diff --git a/.gitignore b/.gitignore index 9c858b5d7..b239de7f4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ target Cargo.lock -pkg \ No newline at end of file +pkg +*.key +*.proof +*.data +.idea/ diff --git a/Cargo.toml b/Cargo.toml index 7563f24a6..17ce15c7a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,30 +15,55 @@ crate-type = ["cdylib", "lib", "staticlib"] [dependencies] rand = "0.4" bit-vec = "0.6" -cfg-if = "0.1" +cfg-if = "1.*" + +#pairing = {package = "pairing_ce", version = "0.24.*" } +pairing = {path = "../pairing", package = "pairing_ce"} -#pairing = {package = "pairing_ce", path = "../pairing" } -pairing = {package = "pairing_ce", version = "0.19" } byteorder = "1" -futures= {package = "futures", version = "0.3", default_features = false, features = ["executor"]} +futures = {package = "futures", version = "0.3", default_features = false, features = ["executor"]} num_cpus = "1" crossbeam = {version = "0.7", optional = true} - prefetch = {version = "0.2", optional = true} web-sys = {version = "0.3", optional = true, features = ["console", "Performance", "Window"]} -tiny-keccak = {version = "1.4.2", optional = true} +tiny-keccak = {version = "1.5", optional = true} blake2-rfc = {version = "0.2.18", optional = true} +blake2s_simd = {version = "0.5"} +lazy_static = {version = "1", optional = true} + +blake2s_const = {version = "0.6", optional = true, path = "./src/plonk/blake2_const/blake2s/"} + +# rescue_hash = {git = "https://github.com/shamatar/rescue_hash.git", optional = true } +# rescue_hash = {path = "../rescue_hash", optional = true } +# poseidon_hash = {path = "../poseidon_hash", optional = true } + +hex = "*" + + +# add GPU +thiserror = "1.0.10" +rand_core = "0.5" +ocl = { version = "0.19.4", package = "fil-ocl", optional = true } +ff-cl-gen = { path = "../ff-cl-gen", optional = true } +fs2 = { version = "0.4.3", optional = true } +log = "0.4.8" +#futures_01 = {package = "futures", version = "0.1"} + + [features] -# default = [] -default = ["multicore"] -#default = ["wasm"] +#default = ["multicore", "plonk"] +default = ["multicore", "plonk", "gpu"] multicore = ["crossbeam", "futures/thread-pool"] sonic = ["tiny-keccak", "blake2-rfc"] gm17 = [] nolog = [] +plonk = ["lazy_static", "tiny-keccak", "blake2s_const"] +# redshift = ["plonk", "rescue_hash", "poseidon_hash"] +marlin = ["tiny-keccak", "blake2s_const"] wasm = ["web-sys"] -nightly = ["prefetch"] +asm = ["pairing/asm"] +gpu = ["ocl", "ff-cl-gen", "fs2"] diff --git a/run_buffered_multiexp.sh b/run_buffered_multiexp.sh new file mode 100755 index 000000000..c07a6313c --- /dev/null +++ b/run_buffered_multiexp.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_large_data_buffered_multiexp diff --git a/run_diff_windows.sh b/run_diff_windows.sh new file mode 100755 index 000000000..9fe22f24b --- /dev/null +++ b/run_diff_windows.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +cargo test --release -- --ignored --nocapture test_large_data_different_windows_multiexp diff --git a/run_diff_windows_nightly.sh b/run_diff_windows_nightly.sh new file mode 100755 index 000000000..28b0584c6 --- /dev/null +++ b/run_diff_windows_nightly.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_large_data_different_windows_multiexp diff --git a/run_diff_windows_nightly_futures.sh b/run_diff_windows_nightly_futures.sh new file mode 100755 index 000000000..5f8889c5b --- /dev/null +++ b/run_diff_windows_nightly_futures.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture future_based_test_large_data_different_windows diff --git a/run_insane_fft.sh b/run_insane_fft.sh new file mode 100755 index 000000000..9a70a6788 --- /dev/null +++ b/run_insane_fft.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_fft_scaling \ No newline at end of file diff --git a/run_insane_lde.sh b/run_insane_lde.sh new file mode 100755 index 000000000..75dff1546 --- /dev/null +++ b/run_insane_lde.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_insane_size_lde \ No newline at end of file diff --git a/run_insane_test.sh b/run_insane_test.sh new file mode 100755 index 000000000..498516b8d --- /dev/null +++ b/run_insane_test.sh @@ -0,0 +1,4 @@ +#!/bin/sh + +# cargo test --release -- --ignored --nocapture test_multiexp_performance_on_large_data +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_large_data_different_multiexps diff --git a/run_insane_test_with_futures.sh b/run_insane_test_with_futures.sh new file mode 100755 index 000000000..facbd3c1e --- /dev/null +++ b/run_insane_test_with_futures.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_future_based_multiexp_performance_on_large_data \ No newline at end of file diff --git a/run_long_division.sh b/run_long_division.sh new file mode 100755 index 000000000..8ef5a320f --- /dev/null +++ b/run_long_division.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +cargo test --release -- --ignored --nocapture test_long_naive_division \ No newline at end of file diff --git a/run_parallel_jobs.sh b/run_parallel_jobs.sh new file mode 100755 index 000000000..cdd1eb8da --- /dev/null +++ b/run_parallel_jobs.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_optimal_bn254_multiexp diff --git a/run_shared_l3.sh b/run_shared_l3.sh new file mode 100755 index 000000000..a5f780114 --- /dev/null +++ b/run_shared_l3.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --ignored --nocapture test_l3_shared_multiexp_bn254 diff --git a/run_test_on_nightly.sh b/run_test_on_nightly.sh new file mode 100755 index 000000000..6f4cab57a --- /dev/null +++ b/run_test_on_nightly.sh @@ -0,0 +1,6 @@ +#!/bin/sh + +# RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release -- --nocapture test_valid_bn254_multiexp +# RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release -- --nocapture test_dense_multiexp_vs_new_multiexp +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --nocapture test_valid_bn254_multiexp +RUSTFLAGS="-C target-cpu=native -C target_feature=+bmi2,+adx,+sse4.1" cargo +nightly test --release --features "asm" -- --nocapture test_dense_multiexp_vs_new_multiexp diff --git a/src/constants.rs b/src/constants.rs new file mode 100644 index 000000000..ddc9e3a6f --- /dev/null +++ b/src/constants.rs @@ -0,0 +1,48 @@ +pub const ETH_BLOCK_10_000_000_HASH: &'static str + = "aa20f7bde5be60603f11a45fc4923aab7552be775403fc00c2e6b805e6297dbe"; + +use crate::pairing::{Engine, CurveProjective}; +use crate::byteorder::{BigEndian, ReadBytesExt}; + +pub fn make_random_points_with_unknown_discrete_log_from_seed( + dst: &[u8], + seed: &[u8], + num_points: usize +) -> Vec { + let mut result = vec![]; + + use rand::{Rng, SeedableRng}; + use rand::chacha::ChaChaRng; + // Create an RNG based on the outcome of the random beacon + let mut rng = { + // if we use Blake hasher + let input: Vec = dst.iter().chain(seed.iter()).cloned().collect(); + let h = blake2s_simd::blake2s(&input); + assert!(h.as_bytes().len() == 32); + let mut seed = [0u32; 8]; + for (i, chunk) in h.as_bytes().chunks_exact(8).enumerate() { + seed[i] = (&chunk[..]).read_u32::().expect("digest is large enough for this to work"); + } + + ChaChaRng::from_seed(&seed) + }; + + for _ in 0..num_points { + let point: E::G1 = rng.gen(); + + result.push(point.into_affine()); + } + + result +} + +pub fn make_random_points_with_unknown_discrete_log( + dst: &[u8], + num_points: usize +) -> Vec { + make_random_points_with_unknown_discrete_log_from_seed::( + dst, + &hex::decode(crate::constants::ETH_BLOCK_10_000_000_HASH).unwrap(), + num_points + ) +} diff --git a/src/cs.rs b/src/cs.rs index 9f68c7e78..ea853bd6d 100644 --- a/src/cs.rs +++ b/src/cs.rs @@ -56,6 +56,12 @@ impl AsRef<[(Variable, E::Fr)]> for LinearCombination { } } +impl AsMut> for LinearCombination { + fn as_mut(&mut self) -> &mut Vec<(Variable, E::Fr)> { + &mut self.0 + } +} + impl LinearCombination { pub fn zero() -> LinearCombination { LinearCombination(vec![]) @@ -178,8 +184,9 @@ impl From for SynthesisError { } } -impl Error for SynthesisError { - fn description(&self) -> &str { + +impl SynthesisError { + pub fn self_description(&self) -> &str { match *self { SynthesisError::AssignmentMissing => "an assignment for a variable could not be computed", SynthesisError::DivisionByZero => "division by zero", @@ -193,13 +200,19 @@ impl Error for SynthesisError { } } +impl Error for SynthesisError { + fn description(&self) -> &str { + self.self_description() + } +} + impl fmt::Display for SynthesisError { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { if let &SynthesisError::IoError(ref e) = self { write!(f, "I/O error: ")?; e.fmt(f) } else { - write!(f, "{}", self.description()) + write!(f, "{}", self.self_description()) } } } diff --git a/src/domain.rs b/src/domain.rs index 7d3d07a76..0d398871f 100644 --- a/src/domain.rs +++ b/src/domain.rs @@ -26,6 +26,10 @@ use super::{ use super::worker::Worker; pub use super::group::*; +use crate::gpu; + +use log::{info, warn}; +use crate::gpu::kernel; pub struct EvaluationDomain> { coeffs: Vec, @@ -156,6 +160,15 @@ impl> EvaluationDomain { best_fft(&mut self.coeffs, worker, &self.omega, self.exp); } + pub fn fft_gpu( + &mut self, + worker: &Worker, + kern: &mut Option>, + ) -> gpu::GPUResult<()> { + best_fft_gpu(kern, &mut self.coeffs, worker, &self.omega, self.exp)?; + Ok(()) + } + pub fn ifft(&mut self, worker: &Worker) { best_fft(&mut self.coeffs, worker, &self.omegainv, self.exp); @@ -173,6 +186,29 @@ impl> EvaluationDomain { }); } + pub fn ifft_gpu( + &mut self, + worker: &Worker, + kern: &mut Option>, + ) -> gpu::GPUResult<()> { + best_fft_gpu(kern, &mut self.coeffs, worker, &self.omegainv, self.exp)?; + + worker.scope(self.coeffs.len(), |scope, chunk| { + let minv = self.minv; + + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v { + v.group_mul_assign(&minv); + } + }); + } + }); + + Ok(()) + } + + pub fn distribute_powers(&mut self, worker: &Worker, g: E::Fr) { worker.scope(self.coeffs.len(), |scope, chunk| { @@ -202,6 +238,28 @@ impl> EvaluationDomain { self.distribute_powers(worker, geninv); } + pub fn transform_powers_of_tau_into_lagrange_basis(&mut self, worker: &Worker) { + self.ifft(&worker); + } + + pub fn transform_powers_of_tau_into_lagrange_basis_on_coset(&mut self, worker: &Worker) + { + let geninv = self.geninv; + self.distribute_powers(worker, geninv); + + // worker.scope(self.coeffs.len(), |scope, chunk| { + // for v in self.coeffs.chunks_mut(chunk) { + // scope.spawn(move |_| { + // for v in v.iter_mut() { + // v.group_mul_assign(&geninv); + // } + // }); + // } + // }); + + self.ifft(worker); + } + /// This evaluates t(tau) for this domain, which is /// tau^m - 1 for these radix-2 domains. pub fn z(&self, tau: &E::Fr) -> E::Fr { @@ -260,6 +318,7 @@ impl> EvaluationDomain { } } + pub(crate) fn best_fft>(a: &mut [T], worker: &Worker, omega: &E::Fr, log_n: u32) { let log_cpus = worker.log_num_cpus(); @@ -271,6 +330,9 @@ pub(crate) fn best_fft>(a: &mut [T], worker: &Worker, ome } } + + + pub(crate) fn serial_fft>(a: &mut [T], omega: &E::Fr, log_n: u32) { fn bitreverse(mut n: u32, l: u32) -> u32 { @@ -375,6 +437,69 @@ pub(crate) fn parallel_fft>( }); } +pub fn create_fft_kernel(log_d: usize, priority: bool) -> Option> + where + E: Engine, +{ + match gpu::FFTKernel::create(1 << log_d, priority) { + Ok(k) => { + info!("GPU FFT kernel instantiated!"); + Some(k) + } + Err(e) => { + warn!("Cannot instantiate GPU FFT kernel! Error: {}", e); + None + } + } + +} + +pub fn best_fft_gpu>( + kern: &mut Option>, + a: &mut [T], + worker: &Worker, + omega: &E::Fr, + log_n: u32, +) -> gpu::GPUResult<()> { + if let Some(ref mut kern) = kern { + if kern + .with(|k: &mut gpu::FFTKernel| gpu_fft(k, a, omega, log_n)) + .is_ok() + { + return Ok(()); + } + } + + let log_cpus = worker.log_num_cpus(); + if log_n <= log_cpus { + serial_fft(a, omega, log_n); + } else { + parallel_fft(a, worker, omega, log_n, log_cpus); + } + + Ok(()) +} + +pub fn gpu_fft>( + kern: &mut gpu::FFTKernel, + a: &mut [T], + omega: &E::Fr, + log_n: u32, +) -> gpu::GPUResult<()> { + // EvaluationDomain module is supposed to work only with E::Fr elements, and not CurveProjective + // points. The Bellman authors have implemented an unnecessarry abstraction called Group + // which is implemented for both PrimeField and CurveProjective elements. As nowhere in the code + // is the CurveProjective version used, T and E::Fr are guaranteed to be equal and thus have same + // size. + // For compatibility/performance reasons we decided to transmute the array to the desired type + // as it seems safe and needs less modifications in the current structure of Bellman library. + let b = unsafe { std::mem::transmute::<&mut [T], &mut [E::Fr]>(a) }; + kern.radix_fft(b, omega, log_n)?; + Ok(()) +} + + + // Test multiplying various (low degree) polynomials together and // comparing with naive evaluations. #[test] @@ -531,11 +656,13 @@ fn test_fft_bn256() { use crate::pairing::bn256::Fr; use num_cpus; + let cpus = num_cpus::get(); - const SAMPLES: usize = 1 << 27; + const SAMPLES: usize = 1 << 20; let rng = &mut rand::thread_rng(); let v1 = (0..SAMPLES).map(|_| Scalar::(Fr::rand(rng))).collect::>(); + let v2 = v1.clone(); let mut v1 = EvaluationDomain::from_coeffs(v1).unwrap(); @@ -545,8 +672,111 @@ fn test_fft_bn256() { v1.ifft(&pool); - let duration_ns = start.elapsed().as_nanos() as f64; - println!("Elapsed {} ns for {} samples", duration_ns, SAMPLES); - let time_per_sample = duration_ns/(SAMPLES as f64); - println!("Tested on {} samples on {} CPUs with {} ns per field element multiplication", SAMPLES, cpus, time_per_sample); + let duration_cpu = start.elapsed().as_nanos() as f64; + println!("CPU Elapsed {} ns for {} samples", duration_cpu, SAMPLES); + + let mut fft_kern = Some(gpu::LockedFFTKernel::::new(20, false)); + let mut v2 = EvaluationDomain::from_coeffs(v2).unwrap(); + + let start = std::time::Instant::now(); + v2.ifft_gpu(&pool, &mut fft_kern).unwrap(); + let duration_gpu = start.elapsed().as_nanos() as f64; + + assert!(v1.coeffs == v2.coeffs); + println!("GPU Elapsed {} ns for {} samples", duration_gpu, SAMPLES); + + println!("Tested on {} samples cpu/gpu {}" , SAMPLES, duration_cpu/duration_gpu ); +} + +#[test] +pub fn gpu_fft_consistency_bls128() { + use pairing::bls12_381::{Bls12, Fr}; + use std::time::Instant; + use pairing::ff::ScalarEngine; + use rand::{self, Rand}; + + let rng = &mut rand::thread_rng(); + + let worker = Worker::new(); + let log_cpus = worker.log_num_cpus(); + let mut kern = gpu::FFTKernel::create(1 << 24, false).expect("Cannot initialize kernel!"); + + for log_d in 1..10 { + let d = 1 << log_d; + + let elems = (0..d) + .map(|_| Scalar::(Fr::rand(rng))) + .collect::>(); + + let mut v1 = EvaluationDomain::from_coeffs(elems.clone()).unwrap(); + let mut v2 = EvaluationDomain::from_coeffs(elems.clone()).unwrap(); + + println!("Testing FFT for {} elements...", d); + + let mut now = Instant::now(); + gpu_fft(&mut kern, &mut v1.coeffs, &v1.omega, log_d).expect("GPU FFT failed!"); + let gpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("GPU took {}ms.", gpu_dur); + + now = Instant::now(); + // if log_d <= log_cpus { + // serial_fft(&mut v2.coeffs, &v2.omega, log_d); + // } else { + // parallel_fft(&mut v2.coeffs, &worker, &v2.omega, log_d, log_cpus); + // } + best_fft( &mut v2.coeffs, &worker, &v2.omega, log_d); + + let cpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("CPU ({} cores) took {}ms.", 1 << log_cpus, cpu_dur); + + println!("Speedup: x{}", cpu_dur as f32 / gpu_dur as f32); + + assert!(v1.coeffs == v2.coeffs); + println!("============================"); + } +} + +#[test] +pub fn gpu_fft_consistency_bn256() { + use pairing::bn256::{Bn256, Fr}; + use std::time::Instant; + use pairing::ff::ScalarEngine; + use rand::{self, Rand}; + + let rng = &mut rand::thread_rng(); + + let worker = Worker::new(); + let log_cpus = worker.log_num_cpus(); + let mut kern = gpu::FFTKernel::create(1 << 24, false).expect("Cannot initialize kernel!"); + + for log_d in 3..10 { + let d = 1 << log_d; + + let elems = (0..d) + .map(|_| Scalar::(Fr::rand(rng))) + .collect::>(); + + let mut v1 = EvaluationDomain::from_coeffs(elems.clone()).unwrap(); + let mut v2 = EvaluationDomain::from_coeffs(elems.clone()).unwrap(); + + println!("Testing FFT for {} elements...", d); + + let mut now = Instant::now(); + gpu_fft(&mut kern, &mut v1.coeffs, &v1.omega, log_d).expect("GPU FFT failed!"); + let gpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("GPU took {}ms.", gpu_dur); + + now = Instant::now(); + + best_fft( &mut v2.coeffs, &worker, &v2.omega, log_d); + + let cpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("CPU ({} cores) took {}ms.", 1 << log_cpus, cpu_dur); + + println!("Speedup: x{}", cpu_dur as f32 / gpu_dur as f32); + + assert!(v1.coeffs == v2.coeffs); + println!("============================"); + } + drop(kern); } \ No newline at end of file diff --git a/src/gpu/error.rs b/src/gpu/error.rs new file mode 100644 index 000000000..4ae867898 --- /dev/null +++ b/src/gpu/error.rs @@ -0,0 +1,33 @@ +#[derive(thiserror::Error, Debug)] +pub enum GPUError { + #[error("GPUError: {0}")] + Simple(&'static str), + #[cfg(feature = "gpu")] + #[error("Ocl Error: {0}")] + Ocl(ocl::Error), + #[cfg(feature = "gpu")] + #[error("GPU taken by a high priority process!")] + GPUTaken, + #[cfg(feature = "gpu")] + #[error("No kernel is initialized!")] + KernelUninitialized, +} + +pub type GPUResult = std::result::Result; + +#[cfg(feature = "gpu")] +impl From for GPUError { + fn from(error: ocl::Error) -> Self { + GPUError::Ocl(error) + } +} + +#[cfg(feature = "gpu")] +impl From> for GPUError { + fn from(e: std::boxed::Box) -> Self { + match e.downcast::() { + Ok(err) => *err, + Err(_) => GPUError::Simple("An unknown GPU error happened!"), + } + } +} diff --git a/src/gpu/fft.rs b/src/gpu/fft.rs new file mode 100644 index 000000000..0defe2b57 --- /dev/null +++ b/src/gpu/fft.rs @@ -0,0 +1,194 @@ +use crate::gpu::{ + error::{GPUError, GPUResult}, + locks, sources, structs, GPU_NVIDIA_DEVICES, +}; +// use ff::Field; +use pairing::ff::Field; +use log::info; +use ocl::{Buffer, MemFlags, ProQue}; +// use paired::Engine; +use pairing::Engine; +use std::cmp; + +// NOTE: Please read `structs.rs` for an explanation for unsafe transmutes of this code! + +const LOG2_MAX_ELEMENTS: usize = 32; // At most 2^32 elements is supported. +const MAX_RADIX_DEGREE: u32 = 8; // Radix256 +const MAX_LOCAL_WORK_SIZE_DEGREE: u32 = 7; // 128 + +pub struct FFTKernel +where + E: Engine, +{ + proque: ProQue, + fft_src_buffer: Buffer>, + fft_dst_buffer: Buffer>, + fft_pq_buffer: Buffer>, + fft_omg_buffer: Buffer>, + _lock: locks::GPULock, // RFC 1857: struct fields are dropped in the same order as they are declared. + priority: bool, +} + +impl FFTKernel +where + E: Engine, +{ + pub fn create(n: u32, priority: bool) -> GPUResult> { + let lock = locks::GPULock::lock(); + + let src = sources::kernel::(true); + let devices = &GPU_NVIDIA_DEVICES; + if devices.is_empty() { + return Err(GPUError::Simple("No working GPUs found!")); + } + let device = devices[0]; // Select the first device for FFT + let pq = ProQue::builder().device(device).src(src).dims(n).build()?; + + let srcbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(n) + .build()?; + let dstbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(n) + .build()?; + let pqbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(1 << MAX_RADIX_DEGREE >> 1) + .build()?; + let omgbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(LOG2_MAX_ELEMENTS) + .build()?; + + info!("FFT: 1 working device(s) selected."); + info!("FFT: Device 0: {}", pq.device().name()?); + + Ok(FFTKernel { + proque: pq, + fft_src_buffer: srcbuff, + fft_dst_buffer: dstbuff, + fft_pq_buffer: pqbuff, + fft_omg_buffer: omgbuff, + _lock: lock, + priority, + }) + } + + /// Peforms a FFT round + /// * `lgn` - Specifies log2 of number of elements + /// * `lgp` - Specifies log2 of `p`, (http://www.bealto.com/gpu-fft_group-1.html) + /// * `deg` - 1=>radix2, 2=>radix4, 3=>radix8, ... + /// * `max_deg` - The precalculated values pq` and `omegas` are valid for radix degrees up to `max_deg` + fn radix_fft_round( + &mut self, + lgn: u32, + lgp: u32, + deg: u32, + max_deg: u32, + in_src: bool, + ) -> GPUResult<()> { + if locks::PriorityLock::should_break(self.priority) { + return Err(GPUError::GPUTaken); + } + + let n = 1u32 << lgn; + let lwsd = cmp::min(deg - 1, MAX_LOCAL_WORK_SIZE_DEGREE); + let kernel = self + .proque + .kernel_builder("radix_fft") + .global_work_size([n >> deg << lwsd]) + .local_work_size(1 << lwsd) + .arg(if in_src { + &self.fft_src_buffer + } else { + &self.fft_dst_buffer + }) + .arg(if in_src { + &self.fft_dst_buffer + } else { + &self.fft_src_buffer + }) + .arg(&self.fft_pq_buffer) + .arg(&self.fft_omg_buffer) + .arg_local::>(1 << deg) + .arg(n) + .arg(lgp) + .arg(deg) + .arg(max_deg) + .build()?; + unsafe { + kernel.enq()?; + } // Running a GPU kernel is unsafe! + Ok(()) + } + + /// Share some precalculated values between threads to boost the performance + fn setup_pq(&mut self, omega: &E::Fr, n: usize, max_deg: u32) -> ocl::Result<()> { + // Precalculate: + // [omega^(0/(2^(deg-1))), omega^(1/(2^(deg-1))), ..., omega^((2^(deg-1)-1)/(2^(deg-1)))] + let mut tpq = vec![structs::PrimeFieldStruct::::default(); 1 << max_deg >> 1]; + let pq = unsafe { + std::mem::transmute::<&mut [structs::PrimeFieldStruct], &mut [E::Fr]>(&mut tpq) + }; + let tw = omega.pow([(n >> max_deg) as u64]); + pq[0] = E::Fr::one(); + if max_deg > 1 { + pq[1] = tw; + for i in 2..(1 << max_deg >> 1) { + pq[i] = pq[i - 1]; + pq[i].mul_assign(&tw); + } + } + self.fft_pq_buffer.write(&tpq).enq()?; + + // Precalculate [omega, omega^2, omega^4, omega^8, ..., omega^(2^31)] + let mut tom = vec![structs::PrimeFieldStruct::::default(); 32]; + let om = unsafe { + std::mem::transmute::<&mut [structs::PrimeFieldStruct], &mut [E::Fr]>(&mut tom) + }; + om[0] = *omega; + for i in 1..LOG2_MAX_ELEMENTS { + om[i] = om[i - 1].pow([2u64]); + } + self.fft_omg_buffer.write(&tom).enq()?; + + Ok(()) + } + + /// Performs FFT on `a` + /// * `omega` - Special value `omega` is used for FFT over finite-fields + /// * `lgn` - Specifies log2 of number of elements + pub fn radix_fft(&mut self, a: &mut [E::Fr], omega: &E::Fr, lgn: u32) -> GPUResult<()> { + let n = 1 << lgn; + + let ta = unsafe { + std::mem::transmute::<&mut [E::Fr], &mut [structs::PrimeFieldStruct]>(a) + }; + + let max_deg = cmp::min(MAX_RADIX_DEGREE, lgn); + self.setup_pq(omega, n, max_deg)?; + + self.fft_src_buffer.write(&*ta).enq()?; + let mut in_src = true; + let mut lgp = 0u32; + while lgp < lgn { + let deg = cmp::min(max_deg, lgn - lgp); + self.radix_fft_round(lgn, lgp, deg, max_deg, in_src)?; + lgp += deg; + in_src = !in_src; // Destination of this FFT round is source of the next round. + } + if in_src { + self.fft_src_buffer.read(ta).enq()?; + } else { + self.fft_dst_buffer.read(ta).enq()?; + } + self.proque.finish()?; // Wait for all commands in the queue (Including read command) + + Ok(()) + } +} diff --git a/src/gpu/fft/fft.cl b/src/gpu/fft/fft.cl new file mode 100644 index 000000000..8ee00eb71 --- /dev/null +++ b/src/gpu/fft/fft.cl @@ -0,0 +1,76 @@ +uint bitreverse(uint n, uint bits) { + uint r = 0; + for(int i = 0; i < bits; i++) { + r = (r << 1) | (n & 1); + n >>= 1; + } + return r; +} + +/* + * FFT algorithm is inspired from: http://www.bealto.com/gpu-fft_group-1.html + */ +__kernel void radix_fft(__global FIELD* x, // Source buffer + __global FIELD* y, // Destination buffer + __global FIELD* pq, // Precalculated twiddle factors + __global FIELD* omegas, // [omega, omega^2, omega^4, ...] + __local FIELD* u, // Local buffer to store intermediary values + uint n, // Number of elements + uint lgp, // Log2 of `p` (Read more in the link above) + uint deg, // 1=>radix2, 2=>radix4, 3=>radix8, ... + uint max_deg) // Maximum degree supported, according to `pq` and `omegas` +{ + uint lid = get_local_id(0); + uint lsize = get_local_size(0); + uint index = get_group_id(0); + uint t = n >> deg; + uint p = 1 << lgp; + uint k = index & (p - 1); + + x += index; + y += ((index - k) << deg) + k; + + uint count = 1 << deg; // 2^deg + uint counth = count >> 1; // Half of count + + uint counts = count / lsize * lid; + uint counte = counts + count / lsize; + + // Compute powers of twiddle + FIELD twiddle = FIELD_pow_lookup(omegas, (n >> lgp >> deg) * k); + FIELD tmp = FIELD_pow(twiddle, counts); + for(uint i = counts; i < counte; i++) { + u[i] = FIELD_mul(tmp, x[i*t]); + tmp = FIELD_mul(tmp, twiddle); + } + barrier(CLK_LOCAL_MEM_FENCE); + + uint pqshift = max_deg - deg; + for(uint rnd = 0; rnd < deg; rnd++) { + uint bit = counth >> rnd; + for(uint i = counts >> 1; i < counte >> 1; i++) { + uint di = i & (bit - 1); + uint i0 = (i << 1) - di; + uint i1 = i0 + bit; + tmp = u[i0]; + u[i0] = FIELD_add(u[i0], u[i1]); + u[i1] = FIELD_sub(tmp, u[i1]); + if(di != 0) u[i1] = FIELD_mul(pq[di << rnd << pqshift], u[i1]); + } + + barrier(CLK_LOCAL_MEM_FENCE); + } + + for(uint i = counts >> 1; i < counte >> 1; i++) { + y[i*p] = u[bitreverse(i, deg)]; + y[(i+counth)*p] = u[bitreverse(i + counth, deg)]; + } +} + +/// Multiplies all of the elements by `field` +__kernel void mul_by_field(__global FIELD* elements, + uint n, + FIELD field) { + uint gid = get_global_id(0); + elements[gid] = FIELD_mul(elements[gid], field); +} \ No newline at end of file diff --git a/src/gpu/locks.rs b/src/gpu/locks.rs new file mode 100644 index 000000000..d34025ee8 --- /dev/null +++ b/src/gpu/locks.rs @@ -0,0 +1,149 @@ +use fs2::FileExt; +use log::{debug, info, warn}; +use std::fs::File; +use std::path::PathBuf; + +const GPU_LOCK_NAME: &str = "bellman.gpu.lock"; +const PRIORITY_LOCK_NAME: &str = "bellman.priority.lock"; +fn tmp_path(filename: &str) -> PathBuf { + let mut p = std::env::temp_dir(); + p.push(filename); + p +} + +/// `GPULock` prevents two kernel objects to be instantiated simultaneously. +#[derive(Debug)] +pub struct GPULock(File); +impl GPULock { + pub fn lock() -> GPULock { + debug!("Acquiring GPU lock..."); + let f = File::create(tmp_path(GPU_LOCK_NAME)).unwrap(); + f.lock_exclusive().unwrap(); + debug!("GPU lock acquired!"); + GPULock(f) + } +} +impl Drop for GPULock { + fn drop(&mut self) { + debug!("GPU lock released!"); + } +} + +/// `PrioriyLock` is like a flag. When acquired, it means a high-priority process +/// needs to acquire the GPU really soon. Acquiring the `PriorityLock` is like +/// signaling all other processes to release their `GPULock`s. +/// Only one process can have the `PriorityLock` at a time. +#[derive(Debug)] +pub struct PriorityLock(File); +impl PriorityLock { + pub fn lock() -> PriorityLock { + debug!("Acquiring priority lock..."); + let f = File::create(tmp_path(PRIORITY_LOCK_NAME)).unwrap(); + f.lock_exclusive().unwrap(); + debug!("Priority lock acquired!"); + PriorityLock(f) + } + pub fn wait(priority: bool) { + if !priority { + File::create(tmp_path(PRIORITY_LOCK_NAME)) + .unwrap() + .lock_exclusive() + .unwrap(); + } + } + pub fn should_break(priority: bool) -> bool { + !priority + && File::create(tmp_path(PRIORITY_LOCK_NAME)) + .unwrap() + .try_lock_exclusive() + .is_err() + } +} +impl Drop for PriorityLock { + fn drop(&mut self) { + debug!("Priority lock released!"); + } +} + +use super::error::{GPUError, GPUResult}; +use super::fft::FFTKernel; +use super::multiexp::MultiexpKernel; +use crate::domain::create_fft_kernel; +use crate::multiexp::create_multiexp_kernel; +use pairing::Engine; + +macro_rules! locked_kernel { + ($class:ident, $kern:ident, $func:ident, $name:expr) => { + pub struct $class + where + E: Engine, + { + log_d: usize, + priority: bool, + kernel: Option<$kern>, + } + + impl $class + where + E: Engine, + { + pub fn new(log_d: usize, priority: bool) -> $class { + $class:: { + log_d, + priority, + kernel: None, + } + } + + fn init(&mut self) { + if self.kernel.is_none() { + PriorityLock::wait(self.priority); + info!("GPU is available for {}!", $name); + self.kernel = $func::(self.log_d, self.priority); + } + } + + fn free(&mut self) { + if let Some(_kernel) = self.kernel.take() { + warn!( + "GPU acquired by a high priority process! Freeing up {} kernels...", + $name + ); + } + } + + pub fn with(&mut self, mut f: F) -> GPUResult + where + F: FnMut(&mut $kern) -> GPUResult, + { + self.init(); + + loop { + if let Some(ref mut k) = self.kernel { //false + match f(k) { + Err(GPUError::GPUTaken) => { + self.free(); + self.init(); + } + Err(e) => { + warn!("GPU {} failed! Falling back to CPU... Error: {}", $name, e); + return Err(e); + } + Ok(v) => return Ok(v), + } + } else { + return Err(GPUError::KernelUninitialized); + } + } + } + } + }; +} + +locked_kernel!(LockedFFTKernel, FFTKernel, create_fft_kernel, "FFT"); +locked_kernel!( + LockedMultiexpKernel, + MultiexpKernel, + create_multiexp_kernel, + "Multiexp" +); diff --git a/src/gpu/mod.rs b/src/gpu/mod.rs new file mode 100644 index 000000000..9fac8620f --- /dev/null +++ b/src/gpu/mod.rs @@ -0,0 +1,44 @@ +mod error; +pub use self::error::*; + +#[cfg(feature = "gpu")] +mod locks; +#[cfg(feature = "gpu")] +pub use self::locks::*; + +#[cfg(feature = "gpu")] +mod sources; +#[cfg(feature = "gpu")] +pub use self::sources::*; + +#[cfg(feature = "gpu")] +mod utils; +#[cfg(feature = "gpu")] +pub use self::utils::*; + +#[cfg(feature = "gpu")] +mod structs; +#[cfg(feature = "gpu")] +pub use self::structs::*; + +#[cfg(feature = "gpu")] +mod fft; +#[cfg(feature = "gpu")] +pub use self::fft::*; + +#[cfg(feature = "gpu")] +mod multiexp; +#[cfg(feature = "gpu")] +pub use self::multiexp::*; + +#[cfg(not(feature = "gpu"))] +mod nogpu; +#[cfg(not(feature = "gpu"))] +pub use self::nogpu::*; + +#[cfg(feature = "gpu")] +use ocl::Device; +#[cfg(feature = "gpu")] +lazy_static::lazy_static! { + pub static ref GPU_NVIDIA_DEVICES: Vec = get_devices(GPU_NVIDIA_PLATFORM_NAME).unwrap_or_default(); +} diff --git a/src/gpu/multiexp.rs b/src/gpu/multiexp.rs new file mode 100644 index 000000000..301c57603 --- /dev/null +++ b/src/gpu/multiexp.rs @@ -0,0 +1,445 @@ +use super::error::{GPUError, GPUResult}; +use super::locks; +use super::sources; +use super::structs; +use super::utils; +use super::GPU_NVIDIA_DEVICES; +use crate::multicore::Worker; + +// use crate::multiexp::{multiexp as cpu_multiexp, FullDensity}; +use crate::source::FullDensity; +use crate::multiexp::multiexp as cpu_multiexp; + + +use crossbeam::thread; + +// use ff::{PrimeField, ScalarEngine}; +use pairing::ff::{PrimeField, ScalarEngine}; + +use futures::Future; + +// use groupy::{CurveAffine, CurveProjective}; +use pairing::{CurveAffine, CurveProjective}; + +use log::{error, info}; +use ocl::{Buffer, Device, MemFlags, ProQue}; + +// use paired::Engine; +use pairing::Engine; + +use std::sync::Arc; +use crate::Index::Input; +use std::time::Instant; + +// NOTE: Please read `structs.rs` for an explanation for unsafe transmutes of this code! + +const MAX_WINDOW_SIZE: usize = 10; +const LOCAL_WORK_SIZE: usize = 256; +const MEMORY_PADDING: f64 = 0.2f64; // Let 20% of GPU memory be free + +pub fn get_cpu_utilization() -> f64 { + use std::env; + env::var("BELLMAN_CPU_UTILIZATION") + .and_then(|v| match v.parse() { + Ok(val) => Ok(val), + Err(_) => { + error!("Invalid BELLMAN_CPU_UTILIZATION! Defaulting to 0..."); + Ok(0f64) + } + }) + .unwrap_or(0f64) + .max(0f64) + .min(1f64) +} + +// Multiexp kernel for a single GPU +pub struct SingleMultiexpKernel +where + E: Engine, +{ + proque: ProQue, + + g1_base_buffer: Buffer>, + g1_bucket_buffer: Buffer>, + g1_result_buffer: Buffer>, + + g2_base_buffer: Buffer>, + g2_bucket_buffer: Buffer>, + g2_result_buffer: Buffer>, + + exp_buffer: Buffer>, + + core_count: usize, + n: usize, + + priority: bool, +} + +fn calc_num_groups(core_count: usize, num_windows: usize) -> usize { + // Observations show that we get the best performance when num_groups * num_windows ~= 2 * CUDA_CORES + return 2 * core_count / num_windows; +} + +fn calc_window_size(n: usize, exp_bits: usize, core_count: usize) -> usize { + // window_size = ln(n / num_groups) + // num_windows = exp_bits / window_size + // num_groups = 2 * core_count / num_windows = 2 * core_count * window_size / exp_bits + // window_size = ln(n / num_groups) = ln(n * exp_bits / (2 * core_count * window_size)) + // window_size = ln(exp_bits * n / (2 * core_count)) - ln(window_size) + // + // Thus we need to solve the following equation: + // window_size + ln(window_size) = ln(exp_bits * n / (2 * core_count)) + let lower_bound = (((exp_bits * n) as f64) / ((2 * core_count) as f64)).ln(); + for w in 0..MAX_WINDOW_SIZE { + if (w as f64) + (w as f64).ln() > lower_bound { + return w; + } + } + return MAX_WINDOW_SIZE; +} + +fn calc_best_chunk_size(max_window_size: usize, core_count: usize, exp_bits: usize) -> usize { + // Best chunk-size (N) can also be calculated using the same logic as calc_window_size: + // n = e^window_size * window_size * 2 * core_count / exp_bits + (((max_window_size as f64).exp() as f64) + * (max_window_size as f64) + * 2f64 + * (core_count as f64) + / (exp_bits as f64)) + .ceil() as usize +} + +fn calc_chunk_size(mem: u64, core_count: usize) -> usize +where + E: Engine, +{ + let aff_size = std::mem::size_of::() + std::mem::size_of::(); + let exp_size = std::mem::size_of::(); + let proj_size = std::mem::size_of::() + std::mem::size_of::(); + ((((mem as f64) * (1f64 - MEMORY_PADDING)) as usize) + - (2 * core_count * ((1 << MAX_WINDOW_SIZE) + 1) * proj_size)) + / (aff_size + exp_size) +} + +impl SingleMultiexpKernel +where + E: Engine, +{ + pub fn create(d: Device, priority: bool) -> GPUResult> { + info!("Begin Compile source file"); + let now = Instant::now(); + let src = sources::kernel::(true); + let pq = ProQue::builder().device(d).src(src).dims(1).build()?; + println!("End Compile source file, spend{} ms", now.elapsed().as_millis()); + drop(now); + let exp_bits = std::mem::size_of::() * 8; + let core_count = utils::get_core_count(d)?; + let mem = utils::get_memory(d)?; + let max_n = calc_chunk_size::(mem, core_count); + let best_n = calc_best_chunk_size(MAX_WINDOW_SIZE, core_count, exp_bits); + let n = std::cmp::min(max_n, best_n); + let max_bucket_len = 1 << MAX_WINDOW_SIZE; + + // Each group will have `num_windows` threads and as there are `num_groups` groups, there will + // be `num_groups` * `num_windows` threads in total. + // Each thread will use `num_groups` * `num_windows` * `bucket_len` buckets. + + let g1basebuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(n) + .build()?; + let g1buckbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(2 * core_count * max_bucket_len) + .build()?; + let g1resbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(2 * core_count) + .build()?; + + let g2basebuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(n) + .build()?; + let g2buckbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(2 * core_count * max_bucket_len) + .build()?; + let g2resbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(2 * core_count) + .build()?; + + let expbuff = Buffer::builder() + .queue(pq.queue().clone()) + .flags(MemFlags::new().read_write()) + .len(n) + .build()?; + + Ok(SingleMultiexpKernel { + proque: pq, + g1_base_buffer: g1basebuff, + g1_bucket_buffer: g1buckbuff, + g1_result_buffer: g1resbuff, + g2_base_buffer: g2basebuff, + g2_bucket_buffer: g2buckbuff, + g2_result_buffer: g2resbuff, + exp_buffer: expbuff, + core_count: core_count, + n, + priority, + }) + } + + pub fn multiexp( + &mut self, + bases: &[G], + exps: &[<::Fr as PrimeField>::Repr], + n: usize, + ) -> GPUResult<::Projective> + where + G: CurveAffine, + { + if locks::PriorityLock::should_break(self.priority) { + return Err(GPUError::GPUTaken); + } + + let exp_bits = std::mem::size_of::() * 8; + let window_size = calc_window_size(n as usize, exp_bits, self.core_count); + let num_windows = ((exp_bits as f64) / (window_size as f64)).ceil() as usize; + let num_groups = calc_num_groups(self.core_count, num_windows); + + let mut res = vec![::Projective::zero(); num_groups * num_windows]; + // info!("MP: start let texps = unsafe"); + let texps = unsafe { + std::mem::transmute::< + &[<::Fr as PrimeField>::Repr], + &[structs::PrimeFieldStruct], + >(exps) + }; + self.exp_buffer.write(texps).enq()?; + // info!("MP: end let texps = unsafe"); + + // Make global work size divisible by `LOCAL_WORK_SIZE` + let mut gws = num_windows * num_groups; + gws += (LOCAL_WORK_SIZE - (gws % LOCAL_WORK_SIZE)) % LOCAL_WORK_SIZE; + + let sz = std::mem::size_of::(); // Trick, used for dispatching between G1 and G2! + if sz == std::mem::size_of::() { + // info!("MP: start g1 let tbases = unsafe"); + let tbases = unsafe { + &*(bases as *const [G] + as *const [structs::CurveAffineStruct<::G1Affine>]) + }; + self.g1_base_buffer.write(tbases).enq()?; + // info!("MP: end g1 let tbases = unsafe"); + // info!("MP: start g1 let kernel = self"); + let kernel = self + .proque + .kernel_builder("G1_bellman_multiexp") + .global_work_size([gws]) + .arg(&self.g1_base_buffer) + .arg(&self.g1_bucket_buffer) + .arg(&self.g1_result_buffer) + .arg(&self.exp_buffer) + .arg(n as u32) + .arg(num_groups as u32) + .arg(num_windows as u32) + .arg(window_size as u32) + .build()?; + unsafe { + kernel.enq()?; + } + // info!("MP: end g1 let kernel = self"); + // info!("MP: start g1 let tres = unsafe"); + let tres = unsafe { + &mut *(&mut res as *mut Vec<::Projective> + as *mut Vec::G1>>) + }; + // info!("MP: end g1 let tres = unsafe"); + // info!("MP : start g1 self.g1_result_buffer.read"); + self.g1_result_buffer.read(tres).enq()?; + // info!("MP : end g1 self.g1_result_buffer.read"); + } else if sz == std::mem::size_of::() { + // info!("MP: start g2 let tbases = unsafe"); + let tbases = unsafe { + &*(bases as *const [G] + as *const [structs::CurveAffineStruct<::G2Affine>]) + }; + self.g2_base_buffer.write(tbases).enq()?; + // info!("MP: end g2 let tbases = unsafe"); + + // info!("MP: start g2 let kernel = self"); + let kernel = self // GPU running & no CPU + .proque + .kernel_builder("G2_bellman_multiexp") + .global_work_size([gws]) + .arg(&self.g2_base_buffer) + .arg(&self.g2_bucket_buffer) + .arg(&self.g2_result_buffer) + .arg(&self.exp_buffer) + .arg(n as u32) + .arg(num_groups as u32) + .arg(num_windows as u32) + .arg(window_size as u32) + .build()?; + unsafe { + kernel.enq()?; + } + // info!("MP: end g2 let kernel = self"); + // info!("MP: start g2 let tres = unsafe"); + let tres = unsafe { + &mut *(&mut res as *mut Vec<::Projective> + as *mut Vec::G2>>) + }; + // info!("MP: end g2 let tres = unsafe"); + // info!("MP : start g2 self.g2_result_buffer.read"); + self.g2_result_buffer.read(tres).enq()?; + // info!("MP : end g2 self.g2_result_buffer.read"); + } else { + return Err(GPUError::Simple("Only E::G1 and E::G2 are supported!")); + } + + // singe CPU: my test [1s 66%CPU] -> multi CPUS + // info!("*************begin accumulating the result************"); + // Using the algorithm below, we can calculate the final result by accumulating the results + // of those `NUM_GROUPS` * `NUM_WINDOWS` threads. + let mut acc = ::Projective::zero(); + let mut bits = 0; + for i in 0..num_windows { + let w = std::cmp::min(window_size, exp_bits - bits); + for _ in 0..w { + acc.double(); + } + for g in 0..num_groups { + acc.add_assign(&res[g * num_windows + i]); + } + bits += w; // Process the next window + } + // info!("*************end accumulating the result************"); + + Ok(acc) + } +} + +// A struct that containts several multiexp kernels for different devices +pub struct MultiexpKernel +where + E: Engine, +{ + kernels: Vec>, + _lock: locks::GPULock, // RFC 1857: struct fields are dropped in the same order as they are declared. +} + +impl MultiexpKernel +where + E: Engine, +{ + pub fn create(priority: bool) -> GPUResult> { + let lock = locks::GPULock::lock(); + + let kernels: Vec<_> = GPU_NVIDIA_DEVICES + .iter() + .map(|d| SingleMultiexpKernel::::create(*d, priority)) + .filter(|res| res.is_ok()) + .map(|res| res.unwrap()) + .collect(); + if kernels.is_empty() { + return Err(GPUError::Simple("No working GPUs found!")); + } + info!( + "Multiexp: {} working device(s) selected. (CPU utilization: {})", + kernels.len(), + get_cpu_utilization() + ); + for (i, k) in kernels.iter().enumerate() { + info!( + "Multiexp: Device {}: {} (Chunk-size: {})", + i, + k.proque.device().name()?, + k.n + ); + } + return Ok(MultiexpKernel:: { + kernels, + _lock: lock, + }); + } + + pub fn multiexp( + &mut self, + pool: &Worker, + bases: Arc>, + exps: Arc::Fr as PrimeField>::Repr>>, + skip: usize, + n: usize, + ) -> GPUResult<::Projective> + where + G: CurveAffine, + ::Engine: pairing::Engine, + { + let num_devices = self.kernels.len(); + // Bases are skipped by `self.1` elements, when converted from (Arc>, usize) to Source + // https://github.com/zkcrypto/bellman/blob/10c5010fd9c2ca69442dc9775ea271e286e776d8/src/multiexp.rs#L38 + let bases = &bases[skip..(skip + n)]; + let exps = &exps[..n]; + + let cpu_n = ((n as f64) * get_cpu_utilization()) as usize; + let n = n - cpu_n; + let (cpu_bases, bases) = bases.split_at(cpu_n); + let (cpu_exps, exps) = exps.split_at(cpu_n); + + let chunk_size = ((n as f64) / (num_devices as f64)).ceil() as usize; + + match thread::scope(|s| -> Result<::Projective, GPUError> { + let mut acc = ::Projective::zero(); + let mut threads = Vec::new(); + if n > 0 { + for ((bases, exps), kern) in bases + .chunks(chunk_size) + .zip(exps.chunks(chunk_size)) + .zip(self.kernels.iter_mut()) + { + threads.push(s.spawn( + move |_| -> Result<::Projective, GPUError> { + let mut acc = ::Projective::zero(); + for (bases, exps) in bases.chunks(kern.n).zip(exps.chunks(kern.n)) { // multi thread + let result = kern.multiexp(bases, exps, bases.len())?; + acc.add_assign(&result); + } + Ok(acc) + }, + )); + } + } + + let cpu_acc = cpu_multiexp( + &pool, + (Arc::new(cpu_bases.to_vec()), 0), + FullDensity, + Arc::new(cpu_exps.to_vec()) + ); + + let mut results = vec![]; + for t in threads { + results.push(t.join()); + } + for r in results { + acc.add_assign(&r??); + } + + acc.add_assign(&cpu_acc.wait().unwrap()); + + Ok(acc) + }) { + Ok(res) => res, + Err(e) => Err(GPUError::from(e)), + } + } +} diff --git a/src/gpu/multiexp/ec.cl b/src/gpu/multiexp/ec.cl new file mode 100644 index 000000000..a6a65214f --- /dev/null +++ b/src/gpu/multiexp/ec.cl @@ -0,0 +1,117 @@ +// Elliptic curve operations (Short Weierstrass Jacobian form) + +#define POINT_ZERO ((POINT_projective){FIELD_ZERO, FIELD_ONE, FIELD_ZERO}) + +typedef struct { + FIELD x; + FIELD y; + bool inf; +} POINT_affine; + +typedef struct { + FIELD x; + FIELD y; + FIELD z; +} POINT_projective; + +// http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l +POINT_projective POINT_double(POINT_projective inp) { + if(FIELD_eq(inp.z, FIELD_ZERO)) return inp; + FIELD a = FIELD_sqr(inp.x); // A = X1^2 + FIELD b = FIELD_sqr(inp.y); // B = Y1^2 + FIELD c = FIELD_sqr(b); // C = B^2 + + // D = 2*((X1+B)2-A-C) + FIELD d = FIELD_add(inp.x, b); + d = FIELD_sqr(d); d = FIELD_sub(FIELD_sub(d, a), c); d = FIELD_double(d); + + FIELD e = FIELD_add(FIELD_double(a), a); // E = 3*A + + FIELD f = FIELD_sqr(e); + + inp.z = FIELD_mul(inp.y, inp.z); inp.z = FIELD_double(inp.z); // Z3 = 2*Y1*Z1 + inp.x = FIELD_sub(FIELD_sub(f, d), d); // X3 = F-2*D + + // Y3 = E*(D-X3)-8*C + c = FIELD_double(c); c = FIELD_double(c); c = FIELD_double(c); + inp.y = FIELD_sub(FIELD_mul(FIELD_sub(d, inp.x), e), c); + + return inp; +} + +// http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl +POINT_projective POINT_add_mixed(POINT_projective a, POINT_affine b) { + if(b.inf) return a; + + if(FIELD_eq(a.z, FIELD_ZERO)) { + a.x = b.x; + a.y = b.y; + a.z = FIELD_ONE; + return a; + } + + FIELD z1z1 = FIELD_sqr(a.z); + FIELD u2 = FIELD_mul(b.x, z1z1); + FIELD s2 = FIELD_mul(FIELD_mul(b.y, a.z), z1z1); + + if(FIELD_eq(a.x, u2) && FIELD_eq(a.y, s2)) + return POINT_double(a); + else { + FIELD h = FIELD_sub(u2, a.x); // H = U2-X1 + FIELD hh = FIELD_sqr(h); // HH = H^2 + FIELD i = FIELD_double(hh); i = FIELD_double(i); // I = 4*HH + FIELD j = FIELD_mul(h, i); // J = H*I + FIELD r = FIELD_sub(s2, a.y); r = FIELD_double(r); // r = 2*(S2-Y1) + FIELD v = FIELD_mul(a.x, i); + + POINT_projective ret; + + // X3 = r^2 - J - 2*V + ret.x = FIELD_sub(FIELD_sub(FIELD_sqr(r), j), FIELD_double(v)); + + // Y3 = r*(V-X3)-2*Y1*J + j = FIELD_mul(a.y, j); j = FIELD_double(j); + ret.y = FIELD_sub(FIELD_mul(FIELD_sub(v, ret.x), r), j); + + // Z3 = (Z1+H)^2-Z1Z1-HH + ret.z = FIELD_add(a.z, h); ret.z = FIELD_sub(FIELD_sub(FIELD_sqr(ret.z), z1z1), hh); + return ret; + } +} + +// http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-add-2007-bl +POINT_projective POINT_add(POINT_projective a, POINT_projective b) { + + if(FIELD_eq(a.z, FIELD_ZERO)) return b; + if(FIELD_eq(b.z, FIELD_ZERO)) return a; + + FIELD z1z1 = FIELD_sqr(a.z); // Z1Z1 = Z1^2 + FIELD z2z2 = FIELD_sqr(b.z); // Z2Z2 = Z2^2 + FIELD u1 = FIELD_mul(a.x, z2z2); // U1 = X1*Z2Z2 + FIELD u2 = FIELD_mul(b.x, z1z1); // U2 = X2*Z1Z1 + FIELD s1 = FIELD_mul(FIELD_mul(a.y, b.z), z2z2); // S1 = Y1*Z2*Z2Z2 + FIELD s2 = FIELD_mul(FIELD_mul(b.y, a.z), z1z1); // S2 = Y2*Z1*Z1Z1 + + if(FIELD_eq(u1, u2) && FIELD_eq(s1, s2)) + return POINT_double(a); + else { + FIELD h = FIELD_sub(u2, u1); // H = U2-U1 + FIELD i = FIELD_double(h); i = FIELD_sqr(i); // I = (2*H)^2 + FIELD j = FIELD_mul(h, i); // J = H*I + FIELD r = FIELD_sub(s2, s1); r = FIELD_double(r); // r = 2*(S2-S1) + FIELD v = FIELD_mul(u1, i); // V = U1*I + a.x = FIELD_sub(FIELD_sub(FIELD_sub(FIELD_sqr(r), j), v), v); // X3 = r^2 - J - 2*V + + // Y3 = r*(V - X3) - 2*S1*J + a.y = FIELD_mul(FIELD_sub(v, a.x), r); + s1 = FIELD_mul(s1, j); s1 = FIELD_double(s1); // S1 = S1 * J * 2 + a.y = FIELD_sub(a.y, s1); + + // Z3 = ((Z1+Z2)^2 - Z1Z1 - Z2Z2)*H + a.z = FIELD_add(a.z, b.z); a.z = FIELD_sqr(a.z); + a.z = FIELD_sub(FIELD_sub(a.z, z1z1), z2z2); + a.z = FIELD_mul(a.z, h); + + return a; + } +} diff --git a/src/gpu/multiexp/field2.cl b/src/gpu/multiexp/field2.cl new file mode 100644 index 000000000..ad387d825 --- /dev/null +++ b/src/gpu/multiexp/field2.cl @@ -0,0 +1,60 @@ +// Fp2 Extension Field where u^2 + 1 = 0 + +#define FIELD2_ZERO ((FIELD2){FIELD_ZERO, FIELD_ZERO}) +#define FIELD2_ONE ((FIELD2){FIELD_ONE, FIELD_ZERO}) + +typedef struct { + FIELD c0; + FIELD c1; +} FIELD2; // Represents: c0 + u * c1 + +bool FIELD2_eq(FIELD2 a, FIELD2 b) { + return FIELD_eq(a.c0, b.c0) && FIELD_eq(a.c1, b.c1); +} +FIELD2 FIELD2_sub(FIELD2 a, FIELD2 b) { + a.c0 = FIELD_sub(a.c0, b.c0); + a.c1 = FIELD_sub(a.c1, b.c1); + return a; +} +FIELD2 FIELD2_add(FIELD2 a, FIELD2 b) { + a.c0 = FIELD_add(a.c0, b.c0); + a.c1 = FIELD_add(a.c1, b.c1); + return a; +} +FIELD2 FIELD2_double(FIELD2 a) { + a.c0 = FIELD_double(a.c0); + a.c1 = FIELD_double(a.c1); + return a; +} + +/* + * (a_0 + u * a_1)(b_0 + u * b_1) = a_0 * b_0 - a_1 * b_1 + u * (a_0 * b_1 + a_1 * b_0) + * Therefore: + * c_0 = a_0 * b_0 - a_1 * b_1 + * c_1 = (a_0 * b_1 + a_1 * b_0) = (a_0 + a_1) * (b_0 + b_1) - a_0 * b_0 - a_1 * b_1 + */ +FIELD2 FIELD2_mul(FIELD2 a, FIELD2 b) { + FIELD aa = FIELD_mul(a.c0, b.c0); + FIELD bb = FIELD_mul(a.c1, b.c1); + FIELD o = FIELD_add(b.c0, b.c1); + a.c1 = FIELD_add(a.c1, a.c0); + a.c1 = FIELD_mul(a.c1, o); + a.c1 = FIELD_sub(a.c1, aa); + a.c1 = FIELD_sub(a.c1, bb); + a.c0 = FIELD_sub(aa, bb); + return a; +} + +/* + * (a_0 + u * a_1)(a_0 + u * a_1) = a_0 ^ 2 - a_1 ^ 2 + u * 2 * a_0 * a_1 + * Therefore: + * c_0 = (a_0 * a_0 - a_1 * a_1) = (a_0 + a_1)(a_0 - a_1) + * c_1 = 2 * a_0 * a_1 + */ +FIELD2 FIELD2_sqr(FIELD2 a) { + FIELD ab = FIELD_mul(a.c0, a.c1); + FIELD c0c1 = FIELD_add(a.c0, a.c1); + a.c0 = FIELD_mul(FIELD_sub(a.c0, a.c1), c0c1); + a.c1 = FIELD_double(ab); + return a; +} diff --git a/src/gpu/multiexp/multiexp.cl b/src/gpu/multiexp/multiexp.cl new file mode 100644 index 000000000..a4072c779 --- /dev/null +++ b/src/gpu/multiexp/multiexp.cl @@ -0,0 +1,64 @@ +/* + * Same multiexp algorithm used in Bellman, with some modifications. + * https://github.com/zkcrypto/bellman/blob/10c5010fd9c2ca69442dc9775ea271e286e776d8/src/multiexp.rs#L174 + * The CPU version of multiexp parallelism is done by dividing the exponent + * values into smaller windows, and then applying a sequence of rounds to each + * window. The GPU kernel not only assigns a thread to each window but also + * divides the bases into several groups which highly increases the number of + * threads running in parallel for calculating a multiexp instance. + */ + +__kernel void POINT_bellman_multiexp( + __global POINT_affine *bases, + __global POINT_projective *buckets, + __global POINT_projective *results, + __global EXPONENT *exps, + uint n, + uint num_groups, + uint num_windows, + uint window_size) { + + // We have `num_windows` * `num_groups` threads per multiexp. + uint gid = get_global_id(0); + if(gid >= num_windows * num_groups) return; + + // We have (2^window_size - 1) buckets. + uint bucket_len = ((1 << window_size) - 1); + + // Each thread has its own set of buckets in global memory. + buckets += bucket_len * gid; + for(uint i = 0; i < bucket_len; i++) buckets[i] = POINT_ZERO; + + uint len = (uint)ceil(n / (float)num_groups); // Num of elements in each group + + // This thread runs the multiexp algorithm on elements from `nstart` to `nened` + // on the window [`bits`, `bits` + `w`) + uint nstart = len * (gid / num_windows); + uint nend = min(nstart + len, n); + uint bits = (gid % num_windows) * window_size; + ushort w = min((ushort)window_size, (ushort)(EXPONENT_BITS - bits)); + + POINT_projective res = POINT_ZERO; + for(uint i = nstart; i < nend; i++) { + uint ind = EXPONENT_get_bits(exps[i], bits, w); + + // O_o, weird optimization, having a single special case makes it + // tremendously faster! + // 511 is chosen because it's half of the maximum bucket len, but + // any other number works... Bigger indices seems to be better... + if(ind == 511) buckets[510] = POINT_add_mixed(buckets[510], bases[i]); + else if(ind--) buckets[ind] = POINT_add_mixed(buckets[ind], bases[i]); + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + POINT_projective acc = POINT_ZERO; + for(int j = bucket_len - 1; j >= 0; j--) { + acc = POINT_add(acc, buckets[j]); + res = POINT_add(res, acc); + } + + results[gid] = res; +} diff --git a/src/gpu/nogpu.rs b/src/gpu/nogpu.rs new file mode 100644 index 000000000..31fca43d0 --- /dev/null +++ b/src/gpu/nogpu.rs @@ -0,0 +1,84 @@ +use super::error::{GPUError, GPUResult}; +use crate::multicore::Worker; + +// use ff::{PrimeField, ScalarEngine}; +// use groupy::CurveAffine; +use pairing::ff::{PrimeField, ScalarEngine}; +use pairing::CurveAffine; + + +use std::marker::PhantomData; +use std::sync::Arc; + +// This module is compiled instead of `fft.rs` and `multiexp.rs` if `gpu` feature is disabled. + +pub struct FFTKernel(PhantomData) +where + E: ScalarEngine; + +impl FFTKernel +where + E: ScalarEngine, +{ + pub fn create(_: u32, _: bool) -> GPUResult> { + return Err(GPUError::Simple("GPU accelerator is not enabled!")); + } + + pub fn radix_fft(&mut self, _: &mut [E::Fr], _: &E::Fr, _: u32) -> GPUResult<()> { + return Err(GPUError::Simple("GPU accelerator is not enabled!")); + } +} + +pub struct MultiexpKernel(PhantomData) +where + E: ScalarEngine; + +impl MultiexpKernel +where + E: ScalarEngine, +{ + pub fn create(_: bool) -> GPUResult> { + return Err(GPUError::Simple("GPU accelerator is not enabled!")); + } + + pub fn multiexp( + &mut self, + _: &Worker, + _: Arc>, + _: Arc::Fr as PrimeField>::Repr>>, + _: usize, + _: usize, + ) -> GPUResult<::Projective> + where + G: CurveAffine, + { + return Err(GPUError::Simple("GPU accelerator is not enabled!")); + } +} + +use pairing::Engine; + +macro_rules! locked_kernel { + ($class:ident) => { + pub struct $class(PhantomData); + + impl $class + where + E: Engine, + { + pub fn new(_: usize, _: bool) -> $class { + $class::(PhantomData) + } + + pub fn with(&mut self, _: F) -> GPUResult + where + F: FnMut(&mut K) -> GPUResult, + { + return Err(GPUError::Simple("GPU accelerator is not enabled!")); + } + } + }; +} + +locked_kernel!(LockedFFTKernel); +locked_kernel!(LockedMultiexpKernel); diff --git a/src/gpu/sources.rs b/src/gpu/sources.rs new file mode 100644 index 000000000..08c95ffef --- /dev/null +++ b/src/gpu/sources.rs @@ -0,0 +1,67 @@ +use ff_cl_gen as ffgen; +// use paired::Engine; +use pairing::Engine; + + +// Instead of having a very large OpenCL program written for a specific curve, with a lot of +// rudandant codes (As OpenCL doesn't have generic types or templates), this module will dynamically +// generate OpenCL codes given different PrimeFields and curves. + +static FFT_SRC: &str = include_str!("fft/fft.cl"); +static FIELD2_SRC: &str = include_str!("multiexp/field2.cl"); +static EC_SRC: &str = include_str!("multiexp/ec.cl"); +static MULTIEXP_SRC: &str = include_str!("multiexp/multiexp.cl"); + +fn field2(field2: &str, field: &str) -> String { + String::from(FIELD2_SRC) + .replace("FIELD2", field2) + .replace("FIELD", field) +} + +fn fft(field: &str) -> String { + String::from(FFT_SRC).replace("FIELD", field) +} + +#[cfg(not(feature = "blstrs"))] +const BLSTRS_DEF: &str = ""; +#[cfg(feature = "blstrs")] +const BLSTRS_DEF: &str = "#define BLSTRS"; + +fn ec(field: &str, point: &str) -> String { + String::from(EC_SRC) + .replace("FIELD", field) + .replace("POINT", point) + .replace("__BLSTRS__", BLSTRS_DEF) +} + +fn multiexp(point: &str, exp: &str) -> String { + String::from(MULTIEXP_SRC) + .replace("POINT", point) + .replace("EXPONENT", exp) +} + +// WARNING: This function works only with Short Weierstrass Jacobian curves with Fq2 extension field. +pub fn kernel(limb64: bool) -> String + where + E: Engine, +{ + vec![ + if limb64 { + ffgen::field::("Fr") + } else { + ffgen::field::("Fr") + }, + fft("Fr"), + if limb64 { + ffgen::field::("Fq") + } else { + ffgen::field::("Fq") + }, + ec("Fq", "G1"), + multiexp("G1", "Fr"), + field2("Fq2", "Fq"), + ec("Fq2", "G2"), + multiexp("G2", "Fr"), + ] + .join("\n\n") +} \ No newline at end of file diff --git a/src/gpu/structs.rs b/src/gpu/structs.rs new file mode 100644 index 000000000..4436cbc5f --- /dev/null +++ b/src/gpu/structs.rs @@ -0,0 +1,55 @@ +// use ff::PrimeField; +// use groupy::{CurveAffine, CurveProjective}; + +use pairing::ff::PrimeField; + +use pairing::{CurveProjective, CurveAffine}; + +use ocl::traits::OclPrm; + +// Everything that needs to be copied to GPU needs to implement OclPrm trait. +// This module implements a generic OclPrm version of PrimeField, CurveAffine and CurveProjective +// so that they can be copied to GPU. +// A transmute from [PrimeField] to [PrimeFieldStruct] is safe as their sizes are equal. +// Also safe for [CurveAffine] to [CurveAffineStruct] and [CurveProjective] to [CurveProjectiveStruct] +// It costs less memory to just transmute the data sources for both FFT and Multiexp to their +// OpenCL friendly equivalents instead of mapping them to a new array with each element casted. + +#[derive(PartialEq, Debug, Clone, Copy)] +#[repr(transparent)] +pub struct PrimeFieldStruct(pub T); +impl Default for PrimeFieldStruct +where + T: PrimeField, +{ + fn default() -> Self { + PrimeFieldStruct::(T::zero()) + } +} +unsafe impl OclPrm for PrimeFieldStruct where T: PrimeField {} + +#[derive(PartialEq, Debug, Clone, Copy)] +#[repr(transparent)] +pub struct CurveAffineStruct(pub T); +impl Default for CurveAffineStruct +where + T: CurveAffine, +{ + fn default() -> Self { + CurveAffineStruct::(T::zero()) + } +} +unsafe impl OclPrm for CurveAffineStruct where T: CurveAffine {} + +#[derive(PartialEq, Debug, Clone, Copy)] +#[repr(transparent)] +pub struct CurveProjectiveStruct(pub T); +impl Default for CurveProjectiveStruct +where + T: CurveProjective, +{ + fn default() -> Self { + CurveProjectiveStruct::(T::zero()) + } +} +unsafe impl OclPrm for CurveProjectiveStruct where T: CurveProjective {} diff --git a/src/gpu/utils.rs b/src/gpu/utils.rs new file mode 100644 index 000000000..33b47f2a9 --- /dev/null +++ b/src/gpu/utils.rs @@ -0,0 +1,78 @@ +use crate::gpu::error::{GPUError, GPUResult}; +use ocl::{Device, Platform}; + +use log::info; +use std::collections::HashMap; +use std::env; + +pub const GPU_NVIDIA_PLATFORM_NAME: &str = "NVIDIA CUDA"; +// pub const CPU_INTEL_PLATFORM_NAME: &str = "Intel(R) CPU Runtime for OpenCL(TM) Applications"; + +pub fn get_devices(platform_name: &str) -> GPUResult> { + if env::var("BELLMAN_NO_GPU").is_ok() { + return Err(GPUError::Simple("GPU accelerator is disabled!")); + } + + let platform = Platform::list()?.into_iter().find(|&p| match p.name() { + Ok(p) => p == platform_name, + Err(_) => false, + }); + match platform { + Some(p) => Ok(Device::list_all(p)?), + None => Err(GPUError::Simple("GPU platform not found!")), + } +} + +lazy_static::lazy_static! { + static ref CORE_COUNTS: HashMap = { + let mut core_counts : HashMap = vec![ + ("TITAN RTX".to_string(), 4608), + + ("Tesla V100".to_string(), 5120), + ("Tesla P100".to_string(), 3584), + ("Tesla T4".to_string(), 2560), + + ("GeForce RTX 2080 Ti".to_string(), 4352), + ("GeForce RTX 2080 SUPER".to_string(), 3072), + ("GeForce RTX 2080".to_string(), 2944), + ("GeForce RTX 2070 SUPER".to_string(), 2560), + + ("GeForce GTX 1080 Ti".to_string(), 3584), + ("GeForce GTX 1080".to_string(), 2560), + ("GeForce GTX 2060".to_string(), 1920), + ("GeForce GTX 1660 Ti".to_string(), 1536), + ("GeForce GTX 1060".to_string(), 1280), + ("GeForce GTX 1060 3GB".to_string(), 1152), + ("GeForce GTX 1650 SUPER".to_string(), 1280), + ("GeForce GTX 1650".to_string(), 896), + ].into_iter().collect(); + + match env::var("BELLMAN_CUSTOM_GPU").and_then(|var| { + for card in var.split(",") { + let splitted = card.split(":").collect::>(); + if splitted.len() != 2 { panic!("Invalid BELLMAN_CUSTOM_GPU!"); } + let name = splitted[0].trim().to_string(); + let cores : usize = splitted[1].trim().parse().expect("Invalid BELLMAN_CUSTOM_GPU!"); + info!("Adding \"{}\" to GPU list with {} CUDA cores.", name, cores); + core_counts.insert(name, cores); + } + Ok(()) + }) { Err(_) => { }, Ok(_) => { } } + + core_counts + }; +} + +pub fn get_core_count(d: Device) -> GPUResult { + match CORE_COUNTS.get(&d.name()?[..]) { + Some(&cores) => Ok(cores), + None => Err(GPUError::Simple("Device unknown!")), // device unknown + } +} + +pub fn get_memory(d: Device) -> GPUResult { + match d.info(ocl::enums::DeviceInfo::GlobalMemSize)? { + ocl::enums::DeviceInfoResult::GlobalMemSize(sz) => Ok(sz), + _ => Err(GPUError::Simple("Cannot extract GPU memory!")), + } +} diff --git a/src/group.rs b/src/group.rs index 8671d76f1..0cfc12ac6 100644 --- a/src/group.rs +++ b/src/group.rs @@ -3,9 +3,11 @@ use crate::pairing::{ CurveProjective }; + use crate::pairing::ff::{ Field, - PrimeField + PrimeField, + ScalarEngine }; use super::{ @@ -79,4 +81,4 @@ impl Group for Scalar { fn group_sub_assign(&mut self, other: &Self) { self.0.sub_assign(&other.0); } -} \ No newline at end of file +} diff --git a/src/kate_commitment/mod.rs b/src/kate_commitment/mod.rs new file mode 100644 index 000000000..29384a303 --- /dev/null +++ b/src/kate_commitment/mod.rs @@ -0,0 +1,2241 @@ +use crate::pairing::{Engine, CurveAffine, CurveProjective}; +use crate::ff::{Field, PrimeField}; +use crate::worker::Worker; +use crate::plonk::polynomials::*; +use std::sync::Arc; +use crate::multiexp; +use crate::SynthesisError; + +use crate::gpu; + +pub trait CrsType {} + +pub struct CrsForMonomialForm; +pub struct CrsForLagrangeForm; +pub struct CrsForLagrangeFormOnCoset; + +impl CrsType for CrsForMonomialForm {} +impl CrsType for CrsForLagrangeForm {} +impl CrsType for CrsForLagrangeFormOnCoset {} + +pub struct Crs { + pub g1_bases: Arc>, + pub g2_monomial_bases: Arc>, + + _marker: std::marker::PhantomData +} + +use std::io::{Read, Write}; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use crate::byteorder::BigEndian; + +impl PartialEq for Crs { + fn eq(&self, other: &Self) -> bool { + self.g1_bases == other.g1_bases + && self.g2_monomial_bases == other.g2_monomial_bases + } +} + +impl Eq for Crs { } + +impl Crs { + pub fn write( + &self, + mut writer: W + ) -> std::io::Result<()> + { + writer.write_u64::(self.g1_bases.len() as u64)?; + for g in &self.g1_bases[..] { + writer.write_all(g.into_uncompressed().as_ref())?; + } + + writer.write_u64::(self.g2_monomial_bases.len() as u64)?; + for g in &self.g2_monomial_bases[..] { + writer.write_all(g.into_uncompressed().as_ref())?; + } + + Ok(()) + } + + pub fn read( + mut reader: R + ) -> std::io::Result + { + use crate::pairing::EncodedPoint; + + let mut g1_repr = ::Uncompressed::empty(); + let mut g2_repr = ::Uncompressed::empty(); + + let num_g1 = reader.read_u64::()?; + + let mut g1_bases = Vec::with_capacity(num_g1 as usize); + + for _ in 0..num_g1 { + reader.read_exact(g1_repr.as_mut())?; + let p = g1_repr.into_affine().map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + g1_bases.push(p); + } + + let num_g2 = reader.read_u64::()?; + assert!(num_g2 == 2u64); + + let mut g2_bases = Vec::with_capacity(num_g2 as usize); + + for _ in 0..num_g2 { + reader.read_exact(g2_repr.as_mut())?; + let p = g2_repr.into_affine().map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + g2_bases.push(p); + } + + let new = Self { + g1_bases: Arc::new(g1_bases), + g2_monomial_bases: Arc::new(g2_bases), + + _marker: std::marker::PhantomData + }; + + Ok(new) + } +} + +impl Crs { + pub fn dummy_crs(size: usize) -> Self { + assert!(size.is_power_of_two()); + + let g1 = vec![E::G1Affine::one(); size]; + let g2 = vec![E::G2Affine::one(); 2]; + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } + + pub fn crs_42(size: usize, worker: &Worker) -> Self { + // kind of how ceremony would work + assert!(size.is_power_of_two()); + + let mut g2 = vec![E::G2Affine::one(); 2]; + + use crate::group::Scalar; + use crate::domain::EvaluationDomain; + use crate::pairing::Wnaf; + + let mut coeffs = vec![Scalar::(E::Fr::one()); size]; + + { + let gen = E::Fr::from_str("42").unwrap(); + + g2[1] = g2[1].mul(gen.into_repr()).into_affine(); + + worker.scope(coeffs.len(), |scope, chunk| { + for (i, p) in coeffs.chunks_mut(chunk).enumerate() + { + scope.spawn(move |_| { + let mut current_p = gen.pow(&[(i*chunk) as u64]); + + for p in p.iter_mut() { + p.0 = current_p; + current_p.mul_assign(&gen); + } + }); + } + }); + } + + let mut g1_wnaf = Wnaf::new(); + let g1_wnaf = g1_wnaf.base(E::G1Affine::one().into_projective(), size); + + let mut g1 = vec![E::G1Affine::zero().into_projective(); size]; + + worker.scope(g1.len(), |scope, chunk| { + for (g1, p) in g1.chunks_mut(chunk).zip(coeffs.chunks(chunk)) + { + let mut g1_wnaf = g1_wnaf.shared(); + scope.spawn(move |_| { + for (g1, p) in g1.iter_mut().zip(p.iter()) + { + // Compute final exponent + let exp = p.0; + + // Exponentiate + *g1 = g1_wnaf.scalar(exp.into_repr()); + } + + // Batch normalize + E::G1::batch_normalization(g1); + }); + } + }); + + let g1: Vec<_> = g1.into_iter().map(|el| el.into_affine()).collect(); + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } +} + +impl Crs { + // Completely invalid, only for testing purposes + pub fn dummy_crs(size: usize) -> Self { + assert!(size.is_power_of_two()); + + let g1 = vec![E::G1Affine::one(); size]; + let g2 = vec![E::G2Affine::one(); 2]; + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } + + pub fn crs_42(size: usize, worker: &Worker) -> Self { + let tmp = Crs::::crs_42(size, &worker); + + Self::from_powers(&tmp, size, &worker) + } + + pub fn from_powers(powers: &Crs::, size: usize, worker: &Worker) -> Self { + assert!(size.is_power_of_two()); + assert!(size <= powers.g1_bases.len()); + + let g2 = powers.g2_monomial_bases.as_ref().to_vec(); + let g1 = powers.g1_bases.as_ref()[..size].to_vec(); + + let g1 = g1.into_iter().map(|el| Point(el.into_projective())).collect(); + + use crate::group::Point; + use crate::domain::EvaluationDomain; + + let mut g1 = EvaluationDomain::from_coeffs(g1).expect("must fit into the domain"); + g1.transform_powers_of_tau_into_lagrange_basis(&worker); + let mut g1: Vec<_> = g1.into_coeffs().into_iter().map(|el| el.0).collect(); + + worker.scope(g1.len(), |scope, chunk| { + for g1 in g1.chunks_mut(chunk) + { + scope.spawn(move |_| { + // Batch normalize + E::G1::batch_normalization(g1); + }); + } + }); + + let g1: Vec<_> = g1.into_iter().map(|el| el.into_affine()).collect(); + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } +} + +impl Crs { + // Completely invalid, only for testing purposes + pub fn dummy_crs(size: usize) -> Self { + assert!(size.is_power_of_two()); + + let g1 = vec![E::G1Affine::one(); size]; + let g2 = vec![E::G2Affine::one(); 2]; + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } + + pub fn crs_42(size: usize, worker: &Worker) -> Self { + let tmp = Crs::::crs_42(size, &worker); + + Self::from_powers(&tmp, size, &worker) + } + + pub fn from_powers(powers: &Crs::, size: usize, worker: &Worker) -> Self { + assert!(size.is_power_of_two()); + assert!(size <= powers.g1_bases.len()); + + let g2 = powers.g2_monomial_bases.as_ref().to_vec(); + let g1 = powers.g1_bases.as_ref()[..size].to_vec(); + + let g1: Vec<_> = g1.into_iter().map(|el| Point(el.into_projective())).collect(); + + use crate::group::Point; + use crate::domain::EvaluationDomain; + + let mut g1 = EvaluationDomain::from_coeffs(g1).expect("must fit into the domain"); + + g1.transform_powers_of_tau_into_lagrange_basis_on_coset(&worker); + let mut g1: Vec<_> = g1.into_coeffs().into_iter().map(|el| el.0).collect(); + + worker.scope(g1.len(), |scope, chunk| { + for g1 in g1.chunks_mut(chunk) + { + scope.spawn(move |_| { + // Batch normalize + E::G1::batch_normalization(g1); + }); + } + }); + + let g1: Vec<_> = g1.into_iter().map(|el| el.into_affine()).collect(); + + Self { + g1_bases: Arc::new(g1), + g2_monomial_bases: Arc::new(g2), + + _marker: std::marker::PhantomData + } + } +} + +pub(crate) fn elements_into_representations( + worker: &Worker, + scalars: &[E::Fr] +) -> Result::Repr>, SynthesisError> +{ + let mut representations = vec![::Repr::default(); scalars.len()]; + worker.scope(scalars.len(), |scope, chunk| { + for (scalar, repr) in scalars.chunks(chunk) + .zip(representations.chunks_mut(chunk)) { + scope.spawn(move |_| { + for (scalar, repr) in scalar.iter() + .zip(repr.iter_mut()) { + *repr = scalar.into_repr(); + } + }); + } + }); + + Ok(representations) +} + +pub fn commit_using_monomials( + poly: &Polynomial, + crs: &Crs, + worker: &Worker +) -> Result { + println!("Committing coefficients"); + + use std::time::Instant; + + let now = Instant::now(); + + let subtime = Instant::now(); + + let scalars_repr = elements_into_representations::( + &worker, + &poly.as_ref() + )?; + + println!("Scalars conversion taken {:?}", subtime.elapsed()); + + // let subtime = Instant::now(); + // + // let res = multiexp::dense_multiexp::( + // &worker, + // &crs.g1_bases[..scalars_repr.len()], + // &scalars_repr + // )?; + // + // println!("Multiexp cpu taken {:?}", subtime.elapsed()); + + let mut kern = Some(gpu::LockedMultiexpKernel::::new(30, false)); + + let subtime = Instant::now(); + let res_gpu = multiexp::dense_multiexp_gpu::( + &worker, + &crs.g1_bases[..scalars_repr.len()], + &scalars_repr, + &mut kern + )?; + + println!("Multiexp gpu taken {:?}", subtime.elapsed()); + + // assert_eq!(res, res_gpu); + + + println!("Commtiment taken {:?}", now.elapsed()); + + // Ok(res.into_affine()) + Ok(res_gpu.into_affine()) +} + +pub fn commit_using_values( + poly: &Polynomial, + crs: &Crs, + worker: &Worker +) -> Result { + println!("Committing values over domain"); + assert_eq!(poly.size(), crs.g1_bases.len()); + + use std::time::Instant; + + let now = Instant::now(); + + let subtime = Instant::now(); + + let scalars_repr = elements_into_representations::( + &worker, + &poly.as_ref() + )?; + + println!("Scalars conversion taken {:?}", subtime.elapsed()); + + let subtime = Instant::now(); + + let res = multiexp::dense_multiexp::( + &worker, + &crs.g1_bases, + &scalars_repr + )?; + + println!("Multiexp taken {:?}", subtime.elapsed()); + + println!("Commtiment taken {:?}", now.elapsed()); + + Ok(res.into_affine()) +} + +pub fn commit_using_raw_values( + values: &[E::Fr], + crs: &Crs, + worker: &Worker +) -> Result { + assert_eq!(values.len().next_power_of_two(), crs.g1_bases.len()); + println!("Committing raw values over domain"); + let scalars_repr = elements_into_representations::( + &worker, + &values + )?; + + let res = multiexp::dense_multiexp::( + &worker, + &crs.g1_bases[0..values.len()], + &scalars_repr + )?; + + Ok(res.into_affine()) +} + +use crate::source::QueryDensity; + +pub fn commit_using_values_with_density ( + values: &[E::Fr], + density: D, + crs: &Crs, + worker: &Worker +) -> Result + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef +{ + use futures::Future; + + println!("Committing values over domain with density"); + // assert_eq!(values.len(), crs.g1_bases.len()); + let scalars_repr = elements_into_representations::( + &worker, + &values + )?; + + // scalars_repr.resize(crs.g1_bases.len(), ::Repr::default()); + + let res = multiexp::multiexp( + &worker, + (crs.g1_bases.clone(), 0), + density, + Arc::new(scalars_repr) + ).wait()?; + + Ok(res.into_affine()) +} + +pub fn commit_using_values_on_coset( + poly: &Polynomial, + crs: &Crs, + worker: &Worker +) -> Result { + println!("Committing values over coset"); + assert_eq!(poly.size(), crs.g1_bases.len()); + let scalars_repr = elements_into_representations::( + &worker, + &poly.as_ref() + )?; + + let res = multiexp::dense_multiexp::( + &worker, + &crs.g1_bases, + &scalars_repr + )?; + + Ok(res.into_affine()) +} + +pub fn calculate_batch_opening_quotient_from_monomials( + polys: &[Polynomial], + challenges: &[E::Fr], + at: E::Fr, + worker: &Worker, +) -> Result, SynthesisError> { + assert_eq!(polys.len(), challenges.len()); + assert!(polys.len() > 0); + let mut tmp = polys[0].clone(); + tmp.scale(worker, challenges[0]); + for (p, c) in polys[1..].iter().zip(challenges[1..].iter()) { + tmp.add_assign_scaled(worker, p, c); + } + + let quotient = divide_single::(tmp.as_ref(), at); + + Polynomial::from_coeffs(quotient) +} + +pub fn open_from_monomials( + poly: &Polynomial, + at: E::Fr, + _expected_value: E::Fr, + crs: &Crs, + worker: &Worker +) -> Result { + assert!(poly.size().is_power_of_two()); + let division_result = divide_single::(poly.as_ref(), at); + assert!(division_result.len().is_power_of_two()); + let division_result = Polynomial::from_coeffs(division_result)?; + + let opening_proof = commit_using_monomials( + &division_result, + &crs, + &worker + )?; + + Ok(opening_proof) +} + +pub fn open_from_values( + poly: &Polynomial, + at: E::Fr, + expected_value: E::Fr, + crs: &Crs, + worker: &Worker +) -> Result { + assert!(poly.size().is_power_of_two()); + let division_result = vec![E::Fr::one(); poly.size()]; + let mut division_result = Polynomial::from_values(division_result)?; + division_result.distribute_powers(&worker, division_result.omega); + division_result.sub_constant(&worker, &at); + division_result.batch_inversion(&worker)?; + + worker.scope(division_result.size(), |scope, chunk_size| { + for (result, values) in division_result.as_mut().chunks_mut(chunk_size) + .zip(poly.as_ref().chunks(chunk_size)) + { + scope.spawn(move |_| { + for (r, &val) in result.iter_mut().zip(values.iter()) { + let mut tmp = val; + tmp.sub_assign(&expected_value); + r.mul_assign(&tmp); + } + }); + } + }); + + let opening_proof = commit_using_values(&division_result, &crs, &worker)?; + + Ok(opening_proof) +} + +pub fn open_from_values_on_coset( + poly: &Polynomial, + coset_factor: E::Fr, + at: E::Fr, + expected_value: E::Fr, + crs: &Crs, + worker: &Worker +) -> Result { + assert!(poly.size().is_power_of_two()); + let division_result = vec![coset_factor; poly.size()]; + let mut division_result = Polynomial::from_values(division_result)?; // [g, g, g, g, ...] + division_result.distribute_powers(&worker, division_result.omega); // [g, g*omega, g*omega^2, ...] + division_result.sub_constant(&worker, &at); // g - z, g*omega - z, g*omega^2 - z, ...] + division_result.batch_inversion(&worker)?; + + worker.scope(division_result.size(), |scope, chunk_size| { + for (result, values) in division_result.as_mut().chunks_mut(chunk_size) + .zip(poly.as_ref().chunks(chunk_size)) + { + scope.spawn(move |_| { + for (r, &val) in result.iter_mut().zip(values.iter()) { + let mut tmp = val; + tmp.sub_assign(&expected_value); + r.mul_assign(&tmp); + } + }); + } + }); + + let opening_proof = commit_using_values_on_coset(&division_result, &crs, &worker)?; + + Ok(opening_proof) +} + +pub fn perform_batched_divisor_for_opening( + mut polynomials: Vec>, + open_at: E::Fr, + opening_values: &[E::Fr], + challenge: E::Fr, + challenge_start: E::Fr, + worker: &Worker +) -> Result<(Polynomial, E::Fr), SynthesisError> { + assert!(polynomials.len() == opening_values.len(), "different number of polynomials and opening values"); + // assert!(polynomials.len() > 1, "should aggregate only two or more polynomials"); + + let size = polynomials[0].size(); + assert!(size.is_power_of_two()); + + let common_divisor = vec![E::Fr::one(); size]; + + let mut common_divisor = Polynomial::from_values(common_divisor)?; + common_divisor.distribute_powers(&worker, common_divisor.omega); + common_divisor.sub_constant(&worker, &open_at); + common_divisor.batch_inversion(&worker)?; + + for (p, v) in polynomials.iter_mut().zip(opening_values.iter()) { + assert!(p.size() == size); + p.sub_constant(&worker, v); + } + + let rest: Vec<_> = polynomials.drain(1..).collect(); + + let mut aggregation = polynomials.pop().expect("one polynomial left"); + if challenge_start != E::Fr::one() { + aggregation.scale(&worker, challenge); + } + + let mut this_challenge = challenge_start; + this_challenge.mul_assign(&challenge); + + for other in rest.into_iter() { + aggregation.add_assign_scaled(&worker, &other, &this_challenge); + this_challenge.mul_assign(&challenge); + } + + aggregation.mul_assign(&worker, &common_divisor); + drop(common_divisor); + + // return next challenge and aggregation + Ok((aggregation, this_challenge)) +} + +pub fn perform_batch_opening_from_values( + polynomials: Vec>, + crs: &Crs::, + open_at: E::Fr, + opening_values: &[E::Fr], + challenge: E::Fr, + worker: &Worker +) -> Result { + let (aggregation, _) = perform_batched_divisor_for_opening::( + polynomials, + open_at, + opening_values, + challenge, + E::Fr::one(), + &worker + )?; + + let opening_proof = commit_using_values(&aggregation, &crs, &worker)?; + + Ok(opening_proof) +} + +pub fn is_valid_opening( + commitment: E::G1Affine, + z: E::Fr, + opening_value: E::Fr, + opening_proof: E::G1Affine, + g2_by_x: E::G2Affine +) -> bool { + // (f(x) - f(z))/(x - z) = op(x) + + // f(x) = f(z) + op(x) * (x - z) + // e(f(x) - f(z) + z*op(x), 1) = e(op(x), x) + // e(f(x) - f(z) + z*op(x), 1) * e(-op(x), x) == 1 // e(0, 0) + + let mut pair_with_1_part = commitment.into_projective(); + let gen_by_opening_value = E::G1Affine::one().mul(opening_value.into_repr()); + let proof_by_z = opening_proof.mul(z.into_repr()); + + pair_with_1_part.sub_assign(&gen_by_opening_value); + pair_with_1_part.add_assign(&proof_by_z); + + let mut pair_with_x_part = opening_proof; + pair_with_x_part.negate(); + + let result = E::final_exponentiation( + &E::miller_loop( + &[ + (&pair_with_1_part.into_affine().prepare(), &E::G2Affine::one().prepare()), + (&pair_with_x_part.prepare(), &g2_by_x.prepare()), + ] + )); + + if let Some(res) = result { + return res == E::Fqk::one(); + } + + false +} + +pub fn is_valid_multiopening( + commitments: &[E::G1Affine], + z: E::Fr, + opening_values: &[E::Fr], + opening_proof: E::G1Affine, + challenge: E::Fr, + g2_by_x: E::G2Affine +) -> bool { + assert!(commitments.len() == opening_values.len()); + // \sum_{i} alpha^i (f(x) - f(z))/(x - z) = op(x) + + // \sum_{i} alpha^i (f(x) - f(z)) - op(x) * (x - z) = 0 + // e(\sum_{i} alpha^i (f(x) - f(z)) + z*op(x), 1) = e(op(x), x) + // e(\sum_{i} alpha^i (f(x) - f(z)) + z*op(x), 1) * e(-op(x), x) == 1 // e(0, 0) + + let mut aggregation = E::G1::zero(); + + let mut this_challenge = E::Fr::one(); + // later change for efficiency + for (c, v) in commitments.iter().zip(opening_values.iter()) { + let mut pair_with_1_part = c.into_projective(); + let gen_by_opening_value = E::G1Affine::one().mul(v.into_repr()); + pair_with_1_part.sub_assign(&gen_by_opening_value); + + pair_with_1_part.mul_assign(this_challenge.into_repr()); + aggregation.add_assign(&pair_with_1_part); + + this_challenge.mul_assign(&challenge); + } + + let proof_by_z = opening_proof.mul(z.into_repr()); + + aggregation.add_assign(&proof_by_z); + + let mut pair_with_x_part = opening_proof; + pair_with_x_part.negate(); + + let result = E::final_exponentiation( + &E::miller_loop( + &[ + (&aggregation.into_affine().prepare(), &E::G2Affine::one().prepare()), + (&pair_with_x_part.prepare(), &g2_by_x.prepare()), + ] + )); + + if let Some(res) = result { + return res == E::Fqk::one(); + } + + false +} + +pub(crate) fn divide_single( + poly: &[E::Fr], + opening_point: E::Fr, +) -> Vec { + // we are only interested in quotient without a reminder, so we actually don't need opening value + let mut b = opening_point; + b.negate(); + + let mut q = vec![E::Fr::zero(); poly.len()]; + + let mut tmp = E::Fr::zero(); + let mut found_one = false; + for (q, r) in q.iter_mut().rev().skip(1).zip(poly.iter().rev()) { + if !found_one { + if r.is_zero() { + continue + } else { + found_one = true; + } + } + + let mut lead_coeff = *r; + lead_coeff.sub_assign(&tmp); + *q = lead_coeff; + tmp = lead_coeff; + tmp.mul_assign(&b); + } + + q +} + +pub fn make_crs_from_ignition_transcript + ?Sized>( + path: &S +) -> Result, SynthesisError> { + use crate::pairing::bn256::{Bn256, Fq, Fq2, Fq12}; + use crate::pairing::EncodedPoint; + use crate::ff::{PrimeField, PrimeFieldRepr}; + use std::io::BufRead; + + const CHUNKS: usize = 20; + + let base_path = std::path::Path::new(&path); + + let mut g1_bases = Vec::with_capacity(100800000 + 1); + g1_bases.push(::G1Affine::one()); + let mut g2_bases = vec![::G2Affine::one()]; + + for i in 0..CHUNKS { + let full_path = base_path.join(&format!("transcript{:02}.dat", i)); + println!("Opening {}", full_path.to_string_lossy()); + let file = std::fs::File::open(full_path).map_err(|e| SynthesisError::IoError(e))?; + let mut reader = std::io::BufReader::with_capacity(1 << 24, file); + + // skip 28 bytes + let mut tmp = [0u8; 28]; + reader.read_exact(&mut tmp).expect("must skip 28 bytes"); + + let mut fq_repr = ::Repr::default(); + let b_coeff = Fq::from_str("3").unwrap(); + + fq_repr.as_mut()[0] = 0x3bf938e377b802a8; + fq_repr.as_mut()[1] = 0x020b1b273633535d; + fq_repr.as_mut()[2] = 0x26b7edf049755260; + fq_repr.as_mut()[3] = 0x2514c6324384a86d; + + let c0 = Fq::from_raw_repr(fq_repr).expect("c0 for B coeff for G2"); + + fq_repr.as_mut()[0] = 0x38e7ecccd1dcff67; + fq_repr.as_mut()[1] = 0x65f0b37d93ce0d3e; + fq_repr.as_mut()[2] = 0xd749d0dd22ac00aa; + fq_repr.as_mut()[3] = 0x0141b9ce4a688d4d; + + let c1 = Fq::from_raw_repr(fq_repr).expect("c0 for B coeff for G2"); + + let b_coeff_fq2 = Fq2 { + c0: c0, + c1: c1 + }; + + for _ in 0..5_040_000{ + // we have to manually read X and Y coordinates + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let x = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let y = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + // manual on-curve check + { + let mut lhs = y; + lhs.square(); + + let mut rhs = x; + rhs.square(); + rhs.mul_assign(&x); + rhs.add_assign(&b_coeff); + + assert!(lhs == rhs); + } + + let p = ::G1Affine::from_xy_unchecked(x, y); + + g1_bases.push(p); + } + + if i == 0 { + // read G2 + { + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let x_c0 = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let x_c1 = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let y_c0 = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + for k in 0..4 { + fq_repr.as_mut()[k] = reader.read_u64::().expect("must read u64"); + } + + let y_c1 = Fq::from_repr(fq_repr).expect("must be valid field element encoding"); + + let x = Fq2 { + c0: x_c0, + c1: x_c1 + }; + + let y = Fq2 { + c0: y_c0, + c1: y_c1 + }; + + { + let mut lhs = y; + lhs.square(); + + let mut rhs = x; + rhs.square(); + rhs.mul_assign(&x); + rhs.add_assign(&b_coeff_fq2); + + assert!(lhs == rhs); + } + + let g2 = ::G2Affine::from_xy_unchecked(x, y); + + g2_bases.push(g2); + + // sanity check by using pairing + { + // check e(g1, g2^x) == e(g1^{x}, g2) + let valid = Bn256::final_exponentiation( + &Bn256::miller_loop( + &[ + (&g1_bases[0].prepare(), &g2.prepare()) + ] + ) + ).unwrap() == Bn256::final_exponentiation( + &Bn256::miller_loop( + &[ + (&g1_bases[1].prepare(), &g2_bases[0].prepare()) + ] + ) + ).unwrap(); + + assert!(valid); + } + } + // read G2 + let mut tmp = [0u8; 128]; + reader.read_exact(&mut tmp).expect("must skip 128 bytes of irrelevant G2 point"); + } + + // read to end + reader.consume(64); + + assert_eq!(reader.fill_buf().unwrap().len(), 0); + } + + assert_eq!(g1_bases.len(), 100800000 + 1); + assert_eq!(g2_bases.len(), 2); + + let new = Crs:: { + g1_bases: Arc::new(g1_bases), + g2_monomial_bases: Arc::new(g2_bases), + + _marker: std::marker::PhantomData + }; + + Ok(new) +} + +#[cfg(test)] +pub(crate) mod test { + use super::*; + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + use crate::ff::{PrimeField, Field}; + use crate::plonk::polynomials::*; + + #[test] + fn test_transformations_of_crs_1() { + let worker = Worker::new(); + + let monomial = Crs::::crs_42(1, &worker); + let lagrange = Crs::::crs_42(1, &worker); + let lagrange_coset = Crs::::crs_42(1, &worker); + + println!("Monomial = {:?}", monomial.g1_bases); + println!("Lagrange = {:?}", lagrange.g1_bases); + println!("Lagrange coset = {:?}", lagrange_coset.g1_bases); + } + + #[test] + fn test_transformations_of_crs_2() { + let worker = Worker::new(); + + let monomial = Crs::::crs_42(2, &worker); + let lagrange = Crs::::crs_42(2, &worker); + let lagrange_coset = Crs::::crs_42(2, &worker); + + println!("Monomial = {:?}", monomial.g1_bases); + println!("Lagrange = {:?}", lagrange.g1_bases); + println!("Lagrange coset = {:?}", lagrange_coset.g1_bases); + + // for a poly in a form a + bx + // commitment is a + b*tau + // values on domain are a+b, a-b + // commitment bases are (1+tau)/2, (1-tau)/2 + // commitment is (a+b)(1+tau)/2 + (a-b)(1-tau)/2 = a/2 + a*tau/2 + b/2 + b*tau/2 + a/2 - a*tau/2 - b/2 + b*tau/2 = a + tau*b + // valus on coset are a + gen*b, a - gen*b + // commitment is a*(b_0 + b_1) + gen*b*(b_0 - b_1) = a * tau*b + // so bases must be b_0 + b_1 = 1 and b_0 - b_1 = tau / gen + // so b_0 = 1 + tau/gen/2, b_1 = 1 - tau/gen/2 + + + let one = Fr::one(); + + let mut two = Fr::one(); + two.double(); + + let poly = Polynomial::::from_coeffs(vec![one, two]).unwrap(); + let values = poly.clone().fft(&worker); + let values_on_coset = poly.clone().coset_fft(&worker); + + let mut tmp = Fr::multiplicative_generator(); + tmp.mul_assign(&two); + tmp.add_assign(&one); + + assert!(tmp == values_on_coset.as_ref()[0]); + + let commitment = commit_using_monomials(&poly, &monomial, &worker).unwrap(); + let commitment_values = commit_using_values(&values, &lagrange, &worker).unwrap(); + let commitment_values_on_coset = commit_using_values_on_coset(&values_on_coset, &lagrange_coset, &worker).unwrap(); + + assert!(commitment == commitment_values); + assert!(commitment == commitment_values_on_coset); + + } + + #[test] + fn test_transformations_of_crs_4() { + let worker = Worker::new(); + + let monomial = Crs::::crs_42(4, &worker); + let lagrange = Crs::::crs_42(4, &worker); + let lagrange_coset = Crs::::crs_42(4, &worker); + + let one = Fr::one(); + + let mut two = Fr::one(); + two.double(); + + let poly = Polynomial::::from_coeffs(vec![one, two, one, two]).unwrap(); + let values = poly.clone().fft(&worker); + let values_on_coset = poly.clone().coset_fft(&worker); + + let commitment = commit_using_monomials(&poly, &monomial, &worker).unwrap(); + let commitment_values = commit_using_values(&values, &lagrange, &worker).unwrap(); + let commitment_values_on_coset = commit_using_values_on_coset(&values_on_coset, &lagrange_coset, &worker).unwrap(); + + assert!(commitment == commitment_values); + assert!(commitment == commitment_values_on_coset); + + } + + #[test] + fn test_transformations_of_crs_large() { + let worker = Worker::new(); + + let size = 1024; + + let monomial = Crs::::crs_42(size, &worker); + let lagrange = Crs::::crs_42(size, &worker); + let lagrange_coset = Crs::::crs_42(size, &worker); + + let mut two = Fr::one(); + two.double(); + + let poly = Polynomial::::from_coeffs(vec![two; size]).unwrap(); + let values = poly.clone().fft(&worker); + let values_on_coset = poly.clone().coset_fft(&worker); + + let commitment = commit_using_monomials(&poly, &monomial, &worker).unwrap(); + let commitment_values = commit_using_values(&values, &lagrange, &worker).unwrap(); + let commitment_values_on_coset = commit_using_values_on_coset(&values_on_coset, &lagrange_coset, &worker).unwrap(); + + assert!(commitment == commitment_values); + assert!(commitment == commitment_values_on_coset); + + } + + #[test] + fn test_opening_large() { + let worker = Worker::new(); + + let size = 1024; + + let monomial = Crs::::crs_42(size, &worker); + let lagrange = Crs::::crs_42(size, &worker); + let lagrange_coset = Crs::::crs_42(size, &worker); + + let mut two = Fr::one(); + two.double(); + + let poly = Polynomial::::from_coeffs(vec![two; size]).unwrap(); + let values = poly.clone().fft(&worker); + let values_on_coset = poly.clone().coset_fft(&worker); + + let z = Fr::from_str("1337").unwrap(); + + let poly_at_z = poly.evaluate_at(&worker, z); + let values_at_z = values.barycentric_evaluate_at(&worker, z).unwrap(); + let valus_on_coset_at_z = values_on_coset.barycentric_over_coset_evaluate_at(&worker, z, &Fr::multiplicative_generator()).unwrap(); + + assert!(poly_at_z == values_at_z); + assert!(poly_at_z == valus_on_coset_at_z); + + let commitment = commit_using_monomials(&poly, &monomial, &worker).unwrap(); + let commitment_values = commit_using_values(&values, &lagrange, &worker).unwrap(); + let commitment_values_on_coset = commit_using_values_on_coset(&values_on_coset, &lagrange_coset, &worker).unwrap(); + + assert!(commitment == commitment_values); + assert!(commitment == commitment_values_on_coset); + + let opening_poly = open_from_monomials(&poly, z, poly_at_z, &monomial, &worker).unwrap(); + let opening_values = open_from_values(&values, z, poly_at_z, &lagrange, &worker).unwrap(); + let opening_values_on_coset = open_from_values_on_coset(&values_on_coset, Fr::multiplicative_generator(), z, poly_at_z, &lagrange_coset, &worker).unwrap(); + + assert!(opening_poly == opening_values); + assert!(opening_poly == opening_values_on_coset); + + let valid = is_valid_opening::(commitment, z, poly_at_z, opening_poly, monomial.g2_monomial_bases[1]); + + assert!(valid); + } + + #[test] + fn test_open_ignition_setup() { + let large_setup = make_crs_from_ignition_transcript("/Users/alexvlasov/Downloads/setup").unwrap(); + let base_path = std::path::Path::new("/Users/alexvlasov/Downloads/setup/processed"); + + for n in 20..=26 { + let full_path = base_path.join(&format!("setup_2^{}.key", n)); + println!("Opening {}", full_path.to_string_lossy()); + let file = std::fs::File::create(full_path).unwrap(); + + let size = 1 << n; + + let truncated_key = Crs:: { + g1_bases: Arc::new(large_setup.g1_bases[..size].to_vec()), + g2_monomial_bases: large_setup.g2_monomial_bases.clone(), + + _marker: std::marker::PhantomData + }; + + let mut writer = std::io::BufWriter::with_capacity(1 << 24, file); + truncated_key.write(&mut writer).unwrap(); + } + } + + #[test] + fn transform_ignition_setup() { + let base_path = std::path::Path::new("/Users/alexvlasov/Downloads/setup/processed"); + + let worker = crate::worker::Worker::new(); + + for n in 20..=26 { + let full_path = base_path.join(&format!("setup_2^{}.key", n)); + println!("Opening {}", full_path.to_string_lossy()); + let file = std::fs::File::open(full_path).unwrap(); + let mut reader = std::io::BufReader::with_capacity(1 << 24, file); + let monomial_form = Crs::::read(&mut reader).unwrap(); + + let size = 1 << n; + + let lagrange = Crs::::from_powers(&monomial_form, size, &worker); + + let full_path = base_path.join(&format!("setup_2^{}_lagrange.key", n)); + println!("Opening {}", full_path.to_string_lossy()); + let file = std::fs::File::create(full_path).unwrap(); + let mut writer = std::io::BufWriter::with_capacity(1 << 24, file); + + lagrange.write(&mut writer).unwrap(); + } + } + + #[test] + fn test_crs_serialization() { + let worker = Worker::new(); + let mut buffer = Vec::with_capacity(1<<28); + let crs = Crs::::crs_42(1024, &worker); + crs.write(&mut buffer).expect("must serialize CRS"); + + let new = Crs::::read(&buffer[..]).expect("must deserialize CRS"); + + assert!(new == crs); + } + + use rand::{Rng}; + + pub(crate) fn make_random_field_elements( + worker: &Worker, + num_elements: usize, + ) -> Vec { + use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + make_random_field_elements_for_rng(worker, num_elements, rng) + } + + pub(crate) fn make_random_field_elements_for_rng( + worker: &Worker, + num_elements: usize, + mut rng: R + ) -> Vec { + let mut result = vec![F::zero(); num_elements]; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + worker.scope(result.len(), |scope, chunk| { + for r in result.chunks_mut(chunk) + { + let seed: [u32; 4] = rng.gen(); + let subrng = ChaChaRng::from_seed(&seed); + scope.spawn(move |_| { + let mut subrng = subrng; + for r in r.iter_mut() { + *r = subrng.gen(); + } + }); + } + }); + + result + } + + fn make_random_g1_points( + worker: &Worker, + num_elements: usize, + ) -> Vec { + use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + make_random_g1_points_for_rng(worker, num_elements, rng) + } + + fn make_random_g1_points_for_rng( + worker: &Worker, + num_elements: usize, + mut rng: R + ) -> Vec { + let mut result = vec![G::zero(); num_elements]; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + worker.scope(result.len(), |scope, chunk| { + for r in result.chunks_mut(chunk) + { + let seed: [u32; 4] = rng.gen(); + let subrng = ChaChaRng::from_seed(&seed); + scope.spawn(move |_| { + let mut subrng = subrng; + for r in r.iter_mut() { + let p: G::Projective = subrng.gen(); + *r = p.into_affine(); + } + }); + } + }); + + result + } + + #[test] + #[ignore] + fn test_multiexp_performance_on_large_data() { + use crate::pairing::bn256::{Bn256, Fr}; + use std::time::Instant; + + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + println!("Generating scalars"); + let scalars = make_random_field_elements::(&worker, max_size); + println!("Generating points"); + let points = make_random_g1_points::<::G1Affine>(&worker, max_size); + println!("Done"); + + for size in vec![1 << 23, 1 << 24, 1 << 25, 1 << 26] { + for cpus in vec![16, 32, 48, 64] { + // for cpus in vec![16, 24, 32] { + let s = &scalars[..size]; + let g = &points[..size]; + + let subworker = Worker::new_with_cpus(cpus); + + let now = Instant::now(); + + // copy-paste, but ok + + let subtime = Instant::now(); + + let scalars_repr = super::elements_into_representations::( + &subworker, + s + ).unwrap(); + + println!("Scalars conversion taken {:?}", subtime.elapsed()); + + let subtime = Instant::now(); + + let _ = multiexp::dense_multiexp::<::G1Affine>( + &subworker, + g, + &scalars_repr + ).unwrap(); + + println!("Multiexp taken {:?}", subtime.elapsed()); + + println!("Total time taken for {} points on {} cpus = {:?}", size, cpus, now.elapsed()); + } + } + } + + #[test] + #[ignore] + fn test_future_based_multiexp_performance_on_large_data() { + use crate::pairing::bn256::{Bn256, Fr}; + use std::time::Instant; + use std::sync::Arc; + + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + println!("Generating scalars"); + let scalars = make_random_field_elements::(&worker, max_size); + println!("Generating points"); + let points = make_random_g1_points::<::G1Affine>(&worker, max_size); + println!("Done"); + + for size in vec![1 << 23, 1 << 24, 1 << 25, 1 << 26] { + for cpus in vec![16, 32, 48, 64] { + // for cpus in vec![16, 24, 32] { + let s = &scalars[..size]; + let g = points[..size].to_vec(); + let g = Arc::from(g); + + let subworker = Worker::new_with_cpus(cpus); + + let now = Instant::now(); + + // copy-paste, but ok + + let subtime = Instant::now(); + + let scalars_repr = super::elements_into_representations::( + &subworker, + s + ).unwrap(); + + let scalars_repr = Arc::from(scalars_repr); + + println!("Scalars conversion taken {:?}", subtime.elapsed()); + + let subtime = Instant::now(); + + let _ = multiexp::future_based_multiexp::<::G1Affine>( + &subworker, + Arc::clone(&g), + Arc::clone(&scalars_repr) + ).wait(); + + println!("Future based multiexp taken {:?}", subtime.elapsed()); + + println!("Total time taken for {} points on {} cpus = {:?}", size, cpus, now.elapsed()); + } + } + } + + #[test] + #[ignore] + fn test_long_naive_division() { + use crate::pairing::bn256::{Bn256, Fr}; + use std::time::Instant; + + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + println!("Generating scalars"); + let scalars = make_random_field_elements::(&worker, max_size); + let divide_at = Fr::from_str("1234567890").unwrap(); + println!("Done"); + + for size in vec![1 << 23, 1 << 24, 1 << 25, 1 << 26] { + let s = &scalars[..size]; + let now = Instant::now(); + + let _ = divide_single::(s, divide_at); + + println!("Total time taken for {} points division = {:?}", size, now.elapsed()); + } + } + + fn serialize_affine_points_for_fpga( + points: &[E::G1Affine], + mut dst: W + ) -> Result<(), std::io::Error> { + use crate::pairing::ff::PrimeFieldRepr; + + println!("First point = {}", points[0]); + for p in points.iter() { + let (x, y) = p.into_xy_unchecked(); + let repr = x.into_raw_repr(); + repr.write_le(&mut dst)?; + + let repr = y.into_raw_repr(); + repr.write_le(&mut dst)?; + } + + Ok(()) + } + + fn serialize_scalars_for_fpga( + scalars: &[E::Fr], + mut dst: W + ) -> Result<(), std::io::Error> { + use crate::pairing::ff::PrimeFieldRepr; + + println!("First scalar = {}", scalars[0]); + for s in scalars.iter() { + let repr = s.into_repr(); + repr.write_le(&mut dst)?; + } + + Ok(()) + } + + fn serialize_projective_points_for_fpga( + points: &[E::G1], + mut dst: W + ) -> Result<(), std::io::Error> { + use crate::pairing::ff::PrimeFieldRepr; + + let (x, y, z) = points[1].into_xyz_unchecked(); + + println!("Second bucket (for scalar = 1): X = {}, Y = {}, Z = {}", x, y, z); + for p in points.iter() { + let (x, y, z) = p.into_xyz_unchecked(); + let repr = x.into_raw_repr(); + repr.write_le(&mut dst)?; + + let repr = y.into_raw_repr(); + repr.write_le(&mut dst)?; + + let repr = z.into_raw_repr(); + repr.write_le(&mut dst)?; + } + + Ok(()) + } + + fn simulate_first_buckets(points: &[E::G1Affine], scalars: &[E::Fr], c: usize, random_point: E::G1Affine) -> Vec { + use crate::pairing::ff::ScalarEngine; + use crate::pairing::ff::PrimeFieldRepr; + + let skip = 0; + let mask = (1u64 << c) - 1u64; + let p = random_point.into_projective(); + let mut buckets = vec![p; 1 << c]; + + for (exp, point) in scalars.iter().zip(points.iter()) { + let this_exp = exp.into_repr(); + + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + buckets[this_exp as usize].add_assign_mixed(point); + } + + buckets + } + + fn test_multiexp_bn254(max_size: usize, sizes: Vec, num_cpus: Vec) { + use crate::pairing::bn256::Bn256; + test_multiexps_inner::(max_size, sizes, num_cpus); + } + + fn test_multiexp_bn254_compact(max_size: usize, sizes: Vec, num_cpus: Vec) { + use crate::pairing::compact_bn256::Bn256; + test_multiexps_inner::(max_size, sizes, num_cpus); + } + + fn test_multiexps_inner(max_size: usize, sizes: Vec, num_cpus: Vec) { + use std::time::Instant; + use std::sync::Arc; + + let worker = Worker::new(); + + println!("Generating scalars"); + let scalars = make_random_field_elements::(&worker, max_size); + println!("Generating points"); + let points = make_random_g1_points::(&worker, max_size); + println!("Done"); + + for size in sizes { + for &cpus in &num_cpus { + let s = &scalars[..size]; + let g = points[..size].to_vec(); + + let subworker = Worker::new_with_cpus(cpus); + + let scalars_repr = super::elements_into_representations::( + &subworker, + s + ).unwrap(); + + let subtime = Instant::now(); + + let _ = multiexp::dense_multiexp::( + &subworker, + &g, + &scalars_repr + ).unwrap(); + + println!("Dense simple multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::dense_unrolled_multiexp_with_prefetch::<::G1Affine>( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Dense unrolled multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::dense_multiexp_uniform::( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Dense uniform multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::stack_allocated_dense_multiexp::<::G1Affine>( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Dense stack multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::map_reduce_multiexp::( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Map reduce multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::producer_consumer_dense_multiexp::<::G1Affine>( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("ProdCons stack multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::stack_allocated_uncompensated_dense_multiexp::<::G1Affine>( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Uncompensated stack multiexp of size {} taken {:?} on {} cpus", size, subtime.elapsed(), cpus); + + // let subtime = Instant::now(); + + // let _ = multiexp::dense_multiexp_with_manual_unrolling::<::G1Affine>( + // &subworker, + // &g, + // &scalars_repr + // ).unwrap(); + + // println!("Dense manually unrolled multiexp taken {:?} on {} cpus", subtime.elapsed(), cpus); + + // let g = Arc::from(g); + // let scalars_repr = Arc::from(scalars_repr); + + // let subtime = Instant::now(); + + // let _ = multiexp::future_based_multiexp::<::G1Affine>( + // &subworker, + // Arc::clone(&g), + // Arc::clone(&scalars_repr) + // ).wait(); + + // println!("Future based multiexp taken {:?} on {} cpus", subtime.elapsed(), cpus); + } + } + } + + // fn test_multiexps_over_window_sizes_bn254(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + // use crate::pairing::bn256::Bn256; + // test_multiexps_over_window_sizes::(max_size, sizes, num_cpus, windows); + // } + + // fn test_multiexps_over_window_sizes_bn254_compact(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + // use crate::pairing::compact_bn256::Bn256; + // test_multiexps_over_window_sizes::(max_size, sizes, num_cpus, windows); + // } + + // fn test_multiexps_over_window_sizes(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + // use std::time::Instant; + // use std::sync::Arc; + + // let worker = Worker::new(); + + // println!("Generating scalars"); + // let scalars = make_random_field_elements::(&worker, max_size); + // println!("Generating points"); + // let points = make_random_g1_points::(&worker, max_size); + // println!("Done"); + + // for size in sizes { + // for &cpus in &num_cpus { + // let mut subresults = vec![]; + // for &window in &windows { + // let s = &scalars[..size]; + // let g = points[..size].to_vec(); + + // let subworker = Worker::new_with_cpus(cpus); + + // let scalars_repr = super::elements_into_representations::( + // &subworker, + // s + // ).unwrap(); + + // let subtime = Instant::now(); + + // let window = window as u32; + + // let _ = multiexp::map_reduce_multiexp_over_fixed_window::( + // &subworker, + // &g, + // &scalars_repr, + // window + // ).unwrap(); + + // subresults.push((window, subtime.elapsed().as_millis())); + + // // println!("Map reduce multiexp of size {} taken {:?} on {} cpus with window size = {}", size, subtime.elapsed(), cpus, window); + // } + + // subresults.sort_by(|a, b| { + // a.1.cmp(&b.1) + // }); + + // println!("Map reduce multiexp of size {} on {} CPUs:", size, cpus); + // for (window, time_ms) in &subresults[0..3] { + // println!("Window = {}, time = {} ms", window, time_ms); + // } + // } + // } + // } + + // fn test_buffered_multiexps_bn254_compact(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec, buffer_sizes: Vec) { + // use crate::pairing::compact_bn256::Bn256; + // test_buffered_multiexp::(max_size, sizes, num_cpus, windows, buffer_sizes); + // } + + // fn test_buffered_multiexp(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec, buffer_sizes: Vec) { + // use std::time::Instant; + // use std::sync::Arc; + + // let worker = Worker::new(); + + // println!("Generating scalars"); + // let scalars = make_random_field_elements::(&worker, max_size); + // println!("Generating points"); + // let points = make_random_g1_points::(&worker, max_size); + // println!("Done"); + + // for size in sizes { + // for &cpus in &num_cpus { + // for &buffer_size in &buffer_sizes { + // let mut subresults = vec![]; + // for &window in &windows { + // let s = &scalars[..size]; + // let g = points[..size].to_vec(); + + // let subworker = Worker::new_with_cpus(cpus); + + // let scalars_repr = super::elements_into_representations::( + // &subworker, + // s + // ).unwrap(); + + // let subtime = Instant::now(); + + // let window = window as u32; + + // let _ = multiexp::buffered_multiexp_over_fixed_window_and_buffer_size::( + // &subworker, + // &g, + // &scalars_repr, + // window, + // buffer_size + // ).unwrap(); + + // subresults.push((window, subtime.elapsed().as_millis())); + + // // println!("Map reduce multiexp of size {} taken {:?} on {} cpus with window size = {}", size, subtime.elapsed(), cpus, window); + // } + + // subresults.sort_by(|a, b| { + // a.1.cmp(&b.1) + // }); + + // println!("Map reduce multiexp of size {} on {} CPUs with buffer size {}:", size, cpus, buffer_size); + // for (window, time_ms) in &subresults[0..3] { + // println!("Window = {}, time = {} ms", window, time_ms); + // } + // } + // } + // } + // } + + // fn test_future_based_multiexps_over_window_sizes_bn254_compact(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + // use crate::pairing::compact_bn256::Bn256; + // test_future_based_multiexps_over_window_sizes::(max_size, sizes, num_cpus, windows); + // } + + // fn test_future_based_multiexps_over_window_sizes_bn254(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + // use crate::pairing::bn256::Bn256; + // test_future_based_multiexps_over_window_sizes::(max_size, sizes, num_cpus, windows); + // } + + // #[ignore] + // #[test] + // fn test_optimal_bn254_multiexp() { + // // use crate::pairing::bn256::Bn256; + // use crate::pairing::compact_bn256::Bn256; + // test_optimal_multiexp::(2, 1 << 24, 24, 12, true); + // test_optimal_multiexp::(2, 1 << 24, 24, 12, false); + // test_optimal_multiexp::(2, 1 << 25, 24, 11, true); + // test_optimal_multiexp::(2, 1 << 25, 24, 11, false); + // } + + // fn test_optimal_multiexp(max_parallel_jobs: usize, max_size: usize, cpus_per_job: usize, window: usize, same_base: bool) { + // use futures::executor::block_on; + // use futures::future::join_all; + + // use std::time::Instant; + // use std::sync::Arc; + // use crate::source::FullDensity; + + // let mut bases = vec![]; + // let mut scalars = vec![]; + // let worker = Worker::new(); + + // assert!(max_parallel_jobs >= 1); + + // use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + // let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + // for _ in 0..max_parallel_jobs { + // let seed: [u32; 4] = rng.gen(); + // let mut subrng = ChaChaRng::from_seed(&seed); + + // let sc = make_random_field_elements_for_rng::(&worker, max_size, &mut subrng); + // let p = make_random_g1_points_for_rng::(&worker, max_size, &mut subrng); + // let s = super::elements_into_representations::( + // &worker, + // &sc + // ).unwrap(); + + // bases.push(Arc::from(p)); + // scalars.push(Arc::from(s)); + // } + + // for num_jobs in 1..=max_parallel_jobs { + // let mut jobs = vec![]; + // let subworker = Worker::new_with_cpus(cpus_per_job * num_jobs); + // let subtime = Instant::now(); + // let window = window as u32; + + // for idx in 0..num_jobs { + // let id = if same_base { + // 0 + // } else { + // idx + // }; + // let p = Arc::clone(&bases[id]); + // let s = Arc::clone(&scalars[idx]); + + // let job = multiexp::future_based_dense_multiexp_over_fixed_width_windows( + // &subworker, + // p, + // s, + // window + // ); + + // // let job = multiexp::multiexp_with_fixed_width::<_, _, _, _>( + // // &subworker, + // // (p, 0), + // // FullDensity, + // // s, + // // window + // // ); + + // jobs.push(job); + // } + + // let joiner = join_all(jobs); + + // let _ = block_on(joiner); + + // let elapsed = subtime.elapsed(); + // if same_base { + // print!("For same bases: "); + // } else { + // print!("For different bases: "); + // } + // println!("{} jobs of size {} with {} CPUs per job and {} bits window taken {:?}", num_jobs, max_size, cpus_per_job, window, elapsed); + // } + // } + + // #[ignore] + // #[test] + // fn test_l3_shared_multiexp_bn254() { + // // use crate::pairing::bn256::Bn256; + // use crate::pairing::compact_bn256::Bn256; + // test_l3_shared_multiexp::(4, 1 << 24, 24, 12); + // test_l3_shared_multiexp::(4, 1 << 25, 24, 12); + // test_optimal_multiexp::(1, 1 << 24, 24, 12, true); + // test_optimal_multiexp::(1, 1 << 25, 24, 12, true); + // test_optimal_multiexp::(1, 1 << 24, 16, 16, true); + // test_optimal_multiexp::(1, 1 << 25, 16, 16, true); + // test_optimal_multiexp::(2, 1 << 24, 24, 12, true); + // test_optimal_multiexp::(2, 1 << 25, 24, 12, true); + // test_optimal_multiexp::(3, 1 << 24, 16, 16, true); + // test_optimal_multiexp::(3, 1 << 25, 16, 16, true); + // test_optimal_multiexp::(4, 1 << 24, 16, 16, true); + // test_optimal_multiexp::(4, 1 << 25, 16, 16, true); + // } + + // fn test_l3_shared_multiexp(max_parallel_jobs: usize, max_size: usize, cpus_per_job: usize, window: usize) { + // use std::time::Instant; + + // let mut bases = vec![]; + // let mut scalars = vec![]; + // let worker = Worker::new(); + + // use rand::{XorShiftRng, SeedableRng, Rand, Rng, ChaChaRng}; + + // let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + // for _ in 0..max_parallel_jobs { + // let seed: [u32; 4] = rng.gen(); + // let mut subrng = ChaChaRng::from_seed(&seed); + + // let sc = make_random_field_elements_for_rng::(&worker, max_size, &mut subrng); + // let p = make_random_g1_points_for_rng::(&worker, max_size, &mut subrng); + // let s = super::elements_into_representations::( + // &worker, + // &sc + // ).unwrap(); + + // bases.push(p); + // scalars.push(s); + // } + + // for j in 1..=max_parallel_jobs { + // let subworker = Worker::new_with_cpus(cpus_per_job * j); + + // let subtime = Instant::now(); + + // let mut exps = vec![]; + // for i in 0..j { + // exps.push(&scalars[i][..]); + // } + + // println!("Running for {} parallel job", j); + // let _ = multiexp::l3_shared_multexp( + // &subworker, + // &bases[0][..], + // &exps[..], + // ).unwrap(); + + // let elapsed = subtime.elapsed(); + + // println!("L3 shared multiexp for {} jobs of size {} with {} CPUs per job and {} bits window taken {:?}", j, max_size, cpus_per_job, window, elapsed); + // } + // } + + fn test_future_based_multiexps_over_window_sizes(max_size: usize, sizes: Vec, num_cpus: Vec, windows: Vec) { + use std::time::Instant; + use std::sync::Arc; + use crate::source::FullDensity; + + let worker = Worker::new(); + + println!("Generating scalars"); + let scalars = make_random_field_elements::(&worker, max_size); + println!("Generating points"); + let points = make_random_g1_points::(&worker, max_size); + println!("Done"); + + for size in sizes { + for &cpus in &num_cpus { + let mut subresults = vec![]; + let mut alt_subresults = vec![]; + + let s = &scalars[..size]; + let g = points[..size].to_vec(); + + let scalars_repr = super::elements_into_representations::( + &worker, + s + ).unwrap(); + + let g = Arc::from(g); + let s = Arc::from(scalars_repr); + + for &window in &windows { + let subworker = Worker::new_with_cpus(cpus); + + let subtime = Instant::now(); + + let window = window as u32; + + let _ = multiexp::future_based_dense_multiexp_over_fixed_width_windows( + &subworker, + Arc::clone(&g), + Arc::clone(&s), + window + ).wait(); + + alt_subresults.push((window, subtime.elapsed().as_millis())); + + let subtime = Instant::now(); + + let _ = multiexp::multiexp_with_fixed_width::<_, _, _, _>( + &subworker, + (Arc::clone(&g), 0), + FullDensity, + Arc::clone(&s), + window + ).wait(); + + subresults.push((window, subtime.elapsed().as_millis())); + } + + subresults.sort_by(|a, b| { + a.1.cmp(&b.1) + }); + + alt_subresults.sort_by(|a, b| { + a.1.cmp(&b.1) + }); + + println!("Standard future based multiexp of size {} on {} CPUs:", size, cpus); + for (window, time_ms) in &subresults[0..3] { + println!("Window = {}, time = {} ms", window, time_ms); + } + + println!("Tuned future based multiexp of size {} on {} CPUs:", size, cpus); + for (window, time_ms) in &alt_subresults[0..3] { + println!("Window = {}, time = {} ms", window, time_ms); + } + } + } + } + + #[test] + #[ignore] + fn test_different_multiexps() { + test_multiexp_bn254(1<<20, vec![1 << 20], vec![3, 4, 6]); + } + + #[test] + #[ignore] + fn test_large_data_different_multiexps() { + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + + let sizes = vec![1 << 23, 1 << 24, 1 << 25, 1 << 26]; + let cpus = vec![8, 12, 16, 24, 32, 48]; + // test_multiexp_bn254(max_size, sizes, cpus); + test_multiexp_bn254_compact(max_size, sizes, cpus); + } + + // #[test] + // #[ignore] + // fn test_small_data_different_windows() { + // let max_size = 1 << 20; + + // let sizes = vec![1 << 16, 1 << 17, 1 << 18, 1 << 19, 1 << 20]; + // let cpus = vec![3, 4, 6]; + // let windows = vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]; + // test_multiexps_over_window_sizes_bn254(max_size, sizes, cpus, windows); + // } + + // #[test] + // #[ignore] + // fn test_large_data_different_windows_multiexp() { + // let max_size = 1 << 26; + // let worker = Worker::new(); + + // assert!(worker.cpus >= 16, "should be tested only on large machines"); + + // let sizes = vec![1 << 20, 1 << 21, 1 << 22, 1 << 23, 1 << 24, 1 << 25, 1 << 26]; + // let cpus = vec![8, 12, 16, 24, 32, 48]; + // let windows = vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]; + // // test_multiexps_over_window_sizes_bn254(max_size, sizes, cpus, windows); + // test_multiexps_over_window_sizes_bn254_compact(max_size, sizes, cpus, windows); + // } + + // #[test] + // #[ignore] + // fn test_large_data_buffered_multiexp() { + // let max_size = 1 << 26; + // let worker = Worker::new(); + + // assert!(worker.cpus >= 16, "should be tested only on large machines"); + + // let sizes = vec![1 << 20, 1 << 21, 1 << 22, 1 << 23, 1 << 24, 1 << 25, 1 << 26]; + // let cpus = vec![8, 12, 16, 24, 32, 48]; + // let windows = vec![10, 11, 12, 13, 14, 15, 16]; + // let buffer_sizes = vec![4, 8, 16, 32, 64, 128]; + // // test_multiexps_over_window_sizes_bn254(max_size, sizes, cpus, windows); + // test_buffered_multiexps_bn254_compact(max_size, sizes, cpus, windows, buffer_sizes); + // } + + // #[test] + // #[ignore] + // fn future_based_test_large_data_different_windows() { + // let max_size = 1 << 26; + // let worker = Worker::new(); + + // assert!(worker.cpus >= 16, "should be tested only on large machines"); + + // let sizes = vec![1 << 20, 1 << 21, 1 << 22, 1 << 23, 1 << 24, 1 << 25, 1 << 26]; + // let cpus = vec![8, 12, 16, 24, 32, 48]; + // let windows = vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]; + // // test_future_based_multiexps_over_window_sizes_bn254(max_size, sizes, cpus, windows); + // test_future_based_multiexps_over_window_sizes_bn254_compact(max_size, sizes, cpus, windows); + // } + + fn make_random_points_with_unknown_discrete_log( + dst: &[u8], + seed: &[u8], + num_points: usize + ) -> Vec { + let mut result = vec![]; + + use rand::{Rng, SeedableRng}; + use rand::chacha::ChaChaRng; + // Create an RNG based on the outcome of the random beacon + let mut rng = { + // if we use Blake hasher + let input: Vec = dst.iter().chain(seed.iter()).cloned().collect(); + let h = blake2s_simd::blake2s(&input); + assert!(h.as_bytes().len() == 32); + let mut seed = [0u32; 8]; + for (i, chunk) in h.as_bytes().chunks_exact(8).enumerate() { + seed[i] = (&chunk[..]).read_u32::().expect("digest is large enough for this to work"); + } + + ChaChaRng::from_seed(&seed) + }; + + for _ in 0..num_points { + let point: E::G1 = rng.gen(); + + result.push(point.into_affine()); + } + + result + } + + #[test] + fn produce_fpga_test_vectors() { + use crate::pairing::ff::ScalarEngine; + use crate::pairing::bls12_381::Bls12; + + let worker =crate::worker::Worker::new(); + + let random_point = make_random_points_with_unknown_discrete_log::( + &b"fpga_dst"[..], + &hex::decode(crate::constants::ETH_BLOCK_10_000_000_HASH).unwrap(), + 1 + )[0]; + + let (x, y) = random_point.into_xy_unchecked(); + println!("Random point in Montgomery form: X = {}, Y = {}", x.into_raw_repr(), y.into_raw_repr()); + + let base_path = std::path::Path::new("./"); + + for n in vec![6, 7, 20] { + let points_path = base_path.join(&format!("input_points_2^{}.key", n)); + let scalars_path = base_path.join(&format!("input_scalars_2^{}.key", n)); + let buckets_path = base_path.join(&format!("output_buckets_2^{}.key", n)); + + println!("Opening {}", points_path.to_string_lossy()); + + let file = std::fs::File::create(points_path).unwrap(); + let mut points_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(scalars_path).unwrap(); + let mut scalars_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(buckets_path).unwrap(); + let mut buckets_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let size = 1 << n; + + let scalars = make_random_field_elements::<::Fr>(&worker, size); + let points = make_random_g1_points::<::G1Affine>(&worker, size); + let buckets = simulate_first_buckets::(&points, &scalars, 13, random_point); + + serialize_affine_points_for_fpga::(&points, &mut points_file).unwrap(); + serialize_scalars_for_fpga::(&scalars, &mut scalars_file).unwrap(); + serialize_projective_points_for_fpga::(&buckets, &mut buckets_file).unwrap(); + } + } + + #[test] + fn produce_bn254_fpga_test_vectors() { + use crate::pairing::ff::ScalarEngine; + use crate::pairing::bn256::{Bn256, Fr}; + + let bucket_width = 16; + let worker = crate::worker::Worker::new(); + + let random_point = make_random_points_with_unknown_discrete_log::( + &b"fpga_dst"[..], + &hex::decode(crate::constants::ETH_BLOCK_10_000_000_HASH).unwrap(), + 1 + )[0]; + + let (x, y) = random_point.into_xy_unchecked(); + println!("Random point in Montgomery form: X = {}, Y = {}", x.into_raw_repr(), y.into_raw_repr()); + + let base_path = std::path::Path::new("./"); + + let mut num_buckets = (Fr::NUM_BITS as usize) / bucket_width; + if (Fr::NUM_BITS as usize) % bucket_width != 0 { + num_buckets += 1; + } + + for n in vec![6, 7, 20] { + let points_path = base_path.join(&format!("bn_254_input_points_2^{}_width_{}.key", n, bucket_width)); + let scalars_path = base_path.join(&format!("bn_254_input_scalars_2^{}_width_{}.key", n, bucket_width)); + let initial_buckets_path = base_path.join(&format!("bn_254_input_buckets_2^{}_width_{}.key", n, bucket_width)); + let buckets_path = base_path.join(&format!("bn_254_output_buckets_2^{}_width_{}.key", n, bucket_width)); + + println!("Opening {}", points_path.to_string_lossy()); + + let file = std::fs::File::create(points_path).unwrap(); + let mut points_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(scalars_path).unwrap(); + let mut scalars_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(initial_buckets_path).unwrap(); + let mut initial_buckets_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(buckets_path).unwrap(); + let mut buckets_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let size = 1 << n; + + let scalars = make_random_field_elements::<::Fr>(&worker, size); + let points = make_random_g1_points::<::G1Affine>(&worker, size); + let initial_buckets = vec![random_point.into_projective(); num_buckets * (1 << bucket_width)]; + let buckets = simulate_first_buckets::(&points, &scalars, bucket_width, random_point); + + serialize_affine_points_for_fpga::(&points, &mut points_file).unwrap(); + serialize_scalars_for_fpga::(&scalars, &mut scalars_file).unwrap(); + serialize_projective_points_for_fpga::(&initial_buckets, &mut initial_buckets_file).unwrap(); + serialize_projective_points_for_fpga::(&buckets, &mut buckets_file).unwrap(); + } + } + + #[test] + fn produce_fpga_window_12_test_vectors() { + let width = 12; + use crate::pairing::ff::ScalarEngine; + use crate::pairing::bls12_381::Bls12; + + let worker = crate::worker::Worker::new(); + + let random_point = make_random_points_with_unknown_discrete_log::( + &b"fpga_dst"[..], + &hex::decode(crate::constants::ETH_BLOCK_10_000_000_HASH).unwrap(), + 1 + )[0]; + + let (x, y) = random_point.into_xy_unchecked(); + println!("Random point in Montgomery form: X = {}, Y = {}", x.into_raw_repr(), y.into_raw_repr()); + + let base_path = std::path::Path::new("./"); + + for n in vec![6, 7, 20] { + let points_path = base_path.join(&format!("input_points_2^{}.key", n)); + let scalars_path = base_path.join(&format!("input_scalars_2^{}.key", n)); + let buckets_path = base_path.join(&format!("width_{}_output_buckets_2^{}.key", width, n)); + + println!("Opening {}", points_path.to_string_lossy()); + + let file = std::fs::File::create(points_path).unwrap(); + let mut points_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(scalars_path).unwrap(); + let mut scalars_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let file = std::fs::File::create(buckets_path).unwrap(); + let mut buckets_file = std::io::BufWriter::with_capacity(1 << 24, file); + + let size = 1 << n; + + let scalars = make_random_field_elements::<::Fr>(&worker, size); + let points = make_random_g1_points::<::G1Affine>(&worker, size); + let buckets = simulate_first_buckets::(&points, &scalars, width, random_point); + + serialize_affine_points_for_fpga::(&points, &mut points_file).unwrap(); + serialize_scalars_for_fpga::(&scalars, &mut scalars_file).unwrap(); + serialize_projective_points_for_fpga::(&buckets, &mut buckets_file).unwrap(); + } + } +} + diff --git a/src/lib.rs b/src/lib.rs index 0f71f9a28..e0d1180dd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,5 @@ -#![allow(unused_imports)] -#![allow(unused_macros)] +#![ allow( dead_code, unused_imports, unused_mut, unused_variables, unused_macros, unused_assignments, unreachable_patterns ) ] + #[macro_use] extern crate cfg_if; @@ -8,6 +8,11 @@ extern crate rand; extern crate bit_vec; extern crate byteorder; +pub use pairing::*; + +use crate::pairing::ff as ff; +pub use ff::*; + #[macro_use] mod log; @@ -16,12 +21,31 @@ pub mod groth16; #[cfg(feature = "gm17")] pub mod gm17; + #[cfg(feature = "sonic")] pub mod sonic; +#[cfg(feature = "plonk")] +pub mod plonk; + +#[macro_use] +#[cfg(feature = "plonk")] +extern crate lazy_static; + +#[cfg(feature = "marlin")] +pub mod marlin; + +#[cfg(feature = "gpu")] +pub mod gpu; + +#[cfg(any(feature = "marlin", feature = "plonk"))] +pub mod kate_commitment; + +pub mod constants; mod group; mod source; mod multiexp; +mod prefetch; #[cfg(test)] mod tests; @@ -33,12 +57,12 @@ cfg_if! { mod multicore; pub mod worker { - pub use crate::multicore::*; + pub use super::multicore::*; } } else { mod singlecore; pub mod worker { - pub use crate::singlecore::*; + pub use super::singlecore::*; } } } diff --git a/src/marlin/generator.rs b/src/marlin/generator.rs new file mode 100644 index 000000000..5905266d0 --- /dev/null +++ b/src/marlin/generator.rs @@ -0,0 +1,801 @@ +use crate::log::Stopwatch; + +use rand::Rng; + +use std::sync::Arc; +use std::collections::HashMap; + +use crate::pairing::{ + Engine, + Wnaf, + CurveProjective, + CurveAffine +}; + +use crate::pairing::ff::{ + PrimeField, + Field +}; + +use super::{ + IndexedSetup, +}; + +use crate::{ + SynthesisError, + Circuit, + ConstraintSystem, + LinearCombination, + Variable, + Index +}; + +use crate::domain::{ + EvaluationDomain, + Scalar +}; + +use crate::worker::{ + Worker +}; + +use crate::plonk::polynomials::*; + +/// This is our assembly structure that we'll use to synthesize the +/// circuit into to perform indexing +struct KeypairAssembly { + num_inputs: usize, + num_aux: usize, + num_constraints: usize, + num_non_zero_in_a: usize, + num_non_zero_in_b: usize, + num_non_zero_in_c: usize, + // these are indexed by variable, and then by index in certain constraint + a_rows: Vec>, + b_rows: Vec>, + c_rows: Vec>, + deduplication_scratch: HashMap, +} + +impl KeypairAssembly { + fn pad_to_square(&mut self) -> Result<(), SynthesisError> { + let size = if self.num_inputs + self.num_aux >= self.num_constraints { + self.num_inputs + self.num_aux + } else { + self.num_constraints + }; + + self.pad_square_to_size(size) + } + + fn pad_square_to_size(&mut self, size: usize) -> Result<(), SynthesisError> { + for _ in (self.num_inputs + self.num_aux)..size { + self.alloc(|| "", || { + Ok(E::Fr::one()) + })?; + } + + self.a_rows.resize(size, LinearCombination::zero()); + self.b_rows.resize(size, LinearCombination::zero()); + self.c_rows.resize(size, LinearCombination::zero()); + + self.num_constraints = size; + + Ok(()) + } + + fn into_indexer_input(self, _worker: &Worker) -> + Result<(usize, usize, (Vec>, Vec> , Vec>)), SynthesisError> + { + let domain_h_size = self.num_inputs + self.num_aux; + let domain_h_size = domain_h_size.next_power_of_two(); + + let domain_k_size = *[self.num_non_zero_in_a, self.num_non_zero_in_b, self.num_non_zero_in_c].iter().max().expect("must exist"); + let domain_k_size = domain_k_size.next_power_of_two(); + + fn into_sparse_matrix( + constraints: Vec>, + num_inputs: usize) + -> Vec> { + let mut result = Vec::with_capacity(constraints.len()); + for row in constraints.into_iter() { + let mut new = Vec::with_capacity(row.0.len()); + for (var, coeff) in row.0.into_iter() { + match var { + Variable(Index::Input(i)) => { + new.push((i, coeff)); + }, + Variable(Index::Aux(i)) => { + new.push((i+num_inputs, coeff)); + } + } + } + + result.push(new); + } + + result + } + + let num_inputs = self.num_inputs; + + let a_matrix = into_sparse_matrix(self.a_rows, num_inputs); + let b_matrix = into_sparse_matrix(self.b_rows, num_inputs); + let c_matrix = into_sparse_matrix(self.c_rows, num_inputs); + + Ok(( + domain_h_size, + domain_k_size, + (a_matrix, b_matrix, c_matrix) + )) + } +} + +use crate::plonk::domains::Domain; + +pub(crate) fn materialize_domain_elements(domain: &Domain, worker: &Worker) -> Vec { + let mut values = vec![F::zero(); domain.size as usize]; + let generator = domain.generator; + + worker.scope(values.len(), |scope, chunk| { + for (i, values) in values.chunks_mut(chunk).enumerate() + { + scope.spawn(move |_| { + let mut current_power = generator.pow(&[(i*chunk) as u64]); + + for p in values { + *p = current_power; + current_power.mul_assign(&generator); + } + }); + } + }); + + values +} + +pub(crate) fn eval_unnormalized_bivariate_lagrange_poly_over_diaginal( + vanishing_degree: u64, + evaluate_on_domain: &Domain, + worker: &Worker +) -> Vec { + let mut values = vec![F::zero(); evaluate_on_domain.size as usize]; + + let mut repr = F::Repr::default(); + repr.as_mut()[0] = vanishing_degree; + let size_as_fe = F::from_repr(repr).expect("must convert domain size into field element"); + + // we need to calculate elements like X^{S - 1} where S is a domain size + // so for omega^0 we have omega ^ 0 = 1 + // for omega^1 we have omega^{S-1} + // for omega^2 we have (omega^2)^{S-1} = (omega^{S-1}) ^ 2 + // and continue to distribute powers this way + let generator_in_size_minus_one = evaluate_on_domain.generator.pow(&[vanishing_degree - 1u64]); + + // each element is size * X ^ {size - 1}, so we just distribute powers of `generator_in_size_minus_one` + worker.scope(values.len(), |scope, chunk| { + for (i, values) in values.chunks_mut(chunk).enumerate() + { + scope.spawn(move |_| { + let mut current_power = generator_in_size_minus_one.pow(&[(i*chunk) as u64]); + current_power.mul_assign(&size_as_fe); + + for p in values { + *p = current_power; + current_power.mul_assign(&generator_in_size_minus_one); + } + }); + } + }); + + values +} + +pub(crate) fn eval_unnormalized_bivariate_lagrange_poly_over_different_inputs( + alpha: F, + vanishing_poly_size: u64, + evaluate_on_domain: &Domain, + worker: &Worker +) -> Vec { + // (vanishing(X) - vanishing(alpha)) / (x - alpha) + // we evaluate it on the domain where vanishing(X) == 0 + // and make it as + // vanishing(alpha) / (alpha - x) + let vanishing_at_alpha = evaluate_vanishing_for_size(&alpha, vanishing_poly_size); + let inv_vanishing_at_alpha = vanishing_at_alpha.inverse().ok_or(SynthesisError::DivisionByZero).expect("should not vanish on random x"); + let inverses = materialize_domain_elements(evaluate_on_domain, &worker); + let mut inverses = Polynomial::from_values(inverses).expect("must fit into the domain"); + inverses.map(&worker, |element| { + let mut tmp = alpha; + tmp.sub_assign(&*element); + tmp.mul_assign(&inv_vanishing_at_alpha); + + *element = tmp; + }); + + inverses.batch_inversion(&worker).expect("must inverse as there are no zeroes"); + + inverses.into_coeffs() +} + +pub(crate) fn reindex_from_one_domain_to_another_assuming_natural_ordering( + domain_0: &Domain, + domain_1: &Domain, + index: usize +) -> usize { + assert!(domain_0.size <= domain_1.size); + + let lde_factor = domain_1.size / domain_0.size; + // in natural ordering element of index i will go into index i*lde_factor + + let new_index = index * (lde_factor as usize); + + new_index +} + +fn reindex_from_one_domain_to_another_assuming_bitreversed_ordering( + domain_0: &Domain, + domain_1: &Domain, + index: usize +) -> usize { + assert!(domain_0.size <= domain_1.size); + + // in bitreversed ordering element of index i will always be in the beginning and unchanged index + + index +} + +impl ConstraintSystem for KeypairAssembly { + type Root = Self; + + fn alloc( + &mut self, + _: A, + _: F + ) -> Result + where F: FnOnce() -> Result, A: FnOnce() -> AR, AR: Into + { + // There is no assignment, so we don't even invoke the + // function for obtaining one. + + let index = self.num_aux; + self.num_aux += 1; + + Ok(Variable(Index::Aux(index))) + } + + fn alloc_input( + &mut self, + _: A, + _: F + ) -> Result + where F: FnOnce() -> Result, A: FnOnce() -> AR, AR: Into + { + // There is no assignment, so we don't even invoke the + // function for obtaining one. + + let index = self.num_inputs; + self.num_inputs += 1; + + Ok(Variable(Index::Input(index))) + } + + fn enforce( + &mut self, + _: A, + a: LA, + b: LB, + c: LC + ) + where A: FnOnce() -> AR, AR: Into, + LA: FnOnce(LinearCombination) -> LinearCombination, + LB: FnOnce(LinearCombination) -> LinearCombination, + LC: FnOnce(LinearCombination) -> LinearCombination + { + fn sort_vars(v_0: &Variable, v_1: &Variable) -> std::cmp::Ordering { + match (v_0, v_1) { + (Variable(Index::Input(v_0_value)), Variable(Index::Input(v_1_value))) => { + v_0_value.cmp(v_1_value) + }, + (Variable(Index::Input(_)), Variable(Index::Aux(_))) => { + std::cmp::Ordering::Less + }, + (Variable(Index::Aux(_)), Variable(Index::Input(_))) => { + std::cmp::Ordering::Greater + }, + (Variable(Index::Aux(v_0_value)), Variable(Index::Aux(v_1_value))) => { + v_0_value.cmp(v_1_value) + } + } + } + + + fn deduplicate_with_sort( + lc: LinearCombination, + scratch: &mut HashMap + ) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return lc; + } + + for (var, coeff) in lc.0.into_iter() { + if let Some(existing_index) = scratch.get_mut(&var) { + existing_index.add_assign(&coeff); + } else { + scratch.insert(var, coeff); + } + } + + let mut deduped_vec: Vec<(Variable, E::Fr)> = scratch.drain().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + deduped_vec.sort_by(|(a, _), (b, _)| sort_vars(a, b)); + + scratch.clear(); + + LinearCombination(deduped_vec) + } + + let a = deduplicate_with_sort(a(LinearCombination::zero()), &mut self.deduplication_scratch); + let b = deduplicate_with_sort(b(LinearCombination::zero()), &mut self.deduplication_scratch); + let c = deduplicate_with_sort(c(LinearCombination::zero()), &mut self.deduplication_scratch); + + // keep track on number of non-zero entries in a/b/c + let num_non_zero_into_a = a.as_ref().len(); + let num_non_zero_into_b = b.as_ref().len(); + let num_non_zero_into_c = c.as_ref().len(); + + let (a, b) = { + self.num_non_zero_in_a += num_non_zero_into_a; + self.num_non_zero_in_b += num_non_zero_into_b; + + (a, b) + }; + + // // keep track on A/B densities and swap if necessary + + // let (a, b) = if self.num_non_zero_in_a >= self.num_non_zero_in_b { + // // there are more in a than in b + // if num_non_zero_into_a >= num_non_zero_into_b { + // // swap a/b + // self.num_non_zero_in_a += num_non_zero_into_b; + // self.num_non_zero_in_b += num_non_zero_into_a; + + // (b, a) + // } else { + // // don't swap + // self.num_non_zero_in_a += num_non_zero_into_a; + // self.num_non_zero_in_b += num_non_zero_into_b; + + // (a, b) + // } + // } else { + // if num_non_zero_into_b >= num_non_zero_into_a { + // // swap a/b + // self.num_non_zero_in_a += num_non_zero_into_b; + // self.num_non_zero_in_b += num_non_zero_into_a; + + // (b, a) + // } else { + // // don't swap + // self.num_non_zero_in_a += num_non_zero_into_a; + // self.num_non_zero_in_b += num_non_zero_into_b; + + // (a, b) + // } + // }; + + self.num_non_zero_in_c += num_non_zero_into_c; + + self.a_rows.push(a); + self.b_rows.push(b); + self.c_rows.push(c); + + self.num_constraints += 1; + } + + fn push_namespace(&mut self, _: N) + where NR: Into, N: FnOnce() -> NR + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) + { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +/// Create parameters for a circuit, given some toxic waste. +pub fn generate_parameters( + circuit: C, +) -> Result, SynthesisError> + where E: Engine, C: Circuit +{ + let mut assembly = KeypairAssembly { + num_inputs: 0, + num_aux: 0, + num_constraints: 0, + num_non_zero_in_a: 0, + num_non_zero_in_b: 0, + num_non_zero_in_c: 0, + a_rows: vec![], + b_rows: vec![], + c_rows: vec![], + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + }; + + // Allocate the "one" input variable + assembly.alloc_input(|| "CS::ONE", || Ok(E::Fr::one()))?; + + // Synthesize the circuit. + circuit.synthesize(&mut assembly)?; + + // // Input constraints to ensure full density of IC query + // // x * 0 = 0 + // for i in 0..assembly.num_inputs { + // assembly.enforce(|| "", + // |lc| lc + Variable(Index::Input(i)), + // |lc| lc, + // |lc| lc, + // ); + // } + + assembly.pad_to_square()?; + + let worker = Worker::new(); + + let (domain_h_size, domain_k_size, (a_matrix, b_matrix, c_matrix)) = assembly.into_indexer_input(&worker)?; + + let domain_h = Domain::new_for_size(domain_h_size as u64)?; + let domain_k = Domain::new_for_size(domain_k_size as u64)?; + + // todo: move materialized domain elements out + fn interpolate_matrix( + matrix: Vec>, + domain_h: &Domain, + domain_k: &Domain, + worker: &Worker + ) -> Result< + ( + usize, + [Polynomial; 3], + [Vec; 2] + ), SynthesisError> { + let mut row_vec = Vec::with_capacity(domain_k.size as usize); + let mut col_vec = Vec::with_capacity(domain_k.size as usize); + let mut val_vec = Vec::with_capacity(domain_k.size as usize); + + let mut inverses_for_lagrange_polys = Vec::with_capacity(domain_k.size as usize); + + let domain_h_elements = materialize_domain_elements(domain_h, worker); + let unnormalized_largrange_values_over_k = eval_unnormalized_bivariate_lagrange_poly_over_diaginal( + domain_h.size, + domain_k, + &worker + ); + + let mut row_indexes = Vec::with_capacity(domain_k.size as usize); + let mut col_indexes = Vec::with_capacity(domain_k.size as usize); + + for (row_index, row) in matrix.into_iter().enumerate() { + for (col_index, coeff) in row { + let row_val = domain_h_elements[row_index]; + row_indexes.push(row_index); + let col_val = domain_h_elements[col_index]; // TODO: do something with inputs? + col_indexes.push(col_index); + + row_vec.push(row_val); + col_vec.push(col_val); + val_vec.push(coeff); + + // row and column indexes are over H, but we can quickly pull their values from evaluations + // over K + let idx_row_into_larger_domain = reindex_from_one_domain_to_another_assuming_natural_ordering( + domain_h, + domain_k, + row_index); + + let idx_col_into_larger_domain = reindex_from_one_domain_to_another_assuming_natural_ordering( + domain_h, + domain_k, + col_index); + + let mut lagrange_eval_value = unnormalized_largrange_values_over_k[idx_row_into_larger_domain]; + lagrange_eval_value.mul_assign(&unnormalized_largrange_values_over_k[idx_col_into_larger_domain]); + inverses_for_lagrange_polys.push(lagrange_eval_value); + } + } + + let num_non_zero = row_vec.len(); + + let mut inverses_for_lagrange = Polynomial::from_values_unpadded(inverses_for_lagrange_polys)?; + inverses_for_lagrange.batch_inversion(&worker)?; + + let mut val_values = Polynomial::from_values_unpadded(val_vec)?; + + val_values.mul_assign(&worker, &inverses_for_lagrange); + + // now pad to the domain size with zeroes + val_values.pad_to_size(domain_k.size as usize)?; + // val_values.pad_to_domain()?; + + assert!(val_values.size() == domain_k.size as usize); + assert!(row_vec.len() <= domain_k.size as usize); + assert!(col_vec.len() <= domain_k.size as usize); + + row_vec.resize(val_values.size(), F::one()); + col_vec.resize(val_values.size(), F::one()); + + let row_values = Polynomial::from_values(row_vec)?; + let col_values = Polynomial::from_values(col_vec)?; + + let val_poly = val_values.ifft(&worker); + let row_poly = row_values.ifft(&worker); + let col_poly = col_values.ifft(&worker); + + // row_indexes.resize(domain_k.size as usize, 0); + + Ok((num_non_zero, [row_poly, col_poly, val_poly], [row_indexes, col_indexes])) + } + + let (a_num_non_zero, [row_a, col_a, val_a], [row_a_indexes, col_a_indexes]) = interpolate_matrix(a_matrix, &domain_h, &domain_k, &worker)?; + let (b_num_non_zero, [row_b, col_b, val_b], [row_b_indexes, col_b_indexes]) = interpolate_matrix(b_matrix, &domain_h, &domain_k, &worker)?; + let (c_num_non_zero, [row_c, col_c, val_c], [row_c_indexes, col_c_indexes]) = interpolate_matrix(c_matrix, &domain_h, &domain_k, &worker)?; + + Ok(IndexedSetup { + a_num_non_zero, + b_num_non_zero, + c_num_non_zero, + domain_h_size, + domain_k_size, + a_matrix_poly: val_a, + b_matrix_poly: val_b, + c_matrix_poly: val_c, + a_row_poly: row_a, + b_row_poly: row_b, + c_row_poly: row_c, + a_col_poly: col_a, + b_col_poly: col_b, + c_col_poly: col_c, + a_row_indexes: row_a_indexes, + b_row_indexes: row_b_indexes, + c_row_indexes: row_c_indexes, + a_col_indexes: col_a_indexes, + b_col_indexes: col_b_indexes, + c_col_indexes: col_c_indexes, + }) +} + +pub fn evaluate_bivariate_lagrange_at_point( + x: F, + y: F, + vanishing_domain_size: u64 +) -> Result { + if x == y { + return evaluate_bivariate_lagrange_at_diagonal_point(x, vanishing_domain_size); + } + let x_vanishing = evaluate_vanishing_for_size(&x, vanishing_domain_size); + let y_vanishing = evaluate_vanishing_for_size(&y, vanishing_domain_size); + + let mut num = x_vanishing; + num.sub_assign(&y_vanishing); + + let mut den = x; + den.sub_assign(&y); + + let den = den.inverse().ok_or(SynthesisError::DivisionByZero)?; + + num.mul_assign(&den); + + Ok(num) +} + +pub fn evaluate_bivariate_lagrange_at_diagonal_point(x: F, vanishing_domain_size: u64) -> Result { + let mut repr = F::Repr::default(); + repr.as_mut()[0] = vanishing_domain_size; + let size_as_fe = F::from_repr(repr).expect("must convert domain size into field element"); + + let mut result = x.pow(&[vanishing_domain_size - 1]); + result.mul_assign(&size_as_fe); + + Ok(result) +} + +fn evaluate_bivariate_lagrange_at_point_for_vanishing_y(x: F, y: F, vanishing_domain_size: u64) -> Result { + if x == y { + return evaluate_bivariate_lagrange_at_diagonal_point(x, vanishing_domain_size); + } + + let mut x_vanishing = x.pow(&[vanishing_domain_size]); + x_vanishing.sub_assign(&F::one()); + + let mut num = x_vanishing; + + let mut den = x; + den.sub_assign(&y); + + let den = den.inverse().ok_or(SynthesisError::DivisionByZero)?; + + num.mul_assign(&den); + + Ok(num) +} + +pub(crate) fn evaluate_vanishing_for_size(point: &F, vanishing_domain_size: u64) -> F { + let mut result = point.pow(&[vanishing_domain_size]); + result.sub_assign(&F::one()); + + result +} + +#[derive(Clone)] +pub(crate) struct IndexerTester { + pub(crate) a: Option, + pub(crate) b: Option, +} + +impl Circuit for IndexerTester { + fn synthesize>( + self, + cs: &mut CS + ) -> Result<(), SynthesisError> + { + let a_var = cs.alloc(|| "a", || { + if let Some(a_value) = self.a { + Ok(a_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "a is zero", + |lc| lc + a_var, + |lc| lc + CS::one(), + |lc| lc + ); + + let b_var = cs.alloc(|| "b", || { + if let Some(b_value) = self.b { + Ok(b_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "b is one", + |lc| lc + b_var, + |lc| lc + CS::one(), + |lc| lc + CS::one() + ); + + let c_var = cs.alloc_input(|| "c", || { + if let Some(a_value) = self.a { + Ok(a_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "a is equal to c", + |lc| lc + a_var, + |lc| lc + CS::one(), + |lc| lc + c_var + ); + + cs.enforce( + || "large linear combinations (valid)", + |lc| lc + a_var + b_var + c_var, + |lc| lc + CS::one(), + |lc| lc + a_var + b_var + c_var + ); + + cs.enforce( + || "large linear combinations (invalid)", + |lc| lc + a_var + b_var + c_var, + |lc| lc + a_var + b_var + c_var, + |lc| lc + ); + + Ok(()) + } +} + +#[cfg(test)] +mod test { + use crate::tests::XORDemo; + use crate::plonk::domains::*; + use crate::worker::Worker; + use super::*; + use std::marker::PhantomData; + + fn test_over_engine_and_circuit>( + circuit: C + ) { + let params = generate_parameters(circuit).unwrap(); + let worker = Worker::new(); + + println!("Params domain H size = {}", params.domain_h_size); + println!("Params domain K size = {}", params.domain_k_size); + + let domain_h = Domain::::new_for_size(params.domain_h_size as u64).unwrap(); + let domain_k = Domain::::new_for_size(params.domain_k_size as u64).unwrap(); + let generator_h = domain_h.generator; + let generator_k = domain_k.generator; + + let mut a_matrix_values = vec![]; + + for i in 0..params.domain_h_size { + let x = generator_h.pow(&[i as u64]); + let mut row = vec![]; + for j in 0..params.domain_h_size { + let y = generator_h.pow(&[j as u64]); + + let mut sum = E::Fr::zero(); + + // sum + for k in 0..params.domain_k_size { + let k = generator_k.pow(&[k as u64]); + let col_value = params.a_col_poly.evaluate_at(&worker, k); + let row_value = params.a_row_poly.evaluate_at(&worker, k); + + let vanishing_at_col_value = evaluate_vanishing_for_size(&col_value, params.domain_h_size as u64); + assert!(vanishing_at_col_value.is_zero()); + + let vanishing_at_row_value = evaluate_vanishing_for_size(&row_value, params.domain_h_size as u64); + assert!(vanishing_at_row_value.is_zero()); + + let lag_x = evaluate_bivariate_lagrange_at_point_for_vanishing_y(x, row_value, params.domain_h_size as u64).unwrap(); + let lag_y = evaluate_bivariate_lagrange_at_point_for_vanishing_y(y, col_value, params.domain_h_size as u64).unwrap(); + let val = params.a_matrix_poly.evaluate_at(&worker, k); + + let mut result = lag_y; + result.mul_assign(&lag_x); + result.mul_assign(&val); + + sum.add_assign(&result); + } + + row.push(sum); + } + + a_matrix_values.push(row); + } + + println!("Indexed A matrix values are {:?}", a_matrix_values); + println!("A row indexes are {:?}", params.a_row_indexes); + println!("A column indexes are {:?}", params.a_col_indexes); + } + + #[test] + fn test_interpolation_poly_1() { + use crate::pairing::bn256::{Bn256}; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + test_over_engine_and_circuit(c); + } + + #[test] + fn test_interpolation_poly_2() { + use crate::pairing::bn256::{Bn256, Fr}; + + let c = IndexerTester:: { + a: None, + b: None, + }; + + test_over_engine_and_circuit(c); + } +} \ No newline at end of file diff --git a/src/marlin/mod.rs b/src/marlin/mod.rs new file mode 100644 index 000000000..38232beec --- /dev/null +++ b/src/marlin/mod.rs @@ -0,0 +1,42 @@ +use crate::pairing::Engine; +use crate::plonk::polynomials::*; + +pub mod generator; +pub mod prover; + +pub struct IndexedSetup { + pub a_num_non_zero: usize, + pub b_num_non_zero: usize, + pub c_num_non_zero: usize, + pub domain_h_size: usize, + pub domain_k_size: usize, + pub a_matrix_poly: Polynomial, + pub b_matrix_poly: Polynomial, + pub c_matrix_poly: Polynomial, + pub a_row_poly: Polynomial, + pub b_row_poly: Polynomial, + pub c_row_poly: Polynomial, + pub a_col_poly: Polynomial, + pub b_col_poly: Polynomial, + pub c_col_poly: Polynomial, + pub a_row_indexes: Vec, + pub b_row_indexes: Vec, + pub c_row_indexes: Vec, + pub a_col_indexes: Vec, + pub b_col_indexes: Vec, + pub c_col_indexes: Vec, +} + +pub struct Proof { + pub opening_on_domain_k_for_beta_3: E::G1Affine, + pub a_val_on_beta_3: E::Fr, + pub b_val_on_beta_3: E::Fr, + pub c_val_on_beta_3: E::Fr, + pub a_row_on_beta_3: E::Fr, + pub b_row_on_beta_3: E::Fr, + pub c_row_on_beta_3: E::Fr, + pub a_col_on_beta_3: E::Fr, + pub b_col_on_beta_3: E::Fr, + pub c_col_on_beta_3: E::Fr, + pub f_3_at_beta_3: E::Fr +} \ No newline at end of file diff --git a/src/marlin/prover.rs b/src/marlin/prover.rs new file mode 100644 index 000000000..3a5734db3 --- /dev/null +++ b/src/marlin/prover.rs @@ -0,0 +1,2324 @@ +use crate::log::Stopwatch; + +use rand::Rng; + +use std::sync::Arc; + +use futures::Future; + +use crate::pairing::{ + Engine, + CurveProjective, + CurveAffine +}; + +use crate::pairing::ff::{ + PrimeField, + Field +}; + +use super::{ + IndexedSetup +}; + +use crate::{ + SynthesisError, + Circuit, + ConstraintSystem, + LinearCombination, + Variable, + Index +}; + +use crate::worker::{ + Worker +}; + +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; + +use super::generator::*; +use super::Proof; + +use crate::kate_commitment::*; + +fn eval( + lc: LinearCombination, + input_assignment: &[E::Fr], + aux_assignment: &[E::Fr] +) -> E::Fr +{ + let mut acc = E::Fr::zero(); + + for (index, coeff) in lc.0.into_iter() { + let mut tmp; + + match index { + Variable(Index::Input(i)) => { + tmp = input_assignment[i]; + }, + Variable(Index::Aux(i)) => { + tmp = aux_assignment[i]; + } + } + + if coeff == E::Fr::one() { + acc.add_assign(&tmp); + } else { + tmp.mul_assign(&coeff); + acc.add_assign(&tmp); + } + } + + acc +} + +// This is a proving assignment with densities precalculated +pub struct PreparedProver{ + assignment: ProvingAssignment, +} + +#[derive(Clone)] +struct ProvingAssignment { + // Evaluations of A, B, C polynomials + a: Vec, + b: Vec, + c: Vec, + + // Assignments of variables + input_assignment: Vec, + aux_assignment: Vec +} + +pub fn prepare_prover( + circuit: C, +) -> Result, SynthesisError> + where E: Engine, C: Circuit +{ + let mut prover = ProvingAssignment { + a: vec![], + b: vec![], + c: vec![], + input_assignment: vec![], + aux_assignment: vec![] + }; + + prover.alloc_input(|| "CS::ONE", || Ok(E::Fr::one()))?; + + circuit.synthesize(&mut prover)?; + + // for i in 0..prover.input_assignment.len() { + // prover.enforce(|| "", + // |lc| lc + Variable(Index::Input(i)), + // |lc| lc, + // |lc| lc, + // ); + // } + + let prepared = PreparedProver { + assignment: prover + }; + + return Ok(prepared) +} + + +pub struct IndexPrecomputations { + // values on 2K size coset for the last check + pub a_row_over_2k_coset: Polynomial, + pub b_row_over_2k_coset: Polynomial, + pub c_row_over_2k_coset: Polynomial, + pub a_col_over_2k_coset: Polynomial, + pub b_col_over_2k_coset: Polynomial, + pub c_col_over_2k_coset: Polynomial, + pub a_val_over_2k_coset: Polynomial, + pub b_val_over_2k_coset: Polynomial, + pub c_val_over_2k_coset: Polynomial, + + // values on K size for sumchecks + pub a_row_over_k: Polynomial, + pub b_row_over_k: Polynomial, + pub c_row_over_k: Polynomial, + pub a_col_over_k: Polynomial, + pub b_col_over_k: Polynomial, + pub c_col_over_k: Polynomial, + pub a_val_over_k: Polynomial, + pub b_val_over_k: Polynomial, + pub c_val_over_k: Polynomial, + + // r(x, x) on H + pub r_x_x_values_over_h: Polynomial, +} + +impl IndexPrecomputations { + pub fn new(params: &IndexedSetup, worker: &Worker) -> Result { + let lde_factor_from_h_to_k = params.domain_k_size / params.domain_h_size; + assert!(lde_factor_from_h_to_k.is_power_of_two()); + + let domain_h = Domain::::new_for_size(params.domain_h_size as u64)?; + + let r_x_x_values_over_h = eval_unnormalized_bivariate_lagrange_poly_over_diaginal(domain_h.size, &domain_h, &worker); + let r_x_x_values_over_h = Polynomial::from_values(r_x_x_values_over_h)?; + + let a_row_over_2k_coset: Polynomial = params.a_row_poly.clone().coset_lde(&worker, 2)?; + let b_row_over_2k_coset: Polynomial = params.b_row_poly.clone().coset_lde(&worker, 2)?; + let c_row_over_2k_coset: Polynomial = params.c_row_poly.clone().coset_lde(&worker, 2)?; + let a_col_over_2k_coset: Polynomial = params.a_col_poly.clone().coset_lde(&worker, 2)?; + let b_col_over_2k_coset: Polynomial = params.b_col_poly.clone().coset_lde(&worker, 2)?; + let c_col_over_2k_coset: Polynomial = params.c_col_poly.clone().coset_lde(&worker, 2)?; + let a_val_over_2k_coset: Polynomial = params.a_matrix_poly.clone().coset_lde(&worker, 2)?; + let b_val_over_2k_coset: Polynomial = params.b_matrix_poly.clone().coset_lde(&worker, 2)?; + let c_val_over_2k_coset: Polynomial = params.c_matrix_poly.clone().coset_lde(&worker, 2)?; + let a_row_over_k: Polynomial = params.a_row_poly.clone().fft(&worker); + let b_row_over_k: Polynomial = params.b_row_poly.clone().fft(&worker); + let c_row_over_k: Polynomial = params.c_row_poly.clone().fft(&worker); + let a_col_over_k: Polynomial = params.a_col_poly.clone().fft(&worker); + let b_col_over_k: Polynomial = params.b_col_poly.clone().fft(&worker); + let c_col_over_k: Polynomial = params.c_col_poly.clone().fft(&worker); + let a_val_over_k: Polynomial = params.a_matrix_poly.clone().fft(&worker); + let b_val_over_k: Polynomial = params.b_matrix_poly.clone().fft(&worker); + let c_val_over_k: Polynomial = params.c_matrix_poly.clone().fft(&worker); + + let new = IndexPrecomputations:: { + a_row_over_2k_coset, + b_row_over_2k_coset, + c_row_over_2k_coset, + a_col_over_2k_coset, + b_col_over_2k_coset, + c_col_over_2k_coset, + a_val_over_2k_coset, + b_val_over_2k_coset, + c_val_over_2k_coset, + a_row_over_k, + b_row_over_k, + c_row_over_k, + a_col_over_k, + b_col_over_k, + c_col_over_k, + a_val_over_k, + b_val_over_k, + c_val_over_k, + r_x_x_values_over_h, + }; + + Ok(new) + + } +} +pub struct PrecomputedBases { + pub crs_values_on_h: Crs::, + pub crs_values_on_k: Crs::, + // pub crs_values_on_h_coset: Crs:: +} + +impl PrecomputedBases { + pub fn new_42_for_index(params: &IndexedSetup, worker: &Worker) -> Self { + println!("Making CRS"); + + let monomial = Crs::::crs_42(params.domain_k_size, &worker); + + println!("Done making power series"); + + // TODO: use subslicing here + let crs_values_on_h = Crs::::from_powers(&monomial, params.domain_h_size, &worker); + println!("Done making lagrange bases on H"); + + let crs_values_on_k = Crs::::from_powers(&monomial, params.domain_k_size, &worker); + // let crs_values_on_h_coset = Crs::::from_powers(&monomial, params.domain_h_size, &worker); + + println!("Done making CRS"); + + Self { + crs_values_on_h, + crs_values_on_k, + // crs_values_on_h_coset, + } + } +} + +impl PreparedProver { + pub fn create_proof( + self, + params: &IndexedSetup, + crs: &PrecomputedBases, + precomputations: &IndexPrecomputations, + ) -> Result<(), SynthesisError> + { + // this prover performs the following: + // - commit to the witness vector `w` and to the results of application of the A/B/C matrixes + // to it as `z_a`, `z_b`, `z_c` (we may ommit commitment to `z_c` and just claim it's value) + // - commit to the quotient (z_a * z_b - z_c)/vanishing_on_H + // - perform a first sumcheck using random challenge `alpha` and linear combination challenges + // `eta_a`, `eta_b`, `eta_c`. Those prove that over the domain H (matrix size): + // sum of the r(alpha, x) * z_m(x) - r_m(alpha, x) * w(x) is equal to zero where M \in {A, B, C} + // and r_m(alpha, x) = \sum_{k \in H} r(alpha, k) * M(k, x) + // at this step we claim commit to eta_a * r_a(alpha, x) + eta_b * r_b(alpha, x) + eta_c * r_c(alpha, x) + // without individual contributions r_a(alpha, x), r_b(alpha, x), r_c(alpha, x) + // - perform the second sumcheck to prove that \sum_{k \in H} r(alpha, k) * M(k, x) is evaluated correctly + // in a batched way: define q_2(x) = r(alpha, x) \sum_{m \in M} * M(x, beta_1) + // if we avaluate previous batched commitment to eta_a * r_a(alpha, x) + eta_b * r_b(alpha, x) + eta_c * r_c(alpha, x) + // at the point beta_1 then it must be equal to \sum_{H} q_2(x) + // - perform a third sumcheck to claim that q_2(x) was evaluated correctly: + // we later check that q_2(beta_2) = r(alpha, beta_2) * \sum_{m \in M} * M(beta_2, beta_1) + // for this purpose we need to prove correctness of M(beta_2, beta_1) relatively to the initial indexing + // for this we define individual polynomials over domain K f_m = M(x, beta_1, beta_2) = Func(indexing, beta_1, beta_2) such that + // after summing out over x we'll get the value M(beta_2, beta_1). To achieve this we perform a sumcheck + + let worker = Worker::new(); + + let domain_h = Domain::::new_for_size(params.domain_h_size as u64)?; + let domain_k = Domain::::new_for_size(params.domain_k_size as u64)?; + + let prover = self.assignment; + + println!("Start prover work"); + let stopwatch = Stopwatch::new(); + + let a_values_on_h = Polynomial::from_values(prover.a)?; + let b_values_on_h = Polynomial::from_values(prover.b)?; + let c_values_on_h = Polynomial::from_values(prover.c)?; + + println!("Committing z_a, z_b, z_c"); + let a_commitment = commit_using_values(&a_values_on_h, &crs.crs_values_on_h, &worker)?; + let b_commitment = commit_using_values(&b_values_on_h, &crs.crs_values_on_h, &worker)?; + let c_commitment = commit_using_values(&c_values_on_h, &crs.crs_values_on_h, &worker)?; + + let h_poly_values_on_h = { + elog_verbose!("H size is {}", a_values_on_h.size()); + + let a_poly = a_values_on_h.clone().ifft(&worker); + let b_poly = b_values_on_h.clone().ifft(&worker); + let c_poly = c_values_on_h.clone().ifft(&worker); + + let mut a = a_poly.coset_fft(&worker); + let b = b_poly.coset_fft(&worker); + let c = c_poly.coset_fft(&worker); + + a.mul_assign(&worker, &b); + drop(b); + a.sub_assign(&worker, &c); + drop(c); + + let z_in_coset = evaluate_vanishing_for_size(&E::Fr::multiplicative_generator(), domain_h.size); + let z_in_coset_inv = z_in_coset.inverse().ok_or(SynthesisError::DivisionByZero)?; + + a.scale(&worker, z_in_coset_inv); // divide + + let h = a.icoset_fft(&worker); + + let h_values = h.fft(&worker); + + h_values + }; + + println!("Committing h"); + let h_commitment = commit_using_values(&h_poly_values_on_h, &crs.crs_values_on_h, &worker)?; + + // TODO: later split this up: use witness poly for proving, but commit to the one contatining + // zeroes instead of inputs + + let mut witness_values_on_h = Vec::with_capacity(a_values_on_h.size()); + witness_values_on_h.extend(prover.input_assignment); + witness_values_on_h.extend(prover.aux_assignment); + witness_values_on_h.resize(a_values_on_h.size(), E::Fr::zero()); + + let witness_values_on_h = Polynomial::from_values(witness_values_on_h)?; + + println!("Committing w"); + let witness_commitment = commit_using_values(&witness_values_on_h, &crs.crs_values_on_h, &worker)?; + + // now start the lincheck + + // define q1(x) = r(alpha, x) * (\ sum_{M} eta_m * z_m(x)) - (\sum_{M} eta_m * r_m(alpha, x)) w(x) + // formally this polynomial is of degree 2H + // then we define a polynomial sum_q1(x) that is a grand sum of q1(x) (easy to calculate from values) + // then we need to show that (q1(x) + sum_q1(x) - sum_q1(x*omega)) / (vanishing_H) == 0 + + let alpha = E::Fr::from_str("5").unwrap(); + let eta_a = E::Fr::one(); + let eta_b = E::Fr::zero(); + let eta_c = E::Fr::zero(); + // let eta_a = E::Fr::from_str("7").unwrap(); + // let eta_b = E::Fr::from_str("11").unwrap(); + // let eta_c = E::Fr::from_str("42").unwrap(); + + // We have not committed to witness values and values of application of A/B/C matrixes on witness + + // also no masking for now + + let mut repr = ::Repr::default(); + repr.as_mut()[0] = domain_h.size; + let size_h_as_fe = E::Fr::from_repr(repr).expect("must convert domain size into field element"); + + let mut repr = ::Repr::default(); + repr.as_mut()[0] = domain_k.size; + let size_k_as_fe = E::Fr::from_repr(repr).expect("must convert domain size into field element"); + + // By this moment we should have oracles to all the witness polynomials, as well as Af, Bf, Cf + + // first sumcheck is for the polynomial + // Q_1(X) = r(alpha, X) * F_1(X) + r_m(alpha, X) * F_2(X) + // where r_m(alpha, X) = \sum_{k \in K} r(X, k) M (k, Y) + // F_1(X) is result of applying one of the matrixes (A/B/C) on the vector of witnesses + // F_2(X) is a witness itself + // this is reduced for the following sumcheck (neglecting the ZK) + // \sum_{H} r(alpha, X) ( \sum_{M} eta_M * z_M(X) ) - witness(X) * \sum_{M} ( \eta_M r_M(alpha, X)) ) + // where z_M(X) = (M * witness)(X) + + let r_alpha_x_values = eval_unnormalized_bivariate_lagrange_poly_over_different_inputs( + alpha, + domain_h.size, + &domain_h, + &worker + ); + + let r_alpha_x_values_over_h = Polynomial::from_values(r_alpha_x_values)?; + + // now do the same for A/B/C matrixes + + // R(X, X) + // let r_x_x_over_h = eval_unnormalized_bivariate_lagrange_poly_over_diaginal(domain_h.size, &domain_h, &worker); + // let r_x_x_values_over_h = Polynomial::from_values(r_x_x_over_h)?; + + // now compute r_M(alpha, X) = \sum_{H} r(alpha, X) M(X, Y) (sum is over X \in H) + + let lde_factor_from_h_to_k = domain_k.size / domain_h.size; + assert!(lde_factor_from_h_to_k.is_power_of_two()); + + // let a_matrix_at_k = params.a_matrix_poly.clone().fft(&worker); + // let b_matrix_at_k = params.b_matrix_poly.clone().fft(&worker); + // let c_matrix_at_k = params.c_matrix_poly.clone().fft(&worker); + + // let domain_h_elements = materialize_domain_elements(&domain_h, &worker); + + fn construct_r_m_from_matrix( + matrix_evals_at_k: &Polynomial, + r_x_x_on_h: &Polynomial, + r_alpha_x_on_h: &Polynomial, + row_indexes: &Vec, + col_indexes: &Vec, + domain_h: &Domain, + worker: &Worker + ) -> Result, SynthesisError> { + let mut result = vec![F::zero(); domain_h.size as usize]; + + let to_spawn = worker.get_num_spawned_threads(col_indexes.len()); + let mut subresults = vec![result.clone(); to_spawn]; + + // M(X, Y) for X = omega^row_index and Y = omega^col_index is equal to the + // R1CS matrix M value at (row_index, col_index) + + worker.scope(col_indexes.len(), |scope, chunk_size| { + for (chunk_id, ((subres, row_chunk), col_chunk)) in subresults.chunks_mut(1) + .zip(row_indexes.chunks(chunk_size)) + .zip(col_indexes.chunks(chunk_size)) + .enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + let write_to_subres = &mut subres[0]; + // first we go over non-degenerate indexes + for (i, (&row_index, &col_index)) in row_chunk.iter().zip(col_chunk.iter()).enumerate() { + let k_domain_index = start + i; + + let r_x_x_at_h_row = &r_x_x_on_h.as_ref()[row_index]; + let r_x_x_at_h_col = &r_x_x_on_h.as_ref()[col_index]; + let r_alpha_x_at_h = &r_alpha_x_on_h.as_ref()[row_index]; + + let val = &matrix_evals_at_k.as_ref()[k_domain_index]; + + let mut result = *r_x_x_at_h_col; + result.mul_assign(val); + result.mul_assign(r_x_x_at_h_row); + // println!("Matrix element contribution into row {}, column {} = {}", row_index, col_index, result); + result.mul_assign(r_alpha_x_at_h); + + write_to_subres[col_index].add_assign(&result); + } + }); + } + }); + + let subresults_ref = &subresults; + worker.scope(result.len(), |scope, chunk_size| { + for (chunk_id, chunk) in result.chunks_mut(chunk_size).enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + for (j, el) in chunk.iter_mut().enumerate() { + let idx = start + j; + for s in subresults_ref.iter() { + if !s[idx].is_zero() { + el.add_assign(&s[idx]); + } + } + } + }); + } + }); + + Polynomial::from_values(result) + } + + let r_a_alpha_x = construct_r_m_from_matrix( + &precomputations.a_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_alpha_x_values_over_h, + ¶ms.a_row_indexes, + ¶ms.a_col_indexes, + &domain_h, + &worker + )?; + + let r_b_alpha_x = construct_r_m_from_matrix( + &precomputations.b_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_alpha_x_values_over_h, + ¶ms.b_row_indexes, + ¶ms.b_col_indexes, + &domain_h, + &worker + )?; + + let r_c_alpha_x = construct_r_m_from_matrix( + &precomputations.c_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_alpha_x_values_over_h, + ¶ms.c_row_indexes, + ¶ms.c_col_indexes, + &domain_h, + &worker + )?; + + // sum_{m} eta_m * z_m + let mut r_m_sum = a_values_on_h.clone(); + r_m_sum.scale(&worker, eta_a); + r_m_sum.add_assign_scaled(&worker, &b_values_on_h, &eta_b); + r_m_sum.add_assign_scaled(&worker, &c_values_on_h, &eta_c); + + // sum_{m} eta_m * M(alpha, x) + let mut r_m_alpha_x_sum = r_a_alpha_x.clone(); + r_m_alpha_x_sum.scale(&worker, eta_a); + r_m_alpha_x_sum.add_assign_scaled(&worker, &r_b_alpha_x, &eta_b); + r_m_alpha_x_sum.add_assign_scaled(&worker, &r_c_alpha_x, &eta_c); + + // r(alpha, X) * \sum (M*witness)(x) * eta_m + + let beta_1 = E::Fr::from_str("137").unwrap(); + + let sum_a_b_c_at_beta_1 = r_m_sum.barycentric_evaluate_at(&worker, beta_1)?; + let sum_m_at_beta_1 = r_m_alpha_x_sum.barycentric_evaluate_at(&worker, beta_1)?; + + let mut proper_t_0_values_on_2h = r_m_sum.clone().ifft(&worker).lde(&worker, 2).unwrap(); + let tmp = r_alpha_x_values_over_h.clone().ifft(&worker).lde(&worker, 2).unwrap(); + + proper_t_0_values_on_2h.mul_assign(&worker, &tmp); + drop(tmp); + + let mut t_0 = r_m_sum; + t_0.mul_assign(&worker, &r_alpha_x_values_over_h); + + // \sum_{H} r_m(alpha, X) * eta_m * witness(x) + + let mut proper_t_1_values_on_2h = r_m_alpha_x_sum.clone().ifft(&worker).lde(&worker, 2).unwrap(); + let tmp = witness_values_on_h.clone().ifft(&worker).lde(&worker, 2).unwrap(); + + proper_t_1_values_on_2h.mul_assign(&worker, &tmp); + drop(tmp); + + let mut t_1 = r_m_alpha_x_sum; + t_1.mul_assign(&worker, &witness_values_on_h); + + // let r_m_sum_sum_over_h = t_0.calculate_sum(&worker)?; + // let r_m_alpha_x_sum_over_h = t_1.calculate_sum(&worker)?; + // assert!(r_m_sum_sum_over_h == r_m_alpha_x_sum_over_h); + + // q1(x) = r(alpha, x) * (\ sum_{M} eta_m * z_m(x)) - (\sum_{M} eta_m * r_m(alpha, x)) w(x) + + let mut q_1_poly_values_over_h = t_0; + q_1_poly_values_over_h.sub_assign(&worker, &t_1); + + let mut proper_q_1_values_on_2h = proper_t_0_values_on_2h; + proper_q_1_values_on_2h.sub_assign(&worker, &proper_t_1_values_on_2h); + + fn calculate_grand_sum_over_subdomain_assuming_natural_ordering_with_normalization( + values: &Polynomial, + worker: &Worker + ) -> Result<(F, Polynomial), SynthesisError> { + let mut result = vec![F::zero(); values.size() + 2]; + + let num_threads = worker.get_num_spawned_threads(values.size()); + let mut subsums_main = vec![F::zero(); num_threads as usize]; + let mut subsums_sub = vec![F::zero(); num_threads as usize]; + + worker.scope(values.as_ref().len(), |scope, chunk| { + for (chunk_idx, (((grand_sum, elements), s_main), s_sub)) in result[2..].chunks_mut(chunk) + .zip(values.as_ref().chunks(chunk)) + .zip(subsums_main.chunks_mut(1)) + .zip(subsums_sub.chunks_mut(1)) + .enumerate() { + scope.spawn(move |_| { + let start_idx = chunk_idx * chunk; + for (i, (g, el)) in grand_sum.iter_mut() + .zip(elements.iter()) + .enumerate() { + let this_idx = start_idx + i; + if this_idx & 1 == 0 { + s_main[0].add_assign(&el); + *g = s_main[0]; + } else { + s_sub[0].add_assign(&el); + *g = s_sub[0]; + } + } + }); + } + }); + + // subsums are [a+b+c, d+e+f, x+y+z] + + let mut tmp_main = F::zero(); + for s in subsums_main.iter_mut() { + tmp_main.add_assign(&s); + *s = tmp_main; + } + + let mut tmp_sub = F::zero(); + for s in subsums_sub.iter_mut() { + tmp_sub.add_assign(&s); + *s = tmp_sub; + } + + // sum over the full domain is the last element + let domain_sum_main = subsums_main.pop().expect("has at least one value"); + let domain_sum_sub = subsums_sub.pop().expect("has at least one value"); + + let subdomain_size_as_fe = F::from_str(&format!("{}", values.size()/2)).expect("must be a valid element"); + let one_over_size = subdomain_size_as_fe.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut normalization_on_main = domain_sum_main; + normalization_on_main.mul_assign(&one_over_size); + + let mut normalization_on_sub = domain_sum_sub; + normalization_on_sub.mul_assign(&one_over_size); + + let chunk_len = worker.get_chunk_size(values.as_ref().len()); + + assert_eq!(result.len() - chunk_len - 2, chunk_len * subsums_main.len()); + + worker.scope(0, |scope, _| { + for (chunk_idx, ((g, s_main), s_sub)) in result[(chunk_len+2)..].chunks_mut(chunk_len) + .zip(subsums_main.chunks(1)) + .zip(subsums_sub.chunks(1)) + .enumerate() { + scope.spawn(move |_| { + let start_idx = (chunk_idx + 1) * chunk_len; + let c_main = s_main[0]; + let c_sub = s_sub[0]; + for (i, g) in g.iter_mut().enumerate() { + let this_idx = start_idx + i; + if this_idx & 1 == 0 { + g.add_assign(&c_main); + } else { + g.add_assign(&c_sub); + } + + } + }); + } + }); + + let alt_total_sum_sub = result.pop().expect("must pop the last element"); + let alt_total_sum_main = result.pop().expect("must pop the last element"); + + assert_eq!(alt_total_sum_main, domain_sum_main, "sum on main domain must match"); + assert_eq!(alt_total_sum_sub, domain_sum_sub, "sum on subdomain must match"); + + println!("Main sum = {}", domain_sum_main); + println!("Sub sum = {}", domain_sum_sub); + + Ok((domain_sum_main, Polynomial::from_values_unpadded(result)?)) + } + + let (proper_q_1_sum_over_2h, proper_q_1_grand_sum_poly_values_over_2h) = + calculate_grand_sum_over_subdomain_assuming_natural_ordering_with_normalization( + &proper_q_1_values_on_2h, + &worker + )?; + + // let rotated_proper_q_1_grand_sum_poly_values_over_2h = proper_q_1_grand_sum_poly_values_over_2h.clone().rotate(2)?; + + let mut quotient = proper_q_1_values_on_2h.clone().ifft(&worker).coset_fft(&worker); + let proper_q_1_grand_sum_poly_values_over_2h_coeffs = proper_q_1_grand_sum_poly_values_over_2h.clone().ifft(&worker); + + let mut proper_q_1_grand_sum_poly_values_over_2h_coeffs_shifted = proper_q_1_grand_sum_poly_values_over_2h_coeffs.clone(); + proper_q_1_grand_sum_poly_values_over_2h_coeffs_shifted.distribute_powers(&worker, domain_h.generator); + + quotient.add_assign(&worker, &proper_q_1_grand_sum_poly_values_over_2h_coeffs.coset_fft(&worker)); + quotient.sub_assign(&worker, &proper_q_1_grand_sum_poly_values_over_2h_coeffs_shifted.coset_fft(&worker)); + + let domain_2h = Domain::new_for_size((params.domain_h_size*2) as u64)?; + + let mut vanishing_of_degree_h_on_2h = evaluate_vanishing_polynomial_of_degree_on_domain( + domain_h.size, + &E::Fr::multiplicative_generator(), + &domain_2h, + &worker + )?; + + vanishing_of_degree_h_on_2h.batch_inversion(&worker)?; + quotient.mul_assign(&worker, &vanishing_of_degree_h_on_2h); + + drop(vanishing_of_degree_h_on_2h); + + let q_1_quotient_on_h = quotient.icoset_fft(&worker).fft(&worker); + + // let (proper_q_1_sum_over_2h, proper_q_1_grand_sum_poly_values_over_2h) = proper_q_1_values_on_2h.calculate_grand_sum(&worker)?; + + println!("Proper sum = {}", proper_q_1_sum_over_2h); + assert!(proper_q_1_sum_over_2h.is_zero()); + + let proper_q_1_at_beta_1 = proper_q_1_values_on_2h.barycentric_evaluate_at(&worker, beta_1)?; + println!("Proper q_1 at beta 1 = {}", proper_q_1_at_beta_1); + // assert!(proper_q_1_sum_over_2h.is_zero()); + let q_1_at_beta = q_1_poly_values_over_h.barycentric_evaluate_at(&worker, beta_1)?; + println!("Hacky q_1 at beta 1 = {}", q_1_at_beta); + + // let (q1_even, q_1_odd) = proper_q_1_values_on_2h.split_into_even_and_odd_assuming_natural_ordering( + // &worker, + // &E::Fr::one() + // )?; + + // let (q1_even_sum, q_1_odd_sum) = proper_q_1_grand_sum_poly_values_over_2h.split_into_even_and_odd_assuming_natural_ordering( + // &worker, + // &E::Fr::one() + // )?; + + println!("Committing Q1 and it's sumcheck poly"); + + + // this is formally correct polynomial as it coincides with a sum of q_1 on H everywhere + let (q_1_sum_over_h, q_1_grand_sum_poly_values_over_h) = q_1_poly_values_over_h.calculate_grand_sum(&worker)?; + + assert!(q_1_sum_over_h.is_zero()); + + // let q_1_commitment = commit_using_values(&q_1_poly_values_over_h, &crs.crs_values_on_h, &worker)?; + // let q_1_sum_commitment = commit_using_values(&q_1_grand_sum_poly_values_over_h, &crs.crs_values_on_h, &worker)?; + + // Now we've completed the first part of the lincheck by incorporating alpha into M(X, Y) + + // { + // let z = E::Fr::from_str("10000").unwrap(); + + // let mut z_omega = z; + // z_omega.mul_assign(&domain_h.generator); + + // let grand_sum_at_z = q_1_grand_sum_poly_coeffs.evaluate_at(&worker, z); + // let grand_sum_at_z_omega = q_1_grand_sum_poly_coeffs.evaluate_at(&worker, z_omega); + // let el_at_z = q_1_poly_coeffs.evaluate_at(&worker, z); + // let vanishing_at_z = evaluate_vanishing_for_size(&z, domain_h.size); + // let quotient_at_z = q_1_sumcheck_quotient_over_h_coeffs.evaluate_at(&worker, z); + + // let mut lhs = grand_sum_at_z; + // lhs.sub_assign(&grand_sum_at_z_omega); + // lhs.add_assign(&el_at_z); + + // let mut rhs = vanishing_at_z; + // rhs.mul_assign("ient_at_z); + + // assert_eq!(lhs, rhs, "q_1 sumcheck must pass"); + // } + + // we would later need to evaluate q_1(z) and q_1_sum(z) and q_1_sum(z*omega) + + + let beta_1 = E::Fr::from_str("137").unwrap(); + + // claim values of z_a, z_b, z_c and h at beta_1 + + let a_at_beta_1 = a_values_on_h.barycentric_evaluate_at(&worker, beta_1)?; + let b_at_beta_1 = b_values_on_h.barycentric_evaluate_at(&worker, beta_1)?; + let c_at_beta_1 = c_values_on_h.barycentric_evaluate_at(&worker, beta_1)?; + let h_at_beta_1 = h_poly_values_on_h.barycentric_evaluate_at(&worker, beta_1)?; + + let vanishing_at_beta_1 = evaluate_vanishing_for_size(&beta_1, domain_h.size); + + { + let mut lhs = a_at_beta_1; + lhs.mul_assign(&b_at_beta_1); + lhs.sub_assign(&c_at_beta_1); + + let mut rhs = h_at_beta_1; + rhs.mul_assign(&vanishing_at_beta_1); + + assert!(lhs == rhs, "ab - c == h * z_H"); + } + + // now we need to make q_2 = r(alpha, X) M(X, beta) + + let r_beta_1_x_values = eval_unnormalized_bivariate_lagrange_poly_over_different_inputs( + beta_1, + domain_h.size, + &domain_h, + &worker + ); + + let r_beta_1_x_values_over_h = Polynomial::from_values(r_beta_1_x_values)?; + + fn materialize_m_x_beta( + matrix_evals_at_k: &Polynomial, + r_x_x_on_h: &Polynomial, + r_beta_x_on_h: &Polynomial, + row_indexes: &Vec, + col_indexes: &Vec, + domain_h: &Domain, + worker: &Worker + ) -> Result, SynthesisError> { + let mut result = vec![F::zero(); domain_h.size as usize]; + + let to_spawn = worker.get_num_spawned_threads(col_indexes.len()); + let mut subresults = vec![result.clone(); to_spawn]; + + // M(X, Y) for X = omega^row_index and Y = omega^col_index is equal to the + // R1CS matrix M value at (row_index, col_index) + + worker.scope(col_indexes.len(), |scope, chunk_size| { + for (chunk_id, ((subres, row_chunk), col_chunk)) in subresults.chunks_mut(1) + .zip(row_indexes.chunks(chunk_size)) + .zip(col_indexes.chunks(chunk_size)) + .enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + let write_to_subres = &mut subres[0]; + // first we go over non-degenerate indexes + for (i, (&row_index, &col_index)) in row_chunk.iter().zip(col_chunk.iter()).enumerate() { + let k_domain_index = start + i; + + let r_x_x_at_h_row = &r_x_x_on_h.as_ref()[row_index]; + let r_beta_x_at_h_col = &r_beta_x_on_h.as_ref()[col_index]; + + let val = &matrix_evals_at_k.as_ref()[k_domain_index]; + + let mut result = *r_x_x_at_h_row; + result.mul_assign(val); + // println!("Matrix element contribution into row {}, column {} = {}", row_index, col_index, result); + result.mul_assign(r_beta_x_at_h_col); + + write_to_subres[col_index].add_assign(&result); + } + }); + } + }); + + let subresults_ref = &subresults; + worker.scope(result.len(), |scope, chunk_size| { + for (chunk_id, chunk) in result.chunks_mut(chunk_size).enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + for (j, el) in chunk.iter_mut().enumerate() { + let idx = start + j; + for s in subresults_ref.iter() { + if !s[idx].is_zero() { + el.add_assign(&s[idx]); + } + } + } + }); + } + }); + + Polynomial::from_values(result) + } + + let r_a_x_beta_on_h = materialize_m_x_beta( + &precomputations.a_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_beta_1_x_values_over_h, + ¶ms.a_row_indexes, + ¶ms.a_col_indexes, + &domain_h, + &worker + )?; + + let r_b_x_beta_on_h = materialize_m_x_beta( + &precomputations.b_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_beta_1_x_values_over_h, + ¶ms.a_row_indexes, + ¶ms.a_col_indexes, + &domain_h, + &worker + )?; + + let r_c_x_beta_on_h = materialize_m_x_beta( + &precomputations.c_val_over_k, + &precomputations.r_x_x_values_over_h, + &r_beta_1_x_values_over_h, + ¶ms.a_row_indexes, + ¶ms.a_col_indexes, + &domain_h, + &worker + )?; + + let beta_2 = E::Fr::from_str("456").unwrap(); + + let mut r_m_beta_sum = r_a_x_beta_on_h; + r_m_beta_sum.scale(&worker, eta_a); + r_m_beta_sum.add_assign_scaled(&worker, &r_b_x_beta_on_h, &eta_b); + r_m_beta_sum.add_assign_scaled(&worker, &r_c_x_beta_on_h, &eta_c); + + drop(r_b_x_beta_on_h); + drop(r_c_x_beta_on_h); + + let r_m_x_beta_1_at_beta_2 = r_m_beta_sum.barycentric_evaluate_at(&worker, beta_2)?; + println!("M(beta_2, beta_1) = {}", r_m_x_beta_1_at_beta_2); + + let mut q_2_poly_values_on_h = r_m_beta_sum; + q_2_poly_values_on_h.mul_assign(&worker, &r_alpha_x_values_over_h); + + let r_alpha_beta_2 = r_alpha_x_values_over_h.barycentric_evaluate_at(&worker, beta_2)?; + println!("r(alpha, beta_2) = {}", r_alpha_beta_2); + + let q_2_sum_value = q_2_poly_values_on_h.calculate_sum(&worker)?; + + let sigma_2 = q_2_sum_value; + + let one_over_h_size = size_h_as_fe.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut tmp = sigma_2; + tmp.mul_assign(&one_over_h_size); + + q_2_poly_values_on_h.sub_constant(&worker, &tmp); + + let (tmp, q_2_grand_sum_over_h) = q_2_poly_values_on_h.calculate_grand_sum(&worker)?; + + assert!(tmp.is_zero()); + + println!("Committing Q2 and it's sumcheck poly"); + // let q_2_commitment = commit_using_values(&q_2_poly_values_on_h, &crs.crs_values_on_h, &worker)?; + let q_2_sum_commitment = commit_using_values(&q_2_grand_sum_over_h, &crs.crs_values_on_h, &worker)?; + + // TODO: check if it's better to reduce it to the single poly of degree 6K then to + // three independent ones of degree 2k + + let beta_2 = E::Fr::from_str("456").unwrap(); + + // now calculate a polynomial f_3 over K using a definition + + fn evaluate_bivariate_lagrange_over_row_or_col_poly( + x: F, + vanishing_poly_size: u64, + row_or_col_evaluations_on_domain: &Polynomial, + evaluate_on_domain: &Domain, + worker: &Worker + ) -> Result, SynthesisError> { + assert!(evaluate_on_domain.size as usize == row_or_col_evaluations_on_domain.size()); + + let vanishing_at_x = evaluate_vanishing_for_size(&x, vanishing_poly_size); + let inv_vanishing_at_x = vanishing_at_x.inverse().ok_or(SynthesisError::DivisionByZero)?; + let mut inverses = row_or_col_evaluations_on_domain.clone(); + inverses.map(&worker, |element| { // (x - col(k))/van(x) + let mut tmp = x; + tmp.sub_assign(&*element); + tmp.mul_assign(&inv_vanishing_at_x); + + *element = tmp; + }); + + inverses.batch_inversion(&worker).expect("must inverse as there are no zeroes"); + + Ok(inverses) + } + + let a_row_poly = params.a_row_poly.clone(); + let b_row_poly = params.b_row_poly.clone(); + let c_row_poly = params.c_row_poly.clone(); + + assert!(a_row_poly.size() == domain_k.size as usize); + + let a_col_poly = params.a_col_poly.clone(); + let b_col_poly = params.b_col_poly.clone(); + let c_col_poly = params.c_col_poly.clone(); + + assert!(a_col_poly.size() == domain_k.size as usize); + + let a_row_values_at_k = a_row_poly.fft(&worker); + let b_row_values_at_k = b_row_poly.fft(&worker); + let c_row_values_at_k = c_row_poly.fft(&worker); + + let a_col_values_at_k = a_col_poly.fft(&worker); + let b_col_values_at_k = b_col_poly.fft(&worker); + let c_col_values_at_k = c_col_poly.fft(&worker); + + let r_beta_1_col_a_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_1, + domain_h.size, + &a_col_values_at_k, + &domain_k, + &worker + )?; + + let r_beta_1_col_b_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_1, + domain_h.size, + &b_col_values_at_k, + &domain_k, + &worker + )?; + + let r_beta_1_col_c_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_1, + domain_h.size, + &c_col_values_at_k, + &domain_k, + &worker + )?; + + let r_beta_2_row_a_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_2, + domain_h.size, + &a_row_values_at_k, + &domain_k, + &worker + )?; + + let r_beta_2_row_b_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_2, + domain_h.size, + &b_row_values_at_k, + &domain_k, + &worker + )?; + + let r_beta_2_row_c_values_over_k = evaluate_bivariate_lagrange_over_row_or_col_poly( + beta_2, + domain_h.size, + &c_row_values_at_k, + &domain_k, + &worker + )?; + + // do multiplication over K + let mut f_3_a_values_over_k_by_eta_a = precomputations.a_val_over_k.clone(); + f_3_a_values_over_k_by_eta_a.scale(&worker, eta_a); + f_3_a_values_over_k_by_eta_a.mul_assign(&worker, &r_beta_2_row_a_values_over_k); + f_3_a_values_over_k_by_eta_a.mul_assign(&worker, &r_beta_1_col_a_values_over_k); + + let mut f_3_b_values_over_k_by_eta_b = precomputations.b_val_over_k.clone(); + f_3_b_values_over_k_by_eta_b.scale(&worker, eta_b); + f_3_b_values_over_k_by_eta_b.mul_assign(&worker, &r_beta_2_row_b_values_over_k); + f_3_b_values_over_k_by_eta_b.mul_assign(&worker, &r_beta_1_col_b_values_over_k); + + let mut f_3_c_values_over_k_by_eta_c = precomputations.c_val_over_k.clone(); + f_3_c_values_over_k_by_eta_c.scale(&worker, eta_c); + f_3_c_values_over_k_by_eta_c.mul_assign(&worker, &r_beta_2_row_c_values_over_k); + f_3_c_values_over_k_by_eta_c.mul_assign(&worker, &r_beta_1_col_c_values_over_k); + + // now we need to prove the following two statements + // - f_3 sums to sigma_3 over K + // - f_3 is calculated correctly + + // first is simple, we did it many times + + let q_3_a_by_eta_a_sum_value = f_3_a_values_over_k_by_eta_a.calculate_sum(&worker)?; + let q_3_b_by_eta_b_sum_value = f_3_b_values_over_k_by_eta_b.calculate_sum(&worker)?; + let q_3_c_by_eta_c_sum_value = f_3_c_values_over_k_by_eta_c.calculate_sum(&worker)?; + + let q_3_a_by_eta_a_poly_coeffs = f_3_a_values_over_k_by_eta_a.clone().ifft(&worker); + let q_3_b_by_eta_b_poly_coeffs = f_3_b_values_over_k_by_eta_b.clone().ifft(&worker); + let q_3_c_by_eta_c_poly_coeffs = f_3_c_values_over_k_by_eta_c.clone().ifft(&worker); + + // those are M(beta_2, beta_1) + let sigma_3_a = q_3_a_by_eta_a_sum_value; + let sigma_3_b = q_3_b_by_eta_b_sum_value; + let sigma_3_c = q_3_c_by_eta_c_sum_value; + + let one_over_k = size_k_as_fe.inverse().ok_or(SynthesisError::DivisionByZero)?; + let mut tmp_a = one_over_k; + tmp_a.mul_assign(&sigma_3_a); + + let mut tmp_b = one_over_k; + tmp_b.mul_assign(&sigma_3_b); + + let mut tmp_c = one_over_k; + tmp_c.mul_assign(&sigma_3_c); + + assert!(q_3_a_by_eta_a_poly_coeffs.as_ref()[0] == tmp_a); + assert!(q_3_b_by_eta_b_poly_coeffs.as_ref()[0] == tmp_b); + assert!(q_3_c_by_eta_c_poly_coeffs.as_ref()[0] == tmp_c); + + f_3_a_values_over_k_by_eta_a.sub_constant(&worker, &tmp_a); + f_3_b_values_over_k_by_eta_b.sub_constant(&worker, &tmp_b); + f_3_c_values_over_k_by_eta_c.sub_constant(&worker, &tmp_c); + + // these are sums of f_3_m(x) - sigma_3_m / |K| + let (t_a, q_3_a_by_eta_a_grand_sum_over_k) = f_3_a_values_over_k_by_eta_a.calculate_grand_sum(&worker)?; + let (t_b, q_3_b_by_eta_b_grand_sum_over_k) = f_3_b_values_over_k_by_eta_b.calculate_grand_sum(&worker)?; + let (t_c, q_3_c_by_eta_c_grand_sum_over_k) = f_3_c_values_over_k_by_eta_c.calculate_grand_sum(&worker)?; + + assert!(t_a.is_zero()); + assert!(t_b.is_zero()); + assert!(t_c.is_zero()); + + println!("Committing Q3_A and it's sumcheck poly"); + let q_3_a_by_eta_a_commitment = commit_using_values(&f_3_a_values_over_k_by_eta_a, &crs.crs_values_on_k, &worker)?; + let q_3_a_by_eta_a_sum_commitment = commit_using_values(&q_3_a_by_eta_a_grand_sum_over_k, &crs.crs_values_on_k, &worker)?; + + println!("Committing Q3_B and it's sumcheck poly"); + let q_3_b_by_eta_b_commitment = commit_using_values(&f_3_b_values_over_k_by_eta_b, &crs.crs_values_on_k, &worker)?; + let q_3_b_by_eta_b_sum_commitment = commit_using_values(&q_3_b_by_eta_b_grand_sum_over_k, &crs.crs_values_on_k, &worker)?; + + println!("Committing Q3_C and it's sumcheck poly"); + let q_3_c_by_eta_c_commitment = commit_using_values(&f_3_c_values_over_k_by_eta_c, &crs.crs_values_on_k, &worker)?; + let q_3_c_by_eta_c_sum_commitment = commit_using_values(&q_3_c_by_eta_c_grand_sum_over_k, &crs.crs_values_on_k, &worker)?; + + // add the sum back to calculate for correspondance with vals + + let lde_factor_for_q_3_check_over_k: usize = 2; + + // this is f_3_a in the coset of size 2K + let q_3_a_by_eta_a_values_over_2k_coset = q_3_a_by_eta_a_poly_coeffs.clone().coset_lde(&worker, lde_factor_for_q_3_check_over_k)?; + let q_3_b_by_eta_b_values_over_2k_coset = q_3_b_by_eta_b_poly_coeffs.clone().coset_lde(&worker, lde_factor_for_q_3_check_over_k)?; + let q_3_c_by_eta_c_values_over_2k_coset = q_3_c_by_eta_c_poly_coeffs.clone().coset_lde(&worker, lde_factor_for_q_3_check_over_k)?; + + let rational_check_linearization_challenge = E::Fr::from_str("1337").unwrap(); + + // now proof that f_3 is a correct derivative of vals + + let vanishing_at_beta_2 = evaluate_vanishing_for_size(&beta_2, domain_h.size); + + let mut vanishing_on_beta_1_by_vanishing_on_beta_2 = vanishing_at_beta_1; + vanishing_on_beta_1_by_vanishing_on_beta_2.mul_assign(&vanishing_at_beta_2); + + let lde_factor_vals = (params.domain_k_size as usize) * lde_factor_for_q_3_check_over_k / params.a_matrix_poly.size(); + assert!(lde_factor_vals.is_power_of_two()); + + // let a_matrixes_values_over_2k_coset = params.a_matrix_poly.clone().coset_lde(&worker, lde_factor_vals)?; + // let b_matrixes_values_over_2k_coset = params.b_matrix_poly.clone().coset_lde(&worker, lde_factor_vals)?; + // let c_matrixes_values_over_2k_coset = params.c_matrix_poly.clone().coset_lde(&worker, lde_factor_vals)?; + + let lde_factor_row_col = (params.domain_k_size as usize) * lde_factor_for_q_3_check_over_k / params.a_row_poly.size(); + assert!(lde_factor_row_col.is_power_of_two()); + + // let mut a_row_poly = params.a_row_poly.clone(); + // a_row_poly.as_mut()[0].sub_assign(&beta_2); + // let mut b_row_poly = params.b_row_poly.clone(); + // b_row_poly.as_mut()[0].sub_assign(&beta_2); + // let mut c_row_poly = params.c_row_poly.clone(); + // c_row_poly.as_mut()[0].sub_assign(&beta_2); + + // let a_row_minus_beta_2_over_2k_coset = a_row_poly.coset_lde(&worker, lde_factor_row_col)?; + // let b_row_minus_beta_2_over_2k_coset = b_row_poly.coset_lde(&worker, lde_factor_row_col)?; + // let c_row_minus_beta_2_over_2k_coset = c_row_poly.coset_lde(&worker, lde_factor_row_col)?; + + // let mut a_col_poly = params.a_col_poly.clone(); + // a_col_poly.as_mut()[0].sub_assign(&beta_1); + // let mut b_col_poly = params.b_col_poly.clone(); + // b_col_poly.as_mut()[0].sub_assign(&beta_1); + // let mut c_col_poly = params.c_col_poly.clone(); + // c_col_poly.as_mut()[0].sub_assign(&beta_1); + + // let a_col_minus_beta_1_over_2k_coset = a_col_poly.coset_lde(&worker, lde_factor_row_col)?; + // let b_col_minus_beta_1_over_2k_coset = b_col_poly.coset_lde(&worker, lde_factor_row_col)?; + // let c_col_minus_beta_1_over_2k_coset = c_col_poly.coset_lde(&worker, lde_factor_row_col)?; + + let mut a_row_minus_beta_2_over_2k_coset = precomputations.a_row_over_2k_coset.clone(); + a_row_minus_beta_2_over_2k_coset.sub_constant(&worker, &beta_2); + + let mut b_row_minus_beta_2_over_2k_coset = precomputations.b_row_over_2k_coset.clone(); + b_row_minus_beta_2_over_2k_coset.sub_constant(&worker, &beta_2); + + let mut c_row_minus_beta_2_over_2k_coset = precomputations.c_row_over_2k_coset.clone(); + c_row_minus_beta_2_over_2k_coset.sub_constant(&worker, &beta_2); + + let mut a_col_minus_beta_1_over_2k_coset = precomputations.a_col_over_2k_coset.clone(); + a_col_minus_beta_1_over_2k_coset.sub_constant(&worker, &beta_1); + + let mut b_col_minus_beta_1_over_2k_coset = precomputations.b_col_over_2k_coset.clone(); + b_col_minus_beta_1_over_2k_coset.sub_constant(&worker, &beta_1); + + let mut c_col_minus_beta_1_over_2k_coset = precomputations.c_col_over_2k_coset.clone(); + c_col_minus_beta_1_over_2k_coset.sub_constant(&worker, &beta_1); + + // for each of the metrixes A/B/C you need to make sure that + // van(beta_1) * van(beta_2) * val(x) - (row(x) - beta_2)(col(x) - beta(1))*f_3_m(x) == 0 at K + // we also aggregate it in a form + // van(beta_1) * van(beta_2) * (eta_a * val_a(x) + eta_b * val_b(x) + eta_c * val_c(x)) - + // - eta_a * (row_a(x) - beta_2)(col_a(x) - beta(1))*f_3_a(x) - eta_b * ... + + // let f_3_values_over_2k_coset = q_3_poly_coeffs.clone().coset_lde(&worker, lde_factor_vals)?; + + let mut linearization_challenge = E::Fr::one(); + + let mut val_a_total_coeffs = eta_a; + val_a_total_coeffs.mul_assign(&vanishing_on_beta_1_by_vanishing_on_beta_2); + // val_a_total_coeffs.mul_assign(&linearization_challenge); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut val_b_total_coeffs = eta_b; + val_b_total_coeffs.mul_assign(&vanishing_on_beta_1_by_vanishing_on_beta_2); + val_b_total_coeffs.mul_assign(&linearization_challenge); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut val_c_total_coeffs = eta_c; + val_c_total_coeffs.mul_assign(&vanishing_on_beta_1_by_vanishing_on_beta_2); + val_c_total_coeffs.mul_assign(&linearization_challenge); + + // eta_a * vanishing(beta_1) * vanishing(beta_2) * linearization_challenge prefactor over val_a(k) + let mut f_3_well_formedness_poly_values_over_2k_coset = precomputations.a_val_over_2k_coset.clone(); + f_3_well_formedness_poly_values_over_2k_coset.scale(&worker, val_a_total_coeffs); + f_3_well_formedness_poly_values_over_2k_coset.add_assign_scaled(&worker, &precomputations.b_val_over_2k_coset, &val_b_total_coeffs); + f_3_well_formedness_poly_values_over_2k_coset.add_assign_scaled(&worker, &precomputations.c_val_over_2k_coset, &val_c_total_coeffs); + + let mut linearization_challenge = E::Fr::one(); + + // now compute a RHS + + // this contains eta_M + let mut tmp = q_3_a_by_eta_a_values_over_2k_coset; // into 2*K size + // tmp.scale(&worker, linearization_challenge); + tmp.mul_assign(&worker, &a_row_minus_beta_2_over_2k_coset); + tmp.mul_assign(&worker, &a_col_minus_beta_1_over_2k_coset); + + f_3_well_formedness_poly_values_over_2k_coset.sub_assign(&worker, &tmp); + + drop(tmp); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut tmp = q_3_b_by_eta_b_values_over_2k_coset; // into 2*K size + tmp.scale(&worker, linearization_challenge); + tmp.mul_assign(&worker, &b_row_minus_beta_2_over_2k_coset); + tmp.mul_assign(&worker, &b_col_minus_beta_1_over_2k_coset); + + f_3_well_formedness_poly_values_over_2k_coset.sub_assign(&worker, &tmp); + + drop(tmp); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut tmp = q_3_c_by_eta_c_values_over_2k_coset; // into 2*K size + tmp.scale(&worker, linearization_challenge); + tmp.mul_assign(&worker, &c_row_minus_beta_2_over_2k_coset); + tmp.mul_assign(&worker, &c_col_minus_beta_1_over_2k_coset); + + f_3_well_formedness_poly_values_over_2k_coset.sub_assign(&worker, &tmp); + + drop(tmp); + + // let domain_2k = Domain::new_for_size(domain_k.size * (lde_factor_for_q_3_check_over_k as u64))?; + + fn evaluate_vanishing_polynomial_of_degree_on_domain( + vanishing_degree: u64, + coset_factor: &F, + domain: &Domain, + worker: &Worker + ) -> Result, SynthesisError> { + let domain_generator = domain.generator; + + let coset_factor = coset_factor.pow(&[vanishing_degree]); + + let domain_generator_in_vanishing_power = domain_generator.pow(&[vanishing_degree]); + + let mut minus_one = F::one(); + minus_one.negate(); + + let mut result = vec![minus_one; domain.size as usize]; + + worker.scope(result.len(), |scope, chunk_size| { + for (chunk_id, chunk) in result.chunks_mut(chunk_size).enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + let mut pow = domain_generator_in_vanishing_power.pow(&[start as u64]); + pow.mul_assign(&coset_factor); + for el in chunk.iter_mut() { + el.add_assign(&pow); + pow.mul_assign(&domain_generator_in_vanishing_power); + } + }); + } + }); + + Polynomial::from_values(result) + } + + // let mut vanishing_of_degree_k_on_2k = evaluate_vanishing_polynomial_of_degree_on_domain( + // domain_k.size, + // &E::Fr::multiplicative_generator(), + // &domain_2k, + // &worker + // )?; + + // vanishing_of_degree_k_on_2k.batch_inversion(&worker)?; + // f_3_well_formedness_poly_values_over_2k_coset.mul_assign(&worker, &vanishing_of_degree_k_on_2k); + + // drop(vanishing_of_degree_k_on_2k); + + // We can compute faster like this if domain is of size 2k + + // we divide by the polynomial that is vanishing on k, but not on 2k + // on half of the element it's equal to the following (inversed): + let vanishing_in_coset_over_k = evaluate_vanishing_for_size(&E::Fr::multiplicative_generator(), domain_k.size); + let vanishing_in_coset_over_k = vanishing_in_coset_over_k.inverse().ok_or(SynthesisError::DivisionByZero)?; + // for other elements x^n - 1 = (generator*omega)^n - 1 = - generator^n - 1 cause omega^2n == 1 on a large domain + let mut vanishing_in_coset_over_k_shifted = E::Fr::multiplicative_generator().pow(&[domain_k.size]); + vanishing_in_coset_over_k_shifted.negate(); + vanishing_in_coset_over_k_shifted.sub_assign(&E::Fr::one()); + let vanishing_in_coset_over_k_shifted = vanishing_in_coset_over_k_shifted.inverse().ok_or(SynthesisError::DivisionByZero)?; + + worker.scope(f_3_well_formedness_poly_values_over_2k_coset.size(), |scope, chunk_size| { + for (chunk_id, chunk) in f_3_well_formedness_poly_values_over_2k_coset.as_mut().chunks_mut(chunk_size).enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + for (j, el) in chunk.iter_mut().enumerate() { + let idx = start + j; + if idx & 1 == 0 { + el.mul_assign(&vanishing_in_coset_over_k); + } else { + el.mul_assign(&vanishing_in_coset_over_k_shifted); + } + } + }); + } + }); + + let beta_3 = E::Fr::from_str("12345678890").unwrap(); + + let f_3_well_formedness_baryc_at_beta_3 = f_3_well_formedness_poly_values_over_2k_coset.barycentric_over_coset_evaluate_at( + &worker, + beta_3, + &E::Fr::multiplicative_generator() + )?; + + let (f_3_even_values_on_k, f_3_odd_values_on_k) = f_3_well_formedness_poly_values_over_2k_coset.split_into_even_and_odd_assuming_natural_ordering( + &worker, + &E::Fr::multiplicative_generator() + )?; + + // TODO: commit to the linear combination using some other linearization challenge + + let f_3_even_commitment = commit_using_values(&f_3_even_values_on_k, &crs.crs_values_on_k, &worker)?; + let f_3_odd_commitment = commit_using_values(&f_3_odd_values_on_k, &crs.crs_values_on_k, &worker)?; + + elog_verbose!("{} seconds for all the commitments", stopwatch.elapsed()); + + let mut beta_3_squared = beta_3; + beta_3_squared.square(); + + let coset_offset_inv = E::Fr::multiplicative_generator().inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut beta_3_squared_by_coset_factor_squared = beta_3_squared; + beta_3_squared_by_coset_factor_squared.mul_assign(&coset_offset_inv); + beta_3_squared_by_coset_factor_squared.mul_assign(&coset_offset_inv); + + let f_3_even_eval = f_3_even_values_on_k.barycentric_evaluate_at(&worker, beta_3_squared_by_coset_factor_squared)?; + let f_3_odd_eval = f_3_odd_values_on_k.barycentric_evaluate_at(&worker, beta_3_squared_by_coset_factor_squared)?; + + let mut lhs = f_3_odd_eval; + lhs.mul_assign(&beta_3); + lhs.add_assign(&f_3_even_eval); + + assert!(lhs == f_3_well_formedness_baryc_at_beta_3); + + // now perform the opening + + // open polynomials on domain K at beta3^2 / g^2 where g is a coset generator + + // q_3_a_by_eta_a_poly_coeffs.as_mut()[0] = E::Fr::zero(); + // q_3_b_by_eta_b_poly_coeffs.as_mut()[0] = E::Fr::zero(); + // q_3_c_by_eta_c_poly_coeffs.as_mut()[0] = E::Fr::zero(); + + let mut beta_3_by_omega = beta_3; + beta_3_by_omega.mul_assign(&domain_k.generator); + + // TODO: Evaluate those that are in a coefficient form faster + // let q_3_a_by_eta_a_eval = f_3_a_values_over_k_by_eta_a.barycentric_evaluate_at(&worker, beta_3)?; + // let q_3_b_by_eta_b_eval = f_3_b_values_over_k_by_eta_b.barycentric_evaluate_at(&worker, beta_3)?; + // let q_3_c_by_eta_c_eval = f_3_c_values_over_k_by_eta_c.barycentric_evaluate_at(&worker, beta_3)?; + let q_3_a_by_eta_a_eval = q_3_a_by_eta_a_poly_coeffs.evaluate_at(&worker, beta_3); + let q_3_b_by_eta_b_eval = q_3_b_by_eta_b_poly_coeffs.evaluate_at(&worker, beta_3); + let q_3_c_by_eta_c_eval = q_3_c_by_eta_c_poly_coeffs.evaluate_at(&worker, beta_3); + drop(q_3_a_by_eta_a_poly_coeffs); + drop(q_3_b_by_eta_b_poly_coeffs); + drop(q_3_c_by_eta_c_poly_coeffs); + let q_3_a_by_eta_a_sum_eval = q_3_a_by_eta_a_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3)?; + let q_3_b_by_eta_b_sum_eval = q_3_b_by_eta_b_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3)?; + let q_3_c_by_eta_c_sum_eval = q_3_c_by_eta_c_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3)?; + let q_3_a_by_eta_a_sum_eval_shifted = q_3_a_by_eta_a_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3_by_omega)?; + let q_3_b_by_eta_b_sum_eval_shifted = q_3_b_by_eta_b_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3_by_omega)?; + let q_3_c_by_eta_c_sum_eval_shifted = q_3_c_by_eta_c_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_3_by_omega)?; + + let val_a_eval = params.a_matrix_poly.evaluate_at(&worker, beta_3); + let val_b_eval = params.b_matrix_poly.evaluate_at(&worker, beta_3); + let val_c_eval = params.c_matrix_poly.evaluate_at(&worker, beta_3); + + let row_a_eval = params.a_row_poly.evaluate_at(&worker, beta_3); + let row_b_eval = params.b_row_poly.evaluate_at(&worker, beta_3); + let row_c_eval = params.c_row_poly.evaluate_at(&worker, beta_3); + + let col_a_eval = params.a_col_poly.evaluate_at(&worker, beta_3); + let col_b_eval = params.b_col_poly.evaluate_at(&worker, beta_3); + let col_c_eval = params.c_col_poly.evaluate_at(&worker, beta_3); + + let polys_for_opening_for_domain_k_at_beta_3_by_gen = vec![ + f_3_even_values_on_k, + f_3_odd_values_on_k, + ]; + + let values_for_opening_for_domain_k_at_beta_3_by_gen = vec![ + f_3_even_eval, + f_3_odd_eval, + ]; + + let challenge_1 = E::Fr::from_str("99999").unwrap(); + + let (mut aggregation_on_k, next_challenge) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_k_at_beta_3_by_gen, + beta_3_squared_by_coset_factor_squared, + &values_for_opening_for_domain_k_at_beta_3_by_gen, + challenge_1, + E::Fr::one(), + &worker + )?; + + let polys_for_opening_for_domain_k_at_beta_3 = vec![ + precomputations.a_val_over_k.clone(), + precomputations.b_val_over_k.clone(), + precomputations.c_val_over_k.clone(), + precomputations.a_row_over_k.clone(), + precomputations.b_row_over_k.clone(), + precomputations.c_row_over_k.clone(), + precomputations.a_col_over_k.clone(), + precomputations.b_col_over_k.clone(), + precomputations.c_col_over_k.clone(), + f_3_a_values_over_k_by_eta_a, + f_3_b_values_over_k_by_eta_b, + f_3_c_values_over_k_by_eta_c, + q_3_a_by_eta_a_grand_sum_over_k.clone(), + q_3_b_by_eta_b_grand_sum_over_k.clone(), + q_3_c_by_eta_c_grand_sum_over_k.clone(), + ]; + + let values_for_opening_for_domain_k_at_beta_3 = vec![ + val_a_eval, + val_b_eval, + val_c_eval, + row_a_eval, + row_b_eval, + row_c_eval, + col_a_eval, + col_b_eval, + col_c_eval, + q_3_a_by_eta_a_eval, + q_3_b_by_eta_b_eval, + q_3_c_by_eta_c_eval, + q_3_a_by_eta_a_sum_eval, + q_3_b_by_eta_b_sum_eval, + q_3_c_by_eta_c_sum_eval, + ]; + + let (aggregation_at_beta_3, next_challenge) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_k_at_beta_3, + beta_3, + &values_for_opening_for_domain_k_at_beta_3, + challenge_1, + next_challenge, + &worker + )?; + + aggregation_on_k.add_assign(&worker, &aggregation_at_beta_3); + drop(aggregation_at_beta_3); + + let polys_for_opening_for_domain_k_at_beta_3_by_omega = vec![ + q_3_a_by_eta_a_grand_sum_over_k, + q_3_b_by_eta_b_grand_sum_over_k, + q_3_c_by_eta_c_grand_sum_over_k, + ]; + + let values_for_opening_for_domain_k_at_beta_3_by_omega = vec![ + q_3_a_by_eta_a_sum_eval_shifted, + q_3_b_by_eta_b_sum_eval_shifted, + q_3_c_by_eta_c_sum_eval_shifted, + ]; + + let (aggregation_at_beta_3_by_omega, _) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_k_at_beta_3_by_omega, + beta_3_by_omega, + &values_for_opening_for_domain_k_at_beta_3_by_omega, + challenge_1, + next_challenge, + &worker + )?; + + aggregation_on_k.add_assign(&worker, &aggregation_at_beta_3_by_omega); + drop(aggregation_at_beta_3_by_omega); + + let proof_on_k = commit_using_values( + &aggregation_on_k, + &crs.crs_values_on_k, + &worker + )?; + + + // TODO: add aggregate here to compute for openings of individual + // f_3_a_values_over_k_by_eta_a, + // f_3_b_values_over_k_by_eta_b, + // f_3_c_values_over_k_by_eta_c, + // q_3_a_by_eta_a_eval, + // q_3_b_by_eta_b_eval, + // q_3_c_by_eta_c_eval, + + // Open everything on beta_2 (on domain H) + + // Since we are opening not the polynomial, but it's content with zero coefficient - set constant terms + + // q_3_a_by_eta_a_poly_coeffs.as_mut()[0] = E::Fr::zero(); + // q_3_b_by_eta_b_poly_coeffs.as_mut()[0] = E::Fr::zero(); + // q_3_c_by_eta_c_poly_coeffs.as_mut()[0] = E::Fr::zero(); + + // TODO: Evaluate those that are in a coefficient form faster + // let q_3_a_by_eta_a_eval = f_3_a_values_over_k_by_eta_a.barycentric_evaluate_at(&worker, beta_3)?; + // let q_3_b_by_eta_a_eval = f_3_b_values_over_k_by_eta_b.barycentric_evaluate_at(&worker, beta_3)?; + // let q_3_c_by_eta_a_eval = f_3_c_values_over_k_by_eta_c.barycentric_evaluate_at(&worker, beta_3)?; + // let q_3_a_by_eta_a_eval = q_3_a_by_eta_a_poly_coeffs.evaluate_at(&worker, beta_2); + // let q_3_b_by_eta_a_eval = q_3_b_by_eta_b_poly_coeffs.evaluate_at(&worker, beta_2); + // let q_3_c_by_eta_a_eval = q_3_c_by_eta_c_poly_coeffs.evaluate_at(&worker, beta_2); + // let q_3_a_by_eta_a_sum_eval = q_3_a_by_eta_a_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2)?; + // let q_3_b_by_eta_b_sum_eval = q_3_b_by_eta_b_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2)?; + // let q_3_c_by_eta_c_sum_eval = q_3_c_by_eta_c_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2)?; + // let q_3_a_by_eta_a_sum_eval_shifted = q_3_a_by_eta_a_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2_by_omega)?; + // let q_3_b_by_eta_b_sum_eval_shifted = q_3_b_by_eta_b_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2_by_omega)?; + // let q_3_c_by_eta_c_sum_eval_shifted = q_3_c_by_eta_c_grand_sum_over_k.barycentric_evaluate_at(&worker, beta_2_by_omega)?; + + + // let challenge_2 = E::Fr::from_str("999991234").unwrap(); + + // let polys_for_opening_for_domain_k_at_beta_3 = vec![ + // f_3_a_values_over_k_by_eta_a, + // f_3_b_values_over_k_by_eta_b, + // f_3_c_values_over_k_by_eta_c, + // // q_3_a_by_eta_a_grand_sum_over_k.clone(), + // // q_3_b_by_eta_b_grand_sum_over_k.clone(), + // // q_3_c_by_eta_c_grand_sum_over_k.clone(), + // ]; + + // let values_for_opening_for_domain_k_at_beta_3 = vec![ + // q_3_a_by_eta_a_eval, + // q_3_b_by_eta_a_eval, + // q_3_c_by_eta_a_eval, + // // q_3_a_by_eta_a_sum_eval, + // // q_3_b_by_eta_b_sum_eval, + // // q_3_c_by_eta_c_sum_eval, + // ]; + + // let proof_for_f_3_grand_sums_at_beta_3 = perform_batch_opening_from_values( + // polys_for_opening_for_domain_k_at_beta_3, + // &crs.crs_values_on_k, + // beta_3, + // &polys_for_opening_for_domain_k_at_beta_3, + // challenge_2, + // &worker + // )?; + + // let challenge_3 = E::Fr::from_str("99999").unwrap(); + + // let polys_for_opening_for_domain_k_at_beta_2_by_omega = vec![ + // q_3_a_by_eta_a_grand_sum_over_k, + // q_3_b_by_eta_b_grand_sum_over_k, + // q_3_c_by_eta_c_grand_sum_over_k, + // ]; + + // let values_for_opening_for_domain_k_at_beta_2_by_omega = vec![ + // q_3_a_by_eta_a_sum_eval_shifted, + // q_3_b_by_eta_b_sum_eval_shifted, + // q_3_c_by_eta_c_sum_eval_shifted, + // ]; + + // let proof_for_f_3_grand_sums_at_beta_2_by_omega = perform_batch_opening_from_values( + // polys_for_opening_for_domain_k_at_beta_2_by_omega, + // &crs.crs_values_on_k, + // beta_2_by_omega, + // &values_for_opening_for_domain_k_at_beta_2_by_omega, + // challenge_3, + // &worker + // )?; + + // open everything else on beta_2 (domain H) + + let mut beta_2_by_omega = beta_2; + beta_2_by_omega.mul_assign(&domain_h.generator); + + let challenge_2 = E::Fr::from_str("9999999").unwrap(); + + // polynomial q_2 DOES HAVE it's constant term set to zero, so we need to add a constant term here + // at the evaluation step! + let mut q_2_eval_at_beta_2 = q_2_poly_values_on_h.barycentric_evaluate_at(&worker, beta_2)?; + let mut sigma_2_over_size_of_h = one_over_h_size; + sigma_2_over_size_of_h.mul_assign(&sigma_2); + q_2_eval_at_beta_2.add_assign(&sigma_2_over_size_of_h); + + let q_2_sum_eval_at_beta_2 = q_2_grand_sum_over_h.barycentric_evaluate_at(&worker, beta_2)?; + let q_2_sum_eval_at_beta_2_shifted = q_2_grand_sum_over_h.barycentric_evaluate_at(&worker, beta_2_by_omega)?; + + let polys_for_opening_for_domain_h_at_beta_2 = vec![ + q_2_poly_values_on_h, + q_2_grand_sum_over_h.clone(), + ]; + + let values_for_opening_for_domain_h_at_beta_2 = vec![ + q_2_eval_at_beta_2, + q_2_sum_eval_at_beta_2, + ]; + + let (mut aggregation_on_h, next_challenge) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_h_at_beta_2, + beta_2, + &values_for_opening_for_domain_h_at_beta_2, + challenge_2, + E::Fr::one(), + &worker + )?; + + let polys_for_opening_for_domain_h_at_beta_2_by_omega = vec![ + q_2_grand_sum_over_h, + ]; + + let values_for_opening_for_domain_h_at_beta_2_by_omega = vec![ + q_2_sum_eval_at_beta_2_shifted, + ]; + + let (aggregation_at_beta_2_by_omega, next_challenge) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_h_at_beta_2_by_omega, + beta_2_by_omega, + &values_for_opening_for_domain_h_at_beta_2_by_omega, + challenge_2, + next_challenge, + &worker + )?; + + + aggregation_on_h.add_assign(&worker, &aggregation_at_beta_2_by_omega); + drop(aggregation_at_beta_2_by_omega); + + // add everything else on beta_1 (domain H) + + let mut beta_1_by_omega = beta_1; + beta_1_by_omega.mul_assign(&domain_h.generator); + + // let q_1_eval_at_beta_1 = q_1_poly_values_over_h.barycentric_evaluate_at(&worker, beta_1)?; + // let q_1_sum_eval_at_beta_1 = q_1_grand_sum_poly_values_over_h.barycentric_evaluate_at(&worker, beta_1)?; + // let q_1_sum_eval_at_beta_1_shifted = q_1_grand_sum_poly_values_over_h.barycentric_evaluate_at(&worker, beta_1_by_omega)?; + + let q_1_eval_at_beta_1 = proper_q_1_values_on_2h.barycentric_evaluate_at(&worker, beta_1)?; + let q_1_sum_eval_at_beta_1 = proper_q_1_grand_sum_poly_values_over_2h.barycentric_evaluate_at(&worker, beta_1)?; + let q_1_sum_eval_at_beta_1_shifted = proper_q_1_grand_sum_poly_values_over_2h.barycentric_evaluate_at(&worker, beta_1_by_omega)?; + let w_at_beta_1 = witness_values_on_h.barycentric_evaluate_at(&worker, beta_1)?; + let q_1_quotient_at_beta_1 = q_1_quotient_on_h.barycentric_evaluate_at(&worker, beta_1)?; + + let polys_for_opening_for_domain_h_at_beta_1 = vec![ + a_values_on_h, + b_values_on_h, + c_values_on_h, + h_poly_values_on_h, + witness_values_on_h, + // q_1_poly_values_over_h, + // q_1_grand_sum_poly_values_over_h.clone(), + ]; + + let values_for_opening_for_domain_h_at_beta_1 = vec![ + a_at_beta_1, + b_at_beta_1, + c_at_beta_1, + h_at_beta_1, + w_at_beta_1, + // q_1_eval_at_beta_1, + // q_1_sum_eval_at_beta_1 + ]; + + let (aggregation_at_beta_1, next_challenge) = perform_batched_divisor_for_opening::( + polys_for_opening_for_domain_h_at_beta_1, + beta_1, + &values_for_opening_for_domain_h_at_beta_1, + challenge_2, + next_challenge, + &worker + )?; + + aggregation_on_h.add_assign(&worker, &aggregation_at_beta_1); + drop(aggregation_at_beta_1); + + // let polys_for_opening_for_domain_h_at_beta_1_by_omega = vec![ + // q_1_grand_sum_poly_values_over_h, + // ]; + + // let values_for_opening_for_domain_h_at_beta_1_by_omega = vec![ + // q_1_sum_eval_at_beta_1_shifted + // ]; + + // let (aggregation_at_beta_1_by_omega, _) = perform_batched_divisor_for_opening::( + // polys_for_opening_for_domain_h_at_beta_1_by_omega, + // beta_1_by_omega, + // &values_for_opening_for_domain_h_at_beta_1_by_omega, + // challenge_2, + // next_challenge, + // &worker + // )?; + + // aggregation_on_h.add_assign(&worker, &aggregation_at_beta_1_by_omega); + // drop(aggregation_at_beta_1_by_omega); + + // this is an opening for everything on H + + let proof_on_h = commit_using_values( + &aggregation_on_h, + &crs.crs_values_on_h, + &worker + )?; + + // fun time - do the checks + + fn compute_from_even_and_odd( + even: F, + odd: F, + at: F, + ) -> F { + let mut res = odd; + res.mul_assign(&at); + res.add_assign(&even); + + res + } + + // first check f3 wellformedness + { + // vanishing(beta_1) * vanishing(beta_2) * val_m(z) - (beta_2 - row_m(z))(beta_1 - col_m(z)) q_3_m(z) = wellformedness(z)*vanishing(z) + + let vanishing_at_beta_3 = evaluate_vanishing_for_size(&beta_3, domain_k.size); + + let f_3_at_beta_3 = compute_from_even_and_odd(f_3_even_eval, f_3_odd_eval, beta_3); + + assert_eq!(f_3_well_formedness_baryc_at_beta_3, f_3_at_beta_3, "f_3 is reconstructed properly"); + + let val_a_at_beta_3 = val_a_eval; + let val_b_at_beta_3 = val_b_eval; + let val_c_at_beta_3 = val_c_eval; + + let row_a_at_beta_3 = row_a_eval; + let row_b_at_beta_3 = row_b_eval; + let row_c_at_beta_3 = row_c_eval; + + let col_a_at_beta_3 = col_a_eval; + let col_b_at_beta_3 = col_b_eval; + let col_c_at_beta_3 = col_c_eval; + + let mut lhs = E::Fr::zero(); + let mut linearization_challenge = E::Fr::one(); + + let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + tmp.mul_assign(&val_a_at_beta_3); + tmp.mul_assign(&eta_a); + + let mut t_row = beta_2; + t_row.sub_assign(&row_a_at_beta_3); + + let mut t_col = beta_1; + t_col.sub_assign(&col_a_at_beta_3); + + t_row.mul_assign(&t_col); + t_row.mul_assign(&q_3_a_by_eta_a_eval); + tmp.sub_assign(&t_row); + tmp.mul_assign(&linearization_challenge); + + lhs.add_assign(&tmp); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + tmp.mul_assign(&val_b_at_beta_3); + tmp.mul_assign(&eta_b); + + let mut t_row = beta_2; + t_row.sub_assign(&row_b_at_beta_3); + + let mut t_col = beta_1; + t_col.sub_assign(&col_b_at_beta_3); + + t_row.mul_assign(&t_col); + t_row.mul_assign(&q_3_b_by_eta_b_eval); + tmp.sub_assign(&t_row); + tmp.mul_assign(&linearization_challenge); + + lhs.add_assign(&tmp); + + linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + tmp.mul_assign(&val_c_at_beta_3); + tmp.mul_assign(&eta_c); + + let mut t_row = beta_2; + t_row.sub_assign(&row_c_at_beta_3); + + let mut t_col = beta_1; + t_col.sub_assign(&col_c_at_beta_3); + + t_row.mul_assign(&t_col); + t_row.mul_assign(&q_3_c_by_eta_c_eval); + tmp.sub_assign(&t_row); + tmp.mul_assign(&linearization_challenge); + + lhs.add_assign(&tmp); + + let mut rhs = vanishing_at_beta_3; + rhs.mul_assign(&f_3_at_beta_3); + + assert_eq!(lhs, rhs, "f_3 wellformedness check"); + + // sumchecks for q_3_m polys + + let mut sigma_3_a_over_size_of_k = one_over_k; + sigma_3_a_over_size_of_k.mul_assign(&sigma_3_a); + + let mut lhs = q_3_a_by_eta_a_eval; + lhs.sub_assign(&q_3_a_by_eta_a_sum_eval_shifted); + lhs.add_assign(&q_3_a_by_eta_a_sum_eval); + lhs.sub_assign(&sigma_3_a_over_size_of_k); + + let rhs = E::Fr::zero(); + + assert_eq!(lhs, rhs, "q_3_a sumcheck"); + + let mut sigma_3_b_over_size_of_k = one_over_k; + sigma_3_b_over_size_of_k.mul_assign(&sigma_3_b); + + let mut lhs = q_3_b_by_eta_b_eval; + lhs.sub_assign(&q_3_b_by_eta_b_sum_eval_shifted); + lhs.add_assign(&q_3_b_by_eta_b_sum_eval); + lhs.sub_assign(&sigma_3_b_over_size_of_k); + + let rhs = E::Fr::zero(); + + assert_eq!(lhs, rhs, "q_3_b sumcheck"); + + let mut sigma_3_c_over_size_of_k = one_over_k; + sigma_3_c_over_size_of_k.mul_assign(&sigma_3_c); + + let mut lhs = q_3_c_by_eta_c_eval; + lhs.sub_assign(&q_3_c_by_eta_c_sum_eval_shifted); + lhs.add_assign(&q_3_c_by_eta_c_sum_eval); + lhs.sub_assign(&sigma_3_c_over_size_of_k); + + let rhs = E::Fr::zero(); + + assert_eq!(lhs, rhs, "q_3_c sumcheck"); + } + + // sumcheck for q_2 + + { + // r(alpha, beta_2) * sigma_3 = sigma_2 + let r_alpha_beta_2 = evaluate_bivariate_lagrange_at_point( + alpha, + beta_2, + domain_h.size + )?; + + println!("r(alpha, beta_2) = {}", r_alpha_beta_2); + + // sigma_3_m = eta_m * M(beta_2, beta_1); + + // q_2(beta_2) = r(alpha, beta_2) * \sum_{m} M(beta_2, beta_1) + + // so we do a sumcheck of q_2(beta_2) - q_2_sum(beta_2 * omega) - q_2_sum(beta_2) - sigma_2/|H| = 0 + + println!("Sigma_3_a = {}", sigma_3_a); + println!("Sigma_3_b = {}", sigma_3_b); + println!("Sigma_3_c = {}", sigma_3_c); + + // reconstruct sigma_2 from the q_3 chunks + let mut sigma_3_reconstructed = E::Fr::zero(); + // these contain eta_m already + sigma_3_reconstructed.add_assign(&sigma_3_a); + sigma_3_reconstructed.add_assign(&sigma_3_b); + sigma_3_reconstructed.add_assign(&sigma_3_c); + + let mut q_2_at_beta_reconstructed = r_alpha_beta_2; + q_2_at_beta_reconstructed.mul_assign(&sigma_3_reconstructed); + + let mut tmp_1 = q_2_at_beta_reconstructed.inverse().unwrap(); + tmp_1.mul_assign(&q_2_eval_at_beta_2); + + println!("tmp 1 = {}", tmp_1); + + let mut tmp_2 = q_2_eval_at_beta_2.inverse().unwrap(); + tmp_2.mul_assign(&q_2_at_beta_reconstructed); + + println!("tmp 2 = {}", tmp_2); + + let mut tmp_3 = r_m_x_beta_1_at_beta_2; + tmp_3.sub_assign(&sigma_3_a); + println!("tmp 3 = {}", tmp_3); + + println!("Sigma_2 = {}", sigma_2); + + // assert_eq!(q_2_eval_at_beta_2, q_2_at_beta_reconstructed, "q_2(beta_2) reconstruction"); + + let mut sigma_2_over_size_of_h = one_over_h_size; + sigma_2_over_size_of_h.mul_assign(&sigma_2); + + let mut lhs = q_2_eval_at_beta_2; + lhs.sub_assign(&q_2_sum_eval_at_beta_2_shifted); + lhs.add_assign(&q_2_sum_eval_at_beta_2); + lhs.sub_assign(&sigma_2_over_size_of_h); + + let rhs = E::Fr::zero(); + + assert_eq!(lhs, rhs, "q_2 sumcheck"); + } + + // sumcheck for q_1 + + { + // reconstruct value of r(alpha, beta_1) * \sum_{m} z_m(beta_1) - (sum{m} M(beta_1, alpha)) * w(beta_1) = q_1(beta_1) + + let r_alpha_beta_1 = evaluate_bivariate_lagrange_at_point( + alpha, + beta_1, + domain_h.size + )?; + + let mut lhs = sum_a_b_c_at_beta_1; + lhs.mul_assign(&r_alpha_beta_1); + + let mut rhs = sum_m_at_beta_1; + rhs.mul_assign(&w_at_beta_1); + + let mut reconstructed_q_1_at_beta_1 = lhs; + reconstructed_q_1_at_beta_1.sub_assign(&rhs); + + assert_eq!(reconstructed_q_1_at_beta_1, q_1_eval_at_beta_1, "lincheck"); + + let mut reconstructed_q_1_at_beta_1 = E::Fr::zero(); + + let mut tmp = a_at_beta_1; + tmp.mul_assign(&eta_a); + reconstructed_q_1_at_beta_1.add_assign(&tmp); + + let mut tmp = b_at_beta_1; + tmp.mul_assign(&eta_b); + reconstructed_q_1_at_beta_1.add_assign(&tmp); + + let mut tmp = c_at_beta_1; + tmp.mul_assign(&eta_c); + reconstructed_q_1_at_beta_1.add_assign(&tmp); + + reconstructed_q_1_at_beta_1.mul_assign(&r_alpha_beta_1); + + let mut tmp = sigma_2; + tmp.mul_assign(&w_at_beta_1); + reconstructed_q_1_at_beta_1.sub_assign(&tmp); + + // assert_eq!(reconstructed_q_1_at_beta_1, q_1_eval_at_beta_1, "q_1 at beta_1 reconstruciton"); + + // let mut lhs = q_1_eval_at_beta_1; + // lhs.sub_assign(&q_1_sum_eval_at_beta_1_shifted); + // lhs.add_assign(&q_1_sum_eval_at_beta_1); + + // let rhs = E::Fr::zero(); + + // assert_eq!(lhs, rhs, "q_1 sumcheck"); + + let mut lhs = q_1_eval_at_beta_1; + lhs.sub_assign(&q_1_sum_eval_at_beta_1_shifted); + lhs.add_assign(&q_1_sum_eval_at_beta_1); + + let mut rhs = q_1_quotient_at_beta_1; + rhs.mul_assign(&vanishing_at_beta_1); + + assert_eq!(lhs, rhs, "q_1 sumcheck"); + } + + // last check: a*b - c = v_H * h + + { + let mut lhs = a_at_beta_1; + lhs.mul_assign(&b_at_beta_1); + lhs.sub_assign(&c_at_beta_1); + + let mut rhs = h_at_beta_1; + rhs.mul_assign(&vanishing_at_beta_1); + + assert!(lhs == rhs, "ab - c == h * z_H"); + } + + // assert!(valid, "f_3 wellformedness"); + + // now we need to perform all the openings + + // For domain K: + // - val_a_at_z, val_b_at_z, val_c_at_z + // - row_a_at_z, row_b_at_z, row_c_at_z + // - col_a_at_z, col_b_at_z, col_c_at_z + // - q_3_a_by_eta_a_commitment at z, + // - q_3_a_by_eta_a_sum_commitment at z and at z*omega + // - q_3_b_by_eta_a_commitment at z, + // - q_3_b_by_eta_a_sum_commitment at z and at z*omega + // - q_3_c_by_eta_a_commitment at z, + // - q_3_c_by_eta_a_sum_commitment at z and at z*omega + + // For domain 2K (and we can move it into two openings on K): + // - f_3_well_formedness_poly_at_z + + // for domain H: + // - z_a_at_z, z_b_at_z, z_c_at_z, h_at_z + // - q_1_at_z, q_1_sum_at_z, q_1_sum_at_z_omega + // - q_2_at_z, q_2_sum_at_z, q_2_sum_at_z_omega + + + + // // ------------------------------------------- + + // // sanity checks + + + + // let q_3_a_by_eta_a_at_z = q_3_a_by_eta_a_poly_coeffs.evaluate_at(&worker, z); + // let q_3_b_by_eta_b_at_z = q_3_b_by_eta_b_poly_coeffs.evaluate_at(&worker, z); + // let q_3_c_by_eta_c_at_z = q_3_c_by_eta_c_poly_coeffs.evaluate_at(&worker, z); + // let val_a_at_z = params.a_matrix_poly.evaluate_at(&worker, z); + // let val_b_at_z = params.b_matrix_poly.evaluate_at(&worker, z); + // let val_c_at_z = params.c_matrix_poly.evaluate_at(&worker, z); + // let row_a_at_z = params.a_row_poly.evaluate_at(&worker, z); + // let row_b_at_z = params.b_row_poly.evaluate_at(&worker, z); + // let row_c_at_z = params.c_row_poly.evaluate_at(&worker, z); + // let col_a_at_z = params.a_col_poly.evaluate_at(&worker, z); + // let col_b_at_z = params.b_col_poly.evaluate_at(&worker, z); + // let col_c_at_z = params.c_col_poly.evaluate_at(&worker, z); + // let vanishing_at_z = evaluate_vanishing_for_size(&z, domain_k.size); + + // // vanishing(beta_1) * vanishing(beta_2) * val_m(z) - (beta_2 - row_m(z))(beta_1 - col_m(z)) q_3_m(z) = wellformedness(z)*vanishing(z) + + // let mut lhs = E::Fr::zero(); + // let mut linearization_challenge = E::Fr::one(); + + // let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + // tmp.mul_assign(&val_a_at_z); + // tmp.mul_assign(&eta_a); + + // let mut t_row = beta_2; + // t_row.sub_assign(&row_a_at_z); + + // let mut t_col = beta_1; + // t_col.sub_assign(&col_a_at_z); + + // t_row.mul_assign(&t_col); + // t_row.mul_assign(&q_3_a_by_eta_a_at_z); + // tmp.sub_assign(&t_row); + // tmp.mul_assign(&linearization_challenge); + + // lhs.add_assign(&tmp); + + // linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + // let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + // tmp.mul_assign(&val_b_at_z); + // tmp.mul_assign(&eta_b); + + // let mut t_row = beta_2; + // t_row.sub_assign(&row_b_at_z); + + // let mut t_col = beta_1; + // t_col.sub_assign(&col_b_at_z); + + // t_row.mul_assign(&t_col); + // t_row.mul_assign(&q_3_b_by_eta_b_at_z); + // tmp.sub_assign(&t_row); + // tmp.mul_assign(&linearization_challenge); + + // lhs.add_assign(&tmp); + + // linearization_challenge.mul_assign(&rational_check_linearization_challenge); + + // let mut tmp = vanishing_on_beta_1_by_vanishing_on_beta_2; + // tmp.mul_assign(&val_c_at_z); + // tmp.mul_assign(&eta_c); + + // let mut t_row = beta_2; + // t_row.sub_assign(&row_c_at_z); + + // let mut t_col = beta_1; + // t_col.sub_assign(&col_c_at_z); + + // t_row.mul_assign(&t_col); + // t_row.mul_assign(&q_3_c_by_eta_c_at_z); + // tmp.sub_assign(&t_row); + // tmp.mul_assign(&linearization_challenge); + + // lhs.add_assign(&tmp); + + // let mut rhs = vanishing_at_z; + // rhs.mul_assign(&f_3_well_formedness_poly_at_z); + + // assert_eq!(lhs, rhs); + + // let mut z_by_omega_k = z; + // z_by_omega_k.mul_assign(&domain_k.generator); + + // let q_3_a_by_eta_a_grand_sum_poly_at_z = q_3_a_grand_sum_poly_coeffs.evaluate_at(&worker, z); + // let q_3_a_by_eta_a_grand_sum_poly_at_z_omega = q_3_a_grand_sum_poly_coeffs.evaluate_at(&worker, z_by_omega_k); + // let q_3_a_by_eta_a_values_poly_at_z = q_3_a_by_eta_a_poly_coeffs.evaluate_at(&worker, z); + // let q_3_a_sumcheck_poly_at_z = E::Fr::zero(); + + // // sum(z*omega) = sum(z) + el(z) everywhere on k + // // el(z) is actually el(z) - sigma_3/Domain_size + + // // sum(z*omega) - sum(z) - (el(z) - sum_over_k(el)) = vanishing(z) * quotient(z) + + // let mut sigma_3_a_over_size_of_k = one_over_k; + // sigma_3_a_over_size_of_k.mul_assign(&sigma_3_a); + + // let mut lhs = q_3_a_by_eta_a_grand_sum_poly_at_z; + // lhs.sub_assign(&q_3_a_by_eta_a_grand_sum_poly_at_z_omega); + // lhs.add_assign(&q_3_a_by_eta_a_values_poly_at_z); + // lhs.sub_assign(&sigma_3_a_over_size_of_k); + + // let mut rhs = vanishing_at_z; + // rhs.mul_assign(&q_3_a_sumcheck_poly_at_z); + + // assert_eq!(lhs, rhs); + + Ok(()) + } +} + +impl ConstraintSystem for ProvingAssignment { + type Root = Self; + + fn alloc( + &mut self, + _: A, + f: F + ) -> Result + where F: FnOnce() -> Result, A: FnOnce() -> AR, AR: Into + { + self.aux_assignment.push(f()?); + + Ok(Variable(Index::Aux(self.aux_assignment.len() - 1))) + } + + fn alloc_input( + &mut self, + _: A, + f: F + ) -> Result + where F: FnOnce() -> Result, A: FnOnce() -> AR, AR: Into + { + self.input_assignment.push(f()?); + + Ok(Variable(Index::Input(self.input_assignment.len() - 1))) + } + + fn enforce( + &mut self, + _: A, + a: LA, + b: LB, + c: LC + ) + where A: FnOnce() -> AR, AR: Into, + LA: FnOnce(LinearCombination) -> LinearCombination, + LB: FnOnce(LinearCombination) -> LinearCombination, + LC: FnOnce(LinearCombination) -> LinearCombination + { + let a = a(LinearCombination::zero()); + let b = b(LinearCombination::zero()); + let c = c(LinearCombination::zero()); + + self.a.push(eval( + a, + &self.input_assignment, + &self.aux_assignment + )); + self.b.push(eval( + b, + &self.input_assignment, + &self.aux_assignment + )); + self.c.push(eval( + c, + &self.input_assignment, + &self.aux_assignment + )); + } + + fn push_namespace(&mut self, _: N) + where NR: Into, N: FnOnce() -> NR + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) + { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +// pub fn create_random_proof>( +// circuit: C, +// params: P, +// rng: &mut R +// ) -> Result, SynthesisError> +// where E: Engine, C: Circuit, R: Rng +// { +// let r = rng.gen(); +// let s = rng.gen(); + +// create_proof::(circuit, params, r, s) +// } + +pub fn create_proof( + circuit: C, + params: &IndexedSetup, + bases: &PrecomputedBases, +) -> Result<(), SynthesisError> + where E: Engine, C: Circuit +{ + let worker = Worker::new(); + println!("Start making precomputations"); + let precomputations = IndexPrecomputations::new(¶ms, &worker).expect("must precompute"); + println!("Done making precomputations"); + let prover = prepare_prover(circuit)?; + + prover.create_proof(params, &bases, &precomputations) +} + +pub fn test_over_engine_and_circuit + Clone>( + circuit: C, +) { + let params = generate_parameters(circuit.clone()).unwrap(); + let worker = Worker::new(); + + let bases = PrecomputedBases::::new_42_for_index(¶ms, &worker); + + println!("Params domain H size = {}", params.domain_h_size); + println!("Params domain K size = {}", params.domain_k_size); + + let _ = create_proof(circuit, ¶ms, &bases).unwrap(); +} + +pub fn test_over_engine_and_circuit_with_proving_key + Clone>( + circuit: C, + base_path: String +) { + let params = generate_parameters(circuit.clone()).unwrap(); + + let bases = read_test_keys::(base_path); + + println!("Params domain H size = {}", params.domain_h_size); + println!("Params domain K size = {}", params.domain_k_size); + + let _ = create_proof(circuit, ¶ms, &bases).unwrap(); +} + +pub fn serialize_bases>( + bases: &PrecomputedBases, + h_file_path: P, + k_file_path: P +) -> std::io::Result<()> { + // let mut h_writer = std::fs::File::open(h_file_path)?; + // let mut k_writer = std::fs::File::open(k_file_path)?; + + let mut h_writer = std::fs::File::create(h_file_path)?; + let mut k_writer = std::fs::File::create(k_file_path)?; + + bases.crs_values_on_h.write(&mut h_writer)?; + bases.crs_values_on_k.write(&mut k_writer)?; + + Ok(()) +} + +pub fn deserialize_bases>( + h_file_path: P, + k_file_path: P +) -> Result, SynthesisError> { + let mut h_reader = std::fs::File::open(h_file_path)?; + let mut k_reader = std::fs::File::open(k_file_path)?; + + let h_values = Crs::::read(&mut h_reader)?; + let k_values = Crs::::read(&mut k_reader)?; + + let new = PrecomputedBases::{ + crs_values_on_h: h_values, + crs_values_on_k: k_values, + }; + + Ok(new) +} + +pub fn create_test_keys + Clone>( + circuit: C, + base_file_name: String +) { + let params = generate_parameters(circuit.clone()).unwrap(); + + let path_h = format!("{}_h.key", base_file_name); + let path_k = format!("{}_k.key", base_file_name); + + let worker = Worker::new(); + + let bases = PrecomputedBases::new_42_for_index(¶ms, &worker); + + serialize_bases(&bases, &path_h, &path_k).expect("must serialize the bases"); +} + +pub fn read_test_keys( + base_file_name: String +) -> PrecomputedBases { + let path_h = format!("{}_h.key", base_file_name); + let path_k = format!("{}_k.key", base_file_name); + + let bases = deserialize_bases::(&path_h, &path_k).expect("must read the bases"); + + bases +} + +#[cfg(test)] +mod test { + use crate::tests::XORDemo; + use crate::plonk::domains::*; + use crate::worker::Worker; + use super::*; + use std::marker::PhantomData; + use super::super::generator::*; + + #[test] + fn test_proving_1() { + use crate::pairing::bn256::{Bn256}; + + let c = XORDemo:: { + a: Some(true), + b: Some(true), + _marker: PhantomData + }; + + test_over_engine_and_circuit(c); + } + + #[test] + fn test_proving_2() { + use crate::pairing::bn256::{Bn256, Fr}; + + let c = IndexerTester:: { + a: None, + b: None, + }; + + test_over_engine_and_circuit(c); + } + + +} \ No newline at end of file diff --git a/src/multicore.rs b/src/multicore.rs index 41b5285d3..2dddc3a72 100644 --- a/src/multicore.rs +++ b/src/multicore.rs @@ -21,7 +21,7 @@ use self::futures::executor::{ThreadPool}; #[derive(Clone)] pub struct Worker { - cpus: usize, + pub(crate) cpus: usize, pool: ThreadPool } @@ -39,7 +39,7 @@ impl Worker { } pub fn new() -> Worker { - Self::new_with_cpus(num_cpus::get()) + Self::new_with_cpus(num_cpus::get_physical()) } pub fn log_num_cpus(&self) -> u32 { @@ -78,16 +78,54 @@ impl Worker { ) -> R where F: FnOnce(&Scope<'a>, usize) -> R { - let chunk_size = if elements < self.cpus { - 1 - } else { - elements / self.cpus - }; + let chunk_size = self.get_chunk_size(elements); crossbeam::scope(|scope| { f(scope, chunk_size) }).expect("must run") } + + pub fn get_chunk_size( + &self, + elements: usize + ) -> usize { + let chunk_size = if elements <= self.cpus { + 1 + } else { + Self::chunk_size_for_num_spawned_threads(elements, self.cpus) + }; + + chunk_size + } + + pub fn get_num_spawned_threads( + &self, + elements: usize + ) -> usize { + let num_spawned = if elements <= self.cpus { + elements + } else { + let chunk = self.get_chunk_size(elements); + let mut spawned = elements / chunk; + if spawned * chunk < elements { + spawned += 1; + } + assert!(spawned <= 2*self.cpus); + + spawned + }; + + num_spawned + } + + pub fn chunk_size_for_num_spawned_threads(elements: usize, num_threads: usize) -> usize { + assert!(elements >= num_threads, "received {} elements to spawn {} threads", elements, num_threads); + if elements % num_threads == 0 { + elements / num_threads + } else { + elements / num_threads + 1 + } + } } pub struct WorkerFuture { diff --git a/src/multiexp.rs b/src/multiexp.rs index bb368cd3b..b1f8588a4 100644 --- a/src/multiexp.rs +++ b/src/multiexp.rs @@ -15,6 +15,14 @@ use super::source::*; use std::future::{Future}; use std::task::{Context, Poll}; use std::pin::{Pin}; +use log::{info, warn}; +use crate::gpu; +use std::iter; + + + + + extern crate futures; @@ -24,6 +32,7 @@ use self::futures::executor::block_on; use super::worker::{Worker, WorkerFuture}; use super::SynthesisError; +use rand_core::RngCore; use cfg_if; @@ -57,7 +66,6 @@ use cfg_if; /// - accumulators over each set of buckets will have an implicit factor of `(2^c)^i`, so before summing thme up /// "higher" accumulators must be doubled `c` times /// -#[cfg(not(feature = "nightly"))] fn multiexp_inner( pool: &Worker, bases: S, @@ -143,54 +151,26 @@ fn multiexp_inner( this } - -cfg_if! { - if #[cfg(feature = "nightly")] { - #[inline(always)] - fn multiexp_inner_impl( - pool: &Worker, - bases: S, - density_map: D, - exponents: Arc::Repr>>, - skip: u32, - c: u32, - handle_trivial: bool - ) -> WorkerFuture< ::Projective, SynthesisError> - where for<'a> &'a Q: QueryDensity, - D: Send + Sync + 'static + Clone + AsRef, - G: CurveAffine, - S: SourceBuilder - { - multiexp_inner_with_prefetch(pool, bases, density_map, exponents, skip, c, handle_trivial) - } - } else { - #[inline(always)] - fn multiexp_inner_impl( - pool: &Worker, - bases: S, - density_map: D, - exponents: Arc::Repr>>, - skip: u32, - c: u32, - handle_trivial: bool - ) -> WorkerFuture< ::Projective, SynthesisError> - where for<'a> &'a Q: QueryDensity, - D: Send + Sync + 'static + Clone + AsRef, - G: CurveAffine, - S: SourceBuilder - { - multiexp_inner(pool, bases, density_map, exponents, skip, c, handle_trivial) - } - } +#[inline(always)] +fn multiexp_inner_impl( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + multiexp_inner(pool, bases, density_map, exponents, skip, c, handle_trivial) + // multiexp_inner_with_prefetch_stable(pool, bases, density_map, exponents, skip, c, handle_trivial) } - - -#[cfg(feature = "nightly")] -extern crate prefetch; - -#[cfg(feature = "nightly")] -fn multiexp_inner_with_prefetch( +fn multiexp_inner_with_prefetch_stable( pool: &Worker, bases: S, density_map: D, @@ -204,9 +184,12 @@ fn multiexp_inner_with_prefetch( G: CurveAffine, S: SourceBuilder { - use prefetch::prefetch::*; // Perform this region of the multiexp let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let density_map = density_map.clone(); + // This is a Pippenger’s algorithm pool.compute(move || { // Accumulate the result @@ -225,7 +208,7 @@ fn multiexp_inner_with_prefetch( let one = ::Fr::one().into_repr(); let padding = Arc::new(vec![zero]); - let mask = 1 << c; + let mask = (1u64 << c) - 1; // Sort the bases into buckets for ((&exp, &next_exp), density) in exponents.iter() @@ -235,10 +218,10 @@ fn multiexp_inner_with_prefetch( if next_exp != zero && next_exp != one { let mut next_exp = next_exp; next_exp.shr(skip); - let next_exp = next_exp.as_ref()[0] % mask; + let next_exp = next_exp.as_ref()[0] & mask; if next_exp != 0 { let p: *const ::Projective = &buckets[(next_exp - 1) as usize]; - prefetch::(p); + crate::prefetch::prefetch_l1_pointer(p); } } @@ -284,10 +267,357 @@ fn multiexp_inner_with_prefetch( Ok(acc) }) }; - + this } + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn future_based_multiexp( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>> +) -> ChunksJoiner< ::Projective > +{ + assert!(exponents.len() <= bases.len()); + let c = if exponents.len() < 32 { + 3u32 + } else { + let mut width = (f64::from(exponents.len() as u32)).ln().ceil() as u32; + let mut num_chunks = ::NUM_BITS / width; + if ::NUM_BITS % width != 0 { + num_chunks += 1; + } + + if num_chunks < pool.cpus as u32 { + width = ::NUM_BITS / (pool.cpus as u32); + if ::NUM_BITS % (pool.cpus as u32) != 0 { + width += 1; + } + } + + width + }; + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + } else { + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn future_based_dense_multiexp_over_fixed_width_windows( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + c: u32 +) -> ChunksJoiner< ::Projective > +{ + assert!(exponents.len() <= bases.len()); + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + // future_based_buffered_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + } else { + // future_based_buffered_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + +fn future_based_dense_multiexp_impl( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> +{ + // Perform this region of the multiexp + let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let bases = bases.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + let padding = Arc::new(vec![zero]); + + let mask = 1 << c; + + // Sort the bases into buckets + for ((&exp, base), &next_exp) in exponents.iter() + .zip(bases.iter()) + .zip(exponents.iter().skip(1).chain(padding.iter())) { + // no matter what happens - prefetch next bucket + if next_exp != zero && next_exp != one { + let mut next_exp = next_exp; + next_exp.shr(skip); + let next_exp = next_exp.as_ref()[0] % mask; + if next_exp != 0 { + let p: *const ::Projective = &buckets[(next_exp - 1) as usize]; + crate::prefetch::prefetch_l1_pointer(p); + } + + } + // Go over density and exponents + if exp == zero { + continue + } else if exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } else { + continue + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % mask; + + if exp != 0 { + (&mut buckets[(exp - 1) as usize]).add_assign_mixed(base); + } else { + continue; + } + } + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + +fn future_based_buffered_dense_multiexp_impl( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> +{ + // Perform this region of the multiexp + let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let bases = bases.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + let mask = 1 << c; + + const BUFFER_SIZE: usize = 64; + let mut buffers: Vec> = vec![Vec::with_capacity(BUFFER_SIZE); (1 << c) - 1]; + + // Sort the bases into buckets + for (&exp, &base) in exponents.iter() + .zip(bases.iter()) { + // Go over density and exponents + if exp == zero { + continue + } else if exp == one { + if handle_trivial { + acc.add_assign_mixed(&base); + } else { + continue + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % mask; + + if exp != 0 { + let idx = (exp - 1) as usize; + if buffers[idx].len() == BUFFER_SIZE { + let mut el = buckets[idx]; + for b in buffers[idx].iter(){ + el.add_assign_mixed(&b); + } + buffers[idx].truncate(0); + buckets[idx] = el; + } + + buffers[idx].push(base); + } else { + continue; + } + } + } + + // we have some unprocessed left, so add them to the buckets + for (idx, buffer) in buffers.into_iter().enumerate() { + let mut el = buckets[idx]; + for b in buffer.into_iter() { + el.add_assign_mixed(&b); + } + buckets[idx] = el; + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + + + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn multiexp_gpu( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Fr as PrimeField>::Repr>>, + kern: &mut Option>, +) -> WorkerFuture< ::Projective, SynthesisError> + where + for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + G::Engine: pairing::Engine, + S: SourceBuilder, +{ + if let Some(ref mut kern) = kern { + if let Ok(p) = kern.with(|k: &mut gpu::MultiexpKernel| { + info!("start ready exponents and bases"); // 1s+ + let mut exps = vec![exponents[0]; exponents.len()]; + let mut n = 0; + for (&e, d) in exponents.iter().zip(density_map.as_ref().iter()) { + if d { + exps[n] = e; + n += 1; + } + } + + let (bss, skip) = bases.clone().get(); + info!("end ready exponents and bases"); + k.multiexp(pool, bss, Arc::new(exps.clone()), skip, n) + + }) { + return pool.compute(move || Ok(p)); + } + } + + let c = if exponents.len() < 32 { + 3u32 + } else { + (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + if let Some(query_size) = density_map.as_ref().get_query_size() { + // If the density map has a known query size, it should not be + // inconsistent with the number of exponents. + + assert!(query_size == exponents.len()); + } + + info!("!!!!!!!!!!!!!!!!!begin multiexp_inner"); + let future = multiexp_inner(pool, bases, density_map, exponents, 0, c, true); + info!("!!!!!!!!!!!!!!!!!end multiexp_inner"); + #[cfg(feature = "gpu")] + { + // Do not give the control back to the caller till the + // multiexp is done. We may want to reacquire the GPU again + // between the multiexps. + let result = future.wait(); + pool.compute(move || result) + } + #[cfg(not(feature = "gpu"))] + future +} + + + /// Perform multi-exponentiation. The caller is responsible for ensuring the /// query size is the same as the number of exponents. pub fn multiexp( @@ -336,6 +666,47 @@ pub fn multiexp( } } +pub(crate) fn multiexp_with_fixed_width( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Fr as PrimeField>::Repr>>, + c: u32 +) -> ChunksJoiner< ::Projective > + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + if let Some(query_size) = density_map.as_ref().get_query_size() { + // If the density map has a known query size, it should not be + // inconsistent with the number of exponents. + + assert!(query_size == exponents.len()); + } + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), 0, c, true) + } else { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + pub struct ChunksJoiner { join: JoinAll< WorkerFuture >, c: u32 @@ -389,6 +760,46 @@ fn join_chunks } +pub fn dense_multiexp_gpu( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + kern: &mut Option> +) -> Result<::Projective, SynthesisError> +{ + if let Some(ref mut kern) = kern { + if let Ok(p) = kern.with(|k: &mut gpu::MultiexpKernel| { + let mut exps = vec![exponents[0]; exponents.len()]; + let mut n = 0; + for &e in exponents.iter(){ + exps[n] = e; + n += 1; + } + let bas = bases.to_vec(); + + k.multiexp(pool, Arc::new(bas.clone()), Arc::new(exps.clone()), 0, n) + }) { + return pool.compute(move || Ok(p)).wait(); + } + } + + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + // dense_multiexp_inner_unrolled_with_prefetch(pool, bases, exponents, 0, c, true) + dense_multiexp_inner(pool, bases, exponents, 0, c, true) + +} + + + + /// Perform multi-exponentiation. The caller is responsible for ensuring that /// the number of bases is the same as the number of exponents. #[allow(dead_code)] @@ -401,12 +812,20 @@ pub fn dense_multiexp( if exponents.len() != bases.len() { return Err(SynthesisError::AssignmentMissing); } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length let c = if exponents.len() < 32 { 3u32 } else { - (f64::from(exponents.len() as u32)).ln().ceil() as u32 + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 }; + // dense_multiexp_inner_unrolled_with_prefetch(pool, bases, exponents, 0, c, true) dense_multiexp_inner(pool, bases, exponents, 0, c, true) } @@ -429,7 +848,7 @@ fn dense_multiexp_inner( pool.scope(bases.len(), |scope, chunk| { for (base, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { let this_region_rwlock = arc.clone(); - // let handle = + // let handle = scope.spawn(move |_| { let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; // Accumulate the result @@ -472,14 +891,14 @@ fn dense_multiexp_inner( let mut guard = match this_region_rwlock.lock() { Ok(guard) => guard, Err(_) => { - panic!("poisoned!"); + panic!("poisoned!"); // poisoned.into_inner() } }; (*guard).add_assign(&acc); }); - + } }); @@ -508,8 +927,27 @@ fn dense_multiexp_inner( } } -#[test] -fn test_new_multiexp_with_bls12() { +fn get_window_size_for_length(length: usize, chunk_length: usize) -> u32 { + if length < 32 { + return 3u32; + } else { + let exact = (f64::from(chunk_length as u32)).ln(); + let floor = exact.floor(); + if exact > floor + 0.5f64 { + return exact.ceil() as u32; + } else { + return floor as u32; + } + + // (f64::from(chunk_length as u32)).ln().ceil() as u32 + // (f64::from(length as u32)).ln().ceil() as u32 + }; +} + +#[cfg(test)] +mod test { + use super::*; + fn naive_multiexp( bases: Arc>, exponents: Arc::Repr>> @@ -526,110 +964,312 @@ fn test_new_multiexp_with_bls12() { acc } - use rand::{self, Rand}; - use crate::pairing::bls12_381::Bls12; + #[test] + fn test_new_multiexp_with_bls12() { + use rand::{self, Rand}; + use crate::pairing::bls12_381::Bls12; - use self::futures::executor::block_on; + use self::futures::executor::block_on; - const SAMPLES: usize = 1 << 14; + const SAMPLES: usize = 1 << 14; - let rng = &mut rand::thread_rng(); - let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); - let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); + let rng = &mut rand::thread_rng(); + let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); - let naive = naive_multiexp(g.clone(), v.clone()); + let naive = naive_multiexp(g.clone(), v.clone()); - let pool = Worker::new(); + let pool = Worker::new(); + + let fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); - let fast = block_on( - multiexp( + assert_eq!(naive, fast); + } + + + #[test] + fn test_valid_bn254_multiexp() { + use rand::{self, Rand}; + use crate::pairing::bn256::Bn256; + + const SAMPLES: usize = 1 << 10; + + let pool = Worker::new(); + + let rng = &mut rand::thread_rng(); + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + let dense = dense_multiexp( &pool, - (g, 0), - FullDensity, - v - ) - ).unwrap(); + &g, + &v, + ).unwrap(); + + let v = Arc::new(v); + let g = Arc::new(g); + + let naive = naive_multiexp(g.clone(), v.clone()); + + assert_eq!(dense, naive); + + use self::futures::executor::block_on; + + let fast_dense = future_based_multiexp( + &pool, + g.clone(), + v.clone() + ).wait().unwrap(); + + assert_eq!(naive, fast_dense); + + let fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); + + assert_eq!(naive, fast); + } - assert_eq!(naive, fast); + #[test] + #[ignore] + fn test_new_multexp_speed_with_bn256() { + + use rand::{self, Rand}; + use crate::pairing::bn256::Bn256; + use num_cpus; + + let cpus = num_cpus::get(); + const SAMPLES: usize = 1 << 22; + + let rng = &mut rand::thread_rng(); + let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); + + let pool = Worker::new(); + + use self::futures::executor::block_on; + + let start = std::time::Instant::now(); + + let _fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("Elapsed {} ns for {} samples", duration_ns, SAMPLES); + let time_per_sample = duration_ns/(SAMPLES as f64); + println!("Tested on {} samples on {} CPUs with {} ns per multiplication", SAMPLES, cpus, time_per_sample); + } + + fn calculate_parameters(size: usize, threads: usize, bits: u32) { + let mut chunk_len = size / threads; + if size / threads != 0 { + chunk_len += 1; + } + let raw_size = (f64::from(chunk_len as u32)).ln(); + let new_window_size = if raw_size.floor() + 0.5 < raw_size { + raw_size.ceil() as u32 + } else { + raw_size.floor() as u32 + }; + let window_size = (f64::from(chunk_len as u32)).ln().ceil() as u32; + + let mut num_windows = bits / window_size; + let leftover = bits % window_size; + if leftover != 0 { + num_windows += 1; + } + + let uncompensated_window = (f64::from(size as u32)).ln().ceil() as u32; + let mut num_uncompensated_windows = bits / uncompensated_window; + let uncompensated_leftover = bits % uncompensated_window; + if uncompensated_leftover != 0 { + num_uncompensated_windows += 1; + } + + println!("For size {} and {} cores: chunk len {}, {} windows, average window {} bits, leftover {} bits. Alternative window size = {}", size, threads, chunk_len, num_windows, window_size, leftover, new_window_size); + // println!("Raw window size = {}", raw_size); + // println!("Uncompensated: {} windows, arevage window {} bits, leftover {} bits", num_uncompensated_windows, uncompensated_window, uncompensated_leftover); + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + } + + #[test] + fn test_sizes_for_bn254() { + let sizes = vec![1<<23, 1<<24]; + let cores = vec![8, 12, 16, 24, 32, 48]; + for size in sizes { + for &core in &cores { + calculate_parameters(size, core, 254); + } + } + } } + +pub fn create_multiexp_kernel(_log_d: usize, priority: bool) -> Option> + where + E: pairing::Engine, +{ + match gpu::MultiexpKernel::::create(priority) { + Ok(k) => { + info!("GPU Multiexp kernel instantiated!"); + Some(k) + } + Err(e) => { + warn!("Cannot instantiate GPU Multiexp kernel! Error: {}", e); + None + } + } +} + + +#[cfg(feature = "gpu")] #[test] -#[ignore] -fn test_new_multexp_speed_with_bn256() { +pub fn gpu_multiexp_consistency() { + use crate::pairing::bls12_381::Bls12; + use std::time::Instant; use rand::{self, Rand}; - use crate::pairing::bn256::Bn256; - use num_cpus; + // use std::env; - let cpus = num_cpus::get(); - const SAMPLES: usize = 1 << 22; + // env::set_var("OCL_DEFAULT_DEVICE_TYPE","GPU"); + + const MAX_LOG_D: usize = 20; + const START_LOG_D: usize = 10; + let mut kern = Some(gpu::LockedMultiexpKernel::::new(MAX_LOG_D, false)); + let pool = Worker::new(); let rng = &mut rand::thread_rng(); - let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); - let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); - let pool = Worker::new(); - use self::futures::executor::block_on; + // let rng = &mut rand::thread_rng(); + // let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + // let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); - let start = std::time::Instant::now(); - let _fast = block_on( - multiexp( - &pool, - (g, 0), - FullDensity, - v - ) - ).unwrap(); + let mut bases = (0..(1 << 10)) + .map(|_| ::G1::rand(rng).into_affine()) + .collect::>(); + + for _ in 10..START_LOG_D { + bases = [bases.clone(), bases.clone()].concat(); + } + + for log_d in START_LOG_D..(MAX_LOG_D + 1) { + let g = Arc::new(bases.clone()); + + let samples = 1 << log_d; + println!("Testing Multiexp for {} elements...", samples); + + let v = Arc::new( + (0..samples) + .map(|_| ::Fr::rand(rng).into_repr()) + .collect::>(), + ); + + let mut now = Instant::now(); + let gpu = multiexp_gpu(&pool, (g.clone(), 0), FullDensity, v.clone(), &mut kern) + .wait() + .unwrap(); + let gpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("GPU took {}ms.", gpu_dur); + println!("============================"); - let duration_ns = start.elapsed().as_nanos() as f64; - println!("Elapsed {} ns for {} samples", duration_ns, SAMPLES); - let time_per_sample = duration_ns/(SAMPLES as f64); - println!("Tested on {} samples on {} CPUs with {} ns per multiplication", SAMPLES, cpus, time_per_sample); + bases = [bases.clone(), bases.clone()].concat(); + } } +#[cfg(feature = "gpu")] #[test] -fn test_dense_multiexp_vs_new_multiexp() { - use rand::{XorShiftRng, SeedableRng, Rand, Rng}; +pub fn gpu_multiexp_consistency_bn256() { + use rand::{self, Rand}; use crate::pairing::bn256::Bn256; - use num_cpus; + use std::time::Instant; + // use std::env; - // const SAMPLES: usize = 1 << 22; - const SAMPLES: usize = 1 << 16; - let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + // env::set_var("OCL_DEFAULT_DEVICE_TYPE","GPU"); - let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); - let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + const MAX_LOG_D: usize = 20; + const START_LOG_D: usize = 10; + let mut kern = Some(gpu::LockedMultiexpKernel::::new(MAX_LOG_D, false)); + let pool = Worker::new(); - println!("Done generating test points and scalars"); + let rng = &mut rand::thread_rng(); - let pool = Worker::new(); - let start = std::time::Instant::now(); + // let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + // let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); - let dense = dense_multiexp( - &pool, &g, &v.clone()).unwrap(); + let mut bases = (0..(1 << 10)) + .map(|_| ::G1::rand(rng).into_affine()) + .collect::>(); - let duration_ns = start.elapsed().as_nanos() as f64; - println!("{} ns for dense for {} samples", duration_ns, SAMPLES); + for _ in 10..START_LOG_D { + bases = [bases.clone(), bases.clone()].concat(); + } - use self::futures::executor::block_on; + for log_d in START_LOG_D..(MAX_LOG_D + 1) { - let start = std::time::Instant::now(); + let samples = 1 << log_d; - let sparse = block_on( - multiexp( + println!("Testing Multiexp for {} elements...", samples); + + let v = (0..samples).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = bases.clone(); + let mut now = Instant::now(); + let dense = dense_multiexp( &pool, - (Arc::new(g), 0), - FullDensity, - Arc::new(v) - ) - ).unwrap(); + &g, + &v, + ).unwrap(); + + let cpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + + println!("CPU took {}ms.", cpu_dur); + + + let mut now = Instant::now(); + let dense_gpu = dense_multiexp_gpu(&pool, &g, &v, &mut kern).unwrap(); + let dense_gpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("dense_gpu took {}ms.", dense_gpu_dur); + + assert_eq!(dense, dense_gpu); - let duration_ns = start.elapsed().as_nanos() as f64; - println!("{} ns for sparse for {} samples", duration_ns, SAMPLES); - assert_eq!(dense, sparse); + let v = Arc::new(v); + let g = Arc::new(g); + + let mut now = Instant::now(); + let gpu = multiexp_gpu(&pool, (g.clone(), 0), FullDensity, v.clone(), &mut kern) + .wait() + .unwrap(); + let gpu_dur = now.elapsed().as_secs() * 1000 as u64 + now.elapsed().subsec_millis() as u64; + println!("GPU took {}ms.", gpu_dur); + + println!("GPU accerlate {}x", cpu_dur/gpu_dur); + + println!("============================"); + assert_eq!(dense, gpu); + + bases = [bases.clone(), bases.clone()].concat(); + } + } \ No newline at end of file diff --git a/src/multiexp_experiments.rs b/src/multiexp_experiments.rs new file mode 100644 index 000000000..1fd47fa0e --- /dev/null +++ b/src/multiexp_experiments.rs @@ -0,0 +1,3428 @@ +use crate::pairing::{ + CurveAffine, + CurveProjective, + Engine +}; + +use crate::pairing::ff::{ + PrimeField, + Field, + PrimeFieldRepr, + ScalarEngine}; + +use std::sync::Arc; +use super::source::*; +use std::future::{Future}; +use std::task::{Context, Poll}; +use std::pin::{Pin}; + +extern crate futures; + +use self::futures::future::{join_all, JoinAll}; +use self::futures::executor::block_on; + +use super::worker::{Worker, WorkerFuture}; + +use super::SynthesisError; + +use cfg_if; + +/// This genious piece of code works in the following way: +/// - choose `c` - the bit length of the region that one thread works on +/// - make `2^c - 1` buckets and initialize them with `G = infinity` (that's equivalent of zero) +/// - there is no bucket for "zero" cause it's not necessary +/// - go over the pairs `(base, scalar)` +/// - for each scalar calculate `scalar % 2^c` and add the base (without any multiplications!) to the +/// corresponding bucket +/// - at the end each bucket will have an accumulated value that should be multiplied by the corresponding factor +/// between `1` and `2^c - 1` to get the right value +/// - here comes the first trick - you don't need to do multiplications at all, just add all the buckets together +/// starting from the first one `(a + b + c + ...)` and than add to the first sum another sum of the form +/// `(b + c + d + ...)`, and than the third one `(c + d + ...)`, that will result in the proper prefactor infront of every +/// accumulator, without any multiplication operations at all +/// - that's of course not enough, so spawn the next thread +/// - this thread works with the same bit width `c`, but SKIPS lowers bits completely, so it actually takes values +/// in the form `(scalar >> c) % 2^c`, so works on the next region +/// - spawn more threads until you exhaust all the bit length +/// - you will get roughly `[bitlength / c] + 1` inaccumulators +/// - double the highest accumulator enough times, add to the next one, double the result, add the next accumulator, continue +/// +/// Demo why it works: +/// ```text +/// a * G + b * H = (a_2 * (2^c)^2 + a_1 * (2^c)^1 + a_0) * G + (b_2 * (2^c)^2 + b_1 * (2^c)^1 + b_0) * H +/// ``` +/// - make buckets over `0` labeled coefficients +/// - make buckets over `1` labeled coefficients +/// - make buckets over `2` labeled coefficients +/// - accumulators over each set of buckets will have an implicit factor of `(2^c)^i`, so before summing thme up +/// "higher" accumulators must be doubled `c` times +/// +fn multiexp_inner( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + // Perform this region of the multiexp + let this = { + // let bases = bases.clone(); + // let exponents = exponents.clone(); + // let density_map = density_map.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Build a source for the bases + let mut bases = bases.new(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + // Sort the bases into buckets + for (&exp, density) in exponents.iter().zip(density_map.as_ref().iter()) { + // Go over density and exponents + if density { + if exp == zero { + bases.skip(1)?; + } else if exp == one { + if handle_trivial { + bases.add_assign_mixed(&mut acc)?; + } else { + bases.skip(1)?; + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % (1 << c); + + if exp != 0 { + bases.add_assign_mixed(&mut buckets[(exp - 1) as usize])?; + } else { + bases.skip(1)?; + } + } + } + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + +#[inline(always)] +fn multiexp_inner_impl( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + multiexp_inner(pool, bases, density_map, exponents, skip, c, handle_trivial) + // multiexp_inner_with_prefetch_stable(pool, bases, density_map, exponents, skip, c, handle_trivial) +} + +fn multiexp_inner_with_prefetch_stable( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + // Perform this region of the multiexp + let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let density_map = density_map.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Build a source for the bases + let mut bases = bases.new(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + let padding = Arc::new(vec![zero]); + + let mask = (1u64 << c) - 1; + + // Sort the bases into buckets + for ((&exp, &next_exp), density) in exponents.iter() + .zip(exponents.iter().skip(1).chain(padding.iter())) + .zip(density_map.as_ref().iter()) { + // no matter what happens - prefetch next bucket + if next_exp != zero && next_exp != one { + let mut next_exp = next_exp; + next_exp.shr(skip); + let next_exp = next_exp.as_ref()[0] & mask; + if next_exp != 0 { + let p: *const ::Projective = &buckets[(next_exp - 1) as usize]; + crate::prefetch::prefetch_l1_pointer(p); + } + + } + // Go over density and exponents + if density { + if exp == zero { + bases.skip(1)?; + } else if exp == one { + if handle_trivial { + bases.add_assign_mixed(&mut acc)?; + } else { + bases.skip(1)?; + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % mask; + + if exp != 0 { + bases.add_assign_mixed(&mut buckets[(exp - 1) as usize])?; + } else { + bases.skip(1)?; + } + } + } + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn future_based_multiexp( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>> +) -> ChunksJoiner< ::Projective > +{ + assert!(exponents.len() <= bases.len()); + let c = if exponents.len() < 32 { + 3u32 + } else { + let mut width = (f64::from(exponents.len() as u32)).ln().ceil() as u32; + let mut num_chunks = ::NUM_BITS / width; + if ::NUM_BITS % width != 0 { + num_chunks += 1; + } + + if num_chunks < pool.cpus as u32 { + width = ::NUM_BITS / (pool.cpus as u32); + if ::NUM_BITS % (pool.cpus as u32) != 0 { + width += 1; + } + } + + width + }; + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + } else { + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn future_based_dense_multiexp_over_fixed_width_windows( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + c: u32 +) -> ChunksJoiner< ::Projective > +{ + assert!(exponents.len() <= bases.len()); + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + // future_based_buffered_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), 0, c, true) + } else { + // future_based_buffered_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + future_based_dense_multiexp_impl(pool, bases.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + +fn future_based_dense_multiexp_impl( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> +{ + // Perform this region of the multiexp + let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let bases = bases.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + let padding = Arc::new(vec![zero]); + + let mask = 1 << c; + + // Sort the bases into buckets + for ((&exp, base), &next_exp) in exponents.iter() + .zip(bases.iter()) + .zip(exponents.iter().skip(1).chain(padding.iter())) { + // no matter what happens - prefetch next bucket + if next_exp != zero && next_exp != one { + let mut next_exp = next_exp; + next_exp.shr(skip); + let next_exp = next_exp.as_ref()[0] % mask; + if next_exp != 0 { + let p: *const ::Projective = &buckets[(next_exp - 1) as usize]; + crate::prefetch::prefetch_l1_pointer(p); + } + + } + // Go over density and exponents + if exp == zero { + continue + } else if exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } else { + continue + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % mask; + + if exp != 0 { + (&mut buckets[(exp - 1) as usize]).add_assign_mixed(base); + } else { + continue; + } + } + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + +fn future_based_buffered_dense_multiexp_impl( + pool: &Worker, + bases: Arc>, + exponents: Arc::Repr>>, + skip: u32, + c: u32, + handle_trivial: bool +) -> WorkerFuture< ::Projective, SynthesisError> +{ + // Perform this region of the multiexp + let this = { + let bases = bases.clone(); + let exponents = exponents.clone(); + let bases = bases.clone(); + + // This is a Pippenger’s algorithm + pool.compute(move || { + // Accumulate the result + let mut acc = G::Projective::zero(); + + // Create buckets to place remainders s mod 2^c, + // it will be 2^c - 1 buckets (no bucket for zeroes) + + // Create space for the buckets + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + let mask = 1 << c; + + const BUFFER_SIZE: usize = 64; + let mut buffers: Vec> = vec![Vec::with_capacity(BUFFER_SIZE); (1 << c) - 1]; + + // Sort the bases into buckets + for (&exp, &base) in exponents.iter() + .zip(bases.iter()) { + // Go over density and exponents + if exp == zero { + continue + } else if exp == one { + if handle_trivial { + acc.add_assign_mixed(&base); + } else { + continue + } + } else { + // Place multiplication into the bucket: Separate s * P as + // (s/2^c) * P + (s mod 2^c) P + // First multiplication is c bits less, so one can do it, + // sum results from different buckets and double it c times, + // then add with (s mod 2^c) P parts + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % mask; + + if exp != 0 { + let idx = (exp - 1) as usize; + if buffers[idx].len() == BUFFER_SIZE { + let mut el = buckets[idx]; + for b in buffers[idx].iter(){ + el.add_assign_mixed(&b); + } + buffers[idx].truncate(0); + buckets[idx] = el; + } + + buffers[idx].push(base); + } else { + continue; + } + } + } + + // we have some unprocessed left, so add them to the buckets + for (idx, buffer) in buffers.into_iter().enumerate() { + let mut el = buckets[idx]; + for b in buffer.into_iter() { + el.add_assign_mixed(&b); + } + buckets[idx] = el; + } + + // Summation by parts + // e.g. 3a + 2b + 1c = a + + // (a) + b + + // ((a) + b) + c + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + Ok(acc) + }) + }; + + this +} + +/// Perform multi-exponentiation. The caller is responsible for ensuring the +/// query size is the same as the number of exponents. +pub fn multiexp( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Fr as PrimeField>::Repr>> +) -> ChunksJoiner< ::Projective > + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + let c = if exponents.len() < 32 { + 3u32 + } else { + (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + if let Some(query_size) = density_map.as_ref().get_query_size() { + // If the density map has a known query size, it should not be + // inconsistent with the number of exponents. + + assert!(query_size == exponents.len()); + } + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), 0, c, true) + } else { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + +pub(crate) fn multiexp_with_fixed_width( + pool: &Worker, + bases: S, + density_map: D, + exponents: Arc::Fr as PrimeField>::Repr>>, + c: u32 +) -> ChunksJoiner< ::Projective > + where for<'a> &'a Q: QueryDensity, + D: Send + Sync + 'static + Clone + AsRef, + G: CurveAffine, + S: SourceBuilder +{ + if let Some(query_size) = density_map.as_ref().get_query_size() { + // If the density map has a known query size, it should not be + // inconsistent with the number of exponents. + + assert!(query_size == exponents.len()); + } + + let mut skip = 0; + let mut futures = Vec::with_capacity((::Fr::NUM_BITS / c + 1) as usize); + + while skip < ::Fr::NUM_BITS { + let chunk_future = if skip == 0 { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), 0, c, true) + } else { + multiexp_inner_impl(pool, bases.clone(), density_map.clone(), exponents.clone(), skip, c, false) + }; + + futures.push(chunk_future); + skip += c; + } + + let join = join_all(futures); + + ChunksJoiner { + join, + c + } +} + +pub struct ChunksJoiner { + join: JoinAll< WorkerFuture >, + c: u32 +} + +impl Future for ChunksJoiner { + type Output = Result; + + fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll + { + let c = self.as_ref().c; + let join = unsafe { self.map_unchecked_mut(|s| &mut s.join) }; + match join.poll(cx) { + Poll::Ready(v) => { + let v = join_chunks(v, c); + return Poll::Ready(v); + }, + Poll::Pending => { + return Poll::Pending; + } + } + } +} + +impl ChunksJoiner { + pub fn wait(self) -> ::Output { + block_on(self) + } +} + +fn join_chunks + (chunks: Vec>, c: u32) -> Result { + if chunks.len() == 0 { + return Ok(G::zero()); + } + + let mut iter = chunks.into_iter().rev(); + let higher = iter.next().expect("is some chunk result"); + let mut higher = higher?; + + for chunk in iter { + let this = chunk?; + for _ in 0..c { + higher.double(); + } + + higher.add_assign(&this); + } + + Ok(higher) +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring that +/// the number of bases is the same as the number of exponents. +#[allow(dead_code)] +pub fn dense_multiexp( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + // dense_multiexp_inner_unrolled_with_prefetch(pool, bases, exponents, 0, c, true) + dense_multiexp_inner(pool, bases, exponents, 0, c, true) +} + +fn dense_multiexp_inner( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + mut skip: u32, + c: u32, + handle_trivial: bool +) -> Result<::Projective, SynthesisError> +{ + use std::sync::{Mutex}; + // Perform this region of the multiexp. We use a different strategy - go over region in parallel, + // then over another region, etc. No Arc required + let this = { + // let mask = (1u64 << c) - 1u64; + let this_region = Mutex::new(::Projective::zero()); + let arc = Arc::new(this_region); + pool.scope(bases.len(), |scope, chunk| { + for (base, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { + let this_region_rwlock = arc.clone(); + // let handle = + scope.spawn(move |_| { + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + // Accumulate the result + let mut acc = G::Projective::zero(); + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + for (base, &exp) in base.iter().zip(exp.iter()) { + // let index = (exp.as_ref()[0] & mask) as usize; + + // if index != 0 { + // buckets[index - 1].add_assign_mixed(base); + // } + + // exp.shr(c as u32); + + if exp != zero { + if exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } + } else { + let mut exp = exp; + exp.shr(skip); + let exp = exp.as_ref()[0] % (1 << c); + if exp != 0 { + buckets[(exp - 1) as usize].add_assign_mixed(base); + } + } + } + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + let mut guard = match this_region_rwlock.lock() { + Ok(guard) => guard, + Err(_) => { + panic!("poisoned!"); + // poisoned.into_inner() + } + }; + + (*guard).add_assign(&acc); + }); + + } + }); + + let this_region = Arc::try_unwrap(arc).unwrap(); + let this_region = this_region.into_inner().unwrap(); + + this_region + }; + + skip += c; + + if skip >= ::Fr::NUM_BITS { + // There isn't another region, and this will be the highest region + return Ok(this); + } else { + // next region is actually higher than this one, so double it enough times + let mut next_region = dense_multiexp_inner( + pool, bases, exponents, skip, c, false).unwrap(); + for _ in 0..c { + next_region.double(); + } + + next_region.add_assign(&this); + + return Ok(next_region); + } +} + +fn get_window_size_for_length(length: usize, chunk_length: usize) -> u32 { + if length < 32 { + return 3u32; + } else { + let exact = (f64::from(chunk_length as u32)).ln(); + let floor = exact.floor(); + if exact > floor + 0.5f64 { + return exact.ceil() as u32; + } else { + return floor as u32; + } + + // (f64::from(chunk_length as u32)).ln().ceil() as u32 + // (f64::from(length as u32)).ln().ceil() as u32 + }; +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring that +/// the number of bases is the same as the number of exponents. +#[allow(dead_code)] +pub fn dense_multiexp_uniform( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + let num_threads = pool.cpus; + + let mut subresults = vec![::Projective::zero(); num_threads]; + + use std::sync::{Arc, Barrier}; + + const SYNCHRONIZATION_STEP: usize = 1 << 17; + const READ_BY: usize = 1 << 7; + const MIN_STACK_SIZE: usize = 1 << 21; // 2MB + assert!(SYNCHRONIZATION_STEP % READ_BY == 0); + + let num_rounds = bases.len() / SYNCHRONIZATION_STEP; + let limit = ((::Fr::NUM_BITS / c) + 1) as usize; + let mut buckets_schedule = Vec::with_capacity(limit); + let mut tmp = ::Fr::NUM_BITS; + for _ in 0..limit { + if tmp != 0 { + let bits = if tmp >= c { + tmp -= c; + + c + } else { + let tt = tmp; + tmp = 0; + + tt + }; + buckets_schedule.push(bits); + } else { + break; + } + } + + let mut barriers = Vec::with_capacity(buckets_schedule.len()); + for _ in 0..buckets_schedule.len() { + let mut tt = Vec::with_capacity(num_rounds); + for _ in 0..num_rounds { + let t = Barrier::new(num_threads); + tt.push(t); + } + barriers.push(tt); + } + + let barrs = &barriers; + let b_schedule = &buckets_schedule; + + let g1_proj_size = std::mem::size_of::<::Projective>(); + let scalar_size = std::mem::size_of::<<::Fr as PrimeField>::Repr>(); + + // potentially we can keep all the buckets on a stack, + // but it would be around 96 MB for BN254 for c = 20; + let _space_to_keep_bases_on_stack = (1 << c) * g1_proj_size; + + let mut stack_size = (g1_proj_size + scalar_size) * READ_BY; + if stack_size < MIN_STACK_SIZE { + stack_size = MIN_STACK_SIZE; + } + + let thread_step = num_threads * READ_BY; + + use crossbeam::thread; + + thread::scope(|s| { + for (thread_idx, subresult) in subresults.iter_mut().enumerate() { + let builder = s.builder().stack_size(stack_size); + builder.spawn(move |_| { + let limit = bases.len(); + let bases = &bases[..limit]; + let exponents = &exponents[..limit]; + let mut buckets = vec![::Projective::zero(); 1 << c]; + let mut skip_bits = 0; + for (chunk_schedule_idx, window_size) in b_schedule.iter().enumerate() { + let mask = (1 << window_size) - 1; + if chunk_schedule_idx != 0 { + (&mut buckets).truncate(0); + (&mut buckets).resize(1 << window_size, ::Projective::zero()); + } + for (i, (bases, exponents)) in bases.chunks(SYNCHRONIZATION_STEP) + .zip(exponents.chunks(SYNCHRONIZATION_STEP)) + .enumerate() { + let num_subchunks = bases.len() / thread_step; + let remainder_start = num_subchunks * thread_step; + let remainder_end = bases.len(); + // assert_eq!(remainder_start, remainder_end, "only support power of two multiexp size for now"); + let mut bases_holder = [G::zero(); READ_BY]; + let mut exponents_holder = [<::Fr as PrimeField>::Repr::default(); READ_BY]; + + for subchunk_start_idx in ((thread_idx*READ_BY)..remainder_start).step_by(thread_step) { + bases_holder.copy_from_slice(&bases[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + exponents_holder.copy_from_slice(&exponents[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + + let mut exps_iter = exponents_holder.iter(); + let mut bases_iter = bases_holder.iter(); + + // semi-unroll first + let mut tmp = *exps_iter.next().unwrap(); + tmp.shr(skip_bits); + let mut this_exp = (tmp.as_ref()[0] & mask) as usize; + + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&next_exp, this_base) in exps_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(this_base); + } + + let mut next_exp = next_exp; + next_exp.shr(skip_bits); + this_exp = (next_exp.as_ref()[0] & mask) as usize; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(last_base); + } + } + + // process the remainder + let remainder_start = remainder_start + (thread_idx*READ_BY); + if remainder_start < remainder_end { + let remainder_end = if remainder_start + READ_BY > remainder_end { + remainder_end + } else { + remainder_start + READ_BY + }; + + let exponents_holder = &exponents[remainder_start..remainder_end]; + let bases_holder = &bases[remainder_start..remainder_end]; + + let mut exps_iter = exponents_holder.iter(); + let mut bases_iter = bases_holder.iter(); + + // semi-unroll first + let mut tmp = *exps_iter.next().unwrap(); + tmp.shr(skip_bits); + let mut this_exp = (tmp.as_ref()[0] & mask) as usize; + + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&next_exp, this_base) in exps_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(this_base); + } + + let mut next_exp = next_exp; + next_exp.shr(skip_bits); + this_exp = (next_exp.as_ref()[0] & mask) as usize; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(last_base); + } + } + + (&barrs[chunk_schedule_idx][i]).wait(); + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = buckets[1]; + let mut running_sum = G::Projective::zero(); + for exp in buckets.iter().skip(2).rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip_bits { + acc.double(); + } + + subresult.add_assign(&acc); + + skip_bits += window_size; + } + }).unwrap(); + } + }).unwrap(); + + let mut result = subresults.drain(0..1).collect::>()[0]; + for t in subresults.into_iter() { + result.add_assign(&t); + } + + Ok(result) +} + +/// Perform multi-exponentiation. The caller is responsible for ensuring that +/// the number of bases is the same as the number of exponents. +pub fn stack_allocated_dense_multiexp( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + + let chunk_len = pool.get_chunk_size(exponents.len()); + + let c = get_window_size_for_length(exponents.len(), chunk_len); + + match c { + 12 => stack_allocated_dense_multiexp_12(pool, bases, exponents), + 13 => stack_allocated_dense_multiexp_13(pool, bases, exponents), + 14 => stack_allocated_dense_multiexp_14(pool, bases, exponents), + 15 => stack_allocated_dense_multiexp_15(pool, bases, exponents), + 16 => stack_allocated_dense_multiexp_16(pool, bases, exponents), + 17 => stack_allocated_dense_multiexp_17(pool, bases, exponents), + 18 => stack_allocated_dense_multiexp_18(pool, bases, exponents), + _ => unimplemented!("not implemented for windows = {}", c) + } +} + + +// /// Perform multi-exponentiation. The caller is responsible for ensuring that +// /// the number of bases is the same as the number of exponents. +// pub fn producer_consumer_dense_multiexp( +// pool: &Worker, +// bases: & [G], +// exponents: & [<::Fr as PrimeField>::Repr], +// ) -> Result<::Projective, SynthesisError> +// { +// if exponents.len() != bases.len() { +// return Err(SynthesisError::AssignmentMissing); +// } + +// let num_workers = pool.cpus - 1; +// let mut window_size = (::Fr::NUM_BITS as usize) / num_workers; +// if (::Fr::NUM_BITS as usize) % num_workers != 0 { +// window_size += 1; +// } + +// if window_size > 20 { +// println!("Degrading to normal one"); +// return dense_multiexp(pool, bases, exponents); +// } +// println!("Windows size = {} for {} multiexp size on {} CPUs", window_size, exponents.len(), pool.cpus); + +// use crossbeam::thread; +// use crossbeam_queue::{ArrayQueue}; +// const CAPACITY: usize = 1 << 16; +// let mask = (1u64 << window_size) - 1u64; + +// use std::sync::atomic::{AtomicBool, Ordering}; +// let end = AtomicBool::from(false); +// let finished = &end; + +// thread::scope(|s| { +// let mut txes = Vec::with_capacity(num_workers); +// let mut rxes = Vec::with_capacity(num_workers); + +// for _ in 0..num_workers { +// let queue = ArrayQueue::<(G, usize)>::new(CAPACITY); +// let queue = Arc::from(queue); +// txes.push(queue.clone()); +// rxes.push(queue); +// } +// // first we spawn thread that produces indexes +// s.spawn(move |_| { +// for (exp, base) in (exponents.iter().copied()).zip(bases.iter().copied()) { +// let mut exp = exp; +// let mut skip = 0u32; +// for c in txes.iter() { +// exp.shr(skip); +// let index = (exp.as_ref()[0] & mask) as usize; +// skip += window_size as u32; +// 'inner: loop { +// if !c.is_full() { +// c.push((base, index)).unwrap(); +// break 'inner; +// } +// } +// } +// } +// finished.store(true, Ordering::Relaxed); +// }); + +// for rx in rxes.into_iter() { +// s.spawn(move |_| { +// let mut buckets = vec![::Projective::zero(); (1 << window_size) - 1]; +// loop { +// if !rx.is_empty() { +// let (base, index) = rx.pop().unwrap(); +// if index != 0 { +// buckets[index - 1].add_assign_mixed(&base); +// } +// } else { +// let ended = finished.load(Ordering::Relaxed); +// if ended { +// break; +// } +// } +// } + +// let mut running_sum = G::Projective::zero(); +// let mut acc = G::Projective::zero(); +// for exp in buckets.into_iter().rev() { +// running_sum.add_assign(&exp); +// acc.add_assign(&running_sum); +// } +// }); +// } +// }).unwrap(); + +// Ok(G::Projective::zero()) +// } + +/// Perform multi-exponentiation. The caller is responsible for ensuring that +/// the number of bases is the same as the number of exponents. +pub fn stack_allocated_uncompensated_dense_multiexp( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + match c { + 12 => stack_allocated_dense_multiexp_12(pool, bases, exponents), + 13 => stack_allocated_dense_multiexp_13(pool, bases, exponents), + 14 => stack_allocated_dense_multiexp_14(pool, bases, exponents), + 15 => stack_allocated_dense_multiexp_15(pool, bases, exponents), + 16 => stack_allocated_dense_multiexp_16(pool, bases, exponents), + 17 => stack_allocated_dense_multiexp_17(pool, bases, exponents), + 18 => stack_allocated_dense_multiexp_18(pool, bases, exponents), + _ => unimplemented!("not implemented for windows = {}", c) + } +} + +fn stack_allocated_dense_multiexp_inner( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32 +) -> Result<::Projective, SynthesisError> +{ + const WINDOW_SIZE: usize = 13; + const SYNCHRONIZATION_STEP: usize = 1 << 17; + const READ_BY: usize = 1 << 7; + const MIN_STACK_SIZE: usize = 1 << 21; // 2MB + const NUM_BUCKETS: usize = 1 << WINDOW_SIZE; + const MASK: u64 = (1 << WINDOW_SIZE) - 1; + + assert!(SYNCHRONIZATION_STEP % READ_BY == 0); + assert_eq!(c as usize, WINDOW_SIZE); + + let num_threads = pool.cpus; + + let mut subresults = vec![::Projective::zero(); num_threads]; + + use std::sync::{Arc, Barrier}; + + let num_rounds = bases.len() / SYNCHRONIZATION_STEP; + let mut num_windows = (::Fr::NUM_BITS / c) as usize; + if ::Fr::NUM_BITS % c != 0 { + num_windows += 1; + } + + let mut barriers = Vec::with_capacity(num_windows); + for _ in 0..num_windows { + let mut tt = Vec::with_capacity(num_rounds); + for _ in 0..num_rounds { + let t = Barrier::new(num_threads); + tt.push(t); + } + barriers.push(tt); + } + + let barrs = &barriers; + + let g1_projective_size = std::mem::size_of::<::Projective>(); + let g1_affine_size = std::mem::size_of::(); + let scalar_size = std::mem::size_of::<<::Fr as PrimeField>::Repr>(); + let usize_size = std::mem::size_of::(); + + // potentially we can keep all the buckets on a stack, + // but it would be around 2.6 MB for BN254 for c = 18; + let space_to_keep_buckets_on_stack = (1 << WINDOW_SIZE) * g1_projective_size; + + let mut stack_size = (g1_affine_size + scalar_size + usize_size) * READ_BY + space_to_keep_buckets_on_stack + (1<<16); + if stack_size < MIN_STACK_SIZE { + stack_size = MIN_STACK_SIZE; + } + + let thread_step = num_threads * READ_BY; + + use crossbeam::thread; + + thread::scope(|s| { + for (thread_idx, subresult) in subresults.iter_mut().enumerate() { + let builder = s.builder().stack_size(stack_size); + builder.spawn(move |_| { + let limit = bases.len(); + let bases = &bases[..limit]; + let exponents = &exponents[..limit]; + let mut buckets = [::Projective::zero(); NUM_BUCKETS]; + let mut skip_bits = 0; + for chunk_schedule_idx in 0..num_windows { + if chunk_schedule_idx != 0 { + buckets = [::Projective::zero(); NUM_BUCKETS]; + } + for (i, (bases, exponents)) in bases.chunks(SYNCHRONIZATION_STEP) + .zip(exponents.chunks(SYNCHRONIZATION_STEP)) + .enumerate() { + let num_subchunks = bases.len() / thread_step; + let remainder_start = num_subchunks * thread_step; + let remainder_end = bases.len(); + // assert_eq!(remainder_start, remainder_end, "only support power of two multiexp size for now"); + let mut bases_holder = [G::zero(); READ_BY]; + let mut exponents_holder = [<::Fr as PrimeField>::Repr::default(); READ_BY]; + let mut indexes_holder = [0usize; READ_BY]; + for subchunk_start_idx in ((thread_idx*READ_BY)..remainder_start).step_by(thread_step) { + exponents_holder.copy_from_slice(&exponents[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + for (index, &exp) in indexes_holder.iter_mut().zip(exponents_holder.iter()) { + let mut exp = exp; + exp.shr(skip_bits); + *index = (exp.as_ref()[0] & MASK) as usize; + } + bases_holder.copy_from_slice(&bases[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + + let mut bases_iter = bases_holder.iter(); + let mut indexes_iter = indexes_holder.iter(); + + // semi-unroll first + let mut this_exp = *(&mut indexes_iter).next().unwrap(); + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&index, this_base) in indexes_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(&this_base); + } + + this_exp = index; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(&last_base); + } + } + + // process the remainder + let remainder_start = remainder_start + (thread_idx*READ_BY); + if remainder_start < remainder_end { + let remainder_end = if remainder_start + READ_BY > remainder_end { + remainder_end + } else { + remainder_start + READ_BY + }; + + let limit = remainder_end - remainder_start; + exponents_holder[..limit].copy_from_slice(&exponents[remainder_start..remainder_end]); + for (index, &exp) in indexes_holder.iter_mut().zip(exponents_holder.iter()) { + let mut exp = exp; + exp.shr(skip_bits); + *index = (exp.as_ref()[0] & MASK) as usize; + } + bases_holder[..limit].copy_from_slice(&bases[remainder_start..remainder_end]); + + let mut bases_iter = bases_holder[..limit].iter(); + let mut indexes_iter = indexes_holder[..limit].iter(); + + // semi-unroll first + let mut this_exp = *indexes_iter.next().unwrap(); + + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&index, this_base) in indexes_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(this_base); + } + + this_exp = index; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(last_base); + } + } + + (&barrs[chunk_schedule_idx][i]).wait(); + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = buckets[1]; + let mut running_sum = G::Projective::zero(); + for exp in buckets.iter().skip(2).rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip_bits { + acc.double(); + } + + subresult.add_assign(&acc); + + skip_bits += WINDOW_SIZE as u32; + } + }).unwrap(); + } + }).unwrap(); + + let mut result = subresults.drain(0..1).collect::>()[0]; + for t in subresults.into_iter() { + result.add_assign(&t); + } + + Ok(result) +} + +pub fn map_reduce_multiexp( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + }; + + let chunk_len = pool.get_chunk_size(exponents.len()); + + pool.scope(0, |scope, _| { + for (b, e) in bases.chunks(chunk_len).zip(exponents.chunks(chunk_len)) { + scope.spawn(move |_| { + serial_multiexp_inner(b, e, c).unwrap(); + }); + } + }); + + Ok(::Projective::zero()) +} + +pub fn map_reduce_multiexp_over_fixed_window( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32 +) -> Result<::Projective, SynthesisError> +{ + if ::Fr::NUM_BITS == 254 { + return map_reduce_multiexp_over_fixed_window_254(pool, bases, exponents, c); + } + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + + let chunk_len = pool.get_chunk_size(exponents.len()); + let num_threads = pool.cpus; + let mut subresults = vec![::Projective::zero(); num_threads]; + + pool.scope(0, |scope, _| { + for ((b, e), s) in bases.chunks(chunk_len).zip(exponents.chunks(chunk_len)).zip(subresults.iter_mut()) { + scope.spawn(move |_| { + // *s = test_memory_serial(b, e, c).unwrap(); + *s = serial_multiexp_inner(b, e, c).unwrap(); + }); + } + }); + + let mut result = ::Projective::zero(); + for s in subresults.into_iter() { + result.add_assign(&s); + } + + Ok(result) +} + +pub fn buffered_multiexp_over_fixed_window_and_buffer_size( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32, + buffer_size: usize +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + + let mut num_runs = (::Fr::NUM_BITS / c) as usize; + if ::Fr::NUM_BITS % c != 0 { + num_runs += 1; + } + + let mut subresults = vec![::Projective::zero(); num_runs]; + + pool.scope(0, |scope, _| { + let mut skip = 0u32; + for s in subresults.iter_mut() { + scope.spawn(move |_| { + *s = buffered_multiexp_inner(bases, exponents, c, skip, buffer_size).unwrap(); + }); + skip += c; + } + }); + + let mut result = ::Projective::zero(); + for s in subresults.into_iter() { + result.add_assign(&s); + } + + Ok(result) +} + +fn map_reduce_multiexp_over_fixed_window_254( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32 +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + + let chunk_len = pool.get_chunk_size(exponents.len()); + let num_threads = pool.cpus; + let mut subresults = vec![::Projective::zero(); num_threads]; + + pool.scope(0, |scope, _| { + for ((b, e), s) in bases.chunks(chunk_len).zip(exponents.chunks(chunk_len)).zip(subresults.iter_mut()) { + scope.spawn(move |_| { + let subres = match c { + 7 => map_reduce_multiexp_254_inner_7(b, e), + 8 => map_reduce_multiexp_254_inner_8(b, e), + 9 => map_reduce_multiexp_254_inner_9(b, e), + 10 => map_reduce_multiexp_254_inner_10(b, e), + 11 => map_reduce_multiexp_254_inner_11(b, e), + 12 => map_reduce_multiexp_254_inner_12(b, e), + 13 => map_reduce_multiexp_254_inner_13(b, e), + 14 => map_reduce_multiexp_254_inner_14(b, e), + 15 => map_reduce_multiexp_254_inner_15(b, e), + 16 => map_reduce_multiexp_254_inner_16(b, e), + 17 => map_reduce_multiexp_254_inner_17(b, e), + 18 => map_reduce_multiexp_254_inner_18(b, e), + _ => unimplemented!("window size is not supported"), + }; + + *s = subres.expect("must calcualate contribution from serial multiexp"); + }); + } + }); + + let mut result = ::Projective::zero(); + for s in subresults.into_iter() { + result.add_assign(&s); + } + + Ok(result) +} + +fn serial_multiexp_inner( + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32 +) -> Result<::Projective, SynthesisError> +{ + let num_buckets = (1 << c) - 1; + let mask: u64 = (1u64 << c) - 1u64; + + // let bases = bases.to_vec(); + // let exponents = exponents.to_vec(); + + let mut result = ::Projective::zero(); + + let mut num_runs = (::Fr::NUM_BITS / c) as usize; + if ::Fr::NUM_BITS % c != 0 { + num_runs += 1; + } + let mut buckets = vec![vec![::Projective::zero(); num_buckets]; num_runs as usize]; + for (&base, &exp) in bases.into_iter().zip(exponents.into_iter()) { + for window_index in 0..num_runs { + let mut exp = exp; + exp.shr(c); + let index = (exp.as_ref()[0] & mask) as usize; + if index != 0 { + // let mut tmp = buckets[window_index][index - 1]; + // tmp.add_assign_mixed(&base); + // buckets[window_index][index - 1] = tmp; + buckets[window_index][index - 1].add_assign_mixed(&base); + } + } + } + + let mut skip_bits = 0; + for b in buckets.into_iter() { + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in b.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip_bits { + acc.double(); + } + + result.add_assign(&acc); + + skip_bits += c as u32; + } + + Ok(result) +} + +// dummy function with minimal branching +fn test_memory_serial( + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32 +) -> Result<::Projective, SynthesisError> +{ + let num_buckets = (1 << c) - 1; + let mask: u64 = (1u64 << c) - 1u64; + + // let bases = bases.to_vec(); + // let exponents = exponents.to_vec(); + + let mut result = ::Projective::zero(); + + let mut num_runs = (::Fr::NUM_BITS / c) as usize; + if ::Fr::NUM_BITS % c != 0 { + num_runs += 1; + } + + let mut buckets = vec![::Projective::zero(); num_runs as usize]; + for (&base, &exp) in bases.into_iter().zip(exponents.into_iter()) { + for window_index in 0..num_runs { + let mut exp = exp; + exp.shr(c); + let index = (exp.as_ref()[0] & mask) as usize; + if index != 0 { + buckets[window_index].add_assign_mixed(&base); + } + } + } + + for _ in 0..num_runs { + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..100 { + acc.double(); + } + + result.add_assign(&acc); + } + + + Ok(result) +} + +fn buffered_multiexp_inner( + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + c: u32, + skip: u32, + buffer_size: usize +) -> Result<::Projective, SynthesisError> +{ + let num_buckets = (1 << c) - 1; + let mask: u64 = (1u64 << c) - 1u64; + + let mut buckets = vec![::Projective::zero(); num_buckets]; + let mut buffers: Vec> = vec![Vec::with_capacity(buffer_size); num_buckets]; + for (&base, &exp) in bases.into_iter().zip(exponents.into_iter()) { + let mut exp = exp; + exp.shr(skip); + let index = (exp.as_ref()[0] & mask) as usize; + if index != 0 { + let idx = index - 1; + if buffers[idx].len() == buffer_size { + // buffer is full, so let's collapse + let mut el = buckets[idx]; + for b in buffers[idx].iter() { + el.add_assign_mixed(&b); + } + buckets[idx] = el; + buffers[idx].truncate(0); + } + + // we always add the point + buffers[idx].push(base); + } + } + + // we have some unprocessed left, so add them to the buckets + for (idx, buffer) in buffers.into_iter().enumerate() { + let mut el = buckets[idx]; + for b in buffer.into_iter() { + el.add_assign_mixed(&b); + } + buckets[idx] = el; + } + + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip { + acc.double(); + } + + Ok(acc) +} + +macro_rules! construct_stack_multiexp { + ( $visibility:vis fn $name:ident ( $n_words:tt ); ) => { + $visibility fn $name( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] + ) -> Result<::Projective, SynthesisError> + { + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + + const WINDOW_SIZE: usize = $n_words; + const SYNCHRONIZATION_STEP: usize = 1 << 17; + const READ_BY: usize = 1 << 7; + const MIN_STACK_SIZE: usize = 1 << 21; // 2MB + const NUM_BUCKETS: usize = 1 << WINDOW_SIZE; + const MASK: u64 = (1 << WINDOW_SIZE) - 1; + + assert!(SYNCHRONIZATION_STEP % READ_BY == 0); + + let num_threads = pool.cpus; + + let mut subresults = vec![::Projective::zero(); num_threads]; + + use std::sync::{Arc, Barrier}; + + let num_rounds = bases.len() / SYNCHRONIZATION_STEP; + let mut num_windows = (::Fr::NUM_BITS as usize) / WINDOW_SIZE; + if (::Fr::NUM_BITS as usize) % WINDOW_SIZE != 0 { + num_windows += 1; + } + + let mut barriers = Vec::with_capacity(num_windows); + for _ in 0..num_windows { + let mut tt = Vec::with_capacity(num_rounds); + for _ in 0..num_rounds { + let t = Barrier::new(num_threads); + tt.push(t); + } + barriers.push(tt); + } + + let barrs = &barriers; + + let g1_projective_size = std::mem::size_of::<::Projective>(); + let g1_affine_size = std::mem::size_of::(); + let scalar_size = std::mem::size_of::<<::Fr as PrimeField>::Repr>(); + let usize_size = std::mem::size_of::(); + + // potentially we can keep all the buckets on a stack, + // but it would be around 2.6 MB for BN254 for c = 18; + let space_to_keep_buckets_on_stack = (1 << WINDOW_SIZE) * g1_projective_size; + + let mut stack_size = (g1_affine_size + scalar_size + usize_size) * READ_BY + space_to_keep_buckets_on_stack + (1<<16); + if stack_size < MIN_STACK_SIZE { + stack_size = MIN_STACK_SIZE; + } + + let thread_step = num_threads * READ_BY; + + use crossbeam::thread; + + thread::scope(|s| { + for (thread_idx, subresult) in subresults.iter_mut().enumerate() { + let builder = s.builder().stack_size(stack_size); + builder.spawn(move |_| { + let limit = bases.len(); + let bases = &bases[..limit]; + let exponents = &exponents[..limit]; + let mut buckets = [::Projective::zero(); NUM_BUCKETS]; + let mut skip_bits = 0; + for chunk_schedule_idx in 0..num_windows { + if chunk_schedule_idx != 0 { + buckets = [::Projective::zero(); NUM_BUCKETS]; + } + for (i, (bases, exponents)) in bases.chunks(SYNCHRONIZATION_STEP) + .zip(exponents.chunks(SYNCHRONIZATION_STEP)) + .enumerate() { + let num_subchunks = bases.len() / thread_step; + let remainder_start = num_subchunks * thread_step; + let remainder_end = bases.len(); + // assert_eq!(remainder_start, remainder_end, "only support power of two multiexp size for now"); + let mut bases_holder = [G::zero(); READ_BY]; + let mut exponents_holder = [<::Fr as PrimeField>::Repr::default(); READ_BY]; + let mut indexes_holder = [0usize; READ_BY]; + for subchunk_start_idx in ((thread_idx*READ_BY)..remainder_start).step_by(thread_step) { + exponents_holder.copy_from_slice(&exponents[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + for (index, &exp) in indexes_holder.iter_mut().zip(exponents_holder.iter()) { + let mut exp = exp; + exp.shr(skip_bits); + *index = (exp.as_ref()[0] & MASK) as usize; + } + bases_holder.copy_from_slice(&bases[subchunk_start_idx..(subchunk_start_idx+READ_BY)]); + + let mut bases_iter = bases_holder.iter(); + let mut indexes_iter = indexes_holder.iter(); + + // semi-unroll first + let mut this_exp = *(&mut indexes_iter).next().unwrap(); + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&index, this_base) in indexes_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(&this_base); + } + + this_exp = index; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(&last_base); + } + } + + // process the remainder + let remainder_start = remainder_start + (thread_idx*READ_BY); + if remainder_start < remainder_end { + let remainder_end = if remainder_start + READ_BY > remainder_end { + remainder_end + } else { + remainder_start + READ_BY + }; + + let limit = remainder_end - remainder_start; + exponents_holder[..limit].copy_from_slice(&exponents[remainder_start..remainder_end]); + for (index, &exp) in indexes_holder.iter_mut().zip(exponents_holder.iter()) { + let mut exp = exp; + exp.shr(skip_bits); + *index = (exp.as_ref()[0] & MASK) as usize; + } + bases_holder[..limit].copy_from_slice(&bases[remainder_start..remainder_end]); + + let mut bases_iter = bases_holder[..limit].iter(); + let mut indexes_iter = indexes_holder[..limit].iter(); + + // semi-unroll first + let mut this_exp = *indexes_iter.next().unwrap(); + + let mut base_prefetch_counter = 0; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + + for (&index, this_base) in indexes_iter.zip(&mut bases_iter) { + if this_exp != 0 { + buckets[this_exp].add_assign_mixed(this_base); + } + + this_exp = index; + + base_prefetch_counter += 1; + crate::prefetch::prefetch_l1_pointer(&buckets[this_exp]); + crate::prefetch::prefetch_l1_pointer(&bases_holder[base_prefetch_counter]); + } + + // finish + if this_exp != 0 { + let last_base = bases_iter.next().unwrap(); + buckets[this_exp].add_assign_mixed(last_base); + } + } + + (&barrs[chunk_schedule_idx][i]).wait(); + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = buckets[1]; + let mut running_sum = G::Projective::zero(); + for exp in buckets.iter().skip(2).rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip_bits { + acc.double(); + } + + subresult.add_assign(&acc); + + skip_bits += WINDOW_SIZE as u32; + } + }).unwrap(); + } + }).unwrap(); + + let mut result = subresults.drain(0..1).collect::>()[0]; + for t in subresults.into_iter() { + result.add_assign(&t); + } + + Ok(result) + } + } +} + +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_12(12);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_13(13);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_14(14);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_15(15);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_16(16);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_17(17);); +construct_stack_multiexp!(pub fn stack_allocated_dense_multiexp_18(18);); + +macro_rules! construct_map_reduce_multiexp_inner { + ( $visibility:vis fn $name:ident ( $n_window: tt, $n_bits: tt); ) => { + $visibility fn $name( + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] + ) -> Result<::Projective, SynthesisError> + { + const WINDOW: u32 = $n_window; + const NUM_BUCKETS: usize = (1 << WINDOW) - 1; + const MASK: u64 = (1u64 << WINDOW) - 1u64; + const NUM_RUNS: usize = ($n_bits / $n_window) + (($n_bits % $n_window > 0) as u32) as usize; + + let mut num_runs_runtime = (::Fr::NUM_BITS / WINDOW) as usize; + if ::Fr::NUM_BITS % WINDOW != 0 { + num_runs_runtime += 1; + } + + assert_eq!(NUM_RUNS, num_runs_runtime, "invalid number of windows in runtime"); + + let mut result = ::Projective::zero(); + + let mut buckets = vec![vec![::Projective::zero(); NUM_BUCKETS]; NUM_RUNS as usize]; + let mut bucket_indexes = [0usize; NUM_RUNS]; + for (&base, &exp) in bases.into_iter().zip(exponents.into_iter()) { + // first we form bucket indexes + let mut exp = exp; + for (window_index, bucket_index) in bucket_indexes.iter_mut().enumerate() { + let index = (exp.as_ref()[0] & MASK) as usize; + exp.shr(WINDOW); + if index != 0 { + crate::prefetch::prefetch_l1_pointer(&buckets[window_index][index - 1]); + } + *bucket_index = index; + } + + for (window_index, &index) in bucket_indexes.iter().enumerate() { + if index != 0 { + // let mut tmp = buckets[window_index][index - 1]; + // tmp.add_assign_mixed(&base); + // buckets[window_index][index - 1] = tmp; + buckets[window_index][index - 1].add_assign_mixed(&base); + } + } + } + + let mut skip_bits = 0; + for b in buckets.into_iter() { + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in b.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip_bits { + acc.double(); + } + + result.add_assign(&acc); + + skip_bits += WINDOW; + } + + Ok(result) + } + } +} + +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_7(7, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_8(8, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_9(9, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_10(10, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_11(11, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_12(12, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_13(13, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_14(14, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_15(15, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_16(16, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_17(17, 254);); +construct_map_reduce_multiexp_inner!(pub fn map_reduce_multiexp_254_inner_18(18, 254);); + +pub fn l3_shared_multexp( + pool: &Worker, + common_bases: & [G], + exponents_set: &[&[<::Fr as PrimeField>::Repr]], +) -> Result<::Projective, SynthesisError> +{ + for exponents in exponents_set.iter() { + if exponents.len() != common_bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + } + + const NUM_WINDOWS: usize = 22; + const WINDOW_SIZE: u32 = 12; + const MASK: u64 = (1u64 << WINDOW_SIZE) - 1; + const NUM_BUCKETS: usize = 1 << WINDOW_SIZE; + const SYNCHRONIZATION_STEP: usize = 1 << 14; // if element size is 64 = 2^7 bytes then we take around 2^21 = 2MB of cache + + assert!((WINDOW_SIZE as usize) * NUM_WINDOWS >= 254); + + fn get_bits(el: Repr, start: usize) -> u64 { + const WINDOW_SIZE: u32 = 12; + const MASK: u64 = (1u64 << WINDOW_SIZE) - 1; + + let end = (start + (WINDOW_SIZE as usize)) % 256; + + let word_begin = start / 64; + let word_end = end / 64; + + let result: u64; + + if word_begin == word_end { + let shift = start % 64; + result = (el.as_ref()[word_begin] >> shift) & MASK; + } else { + let shift_low = start % 64; + let shift_high = 64 - shift_low; + result = ((el.as_ref()[word_begin] >> shift_low) | (el.as_ref()[word_end] << shift_high)) & MASK; + } + + result + } + + // let mut subresults = vec![::Projective::zero(); num_threads]; + + let limit = common_bases.len() - 2; + + use std::sync::Barrier; + let num_threads = NUM_WINDOWS * exponents_set.len(); + let num_sync_rounds = limit / SYNCHRONIZATION_STEP; + let mut barriers = Vec::with_capacity(num_sync_rounds); + for _ in 0..num_sync_rounds { + let t = Barrier::new(num_threads); + barriers.push(t); + } + + let barrs = &barriers; + + pool.scope(0, |scope, _| { + for (exponents_idx, exponents) in exponents_set.iter().enumerate() { + // first one is unrolled manually + let mut start = 0; + if exponents_idx == 0 { + scope.spawn(move |_| { + let mut barriers_it = barrs.iter(); + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + unsafe { crate::prefetch::prefetch_l3(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l3(common_bases.get_unchecked(i+1)) }; + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + if this_index != 0 { + unsafe { buckets.get_unchecked_mut(this_index-1).add_assign_mixed(&base) }; + } + + if next_index != 0 { + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index-1)) }; + this_index = next_index; + } + + // unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + // unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + // this_index = next_index; + + // i != 0 and i % SYNCHRONIZATION_STEP == 0 + if i !=0 && (i & (SYNCHRONIZATION_STEP - 1)) == 0 { + barriers_it.next().unwrap().wait(); + } + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } else { + // we do not to prefetch bases, only exponents + scope.spawn(move |_| { + let mut barriers_it = barrs.iter(); + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + unsafe { crate::prefetch::prefetch_l3(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + if this_index != 0 { + unsafe { buckets.get_unchecked_mut(this_index-1).add_assign_mixed(&base) }; + } + + if next_index != 0 { + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index-1)) }; + this_index = next_index; + } + + // unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + // unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + // this_index = next_index; + + // i != 0 and i % SYNCHRONIZATION_STEP == 0 + if i !=0 && (i & (SYNCHRONIZATION_STEP - 1)) == 0 { + barriers_it.next().unwrap().wait(); + } + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } + + for _ in 1..NUM_WINDOWS { + // no L3 prefetches here + start += WINDOW_SIZE as usize; + scope.spawn(move |_| { + let mut barriers_it = barrs.iter(); + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + if this_index != 0 { + unsafe { buckets.get_unchecked_mut(this_index-1).add_assign_mixed(&base) }; + } + + if next_index != 0 { + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index-1)) }; + this_index = next_index; + } + + // unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + // unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + // this_index = next_index; + + // i != 0 and i % SYNCHRONIZATION_STEP == 0 + if i !=0 && (i & (SYNCHRONIZATION_STEP - 1)) == 0 { + barriers_it.next().unwrap().wait(); + } + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } + } + }); + + // let mut result = ::Projective::zero(); + // for s in subresults.into_iter() { + // result.add_assign(&s); + // } + + Ok(::Projective::zero()) +} + +pub fn l3_shared_multexp_with_local_access( + pool: &Worker, + common_bases: & [G], + exponents_set: &[&[<::Fr as PrimeField>::Repr]], +) -> Result<::Projective, SynthesisError> +{ + use std::sync::atomic::{AtomicUsize, Ordering}; + + static GLOBAL_THREAD_COUNT: AtomicUsize = AtomicUsize::new(0); + + assert_eq!(exponents_set.len(), 2, "only support unroll by 2 for now"); + for exponents in exponents_set.iter() { + if exponents.len() != common_bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + } + + const NUM_WINDOWS: usize = 22; + const WINDOW_SIZE: u32 = 12; + const MASK: u64 = (1u64 << WINDOW_SIZE) - 1; + const NUM_BUCKETS: usize = 1 << WINDOW_SIZE; + + assert!((WINDOW_SIZE as usize) * NUM_WINDOWS >= 254); + + fn get_bits(el: Repr, start: usize) -> u64 { + const WINDOW_SIZE: u32 = 12; + const MASK: u64 = (1u64 << WINDOW_SIZE) - 1; + + let end = (start + (WINDOW_SIZE as usize)) % 256; + + let word_begin = start / 64; + let word_end = end / 64; + + let result: u64; + + if word_begin == word_end { + let shift = start % 64; + result = (el.as_ref()[word_begin] >> shift) & MASK; + } else { + let shift_low = start % 64; + let shift_high = 64 - shift_low; + result = ((el.as_ref()[word_begin] >> shift_low) | (el.as_ref()[word_end] << shift_high)) & MASK; + } + + result + } + + // let mut subresults = vec![::Projective::zero(); num_threads]; + + let limit = common_bases.len() - 2; + + pool.scope(0, |scope, _| { + for (exponents_idx, exponents) in exponents_set.iter().enumerate() { + // first one is unrolled manually + let mut start = 0; + if exponents_idx == 0 { + scope.spawn(move |_| { + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + // unsafe { crate::prefetch::prefetch_l3(exponents.get_unchecked(i+2)) }; + // unsafe { crate::prefetch::prefetch_l3(common_bases.get_unchecked(i+1)) }; + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + // if this_index != 0 { + // unsafe { buckets.get_unchecked_mut(this_index-1).add_assign_mixed(&base) }; + // } + + // if next_index != 0 { + // unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index-1)) }; + // this_index = next_index; + // } + + unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + this_index = next_index; + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } else { + // we do not to prefetch bases, only exponents + scope.spawn(move |_| { + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + // unsafe { crate::prefetch::prefetch_l3(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + this_index = next_index; + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } + + for _ in 0..128 { + let _ = GLOBAL_THREAD_COUNT.fetch_add(1, Ordering::SeqCst); + } + // std::thread::sleep(std::time::Duration::from_nanos(100)); + + for _ in 1..NUM_WINDOWS { + // no L3 prefetches here + start += WINDOW_SIZE as usize; + scope.spawn(move |_| { + let mut buckets = vec![::Projective::zero(); NUM_BUCKETS]; + + let tmp = exponents[0]; + let mut this_index = get_bits(tmp, start) as usize; + for i in 0..limit { + unsafe { crate::prefetch::prefetch_l1(exponents.get_unchecked(i+2)) }; + unsafe { crate::prefetch::prefetch_l1(common_bases.get_unchecked(i+1)) }; + + let tmp = unsafe { *exponents.get_unchecked(i+1) }; + let base = unsafe { *common_bases.get_unchecked(i) }; + let next_index = get_bits(tmp, start) as usize; + + unsafe { buckets.get_unchecked_mut(this_index).add_assign_mixed(&base) }; + unsafe { crate::prefetch::prefetch_l1(buckets.get_unchecked(next_index)) }; + this_index = next_index; + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut acc = G::Projective::zero(); + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..start { + acc.double(); + } + }); + } + } + }); + + // let mut result = ::Projective::zero(); + // for s in subresults.into_iter() { + // result.add_assign(&s); + // } + + Ok(::Projective::zero()) +} + + +#[allow(dead_code)] +pub fn dense_unrolled_multiexp_with_prefetch( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + dense_multiexp_inner_unrolled_with_prefetch(pool, bases, exponents, 0, c, true) +} + +#[allow(dead_code)] +fn dense_multiexp_inner_unrolled_with_prefetch( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + mut skip: u32, + c: u32, + handle_trivial: bool +) -> Result<::Projective, SynthesisError> +{ + const UNROLL_BY: usize = 8; + + use std::sync::{Mutex}; + // Perform this region of the multiexp. We use a different strategy - go over region in parallel, + // then over another region, etc. No Arc required + let this = { + let mask = (1u64 << c) - 1u64; + let this_region = Mutex::new(::Projective::zero()); + let arc = Arc::new(this_region); + + pool.scope(bases.len(), |scope, chunk| { + for (bases, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { + let this_region_rwlock = arc.clone(); + // let handle = + scope.spawn(move |_| { + let mut buckets = vec![::Projective::zero(); (1 << c) - 1]; + // Accumulate the result + let mut acc = G::Projective::zero(); + let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + let unrolled_steps = bases.len() / UNROLL_BY; + let remainder = bases.len() % UNROLL_BY; + + let mut offset = 0; + for _ in 0..unrolled_steps { + // [0..7] + for i in 0..UNROLL_BY { + crate::prefetch::prefetch_l3_pointer(&bases[offset+i] as *const _); + crate::prefetch::prefetch_l3_pointer(&exp[offset+i] as *const _); + } + + // offset + [0..6] + for i in 0..(UNROLL_BY-1) { + let this_exp = exp[offset+i]; + let mut next_exp = exp[offset+i+1]; + let base = &bases[offset+i]; + + if this_exp != zero { + if this_exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + if this_exp != 0 { + buckets[(this_exp - 1) as usize].add_assign_mixed(base); + } + } + } + + { + next_exp.shr(skip); + let next_exp = next_exp.as_ref()[0] & mask; + if next_exp != 0 { + crate::prefetch::prefetch_l3_pointer(&buckets[(next_exp - 1) as usize] as *const _); + } + } + } + + // offset + 7 + let this_exp = exp[offset+(UNROLL_BY-1)]; + let base = &bases[offset+(UNROLL_BY-1)]; + + if this_exp != zero { + if this_exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + if this_exp != 0 { + buckets[(this_exp - 1) as usize].add_assign_mixed(base); + } + } + } + + // go into next region + offset += UNROLL_BY; + } + + for _ in 0..remainder { + let this_exp = exp[offset]; + let base = &bases[offset]; + + if this_exp != zero { + if this_exp == one { + if handle_trivial { + acc.add_assign_mixed(base); + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + if this_exp != 0 { + buckets[(this_exp - 1) as usize].add_assign_mixed(base); + } + } + } + + offset += 1; + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + let mut guard = match this_region_rwlock.lock() { + Ok(guard) => guard, + Err(_) => { + panic!("poisoned!"); + // poisoned.into_inner() + } + }; + + (*guard).add_assign(&acc); + }); + + } + }); + + let this_region = Arc::try_unwrap(arc).unwrap(); + let this_region = this_region.into_inner().unwrap(); + + this_region + }; + + skip += c; + + if skip >= ::Fr::NUM_BITS { + // There isn't another region, and this will be the highest region + return Ok(this); + } else { + // next region is actually higher than this one, so double it enough times + let mut next_region = dense_multiexp_inner_unrolled_with_prefetch( + pool, bases, exponents, skip, c, false).unwrap(); + for _ in 0..c { + next_region.double(); + } + + next_region.add_assign(&this); + + return Ok(next_region); + } +} + + +#[allow(dead_code)] +pub fn dense_multiexp_with_manual_unrolling( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr] +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + // do some heuristics here + // we proceed chunks of all points, and all workers do the same work over + // some scalar width, so to have expected number of additions into buckets to 1 + // we have to take log2 from the expected chunk(!) length + let c = if exponents.len() < 32 { + 3u32 + } else { + let chunk_len = pool.get_chunk_size(exponents.len()); + (f64::from(chunk_len as u32)).ln().ceil() as u32 + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + dense_multiexp_with_manual_unrolling_impl(pool, bases, exponents, 0, c, true) + // dense_multiexp_with_manual_unrolling_impl_2(pool, bases, exponents, 0, c, true) +} + + +#[allow(dead_code)] +fn dense_multiexp_with_manual_unrolling_impl( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + mut skip: u32, + c: u32, + handle_trivial: bool +) -> Result<::Projective, SynthesisError> +{ + const UNROLL_BY: usize = 1024; + + use std::sync::{Mutex}; + // Perform this region of the multiexp. We use a different strategy - go over region in parallel, + // then over another region, etc. No Arc required + let this = { + let mask = (1u64 << c) - 1u64; + let this_region = Mutex::new(::Projective::zero()); + let arc = Arc::new(this_region); + + pool.scope(bases.len(), |scope, chunk| { + for (bases, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { + let this_region_rwlock = arc.clone(); + // let handle = + scope.spawn(move |_| { + // make buckets for ALL exponents including 0 and 1 + let mut buckets = vec![::Projective::zero(); 1 << c]; + + // let zero = ::Fr::zero().into_repr(); + let one = ::Fr::one().into_repr(); + + let mut this_chunk_exponents = [<::Fr as PrimeField>::Repr::default(); UNROLL_BY]; + let mut next_chunk_exponents = [<::Fr as PrimeField>::Repr::default(); UNROLL_BY]; + + let mut this_chunk_bases = [G::zero(); UNROLL_BY]; + let mut next_chunk_bases = [G::zero(); UNROLL_BY]; + + let unrolled_steps = bases.len() / UNROLL_BY; + assert!(unrolled_steps >= 2); + let remainder = bases.len() % UNROLL_BY; + assert_eq!(remainder, 0); + + // first step is manually unrolled + + // manually copy to the stack + let mut start_idx = 0; + let mut end_idx = UNROLL_BY; + this_chunk_exponents.copy_from_slice(&exp[start_idx..end_idx]); + this_chunk_bases.copy_from_slice(&bases[start_idx..end_idx]); + + start_idx += UNROLL_BY; + end_idx += UNROLL_BY; + next_chunk_exponents.copy_from_slice(&exp[start_idx..end_idx]); + next_chunk_bases.copy_from_slice(&bases[start_idx..end_idx]); + + let mut intra_chunk_idx = 0; + + let mut previous_exponent_index = 0; + let mut previous_base = G::zero(); + + let mut this_exponent_index = 0; + let mut this_base = G::zero(); + + let this_exp = this_chunk_exponents[intra_chunk_idx]; + + if this_exp == one { + if handle_trivial { + this_exponent_index = 1; + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + this_exponent_index = this_exp as usize; + } + + this_base = this_chunk_bases[intra_chunk_idx]; + + previous_base = this_base; + previous_exponent_index = this_exponent_index; + + crate::prefetch::prefetch_l2_pointer(&buckets[previous_exponent_index] as *const _); + + intra_chunk_idx += 1; + + // now we can roll + + for _ in 1..(unrolled_steps-1) { + while intra_chunk_idx < UNROLL_BY { + // add what was processed in a previous step + (&mut buckets[previous_exponent_index]).add_assign_mixed(&previous_base); + + let this_exp = this_chunk_exponents[intra_chunk_idx]; + + if this_exp == one { + if handle_trivial { + this_exponent_index = 1; + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + this_exponent_index = this_exp as usize; + } + + this_base = this_chunk_bases[intra_chunk_idx]; + + previous_base = this_base; + previous_exponent_index = this_exponent_index; + + crate::prefetch::prefetch_l2_pointer(&buckets[previous_exponent_index] as *const _); + + intra_chunk_idx += 1; + } + + // swap and read next chunk + + this_chunk_bases = next_chunk_bases; + this_chunk_exponents = next_chunk_exponents; + + start_idx += UNROLL_BY; + end_idx += UNROLL_BY; + next_chunk_exponents.copy_from_slice(&exp[start_idx..end_idx]); + next_chunk_bases.copy_from_slice(&bases[start_idx..end_idx]); + + intra_chunk_idx = 0; + } + + // process the last one + { + while intra_chunk_idx < UNROLL_BY { + // add what was processed in a previous step + (&mut buckets[previous_exponent_index]).add_assign_mixed(&previous_base); + + let this_exp = this_chunk_exponents[intra_chunk_idx]; + + if this_exp == one { + if handle_trivial { + this_exponent_index = 1; + } + } else { + let mut this_exp = this_exp; + this_exp.shr(skip); + let this_exp = this_exp.as_ref()[0] & mask; + this_exponent_index = this_exp as usize; + } + + this_base = this_chunk_bases[intra_chunk_idx]; + + previous_base = this_base; + previous_exponent_index = this_exponent_index; + + crate::prefetch::prefetch_l2_pointer(&buckets[previous_exponent_index] as *const _); + + intra_chunk_idx += 1; + } + + // very last addition + (&mut buckets[previous_exponent_index]).add_assign_mixed(&previous_base); + } + + let _: Vec<_> = buckets.drain(..1).collect(); + + let acc: Vec<_> = buckets.drain(..1).collect(); + let mut acc = acc[0]; + + // buckets are filled with the corresponding accumulated value, now sum + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + let mut guard = match this_region_rwlock.lock() { + Ok(guard) => guard, + Err(_) => { + panic!("poisoned!"); + // poisoned.into_inner() + } + }; + + (*guard).add_assign(&acc); + }); + + } + }); + + let this_region = Arc::try_unwrap(arc).unwrap(); + let this_region = this_region.into_inner().unwrap(); + + this_region + }; + + skip += c; + + if skip >= ::Fr::NUM_BITS { + // There isn't another region, and this will be the highest region + return Ok(this); + } else { + // next region is actually higher than this one, so double it enough times + let mut next_region = dense_multiexp_with_manual_unrolling_impl( + pool, bases, exponents, skip, c, false).unwrap(); + for _ in 0..c { + next_region.double(); + } + + next_region.add_assign(&this); + + return Ok(next_region); + } +} + + +#[allow(dead_code)] +fn dense_multiexp_with_manual_unrolling_impl_2( + pool: &Worker, + bases: & [G], + exponents: & [<::Fr as PrimeField>::Repr], + mut skip: u32, + c: u32, + _handle_trivial: bool +) -> Result<::Projective, SynthesisError> +{ + // we assume that a single memory fetch is around 10-12 ns, so before any operation + // we ideally should prefetch a memory unit for a next operation + const CACHE_BY: usize = 1024; + + use std::sync::{Mutex}; + // Perform this region of the multiexp. We use a different strategy - go over region in parallel, + // then over another region, etc. No Arc required + let this = { + let mask = (1u64 << c) - 1u64; + let this_region = Mutex::new(::Projective::zero()); + let arc = Arc::new(this_region); + + pool.scope(bases.len(), |scope, chunk| { + for (bases, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { + let this_region_rwlock = arc.clone(); + // let handle = + scope.spawn(move |_| { + // make buckets for ALL exponents including 0 and 1 + let mut buckets = vec![::Projective::zero(); 1 << c]; + + // let zero = ::Fr::zero().into_repr(); + // let one = ::Fr::one().into_repr(); + + let mut exponents_chunk = [<::Fr as PrimeField>::Repr::default(); CACHE_BY]; + let mut bases_chunk = [G::zero(); CACHE_BY]; + + let unrolled_steps = bases.len() / CACHE_BY; + assert!(unrolled_steps >= 2); + let remainder = bases.len() % CACHE_BY; + assert_eq!(remainder, 0); + + use std::ptr::NonNull; + + let mut basket_pointers_to_process = [(NonNull::< ::Projective>::dangling(), G::zero()); CACHE_BY]; + + let basket_pointer = buckets.as_mut_ptr(); + + let mut start_idx = 0; + let mut end_idx = CACHE_BY; + + for _ in 0..(unrolled_steps-1) { + exponents_chunk.copy_from_slice(&exp[start_idx..end_idx]); + bases_chunk.copy_from_slice(&bases[start_idx..end_idx]); + + let mut bucket_idx = 0; + + for (e, b) in exponents_chunk.iter().zip(bases_chunk.iter()) { + let mut this_exp = *e; + this_exp.shr(skip); + let this_exp = (this_exp.as_ref()[0] & mask) as usize; + if this_exp != 0 { + let ptr = unsafe { NonNull::new_unchecked(basket_pointer.add(this_exp)) }; + basket_pointers_to_process[bucket_idx] = (ptr, *b); + bucket_idx += 1; + } + } + + for i in 0..bucket_idx { + crate::prefetch::prefetch_l1_pointer(basket_pointers_to_process[i].0.as_ptr() as *const _); + } + + crate::prefetch::prefetch_l2_pointer(&bases[end_idx] as *const _); + crate::prefetch::prefetch_l2_pointer(&bases[end_idx+1] as *const _); + + for i in 0..bucket_idx { + let (mut ptr, to_add) = basket_pointers_to_process[i]; + let point_ref: &mut _ = unsafe { ptr.as_mut()}; + point_ref.add_assign_mixed(&to_add); + } + + start_idx += CACHE_BY; + end_idx += CACHE_BY; + } + + drop(basket_pointer); + + let _: Vec<_> = buckets.drain(..1).collect(); + + let acc: Vec<_> = buckets.drain(..1).collect(); + let mut acc = acc[0]; + + // buckets are filled with the corresponding accumulated value, now sum + let mut running_sum = G::Projective::zero(); + for exp in buckets.into_iter().rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + let mut guard = match this_region_rwlock.lock() { + Ok(guard) => guard, + Err(_) => { + panic!("poisoned!"); + // poisoned.into_inner() + } + }; + + (*guard).add_assign(&acc); + }); + + } + }); + + let this_region = Arc::try_unwrap(arc).unwrap(); + let this_region = this_region.into_inner().unwrap(); + + this_region + }; + + skip += c; + + if skip >= ::Fr::NUM_BITS { + // There isn't another region, and this will be the highest region + return Ok(this); + } else { + // next region is actually higher than this one, so double it enough times + let mut next_region = dense_multiexp_with_manual_unrolling_impl_2( + pool, bases, exponents, skip, c, false).unwrap(); + for _ in 0..c { + next_region.double(); + } + + next_region.add_assign(&this); + + return Ok(next_region); + } +} + + +/// Perform multi-exponentiation. The caller is responsible for ensuring that +/// the number of bases is the same as the number of exponents. +#[allow(dead_code)] +pub fn dense_multiexp_consume( + pool: &Worker, + bases: & [G], + exponents: Vec<<::Fr as PrimeField>::Repr> +) -> Result<::Projective, SynthesisError> +{ + if exponents.len() != bases.len() { + return Err(SynthesisError::AssignmentMissing); + } + let c = if exponents.len() < 32 { + 3u32 + } else { + (f64::from(exponents.len() as u32)).ln().ceil() as u32 + }; + + dense_multiexp_inner_consume(pool, bases, exponents, c) +} + +fn dense_multiexp_inner_consume( + pool: &Worker, + bases: & [G], + exponents: Vec<<::Fr as PrimeField>::Repr>, + c: u32, +) -> Result<::Projective, SynthesisError> +{ + // spawn exactly required number of threads at the time, not more + // each thread mutates part of the exponents and walks over the same range of bases + + use std::sync::mpsc::{channel}; + + let (tx, rx) = channel(); + + pool.scope(bases.len(), |scope, chunk| { + for (base, exp) in bases.chunks(chunk).zip(exponents.chunks(chunk)) { + let tx = tx.clone(); + scope.spawn(move |_| { + let mut skip = 0; + + let mut result = G::Projective::zero(); + + let mut buckets = vec![::Projective::zero(); 1 << c]; + + let zero = ::Fr::zero().into_repr(); + // let one = ::Fr::one().into_repr(); + + let padding = Some(::Fr::zero().into_repr()); + let mask: u64 = (1 << c) - 1; + + loop { + let mut next_bucket_index = (exp[0].as_ref()[0] & mask) as usize; + let exp_next_constant_iter = exp.iter().skip(1); + // let this_exp_to_use = exp.iter(); + + let mut acc = G::Projective::zero(); + + // for ((base, &this_exp_to_use), &next_exp_to_prefetch) in base.iter() + // .zip(this_exp_to_use) + // .zip(exp_next_constant_iter.chain(padding.iter())) + // { + for (base, &next_exp_to_prefetch) in base.iter() + .zip(exp_next_constant_iter.chain(padding.iter())) + { + let this_bucket_index = next_bucket_index; + + { + // if next_exp_to_prefetch != zero && next_exp_to_prefetch != one { + if next_exp_to_prefetch != zero { + let mut e = next_exp_to_prefetch; + e.shr(skip); + next_bucket_index = (next_exp_to_prefetch.as_ref()[0] & mask) as usize; + + if next_bucket_index > 0 { + // crate::prefetch::prefetch_l3(&buckets[next_bucket_index]); + crate::prefetch::prefetch_l3_pointer(&buckets[next_bucket_index] as *const _); + } + } else { + next_bucket_index = 0; + } + } + + if this_bucket_index > 0 { + buckets[this_bucket_index].add_assign_mixed(base); + } + + // // now add base to the bucket that we've + // if this_bucket_index > 1 { + // buckets[this_bucket_index].add_assign_mixed(base); + // } else { + // acc.add_assign_mixed(base); + // } + } + + // buckets are filled with the corresponding accumulated value, now sum + let mut running_sum = G::Projective::zero(); + // now start from the last one and add + for exp in buckets.iter().skip(1).rev() { + running_sum.add_assign(&exp); + acc.add_assign(&running_sum); + } + + for _ in 0..skip { + acc.double(); + } + + result.add_assign(&acc); + + skip += c; + + if skip >= ::Fr::NUM_BITS { + // next chunk is the last one + tx.send(result).unwrap(); + + break; + } else { + buckets.truncate(0); + buckets.resize(1 << c, ::Projective::zero()); + } + } + }); + } + }); + + // do something with rx + + let mut result = ::Projective::zero(); + + for value in rx.try_iter() { + result.add_assign(&value); + } + + Ok(result) +} + +#[cfg(test)] +mod test { + use super::*; + + fn naive_multiexp( + bases: Arc>, + exponents: Arc::Repr>> + ) -> G::Projective + { + assert_eq!(bases.len(), exponents.len()); + + let mut acc = G::Projective::zero(); + + for (base, exp) in bases.iter().zip(exponents.iter()) { + acc.add_assign(&base.mul(*exp)); + } + + acc + } + + #[test] + fn test_new_multiexp_with_bls12() { + use rand::{self, Rand}; + use crate::pairing::bls12_381::Bls12; + + use self::futures::executor::block_on; + + const SAMPLES: usize = 1 << 14; + + let rng = &mut rand::thread_rng(); + let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); + + let naive = naive_multiexp(g.clone(), v.clone()); + + let pool = Worker::new(); + + let fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); + + assert_eq!(naive, fast); + } + + + #[test] + fn test_valid_bn254_multiexp() { + use rand::{self, Rand}; + use crate::pairing::bn256::Bn256; + + const SAMPLES: usize = 1 << 14; + + let pool = Worker::new(); + + let rng = &mut rand::thread_rng(); + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + let dense = dense_multiexp( + &pool, + &g, + &v, + ).unwrap(); + + let v = Arc::new(v); + let g = Arc::new(g); + + let naive = naive_multiexp(g.clone(), v.clone()); + + assert_eq!(dense, naive); + + use self::futures::executor::block_on; + + let fast_dense = future_based_multiexp( + &pool, + g.clone(), + v.clone() + ).wait().unwrap(); + + assert_eq!(naive, fast_dense); + + let fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); + + assert_eq!(naive, fast); + } + + #[test] + #[ignore] + fn test_new_multexp_speed_with_bn256() { + + use rand::{self, Rand}; + use crate::pairing::bn256::Bn256; + use num_cpus; + + let cpus = num_cpus::get(); + const SAMPLES: usize = 1 << 22; + + let rng = &mut rand::thread_rng(); + let v = Arc::new((0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>()); + let g = Arc::new((0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>()); + + let pool = Worker::new(); + + use self::futures::executor::block_on; + + let start = std::time::Instant::now(); + + let _fast = block_on( + multiexp( + &pool, + (g, 0), + FullDensity, + v + ) + ).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("Elapsed {} ns for {} samples", duration_ns, SAMPLES); + let time_per_sample = duration_ns/(SAMPLES as f64); + println!("Tested on {} samples on {} CPUs with {} ns per multiplication", SAMPLES, cpus, time_per_sample); + } + + #[test] + fn test_dense_multiexp_vs_new_multiexp() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::pairing::bn256::Bn256; + use num_cpus; + + // const SAMPLES: usize = 1 << 22; + const SAMPLES: usize = 1 << 16; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + + println!("Done generating test points and scalars"); + + let pool = Worker::new(); + + let start = std::time::Instant::now(); + + let dense = dense_multiexp( + &pool, &g, &v.clone()).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("{} ns for dense for {} samples", duration_ns, SAMPLES); + + let start = std::time::Instant::now(); + + let _map_reduce = map_reduce_multiexp_over_fixed_window( + &pool, + &g, + &v, + 11 + ).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("{} ns for map reduce for {} samples", duration_ns, SAMPLES); + + // assert_eq!(dense, map_reduce); + + let start = std::time::Instant::now(); + + let buffered = buffered_multiexp_over_fixed_window_and_buffer_size( + &pool, + &g, + &v, + 11, + 64, + ).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("{} ns for buffered multiexp for {} samples", duration_ns, SAMPLES); + + assert_eq!(dense, buffered); + + use self::futures::executor::block_on; + + let start = std::time::Instant::now(); + + let sparse = block_on( + multiexp( + &pool, + (Arc::new(g), 0), + FullDensity, + Arc::new(v) + ) + ).unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("{} ns for sparse for {} samples", duration_ns, SAMPLES); + + assert_eq!(dense, sparse); + } + + + #[test] + fn test_bench_sparse_multiexp() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use num_cpus; + + type Eng = crate::pairing::bls12_381::Bls12; + + const SAMPLES: usize = 1 << 22; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + + println!("Done generating test points and scalars"); + + let pool = Worker::new(); + let start = std::time::Instant::now(); + + let _sparse = multiexp( + &pool, + (Arc::new(g), 0), + FullDensity, + Arc::new(v) + ).wait().unwrap(); + + let duration_ns = start.elapsed().as_nanos() as f64; + println!("{} ms for sparse for {} samples on {:?}", duration_ns/1000.0f64, SAMPLES, Eng{}); + } + + #[test] + fn test_bench_dense_consuming_multiexp() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + + // type Eng = crate::pairing::bn256::Bn256; + type Eng = crate::pairing::bls12_381::Bls12; + use num_cpus; + + const SAMPLES: usize = 1 << 22; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + + let pool = Worker::new(); + let start = std::time::Instant::now(); + + let _dense = dense_multiexp_consume( + &pool, + &g, + v + ).unwrap(); + + println!("{:?} for dense for {} samples", start.elapsed(), SAMPLES); + } + + fn calculate_parameters(size: usize, threads: usize, bits: u32) { + let mut chunk_len = size / threads; + if size / threads != 0 { + chunk_len += 1; + } + let raw_size = (f64::from(chunk_len as u32)).ln(); + let new_window_size = if raw_size.floor() + 0.5 < raw_size { + raw_size.ceil() as u32 + } else { + raw_size.floor() as u32 + }; + let window_size = (f64::from(chunk_len as u32)).ln().ceil() as u32; + + let mut num_windows = bits / window_size; + let leftover = bits % window_size; + if leftover != 0 { + num_windows += 1; + } + + let uncompensated_window = (f64::from(size as u32)).ln().ceil() as u32; + let mut num_uncompensated_windows = bits / uncompensated_window; + let uncompensated_leftover = bits % uncompensated_window; + if uncompensated_leftover != 0 { + num_uncompensated_windows += 1; + } + + println!("For size {} and {} cores: chunk len {}, {} windows, average window {} bits, leftover {} bits. Alternative window size = {}", size, threads, chunk_len, num_windows, window_size, leftover, new_window_size); + // println!("Raw window size = {}", raw_size); + // println!("Uncompensated: {} windows, arevage window {} bits, leftover {} bits", num_uncompensated_windows, uncompensated_window, uncompensated_leftover); + + // (f64::from(exponents.len() as u32)).ln().ceil() as u32 + } + + #[test] + fn test_sizes_for_bn254() { + let sizes = vec![1<<23, 1<<24]; + let cores = vec![8, 12, 16, 24, 32, 48]; + for size in sizes { + for &core in &cores { + calculate_parameters(size, core, 254); + } + } + } +} \ No newline at end of file diff --git a/src/plonk/adaptor/alternative.rs b/src/plonk/adaptor/alternative.rs new file mode 100644 index 000000000..934607c6e --- /dev/null +++ b/src/plonk/adaptor/alternative.rs @@ -0,0 +1,2022 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::SynthesisError; + +use crate::plonk::cs::gates::Gate; +use crate::plonk::cs::gates::Coeff; +use crate::plonk::cs::gates::Variable as PlonkVariable; +use crate::plonk::cs::gates::Index as PlonkIndex; + +use crate::plonk::cs::Circuit as PlonkCircuit; +use crate::plonk::cs::ConstraintSystem as PlonkConstraintSystem; + +use std::marker::PhantomData; + +use std::collections::{HashSet, HashMap}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MergeLcVariant { + AIsTheOnlyMeaningful, + BIsTheOnlyMeaningful, + MergeABWithConstantC, + MergeACThroughConstantB, + MergeBCThroughConstantA, + CIsTheOnlyMeaningful, +} + +// These are transpilation options over A * B - C = 0 constraint +#[derive(Clone, PartialEq, Eq)] +pub enum TranspilationVariant { + LeaveAsSingleVariable(E::Fr), + IntoQuandaticGate((E::Fr, E::Fr, E::Fr)), + IntoLinearGate((E::Fr, E::Fr)), + IntoSingleAdditionGate((E::Fr, E::Fr, E::Fr, E::Fr)), + IntoMultipleAdditionGates((E::Fr, E::Fr, E::Fr, E::Fr), Vec), + MergeLinearCombinations((MergeLcVariant, E::Fr, Box>)), + IsConstant(E::Fr), + TransformLc(Box<(TranspilationVariant, TranspilationVariant, TranspilationVariant)>) +} + +impl std::fmt::Debug for TranspilationVariant { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TranspilationVariant::LeaveAsSingleVariable(c) => { + writeln!(f, "Variant: leave LC as a single variable")?; + writeln!(f, "With coefficient {}", c)?; + }, + TranspilationVariant::IntoQuandaticGate(c) => { + writeln!(f, "Variant: into quadratic gate")?; + writeln!(f, "{} + {} * x + {} * x^2", c.0, c.1, c.2)?; + }, + TranspilationVariant::IntoLinearGate(c) => { + writeln!(f, "Variant: into linear gate")?; + writeln!(f, "{} + {} * x", c.0, c.1)?; + }, + TranspilationVariant::IntoSingleAdditionGate(c) => { + writeln!(f, "Variant: into single addition gate")?; + writeln!(f, "{}*a + {}*b + {}*c + {} = 0", c.0, c.1, c.2, c.3)?; + }, + TranspilationVariant::IntoMultipleAdditionGates(c, next) => { + writeln!(f, "Variant: into multiple addition gates")?; + writeln!(f, "{}*a + {}*b + {}*c + {} = 0", c.0, c.1, c.2, c.3)?; + writeln!(f, "{:?}", next)?; + }, + TranspilationVariant::MergeLinearCombinations(c) => { + writeln!(f, "Variant: merge linear combinations")?; + writeln!(f, "Merge with hint: {:?}", c.0)?; + }, + TranspilationVariant::IsConstant(c) => { + writeln!(f, "Variant: into constant factor {}", c)?; + }, + TranspilationVariant::TransformLc(b) => { + writeln!(f, "Variant: into combinatoric transform LC")?; + writeln!(f, "A: {:?}", b.as_ref().0)?; + writeln!(f, "B: {:?}", b.as_ref().1)?; + writeln!(f, "C: {:?}", b.as_ref().2)?; + }, + } + + Ok(()) + } +} + +pub struct Transpiler { + current_constraint_index: usize, + current_plonk_input_idx: usize, + current_plonk_aux_idx: usize, + scratch: HashSet, + // deduplication_scratch: HashMap, + deduplication_scratch: HashMap, + hints: Vec<(usize, TranspilationVariant)>, +} + +impl Transpiler { + pub fn new() -> Self { + Self { + current_constraint_index: 0, + current_plonk_input_idx: 1, + current_plonk_aux_idx: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + hints: vec![], + } + } + + pub fn into_hints(self) -> Vec<(usize, TranspilationVariant)> { + self.hints + } + + fn increment_lc_number(&mut self) -> usize { + let current_lc_number = self.current_constraint_index; + self.current_constraint_index += 1; + + current_lc_number + } + + fn enforce_lc_as_gates( + &mut self, + lc: LinearCombination, + multiplier: E::Fr, + free_term_constant: E::Fr + ) -> TranspilationVariant { + // let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let (lc, mut constant_coeff) = split_constant_term::(lc); + + let (contains_constant, num_linear_terms) = num_unique_values::(&lc, &mut self.scratch); + assert!(!contains_constant, "must have split constant term before"); + assert!(num_linear_terms > 0); + // if num_linear_terms == 1 && free_term_constant == zero_fr && constant_coeff == zero_fr { + // let (_existing_var, mut coeff) = lc.as_ref()[0]; + // coeff.mul_assign(&multiplier); + + // let hint = TranspilationVariant::::LeaveAsSingleVariable(coeff); + + // return hint + // } + // else if num_linear_terms == 1 && (contains_constant || free_term_constant != zero_fr) { + // let (_, mut constant_coeff) = get_constant_term::(&lc); + // let (_, single_var, mut linear_coeff) = get_first_variable_with_coeff::(&lc); + // linear_coeff.mul_assign(&multiplier); + + // constant_coeff.mul_assign(&multiplier); + // constant_coeff.sub_assign(&free_term_constant); + + // let hint = TranspilationVariant::::IntoSingleAdditionGate((linear_coeff, zero_fr, zero_fr, constant_coeff)); + + // return hint; + // } + // else + if num_linear_terms <= 3 { + let (mut a_coef, mut b_coef, mut c_coef) = rewrite_lc_into_single_enforcement_gate(&lc, self, &mut (self.scratch.clone())); + // we've made a sinlge addition gate, but we may need to scale it (my multipler) + // and also account for a RHS in a form of = constant_coeff + + if multiplier == E::Fr::zero() { + assert!(free_term_constant == E::Fr::zero()); + unreachable!(); + // it's a constraint 0 * LC = 0 + } else { + //scale + if multiplier != one_fr { + a_coef.mul_assign(&multiplier); + b_coef.mul_assign(&multiplier); + c_coef.mul_assign(&multiplier); + constant_coeff.mul_assign(&multiplier); + } + + constant_coeff.sub_assign(&free_term_constant); + } + + let hint = TranspilationVariant::::IntoSingleAdditionGate((a_coef, b_coef, c_coef, constant_coeff)); + + return hint; + } else { + let (first_gate, mut other_coefs) = rewrite_lc_into_multiple_enforcement_gates(&lc, self, &mut (self.scratch.clone())); + let (mut a_coef, mut b_coef, mut c_coef) = first_gate; + if multiplier == E::Fr::zero() { + assert!(free_term_constant == E::Fr::zero()); + // it's a constraint 0 * LC = 0 + } else { + //scale + if multiplier != one_fr { + a_coef.mul_assign(&multiplier); + b_coef.mul_assign(&multiplier); + c_coef.mul_assign(&multiplier); + constant_coeff.mul_assign(&multiplier); + + for c in other_coefs.iter_mut() { + c.mul_assign(&multiplier); + } + } + + constant_coeff.sub_assign(&free_term_constant); + } + + let hint = TranspilationVariant::::IntoMultipleAdditionGates((a_coef, b_coef, c_coef, constant_coeff), other_coefs); + + return hint; + } + } + + fn rewrite_lc(&mut self, lc: &LinearCombination, multiplier: E::Fr, free_term_constant: E::Fr) -> (Variable, TranspilationVariant) { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let (contains_constant, num_linear_terms) = num_unique_values::(&lc, &mut self.scratch); + assert!(num_linear_terms > 0); + if num_linear_terms == 1 && !contains_constant && free_term_constant == zero_fr { + let (existing_var, mut coeff) = lc.as_ref()[0]; + coeff.mul_assign(&multiplier); + + let hint = TranspilationVariant::::LeaveAsSingleVariable(coeff); + + return (existing_var, hint); + } else if num_linear_terms <= 2 { + let (new_var, (mut a_coef, mut b_coef, mut c_coef, mut constant_coeff)) = rewrite_lc_into_single_addition_gate(&lc, self, &mut (self.scratch.clone())); + // we've made a sinlge addition gate, but we may need to scale it (my multipler) + // and also account for a RHS in a form of = constant_coeff + + if multiplier == E::Fr::zero() { + assert!(free_term_constant == E::Fr::zero()); + unreachable!(); + // it's a constraint 0 * LC = 0 + } else { + //scale + if multiplier != one_fr { + a_coef.mul_assign(&multiplier); + b_coef.mul_assign(&multiplier); + c_coef.mul_assign(&multiplier); + constant_coeff.mul_assign(&multiplier); + } + + constant_coeff.sub_assign(&free_term_constant); + } + + let hint = TranspilationVariant::::IntoSingleAdditionGate((a_coef, b_coef, c_coef, constant_coeff)); + + return (new_var, hint); + } else { + let (new_var, first_gate, mut other_coefs) = rewrite_lc_into_multiple_addition_gates(&lc, self, &mut (self.scratch.clone())); + let (mut a_coef, mut b_coef, mut c_coef, mut constant_coeff) = first_gate; + if multiplier == E::Fr::zero() { + assert!(free_term_constant == E::Fr::zero()); + // it's a constraint 0 * LC = 0 + } else { + //scale + if multiplier != one_fr { + a_coef.mul_assign(&multiplier); + b_coef.mul_assign(&multiplier); + c_coef.mul_assign(&multiplier); + constant_coeff.mul_assign(&multiplier); + + for c in other_coefs.iter_mut() { + c.mul_assign(&multiplier); + } + } + + constant_coeff.sub_assign(&free_term_constant); + } + + let hint = TranspilationVariant::::IntoMultipleAdditionGates((a_coef, b_coef, c_coef, constant_coeff), other_coefs); + + return (new_var, hint); + } + } +} + +impl crate::ConstraintSystem for Transpiler +{ + type Root = Self; + + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, _f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + self.current_plonk_aux_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Aux(self.current_plonk_aux_idx))) + } + + fn alloc_input( + &mut self, + _: A, + _f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + // we do +1 to not encounter Input(0) + self.current_plonk_input_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Input(self.current_plonk_input_idx))) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + // let ann: String = _ann().into(); + // println!("Enforce {}", ann); + + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let mut negative_one_fr = E::Fr::one(); + negative_one_fr.negate(); + + // we need to determine the type of transformation constraint + + // let's handle trivial cases first + + // A or B or C are just constant terms + + let a = deduplicate_stable::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let b = deduplicate_stable::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let c = deduplicate_stable::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + + let (a_is_constant, a_constant_coeff) = is_constant::(&a); + let (b_is_constant, b_constant_coeff) = is_constant::(&b); + let (c_is_constant, c_constant_coeff) = is_constant::(&c); + + match (a_is_constant, b_is_constant, c_is_constant) { + (true, true, true) => { + unreachable!("R1CS has a gate 1 * 1 = 1"); + }, + (true, false, true) | (false, true, true) => { + // we have something like c0 * LC = c1 + let lc = if !a_is_constant { + a + } else if !b_is_constant { + b + } else { + unreachable!("Either A or B LCs are constant"); + }; + + let multiplier = if a_is_constant { + a_constant_coeff + } else if b_is_constant { + b_constant_coeff + } else { + unreachable!("Must take multiplier from A or B"); + }; + + let hint_lc = self.enforce_lc_as_gates(lc, multiplier, c_constant_coeff); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::MergeLinearCombinations((MergeLcVariant::MergeACThroughConstantB, one_fr, Box::new(hint_lc))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (false, false, true) => { + // potential quadatic gate + let (is_quadratic_gate, coeffs) = is_quadratic_gate::(&a, &b, &c, &mut self.scratch); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::IntoQuandaticGate(coeffs); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let (_new_a_var, hint_a) = self.rewrite_lc(&a, one_fr, zero_fr); + let (_new_b_var, hint_b) = self.rewrite_lc(&b, one_fr, zero_fr); + + let current_lc_number = self.increment_lc_number(); + + let hint_c = TranspilationVariant::::IsConstant(c_constant_coeff); + + let hint = TranspilationVariant::::TransformLc(Box::new((hint_a, hint_b, hint_c))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (true, false, false) | (false, true, false) => { + // LC * 1 = LC + + let multiplier = if a_is_constant { + a_constant_coeff + } else if b_is_constant { + b_constant_coeff + } else { + unreachable!() + }; + + let lc_variant = if a_is_constant { + MergeLcVariant::MergeBCThroughConstantA + } else { + MergeLcVariant::MergeACThroughConstantB + }; + + if multiplier == zero_fr { + // LC_AB * 0 = LC_C => LC_C == 0 + + let hint_lc = self.enforce_lc_as_gates(c, one_fr, zero_fr); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::MergeLinearCombinations((MergeLcVariant::CIsTheOnlyMeaningful, one_fr, Box::new(hint_lc))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let mut final_lc = if !a_is_constant { + a + } else if !b_is_constant { + b + } else { + unreachable!() + }; + + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + + // let final_lc = final_lc - &c; + let final_lc = subtract_lcs_with_dedup_stable::(final_lc, c, &mut self.deduplication_scratch); + + // we rewrite final LC taking into account the constant inside and no external constant + let hint_lc = self.enforce_lc_as_gates(final_lc, one_fr, zero_fr); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::MergeLinearCombinations((lc_variant, one_fr, Box::new(hint_lc))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + + }, + (true, true, false) => { + // A and B are some constants + let mut final_constant = a_constant_coeff; + final_constant.mul_assign(&b_constant_coeff); + + let hint_lc = self.enforce_lc_as_gates(c, one_fr, final_constant); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::MergeLinearCombinations((MergeLcVariant::CIsTheOnlyMeaningful, one_fr, Box::new(hint_lc))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (false, false, false) => { + // potentially it can still be quadratic + let (is_quadratic_gate, coeffs) = is_quadratic_gate::(&a, &b, &c, &mut self.scratch); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::IntoQuandaticGate(coeffs); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + // rewrite into addition gates and multiplication gates + + let (_new_a_var, hint_a) = self.rewrite_lc(&a, one_fr, zero_fr); + let (_new_b_var, hint_b) = self.rewrite_lc(&b, one_fr, zero_fr); + let (_new_c_var, hint_c) = self.rewrite_lc(&c, one_fr, zero_fr); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::::TransformLc(Box::new((hint_a, hint_b, hint_c))); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + } + } + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +// List of heuristics + +use crate::{LinearCombination, ConstraintSystem, Variable}; + +fn is_quadratic_gate>( + a: &LinearCombination, + b: &LinearCombination, + c: &LinearCombination, + scratch: &mut HashSet:: +) -> (bool, (E::Fr, E::Fr, E::Fr)) { + let zero = E::Fr::zero(); + + let (_a_containts_constant, a_constant_coeff) = get_constant_term::(&a); + let (_b_containts_constant, b_constant_coeff) = get_constant_term::(&b); + let (_c_containts_constant, c_constant_coeff) = get_constant_term::(&c); + + let (a_is_linear, a_linear_var, a_linear_var_coeff) = is_linear_term::(&a, scratch); + let (b_is_linear, b_linear_var, b_linear_var_coeff) = is_linear_term::(&b, scratch); + let (c_is_linear, c_linear_var, c_linear_var_coeff) = is_linear_term::(&c, scratch); + + let (c_is_constant, _) = is_constant::(&c); + + let is_quadratic; + if c_is_constant { + is_quadratic = a_is_linear && b_is_linear && a_linear_var == b_linear_var; + } else { + if a_is_linear && b_is_linear && c_is_linear && a_linear_var == b_linear_var && b_linear_var == c_linear_var { + is_quadratic = true; + } else { + return (false, (zero, zero, zero)); + } + } + + if is_quadratic { + // something like (v - 1) * (v - 1) = (v - 1) + // and we can make a quadratic gate + + let mut quadratic_term = a_linear_var_coeff; + quadratic_term.mul_assign(&b_linear_var_coeff); + + let mut linear_term_0 = a_constant_coeff; + linear_term_0.mul_assign(&b_linear_var_coeff); + + let mut linear_term_1 = b_constant_coeff; + linear_term_1.mul_assign(&a_linear_var_coeff); + + let mut linear_term = linear_term_0; + linear_term.add_assign(&linear_term_1); + if c_is_linear { + linear_term.sub_assign(&c_linear_var_coeff); + } + + let mut constant_term = a_constant_coeff; + constant_term.mul_assign(&b_constant_coeff); + + if c_constant_coeff != zero { + constant_term.sub_assign(&c_constant_coeff); + } + + return (true, (constant_term, linear_term, quadratic_term)); + } + + (false, (zero, zero, zero)) +} + +fn is_constant>(lc: &LinearCombination) -> (bool, E::Fr) { + // formally it's an empty LC, so it's a constant 0 + if lc.as_ref().len() == 0 { + return (true, E::Fr::zero()); + } + + let result = get_constant_term::(&lc); + + if result.0 && lc.as_ref().len() == 1 { + return result; + } + + (false, E::Fr::zero()) +} + +fn get_constant_term>(lc: &LinearCombination) -> (bool, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var == &cs_one { + return (true, *coeff); + } + } + + (false, E::Fr::zero()) +} + +fn get_first_variable>(lc: &LinearCombination) -> (bool, Variable) { + let cs_one = CS::one(); + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var); + } + } + + (false, cs_one) +} + +fn get_first_variable_with_coeff>(lc: &LinearCombination) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var, *coeff); + } + } + + (false, cs_one, E::Fr::zero()) +} + +fn num_unique_values>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, usize) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut contains_constant = false; + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + } else { + contains_constant = true; + } + } + + let num_unique_without_constant = scratch.len(); + + scratch.clear(); + + (contains_constant, num_unique_without_constant) +} + +fn is_linear_term>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut linear_coeff = E::Fr::zero(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + linear_coeff = *coeff; + } + } + + let num_unique_without_constant = scratch.len(); + + if num_unique_without_constant == 1 { + let terms: Vec<_> = scratch.drain().collect(); + let term = terms[0]; + + return (true, term, linear_coeff) + } else { + scratch.clear(); + + return (false, cs_one, E::Fr::zero()) + } +} + +fn rewrite_lc_into_single_enforcement_gate>( + lc: &LinearCombination, + _cs: &mut CS, + scratch: &mut HashSet +) -> (E::Fr, E::Fr, E::Fr) { + let (_contains_constant, num_linear_terms) = num_unique_values::(&lc, scratch); + assert!(num_linear_terms > 0 && num_linear_terms <= 3); + assert!(!_contains_constant); + + // this linear combination has only 2 non-constant terms that + + // we can just make an addition gate + let cs_one = CS::one(); + + let mut found_a = false; + let mut found_b = false; + let mut a_coeff = E::Fr::zero(); + let mut b_coeff = E::Fr::zero(); + let mut c_coeff = E::Fr::zero(); + + let it = lc.as_ref().iter(); + + for (var, coeff) in it { + if var == &cs_one { + panic!("must not encounter constant terms here!"); + } else { + if !found_a { + found_a = true; + a_coeff = *coeff; + } else if !found_b { + found_b = true; + b_coeff = *coeff; + } else { + c_coeff = *coeff; + } + } + } + + (a_coeff, b_coeff, c_coeff) +} + +fn rewrite_lc_into_multiple_enforcement_gates>( + lc: &LinearCombination, + cs: &mut CS, + scratch: &mut HashSet +) -> ((E::Fr, E::Fr, E::Fr), Vec) // first rewrite is full, than it's Z + a * X - Y = 0 +{ + // assert!(lc.as_ref().len() > 3); + + // let (_contains_constant, num_linear_terms) = num_unique_values::(&lc, scratch); + // assert!(num_linear_terms > 3); + // // we can just make an addition gate + // let cs_one = CS::one(); + + // let (_, constant_term) = get_constant_term::(&lc); + + // let mut found_a = false; + // let mut found_b = false; + // let mut a_coeff = E::Fr::zero(); + // let mut b_coeff = E::Fr::zero(); + // let mut c_coeff = E::Fr::zero(); + + // let mut it = lc.as_ref().iter(); + + // for (var, coeff) in &mut it { + // if var == &cs_one { + // continue; + // } else { + // if !found_a { + // found_a = true; + // a_coeff = *coeff; + // } else if !found_b { + // found_b = true; + // b_coeff = *coeff; + // } else { + // c_coeff = *coeff; + // } + // } + // } + + // // we've consumed 3 values + + // let first_addition_gate = (a_coeff, b_coeff, c_coeff, constant_term); + + // let mut extra_coefficients = Vec::with_capacity(num_linear_terms - 3); + // for (var, coeff) in it { + // if var != &cs_one { + // extra_coefficients.push(*coeff); + // } + // } + + // (first_addition_gate, extra_coefficients) + + assert!(lc.as_ref().len() > 3); + + let (_contains_constant, num_linear_terms) = num_unique_values::(&lc, scratch); + assert!(num_linear_terms > 3); + // we can just make an addition gate + let cs_one = CS::one(); + + let mut found_a = false; + + let mut a_coeff = E::Fr::zero(); + let mut b_coeff = E::Fr::zero(); + + let mut it = lc.as_ref().iter(); + + for (var, coeff) in &mut it { + if var != &cs_one { + if !found_a { + found_a = true; + a_coeff = *coeff; + } else { + b_coeff = *coeff; + break; + } + } else { + panic!("Must not encounter constant here"); + } + } + + // we've consumed 2 values + + let mut c_coeff = E::Fr::one(); + c_coeff.negate(); + + let _new_var = cs.alloc(|| "allocate addition gate", + || { + unreachable!() + } + ).expect("must allocate an extra variable"); + + let first_addition_gate = (a_coeff, b_coeff, c_coeff); + + // let mut extra_coefficients = Vec::with_capacity(lc.as_ref().len() - 2); + // for (var, coeff) in it { + // if var != &cs_one { + // extra_coefficients.push(*coeff); + // new_var = cs.alloc(|| "allocate addition gate", + // || { + // unreachable!() + // } + // ).expect("must allocate an extra variable"); + // } + // } + + // (first_addition_gate, extra_coefficients) + + // next gates are 1*old_new_var + b*original_var - new_new_var = 0 + + let mut extra_coefficients = Vec::with_capacity(lc.as_ref().len() - 2); + + let cycle_len = it.len(); + + assert!(cycle_len > 1); // otherwise we could have made one gate + + let mut gates_created = 0; + + loop { + let (var, coeff) = it.next().expect("there should be a chain variable"); + if var != &cs_one { + if gates_created != cycle_len - 2 { + extra_coefficients.push(*coeff); + let _new_var = cs.alloc(|| "allocate addition gate", + || { + unreachable!() + } + ).expect("must allocate an extra variable"); + gates_created += 1; + } else { + let (_last_var, last_coeff) = it.next().expect("there should be a last chain variable"); + extra_coefficients.push(*coeff); + extra_coefficients.push(*last_coeff); + break; + } + } else { + panic!("Cycle mismatch: constant term must have been split before"); + } + } + + (first_addition_gate, extra_coefficients) +} + +fn rewrite_lc_into_single_addition_gate>( + lc: &LinearCombination, + cs: &mut CS, + scratch: &mut HashSet +) -> (Variable, (E::Fr, E::Fr, E::Fr, E::Fr)) { + let (_contains_constant, num_linear_terms) = num_unique_values::(&lc, scratch); + assert!(num_linear_terms > 0 && num_linear_terms <= 3); + + // this linear combination has only 2 non-constant terms that + + // we can just make an addition gate + let cs_one = CS::one(); + + let mut constant_term = E::Fr::zero(); + + let mut found_a = false; + let mut a_coeff = E::Fr::zero(); + let mut b_coeff = E::Fr::zero(); + + let it = lc.as_ref().iter(); + + for (var, coeff) in it { + if var == &cs_one { + constant_term = *coeff; + } else { + if !found_a { + found_a = true; + a_coeff = *coeff; + } else { + b_coeff = *coeff; + } + } + } + + let mut c_coeff = E::Fr::one(); + c_coeff.negate(); + + let new_var = cs.alloc(|| "allocate addition gate", + || { + unreachable!() + }).expect("must allocate an extra variable"); + + (new_var, (a_coeff, b_coeff, c_coeff, constant_term)) +} + +fn rewrite_lc_into_multiple_addition_gates>( + lc: &LinearCombination, + cs: &mut CS, + scratch: &mut HashSet +) -> (Variable, (E::Fr, E::Fr, E::Fr, E::Fr), Vec) // first rewrite is full, than it's Z + a * X - Y = 0 +{ + assert!(lc.as_ref().len() > 2); + + let (_contains_constant, num_linear_terms) = num_unique_values::(&lc, scratch); + assert!(num_linear_terms > 2); + // we can just make an addition gate + let cs_one = CS::one(); + + let (_, constant_term) = get_constant_term::(&lc); + + let mut found_a = false; + + let mut a_coeff = E::Fr::zero(); + let mut b_coeff = E::Fr::zero(); + + let mut it = lc.as_ref().iter(); + + for (var, coeff) in &mut it { + if var != &cs_one { + if !found_a { + found_a = true; + a_coeff = *coeff; + } else { + b_coeff = *coeff; + break; + } + } + } + + // we've consumed 2 values + + let mut c_coeff = E::Fr::one(); + c_coeff.negate(); + + let mut new_var = cs.alloc(|| "allocate addition gate", + || { + unreachable!() + } + ).expect("must allocate an extra variable"); + + let first_addition_gate = (a_coeff, b_coeff, c_coeff, constant_term); + + let mut extra_coefficients = Vec::with_capacity(lc.as_ref().len() - 2); + for (var, coeff) in it { + if var != &cs_one { + extra_coefficients.push(*coeff); + new_var = cs.alloc(|| "allocate addition gate", + || { + unreachable!() + } + ).expect("must allocate an extra variable"); + } + } + + (new_var, first_addition_gate, extra_coefficients) +} + +fn deduplicate>( + lc: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + for (var, coeff) in lc.0.into_iter() { + if let Some(existing_coeff) = scratch.get_mut(&var) { + existing_coeff.add_assign(&coeff); + } else { + scratch.insert(var, coeff); + } + } + + let as_vec: Vec<(Variable, E::Fr)> = scratch.drain().collect(); + + LinearCombination(as_vec) +} + +fn deduplicate_stable>( + lc: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return lc; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc.as_ref().len()); + + for (var, coeff) in lc.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn subtract_lcs_with_dedup_stable>( + lc_0: LinearCombination, + lc_1: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc_0.as_ref().len() == 0 && lc_1.as_ref().len() == 0{ + return lc_0; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc_0.as_ref().len() + lc_1.as_ref().len()); + + for (var, coeff) in lc_0.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + for (var, coeff) in lc_1.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.sub_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + let mut coeff_negated = coeff; + coeff_negated.negate(); + deduped_vec.push((var, coeff_negated)); + scratch.insert(var, new_idx); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn split_constant_term>( + mut lc: LinearCombination, +) -> (LinearCombination, E::Fr) { + if lc.as_ref().len() == 0 { + return (lc, E::Fr::zero()); + } + + let mut idx = None; + let cs_one = CS::one(); + let mut constant_coeff = E::Fr::zero(); + + for (i, (var, coeff)) in lc.0.iter().enumerate() { + if var == &cs_one { + idx = Some(i); + constant_coeff = *coeff; + break; + } + } + + if let Some(idx) = idx { + let _ = lc.0.swap_remove(idx); + return (lc, constant_coeff); + } else { + return (lc, constant_coeff); + } +} + + +pub struct Adaptor<'a, E: Engine, CS: PlonkConstraintSystem + 'a> { + cs: &'a mut CS, + hints: &'a Vec<(usize, TranspilationVariant)>, + current_constraint_index: usize, + current_hint_index: usize, + scratch: HashSet, + // deduplication_scratch: HashMap, + deduplication_scratch: HashMap, +} + +impl<'a, E: Engine, CS: PlonkConstraintSystem + 'a> Adaptor<'a, E, CS> { + // fn get_next_hint(&mut self) -> &(usize, TranspilationVariant) { + // let current_hint_index = self.current_hint_index; + // let expected_constraint_index = self.current_constraint_index; + + // let next_hint = &self.hints[current_hint_index]; + + // assert!(next_hint.0 == expected_constraint_index); + + // self.current_hint_index += 1; + // self.current_constraint_index += 1; + + // next_hint + // } + + fn get_next_hint(&mut self) -> (usize, TranspilationVariant) { + let current_hint_index = self.current_hint_index; + let expected_constraint_index = self.current_constraint_index; + + let next_hint = self.hints[current_hint_index].clone(); + + assert!(next_hint.0 == expected_constraint_index); + + self.current_hint_index += 1; + self.current_constraint_index += 1; + + next_hint + } + + // make a new variable based on existing ones + fn make_single_addition_gate(&mut self, lc: &LinearCombination, gate_coeffs: (E::Fr, E::Fr, E::Fr, E::Fr)) -> Result { + let zero_fr = E::Fr::zero(); + + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (a_coeff, b_coeff, c_coeff, constant_coeff) = gate_coeffs; + + assert!(c_coeff == minus_one_fr); + + // we can just make an addition gate + let cs_one = Self::one(); + + let it = lc.as_ref().iter(); + + if b_coeff.is_zero() { + let mut a_var = PlonkVariable::new_unchecked(PlonkIndex::Aux(0)); + for (var, _) in it { + if var == &cs_one { + continue + } else { + a_var = convert_variable(*var); + break; + } + } + + let a_value = self.cs.get_value(a_var); + + let new_var = self.cs.alloc( + || { + let mut c_value = a_value?; + c_value.mul_assign(&a_coeff); + c_value.add_assign(&constant_coeff); + // c_value.negate(); + + Ok(c_value) + // c = constant + a*a_coeff + })?; + + self.cs.new_gate((a_var, self.cs.get_dummy_variable(), new_var), (a_coeff, b_coeff, c_coeff, zero_fr, constant_coeff))?; + + Ok(new_var) + } else { + let mut a_var = self.cs.get_dummy_variable(); + let mut b_var = self.cs.get_dummy_variable(); + let mut found_a = false; + + for (var, _) in it { + if var == &cs_one { + continue + } else { + if !found_a { + found_a = true; + a_var = convert_variable(*var); + } else { + b_var = convert_variable(*var); + break; + } + } + } + + let a_value = self.cs.get_value(a_var); + let b_value = self.cs.get_value(b_var); + + let new_var = self.cs.alloc( + || { + let a_value = a_value?; + let mut b_value = b_value?; + b_value.mul_assign(&b_coeff); + let mut c_value = a_value; + c_value.mul_assign(&a_coeff); + c_value.add_assign(&b_value); + c_value.add_assign(&constant_coeff); + // c_value.negate(); + + Ok(c_value) + // c = - constant - a*a_coeff - b*b_coeff + })?; + + self.cs.new_gate((a_var, b_var, new_var), (a_coeff, b_coeff, c_coeff, zero_fr, constant_coeff))?; + + Ok(new_var) + } + } + + // make a new variable based on existing ones + fn enforce_lc_with_single_addition_gate( + &mut self, + lc: LinearCombination, + gate_coeffs: (E::Fr, E::Fr, E::Fr, E::Fr) + ) -> Result<(), SynthesisError> { + let zero_fr = E::Fr::zero(); + + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (lc, _const) = split_constant_term::(lc); + + let (a_coeff, b_coeff, c_coeff, constant_coeff) = gate_coeffs; + + // assert!(_const == constant_coeff); + + // we can just make an addition gate + let cs_one = Self::one(); + + let it = lc.as_ref().iter(); + + let mut found_a = false; + let mut found_b = false; + let need_b = !b_coeff.is_zero(); + let need_c = !c_coeff.is_zero(); + + let mut a_var = self.cs.get_dummy_variable(); + let mut b_var = self.cs.get_dummy_variable(); + let mut c_var = self.cs.get_dummy_variable(); + + for (var, _) in it { + if var != &cs_one { + if !found_a { + found_a = true; + a_var = convert_variable(*var); + } else if need_b && !found_b{ + found_b = true; + b_var = convert_variable(*var); + } else if need_c { + c_var = convert_variable(*var); + } else { + break; + } + } else { + panic!("must not encounter constant term when enforcing a linear combination"); + } + } + + self.cs.new_gate((a_var, b_var, c_var), (a_coeff, b_coeff, c_coeff, zero_fr, constant_coeff))?; + + Ok(()) + } + + // make a new variable based on existing ones + fn make_chain_of_addition_gates( + &mut self, + lc: &LinearCombination, + first_gate_coeffs: (E::Fr, E::Fr, E::Fr, E::Fr), + chain_coeffs: Vec + ) -> Result { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (a_coeff, b_coeff, c_coeff, constant_coeff) = first_gate_coeffs; + + assert!(c_coeff == minus_one_fr); + if b_coeff.is_zero() { + return Err(SynthesisError::Unsatisfiable); + } + // assert!(!b_coeff.is_zero()); + + // we can just make an addition gate + let cs_one = Self::one(); + + let mut it = lc.as_ref().iter(); + + let mut new_var = if b_coeff.is_zero() { + unreachable!() + } else { + let mut a_var = self.cs.get_dummy_variable(); + let mut b_var = self.cs.get_dummy_variable(); + let mut found_a = false; + + for (var, _) in &mut it { + if var == &cs_one { + continue + } else { + if !found_a { + found_a = true; + a_var = convert_variable(*var); + } else { + b_var = convert_variable(*var); + break; + } + } + } + + let a_value = self.cs.get_value(a_var); + let b_value = self.cs.get_value(b_var); + + let new_var = self.cs.alloc( + || { + let a_value = a_value?; + let mut b_value = b_value?; + b_value.mul_assign(&b_coeff); + let mut c_value = a_value; + c_value.mul_assign(&a_coeff); + c_value.add_assign(&b_value); + c_value.add_assign(&constant_coeff); + // c_value.negate(); + + Ok(c_value) + // c = - constant - a*a_coeff - b*b_coeff + })?; + + self.cs.new_gate((a_var, b_var, new_var), (a_coeff, b_coeff, c_coeff, zero_fr, constant_coeff))?; + + new_var + }; + + // next gates are 1*old_new_var + b*original_var - new_new_var = 0 + + let mut chain_iter = chain_coeffs.into_iter(); + + for (var, _)in &mut it { + if var != &cs_one { + let hint_coeff = chain_iter.next().expect("chain coefficient must exist"); + let original_var = convert_variable(*var); + let original_var_value = self.cs.get_value(original_var); + let new_var_value = self.cs.get_value(new_var); + + let old_new_var = new_var; + + new_var = self.cs.alloc( + || { + let mut new = original_var_value?; + new.mul_assign(&hint_coeff); + new.add_assign(&new_var_value?); + + Ok(new) + })?; + + self.cs.new_gate((old_new_var, original_var, new_var), (one_fr, hint_coeff, minus_one_fr, zero_fr, zero_fr))?; + } + } + + assert!(chain_iter.next().is_none()); + + Ok(new_var) + } + + // make a new variable based on existing ones + fn enforce_lc_using_chain_of_addition_gates( + &mut self, + lc: LinearCombination, + first_gate_coeffs: (E::Fr, E::Fr, E::Fr, E::Fr), + chain_coeffs: Vec + ) -> Result<(), SynthesisError> { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (lc, _const) = split_constant_term::(lc); + + let (a_coeff, b_coeff, c_coeff, constant_coeff) = first_gate_coeffs; + + // assert!(_const == constant_coeff); + + assert!(c_coeff == minus_one_fr); + if b_coeff.is_zero() { + return Err(SynthesisError::Unsatisfiable); + } + + // we can just make an addition gate + let cs_one = Self::one(); + + let mut it = lc.as_ref().iter(); + + let mut new_var = if b_coeff.is_zero() { + unreachable!() + } else { + let mut a_var = self.cs.get_dummy_variable(); + let mut b_var = self.cs.get_dummy_variable(); + let mut found_a = false; + + for (var, _) in &mut it { + if var == &cs_one { + continue + } else { + if !found_a { + found_a = true; + a_var = convert_variable(*var); + } else { + b_var = convert_variable(*var); + break; + } + } + } + + let a_value = self.cs.get_value(a_var); + let b_value = self.cs.get_value(b_var); + + let new_var = self.cs.alloc( + || { + let a_value = a_value?; + let mut b_value = b_value?; + b_value.mul_assign(&b_coeff); + let mut c_value = a_value; + c_value.mul_assign(&a_coeff); + c_value.add_assign(&b_value); + c_value.add_assign(&constant_coeff); + // c_value.negate(); + + Ok(c_value) + // c = - constant - a*a_coeff - b*b_coeff + })?; + + self.cs.new_gate((a_var, b_var, new_var), (a_coeff, b_coeff, c_coeff, zero_fr, constant_coeff))?; + + new_var + }; + + // next gates are 1*old_new_var + b*original_var - new_new_var = 0 + + let cycle_len = chain_coeffs.len(); + let mut chain_iter = chain_coeffs.into_iter(); + + assert!(cycle_len > 1); + + let mut gates_created = 0; + + loop { + let (var, _) = it.next().expect("there should be a chain variable"); + if var != &cs_one { + if gates_created != cycle_len - 2 { + let hint_coeff = chain_iter.next().expect("there should be a chain coeff"); + let original_var = convert_variable(*var); + let original_var_value = self.cs.get_value(original_var); + let new_var_value = self.cs.get_value(new_var); + + let old_new_var = new_var; + + new_var = self.cs.alloc( + || { + let mut new = original_var_value?; + new.mul_assign(&hint_coeff); + new.add_assign(&new_var_value?); + + Ok(new) + })?; + + self.cs.new_gate((old_new_var, original_var, new_var), (one_fr, hint_coeff, minus_one_fr, zero_fr, zero_fr))?; + gates_created += 1; + } else { + let (last_var, _) = it.next().expect("there should be a last chain variable"); + let hint_coeff = chain_iter.next().expect("there should be a chain coeff"); + let hint_coeff_last = chain_iter.next().expect("there should be a last chain coeff"); + let original_var = convert_variable(*var); + let original_last_var = convert_variable(*last_var); + + self.cs.new_gate((new_var, original_var, original_last_var), (one_fr, hint_coeff, hint_coeff_last, zero_fr, zero_fr))?; + break; + } + } else { + panic!("Cycle mismatch, enforcing LC using sequence of gates requires LC without the constant term"); + } + } + + assert!(chain_iter.next().is_none()); + + Ok(()) + } + + // fn rewrite_lc(&mut self, lc: &LinearCombination, multiplier: E::Fr, free_term_constant: E::Fr) -> (Variable, TranspilationVariant) { + // let one_fr = E::Fr::one(); + + // let (contains_constant, num_linear_terms) = num_unique_values::(&lc, &mut self.scratch); + // assert!(num_linear_terms > 0); + // if num_linear_terms == 1 && !contains_constant { + // let (existing_var, coeff) = lc.as_ref()[0]; + + // let hint = TranspilationVariant::::LeaveAsSingleVariable(coeff); + + // return (existing_var, hint); + // } else if num_linear_terms <= 2 { + // let (new_var, (mut a_coef, mut b_coef, mut c_coef, mut constant_coeff)) = rewrite_lc_into_single_addition_gate(&lc, self, &mut (self.scratch.clone())); + + // if multiplier == E::Fr::zero() { + // assert!(free_term_constant == E::Fr::zero()); + // // it's a constraint 0 * LC = 0 + // } else { + // //scale + // if multiplier != one_fr { + // a_coef.mul_assign(&multiplier); + // b_coef.mul_assign(&multiplier); + // c_coef.mul_assign(&multiplier); + // constant_coeff.mul_assign(&multiplier); + // } + + // constant_coeff.sub_assign(&free_term_constant); + // } + + // let hint = TranspilationVariant::::IntoSingleAdditionGate((a_coef, b_coef, c_coef, constant_coeff)); + + // return (new_var, hint); + // } else { + // let (new_var, first_gate, mut other_coefs) = rewrite_lc_into_multiple_addition_gates(&lc, self, &mut (self.scratch.clone())); + // let (mut a_coef, mut b_coef, mut c_coef, mut constant_coeff) = first_gate; + // if multiplier == E::Fr::zero() { + // assert!(free_term_constant == E::Fr::zero()); + // // it's a constraint 0 * LC = 0 + // } else { + // //scale + // if multiplier != one_fr { + // a_coef.mul_assign(&multiplier); + // b_coef.mul_assign(&multiplier); + // c_coef.mul_assign(&multiplier); + // constant_coeff.mul_assign(&multiplier); + + // for c in other_coefs.iter_mut() { + // c.mul_assign(&multiplier); + // } + // } + + // constant_coeff.sub_assign(&free_term_constant); + // } + + // let hint = TranspilationVariant::::IntoMultipleAdditionGates((a_coef, b_coef, c_coef, constant_coeff), other_coefs); + + // return (new_var, hint); + // } + // } +} + +impl<'a, E: Engine, CS: PlonkConstraintSystem + 'a> crate::ConstraintSystem + for Adaptor<'a, E, CS> +{ + type Root = Self; + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Aux(index)) => crate::Variable::new_unchecked(crate::Index::Aux(index)), + _ => unreachable!("Map aux into aux"), + }) + } + + fn alloc_input( + &mut self, + _: A, + f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc_input(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Input(index)) => crate::Variable::new_unchecked(crate::Index::Input(index)), + _ => unreachable!("Map input into input"), + }) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (_, hint) = { + self.get_next_hint() + }; + + let a = { deduplicate_stable::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch) }; + let b = { deduplicate_stable::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch) }; + let c = { deduplicate_stable::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch) }; + + // let ann : String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("LC_A"); + // for (var, coeff) in a.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_B"); + // for (var, coeff) in b.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_C"); + // for (var, coeff) in c.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + + let (a_is_constant, a_constant_coeff) = is_constant::(&a); + let (b_is_constant, b_constant_coeff) = is_constant::(&b); + let (c_is_constant, c_constant_coeff) = is_constant::(&c); + + let (a_has_variable, a_first_variable) = get_first_variable::(&a); + let (b_has_variable, b_first_variable) = get_first_variable::(&b); + let (c_has_variable, c_first_variable) = get_first_variable::(&c); + + debug_assert!(a_is_constant & a_has_variable == false); + debug_assert!(b_is_constant & b_has_variable == false); + debug_assert!(c_is_constant & c_has_variable == false); + + let dummy_var = self.cs.get_dummy_variable(); + + // variables are left, right, output + // coefficients are left, right, output, multiplication, constant + + match hint { + TranspilationVariant::IntoLinearGate((c0, c1)) => { + let var = if c_has_variable { + convert_variable(c_first_variable) + } else if b_has_variable { + convert_variable(b_first_variable) + } else if a_has_variable { + convert_variable(a_first_variable) + } else { + unreachable!(); + }; + + self.cs.new_gate((var, dummy_var, dummy_var), (c1, zero_fr, zero_fr, zero_fr, c0)).expect("must make a gate"); + + }, + TranspilationVariant::IntoQuandaticGate((c0, c1, c2)) => { + let var = if c_has_variable { + convert_variable(c_first_variable) + } else if b_has_variable { + convert_variable(b_first_variable) + } else if a_has_variable { + convert_variable(a_first_variable) + } else { + unreachable!(); + }; + + self.cs.new_gate((var, var, dummy_var), (c1, zero_fr, zero_fr, c2, c0)).expect("must make a gate"); + }, + TranspilationVariant::TransformLc(boxed_hints) => { + let (t_a, t_b, t_c) = *boxed_hints; + let mut multiplication_constant = one_fr; + let a_var = match t_a { + TranspilationVariant::IntoSingleAdditionGate(coeffs) => { + self.make_single_addition_gate(&a, coeffs).expect("must make a gate") + }, + TranspilationVariant::IntoMultipleAdditionGates(coeffs, chain) => { + self.make_chain_of_addition_gates(&a, coeffs, chain).expect("must make a gate") + }, + TranspilationVariant::LeaveAsSingleVariable(coeff) => { + assert!(a_has_variable); + multiplication_constant.mul_assign(&coeff); + + convert_variable(a_first_variable) + }, + _ => {unreachable!("{:?}", t_a)} + }; + + let b_var = match t_b { + TranspilationVariant::IntoSingleAdditionGate(coeffs) => { + self.make_single_addition_gate(&b, coeffs).expect("must make a gate") + }, + TranspilationVariant::IntoMultipleAdditionGates(coeffs, chain) => { + self.make_chain_of_addition_gates(&b, coeffs, chain).expect("must make a gate") + }, + TranspilationVariant::LeaveAsSingleVariable(coeff) => { + assert!(b_has_variable); + multiplication_constant.mul_assign(&coeff); + + convert_variable(b_first_variable) + }, + _ => {unreachable!("{:?}", t_b)} + }; + + let (c_is_just_a_constant, c_var, mut c_coeff) = match t_c { + TranspilationVariant::IntoSingleAdditionGate(coeffs) => { + (false, Some(self.make_single_addition_gate(&c, coeffs).expect("must make a gate")), one_fr) + }, + TranspilationVariant::IntoMultipleAdditionGates(coeffs, chain) => { + (false, Some(self.make_chain_of_addition_gates(&c, coeffs, chain).expect("must make a gate")), one_fr) + }, + TranspilationVariant::LeaveAsSingleVariable(coeff) => { + assert!(c_has_variable); + + (false, Some(convert_variable(c_first_variable)), coeff) + }, + TranspilationVariant::IsConstant(value) => { + assert!(c_is_constant); + assert!(c_constant_coeff == value); + (true, None, one_fr) + } + // TranspilationVariant::IntoLinearGate((c0, c1)) => { + // assert!(c_has_variable); + // multiplication_constant.mul_assign(&c1); + + // (false, Some(convert_variable(c_first_variable)) ) + // }, + _ => {unreachable!("{:?}", t_c)} + }; + + if c_is_just_a_constant { + let mut constant_term = c_constant_coeff; + constant_term.negate(); + + // A*B == constant + self.cs.new_gate((a_var, b_var, dummy_var), (zero_fr, zero_fr, zero_fr, multiplication_constant, constant_term)).expect("must make a gate"); + } else { + c_coeff.negate(); + let c_var = c_var.expect("must be a variable"); + self.cs.new_gate((a_var, b_var, c_var), (zero_fr, zero_fr, c_coeff, multiplication_constant, zero_fr)).expect("must make a gate"); + } + }, + TranspilationVariant::IntoMultipleAdditionGates(_, _) => { + // self.make_chain_of_addition_gates(&c, coeffs, chain).expect("must make a gate"); + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("LC_A"); + // for (var, coeff) in a.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_B"); + // for (var, coeff) in b.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_C"); + // for (var, coeff) in c.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("Hint is {:?}", hint); + unreachable!() + }, + TranspilationVariant::IntoSingleAdditionGate(_) => { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint is {:?}", hint); + unreachable!() + }, + TranspilationVariant::IsConstant(_) => { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint is {:?}", hint); + unreachable!() + }, + TranspilationVariant::LeaveAsSingleVariable(_) => { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint is {:?}", hint); + unreachable!() + }, + TranspilationVariant::MergeLinearCombinations((merge_variant, coeff, merge_hint)) => { + let multiplier = if a_is_constant { + a_constant_coeff + } else if b_is_constant { + b_constant_coeff + } else { + unreachable!() + }; + + assert!(coeff == one_fr); + + let lc_into_rewriting = match merge_variant { + MergeLcVariant::MergeACThroughConstantB => { + assert!(b_is_constant); + let mut final_lc = a; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + + subtract_lcs_with_dedup_stable::(final_lc, c, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::MergeBCThroughConstantA => { + assert!(a_is_constant); + let mut final_lc = b; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + + subtract_lcs_with_dedup_stable::(final_lc, c, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::CIsTheOnlyMeaningful => { + let mut tmp = one_fr; + tmp.mul_assign(&a_constant_coeff); + tmp.mul_assign(&b_constant_coeff); + assert!(tmp.is_zero() || (a_is_constant && b_is_constant)); + + c + }, + _ => { + unreachable!() + } + }; + + let h = *merge_hint; + + match h { + TranspilationVariant::IntoSingleAdditionGate(coeffs) => { + self.enforce_lc_with_single_addition_gate(lc_into_rewriting, coeffs).expect("must make a gate"); + }, + TranspilationVariant::IntoMultipleAdditionGates(coeffs, chain) => { + self.enforce_lc_using_chain_of_addition_gates(lc_into_rewriting, coeffs, chain).expect("must make a gate"); + }, + // TranspilationVariant::LeaveAsSingleVariable(coeff) => { + // let (contains_a_variable, variable) = get_first_variable::(&lc_into_rewriting); + // assert!(contains_a_variable); + // // enforce that final variable after rewriting is exactly zero + // self.cs.new_gate((convert_variable(variable), dummy_var, dummy_var), (coeff, zero_fr, zero_fr, zero_fr, zero_fr)).expect("must make a gate"); + // }, + // TranspilationVariant::IntoLinearGate((c0, c1)) => { + // let (contains_a_variable, variable) = get_first_variable::(&lc_into_rewriting); + // assert!(contains_a_variable); + // self.cs.new_gate((convert_variable(variable), dummy_var, dummy_var), (c1, zero_fr, zero_fr, zero_fr, c0)).expect("must make a gate"); + // } + _ => { + unreachable!("{:?}", h); + } + }; + } + } + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +fn convert_variable(r1cs_variable: crate::Variable) -> PlonkVariable { + let var = match r1cs_variable.get_unchecked() { + crate::Index::Input(0) => {unreachable!("can not convert input variable number 0 (CS::one)")}, + crate::Index::Aux(0) => {unreachable!("can not convert aux variable labeled as 0 (taken by Plonk CS)")}, + crate::Index::Input(i) => PlonkVariable(PlonkIndex::Input(i)), + crate::Index::Aux(i) => PlonkVariable(PlonkIndex::Aux(i)), + }; + + var +} + +use std::cell::Cell; + +pub struct AdaptorCircuit<'a, E:Engine, C: crate::Circuit>{ + circuit: Cell>, + hints: &'a Vec<(usize, TranspilationVariant)>, +} + +impl<'a, E:Engine, C: crate::Circuit> AdaptorCircuit<'a, E, C> { + pub fn new<'b>(circuit: C, hints: &'b Vec<(usize, TranspilationVariant)>) -> Self + where 'b: 'a + { + Self { + circuit: Cell::new(Some(circuit)), + hints: hints + } + } +} + +impl<'a, E: Engine, C: crate::Circuit> PlonkCircuit for AdaptorCircuit<'a, E, C> { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let mut adaptor = Adaptor { + cs: cs, + hints: self.hints, + current_constraint_index: 0, + current_hint_index: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + }; + + let c = self.circuit.replace(None).expect("Must replace a circuit out from cell"); + + match c.synthesize(&mut adaptor) { + Err(_) => return Err(SynthesisError::AssignmentMissing), + Ok(_) => {} + }; + + Ok(()) + } +} + +#[test] +fn transpile_xor_using_adaptor() { + use crate::tests::XORDemo; + use crate::cs::Circuit; + use crate::pairing::bn256::Bn256; + use crate::plonk::plonk::generator::*; + use crate::plonk::plonk::prover::*; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let mut transpiler = Transpiler::new(); + + c.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let hints = transpiler.hints; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let adapted_curcuit = AdaptorCircuit::new(c, &hints); + + let mut assembly = GeneratorAssembly::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + assembly.finalize(); + + // for (i, g) in assembly.aux_gates.iter().enumerate() { + // println!("Gate {} = {:?}", i, g); + // } + + let c = XORDemo:: { + a: Some(true), + b: Some(true), + _marker: PhantomData + }; + + println!("Trying to prove"); + + let adapted_curcuit = AdaptorCircuit::new(c, &hints); + + let mut prover = ProvingAssembly::::new(); + adapted_curcuit.synthesize(&mut prover).unwrap(); + prover.finalize(); + + assert!(prover.is_satisfied()); +} \ No newline at end of file diff --git a/src/plonk/adaptor/mod.rs b/src/plonk/adaptor/mod.rs new file mode 100644 index 000000000..6487cdd00 --- /dev/null +++ b/src/plonk/adaptor/mod.rs @@ -0,0 +1,351 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::SynthesisError; + +use crate::plonk::cs::gates::Gate; +use crate::plonk::cs::gates::Coeff; +use crate::plonk::cs::gates::Variable as PlonkVariable; +use crate::plonk::cs::gates::Index as PlonkIndex; + +use crate::plonk::cs::Circuit as PlonkCircuit; +use crate::plonk::cs::ConstraintSystem as PlonkConstraintSystem; + +use std::marker::PhantomData; + +pub mod alternative; + +// pub struct Adaptor<'a, E: Engine, CS: PlonkConstraintSystem + 'a> { +// cs: &'a mut CS, +// _marker: PhantomData, +// } + +// impl<'a, E: Engine, CS: PlonkConstraintSystem + 'a> crate::ConstraintSystem +// for Adaptor<'a, E, CS> +// { +// type Root = Self; + +// fn one() -> crate::Variable { +// crate::Variable::new_unchecked(crate::Index::Input(0)) +// } + +// fn alloc(&mut self, _: A, f: F) -> Result +// where +// F: FnOnce() -> Result, +// A: FnOnce() -> AR, +// AR: Into, +// { +// let var = self.cs.alloc(|| { +// f().map_err(|_| crate::SynthesisError::AssignmentMissing) +// })?; + +// Ok(match var { +// PlonkVariable(PlonkIndex::Input(index)) => crate::Variable::new_unchecked(crate::Index::Input(index)), +// _ => unreachable!(), +// }) +// } + +// fn alloc_input( +// &mut self, +// _: A, +// f: F, +// ) -> Result +// where +// F: FnOnce() -> Result, +// A: FnOnce() -> AR, +// AR: Into, +// { +// let var = self.cs.alloc_input(|| { +// f().map_err(|_| crate::SynthesisError::AssignmentMissing) +// })?; + +// Ok(match var { +// PlonkVariable(PlonkIndex::Aux(index)) => crate::Variable::new_unchecked(crate::Index::Aux(index)), +// _ => unreachable!(), +// }) +// } + +// fn enforce(&mut self, _: A, a: LA, b: LB, c: LC) +// where +// A: FnOnce() -> AR, +// AR: Into, +// LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, +// LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, +// LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, +// { + +// /// Represents either a "true" variable or a constant +// /// auxillary variable. +// #[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)] +// enum Var +// { +// InputVar(PlonkVariable), +// ConstVar +// } + +// fn convert(lc: crate::LinearCombination) -> Vec<(E::Fr, Var)> { +// let mut ret = Vec::with_capacity(lc.as_ref().len()); + +// for &(v, coeff) in lc.as_ref().iter() { +// let var = match v.get_unchecked() { +// crate::Index::Input(0) => Var::ConstVar, +// crate::Index::Input(i) => Var::InputVar(PlonkVariable(PlonkIndex::Input(i))), +// crate::Index::Aux(i) => Var::InputVar(PlonkVariable(PlonkIndex::Aux(i))), +// }; + +// ret.push((coeff, var)); +// } + +// ret +// } + +// let a_terms = convert(a(crate::LinearCombination::zero())); +// let b_terms = convert(b(crate::LinearCombination::zero())); +// let c_terms = convert(c(crate::LinearCombination::zero())); + +// ///first check if we are dealing with a boolean constraint +// ///we use the following euristics: +// ///analyse comment string +// ///calculate the number of arguments in each linear combination - in boolean constraint length of each lc is at most 2 +// /// this function returns true in the case of boolean constraint + +// fn handle_boolean_constraint( +// la: &Vec<(E::Fr, Var)>, +// lb: &Vec<(E::Fr, Var)>, +// lc: &Vec<(E::Fr, Var)>, +// ) -> bool +// where +// A: FnOnce() -> AR, +// AR: Into +// { +// return true; +// } + + +// fn eval_lc_short>( +// term1: (E::Fr, PlonkVariable), +// term2: (E::Fr, PlonkVariable), +// cs: &CS, +// ) -> Option +// { +// let mut extra_value = E::Fr::zero(); + +// let mut var_value = match cs.get_value(term1.1) { +// Ok(tmp) => tmp, +// Err(_) => return None, +// }; +// var_value.mul_assign(&term1.0); +// extra_value.add_assign(&var_value); + +// var_value = match cs.get_value(term2.1) { +// Ok(tmp) => tmp, +// Err(_) => return None, +// }; +// var_value.mul_assign(&term2.0); +// extra_value.add_assign(&var_value); + +// Some(extra_value) +// } + + +// fn allocate_new_lc_var>( +// term1: (E::Fr, PlonkVariable), +// term2: (E::Fr, PlonkVariable), +// cs: &mut CS, +// ) -> PlonkVariable +// { + +// let extra_value = eval_lc_short(term1, term2, &*cs); +// let extra_variable = cs.alloc(|| +// { +// if let Some(value) = extra_value { +// Ok(value) +// } else { +// Err(SynthesisError::AssignmentMissing) +// } +// } +// ).expect("must allocate"); + +// cs.enforce_mul_3((term1.1, term2.1, extra_variable)).expect("must allocate"); +// extra_variable +// } + + +// fn allocate_lc_intermediate_variables>( +// terms: Vec<(E::Fr, Var)>, +// cs: &mut CS, +// ) -> (PlonkVariable, Option) { + +// debug_assert!(terms.len() > 2); +// let mut const_var_found = false; +// let mut const_coeff = E::Fr::zero(); +// let mut current_var : Option<(E::Fr, PlonkVariable)> = None; + +// for &(coeff, var) in terms.iter() { +// match var { +// Var::ConstVar => { +// if const_var_found { +// unreachable!(); +// } +// const_var_found = true; +// const_coeff = coeff; +// } +// Var::InputVar(pv) => { +// current_var = match current_var { +// None => Some((coeff, pv)), +// Some((old_coeff, old_pv)) => { +// let new_val = allocate_new_lc_var((old_coeff, old_pv), (coeff, pv), cs); +// Some((E::Fr::one(), new_val)) +// } +// } +// } +// } + +// } + +// let var = match current_var { +// Some((_, pv)) => pv, +// None => unreachable!(), +// }; + +// let coef = match const_var_found{ +// false => None, +// true => Some(const_coeff) +// } ; + +// return (var, coef) +// } + + +// /// after parsing we should return on of three possible results: +// /// variable, constant or sum variable + constant + +// fn parse_lc>( +// terms: Vec<(E::Fr, Var)>, +// cs: &mut CS, +// ) -> (Option<(E::Fr, PlonkVariable)>, Option) { +// // there are few options +// match terms.len() { +// 0 => { +// //Every linear combination in real cs should contain at least one term! +// unreachable!(); +// }, + +// 1 => { +// let (c_0, v_0) = terms[0]; +// let result = match v_0 { +// Var::InputVar(pv) => (Some((c_0, pv)), None), +// Var::ConstVar => (None, Some(c_0)), +// }; +// // forward the result +// return result; +// }, + +// 2 => { +// let (c_0, v_0) = terms[0]; +// let (c_1, v_1) = terms[1]; + +// //check of one of v_0, v_1 is constant and the other is variable or vice versa +// //the case of two constants is impossible in real cs! +// let result = match (v_0, v_1) { +// (Var::InputVar(pv), Var::ConstVar) => (Some((c_0, pv)), Some(c_1)), +// (Var::ConstVar, Var::InputVar(pv)) => (Some((c_1, pv)), Some(c_0)), +// (Var::InputVar(pv0), Var::InputVar(pv1)) => { +// let extra_variable = allocate_new_lc_var((c_0, pv0), (c_1, pv1), cs); +// (Some((E::Fr::one(), extra_variable)), None) +// } +// (Var::ConstVar, Var::ConstVar) => unreachable!(), +// }; + +// return result; +// } + +// _ => { +// // here we need to allocate intermediate variables and output the last one +// let last_vars = allocate_lc_intermediate_variables(terms, cs); +// return (Some((E::Fr::one(), last_vars.0)), last_vars.1); +// } +// } +// } + +// let a_var = parse_lc(a_terms, self.cs); +// let b_var = parse_lc(b_terms, self.cs); +// let c_var = parse_lc(c_terms, self.cs); + + +// /// parse result and return expr of the form: coeff * var + constant + +// fn unfold_var>( +// var: (Option<(E::Fr, PlonkVariable)>, Option<(E::Fr)>), +// stub: PlonkVariable, +// cs: &mut CS, +// ) -> (E::Fr, PlonkVariable, E::Fr) +// { + +// let result = match var { +// (Some((coeff, var)), Some(constant)) => (coeff, var, constant), +// (Some((coeff, var)), None) => (coeff, var, E::Fr::zero()), +// (None, Some(constant)) => (E::Fr::zero(), stub, constant), +// _ => unreachable!(), +// }; + +// return result; +// } + +// // our final equation is of the following form +// // (x a_var + c_1) (y b_var + c_2) = (z c_var + c_3) +// // we can convert it to standard PLONK form: +// // (xy) a_var + b_var + (x c_2) a_var + (y c_1) b_var - z c_var + (c_1 c_2 - c_3) */ + +// let (mut x, a_var, mut c_1) : (E::Fr, PlonkVariable, E::Fr) = unfold_var(a_var, CS::ZERO, self.cs); +// let (mut y, b_var, c_2) : (E::Fr, PlonkVariable, E::Fr) = unfold_var(b_var, CS::ZERO, self.cs); +// let (mut z, c_var, mut c_3) : (E::Fr, PlonkVariable, E::Fr) = unfold_var(c_var, CS::ZERO, self.cs); + +// let mut a_coef : E::Fr = x; +// a_coef.mul_assign(&y); + +// x.mul_assign(&c_2); +// y.mul_assign(&c_1); +// z.negate(); +// c_1.mul_assign(&c_2); +// c_3.negate(); +// c_1.add_assign(&c_3); + +// self.cs.new_gate((a_var, b_var, c_var), (a_coef, x, y, z, c_1)); +// } + +// fn push_namespace(&mut self, _: N) +// where +// NR: Into, +// N: FnOnce() -> NR, +// { +// // Do nothing; we don't care about namespaces in this context. +// } + +// fn pop_namespace(&mut self) { +// // Do nothing; we don't care about namespaces in this context. +// } + +// fn get_root(&mut self) -> &mut Self::Root { +// self +// } +// } + +// #[derive(Clone)] +// pub struct AdaptorCircuit(pub T); + +// impl<'a, E: Engine, C: crate::Circuit + Clone> PlonkCircuit for AdaptorCircuit { +// fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { +// let mut adaptor = Adaptor { +// cs: cs, +// _marker: PhantomData, +// }; + +// match self.0.clone().synthesize(&mut adaptor) { +// Err(_) => return Err(SynthesisError::AssignmentMissing), +// Ok(_) => {} +// }; + +// Ok(()) +// } +// } \ No newline at end of file diff --git a/src/plonk/better_better_cs/cs.rs b/src/plonk/better_better_cs/cs.rs new file mode 100644 index 000000000..4d38861e9 --- /dev/null +++ b/src/plonk/better_better_cs/cs.rs @@ -0,0 +1,5406 @@ +use crate::pairing::ff::{Field, PrimeField, PrimeFieldRepr}; +use crate::pairing::{Engine, CurveAffine, CurveProjective}; +use crate::bit_vec::BitVec; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::worker::Worker; +use crate::plonk::domains::*; +use crate::plonk::polynomials::*; + +pub use crate::plonk::cs::variable::*; +use crate::plonk::better_cs::utils::*; +pub use super::lookup_tables::{self, *}; + +use crate::plonk::fft::cooley_tukey_ntt::*; + +use super::utils::*; +pub use super::data_structures::*; +pub use super::setup::*; + +pub trait SynthesisMode: Clone + Send + Sync + std::fmt::Debug { + const PRODUCE_WITNESS: bool; + const PRODUCE_SETUP: bool; +} +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] +pub struct SynthesisModeGenerateSetup; + +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] +pub struct SynthesisModeProve; + +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] +pub struct SynthesisModeTesting; + +impl SynthesisMode for SynthesisModeGenerateSetup { + const PRODUCE_WITNESS: bool = false; + const PRODUCE_SETUP: bool = true; +} + +impl SynthesisMode for SynthesisModeProve { + const PRODUCE_WITNESS: bool = true; + const PRODUCE_SETUP: bool = false; +} + +impl SynthesisMode for SynthesisModeTesting { + const PRODUCE_WITNESS: bool = true; + const PRODUCE_SETUP: bool = true; +} + +pub trait Circuit { + type MainGate: MainGate; + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError>; + fn declare_used_gates() -> Result>>, SynthesisError> { + Ok( + vec![Self::MainGate::default().into_internal()] + ) + } +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum Coefficient { + PlusOne, + MinusOne, + Other +} + +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub struct PolynomialMultiplicativeTerm(pub Coefficient, pub Vec); + +impl PolynomialMultiplicativeTerm { + fn degree(&self) -> usize { + self.1.len() + } +} + +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub(crate) struct PolynomialOpeningRequest { + pub(crate) id: PolyIdentifier, + pub(crate) dilation: TimeDilation, +} + +pub trait GateInternal: Send + + Sync + + 'static + + std::any::Any + + std::fmt::Debug +{ + fn name(&self) -> &'static str; + fn degree(&self) -> usize; + fn can_include_public_inputs(&self) -> bool; + fn all_queried_polynomials(&self) -> Vec; + fn setup_polynomials(&self) -> Vec; + fn variable_polynomials(&self) -> Vec; + fn witness_polynomials(&self) -> Vec { + vec![] + } + fn benefits_from_linearization(&self) -> bool; + fn linearizes_over(&self) -> Vec; + fn needs_opened_for_linearization(&self) -> Vec; + fn num_quotient_terms(&self) -> usize; + fn verify_on_row<'a>(&self, row: usize, poly_storage: &AssembledPolynomialStorage<'a, E>, last_row: bool) -> E::Fr; + fn contribute_into_quotient<'a, 'b>( + &self, + domain_size: usize, + poly_storage: &mut AssembledPolynomialStorage<'a, E>, + monomials_storage: & AssembledPolynomialStorageForMonomialForms<'b, E>, + challenges: &[E::Fr], + omegas_bitreversed: &BitReversedOmegas, + omegas_inv_bitreversed: &OmegasInvBitreversed, + worker: &Worker + ) -> Result, SynthesisError>; + fn contribute_into_linearization<'a>( + &self, + domain_size: usize, + at: E::Fr, + queried_values: &std::collections::HashMap, + monomials_storage: & AssembledPolynomialStorageForMonomialForms<'a, E>, + challenges: &[E::Fr], + worker: &Worker + ) -> Result, SynthesisError>; + fn contribute_into_verification_equation( + &self, + domain_size: usize, + at: E::Fr, + queried_values: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result; + fn put_public_inputs_into_selector_id(&self) -> Option; + fn box_clone(&self) -> Box>; + fn contribute_into_linearization_commitment( + &self, + domain_size: usize, + at: E::Fr, + queried_values: &std::collections::HashMap, + commitments_storage: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result; +} + +pub trait Gate: GateInternal + + Sized + + Clone + + std::hash::Hash + + std::default::Default +{ + fn as_internal(&self) -> &dyn GateInternal { + self as &dyn GateInternal + } + + fn into_internal(self) -> Box> { + Box::from(self) as Box> + } +} + +pub trait MainGate: Gate { + const NUM_LINEAR_TERMS: usize; + const NUM_VARIABLES: usize; + const NUM_VARIABLES_ON_NEXT_STEP: usize; + + // fn num_linear_terms(&self) -> usize; + // fn num_variables(&self) -> usize; + // fn num_variables_of_next_step(&self) -> usize; + + fn range_of_multiplicative_term() -> std::ops::Range; + fn range_of_linear_terms() -> std::ops::Range; + fn index_for_constant_term() -> usize; + fn range_of_next_step_linear_terms() -> std::ops::Range; + fn format_term(instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError>; + fn format_linear_term_with_duplicates(instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError>; + fn dummy_vars_to_inscribe(dummy: Variable) -> Vec; + fn empty_coefficients() -> Vec; + fn contribute_into_quotient_for_public_inputs<'a, 'b>( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + poly_storage: &mut AssembledPolynomialStorage<'b, E>, + monomial_storage: & AssembledPolynomialStorageForMonomialForms<'a, E>, + challenges: &[E::Fr], + omegas_bitreversed: &BitReversedOmegas, + omegas_inv_bitreversed: &OmegasInvBitreversed, + worker: &Worker + ) -> Result, SynthesisError>; + fn contribute_into_linearization_for_public_inputs<'a>( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + at: E::Fr, + queried_values: &std::collections::HashMap, + monomials_storage: & AssembledPolynomialStorageForMonomialForms<'a, E>, + challenges: &[E::Fr], + worker: &Worker + ) -> Result, SynthesisError>; + fn add_inputs_into_quotient( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + at: E::Fr, + challenges: &[E::Fr], + ) -> Result; + // fn contribute_into_verification_equation_for_public_inputs( + // &self, + // domain_size: usize, + // public_inputs: &[E::Fr], + // at: E::Fr, + // queried_values: &std::collections::HashMap, + // challenges: &[E::Fr], + // ) -> Result; + fn contribute_into_linearization_commitment_for_public_inputs( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + at: E::Fr, + queried_values: &std::collections::HashMap, + commitments_storage: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result; +} + +impl std::hash::Hash for dyn GateInternal { + fn hash(&self, state: &mut H) where H: std::hash::Hasher { + self.type_id().hash(state); + self.name().hash(state); + self.degree().hash(state); + } +} + +impl PartialEq for dyn GateInternal { + fn eq(&self, other: &Self) -> bool { + self.type_id() == other.type_id() && + self.name() == other.name() && + self.degree() == other.degree() + } +} + +impl Eq for dyn GateInternal {} + +impl Clone for Box> { + fn clone(&self) -> Self { + self.box_clone() + } +} +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub struct LinearCombinationOfTerms(pub Vec); + +impl LinearCombinationOfTerms { + fn terms(&self) -> &[PolynomialMultiplicativeTerm] { + &self.0[..] + } +} + +#[derive(Clone, Debug)] +pub enum ArithmeticTerm{ + Product(Vec, E::Fr), + SingleVariable(Variable, E::Fr), + Constant(E::Fr), +} + +impl ArithmeticTerm { + pub fn from_variable(var: Variable) -> Self { + ArithmeticTerm::SingleVariable(var, E::Fr::one()) + } + + pub fn from_variable_and_coeff(var: Variable, coeff: E::Fr) -> Self { + ArithmeticTerm::SingleVariable(var, coeff) + } + + pub fn constant(coeff: E::Fr) -> Self { + ArithmeticTerm::Constant(coeff) + } + + pub fn mul_by_variable(self, other: Variable) -> Self { + match self { + ArithmeticTerm::Product(mut terms, coeff) => { + terms.push(other); + + ArithmeticTerm::Product(terms, coeff) + }, + ArithmeticTerm::SingleVariable(this, coeff) => { + let terms = vec![this, other]; + + ArithmeticTerm::Product(terms, coeff) + }, + ArithmeticTerm::Constant(coeff) => { + let terms = vec![other]; + + ArithmeticTerm::Product(terms, coeff) + }, + } + } + + pub fn scale(&mut self, by: &E::Fr) { + match self { + ArithmeticTerm::Product(_, ref mut coeff) => { + coeff.mul_assign(by); + }, + ArithmeticTerm::SingleVariable(_, ref mut coeff) => { + coeff.mul_assign(by); + }, + ArithmeticTerm::Constant(ref mut coeff) => { + coeff.mul_assign(by); + }, + } + } +} + +#[derive(Clone, Debug)] +pub struct MainGateTerm{ + terms: Vec>, + vars_scratch: std::collections::HashMap, + num_multiplicative_terms: usize, + num_constant_terms: usize +} + +impl MainGateTerm { + pub fn new() -> Self { + Self { + terms: Vec::with_capacity(8), + vars_scratch: std::collections::HashMap::with_capacity(8), + num_multiplicative_terms: 0, + num_constant_terms: 0 + } + } + + pub fn len_without_constant(&self) -> usize { + self.terms.len() + } + + pub fn add_assign(&mut self, other: ArithmeticTerm) { + match other { + ArithmeticTerm::Product(_, _) => { + self.num_multiplicative_terms += 1; + self.terms.push(other); + }, + ArithmeticTerm::SingleVariable(var, coeff) => { + // deduplicate + if self.vars_scratch.get(&var).is_some() { + let index = *self.vars_scratch.get(&var).unwrap(); + match &mut self.terms[index] { + ArithmeticTerm::SingleVariable(_, ref mut c) => { + c.add_assign(&coeff); + }, + _ => { + unreachable!() + } + } + } else { + // just push + self.vars_scratch.insert(var, self.terms.len()); + self.terms.push(other); + } + }, + ArithmeticTerm::Constant(_) => { + self.num_constant_terms += 1; + self.terms.push(other); + }, + } + + debug_assert!(self.num_constant_terms <= 1, "must duplicate constants"); + } + + pub fn add_assign_allowing_duplicates(&mut self, other: ArithmeticTerm) { + match other { + ArithmeticTerm::Product(_, _) => { + self.num_multiplicative_terms += 1; + self.terms.push(other); + }, + ArithmeticTerm::SingleVariable(_, _) => { + // we just push and don't even count this variable as duplicatable + self.terms.push(other); + }, + ArithmeticTerm::Constant(_) => { + self.num_constant_terms += 1; + self.terms.push(other); + }, + } + + debug_assert!(self.num_constant_terms <= 1, "must duplicate constants"); + } + + pub fn sub_assign(&mut self, mut other: ArithmeticTerm) { + match &mut other { + ArithmeticTerm::Product(_, ref mut coeff) => { + coeff.negate(); + }, + ArithmeticTerm::SingleVariable(_, ref mut coeff) => { + coeff.negate(); + }, + ArithmeticTerm::Constant(ref mut coeff) => { + coeff.negate(); + }, + } + + self.add_assign(other); + + debug_assert!(self.num_constant_terms <= 1, "must not duplicate constants"); + } + + pub fn sub_assign_allowing_duplicates(&mut self, mut other: ArithmeticTerm) { + match &mut other { + ArithmeticTerm::Product(_, ref mut coeff) => { + coeff.negate(); + }, + ArithmeticTerm::SingleVariable(_, ref mut coeff) => { + coeff.negate(); + }, + ArithmeticTerm::Constant(ref mut coeff) => { + coeff.negate(); + }, + } + + self.add_assign_allowing_duplicates(other); + + debug_assert!(self.num_constant_terms <= 1, "must not duplicate constants"); + } +} + +#[derive(Clone, Debug, Hash, Default)] +pub struct Width4MainGateWithDNext; + +impl GateInternal for Width4MainGateWithDNext { + fn name(&self) -> &'static str { + "main gate of width 4 with D_next" + } + + fn degree(&self) -> usize { + 3 + } + + fn can_include_public_inputs(&self) -> bool { + true + } + + fn all_queried_polynomials(&self) -> Vec { + let name = >::name(&self); + + vec![ + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 0)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 1)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 2)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 3)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 4)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 5)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 6)), + + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(3)), + + PolynomialInConstraint::from_id_and_dilation(PolyIdentifier::VariablesPolynomial(3), 1), + ] + } + + fn setup_polynomials(&self) -> Vec { + let name = >::name(&self); + + vec![ + PolyIdentifier::GateSetupPolynomial(name, 0), + PolyIdentifier::GateSetupPolynomial(name, 1), + PolyIdentifier::GateSetupPolynomial(name, 2), + PolyIdentifier::GateSetupPolynomial(name, 3), + PolyIdentifier::GateSetupPolynomial(name, 4), + PolyIdentifier::GateSetupPolynomial(name, 5), + PolyIdentifier::GateSetupPolynomial(name, 6), + ] + } + + fn variable_polynomials(&self) -> Vec { + vec![ + PolyIdentifier::VariablesPolynomial(0), + PolyIdentifier::VariablesPolynomial(1), + PolyIdentifier::VariablesPolynomial(2), + PolyIdentifier::VariablesPolynomial(3), + ] + } + + fn benefits_from_linearization(&self) -> bool { + true + } + + fn linearizes_over(&self) -> Vec { + let name = >::name(&self); + + vec![ + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 0)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 1)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 2)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 3)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 4)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 5)), + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 6)), + ] + } + + fn needs_opened_for_linearization(&self) -> Vec { + vec![ + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2)), + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(3)), + + PolynomialInConstraint::from_id_and_dilation(PolyIdentifier::VariablesPolynomial(3), 1), + ] + } + + fn num_quotient_terms(&self) -> usize { + 1 + } + + fn verify_on_row(&self, row: usize, poly_storage: &AssembledPolynomialStorage, last_row: bool) -> E::Fr { + let name = >::name(&self); + + let q_a = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 0), row); + let q_b = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 1), row); + let q_c = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 2), row); + let q_d = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 3), row); + let q_m = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 4), row); + let q_const = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 5), row); + let q_d_next = poly_storage.get_poly_at_step(PolyIdentifier::GateSetupPolynomial(name, 6), row); + + // println!("{}*A + {}*B + {}*C + {}*D + {} + {}*A*A + {}*D_next", q_a, q_b, q_c, q_d, q_const, q_m, q_d_next); + let a_value = poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(0), row); + let b_value = poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(1), row); + let c_value = poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(2), row); + let d_value = poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(3), row); + let d_next_value = if last_row == false { + Some(poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(3), row+1)) + } else { + None + }; + + // println!("A = {}, B = {}, C = {}, D = {}, D_Next = {:?}", a_value, b_value, c_value, d_value, d_next_value); + + let mut total = E::Fr::zero(); + + for (q, v) in [a_value, b_value, c_value, d_value].iter() + .zip([q_a, q_b, q_c, q_d].iter()) + { + let mut tmp = *q; + tmp.mul_assign(v); + total.add_assign(&tmp); + } + + total.add_assign(&q_const); + + let mut tmp = q_m; + tmp.mul_assign(&a_value); + tmp.mul_assign(&b_value); + total.add_assign(&tmp); + + if last_row == false { + let mut tmp = d_next_value.expect("must be able to get d_next"); + tmp.mul_assign(&q_d_next); + + total.add_assign(&tmp); + } else { + assert!(q_d_next.is_zero()); + } + + total + } + + fn contribute_into_quotient( + &self, + _domain_size: usize, + _poly_storage: &mut AssembledPolynomialStorage, + _monomial_storage: & AssembledPolynomialStorageForMonomialForms, + _challenges: &[E::Fr], + _omegas_bitreversed: &BitReversedOmegas, + _omegas_inv_bitreversed: &OmegasInvBitreversed, + _worker: &Worker + ) -> Result, SynthesisError> { + unreachable!("this type of gate can only be used as a main gate"); + } + + fn contribute_into_linearization( + &self, + _domain_size: usize, + _at: E::Fr, + _queried_values: &std::collections::HashMap, + _monomials_storage: & AssembledPolynomialStorageForMonomialForms, + _challenges: &[E::Fr], + _worker: &Worker + ) -> Result, SynthesisError> { + unreachable!("this gate is indended to be the main gate and should use main gate functions") + } + fn contribute_into_verification_equation( + &self, + _domain_size: usize, + _at: E::Fr, + _queried_values: &std::collections::HashMap, + _challenges: &[E::Fr], + ) -> Result { + unreachable!("this gate is indended to be the main gate and should use main gate functions") + } + + fn put_public_inputs_into_selector_id(&self) -> Option { + Some(5) + } + + fn box_clone(&self) -> Box> { + Box::from(self.clone()) + } + fn contribute_into_linearization_commitment( + &self, + domain_size: usize, + at: E::Fr, + queried_values: &std::collections::HashMap, + commitments_storage: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result { + unreachable!("this gate is indended to be the main gate and should use main gate functions") + } +} + +impl Gate for Width4MainGateWithDNext { + +} + +impl MainGate for Width4MainGateWithDNext { + const NUM_LINEAR_TERMS: usize = 4; + const NUM_VARIABLES: usize = 4; + const NUM_VARIABLES_ON_NEXT_STEP: usize = 1; + + fn range_of_multiplicative_term() -> std::ops::Range { + 0..2 + } + fn range_of_linear_terms() -> std::ops::Range { + 0..4 + } + + fn index_for_constant_term() -> usize { + 5 + } + + fn range_of_next_step_linear_terms() -> std::ops::Range { + 6..7 + } + + fn format_term(mut instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError> { + let mut flattened_variables = vec![padding; 4]; + let mut flattened_coefficients = vec![E::Fr::zero(); 7]; + let mut bitmap = SimpleBitmap::new(); + + let allowed_linear = 4; + let allowed_multiplications = 1; + let allowed_constants = 1; + + let mut used_in_multiplication = [padding; 2]; + + debug_assert!(instance.num_constant_terms <= allowed_constants, "must not containt more constants than allowed"); + debug_assert!(instance.num_multiplicative_terms <= allowed_multiplications, "must not containt more multiplications than allowed"); + debug_assert!(instance.terms.len() <= allowed_constants + allowed_multiplications + allowed_linear, "gate can not fit that many terms"); + + if instance.num_multiplicative_terms != 0 { + let index = instance.terms.iter().position( + |t| { + match t { + ArithmeticTerm::Product(_, _) => true, + _ => false, + } + } + ).unwrap(); + + let term = instance.terms.swap_remove(index); + match term { + ArithmeticTerm::Product(vars, coeff) => { + debug_assert_eq!(vars.len(), 2, "multiplicative terms must contain two variables"); + + flattened_variables[0] = vars[0]; + flattened_variables[1] = vars[1]; + used_in_multiplication[0] = vars[0]; + used_in_multiplication[1] = vars[1]; + flattened_coefficients[4] = coeff; + bitmap.set(0); + bitmap.set(1); + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + if instance.num_constant_terms != 0 { + let index = instance.terms.iter().position( + |t| { + match t { + ArithmeticTerm::Constant(_) => true, + _ => false, + } + } + ).unwrap(); + + let term = instance.terms.swap_remove(index); + match term { + ArithmeticTerm::Constant(coeff) => { + flattened_coefficients[5] = coeff; + }, + _ => { + unreachable!("must be constant term"); + } + } + } + + // only additions left + for term in instance.terms.into_iter() { + match term { + ArithmeticTerm::SingleVariable(var, coeff) => { + let index = flattened_variables.iter().position( + |&t| t == var + ); + if let Some(index) = index { + // there is some variable there already, so it must have come from multiplication + assert!(used_in_multiplication[0] == var || used_in_multiplication[1] == var, + "variable in linear term must only happen already if it was in multiplication"); + flattened_coefficients[index] = coeff; + } else { + let idx = bitmap.get_next_unused(); + flattened_variables[idx] = var; + flattened_coefficients[idx] = coeff; + bitmap.set(idx); + } + }, + _ => { + unreachable!("must be additive term"); + } + } + } + + Ok((flattened_variables, flattened_coefficients)) + } + + fn format_linear_term_with_duplicates(mut instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError> { + let mut flattened_variables = vec![padding; 4]; + let mut flattened_coefficients = vec![E::Fr::zero(); 7]; + let mut bitmap = SimpleBitmap::new(); + + let allowed_linear = 4; + let allowed_multiplications = 0; + let allowed_constants = 1; + + debug_assert!(instance.num_constant_terms <= allowed_constants, "must not containt more constants than allowed"); + assert!(instance.num_multiplicative_terms <= allowed_multiplications, "must not containt multiplications"); + debug_assert!(instance.terms.len() <= allowed_constants + allowed_multiplications + allowed_linear, "gate can not fit that many terms"); + + if instance.num_constant_terms != 0 { + let index = instance.terms.iter().position( + |t| { + match t { + ArithmeticTerm::Constant(_) => true, + _ => false, + } + } + ).unwrap(); + + let term = instance.terms.swap_remove(index); + match term { + ArithmeticTerm::Constant(coeff) => { + flattened_coefficients[5] = coeff; + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + for term in instance.terms.into_iter() { + match term { + ArithmeticTerm::SingleVariable(var, coeff) => { + let idx = bitmap.get_next_unused(); + flattened_variables[idx] = var; + flattened_coefficients[idx] = coeff; + bitmap.set(idx); + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + Ok((flattened_variables, flattened_coefficients)) + } + + fn dummy_vars_to_inscribe(dummy: Variable) -> Vec { + vec![dummy; 4] + } + + fn empty_coefficients() -> Vec { + vec![E::Fr::zero(); 7] + } + + fn contribute_into_quotient_for_public_inputs<'a, 'b>( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + poly_storage: &mut AssembledPolynomialStorage<'a, E>, + monomials_storage: & AssembledPolynomialStorageForMonomialForms<'b, E>, + challenges: &[E::Fr], + omegas_bitreversed: &BitReversedOmegas, + omegas_inv_bitreversed: &OmegasInvBitreversed, + worker: &Worker + ) -> Result, SynthesisError> { + assert!(domain_size.is_power_of_two()); + assert_eq!(challenges.len(), >::num_quotient_terms(&self)); + + let lde_factor = poly_storage.lde_factor; + assert!(lde_factor.is_power_of_two()); + + assert!(poly_storage.is_bitreversed); + + let coset_factor = E::Fr::multiplicative_generator(); + // Include the public inputs + let mut inputs_poly = Polynomial::::new_for_size(domain_size)?; + for (idx, &input) in public_inputs.iter().enumerate() { + inputs_poly.as_mut()[idx] = input; + } + // go into monomial form + + let mut inputs_poly = inputs_poly.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // add constants selectors vector + let name = >::name(&self); + + let key = PolyIdentifier::GateSetupPolynomial(name, 5); + let constants_poly_ref = monomials_storage.get_poly(key); + inputs_poly.add_assign(&worker, constants_poly_ref); + drop(constants_poly_ref); + + // LDE + let mut t_1 = inputs_poly.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + omegas_bitreversed, + &coset_factor + )?; + + for p in >::all_queried_polynomials(&self).into_iter() { + // skip public constants poly (was used in public inputs) + if p == PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 5)) { + continue; + } + ensure_in_map_or_create(&worker, + p, + domain_size, + omegas_bitreversed, + lde_factor, + coset_factor, + monomials_storage, + poly_storage + )?; + } + + let ldes_storage = &*poly_storage; + + // Q_A * A + let q_a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 0)), + ldes_storage + ); + let a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + ldes_storage + ); + let mut tmp = q_a_ref.clone(); + tmp.mul_assign(&worker, a_ref); + t_1.add_assign(&worker, &tmp); + drop(q_a_ref); + drop(a_ref); + + // Q_B * B + let q_b_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 1)), + ldes_storage + ); + let b_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + ldes_storage + ); + tmp.reuse_allocation(q_b_ref); + tmp.mul_assign(&worker, b_ref); + t_1.add_assign(&worker, &tmp); + drop(q_b_ref); + drop(b_ref); + + // // Q_C * C + let q_c_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 2)), + ldes_storage + ); + let c_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2)), + ldes_storage + ); + tmp.reuse_allocation(q_c_ref); + tmp.mul_assign(&worker, c_ref); + t_1.add_assign(&worker, &tmp); + drop(q_c_ref); + drop(c_ref); + + // // Q_D * D + let q_d_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 3)), + ldes_storage + ); + let d_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(3)), + ldes_storage + ); + tmp.reuse_allocation(q_d_ref); + tmp.mul_assign(&worker, d_ref); + t_1.add_assign(&worker, &tmp); + drop(q_d_ref); + drop(d_ref); + + // Q_M * A * B + let q_m_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 4)), + ldes_storage + ); + let a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + ldes_storage + ); + let b_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + ldes_storage + ); + tmp.reuse_allocation(q_m_ref); + tmp.mul_assign(&worker, a_ref); + tmp.mul_assign(&worker, b_ref); + t_1.add_assign(&worker, &tmp); + drop(q_m_ref); + drop(a_ref); + drop(b_ref); + + // Q_D_next * D_next + let q_d_next_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::GateSetupPolynomial(name, 6)), + ldes_storage + ); + let d_next_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id_and_dilation(PolyIdentifier::VariablesPolynomial(3), 1), + ldes_storage + ); + tmp.reuse_allocation(q_d_next_ref); + tmp.mul_assign(&worker, d_next_ref); + t_1.add_assign(&worker, &tmp); + drop(q_d_next_ref); + drop(d_next_ref); + + t_1.scale(&worker, challenges[0]); + + Ok(t_1) + } + + fn contribute_into_linearization_for_public_inputs( + &self, + _domain_size: usize, + _public_inputs: &[E::Fr], + _at: E::Fr, + queried_values: &std::collections::HashMap, + monomials_storage: & AssembledPolynomialStorageForMonomialForms, + challenges: &[E::Fr], + worker: &Worker + ) -> Result, SynthesisError> { + // we actually do not depend on public inputs, but we use this form for consistency + assert_eq!(challenges.len(), 1); + + let a_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0))) + .ok_or(SynthesisError::AssignmentMissing)?; + let b_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1))) + .ok_or(SynthesisError::AssignmentMissing)?; + let c_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2))) + .ok_or(SynthesisError::AssignmentMissing)?; + let d_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(3))) + .ok_or(SynthesisError::AssignmentMissing)?; + let d_next_value = *queried_values.get(&PolynomialInConstraint::from_id_and_dilation(PolyIdentifier::VariablesPolynomial(3), 1)) + .ok_or(SynthesisError::AssignmentMissing)?; + + let name = >::name(&self); + + // Q_a * A + let mut result = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 0)).clone(); + result.scale(&worker, a_value); + + // Q_b * B + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 1)); + result.add_assign_scaled(&worker, poly_ref, &b_value); + + // Q_c * C + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 2)); + result.add_assign_scaled(&worker, poly_ref, &c_value); + + // Q_d * D + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 3)); + result.add_assign_scaled(&worker, poly_ref, &d_value); + + // Q_m * A*B + let mut tmp = a_value; + tmp.mul_assign(&b_value); + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 4)); + result.add_assign_scaled(&worker, poly_ref, &tmp); + + // Q_const + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 5)); + result.add_assign(&worker, poly_ref); + + // Q_dNext * D_next + let poly_ref = monomials_storage.get_poly(PolyIdentifier::GateSetupPolynomial(name, 6)); + result.add_assign_scaled(&worker, poly_ref, &d_next_value); + + result.scale(&worker, challenges[0]); + + Ok(result) + } + fn add_inputs_into_quotient( + &self, + domain_size: usize, + public_inputs: &[E::Fr], + at: E::Fr, + challenges: &[E::Fr], + ) -> Result { + if public_inputs.len() == 0 { + return Ok(E::Fr::zero()); + } + assert_eq!(challenges.len(), 1); + // just evaluate L_{i}(z) * value + let mut contribution = E::Fr::zero(); + let domain = Domain::::new_for_size(domain_size as u64)?; + for (idx, inp) in public_inputs.iter().enumerate() { + let mut tmp = evaluate_lagrange_poly_at_point(idx, &domain, at)?; + tmp.mul_assign(&inp); + + contribution.add_assign(&tmp); + } + + contribution.mul_assign(&challenges[0]); + + Ok(contribution) + } + fn contribute_into_linearization_commitment_for_public_inputs<'a>( + &self, + _domain_size: usize, + _public_inputs: &[E::Fr], + _at: E::Fr, + queried_values: &std::collections::HashMap, + commitments_storage: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result { + // we actually do not depend on public inputs, but we use this form for consistency + assert_eq!(challenges.len(), 1); + + let mut aggregate = E::G1::zero(); + + let a_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0))) + .ok_or(SynthesisError::AssignmentMissing)?; + let b_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1))) + .ok_or(SynthesisError::AssignmentMissing)?; + let c_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2))) + .ok_or(SynthesisError::AssignmentMissing)?; + let d_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(3))) + .ok_or(SynthesisError::AssignmentMissing)?; + let d_next_value = *queried_values.get(&PolynomialInConstraint::from_id_and_dilation(PolyIdentifier::VariablesPolynomial(3), 1)) + .ok_or(SynthesisError::AssignmentMissing)?; + + let name = >::name(&self); + + // Q_a * A + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 0)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(a_value.into_repr()); + aggregate.add_assign(&scaled); + + // Q_b * B + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 1)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(b_value.into_repr()); + aggregate.add_assign(&scaled); + + // Q_c * C + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 2)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(c_value.into_repr()); + aggregate.add_assign(&scaled); + + // Q_d * D + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 3)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(d_value.into_repr()); + aggregate.add_assign(&scaled); + + // Q_m * A*B + let mut tmp = a_value; + tmp.mul_assign(&b_value); + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 4)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(tmp.into_repr()); + aggregate.add_assign(&scaled); + + // Q_const + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 5)).ok_or(SynthesisError::AssignmentMissing)?; + aggregate.add_assign_mixed(&commitment); + + // Q_dNext * D_next + let commitment = commitments_storage.get(&PolyIdentifier::GateSetupPolynomial(name, 6)).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = commitment.mul(d_next_value.into_repr()); + aggregate.add_assign(&scaled); + + aggregate.mul_assign(challenges[0]); + + Ok(aggregate) + } +} + +pub fn get_from_map_unchecked<'a, 'b: 'a, E: Engine>( + key_with_dilation: PolynomialInConstraint, + ldes_map: &'a AssembledPolynomialStorage<'b, E> +) -> &'a Polynomial { + + let (key, dilation_value) = key_with_dilation.into_id_and_raw_dilation(); + + let r = if dilation_value == 0 { + match key { + k @ PolyIdentifier::VariablesPolynomial(..) => { + ldes_map.state_map.get(&k).expect(&format!("Must get poly {:?} from ldes storage", &k)).as_ref() + }, + k @ PolyIdentifier::WitnessPolynomial(..) => { + ldes_map.witness_map.get(&k).expect(&format!("Must get poly {:?} from ldes storage", &k)).as_ref() + }, + k @ PolyIdentifier::GateSetupPolynomial(..) => { + ldes_map.setup_map.get(&k).expect(&format!("Must get poly {:?} from ldes storage", &k)).as_ref() + }, + _ => { + unreachable!(); + } + } + } else { + ldes_map.scratch_space.get(&key_with_dilation).expect(&format!("Must get poly {:?} from lde storage", &key_with_dilation)).as_ref() + }; + + r +} + +pub fn ensure_in_map_or_create<'a, 'b, E: Engine>( + worker: &Worker, + key_with_dilation: PolynomialInConstraint, + domain_size: usize, + omegas_bitreversed: &BitReversedOmegas, + lde_factor: usize, + coset_factor: E::Fr, + monomials_map: & AssembledPolynomialStorageForMonomialForms<'a, E>, + ldes_map: &mut AssembledPolynomialStorage<'b, E> +) -> Result<(), SynthesisError> { + assert!(ldes_map.is_bitreversed); + assert_eq!(ldes_map.lde_factor, lde_factor); + + let (key, dilation_value) = key_with_dilation.into_id_and_raw_dilation(); + + let mut contains_in_scratch_or_maps = false; + + if dilation_value == 0 { + match key { + k @ PolyIdentifier::VariablesPolynomial(..) => { + if ldes_map.state_map.get(&k).is_some() { + contains_in_scratch_or_maps = true; + } + }, + k @ PolyIdentifier::WitnessPolynomial(..) => { + if ldes_map.witness_map.get(&k).is_some() { + contains_in_scratch_or_maps = true; + } + }, + k @ PolyIdentifier::GateSetupPolynomial(..) => { + if ldes_map.setup_map.get(&k).is_some() { + contains_in_scratch_or_maps = true; + } + }, + _ => { + unreachable!(); + } + } + } else { + if ldes_map.scratch_space.get(&key_with_dilation).is_some() { + contains_in_scratch_or_maps = true; + } + }; + + if !contains_in_scratch_or_maps { + // optimistic case: we have already calculated value without dilation + // but now need to just rotate + let lde_without_dilation = match key { + k @ PolyIdentifier::VariablesPolynomial(..) => { + ldes_map.state_map.get(&k) + }, + k @ PolyIdentifier::WitnessPolynomial(..) => { + ldes_map.witness_map.get(&k) + }, + k @ PolyIdentifier::GateSetupPolynomial(..) => { + ldes_map.setup_map.get(&k) + }, + _ => { + unreachable!(); + } + }; + + let mut done = false; + + let rotated = if let Some(lde) = lde_without_dilation.as_ref() { + let rotation_factor = dilation_value * lde_factor; + let f = lde.as_ref().clone_shifted_assuming_bitreversed(rotation_factor, worker)?; + drop(lde); + + Some(f) + } else { + None + }; + + drop(lde_without_dilation); + + if let Some(f) = rotated { + let proxy = PolynomialProxy::from_owned(f); + ldes_map.scratch_space.insert(key_with_dilation, proxy); + + done = true; + }; + + if !done { + // perform LDE and push + + let monomial = match key { + k @ PolyIdentifier::VariablesPolynomial(..) => { + monomials_map.state_map.get(&k).unwrap().as_ref() + }, + k @ PolyIdentifier::WitnessPolynomial(..) => { + monomials_map.witness_map.get(&k).unwrap().as_ref() + }, + k @ PolyIdentifier::GateSetupPolynomial(..) => { + monomials_map.setup_map.get(&k).unwrap().as_ref() + }, + _ => { + unreachable!(); + } + }; + + let lde = monomial.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + omegas_bitreversed, + &coset_factor + )?; + + let final_lde = if dilation_value != 0 { + let rotation_factor = dilation_value * lde_factor; + let f = lde.clone_shifted_assuming_bitreversed(rotation_factor, worker)?; + drop(lde); + + f + } else { + lde + }; + + // insert back + + let proxy = PolynomialProxy::from_owned(final_lde); + + if dilation_value == 0 { + match key { + k @ PolyIdentifier::VariablesPolynomial(..) => { + ldes_map.state_map.insert(k, proxy); + }, + k @ PolyIdentifier::WitnessPolynomial(..) => { + ldes_map.witness_map.insert(k, proxy); + }, + k @ PolyIdentifier::GateSetupPolynomial(..) => { + ldes_map.setup_map.insert(k, proxy); + }, + _ => { + unreachable!(); + } + } + } else { + ldes_map.scratch_space.insert(key_with_dilation, proxy); + }; + + done = true; + } + + assert!(done); + } + + Ok(()) +} + +struct SimpleBitmap(u64, usize); +impl SimpleBitmap { + fn new() -> Self { + Self(0u64, 0) + } + + fn get_next_unused(&mut self) -> usize { + for i in 0..64 { + if self.get(i) == false { + return i; + } + } + + unreachable!() + } + + fn get(&self, idx: usize) -> bool { + 1u64 << idx & self.0 > 0 + } + + fn set(&mut self, idx: usize) { + self.0 |= 1u64 << idx; + } +} + +pub trait PlonkConstraintSystemParams: Sized + Copy + Clone + Send + Sync { + const STATE_WIDTH: usize; + const WITNESS_WIDTH: usize; + const HAS_WITNESS_POLYNOMIALS: bool; + const HAS_CUSTOM_GATES: bool; + const CAN_ACCESS_NEXT_TRACE_STEP: bool; +} + +use std::sync::Arc; + +pub trait ConstraintSystem { + type Params: PlonkConstraintSystemParams; + type MainGate: MainGate; + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + fn new_single_gate_for_trace_step>(&mut self, + equation: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + self.begin_gates_batch_for_step()?; + self.new_gate_in_batch( + equation, + coefficients_assignments, + variables_assignments, + witness_assignments + )?; + self.end_gates_batch_for_step() + } + + fn get_main_gate(&self) -> &Self::MainGate; + + fn allocate_main_gate(&mut self, term: MainGateTerm) -> Result<(), SynthesisError> { + let (vars, coeffs) = Self::MainGate::format_term(term, Self::get_dummy_variable())?; + + let mg = Self::MainGate::default(); + + self.new_single_gate_for_trace_step( + &mg, + &coeffs, + &vars, + &[] + ) + } + + fn begin_gates_batch_for_step(&mut self) -> Result<(), SynthesisError>; + fn new_gate_in_batch>(&mut self, + equation: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError>; + fn end_gates_batch_for_step(&mut self) -> Result<(), SynthesisError>; + + fn allocate_variables_without_gate(&mut self, + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError>; + + fn get_value(&self, _variable: Variable) -> Result { + Err(SynthesisError::AssignmentMissing) + } + + fn get_dummy_variable() -> Variable; + + fn get_explicit_zero(&mut self) -> Result; + fn get_explicit_one(&mut self) -> Result; + + fn add_table(&mut self, table: LookupTableApplication) -> Result>, SynthesisError>; + fn get_table(&self, functional_name: &str) -> Result>, SynthesisError>; + + fn add_multitable(&mut self, table: MultiTableApplication) -> Result<(), SynthesisError>; + fn get_multitable(&self, functional_name: &str) -> Result>, SynthesisError>; + + fn apply_single_lookup_gate(&mut self, variables: &[Variable], gate: Arc>) -> Result<(), SynthesisError>; + fn apply_multi_lookup_gate(&mut self, variables: &[Variable], gate: Arc>) -> Result<(), SynthesisError>; + + fn get_current_step_number(&self) -> usize; + fn get_current_aux_gate_number(&self) -> usize; +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct PlonkCsWidth4WithNextStepParams; +impl PlonkConstraintSystemParams for PlonkCsWidth4WithNextStepParams { + const STATE_WIDTH: usize = 4; + const WITNESS_WIDTH: usize = 0; + const HAS_WITNESS_POLYNOMIALS: bool = false; + const HAS_CUSTOM_GATES: bool = false; + const CAN_ACCESS_NEXT_TRACE_STEP: bool = true; +} + +#[derive(Clone, Copy, Debug)] +pub struct PlonkCsWidth4WithNextStepAndCustomGatesParams; + +impl PlonkConstraintSystemParams for PlonkCsWidth4WithNextStepAndCustomGatesParams { + const STATE_WIDTH: usize = 4; + const WITNESS_WIDTH: usize = 0; + const HAS_WITNESS_POLYNOMIALS: bool = false; + const HAS_CUSTOM_GATES: bool = true; + const CAN_ACCESS_NEXT_TRACE_STEP: bool = true; +} + +use crate::plonk::polynomials::*; + +#[derive(Clone)] +pub struct PolynomialStorage { + pub state_map: std::collections::HashMap>, + pub witness_map: std::collections::HashMap>, + pub setup_map: std::collections::HashMap>, +} + +impl PolynomialStorage { + pub fn new() -> Self { + Self { + state_map: std::collections::HashMap::new(), + witness_map: std::collections::HashMap::new(), + setup_map: std::collections::HashMap::new(), + } + } + + pub fn get_value(&self, poly: &PolynomialInConstraint, n: usize) -> Result { + match poly { + PolynomialInConstraint(PolyIdentifier::VariablesPolynomial(_), TimeDilation(_)) => { + unreachable!("should not try to get value of the state polynomial, get variable first instead"); + }, + PolynomialInConstraint(PolyIdentifier::GateSetupPolynomial(gate_descr, idx), TimeDilation(dilation)) => { + let final_index = n + dilation; + let identifier = PolyIdentifier::GateSetupPolynomial(gate_descr, *idx); + let value = *self.setup_map + .get(&identifier) + .ok_or(SynthesisError::AssignmentMissing)? + .get(final_index) + .ok_or(SynthesisError::AssignmentMissing)?; + + Ok(value) + }, + PolynomialInConstraint(PolyIdentifier::WitnessPolynomial(_), TimeDilation(_)) => { + unimplemented!() + }, + _ => { + unreachable!(); + } + } + } + + pub fn get_variable(&self, poly: &PolynomialInConstraint, n: usize) -> Result { + match poly { + PolynomialInConstraint(PolyIdentifier::VariablesPolynomial(idx), TimeDilation(dilation)) => { + let final_index = n + dilation; + let identifier = PolyIdentifier::VariablesPolynomial(*idx); + let value = *self.state_map + .get(&identifier) + .ok_or(SynthesisError::AssignmentMissing)? + .get(final_index) + .ok_or(SynthesisError::AssignmentMissing)?; + + Ok(value) + }, + _ => { + unreachable!("should not try to get variable of setup or witness polynomial"); + } + } + } +} + +#[derive(Clone)] +pub struct GateDensityStorage(pub std::collections::HashMap>, BitVec>); + +impl GateDensityStorage { + pub fn new() -> Self { + Self(std::collections::HashMap::new()) + } +} + +pub struct GateConstantCoefficientsStorage(pub std::collections::HashMap>, Vec>); + +impl GateConstantCoefficientsStorage { + pub fn new() -> Self { + Self(std::collections::HashMap::new()) + } +} + +pub type TrivialAssembly = Assembly; +pub type ProvingAssembly = Assembly; +pub type SetupAssembly = Assembly; + +#[derive(Clone)] +pub struct Assembly, MG: MainGate, S: SynthesisMode> { + pub inputs_storage: PolynomialStorage, + pub aux_storage: PolynomialStorage, + pub num_input_gates: usize, + pub num_aux_gates: usize, + pub max_constraint_degree: usize, + pub main_gate: MG, + pub input_assingments: Vec, + pub aux_assingments: Vec, + pub num_inputs: usize, + pub num_aux: usize, + pub trace_step_for_batch: Option, + pub is_finalized: bool, + + pub gates: std::collections::HashSet>>, + pub all_queried_polys_in_constraints: std::collections::HashSet, + // pub sorted_setup_polynomial_ids: Vec, + pub sorted_gates: Vec>>, + pub aux_gate_density: GateDensityStorage, + pub explicit_zero_variable: Option, + pub explicit_one_variable: Option, + + pub tables: Vec>>, + pub multitables: Vec>>, + pub table_selectors: std::collections::HashMap, + pub multitable_selectors: std::collections::HashMap, + pub table_ids_poly: Vec, + pub total_length_of_all_tables: usize, + + pub individual_table_entries: std::collections::HashMap>>, + pub individual_multitable_entries: std::collections::HashMap>>, + pub known_table_ids: Vec, + pub num_table_lookups: usize, + pub num_multitable_lookups: usize, + + _marker_p: std::marker::PhantomData

, + _marker_s: std::marker::PhantomData, +} + +impl, MG: MainGate, S: SynthesisMode> ConstraintSystem for Assembly { + type Params = P; + type MainGate = MG; + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + + self.num_aux += 1; + let index = self.num_aux; + if S::PRODUCE_WITNESS { + let value = value()?; + self.aux_assingments.push(value); + } + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_inputs += 1; + let index = self.num_inputs; + if S::PRODUCE_WITNESS { + let value = value()?; + self.input_assingments.push(value); + } + + let input_var = Variable(Index::Input(index)); + + let mut main_gate = MainGateTerm::::new(); + main_gate.sub_assign(ArithmeticTerm::from_variable(input_var)); + + let dummy = Self::get_dummy_variable(); + let (variables_assignments, coefficients_assignments) = MG::format_term(main_gate, dummy).expect("must make empty padding gate"); + + let n = self.num_input_gates; + Self::allocate_into_storage( + &MG::default(), + &mut self.inputs_storage, + n, + &coefficients_assignments, + &variables_assignments, + &[] + )?; + + self.num_input_gates += 1; + + Ok(input_var) + } + + fn get_main_gate(&self) -> &MG { + &self.main_gate + } + + fn begin_gates_batch_for_step(&mut self) -> Result<(), SynthesisError> { + debug_assert!(self.trace_step_for_batch.is_none()); + self.num_aux_gates += 1; + let n = self.num_aux_gates; + self.trace_step_for_batch = Some(n); + + Ok(()) + } + + fn new_gate_in_batch>(&mut self, + gate: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + // check that gate is ok for config + // debug_assert!(check_gate_is_allowed_for_params::(&gate), format!("supplied params do not work with gate {:?}", gate)); + + let n = self.trace_step_for_batch.unwrap(); + // make zero-enumerated index + let n = n - 1; + + Self::allocate_into_storage( + gate, + &mut self.aux_storage, + n, + coefficients_assignments, + variables_assignments, + witness_assignments, + )?; + + self.add_gate_into_list(gate); + + if S::PRODUCE_SETUP { + if let Some(tracker) = self.aux_gate_density.0.get_mut(gate.as_internal() as &dyn GateInternal) { + if tracker.len() != n { + let padding = n - tracker.len(); + tracker.grow(padding, false); + } + tracker.push(true); + debug_assert_eq!(n+1, tracker.len()); + } else { + self.aux_gate_density.0.insert(gate.clone().into_internal(), BitVec::new()); + let tracker = self.aux_gate_density.0.get_mut(gate.as_internal() as &dyn GateInternal).unwrap(); + tracker.grow(n, false); + tracker.push(true); + debug_assert_eq!(n+1, tracker.len()); + } + } + + Ok(()) + } + + fn allocate_variables_without_gate(&mut self, + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + let n = self.trace_step_for_batch.expect("may only be called in a batch"); + // make zero-enumerated index + let n = n - 1; + + let empty_coefficients = Self::MainGate::empty_coefficients(); + + let gate = Self::MainGate::default(); + + Self::allocate_into_storage( + &gate, + &mut self.aux_storage, + n, + &empty_coefficients, + variables_assignments, + witness_assignments, + )?; + + if S::PRODUCE_SETUP { + let apply_gate = false; + + let tracker = self.aux_gate_density.0.get_mut(gate.as_internal() as &dyn GateInternal).unwrap(); + if tracker.len() != n { + let padding = n - tracker.len(); + tracker.grow(padding, false); + } + tracker.push(apply_gate); + debug_assert_eq!(n+1, tracker.len()); + } + + Ok(()) + } + + fn end_gates_batch_for_step(&mut self) -> Result<(), SynthesisError> { + debug_assert!(self.trace_step_for_batch.is_some()); + let n = self.trace_step_for_batch.take().unwrap(); + debug_assert_eq!(n, self.num_aux_gates, "invalid batch id"); + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + if !S::PRODUCE_WITNESS { + return Err(SynthesisError::AssignmentMissing); + } + let value = match var { + Variable(Index::Aux(0)) => { + // use crate::rand::Rng; + + // let mut rng = crate::rand::thread_rng(); + // let value: E::Fr = rng.gen(); + + // value + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable() -> Variable { + Self::dummy_variable() + } + + fn get_explicit_zero(&mut self) -> Result { + if let Some(var) = self.explicit_zero_variable { + return Ok(var); + } + + let value = E::Fr::zero(); + let zero = self.alloc(|| Ok(value))?; + + let self_term = ArithmeticTerm::from_variable(zero); + let other_term = ArithmeticTerm::constant(value); + let mut term = MainGateTerm::new(); + term.add_assign(self_term); + term.sub_assign(other_term); + + self.allocate_main_gate(term)?; + + self.explicit_zero_variable = Some(zero); + + Ok(zero) + } + + fn get_explicit_one(&mut self) -> Result { + if let Some(var) = self.explicit_one_variable { + return Ok(var); + } + + let value = E::Fr::one(); + let one = self.alloc(|| Ok(value))?; + + let self_term = ArithmeticTerm::from_variable(one); + let other_term = ArithmeticTerm::constant(value); + let mut term = MainGateTerm::new(); + term.add_assign(self_term); + term.sub_assign(other_term); + + self.allocate_main_gate(term)?; + + self.explicit_one_variable = Some(one); + + Ok(one) + } + + fn add_table(&mut self, table: LookupTableApplication) -> Result>, SynthesisError> { + assert!(table.applies_over().len() == 3, "only support tables of width 3"); + assert!(table.can_be_combined(), "can only add tables that are combinable"); + assert!(!self.known_table_ids.contains(&table.table_id())); + let table_name = table.functional_name(); + let table_id = table.table_id(); + let number_of_entries = table.size(); + + let shared = Arc::from(table); + let res = shared.clone(); + + self.tables.push(shared); + self.individual_table_entries.insert(table_name.clone(), vec![]); + self.table_selectors.insert(table_name, BitVec::new()); + self.known_table_ids.push(table_id); + + self.total_length_of_all_tables += number_of_entries; + + Ok(res) + } + + fn get_table(&self, name: &str) -> Result>, SynthesisError> { + for t in self.tables.iter() { + if t.functional_name() == name { + return Ok(Arc::clone(t)); + } + } + + Err(SynthesisError::AssignmentMissing) + } + + fn add_multitable(&mut self, table: MultiTableApplication) -> Result<(), SynthesisError> { + let table_name = table.functional_name(); + let mut exists = false; + for t in self.multitables.iter() { + if t.functional_name() == table_name { + exists = true; + } + } + assert!(exists == false); + self.multitables.push(Arc::from(table)); + self.multitable_selectors.insert(table_name.clone(), BitVec::new()); + self.individual_table_entries.insert(table_name.clone(), vec![]); + + Ok(()) + } + + fn get_multitable(&self, functional_name: &str) -> Result>, SynthesisError> { + for t in self.multitables.iter() { + if t.functional_name() == functional_name { + return Ok(Arc::clone(t)); + } + } + + Err(SynthesisError::AssignmentMissing) + } + + #[track_caller] + fn apply_single_lookup_gate(&mut self, variables: &[Variable], table: Arc>) -> Result<(), SynthesisError> { + let n = self.trace_step_for_batch.expect("may only add table constraint in a transaction"); + // make zero-enumerated index + let n = n - 1; + + if S::PRODUCE_SETUP { + debug_assert!(self.tables.contains(&table)); + assert!(table.can_be_combined() == true); + assert!(table.applies_over().len() == 3); + + let table_name = table.functional_name(); + + // we need to: + // - mark that this table applies at this row + // - add values into the list to later on make a sorted polynomial + + let tracker = self.table_selectors.get_mut(&table_name).unwrap(); + if tracker.len() != n { + let padding = n - tracker.len(); + tracker.grow(padding, false); + } + tracker.push(true); + debug_assert_eq!(n+1, tracker.len()); + + // keep track of what table is applied at what row + self.table_ids_poly.resize(n, E::Fr::zero()); + self.table_ids_poly.push(table.table_id()); + } + + if S::PRODUCE_WITNESS { + let table_name = table.functional_name(); + + // add values for lookup table sorting later + let keys_and_values_len = table.applies_over().len(); + let mut table_entries = Vec::with_capacity(keys_and_values_len + 1); + for v in variables.iter() { + let value = self.get_value(*v).unwrap(); + table_entries.push(value); + } + table_entries.push(table.table_id()); + + let entries = self.individual_table_entries.get_mut(&table_name).unwrap(); + assert_eq!(variables.len(), table.applies_over().len()); + + let valid_entries = table.is_valid_entry(&table_entries[..keys_and_values_len]); + assert!(valid_entries); + + if !valid_entries { + return Err(SynthesisError::Unsatisfiable); + } + + entries.push(table_entries); + } + + self.num_table_lookups += 1; + + Ok(()) + } + + #[track_caller] + fn apply_multi_lookup_gate(&mut self, variables: &[Variable], table: Arc>) -> Result<(), SynthesisError> { + let n = self.trace_step_for_batch.expect("may only add table constraint in a transaction"); + // make zero-enumerated index + let n = n - 1; + + if S::PRODUCE_SETUP { + let table_name = table.functional_name(); + let tracker = self.multitable_selectors.get_mut(&table_name).unwrap(); + if tracker.len() != n { + let padding = n - tracker.len(); + tracker.grow(padding, false); + } + tracker.push(true); + debug_assert_eq!(n+1, tracker.len()); + + self.table_ids_poly.resize(n, E::Fr::zero()); + self.table_ids_poly.push(table.table_id()); + } + + if S::PRODUCE_WITNESS { + let table_name = table.functional_name(); + let mut table_entries = Vec::with_capacity(table.applies_over().len()); + for v in variables.iter() { + let value = self.get_value(*v).unwrap(); + table_entries.push(value); + } + + let entries = self.individual_table_entries.get_mut(&table_name).unwrap(); + assert_eq!(variables.len(), table.applies_over().len()); + + assert!(table.is_valid_entry(&table_entries)); + + entries.push(table_entries); + } + + self.num_multitable_lookups += 1; + + Ok(()) + } + + fn get_current_step_number(&self) -> usize { + self.n() + } + + fn get_current_aux_gate_number(&self) -> usize { + self.num_aux_gates + } +} + +impl, MG: MainGate, S: SynthesisMode> Assembly { + fn allocate_into_storage>( + gate: &G, + storage: &mut PolynomialStorage, + n: usize, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + let dummy = Self::get_dummy_variable(); + let zero = E::Fr::zero(); + + if S::PRODUCE_SETUP { + let mut coeffs_it = coefficients_assignments.iter(); + + for setup_poly in gate.setup_polynomials().into_iter() { + let poly_ref = storage.setup_map.entry(setup_poly).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, E::Fr::zero()); + } + poly_ref.push(*coeffs_it.next().unwrap_or(&zero)); + } + + debug_assert!(coeffs_it.next().is_none(), "must consume all the coefficients for gate"); + + } + + let mut variable_it = variables_assignments.iter(); + + for var_poly in gate.variable_polynomials().into_iter() { + let poly_ref = storage.state_map.entry(var_poly).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, dummy); + } + if poly_ref.len() == n { + // we consume variable only ONCE + let var = *variable_it.next().unwrap_or(&dummy); + poly_ref.push(var); + } + } + + debug_assert!(variable_it.next().is_none(), "must consume all variables for gate"); + + let mut witness_it = witness_assignments.iter(); + + for key in gate.witness_polynomials().into_iter() { + let poly_ref = storage.witness_map.entry(key).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, E::Fr::zero()); + } + poly_ref.push(*witness_it.next().unwrap_or(&zero)); + } + + Ok(()) + } + + pub fn n(&self) -> usize { + self.num_input_gates + self.num_aux_gates + } + + fn add_gate_into_list>(&mut self, gate: &G) { + if !self.gates.contains(gate.as_internal() as &dyn GateInternal) { + self.gates.insert(gate.clone().into_internal()); + + // self.add_gate_setup_polys_into_list(gate); + for p in gate.all_queried_polynomials().into_iter() { + self.all_queried_polys_in_constraints.insert(p); + } + + self.sorted_gates.push(gate.clone().into_internal()); + + let degree = gate.degree(); + if self.max_constraint_degree < degree { + self.max_constraint_degree = degree; + } + } + } + + pub fn new() -> Self { + let mut tmp = Self { + inputs_storage: PolynomialStorage::new(), + aux_storage: PolynomialStorage::new(), + + max_constraint_degree: 0, + + num_input_gates: 0, + num_aux_gates: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + main_gate: MG::default(), + + trace_step_for_batch: None, + + gates: std::collections::HashSet::new(), + all_queried_polys_in_constraints: std::collections::HashSet::new(), + + aux_gate_density: GateDensityStorage::new(), + + // sorted_setup_polynomial_ids: vec![], + sorted_gates: vec![], + + is_finalized: false, + + explicit_zero_variable: None, + explicit_one_variable: None, + + tables: vec![], + multitables: vec![], + table_selectors: std::collections::HashMap::new(), + multitable_selectors: std::collections::HashMap::new(), + table_ids_poly: vec![], + total_length_of_all_tables: 0, + + individual_table_entries: std::collections::HashMap::new(), + individual_multitable_entries: std::collections::HashMap::new(), + + known_table_ids: vec![], + + num_table_lookups: 0, + num_multitable_lookups: 0, + + _marker_p: std::marker::PhantomData, + _marker_s: std::marker::PhantomData, + }; + + tmp.add_gate_into_list(&MG::default()); + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable() -> Variable { + Variable(Index::Aux(0)) + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let mut min_space_for_lookups = self.num_table_lookups; + for table in self.tables.iter() { + let table_num_rows = table.size(); + min_space_for_lookups += table_num_rows; + } + min_space_for_lookups += self.n(); + + let new_size_candidates = [(self.n() + 1).next_power_of_two() - 1, (min_space_for_lookups + 1).next_power_of_two() - 1]; + + let new_size = *new_size_candidates.iter().max().unwrap(); + + let dummy = Self::get_dummy_variable(); + + // let empty_gate = MainGateTerm::::new(); + let empty_vars = vec![dummy; >::Params::STATE_WIDTH]; + let empty_witness = vec![E::Fr::zero(); >::Params::WITNESS_WIDTH]; + + // let mg = MG::default(); + + for _ in self.n()..new_size { + + self.begin_gates_batch_for_step().unwrap(); + + self.allocate_variables_without_gate( + &empty_vars, + &empty_witness + ).unwrap(); + + self.end_gates_batch_for_step().unwrap(); + + // self.new_single_gate_for_trace_step( + // &mg, + // &coeffs, + // &vars, + // &[] + // ).expect("must add padding gate"); + } + + let new_size_for_aux = new_size - self.num_input_gates; + + if S::PRODUCE_SETUP { + // pad gate selectors + for (_, tracker) in self.aux_gate_density.0.iter_mut() { + tracker.grow(new_size_for_aux, false); + } + + // pad lookup selectors + for (_, selector) in self.table_selectors.iter_mut() { + selector.grow(new_size_for_aux, false); + } + + // pad special purpose table selector poly + self.table_ids_poly.resize(new_size_for_aux, E::Fr::zero()); + } + + assert!((self.n()+1).is_power_of_two()); + self.is_finalized = true; + } + + fn get_storage_for_trace_step(&self, step: usize) -> &PolynomialStorage { + if step < self.num_input_gates { + &self.inputs_storage + } else { + &self.aux_storage + } + } + + pub fn is_satisfied(&self) -> bool { + if !S::PRODUCE_SETUP || !S::PRODUCE_WITNESS { + // only testing mode can run this check for now + return true; + } + // expect a small number of inputs + + if self.n() == 0 { + return true; + } + + // TODO: handle public inputs + + // for i in 0..self.num_input_gates { + // let gate = self.input_assingments + // } + + // let one = E::Fr::one(); + // let mut minus_one = E::Fr::one(); + // minus_one.negate(); + + let n = self.n() - 1; + + let worker = Worker::new(); + + let storage = self.make_assembled_poly_storage(&worker, false).unwrap(); + + for (gate_type, density) in self.aux_gate_density.0.iter() { + for (gate_index, is_applicable) in density.iter().enumerate() { + if is_applicable == false { + continue; + } + + let trace_index = self.num_input_gates + gate_index; + + let last = trace_index == n; + + let value = gate_type.verify_on_row(trace_index, &storage, last); + + if value.is_zero() == false { + println!("Unsatisfied at aux gate {} (zero enumerated)", gate_index); + println!("Constraint value = {}", value); + println!("Gate {:?}", gate_type.name()); + return false; + } + } + } + + true + } + + pub(crate) fn make_permutations(&self, worker: &Worker) -> Result>, SynthesisError> { + assert!(self.is_finalized); + + if !S::PRODUCE_SETUP { + return Err(SynthesisError::AssignmentMissing); + } + + let num_gates = self.n(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + let mut poly_ids = vec![]; + for i in 0..P::STATE_WIDTH { + let id = PolyIdentifier::VariablesPolynomial(i); + poly_ids.push(id); + } + + // gate_idx is zero-enumerated here + for gate_idx in 0..num_gates + { + let storage = self.get_storage_for_trace_step(gate_idx); + for (state_poly_index, poly_id) in poly_ids.iter().enumerate() { + let variables_vec_ref = storage.state_map.get(&poly_id).expect("must get a variables polynomial"); + let storage_idx = if gate_idx < self.num_input_gates { + gate_idx + } else { + gate_idx - self.num_input_gates + }; + + let v = variables_vec_ref[storage_idx]; + match v { + Variable(Index::Aux(0)) => { + // Dummy variables do not participate in the permutation + }, + Variable(Index::Input(0)) => { + unreachable!("There must be no input with index 0"); + }, + Variable(Index::Input(index)) => { + let i = index; // inputs are [1, num_inputs] + partitions[i].push((state_poly_index, gate_idx+1)); + }, + Variable(Index::Aux(index)) => { + let i = index + num_inputs; // aux are [num_inputs + 1, ..] + partitions[i].push((state_poly_index, gate_idx+1)); + }, + } + } + } + + // sanity check + assert_eq!(partitions[0].len(), 0); + + let domain = Domain::new_for_size(num_gates as u64).expect("must have enough roots of unity to fit the circuit"); + + // now we need to make root at it's cosets + let domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, &worker + ); + + // domain_elements.pop().unwrap(); + + use crate::ff::SqrtField; + use crate::ff::LegendreSymbol; + + let mut non_residues = vec![]; + non_residues.push(E::Fr::one()); + non_residues.extend(make_non_residues::(P::STATE_WIDTH - 1)); + + assert_eq!(non_residues.len(), 4); + + let mut sigmas = vec![]; + for i in 0..P::STATE_WIDTH { + let mut sigma_i = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_i.scale(&worker, non_residues[i]); + sigmas.push(sigma_i); + } + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 1 { + let mut els: Vec<_> = vec.drain(0..1).collect(); + debug_assert_eq!(els.len(), 1); + // els.reverse(); + vec.push(els.pop().unwrap()); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + // we do not need to permute over partitions of length 1, + // as this variable only happends in one place + if partition.len() == 1 { + continue; + } + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + // (column_idx, trace_step_idx) + let new_zero_enumerated = new.1 - 1; + let mut new_value = domain_elements[new_zero_enumerated]; + + // we have shuffled the values, so we need to determine FROM + // which of k_i * {1, omega, ...} cosets we take a value + // for a permutation polynomial + new_value.mul_assign(&non_residues[new.0]); + + // check to what witness polynomial the variable belongs + let place_into = &mut sigmas[original.0].as_mut(); + + let original_zero_enumerated = original.1 - 1; + place_into[original_zero_enumerated] = new_value; + } + } + + Ok(sigmas) + } + + fn make_setup_polynomials( + &self, + with_finalization: bool + ) -> Result>, SynthesisError> { + if with_finalization { + assert!(self.is_finalized); + } + + if !S::PRODUCE_SETUP { + return Err(SynthesisError::AssignmentMissing); + } + + let total_num_gates = self.n(); + let num_input_gates = self.num_input_gates; + + let mut map = std::collections::HashMap::new(); + + let setup_poly_ids: Vec<_> = self.aux_storage.setup_map.keys().collect(); + + for &id in setup_poly_ids.into_iter() { + let mut assembled_poly = vec![E::Fr::zero(); total_num_gates]; + if num_input_gates != 0 { + let input_gates_coeffs = &mut assembled_poly[..num_input_gates]; + input_gates_coeffs.copy_from_slice(&self.inputs_storage.setup_map.get(&id).unwrap()[..]); + } + + { + let src = &self.aux_storage.setup_map.get(&id).unwrap()[..]; + let src_len = src.len(); + let aux_gates_coeffs = &mut assembled_poly[num_input_gates..(num_input_gates+src_len)]; + aux_gates_coeffs.copy_from_slice(src); + } + + let as_poly = Polynomial::from_values_unpadded(assembled_poly)?; + + map.insert(id, as_poly); + } + + Ok(map) + } + + #[track_caller] + pub fn create_setup>( + &self, + worker: &Worker + ) -> Result, SynthesisError> { + assert!(self.is_finalized); + + assert!(S::PRODUCE_SETUP); + + let claimed_gates_list = C::declare_used_gates()?; + let known_gates_list = &self.sorted_gates; + + assert_eq!(&claimed_gates_list, known_gates_list, "trying to perform setup for a circuit that has different gates set from synthesized one: circuit claims {:?}, in synthesis we had {:?}", &claimed_gates_list, &known_gates_list); + + // check for consistency + { + assert!(&>::MainGate::default().into_internal() == &claimed_gates_list[0]); + assert!(&C::MainGate::default().into_internal() == &claimed_gates_list[0]); + // dbg!(&claimed_gates_list[0]); + // let as_any = (&claimed_gates_list[0]) as &dyn std::any::Any; + // match as_any.downcast_ref::<>::MainGate>() { + // Some(..) => { + + // }, + // None => { + // println!("Type mismatch: first gate among used gates must be the main gate of CS"); + // // panic!("first gate among used gates must be the main gate of CS"); + // } + // } + } + + let mut setup = Setup::::empty(); + + setup.n = self.n(); + setup.num_inputs = self.num_inputs; + setup.state_width = >::Params::STATE_WIDTH; + setup.num_witness_polys = >::Params::WITNESS_WIDTH; + + setup.non_residues = make_non_residues::(setup.state_width - 1); + + let (mut setup_polys_values_map, permutation_polys) = self.perform_setup(&worker)?; + for gate in known_gates_list.iter() { + let setup_polys = gate.setup_polynomials(); + for id in setup_polys.into_iter() { + let values = setup_polys_values_map.remove(&id).expect("must contain setup poly").clone_padded_to_domain()?; + let mon = values.icoset_fft_for_generator(&worker, &E::Fr::one()); + + setup.gate_setup_monomials.push(mon); + } + } + + for perm in permutation_polys.into_iter() { + let mon = perm.icoset_fft_for_generator(&worker, &E::Fr::one()); + + setup.permutation_monomials.push(mon); + } + + let gate_selector_values = self.output_gate_selectors(&worker)?; + + if known_gates_list.len() > 1 { + assert_eq!(gate_selector_values.len(), known_gates_list.len(), "numbers of selectors and known gates mismatch"); + } + + for values in gate_selector_values.into_iter() { + let poly = Polynomial::from_values(values)?; + let mon = poly.icoset_fft_for_generator(&worker, &E::Fr::one()); + + setup.gate_selectors_monomials.push(mon); + } + + if self.tables.len() > 0 && self.num_table_lookups > 0 { + // we have lookup tables, so add them to setup + + let num_lookups = self.num_table_lookups; + setup.total_lookup_entries_length = num_lookups; + + let table_tails = self.calculate_t_polynomial_values_for_single_application_tables()?; + assert_eq!(table_tails.len(), 4); + + let tails_len = table_tails[0].len(); + + // total number of gates, Input + Aux + let size = self.n(); + + let copy_start = size - tails_len; + + for tail in table_tails.into_iter() { + let mut values = vec![E::Fr::zero(); size]; + values[copy_start..].copy_from_slice(&tail[..]); + + let poly = Polynomial::from_values(values)?; + let mon = poly.icoset_fft_for_generator(&worker, &E::Fr::one()); + + setup.lookup_tables_monomials.push(mon); + } + + let selector_for_lookup_values = self.calculate_lookup_selector_values()?; + let poly = Polynomial::from_values(selector_for_lookup_values)?; + let mon = poly.icoset_fft_for_generator(&worker, &E::Fr::one()); + setup.lookup_selector_monomial = Some(mon); + + let table_type_values = self.calculate_table_type_values()?; + let poly = Polynomial::from_values(table_type_values)?; + let mon = poly.icoset_fft_for_generator(&worker, &E::Fr::one()); + setup.lookup_table_type_monomial = Some(mon); + } + + Ok(setup) + } + + pub fn perform_setup( + &self, + worker: &Worker + ) -> Result< + (std::collections::HashMap>, Vec>), + SynthesisError + > { + let map = self.make_setup_polynomials(true)?; + let permutation_polys = self.make_permutations(&worker)?; + + Ok((map, permutation_polys)) + } + + pub fn output_gate_selectors(&self, worker: &Worker) -> Result>, SynthesisError> { + if self.sorted_gates.len() == 1 { + return Ok(vec![]); + } + + let num_gate_selectors = self.sorted_gates.len(); + + let one = E::Fr::one(); + let empty_poly_values = vec![E::Fr::zero(); self.n()]; + let mut poly_values = vec![empty_poly_values.clone(); num_gate_selectors]; + let num_input_gates = self.num_input_gates; + + // first gate in sorted in a main gate and applies on public inputs + for p in poly_values[0][..num_input_gates].iter_mut() { + *p = one; + } + + worker.scope(poly_values.len(), |scope, chunk| { + for (i, lh) in poly_values.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // we take `values_per_leaf` values from each of the polynomial + // and push them into the conbinations + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let id = &self.sorted_gates[idx]; + let density = self.aux_gate_density.0.get(id).unwrap(); + let poly_mut_slice: &mut [E::Fr] = &mut lh[num_input_gates..]; + for (i, d) in density.iter().enumerate() { + if d { + poly_mut_slice[i] = one; + } + } + } + }); + } + }); + + Ok(poly_values) + } + + pub fn calculate_t_polynomial_values_for_single_application_tables(&self) -> + Result>, SynthesisError> { + + if !S::PRODUCE_SETUP { + return Err(SynthesisError::AssignmentMissing); + } + + if self.tables.len() == 0 { + return Ok(vec![]) + } + + // we should pass over every table and append it + + let mut width = 0; + for table in self.tables.iter() { + if width == 0 { + width = table.width(); + } else { + assert_eq!(width, table.width()); + } + } + + assert_eq!(width, 3, "only support tables that span over 3 polynomials for now"); + + let mut column_contributions = vec![vec![]; width + 1]; + + for table in self.tables.iter() { + let entries = table.get_table_values_for_polys(); + // these are individual column vectors, so just copy + for (idx, e) in entries.into_iter().enumerate() { + column_contributions[idx].extend(e); + } + + let table_id = table.table_id(); + let pad_to_len = column_contributions[0].len(); + + column_contributions.last_mut().unwrap().resize(pad_to_len, table_id); + } + + + Ok(column_contributions) + } + + pub fn calculate_interleaved_t_polys(&self) -> + Result>, SynthesisError> { + assert!(self.is_finalized); + + if self.tables.len() == 0 { + return Ok(vec![]) + } + + // we should pass over every table and append it + + let mut width = 0; + for table in self.tables.iter() { + if width == 0 { + width = table.width(); + } else { + assert_eq!(width, table.width()); + } + } + + assert_eq!(width, 3, "only support tables that span over 3 polynomials for now"); + + assert!(self.is_finalized); + if self.tables.len() == 0 { + return Ok(vec![]); + } + + // total number of gates, Input + Aux + let size = self.n(); + + let aux_gates_start = self.num_input_gates; + + let mut contributions = vec![vec![E::Fr::zero(); size]; 4]; + + // make it shifted for ease of rotations later one + let mut place_into_idx = aux_gates_start + 1; + + let lookup_selector = self.calculate_lookup_selector_values()?; + + for single_application in self.tables.iter() { + let entries = single_application.get_table_values_for_polys(); + assert_eq!(entries.len(), 3); + let table_id = single_application.table_id(); + let num_entries = single_application.size(); + + assert_eq!(entries[0].len(), num_entries); + + for entry_idx in 0..num_entries { + 'inner: loop { + if lookup_selector[place_into_idx].is_zero() { + // we can place a table row into the poly + for column in 0..3 { + contributions[column][place_into_idx] = entries[column][entry_idx]; + } + contributions[3][place_into_idx] = table_id; + place_into_idx += 1; + + break 'inner; + } else { + // go for a next one + place_into_idx += 1; + } + } + } + } + + Ok(contributions) + } + + pub fn calculate_s_poly_contributions_from_witness(&self) -> + Result>, SynthesisError> + { + if self.tables.len() == 0 { + return Ok(vec![]); + } + // we first form a set of all occured witness values, + // then include table entries to the set + // and then sort this set + + let mut kv_set_entries = vec![]; + let mut contributions_per_column = vec![vec![]; 4]; + for single_application in self.tables.iter() { + // copy all queries from witness + let table_name = single_application.functional_name(); + for kv_values in self.individual_table_entries.get(&table_name).unwrap() { + let entry = KeyValueSet::::from_slice(&kv_values[..3]); + kv_set_entries.push(entry); + } + + // copy table elements themselves + + let entries = single_application.get_table_values_for_polys(); + // those are full values of polynomials, so we have to virtually transpose + + let size = entries[0].len(); + for i in 0..size { + let entry = KeyValueSet::new([entries[0][i], entries[1][i], entries[2][i]]); + kv_set_entries.push(entry) + } + + kv_set_entries.sort(); + + // now copy backward with addition of the table id + + for kv in kv_set_entries.iter() { + for i in 0..3 { + contributions_per_column[i].push(kv.inner[i]); + } + } + + let table_id = single_application.table_id(); + let pad_to_len = contributions_per_column[0].len(); + contributions_per_column.last_mut().unwrap().resize(pad_to_len, table_id); + + kv_set_entries.truncate(0); + } + + Ok(contributions_per_column) + } + + pub fn calculate_table_type_values( + &self + ) -> + Result, SynthesisError> + { + assert!(self.is_finalized); + + if !S::PRODUCE_SETUP { + return Err(SynthesisError::AssignmentMissing); + } + + if self.tables.len() == 0 { + return Ok(vec![]); + } + + let table_ids_vector_on_aux_gates = &self.table_ids_poly; + + let num_aux_gates = self.num_aux_gates; + + // total number of gates, Input + Aux + let size = self.n(); + + let aux_gates_start = self.num_input_gates; + let aux_gates_end = aux_gates_start + num_aux_gates; + + let mut values = vec![E::Fr::zero(); size]; + assert_eq!(num_aux_gates, table_ids_vector_on_aux_gates.len()); + + values[aux_gates_start..aux_gates_end].copy_from_slice(table_ids_vector_on_aux_gates); + + Ok(values) + } + + pub fn calculate_lookup_selector_values( + &self + ) -> Result, SynthesisError> { + assert!(self.is_finalized); + + if !S::PRODUCE_SETUP { + return Err(SynthesisError::AssignmentMissing); + } + + if self.tables.len() == 0 { + return Ok(vec![]); + } + + // total number of gates, Input + Aux + let size = self.n(); + + let aux_gates_start = self.num_input_gates; + + let num_aux_gates = self.num_aux_gates; + // input + aux gates without t-polys + + let mut lookup_selector_values = vec![E::Fr::zero(); size]; + + for single_application in self.tables.iter() { + let table_name = single_application.functional_name(); + let selector_bitvec = self.table_selectors.get(&table_name).unwrap(); + + for aux_gate_idx in 0..num_aux_gates { + if selector_bitvec[aux_gate_idx] { + let global_gate_idx = aux_gate_idx + aux_gates_start; + // place 1 into selector + lookup_selector_values[global_gate_idx] = E::Fr::one(); + } + } + } + + Ok(lookup_selector_values) + } + + pub fn calculate_masked_lookup_entries( + &self, + storage: &AssembledPolynomialStorage + ) -> + Result>, SynthesisError> + { + assert!(self.is_finalized); + if self.tables.len() == 0 { + return Ok(vec![]); + } + + // total number of gates, Input + Aux + let size = self.n(); + + let aux_gates_start = self.num_input_gates; + + let num_aux_gates = self.num_aux_gates; + // input + aux gates without t-polys + + let mut contributions_per_column = vec![vec![E::Fr::zero(); size]; 3]; + for single_application in self.tables.iter() { + let table_name = single_application.functional_name(); + let keys_and_values = single_application.applies_over(); + let selector_bitvec = self.table_selectors.get(&table_name).unwrap(); + + for aux_gate_idx in 0..num_aux_gates { + if selector_bitvec[aux_gate_idx] { + let global_gate_idx = aux_gate_idx + aux_gates_start; + + // place value into f poly + for (idx, &poly_id) in keys_and_values.iter().enumerate() { + let value = storage.get_poly_at_step(poly_id, global_gate_idx); + contributions_per_column[idx][global_gate_idx] = value; + } + } + } + } + + Ok(contributions_per_column) + } + + pub fn calculate_masked_lookup_entries_using_selector<'a>( + &self, + storage: &AssembledPolynomialStorage, + selector: &PolynomialProxy<'a, E::Fr, Values> + ) -> + Result>, SynthesisError> + { + assert!(self.is_finalized); + if self.tables.len() == 0 { + return Ok(vec![]); + } + + // total number of gates, Input + Aux + let size = self.n(); + + let aux_gates_start = self.num_input_gates; + + let num_aux_gates = self.num_aux_gates; + // input + aux gates without t-polys + + let selector_ref = selector.as_ref().as_ref(); + + let one = E::Fr::one(); + + let mut contributions_per_column = vec![vec![E::Fr::zero(); size]; 3]; + for single_application in self.tables.iter() { + let keys_and_values = single_application.applies_over(); + + for aux_gate_idx in 0..num_aux_gates { + let global_gate_idx = aux_gate_idx + aux_gates_start; + + if selector_ref[global_gate_idx] == one { + // place value into f poly + for (idx, &poly_id) in keys_and_values.iter().enumerate() { + let value = storage.get_poly_at_step(poly_id, global_gate_idx); + contributions_per_column[idx][global_gate_idx] = value; + } + } + } + } + + Ok(contributions_per_column) + } + + fn sort_by_t( + witness_entries: &Vec>, + table_entries: &Vec>, + ) -> Result< Vec>, SynthesisError> { + assert_eq!(witness_entries.len(), table_entries.len()); + + if witness_entries.len() == 0 { + return Ok(vec![]); + } + + // make s = f sorted by t (elements in s appear in the same order as elements in t) + + let entries_len = table_entries[0].len(); + let witnesses_len = witness_entries[0].len(); + + let mut index_lookups_for_sorting = vec![std::collections::HashMap::with_capacity(entries_len); witness_entries.len()]; + + for (idx, table) in table_entries.iter().enumerate() { + for (entry_index, &entry_value) in table.iter().enumerate() { + // make a reverse lookup field element -> index + index_lookups_for_sorting[idx].insert(entry_value, entry_index); + } + } + + let mut column_contributions = vec![]; + + for (idx, witness_column) in witness_entries.iter().enumerate() { + let mut indexes = vec![usize::max_value(); witnesses_len]; + for (witness_index, witness_value) in witness_column.iter().enumerate() { + let reverse_lookup_index = index_lookups_for_sorting[idx].get(witness_value).unwrap(); + indexes[witness_index] = *reverse_lookup_index; + } + + indexes.sort(); + + println!("sorted_index = {:?}", indexes); + + let mut s_for_column = Vec::with_capacity(witnesses_len); + + for sorted_index in indexes.into_iter() { + let table = &table_entries[idx]; + s_for_column.push(table[sorted_index]); + } + + column_contributions.push(s_for_column); + } + + + Ok(column_contributions) + } + + pub fn make_state_and_witness_polynomials( + &self, + worker: &Worker, + with_finalization: bool + ) -> Result<(Vec>, Vec>), SynthesisError> + { + if with_finalization { + assert!(self.is_finalized); + } + + if !S::PRODUCE_WITNESS { + return Err(SynthesisError::AssignmentMissing); + } + + let mut full_assignments = if with_finalization { + vec![Vec::with_capacity((self.n()+1).next_power_of_two()); P::STATE_WIDTH] + } else { + vec![Vec::with_capacity(self.n()+1); P::STATE_WIDTH] + }; + + let pad_to = if with_finalization { + (self.n()+1).next_power_of_two() + } else { + self.n()+1 + }; + + let num_input_gates = self.num_input_gates; + let num_aux_gates = self.num_aux_gates; + + full_assignments[0].extend_from_slice(&self.input_assingments); + assert!(full_assignments[0].len() == num_input_gates); + for i in 1..P::STATE_WIDTH { + full_assignments[i].resize(num_input_gates, E::Fr::zero()); + } + + let dummy = Self::get_dummy_variable(); + + worker.scope(full_assignments.len(), |scope, chunk| { + for (i, lh) in full_assignments.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // we take `values_per_leaf` values from each of the polynomial + // and push them into the conbinations + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let id = PolyIdentifier::VariablesPolynomial(idx); + let poly_ref = self.aux_storage.state_map.get(&id).unwrap(); + for i in 0..num_aux_gates { + let var = poly_ref.get(i).unwrap_or(&dummy); + let value = self.get_value(*var).unwrap(); + lh.push(value); + } + } + }); + } + }); + + for p in full_assignments.iter_mut() { + p.resize(pad_to - 1, E::Fr::zero()); + } + + for a in full_assignments.iter() { + assert_eq!(a.len(), pad_to - 1); + } + + Ok((full_assignments, vec![])) + } + + pub fn make_assembled_poly_storage<'a>( + &self, + worker: &Worker, + with_finalization: bool + ) -> Result, SynthesisError> { + if with_finalization { + assert!(self.is_finalized); + } + + let (state_polys, witness_polys) = self.make_state_and_witness_polynomials(&worker, with_finalization)?; + + let mut state_polys_map = std::collections::HashMap::new(); + for (idx, poly) in state_polys.into_iter().enumerate() { + let key = PolyIdentifier::VariablesPolynomial(idx); + let p = Polynomial::from_values_unpadded(poly)?; + let p = PolynomialProxy::from_owned(p); + state_polys_map.insert(key, p); + } + + let mut witness_polys_map = std::collections::HashMap::new(); + for (idx, poly) in witness_polys.into_iter().enumerate() { + let key = PolyIdentifier::WitnessPolynomial(idx); + let p = Polynomial::from_values_unpadded(poly)?; + let p = PolynomialProxy::from_owned(p); + witness_polys_map.insert(key, p); + } + + let mut setup_map = std::collections::HashMap::new(); + let mut gate_selectors_map = std::collections::HashMap::new(); + + if S::PRODUCE_SETUP { + let setup_polys_map = self.make_setup_polynomials(with_finalization)?; + let gate_selectors = self.output_gate_selectors(&worker)?; + + for (gate, poly) in self.sorted_gates.iter().zip(gate_selectors.into_iter()) { + // let key = gate.clone(); + let key = PolyIdentifier::GateSelector(gate.name()); + let p = Polynomial::from_values_unpadded(poly)?; + let p = PolynomialProxy::from_owned(p); + gate_selectors_map.insert(key, p); + } + + for (key, p) in setup_polys_map.into_iter() { + let p = PolynomialProxy::from_owned(p); + setup_map.insert(key, p); + } + } + + let assembled = AssembledPolynomialStorage:: { + state_map: state_polys_map, + witness_map: witness_polys_map, + setup_map: setup_map, + scratch_space: std::collections::HashMap::new(), + gate_selectors: gate_selectors_map, + named_polys: std::collections::HashMap::new(), + is_bitreversed: false, + lde_factor: 1 + }; + + Ok(assembled) + } + + pub fn create_monomial_storage<'a, 'b>( + worker: &Worker, + omegas_inv: &OmegasInvBitreversed, + value_form_storage: &'a AssembledPolynomialStorage, + include_setup: bool, + ) -> Result, SynthesisError> { + assert_eq!(value_form_storage.lde_factor, 1); + assert!(value_form_storage.is_bitreversed == false); + + let mut monomial_storage = AssembledPolynomialStorageForMonomialForms::::new(); + + for (&k, v) in value_form_storage.state_map.iter() { + let mon_form = v.as_ref().clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + omegas_inv, + &E::Fr::one() + )?; + let mon_form = PolynomialProxy::from_owned(mon_form); + monomial_storage.state_map.insert(k, mon_form); + } + + for (&k, v) in value_form_storage.witness_map.iter() { + let mon_form = v.as_ref().clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + omegas_inv, + &E::Fr::one() + )?; + let mon_form = PolynomialProxy::from_owned(mon_form); + monomial_storage.witness_map.insert(k, mon_form); + } + + if include_setup { + for (&k, v) in value_form_storage.gate_selectors.iter() { + let mon_form = v.as_ref().clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + omegas_inv, + &E::Fr::one() + )?; + let mon_form = PolynomialProxy::from_owned(mon_form); + monomial_storage.gate_selectors.insert(k, mon_form); + } + + for (&k, v) in value_form_storage.setup_map.iter() { + let mon_form = v.as_ref().clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + omegas_inv, + &E::Fr::one() + )?; + let mon_form = PolynomialProxy::from_owned(mon_form); + monomial_storage.setup_map.insert(k, mon_form); + } + } + + Ok(monomial_storage) + } + + pub fn prover_stub(self, worker: &Worker) -> Result<(), SynthesisError> { + use crate::pairing::CurveAffine; + + assert!(self.is_finalized); + + let num_state_polys = >::Params::STATE_WIDTH; + let num_witness_polys = >::Params::WITNESS_WIDTH; + + let mut values_storage = self.make_assembled_poly_storage(worker, true)?; + let permutation_polys = self.make_permutations(&worker)?; + assert_eq!(permutation_polys.len(), num_state_polys); + + for (idx, poly) in permutation_polys.into_iter().enumerate() { + let key = PolyIdentifier::PermutationPolynomial(idx); + let poly = PolynomialProxy::from_owned(poly); + values_storage.setup_map.insert(key, poly); + } + + let required_domain_size = self.n() + 1; + assert!(required_domain_size.is_power_of_two()); + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(required_domain_size); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(required_domain_size); + + let mut ldes_storage = AssembledPolynomialStorage::::new( + true, + self.max_constraint_degree.next_power_of_two() + ); + let monomials_storage = Self::create_monomial_storage( + &worker, + &omegas_inv_bitreversed, + &values_storage, + true + )?; + + // step 1 - commit state and witness, enumerated. Also commit sorted polynomials for table arguments + let mut commitments = vec![]; + + for i in 0..num_state_polys { + // TODO + let id = PolyIdentifier::VariablesPolynomial(i); + let commitment = E::G1Affine::zero(); + commitments.push(commitment); + } + + for i in 0..num_witness_polys { + // TODO + let id = PolyIdentifier::WitnessPolynomial(i); + let commitment = E::G1Affine::zero(); + commitments.push(commitment); + } + + // step 1.5 - if there are lookup tables then draw random "eta" to linearlize over tables + let mut lookup_data: Option> = if self.tables.len() > 0 { + // TODO: Some of those values are actually part of the setup, but deal with it later + + let eta = E::Fr::from_str("987").unwrap(); + + // these are selected rows from witness (where lookup applies) + // TODO: split and output selector without calculating witness + + let selector_for_lookup_values = self.calculate_lookup_selector_values()?; + let table_type_values = self.calculate_table_type_values()?; + + let mut table_contributions_values = self.calculate_masked_lookup_entries(&values_storage)?; + + assert_eq!(table_contributions_values.len(), 3); + + let witness_len = table_contributions_values[0].len(); + assert_eq!(witness_len, required_domain_size - 1); + + let mut f_poly_values_aggregated = table_contributions_values.drain(0..1).collect::>().pop().unwrap(); + + let mut current = eta; + for t in table_contributions_values.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut f_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + // add table type marker + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut f_poly_values_aggregated, &table_type_values); + + let table_type_poly_monomial = { + let mon = Polynomial::from_values(table_type_values)?; + let mon = mon.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + mon + }; + + // these are unsorted rows of lookup tables + let mut t_poly_ends = self.calculate_t_polynomial_values_for_single_application_tables()?; + + assert_eq!(t_poly_ends.len(), 4); + + let mut t_poly_values_aggregated = t_poly_ends.drain(0..1).collect::>().pop().unwrap(); + let mut current = eta; + for t in t_poly_ends.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut t_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + let copy_start = witness_len - t_poly_values_aggregated.len(); + let mut full_t_poly_values = vec![E::Fr::zero(); witness_len]; + let mut full_t_poly_values_shifted = full_t_poly_values.clone(); + + full_t_poly_values[copy_start..].copy_from_slice(&t_poly_values_aggregated); + full_t_poly_values_shifted[(copy_start - 1)..(witness_len-1)].copy_from_slice(&t_poly_values_aggregated); + + assert!(full_t_poly_values[0].is_zero()); + + dbg!(&full_t_poly_values); + + // // these are unsorted rows of lookup tables + // let mut interleaved_t_polys = self.calculate_interleaved_t_polys()?; + + // assert_eq!(interleaved_t_polys.len(), 4); + // assert_eq!(interleaved_t_polys[0].len(), witness_len); + + // let mut t_poly_values_aggregated = interleaved_t_polys.drain(0..1).collect::>().pop().unwrap(); + // let mut current = eta; + // for t in interleaved_t_polys.into_iter() { + // let op = BinopAddAssignScaled::new(current); + // binop_over_slices(&worker, &op, &mut t_poly_values_aggregated, &t); + + // current.mul_assign(&eta); + // } + + // let mut full_t_poly_values = vec![E::Fr::zero(); witness_len]; + // let mut full_t_poly_values_shifted = full_t_poly_values.clone(); + + // full_t_poly_values[..].copy_from_slice(&t_poly_values_aggregated); + // full_t_poly_values_shifted[..(witness_len-1)].copy_from_slice(&t_poly_values_aggregated[1..]); + + // assert!(full_t_poly_values[0].is_zero()); + + let mut s_poly_ends = self.calculate_s_poly_contributions_from_witness()?; + assert_eq!(s_poly_ends.len(), 4); + + let mut s_poly_values_aggregated = s_poly_ends.drain(0..1).collect::>().pop().unwrap(); + let mut current = eta; + for t in s_poly_ends.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut s_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + let sorted_copy_start = witness_len - s_poly_values_aggregated.len(); + + let mut full_s_poly_values = vec![E::Fr::zero(); witness_len]; + let mut full_s_poly_values_shifted = full_s_poly_values.clone(); + + full_s_poly_values[sorted_copy_start..].copy_from_slice(&s_poly_values_aggregated); + full_s_poly_values_shifted[(sorted_copy_start - 1)..(witness_len-1)].copy_from_slice(&s_poly_values_aggregated); + + assert!(full_s_poly_values[0].is_zero()); + + let selector_poly = Polynomial::::from_values(selector_for_lookup_values)?.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + let data = lookup_tables::LookupDataHolder:: { + eta, + f_poly_unpadded_values: Some(Polynomial::from_values_unpadded(f_poly_values_aggregated)?), + t_poly_unpadded_values: Some(Polynomial::from_values_unpadded(full_t_poly_values)?), + t_shifted_unpadded_values: Some(Polynomial::from_values_unpadded(full_t_poly_values_shifted)?), + s_poly_unpadded_values: Some(Polynomial::from_values_unpadded(full_s_poly_values)?), + s_shifted_unpadded_values: Some(Polynomial::from_values_unpadded(full_s_poly_values_shifted)?), + // f_poly_monomial: None, + t_poly_monomial: None, + s_poly_monomial: None, + selector_poly_monomial: Some(selector_poly), + table_type_poly_monomial: Some(table_type_poly_monomial), + }; + + Some(data) + } else { + None + }; + + if self.multitables.len() > 0 { + unimplemented!("do not support multitables yet") + } + + // step 2 - grand product arguments + + let beta_for_copy_permutation = E::Fr::from_str("123").unwrap(); + let gamma_for_copy_permutation = E::Fr::from_str("456").unwrap(); + + // copy permutation grand product argument + + let mut grand_products_protos_with_gamma = vec![]; + + for i in 0..num_state_polys { + let id = PolyIdentifier::VariablesPolynomial(i); + + let mut p = values_storage.state_map.get(&id).unwrap().as_ref().clone(); + p.add_constant(&worker, &gamma_for_copy_permutation); + + grand_products_protos_with_gamma.push(p); + } + + let required_domain_size = required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let non_residues = make_non_residues::(num_state_polys - 1); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta_for_copy_permutation); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let mut permutation_polynomials_values_of_size_n_minus_one = vec![]; + + for idx in 0..num_state_polys { + let key = PolyIdentifier::PermutationPolynomial(idx); + + let mut coeffs = values_storage.get_poly(key).clone().into_coeffs(); + coeffs.pop().unwrap(); + + let p = Polynomial::from_values_unpadded(coeffs)?; + permutation_polynomials_values_of_size_n_minus_one.push(p); + } + + let z_den = { + assert_eq!( + permutation_polynomials_values_of_size_n_minus_one.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = permutation_polynomials_values_of_size_n_minus_one.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, permutation_polys_it.next().unwrap(), &beta_for_copy_permutation); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, &perm, &beta_for_copy_permutation); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + drop(z_num); + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + + let copy_permutation_z_in_monomial_form = z.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + // // TODO: move to setup + // let mut permutation_polys_in_monomial_form = vec![]; + // for idx in 0.. { + // let key = PolyIdentifier::PermutationPolynomial(idx); + // let p = p.ifft_using_bitreversed_ntt( + // &worker, + // &omegas_inv_bitreversed, + // &E::Fr::one() + // )?; + + // permutation_polys_in_monomial_form.push(p); + // } + + let mut beta_for_lookup = None; + let mut gamma_for_lookup = None; + + let lookup_z_poly_in_monomial_form = if let Some(data) = lookup_data.as_mut() { + let beta_for_lookup_permutation = E::Fr::from_str("789").unwrap(); + let gamma_for_lookup_permutation = E::Fr::from_str("1230").unwrap(); + + beta_for_lookup = Some(beta_for_lookup_permutation); + gamma_for_lookup = Some(gamma_for_lookup_permutation); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + let f_poly_unpadded_values = data.f_poly_unpadded_values.take().unwrap(); + let t_poly_unpadded_values = data.t_poly_unpadded_values.take().unwrap(); + let t_shifted_unpadded_values = data.t_shifted_unpadded_values.take().unwrap(); + let s_poly_unpadded_values = data.s_poly_unpadded_values.take().unwrap(); + let s_shifted_unpadded_values = data.s_shifted_unpadded_values.take().unwrap(); + + // Z(x*omega) = Z(x) * + // (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) / + // (\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut z_num = { + // (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + + let mut t = t_poly_unpadded_values.clone(); + t.add_assign_scaled(&worker, &t_shifted_unpadded_values, &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + let mut tmp = f_poly_unpadded_values.clone(); + tmp.add_constant(&worker, &gamma_for_lookup_permutation); + tmp.scale(&worker, beta_plus_one); + + t.mul_assign(&worker, &tmp); + drop(tmp); + + t + }; + + let z_den = { + // (\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut t = s_poly_unpadded_values.clone(); + t.add_assign_scaled(&worker, &s_shifted_unpadded_values, &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + t.batch_inversion(&worker)?; + + t + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + drop(z_num); + + assert!(z.size().is_power_of_two()); + + assert_eq!(z.as_ref()[0], E::Fr::one()); + assert_eq!(*z.as_ref().last().unwrap(), expected); + + let t_poly_monomial = t_poly_unpadded_values.clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + let s_poly_monomial = s_poly_unpadded_values.clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + // data.f_poly_monomial = Some(f_poly_monomial); + data.t_poly_monomial = Some(t_poly_monomial); + data.s_poly_monomial = Some(s_poly_monomial); + + let z = z.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + Some(z) + } else { + None + }; + + // TODO: commit to z polynomials + + // now draw alpha and add all the contributions to the quotient polynomial + + let alpha = E::Fr::from_str("1234567890").unwrap(); + + let mut total_powers_of_alpha_for_gates = 0; + for g in self.sorted_gates.iter() { + total_powers_of_alpha_for_gates += g.num_quotient_terms(); + } + + println!("Have {} terms from {} gates", total_powers_of_alpha_for_gates, self.sorted_gates.len()); + + let mut current_alpha = E::Fr::one(); + let mut powers_of_alpha_for_gates = Vec::with_capacity(total_powers_of_alpha_for_gates); + powers_of_alpha_for_gates.push(current_alpha); + for _ in 1..total_powers_of_alpha_for_gates { + current_alpha.mul_assign(&alpha); + powers_of_alpha_for_gates.push(current_alpha); + } + + assert_eq!(powers_of_alpha_for_gates.len(), total_powers_of_alpha_for_gates); + + let mut all_gates = self.sorted_gates.clone(); + let num_different_gates = self.sorted_gates.len(); + + let mut challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut lde_factor = num_state_polys; + for g in self.sorted_gates.iter() { + let degree = g.degree(); + if degree > lde_factor { + lde_factor = degree; + } + } + + assert!(lde_factor <= 4); + + let coset_factor = E::Fr::multiplicative_generator(); + + let mut t_poly = { + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let input_values = self.input_assingments.clone(); + + let mut t = gate.contribute_into_quotient_for_public_inputs( + required_domain_size, + &input_values, + &mut ldes_storage, + &monomials_storage, + for_gate, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &worker + )?; + + if num_different_gates > 1 { + // we have to multiply by the masking poly (selector) + let key = PolyIdentifier::GateSelector(gate.name()); + let monomial_selector = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let lde = monomial_selector.clone_padded_to_domain()?.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + t.mul_assign(&worker, &lde); + drop(lde); + } + + t + }; + + let non_main_gates = all_gates; + + for gate in non_main_gates.into_iter() { + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let mut contribution = gate.contribute_into_quotient( + required_domain_size, + &mut ldes_storage, + &monomials_storage, + for_gate, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &worker + )?; + + { + // we have to multiply by the masking poly (selector) + let key = PolyIdentifier::GateSelector(gate.name()); + let monomial_selector = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let lde = monomial_selector.clone_padded_to_domain()?.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + contribution.mul_assign(&worker, &lde); + drop(lde); + } + + t_poly.add_assign(&worker, &contribution); + } + + assert_eq!(challenges_slice.len(), 0); + + println!("Power of alpha for a start of normal permutation argument = {}", total_powers_of_alpha_for_gates); + + // perform copy-permutation argument + + // we precompute L_{0} here cause it's necessary for both copy-permutation and lookup permutation + + // z(omega^0) - 1 == 0 + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + let l_0_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let mut copy_grand_product_alphas = None; + let x_poly_lde_bitreversed = { + // now compute the permutation argument + + let z_coset_lde_bitreversed = copy_permutation_z_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + assert!(z_coset_lde_bitreversed.size() == required_domain_size*lde_factor); + + let z_shifted_coset_lde_bitreversed = z_coset_lde_bitreversed.clone_shifted_assuming_bitreversed( + lde_factor, + &worker, + )?; + + assert!(z_shifted_coset_lde_bitreversed.size() == required_domain_size*lde_factor); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + let mut contrib_z = z_coset_lde_bitreversed.clone(); + + // precompute x poly + let mut x_poly = Polynomial::from_values(vec![ + coset_factor; + required_domain_size*lde_factor + ])?; + x_poly.distribute_powers(&worker, z_shifted_coset_lde_bitreversed.omega); + x_poly.bitreverse_enumeration(&worker); + + assert_eq!(x_poly.size(), required_domain_size * lde_factor); + + // A + beta*X + gamma + + let mut tmp = ldes_storage.state_map.get(&PolyIdentifier::VariablesPolynomial(0)).unwrap().as_ref().clone(); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + tmp.add_assign_scaled(&worker, &x_poly, &beta_for_copy_permutation); + contrib_z.mul_assign(&worker, &tmp); + + assert_eq!(non_residues.len() + 1, num_state_polys); + + for (poly_idx, non_res) in (1..num_state_polys).zip(non_residues.iter()) { + let mut factor = beta_for_copy_permutation; + factor.mul_assign(&non_res); + + let key = PolyIdentifier::VariablesPolynomial(poly_idx); + tmp.reuse_allocation(&ldes_storage.state_map.get(&key).unwrap().as_ref()); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + tmp.add_assign_scaled(&worker, &x_poly, &factor); + contrib_z.mul_assign(&worker, &tmp); + } + + t_poly.add_assign_scaled(&worker, &contrib_z, ¤t_alpha); + + let alpha_0 = current_alpha; + + drop(contrib_z); + + let mut contrib_z = z_shifted_coset_lde_bitreversed; + + // A + beta*perm_a + gamma + + for idx in 0..num_state_polys { + let key = PolyIdentifier::VariablesPolynomial(idx); + + tmp.reuse_allocation(&ldes_storage.state_map.get(&key).unwrap().as_ref()); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + + let key = PolyIdentifier::PermutationPolynomial(idx); + let perm = monomials_storage.get_poly(key).clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + tmp.add_assign_scaled(&worker, &perm, &beta_for_copy_permutation); + contrib_z.mul_assign(&worker, &tmp); + drop(perm); + } + + t_poly.sub_assign_scaled(&worker, &contrib_z, ¤t_alpha); + + drop(contrib_z); + + drop(tmp); + + // Z(x) * L_{0}(x) - 1 == 0 + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + { + let mut z_minus_one_by_l_0 = z_coset_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + z_minus_one_by_l_0.mul_assign(&worker, &l_0_coset_lde_bitreversed); + + t_poly.add_assign_scaled(&worker, &z_minus_one_by_l_0, ¤t_alpha); + } + + copy_grand_product_alphas = Some([alpha_0, alpha_1]); + + x_poly + }; + + // let inverse_divisor_on_coset_lde_natural_ordering = { + // let mut vanishing_poly_inverse_bitreversed = + // evaluate_vanishing_polynomial_of_degree_on_domain_size::( + // required_domain_size as u64, + // &E::Fr::multiplicative_generator(), + // (required_domain_size * lde_factor) as u64, + // &worker, + // )?; + // vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + // // vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker)?; + + // vanishing_poly_inverse_bitreversed + // }; + + // t_poly.bitreverse_enumeration(&worker); + + // t_poly.mul_assign(&worker, &inverse_divisor_on_coset_lde_natural_ordering); + + // drop(inverse_divisor_on_coset_lde_natural_ordering); + + // add contribution from grand product for loopup polys if there is one + + let mut lookup_grand_product_alphas = None; + if let Some(z_poly_in_monomial_form) = lookup_z_poly_in_monomial_form.as_ref() { + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + current_alpha.mul_assign(&alpha); + + let alpha_0 = current_alpha; + + // same grand product argument for lookup permutation except divisor is now with one point cut + + let z_lde = z_poly_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let z_lde_shifted = z_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + // We make an small ad-hoc modification here and instead of dividing some contributions by + // (X^n - 1)/(X - omega^{n-1}) we move (X - omega^{n-1}) to the numerator and join the divisions + + // Numerator degree is at max 4n, so it's < 4n after division + + // ( Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // - Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) )*(X - omega^{n-1}) + + let data = lookup_data.as_ref().unwrap(); + + let s_lde = data.s_poly_monomial.as_ref().unwrap().clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let s_lde_shifted = s_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + // Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut contribution = s_lde; + contribution.add_assign_scaled(&worker, &s_lde_shifted, &beta_for_lookup_permutation); + contribution.add_constant(&worker, &gamma_beta); + contribution.mul_assign(&worker, &z_lde_shifted); + + drop(s_lde_shifted); + drop(z_lde_shifted); + + let t_lde = data.t_poly_monomial.as_ref().unwrap().clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let t_lde_shifted = t_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + let f_lde = { + // add up ldes of a,b,c and table_type poly and multiply by selector + + let a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + &ldes_storage + ); + let mut tmp = a_ref.clone(); + drop(a_ref); + + let eta = lookup_data.as_ref().unwrap().eta; + + let mut current = eta; + + let b_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + &ldes_storage + ); + + tmp.add_assign_scaled(&worker, b_ref, ¤t); + + drop(b_ref); + current.mul_assign(&eta); + + let c_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2)), + &ldes_storage + ); + + tmp.add_assign_scaled(&worker, c_ref, ¤t); + + drop(c_ref); + current.mul_assign(&eta); + + let table_type_lde = lookup_data.as_ref().unwrap().table_type_poly_monomial.as_ref().unwrap().clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.add_assign_scaled(&worker, &table_type_lde, ¤t); + + drop(table_type_lde); + + let lookup_selector_lde = lookup_data.as_ref().unwrap().selector_poly_monomial.as_ref().unwrap().clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.mul_assign(&worker, &lookup_selector_lde); + + drop(lookup_selector_lde); + + tmp + + }; + + // - Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + + let mut tmp = f_lde; + tmp.add_constant(&worker, &gamma_for_lookup_permutation); + tmp.mul_assign(&worker, &z_lde); + tmp.scale(&worker, beta_plus_one); + + let mut t = t_lde; + t.add_assign_scaled(&worker, &t_lde_shifted, &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + tmp.mul_assign(&worker, &t); + + drop(t); + drop(t_lde_shifted); + + contribution.sub_assign(&worker, &tmp); + + contribution.scale(&worker, current_alpha); + + // multiply by (X - omega^{n-1}) + + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut x_minus_last_omega = x_poly_lde_bitreversed; + x_minus_last_omega.sub_constant(&worker, &last_omega); + + contribution.mul_assign(&worker, &x_minus_last_omega); + drop(x_minus_last_omega); + + // we do not need to do addition multiplications for terms below cause multiplication by lagrange poly + // does everything for us + + // check that (Z(x) - 1) * L_{0} == 0 + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + tmp.reuse_allocation(&z_lde); + tmp.sub_constant(&worker, &E::Fr::one()); + tmp.mul_assign(&worker, &l_0_coset_lde_bitreversed); + + drop(l_0_coset_lde_bitreversed); + + contribution.add_assign_scaled(&worker, &tmp, ¤t_alpha); + + // check that (Z(x) - expected) * L_{n-1} == 0 + + current_alpha.mul_assign(&alpha); + + let alpha_2 = current_alpha; + + let l_last = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), required_domain_size - 1)?; + + let l_last_coset_lde_bitreversed = l_last.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.reuse_allocation(&z_lde); + tmp.sub_constant(&worker, &expected); + tmp.mul_assign(&worker, &l_last_coset_lde_bitreversed); + + drop(l_last_coset_lde_bitreversed); + + contribution.add_assign_scaled(&worker, &tmp, ¤t_alpha); + + drop(tmp); + drop(z_lde); + + // contribution.bitreverse_enumeration(&worker); + + + // let vanishing_for_lookup = { + // let normally_enumerated = calculate_inverse_vanishing_polynomial_with_last_point_cut( + // &worker, + // required_domain_size * lde_factor, + // required_domain_size, + // coset_factor, + // )?; + + // normally_enumerated + // }; + + // contribution.mul_assign(&worker, &vanishing_for_lookup); + + t_poly.add_assign(&worker, &contribution); + + drop(contribution); + + lookup_grand_product_alphas = Some([alpha_0, alpha_1, alpha_2]); + } else { + drop(x_poly_lde_bitreversed); + drop(l_0_coset_lde_bitreversed); + } + + // perform the division + + let inverse_divisor_on_coset_lde_natural_ordering = { + let mut vanishing_poly_inverse_bitreversed = + evaluate_vanishing_polynomial_of_degree_on_domain_size::( + required_domain_size as u64, + &E::Fr::multiplicative_generator(), + (required_domain_size * lde_factor) as u64, + &worker, + )?; + vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + // vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker)?; + + vanishing_poly_inverse_bitreversed + }; + + // don't forget to bitreverse + + t_poly.bitreverse_enumeration(&worker); + + t_poly.mul_assign(&worker, &inverse_divisor_on_coset_lde_natural_ordering); + + drop(inverse_divisor_on_coset_lde_natural_ordering); + + let t_poly = t_poly.icoset_fft_for_generator(&worker, &coset_factor); + + println!("Lde factor = {}", lde_factor); + + // println!("Quotient poly = {:?}", t_poly.as_ref()); + + { + // degree is 4n-4 + let l = t_poly.as_ref().len(); + assert_eq!(&t_poly.as_ref()[(l-4)..], &[E::Fr::zero(); 4][..]); + } + + println!("Quotient poly degree = {}", get_degree::(&t_poly)); + + let t_poly_parts = t_poly.break_into_multiples(required_domain_size)?; + // TODO: commit every of them + + // draw opening point + let z = E::Fr::from_str("333444555").unwrap(); + let omega = domain.generator; + + // Now perform the linearization. + // First collect and evalute all the polynomials that are necessary for linearization + + let mut opening_requests_before_linearization = std::collections::HashSet::new(); + let mut all_queries = std::collections::HashSet::new(); + let mut sorted_opening_requests = vec![]; + let mut sorted_selector_for_opening = vec![]; + let mut polys_in_linearization = std::collections::HashSet::new(); + + let num_gate_types = self.sorted_gates.len(); + + for gate in self.sorted_gates.iter() { + for q in gate.all_queried_polynomials().into_iter() { + all_queries.insert(q); + } + if gate.benefits_from_linearization() { + // it's better to linearize the gate + if num_gate_types > 1 { + // there are various gates, so we need to query the selector + sorted_selector_for_opening.push(gate.box_clone()); + } + + for q in gate.needs_opened_for_linearization().into_iter() { + if !opening_requests_before_linearization.contains(&q) { + opening_requests_before_linearization.insert(q.clone()); + sorted_opening_requests.push(q); + } + } + + for q in gate.linearizes_over().into_iter() { + polys_in_linearization.insert(q); + } + } else { + // we will linearize over the selector, so we do not need to query it + } + } + + // println!("Will need to open for linearization: {:?}", sorted_opening_requests); + // println!("Will open selectors: {:?}", sorted_selector_for_opening); + + // println!("All queries = {:?}", all_queries); + + // Sanity check: we open everything either in linearization or in plain text! + { + let must_open_without_linearization: Vec<_> = all_queries.difference(&polys_in_linearization).collect(); + + for p in must_open_without_linearization.into_iter() { + assert!(opening_requests_before_linearization.contains(&p)); + } + } + + let mut query_values = vec![]; + let mut query_values_map_over_dilation = std::collections::HashMap::new(); + let mut query_values_map = std::collections::HashMap::new(); + + for p in sorted_opening_requests.into_iter() { + let (id, dilation_value) = p.into_id_and_raw_dilation(); + let poly_ref = match id { + p @ PolyIdentifier::VariablesPolynomial(..) => { + monomials_storage.state_map.get(&p).unwrap().as_ref() + }, + p @ PolyIdentifier::WitnessPolynomial(..) => { + monomials_storage.witness_map.get(&p).unwrap().as_ref() + }, + p @ PolyIdentifier::GateSetupPolynomial(..) => { + monomials_storage.setup_map.get(&p).unwrap().as_ref() + }, + _ => { + unreachable!(); + } + }; + + let mut opening_point = z; + for _ in 0..dilation_value { + opening_point.mul_assign(&omega); + } + + let value = poly_ref.evaluate_at(&worker, opening_point); + + let entry = query_values_map_over_dilation.entry(dilation_value).or_insert(vec![]); + entry.push(value); + + query_values_map.insert(p, value); + query_values.push(value); + } + + // TODO: commit queried values + + // println!("Queried values = {:?}", query_values_map_over_dilation); + + // also open selectors + + let mut selector_values = vec![]; + for s in sorted_selector_for_opening.into_iter() { + let key = PolyIdentifier::GateSelector(s.name()); + let poly_ref = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let value = poly_ref.evaluate_at(&worker, z); + + selector_values.push(value); + } + + // TODO: commit queried selector values + + // copy-permutation polynomials queries + + let mut copy_permutation_queries = vec![]; + + for idx in 0..(num_state_polys-1) { + let key = PolyIdentifier::PermutationPolynomial(idx); + let value = monomials_storage.get_poly(key).evaluate_at(&worker, z); + + copy_permutation_queries.push(value); + } + + // TODO: commit queried permutation poly values + + // copy-permutation grand product query + + let mut z_omega = z; + z_omega.mul_assign(&domain.generator); + let copy_permutation_z_at_z_omega = copy_permutation_z_in_monomial_form.evaluate_at(&worker, z_omega); + + // TODO: commit copy-permutation grand product query + + // we've computed everything, so perform linearization + + let mut challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = self.sorted_gates.clone(); + + let mut r_poly = { + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(gate.benefits_from_linearization(), "main gate is expected to benefit from linearization!"); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let input_values = self.input_assingments.clone(); + + let mut r = gate.contribute_into_linearization_for_public_inputs( + required_domain_size, + &input_values, + z, + &query_values_map, + &monomials_storage, + for_gate, + &worker + )?; + + let mut selectors_it = selector_values.clone().into_iter(); + + if num_different_gates > 1 { + // first multiply r by the selector value at z + r.scale(&worker, selectors_it.next().unwrap()); + } + + // now proceed per gate + for gate in all_gates.into_iter() { + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + if gate.benefits_from_linearization() { + // gate benefits from linearization, so make temporary value + let tmp = gate.contribute_into_linearization( + required_domain_size, + z, + &query_values_map, + &monomials_storage, + for_gate, + &worker + )?; + + let selector_value = selectors_it.next().unwrap(); + + r.add_assign_scaled(&worker, &tmp, &selector_value); + } else { + // we linearize over the selector, so take a selector and scale it + let gate_value_at_z = gate.contribute_into_verification_equation( + required_domain_size, + z, + &query_values_map, + for_gate + )?; + + let key = PolyIdentifier::GateSelector(gate.name()); + let gate_selector_ref = monomials_storage.gate_selectors.get(&key).expect("must get monomial form of gate selector").as_ref(); + + r.add_assign_scaled(&worker, gate_selector_ref, &gate_value_at_z); + } + } + + assert!(selectors_it.next().is_none()); + assert_eq!(challenges_slice.len(), 0); + + r + }; + + // add contributions from copy-permutation and lookup-permutation + + // copy-permutation linearization comtribution + { + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let some_one = Some(E::Fr::one()); + let mut non_residues_iterator = some_one.iter().chain(&non_residues); + + let mut factor = alpha_0; + + for idx in 0..num_state_polys { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let mut t = z; + let non_res = non_residues_iterator.next().unwrap(); + t.mul_assign(&non_res); + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + assert!(non_residues_iterator.next().is_none()); + + r_poly.add_assign_scaled(&worker, ©_permutation_z_in_monomial_form, &factor); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = alpha_0; + factor.mul_assign(&beta_for_copy_permutation); + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let key = PolyIdentifier::PermutationPolynomial(num_state_polys - 1); + let last_permutation_poly_ref = monomials_storage.get_poly(key); + + r_poly.sub_assign_scaled(&worker, last_permutation_poly_ref, &factor); + + // + L_0(z) * Z(x) + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign(&alpha_1); + + r_poly.add_assign_scaled(&worker, ©_permutation_z_in_monomial_form, &factor); + } + + // lookup grand product linearization + + // due to separate divisor it's not obvious if this is beneficial without some tricks + // like multiplication by (1 - L_{n-1}) or by (x - omega^{n-1}) + + // Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) == 0 + // check that (Z(x) - 1) * L_{0} == 0 + // check that (Z(x) - expected) * L_{n-1} == 0, or (Z(x*omega) - expected)* L_{n-2} == 0 + + // f(x) does not need to be opened as it's made of table selector and witnesses + // if we pursue the strategy from the linearization of a copy-permutation argument + // then we leave something like s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) term, + // and Z(x) from Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) term, + // with terms with lagrange polys as multipliers left intact + + let lookup_queries = if let Some(lookup_z_poly) = lookup_z_poly_in_monomial_form.as_ref() { + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let s_at_z_omega = lookup_data.as_ref().unwrap().s_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z_omega); + let grand_product_at_z_omega = lookup_z_poly.evaluate_at(&worker, z_omega); + let t_at_z = lookup_data.as_ref().unwrap().t_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z); + let t_at_z_omega = lookup_data.as_ref().unwrap().t_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z_omega); + let selector_at_z = lookup_data.as_ref().unwrap().selector_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z); + let table_type_at_z = lookup_data.as_ref().unwrap().table_type_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z); + + let l_0_at_z = evaluate_lagrange_poly_at_point(0, &domain, z)?; + let l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + // (Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)))*(X - omega^{n-1}) + + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + // s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + let mut factor = grand_product_at_z_omega; // we do not need to account for additive terms + factor.mul_assign(&alpha_0); + factor.mul_assign(&z_minus_last_omega); + + r_poly.add_assign_scaled(&worker, lookup_data.as_ref().unwrap().s_poly_monomial.as_ref().unwrap(), &factor); + + // Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + // + alpha_1 * Z(x) * L_{0}(z) + alpha_2 * Z(x) * L_{n-1}(z) + + // accumulate coefficient + let mut factor = t_at_z_omega; + factor.mul_assign(&beta_for_lookup_permutation); + factor.add_assign(&t_at_z); + factor.add_assign(&gamma_beta); + + // (\gamma + f(x)) + + let mut f_reconstructed = E::Fr::zero(); + let mut current = E::Fr::one(); + let eta = lookup_data.as_ref().unwrap().eta; + // a,b,c + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let mut value = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + + value.mul_assign(¤t); + f_reconstructed.add_assign(&value); + + current.mul_assign(&eta); + } + + // and table type + let mut t = table_type_at_z; + t.mul_assign(¤t); + f_reconstructed.add_assign(&t); + + f_reconstructed.mul_assign(&selector_at_z); + f_reconstructed.add_assign(&gamma_for_lookup_permutation); + + // end of (\gamma + f(x)) part + + factor.mul_assign(&f_reconstructed); + factor.mul_assign(&beta_plus_one); + factor.negate(); // don't forget minus sign + factor.mul_assign(&alpha_0); + + // Multiply by (z - omega^{n-1}) + + factor.mul_assign(&z_minus_last_omega); + + // L_{0}(z) in front of Z(x) + + let mut tmp = l_0_at_z; + tmp.mul_assign(&alpha_1); + factor.add_assign(&tmp); + + // L_{n-1}(z) in front of Z(x) + + let mut tmp = l_n_minus_one_at_z; + tmp.mul_assign(&alpha_2); + factor.add_assign(&tmp); + + r_poly.add_assign_scaled(&worker, lookup_z_poly, &factor); + + let query = LookupQuery:: { + s_at_z_omega, + grand_product_at_z_omega, + t_at_z, + t_at_z_omega, + selector_at_z, + table_type_at_z, + }; + + Some(query) + } else { + None + }; + + let linearization_at_z = r_poly.evaluate_at(&worker, z); + + // don't forget to evaluate quotient too + + let t_at_z = { + let mut result = E::Fr::zero(); + let mut current = E::Fr::one(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + for p in t_poly_parts.iter() { + let mut subvalue_at_z = p.evaluate_at(&worker, z); + subvalue_at_z.mul_assign(¤t); + result.add_assign(&subvalue_at_z); + current.mul_assign(&z_in_domain_size); + } + + result + }; + + // linearization is done, now perform sanity check + // this is effectively a verification procedure + + { + let vanishing_at_z = evaluate_vanishing_for_size(&z, required_domain_size as u64); + + // first let's aggregate gates + + let mut t_num_on_full_domain = E::Fr::zero(); + + let challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = self.sorted_gates.clone(); + + // we've suffered and linearization polynomial captures all the gates except the public input! + + { + let mut tmp = linearization_at_z; + // add input values + + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(gate.benefits_from_linearization(), "main gate is expected to benefit from linearization!"); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, _) = challenges_slice.split_at(num_challenges); + + let input_values = self.input_assingments.clone(); + + let mut inputs_term = gate.add_inputs_into_quotient( + required_domain_size, + &input_values, + z, + for_gate, + )?; + + if num_different_gates > 1 { + let selector_value = selector_values[0]; + inputs_term.mul_assign(&selector_value); + } + + tmp.add_assign(&inputs_term); + + t_num_on_full_domain.add_assign(&tmp); + } + + // now aggregate leftovers from grand product for copy permutation + { + // - alpha_0 * (a + perm(z) * beta + gamma)*()*(d + gamma) * z(z*omega) + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let mut factor = alpha_0; + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(num_state_polys-1)); + let mut tmp = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + tmp.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&tmp); + + t_num_on_full_domain.sub_assign(&factor); + + // - L_0(z) * alpha_1 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + } + + // and if exists - grand product for lookup permutation + + { + if lookup_queries.is_some() { + + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let lookup_queries = lookup_queries.clone().expect("lookup queries must be made"); + + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + // in a linearization we've taken terms: + // - s(x) from the alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + // - and Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) (term in full) + + // + alpha_1 * (Z(x) - 1) * L_{0}(z) + alpha_2 * (Z(x) - expected) * L_{n-1}(z) + + // first make alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + \beta * s(x*omega))) + + let mut tmp = lookup_queries.s_at_z_omega; + tmp.mul_assign(&beta_for_lookup_permutation); + tmp.add_assign(&gamma_beta); + tmp.mul_assign(&lookup_queries.grand_product_at_z_omega); + tmp.mul_assign(&alpha_0); + + // (z - omega^{n-1}) for this part + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + tmp.mul_assign(&z_minus_last_omega); + + t_num_on_full_domain.add_assign(&tmp); + + // // - alpha_1 * L_{0}(z) + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + + // // - alpha_2 * expected L_{n-1}(z) + + let mut l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + l_n_minus_one_at_z.mul_assign(&expected); + l_n_minus_one_at_z.mul_assign(&alpha_2); + + t_num_on_full_domain.sub_assign(&l_n_minus_one_at_z); + } + } + + let mut lhs = t_at_z; + lhs.mul_assign(&vanishing_at_z); + + let rhs = t_num_on_full_domain; + + if lhs != rhs { + dbg!("Circuit is not satisfied"); + return Err(SynthesisError::Unsatisfiable); + } + } + + Ok(()) + } +} + +#[cfg(test)] +mod test { + use super::*; + + use crate::pairing::Engine; + use crate::pairing::ff::PrimeField; + + struct TestCircuit4{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4 { + type MainGate = Width4MainGateWithDNext; + + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + // 2a - b = 0 + + let two_a = ArithmeticTerm::from_variable_and_coeff(a, two); + let minus_b = ArithmeticTerm::from_variable_and_coeff(b, negative_one); + let mut term = MainGateTerm::new(); + term.add_assign(two_a); + term.add_assign(minus_b); + + cs.allocate_main_gate(term)?; + + // c - a*b == 0 + + let mut ab_term = ArithmeticTerm::from_variable(a).mul_by_variable(b); + ab_term.scale(&negative_one); + let c_term = ArithmeticTerm::from_variable(c); + let mut term = MainGateTerm::new(); + term.add_assign(c_term); + term.add_assign(ab_term); + + cs.allocate_main_gate(term)?; + + // d - 100 == 0 + + let hundred = ArithmeticTerm::constant(E::Fr::from_str("100").unwrap()); + let d_term = ArithmeticTerm::from_variable(d); + let mut term = MainGateTerm::new(); + term.add_assign(d_term); + term.sub_assign(hundred); + + cs.allocate_main_gate(term)?; + + // let gamma = cs.alloc_input(|| { + // Ok(E::Fr::from_str("20").unwrap()) + // })?; + + let gamma = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + // gamma - b == 0 + + let gamma_term = ArithmeticTerm::from_variable(gamma); + let b_term = ArithmeticTerm::from_variable(b); + let mut term = MainGateTerm::new(); + term.add_assign(gamma_term); + term.sub_assign(b_term); + + cs.allocate_main_gate(term)?; + + // 2a + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(a, two)); + + let dummy = CS::get_dummy_variable(); + + // 2a - d_next = 0 + + let (vars, mut coeffs) = CS::MainGate::format_term(term, dummy)?; + *coeffs.last_mut().unwrap() = negative_one; + + // here d is equal = 2a, so we need to place b there + // and compensate it with -b somewhere before + + cs.new_single_gate_for_trace_step(&CS::MainGate::default(), + &coeffs, + &vars, + &[] + )?; + + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable(b)); + + // b + 0 + 0 - b = 0 + let (mut vars, mut coeffs) = CS::MainGate::format_term(term, dummy)?; + coeffs[3] = negative_one; + vars[3] = b; + + cs.new_single_gate_for_trace_step(&CS::MainGate::default(), + &coeffs, + &vars, + &[] + )?; + + Ok(()) + } + } + + struct TestCircuit4WithLookups{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4WithLookups { + type MainGate = Width4MainGateWithDNext; + + fn declare_used_gates() -> Result>>, SynthesisError> { + Ok( + vec![ + Width4MainGateWithDNext::default().into_internal(), + TestBitGate::default().into_internal() + ] + ) + } + + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let columns = vec![PolyIdentifier::VariablesPolynomial(0), PolyIdentifier::VariablesPolynomial(1), PolyIdentifier::VariablesPolynomial(2)]; + let range_table = LookupTableApplication::new_range_table_of_width_3(2, columns.clone())?; + let range_table_name = range_table.functional_name(); + + let xor_table = LookupTableApplication::new_xor_table(2, columns.clone())?; + let xor_table_name = xor_table.functional_name(); + + let and_table = LookupTableApplication::new_and_table(2, columns)?; + let and_table_name = and_table.functional_name(); + + cs.add_table(range_table)?; + cs.add_table(xor_table)?; + cs.add_table(and_table)?; + + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let e = cs.alloc(|| { + Ok(E::Fr::from_str("2").unwrap()) + })?; + + let binary_x_value = E::Fr::from_str("3").unwrap(); + let binary_y_value = E::Fr::from_str("1").unwrap(); + + let binary_x = cs.alloc(|| { + Ok(binary_x_value) + })?; + + let binary_y = cs.alloc(|| { + Ok(binary_y_value) + })?; + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + // 2a - b = 0 + + let two_a = ArithmeticTerm::from_variable_and_coeff(a, two); + let minus_b = ArithmeticTerm::from_variable_and_coeff(b, negative_one); + let mut term = MainGateTerm::new(); + term.add_assign(two_a); + term.add_assign(minus_b); + + cs.allocate_main_gate(term)?; + + // c - a*b == 0 + + let mut ab_term = ArithmeticTerm::from_variable(a).mul_by_variable(b); + ab_term.scale(&negative_one); + let c_term = ArithmeticTerm::from_variable(c); + let mut term = MainGateTerm::new(); + term.add_assign(c_term); + term.add_assign(ab_term); + + cs.allocate_main_gate(term)?; + + let dummy = CS::get_dummy_variable(); + + // and table (gate #2 zero enumerated) + { + let table = cs.get_table(&and_table_name)?; + let num_keys_and_values = table.width(); + + let and_result_value = table.query(&[binary_x_value, binary_y_value])?[0]; + + let binary_z = cs.alloc(|| { + Ok(and_result_value) + })?; + + cs.begin_gates_batch_for_step()?; + + let vars = [binary_x, binary_y, binary_z, dummy]; + cs.allocate_variables_without_gate( + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + // d - 100 == 0 + + let hundred = ArithmeticTerm::constant(E::Fr::from_str("100").unwrap()); + let d_term = ArithmeticTerm::from_variable(d); + let mut term = MainGateTerm::new(); + term.add_assign(d_term); + term.sub_assign(hundred); + + cs.allocate_main_gate(term)?; + + let var_zero = cs.get_explicit_zero()?; + + // range table (gate #4 zero enumerated) + { + let table = cs.get_table(&range_table_name)?; + let num_keys_and_values = table.width(); + + cs.begin_gates_batch_for_step()?; + + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(e, E::Fr::zero())); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(var_zero, E::Fr::zero())); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(var_zero, E::Fr::zero())); + + let (vars, coeffs) = CS::MainGate::format_linear_term_with_duplicates(term, dummy)?; + + cs.new_gate_in_batch( + &CS::MainGate::default(), + &coeffs, + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + // xor table (gate #5 zero enumerated) + { + let table = cs.get_table(&xor_table_name)?; + let num_keys_and_values = table.width(); + + let xor_result_value = table.query(&[binary_x_value, binary_y_value])?[0]; + + let binary_z = cs.alloc(|| { + Ok(xor_result_value) + })?; + + cs.begin_gates_batch_for_step()?; + + let vars = [binary_x, binary_y, binary_z, dummy]; + cs.allocate_variables_without_gate( + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + let one = cs.get_explicit_one()?; + + cs.new_single_gate_for_trace_step( + &TestBitGate::default(), + &[], + &[one], + &[], + )?; + + Ok(()) + } + } + + + struct TestCircuit4WithLookupsManyGatesSmallTable{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4WithLookupsManyGatesSmallTable { + type MainGate = Width4MainGateWithDNext; + + fn declare_used_gates() -> Result>>, SynthesisError> { + Ok( + vec![ + Width4MainGateWithDNext::default().into_internal(), + ] + ) + } + + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let columns = vec![PolyIdentifier::VariablesPolynomial(0), PolyIdentifier::VariablesPolynomial(1), PolyIdentifier::VariablesPolynomial(2)]; + let range_table = LookupTableApplication::new_range_table_of_width_3(2, columns.clone())?; + let range_table_name = range_table.functional_name(); + + let xor_table = LookupTableApplication::new_xor_table(2, columns.clone())?; + let xor_table_name = xor_table.functional_name(); + + let and_table = LookupTableApplication::new_and_table(2, columns)?; + let and_table_name = and_table.functional_name(); + + cs.add_table(range_table)?; + cs.add_table(xor_table)?; + cs.add_table(and_table)?; + + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + let binary_x_value = E::Fr::from_str("3").unwrap(); + let binary_y_value = E::Fr::from_str("1").unwrap(); + + let binary_x = cs.alloc(|| { + Ok(binary_x_value) + })?; + + let binary_y = cs.alloc(|| { + Ok(binary_y_value) + })?; + + let mut negative_one = E::Fr::one(); + negative_one.negate(); + + for _ in 0..((1 << 11) - 100) { + // c - a*b == 0 + + let mut ab_term = ArithmeticTerm::from_variable(a).mul_by_variable(b); + ab_term.scale(&negative_one); + let c_term = ArithmeticTerm::from_variable(c); + let mut term = MainGateTerm::new(); + term.add_assign(c_term); + term.add_assign(ab_term); + + cs.allocate_main_gate(term)?; + } + + let dummy = CS::get_dummy_variable(); + + // and table + { + let table = cs.get_table(&and_table_name)?; + let num_keys_and_values = table.width(); + + let and_result_value = table.query(&[binary_x_value, binary_y_value])?[0]; + + let binary_z = cs.alloc(|| { + Ok(and_result_value) + })?; + + cs.begin_gates_batch_for_step()?; + + let vars = [binary_x, binary_y, binary_z, dummy]; + cs.allocate_variables_without_gate( + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + let var_zero = cs.get_explicit_zero()?; + + // range table + { + let table = cs.get_table(&range_table_name)?; + let num_keys_and_values = table.width(); + + cs.begin_gates_batch_for_step()?; + + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(binary_y, E::Fr::zero())); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(var_zero, E::Fr::zero())); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(var_zero, E::Fr::zero())); + + let (vars, coeffs) = CS::MainGate::format_linear_term_with_duplicates(term, dummy)?; + + cs.new_gate_in_batch( + &CS::MainGate::default(), + &coeffs, + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + // xor table + { + let table = cs.get_table(&xor_table_name)?; + let num_keys_and_values = table.width(); + + let xor_result_value = table.query(&[binary_x_value, binary_y_value])?[0]; + + let binary_z = cs.alloc(|| { + Ok(xor_result_value) + })?; + + cs.begin_gates_batch_for_step()?; + + let vars = [binary_x, binary_y, binary_z, dummy]; + cs.allocate_variables_without_gate( + &vars, + &[] + )?; + + cs.apply_single_lookup_gate(&vars[..num_keys_and_values], table)?; + + cs.end_gates_batch_for_step()?; + } + + Ok(()) + } + } + + #[test] + fn test_trivial_circuit_with_gate_agnostic_cs() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + assert!(assembly.gates.len() == 1); + + // println!("Assembly state polys = {:?}", assembly.storage.state_map); + + // println!("Assembly setup polys = {:?}", assembly.storage.setup_map); + + println!("Assembly contains {} gates", assembly.n()); + assembly.finalize(); + assert!(assembly.is_satisfied()); + + assembly.finalize(); + + let worker = Worker::new(); + + let (_storage, _permutation_polys) = assembly.perform_setup(&worker).unwrap(); + } + + #[test] + fn test_circuit_with_combined_lookups() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4WithLookups:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + println!("Assembly contains {} gates", assembly.n()); + assert!(assembly.is_satisfied()); + + assert!(assembly.gates.len() == 2); + + assembly.finalize(); + + println!("Finalized assembly contains {} gates", assembly.n()); + + let worker = Worker::new(); + + let _ = assembly.prover_stub(&worker).unwrap(); + } + + #[test] + fn test_circuit_with_small_tables() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4WithLookupsManyGatesSmallTable:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + println!("Assembly contains {} gates", assembly.n()); + assert!(assembly.is_satisfied()); + + assert_eq!(assembly.gates.len(), 1); + assert_eq!(assembly.total_length_of_all_tables, 4*4 + 4*4 + 4); + + assembly.finalize(); + + println!("Finalized assembly contains {} gates", assembly.n()); + + let worker = Worker::new(); + + let _ = assembly.prover_stub(&worker).unwrap(); + } + + #[test] + fn test_circuit_setup_and_prove() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + use crate::plonk::better_better_cs::verifier::*; + use crate::plonk::better_better_cs::setup::VerificationKey; + + let mut assembly = SetupAssembly::::new(); + + let circuit = TestCircuit4WithLookups:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + println!("Assembly contains {} gates", assembly.n()); + assert!(assembly.is_satisfied()); + + assembly.finalize(); + + println!("Finalized assembly contains {} gates", assembly.n()); + + let worker = Worker::new(); + + let setup = assembly.create_setup::>(&worker).unwrap(); + + let mut assembly = ProvingAssembly::::new(); + circuit.synthesize(&mut assembly).expect("must work"); + assembly.finalize(); + + let size = assembly.n().next_power_of_two(); + + use crate::plonk::commitments::transcript::keccak_transcript::RollingKeccakTranscript; + use crate::kate_commitment::*; + + let crs_mons = Crs::::crs_42(size, &worker); + + let proof = assembly.create_proof::, RollingKeccakTranscript>( + &worker, + &setup, + &crs_mons, + None + ).unwrap(); + + let vk = VerificationKey::from_setup(&setup, &worker, &crs_mons).unwrap(); + + let valid = verify::, RollingKeccakTranscript>( + &vk, + &proof, + None, + ).unwrap(); + + dbg!(valid); + } + + #[derive(Clone, Debug, Hash, Default)] + pub struct TestBitGate; + + impl GateInternal for TestBitGate { + fn name(&self) -> &'static str { + "Test bit gate on A" + } + + fn degree(&self) -> usize { + 2 + } + + fn can_include_public_inputs(&self) -> bool { + false + } + + fn all_queried_polynomials(&self) -> Vec { + vec![ + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + ] + } + + fn setup_polynomials(&self) -> Vec { + vec![] + } + + fn variable_polynomials(&self) -> Vec { + vec![ + PolyIdentifier::VariablesPolynomial(0), + ] + } + + fn benefits_from_linearization(&self) -> bool { + false + } + + fn linearizes_over(&self) -> Vec { + vec![] + } + + fn needs_opened_for_linearization(&self) -> Vec { + vec![] + } + + fn num_quotient_terms(&self) -> usize { + 1 + } + + fn verify_on_row<'a>(&self, row: usize, poly_storage: &AssembledPolynomialStorage<'a, E>, _last_row: bool) -> E::Fr { + let q_a = poly_storage.get_poly_at_step(PolyIdentifier::VariablesPolynomial(0), row); + + // (A - 1) * A + let mut tmp = q_a; + tmp.sub_assign(&E::Fr::one()); + tmp.mul_assign(&q_a); + + tmp + } + + fn contribute_into_quotient<'a, 'b>( + &self, + domain_size: usize, + poly_storage: &mut AssembledPolynomialStorage<'a, E>, + monomials_storage: & AssembledPolynomialStorageForMonomialForms<'b, E>, + challenges: &[E::Fr], + omegas_bitreversed: &BitReversedOmegas, + _omegas_inv_bitreversed: &OmegasInvBitreversed, + worker: &Worker + ) -> Result, SynthesisError> { + assert!(domain_size.is_power_of_two()); + assert_eq!(challenges.len(), >::num_quotient_terms(&self)); + + let lde_factor = poly_storage.lde_factor; + assert!(lde_factor.is_power_of_two()); + + assert!(poly_storage.is_bitreversed); + + let coset_factor = E::Fr::multiplicative_generator(); + + for p in >::all_queried_polynomials(&self).into_iter() { + ensure_in_map_or_create(&worker, + p, + domain_size, + omegas_bitreversed, + lde_factor, + coset_factor, + monomials_storage, + poly_storage + )?; + } + + let ldes_storage = &*poly_storage; + + // (A - 1) * A + let a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + ldes_storage + ); + + let mut tmp = a_ref.clone(); + drop(a_ref); + + let one = E::Fr::one(); + + tmp.map(&worker, + |el| { + let mut tmp = *el; + tmp.sub_assign(&one); + tmp.mul_assign(&*el); + + *el = tmp; + }, + ); + + tmp.scale(&worker, challenges[0]); + + Ok(tmp) + } + + fn contribute_into_linearization<'a>( + &self, + _domain_size: usize, + _at: E::Fr, + _queried_values: &std::collections::HashMap, + _monomials_storage: & AssembledPolynomialStorageForMonomialForms<'a, E>, + _challenges: &[E::Fr], + _worker: &Worker + ) -> Result, SynthesisError> { + unreachable!("this gate does not contribute into linearization"); + } + fn contribute_into_verification_equation( + &self, + _domain_size: usize, + _at: E::Fr, + queried_values: &std::collections::HashMap, + challenges: &[E::Fr], + ) -> Result { + assert_eq!(challenges.len(), 1); + // (A-1) * A + let a_value = *queried_values.get(&PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0))) + .ok_or(SynthesisError::AssignmentMissing)?; + let mut result = a_value; + result.sub_assign(&E::Fr::one()); + result.mul_assign(&a_value); + result.mul_assign(&challenges[0]); + + Ok(result) + } + + fn put_public_inputs_into_selector_id(&self) -> Option { + None + } + + fn box_clone(&self) -> Box> { + Box::from(self.clone()) + } + fn contribute_into_linearization_commitment( + &self, + _domain_size: usize, + _at: E::Fr, + _queried_values: &std::collections::HashMap, + _commitments_storage: &std::collections::HashMap, + _challenges: &[E::Fr], + ) -> Result { + unreachable!("this gate does not contribute into linearization"); + } + } + + impl Gate for TestBitGate {} +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/cs_old.rs b/src/plonk/better_better_cs/cs_old.rs new file mode 100644 index 000000000..057f57bb4 --- /dev/null +++ b/src/plonk/better_better_cs/cs_old.rs @@ -0,0 +1,2411 @@ +use crate::pairing::ff::{Field}; +use crate::pairing::{Engine}; +use crate::bit_vec::BitVec; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::worker::Worker; +use crate::plonk::domains::*; +use crate::plonk::polynomials::*; + +pub use crate::plonk::cs::variable::*; +use crate::plonk::better_cs::utils::*; + +pub trait Circuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError>; +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum PolynomialInConstraint { + VariablesPolynomial(usize, TimeDilation), + WitnessPolynomial(usize, TimeDilation), + SetupPolynomial(&'static str, usize, TimeDilation) +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum Coefficient { + PlusOne, + MinusOne, + Other +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum PolyIdentifier { + VariablesPolynomial(usize), + WitnessPolynomial(usize), + SetupPolynomial(&'static str, usize), +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct TimeDilation(pub usize); + +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub struct PolynomialMultiplicativeTerm(pub Coefficient, pub Vec); + +impl PolynomialMultiplicativeTerm { + fn degree(&self) -> usize { + self.1.len() + } +} + +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub struct LinearCombinationOfTerms(pub Vec); + +impl LinearCombinationOfTerms { + fn terms(&self) -> &[PolynomialMultiplicativeTerm] { + &self.0[..] + } +} + +pub enum ArithmeticTerm{ + Product(Vec, E::Fr), + SingleVariable(Variable, E::Fr), + Constant(E::Fr), +} + +impl ArithmeticTerm { + pub fn from_variable(var: Variable) -> Self { + ArithmeticTerm::SingleVariable(var, E::Fr::one()) + } + + pub fn from_variable_and_coeff(var: Variable, coeff: E::Fr) -> Self { + ArithmeticTerm::SingleVariable(var, coeff) + } + + pub fn constant(coeff: E::Fr) -> Self { + ArithmeticTerm::Constant(coeff) + } + + pub fn mul_by_variable(self, other: Variable) -> Self { + match self { + ArithmeticTerm::Product(mut terms, coeff) => { + terms.push(other); + + ArithmeticTerm::Product(terms, coeff) + }, + ArithmeticTerm::SingleVariable(this, coeff) => { + let terms = vec![this, other]; + + ArithmeticTerm::Product(terms, coeff) + }, + ArithmeticTerm::Constant(coeff) => { + let terms = vec![other]; + + ArithmeticTerm::Product(terms, coeff) + }, + } + } + + pub fn scale(&mut self, by: &E::Fr) { + match self { + ArithmeticTerm::Product(_, ref mut coeff) => { + coeff.mul_assign(by); + }, + ArithmeticTerm::SingleVariable(_, ref mut coeff) => { + coeff.mul_assign(by); + }, + ArithmeticTerm::Constant(ref mut coeff) => { + coeff.mul_assign(by); + }, + } + } +} + +pub struct MainGateTerm{ + terms: Vec>, + num_multiplicative_terms: usize, + num_constant_terms: usize +} + +impl MainGateTerm { + pub fn new() -> Self { + Self { + terms: Vec::with_capacity(8), + num_multiplicative_terms: 0, + num_constant_terms: 0 + } + } + + pub fn len_without_constant(&self) -> usize { + self.terms.len() + } + + pub fn add_assign(&mut self, other: ArithmeticTerm) { + match &other { + ArithmeticTerm::Product(_, _) => { + self.num_multiplicative_terms += 1; + self.terms.push(other); + }, + ArithmeticTerm::SingleVariable(_, _) => { + self.terms.push(other); + }, + ArithmeticTerm::Constant(_) => { + self.num_constant_terms += 1; + self.terms.push(other); + }, + } + + debug_assert!(self.num_constant_terms <= 1, "must not duplicate constants"); + } + + pub fn sub_assign(&mut self, mut other: ArithmeticTerm) { + match &mut other { + ArithmeticTerm::Product(_, ref mut coeff) => { + coeff.negate(); + self.num_multiplicative_terms += 1; + }, + ArithmeticTerm::SingleVariable(_, ref mut coeff) => { + coeff.negate(); + }, + ArithmeticTerm::Constant(ref mut coeff) => { + coeff.negate(); + self.num_constant_terms += 1; + }, + } + + self.terms.push(other); + + debug_assert!(self.num_constant_terms <= 1, "must not duplicate constants"); + } +} + +pub trait MainGateEquation: GateEquation { + const NUM_LINEAR_TERMS: usize; + const NUM_VARIABLES: usize; + const NUM_VARIABLES_ON_NEXT_STEP: usize; + fn range_of_multiplicative_term() -> std::ops::Range; + fn range_of_linear_terms() -> std::ops::Range; + fn index_for_constant_term() -> usize; + fn range_of_next_step_linear_terms() -> std::ops::Range; + fn format_term(instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError>; +} + +pub trait GateEquation: GateEquationInternal + + Sized + + Clone + + std::hash::Hash + + std::default::Default +{ + const HAS_NONTRIVIAL_CONSTANTS: bool; + const NUM_CONSTANTS: usize; + + fn as_internal(&self) -> &dyn GateEquationInternal { + self as &dyn GateEquationInternal + } + + fn into_internal(self) -> Box { + Box::from(self) as Box + } + + fn static_description() -> &'static Self; + + fn output_constant_coefficients() -> Vec; +} + +pub trait GateEquationInternal: Send + + Sync + + 'static + + std::any::Any + + std::fmt::Debug +{ + fn degree(&self) -> usize; + fn num_constraints(&self) -> usize; + fn can_include_public_inputs(&self) -> bool; + fn put_public_inputs_into_selector_id(&self) -> Option; + fn get_constraint(&self) -> &LinearCombinationOfTerms; + fn get_constraints(&self) -> &[LinearCombinationOfTerms]; +} + +impl std::hash::Hash for dyn GateEquationInternal { + fn hash(&self, state: &mut H) where H: std::hash::Hasher { + self.type_id().hash(state); + self.degree().hash(state); + for t in self.get_constraints().iter() { + t.hash(state); + } + } +} + +impl PartialEq for dyn GateEquationInternal { + fn eq(&self, other: &Self) -> bool { + self.degree() == other.degree() && + self.get_constraints() == other.get_constraints() + } +} + +impl Eq for dyn GateEquationInternal {} + +#[derive(Clone, Debug, Hash)] +pub struct Width4MainGateWithDNextEquation(pub [LinearCombinationOfTerms; 1]); + +impl GateEquationInternal for Width4MainGateWithDNextEquation { + fn degree(&self) -> usize { + 3 + } + + fn num_constraints(&self) -> usize { + 1 + } + + fn can_include_public_inputs(&self) -> bool { + true + } + + fn put_public_inputs_into_selector_id(&self) -> Option { + Some(5) + } + + fn get_constraint(&self) -> &LinearCombinationOfTerms { + &(self.0[0]) + } + + fn get_constraints(&self) -> &[LinearCombinationOfTerms] { + &self.0[..] + } +} + +impl GateEquation for Width4MainGateWithDNextEquation { + const HAS_NONTRIVIAL_CONSTANTS: bool = false; + const NUM_CONSTANTS: usize = 7; + + // Width4MainGateWithDNextEquation is NOT generic, so this is fine + // and safe since it's sync! + fn static_description() -> &'static Self { + static mut VALUE: Option = None; + static INIT: std::sync::Once = std::sync::Once::new(); + + unsafe { + INIT.call_once(||{ + VALUE = Some(Width4MainGateWithDNextEquation::default()); + }); + + VALUE.as_ref().unwrap() + } + } + + fn output_constant_coefficients() -> Vec { + vec![E::Fr::one(); 7] + } +} + + +struct SimpleBitmap(u64, usize); +impl SimpleBitmap { + fn new() -> Self { + Self(0u64, 0) + } + + fn get_next_unused(&mut self) -> usize { + for i in 0..64 { + if self.get(i) == false { + return i; + } + } + + unreachable!() + } + + fn get(&self, idx: usize) -> bool{ + 1u64 << idx & self.0 > 0 + } + + fn set(&mut self, idx: usize) { + self.0 |= 1u64 << idx; + } +} + +impl MainGateEquation for Width4MainGateWithDNextEquation { + const NUM_LINEAR_TERMS: usize = 4; + const NUM_VARIABLES: usize = 4; + const NUM_VARIABLES_ON_NEXT_STEP: usize = 1; + + fn range_of_multiplicative_term() -> std::ops::Range { + 0..2 + } + fn range_of_linear_terms() -> std::ops::Range { + 0..4 + } + + fn index_for_constant_term() -> usize { + 5 + } + + fn range_of_next_step_linear_terms() -> std::ops::Range { + 6..7 + } + + fn format_term(mut instance: MainGateTerm, padding: Variable) -> Result<(Vec, Vec), SynthesisError> { + let mut flattened_variables = vec![padding; Self::NUM_VARIABLES]; + let mut flattened_coefficients = vec![E::Fr::zero(); 7]; + let mut bitmap = SimpleBitmap::new(); + + let allowed_linear = 4; + let allowed_multiplications = 1; + let allowed_constants = 1; + + debug_assert!(instance.num_constant_terms <= allowed_constants, "must not containt more constants than allowed"); + debug_assert!(instance.num_multiplicative_terms <= allowed_multiplications, "must not containt more multiplications than allowed"); + debug_assert!(instance.terms.len() <= allowed_constants + allowed_multiplications + allowed_linear, "gate can not fit that many terms"); + + if instance.num_multiplicative_terms != 0 { + let index = instance.terms.iter().position( + |t| { + match t { + ArithmeticTerm::Product(_, _) => true, + _ => false, + } + } + ).unwrap(); + + let term = instance.terms.swap_remove(index); + match term { + ArithmeticTerm::Product(vars, coeff) => { + debug_assert_eq!(vars.len(), 2, "multiplicative terms must contain two variables"); + + flattened_variables[0] = vars[0]; + flattened_variables[1] = vars[1]; + flattened_coefficients[4] = coeff; + bitmap.set(0); + bitmap.set(1); + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + if instance.num_constant_terms != 0 { + let index = instance.terms.iter().position( + |t| { + match t { + ArithmeticTerm::Constant(_) => true, + _ => false, + } + } + ).unwrap(); + + let term = instance.terms.swap_remove(index); + match term { + ArithmeticTerm::Constant(coeff) => { + flattened_coefficients[5] = coeff; + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + // only additions left + for term in instance.terms.into_iter() { + match term { + ArithmeticTerm::SingleVariable(var, coeff) => { + let index = flattened_variables.iter().position( + |&t| t == var + ); + if let Some(index) = index { + // there is some variable there already, + flattened_coefficients[index] = coeff; + } else { + let idx = bitmap.get_next_unused(); + flattened_variables[idx] = var; + flattened_coefficients[idx] = coeff; + bitmap.set(idx); + } + }, + _ => { + unreachable!("must be multiplicative term"); + } + } + } + + Ok((flattened_variables, flattened_coefficients)) + } +} + +impl std::default::Default for Width4MainGateWithDNextEquation { + fn default() -> Self { + Self::get_equation() + } +} + +impl Width4MainGateWithDNextEquation { + pub fn get_equation() -> Self { + let mut terms: Vec = Vec::with_capacity(7); + // linear terms + for i in 0..4 { + // N * Q_n + terms.push( + PolynomialMultiplicativeTerm( + Coefficient::PlusOne, + vec![ + PolynomialInConstraint::VariablesPolynomial(i, TimeDilation(0)), + PolynomialInConstraint::SetupPolynomial("main gate of width 4", i, TimeDilation(0)) + ] + ) + ); + } + + // multiplication + terms.push( + PolynomialMultiplicativeTerm( + Coefficient::PlusOne, + vec![ + PolynomialInConstraint::VariablesPolynomial(0, TimeDilation(0)), + PolynomialInConstraint::VariablesPolynomial(1, TimeDilation(0)), + PolynomialInConstraint::SetupPolynomial("main gate of width 4", 4, TimeDilation(0)) + ] + ) + ); + + // constant + terms.push( + PolynomialMultiplicativeTerm( + Coefficient::PlusOne, + vec![ + PolynomialInConstraint::SetupPolynomial("main gate of width 4", 5, TimeDilation(0)) + ] + ) + ); + + terms.push( + PolynomialMultiplicativeTerm( + Coefficient::PlusOne, + vec![ + PolynomialInConstraint::VariablesPolynomial(3, TimeDilation(1)), + PolynomialInConstraint::SetupPolynomial("main gate of width 4", 6, TimeDilation(0)) + ] + ) + ); + + Self([LinearCombinationOfTerms(terms)]) + } +} + +fn check_gate_to_support_public_inputs(gate: &G) -> bool { + for t in gate.get_constraints() { + for c in t.0.iter() { + if c.1.len() != 1 { + continue; + } + for s in c.1.iter() { + match s { + PolynomialInConstraint::SetupPolynomial(..) => { + return true; + }, + _ => {} + } + } + } + } + + false +} + +fn has_access_to_next_step(gate: &G) -> bool { + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::VariablesPolynomial(_, TimeDilation(shift)) => { + if shift != &0usize { + return true; + } + }, + PolynomialInConstraint::WitnessPolynomial(_, TimeDilation(shift)) => { + if shift != &0usize { + return true; + } + }, + PolynomialInConstraint::SetupPolynomial(_, _, TimeDilation(shift)) => { + if shift != &0usize { + return true; + } + }, + } + } + } + } + + false +} + +fn max_addressed_state_poly(gate: &G) -> Option { + let mut max: Option = None; + + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::VariablesPolynomial(idx, _) => { + let new_max = match max.take() { + Some(value) => { + if value < *idx { + Some(*idx) + } else { + Some(value) + } + }, + None => { + Some(*idx) + } + }; + + max = new_max; + }, + _ => {} + } + } + } + } + + max +} + +fn max_addressed_witness_poly(gate: &G) -> Option { + let mut max: Option = None; + + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::WitnessPolynomial(idx, _) => { + let new_max = match max.take() { + Some(value) => { + if value < *idx { + Some(*idx) + } else { + Some(value) + } + }, + None => { + Some(*idx) + } + }; + + max = new_max; + }, + _ => {} + } + } + } + } + + max +} + +// fn max_addressed_setup_poly(gate: &G) -> Option<(usize, &'static str)> { +// let mut max: Option = None; + +// let mut setup_tag = None; + +// for t in gate.get_constraints() { +// for c in t.0.iter() { +// for s in c.0.iter() { +// match s { +// PolynomialInConstraint::SetupPolynomial(name, idx, _) => { +// let new_max = match max.take() { +// Some(value) => { +// if value < *idx { +// Some(*idx) +// } else { +// Some(value) +// } +// }, +// None => { +// Some(*idx) +// } +// }; + +// max = new_max; +// }, +// _ => {} +// } +// } +// } +// } + +// max +// } + +fn check_gate_is_allowed_for_params, G: GateEquation>( + gate: &G +) -> bool { + let mut max_state = max_addressed_state_poly(gate); + let mut max_witness = max_addressed_witness_poly(gate); + // let max_setup = max_addressed_setup_poly(gate); + + let accesses_other_rows = has_access_to_next_step(gate); + if accesses_other_rows && P::CAN_ACCESS_NEXT_TRACE_STEP == false { + return false; + } + + match max_state.take() { + Some(m) => { + if m > P::STATE_WIDTH { + return false; + } + }, + _ => {} + } + + match max_witness.take() { + Some(m) => { + if m > P::WITNESS_WIDTH { + return false; + } + }, + _ => {} + } + + true +} + +pub trait PlonkConstraintSystemParams: Sized + Copy + Clone + Send + Sync { + const STATE_WIDTH: usize; + const WITNESS_WIDTH: usize; + const HAS_WITNESS_POLYNOMIALS: bool; + const HAS_CUSTOM_GATES: bool; + const CAN_ACCESS_NEXT_TRACE_STEP: bool; +} + +pub trait ConstraintSystem { + type Params: PlonkConstraintSystemParams; + type MainGate: MainGateEquation; + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + fn new_single_gate_for_trace_step(&mut self, + equation: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + self.begin_gates_batch_for_step()?; + self.new_gate_in_batch( + equation, + coefficients_assignments, + variables_assignments, + witness_assignments + )?; + self.end_gates_batch_for_step() + } + + fn get_main_gate(&self) -> &Self::MainGate; + + fn allocate_main_gate(&mut self, gate: MainGateTerm) -> Result<(), SynthesisError> { + let (vars, coeffs) = Self::MainGate::format_term(gate, Self::get_dummy_variable())?; + + let mg = Self::MainGate::static_description(); + + self.new_single_gate_for_trace_step( + mg, + &coeffs, + &vars, + &[] + ) + } + + fn begin_gates_batch_for_step(&mut self) -> Result<(), SynthesisError>; + fn new_gate_in_batch(&mut self, + equation: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError>; + fn end_gates_batch_for_step(&mut self) -> Result<(), SynthesisError>; + + fn get_value(&self, _variable: Variable) -> Result { + Err(SynthesisError::AssignmentMissing) + } + + fn get_dummy_variable() -> Variable; +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct PlonkCsWidth4WithNextStepParams; +impl PlonkConstraintSystemParams for PlonkCsWidth4WithNextStepParams { + const STATE_WIDTH: usize = 4; + const WITNESS_WIDTH: usize = 0; + const HAS_WITNESS_POLYNOMIALS: bool = false; + const HAS_CUSTOM_GATES: bool = false; + const CAN_ACCESS_NEXT_TRACE_STEP: bool = true; +} + +use crate::plonk::polynomials::*; + +// pub struct PolynomialStorage { +// pub state_map: std::collections::HashMap>, +// pub witness_map: std::collections::HashMap>, +// pub setup_map: std::collections::HashMap>, +// } + +pub struct PolynomialStorage { + pub state_map: std::collections::HashMap>, + pub witness_map: std::collections::HashMap>, + pub setup_map: std::collections::HashMap>, +} + +impl PolynomialStorage { + pub fn new() -> Self { + Self { + state_map: std::collections::HashMap::new(), + witness_map: std::collections::HashMap::new(), + setup_map: std::collections::HashMap::new(), + } + } + + pub fn get_value(&self, poly: &PolynomialInConstraint, n: usize) -> Result { + match poly { + PolynomialInConstraint::VariablesPolynomial(_, _) => { + unreachable!("should not try to get value of the state polynomial, get variable first instead"); + }, + PolynomialInConstraint::SetupPolynomial(gate_descr, idx, TimeDilation(dilation)) => { + let final_index = n + dilation; + let identifier = PolyIdentifier::SetupPolynomial(gate_descr, *idx); + let value = *self.setup_map + .get(&identifier) + .ok_or(SynthesisError::AssignmentMissing)? + .get(final_index) + .ok_or(SynthesisError::AssignmentMissing)?; + + Ok(value) + }, + PolynomialInConstraint::WitnessPolynomial(_, _) => { + unimplemented!() + } + } + } + + pub fn get_variable(&self, poly: &PolynomialInConstraint, n: usize) -> Result { + match poly { + PolynomialInConstraint::VariablesPolynomial(idx, TimeDilation(dilation)) => { + let final_index = n + dilation; + let identifier = PolyIdentifier::VariablesPolynomial(*idx); + let value = *self.state_map + .get(&identifier) + .ok_or(SynthesisError::AssignmentMissing)? + .get(final_index) + .ok_or(SynthesisError::AssignmentMissing)?; + + Ok(value) + }, + _ => { + unreachable!("should not try to get variable of setup or witness polynomial"); + } + } + } + + // pub fn sort_by_public_inputs(&mut self, inputs_map: &[usize]) { + // for (_, storage) in self.state_map.iter_mut() { + // for (input_idx, gate_idx) in inputs_map.iter().enumerate() { + // storage.swap(*gate_idx, input_idx); + // } + // } + // for (_, storage) in self.setup_map.iter_mut() { + // for (input_idx, gate_idx) in inputs_map.iter().enumerate() { + // storage.swap(*gate_idx, input_idx); + // } + // } + // for (_, storage) in self.witness_map.iter_mut() { + // for (input_idx, gate_idx) in inputs_map.iter().enumerate() { + // storage.swap(*gate_idx, input_idx); + // } + // } + // } +} + +pub struct GateDensityStorage(pub std::collections::HashMap, BitVec>); + +impl GateDensityStorage { + pub fn new() -> Self { + Self(std::collections::HashMap::new()) + } + + // pub fn sort_by_public_inputs(&mut self, inputs_map: &[usize]) { + // if self.0.is_empty() { + // return; + // } + + // for (_, density) in self.0.iter_mut() { + // for (input_idx, gate_idx) in inputs_map.iter().enumerate() { + // let value_at_n = density[*gate_idx]; + // assert!(value_at_n, "main gate must be set at public input"); + // let value_at_input_index = density[input_idx]; + + // density.set(*gate_idx, value_at_input_index); + // density.set(input_idx, value_at_n); + // } + // } + // } +} + +pub struct GateConstantCoefficientsStorage(pub std::collections::HashMap, Vec>); + +impl GateConstantCoefficientsStorage { + pub fn new() -> Self { + Self(std::collections::HashMap::new()) + } +} + +pub struct TrivialAssembly, MG: MainGateEquation> { + pub inputs_storage: PolynomialStorage, + pub aux_storage: PolynomialStorage, + pub num_input_gates: usize, + pub num_aux_gates: usize, + pub max_constraint_degree: usize, + pub main_gate: MG, + pub input_assingments: Vec, + pub aux_assingments: Vec, + pub num_inputs: usize, + pub num_aux: usize, + pub trace_step_for_batch: Option, + pub is_finalized: bool, + pub constraints: std::collections::HashSet>, + pub gate_internal_coefficients: GateConstantCoefficientsStorage, + pub sorted_setup_polynomial_ids: Vec, + pub sorted_gates: Vec>, + pub sorted_gate_constants: Vec>, + pub aux_gate_density: GateDensityStorage, + _marker: std::marker::PhantomData

+} + +impl, MG: MainGateEquation> ConstraintSystem for TrivialAssembly { + type Params = P; + type MainGate = MG; + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + // println!("Allocated variable Aux({}) with value {}", index, value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let mut main_gate = MainGateTerm::::new(); + main_gate.sub_assign(ArithmeticTerm::from_variable(input_var)); + + let dummy = Self::get_dummy_variable(); + let (variables_assignments, coefficients_assignments) = MG::format_term(main_gate, dummy).expect("must make empty padding gate"); + + let n = self.num_input_gates; + Self::allocate_into_storage( + MG::static_description(), + &mut self.inputs_storage, + n, + &coefficients_assignments, + &variables_assignments, + &[] + )?; + + self.num_input_gates += 1; + + Ok(input_var) + } + + fn get_main_gate(&self) -> &MG { + &self.main_gate + } + + fn begin_gates_batch_for_step(&mut self) -> Result<(), SynthesisError> { + debug_assert!(self.trace_step_for_batch.is_none()); + self.num_aux_gates += 1; + let n = self.num_aux_gates; + self.trace_step_for_batch = Some(n); + + Ok(()) + } + + fn new_gate_in_batch(&mut self, + gate: &G, + coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + // check that gate is ok for config + debug_assert!(check_gate_is_allowed_for_params::(&gate), format!("supplied params do not work with gate {:?}", gate)); + + let n = self.trace_step_for_batch.unwrap(); + // make zero-enumerated index + let n = n - 1; + + Self::allocate_into_storage( + gate, + &mut self.aux_storage, + n, + coefficients_assignments, + variables_assignments, + witness_assignments + )?; + + self.add_gate_into_list(gate); + + if let Some(tracker) = self.aux_gate_density.0.get_mut(gate.as_internal() as &dyn GateEquationInternal) { + if tracker.len() != n { + let padding = n - tracker.len(); + tracker.grow(padding, false); + } + tracker.push(true); + debug_assert_eq!(n+1, tracker.len()); + } else { + self.aux_gate_density.0.insert(gate.clone().into_internal(), BitVec::new()); + let tracker = self.aux_gate_density.0.get_mut(gate.as_internal() as &dyn GateEquationInternal).unwrap(); + tracker.grow(n, false); + tracker.push(true); + } + + Ok(()) + } + + fn end_gates_batch_for_step(&mut self) -> Result<(), SynthesisError> { + debug_assert!(self.trace_step_for_batch.is_some()); + let n = self.trace_step_for_batch.take().unwrap(); + debug_assert_eq!(n, self.num_aux_gates, "invalid batch id"); + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Aux(0)) => { + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable() -> Variable { + Self::dummy_variable() + } +} + +impl, MG: MainGateEquation> TrivialAssembly { + fn allocate_into_storage( + gate: &G, + storage: &mut PolynomialStorage, + n: usize,coefficients_assignments: &[E::Fr], + variables_assignments: &[Variable], + witness_assignments: &[E::Fr] + ) -> Result<(), SynthesisError> { + let dummy = Self::get_dummy_variable(); + let zero = E::Fr::zero(); + + let mut coeffs_it = coefficients_assignments.iter(); + + let mut setup_index: Option<(&'static str, usize)> = None; + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::SetupPolynomial(name, idx, _) => { + setup_index = Some((name, *idx)); + }, + _ => {} + } + + match setup_index.take() { + Some((name, idx)) => { + let key = PolyIdentifier::SetupPolynomial(name, idx); + let poly_ref = storage.setup_map.entry(key).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, E::Fr::zero()); + } + poly_ref.push(*coeffs_it.next().unwrap_or(&zero)); + }, + _ => {} + } + } + } + } + + debug_assert!(coeffs_it.next().is_none(), "must consume all the coefficients for gate"); + + let mut variable_index: Option = None; + + let mut variable_it = variables_assignments.iter(); + + // go through all used variables to place them into the STATE + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::VariablesPolynomial(idx, TimeDilation(0)) => { + variable_index = Some(*idx); + } + PolynomialInConstraint::VariablesPolynomial(_, TimeDilation(_)) => { + // gate can only have power over the current step + }, + _ => {} + } + + match variable_index.take() { + Some(idx) => { + let key = PolyIdentifier::VariablesPolynomial(idx); + let poly_ref = storage.state_map.entry(key).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, dummy); + } else if poly_ref.len() == n { + // we consume variable only ONCE + let var = *variable_it.next().unwrap_or(&dummy); + poly_ref.push(var); + } + }, + _ => {} + } + } + } + } + + debug_assert!(variable_it.next().is_none(), "must consume all variables for gate"); + + let mut witness_it = witness_assignments.iter(); + + let mut witness_index: Option = None; + + // go through all used variables to place them into the STATE + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::WitnessPolynomial(idx, TimeDilation(0)) => { + witness_index = Some(*idx); + }, + _ => {} + } + + match witness_index.take() { + Some(idx) => { + let key = PolyIdentifier::VariablesPolynomial(idx); + let poly_ref = storage.witness_map.entry(key).or_insert(vec![]); + if poly_ref.len() < n { + poly_ref.resize(n, E::Fr::zero()); + } + poly_ref.push(*witness_it.next().unwrap_or(&zero)); + }, + _ => {} + } + } + } + } + + Ok(()) + } + + pub fn n(&self) -> usize { + self.num_input_gates + self.num_aux_gates + } + + fn add_gate_setup_polys_into_list(&mut self, gate: &G) { + let mut setup_index: Option<(&'static str, usize)> = None; + for t in gate.get_constraints() { + for c in t.0.iter() { + for s in c.1.iter() { + match s { + PolynomialInConstraint::SetupPolynomial(name, idx, _) => { + setup_index = Some((name, *idx)); + }, + _ => {} + } + + match setup_index.take() { + Some((name, idx)) => { + let key = PolyIdentifier::SetupPolynomial(name, idx); + self.sorted_setup_polynomial_ids.push(key); + }, + _ => {} + } + } + } + } + } + + fn add_gate_into_list(&mut self, gate: &G) { + if !self.constraints.contains(gate.as_internal() as &dyn GateEquationInternal) { + self.constraints.insert(gate.clone().into_internal()); + + self.add_gate_setup_polys_into_list(gate); + + self.sorted_gates.push(gate.clone().into_internal()); + + let degree = gate.degree(); + if self.max_constraint_degree < degree { + self.max_constraint_degree = degree; + } + + let gate_constants = G::output_constant_coefficients::(); + self.sorted_gate_constants.push(gate_constants.clone()); + self.gate_internal_coefficients.0.insert(Box::from(gate.clone().into_internal()), gate_constants); + } + } + + pub fn new() -> Self { + let mut tmp = Self { + inputs_storage: PolynomialStorage::new(), + aux_storage: PolynomialStorage::new(), + + max_constraint_degree: 0, + + num_input_gates: 0, + num_aux_gates: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + main_gate: MG::default(), + + trace_step_for_batch: None, + + constraints: std::collections::HashSet::new(), + gate_internal_coefficients: GateConstantCoefficientsStorage::::new(), + + aux_gate_density: GateDensityStorage::new(), + sorted_setup_polynomial_ids: vec![], + sorted_gates: vec![], + sorted_gate_constants: vec![], + + is_finalized: false, + + _marker: std::marker::PhantomData + }; + + tmp.add_gate_into_list(&MG::default()); + + assert!(check_gate_to_support_public_inputs(&tmp.main_gate), "default gate must support making public inputs"); + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable() -> Variable { + Variable(Index::Aux(0)) + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + if (self.n()+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let dummmy = Self::get_dummy_variable(); + + let empty_gate = MainGateTerm::::new(); + let (vars, coeffs) = MG::format_term(empty_gate, dummmy).expect("must make empty padding gate"); + + for _ in self.n()..(self.n().next_power_of_two() - 1) { + self.new_single_gate_for_trace_step( + MG::static_description(), + &coeffs, + &vars, + &[] + ).expect("must add padding gate"); + } + + assert!((self.n()+1).is_power_of_two()); + self.is_finalized = true; + } + + fn get_storage_for_trace_step(&self, step: usize) -> &PolynomialStorage { + if step < self.num_input_gates { + &self.inputs_storage + } else { + &self.aux_storage + } + } + + pub fn is_satisfied(&self) -> bool { + // expect a small number of inputs + + // TODO: handle public inputs + + // for i in 0..self.num_input_gates { + // let gate = self.input_assingments + // } + + let one = E::Fr::one(); + let mut minus_one = E::Fr::one(); + minus_one.negate(); + + let n = self.n() - 1; + + for (gate_type, density) in self.aux_gate_density.0.iter() { + let constraints = gate_type.as_ref().get_constraints(); + let constants = self.gate_internal_coefficients.0.get(gate_type.as_ref()).expect(&format!("must get internal coefficients for the gate {:?}", gate_type.as_ref())); + let mut constants_iter = constants.iter(); + + for (gate_index, is_applicable) in density.iter().enumerate() { + if is_applicable == false { + continue; + } + + let trace_index = self.num_input_gates + gate_index; + + for constraint in constraints.iter() { + let mut constraint_value = E::Fr::zero(); + for term in constraint.0.iter() { + let mut base = match term.0 { + Coefficient::PlusOne => one, + Coefficient::MinusOne => minus_one, + Coefficient::Other => *constants_iter.next().unwrap() + }; + + let storage = self.get_storage_for_trace_step(trace_index); + + for poly in term.1.iter() { + let value = match poly { + PolynomialInConstraint::VariablesPolynomial(_, TimeDilation(dilation)) => { + debug_assert!(*dilation <= 1, "only handles variables on this and next step"); + if trace_index == n && *dilation > 0 { + continue; + } + let variable = storage.get_variable(poly, gate_index).expect(&format!("must get a variable for poly {:?} for aux gate {}", poly, gate_index)); + let value = self.get_value(variable).expect("must get a state variable value"); + + value + }, + PolynomialInConstraint::SetupPolynomial(_, _, TimeDilation(dilation)) => { + debug_assert_eq!(*dilation, 0, "only handles setup polys on this step for now"); + if trace_index == n && *dilation > 0 { + continue; + } + + let value = storage.get_value(poly, gate_index).expect(&format!("must get a setup value for poly {:?} for aux gate {}", poly, gate_index)); + + value + }, + PolynomialInConstraint::WitnessPolynomial(_, TimeDilation(dilation)) => { + debug_assert_eq!(*dilation, 0, "only handles witness polys on this step for now"); + if trace_index == n && *dilation > 0 { + continue; + } + + let value = storage.get_value(poly, gate_index).expect(&format!("must get a witness value for poly {:?} for aux gate {}", poly, gate_index)); + + value + } + }; + + base.mul_assign(&value); + } + + constraint_value.add_assign(&base); + } + + if !constraint_value.is_zero() { + println!("Unsatisfied at aux gate {} (zero enumerated)", gate_index); + println!("Constraint value = {}", constraint_value); + println!("Gate {:?}", gate_type); + return false; + } + } + } + } + + true + } + + pub(crate) fn make_permutations(&self, worker: &Worker) -> Vec> { + assert!(self.is_finalized); + + let num_gates = self.n(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + let mut poly_ids = vec![]; + for i in 0..P::STATE_WIDTH { + let id = PolyIdentifier::VariablesPolynomial(i); + poly_ids.push(id); + } + + // gate_idx is zero-enumerated here + for gate_idx in 0..num_gates + { + let storage = self.get_storage_for_trace_step(gate_idx); + for (state_poly_index, poly_id) in poly_ids.iter().enumerate() { + let variables_vec_ref = storage.state_map.get(&poly_id).expect("must get a variables polynomial"); + let storage_idx = if gate_idx < self.num_input_gates { + gate_idx + } else { + gate_idx - self.num_input_gates + }; + + let v = variables_vec_ref[storage_idx]; + match v { + Variable(Index::Aux(0)) => { + // Dummy variables do not participate in the permutation + }, + Variable(Index::Input(0)) => { + unreachable!("There must be no input with index 0"); + }, + Variable(Index::Input(index)) => { + let i = index; // inputs are [1, num_inputs] + partitions[i].push((state_poly_index, gate_idx+1)); + }, + Variable(Index::Aux(index)) => { + let i = index + num_inputs; // aux are [num_inputs + 1, ..] + partitions[i].push((state_poly_index, gate_idx+1)); + }, + } + } + } + + // sanity check + assert_eq!(partitions[0].len(), 0); + + let domain = Domain::new_for_size(num_gates as u64).expect("must have enough roots of unity to fit the circuit"); + + // now we need to make root at it's cosets + let domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, &worker + ); + + // domain_elements.pop().unwrap(); + + use crate::ff::SqrtField; + use crate::ff::LegendreSymbol; + + let mut non_residues = vec![]; + non_residues.push(E::Fr::one()); + non_residues.extend(make_non_residues::(P::STATE_WIDTH - 1)); + + assert_eq!(non_residues.len(), 4); + + let mut sigmas = vec![]; + for i in 0..P::STATE_WIDTH { + let mut sigma_i = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_i.scale(&worker, non_residues[i]); + sigmas.push(sigma_i); + } + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 1 { + let mut els: Vec<_> = vec.drain(0..1).collect(); + els.reverse(); + vec.push(els.pop().unwrap()); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + // we do not need to permute over partitions of length 1, + // as this variable only happends in one place + if partition.len() == 1 { + continue; + } + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + // let permutation = partition.clone(); + // permutations[i] = permutation; + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + // (column_idx, trace_step_idx) + let new_zero_enumerated = new.1 - 1; + let mut new_value = domain_elements[new_zero_enumerated]; + + // we have shuffled the values, so we need to determine FROM + // which of k_i * {1, omega, ...} cosets we take a value + // for a permutation polynomial + new_value.mul_assign(&non_residues[new.0]); + + // check to what witness polynomial the variable belongs + let place_into = &mut sigmas[original.0].as_mut(); + + let original_zero_enumerated = original.1 - 1; + place_into[original_zero_enumerated] = new_value; + } + } + + sigmas + } + + pub fn perform_setup( + &self, + worker: &Worker + ) -> Result< + (std::collections::HashMap>, Vec>), + SynthesisError + > { + assert!(self.is_finalized); + let total_num_gates = self.n(); + + let num_input_gates = self.num_input_gates; + + let mut map = std::collections::HashMap::new(); + + let setup_poly_ids: Vec<_> = self.aux_storage.setup_map.keys().collect(); + + for &id in setup_poly_ids.into_iter() { + let mut assembled_poly = vec![E::Fr::zero(); total_num_gates]; + if num_input_gates != 0 { + let input_gates_coeffs = &mut assembled_poly[..num_input_gates]; + input_gates_coeffs.copy_from_slice(&self.inputs_storage.setup_map.get(&id).unwrap()[..]); + } + + { + let aux_gates_coeffs = &mut assembled_poly[num_input_gates..]; + aux_gates_coeffs.copy_from_slice(&self.aux_storage.setup_map.get(&id).unwrap()[..]); + } + + let as_poly = Polynomial::from_values_unpadded(assembled_poly)?; + + map.insert(id, as_poly); + } + + let permutation_polys = self.make_permutations(&worker); + + Ok((map, permutation_polys)) + } + + pub fn output_gate_selectors(&self, worker: &Worker) -> Result>, SynthesisError> { + assert!(self.is_finalized); + if self.sorted_gates.len() == 1 { + return Ok(vec![]); + } + + let num_gate_selectors = self.sorted_gates.len(); + + let one = E::Fr::one(); + let empty_poly = Polynomial::::new_for_size(self.n().next_power_of_two())?; + let mut poly_values = vec![empty_poly.clone(); num_gate_selectors]; + let num_input_gates = self.num_input_gates; + + for p in poly_values.iter_mut() { + for p in p.as_mut()[..num_input_gates].iter_mut() { + *p = one; + } + } + + worker.scope(poly_values.len(), |scope, chunk| { + for (i, lh) in poly_values.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // we take `values_per_leaf` values from each of the polynomial + // and push them into the conbinations + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let id = &self.sorted_gates[idx]; + let density = self.aux_gate_density.0.get(id).unwrap(); + let poly_mut_slice: &mut [E::Fr] = &mut lh.as_mut()[num_input_gates..]; + for (i, d) in density.iter().enumerate() { + if d { + poly_mut_slice[i] = one; + } + } + } + }); + } + }); + + Ok(poly_values) + } + + pub fn make_state_and_witness_polynomials( + &self, + worker: &Worker + ) -> Result<(Vec>, Vec>), SynthesisError> + { + assert!(self.is_finalized); + + let mut full_assignments = vec![Vec::with_capacity((self.n()+1).next_power_of_two()); P::STATE_WIDTH]; + + let num_input_gates = self.num_input_gates; + let num_aux_gates = self.num_aux_gates; + + full_assignments[0].extend_from_slice(&self.input_assingments); + assert!(full_assignments[0].len() == num_input_gates); + for i in 1..P::STATE_WIDTH { + full_assignments[i].resize(num_input_gates, E::Fr::zero()); + } + + worker.scope(full_assignments.len(), |scope, chunk| { + for (i, lh) in full_assignments.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // we take `values_per_leaf` values from each of the polynomial + // and push them into the conbinations + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let id = PolyIdentifier::VariablesPolynomial(idx); + let poly_ref = self.aux_storage.state_map.get(&id).unwrap(); + for i in 0..num_aux_gates { + let var = poly_ref[i]; + let value = self.get_value(var).unwrap(); + lh.push(value); + } + } + }); + } + }); + + for p in full_assignments.iter_mut() { + p.resize((self.n()+1).next_power_of_two() - 1, E::Fr::zero()); + } + + for a in full_assignments.iter() { + assert_eq!(a.len(), (self.n()+1).next_power_of_two() - 1); + } + + Ok((full_assignments, vec![])) + } +} + +use crate::pairing::bn256; + +#[cfg(feature = "redshift")] +pub fn prove_with_rescue_bn256, MG: MainGateEquation, C: Circuit>( + circuit: &C +) -> Result<(), SynthesisError> { + use super::*; + use rescue_hash::RescueEngine; + use rescue_hash::bn256::Bn256RescueParams; + + use super::redshift::setup::*; + use super::redshift::prover::*; + use super::redshift::tree_hash::*; + + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + println!("Performing setup for {} gates", num_gates); + + let params = Bn256RescueParams::new_checked_2_into_1(); + + use crate::plonk::commitments::transcript::{Prng, rescue_transcript}; + + let mut prng = rescue_transcript::RescueTranscript::::from_params(¶ms); + + let hasher = RescueBinaryTreeHasher::::new(¶ms); + + let worker = Worker::new(); + + let (setup_multioracle, mut permutations) = SetupMultioracle::from_assembly( + assembly, + hasher.clone(), + &worker + )?; + + println!("Setup is done"); + + // cut permutations + for p in permutations.iter_mut() { + p.pop_last().unwrap(); + } + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + let start = std::time::Instant::now(); + + let (prover, first_state, first_message) = RedshiftProver::first_step( + assembly, + hasher.clone(), + &worker + )?; + + println!("First message"); + + for input in first_message.input_values.iter() { + prng.commit_input(input); + } + + prng.commit_input(&first_message.witness_multioracle_commitment); + + let beta = prng.get_challenge(); + let gamma = prng.get_challenge(); + + let first_verifier_message = FirstVerifierMessage:: { + beta, + gamma, + }; + + let (second_state, second_message) = prover.second_step_from_first_step( + first_state, + first_verifier_message, + &permutations, + &worker + )?; + + println!("Second message"); + + prng.commit_input(&second_message.grand_product_oracle_commitment); + + let alpha = prng.get_challenge(); + + let second_verifier_message = SecondVerifierMessage:: { + alpha, + beta, + gamma, + }; + + let (third_state, third_message) = prover.third_step_from_second_step( + second_state, + second_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Third message"); + + prng.commit_input(&third_message.quotient_poly_oracle_commitment); + + let z = prng.get_challenge(); + + let third_verifier_message = ThirdVerifierMessage:: { + alpha, + beta, + gamma, + z, + }; + + let (fourth_state, fourth_message) = prover.fourth_step_from_third_step( + third_state, + third_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Fourth message"); + + let mut wire_values_at_z = fourth_message.wire_values_at_z; + wire_values_at_z.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z: Vec<_> = wire_values_at_z.into_iter().map(|el| el.1).collect(); + + let mut wire_values_at_z_omega = fourth_message.wire_values_at_z_omega; + wire_values_at_z_omega.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z_omega: Vec<_> = wire_values_at_z_omega.into_iter().map(|el| el.1).collect(); + + for w in wire_values_at_z.iter() + .chain(&wire_values_at_z_omega) + .chain(&Some(fourth_message.grand_product_at_z)) + .chain(&Some(fourth_message.grand_product_at_z_omega)) + .chain(&fourth_message.quotient_polynomial_parts_at_z) + .chain(&fourth_message.setup_values_at_z) + .chain(&fourth_message.permutation_polynomials_at_z) + .chain(&fourth_message.gate_selector_polynomials_at_z) + { + prng.commit_input(&w); + } + + let v = prng.get_challenge(); + + let fourth_verifier_message = FourthVerifierMessage:: { + alpha, + beta, + gamma, + z, + v, + }; + + let fifth_message = prover.fifth_step_from_fourth_step( + fourth_state, + fourth_verifier_message, + &setup_multioracle, + &mut prng, + &worker + )?; + + println!("Fifth message"); + + println!("Proving {} gates taken {:?}", num_gates, start.elapsed()); + + Ok(()) +} + +#[cfg(feature = "redshift")] +pub fn prove_with_poseidon_bn256, MG: MainGateEquation, C: Circuit>( + circuit: &C +) -> Result<(), SynthesisError> { + use super::*; + use poseidon_hash::PoseidonEngine; + use poseidon_hash::bn256::Bn256PoseidonParams; + + use super::redshift::setup::*; + use super::redshift::prover::*; + use super::redshift::tree_hash::*; + + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + println!("Performing setup for {} gates", num_gates); + + let params = Bn256PoseidonParams::new_checked_2_into_1(); + + use crate::plonk::commitments::transcript::{Prng, poseidon_transcript}; + + let mut prng = poseidon_transcript::PoseidonTranscript::::from_params(¶ms); + + let hasher = PoseidonBinaryTreeHasher::::new(¶ms); + + let worker = Worker::new(); + + let (setup_multioracle, mut permutations) = SetupMultioracle::from_assembly( + assembly, + hasher.clone(), + &worker + )?; + + println!("Setup is done"); + + // cut permutations + for p in permutations.iter_mut() { + p.pop_last().unwrap(); + } + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + let start = std::time::Instant::now(); + + let (prover, first_state, first_message) = RedshiftProver::first_step( + assembly, + hasher.clone(), + &worker + )?; + + println!("First message"); + + for input in first_message.input_values.iter() { + prng.commit_input(input); + } + + prng.commit_input(&first_message.witness_multioracle_commitment); + + let beta = prng.get_challenge(); + let gamma = prng.get_challenge(); + + let first_verifier_message = FirstVerifierMessage:: { + beta, + gamma, + }; + + let (second_state, second_message) = prover.second_step_from_first_step( + first_state, + first_verifier_message, + &permutations, + &worker + )?; + + println!("Second message"); + + prng.commit_input(&second_message.grand_product_oracle_commitment); + + let alpha = prng.get_challenge(); + + let second_verifier_message = SecondVerifierMessage:: { + alpha, + beta, + gamma, + }; + + let (third_state, third_message) = prover.third_step_from_second_step( + second_state, + second_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Third message"); + + prng.commit_input(&third_message.quotient_poly_oracle_commitment); + + let z = prng.get_challenge(); + + let third_verifier_message = ThirdVerifierMessage:: { + alpha, + beta, + gamma, + z, + }; + + let (fourth_state, fourth_message) = prover.fourth_step_from_third_step( + third_state, + third_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Fourth message"); + + let mut wire_values_at_z = fourth_message.wire_values_at_z; + wire_values_at_z.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z: Vec<_> = wire_values_at_z.into_iter().map(|el| el.1).collect(); + + let mut wire_values_at_z_omega = fourth_message.wire_values_at_z_omega; + wire_values_at_z_omega.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z_omega: Vec<_> = wire_values_at_z_omega.into_iter().map(|el| el.1).collect(); + + for w in wire_values_at_z.iter() + .chain(&wire_values_at_z_omega) + .chain(&Some(fourth_message.grand_product_at_z)) + .chain(&Some(fourth_message.grand_product_at_z_omega)) + .chain(&fourth_message.quotient_polynomial_parts_at_z) + .chain(&fourth_message.setup_values_at_z) + .chain(&fourth_message.permutation_polynomials_at_z) + .chain(&fourth_message.gate_selector_polynomials_at_z) + { + prng.commit_input(&w); + } + + let v = prng.get_challenge(); + + let fourth_verifier_message = FourthVerifierMessage:: { + alpha, + beta, + gamma, + z, + v, + }; + + let fifth_message = prover.fifth_step_from_fourth_step( + fourth_state, + fourth_verifier_message, + &setup_multioracle, + &mut prng, + &worker + )?; + + println!("Fifth message"); + + println!("Proving {} gates taken {:?}", num_gates, start.elapsed()); + + Ok(()) +} + +#[cfg(feature = "redshift")] +pub fn prove_with_hash_counting_bn256, MG: MainGateEquation, C: Circuit>( + circuit: &C +) -> Result<(), SynthesisError> { + use super::*; + use rescue_hash::RescueEngine; + use rescue_hash::bn256::Bn256RescueParams; + + use super::redshift::setup::*; + use super::redshift::prover::*; + use super::redshift::tree_hash::*; + + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + println!("Performing setup for {} gates", num_gates); + + let params = Bn256RescueParams::new_checked_2_into_1(); + + use crate::plonk::commitments::transcript::{Prng, rescue_transcript}; + + let mut prng = rescue_transcript::RescueTranscript::::from_params(¶ms); + + let hasher = CountingHash::::new(); + + let worker = Worker::new(); + + let (setup_multioracle, mut permutations) = SetupMultioracle::from_assembly( + assembly, + hasher.clone(), + &worker + )?; + + println!("Setup is done"); + + // cut permutations + for p in permutations.iter_mut() { + p.pop_last().unwrap(); + } + + let mut assembly = TrivialAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.n(); + + let start = std::time::Instant::now(); + + let (prover, first_state, first_message) = RedshiftProver::first_step( + assembly, + hasher.clone(), + &worker + )?; + + println!("First message"); + + for input in first_message.input_values.iter() { + prng.commit_input(input); + } + + prng.commit_input(&first_message.witness_multioracle_commitment); + + let beta = prng.get_challenge(); + let gamma = prng.get_challenge(); + + let first_verifier_message = FirstVerifierMessage:: { + beta, + gamma, + }; + + let (second_state, second_message) = prover.second_step_from_first_step( + first_state, + first_verifier_message, + &permutations, + &worker + )?; + + println!("Second message"); + + prng.commit_input(&second_message.grand_product_oracle_commitment); + + let alpha = prng.get_challenge(); + + let second_verifier_message = SecondVerifierMessage:: { + alpha, + beta, + gamma, + }; + + let (third_state, third_message) = prover.third_step_from_second_step( + second_state, + second_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Third message"); + + prng.commit_input(&third_message.quotient_poly_oracle_commitment); + + let z = prng.get_challenge(); + + let third_verifier_message = ThirdVerifierMessage:: { + alpha, + beta, + gamma, + z, + }; + + let (fourth_state, fourth_message) = prover.fourth_step_from_third_step( + third_state, + third_verifier_message, + &setup_multioracle, + &worker + )?; + + println!("Fourth message"); + + let mut wire_values_at_z = fourth_message.wire_values_at_z; + wire_values_at_z.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z: Vec<_> = wire_values_at_z.into_iter().map(|el| el.1).collect(); + + let mut wire_values_at_z_omega = fourth_message.wire_values_at_z_omega; + wire_values_at_z_omega.sort_by(|a, b| a.0.cmp(&b.0)); + + let wire_values_at_z_omega: Vec<_> = wire_values_at_z_omega.into_iter().map(|el| el.1).collect(); + + for w in wire_values_at_z.iter() + .chain(&wire_values_at_z_omega) + .chain(&Some(fourth_message.grand_product_at_z)) + .chain(&Some(fourth_message.grand_product_at_z_omega)) + .chain(&fourth_message.quotient_polynomial_parts_at_z) + .chain(&fourth_message.setup_values_at_z) + .chain(&fourth_message.permutation_polynomials_at_z) + .chain(&fourth_message.gate_selector_polynomials_at_z) + { + prng.commit_input(&w); + } + + let v = prng.get_challenge(); + + let fourth_verifier_message = FourthVerifierMessage:: { + alpha, + beta, + gamma, + z, + v, + }; + + let fifth_message = prover.fifth_step_from_fourth_step( + fourth_state, + fourth_verifier_message, + &setup_multioracle, + &mut prng, + &worker + )?; + + println!("Fifth message"); + + use std::sync::atomic::{AtomicUsize, Ordering}; + use super::redshift::tree_hash::COUNTER; + + let num_hashes = COUNTER.load(Ordering::Relaxed); + + println!("Num hash invocations: {}", num_hashes); + + Ok(()) +} + + +#[cfg(test)] +mod test { + use super::*; + + use crate::pairing::Engine; + use crate::pairing::ff::PrimeField; + + struct TestCircuit4{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4 { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + // 2a - b = 0 + + let two_a = ArithmeticTerm::from_variable_and_coeff(a, two); + let minus_b = ArithmeticTerm::from_variable_and_coeff(b, negative_one); + let mut term = MainGateTerm::new(); + term.add_assign(two_a); + term.add_assign(minus_b); + + cs.allocate_main_gate(term)?; + + // c - a*b == 0 + + let mut ab_term = ArithmeticTerm::from_variable(a).mul_by_variable(b); + ab_term.scale(&negative_one); + let c_term = ArithmeticTerm::from_variable(c); + let mut term = MainGateTerm::new(); + term.add_assign(c_term); + term.add_assign(ab_term); + + cs.allocate_main_gate(term)?; + + // d - 100 == 0 + + let hundred = ArithmeticTerm::constant(E::Fr::from_str("100").unwrap()); + let d_term = ArithmeticTerm::from_variable(d); + let mut term = MainGateTerm::new(); + term.add_assign(d_term); + term.sub_assign(hundred); + + cs.allocate_main_gate(term)?; + + let gamma = cs.alloc_input(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + // gamma - b == 0 + + let gamma_term = ArithmeticTerm::from_variable(gamma); + let b_term = ArithmeticTerm::from_variable(b); + let mut term = MainGateTerm::new(); + term.add_assign(gamma_term); + term.sub_assign(b_term); + + cs.allocate_main_gate(term)?; + + // 2a + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable_and_coeff(a, two)); + + let dummy = CS::get_dummy_variable(); + + // 2a - d_next = 0 + + let (vars, mut coeffs) = CS::MainGate::format_term(term, dummy)?; + *coeffs.last_mut().unwrap() = negative_one; + + // here d is equal = 2a, so we need to place b there + // and compensate it with -b somewhere before + + cs.new_single_gate_for_trace_step(CS::MainGate::static_description(), + &coeffs, + &vars, + &[] + )?; + + let mut term = MainGateTerm::::new(); + term.add_assign(ArithmeticTerm::from_variable(b)); + + // b + 0 + 0 - b = 0 + let (mut vars, mut coeffs) = CS::MainGate::format_term(term, dummy)?; + coeffs[3] = negative_one; + vars[3] = b; + + cs.new_single_gate_for_trace_step(CS::MainGate::static_description(), + &coeffs, + &vars, + &[] + )?; + + Ok(()) + } + } + + #[test] + fn test_trivial_circuit_with_gate_agnostic_cs() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + assert!(assembly.constraints.len() == 1); + + // println!("Assembly state polys = {:?}", assembly.storage.state_map); + + // println!("Assembly setup polys = {:?}", assembly.storage.setup_map); + + println!("Assembly contains {} gates", assembly.n()); + + assert!(assembly.is_satisfied()); + + assembly.finalize(); + + let worker = Worker::new(); + + let (_storage, _permutation_polys) = assembly.perform_setup(&worker).unwrap(); + } + + #[test] + #[cfg(feature = "redshift")] + fn test_make_setup_for_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + use super::super::redshift::setup::*; + use super::super::redshift::prover::*; + use super::super::redshift::tree_hash::*; + use rescue_hash::bn256::Bn256RescueParams; + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + assert!(assembly.constraints.len() == 1); + + // println!("Assembly state polys = {:?}", assembly.storage.state_map); + + // println!("Assembly setup polys = {:?}", assembly.storage.setup_map); + + println!("Assembly contains {} gates", assembly.n()); + + assert!(assembly.is_satisfied()); + + assembly.finalize(); + + let params = Bn256RescueParams::new_checked_2_into_1(); + let hasher = RescueBinaryTreeHasher::::new(¶ms); + + let worker = Worker::new(); + + let (setup_multioracle, mut permutations) = SetupMultioracle::from_assembly( + assembly, + hasher.clone(), + &worker + ).unwrap(); + + let mut assembly = TrivialAssembly::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + assembly.finalize(); + + let (prover, first_state, first_message) = RedshiftProver::first_step( + assembly, + hasher.clone(), + &worker + ).unwrap(); + + let first_verifier_message = FirstVerifierMessage:: { + beta: Fr::from_str("123").unwrap(), + gamma: Fr::from_str("456").unwrap(), + }; + + // cut permutations + + for p in permutations.iter_mut() { + p.pop_last().unwrap(); + } + + let (second_state, second_message) = prover.second_step_from_first_step( + first_state, + first_verifier_message, + &permutations, + &worker + ).unwrap(); + + let second_verifier_message = SecondVerifierMessage:: { + alpha: Fr::from_str("789").unwrap(), + beta: Fr::from_str("123").unwrap(), + gamma: Fr::from_str("456").unwrap(), + }; + + let (third_state, third_message) = prover.third_step_from_second_step( + second_state, + second_verifier_message, + &setup_multioracle, + &worker + ).unwrap(); + + let third_verifier_message = ThirdVerifierMessage:: { + alpha: Fr::from_str("789").unwrap(), + beta: Fr::from_str("123").unwrap(), + gamma: Fr::from_str("456").unwrap(), + z: Fr::from_str("1337").unwrap() + }; + + let (fourth_state, fourth_message) = prover.fourth_step_from_third_step( + third_state, + third_verifier_message, + &setup_multioracle, + &worker + ).unwrap(); + + let fourth_verifier_message = FourthVerifierMessage:: { + alpha: Fr::from_str("789").unwrap(), + beta: Fr::from_str("123").unwrap(), + gamma: Fr::from_str("456").unwrap(), + z: Fr::from_str("1337").unwrap(), + v: Fr::from_str("97531").unwrap(), + }; + + use crate::plonk::commitments::transcript::{Prng, rescue_transcript}; + + let mut prng = rescue_transcript::RescueTranscript::::from_params(¶ms); + prng.commit_input(&Fr::from_str("97531").unwrap()); + + let fifth_message = prover.fifth_step_from_fourth_step( + fourth_state, + fourth_verifier_message, + &setup_multioracle, + &mut prng, + &worker + ).unwrap(); + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/data_structures.rs b/src/plonk/better_better_cs/data_structures.rs new file mode 100644 index 000000000..a2d5fae4b --- /dev/null +++ b/src/plonk/better_better_cs/data_structures.rs @@ -0,0 +1,332 @@ +use crate::pairing::ff::*; +use crate::pairing::*; +use crate::plonk::polynomials::*; +use super::cs::GateInternal; + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum PolyIdentifier { + VariablesPolynomial(usize), + WitnessPolynomial(usize), + GateSetupPolynomial(&'static str, usize), + GateSelector(&'static str), + LookupSelector, + LookupTableEntriesPolynomial(usize), + NamedSetupPolynomial(&'static str), + PermutationPolynomial(usize), +} + +pub const LOOKUP_TABLE_TYPE_POLYNOMIAL: &'static str = "LOOKUP_TABLE_TYPE_POLYNOMIAL"; + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct TimeDilation(pub usize); +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct PolynomialInConstraint(pub PolyIdentifier, pub TimeDilation); + +impl PolynomialInConstraint{ + pub const fn from_id(id: PolyIdentifier) -> Self { + Self(id, TimeDilation(0)) + } + pub const fn from_id_and_dilation(id: PolyIdentifier, dilation: usize) -> Self { + Self(id, TimeDilation(dilation)) + } + pub const fn into_id_and_raw_dilation(self) -> (PolyIdentifier, usize) { + (self.0, (self.1).0) + } +} + +pub enum PolynomialProxy<'a, F: PrimeField, P: PolynomialForm> { + Borrowed(&'a Polynomial), + Owned(Polynomial), +} + +impl<'a, F: PrimeField, P: PolynomialForm> PolynomialProxy<'a, F, P> { + pub fn from_owned(poly: Polynomial) -> Self { + PolynomialProxy::Owned(poly) + } + + pub fn from_borrowed(poly: &'a Polynomial) -> Self { + PolynomialProxy::Borrowed(poly) + } + + pub fn as_ref(&self) -> &Polynomial { + match self { + PolynomialProxy::Borrowed(b) => { + &*b + }, + PolynomialProxy::Owned(o) => { + &o + } + } + } + + pub fn as_data_ref(&self) -> &[F] { + match self { + PolynomialProxy::Borrowed(b) => { + b.as_ref() + }, + PolynomialProxy::Owned(o) => { + o.as_ref() + } + } + } + + pub fn as_data_ref_mut(&mut self) -> &mut [F] { + match self { + PolynomialProxy::Borrowed(..) => { + unreachable!("Can not borrow mutable for non-owned proxy") + }, + PolynomialProxy::Owned(o) => { + o.as_mut() + } + } + } + + pub fn into_poly(self) -> Polynomial { + match self { + PolynomialProxy::Borrowed(b) => { + b.clone() + }, + PolynomialProxy::Owned(o) => { + o + } + } + } + + pub fn clone_as_owned(&self) -> Self { + match self { + PolynomialProxy::Borrowed(ref b) => { + PolynomialProxy::Owned((*b).clone()) + }, + PolynomialProxy::Owned(o) => { + PolynomialProxy::Owned(o.clone()) + } + } + } +} + +pub fn clone_as_borrowed<'a, 'b: 'a, F: PrimeField, P: PolynomialForm>( + src: &'a PolynomialProxy<'b, F, P> +) -> PolynomialProxy<'a, F, P> { + match src { + PolynomialProxy::Borrowed(ref b) => { + PolynomialProxy::Borrowed(*b) + }, + PolynomialProxy::Owned(ref o) => { + PolynomialProxy::Borrowed(o) + } + } +} + +// impl<'a, F: PrimeField, P: PolynomialForm> Clone for PolynomialProxy<'a, F, P> { +// fn clone(&self) -> Self { +// match self { +// PolynomialProxy::Borrowed(ref b) => { +// PolynomialProxy::Borrowed(b) +// }, +// PolynomialProxy::Owned(ref o) => { +// PolynomialProxy::Borrowed(o) +// } +// } +// } +// } + + +pub struct AssembledPolynomialStorage<'a, E: Engine> { + pub state_map: std::collections::HashMap>, + pub witness_map: std::collections::HashMap>, + pub setup_map: std::collections::HashMap>, + pub scratch_space: std::collections::HashMap>, + pub gate_selectors: std::collections::HashMap>, + pub named_polys: std::collections::HashMap>, + pub is_bitreversed: bool, + pub lde_factor: usize +} + +pub struct AssembledPolynomialStorageForMonomialForms<'a, E: Engine> { + pub state_map: std::collections::HashMap>, + pub witness_map: std::collections::HashMap>, + pub setup_map: std::collections::HashMap>, + pub gate_selectors: std::collections::HashMap>, + pub named_polys: std::collections::HashMap>, +} + +impl<'a, E: Engine> AssembledPolynomialStorage<'a, E> { + pub fn get_poly(&self, id: PolyIdentifier) -> &Polynomial { + match id { + p @ PolyIdentifier::VariablesPolynomial(..) => { + self.state_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::WitnessPolynomial(..) => { + self.witness_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::GateSetupPolynomial(..) => { + self.setup_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::GateSelector(..) => { + self.gate_selectors.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::PermutationPolynomial(..) => { + self.setup_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::LookupSelector => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::LookupTableEntriesPolynomial(..) => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::NamedSetupPolynomial(..) => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + _ => { + unreachable!() + } + } + } + pub fn get_poly_at_step(&self, id: PolyIdentifier, step: usize) -> E::Fr { + assert!(self.is_bitreversed == false); + assert!(self.lde_factor == 1); + let p = self.get_poly(id); + p.as_ref()[step] + } + + pub fn get_selector_for_gate(&self, gate: &dyn GateInternal) -> &Polynomial { + let gate_name = gate.name(); + let p = PolyIdentifier::GateSelector(gate_name); + self.gate_selectors.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + } + + pub fn new(bitreversed: bool, lde_factor: usize) -> Self { + Self { + state_map: std::collections::HashMap::new(), + witness_map: std::collections::HashMap::new(), + setup_map: std::collections::HashMap::new(), + gate_selectors: std::collections::HashMap::new(), + scratch_space: std::collections::HashMap::new(), + named_polys: std::collections::HashMap::new(), + is_bitreversed: bitreversed, + lde_factor + } + } + + pub fn add_setup_polys<'b: 'a>(&mut self, ids: &[PolyIdentifier], polys: &'b [Polynomial]) { + assert_eq!(ids.len(), polys.len()); + for (id, poly) in ids.iter().zip(polys.iter()) { + let proxy = PolynomialProxy::from_borrowed(poly); + + match id { + p @ PolyIdentifier::GateSetupPolynomial(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::GateSelector(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::PermutationPolynomial(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::LookupSelector => { + self.named_polys.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::LookupTableEntriesPolynomial(..) => { + self.named_polys.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::NamedSetupPolynomial(..) => { + self.named_polys.insert(p.clone(), proxy); + }, + _ => { + unreachable!() + } + } + } + } +} + +impl<'a, E: Engine> AssembledPolynomialStorageForMonomialForms<'a, E> { + pub fn get_poly(&self, id: PolyIdentifier) -> &Polynomial { + match id { + p @ PolyIdentifier::VariablesPolynomial(..) => { + self.state_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::WitnessPolynomial(..) => { + self.witness_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::GateSetupPolynomial(..) => { + self.setup_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::GateSelector(..) => { + self.gate_selectors.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::PermutationPolynomial(..) => { + self.setup_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::LookupSelector => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::LookupTableEntriesPolynomial(..) => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + p @ PolyIdentifier::NamedSetupPolynomial(..) => { + self.named_polys.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + }, + } + } + + pub fn new() -> Self { + Self { + state_map: std::collections::HashMap::new(), + witness_map: std::collections::HashMap::new(), + setup_map: std::collections::HashMap::new(), + gate_selectors: std::collections::HashMap::new(), + named_polys: std::collections::HashMap::new(), + } + } + + pub fn get_selector_for_gate(&self, gate: &dyn GateInternal) -> &Polynomial { + let gate_name = gate.name(); + let p = PolyIdentifier::GateSelector(gate_name); + self.state_map.get(&p).expect(&format!("poly {:?} must exist", p)).as_ref() + } + + pub fn add_setup_polys<'b: 'a>(&mut self, ids: &[PolyIdentifier], polys: &'b [Polynomial]) { + assert_eq!(ids.len(), polys.len()); + for (id, poly) in ids.iter().zip(polys.iter()) { + let proxy = PolynomialProxy::from_borrowed(poly); + + match id { + p @ PolyIdentifier::GateSetupPolynomial(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::GateSelector(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::PermutationPolynomial(..) => { + self.setup_map.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::LookupSelector => { + self.named_polys.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::LookupTableEntriesPolynomial(..) => { + self.named_polys.insert(p.clone(), proxy); + }, + p @ PolyIdentifier::NamedSetupPolynomial(..) => { + self.named_polys.insert(p.clone(), proxy); + } + _ => { + unreachable!() + } + } + } + } +} + +pub struct LookupDataHolder<'a, E: Engine> { + pub eta: E::Fr, + pub f_poly_unpadded_values: Option>, + pub t_poly_unpadded_values: Option>, + pub t_shifted_unpadded_values: Option>, + pub s_poly_unpadded_values: Option>, + pub s_shifted_unpadded_values: Option>, + pub t_poly_monomial: Option>, + pub s_poly_monomial: Option>, + pub selector_poly_monomial: Option>, + pub table_type_poly_monomial: Option>, +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/gadgets/assignment.rs b/src/plonk/better_better_cs/gadgets/assignment.rs new file mode 100644 index 000000000..eb7b31893 --- /dev/null +++ b/src/plonk/better_better_cs/gadgets/assignment.rs @@ -0,0 +1,24 @@ +use crate::{ + SynthesisError +}; + +pub trait Assignment { + fn get(&self) -> Result<&T, SynthesisError>; + fn grab(self) -> Result; +} + +impl Assignment for Option { + fn get(&self) -> Result<&T, SynthesisError> { + match self { + Some(v) => Ok(v), + None => Err(SynthesisError::AssignmentMissing) + } + } + + fn grab(self) -> Result { + match self { + Some(v) => Ok(v), + None => Err(SynthesisError::AssignmentMissing) + } + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/gadgets/mod.rs b/src/plonk/better_better_cs/gadgets/mod.rs new file mode 100644 index 000000000..a149720d6 --- /dev/null +++ b/src/plonk/better_better_cs/gadgets/mod.rs @@ -0,0 +1,3 @@ +mod num; +mod rescue; +mod assignment; \ No newline at end of file diff --git a/src/plonk/better_better_cs/gadgets/num.rs b/src/plonk/better_better_cs/gadgets/num.rs new file mode 100644 index 000000000..bab6c564b --- /dev/null +++ b/src/plonk/better_better_cs/gadgets/num.rs @@ -0,0 +1,184 @@ +use crate::pairing::{ + Engine, +}; + +use crate::pairing::ff::{ + Field, + PrimeField, + PrimeFieldRepr, + BitIterator +}; + +use crate::{ + SynthesisError, +}; + +use crate::plonk::better_better_cs::cs::{ + Variable, + ConstraintSystem, + ArithmeticTerm, + MainGateTerm +}; + +use super::assignment::{ + Assignment +}; + +use std::ops::{Add, Sub}; + +pub struct AllocatedNum { + value: Option, + variable: Variable +} + +impl Clone for AllocatedNum { + fn clone(&self) -> Self { + AllocatedNum { + value: self.value, + variable: self.variable + } + } +} + +impl AllocatedNum { + pub fn get_variable(&self) -> Variable { + self.variable + } + + pub fn get_value(&self) -> Option { + self.value + } + + pub fn alloc( + cs: &mut CS, + value: F, + ) -> Result + where CS: ConstraintSystem, + F: FnOnce() -> Result + { + let mut new_value = None; + let var = cs.alloc( + || { + let tmp = value()?; + + new_value = Some(tmp); + + Ok(tmp) + } + )?; + + Ok(AllocatedNum { + value: new_value, + variable: var + }) + } + + pub fn add( + &self, + cs: &mut CS, + other: &Self + ) -> Result + where CS: ConstraintSystem + { + let mut value = None; + + let addition_result = cs.alloc(|| { + let mut tmp = *self.value.get()?; + tmp.add_assign(other.value.get()?); + + value = Some(tmp); + + Ok(tmp) + })?; + + let self_term = ArithmeticTerm::from_variable(self.variable); + let other_term = ArithmeticTerm::from_variable(other.variable); + let result_term = ArithmeticTerm::from_variable(addition_result); + let mut term = MainGateTerm::new(); + term.add_assign(self_term); + term.add_assign(other_term); + term.sub_assign(result_term); + + cs.allocate_main_gate(term)?; + + Ok(AllocatedNum { + value: value, + variable: addition_result + }) + } + + pub fn add_constant( + &self, + cs: &mut CS, + constant: E::Fr + ) -> Result + where CS: ConstraintSystem + { + let mut value = None; + + let addition_result = cs.alloc(|| { + let mut tmp = *self.value.get()?; + tmp.add_assign(&constant); + + value = Some(tmp); + + Ok(tmp) + })?; + + let self_term = ArithmeticTerm::from_variable(self.variable); + let other_term = ArithmeticTerm::constant(constant); + let result_term = ArithmeticTerm::from_variable(addition_result); + let mut term = MainGateTerm::new(); + term.add_assign(self_term); + term.add_assign(other_term); + term.sub_assign(result_term); + + cs.allocate_main_gate(term)?; + + Ok(AllocatedNum { + value: value, + variable: addition_result + }) + } + + pub fn mul( + &self, + cs: &mut CS, + other: &Self + ) -> Result + where CS: ConstraintSystem + { + let mut value = None; + + let product = cs.alloc(|| { + let mut tmp = *self.value.get()?; + tmp.mul_assign(other.value.get()?); + + value = Some(tmp); + + Ok(tmp) + })?; + + let self_term = ArithmeticTerm::from_variable(self.variable).mul_by_variable(other.variable); + let result_term = ArithmeticTerm::from_variable(product); + let mut term = MainGateTerm::new(); + term.add_assign(self_term); + term.sub_assign(result_term); + + cs.allocate_main_gate(term)?; + + Ok(AllocatedNum { + value: value, + variable: product + }) + } + + pub fn square( + &self, + cs: &mut CS, + ) -> Result + where CS: ConstraintSystem + { + self.mul(cs, &self) + } +} diff --git a/src/plonk/better_better_cs/gadgets/rescue.rs b/src/plonk/better_better_cs/gadgets/rescue.rs new file mode 100644 index 000000000..8315629e7 --- /dev/null +++ b/src/plonk/better_better_cs/gadgets/rescue.rs @@ -0,0 +1,493 @@ +use crate::pairing::{ + Engine, +}; + +use crate::pairing::ff::{ + Field, + PrimeField, + PrimeFieldRepr, + BitIterator +}; + +use crate::{ + SynthesisError, +}; + +use crate::plonk::better_better_cs::cs::{ + Variable, + ConstraintSystem, + ArithmeticTerm, + MainGateTerm, + Width4MainGateWithDNextEquation, + MainGateEquation, + GateEquationInternal, + GateEquation, + LinearCombinationOfTerms, + PolynomialMultiplicativeTerm, + PolynomialInConstraint, + TimeDilation +}; + +use super::assignment::{ + Assignment +}; + +use super::num::{AllocatedNum}; + +use crate::plonk::better_better_cs::cs::PlonkConstraintSystemParams; + +pub struct Rescue125 { + _marker: std::marker::PhantomData +} + +enum RescueStateSimplifier { + Number(AllocatedNum), + Constant(E::Fr) +} + + +#[derive(Clone, Debug, Hash)] +pub struct Rescue5CustomGate(pub [LinearCombinationOfTerms; 3]); + +impl GateEquationInternal for Rescue5CustomGate { + fn degree(&self) -> usize { + 2 + } + + fn num_constraints(&self) -> usize { + 3 + } + + fn get_constraint(&self) -> &LinearCombinationOfTerms { + unreachable!("must not try to access single constraint of Rescue alpha 5 gate"); + } + + fn get_constraints(&self) -> &[LinearCombinationOfTerms] { + &self.0[..] + } +} + +impl GateEquation for Rescue5CustomGate { + // Width4MainGateWithDNextEquation is NOT generic, so this is fine + // and safe since it's sync! + fn static_description() -> &'static Self { + static mut VALUE: Option = None; + static INIT: std::sync::Once = std::sync::Once::new(); + + unsafe { + INIT.call_once(||{ + VALUE = Some(Rescue5CustomGate::default()); + }); + + VALUE.as_ref().unwrap() + } + } +} + + +impl std::default::Default for Rescue5CustomGate { + fn default() -> Self { + Self::get_equation() + } +} + +impl Rescue5CustomGate { + pub fn get_equation() -> Self { + let mut term_square: Vec = Vec::with_capacity(2); + // constant + term_square.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(0, TimeDilation(0)), + PolynomialInConstraint::VariablesPolynomial(0, TimeDilation(0)) + ] + ) + ); + + term_square.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(1, TimeDilation(0)) + ] + ) + ); + + let mut term_quad: Vec = Vec::with_capacity(2); + // constant + term_quad.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(1, TimeDilation(0)), + PolynomialInConstraint::VariablesPolynomial(1, TimeDilation(0)) + ] + ) + ); + + term_quad.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(2, TimeDilation(0)) + ] + ) + ); + + let mut term_fifth: Vec = Vec::with_capacity(2); + // constant + term_fifth.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(0, TimeDilation(0)), + PolynomialInConstraint::VariablesPolynomial(2, TimeDilation(0)) + ] + ) + ); + + term_fifth.push( + PolynomialMultiplicativeTerm( + vec![ + PolynomialInConstraint::VariablesPolynomial(3, TimeDilation(0)) + ] + ) + ); + + Self([ + LinearCombinationOfTerms(term_square), + LinearCombinationOfTerms(term_quad), + LinearCombinationOfTerms(term_fifth)]) + } +} + +impl Rescue125 { + const RATE: usize = 2; + const CAPACITY: usize = 1; + const STATE_WIDTH: usize = Self::RATE + Self::CAPACITY; + const ALPHA: u64 = 5; + const NUM_ROUNDS_DOUBLED: usize = 44; + + pub fn hash>( + cs: &mut CS, + input: &[AllocatedNum] + ) -> Result, SynthesisError> { + assert_eq!(input.len(), Self::RATE); + assert_eq!(CS::Params::STATE_WIDTH, 4); + assert!(CS::Params::CAN_ACCESS_NEXT_TRACE_STEP); + + let one = E::Fr::one(); + let zero = E::Fr::zero(); + let mut minus_one = one; + minus_one.negate(); + + let mut round_constant_placeholder = E::Fr::one(); + round_constant_placeholder.double(); + + let dummy_var = CS::get_dummy_variable(); + + // with first sbox + // (input[0] + round_constant[0]) ^ [alpha_inv] -> state[0] + // (input[1] + round_constant[1]) ^ [alpha_inv] -> state[1] + // round_constant[2] ^ [alpha_inv] -> state[2] + + // but we proof otherwise + // state[0] ^ 5 = (input[0] + round_constant[0]) + // state[1] ^ 5 = (input[1] + round_constant[1]) + // state[2] = constant + + // with state width of 4 we can have + + // a = state[0] + // b = state[0] ^ 2 + // c = state[0] ^ 4 = b^2 + // d = c * a = state[0]^5 + + // and BEFORE it we have a gate + // input[0] + round_constant[0] - d_next = 0 + + let state_0 = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + let state_0_squared = state_0.clone(); + let state_0_quad = state_0.clone(); + let state_0_fifth = state_0.clone(); + + let state_1 = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + let state_1_squared = state_1.clone(); + let state_1_quad = state_1.clone(); + let state_1_fifth = state_1.clone(); + + // input[0] + round_constant[0] - state[0]^5 = 0 + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[one, minus_one, zero, zero, zero, round_constant_placeholder, zero], + &[input[0].get_variable(), state_0_fifth.get_variable(), dummy_var, dummy_var], + &[] + )?; + + // now it's time for a custom gate + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_0.get_variable(), state_0_squared.get_variable(), state_0_quad.get_variable(), state_0_fifth.get_variable()], + &[] + )?; + + // same for input[1] + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[one, minus_one, zero, zero, zero, round_constant_placeholder, zero], + &[input[1].get_variable(), state_0_fifth.get_variable(), dummy_var, dummy_var], + &[] + )?; + + // now it's time for a custom gate + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_1.get_variable(), state_1_squared.get_variable(), state_1_quad.get_variable(), state_1_fifth.get_variable()], + &[] + )?; + + // now apply MDS, add constants and make next sbox manually + // state_0 * coeff + state_1 * coeff + constant + round_constant + // + + let mut state_0_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, minus_one, zero, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_0_after_mds_and_round_const.get_variable(), dummy_var], + &[] + )?; + + let mut state_1_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, minus_one, zero, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_1_after_mds_and_round_const.get_variable(), dummy_var], + &[] + )?; + + let mut state_2_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, minus_one, zero, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_2_after_mds_and_round_const.get_variable(), dummy_var], + &[] + )?; + + for round in 1..Self::NUM_ROUNDS_DOUBLED { + let (state_0, state_1, state_2) = if round & 1 == 0 { + let state_0 = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + let state_0_squared = state_0.clone(); + let state_0_quad = state_0.clone(); + + let state_1 = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + let state_1_squared = state_1.clone(); + let state_1_quad = state_1.clone(); + + let state_2 = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + let state_2_squared = state_2.clone(); + let state_2_quad = state_2.clone(); + + // now it's time for a custom gates cause we already had round constant added + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_0.get_variable(), state_0_squared.get_variable(), state_0_quad.get_variable(), state_0_after_mds_and_round_const.get_variable()], + &[] + )?; + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_1.get_variable(), state_1_squared.get_variable(), state_1_quad.get_variable(), state_1_after_mds_and_round_const.get_variable()], + &[] + )?; + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_2.get_variable(), state_2_squared.get_variable(), state_2_quad.get_variable(), state_2_after_mds_and_round_const.get_variable()], + &[] + )?; + + (state_0, state_1, state_2) + } else { + // this s-box is just making into 5th power + + let state_0_squared = state_0_after_mds_and_round_const.clone(); + let state_0_quad = state_0_after_mds_and_round_const.clone(); + let state_0_fifth = state_0_after_mds_and_round_const.clone(); + + let state_1_squared = state_1_after_mds_and_round_const.clone(); + let state_1_quad = state_1_after_mds_and_round_const.clone(); + let state_1_fifth = state_1_after_mds_and_round_const.clone(); + + let state_2_squared = state_2_after_mds_and_round_const.clone(); + let state_2_quad = state_2_after_mds_and_round_const.clone(); + let state_2_fifth = state_2_after_mds_and_round_const.clone(); + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_0_after_mds_and_round_const.get_variable(), state_0_squared.get_variable(), state_0_quad.get_variable(), state_0_fifth.get_variable()], + &[] + )?; + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_1_after_mds_and_round_const.get_variable(), state_1_squared.get_variable(), state_1_quad.get_variable(), state_1_fifth.get_variable()], + &[] + )?; + + cs.new_single_gate_for_trace_step( + Rescue5CustomGate::static_description(), + &[], + &[state_2_after_mds_and_round_const.get_variable(), state_2_squared.get_variable(), state_2_quad.get_variable(), state_2_fifth.get_variable()], + &[] + )?; + + (state_0_fifth, state_1_fifth, state_2_fifth) + }; + + // mds and constant + + state_0_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, round_constant_placeholder, minus_one, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_2.get_variable(), state_0_after_mds_and_round_const.get_variable()], + &[] + )?; + + state_1_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, round_constant_placeholder, minus_one, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_2.get_variable(), state_1_after_mds_and_round_const.get_variable()], + &[] + )?; + + state_2_after_mds_and_round_const = AllocatedNum::::alloc( + cs, + || { + Ok(E::Fr::one()) + } + )?; + + cs.new_single_gate_for_trace_step( + Width4MainGateWithDNextEquation::static_description(), + &[round_constant_placeholder, round_constant_placeholder, round_constant_placeholder, minus_one, round_constant_placeholder, zero, zero], + &[state_0.get_variable(), state_1.get_variable(), state_2.get_variable(), state_2_after_mds_and_round_const.get_variable()], + &[] + )?; + } + + Ok(state_0_after_mds_and_round_const) + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::plonk::better_better_cs::cs::*; + + #[test] + fn test_trivial_circuit_with_gate_agnostic_cs() { + use crate::pairing::bn256::{Bn256, Fr}; + + let mut assembly = TrivialAssembly::::new(); + let before = assembly.n; + + let input_0 = AllocatedNum::alloc( + &mut assembly, + || { + Ok(Fr::one()) + } + ).unwrap(); + + let input_1 = AllocatedNum::alloc( + &mut assembly, + || { + Ok(Fr::one()) + } + ).unwrap(); + + let _ = Rescue125::hash(&mut assembly, &vec![input_0, input_1]).unwrap(); + + assert!(assembly.constraints.len() == 2); + let num_gates = assembly.n - before; + println!("Single rescue r = 2, c = 1, alpha = 5 invocation takes {} gates", num_gates); + + for (gate, density) in assembly.gate_density.0.into_iter() { + println!("Custom gate {:?} selector = {:?}", gate, density); + } + + // println!("Assembly state polys = {:?}", assembly.storage.state_map); + + // println!("Assembly setup polys = {:?}", assembly.storage.setup_map); + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/lookup_tables.rs b/src/plonk/better_better_cs/lookup_tables.rs new file mode 100644 index 000000000..31feb4267 --- /dev/null +++ b/src/plonk/better_better_cs/lookup_tables.rs @@ -0,0 +1,708 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; +use crate::bit_vec::BitVec; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::worker::Worker; +use crate::plonk::domains::*; +use crate::plonk::polynomials::*; + +pub use crate::plonk::cs::variable::*; +use crate::plonk::better_cs::utils::*; +use super::cs::*; +use super::data_structures::*; + +pub const RANGE_CHECK_SINGLE_APPLICATION_TABLE_NAME: &'static str = "Range check table for a single column"; + +pub trait LookupTableInternal: Send + + Sync + + 'static + + std::any::Any + + std::fmt::Debug { + fn name(&self) -> &'static str; + fn table_size(&self) -> usize; + fn num_keys(&self) -> usize; + fn num_values(&self) -> usize; + fn allows_combining(&self) -> bool; + fn is_valid_entry(&self, keys: &[E::Fr], values: &[E::Fr]) -> bool; + fn query(&self, keys: &[E::Fr]) -> Result, SynthesisError>; + fn get_table_values_for_polys(&self) -> Vec>; + fn table_id(&self) -> E::Fr; + fn sort(&self, values: &[E::Fr], column: usize) -> Result, SynthesisError>; + fn box_clone(&self) -> Box>; + fn column_is_trivial(&self, column_num: usize) -> bool; + } + +impl std::hash::Hash for dyn LookupTableInternal { + fn hash(&self, state: &mut H) where H: std::hash::Hasher { + self.type_id().hash(state); + self.name().hash(state); + self.table_size().hash(state); + self.num_keys().hash(state); + self.num_values().hash(state); + } +} + +impl PartialEq for dyn LookupTableInternal { + fn eq(&self, other: &Self) -> bool { + self.type_id() == other.type_id() && + self.name() == other.name() && + self.table_size() == other.table_size() && + self.num_keys() == other.num_keys() && + self.num_values() == other.num_values() + } +} + +impl Eq for dyn LookupTableInternal {} + +/// Applies a single lookup table to a specific set of columns +pub struct LookupTableApplication { + name: &'static str, + apply_over: Vec, + table_to_apply: Box>, + name_generator: Option String) + 'static + Send + Sync>>, + can_be_combined: bool +} + +impl std::fmt::Debug for LookupTableApplication { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("LookupTableApplication") + .field("name", &self.name) + .field("apply_over", &self.apply_over) + .field("table_to_apply", &self.table_to_apply) + .field("can_be_combined", &self.can_be_combined) + .finish() + } +} + +impl PartialEq for LookupTableApplication { + fn eq(&self, other: &Self) -> bool { + self.name == other.name && + self.apply_over == other.apply_over && + &self.table_to_apply == &other.table_to_apply && + self.can_be_combined == other.can_be_combined + } +} + +impl Eq for LookupTableApplication {} + +impl LookupTableApplication { + pub fn new>( + name: &'static str, + table: L, + apply_over: Vec, + name_generator: Option String) + 'static + Send + Sync>>, + can_be_combined: bool + ) -> Self { + Self { + name, + apply_over, + table_to_apply: Box::from(table) as Box>, + name_generator, + can_be_combined + } + } + + pub fn new_range_table_of_width_3(width: usize, over: Vec) -> Result { + let table = RangeCheckTableOverOneColumnOfWidth3::new(width); + + let name = RANGE_CHECK_SINGLE_APPLICATION_TABLE_NAME; + + Ok(Self { + name: name, + apply_over: over, + table_to_apply: table.box_clone(), + name_generator: None, + can_be_combined: true + }) + } + + pub fn new_xor_table(bit_width: usize, over: Vec) -> Result { + Self::new_binop_table::(bit_width, over, "XOR table") + } + + pub fn new_and_table(bit_width: usize, over: Vec) -> Result { + Self::new_binop_table::(bit_width, over, "AND table") + } + + pub fn new_or_table(bit_width: usize, over: Vec) -> Result { + Self::new_binop_table::(bit_width, over, "OR table") + } + + pub fn new_binop_table(bit_width: usize, over: Vec, name: &'static str) -> Result { + let table = TwoKeysOneValueBinopTable::::new(bit_width, name); + + Ok(Self { + name: name, + apply_over: over, + table_to_apply: table.box_clone(), + name_generator: None, + can_be_combined: true + }) + } + + pub fn functional_name(&self) -> String { + if let Some(gen) = self.name_generator.as_ref() { + gen() + } else { + self.name.to_string() + // format!("{} over {:?}", self.table_to_apply.name(), self.apply_over) + } + } + + pub fn applies_over(&self) -> &[PolyIdentifier] { + &self.apply_over + } + + pub fn can_be_combined(&self) -> bool { + self.can_be_combined && self.table_to_apply.allows_combining() + } + + #[track_caller] + pub fn is_valid_entry(&self, values: &[E::Fr]) -> bool { + let num_keys = self.table_to_apply.num_keys(); + let num_values = self.table_to_apply.num_values(); + + assert_eq!(num_keys + num_values, values.len()); + + let (keys, values) = values.split_at(num_keys); + + self.table_to_apply.is_valid_entry(keys, values) + } + + pub fn table_id(&self) -> E::Fr { + self.table_to_apply.table_id() + } + + pub fn size(&self) -> usize { + self.table_to_apply.table_size() + } + + pub fn width(&self) -> usize { + self.table_to_apply.num_keys() + self.table_to_apply.num_values() + } + + pub fn get_table_values_for_polys(&self) -> Vec> { + self.table_to_apply.get_table_values_for_polys() + } + + pub fn query(&self, keys: &[E::Fr]) -> Result, SynthesisError> { + self.table_to_apply.query(keys) + } +} + +/// Apply multiple tables at the same time to corresponding columns +#[derive(Debug)] +pub struct MultiTableApplication { + name: &'static str, + apply_over: Vec, + tables_to_apply: Vec>>, + table_size: usize, + id: E::Fr +} + +impl PartialEq for MultiTableApplication { + fn eq(&self, other: &Self) -> bool { + self.name == other.name && + self.apply_over == other.apply_over && + &self.tables_to_apply == &other.tables_to_apply && + self.table_size == other.table_size + } +} + +impl Eq for MultiTableApplication {} + +impl MultiTableApplication { + pub fn name(&self) -> String { + format!("Table {} of size {}", self.name, self.table_size) + } + + pub fn functional_name(&self) -> String { + self.name.to_string() + } + + pub fn new_range_table_of_width_3(width: usize, over: Vec) -> Result { + let table = RangeCheckTableOverSingleColumn::new(width); + + let name = "Range check table"; + + Ok(Self { + name: name, + apply_over: over, + tables_to_apply: vec![table.box_clone(), table.box_clone(), table.box_clone()], + table_size: 1 << width, + id: table_id_from_string::(name) + }) + } + + pub fn applies_over(&self) -> &[PolyIdentifier] { + &self.apply_over + } + + pub fn is_valid_entry(&self, values: &[E::Fr]) -> bool { + assert_eq!(values.len(), 3); + let mut all_values = values; + let mut valid = true; + for t in self.tables_to_apply.iter() { + let num_keys = t.num_keys(); + let num_values = t.num_values(); + let (keys, rest) = all_values.split_at(num_keys); + let (values, rest) = rest.split_at(num_values); + valid &= t.is_valid_entry(keys, values); + all_values = rest; + } + + valid + } + + pub fn size(&self) -> usize { + self.table_size + } + + pub fn table_id(&self) -> E::Fr { + self.id + } + + pub fn width(&self) -> usize { + let mut width = 0; + for t in self.tables_to_apply.iter() { + width += t.num_keys(); + width += t.num_values(); + } + + width + } +} +#[derive(Clone)] +pub struct RangeCheckTableOverSingleColumn { + table_entries: Vec, + entries_map: std::collections::HashMap, + bits: usize +} + +impl RangeCheckTableOverSingleColumn { + pub fn new(bits: usize) -> Self { + let mut entries = Vec::with_capacity(1 << bits); + let mut map = std::collections::HashMap::with_capacity(1 << bits); + for i in 0..(1 << bits) { + let value = E::Fr::from_str(&i.to_string()).unwrap(); + entries.push(value); + map.insert(value, i); + } + + Self { + table_entries: entries, + entries_map: map, + bits + } + } +} + +impl std::fmt::Debug for RangeCheckTableOverSingleColumn { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("RangeCheckTableOverSingleColumn") + .field("bits", &self.bits) + .finish() + } +} + +impl LookupTableInternal for RangeCheckTableOverSingleColumn { + fn name(&self) -> &'static str { + RANGE_CHECK_SINGLE_APPLICATION_TABLE_NAME + } + fn table_size(&self) -> usize { + debug_assert_eq!(1usize << self.bits, self.table_entries.len()); + 1usize << self.bits + } + fn num_keys(&self) -> usize { + 1 + } + fn num_values(&self) -> usize { + 0 + } + fn allows_combining(&self) -> bool { + false + } + fn is_valid_entry(&self, keys: &[E::Fr], values: &[E::Fr]) -> bool { + assert!(keys.len() == 1); + assert!(values.len() == 0); + + self.table_entries.contains(&keys[0]) + } + fn query(&self, keys: &[E::Fr]) -> Result, SynthesisError> { + assert!(keys.len() == 1); + + if self.entries_map.get(&keys[0]).is_some() { + return Ok(vec![]); + } else { + return Err(SynthesisError::Unsatisfiable); + } + } + fn get_table_values_for_polys(&self) -> Vec> { + vec![self.table_entries.clone()] + } + fn table_id(&self) -> E::Fr { + table_id_from_string(self.name()) + } + fn sort(&self, _values: &[E::Fr], _column: usize) -> Result, SynthesisError> { + unimplemented!() + } + fn box_clone(&self) -> Box> { + Box::from(self.clone()) + } + fn column_is_trivial(&self, column_num: usize) -> bool { + assert!(column_num < 1); + + false + } +} + +#[derive(Clone)] +pub struct RangeCheckTableOverOneColumnOfWidth3 { + table_entries: Vec, + dummy_entries: Vec, + bits: usize +} + +impl RangeCheckTableOverOneColumnOfWidth3 { + pub fn new(bits: usize) -> Self { + let mut entries = Vec::with_capacity(1 << bits); + for i in 0..(1 << bits) { + let value = E::Fr::from_str(&i.to_string()).unwrap(); + entries.push(value); + } + + let dummy_entries = vec![E::Fr::zero(); 1 << bits]; + Self { + table_entries: entries, + dummy_entries, + bits + } + } +} + +impl std::fmt::Debug for RangeCheckTableOverOneColumnOfWidth3 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("RangeCheckTableOverOneColumnOfWidth3") + .field("bits", &self.bits) + .finish() + } +} + +impl LookupTableInternal for RangeCheckTableOverOneColumnOfWidth3 { + fn name(&self) -> &'static str { + "Range check table for a single column only with width 3" + } + fn table_size(&self) -> usize { + debug_assert_eq!(1usize << self.bits, self.table_entries.len()); + 1usize << self.bits + } + fn num_keys(&self) -> usize { + 3 + } + fn num_values(&self) -> usize { + 0 + } + fn allows_combining(&self) -> bool { + true + } + fn is_valid_entry(&self, keys: &[E::Fr], values: &[E::Fr]) -> bool { + assert!(keys.len() == 3); + assert!(values.len() == 0); + + let repr = keys[0].into_repr().as_ref()[0]; + let mut valid = repr < (1 << self.bits); + valid = valid & keys[1].is_zero(); + valid = valid & keys[2].is_zero(); + + valid + } + fn query(&self, keys: &[E::Fr]) -> Result, SynthesisError> { + assert!(keys.len() == 3); + + let is_valid = self.is_valid_entry(keys, &[]); + + if is_valid { + return Ok(vec![]); + } else { + return Err(SynthesisError::Unsatisfiable); + } + } + fn get_table_values_for_polys(&self) -> Vec> { + vec![self.table_entries.clone(), self.dummy_entries.clone(), self.dummy_entries.clone()] + } + fn table_id(&self) -> E::Fr { + table_id_from_string(self.name()) + } + fn sort(&self, values: &[E::Fr], _column: usize) -> Result, SynthesisError> { + unimplemented!() + } + fn box_clone(&self) -> Box> { + Box::from(self.clone()) + } + + fn column_is_trivial(&self, column_num: usize) -> bool { + assert!(column_num < 3); + + if column_num == 0 { + false + } else { + true + } + } +} + +pub trait Binop: 'static + Clone + Copy + Send + Sync + std::fmt::Debug + PartialEq + Eq { + const NAME: &'static str; + fn apply(x: usize, y: usize) -> usize; +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct XorBinop; + +impl Binop for XorBinop { + const NAME: &'static str = "XOR binop"; + + fn apply(x: usize, y: usize) -> usize { + x ^ y + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct AndBinop; + +impl Binop for AndBinop { + const NAME: &'static str = "AND binop"; + + fn apply(x: usize, y: usize) -> usize { + x & y + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct OrBinop; + +impl Binop for OrBinop { + const NAME: &'static str = "OR binop"; + + fn apply(x: usize, y: usize) -> usize { + x | y + } +} + +#[derive(Clone)] +pub struct TwoKeysOneValueBinopTable { + table_entries: [Vec; 3], + table_lookup_map: std::collections::HashMap<(E::Fr, E::Fr), E::Fr>, + bits: usize, + name: &'static str, + _binop_marker: std::marker::PhantomData +} + +impl TwoKeysOneValueBinopTable { + pub fn new(bits: usize, name: &'static str) -> Self { + let mut key_0 = Vec::with_capacity(1 << bits); + let mut key_1 = Vec::with_capacity(1 << bits); + let mut value_0 = Vec::with_capacity(1 << bits); + + let mut map = std::collections::HashMap::with_capacity(1 << (bits * 2)); + for x in 0..(1 << bits) { + for y in 0..(1< std::fmt::Debug for TwoKeysOneValueBinopTable { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("TwoKeysOneValueBinopTable") + .field("bits", &self.bits) + .field("binop", &B::NAME) + .finish() + } +} + +impl LookupTableInternal for TwoKeysOneValueBinopTable { + fn name(&self) -> &'static str { + self.name + } + fn table_size(&self) -> usize { + debug_assert_eq!(1usize << (self.bits*2), self.table_entries[0].len()); + 1usize << (self.bits*2) + } + fn num_keys(&self) -> usize { + 2 + } + fn num_values(&self) -> usize { + 1 + } + fn allows_combining(&self) -> bool { + true + } + fn is_valid_entry(&self, keys: &[E::Fr], values: &[E::Fr]) -> bool { + assert!(keys.len() == 2); + assert!(values.len() == 1); + + if let Some(entry) = self.table_lookup_map.get(&(keys[0], keys[1])) { + return entry == &values[0]; + } + + false + } + fn query(&self, keys: &[E::Fr]) -> Result, SynthesisError> { + assert!(keys.len() == 2); + + if let Some(entry) = self.table_lookup_map.get(&(keys[0], keys[1])) { + return Ok(vec![*entry]) + } + + Err(SynthesisError::Unsatisfiable) + } + + fn get_table_values_for_polys(&self) -> Vec> { + vec![self.table_entries[0].clone(), self.table_entries[1].clone(), self.table_entries[2].clone()] + } + fn table_id(&self) -> E::Fr { + table_id_from_string(self.name()) + } + fn sort(&self, values: &[E::Fr], _column: usize) -> Result, SynthesisError> { + unimplemented!() + } + fn box_clone(&self) -> Box> { + Box::from(self.clone()) + } + + fn column_is_trivial(&self, column_num: usize) -> bool { + assert!(column_num < 3); + + false + } +} + + +pub fn table_id_from_string( + s: &str +) -> F { + let mut h = tiny_keccak::keccak256(s.as_bytes()); + for i in 0..4 { + h[i] = 0u8; + } + + use crate::pairing::ff::PrimeFieldRepr; + + let mut repr = F::Repr::default(); + repr.read_be(&h[..]).unwrap(); + + F::from_repr(repr).unwrap() +} + +#[derive(Clone, Copy)] +pub(crate) struct KeyValueSet { + pub(crate) inner: [E::Fr; 3] +} + +impl KeyValueSet { + pub(crate) fn new(set: [E::Fr; 3]) -> Self { + Self { + inner: set + } + } + + pub(crate) fn from_slice(input: &[E::Fr]) -> Self { + debug_assert_eq!(input.len(), 3); + let mut inner = [E::Fr::zero(); 3]; + inner.copy_from_slice(input); + + Self { + inner + } + } +} + +impl std::cmp::PartialEq for KeyValueSet { + fn eq(&self, other: &Self) -> bool { + self.inner == other.inner + } +} + +impl std::cmp::Eq for KeyValueSet {} + +impl std::cmp::Ord for KeyValueSet { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + match self.inner[0].into_repr().cmp(&other.inner[0].into_repr()) { + std::cmp::Ordering::Equal => { + return self.inner[1].into_repr().cmp(&other.inner[1].into_repr()); + // match self.inner[1].into_repr().cmp(&other.inner[1].into_repr()) { + // std::cmp::Ordering::Equal => { + // unreachable!("keys and values set must have no duality"); + // } + // ord @ _ => { + // return ord; + // } + // } + }, + ord @ _ => { + return ord; + } + } + } +} + +impl std::cmp::PartialOrd for KeyValueSet { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl std::fmt::Debug for KeyValueSet { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("KeyValueSet") + .field("inner", &self.inner) + .finish() + } +} + +pub(crate) struct LookupDataHolder { + pub(crate) eta: E::Fr, + pub(crate) f_poly_unpadded_values: Option>, + pub(crate) t_poly_unpadded_values: Option>, + pub(crate) t_shifted_unpadded_values: Option>, + pub(crate) s_poly_unpadded_values: Option>, + pub(crate) s_shifted_unpadded_values: Option>, + // pub(crate) f_poly_monomial: Option>, + pub(crate) t_poly_monomial: Option>, + pub(crate) s_poly_monomial: Option>, + pub(crate) selector_poly_monomial: Option>, + pub(crate) table_type_poly_monomial: Option>, +} + +#[derive(Clone, Copy, Debug)] +pub(crate) struct LookupQuery { + pub(crate) s_at_z_omega: E::Fr, + pub(crate) grand_product_at_z_omega: E::Fr, + pub(crate) t_at_z: E::Fr, + pub(crate) t_at_z_omega: E::Fr, + pub(crate) selector_at_z: E::Fr, + pub(crate) table_type_at_z: E::Fr, +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/mod.rs b/src/plonk/better_better_cs/mod.rs new file mode 100644 index 000000000..0dc844c0e --- /dev/null +++ b/src/plonk/better_better_cs/mod.rs @@ -0,0 +1,12 @@ +pub mod cs; +pub mod cs_old; +pub mod lookup_tables; +pub mod utils; +pub mod data_structures; +pub mod setup; +pub mod proof; +pub mod verifier; +pub mod trees; + +#[cfg(feature = "redshift")] +pub mod redshift; \ No newline at end of file diff --git a/src/plonk/better_better_cs/proof/mod.rs b/src/plonk/better_better_cs/proof/mod.rs new file mode 100644 index 000000000..77ce1c0f7 --- /dev/null +++ b/src/plonk/better_better_cs/proof/mod.rs @@ -0,0 +1,2286 @@ +use super::cs::*; +use super::data_structures::{self, *}; +use crate::pairing::ff::*; +use crate::pairing::*; +use crate::plonk::polynomials::*; +use std::collections::HashMap; + +use crate::plonk::domains::*; +use crate::worker::Worker; +use crate::SynthesisError; + +use crate::kate_commitment::*; + +use super::super::better_cs::utils::*; +use super::setup::*; +use super::utils::*; + +use crate::plonk::fft::cooley_tukey_ntt::*; + +use crate::byteorder::BigEndian; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use std::io::{Read, Write}; + +use crate::plonk::better_cs::keys::*; + +use log::info; + +pub fn write_tuple_with_one_index( + tuple: &(usize, F), + mut writer: W +) -> std::io::Result<()> { + writer.write_u64::(tuple.0 as u64)?; + write_fr(&tuple.1, &mut writer)?; + + Ok(()) +} + +pub fn write_tuple_with_one_index_vec(p: &[(usize, F)], mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.len() as u64)?; + for p in p.iter() { + write_tuple_with_one_index(p, &mut writer)?; + } + Ok(()) +} + +pub fn read_tuple_with_one_index(mut reader: R) -> std::io::Result<(usize, F)> { + let index = reader.read_u64::()?; + let el = read_fr(&mut reader)?; + + Ok((index as usize, el)) +} + +pub fn read_tuple_with_one_index_vec(mut reader: R) -> std::io::Result> { + let num_elements = reader.read_u64::()?; + let mut elements = vec![]; + for _ in 0..num_elements { + let el = read_tuple_with_one_index(&mut reader)?; + elements.push(el); + } + + Ok(elements) +} + +pub fn write_tuple_with_two_indexes( + tuple: &(usize, usize, F), + mut writer: W +) -> std::io::Result<()> { + writer.write_u64::(tuple.0 as u64)?; + writer.write_u64::(tuple.1 as u64)?; + write_fr(&tuple.2, &mut writer)?; + + Ok(()) +} + +pub fn write_tuple_with_two_indexes_vec(p: &[(usize, usize, F)], mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.len() as u64)?; + for p in p.iter() { + write_tuple_with_two_indexes(p, &mut writer)?; + } + Ok(()) +} + +pub fn read_tuple_with_two_indexes(mut reader: R) -> std::io::Result<(usize, usize, F)> { + let index_0 = reader.read_u64::()?; + let index_1 = reader.read_u64::()?; + let el = read_fr(&mut reader)?; + + Ok((index_0 as usize, index_1 as usize, el)) +} + +pub fn read_tuple_with_two_indexes_vec(mut reader: R) -> std::io::Result> { + let num_elements = reader.read_u64::()?; + let mut elements = vec![]; + for _ in 0..num_elements { + let el = read_tuple_with_two_indexes(&mut reader)?; + elements.push(el); + } + + Ok(elements) +} + +#[derive(Clone, PartialEq, Eq)] +pub struct Proof> { + pub n: usize, + pub inputs: Vec, + pub state_polys_commitments: Vec, + pub witness_polys_commitments: Vec, + pub copy_permutation_grand_product_commitment: E::G1Affine, + + pub lookup_s_poly_commitment: Option, + pub lookup_grand_product_commitment: Option, + + pub quotient_poly_parts_commitments: Vec, + + pub state_polys_openings_at_z: Vec, + pub state_polys_openings_at_dilations: Vec<(usize, usize, E::Fr)>, + pub witness_polys_openings_at_z: Vec, + pub witness_polys_openings_at_dilations: Vec<(usize, usize, E::Fr)>, + + pub gate_setup_openings_at_z: Vec<(usize, usize, E::Fr)>, + pub gate_selectors_openings_at_z: Vec<(usize, E::Fr)>, + + pub copy_permutation_polys_openings_at_z: Vec, + pub copy_permutation_grand_product_opening_at_z_omega: E::Fr, + + pub lookup_s_poly_opening_at_z_omega: Option, + pub lookup_grand_product_opening_at_z_omega: Option, + + pub lookup_t_poly_opening_at_z: Option, + pub lookup_t_poly_opening_at_z_omega: Option, + + pub lookup_selector_poly_opening_at_z: Option, + pub lookup_table_type_poly_opening_at_z: Option, + + pub quotient_poly_opening_at_z: E::Fr, + + pub linearization_poly_opening_at_z: E::Fr, + + pub opening_proof_at_z: E::G1Affine, + pub opening_proof_at_z_omega: E::G1Affine, + + _marker: std::marker::PhantomData +} + +impl> Proof { + pub fn empty() -> Self { + Self { + n: 0, + inputs: vec![], + state_polys_commitments: vec![], + witness_polys_commitments: vec![], + copy_permutation_grand_product_commitment: E::G1Affine::zero(), + + lookup_s_poly_commitment: None, + lookup_grand_product_commitment: None, + + quotient_poly_parts_commitments: vec![], + + state_polys_openings_at_z: vec![], + state_polys_openings_at_dilations: vec![], + witness_polys_openings_at_z: vec![], + witness_polys_openings_at_dilations: vec![], + + gate_setup_openings_at_z: vec![], + gate_selectors_openings_at_z: vec![], + + copy_permutation_polys_openings_at_z: vec![], + copy_permutation_grand_product_opening_at_z_omega: E::Fr::zero(), + + lookup_s_poly_opening_at_z_omega: None, + lookup_grand_product_opening_at_z_omega: None, + + lookup_t_poly_opening_at_z: None, + lookup_t_poly_opening_at_z_omega: None, + + lookup_selector_poly_opening_at_z: None, + lookup_table_type_poly_opening_at_z: None, + + quotient_poly_opening_at_z: E::Fr::zero(), + + linearization_poly_opening_at_z: E::Fr::zero(), + + opening_proof_at_z: E::G1Affine::zero(), + opening_proof_at_z_omega: E::G1Affine::zero(), + + _marker: std::marker::PhantomData + } + } + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(self.n as u64)?; + + write_fr_vec(&self.inputs, &mut writer)?; + + write_curve_affine_vec(&self.state_polys_commitments, &mut writer)?; + write_curve_affine_vec(&self.witness_polys_commitments, &mut writer)?; + + write_curve_affine(&self.copy_permutation_grand_product_commitment, &mut writer)?; + + write_optional_curve_affine(&self.lookup_s_poly_commitment, &mut writer)?; + write_optional_curve_affine(&self.lookup_grand_product_commitment, &mut writer)?; + + write_curve_affine_vec(&self.quotient_poly_parts_commitments, &mut writer)?; + + write_fr_vec(&self.state_polys_openings_at_z, &mut writer)?; + write_tuple_with_two_indexes_vec(&self.state_polys_openings_at_dilations, &mut writer)?; + + write_fr_vec(&self.witness_polys_openings_at_z, &mut writer)?; + write_tuple_with_two_indexes_vec(&self.witness_polys_openings_at_dilations, &mut writer)?; + + write_tuple_with_two_indexes_vec(&self.gate_setup_openings_at_z, &mut writer)?; + write_tuple_with_one_index_vec(&self.gate_selectors_openings_at_z, &mut writer)?; + + write_fr_vec(&self.copy_permutation_polys_openings_at_z, &mut writer)?; + write_fr(&self.copy_permutation_grand_product_opening_at_z_omega, &mut writer)?; + + write_optional_fr(&self.lookup_s_poly_opening_at_z_omega, &mut writer)?; + write_optional_fr(&self.lookup_grand_product_opening_at_z_omega, &mut writer)?; + + write_optional_fr(&self.lookup_t_poly_opening_at_z, &mut writer)?; + write_optional_fr(&self.lookup_t_poly_opening_at_z_omega, &mut writer)?; + + write_optional_fr(&self.lookup_selector_poly_opening_at_z, &mut writer)?; + write_optional_fr(&self.lookup_table_type_poly_opening_at_z, &mut writer)?; + + write_fr(&self.quotient_poly_opening_at_z, &mut writer)?; + write_fr(&self.linearization_poly_opening_at_z, &mut writer)?; + + write_curve_affine(&self.opening_proof_at_z, &mut writer)?; + write_curve_affine(&self.opening_proof_at_z_omega, &mut writer)?; + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + let new = Self { + n: reader.read_u64::()? as usize, + inputs: read_fr_vec(&mut reader)?, + state_polys_commitments: read_curve_affine_vector(&mut reader)?, + witness_polys_commitments: read_curve_affine_vector(&mut reader)?, + copy_permutation_grand_product_commitment: read_curve_affine(&mut reader)?, + + lookup_s_poly_commitment: read_optional_curve_affine(&mut reader)?, + lookup_grand_product_commitment: read_optional_curve_affine(&mut reader)?, + + quotient_poly_parts_commitments: read_curve_affine_vector(&mut reader)?, + + state_polys_openings_at_z: read_fr_vec(&mut reader)?, + state_polys_openings_at_dilations: read_tuple_with_two_indexes_vec(&mut reader)?, + witness_polys_openings_at_z: read_fr_vec(&mut reader)?, + witness_polys_openings_at_dilations: read_tuple_with_two_indexes_vec(&mut reader)?, + + gate_setup_openings_at_z: read_tuple_with_two_indexes_vec(&mut reader)?, + gate_selectors_openings_at_z: read_tuple_with_one_index_vec(&mut reader)?, + + copy_permutation_polys_openings_at_z: read_fr_vec(&mut reader)?, + copy_permutation_grand_product_opening_at_z_omega: read_fr(&mut reader)?, + + lookup_s_poly_opening_at_z_omega: read_optional_fr(&mut reader)?, + lookup_grand_product_opening_at_z_omega: read_optional_fr(&mut reader)?, + + lookup_t_poly_opening_at_z: read_optional_fr(&mut reader)?, + lookup_t_poly_opening_at_z_omega: read_optional_fr(&mut reader)?, + + lookup_selector_poly_opening_at_z: read_optional_fr(&mut reader)?, + lookup_table_type_poly_opening_at_z: read_optional_fr(&mut reader)?, + + quotient_poly_opening_at_z: read_fr(&mut reader)?, + + linearization_poly_opening_at_z: read_fr(&mut reader)?, + + opening_proof_at_z: read_curve_affine(&mut reader)?, + opening_proof_at_z_omega: read_curve_affine(&mut reader)?, + + _marker: std::marker::PhantomData + }; + + Ok(new) + } +} + +use super::cs::*; +use crate::plonk::commitments::transcript::*; + +impl, MG: MainGate, S: SynthesisMode> Assembly { + pub fn create_proof, T: Transcript>( + self, + worker: &Worker, + setup: &Setup, + mon_crs: &Crs, + transcript_params: Option, + ) -> Result, SynthesisError> + { + assert!(S::PRODUCE_WITNESS); + assert!(self.is_finalized); + + let mut transcript = if let Some(params) = transcript_params { + T::new_from_params(params) + } else { + T::new() + }; + + let mut proof = Proof::::empty(); + + let input_values = self.input_assingments.clone(); + + proof.n = self.n(); + proof.inputs = input_values.clone(); + + for inp in input_values.iter() { + transcript.commit_field_element(inp); + } + + let num_state_polys = >::Params::STATE_WIDTH; + let num_witness_polys = >::Params::WITNESS_WIDTH; + + info!("self.make_assembled_poly_storage"); + let mut values_storage = self.make_assembled_poly_storage(worker, true)?; + + let required_domain_size = self.n() + 1; + assert!(required_domain_size.is_power_of_two()); + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(required_domain_size); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(required_domain_size); + + // if we simultaneously produce setup then grab permutation polys in values forms + info!(" if S::PRODUCE_SETUP"); + if S::PRODUCE_SETUP { + let permutation_polys = self.make_permutations(&worker)?; + assert_eq!(permutation_polys.len(), num_state_polys); + + for (idx, poly) in permutation_polys.into_iter().enumerate() { + let key = PolyIdentifier::PermutationPolynomial(idx); + let poly = PolynomialProxy::from_owned(poly); + values_storage.setup_map.insert(key, poly); + } + } else { + // compute from setup: much time - multi threads + for idx in 0..num_state_polys { + let key = PolyIdentifier::PermutationPolynomial(idx); + // let vals = setup.permutation_monomials[idx].clone().fft(&worker).into_coeffs(); + let vals = setup.permutation_monomials[idx].clone().fft_using_bitreversed_ntt( + &worker, + &omegas_bitreversed, + &E::Fr::one() + )?.into_coeffs(); + let poly = Polynomial::from_values_unpadded(vals)?; + let poly = PolynomialProxy::from_owned(poly); + values_storage.setup_map.insert(key, poly); + } + } + + let mut ldes_storage = AssembledPolynomialStorage::::new( + true, + self.max_constraint_degree.next_power_of_two() + ); + + info!(" let mut monomials_storage = Self::create_monomial_storage"); + // much time - multi thread + let mut monomials_storage = Self::create_monomial_storage( + &worker, + &omegas_inv_bitreversed, + &values_storage, + true + )?; + + monomials_storage.extend_from_setup(setup)?; + + info!(" for i in 0..num_state_polys"); + // step 1 - commit state and witness, enumerated. Also commit sorted polynomials for table arguments + for i in 0..num_state_polys { + let key = PolyIdentifier::VariablesPolynomial(i); + let poly_ref = monomials_storage.get_poly(key); + let commitment = commit_using_monomials( + poly_ref, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + &commitment + ); + + proof.state_polys_commitments.push(commitment); + } + + info!("for i in 0..num_witness_polys"); + for i in 0..num_witness_polys { + let key = PolyIdentifier::VariablesPolynomial(i); + let poly_ref = monomials_storage.get_poly(key); + let commitment = commit_using_monomials( + poly_ref, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + &commitment + ); + + proof.witness_polys_commitments.push(commitment); + } + info!("let mut lookup_data: Option>"); + // step 1.5 - if there are lookup tables then draw random "eta" to linearlize over tables + let mut lookup_data: Option> = if self.tables.len() > 0 { + let eta = transcript.get_challenge(); + // let eta = E::Fr::from_str("987").unwrap(); + + // these are selected rows from witness (where lookup applies) + + let (selector_poly, table_type_mononial, table_type_values) = if S::PRODUCE_SETUP { + let selector_for_lookup_values = self.calculate_lookup_selector_values()?; + let table_type_values = self.calculate_table_type_values()?; + + let table_type_poly_monomial = { + let mon = Polynomial::from_values(table_type_values.clone())?; + let mon = mon.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + mon + }; + + let selector_poly = Polynomial::::from_values(selector_for_lookup_values)?.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + let selector_poly = PolynomialProxy::from_owned(selector_poly); + let table_type_poly = PolynomialProxy::from_owned(table_type_poly_monomial); + + (selector_poly, table_type_poly, table_type_values) + } else { + let selector_poly_ref = setup.lookup_selector_monomial.as_ref().expect("setup must contain lookup selector poly"); + let selector_poly = PolynomialProxy::from_borrowed(selector_poly_ref); + + let table_type_poly_ref = setup.lookup_table_type_monomial.as_ref().expect("setup must contain lookup table type poly"); + let table_type_poly = PolynomialProxy::from_borrowed(table_type_poly_ref); + + // let mut table_type_values = table_type_poly_ref.clone().fft(&worker).into_coeffs(); + let mut table_type_values = table_type_poly_ref.clone().fft_using_bitreversed_ntt( + &worker, + &omegas_bitreversed, + &E::Fr::one() + )?.into_coeffs(); + table_type_values.pop().unwrap(); + + (selector_poly, table_type_poly, table_type_values) + }; + + let witness_len = required_domain_size - 1; + + info!("let f_poly_values_aggregated"); + let f_poly_values_aggregated = { + let mut table_contributions_values = if S::PRODUCE_SETUP { + self.calculate_masked_lookup_entries(&values_storage)? + } else { + // let selector_values = PolynomialProxy::from_owned(selector_poly.as_ref().clone().fft(&worker)); + let selector_values = selector_poly.as_ref().clone().fft_using_bitreversed_ntt( + &worker, + &omegas_bitreversed, + &E::Fr::one() + )?; + + let selector_values = PolynomialProxy::from_owned(selector_values); + + self.calculate_masked_lookup_entries_using_selector( + &values_storage, + &selector_values + )? + }; + + assert_eq!(table_contributions_values.len(), 3); + + assert_eq!(witness_len, table_contributions_values[0].len()); + + let mut f_poly_values_aggregated = table_contributions_values.drain(0..1).collect::>().pop().unwrap(); + + let mut current = eta; + for t in table_contributions_values.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut f_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + // add table type marker + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut f_poly_values_aggregated, &table_type_values); + + Polynomial::from_values_unpadded(f_poly_values_aggregated)? + }; + + info!("let (t_poly_values, t_poly_values_shifted, t_poly_monomial)"); + let (t_poly_values, t_poly_values_shifted, t_poly_monomial) = if S::PRODUCE_SETUP { + // these are unsorted rows of lookup tables + let mut t_poly_ends = self.calculate_t_polynomial_values_for_single_application_tables()?; + + assert_eq!(t_poly_ends.len(), 4); + + let mut t_poly_values_aggregated = t_poly_ends.drain(0..1).collect::>().pop().unwrap(); + let mut current = eta; + for t in t_poly_ends.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut t_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + let copy_start = witness_len - t_poly_values_aggregated.len(); + let mut full_t_poly_values = vec![E::Fr::zero(); witness_len]; + let mut full_t_poly_values_shifted = full_t_poly_values.clone(); + + full_t_poly_values[copy_start..].copy_from_slice(&t_poly_values_aggregated); + full_t_poly_values_shifted[(copy_start - 1)..(witness_len-1)].copy_from_slice(&t_poly_values_aggregated); + + assert!(full_t_poly_values[0].is_zero()); + + let t_poly_monomial = { + let mon = Polynomial::from_values(full_t_poly_values.clone())?; + let mon = mon.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + mon + }; + + ( + PolynomialProxy::from_owned(Polynomial::from_values_unpadded(full_t_poly_values)?), + PolynomialProxy::from_owned(Polynomial::from_values_unpadded(full_t_poly_values_shifted)?), + PolynomialProxy::from_owned(t_poly_monomial) + ) + } else { + let mut t_poly_values_monomial_aggregated = setup.lookup_tables_monomials[0].clone(); + let mut current = eta; + for idx in 1..4 { + let to_aggregate_ref = &setup.lookup_tables_monomials[idx]; + t_poly_values_monomial_aggregated.add_assign_scaled( + &worker, + to_aggregate_ref, + ¤t + ); + + current.mul_assign(&eta); + } + info!("let mut t_poly_values = t_poly_values_monomial_aggregated"); + // let mut t_poly_values = t_poly_values_monomial_aggregated.clone().fft(&worker); + let mut t_poly_values = t_poly_values_monomial_aggregated.clone().fft_using_bitreversed_ntt( + &worker, + &omegas_bitreversed, + &E::Fr::one() + )?; + let mut t_values_shifted_coeffs = t_poly_values.clone().into_coeffs(); + let _ = t_poly_values.pop_last()?; + + let _: Vec<_> = t_values_shifted_coeffs.drain(0..1).collect(); + + let t_poly_values_shifted = Polynomial::from_values_unpadded(t_values_shifted_coeffs)?; + + assert_eq!(witness_len, t_poly_values.size()); + assert_eq!(witness_len, t_poly_values_shifted.size()); + + ( + PolynomialProxy::from_owned(t_poly_values), + PolynomialProxy::from_owned(t_poly_values_shifted), + PolynomialProxy::from_owned(t_poly_values_monomial_aggregated) + ) + }; + info!("let (s_poly_monomial, s_poly_unpadded_values, s_shifted_unpadded_values)"); + let (s_poly_monomial, s_poly_unpadded_values, s_shifted_unpadded_values) = { + let mut s_poly_ends = self.calculate_s_poly_contributions_from_witness()?; + assert_eq!(s_poly_ends.len(), 4); + + let mut s_poly_values_aggregated = s_poly_ends.drain(0..1).collect::>().pop().unwrap(); + let mut current = eta; + for t in s_poly_ends.into_iter() { + let op = BinopAddAssignScaled::new(current); + binop_over_slices(&worker, &op, &mut s_poly_values_aggregated, &t); + + current.mul_assign(&eta); + } + + let sorted_copy_start = witness_len - s_poly_values_aggregated.len(); + + let mut full_s_poly_values = vec![E::Fr::zero(); witness_len]; + let mut full_s_poly_values_shifted = full_s_poly_values.clone(); + + full_s_poly_values[sorted_copy_start..].copy_from_slice(&s_poly_values_aggregated); + full_s_poly_values_shifted[(sorted_copy_start - 1)..(witness_len-1)].copy_from_slice(&s_poly_values_aggregated); + + assert!(full_s_poly_values[0].is_zero()); + + let s_poly_monomial = { + let mon = Polynomial::from_values(full_s_poly_values.clone())?; + let mon = mon.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + mon + }; + + ( + s_poly_monomial, + Polynomial::from_values_unpadded(full_s_poly_values)?, + Polynomial::from_values_unpadded(full_s_poly_values_shifted)? + ) + }; + + info!(" let s_poly_commitment = commit_using_monomials"); + let s_poly_commitment = commit_using_monomials( + &s_poly_monomial, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + &s_poly_commitment + ); + + proof.lookup_s_poly_commitment = Some(s_poly_commitment); + + let data = data_structures::LookupDataHolder:: { + eta, + f_poly_unpadded_values: Some(f_poly_values_aggregated), + t_poly_unpadded_values: Some(t_poly_values), + t_shifted_unpadded_values: Some(t_poly_values_shifted), + s_poly_unpadded_values: Some(s_poly_unpadded_values), + s_shifted_unpadded_values: Some(s_shifted_unpadded_values), + t_poly_monomial: Some(t_poly_monomial), + s_poly_monomial: Some(s_poly_monomial), + selector_poly_monomial: Some(selector_poly), + table_type_poly_monomial: Some(table_type_mononial), + }; + + Some(data) + } else { + None + }; + + if self.multitables.len() > 0 { + unimplemented!("do not support multitables yet") + } + + // step 2 - grand product arguments + + let beta_for_copy_permutation = transcript.get_challenge(); + let gamma_for_copy_permutation = transcript.get_challenge(); + + // let beta_for_copy_permutation = E::Fr::from_str("123").unwrap(); + // let gamma_for_copy_permutation = E::Fr::from_str("456").unwrap(); + + // copy permutation grand product argument + + let mut grand_products_protos_with_gamma = vec![]; + + for i in 0..num_state_polys { + let id = PolyIdentifier::VariablesPolynomial(i); + + let mut p = values_storage.state_map.get(&id).unwrap().as_ref().clone(); + p.add_constant(&worker, &gamma_for_copy_permutation); + + grand_products_protos_with_gamma.push(p); + } + + let required_domain_size = required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let non_residues = make_non_residues::(num_state_polys - 1); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta_for_copy_permutation); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let mut permutation_polynomials_values_of_size_n_minus_one = vec![]; + + for idx in 0..num_state_polys { + let key = PolyIdentifier::PermutationPolynomial(idx); + + let mut coeffs = values_storage.get_poly(key).clone().into_coeffs(); + coeffs.pop().unwrap(); + + let p = Polynomial::from_values_unpadded(coeffs)?; + permutation_polynomials_values_of_size_n_minus_one.push(p); + } + + let z_den = { + assert_eq!( + permutation_polynomials_values_of_size_n_minus_one.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = permutation_polynomials_values_of_size_n_minus_one.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, permutation_polys_it.next().unwrap(), &beta_for_copy_permutation); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, &perm, &beta_for_copy_permutation); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + drop(z_num); + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + + let copy_permutation_z_in_monomial_form = z.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + let copy_permutation_z_poly_commitment = commit_using_monomials( + ©_permutation_z_in_monomial_form, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + ©_permutation_z_poly_commitment + ); + + proof.copy_permutation_grand_product_commitment = copy_permutation_z_poly_commitment; + + let mut beta_for_lookup = None; + let mut gamma_for_lookup = None; + + let lookup_z_poly_in_monomial_form = if let Some(data) = lookup_data.as_mut() { + let beta_for_lookup_permutation = transcript.get_challenge(); + let gamma_for_lookup_permutation = transcript.get_challenge(); + + // let beta_for_lookup_permutation = E::Fr::from_str("789").unwrap(); + // let gamma_for_lookup_permutation = E::Fr::from_str("1230").unwrap(); + + beta_for_lookup = Some(beta_for_lookup_permutation); + gamma_for_lookup = Some(gamma_for_lookup_permutation); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + let f_poly_unpadded_values = data.f_poly_unpadded_values.take().unwrap(); + let t_poly_unpadded_values = data.t_poly_unpadded_values.take().unwrap(); + let t_shifted_unpadded_values = data.t_shifted_unpadded_values.take().unwrap(); + let s_poly_unpadded_values = data.s_poly_unpadded_values.take().unwrap(); + let s_shifted_unpadded_values = data.s_shifted_unpadded_values.take().unwrap(); + + // Z(x*omega) = Z(x) * + // (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) / + // (\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut z_num = { + // (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + + let mut t = t_poly_unpadded_values.as_ref().clone(); + t.add_assign_scaled(&worker, t_shifted_unpadded_values.as_ref(), &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + let mut tmp = f_poly_unpadded_values.clone(); + tmp.add_constant(&worker, &gamma_for_lookup_permutation); + tmp.scale(&worker, beta_plus_one); + + t.mul_assign(&worker, &tmp); + drop(tmp); + + t + }; + + let z_den = { + // (\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut t = s_poly_unpadded_values.clone(); + t.add_assign_scaled(&worker, &s_shifted_unpadded_values, &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + t.batch_inversion(&worker)?; + + t + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + drop(z_num); + + assert!(z.size().is_power_of_two()); + + assert_eq!(z.as_ref()[0], E::Fr::one()); + assert_eq!(*z.as_ref().last().unwrap(), expected); + + // let t_poly_monomial = t_poly_unpadded_values.as_ref().clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + // &worker, + // &omegas_inv_bitreversed, + // &E::Fr::one() + // )?; + + // let s_poly_monomial = s_poly_unpadded_values.clone_padded_to_domain()?.ifft_using_bitreversed_ntt( + // &worker, + // &omegas_inv_bitreversed, + // &E::Fr::one() + // )?; + + // data.t_poly_monomial = Some(t_poly_monomial); + // data.s_poly_monomial = Some(s_poly_monomial); + + let z = z.ifft_using_bitreversed_ntt( + &worker, + &omegas_inv_bitreversed, + &E::Fr::one() + )?; + + let lookup_z_poly_commitment = commit_using_monomials( + &z, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + &lookup_z_poly_commitment + ); + + proof.lookup_grand_product_commitment = Some(lookup_z_poly_commitment); + + Some(z) + } else { + None + }; + + // now draw alpha and add all the contributions to the quotient polynomial + + let alpha = transcript.get_challenge(); + // let alpha = E::Fr::from_str("1234567890").unwrap(); + + let mut total_powers_of_alpha_for_gates = 0; + for g in self.sorted_gates.iter() { + total_powers_of_alpha_for_gates += g.num_quotient_terms(); + } + + // println!("Have {} terms from {} gates", total_powers_of_alpha_for_gates, self.sorted_gates.len()); + + let mut current_alpha = E::Fr::one(); + let mut powers_of_alpha_for_gates = Vec::with_capacity(total_powers_of_alpha_for_gates); + powers_of_alpha_for_gates.push(current_alpha); + for _ in 1..total_powers_of_alpha_for_gates { + current_alpha.mul_assign(&alpha); + powers_of_alpha_for_gates.push(current_alpha); + } + + assert_eq!(powers_of_alpha_for_gates.len(), total_powers_of_alpha_for_gates); + + let mut all_gates = self.sorted_gates.clone(); + let num_different_gates = self.sorted_gates.len(); + + let mut challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut lde_factor = num_state_polys; + for g in self.sorted_gates.iter() { + let degree = g.degree(); + if degree > lde_factor { + lde_factor = degree; + } + } + + assert!(lde_factor <= 4); + + let coset_factor = E::Fr::multiplicative_generator(); + + let mut t_poly = { + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let input_values = self.input_assingments.clone(); + + // much much much time + let mut t = gate.contribute_into_quotient_for_public_inputs( + required_domain_size, + &input_values, + &mut ldes_storage, + &monomials_storage, + for_gate, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &worker + )?; + + if num_different_gates > 1 { + // we have to multiply by the masking poly (selector) + let key = PolyIdentifier::GateSelector(gate.name()); + let monomial_selector = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let selector_lde = monomial_selector.clone_padded_to_domain()?.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + t.mul_assign(&worker, &selector_lde); + drop(selector_lde); + } + + t + }; + + let non_main_gates = all_gates; + + for gate in non_main_gates.into_iter() { + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let mut contribution = gate.contribute_into_quotient( + required_domain_size, + &mut ldes_storage, + &monomials_storage, + for_gate, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &worker + )?; + + { + // we have to multiply by the masking poly (selector) + let key = PolyIdentifier::GateSelector(gate.name()); + let monomial_selector = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let selector_lde = monomial_selector.clone_padded_to_domain()?.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + contribution.mul_assign(&worker, &selector_lde); + drop(selector_lde); + } + + t_poly.add_assign(&worker, &contribution); + } + + assert_eq!(challenges_slice.len(), 0); + + println!("Power of alpha for a start of normal permutation argument = {}", total_powers_of_alpha_for_gates); + + // perform copy-permutation argument + + // we precompute L_{0} here cause it's necessary for both copy-permutation and lookup permutation + + // z(omega^0) - 1 == 0 + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + let l_0_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let mut copy_grand_product_alphas = None; + let x_poly_lde_bitreversed = { + // now compute the permutation argument + + // bump alpha + current_alpha.mul_assign(&alpha); + let alpha_0 = current_alpha; + + let z_coset_lde_bitreversed = copy_permutation_z_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + assert!(z_coset_lde_bitreversed.size() == required_domain_size*lde_factor); + + let z_shifted_coset_lde_bitreversed = z_coset_lde_bitreversed.clone_shifted_assuming_bitreversed( + lde_factor, + &worker, + )?; + + assert!(z_shifted_coset_lde_bitreversed.size() == required_domain_size*lde_factor); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + let mut contrib_z = z_coset_lde_bitreversed.clone(); + + // precompute x poly + let mut x_poly = Polynomial::from_values(vec![ + coset_factor; + required_domain_size*lde_factor + ])?; + x_poly.distribute_powers(&worker, z_shifted_coset_lde_bitreversed.omega); + x_poly.bitreverse_enumeration(&worker); + + assert_eq!(x_poly.size(), required_domain_size * lde_factor); + + // A + beta*X + gamma + + let mut tmp = ldes_storage.state_map.get(&PolyIdentifier::VariablesPolynomial(0)).unwrap().as_ref().clone(); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + tmp.add_assign_scaled(&worker, &x_poly, &beta_for_copy_permutation); + contrib_z.mul_assign(&worker, &tmp); + + assert_eq!(non_residues.len() + 1, num_state_polys); + + for (poly_idx, non_res) in (1..num_state_polys).zip(non_residues.iter()) { + let mut factor = beta_for_copy_permutation; + factor.mul_assign(&non_res); + + let key = PolyIdentifier::VariablesPolynomial(poly_idx); + tmp.reuse_allocation(&ldes_storage.state_map.get(&key).unwrap().as_ref()); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + tmp.add_assign_scaled(&worker, &x_poly, &factor); + contrib_z.mul_assign(&worker, &tmp); + } + + t_poly.add_assign_scaled(&worker, &contrib_z, ¤t_alpha); + + drop(contrib_z); + + let mut contrib_z = z_shifted_coset_lde_bitreversed; + + // A + beta*perm_a + gamma + + for idx in 0..num_state_polys { + let key = PolyIdentifier::VariablesPolynomial(idx); + + tmp.reuse_allocation(&ldes_storage.state_map.get(&key).unwrap().as_ref()); + tmp.add_constant(&worker, &gamma_for_copy_permutation); + + let key = PolyIdentifier::PermutationPolynomial(idx); + let perm = monomials_storage.get_poly(key).clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + tmp.add_assign_scaled(&worker, &perm, &beta_for_copy_permutation); + contrib_z.mul_assign(&worker, &tmp); + drop(perm); + } + + t_poly.sub_assign_scaled(&worker, &contrib_z, ¤t_alpha); + + drop(contrib_z); + + drop(tmp); + + // Z(x) * L_{0}(x) - 1 == 0 + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + { + let mut z_minus_one_by_l_0 = z_coset_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + z_minus_one_by_l_0.mul_assign(&worker, &l_0_coset_lde_bitreversed); + + t_poly.add_assign_scaled(&worker, &z_minus_one_by_l_0, ¤t_alpha); + } + + copy_grand_product_alphas = Some([alpha_0, alpha_1]); + + x_poly + }; + + // add contribution from grand product for loopup polys if there is one + + let mut lookup_grand_product_alphas = None; + if let Some(z_poly_in_monomial_form) = lookup_z_poly_in_monomial_form.as_ref() { + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + current_alpha.mul_assign(&alpha); + + let alpha_0 = current_alpha; + + // same grand product argument for lookup permutation except divisor is now with one point cut + + let z_lde = z_poly_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let z_lde_shifted = z_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + // We make an small ad-hoc modification here and instead of dividing some contributions by + // (X^n - 1)/(X - omega^{n-1}) we move (X - omega^{n-1}) to the numerator and join the divisions + + // Numerator degree is at max 4n, so it's < 4n after division + + // ( Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // - Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) )*(X - omega^{n-1}) + + let data = lookup_data.as_ref().unwrap(); + + let s_lde = data.s_poly_monomial.as_ref().unwrap().clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let s_lde_shifted = s_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + // Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + + let mut contribution = s_lde; + contribution.add_assign_scaled(&worker, &s_lde_shifted, &beta_for_lookup_permutation); + contribution.add_constant(&worker, &gamma_beta); + contribution.mul_assign(&worker, &z_lde_shifted); + + drop(s_lde_shifted); + drop(z_lde_shifted); + + let t_lde = data.t_poly_monomial.as_ref().unwrap().as_ref().clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + let t_lde_shifted = t_lde.clone_shifted_assuming_bitreversed( + lde_factor, + &worker + )?; + + let f_lde = { + // add up ldes of a,b,c and table_type poly and multiply by selector + + let a_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(0)), + &ldes_storage + ); + let mut tmp = a_ref.clone(); + drop(a_ref); + + let eta = lookup_data.as_ref().unwrap().eta; + + let mut current = eta; + + let b_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(1)), + &ldes_storage + ); + + tmp.add_assign_scaled(&worker, b_ref, ¤t); + + drop(b_ref); + current.mul_assign(&eta); + + let c_ref = get_from_map_unchecked( + PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(2)), + &ldes_storage + ); + + tmp.add_assign_scaled(&worker, c_ref, ¤t); + + drop(c_ref); + current.mul_assign(&eta); + + let table_type_lde = lookup_data.as_ref().unwrap().table_type_poly_monomial.as_ref().unwrap().as_ref().clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.add_assign_scaled(&worker, &table_type_lde, ¤t); + + drop(table_type_lde); + + let lookup_selector_lde = lookup_data.as_ref().unwrap().selector_poly_monomial.as_ref().unwrap().as_ref().clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.mul_assign(&worker, &lookup_selector_lde); + + drop(lookup_selector_lde); + + tmp + + }; + + // - Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + + let mut tmp = f_lde; + tmp.add_constant(&worker, &gamma_for_lookup_permutation); + tmp.mul_assign(&worker, &z_lde); + tmp.scale(&worker, beta_plus_one); + + let mut t = t_lde; + t.add_assign_scaled(&worker, &t_lde_shifted, &beta_for_lookup_permutation); + t.add_constant(&worker, &gamma_beta); + + tmp.mul_assign(&worker, &t); + + drop(t); + drop(t_lde_shifted); + + contribution.sub_assign(&worker, &tmp); + + contribution.scale(&worker, current_alpha); + + // multiply by (X - omega^{n-1}) + + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut x_minus_last_omega = x_poly_lde_bitreversed; + x_minus_last_omega.sub_constant(&worker, &last_omega); + + contribution.mul_assign(&worker, &x_minus_last_omega); + drop(x_minus_last_omega); + + // we do not need to do addition multiplications for terms below cause multiplication by lagrange poly + // does everything for us + + // check that (Z(x) - 1) * L_{0} == 0 + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + tmp.reuse_allocation(&z_lde); + tmp.sub_constant(&worker, &E::Fr::one()); + tmp.mul_assign(&worker, &l_0_coset_lde_bitreversed); + + drop(l_0_coset_lde_bitreversed); + + contribution.add_assign_scaled(&worker, &tmp, ¤t_alpha); + + // check that (Z(x) - expected) * L_{n-1} == 0 + + current_alpha.mul_assign(&alpha); + + let alpha_2 = current_alpha; + + let l_last = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), required_domain_size - 1)?; + + let l_last_coset_lde_bitreversed = l_last.bitreversed_lde_using_bitreversed_ntt( + &worker, + lde_factor, + &omegas_bitreversed, + &coset_factor + )?; + + tmp.reuse_allocation(&z_lde); + tmp.sub_constant(&worker, &expected); + tmp.mul_assign(&worker, &l_last_coset_lde_bitreversed); + + drop(l_last_coset_lde_bitreversed); + + contribution.add_assign_scaled(&worker, &tmp, ¤t_alpha); + + drop(tmp); + drop(z_lde); + + t_poly.add_assign(&worker, &contribution); + + drop(contribution); + + lookup_grand_product_alphas = Some([alpha_0, alpha_1, alpha_2]); + } else { + drop(x_poly_lde_bitreversed); + drop(l_0_coset_lde_bitreversed); + } + + // perform the division + + let inverse_divisor_on_coset_lde_natural_ordering = { + let mut vanishing_poly_inverse_bitreversed = + evaluate_vanishing_polynomial_of_degree_on_domain_size::( + required_domain_size as u64, + &E::Fr::multiplicative_generator(), + (required_domain_size * lde_factor) as u64, + &worker, + )?; + vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + // vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker)?; + + vanishing_poly_inverse_bitreversed + }; + + // don't forget to bitreverse + + t_poly.bitreverse_enumeration(&worker); + + t_poly.mul_assign(&worker, &inverse_divisor_on_coset_lde_natural_ordering); + + drop(inverse_divisor_on_coset_lde_natural_ordering); + + let t_poly = t_poly.icoset_fft_for_generator(&worker, &coset_factor); + + println!("Lde factor = {}", lde_factor); + + // println!("Quotient poly = {:?}", t_poly.as_ref()); + + { + // degree is 4n-4 + let l = t_poly.as_ref().len(); + if &t_poly.as_ref()[(l-4)..] != &[E::Fr::zero(); 4][..] { + return Err(SynthesisError::Unsatisfiable); + } + // assert_eq!(&t_poly.as_ref()[(l-4)..], &[E::Fr::zero(); 4][..], "quotient degree is too large"); + } + + // println!("Quotient poly degree = {}", get_degree::(&t_poly)); + + let mut t_poly_parts = t_poly.break_into_multiples(required_domain_size)?; + + for part in t_poly_parts.iter() { + let commitment = commit_using_monomials( + part, + mon_crs, + &worker + )?; + + commit_point_as_xy::( + &mut transcript, + &commitment + ); + + proof.quotient_poly_parts_commitments.push(commitment); + } + + // draw opening point + let z = transcript.get_challenge(); + + // let z = E::Fr::from_str("333444555").unwrap(); + let omega = domain.generator; + + // evaluate quotient at z + + let quotient_at_z = { + let mut result = E::Fr::zero(); + let mut current = E::Fr::one(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + for p in t_poly_parts.iter() { + let mut subvalue_at_z = p.evaluate_at(&worker, z); + + subvalue_at_z.mul_assign(¤t); + result.add_assign(&subvalue_at_z); + current.mul_assign(&z_in_domain_size); + } + + result + }; + + // commit quotient value + transcript.commit_field_element("ient_at_z); + + proof.quotient_poly_opening_at_z = quotient_at_z; + + // Now perform the linearization. + // First collect and evalute all the polynomials that are necessary for linearization + // and construction of the verification equation + + const MAX_DILATION: usize = 1; + + let queries_with_linearization = sort_queries_for_linearization(&self.sorted_gates, MAX_DILATION); + + let mut query_values_map = std::collections::HashMap::new(); + + // go over all required queries + + for (dilation_value, ids) in queries_with_linearization.state_polys.iter().enumerate() { + for id in ids.into_iter() { + let (poly_ref, poly_idx) = if let PolyIdentifier::VariablesPolynomial(idx) = id { + (monomials_storage.state_map.get(&id).unwrap().as_ref(), idx) + } + else { + unreachable!(); + }; + + let mut opening_point = z; + for _ in 0..dilation_value { + opening_point.mul_assign(&omega); + } + + let value = poly_ref.evaluate_at(&worker, opening_point); + + transcript.commit_field_element(&value); + + if dilation_value == 0 { + proof.state_polys_openings_at_z.push(value); + } else { + proof.state_polys_openings_at_dilations.push((dilation_value, *poly_idx, value)); + } + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + + for (dilation_value, ids) in queries_with_linearization.witness_polys.iter().enumerate() { + for id in ids.into_iter() { + let (poly_ref, poly_idx) = if let PolyIdentifier::WitnessPolynomial(idx) = id { + (monomials_storage.witness_map.get(&id).unwrap().as_ref(), idx) + } + else { + unreachable!(); + }; + + let mut opening_point = z; + for _ in 0..dilation_value { + opening_point.mul_assign(&omega); + } + + let value = poly_ref.evaluate_at(&worker, opening_point); + + transcript.commit_field_element(&value); + + if dilation_value == 0 { + proof.witness_polys_openings_at_z.push(value); + } else { + proof.witness_polys_openings_at_dilations.push((dilation_value, *poly_idx, value)); + } + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + + for (gate_idx, queries) in queries_with_linearization.gate_setup_polys.iter().enumerate() { + for (dilation_value, ids) in queries.iter().enumerate() { + for id in ids.into_iter() { + let (poly_ref, poly_idx) = if let PolyIdentifier::GateSetupPolynomial(_, idx) = id { + (monomials_storage.setup_map.get(&id).unwrap().as_ref(), idx) + } + else { + unreachable!(); + }; + + let mut opening_point = z; + for _ in 0..dilation_value { + opening_point.mul_assign(&omega); + } + + let value = poly_ref.evaluate_at(&worker, opening_point); + + transcript.commit_field_element(&value); + + if dilation_value == 0 { + proof.gate_setup_openings_at_z.push((gate_idx, *poly_idx, value)); + } else { + unimplemented!("gate setup polynomials can not be time dilated"); + } + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + } + + // also open selectors + + let mut selector_values = vec![]; + for s in queries_with_linearization.gate_selectors.iter() { + let gate_index = self.sorted_gates.iter().position(|r| r == s).unwrap(); + + let key = PolyIdentifier::GateSelector(s.name()); + let poly_ref = monomials_storage.gate_selectors.get(&key).unwrap().as_ref(); + let value = poly_ref.evaluate_at(&worker, z); + + transcript.commit_field_element(&value); + + proof.gate_selectors_openings_at_z.push((gate_index, value)); + + selector_values.push(value); + } + + // copy-permutation polynomials queries + + let mut copy_permutation_queries = vec![]; + + for idx in 0..(num_state_polys-1) { + let key = PolyIdentifier::PermutationPolynomial(idx); + let value = monomials_storage.get_poly(key).evaluate_at(&worker, z); + + transcript.commit_field_element(&value); + + proof.copy_permutation_polys_openings_at_z.push(value); + + copy_permutation_queries.push(value); + } + + // copy-permutation grand product query + + let mut z_omega = z; + z_omega.mul_assign(&domain.generator); + let copy_permutation_z_at_z_omega = copy_permutation_z_in_monomial_form.evaluate_at(&worker, z_omega); + transcript.commit_field_element(©_permutation_z_at_z_omega); + proof.copy_permutation_grand_product_opening_at_z_omega = copy_permutation_z_at_z_omega; + + // we've computed everything, so perform linearization + + let mut challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = self.sorted_gates.clone(); + + let mut r_poly = { + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(gate.benefits_from_linearization(), "main gate is expected to benefit from linearization!"); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let input_values = self.input_assingments.clone(); + + let mut r = gate.contribute_into_linearization_for_public_inputs( + required_domain_size, + &input_values, + z, + &query_values_map, + &monomials_storage, + for_gate, + &worker + )?; + + let mut selectors_it = selector_values.clone().into_iter(); + + if num_different_gates > 1 { + // first multiply r by the selector value at z + r.scale(&worker, selectors_it.next().unwrap()); + } + + // now proceed per gate + for gate in all_gates.into_iter() { + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + if gate.benefits_from_linearization() { + // gate benefits from linearization, so make temporary value + let tmp = gate.contribute_into_linearization( + required_domain_size, + z, + &query_values_map, + &monomials_storage, + for_gate, + &worker + )?; + + let selector_value = selectors_it.next().unwrap(); + + r.add_assign_scaled(&worker, &tmp, &selector_value); + } else { + // we linearize over the selector, so take a selector and scale it + let gate_value_at_z = gate.contribute_into_verification_equation( + required_domain_size, + z, + &query_values_map, + for_gate + )?; + + let key = PolyIdentifier::GateSelector(gate.name()); + let gate_selector_ref = monomials_storage.gate_selectors.get(&key).expect("must get monomial form of gate selector").as_ref(); + + r.add_assign_scaled(&worker, gate_selector_ref, &gate_value_at_z); + } + } + + assert!(selectors_it.next().is_none()); + assert_eq!(challenges_slice.len(), 0); + + r + }; + + // add contributions from copy-permutation and lookup-permutation + + // copy-permutation linearization comtribution + { + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let some_one = Some(E::Fr::one()); + let mut non_residues_iterator = some_one.iter().chain(&non_residues); + + let mut factor = alpha_0; + + for idx in 0..num_state_polys { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let mut t = z; + let non_res = non_residues_iterator.next().unwrap(); + t.mul_assign(&non_res); + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + assert!(non_residues_iterator.next().is_none()); + + r_poly.add_assign_scaled(&worker, ©_permutation_z_in_monomial_form, &factor); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = alpha_0; + factor.mul_assign(&beta_for_copy_permutation); + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let key = PolyIdentifier::PermutationPolynomial(num_state_polys - 1); + let last_permutation_poly_ref = monomials_storage.get_poly(key); + + r_poly.sub_assign_scaled(&worker, last_permutation_poly_ref, &factor); + + // + L_0(z) * Z(x) + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign(&alpha_1); + + r_poly.add_assign_scaled(&worker, ©_permutation_z_in_monomial_form, &factor); + } + + // lookup grand product linearization + + // due to separate divisor it's not obvious if this is beneficial without some tricks + // like multiplication by (1 - L_{n-1}) or by (x - omega^{n-1}) + + // Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) == 0 + // check that (Z(x) - 1) * L_{0} == 0 + // check that (Z(x) - expected) * L_{n-1} == 0, or (Z(x*omega) - expected)* L_{n-2} == 0 + + // f(x) does not need to be opened as it's made of table selector and witnesses + // if we pursue the strategy from the linearization of a copy-permutation argument + // then we leave something like s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) term, + // and Z(x) from Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) term, + // with terms with lagrange polys as multipliers left intact + + let lookup_queries = if let Some(lookup_z_poly) = lookup_z_poly_in_monomial_form.as_ref() { + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let s_at_z_omega = lookup_data.as_ref().unwrap().s_poly_monomial.as_ref().unwrap().evaluate_at(&worker, z_omega); + let grand_product_at_z_omega = lookup_z_poly.evaluate_at(&worker, z_omega); + let t_at_z = lookup_data.as_ref().unwrap().t_poly_monomial.as_ref().unwrap().as_ref().evaluate_at(&worker, z); + let t_at_z_omega = lookup_data.as_ref().unwrap().t_poly_monomial.as_ref().unwrap().as_ref().evaluate_at(&worker, z_omega); + let selector_at_z = lookup_data.as_ref().unwrap().selector_poly_monomial.as_ref().unwrap().as_ref().evaluate_at(&worker, z); + let table_type_at_z = lookup_data.as_ref().unwrap().table_type_poly_monomial.as_ref().unwrap().as_ref().evaluate_at(&worker, z); + + let l_0_at_z = evaluate_lagrange_poly_at_point(0, &domain, z)?; + let l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + // (Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)))*(X - omega^{n-1}) + + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + // s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + let mut factor = grand_product_at_z_omega; // we do not need to account for additive terms + factor.mul_assign(&alpha_0); + factor.mul_assign(&z_minus_last_omega); + + r_poly.add_assign_scaled(&worker, lookup_data.as_ref().unwrap().s_poly_monomial.as_ref().unwrap(), &factor); + + // Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + // + alpha_1 * Z(x) * L_{0}(z) + alpha_2 * Z(x) * L_{n-1}(z) + + // accumulate coefficient + let mut factor = t_at_z_omega; + factor.mul_assign(&beta_for_lookup_permutation); + factor.add_assign(&t_at_z); + factor.add_assign(&gamma_beta); + + // (\gamma + f(x)) + + let mut f_reconstructed = E::Fr::zero(); + let mut current = E::Fr::one(); + let eta = lookup_data.as_ref().unwrap().eta; + // a,b,c + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let mut value = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + + value.mul_assign(¤t); + f_reconstructed.add_assign(&value); + + current.mul_assign(&eta); + } + + // and table type + let mut t = table_type_at_z; + t.mul_assign(¤t); + f_reconstructed.add_assign(&t); + + f_reconstructed.mul_assign(&selector_at_z); + f_reconstructed.add_assign(&gamma_for_lookup_permutation); + + // end of (\gamma + f(x)) part + + factor.mul_assign(&f_reconstructed); + factor.mul_assign(&beta_plus_one); + factor.negate(); // don't forget minus sign + factor.mul_assign(&alpha_0); + + // Multiply by (z - omega^{n-1}) + + factor.mul_assign(&z_minus_last_omega); + + // L_{0}(z) in front of Z(x) + + let mut tmp = l_0_at_z; + tmp.mul_assign(&alpha_1); + factor.add_assign(&tmp); + + // L_{n-1}(z) in front of Z(x) + + let mut tmp = l_n_minus_one_at_z; + tmp.mul_assign(&alpha_2); + factor.add_assign(&tmp); + + r_poly.add_assign_scaled(&worker, lookup_z_poly, &factor); + + let query = LookupQuery:: { + s_at_z_omega, + grand_product_at_z_omega, + t_at_z, + t_at_z_omega, + selector_at_z, + table_type_at_z, + }; + + Some(query) + } else { + None + }; + + if let Some(queries) = lookup_queries.as_ref() { + // first commit values at z, and then at z*omega + transcript.commit_field_element(&queries.t_at_z); + transcript.commit_field_element(&queries.selector_at_z); + transcript.commit_field_element(&queries.table_type_at_z); + + // now at z*omega + transcript.commit_field_element(&queries.s_at_z_omega); + transcript.commit_field_element(&queries.grand_product_at_z_omega); + transcript.commit_field_element(&queries.t_at_z_omega); + + proof.lookup_s_poly_opening_at_z_omega = Some(queries.s_at_z_omega); + proof.lookup_grand_product_opening_at_z_omega = Some(queries.grand_product_at_z_omega); + proof.lookup_t_poly_opening_at_z = Some(queries.t_at_z); + proof.lookup_t_poly_opening_at_z_omega = Some(queries.t_at_z_omega); + proof.lookup_selector_poly_opening_at_z = Some(queries.selector_at_z); + proof.lookup_table_type_poly_opening_at_z = Some(queries.table_type_at_z); + } + + let linearization_at_z = r_poly.evaluate_at(&worker, z); + + transcript.commit_field_element(&linearization_at_z); + proof.linearization_poly_opening_at_z = linearization_at_z; + + // linearization is done, now perform sanity check + // this is effectively a verification procedure + + { + let vanishing_at_z = evaluate_vanishing_for_size(&z, required_domain_size as u64); + + // first let's aggregate gates + + let mut t_num_on_full_domain = E::Fr::zero(); + + let challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = self.sorted_gates.clone(); + + // we've suffered and linearization polynomial captures all the gates except the public input! + + { + let mut tmp = linearization_at_z; + // add input values + + let gate = all_gates.drain(0..1).into_iter().next().unwrap(); + assert!(gate.benefits_from_linearization(), "main gate is expected to benefit from linearization!"); + assert!(>::MainGate::default().into_internal() == gate); + let gate = >::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, _) = challenges_slice.split_at(num_challenges); + + let input_values = self.input_assingments.clone(); + + let mut inputs_term = gate.add_inputs_into_quotient( + required_domain_size, + &input_values, + z, + for_gate, + )?; + + if num_different_gates > 1 { + let selector_value = selector_values[0]; + inputs_term.mul_assign(&selector_value); + } + + tmp.add_assign(&inputs_term); + + t_num_on_full_domain.add_assign(&tmp); + } + + // now aggregate leftovers from grand product for copy permutation + { + // - alpha_0 * (a + perm(z) * beta + gamma)*()*(d + gamma) * z(z*omega) + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let mut factor = alpha_0; + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(num_state_polys-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(num_state_polys-1)); + let mut tmp = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + tmp.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&tmp); + + t_num_on_full_domain.sub_assign(&factor); + + // - L_0(z) * alpha_1 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + } + + // and if exists - grand product for lookup permutation + + { + if lookup_queries.is_some() { + + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let lookup_queries = lookup_queries.clone().expect("lookup queries must be made"); + + let beta_for_lookup_permutation = beta_for_lookup.unwrap(); + let gamma_for_lookup_permutation = gamma_for_lookup.unwrap(); + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + // in a linearization we've taken terms: + // - s(x) from the alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + // - and Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) (term in full) + + // + alpha_1 * (Z(x) - 1) * L_{0}(z) + alpha_2 * (Z(x) - expected) * L_{n-1}(z) + + // first make alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + \beta * s(x*omega))) + + let mut tmp = lookup_queries.s_at_z_omega; + tmp.mul_assign(&beta_for_lookup_permutation); + tmp.add_assign(&gamma_beta); + tmp.mul_assign(&lookup_queries.grand_product_at_z_omega); + tmp.mul_assign(&alpha_0); + + // (z - omega^{n-1}) for this part + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + tmp.mul_assign(&z_minus_last_omega); + + t_num_on_full_domain.add_assign(&tmp); + + // // - alpha_1 * L_{0}(z) + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + + // // - alpha_2 * expected L_{n-1}(z) + + let mut l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + l_n_minus_one_at_z.mul_assign(&expected); + l_n_minus_one_at_z.mul_assign(&alpha_2); + + t_num_on_full_domain.sub_assign(&l_n_minus_one_at_z); + } + } + + let mut lhs = quotient_at_z; + lhs.mul_assign(&vanishing_at_z); + + let rhs = t_num_on_full_domain; + + if lhs != rhs { + dbg!("Circuit is not satisfied"); + return Err(SynthesisError::Unsatisfiable); + } + } + + let v = transcript.get_challenge(); + + // now construct two polynomials that are opened at z and z*omega + + let mut multiopening_challenge = E::Fr::one(); + + let mut poly_to_divide_at_z = t_poly_parts.drain(0..1).collect::>().pop().unwrap(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + let mut power_of_z = z_in_domain_size; + for t_part in t_poly_parts.into_iter() { + poly_to_divide_at_z.add_assign_scaled(&worker, &t_part, &power_of_z); + power_of_z.mul_assign(&z_in_domain_size); + } + + // linearization polynomial + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &r_poly, &multiopening_challenge); + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 as u64])); + + // now proceed over all queries + + const THIS_STEP_DILATION: usize = 0; + for id in queries_with_linearization.state_polys[THIS_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + for id in queries_with_linearization.witness_polys[THIS_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + for queries in queries_with_linearization.gate_setup_polys.iter() { + for id in queries[THIS_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + } + + // also open selectors at z + for s in queries_with_linearization.gate_selectors.iter() { + multiopening_challenge.mul_assign(&v); + let key = PolyIdentifier::GateSelector(s.name()); + let poly_ref = monomials_storage.get_poly(key); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + for idx in 0..(num_state_polys-1) { + multiopening_challenge.mul_assign(&v); + let key = PolyIdentifier::PermutationPolynomial(idx); + let poly_ref = monomials_storage.get_poly(key); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + // if lookup is present - add it + if let Some(data) = lookup_data.as_ref() { + // we need to add t(x), selector(x) and table type(x) + multiopening_challenge.mul_assign(&v); + let poly_ref = data.t_poly_monomial.as_ref().unwrap().as_ref(); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + let poly_ref = data.selector_poly_monomial.as_ref().unwrap().as_ref(); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + let poly_ref = data.table_type_poly_monomial.as_ref().unwrap().as_ref(); + poly_to_divide_at_z.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + // now proceed at z*omega + multiopening_challenge.mul_assign(&v); + let mut poly_to_divide_at_z_omega = copy_permutation_z_in_monomial_form; + poly_to_divide_at_z_omega.scale(&worker, multiopening_challenge); + + // { + // let tmp = commit_using_monomials( + // &poly_to_divide_at_z_omega, + // &mon_crs, + // &worker + // )?; + + // dbg!(tmp); + + // let tmp = poly_to_divide_at_z_omega.evaluate_at(&worker, z_omega); + + // dbg!(tmp); + // } + + const NEXT_STEP_DILATION: usize = 1; + + for id in queries_with_linearization.state_polys[NEXT_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + for id in queries_with_linearization.witness_polys[NEXT_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + for queries in queries_with_linearization.gate_setup_polys.iter() { + for id in queries[NEXT_STEP_DILATION].iter() { + multiopening_challenge.mul_assign(&v); + let poly_ref = monomials_storage.get_poly(*id); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + } + + if let Some(data) = lookup_data { + // we need to add s(x), grand_product(x) and t(x) + multiopening_challenge.mul_assign(&v); + let poly_ref = data.s_poly_monomial.as_ref().unwrap(); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + let poly_ref = lookup_z_poly_in_monomial_form.as_ref().unwrap(); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + let poly_ref = data.t_poly_monomial.as_ref().unwrap().as_ref(); + poly_to_divide_at_z_omega.add_assign_scaled(&worker, poly_ref, &multiopening_challenge); + } + + // division in monomial form is sequential, so we parallelize the divisions + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + let mut polys = vec![(poly_to_divide_at_z, z), (poly_to_divide_at_z_omega, z_by_omega)]; + + worker.scope(polys.len(), |scope, chunk| { + for p in polys.chunks_mut(chunk) { + scope.spawn(move |_| { + let (poly, at) = &p[0]; + let at = *at; + let result = divide_single::(poly.as_ref(), at); + p[0] = (Polynomial::from_coeffs(result).unwrap(), at); + }); + } + }); + + let open_at_z_omega = polys.pop().unwrap().0; + let open_at_z = polys.pop().unwrap().0; + + let opening_at_z = commit_using_monomials( + &open_at_z, + &mon_crs, + &worker + )?; + + let opening_at_z_omega = commit_using_monomials( + &open_at_z_omega, + &mon_crs, + &worker + )?; + + proof.opening_proof_at_z = opening_at_z; + proof.opening_proof_at_z_omega = opening_at_z_omega; + + Ok(proof) + } +} + +#[derive(Debug)] +pub struct SortedGateQueries{ + pub state_polys: Vec>, + pub witness_polys: Vec>, + pub gate_selectors: Vec>>, + pub gate_setup_polys: Vec>>, +} + +/// we sort queries by: +/// - witness first +/// - gate selectors +/// - gate setups in order of gates appearing +/// - additionally we split them into buckets of different dilation +pub fn sort_queries_for_linearization(gates: & Vec>>, max_dilation: usize) -> SortedGateQueries{ + let state_polys_sorted_by_dilation = vec![vec![]; max_dilation+1]; + let witness_polys_sorted_by_dilation = vec![vec![]; max_dilation+1]; + let gate_setup_polys_by_gate_and_dilation = vec![vec![vec![]; max_dilation+1]; gates.len()]; + + let mut queries = SortedGateQueries:: { + state_polys: state_polys_sorted_by_dilation, + witness_polys: witness_polys_sorted_by_dilation, + gate_selectors: vec![], + gate_setup_polys: gate_setup_polys_by_gate_and_dilation, + }; + + let mut opening_requests_before_linearization = std::collections::HashSet::new(); + let mut all_queries = std::collections::HashSet::new(); + let mut sorted_opening_requests = vec![]; + let mut sorted_selector_for_opening = vec![]; + let mut polys_in_linearization = std::collections::HashSet::new(); + + let num_gate_types = gates.len(); + + for (gate_idx, gate) in gates.iter().enumerate() { + for q in gate.all_queried_polynomials().into_iter() { + all_queries.insert(q); + } + let queries_to_add = if gate.benefits_from_linearization() { + if num_gate_types > 1 { + // there are various gates, so we need to query the selector + sorted_selector_for_opening.push(gate.box_clone()); + } + + // it's better to linearize the gate + for q in gate.linearizes_over().into_iter() { + polys_in_linearization.insert(q); + } + + gate.needs_opened_for_linearization() + } else { + // we will linearize over the selector, so we do not need to query it + // and instead have to query all other polynomials + + // we blindly add all queried polys + gate.all_queried_polynomials() + }; + + for q in queries_to_add.into_iter() { + if !opening_requests_before_linearization.contains(&q) { + opening_requests_before_linearization.insert(q.clone()); + + // push into the corresponding bucket + + let (id, dilation_value) = q.into_id_and_raw_dilation(); + match id { + p @ PolyIdentifier::VariablesPolynomial(..) => { + queries.state_polys[dilation_value].push(p); + }, + p @ PolyIdentifier::WitnessPolynomial(..) => { + queries.witness_polys[dilation_value].push(p); + }, + p @ PolyIdentifier::GateSetupPolynomial(..) => { + queries.gate_setup_polys[gate_idx][dilation_value].push(p); + }, + _ => { + unreachable!(); + } + }; + + + sorted_opening_requests.push(q); + + } + } + } + + // Sanity check: we open everything either in linearization or in plain text! + { + let must_open_without_linearization: Vec<_> = all_queries.difference(&polys_in_linearization).collect(); + + for p in must_open_without_linearization.into_iter() { + assert!(opening_requests_before_linearization.contains(&p)); + } + } + + // gate selectors are always sorted by the gate order + queries.gate_selectors = sorted_selector_for_opening; + + queries +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/redshift/mod.rs b/src/plonk/better_better_cs/redshift/mod.rs new file mode 100644 index 000000000..949a4c4f3 --- /dev/null +++ b/src/plonk/better_better_cs/redshift/mod.rs @@ -0,0 +1,8 @@ +pub mod multioracle; +pub mod setup; +pub mod prover; +pub mod simple_fri; +pub mod poseidon_tree_hash; + +pub use super::trees::binary_tree; +pub use super::trees::tree_hash; \ No newline at end of file diff --git a/src/plonk/better_better_cs/redshift/multioracle.rs b/src/plonk/better_better_cs/redshift/multioracle.rs new file mode 100644 index 000000000..c1024978f --- /dev/null +++ b/src/plonk/better_better_cs/redshift/multioracle.rs @@ -0,0 +1,106 @@ +use crate::pairing::{Engine}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use crate::worker::Worker; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::*; +use super::tree_hash::*; +use super::binary_tree::{BinaryTree, BinaryTreeParams}; +use crate::plonk::polynomials::*; + +pub struct Multioracle<'a, E: Engine, H: BinaryTreeHasher > { + pub polynomial_values_refs: Vec<&'a [E::Fr]>, + pub tree: BinaryTree +} + +impl<'a, E: Engine, H: BinaryTreeHasher> Multioracle<'a, E, H> { + pub fn combine_leafs<'p>( + polynomials: &'p [Polynomial], + num_values_from_one_poly_into_leaf: usize, + worker: &Worker + ) -> Vec> { + let num_polys = polynomials.len(); + let num_leafs = polynomials[0].size() / num_values_from_one_poly_into_leaf; + println!("{} leafs total", num_leafs); + assert!(num_leafs.is_power_of_two()); + + // we need vector (over leafs) + // of vectors(over individual polys) + // of references + let mut leaf_refs_combined: Vec> = vec![vec![&[]; num_polys]; num_leafs]; + + let poly_refs: Vec<_> = polynomials.iter().map(|el| el.as_ref()).collect(); + + let poly_refs_ref = &poly_refs; + + println!("Start combining leafs"); + + worker.scope(leaf_refs_combined.len(), |scope, chunk| { + for (i, lh) in leaf_refs_combined.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // we take `values_per_leaf` values from each of the polynomial + // and push them into the conbinations + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let start = idx * num_values_from_one_poly_into_leaf; + let end = start + num_values_from_one_poly_into_leaf; + + for (idx, &poly_values) in poly_refs_ref.iter().enumerate() { + let slice = &poly_values[start..end]; + lh[idx] = slice; + } + } + }); + } + }); + + println!("Done combining leafs"); + + leaf_refs_combined + } + + pub fn new_from_polynomials( + polynomials: &'a [Polynomial], + tree_hasher: H, + num_values_from_one_poly_into_leaf: usize, + worker: &Worker + ) -> Self { + // first make combinations of leaf values + // expect polynomials to be in bitreverse enumeration + let num_polys = polynomials.len(); + let values_per_leaf = num_polys * num_values_from_one_poly_into_leaf; + println!("Placing {} values into single leaf", values_per_leaf); + + let tree_params = BinaryTreeParams { + values_per_leaf: values_per_leaf + }; + + // we need vector (over leafs) + // of vectors(over individual polys) + // of references + let leaf_refs_combined = Self::combine_leafs( + polynomials, + num_values_from_one_poly_into_leaf, + &worker + ); + + println!("Start making a tree"); + + let tree = BinaryTree::create_from_combined_leafs( + &leaf_refs_combined, + num_polys, + tree_hasher, + &tree_params + ); + + println!("Done making a tree"); + + let poly_refs: Vec<_> = polynomials.iter().map(|el| el.as_ref()).collect(); + + Self { + polynomial_values_refs: poly_refs, + tree + } + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/redshift/poseidon_tree_hash.rs b/src/plonk/better_better_cs/redshift/poseidon_tree_hash.rs new file mode 100644 index 000000000..4a211d36a --- /dev/null +++ b/src/plonk/better_better_cs/redshift/poseidon_tree_hash.rs @@ -0,0 +1,57 @@ +use crate::pairing::ff::{Field, PrimeField}; +use poseidon_hash::{PoseidonEngine, PoseidonHashParams, poseidon_hash}; +use super::tree_hash::BinaryTreeHasher; + +pub struct PoseidonBinaryTreeHasher<'a, E: PoseidonEngine> { + params: &'a E::Params, +} + +impl<'a, E: PoseidonEngine> PoseidonBinaryTreeHasher<'a, E> { + pub fn new(params: &'a E::Params) -> Self { + assert_eq!(params.rate(), 2u32); + assert_eq!(params.output_len(), 1u32); + Self { + params: params + } + } +} + +impl<'a, E: PoseidonEngine> Clone for PoseidonBinaryTreeHasher<'a, E> { + fn clone(&self) -> Self { + Self { + params: self.params + } + } +} + +use std::sync::atomic::{AtomicUsize, Ordering}; + +impl<'a, E: PoseidonEngine> BinaryTreeHasher for PoseidonBinaryTreeHasher<'a, E> { + type Output = E::Fr; + + #[inline] + fn placeholder_output() -> Self::Output { + E::Fr::zero() + } + + fn leaf_hash(&self, input: &[E::Fr]) -> Self::Output { + let mut num_invocations = input.len() / 2; + if input.len() % 2 != 0 { + num_invocations += 1; + } + + super::tree_hash::COUNTER.fetch_add(num_invocations, Ordering::SeqCst); + + let mut as_vec = poseidon_hash::(self.params, input); + + as_vec.pop().unwrap() + } + + fn node_hash(&self, input: &[Self::Output; 2], _level: usize) -> Self::Output { + super::tree_hash::COUNTER.fetch_add(2, Ordering::SeqCst); + + let mut as_vec = poseidon_hash::(self.params, &input[..]); + + as_vec.pop().unwrap() + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/redshift/prover.rs b/src/plonk/better_better_cs/redshift/prover.rs new file mode 100644 index 000000000..f3cad2ab8 --- /dev/null +++ b/src/plonk/better_better_cs/redshift/prover.rs @@ -0,0 +1,1480 @@ +use crate::pairing::{Engine}; +use crate::pairing::ff::{Field, PrimeField, PrimeFieldRepr}; +use crate::worker::Worker; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::*; +use super::tree_hash::BinaryTreeHasher; +use super::binary_tree::{BinaryTree, BinaryTreeParams}; +use crate::plonk::polynomials::*; +use super::multioracle::Multioracle; +use super::super::cs_old::*; +use crate::SynthesisError; +use super::setup::*; +use crate::plonk::better_cs::utils::*; +use crate::plonk::domains::*; +use crate::plonk::fft::cooley_tukey_ntt::*; +use simple_fri::*; +use crate::plonk::commitments::transcript::Prng; + +pub(crate) fn get_precomputed_x_lde( + domain_size: usize, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + let mut x_poly = Polynomial::from_values(vec![ + coset_factor; + domain_size + ])?; + x_poly.distribute_powers(&worker, x_poly.omega); + x_poly.bitreverse_enumeration(&worker); + + Ok(x_poly) +} + +pub(crate) fn get_precomputed_inverse_divisor( + vanishing_size: usize, + domain_size: usize, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + let mut vanishing_poly_inverse_bitreversed = + evaluate_vanishing_polynomial_of_degree_on_domain_size::( + vanishing_size as u64, + &coset_factor, + domain_size as u64, + &worker, + )?; + vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker); + + Ok(vanishing_poly_inverse_bitreversed) +} + +pub(crate) struct FirstPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_ldes: Vec>, + witness_polys_unpadded_values: Vec>, + witness_multioracle_tree: BinaryTree, +} + +pub(crate) struct FirstProverMessage> { + pub(crate) n: usize, + pub(crate) num_inputs: usize, + pub(crate) input_values: Vec, + pub(crate) witness_multioracle_commitment: H::Output, +} + +pub(crate) struct FirstVerifierMessage { + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, +} + +pub(crate) struct SecondPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_ldes: Vec>, + witness_polys_in_monomial_form: Vec>, + witness_multioracle_tree: BinaryTree, + grand_product_polynomial_lde: Vec>, + grand_product_polynomial_in_monomial_form: Vec>, + grand_product_polynomial_multioracle_tree: BinaryTree, +} + +pub(crate) struct SecondProverMessage> { + pub(crate) grand_product_oracle_commitment: H::Output, + + _marker: std::marker::PhantomData +} + +pub(crate) struct SecondVerifierMessage { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, +} + +pub(crate) struct ThirdPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_ldes: Vec>, + witness_polys_in_monomial_form: Vec>, + witness_multioracle_tree: BinaryTree, + grand_product_polynomial_lde: Vec>, + grand_product_polynomial_in_monomial_form: Vec>, + grand_product_polynomial_multioracle_tree: BinaryTree, + t_poly_parts_ldes: Vec>, + t_poly_parts: Vec>, + t_poly_parts_multioracle_tree: BinaryTree, +} + +pub(crate) struct ThirdProverMessage> { + pub(crate) quotient_poly_oracle_commitment: H::Output, + + _marker: std::marker::PhantomData +} + +pub(crate) struct ThirdVerifierMessage { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + pub(crate) z: E::Fr, +} + +pub(crate) struct FourthPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_ldes: Vec>, + witness_polys_in_monomial_form: Vec>, + witness_multioracle_tree: BinaryTree, + grand_product_polynomial_lde: Vec>, + grand_product_polynomial_in_monomial_form: Vec>, + grand_product_polynomial_multioracle_tree: BinaryTree, + t_poly_parts_ldes: Vec>, + t_poly_parts: Vec>, + t_poly_parts_multioracle_tree: BinaryTree, + wire_values_at_z: Vec<(usize, E::Fr)>, + wire_values_at_z_omega: Vec<(usize, E::Fr)>, + setup_values_at_z: Vec, + permutation_polynomials_at_z: Vec, + gate_selector_polynomials_at_z: Vec, + grand_product_at_z: E::Fr, + grand_product_at_z_omega: E::Fr, + quotient_polynomial_parts_at_z: Vec, +} + +pub(crate) struct FourthProverMessage { + pub(crate) wire_values_at_z: Vec<(usize, E::Fr)>, + pub(crate) wire_values_at_z_omega: Vec<(usize, E::Fr)>, + pub(crate) setup_values_at_z: Vec, + pub(crate) permutation_polynomials_at_z: Vec, + pub(crate) gate_selector_polynomials_at_z: Vec, + pub(crate) grand_product_at_z: E::Fr, + pub(crate) grand_product_at_z_omega: E::Fr, + pub(crate) quotient_polynomial_parts_at_z: Vec, +} + +pub(crate) struct FourthVerifierMessage { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + pub(crate) z: E::Fr, + pub(crate) v: E::Fr, +} + +pub(crate) struct FifthProverMessage> { + pub(crate) fri_intermediate_roots: Vec, + pub(crate) final_coefficients: Vec, +} + +struct WitnessOpeningRequest<'a, F: PrimeField> { + polynomials: Vec<&'a Polynomial>, + opening_point: F, + opening_values: Vec +} + +struct SetupOpeningRequest<'a, F: PrimeField> { + polynomials: Vec<&'a Polynomial>, + setup_point: F, + setup_values: Vec, + opening_point: F, + opening_values: Vec +} + +pub struct RedshiftProver> { + sorted_gates: Vec>, + gate_constants: Vec>, + precomputed_omegas: BitReversedOmegas, + precomputed_omegas_inv: OmegasInvBitreversed, + tree_hasher: H, + state_width: usize, +} + +impl> RedshiftProver { + pub(crate) fn first_step, MG: MainGateEquation>( + assembly: TrivialAssembly, + tree_hasher: H, + worker: &Worker, + ) -> Result<( + Self, + FirstPartialProverState, + FirstProverMessage + ), SynthesisError> + { + assert!(assembly.is_finalized); + + let input_values = assembly.input_assingments.clone(); + + let n = assembly.n(); + let size = n.next_power_of_two(); + let num_inputs = assembly.num_inputs; + + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let non_residues = make_non_residues::( + P::STATE_WIDTH - 1 + ); + + let (full_assignments, _) = assembly.make_state_and_witness_polynomials(&worker)?; + + let gate_constants = assembly.sorted_gate_constants; + let sorted_gates = assembly.sorted_gates; + + // Commit wire polynomials + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + let mut first_message = FirstProverMessage:: { + n: n, + num_inputs: num_inputs, + input_values: input_values.clone(), + witness_multioracle_commitment: H::placeholder_output() + }; + + let s = Self { + sorted_gates, + gate_constants, + precomputed_omegas: omegas_bitreversed, + precomputed_omegas_inv: omegas_inv_bitreversed, + tree_hasher: tree_hasher.clone(), + state_width: P::STATE_WIDTH, + }; + + let coset_factor = E::Fr::multiplicative_generator(); + + let mut witness_polys_ldes = vec![]; + + for wire_poly in full_assignments.iter() { + let lde = Polynomial::from_values(wire_poly.clone())? + .ifft_using_bitreversed_ntt( + &worker, + &s.precomputed_omegas_inv, + &E::Fr::one() + )? + .bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + &s.precomputed_omegas, + &coset_factor + )?; + + witness_polys_ldes.push(lde); + } + + // now transform assignments in the polynomials + + let mut witness_polys_unpadded_values = vec![]; + + for p in full_assignments.into_iter() { + let p = Polynomial::from_values_unpadded(p)?; + witness_polys_unpadded_values.push(p); + } + + let multioracle = Multioracle::new_from_polynomials( + &witness_polys_ldes, + tree_hasher, + FRI_VALUES_PER_LEAF, + &worker + ); + + let tree = multioracle.tree; + first_message.witness_multioracle_commitment = tree.get_commitment(); + + let first_state = FirstPartialProverState:: { + required_domain_size: n+1, + non_residues: non_residues, + input_values: input_values.clone(), + witness_polys_ldes: witness_polys_ldes, + witness_polys_unpadded_values: witness_polys_unpadded_values, + witness_multioracle_tree: tree + }; + + Ok((s, first_state, first_message)) + } + + pub(crate) fn second_step_from_first_step( + &self, + first_state: FirstPartialProverState, + first_verifier_message: FirstVerifierMessage, + permutation_polynomials: &Vec>, + worker: &Worker + ) -> Result<( + SecondPartialProverState, + SecondProverMessage + ), SynthesisError> + { + let FirstVerifierMessage { beta, gamma, ..} = first_verifier_message; + + assert_eq!(first_state.witness_polys_unpadded_values.len(), self.state_width, "first state must containt assignment poly values"); + + let mut grand_products_protos_with_gamma = first_state.witness_polys_unpadded_values.clone(); + + // add gamma here to save computations later + for p in grand_products_protos_with_gamma.iter_mut() { + p.add_constant(&worker, &gamma); + } + + let required_domain_size = first_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(first_state.non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let z_den = { + assert_eq!( + permutation_polynomials.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = permutation_polynomials.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, permutation_polys_it.next().unwrap(), &beta); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, perm, &beta); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + assert!(z.as_ref().last().expect("must exist") == &E::Fr::one()); + + // interpolate on the main domain + let grand_product_in_monomial_form = z.ifft_using_bitreversed_ntt(&worker, &self.precomputed_omegas_inv, &E::Fr::one())?; + + let coset_factor = E::Fr::multiplicative_generator(); + + let grand_product_lde = grand_product_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + &self.precomputed_omegas, + &coset_factor + )?; + + let grand_product_ldes = vec![grand_product_lde]; + + let multioracle = Multioracle::new_from_polynomials( + &grand_product_ldes, + self.tree_hasher.clone(), + FRI_VALUES_PER_LEAF, + &worker + ); + + let mut witness_polys_in_monomial_form = vec![]; + for mut p in first_state.witness_polys_unpadded_values.into_iter() { + p.pad_to_domain()?; + let p = p.ifft_using_bitreversed_ntt(&worker, &self.precomputed_omegas_inv, &E::Fr::one())?; + witness_polys_in_monomial_form.push(p); + } + + let tree = multioracle.tree; + let commitment = tree.get_commitment(); + + let state = SecondPartialProverState:: { + required_domain_size, + non_residues: first_state.non_residues, + input_values: first_state.input_values, + witness_polys_ldes: first_state.witness_polys_ldes, + witness_polys_in_monomial_form: witness_polys_in_monomial_form, + witness_multioracle_tree: first_state.witness_multioracle_tree, + grand_product_polynomial_lde: grand_product_ldes, + grand_product_polynomial_in_monomial_form: vec![grand_product_in_monomial_form], + grand_product_polynomial_multioracle_tree: tree, + }; + + let message = SecondProverMessage:: { + grand_product_oracle_commitment: commitment, + + _marker: std::marker::PhantomData + }; + + Ok((state, message)) + } + + pub(crate) fn third_step_from_second_step( + &self, + second_state: SecondPartialProverState, + second_verifier_message: SecondVerifierMessage, + setup: &SetupMultioracle, + worker: &Worker + ) -> Result<( + ThirdPartialProverState, + ThirdProverMessage + ), SynthesisError> + { + use std::sync::Arc; + + let mut quotient_linearization_challenge = E::Fr::one(); + let SecondVerifierMessage { alpha, beta, gamma, .. } = second_verifier_message; + + let coset_factor = E::Fr::multiplicative_generator(); + + let required_domain_size = second_state.required_domain_size; + + println!("Domain size = {}", required_domain_size); + + let mut max_degree = self.state_width + 1; + let assume_gate_selectors = self.sorted_gates.len() > 1; + + let mut extra_precomputations_storage_by_time_dilation = std::collections::HashMap::new(); + + for gate in self.sorted_gates.iter() { + let mut degree = gate.degree(); + if assume_gate_selectors { + degree += 1; + } + + if degree > max_degree { + max_degree = degree; + } + } + + assert!(max_degree <= 5, "we do not support very high order constraints yet"); + + let quotient_degree_factor = (max_degree - 1).next_power_of_two(); + // let quotient_degree_factor = 8; + + let quotient_degree = quotient_degree_factor * required_domain_size; + + assert!(quotient_degree.is_power_of_two()); + + let one = E::Fr::one(); + let mut minus_one = one; + minus_one.negate(); + + // we also assume bitreverse + let mut t = Polynomial::::new_for_size(quotient_degree)?; + + let mut global_scratch_space = t.clone(); + + let mut public_inputs_processed = false; + + let partition_factor = LDE_FACTOR / quotient_degree_factor; + + let use_gate_selectors = self.sorted_gates.len() > 1; + let selectors_indexes = setup.gate_selectors_indexes.clone(); + println!("Have {} gate selector indexes", selectors_indexes.len()); + let mut selectors_range_it = selectors_indexes.into_iter(); + + let mut local_scratch_space = if use_gate_selectors { + Some(global_scratch_space.clone()) + } else { + None + }; + + for (i, (gate, constants)) in self.sorted_gates.iter().zip(self.gate_constants.iter()).enumerate() { + let mut constants_iter = constants.iter(); + if i == 0 { + assert!(gate.can_include_public_inputs()); + } + let constant_term_index = gate.put_public_inputs_into_selector_id(); + for constraint in gate.get_constraints().iter() { + for term in constraint.0.iter() { + let mut must_refill_scratch = true; + let mut base = match term.0 { + Coefficient::PlusOne => one, + Coefficient::MinusOne => minus_one, + Coefficient::Other => *constants_iter.next().unwrap() + }; + + for poly in term.1.iter() { + match poly { + PolynomialInConstraint::VariablesPolynomial( + poly_num, TimeDilation(0) + ) => { + let poly_lde_ref = &second_state.witness_polys_ldes[*poly_num]; + let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + partition_factor + )?; + let scratch_space = if use_gate_selectors { + local_scratch_space.as_mut().unwrap() + } else { + &mut global_scratch_space + }; + + if must_refill_scratch { + must_refill_scratch = false; + scratch_space.reuse_allocation(&poly_lde_part); + } else { + scratch_space.mul_assign(&worker, &poly_lde_part); + } + }, + PolynomialInConstraint::VariablesPolynomial( + poly_num, TimeDilation(dilation) + ) => { + let dilated_poly = if let Some(dilated_poly) = extra_precomputations_storage_by_time_dilation.get(&(*poly_num, TimeDilation(*dilation))) { + dilated_poly + } else { + let poly_lde_ref = &second_state.witness_polys_ldes[*poly_num]; + let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + partition_factor + )?; + + let shift = quotient_degree_factor * (*dilation); + let dilated_poly = poly_lde_part.clone_shifted_assuming_bitreversed(shift, &worker)?; + + extra_precomputations_storage_by_time_dilation.insert((*poly_num, TimeDilation(*dilation)), dilated_poly); + + extra_precomputations_storage_by_time_dilation.get(&(*poly_num, TimeDilation(*dilation))).unwrap() + }; + + let scratch_space = if use_gate_selectors { + local_scratch_space.as_mut().unwrap() + } else { + &mut global_scratch_space + }; + + if must_refill_scratch { + must_refill_scratch = false; + scratch_space.reuse_allocation(dilated_poly); + } else { + scratch_space.mul_assign(&worker, dilated_poly); + } + }, + PolynomialInConstraint::SetupPolynomial( + str_id, poly_num, TimeDilation(0) + ) => { + let id = PolyIdentifier::SetupPolynomial(str_id, *poly_num); + let idx = setup.setup_ids.iter().position(|el| el == &id).unwrap(); + let poly_lde_ref = &setup.polynomial_ldes[idx]; + let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + partition_factor + )?; + + let process_public_inputs = if constant_term_index.is_some() { + public_inputs_processed == false && constant_term_index.unwrap() == *poly_num + } else { + false + }; + + let scratch_space = if use_gate_selectors { + local_scratch_space.as_mut().unwrap() + } else { + &mut global_scratch_space + }; + + if process_public_inputs { + public_inputs_processed = true; + // processing public inputs + assert!(base == one); // base coefficient for here should be one + let mut inputs_poly = Polynomial::::new_for_size(required_domain_size)?; + + for (idx, &input) in second_state.input_values.iter().enumerate() { + inputs_poly.as_mut()[idx] = input; + } + // go into monomial form + + let inputs_poly = inputs_poly.ifft_using_bitreversed_ntt( + &worker, + &self.precomputed_omegas_inv, + &E::Fr::one() + )?; + + let mut inputs_poly = inputs_poly.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR / partition_factor, + &self.precomputed_omegas, + &coset_factor + )?; + + // add constants selectors vector + inputs_poly.add_assign(&worker, &poly_lde_part); + + if must_refill_scratch { + must_refill_scratch = false; + scratch_space.reuse_allocation(&inputs_poly); + } else { + scratch_space.mul_assign(&worker, &inputs_poly); + } + } else { + if must_refill_scratch { + must_refill_scratch = false; + scratch_space.reuse_allocation(&poly_lde_part); + } else { + scratch_space.mul_assign(&worker, &poly_lde_part); + } + } + }, + _ => { + unimplemented!() + } + } + } + + base.mul_assign("ient_linearization_challenge); + + if use_gate_selectors { + let scratch_space = local_scratch_space.as_ref().unwrap(); + global_scratch_space.add_assign_scaled(&worker, &scratch_space, &base); + } else { + // add into T poly directly + t.add_assign_scaled(&worker, &global_scratch_space, &base); + } + } + + // if use_gate_selectors { + // let selector_idx = (&mut selectors_range_it).next().expect(&format!("must get gate selector for gate {}", i)); + // let poly_lde_ref = &setup.polynomial_ldes[selector_idx]; + // let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + // partition_factor + // )?; + // global_scratch_space.mul_assign(&worker, &poly_lde_part); + // t.add_assign(&worker, &global_scratch_space); + // } + + quotient_linearization_challenge.mul_assign(&alpha); + } + + if use_gate_selectors { + let selector_idx = (&mut selectors_range_it).next().expect(&format!("must get gate selector for gate {}", i)); + let poly_lde_ref = &setup.polynomial_ldes[selector_idx]; + let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + partition_factor + )?; + global_scratch_space.mul_assign(&worker, &poly_lde_part); + t.add_assign(&worker, &global_scratch_space); + } + } + + let mut scratch_space = global_scratch_space; + + let grand_product_lde_bitreversed = second_state.grand_product_polynomial_lde[0].clone_subset_assuming_bitreversed( + partition_factor + )?; + + let shift = quotient_degree_factor; + + let grand_product_shifted_lde_bitreversed = grand_product_lde_bitreversed.clone_shifted_assuming_bitreversed(shift, &worker)?; + + let non_residues = second_state.non_residues.clone(); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + + { + let mut contrib_z = grand_product_lde_bitreversed.clone(); + + // A + beta*X + gamma + + let poly_lde_ref = &second_state.witness_polys_ldes[0]; + let poly_lde_part = poly_lde_ref.clone_subset_assuming_bitreversed( + partition_factor + )?; + + scratch_space.reuse_allocation(&poly_lde_part); + drop(poly_lde_ref); + + scratch_space.add_constant(&worker, &gamma); + let x_precomp = get_precomputed_x_lde::( + quotient_degree, + &worker + )?; + + scratch_space.add_assign_scaled(&worker, &x_precomp, &beta); + contrib_z.mul_assign(&worker, &scratch_space); + + assert_eq!(non_residues.len() + 1, self.state_width); + + for (w, non_res) in second_state.witness_polys_ldes[1..].iter().zip(non_residues.iter()) { + let mut factor = beta; + factor.mul_assign(&non_res); + + let poly_lde_part = w.clone_subset_assuming_bitreversed( + partition_factor + )?; + + scratch_space.reuse_allocation(&poly_lde_part); + scratch_space.add_constant(&worker, &gamma); + scratch_space.add_assign_scaled(&worker, &x_precomp, &factor); + contrib_z.mul_assign(&worker, &scratch_space); + } + + t.add_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + + let mut contrib_z = grand_product_shifted_lde_bitreversed; + + // A + beta*perm_a + gamma + + for (w, perm_idx) in second_state.witness_polys_ldes.iter().zip(setup.permutations_ranges[0].clone()) { + let poly_lde_part = w.clone_subset_assuming_bitreversed( + partition_factor + )?; + + let perm_part = setup.polynomial_ldes[perm_idx].clone_subset_assuming_bitreversed( + partition_factor + )?; + + scratch_space.reuse_allocation(&poly_lde_part); + scratch_space.add_constant(&worker, &gamma); + scratch_space.add_assign_scaled(&worker, &perm_part, &beta); + contrib_z.mul_assign(&worker, &scratch_space); + } + + t.sub_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // z(omega^0) - 1 == 0 + + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + { + let mut z_minus_one_by_l_0 = grand_product_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + let l_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR / partition_factor, + &self.precomputed_omegas, + &coset_factor + )?; + + z_minus_one_by_l_0.mul_assign(&worker, &l_coset_lde_bitreversed); + + t.add_assign_scaled(&worker, &z_minus_one_by_l_0, "ient_linearization_challenge); + + drop(z_minus_one_by_l_0); + } + + drop(scratch_space); + + let divisor_inversed = get_precomputed_inverse_divisor::( + required_domain_size, + quotient_degree, + &worker + )?; + t.mul_assign(&worker, &divisor_inversed); + + t.bitreverse_enumeration(&worker); + + let t_poly_in_monomial_form = t.icoset_fft_for_generator( + &worker, + &E::Fr::multiplicative_generator() + ); + + fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + degree + } + + println!("T degree = {}", get_degree::(&t_poly_in_monomial_form)); + + let t_poly_parts = t_poly_in_monomial_form.break_into_multiples(required_domain_size)?; + + let mut t_poly_parts_ldes = vec![]; + for p in t_poly_parts.iter() { + let lde = p.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + &self.precomputed_omegas, + &coset_factor + )?; + + t_poly_parts_ldes.push(lde); + } + + let multioracle = Multioracle::new_from_polynomials( + &t_poly_parts_ldes, + self.tree_hasher.clone(), + FRI_VALUES_PER_LEAF, + &worker + ); + + let tree = multioracle.tree; + let commitment = tree.get_commitment(); + + let state = ThirdPartialProverState:: { + required_domain_size, + non_residues: second_state.non_residues, + input_values: second_state.input_values, + witness_polys_ldes: second_state.witness_polys_ldes, + witness_polys_in_monomial_form: second_state.witness_polys_in_monomial_form, + witness_multioracle_tree: second_state.witness_multioracle_tree, + grand_product_polynomial_lde: second_state.grand_product_polynomial_lde, + grand_product_polynomial_in_monomial_form: second_state.grand_product_polynomial_in_monomial_form, + grand_product_polynomial_multioracle_tree: second_state.grand_product_polynomial_multioracle_tree, + t_poly_parts_ldes: t_poly_parts_ldes, + t_poly_parts: t_poly_parts, + t_poly_parts_multioracle_tree: tree, + }; + + let message = ThirdProverMessage:: { + quotient_poly_oracle_commitment: commitment, + + _marker: std::marker::PhantomData + }; + + Ok((state, message)) + } + + pub(crate) fn fourth_step_from_third_step( + &self, + third_state: ThirdPartialProverState, + third_verifier_message: ThirdVerifierMessage, + setup: &SetupMultioracle, + worker: &Worker + ) -> Result<( + FourthPartialProverState, + FourthProverMessage + ), SynthesisError> + { + let ThirdVerifierMessage { z, .. } = third_verifier_message; + let required_domain_size = third_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut state = FourthPartialProverState:: { + required_domain_size, + non_residues: third_state.non_residues, + input_values: third_state.input_values, + witness_polys_ldes: third_state.witness_polys_ldes, + witness_polys_in_monomial_form: third_state.witness_polys_in_monomial_form, + witness_multioracle_tree: third_state.witness_multioracle_tree, + grand_product_polynomial_lde: third_state.grand_product_polynomial_lde, + grand_product_polynomial_in_monomial_form: third_state.grand_product_polynomial_in_monomial_form, + grand_product_polynomial_multioracle_tree: third_state.grand_product_polynomial_multioracle_tree, + t_poly_parts_ldes: third_state.t_poly_parts_ldes, + t_poly_parts: third_state.t_poly_parts, + t_poly_parts_multioracle_tree: third_state.t_poly_parts_multioracle_tree, + wire_values_at_z: vec![], + wire_values_at_z_omega: vec![], + setup_values_at_z: vec![E::Fr::zero(); setup.setup_ids.len()], + permutation_polynomials_at_z: vec![], + gate_selector_polynomials_at_z: vec![], + grand_product_at_z: E::Fr::zero(), + grand_product_at_z_omega: E::Fr::zero(), + quotient_polynomial_parts_at_z: vec![], + }; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + // now need to go over constraints and decide what polynomials to open where + + let mut dilation_maps = std::collections::HashMap::new(); + + for gate in self.sorted_gates.iter() { + for constraint in gate.get_constraints().iter() { + for term in constraint.0.iter() { + for poly in term.1.iter() { + match poly { + PolynomialInConstraint::VariablesPolynomial( + poly_num, TimeDilation(dilation) + ) => { + let poly_id = PolyIdentifier::VariablesPolynomial(*poly_num); + let key = TimeDilation(*dilation); + let entry = dilation_maps.entry(key).or_insert(vec![]); + if !entry.contains(&poly_id) { + entry.push(poly_id); + } + }, + PolynomialInConstraint::SetupPolynomial( + str_id, poly_num, TimeDilation(0) + ) => { + let poly_id = PolyIdentifier::SetupPolynomial(str_id, *poly_num); + let key = TimeDilation(0); + let entry = dilation_maps.entry(key).or_insert(vec![]); + if !entry.contains(&poly_id) { + entry.push(poly_id); + } + }, + _ => { + unimplemented!() + } + } + } + } + } + } + + let mut keys: Vec<_> = dilation_maps.keys().map(|el| el.clone()).collect(); + keys.sort_by(|a, b| a.0.cmp(&b.0)); + + assert!(keys.len() <= 2, "large time dilations are not supported"); + + let points_set = vec![z, z_by_omega]; + + for (i, key) in keys.into_iter().enumerate() { + let poly_ids = (&mut dilation_maps).remove(&key).unwrap(); + for id in poly_ids.into_iter() { + if let Some(setup_poly_idx) = setup.setup_ids.iter().position(|el| el == &id) { + assert!(i == 0, "don't support setup polys with dilation yet"); + let poly_ref = &setup.polynomials_in_monomial_form[setup_poly_idx]; + let evaluate_at = points_set[i]; + let value = poly_ref.evaluate_at(&worker, evaluate_at); + + state.setup_values_at_z[setup_poly_idx] = value; + } else { + if let PolyIdentifier::VariablesPolynomial(state_idx) = id { + let poly_ref = &state.witness_polys_in_monomial_form[state_idx]; + let evaluate_at = points_set[i]; + let value = poly_ref.evaluate_at(&worker, evaluate_at); + if i == 0 { + state.wire_values_at_z.push((state_idx, value)); + } else if i == 1 { + state.wire_values_at_z_omega.push((state_idx, value)); + } + } else { + unimplemented!() + } + } + } + + if i == 0 { + // also open permutation polys and quotient + for setup_poly_idx in setup.permutations_ranges[0].clone() { + let poly_ref = &setup.polynomials_in_monomial_form[setup_poly_idx]; + let value = poly_ref.evaluate_at(&worker, z); + + state.permutation_polynomials_at_z.push(value); + } + + for selector_poly_idx in setup.gate_selectors_indexes.iter() { + let poly_ref = &setup.polynomials_in_monomial_form[*selector_poly_idx]; + let value = poly_ref.evaluate_at(&worker, z); + + state.gate_selector_polynomials_at_z.push(value); + } + + // let mut quotient_at_z = E::Fr::zero(); + // let mut current = E::Fr::one(); + // let mut z_in_domain_size = z.pow(&[required_domain_size as u64]); + for poly_ref in state.t_poly_parts.iter() { + let value_of_part = poly_ref.evaluate_at(&worker, z); + + state.quotient_polynomial_parts_at_z.push(value_of_part); + } + } + } + + state.grand_product_at_z = state.grand_product_polynomial_in_monomial_form[0].evaluate_at(&worker, z); + state.grand_product_at_z_omega = state.grand_product_polynomial_in_monomial_form[0].evaluate_at(&worker, z_by_omega); + + let message = FourthProverMessage:: { + wire_values_at_z: state.wire_values_at_z.clone(), + wire_values_at_z_omega: state.wire_values_at_z_omega.clone(), + setup_values_at_z: state.setup_values_at_z.clone(), + permutation_polynomials_at_z: state.permutation_polynomials_at_z.clone(), + gate_selector_polynomials_at_z: state.gate_selector_polynomials_at_z.clone(), + grand_product_at_z: state.grand_product_at_z, + grand_product_at_z_omega: state.grand_product_at_z_omega, + quotient_polynomial_parts_at_z: state.quotient_polynomial_parts_at_z.clone(), + }; + + Ok((state, message)) + } + + fn perform_fri> + ( + &self, + aggregation_challenge: E::Fr, + witness_opening_requests: Vec>, + setup_opening_requests: Vec>, + worker: &Worker, + prng: &mut P + ) -> Result, SynthesisError> { + let mut len = 0; + for r in witness_opening_requests.iter() { + for p in r.polynomials.iter() { + if len == 0 { + len = p.size(); + } else { + assert_eq!(p.size(), len, "poly lengths are different!"); + } + } + } + + for r in setup_opening_requests.iter() { + for p in r.polynomials.iter() { + if len == 0 { + len = p.size(); + } else { + assert_eq!(p.size(), len, "poly lengths are different!"); + } + } + } + + assert!(len != 0); + let required_divisor_size = len; + + let mut final_aggregate = Polynomial::from_values(vec![E::Fr::zero(); required_divisor_size])?; + + let mut precomputed_bitreversed_coset_divisor = Polynomial::from_values(vec![E::Fr::one(); required_divisor_size])?; + precomputed_bitreversed_coset_divisor.distribute_powers(&worker, precomputed_bitreversed_coset_divisor.omega); + precomputed_bitreversed_coset_divisor.scale(&worker, E::Fr::multiplicative_generator()); + precomputed_bitreversed_coset_divisor.bitreverse_enumeration(&worker); + + let mut scratch_space_numerator = final_aggregate.clone(); + let mut scratch_space_denominator = final_aggregate.clone(); + + let mut alpha = E::Fr::one(); + + for witness_request in witness_opening_requests.iter() { + let z = witness_request.opening_point; + let mut minus_z = z; + minus_z.negate(); + scratch_space_denominator.reuse_allocation(&precomputed_bitreversed_coset_divisor); + scratch_space_denominator.add_constant(&worker, &minus_z); + scratch_space_denominator.batch_inversion(&worker)?; + for (poly, value) in witness_request.polynomials.iter().zip(witness_request.opening_values.iter()) { + scratch_space_numerator.reuse_allocation(&poly); + let mut v = *value; + v.negate(); + scratch_space_numerator.add_constant(&worker, &v); + scratch_space_numerator.mul_assign(&worker, &scratch_space_denominator); + if aggregation_challenge != E::Fr::one() { + scratch_space_numerator.scale(&worker, alpha); + } + + final_aggregate.add_assign(&worker, &scratch_space_numerator); + + alpha.mul_assign(&aggregation_challenge); + } + } + + for setup_request in setup_opening_requests.iter() { + // for now assume a single setup point per poly and setup point is the same for all polys + // (omega - y)(omega - z) = omega^2 - (z+y)*omega + zy + + let setup_point = setup_request.setup_point; + let opening_point = setup_request.opening_point; + + let mut t0 = setup_point; + t0.add_assign(&opening_point); + t0.negate(); + + let mut t1 = setup_point; + t1.mul_assign(&opening_point); + + scratch_space_denominator.reuse_allocation(&precomputed_bitreversed_coset_divisor); + worker.scope(scratch_space_denominator.as_ref().len(), |scope, chunk| { + for den in scratch_space_denominator.as_mut().chunks_mut(chunk) { + scope.spawn(move |_| { + for d in den.iter_mut() { + let mut result = *d; + result.square(); + result.add_assign(&t1); + + let mut tmp = t0; + tmp.mul_assign(&d); + + result.add_assign(&tmp); + + *d = result; + } + }); + } + }); + + scratch_space_denominator.batch_inversion(&worker)?; + + // each numerator must have a value removed of the polynomial that interpolates the following points: + // (setup_x, setup_y) + // (opening_x, opening_y) + // such polynomial is linear and has a form e.g setup_y + (X - setup_x) * (witness_y - setup_y) / (witness_x - setup_x) + + for ((poly, value), setup_value) in setup_request.polynomials.iter().zip(setup_request.opening_values.iter()).zip(setup_request.setup_values.iter()) { + scratch_space_numerator.reuse_allocation(&poly); + + let intercept = setup_value; + let mut t0 = opening_point; + t0.sub_assign(&setup_point); + + let mut slope = t0.inverse().expect("must exist"); + + let mut t1 = *value; + t1.sub_assign(&setup_value); + + slope.mul_assign(&t1); + + worker.scope(scratch_space_numerator.as_ref().len(), |scope, chunk| { + for (num, omega) in scratch_space_numerator.as_mut().chunks_mut(chunk). + zip(precomputed_bitreversed_coset_divisor.as_ref().chunks(chunk)) { + scope.spawn(move |_| { + for (n, omega) in num.iter_mut().zip(omega.iter()) { + let mut result = *omega; + result.sub_assign(&setup_point); + result.mul_assign(&slope); + result.add_assign(&intercept); + + n.sub_assign(&result); + } + }); + } + }); + + scratch_space_numerator.mul_assign(&worker, &scratch_space_denominator); + if aggregation_challenge != E::Fr::one() { + scratch_space_numerator.scale(&worker, alpha); + } + + final_aggregate.add_assign(&worker, &scratch_space_numerator); + + alpha.mul_assign(&aggregation_challenge); + } + } + + let fri_combiner = FriCombiner::initialize_for_domain_size( + required_divisor_size, + LDE_FACTOR, + 1, + E::Fr::multiplicative_generator(), + FRI_VALUES_PER_LEAF, + self.tree_hasher.clone(), + ); + + println!("Start making FRI oracles"); + + let oracles = fri_combiner.perform_fri_assuming_bitreversed( + &final_aggregate.as_ref(), + prng, + &worker + )?; + + Ok(oracles) + } + + + pub(crate) fn fifth_step_from_fourth_step>( + &self, + fourth_state: FourthPartialProverState, + fourth_verifier_message: FourthVerifierMessage, + setup: &SetupMultioracle, + prng: &mut P, + worker: &Worker + ) -> Result, SynthesisError> + { + let FourthVerifierMessage { z, v, .. } = fourth_verifier_message; + let required_domain_size = fourth_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + // now we need to sort polynomials and gates by + // - first filter setup polynomials + // - each setup is opened separately at reference point and required point + // - then filter witness polys + // - open them at every required point + + println!("Start making setup opening requests"); + + let mut setup_opening_requests = vec![]; + + // TODO: do better + + { + let mut setup_values = vec![]; + let mut setup_poly_refs = vec![]; + + for (i, _) in setup.setup_ids.iter().enumerate() { + setup_values.push(setup.setup_poly_values[i]); + setup_poly_refs.push(&setup.polynomial_ldes[i]); + } + + let range_of_permutation_polys = setup.permutations_ranges[0].clone(); + + for (value, perm_ref) in setup.setup_poly_values[range_of_permutation_polys.clone()].iter() + .zip(setup.polynomial_ldes[range_of_permutation_polys].iter()) + { + setup_values.push(*value); + setup_poly_refs.push(perm_ref); + } + + for selector_poly_idx in setup.gate_selectors_indexes.iter() { + let poly_ref = &setup.polynomial_ldes[*selector_poly_idx]; + let value = setup.setup_poly_values[*selector_poly_idx]; + + setup_values.push(value); + setup_poly_refs.push(poly_ref); + } + + let mut opening_values = vec![]; + opening_values.extend_from_slice(&fourth_state.setup_values_at_z[..]); + opening_values.extend_from_slice(&fourth_state.permutation_polynomials_at_z[..]); + opening_values.extend_from_slice(&fourth_state.gate_selector_polynomials_at_z[..]); + + assert_eq!(setup_values.len(), opening_values.len(), "number of setup values is not equal to number of opening values"); + + let request = SetupOpeningRequest { + polynomials: setup_poly_refs, + setup_point: setup.setup_point, + setup_values: setup_values, + opening_point: z, + opening_values: opening_values + }; + + setup_opening_requests.push(request); + } + + println!("Start making witness opening assignments"); + + let mut witness_opening_requests = vec![]; + + let opening_points = vec![z, z_by_omega]; + let storages = vec![&fourth_state.wire_values_at_z, &fourth_state.wire_values_at_z_omega]; + + for dilation in 0usize..=1usize { + let mut per_dilation_set = vec![]; + for gate in self.sorted_gates.iter() { + for constraint in gate.get_constraints().iter() { + for term in constraint.0.iter() { + for poly in term.1.iter() { + match poly { + PolynomialInConstraint::VariablesPolynomial( + poly_num, TimeDilation(dil) + ) => { + if dil == &dilation { + if !per_dilation_set.contains(poly_num) { + per_dilation_set.push(*poly_num) + } + } + }, + _ => {} + } + } + } + } + } + + let mut opening_values = vec![]; + let mut opening_refs = vec![]; + let open_at = opening_points[dilation]; + let storage = storages[dilation]; + for id in per_dilation_set.into_iter() { + let poly_ref = &fourth_state.witness_polys_ldes[id]; + + let mut tmp: Vec<_> = storage.iter().filter( + |el| el.0 == id + ).collect(); + + assert_eq!(tmp.len(), 1); + let value = tmp.pop().unwrap().1; + + opening_values.push(value); + opening_refs.push(poly_ref); + } + + if dilation == 0 { + opening_values.push(fourth_state.grand_product_at_z); + opening_refs.push(&fourth_state.grand_product_polynomial_lde[0]); + } else if dilation == 1 { + opening_values.push(fourth_state.grand_product_at_z_omega); + opening_refs.push(&fourth_state.grand_product_polynomial_lde[0]); + } + + let request = WitnessOpeningRequest { + polynomials: opening_refs, + opening_point: open_at, + opening_values: opening_values + }; + + witness_opening_requests.push(request); + } + + let fri_oracles_set = self.perform_fri( + v, + witness_opening_requests, + setup_opening_requests, + &worker, + prng + )?; + + let commitments = fri_oracles_set.intermediate_roots.clone(); + let coeffs = fri_oracles_set.final_coefficients.clone(); + + let message = FifthProverMessage { + fri_intermediate_roots: commitments, + final_coefficients: coeffs, + }; + + let num_queries = 32; + + use super::multioracle::Multioracle; + + { + let idx_start = 0; + let indexes: Vec = (idx_start..(idx_start+FRI_VALUES_PER_LEAF)).collect(); + + let setup_tree_params = setup.tree.params.clone(); + let witness_tree_params = fourth_state.witness_multioracle_tree.params.clone(); + let grand_product_tree_params = fourth_state.grand_product_polynomial_multioracle_tree.params.clone(); + let t_poly_tree_params = fourth_state.t_poly_parts_multioracle_tree.params.clone(); + let mut fri_subtrees_params = vec![]; + for s in fri_oracles_set.intermediate_oracles.iter() { + fri_subtrees_params.push(s.params.clone()); + } + + let setup_query = setup.tree.produce_multiquery( + indexes.clone(), + setup.polynomial_ldes.len(), + &Multioracle::::combine_leafs( + &setup.polynomial_ldes, + FRI_VALUES_PER_LEAF, + &worker, + ) + ); + + let witness_query = fourth_state.witness_multioracle_tree.produce_multiquery( + indexes.clone(), + fourth_state.witness_polys_ldes.len(), + &Multioracle::::combine_leafs( + &fourth_state.witness_polys_ldes, + FRI_VALUES_PER_LEAF, + &worker, + ) + ); + + let grand_product_query = fourth_state.grand_product_polynomial_multioracle_tree.produce_multiquery( + indexes.clone(), + fourth_state.grand_product_polynomial_lde.len(), + &Multioracle::::combine_leafs( + &fourth_state.grand_product_polynomial_lde, + FRI_VALUES_PER_LEAF, + &worker, + ) + ); + + let quotient_query = fourth_state.t_poly_parts_multioracle_tree.produce_multiquery( + indexes.clone(), + fourth_state.t_poly_parts_ldes.len(), + &Multioracle::::combine_leafs( + &fourth_state.t_poly_parts_ldes, + FRI_VALUES_PER_LEAF, + &worker, + ) + ); + + let mut fri_queries = vec![]; + for ((vals, tree), params) in fri_oracles_set.intermediate_leaf_values.iter() + .zip(fri_oracles_set.intermediate_oracles.iter()) + .zip(fri_subtrees_params.iter()) + { + + let idx_start = 0; + let indexes: Vec = (idx_start..(idx_start + params.values_per_leaf)).collect(); + + let query = tree.produce_query( + indexes, + &vals + ); + + fri_queries.push(query); + } + + use std::sync::atomic::{AtomicUsize, Ordering}; + + let value = super::tree_hash::COUNTER.load(Ordering::SeqCst); + super::tree_hash::COUNTER.fetch_sub(value, Ordering::SeqCst); + + let hasher = setup.tree.tree_hasher.clone(); + + let _ = BinaryTree::verify_multiquery( + &setup.tree.get_commitment(), + &setup_query, + &setup_tree_params, + &hasher + ); + + let _ = BinaryTree::verify_multiquery( + &setup.tree.get_commitment(), + &witness_query, + &witness_tree_params, + &hasher + ); + + let _ = BinaryTree::verify_multiquery( + &setup.tree.get_commitment(), + &grand_product_query, + &grand_product_tree_params, + &hasher + ); + + + let _ = BinaryTree::verify_multiquery( + &setup.tree.get_commitment(), + "ient_query, + &t_poly_tree_params, + &hasher + ); + + for (query, params) in fri_queries.into_iter() + .zip(fri_subtrees_params.iter()) { + let _ = BinaryTree::verify_query( + &setup.tree.get_commitment(), + &query, + ¶ms, + &hasher + ); + } + + let value = super::tree_hash::COUNTER.load(Ordering::SeqCst); + + println!("Single query taken {} hashes", value); + } + + Ok(message) + } +} diff --git a/src/plonk/better_better_cs/redshift/setup.rs b/src/plonk/better_better_cs/redshift/setup.rs new file mode 100644 index 000000000..b86ac7705 --- /dev/null +++ b/src/plonk/better_better_cs/redshift/setup.rs @@ -0,0 +1,131 @@ +use crate::pairing::{Engine}; +use crate::pairing::ff::{Field, PrimeField, PrimeFieldRepr}; +use crate::worker::Worker; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::*; +use super::tree_hash::*; +use super::binary_tree::{BinaryTree, BinaryTreeParams}; +use crate::plonk::polynomials::*; +use super::multioracle::Multioracle; +use super::super::cs_old::*; +use crate::SynthesisError; + +pub struct SetupMultioracle> { + pub polynomials_in_monomial_form: Vec>, + pub setup_poly_values: Vec, + pub setup_point: E::Fr, + pub polynomial_ldes: Vec>, + pub setup_ids: Vec, + pub permutations_ranges: Vec>, + pub gate_selectors_indexes: Vec, + pub tree: BinaryTree +} + +pub const LDE_FACTOR: usize = 16; +pub const FRI_VALUES_PER_LEAF: usize = 8; + +impl> SetupMultioracle { + pub fn from_assembly, MG: MainGateEquation>( + assembly: TrivialAssembly, + tree_hasher: H, + worker: &Worker + ) -> Result<(Self, Vec>), SynthesisError> { + use crate::plonk::fft::cooley_tukey_ntt::*; + + let size = assembly.n().next_power_of_two(); + + println!("Using LDE to size {}", size * LDE_FACTOR); + + let (mut storage, permutations) = assembly.perform_setup(&worker)?; + let gate_selectors = assembly.output_gate_selectors(&worker)?; + let ids = assembly.sorted_setup_polynomial_ids.clone(); + drop(assembly); + + let mut setup_polys = vec![]; + + let mut mononial_forms = vec![]; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + for id in ids.iter() { + let mut setup_poly = storage.remove(&id).expect(&format!("must contain a poly for id {:?}", id)); + setup_poly.pad_to_domain()?; + let coeffs = setup_poly.ifft_using_bitreversed_ntt(&worker, &omegas_inv_bitreversed, &E::Fr::one())?; + mononial_forms.push(coeffs.clone()); + let lde = coeffs.bitreversed_lde_using_bitreversed_ntt(&worker, LDE_FACTOR, &omegas_bitreversed, &E::Fr::multiplicative_generator())?; + + setup_polys.push(lde); + } + + println!("Setup LDEs completed"); + + let mut permutations_ranges = vec![]; + let before = setup_polys.len(); + + for mut p in permutations.iter().cloned() { + p.pad_to_domain()?; + let coeffs = p.ifft_using_bitreversed_ntt(&worker, &omegas_inv_bitreversed, &E::Fr::one())?; + mononial_forms.push(coeffs.clone()); + let lde = coeffs.bitreversed_lde_using_bitreversed_ntt(&worker, LDE_FACTOR, &omegas_bitreversed, &E::Fr::multiplicative_generator())?; + + setup_polys.push(lde); + } + + let after = setup_polys.len(); + + permutations_ranges.push(before..after); + + println!("Permutations LDEs completed"); + + let mut gate_selectors_indexes = vec![]; + + for mut selector in gate_selectors.into_iter() { + let before = setup_polys.len(); + gate_selectors_indexes.push(before); + + selector.pad_to_domain()?; + let coeffs = selector.ifft_using_bitreversed_ntt(&worker, &omegas_inv_bitreversed, &E::Fr::one())?; + mononial_forms.push(coeffs.clone()); + let lde = coeffs.bitreversed_lde_using_bitreversed_ntt(&worker, LDE_FACTOR, &omegas_bitreversed, &E::Fr::multiplicative_generator())?; + + setup_polys.push(lde); + } + + println!("Num gate selectors: {}", gate_selectors_indexes.len()); + + println!("Gate selectors LDEs completed"); + + let multioracle = Multioracle::::new_from_polynomials( + &setup_polys, + tree_hasher, + FRI_VALUES_PER_LEAF, + &worker + ); + + let tree = multioracle.tree; + + let setup_point = E::Fr::from_str("1234567890").unwrap(); + + let mut setup_poly_values = vec![]; + + for p in mononial_forms.iter() { + let value = p.evaluate_at(&worker, setup_point); + setup_poly_values.push(value); + } + + let setup = Self { + polynomials_in_monomial_form: mononial_forms, + setup_poly_values, + setup_point, + polynomial_ldes: setup_polys, + tree, + setup_ids: ids, + permutations_ranges, + gate_selectors_indexes, + }; + + Ok((setup, permutations)) + } +} + diff --git a/src/plonk/better_better_cs/redshift/simple_fri/mod.rs b/src/plonk/better_better_cs/redshift/simple_fri/mod.rs new file mode 100644 index 000000000..111b82fe2 --- /dev/null +++ b/src/plonk/better_better_cs/redshift/simple_fri/mod.rs @@ -0,0 +1,308 @@ +// pub mod fri; +// pub mod query_producer; +// pub mod verifier; +// pub mod precomputation; + +use crate::SynthesisError; +use crate::worker::Worker; +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::Engine; +use crate::plonk::commitments::transcript::*; + +use crate::plonk::better_better_cs::redshift::binary_tree::*; +use crate::plonk::better_better_cs::redshift::tree_hash::*; +use crate::plonk::polynomials::*; +use crate::plonk::commitments::transcript::Prng; +use crate::plonk::fft::cooley_tukey_ntt::*; + +pub struct FriCombiner> { + precomputations: OmegasInvBitreversed, + fri_domain_size: usize, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + folding_schedule: Vec, + tree_hasher: H, + optimal_values_per_leaf: usize, + coset_factor: E::Fr, +} + +pub struct FriOraclesSet> { + pub intermediate_oracles: Vec>, + pub intermediate_roots: Vec, + pub intermediate_leaf_values: Vec>, + pub intermediate_challenges: Vec>, + pub final_coefficients: Vec +} + +impl> FriCombiner { + pub fn initialize_for_domain_size( + size: usize, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + coset_factor: E::Fr, + optimal_values_per_leaf: usize, + hasher: H + ) -> Self { + assert!(output_coeffs_at_degree_plus_one.is_power_of_two()); + assert!(lde_factor.is_power_of_two()); + + let precomputations = OmegasInvBitreversed::new_for_domain_size(size); + let mut schedule = vec![]; + + let folding_factor = size / lde_factor / output_coeffs_at_degree_plus_one; + + assert!(folding_factor.is_power_of_two()); + + let mut size_left = log2_floor(folding_factor) as usize; + + let base = log2_floor(optimal_values_per_leaf) as usize; + + while size_left >= base { + size_left -= base; + schedule.push(base); + } + + if size_left != 0 { + schedule.push(size_left) + } + + Self { + precomputations, + fri_domain_size: size, + lde_factor, + output_coeffs_at_degree_plus_one, + folding_schedule: schedule, + tree_hasher: hasher, + optimal_values_per_leaf, + coset_factor + } + } + + pub fn perform_fri_assuming_bitreversed>( + &self, + lde_values: &[E::Fr], + prng: &mut P, + worker: &Worker, + ) -> Result, SynthesisError> { + let mut coset_schedule_index = 0; + let coset_factor = self.folding_schedule[coset_schedule_index]; + + let mut total_wrap_factor = 1; + for s in self.folding_schedule.iter() { + let coeff = 1 << *s; + total_wrap_factor *= coeff; + } + + let initial_domain_size = lde_values.len(); + + assert_eq!(self.precomputations.domain_size(), initial_domain_size); + + let mut two = E::Fr::one(); + two.double(); + let two_inv = two.inverse().expect("should exist"); + + let initial_degree_plus_one = initial_domain_size / self.lde_factor; + assert_eq!(initial_degree_plus_one / total_wrap_factor, self.output_coeffs_at_degree_plus_one, + "number of FRI round does not match the ouput degree: initial degree+1 = {}, wrapping factor {}, output at degree+1 = {}", + initial_degree_plus_one, total_wrap_factor, self.output_coeffs_at_degree_plus_one); + + let mut intermediate_oracles = vec![]; + let mut intermediate_values = vec![]; + let mut intermediate_roots = vec![]; + + let mut challenges = vec![]; + let num_challenges = coset_factor; + let mut next_domain_challenges = { + let mut challenges = vec![]; + for _ in 0..num_challenges { + challenges.push(prng.get_challenge()); + } + + challenges + }; + + challenges.push(next_domain_challenges.clone()); + + let mut values_slice = lde_values.as_ref(); + + let omegas_inv_bitreversed: &[E::Fr] = self.precomputations.bit_reversed_omegas(); + + // if we would precompute all N we would have + // [0, N/2, N/4, 3N/4, N/8, N/2 + N/8, N/8 + N/4, N/8 + N/4 + N/2, ...] + // but we only precompute half of them and have + // [0, N/4, N/8, N/8 + N/4, ...] + + let mut this_domain_size = lde_values.len(); + + // step 0: fold totally by 2 + // step 1: fold totally by 4 + // etc... + + let num_steps = self.folding_schedule.len(); + + // we do NOT need to make the first (largest) tree cause it's values are simulated + // so we will cover the first step later on separately + for (fri_step, coset_factor) in self.folding_schedule.iter().enumerate() { + let coset_factor = *coset_factor; + let wrapping_factor = 1 << coset_factor; + let next_domain_size = this_domain_size / wrapping_factor; + let mut next_values = vec![E::Fr::zero(); next_domain_size]; + + // we combine like this with FRI trees being aware of the FRI computations + // next_value(omega**) + // / \ + // intermediate(omega*) intermediate(-omega*) + // / \ / \ + // this(omega) this(-omega) this(omega') this(-omega') + // + // so omega* = omega^2i. omega' = sqrt(-omega^2i) = sqrt(omega^(N/2 + 2i)) = omega^N/4 + i + // + // we expect values to come bitreversed, so this(omega) and this(-omega) are always adjustent to each other + // because in normal emumeration it would be elements b0XYZ and b1XYZ, and now it's bZYX0 and bZYX1 + // + // this(omega^(N/4 + i)) for b00YZ has a form b01YZ, so bitreversed it's bZY00 and bZY10 + // this(-omega^(N/4 + i)) obviously has bZY11, so they are all near in initial values + + worker.scope(next_values.len(), |scope, chunk| { + for (i, v) in next_values.chunks_mut(chunk).enumerate() { + let next_domain_challenges = next_domain_challenges.clone(); + scope.spawn(move |_| { + let initial_k = i*chunk; + let mut this_level_values = Vec::with_capacity(wrapping_factor); + let mut next_level_values = vec![E::Fr::zero(); wrapping_factor]; + for (j, v) in v.iter_mut().enumerate() { + let batch_id = initial_k + j; + let values_offset = batch_id*wrapping_factor; + for (wrapping_step, challenge) in next_domain_challenges.iter().enumerate() { + let base_omega_idx = (batch_id * wrapping_factor) >> (1 + wrapping_step); + let expected_this_level_values = wrapping_factor >> wrapping_step; + let expected_next_level_values = wrapping_factor >> (wrapping_step + 1); + let inputs = if wrapping_step == 0 { + &values_slice[values_offset..(values_offset + wrapping_factor)] + } else { + &this_level_values[..expected_this_level_values] + }; + + // imagine first FRI step, first wrapping step + // in values we have f(i), f(i + N/2), f(i + N/4), f(i + N/4 + N/2), f(i + N/8), ... + // so we need to use omega(i) for the first pair, omega(i + N/4) for the second, omega(i + N/8) + // on the next step we would have f'(2i), f'(2i + N/2), f'(2i + N/4), f'(2i + N/4 + N/2) + // so we would have to pick omega(2i) and omega(2i + N/4) + // this means LSB is always the same an only depend on the pair_idx below + // MSB is more tricky + // for a batch number 0 we have i = 0 + // for a batch number 1 due to bitreverse we have index equal to b000001xxx where LSB are not important in the batch + // such value actually gives i = bxxx100000 that is a bitreverse of the batch number with proper number of bits + // due to precomputed omegas also being bitreversed we just need a memory location b000001xxx >> 1 + + debug_assert_eq!(inputs.len() / 2, expected_next_level_values); + + for (pair_idx, (pair, o)) in inputs.chunks(2).zip(next_level_values[..expected_next_level_values].iter_mut()).enumerate() { + debug_assert!(base_omega_idx & pair_idx == 0); + let omega_idx = base_omega_idx + pair_idx; + let omega_inv = omegas_inv_bitreversed[omega_idx]; + let f_at_omega = pair[0]; + let f_at_minus_omega = pair[1]; + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&omega_inv); + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + *o = tmp; + } + + this_level_values.clear(); + this_level_values.clone_from(&next_level_values); + } + + *v = next_level_values[0]; + } + }); + } + }); + + // until we hit the last step we take newly produced values + // and make an oracle from them + if fri_step < num_steps - 1 { + coset_schedule_index += 1; + this_domain_size = next_domain_size; + let coset_factor = self.folding_schedule[coset_schedule_index]; + + let tree_params = BinaryTreeParams { + values_per_leaf: (1 << coset_factor) + }; + + let intermediate_oracle = BinaryTree::create( + &next_values, + self.tree_hasher.clone(), + &tree_params + ); + + let root = intermediate_oracle.get_commitment(); + let num_challenges = coset_factor; + next_domain_challenges = { + prng.commit_input(&root); + let mut challenges = vec![]; + for _ in 0..num_challenges { + challenges.push(prng.get_challenge()); + } + + challenges + }; + + challenges.push(next_domain_challenges.clone()); + intermediate_roots.push(root); + intermediate_oracles.push(intermediate_oracle); + } + + intermediate_values.push(next_values); + + values_slice = intermediate_values.last().expect("is something").as_ref(); + } + + assert_eq!(challenges.len(), num_steps); + assert_eq!(intermediate_roots.len(), num_steps-1); + assert_eq!(intermediate_oracles.len(), num_steps-1); + assert_eq!(intermediate_values.len(), num_steps); + + let mut final_poly_values = Polynomial::from_values(values_slice.to_vec())?; + final_poly_values.bitreverse_enumeration(&worker); + let final_poly_coeffs = if self.coset_factor == E::Fr::one() { + final_poly_values.icoset_fft(&worker) + } else { + final_poly_values.icoset_fft_for_generator(&worker, &self.coset_factor) + }; + + let mut final_poly_coeffs = final_poly_coeffs.into_coeffs(); + + let mut degree = final_poly_coeffs.len() - 1; + for c in final_poly_coeffs.iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break + } + } + + assert!(degree < self.output_coeffs_at_degree_plus_one, "polynomial degree is too large, coeffs = {:?}", final_poly_coeffs); + + final_poly_coeffs.truncate(self.output_coeffs_at_degree_plus_one); + + let set = FriOraclesSet { + intermediate_oracles, + intermediate_roots, + intermediate_leaf_values: intermediate_values, + intermediate_challenges: challenges, + final_coefficients: final_poly_coeffs + }; + + Ok(set) + } +} diff --git a/src/plonk/better_better_cs/redshift/simple_fri/verifier.rs b/src/plonk/better_better_cs/redshift/simple_fri/verifier.rs new file mode 100644 index 000000000..3c8deaf11 --- /dev/null +++ b/src/plonk/better_better_cs/redshift/simple_fri/verifier.rs @@ -0,0 +1,318 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::fri::*; +use super::super::*; + +impl CosetCombiningFriIop { + pub fn verify_prototype( + proof: & FRIProofPrototype>>, + leaf_values: & Polynomial, + natural_element_index: usize + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + // start from the bottom: we need to get a "pair" and calculate FRI step + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + + let mut omega = domain.generator; + let mut omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + debug_assert_eq!(F::one(), omega_inv.pow([domain.size])); + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + + for (iop_values, iop_challenge) in Some(leaf_values).into_iter().chain(&proof.intermediate_values) + .zip(proof.challenges.iter()) { + + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + assert!(coset_values.len() == 2); + assert!(coset_values[0] < coset_values[1]); + + let f_at_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[0]); + + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + return Ok(false); + } + + let supplied_value = *I::get_for_natural_index(iop_values.as_ref(), domain_idx); + // check consistency + if supplied_value != value { + return Ok(false); + } + } + + let f_at_minus_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[1]); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = *f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = *f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + // debug_assert!(domain_idx < domain_size / 2); + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + Ok(valid) + } + + // pub fn verify_proof_queries >::TreeHasher as IopTreeHasher >::HashOutput> >( + // proof: &FRIProof, + // natural_element_indexes: Vec, + // degree: usize, + // expected_value_from_oracle: F, + // prng: &mut P + // ) -> Result { + + // } + + pub fn verify_proof_queries( + proof: &FRIProof, + natural_element_indexes: Vec, + degree: usize, + expected_values_from_oracle: &[F], + fri_challenges: &[F] + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let omega = domain.generator; + let omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + assert!(fri_challenges.len() == proof.roots.len()); + + assert!(natural_element_indexes.len() == proof.queries.len()); + + for ((query, natural_element_index), expected_value_from_oracle) in proof.queries.iter() + .zip(natural_element_indexes.into_iter()) + .zip(expected_values_from_oracle.iter()) + { + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + // let next_domain_size = domain.size / 2; + // let el = domain_element.pow([next_domain_size]); + // if el == F::one() { + // return Err(SynthesisError::UnexpectedIdentity); + // } + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + let mut omega = omega; + let mut omega_inv = omega_inv; + + if query.len() % degree != 0 { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for (round, ((root, queries), iop_challenge)) in proof.roots.iter() + .zip(query.chunks_exact(degree)) + .zip(fri_challenges.iter()) + .enumerate() + { + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + if coset_values.len() != >::COSET_SIZE { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for q in queries.iter() { + if !coset_values.contains(&q.natural_index()) { + println!("Coset values do not contain query index {}", q.natural_index()); + return Ok(false); + } + } + + if round == 0 { + for q in queries.iter() { + if q.natural_index() == natural_element_index && q.value() != *expected_value_from_oracle { + println!("Expected {}, got {} from query", expected_value_from_oracle, q.value()); + return Ok(false); + } + } + } + + for (c, q) in coset_values.iter().zip(queries.iter()) { + let tree_index = >::natural_index_into_tree_index(*c); + if q.tree_index() != tree_index { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + assert!(q.natural_index() == *c, "coset values and produced queries are expected to be sorted!"); + } + + for q in queries.iter() { + if !I::verify_query(&q, &root) { + println!("Query is not in the root"); + return Ok(false); + } + } + + let f_at_omega = (&queries[0]).value(); + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + println!("Coset values {:?} do not containt required index {}", coset_values, domain_idx); + return Ok(false); + } + + let q: Vec<_> = queries.iter().filter(|el| el.natural_index() == domain_idx).collect(); + if q.len() != 1 { + println!("Queries containt duplicate opening for required index {}", domain_idx); + return Ok(false) + } + + let supplied_value = q[0].value(); + // check in the next domain + if supplied_value != value { + println!("Query value {} is not equal to the expected value {} for round {}", supplied_value, value, round); + return Ok(false); + } + } + + let f_at_minus_omega = (&queries[1]).value(); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + if !valid { + println!("Value from supplied coefficients {} is not equal to the value from queries {} for natural index {}", expected_value_from_coefficients, expected_value, natural_element_index); + println!("Final coefficients = {:?}", proof.final_coefficients); + return Ok(false); + } + } + + Ok(true) + } +} diff --git a/src/plonk/better_better_cs/setup/mod.rs b/src/plonk/better_better_cs/setup/mod.rs new file mode 100644 index 000000000..34506bddc --- /dev/null +++ b/src/plonk/better_better_cs/setup/mod.rs @@ -0,0 +1,345 @@ +use super::cs::*; +use super::data_structures::*; +use crate::pairing::ff::*; +use crate::pairing::*; +use crate::plonk::polynomials::*; +use std::collections::HashMap; + +use crate::plonk::domains::*; +use crate::worker::Worker; +use crate::SynthesisError; + +use crate::kate_commitment::*; + +use super::super::better_cs::utils::make_non_residues; + +use crate::byteorder::BigEndian; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use std::io::{Read, Write}; + +use crate::plonk::better_cs::keys::*; + +#[derive(Clone, PartialEq, Eq)] +pub struct Setup> { + pub n: usize, + pub num_inputs: usize, + pub state_width: usize, + pub num_witness_polys: usize, + + pub gate_setup_monomials: Vec>, + pub gate_selectors_monomials: Vec>, + pub permutation_monomials: Vec>, + + pub total_lookup_entries_length: usize, + pub lookup_selector_monomial: Option>, + pub lookup_tables_monomials: Vec>, + pub lookup_table_type_monomial: Option>, + + pub non_residues: Vec, + + _marker: std::marker::PhantomData +} + +impl> std::fmt::Debug for Setup { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Setup") + .field("n", &self.n) + .field("num_inputs", &self.num_inputs) + .field("gate_setup_monomials", &self.gate_setup_monomials) + .field("gate_selectors_monomials", &self.gate_selectors_monomials) + .field("permutation_monomials", &self.permutation_monomials) + .field("total_lookup_entries_length", &self.total_lookup_entries_length) + .field("lookup_selector_monomial", &self.lookup_selector_monomial) + .field("lookup_tables_monomials", &self.lookup_tables_monomials) + .field("lookup_table_type_monomial", &self.lookup_table_type_monomial) + .finish() + } +} + +impl> Setup { + pub fn empty() -> Self { + Self { + n: 0, + num_inputs: 0, + state_width: 0, + num_witness_polys: 0, + gate_setup_monomials: vec![], + gate_selectors_monomials: vec![], + permutation_monomials: vec![], + + total_lookup_entries_length: 0, + lookup_selector_monomial: None, + lookup_tables_monomials: vec![], + lookup_table_type_monomial: None, + non_residues: vec![], + + _marker: std::marker::PhantomData + } + } + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(self.n as u64)?; + writer.write_u64::(self.num_inputs as u64)?; + writer.write_u64::(self.state_width as u64)?; + writer.write_u64::(self.num_witness_polys as u64)?; + + write_polynomials_vec(&self.gate_setup_monomials, &mut writer)?; + write_polynomials_vec(&self.gate_selectors_monomials, &mut writer)?; + write_polynomials_vec(&self.permutation_monomials, &mut writer)?; + + writer.write_u64::(self.total_lookup_entries_length as u64)?; + write_optional_polynomial(&self.lookup_selector_monomial, &mut writer)?; + write_polynomials_vec(&self.lookup_tables_monomials, &mut writer)?; + write_optional_polynomial(&self.lookup_table_type_monomial, &mut writer)?; + + write_fr_vec(&self.non_residues, &mut writer)?; + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + use crate::pairing::CurveAffine; + use crate::pairing::EncodedPoint; + + let n = reader.read_u64::()?; + let num_inputs = reader.read_u64::()?; + let state_width = reader.read_u64::()?; + let num_witness_polys = reader.read_u64::()?; + + let gate_setup_monomials = read_polynomials_coeffs_vec(&mut reader)?; + let gate_selectors_monomials = read_polynomials_coeffs_vec(&mut reader)?; + let permutation_monomials = read_polynomials_coeffs_vec(&mut reader)?; + + let total_lookup_entries_length = reader.read_u64::()?; + let lookup_selector_monomial = read_optional_polynomial_coeffs(&mut reader)?; + let lookup_tables_monomials = read_polynomials_coeffs_vec(&mut reader)?; + let lookup_table_type_monomial = read_optional_polynomial_coeffs(&mut reader)?; + + let non_residues = read_fr_vec(&mut reader)?; + + let new = Self { + n: n as usize, + num_inputs: num_inputs as usize, + state_width: state_width as usize, + num_witness_polys: num_witness_polys as usize, + gate_setup_monomials, + gate_selectors_monomials, + permutation_monomials, + total_lookup_entries_length: total_lookup_entries_length as usize, + lookup_selector_monomial, + lookup_tables_monomials, + lookup_table_type_monomial, + non_residues, + + _marker: std::marker::PhantomData, + }; + + Ok(new) + } +} + +#[derive(Clone, PartialEq, Eq)] +pub struct VerificationKey> { + pub n: usize, + pub num_inputs: usize, + pub state_width: usize, + pub num_witness_polys: usize, + + pub gate_setup_commitments: Vec, + pub gate_selectors_commitments: Vec, + pub permutation_commitments: Vec, + + pub total_lookup_entries_length: usize, + pub lookup_selector_commitment: Option, + pub lookup_tables_commitments: Vec, + pub lookup_table_type_commitment: Option, + + pub non_residues: Vec, + pub g2_elements: [E::G2Affine; 2], + + _marker: std::marker::PhantomData +} + +impl> std::fmt::Debug for VerificationKey { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("VerificationKey") + .field("n", &self.n) + .field("num_inputs", &self.num_inputs) + .field("gate_setup_commitments", &self.gate_setup_commitments) + .field("gate_selectors_commitments", &self.gate_selectors_commitments) + .field("permutation_commitments", &self.permutation_commitments) + .field("total_lookup_entries_length", &self.total_lookup_entries_length) + .field("lookup_selector_commitment", &self.lookup_selector_commitment) + .field("lookup_tables_commitments", &self.lookup_tables_commitments) + .field("lookup_table_type_commitment", &self.lookup_table_type_commitment) + .finish() + } +} + +impl> VerificationKey { + pub fn from_setup( + setup: &Setup, + worker: &Worker, + crs: &Crs, + ) -> Result { + let mut new = Self { + n: setup.n, + num_inputs: setup.num_inputs, + state_width: setup.state_width, + num_witness_polys: setup.num_witness_polys, + gate_setup_commitments: vec![], + gate_selectors_commitments: vec![], + permutation_commitments: vec![], + + total_lookup_entries_length: setup.total_lookup_entries_length, + lookup_selector_commitment: None, + lookup_tables_commitments: vec![], + lookup_table_type_commitment: None, + + non_residues: vec![], + g2_elements: [crs.g2_monomial_bases[0], crs.g2_monomial_bases[1]], + + _marker: std::marker::PhantomData, + }; + + for (p, c) in vec![ + (&setup.gate_setup_monomials, &mut new.gate_setup_commitments), + (&setup.gate_selectors_monomials, &mut new.gate_selectors_commitments), + (&setup.permutation_monomials, &mut new.permutation_commitments), + (&setup.lookup_tables_monomials, &mut new.lookup_tables_commitments), + ].into_iter() { + for p in p.iter() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + c.push(commitment); + } + } + + if let Some(p) = setup.lookup_selector_monomial.as_ref() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + new.lookup_selector_commitment = Some(commitment); + } + + if let Some(p) = setup.lookup_table_type_monomial.as_ref() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + new.lookup_table_type_commitment = Some(commitment); + } + + new.non_residues = setup.non_residues.clone(); + + // new.non_residues + // .extend(make_non_residues::(state_width - 1)); + + Ok(new) + } + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(self.n as u64)?; + writer.write_u64::(self.num_inputs as u64)?; + writer.write_u64::(self.state_width as u64)?; + writer.write_u64::(self.num_witness_polys as u64)?; + + write_curve_affine_vec(&self.gate_setup_commitments, &mut writer)?; + write_curve_affine_vec(&self.gate_selectors_commitments, &mut writer)?; + write_curve_affine_vec(&self.permutation_commitments, &mut writer)?; + + writer.write_u64::(self.total_lookup_entries_length as u64)?; + write_optional_curve_affine(&self.lookup_selector_commitment, &mut writer)?; + write_curve_affine_vec(&self.lookup_tables_commitments, &mut writer)?; + write_optional_curve_affine(&self.lookup_table_type_commitment, &mut writer)?; + + write_fr_vec(&self.non_residues, &mut writer)?; + + write_curve_affine(&self.g2_elements[0], &mut writer)?; + write_curve_affine(&self.g2_elements[1], &mut writer)?; + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + use crate::pairing::CurveAffine; + use crate::pairing::EncodedPoint; + + let n = reader.read_u64::()?; + let num_inputs = reader.read_u64::()?; + let state_width = reader.read_u64::()?; + let num_witness_polys = reader.read_u64::()?; + + let gate_setup_commitments = read_curve_affine_vector(&mut reader)?; + let gate_selectors_commitments = read_curve_affine_vector(&mut reader)?; + let permutation_commitments = read_curve_affine_vector(&mut reader)?; + + let total_lookup_entries_length = reader.read_u64::()?; + let lookup_selector_commitment = read_optional_curve_affine(&mut reader)?; + let lookup_tables_commitments = read_curve_affine_vector(&mut reader)?; + let lookup_table_type_commitment = read_optional_curve_affine(&mut reader)?; + + let non_residues = read_fr_vec(&mut reader)?; + + let h = read_curve_affine(&mut reader)?; + let h_x = read_curve_affine(&mut reader)?; + + let new = Self { + n: n as usize, + num_inputs: num_inputs as usize, + state_width: state_width as usize, + num_witness_polys: num_witness_polys as usize, + gate_setup_commitments, + gate_selectors_commitments, + permutation_commitments, + total_lookup_entries_length: total_lookup_entries_length as usize, + lookup_selector_commitment, + lookup_tables_commitments, + lookup_table_type_commitment, + non_residues, + + g2_elements: [h, h_x], + + _marker: std::marker::PhantomData, + }; + + Ok(new) + } +} + +use super::data_structures::AssembledPolynomialStorageForMonomialForms; + +impl<'a, E: Engine> AssembledPolynomialStorageForMonomialForms<'a, E> { + pub fn extend_from_setup>(&mut self, setup: &'a Setup) -> Result<(), SynthesisError> { + // extend with gate setup polys, gate selectors, permutation polys + // and lookup table setup polys if available + let all_gates = C::declare_used_gates()?; + + let has_selectors = all_gates.len() > 1; + + let mut setup_gates_iter = setup.gate_setup_monomials.iter(); + for gate in all_gates.iter() { + for poly_id in gate.setup_polynomials().into_iter() { + let poly_ref = setup_gates_iter.next().expect(&format!("must have gate setup poly {:?} for gate {:?} in setup", poly_id, gate)); + let proxy = PolynomialProxy::from_borrowed(poly_ref); + self.setup_map.insert(poly_id, proxy); + } + } + + assert!(setup_gates_iter.next().is_none()); + + if has_selectors { + let mut selector_iter = setup.gate_selectors_monomials.iter(); + for gate in all_gates.into_iter() { + let id = PolyIdentifier::GateSelector(gate.name()); + let poly_ref = selector_iter.next().expect(&format!("must have gate selector poly for gate {:?} in setup", gate)); + let proxy = PolynomialProxy::from_borrowed(poly_ref); + self.gate_selectors.insert(id, proxy); + } + assert!(selector_iter.next().is_none()); + } + + for (idx, poly_ref) in setup.permutation_monomials.iter().enumerate() { + let id = PolyIdentifier::PermutationPolynomial(idx); + let proxy = PolynomialProxy::from_borrowed(poly_ref); + self.setup_map.insert(id, proxy); + } + + Ok(()) + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/trees/binary_tree.rs b/src/plonk/better_better_cs/trees/binary_tree.rs new file mode 100644 index 000000000..b2efede91 --- /dev/null +++ b/src/plonk/better_better_cs/trees/binary_tree.rs @@ -0,0 +1,470 @@ +use crate::pairing::{Engine}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use crate::worker::Worker; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::*; +use super::tree_hash::*; + +#[derive(Debug)] +pub struct BinaryTree> { + pub (crate) size: usize, + pub (crate) num_leafs: usize, + pub (crate) num_combined: usize, + pub (crate) nodes: Vec, + pub (crate) params: BinaryTreeParams, + pub (crate) tree_hasher: H, + _marker: std::marker::PhantomData +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct BinaryTreeParams { + pub values_per_leaf: usize +} + +use std::time::Instant; + +impl> BinaryTree { + fn hash_into_leaf(tree_hasher: &H, values: &[E::Fr]) -> H::Output { + tree_hasher.leaf_hash(values) + } + + fn make_full_path(&self, leaf_index: usize, leaf_pair_hash: H::Output) -> Vec { + let mut nodes = &self.nodes[..]; + + let mut path = vec![]; + path.push(leaf_pair_hash); + + let mut idx = leaf_index; + idx >>= 1; + + for _ in 0..log2_floor(nodes.len() / 2) { + let half_len = nodes.len() / 2; + let (next_level, this_level) = nodes.split_at(half_len); + let pair_idx = idx ^ 1usize; + let value = this_level[pair_idx]; + path.push(value); + idx >>= 1; + nodes = next_level; + } + + path + } + + pub(crate) fn size(&self) -> usize { + self.size + } + + pub(crate) fn num_leafs(&self) -> usize { + self.num_leafs + } + + pub fn create_from_combined_leafs( + leafs: &[Vec<&[E::Fr]>], + num_combined: usize, + tree_hasher: H, + params: &BinaryTreeParams + ) -> Self { + let values_per_leaf = params.values_per_leaf; + let num_leafs = leafs.len(); + let values_per_leaf_supplied = leafs[0].len() * leafs[0][0].len(); + assert_eq!(num_combined, leafs[0].len(), "invalid number of total combined leafs"); + assert_eq!(values_per_leaf, values_per_leaf_supplied, "values per leaf from params and from data is not consistent"); + assert!(num_leafs.is_power_of_two(), "tree must be binary"); + + let num_nodes = num_leafs; + + let size = num_leafs * values_per_leaf; + + let mut nodes = vec![H::placeholder_output(); num_nodes]; + + let worker = Worker::new(); + + let mut leaf_hashes = vec![H::placeholder_output(); num_leafs]; + + let hasher_ref = &tree_hasher; + + { + worker.scope(leaf_hashes.len(), |scope, chunk| { + for (i, lh) in leaf_hashes.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let mut scratch_space = Vec::with_capacity(values_per_leaf); + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + // idx is index of the leaf + let idx = base_idx + j; + let leaf_values_ref = &leafs[idx]; + for &lv in leaf_values_ref.iter() { + scratch_space.extend_from_slice(lv); + } + debug_assert_eq!(scratch_space.len(), values_per_leaf); + *lh = hasher_ref.leaf_hash(&scratch_space[..]); + scratch_space.truncate(0); + } + }); + } + }); + } + + println!("Leaf hashes completed"); + + // leafs are now encoded and hashed, so let's make a tree + + let num_levels = log2_floor(num_leafs) as usize; + let mut nodes_for_hashing = &mut nodes[..]; + + // separately hash last level, which hashes leaf hashes into first nodes + { + let _level = num_levels-1; + let inputs = &mut leaf_hashes[..]; + let (_, outputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [H::placeholder_output(); 2]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0] = i[0]; + hash_input[1] = i[1]; + *o = hasher_ref.node_hash(&hash_input, _level); + } + }); + } + }); + } + + for _level in (0..(num_levels-1)).rev() { + // do the trick - split + let (next_levels, inputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + let (_, outputs) = next_levels.split_at_mut(next_levels.len() / 2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [H::placeholder_output(); 2]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0] = i[0]; + hash_input[1] = i[1]; + *o = hasher_ref.node_hash(&hash_input, _level); + } + }); + } + }); + + nodes_for_hashing = next_levels; + } + + Self { + size: size, + num_leafs: num_leafs, + nodes: nodes, + num_combined, + tree_hasher: tree_hasher, + params: params.clone(), + _marker: std::marker::PhantomData + } + + } + + pub(crate) fn create(values: &[E::Fr], tree_hasher: H, params: &BinaryTreeParams) -> Self { + assert!(params.values_per_leaf.is_power_of_two()); + + let values_per_leaf = params.values_per_leaf; + let num_leafs = values.len() / values_per_leaf; + assert!(num_leafs.is_power_of_two()); + + let num_nodes = num_leafs; + + // size is a total number of elements + let size = values.len(); + + let mut nodes = vec![H::placeholder_output(); num_nodes]; + + let worker = Worker::new(); + + let mut leaf_hashes = vec![H::placeholder_output(); num_leafs]; + + let hasher_ref = &tree_hasher; + + { + worker.scope(leaf_hashes.len(), |scope, chunk| { + for (i, lh) in leaf_hashes.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let values_start = idx * values_per_leaf; + let values_end = values_start + values_per_leaf; + *lh = hasher_ref.leaf_hash(&values[values_start..values_end]); + } + }); + } + }); + } + + // leafs are now encoded and hashed, so let's make a tree + + let num_levels = log2_floor(num_leafs) as usize; + let mut nodes_for_hashing = &mut nodes[..]; + + // separately hash last level, which hashes leaf hashes into first nodes + { + let _level = num_levels-1; + let inputs = &mut leaf_hashes[..]; + let (_, outputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [H::placeholder_output(); 2]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0] = i[0]; + hash_input[1] = i[1]; + *o = hasher_ref.node_hash(&hash_input, _level); + } + }); + } + }); + } + + for _level in (0..(num_levels-1)).rev() { + // do the trick - split + let (next_levels, inputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + let (_, outputs) = next_levels.split_at_mut(next_levels.len() / 2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [H::placeholder_output(); 2]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0] = i[0]; + hash_input[1] = i[1]; + *o = hasher_ref.node_hash(&hash_input, _level); + } + }); + } + }); + + nodes_for_hashing = next_levels; + } + + Self { + size: size, + nodes: nodes, + num_leafs: num_leafs, + num_combined: 1, + tree_hasher: tree_hasher, + params: params.clone(), + _marker: std::marker::PhantomData + } + } + + pub fn get_commitment(&self) -> H::Output { + self.nodes[1].clone() + } + + pub fn produce_query(&self, indexes: Vec, values: &[E::Fr]) -> Query { + // we never expect that query is mis-alligned, so check it + debug_assert!(indexes[0] % self.params.values_per_leaf == 0); + debug_assert!(indexes.len() == self.params.values_per_leaf); + debug_assert!(indexes == (indexes[0]..(indexes[0]+self.params.values_per_leaf)).collect::>()); + debug_assert!(*indexes.last().expect("is some") < self.size()); + debug_assert!(*indexes.last().expect("is some") < values.len()); + + let query_values = Vec::from(&values[indexes[0]..(indexes[0]+self.params.values_per_leaf)]); + + let leaf_index = indexes[0] / self.params.values_per_leaf; + + let pair_index = leaf_index ^ 1; + + let leaf_pair_hash = self.tree_hasher.leaf_hash(&values[(pair_index*self.params.values_per_leaf)..((pair_index+1)*self.params.values_per_leaf)]); + + let path = self.make_full_path(leaf_index, leaf_pair_hash); + + Query:: { + indexes: indexes, + values: query_values, + path: path, + } + } + + pub fn produce_multiquery( + &self, + indexes: Vec, + num_combined: usize, + leafs: &[Vec<&[E::Fr]>] + ) -> MultiQuery { + // debug_assert!(indexes[0] % self.params.values_per_leaf == 0); + // debug_assert!(indexes.len() == self.params.values_per_leaf); + debug_assert!(indexes == (indexes[0]..(indexes[0]+(self.params.values_per_leaf/self.num_combined))).collect::>()); + debug_assert!(*indexes.last().expect("is some") < self.size()); + debug_assert!(leafs[0].len() == num_combined); + + let leaf_index = indexes[0] / (self.params.values_per_leaf / num_combined); + + let mut query_values = Vec::with_capacity(indexes.len()); + let this_leaf = &leafs[leaf_index]; + + for part in this_leaf.iter() { + query_values.push(part.to_vec()); + } + + let pair_index = leaf_index ^ 1; + + let mut scratch_space = Vec::with_capacity(self.params.values_per_leaf); + + let pair_leaf_combination = &leafs[pair_index]; + + for r in pair_leaf_combination.iter() { + // walk over the polynomials + scratch_space.extend_from_slice(r); + } + + let leaf_pair_hash = self.tree_hasher.leaf_hash(&scratch_space); + + let path = self.make_full_path(leaf_index, leaf_pair_hash); + + MultiQuery:: { + indexes: indexes, + values: query_values, + num_combined, + path: path, + } + } + + pub fn verify_query( + commitment: &H::Output, + query: &Query, + params: &BinaryTreeParams, + tree_hasher: &H + ) -> bool { + if query.values().len() != params.values_per_leaf { + return false; + } + + let mut hash = tree_hasher.leaf_hash(query.values()); + let mut idx = query.indexes()[0] / params.values_per_leaf; + let mut hash_input = [H::placeholder_output(); 2]; + + for el in query.path.iter() { + { + if idx & 1usize == 0 { + hash_input[0] = hash; + hash_input[1] = *el; + } else { + hash_input[0] = *el; + hash_input[1] = hash; + } + } + hash = tree_hasher.node_hash(&hash_input, 0); + idx >>= 1; + } + + &hash == commitment + } + + pub fn verify_multiquery( + commitment: &H::Output, + query: &MultiQuery, + params: &BinaryTreeParams, + tree_hasher: &H + ) -> bool { + let values = query.values_flattened(); + if values.len() != params.values_per_leaf { + return false; + } + + let num_combined = query.num_combined(); + + let mut hash = tree_hasher.leaf_hash(&values); + let mut idx = query.indexes()[0] / (params.values_per_leaf / num_combined); + let mut hash_input = [H::placeholder_output(); 2]; + + for el in query.path.iter() { + { + if idx & 1usize == 0 { + hash_input[0] = hash; + hash_input[1] = *el; + } else { + hash_input[0] = *el; + hash_input[1] = hash; + } + } + hash = tree_hasher.node_hash(&hash_input, 0); + idx >>= 1; + } + + &hash == commitment + } +} + +impl> PartialEq for BinaryTree { + fn eq(&self, other: &Self) -> bool { + self.get_commitment() == other.get_commitment() + } +} + +impl> Eq for BinaryTree {} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Query> { + indexes: Vec, + values: Vec, + path: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct MultiQuery> { + indexes: Vec, + values: Vec>, + num_combined: usize, + path: Vec, +} + +impl> Query { + pub fn indexes(&self) -> Vec { + self.indexes.clone() + } + + pub fn values(&self) -> &[E::Fr] { + &self.values + } + + pub fn path(&self) -> &[H::Output] { + &self.path + } +} + +impl> MultiQuery { + fn indexes(&self) -> Vec { + self.indexes.clone() + } + + fn values_flattened(&self) -> Vec { + let mut concat = Vec::with_capacity(self.values.len() + self.values[0].len()); + for v in self.values.iter() { + concat.extend_from_slice(&v[..]); + } + + concat + } + + fn num_combined(&self) -> usize { + debug_assert_eq!(self.num_combined, self.values.len()); + + self.num_combined + } +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/trees/mod.rs b/src/plonk/better_better_cs/trees/mod.rs new file mode 100644 index 000000000..940ffbba4 --- /dev/null +++ b/src/plonk/better_better_cs/trees/mod.rs @@ -0,0 +1,2 @@ +pub mod tree_hash; +pub mod binary_tree; \ No newline at end of file diff --git a/src/plonk/better_better_cs/trees/tree_hash.rs b/src/plonk/better_better_cs/trees/tree_hash.rs new file mode 100644 index 000000000..d0cc19ba9 --- /dev/null +++ b/src/plonk/better_better_cs/trees/tree_hash.rs @@ -0,0 +1,9 @@ +use crate::pairing::ff::{Field, PrimeField}; + +pub trait BinaryTreeHasher: Sized + Send + Sync + Clone { + type Output: Sized + Clone + Copy + Send + Sync + PartialEq + Eq; + + fn placeholder_output() -> Self::Output; + fn leaf_hash(&self, input: &[F]) -> Self::Output; + fn node_hash(&self, input: &[Self::Output; 2], level: usize) -> Self::Output; +} diff --git a/src/plonk/better_better_cs/utils.rs b/src/plonk/better_better_cs/utils.rs new file mode 100644 index 000000000..202f42397 --- /dev/null +++ b/src/plonk/better_better_cs/utils.rs @@ -0,0 +1,117 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::Worker; +use crate::plonk::domains::*; +use crate::SynthesisError; + +use crate::plonk::polynomials::*; + +pub trait FieldBinop: 'static + Copy + Clone + Send + Sync + std::fmt::Debug { + fn apply(&self, dest: &mut F, source: &F); +} + +pub(crate) fn binop_over_slices>(worker: &Worker, binop: &B, dest: &mut [F], source: &[F]) { + assert_eq!(dest.len(), source.len()); + worker.scope(dest.len(), |scope, chunk| { + for (dest, source) in dest.chunks_mut(chunk) + .zip(source.chunks(chunk)) { + scope.spawn(move |_| { + for (dest, source) in dest.iter_mut().zip(source.iter()) { + binop.apply(dest, source); + } + }); + } + }); +} + +#[derive(Clone, Copy, Debug)] +pub struct BinopAddAssign; + +impl FieldBinop for BinopAddAssign { + #[inline(always)] + fn apply(&self, dest: &mut F, source: &F) { + dest.add_assign(source); + } +} + +#[derive(Clone, Copy, Debug)] +pub struct BinopAddAssignScaled{ + pub scale: F +} + +impl BinopAddAssignScaled { + pub fn new(scale: F) -> Self { + Self { + scale + } + } +} + +impl FieldBinop for BinopAddAssignScaled { + #[inline(always)] + fn apply(&self, dest: &mut F, source: &F) { + let mut tmp = self.scale; + tmp.mul_assign(&source); + + dest.add_assign(&tmp); + } +} + +pub(crate) fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + degree +} + +pub (crate) fn calculate_inverse_vanishing_polynomial_with_last_point_cut( + worker: &Worker, + poly_size:usize, + vahisning_size: usize, + coset_factor: F, +) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64)?; + let n_domain_omega = domain.generator; + let mut root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + root.negate(); + + let mut negative_one = F::one(); + negative_one.negate(); + + let mut numerator = Polynomial::::from_values(vec![coset_factor; poly_size])?; + // evaluate X in linear time + + numerator.distribute_powers(&worker, numerator.omega); + numerator.add_constant(&worker, &root); + + // numerator.add_constant(&worker, &negative_one); + // now it's a series of values in a coset + + // now we should evaluate X^(n+1) - 1 in a linear time + + let shift = coset_factor.pow([vahisning_size as u64]); + + let mut denominator = Polynomial::::from_values(vec![shift; poly_size])?; + + // elements are h^size - 1, (hg)^size - 1, (hg^2)^size - 1, ... + + denominator.distribute_powers(&worker, denominator.omega.pow([vahisning_size as u64])); + denominator.add_constant(&worker, &negative_one); + + denominator.batch_inversion(&worker)?; + + numerator.mul_assign(&worker, &denominator); + + Ok(numerator) +} \ No newline at end of file diff --git a/src/plonk/better_better_cs/verifier/mod.rs b/src/plonk/better_better_cs/verifier/mod.rs new file mode 100644 index 000000000..ab4fee3f1 --- /dev/null +++ b/src/plonk/better_better_cs/verifier/mod.rs @@ -0,0 +1,984 @@ +use crate::pairing::ff::*; +use crate::pairing::*; + +use super::setup::VerificationKey; +use super::proof::{Proof, sort_queries_for_linearization}; +use super::cs::*; +use super::data_structures::*; + +use std::collections::HashMap; + +use crate::plonk::domains::*; +use crate::SynthesisError; + +use crate::plonk::commitments::transcript::*; +use crate::kate_commitment::*; +use crate::plonk::better_cs::utils::*; +use super::lookup_tables::LookupQuery; + +pub const MAX_DILATION: usize = 1; + +pub fn verify, T: Transcript>( + vk: &VerificationKey, + proof: &Proof, + transcript_params: Option, +) -> Result { + let ((pair_with_generator, pair_with_x), success) = aggregate::<_, _, T>(vk, proof, transcript_params)?; + if !success { + return Ok(false) + } + + let valid = E::final_exponentiation( + &E::miller_loop(&[ + (&pair_with_generator.prepare(), &vk.g2_elements[0].prepare()), + (&pair_with_x.prepare(), &vk.g2_elements[1].prepare()) + ]) + ).ok_or(SynthesisError::Unsatisfiable)? == E::Fqk::one(); + + Ok(valid) +} + +fn safe_assert(must_be_true: bool) -> Result<(), SynthesisError> { + if !must_be_true { + return Err(SynthesisError::AssignmentMissing); + } + + Ok(()) +} + +fn safe_assert_eq(a: T, b: T) -> Result<(), SynthesisError> { + safe_assert(a==b) +} + +pub fn aggregate, T: Transcript>( + vk: &VerificationKey, + proof: &Proof, + transcript_params: Option, +) -> Result<((E::G1Affine, E::G1Affine), bool), SynthesisError> { + let mut transcript = if let Some(params) = transcript_params { + T::new_from_params(params) + } else { + T::new() + }; + + let sorted_gates = C::declare_used_gates()?; + let num_different_gates = sorted_gates.len(); + + safe_assert((vk.n+1).is_power_of_two())?; + let required_domain_size = vk.n.next_power_of_two(); + + let domain = Domain::::new_for_size(required_domain_size as u64)?; + + for inp in proof.inputs.iter() { + transcript.commit_field_element(inp); + } + + for idx in 0..vk.state_width { + let commitment = proof.state_polys_commitments.get(idx).ok_or(SynthesisError::AssignmentMissing)?; + commit_point_as_xy::(&mut transcript, commitment); + } + + for idx in 0..vk.num_witness_polys { + let commitment = proof.witness_polys_commitments.get(idx).ok_or(SynthesisError::AssignmentMissing)?; + commit_point_as_xy::(&mut transcript, commitment); + } + + let mut eta = E::Fr::zero(); + if vk.total_lookup_entries_length > 0 { + eta = transcript.get_challenge(); + + let commitment = proof.lookup_s_poly_commitment.as_ref().ok_or(SynthesisError::AssignmentMissing)?; + commit_point_as_xy::(&mut transcript, commitment); + } + + let beta_for_copy_permutation = transcript.get_challenge(); + let gamma_for_copy_permutation = transcript.get_challenge(); + + let commitment = &proof.copy_permutation_grand_product_commitment; + commit_point_as_xy::(&mut transcript, commitment); + + let mut beta_for_lookup = None; + let mut gamma_for_lookup = None; + + if vk.total_lookup_entries_length > 0 { + let beta_for_lookup_permutation = transcript.get_challenge(); + let gamma_for_lookup_permutation = transcript.get_challenge(); + + beta_for_lookup = Some(beta_for_lookup_permutation); + gamma_for_lookup = Some(gamma_for_lookup_permutation); + + let commitment = proof.lookup_grand_product_commitment.as_ref().ok_or(SynthesisError::AssignmentMissing)?; + commit_point_as_xy::(&mut transcript, commitment); + } + + let alpha = transcript.get_challenge(); + + let mut total_powers_of_alpha_for_gates = 0; + for g in sorted_gates.iter() { + total_powers_of_alpha_for_gates += g.num_quotient_terms(); + } + + // println!("Have {} terms from {} gates", total_powers_of_alpha_for_gates, sorted_gates.len()); + + let mut current_alpha = E::Fr::one(); + let mut powers_of_alpha_for_gates = Vec::with_capacity(total_powers_of_alpha_for_gates); + powers_of_alpha_for_gates.push(current_alpha); + for _ in 1..total_powers_of_alpha_for_gates { + current_alpha.mul_assign(&alpha); + powers_of_alpha_for_gates.push(current_alpha); + } + + safe_assert_eq(powers_of_alpha_for_gates.len(), total_powers_of_alpha_for_gates)?; + + let copy_grand_product_alphas; + + { + current_alpha.mul_assign(&alpha); + let alpha_0 = current_alpha; + + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + copy_grand_product_alphas = Some([alpha_0, alpha_1]); + } + + let mut lookup_grand_product_alphas = None; + + if vk.total_lookup_entries_length > 0 { + current_alpha.mul_assign(&alpha); + + let alpha_0 = current_alpha; + + current_alpha.mul_assign(&alpha); + + let alpha_1 = current_alpha; + + current_alpha.mul_assign(&alpha); + + let alpha_2 = current_alpha; + + lookup_grand_product_alphas = Some([alpha_0, alpha_1, alpha_2]); + } + + for commitment in proof.quotient_poly_parts_commitments.iter() { + commit_point_as_xy::(&mut transcript, commitment); + } + + let z = transcript.get_challenge(); + + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + + let quotient_at_z = proof.quotient_poly_opening_at_z; + transcript.commit_field_element("ient_at_z); + + // first reconstruct storage of all the commitments + + let mut setup_commitments_storage = HashMap::new(); + let mut gate_selectors_commitments_storage = HashMap::new(); + { + let mut gate_setup_polys_commitments_iter = vk.gate_setup_commitments.iter(); + let mut gate_selectors_polys_commitments_iter = vk.gate_selectors_commitments.iter(); + + for gate in sorted_gates.iter() { + let key = PolyIdentifier::GateSelector(gate.name()); + let commitment = *gate_selectors_polys_commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + gate_selectors_commitments_storage.insert(key, commitment); + + let setup_polys = gate.setup_polynomials(); + for id in setup_polys.into_iter() { + let commitment = *gate_setup_polys_commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + + setup_commitments_storage.insert(id, commitment); + } + } + + safe_assert(gate_setup_polys_commitments_iter.next().is_none())?; + safe_assert(gate_selectors_polys_commitments_iter.next().is_none())?; + } + + let queries_with_linearization = sort_queries_for_linearization(&sorted_gates, MAX_DILATION); + + let mut query_values_map = std::collections::HashMap::new(); + + let mut state_polys_openings_at_z_iter = proof.state_polys_openings_at_z.iter(); + let mut state_polys_openings_at_dilations_iter = proof.state_polys_openings_at_dilations.iter(); + + let mut all_values_queried_at_z = vec![]; + let mut all_values_queried_at_z_omega = vec![]; + + let mut all_commitments_queried_at_z = vec![]; + let mut all_commitments_queried_at_z_omega = vec![]; + + for (dilation_value, ids) in queries_with_linearization.state_polys.iter().enumerate() { + safe_assert(dilation_value <= MAX_DILATION)?; + for id in ids.into_iter() { + let poly_idx = if let PolyIdentifier::VariablesPolynomial(idx) = id { + idx + } else { + unreachable!(); + }; + + let commitment = *proof.state_polys_commitments.get(*poly_idx).ok_or(SynthesisError::AssignmentMissing)?; + + let value = if dilation_value == 0 { + let value = *state_polys_openings_at_z_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + + all_values_queried_at_z.push(value); + all_commitments_queried_at_z.push(commitment); + + value + } else { + let (dilation, state_poly_idx, value) = *state_polys_openings_at_dilations_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert_eq(dilation, dilation_value)?; + safe_assert_eq(*poly_idx, state_poly_idx)?; + safe_assert(state_poly_idx < vk.state_width)?; + + all_values_queried_at_z_omega.push(value); + all_commitments_queried_at_z_omega.push(commitment); + + value + }; + + transcript.commit_field_element(&value); + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + + safe_assert(state_polys_openings_at_z_iter.next().is_none())?; + safe_assert(state_polys_openings_at_dilations_iter.next().is_none())?; + + let mut witness_polys_openings_at_z_iter = proof.witness_polys_openings_at_z.iter(); + let mut witness_polys_openings_at_dilations_iter = proof.witness_polys_openings_at_dilations.iter(); + + for (dilation_value, ids) in queries_with_linearization.witness_polys.iter().enumerate() { + safe_assert(dilation_value <= MAX_DILATION)?; + for id in ids.into_iter() { + let poly_idx = if let PolyIdentifier::WitnessPolynomial(idx) = id { + idx + } else { + unreachable!(); + }; + + let commitment = *proof.witness_polys_commitments.get(*poly_idx).ok_or(SynthesisError::AssignmentMissing)?; + + let value = if dilation_value == 0 { + let value = *witness_polys_openings_at_z_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + + all_values_queried_at_z.push(value); + all_commitments_queried_at_z.push(commitment); + + value + } else { + let (dilation, witness_poly_idx, value) = *witness_polys_openings_at_dilations_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert_eq(dilation, dilation_value)?; + safe_assert_eq(*poly_idx, witness_poly_idx)?; + safe_assert(witness_poly_idx < vk.num_witness_polys)?; + + all_values_queried_at_z_omega.push(value); + all_commitments_queried_at_z_omega.push(commitment); + + value + }; + + transcript.commit_field_element(&value); + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + + safe_assert(witness_polys_openings_at_z_iter.next().is_none())?; + safe_assert(witness_polys_openings_at_dilations_iter.next().is_none())?; + + let mut gate_setup_openings_at_z_iter = proof.gate_setup_openings_at_z.iter(); + + for (gate_idx, queries) in queries_with_linearization.gate_setup_polys.iter().enumerate() { + for (dilation_value, ids) in queries.iter().enumerate() { + safe_assert(dilation_value <= MAX_DILATION)?; + for id in ids.into_iter() { + let poly_idx = if let PolyIdentifier::GateSetupPolynomial(_, idx) = id { + idx + } else { + unreachable!(); + }; + + let commitment = *setup_commitments_storage.get(&id).ok_or(SynthesisError::AssignmentMissing)?; + + let value = if dilation_value == 0 { + let (gate_index, setup_poly_index, value) = *gate_setup_openings_at_z_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert_eq(gate_idx, gate_index)?; + safe_assert_eq(*poly_idx, setup_poly_index)?; + + all_values_queried_at_z.push(value); + all_commitments_queried_at_z.push(commitment); + + value + } else { + unimplemented!("gate setup polynomials can not be time dilated"); + }; + + transcript.commit_field_element(&value); + + let key = PolynomialInConstraint::from_id_and_dilation(*id, dilation_value); + + query_values_map.insert(key, value); + } + } + } + + safe_assert(gate_setup_openings_at_z_iter.next().is_none())?; + + // also open gate selectors + let mut selector_values_iter = proof.gate_selectors_openings_at_z.iter(); + let mut selector_values = vec![]; + for s in queries_with_linearization.gate_selectors.iter() { + let gate_index = sorted_gates.iter().position(|r| r == s).ok_or(SynthesisError::AssignmentMissing)?; + + let (gate_idx, value) = *selector_values_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert_eq(gate_index, gate_idx)?; + transcript.commit_field_element(&value); + + let key = PolyIdentifier::GateSelector(s.name()); + + // let commitment = *selector_commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + let commitment = *gate_selectors_commitments_storage.get(&key).ok_or(SynthesisError::AssignmentMissing)?; + + selector_values.push(value); + all_values_queried_at_z.push(value); + all_commitments_queried_at_z.push(commitment); + } + + safe_assert(selector_values_iter.next().is_none())?; + + // copy-permutation polynomials queries + + let mut copy_permutation_polys_openings_at_z_iter = proof.copy_permutation_polys_openings_at_z.iter(); + let mut copy_permutation_polys_commitments_iter = vk.permutation_commitments.iter(); + + let mut copy_permutation_queries = vec![]; + + for _ in 0..(vk.state_width-1) { + let value = *copy_permutation_polys_openings_at_z_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + + transcript.commit_field_element(&value); + + copy_permutation_queries.push(value); + all_values_queried_at_z.push(value); + + let commitment = *copy_permutation_polys_commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?; + all_commitments_queried_at_z.push(commitment); + } + + safe_assert(copy_permutation_polys_openings_at_z_iter.next().is_none())?; + + // copy-permutation grand product query + + let mut z_omega = z; + z_omega.mul_assign(&domain.generator); + + // for polys below we will insert queried commitments manually into the corresponding lists + let copy_permutation_z_at_z_omega = proof.copy_permutation_grand_product_opening_at_z_omega; + transcript.commit_field_element(©_permutation_z_at_z_omega); + + if vk.total_lookup_entries_length > 0 { + // first commit values at z, and then at z*omega + transcript.commit_field_element(proof.lookup_t_poly_opening_at_z.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + transcript.commit_field_element(proof.lookup_selector_poly_opening_at_z.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + transcript.commit_field_element(proof.lookup_table_type_poly_opening_at_z.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + + // now at z*omega + transcript.commit_field_element(proof.lookup_s_poly_opening_at_z_omega.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + transcript.commit_field_element(proof.lookup_grand_product_opening_at_z_omega.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + transcript.commit_field_element(proof.lookup_t_poly_opening_at_z_omega.as_ref().ok_or(SynthesisError::AssignmentMissing)?); + } + + let linearization_at_z = proof.linearization_poly_opening_at_z; + transcript.commit_field_element(&linearization_at_z); + + // linearization is done, now perform sanity check + // this is effectively a verification procedure + + let mut lookup_query = None; + + { + let vanishing_at_z = evaluate_vanishing_for_size(&z, required_domain_size as u64); + + // first let's aggregate gates + + let mut t_num_on_full_domain = E::Fr::zero(); + + let challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = sorted_gates.clone(); + + // we've suffered and linearization polynomial captures all the gates except the public input! + + { + let mut tmp = linearization_at_z; + // add input values + + let gate = all_gates.drain(0..1).into_iter().next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert(gate.benefits_from_linearization())?; + safe_assert(C::MainGate::default().into_internal() == gate)?; + let gate = C::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, _) = challenges_slice.split_at(num_challenges); + + let input_values = proof.inputs.clone(); + + let mut inputs_term = gate.add_inputs_into_quotient( + required_domain_size, + &input_values, + z, + for_gate, + )?; + + if num_different_gates > 1 { + let selector_value = selector_values[0]; + inputs_term.mul_assign(&selector_value); + } + + tmp.add_assign(&inputs_term); + + t_num_on_full_domain.add_assign(&tmp); + } + + // now aggregate leftovers from grand product for copy permutation + { + // - alpha_0 * (a + perm(z) * beta + gamma)*()*(d + gamma) * z(z*omega) + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let mut factor = alpha_0; + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(vk.state_width-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(vk.state_width-1)); + let mut tmp = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + tmp.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&tmp); + + t_num_on_full_domain.sub_assign(&factor); + + // - L_0(z) * alpha_1 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + } + + // and if exists - grand product for lookup permutation + { + if vk.total_lookup_entries_length > 0 { + + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let lookup_queries = LookupQuery:: { + s_at_z_omega: proof.lookup_s_poly_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?, + grand_product_at_z_omega: proof.lookup_grand_product_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?, + t_at_z: proof.lookup_t_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?, + t_at_z_omega: proof.lookup_t_poly_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?, + selector_at_z: proof.lookup_selector_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?, + table_type_at_z: proof.lookup_table_type_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?, + }; + + let beta_for_lookup_permutation = beta_for_lookup.ok_or(SynthesisError::AssignmentMissing)?; + let gamma_for_lookup_permutation = gamma_for_lookup.ok_or(SynthesisError::AssignmentMissing)?; + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + let expected = gamma_beta.pow([(required_domain_size-1) as u64]); + + // in a linearization we've taken terms: + // - s(x) from the alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + // - and Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) (term in full) + + // + alpha_1 * (Z(x) - 1) * L_{0}(z) + alpha_2 * (Z(x) - expected) * L_{n-1}(z) + + // first make alpha_0 * Z(x*omega)*(\gamma*(1 + \beta) + \beta * s(x*omega))) + + let mut tmp = lookup_queries.s_at_z_omega; + tmp.mul_assign(&beta_for_lookup_permutation); + tmp.add_assign(&gamma_beta); + tmp.mul_assign(&lookup_queries.grand_product_at_z_omega); + tmp.mul_assign(&alpha_0); + + // (z - omega^{n-1}) for this part + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + tmp.mul_assign(&z_minus_last_omega); + + t_num_on_full_domain.add_assign(&tmp); + + // // - alpha_1 * L_{0}(z) + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign(&alpha_1); + + t_num_on_full_domain.sub_assign(&l_0_at_z); + + // // - alpha_2 * expected L_{n-1}(z) + + let mut l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + l_n_minus_one_at_z.mul_assign(&expected); + l_n_minus_one_at_z.mul_assign(&alpha_2); + + t_num_on_full_domain.sub_assign(&l_n_minus_one_at_z); + + lookup_query = Some(lookup_queries); + } + } + + let mut lhs = quotient_at_z; + lhs.mul_assign(&vanishing_at_z); + + let rhs = t_num_on_full_domain; + + if lhs != rhs { + return Ok(((E::G1Affine::zero(), E::G1Affine::zero()), false)); + } + } + + // now we need to reconstruct the effective linearization poly with homomorphic properties + let linearization_commitment = { + + let mut challenges_slice = &powers_of_alpha_for_gates[..]; + + let mut all_gates = sorted_gates.clone(); + + let gate = all_gates.drain(0..1).into_iter().next().ok_or(SynthesisError::AssignmentMissing)?; + safe_assert(gate.benefits_from_linearization())?; + safe_assert(C::MainGate::default().into_internal() == gate)?; + let gate = C::MainGate::default(); + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + let input_values = proof.inputs.clone(); + + let mut r = gate.contribute_into_linearization_commitment_for_public_inputs( + required_domain_size, + &input_values, + z, + &query_values_map, + &setup_commitments_storage, + for_gate, + )?; + + let mut selectors_it = selector_values.clone().into_iter(); + + if num_different_gates > 1 { + // first multiply r by the selector value at z + r.mul_assign(selectors_it.next().ok_or(SynthesisError::AssignmentMissing)?.into_repr()); + } + + // now proceed per gate + for gate in all_gates.into_iter() { + let num_challenges = gate.num_quotient_terms(); + let (for_gate, rest) = challenges_slice.split_at(num_challenges); + challenges_slice = rest; + + if gate.benefits_from_linearization() { + // gate benefits from linearization, so make temporary value + let tmp = gate.contribute_into_linearization_commitment( + required_domain_size, + z, + &query_values_map, + &setup_commitments_storage, + for_gate, + )?; + + let selector_value = selectors_it.next().ok_or(SynthesisError::AssignmentMissing)?; + let mut scaled = tmp; + scaled.mul_assign(selector_value.into_repr()); + + r.add_assign(&scaled); + } else { + // we linearize over the selector, so take a selector and scale it + let gate_value_at_z = gate.contribute_into_verification_equation( + required_domain_size, + z, + &query_values_map, + for_gate + )?; + + let key = PolyIdentifier::GateSelector(gate.name()); + let gate_selector = gate_selectors_commitments_storage.get(&key).ok_or(SynthesisError::AssignmentMissing)?; + let scaled = gate_selector.mul(gate_value_at_z.into_repr()); + + r.add_assign(&scaled); + } + } + + safe_assert(selectors_it.next().is_none())?; + safe_assert_eq(challenges_slice.len(), 0)?; + + // add contributions from copy-permutation and lookup-permutation + + // copy-permutation linearization comtribution + { + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let [alpha_0, alpha_1] = copy_grand_product_alphas.expect("there must be powers of alpha for copy permutation"); + + let some_one = Some(E::Fr::one()); + let mut non_residues_iterator = some_one.iter().chain(&vk.non_residues); + + let mut factor = alpha_0; + + for idx in 0..vk.state_width { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let mut t = z; + let non_res = non_residues_iterator.next().ok_or(SynthesisError::AssignmentMissing)?; + t.mul_assign(&non_res); + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + safe_assert(non_residues_iterator.next().is_none())?; + + let scaled = proof.copy_permutation_grand_product_commitment.mul(factor.into_repr()); + + r.add_assign(&scaled); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = alpha_0; + factor.mul_assign(&beta_for_copy_permutation); + factor.mul_assign(©_permutation_z_at_z_omega); + + for idx in 0..(vk.state_width-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let wire_value = query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + let permutation_at_z = copy_permutation_queries[idx]; + let mut t = permutation_at_z; + + t.mul_assign(&beta_for_copy_permutation); + t.add_assign(&wire_value); + t.add_assign(&gamma_for_copy_permutation); + + factor.mul_assign(&t); + } + + let scaled = vk.permutation_commitments.get(vk.state_width - 1).ok_or(SynthesisError::AssignmentMissing)?.mul(factor.into_repr()); + + r.sub_assign(&scaled); + + // + L_0(z) * Z(x) + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign(&alpha_1); + + let scaled = proof.copy_permutation_grand_product_commitment.mul(factor.into_repr()); + + r.add_assign(&scaled); + } + + // lookup grand product linearization + + // due to separate divisor it's not obvious if this is beneficial without some tricks + // like multiplication by (1 - L_{n-1}) or by (x - omega^{n-1}) + + // Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) == 0 + // check that (Z(x) - 1) * L_{0} == 0 + // check that (Z(x) - expected) * L_{n-1} == 0, or (Z(x*omega) - expected)* L_{n-2} == 0 + + // f(x) does not need to be opened as it's made of table selector and witnesses + // if we pursue the strategy from the linearization of a copy-permutation argument + // then we leave something like s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) term, + // and Z(x) from Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) term, + // with terms with lagrange polys as multipliers left intact + + if vk.total_lookup_entries_length > 0 { + let [alpha_0, alpha_1, alpha_2] = lookup_grand_product_alphas.expect("there must be powers of alpha for lookup permutation"); + + let lookup_queries = lookup_query.expect("lookup data must be constructed"); + + // let s_at_z_omega = lookup_queries.s_at_z_omega; + let grand_product_at_z_omega = lookup_queries.grand_product_at_z_omega; + let t_at_z = lookup_queries.t_at_z; + let t_at_z_omega = lookup_queries.t_at_z_omega; + let selector_at_z = lookup_queries.selector_at_z; + let table_type_at_z = lookup_queries.table_type_at_z; + + let l_0_at_z = evaluate_lagrange_poly_at_point(0, &domain, z)?; + let l_n_minus_one_at_z = evaluate_lagrange_poly_at_point(required_domain_size - 1, &domain, z)?; + + let beta_for_lookup_permutation = beta_for_lookup.ok_or(SynthesisError::AssignmentMissing)?; + let gamma_for_lookup_permutation = gamma_for_lookup.ok_or(SynthesisError::AssignmentMissing)?; + + let mut beta_plus_one = beta_for_lookup_permutation; + beta_plus_one.add_assign(&E::Fr::one()); + let mut gamma_beta = gamma_for_lookup_permutation; + gamma_beta.mul_assign(&beta_plus_one); + + // (Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) - + // Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)))*(X - omega^{n-1}) + + let last_omega = domain.generator.pow(&[(required_domain_size - 1) as u64]); + let mut z_minus_last_omega = z; + z_minus_last_omega.sub_assign(&last_omega); + + // s(x) from the Z(x*omega)*(\gamma*(1 + \beta) + s(x) + \beta * s(x*omega))) + let mut factor = grand_product_at_z_omega; // we do not need to account for additive terms + factor.mul_assign(&alpha_0); + factor.mul_assign(&z_minus_last_omega); + + let scaled = proof.lookup_s_poly_commitment.ok_or(SynthesisError::AssignmentMissing)?.mul(factor.into_repr()); + + r.add_assign(&scaled); + + // Z(x) from - alpha_0 * Z(x) * (\beta + 1) * (\gamma + f(x)) * (\gamma(1 + \beta) + t(x) + \beta * t(x*omega)) + // + alpha_1 * Z(x) * L_{0}(z) + alpha_2 * Z(x) * L_{n-1}(z) + + // accumulate coefficient + let mut factor = t_at_z_omega; + factor.mul_assign(&beta_for_lookup_permutation); + factor.add_assign(&t_at_z); + factor.add_assign(&gamma_beta); + + // (\gamma + f(x)) + + let mut f_reconstructed = E::Fr::zero(); + let mut current = E::Fr::one(); + let eta = eta; + // a,b,c + safe_assert_eq(vk.state_width, 4)?; + for idx in 0..(vk.state_width-1) { + let key = PolynomialInConstraint::from_id(PolyIdentifier::VariablesPolynomial(idx)); + let mut value = *query_values_map.get(&key) + .ok_or(SynthesisError::AssignmentMissing)?; + + value.mul_assign(¤t); + f_reconstructed.add_assign(&value); + + current.mul_assign(&eta); + } + + // and table type + let mut t = table_type_at_z; + t.mul_assign(¤t); + f_reconstructed.add_assign(&t); + + f_reconstructed.mul_assign(&selector_at_z); + f_reconstructed.add_assign(&gamma_for_lookup_permutation); + + // end of (\gamma + f(x)) part + + factor.mul_assign(&f_reconstructed); + factor.mul_assign(&beta_plus_one); + factor.negate(); // don't forget minus sign + factor.mul_assign(&alpha_0); + + // Multiply by (z - omega^{n-1}) + + factor.mul_assign(&z_minus_last_omega); + + // L_{0}(z) in front of Z(x) + + let mut tmp = l_0_at_z; + tmp.mul_assign(&alpha_1); + factor.add_assign(&tmp); + + // L_{n-1}(z) in front of Z(x) + + let mut tmp = l_n_minus_one_at_z; + tmp.mul_assign(&alpha_2); + factor.add_assign(&tmp); + + let scaled = proof.lookup_grand_product_commitment.ok_or(SynthesisError::AssignmentMissing)?.mul(factor.into_repr()); + + r.add_assign(&scaled); + } + + r.into_affine() + }; + + let v = transcript.get_challenge(); + + // commit proofs + + commit_point_as_xy::(&mut transcript, &proof.opening_proof_at_z); + commit_point_as_xy::(&mut transcript, &proof.opening_proof_at_z_omega); + + let u = transcript.get_challenge(); + + // first perform naive verification at z + // f(x) - f(z) = q(x)(x - z) => + // e(f(x) - f(z)*g + z*q(x), h)*e(-q(x), h^x) == 1 + // when we aggregate we need to aggregate f(x) part (commitments) and f(z) part (values) + + let mut values_queried_at_z = vec![quotient_at_z]; + values_queried_at_z.push(linearization_at_z); + values_queried_at_z.extend(all_values_queried_at_z); + + let quotient_commitment_aggregated = { + let mut quotient_commitments_iter = proof.quotient_poly_parts_commitments.iter(); + let mut result = quotient_commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?.into_projective(); + + let mut current = z_in_domain_size; + for part in quotient_commitments_iter { + let tmp = *part; + let tmp = tmp.mul(current.into_repr()); + + result.add_assign(&tmp); + current.mul_assign(&z_in_domain_size); + } + + result.into_affine() + }; + + let mut commitments_queried_at_z = vec![]; + commitments_queried_at_z.push(quotient_commitment_aggregated); + commitments_queried_at_z.push(linearization_commitment); + commitments_queried_at_z.extend(all_commitments_queried_at_z); + + let mut reconstructed_lookup_t_poly_commitment = None; + + if vk.total_lookup_entries_length > 0 { + // we need to add t(x), selector(x) and table type(x) + values_queried_at_z.push(proof.lookup_t_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?); + values_queried_at_z.push(proof.lookup_selector_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?); + values_queried_at_z.push(proof.lookup_table_type_poly_opening_at_z.ok_or(SynthesisError::AssignmentMissing)?); + + // use eta to reconstruct t poly aggregated commitment + let lookup_t_poly_commitment_aggregated = { + let mut commitments_iter = vk.lookup_tables_commitments.iter(); + let mut result = commitments_iter.next().ok_or(SynthesisError::AssignmentMissing)?.into_projective(); + + let mut current = eta; + for part in commitments_iter { + let tmp = *part; + let tmp = tmp.mul(current.into_repr()); + + result.add_assign(&tmp); + current.mul_assign(&eta); + } + + result.into_affine() + }; + + reconstructed_lookup_t_poly_commitment = Some(lookup_t_poly_commitment_aggregated); + + commitments_queried_at_z.push(lookup_t_poly_commitment_aggregated); + commitments_queried_at_z.push(vk.lookup_selector_commitment.ok_or(SynthesisError::AssignmentMissing)?); + commitments_queried_at_z.push(vk.lookup_table_type_commitment.ok_or(SynthesisError::AssignmentMissing)?); + } + + let mut values_queried_at_z_omega = vec![copy_permutation_z_at_z_omega]; + values_queried_at_z_omega.extend(all_values_queried_at_z_omega); + + let mut commitments_queried_at_z_omega = vec![proof.copy_permutation_grand_product_commitment]; + commitments_queried_at_z_omega.extend(all_commitments_queried_at_z_omega); + + if vk.total_lookup_entries_length > 0 { + // we need to add s(x), grand_product(x) and t(x) + values_queried_at_z_omega.push(proof.lookup_s_poly_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?); + values_queried_at_z_omega.push(proof.lookup_grand_product_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?); + values_queried_at_z_omega.push(proof.lookup_t_poly_opening_at_z_omega.ok_or(SynthesisError::AssignmentMissing)?); + + commitments_queried_at_z_omega.push(proof.lookup_s_poly_commitment.ok_or(SynthesisError::AssignmentMissing)?); + commitments_queried_at_z_omega.push(proof.lookup_grand_product_commitment.ok_or(SynthesisError::AssignmentMissing)?); + commitments_queried_at_z_omega.push(reconstructed_lookup_t_poly_commitment.expect("t poly for lookup must be reconstructed")); + } + + safe_assert_eq(commitments_queried_at_z.len(), values_queried_at_z.len())?; + safe_assert_eq(commitments_queried_at_z_omega.len(), values_queried_at_z_omega.len())?; + + let mut aggregated_commitment_at_z = commitments_queried_at_z.drain(0..1).next().ok_or(SynthesisError::AssignmentMissing)?.into_projective(); + let mut aggregated_opening_at_z = values_queried_at_z.drain(0..1).next().ok_or(SynthesisError::AssignmentMissing)?; + + let mut aggregation_challenge = E::Fr::one(); + + for (commitment, value) in commitments_queried_at_z.into_iter().zip(values_queried_at_z.into_iter()) { + aggregation_challenge.mul_assign(&v); + + let scaled = commitment.mul(aggregation_challenge.into_repr()); + aggregated_commitment_at_z.add_assign(&scaled); + // dbg!(aggregated_commitment_at_z.into_affine()); + + let mut tmp = value; + tmp.mul_assign(&aggregation_challenge); + aggregated_opening_at_z.add_assign(&tmp); + } + + aggregation_challenge.mul_assign(&v); + + let mut aggregated_commitment_at_z_omega = commitments_queried_at_z_omega.drain(0..1).next().ok_or(SynthesisError::AssignmentMissing)?.mul(aggregation_challenge.into_repr()); + let mut aggregated_opening_at_z_omega = values_queried_at_z_omega.drain(0..1).next().ok_or(SynthesisError::AssignmentMissing)?; + aggregated_opening_at_z_omega.mul_assign(&aggregation_challenge); + + for (commitment, value) in commitments_queried_at_z_omega.into_iter().zip(values_queried_at_z_omega.into_iter()) { + aggregation_challenge.mul_assign(&v); + + let scaled = commitment.mul(aggregation_challenge.into_repr()); + aggregated_commitment_at_z_omega.add_assign(&scaled); + + let mut tmp = value; + tmp.mul_assign(&aggregation_challenge); + aggregated_opening_at_z_omega.add_assign(&tmp); + } + + // f(x) + let mut pair_with_generator = aggregated_commitment_at_z; + aggregated_commitment_at_z_omega.mul_assign(u.into_repr()); + pair_with_generator.add_assign(&aggregated_commitment_at_z_omega); + + // - f(z)*g + let mut aggregated_value = aggregated_opening_at_z_omega; + aggregated_value.mul_assign(&u); + aggregated_value.add_assign(&aggregated_opening_at_z); + + let tmp = E::G1Affine::one().mul(aggregated_value.into_repr()); + pair_with_generator.sub_assign(&tmp); + + // +z * q(x) + let mut tmp = proof.opening_proof_at_z.mul(z.into_repr()); + + let mut t0 = z_omega; + t0.mul_assign(&u); + let t1 = proof.opening_proof_at_z_omega.mul(t0.into_repr()); + tmp.add_assign(&t1); + pair_with_generator.add_assign(&tmp); + + // rhs + let mut pair_with_x = proof.opening_proof_at_z_omega.mul(u.into_repr()); + pair_with_x.add_assign_mixed(&proof.opening_proof_at_z); + + let mut pair_with_x = pair_with_x.into_affine(); + pair_with_x.negate(); + + let pair_with_generator = pair_with_generator.into_affine(); + + Ok(((pair_with_generator, pair_with_x), true)) +} diff --git a/src/plonk/better_cs/adaptor.rs b/src/plonk/better_cs/adaptor.rs new file mode 100644 index 000000000..0f1cd8a9e --- /dev/null +++ b/src/plonk/better_cs/adaptor.rs @@ -0,0 +1,2334 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::SynthesisError; + +use super::cs::{PlonkConstraintSystemParams, StateVariablesSet, TraceStepCoefficients}; +use crate::plonk::cs::gates::Variable as PlonkVariable; +use crate::plonk::cs::gates::Index as PlonkIndex; + +use super::cs::Circuit as PlonkCircuit; +use super::cs::ConstraintSystem as PlonkConstraintSystem; + +use std::marker::PhantomData; + +use std::collections::{HashSet, HashMap}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MergeLcVariant { + AIsTheOnlyMeaningful, + BIsTheOnlyMeaningful, + MergeABWithConstantC, + MergeACThroughConstantB, + MergeBCThroughConstantA, + CIsTheOnlyMeaningful, +} + +impl MergeLcVariant { + pub fn into_u8(&self) -> u8 { + match self { + MergeLcVariant::AIsTheOnlyMeaningful => 1u8, + MergeLcVariant::BIsTheOnlyMeaningful => 2u8, + MergeLcVariant::MergeABWithConstantC => 3u8, + MergeLcVariant::MergeACThroughConstantB => 4u8, + MergeLcVariant::MergeBCThroughConstantA => 5u8, + MergeLcVariant::CIsTheOnlyMeaningful => 6u8, + } + } + + pub fn from_u8(value: u8) -> std::io::Result { + let s = match value { + 1u8 => MergeLcVariant::AIsTheOnlyMeaningful, + 2u8 => MergeLcVariant::BIsTheOnlyMeaningful, + 3u8 => MergeLcVariant::MergeABWithConstantC, + 4u8 => MergeLcVariant::MergeACThroughConstantB, + 5u8 => MergeLcVariant::MergeBCThroughConstantA, + 6u8 => MergeLcVariant::CIsTheOnlyMeaningful, + _ => { + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown LC merging variant"); + + return Err(custom_error); + } + }; + + Ok(s) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LcTransformationVariant { + IsSingleVariable, + IntoSingleGate, + IntoMultipleGates, + IsConstant, +} + +impl LcTransformationVariant { + pub fn into_u8(&self) -> u8 { + match self { + LcTransformationVariant::IsSingleVariable => 1u8, + LcTransformationVariant::IntoSingleGate => 2u8, + LcTransformationVariant::IntoMultipleGates => 3u8, + LcTransformationVariant::IsConstant => 4u8, + } + } + + pub fn from_u8(value: u8) -> std::io::Result { + let s = match value { + 1u8 => LcTransformationVariant::IsSingleVariable, + 2u8 => LcTransformationVariant::IntoSingleGate, + 3u8 => LcTransformationVariant::IntoMultipleGates, + 4u8 => LcTransformationVariant::IsConstant, + _ => { + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown LC transformation variant"); + + return Err(custom_error); + } + }; + + Ok(s) + } +} + +struct TranspilationScratchSpace { + scratch_space_for_vars: Vec, + scratch_space_for_coeffs: Vec, + scratch_space_for_booleans: Vec, +} + +impl TranspilationScratchSpace { + fn new(width: usize) -> Self { + Self { + scratch_space_for_vars: Vec::with_capacity(width), + scratch_space_for_coeffs: Vec::with_capacity(width), + scratch_space_for_booleans: Vec::with_capacity(width), + } + } + + fn clear(&mut self) { + self.scratch_space_for_vars.truncate(0); + self.scratch_space_for_coeffs.truncate(0); + self.scratch_space_for_booleans.truncate(0); + } +} + +// These are transpilation options over A * B - C = 0 constraint +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum TranspilationVariant { + IntoQuadraticGate, + IntoAdditionGate(LcTransformationVariant), + MergeLinearCombinations(MergeLcVariant, LcTransformationVariant), + IntoMultiplicationGate((LcTransformationVariant, LcTransformationVariant, LcTransformationVariant)) +} + +use std::io::{Read, Write}; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use crate::byteorder::BigEndian; + +impl TranspilationVariant { + pub fn into_u8(&self) -> u8 { + match self { + TranspilationVariant::IntoQuadraticGate => 1u8, + TranspilationVariant::IntoAdditionGate(_) => 2u8, + TranspilationVariant::MergeLinearCombinations(_, _) => 3u8, + TranspilationVariant::IntoMultiplicationGate(_) => 4u8, + } + } + + pub fn write( + &self, + mut writer: W + ) -> std::io::Result<()> + { + let prefix = self.into_u8(); + writer.write_u8(prefix)?; + match self { + TranspilationVariant::IntoAdditionGate(subhint) => { + let subhint = subhint.into_u8(); + writer.write_u8(subhint)?; + } + TranspilationVariant::MergeLinearCombinations(variant, subhint) => { + let variant = variant.into_u8(); + writer.write_u8(variant)?; + + let subhint = subhint.into_u8(); + writer.write_u8(subhint)?; + }, + TranspilationVariant::IntoMultiplicationGate(hints) => { + let (h_a, h_b, h_c) = hints; + writer.write_u8(h_a.into_u8())?; + writer.write_u8(h_b.into_u8())?; + writer.write_u8(h_c.into_u8())?; + }, + _ => { + } + } + + Ok(()) + } + + pub fn read( + mut reader: R + ) -> std::io::Result + { + let prefix = reader.read_u8()?; + + match prefix { + 1u8 => {return Ok(TranspilationVariant::IntoQuadraticGate); }, + 2u8 => { + let subhint = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::IntoAdditionGate(subhint)); + }, + 3u8 => { + let variant = MergeLcVariant::from_u8(reader.read_u8()?)?; + let subhint = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::MergeLinearCombinations(variant, subhint)); + }, + 4u8 => { + let subhint_a = LcTransformationVariant::from_u8(reader.read_u8()?)?; + let subhint_b = LcTransformationVariant::from_u8(reader.read_u8()?)?; + let subhint_c = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::IntoMultiplicationGate((subhint_a, subhint_b, subhint_c))); + }, + _ => {} + } + + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown transpilation variant"); + + Err(custom_error) + } +} + +pub fn read_transpilation_hints( + mut reader: R +) -> std::io::Result> { + let num_hints = reader.read_u64::()?; + let mut hints = Vec::with_capacity(num_hints as usize); + + for _ in 0..num_hints { + let idx = reader.read_u64::()?; + let hint = TranspilationVariant::read(&mut reader)?; + hints.push((idx as usize, hint)); + } + + Ok(hints) +} + +pub fn write_transpilation_hints( + hints: &Vec<(usize, TranspilationVariant)>, + mut writer: W +) -> std::io::Result<()> { + writer.write_u64::(hints.len() as u64)?; + for (idx, h) in hints.iter() { + writer.write_u64::(*idx as u64)?; + h.write(&mut writer)?; + } + + Ok(()) +} + +impl std::fmt::Debug for TranspilationVariant { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TranspilationVariant::IntoQuadraticGate => { + writeln!(f, "Variant: into quadratic gate")?; + }, + TranspilationVariant::IntoAdditionGate(_) => { + writeln!(f, "Variant: make an addition gate")?; + }, + TranspilationVariant::MergeLinearCombinations(merge_type, _) => { + writeln!(f, "Variant: merge linear combinations as {:?}", merge_type)?; + }, + TranspilationVariant::IntoMultiplicationGate(b) => { + writeln!(f, "Variant: into combinatoric multiplication gate")?; + writeln!(f, "A: {:?}", b.0)?; + writeln!(f, "B: {:?}", b.1)?; + writeln!(f, "C: {:?}", b.2)?; + }, + } + + Ok(()) + } +} + +pub struct Transpiler> { + current_constraint_index: usize, + current_plonk_input_idx: usize, + current_plonk_aux_idx: usize, + scratch: HashSet, + // deduplication_scratch: HashMap, + deduplication_scratch: HashMap, + transpilation_scratch_space: Option>, + hints: Vec<(usize, TranspilationVariant)>, + n: usize, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

+} + +// by convention last coefficient is a coefficient for a jump to the next step +fn allocate_into_cs, CS: PlonkConstraintSystem> ( + cs: &mut CS, + needs_next_step: bool, + variables: &[PlonkVariable], + coefficients: &[E::Fr] +) -> Result<(), SynthesisError> { + if needs_next_step { + debug_assert!(coefficients.len() == P::STATE_WIDTH + 1 + 1 + 1); + debug_assert!(P::CAN_ACCESS_NEXT_TRACE_STEP); + + cs.new_gate( + P::StateVariables::from_variables(variables), + P::ThisTraceStepCoefficients::from_coeffs(&coefficients[0..(P::STATE_WIDTH+2)]), + P::NextTraceStepCoefficients::from_coeffs(&coefficients[(P::STATE_WIDTH+2)..]) + )?; + } else { + debug_assert!(coefficients.len() >= P::STATE_WIDTH + 1 + 1); + debug_assert!(coefficients.last().unwrap().is_zero()); + + cs.new_gate( + P::StateVariables::from_variables(variables), + P::ThisTraceStepCoefficients::from_coeffs(&coefficients[0..(P::STATE_WIDTH+2)]), + P::NextTraceStepCoefficients::from_coeffs(&coefficients[(P::STATE_WIDTH+2)..]) + )?; + } + + Ok(()) +} + +fn evaluate_lc, CS: PlonkConstraintSystem>( + cs: &CS, + lc: &LinearCombination, + // multiplier: E::Fr, + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in lc.as_ref().iter() { + let mut may_be_value = cs.get_value(convert_variable(*var))?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_variables, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[(Variable, E::Fr)], + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter() { + let mut may_be_value = cs.get_value(convert_variable(*var))?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_plonk_variables, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[(PlonkVariable, E::Fr)], + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter() { + let mut may_be_value = cs.get_value(*var)?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_plonk_variables_and_coeffs, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[PlonkVariable], + coeffs: &[E::Fr], + free_term_constant: E::Fr +) -> Result { + debug_assert_eq!(variables.len(), coeffs.len()); + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter().zip(coeffs.iter()) { + let mut may_be_value = cs.get_value(*var)?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn enforce_lc_as_gates, CS: PlonkConstraintSystem>( + cs: &mut CS, + mut lc: LinearCombination, + multiplier: E::Fr, + free_term_constant: E::Fr, + collapse_into_single_variable: bool, + scratch_space: &mut TranspilationScratchSpace, +) -> Result<(Option, E::Fr, LcTransformationVariant), SynthesisError> { + assert!(P::CAN_ACCESS_NEXT_TRACE_STEP, "Transliper only works for proof systems with access to next step"); + + assert!(scratch_space.scratch_space_for_vars.len() == 0); + assert!(scratch_space.scratch_space_for_coeffs.len() == 0); + assert!(scratch_space.scratch_space_for_booleans.len() == 0); + + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + // trivial case - single variable + + assert!(lc.0.len() > 0); + + if lc.0.len() == 1 { + if free_term_constant.is_zero() { + // this linear combination contains only one variable and no constant + // term, so we just leave it as is, + // but ONLY if we just need to collapse LC into a variable + if collapse_into_single_variable { + let (var, coeff) = lc.0[0]; + + return Ok((Some(convert_variable(var)), coeff, LcTransformationVariant::IsSingleVariable)); + } + } + } + + // everything else should be handled here by making a new variable + + // scale if necessary + if multiplier.is_zero() { + assert!(free_term_constant.is_zero()); + unreachable!(); + // it's a constraint 0 * LC = 0 + } else { + if multiplier != one_fr { + for (_, c) in lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + } + + // if we need to collaplse an LC into a single variable for + // future use we allocate it and then subtract it from linear combination + // to have an enforcement LC == 0 in all the cases + + let final_variable = if collapse_into_single_variable { + let may_be_new_value = evaluate_lc::(&*cs, &lc, free_term_constant); + let new_var = cs.alloc(|| { + may_be_new_value + })?; + + Some(new_var) + } else { + None + }; + + if let Some(var) = final_variable { + subtract_variable_unchecked(&mut lc, convert_variable_back(var)); + } + + let num_terms = lc.0.len(); + + // we have two options: + // - fit everything into a single gate (in case of number terms in the linear combination + // smaller than a width of the state) + // - make a required number of extra variables and chain it + + if num_terms <= P::STATE_WIDTH { + // we can just make a single gate + + // fill the gate with nothing first and replace after + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + + let it = lc.0.into_iter(); + + // we can consume and never have leftovers + let mut idx = 0; + for (var, coeff) in it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + } + } + + // add multiplication coefficient, constant and next step one + + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(free_term_constant); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + + allocate_into_cs( + cs, + false, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + let hint = LcTransformationVariant::IntoSingleGate; + + return Ok((final_variable, one_fr, hint)); + } else { + // we can take: + // - STATE_WIDTH variables to form the first gate and place their sum into the last wire of the next gate + // - every time take STATE_WIDTH-1 variables and place their sum + last wire into the next gate last wire + + // we have also made a final variable already, so there is NO difference + let cycles = ((lc.0.len() - P::STATE_WIDTH) + (P::STATE_WIDTH - 2)) / (P::STATE_WIDTH - 1); // ceil + let mut it = lc.0.into_iter(); + + // this is a placeholder variable that must go into the + // corresponding trace polynomial at the NEXT time step + let mut next_step_var_in_chain = { + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + if idx == P::STATE_WIDTH { + break; + } + } + } + + // for a P::STATE_WIDTH variables we make a corresponding LC + // ~ a + b + c + d + constant. That will be equal to d_next + let may_be_new_intermediate_value = evaluate_over_plonk_variables_and_coeffs::( + &*cs, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs, + free_term_constant + ); + + // we manually allocate the new variable + let new_intermediate_var = cs.alloc(|| { + may_be_new_intermediate_value + })?; + + // no multiplication coefficient, + // but -1 to link to the next trace step (we enforce == 0) + scratch_space.scratch_space_for_coeffs.push(zero_fr); // no multiplication + scratch_space.scratch_space_for_coeffs.push(free_term_constant); // add constant + scratch_space.scratch_space_for_coeffs.push(minus_one_fr); // -1 for a d_next + + allocate_into_cs( + cs, + true, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + new_intermediate_var + }; + + // run over the rest + + // we can only take one less cause + // we've already used one of the variable + let consume_from_lc = P::STATE_WIDTH - 1; + for _ in 0..(cycles-1) { + scratch_space.scratch_space_for_vars.resize(consume_from_lc, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(consume_from_lc, false); + scratch_space.scratch_space_for_coeffs.resize(consume_from_lc, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + if idx == consume_from_lc { + break; + } + } + } + + // push +1 and the allocated variable from the previous step + + scratch_space.scratch_space_for_coeffs.push(one_fr); + scratch_space.scratch_space_for_vars.push(next_step_var_in_chain); + + let may_be_new_intermediate_value = evaluate_over_plonk_variables_and_coeffs::( + &*cs, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs, + zero_fr + ); + + let new_intermediate_var = cs.alloc(|| { + may_be_new_intermediate_value + })?; + + // no multiplication coefficient and no constant now, + // but -1 to link to the next trace step + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(minus_one_fr); + + allocate_into_cs( + cs, + true, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + next_step_var_in_chain = new_intermediate_var; + } + + // final step - we just make a single gate, last one + { + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH-1, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH-1, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH-1, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + } + } + + assert!(idx < P::STATE_WIDTH); + // append d_next + scratch_space.scratch_space_for_vars.push(next_step_var_in_chain); + scratch_space.scratch_space_for_coeffs.push(one_fr); + + // no multiplication coefficient, no constant, no next step + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + + allocate_into_cs( + cs, + false, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + } + + assert!(it.next().is_none()); + + let hint = LcTransformationVariant::IntoMultipleGates; + + return Ok((final_variable, one_fr, hint)); + } +} + +impl> Transpiler { + pub fn new() -> Self { + Self { + current_constraint_index: 0, + current_plonk_input_idx: 0, + current_plonk_aux_idx: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + transpilation_scratch_space: Some(TranspilationScratchSpace::::new(P::STATE_WIDTH * 2)), + hints: vec![], + n: 0usize, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + } + } + + pub fn num_gates(&self) -> usize { + self.n + } + + pub fn into_hints(self) -> Vec<(usize, TranspilationVariant)> { + self.hints + } + + pub fn into_hints_and_num_gates(self) -> (usize, Vec<(usize, TranspilationVariant)>) { + (self.n, self.hints) + } + + fn increment_lc_number(&mut self) -> usize { + let current_lc_number = self.current_constraint_index; + self.current_constraint_index += 1; + + current_lc_number + } +} + +impl> PlonkConstraintSystem for Transpiler { + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc( + self, + || "alloc aux var", + value)?; + + Ok(convert_variable(var)) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc_input( + self, + || "alloc input var", + value)?; + + self.n += 1; + + Ok(convert_variable(var)) + } + + fn new_gate(&mut self, + _variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + // Transpiler does NOT allocate any gates himself + self.n += 1; + + Ok(()) + } + + fn get_dummy_variable(&self) -> PlonkVariable { + PlonkVariable::new_unchecked(PlonkIndex::Aux(0)) + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams> PlonkConstraintSystem for &'a mut Transpiler { + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc( + self, + || "alloc aux var", + value)?; + + Ok(convert_variable(var)) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc_input( + self, + || "alloc input var", + value)?; + + self.n += 1; + + Ok(convert_variable(var)) + } + + fn new_gate(&mut self, + _variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + // Transpiler does NOT allocate any gates himself + self.n += 1; + + Ok(()) + } + + fn get_dummy_variable(&self) -> PlonkVariable { + PlonkVariable::new_unchecked(PlonkIndex::Aux(0)) + } +} + +impl> crate::ConstraintSystem for Transpiler +{ + type Root = Self; + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, _f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + self.current_plonk_aux_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Aux(self.current_plonk_aux_idx))) + } + + fn alloc_input( + &mut self, + _: A, + _f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + self.current_plonk_input_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Input(self.current_plonk_input_idx))) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let mut negative_one_fr = E::Fr::one(); + negative_one_fr.negate(); + + // we need to determine the type of transformation constraint + + // let's handle trivial cases first + + // A or B or C are just constant terms + + let (a_has_constant, a_constant_term, a_lc_is_empty, a_lc) = deduplicate_and_split_linear_term::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (b_has_constant, b_constant_term, b_lc_is_empty, b_lc) = deduplicate_and_split_linear_term::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (c_has_constant, c_constant_term, c_lc_is_empty, c_lc) = deduplicate_and_split_linear_term::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + + let a_is_constant = a_has_constant & a_lc_is_empty; + let b_is_constant = b_has_constant & b_lc_is_empty; + let c_is_constant = c_has_constant & c_lc_is_empty; + + // debug_assert!(a_has_constant || !a_lc_is_empty); + // debug_assert!(b_has_constant || !b_lc_is_empty); + // debug_assert!(c_has_constant || !c_lc_is_empty); + + match (a_is_constant, b_is_constant, c_is_constant) { + (true, true, true) => { + unreachable!("R1CS has a gate 1 * 1 = 1"); + }, + (true, false, true) | (false, true, true) => { + // println!("C * LC = C"); + // we have something like c0 * LC = c1 + // do we form an "addition gate", that may take more than + // one gate itself + let lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!("Either A or B LCs are constant"); + }; + + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!("Must take multiplier from A or B"); + }; + + let mut free_constant_term = if a_is_constant { + b_constant_term + } else if b_is_constant { + a_constant_term + } else { + unreachable!("Either A or B LCs are constant"); + }; + + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint) = enforce_lc_as_gates( + self, + lc, + multiplier, + free_constant_term, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * LC = c1"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, TranspilationVariant::IntoAdditionGate(hint))); + + return; + }, + (false, false, true) => { + // println!("LC * LC = C"); + // potential quadatic gate, but ig general + // it's a full multiplication gate + let (is_quadratic_gate, _coeffs) = check_for_quadratic_gate::( + &a_lc, + &b_lc, + &c_lc, + a_constant_term, + b_constant_term, + c_constant_term + ); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + // we don't pass a call to any function that allocates a gate, + // so we count ourselves + self.n += 1; + + let hint = TranspilationVariant::IntoQuadraticGate; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_new_a_var, _, hint_a) = enforce_lc_as_gates( + self, + a_lc, + one_fr, + a_constant_term, + true, + &mut space + ).expect("must allocate A LC as gates for constraint like LC * LC = c1"); + + let (_new_b_var, _, hint_b) = enforce_lc_as_gates( + self, + b_lc, + one_fr, + b_constant_term, + true, + &mut space + ).expect("must allocate B LC as gates for constraint like LC * LC = c1"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint_c = LcTransformationVariant::IsConstant; + + let hint = TranspilationVariant::IntoMultiplicationGate((hint_a, hint_b, hint_c)); + // we don't pass a call to any function that allocates a gate, + // so we count ourselves + self.n += 1; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (true, false, false) | (false, true, false) => { + // sometihng like LC * const = LC + // so we can merge them into one long linear combination + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!() + }; + + let lc_variant = if a_is_constant { + MergeLcVariant::MergeBCThroughConstantA + } else { + MergeLcVariant::MergeACThroughConstantB + }; + + if multiplier == zero_fr { + // LC_AB * 0 = LC_C => LC_C == 0 + // not sure that any sane circuit will have this, + // but we cover this variant + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_c) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + zero_fr, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like 0 = LC_C"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(MergeLcVariant::CIsTheOnlyMeaningful, hint_c); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let mut final_lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!() + }; + + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + + let mut free_constant_term = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!() + }; + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + // let final_lc = final_lc - &c; + let final_lc = subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_lc) = enforce_lc_as_gates( + self, + final_lc, + one_fr, + free_constant_term, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * LC = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(lc_variant, hint_lc); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + + }, + (true, true, false) => { + // const * const = LC + // A and B are some constants + // also strange one, but we cover all the options exhaustively + let mut free_constant_term = a_constant_term; + free_constant_term.mul_assign(&b_constant_term); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_lc) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + free_constant_term, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * c1 = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(MergeLcVariant::CIsTheOnlyMeaningful, hint_lc); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (false, false, false) => { + // LC * LC = LC + // potentially it can still be quadratic + let (is_quadratic_gate, _coeffs) = is_quadratic_gate::( + &a_lc, + &b_lc, + &c_lc, &mut self.scratch); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::IntoQuadraticGate; + // we don't pass a call to any function that allocates a gate, + // so we count ourselves + self.n += 1; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + // rewrite into addition gates and multiplication gates + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_new_a_var, _, hint_a) = enforce_lc_as_gates( + self, + a_lc, + one_fr, + a_constant_term, + true, + &mut space + ).expect("must allocate A LC as gates for constraint like LC * LC = LC"); + let (_new_b_var, _, hint_b) = enforce_lc_as_gates( + self, + b_lc, + one_fr, + b_constant_term, + true, + &mut space + ).expect("must allocate B LC as gates for constraint like LC * LC = LC"); + let (_new_c_var, _, hint_c) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + c_constant_term, + true, + &mut space + ).expect("must allocate C LC as gates for constraint like LC * LC = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::IntoMultiplicationGate((hint_a, hint_b, hint_c)); + // we don't pass a call to any function that allocates a gate, + // so we count ourselves + self.n += 1; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + } + } + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +// List of heuristics + +use crate::{LinearCombination, ConstraintSystem, Variable}; + +fn is_quadratic_gate>( + a: &LinearCombination, + b: &LinearCombination, + c: &LinearCombination, + scratch: &mut HashSet:: +) -> (bool, (E::Fr, E::Fr, E::Fr)) { + let zero = E::Fr::zero(); + + let (_a_containts_constant, a_constant_coeff) = get_constant_term::(&a); + let (_b_containts_constant, b_constant_coeff) = get_constant_term::(&b); + let (_c_containts_constant, c_constant_coeff) = get_constant_term::(&c); + + let (a_is_linear, a_linear_var, a_linear_var_coeff) = is_linear_term::(&a, scratch); + let (b_is_linear, b_linear_var, b_linear_var_coeff) = is_linear_term::(&b, scratch); + let (c_is_linear, c_linear_var, c_linear_var_coeff) = is_linear_term::(&c, scratch); + + let (c_is_constant, _) = is_constant::(&c); + + let is_quadratic; + if c_is_constant { + is_quadratic = a_is_linear && b_is_linear && a_linear_var == b_linear_var; + } else { + if a_is_linear && b_is_linear && c_is_linear && a_linear_var == b_linear_var && b_linear_var == c_linear_var { + is_quadratic = true; + } else { + return (false, (zero, zero, zero)); + } + } + + if is_quadratic { + // something like (v - 1) * (v - 1) = (v - 1) + // and we can make a quadratic gate + + let mut quadratic_term = a_linear_var_coeff; + quadratic_term.mul_assign(&b_linear_var_coeff); + + let mut linear_term_0 = a_constant_coeff; + linear_term_0.mul_assign(&b_linear_var_coeff); + + let mut linear_term_1 = b_constant_coeff; + linear_term_1.mul_assign(&a_linear_var_coeff); + + let mut linear_term = linear_term_0; + linear_term.add_assign(&linear_term_1); + if c_is_linear { + linear_term.sub_assign(&c_linear_var_coeff); + } + + let mut constant_term = a_constant_coeff; + constant_term.mul_assign(&b_constant_coeff); + + if c_constant_coeff != zero { + constant_term.sub_assign(&c_constant_coeff); + } + + return (true, (constant_term, linear_term, quadratic_term)); + } + + (false, (zero, zero, zero)) +} + +fn check_for_quadratic_gate( + a: &LinearCombination, + b: &LinearCombination, + c: &LinearCombination, + a_constant_term: E::Fr, + b_constant_term: E::Fr, + c_constant_term: E::Fr, +) -> (bool, (E::Fr, E::Fr, E::Fr)) { + let zero = E::Fr::zero(); + + let a_is_linear = a.0.len() == 1; + let b_is_linear = b.0.len() == 1; + let c_is_linear = c.0.len() == 1; + + let c_is_empty = c.0.len() == 0; + + let mut a_linear_var_coeff = E::Fr::zero(); + let mut b_linear_var_coeff = E::Fr::zero(); + let mut c_linear_var_coeff = E::Fr::zero(); + + let mut is_quadratic = false; + if c_is_empty { + if a_is_linear && b_is_linear { + let (a_linear_var, a_coeff) = a.0[0]; + let (b_linear_var, b_coeff) = b.0[0]; + a_linear_var_coeff = a_coeff; + b_linear_var_coeff = b_coeff; + + is_quadratic = a_linear_var == b_linear_var; + } + } else { + if a_is_linear && b_is_linear && c_is_linear { + let (a_linear_var, a_coeff) = a.0[0]; + let (b_linear_var, b_coeff) = b.0[0]; + let (c_linear_var, c_coeff) = c.0[0]; + + a_linear_var_coeff = a_coeff; + b_linear_var_coeff = b_coeff; + c_linear_var_coeff = c_coeff; + + is_quadratic = a_linear_var == b_linear_var && b_linear_var == c_linear_var; + } + } + + if is_quadratic { + // something like (v - 1) * (v - 1) = (v - 1) + // and we can make a quadratic gate + + let mut quadratic_term = a_linear_var_coeff; + quadratic_term.mul_assign(&b_linear_var_coeff); + + let mut linear_term_0 = a_constant_term; + linear_term_0.mul_assign(&b_linear_var_coeff); + + let mut linear_term_1 = b_constant_term; + linear_term_1.mul_assign(&a_linear_var_coeff); + + let mut linear_term = linear_term_0; + linear_term.add_assign(&linear_term_1); + if c_is_linear { + linear_term.sub_assign(&c_linear_var_coeff); + } + + let mut constant_term = a_constant_term; + constant_term.mul_assign(&b_constant_term); + + if c_constant_term != zero { + constant_term.sub_assign(&c_constant_term); + } + + return (true, (constant_term, linear_term, quadratic_term)); + } + + (false, (zero, zero, zero)) +} + +fn is_constant>(lc: &LinearCombination) -> (bool, E::Fr) { + // formally it's an empty LC, so it's a constant 0 + if lc.as_ref().len() == 0 { + return (true, E::Fr::zero()); + } + + let result = get_constant_term::(&lc); + + if result.0 && lc.as_ref().len() == 1 { + return result; + } + + (false, E::Fr::zero()) +} + +fn get_constant_term>(lc: &LinearCombination) -> (bool, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var == &cs_one { + return (true, *coeff); + } + } + + (false, E::Fr::zero()) +} + +fn get_first_variable>(lc: &LinearCombination) -> (bool, Variable) { + let cs_one = CS::one(); + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var); + } + } + + (false, cs_one) +} + +fn get_first_variable_with_coeff>(lc: &LinearCombination) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var, *coeff); + } + } + + (false, cs_one, E::Fr::zero()) +} + +fn num_unique_values>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, usize) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut contains_constant = false; + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + } else { + contains_constant = true; + } + } + + let num_unique_without_constant = scratch.len(); + + scratch.clear(); + + (contains_constant, num_unique_without_constant) +} + +fn is_linear_term>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut linear_coeff = E::Fr::zero(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + linear_coeff = *coeff; + } + } + + let num_unique_without_constant = scratch.len(); + + if num_unique_without_constant == 1 { + let terms: Vec<_> = scratch.drain().collect(); + let term = terms[0]; + + return (true, term, linear_coeff) + } else { + scratch.clear(); + + return (false, cs_one, E::Fr::zero()) + } +} + +fn deduplicate_stable>( + lc: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return lc; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc.as_ref().len()); + + for (var, coeff) in lc.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn deduplicate_and_split_linear_term>( + lc: LinearCombination, + scratch: &mut HashMap +) -> (bool, E::Fr, bool, LinearCombination) { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return (true, E::Fr::zero(), true, lc); + } + + let cs_one = CS::one(); + let mut constant_term = E::Fr::zero(); + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc.as_ref().len()); + + for (var, coeff) in lc.0.into_iter() { + if var != cs_one { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } else { + constant_term.add_assign(&coeff); + } + } + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + scratch.clear(); + + let has_constant = !constant_term.is_zero(); + let lc_is_empty = deduped_vec.len() == 0; + + (has_constant, constant_term, lc_is_empty, LinearCombination(deduped_vec)) +} + +fn subtract_lcs_with_dedup_stable>( + lc_0: LinearCombination, + lc_1: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc_0.as_ref().len() == 0 && lc_1.as_ref().len() == 0{ + return lc_0; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc_0.as_ref().len() + lc_1.as_ref().len()); + + for (var, coeff) in lc_0.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + for (var, coeff) in lc_1.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.sub_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + let mut coeff_negated = coeff; + coeff_negated.negate(); + deduped_vec.push((var, coeff_negated)); + scratch.insert(var, new_idx); + } + } + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn subtract_variable_unchecked( + lc: &mut LinearCombination, + variable: Variable +) { + let mut minus_one = E::Fr::one(); + minus_one.negate(); + + lc.0.push((variable, minus_one)); +} + +fn split_constant_term>( + mut lc: LinearCombination, +) -> (LinearCombination, E::Fr) { + if lc.as_ref().len() == 0 { + return (lc, E::Fr::zero()); + } + + let mut idx = None; + let cs_one = CS::one(); + let mut constant_coeff = E::Fr::zero(); + + for (i, (var, coeff)) in lc.0.iter().enumerate() { + if var == &cs_one { + idx = Some(i); + constant_coeff = *coeff; + break; + } + } + + if let Some(idx) = idx { + let _ = lc.0.swap_remove(idx); + return (lc, constant_coeff); + } else { + return (lc, constant_coeff); + } +} + + +pub struct Adaptor<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> { + cs: &'a mut CS, + hints: &'a Vec<(usize, TranspilationVariant)>, + current_constraint_index: usize, + current_hint_index: usize, + scratch: HashSet, + // deduplication_scratch: HashMap, + deduplication_scratch: HashMap, + transpilation_scratch_space: Option>, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

, +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> Adaptor<'a, E, P, CS> { + fn get_next_hint(&mut self) -> (usize, TranspilationVariant) { + let current_hint_index = self.current_hint_index; + let expected_constraint_index = self.current_constraint_index; + + let next_hint = self.hints[current_hint_index].clone(); + + assert!(next_hint.0 == expected_constraint_index); + + self.current_hint_index += 1; + self.current_constraint_index += 1; + + next_hint + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> crate::ConstraintSystem + for Adaptor<'a, E, P, CS> +{ + type Root = Self; + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Aux(index)) => crate::Variable::new_unchecked(crate::Index::Aux(index)), + _ => unreachable!("Map aux into aux"), + }) + } + + fn alloc_input( + &mut self, + _: A, + f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc_input(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Input(index)) => crate::Variable::new_unchecked(crate::Index::Input(index)), + _ => unreachable!("Map input into input"), + }) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (_, hint) = { + self.get_next_hint() + }; + + let _hint = hint.clone(); + + // we need to determine the type of transformation constraint + + // let's handle trivial cases first + + // A or B or C are just constant terms + + let (a_has_constant, a_constant_term, a_lc_is_empty, a_lc) = deduplicate_and_split_linear_term::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (b_has_constant, b_constant_term, b_lc_is_empty, b_lc) = deduplicate_and_split_linear_term::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (c_has_constant, c_constant_term, c_lc_is_empty, c_lc) = deduplicate_and_split_linear_term::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + + let a_is_constant = a_has_constant & a_lc_is_empty; + let b_is_constant = b_has_constant & b_lc_is_empty; + let c_is_constant = c_has_constant & c_lc_is_empty; + + let dummy_var = self.cs.get_dummy_variable(); + + // variables are left, right, output + // coefficients are left, right, output, multiplication, constant + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + match hint { + TranspilationVariant::IntoQuadraticGate => { + let var = if !a_lc_is_empty { + convert_variable(a_lc.0[0].0) + } else if !b_lc_is_empty { + convert_variable(b_lc.0[0].0) + } else if !c_lc_is_empty { + convert_variable(c_lc.0[0].0) + } else { + unreachable!(); + }; + + let (is_quadratic, coeffs) = check_for_quadratic_gate( + &a_lc, + &b_lc, + &c_lc, + a_constant_term, + b_constant_term, + c_constant_term + ); + + debug_assert!(is_quadratic); + + let (c0, c1, c2) = coeffs; + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs[0] = c1; + space.scratch_space_for_coeffs.push(c2); + space.scratch_space_for_coeffs.push(c0); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*A + A + const == A*(B=A) + A + const + space.scratch_space_for_vars[0] = var; + space.scratch_space_for_vars[1] = var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a quadratic gate"); + }, + TranspilationVariant::IntoMultiplicationGate(hints) => { + + let (t_a, t_b, t_c) = hints; + let mut q_m = one_fr; + let mut q_c = one_fr; + let a_var = match t_a { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_a_var, a_coeff, _variant) = enforce_lc_as_gates( + self.cs, + a_lc, + one_fr, + a_constant_term, + true, + &mut space + ).expect("must allocate A variable to transpile A LC for multiplication gate"); + + assert!(a_coeff == one_fr); + + assert!(_variant == hint); + + new_a_var.expect("transpiler must create a new variable for LC A") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!a_lc_is_empty); + let (var, coeff) = a_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeff before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_a)} + }; + + let b_var = match t_b { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_b_var, b_coeff, _variant) = enforce_lc_as_gates( + self.cs, + b_lc, + one_fr, + b_constant_term, + true, + &mut space + ).expect("must allocate B variable to transpile B LC for multiplication gate"); + + assert!(b_coeff == one_fr); + + assert!(_variant == hint); + + new_b_var.expect("transpiler must create a new variable for LC B") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!b_lc_is_empty); + let (var, coeff) = b_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeffs before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_b)} + }; + + let (c_is_just_a_constant, c_var) = match t_c { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_c_var, c_coeff, _variant) = enforce_lc_as_gates( + self.cs, + c_lc, + one_fr, + c_constant_term, + true, + &mut space + ).expect("must allocate C variable to transpile C LC for multiplication gate"); + + assert!(c_coeff == one_fr); + + assert!(_variant == hint); + + (false, Some(new_c_var.expect("transpiler must create a new variable for LC C"))) + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!c_lc_is_empty); + let (var, coeff) = c_lc.0[0]; + q_c = coeff; + + (false, Some(convert_variable(var))) + }, + LcTransformationVariant::IsConstant => { + assert!(c_lc_is_empty); + assert!(c_has_constant); + + (true, None) + }, + }; + + if c_is_just_a_constant { + let mut constant_term = c_constant_term; + constant_term.negate(); // - C + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs.push(q_m); + space.scratch_space_for_coeffs.push(constant_term); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*B + const == 0 + space.scratch_space_for_vars[0] = a_var; + space.scratch_space_for_vars[1] = b_var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a multiplication gate with C being constant"); + } else { + // Plain multiplication gate + + q_c.negate(); // - C + + let c_var = c_var.expect("C must be a variable"); + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs[2] = q_c; + space.scratch_space_for_coeffs.push(q_m); + space.scratch_space_for_coeffs.push(zero_fr); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*B - C == 0 + space.scratch_space_for_vars[0] = a_var; + space.scratch_space_for_vars[1] = b_var; + space.scratch_space_for_vars[2] = c_var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a plain multiplication gate"); + } + }, + // make an addition gate + TranspilationVariant::IntoAdditionGate(hint) => { + // these are simple enforcements that are not a part of multiplication gate + // or merge of LCs + + if c_is_constant { + let lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!("Either A or B LCs are constant"); + }; + + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!("Must take multiplier from A or B"); + }; + + let mut free_constant_term = if a_is_constant { + b_constant_term + } else if b_is_constant { + a_constant_term + } else { + unreachable!("Either A or B LCs are constant"); + }; + + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + let (_, _, _variant) = enforce_lc_as_gates( + self.cs, + lc, + multiplier, + free_constant_term, + false, + &mut space + ).expect("must allocate variable to transpile LC == 0 gate"); + + assert!(hint == _variant); + } else { + // c is not a constant and it's handled by MergeLCs + unreachable!(); + } + }, + TranspilationVariant::MergeLinearCombinations(merge_variant, merge_hint) => { + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!() + }; + + let mut free_constant_term; + + let lc_into_rewriting = match merge_variant { + MergeLcVariant::MergeACThroughConstantB => { + assert!(b_is_constant); + let mut final_lc = a_lc; + free_constant_term = a_constant_term; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + free_constant_term.mul_assign(&multiplier); + } + + free_constant_term.sub_assign(&c_constant_term); + + subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::MergeBCThroughConstantA => { + assert!(a_is_constant); + let mut final_lc = b_lc; + free_constant_term = b_constant_term; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + free_constant_term.mul_assign(&multiplier); + } + + free_constant_term.sub_assign(&c_constant_term); + + subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::CIsTheOnlyMeaningful => { + free_constant_term = a_constant_term; + free_constant_term.mul_assign(&b_constant_term); + free_constant_term.negate(); + free_constant_term.add_assign(&c_constant_term); + + c_lc + }, + _ => { + unreachable!() + } + }; + + let h = merge_hint; + + match h { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_c_var, _coeff, _variant) = enforce_lc_as_gates( + self.cs, + lc_into_rewriting, + one_fr, + free_constant_term, + false, + &mut space + ).expect("must allocate gates to transpile merging of LCs"); + + assert!(_coeff == one_fr); + + assert!(new_c_var.is_none()); + assert!(_variant == hint); + }, + _ => { + unreachable!("{:?}", h); + } + }; + } + } + + space.clear(); + self.transpilation_scratch_space = Some(space); + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +fn convert_variable(r1cs_variable: crate::Variable) -> PlonkVariable { + let var = match r1cs_variable.get_unchecked() { + crate::Index::Input(0) => {unreachable!("can not convert input variable number 0 (CS::one)")}, + crate::Index::Aux(0) => {unreachable!("can not convert aux variable labeled as 0 (taken by Plonk CS)")}, + crate::Index::Input(i) => PlonkVariable(PlonkIndex::Input(i)), + crate::Index::Aux(i) => PlonkVariable(PlonkIndex::Aux(i)), + }; + + var +} + +fn convert_variable_back(plonk_variable: PlonkVariable) -> crate::Variable { + let var = match plonk_variable.get_unchecked() { + crate::plonk::cs::variable::Index::Input(0) => {unreachable!("can not convert input variable number 0 (does not exist in plonk)")}, + crate::plonk::cs::variable::Index::Aux(0) => {unreachable!("can not convert aux variable labeled as 0 (does not exist in plonk, dummy gate)")}, + crate::plonk::cs::variable::Index::Input(i) => crate::Variable(crate::Index::Input(i)), + crate::plonk::cs::variable::Index::Aux(i) => crate::Variable(crate::Index::Aux(i)), + }; + + var +} + +use std::cell::Cell; + +pub struct AdaptorCircuit<'a, E:Engine, P: PlonkConstraintSystemParams, C: crate::Circuit>{ + circuit: Cell>, + hints: &'a Vec<(usize, TranspilationVariant)>, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

, +} + +impl<'a, E:Engine, P: PlonkConstraintSystemParams, C: crate::Circuit> AdaptorCircuit<'a, E, P, C> { + pub fn new<'b>(circuit: C, hints: &'b Vec<(usize, TranspilationVariant)>) -> Self + where 'b: 'a + { + Self { + circuit: Cell::new(Some(circuit)), + hints: hints, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + } + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, C: crate::Circuit> PlonkCircuit for AdaptorCircuit<'a, E, P, C> { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let mut adaptor = Adaptor:: { + cs: cs, + hints: self.hints, + current_constraint_index: 0, + current_hint_index: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + transpilation_scratch_space: Some(TranspilationScratchSpace::new(P::STATE_WIDTH * 2)), + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + }; + + let c = self.circuit.replace(None).expect("Must replace a circuit out from cell"); + + c.synthesize(&mut adaptor) + } +} + +#[test] +fn transpile_xor_using_new_adaptor() { + use crate::tests::XORDemo; + use crate::cs::Circuit; + use crate::pairing::bn256::{Bn256, Fr}; + use super::test_assembly::*; + use super::cs::PlonkCsWidth4WithNextStepParams; + use super::generator::*; + use super::prover::*; + use crate::worker::Worker; + use super::verifier::*; + use crate::kate_commitment::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transcript::keccak_transcript::*; + use crate::plonk::fft::cooley_tukey_ntt::*; + use super::keys::*; + use crate::plonk::domains::Domain; + use super::utils::make_non_residues; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let mut transpiler = Transpiler::::new(); + + c.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let hints = transpiler.hints; + + for (constraint_id, hint) in hints.iter() { + println!("Constraint {} into {:?}", constraint_id, hint); + } + + // let c = XORDemo:: { + // a: None, + // b: None, + // _marker: PhantomData + // }; + + let c = XORDemo:: { + a: Some(true), + b: Some(false), + _marker: PhantomData + }; + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + + let mut assembly = TestAssembly::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + let num_gates = assembly.num_gates(); + println!("Transpiled into {} gates", num_gates); + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + assembly.finalize(); + + let worker = Worker::new(); + + let setup = assembly.setup(&worker).unwrap(); + + let crs_mons = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + let crs_vals = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs_mons + ).unwrap(); + + let precomputations = SetupPolynomialsPrecomputations::from_setup( + &setup, + &worker + ).unwrap(); + + let mut assembly = ProverAssembly4WithNextStep::::new(); + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + + adapted_curcuit.synthesize(&mut assembly).expect("must work"); + + assembly.finalize(); + + let size = setup.permutation_polynomials[0].size(); + + let domain = Domain::::new_for_size(size as u64).unwrap(); + let non_residues = make_non_residues::(3); + println!("Non residues = {:?}", non_residues); + + type Transcr = RollingKeccakTranscript; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + let proof = assembly.prove::( + &worker, + &setup, + &precomputations, + &crs_vals, + &crs_mons, + &omegas_bitreversed, + &omegas_inv_bitreversed, + None + ).unwrap(); + + let is_valid = verify::(&proof, &verification_key, None).unwrap(); + + assert!(is_valid); + + // println!("Verification key = {:?}", verification_key); + // println!("Proof = {:?}", proof); + + let mut key_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_vk.key").unwrap() + ); + verification_key.write(&mut key_writer).unwrap(); + + let mut proof_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_proof.proof").unwrap() + ); + proof.write(&mut proof_writer).unwrap(); +} + +#[test] +fn transpile_xor_and_prove_with_no_precomputations() { + use crate::tests::XORDemo; + use crate::cs::Circuit; + use crate::pairing::bn256::{Bn256, Fr}; + use super::test_assembly::*; + use super::cs::PlonkCsWidth4WithNextStepParams; + use super::generator::*; + use super::prover::*; + use crate::worker::Worker; + use super::verifier::*; + use crate::kate_commitment::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transcript::keccak_transcript::*; + use crate::plonk::fft::cooley_tukey_ntt::*; + use super::keys::*; + use crate::plonk::domains::Domain; + use super::utils::make_non_residues; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let mut transpiler = Transpiler::::new(); + + c.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let hints = transpiler.hints; + + for (constraint_id, hint) in hints.iter() { + println!("Constraint {} into {:?}", constraint_id, hint); + } + + // let c = XORDemo:: { + // a: None, + // b: None, + // _marker: PhantomData + // }; + + let c = XORDemo:: { + a: Some(true), + b: Some(false), + _marker: PhantomData + }; + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + + let mut assembly = TestAssembly::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + let num_gates = assembly.num_gates(); + println!("Transpiled into {} gates", num_gates); + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + assembly.finalize(); + + let worker = Worker::new(); + + let setup = assembly.setup(&worker).unwrap(); + + let crs_mons = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs_mons + ).unwrap(); + + let size = setup.permutation_polynomials[0].size(); + + let domain = Domain::::new_for_size(size as u64).unwrap(); + let non_residues = make_non_residues::(3); + println!("Non residues = {:?}", non_residues); + + type Transcr = RollingKeccakTranscript; + + let proof = super::super::prove_by_steps::<_, _, Transcr>( + c, + &hints, + &setup, + None, + &crs_mons, + None + ).unwrap(); + + let is_valid = verify::(&proof, &verification_key, None).unwrap(); + + assert!(is_valid); + + // println!("Verification key = {:?}", verification_key); + // println!("Proof = {:?}", proof); + + let mut key_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_vk.key").unwrap() + ); + verification_key.write(&mut key_writer).unwrap(); + + let mut proof_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_proof.proof").unwrap() + ); + proof.write(&mut proof_writer).unwrap(); +} \ No newline at end of file diff --git a/src/plonk/better_cs/cs.rs b/src/plonk/better_cs/cs.rs new file mode 100644 index 000000000..9965b2636 --- /dev/null +++ b/src/plonk/better_cs/cs.rs @@ -0,0 +1,270 @@ +use crate::pairing::ff::{Field}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +pub use crate::plonk::cs::variable::*; + +pub trait Circuit> { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError>; +} + +pub trait CustomGateMarker: Sized {} + +// pub trait TraceStepCoefficients<'a, E: Engine>: Sized +// + AsRef<[E::Fr]> +// + Copy +// + Clone +// + PartialEq +// + Eq +// + ExactSizeIterator { } + +// pub trait PlonkConstraintSystemParams where +// for <'a> T1: TraceStepCoefficients<'a, E>, +// for <'a> T2: TraceStepCoefficients<'a, E> { +// const STATE_WIDTH: usize; +// const HAS_CUSTOM_GATES: bool; +// const CAN_ACCESS_NEXT_TRACE_STEP: bool; + +// type CustomGateType: CustomGateMarker; +// } + +pub trait TraceStepCoefficients: Sized + + AsRef<[E::Fr]> + + Copy + + Clone + + PartialEq + + Eq { + fn empty() -> Self; + fn identity() -> Self; + fn negate(&mut self); + fn from_coeffs(coeffs: &[E::Fr]) -> Self; + } + +pub trait StateVariablesSet: Sized + AsRef<[Variable]> + Copy + Clone + PartialEq + Eq { + fn from_variable_and_padding(variable: Variable, padding: Variable) -> Self; + fn from_variables(variables: &[Variable]) -> Self; +} + +pub trait PlonkConstraintSystemParams: Clone { + const STATE_WIDTH: usize; + const HAS_CUSTOM_GATES: bool; + const CAN_ACCESS_NEXT_TRACE_STEP: bool; + + type StateVariables: StateVariablesSet; + type ThisTraceStepCoefficients: TraceStepCoefficients; + type NextTraceStepCoefficients: TraceStepCoefficients; + + type CustomGateType: CustomGateMarker; +} + +pub trait ConstraintSystem> { + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + fn new_gate(&mut self, + variables: P::StateVariables, + this_step_coeffs: P::ThisTraceStepCoefficients, + next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError>; + + fn get_value(&self, _variable: Variable) -> Result { + Err(SynthesisError::AssignmentMissing) + } + + fn get_dummy_variable(&self) -> Variable; +} + + +pub struct NoCustomGate; +impl CustomGateMarker for NoCustomGate {} + +impl StateVariablesSet for [Variable; 3] { + fn from_variable_and_padding(variable: Variable, padding: Variable) -> Self { + [variable, padding, padding] + } + fn from_variables(variables: &[Variable]) -> Self { + debug_assert_eq!(variables.len(), 3); + + [variables[0], variables[1], variables[2]] + } +} + +impl StateVariablesSet for [Variable; 4] { + fn from_variable_and_padding(variable: Variable, padding: Variable) -> Self { + [variable, padding, padding, padding] + } + fn from_variables(variables: &[Variable]) -> Self { + debug_assert_eq!(variables.len(), 4); + + [variables[0], variables[1], variables[2], variables[3]] + } +} + +// impl TraceStepCoefficients for () { +// fn empty() -> Self { +// () +// } +// fn identity() -> Self { +// () +// } +// fn from_coeffs(coeffs: &[E::Fr]) -> Self { +// debug_assert_eq!(coeffs.len(), 0); + +// () +// } +// } + +// impl AsRef<[E::Fr]> for () { +// fn as_ref(&self) -> &[E::Fr] { +// &[] +// } +// } + +impl TraceStepCoefficients for [E::Fr; 0] { + fn empty() -> Self { + [] + } + fn identity() -> Self { + [] + } + fn negate(&mut self) { + + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 0); + + [] + } +} + +impl TraceStepCoefficients for [E::Fr; 1] { + fn empty() -> Self { + [E::Fr::zero()] + } + fn identity() -> Self { + [E::Fr::one()] + } + fn negate(&mut self) { + for c in self.iter_mut() { + c.negate(); + } + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 1); + + [coeffs[0]] + } +} + +impl TraceStepCoefficients for [E::Fr; 3] { + fn empty() -> Self { + [E::Fr::zero(); 3] + } + fn identity() -> Self { + [E::Fr::one(), E::Fr::zero(), E::Fr::zero()] + } + fn negate(&mut self) { + for c in self.iter_mut() { + c.negate(); + } + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 3); + + [coeffs[0], coeffs[1], coeffs[2]] + } +} + +impl TraceStepCoefficients for [E::Fr; 4] { + fn empty() -> Self { + [E::Fr::zero(); 4] + } + fn identity() -> Self { + [E::Fr::one(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero()] + } + fn negate(&mut self) { + for c in self.iter_mut() { + c.negate(); + } + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 4); + + [coeffs[0], coeffs[1], coeffs[2], coeffs[3]] + } +} + +impl TraceStepCoefficients for [E::Fr; 5] { + fn empty() -> Self { + [E::Fr::zero(); 5] + } + fn identity() -> Self { + [E::Fr::one(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero()] + } + fn negate(&mut self) { + for c in self.iter_mut() { + c.negate(); + } + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 5); + + [coeffs[0], coeffs[1], coeffs[2], coeffs[3], coeffs[4]] + } +} + +impl TraceStepCoefficients for [E::Fr; 6] { + fn empty() -> Self { + [E::Fr::zero(); 6] + } + fn identity() -> Self { + [E::Fr::one(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero(), E::Fr::zero()] + } + fn negate(&mut self) { + for c in self.iter_mut() { + c.negate(); + } + } + fn from_coeffs(coeffs: &[E::Fr]) -> Self { + debug_assert_eq!(coeffs.len(), 6); + + [coeffs[0], coeffs[1], coeffs[2], coeffs[3], coeffs[4], coeffs[5]] + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct PlonkCsWidth3WithNextStepParams; +impl PlonkConstraintSystemParams for PlonkCsWidth3WithNextStepParams { + const STATE_WIDTH: usize = 3; + const HAS_CUSTOM_GATES: bool = false; + const CAN_ACCESS_NEXT_TRACE_STEP: bool = true; + + type StateVariables = [Variable; 3]; + type ThisTraceStepCoefficients = [E::Fr; 5]; + type NextTraceStepCoefficients = [E::Fr; 1]; + + type CustomGateType = NoCustomGate; +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct PlonkCsWidth4WithNextStepParams; +impl PlonkConstraintSystemParams for PlonkCsWidth4WithNextStepParams { + const STATE_WIDTH: usize = 4; + const HAS_CUSTOM_GATES: bool = false; + const CAN_ACCESS_NEXT_TRACE_STEP: bool = true; + + type StateVariables = [Variable; 4]; + type ThisTraceStepCoefficients = [E::Fr; 6]; + type NextTraceStepCoefficients = [E::Fr; 1]; + + type CustomGateType = NoCustomGate; +} diff --git a/src/plonk/better_cs/fma_adaptor.rs b/src/plonk/better_cs/fma_adaptor.rs new file mode 100644 index 000000000..87d9b3429 --- /dev/null +++ b/src/plonk/better_cs/fma_adaptor.rs @@ -0,0 +1,2473 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::SynthesisError; + +use super::cs::{PlonkConstraintSystemParams, StateVariablesSet, TraceStepCoefficients}; +use crate::plonk::cs::gates::Variable as PlonkVariable; +use crate::plonk::cs::gates::Index as PlonkIndex; + +use super::cs::Circuit as PlonkCircuit; +use super::cs::ConstraintSystem as PlonkConstraintSystem; + +use std::marker::PhantomData; + +use std::collections::{HashSet, HashMap}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MergeLcVariant { + AIsTheOnlyMeaningful, + BIsTheOnlyMeaningful, + MergeABWithConstantC, + MergeACThroughConstantB, + MergeBCThroughConstantA, + CIsTheOnlyMeaningful, +} + +impl MergeLcVariant { + pub fn into_u8(&self) -> u8 { + match self { + MergeLcVariant::AIsTheOnlyMeaningful => 1u8, + MergeLcVariant::BIsTheOnlyMeaningful => 2u8, + MergeLcVariant::MergeABWithConstantC => 3u8, + MergeLcVariant::MergeACThroughConstantB => 4u8, + MergeLcVariant::MergeBCThroughConstantA => 5u8, + MergeLcVariant::CIsTheOnlyMeaningful => 6u8, + } + } + + pub fn from_u8(value: u8) -> std::io::Result { + let s = match value { + 1u8 => MergeLcVariant::AIsTheOnlyMeaningful, + 2u8 => MergeLcVariant::BIsTheOnlyMeaningful, + 3u8 => MergeLcVariant::MergeABWithConstantC, + 4u8 => MergeLcVariant::MergeACThroughConstantB, + 5u8 => MergeLcVariant::MergeBCThroughConstantA, + 6u8 => MergeLcVariant::CIsTheOnlyMeaningful, + _ => { + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown LC merging variant"); + + return Err(custom_error); + } + }; + + Ok(s) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LcTransformationVariant { + IsSingleVariable, + IntoSingleGate, + IntoMultipleGates, + IsConstant, +} + +impl LcTransformationVariant { + pub fn into_u8(&self) -> u8 { + match self { + LcTransformationVariant::IsSingleVariable => 1u8, + LcTransformationVariant::IntoSingleGate => 2u8, + LcTransformationVariant::IntoMultipleGates => 3u8, + LcTransformationVariant::IsConstant => 4u8, + } + } + + pub fn from_u8(value: u8) -> std::io::Result { + let s = match value { + 1u8 => LcTransformationVariant::IsSingleVariable, + 2u8 => LcTransformationVariant::IntoSingleGate, + 3u8 => LcTransformationVariant::IntoMultipleGates, + 4u8 => LcTransformationVariant::IsConstant, + _ => { + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown LC transformation variant"); + + return Err(custom_error); + } + }; + + Ok(s) + } +} + +struct TranspilationScratchSpace { + scratch_space_for_vars: Vec, + scratch_space_for_coeffs: Vec, + scratch_space_for_booleans: Vec, +} + +impl TranspilationScratchSpace { + fn new(width: usize) -> Self { + Self { + scratch_space_for_vars: Vec::with_capacity(width), + scratch_space_for_coeffs: Vec::with_capacity(width), + scratch_space_for_booleans: Vec::with_capacity(width), + } + } + + fn clear(&mut self) { + self.scratch_space_for_vars.truncate(0); + self.scratch_space_for_coeffs.truncate(0); + self.scratch_space_for_booleans.truncate(0); + } +} + +// These are transpilation options over A * B - C = 0 constraint +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum TranspilationVariant { + IntoQuadraticGate, + IntoAdditionGate(LcTransformationVariant), + MergeLinearCombinations(MergeLcVariant, LcTransformationVariant), + IntoMultiplicationGate((LcTransformationVariant, LcTransformationVariant, LcTransformationVariant)), + IntoFMAGate((LcTransformationVariant, LcTransformationVariant, LcTransformationVariant)) +} + +use std::io::{Read, Write}; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use crate::byteorder::BigEndian; + +impl TranspilationVariant { + pub fn into_u8(&self) -> u8 { + match self { + TranspilationVariant::IntoQuadraticGate => 1u8, + TranspilationVariant::IntoAdditionGate(_) => 2u8, + TranspilationVariant::MergeLinearCombinations(_, _) => 3u8, + TranspilationVariant::IntoMultiplicationGate(_) => 4u8, + TranspilationVariant::IntoFMAGate(_) => 5u8, + } + } + + pub fn write( + &self, + mut writer: W + ) -> std::io::Result<()> + { + let prefix = self.into_u8(); + writer.write_u8(prefix)?; + match self { + TranspilationVariant::IntoAdditionGate(subhint) => { + let subhint = subhint.into_u8(); + writer.write_u8(subhint)?; + } + TranspilationVariant::MergeLinearCombinations(variant, subhint) => { + let variant = variant.into_u8(); + writer.write_u8(variant)?; + + let subhint = subhint.into_u8(); + writer.write_u8(subhint)?; + }, + TranspilationVariant::IntoMultiplicationGate(hints) => { + let (h_a, h_b, h_c) = hints; + writer.write_u8(h_a.into_u8())?; + writer.write_u8(h_b.into_u8())?; + writer.write_u8(h_c.into_u8())?; + }, + _ => { + } + } + + Ok(()) + } + + pub fn read( + mut reader: R + ) -> std::io::Result + { + let prefix = reader.read_u8()?; + + match prefix { + 1u8 => {return Ok(TranspilationVariant::IntoQuadraticGate); }, + 2u8 => { + let subhint = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::IntoAdditionGate(subhint)); + }, + 3u8 => { + let variant = MergeLcVariant::from_u8(reader.read_u8()?)?; + let subhint = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::MergeLinearCombinations(variant, subhint)); + }, + 4u8 => { + let subhint_a = LcTransformationVariant::from_u8(reader.read_u8()?)?; + let subhint_b = LcTransformationVariant::from_u8(reader.read_u8()?)?; + let subhint_c = LcTransformationVariant::from_u8(reader.read_u8()?)?; + + return Ok(TranspilationVariant::IntoMultiplicationGate((subhint_a, subhint_b, subhint_c))); + }, + _ => {} + } + + use std::io::{Error, ErrorKind}; + let custom_error = Error::new(ErrorKind::Other, "unknown transpilation variant"); + + Err(custom_error) + } +} + +pub fn read_transpilation_hints( + mut reader: R +) -> std::io::Result> { + let num_hints = reader.read_u64::()?; + let mut hints = Vec::with_capacity(num_hints as usize); + + for _ in 0..num_hints { + let idx = reader.read_u64::()?; + let hint = TranspilationVariant::read(&mut reader)?; + hints.push((idx as usize, hint)); + } + + Ok(hints) +} + +pub fn write_transpilation_hints( + hints: &Vec<(usize, TranspilationVariant)>, + mut writer: W +) -> std::io::Result<()> { + writer.write_u64::(hints.len() as u64)?; + for (idx, h) in hints.iter() { + writer.write_u64::(*idx as u64)?; + h.write(&mut writer)?; + } + + Ok(()) +} + +impl std::fmt::Debug for TranspilationVariant { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TranspilationVariant::IntoQuadraticGate => { + writeln!(f, "Variant: into quadratic gate")?; + }, + TranspilationVariant::IntoAdditionGate(_) => { + writeln!(f, "Variant: make an addition gate")?; + }, + TranspilationVariant::MergeLinearCombinations(merge_type, _) => { + writeln!(f, "Variant: merge linear combinations as {:?}", merge_type)?; + }, + TranspilationVariant::IntoMultiplicationGate(b) => { + writeln!(f, "Variant: into combinatoric multiplication gate")?; + writeln!(f, "A: {:?}", b.0)?; + writeln!(f, "B: {:?}", b.1)?; + writeln!(f, "C: {:?}", b.2)?; + }, + TranspilationVariant::IntoFMAGate(b) => { + writeln!(f, "Variant: into FMA gate")?; + writeln!(f, "A: {:?}", b.0)?; + writeln!(f, "B: {:?}", b.1)?; + writeln!(f, "C: {:?}", b.2)?; + }, + } + + Ok(()) + } +} + +pub struct Transpiler> { + current_constraint_index: usize, + current_plonk_input_idx: usize, + current_plonk_aux_idx: usize, + scratch: HashSet, + deduplication_scratch: HashMap, + transpilation_scratch_space: Option>, + hints: Vec<(usize, TranspilationVariant)>, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

+} + +// by convention last coefficient is a coefficient for a jump to the next step +fn allocate_into_cs, CS: PlonkConstraintSystem> ( + cs: &mut CS, + needs_next_step: bool, + variables: &[PlonkVariable], + coefficients: &[E::Fr] +) -> Result<(), SynthesisError> { + if needs_next_step { + debug_assert!(coefficients.len() == P::STATE_WIDTH + 1 + 1 + 1); + debug_assert!(P::CAN_ACCESS_NEXT_TRACE_STEP); + + cs.new_gate( + P::StateVariables::from_variables(variables), + P::ThisTraceStepCoefficients::from_coeffs(&coefficients[0..(P::STATE_WIDTH+2)]), + P::NextTraceStepCoefficients::from_coeffs(&coefficients[(P::STATE_WIDTH+2)..]) + )?; + } else { + debug_assert!(coefficients.len() >= P::STATE_WIDTH + 1 + 1); + debug_assert!(coefficients.last().unwrap().is_zero()); + + cs.new_gate( + P::StateVariables::from_variables(variables), + P::ThisTraceStepCoefficients::from_coeffs(&coefficients[0..(P::STATE_WIDTH+2)]), + P::NextTraceStepCoefficients::from_coeffs(&coefficients[(P::STATE_WIDTH+2)..]) + )?; + } + + Ok(()) +} + +fn evaluate_lc, CS: PlonkConstraintSystem>( + cs: &CS, + lc: &LinearCombination, + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in lc.as_ref().iter() { + let mut may_be_value = cs.get_value(convert_variable(*var))?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_variables, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[(Variable, E::Fr)], + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter() { + let mut may_be_value = cs.get_value(convert_variable(*var))?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_plonk_variables, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[(PlonkVariable, E::Fr)], + // multiplier: E::Fr, + free_term_constant: E::Fr +) -> Result { + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter() { + let mut may_be_value = cs.get_value(*var)?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn evaluate_over_plonk_variables_and_coeffs, CS: PlonkConstraintSystem>( + cs: &CS, + variables: &[PlonkVariable], + coeffs: &[E::Fr], + free_term_constant: E::Fr +) -> Result { + debug_assert_eq!(variables.len(), coeffs.len()); + let mut final_value = E::Fr::zero(); + for (var, coeff) in variables.iter().zip(coeffs.iter()) { + let mut may_be_value = cs.get_value(*var)?; + may_be_value.mul_assign(&coeff); + final_value.add_assign(&may_be_value); + } + + final_value.add_assign(&free_term_constant); + + Ok(final_value) +} + +fn enforce_lc_as_gates, CS: PlonkConstraintSystem>( + cs: &mut CS, + mut lc: LinearCombination, + multiplier: E::Fr, + free_term_constant: E::Fr, + collapse_into_single_variable: bool, // we use this when we later want to make a multiplication gate + try_fma: bool, // we indicate that we want to transpile C query + scratch_space: &mut TranspilationScratchSpace, +) -> Result<(Option, E::Fr, LcTransformationVariant, bool), SynthesisError> { + assert!(P::CAN_ACCESS_NEXT_TRACE_STEP, "Transliper only works for proof systems with access to next step"); + + assert!(scratch_space.scratch_space_for_vars.len() == 0); + assert!(scratch_space.scratch_space_for_coeffs.len() == 0); + assert!(scratch_space.scratch_space_for_booleans.len() == 0); + + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + // trivial case - single variable + + assert!(lc.0.len() > 0); + + if lc.0.len() == 1 { + if free_term_constant.is_zero() { + // this linear combination contains only one variable and no constant + // term, so we just leave it as is, + // but ONLY if we just need to collapse LC into a variable + if collapse_into_single_variable { + let (var, coeff) = lc.0[0]; + + return Ok((Some(convert_variable(var)), coeff, LcTransformationVariant::IsSingleVariable, false)); + } + } + } + + // everything else should be handled here by making a new variable + + // scale if necessary + if multiplier.is_zero() { + assert!(free_term_constant.is_zero()); + unreachable!(); + // it's a constraint 0 * LC = 0 + } else { + if multiplier != one_fr { + for (_, c) in lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + } + + // if we need to collaplse an LC into a single variable for + // future use we allocate it and then subtract it from linear combination + // to have an enforcement LC == 0 in all the cases + + let final_variable = if collapse_into_single_variable { + let may_be_new_value = evaluate_lc::(&*cs, &lc, free_term_constant); + let new_var = cs.alloc(|| { + may_be_new_value + })?; + + Some(new_var) + } else { + None + }; + + if let Some(var) = final_variable { + subtract_variable_unchecked(&mut lc, convert_variable_back(var)); + } + + let num_terms = lc.0.len(); + + // we have two options: + // - fit everything into a single gate (in case of number terms in the linear combination + // smaller than a width of the state) + // - make a required number of extra variables and chain it + + // this is a special case when we can make a gate + if try_fma && collapse_into_single_variable && num_terms == P::STATE_WIDTH + 1 { + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + + let mut it = lc.0.into_iter(); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + if idx == P::STATE_WIDTH { + break; + } + } + } + + let (fma_variable, c) = it.next().expect("must be a variable"); + assert_eq!(c, minus_one_fr); + + // no multiplication coefficient, + // but -1 to link to the next trace step (we enforce == 0) + scratch_space.scratch_space_for_coeffs.push(zero_fr); // no multiplication + scratch_space.scratch_space_for_coeffs.push(free_term_constant); // add constant + scratch_space.scratch_space_for_coeffs.push(minus_one_fr); // -1 for a d_next + + allocate_into_cs( + cs, + true, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + let hint = LcTransformationVariant::IntoSingleGate; + + return Ok((Some(convert_variable(fma_variable)), one_fr, hint, true)); + } + + if num_terms <= P::STATE_WIDTH { + // we can just make a single gate + + // fill the gate with nothing first and replace after + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + + let it = lc.0.into_iter(); + + // we can consume and never have leftovers + let mut idx = 0; + for (var, coeff) in it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + } + } + + // add multiplication coefficient, constant and next step one + + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(free_term_constant); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + + allocate_into_cs( + cs, + false, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + let hint = LcTransformationVariant::IntoSingleGate; + + return Ok((final_variable, one_fr, hint, false)); + } else { + // we can take: + // - STATE_WIDTH variables to form the first gate and place their sum into the last wire of the next gate + // - every time take STATE_WIDTH-1 variables and place their sum + last wire into the next gate last wire + + // we have also made a final variable already, so there is NO difference + let cycles = ((lc.0.len() - P::STATE_WIDTH) + (P::STATE_WIDTH - 2)) / (P::STATE_WIDTH - 1); // ceil + let mut it = lc.0.into_iter(); + + // this is a placeholder variable that must go into the + // corresponding trace polynomial at the NEXT time step + let mut next_step_var_in_chain = { + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + if idx == P::STATE_WIDTH { + break; + } + } + } + + // for a P::STATE_WIDTH variables we make a corresponding LC + // ~ a + b + c + d + constant. That will be equal to d_next + let may_be_new_intermediate_value = evaluate_over_plonk_variables_and_coeffs::( + &*cs, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs, + free_term_constant + ); + + // we manually allocate the new variable + let new_intermediate_var = cs.alloc(|| { + may_be_new_intermediate_value + })?; + + // no multiplication coefficient, + // but -1 to link to the next trace step (we enforce == 0) + scratch_space.scratch_space_for_coeffs.push(zero_fr); // no multiplication + scratch_space.scratch_space_for_coeffs.push(free_term_constant); // add constant + scratch_space.scratch_space_for_coeffs.push(minus_one_fr); // -1 for a d_next + + allocate_into_cs( + cs, + true, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + new_intermediate_var + }; + + // run over the rest + + // we can only take one less cause + // we've already used one of the variable + let consume_from_lc = P::STATE_WIDTH - 1; + for _ in 0..(cycles-1) { + scratch_space.scratch_space_for_vars.resize(consume_from_lc, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(consume_from_lc, false); + scratch_space.scratch_space_for_coeffs.resize(consume_from_lc, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + if idx == consume_from_lc { + break; + } + } + } + + // push +1 and the allocated variable from the previous step + + scratch_space.scratch_space_for_coeffs.push(one_fr); + scratch_space.scratch_space_for_vars.push(next_step_var_in_chain); + + let may_be_new_intermediate_value = evaluate_over_plonk_variables_and_coeffs::( + &*cs, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs, + zero_fr + ); + + let new_intermediate_var = cs.alloc(|| { + may_be_new_intermediate_value + })?; + + // no multiplication coefficient and no constant now, + // but -1 to link to the next trace step + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(minus_one_fr); + + allocate_into_cs( + cs, + true, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + + next_step_var_in_chain = new_intermediate_var; + } + + // final step - we just make a single gate, last one + { + scratch_space.scratch_space_for_vars.resize(P::STATE_WIDTH-1, cs.get_dummy_variable()); + scratch_space.scratch_space_for_booleans.resize(P::STATE_WIDTH-1, false); + scratch_space.scratch_space_for_coeffs.resize(P::STATE_WIDTH-1, zero_fr); + + // we can consume and never have leftovers + + let mut idx = 0; + for (var, coeff) in &mut it { + if scratch_space.scratch_space_for_booleans[idx] == false { + scratch_space.scratch_space_for_booleans[idx] = true; + scratch_space.scratch_space_for_coeffs[idx] = coeff; + scratch_space.scratch_space_for_vars[idx] = convert_variable(var); + idx += 1; + } + } + + assert!(idx < P::STATE_WIDTH); + // append d_next + scratch_space.scratch_space_for_vars.push(next_step_var_in_chain); + scratch_space.scratch_space_for_coeffs.push(one_fr); + + // no multiplication coefficient, no constant, no next step + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + scratch_space.scratch_space_for_coeffs.push(zero_fr); + + allocate_into_cs( + cs, + false, + &*scratch_space.scratch_space_for_vars, + &*scratch_space.scratch_space_for_coeffs + )?; + + scratch_space.clear(); + } + + assert!(it.next().is_none()); + + let hint = LcTransformationVariant::IntoMultipleGates; + + return Ok((final_variable, one_fr, hint, false)); + } +} + +impl> Transpiler { + pub fn new() -> Self { + Self { + current_constraint_index: 0, + current_plonk_input_idx: 0, + current_plonk_aux_idx: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + transpilation_scratch_space: Some(TranspilationScratchSpace::::new(P::STATE_WIDTH * 2)), + hints: vec![], + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + } + } + + pub fn into_hints(self) -> Vec<(usize, TranspilationVariant)> { + self.hints + } + + fn increment_lc_number(&mut self) -> usize { + let current_lc_number = self.current_constraint_index; + self.current_constraint_index += 1; + + current_lc_number + } +} + +impl> PlonkConstraintSystem for Transpiler { + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc( + self, + || "alloc aux var", + value)?; + + Ok(convert_variable(var)) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc_input( + self, + || "alloc input var", + value)?; + Ok(convert_variable(var)) + } + + fn new_gate(&mut self, + _variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + // Transpiler does NOT allocate any gates himself + Ok(()) + } + + fn get_dummy_variable(&self) -> PlonkVariable { + PlonkVariable::new_unchecked(PlonkIndex::Aux(0)) + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams> PlonkConstraintSystem for &'a mut Transpiler { + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc( + self, + || "alloc aux var", + value)?; + + Ok(convert_variable(var)) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let var = crate::ConstraintSystem::::alloc_input( + self, + || "alloc input var", + value)?; + Ok(convert_variable(var)) + } + + fn new_gate(&mut self, + _variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + // Transpiler does NOT allocate any gates himself + Ok(()) + } + + fn get_dummy_variable(&self) -> PlonkVariable { + PlonkVariable::new_unchecked(PlonkIndex::Aux(0)) + } +} + +impl> crate::ConstraintSystem for Transpiler +{ + type Root = Self; + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, _f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + self.current_plonk_aux_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Aux(self.current_plonk_aux_idx))) + } + + fn alloc_input( + &mut self, + _: A, + _f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + self.current_plonk_input_idx += 1; + + Ok(crate::Variable::new_unchecked(crate::Index::Input(self.current_plonk_input_idx))) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + // let ann: String = _ann().into(); + // if ann.contains("y-coordinate lookup") { + // // + // let _t = E::Fr::one(); + // }; + // println!("Enforce {}", ann); + + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + + let mut negative_one_fr = E::Fr::one(); + negative_one_fr.negate(); + + // we need to determine the type of transformation constraint + + // let's handle trivial cases first + + // A or B or C are just constant terms + + let (a_has_constant, a_constant_term, a_lc_is_empty, a_lc) = deduplicate_and_split_linear_term::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (b_has_constant, b_constant_term, b_lc_is_empty, b_lc) = deduplicate_and_split_linear_term::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (c_has_constant, c_constant_term, c_lc_is_empty, c_lc) = deduplicate_and_split_linear_term::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + + let a_is_constant = a_has_constant & a_lc_is_empty; + let b_is_constant = b_has_constant & b_lc_is_empty; + let c_is_constant = c_has_constant & c_lc_is_empty; + + // debug_assert!(a_has_constant || !a_lc_is_empty); + // debug_assert!(b_has_constant || !b_lc_is_empty); + // debug_assert!(c_has_constant || !c_lc_is_empty); + + match (a_is_constant, b_is_constant, c_is_constant) { + (true, true, true) => { + unreachable!("R1CS has a gate 1 * 1 = 1"); + }, + (true, false, true) | (false, true, true) => { + // println!("C * LC = C"); + // we have something like c0 * LC = c1 + // do we form an "addition gate", that may take more than + // one gate itself + let lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!("Either A or B LCs are constant"); + }; + + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!("Must take multiplier from A or B"); + }; + + let mut free_constant_term = if a_is_constant { + b_constant_term + } else if b_is_constant { + a_constant_term + } else { + unreachable!("Either A or B LCs are constant"); + }; + + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint, _) = enforce_lc_as_gates( + self, + lc, + multiplier, + free_constant_term, + false, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * LC = c1"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, TranspilationVariant::IntoAdditionGate(hint))); + + return; + }, + (false, false, true) => { + // println!("LC * LC = C"); + // potential quadatic gate, but ig general + // it's a full multiplication gate + let (is_quadratic_gate, _coeffs) = check_for_quadratic_gate::( + &a_lc, + &b_lc, + &c_lc, + a_constant_term, + b_constant_term, + c_constant_term + ); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::IntoQuadraticGate; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_new_a_var, _, hint_a, _) = enforce_lc_as_gates( + self, + a_lc, + one_fr, + a_constant_term, + true, + false, + &mut space + ).expect("must allocate A LC as gates for constraint like LC * LC = c1"); + + let (_new_b_var, _, hint_b, _) = enforce_lc_as_gates( + self, + b_lc, + one_fr, + b_constant_term, + true, + false, + &mut space + ).expect("must allocate B LC as gates for constraint like LC * LC = c1"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint_c = LcTransformationVariant::IsConstant; + + let hint = TranspilationVariant::IntoMultiplicationGate((hint_a, hint_b, hint_c)); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (true, false, false) | (false, true, false) => { + // sometihng like LC * const = LC + // so we can merge them into one long linear combination + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!() + }; + + let lc_variant = if a_is_constant { + MergeLcVariant::MergeBCThroughConstantA + } else { + MergeLcVariant::MergeACThroughConstantB + }; + + if multiplier == zero_fr { + // LC_AB * 0 = LC_C => LC_C == 0 + // not sure that any sane circuit will have this, + // but we cover this variant + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_c, _) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + zero_fr, + false, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like 0 = LC_C"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(MergeLcVariant::CIsTheOnlyMeaningful, hint_c); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + let mut final_lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!() + }; + + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + } + + let mut free_constant_term = a_constant_term; + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + // let final_lc = final_lc - &c; + let final_lc = subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_lc, _) = enforce_lc_as_gates( + self, + final_lc, + one_fr, + free_constant_term, + false, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * LC = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(lc_variant, hint_lc); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + + }, + (true, true, false) => { + // const * const = LC + // A and B are some constants + // also strange one, but we cover all the options exhaustively + let mut free_constant_term = a_constant_term; + free_constant_term.mul_assign(&b_constant_term); + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_, _, hint_lc, _) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + free_constant_term, + false, + false, + &mut space + ).expect("must allocate LCs as gates for constraint like c0 * c1 = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::MergeLinearCombinations(MergeLcVariant::CIsTheOnlyMeaningful, hint_lc); + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + }, + (false, false, false) => { + // LC * LC = LC + // potentially it can still be quadratic + let (is_quadratic_gate, _coeffs) = is_quadratic_gate::( + &a_lc, + &b_lc, + &c_lc, &mut self.scratch); + if is_quadratic_gate { + let current_lc_number = self.increment_lc_number(); + + let hint = TranspilationVariant::IntoQuadraticGate; + + // println!("Hint = {:?}", hint); + + self.hints.push((current_lc_number, hint)); + + return; + } + + // rewrite into addition gates and multiplication gates + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + let (_new_a_var, _, hint_a, _) = enforce_lc_as_gates( + self, + a_lc, + one_fr, + a_constant_term, + true, + false, + &mut space + ).expect("must allocate A LC as gates for constraint like LC * LC = LC"); + let (_new_b_var, _, hint_b, _) = enforce_lc_as_gates( + self, + b_lc, + one_fr, + b_constant_term, + true, + false, + &mut space + ).expect("must allocate B LC as gates for constraint like LC * LC = LC"); + let (_new_c_var, _, hint_c, can_use_fma) = enforce_lc_as_gates( + self, + c_lc, + one_fr, + c_constant_term, + true, + true, + &mut space + ).expect("must allocate C LC as gates for constraint like LC * LC = LC"); + + self.transpilation_scratch_space = Some(space); + + let current_lc_number = self.increment_lc_number(); + + let hint = if can_use_fma { + TranspilationVariant::IntoFMAGate((hint_a, hint_b, hint_c)) + } else { + TranspilationVariant::IntoMultiplicationGate((hint_a, hint_b, hint_c)) + }; + + + self.hints.push((current_lc_number, hint)); + } + } + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +// List of heuristics + +use crate::{LinearCombination, ConstraintSystem, Variable}; + +fn is_quadratic_gate>( + a: &LinearCombination, + b: &LinearCombination, + c: &LinearCombination, + scratch: &mut HashSet:: +) -> (bool, (E::Fr, E::Fr, E::Fr)) { + let zero = E::Fr::zero(); + + let (_a_containts_constant, a_constant_coeff) = get_constant_term::(&a); + let (_b_containts_constant, b_constant_coeff) = get_constant_term::(&b); + let (_c_containts_constant, c_constant_coeff) = get_constant_term::(&c); + + let (a_is_linear, a_linear_var, a_linear_var_coeff) = is_linear_term::(&a, scratch); + let (b_is_linear, b_linear_var, b_linear_var_coeff) = is_linear_term::(&b, scratch); + let (c_is_linear, c_linear_var, c_linear_var_coeff) = is_linear_term::(&c, scratch); + + let (c_is_constant, _) = is_constant::(&c); + + let is_quadratic; + if c_is_constant { + is_quadratic = a_is_linear && b_is_linear && a_linear_var == b_linear_var; + } else { + if a_is_linear && b_is_linear && c_is_linear && a_linear_var == b_linear_var && b_linear_var == c_linear_var { + is_quadratic = true; + } else { + return (false, (zero, zero, zero)); + } + } + + if is_quadratic { + // something like (v - 1) * (v - 1) = (v - 1) + // and we can make a quadratic gate + + let mut quadratic_term = a_linear_var_coeff; + quadratic_term.mul_assign(&b_linear_var_coeff); + + let mut linear_term_0 = a_constant_coeff; + linear_term_0.mul_assign(&b_linear_var_coeff); + + let mut linear_term_1 = b_constant_coeff; + linear_term_1.mul_assign(&a_linear_var_coeff); + + let mut linear_term = linear_term_0; + linear_term.add_assign(&linear_term_1); + if c_is_linear { + linear_term.sub_assign(&c_linear_var_coeff); + } + + let mut constant_term = a_constant_coeff; + constant_term.mul_assign(&b_constant_coeff); + + if c_constant_coeff != zero { + constant_term.sub_assign(&c_constant_coeff); + } + + return (true, (constant_term, linear_term, quadratic_term)); + } + + (false, (zero, zero, zero)) +} + +fn check_for_quadratic_gate( + a: &LinearCombination, + b: &LinearCombination, + c: &LinearCombination, + a_constant_term: E::Fr, + b_constant_term: E::Fr, + c_constant_term: E::Fr, +) -> (bool, (E::Fr, E::Fr, E::Fr)) { + let zero = E::Fr::zero(); + + let a_is_linear = a.0.len() == 1; + let b_is_linear = b.0.len() == 1; + let c_is_linear = c.0.len() == 1; + + let c_is_empty = c.0.len() == 0; + + let mut a_linear_var_coeff = E::Fr::zero(); + let mut b_linear_var_coeff = E::Fr::zero(); + let mut c_linear_var_coeff = E::Fr::zero(); + + let mut is_quadratic = false; + if c_is_empty { + if a_is_linear && b_is_linear { + let (a_linear_var, a_coeff) = a.0[0]; + let (b_linear_var, b_coeff) = b.0[0]; + a_linear_var_coeff = a_coeff; + b_linear_var_coeff = b_coeff; + + is_quadratic = a_linear_var == b_linear_var; + } + } else { + if a_is_linear && b_is_linear && c_is_linear { + let (a_linear_var, a_coeff) = a.0[0]; + let (b_linear_var, b_coeff) = b.0[0]; + let (c_linear_var, c_coeff) = c.0[0]; + + a_linear_var_coeff = a_coeff; + b_linear_var_coeff = b_coeff; + c_linear_var_coeff = c_coeff; + + is_quadratic = a_linear_var == b_linear_var && b_linear_var == c_linear_var; + } + } + + if is_quadratic { + // something like (v - 1) * (v - 1) = (v - 1) + // and we can make a quadratic gate + + let mut quadratic_term = a_linear_var_coeff; + quadratic_term.mul_assign(&b_linear_var_coeff); + + let mut linear_term_0 = a_constant_term; + linear_term_0.mul_assign(&b_linear_var_coeff); + + let mut linear_term_1 = b_constant_term; + linear_term_1.mul_assign(&a_linear_var_coeff); + + let mut linear_term = linear_term_0; + linear_term.add_assign(&linear_term_1); + if c_is_linear { + linear_term.sub_assign(&c_linear_var_coeff); + } + + let mut constant_term = a_constant_term; + constant_term.mul_assign(&b_constant_term); + + if c_constant_term != zero { + constant_term.sub_assign(&c_constant_term); + } + + return (true, (constant_term, linear_term, quadratic_term)); + } + + (false, (zero, zero, zero)) +} + +fn is_constant>(lc: &LinearCombination) -> (bool, E::Fr) { + // formally it's an empty LC, so it's a constant 0 + if lc.as_ref().len() == 0 { + return (true, E::Fr::zero()); + } + + let result = get_constant_term::(&lc); + + if result.0 && lc.as_ref().len() == 1 { + return result; + } + + (false, E::Fr::zero()) +} + +fn get_constant_term>(lc: &LinearCombination) -> (bool, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var == &cs_one { + return (true, *coeff); + } + } + + (false, E::Fr::zero()) +} + +fn get_first_variable>(lc: &LinearCombination) -> (bool, Variable) { + let cs_one = CS::one(); + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var); + } + } + + (false, cs_one) +} + +fn get_first_variable_with_coeff>(lc: &LinearCombination) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + return (true, *var, *coeff); + } + } + + (false, cs_one, E::Fr::zero()) +} + +fn num_unique_values>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, usize) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut contains_constant = false; + + for (var, _) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + } else { + contains_constant = true; + } + } + + let num_unique_without_constant = scratch.len(); + + scratch.clear(); + + (contains_constant, num_unique_without_constant) +} + +fn is_linear_term>(lc: &LinearCombination, scratch: &mut HashSet::) -> (bool, Variable, E::Fr) { + let cs_one = CS::one(); + + debug_assert!(scratch.is_empty()); + + let mut linear_coeff = E::Fr::zero(); + + for (var, coeff) in lc.as_ref().iter() { + if var != &cs_one { + scratch.insert(*var); + linear_coeff = *coeff; + } + } + + let num_unique_without_constant = scratch.len(); + + if num_unique_without_constant == 1 { + let terms: Vec<_> = scratch.drain().collect(); + let term = terms[0]; + + return (true, term, linear_coeff) + } else { + scratch.clear(); + + return (false, cs_one, E::Fr::zero()) + } +} + +fn deduplicate_stable>( + lc: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return lc; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc.as_ref().len()); + + for (var, coeff) in lc.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn deduplicate_and_split_linear_term>( + lc: LinearCombination, + scratch: &mut HashMap +) -> (bool, E::Fr, bool, LinearCombination) { + assert!(scratch.is_empty()); + + if lc.as_ref().len() == 0 { + return (true, E::Fr::zero(), true, lc); + } + + let cs_one = CS::one(); + let mut constant_term = E::Fr::zero(); + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc.as_ref().len()); + + for (var, coeff) in lc.0.into_iter() { + if var != cs_one { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } else { + constant_term.add_assign(&coeff); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + let has_constant = !constant_term.is_zero(); + let lc_is_empty = deduped_vec.len() == 0; + + (has_constant, constant_term, lc_is_empty, LinearCombination(deduped_vec)) +} + +fn subtract_lcs_with_dedup_stable>( + lc_0: LinearCombination, + lc_1: LinearCombination, + scratch: &mut HashMap +) -> LinearCombination { + assert!(scratch.is_empty()); + + if lc_0.as_ref().len() == 0 && lc_1.as_ref().len() == 0{ + return lc_0; + } + + let mut deduped_vec: Vec<(crate::cs::Variable, E::Fr)> = Vec::with_capacity(lc_0.as_ref().len() + lc_1.as_ref().len()); + + for (var, coeff) in lc_0.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.add_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + deduped_vec.push((var, coeff)); + scratch.insert(var, new_idx); + } + } + + for (var, coeff) in lc_1.0.into_iter() { + if let Some(existing_index) = scratch.get(&var) { + let (_, c) = &mut deduped_vec[*existing_index]; + c.sub_assign(&coeff); + } else { + let new_idx = deduped_vec.len(); + let mut coeff_negated = coeff; + coeff_negated.negate(); + deduped_vec.push((var, coeff_negated)); + scratch.insert(var, new_idx); + } + } + + // let _initial_len = deduped_vec.len(); + + deduped_vec = deduped_vec.into_iter().filter(|(_var, coeff)| !coeff.is_zero()).collect(); + + // let _final_len = deduped_vec.len(); + + // if _initial_len != _final_len { + // println!("Encountered constraint with zero coeff for variable!"); + // } + + // assert!(deduped_vec.len() != 0); + + scratch.clear(); + + LinearCombination(deduped_vec) +} + +fn subtract_variable_unchecked( + lc: &mut LinearCombination, + variable: Variable +) { + let mut minus_one = E::Fr::one(); + minus_one.negate(); + + lc.0.push((variable, minus_one)); +} + +fn split_constant_term>( + mut lc: LinearCombination, +) -> (LinearCombination, E::Fr) { + if lc.as_ref().len() == 0 { + return (lc, E::Fr::zero()); + } + + let mut idx = None; + let cs_one = CS::one(); + let mut constant_coeff = E::Fr::zero(); + + for (i, (var, coeff)) in lc.0.iter().enumerate() { + if var == &cs_one { + idx = Some(i); + constant_coeff = *coeff; + break; + } + } + + if let Some(idx) = idx { + let _ = lc.0.swap_remove(idx); + return (lc, constant_coeff); + } else { + return (lc, constant_coeff); + } +} + + +pub struct Adaptor<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> { + cs: &'a mut CS, + hints: &'a Vec<(usize, TranspilationVariant)>, + current_constraint_index: usize, + current_hint_index: usize, + scratch: HashSet, + // deduplication_scratch: HashMap, + deduplication_scratch: HashMap, + transpilation_scratch_space: Option>, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

, +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> Adaptor<'a, E, P, CS> { + // fn get_next_hint(&mut self) -> &(usize, TranspilationVariant) { + // let current_hint_index = self.current_hint_index; + // let expected_constraint_index = self.current_constraint_index; + + // let next_hint = &self.hints[current_hint_index]; + + // assert!(next_hint.0 == expected_constraint_index); + + // self.current_hint_index += 1; + // self.current_constraint_index += 1; + + // next_hint + // } + + fn get_next_hint(&mut self) -> (usize, TranspilationVariant) { + let current_hint_index = self.current_hint_index; + let expected_constraint_index = self.current_constraint_index; + + let next_hint = self.hints[current_hint_index].clone(); + + assert!(next_hint.0 == expected_constraint_index); + + self.current_hint_index += 1; + self.current_constraint_index += 1; + + next_hint + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, CS: PlonkConstraintSystem + 'a> crate::ConstraintSystem + for Adaptor<'a, E, P, CS> +{ + type Root = Self; + + fn one() -> crate::Variable { + crate::Variable::new_unchecked(crate::Index::Input(0)) + } + + fn alloc(&mut self, _: A, f: F) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Aux(index)) => crate::Variable::new_unchecked(crate::Index::Aux(index)), + _ => unreachable!("Map aux into aux"), + }) + } + + fn alloc_input( + &mut self, + _: A, + f: F, + ) -> Result + where + F: FnOnce() -> Result, + A: FnOnce() -> AR, + AR: Into, + { + let var = self.cs.alloc_input(|| { + f().map_err(|_| crate::SynthesisError::AssignmentMissing) + })?; + + Ok(match var { + PlonkVariable(PlonkIndex::Input(index)) => crate::Variable::new_unchecked(crate::Index::Input(index)), + _ => unreachable!("Map input into input"), + }) + } + + fn enforce(&mut self, _ann: A, a: LA, b: LB, c: LC) + where + A: FnOnce() -> AR, + AR: Into, + LA: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LB: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + LC: FnOnce(crate::LinearCombination) -> crate::LinearCombination, + { + let zero_fr = E::Fr::zero(); + let one_fr = E::Fr::one(); + let mut minus_one_fr = E::Fr::one(); + minus_one_fr.negate(); + + let (_, hint) = { + self.get_next_hint() + }; + + let _hint = hint.clone(); + + // we need to determine the type of transformation constraint + + // let's handle trivial cases first + + // A or B or C are just constant terms + + let (a_has_constant, a_constant_term, a_lc_is_empty, a_lc) = deduplicate_and_split_linear_term::(a(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (b_has_constant, b_constant_term, b_lc_is_empty, b_lc) = deduplicate_and_split_linear_term::(b(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + let (c_has_constant, c_constant_term, c_lc_is_empty, c_lc) = deduplicate_and_split_linear_term::(c(crate::LinearCombination::zero()), &mut self.deduplication_scratch); + + let a_is_constant = a_has_constant & a_lc_is_empty; + let b_is_constant = b_has_constant & b_lc_is_empty; + let c_is_constant = c_has_constant & c_lc_is_empty; + + // debug_assert!(a_has_constant || !a_lc_is_empty); + // debug_assert!(b_has_constant || !b_lc_is_empty); + // debug_assert!(c_has_constant || !c_lc_is_empty); + + // let ann : String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("LC_A"); + // for (var, coeff) in a.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_B"); + // for (var, coeff) in b.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + // println!("LC_C"); + // for (var, coeff) in c.as_ref().iter() { + // println!("{} * {:?}", coeff, var); + // } + + let dummy_var = self.cs.get_dummy_variable(); + + // variables are left, right, output + // coefficients are left, right, output, multiplication, constant + + let mut space = self.transpilation_scratch_space.take().unwrap(); + + match hint { + TranspilationVariant::IntoQuadraticGate => { + let var = if !a_lc_is_empty { + convert_variable(a_lc.0[0].0) + } else if !b_lc_is_empty { + convert_variable(b_lc.0[0].0) + } else if !c_lc_is_empty { + convert_variable(c_lc.0[0].0) + } else { + unreachable!(); + }; + + let (is_quadratic, coeffs) = check_for_quadratic_gate( + &a_lc, + &b_lc, + &c_lc, + a_constant_term, + b_constant_term, + c_constant_term + ); + + debug_assert!(is_quadratic); + + let (c0, c1, c2) = coeffs; + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs[0] = c1; + space.scratch_space_for_coeffs.push(c2); + space.scratch_space_for_coeffs.push(c0); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*A + A + const == A*(B=A) + A + const + space.scratch_space_for_vars[0] = var; + space.scratch_space_for_vars[1] = var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a quadratic gate"); + + // self.cs.new_gate( + // (var, var, dummy_var), + // [c1, zero_fr, zero_fr, c2, c0, zero_fr] + // ).expect("must make a quadratic gate"); + }, + TranspilationVariant::IntoMultiplicationGate(hints) => { + // let ann: String = _ann().into(); + // if ann.contains("(a - b) * x == r - 1") { + // println!("{}", ann); + // } + + let (t_a, t_b, t_c) = hints; + let mut q_m = one_fr; + let mut q_c = one_fr; + let a_var = match t_a { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_a_var, a_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + a_lc, + one_fr, + a_constant_term, + true, + false, + &mut space + ).expect("must allocate A variable to transpile A LC for multiplication gate"); + + assert!(a_coeff == one_fr); + + assert!(_variant == hint); + + new_a_var.expect("transpiler must create a new variable for LC A") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!a_lc_is_empty); + let (var, coeff) = a_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeff before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_a)} + }; + + let b_var = match t_b { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_b_var, b_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + b_lc, + one_fr, + b_constant_term, + true, + false, + &mut space + ).expect("must allocate B variable to transpile B LC for multiplication gate"); + + assert!(b_coeff == one_fr); + + assert!(_variant == hint); + + new_b_var.expect("transpiler must create a new variable for LC B") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!b_lc_is_empty); + let (var, coeff) = b_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeffs before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_b)} + }; + + let (c_is_just_a_constant, c_var) = match t_c { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_c_var, c_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + c_lc, + one_fr, + c_constant_term, + true, + false, + &mut space + ).expect("must allocate C variable to transpile C LC for multiplication gate"); + + assert!(c_coeff == one_fr); + + assert!(_variant == hint); + + (false, Some(new_c_var.expect("transpiler must create a new variable for LC C"))) + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!c_lc_is_empty); + let (var, coeff) = c_lc.0[0]; + q_c = coeff; + + (false, Some(convert_variable(var))) + }, + LcTransformationVariant::IsConstant => { + assert!(c_lc_is_empty); + assert!(c_has_constant); + + (true, None) + }, + }; + + if c_is_just_a_constant { + let mut constant_term = c_constant_term; + constant_term.negate(); // - C + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs.push(q_m); + space.scratch_space_for_coeffs.push(constant_term); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*B + const == 0 + space.scratch_space_for_vars[0] = a_var; + space.scratch_space_for_vars[1] = b_var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a multiplication gate with C being constant"); + + // A*B == constant + // let t = self.cs.new_gate( + // (a_var, b_var, dummy_var), + // [zero_fr, zero_fr, zero_fr, q_m, constant_term, zero_fr] + // ); //.expect("must make a multiplication gate with C being constant"); + + // if t.is_err() { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint = {:?}", _hint); + // panic!("Unsatisfied multiplication gate with C being constant"); + // } + } else { + // Plain multiplication gate + + q_c.negate(); // - C + + let c_var = c_var.expect("C must be a variable"); + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs[2] = q_c; + space.scratch_space_for_coeffs.push(q_m); + space.scratch_space_for_coeffs.push(zero_fr); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*B - C == 0 + space.scratch_space_for_vars[0] = a_var; + space.scratch_space_for_vars[1] = b_var; + space.scratch_space_for_vars[2] = c_var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a plain multiplication gate"); + + + // let t = self.cs.new_gate( + // (a_var, b_var, c_var), + // [zero_fr, zero_fr, q_c, q_m, zero_fr, zero_fr] + // ); //.expect("must make a multiplication gate"); + + // if t.is_err() { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("A constant term = {}", a_constant_term); + // println!("B constant term = {}", b_constant_term); + // println!("C constant term = {}", c_constant_term); + // println!("Hint = {:?}", _hint); + // panic!("Unsatisfied multiplication gate"); + // } + } + }, + TranspilationVariant::IntoFMAGate(hints) => { + let (t_a, t_b, t_c) = hints; + let mut q_m = one_fr; + let a_var = match t_a { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_a_var, a_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + a_lc, + one_fr, + a_constant_term, + true, + false, + &mut space + ).expect("must allocate A variable to transpile A LC for multiplication gate"); + + assert!(a_coeff == one_fr); + + assert!(_variant == hint); + + new_a_var.expect("transpiler must create a new variable for LC A") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!a_lc_is_empty); + let (var, coeff) = a_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeff before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_a)} + }; + + let b_var = match t_b { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_b_var, b_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + b_lc, + one_fr, + b_constant_term, + true, + false, + &mut space + ).expect("must allocate B variable to transpile B LC for multiplication gate"); + + assert!(b_coeff == one_fr); + + assert!(_variant == hint); + + new_b_var.expect("transpiler must create a new variable for LC B") + }, + LcTransformationVariant::IsSingleVariable => { + assert!(!b_lc_is_empty); + let (var, coeff) = b_lc.0[0]; + q_m.mul_assign(&coeff); // collapse coeffs before A*B + + convert_variable(var) + }, + _ => {unreachable!("{:?}", t_b)} + }; + + let c_var = match t_c { + hint @ LcTransformationVariant::IntoSingleGate => { + let (new_c_var, c_coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + c_lc, + one_fr, + c_constant_term, + true, + true, + &mut space + ).expect("must allocate C variable to transpile C LC for multiplication gate"); + + assert!(c_coeff == one_fr); + + assert!(_variant == hint); + + Some(new_c_var.expect("transpiler must create a new variable for LC C")) + }, + _ => { unreachable!("{:?}", t_c)} + }; + + // Plain multiplication gate, but in a form A*B - D = 0 + + let q_d = minus_one_fr; + + let d_var = c_var.expect("C must be a variable"); + + space.scratch_space_for_coeffs.resize(P::STATE_WIDTH, zero_fr); + space.scratch_space_for_vars.resize(P::STATE_WIDTH, dummy_var); + + space.scratch_space_for_coeffs[3] = q_d; + space.scratch_space_for_coeffs.push(q_m); + space.scratch_space_for_coeffs.push(zero_fr); + space.scratch_space_for_coeffs.push(zero_fr); + + // ~ A*B - D == 0 + space.scratch_space_for_vars[0] = a_var; + space.scratch_space_for_vars[1] = b_var; + space.scratch_space_for_vars[3] = d_var; + + allocate_into_cs( + self.cs, + false, + &*space.scratch_space_for_vars, + &*space.scratch_space_for_coeffs + ).expect("must make a plain multiplication gate"); + }, + // make an addition gate + TranspilationVariant::IntoAdditionGate(hint) => { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint is {:?}", hint); + + // these are simple enforcements that are not a part of multiplication gate + // or merge of LCs + + if c_is_constant { + let lc = if !a_is_constant { + a_lc + } else if !b_is_constant { + b_lc + } else { + unreachable!("Either A or B LCs are constant"); + }; + + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!("Must take multiplier from A or B"); + }; + + let mut free_constant_term = if a_is_constant { + b_constant_term + } else if b_is_constant { + a_constant_term + } else { + unreachable!("Either A or B LCs are constant"); + }; + + free_constant_term.mul_assign(&multiplier); + free_constant_term.sub_assign(&c_constant_term); + + let (_, _, _variant, _) = enforce_lc_as_gates( + self.cs, + lc, + multiplier, + free_constant_term, + false, + false, + &mut space + ).expect("must allocate variable to transpile LC == 0 gate"); + + assert!(hint == _variant); + } else { + // let ann: String = _ann().into(); + // println!("Enforcing {}", ann); + // println!("Hint is {:?}", hint); + + // c is not a constant and it's handled by MergeLCs + unreachable!(); + } + }, + TranspilationVariant::MergeLinearCombinations(merge_variant, merge_hint) => { + let multiplier = if a_is_constant { + a_constant_term + } else if b_is_constant { + b_constant_term + } else { + unreachable!() + }; + + let mut free_constant_term; + + let lc_into_rewriting = match merge_variant { + MergeLcVariant::MergeACThroughConstantB => { + assert!(b_is_constant); + let mut final_lc = a_lc; + free_constant_term = a_constant_term; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + free_constant_term.mul_assign(&multiplier); + } + + free_constant_term.sub_assign(&c_constant_term); + + subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::MergeBCThroughConstantA => { + assert!(a_is_constant); + let mut final_lc = b_lc; + free_constant_term = b_constant_term; + if multiplier != one_fr { + for (_, c) in final_lc.0.iter_mut() { + c.mul_assign(&multiplier); + } + free_constant_term.mul_assign(&multiplier); + } + + free_constant_term.sub_assign(&c_constant_term); + + subtract_lcs_with_dedup_stable::(final_lc, c_lc, &mut self.deduplication_scratch) + // final_lc - &c + }, + MergeLcVariant::CIsTheOnlyMeaningful => { + free_constant_term = a_constant_term; + free_constant_term.mul_assign(&b_constant_term); + free_constant_term.negate(); + free_constant_term.add_assign(&c_constant_term); + + c_lc + }, + _ => { + unreachable!() + } + }; + + let h = merge_hint; + + match h { + hint @ LcTransformationVariant::IntoSingleGate | + hint @ LcTransformationVariant::IntoMultipleGates => { + let (new_c_var, _coeff, _variant, _) = enforce_lc_as_gates( + self.cs, + lc_into_rewriting, + one_fr, + free_constant_term, + false, + false, + &mut space + ).expect("must allocate gates to transpile merging of LCs"); + + assert!(_coeff == one_fr); + + assert!(new_c_var.is_none()); + assert!(_variant == hint); + }, + _ => { + unreachable!("{:?}", h); + } + }; + } + } + + space.clear(); + self.transpilation_scratch_space = Some(space); + } + + fn push_namespace(&mut self, _: N) + where + NR: Into, + N: FnOnce() -> NR, + { + // Do nothing; we don't care about namespaces in this context. + } + + fn pop_namespace(&mut self) { + // Do nothing; we don't care about namespaces in this context. + } + + fn get_root(&mut self) -> &mut Self::Root { + self + } +} + +fn convert_variable(r1cs_variable: crate::Variable) -> PlonkVariable { + let var = match r1cs_variable.get_unchecked() { + crate::Index::Input(0) => {unreachable!("can not convert input variable number 0 (CS::one)")}, + crate::Index::Aux(0) => {unreachable!("can not convert aux variable labeled as 0 (taken by Plonk CS)")}, + crate::Index::Input(i) => PlonkVariable(PlonkIndex::Input(i)), + crate::Index::Aux(i) => PlonkVariable(PlonkIndex::Aux(i)), + }; + + var +} + +fn convert_variable_back(plonk_variable: PlonkVariable) -> crate::Variable { + let var = match plonk_variable.get_unchecked() { + crate::plonk::cs::variable::Index::Input(0) => {unreachable!("can not convert input variable number 0 (does not exist in plonk)")}, + crate::plonk::cs::variable::Index::Aux(0) => {unreachable!("can not convert aux variable labeled as 0 (does not exist in plonk, dummy gate)")}, + crate::plonk::cs::variable::Index::Input(i) => crate::Variable(crate::Index::Input(i)), + crate::plonk::cs::variable::Index::Aux(i) => crate::Variable(crate::Index::Aux(i)), + }; + + var +} + +use std::cell::Cell; + +pub struct AdaptorCircuit<'a, E:Engine, P: PlonkConstraintSystemParams, C: crate::Circuit>{ + circuit: Cell>, + hints: &'a Vec<(usize, TranspilationVariant)>, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData

, +} + +impl<'a, E:Engine, P: PlonkConstraintSystemParams, C: crate::Circuit> AdaptorCircuit<'a, E, P, C> { + pub fn new<'b>(circuit: C, hints: &'b Vec<(usize, TranspilationVariant)>) -> Self + where 'b: 'a + { + Self { + circuit: Cell::new(Some(circuit)), + hints: hints, + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + } + } +} + +impl<'a, E: Engine, P: PlonkConstraintSystemParams, C: crate::Circuit> PlonkCircuit for AdaptorCircuit<'a, E, P, C> { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let mut adaptor = Adaptor:: { + cs: cs, + hints: self.hints, + current_constraint_index: 0, + current_hint_index: 0, + scratch: HashSet::with_capacity((E::Fr::NUM_BITS * 2) as usize), + deduplication_scratch: HashMap::with_capacity((E::Fr::NUM_BITS * 2) as usize), + transpilation_scratch_space: Some(TranspilationScratchSpace::new(P::STATE_WIDTH * 2)), + _marker_e: std::marker::PhantomData, + _marker_p: std::marker::PhantomData + }; + + let c = self.circuit.replace(None).expect("Must replace a circuit out from cell"); + + c.synthesize(&mut adaptor) + } +} + +#[test] +fn transpile_xor_using_fma_adaptor() { + use crate::tests::XORDemo; + use crate::cs::Circuit; + use crate::pairing::bn256::{Bn256, Fr}; + use super::test_assembly::*; + use super::cs::PlonkCsWidth4WithNextStepParams; + use super::generator::*; + use super::prover::*; + use crate::worker::Worker; + use super::verifier::*; + use crate::kate_commitment::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transcript::keccak_transcript::*; + use crate::plonk::fft::cooley_tukey_ntt::*; + use super::keys::*; + use crate::plonk::domains::Domain; + use super::utils::make_non_residues; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let mut transpiler = Transpiler::::new(); + + c.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let hints = transpiler.hints; + + for (constraint_id, hint) in hints.iter() { + println!("Constraint {} into {:?}", constraint_id, hint); + } + + // let c = XORDemo:: { + // a: None, + // b: None, + // _marker: PhantomData + // }; + + let c = XORDemo:: { + a: Some(true), + b: Some(false), + _marker: PhantomData + }; + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + + let mut assembly = TestAssembly::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + let num_gates = assembly.num_gates(); + println!("Transpiled into {} gates", num_gates); + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + adapted_curcuit.synthesize(&mut assembly).expect("sythesize of transpiled into CS must succeed"); + assembly.finalize(); + + let worker = Worker::new(); + + let setup = assembly.setup(&worker).unwrap(); + + let crs_mons = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + let crs_vals = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs_mons + ).unwrap(); + + let precomputations = SetupPolynomialsPrecomputations::from_setup( + &setup, + &worker + ).unwrap(); + + let mut assembly = ProverAssembly4WithNextStep::::new(); + + let adapted_curcuit = AdaptorCircuit::::new(c.clone(), &hints); + + adapted_curcuit.synthesize(&mut assembly).expect("must work"); + + assembly.finalize(); + + let size = setup.permutation_polynomials[0].size(); + + let domain = Domain::::new_for_size(size as u64).unwrap(); + let non_residues = make_non_residues::(3); + println!("Non residues = {:?}", non_residues); + + type Transcr = RollingKeccakTranscript; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + let proof = assembly.prove::( + &worker, + &setup, + &precomputations, + &crs_vals, + &crs_mons, + &omegas_bitreversed, + &omegas_inv_bitreversed, + None, + ).unwrap(); + + let is_valid = verify::(&proof, &verification_key, None).unwrap(); + + assert!(is_valid); + + // println!("Verification key = {:?}", verification_key); + // println!("Proof = {:?}", proof); + + let mut key_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_vk.key").unwrap() + ); + verification_key.write(&mut key_writer).unwrap(); + + let mut proof_writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./xor_proof.proof").unwrap() + ); + proof.write(&mut proof_writer).unwrap(); +} \ No newline at end of file diff --git a/src/plonk/better_cs/generator.rs b/src/plonk/better_cs/generator.rs new file mode 100644 index 000000000..e7c62e743 --- /dev/null +++ b/src/plonk/better_cs/generator.rs @@ -0,0 +1,665 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use crate::plonk::domains::*; + +use std::marker::PhantomData; + +use super::cs::*; +use super::keys::SetupPolynomials; +pub use super::utils::{make_non_residues}; + +#[derive(Debug, Clone)] +pub struct GeneratorAssembly> { + m: usize, + n: usize, + input_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + aux_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + + num_inputs: usize, + num_aux: usize, + + inputs_map: Vec, + + is_finalized: bool +} + +impl> ConstraintSystem for GeneratorAssembly { + // allocate a variable + fn alloc(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + + self.num_aux += 1; + let index = self.num_aux; + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + + self.num_inputs += 1; + let index = self.num_inputs; + + let input_var = Variable(Index::Input(index)); + + let dummy = self.get_dummy_variable(); + + let vars = P::StateVariables::from_variable_and_padding(input_var, dummy); + let mut this_step_coeffs = P::ThisTraceStepCoefficients::identity(); + this_step_coeffs.negate(); // we use -1 here to later add to the constants polynomial using + sign + let next_step_coeffs = P::NextTraceStepCoefficients::empty(); + + self.input_gates.push((vars, this_step_coeffs, next_step_coeffs)); + self.n += 1; + + Ok(input_var) + } + + // allocate an abstract gate + fn new_gate(&mut self, + variables: P::StateVariables, + this_step_coeffs: P::ThisTraceStepCoefficients, + next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> + { + self.aux_gates.push((variables, this_step_coeffs, next_step_coeffs)); + self.n += 1; + + Ok(()) + } + + fn get_value(&self, _var: Variable) -> Result { + Err(SynthesisError::AssignmentMissing) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl> GeneratorAssembly { + pub fn new() -> Self { + let tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + inputs_map: vec![], + + is_finalized: false, + }; + + tmp + } + + pub fn new_with_size_hints(num_inputs: usize, num_aux: usize) -> Self { + let tmp = Self { + n: 0, + m: 0, + input_gates: Vec::with_capacity(num_inputs), + aux_gates: Vec::with_capacity(num_aux), + + num_inputs: 0, + num_aux: 0, + + inputs_map: Vec::with_capacity(num_inputs), + + is_finalized: false, + }; + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + Variable(Index::Aux(0)) + } + + pub fn num_gates(&self) -> usize { + self.input_gates.len() + self.aux_gates.len() + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let dummy = self.get_dummy_variable(); + + let vars = P::StateVariables::from_variable_and_padding(dummy, dummy); + let this_step_coeffs = P::ThisTraceStepCoefficients::empty(); + let next_step_coeffs = P::NextTraceStepCoefficients::empty(); + + let empty_gate = (vars, this_step_coeffs, next_step_coeffs); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + let n = self.input_gates.len() + self.aux_gates.len(); + assert!((n+1).is_power_of_two()); + self.n = n; + + self.is_finalized = true; + } +} + +// later we can alias traits +// pub trait PlonkCsWidth3WithNextStep = ConstraintSystem; + +pub type GeneratorAssembly3WithNextStep = GeneratorAssembly; +pub type GeneratorAssembly4WithNextStep = GeneratorAssembly; + +impl GeneratorAssembly4WithNextStep { + pub fn make_selector_polynomials( + &self, + worker: &Worker + ) -> Result< + ([Polynomial::; 6], [Polynomial::; 1]), + SynthesisError + > { + assert!(self.is_finalized); + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_a = vec![E::Fr::zero(); total_num_gates]; + let mut q_b = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + let mut q_d = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_const = vec![E::Fr::zero(); total_num_gates]; + + let mut q_d_next = vec![E::Fr::zero(); total_num_gates]; + + // expect a small number of inputs + for (gate, q_a) in self.input_gates.iter() + .zip(q_a.iter_mut()) + { + let mut tmp = gate.1[0]; + tmp.negate(); + // -a + const = 0, where const will come from verifier + assert_eq!(tmp, E::Fr::one()); + *q_a = gate.1[0]; + } + + // now fill the aux gates + + let num_input_gates = self.input_gates.len(); + let q_a_aux = &mut q_a[num_input_gates..]; + let q_b_aux = &mut q_b[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + let q_d_aux = &mut q_d[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_const_aux = &mut q_const[num_input_gates..]; + + let q_d_next_aux = &mut q_d_next[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_a_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((((gate, q_a), q_b), q_c), q_d), q_m), q_const), q_d_next) + in self.aux_gates.chunks(chunk) + .zip(q_a_aux.chunks_mut(chunk)) + .zip(q_b_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + .zip(q_d_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_const_aux.chunks_mut(chunk)) + .zip(q_d_next_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((((gate, q_a), q_b), q_c), q_d), q_m), q_const), q_d_next) + in gate.iter() + .zip(q_a.iter_mut()) + .zip(q_b.iter_mut()) + .zip(q_c.iter_mut()) + .zip(q_d.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_const.iter_mut()) + .zip(q_d_next.iter_mut()) + { + *q_a = gate.1[0]; + *q_b = gate.1[1]; + *q_c = gate.1[2]; + *q_d = gate.1[3]; + *q_m = gate.1[4]; + *q_const = gate.1[5]; + + *q_d_next = gate.2[0]; + } + }); + } + }); + + let q_a = Polynomial::from_values(q_a)?; + let q_b = Polynomial::from_values(q_b)?; + let q_c = Polynomial::from_values(q_c)?; + let q_d = Polynomial::from_values(q_d)?; + let q_m = Polynomial::from_values(q_m)?; + let q_const = Polynomial::from_values(q_const)?; + + let q_d_next = Polynomial::from_values(q_d_next)?; + + Ok(([q_a, q_b, q_c, q_d, q_m, q_const], [q_d_next])) + } + + pub(crate) fn make_permutations(&self, worker: &Worker) -> [Polynomial::; 4] { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + // gate_idx is zero-enumerated here + for (gate_idx, (vars, _, _)) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + for (var_index_in_gate, v) in vars.iter().enumerate() { + match v { + Variable(Index::Aux(0)) => { + // Dummy variables do not participate in the permutation + }, + Variable(Index::Input(0)) => { + unreachable!("There must be no input with index 0"); + }, + Variable(Index::Input(index)) => { + let i = *index; // inputs are [1, num_inputs] + partitions[i].push((var_index_in_gate, gate_idx+1)); + }, + Variable(Index::Aux(index)) => { + let i = index + num_inputs; // aux are [num_inputs + 1, ..] + partitions[i].push((var_index_in_gate, gate_idx+1)); + }, + } + } + } + + // sanity check + assert_eq!(partitions[0].len(), 0); + + let domain = Domain::new_for_size(num_gates as u64).expect("must have enough roots of unity to fit the circuit"); + + // now we need to make root at it's cosets + let domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, &worker + ); + + // domain_elements.pop().unwrap(); + + use crate::ff::SqrtField; + use crate::ff::LegendreSymbol; + + let mut non_residues = vec![]; + non_residues.push(E::Fr::one()); + non_residues.extend(make_non_residues::(3)); + + assert_eq!(non_residues.len(), 4); + + let mut sigma_1 = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_1.scale(&worker, non_residues[0]); + let mut sigma_2 = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_2.scale(&worker, non_residues[1]); + let mut sigma_3 = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_3.scale(&worker, non_residues[2]); + let mut sigma_4 = Polynomial::from_values_unpadded(domain_elements.clone()).unwrap(); + sigma_4.scale(&worker, non_residues[3]); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 1 { + let mut els: Vec<_> = vec.drain(0..1).collect(); + els.reverse(); + vec.push(els.pop().unwrap()); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + // we do not need to permute over partitions of length 1, + // as this variable only happends in one place + if partition.len() == 1 { + continue; + } + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + // let permutation = partition.clone(); + // permutations[i] = permutation; + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + // (column_idx, trace_step_idx) + let new_zero_enumerated = new.1 - 1; + let mut new_value = domain_elements[new_zero_enumerated]; + + // we have shuffled the values, so we need to determine FROM + // which of k_i * {1, omega, ...} cosets we take a value + // for a permutation polynomial + new_value.mul_assign(&non_residues[new.0]); + + // check to what witness polynomial the variable belongs + let place_into = match original.0 { + 0 => { + sigma_1.as_mut() + }, + 1 => { + sigma_2.as_mut() + }, + 2 => { + sigma_3.as_mut() + }, + 3 => { + sigma_4.as_mut() + }, + _ => { + unreachable!() + } + }; + + let original_zero_enumerated = original.1 - 1; + place_into[original_zero_enumerated] = new_value; + } + } + + // sigma_1.pad_to_domain().expect("must pad to power of two"); + // sigma_2.pad_to_domain().expect("must pad to power of two"); + // sigma_3.pad_to_domain().expect("must pad to power of two"); + // sigma_4.pad_to_domain().expect("must pad to power of two"); + + [sigma_1, sigma_2, sigma_3, sigma_4] + } + + pub fn setup(self, worker: &Worker) -> Result, SynthesisError> { + assert!(self.is_finalized); + + let n = self.n; + let num_inputs = self.num_inputs; + + let [sigma_1, sigma_2, sigma_3, sigma_4] = self.make_permutations(&worker); + + let ([q_a, q_b, q_c, q_d, q_m, q_const], + [q_d_next]) = self.make_selector_polynomials(&worker)?; + + drop(self); + + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + let sigma_4 = sigma_4.ifft(&worker); + + let q_a = q_a.ifft(&worker); + let q_b = q_b.ifft(&worker); + let q_c = q_c.ifft(&worker); + let q_d = q_d.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_const = q_const.ifft(&worker); + + let q_d_next = q_d_next.ifft(&worker); + + let setup = SetupPolynomials:: { + n, + num_inputs, + selector_polynomials: vec![q_a, q_b, q_c, q_d, q_m, q_const], + next_step_selector_polynomials: vec![q_d_next], + permutation_polynomials: vec![sigma_1, sigma_2, sigma_3, sigma_4], + + _marker: std::marker::PhantomData + }; + + Ok(setup) + } +} + +// use crate::ff::SqrtField; + +// pub(crate) fn make_non_residues(num: usize) -> Vec { + +// use crate::ff::LegendreSymbol; + +// let mut non_residues = vec![]; +// let mut current = F::one(); +// let one = F::one(); +// for _ in 0..num { +// loop { +// if current.legendre() != LegendreSymbol::QuadraticNonResidue { +// current.add_assign(&one); +// } else { +// non_residues.push(current); +// break; +// } +// } +// } + +// non_residues +// } + +#[cfg(test)] +mod test { + use super::*; + + use crate::pairing::Engine; + + struct TestCircuit4{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4 { + fn synthesize >(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let zero = E::Fr::zero(); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + let dummy = cs.get_dummy_variable(); + + // 2a - b == 0 + cs.new_gate( + [a, b, dummy, dummy], + [two, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // 10b - c = 0 + let ten = E::Fr::from_str("10").unwrap(); + + cs.new_gate( + [b, c, dummy, dummy], + [ten, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // c - a*b == 0 + + cs.new_gate( + [a, b, dummy, c], + [zero, zero, zero, negative_one, one, zero], + [zero] + )?; + + // 10a + 10b - c - d == 0 + + cs.new_gate( + [a, b, c, d], + [ten, ten, negative_one, negative_one, zero, zero], + [zero] + )?; + + + Ok(()) + } + } + + #[test] + fn test_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + // println!("{:?}", assembly); + + assembly.finalize(); + + let worker = Worker::new(); + + println!("Char = {}", Fr::char()); + + let [sigma_1, sigma_2, sigma_3, sigma_4] = assembly.make_permutations(&worker); + + let zero = Fr::zero(); + + let a_var_value = Fr::from_str("10").unwrap(); + let b_var_value = Fr::from_str("20").unwrap(); + let c_var_value = Fr::from_str("200").unwrap(); + let d_var_value = Fr::from_str("100").unwrap(); + + let dummy_1 = Fr::from_str("123").unwrap(); + let dummy_2 = Fr::from_str("456").unwrap(); + + let a = vec![a_var_value, b_var_value, a_var_value, a_var_value, zero, zero, zero]; + let b = vec![b_var_value, c_var_value, b_var_value, b_var_value, zero, zero, zero]; + let c = vec![dummy_1, zero, zero, c_var_value, zero, zero, zero]; + let d = vec![zero, dummy_2, c_var_value, d_var_value, zero, zero, zero]; + + let num_gates = assembly.num_gates(); + + let beta = Fr::from_str("15").unwrap(); + let gamma = Fr::from_str("4").unwrap(); + + let domain = crate::plonk::domains::Domain::new_for_size(num_gates as u64).unwrap(); + let omega = domain.generator; + + let mut non_res = vec![Fr::one()]; + non_res.extend(make_non_residues::(3)); + + let p = vec![ + (a, sigma_1, non_res[0]), + (b, sigma_2, non_res[1]), + (c, sigma_3, non_res[2]), + (d, sigma_4, non_res[3]), + ]; + + let mut subproducts: Vec> = vec![vec![]; 4]; + let mut permuted_subproducts: Vec> = vec![vec![]; 4]; + + for (((wit, perm, non_res), subprod), permuted_subprod) in p.into_iter() + .zip(subproducts.iter_mut()) + .zip(permuted_subproducts.iter_mut()) { + let mut current = non_res; // omega^0 * k + for (el, sig) in wit.iter().zip(perm.as_ref().iter()) { + let mut tmp = current; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + subprod.push(tmp); + + let mut tmp = *sig; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + permuted_subprod.push(tmp); + + current.mul_assign(&omega); + } + } + + let mut f_poly = vec![]; + let mut g_poly = vec![]; + + for i in 0..subproducts[0].len() { + let mut tmp = Fr::one(); + for p in subproducts.iter() { + tmp.mul_assign(&p[i]); + } + + f_poly.push(tmp); + } + + for i in 0..permuted_subproducts[0].len() { + let mut tmp = Fr::one(); + for p in permuted_subproducts.iter() { + tmp.mul_assign(&p[i]); + } + + g_poly.push(tmp); + } + + let mut tmp = Fr::one(); + let mut f_prime = vec![tmp]; + for el in f_poly.iter() { + tmp.mul_assign(&el); + f_prime.push(tmp); + } + + let mut tmp = Fr::one(); + let mut g_prime = vec![tmp]; + for el in g_poly.iter() { + tmp.mul_assign(&el); + g_prime.push(tmp); + } + + assert!(f_prime[0] == g_prime[0]); + assert!(f_prime[num_gates] == g_prime[num_gates]); + + let _setup = assembly.setup(&worker).unwrap(); + } +} \ No newline at end of file diff --git a/src/plonk/better_cs/keys.rs b/src/plonk/better_cs/keys.rs new file mode 100644 index 000000000..0c7084b84 --- /dev/null +++ b/src/plonk/better_cs/keys.rs @@ -0,0 +1,951 @@ +use super::cs::*; + +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine, CurveAffine, EncodedPoint}; + +use crate::plonk::domains::*; +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use crate::SynthesisError; + +use crate::kate_commitment::*; + +use std::marker::PhantomData; + +use super::utils::*; +use super::LDE_FACTOR; + +pub struct SetupPolynomials> { + pub n: usize, + pub num_inputs: usize, + pub selector_polynomials: Vec>, + pub next_step_selector_polynomials: Vec>, + pub permutation_polynomials: Vec>, + + pub(crate) _marker: std::marker::PhantomData

, +} + +use crate::byteorder::BigEndian; +use crate::byteorder::ReadBytesExt; +use crate::byteorder::WriteBytesExt; +use std::io::{Read, Write}; + + +// pub trait EngineDataSerializationRead: Sized { +// fn read(reader: R) -> std::io::Result; +// } + +// pub trait EngineDataSerializationWrite: Sized { +// fn write(&self, writer: W) -> std::io::Result<()>; +// } + +// pub trait EngineDataSerialization: EngineDataSerializationRead + EngineDataSerializationWrite {} + +// impl EngineDataSerializationRead for E::Fr { +// fn read(reader: R) -> std::io::Result { +// read_fr(reader) +// } +// } + +// impl EngineDataSerializationWrite for E::Fr { +// fn write(&self, writer: W) -> std::io::Result<()> { +// write_fr(self, writer) +// } +// } + +// impl EngineDataSerializationRead for T where E::G1Affine = T { +// fn read(reader: R) -> std::io::Result { +// let mut repr = ::Uncompressed::empty(); +// reader.read_exact(repr.as_mut())?; + +// let e = repr +// .into_affine() +// .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + +// Ok(e) +// } +// } + +// impl EngineDataSerializationWrite for E::G1Affine { +// fn write(&self, writer: W) -> std::io::Result<()> { +// writer.write_all(self.into_uncompressed().as_ref())?; +// } +// } + +pub fn read_curve_affine(mut reader: R) -> std::io::Result { + let mut repr = G::Uncompressed::empty(); + reader.read_exact(repr.as_mut())?; + + let e = repr + .into_affine() + .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + + Ok(e) +} + +pub fn read_optional_curve_affine(mut reader: R) -> std::io::Result> { + use crate::ff::PrimeFieldRepr; + + let is_some = read_optional_flag(&mut reader)?; + if is_some { + let el = read_curve_affine(&mut reader)?; + + Ok(Some(el)) + } else { + Ok(None) + } +} + +pub fn read_curve_affine_vector(mut reader: R) -> std::io::Result> { + let num_elements = reader.read_u64::()?; + let mut elements = vec![]; + for _ in 0..num_elements { + let el = read_curve_affine(&mut reader)?; + elements.push(el); + } + + Ok(elements) +} + +pub fn write_curve_affine(p: &G, mut writer: W) -> std::io::Result<()> { + writer.write_all(p.into_uncompressed().as_ref())?; + + Ok(()) +} + +pub fn write_optional_curve_affine(p: &Option, mut writer: W) -> std::io::Result<()> { + write_optional_flag(p.is_some(), &mut writer)?; + if let Some(p) = p.as_ref() { + write_curve_affine(p, &mut writer)?; + } + + Ok(()) +} + +pub fn write_curve_affine_vec(p: &[G], mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.len() as u64)?; + for p in p.iter() { + write_curve_affine(p, &mut writer)?; + } + Ok(()) +} + +pub fn write_fr(el: &F, mut writer: W) -> std::io::Result<()> { + use crate::ff::PrimeFieldRepr; + + let repr = el.into_repr(); + repr.write_be(&mut writer)?; + + Ok(()) +} + +pub fn write_optional_fr(el: &Option, mut writer: W) -> std::io::Result<()> { + use crate::ff::PrimeFieldRepr; + + write_optional_flag(el.is_some(), &mut writer)?; + if let Some(el) = el.as_ref() { + write_fr(el, &mut writer)?; + } + + Ok(()) +} + +pub fn write_fr_vec(p: &[F], mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.len() as u64)?; + for p in p.iter() { + write_fr(p, &mut writer)?; + } + Ok(()) +} + +pub fn write_fr_raw(el: &F, mut writer: W) -> std::io::Result<()> { + use crate::ff::PrimeFieldRepr; + + let repr = el.into_raw_repr(); + repr.write_be(&mut writer)?; + + Ok(()) +} + +pub fn read_optional_fr(mut reader: R) -> std::io::Result> { + use crate::ff::PrimeFieldRepr; + + let is_some = read_optional_flag(&mut reader)?; + if is_some { + let el = read_fr(&mut reader)?; + + Ok(Some(el)) + } else { + Ok(None) + } +} + +pub fn read_fr(mut reader: R) -> std::io::Result { + use crate::ff::PrimeFieldRepr; + + let mut repr = F::Repr::default(); + repr.read_be(&mut reader)?; + + F::from_repr(repr).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e)) +} + +pub fn read_fr_vec(mut reader: R) -> std::io::Result> { + let num_elements = reader.read_u64::()?; + let mut elements = vec![]; + for _ in 0..num_elements { + let el = read_fr(&mut reader)?; + elements.push(el); + } + + Ok(elements) +} + +pub fn read_fr_raw(mut reader: R) -> std::io::Result { + use crate::ff::PrimeFieldRepr; + let mut repr = F::Repr::default(); + repr.read_be(&mut reader)?; + + F::from_raw_repr(repr).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e)) +} + +pub fn read_optional_flag(mut reader: R) -> std::io::Result { + let value = reader.read_u64::()?; + if value == 1 { + return Ok(true); + } else if value == 0 { + return Ok(false); + } + + panic!("invalid encoding of optional flag"); +} + +pub fn write_optional_flag(is_some: bool, mut writer: W) -> std::io::Result<()> { + if is_some { + writer.write_u64::(1u64)?; + } else { + writer.write_u64::(0u64)?; + } + + Ok(()) +} + +pub fn read_optional_polynomial_coeffs(mut reader: R) -> std::io::Result>> { + let is_some = read_optional_flag(&mut reader)?; + if is_some { + let p = read_polynomial_coeffs(&mut reader)?; + + Ok(Some(p)) + } else { + Ok(None) + } +} + +pub fn read_optional_polynomial_values_unpadded(mut reader: R) -> std::io::Result>> { + let is_some = read_optional_flag(&mut reader)?; + if is_some { + let p = read_polynomial_values_unpadded(&mut reader)?; + + Ok(Some(p)) + } else { + Ok(None) + } +} + +pub fn write_optional_polynomial(p: &Option>, mut writer: W) -> std::io::Result<()> { + write_optional_flag(p.is_some(), &mut writer)?; + if let Some(p) = p.as_ref() { + write_polynomial(p, &mut writer)?; + } + Ok(()) +} + +pub fn read_polynomials_coeffs_vec(mut reader: R) -> std::io::Result>> { + let num_polys = reader.read_u64::()?; + let mut polys = vec![]; + for _ in 0..num_polys { + let p = read_polynomial_coeffs(&mut reader)?; + polys.push(p); + } + + Ok(polys) +} + +pub fn read_polynomials_values_unpadded_vec(mut reader: R) -> std::io::Result>> { + let num_polys = reader.read_u64::()?; + let mut polys = vec![]; + for _ in 0..num_polys { + let p = read_polynomial_values_unpadded(&mut reader)?; + polys.push(p); + } + + Ok(polys) +} + +pub fn write_polynomials_vec(p: &[Polynomial], mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.len() as u64)?; + for p in p.iter() { + write_polynomial(p, &mut writer)?; + } + Ok(()) +} + +pub fn write_polynomial(p: &Polynomial, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(p.as_ref().len() as u64)?; + for el in p.as_ref().iter() { + write_fr(el, &mut writer)?; + } + Ok(()) +} + +pub fn read_polynomial_coeffs(mut reader: R) -> std::io::Result> { + let num_values = reader.read_u64::()?; + let mut poly_coeffs = Vec::with_capacity(num_values as usize); + for _ in 0..num_values { + let el = read_fr(&mut reader)?; + poly_coeffs.push(el); + } + + Ok(Polynomial::from_coeffs(poly_coeffs).expect("must fit into some domain")) +} + +pub fn read_polynomial_values_unpadded(mut reader: R) -> std::io::Result> { + let num_values = reader.read_u64::()?; + let mut poly_values = Vec::with_capacity(num_values as usize); + for _ in 0..num_values { + let el = read_fr(&mut reader)?; + poly_values.push(el); + } + + Ok(Polynomial::from_values_unpadded(poly_values).expect("must fit into some domain")) +} + +impl> SetupPolynomials { + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(self.n as u64)?; + writer.write_u64::(self.num_inputs as u64)?; + + writer.write_u64::(self.selector_polynomials.len() as u64)?; + for p in self.selector_polynomials.iter() { + write_polynomial(p, &mut writer)?; + } + + writer.write_u64::(self.next_step_selector_polynomials.len() as u64)?; + for p in self.next_step_selector_polynomials.iter() { + write_polynomial(p, &mut writer)?; + } + + writer.write_u64::(self.permutation_polynomials.len() as u64)?; + for p in self.permutation_polynomials.iter() { + write_polynomial(p, &mut writer)?; + } + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + let n = reader.read_u64::()?; + let num_inputs = reader.read_u64::()?; + + let num_selectors = reader.read_u64::()?; + let mut selectors = Vec::with_capacity(num_selectors as usize); + for _ in 0..num_selectors { + let poly = read_polynomial_coeffs(&mut reader)?; + selectors.push(poly); + } + + let num_next_step_selectors = reader.read_u64::()?; + let mut next_step_selectors = Vec::with_capacity(num_next_step_selectors as usize); + for _ in 0..num_next_step_selectors { + let poly = read_polynomial_coeffs(&mut reader)?; + next_step_selectors.push(poly); + } + + let num_permutation_polys = reader.read_u64::()?; + let mut permutation_polys = Vec::with_capacity(num_permutation_polys as usize); + for _ in 0..num_permutation_polys { + let poly = read_polynomial_coeffs(&mut reader)?; + permutation_polys.push(poly); + } + + let new = Self { + n: n as usize, + num_inputs: num_inputs as usize, + selector_polynomials: selectors, + next_step_selector_polynomials: next_step_selectors, + permutation_polynomials: permutation_polys, + + _marker: std::marker::PhantomData, + }; + + Ok(new) + } +} + +pub struct SetupPolynomialsPrecomputations> { + pub selector_polynomials_on_coset_of_size_4n_bitreversed: Vec>, + pub next_step_selector_polynomials_on_coset_of_size_4n_bitreversed: + Vec>, + pub permutation_polynomials_on_coset_of_size_4n_bitreversed: Vec>, + pub permutation_polynomials_values_of_size_n_minus_one: Vec>, + pub inverse_divisor_on_coset_of_size_4n_bitreversed: Polynomial, + pub x_on_coset_of_size_4n_bitreversed: Polynomial, + + pub(crate) _marker: std::marker::PhantomData

, +} + +use crate::plonk::fft::cooley_tukey_ntt::{BitReversedOmegas, CTPrecomputations}; + +impl> SetupPolynomialsPrecomputations { + pub fn from_setup_and_precomputations>( + setup: &SetupPolynomials, + worker: &Worker, + omegas_bitreversed: &CP, + ) -> Result { + let mut new = Self { + selector_polynomials_on_coset_of_size_4n_bitreversed: vec![], + next_step_selector_polynomials_on_coset_of_size_4n_bitreversed: vec![], + permutation_polynomials_on_coset_of_size_4n_bitreversed: vec![], + permutation_polynomials_values_of_size_n_minus_one: vec![], + inverse_divisor_on_coset_of_size_4n_bitreversed: Polynomial::from_values(vec![ + E::Fr::one(), + ]) + .unwrap(), + x_on_coset_of_size_4n_bitreversed: Polynomial::from_values(vec![E::Fr::one()]).unwrap(), + + _marker: std::marker::PhantomData, + }; + + let required_domain_size = setup.selector_polynomials[0].size(); + + assert!(required_domain_size.is_power_of_two()); + let coset_generator = E::Fr::multiplicative_generator(); + + // let coset_generator = E::Fr::one(); + + // we do not precompute q_const as we need to use it for public inputs; + for p in setup.selector_polynomials[0..(setup.selector_polynomials.len() - 1)].iter() { + let ext = p.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_generator, + )?; + + new.selector_polynomials_on_coset_of_size_4n_bitreversed + .push(ext); + } + + for p in setup.next_step_selector_polynomials.iter() { + let ext = p.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_generator, + )?; + + new.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed + .push(ext); + } + + for p in setup.permutation_polynomials.iter() { + let lde = p.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_generator, + )?; + new.permutation_polynomials_on_coset_of_size_4n_bitreversed + .push(lde); + + let as_values = p.clone().fft(&worker); + let mut as_values = as_values.into_coeffs(); + as_values + .pop() + .expect("must shorted permutation polynomial values by one"); + + let p = Polynomial::from_values_unpadded(as_values)?; + + new.permutation_polynomials_values_of_size_n_minus_one + .push(p); + } + + let mut vanishing_poly_inverse_bitreversed = + evaluate_vanishing_polynomial_of_degree_on_domain_size::( + required_domain_size as u64, + &E::Fr::multiplicative_generator(), + (required_domain_size * LDE_FACTOR) as u64, + &worker, + )?; + vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker); + + assert_eq!( + vanishing_poly_inverse_bitreversed.size(), + required_domain_size * LDE_FACTOR + ); + + // evaluate polynomial X on the coset + let mut x_poly = Polynomial::from_values(vec![ + coset_generator; + vanishing_poly_inverse_bitreversed.size() + ])?; + x_poly.distribute_powers(&worker, x_poly.omega); + x_poly.bitreverse_enumeration(&worker); + + assert_eq!(x_poly.size(), required_domain_size * LDE_FACTOR); + + new.inverse_divisor_on_coset_of_size_4n_bitreversed = vanishing_poly_inverse_bitreversed; + new.x_on_coset_of_size_4n_bitreversed = x_poly; + + Ok(new) + } + + pub fn from_setup( + setup: &SetupPolynomials, + worker: &Worker, + ) -> Result { + let precomps = + BitReversedOmegas::new_for_domain_size(setup.permutation_polynomials[0].size()); + + Self::from_setup_and_precomputations(setup, worker, &precomps) + } + + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + writer.write_u64::(self.selector_polynomials_on_coset_of_size_4n_bitreversed.len() as u64)?; + for p in &self.selector_polynomials_on_coset_of_size_4n_bitreversed { + write_polynomial(p, &mut writer)?; + } + writer.write_u64::(self.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed.len() as u64)?; + for p in &self.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed { + write_polynomial(p, &mut writer)?; + } + writer.write_u64::(self.permutation_polynomials_on_coset_of_size_4n_bitreversed.len() as u64)?; + for p in &self.permutation_polynomials_on_coset_of_size_4n_bitreversed { + write_polynomial(p, &mut writer)?; + } + writer.write_u64::(self.permutation_polynomials_values_of_size_n_minus_one.len() as u64)?; + for p in &self.permutation_polynomials_values_of_size_n_minus_one { + write_polynomial(p, &mut writer)?; + } + write_polynomial(&self.inverse_divisor_on_coset_of_size_4n_bitreversed, &mut writer)?; + write_polynomial(&self.x_on_coset_of_size_4n_bitreversed, &mut writer)?; + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + let num_selectors = reader.read_u64::()?; + let mut selector_polynomials_on_coset_of_size_4n_bitreversed = + Vec::with_capacity(num_selectors as usize); + for _ in 0..num_selectors { + let poly = read_polynomial_values_unpadded(&mut reader)?; + selector_polynomials_on_coset_of_size_4n_bitreversed.push(poly); + } + + let num_next_step_selectors = reader.read_u64::()?; + let mut next_step_selector_polynomials_on_coset_of_size_4n_bitreversed = + Vec::with_capacity(num_next_step_selectors as usize); + for _ in 0..num_next_step_selectors { + let poly = read_polynomial_values_unpadded(&mut reader)?; + next_step_selector_polynomials_on_coset_of_size_4n_bitreversed.push(poly); + } + + let num_permutation_polys = reader.read_u64::()?; + let mut permutation_polynomials_on_coset_of_size_4n_bitreversed = + Vec::with_capacity(num_permutation_polys as usize); + for _ in 0..num_permutation_polys { + let poly = read_polynomial_values_unpadded(&mut reader)?; + permutation_polynomials_on_coset_of_size_4n_bitreversed.push(poly); + } + + let num_permutation_polys_size_minus_one = reader.read_u64::()?; + let mut permutation_polynomials_values_of_size_n_minus_one = Vec::with_capacity(num_permutation_polys as usize); + for _ in 0..num_permutation_polys_size_minus_one { + let poly = read_polynomial_values_unpadded(&mut reader)?; + permutation_polynomials_values_of_size_n_minus_one.push(poly); + } + let inverse_divisor_on_coset_of_size_4n_bitreversed = read_polynomial_values_unpadded(&mut reader)?; + let x_on_coset_of_size_4n_bitreversed = read_polynomial_values_unpadded(&mut reader)?; + + Ok(Self { + selector_polynomials_on_coset_of_size_4n_bitreversed, + next_step_selector_polynomials_on_coset_of_size_4n_bitreversed, + permutation_polynomials_on_coset_of_size_4n_bitreversed, + permutation_polynomials_values_of_size_n_minus_one, + inverse_divisor_on_coset_of_size_4n_bitreversed, + x_on_coset_of_size_4n_bitreversed, + _marker: std::marker::PhantomData, + }) + } +} + +#[derive(Clone, Debug)] +pub struct Proof> { + pub num_inputs: usize, + pub n: usize, + pub input_values: Vec, + pub wire_commitments: Vec, + pub grand_product_commitment: E::G1Affine, + pub quotient_poly_commitments: Vec, + + pub wire_values_at_z: Vec, + pub wire_values_at_z_omega: Vec, + pub grand_product_at_z_omega: E::Fr, + pub quotient_polynomial_at_z: E::Fr, + pub linearization_polynomial_at_z: E::Fr, + pub permutation_polynomials_at_z: Vec, + + pub opening_at_z_proof: E::G1Affine, + pub opening_at_z_omega_proof: E::G1Affine, + + pub(crate) _marker: std::marker::PhantomData

, +} + +impl> Proof { + pub fn empty() -> Self { + use crate::pairing::CurveAffine; + + Self { + num_inputs: 0, + n: 0, + input_values: vec![], + wire_commitments: vec![], + grand_product_commitment: E::G1Affine::zero(), + quotient_poly_commitments: vec![], + wire_values_at_z: vec![], + wire_values_at_z_omega: vec![], + grand_product_at_z_omega: E::Fr::zero(), + quotient_polynomial_at_z: E::Fr::zero(), + linearization_polynomial_at_z: E::Fr::zero(), + permutation_polynomials_at_z: vec![], + + opening_at_z_proof: E::G1Affine::zero(), + opening_at_z_omega_proof: E::G1Affine::zero(), + + _marker: std::marker::PhantomData, + } + } + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + use crate::pairing::CurveAffine; + + assert_eq!(self.num_inputs, self.input_values.len()); + + writer.write_u64::(self.n as u64)?; + writer.write_u64::(self.num_inputs as u64)?; + + // writer.write_u64::(self.input_values.len() as u64)?; + for p in self.input_values.iter() { + write_fr(p, &mut writer)?; + } + + assert_eq!(self.wire_commitments.len(), P::STATE_WIDTH); + writer.write_u64::(self.wire_commitments.len() as u64)?; + for p in self.wire_commitments.iter() { + writer.write_all(p.into_uncompressed().as_ref())?; + } + + writer.write_all(self.grand_product_commitment.into_uncompressed().as_ref())?; + + writer.write_u64::(self.quotient_poly_commitments.len() as u64)?; + for p in self.quotient_poly_commitments.iter() { + writer.write_all(p.into_uncompressed().as_ref())?; + } + + writer.write_u64::(self.wire_values_at_z.len() as u64)?; + for p in self.wire_values_at_z.iter() { + write_fr(p, &mut writer)?; + } + + writer.write_u64::(self.wire_values_at_z_omega.len() as u64)?; + for p in self.wire_values_at_z_omega.iter() { + write_fr(p, &mut writer)?; + } + + write_fr(&self.grand_product_at_z_omega, &mut writer)?; + write_fr(&self.quotient_polynomial_at_z, &mut writer)?; + write_fr(&self.linearization_polynomial_at_z, &mut writer)?; + + writer.write_u64::(self.permutation_polynomials_at_z.len() as u64)?; + for p in self.permutation_polynomials_at_z.iter() { + write_fr(p, &mut writer)?; + } + + writer.write_all(self.opening_at_z_proof.into_uncompressed().as_ref())?; + writer.write_all(self.opening_at_z_omega_proof.into_uncompressed().as_ref())?; + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + use crate::pairing::CurveAffine; + use crate::pairing::EncodedPoint; + + let n = reader.read_u64::()?; + let num_inputs = reader.read_u64::()?; + + let read_g1 = |reader: &mut R| -> std::io::Result { + let mut repr = ::Uncompressed::empty(); + reader.read_exact(repr.as_mut())?; + + let e = repr + .into_affine() + .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + + Ok(e) + }; + + let mut inputs = Vec::with_capacity(num_inputs as usize); + for _ in 0..num_inputs { + let p = read_fr(&mut reader)?; + inputs.push(p); + } + + let num_wire_commitments = reader.read_u64::()?; + let mut wire_commitments = Vec::with_capacity(num_wire_commitments as usize); + for _ in 0..num_wire_commitments { + let p = read_g1(&mut reader)?; + wire_commitments.push(p); + } + + let grand_product_commitment = read_g1(&mut reader)?; + + let num_quotient_commitments = reader.read_u64::()?; + let mut quotient_poly_commitments = Vec::with_capacity(num_quotient_commitments as usize); + for _ in 0..num_quotient_commitments { + let p = read_g1(&mut reader)?; + quotient_poly_commitments.push(p); + } + + let num_wire_values_at_z = reader.read_u64::()?; + let mut wire_values_at_z = Vec::with_capacity(num_wire_values_at_z as usize); + for _ in 0..num_wire_values_at_z { + let p = read_fr(&mut reader)?; + wire_values_at_z.push(p); + } + + let num_wire_values_at_z_omega = reader.read_u64::()?; + let mut wire_values_at_z_omega = Vec::with_capacity(num_wire_values_at_z_omega as usize); + for _ in 0..num_wire_values_at_z_omega { + let p = read_fr(&mut reader)?; + wire_values_at_z_omega.push(p); + } + + let grand_product_at_z_omega = read_fr(&mut reader)?; + let quotient_polynomial_at_z = read_fr(&mut reader)?; + let linearization_polynomial_at_z = read_fr(&mut reader)?; + + let num_perm_at_z = reader.read_u64::()?; + let mut permutation_polynomials_at_z = Vec::with_capacity(num_perm_at_z as usize); + for _ in 0..num_perm_at_z { + let p = read_fr(&mut reader)?; + permutation_polynomials_at_z.push(p); + } + + let opening_at_z_proof = read_g1(&mut reader)?; + let opening_at_z_omega_proof = read_g1(&mut reader)?; + + let new = Self { + num_inputs: num_inputs as usize, + n: n as usize, + input_values: inputs, + wire_commitments: wire_commitments, + grand_product_commitment: grand_product_commitment, + quotient_poly_commitments: quotient_poly_commitments, + wire_values_at_z: wire_values_at_z, + wire_values_at_z_omega: wire_values_at_z_omega, + grand_product_at_z_omega, + quotient_polynomial_at_z, + linearization_polynomial_at_z, + permutation_polynomials_at_z: permutation_polynomials_at_z, + + opening_at_z_proof: opening_at_z_proof, + opening_at_z_omega_proof: opening_at_z_omega_proof, + + _marker: std::marker::PhantomData, + }; + + Ok(new) + } +} + +#[derive(Clone, Debug)] +pub struct VerificationKey> { + pub n: usize, + pub num_inputs: usize, + pub selector_commitments: Vec, + pub next_step_selector_commitments: Vec, + pub permutation_commitments: Vec, + pub non_residues: Vec, + + pub g2_elements: [E::G2Affine; 2], + + pub(crate) _marker: std::marker::PhantomData

, +} + +impl> VerificationKey { + pub fn from_setup( + setup: &SetupPolynomials, + worker: &Worker, + crs: &Crs, + ) -> Result { + assert_eq!(setup.selector_polynomials.len(), P::STATE_WIDTH + 2); + if P::CAN_ACCESS_NEXT_TRACE_STEP == false { + assert_eq!(setup.next_step_selector_polynomials.len(), 0); + } + assert_eq!(setup.permutation_polynomials.len(), P::STATE_WIDTH); + + let mut new = Self { + n: setup.n, + num_inputs: setup.num_inputs, + selector_commitments: vec![], + next_step_selector_commitments: vec![], + permutation_commitments: vec![], + non_residues: vec![], + + g2_elements: [crs.g2_monomial_bases[0], crs.g2_monomial_bases[1]], + + _marker: std::marker::PhantomData, + }; + + for p in setup.selector_polynomials.iter() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + new.selector_commitments.push(commitment); + } + + for p in setup.next_step_selector_polynomials.iter() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + new.next_step_selector_commitments.push(commitment); + } + + for p in setup.permutation_polynomials.iter() { + let commitment = commit_using_monomials(p, &crs, &worker)?; + new.permutation_commitments.push(commitment); + } + + new.non_residues + .extend(super::utils::make_non_residues::(P::STATE_WIDTH - 1)); + + Ok(new) + } + + pub fn write(&self, mut writer: W) -> std::io::Result<()> { + use crate::pairing::CurveAffine; + + writer.write_u64::(self.n as u64)?; + writer.write_u64::(self.num_inputs as u64)?; + + writer.write_u64::(self.selector_commitments.len() as u64)?; + for p in self.selector_commitments.iter() { + writer.write_all(p.into_uncompressed().as_ref())?; + } + + writer.write_u64::(self.next_step_selector_commitments.len() as u64)?; + for p in self.next_step_selector_commitments.iter() { + writer.write_all(p.into_uncompressed().as_ref())?; + } + + writer.write_u64::(self.permutation_commitments.len() as u64)?; + for p in self.permutation_commitments.iter() { + writer.write_all(p.into_uncompressed().as_ref())?; + } + + writer.write_u64::(self.non_residues.len() as u64)?; + for p in self.non_residues.iter() { + write_fr(p, &mut writer)?; + } + + writer.write_all(self.g2_elements[0].into_uncompressed().as_ref())?; + writer.write_all(self.g2_elements[1].into_uncompressed().as_ref())?; + + Ok(()) + } + + pub fn read(mut reader: R) -> std::io::Result { + use crate::pairing::CurveAffine; + use crate::pairing::EncodedPoint; + + let n = reader.read_u64::()?; + let num_inputs = reader.read_u64::()?; + + let read_g1 = |reader: &mut R| -> std::io::Result { + let mut repr = ::Uncompressed::empty(); + reader.read_exact(repr.as_mut())?; + + let e = repr + .into_affine() + .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?; + + Ok(e) + }; + + let read_g2_not_zero = |reader: &mut R| -> std::io::Result { + let mut repr = ::Uncompressed::empty(); + reader.read_exact(repr.as_mut())?; + + let e = repr + .into_affine() + .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e)) + .and_then(|e| { + if e.is_zero() { + Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "point at infinity", + ))? + } else { + Ok(e) + } + }); + + e + }; + + let num_selectors = reader.read_u64::()?; + let mut selectors = Vec::with_capacity(num_selectors as usize); + for _ in 0..num_selectors { + let p = read_g1(&mut reader)?; + selectors.push(p); + } + + let num_next_step_selectors = reader.read_u64::()?; + let mut next_step_selectors = Vec::with_capacity(num_next_step_selectors as usize); + for _ in 0..num_next_step_selectors { + let p = read_g1(&mut reader)?; + next_step_selectors.push(p); + } + + let num_permutation_polys = reader.read_u64::()?; + let mut permutation_polys = Vec::with_capacity(num_permutation_polys as usize); + for _ in 0..num_permutation_polys { + let p = read_g1(&mut reader)?; + permutation_polys.push(p); + } + + let num_non_residues = reader.read_u64::()?; + let mut non_residues = Vec::with_capacity(num_non_residues as usize); + for _ in 0..num_non_residues { + let p = read_fr(&mut reader)?; + non_residues.push(p); + } + + let g2_points = [ + read_g2_not_zero(&mut reader)?, + read_g2_not_zero(&mut reader)?, + ]; + + let new = Self { + n: n as usize, + num_inputs: num_inputs as usize, + selector_commitments: selectors, + next_step_selector_commitments: next_step_selectors, + permutation_commitments: permutation_polys, + non_residues: non_residues, + + g2_elements: g2_points, + + _marker: std::marker::PhantomData, + }; + + Ok(new) + } +} diff --git a/src/plonk/better_cs/mod.rs b/src/plonk/better_cs/mod.rs new file mode 100644 index 000000000..7e6bd694a --- /dev/null +++ b/src/plonk/better_cs/mod.rs @@ -0,0 +1,13 @@ +pub mod cs; +pub mod test_assembly; +pub mod adaptor; +pub mod generator; +pub mod keys; +pub mod prover; +pub mod verifier; +pub mod one_shot_test_assembly; +pub mod fma_adaptor; + +pub(crate) mod utils; + +const LDE_FACTOR: usize = 4; \ No newline at end of file diff --git a/src/plonk/better_cs/one_shot_test_assembly.rs b/src/plonk/better_cs/one_shot_test_assembly.rs new file mode 100644 index 000000000..6bccec2d2 --- /dev/null +++ b/src/plonk/better_cs/one_shot_test_assembly.rs @@ -0,0 +1,295 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use super::cs::*; + +#[derive(Debug, Clone)] +pub struct OneShotTestAssembly> { + m: usize, + n: usize, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + input_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + aux_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + + inputs_map: Vec, + + is_finalized: bool, + + next_step_leftover_from_previous_gate: Option<(E::Fr, P::NextTraceStepCoefficients)>, + + _marker: std::marker::PhantomData

+} + +impl> ConstraintSystem for OneShotTestAssembly { + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + // println!("Allocated variable Aux({}) with value {}", index, value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let dummy = self.get_dummy_variable(); + + let vars = P::StateVariables::from_variable_and_padding(input_var, dummy); + let mut this_step_coeffs = P::ThisTraceStepCoefficients::identity(); + this_step_coeffs.negate(); // we use -1 here to later add to the constants polynomial using + sign + let next_step_coeffs = P::NextTraceStepCoefficients::empty(); + + self.input_gates.push((vars, this_step_coeffs, next_step_coeffs)); + self.n += 1; + + Ok(input_var) + + } + + // allocate an abstract gate + fn new_gate(&mut self, + variables: P::StateVariables, + this_step_coeffs: P::ThisTraceStepCoefficients, + next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + self.aux_gates.push((variables, this_step_coeffs, next_step_coeffs)); + + self.n += 1; + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Aux(0)) => { + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl> OneShotTestAssembly { + pub fn new() -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + input_gates: vec![], + aux_gates: vec![], + + + inputs_map: vec![], + + is_finalized: false, + + next_step_leftover_from_previous_gate: None, + + _marker: std::marker::PhantomData + }; + + tmp + } + + pub fn new_with_size_hints(num_inputs: usize, num_aux: usize) -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: Vec::with_capacity(num_inputs), + aux_assingments: Vec::with_capacity(num_aux), + + input_gates:Vec::with_capacity(num_inputs), + aux_gates: Vec::with_capacity(num_aux), + + inputs_map: Vec::with_capacity(num_inputs), + + is_finalized: false, + + next_step_leftover_from_previous_gate: None, + + _marker: std::marker::PhantomData + }; + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + Variable(Index::Aux(0)) + } + + pub fn is_well_formed(&self) -> bool { + // check that last gate does not chain further! + self.next_step_leftover_from_previous_gate.is_none() + } + + pub fn num_gates(&self) -> usize { + self.n + } +} + +impl OneShotTestAssembly { + pub fn is_satisfied(&self, in_a_middle: bool) -> bool { + // expect a small number of inputs + for (_i, (_vars, this_step_coeffs, next_step_coeffs)) in self.input_gates.iter().enumerate() + { + for c in this_step_coeffs.as_ref().iter().skip(1) { + assert!(c.is_zero(), "input gate must contatain only one coefficient"); + } + for c in next_step_coeffs.as_ref().iter() { + assert!(c.is_zero(), "input gate must contatain no next step coefficients"); + } + } + + for (i, gate_pair) in self.aux_gates.windows(2).enumerate() + { + let this_gate = &gate_pair[0]; + let next_gate = &gate_pair[1]; + + let mut this_gate_value = E::Fr::zero(); + + let mut coeffs_iter = this_gate.1.as_ref().iter(); + + // addition + for (&this_var, this_coeff) in this_gate.0.as_ref().iter() + .zip(&mut coeffs_iter) + { + let mut tmp = self.get_value(this_var).expect("must get a variable value"); + tmp.mul_assign(&this_coeff); + + this_gate_value.add_assign(&tmp); + } + + // multiplication + + let mut tmp = self.get_value(this_gate.0.as_ref()[0]).expect("must get a variable value"); + tmp.mul_assign(&self.get_value(this_gate.0.as_ref()[1]).expect("must get a variable value")); + tmp.mul_assign(&(&mut coeffs_iter.next().unwrap())); + + this_gate_value.add_assign(&tmp); + + // constant + + this_gate_value.add_assign(&(&mut coeffs_iter.next().unwrap())); + + // next step part + + for (&next_var, next_step_coeffs_coeff) in next_gate.0.as_ref().iter().rev() + .zip(this_gate.2.as_ref().iter()) + { + let mut tmp = self.get_value(next_var).expect("must get a variable value"); + tmp.mul_assign(&next_step_coeffs_coeff); + + this_gate_value.add_assign(&tmp); + } + + + if !this_gate_value.is_zero() { + println!("Unsatisfied at aux gate {}", i+1); + println!("Gate {:?}", this_gate); + // println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + return false; + } + } + + if !in_a_middle { + let i = self.aux_gates.len(); + let last_gate = *self.aux_gates.last().unwrap(); + + let this_gate = last_gate; + + let mut this_gate_value = E::Fr::zero(); + + let mut coeffs_iter = this_gate.1.as_ref().iter(); + + // addition + for (&this_var, this_coeff) in this_gate.0.as_ref().iter() + .zip(&mut coeffs_iter) + { + let mut tmp = self.get_value(this_var).expect("must get a variable value"); + tmp.mul_assign(&this_coeff); + + this_gate_value.add_assign(&tmp); + } + + // multiplication + + let mut tmp = self.get_value(this_gate.0.as_ref()[0]).expect("must get a variable value"); + tmp.mul_assign(&self.get_value(this_gate.0.as_ref()[1]).expect("must get a variable value")); + tmp.mul_assign(&(&mut coeffs_iter.next().unwrap())); + + this_gate_value.add_assign(&tmp); + + // constant + + this_gate_value.add_assign(&(&mut coeffs_iter.next().unwrap())); + + // next step part must be empty + + for c in this_gate.2.as_ref().iter() { + assert!(c.is_zero(), "last gate must not wrap around"); + } + + if !this_gate_value.is_zero() { + println!("Unsatisfied at last aux gate {}", i+1); + println!("Gate {:?}", this_gate); + // println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + return false; + } + } + + true + } +} diff --git a/src/plonk/better_cs/prover.rs.old b/src/plonk/better_cs/prover.rs.old new file mode 100644 index 000000000..6d694f7ec --- /dev/null +++ b/src/plonk/better_cs/prover.rs.old @@ -0,0 +1,1203 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use crate::plonk::domains::*; + +use std::marker::PhantomData; + +use super::cs::*; +use super::keys::{SetupPolynomials, Proof, SetupPolynomialsPrecomputations}; + +use crate::source::{DensityTracker, DensityTrackerersChain}; + +use crate::kate_commitment::*; +use super::utils::*; + +use crate::plonk::commitments::transcript::*; +use crate::plonk::fft::cooley_tukey_ntt::*; + +use super::LDE_FACTOR; + +// #[derive(Debug, Clone)] +pub struct ProverAssembly> { + m: usize, + n: usize, + // input_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + // aux_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + wire_assignments: Vec>, + + // aux_densities: Vec, + + inputs_map: Vec, + dummy_var: Variable, + + is_finalized: bool, + + _marker: std::marker::PhantomData

+} + +impl> ConstraintSystem for ProverAssembly { + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + // there is an implicit gate to constraint the input + // and it's handled during the proving + self.n += 1; + + Ok(input_var) + + } + + // allocate an abstract gate + fn new_gate(&mut self, + variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> + { + for (idx, &v) in variables.as_ref().iter().enumerate() { + let val = self.get_value(v)?; + self.wire_assignments[idx].push(val); + } + self.n += 1; + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Aux(0)) => { + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + unreachable!(); + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl> ProverAssembly { + pub fn new() -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + wire_assignments: vec![vec![]; P::STATE_WIDTH], + + // aux_densities: vec![DensityTracker::new(); P::STATE_WIDTH], + + inputs_map: vec![], + dummy_var: Variable(Index::Aux(0)), + + is_finalized: false, + + _marker: std::marker::PhantomData + }; + + tmp + } + + pub fn new_with_size_hints(num_inputs: usize, num_aux: usize) -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: Vec::with_capacity(num_inputs), + aux_assingments: Vec::with_capacity(num_aux), + + wire_assignments: vec![Vec::with_capacity(num_inputs + num_aux); P::STATE_WIDTH], + + // aux_densities: vec![DensityTracker::new(); P::STATE_WIDTH], + + inputs_map: Vec::with_capacity(num_inputs), + dummy_var: Variable(Index::Aux(0)), + + is_finalized: false, + + _marker: std::marker::PhantomData + }; + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + Variable(Index::Aux(0)) + } + + pub fn num_gates(&self) -> usize { + self.n + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let n = self.n; + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + self.n = (n+1).next_power_of_two() - 1; + + self.is_finalized = true; + } + + // pub fn make_witness_polynomials( + // self + // ) -> Result<(Vec>, Vec), SynthesisError> + // { + // assert!(self.is_finalized); + + // let mut full_assignments = vec![Vec::with_capacity((self.n+1).next_power_of_two()); self.wire_assignments.len()]; + + // for inp in self.input_assingments.into_iter() { + // // inputs will always go into A wire + // full_assignments[0].push(inp); + // for i in 1..full_assignments.len() { + // full_assignments[i].push(E::Fr::zero()); + // } + // } + + // for (idx, aux) in self.wire_assignments.into_iter().enumerate() { + // full_assignments[idx].extend(aux); + // full_assignments[idx].resize((self.n+1).next_power_of_two() - 1, E::Fr::zero()); + // } + + // let mut aux_densities = self.aux_densities; + + // for d in aux_densities.iter_mut() { + // d.pad((self.n+1).next_power_of_two() - 1); + // } + + // for a in full_assignments.iter() { + // assert_eq!(a.len(), (self.n+1).next_power_of_two() - 1); + // } + + // Ok((full_assignments, aux_densities)) + // } + + pub fn make_witness_polynomials( + self + ) -> Result>, SynthesisError> + { + assert!(self.is_finalized); + + let mut full_assignments = vec![Vec::with_capacity((self.n+1).next_power_of_two()); self.wire_assignments.len()]; + + for inp in self.input_assingments.into_iter() { + // inputs will always go into A wire + full_assignments[0].push(inp); + for i in 1..full_assignments.len() { + full_assignments[i].push(E::Fr::zero()); + } + } + + for (idx, aux) in self.wire_assignments.into_iter().enumerate() { + full_assignments[idx].extend(aux); + full_assignments[idx].resize((self.n+1).next_power_of_two() - 1, E::Fr::zero()); + } + + for a in full_assignments.iter() { + assert_eq!(a.len(), (self.n+1).next_power_of_two() - 1); + } + + Ok(full_assignments) + } +} + +// later we can alias traits +// pub trait PlonkCsWidth3WithNextStep = ConstraintSystem; + +pub type ProverAssembly3WithNextStep = ProverAssembly; +pub type ProverAssembly4WithNextStep = ProverAssembly; + + + +impl ProverAssembly4WithNextStep { + pub fn prove, CP: CTPrecomputations, CPI: CTPrecomputations>( + self, + worker: &Worker, + setup: &SetupPolynomials, + setup_precomputations: &SetupPolynomialsPrecomputations, + crs_vals: &Crs, + crs_mon: &Crs, + omegas_bitreversed: &CP, + omegas_inv_bitreversed: &CPI + ) -> Result, SynthesisError> { + use crate::pairing::CurveAffine; + use std::sync::Arc; + + let mut transcript = T::new(); + + assert!(self.is_finalized); + + let input_values = self.input_assingments.clone(); + + for inp in input_values.iter() { + transcript.commit_field_element(inp); + } + + let n = self.n; + let num_inputs = self.num_inputs; + + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let full_assignments = self.make_witness_polynomials()?; + + let mut proof = Proof::::empty(); + proof.n = n; + proof.num_inputs = num_inputs; + proof.input_values = input_values.clone(); + + let coset_factor = E::Fr::multiplicative_generator(); + + // let coset_factor = E::Fr::one(); + + // Commit wire polynomials + + for wire_poly in full_assignments.iter() { + let commitment = commit_using_raw_values( + &wire_poly, + &crs_vals, + &worker + )?; + + commit_point_as_xy::(&mut transcript, &commitment); + + proof.wire_commitments.push(commitment); + } + + // now transform assignments in the polynomials + + let mut assignment_polynomials = vec![]; + for p in full_assignments.into_iter() { + let p = Polynomial::from_values_unpadded(p)?; + assignment_polynomials.push(p); + } + + // make grand product polynomials + + // draw challenges for grand products + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut grand_products_protos_with_gamma = assignment_polynomials.clone(); + + // add gamma here to save computations later + for p in grand_products_protos_with_gamma.iter_mut() { + p.add_constant(&worker, &gamma); + } + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta); + + let non_residues = make_non_residues::( + >::STATE_WIDTH - 1, + &domain + ); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let z_den = { + assert_eq!( + setup_precomputations.permutation_polynomials_values_of_size_n_minus_one.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = setup_precomputations.permutation_polynomials_values_of_size_n_minus_one.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, &permutation_polys_it.next().unwrap(), &beta); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, &perm, &beta); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + // println!("Z last = {}", z.as_ref().last().unwrap()); + // assert!(z.as_ref().last().expect("must exist") == &E::Fr::one()); + + let z_commitment = commit_using_values( + &z, + &crs_vals, + &worker + )?; + proof.grand_product_commitment = z_commitment; + + commit_point_as_xy::(&mut transcript, &proof.grand_product_commitment); + + // interpolate on the main domain + let z_in_monomial_form = z.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // those are z(x*Omega) formally + let mut z_shifted_in_monomial_form = z_in_monomial_form.clone(); + z_shifted_in_monomial_form.distribute_powers(&worker, z_in_monomial_form.omega); + + // now we have to LDE everything and compute quotient polynomial + // also to save on openings that we will have to do from the monomial form anyway + + let mut witness_polys_in_monomial_form = vec![]; + + let mut witness_ldes_on_coset = vec![]; + let mut witness_next_ldes_on_coset = vec![]; + + for (idx, w) in assignment_polynomials.into_iter().enumerate() { + let monomial = w.clone_padded_to_domain()?.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + witness_polys_in_monomial_form.push(monomial.clone()); + + // this is D polynomial and we need to make next + if idx == >::STATE_WIDTH - 1 { + let mut d_next = monomial.clone(); + d_next.distribute_powers(&worker, d_next.omega); + + let lde = d_next.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + witness_next_ldes_on_coset.push(lde); + } + + let lde = monomial.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + witness_ldes_on_coset.push(lde); + } + + let alpha = transcript.get_challenge(); + + // calculate first part of the quotient polynomial - the gate itself + // A + B + C + D + AB + CONST + D_NEXT == 0 everywhere but on the last point of the domain + + let mut quotient_linearization_challenge = E::Fr::one(); + + let (mut t_1, mut tmp) = { + // Include the public inputs + let mut inputs_poly = Polynomial::::new_for_size(required_domain_size)?; + for (idx, &input) in input_values.iter().enumerate() { + inputs_poly.as_mut()[idx] = input; + } + // go into monomial form + + let mut inputs_poly = inputs_poly.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // add constants selectors vector + inputs_poly.add_assign(&worker, setup.selector_polynomials.last().unwrap()); + + // LDE + let mut t_1 = inputs_poly.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + // Q_A * A + let mut tmp = setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[0].clone(); + tmp.mul_assign(&worker, &witness_ldes_on_coset[0]); + t_1.add_assign(&worker, &tmp); + + // Q_B * B + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[1]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[1]); + t_1.add_assign(&worker, &tmp); + + // Q_C * C + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[2]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[2]); + t_1.add_assign(&worker, &tmp); + + // Q_D * D + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[3]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[3]); + t_1.add_assign(&worker, &tmp); + + // Q_M * A * B + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[4]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[0]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[1]); + t_1.add_assign(&worker, &tmp); + + tmp.reuse_allocation(&setup_precomputations.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed[0]); + tmp.mul_assign(&worker, &witness_next_ldes_on_coset[0]); + t_1.add_assign(&worker, &tmp); + + (t_1, tmp) + }; + + // drop(witness_ldes_on_coset); + drop(witness_next_ldes_on_coset); + + // now compute the permutation argument + + let z_coset_lde_bitreversed = z_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + assert!(z_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + let z_shifted_coset_lde_bitreversed = z_shifted_in_monomial_form.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + assert!(z_shifted_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + + quotient_linearization_challenge.mul_assign(&alpha); + + { + let mut contrib_z = z_coset_lde_bitreversed.clone(); + + // A + beta*X + gamma + + tmp.reuse_allocation(&witness_ldes_on_coset[0]); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &setup_precomputations.x_on_coset_of_size_4n_bitreversed, &beta); + contrib_z.mul_assign(&worker, &tmp); + + assert_eq!(non_residues.len() + 1, witness_ldes_on_coset.len()); + + for (w, non_res) in witness_ldes_on_coset[1..].iter().zip(non_residues.iter()) { + let mut factor = beta; + factor.mul_assign(&non_res); + + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &setup_precomputations.x_on_coset_of_size_4n_bitreversed, &factor); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.add_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + + let mut contrib_z = z_shifted_coset_lde_bitreversed; + + // A + beta*perm_a + gamma + + assert_eq!( + setup_precomputations.permutation_polynomials_on_coset_of_size_4n_bitreversed.len(), witness_ldes_on_coset.len() + ); + + for (w, perm) in witness_ldes_on_coset.iter() + .zip(setup_precomputations.permutation_polynomials_on_coset_of_size_4n_bitreversed.iter()) { + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &perm, &beta); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.sub_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // z(omega^0) - 1 == 0 + + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + { + let mut z_minus_one_by_l_0 = z_coset_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + let l_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + z_minus_one_by_l_0.mul_assign(&worker, &l_coset_lde_bitreversed); + + t_1.add_assign_scaled(&worker, &z_minus_one_by_l_0, "ient_linearization_challenge); + + drop(z_minus_one_by_l_0); + } + + drop(tmp); + + t_1.mul_assign(&worker, &setup_precomputations.inverse_divisor_on_coset_of_size_4n_bitreversed); + + t_1.bitreverse_enumeration(&worker); + + let t_poly_in_monomial_form = t_1.icoset_fft_for_generator(&worker, &E::Fr::multiplicative_generator()); + + let mut t_poly_parts = t_poly_in_monomial_form.break_into_multiples(required_domain_size)?; + + for t_part in t_poly_parts.iter() { + let t_part_commitment = commit_using_monomials( + &t_part, + &crs_mon, + &worker + )?; + + commit_point_as_xy::(&mut transcript, &t_part_commitment); + + proof.quotient_poly_commitments.push(t_part_commitment); + } + + // draw random point + + let z = transcript.get_challenge(); + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + for (idx, p) in witness_polys_in_monomial_form.iter().enumerate() { + let value_at_z = p.evaluate_at(&worker, z); + proof.wire_values_at_z.push(value_at_z); + if idx == 3 { + let value_at_z_omega = p.evaluate_at(&worker, z_by_omega); + proof.wire_values_at_z_omega.push(value_at_z_omega); + } + } + + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + let value_at_z = p.evaluate_at(&worker, z); + proof.permutation_polynomials_at_z.push(value_at_z); + } + + let z_at_z_omega = z_in_monomial_form.evaluate_at(&worker, z_by_omega); + proof.grand_product_at_z_omega = z_at_z_omega; + + let t_at_z = { + let mut result = E::Fr::zero(); + let mut current = E::Fr::one(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + for p in t_poly_parts.iter() { + let mut subvalue_at_z = p.evaluate_at(&worker, z); + subvalue_at_z.mul_assign(¤t); + result.add_assign(&subvalue_at_z); + current.mul_assign(&z_in_domain_size); + } + + result + }; + + proof.quotient_polynomial_at_z = t_at_z; + + for el in proof.wire_values_at_z.iter() { + transcript.commit_field_element(el); + } + + for el in proof.wire_values_at_z_omega.iter() { + transcript.commit_field_element(el); + } + + for el in proof.permutation_polynomials_at_z.iter() { + transcript.commit_field_element(el); + } + + transcript.commit_field_element(&proof.quotient_polynomial_at_z); + + // now compute linearization_polynomial in a monomial form + + let mut quotient_linearization_challenge = E::Fr::one(); + + let r = { + // Q_const + let mut r = setup.selector_polynomials[5].clone(); + + // Q_A * A(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[0], &proof.wire_values_at_z[0]); + + // Q_B * B(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[1], &proof.wire_values_at_z[1]); + + // Q_C * C(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[2], &proof.wire_values_at_z[2]); + + // Q_D * D(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[3], &proof.wire_values_at_z[3]); + + // Q_M * A(z) * B(z) + let mut scaling_factor = proof.wire_values_at_z[0]; + scaling_factor.mul_assign(&proof.wire_values_at_z[1]); + r.add_assign_scaled(&worker, &setup.selector_polynomials[4], &scaling_factor); + + // Q_D_Next * D(z*omega) + + r.add_assign_scaled(&worker, &setup.next_step_selector_polynomials[0], &proof.wire_values_at_z_omega[0]); + + quotient_linearization_challenge.mul_assign(&alpha); + + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let mut factor = quotient_linearization_challenge; + for (wire_at_z, non_residue) in proof.wire_values_at_z.iter() + .zip(Some(E::Fr::one()).iter().chain(&non_residues)) + { + let mut t = z; + t.mul_assign(&non_residue); + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.add_assign_scaled(&worker, &z_in_monomial_form, &factor); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = quotient_linearization_challenge; + factor.mul_assign(&beta); + factor.mul_assign(&z_at_z_omega); + + for (wire_at_z, perm_at_z) in proof.wire_values_at_z.iter() + .zip(proof.permutation_polynomials_at_z.iter()) + { + let mut t = *perm_at_z; + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.sub_assign_scaled(&worker, &setup.permutation_polynomials.last().expect("last permutation poly"), &factor); + + // + L_0(z) * Z(x) + + quotient_linearization_challenge.mul_assign(&alpha); + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign("ient_linearization_challenge); + + r.add_assign_scaled(&worker, &z_in_monomial_form, &factor); + + r + }; + + // commit the linearization polynomial + + let r_at_z = r.evaluate_at(&worker, z); + proof.linearization_polynomial_at_z = r_at_z; + + transcript.commit_field_element(&proof.linearization_polynomial_at_z); + + // sanity check - verification + { + let mut lhs = t_at_z; + let vanishing_at_z = evaluate_vanishing_for_size(&z ,required_domain_size as u64); + lhs.mul_assign(&vanishing_at_z); + + let mut quotient_linearization_challenge = E::Fr::one(); + + let mut rhs = r_at_z; + + // add public inputs + { + for (idx, input) in input_values.iter().enumerate() { + let mut tmp = evaluate_lagrange_poly_at_point(idx, &domain, z)?; + tmp.mul_assign(&input); + + rhs.add_assign(&tmp); + } + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // - \alpha (a + perm(z) * beta + gamma)*()*(d + gamma) & z(z*omega) + + let mut z_part = z_at_z_omega; + + assert_eq!(proof.permutation_polynomials_at_z.len() + 1, proof.wire_values_at_z.len()); + + for (w, p) in proof.wire_values_at_z.iter().zip(proof.permutation_polynomials_at_z.iter()) { + let mut tmp = *p; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&w); + + z_part.mul_assign(&tmp); + } + + // last poly value and gamma + let mut tmp = gamma; + tmp.add_assign(&proof.wire_values_at_z.iter().rev().next().unwrap()); + + z_part.mul_assign(&tmp); + z_part.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&z_part); + + quotient_linearization_challenge.mul_assign(&alpha); + + // - L_0(z) * \alpha^2 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&l_0_at_z); + + if lhs != rhs { + return Err(SynthesisError::Unsatisfiable); + } + } + + // get multiopening challenge + + let v = transcript.get_challenge(); + + // open at z: + // t_i(x) * z^{domain_size*i} + // r(x) + // witnesses + // permutations except of the last one + + // open at z*omega: + // z(x) + // next step witnesses (if any) + + let mut multiopening_challenge = E::Fr::one(); + + let mut poly_to_divide_at_z = t_poly_parts.drain(0..1).collect::>().pop().unwrap(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + let mut power_of_z = z_in_domain_size; + for t_part in t_poly_parts.into_iter() { + poly_to_divide_at_z.add_assign_scaled(&worker, &t_part, &power_of_z); + power_of_z.mul_assign(&z_in_domain_size); + } + + // linearization polynomial + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &r, &multiopening_challenge); + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 as u64])); + + // all witness polys + for w in witness_polys_in_monomial_form.iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &w, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4) as u64])); + + // all except of the last permutation polys + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &p, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3) as u64])); + + multiopening_challenge.mul_assign(&v); + + let mut poly_to_divide_at_z_omega = z_in_monomial_form; + poly_to_divide_at_z_omega.scale(&worker, multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + + // d should be opened at z*omega due to d_next + poly_to_divide_at_z_omega.add_assign_scaled(&worker, &witness_polys_in_monomial_form[3], &multiopening_challenge); + drop(witness_polys_in_monomial_form); + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3 + 1 + 1) as u64])); + + // division in monomial form is sequential, so we parallelize the divisions + + let mut polys = vec![(poly_to_divide_at_z, z), (poly_to_divide_at_z_omega, z_by_omega)]; + + worker.scope(polys.len(), |scope, chunk| { + for p in polys.chunks_mut(chunk) { + scope.spawn(move |_| { + let (poly, at) = &p[0]; + let at = *at; + let result = divide_single::(poly.as_ref(), at); + p[0] = (Polynomial::from_coeffs(result).unwrap(), at); + }); + } + }); + + let open_at_z_omega = polys.pop().unwrap().0; + let open_at_z = polys.pop().unwrap().0; + + let opening_at_z = commit_using_monomials( + &open_at_z, + &crs_mon, + &worker + )?; + + let opening_at_z_omega = commit_using_monomials( + &open_at_z_omega, + &crs_mon, + &worker + )?; + + proof.opening_at_z_proof = opening_at_z; + proof.opening_at_z_omega_proof = opening_at_z_omega; + + Ok(proof) + } +} + +enum PrecomputationsForPolynomial<'a, F: PrimeField> { + Borrowed(&'a Polynomial), + Owned(Polynomial), + None +} + +struct PartialVerifierState> { + witness_polys_as_coeffs: Vec, + + _marker: std::marker::PhantomData

+} + +struct FirstVerifierMessage> { + witness_commitments: Vec, + + _marker: std::marker::PhantomData

+} + +#[cfg(test)] +mod test { + use super::*; + use super::super::verifier::verify; + + use crate::pairing::Engine; + + #[derive(Clone)] + struct TestCircuit4{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4 { + fn synthesize >(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc_input(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc_input(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let zero = E::Fr::zero(); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + let dummy = cs.get_dummy_variable(); + + // 2a - b == 0 + cs.new_gate( + [a, b, dummy, dummy], + [two, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // try various combinations + cs.new_gate( + [dummy, b, dummy, a], + [zero, negative_one, zero, two, zero, zero], + [zero] + )?; + + cs.new_gate( + [dummy, b, a, dummy], + [zero, negative_one, two, zero, zero, zero], + [zero] + )?; + + // 10b - c = 0 + let ten = E::Fr::from_str("10").unwrap(); + + cs.new_gate( + [b, c, dummy, dummy], + [ten, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // same, try various combinations + + cs.new_gate( + [dummy, c, dummy, b], + [zero, negative_one, zero, ten, zero, zero], + [zero] + )?; + + cs.new_gate( + [dummy, c, b, dummy], + [zero, negative_one, ten, zero, zero, zero], + [zero] + )?; + + // c - a*b == 0 + + cs.new_gate( + [a, b, dummy, c], + [zero, zero, zero, negative_one, one, zero], + [zero] + )?; + + cs.new_gate( + [a, b, c, dummy], + [zero, zero, negative_one, zero, one, zero], + [zero] + )?; + + // 10a + 10b - c - d == 0 + + cs.new_gate( + [a, b, c, d], + [ten, ten, negative_one, negative_one, zero, zero], + [zero] + )?; + + cs.new_gate( + [a, d, b, c], + [ten, negative_one, ten, negative_one, zero, zero], + [zero] + )?; + + // 2d - c == 0 + + cs.new_gate( + [d, c, dummy, dummy], + [two, negative_one, zero, zero, zero, zero], + [zero] + )?; + + cs.new_gate( + [d, c, dummy, d], + [one, negative_one, zero, one, zero, zero], + [zero] + )?; + + // make a gate that affects next step + + // 10a + 10b - c - (something in d on next step) == 0, then + // d + 0 + 0 - d = 0 + + cs.new_gate( + [a, b, c, dummy], + [ten, ten, negative_one, zero, zero, zero], + [negative_one] + )?; + + cs.new_gate( + [d, dummy, dummy, d], + [one, zero, zero, negative_one, zero, zero], + [zero] + )?; + + // check internal constant + + cs.new_gate( + [d, dummy, dummy, dummy], + [negative_one, zero, zero, zero, zero, E::Fr::from_str("100").unwrap()], + [zero] + )?; + + Ok(()) + } + } + + #[test] + fn test_prove_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + use crate::plonk::better_cs::generator::*; + use crate::plonk::better_cs::keys::*; + + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.clone().synthesize(&mut assembly).expect("must work"); + + // println!("{:?}", assembly); + + assembly.finalize(); + + let worker = Worker::new(); + + let setup = assembly.setup(&worker).unwrap(); + + let crs_mons = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + let crs_vals = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs_mons + ).unwrap(); + + // println!("Verification key = {:?}", verification_key); + + let precomputations = SetupPolynomialsPrecomputations::from_setup( + &setup, + &worker + ).unwrap(); + + let mut assembly = ProverAssembly4WithNextStep::::new(); + + circuit.clone().synthesize(&mut assembly).expect("must work"); + + assembly.finalize(); + + let size = setup.permutation_polynomials[0].size(); + + type Transcr = Blake2sTranscript; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + let proof = assembly.prove::( + &worker, + &setup, + &precomputations, + &crs_vals, + &crs_mons, + &omegas_bitreversed, + &omegas_inv_bitreversed, + ).unwrap(); + + let is_valid = verify::(&proof, &verification_key).unwrap(); + + assert!(is_valid); + + } +} \ No newline at end of file diff --git a/src/plonk/better_cs/prover/mod.rs b/src/plonk/better_cs/prover/mod.rs new file mode 100644 index 000000000..efe0175f5 --- /dev/null +++ b/src/plonk/better_cs/prover/mod.rs @@ -0,0 +1,1192 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use crate::plonk::domains::*; + +use std::marker::PhantomData; + +use super::cs::*; +use super::keys::{SetupPolynomials, Proof, SetupPolynomialsPrecomputations}; + +use crate::source::{DensityTracker, DensityTrackerersChain}; + +use crate::kate_commitment::*; +use super::utils::*; + +use crate::plonk::commitments::transcript::*; +use crate::plonk::fft::cooley_tukey_ntt::*; + +use super::LDE_FACTOR; + +pub(crate) mod prove_steps; + +// #[derive(Debug, Clone)] +pub struct ProverAssembly> { + m: usize, + n: usize, + // input_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + // aux_gates: Vec<(P::StateVariables, P::ThisTraceStepCoefficients, P::NextTraceStepCoefficients)>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + wire_assignments: Vec>, + + // aux_densities: Vec, + + inputs_map: Vec, + dummy_var: Variable, + + is_finalized: bool, + + _marker: std::marker::PhantomData

+} + +impl> ConstraintSystem for ProverAssembly { + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + // there is an implicit gate to constraint the input + // and it's handled during the proving + self.n += 1; + + Ok(input_var) + + } + + // allocate an abstract gate + fn new_gate(&mut self, + variables: P::StateVariables, + _this_step_coeffs: P::ThisTraceStepCoefficients, + _next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> + { + for (idx, &v) in variables.as_ref().iter().enumerate() { + let val = self.get_value(v)?; + self.wire_assignments[idx].push(val); + } + self.n += 1; + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Aux(0)) => { + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + unreachable!(); + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl> ProverAssembly { + pub fn new() -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + wire_assignments: vec![vec![]; P::STATE_WIDTH], + + // aux_densities: vec![DensityTracker::new(); P::STATE_WIDTH], + + inputs_map: vec![], + dummy_var: Variable(Index::Aux(0)), + + is_finalized: false, + + _marker: std::marker::PhantomData + }; + + tmp + } + + pub fn new_with_size_hints(num_inputs: usize, num_aux: usize) -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: Vec::with_capacity(num_inputs), + aux_assingments: Vec::with_capacity(num_aux), + + wire_assignments: vec![Vec::with_capacity(num_inputs + num_aux); P::STATE_WIDTH], + + // aux_densities: vec![DensityTracker::new(); P::STATE_WIDTH], + + inputs_map: Vec::with_capacity(num_inputs), + dummy_var: Variable(Index::Aux(0)), + + is_finalized: false, + + _marker: std::marker::PhantomData + }; + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + Variable(Index::Aux(0)) + } + + pub fn num_gates(&self) -> usize { + self.n + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let n = self.n; + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + self.n = (n+1).next_power_of_two() - 1; + + self.is_finalized = true; + } + + // pub fn make_witness_polynomials( + // self + // ) -> Result<(Vec>, Vec), SynthesisError> + // { + // assert!(self.is_finalized); + + // let mut full_assignments = vec![Vec::with_capacity((self.n+1).next_power_of_two()); self.wire_assignments.len()]; + + // for inp in self.input_assingments.into_iter() { + // // inputs will always go into A wire + // full_assignments[0].push(inp); + // for i in 1..full_assignments.len() { + // full_assignments[i].push(E::Fr::zero()); + // } + // } + + // for (idx, aux) in self.wire_assignments.into_iter().enumerate() { + // full_assignments[idx].extend(aux); + // full_assignments[idx].resize((self.n+1).next_power_of_two() - 1, E::Fr::zero()); + // } + + // let mut aux_densities = self.aux_densities; + + // for d in aux_densities.iter_mut() { + // d.pad((self.n+1).next_power_of_two() - 1); + // } + + // for a in full_assignments.iter() { + // assert_eq!(a.len(), (self.n+1).next_power_of_two() - 1); + // } + + // Ok((full_assignments, aux_densities)) + // } + + pub fn make_witness_polynomials( + self + ) -> Result>, SynthesisError> + { + assert!(self.is_finalized); + + let mut full_assignments = vec![Vec::with_capacity((self.n+1).next_power_of_two()); self.wire_assignments.len()]; + + for inp in self.input_assingments.into_iter() { + // inputs will always go into A wire + full_assignments[0].push(inp); + for i in 1..full_assignments.len() { + full_assignments[i].push(E::Fr::zero()); + } + } + + for (idx, aux) in self.wire_assignments.into_iter().enumerate() { + full_assignments[idx].extend(aux); + full_assignments[idx].resize((self.n+1).next_power_of_two() - 1, E::Fr::zero()); + } + + for a in full_assignments.iter() { + assert_eq!(a.len(), (self.n+1).next_power_of_two() - 1); + } + + Ok(full_assignments) + } +} + +// later we can alias traits +// pub trait PlonkCsWidth3WithNextStep = ConstraintSystem; + +pub type ProverAssembly3WithNextStep = ProverAssembly; +pub type ProverAssembly4WithNextStep = ProverAssembly; + +impl ProverAssembly4WithNextStep { + pub fn prove, CP: CTPrecomputations, CPI: CTPrecomputations>( + self, + worker: &Worker, + setup: &SetupPolynomials, + setup_precomputations: &SetupPolynomialsPrecomputations, + crs_vals: &Crs, + crs_mon: &Crs, + omegas_bitreversed: &CP, + omegas_inv_bitreversed: &CPI, + transcript_init_params: Option< >:: InitializationParameters>, + ) -> Result, SynthesisError> { + use crate::pairing::CurveAffine; + use std::sync::Arc; + + let mut transcript = if let Some(p) = transcript_init_params { + T::new_from_params(p) + } else { + T::new() + }; + + assert!(self.is_finalized); + + let input_values = self.input_assingments.clone(); + + for inp in input_values.iter() { + transcript.commit_field_element(inp); + } + + let n = self.n; + let num_inputs = self.num_inputs; + + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let full_assignments = self.make_witness_polynomials()?; + + let mut proof = Proof::::empty(); + proof.n = n; + proof.num_inputs = num_inputs; + proof.input_values = input_values.clone(); + + let coset_factor = E::Fr::multiplicative_generator(); + + // let coset_factor = E::Fr::one(); + + // Commit wire polynomials + + for wire_poly in full_assignments.iter() { + let commitment = commit_using_raw_values( + &wire_poly, + &crs_vals, + &worker + )?; + + commit_point_as_xy::(&mut transcript, &commitment); + + proof.wire_commitments.push(commitment); + } + + // now transform assignments in the polynomials + + let mut assignment_polynomials = vec![]; + for p in full_assignments.into_iter() { + let p = Polynomial::from_values_unpadded(p)?; + assignment_polynomials.push(p); + } + + // make grand product polynomials + + // draw challenges for grand products + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut grand_products_protos_with_gamma = assignment_polynomials.clone(); + + // add gamma here to save computations later + for p in grand_products_protos_with_gamma.iter_mut() { + p.add_constant(&worker, &gamma); + } + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta); + + let non_residues = make_non_residues::( + >::STATE_WIDTH - 1 + ); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let z_den = { + assert_eq!( + setup_precomputations.permutation_polynomials_values_of_size_n_minus_one.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = setup_precomputations.permutation_polynomials_values_of_size_n_minus_one.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, &permutation_polys_it.next().unwrap(), &beta); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, &perm, &beta); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + // println!("Z last = {}", z.as_ref().last().unwrap()); + // assert!(z.as_ref().last().expect("must exist") == &E::Fr::one()); + + let z_commitment = commit_using_values( + &z, + &crs_vals, + &worker + )?; + proof.grand_product_commitment = z_commitment; + + commit_point_as_xy::(&mut transcript, &proof.grand_product_commitment); + + // interpolate on the main domain + let z_in_monomial_form = z.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // those are z(x*Omega) formally + let mut z_shifted_in_monomial_form = z_in_monomial_form.clone(); + z_shifted_in_monomial_form.distribute_powers(&worker, z_in_monomial_form.omega); + + // now we have to LDE everything and compute quotient polynomial + // also to save on openings that we will have to do from the monomial form anyway + + let mut witness_polys_in_monomial_form = vec![]; + + let mut witness_ldes_on_coset = vec![]; + let mut witness_next_ldes_on_coset = vec![]; + + for (idx, w) in assignment_polynomials.into_iter().enumerate() { + let monomial = w.clone_padded_to_domain()?.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + witness_polys_in_monomial_form.push(monomial.clone()); + + // this is D polynomial and we need to make next + if idx == >::STATE_WIDTH - 1 { + let mut d_next = monomial.clone(); + d_next.distribute_powers(&worker, d_next.omega); + + let lde = d_next.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + witness_next_ldes_on_coset.push(lde); + } + + let lde = monomial.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + witness_ldes_on_coset.push(lde); + } + + let alpha = transcript.get_challenge(); + + // calculate first part of the quotient polynomial - the gate itself + // A + B + C + D + AB + CONST + D_NEXT == 0 everywhere but on the last point of the domain + + let mut quotient_linearization_challenge = E::Fr::one(); + + let (mut t_1, mut tmp) = { + // Include the public inputs + let mut inputs_poly = Polynomial::::new_for_size(required_domain_size)?; + for (idx, &input) in input_values.iter().enumerate() { + inputs_poly.as_mut()[idx] = input; + } + // go into monomial form + + let mut inputs_poly = inputs_poly.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // add constants selectors vector + inputs_poly.add_assign(&worker, setup.selector_polynomials.last().unwrap()); + + // LDE + let mut t_1 = inputs_poly.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + // Q_A * A + let mut tmp = setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[0].clone(); + tmp.mul_assign(&worker, &witness_ldes_on_coset[0]); + t_1.add_assign(&worker, &tmp); + + // Q_B * B + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[1]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[1]); + t_1.add_assign(&worker, &tmp); + + // Q_C * C + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[2]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[2]); + t_1.add_assign(&worker, &tmp); + + // Q_D * D + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[3]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[3]); + t_1.add_assign(&worker, &tmp); + + // Q_M * A * B + tmp.reuse_allocation(&setup_precomputations.selector_polynomials_on_coset_of_size_4n_bitreversed[4]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[0]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[1]); + t_1.add_assign(&worker, &tmp); + + tmp.reuse_allocation(&setup_precomputations.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed[0]); + tmp.mul_assign(&worker, &witness_next_ldes_on_coset[0]); + t_1.add_assign(&worker, &tmp); + + (t_1, tmp) + }; + + // drop(witness_ldes_on_coset); + drop(witness_next_ldes_on_coset); + + // now compute the permutation argument + + let z_coset_lde_bitreversed = z_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + assert!(z_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + let z_shifted_coset_lde_bitreversed = z_shifted_in_monomial_form.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + assert!(z_shifted_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + + quotient_linearization_challenge.mul_assign(&alpha); + + { + let mut contrib_z = z_coset_lde_bitreversed.clone(); + + // A + beta*X + gamma + + tmp.reuse_allocation(&witness_ldes_on_coset[0]); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &setup_precomputations.x_on_coset_of_size_4n_bitreversed, &beta); + contrib_z.mul_assign(&worker, &tmp); + + assert_eq!(non_residues.len() + 1, witness_ldes_on_coset.len()); + + for (w, non_res) in witness_ldes_on_coset[1..].iter().zip(non_residues.iter()) { + let mut factor = beta; + factor.mul_assign(&non_res); + + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &setup_precomputations.x_on_coset_of_size_4n_bitreversed, &factor); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.add_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + + let mut contrib_z = z_shifted_coset_lde_bitreversed; + + // A + beta*perm_a + gamma + + assert_eq!( + setup_precomputations.permutation_polynomials_on_coset_of_size_4n_bitreversed.len(), witness_ldes_on_coset.len() + ); + + for (w, perm) in witness_ldes_on_coset.iter() + .zip(setup_precomputations.permutation_polynomials_on_coset_of_size_4n_bitreversed.iter()) { + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, &perm, &beta); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.sub_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // z(omega^0) - 1 == 0 + + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + { + let mut z_minus_one_by_l_0 = z_coset_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + let l_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + omegas_bitreversed, + &coset_factor + )?; + + z_minus_one_by_l_0.mul_assign(&worker, &l_coset_lde_bitreversed); + + t_1.add_assign_scaled(&worker, &z_minus_one_by_l_0, "ient_linearization_challenge); + + drop(z_minus_one_by_l_0); + } + + drop(tmp); + + t_1.mul_assign(&worker, &setup_precomputations.inverse_divisor_on_coset_of_size_4n_bitreversed); + + t_1.bitreverse_enumeration(&worker); + + let t_poly_in_monomial_form = t_1.icoset_fft_for_generator(&worker, &E::Fr::multiplicative_generator()); + + let mut t_poly_parts = t_poly_in_monomial_form.break_into_multiples(required_domain_size)?; + + for t_part in t_poly_parts.iter() { + let t_part_commitment = commit_using_monomials( + &t_part, + &crs_mon, + &worker + )?; + + commit_point_as_xy::(&mut transcript, &t_part_commitment); + + proof.quotient_poly_commitments.push(t_part_commitment); + } + + // draw random point + + let z = transcript.get_challenge(); + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + for (idx, p) in witness_polys_in_monomial_form.iter().enumerate() { + let value_at_z = p.evaluate_at(&worker, z); + proof.wire_values_at_z.push(value_at_z); + if idx == 3 { + let value_at_z_omega = p.evaluate_at(&worker, z_by_omega); + proof.wire_values_at_z_omega.push(value_at_z_omega); + } + } + + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + let value_at_z = p.evaluate_at(&worker, z); + proof.permutation_polynomials_at_z.push(value_at_z); + } + + let z_at_z_omega = z_in_monomial_form.evaluate_at(&worker, z_by_omega); + proof.grand_product_at_z_omega = z_at_z_omega; + + let t_at_z = { + let mut result = E::Fr::zero(); + let mut current = E::Fr::one(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + for p in t_poly_parts.iter() { + let mut subvalue_at_z = p.evaluate_at(&worker, z); + subvalue_at_z.mul_assign(¤t); + result.add_assign(&subvalue_at_z); + current.mul_assign(&z_in_domain_size); + } + + result + }; + + proof.quotient_polynomial_at_z = t_at_z; + + for el in proof.wire_values_at_z.iter() { + transcript.commit_field_element(el); + } + + for el in proof.wire_values_at_z_omega.iter() { + transcript.commit_field_element(el); + } + + for el in proof.permutation_polynomials_at_z.iter() { + transcript.commit_field_element(el); + } + + transcript.commit_field_element(&proof.quotient_polynomial_at_z); + + // now compute linearization_polynomial in a monomial form + + let mut quotient_linearization_challenge = E::Fr::one(); + + let r = { + // Q_const + let mut r = setup.selector_polynomials[5].clone(); + + // Q_A * A(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[0], &proof.wire_values_at_z[0]); + + // Q_B * B(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[1], &proof.wire_values_at_z[1]); + + // Q_C * C(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[2], &proof.wire_values_at_z[2]); + + // Q_D * D(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[3], &proof.wire_values_at_z[3]); + + // Q_M * A(z) * B(z) + let mut scaling_factor = proof.wire_values_at_z[0]; + scaling_factor.mul_assign(&proof.wire_values_at_z[1]); + r.add_assign_scaled(&worker, &setup.selector_polynomials[4], &scaling_factor); + + // Q_D_Next * D(z*omega) + + r.add_assign_scaled(&worker, &setup.next_step_selector_polynomials[0], &proof.wire_values_at_z_omega[0]); + + quotient_linearization_challenge.mul_assign(&alpha); + + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let mut factor = quotient_linearization_challenge; + for (wire_at_z, non_residue) in proof.wire_values_at_z.iter() + .zip(Some(E::Fr::one()).iter().chain(&non_residues)) + { + let mut t = z; + t.mul_assign(&non_residue); + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.add_assign_scaled(&worker, &z_in_monomial_form, &factor); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = quotient_linearization_challenge; + factor.mul_assign(&beta); + factor.mul_assign(&z_at_z_omega); + + for (wire_at_z, perm_at_z) in proof.wire_values_at_z.iter() + .zip(proof.permutation_polynomials_at_z.iter()) + { + let mut t = *perm_at_z; + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.sub_assign_scaled(&worker, &setup.permutation_polynomials.last().expect("last permutation poly"), &factor); + + // + L_0(z) * Z(x) + + quotient_linearization_challenge.mul_assign(&alpha); + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign("ient_linearization_challenge); + + r.add_assign_scaled(&worker, &z_in_monomial_form, &factor); + + r + }; + + // commit the linearization polynomial + + let r_at_z = r.evaluate_at(&worker, z); + proof.linearization_polynomial_at_z = r_at_z; + + transcript.commit_field_element(&proof.linearization_polynomial_at_z); + + transcript.commit_field_element(&proof.grand_product_at_z_omega); + + // sanity check - verification + { + let mut lhs = t_at_z; + let vanishing_at_z = evaluate_vanishing_for_size(&z ,required_domain_size as u64); + lhs.mul_assign(&vanishing_at_z); + + let mut quotient_linearization_challenge = E::Fr::one(); + + let mut rhs = r_at_z; + + // add public inputs + { + for (idx, input) in input_values.iter().enumerate() { + let mut tmp = evaluate_lagrange_poly_at_point(idx, &domain, z)?; + tmp.mul_assign(&input); + + rhs.add_assign(&tmp); + } + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // - \alpha (a + perm(z) * beta + gamma)*()*(d + gamma) & z(z*omega) + + let mut z_part = z_at_z_omega; + + assert_eq!(proof.permutation_polynomials_at_z.len() + 1, proof.wire_values_at_z.len()); + + for (w, p) in proof.wire_values_at_z.iter().zip(proof.permutation_polynomials_at_z.iter()) { + let mut tmp = *p; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&w); + + z_part.mul_assign(&tmp); + } + + // last poly value and gamma + let mut tmp = gamma; + tmp.add_assign(&proof.wire_values_at_z.iter().rev().next().unwrap()); + + z_part.mul_assign(&tmp); + z_part.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&z_part); + + quotient_linearization_challenge.mul_assign(&alpha); + + // - L_0(z) * \alpha^2 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&l_0_at_z); + + if lhs != rhs { + return Err(SynthesisError::Unsatisfiable); + } + } + + // get multiopening challenge + + let v = transcript.get_challenge(); + + // open at z: + // t_i(x) * z^{domain_size*i} + // r(x) + // witnesses + // permutations except of the last one + + // open at z*omega: + // z(x) + // next step witnesses (if any) + + let mut multiopening_challenge = E::Fr::one(); + + let mut poly_to_divide_at_z = t_poly_parts.drain(0..1).collect::>().pop().unwrap(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + let mut power_of_z = z_in_domain_size; + for t_part in t_poly_parts.into_iter() { + poly_to_divide_at_z.add_assign_scaled(&worker, &t_part, &power_of_z); + power_of_z.mul_assign(&z_in_domain_size); + } + + // linearization polynomial + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &r, &multiopening_challenge); + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 as u64])); + + // all witness polys + for w in witness_polys_in_monomial_form.iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &w, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4) as u64])); + + // all except of the last permutation polys + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &p, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3) as u64])); + + multiopening_challenge.mul_assign(&v); + + let mut poly_to_divide_at_z_omega = z_in_monomial_form; + poly_to_divide_at_z_omega.scale(&worker, multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + + // d should be opened at z*omega due to d_next + poly_to_divide_at_z_omega.add_assign_scaled(&worker, &witness_polys_in_monomial_form[3], &multiopening_challenge); + drop(witness_polys_in_monomial_form); + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3 + 1 + 1) as u64])); + + // division in monomial form is sequential, so we parallelize the divisions + + let mut polys = vec![(poly_to_divide_at_z, z), (poly_to_divide_at_z_omega, z_by_omega)]; + + worker.scope(polys.len(), |scope, chunk| { + for p in polys.chunks_mut(chunk) { + scope.spawn(move |_| { + let (poly, at) = &p[0]; + let at = *at; + let result = divide_single::(poly.as_ref(), at); + p[0] = (Polynomial::from_coeffs(result).unwrap(), at); + }); + } + }); + + let open_at_z_omega = polys.pop().unwrap().0; + let open_at_z = polys.pop().unwrap().0; + + let opening_at_z = commit_using_monomials( + &open_at_z, + &crs_mon, + &worker + )?; + + let opening_at_z_omega = commit_using_monomials( + &open_at_z_omega, + &crs_mon, + &worker + )?; + + proof.opening_at_z_proof = opening_at_z; + proof.opening_at_z_omega_proof = opening_at_z_omega; + + Ok(proof) + } +} + +#[cfg(test)] +mod test { + use super::*; + use super::super::verifier::verify; + + use crate::pairing::Engine; + + #[derive(Clone)] + struct TestCircuit4{ + _marker: PhantomData + } + + impl Circuit for TestCircuit4 { + fn synthesize >(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc_input(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc_input(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let d = cs.alloc(|| { + Ok(E::Fr::from_str("100").unwrap()) + })?; + + println!("D = {:?}", d); + + let zero = E::Fr::zero(); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + let dummy = cs.get_dummy_variable(); + + // 2a - b == 0 + cs.new_gate( + [a, b, dummy, dummy], + [two, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // try various combinations + cs.new_gate( + [dummy, b, dummy, a], + [zero, negative_one, zero, two, zero, zero], + [zero] + )?; + + cs.new_gate( + [dummy, b, a, dummy], + [zero, negative_one, two, zero, zero, zero], + [zero] + )?; + + // 10b - c = 0 + let ten = E::Fr::from_str("10").unwrap(); + + cs.new_gate( + [b, c, dummy, dummy], + [ten, negative_one, zero, zero, zero, zero], + [zero] + )?; + + // same, try various combinations + + cs.new_gate( + [dummy, c, dummy, b], + [zero, negative_one, zero, ten, zero, zero], + [zero] + )?; + + cs.new_gate( + [dummy, c, b, dummy], + [zero, negative_one, ten, zero, zero, zero], + [zero] + )?; + + // c - a*b == 0 + + cs.new_gate( + [a, b, dummy, c], + [zero, zero, zero, negative_one, one, zero], + [zero] + )?; + + cs.new_gate( + [a, b, c, dummy], + [zero, zero, negative_one, zero, one, zero], + [zero] + )?; + + // 10a + 10b - c - d == 0 + + cs.new_gate( + [a, b, c, d], + [ten, ten, negative_one, negative_one, zero, zero], + [zero] + )?; + + cs.new_gate( + [a, d, b, c], + [ten, negative_one, ten, negative_one, zero, zero], + [zero] + )?; + + // 2d - c == 0 + + cs.new_gate( + [d, c, dummy, dummy], + [two, negative_one, zero, zero, zero, zero], + [zero] + )?; + + cs.new_gate( + [d, c, dummy, d], + [one, negative_one, zero, one, zero, zero], + [zero] + )?; + + // make a gate that affects next step + + // 10a + 10b - c - (something in d on next step) == 0, then + // d + 0 + 0 - d = 0 + + cs.new_gate( + [a, b, c, dummy], + [ten, ten, negative_one, zero, zero, zero], + [negative_one] + )?; + + cs.new_gate( + [d, dummy, dummy, d], + [one, zero, zero, negative_one, zero, zero], + [zero] + )?; + + // check internal constant + + cs.new_gate( + [d, dummy, dummy, dummy], + [negative_one, zero, zero, zero, zero, E::Fr::from_str("100").unwrap()], + [zero] + )?; + + Ok(()) + } + } + + #[test] + fn test_prove_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::worker::Worker; + use crate::plonk::better_cs::generator::*; + use crate::plonk::better_cs::keys::*; + + let mut assembly = GeneratorAssembly4WithNextStep::::new(); + + let circuit = TestCircuit4:: { + _marker: PhantomData + }; + + circuit.clone().synthesize(&mut assembly).expect("must work"); + + // println!("{:?}", assembly); + + assembly.finalize(); + + let worker = Worker::new(); + + let setup = assembly.setup(&worker).unwrap(); + + let crs_mons = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + let crs_vals = Crs::::crs_42(setup.permutation_polynomials[0].size(), &worker); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs_mons + ).unwrap(); + + // println!("Verification key = {:?}", verification_key); + + let precomputations = SetupPolynomialsPrecomputations::from_setup( + &setup, + &worker + ).unwrap(); + + let mut assembly = ProverAssembly4WithNextStep::::new(); + + circuit.clone().synthesize(&mut assembly).expect("must work"); + + assembly.finalize(); + + let size = setup.permutation_polynomials[0].size(); + + type Transcr = Blake2sTranscript; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + let proof = assembly.prove::( + &worker, + &setup, + &precomputations, + &crs_vals, + &crs_mons, + &omegas_bitreversed, + &omegas_inv_bitreversed, + None, + ).unwrap(); + + let is_valid = verify::(&proof, &verification_key, None).unwrap(); + + assert!(is_valid); + + } +} \ No newline at end of file diff --git a/src/plonk/better_cs/prover/prove_steps.rs b/src/plonk/better_cs/prover/prove_steps.rs new file mode 100644 index 000000000..cdf407f81 --- /dev/null +++ b/src/plonk/better_cs/prover/prove_steps.rs @@ -0,0 +1,1331 @@ +use super::*; + +pub(crate) enum PrecomputationsForPolynomial<'a, F: PrimeField> { + Borrowed(&'a Polynomial), + Owned(Polynomial), + None +} + +impl<'a, F: PrimeField> AsRef> for PrecomputationsForPolynomial<'a, F> { + fn as_ref(&self) -> &Polynomial { + match self { + PrecomputationsForPolynomial::Borrowed(b) => { + b + }, + PrecomputationsForPolynomial::Owned(o) => { + &o + } + PrecomputationsForPolynomial::None => { + unreachable!("precomputations must have been made"); + } + } + } +} + +impl<'a, F: PrimeField> PrecomputationsForPolynomial<'a, F> { + pub(crate) fn into_poly(self) -> Polynomial { + match self { + PrecomputationsForPolynomial::Borrowed(b) => { + b.clone() + }, + PrecomputationsForPolynomial::Owned(o) => { + o + } + PrecomputationsForPolynomial::None => { + unreachable!("precomputations must have been made"); + } + } + } +} + +pub(crate) fn get_precomputed_permutation_poly_lde_for_index<'a, E: Engine, CP: CTPrecomputations>( + index: usize, + domain_size: usize, + setup: &SetupPolynomials, + setup_precomputations: &Option< &'a SetupPolynomialsPrecomputations >, + precomputed_omegas: &mut PrecomputedOmegas, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + + if let Some(prec) = setup_precomputations { + let p = &prec.permutation_polynomials_on_coset_of_size_4n_bitreversed[index]; + + return Ok(PrecomputationsForPolynomial::Borrowed(p)); + } else { + match &*precomputed_omegas { + PrecomputedOmegas::None => { + *precomputed_omegas = PrecomputedOmegas::Owned(CP::new_for_domain_size(domain_size), E::Fr::one()); + } + _ => {} + } + + let p = setup.permutation_polynomials[index] + .clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + return Ok(PrecomputationsForPolynomial::Owned(p)); + } +} + +pub(crate) fn get_precomputed_selector_lde_for_index<'a, E: Engine, CP: CTPrecomputations>( + index: usize, + domain_size: usize, + setup: &SetupPolynomials, + setup_precomputations: &Option< &'a SetupPolynomialsPrecomputations >, + precomputed_omegas: &mut PrecomputedOmegas, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + + if let Some(prec) = setup_precomputations { + let p = &prec.selector_polynomials_on_coset_of_size_4n_bitreversed[index]; + + return Ok(PrecomputationsForPolynomial::Borrowed(p)); + } else { + match &*precomputed_omegas { + PrecomputedOmegas::None => { + *precomputed_omegas = PrecomputedOmegas::Owned(CP::new_for_domain_size(domain_size), E::Fr::one()); + } + _ => {} + } + + let p = setup.selector_polynomials[index] + .clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + return Ok(PrecomputationsForPolynomial::Owned(p)); + } +} + +pub(crate) fn get_precomputed_next_step_selector_lde_for_index<'a, E: Engine, CP: CTPrecomputations>( + index: usize, + domain_size: usize, + setup: &SetupPolynomials, + setup_precomputations: &Option< &'a SetupPolynomialsPrecomputations >, + precomputed_omegas: &mut PrecomputedOmegas, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + + if let Some(prec) = setup_precomputations { + let p = &prec.next_step_selector_polynomials_on_coset_of_size_4n_bitreversed[index]; + + return Ok(PrecomputationsForPolynomial::Borrowed(p)); + } else { + match &*precomputed_omegas { + PrecomputedOmegas::None => { + *precomputed_omegas = PrecomputedOmegas::Owned(CP::new_for_domain_size(domain_size), E::Fr::one()); + } + _ => {} + } + + let p = setup.next_step_selector_polynomials[index] + .clone() + .bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + return Ok(PrecomputationsForPolynomial::Owned(p)); + } +} + +pub(crate) fn get_precomputed_x_lde<'a, E: Engine>( + domain_size: usize, + setup_precomputations: &Option< &'a SetupPolynomialsPrecomputations >, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + + if let Some(prec) = setup_precomputations { + let p = &prec.x_on_coset_of_size_4n_bitreversed; + + return Ok(PrecomputationsForPolynomial::Borrowed(p)); + } else { + let mut x_poly = Polynomial::from_values(vec![ + coset_factor; + domain_size * LDE_FACTOR + ])?; + x_poly.distribute_powers(&worker, x_poly.omega); + x_poly.bitreverse_enumeration(&worker); + + return Ok(PrecomputationsForPolynomial::Owned(x_poly)); + } +} + +pub(crate) fn get_precomputed_inverse_divisor<'a, E: Engine>( + domain_size: usize, + setup_precomputations: &Option< &'a SetupPolynomialsPrecomputations >, + worker: &Worker +) -> Result, SynthesisError> { + let coset_factor = E::Fr::multiplicative_generator(); + + if let Some(prec) = setup_precomputations { + let p = &prec.inverse_divisor_on_coset_of_size_4n_bitreversed; + + return Ok(PrecomputationsForPolynomial::Borrowed(p)); + } else { + let mut vanishing_poly_inverse_bitreversed = + evaluate_vanishing_polynomial_of_degree_on_domain_size::( + domain_size as u64, + &coset_factor, + (domain_size * LDE_FACTOR) as u64, + &worker, + )?; + vanishing_poly_inverse_bitreversed.batch_inversion(&worker)?; + vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker); + + return Ok(PrecomputationsForPolynomial::Owned(vanishing_poly_inverse_bitreversed)); + } +} + +pub(crate) enum PrecomputedOmegas<'a, F: PrimeField, CP: CTPrecomputations> { + Borrowed(&'a CP, F), + Owned(CP, F), + None +} + +impl<'a, F: PrimeField, CP: CTPrecomputations> AsRef for PrecomputedOmegas<'a, F, CP> { + fn as_ref(&self) -> &CP { + match self { + PrecomputedOmegas::Borrowed(b, _) => { + b + }, + PrecomputedOmegas::Owned(o, _) => { + &o + } + PrecomputedOmegas::None => { + unreachable!("precomputations must have been made"); + } + } + } +} + +pub(crate) struct FirstPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_as_coeffs: Vec>, + witness_polys_unpadded_values: Vec>, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct FirstProverMessage> { + pub(crate) n: usize, + pub(crate) num_inputs: usize, + pub(crate) input_values: Vec, + pub(crate) wire_commitments: Vec, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct FirstVerifierMessage> { + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + + pub(crate) _marker: std::marker::PhantomData

+} + +pub(crate) struct SecondPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_as_coeffs: Vec>, + z_in_monomial_form: Polynomial, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct SecondProverMessage> { + pub(crate) z_commitment: E::G1Affine, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct SecondVerifierMessage> { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + + pub(crate) _marker: std::marker::PhantomData

+} + +pub(crate) struct ThirdPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_as_coeffs: Vec>, + z_in_monomial_form: Polynomial, + t_poly_parts: Vec>, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct ThirdProverMessage> { + pub(crate) quotient_poly_commitments: Vec, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct ThirdVerifierMessage> { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + pub(crate) z: E::Fr, + + pub(crate) _marker: std::marker::PhantomData

+} + +pub(crate) struct FourthPartialProverState> { + required_domain_size: usize, + non_residues: Vec, + input_values: Vec, + witness_polys_as_coeffs: Vec>, + z_in_monomial_form: Polynomial, + t_poly_parts: Vec>, + linearization_polynomial: Polynomial, + wire_values_at_z: Vec, + wire_values_at_z_omega: Vec, + permutation_polynomials_at_z: Vec, + grand_product_at_z_omega: E::Fr, + quotient_polynomial_at_z: E::Fr, + linearization_polynomial_at_z: E::Fr, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct FourthProverMessage> { + pub(crate) wire_values_at_z: Vec, + pub(crate) wire_values_at_z_omega: Vec, + pub(crate) permutation_polynomials_at_z: Vec, + pub(crate) grand_product_at_z_omega: E::Fr, + pub(crate) quotient_polynomial_at_z: E::Fr, + pub(crate) linearization_polynomial_at_z: E::Fr, + + _marker: std::marker::PhantomData

+} + +pub(crate) struct FourthVerifierMessage> { + pub(crate) alpha: E::Fr, + pub(crate) beta: E::Fr, + pub(crate) gamma: E::Fr, + pub(crate) z: E::Fr, + pub(crate) v: E::Fr, + + pub(crate) _marker: std::marker::PhantomData

+} + +pub(crate) struct FifthProverMessage> { + pub(crate) opening_proof_at_z: E::G1Affine, + pub(crate) opening_proof_at_z_omega: E::G1Affine, + + _marker: std::marker::PhantomData

+} + +impl ProverAssembly4WithNextStep { + pub(crate) fn first_step_with_lagrange_form_key( + self, + worker: &Worker, + crs_vals: &Crs, + ) -> Result<( + FirstPartialProverState, + FirstProverMessage + ), SynthesisError> + { + use crate::pairing::CurveAffine; + use std::sync::Arc; + + assert!(self.is_finalized); + + let input_values = self.input_assingments.clone(); + + let n = self.n; + let num_inputs = self.num_inputs; + + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let non_residues = make_non_residues::( + >::STATE_WIDTH - 1 + ); + + let full_assignments = self.make_witness_polynomials()?; + + // Commit wire polynomials + + let mut first_message = FirstProverMessage:: { + n: n, + num_inputs: num_inputs, + input_values: input_values.clone(), + wire_commitments: Vec::with_capacity(4), + + _marker: std::marker::PhantomData + }; + + for wire_poly in full_assignments.iter() { + let commitment = commit_using_raw_values( + &wire_poly, + &crs_vals, + &worker + )?; + + first_message.wire_commitments.push(commitment); + } + + // now transform assignments in the polynomials + + let mut assignment_polynomials = vec![]; + for p in full_assignments.into_iter() { + let p = Polynomial::from_values_unpadded(p)?; + assignment_polynomials.push(p); + } + + let state = FirstPartialProverState:: { + required_domain_size, + non_residues, + input_values: input_values.clone(), + witness_polys_as_coeffs: vec![], + witness_polys_unpadded_values: assignment_polynomials, + + _marker: std::marker::PhantomData + }; + + Ok((state, first_message)) + } + + pub(crate) fn first_step_with_monomial_form_key>( + self, + worker: &Worker, + crs_mons: &Crs, + precomputed_omegas_inv: &mut PrecomputedOmegas + ) -> Result<( + FirstPartialProverState, + FirstProverMessage + ), SynthesisError> + { + use crate::pairing::CurveAffine; + use std::sync::Arc; + + assert!(self.is_finalized); + + let input_values = self.input_assingments.clone(); + + let n = self.n; + let num_inputs = self.num_inputs; + + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let non_residues = make_non_residues::( + >::STATE_WIDTH - 1 + ); + + let full_assignments = self.make_witness_polynomials()?; + + // Commit wire polynomials + + let mut first_message = FirstProverMessage:: { + n: n, + num_inputs: num_inputs, + input_values: input_values.clone(), + wire_commitments: Vec::with_capacity(4), + + _marker: std::marker::PhantomData + }; + + let mut wire_polys_as_coefficients = Vec::with_capacity(full_assignments.len()); + + match &*precomputed_omegas_inv { + PrecomputedOmegas::None => { + *precomputed_omegas_inv = PrecomputedOmegas::Owned(CPI::new_for_domain_size(required_domain_size), E::Fr::one()); + } + _ => {} + } + + for wire_poly in full_assignments.iter() { + let as_poly = Polynomial::from_values(wire_poly.clone())?; + let as_coeffs = as_poly + .ifft_using_bitreversed_ntt(&worker, precomputed_omegas_inv.as_ref(), &E::Fr::one())?; + + let commitment = commit_using_monomials( + &as_coeffs, + &crs_mons, + &worker + )?; + + wire_polys_as_coefficients.push(as_coeffs); + + first_message.wire_commitments.push(commitment); + } + + // now transform assignments in the polynomials + + let mut assignment_polynomials = vec![]; + for p in full_assignments.into_iter() { + let p = Polynomial::from_values_unpadded(p)?; + assignment_polynomials.push(p); + } + + + let state = FirstPartialProverState:: { + required_domain_size, + non_residues, + input_values: input_values.clone(), + witness_polys_as_coeffs: wire_polys_as_coefficients, + witness_polys_unpadded_values: assignment_polynomials, + + _marker: std::marker::PhantomData + }; + + Ok((state, first_message)) + } + + pub(crate) fn second_step_from_first_step>( + first_state: FirstPartialProverState, + first_verifier_message: FirstVerifierMessage, + setup: &SetupPolynomials, + crs_mons: &Crs, + setup_precomputations: &Option< &SetupPolynomialsPrecomputations >, + precomputed_omegas_inv: &mut PrecomputedOmegas, + worker: &Worker + ) -> Result<( + SecondPartialProverState, + SecondProverMessage + ), SynthesisError> + { + let FirstVerifierMessage { beta, gamma, ..} = first_verifier_message; + + assert_eq!(first_state.witness_polys_unpadded_values.len(), 4, "first state must containt assignment poly values"); + + let mut grand_products_protos_with_gamma = first_state.witness_polys_unpadded_values.clone(); + + // add gamma here to save computations later + for p in grand_products_protos_with_gamma.iter_mut() { + p.add_constant(&worker, &gamma); + } + + let required_domain_size = first_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut domain_elements = materialize_domain_elements_with_natural_enumeration( + &domain, + &worker + ); + + domain_elements.pop().expect("must pop last element for omega^i"); + + let mut domain_elements_poly_by_beta = Polynomial::from_values_unpadded(domain_elements)?; + domain_elements_poly_by_beta.scale(&worker, beta); + + // we take A, B, C, ... values and form (A + beta * X * non_residue + gamma), etc and calculate their grand product + + let mut z_num = { + let mut grand_products_proto_it = grand_products_protos_with_gamma.iter().cloned(); + + let mut z_1 = grand_products_proto_it.next().unwrap(); + z_1.add_assign(&worker, &domain_elements_poly_by_beta); + + for (mut p, non_res) in grand_products_proto_it.zip(first_state.non_residues.iter()) { + p.add_assign_scaled(&worker, &domain_elements_poly_by_beta, non_res); + z_1.mul_assign(&worker, &p); + } + + z_1 + }; + + // we take A, B, C, ... values and form (A + beta * perm_a + gamma), etc and calculate their grand product + + let mut permutation_polynomials_values_of_size_n_minus_one = vec![]; + + if let Some(prec) = setup_precomputations { + for p in prec.permutation_polynomials_values_of_size_n_minus_one.iter() { + let pp = PrecomputationsForPolynomial::Borrowed(p); + permutation_polynomials_values_of_size_n_minus_one.push(pp); + } + } else { + match &*precomputed_omegas_inv { + PrecomputedOmegas::None => { + *precomputed_omegas_inv = PrecomputedOmegas::Owned(CPI::new_for_domain_size(required_domain_size), E::Fr::one()); + } + _ => {} + } + + // we need to only do up to the last one + for p in setup.permutation_polynomials.iter() { + let as_values = p.clone().fft(&worker); + let mut as_values = as_values.into_coeffs(); + as_values + .pop() + .expect("must shorted permutation polynomial values by one"); + + let p = Polynomial::from_values_unpadded(as_values)?; + let p = PrecomputationsForPolynomial::Owned(p); + + permutation_polynomials_values_of_size_n_minus_one.push(p); + } + } + + let z_den = { + assert_eq!( + permutation_polynomials_values_of_size_n_minus_one.len(), + grand_products_protos_with_gamma.len() + ); + let mut grand_products_proto_it = grand_products_protos_with_gamma.into_iter(); + let mut permutation_polys_it = permutation_polynomials_values_of_size_n_minus_one.iter(); + + let mut z_2 = grand_products_proto_it.next().unwrap(); + z_2.add_assign_scaled(&worker, permutation_polys_it.next().unwrap().as_ref(), &beta); + + for (mut p, perm) in grand_products_proto_it + .zip(permutation_polys_it) { + // permutation polynomials + p.add_assign_scaled(&worker, perm.as_ref(), &beta); + z_2.mul_assign(&worker, &p); + } + + z_2.batch_inversion(&worker)?; + + z_2 + }; + + z_num.mul_assign(&worker, &z_den); + drop(z_den); + + let z = z_num.calculate_shifted_grand_product(&worker)?; + + assert!(z.size().is_power_of_two()); + + assert!(z.as_ref()[0] == E::Fr::one()); + // println!("Z last = {}", z.as_ref().last().unwrap()); + // assert!(z.as_ref().last().expect("must exist") == &E::Fr::one()); + + // interpolate on the main domain + let z_in_monomial_form = z.ifft_using_bitreversed_ntt(&worker, precomputed_omegas_inv.as_ref(), &E::Fr::one())?; + + let z_commitment = commit_using_monomials( + &z_in_monomial_form, + &crs_mons, + &worker + )?; + + let state = SecondPartialProverState:: { + required_domain_size, + non_residues: first_state.non_residues, + input_values: first_state.input_values, + witness_polys_as_coeffs: first_state.witness_polys_as_coeffs, + z_in_monomial_form: z_in_monomial_form, + + _marker: std::marker::PhantomData + }; + + let message = SecondProverMessage:: { + z_commitment: z_commitment, + + _marker: std::marker::PhantomData + }; + + Ok((state, message)) + } + + pub(crate) fn third_step_from_second_step, CPI: CTPrecomputations>( + second_state: SecondPartialProverState, + second_verifier_message: SecondVerifierMessage, + setup: &SetupPolynomials, + crs_mons: &Crs, + setup_precomputations: &Option< &SetupPolynomialsPrecomputations >, + precomputed_omegas: &mut PrecomputedOmegas, + precomputed_omegas_inv: &mut PrecomputedOmegas, + worker: &Worker + ) -> Result<( + ThirdPartialProverState, + ThirdProverMessage + ), SynthesisError> + { + let z_in_monomial_form = second_state.z_in_monomial_form; + + // those are z(x*Omega) formally + let mut z_shifted_in_monomial_form = z_in_monomial_form.clone(); + z_shifted_in_monomial_form.distribute_powers(&worker, z_in_monomial_form.omega); + + // now we have to LDE everything and compute quotient polynomial + // also to save on openings that we will have to do from the monomial form anyway + + let witness_polys_in_monomial_form = second_state.witness_polys_as_coeffs; + + let required_domain_size = second_state.required_domain_size; + let coset_factor = E::Fr::multiplicative_generator(); + + match &*precomputed_omegas { + PrecomputedOmegas::None => { + *precomputed_omegas = PrecomputedOmegas::Owned(CP::new_for_domain_size(required_domain_size), E::Fr::one()); + } + _ => {} + } + + match &*precomputed_omegas_inv { + PrecomputedOmegas::None => { + *precomputed_omegas_inv = PrecomputedOmegas::Owned(CPI::new_for_domain_size(required_domain_size), E::Fr::one()); + } + _ => {} + } + + let mut witness_ldes_on_coset = vec![]; + let mut witness_next_ldes_on_coset = vec![]; + + for (idx, monomial) in witness_polys_in_monomial_form.iter().enumerate() { + // this is D polynomial and we need to make next + if idx == >::STATE_WIDTH - 1 { + let mut d_next = monomial.clone(); + d_next.distribute_powers(&worker, d_next.omega); + + let lde = d_next.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + witness_next_ldes_on_coset.push(lde); + } + + let lde = monomial.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + witness_ldes_on_coset.push(lde); + } + + + let SecondVerifierMessage { alpha, beta, gamma, .. } = second_verifier_message; + + // calculate first part of the quotient polynomial - the gate itself + // A + B + C + D + AB + CONST + D_NEXT == 0 everywhere but on the last point of the domain + + let mut quotient_linearization_challenge = E::Fr::one(); + let input_values = second_state.input_values; + + let (mut t_1, mut tmp) = { + // Include the public inputs + let mut inputs_poly = Polynomial::::new_for_size(required_domain_size)?; + for (idx, &input) in input_values.iter().enumerate() { + inputs_poly.as_mut()[idx] = input; + } + // go into monomial form + + let mut inputs_poly = inputs_poly.ifft_using_bitreversed_ntt(&worker, precomputed_omegas_inv.as_ref(), &E::Fr::one())?; + + // add constants selectors vector + inputs_poly.add_assign(&worker, setup.selector_polynomials.last().unwrap()); + + // LDE + let mut t_1 = inputs_poly.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + // t_1 is now q_constant + + // Q_A * A + let mut tmp = witness_ldes_on_coset[0].clone(); + let a_selector = get_precomputed_selector_lde_for_index( + 0, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, &a_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(a_selector); + + // Q_B * B + tmp.reuse_allocation(&witness_ldes_on_coset[1]); + let b_selector = get_precomputed_selector_lde_for_index( + 1, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, &b_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(b_selector); + + // Q_C * C + tmp.reuse_allocation(&witness_ldes_on_coset[2]); + let c_selector = get_precomputed_selector_lde_for_index( + 2, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, c_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(c_selector); + + // Q_D * D + tmp.reuse_allocation(&witness_ldes_on_coset[3]); + let d_selector = get_precomputed_selector_lde_for_index( + 3, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, d_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(d_selector); + + // Q_M * A * B + tmp.reuse_allocation(&witness_ldes_on_coset[0]); + tmp.mul_assign(&worker, &witness_ldes_on_coset[1]); + let m_selector = get_precomputed_selector_lde_for_index( + 4, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, &m_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(m_selector); + + tmp.reuse_allocation(&witness_next_ldes_on_coset[0]); + let d_next_selector = get_precomputed_next_step_selector_lde_for_index( + 0, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.mul_assign(&worker, d_next_selector.as_ref()); + t_1.add_assign(&worker, &tmp); + drop(d_next_selector); + + (t_1, tmp) + }; + + // drop(witness_ldes_on_coset); + drop(witness_next_ldes_on_coset); + + // now compute the permutation argument + + let z_coset_lde_bitreversed = z_in_monomial_form.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + assert!(z_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + let z_shifted_coset_lde_bitreversed = z_shifted_in_monomial_form.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + assert!(z_shifted_coset_lde_bitreversed.size() == required_domain_size*LDE_FACTOR); + + let non_residues = make_non_residues::( + >::STATE_WIDTH - 1 + ); + + // For both Z_1 and Z_2 we first check for grand products + // z*(X)(A + beta*X + gamma)(B + beta*k_1*X + gamma)(C + beta*K_2*X + gamma) - + // - (A + beta*perm_a(X) + gamma)(B + beta*perm_b(X) + gamma)(C + beta*perm_c(X) + gamma)*Z(X*Omega)== 0 + + // we use evaluations of the polynomial X and K_i * X on a large domain's coset + + quotient_linearization_challenge.mul_assign(&alpha); + + { + let mut contrib_z = z_coset_lde_bitreversed.clone(); + + // A + beta*X + gamma + + tmp.reuse_allocation(&witness_ldes_on_coset[0]); + tmp.add_constant(&worker, &gamma); + let x_precomp = get_precomputed_x_lde( + required_domain_size, + setup_precomputations, + &worker + )?; + tmp.add_assign_scaled(&worker, x_precomp.as_ref(), &beta); + contrib_z.mul_assign(&worker, &tmp); + + assert_eq!(non_residues.len() + 1, witness_ldes_on_coset.len()); + + for (w, non_res) in witness_ldes_on_coset[1..].iter().zip(non_residues.iter()) { + let mut factor = beta; + factor.mul_assign(&non_res); + + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, x_precomp.as_ref(), &factor); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.add_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + + let mut contrib_z = z_shifted_coset_lde_bitreversed; + + // A + beta*perm_a + gamma + + for (idx, w) in witness_ldes_on_coset.iter().enumerate() { + let perm = get_precomputed_permutation_poly_lde_for_index( + idx, + required_domain_size, + &setup, + &setup_precomputations, + precomputed_omegas, + &worker + )?; + tmp.reuse_allocation(&w); + tmp.add_constant(&worker, &gamma); + tmp.add_assign_scaled(&worker, perm.as_ref(), &beta); + contrib_z.mul_assign(&worker, &tmp); + } + + t_1.sub_assign_scaled(&worker, &contrib_z, "ient_linearization_challenge); + + drop(contrib_z); + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // z(omega^0) - 1 == 0 + + let l_0 = calculate_lagrange_poly::(&worker, required_domain_size.next_power_of_two(), 0)?; + + { + let mut z_minus_one_by_l_0 = z_coset_lde_bitreversed; + z_minus_one_by_l_0.sub_constant(&worker, &E::Fr::one()); + + let l_coset_lde_bitreversed = l_0.bitreversed_lde_using_bitreversed_ntt( + &worker, + LDE_FACTOR, + precomputed_omegas.as_ref(), + &coset_factor + )?; + + z_minus_one_by_l_0.mul_assign(&worker, &l_coset_lde_bitreversed); + + t_1.add_assign_scaled(&worker, &z_minus_one_by_l_0, "ient_linearization_challenge); + + drop(z_minus_one_by_l_0); + } + + drop(tmp); + + let divisor_inversed = get_precomputed_inverse_divisor( + required_domain_size, + setup_precomputations, + &worker + )?; + t_1.mul_assign(&worker, divisor_inversed.as_ref()); + + t_1.bitreverse_enumeration(&worker); + + let t_poly_in_monomial_form = t_1.icoset_fft_for_generator(&worker, &E::Fr::multiplicative_generator()); + + let t_poly_parts = t_poly_in_monomial_form.break_into_multiples(required_domain_size)?; + + let state = ThirdPartialProverState:: { + required_domain_size, + non_residues: second_state.non_residues, + input_values: input_values, + witness_polys_as_coeffs: witness_polys_in_monomial_form, + z_in_monomial_form: z_in_monomial_form, + t_poly_parts : t_poly_parts, + + _marker: std::marker::PhantomData + }; + + let mut message = ThirdProverMessage:: { + quotient_poly_commitments: Vec::with_capacity(4), + + _marker: std::marker::PhantomData + }; + + for t_part in state.t_poly_parts.iter() { + let t_part_commitment = commit_using_monomials( + &t_part, + &crs_mons, + &worker + )?; + + message.quotient_poly_commitments.push(t_part_commitment); + } + + Ok((state, message)) + } + + pub(crate) fn fourth_step_from_third_step( + third_state: ThirdPartialProverState, + third_verifier_message: ThirdVerifierMessage, + setup: &SetupPolynomials, + worker: &Worker + ) -> Result<( + FourthPartialProverState, + FourthProverMessage + ), SynthesisError> + { + let ThirdVerifierMessage { alpha, beta, gamma, z, .. } = third_verifier_message; + let required_domain_size = third_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut state = FourthPartialProverState:: { + required_domain_size, + non_residues: third_state.non_residues, + input_values: third_state.input_values, + witness_polys_as_coeffs: third_state.witness_polys_as_coeffs, + z_in_monomial_form: third_state.z_in_monomial_form, + t_poly_parts : third_state.t_poly_parts, + linearization_polynomial: Polynomial::::new_for_size(0)?, + wire_values_at_z: vec![], + wire_values_at_z_omega: vec![], + permutation_polynomials_at_z: vec![], + grand_product_at_z_omega: E::Fr::zero(), + quotient_polynomial_at_z: E::Fr::zero(), + linearization_polynomial_at_z: E::Fr::zero(), + + _marker: std::marker::PhantomData + }; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + for (idx, p) in state.witness_polys_as_coeffs.iter().enumerate() { + let value_at_z = p.evaluate_at(&worker, z); + state.wire_values_at_z.push(value_at_z); + if idx == 3 { + let value_at_z_omega = p.evaluate_at(&worker, z_by_omega); + state.wire_values_at_z_omega.push(value_at_z_omega); + } + } + + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + let value_at_z = p.evaluate_at(&worker, z); + state.permutation_polynomials_at_z.push(value_at_z); + } + + let z_at_z_omega = state.z_in_monomial_form.evaluate_at(&worker, z_by_omega); + state.grand_product_at_z_omega = z_at_z_omega; + + let t_at_z = { + let mut result = E::Fr::zero(); + let mut current = E::Fr::one(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + for p in state.t_poly_parts.iter() { + let mut subvalue_at_z = p.evaluate_at(&worker, z); + subvalue_at_z.mul_assign(¤t); + result.add_assign(&subvalue_at_z); + current.mul_assign(&z_in_domain_size); + } + + result + }; + + state.quotient_polynomial_at_z = t_at_z; + + let mut quotient_linearization_challenge = E::Fr::one(); + + let r = { + // Q_const + let mut r = setup.selector_polynomials[5].clone(); + + // Q_A * A(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[0], &state.wire_values_at_z[0]); + + // Q_B * B(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[1], &state.wire_values_at_z[1]); + + // Q_C * C(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[2], &state.wire_values_at_z[2]); + + // Q_D * D(z) + r.add_assign_scaled(&worker, &setup.selector_polynomials[3], &state.wire_values_at_z[3]); + + // Q_M * A(z) * B(z) + let mut scaling_factor = state.wire_values_at_z[0]; + scaling_factor.mul_assign(&state.wire_values_at_z[1]); + r.add_assign_scaled(&worker, &setup.selector_polynomials[4], &scaling_factor); + + // Q_D_Next * D(z*omega) + + r.add_assign_scaled(&worker, &setup.next_step_selector_polynomials[0], &state.wire_values_at_z_omega[0]); + + quotient_linearization_challenge.mul_assign(&alpha); + + // + (a(z) + beta*z + gamma)*()*()*()*Z(x) + + let mut factor = quotient_linearization_challenge; + for (wire_at_z, non_residue) in state.wire_values_at_z.iter() + .zip(Some(E::Fr::one()).iter().chain(&state.non_residues)) + { + let mut t = z; + t.mul_assign(&non_residue); + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.add_assign_scaled(&worker, &state.z_in_monomial_form, &factor); + + // - (a(z) + beta*perm_a + gamma)*()*()*z(z*omega) * beta * perm_d(X) + + let mut factor = quotient_linearization_challenge; + factor.mul_assign(&beta); + factor.mul_assign(&z_at_z_omega); + + for (wire_at_z, perm_at_z) in state.wire_values_at_z.iter() + .zip(state.permutation_polynomials_at_z.iter()) + { + let mut t = *perm_at_z; + t.mul_assign(&beta); + t.add_assign(&wire_at_z); + t.add_assign(&gamma); + + factor.mul_assign(&t); + } + + r.sub_assign_scaled(&worker, &setup.permutation_polynomials.last().expect("last permutation poly"), &factor); + + // + L_0(z) * Z(x) + + quotient_linearization_challenge.mul_assign(&alpha); + + let mut factor = evaluate_l0_at_point(required_domain_size as u64, z)?; + factor.mul_assign("ient_linearization_challenge); + + r.add_assign_scaled(&worker, &state.z_in_monomial_form, &factor); + + r + }; + + // commit the linearization polynomial + + let r_at_z = r.evaluate_at(&worker, z); + state.linearization_polynomial_at_z = r_at_z; + + state.linearization_polynomial = r; + + // sanity check - verification + { + let mut lhs = t_at_z; + let vanishing_at_z = evaluate_vanishing_for_size(&z ,required_domain_size as u64); + lhs.mul_assign(&vanishing_at_z); + + let mut quotient_linearization_challenge = E::Fr::one(); + + let mut rhs = r_at_z; + + // add public inputs + { + for (idx, input) in state.input_values.iter().enumerate() { + let mut tmp = evaluate_lagrange_poly_at_point(idx, &domain, z)?; + tmp.mul_assign(&input); + + rhs.add_assign(&tmp); + } + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // - \alpha (a + perm(z) * beta + gamma)*()*(d + gamma) & z(z*omega) + + let mut z_part = z_at_z_omega; + + assert_eq!(state.permutation_polynomials_at_z.len() + 1, state.wire_values_at_z.len()); + + for (w, p) in state.wire_values_at_z.iter().zip(state.permutation_polynomials_at_z.iter()) { + let mut tmp = *p; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&w); + + z_part.mul_assign(&tmp); + } + + // last poly value and gamma + let mut tmp = gamma; + tmp.add_assign(&state.wire_values_at_z.iter().rev().next().unwrap()); + + z_part.mul_assign(&tmp); + z_part.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&z_part); + + quotient_linearization_challenge.mul_assign(&alpha); + + // - L_0(z) * \alpha^2 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&l_0_at_z); + + if lhs != rhs { + return Err(SynthesisError::Unsatisfiable); + } + } + + let message = FourthProverMessage:: { + wire_values_at_z: state.wire_values_at_z.clone(), + wire_values_at_z_omega: state.wire_values_at_z_omega.clone(), + permutation_polynomials_at_z: state.permutation_polynomials_at_z.clone(), + grand_product_at_z_omega: state.grand_product_at_z_omega, + quotient_polynomial_at_z: state.quotient_polynomial_at_z, + linearization_polynomial_at_z: state.linearization_polynomial_at_z, + + _marker: std::marker::PhantomData + }; + + Ok((state, message)) + } + + + pub(crate) fn fifth_step_from_fourth_step( + mut fourth_state: FourthPartialProverState, + fourth_verifier_message: FourthVerifierMessage, + setup: &SetupPolynomials, + crs_mons: &Crs, + worker: &Worker + ) -> Result, SynthesisError> + { + let FourthVerifierMessage { z, v, .. } = fourth_verifier_message; + let required_domain_size = fourth_state.required_domain_size; + + let domain = Domain::new_for_size(required_domain_size as u64)?; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + // open at z: + // t_i(x) * z^{domain_size*i} + // r(x) + // witnesses + // permutations except of the last one + + // open at z*omega: + // z(x) + // next step witnesses (if any) + + let mut multiopening_challenge = E::Fr::one(); + + let mut poly_to_divide_at_z = fourth_state.t_poly_parts.drain(0..1).collect::>().pop().unwrap(); + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + let mut power_of_z = z_in_domain_size; + for t_part in fourth_state.t_poly_parts.into_iter() { + poly_to_divide_at_z.add_assign_scaled(&worker, &t_part, &power_of_z); + power_of_z.mul_assign(&z_in_domain_size); + } + + // linearization polynomial + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &fourth_state.linearization_polynomial, &multiopening_challenge); + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 as u64])); + + // all witness polys + for w in fourth_state.witness_polys_as_coeffs.iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &w, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4) as u64])); + + // all except of the last permutation polys + for p in setup.permutation_polynomials[..(setup.permutation_polynomials.len() - 1)].iter() { + multiopening_challenge.mul_assign(&v); + poly_to_divide_at_z.add_assign_scaled(&worker, &p, &multiopening_challenge); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3) as u64])); + + multiopening_challenge.mul_assign(&v); + + let mut poly_to_divide_at_z_omega = fourth_state.z_in_monomial_form; + poly_to_divide_at_z_omega.scale(&worker, multiopening_challenge); + + multiopening_challenge.mul_assign(&v); + + // d should be opened at z*omega due to d_next + poly_to_divide_at_z_omega.add_assign_scaled(&worker, &fourth_state.witness_polys_as_coeffs[3], &multiopening_challenge); + fourth_state.witness_polys_as_coeffs.truncate(0); // drop + + debug_assert_eq!(multiopening_challenge, v.pow(&[(1 + 4 + 3 + 1 + 1) as u64])); + + // division in monomial form is sequential, so we parallelize the divisions + + let mut polys = vec![(poly_to_divide_at_z, z), (poly_to_divide_at_z_omega, z_by_omega)]; + + worker.scope(polys.len(), |scope, chunk| { + for p in polys.chunks_mut(chunk) { + scope.spawn(move |_| { + let (poly, at) = &p[0]; + let at = *at; + let result = divide_single::(poly.as_ref(), at); + p[0] = (Polynomial::from_coeffs(result).unwrap(), at); + }); + } + }); + + let open_at_z_omega = polys.pop().unwrap().0; + let open_at_z = polys.pop().unwrap().0; + + let opening_at_z = commit_using_monomials( + &open_at_z, + &crs_mons, + &worker + )?; + + let opening_at_z_omega = commit_using_monomials( + &open_at_z_omega, + &crs_mons, + &worker + )?; + + let message = FifthProverMessage:: { + opening_proof_at_z: opening_at_z, + opening_proof_at_z_omega: opening_at_z_omega, + + _marker: std::marker::PhantomData + }; + + Ok(message) + } +} diff --git a/src/plonk/better_cs/test_assembly.rs b/src/plonk/better_cs/test_assembly.rs new file mode 100644 index 000000000..cc4cb0307 --- /dev/null +++ b/src/plonk/better_cs/test_assembly.rs @@ -0,0 +1,368 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use super::cs::*; + +#[derive(Debug, Clone)] +pub struct TestAssembly> { + m: usize, + n: usize, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + inputs_map: Vec, + + is_finalized: bool, + + next_step_leftover_from_previous_gate: Option<(E::Fr, P::NextTraceStepCoefficients)>, + + _marker: std::marker::PhantomData

+} + +impl> ConstraintSystem for TestAssembly { + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + // println!("Allocated variable Aux({}) with value {}", index, value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + self.n += 1; + + Ok(input_var) + + } + + // allocate an abstract gate + fn new_gate(&mut self, + variables: P::StateVariables, + this_step_coeffs: P::ThisTraceStepCoefficients, + next_step_coeffs: P::NextTraceStepCoefficients + ) -> Result<(), SynthesisError> { + // check that leftover of this gate is satisfied + + if let Some((value_leftover, coeffs)) = self.next_step_leftover_from_previous_gate.take() { + let mut leftover = value_leftover; + for (&var, coeff) in variables.as_ref().iter().rev() + .zip(coeffs.as_ref().iter()) + { + let mut value = self.get_value(var)?; + value.mul_assign(&coeff); + + leftover.add_assign(&value); + } + + if leftover.is_zero() == false { + return Err(SynthesisError::Unsatisfiable); + } + } + + // now check for THIS gate + + let mut gate_value = E::Fr::zero(); + + let mut this_step_coeffs_iter = this_step_coeffs.as_ref().iter(); + + // first take an LC + for (&var, coeff) in variables.as_ref().iter() + .zip(&mut this_step_coeffs_iter) + { + let mut value = self.get_value(var)?; + value.mul_assign(&coeff); + + gate_value.add_assign(&value); + } + + // multiplication + let mut q_m = *(this_step_coeffs_iter.next().unwrap()); + q_m.mul_assign(&self.get_value(variables.as_ref()[0])?); + q_m.mul_assign(&self.get_value(variables.as_ref()[1])?); + gate_value.add_assign(&q_m); + + // constant + gate_value.add_assign(this_step_coeffs_iter.next().unwrap()); + + assert!(next_step_coeffs.as_ref().len() <= 1); + if next_step_coeffs.as_ref().len() != 0 { + assert!(P::CAN_ACCESS_NEXT_TRACE_STEP == true); + if next_step_coeffs.as_ref()[0].is_zero() == false { + self.next_step_leftover_from_previous_gate = Some((gate_value, next_step_coeffs)); + } + // assert!(self.next_step_vars.is_some()); + // let next_step_vars = self.next_step_vars.take().expect("must have some next step variables") + // for (&var, coeff) in variables.as_ref().iter().rev() + // .zip(next_step_coeffs.as_ref().iter()) + // { + // let mut value = self.get_value(var)?; + // value.mul_assign(&coeff); + + // gate_value.add_assign(&value); + // } + } else { + if gate_value.is_zero() == false { + return Err(SynthesisError::Unsatisfiable); + } + } + + + + + + self.n += 1; + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Aux(0)) => { + E::Fr::zero() + // return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(0)) => { + return Err(SynthesisError::AssignmentMissing); + } + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl> TestAssembly { + pub fn new() -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + inputs_map: vec![], + + is_finalized: false, + + next_step_leftover_from_previous_gate: None, + + _marker: std::marker::PhantomData + }; + + tmp + } + + pub fn new_with_size_hints(num_inputs: usize, num_aux: usize) -> Self { + let tmp = Self { + n: 0, + m: 0, + + num_inputs: 0, + num_aux: 0, + + input_assingments: Vec::with_capacity(num_inputs), + aux_assingments: Vec::with_capacity(num_aux), + + inputs_map: Vec::with_capacity(num_inputs), + + is_finalized: false, + + next_step_leftover_from_previous_gate: None, + + _marker: std::marker::PhantomData + }; + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + Variable(Index::Aux(0)) + } + + pub fn is_well_formed(&self) -> bool { + // check that last gate does not chain further! + self.next_step_leftover_from_previous_gate.is_none() + } + + // pub fn is_satisfied(&self, in_a_middle: bool) -> bool { + // // expect a small number of inputs + // for (i, gate) in self.input_gates.iter().enumerate() + // { + // let Gate:: { + // variables: [a_var, b_var, c_var], + // coefficients: [q_l, q_r, q_o, q_m, q_c, q_c_next] + // } = *gate; + + // assert!(q_c.is_zero(), "should not hardcode a constant into the input gate"); + // assert!(q_c_next.is_zero(), "input gates should not link to the next gate"); + + // let a_value = self.get_value(a_var).expect("must get a variable value"); + // let b_value = self.get_value(b_var).expect("must get a variable value"); + // let c_value = self.get_value(c_var).expect("must get a variable value"); + + // let input_value = self.input_assingments[i]; + // let mut res = input_value; + // res.negate(); + + // let mut tmp = q_l; + // tmp.mul_assign(&a_value); + // res.add_assign(&tmp); + + // let mut tmp = q_r; + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // let mut tmp = q_o; + // tmp.mul_assign(&c_value); + // res.add_assign(&tmp); + + // let mut tmp = q_m; + // tmp.mul_assign(&a_value); + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // if !res.is_zero() { + // println!("Unsatisfied at input gate {}: {:?}", i+1, gate); + // println!("A value = {}, B value = {}, C value = {}", a_value, b_value, c_value); + // return false; + // } + // } + + // for (i, gate_pair) in self.aux_gates.windows(2).enumerate() + // { + // let this_gate = gate_pair[0]; + // let next_gate = &gate_pair[1]; + + // let Gate:: { + // variables: [a_var, b_var, c_var], + // coefficients: [q_l, q_r, q_o, q_m, q_c, q_c_next] + // } = this_gate; + + // let a_value = self.get_value(a_var).expect("must get a variable value"); + // let b_value = self.get_value(b_var).expect("must get a variable value"); + // let c_value = self.get_value(c_var).expect("must get a variable value"); + + // let next_gate_c_var = next_gate.variables[2]; + + // let c_next_value = self.get_value(next_gate_c_var).expect("must get a variable value"); + + // let mut res = q_c; + + // let mut tmp = q_l; + // tmp.mul_assign(&a_value); + // res.add_assign(&tmp); + + // let mut tmp = q_r; + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // let mut tmp = q_o; + // tmp.mul_assign(&c_value); + // res.add_assign(&tmp); + + // let mut tmp = q_m; + // tmp.mul_assign(&a_value); + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // let mut tmp = q_c_next; + // tmp.mul_assign(&c_next_value); + // res.add_assign(&tmp); + + // if !res.is_zero() { + // println!("Unsatisfied at aux gate {}", i+1); + // println!("Gate {:?}", this_gate); + // println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + // return false; + // } + // } + + // if !in_a_middle { + // let i = self.aux_gates.len(); + // let last_gate = *self.aux_gates.last().unwrap(); + + // let Gate:: { + // variables: [a_var, b_var, c_var], + // coefficients: [q_l, q_r, q_o, q_m, q_c, q_c_next] + // } = last_gate; + + // let a_value = self.get_value(a_var).expect("must get a variable value"); + // let b_value = self.get_value(b_var).expect("must get a variable value"); + // let c_value = self.get_value(c_var).expect("must get a variable value"); + + // assert!(q_c_next.is_zero(), "last gate should not be linked to the next one"); + + // let mut res = q_c; + + // let mut tmp = q_l; + // tmp.mul_assign(&a_value); + // res.add_assign(&tmp); + + // let mut tmp = q_r; + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // let mut tmp = q_o; + // tmp.mul_assign(&c_value); + // res.add_assign(&tmp); + + // let mut tmp = q_m; + // tmp.mul_assign(&a_value); + // tmp.mul_assign(&b_value); + // res.add_assign(&tmp); + + // if !res.is_zero() { + // println!("Unsatisfied at aux gate {}", i+1); + // println!("Gate {:?}", last_gate); + // println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + // return false; + // } + // } + + // true + // } + + pub fn num_gates(&self) -> usize { + self.n + } +} diff --git a/src/plonk/better_cs/utils.rs b/src/plonk/better_cs/utils.rs new file mode 100644 index 000000000..480d717b3 --- /dev/null +++ b/src/plonk/better_cs/utils.rs @@ -0,0 +1,256 @@ +use crate::ff::PrimeField; +use crate::pairing::{Engine, CurveAffine}; +use crate::worker::Worker; +use crate::SynthesisError; +use crate::plonk::domains::Domain; +use crate::plonk::polynomials::*; +use crate::plonk::commitments::transcript::Transcript; + +pub(crate) fn calculate_inverse_vanishing_polynomial_in_a_coset( + worker: &Worker, + poly_size: usize, + vahisning_size: usize +) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64)?; + let n_domain_omega = domain.generator; + let mut root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + root.negate(); + + let multiplicative_generator = F::multiplicative_generator(); + + let mut negative_one = F::one(); + negative_one.negate(); + + let mut numerator = Polynomial::::from_values(vec![multiplicative_generator; poly_size])?; + // evaluate X in linear time + + numerator.distribute_powers(&worker, numerator.omega); + numerator.add_constant(&worker, &root); + + // numerator.add_constant(&worker, &negative_one); + // now it's a series of values in a coset + + // now we should evaluate X^(n+1) - 1 in a linear time + + let shift = multiplicative_generator.pow([vahisning_size as u64]); + + let mut denominator = Polynomial::::from_values(vec![shift; poly_size])?; + + // elements are h^size - 1, (hg)^size - 1, (hg^2)^size - 1, ... + + denominator.distribute_powers(&worker, denominator.omega.pow([vahisning_size as u64])); + denominator.add_constant(&worker, &negative_one); + + denominator.batch_inversion(&worker)?; + + numerator.mul_assign(&worker, &denominator); + + Ok(numerator) +} + +pub(crate) fn evaluate_inverse_vanishing_poly_with_last_point_cut( + vahisning_size: usize, + point: F +) -> F { + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("should fit"); + let n_domain_omega = domain.generator; + let root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + + let mut numerator = point; + numerator.sub_assign(&root); + + let mut denominator = point.pow([vahisning_size as u64]); + denominator.sub_assign(&F::one()); + + let denominator = denominator.inverse().expect("must exist"); + + numerator.mul_assign(&denominator); + + numerator +} + +pub(crate) fn calculate_lagrange_poly( + worker: &Worker, + poly_size:usize, + poly_number: usize +) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(poly_number < poly_size); + + let mut poly = Polynomial::::from_values(vec![F::zero(); poly_size])?; + + poly.as_mut()[poly_number] = F::one(); + + Ok(poly.ifft(&worker)) +} + +pub(crate) fn evaluate_vanishing_polynomial_of_degree_on_domain_size( + vanishing_degree: u64, + coset_factor: &F, + domain_size: u64, + worker: &Worker +) -> Result, SynthesisError> { + let domain = Domain::::new_for_size(domain_size)?; + let domain_generator = domain.generator; + + let coset_factor = coset_factor.pow(&[vanishing_degree]); + + let domain_generator_in_vanishing_power = domain_generator.pow(&[vanishing_degree]); + + let mut minus_one = F::one(); + minus_one.negate(); + + let mut result = vec![minus_one; domain.size as usize]; + + worker.scope(result.len(), |scope, chunk_size| { + for (chunk_id, chunk) in result.chunks_mut(chunk_size).enumerate() { + scope.spawn(move |_| { + let start = chunk_id * chunk_size; + let mut pow = domain_generator_in_vanishing_power.pow(&[start as u64]); + pow.mul_assign(&coset_factor); + for el in chunk.iter_mut() { + el.add_assign(&pow); + pow.mul_assign(&domain_generator_in_vanishing_power); + } + }); + } + }); + + Polynomial::from_values(result) +} + +pub(crate) fn evaluate_vanishing_for_size(point: &F, vanishing_domain_size: u64) -> F { + let mut result = point.pow(&[vanishing_domain_size]); + result.sub_assign(&F::one()); + + result +} + +pub(crate) fn evaluate_l0_at_point( + domain_size: u64, + point: F +) -> Result { + let size_as_fe = F::from_str(&format!("{}", domain_size)).unwrap(); + + let mut den = point; + den.sub_assign(&F::one()); + den.mul_assign(&size_as_fe); + + let den = den.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut num = point.pow(&[domain_size]); + num.sub_assign(&F::one()); + num.mul_assign(&den); + + Ok(num) +} + +pub(crate) fn evaluate_lagrange_poly_at_point( + poly_number: usize, + domain: &Domain, + point: F +) -> Result { + // lagrange polynomials have a form + // (omega^i / N) / (X - omega^i) * (X^N - 1) + + let mut num = evaluate_vanishing_for_size(&point, domain.size); + let omega_power = domain.generator.pow(&[poly_number as u64]); + num.mul_assign(&omega_power); + + let size_as_fe = F::from_str(&format!("{}", domain.size)).unwrap(); + + let mut den = point; + den.sub_assign(&omega_power); + den.mul_assign(&size_as_fe); + + let den = den.inverse().ok_or(SynthesisError::DivisionByZero)?; + + num.mul_assign(&den); + + Ok(num) +} + +use crate::ff::SqrtField; + + +pub fn make_non_residues(num: usize) -> Vec { + // create largest domain possible + assert!(F::S < 63); + let domain_size = 1u64 << (F::S as u64); + + let domain = Domain::::new_for_size(domain_size).expect("largest domain must exist"); + + make_non_residues_for_domain(num, &domain) +} + +pub fn make_non_residues_for_domain(num: usize, domain: &Domain) -> Vec { + use crate::ff::LegendreSymbol; + + // we need to check that + // - some k is not a residue + // - it's NOT a part of coset formed as other_k * {1, omega^1, ...} + + let mut non_residues = vec![]; + let mut current = F::one(); + let one = F::one(); + for _ in 0..num { + loop { + if current.legendre() != LegendreSymbol::QuadraticNonResidue { + current.add_assign(&one); + } else { + let mut is_unique = true; + { + // first pow into the domain size + let tmp = current.pow(&[domain.size]); + // then check: if it's in some other coset, then + // X^N == other_k ^ N + for t in Some(one).iter().chain(non_residues.iter()) { + if !is_unique { + break; + } + let t_in_domain_size = t.pow(&[domain.size]); + if tmp == t_in_domain_size { + is_unique = false; + } + } + } + if is_unique { + non_residues.push(current); + current.add_assign(&one); + break; + } + } + } + } + + non_residues +} + +pub fn commit_point_as_xy>( + transcript: &mut T, + point: &E::G1Affine +) { + use crate::ff::Field; + + if point.is_zero() { + transcript.commit_fe(&E::Fq::zero()); + transcript.commit_fe(&E::Fq::zero()); + } else { + let (x, y) = point.into_xy_unchecked(); + transcript.commit_fe(&x); + transcript.commit_fe(&y); + } +} \ No newline at end of file diff --git a/src/plonk/better_cs/verifier.rs b/src/plonk/better_cs/verifier.rs new file mode 100644 index 000000000..2f150aed3 --- /dev/null +++ b/src/plonk/better_cs/verifier.rs @@ -0,0 +1,416 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use crate::plonk::domains::*; + +use std::marker::PhantomData; + +use super::cs::*; +use super::keys::{Proof, VerificationKey}; + +use crate::source::{DensityTracker, DensityTrackerersChain}; + +use crate::kate_commitment::*; +use super::utils::*; + +use crate::plonk::commitments::transcript::*; + +pub fn verify, T: Transcript>( + proof: &Proof, + verification_key: &VerificationKey, + transcript_init_params: Option< >:: InitializationParameters>, +) -> Result { + let (valid, _) = verify_and_aggregate::(proof, verification_key, transcript_init_params)?; + + Ok(valid) +} + +pub fn verify_and_aggregate, T: Transcript>( + proof: &Proof, + verification_key: &VerificationKey, + transcript_init_params: Option< >:: InitializationParameters>, +) -> Result<(bool, [E::G1Affine; 2]), SynthesisError> { + use crate::pairing::CurveAffine; + use crate::pairing::CurveProjective; + + assert!(P::CAN_ACCESS_NEXT_TRACE_STEP); + + let mut transcript = if let Some(p) = transcript_init_params { + T::new_from_params(p) + } else { + T::new() + }; + + if proof.n != verification_key.n { + return Err(SynthesisError::MalformedVerifyingKey); + } + + if proof.num_inputs != verification_key.num_inputs { + return Err(SynthesisError::MalformedVerifyingKey); + } + + let n = proof.n; + let required_domain_size = n + 1; + if required_domain_size.is_power_of_two() == false { + return Err(SynthesisError::MalformedVerifyingKey); + } + + let domain = Domain::::new_for_size(required_domain_size as u64)?; + + let selector_q_const_index = P::STATE_WIDTH + 1; + let selector_q_m_index = P::STATE_WIDTH; + + let non_residues = make_non_residues::(P::STATE_WIDTH - 1); + + // Commit public inputs + for inp in proof.input_values.iter() { + transcript.commit_field_element(&inp); + } + + // Commit wire values + for w in proof.wire_commitments.iter() { + commit_point_as_xy::(&mut transcript, &w); + } + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + // commit grand product + commit_point_as_xy::(&mut transcript, &proof.grand_product_commitment); + + let alpha = transcript.get_challenge(); + + // Commit parts of the quotient polynomial + for w in proof.quotient_poly_commitments.iter() { + commit_point_as_xy::(&mut transcript, &w); + } + + let z = transcript.get_challenge(); + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + // commit every claimed value + + for el in proof.wire_values_at_z.iter() { + transcript.commit_field_element(el); + } + + for el in proof.wire_values_at_z_omega.iter() { + transcript.commit_field_element(el); + } + + for el in proof.permutation_polynomials_at_z.iter() { + transcript.commit_field_element(el); + } + + transcript.commit_field_element(&proof.quotient_polynomial_at_z); + + transcript.commit_field_element(&proof.linearization_polynomial_at_z); + + transcript.commit_field_element(&proof.grand_product_at_z_omega); + + + // do the actual check for relationship at z + + { + let mut lhs = proof.quotient_polynomial_at_z; + let vanishing_at_z = evaluate_vanishing_for_size(&z, required_domain_size as u64); + lhs.mul_assign(&vanishing_at_z); + + let mut quotient_linearization_challenge = E::Fr::one(); + + let mut rhs = proof.linearization_polynomial_at_z; + + // add public inputs + { + for (idx, input) in proof.input_values.iter().enumerate() { + let mut tmp = evaluate_lagrange_poly_at_point(idx, &domain, z)?; + tmp.mul_assign(&input); + + rhs.add_assign(&tmp); + } + } + + quotient_linearization_challenge.mul_assign(&alpha); + + // - \alpha (a + perm(z) * beta + gamma)*()*(d + gamma) & z(z*omega) + + let mut z_part = proof.grand_product_at_z_omega; + + for (w, p) in proof.wire_values_at_z.iter().zip(proof.permutation_polynomials_at_z.iter()) { + let mut tmp = *p; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&w); + + z_part.mul_assign(&tmp); + } + + // last poly value and gamma + let mut tmp = gamma; + tmp.add_assign(&proof.wire_values_at_z.iter().rev().next().unwrap()); + + z_part.mul_assign(&tmp); + z_part.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&z_part); + + quotient_linearization_challenge.mul_assign(&alpha); + + // - L_0(z) * \alpha^2 + + let mut l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + l_0_at_z.mul_assign("ient_linearization_challenge); + + rhs.sub_assign(&l_0_at_z); + + if lhs != rhs { + return Ok((false, [E::G1Affine::zero(); 2])); + } + } + + let v = transcript.get_challenge(); + + commit_point_as_xy::(&mut transcript, &proof.opening_at_z_proof); + + commit_point_as_xy::(&mut transcript, &proof.opening_at_z_omega_proof); + + let u = transcript.get_challenge(); + + let z_in_domain_size = z.pow(&[required_domain_size as u64]); + + // first let's reconstruct the linearization polynomial from + // honomorphic commitments, and simultaneously add (through the separation scalar "u") + // part for opening of z(X) at z*omega + + // calculate the power to add z(X) commitment that is opened at x*omega + // it's r(X) + witness + all permutations + 1 + let v_power_for_standalone_z_x_opening = 1 + 1 + P::STATE_WIDTH + (P::STATE_WIDTH-1); + + let virtual_commitment_for_linearization_poly = { + let mut r = E::G1::zero(); + + // main gate. Does NOT include public inputs + { + // Q_const(x) + r.add_assign_mixed(&verification_key.selector_commitments[selector_q_const_index]); + + for i in 0..P::STATE_WIDTH { + // Q_k(X) * K(z) + r.add_assign(&verification_key.selector_commitments[i].mul(proof.wire_values_at_z[i].into_repr())); + } + + // Q_m(X) * A(z) * B(z) + let mut scalar = proof.wire_values_at_z[0]; + scalar.mul_assign(&proof.wire_values_at_z[1]); + r.add_assign(&verification_key.selector_commitments[selector_q_m_index].mul(scalar.into_repr())); + + // Q_d_next(X) * D(z*omega) + r.add_assign(&verification_key.next_step_selector_commitments[0].mul(proof.wire_values_at_z_omega[0].into_repr())); + } + + // v * [alpha * (a + beta*z + gamma)(b + beta*k_1*z + gamma)()() * z(X) - + // - \alpha * (a*perm_a(z)*beta + gamma)()()*beta*z(z*omega) * perm_d(X) + + // + alpha^2 * L_0(z) * z(X) ] + + // + v^{P} * u * z(X) + // and join alpha^2 * L_0(z) and v^{P} * u into the first term containing z(X) + + // [alpha * (a + beta*z + gamma)(b + beta*k_1*z + gamma)()() + alpha^2 * L_0(z)] * z(X) + let grand_product_part_at_z = { + let mut scalar = E::Fr::one(); + + // permutation part + for (wire, non_res) in proof.wire_values_at_z.iter() + .zip(Some(E::Fr::one()).iter().chain(&non_residues)) + { + let mut tmp = z; + tmp.mul_assign(&non_res); + tmp.mul_assign(&beta); + tmp.add_assign(&wire); + tmp.add_assign(&gamma); + + scalar.mul_assign(&tmp); + } + + scalar.mul_assign(&alpha); + + let l_0_at_z = evaluate_l0_at_point(required_domain_size as u64, z)?; + + // + L_0(z) * alpha^2 + let mut tmp = l_0_at_z; + tmp.mul_assign(&alpha); + tmp.mul_assign(&alpha); + scalar.add_assign(&tmp); + + // * v + // scalar.mul_assign(&v); + + scalar + }; + + // v^{P} * u * z(X) + let grand_product_part_at_z_omega = { + // + v^{P} * u + let mut tmp = v.pow(&[v_power_for_standalone_z_x_opening as u64]); + tmp.mul_assign(&u); + + tmp + }; + + // \alpha * (a*perm_a(z)*beta + gamma)()()*beta*z(z*omega) * perm_d(X) + let last_permutation_part_at_z = { + let mut scalar = E::Fr::one(); + + // permutation part + for (wire, perm_at_z) in proof.wire_values_at_z.iter() + .zip(&proof.permutation_polynomials_at_z) + { + let mut tmp = beta; + tmp.mul_assign(&perm_at_z); + tmp.add_assign(&wire); + tmp.add_assign(&gamma); + + scalar.mul_assign(&tmp); + } + + scalar.mul_assign(&beta); + scalar.mul_assign(&proof.grand_product_at_z_omega); + scalar.mul_assign(&alpha); + // scalar.mul_assign(&v); + + scalar + }; + + { + let mut tmp = proof.grand_product_commitment.mul(grand_product_part_at_z.into_repr()); + tmp.sub_assign(&verification_key.permutation_commitments.last().unwrap().mul(last_permutation_part_at_z.into_repr())); + + r.add_assign(&tmp); + } + + r.mul_assign(v.into_repr()); + + r.add_assign(&proof.grand_product_commitment.mul(grand_product_part_at_z_omega.into_repr())); + + r + }; + + // now check the openings + + let mut multiopening_challenge = E::Fr::one(); + + // reassemble a homomorphic commitment + + // aggregate t(X) from parts + + let mut commitments_aggregation = proof.quotient_poly_commitments[0].into_projective(); + + let mut current = z_in_domain_size; + for part in proof.quotient_poly_commitments.iter().skip(1) { + commitments_aggregation.add_assign(&part.mul(current.into_repr())); + current.mul_assign(&z_in_domain_size); + } + + // do the same for linearization + multiopening_challenge.mul_assign(&v); // to preserve sequence + + commitments_aggregation.add_assign(&virtual_commitment_for_linearization_poly); // v^1 is contained inside + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 as u64])); + + // do the same for wires + for com in proof.wire_commitments.iter() { + multiopening_challenge.mul_assign(&v); // v^{1+STATE_WIDTH} + let tmp = com.mul(multiopening_challenge.into_repr()); + commitments_aggregation.add_assign(&tmp); + } + + debug_assert_eq!(multiopening_challenge, v.pow(&[1 + 4 as u64])); + + // and for all permutation polynomials except the last one + assert_eq!(verification_key.permutation_commitments.len(), proof.permutation_polynomials_at_z.len() + 1); + + for com in verification_key.permutation_commitments[0..(verification_key.permutation_commitments.len() - 1)].iter() { + multiopening_challenge.mul_assign(&v); // v^{1+STATE_WIDTH + STATE_WIDTH - 1} + let tmp = com.mul(multiopening_challenge.into_repr()); + commitments_aggregation.add_assign(&tmp); + } + + multiopening_challenge.mul_assign(&v); // we skip z(X) at z + + // aggregate last wire commitment (that is opened at z*omega) + // using multiopening challenge and u + multiopening_challenge.mul_assign(&v); + let mut scalar = multiopening_challenge; + scalar.mul_assign(&u); + commitments_aggregation.add_assign(&proof.wire_commitments.last().unwrap().mul(scalar.into_repr())); + + // subtract the opening value using one multiplication + + let mut multiopening_challenge_for_values = E::Fr::one(); + let mut aggregated_value = proof.quotient_polynomial_at_z; + for value_at_z in Some(proof.linearization_polynomial_at_z).iter() + .chain(&proof.wire_values_at_z) + .chain(&proof.permutation_polynomials_at_z) + { + multiopening_challenge_for_values.mul_assign(&v); + let mut tmp = *value_at_z; + tmp.mul_assign(&multiopening_challenge_for_values); + aggregated_value.add_assign(&tmp); + } + + // add parts that are opened at z*omega using `u` + { + multiopening_challenge_for_values.mul_assign(&v); + let mut scalar = multiopening_challenge_for_values; + scalar.mul_assign(&u); + let mut tmp = proof.grand_product_at_z_omega; + tmp.mul_assign(&scalar); + + aggregated_value.add_assign(&tmp); + } + { + multiopening_challenge_for_values.mul_assign(&v); + let mut scalar = multiopening_challenge_for_values; + scalar.mul_assign(&u); + let mut tmp = proof.wire_values_at_z_omega[0]; + tmp.mul_assign(&scalar); + + aggregated_value.add_assign(&tmp); + } + + assert_eq!(multiopening_challenge, multiopening_challenge_for_values); + + // make equivalent of (f(x) - f(z)) + commitments_aggregation.sub_assign(&E::G1Affine::one().mul(aggregated_value.into_repr())); + + // now check that + // e(proof_for_z + u*proof_for_z_omega, g2^x) = e(z*proof_for_z + z*omega*u*proof_for_z_omega + (aggregated_commitment - aggregated_opening), g2^1) + // with a corresponding change of sign + + let mut pair_with_generator = commitments_aggregation; + + pair_with_generator.add_assign(&proof.opening_at_z_proof.mul(z.into_repr())); + let mut scalar = z_by_omega; + scalar.mul_assign(&u); + pair_with_generator.add_assign(&proof.opening_at_z_omega_proof.mul(scalar.into_repr())); + + let mut pair_with_x = proof.opening_at_z_omega_proof.mul(u.into_repr()); + pair_with_x.add_assign_mixed(&proof.opening_at_z_proof); + pair_with_x.negate(); + + let pair_with_generator = pair_with_generator.into_affine(); + let pair_with_x = pair_with_x.into_affine(); + + let valid = E::final_exponentiation( + &E::miller_loop(&[ + (&pair_with_generator.prepare(), &verification_key.g2_elements[0].prepare()), + (&pair_with_x.prepare(), &verification_key.g2_elements[1].prepare()) + ]) + ).unwrap() == E::Fqk::one(); + + Ok((valid, [pair_with_generator, pair_with_x])) +} \ No newline at end of file diff --git a/src/plonk/blake2_const/.gitignore b/src/plonk/blake2_const/.gitignore new file mode 100644 index 000000000..98e5fcf31 --- /dev/null +++ b/src/plonk/blake2_const/.gitignore @@ -0,0 +1,3 @@ +target +**/*.rs.bk +Cargo.lock diff --git a/src/plonk/blake2_const/.travis.yml b/src/plonk/blake2_const/.travis.yml new file mode 100644 index 000000000..b1edcbf13 --- /dev/null +++ b/src/plonk/blake2_const/.travis.yml @@ -0,0 +1,22 @@ +language: rust +os: + - linux + - osx + - windows +rust: + - stable + - beta + - nightly +script: + - (cd run_all_tests && cargo run) +# Also run the tests on a non-x86, big-endian system. +matrix: + include: + - name: "mips64" + os: linux + rust: stable + install: + - cargo install cross + script: + - (cd blake2b && cross test --target mips64-unknown-linux-gnuabi64) + - (cd blake2s && cross test --target mips64-unknown-linux-gnuabi64) diff --git a/src/plonk/blake2_const/Cargo.toml b/src/plonk/blake2_const/Cargo.toml new file mode 100644 index 000000000..50e941cd6 --- /dev/null +++ b/src/plonk/blake2_const/Cargo.toml @@ -0,0 +1,38 @@ +# This root project only contains shared tests and benchmarks. This is very +# similar to a Cargo workspace. We're not using a real workspace because +# https://github.com/rust-lang/cargo/issues/5015 makes it hard to run tests +# with --no-default-features, to test the no_std case. + +[package] +name = "blake2_simd_root" +version = "0.0.0" +authors = ["Jack O'Connor"] +description = "a pure Rust BLAKE2b implementation with dynamic SIMD" +license = "MIT" +repository = "https://github.com/oconnor663/blake2b_simd" +documentation = "https://docs.rs/blake2b_simd" +readme = "README.md" +edition = "2018" + +[features] +# Note that this root crates never builds itself with no_std. The "std" feature +# only controls whether blake2b_simd and blake2s_simd build with no_std. +default = ["std"] +std = ["blake2b_simd/std", "blake2s_simd/std"] + +[dependencies] +arrayvec = "0.5.0" +blake2b_simd = { path = "./blake2b", default-features = false } +blake2s_simd = { path = "./blake2s", default-features = false } +blake2-avx2-sneves = { path = "benches/blake2-avx2-sneves", optional = true } +hex = "0.3.2" +kangarootwelve = { path = "benches/kangarootwelve", optional = true } +lazy_static = "1.3.0" +libsodium-ffi = { version = "0.1.17", optional = true } +openssl = { version = "0.10.23", optional = true } +page_size = "0.4.1" +serde = { version = "1.0.91", features = ["derive"] } +serde_json = "1.0.39" +rand = "0.7.0" +rand_chacha = "0.2.0" +ring = { version = "0.16.0", optional = true } diff --git a/src/plonk/blake2_const/LICENSE b/src/plonk/blake2_const/LICENSE new file mode 100644 index 000000000..42de91968 --- /dev/null +++ b/src/plonk/blake2_const/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Jack O'Connor + +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/src/plonk/blake2_const/README.md b/src/plonk/blake2_const/README.md new file mode 100644 index 000000000..671c718e5 --- /dev/null +++ b/src/plonk/blake2_const/README.md @@ -0,0 +1,129 @@ +# blake2b_simd [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) [![docs.rs](https://docs.rs/blake2b_simd/badge.svg)](https://docs.rs/blake2b_simd) [![crates.io](https://img.shields.io/crates/v/blake2b_simd.svg)](https://crates.io/crates/blake2b_simd)
blake2s_simd [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) [![docs.rs](https://docs.rs/blake2s_simd/badge.svg)](https://docs.rs/blake2s_simd) [![crates.io](https://img.shields.io/crates/v/blake2s_simd.svg)](https://crates.io/crates/blake2s_simd) + +An implementation of the BLAKE2(b/s/bp/sp) family of hash functions with: + +- 100% stable Rust. +- SIMD implementations based on Samuel Neves' [`blake2-avx2`](https://github.com/sneves/blake2-avx2). + These are very fast. See the Performance section below. +- Portable, safe implementations for other platforms. +- Dynamic CPU feature detection. Binaries include multiple implementations by default and + choose the fastest one the processor supports at runtime. +- All the features from the [the BLAKE2 spec](https://blake2.net/blake2.pdf), like adjustable + length, keying, and associated data for tree hashing. +- The `blake2` command line utility, published as the + [`blake2_bin`](https://crates.io/crates/blake2_bin) crate, with command line flags for all + the BLAKE2 variants and associated data features. +- `no_std` support. The `std` Cargo feature is on by default, for CPU feature detection and + for implementing `std::io::Write`. +- Support for computing multiple BLAKE2b and BLAKE2s hashes in parallel, matching the + efficiency of BLAKE2bp and BLAKE2sp. See the `many` module in each crate. + +## Example + +```rust +use blake2b_simd::{blake2b, Params}; + +let expected = "ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6d\ + c1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"; +let hash = blake2b(b"foo"); +assert_eq!(expected, &hash.to_hex()); + +let hash = Params::new() + .hash_length(16) + .key(b"The Magic Words are Squeamish Ossifrage") + .personal(b"L. P. Waterhouse") + .to_state() + .update(b"foo") + .update(b"bar") + .update(b"baz") + .finalize(); +assert_eq!("ee8ff4e9be887297cf79348dc35dab56", &hash.to_hex()); +``` + +An example using the included `blake2` command line utility: + +```bash +$ cargo install blake2_bin +$ echo hi | blake2 -sp +49228db2a2fa8d25e8b3b2aca5a70234c71490516eaca9cba007b27d59c532b8 +``` + +## Performance + +To run small benchmarks yourself, run `cargo +nightly bench`. If you +have OpenSSL, libsodium, and Clang installed on your machine, you can +add `--all-features` to include comparison benchmarks with other native +libraries. + +The `benches/bench_multiprocess` sub-crate runs various hash functions +on long inputs in memory and tries to average over many sources of +variability. Here are the results from my laptop for `cargo run --release`: + +- Intel Core i5-8250U, Arch Linux, kernel version 5.1.9 +- libsodium version 1.0.18 +- OpenSSL version 1.1.1.c +- rustc 1.35.0 +- Clang 8.0.0 + +```table +╭─────────────────────────┬────────────╮ +│ blake2s_simd many::hash │ 2.458 GB/s │ +│ blake2s_simd BLAKE2sp │ 2.446 GB/s │ +│ sneves BLAKE2sp │ 2.311 GB/s │ +│ blake2b_simd many::hash │ 2.229 GB/s │ +│ blake2b_simd BLAKE2bp │ 2.221 GB/s │ +│ sneves BLAKE2bp │ 2.032 GB/s │ +│ libsodium BLAKE2b │ 1.111 GB/s │ +│ blake2b_simd BLAKE2b │ 1.055 GB/s │ +│ sneves BLAKE2b │ 1.054 GB/s │ +│ OpenSSL SHA-1 │ 0.972 GB/s │ +│ blake2s_simd BLAKE2s │ 0.686 GB/s │ +│ OpenSSL SHA-512 │ 0.667 GB/s │ +╰─────────────────────────┴────────────╯ +``` + +Note that `libsodium BLAKE2b` beats `blake2b_simd BLAKE2b` and `sneves +BLAKE2b` by about 5%. This turns out to be a GCC vs LLVM effect. The +Arch Linux libsodium package is built with GCC, which seems to do better +than Clang or rustc under `-mavx2`/`target_feature(enable="avx2")`. If I +build `sneves BLAKE2b` under GCC, it catches up with libsodium, and if I +build libsodium under Clang, it's 14% slower. However, GCC doesn't seem +to benefit from `-march=native`/`target-cpu=native`, while Clang and +rustc do better: + +```table +╭─────────────────────────┬────────────╮ +│ blake2s_simd many::hash │ 2.586 GB/s │ +│ blake2s_simd BLAKE2sp │ 2.570 GB/s │ +│ sneves BLAKE2sp │ 2.372 GB/s │ +│ blake2b_simd many::hash │ 2.368 GB/s │ +│ blake2b_simd BLAKE2bp │ 2.353 GB/s │ +│ sneves BLAKE2bp │ 2.234 GB/s │ +│ sneves BLAKE2b │ 1.211 GB/s │ +│ blake2b_simd BLAKE2b │ 1.206 GB/s │ +│ blake2s_simd BLAKE2s │ 0.730 GB/s │ +╰─────────────────────────┴────────────╯ +``` + +The `benches/bench_blake2_bin.py` script benchmarks the `blake2` command +line utility against several Coreutils hashes, on a 1 GB file of random +data. Here are the results from my laptop: + +```table +╭─────────────────────┬────────────╮ +│ blake2 -sp │ 1.729 GB/s │ +│ blake2 -bp │ 1.622 GB/s │ +│ blake2 -b │ 0.917 GB/s │ +│ coreutils sha1sum │ 0.856 GB/s │ +│ coreutils b2sum │ 0.714 GB/s │ +│ blake2 -s │ 0.633 GB/s │ +│ coreutils md5sum │ 0.622 GB/s │ +│ coreutils sha512sum │ 0.620 GB/s │ +╰─────────────────────┴────────────╯ +``` + +## Links + +- [v0.1.0 announcement on r/rust](https://www.reddit.com/r/rust/comments/96q69x/code_review_request_an_avx2_implementation_of/) +- [v0.5.1 announcement on r/rust](https://www.reddit.com/r/rust/comments/brqilo/blake2b_simd_is_joined_by_blake2s_simd_with_new/) +- the [experimental Bao hash](https://github.com/oconnor663/bao), based on this BLAKE2 implementation diff --git a/src/plonk/blake2_const/benches/.gitattributes b/src/plonk/blake2_const/benches/.gitattributes new file mode 100644 index 000000000..77a07c729 --- /dev/null +++ b/src/plonk/blake2_const/benches/.gitattributes @@ -0,0 +1,3 @@ +# Stop GitHub from thinking the majority of the repo is Objective-C :-D +blake2-avx2-sneves/* linguist-vendored +kangarootwelve/* linguist-vendored diff --git a/src/plonk/blake2_const/benches/bench.rs b/src/plonk/blake2_const/benches/bench.rs new file mode 100644 index 000000000..4926ec5bf --- /dev/null +++ b/src/plonk/blake2_const/benches/bench.rs @@ -0,0 +1,654 @@ +#![feature(test)] + +extern crate test; + +use rand::seq::SliceRandom; +use rand::RngCore; +use test::Bencher; + +const LONG: usize = 1 << 16; // 64 KiB + +#[cfg(feature = "kangarootwelve")] +const VERYLONG: usize = 1 << 20; // 1 MiB + +// This struct randomizes two things: +// 1. The actual bytes of input. +// 2. The page offset the input starts at. +struct RandomInput { + buf: Vec, + len: usize, + offsets: Vec, + offset_index: usize, +} + +impl RandomInput { + fn new(b: &mut Bencher, len: usize) -> Self { + b.bytes += len as u64; + let page_size: usize = page_size::get(); + let mut buf = vec![0u8; len + page_size]; + let mut rng = rand::thread_rng(); + rng.fill_bytes(&mut buf); + let mut offsets: Vec = (0..page_size).collect(); + offsets.shuffle(&mut rng); + Self { + buf, + len, + offsets, + offset_index: 0, + } + } + + fn get(&mut self) -> &[u8] { + let offset = self.offsets[self.offset_index]; + self.offset_index += 1; + if self.offset_index >= self.offsets.len() { + self.offset_index = 0; + } + &self.buf[offset..][..self.len] + } +} + +#[bench] +fn bench_oneblock_blake2b_avx2(b: &mut Bencher) { + let mut input = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + b.iter(|| blake2b_simd::blake2b(input.get())); +} + +#[bench] +fn bench_onebyte_blake2b_avx2(b: &mut Bencher) { + b.iter(|| blake2b_simd::blake2b(b"x")); +} + +#[bench] +fn bench_long_blake2b_avx2(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2b_simd::blake2b(input.get())); +} + +#[bench] +fn bench_oneblock_blake2b_portable(b: &mut Bencher) { + let mut input = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let mut params = blake2b_simd::Params::new(); + blake2b_simd::benchmarks::force_portable(&mut params); + b.iter(|| params.hash(input.get())); +} + +#[bench] +fn bench_long_blake2b_portable(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + let mut params = blake2b_simd::Params::new(); + blake2b_simd::benchmarks::force_portable(&mut params); + b.iter(|| params.hash(input.get())); +} + +#[bench] +fn bench_oneblock_blake2s_sse41(b: &mut Bencher) { + let mut input = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + b.iter(|| blake2s_simd::blake2s(input.get())); +} + +#[bench] +fn bench_onebyte_blake2s_sse41(b: &mut Bencher) { + b.iter(|| blake2s_simd::blake2s(b"x")); +} + +#[bench] +fn bench_long_blake2s_sse41(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2s_simd::blake2s(input.get())); +} + +#[bench] +fn bench_oneblock_blake2s_portable(b: &mut Bencher) { + let mut input = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut params = blake2s_simd::Params::new(); + blake2s_simd::benchmarks::force_portable(&mut params); + b.iter(|| params.hash(input.get())); +} + +#[bench] +fn bench_long_blake2s_portable(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + let mut params = blake2s_simd::Params::new(); + blake2s_simd::benchmarks::force_portable(&mut params); + b.iter(|| params.hash(input.get())); +} + +#[bench] +fn bench_long_blake2bp(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2b_simd::blake2bp::blake2bp(input.get())); +} + +#[bench] +fn bench_long_blake2sp(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2s_simd::blake2sp::blake2sp(input.get())); +} + +#[bench] +fn bench_long_blake2b_many_2x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, LONG); + let mut input1 = RandomInput::new(b, LONG); + let params = blake2b_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2b_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input1.get()), + ]; + blake2b_simd::many::hash_many(jobs.iter_mut()); + [jobs[0].to_hash(), jobs[1].to_hash()] + }); +} + +#[bench] +fn bench_long_blake2b_many_4x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, LONG); + let mut input1 = RandomInput::new(b, LONG); + let mut input2 = RandomInput::new(b, LONG); + let mut input3 = RandomInput::new(b, LONG); + let params = blake2b_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2b_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input3.get()), + ]; + blake2b_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + ] + }); +} + +#[bench] +fn bench_long_blake2s_many_4x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, LONG); + let mut input1 = RandomInput::new(b, LONG); + let mut input2 = RandomInput::new(b, LONG); + let mut input3 = RandomInput::new(b, LONG); + let params = blake2s_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2s_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input3.get()), + ]; + blake2s_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + ] + }); +} + +#[bench] +fn bench_long_blake2s_many_8x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, LONG); + let mut input1 = RandomInput::new(b, LONG); + let mut input2 = RandomInput::new(b, LONG); + let mut input3 = RandomInput::new(b, LONG); + let mut input4 = RandomInput::new(b, LONG); + let mut input5 = RandomInput::new(b, LONG); + let mut input6 = RandomInput::new(b, LONG); + let mut input7 = RandomInput::new(b, LONG); + let params = blake2s_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2s_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input3.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input4.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input5.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input6.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input7.get()), + ]; + blake2s_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + jobs[4].to_hash(), + jobs[5].to_hash(), + jobs[6].to_hash(), + jobs[7].to_hash(), + ] + }); +} + +#[bench] +fn bench_oneblock_blake2b_many_2x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let mut input1 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let params = blake2b_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2b_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input1.get()), + ]; + blake2b_simd::many::hash_many(jobs.iter_mut()); + [jobs[0].to_hash(), jobs[1].to_hash()] + }); +} + +#[bench] +fn bench_oneblock_blake2b_many_4x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let mut input1 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let mut input2 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let mut input3 = RandomInput::new(b, blake2b_simd::BLOCKBYTES); + let params = blake2b_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2b_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2b_simd::many::HashManyJob::new(¶ms, input3.get()), + ]; + blake2b_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + ] + }); +} + +#[bench] +fn bench_oneblock_blake2s_many_4x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input1 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input2 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input3 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let params = blake2s_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2s_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input3.get()), + ]; + blake2s_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + ] + }); +} + +#[bench] +fn bench_oneblock_blake2s_many_8x(b: &mut Bencher) { + let mut input0 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input1 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input2 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input3 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input4 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input5 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input6 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let mut input7 = RandomInput::new(b, blake2s_simd::BLOCKBYTES); + let params = blake2s_simd::Params::new(); + b.iter(|| { + let mut jobs = [ + blake2s_simd::many::HashManyJob::new(¶ms, input0.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input1.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input2.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input3.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input4.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input5.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input6.get()), + blake2s_simd::many::HashManyJob::new(¶ms, input7.get()), + ]; + blake2s_simd::many::hash_many(jobs.iter_mut()); + [ + jobs[0].to_hash(), + jobs[1].to_hash(), + jobs[2].to_hash(), + jobs[3].to_hash(), + jobs[4].to_hash(), + jobs[5].to_hash(), + jobs[6].to_hash(), + jobs[7].to_hash(), + ] + }); +} + +// Note for comparison: The blake2-avx2-sneves C code is currently compiled +// with `clang -mavx2`. That is, not with -march=native. Upstream uses +// -march=native, but -mavx2 is closer to how blake2b_simd is compiled, and it +// makes the benchmark more apples-to-apples. When I compare compilers, GCC +// seems to produce better code than clang under -mavx2, but Clang seems to +// produce better code under -march=native. Not sure why. +#[cfg(feature = "blake2-avx2-sneves")] +#[bench] +fn bench_long_sneves_blake2b(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2_avx2_sneves::blake2b(input.get())); +} + +#[cfg(feature = "blake2-avx2-sneves")] +#[bench] +fn bench_long_sneves_blake2bp(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2_avx2_sneves::blake2bp(input.get())); +} + +#[cfg(feature = "blake2-avx2-sneves")] +#[bench] +fn bench_long_sneves_blake2sp(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| blake2_avx2_sneves::blake2sp(input.get())); +} + +// Note for comparison: Unlike the blake2-avx2-sneves C code above, the +// KangarooTwelve C code *is* compiled with -march=native. Their build system +// is more involved than above, and I don't want to muck around with it. +// Current benchmarks are almost exactly on par with blake2b_simd, maybe just a +// hair faster, which is a surprising coincidence. However, with the equivalent +// flag RUSTFLAGS="-C target-cpu=native", blake2b_simd pulls ahead. +#[cfg(feature = "kangarootwelve")] +#[bench] +fn bench_verylong_kangarootwelve(b: &mut Bencher) { + let mut input = RandomInput::new(b, VERYLONG); + b.iter(|| kangarootwelve::kangarootwelve(input.get())); +} + +#[cfg(feature = "kangarootwelve")] +#[bench] +fn bench_long_kangarootwelve(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| kangarootwelve::kangarootwelve(input.get())); +} + +#[cfg(feature = "kangarootwelve")] +#[bench] +fn bench_onebyte_kangarootwelve(b: &mut Bencher) { + b.iter(|| kangarootwelve::kangarootwelve(b"x")); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_long_libsodium_blake2b(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + let mut out = [0; 64]; + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + let input_slice = input.get(); + libsodium_ffi::crypto_generichash( + out.as_mut_ptr(), + out.len(), + input_slice.as_ptr(), + input_slice.len() as u64, + std::ptr::null(), + 0, + ); + }); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_onebyte_libsodium_blake2b(b: &mut Bencher) { + let mut out = [0; 64]; + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + let input_slice = b"x"; + libsodium_ffi::crypto_generichash( + out.as_mut_ptr(), + out.len(), + input_slice.as_ptr(), + input_slice.len() as u64, + std::ptr::null(), + 0, + ); + }); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_long_libsodium_chacha20(b: &mut Bencher) { + b.bytes = LONG as u64; + let mut out = vec![0; LONG]; + let mut key = [0; libsodium_ffi::crypto_stream_chacha20_KEYBYTES]; + rand::thread_rng().fill_bytes(&mut key); + let mut nonce = [0; libsodium_ffi::crypto_stream_chacha20_NONCEBYTES]; + rand::thread_rng().fill_bytes(&mut nonce); + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + libsodium_ffi::crypto_stream_chacha20( + out.as_mut_ptr(), + out.len() as u64, + nonce.as_ptr(), + key.as_ptr(), + ); + }); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_onebyte_libsodium_chacha20(b: &mut Bencher) { + let mut out = [0]; + let mut key = [0; libsodium_ffi::crypto_stream_chacha20_KEYBYTES]; + rand::thread_rng().fill_bytes(&mut key); + let mut nonce = [0; libsodium_ffi::crypto_stream_chacha20_NONCEBYTES]; + rand::thread_rng().fill_bytes(&mut nonce); + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + libsodium_ffi::crypto_stream_chacha20( + out.as_mut_ptr(), + out.len() as u64, + nonce.as_ptr(), + key.as_ptr(), + ); + }); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_long_libsodium_poly1305(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + let mut out = [0; libsodium_ffi::crypto_onetimeauth_BYTES]; + let mut key = [0; libsodium_ffi::crypto_onetimeauth_KEYBYTES]; + rand::thread_rng().fill_bytes(&mut key); + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + let input_slice = input.get(); + libsodium_ffi::crypto_onetimeauth( + out.as_mut_ptr(), + input_slice.as_ptr(), + input_slice.len() as u64, + key.as_ptr(), + ); + }); +} + +#[cfg(feature = "libsodium-ffi")] +#[bench] +fn bench_onebyte_libsodium_poly1305(b: &mut Bencher) { + let mut out = [0; libsodium_ffi::crypto_onetimeauth_BYTES]; + let mut key = [0; libsodium_ffi::crypto_onetimeauth_KEYBYTES]; + rand::thread_rng().fill_bytes(&mut key); + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + b.iter(|| unsafe { + let input_slice = b"x"; + libsodium_ffi::crypto_onetimeauth( + out.as_mut_ptr(), + input_slice.as_ptr(), + input_slice.len() as u64, + key.as_ptr(), + ); + }); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_long_openssl_md5(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::md5(), input.get())); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_onebyte_openssl_md5(b: &mut Bencher) { + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::md5(), b"x")); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_long_openssl_sha1(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha1(), input.get())); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_onebyte_openssl_sha1(b: &mut Bencher) { + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha1(), b"x")); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_long_openssl_sha256(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha256(), input.get())); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_onebyte_openssl_sha256(b: &mut Bencher) { + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha256(), b"x")); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_long_openssl_sha512(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha512(), input.get())); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_onebyte_openssl_sha3_256(b: &mut Bencher) { + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha3_256(), b"x")); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_long_openssl_sha3_256(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha3_256(), input.get())); +} + +#[cfg(feature = "openssl")] +#[bench] +fn bench_onebyte_openssl_sha512(b: &mut Bencher) { + b.iter(|| openssl::hash::hash(openssl::hash::MessageDigest::sha512(), b"x")); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_long_ring_sha1(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| ring::digest::digest(&ring::digest::SHA1_FOR_LEGACY_USE_ONLY, input.get())); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_onebyte_ring_sha1(b: &mut Bencher) { + b.iter(|| ring::digest::digest(&ring::digest::SHA1_FOR_LEGACY_USE_ONLY, b"x")); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_long_ring_sha256(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| ring::digest::digest(&ring::digest::SHA256, input.get())); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_onebyte_ring_sha256(b: &mut Bencher) { + b.iter(|| ring::digest::digest(&ring::digest::SHA256, b"x")); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_long_ring_sha512(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + b.iter(|| ring::digest::digest(&ring::digest::SHA512, input.get())); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_onebyte_ring_sha512(b: &mut Bencher) { + b.iter(|| ring::digest::digest(&ring::digest::SHA512, b"x")); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_long_ring_chacha20poly1305(b: &mut Bencher) { + let mut input = RandomInput::new(b, LONG); + let mut buf = input.get().to_vec(); + let alg = &ring::aead::CHACHA20_POLY1305; + let mut key_bytes = vec![0; alg.key_len()]; + rand::thread_rng().fill_bytes(&mut key_bytes); + let unbound_key = ring::aead::UnboundKey::new(alg, &key_bytes).expect("invalid key"); + let less_safe_key = ring::aead::LessSafeKey::new(unbound_key); + let mut nonce_bytes = vec![0; alg.nonce_len()]; + rand::thread_rng().fill_bytes(&mut nonce_bytes); + b.iter(|| { + let nonce = + ring::aead::Nonce::try_assume_unique_for_key(&nonce_bytes).expect("invalid nonce"); + less_safe_key + .seal_in_place_separate_tag(nonce, ring::aead::Aad::empty(), &mut buf) + .expect("invalid encryption") + }); +} + +#[cfg(feature = "ring")] +#[bench] +fn bench_onebyte_ring_chacha20poly1305(b: &mut Bencher) { + let mut buf = [0]; + let alg = &ring::aead::CHACHA20_POLY1305; + let mut key_bytes = vec![0; alg.key_len()]; + rand::thread_rng().fill_bytes(&mut key_bytes); + let unbound_key = ring::aead::UnboundKey::new(alg, &key_bytes).expect("invalid key"); + let less_safe_key = ring::aead::LessSafeKey::new(unbound_key); + let mut nonce_bytes = vec![0; alg.nonce_len()]; + rand::thread_rng().fill_bytes(&mut nonce_bytes); + b.iter(|| { + let nonce = + ring::aead::Nonce::try_assume_unique_for_key(&nonce_bytes).expect("invalid nonce"); + less_safe_key + .seal_in_place_separate_tag(nonce, ring::aead::Aad::empty(), &mut buf) + .expect("invalid encryption") + }); +} diff --git a/src/plonk/blake2_const/benches/bench_blake2_bin.py b/src/plonk/blake2_const/benches/bench_blake2_bin.py new file mode 100755 index 000000000..a433c7535 --- /dev/null +++ b/src/plonk/blake2_const/benches/bench_blake2_bin.py @@ -0,0 +1,108 @@ +#! /usr/bin/env python3 + +from pathlib import Path +import subprocess +import os +import statistics +import tempfile +import time + +# On my i5-8250U laptop, at 1MB of input or below, the results of the benchmark +# are pretty random. Above 10MB, all of the implementations keep getting +# faster, but their relative performance is consistent. +INPUT_SIZE = 1_000_000_000 +NUM_RUNS = 10 + +bin_root = Path(__file__).parent / "../blake2_bin" +bin_path = str(bin_root / "target/release/blake2") + +targets = [ + ["md5sum"], + ["sha1sum"], + ["sha512sum"], + ["/usr/bin/b2sum"], + [bin_path, "-b"], + [bin_path, "-s"], + [bin_path, "-bp"], + [bin_path, "-sp"], +] + + +def print_diff(diff, gigs, message, stdev=None, stdev_rate=None): + gb_per_sec = gigs / diff + diff_stdev = "" + gbps_stdev = "" + if stdev is not None: + diff_stdev = " ± {:.6f}".format(stdev) + if stdev_rate is not None: + gbps_stdev = " ± {:.6f}".format(stdev_rate) + print("{:.6f}{} ({:.6f}{} GB/s) {}".format(diff, diff_stdev, gb_per_sec, + gbps_stdev, message)) + + +def random_temp_file(size): + f = tempfile.TemporaryFile() + # Write random data 1 MiB at a time. + while size > 2**20: + f.write(os.urandom(2**20)) + size -= 2**20 + f.write(os.urandom(size)) + f.seek(0) + return f + + +def main(): + input_file = random_temp_file(INPUT_SIZE) + input_gigs = INPUT_SIZE / 1_000_000_000 + build_command = ["cargo", "build", "--release"] + print(" ".join(build_command)) + subprocess.run(build_command, cwd=bin_root) + + averages = {} + bests = {} + stdevs = {} + stdevs_rate = {} + for target in targets: + target_name = " ".join(target) + runs = [] + rates = [] + best = float('inf') + for i in range(NUM_RUNS): + input_file.seek(0) + + # Do a run! + start = time.perf_counter() + subprocess.run(target, stdin=input_file, stdout=subprocess.DEVNULL) + diff = time.perf_counter() - start + + if i == 0: + print_diff(diff, input_gigs, target_name + " (ignored)") + else: + print_diff(diff, input_gigs, target_name) + runs.append(diff) + rates.append(input_gigs / diff) + averages[target_name] = sum(runs) / len(runs) + bests[target_name] = min(runs) + stdevs[target_name] = statistics.stdev(runs) + stdevs_rate[target_name] = statistics.stdev(rates) + + print("--- best ---") + best_list = list(bests.items()) + best_list.sort(key=lambda pair: pair[1]) + for target_name, best in best_list: + print_diff(best, input_gigs, target_name) + + print("--- average ---") + average_list = list(averages.items()) + average_list.sort(key=lambda pair: pair[1]) + for target_name, average in average_list: + print_diff( + average, + input_gigs, + target_name, + stdev=stdevs[target_name], + stdev_rate=stdevs_rate[target_name]) + + +if __name__ == "__main__": + main() diff --git a/src/plonk/blake2_const/benches/bench_multiprocess/Cargo.toml b/src/plonk/blake2_const/benches/bench_multiprocess/Cargo.toml new file mode 100644 index 000000000..00c2471d7 --- /dev/null +++ b/src/plonk/blake2_const/benches/bench_multiprocess/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "bench_multiprocess" +version = "0.0.0" +authors = ["Jack O'Connor "] +edition = "2018" + +[dependencies] +blake2b_simd = { path = "../../blake2b" } +blake2s_simd = { path = "../../blake2s" } +rand = "0.6.5" +openssl = "0.10.23" +libsodium-ffi = "0.1.17" +blake2-avx2-sneves = { path = "../blake2-avx2-sneves" } +page_size = "0.4.1" +arrayvec = "0.5.0" diff --git a/src/plonk/blake2_const/benches/bench_multiprocess/plot.py b/src/plonk/blake2_const/benches/bench_multiprocess/plot.py new file mode 100755 index 000000000..58df8d75e --- /dev/null +++ b/src/plonk/blake2_const/benches/bench_multiprocess/plot.py @@ -0,0 +1,20 @@ +#! /usr/bin/python3 + +import matplotlib.pyplot as plt +import sys + +filename = sys.argv[1] + +xs = [] +ys = [] +for line in open(filename): + (x, y) = line.split() + xs.append(int(x)) + ys.append(float(y)) + +# plt.plot(xs, ys, marker=".", linestyle="none") +plt.plot(xs, ys, marker=".") +plt.xlabel("byte offset of input from a page boundary") +plt.ylabel("throughput (GB/s)") +plt.title(filename) +plt.show() diff --git a/src/plonk/blake2_const/benches/bench_multiprocess/src/main.rs b/src/plonk/blake2_const/benches/bench_multiprocess/src/main.rs new file mode 100644 index 000000000..23f4bbb16 --- /dev/null +++ b/src/plonk/blake2_const/benches/bench_multiprocess/src/main.rs @@ -0,0 +1,379 @@ +//! There are many sources of variability in the performance of these BLAKE2 +//! functions: +//! +//! 1. Random noise. We do many runs to average the noise out. +//! 2. Random noise that's sticky to a given process. See: +//! https://blog.phusion.nl/2017/07/13/understanding-your-benchmarks-and-easy-tips-for-fixing-them +//! We split the runs over many worker processes to average this out. +//! 3. Variable memory throughput depending on the offset of the input. See: +//! https://github.com/oconnor663/blake2b_simd/issues/8 +//! +//! That offset effect especially troublesome. The overall throughput of +//! BLAKE2bp at the "worst" offset is several percentage points lower than at +//! the "best". Furthermore, the relationship between offset and throughput is +//! quite complicated -- there's no simple rule like "start at a page boundary" +//! that papers over the problem. (A blunt approach like that tend to pessimize +//! BLAKE2bp in favor of many::hash, which suffers less from this effect when +//! its multiple inputs are at uncorrelated offsets.) The size of the effect +//! also grows with the length of the input; 100 MB inputs show it more than 1 +//! MB inputs, probably due to caching effects. +//! +//! Currently we try to address this by averaging over throughput at every +//! possible input offset. Experiments at +//! https://github.com/oconnor663/blake2b_simd/issues/8 show that the offset +//! effect has a period of 512 bytes, so we run every offset from 0 to 511. +//! This does seem to produce stable results, though it raises tricky questions +//! about how real world performance will compare to these benchmarks. For +//! example, real world inputs will probably sit at whatever offset the global +//! memory allocator produces, which 1) isn't random at all and 2) probably +//! varies depending on memory pressure. But such is life for benchmarks. + +extern crate blake2b_simd; + +use rand::seq::SliceRandom; +use rand::RngCore; +use std::cmp::Ordering::{Greater, Less}; +use std::env; +use std::io::prelude::*; +use std::process; +use std::ptr; +use std::str; +use std::time::Instant; + +const WORKERS: usize = 100; + +// 512 is the measured period of the offset effect in BLAKE2bp. +// See https://github.com/oconnor663/blake2b_simd/issues/8. +const OFFSET_PERIOD: usize = 512; + +const BENCH_LEN: usize = 1_000_000; + +static ALGOS: &[(&str, HashBench)] = &[ + ("blake2b_simd BLAKE2b", blake2b_hash), + ("blake2b_simd many", blake2b_hash_many), + ("blake2b_simd BLAKE2bp", hash_blake2bp), + ("blake2s_simd BLAKE2s", blake2s_hash), + ("blake2s_simd many", blake2s_hash_many), + ("blake2s_simd BLAKE2sp", hash_blake2sp), + ("sneves BLAKE2b", hash_sneves_blake2b), + ("sneves BLAKE2bp", hash_sneves_blake2bp), + ("sneves BLAKE2sp", hash_sneves_blake2sp), + ("libsodium BLAKE2b", libsodium), + ("OpenSSL SHA-1", openssl_sha1), + ("OpenSSL SHA-512", openssl_sha512), +]; + +type HashBench = fn() -> u128; + +fn bench(mut f: impl FnMut()) -> u128 { + // dummy run + f(); + // real timed runs + let before = Instant::now(); + for _ in 0..OFFSET_PERIOD { + f(); + } + let after = Instant::now(); + (after - before).as_nanos() +} + +fn blake2b_hash() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2b_simd::blake2b(input.get()); + }) +} + +fn blake2s_hash() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2s_simd::blake2s(input.get()); + }) +} + +// This one does each run with N=degree inputs at the same offset. This leads +// to an offset effect comparable to what we see with BLAKE2bp. +// fn blake2b_hash_many_correlated() -> u128 { +// let degree = blake2b_simd::many::degree(); +// let bench_len = BENCH_LEN / degree; +// let mut inputs = Vec::new(); +// for _ in 0..degree { +// inputs.push(OffsetInput::new(bench_len)); +// } +// let params = blake2b_simd::Params::new(); +// bench(|| { +// let mut jobs = arrayvec::ArrayVec::<[_; blake2b_simd::many::MAX_DEGREE]>::new(); +// for input in &mut inputs { +// let job = blake2b_simd::many::HashManyJob::new(¶ms, input.get()); +// jobs.push(job); +// } +// blake2b_simd::many::hash_many(&mut jobs); +// }) +// } + +// This one does each run with N=degree inputs at uncorrelated offsets. This +// turns out to reduce the offset effect and give better performance. This is +// currently the number I report in the crate documentation. On the one hand, +// that's a self-serving decision, because it's a higher number. On the other +// hand, the fact that numbers are different is pretty important, and I don't +// want to bury it. +fn blake2b_hash_many() -> u128 { + let degree = blake2b_simd::many::degree(); + let bench_len = BENCH_LEN / degree; + let mut inputs = Vec::new(); + for _ in 0..degree { + let mut offset_input = OffsetInput::new(bench_len); + offset_input.offsets.shuffle(); + inputs.push(OffsetInput::new(bench_len)); + } + let params = blake2b_simd::Params::new(); + bench(|| { + let mut jobs = arrayvec::ArrayVec::<[_; blake2b_simd::many::MAX_DEGREE]>::new(); + for input in &mut inputs { + let job = blake2b_simd::many::HashManyJob::new(¶ms, input.get()); + jobs.push(job); + } + blake2b_simd::many::hash_many(&mut jobs); + }) +} + +fn blake2s_hash_many() -> u128 { + let degree = blake2s_simd::many::degree(); + let bench_len = BENCH_LEN / degree; + let mut inputs = Vec::new(); + for _ in 0..degree { + let mut offset_input = OffsetInput::new(bench_len); + offset_input.offsets.shuffle(); + inputs.push(OffsetInput::new(bench_len)); + } + let params = blake2s_simd::Params::new(); + bench(|| { + let mut jobs = arrayvec::ArrayVec::<[_; blake2s_simd::many::MAX_DEGREE]>::new(); + for input in &mut inputs { + let job = blake2s_simd::many::HashManyJob::new(¶ms, input.get()); + jobs.push(job); + } + blake2s_simd::many::hash_many(&mut jobs); + }) +} + +fn hash_blake2bp() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2b_simd::blake2bp::blake2bp(input.get()); + }) +} + +fn hash_blake2sp() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2s_simd::blake2sp::blake2sp(input.get()); + }) +} + +fn hash_sneves_blake2b() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2_avx2_sneves::blake2b(input.get()); + }) +} + +fn hash_sneves_blake2bp() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2_avx2_sneves::blake2bp(input.get()); + }) +} + +fn hash_sneves_blake2sp() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + blake2_avx2_sneves::blake2sp(input.get()); + }) +} + +fn libsodium() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + let mut out = [0; 64]; + unsafe { + let init_ret = libsodium_ffi::sodium_init(); + assert!(init_ret != -1); + } + let input_slice = input.get(); + unsafe { + libsodium_ffi::crypto_generichash( + out.as_mut_ptr(), + out.len(), + input_slice.as_ptr(), + input_slice.len() as u64, + ptr::null(), + 0, + ); + }; + }) +} + +fn openssl_sha1() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + openssl::hash::hash(openssl::hash::MessageDigest::sha1(), input.get()).unwrap(); + }) +} + +fn openssl_sha512() -> u128 { + let mut input = OffsetInput::new(BENCH_LEN); + bench(|| { + openssl::hash::hash(openssl::hash::MessageDigest::sha512(), input.get()).unwrap(); + }) +} + +struct VecIter { + vec: Vec, + i: usize, +} + +impl VecIter { + fn next(&mut self) -> T { + let item = self.vec[self.i].clone(); + self.i += 1; + if self.i >= self.vec.len() { + self.i = 0; + } + item + } + + fn shuffle(&mut self) { + self.vec.shuffle(&mut rand::thread_rng()); + } +} + +// This struct serves inputs that rotate through all possible memory offsets +// relative to OFFSET_PERIOD. +struct OffsetInput { + buf: Vec, + len: usize, + offsets: VecIter, +} + +impl OffsetInput { + fn new(len: usize) -> Self { + let mut buf = vec![0u8; len + OFFSET_PERIOD]; + rand::thread_rng().fill_bytes(&mut buf); + // Make each offset absolute in the address space, by adjusting for + // where the Vec was allocated. + let adjustment = OFFSET_PERIOD - (buf.as_ptr() as usize % OFFSET_PERIOD); + let offsets: Vec = (0..OFFSET_PERIOD) + .map(|off| (off + adjustment) % OFFSET_PERIOD) + .collect(); + Self { + buf, + len, + offsets: VecIter { vec: offsets, i: 0 }, + } + } + + fn get(&mut self) -> &[u8] { + &self.buf[self.offsets.next()..][..self.len] + } +} + +fn get_hash_bench(name: &str) -> HashBench { + let mut hash_fn = None; + for &(algo_name, f) in ALGOS { + if name == algo_name { + hash_fn = Some(f); + break; + } + } + hash_fn.expect(&format!("no such algo: {}", name)) +} + +// Note that bytes/nanosecond and GB/second are the same unit. +fn rate_f32(ns: u128, input_len: usize) -> f32 { + input_len as f32 / ns as f32 +} + +fn worker(algo: &str) { + let hash_bench = get_hash_bench(algo); + let total_ns = hash_bench(); + println!("{}", total_ns); +} + +fn run_algo(algo_name: &str) -> f32 { + // Fire off all the workers in series and collect their reported times. + let mut _times = Vec::new(); + let mut _total_ns = 0; + for _ in 0..WORKERS { + env::set_var("BENCH_ALGO", algo_name); + let mut cmd = process::Command::new(env::current_exe().unwrap()); + cmd.stdout(process::Stdio::piped()); + let child = cmd.spawn().unwrap(); + let output = child.wait_with_output().unwrap(); + let ns: u128 = str::from_utf8(&output.stdout) + .unwrap() + .trim() + .parse() + .unwrap(); + // eprintln!( + // "worker throughput: {}", + // rate_f32(ns, RUNS_PER_WORKER * worker_len) + // ); + _times.push(ns); + _total_ns += ns; + } + _times.sort(); + let throughput = rate_f32(_total_ns, WORKERS * OFFSET_PERIOD * BENCH_LEN); + + // eprintln!("final throughput: {}", throughput); + throughput +} + +fn main() { + if let Ok(name) = env::var("BENCH_ALGO") { + worker(&name); + return; + } + + // If a positional argument is given, it should be a substring of exactly + // one algorithm name. In that case, run just that algorithm, and print the + // result with no other formatting. + if let Some(arg) = std::env::args().nth(1) { + let matches: Vec<&str> = ALGOS + .iter() + .map(|&(name, _)| name) + .filter(|&name| name == arg.as_str()) + .collect(); + if matches.is_empty() { + panic!("no match"); + } + if matches.len() > 1 { + panic!("too many matches {:?}", &matches); + } + let algo_name = matches[0]; + let throughput = run_algo(algo_name); + println!("{:.3}", throughput); + return; + } + + // Otherwise run all the benchmarks and print them sorted at the end. + let mut throughputs = Vec::new(); + for &(algo_name, _) in ALGOS { + print!("{}: ", algo_name); + std::io::stdout().flush().unwrap(); + + let throughput = run_algo(algo_name); + throughputs.push((throughput, algo_name)); + + println!("{:.3}", throughput); + } + + // Sort by the fastest rate. + throughputs.sort_by(|t1, t2| if t1.0 > t2.0 { Less } else { Greater }); + + let max_name_len = ALGOS.iter().map(|(name, _)| name.len()).max().unwrap(); + println!("\nIn order:"); + for &(throughput, name) in &throughputs { + println!("{0:1$} {2:.3}", name, max_name_len, throughput); + } +} diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/.gitignore b/src/plonk/blake2_const/benches/blake2-avx2-sneves/.gitignore new file mode 100644 index 000000000..2f88dbac5 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/.gitignore @@ -0,0 +1,3 @@ +/target +**/*.rs.bk +Cargo.lock \ No newline at end of file diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/Cargo.toml b/src/plonk/blake2_const/benches/blake2-avx2-sneves/Cargo.toml new file mode 100644 index 000000000..020c33fb8 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "blake2-avx2-sneves" +version = "0.0.0" +authors = ["Jack O'Connor "] +edition = "2018" + +[dependencies] + +[build-dependencies] +cc = "1.0.37" + +[dev-dependencies] +serde = { version = "1.0.91", features = ["derive"] } +serde_json = "1.0.39" +hex = "0.3.2" diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/README.md b/src/plonk/blake2_const/benches/blake2-avx2-sneves/README.md new file mode 100644 index 000000000..d8d42998e --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/README.md @@ -0,0 +1,5 @@ +This is Rust FFI wrapper around the +[`blake2-avx2`](https://github.com/sneves/blake2-avx2) C implementation, +which is vendored here and statically linked. It's intended for +benchmarking only. This code assumes AVX2 support and isn't suitable for +shipping. diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/LICENSE b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/LICENSE new file mode 100644 index 000000000..0e259d42c --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/LICENSE @@ -0,0 +1,121 @@ +Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/Makefile b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/Makefile new file mode 100644 index 000000000..565ecafd6 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/Makefile @@ -0,0 +1,48 @@ +CFLAGS=-std=c89 -Ofast -march=haswell -Wall -Wextra -pedantic -Wfatal-errors -Wno-long-long + +all: check + +bench: check + $(SHELL) bench.sh + +check: blake2b-check-1.exe blake2b-check-2.exe blake2b-check-3.exe blake2bp-check-1.exe blake2bp-check-2.exe blake2bp-check-3.exe blake2sp-check-1.exe blake2sp-check-2.exe blake2sp-check-3.exe + +blake2b-check-1.exe: blake2b.c + $(CC) $(CFLAGS) -DBLAKE2B_SELFTEST -DPERMUTE_WITH_NOTHING -o $@ $< + ./$@ + +blake2b-check-2.exe: blake2b.c + $(CC) $(CFLAGS) -DBLAKE2B_SELFTEST -DPERMUTE_WITH_SHUFFLES -o $@ $< + ./$@ + +blake2b-check-3.exe: blake2b.c + $(CC) $(CFLAGS) -DBLAKE2B_SELFTEST -DPERMUTE_WITH_GATHER -o $@ $< + ./$@ + +blake2bp-check-1.exe: blake2bp.c + $(CC) $(CFLAGS) -DBLAKE2BP_SELFTEST -DPERMUTE_WITH_NOTHING -o $@ $< + ./$@ + +blake2bp-check-2.exe: blake2bp.c + $(CC) $(CFLAGS) -DBLAKE2BP_SELFTEST -DPERMUTE_WITH_SHUFFLES -o $@ $< + ./$@ + +blake2bp-check-3.exe: blake2bp.c + $(CC) $(CFLAGS) -DBLAKE2BP_SELFTEST -DPERMUTE_WITH_GATHER -o $@ $< + ./$@ + + +blake2sp-check-1.exe: blake2sp.c + $(CC) $(CFLAGS) -DBLAKE2SP_SELFTEST -DPERMUTE_WITH_NOTHING -o $@ $< + ./$@ + +blake2sp-check-2.exe: blake2sp.c + $(CC) $(CFLAGS) -DBLAKE2SP_SELFTEST -DPERMUTE_WITH_SHUFFLES -o $@ $< + ./$@ + +blake2sp-check-3.exe: blake2sp.c + $(CC) $(CFLAGS) -DBLAKE2SP_SELFTEST -DPERMUTE_WITH_GATHER -o $@ $< + ./$@ + +clean: + rm -f *.exe \ No newline at end of file diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/README.md b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/README.md new file mode 100644 index 000000000..e53078ee2 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/README.md @@ -0,0 +1,13 @@ +# BLAKE2 AVX2 implementations + +This is **experimental** code implementing [BLAKE2](https://blake2.net/) using the AVX2 instruction set present in the Intel [Haswell](https://en.wikipedia.org/wiki/Haswell_%28microarchitecture%29) and later microarchitectures. + +It currently implements BLAKE2b, BLAKE2bp, and BLAKE2sp using 3 similar but slightly different approaches: one lets the compiler choose how to permute the message, another one does it manually, and the final one uses the gather instructions introduced with AVX2. Current recorded speeds for long messages are: + + - 3.19 cycles per byte on Haswell for BLAKE2b; + - 1.37 cycles per byte on Haswell for BLAKE2bp; + - 1.39 cycles per byte on Haswell for BLAKE2sp. + + - 3.08 cycles per byte on Skylake for BLAKE2b; + - 1.29 cycles per byte on Skylake for BLAKE2bp; + - 1.30 cycles per byte on Skylake for BLAKE2sp. diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.c b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.c new file mode 100644 index 000000000..e0ae08db6 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.c @@ -0,0 +1,82 @@ +#include +#include +#include +#include + +#if defined(_MSC_VER) +#include +#endif + +extern int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen); + +static int bench_cmp( const void *x, const void *y ) { + const int64_t *ix = (const int64_t *)x; + const int64_t *iy = (const int64_t *)y; + return *ix - *iy; +} + +#if defined(_MSC_VER) +static uint64_t cpucycles(void) { + return __rdtsc(); +} +#else +#if defined(__i386__) +static uint64_t cpucycles(void) { + uint64_t result; + __asm__ __volatile__( + "rdtsc\n" + : "=A" ( result ) + ); + return result; +} +#elif defined(__x86_64__) +static uint64_t cpucycles(void) { + uint64_t result; + __asm__ __volatile__( + "rdtsc\n" + "shlq $32,%%rdx\n" + "orq %%rdx,%%rax" + : "=a" ( result ) :: "%rdx" + ); + return result; +} +#else +#error "Don't know how to count cycles!" +#endif +#endif /* _MSC_VER */ + +#define BENCH_TRIALS 512 +#define BENCH_MAXLEN 1536 + +int main(void) { + static uint8_t in[4096]; + static uint64_t median[4096 + 1]; + int i, j; + + printf( "#bytes median per byte\n" ); + /* 1 ... BENCH_MAXLEN */ + for(j = 0; j <= 4096; ++j) { + uint64_t cycles[BENCH_TRIALS + 1]; + + for(i = 0; i <= BENCH_TRIALS; ++i) { + cycles[i] = cpucycles(); + crypto_hash(in, in, j); + } + + for(i = 0; i < BENCH_TRIALS; ++i) { + cycles[i] = cycles[i + 1] - cycles[i]; + } + + qsort(cycles, BENCH_TRIALS, sizeof(uint64_t), bench_cmp); + median[j] = cycles[BENCH_TRIALS / 2]; + } + + for( j = 0; j <= BENCH_MAXLEN; j += 8 ) { + printf("%5d %7.2f\n", j, (double)median[j] / j); + } + + printf( "#2048 %7.2f\n", (double)median[2048] / 2048.0 ); + printf( "#4096 %7.2f\n", (double)median[4096] / 4096.0 ); + printf( "#long %7.2f\n", (double)(median[4096] - median[2048]) / 2048.0); + return 0; +} diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.sh b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.sh new file mode 100644 index 000000000..4a84979a8 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/bench.sh @@ -0,0 +1,16 @@ +for primitive in blake2b.c blake2bp.c blake2sp.c +do + for compiler in gcc clang + do + for opt in -O3 -Os + do + for impl in PERMUTE_WITH_NONE PERMUTE_WITH_SHUFFLES PERMUTE_WITH_GATHER + do + $compiler $opt -D$impl -DSUPERCOP -std=gnu99 -mavx2 -o bench.exe bench.c $primitive + echo $compiler $opt -D$impl $primitive + taskset -c 0 ./bench.exe | tail -3 + rm -f bench.exe + done + done + done +done diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2-kat.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2-kat.h new file mode 100644 index 000000000..a1f210bef --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2-kat.h @@ -0,0 +1,131138 @@ +#ifndef BLAKE2_AVX2_BLAKE2_KAT_H +#define BLAKE2_AVX2_BLAKE2_KAT_H + +#include +#include "blake2.h" + +#define BLAKE2_KAT_LENGTH 2048 + +static const uint8_t blake2s_kat[BLAKE2_KAT_LENGTH][BLAKE2S_OUTBYTES] = +{ + { + 0x69, 0x21, 0x7A, 0x30, 0x79, 0x90, 0x80, 0x94, + 0xE1, 0x11, 0x21, 0xD0, 0x42, 0x35, 0x4A, 0x7C, + 0x1F, 0x55, 0xB6, 0x48, 0x2C, 0xA1, 0xA5, 0x1E, + 0x1B, 0x25, 0x0D, 0xFD, 0x1E, 0xD0, 0xEE, 0xF9 + }, + { + 0xE3, 0x4D, 0x74, 0xDB, 0xAF, 0x4F, 0xF4, 0xC6, + 0xAB, 0xD8, 0x71, 0xCC, 0x22, 0x04, 0x51, 0xD2, + 0xEA, 0x26, 0x48, 0x84, 0x6C, 0x77, 0x57, 0xFB, + 0xAA, 0xC8, 0x2F, 0xE5, 0x1A, 0xD6, 0x4B, 0xEA + }, + { + 0xDD, 0xAD, 0x9A, 0xB1, 0x5D, 0xAC, 0x45, 0x49, + 0xBA, 0x42, 0xF4, 0x9D, 0x26, 0x24, 0x96, 0xBE, + 0xF6, 0xC0, 0xBA, 0xE1, 0xDD, 0x34, 0x2A, 0x88, + 0x08, 0xF8, 0xEA, 0x26, 0x7C, 0x6E, 0x21, 0x0C + }, + { + 0xE8, 0xF9, 0x1C, 0x6E, 0xF2, 0x32, 0xA0, 0x41, + 0x45, 0x2A, 0xB0, 0xE1, 0x49, 0x07, 0x0C, 0xDD, + 0x7D, 0xD1, 0x76, 0x9E, 0x75, 0xB3, 0xA5, 0x92, + 0x1B, 0xE3, 0x78, 0x76, 0xC4, 0x5C, 0x99, 0x00 + }, + { + 0x0C, 0xC7, 0x0E, 0x00, 0x34, 0x8B, 0x86, 0xBA, + 0x29, 0x44, 0xD0, 0xC3, 0x20, 0x38, 0xB2, 0x5C, + 0x55, 0x58, 0x4F, 0x90, 0xDF, 0x23, 0x04, 0xF5, + 0x5F, 0xA3, 0x32, 0xAF, 0x5F, 0xB0, 0x1E, 0x20 + }, + { + 0xEC, 0x19, 0x64, 0x19, 0x10, 0x87, 0xA4, 0xFE, + 0x9D, 0xF1, 0xC7, 0x95, 0x34, 0x2A, 0x02, 0xFF, + 0xC1, 0x91, 0xA5, 0xB2, 0x51, 0x76, 0x48, 0x56, + 0xAE, 0x5B, 0x8B, 0x57, 0x69, 0xF0, 0xC6, 0xCD + }, + { + 0xE1, 0xFA, 0x51, 0x61, 0x8D, 0x7D, 0xF4, 0xEB, + 0x70, 0xCF, 0x0D, 0x5A, 0x9E, 0x90, 0x6F, 0x80, + 0x6E, 0x9D, 0x19, 0xF7, 0xF4, 0xF0, 0x1E, 0x3B, + 0x62, 0x12, 0x88, 0xE4, 0x12, 0x04, 0x05, 0xD6 + }, + { + 0x59, 0x80, 0x01, 0xFA, 0xFB, 0xE8, 0xF9, 0x4E, + 0xC6, 0x6D, 0xC8, 0x27, 0xD0, 0x12, 0xCF, 0xCB, + 0xBA, 0x22, 0x28, 0x56, 0x9F, 0x44, 0x8E, 0x89, + 0xEA, 0x22, 0x08, 0xC8, 0xBF, 0x76, 0x92, 0x93 + }, + { + 0xC7, 0xE8, 0x87, 0xB5, 0x46, 0x62, 0x36, 0x35, + 0xE9, 0x3E, 0x04, 0x95, 0x59, 0x8F, 0x17, 0x26, + 0x82, 0x19, 0x96, 0xC2, 0x37, 0x77, 0x05, 0xB9, + 0x3A, 0x1F, 0x63, 0x6F, 0x87, 0x2B, 0xFA, 0x2D + }, + { + 0xC3, 0x15, 0xA4, 0x37, 0xDD, 0x28, 0x06, 0x2A, + 0x77, 0x0D, 0x48, 0x19, 0x67, 0x13, 0x6B, 0x1B, + 0x5E, 0xB8, 0x8B, 0x21, 0xEE, 0x53, 0xD0, 0x32, + 0x9C, 0x58, 0x97, 0x12, 0x6E, 0x9D, 0xB0, 0x2C + }, + { + 0xBB, 0x47, 0x3D, 0xED, 0xDC, 0x05, 0x5F, 0xEA, + 0x62, 0x28, 0xF2, 0x07, 0xDA, 0x57, 0x53, 0x47, + 0xBB, 0x00, 0x40, 0x4C, 0xD3, 0x49, 0xD3, 0x8C, + 0x18, 0x02, 0x63, 0x07, 0xA2, 0x24, 0xCB, 0xFF + }, + { + 0x68, 0x7E, 0x18, 0x73, 0xA8, 0x27, 0x75, 0x91, + 0xBB, 0x33, 0xD9, 0xAD, 0xF9, 0xA1, 0x39, 0x12, + 0xEF, 0xEF, 0xE5, 0x57, 0xCA, 0xFC, 0x39, 0xA7, + 0x95, 0x26, 0x23, 0xE4, 0x72, 0x55, 0xF1, 0x6D + }, + { + 0x1A, 0xC7, 0xBA, 0x75, 0x4D, 0x6E, 0x2F, 0x94, + 0xE0, 0xE8, 0x6C, 0x46, 0xBF, 0xB2, 0x62, 0xAB, + 0xBB, 0x74, 0xF4, 0x50, 0xEF, 0x45, 0x6D, 0x6B, + 0x4D, 0x97, 0xAA, 0x80, 0xCE, 0x6D, 0xA7, 0x67 + }, + { + 0x01, 0x2C, 0x97, 0x80, 0x96, 0x14, 0x81, 0x6B, + 0x5D, 0x94, 0x94, 0x47, 0x7D, 0x4B, 0x68, 0x7D, + 0x15, 0xB9, 0x6E, 0xB6, 0x9C, 0x0E, 0x80, 0x74, + 0xA8, 0x51, 0x6F, 0x31, 0x22, 0x4B, 0x5C, 0x98 + }, + { + 0x91, 0xFF, 0xD2, 0x6C, 0xFA, 0x4D, 0xA5, 0x13, + 0x4C, 0x7E, 0xA2, 0x62, 0xF7, 0x88, 0x9C, 0x32, + 0x9F, 0x61, 0xF6, 0xA6, 0x57, 0x22, 0x5C, 0xC2, + 0x12, 0xF4, 0x00, 0x56, 0xD9, 0x86, 0xB3, 0xF4 + }, + { + 0xD9, 0x7C, 0x82, 0x8D, 0x81, 0x82, 0xA7, 0x21, + 0x80, 0xA0, 0x6A, 0x78, 0x26, 0x83, 0x30, 0x67, + 0x3F, 0x7C, 0x4E, 0x06, 0x35, 0x94, 0x7C, 0x04, + 0xC0, 0x23, 0x23, 0xFD, 0x45, 0xC0, 0xA5, 0x2D + }, + { + 0xEF, 0xC0, 0x4C, 0xDC, 0x39, 0x1C, 0x7E, 0x91, + 0x19, 0xBD, 0x38, 0x66, 0x8A, 0x53, 0x4E, 0x65, + 0xFE, 0x31, 0x03, 0x6D, 0x6A, 0x62, 0x11, 0x2E, + 0x44, 0xEB, 0xEB, 0x11, 0xF9, 0xC5, 0x70, 0x80 + }, + { + 0x99, 0x2C, 0xF5, 0xC0, 0x53, 0x44, 0x2A, 0x5F, + 0xBC, 0x4F, 0xAF, 0x58, 0x3E, 0x04, 0xE5, 0x0B, + 0xB7, 0x0D, 0x2F, 0x39, 0xFB, 0xB6, 0xA5, 0x03, + 0xF8, 0x9E, 0x56, 0xA6, 0x3E, 0x18, 0x57, 0x8A + }, + { + 0x38, 0x64, 0x0E, 0x9F, 0x21, 0x98, 0x3E, 0x67, + 0xB5, 0x39, 0xCA, 0xCC, 0xAE, 0x5E, 0xCF, 0x61, + 0x5A, 0xE2, 0x76, 0x4F, 0x75, 0xA0, 0x9C, 0x9C, + 0x59, 0xB7, 0x64, 0x83, 0xC1, 0xFB, 0xC7, 0x35 + }, + { + 0x21, 0x3D, 0xD3, 0x4C, 0x7E, 0xFE, 0x4F, 0xB2, + 0x7A, 0x6B, 0x35, 0xF6, 0xB4, 0x00, 0x0D, 0x1F, + 0xE0, 0x32, 0x81, 0xAF, 0x3C, 0x72, 0x3E, 0x5C, + 0x9F, 0x94, 0x74, 0x7A, 0x5F, 0x31, 0xCD, 0x3B + }, + { + 0xEC, 0x24, 0x6E, 0xEE, 0xB9, 0xCE, 0xD3, 0xF7, + 0xAD, 0x33, 0xED, 0x28, 0x66, 0x0D, 0xD9, 0xBB, + 0x07, 0x32, 0x51, 0x3D, 0xB4, 0xE2, 0xFA, 0x27, + 0x8B, 0x60, 0xCD, 0xE3, 0x68, 0x2A, 0x4C, 0xCD + }, + { + 0xAC, 0x9B, 0x61, 0xD4, 0x46, 0x64, 0x8C, 0x30, + 0x05, 0xD7, 0x89, 0x2B, 0xF3, 0xA8, 0x71, 0x9F, + 0x4C, 0x81, 0x81, 0xCF, 0xDC, 0xBC, 0x2B, 0x79, + 0xFE, 0xF1, 0x0A, 0x27, 0x9B, 0x91, 0x10, 0x95 + }, + { + 0x7B, 0xF8, 0xB2, 0x29, 0x59, 0xE3, 0x4E, 0x3A, + 0x43, 0xF7, 0x07, 0x92, 0x23, 0xE8, 0x3A, 0x97, + 0x54, 0x61, 0x7D, 0x39, 0x1E, 0x21, 0x3D, 0xFD, + 0x80, 0x8E, 0x41, 0xB9, 0xBE, 0xAD, 0x4C, 0xE7 + }, + { + 0x68, 0xD4, 0xB5, 0xD4, 0xFA, 0x0E, 0x30, 0x2B, + 0x64, 0xCC, 0xC5, 0xAF, 0x79, 0x29, 0x13, 0xAC, + 0x4C, 0x88, 0xEC, 0x95, 0xC0, 0x7D, 0xDF, 0x40, + 0x69, 0x42, 0x56, 0xEB, 0x88, 0xCE, 0x9F, 0x3D + }, + { + 0xB2, 0xC2, 0x42, 0x0F, 0x05, 0xF9, 0xAB, 0xE3, + 0x63, 0x15, 0x91, 0x93, 0x36, 0xB3, 0x7E, 0x4E, + 0x0F, 0xA3, 0x3F, 0xF7, 0xE7, 0x6A, 0x49, 0x27, + 0x67, 0x00, 0x6F, 0xDB, 0x5D, 0x93, 0x54, 0x62 + }, + { + 0x13, 0x4F, 0x61, 0xBB, 0xD0, 0xBB, 0xB6, 0x9A, + 0xED, 0x53, 0x43, 0x90, 0x45, 0x51, 0xA3, 0xE6, + 0xC1, 0xAA, 0x7D, 0xCD, 0xD7, 0x7E, 0x90, 0x3E, + 0x70, 0x23, 0xEB, 0x7C, 0x60, 0x32, 0x0A, 0xA7 + }, + { + 0x46, 0x93, 0xF9, 0xBF, 0xF7, 0xD4, 0xF3, 0x98, + 0x6A, 0x7D, 0x17, 0x6E, 0x6E, 0x06, 0xF7, 0x2A, + 0xD1, 0x49, 0x0D, 0x80, 0x5C, 0x99, 0xE2, 0x53, + 0x47, 0xB8, 0xDE, 0x77, 0xB4, 0xDB, 0x6D, 0x9B + }, + { + 0x85, 0x3E, 0x26, 0xF7, 0x41, 0x95, 0x3B, 0x0F, + 0xD5, 0xBD, 0xB4, 0x24, 0xE8, 0xAB, 0x9E, 0x8B, + 0x37, 0x50, 0xEA, 0xA8, 0xEF, 0x61, 0xE4, 0x79, + 0x02, 0xC9, 0x1E, 0x55, 0x4E, 0x9C, 0x73, 0xB9 + }, + { + 0xF7, 0xDE, 0x53, 0x63, 0x61, 0xAB, 0xAA, 0x0E, + 0x15, 0x81, 0x56, 0xCF, 0x0E, 0xA4, 0xF6, 0x3A, + 0x99, 0xB5, 0xE4, 0x05, 0x4F, 0x8F, 0xA4, 0xC9, + 0xD4, 0x5F, 0x62, 0x85, 0xCA, 0xD5, 0x56, 0x94 + }, + { + 0x4C, 0x23, 0x06, 0x08, 0x86, 0x0A, 0x99, 0xAE, + 0x8D, 0x7B, 0xD5, 0xC2, 0xCC, 0x17, 0xFA, 0x52, + 0x09, 0x6B, 0x9A, 0x61, 0xBE, 0xDB, 0x17, 0xCB, + 0x76, 0x17, 0x86, 0x4A, 0xD2, 0x9C, 0xA7, 0xA6 + }, + { + 0xAE, 0xB9, 0x20, 0xEA, 0x87, 0x95, 0x2D, 0xAD, + 0xB1, 0xFB, 0x75, 0x92, 0x91, 0xE3, 0x38, 0x81, + 0x39, 0xA8, 0x72, 0x86, 0x50, 0x01, 0x88, 0x6E, + 0xD8, 0x47, 0x52, 0xE9, 0x3C, 0x25, 0x0C, 0x2A + }, + { + 0xAB, 0xA4, 0xAD, 0x9B, 0x48, 0x0B, 0x9D, 0xF3, + 0xD0, 0x8C, 0xA5, 0xE8, 0x7B, 0x0C, 0x24, 0x40, + 0xD4, 0xE4, 0xEA, 0x21, 0x22, 0x4C, 0x2E, 0xB4, + 0x2C, 0xBA, 0xE4, 0x69, 0xD0, 0x89, 0xB9, 0x31 + }, + { + 0x05, 0x82, 0x56, 0x07, 0xD7, 0xFD, 0xF2, 0xD8, + 0x2E, 0xF4, 0xC3, 0xC8, 0xC2, 0xAE, 0xA9, 0x61, + 0xAD, 0x98, 0xD6, 0x0E, 0xDF, 0xF7, 0xD0, 0x18, + 0x98, 0x3E, 0x21, 0x20, 0x4C, 0x0D, 0x93, 0xD1 + }, + { + 0xA7, 0x42, 0xF8, 0xB6, 0xAF, 0x82, 0xD8, 0xA6, + 0xCA, 0x23, 0x57, 0xC5, 0xF1, 0xCF, 0x91, 0xDE, + 0xFB, 0xD0, 0x66, 0x26, 0x7D, 0x75, 0xC0, 0x48, + 0xB3, 0x52, 0x36, 0x65, 0x85, 0x02, 0x59, 0x62 + }, + { + 0x2B, 0xCA, 0xC8, 0x95, 0x99, 0x00, 0x0B, 0x42, + 0xC9, 0x5A, 0xE2, 0x38, 0x35, 0xA7, 0x13, 0x70, + 0x4E, 0xD7, 0x97, 0x89, 0xC8, 0x4F, 0xEF, 0x14, + 0x9A, 0x87, 0x4F, 0xF7, 0x33, 0xF0, 0x17, 0xA2 + }, + { + 0xAC, 0x1E, 0xD0, 0x7D, 0x04, 0x8F, 0x10, 0x5A, + 0x9E, 0x5B, 0x7A, 0xB8, 0x5B, 0x09, 0xA4, 0x92, + 0xD5, 0xBA, 0xFF, 0x14, 0xB8, 0xBF, 0xB0, 0xE9, + 0xFD, 0x78, 0x94, 0x86, 0xEE, 0xA2, 0xB9, 0x74 + }, + { + 0xE4, 0x8D, 0x0E, 0xCF, 0xAF, 0x49, 0x7D, 0x5B, + 0x27, 0xC2, 0x5D, 0x99, 0xE1, 0x56, 0xCB, 0x05, + 0x79, 0xD4, 0x40, 0xD6, 0xE3, 0x1F, 0xB6, 0x24, + 0x73, 0x69, 0x6D, 0xBF, 0x95, 0xE0, 0x10, 0xE4 + }, + { + 0x12, 0xA9, 0x1F, 0xAD, 0xF8, 0xB2, 0x16, 0x44, + 0xFD, 0x0F, 0x93, 0x4F, 0x3C, 0x4A, 0x8F, 0x62, + 0xBA, 0x86, 0x2F, 0xFD, 0x20, 0xE8, 0xE9, 0x61, + 0x15, 0x4C, 0x15, 0xC1, 0x38, 0x84, 0xED, 0x3D + }, + { + 0x7C, 0xBE, 0xE9, 0x6E, 0x13, 0x98, 0x97, 0xDC, + 0x98, 0xFB, 0xEF, 0x3B, 0xE8, 0x1A, 0xD4, 0xD9, + 0x64, 0xD2, 0x35, 0xCB, 0x12, 0x14, 0x1F, 0xB6, + 0x67, 0x27, 0xE6, 0xE5, 0xDF, 0x73, 0xA8, 0x78 + }, + { + 0xEB, 0xF6, 0x6A, 0xBB, 0x59, 0x7A, 0xE5, 0x72, + 0xA7, 0x29, 0x7C, 0xB0, 0x87, 0x1E, 0x35, 0x5A, + 0xCC, 0xAF, 0xAD, 0x83, 0x77, 0xB8, 0xE7, 0x8B, + 0xF1, 0x64, 0xCE, 0x2A, 0x18, 0xDE, 0x4B, 0xAF + }, + { + 0x71, 0xB9, 0x33, 0xB0, 0x7E, 0x4F, 0xF7, 0x81, + 0x8C, 0xE0, 0x59, 0xD0, 0x08, 0x82, 0x9E, 0x45, + 0x3C, 0x6F, 0xF0, 0x2E, 0xC0, 0xA7, 0xDB, 0x39, + 0x3F, 0xC2, 0xD8, 0x70, 0xF3, 0x7A, 0x72, 0x86 + }, + { + 0x7C, 0xF7, 0xC5, 0x13, 0x31, 0x22, 0x0B, 0x8D, + 0x3E, 0xBA, 0xED, 0x9C, 0x29, 0x39, 0x8A, 0x16, + 0xD9, 0x81, 0x56, 0xE2, 0x61, 0x3C, 0xB0, 0x88, + 0xF2, 0xB0, 0xE0, 0x8A, 0x1B, 0xE4, 0xCF, 0x4F + }, + { + 0x3E, 0x41, 0xA1, 0x08, 0xE0, 0xF6, 0x4A, 0xD2, + 0x76, 0xB9, 0x79, 0xE1, 0xCE, 0x06, 0x82, 0x79, + 0xE1, 0x6F, 0x7B, 0xC7, 0xE4, 0xAA, 0x1D, 0x21, + 0x1E, 0x17, 0xB8, 0x11, 0x61, 0xDF, 0x16, 0x02 + }, + { + 0x88, 0x65, 0x02, 0xA8, 0x2A, 0xB4, 0x7B, 0xA8, + 0xD8, 0x67, 0x10, 0xAA, 0x9D, 0xE3, 0xD4, 0x6E, + 0xA6, 0x5C, 0x47, 0xAF, 0x6E, 0xE8, 0xDE, 0x45, + 0x0C, 0xCE, 0xB8, 0xB1, 0x1B, 0x04, 0x5F, 0x50 + }, + { + 0xC0, 0x21, 0xBC, 0x5F, 0x09, 0x54, 0xFE, 0xE9, + 0x4F, 0x46, 0xEA, 0x09, 0x48, 0x7E, 0x10, 0xA8, + 0x48, 0x40, 0xD0, 0x2F, 0x64, 0x81, 0x0B, 0xC0, + 0x8D, 0x9E, 0x55, 0x1F, 0x7D, 0x41, 0x68, 0x14 + }, + { + 0x20, 0x30, 0x51, 0x6E, 0x8A, 0x5F, 0xE1, 0x9A, + 0xE7, 0x9C, 0x33, 0x6F, 0xCE, 0x26, 0x38, 0x2A, + 0x74, 0x9D, 0x3F, 0xD0, 0xEC, 0x91, 0xE5, 0x37, + 0xD4, 0xBD, 0x23, 0x58, 0xC1, 0x2D, 0xFB, 0x22 + }, + { + 0x55, 0x66, 0x98, 0xDA, 0xC8, 0x31, 0x7F, 0xD3, + 0x6D, 0xFB, 0xDF, 0x25, 0xA7, 0x9C, 0xB1, 0x12, + 0xD5, 0x42, 0x58, 0x60, 0x60, 0x5C, 0xBA, 0xF5, + 0x07, 0xF2, 0x3B, 0xF7, 0xE9, 0xF4, 0x2A, 0xFE + }, + { + 0x2F, 0x86, 0x7B, 0xA6, 0x77, 0x73, 0xFD, 0xC3, + 0xE9, 0x2F, 0xCE, 0xD9, 0x9A, 0x64, 0x09, 0xAD, + 0x39, 0xD0, 0xB8, 0x80, 0xFD, 0xE8, 0xF1, 0x09, + 0xA8, 0x17, 0x30, 0xC4, 0x45, 0x1D, 0x01, 0x78 + }, + { + 0x17, 0x2E, 0xC2, 0x18, 0xF1, 0x19, 0xDF, 0xAE, + 0x98, 0x89, 0x6D, 0xFF, 0x29, 0xDD, 0x98, 0x76, + 0xC9, 0x4A, 0xF8, 0x74, 0x17, 0xF9, 0xAE, 0x4C, + 0x70, 0x14, 0xBB, 0x4E, 0x4B, 0x96, 0xAF, 0xC7 + }, + { + 0x3F, 0x85, 0x81, 0x4A, 0x18, 0x19, 0x5F, 0x87, + 0x9A, 0xA9, 0x62, 0xF9, 0x5D, 0x26, 0xBD, 0x82, + 0xA2, 0x78, 0xF2, 0xB8, 0x23, 0x20, 0x21, 0x8F, + 0x6B, 0x3B, 0xD6, 0xF7, 0xF6, 0x67, 0xA6, 0xD9 + }, + { + 0x1B, 0x61, 0x8F, 0xBA, 0xA5, 0x66, 0xB3, 0xD4, + 0x98, 0xC1, 0x2E, 0x98, 0x2C, 0x9E, 0xC5, 0x2E, + 0x4D, 0xA8, 0x5A, 0x8C, 0x54, 0xF3, 0x8F, 0x34, + 0xC0, 0x90, 0x39, 0x4F, 0x23, 0xC1, 0x84, 0xC1 + }, + { + 0x0C, 0x75, 0x8F, 0xB5, 0x69, 0x2F, 0xFD, 0x41, + 0xA3, 0x57, 0x5D, 0x0A, 0xF0, 0x0C, 0xC7, 0xFB, + 0xF2, 0xCB, 0xE5, 0x90, 0x5A, 0x58, 0x32, 0x3A, + 0x88, 0xAE, 0x42, 0x44, 0xF6, 0xE4, 0xC9, 0x93 + }, + { + 0xA9, 0x31, 0x36, 0x0C, 0xAD, 0x62, 0x8C, 0x7F, + 0x12, 0xA6, 0xC1, 0xC4, 0xB7, 0x53, 0xB0, 0xF4, + 0x06, 0x2A, 0xEF, 0x3C, 0xE6, 0x5A, 0x1A, 0xE3, + 0xF1, 0x93, 0x69, 0xDA, 0xDF, 0x3A, 0xE2, 0x3D + }, + { + 0xCB, 0xAC, 0x7D, 0x77, 0x3B, 0x1E, 0x3B, 0x3C, + 0x66, 0x91, 0xD7, 0xAB, 0xB7, 0xE9, 0xDF, 0x04, + 0x5C, 0x8B, 0xA1, 0x92, 0x68, 0xDE, 0xD1, 0x53, + 0x20, 0x7F, 0x5E, 0x80, 0x43, 0x52, 0xEC, 0x5D + }, + { + 0x23, 0xA1, 0x96, 0xD3, 0x80, 0x2E, 0xD3, 0xC1, + 0xB3, 0x84, 0x01, 0x9A, 0x82, 0x32, 0x58, 0x40, + 0xD3, 0x2F, 0x71, 0x95, 0x0C, 0x45, 0x80, 0xB0, + 0x34, 0x45, 0xE0, 0x89, 0x8E, 0x14, 0x05, 0x3C + }, + { + 0xF4, 0x49, 0x54, 0x70, 0xF2, 0x26, 0xC8, 0xC2, + 0x14, 0xBE, 0x08, 0xFD, 0xFA, 0xD4, 0xBC, 0x4A, + 0x2A, 0x9D, 0xBE, 0xA9, 0x13, 0x6A, 0x21, 0x0D, + 0xF0, 0xD4, 0xB6, 0x49, 0x29, 0xE6, 0xFC, 0x14 + }, + { + 0xE2, 0x90, 0xDD, 0x27, 0x0B, 0x46, 0x7F, 0x34, + 0xAB, 0x1C, 0x00, 0x2D, 0x34, 0x0F, 0xA0, 0x16, + 0x25, 0x7F, 0xF1, 0x9E, 0x58, 0x33, 0xFD, 0xBB, + 0xF2, 0xCB, 0x40, 0x1C, 0x3B, 0x28, 0x17, 0xDE + }, + { + 0x9F, 0xC7, 0xB5, 0xDE, 0xD3, 0xC1, 0x50, 0x42, + 0xB2, 0xA6, 0x58, 0x2D, 0xC3, 0x9B, 0xE0, 0x16, + 0xD2, 0x4A, 0x68, 0x2D, 0x5E, 0x61, 0xAD, 0x1E, + 0xFF, 0x9C, 0x63, 0x30, 0x98, 0x48, 0xF7, 0x06 + }, + { + 0x8C, 0xCA, 0x67, 0xA3, 0x6D, 0x17, 0xD5, 0xE6, + 0x34, 0x1C, 0xB5, 0x92, 0xFD, 0x7B, 0xEF, 0x99, + 0x26, 0xC9, 0xE3, 0xAA, 0x10, 0x27, 0xEA, 0x11, + 0xA7, 0xD8, 0xBD, 0x26, 0x0B, 0x57, 0x6E, 0x04 + }, + { + 0x40, 0x93, 0x92, 0xF5, 0x60, 0xF8, 0x68, 0x31, + 0xDA, 0x43, 0x73, 0xEE, 0x5E, 0x00, 0x74, 0x26, + 0x05, 0x95, 0xD7, 0xBC, 0x24, 0x18, 0x3B, 0x60, + 0xED, 0x70, 0x0D, 0x45, 0x83, 0xD3, 0xF6, 0xF0 + }, + { + 0x28, 0x02, 0x16, 0x5D, 0xE0, 0x90, 0x91, 0x55, + 0x46, 0xF3, 0x39, 0x8C, 0xD8, 0x49, 0x16, 0x4A, + 0x19, 0xF9, 0x2A, 0xDB, 0xC3, 0x61, 0xAD, 0xC9, + 0x9B, 0x0F, 0x20, 0xC8, 0xEA, 0x07, 0x10, 0x54 + }, + { + 0xAD, 0x83, 0x91, 0x68, 0xD9, 0xF8, 0xA4, 0xBE, + 0x95, 0xBA, 0x9E, 0xF9, 0xA6, 0x92, 0xF0, 0x72, + 0x56, 0xAE, 0x43, 0xFE, 0x6F, 0x98, 0x64, 0xE2, + 0x90, 0x69, 0x1B, 0x02, 0x56, 0xCE, 0x50, 0xA9 + }, + { + 0x75, 0xFD, 0xAA, 0x50, 0x38, 0xC2, 0x84, 0xB8, + 0x6D, 0x6E, 0x8A, 0xFF, 0xE8, 0xB2, 0x80, 0x7E, + 0x46, 0x7B, 0x86, 0x60, 0x0E, 0x79, 0xAF, 0x36, + 0x89, 0xFB, 0xC0, 0x63, 0x28, 0xCB, 0xF8, 0x94 + }, + { + 0xE5, 0x7C, 0xB7, 0x94, 0x87, 0xDD, 0x57, 0x90, + 0x24, 0x32, 0xB2, 0x50, 0x73, 0x38, 0x13, 0xBD, + 0x96, 0xA8, 0x4E, 0xFC, 0xE5, 0x9F, 0x65, 0x0F, + 0xAC, 0x26, 0xE6, 0x69, 0x6A, 0xEF, 0xAF, 0xC3 + }, + { + 0x56, 0xF3, 0x4E, 0x8B, 0x96, 0x55, 0x7E, 0x90, + 0xC1, 0xF2, 0x4B, 0x52, 0xD0, 0xC8, 0x9D, 0x51, + 0x08, 0x6A, 0xCF, 0x1B, 0x00, 0xF6, 0x34, 0xCF, + 0x1D, 0xDE, 0x92, 0x33, 0xB8, 0xEA, 0xAA, 0x3E + }, + { + 0x1B, 0x53, 0xEE, 0x94, 0xAA, 0xF3, 0x4E, 0x4B, + 0x15, 0x9D, 0x48, 0xDE, 0x35, 0x2C, 0x7F, 0x06, + 0x61, 0xD0, 0xA4, 0x0E, 0xDF, 0xF9, 0x5A, 0x0B, + 0x16, 0x39, 0xB4, 0x09, 0x0E, 0x97, 0x44, 0x72 + }, + { + 0x05, 0x70, 0x5E, 0x2A, 0x81, 0x75, 0x7C, 0x14, + 0xBD, 0x38, 0x3E, 0xA9, 0x8D, 0xDA, 0x54, 0x4E, + 0xB1, 0x0E, 0x6B, 0xC0, 0x7B, 0xAE, 0x43, 0x5E, + 0x25, 0x18, 0xDB, 0xE1, 0x33, 0x52, 0x53, 0x75 + }, + { + 0xD8, 0xB2, 0x86, 0x6E, 0x8A, 0x30, 0x9D, 0xB5, + 0x3E, 0x52, 0x9E, 0xC3, 0x29, 0x11, 0xD8, 0x2F, + 0x5C, 0xA1, 0x6C, 0xFF, 0x76, 0x21, 0x68, 0x91, + 0xA9, 0x67, 0x6A, 0xA3, 0x1A, 0xAA, 0x6C, 0x42 + }, + { + 0xF5, 0x04, 0x1C, 0x24, 0x12, 0x70, 0xEB, 0x04, + 0xC7, 0x1E, 0xC2, 0xC9, 0x5D, 0x4C, 0x38, 0xD8, + 0x03, 0xB1, 0x23, 0x7B, 0x0F, 0x29, 0xFD, 0x4D, + 0xB3, 0xEB, 0x39, 0x76, 0x69, 0xE8, 0x86, 0x99 + }, + { + 0x9A, 0x4C, 0xE0, 0x77, 0xC3, 0x49, 0x32, 0x2F, + 0x59, 0x5E, 0x0E, 0xE7, 0x9E, 0xD0, 0xDA, 0x5F, + 0xAB, 0x66, 0x75, 0x2C, 0xBF, 0xEF, 0x8F, 0x87, + 0xD0, 0xE9, 0xD0, 0x72, 0x3C, 0x75, 0x30, 0xDD + }, + { + 0x65, 0x7B, 0x09, 0xF3, 0xD0, 0xF5, 0x2B, 0x5B, + 0x8F, 0x2F, 0x97, 0x16, 0x3A, 0x0E, 0xDF, 0x0C, + 0x04, 0xF0, 0x75, 0x40, 0x8A, 0x07, 0xBB, 0xEB, + 0x3A, 0x41, 0x01, 0xA8, 0x91, 0x99, 0x0D, 0x62 + }, + { + 0x1E, 0x3F, 0x7B, 0xD5, 0xA5, 0x8F, 0xA5, 0x33, + 0x34, 0x4A, 0xA8, 0xED, 0x3A, 0xC1, 0x22, 0xBB, + 0x9E, 0x70, 0xD4, 0xEF, 0x50, 0xD0, 0x04, 0x53, + 0x08, 0x21, 0x94, 0x8F, 0x5F, 0xE6, 0x31, 0x5A + }, + { + 0x80, 0xDC, 0xCF, 0x3F, 0xD8, 0x3D, 0xFD, 0x0D, + 0x35, 0xAA, 0x28, 0x58, 0x59, 0x22, 0xAB, 0x89, + 0xD5, 0x31, 0x39, 0x97, 0x67, 0x3E, 0xAF, 0x90, + 0x5C, 0xEA, 0x9C, 0x0B, 0x22, 0x5C, 0x7B, 0x5F + }, + { + 0x8A, 0x0D, 0x0F, 0xBF, 0x63, 0x77, 0xD8, 0x3B, + 0xB0, 0x8B, 0x51, 0x4B, 0x4B, 0x1C, 0x43, 0xAC, + 0xC9, 0x5D, 0x75, 0x17, 0x14, 0xF8, 0x92, 0x56, + 0x45, 0xCB, 0x6B, 0xC8, 0x56, 0xCA, 0x15, 0x0A + }, + { + 0x9F, 0xA5, 0xB4, 0x87, 0x73, 0x8A, 0xD2, 0x84, + 0x4C, 0xC6, 0x34, 0x8A, 0x90, 0x19, 0x18, 0xF6, + 0x59, 0xA3, 0xB8, 0x9E, 0x9C, 0x0D, 0xFE, 0xEA, + 0xD3, 0x0D, 0xD9, 0x4B, 0xCF, 0x42, 0xEF, 0x8E + }, + { + 0x80, 0x83, 0x2C, 0x4A, 0x16, 0x77, 0xF5, 0xEA, + 0x25, 0x60, 0xF6, 0x68, 0xE9, 0x35, 0x4D, 0xD3, + 0x69, 0x97, 0xF0, 0x37, 0x28, 0xCF, 0xA5, 0x5E, + 0x1B, 0x38, 0x33, 0x7C, 0x0C, 0x9E, 0xF8, 0x18 + }, + { + 0xAB, 0x37, 0xDD, 0xB6, 0x83, 0x13, 0x7E, 0x74, + 0x08, 0x0D, 0x02, 0x6B, 0x59, 0x0B, 0x96, 0xAE, + 0x9B, 0xB4, 0x47, 0x72, 0x2F, 0x30, 0x5A, 0x5A, + 0xC5, 0x70, 0xEC, 0x1D, 0xF9, 0xB1, 0x74, 0x3C + }, + { + 0x3E, 0xE7, 0x35, 0xA6, 0x94, 0xC2, 0x55, 0x9B, + 0x69, 0x3A, 0xA6, 0x86, 0x29, 0x36, 0x1E, 0x15, + 0xD1, 0x22, 0x65, 0xAD, 0x6A, 0x3D, 0xED, 0xF4, + 0x88, 0xB0, 0xB0, 0x0F, 0xAC, 0x97, 0x54, 0xBA + }, + { + 0xD6, 0xFC, 0xD2, 0x32, 0x19, 0xB6, 0x47, 0xE4, + 0xCB, 0xD5, 0xEB, 0x2D, 0x0A, 0xD0, 0x1E, 0xC8, + 0x83, 0x8A, 0x4B, 0x29, 0x01, 0xFC, 0x32, 0x5C, + 0xC3, 0x70, 0x19, 0x81, 0xCA, 0x6C, 0x88, 0x8B + }, + { + 0x05, 0x20, 0xEC, 0x2F, 0x5B, 0xF7, 0xA7, 0x55, + 0xDA, 0xCB, 0x50, 0xC6, 0xBF, 0x23, 0x3E, 0x35, + 0x15, 0x43, 0x47, 0x63, 0xDB, 0x01, 0x39, 0xCC, + 0xD9, 0xFA, 0xEF, 0xBB, 0x82, 0x07, 0x61, 0x2D + }, + { + 0xAF, 0xF3, 0xB7, 0x5F, 0x3F, 0x58, 0x12, 0x64, + 0xD7, 0x66, 0x16, 0x62, 0xB9, 0x2F, 0x5A, 0xD3, + 0x7C, 0x1D, 0x32, 0xBD, 0x45, 0xFF, 0x81, 0xA4, + 0xED, 0x8A, 0xDC, 0x9E, 0xF3, 0x0D, 0xD9, 0x89 + }, + { + 0xD0, 0xDD, 0x65, 0x0B, 0xEF, 0xD3, 0xBA, 0x63, + 0xDC, 0x25, 0x10, 0x2C, 0x62, 0x7C, 0x92, 0x1B, + 0x9C, 0xBE, 0xB0, 0xB1, 0x30, 0x68, 0x69, 0x35, + 0xB5, 0xC9, 0x27, 0xCB, 0x7C, 0xCD, 0x5E, 0x3B + }, + { + 0xE1, 0x14, 0x98, 0x16, 0xB1, 0x0A, 0x85, 0x14, + 0xFB, 0x3E, 0x2C, 0xAB, 0x2C, 0x08, 0xBE, 0xE9, + 0xF7, 0x3C, 0xE7, 0x62, 0x21, 0x70, 0x12, 0x46, + 0xA5, 0x89, 0xBB, 0xB6, 0x73, 0x02, 0xD8, 0xA9 + }, + { + 0x7D, 0xA3, 0xF4, 0x41, 0xDE, 0x90, 0x54, 0x31, + 0x7E, 0x72, 0xB5, 0xDB, 0xF9, 0x79, 0xDA, 0x01, + 0xE6, 0xBC, 0xEE, 0xBB, 0x84, 0x78, 0xEA, 0xE6, + 0xA2, 0x28, 0x49, 0xD9, 0x02, 0x92, 0x63, 0x5C + }, + { + 0x12, 0x30, 0xB1, 0xFC, 0x8A, 0x7D, 0x92, 0x15, + 0xED, 0xC2, 0xD4, 0xA2, 0xDE, 0xCB, 0xDD, 0x0A, + 0x6E, 0x21, 0x6C, 0x92, 0x42, 0x78, 0xC9, 0x1F, + 0xC5, 0xD1, 0x0E, 0x7D, 0x60, 0x19, 0x2D, 0x94 + }, + { + 0x57, 0x50, 0xD7, 0x16, 0xB4, 0x80, 0x8F, 0x75, + 0x1F, 0xEB, 0xC3, 0x88, 0x06, 0xBA, 0x17, 0x0B, + 0xF6, 0xD5, 0x19, 0x9A, 0x78, 0x16, 0xBE, 0x51, + 0x4E, 0x3F, 0x93, 0x2F, 0xBE, 0x0C, 0xB8, 0x71 + }, + { + 0x6F, 0xC5, 0x9B, 0x2F, 0x10, 0xFE, 0xBA, 0x95, + 0x4A, 0xA6, 0x82, 0x0B, 0x3C, 0xA9, 0x87, 0xEE, + 0x81, 0xD5, 0xCC, 0x1D, 0xA3, 0xC6, 0x3C, 0xE8, + 0x27, 0x30, 0x1C, 0x56, 0x9D, 0xFB, 0x39, 0xCE + }, + { + 0xC7, 0xC3, 0xFE, 0x1E, 0xEB, 0xDC, 0x7B, 0x5A, + 0x93, 0x93, 0x26, 0xE8, 0xDD, 0xB8, 0x3E, 0x8B, + 0xF2, 0xB7, 0x80, 0xB6, 0x56, 0x78, 0xCB, 0x62, + 0xF2, 0x08, 0xB0, 0x40, 0xAB, 0xDD, 0x35, 0xE2 + }, + { + 0x0C, 0x75, 0xC1, 0xA1, 0x5C, 0xF3, 0x4A, 0x31, + 0x4E, 0xE4, 0x78, 0xF4, 0xA5, 0xCE, 0x0B, 0x8A, + 0x6B, 0x36, 0x52, 0x8E, 0xF7, 0xA8, 0x20, 0x69, + 0x6C, 0x3E, 0x42, 0x46, 0xC5, 0xA1, 0x58, 0x64 + }, + { + 0x21, 0x6D, 0xC1, 0x2A, 0x10, 0x85, 0x69, 0xA3, + 0xC7, 0xCD, 0xDE, 0x4A, 0xED, 0x43, 0xA6, 0xC3, + 0x30, 0x13, 0x9D, 0xDA, 0x3C, 0xCC, 0x4A, 0x10, + 0x89, 0x05, 0xDB, 0x38, 0x61, 0x89, 0x90, 0x50 + }, + { + 0xA5, 0x7B, 0xE6, 0xAE, 0x67, 0x56, 0xF2, 0x8B, + 0x02, 0xF5, 0x9D, 0xAD, 0xF7, 0xE0, 0xD7, 0xD8, + 0x80, 0x7F, 0x10, 0xFA, 0x15, 0xCE, 0xD1, 0xAD, + 0x35, 0x85, 0x52, 0x1A, 0x1D, 0x99, 0x5A, 0x89 + }, + { + 0x81, 0x6A, 0xEF, 0x87, 0x59, 0x53, 0x71, 0x6C, + 0xD7, 0xA5, 0x81, 0xF7, 0x32, 0xF5, 0x3D, 0xD4, + 0x35, 0xDA, 0xB6, 0x6D, 0x09, 0xC3, 0x61, 0xD2, + 0xD6, 0x59, 0x2D, 0xE1, 0x77, 0x55, 0xD8, 0xA8 + }, + { + 0x9A, 0x76, 0x89, 0x32, 0x26, 0x69, 0x3B, 0x6E, + 0xA9, 0x7E, 0x6A, 0x73, 0x8F, 0x9D, 0x10, 0xFB, + 0x3D, 0x0B, 0x43, 0xAE, 0x0E, 0x8B, 0x7D, 0x81, + 0x23, 0xEA, 0x76, 0xCE, 0x97, 0x98, 0x9C, 0x7E + }, + { + 0x8D, 0xAE, 0xDB, 0x9A, 0x27, 0x15, 0x29, 0xDB, + 0xB7, 0xDC, 0x3B, 0x60, 0x7F, 0xE5, 0xEB, 0x2D, + 0x32, 0x11, 0x77, 0x07, 0x58, 0xDD, 0x3B, 0x0A, + 0x35, 0x93, 0xD2, 0xD7, 0x95, 0x4E, 0x2D, 0x5B + }, + { + 0x16, 0xDB, 0xC0, 0xAA, 0x5D, 0xD2, 0xC7, 0x74, + 0xF5, 0x05, 0x10, 0x0F, 0x73, 0x37, 0x86, 0xD8, + 0xA1, 0x75, 0xFC, 0xBB, 0xB5, 0x9C, 0x43, 0xE1, + 0xFB, 0xFF, 0x3E, 0x1E, 0xAF, 0x31, 0xCB, 0x4A + }, + { + 0x86, 0x06, 0xCB, 0x89, 0x9C, 0x6A, 0xEA, 0xF5, + 0x1B, 0x9D, 0xB0, 0xFE, 0x49, 0x24, 0xA9, 0xFD, + 0x5D, 0xAB, 0xC1, 0x9F, 0x88, 0x26, 0xF2, 0xBC, + 0x1C, 0x1D, 0x7D, 0xA1, 0x4D, 0x2C, 0x2C, 0x99 + }, + { + 0x84, 0x79, 0x73, 0x1A, 0xED, 0xA5, 0x7B, 0xD3, + 0x7E, 0xAD, 0xB5, 0x1A, 0x50, 0x7E, 0x30, 0x7F, + 0x3B, 0xD9, 0x5E, 0x69, 0xDB, 0xCA, 0x94, 0xF3, + 0xBC, 0x21, 0x72, 0x60, 0x66, 0xAD, 0x6D, 0xFD + }, + { + 0x58, 0x47, 0x3A, 0x9E, 0xA8, 0x2E, 0xFA, 0x3F, + 0x3B, 0x3D, 0x8F, 0xC8, 0x3E, 0xD8, 0x86, 0x31, + 0x27, 0xB3, 0x3A, 0xE8, 0xDE, 0xAE, 0x63, 0x07, + 0x20, 0x1E, 0xDB, 0x6D, 0xDE, 0x61, 0xDE, 0x29 + }, + { + 0x9A, 0x92, 0x55, 0xD5, 0x3A, 0xF1, 0x16, 0xDE, + 0x8B, 0xA2, 0x7C, 0xE3, 0x5B, 0x4C, 0x7E, 0x15, + 0x64, 0x06, 0x57, 0xA0, 0xFC, 0xB8, 0x88, 0xC7, + 0x0D, 0x95, 0x43, 0x1D, 0xAC, 0xD8, 0xF8, 0x30 + }, + { + 0x9E, 0xB0, 0x5F, 0xFB, 0xA3, 0x9F, 0xD8, 0x59, + 0x6A, 0x45, 0x49, 0x3E, 0x18, 0xD2, 0x51, 0x0B, + 0xF3, 0xEF, 0x06, 0x5C, 0x51, 0xD6, 0xE1, 0x3A, + 0xBE, 0x66, 0xAA, 0x57, 0xE0, 0x5C, 0xFD, 0xB7 + }, + { + 0x81, 0xDC, 0xC3, 0xA5, 0x05, 0xEA, 0xCE, 0x3F, + 0x87, 0x9D, 0x8F, 0x70, 0x27, 0x76, 0x77, 0x0F, + 0x9D, 0xF5, 0x0E, 0x52, 0x1D, 0x14, 0x28, 0xA8, + 0x5D, 0xAF, 0x04, 0xF9, 0xAD, 0x21, 0x50, 0xE0 + }, + { + 0xE3, 0xE3, 0xC4, 0xAA, 0x3A, 0xCB, 0xBC, 0x85, + 0x33, 0x2A, 0xF9, 0xD5, 0x64, 0xBC, 0x24, 0x16, + 0x5E, 0x16, 0x87, 0xF6, 0xB1, 0xAD, 0xCB, 0xFA, + 0xE7, 0x7A, 0x8F, 0x03, 0xC7, 0x2A, 0xC2, 0x8C + }, + { + 0x67, 0x46, 0xC8, 0x0B, 0x4E, 0xB5, 0x6A, 0xEA, + 0x45, 0xE6, 0x4E, 0x72, 0x89, 0xBB, 0xA3, 0xED, + 0xBF, 0x45, 0xEC, 0xF8, 0x20, 0x64, 0x81, 0xFF, + 0x63, 0x02, 0x12, 0x29, 0x84, 0xCD, 0x52, 0x6A + }, + { + 0x2B, 0x62, 0x8E, 0x52, 0x76, 0x4D, 0x7D, 0x62, + 0xC0, 0x86, 0x8B, 0x21, 0x23, 0x57, 0xCD, 0xD1, + 0x2D, 0x91, 0x49, 0x82, 0x2F, 0x4E, 0x98, 0x45, + 0xD9, 0x18, 0xA0, 0x8D, 0x1A, 0xE9, 0x90, 0xC0 + }, + { + 0xE4, 0xBF, 0xE8, 0x0D, 0x58, 0xC9, 0x19, 0x94, + 0x61, 0x39, 0x09, 0xDC, 0x4B, 0x1A, 0x12, 0x49, + 0x68, 0x96, 0xC0, 0x04, 0xAF, 0x7B, 0x57, 0x01, + 0x48, 0x3D, 0xE4, 0x5D, 0x28, 0x23, 0xD7, 0x8E + }, + { + 0xEB, 0xB4, 0xBA, 0x15, 0x0C, 0xEF, 0x27, 0x34, + 0x34, 0x5B, 0x5D, 0x64, 0x1B, 0xBE, 0xD0, 0x3A, + 0x21, 0xEA, 0xFA, 0xE9, 0x33, 0xC9, 0x9E, 0x00, + 0x92, 0x12, 0xEF, 0x04, 0x57, 0x4A, 0x85, 0x30 + }, + { + 0x39, 0x66, 0xEC, 0x73, 0xB1, 0x54, 0xAC, 0xC6, + 0x97, 0xAC, 0x5C, 0xF5, 0xB2, 0x4B, 0x40, 0xBD, + 0xB0, 0xDB, 0x9E, 0x39, 0x88, 0x36, 0xD7, 0x6D, + 0x4B, 0x88, 0x0E, 0x3B, 0x2A, 0xF1, 0xAA, 0x27 + }, + { + 0xEF, 0x7E, 0x48, 0x31, 0xB3, 0xA8, 0x46, 0x36, + 0x51, 0x8D, 0x6E, 0x4B, 0xFC, 0xE6, 0x4A, 0x43, + 0xDB, 0x2A, 0x5D, 0xDA, 0x9C, 0xCA, 0x2B, 0x44, + 0xF3, 0x90, 0x33, 0xBD, 0xC4, 0x0D, 0x62, 0x43 + }, + { + 0x7A, 0xBF, 0x6A, 0xCF, 0x5C, 0x8E, 0x54, 0x9D, + 0xDB, 0xB1, 0x5A, 0xE8, 0xD8, 0xB3, 0x88, 0xC1, + 0xC1, 0x97, 0xE6, 0x98, 0x73, 0x7C, 0x97, 0x85, + 0x50, 0x1E, 0xD1, 0xF9, 0x49, 0x30, 0xB7, 0xD9 + }, + { + 0x88, 0x01, 0x8D, 0xED, 0x66, 0x81, 0x3F, 0x0C, + 0xA9, 0x5D, 0xEF, 0x47, 0x4C, 0x63, 0x06, 0x92, + 0x01, 0x99, 0x67, 0xB9, 0xE3, 0x68, 0x88, 0xDA, + 0xDD, 0x94, 0x12, 0x47, 0x19, 0xB6, 0x82, 0xF6 + }, + { + 0x39, 0x30, 0x87, 0x6B, 0x9F, 0xC7, 0x52, 0x90, + 0x36, 0xB0, 0x08, 0xB1, 0xB8, 0xBB, 0x99, 0x75, + 0x22, 0xA4, 0x41, 0x63, 0x5A, 0x0C, 0x25, 0xEC, + 0x02, 0xFB, 0x6D, 0x90, 0x26, 0xE5, 0x5A, 0x97 + }, + { + 0x0A, 0x40, 0x49, 0xD5, 0x7E, 0x83, 0x3B, 0x56, + 0x95, 0xFA, 0xC9, 0x3D, 0xD1, 0xFB, 0xEF, 0x31, + 0x66, 0xB4, 0x4B, 0x12, 0xAD, 0x11, 0x24, 0x86, + 0x62, 0x38, 0x3A, 0xE0, 0x51, 0xE1, 0x58, 0x27 + }, + { + 0x81, 0xDC, 0xC0, 0x67, 0x8B, 0xB6, 0xA7, 0x65, + 0xE4, 0x8C, 0x32, 0x09, 0x65, 0x4F, 0xE9, 0x00, + 0x89, 0xCE, 0x44, 0xFF, 0x56, 0x18, 0x47, 0x7E, + 0x39, 0xAB, 0x28, 0x64, 0x76, 0xDF, 0x05, 0x2B + }, + { + 0xE6, 0x9B, 0x3A, 0x36, 0xA4, 0x46, 0x19, 0x12, + 0xDC, 0x08, 0x34, 0x6B, 0x11, 0xDD, 0xCB, 0x9D, + 0xB7, 0x96, 0xF8, 0x85, 0xFD, 0x01, 0x93, 0x6E, + 0x66, 0x2F, 0xE2, 0x92, 0x97, 0xB0, 0x99, 0xA4 + }, + { + 0x5A, 0xC6, 0x50, 0x3B, 0x0D, 0x8D, 0xA6, 0x91, + 0x76, 0x46, 0xE6, 0xDC, 0xC8, 0x7E, 0xDC, 0x58, + 0xE9, 0x42, 0x45, 0x32, 0x4C, 0xC2, 0x04, 0xF4, + 0xDD, 0x4A, 0xF0, 0x15, 0x63, 0xAC, 0xD4, 0x27 + }, + { + 0xDF, 0x6D, 0xDA, 0x21, 0x35, 0x9A, 0x30, 0xBC, + 0x27, 0x17, 0x80, 0x97, 0x1C, 0x1A, 0xBD, 0x56, + 0xA6, 0xEF, 0x16, 0x7E, 0x48, 0x08, 0x87, 0x88, + 0x8E, 0x73, 0xA8, 0x6D, 0x3B, 0xF6, 0x05, 0xE9 + }, + { + 0xE8, 0xE6, 0xE4, 0x70, 0x71, 0xE7, 0xB7, 0xDF, + 0x25, 0x80, 0xF2, 0x25, 0xCF, 0xBB, 0xED, 0xF8, + 0x4C, 0xE6, 0x77, 0x46, 0x62, 0x66, 0x28, 0xD3, + 0x30, 0x97, 0xE4, 0xB7, 0xDC, 0x57, 0x11, 0x07 + }, + { + 0x53, 0xE4, 0x0E, 0xAD, 0x62, 0x05, 0x1E, 0x19, + 0xCB, 0x9B, 0xA8, 0x13, 0x3E, 0x3E, 0x5C, 0x1C, + 0xE0, 0x0D, 0xDC, 0xAD, 0x8A, 0xCF, 0x34, 0x2A, + 0x22, 0x43, 0x60, 0xB0, 0xAC, 0xC1, 0x47, 0x77 + }, + { + 0x9C, 0xCD, 0x53, 0xFE, 0x80, 0xBE, 0x78, 0x6A, + 0xA9, 0x84, 0x63, 0x84, 0x62, 0xFB, 0x28, 0xAF, + 0xDF, 0x12, 0x2B, 0x34, 0xD7, 0x8F, 0x46, 0x87, + 0xEC, 0x63, 0x2B, 0xB1, 0x9D, 0xE2, 0x37, 0x1A + }, + { + 0xCB, 0xD4, 0x80, 0x52, 0xC4, 0x8D, 0x78, 0x84, + 0x66, 0xA3, 0xE8, 0x11, 0x8C, 0x56, 0xC9, 0x7F, + 0xE1, 0x46, 0xE5, 0x54, 0x6F, 0xAA, 0xF9, 0x3E, + 0x2B, 0xC3, 0xC4, 0x7E, 0x45, 0x93, 0x97, 0x53 + }, + { + 0x25, 0x68, 0x83, 0xB1, 0x4E, 0x2A, 0xF4, 0x4D, + 0xAD, 0xB2, 0x8E, 0x1B, 0x34, 0xB2, 0xAC, 0x0F, + 0x0F, 0x4C, 0x91, 0xC3, 0x4E, 0xC9, 0x16, 0x9E, + 0x29, 0x03, 0x61, 0x58, 0xAC, 0xAA, 0x95, 0xB9 + }, + { + 0x44, 0x71, 0xB9, 0x1A, 0xB4, 0x2D, 0xB7, 0xC4, + 0xDD, 0x84, 0x90, 0xAB, 0x95, 0xA2, 0xEE, 0x8D, + 0x04, 0xE3, 0xEF, 0x5C, 0x3D, 0x6F, 0xC7, 0x1A, + 0xC7, 0x4B, 0x2B, 0x26, 0x91, 0x4D, 0x16, 0x41 + }, + { + 0xA5, 0xEB, 0x08, 0x03, 0x8F, 0x8F, 0x11, 0x55, + 0xED, 0x86, 0xE6, 0x31, 0x90, 0x6F, 0xC1, 0x30, + 0x95, 0xF6, 0xBB, 0xA4, 0x1D, 0xE5, 0xD4, 0xE7, + 0x95, 0x75, 0x8E, 0xC8, 0xC8, 0xDF, 0x8A, 0xF1 + }, + { + 0xDC, 0x1D, 0xB6, 0x4E, 0xD8, 0xB4, 0x8A, 0x91, + 0x0E, 0x06, 0x0A, 0x6B, 0x86, 0x63, 0x74, 0xC5, + 0x78, 0x78, 0x4E, 0x9A, 0xC4, 0x9A, 0xB2, 0x77, + 0x40, 0x92, 0xAC, 0x71, 0x50, 0x19, 0x34, 0xAC + }, + { + 0x28, 0x54, 0x13, 0xB2, 0xF2, 0xEE, 0x87, 0x3D, + 0x34, 0x31, 0x9E, 0xE0, 0xBB, 0xFB, 0xB9, 0x0F, + 0x32, 0xDA, 0x43, 0x4C, 0xC8, 0x7E, 0x3D, 0xB5, + 0xED, 0x12, 0x1B, 0xB3, 0x98, 0xED, 0x96, 0x4B + }, + { + 0x02, 0x16, 0xE0, 0xF8, 0x1F, 0x75, 0x0F, 0x26, + 0xF1, 0x99, 0x8B, 0xC3, 0x93, 0x4E, 0x3E, 0x12, + 0x4C, 0x99, 0x45, 0xE6, 0x85, 0xA6, 0x0B, 0x25, + 0xE8, 0xFB, 0xD9, 0x62, 0x5A, 0xB6, 0xB5, 0x99 + }, + { + 0x38, 0xC4, 0x10, 0xF5, 0xB9, 0xD4, 0x07, 0x20, + 0x50, 0x75, 0x5B, 0x31, 0xDC, 0xA8, 0x9F, 0xD5, + 0x39, 0x5C, 0x67, 0x85, 0xEE, 0xB3, 0xD7, 0x90, + 0xF3, 0x20, 0xFF, 0x94, 0x1C, 0x5A, 0x93, 0xBF + }, + { + 0xF1, 0x84, 0x17, 0xB3, 0x9D, 0x61, 0x7A, 0xB1, + 0xC1, 0x8F, 0xDF, 0x91, 0xEB, 0xD0, 0xFC, 0x6D, + 0x55, 0x16, 0xBB, 0x34, 0xCF, 0x39, 0x36, 0x40, + 0x37, 0xBC, 0xE8, 0x1F, 0xA0, 0x4C, 0xEC, 0xB1 + }, + { + 0x1F, 0xA8, 0x77, 0xDE, 0x67, 0x25, 0x9D, 0x19, + 0x86, 0x3A, 0x2A, 0x34, 0xBC, 0xC6, 0x96, 0x2A, + 0x2B, 0x25, 0xFC, 0xBF, 0x5C, 0xBE, 0xCD, 0x7E, + 0xDE, 0x8F, 0x1F, 0xA3, 0x66, 0x88, 0xA7, 0x96 + }, + { + 0x5B, 0xD1, 0x69, 0xE6, 0x7C, 0x82, 0xC2, 0xC2, + 0xE9, 0x8E, 0xF7, 0x00, 0x8B, 0xDF, 0x26, 0x1F, + 0x2D, 0xDF, 0x30, 0xB1, 0xC0, 0x0F, 0x9E, 0x7F, + 0x27, 0x5B, 0xB3, 0xE8, 0xA2, 0x8D, 0xC9, 0xA2 + }, + { + 0xC8, 0x0A, 0xBE, 0xEB, 0xB6, 0x69, 0xAD, 0x5D, + 0xEE, 0xB5, 0xF5, 0xEC, 0x8E, 0xA6, 0xB7, 0xA0, + 0x5D, 0xDF, 0x7D, 0x31, 0xEC, 0x4C, 0x0A, 0x2E, + 0xE2, 0x0B, 0x0B, 0x98, 0xCA, 0xEC, 0x67, 0x46 + }, + { + 0xE7, 0x6D, 0x3F, 0xBD, 0xA5, 0xBA, 0x37, 0x4E, + 0x6B, 0xF8, 0xE5, 0x0F, 0xAD, 0xC3, 0xBB, 0xB9, + 0xBA, 0x5C, 0x20, 0x6E, 0xBD, 0xEC, 0x89, 0xA3, + 0xA5, 0x4C, 0xF3, 0xDD, 0x84, 0xA0, 0x70, 0x16 + }, + { + 0x7B, 0xBA, 0x9D, 0xC5, 0xB5, 0xDB, 0x20, 0x71, + 0xD1, 0x77, 0x52, 0xB1, 0x04, 0x4C, 0x1E, 0xCE, + 0xD9, 0x6A, 0xAF, 0x2D, 0xD4, 0x6E, 0x9B, 0x43, + 0x37, 0x50, 0xE8, 0xEA, 0x0D, 0xCC, 0x18, 0x70 + }, + { + 0xF2, 0x9B, 0x1B, 0x1A, 0xB9, 0xBA, 0xB1, 0x63, + 0x01, 0x8E, 0xE3, 0xDA, 0x15, 0x23, 0x2C, 0xCA, + 0x78, 0xEC, 0x52, 0xDB, 0xC3, 0x4E, 0xDA, 0x5B, + 0x82, 0x2E, 0xC1, 0xD8, 0x0F, 0xC2, 0x1B, 0xD0 + }, + { + 0x9E, 0xE3, 0xE3, 0xE7, 0xE9, 0x00, 0xF1, 0xE1, + 0x1D, 0x30, 0x8C, 0x4B, 0x2B, 0x30, 0x76, 0xD2, + 0x72, 0xCF, 0x70, 0x12, 0x4F, 0x9F, 0x51, 0xE1, + 0xDA, 0x60, 0xF3, 0x78, 0x46, 0xCD, 0xD2, 0xF4 + }, + { + 0x70, 0xEA, 0x3B, 0x01, 0x76, 0x92, 0x7D, 0x90, + 0x96, 0xA1, 0x85, 0x08, 0xCD, 0x12, 0x3A, 0x29, + 0x03, 0x25, 0x92, 0x0A, 0x9D, 0x00, 0xA8, 0x9B, + 0x5D, 0xE0, 0x42, 0x73, 0xFB, 0xC7, 0x6B, 0x85 + }, + { + 0x67, 0xDE, 0x25, 0xC0, 0x2A, 0x4A, 0xAB, 0xA2, + 0x3B, 0xDC, 0x97, 0x3C, 0x8B, 0xB0, 0xB5, 0x79, + 0x6D, 0x47, 0xCC, 0x06, 0x59, 0xD4, 0x3D, 0xFF, + 0x1F, 0x97, 0xDE, 0x17, 0x49, 0x63, 0xB6, 0x8E + }, + { + 0xB2, 0x16, 0x8E, 0x4E, 0x0F, 0x18, 0xB0, 0xE6, + 0x41, 0x00, 0xB5, 0x17, 0xED, 0x95, 0x25, 0x7D, + 0x73, 0xF0, 0x62, 0x0D, 0xF8, 0x85, 0xC1, 0x3D, + 0x2E, 0xCF, 0x79, 0x36, 0x7B, 0x38, 0x4C, 0xEE + }, + { + 0x2E, 0x7D, 0xEC, 0x24, 0x28, 0x85, 0x3B, 0x2C, + 0x71, 0x76, 0x07, 0x45, 0x54, 0x1F, 0x7A, 0xFE, + 0x98, 0x25, 0xB5, 0xDD, 0x77, 0xDF, 0x06, 0x51, + 0x1D, 0x84, 0x41, 0xA9, 0x4B, 0xAC, 0xC9, 0x27 + }, + { + 0xCA, 0x9F, 0xFA, 0xC4, 0xC4, 0x3F, 0x0B, 0x48, + 0x46, 0x1D, 0xC5, 0xC2, 0x63, 0xBE, 0xA3, 0xF6, + 0xF0, 0x06, 0x11, 0xCE, 0xAC, 0xAB, 0xF6, 0xF8, + 0x95, 0xBA, 0x2B, 0x01, 0x01, 0xDB, 0xB6, 0x8D + }, + { + 0x74, 0x10, 0xD4, 0x2D, 0x8F, 0xD1, 0xD5, 0xE9, + 0xD2, 0xF5, 0x81, 0x5C, 0xB9, 0x34, 0x17, 0x99, + 0x88, 0x28, 0xEF, 0x3C, 0x42, 0x30, 0xBF, 0xBD, + 0x41, 0x2D, 0xF0, 0xA4, 0xA7, 0xA2, 0x50, 0x7A + }, + { + 0x50, 0x10, 0xF6, 0x84, 0x51, 0x6D, 0xCC, 0xD0, + 0xB6, 0xEE, 0x08, 0x52, 0xC2, 0x51, 0x2B, 0x4D, + 0xC0, 0x06, 0x6C, 0xF0, 0xD5, 0x6F, 0x35, 0x30, + 0x29, 0x78, 0xDB, 0x8A, 0xE3, 0x2C, 0x6A, 0x81 + }, + { + 0xAC, 0xAA, 0xB5, 0x85, 0xF7, 0xB7, 0x9B, 0x71, + 0x99, 0x35, 0xCE, 0xB8, 0x95, 0x23, 0xDD, 0xC5, + 0x48, 0x27, 0xF7, 0x5C, 0x56, 0x88, 0x38, 0x56, + 0x15, 0x4A, 0x56, 0xCD, 0xCD, 0x5E, 0xE9, 0x88 + }, + { + 0x66, 0x6D, 0xE5, 0xD1, 0x44, 0x0F, 0xEE, 0x73, + 0x31, 0xAA, 0xF0, 0x12, 0x3A, 0x62, 0xEF, 0x2D, + 0x8B, 0xA5, 0x74, 0x53, 0xA0, 0x76, 0x96, 0x35, + 0xAC, 0x6C, 0xD0, 0x1E, 0x63, 0x3F, 0x77, 0x12 + }, + { + 0xA6, 0xF9, 0x86, 0x58, 0xF6, 0xEA, 0xBA, 0xF9, + 0x02, 0xD8, 0xB3, 0x87, 0x1A, 0x4B, 0x10, 0x1D, + 0x16, 0x19, 0x6E, 0x8A, 0x4B, 0x24, 0x1E, 0x15, + 0x58, 0xFE, 0x29, 0x96, 0x6E, 0x10, 0x3E, 0x8D + }, + { + 0x89, 0x15, 0x46, 0xA8, 0xB2, 0x9F, 0x30, 0x47, + 0xDD, 0xCF, 0xE5, 0xB0, 0x0E, 0x45, 0xFD, 0x55, + 0x75, 0x63, 0x73, 0x10, 0x5E, 0xA8, 0x63, 0x7D, + 0xFC, 0xFF, 0x54, 0x7B, 0x6E, 0xA9, 0x53, 0x5F + }, + { + 0x18, 0xDF, 0xBC, 0x1A, 0xC5, 0xD2, 0x5B, 0x07, + 0x61, 0x13, 0x7D, 0xBD, 0x22, 0xC1, 0x7C, 0x82, + 0x9D, 0x0F, 0x0E, 0xF1, 0xD8, 0x23, 0x44, 0xE9, + 0xC8, 0x9C, 0x28, 0x66, 0x94, 0xDA, 0x24, 0xE8 + }, + { + 0xB5, 0x4B, 0x9B, 0x67, 0xF8, 0xFE, 0xD5, 0x4B, + 0xBF, 0x5A, 0x26, 0x66, 0xDB, 0xDF, 0x4B, 0x23, + 0xCF, 0xF1, 0xD1, 0xB6, 0xF4, 0xAF, 0xC9, 0x85, + 0xB2, 0xE6, 0xD3, 0x30, 0x5A, 0x9F, 0xF8, 0x0F + }, + { + 0x7D, 0xB4, 0x42, 0xE1, 0x32, 0xBA, 0x59, 0xBC, + 0x12, 0x89, 0xAA, 0x98, 0xB0, 0xD3, 0xE8, 0x06, + 0x00, 0x4F, 0x8E, 0xC1, 0x28, 0x11, 0xAF, 0x1E, + 0x2E, 0x33, 0xC6, 0x9B, 0xFD, 0xE7, 0x29, 0xE1 + }, + { + 0x25, 0x0F, 0x37, 0xCD, 0xC1, 0x5E, 0x81, 0x7D, + 0x2F, 0x16, 0x0D, 0x99, 0x56, 0xC7, 0x1F, 0xE3, + 0xEB, 0x5D, 0xB7, 0x45, 0x56, 0xE4, 0xAD, 0xF9, + 0xA4, 0xFF, 0xAF, 0xBA, 0x74, 0x01, 0x03, 0x96 + }, + { + 0x4A, 0xB8, 0xA3, 0xDD, 0x1D, 0xDF, 0x8A, 0xD4, + 0x3D, 0xAB, 0x13, 0xA2, 0x7F, 0x66, 0xA6, 0x54, + 0x4F, 0x29, 0x05, 0x97, 0xFA, 0x96, 0x04, 0x0E, + 0x0E, 0x1D, 0xB9, 0x26, 0x3A, 0xA4, 0x79, 0xF8 + }, + { + 0xEE, 0x61, 0x72, 0x7A, 0x07, 0x66, 0xDF, 0x93, + 0x9C, 0xCD, 0xC8, 0x60, 0x33, 0x40, 0x44, 0xC7, + 0x9A, 0x3C, 0x9B, 0x15, 0x62, 0x00, 0xBC, 0x3A, + 0xA3, 0x29, 0x73, 0x48, 0x3D, 0x83, 0x41, 0xAE + }, + { + 0x3F, 0x68, 0xC7, 0xEC, 0x63, 0xAC, 0x11, 0xEB, + 0xB9, 0x8F, 0x94, 0xB3, 0x39, 0xB0, 0x5C, 0x10, + 0x49, 0x84, 0xFD, 0xA5, 0x01, 0x03, 0x06, 0x01, + 0x44, 0xE5, 0xA2, 0xBF, 0xCC, 0xC9, 0xDA, 0x95 + }, + { + 0x05, 0x6F, 0x29, 0x81, 0x6B, 0x8A, 0xF8, 0xF5, + 0x66, 0x82, 0xBC, 0x4D, 0x7C, 0xF0, 0x94, 0x11, + 0x1D, 0xA7, 0x73, 0x3E, 0x72, 0x6C, 0xD1, 0x3D, + 0x6B, 0x3E, 0x8E, 0xA0, 0x3E, 0x92, 0xA0, 0xD5 + }, + { + 0xF5, 0xEC, 0x43, 0xA2, 0x8A, 0xCB, 0xEF, 0xF1, + 0xF3, 0x31, 0x8A, 0x5B, 0xCA, 0xC7, 0xC6, 0x6D, + 0xDB, 0x52, 0x30, 0xB7, 0x9D, 0xB2, 0xD1, 0x05, + 0xBC, 0xBE, 0x15, 0xF3, 0xC1, 0x14, 0x8D, 0x69 + }, + { + 0x2A, 0x69, 0x60, 0xAD, 0x1D, 0x8D, 0xD5, 0x47, + 0x55, 0x5C, 0xFB, 0xD5, 0xE4, 0x60, 0x0F, 0x1E, + 0xAA, 0x1C, 0x8E, 0xDA, 0x34, 0xDE, 0x03, 0x74, + 0xEC, 0x4A, 0x26, 0xEA, 0xAA, 0xA3, 0x3B, 0x4E + }, + { + 0xDC, 0xC1, 0xEA, 0x7B, 0xAA, 0xB9, 0x33, 0x84, + 0xF7, 0x6B, 0x79, 0x68, 0x66, 0x19, 0x97, 0x54, + 0x74, 0x2F, 0x7B, 0x96, 0xD6, 0xB4, 0xC1, 0x20, + 0x16, 0x5C, 0x04, 0xA6, 0xC4, 0xF5, 0xCE, 0x10 + }, + { + 0x13, 0xD5, 0xDF, 0x17, 0x92, 0x21, 0x37, 0x9C, + 0x6A, 0x78, 0xC0, 0x7C, 0x79, 0x3F, 0xF5, 0x34, + 0x87, 0xCA, 0xE6, 0xBF, 0x9F, 0xE8, 0x82, 0x54, + 0x1A, 0xB0, 0xE7, 0x35, 0xE3, 0xEA, 0xDA, 0x3B + }, + { + 0x8C, 0x59, 0xE4, 0x40, 0x76, 0x41, 0xA0, 0x1E, + 0x8F, 0xF9, 0x1F, 0x99, 0x80, 0xDC, 0x23, 0x6F, + 0x4E, 0xCD, 0x6F, 0xCF, 0x52, 0x58, 0x9A, 0x09, + 0x9A, 0x96, 0x16, 0x33, 0x96, 0x77, 0x14, 0xE1 + }, + { + 0x83, 0x3B, 0x1A, 0xC6, 0xA2, 0x51, 0xFD, 0x08, + 0xFD, 0x6D, 0x90, 0x8F, 0xEA, 0x2A, 0x4E, 0xE1, + 0xE0, 0x40, 0xBC, 0xA9, 0x3F, 0xC1, 0xA3, 0x8E, + 0xC3, 0x82, 0x0E, 0x0C, 0x10, 0xBD, 0x82, 0xEA + }, + { + 0xA2, 0x44, 0xF9, 0x27, 0xF3, 0xB4, 0x0B, 0x8F, + 0x6C, 0x39, 0x15, 0x70, 0xC7, 0x65, 0x41, 0x8F, + 0x2F, 0x6E, 0x70, 0x8E, 0xAC, 0x90, 0x06, 0xC5, + 0x1A, 0x7F, 0xEF, 0xF4, 0xAF, 0x3B, 0x2B, 0x9E + }, + { + 0x3D, 0x99, 0xED, 0x95, 0x50, 0xCF, 0x11, 0x96, + 0xE6, 0xC4, 0xD2, 0x0C, 0x25, 0x96, 0x20, 0xF8, + 0x58, 0xC3, 0xD7, 0x03, 0x37, 0x4C, 0x12, 0x8C, + 0xE7, 0xB5, 0x90, 0x31, 0x0C, 0x83, 0x04, 0x6D + }, + { + 0x2B, 0x35, 0xC4, 0x7D, 0x7B, 0x87, 0x76, 0x1F, + 0x0A, 0xE4, 0x3A, 0xC5, 0x6A, 0xC2, 0x7B, 0x9F, + 0x25, 0x83, 0x03, 0x67, 0xB5, 0x95, 0xBE, 0x8C, + 0x24, 0x0E, 0x94, 0x60, 0x0C, 0x6E, 0x33, 0x12 + }, + { + 0x5D, 0x11, 0xED, 0x37, 0xD2, 0x4D, 0xC7, 0x67, + 0x30, 0x5C, 0xB7, 0xE1, 0x46, 0x7D, 0x87, 0xC0, + 0x65, 0xAC, 0x4B, 0xC8, 0xA4, 0x26, 0xDE, 0x38, + 0x99, 0x1F, 0xF5, 0x9A, 0xA8, 0x73, 0x5D, 0x02 + }, + { + 0xB8, 0x36, 0x47, 0x8E, 0x1C, 0xA0, 0x64, 0x0D, + 0xCE, 0x6F, 0xD9, 0x10, 0xA5, 0x09, 0x62, 0x72, + 0xC8, 0x33, 0x09, 0x90, 0xCD, 0x97, 0x86, 0x4A, + 0xC2, 0xBF, 0x14, 0xEF, 0x6B, 0x23, 0x91, 0x4A + }, + { + 0x91, 0x00, 0xF9, 0x46, 0xD6, 0xCC, 0xDE, 0x3A, + 0x59, 0x7F, 0x90, 0xD3, 0x9F, 0xC1, 0x21, 0x5B, + 0xAD, 0xDC, 0x74, 0x13, 0x64, 0x3D, 0x85, 0xC2, + 0x1C, 0x3E, 0xEE, 0x5D, 0x2D, 0xD3, 0x28, 0x94 + }, + { + 0xDA, 0x70, 0xEE, 0xDD, 0x23, 0xE6, 0x63, 0xAA, + 0x1A, 0x74, 0xB9, 0x76, 0x69, 0x35, 0xB4, 0x79, + 0x22, 0x2A, 0x72, 0xAF, 0xBA, 0x5C, 0x79, 0x51, + 0x58, 0xDA, 0xD4, 0x1A, 0x3B, 0xD7, 0x7E, 0x40 + }, + { + 0xF0, 0x67, 0xED, 0x6A, 0x0D, 0xBD, 0x43, 0xAA, + 0x0A, 0x92, 0x54, 0xE6, 0x9F, 0xD6, 0x6B, 0xDD, + 0x8A, 0xCB, 0x87, 0xDE, 0x93, 0x6C, 0x25, 0x8C, + 0xFB, 0x02, 0x28, 0x5F, 0x2C, 0x11, 0xFA, 0x79 + }, + { + 0x71, 0x5C, 0x99, 0xC7, 0xD5, 0x75, 0x80, 0xCF, + 0x97, 0x53, 0xB4, 0xC1, 0xD7, 0x95, 0xE4, 0x5A, + 0x83, 0xFB, 0xB2, 0x28, 0xC0, 0xD3, 0x6F, 0xBE, + 0x20, 0xFA, 0xF3, 0x9B, 0xDD, 0x6D, 0x4E, 0x85 + }, + { + 0xE4, 0x57, 0xD6, 0xAD, 0x1E, 0x67, 0xCB, 0x9B, + 0xBD, 0x17, 0xCB, 0xD6, 0x98, 0xFA, 0x6D, 0x7D, + 0xAE, 0x0C, 0x9B, 0x7A, 0xD6, 0xCB, 0xD6, 0x53, + 0x96, 0x34, 0xE3, 0x2A, 0x71, 0x9C, 0x84, 0x92 + }, + { + 0xEC, 0xE3, 0xEA, 0x81, 0x03, 0xE0, 0x24, 0x83, + 0xC6, 0x4A, 0x70, 0xA4, 0xBD, 0xCE, 0xE8, 0xCE, + 0xB6, 0x27, 0x8F, 0x25, 0x33, 0xF3, 0xF4, 0x8D, + 0xBE, 0xED, 0xFB, 0xA9, 0x45, 0x31, 0xD4, 0xAE + }, + { + 0x38, 0x8A, 0xA5, 0xD3, 0x66, 0x7A, 0x97, 0xC6, + 0x8D, 0x3D, 0x56, 0xF8, 0xF3, 0xEE, 0x8D, 0x3D, + 0x36, 0x09, 0x1F, 0x17, 0xFE, 0x5D, 0x1B, 0x0D, + 0x5D, 0x84, 0xC9, 0x3B, 0x2F, 0xFE, 0x40, 0xBD + }, + { + 0x8B, 0x6B, 0x31, 0xB9, 0xAD, 0x7C, 0x3D, 0x5C, + 0xD8, 0x4B, 0xF9, 0x89, 0x47, 0xB9, 0xCD, 0xB5, + 0x9D, 0xF8, 0xA2, 0x5F, 0xF7, 0x38, 0x10, 0x10, + 0x13, 0xBE, 0x4F, 0xD6, 0x5E, 0x1D, 0xD1, 0xA3 + }, + { + 0x06, 0x62, 0x91, 0xF6, 0xBB, 0xD2, 0x5F, 0x3C, + 0x85, 0x3D, 0xB7, 0xD8, 0xB9, 0x5C, 0x9A, 0x1C, + 0xFB, 0x9B, 0xF1, 0xC1, 0xC9, 0x9F, 0xB9, 0x5A, + 0x9B, 0x78, 0x69, 0xD9, 0x0F, 0x1C, 0x29, 0x03 + }, + { + 0xA7, 0x07, 0xEF, 0xBC, 0xCD, 0xCE, 0xED, 0x42, + 0x96, 0x7A, 0x66, 0xF5, 0x53, 0x9B, 0x93, 0xED, + 0x75, 0x60, 0xD4, 0x67, 0x30, 0x40, 0x16, 0xC4, + 0x78, 0x0D, 0x77, 0x55, 0xA5, 0x65, 0xD4, 0xC4 + }, + { + 0x38, 0xC5, 0x3D, 0xFB, 0x70, 0xBE, 0x7E, 0x79, + 0x2B, 0x07, 0xA6, 0xA3, 0x5B, 0x8A, 0x6A, 0x0A, + 0xBA, 0x02, 0xC5, 0xC5, 0xF3, 0x8B, 0xAF, 0x5C, + 0x82, 0x3F, 0xDF, 0xD9, 0xE4, 0x2D, 0x65, 0x7E + }, + { + 0xF2, 0x91, 0x13, 0x86, 0x50, 0x1D, 0x9A, 0xB9, + 0xD7, 0x20, 0xCF, 0x8A, 0xD1, 0x05, 0x03, 0xD5, + 0x63, 0x4B, 0xF4, 0xB7, 0xD1, 0x2B, 0x56, 0xDF, + 0xB7, 0x4F, 0xEC, 0xC6, 0xE4, 0x09, 0x3F, 0x68 + }, + { + 0xC6, 0xF2, 0xBD, 0xD5, 0x2B, 0x81, 0xE6, 0xE4, + 0xF6, 0x59, 0x5A, 0xBD, 0x4D, 0x7F, 0xB3, 0x1F, + 0x65, 0x11, 0x69, 0xD0, 0x0F, 0xF3, 0x26, 0x92, + 0x6B, 0x34, 0x94, 0x7B, 0x28, 0xA8, 0x39, 0x59 + }, + { + 0x29, 0x3D, 0x94, 0xB1, 0x8C, 0x98, 0xBB, 0x32, + 0x23, 0x36, 0x6B, 0x8C, 0xE7, 0x4C, 0x28, 0xFB, + 0xDF, 0x28, 0xE1, 0xF8, 0x4A, 0x33, 0x50, 0xB0, + 0xEB, 0x2D, 0x18, 0x04, 0xA5, 0x77, 0x57, 0x9B + }, + { + 0x2C, 0x2F, 0xA5, 0xC0, 0xB5, 0x15, 0x33, 0x16, + 0x5B, 0xC3, 0x75, 0xC2, 0x2E, 0x27, 0x81, 0x76, + 0x82, 0x70, 0xA3, 0x83, 0x98, 0x5D, 0x13, 0xBD, + 0x6B, 0x67, 0xB6, 0xFD, 0x67, 0xF8, 0x89, 0xEB + }, + { + 0xCA, 0xA0, 0x9B, 0x82, 0xB7, 0x25, 0x62, 0xE4, + 0x3F, 0x4B, 0x22, 0x75, 0xC0, 0x91, 0x91, 0x8E, + 0x62, 0x4D, 0x91, 0x16, 0x61, 0xCC, 0x81, 0x1B, + 0xB5, 0xFA, 0xEC, 0x51, 0xF6, 0x08, 0x8E, 0xF7 + }, + { + 0x24, 0x76, 0x1E, 0x45, 0xE6, 0x74, 0x39, 0x53, + 0x79, 0xFB, 0x17, 0x72, 0x9C, 0x78, 0xCB, 0x93, + 0x9E, 0x6F, 0x74, 0xC5, 0xDF, 0xFB, 0x9C, 0x96, + 0x1F, 0x49, 0x59, 0x82, 0xC3, 0xED, 0x1F, 0xE3 + }, + { + 0x55, 0xB7, 0x0A, 0x82, 0x13, 0x1E, 0xC9, 0x48, + 0x88, 0xD7, 0xAB, 0x54, 0xA7, 0xC5, 0x15, 0x25, + 0x5C, 0x39, 0x38, 0xBB, 0x10, 0xBC, 0x78, 0x4D, + 0xC9, 0xB6, 0x7F, 0x07, 0x6E, 0x34, 0x1A, 0x73 + }, + { + 0x6A, 0xB9, 0x05, 0x7B, 0x97, 0x7E, 0xBC, 0x3C, + 0xA4, 0xD4, 0xCE, 0x74, 0x50, 0x6C, 0x25, 0xCC, + 0xCD, 0xC5, 0x66, 0x49, 0x7C, 0x45, 0x0B, 0x54, + 0x15, 0xA3, 0x94, 0x86, 0xF8, 0x65, 0x7A, 0x03 + }, + { + 0x24, 0x06, 0x6D, 0xEE, 0xE0, 0xEC, 0xEE, 0x15, + 0xA4, 0x5F, 0x0A, 0x32, 0x6D, 0x0F, 0x8D, 0xBC, + 0x79, 0x76, 0x1E, 0xBB, 0x93, 0xCF, 0x8C, 0x03, + 0x77, 0xAF, 0x44, 0x09, 0x78, 0xFC, 0xF9, 0x94 + }, + { + 0x20, 0x00, 0x0D, 0x3F, 0x66, 0xBA, 0x76, 0x86, + 0x0D, 0x5A, 0x95, 0x06, 0x88, 0xB9, 0xAA, 0x0D, + 0x76, 0xCF, 0xEA, 0x59, 0xB0, 0x05, 0xD8, 0x59, + 0x91, 0x4B, 0x1A, 0x46, 0x65, 0x3A, 0x93, 0x9B + }, + { + 0xB9, 0x2D, 0xAA, 0x79, 0x60, 0x3E, 0x3B, 0xDB, + 0xC3, 0xBF, 0xE0, 0xF4, 0x19, 0xE4, 0x09, 0xB2, + 0xEA, 0x10, 0xDC, 0x43, 0x5B, 0xEE, 0xFE, 0x29, + 0x59, 0xDA, 0x16, 0x89, 0x5D, 0x5D, 0xCA, 0x1C + }, + { + 0xE9, 0x47, 0x94, 0x87, 0x05, 0xB2, 0x06, 0xD5, + 0x72, 0xB0, 0xE8, 0xF6, 0x2F, 0x66, 0xA6, 0x55, + 0x1C, 0xBD, 0x6B, 0xC3, 0x05, 0xD2, 0x6C, 0xE7, + 0x53, 0x9A, 0x12, 0xF9, 0xAA, 0xDF, 0x75, 0x71 + }, + { + 0x3D, 0x67, 0xC1, 0xB3, 0xF9, 0xB2, 0x39, 0x10, + 0xE3, 0xD3, 0x5E, 0x6B, 0x0F, 0x2C, 0xCF, 0x44, + 0xA0, 0xB5, 0x40, 0xA4, 0x5C, 0x18, 0xBA, 0x3C, + 0x36, 0x26, 0x4D, 0xD4, 0x8E, 0x96, 0xAF, 0x6A + }, + { + 0xC7, 0x55, 0x8B, 0xAB, 0xDA, 0x04, 0xBC, 0xCB, + 0x76, 0x4D, 0x0B, 0xBF, 0x33, 0x58, 0x42, 0x51, + 0x41, 0x90, 0x2D, 0x22, 0x39, 0x1D, 0x9F, 0x8C, + 0x59, 0x15, 0x9F, 0xEC, 0x9E, 0x49, 0xB1, 0x51 + }, + { + 0x0B, 0x73, 0x2B, 0xB0, 0x35, 0x67, 0x5A, 0x50, + 0xFF, 0x58, 0xF2, 0xC2, 0x42, 0xE4, 0x71, 0x0A, + 0xEC, 0xE6, 0x46, 0x70, 0x07, 0x9C, 0x13, 0x04, + 0x4C, 0x79, 0xC9, 0xB7, 0x49, 0x1F, 0x70, 0x00 + }, + { + 0xD1, 0x20, 0xB5, 0xEF, 0x6D, 0x57, 0xEB, 0xF0, + 0x6E, 0xAF, 0x96, 0xBC, 0x93, 0x3C, 0x96, 0x7B, + 0x16, 0xCB, 0xE6, 0xE2, 0xBF, 0x00, 0x74, 0x1C, + 0x30, 0xAA, 0x1C, 0x54, 0xBA, 0x64, 0x80, 0x1F + }, + { + 0x58, 0xD2, 0x12, 0xAD, 0x6F, 0x58, 0xAE, 0xF0, + 0xF8, 0x01, 0x16, 0xB4, 0x41, 0xE5, 0x7F, 0x61, + 0x95, 0xBF, 0xEF, 0x26, 0xB6, 0x14, 0x63, 0xED, + 0xEC, 0x11, 0x83, 0xCD, 0xB0, 0x4F, 0xE7, 0x6D + }, + { + 0xB8, 0x83, 0x6F, 0x51, 0xD1, 0xE2, 0x9B, 0xDF, + 0xDB, 0xA3, 0x25, 0x56, 0x53, 0x60, 0x26, 0x8B, + 0x8F, 0xAD, 0x62, 0x74, 0x73, 0xED, 0xEC, 0xEF, + 0x7E, 0xAE, 0xFE, 0xE8, 0x37, 0xC7, 0x40, 0x03 + }, + { + 0xC5, 0x47, 0xA3, 0xC1, 0x24, 0xAE, 0x56, 0x85, + 0xFF, 0xA7, 0xB8, 0xED, 0xAF, 0x96, 0xEC, 0x86, + 0xF8, 0xB2, 0xD0, 0xD5, 0x0C, 0xEE, 0x8B, 0xE3, + 0xB1, 0xF0, 0xC7, 0x67, 0x63, 0x06, 0x9D, 0x9C + }, + { + 0x5D, 0x16, 0x8B, 0x76, 0x9A, 0x2F, 0x67, 0x85, + 0x3D, 0x62, 0x95, 0xF7, 0x56, 0x8B, 0xE4, 0x0B, + 0xB7, 0xA1, 0x6B, 0x8D, 0x65, 0xBA, 0x87, 0x63, + 0x5D, 0x19, 0x78, 0xD2, 0xAB, 0x11, 0xBA, 0x2A + }, + { + 0xA2, 0xF6, 0x75, 0xDC, 0x73, 0x02, 0x63, 0x8C, + 0xB6, 0x02, 0x01, 0x06, 0x4C, 0xA5, 0x50, 0x77, + 0x71, 0x4D, 0x71, 0xFE, 0x09, 0x6A, 0x31, 0x5F, + 0x2F, 0xE7, 0x40, 0x12, 0x77, 0xCA, 0xA5, 0xAF + }, + { + 0xC8, 0xAA, 0xB5, 0xCD, 0x01, 0x60, 0xAE, 0x78, + 0xCD, 0x2E, 0x8A, 0xC5, 0xFB, 0x0E, 0x09, 0x3C, + 0xDB, 0x5C, 0x4B, 0x60, 0x52, 0xA0, 0xA9, 0x7B, + 0xB0, 0x42, 0x16, 0x82, 0x6F, 0xA7, 0xA4, 0x37 + }, + { + 0xFF, 0x68, 0xCA, 0x40, 0x35, 0xBF, 0xEB, 0x43, + 0xFB, 0xF1, 0x45, 0xFD, 0xDD, 0x5E, 0x43, 0xF1, + 0xCE, 0xA5, 0x4F, 0x11, 0xF7, 0xBE, 0xE1, 0x30, + 0x58, 0xF0, 0x27, 0x32, 0x9A, 0x4A, 0x5F, 0xA4 + }, + { + 0x1D, 0x4E, 0x54, 0x87, 0xAE, 0x3C, 0x74, 0x0F, + 0x2B, 0xA6, 0xE5, 0x41, 0xAC, 0x91, 0xBC, 0x2B, + 0xFC, 0xD2, 0x99, 0x9C, 0x51, 0x8D, 0x80, 0x7B, + 0x42, 0x67, 0x48, 0x80, 0x3A, 0x35, 0x0F, 0xD4 + }, + { + 0x6D, 0x24, 0x4E, 0x1A, 0x06, 0xCE, 0x4E, 0xF5, + 0x78, 0xDD, 0x0F, 0x63, 0xAF, 0xF0, 0x93, 0x67, + 0x06, 0x73, 0x51, 0x19, 0xCA, 0x9C, 0x8D, 0x22, + 0xD8, 0x6C, 0x80, 0x14, 0x14, 0xAB, 0x97, 0x41 + }, + { + 0xDE, 0xCF, 0x73, 0x29, 0xDB, 0xCC, 0x82, 0x7B, + 0x8F, 0xC5, 0x24, 0xC9, 0x43, 0x1E, 0x89, 0x98, + 0x02, 0x9E, 0xCE, 0x12, 0xCE, 0x93, 0xB7, 0xB2, + 0xF3, 0xE7, 0x69, 0xA9, 0x41, 0xFB, 0x8C, 0xEA + }, + { + 0x2F, 0xAF, 0xCC, 0x0F, 0x2E, 0x63, 0xCB, 0xD0, + 0x77, 0x55, 0xBE, 0x7B, 0x75, 0xEC, 0xEA, 0x0A, + 0xDF, 0xF9, 0xAA, 0x5E, 0xDE, 0x2A, 0x52, 0xFD, + 0xAB, 0x4D, 0xFD, 0x03, 0x74, 0xCD, 0x48, 0x3F + }, + { + 0xAA, 0x85, 0x01, 0x0D, 0xD4, 0x6A, 0x54, 0x6B, + 0x53, 0x5E, 0xF4, 0xCF, 0x5F, 0x07, 0xD6, 0x51, + 0x61, 0xE8, 0x98, 0x28, 0xF3, 0xA7, 0x7D, 0xB7, + 0xB9, 0xB5, 0x6F, 0x0D, 0xF5, 0x9A, 0xAE, 0x45 + }, + { + 0x07, 0xE8, 0xE1, 0xEE, 0x73, 0x2C, 0xB0, 0xD3, + 0x56, 0xC9, 0xC0, 0xD1, 0x06, 0x9C, 0x89, 0xD1, + 0x7A, 0xDF, 0x6A, 0x9A, 0x33, 0x4F, 0x74, 0x5E, + 0xC7, 0x86, 0x73, 0x32, 0x54, 0x8C, 0xA8, 0xE9 + }, + { + 0x0E, 0x01, 0xE8, 0x1C, 0xAD, 0xA8, 0x16, 0x2B, + 0xFD, 0x5F, 0x8A, 0x8C, 0x81, 0x8A, 0x6C, 0x69, + 0xFE, 0xDF, 0x02, 0xCE, 0xB5, 0x20, 0x85, 0x23, + 0xCB, 0xE5, 0x31, 0x3B, 0x89, 0xCA, 0x10, 0x53 + }, + { + 0x6B, 0xB6, 0xC6, 0x47, 0x26, 0x55, 0x08, 0x43, + 0x99, 0x85, 0x2E, 0x00, 0x24, 0x9F, 0x8C, 0xB2, + 0x47, 0x89, 0x6D, 0x39, 0x2B, 0x02, 0xD7, 0x3B, + 0x7F, 0x0D, 0xD8, 0x18, 0xE1, 0xE2, 0x9B, 0x07 + }, + { + 0x42, 0xD4, 0x63, 0x6E, 0x20, 0x60, 0xF0, 0x8F, + 0x41, 0xC8, 0x82, 0xE7, 0x6B, 0x39, 0x6B, 0x11, + 0x2E, 0xF6, 0x27, 0xCC, 0x24, 0xC4, 0x3D, 0xD5, + 0xF8, 0x3A, 0x1D, 0x1A, 0x7E, 0xAD, 0x71, 0x1A + }, + { + 0x48, 0x58, 0xC9, 0xA1, 0x88, 0xB0, 0x23, 0x4F, + 0xB9, 0xA8, 0xD4, 0x7D, 0x0B, 0x41, 0x33, 0x65, + 0x0A, 0x03, 0x0B, 0xD0, 0x61, 0x1B, 0x87, 0xC3, + 0x89, 0x2E, 0x94, 0x95, 0x1F, 0x8D, 0xF8, 0x52 + }, + { + 0x3F, 0xAB, 0x3E, 0x36, 0x98, 0x8D, 0x44, 0x5A, + 0x51, 0xC8, 0x78, 0x3E, 0x53, 0x1B, 0xE3, 0xA0, + 0x2B, 0xE4, 0x0C, 0xD0, 0x47, 0x96, 0xCF, 0xB6, + 0x1D, 0x40, 0x34, 0x74, 0x42, 0xD3, 0xF7, 0x94 + }, + { + 0xEB, 0xAB, 0xC4, 0x96, 0x36, 0xBD, 0x43, 0x3D, + 0x2E, 0xC8, 0xF0, 0xE5, 0x18, 0x73, 0x2E, 0xF8, + 0xFA, 0x21, 0xD4, 0xD0, 0x71, 0xCC, 0x3B, 0xC4, + 0x6C, 0xD7, 0x9F, 0xA3, 0x8A, 0x28, 0xB8, 0x10 + }, + { + 0xA1, 0xD0, 0x34, 0x35, 0x23, 0xB8, 0x93, 0xFC, + 0xA8, 0x4F, 0x47, 0xFE, 0xB4, 0xA6, 0x4D, 0x35, + 0x0A, 0x17, 0xD8, 0xEE, 0xF5, 0x49, 0x7E, 0xCE, + 0x69, 0x7D, 0x02, 0xD7, 0x91, 0x78, 0xB5, 0x91 + }, + { + 0x26, 0x2E, 0xBF, 0xD9, 0x13, 0x0B, 0x7D, 0x28, + 0x76, 0x0D, 0x08, 0xEF, 0x8B, 0xFD, 0x3B, 0x86, + 0xCD, 0xD3, 0xB2, 0x11, 0x3D, 0x2C, 0xAE, 0xF7, + 0xEA, 0x95, 0x1A, 0x30, 0x3D, 0xFA, 0x38, 0x46 + }, + { + 0xF7, 0x61, 0x58, 0xED, 0xD5, 0x0A, 0x15, 0x4F, + 0xA7, 0x82, 0x03, 0xED, 0x23, 0x62, 0x93, 0x2F, + 0xCB, 0x82, 0x53, 0xAA, 0xE3, 0x78, 0x90, 0x3E, + 0xDE, 0xD1, 0xE0, 0x3F, 0x70, 0x21, 0xA2, 0x57 + }, + { + 0x26, 0x17, 0x8E, 0x95, 0x0A, 0xC7, 0x22, 0xF6, + 0x7A, 0xE5, 0x6E, 0x57, 0x1B, 0x28, 0x4C, 0x02, + 0x07, 0x68, 0x4A, 0x63, 0x34, 0xA1, 0x77, 0x48, + 0xA9, 0x4D, 0x26, 0x0B, 0xC5, 0xF5, 0x52, 0x74 + }, + { + 0xC3, 0x78, 0xD1, 0xE4, 0x93, 0xB4, 0x0E, 0xF1, + 0x1F, 0xE6, 0xA1, 0x5D, 0x9C, 0x27, 0x37, 0xA3, + 0x78, 0x09, 0x63, 0x4C, 0x5A, 0xBA, 0xD5, 0xB3, + 0x3D, 0x7E, 0x39, 0x3B, 0x4A, 0xE0, 0x5D, 0x03 + }, + { + 0x98, 0x4B, 0xD8, 0x37, 0x91, 0x01, 0xBE, 0x8F, + 0xD8, 0x06, 0x12, 0xD8, 0xEA, 0x29, 0x59, 0xA7, + 0x86, 0x5E, 0xC9, 0x71, 0x85, 0x23, 0x55, 0x01, + 0x07, 0xAE, 0x39, 0x38, 0xDF, 0x32, 0x01, 0x1B + }, + { + 0xC6, 0xF2, 0x5A, 0x81, 0x2A, 0x14, 0x48, 0x58, + 0xAC, 0x5C, 0xED, 0x37, 0xA9, 0x3A, 0x9F, 0x47, + 0x59, 0xBA, 0x0B, 0x1C, 0x0F, 0xDC, 0x43, 0x1D, + 0xCE, 0x35, 0xF9, 0xEC, 0x1F, 0x1F, 0x4A, 0x99 + }, + { + 0x92, 0x4C, 0x75, 0xC9, 0x44, 0x24, 0xFF, 0x75, + 0xE7, 0x4B, 0x8B, 0x4E, 0x94, 0x35, 0x89, 0x58, + 0xB0, 0x27, 0xB1, 0x71, 0xDF, 0x5E, 0x57, 0x89, + 0x9A, 0xD0, 0xD4, 0xDA, 0xC3, 0x73, 0x53, 0xB6 + }, + { + 0x0A, 0xF3, 0x58, 0x92, 0xA6, 0x3F, 0x45, 0x93, + 0x1F, 0x68, 0x46, 0xED, 0x19, 0x03, 0x61, 0xCD, + 0x07, 0x30, 0x89, 0xE0, 0x77, 0x16, 0x57, 0x14, + 0xB5, 0x0B, 0x81, 0xA2, 0xE3, 0xDD, 0x9B, 0xA1 + }, + { + 0xCC, 0x80, 0xCE, 0xFB, 0x26, 0xC3, 0xB2, 0xB0, + 0xDA, 0xEF, 0x23, 0x3E, 0x60, 0x6D, 0x5F, 0xFC, + 0x80, 0xFA, 0x17, 0x42, 0x7D, 0x18, 0xE3, 0x04, + 0x89, 0x67, 0x3E, 0x06, 0xEF, 0x4B, 0x87, 0xF7 + }, + { + 0xC2, 0xF8, 0xC8, 0x11, 0x74, 0x47, 0xF3, 0x97, + 0x8B, 0x08, 0x18, 0xDC, 0xF6, 0xF7, 0x01, 0x16, + 0xAC, 0x56, 0xFD, 0x18, 0x4D, 0xD1, 0x27, 0x84, + 0x94, 0xE1, 0x03, 0xFC, 0x6D, 0x74, 0xA8, 0x87 + }, + { + 0xBD, 0xEC, 0xF6, 0xBF, 0xC1, 0xBA, 0x0D, 0xF6, + 0xE8, 0x62, 0xC8, 0x31, 0x99, 0x22, 0x07, 0x79, + 0x6A, 0xCC, 0x79, 0x79, 0x68, 0x35, 0x88, 0x28, + 0xC0, 0x6E, 0x7A, 0x51, 0xE0, 0x90, 0x09, 0x8F + }, + { + 0x24, 0xD1, 0xA2, 0x6E, 0x3D, 0xAB, 0x02, 0xFE, + 0x45, 0x72, 0xD2, 0xAA, 0x7D, 0xBD, 0x3E, 0xC3, + 0x0F, 0x06, 0x93, 0xDB, 0x26, 0xF2, 0x73, 0xD0, + 0xAB, 0x2C, 0xB0, 0xC1, 0x3B, 0x5E, 0x64, 0x51 + }, + { + 0xEC, 0x56, 0xF5, 0x8B, 0x09, 0x29, 0x9A, 0x30, + 0x0B, 0x14, 0x05, 0x65, 0xD7, 0xD3, 0xE6, 0x87, + 0x82, 0xB6, 0xE2, 0xFB, 0xEB, 0x4B, 0x7E, 0xA9, + 0x7A, 0xC0, 0x57, 0x98, 0x90, 0x61, 0xDD, 0x3F + }, + { + 0x11, 0xA4, 0x37, 0xC1, 0xAB, 0xA3, 0xC1, 0x19, + 0xDD, 0xFA, 0xB3, 0x1B, 0x3E, 0x8C, 0x84, 0x1D, + 0xEE, 0xEB, 0x91, 0x3E, 0xF5, 0x7F, 0x7E, 0x48, + 0xF2, 0xC9, 0xCF, 0x5A, 0x28, 0xFA, 0x42, 0xBC + }, + { + 0x53, 0xC7, 0xE6, 0x11, 0x4B, 0x85, 0x0A, 0x2C, + 0xB4, 0x96, 0xC9, 0xB3, 0xC6, 0x9A, 0x62, 0x3E, + 0xAE, 0xA2, 0xCB, 0x1D, 0x33, 0xDD, 0x81, 0x7E, + 0x47, 0x65, 0xED, 0xAA, 0x68, 0x23, 0xC2, 0x28 + }, + { + 0x15, 0x4C, 0x3E, 0x96, 0xFE, 0xE5, 0xDB, 0x14, + 0xF8, 0x77, 0x3E, 0x18, 0xAF, 0x14, 0x85, 0x79, + 0x13, 0x50, 0x9D, 0xA9, 0x99, 0xB4, 0x6C, 0xDD, + 0x3D, 0x4C, 0x16, 0x97, 0x60, 0xC8, 0x3A, 0xD2 + }, + { + 0x40, 0xB9, 0x91, 0x6F, 0x09, 0x3E, 0x02, 0x7A, + 0x87, 0x86, 0x64, 0x18, 0x18, 0x92, 0x06, 0x20, + 0x47, 0x2F, 0xBC, 0xF6, 0x8F, 0x70, 0x1D, 0x1B, + 0x68, 0x06, 0x32, 0xE6, 0x99, 0x6B, 0xDE, 0xD3 + }, + { + 0x24, 0xC4, 0xCB, 0xBA, 0x07, 0x11, 0x98, 0x31, + 0xA7, 0x26, 0xB0, 0x53, 0x05, 0xD9, 0x6D, 0xA0, + 0x2F, 0xF8, 0xB1, 0x48, 0xF0, 0xDA, 0x44, 0x0F, + 0xE2, 0x33, 0xBC, 0xAA, 0x32, 0xC7, 0x2F, 0x6F + }, + { + 0x5D, 0x20, 0x15, 0x10, 0x25, 0x00, 0x20, 0xB7, + 0x83, 0x68, 0x96, 0x88, 0xAB, 0xBF, 0x8E, 0xCF, + 0x25, 0x94, 0xA9, 0x6A, 0x08, 0xF2, 0xBF, 0xEC, + 0x6C, 0xE0, 0x57, 0x44, 0x65, 0xDD, 0xED, 0x71 + }, + { + 0x04, 0x3B, 0x97, 0xE3, 0x36, 0xEE, 0x6F, 0xDB, + 0xBE, 0x2B, 0x50, 0xF2, 0x2A, 0xF8, 0x32, 0x75, + 0xA4, 0x08, 0x48, 0x05, 0xD2, 0xD5, 0x64, 0x59, + 0x62, 0x45, 0x4B, 0x6C, 0x9B, 0x80, 0x53, 0xA0 + }, + { + 0x56, 0x48, 0x35, 0xCB, 0xAE, 0xA7, 0x74, 0x94, + 0x85, 0x68, 0xBE, 0x36, 0xCF, 0x52, 0xFC, 0xDD, + 0x83, 0x93, 0x4E, 0xB0, 0xA2, 0x75, 0x12, 0xDB, + 0xE3, 0xE2, 0xDB, 0x47, 0xB9, 0xE6, 0x63, 0x5A + }, + { + 0xF2, 0x1C, 0x33, 0xF4, 0x7B, 0xDE, 0x40, 0xA2, + 0xA1, 0x01, 0xC9, 0xCD, 0xE8, 0x02, 0x7A, 0xAF, + 0x61, 0xA3, 0x13, 0x7D, 0xE2, 0x42, 0x2B, 0x30, + 0x03, 0x5A, 0x04, 0xC2, 0x70, 0x89, 0x41, 0x83 + }, + { + 0x9D, 0xB0, 0xEF, 0x74, 0xE6, 0x6C, 0xBB, 0x84, + 0x2E, 0xB0, 0xE0, 0x73, 0x43, 0xA0, 0x3C, 0x5C, + 0x56, 0x7E, 0x37, 0x2B, 0x3F, 0x23, 0xB9, 0x43, + 0xC7, 0x88, 0xA4, 0xF2, 0x50, 0xF6, 0x78, 0x91 + }, + { + 0xAB, 0x8D, 0x08, 0x65, 0x5F, 0xF1, 0xD3, 0xFE, + 0x87, 0x58, 0xD5, 0x62, 0x23, 0x5F, 0xD2, 0x3E, + 0x7C, 0xF9, 0xDC, 0xAA, 0xD6, 0x58, 0x87, 0x2A, + 0x49, 0xE5, 0xD3, 0x18, 0x3B, 0x6C, 0xCE, 0xBD + }, + { + 0x6F, 0x27, 0xF7, 0x7E, 0x7B, 0xCF, 0x46, 0xA1, + 0xE9, 0x63, 0xAD, 0xE0, 0x30, 0x97, 0x33, 0x54, + 0x30, 0x31, 0xDC, 0xCD, 0xD4, 0x7C, 0xAA, 0xC1, + 0x74, 0xD7, 0xD2, 0x7C, 0xE8, 0x07, 0x7E, 0x8B + }, + { + 0xE3, 0xCD, 0x54, 0xDA, 0x7E, 0x44, 0x4C, 0xAA, + 0x62, 0x07, 0x56, 0x95, 0x25, 0xA6, 0x70, 0xEB, + 0xAE, 0x12, 0x78, 0xDE, 0x4E, 0x3F, 0xE2, 0x68, + 0x4B, 0x3E, 0x33, 0xF5, 0xEF, 0x90, 0xCC, 0x1B + }, + { + 0xB2, 0xC3, 0xE3, 0x3A, 0x51, 0xD2, 0x2C, 0x4C, + 0x08, 0xFC, 0x09, 0x89, 0xC8, 0x73, 0xC9, 0xCC, + 0x41, 0x50, 0x57, 0x9B, 0x1E, 0x61, 0x63, 0xFA, + 0x69, 0x4A, 0xD5, 0x1D, 0x53, 0xD7, 0x12, 0xDC + }, + { + 0xBE, 0x7F, 0xDA, 0x98, 0x3E, 0x13, 0x18, 0x9B, + 0x4C, 0x77, 0xE0, 0xA8, 0x09, 0x20, 0xB6, 0xE0, + 0xE0, 0xEA, 0x80, 0xC3, 0xB8, 0x4D, 0xBE, 0x7E, + 0x71, 0x17, 0xD2, 0x53, 0xF4, 0x81, 0x12, 0xF4 + }, + { + 0xB6, 0x00, 0x8C, 0x28, 0xFA, 0xE0, 0x8A, 0xA4, + 0x27, 0xE5, 0xBD, 0x3A, 0xAD, 0x36, 0xF1, 0x00, + 0x21, 0xF1, 0x6C, 0x77, 0xCF, 0xEA, 0xBE, 0xD0, + 0x7F, 0x97, 0xCC, 0x7D, 0xC1, 0xF1, 0x28, 0x4A + }, + { + 0x6E, 0x4E, 0x67, 0x60, 0xC5, 0x38, 0xF2, 0xE9, + 0x7B, 0x3A, 0xDB, 0xFB, 0xBC, 0xDE, 0x57, 0xF8, + 0x96, 0x6B, 0x7E, 0xA8, 0xFC, 0xB5, 0xBF, 0x7E, + 0xFE, 0xC9, 0x13, 0xFD, 0x2A, 0x2B, 0x0C, 0x55 + }, + { + 0x4A, 0xE5, 0x1F, 0xD1, 0x83, 0x4A, 0xA5, 0xBD, + 0x9A, 0x6F, 0x7E, 0xC3, 0x9F, 0xC6, 0x63, 0x33, + 0x8D, 0xC5, 0xD2, 0xE2, 0x07, 0x61, 0x56, 0x6D, + 0x90, 0xCC, 0x68, 0xB1, 0xCB, 0x87, 0x5E, 0xD8 + }, + { + 0xB6, 0x73, 0xAA, 0xD7, 0x5A, 0xB1, 0xFD, 0xB5, + 0x40, 0x1A, 0xBF, 0xA1, 0xBF, 0x89, 0xF3, 0xAD, + 0xD2, 0xEB, 0xC4, 0x68, 0xDF, 0x36, 0x24, 0xA4, + 0x78, 0xF4, 0xFE, 0x85, 0x9D, 0x8D, 0x55, 0xE2 + }, + { + 0x13, 0xC9, 0x47, 0x1A, 0x98, 0x55, 0x91, 0x35, + 0x39, 0x83, 0x66, 0x60, 0x39, 0x8D, 0xA0, 0xF3, + 0xF9, 0x9A, 0xDA, 0x08, 0x47, 0x9C, 0x69, 0xD1, + 0xB7, 0xFC, 0xAA, 0x34, 0x61, 0xDD, 0x7E, 0x59 + }, + { + 0x2C, 0x11, 0xF4, 0xA7, 0xF9, 0x9A, 0x1D, 0x23, + 0xA5, 0x8B, 0xB6, 0x36, 0x35, 0x0F, 0xE8, 0x49, + 0xF2, 0x9C, 0xBA, 0xC1, 0xB2, 0xA1, 0x11, 0x2D, + 0x9F, 0x1E, 0xD5, 0xBC, 0x5B, 0x31, 0x3C, 0xCD + }, + { + 0xC7, 0xD3, 0xC0, 0x70, 0x6B, 0x11, 0xAE, 0x74, + 0x1C, 0x05, 0xA1, 0xEF, 0x15, 0x0D, 0xD6, 0x5B, + 0x54, 0x94, 0xD6, 0xD5, 0x4C, 0x9A, 0x86, 0xE2, + 0x61, 0x78, 0x54, 0xE6, 0xAE, 0xEE, 0xBB, 0xD9 + }, + { + 0x19, 0x4E, 0x10, 0xC9, 0x38, 0x93, 0xAF, 0xA0, + 0x64, 0xC3, 0xAC, 0x04, 0xC0, 0xDD, 0x80, 0x8D, + 0x79, 0x1C, 0x3D, 0x4B, 0x75, 0x56, 0xE8, 0x9D, + 0x8D, 0x9C, 0xB2, 0x25, 0xC4, 0xB3, 0x33, 0x39 + }, + { + 0x6F, 0xC4, 0x98, 0x8B, 0x8F, 0x78, 0x54, 0x6B, + 0x16, 0x88, 0x99, 0x18, 0x45, 0x90, 0x8F, 0x13, + 0x4B, 0x6A, 0x48, 0x2E, 0x69, 0x94, 0xB3, 0xD4, + 0x83, 0x17, 0xBF, 0x08, 0xDB, 0x29, 0x21, 0x85 + }, + { + 0x56, 0x65, 0xBE, 0xB8, 0xB0, 0x95, 0x55, 0x25, + 0x81, 0x3B, 0x59, 0x81, 0xCD, 0x14, 0x2E, 0xD4, + 0xD0, 0x3F, 0xBA, 0x38, 0xA6, 0xF3, 0xE5, 0xAD, + 0x26, 0x8E, 0x0C, 0xC2, 0x70, 0xD1, 0xCD, 0x11 + }, + { + 0xB8, 0x83, 0xD6, 0x8F, 0x5F, 0xE5, 0x19, 0x36, + 0x43, 0x1B, 0xA4, 0x25, 0x67, 0x38, 0x05, 0x3B, + 0x1D, 0x04, 0x26, 0xD4, 0xCB, 0x64, 0xB1, 0x6E, + 0x83, 0xBA, 0xDC, 0x5E, 0x9F, 0xBE, 0x3B, 0x81 + }, + { + 0x53, 0xE7, 0xB2, 0x7E, 0xA5, 0x9C, 0x2F, 0x6D, + 0xBB, 0x50, 0x76, 0x9E, 0x43, 0x55, 0x4D, 0xF3, + 0x5A, 0xF8, 0x9F, 0x48, 0x22, 0xD0, 0x46, 0x6B, + 0x00, 0x7D, 0xD6, 0xF6, 0xDE, 0xAF, 0xFF, 0x02 + }, + { + 0x1F, 0x1A, 0x02, 0x29, 0xD4, 0x64, 0x0F, 0x01, + 0x90, 0x15, 0x88, 0xD9, 0xDE, 0xC2, 0x2D, 0x13, + 0xFC, 0x3E, 0xB3, 0x4A, 0x61, 0xB3, 0x29, 0x38, + 0xEF, 0xBF, 0x53, 0x34, 0xB2, 0x80, 0x0A, 0xFA + }, + { + 0xC2, 0xB4, 0x05, 0xAF, 0xA0, 0xFA, 0x66, 0x68, + 0x85, 0x2A, 0xEE, 0x4D, 0x88, 0x04, 0x08, 0x53, + 0xFA, 0xB8, 0x00, 0xE7, 0x2B, 0x57, 0x58, 0x14, + 0x18, 0xE5, 0x50, 0x6F, 0x21, 0x4C, 0x7D, 0x1F + }, + { + 0xC0, 0x8A, 0xA1, 0xC2, 0x86, 0xD7, 0x09, 0xFD, + 0xC7, 0x47, 0x37, 0x44, 0x97, 0x71, 0x88, 0xC8, + 0x95, 0xBA, 0x01, 0x10, 0x14, 0x24, 0x7E, 0x4E, + 0xFA, 0x8D, 0x07, 0xE7, 0x8F, 0xEC, 0x69, 0x5C + }, + { + 0xF0, 0x3F, 0x57, 0x89, 0xD3, 0x33, 0x6B, 0x80, + 0xD0, 0x02, 0xD5, 0x9F, 0xDF, 0x91, 0x8B, 0xDB, + 0x77, 0x5B, 0x00, 0x95, 0x6E, 0xD5, 0x52, 0x8E, + 0x86, 0xAA, 0x99, 0x4A, 0xCB, 0x38, 0xFE, 0x2D + }, + { + 0x5F, 0xDE, 0xB5, 0x9F, 0x68, 0x1D, 0x97, 0x5F, + 0x52, 0xC8, 0xE6, 0x9C, 0x55, 0x02, 0xE0, 0x2A, + 0x12, 0xA3, 0xAF, 0xCC, 0x58, 0x36, 0xBA, 0x58, + 0xF4, 0x27, 0x84, 0xC4, 0x39, 0x22, 0x87, 0x81 + }, + { + 0x77, 0x95, 0xEC, 0xF7, 0x43, 0x55, 0xF1, 0xBD, + 0xC9, 0xEE, 0x58, 0x18, 0xC3, 0x57, 0x08, 0x1B, + 0x6A, 0x51, 0xB8, 0xDD, 0x80, 0x1B, 0xE3, 0x5B, + 0x1A, 0x87, 0x23, 0x91, 0x01, 0x4E, 0xDE, 0xAE + }, + { + 0x4C, 0xB0, 0x83, 0xAE, 0xFE, 0xFA, 0xC4, 0x10, + 0xEB, 0xE5, 0xAD, 0x4A, 0xF0, 0xFC, 0x32, 0xBC, + 0x26, 0xEA, 0x85, 0x00, 0x46, 0x61, 0xFF, 0xDC, + 0xFB, 0xFC, 0xD9, 0x9A, 0x59, 0x40, 0xED, 0xF8 + }, + { + 0xE7, 0xC5, 0xEE, 0x78, 0xC0, 0xCA, 0xF4, 0x7C, + 0xA9, 0x6B, 0x30, 0x2B, 0x51, 0xD4, 0x9C, 0x54, + 0x51, 0xA3, 0x27, 0x18, 0x84, 0xC9, 0xF0, 0x38, + 0x2A, 0x18, 0xEB, 0x2D, 0xAE, 0x01, 0xE4, 0x4E + }, + { + 0x6B, 0x67, 0x48, 0xFD, 0xA0, 0x43, 0x92, 0x6A, + 0x5E, 0xDB, 0xB8, 0x33, 0x84, 0x5F, 0xE5, 0xC8, + 0xD9, 0xAB, 0xEB, 0xE0, 0xE2, 0x87, 0x10, 0x86, + 0x98, 0xE8, 0xC8, 0xE4, 0xC5, 0x9A, 0x36, 0x31 + }, + { + 0x11, 0x37, 0x07, 0x70, 0xA6, 0x52, 0x20, 0x82, + 0xAF, 0x68, 0x9B, 0x1F, 0xBA, 0x14, 0x9C, 0x81, + 0xFD, 0x5A, 0x16, 0x87, 0x8F, 0x89, 0x58, 0x13, + 0x54, 0x74, 0x39, 0x7F, 0x72, 0x61, 0x74, 0x51 + }, + { + 0x98, 0xC9, 0x46, 0xCB, 0xE2, 0xD8, 0x9B, 0x09, + 0x29, 0x80, 0x16, 0x73, 0x61, 0xD0, 0x64, 0xD0, + 0x62, 0xE4, 0xA0, 0xF4, 0x8C, 0x0A, 0x49, 0x60, + 0xB6, 0xAC, 0xD6, 0x91, 0x4C, 0x0D, 0x10, 0x03 + }, + { + 0xC2, 0x98, 0xF7, 0x56, 0x66, 0xCD, 0x64, 0x42, + 0x3C, 0x8C, 0x95, 0x7C, 0x5B, 0xA3, 0x3A, 0x5D, + 0x65, 0xBB, 0xD9, 0x9F, 0x2F, 0x0A, 0x6F, 0x40, + 0xC0, 0xD8, 0x85, 0x73, 0xFC, 0xFB, 0x3F, 0xCC + }, + { + 0xAF, 0xB9, 0x4B, 0x50, 0x4E, 0x3C, 0x32, 0x96, + 0xD5, 0xCC, 0xC4, 0x44, 0x76, 0xF2, 0x94, 0xBD, + 0xD3, 0x82, 0xFC, 0x2D, 0xBE, 0x04, 0x91, 0x2F, + 0x2F, 0x90, 0x62, 0x32, 0x4F, 0xA1, 0x7C, 0x56 + }, + { + 0xD5, 0xA7, 0x88, 0x78, 0x0C, 0x52, 0x99, 0x4B, + 0xC1, 0xBC, 0xA6, 0xF7, 0x5D, 0xD3, 0x7F, 0x8B, + 0xC7, 0x11, 0x57, 0xD3, 0x43, 0xEC, 0x90, 0xF6, + 0x6E, 0x08, 0x33, 0xC7, 0x04, 0x87, 0x7B, 0x0C + }, + { + 0x10, 0x5E, 0x4E, 0xD3, 0x17, 0xCF, 0xEF, 0x4E, + 0x40, 0xA2, 0xFD, 0xC4, 0x7D, 0x65, 0x30, 0x79, + 0xBF, 0xC4, 0x7B, 0xCE, 0x8C, 0x80, 0x1B, 0x56, + 0x2A, 0x24, 0x09, 0xE5, 0xDA, 0x9D, 0x15, 0xA4 + }, + { + 0x0A, 0x1D, 0xEB, 0xFB, 0x25, 0xB8, 0x85, 0x11, + 0xEC, 0xE6, 0xC1, 0x65, 0xFE, 0x70, 0xFE, 0x28, + 0x5E, 0xA3, 0xDA, 0x1A, 0x8B, 0xC5, 0x1C, 0x73, + 0xB6, 0xE6, 0x3A, 0xE0, 0xFE, 0xEF, 0xE8, 0xE3 + }, + { + 0x72, 0xE7, 0x4B, 0x89, 0x23, 0x5B, 0xE1, 0x31, + 0xC9, 0xC5, 0xB5, 0xF8, 0x39, 0x61, 0xD8, 0x1F, + 0x79, 0x07, 0xCC, 0x62, 0x6B, 0x80, 0x4D, 0x8D, + 0xB3, 0xF4, 0x2C, 0x3F, 0x52, 0xC8, 0x24, 0xF7 + }, + { + 0x2B, 0xA5, 0xED, 0x64, 0xBA, 0xB4, 0xA3, 0xEA, + 0x8D, 0x20, 0x1E, 0x5E, 0x04, 0x89, 0xC1, 0x51, + 0x42, 0xF9, 0xF5, 0x85, 0xE5, 0x08, 0xB0, 0x66, + 0x06, 0xC9, 0x57, 0x37, 0x77, 0x86, 0x08, 0x5F + }, + { + 0xAA, 0xDB, 0xDD, 0xE7, 0x03, 0x06, 0x60, 0xE7, + 0x1D, 0x6D, 0x1A, 0xDB, 0x72, 0x6A, 0x25, 0x6F, + 0x27, 0xC6, 0x1B, 0x23, 0x6B, 0x94, 0x3F, 0xC6, + 0xF5, 0x0F, 0x97, 0x27, 0x5D, 0xF4, 0x5B, 0xFC + }, + { + 0x73, 0x45, 0x11, 0xDB, 0x87, 0x3E, 0x04, 0x9D, + 0x5A, 0x5F, 0x9E, 0xB0, 0x4E, 0x41, 0x78, 0x6D, + 0x32, 0xBF, 0x2F, 0x23, 0x78, 0xBB, 0xFF, 0x91, + 0x97, 0xD3, 0xA9, 0xAF, 0xD9, 0x7C, 0xD7, 0xA1 + }, + { + 0x24, 0x9E, 0xF0, 0xCD, 0xC0, 0x23, 0xFD, 0x6E, + 0xAE, 0xD9, 0xA3, 0x2C, 0x4F, 0x6A, 0xA6, 0x20, + 0xE9, 0x6C, 0x1A, 0xA0, 0xA0, 0x3D, 0xAE, 0xB5, + 0x30, 0x96, 0x9B, 0xBA, 0x56, 0xE8, 0xCA, 0x50 + }, + { + 0xAD, 0xFE, 0x52, 0x44, 0x74, 0xC2, 0x55, 0x0E, + 0x89, 0x85, 0x5E, 0xE7, 0x03, 0x24, 0x8C, 0xFF, + 0x1E, 0x56, 0xAE, 0x95, 0x54, 0xAA, 0xF9, 0x80, + 0x7C, 0x24, 0x34, 0xB7, 0x4C, 0xD9, 0xE3, 0x3C + }, + { + 0x91, 0x9E, 0x98, 0xD6, 0x1E, 0x9B, 0x62, 0x99, + 0x05, 0x04, 0x55, 0x32, 0x77, 0x8C, 0x2D, 0xF9, + 0x23, 0x2A, 0xA3, 0x59, 0xA9, 0x89, 0x46, 0x5A, + 0x6A, 0x76, 0xD5, 0xFD, 0xA1, 0xE4, 0xE9, 0x5C + }, + { + 0xA0, 0xA3, 0xAC, 0xB4, 0xDB, 0x21, 0x46, 0x27, + 0xB4, 0x91, 0xF7, 0xD3, 0x54, 0xDA, 0xD8, 0xEB, + 0xE3, 0x5A, 0xB9, 0xB8, 0x6F, 0x33, 0xA2, 0xFA, + 0x41, 0x22, 0xDB, 0x31, 0xD6, 0x1B, 0x86, 0x5D + }, + { + 0xC0, 0x4E, 0x2F, 0x3F, 0xC0, 0xFA, 0xA6, 0x1D, + 0x9D, 0xCC, 0x56, 0xDC, 0xA8, 0x49, 0xC8, 0xDE, + 0x8D, 0xEB, 0x38, 0x9F, 0xB1, 0x55, 0x8C, 0xA2, + 0x29, 0xA9, 0xF1, 0x41, 0x16, 0xBE, 0xE7, 0xE6 + }, + { + 0x3A, 0x8B, 0x96, 0xEB, 0xA5, 0x73, 0xA9, 0x8B, + 0xBD, 0x0F, 0x90, 0x91, 0x89, 0x84, 0x56, 0x79, + 0xE7, 0x21, 0xBC, 0x70, 0x69, 0x4F, 0xF6, 0x8B, + 0xA9, 0xD9, 0x23, 0xCF, 0xD6, 0xFB, 0x32, 0xB0 + }, + { + 0xB5, 0x9A, 0xF9, 0xCA, 0xAB, 0x02, 0x7E, 0x91, + 0x94, 0xDB, 0xC3, 0xEB, 0x65, 0x2E, 0x85, 0x49, + 0x08, 0xBF, 0x94, 0x1D, 0xE1, 0x7B, 0x7D, 0x0D, + 0x6D, 0x6B, 0x43, 0x2E, 0xCD, 0xCD, 0xDF, 0x72 + }, + { + 0x65, 0xCA, 0x91, 0xBC, 0x52, 0x16, 0x24, 0xB9, + 0x12, 0x3C, 0xE4, 0xC5, 0xA9, 0x4C, 0xB9, 0x4B, + 0x47, 0xE6, 0x84, 0xA8, 0x72, 0xC8, 0x07, 0xD5, + 0x21, 0x87, 0x0E, 0xC9, 0x52, 0xEF, 0xFD, 0x62 + }, + { + 0x09, 0xE2, 0x9B, 0xBE, 0xFE, 0xA4, 0xB7, 0xD7, + 0xDE, 0xB8, 0x66, 0xB1, 0xCD, 0xC3, 0x76, 0x91, + 0x6B, 0x01, 0xD4, 0xE7, 0xBA, 0x04, 0x3E, 0x45, + 0x5A, 0x12, 0xA8, 0x19, 0x4A, 0x50, 0x74, 0xA9 + }, + { + 0x96, 0xB2, 0xBE, 0x32, 0x61, 0x25, 0x87, 0x1C, + 0xCA, 0x79, 0x25, 0xE3, 0xEF, 0x80, 0xAE, 0xE4, + 0xCB, 0xAC, 0x94, 0xCD, 0x0E, 0x5C, 0x92, 0x46, + 0x3D, 0x3E, 0x29, 0xB9, 0xA5, 0x26, 0x85, 0x36 + }, + { + 0x62, 0xEE, 0x1A, 0xB4, 0x36, 0x34, 0x9C, 0x17, + 0xBA, 0x6C, 0xF6, 0xE9, 0x9E, 0x41, 0x32, 0x6A, + 0x7E, 0x64, 0xF1, 0x88, 0x8F, 0xBE, 0x39, 0x27, + 0xB6, 0xC7, 0x33, 0x65, 0x92, 0x5C, 0x1F, 0xFD + }, + { + 0xBD, 0xC8, 0xC6, 0xFA, 0xF2, 0xBA, 0x51, 0x77, + 0xB2, 0x9D, 0x19, 0x41, 0x43, 0x69, 0x1B, 0x6B, + 0xAA, 0x04, 0xD3, 0x22, 0x17, 0xBA, 0x96, 0x43, + 0x21, 0xBF, 0xFE, 0x57, 0x29, 0xC9, 0x15, 0x43 + }, + { + 0x8C, 0xCF, 0x02, 0xDB, 0x79, 0x24, 0x7B, 0xEA, + 0xF5, 0xC6, 0x1E, 0x4B, 0x45, 0x60, 0x3E, 0xD0, + 0xB0, 0x27, 0x5A, 0x5A, 0xD6, 0xA5, 0x55, 0x87, + 0x64, 0x61, 0x71, 0x4E, 0x8F, 0xF1, 0x11, 0xA9 + }, + { + 0xAD, 0xF9, 0xFF, 0x25, 0x51, 0xEE, 0x3D, 0x9D, + 0x76, 0xD5, 0xDF, 0xD6, 0xC3, 0xBD, 0xA1, 0x22, + 0x14, 0xD9, 0xE0, 0xF0, 0xD9, 0x8C, 0xFC, 0x41, + 0x9B, 0xA9, 0x39, 0x07, 0x25, 0x78, 0x51, 0xD7 + }, + { + 0x4B, 0x48, 0x8D, 0x6F, 0xB0, 0x0C, 0x0D, 0xD2, + 0x24, 0x0B, 0x35, 0x75, 0xE0, 0xFA, 0xAC, 0x87, + 0x94, 0x09, 0xBD, 0xF2, 0xB3, 0x97, 0x00, 0xAE, + 0x39, 0x85, 0x0F, 0x4E, 0xF9, 0x19, 0x56, 0x76 + }, + { + 0xA0, 0x4D, 0xC7, 0x16, 0x2E, 0xC9, 0x86, 0x1A, + 0xB6, 0x8E, 0x22, 0x9C, 0x69, 0x91, 0x5D, 0x8D, + 0xA1, 0x7C, 0xFE, 0x46, 0x90, 0xA6, 0x99, 0xDB, + 0x70, 0x75, 0x6E, 0x5D, 0x88, 0x9C, 0x4C, 0xC1 + }, + { + 0xDB, 0x76, 0xE4, 0x16, 0xC9, 0x1D, 0x72, 0xED, + 0x9E, 0x59, 0x69, 0x2B, 0xE0, 0x1E, 0xE2, 0xFD, + 0xA9, 0x17, 0x06, 0xDD, 0x20, 0x54, 0xF1, 0xFE, + 0x5C, 0x9D, 0xC8, 0x2F, 0x1F, 0x0C, 0xD4, 0x47 + }, + { + 0x80, 0x4A, 0xB1, 0xB0, 0xA7, 0xF4, 0xBF, 0xC0, + 0x15, 0x43, 0x19, 0x68, 0xC9, 0xA6, 0xE1, 0x80, + 0xE9, 0x82, 0xE2, 0x8D, 0xA9, 0x7D, 0x5E, 0x4C, + 0x34, 0x38, 0xD6, 0x1D, 0x19, 0x8D, 0x5B, 0xA7 + }, + { + 0x07, 0x48, 0xA5, 0xA7, 0x78, 0x54, 0x20, 0x73, + 0x9B, 0x59, 0xBB, 0xB4, 0x00, 0x80, 0x23, 0x6F, + 0x1B, 0x67, 0xE3, 0x15, 0x34, 0x2E, 0x89, 0x5A, + 0x4C, 0xD5, 0xF3, 0x92, 0x8B, 0x2F, 0x4D, 0x72 + }, + { + 0xF1, 0x1D, 0xE6, 0xD2, 0x39, 0x95, 0xAD, 0x70, + 0x66, 0x6F, 0xDC, 0xF3, 0x28, 0x65, 0x2B, 0x9E, + 0xA7, 0xCE, 0x62, 0xFA, 0xCA, 0x60, 0x92, 0x34, + 0x04, 0x8D, 0x5F, 0x58, 0x02, 0xD5, 0x7A, 0x7F + }, + { + 0xE3, 0xE3, 0xA1, 0x4C, 0xC0, 0x72, 0x9E, 0x50, + 0x73, 0x2E, 0x31, 0xA1, 0x19, 0xBC, 0x03, 0x55, + 0x38, 0xC6, 0x45, 0xB8, 0x4F, 0x68, 0xAC, 0x92, + 0xDB, 0x1D, 0x99, 0x35, 0xA7, 0xDF, 0xB5, 0xA6 + }, + { + 0x6B, 0x7E, 0x06, 0x7C, 0xFE, 0xBD, 0x29, 0x2F, + 0x38, 0xC8, 0x02, 0x04, 0x64, 0xC8, 0x2E, 0xAE, + 0x10, 0xB3, 0xDE, 0xFC, 0x3D, 0x4A, 0x77, 0x01, + 0xE6, 0x3D, 0xDD, 0x81, 0xE8, 0x93, 0x19, 0x31 + }, + { + 0x01, 0xA5, 0xB8, 0x95, 0xC9, 0x9E, 0x69, 0xA6, + 0x62, 0x31, 0x23, 0x1B, 0xAF, 0x79, 0x38, 0xAB, + 0x85, 0x52, 0x5B, 0x69, 0xF1, 0x01, 0xD8, 0x65, + 0x1E, 0x3D, 0x50, 0xE8, 0xF7, 0xF3, 0x98, 0xDC + }, + { + 0x04, 0x64, 0xBA, 0x18, 0x26, 0xAF, 0xB4, 0xB8, + 0x9F, 0xF3, 0x98, 0x1F, 0x4F, 0x1F, 0x98, 0x43, + 0x06, 0xE0, 0x9F, 0x1A, 0x1C, 0x8B, 0x02, 0x52, + 0x25, 0xDF, 0x9C, 0xE3, 0x8C, 0xB5, 0xC5, 0x9B + }, + { + 0xC0, 0x04, 0xD3, 0x3D, 0x36, 0xBC, 0xD9, 0xED, + 0x98, 0xBA, 0x5A, 0x9A, 0xD8, 0x82, 0x49, 0xE2, + 0xFA, 0x80, 0x30, 0x6E, 0xAB, 0xD2, 0x9E, 0x26, + 0xB1, 0x9D, 0x41, 0xF8, 0xFA, 0xED, 0x2E, 0xE8 + }, + { + 0xD0, 0x86, 0x4F, 0x02, 0x02, 0xA8, 0xD6, 0x4B, + 0x3F, 0x3D, 0x7E, 0xE6, 0x86, 0xB6, 0xBE, 0xFE, + 0xE0, 0x5A, 0xA2, 0x37, 0x49, 0x77, 0x50, 0x06, + 0xD6, 0x3F, 0xAD, 0x9C, 0x0C, 0xE1, 0x23, 0xDE + }, + { + 0x4B, 0xAD, 0xDC, 0x94, 0x18, 0x55, 0x73, 0x8F, + 0x0A, 0xB6, 0x27, 0x7A, 0x67, 0x98, 0x84, 0xB9, + 0x48, 0xD1, 0x1F, 0xF3, 0xC7, 0x0E, 0x16, 0xB4, + 0xB0, 0xF8, 0x99, 0x25, 0xEE, 0xE3, 0x56, 0x8B + }, + { + 0x91, 0x5A, 0x32, 0x52, 0xC5, 0x57, 0xD0, 0xF7, + 0x76, 0xFB, 0x4A, 0x3C, 0x21, 0x8C, 0x6B, 0xED, + 0x07, 0x79, 0x65, 0xA9, 0x65, 0x6F, 0x3D, 0x7B, + 0x3F, 0xFC, 0xA4, 0x1F, 0xC5, 0xE7, 0xE6, 0xE4 + }, + { + 0x0D, 0x27, 0x33, 0x50, 0x27, 0x5E, 0xCB, 0xBB, + 0x6D, 0x56, 0x31, 0x97, 0x38, 0x56, 0xF5, 0x7F, + 0xF3, 0x9F, 0x6D, 0x22, 0x84, 0xB8, 0x1C, 0x3A, + 0x3E, 0x1D, 0xF1, 0x6F, 0xB5, 0xE9, 0x71, 0x1A + }, + { + 0x28, 0x75, 0xDD, 0xD7, 0x44, 0x8D, 0x16, 0xC5, + 0x1C, 0xA1, 0xDF, 0xF4, 0xB7, 0xE0, 0xAC, 0x5D, + 0xCA, 0x61, 0xD7, 0xDD, 0xC5, 0x3E, 0x24, 0xEE, + 0xDA, 0x88, 0xE7, 0x7D, 0x6B, 0x13, 0x2D, 0x0A + }, + { + 0xF1, 0xE2, 0x2D, 0x86, 0x99, 0xAF, 0x6D, 0x99, + 0x9A, 0xA3, 0x8C, 0x59, 0x94, 0xD9, 0xB1, 0x46, + 0x3D, 0x86, 0x22, 0xEC, 0xBE, 0xBA, 0xF2, 0x25, + 0x2F, 0x1C, 0x1B, 0x38, 0xE0, 0x53, 0x27, 0x0F + }, + { + 0x67, 0xAD, 0x69, 0xD7, 0x1F, 0x1D, 0xEA, 0x9A, + 0xEA, 0xE5, 0x18, 0x16, 0x77, 0x8C, 0xDD, 0x0F, + 0x86, 0x5B, 0xDB, 0x67, 0x17, 0x50, 0xB4, 0xAA, + 0x0D, 0x11, 0xCD, 0x8E, 0x77, 0xA1, 0x70, 0x13 + }, + { + 0x59, 0x7B, 0xDF, 0xBC, 0xE4, 0x5D, 0xC8, 0x30, + 0x37, 0x2F, 0xE9, 0x4F, 0xD9, 0x43, 0x9A, 0x9F, + 0xF0, 0x1A, 0x42, 0x7D, 0xDD, 0xCB, 0x86, 0x85, + 0x2E, 0x6D, 0x1D, 0xB0, 0x96, 0xA7, 0x5F, 0x53 + }, + { + 0x8A, 0x79, 0x43, 0x86, 0xDA, 0x87, 0x5C, 0xA3, + 0x02, 0xDF, 0xB4, 0x40, 0x54, 0xA4, 0xB8, 0x5D, + 0x04, 0x0A, 0x22, 0xFE, 0xB4, 0x6B, 0xD4, 0x28, + 0xE9, 0xE9, 0x8A, 0x74, 0x0D, 0x3F, 0xEB, 0x64 + }, + { + 0x3A, 0x24, 0x75, 0x24, 0x4F, 0x07, 0x5E, 0x2C, + 0x5C, 0xA4, 0x3D, 0xAC, 0x3D, 0xE2, 0x11, 0xCC, + 0xF7, 0x6D, 0xEF, 0x11, 0x4A, 0x3B, 0xEF, 0x8A, + 0xB0, 0x47, 0x25, 0xD4, 0x72, 0x91, 0x95, 0x73 + }, + { + 0x6D, 0xEB, 0xD4, 0xAD, 0x70, 0xD3, 0x90, 0x67, + 0xD2, 0xA5, 0x5C, 0xA6, 0x60, 0xDD, 0xB9, 0x62, + 0xA6, 0x84, 0x55, 0xEF, 0x3F, 0xC5, 0xEF, 0x91, + 0x8F, 0xF7, 0x57, 0x1E, 0x7A, 0x5B, 0x46, 0x8A + }, + { + 0x72, 0x1D, 0x57, 0x4C, 0x2B, 0xA0, 0x19, 0xBC, + 0x1C, 0x99, 0x3E, 0x25, 0x9C, 0x3C, 0x34, 0x01, + 0xB0, 0xA2, 0x62, 0x06, 0x20, 0x5F, 0x2F, 0x81, + 0x8A, 0x91, 0xEA, 0x03, 0x94, 0xB3, 0x1F, 0xA4 + }, + { + 0xCA, 0x1C, 0x67, 0xCF, 0x5A, 0x0F, 0x51, 0xBF, + 0xB7, 0xC8, 0xBC, 0x8B, 0xC3, 0xCE, 0x2C, 0x30, + 0x4B, 0xC1, 0x38, 0x5F, 0x21, 0xEA, 0xE9, 0xC2, + 0x33, 0x6D, 0xFF, 0x9A, 0xCE, 0x0E, 0x1D, 0x81 + }, + { + 0x43, 0x8A, 0xCF, 0xB1, 0x29, 0x5E, 0xA3, 0xDD, + 0x65, 0x86, 0xAC, 0x86, 0xF5, 0xEA, 0x92, 0x7F, + 0xE6, 0x66, 0x3A, 0xAF, 0xBC, 0x93, 0x58, 0x2A, + 0x89, 0x07, 0xC7, 0x32, 0xDD, 0x4E, 0x0C, 0xA5 + }, + { + 0xF4, 0x15, 0x61, 0x96, 0x31, 0x67, 0x9F, 0x38, + 0x48, 0x04, 0x56, 0xD1, 0x68, 0x03, 0x19, 0x2F, + 0x10, 0x31, 0xEE, 0x99, 0x07, 0xD8, 0xE5, 0x6A, + 0x94, 0x17, 0x3B, 0xA3, 0x20, 0xC1, 0x35, 0x92 + }, + { + 0xCD, 0x94, 0xDB, 0xE7, 0xA0, 0xF2, 0xB4, 0x7A, + 0x45, 0x7A, 0x9D, 0xD6, 0x3A, 0x6D, 0x11, 0x6B, + 0x29, 0x27, 0x45, 0x17, 0xAA, 0xA0, 0xF1, 0xAB, + 0x6E, 0x59, 0x28, 0x87, 0x94, 0x40, 0xB6, 0xC0 + }, + { + 0x30, 0xD1, 0x48, 0x85, 0x79, 0x52, 0x5D, 0x21, + 0xA6, 0xEF, 0x63, 0x71, 0x7A, 0x98, 0x62, 0x23, + 0x33, 0x49, 0xA8, 0x15, 0xB5, 0x53, 0xE5, 0xFC, + 0xDB, 0x45, 0xAD, 0x51, 0x2B, 0x07, 0x1A, 0x7A + }, + { + 0xF8, 0xDC, 0x1F, 0xA5, 0xE2, 0x90, 0xFC, 0x99, + 0xF3, 0xE6, 0xDA, 0xDC, 0xF8, 0x86, 0x78, 0x9E, + 0xC8, 0x4E, 0x76, 0xFE, 0x03, 0xB6, 0x91, 0xB2, + 0xFA, 0xA7, 0x93, 0x59, 0xEF, 0x1A, 0xE0, 0x18 + }, + { + 0x9E, 0x45, 0xB1, 0xEF, 0xDD, 0x14, 0x60, 0x1D, + 0xAD, 0xA1, 0x63, 0x79, 0x6D, 0x94, 0xA7, 0xDD, + 0x70, 0x77, 0xD0, 0x08, 0x00, 0xAC, 0x7D, 0x86, + 0xDB, 0x80, 0xB8, 0x2C, 0x5D, 0x64, 0xF8, 0xBB + }, + { + 0x6F, 0x3C, 0x41, 0xAF, 0x77, 0x4D, 0xCD, 0xE8, + 0x87, 0x42, 0x57, 0x82, 0x1E, 0x15, 0x49, 0x08, + 0x6E, 0x88, 0xFF, 0xF3, 0xA0, 0x12, 0x9B, 0x31, + 0x09, 0xED, 0xD2, 0xB8, 0x89, 0x60, 0xCC, 0x60 + }, + { + 0x6E, 0x87, 0x16, 0x06, 0x82, 0x9F, 0xDB, 0xF2, + 0x9F, 0xAF, 0x4A, 0xC2, 0x1F, 0xE3, 0x58, 0xA9, + 0x70, 0xF1, 0x62, 0xC3, 0x03, 0x7B, 0xC4, 0x5F, + 0x40, 0xBD, 0x27, 0xBE, 0xED, 0x09, 0x42, 0xEB + }, + { + 0xFD, 0xB3, 0x6A, 0x23, 0x84, 0x7C, 0x56, 0xA5, + 0xC8, 0x39, 0x0E, 0x7A, 0xD3, 0xB4, 0x18, 0x46, + 0x49, 0x15, 0xC1, 0x2D, 0xF3, 0x47, 0x17, 0xCE, + 0x25, 0x73, 0x64, 0x2F, 0x14, 0x8F, 0x4F, 0x17 + }, + { + 0xAC, 0x65, 0x4A, 0xF3, 0xC1, 0x32, 0x47, 0xEE, + 0xDD, 0x83, 0x26, 0x6C, 0x06, 0xCF, 0x31, 0x44, + 0x87, 0xF4, 0x8D, 0xEF, 0x83, 0x4E, 0x2F, 0xF4, + 0x86, 0x63, 0xA9, 0x0D, 0x2B, 0x75, 0x80, 0xB7 + }, + { + 0xA1, 0x3B, 0xAE, 0x45, 0x82, 0x50, 0x22, 0xD1, + 0x19, 0x2E, 0xE4, 0x33, 0x43, 0xF4, 0xDA, 0x75, + 0x07, 0xD4, 0x3C, 0xED, 0x33, 0x08, 0x83, 0x5D, + 0xF3, 0x50, 0xE5, 0x92, 0x03, 0xA4, 0x6C, 0x71 + }, + { + 0x57, 0x77, 0x71, 0x26, 0xE7, 0xB2, 0x49, 0xCE, + 0xCC, 0x65, 0x3E, 0xE7, 0x4F, 0x76, 0x0B, 0x89, + 0x94, 0x1A, 0xA8, 0xD3, 0x30, 0x6D, 0xAC, 0x56, + 0x8A, 0xCA, 0x8D, 0xF7, 0xC8, 0xB9, 0xC1, 0x2B + }, + { + 0xA7, 0x0B, 0xD2, 0x1E, 0xFA, 0x31, 0x66, 0xDE, + 0xB3, 0x71, 0x19, 0x86, 0xCD, 0x8D, 0x76, 0x59, + 0x67, 0x89, 0x32, 0xF3, 0x38, 0xB1, 0x34, 0x5B, + 0x65, 0x38, 0x70, 0x45, 0x17, 0xA8, 0x7C, 0xB4 + }, + { + 0x2F, 0x14, 0x2A, 0x5A, 0xD7, 0x46, 0xAB, 0xCD, + 0x34, 0x17, 0xA6, 0xB6, 0x2C, 0x36, 0x9C, 0x17, + 0xAA, 0x9C, 0xD3, 0x47, 0xC5, 0x1D, 0xA8, 0x80, + 0x23, 0xE4, 0x55, 0xAC, 0x5B, 0x70, 0x0D, 0x16 + }, + { + 0x9E, 0x10, 0xB1, 0xF6, 0x8D, 0x2F, 0x24, 0x91, + 0x62, 0x29, 0x08, 0x8B, 0x8D, 0x3B, 0x3D, 0xD0, + 0x4D, 0xBC, 0xCA, 0xD2, 0xEB, 0x94, 0x37, 0x97, + 0x66, 0x1A, 0x40, 0x37, 0x2E, 0xB9, 0x78, 0x1B + }, + { + 0x36, 0xA4, 0x75, 0xEB, 0xA0, 0xA9, 0xEC, 0x0B, + 0xDD, 0x43, 0x23, 0xE0, 0x28, 0x95, 0x78, 0x7C, + 0x26, 0x0E, 0x2F, 0x46, 0x88, 0xEF, 0x27, 0x84, + 0x48, 0x08, 0xCE, 0x15, 0xFA, 0x1B, 0x8F, 0xDD + }, + { + 0x11, 0xA0, 0xCB, 0x29, 0x24, 0xFE, 0xD2, 0x66, + 0xD2, 0xA5, 0x13, 0x9C, 0xBD, 0x56, 0x35, 0x84, + 0xF1, 0xA4, 0xB1, 0xA2, 0xDD, 0xC5, 0xA6, 0x02, + 0xA5, 0x49, 0x22, 0xBD, 0xC3, 0x9D, 0xCF, 0x65 + }, + { + 0xDE, 0x50, 0xEE, 0x8E, 0x88, 0xE5, 0xDF, 0x9E, + 0xA7, 0xCB, 0x4A, 0xE8, 0xA1, 0xAA, 0x7A, 0x2F, + 0x0D, 0xFA, 0xCA, 0xED, 0x8E, 0xE4, 0x97, 0x6D, + 0xE3, 0x22, 0x70, 0x9E, 0xD1, 0x79, 0xB6, 0xA0 + }, + { + 0xA6, 0xA6, 0xB0, 0xD0, 0xB0, 0xFC, 0x01, 0x8B, + 0x97, 0xD2, 0x78, 0x0A, 0x6C, 0x1F, 0x6B, 0x0E, + 0x14, 0x56, 0x25, 0xE2, 0xE1, 0xFC, 0x19, 0x78, + 0x10, 0xED, 0xC6, 0x03, 0x4A, 0xA5, 0xB3, 0xDF + }, + { + 0x4E, 0x7A, 0x2B, 0x3F, 0xC7, 0x1F, 0x55, 0x39, + 0x1C, 0x33, 0x40, 0x23, 0xBB, 0x75, 0xD5, 0xF5, + 0x08, 0x28, 0x9C, 0x16, 0x27, 0xA4, 0x3D, 0xB8, + 0x76, 0x93, 0xA5, 0x93, 0xAE, 0x02, 0x24, 0x60 + }, + { + 0xF0, 0xB9, 0xA3, 0xC7, 0x9D, 0xC0, 0x04, 0x9C, + 0xA1, 0x26, 0xC1, 0x57, 0x85, 0x9F, 0x24, 0x57, + 0xF7, 0x40, 0xAC, 0xB2, 0xB5, 0xBC, 0xCA, 0xF2, + 0x32, 0xD7, 0x7C, 0x86, 0x41, 0xE6, 0xA0, 0x46 + }, + { + 0xD9, 0xB3, 0xFE, 0x0B, 0x04, 0xDF, 0x37, 0xDA, + 0xFF, 0x35, 0xDD, 0x0B, 0xF2, 0x67, 0xCB, 0xF7, + 0xEE, 0x4C, 0x47, 0xD1, 0x34, 0x46, 0x0F, 0x1D, + 0x5E, 0xD8, 0xAC, 0x57, 0xA5, 0x2A, 0xB0, 0xEC + }, + { + 0xE8, 0x47, 0x71, 0x04, 0x8A, 0xD7, 0xC8, 0xC2, + 0xF6, 0xF8, 0x9C, 0x6C, 0x00, 0xC5, 0x6D, 0x34, + 0x0C, 0xE4, 0x9B, 0xF9, 0x6E, 0xB9, 0xE3, 0xB8, + 0xC6, 0xD9, 0xDB, 0x4D, 0xF0, 0x56, 0x83, 0xE3 + }, + { + 0x04, 0x50, 0xC4, 0x68, 0x58, 0x34, 0x49, 0xEF, + 0xBD, 0x5A, 0xCE, 0xA8, 0x72, 0x23, 0x14, 0xAB, + 0xF1, 0xF8, 0x94, 0x41, 0x28, 0x77, 0x8A, 0x29, + 0xBB, 0xB7, 0x69, 0x5B, 0x6E, 0x4E, 0xF0, 0xD1 + }, + { + 0x75, 0x78, 0x67, 0x4A, 0xE9, 0x9F, 0x2D, 0x6E, + 0x05, 0x62, 0x69, 0xA9, 0x7E, 0x68, 0x18, 0xF7, + 0xE1, 0xDE, 0x3A, 0xD9, 0x90, 0x2B, 0x75, 0x58, + 0xDF, 0xA7, 0x02, 0x74, 0x52, 0xE0, 0x7B, 0x01 + }, + { + 0x5C, 0x88, 0x9D, 0xAD, 0xD6, 0xC0, 0xCA, 0xBC, + 0x84, 0x83, 0xBE, 0x37, 0xC2, 0xE0, 0x9F, 0x29, + 0x09, 0xF0, 0xFB, 0xD2, 0x4E, 0x9D, 0x53, 0x2A, + 0xB0, 0x5D, 0x0D, 0x54, 0x8F, 0x1D, 0x33, 0x18 + }, + { + 0x9E, 0x17, 0x93, 0x88, 0xFF, 0x77, 0x2B, 0x14, + 0xB4, 0x7F, 0x9C, 0x96, 0x49, 0x98, 0xE5, 0x61, + 0xBC, 0x2C, 0xDE, 0xA7, 0x95, 0x7C, 0xDD, 0x48, + 0xDB, 0xDA, 0x36, 0xB7, 0x91, 0x3E, 0xED, 0x11 + }, + { + 0x9B, 0x49, 0x9E, 0xB3, 0x45, 0x00, 0xEC, 0x89, + 0xA7, 0x95, 0x23, 0xA0, 0xB0, 0xAC, 0x35, 0xA4, + 0x6B, 0x77, 0x6A, 0xB3, 0x6B, 0xF5, 0x92, 0x6F, + 0xEF, 0xA1, 0xD2, 0xCF, 0x90, 0x54, 0x1E, 0x20 + }, + { + 0x11, 0x11, 0x3D, 0xCE, 0xA3, 0xE7, 0x93, 0xE3, + 0x6B, 0xC9, 0xC7, 0xB6, 0xB0, 0x21, 0x73, 0x2E, + 0xEE, 0x6E, 0x5F, 0x77, 0xB6, 0x86, 0x10, 0x76, + 0x54, 0x63, 0x0D, 0x0F, 0x4A, 0xFA, 0x32, 0x9A + }, + { + 0xC2, 0xB7, 0xAE, 0xBC, 0xB4, 0xA5, 0xB5, 0x39, + 0x91, 0xD2, 0x8A, 0x05, 0xB3, 0x4A, 0x40, 0x04, + 0xB3, 0xB0, 0x9B, 0x7B, 0x5D, 0x42, 0x51, 0x1D, + 0x58, 0x9B, 0x72, 0x96, 0x3F, 0x17, 0x4C, 0xED + }, + { + 0x32, 0x3A, 0x2A, 0x7F, 0x57, 0xD9, 0xEE, 0x7D, + 0x51, 0xE1, 0x9E, 0x17, 0x1F, 0xAE, 0x59, 0xC5, + 0xEE, 0xF8, 0xCA, 0x25, 0xE0, 0xAC, 0x93, 0x8D, + 0xE2, 0x7C, 0x93, 0x81, 0x80, 0x84, 0xDF, 0x4A + }, + { + 0x8B, 0xF6, 0x62, 0x4E, 0xD1, 0xAC, 0xDE, 0xD2, + 0x44, 0x64, 0x69, 0x45, 0x8D, 0xED, 0xF8, 0x0A, + 0x04, 0xFE, 0xD4, 0x66, 0x4F, 0x8D, 0xE5, 0x1F, + 0xFF, 0xA6, 0x8E, 0xC3, 0x16, 0x7B, 0x74, 0xC3 + }, + { + 0x16, 0xE4, 0x67, 0xE5, 0x6E, 0xA5, 0x54, 0x26, + 0xE8, 0xFC, 0x18, 0x46, 0xE1, 0x39, 0xCD, 0x9E, + 0xFD, 0xFF, 0xD5, 0x4C, 0xEB, 0xA7, 0xA0, 0x20, + 0xA4, 0x6F, 0x44, 0x93, 0xB5, 0x88, 0xC2, 0x26 + }, + { + 0xED, 0x7B, 0xEE, 0xF5, 0x87, 0x11, 0xA8, 0x94, + 0x73, 0xFF, 0x74, 0x4D, 0xAA, 0xED, 0xEA, 0x00, + 0xDC, 0xBE, 0xB7, 0xC7, 0xFA, 0x0E, 0xDA, 0x45, + 0x81, 0x7A, 0x38, 0x9E, 0x73, 0xEA, 0x9F, 0x8B + }, + { + 0xB2, 0xFD, 0x78, 0x8B, 0xF7, 0x6A, 0x40, 0x6F, + 0x45, 0x2A, 0x53, 0x86, 0xE1, 0xC9, 0x4A, 0xE7, + 0x1B, 0xF2, 0xFC, 0x30, 0xED, 0x45, 0x0A, 0xB5, + 0x3F, 0x12, 0xD7, 0x2B, 0x16, 0x94, 0xD5, 0x03 + }, + { + 0x3B, 0x94, 0xC3, 0x02, 0x23, 0xAE, 0xC3, 0x70, + 0x64, 0xCB, 0x85, 0x0A, 0xBF, 0x6C, 0x84, 0x6E, + 0xF4, 0x32, 0xED, 0xCA, 0xC3, 0x67, 0x81, 0xEB, + 0x10, 0x13, 0x81, 0x82, 0xC7, 0x16, 0x61, 0x3C + }, + { + 0x17, 0x93, 0x53, 0x46, 0xD1, 0x50, 0x2A, 0xE4, + 0xC1, 0xD1, 0xEB, 0x6D, 0x4B, 0xD8, 0x68, 0xF1, + 0x31, 0xAE, 0xEE, 0xF6, 0xDA, 0x36, 0xDF, 0xED, + 0xAC, 0x04, 0x1D, 0xD5, 0x49, 0x26, 0xBB, 0x82 + }, + { + 0x3A, 0xCF, 0x7B, 0xD0, 0x87, 0x04, 0x6E, 0x03, + 0x11, 0xA6, 0x5C, 0x14, 0x69, 0x88, 0xF4, 0x21, + 0x19, 0x57, 0x9F, 0x49, 0x05, 0xC0, 0x7A, 0xD3, + 0x6B, 0x45, 0x69, 0x70, 0x35, 0x13, 0x76, 0x6A + }, + { + 0xBB, 0x92, 0x8C, 0xA9, 0x5C, 0x58, 0x8A, 0x10, + 0x53, 0xD1, 0x34, 0x70, 0x3B, 0xAD, 0x2B, 0x01, + 0x08, 0xD1, 0x33, 0xC2, 0xCF, 0xFB, 0xCD, 0xBB, + 0x46, 0x84, 0x67, 0xCA, 0x1A, 0x51, 0x2C, 0x30 + }, + { + 0xBF, 0xD7, 0x08, 0xE5, 0xC6, 0x1A, 0x27, 0x3C, + 0xCA, 0x42, 0x22, 0x71, 0x51, 0x72, 0x3A, 0xD5, + 0x01, 0x12, 0x0A, 0xB4, 0x04, 0x5D, 0x53, 0x55, + 0x0F, 0x59, 0xE0, 0xEE, 0x7D, 0xFE, 0x93, 0x04 + }, + { + 0x19, 0x3A, 0x8C, 0x0A, 0x6E, 0x56, 0x8C, 0x1C, + 0x17, 0x76, 0xE6, 0x4F, 0xF6, 0x4D, 0x9C, 0x56, + 0x3B, 0x14, 0xE2, 0x06, 0xA1, 0x2A, 0x21, 0xFF, + 0xDA, 0x42, 0x88, 0x31, 0xE7, 0x4F, 0x72, 0x14 + }, + { + 0x35, 0xFF, 0xC2, 0xFB, 0x70, 0xF1, 0xED, 0xFE, + 0x89, 0x06, 0xD9, 0x21, 0xCE, 0xF5, 0x1D, 0xD4, + 0x3E, 0xC6, 0x45, 0xFA, 0x2C, 0x21, 0xB8, 0xB3, + 0xAB, 0xC7, 0x7F, 0x9B, 0x13, 0xAD, 0x49, 0x57 + }, + { + 0x98, 0x5D, 0xBF, 0xD5, 0x8D, 0x7E, 0xA8, 0x06, + 0x80, 0xF5, 0x73, 0x0B, 0xC3, 0x8F, 0x21, 0x8E, + 0x7E, 0x3B, 0x65, 0xBD, 0x68, 0x85, 0xC2, 0x1A, + 0x0F, 0x3F, 0x31, 0xE0, 0x6F, 0xDA, 0x3A, 0xFE + }, + { + 0xAF, 0xEF, 0xA6, 0x75, 0xEA, 0xB1, 0x59, 0xA9, + 0x15, 0x11, 0x8D, 0x72, 0x69, 0x5D, 0x5A, 0x47, + 0x1C, 0xEE, 0x39, 0xA3, 0xDA, 0x1B, 0xF3, 0x91, + 0x1D, 0x06, 0xE1, 0xA4, 0x6F, 0x7C, 0x57, 0xC7 + }, + { + 0x70, 0x09, 0x62, 0xAF, 0x90, 0x56, 0xFF, 0x21, + 0xEF, 0x56, 0x67, 0xF2, 0xD8, 0xC2, 0x2B, 0xDD, + 0xB0, 0xF1, 0xFF, 0x60, 0xA5, 0x22, 0x7C, 0x0C, + 0x77, 0x6F, 0x15, 0x0B, 0xAD, 0x19, 0x23, 0x16 + }, + { + 0x63, 0x5C, 0x6A, 0x66, 0xEF, 0x30, 0xC3, 0xC2, + 0xD1, 0x7A, 0x8C, 0x16, 0x50, 0xD2, 0x24, 0x00, + 0x3A, 0xFA, 0x51, 0x3F, 0xBA, 0x90, 0x55, 0x20, + 0x78, 0x57, 0xBB, 0x3F, 0x8E, 0xF2, 0x7E, 0x71 + }, + { + 0x48, 0xBB, 0xA3, 0x51, 0xCE, 0x88, 0xCB, 0x0F, + 0x54, 0xC2, 0x89, 0x19, 0x98, 0x4A, 0x38, 0x87, + 0xD3, 0x3B, 0x49, 0xF1, 0x2A, 0xFA, 0x33, 0xA4, + 0x08, 0x8D, 0xD0, 0xB7, 0x20, 0x8D, 0x37, 0x21 + }, + { + 0x31, 0x9F, 0x2B, 0x26, 0x39, 0xF3, 0x08, 0xEE, + 0x29, 0x6E, 0x40, 0x35, 0x69, 0x3A, 0x16, 0xA7, + 0x85, 0x57, 0x4D, 0xCC, 0xD9, 0x7C, 0x70, 0x53, + 0x82, 0xBC, 0xB5, 0xE9, 0xD2, 0xA7, 0xC4, 0x5B + }, + { + 0xC4, 0x71, 0xE8, 0xC0, 0xF6, 0xB1, 0xCB, 0x44, + 0xEE, 0x44, 0xD0, 0x75, 0x08, 0x35, 0x50, 0x86, + 0x5A, 0xB2, 0x36, 0x85, 0x16, 0xA7, 0xA1, 0x6B, + 0x84, 0xCF, 0x91, 0x8C, 0x64, 0x2E, 0x79, 0x41 + }, + { + 0x14, 0x6C, 0x5B, 0x70, 0xE4, 0x22, 0x50, 0x30, + 0x2E, 0x08, 0xFC, 0x96, 0xC2, 0x1C, 0xCC, 0x9B, + 0xFB, 0x15, 0x4A, 0xE6, 0x70, 0x18, 0x10, 0x03, + 0x63, 0xB4, 0x96, 0x63, 0x3B, 0x31, 0x35, 0xFF + }, + { + 0x07, 0xDD, 0xFD, 0x96, 0xF3, 0xA1, 0x12, 0x6C, + 0x15, 0x54, 0xF8, 0x4D, 0x4E, 0x19, 0x07, 0x0D, + 0x73, 0x5E, 0xF7, 0xB7, 0x73, 0x74, 0xE1, 0xF1, + 0x90, 0x81, 0x88, 0x27, 0xFF, 0x66, 0x15, 0xF8 + }, + { + 0xC6, 0x21, 0x1D, 0x77, 0xCE, 0x34, 0x9E, 0xA8, + 0xD4, 0x17, 0xA7, 0x15, 0xDA, 0x65, 0xA3, 0xFF, + 0xDB, 0x46, 0xDE, 0x34, 0x81, 0x9A, 0x41, 0xB0, + 0x04, 0x81, 0xAC, 0xDF, 0x7A, 0xF1, 0x54, 0x09 + }, + { + 0x69, 0xEE, 0x95, 0x74, 0x23, 0x28, 0x9E, 0x33, + 0xAC, 0x96, 0xA5, 0x8F, 0xFE, 0x49, 0x96, 0x7A, + 0x59, 0xAB, 0x8F, 0x50, 0x99, 0xA1, 0xDA, 0x9E, + 0x0E, 0x65, 0x82, 0xD0, 0x95, 0x50, 0xCA, 0xE7 + }, + { + 0x76, 0x53, 0x37, 0x09, 0x0E, 0xB9, 0x74, 0x2A, + 0x79, 0x44, 0x15, 0xB2, 0x5B, 0xC6, 0x90, 0x02, + 0x5A, 0x90, 0x82, 0xDA, 0x4C, 0x76, 0x69, 0x87, + 0xDB, 0xAD, 0x9B, 0x4F, 0x20, 0x11, 0xD2, 0xBB + }, + { + 0x0B, 0x67, 0x94, 0xA0, 0x68, 0x48, 0x88, 0xD1, + 0xB3, 0xDB, 0xF5, 0xCB, 0x70, 0xB0, 0x7E, 0xA7, + 0x60, 0xA6, 0x03, 0x88, 0xA8, 0x0E, 0x07, 0x3F, + 0xBC, 0xF5, 0x6F, 0xE8, 0xFA, 0xFF, 0xF8, 0x4C + }, + { + 0x2B, 0xA2, 0xD1, 0x76, 0xE8, 0xB2, 0x6E, 0x0E, + 0x8B, 0x39, 0x31, 0x3C, 0x97, 0xB3, 0xB8, 0xEC, + 0x68, 0x58, 0x79, 0x45, 0x01, 0x41, 0xD6, 0x21, + 0xA3, 0x1E, 0x2F, 0xDB, 0x00, 0x63, 0x26, 0x1B + }, + { + 0xD3, 0x6E, 0x38, 0xFD, 0x27, 0xDB, 0x0C, 0x28, + 0x13, 0x2D, 0x76, 0x69, 0x56, 0xBA, 0x12, 0x91, + 0xED, 0xEF, 0xB0, 0x5D, 0x96, 0x6B, 0xBB, 0x8E, + 0x35, 0x43, 0xA3, 0x8D, 0x04, 0x57, 0x59, 0x73 + }, + { + 0x61, 0x11, 0xB4, 0x69, 0x5B, 0x79, 0x0C, 0x59, + 0x7B, 0xA8, 0x40, 0x56, 0x8F, 0xA0, 0x5E, 0x92, + 0x72, 0x4B, 0xD2, 0xA7, 0xF4, 0xFC, 0xD7, 0x46, + 0xC6, 0x90, 0xA4, 0x53, 0xC8, 0xC4, 0x7F, 0x17 + }, + { + 0xA9, 0x53, 0xD1, 0xF6, 0x9C, 0xEC, 0xFE, 0x70, + 0xC0, 0x28, 0xDF, 0xFB, 0x99, 0x83, 0xA3, 0xD9, + 0xA0, 0x79, 0xA3, 0x65, 0x1E, 0xB5, 0xFB, 0x02, + 0x94, 0x07, 0x47, 0xE8, 0xA3, 0x7F, 0x40, 0x17 + }, + { + 0x36, 0x53, 0xAD, 0x4D, 0x4A, 0xD2, 0x3F, 0x2B, + 0xB1, 0x59, 0x6C, 0x63, 0xAB, 0x4C, 0x2B, 0x82, + 0x43, 0xC5, 0xEA, 0x1C, 0x58, 0x31, 0x31, 0x6B, + 0x96, 0xCC, 0xBC, 0x1E, 0xA1, 0xA0, 0x53, 0x18 + }, + { + 0x03, 0x1D, 0x61, 0x85, 0xF5, 0x10, 0x03, 0x00, + 0xB8, 0x18, 0xFD, 0xC2, 0xFC, 0x8A, 0x91, 0xC9, + 0x53, 0x32, 0x5A, 0x1F, 0xAF, 0xFD, 0xCB, 0xD3, + 0xD0, 0x47, 0x8E, 0xCB, 0x7A, 0xCB, 0x7E, 0xEA + }, + { + 0xFF, 0x57, 0x34, 0x95, 0xD4, 0x0B, 0x27, 0xBD, + 0xE3, 0x91, 0xDA, 0xC9, 0x12, 0x22, 0xC3, 0xB7, + 0xEE, 0xAF, 0x02, 0x3F, 0x37, 0x2A, 0xD8, 0xEE, + 0x8B, 0x60, 0x39, 0x9B, 0xDB, 0x30, 0x36, 0xD9 + }, + { + 0xB7, 0x43, 0x46, 0xFE, 0xCB, 0xA2, 0x6C, 0x8E, + 0x6C, 0xF0, 0x2C, 0x06, 0xEA, 0x92, 0xDF, 0x64, + 0xC5, 0xA7, 0xEC, 0x24, 0x19, 0x08, 0xCC, 0x0E, + 0xB3, 0x3A, 0xE6, 0x26, 0xCA, 0xE0, 0x62, 0xD6 + }, + { + 0x44, 0x6C, 0xFC, 0x66, 0x89, 0x75, 0x28, 0x54, + 0xC8, 0x8C, 0x2D, 0xDB, 0xE6, 0x49, 0x55, 0x34, + 0xDB, 0xBC, 0xD3, 0x17, 0x70, 0xFC, 0xFC, 0x09, + 0x50, 0x46, 0x9C, 0x61, 0xB3, 0xBB, 0x3D, 0x7E + }, + { + 0x3C, 0x10, 0x1C, 0x16, 0x59, 0x63, 0x1D, 0x57, + 0xA9, 0x41, 0x32, 0x40, 0x3C, 0x26, 0x21, 0xC2, + 0xB4, 0xF8, 0xB3, 0x32, 0x97, 0x0C, 0x7D, 0x17, + 0x90, 0xFE, 0x08, 0x2E, 0x56, 0x31, 0x95, 0x4B + }, + { + 0x83, 0xB5, 0xBF, 0x99, 0xB1, 0x55, 0xBB, 0x1E, + 0xF2, 0x62, 0x3B, 0x58, 0x09, 0x4D, 0x66, 0x04, + 0x25, 0xDD, 0x12, 0xBC, 0xB9, 0x8F, 0xE9, 0x76, + 0x43, 0xA7, 0xC8, 0x4E, 0x6A, 0x6D, 0xA7, 0x2E + }, + { + 0xCD, 0xEB, 0x2D, 0x1E, 0x27, 0xB2, 0x08, 0xEE, + 0xED, 0x69, 0x92, 0xF5, 0xA6, 0x30, 0x9F, 0x90, + 0xE7, 0x9F, 0xC2, 0xFD, 0x5E, 0x74, 0x15, 0x93, + 0x29, 0x20, 0x15, 0x63, 0xA5, 0xFA, 0x05, 0xDD + }, + { + 0x4A, 0xF2, 0x8A, 0x6C, 0x0E, 0xDD, 0x11, 0xFA, + 0xBF, 0x31, 0x27, 0x97, 0xEB, 0x95, 0x58, 0x02, + 0x5D, 0x95, 0xA6, 0xC1, 0x83, 0x2A, 0xA7, 0x39, + 0xF8, 0x62, 0xFA, 0x08, 0x53, 0x91, 0x4A, 0x03 + }, + { + 0xC7, 0xEB, 0x94, 0x6D, 0xBD, 0x99, 0xAC, 0x34, + 0xC5, 0xEF, 0xC2, 0xA7, 0x7B, 0x6C, 0xF5, 0xE9, + 0x17, 0xCE, 0x17, 0x3A, 0xCE, 0x4A, 0xD3, 0xED, + 0xB9, 0x71, 0xE4, 0xFF, 0x01, 0x98, 0x34, 0x9A + }, + { + 0x00, 0xD0, 0xC3, 0x3B, 0x21, 0x65, 0xEE, 0x8A, + 0xA5, 0xFF, 0x64, 0x33, 0x31, 0xC2, 0xB1, 0xFD, + 0xA7, 0xBB, 0x6C, 0xE2, 0xEE, 0x89, 0x3C, 0xBC, + 0xA8, 0x4C, 0xC1, 0xAE, 0x08, 0x50, 0xA7, 0xB9 + }, + { + 0x08, 0x24, 0xA2, 0x31, 0xFD, 0x17, 0xDA, 0xC6, + 0xF4, 0xEE, 0xD3, 0x33, 0x18, 0xF8, 0xFC, 0x25, + 0x8C, 0x9D, 0xF9, 0xD9, 0xD9, 0xDB, 0xAB, 0x40, + 0xE4, 0x64, 0x75, 0x5B, 0xE0, 0x70, 0xF8, 0xCF + }, + { + 0x13, 0xDF, 0x5A, 0xB4, 0x96, 0x4F, 0x5F, 0xF0, + 0x2D, 0x96, 0x23, 0x57, 0xAC, 0xEC, 0x20, 0x10, + 0xBB, 0x5D, 0x11, 0x95, 0x96, 0x23, 0x47, 0xED, + 0x17, 0x10, 0x23, 0x34, 0x38, 0x33, 0xB3, 0xAB + }, + { + 0xDD, 0x81, 0x64, 0x30, 0xC1, 0xD9, 0xC1, 0xCE, + 0x31, 0xB4, 0x87, 0x3D, 0xD6, 0x10, 0xCF, 0xD7, + 0x3A, 0xD3, 0xE7, 0xA8, 0x24, 0x89, 0xF3, 0x7F, + 0xD3, 0x7F, 0xF8, 0x16, 0x8E, 0xFD, 0x66, 0x4E + }, + { + 0xA8, 0x94, 0x69, 0x82, 0x00, 0x68, 0x33, 0x11, + 0x8B, 0x8B, 0x91, 0x5A, 0x10, 0x0A, 0x27, 0x86, + 0x8B, 0xDC, 0x80, 0xBA, 0xCA, 0x20, 0xC1, 0x9C, + 0x0A, 0x6A, 0xAA, 0x65, 0x93, 0xFB, 0x57, 0x5C + }, + { + 0xD3, 0xB6, 0xCD, 0x39, 0x3D, 0xDE, 0xCB, 0x57, + 0x1D, 0xD6, 0x83, 0x2C, 0xE0, 0x31, 0xD3, 0xD0, + 0xE7, 0x69, 0xDB, 0xD2, 0x51, 0x60, 0x25, 0xBD, + 0xE8, 0x9A, 0x2A, 0xC4, 0xD2, 0x05, 0x50, 0xB8 + }, + { + 0x7D, 0x56, 0x6E, 0xA9, 0x93, 0x86, 0x49, 0x17, + 0x47, 0x12, 0x8B, 0xAC, 0x05, 0xEA, 0x96, 0x45, + 0x0E, 0x76, 0x27, 0xFD, 0x2C, 0xC7, 0x15, 0x31, + 0x8C, 0xC0, 0x46, 0x0A, 0x04, 0xF4, 0x48, 0xA8 + }, + { + 0x4B, 0xBA, 0x8E, 0x76, 0x58, 0x6F, 0x77, 0x47, + 0x81, 0x99, 0x18, 0x4D, 0x78, 0x4B, 0x81, 0xC3, + 0xF2, 0x30, 0x58, 0xBD, 0x34, 0x18, 0xFF, 0x34, + 0x50, 0x39, 0x5E, 0x25, 0x43, 0x5A, 0x11, 0x4D + }, + { + 0xDE, 0x6C, 0x54, 0xD2, 0xA8, 0x85, 0x03, 0x61, + 0x5B, 0x15, 0x36, 0x40, 0x78, 0xC2, 0x55, 0xE1, + 0x78, 0xFB, 0x2B, 0x06, 0xF9, 0xD6, 0x2A, 0xC9, + 0x83, 0x45, 0xF3, 0xAC, 0x18, 0xB7, 0xBB, 0x6D + }, + { + 0x64, 0xCD, 0x9C, 0xDC, 0x5F, 0xBD, 0xB1, 0x74, + 0x58, 0x1C, 0xA2, 0xE7, 0x93, 0x2A, 0x2B, 0xF8, + 0x8F, 0x33, 0x1C, 0xD3, 0x9B, 0xA9, 0xE0, 0x7A, + 0x93, 0xA1, 0x99, 0x25, 0x3E, 0xF4, 0x76, 0x73 + }, + { + 0x4B, 0xBE, 0x6B, 0x5E, 0xCD, 0x0E, 0xDF, 0xFC, + 0x62, 0xCC, 0x72, 0xC9, 0x53, 0x52, 0xC5, 0x23, + 0x02, 0x9F, 0xC0, 0xE1, 0xB7, 0xE8, 0xEF, 0xBC, + 0x83, 0x0E, 0x3E, 0x0B, 0x59, 0x1C, 0x31, 0xB4 + }, + { + 0x60, 0xD8, 0xBE, 0xCA, 0xA7, 0x90, 0x59, 0xDB, + 0x5E, 0x9B, 0x0A, 0x35, 0x7F, 0xF2, 0xC2, 0x37, + 0xF5, 0x0C, 0xC4, 0x4B, 0x93, 0xC7, 0xCB, 0x04, + 0x33, 0x2E, 0x5F, 0xEB, 0x5C, 0x2B, 0xAF, 0x83 + }, + { + 0x7B, 0x07, 0x38, 0xFA, 0xB8, 0xAD, 0xA3, 0x5B, + 0x61, 0xF1, 0xFD, 0xF7, 0xB5, 0xB1, 0x74, 0x56, + 0x28, 0xC4, 0x1D, 0x3D, 0xB4, 0xD2, 0xCA, 0xE7, + 0x97, 0x6F, 0xB0, 0x3C, 0x30, 0xE8, 0x8B, 0x0F + }, + { + 0xE1, 0x67, 0xF9, 0x35, 0xD8, 0x0A, 0xF3, 0x2B, + 0xE4, 0x15, 0xB7, 0x82, 0x09, 0x43, 0x24, 0x85, + 0xA5, 0xEB, 0x34, 0x1C, 0x94, 0x16, 0x6B, 0x2C, + 0xE0, 0xE8, 0xDB, 0xE3, 0x13, 0x3F, 0xC9, 0x76 + }, + { + 0xFA, 0x04, 0xB3, 0xBE, 0x57, 0x26, 0x19, 0x97, + 0x73, 0x66, 0xEC, 0xC2, 0xBB, 0x9A, 0x6A, 0x87, + 0xAB, 0xD2, 0x06, 0xE3, 0x6F, 0x54, 0xC6, 0xC0, + 0x37, 0x07, 0xDB, 0x6D, 0x99, 0xB8, 0x5E, 0xBA + }, + { + 0x71, 0x8C, 0x0F, 0x50, 0x5E, 0x4D, 0x90, 0x37, + 0x8B, 0x88, 0xBF, 0xCB, 0x01, 0x62, 0x37, 0xC4, + 0xDB, 0x54, 0x4A, 0xC0, 0xD9, 0x8F, 0xF6, 0x57, + 0x0E, 0x30, 0x4A, 0x5C, 0x99, 0xF0, 0xB0, 0xD1 + }, + { + 0xC8, 0x90, 0xB9, 0x19, 0x18, 0xC5, 0x0B, 0x21, + 0x3B, 0xD3, 0xBC, 0xEA, 0x31, 0x6A, 0x6C, 0xBE, + 0x4A, 0x46, 0x72, 0x67, 0x72, 0x75, 0x26, 0xE5, + 0xD9, 0xBE, 0x04, 0x3E, 0xB6, 0xA5, 0x0D, 0x93 + }, + { + 0x32, 0xA5, 0xBC, 0xAF, 0xB7, 0x11, 0xAB, 0x11, + 0x31, 0xE8, 0x25, 0x5D, 0xD6, 0xE1, 0x76, 0xFD, + 0x07, 0x45, 0x88, 0x2D, 0x81, 0x06, 0x4C, 0xD7, + 0x86, 0x70, 0x42, 0xDD, 0x99, 0x09, 0x8F, 0x40 + }, + { + 0xEB, 0x20, 0x6B, 0xA0, 0xD5, 0x79, 0x60, 0x3D, + 0xA3, 0x0C, 0x7B, 0xC6, 0x8D, 0xFE, 0xE8, 0x41, + 0x21, 0xAA, 0x15, 0x68, 0x81, 0xDC, 0x59, 0x68, + 0x21, 0x25, 0x3F, 0x10, 0xF7, 0xB4, 0xC8, 0x82 + }, + { + 0xC4, 0x1F, 0xED, 0x1A, 0x06, 0x6B, 0xD7, 0xCC, + 0x28, 0xB4, 0x2C, 0x77, 0xC2, 0x29, 0x25, 0x00, + 0xB0, 0x07, 0xD8, 0xE5, 0xA0, 0xA1, 0xEC, 0xA3, + 0x3D, 0x2A, 0x8F, 0xC4, 0x33, 0x68, 0xE9, 0x1D + }, + { + 0xE6, 0x26, 0x73, 0xE9, 0xDE, 0x4E, 0x83, 0x54, + 0x2A, 0xBC, 0xB1, 0x64, 0x94, 0x5B, 0x07, 0x52, + 0xB0, 0xDE, 0x3D, 0x45, 0x05, 0x27, 0x17, 0x58, + 0x2C, 0x4E, 0x32, 0x7C, 0x94, 0x55, 0x59, 0x2A + }, + { + 0xE7, 0x0D, 0xCC, 0x3E, 0xFC, 0x4D, 0xAD, 0xE1, + 0x32, 0x5C, 0xC0, 0xA3, 0x35, 0x04, 0x09, 0x4D, + 0x41, 0xC2, 0xC6, 0xCA, 0xAC, 0x7E, 0xE1, 0xDF, + 0x5F, 0xA5, 0xED, 0x45, 0x76, 0xDD, 0x4B, 0x17 + }, + { + 0x61, 0x39, 0x08, 0xD7, 0xAA, 0x5F, 0xD2, 0xF9, + 0xE2, 0x89, 0xED, 0x2D, 0x5C, 0xD9, 0xDF, 0x7D, + 0x15, 0x7B, 0x7F, 0x2B, 0xE7, 0xF4, 0x40, 0x7E, + 0x4B, 0xD5, 0x28, 0x28, 0xC4, 0x64, 0xB8, 0x0E + }, + { + 0x98, 0xC0, 0x8C, 0xA6, 0x21, 0xF4, 0xC1, 0xA4, + 0x07, 0x4C, 0xD4, 0x3C, 0xBA, 0xF3, 0xEA, 0xAF, + 0x9E, 0x4F, 0xF1, 0x10, 0xE6, 0xB9, 0xC6, 0x29, + 0x55, 0x25, 0xCA, 0x22, 0x8D, 0x66, 0xEC, 0x88 + }, + { + 0x88, 0xE5, 0xEB, 0x01, 0xEB, 0x08, 0x68, 0x1C, + 0x64, 0xFF, 0xF3, 0x8C, 0xF9, 0x7D, 0x9A, 0xAC, + 0x9C, 0xDF, 0x7A, 0x2B, 0xE2, 0x3E, 0x1A, 0x73, + 0x1D, 0x02, 0xBB, 0xA2, 0x90, 0x39, 0xF1, 0x9B + }, + { + 0xF8, 0x9D, 0x9D, 0x13, 0x5B, 0x46, 0x2E, 0x3A, + 0x5B, 0xC5, 0xA3, 0xF6, 0xB9, 0x6D, 0xC0, 0xB5, + 0x71, 0x2C, 0x96, 0x50, 0xC2, 0x29, 0x31, 0x05, + 0x8A, 0xA2, 0x00, 0xA6, 0x91, 0x41, 0xC7, 0xBC + }, + { + 0x00, 0xB0, 0xBD, 0x82, 0xA6, 0x46, 0x8D, 0x79, + 0xC6, 0x9A, 0xFF, 0xE9, 0xF9, 0xCC, 0x6C, 0x73, + 0x35, 0x35, 0x64, 0xD0, 0x45, 0xB5, 0x0B, 0x97, + 0x9D, 0x35, 0x42, 0x9E, 0x83, 0x1D, 0x3F, 0x22 + }, + { + 0x71, 0x72, 0xF5, 0xBB, 0xCD, 0x0C, 0xB7, 0xE4, + 0xB3, 0x37, 0x9B, 0x50, 0x10, 0xAA, 0x76, 0xBD, + 0x4E, 0xF4, 0x90, 0x7A, 0x93, 0xC5, 0x00, 0xD2, + 0xF8, 0xB6, 0xCE, 0x39, 0xC4, 0x5B, 0x97, 0x6D + }, + { + 0xF4, 0x92, 0x20, 0x91, 0xC3, 0x2C, 0x48, 0x3C, + 0x72, 0x38, 0x48, 0x16, 0x79, 0x9C, 0x4B, 0x1C, + 0x94, 0x60, 0x6B, 0x1D, 0x5F, 0xBA, 0xCF, 0xF5, + 0xE0, 0x88, 0x1D, 0xB6, 0x95, 0xCF, 0xC2, 0x28 + }, + { + 0x5A, 0xAA, 0x4A, 0xC5, 0x90, 0x12, 0xFC, 0xFA, + 0x11, 0x14, 0x33, 0x86, 0x06, 0x11, 0xD1, 0x7F, + 0xD4, 0xE2, 0x33, 0x80, 0xE3, 0x9C, 0x25, 0x87, + 0x3B, 0xD3, 0x47, 0xD5, 0x64, 0x4B, 0x64, 0xAA + }, + { + 0xA4, 0xAF, 0x4E, 0xC1, 0xDC, 0xDD, 0x6A, 0xA1, + 0xAD, 0xD4, 0xDC, 0x45, 0x50, 0x04, 0xB1, 0xFA, + 0x32, 0xF7, 0x63, 0x36, 0x3D, 0xC9, 0xBE, 0xB2, + 0x12, 0xDB, 0xD9, 0x21, 0xCA, 0x60, 0x1D, 0xB0 + }, + { + 0xF4, 0x98, 0x0B, 0x59, 0xD2, 0x8A, 0xEC, 0x2F, + 0xB0, 0x99, 0x74, 0x57, 0x8E, 0xB8, 0x63, 0x3D, + 0x62, 0x8F, 0x17, 0xDC, 0xCD, 0x9C, 0x8A, 0x02, + 0xD1, 0x47, 0xCD, 0x92, 0x5A, 0xA9, 0x57, 0x57 + }, + { + 0x29, 0x8B, 0x9E, 0x51, 0x31, 0x0B, 0xE4, 0x6C, + 0xB5, 0xAC, 0x2D, 0x11, 0xBE, 0x98, 0x19, 0xDB, + 0xE8, 0xAE, 0xEB, 0x94, 0x94, 0xC0, 0x61, 0x90, + 0x8C, 0x55, 0x8E, 0xC3, 0xBB, 0xFF, 0xDA, 0x07 + }, + { + 0x69, 0x61, 0x51, 0x7C, 0xDF, 0x3C, 0x28, 0x4E, + 0xD3, 0xB6, 0x42, 0xA6, 0xCC, 0x74, 0xDC, 0xBC, + 0xFD, 0xE0, 0xD9, 0x26, 0x2F, 0x36, 0x33, 0xB4, + 0x91, 0xE3, 0xFA, 0x86, 0x07, 0x6E, 0xD7, 0xD1 + }, + { + 0xFF, 0xFD, 0x29, 0x27, 0x31, 0x17, 0xA3, 0x01, + 0x9D, 0x7F, 0x29, 0xBB, 0x93, 0x05, 0x06, 0x56, + 0xAD, 0x2B, 0x91, 0xAB, 0xB7, 0xE5, 0x5A, 0xAE, + 0x33, 0x04, 0x7D, 0x27, 0x5A, 0xB8, 0x13, 0xBF + }, + { + 0x85, 0xA4, 0x59, 0x61, 0x18, 0x10, 0x68, 0x98, + 0x81, 0x41, 0xE5, 0x19, 0xF5, 0x30, 0x12, 0x83, + 0x23, 0x68, 0x43, 0xFB, 0xDA, 0x0A, 0xF2, 0x63, + 0x10, 0x49, 0x94, 0xB6, 0xAB, 0xE2, 0xE8, 0x80 + }, + { + 0x75, 0x2E, 0x12, 0x88, 0x6A, 0xE2, 0xE5, 0xEC, + 0x3E, 0x87, 0x32, 0x50, 0xF6, 0xA2, 0xF7, 0xF0, + 0x6F, 0x91, 0xA4, 0x8F, 0x47, 0x22, 0x61, 0xF0, + 0x90, 0xAD, 0x16, 0x89, 0xE9, 0xE2, 0xDC, 0xE3 + }, + { + 0xD3, 0xF4, 0x49, 0x69, 0x79, 0xBB, 0x52, 0xBE, + 0x23, 0xA9, 0x5C, 0xF0, 0xB7, 0xB1, 0xB5, 0x18, + 0xAA, 0xF5, 0x85, 0x70, 0xA4, 0x6B, 0x84, 0xB5, + 0xEE, 0x2B, 0x6B, 0x67, 0x8E, 0xE7, 0x80, 0xFE + }, + { + 0xA2, 0x72, 0xE8, 0x57, 0xBF, 0xB5, 0xE9, 0xF8, + 0xD8, 0x67, 0x8C, 0xB0, 0x5C, 0xEB, 0x16, 0x44, + 0x28, 0x28, 0xC1, 0xBC, 0xE5, 0xE1, 0x11, 0x67, + 0xA8, 0x66, 0xE9, 0xC5, 0x54, 0x73, 0x95, 0x55 + }, + { + 0x66, 0xAB, 0xDB, 0xC5, 0xA7, 0x80, 0xBA, 0x79, + 0x83, 0xD8, 0x3C, 0x4A, 0x2C, 0x72, 0x5B, 0x8C, + 0x86, 0xAF, 0xB6, 0xA6, 0x08, 0xB7, 0x4D, 0xB6, + 0xE1, 0x33, 0xD3, 0x4B, 0xC1, 0x52, 0x76, 0xE6 + }, + { + 0xA5, 0xF7, 0xD5, 0x11, 0x5E, 0x98, 0xBD, 0xC6, + 0xF9, 0xB4, 0xBF, 0x74, 0xF9, 0xD1, 0x68, 0x0D, + 0xA3, 0xAF, 0x63, 0x0C, 0xA5, 0x25, 0x86, 0x02, + 0xEF, 0xFA, 0xF9, 0xCD, 0xC9, 0xBC, 0xF1, 0xC6 + }, + { + 0xBF, 0x15, 0x09, 0xB4, 0xD9, 0x1B, 0xED, 0x95, + 0x2C, 0x65, 0x45, 0x64, 0xA1, 0x0D, 0xD5, 0xE4, + 0x91, 0xC4, 0xBB, 0x4A, 0x12, 0xD1, 0xC8, 0xC3, + 0xE3, 0x94, 0xB4, 0x92, 0xE9, 0xD3, 0x1B, 0xDC + }, + { + 0x7A, 0x7B, 0xA3, 0xC4, 0x7B, 0xEE, 0x10, 0x20, + 0xE8, 0x66, 0xE0, 0xA9, 0xD8, 0xC1, 0x9F, 0x54, + 0x18, 0xC8, 0xE6, 0x56, 0x10, 0xE6, 0x64, 0x3C, + 0x07, 0x36, 0x87, 0x5D, 0x17, 0xA4, 0x34, 0xBF + }, + { + 0x93, 0x3C, 0xCE, 0xC7, 0x55, 0xA0, 0x9D, 0xB6, + 0x2D, 0xE8, 0x6E, 0x13, 0x21, 0x6E, 0xED, 0xE5, + 0x8A, 0xA4, 0x66, 0x39, 0x3A, 0x10, 0x5B, 0xBB, + 0x55, 0x07, 0xDC, 0x7D, 0x20, 0x0A, 0x44, 0xCE + }, + { + 0x2B, 0x17, 0x27, 0xCC, 0x64, 0xEA, 0xB9, 0x7F, + 0x0A, 0x38, 0xFB, 0xEA, 0xC7, 0x98, 0xD9, 0xF0, + 0x41, 0xA4, 0x21, 0x37, 0xE5, 0x2C, 0x9D, 0xCC, + 0xA4, 0x88, 0xA7, 0xFD, 0xC3, 0x4A, 0xC0, 0xE1 + }, + { + 0xCA, 0xDA, 0x33, 0x13, 0x7B, 0xA4, 0x18, 0xDC, + 0x06, 0x47, 0xBE, 0x33, 0xBB, 0x59, 0xCB, 0x66, + 0xFE, 0x16, 0x08, 0xEA, 0x5B, 0x74, 0xE2, 0xAB, + 0x4E, 0xB0, 0x6C, 0xD5, 0xBC, 0xEA, 0x56, 0xD0 + }, + { + 0xAB, 0x6F, 0x89, 0xEC, 0x4D, 0x07, 0x05, 0xA4, + 0x58, 0x26, 0xB9, 0xBB, 0xBF, 0xC6, 0x4C, 0x1F, + 0x30, 0x55, 0xA8, 0x74, 0x3C, 0xA5, 0x3F, 0x73, + 0xC2, 0xA0, 0x31, 0x2C, 0x3B, 0x60, 0xE7, 0x25 + }, + { + 0x5C, 0x52, 0xE9, 0x70, 0x41, 0x96, 0xE5, 0x63, + 0x88, 0x5E, 0xE4, 0xC0, 0x0E, 0x38, 0x69, 0x49, + 0x73, 0x30, 0x36, 0x55, 0x7C, 0xDA, 0x3E, 0xDE, + 0x2F, 0x3E, 0xBC, 0x28, 0x93, 0xE5, 0xD9, 0x98 + }, + { + 0xED, 0xA3, 0x59, 0x67, 0x1E, 0x87, 0xC6, 0x0F, + 0x8F, 0xDB, 0x21, 0x3C, 0xC8, 0x17, 0x93, 0x9A, + 0x04, 0x3A, 0x81, 0x05, 0x20, 0xCF, 0x88, 0x7C, + 0x15, 0xD4, 0x36, 0xF6, 0x8E, 0x97, 0xD5, 0x95 + }, + { + 0x99, 0x2D, 0x0F, 0x6A, 0xD5, 0x8D, 0xC8, 0xA5, + 0xC8, 0xD6, 0x9C, 0xCA, 0x73, 0xFD, 0x7B, 0xB5, + 0x7C, 0x27, 0xBA, 0x93, 0x50, 0x14, 0x03, 0x9C, + 0xEB, 0xE7, 0x56, 0x93, 0x7F, 0xDC, 0x5D, 0xC6 + }, + { + 0x6E, 0x3D, 0xE7, 0xDF, 0xBC, 0xEF, 0x21, 0xB0, + 0x02, 0xBB, 0xDA, 0x78, 0x7A, 0xEE, 0x89, 0xAC, + 0x84, 0xC7, 0xFF, 0x95, 0xAC, 0xFD, 0x37, 0x4B, + 0x51, 0x91, 0x0C, 0x60, 0x34, 0x8E, 0xA3, 0xF0 + }, + { + 0xDF, 0x58, 0xB2, 0x11, 0x33, 0x9E, 0x96, 0x65, + 0xA3, 0xB6, 0x0C, 0xAB, 0xF3, 0x4F, 0x0F, 0xAB, + 0xAC, 0x36, 0xD6, 0x33, 0x19, 0x8B, 0xF5, 0xEF, + 0xB7, 0xBF, 0xAF, 0xFA, 0x23, 0x3D, 0x40, 0xDC + }, + { + 0x5F, 0x70, 0xE3, 0xA5, 0xCD, 0xAF, 0x54, 0x3D, + 0xB8, 0x8C, 0xDF, 0xF1, 0x94, 0x94, 0xE5, 0x27, + 0xDF, 0x02, 0x05, 0xD3, 0x9C, 0xD2, 0x77, 0x17, + 0x9F, 0x2E, 0xDB, 0xF4, 0x1D, 0x15, 0x9C, 0x16 + }, + { + 0x25, 0xC9, 0x27, 0xB0, 0x9C, 0x91, 0x5E, 0x2A, + 0x40, 0xF8, 0x26, 0xC0, 0x1C, 0xB7, 0x2D, 0xF8, + 0xDF, 0x72, 0x17, 0x7C, 0xC4, 0xDB, 0xB8, 0x90, + 0x58, 0x7B, 0xA0, 0x1E, 0x44, 0x66, 0x8A, 0xAB + }, + { + 0x11, 0x93, 0x84, 0xD4, 0x11, 0x92, 0xBB, 0xCF, + 0x16, 0x2D, 0x82, 0xA0, 0xD0, 0x6E, 0x1B, 0xF5, + 0x46, 0x0A, 0xA4, 0xB6, 0x3D, 0xE3, 0x28, 0xEE, + 0x15, 0x47, 0x8A, 0x96, 0xDF, 0x9E, 0x6F, 0x78 + }, + { + 0x71, 0xA7, 0x73, 0x5F, 0xE7, 0x2D, 0x23, 0x29, + 0xE7, 0xE1, 0x42, 0xB5, 0x4B, 0x4C, 0x60, 0xB5, + 0x43, 0xD4, 0xB3, 0x08, 0x60, 0x9F, 0x14, 0xD7, + 0xC9, 0x02, 0xAC, 0xAE, 0xF4, 0x4E, 0xD3, 0x2E + }, + { + 0xFB, 0x20, 0x1D, 0xD9, 0x15, 0xA9, 0x5E, 0x0A, + 0x8D, 0x0E, 0x64, 0x28, 0x3D, 0xF2, 0xF4, 0x2F, + 0x69, 0x7E, 0xBD, 0x2F, 0x10, 0x4F, 0x4C, 0x3A, + 0x11, 0x32, 0xC4, 0x4E, 0x4A, 0x6D, 0x73, 0xF0 + }, + { + 0xAA, 0x6C, 0x1D, 0x10, 0xFA, 0x28, 0xC7, 0x4E, + 0x3C, 0xD7, 0x9D, 0xBB, 0x3D, 0xC4, 0xD9, 0x41, + 0x5A, 0x74, 0x6F, 0x6A, 0x85, 0xCF, 0x95, 0xE7, + 0x84, 0xEC, 0x73, 0x57, 0x8C, 0x24, 0x1E, 0xDC + }, + { + 0x9B, 0xCE, 0xE4, 0x81, 0x10, 0xEF, 0x46, 0xB2, + 0x82, 0x93, 0xB4, 0x64, 0x4F, 0xD7, 0xB3, 0xFD, + 0x57, 0x43, 0x2D, 0x7F, 0x97, 0xA9, 0x3B, 0x23, + 0x78, 0x47, 0x3D, 0xB0, 0x3A, 0x2F, 0x2F, 0x5F + }, + { + 0xC3, 0xC7, 0x4E, 0x39, 0xF0, 0x31, 0x13, 0x2A, + 0x2E, 0xA5, 0xE8, 0x97, 0xB1, 0x32, 0xF3, 0xC1, + 0xF7, 0x56, 0x3D, 0x47, 0xE7, 0x5A, 0xA0, 0x3C, + 0xF3, 0xCE, 0x9D, 0x0E, 0xDC, 0x08, 0xCC, 0x00 + }, + { + 0x45, 0x6B, 0xB9, 0x10, 0x62, 0x60, 0xBA, 0x98, + 0xE3, 0xD5, 0x50, 0x0C, 0x58, 0x19, 0x29, 0x46, + 0xB6, 0xFD, 0x6D, 0x84, 0x21, 0x46, 0x8E, 0x57, + 0x51, 0xE2, 0x3B, 0x1B, 0xD1, 0x9D, 0xEF, 0xDF + }, + { + 0x9C, 0x15, 0x22, 0xA7, 0x84, 0xD2, 0x99, 0x7E, + 0x8F, 0x7F, 0xC0, 0x0C, 0x92, 0xA1, 0xD5, 0xB2, + 0x22, 0x63, 0x8F, 0xE2, 0xAA, 0xFF, 0x82, 0x8F, + 0x14, 0xD9, 0x52, 0x9A, 0x2C, 0x87, 0x56, 0xA8 + }, + { + 0x4B, 0x54, 0x9E, 0x0B, 0x36, 0x57, 0x0F, 0x3C, + 0x4B, 0x59, 0xE5, 0xD5, 0x98, 0x29, 0x3F, 0x9F, + 0xD1, 0x9F, 0x94, 0xEC, 0xCA, 0xBC, 0x1E, 0x18, + 0x50, 0xB5, 0x36, 0xBA, 0x57, 0x89, 0x03, 0x51 + }, + { + 0x86, 0xB7, 0xAA, 0x41, 0x51, 0x3B, 0xF1, 0x07, + 0x58, 0x26, 0x33, 0xEE, 0x7D, 0xEF, 0xDF, 0x7B, + 0xB2, 0xD2, 0xBA, 0x57, 0x56, 0x43, 0xAB, 0xF8, + 0x82, 0xBE, 0xE1, 0xA7, 0x09, 0xBC, 0xC2, 0x73 + }, + { + 0x16, 0xA9, 0x5B, 0x5F, 0x52, 0x32, 0x61, 0x6A, + 0xE2, 0x49, 0xDC, 0x07, 0x3F, 0x9B, 0xE0, 0x46, + 0x8B, 0xF0, 0x28, 0x5E, 0xD8, 0x65, 0x07, 0x3C, + 0xFB, 0x03, 0xC0, 0xDC, 0xF9, 0xF9, 0x4A, 0x27 + }, + { + 0xA4, 0xAA, 0xA5, 0x7A, 0xCE, 0xDF, 0x74, 0x5E, + 0x58, 0x38, 0x23, 0x44, 0x8C, 0x21, 0xB7, 0x1A, + 0xC7, 0xB2, 0x9B, 0x2F, 0x00, 0xDB, 0x2B, 0x87, + 0xD6, 0x4A, 0xCA, 0x6B, 0x13, 0x11, 0xE1, 0x58 + }, + { + 0xF0, 0xAB, 0x09, 0x92, 0x89, 0x3E, 0xB5, 0x21, + 0x5B, 0x98, 0x35, 0xC5, 0x53, 0x66, 0xBE, 0x48, + 0x4F, 0xC5, 0xFE, 0x71, 0x0E, 0xFF, 0x25, 0xC6, + 0xA2, 0x21, 0x68, 0x3D, 0x11, 0xCC, 0x9F, 0x14 + }, + { + 0xF8, 0x23, 0x5B, 0xB8, 0xA4, 0x09, 0x53, 0xD0, + 0x4C, 0xA7, 0x7C, 0xFB, 0x1E, 0xAF, 0x9D, 0x24, + 0xC5, 0xF1, 0xBA, 0x8E, 0x86, 0xBE, 0xE3, 0x77, + 0xB8, 0xA9, 0x67, 0x58, 0x14, 0x69, 0x9A, 0x37 + }, + { + 0xF0, 0x88, 0xE7, 0x12, 0x2D, 0x92, 0x0F, 0xB8, + 0xD7, 0xC3, 0x9F, 0x49, 0xDC, 0xE5, 0x58, 0x30, + 0xD6, 0x38, 0x05, 0x1B, 0x2E, 0x79, 0x78, 0xB6, + 0x5A, 0xA1, 0xA5, 0x5D, 0x68, 0x1B, 0x28, 0x17 + }, + { + 0x7C, 0x02, 0x1C, 0x6C, 0x4C, 0x03, 0xC0, 0xA9, + 0x8D, 0x76, 0x2F, 0x0C, 0xDB, 0x47, 0x44, 0xEB, + 0xB7, 0xBC, 0x86, 0xBE, 0xA2, 0x40, 0xCE, 0xDD, + 0xBB, 0x00, 0xD9, 0x33, 0x85, 0xE0, 0xD7, 0xFE + }, + { + 0xCB, 0xBE, 0x41, 0xC7, 0x68, 0x92, 0x0A, 0x94, + 0x5F, 0x5A, 0x98, 0x6E, 0x06, 0x39, 0xDC, 0x52, + 0xD3, 0xE8, 0x0E, 0xB6, 0x9B, 0xC2, 0xE3, 0xBC, + 0x53, 0xDE, 0xAF, 0x54, 0x36, 0x3E, 0x5A, 0x36 + }, + { + 0x0D, 0xFC, 0x8A, 0x7E, 0x45, 0x47, 0x72, 0xA7, + 0x7F, 0x55, 0x4A, 0x57, 0x5C, 0x09, 0xEA, 0xF5, + 0x23, 0x66, 0xC8, 0x70, 0x3B, 0x86, 0xA8, 0x6C, + 0x4A, 0x16, 0x8F, 0x98, 0x98, 0xFD, 0x87, 0x10 + }, + { + 0x13, 0x6F, 0x1A, 0x61, 0xF3, 0x2F, 0xEE, 0x21, + 0xD7, 0xC9, 0xF4, 0x0D, 0xDD, 0xB9, 0x77, 0x46, + 0x3E, 0x3D, 0x8A, 0xAA, 0x9D, 0x52, 0x74, 0x70, + 0xFD, 0x5A, 0x79, 0x90, 0xB3, 0xE1, 0xA5, 0xBD + }, + { + 0xBF, 0x6D, 0xCB, 0xCB, 0x55, 0x84, 0xAB, 0xAA, + 0xC7, 0x73, 0x5A, 0x67, 0xC7, 0x04, 0x39, 0xEC, + 0xF2, 0x42, 0xBB, 0x46, 0x52, 0x0E, 0x96, 0x5D, + 0xDA, 0xA9, 0x09, 0x33, 0x58, 0xE1, 0xFA, 0xD3 + }, + { + 0x80, 0x1D, 0x61, 0x31, 0x61, 0x6E, 0x1A, 0xB7, + 0x57, 0x07, 0xEB, 0x40, 0xC4, 0x20, 0x38, 0x8F, + 0x66, 0x4C, 0x0B, 0x30, 0xAB, 0xED, 0x7C, 0xAA, + 0xA1, 0xDC, 0x28, 0xFD, 0x34, 0x62, 0xF5, 0xD7 + }, + { + 0xCE, 0x45, 0x83, 0x39, 0x9F, 0xA3, 0xCF, 0x13, + 0x99, 0xAE, 0x06, 0x5F, 0xD4, 0x29, 0xC1, 0x1E, + 0x0F, 0x4C, 0x16, 0xCA, 0x3E, 0x30, 0x15, 0x60, + 0x85, 0x88, 0x42, 0x1F, 0xCC, 0xE7, 0x7E, 0xE9 + }, + { + 0xF7, 0xF0, 0xC9, 0x7B, 0x35, 0xDB, 0xAF, 0x51, + 0x80, 0xB0, 0x15, 0x74, 0x94, 0x19, 0x68, 0x5D, + 0xF1, 0xC3, 0x30, 0x18, 0xAA, 0xB2, 0xD7, 0xED, + 0x99, 0x8E, 0x8E, 0x6D, 0x61, 0xB7, 0x2F, 0x65 + }, + { + 0xE0, 0x14, 0x46, 0xB8, 0x75, 0xCC, 0xDE, 0x41, + 0x50, 0x69, 0x26, 0x51, 0xE3, 0x17, 0x76, 0xDE, + 0x09, 0x90, 0x22, 0x11, 0x6B, 0x11, 0x3D, 0x1F, + 0xBD, 0x2B, 0xDE, 0x13, 0x9D, 0x90, 0x95, 0x13 + }, + { + 0x06, 0xD5, 0xAF, 0x78, 0x37, 0x9D, 0xC1, 0x38, + 0x1E, 0xDA, 0x70, 0x51, 0xFF, 0x37, 0xA9, 0x75, + 0xBF, 0x72, 0x4F, 0xCA, 0xFD, 0x9A, 0x51, 0x1B, + 0x2B, 0x52, 0x7C, 0xE8, 0x97, 0xDC, 0x03, 0xD4 + }, + { + 0x92, 0xF2, 0x8B, 0x0B, 0xCD, 0x93, 0xB3, 0xB0, + 0x08, 0xD0, 0x25, 0xBF, 0xBB, 0xBE, 0x4E, 0xDF, + 0xB8, 0xBC, 0x60, 0x79, 0x40, 0xBA, 0x59, 0x68, + 0x5C, 0xA7, 0x86, 0x85, 0x07, 0x16, 0xBD, 0xFF + }, + { + 0x60, 0xCF, 0x51, 0x16, 0xA8, 0xBB, 0x26, 0x17, + 0xDD, 0x66, 0x15, 0xC1, 0xC5, 0x6F, 0xC6, 0x1D, + 0x88, 0x60, 0x2C, 0x47, 0xB1, 0x52, 0x64, 0x33, + 0x0E, 0x5A, 0xFE, 0x27, 0x1D, 0x0B, 0xB7, 0xAB + }, + { + 0xB5, 0xD5, 0x79, 0x86, 0x3F, 0x9A, 0xFB, 0x22, + 0x2B, 0x37, 0xE2, 0x37, 0x21, 0x1C, 0xED, 0xDC, + 0x4B, 0x23, 0x3B, 0x27, 0xC6, 0x0D, 0x70, 0x70, + 0xE5, 0xA9, 0x2C, 0x16, 0x5F, 0x11, 0x73, 0x86 + }, + { + 0xAC, 0x6E, 0x2F, 0xE9, 0x59, 0xC5, 0x96, 0xBE, + 0x0B, 0xCB, 0x0A, 0xE7, 0xE7, 0x0A, 0x8A, 0xFC, + 0x89, 0x9D, 0xCA, 0x95, 0x02, 0xCF, 0xD0, 0xFD, + 0x88, 0xA9, 0x4E, 0x95, 0xF5, 0x42, 0xCD, 0xF3 + }, + { + 0xF7, 0xCC, 0xE0, 0xF6, 0x17, 0x63, 0x75, 0xC0, + 0x42, 0xFD, 0x1A, 0x16, 0xA8, 0x52, 0x83, 0xE2, + 0x4B, 0xDB, 0x1A, 0x53, 0x74, 0x2A, 0xCC, 0x13, + 0xE4, 0x1C, 0xAD, 0x7E, 0x6B, 0xE1, 0xA1, 0xAA + }, + { + 0xC4, 0xD7, 0xB7, 0xFE, 0x8D, 0x9A, 0x82, 0x3F, + 0x36, 0x52, 0x16, 0xC5, 0xCD, 0xEB, 0x5A, 0x62, + 0xB1, 0x44, 0x46, 0xC1, 0x30, 0x2F, 0x43, 0x34, + 0xA7, 0x42, 0x86, 0x6E, 0xCE, 0x08, 0xAB, 0x32 + }, + { + 0xA3, 0x3F, 0x6F, 0xC1, 0x42, 0xA1, 0x44, 0xB8, + 0xB0, 0xF5, 0x5B, 0x15, 0x51, 0x09, 0x80, 0xBD, + 0xA1, 0xAE, 0xDC, 0x40, 0x0A, 0x3D, 0x6E, 0x07, + 0x7D, 0xD0, 0x0A, 0x97, 0xF0, 0x1D, 0xC6, 0x60 + }, + { + 0x32, 0xDA, 0x78, 0xE3, 0xD2, 0x95, 0x5D, 0x88, + 0x4D, 0x37, 0x12, 0xF3, 0xBD, 0x9D, 0x71, 0x48, + 0x13, 0x82, 0x26, 0xE2, 0x7C, 0x40, 0xC4, 0x13, + 0xEF, 0xE2, 0xC1, 0x0F, 0xA8, 0xC6, 0x1D, 0xA0 + }, + { + 0xCF, 0xBE, 0xBC, 0xD9, 0xCA, 0x12, 0x9F, 0x68, + 0xBC, 0x86, 0xBF, 0x8E, 0x8D, 0xD9, 0x57, 0x3C, + 0x4B, 0xBD, 0x6B, 0xF4, 0x8F, 0x74, 0x1D, 0xA4, + 0x66, 0xAB, 0xC4, 0x0F, 0x35, 0xD9, 0xB3, 0x52 + }, + { + 0x92, 0xD1, 0xED, 0xD2, 0x67, 0x95, 0xCF, 0xF4, + 0x2D, 0x0C, 0xB0, 0xA3, 0xF4, 0xEA, 0x94, 0x1D, + 0x6A, 0xEC, 0x76, 0x54, 0x50, 0x9D, 0x51, 0x3F, + 0x7B, 0xB0, 0x82, 0x09, 0xA2, 0x09, 0x9B, 0x1A + }, + { + 0x0E, 0xB3, 0x33, 0xB0, 0xF3, 0x69, 0x77, 0x3D, + 0xBB, 0x0C, 0x7D, 0x50, 0xF3, 0x0E, 0x46, 0x7B, + 0xB0, 0xC5, 0x1F, 0x1C, 0x65, 0xA0, 0x89, 0xAA, + 0x18, 0xFC, 0xAB, 0x90, 0xBE, 0xAE, 0x19, 0x5E + }, + { + 0x99, 0x32, 0x81, 0x3B, 0x0D, 0xF9, 0x9B, 0xAD, + 0xDD, 0x83, 0x4C, 0xC9, 0xED, 0xF7, 0xB2, 0x69, + 0x8F, 0x29, 0x9C, 0x55, 0xF3, 0x87, 0x7F, 0xBE, + 0xAC, 0x11, 0x8E, 0xD8, 0x92, 0xB5, 0x8C, 0x6F + }, + { + 0xFA, 0xDC, 0x66, 0x25, 0xCC, 0x52, 0x30, 0xC9, + 0xD2, 0x8B, 0x6C, 0x6A, 0x6A, 0x5B, 0x6E, 0x1D, + 0x73, 0x8C, 0xCD, 0x0E, 0x07, 0xD9, 0xAE, 0x8D, + 0x41, 0xFB, 0x42, 0x69, 0x3F, 0xE1, 0x42, 0x5C + }, + { + 0x71, 0xF7, 0x3E, 0x1D, 0xD8, 0xE8, 0xE8, 0xD2, + 0xBD, 0xA7, 0xD4, 0x8C, 0x70, 0x8D, 0x13, 0x32, + 0x36, 0xB1, 0xDC, 0xC2, 0x30, 0x14, 0xFE, 0xA3, + 0xE4, 0x59, 0x2A, 0x4E, 0x48, 0xCD, 0xD0, 0xAD + }, + { + 0x93, 0xFE, 0x72, 0xA6, 0x51, 0x03, 0x87, 0x3D, + 0xBA, 0x5D, 0xA5, 0x5F, 0x8E, 0x07, 0x99, 0x9B, + 0x22, 0x00, 0x26, 0xB3, 0x17, 0xC4, 0xB4, 0x84, + 0xBD, 0x3A, 0x40, 0x15, 0x4D, 0x0C, 0x4A, 0x51 + }, + { + 0x25, 0x70, 0x56, 0x75, 0xDF, 0x3B, 0x60, 0xBE, + 0xD8, 0x5D, 0x23, 0xA2, 0xB2, 0x37, 0x2C, 0x89, + 0x87, 0x9F, 0xA0, 0x49, 0xFF, 0x07, 0xD8, 0x1A, + 0x9F, 0xF0, 0x72, 0x49, 0x91, 0xEC, 0xF2, 0x09 + }, + { + 0x3E, 0x25, 0xB7, 0x5B, 0x8F, 0x6F, 0x98, 0x77, + 0x2B, 0xD0, 0x7F, 0xBD, 0x93, 0x99, 0x6C, 0x32, + 0xDC, 0xA2, 0x64, 0x70, 0xF0, 0x25, 0x15, 0x22, + 0x21, 0xC0, 0x21, 0x62, 0xF2, 0x77, 0x74, 0xE6 + }, + { + 0x3E, 0x5D, 0x51, 0x94, 0xB6, 0x3B, 0xBA, 0x0E, + 0xAC, 0xC3, 0x7A, 0x99, 0xB5, 0x90, 0xEC, 0x88, + 0x85, 0xDE, 0xB2, 0x0A, 0xB5, 0x6F, 0xC9, 0xDC, + 0xA5, 0xDA, 0x20, 0xFC, 0xB0, 0x73, 0x28, 0xE9 + }, + { + 0x5C, 0xCE, 0xDD, 0x80, 0xEB, 0x09, 0x3F, 0xB2, + 0x86, 0x59, 0xA7, 0x1B, 0xEE, 0x2D, 0x32, 0xC3, + 0x41, 0x5F, 0x1F, 0x8B, 0x85, 0x02, 0x65, 0xC3, + 0x88, 0x64, 0xFE, 0x9C, 0xE7, 0x38, 0xC3, 0x0C + }, + { + 0x9E, 0x86, 0x81, 0x17, 0xF5, 0x4B, 0x3A, 0xA2, + 0x24, 0xFF, 0x18, 0xF5, 0x5B, 0xE4, 0x38, 0x6B, + 0x59, 0xD3, 0xAA, 0x24, 0xC1, 0x2A, 0x76, 0xCA, + 0x2A, 0x8F, 0xC1, 0x2E, 0xD1, 0x4D, 0xDC, 0xCA + }, + { + 0x03, 0x93, 0x40, 0x98, 0x2E, 0x53, 0xA4, 0x33, + 0x03, 0x32, 0x37, 0x5A, 0xF3, 0x3B, 0x34, 0xF1, + 0x1E, 0xF6, 0xF7, 0x3D, 0xCA, 0x8D, 0x6A, 0x7A, + 0x5C, 0xB9, 0x0B, 0x45, 0x8B, 0xD9, 0x24, 0xB3 + }, + { + 0x1F, 0x49, 0x2A, 0xBA, 0x6C, 0xE5, 0x5B, 0x49, + 0x6B, 0x7D, 0xB2, 0x28, 0xE6, 0x5A, 0x4A, 0xC7, + 0xAB, 0x1B, 0xB4, 0x66, 0x4A, 0x81, 0x52, 0x8A, + 0xB4, 0x30, 0xA3, 0xD7, 0x4F, 0x4E, 0xE6, 0x1E + }, + { + 0x33, 0x2C, 0xF0, 0x76, 0xAD, 0x2E, 0x42, 0x51, + 0xEB, 0x2C, 0x7A, 0x3F, 0xCB, 0x67, 0x6B, 0x99, + 0x5D, 0x74, 0xE5, 0x15, 0x9E, 0xF2, 0x19, 0xAF, + 0xC6, 0x2D, 0x2A, 0xA6, 0x18, 0x49, 0x32, 0xB2 + }, + { + 0x28, 0x23, 0xFF, 0x1A, 0x83, 0x68, 0x36, 0xF3, + 0x53, 0x90, 0xE9, 0xA0, 0x2A, 0xE7, 0x11, 0x4D, + 0xDD, 0x61, 0x9D, 0x69, 0x45, 0xE2, 0x12, 0x66, + 0x8D, 0x80, 0x65, 0x1C, 0xD8, 0x90, 0x2E, 0x97 + }, + { + 0xE1, 0xE1, 0x66, 0x52, 0x35, 0x86, 0xA5, 0xCE, + 0xF4, 0x69, 0x78, 0x80, 0x6E, 0xD6, 0xAA, 0xC3, + 0x94, 0x28, 0x59, 0x2C, 0xD5, 0xBE, 0x59, 0x11, + 0xC7, 0xFC, 0x01, 0xA7, 0x2F, 0x88, 0x9D, 0xAE + }, + { + 0x14, 0x72, 0x92, 0x71, 0xB8, 0x77, 0xA0, 0xA8, + 0x55, 0x78, 0xED, 0xB7, 0x86, 0xA3, 0xEA, 0x94, + 0xDE, 0x6E, 0xB0, 0xF9, 0xE9, 0x3A, 0x50, 0x3A, + 0x32, 0x5D, 0x4A, 0x17, 0x36, 0x1D, 0x29, 0x04 + }, + { + 0xF6, 0x49, 0x90, 0xB3, 0x1D, 0x63, 0x62, 0xFF, + 0x82, 0x7A, 0xD5, 0x85, 0xEF, 0xE1, 0x4B, 0x56, + 0x26, 0xC6, 0x09, 0x7C, 0x2E, 0xC6, 0xAA, 0xD3, + 0xA2, 0x36, 0x46, 0xC9, 0x58, 0x50, 0xC2, 0xF5 + }, + { + 0xEB, 0x70, 0x51, 0xF3, 0x18, 0x55, 0xB7, 0x6E, + 0x30, 0x44, 0xE6, 0x9E, 0x06, 0x74, 0xD5, 0x30, + 0xA5, 0xCB, 0xEB, 0xFF, 0x8B, 0x88, 0x0C, 0x9B, + 0x9E, 0x47, 0xDB, 0xF2, 0x56, 0x8F, 0xE7, 0xD6 + }, + { + 0xAB, 0x83, 0xA8, 0xD9, 0xD0, 0x21, 0x28, 0xE7, + 0x18, 0x7A, 0xC1, 0x46, 0xA6, 0x4F, 0xB8, 0xCD, + 0xF9, 0xE4, 0xC6, 0xD5, 0x9C, 0xEA, 0xB0, 0x9F, + 0x19, 0xB2, 0x2D, 0x1E, 0xA7, 0xC2, 0x29, 0x90 + }, + { + 0x21, 0x2A, 0xF7, 0xA4, 0x3B, 0x27, 0x20, 0x2B, + 0x21, 0x73, 0xCE, 0xCE, 0x1C, 0x29, 0x5B, 0xE0, + 0x7A, 0x66, 0xD3, 0x42, 0xDC, 0xC5, 0xA9, 0xBA, + 0xE4, 0x7C, 0x17, 0xB1, 0xCA, 0x7F, 0xC8, 0x15 + }, + { + 0xDA, 0x20, 0xD2, 0x36, 0x1F, 0xDA, 0x3B, 0xB7, + 0x07, 0x3F, 0x51, 0xB0, 0x83, 0xE8, 0x09, 0x30, + 0xB9, 0x33, 0x68, 0x80, 0xD4, 0xE5, 0x0D, 0xEA, + 0xA5, 0x6E, 0xD9, 0xBE, 0x68, 0xFF, 0x54, 0x75 + }, + { + 0x7E, 0x76, 0x04, 0xCC, 0x3B, 0xA2, 0x74, 0xAE, + 0xCE, 0xA8, 0x62, 0xE7, 0xDB, 0x27, 0xB2, 0xF5, + 0x8A, 0xAF, 0x96, 0xAA, 0x06, 0x87, 0xCD, 0xBC, + 0xBD, 0x1D, 0xD4, 0x96, 0xBC, 0xB4, 0x06, 0x0E + }, + { + 0xA9, 0x76, 0x53, 0x4B, 0x8B, 0x58, 0x95, 0xD2, + 0xE5, 0xDB, 0x53, 0x80, 0xC3, 0x8B, 0x0D, 0x97, + 0x75, 0x17, 0x55, 0x8E, 0x59, 0xE9, 0xC1, 0x9E, + 0xDE, 0xCE, 0xE2, 0xB2, 0x51, 0xC0, 0xBA, 0x16 + }, + { + 0xA5, 0x30, 0x9F, 0x26, 0x63, 0xBA, 0x71, 0x5F, + 0x08, 0x80, 0xA0, 0xA6, 0xFA, 0x7C, 0xEB, 0x3F, + 0x11, 0xF0, 0xA6, 0x28, 0x7C, 0x44, 0x32, 0x85, + 0xC5, 0x2E, 0x85, 0xFA, 0x08, 0xB6, 0x85, 0x4D + }, + { + 0xEB, 0xAA, 0xF8, 0x71, 0xFA, 0x7F, 0xF6, 0x07, + 0xF8, 0xBC, 0xBD, 0xB6, 0x3A, 0x93, 0xAC, 0xE7, + 0xE8, 0x7B, 0xEA, 0x60, 0x57, 0x2F, 0x7B, 0x8D, + 0x79, 0x55, 0x25, 0xFF, 0x47, 0x99, 0xE0, 0x73 + }, + { + 0xBE, 0x1D, 0xE7, 0xED, 0x49, 0x3D, 0xED, 0x8B, + 0x74, 0xB5, 0x9F, 0x7E, 0xED, 0x01, 0x23, 0xBF, + 0x32, 0x69, 0xAA, 0x63, 0xEC, 0xEB, 0x8D, 0x3C, + 0xE3, 0x97, 0x96, 0x36, 0xD1, 0xF8, 0x89, 0xFB + }, + { + 0x00, 0x8E, 0x89, 0x57, 0x52, 0xF8, 0xEE, 0xCA, + 0x2E, 0x51, 0x6D, 0x67, 0x8A, 0xCE, 0x86, 0xE2, + 0xA3, 0xD7, 0xF5, 0x6C, 0xBC, 0x97, 0x73, 0x9F, + 0xA2, 0x04, 0x4C, 0x58, 0x69, 0x4F, 0x68, 0x05 + }, + { + 0xDE, 0x58, 0x6F, 0x4D, 0xA8, 0xCE, 0x88, 0xD7, + 0xA9, 0xB9, 0x80, 0x0E, 0x3C, 0xED, 0x61, 0x93, + 0x17, 0x5E, 0x11, 0x30, 0x34, 0x36, 0x29, 0x4D, + 0x34, 0xC9, 0xFA, 0x19, 0x6E, 0xE1, 0xCC, 0x16 + }, + { + 0x5B, 0x20, 0x24, 0xAE, 0x6D, 0xE8, 0x79, 0x01, + 0xB9, 0xC0, 0x9F, 0x3D, 0x92, 0x58, 0xED, 0x08, + 0x1E, 0x37, 0x91, 0x9F, 0xD2, 0x24, 0x3F, 0xEB, + 0x0B, 0x60, 0xCA, 0x17, 0xF9, 0x64, 0xE4, 0x8E + }, + { + 0x10, 0x7B, 0x19, 0x9E, 0xD3, 0x87, 0x49, 0x3F, + 0xA3, 0x23, 0x03, 0x6B, 0xCF, 0xD1, 0xCC, 0xB1, + 0x46, 0xEA, 0x7F, 0xBB, 0xB8, 0x37, 0x66, 0x9F, + 0x99, 0x76, 0x28, 0xE5, 0x26, 0x6D, 0x07, 0x2C + }, + { + 0xF7, 0x07, 0xD8, 0xF6, 0x69, 0xF7, 0x02, 0xE4, + 0xCF, 0x03, 0x8B, 0xE4, 0x36, 0xA8, 0x77, 0xEF, + 0x89, 0xE7, 0x4F, 0xB8, 0x3E, 0x32, 0x5E, 0x6E, + 0xFA, 0x68, 0x1F, 0xD0, 0xA8, 0x32, 0x22, 0x3E + }, + { + 0xBF, 0xB0, 0x1D, 0x73, 0x6E, 0x22, 0x80, 0x25, + 0xC0, 0x94, 0xC9, 0xD2, 0xF4, 0x69, 0xF3, 0x95, + 0xB8, 0x15, 0x3B, 0xD9, 0x09, 0xD0, 0xC5, 0xA3, + 0xBD, 0xCC, 0x1D, 0x47, 0x9C, 0xBE, 0x5C, 0x7A + }, + { + 0xFB, 0xB3, 0xA6, 0xD9, 0xD1, 0x62, 0x83, 0xBE, + 0xFB, 0x69, 0xE9, 0x9C, 0x19, 0x13, 0xD4, 0x7A, + 0x30, 0x5E, 0x0B, 0x6E, 0x70, 0x85, 0x1F, 0x95, + 0x16, 0x76, 0xBF, 0xDC, 0x67, 0xA0, 0x6F, 0x23 + }, + { + 0xEC, 0x3F, 0x5A, 0x17, 0x77, 0xFD, 0x14, 0xA3, + 0xEC, 0xD0, 0x6B, 0xE5, 0xE1, 0x9B, 0x06, 0xDA, + 0x24, 0xEE, 0x70, 0x60, 0xBC, 0xC6, 0x3E, 0xDF, + 0xE2, 0x71, 0x72, 0x67, 0xA1, 0x79, 0x7D, 0x9B + }, + { + 0x20, 0x5D, 0xBB, 0x1C, 0x8E, 0xD2, 0xD0, 0xC6, + 0xC5, 0xE1, 0xCC, 0x55, 0x15, 0x03, 0x1F, 0x3D, + 0xB0, 0x98, 0x60, 0xE7, 0x8B, 0x6A, 0x64, 0x40, + 0xAD, 0xA2, 0x86, 0xF3, 0x2B, 0x00, 0xE2, 0x5E + }, + { + 0xFD, 0xC7, 0x25, 0x55, 0x1D, 0x9B, 0x2C, 0xAD, + 0xB1, 0xA2, 0x90, 0x15, 0xEE, 0x59, 0xEE, 0xBC, + 0xEC, 0x82, 0xAF, 0x93, 0x26, 0xB8, 0x97, 0xF8, + 0x25, 0x47, 0xA8, 0x98, 0x04, 0x99, 0x3D, 0x02 + }, + { + 0x47, 0x93, 0x16, 0x1D, 0x71, 0xB7, 0xB1, 0x0D, + 0x95, 0xA5, 0x44, 0x58, 0x31, 0x63, 0x05, 0x56, + 0x18, 0xEB, 0x74, 0xB9, 0xE0, 0x45, 0x77, 0xD8, + 0xB7, 0xF3, 0x96, 0x6F, 0xAC, 0xAA, 0xFD, 0x9F + }, + { + 0x94, 0xBC, 0x92, 0x0C, 0x3F, 0x50, 0xAA, 0xFB, + 0xE9, 0xD7, 0xCA, 0x74, 0x2F, 0x88, 0xFA, 0xF6, + 0x8C, 0xF5, 0xD9, 0x00, 0x7E, 0xC0, 0x07, 0x1B, + 0xE5, 0x85, 0x0E, 0x81, 0x7D, 0x9C, 0xAF, 0x27 + }, + { + 0xF3, 0x1F, 0x12, 0xB2, 0x81, 0x85, 0xB0, 0x8B, + 0xF4, 0xD9, 0x03, 0xE4, 0x33, 0xFB, 0x58, 0xAA, + 0x1C, 0xD7, 0x5B, 0xB8, 0xB7, 0xB7, 0x1C, 0x33, + 0x5D, 0x5E, 0x64, 0xB2, 0x30, 0x3A, 0x5B, 0x9A + }, + { + 0x0F, 0xD4, 0x93, 0x4F, 0xBA, 0xCA, 0xE4, 0x37, + 0xAE, 0x23, 0x84, 0x1C, 0x7A, 0x56, 0xF1, 0x9D, + 0xF8, 0xAD, 0x92, 0xFF, 0x45, 0x4A, 0x59, 0xA8, + 0x69, 0x76, 0x43, 0x50, 0x1C, 0x71, 0x0B, 0x6A + }, + { + 0xEB, 0x6B, 0x7F, 0x54, 0xDF, 0x3E, 0x91, 0x03, + 0x96, 0x54, 0x03, 0x70, 0x5B, 0x4C, 0x35, 0x07, + 0xAA, 0xE5, 0x87, 0xB5, 0x0C, 0xE2, 0x68, 0xA9, + 0x27, 0xA7, 0x6D, 0xA9, 0x18, 0xCF, 0x4B, 0x0F + }, + { + 0x5D, 0xDB, 0x42, 0x20, 0x6C, 0x7C, 0x0A, 0x28, + 0x36, 0x41, 0x32, 0x55, 0xFC, 0xDE, 0x75, 0xA5, + 0x44, 0x37, 0x75, 0x55, 0xC8, 0xBE, 0x28, 0x60, + 0xE5, 0x85, 0x34, 0xB4, 0xF6, 0xD5, 0xCB, 0x0F + }, + { + 0xBE, 0x5E, 0xA7, 0x1D, 0x9B, 0x20, 0xBB, 0x60, + 0xD5, 0x3C, 0x64, 0x92, 0xA2, 0x82, 0x85, 0x50, + 0xA5, 0x29, 0xC1, 0x5A, 0xAD, 0x44, 0xC6, 0xEA, + 0xF3, 0x5C, 0x53, 0xED, 0xAD, 0x8E, 0x76, 0x7F + }, + { + 0xA1, 0xD6, 0x70, 0x24, 0xCE, 0x9D, 0x19, 0xB1, + 0x91, 0x8D, 0xB5, 0x37, 0x32, 0xA8, 0x01, 0xFC, + 0x46, 0xB9, 0x69, 0xC4, 0x7F, 0x2D, 0xAA, 0x3A, + 0xC9, 0xDB, 0xE5, 0x56, 0x18, 0x62, 0x97, 0x49 + }, + { + 0xAE, 0xB5, 0x49, 0x9D, 0x81, 0xF1, 0x4C, 0xB1, + 0x0C, 0x25, 0x39, 0x41, 0x1C, 0xBE, 0x3E, 0x71, + 0x16, 0x72, 0x93, 0x45, 0x85, 0x43, 0xBF, 0xA4, + 0xCA, 0x1F, 0x95, 0x84, 0x62, 0x5F, 0xD4, 0xC6 + }, + { + 0xE3, 0x60, 0xB1, 0xF2, 0x96, 0x91, 0xAC, 0x67, + 0x47, 0x93, 0xC9, 0x7E, 0x51, 0xC1, 0x07, 0x1B, + 0x50, 0xE7, 0x6E, 0x6A, 0x11, 0xCC, 0xDE, 0x36, + 0xB5, 0xED, 0x84, 0xF3, 0xB8, 0x81, 0x96, 0xC7 + }, + { + 0xE1, 0xEE, 0x53, 0x26, 0x87, 0x21, 0x70, 0x57, + 0x98, 0xA5, 0x38, 0x8D, 0xAA, 0x1D, 0xE6, 0xCF, + 0xA1, 0x4C, 0x7E, 0x0B, 0x80, 0xD7, 0xF6, 0x52, + 0xEC, 0xCD, 0x9A, 0x2E, 0xE7, 0x70, 0x42, 0x61 + }, + { + 0x32, 0x26, 0x1E, 0x6D, 0x88, 0x8F, 0x10, 0x9C, + 0x7F, 0x08, 0xB8, 0xEA, 0xB4, 0xE9, 0x8F, 0x34, + 0xB4, 0x23, 0xB1, 0xC7, 0x5C, 0x8F, 0x55, 0x5B, + 0x24, 0x0B, 0x5B, 0x23, 0xFF, 0x1E, 0x71, 0xC6 + }, + { + 0xD1, 0x5A, 0xCF, 0x84, 0x9E, 0x35, 0x92, 0x91, + 0x7D, 0xD9, 0xDE, 0xEA, 0xB2, 0x61, 0xB6, 0x33, + 0xE9, 0xC7, 0x52, 0x6D, 0x36, 0x0F, 0xCC, 0x3C, + 0x32, 0x30, 0x17, 0x35, 0xCA, 0xE2, 0x74, 0x34 + }, + { + 0x4A, 0xE2, 0xBE, 0xE2, 0xA0, 0x87, 0xAD, 0xCA, + 0x7D, 0x71, 0xFF, 0x59, 0x35, 0x8F, 0x2A, 0xF5, + 0x55, 0xAC, 0x93, 0xB5, 0x26, 0x45, 0xCE, 0x42, + 0x82, 0xFB, 0x37, 0x60, 0xF6, 0x9C, 0x58, 0x54 + }, + { + 0xFC, 0x27, 0xD9, 0x81, 0x36, 0x05, 0x15, 0x16, + 0x93, 0x99, 0xD1, 0x42, 0x3E, 0xAC, 0x56, 0xB8, + 0xD3, 0x40, 0xE0, 0x3E, 0xE7, 0x9C, 0x63, 0xC3, + 0x77, 0xAB, 0xCD, 0xDA, 0xB3, 0xB8, 0xCC, 0x0A + }, + { + 0xDD, 0xF6, 0xD8, 0xA4, 0x03, 0x09, 0x22, 0x9A, + 0xA1, 0x6C, 0x5C, 0xC3, 0xFA, 0x84, 0x31, 0x15, + 0xF1, 0xEB, 0xE2, 0x98, 0x8C, 0x5B, 0x71, 0xDF, + 0x98, 0xA5, 0xE3, 0x3A, 0x7C, 0xA4, 0x85, 0x99 + }, + { + 0x2B, 0xFE, 0x12, 0x84, 0x9C, 0x66, 0x77, 0x4B, + 0xF0, 0x3E, 0xEA, 0xB0, 0x51, 0x44, 0xFC, 0xCA, + 0x80, 0x04, 0xCD, 0x08, 0x61, 0xCE, 0xCA, 0xAD, + 0x42, 0xA7, 0xF3, 0xA5, 0xB2, 0xA0, 0xE9, 0x6B + }, + { + 0xC4, 0x52, 0xA9, 0xAD, 0x9D, 0x8E, 0xA5, 0x1D, + 0x27, 0xD5, 0x6B, 0x92, 0x62, 0x06, 0x73, 0x5C, + 0x27, 0xC7, 0x29, 0x56, 0x7C, 0xA0, 0xE8, 0xC0, + 0x70, 0x67, 0xF7, 0x5E, 0xE3, 0x45, 0xAC, 0xFC + }, + { + 0x38, 0x0E, 0x35, 0xF4, 0x27, 0x69, 0x23, 0xE8, + 0xDB, 0x66, 0x8E, 0x63, 0x07, 0x54, 0xF4, 0xE2, + 0xB8, 0x9D, 0xCD, 0x95, 0xA7, 0x7B, 0x28, 0x9D, + 0x5B, 0x40, 0x89, 0xE1, 0xCE, 0x75, 0x53, 0x18 + }, + { + 0x83, 0x70, 0xD7, 0x1B, 0x6E, 0x0F, 0xB5, 0xDC, + 0x09, 0xE6, 0xBA, 0xFA, 0xC5, 0x0B, 0x82, 0x66, + 0x70, 0xB5, 0x7A, 0xC7, 0x72, 0x4E, 0x94, 0x2F, + 0xD9, 0x6F, 0x0F, 0xD8, 0x22, 0xA6, 0x46, 0xBE + }, + { + 0x06, 0x71, 0x17, 0x37, 0x11, 0x94, 0x73, 0xD7, + 0x6F, 0xEA, 0xD8, 0x22, 0x39, 0x6D, 0x18, 0xF1, + 0x35, 0x47, 0x13, 0x93, 0x79, 0x40, 0x29, 0xD9, + 0xAA, 0xA7, 0x9B, 0xE0, 0x54, 0x31, 0x7A, 0x7B + }, + { + 0x7B, 0xE8, 0x4C, 0xA4, 0xD4, 0xAC, 0x2A, 0x03, + 0xE0, 0x9D, 0x91, 0x05, 0xC0, 0x6F, 0x4A, 0x5F, + 0x7F, 0xBE, 0x4C, 0x54, 0xD4, 0x99, 0x47, 0x69, + 0xFD, 0xD0, 0x29, 0x38, 0xBE, 0x05, 0x0C, 0x44 + }, + { + 0x0E, 0x4E, 0x62, 0x59, 0x6C, 0xF8, 0x84, 0x8F, + 0x83, 0xD8, 0x41, 0xA4, 0x61, 0xDD, 0xC7, 0xBC, + 0x9E, 0x2E, 0xE0, 0x96, 0x77, 0x50, 0xFA, 0x2B, + 0xCC, 0xC9, 0xAF, 0x56, 0xB4, 0xDF, 0xF9, 0x00 + }, + { + 0x94, 0x5B, 0x94, 0x8A, 0x5D, 0xAD, 0x09, 0x10, + 0xBF, 0x73, 0x73, 0xBF, 0xAF, 0x57, 0x19, 0x5B, + 0x57, 0xFE, 0xDB, 0x48, 0xA2, 0xE1, 0x12, 0xA7, + 0x43, 0x3A, 0xBD, 0x7A, 0xFE, 0x9E, 0x1E, 0xAB + }, + { + 0x67, 0x30, 0xA4, 0xFE, 0x07, 0x13, 0x7D, 0x38, + 0x88, 0xEE, 0xAF, 0x22, 0xCF, 0x93, 0x01, 0xC6, + 0x17, 0x9F, 0x7F, 0x0D, 0x00, 0x5E, 0xE7, 0x46, + 0xEF, 0x33, 0xC9, 0xAE, 0x79, 0x44, 0x72, 0x35 + }, + { + 0xCC, 0xC0, 0xDB, 0xA4, 0x22, 0x7F, 0x47, 0x2F, + 0xAA, 0x5B, 0xF7, 0xF1, 0x82, 0x69, 0xBC, 0x92, + 0x24, 0xB3, 0xEA, 0xD4, 0xD1, 0x59, 0xAB, 0xF9, + 0xC2, 0x1D, 0x81, 0x7A, 0x06, 0x96, 0xCA, 0x97 + }, + { + 0x6A, 0x24, 0x7B, 0x38, 0xBE, 0x25, 0xE8, 0xEF, + 0xFA, 0xCE, 0x45, 0x5D, 0x96, 0x86, 0xCD, 0xD9, + 0xD9, 0xD0, 0x99, 0x53, 0x4B, 0x82, 0xD2, 0x5D, + 0x69, 0x9E, 0x48, 0x5A, 0x58, 0x9C, 0x68, 0xCF + }, + { + 0x22, 0x60, 0x60, 0xE2, 0xE4, 0xCD, 0x60, 0x8F, + 0x35, 0x5A, 0x35, 0xC2, 0xD9, 0xE5, 0xD8, 0xCE, + 0x3D, 0xD0, 0x3A, 0x7F, 0xE6, 0xF5, 0x9A, 0xBE, + 0xAC, 0x38, 0x53, 0x96, 0x4C, 0xF9, 0xEE, 0x57 + }, + { + 0x11, 0x1F, 0xDF, 0x2B, 0xFE, 0xFB, 0xE4, 0x6E, + 0x49, 0xAA, 0x68, 0xE3, 0x74, 0x2D, 0xB1, 0x29, + 0x9D, 0x93, 0x8F, 0x24, 0x45, 0x6E, 0x57, 0x8C, + 0xFA, 0x25, 0xFA, 0x86, 0xC0, 0xC6, 0xC1, 0x7D + }, + { + 0xEA, 0x7E, 0x87, 0x3B, 0xDD, 0x87, 0x1A, 0xF3, + 0xF5, 0x61, 0xD3, 0xC2, 0x25, 0x2B, 0x77, 0xD8, + 0xB8, 0xC3, 0xC0, 0x02, 0x76, 0xCE, 0x15, 0x47, + 0x68, 0x18, 0xCC, 0x7D, 0xB3, 0xA0, 0x0B, 0xFB + }, + { + 0x3C, 0x2D, 0x35, 0x87, 0xAB, 0xE7, 0xF7, 0x2D, + 0xD5, 0x49, 0xED, 0x76, 0xF4, 0x41, 0xC1, 0x4D, + 0x04, 0xFF, 0x67, 0xDD, 0x03, 0x00, 0x74, 0x15, + 0x91, 0xBE, 0xD7, 0xDE, 0x53, 0x23, 0xFF, 0x9B + }, + { + 0x8A, 0x08, 0x89, 0x62, 0x97, 0xC9, 0xEB, 0x62, + 0x48, 0x86, 0x3E, 0xE4, 0x59, 0x64, 0x56, 0x07, + 0x38, 0xFA, 0x46, 0x4D, 0xD6, 0x31, 0x52, 0xE9, + 0xFB, 0x3E, 0xC0, 0x74, 0x78, 0x19, 0x35, 0x58 + }, + { + 0x64, 0x98, 0x0B, 0x86, 0x12, 0xF7, 0x48, 0x83, + 0x60, 0xFF, 0xF8, 0xA2, 0x61, 0x11, 0xC6, 0xA4, + 0x2F, 0x94, 0x48, 0xEC, 0xEB, 0x65, 0xC4, 0xE3, + 0x60, 0xFB, 0x80, 0x37, 0x7C, 0xB3, 0xBF, 0xA0 + }, + { + 0xB4, 0xBF, 0x85, 0x7E, 0x77, 0x51, 0x97, 0xC0, + 0xF3, 0x29, 0xEC, 0xF0, 0x52, 0xFF, 0xB7, 0x33, + 0xB4, 0x4E, 0x11, 0xCB, 0x70, 0x0D, 0xC4, 0x78, + 0xD8, 0xD6, 0xEA, 0xAC, 0x09, 0xDE, 0x02, 0x7F + }, + { + 0xAC, 0x67, 0x61, 0xCB, 0x4E, 0x86, 0x56, 0xFE, + 0x25, 0x54, 0xAB, 0xFF, 0x22, 0xBB, 0xC3, 0xFE, + 0x2F, 0xBE, 0x37, 0xDB, 0x16, 0x14, 0x75, 0x4C, + 0xAE, 0xF2, 0xC0, 0x6B, 0xDE, 0xF5, 0xD7, 0x9A + }, + { + 0x5D, 0x01, 0xA6, 0xF6, 0x14, 0x71, 0xA5, 0x23, + 0x51, 0xAE, 0x37, 0xDB, 0x7D, 0x82, 0xB8, 0x89, + 0x1B, 0x40, 0xF5, 0x40, 0x30, 0xA6, 0x14, 0xC5, + 0xE4, 0x82, 0x79, 0x01, 0xFC, 0xC4, 0x39, 0x9F + }, + { + 0xFC, 0x51, 0xB6, 0x38, 0x07, 0x5A, 0xE8, 0x56, + 0xBF, 0xE3, 0xB6, 0x50, 0x3F, 0xA0, 0xDE, 0x18, + 0xE6, 0x63, 0xC3, 0xE1, 0x2F, 0xA9, 0x4C, 0xD4, + 0x26, 0xF0, 0x2F, 0x48, 0x8C, 0x66, 0x3D, 0x16 + }, + { + 0x58, 0xD8, 0x48, 0xD3, 0x6B, 0x64, 0xF1, 0x15, + 0x60, 0xD8, 0x92, 0x88, 0xB6, 0x1F, 0xE3, 0xA5, + 0xAC, 0x6B, 0x91, 0xE2, 0x71, 0x8D, 0xFD, 0x48, + 0x7A, 0x7F, 0xA4, 0xD2, 0xAD, 0xBF, 0x21, 0xAC + }, + { + 0x95, 0x58, 0x0D, 0x08, 0xC7, 0x19, 0x14, 0x1B, + 0x0F, 0xF4, 0x26, 0x37, 0x3D, 0x93, 0x46, 0x48, + 0xA5, 0xB1, 0xE0, 0x64, 0x8C, 0x50, 0x63, 0xDC, + 0x14, 0xD6, 0x0D, 0x2C, 0xC4, 0xC9, 0xF9, 0x8E + }, + { + 0x80, 0x15, 0x90, 0xB2, 0xA4, 0x04, 0x84, 0x7E, + 0x78, 0x7E, 0x96, 0x51, 0x32, 0x5E, 0x1E, 0xB4, + 0x5C, 0xA5, 0x04, 0x55, 0x0C, 0x4E, 0x9D, 0x20, + 0xFD, 0xFE, 0x5F, 0xE1, 0xC6, 0xCB, 0xE0, 0x21 + }, + { + 0x11, 0x77, 0x16, 0x40, 0x75, 0xCB, 0x12, 0x3F, + 0x57, 0xCD, 0x70, 0xB5, 0xA6, 0x68, 0xF9, 0x3C, + 0x4B, 0xFC, 0xCC, 0x35, 0xE1, 0xBE, 0x7C, 0x8A, + 0x49, 0xF6, 0x53, 0x66, 0x83, 0xCD, 0xE7, 0xCA + }, + { + 0x64, 0xA8, 0xC7, 0x6A, 0x02, 0x31, 0xDA, 0x67, + 0x61, 0xDB, 0x79, 0xCC, 0x7E, 0xC2, 0xC4, 0xBA, + 0x2A, 0x12, 0x83, 0xB8, 0x25, 0x22, 0x21, 0xAA, + 0x30, 0xD1, 0x70, 0x98, 0xF1, 0xA1, 0xCD, 0xF7 + }, + { + 0x23, 0xC0, 0x4F, 0x56, 0x0A, 0xB5, 0x1B, 0x2F, + 0x7E, 0x19, 0x48, 0x73, 0x7A, 0x72, 0x9B, 0x9E, + 0x0B, 0xA6, 0xC9, 0x1D, 0xED, 0xD4, 0x9A, 0xDE, + 0x44, 0xAF, 0x14, 0xF7, 0x08, 0xC8, 0xF6, 0x4B + }, + { + 0xCF, 0xFF, 0xB5, 0x12, 0x71, 0x3E, 0xF6, 0xA1, + 0xB9, 0x0B, 0x17, 0x6A, 0x7E, 0x77, 0x18, 0x24, + 0x0A, 0x5E, 0x94, 0xA7, 0x00, 0x2C, 0x41, 0xE7, + 0x7A, 0x4D, 0x27, 0xE2, 0x6A, 0x13, 0x8D, 0x46 + }, + { + 0x99, 0xB7, 0x8F, 0xD0, 0xD1, 0x71, 0x60, 0x8A, + 0x0D, 0xDA, 0x58, 0xFC, 0x66, 0x5F, 0xB0, 0x03, + 0x32, 0x9F, 0x57, 0x81, 0x10, 0x8B, 0x7F, 0x00, + 0x6E, 0x3E, 0xE2, 0xB3, 0x5B, 0xDA, 0xD4, 0x23 + }, + { + 0x0F, 0x38, 0x41, 0x3E, 0xDD, 0x94, 0x93, 0x98, + 0xD2, 0xD9, 0x55, 0x77, 0xB6, 0x7B, 0xDB, 0x44, + 0xC3, 0x04, 0x05, 0x0E, 0xA0, 0xCE, 0x94, 0x5C, + 0x47, 0x92, 0x16, 0x0B, 0xD5, 0x3B, 0x12, 0x68 + }, + { + 0xFE, 0x7F, 0x91, 0xBB, 0x13, 0x34, 0x29, 0xC7, + 0xD7, 0x66, 0xF0, 0xB7, 0x5B, 0xC7, 0x0E, 0x67, + 0xDE, 0xAD, 0xD4, 0x2B, 0xDE, 0xBC, 0x61, 0xAF, + 0x46, 0xE5, 0x6A, 0xA5, 0x42, 0x1A, 0x40, 0x0D + }, + { + 0xB0, 0xD9, 0xED, 0x4D, 0x21, 0x9C, 0x57, 0xFE, + 0xA7, 0x1A, 0x41, 0xBB, 0xA6, 0x05, 0xE7, 0xAE, + 0x0E, 0x17, 0xEA, 0x15, 0x13, 0x44, 0x17, 0x65, + 0x1C, 0xBF, 0xA2, 0xF9, 0x79, 0x1F, 0x02, 0x2C + }, + { + 0xD7, 0xEF, 0x65, 0x9D, 0x9F, 0xB2, 0x9B, 0x55, + 0x58, 0x0C, 0x38, 0xD5, 0x4C, 0x6B, 0x39, 0x52, + 0x4E, 0xCC, 0x5F, 0xFC, 0xA8, 0x4D, 0x15, 0x5C, + 0x7D, 0x3D, 0xF4, 0xBC, 0x26, 0x85, 0x94, 0xA8 + }, + { + 0x6B, 0x19, 0xB7, 0xB8, 0x0C, 0xCF, 0x74, 0x37, + 0xD9, 0x8D, 0xEF, 0xD9, 0x41, 0x7E, 0xB5, 0xD1, + 0x4C, 0xC4, 0x8A, 0x8B, 0x3A, 0x67, 0xC0, 0xB7, + 0x7A, 0x7C, 0x1C, 0x4F, 0x48, 0xB1, 0x80, 0x97 + }, + { + 0x6F, 0x6E, 0x6B, 0x8D, 0x67, 0xD2, 0x37, 0x9C, + 0x0F, 0x9C, 0xCB, 0x94, 0xDD, 0x32, 0xC3, 0xE6, + 0xB1, 0x7E, 0xFF, 0x2E, 0x5F, 0xE7, 0xAC, 0xD9, + 0x40, 0x4B, 0x61, 0xD3, 0xC8, 0xB4, 0x7A, 0x5B + }, + { + 0xA8, 0x73, 0x81, 0xD5, 0x94, 0xA0, 0x8C, 0x10, + 0x14, 0x74, 0x7E, 0x34, 0x08, 0x83, 0x87, 0x27, + 0x5A, 0x3C, 0xE8, 0x3E, 0x03, 0x7D, 0xF0, 0x49, + 0x7E, 0x4E, 0x3C, 0x43, 0x4E, 0xF1, 0x17, 0xA3 + }, + { + 0x3F, 0x5B, 0xEE, 0x67, 0x4D, 0xD3, 0xD3, 0xE6, + 0xBE, 0x40, 0x0F, 0xF5, 0x89, 0xDE, 0x99, 0xF1, + 0xD3, 0x31, 0x2C, 0x0F, 0x66, 0xB1, 0xB9, 0x2A, + 0xDE, 0xBD, 0xDC, 0xBD, 0xC4, 0x81, 0x42, 0x8F + }, + { + 0xA8, 0x07, 0xB3, 0xA5, 0xDF, 0x4A, 0x81, 0x7B, + 0xEE, 0x1F, 0x3C, 0x32, 0xAC, 0x41, 0xB4, 0xCA, + 0xE4, 0x6F, 0xB8, 0xE8, 0xA5, 0x8E, 0x65, 0xCD, + 0x9A, 0xD7, 0xEB, 0x65, 0x5B, 0xFE, 0x0F, 0x88 + }, + { + 0xC1, 0xE8, 0xC2, 0x35, 0x47, 0xD3, 0x52, 0x31, + 0x6E, 0x21, 0xB6, 0x34, 0xCC, 0x29, 0xC4, 0x32, + 0xFA, 0x35, 0x31, 0xAE, 0xA8, 0xDB, 0xA0, 0xA2, + 0xC3, 0x9A, 0xDA, 0x8C, 0xB3, 0xDD, 0xEF, 0xA3 + }, + { + 0x1A, 0x5D, 0x99, 0x0B, 0xE6, 0x28, 0xAF, 0x31, + 0x21, 0x16, 0x7C, 0xB2, 0x80, 0x81, 0xB7, 0x25, + 0x9A, 0x0C, 0x38, 0x89, 0xE9, 0x99, 0x7D, 0xA2, + 0x10, 0x46, 0xFE, 0xCE, 0xDC, 0x5F, 0x7B, 0x83 + }, + { + 0xB7, 0xD4, 0xA8, 0x8A, 0x4E, 0x15, 0x73, 0x88, + 0x64, 0x63, 0x6A, 0x59, 0x57, 0x90, 0x76, 0x68, + 0xE4, 0x30, 0xD6, 0x03, 0x55, 0x31, 0xC5, 0x3E, + 0x65, 0x45, 0x15, 0x01, 0x96, 0xCE, 0x9A, 0x01 + }, + { + 0x2B, 0x96, 0x55, 0xB1, 0x84, 0xBB, 0x32, 0x77, + 0xB1, 0x3B, 0x31, 0xF2, 0x58, 0x11, 0x9E, 0x6C, + 0x10, 0xF4, 0x7A, 0x6C, 0xC9, 0xCF, 0xDA, 0x89, + 0xCF, 0x67, 0x93, 0x3B, 0x12, 0x80, 0x31, 0x55 + }, + { + 0x30, 0x27, 0x1E, 0xD4, 0x2D, 0xDE, 0xF8, 0x36, + 0x72, 0x9E, 0xD9, 0x1A, 0x81, 0x44, 0xCC, 0x6C, + 0x55, 0x92, 0x4E, 0xF3, 0xB0, 0xEB, 0xA0, 0x08, + 0x3D, 0xE2, 0x09, 0x63, 0xDA, 0xAC, 0x97, 0xAE + }, + { + 0x92, 0x44, 0x6B, 0x25, 0x4D, 0x44, 0x71, 0x79, + 0xA1, 0xAC, 0x26, 0x53, 0xE1, 0x2D, 0x14, 0x0F, + 0x30, 0x3B, 0x0D, 0x92, 0xF4, 0xDF, 0x66, 0xBA, + 0x53, 0xD1, 0x5F, 0x22, 0xC7, 0x85, 0x21, 0x6A + }, + { + 0x4E, 0x35, 0x3B, 0x58, 0xD5, 0xC0, 0x2D, 0x1B, + 0xAD, 0x25, 0x06, 0xC1, 0xC4, 0x0D, 0x60, 0x21, + 0x68, 0xC0, 0xF4, 0x8D, 0x47, 0x95, 0xDC, 0x06, + 0x04, 0xDA, 0xC3, 0xA8, 0x3E, 0xEF, 0xF0, 0x07 + }, + { + 0x06, 0x1D, 0xEA, 0xC1, 0xBC, 0x0E, 0x44, 0x63, + 0xFE, 0x0F, 0x7A, 0x4B, 0x84, 0x93, 0x33, 0x12, + 0xC0, 0x51, 0xA1, 0x46, 0x0E, 0x22, 0xC6, 0x5A, + 0x06, 0xD3, 0x19, 0x97, 0x35, 0x82, 0xBB, 0xB7 + }, + { + 0xC5, 0x69, 0xD5, 0x1D, 0x86, 0x3F, 0xDE, 0xA7, + 0x10, 0x04, 0x41, 0x62, 0x32, 0xC7, 0x41, 0x92, + 0x0B, 0x69, 0x89, 0xC8, 0x0C, 0x85, 0x53, 0xB1, + 0x1A, 0x44, 0xB0, 0x29, 0x02, 0x2E, 0xCB, 0x96 + }, + { + 0xD8, 0xD3, 0xDA, 0xC5, 0xAD, 0xF7, 0xF9, 0xFA, + 0xB5, 0x54, 0x8A, 0xE7, 0x19, 0x92, 0x63, 0x40, + 0x78, 0x0A, 0x90, 0x72, 0x7E, 0x6D, 0x17, 0xAB, + 0x4B, 0xA3, 0xD8, 0x98, 0x1B, 0x7C, 0x43, 0x80 + }, + { + 0x8B, 0xBB, 0x64, 0xC7, 0xCF, 0x88, 0xA8, 0xF9, + 0x4C, 0xF0, 0x8C, 0x45, 0x71, 0xA4, 0x0E, 0x98, + 0xA2, 0x36, 0x56, 0x0A, 0x39, 0x9C, 0x84, 0x24, + 0xFD, 0xBE, 0x6D, 0x52, 0x6C, 0x48, 0xD2, 0x2A + }, + { + 0x07, 0x05, 0xE0, 0xD1, 0x4D, 0xBC, 0x3D, 0x37, + 0xDB, 0xB2, 0xD1, 0x97, 0xA3, 0x79, 0xB9, 0xC5, + 0x04, 0x34, 0x5E, 0x94, 0x59, 0xAE, 0x1F, 0xB4, + 0x5E, 0xC9, 0x73, 0xDA, 0xAD, 0xFB, 0xF5, 0xD5 + }, + { + 0x73, 0x70, 0x85, 0x16, 0xE6, 0x80, 0x61, 0xE0, + 0x24, 0xD3, 0x38, 0xD0, 0xEC, 0x9A, 0x80, 0xF8, + 0xF3, 0x17, 0x8E, 0x29, 0x17, 0x71, 0x93, 0x1F, + 0x33, 0x35, 0x1F, 0x30, 0xC5, 0x2C, 0xBA, 0xD7 + }, + { + 0x9E, 0x1D, 0xFC, 0x67, 0x55, 0x51, 0x94, 0x4A, + 0x9F, 0x6B, 0x50, 0x0C, 0x47, 0xB3, 0x35, 0x72, + 0x5E, 0x34, 0x7D, 0xF5, 0x7A, 0xD1, 0x89, 0x65, + 0x41, 0xAB, 0xE9, 0xFE, 0x9F, 0xBD, 0x2A, 0xBD + }, + { + 0xD0, 0x02, 0xD5, 0xE0, 0x00, 0x49, 0x6B, 0x25, + 0xBC, 0xE9, 0x50, 0x13, 0x1B, 0x66, 0x29, 0x74, + 0x86, 0x4F, 0x90, 0xF5, 0x8E, 0x5B, 0x72, 0xEA, + 0xD6, 0xB5, 0xAD, 0x34, 0x31, 0xD7, 0x54, 0x42 + }, + { + 0x41, 0x1C, 0x48, 0x37, 0xE6, 0x0C, 0x7B, 0xED, + 0x88, 0x6E, 0xCE, 0x86, 0x0C, 0x4B, 0x40, 0x84, + 0x09, 0x34, 0x62, 0xFE, 0x1E, 0xBA, 0x8A, 0x76, + 0xDD, 0x8B, 0xBB, 0xCE, 0x11, 0xD5, 0xB8, 0xC8 + }, + { + 0x58, 0xC2, 0x75, 0xEF, 0x0E, 0x7E, 0x3D, 0x8E, + 0x65, 0xAA, 0x8F, 0x1F, 0xC7, 0xBE, 0xE9, 0x84, + 0xE8, 0xFA, 0xAE, 0xA5, 0xA7, 0xFE, 0xE3, 0x3D, + 0xAD, 0xBB, 0xDC, 0x2B, 0xE6, 0xA4, 0xA1, 0xFB + }, + { + 0x58, 0x36, 0x2D, 0xFB, 0x2E, 0x1D, 0x2D, 0x68, + 0x4A, 0xFD, 0x06, 0x07, 0x9F, 0xAA, 0xEB, 0x25, + 0x54, 0xD7, 0x9E, 0xBC, 0x4C, 0x45, 0x51, 0x05, + 0x78, 0xB3, 0xB9, 0x02, 0x7C, 0x9D, 0xCD, 0x7D + }, + { + 0x36, 0xB8, 0xB3, 0x3D, 0x63, 0x67, 0x11, 0xDE, + 0xD0, 0x4B, 0xC8, 0xD5, 0xCA, 0xC0, 0xDE, 0xF6, + 0xBC, 0x26, 0x76, 0x65, 0x99, 0xDD, 0x3C, 0x17, + 0xD8, 0x1B, 0xB3, 0x09, 0x03, 0xC4, 0xB8, 0xB1 + }, + { + 0x01, 0x75, 0xEF, 0x21, 0xFD, 0x72, 0x69, 0xF2, + 0x7A, 0x63, 0x6A, 0x4A, 0x76, 0x8D, 0x06, 0xE0, + 0x7D, 0xEF, 0xEB, 0x70, 0x46, 0x06, 0xEF, 0xD1, + 0x17, 0x8D, 0x09, 0xED, 0xEE, 0x45, 0x45, 0xD2 + }, + { + 0x9A, 0x02, 0xE0, 0x8F, 0x5D, 0x95, 0x6D, 0xA7, + 0xEB, 0xAD, 0xE7, 0x27, 0x63, 0xB7, 0xAA, 0xBA, + 0x3F, 0x71, 0x84, 0x07, 0x07, 0xB1, 0x53, 0xAE, + 0x7F, 0x6F, 0xC2, 0x3A, 0x82, 0x75, 0x78, 0xE7 + }, + { + 0x15, 0xB4, 0xB6, 0x9A, 0x76, 0x9C, 0x3B, 0xDE, + 0x24, 0x27, 0x36, 0x28, 0x8D, 0x62, 0xDF, 0x5F, + 0xE7, 0x82, 0x2B, 0x2E, 0xCF, 0xD6, 0xAF, 0x8B, + 0x8D, 0xE7, 0x08, 0xE2, 0x35, 0xFC, 0x5D, 0x62 + }, + { + 0xE0, 0x52, 0x85, 0xB7, 0xB6, 0xD6, 0x46, 0xB1, + 0x3A, 0xCE, 0x9B, 0x27, 0x22, 0x15, 0xAD, 0xE3, + 0xC8, 0xF6, 0xB7, 0xD3, 0x9E, 0x13, 0xBB, 0x31, + 0x0D, 0x93, 0x2D, 0xD7, 0xA7, 0xAB, 0x2A, 0xC9 + }, + { + 0x5A, 0x4A, 0x79, 0xDE, 0x70, 0x8A, 0xA8, 0x4F, + 0x6A, 0x2B, 0x45, 0xD0, 0x3D, 0x22, 0x20, 0xF6, + 0x45, 0xBF, 0x98, 0x71, 0x30, 0xF6, 0x50, 0x24, + 0x02, 0xE5, 0xEE, 0x4F, 0xEA, 0x16, 0x3D, 0x0F + }, + { + 0x81, 0x80, 0x24, 0xBE, 0x3C, 0x6C, 0x56, 0x1A, + 0x38, 0xC7, 0xC4, 0xF2, 0xB7, 0x5C, 0xA3, 0xFF, + 0x1B, 0xA8, 0x06, 0x57, 0x2D, 0x5B, 0x80, 0xBB, + 0xEC, 0x11, 0x5A, 0xF2, 0xBF, 0x1A, 0xB3, 0xE7 + }, + { + 0x29, 0x87, 0x24, 0x98, 0xD4, 0xB7, 0xA6, 0x13, + 0x18, 0x52, 0xF0, 0x71, 0xAF, 0x0E, 0xF4, 0xE2, + 0x86, 0x65, 0x5A, 0x72, 0x9B, 0x86, 0x08, 0x71, + 0xBF, 0x4F, 0x61, 0x32, 0x4A, 0xCE, 0xA5, 0x74 + }, + { + 0x8C, 0x7D, 0xC2, 0xEE, 0x39, 0x93, 0x34, 0xF0, + 0x4A, 0xD4, 0x18, 0xA0, 0xEF, 0x5D, 0x05, 0xA2, + 0x16, 0x00, 0xBD, 0xE0, 0xCE, 0xCB, 0x6C, 0xF6, + 0x47, 0xCD, 0x6A, 0x78, 0xA2, 0x75, 0xC9, 0x85 + }, + { + 0x6A, 0x18, 0x96, 0xB6, 0x99, 0xC4, 0x3C, 0xA0, + 0x7E, 0x9B, 0xB2, 0x47, 0x67, 0x49, 0x07, 0x68, + 0xFE, 0xE8, 0x58, 0xEE, 0xAD, 0x26, 0x11, 0x80, + 0x58, 0x2F, 0x37, 0xCE, 0x59, 0x77, 0x2B, 0x90 + }, + { + 0xD8, 0x70, 0x9D, 0x7B, 0x0D, 0xCB, 0xFD, 0xBF, + 0x38, 0x46, 0x10, 0x59, 0x5A, 0x9A, 0x82, 0x57, + 0xA0, 0xDC, 0xE4, 0x5F, 0xF5, 0x18, 0x76, 0xEC, + 0x4B, 0xBF, 0x7F, 0x51, 0xFC, 0xB2, 0x13, 0xAD + }, + { + 0xFB, 0x4E, 0x97, 0xBD, 0xE0, 0x8E, 0xCA, 0x7B, + 0xA2, 0xB7, 0x35, 0xCF, 0xFA, 0x04, 0xC1, 0xD2, + 0xE9, 0x31, 0x1E, 0xD2, 0x63, 0xE1, 0xDA, 0xE6, + 0xC6, 0x2D, 0x8A, 0x69, 0xF3, 0x2F, 0x19, 0x84 + }, + { + 0x6A, 0xF9, 0x5E, 0x51, 0x5C, 0x0E, 0xCE, 0x21, + 0x6A, 0x9E, 0x6C, 0xD4, 0xA8, 0x94, 0x8F, 0x67, + 0xEA, 0xC6, 0x07, 0x28, 0x6D, 0xAB, 0xA1, 0x9F, + 0x47, 0x80, 0x2D, 0xF4, 0x31, 0x11, 0x62, 0x0E + }, + { + 0x80, 0xBD, 0x46, 0x17, 0xEE, 0x5D, 0x71, 0x02, + 0xF3, 0xB1, 0x09, 0x2A, 0xFA, 0x04, 0xF7, 0x47, + 0xF6, 0x5C, 0xE4, 0xB9, 0x96, 0xA1, 0x6B, 0x38, + 0x38, 0xEE, 0xD7, 0x96, 0xD5, 0x79, 0xB0, 0x5F + }, + { + 0xC4, 0x8C, 0x09, 0x77, 0x68, 0x35, 0xF4, 0x43, + 0xEC, 0x91, 0xF4, 0x23, 0x2F, 0x87, 0xA0, 0x08, + 0x81, 0x09, 0xB7, 0x74, 0x26, 0x00, 0x2B, 0xD8, + 0xD1, 0x93, 0x7C, 0xB0, 0xBF, 0x59, 0x0F, 0x1E + }, + { + 0xFA, 0x6F, 0x5E, 0x21, 0x4C, 0xFD, 0x38, 0x3C, + 0xBF, 0xF1, 0xF5, 0x01, 0x9E, 0x59, 0xA0, 0x43, + 0xD5, 0x9C, 0xF5, 0x09, 0xC3, 0x75, 0xFA, 0xDF, + 0xF7, 0x4C, 0xBA, 0x4C, 0xC5, 0x10, 0x9F, 0x0E + }, + { + 0x30, 0xE0, 0x4A, 0xD7, 0xED, 0xAC, 0xAD, 0x9A, + 0xE8, 0xCA, 0xBA, 0x72, 0x33, 0x74, 0xB4, 0xB7, + 0xD6, 0x13, 0xD7, 0x25, 0x72, 0x70, 0xB9, 0x0B, + 0x5B, 0x6F, 0xBF, 0x1D, 0xFC, 0x42, 0xF2, 0x12 + }, + { + 0xDD, 0x98, 0xCF, 0xB7, 0x73, 0x76, 0x30, 0xE6, + 0xF7, 0xD8, 0xCB, 0x37, 0x52, 0x53, 0xC6, 0x42, + 0xAF, 0x65, 0x9B, 0xB8, 0xEB, 0xBE, 0x34, 0x80, + 0x97, 0xBE, 0xAB, 0x8A, 0x0B, 0x77, 0x44, 0x4A + }, + { + 0x3F, 0x5F, 0x64, 0xA8, 0x4D, 0x22, 0x1E, 0x4D, + 0x5E, 0x84, 0x21, 0xF8, 0xBC, 0xBF, 0xF4, 0x9A, + 0x76, 0x53, 0xBF, 0x89, 0x2A, 0x02, 0x6B, 0x88, + 0x53, 0x47, 0xD9, 0x2A, 0x2A, 0x0F, 0x15, 0xF3 + }, + { + 0xFA, 0x51, 0x01, 0xEA, 0xA5, 0x62, 0x95, 0xDC, + 0x7B, 0x18, 0x16, 0x6B, 0x61, 0xC7, 0x3B, 0x11, + 0x27, 0x07, 0x57, 0xDF, 0xF2, 0xFD, 0xF3, 0x63, + 0x14, 0xD8, 0x9F, 0x54, 0xB8, 0x5D, 0x39, 0xF7 + }, + { + 0x44, 0xF4, 0x59, 0xFA, 0x7B, 0x88, 0x1F, 0x33, + 0x03, 0xAD, 0x0E, 0xE3, 0x0F, 0x4A, 0xF8, 0x3F, + 0x4B, 0xB9, 0x80, 0x75, 0x34, 0x28, 0xC2, 0x82, + 0x95, 0x00, 0xE1, 0xF5, 0xFF, 0x20, 0x62, 0x3B + }, + { + 0x5C, 0x2A, 0xE5, 0xF9, 0x95, 0x25, 0x26, 0xD6, + 0x61, 0x81, 0x5D, 0x60, 0x87, 0x36, 0x75, 0x44, + 0x8F, 0x11, 0xF3, 0xF7, 0xF6, 0xCC, 0x74, 0x9F, + 0x01, 0x50, 0x5C, 0xC7, 0x7E, 0x35, 0x68, 0x6F + }, + { + 0x6F, 0xCC, 0x77, 0xFB, 0xC4, 0xA7, 0x00, 0x8B, + 0x4B, 0x02, 0x53, 0x25, 0x36, 0x13, 0xF9, 0x6F, + 0x5F, 0x40, 0xC1, 0x1B, 0x50, 0x09, 0x6D, 0x1C, + 0xFF, 0x64, 0x86, 0x53, 0xD6, 0x3E, 0xD8, 0x77 + }, + { + 0xB3, 0xDC, 0x2C, 0xE3, 0xA0, 0xFB, 0xE5, 0x5B, + 0x2C, 0x9D, 0x75, 0xB1, 0xC1, 0x73, 0x16, 0x48, + 0xD9, 0x8E, 0x20, 0xBA, 0x0E, 0x80, 0x32, 0x13, + 0x82, 0x52, 0x86, 0xFA, 0x12, 0x6C, 0x14, 0x48 + }, + { + 0xA2, 0xF5, 0x74, 0xA9, 0xA7, 0xD7, 0xA5, 0x6B, + 0x50, 0x07, 0x92, 0x54, 0x07, 0xA6, 0x66, 0x2D, + 0xD9, 0x4A, 0xC3, 0x46, 0xA7, 0x55, 0xE4, 0x9B, + 0x2F, 0x4A, 0x89, 0x33, 0x3E, 0x75, 0xDF, 0x2B + }, + { + 0x5E, 0x7B, 0x77, 0xB6, 0x3F, 0xBB, 0x68, 0xF1, + 0x08, 0xFF, 0x72, 0x6F, 0x99, 0x6F, 0xBA, 0xAB, + 0x9D, 0xFA, 0x5A, 0x70, 0x8D, 0xCB, 0x5D, 0xB8, + 0xC2, 0xEA, 0x3F, 0x85, 0xF6, 0xAB, 0x2B, 0xFF + }, + { + 0xE0, 0xB4, 0x4E, 0xE1, 0x86, 0x6B, 0xCC, 0xB2, + 0x34, 0x27, 0x18, 0x1D, 0x0C, 0x73, 0xDD, 0x2C, + 0xFF, 0x77, 0x70, 0x1C, 0x16, 0x32, 0x07, 0x59, + 0x57, 0x07, 0x63, 0x06, 0xED, 0x55, 0x53, 0xE0 + }, + { + 0x4A, 0xC0, 0x7E, 0xCC, 0x90, 0x15, 0x83, 0xD2, + 0x98, 0x16, 0xD9, 0x9F, 0xDB, 0x5F, 0x12, 0xA9, + 0x16, 0x24, 0x3F, 0x6A, 0x80, 0x2C, 0x5E, 0x0B, + 0x00, 0x02, 0x7B, 0x8B, 0x2D, 0x57, 0xEB, 0x37 + }, + { + 0x61, 0xAF, 0xBB, 0xDC, 0x0F, 0x1D, 0xD1, 0x2E, + 0x4F, 0x58, 0x44, 0x9F, 0x57, 0x9B, 0x8A, 0x38, + 0x0A, 0x1A, 0x93, 0x7B, 0x06, 0x77, 0xF7, 0xA6, + 0xF5, 0xF4, 0xFA, 0xBE, 0x99, 0x9C, 0x41, 0xA4 + }, + { + 0x3D, 0xE1, 0xB3, 0x97, 0xF2, 0xA3, 0xF0, 0x30, + 0xB6, 0x94, 0x7E, 0xCA, 0xD8, 0x2C, 0x1F, 0x8F, + 0x50, 0x43, 0x2C, 0x5D, 0x99, 0x93, 0x3D, 0x75, + 0xA2, 0x84, 0xE4, 0xED, 0x74, 0xC5, 0x89, 0x4D + }, + { + 0x06, 0x5B, 0x0E, 0x27, 0x6E, 0xEB, 0x29, 0xEE, + 0x95, 0x2E, 0xF8, 0xF5, 0x88, 0xAE, 0xAE, 0x62, + 0xC5, 0x5C, 0xF5, 0x64, 0x77, 0xE3, 0x11, 0x2E, + 0xC3, 0xF0, 0x96, 0x5A, 0x04, 0xEA, 0xC2, 0x72 + }, + { + 0x81, 0xEB, 0x2D, 0xD1, 0x38, 0x6C, 0xBE, 0x84, + 0xF3, 0xEF, 0x15, 0x73, 0xD5, 0x63, 0x95, 0xD4, + 0x70, 0xFA, 0x0F, 0xD2, 0x41, 0x01, 0x0F, 0x38, + 0xFE, 0x58, 0x93, 0x6E, 0xB4, 0xC8, 0xE7, 0xA2 + }, + { + 0x3C, 0x3A, 0x2B, 0x92, 0x14, 0x1B, 0xD1, 0x8A, + 0xF5, 0x86, 0xCA, 0x12, 0x34, 0x00, 0xAC, 0x1A, + 0x7F, 0xA6, 0xC0, 0x6B, 0xD0, 0x30, 0x3E, 0xFD, + 0xCA, 0x2B, 0xC4, 0xE4, 0xDB, 0x94, 0xD5, 0xF1 + }, + { + 0x36, 0xC7, 0xE7, 0x42, 0xC7, 0xA1, 0x18, 0x87, + 0x79, 0x0B, 0x88, 0x76, 0xCB, 0x84, 0x37, 0x66, + 0x8D, 0x80, 0x9A, 0xD4, 0xA7, 0x6C, 0xF0, 0x0F, + 0x86, 0xF8, 0x3A, 0x5E, 0x98, 0xB5, 0xFE, 0x8A + }, + { + 0x00, 0x20, 0x0F, 0x0A, 0x36, 0x80, 0x88, 0x1A, + 0x87, 0xFE, 0x38, 0x20, 0xF5, 0xCE, 0x06, 0x15, + 0xF0, 0x8A, 0xEA, 0x55, 0x42, 0xA5, 0x64, 0x08, + 0xE3, 0x7E, 0x5B, 0xAE, 0xD6, 0xC4, 0x64, 0xFC + }, + { + 0xF5, 0xF6, 0x49, 0x23, 0xD4, 0xCC, 0x69, 0x6B, + 0x58, 0x2E, 0x48, 0x9A, 0xFD, 0x7A, 0x42, 0x93, + 0xE4, 0xA7, 0xC5, 0x96, 0x7A, 0x1B, 0x1E, 0x88, + 0x62, 0x93, 0x25, 0xC6, 0x5F, 0x11, 0x58, 0xFE + }, + { + 0xB5, 0xEF, 0x82, 0x0A, 0xFC, 0x38, 0x79, 0xF5, + 0x80, 0x3A, 0xB5, 0x75, 0xD5, 0x1D, 0xCF, 0xDE, + 0x98, 0xF6, 0x62, 0x02, 0x42, 0x51, 0xC1, 0xAA, + 0x50, 0x31, 0xB0, 0x32, 0x6F, 0xAB, 0x0C, 0xDC + }, + { + 0xB9, 0xC6, 0xD8, 0x45, 0x65, 0x3F, 0xDA, 0x66, + 0xF4, 0xCD, 0x0D, 0x72, 0x3E, 0x73, 0x26, 0xF4, + 0x76, 0x3C, 0xC7, 0xDB, 0xEF, 0x07, 0x51, 0x31, + 0xA0, 0x9A, 0xF9, 0x73, 0x9A, 0x59, 0x2F, 0xE5 + }, + { + 0xEC, 0x84, 0x74, 0x55, 0x45, 0x58, 0xF1, 0xB5, + 0xEE, 0xF5, 0x0A, 0xA6, 0x05, 0x51, 0x16, 0xE7, + 0xAE, 0xC3, 0xF6, 0xB7, 0xC9, 0xE9, 0x3B, 0xB9, + 0x15, 0xAF, 0xB7, 0xC1, 0x1D, 0x04, 0x02, 0x07 + }, + { + 0x94, 0xF4, 0xDF, 0xCD, 0xFB, 0x30, 0xDE, 0x6A, + 0x26, 0x32, 0x4C, 0x1C, 0x0C, 0x27, 0x1D, 0x3F, + 0x70, 0x01, 0xBD, 0x7C, 0xBD, 0xBB, 0xD1, 0x58, + 0xC1, 0x9C, 0x2C, 0x22, 0x6B, 0xFD, 0xAF, 0x48 + }, + { + 0x98, 0x45, 0x5D, 0x74, 0x36, 0xFA, 0x58, 0xEF, + 0x2D, 0x0E, 0x81, 0x07, 0x10, 0x7F, 0x46, 0x6B, + 0x64, 0xDA, 0xD2, 0x79, 0x02, 0x54, 0xFA, 0x8E, + 0x6D, 0x53, 0xAD, 0xCD, 0x7B, 0x22, 0x58, 0xE6 + }, + { + 0xE3, 0x74, 0x18, 0xD9, 0xA4, 0x01, 0x20, 0xA3, + 0xE3, 0xB4, 0x9B, 0x23, 0x9E, 0xFE, 0x79, 0xDA, + 0x11, 0x20, 0xB7, 0x52, 0x72, 0x6E, 0xE5, 0x06, + 0xC9, 0x75, 0x32, 0x93, 0xA2, 0x0F, 0xA0, 0xF2 + }, + { + 0x65, 0x32, 0xA0, 0xC4, 0x01, 0xC4, 0x4C, 0xB4, + 0xF3, 0x1B, 0x42, 0x68, 0xE6, 0xDE, 0xAC, 0x97, + 0xB5, 0xD7, 0xC7, 0x34, 0x15, 0xA4, 0x7D, 0x5B, + 0xD6, 0x81, 0x1F, 0xB8, 0x53, 0x12, 0xCE, 0x9C + }, + { + 0x50, 0x31, 0xDD, 0xF4, 0x84, 0xBC, 0x2C, 0x4B, + 0x86, 0x3E, 0x5B, 0xD8, 0x23, 0xD5, 0x2D, 0x0B, + 0x91, 0x47, 0xBD, 0x70, 0xFD, 0x4E, 0x03, 0x46, + 0xF2, 0x14, 0xEE, 0xA6, 0x69, 0xEE, 0x1C, 0x25 + }, + { + 0x02, 0x08, 0xFC, 0x07, 0x8D, 0xD5, 0x30, 0xB5, + 0xBA, 0x5D, 0x6D, 0xCE, 0xC3, 0x4A, 0xA4, 0x3B, + 0x86, 0x03, 0x74, 0x0C, 0x8A, 0x12, 0x70, 0x3F, + 0xD0, 0x3C, 0x7C, 0x39, 0x23, 0x46, 0xF3, 0xD4 + }, + { + 0x6B, 0xF0, 0x0F, 0xCE, 0x6F, 0xC2, 0xFA, 0x48, + 0x5A, 0x56, 0x76, 0x2B, 0xF8, 0xF5, 0x2F, 0x31, + 0xFC, 0x2C, 0xC0, 0x2E, 0x78, 0x13, 0x33, 0xF1, + 0xA4, 0x14, 0x40, 0x88, 0x82, 0x1C, 0xFF, 0xC6 + }, + { + 0x2A, 0xC3, 0x0A, 0x29, 0x99, 0xEE, 0x0A, 0x32, + 0x7E, 0x57, 0x2D, 0xB9, 0x52, 0x5A, 0xA0, 0x0E, + 0xF3, 0x74, 0x6F, 0x4D, 0x7D, 0xFE, 0x38, 0x6D, + 0x1B, 0xD3, 0xA0, 0x40, 0x58, 0xB4, 0x3D, 0x83 + }, + { + 0x59, 0x7E, 0x75, 0x47, 0xFA, 0x38, 0xFF, 0x6C, + 0xDE, 0x91, 0x40, 0xAB, 0x36, 0x77, 0x14, 0xB8, + 0xF3, 0x2F, 0x8D, 0xA9, 0xA5, 0x8F, 0xAD, 0xDB, + 0xB7, 0x79, 0xF7, 0x20, 0x0D, 0xFC, 0x7A, 0x8C + }, + { + 0xA0, 0x1F, 0xC4, 0x7C, 0xAB, 0x36, 0x07, 0x8B, + 0x5B, 0xF1, 0x69, 0xE9, 0xCE, 0xE2, 0xF7, 0x9D, + 0xAA, 0x94, 0xAD, 0x7A, 0x52, 0x3B, 0x32, 0x8B, + 0x97, 0x90, 0x63, 0x92, 0xD9, 0xDA, 0x19, 0x3E + }, + { + 0x06, 0x12, 0x51, 0x15, 0x96, 0x21, 0xE1, 0xFE, + 0x48, 0xDE, 0x32, 0x47, 0x16, 0x66, 0xD6, 0x52, + 0x8D, 0x6B, 0x4D, 0x8C, 0x0F, 0x69, 0xE4, 0xA7, + 0x34, 0xCC, 0x54, 0x5A, 0x47, 0x49, 0x14, 0xEB + }, + { + 0xF0, 0x6C, 0xC2, 0xA8, 0xA8, 0x4F, 0xDE, 0xC1, + 0x8B, 0xB5, 0x57, 0x4D, 0x84, 0x36, 0xB6, 0xB8, + 0x5C, 0x35, 0x8A, 0x8F, 0x58, 0x2E, 0x59, 0xC0, + 0x7A, 0x68, 0xD5, 0xF0, 0x01, 0x9F, 0xC5, 0xC2 + }, + { + 0x86, 0xD7, 0x3A, 0xE5, 0xF7, 0x69, 0x13, 0x1D, + 0x67, 0x22, 0x27, 0xC0, 0xC8, 0xDD, 0x7A, 0x9F, + 0x3B, 0xCD, 0x45, 0xA9, 0x4A, 0x6A, 0x4A, 0x96, + 0x60, 0x7C, 0x76, 0x4B, 0x79, 0x5E, 0xED, 0x27 + }, + { + 0xA1, 0xF3, 0x12, 0xE7, 0xAC, 0xDD, 0x7F, 0x30, + 0x77, 0x4A, 0xFA, 0x44, 0xD3, 0x8F, 0xCA, 0xE5, + 0x6D, 0x3D, 0x3B, 0x13, 0xF1, 0x83, 0xAB, 0x38, + 0x14, 0x3F, 0x2D, 0x31, 0xF2, 0x33, 0x23, 0xBF + }, + { + 0x20, 0x5B, 0xE6, 0x18, 0x9B, 0x9E, 0x7F, 0x80, + 0x00, 0xF8, 0x62, 0x83, 0xEC, 0x2F, 0xC5, 0x6D, + 0xC8, 0x99, 0xD9, 0x7F, 0x84, 0xE7, 0xA1, 0xC5, + 0xA4, 0xAE, 0xCC, 0x33, 0xE9, 0x28, 0xE9, 0x64 + }, + { + 0xEE, 0x61, 0xD2, 0x56, 0xDD, 0x50, 0x11, 0x57, + 0x84, 0xE3, 0x33, 0x97, 0x72, 0x21, 0xB6, 0x91, + 0xBF, 0x2F, 0x65, 0xDC, 0x07, 0x6B, 0x8E, 0x2C, + 0x37, 0xF5, 0x7A, 0xCE, 0x50, 0xD1, 0xF4, 0x8D + }, + { + 0xBA, 0x4C, 0xED, 0x4C, 0xD7, 0x4E, 0x07, 0xBE, + 0xB4, 0x8F, 0x1C, 0x0C, 0xBD, 0xFA, 0x0F, 0xCA, + 0x14, 0x2C, 0x7D, 0x43, 0xF3, 0xBF, 0x54, 0x38, + 0x39, 0xD9, 0x75, 0x1E, 0x0A, 0x8F, 0xEB, 0xA6 + }, + { + 0xDA, 0x84, 0x65, 0x9E, 0x02, 0x96, 0xF5, 0x53, + 0xED, 0x7E, 0xB8, 0x12, 0x5E, 0x79, 0xFC, 0x34, + 0x9C, 0x78, 0x4C, 0x50, 0x50, 0xF4, 0x20, 0x99, + 0x11, 0xC3, 0x65, 0xE6, 0x8B, 0xFD, 0xD5, 0x59 + }, + { + 0xA0, 0xF1, 0xC7, 0x4E, 0xC7, 0x11, 0x07, 0x14, + 0x25, 0x29, 0x95, 0x31, 0xBC, 0xFC, 0xB9, 0xDA, + 0xEC, 0x1B, 0xFD, 0x3E, 0x7E, 0x7D, 0x69, 0x5E, + 0x7C, 0x88, 0xE3, 0x60, 0x78, 0x57, 0xFD, 0xDD + }, + { + 0xBB, 0x4F, 0x8D, 0xD1, 0x72, 0x96, 0xDB, 0x68, + 0x7E, 0x2E, 0x43, 0x55, 0x22, 0xBF, 0xAF, 0xB7, + 0xEB, 0x96, 0xD4, 0x64, 0xE9, 0x5B, 0x1B, 0x36, + 0x19, 0xB4, 0x46, 0x22, 0x57, 0x72, 0xB8, 0x3D + }, + { + 0xCF, 0xE6, 0xFF, 0xF6, 0x5E, 0xDC, 0x3C, 0x64, + 0x24, 0xE7, 0xAD, 0x71, 0x5D, 0xB5, 0xEA, 0x01, + 0xFF, 0x8B, 0x0E, 0x18, 0x5A, 0x39, 0xBA, 0xCE, + 0xE2, 0xB0, 0x1F, 0x81, 0x61, 0x00, 0x9A, 0x96 + }, + { + 0x04, 0x1D, 0x99, 0xB1, 0xFE, 0x72, 0x8D, 0xDA, + 0x1A, 0x50, 0xCC, 0xAD, 0x5A, 0xFB, 0xBA, 0xF8, + 0x33, 0x61, 0x50, 0xA5, 0xA0, 0x7C, 0x14, 0xF5, + 0x15, 0x71, 0xEC, 0x0B, 0x6C, 0x7C, 0x29, 0x1C + }, + { + 0x77, 0xBF, 0x2A, 0xC1, 0xAB, 0x9C, 0xAC, 0xEA, + 0x55, 0x6E, 0x44, 0x27, 0x28, 0xB1, 0x5B, 0xB5, + 0x39, 0xBF, 0xE4, 0x02, 0x05, 0xAF, 0x0B, 0x01, + 0xD2, 0x9E, 0x5C, 0xED, 0x54, 0x9D, 0xD0, 0xF1 + }, + { + 0x6B, 0x57, 0xA2, 0xC1, 0x26, 0xAC, 0xC4, 0x85, + 0x66, 0xF3, 0x60, 0x51, 0x93, 0xE2, 0x02, 0x62, + 0xB4, 0xE5, 0x9F, 0x51, 0x11, 0x1E, 0xAB, 0x60, + 0xD6, 0xF3, 0x76, 0xCB, 0x46, 0x4C, 0x61, 0xA8 + }, + { + 0xFD, 0xD3, 0x3F, 0xF8, 0xA7, 0x7C, 0x2C, 0x52, + 0x2B, 0x92, 0xFA, 0x64, 0xAD, 0xB1, 0xFC, 0xD7, + 0xEE, 0x39, 0x47, 0xCD, 0x87, 0x70, 0xA0, 0xB0, + 0x96, 0x54, 0x77, 0x51, 0x95, 0xB8, 0x7B, 0x2C + }, + { + 0xCA, 0xCE, 0xB9, 0x5C, 0x18, 0x75, 0xCA, 0x93, + 0x08, 0x01, 0xB3, 0x42, 0x3F, 0xE4, 0x92, 0x75, + 0x56, 0x6C, 0xA4, 0xD8, 0x56, 0x4E, 0x17, 0xF1, + 0x49, 0x3A, 0xE7, 0xEB, 0x3B, 0x4F, 0x61, 0xBA + }, + { + 0x18, 0x55, 0xC6, 0x75, 0xB4, 0xCC, 0xCC, 0x4F, + 0x42, 0x0A, 0xDF, 0x9A, 0x1B, 0x0A, 0x46, 0xCA, + 0x88, 0xA2, 0xEA, 0xD3, 0x6B, 0xC4, 0xAD, 0xBC, + 0x0F, 0xDF, 0xBD, 0x0D, 0xCA, 0x45, 0xA3, 0xDA + }, + { + 0xAC, 0xF8, 0x13, 0x07, 0x01, 0x59, 0xD9, 0x1B, + 0xA9, 0xA3, 0xB0, 0x46, 0x6A, 0x70, 0x8B, 0x35, + 0xF5, 0x79, 0x28, 0xC3, 0xE6, 0x36, 0xAC, 0x37, + 0xC4, 0x53, 0xDD, 0xBE, 0xF0, 0xE3, 0x3C, 0xA7 + }, + { + 0x4C, 0x5C, 0x3E, 0xA0, 0x3E, 0xA7, 0xF0, 0x2A, + 0x99, 0x38, 0xD4, 0x98, 0x3A, 0x0D, 0xCF, 0xAD, + 0x9C, 0xFA, 0xFF, 0x2C, 0xA2, 0x78, 0x2B, 0x48, + 0xF9, 0x33, 0xA7, 0x4D, 0xA1, 0x01, 0x5A, 0xC2 + }, + { + 0x14, 0x6D, 0x2B, 0x7A, 0xDF, 0x41, 0x3A, 0x20, + 0x28, 0x4E, 0x4D, 0xC2, 0xB2, 0x23, 0x34, 0x21, + 0x4A, 0xD0, 0xED, 0x6E, 0x95, 0x4B, 0x24, 0xBE, + 0xA9, 0x07, 0x6C, 0x61, 0xBC, 0x3C, 0x6E, 0xB6 + }, + { + 0x66, 0xA4, 0xAB, 0x0C, 0xC9, 0x94, 0x70, 0xB0, + 0xB7, 0x88, 0x1B, 0x37, 0xBF, 0x16, 0x5F, 0x7D, + 0xB6, 0x70, 0xD2, 0x97, 0x70, 0x71, 0x0F, 0x38, + 0x5A, 0x53, 0x9F, 0x42, 0xB0, 0xCE, 0x6F, 0xE1 + }, + { + 0x4F, 0xB0, 0x15, 0xB5, 0x52, 0xB6, 0xCE, 0xEE, + 0xE7, 0x6A, 0xC5, 0xE9, 0x0D, 0x90, 0x9F, 0x4D, + 0xF6, 0x1D, 0x31, 0x06, 0x03, 0xA9, 0x51, 0x01, + 0x26, 0x6F, 0x5D, 0xAB, 0x37, 0xD2, 0xB6, 0x36 + }, + { + 0x06, 0xAA, 0x10, 0x7F, 0x12, 0xC7, 0x19, 0xE6, + 0x52, 0xE5, 0x5D, 0x89, 0x61, 0x4E, 0x76, 0xE1, + 0xEF, 0x0D, 0x13, 0x7B, 0x57, 0x8D, 0xFB, 0xBF, + 0x50, 0xF1, 0xDC, 0x6F, 0xA4, 0x69, 0x8E, 0xDF + }, + { + 0x89, 0xBB, 0x67, 0xE9, 0x9A, 0x4A, 0x9B, 0x8C, + 0xF7, 0x3F, 0x70, 0xA7, 0x4E, 0xC2, 0xB0, 0x54, + 0x3E, 0x37, 0x21, 0x94, 0x19, 0x95, 0xC9, 0xBA, + 0x2C, 0x89, 0xDE, 0x80, 0xA4, 0x1A, 0x4C, 0x70 + }, + { + 0x64, 0x07, 0xB8, 0x0E, 0xDD, 0x5D, 0x77, 0x8C, + 0x4F, 0x3E, 0x8D, 0x43, 0x52, 0x9E, 0x8E, 0x5D, + 0x6E, 0xC8, 0x88, 0xE5, 0xC1, 0xDB, 0x6A, 0x58, + 0x76, 0x44, 0x48, 0x4D, 0x55, 0x65, 0xA2, 0xF3 + }, + { + 0xE6, 0x31, 0x60, 0xA5, 0x69, 0xEE, 0x17, 0xA8, + 0x9E, 0x11, 0x04, 0x03, 0x59, 0xA4, 0x74, 0x4F, + 0x67, 0xB2, 0xD2, 0x23, 0x1D, 0x63, 0x34, 0xF8, + 0x1E, 0x79, 0xDB, 0x3A, 0x1D, 0x65, 0xED, 0xD6 + }, + { + 0x56, 0x8E, 0x7B, 0x4C, 0x33, 0x3A, 0x39, 0x0F, + 0xEF, 0x25, 0x6C, 0x61, 0xB1, 0xA9, 0x31, 0x98, + 0xBF, 0xDC, 0x90, 0xF3, 0xAA, 0x64, 0x7C, 0x3A, + 0xFB, 0xC8, 0x70, 0x1D, 0x60, 0x4C, 0xD4, 0x0B + }, + { + 0xE9, 0x03, 0x2C, 0xE4, 0x52, 0x35, 0xBF, 0x88, + 0xCA, 0x22, 0x63, 0xFA, 0xA2, 0x5A, 0xB5, 0xE0, + 0xA5, 0x65, 0x4D, 0x2D, 0x8E, 0x7F, 0x99, 0x13, + 0x14, 0x93, 0x57, 0xD5, 0xE4, 0x7A, 0x3E, 0xE6 + }, + { + 0xF2, 0xE4, 0x0E, 0x91, 0xED, 0xE1, 0x40, 0x0B, + 0xD5, 0x83, 0xDB, 0x00, 0xD2, 0xC7, 0x04, 0x7A, + 0x22, 0x18, 0x86, 0x5A, 0x1F, 0x69, 0x77, 0xAD, + 0x47, 0xFC, 0x9F, 0x64, 0x87, 0xAB, 0xA3, 0xF8 + }, + { + 0xB5, 0xC2, 0xA5, 0xD9, 0xF8, 0xC2, 0xBF, 0x63, + 0x91, 0x99, 0x56, 0xAF, 0xC3, 0xA6, 0xB4, 0x1A, + 0x08, 0x48, 0xC6, 0x30, 0xBB, 0x5C, 0xE8, 0x80, + 0x78, 0x1B, 0x7D, 0xC1, 0xEE, 0x55, 0x5A, 0xB5 + }, + { + 0x0C, 0xA5, 0x81, 0x97, 0x4F, 0x0B, 0x8F, 0xCE, + 0x6F, 0xE4, 0x10, 0xCA, 0x45, 0x79, 0xC3, 0x7F, + 0xA1, 0xD5, 0x35, 0xC0, 0x66, 0xAF, 0xBC, 0x97, + 0x94, 0x2F, 0xF3, 0x1B, 0xCF, 0x02, 0x26, 0xD5 + }, + { + 0xD6, 0xB7, 0x19, 0x7B, 0xD0, 0xF9, 0xF9, 0x1D, + 0x1D, 0xFC, 0xE8, 0x92, 0x0E, 0x0E, 0xC2, 0x4E, + 0xFE, 0xDC, 0xC5, 0xC8, 0x30, 0x4F, 0xC7, 0x1F, + 0x7E, 0xF4, 0xDD, 0xCF, 0xD2, 0xA6, 0x05, 0x68 + }, + { + 0x5D, 0x8A, 0x65, 0xBF, 0xE3, 0xA3, 0x19, 0x7A, + 0xC6, 0x86, 0x7B, 0x7E, 0x93, 0x01, 0x56, 0xFC, + 0xE6, 0xAD, 0x36, 0x10, 0x8E, 0xBE, 0x2D, 0x3F, + 0x08, 0xB3, 0xE9, 0xA7, 0xAA, 0x8F, 0x63, 0x3A + }, + { + 0xC4, 0x02, 0xE6, 0x83, 0x72, 0x12, 0x30, 0x23, + 0x25, 0x56, 0xA6, 0xEE, 0x1D, 0x0D, 0x30, 0x2A, + 0x44, 0x9D, 0x6F, 0x4B, 0xEA, 0xF4, 0x58, 0xB5, + 0xC3, 0x7A, 0xC4, 0xBC, 0x5B, 0x1B, 0xBC, 0x6A + }, + { + 0xBB, 0x30, 0x34, 0x27, 0xEF, 0xEE, 0x5F, 0x6C, + 0xAD, 0xF1, 0xDC, 0x2F, 0xD1, 0x9F, 0x14, 0x65, + 0x31, 0xB7, 0xBE, 0xEA, 0xEF, 0x55, 0x83, 0x71, + 0xE5, 0x14, 0x23, 0xC5, 0xBA, 0xF8, 0xED, 0xD8 + }, + { + 0x5B, 0x8D, 0x44, 0x10, 0x24, 0x46, 0x98, 0x94, + 0xFD, 0x0F, 0x69, 0xD9, 0x15, 0xE0, 0x1E, 0x04, + 0x57, 0xA9, 0x2C, 0x57, 0xC0, 0x47, 0xBB, 0xB4, + 0xD7, 0x4D, 0x8A, 0x78, 0x2D, 0x8B, 0x18, 0x22 + }, + { + 0xD2, 0xA7, 0x41, 0x5B, 0x5B, 0x68, 0x5B, 0x71, + 0x10, 0x76, 0x2A, 0xB9, 0xD1, 0xDC, 0x1F, 0x96, + 0x99, 0x0C, 0x97, 0x0A, 0x06, 0xE0, 0x51, 0xBB, + 0xF2, 0xBC, 0x39, 0x0F, 0x8D, 0x41, 0x5B, 0xE8 + }, + { + 0x37, 0xA7, 0x66, 0x1B, 0x52, 0xE2, 0x2E, 0xCD, + 0x52, 0x5B, 0x91, 0x32, 0x95, 0xA9, 0x4F, 0x04, + 0x01, 0xC0, 0x11, 0x71, 0x69, 0xEC, 0xE2, 0xE6, + 0x37, 0x02, 0x27, 0xC4, 0x08, 0xF7, 0xED, 0x90 + }, + { + 0x0D, 0xA7, 0xCF, 0xBA, 0xC8, 0xD4, 0x2D, 0x27, + 0x2D, 0xED, 0x07, 0xA0, 0x0E, 0xBA, 0x79, 0x73, + 0x76, 0x65, 0x8D, 0x71, 0xD3, 0x01, 0x35, 0x70, + 0xC9, 0x80, 0x85, 0x00, 0x8C, 0xBC, 0xD8, 0xDC + }, + { + 0xDF, 0x5E, 0xF1, 0x9F, 0x16, 0x03, 0xAC, 0x67, + 0xEC, 0xDA, 0x52, 0xD3, 0x7F, 0x89, 0x98, 0x17, + 0xB3, 0x75, 0x91, 0xCC, 0x9E, 0x0D, 0x9D, 0xEB, + 0x0D, 0x9F, 0xC9, 0x31, 0xEC, 0x94, 0xFE, 0x67 + }, + { + 0x47, 0x1B, 0xAE, 0x0E, 0x65, 0xAC, 0x4E, 0xA6, + 0xF2, 0x1D, 0x05, 0xCE, 0x09, 0xD2, 0x6D, 0xF6, + 0xA9, 0xE4, 0x0C, 0x8A, 0x7E, 0x9E, 0xBF, 0xCE, + 0x12, 0xF9, 0x8F, 0x3E, 0x31, 0x33, 0xEB, 0x94 + }, + { + 0x1A, 0x67, 0x70, 0x27, 0x21, 0x6E, 0xF1, 0x2B, + 0x14, 0x04, 0xFC, 0x70, 0x90, 0x20, 0x38, 0x3B, + 0x16, 0x13, 0xD1, 0xAE, 0x28, 0x97, 0xAA, 0x3D, + 0x5C, 0xBB, 0x8C, 0x5F, 0x16, 0xE6, 0x6A, 0xFA + }, + { + 0x74, 0x1B, 0x6D, 0x54, 0x61, 0x91, 0x31, 0x1A, + 0x13, 0xDA, 0x0C, 0x47, 0x08, 0x72, 0x65, 0xA8, + 0x91, 0x4D, 0x8B, 0xCF, 0x0B, 0xE4, 0xC1, 0x28, + 0x9C, 0xE5, 0x77, 0x34, 0x79, 0x62, 0xF5, 0x24 + }, + { + 0xF0, 0x0E, 0x69, 0x33, 0x9F, 0xA0, 0x11, 0x88, + 0x30, 0xC4, 0xEB, 0x5D, 0x91, 0xA7, 0xAD, 0xDC, + 0xA0, 0x2C, 0x3E, 0x8F, 0x88, 0x73, 0xA2, 0x3B, + 0xF5, 0x34, 0x7A, 0xBC, 0x7F, 0x9B, 0x88, 0x5B + }, + { + 0xDD, 0xD1, 0x30, 0x3D, 0x7C, 0xFE, 0x33, 0xD1, + 0x43, 0x34, 0x79, 0x23, 0xF2, 0x63, 0x8B, 0x3D, + 0x8A, 0x47, 0xE6, 0x82, 0xE7, 0xCE, 0x47, 0x05, + 0x42, 0x75, 0x09, 0xAF, 0xD7, 0xB3, 0xF4, 0x13 + }, + { + 0x5C, 0x71, 0xDD, 0xDC, 0x11, 0x02, 0x9A, 0x4F, + 0x8C, 0x52, 0x34, 0x79, 0xB0, 0x33, 0xEF, 0xB4, + 0xF8, 0xAF, 0x6D, 0x81, 0x90, 0x82, 0x03, 0x80, + 0xEB, 0x46, 0x20, 0x08, 0x70, 0x3B, 0x50, 0x70 + }, + { + 0xAB, 0x1A, 0xC7, 0x7F, 0xCE, 0x2E, 0x58, 0xF0, + 0x95, 0x20, 0x47, 0xD0, 0x91, 0xD4, 0x03, 0xC5, + 0xA3, 0x75, 0x32, 0x32, 0x13, 0xFF, 0x0A, 0x59, + 0x16, 0x0D, 0x76, 0xEB, 0xAE, 0xFF, 0x9B, 0xB6 + }, + { + 0x95, 0x4D, 0x40, 0x04, 0x84, 0x0D, 0x1F, 0xBE, + 0xA2, 0xCD, 0x08, 0x96, 0x97, 0xA0, 0x64, 0x80, + 0x96, 0x9A, 0x61, 0x3F, 0xCC, 0x93, 0x03, 0x02, + 0x23, 0xD6, 0x6B, 0x4C, 0x50, 0xF8, 0x8D, 0x6B + }, + { + 0x44, 0x16, 0xE6, 0x58, 0x7B, 0x05, 0x75, 0x17, + 0x7D, 0x22, 0x3C, 0xBC, 0x0F, 0xC2, 0xC8, 0x13, + 0xB5, 0x0B, 0x67, 0x2A, 0xE5, 0x92, 0xA5, 0x40, + 0x9A, 0xB9, 0xA9, 0xB8, 0x16, 0x9D, 0x9C, 0x24 + }, + { + 0x2C, 0xCD, 0x1E, 0x50, 0xA9, 0x82, 0x65, 0x56, + 0xE3, 0xE5, 0xB9, 0x7B, 0x7F, 0xC2, 0xB2, 0x2B, + 0x53, 0x6A, 0x45, 0x82, 0xEA, 0xDD, 0x8F, 0x42, + 0xFF, 0x70, 0x0F, 0x05, 0x94, 0xD0, 0xA4, 0x64 + }, + { + 0x08, 0x8C, 0xE4, 0xE7, 0x2D, 0x0A, 0xFC, 0xC0, + 0x9A, 0x67, 0xC0, 0x51, 0xD5, 0x34, 0x82, 0x8A, + 0x7C, 0xFD, 0x3F, 0xD0, 0x2D, 0x02, 0xAD, 0xB6, + 0xF5, 0x81, 0x75, 0x3F, 0xCB, 0x27, 0xDC, 0x3A + }, + { + 0x80, 0x99, 0xB6, 0x71, 0x47, 0x56, 0xE0, 0xA5, + 0xEB, 0x11, 0xEA, 0x38, 0x0A, 0x75, 0x58, 0x95, + 0xC8, 0xD9, 0xBD, 0xC1, 0xD6, 0xAD, 0x5B, 0x79, + 0xFC, 0xC3, 0x14, 0x48, 0x27, 0xAB, 0x86, 0x45 + }, + { + 0xBE, 0xD0, 0xC2, 0x99, 0xCB, 0x62, 0x5E, 0x61, + 0xDD, 0x80, 0xF5, 0xBE, 0x3B, 0xE8, 0x47, 0x2B, + 0xE4, 0x16, 0xF6, 0x4B, 0x16, 0xB4, 0x34, 0x56, + 0x54, 0x61, 0x0B, 0x53, 0xA4, 0x0C, 0xDE, 0x81 + }, + { + 0x09, 0xFF, 0x67, 0x36, 0xE1, 0x5D, 0x13, 0xB3, + 0xC0, 0x73, 0x1E, 0xB7, 0x45, 0x24, 0xD6, 0xE9, + 0xE5, 0x93, 0x6C, 0x99, 0x47, 0x36, 0x78, 0x08, + 0xAE, 0xF6, 0x44, 0x69, 0x8F, 0x9E, 0xEC, 0x1B + }, + { + 0xD4, 0x53, 0x9E, 0xBA, 0x6F, 0x46, 0xD0, 0x1C, + 0xBF, 0x75, 0x28, 0xF9, 0x4F, 0x04, 0x08, 0xC0, + 0x1B, 0x35, 0xF6, 0xB7, 0xD2, 0x0D, 0xA9, 0xCB, + 0x68, 0x25, 0xA3, 0xEA, 0x41, 0x64, 0x4D, 0xE4 + }, + { + 0x77, 0x37, 0xE9, 0x2A, 0xD1, 0xCA, 0x70, 0xBF, + 0xBB, 0x0B, 0xAB, 0x74, 0xC3, 0x16, 0xFC, 0x52, + 0x12, 0x62, 0xAC, 0x94, 0x8E, 0x58, 0x6C, 0xC2, + 0x99, 0x7D, 0x32, 0x8E, 0x85, 0x0C, 0x65, 0xF9 + }, + { + 0x48, 0x44, 0x11, 0x93, 0x0F, 0x4E, 0x14, 0x1C, + 0x4D, 0x98, 0xFC, 0xE3, 0xDF, 0x58, 0xFC, 0x8C, + 0x46, 0x18, 0x03, 0x26, 0x12, 0x66, 0x3A, 0xA0, + 0xD5, 0x9F, 0x53, 0x25, 0x8A, 0xD5, 0x83, 0x11 + }, + { + 0x9C, 0x25, 0xA1, 0x6C, 0x67, 0x3D, 0x46, 0xCE, + 0x7B, 0x6A, 0x2B, 0x2D, 0xD5, 0x03, 0x88, 0x99, + 0x22, 0x88, 0x6F, 0x39, 0x4B, 0x2E, 0xF2, 0x1A, + 0x1C, 0x3F, 0xF0, 0x24, 0x57, 0x94, 0x7B, 0xCF + }, + { + 0x76, 0x26, 0x51, 0x4A, 0xDE, 0x67, 0x6D, 0x0E, + 0x64, 0x07, 0x1D, 0xD9, 0xB8, 0x9E, 0xEC, 0xF6, + 0xA8, 0xC3, 0x4E, 0xB2, 0x72, 0x06, 0xAB, 0xA3, + 0xC4, 0x97, 0x6C, 0xAD, 0x9C, 0x93, 0x31, 0x14 + }, + { + 0xCA, 0xBF, 0xA1, 0x5B, 0xE0, 0x2B, 0x1B, 0x19, + 0xED, 0x66, 0xC4, 0xB0, 0x2A, 0x99, 0x2E, 0x8D, + 0x17, 0xE4, 0xE9, 0x08, 0xA8, 0x8E, 0xC4, 0x61, + 0x5D, 0x02, 0x2B, 0x7C, 0x30, 0x9E, 0x75, 0x9B + }, + { + 0xD7, 0xC0, 0xC3, 0x73, 0xF4, 0x0F, 0x6B, 0x2D, + 0x81, 0x79, 0x5A, 0x43, 0x35, 0xA7, 0x51, 0x52, + 0x97, 0xBC, 0x3F, 0xC4, 0xB0, 0x2D, 0x8F, 0x92, + 0xDA, 0xF9, 0xC8, 0xAC, 0x17, 0x9C, 0xA7, 0x93 + }, + { + 0x9E, 0x5A, 0x08, 0x8A, 0x4E, 0xF2, 0x7E, 0x5E, + 0xF9, 0x62, 0x85, 0x53, 0x1C, 0xC5, 0x68, 0xFD, + 0x89, 0xE9, 0x3E, 0xC5, 0x4F, 0x35, 0x55, 0xC7, + 0x47, 0x77, 0x68, 0x31, 0x9B, 0xF4, 0x5C, 0x70 + }, + { + 0xAC, 0xBB, 0xB8, 0x90, 0x9E, 0x5F, 0x92, 0xA8, + 0xD7, 0x40, 0xEE, 0xD0, 0xF0, 0xFC, 0x3E, 0x45, + 0xEA, 0xFB, 0xE2, 0x42, 0xF5, 0xF5, 0x75, 0xB9, + 0x5F, 0xD1, 0xC4, 0x37, 0x78, 0x79, 0x73, 0x38 + }, + { + 0x9E, 0xEC, 0xF9, 0xDA, 0xBF, 0x1E, 0xEA, 0x0B, + 0xEA, 0x78, 0x8B, 0x8D, 0x40, 0x7F, 0xDE, 0x96, + 0xC7, 0x1E, 0x51, 0x59, 0x3B, 0x97, 0x81, 0xB7, + 0x2D, 0x9E, 0x39, 0x27, 0x78, 0xA2, 0x07, 0x07 + }, + { + 0x09, 0xE5, 0x5E, 0xEE, 0x2B, 0x4A, 0xCC, 0xF2, + 0xE1, 0x0C, 0xD7, 0xA0, 0x97, 0x8E, 0x69, 0xB6, + 0x29, 0xA1, 0x8E, 0xFD, 0xD4, 0x65, 0x2F, 0x3A, + 0xDE, 0xD9, 0x49, 0xBE, 0x6B, 0x6B, 0x2C, 0x90 + }, + { + 0x63, 0x71, 0xD3, 0x7E, 0xBB, 0x19, 0x53, 0x8B, + 0x82, 0x27, 0x85, 0x14, 0xA0, 0xCC, 0xD1, 0x35, + 0x11, 0x00, 0xC8, 0x8F, 0x99, 0x4C, 0xDD, 0x37, + 0xA1, 0x8E, 0x93, 0x8A, 0x38, 0xE9, 0x10, 0xC7 + }, + { + 0xF2, 0x5B, 0x09, 0xDB, 0xFC, 0xEF, 0x92, 0x44, + 0x6D, 0x48, 0xCC, 0xB5, 0xF5, 0x04, 0xBB, 0x39, + 0xD7, 0x06, 0x13, 0x53, 0xF7, 0x51, 0x0F, 0x0E, + 0xF7, 0x58, 0x93, 0x93, 0x60, 0x59, 0x15, 0x24 + }, + { + 0xBF, 0x7B, 0x9B, 0x45, 0xED, 0x92, 0x39, 0xB6, + 0xCF, 0x85, 0xA6, 0x9E, 0x26, 0x43, 0x4A, 0x9F, + 0x32, 0x8F, 0x44, 0xCE, 0x67, 0xAF, 0x49, 0xC5, + 0x31, 0x27, 0x72, 0x33, 0x7D, 0x37, 0xFB, 0xEF + }, + { + 0xFB, 0xA2, 0x24, 0xEB, 0x86, 0x1F, 0xA8, 0x85, + 0x2C, 0x70, 0x0B, 0xC7, 0xE2, 0x85, 0x08, 0x87, + 0x2D, 0xC2, 0x37, 0xCB, 0x7A, 0xD7, 0xA0, 0x57, + 0x93, 0xB0, 0x2F, 0xDD, 0x56, 0xA0, 0xC2, 0x1A + }, + { + 0x82, 0x43, 0x04, 0xE2, 0xF3, 0x22, 0x79, 0xFE, + 0xF6, 0xD2, 0xAE, 0xB5, 0x3A, 0x82, 0x5B, 0xA1, + 0x60, 0x78, 0x6D, 0x8A, 0xA6, 0x27, 0x56, 0xEB, + 0x83, 0x42, 0xA2, 0xB2, 0x7E, 0xBE, 0x04, 0x4C + }, + { + 0xB2, 0xA1, 0x57, 0x12, 0x3F, 0xDE, 0x8C, 0x76, + 0x12, 0x39, 0x10, 0x36, 0x1E, 0xF4, 0xD0, 0xA2, + 0xF8, 0xBD, 0x32, 0x9F, 0x9C, 0x83, 0x92, 0x13, + 0x14, 0xDA, 0xB2, 0x7B, 0xAB, 0xB1, 0x8E, 0xF1 + }, + { + 0x36, 0x1A, 0x05, 0x6A, 0x77, 0x78, 0x2B, 0xC5, + 0x18, 0x30, 0xD2, 0x7F, 0xBC, 0xA5, 0xDF, 0xD1, + 0x00, 0xA0, 0x02, 0xD4, 0x88, 0xFF, 0xA8, 0xA7, + 0xF9, 0x84, 0x09, 0x68, 0x4E, 0x82, 0x24, 0x97 + }, + { + 0x33, 0xE1, 0x6D, 0xFB, 0x50, 0xFA, 0xAD, 0x9B, + 0xE2, 0xF7, 0xA8, 0xF4, 0x13, 0xB1, 0xB4, 0xF9, + 0x99, 0x8C, 0xF5, 0xDC, 0x82, 0x77, 0xDD, 0xBE, + 0xD7, 0x5C, 0xCD, 0xAC, 0x8B, 0x4A, 0x5E, 0x68 + }, + { + 0x23, 0xAD, 0xF5, 0x5C, 0x5E, 0xA1, 0x4C, 0xC9, + 0x54, 0xE1, 0x3E, 0xFC, 0xE2, 0x60, 0x78, 0x86, + 0x01, 0x83, 0x46, 0xD4, 0x76, 0xB1, 0x26, 0x93, + 0x85, 0x38, 0x94, 0xDA, 0xDC, 0x2D, 0x6B, 0xB4 + }, + { + 0xE0, 0x92, 0x2E, 0x53, 0x4F, 0xAF, 0xDB, 0x78, + 0xC6, 0x7C, 0xEB, 0x44, 0x53, 0xF2, 0x11, 0xAF, + 0x94, 0xEE, 0xDC, 0x5C, 0x2C, 0xF4, 0xEE, 0x5D, + 0x79, 0xF8, 0x2E, 0x8E, 0xC3, 0x3C, 0x83, 0xC1 + }, + { + 0x85, 0x42, 0x29, 0x9A, 0xD7, 0x2B, 0x4E, 0x61, + 0x17, 0x10, 0x52, 0xDD, 0xC3, 0x7C, 0x96, 0xB5, + 0xC3, 0x83, 0x09, 0x33, 0x5C, 0x02, 0x16, 0x1D, + 0xA0, 0xD6, 0x91, 0xB6, 0x05, 0xAE, 0x59, 0x9C + }, + { + 0xFE, 0xFD, 0x43, 0x21, 0x43, 0xA0, 0x23, 0x76, + 0x89, 0x8E, 0x2D, 0xD4, 0xAB, 0x77, 0x8F, 0x5A, + 0x41, 0xDC, 0xFF, 0xF9, 0xCB, 0x97, 0xBB, 0x6B, + 0x79, 0x8B, 0x95, 0x74, 0x46, 0x90, 0xF6, 0xFE + }, + { + 0xF5, 0xA4, 0xDE, 0x10, 0xA1, 0x21, 0xC7, 0xDD, + 0x4F, 0xE2, 0x4F, 0x0E, 0x79, 0xA2, 0xB9, 0x66, + 0x44, 0xC2, 0x01, 0x21, 0x8C, 0xD0, 0x54, 0xA6, + 0x90, 0x5C, 0xB9, 0xC7, 0x6F, 0x83, 0x77, 0x7A + }, + { + 0x7C, 0xC9, 0x84, 0x20, 0xE8, 0xD4, 0xEC, 0x50, + 0xCB, 0xB0, 0x68, 0x47, 0x17, 0xBF, 0x29, 0x4C, + 0x9A, 0x0A, 0xC7, 0x07, 0x8C, 0xF7, 0x8B, 0x6C, + 0x96, 0x62, 0xDC, 0xFF, 0xCC, 0x7C, 0xCA, 0xBE + }, + { + 0x03, 0x0F, 0xCC, 0xFB, 0x10, 0x61, 0x1D, 0xED, + 0x10, 0x2E, 0xB0, 0x67, 0xF7, 0x1C, 0x5F, 0xB3, + 0xEF, 0xBA, 0x11, 0xE0, 0xE8, 0xCA, 0x8E, 0x87, + 0x8A, 0x2C, 0x0B, 0x8D, 0xA1, 0xBB, 0x63, 0xBD + }, + { + 0xE7, 0x3D, 0x29, 0xC1, 0x41, 0xBC, 0x77, 0xB7, + 0x07, 0x70, 0xAD, 0x63, 0xDB, 0x79, 0x9E, 0x8D, + 0x7A, 0xB7, 0x05, 0x6F, 0xAB, 0x3D, 0x8A, 0xEA, + 0xCE, 0x76, 0xC8, 0xFA, 0x7A, 0x0B, 0x40, 0xD5 + }, + { + 0xDE, 0xD2, 0xB3, 0xBE, 0x0F, 0xDD, 0xA2, 0x40, + 0x8E, 0x61, 0x77, 0xA4, 0xC5, 0x2F, 0xC2, 0x9D, + 0x76, 0x1B, 0xA4, 0x33, 0x3E, 0xE8, 0x47, 0x2C, + 0x09, 0xE0, 0xA4, 0x72, 0x9E, 0x08, 0xE5, 0xA9 + }, + { + 0x51, 0x6E, 0x00, 0x60, 0xFE, 0x64, 0xC9, 0xC4, + 0x3E, 0x26, 0x89, 0x94, 0x8A, 0xED, 0xCF, 0xE7, + 0x47, 0xF6, 0x79, 0x52, 0x2A, 0x6A, 0x41, 0xF8, + 0xA0, 0xB4, 0x2E, 0x04, 0x19, 0xCC, 0x41, 0xBE + }, + { + 0x0B, 0x33, 0x61, 0x6B, 0x71, 0xFB, 0x3B, 0x74, + 0x1E, 0x46, 0xF7, 0xDA, 0xEC, 0x88, 0x58, 0x3F, + 0xD5, 0xFB, 0x3A, 0x55, 0xEB, 0x9A, 0xD0, 0x3C, + 0xE2, 0xF2, 0x3C, 0x6D, 0x14, 0xB8, 0xFC, 0xBF + }, + { + 0x05, 0x4D, 0x34, 0x8F, 0x53, 0x1C, 0xE1, 0x47, + 0x28, 0x5F, 0xC4, 0x34, 0x9D, 0xE4, 0x7B, 0xD6, + 0xAE, 0x5F, 0xB9, 0xE5, 0x72, 0xE6, 0x32, 0xFA, + 0xC8, 0x3A, 0x69, 0xFD, 0xD0, 0xB5, 0x10, 0xB3 + }, + { + 0xBA, 0xB1, 0x2D, 0x9B, 0x9B, 0xD3, 0xCD, 0xCD, + 0x6C, 0x48, 0x5A, 0xED, 0xFE, 0x0A, 0xE3, 0x13, + 0x18, 0xDC, 0x22, 0xA5, 0x8B, 0x29, 0xE9, 0xE9, + 0x64, 0x08, 0x69, 0x0E, 0xE5, 0xAE, 0xF3, 0x9C + }, + { + 0x16, 0x83, 0x07, 0x27, 0x90, 0x13, 0xA3, 0x02, + 0x28, 0xBC, 0xE5, 0x3B, 0xF4, 0x80, 0x7B, 0xBC, + 0x98, 0xAD, 0x91, 0xDE, 0x30, 0x09, 0x94, 0xD1, + 0xC8, 0xE0, 0x54, 0x7E, 0xC1, 0x76, 0x81, 0x46 + }, + { + 0xA3, 0x94, 0x78, 0xFD, 0x8F, 0x01, 0xF7, 0x6A, + 0x51, 0x99, 0x78, 0x88, 0x91, 0x5D, 0x44, 0x20, + 0x8B, 0xCE, 0x25, 0x8D, 0x2D, 0x32, 0x6A, 0x2D, + 0x7F, 0xFF, 0x82, 0x10, 0xE8, 0xEE, 0x08, 0x7B + }, + { + 0xC0, 0xD3, 0xF9, 0x7B, 0xFF, 0x9F, 0x24, 0xD9, + 0x00, 0xC6, 0x96, 0x5E, 0x58, 0xAC, 0xDE, 0x08, + 0xAA, 0xF4, 0xF0, 0x69, 0x60, 0x22, 0x58, 0x5A, + 0xF4, 0xF5, 0x09, 0x0F, 0xCD, 0x3A, 0x8D, 0x94 + }, + { + 0xF0, 0xF0, 0x4F, 0x83, 0xC7, 0xC0, 0x92, 0x4E, + 0xA1, 0x8F, 0xE1, 0x85, 0xB6, 0x1D, 0x1E, 0x6E, + 0x4E, 0xF0, 0x38, 0xA0, 0x87, 0xD5, 0xDC, 0x3E, + 0x5A, 0x40, 0x98, 0xD8, 0xF9, 0x78, 0x6B, 0x8E + }, + { + 0x3E, 0xF8, 0x57, 0x05, 0xCD, 0x1F, 0x5B, 0xCF, + 0x66, 0xD5, 0x0F, 0x68, 0xB5, 0x9B, 0x1F, 0x40, + 0xC5, 0x75, 0x0E, 0x34, 0x96, 0x1E, 0x3F, 0x26, + 0xC2, 0x30, 0x41, 0x84, 0x65, 0xE5, 0xE4, 0x2D + }, + { + 0x39, 0x74, 0xE3, 0x53, 0x32, 0xCE, 0xD6, 0xBE, + 0x4C, 0x76, 0xD6, 0x7B, 0xD9, 0xCC, 0xDB, 0x09, + 0x2B, 0xB4, 0x86, 0x54, 0x5F, 0xF5, 0x0E, 0xC2, + 0xBD, 0xE6, 0x5D, 0x5D, 0x73, 0xA3, 0x0A, 0xA7 + }, + { + 0xA9, 0x60, 0xFC, 0x2F, 0x84, 0x8B, 0xF5, 0x7A, + 0xC2, 0x89, 0x9F, 0x50, 0xDE, 0xC4, 0x2F, 0x5C, + 0xDB, 0xAB, 0x0D, 0x17, 0xA2, 0x6F, 0x79, 0x29, + 0x63, 0x24, 0x7C, 0x0B, 0xE9, 0x60, 0xE2, 0x4E + }, + { + 0x0A, 0xBE, 0x9C, 0x33, 0xFC, 0x25, 0x20, 0x54, + 0x0E, 0x53, 0xD6, 0xED, 0x8F, 0x2E, 0xFC, 0x06, + 0x44, 0xC1, 0x67, 0x58, 0x36, 0xF9, 0x57, 0xEC, + 0xF2, 0xD3, 0xA8, 0xE9, 0xE1, 0xE5, 0x45, 0x78 + }, + { + 0x28, 0x96, 0x9F, 0x24, 0x44, 0x96, 0x6A, 0xFF, + 0xBE, 0xE7, 0xF9, 0xC1, 0x59, 0xAB, 0xEB, 0xB6, + 0xCD, 0x25, 0x52, 0xD8, 0x29, 0x4F, 0x28, 0x7C, + 0xFF, 0x24, 0xDB, 0xAB, 0x47, 0xE4, 0xE7, 0x03 + }, + { + 0xB5, 0x4F, 0x5B, 0x16, 0x65, 0x89, 0x54, 0x6F, + 0x3B, 0xD2, 0xE7, 0x5A, 0x9F, 0xA8, 0x59, 0x32, + 0x2A, 0x35, 0x05, 0x3B, 0x49, 0x2B, 0x2F, 0xF8, + 0xFA, 0x39, 0xEE, 0xBB, 0xE0, 0x10, 0xE4, 0xAB + }, + { + 0xF7, 0xE4, 0x6E, 0x57, 0xF3, 0xF5, 0x32, 0x18, + 0xA5, 0xBE, 0x18, 0x21, 0x43, 0x19, 0xCD, 0x85, + 0x30, 0xD0, 0xF1, 0x6F, 0xB2, 0xBD, 0x0B, 0xB1, + 0x6F, 0x00, 0x97, 0x01, 0x77, 0x51, 0x72, 0xBA + }, + { + 0x15, 0xAF, 0x91, 0x81, 0x7A, 0x63, 0x8A, 0x6E, + 0xA8, 0x88, 0x8D, 0xF6, 0x9B, 0x8D, 0xFE, 0xE5, + 0x9C, 0x03, 0x4E, 0x2E, 0xB3, 0xB2, 0x41, 0x5E, + 0xB7, 0x50, 0xED, 0xE4, 0xFD, 0x8A, 0xCF, 0xC1 + }, + { + 0x6E, 0x66, 0xC3, 0x53, 0x37, 0x2D, 0xCD, 0x86, + 0x75, 0xC7, 0x6A, 0x37, 0x74, 0x01, 0xB2, 0x72, + 0xAA, 0x92, 0x8C, 0x34, 0x8B, 0x36, 0xD6, 0x93, + 0x81, 0x8B, 0xF8, 0x33, 0xA1, 0xD5, 0xA3, 0x40 + }, + { + 0x8F, 0x9B, 0x67, 0xDE, 0x3C, 0xE2, 0xC6, 0x0E, + 0x2B, 0x83, 0xAD, 0x86, 0xD7, 0xCE, 0x07, 0x66, + 0x22, 0x5A, 0x00, 0x34, 0x2A, 0x40, 0xB9, 0x2A, + 0xD3, 0x11, 0xEA, 0x25, 0x21, 0x55, 0x42, 0xAA + }, + { + 0x4B, 0xE6, 0x0E, 0x42, 0xA2, 0xCE, 0x20, 0x20, + 0x8C, 0x43, 0x62, 0x35, 0x35, 0xC3, 0xFC, 0x67, + 0xC1, 0xCF, 0x08, 0xAA, 0x40, 0x57, 0xDF, 0xCC, + 0xD8, 0x28, 0x35, 0x5F, 0xCE, 0x4A, 0x82, 0x9A + }, + { + 0x53, 0xE0, 0x2A, 0x7A, 0x7F, 0x56, 0xE7, 0x1B, + 0x09, 0x4B, 0xDF, 0x6A, 0xBE, 0xA8, 0xC1, 0xCF, + 0x5B, 0x1B, 0xAE, 0x13, 0xC3, 0x9F, 0x07, 0x37, + 0xDC, 0x11, 0xC8, 0xF4, 0xAB, 0x11, 0xA8, 0x9A + }, + { + 0x1D, 0x7D, 0xE2, 0xBC, 0x65, 0x2B, 0x06, 0xAC, + 0x43, 0xFD, 0x75, 0xBF, 0x8A, 0x20, 0x82, 0xED, + 0x3B, 0xE9, 0x48, 0xCB, 0xF3, 0x3B, 0x23, 0xB4, + 0x90, 0xD6, 0xA4, 0xF4, 0x5C, 0x20, 0xB7, 0x92 + }, + { + 0x4A, 0xE1, 0x81, 0x2C, 0xC6, 0x4F, 0xB3, 0x3F, + 0xA0, 0x47, 0x06, 0xE8, 0x22, 0xE5, 0x0C, 0xDF, + 0xED, 0x33, 0x70, 0xB1, 0x8D, 0x92, 0xA7, 0xE7, + 0x7B, 0x0D, 0x4D, 0x69, 0xCF, 0xDE, 0xA2, 0x86 + }, + { + 0x44, 0xA7, 0x6A, 0xA8, 0x7E, 0x1D, 0x41, 0x17, + 0x54, 0x16, 0x7D, 0x11, 0xEB, 0x91, 0x2B, 0xC6, + 0x5F, 0x97, 0x38, 0xAB, 0x3E, 0x95, 0x90, 0x09, + 0x25, 0x70, 0xD5, 0x65, 0x46, 0x90, 0xF6, 0x4E + }, + { + 0x70, 0x09, 0xE8, 0x5B, 0x1B, 0xA9, 0x2C, 0x20, + 0x38, 0x81, 0xF7, 0x76, 0x71, 0xCF, 0x27, 0xAD, + 0x83, 0x65, 0x36, 0xE2, 0x52, 0x28, 0x56, 0x33, + 0x5A, 0x55, 0x10, 0x54, 0x2E, 0xCB, 0xD6, 0xD1 + }, + { + 0xF6, 0x9B, 0xB1, 0xF5, 0xD0, 0x86, 0x3B, 0xAA, + 0xBE, 0xA4, 0x71, 0x80, 0x43, 0x08, 0x07, 0x68, + 0x03, 0xD8, 0x47, 0x7F, 0xF4, 0x4E, 0x8D, 0x7E, + 0x99, 0xEB, 0xF9, 0xA3, 0xF8, 0xDC, 0xAD, 0x1F + }, + { + 0x93, 0x62, 0x6D, 0x0F, 0xE7, 0xFE, 0xAD, 0xE8, + 0x50, 0x12, 0xC8, 0x90, 0x2E, 0x0F, 0xFB, 0xDF, + 0x34, 0x94, 0xC5, 0x8C, 0xF6, 0xB1, 0x4B, 0xFD, + 0xFD, 0xEC, 0x33, 0xB3, 0x63, 0x4D, 0x6D, 0x63 + }, + { + 0xA9, 0x2E, 0xB7, 0x32, 0x05, 0xB1, 0xBE, 0xB3, + 0x7A, 0x96, 0x46, 0x6F, 0xC0, 0x3C, 0xD5, 0xD0, + 0x39, 0x05, 0x76, 0x72, 0x5F, 0x3E, 0x72, 0xA9, + 0xE4, 0x58, 0x1E, 0x77, 0xD7, 0x15, 0x5C, 0xC1 + }, + { + 0x6B, 0xED, 0xA8, 0x64, 0x9D, 0x5B, 0x53, 0x54, + 0xF1, 0x51, 0x62, 0x95, 0x58, 0xE2, 0xC8, 0x73, + 0xEF, 0x36, 0x00, 0x52, 0xEC, 0xCD, 0xD0, 0xF4, + 0xA6, 0xB9, 0x64, 0xE0, 0x93, 0x26, 0x52, 0x27 + }, + { + 0xFE, 0x1C, 0x17, 0x3A, 0x07, 0x18, 0x1D, 0xA4, + 0xAC, 0xEC, 0x1E, 0xE9, 0xE5, 0x72, 0xDF, 0xE7, + 0xF5, 0x7B, 0xA7, 0x8F, 0x2A, 0xDA, 0xC9, 0x7A, + 0x78, 0x02, 0xFF, 0x12, 0xC6, 0x43, 0xE3, 0x18 + }, + { + 0x09, 0x86, 0x03, 0x34, 0xDC, 0x1F, 0xC7, 0x51, + 0xA6, 0xD1, 0x83, 0xD5, 0xFB, 0xDC, 0x8F, 0x65, + 0x18, 0x9C, 0x5F, 0x68, 0x0E, 0x13, 0xE9, 0xD4, + 0x6C, 0x82, 0x5E, 0xA2, 0x9A, 0x63, 0x32, 0xA2 + }, + { + 0x41, 0xAD, 0x31, 0xE4, 0x4C, 0xF5, 0x7C, 0x57, + 0x8D, 0x54, 0x2E, 0xC8, 0x7B, 0x05, 0xA3, 0x17, + 0xA4, 0x67, 0x96, 0xFD, 0xF7, 0xC7, 0xF0, 0x7F, + 0x0C, 0xF0, 0x67, 0x31, 0xC5, 0x77, 0xCE, 0xE0 + }, + { + 0x89, 0x4A, 0xCC, 0x19, 0x1A, 0x94, 0x00, 0x85, + 0xC6, 0x5A, 0x04, 0x4C, 0x7D, 0x99, 0x1D, 0x53, + 0x41, 0x4C, 0x26, 0xC5, 0x7F, 0xE7, 0x6C, 0xAC, + 0x97, 0xD8, 0xBE, 0xA9, 0x8D, 0x12, 0xB2, 0xB7 + }, + { + 0xB8, 0xF6, 0xA2, 0x74, 0x9D, 0x60, 0x9A, 0x8D, + 0x21, 0xA9, 0x1B, 0x85, 0x65, 0x70, 0x15, 0xA9, + 0xBE, 0x42, 0x09, 0x21, 0x3A, 0xC8, 0xFF, 0x90, + 0x0D, 0x64, 0xE3, 0xEB, 0x8B, 0xF4, 0x9B, 0x64 + }, + { + 0x99, 0x66, 0xF3, 0xC8, 0xD4, 0x66, 0x84, 0x18, + 0xC1, 0xCE, 0x86, 0xCB, 0xB8, 0xD6, 0x9D, 0xAD, + 0x4D, 0xE8, 0x5B, 0xBF, 0x7A, 0x01, 0x11, 0xCD, + 0xBB, 0x94, 0x36, 0x84, 0xE3, 0x4C, 0x51, 0x31 + }, + { + 0x98, 0x78, 0x4B, 0x6F, 0xEE, 0xD8, 0x8D, 0xE8, + 0x09, 0x86, 0x6A, 0xCD, 0xD4, 0x2B, 0x58, 0x4A, + 0xFE, 0x46, 0xEB, 0xC2, 0xBE, 0xC0, 0x7F, 0x2B, + 0xDC, 0x25, 0x52, 0x0A, 0xBD, 0xA3, 0xDB, 0x3B + }, + { + 0x8F, 0x3A, 0x61, 0x3C, 0x5C, 0x08, 0x22, 0xE7, + 0x59, 0xED, 0x6A, 0x9D, 0x30, 0x86, 0x20, 0x86, + 0xCB, 0x80, 0x21, 0x96, 0xD7, 0x44, 0x30, 0x46, + 0xD7, 0x59, 0x8E, 0x1A, 0x86, 0xD4, 0x2E, 0xCC + }, + { + 0x00, 0x1B, 0xA1, 0x7C, 0xDB, 0x3B, 0x1A, 0x16, + 0x00, 0x3E, 0x6E, 0x8A, 0x7F, 0xEB, 0xE3, 0x73, + 0x6C, 0x3D, 0x48, 0xD0, 0x42, 0xBD, 0xF4, 0xAE, + 0xBB, 0x8A, 0x1A, 0x2D, 0x80, 0x5C, 0x62, 0x33 + }, + { + 0xBB, 0xEF, 0xB2, 0x1D, 0xF6, 0xE1, 0xE9, 0xF6, + 0xD1, 0x47, 0x11, 0x9A, 0xE8, 0xB4, 0x3D, 0x66, + 0x6E, 0x04, 0x72, 0x3F, 0x15, 0x7E, 0x9C, 0x57, + 0xF0, 0xF5, 0x8F, 0x0F, 0x1F, 0xE9, 0x98, 0xB3 + }, + { + 0x57, 0x50, 0xFE, 0x06, 0x1D, 0x5D, 0x4B, 0x23, + 0xD1, 0xE5, 0x1A, 0xA2, 0x87, 0x24, 0x1C, 0x56, + 0x7C, 0x7A, 0x12, 0xFA, 0x75, 0xC0, 0x26, 0xD9, + 0xDF, 0x11, 0xE4, 0xDD, 0x41, 0x24, 0x7B, 0xF4 + }, + { + 0x9A, 0x52, 0xF8, 0xD1, 0x42, 0x2B, 0x4D, 0x90, + 0xD3, 0x7E, 0x6D, 0x07, 0x00, 0x7E, 0x3E, 0x4B, + 0x0C, 0xFF, 0xE5, 0xD1, 0xF0, 0x74, 0x21, 0x6C, + 0xEB, 0xBF, 0x2A, 0xBB, 0x21, 0x3F, 0x0F, 0xAE + }, + { + 0x5E, 0x00, 0x27, 0x73, 0x45, 0x8D, 0xC6, 0x1E, + 0x41, 0x8B, 0x3E, 0x1B, 0x5F, 0xF3, 0xA1, 0x5A, + 0xE0, 0xFB, 0x23, 0xA5, 0x2B, 0x49, 0x14, 0xC1, + 0xAE, 0xAB, 0xCA, 0xA6, 0x06, 0xDA, 0xDE, 0xF7 + }, + { + 0xB5, 0xA1, 0xCD, 0xDF, 0x8F, 0xB9, 0xD7, 0xC1, + 0x46, 0x53, 0x7F, 0xE0, 0x68, 0xE1, 0x8C, 0x8E, + 0x73, 0x56, 0x4B, 0x52, 0xA8, 0x0D, 0xFE, 0x2C, + 0x00, 0x91, 0x84, 0x66, 0x73, 0xD1, 0x16, 0x6C + }, + { + 0x75, 0x92, 0x08, 0xC2, 0x7A, 0xF9, 0x9A, 0x70, + 0xDE, 0x67, 0xF1, 0xA3, 0xB8, 0x78, 0xE0, 0x25, + 0xB1, 0xBE, 0xEB, 0x46, 0x0D, 0xAD, 0xBA, 0x58, + 0x5E, 0x74, 0xB3, 0x38, 0x85, 0x73, 0xC4, 0x20 + }, + { + 0x46, 0x7D, 0xEB, 0xEC, 0x57, 0x8E, 0x91, 0x33, + 0x7F, 0x80, 0xB4, 0x9D, 0x56, 0xB0, 0x26, 0xE5, + 0x13, 0xDE, 0x8E, 0x05, 0x23, 0x6F, 0xEF, 0x22, + 0xE8, 0x56, 0x84, 0xCD, 0xB2, 0x88, 0x07, 0xD1 + }, + { + 0x57, 0x36, 0x57, 0xF9, 0xD0, 0x12, 0xBE, 0x67, + 0x27, 0x0D, 0xD3, 0x9C, 0x9B, 0x04, 0x8A, 0x0F, + 0xD3, 0xBE, 0xA1, 0x0B, 0x86, 0x7E, 0x12, 0x50, + 0x23, 0x2C, 0xB3, 0x08, 0x38, 0xA8, 0x51, 0xA8 + }, + { + 0x0D, 0x36, 0xA7, 0x4B, 0xFE, 0x35, 0xEA, 0xB4, + 0x0F, 0xE3, 0xBE, 0xFE, 0xEA, 0x3F, 0x69, 0x3D, + 0xA1, 0xA3, 0xBF, 0x6B, 0xB0, 0x47, 0xF7, 0xA1, + 0x28, 0xCE, 0xA0, 0x4A, 0x9F, 0xF4, 0xCB, 0xEC + }, + { + 0xF4, 0x49, 0x36, 0x26, 0x27, 0xBB, 0x9E, 0x8D, + 0x28, 0xC2, 0xCB, 0x2B, 0xF6, 0xBE, 0xE1, 0x2B, + 0x11, 0x69, 0xF6, 0x51, 0x36, 0x52, 0xDD, 0x88, + 0x91, 0x59, 0xCF, 0xC6, 0x64, 0xD3, 0xF5, 0x95 + }, + { + 0x25, 0x28, 0xED, 0xB9, 0xD6, 0xE8, 0xDA, 0x22, + 0x07, 0x9B, 0xE6, 0x56, 0x50, 0xBB, 0x00, 0xDD, + 0x7A, 0xB2, 0x20, 0x16, 0xF2, 0x48, 0x59, 0x52, + 0x83, 0xE7, 0x2F, 0x3C, 0xCF, 0x6F, 0x2A, 0xC0 + }, + { + 0x80, 0x9E, 0x6B, 0x65, 0x20, 0x62, 0x41, 0x55, + 0x63, 0xF0, 0xA1, 0x0C, 0xAF, 0x13, 0xEA, 0x2F, + 0xE9, 0xC1, 0x0D, 0x8A, 0x96, 0x78, 0x4E, 0xCA, + 0x5F, 0xC3, 0xD8, 0x6D, 0xB7, 0x68, 0x9E, 0x03 + }, + { + 0x16, 0xAA, 0x8F, 0xF8, 0x58, 0x93, 0x3A, 0x43, + 0x0B, 0x99, 0xFB, 0x6D, 0xE5, 0xFF, 0xCF, 0x43, + 0xA1, 0xFB, 0x51, 0x3B, 0x83, 0x18, 0xA8, 0xC1, + 0x92, 0x33, 0x6A, 0x56, 0x35, 0x6B, 0x7D, 0xD9 + }, + { + 0x7C, 0x81, 0xAC, 0x19, 0xA8, 0x44, 0xC6, 0x9B, + 0x52, 0x88, 0x30, 0x9D, 0xCA, 0x1F, 0x47, 0x8F, + 0x6D, 0x4B, 0xC7, 0x43, 0xFC, 0xD9, 0x84, 0xC3, + 0xD5, 0xD8, 0xA4, 0x03, 0xDB, 0xC4, 0xD9, 0x9B + }, + { + 0x7A, 0x5E, 0x1C, 0x06, 0x77, 0xD6, 0x56, 0xB5, + 0x2C, 0x4B, 0xB0, 0xC4, 0x85, 0xD9, 0x3D, 0x63, + 0xAB, 0x86, 0x09, 0x85, 0xF9, 0x0B, 0xF5, 0x97, + 0xF6, 0x54, 0x32, 0x3B, 0x2A, 0xC4, 0xD0, 0x11 + }, + { + 0x6D, 0xC4, 0x58, 0x52, 0x1A, 0x49, 0x7D, 0x29, + 0x85, 0x77, 0x24, 0xF2, 0xAA, 0x5C, 0x39, 0xB2, + 0xD8, 0xA4, 0x3F, 0x73, 0xBE, 0x38, 0xF6, 0xD7, + 0x12, 0x82, 0x3F, 0x34, 0x19, 0x3A, 0x62, 0xF4 + }, + { + 0xBE, 0x29, 0xCD, 0x07, 0xDB, 0x62, 0xD2, 0xAC, + 0x63, 0x67, 0x9D, 0x0A, 0x95, 0x67, 0xA1, 0x26, + 0x88, 0x46, 0xD3, 0xF9, 0x08, 0xB4, 0x62, 0x5B, + 0x95, 0x31, 0x8E, 0x2A, 0x55, 0x0A, 0x9A, 0x5A + }, + { + 0x96, 0x18, 0xD7, 0x83, 0xE1, 0x33, 0x66, 0xDA, + 0x46, 0x4A, 0x2E, 0x4C, 0xE0, 0x5C, 0xBF, 0x03, + 0x45, 0xF7, 0x3E, 0x5B, 0xC8, 0xB8, 0x45, 0xCD, + 0x38, 0xC2, 0xA8, 0xD9, 0x03, 0xA6, 0x08, 0x2B + }, + { + 0x44, 0x97, 0xBF, 0x7D, 0xD9, 0x17, 0xFC, 0xA1, + 0x69, 0x06, 0x46, 0x4F, 0xFA, 0x84, 0x4D, 0xD5, + 0xD8, 0x6E, 0x62, 0x64, 0x90, 0x7D, 0x2F, 0xB7, + 0x5D, 0x4F, 0x91, 0x1B, 0x7C, 0x0E, 0x01, 0x7B + }, + { + 0xD9, 0x36, 0x0A, 0xAC, 0x7D, 0x5F, 0xBE, 0x7E, + 0x89, 0x44, 0x7B, 0xA8, 0x84, 0xE1, 0x9D, 0xE8, + 0x83, 0xA1, 0xCD, 0x8B, 0x9D, 0x5D, 0x3B, 0xBA, + 0xC9, 0x23, 0xEE, 0x3D, 0xCE, 0x94, 0x79, 0xE1 + }, + { + 0xFF, 0xC8, 0x46, 0x26, 0x35, 0xF2, 0x21, 0x26, + 0x68, 0x7E, 0x8E, 0x3F, 0x4E, 0x23, 0xAE, 0xDC, + 0xF8, 0xC2, 0x3A, 0xD8, 0x5E, 0xA7, 0x12, 0xCF, + 0xB2, 0x79, 0x8E, 0xC4, 0x77, 0x72, 0x22, 0x24 + }, + { + 0x48, 0xBF, 0xAC, 0x3B, 0x6A, 0x92, 0x58, 0xA3, + 0xDC, 0xE5, 0xF8, 0xBF, 0x35, 0xCD, 0xEF, 0xD8, + 0xB0, 0x06, 0x40, 0x93, 0xF9, 0x88, 0xC5, 0xA3, + 0xB4, 0x37, 0xBF, 0xA2, 0x56, 0xB0, 0xB9, 0xB2 + }, + { + 0x39, 0x1E, 0xBF, 0x53, 0x11, 0x12, 0xA1, 0x43, + 0xAB, 0xD8, 0xAE, 0x3C, 0x92, 0x1B, 0x17, 0x02, + 0x4D, 0xCB, 0x0B, 0x25, 0xD9, 0x8F, 0x22, 0xD0, + 0x19, 0xA9, 0x0E, 0x19, 0x51, 0x88, 0xD2, 0xCF + }, + { + 0x6A, 0x26, 0xBF, 0x6B, 0x64, 0x7C, 0x5D, 0x92, + 0x99, 0xE3, 0x39, 0xB1, 0x87, 0x9B, 0x7E, 0xD8, + 0xE6, 0xE9, 0x0B, 0x30, 0x70, 0xD7, 0xBD, 0xDC, + 0x0A, 0xBC, 0xC1, 0xBB, 0x9D, 0x3C, 0x21, 0x01 + }, + { + 0xB9, 0x28, 0xA1, 0x78, 0x62, 0xE2, 0x11, 0xE9, + 0x97, 0x59, 0xBA, 0x88, 0x19, 0x28, 0x08, 0x03, + 0xA9, 0x14, 0xCD, 0x3D, 0xEE, 0x7C, 0x5D, 0x71, + 0x1A, 0x3B, 0x51, 0x85, 0xAA, 0x96, 0xA7, 0xB3 + }, + { + 0x72, 0x88, 0x06, 0x1B, 0x0F, 0x7B, 0x6B, 0x96, + 0x11, 0x28, 0x3F, 0x2D, 0x8D, 0x80, 0x82, 0xCD, + 0x26, 0x27, 0xEE, 0x57, 0x98, 0xA5, 0xE4, 0x40, + 0x21, 0x45, 0xE4, 0xC4, 0x1D, 0x78, 0x7D, 0x37 + }, + { + 0x98, 0xAA, 0xC1, 0x02, 0xCF, 0x8F, 0x13, 0xAB, + 0xF2, 0x28, 0x2C, 0x09, 0x66, 0x66, 0x52, 0xD9, + 0xE6, 0x65, 0x9D, 0xCD, 0x68, 0x21, 0x26, 0x70, + 0xD5, 0x38, 0xB0, 0x54, 0xFD, 0x89, 0x83, 0x82 + }, + { + 0x2B, 0xCE, 0xD3, 0x49, 0x07, 0x47, 0x76, 0xD7, + 0x8E, 0x64, 0x17, 0x62, 0xDF, 0xB5, 0xC1, 0xCE, + 0xBE, 0x3D, 0xFE, 0xDE, 0xF1, 0x85, 0xC0, 0xAF, + 0x5C, 0xD8, 0x1C, 0x55, 0x26, 0xC1, 0x0F, 0x26 + }, + { + 0x01, 0xB6, 0xCC, 0xE2, 0xD5, 0xD4, 0x18, 0xCD, + 0x1F, 0xAC, 0x8F, 0xE3, 0x54, 0x45, 0xEA, 0x04, + 0x8F, 0xC2, 0x04, 0x8B, 0xBC, 0x33, 0x66, 0x0B, + 0xD6, 0x7E, 0xF2, 0xD2, 0xAA, 0xC0, 0x89, 0x15 + }, + { + 0xA3, 0x5F, 0x3B, 0x0B, 0xD8, 0x0A, 0x3C, 0x99, + 0x64, 0x9C, 0x4D, 0x36, 0x13, 0xAC, 0x0B, 0xE0, + 0x7E, 0x61, 0x1C, 0x0A, 0x22, 0x31, 0xAF, 0x8F, + 0x08, 0x87, 0xDB, 0x5E, 0x37, 0x0C, 0x01, 0x46 + }, + { + 0xDC, 0x3C, 0x30, 0x08, 0xF7, 0xA1, 0xCB, 0xC8, + 0xE6, 0xDD, 0xAC, 0x90, 0x7C, 0x0E, 0x5A, 0xB0, + 0x37, 0xD3, 0x49, 0xC2, 0x78, 0x30, 0x45, 0x72, + 0x74, 0xC1, 0x7C, 0x56, 0x7C, 0xA3, 0x1E, 0xA4 + }, + { + 0xA7, 0x21, 0xC2, 0x95, 0xAB, 0xED, 0x3F, 0xC4, + 0x08, 0x7A, 0xF0, 0x4F, 0x55, 0xF6, 0xBD, 0x11, + 0x5E, 0x6D, 0xBF, 0x04, 0x0B, 0x0C, 0xED, 0x7E, + 0x77, 0xD5, 0x19, 0x79, 0x8F, 0x7D, 0x5C, 0x1A + }, + { + 0xD1, 0xC8, 0xDB, 0xC7, 0xC7, 0xE9, 0x83, 0x3A, + 0x23, 0x43, 0xC1, 0x56, 0x03, 0xA7, 0x67, 0xAC, + 0x79, 0x6A, 0x6D, 0x9C, 0x45, 0xD8, 0xE1, 0xC3, + 0x35, 0x7D, 0x60, 0xCD, 0x3B, 0xA1, 0x18, 0x78 + }, + { + 0x98, 0x1A, 0x68, 0x24, 0xFC, 0x40, 0x25, 0x23, + 0xBE, 0x51, 0x98, 0xE3, 0xE8, 0x2F, 0xB8, 0x08, + 0xBA, 0x50, 0x34, 0x1F, 0x5D, 0xE4, 0xFE, 0x5D, + 0x65, 0x19, 0x6C, 0xEB, 0xC9, 0x44, 0xB3, 0x5B + }, + { + 0x48, 0x47, 0xFA, 0x5F, 0x21, 0xA2, 0x75, 0x33, + 0xDA, 0x84, 0x99, 0xF6, 0x37, 0x2F, 0x4B, 0x70, + 0xA2, 0x3E, 0x2F, 0xEF, 0xF7, 0x1C, 0x5F, 0x36, + 0x47, 0xCB, 0xFA, 0xFC, 0xEC, 0xEB, 0xFC, 0x93 + }, + { + 0x50, 0xE6, 0xFD, 0x4A, 0x4B, 0x50, 0xCE, 0x11, + 0xD6, 0x43, 0xD2, 0x6A, 0xF0, 0x9B, 0xA9, 0xD6, + 0x60, 0x8B, 0x95, 0x5D, 0xCF, 0xBE, 0xA3, 0x77, + 0xF3, 0x5A, 0xED, 0x30, 0xD4, 0x2F, 0x06, 0x68 + }, + { + 0x98, 0x02, 0xFE, 0x65, 0xBE, 0x4F, 0x3E, 0x23, + 0x2A, 0x10, 0x45, 0xB7, 0x11, 0x7A, 0x5B, 0x01, + 0xBE, 0xCC, 0x8C, 0x0A, 0x9A, 0x88, 0x4F, 0x55, + 0x72, 0xCE, 0x58, 0x8D, 0xFA, 0x37, 0xF9, 0xD0 + }, + { + 0xEF, 0x3E, 0xAE, 0xEB, 0x63, 0xDF, 0x9C, 0x8A, + 0xA5, 0x6E, 0x2D, 0x1C, 0x41, 0xC2, 0x73, 0x29, + 0xEF, 0x56, 0x4F, 0x93, 0x89, 0x7C, 0xCA, 0x0C, + 0x00, 0x43, 0x06, 0x47, 0x6A, 0x23, 0x6E, 0x6C + }, + { + 0x25, 0x4E, 0x4B, 0x14, 0x87, 0x19, 0x12, 0x4F, + 0xF2, 0xD4, 0x80, 0xC8, 0x91, 0xAC, 0xDF, 0x74, + 0x52, 0x40, 0x3B, 0xED, 0x3E, 0x80, 0xD9, 0x1C, + 0x9C, 0xCE, 0x69, 0xA1, 0xB2, 0x77, 0x18, 0xDD + }, + { + 0x8A, 0x7F, 0xD5, 0x9E, 0xD6, 0xC0, 0x77, 0x28, + 0x1A, 0x04, 0x74, 0x59, 0xE4, 0xDA, 0xDD, 0x29, + 0xD1, 0xDD, 0x8E, 0x04, 0x11, 0xD3, 0xF4, 0xF7, + 0x37, 0x70, 0x0E, 0x0D, 0x94, 0xBE, 0x5F, 0x31 + }, + { + 0x31, 0x4C, 0x04, 0x2D, 0x4C, 0x67, 0x57, 0xA9, + 0x89, 0x42, 0x65, 0xAC, 0xA5, 0xAB, 0xB0, 0x5F, + 0xE8, 0x28, 0x40, 0x64, 0xF1, 0x37, 0x98, 0x8D, + 0x2E, 0x00, 0x92, 0xB7, 0x54, 0x57, 0xAC, 0xD4 + }, + { + 0xF0, 0x7B, 0x0B, 0x0D, 0x12, 0xF0, 0x20, 0x58, + 0x68, 0xC1, 0x7C, 0xF5, 0x07, 0x9D, 0xEF, 0x57, + 0xFA, 0x77, 0x7B, 0x0D, 0x32, 0x52, 0x4C, 0xCD, + 0x60, 0xC0, 0x61, 0xFE, 0x8A, 0x22, 0x7E, 0xF4 + }, + { + 0xE6, 0xAB, 0xB7, 0x21, 0xD7, 0x46, 0xC9, 0xBA, + 0x16, 0xE7, 0xDF, 0x9E, 0x63, 0x15, 0x05, 0xEA, + 0xC0, 0xAF, 0x09, 0x5F, 0xD4, 0xB6, 0xF4, 0x0D, + 0xB7, 0xA8, 0xD6, 0x3D, 0x6B, 0x5D, 0xBD, 0x2D + }, + { + 0x4D, 0x84, 0x3F, 0x16, 0xD5, 0xFC, 0x0F, 0xB2, + 0x9D, 0xFB, 0x29, 0xD7, 0xE2, 0x23, 0xCB, 0x18, + 0x6D, 0x97, 0x81, 0x6B, 0x41, 0x92, 0x96, 0x08, + 0x3B, 0xDC, 0x12, 0xF2, 0xCF, 0x60, 0xD6, 0x7E + }, + { + 0xB4, 0xC0, 0x5A, 0xEF, 0x31, 0xC5, 0x17, 0x2E, + 0x1A, 0x63, 0xBA, 0xC3, 0x1D, 0xAE, 0xEC, 0xE4, + 0xFE, 0x53, 0x28, 0x05, 0x9A, 0x52, 0xEC, 0x2E, + 0x7F, 0x71, 0xEE, 0xE9, 0x0C, 0x81, 0xBE, 0x5A + }, + { + 0xF3, 0xF5, 0x8A, 0xBD, 0x4E, 0xBC, 0x1B, 0xAE, + 0x2B, 0x43, 0x6F, 0x5C, 0xDB, 0x72, 0x0B, 0xDC, + 0x59, 0x0B, 0x3A, 0x04, 0x99, 0x77, 0x98, 0x19, + 0xB6, 0x7F, 0x58, 0xDC, 0xC4, 0x68, 0xA4, 0x70 + }, + { + 0xFD, 0xBE, 0xD1, 0xF5, 0x19, 0x62, 0x5D, 0x59, + 0x92, 0x26, 0xF6, 0x79, 0x49, 0x4B, 0x95, 0xF7, + 0x84, 0x94, 0xA3, 0xFF, 0x0D, 0x49, 0x77, 0x67, + 0x0B, 0xFC, 0xDA, 0x11, 0x02, 0xDD, 0x0E, 0x71 + }, + { + 0x3A, 0x1A, 0xD5, 0x94, 0x6F, 0x06, 0x15, 0x9F, + 0x3C, 0xB1, 0xE4, 0xC6, 0x2A, 0x45, 0xB9, 0x24, + 0xE8, 0xE1, 0xBF, 0x91, 0x17, 0x85, 0xF7, 0x91, + 0xD5, 0xE2, 0x69, 0xFE, 0xF6, 0xA8, 0xB3, 0x6E + }, + { + 0x11, 0x62, 0xA4, 0x86, 0xC0, 0x40, 0x06, 0xE3, + 0xFB, 0x0D, 0xD3, 0x65, 0x92, 0x6B, 0x60, 0xA9, + 0xD9, 0x89, 0xC3, 0xF9, 0x98, 0x36, 0xD1, 0x73, + 0x89, 0x0B, 0x05, 0xB0, 0x57, 0xAD, 0xB4, 0x49 + }, + { + 0xBD, 0xAB, 0x74, 0xA1, 0xD0, 0xBF, 0x62, 0xC7, + 0x39, 0x1E, 0x2E, 0xD8, 0x8E, 0x0E, 0xC8, 0x37, + 0x8E, 0x9A, 0xE4, 0x64, 0xB1, 0xA4, 0xE3, 0x07, + 0xCB, 0xB8, 0xDD, 0x21, 0x21, 0x05, 0xE0, 0xBF + }, + { + 0xCF, 0x3F, 0x94, 0x74, 0x97, 0x5B, 0x69, 0x2F, + 0x5B, 0x60, 0x3B, 0x32, 0xF7, 0x90, 0x3D, 0xA0, + 0xBB, 0xD7, 0xEB, 0x05, 0x6D, 0x83, 0x35, 0xA4, + 0x0B, 0x80, 0x1F, 0xD2, 0xF8, 0xE1, 0xC7, 0xB6 + }, + { + 0x84, 0x4F, 0x3A, 0x0D, 0xD9, 0xAA, 0xB1, 0x72, + 0xBD, 0xCA, 0x65, 0xF7, 0x92, 0x7F, 0x0D, 0xDC, + 0x3C, 0xC3, 0x4B, 0xEA, 0x90, 0x8E, 0xE8, 0x10, + 0x76, 0xE4, 0xE6, 0x95, 0x17, 0xDC, 0x2D, 0x01 + }, + { + 0x12, 0xC3, 0xF2, 0xA5, 0x92, 0x60, 0x4B, 0x8E, + 0xCD, 0xB7, 0xE0, 0x47, 0xBB, 0x5A, 0xC8, 0xE4, + 0x22, 0x7E, 0xA6, 0xD0, 0x6A, 0x59, 0x68, 0x4F, + 0xE9, 0xE2, 0x4F, 0x97, 0xFA, 0xB6, 0x51, 0xD1 + }, + { + 0x7F, 0xBF, 0x47, 0x97, 0xA6, 0xAB, 0xEC, 0x7A, + 0x3B, 0x9D, 0xB3, 0xE3, 0x56, 0x4A, 0xB0, 0x92, + 0x64, 0xFC, 0x6D, 0xCF, 0xA0, 0xAC, 0x88, 0x6E, + 0x3C, 0x56, 0x74, 0x25, 0x7E, 0x9D, 0x42, 0xD3 + }, + { + 0x00, 0x3B, 0x53, 0xC2, 0x2D, 0xA1, 0x80, 0x9F, + 0xF7, 0x2C, 0xCA, 0xE6, 0x88, 0xB8, 0x8F, 0x29, + 0x85, 0x30, 0xEE, 0x7D, 0x51, 0x51, 0x74, 0x72, + 0xB8, 0x55, 0xED, 0x1A, 0x06, 0x67, 0xDC, 0x69 + }, + { + 0xF2, 0x54, 0x0A, 0xAA, 0x51, 0xF9, 0x89, 0x7B, + 0x1E, 0x82, 0x15, 0x01, 0xE3, 0xB9, 0xFE, 0xBA, + 0xA7, 0x2F, 0xFC, 0xBB, 0xC2, 0x54, 0x1B, 0xC5, + 0x4E, 0xCE, 0xCB, 0x8B, 0x13, 0x85, 0x72, 0xD5 + }, + { + 0x8C, 0xEF, 0xE6, 0xE3, 0xE5, 0xFB, 0x2A, 0x2B, + 0x38, 0x91, 0xA3, 0x45, 0x25, 0xBC, 0x34, 0x00, + 0xAA, 0xF7, 0x02, 0x11, 0xFE, 0x57, 0x92, 0xCC, + 0x3A, 0xC2, 0x70, 0x34, 0x5B, 0x73, 0x4A, 0x58 + }, + { + 0x73, 0x1D, 0xF1, 0x3A, 0x0B, 0xD9, 0x35, 0xDA, + 0x03, 0x46, 0x07, 0xBC, 0x47, 0x00, 0x96, 0xA3, + 0x77, 0xFA, 0x7F, 0x49, 0xF7, 0x78, 0xE8, 0xF5, + 0x8C, 0x4C, 0xB6, 0x0B, 0x48, 0x21, 0xEF, 0x5F + }, + { + 0xB2, 0xE6, 0x3F, 0x65, 0x3A, 0x32, 0xCF, 0xD4, + 0xAB, 0xCF, 0x9D, 0x35, 0x2A, 0x40, 0xEB, 0x40, + 0xA2, 0x46, 0xB7, 0x7A, 0x47, 0x18, 0x11, 0x59, + 0x4A, 0xD2, 0xC7, 0x25, 0xB9, 0x38, 0x44, 0x00 + }, + { + 0x24, 0x6C, 0x2E, 0x16, 0xFF, 0x1F, 0x43, 0xFD, + 0xA7, 0xB5, 0xE9, 0x80, 0xF8, 0xDA, 0xAC, 0x68, + 0x1D, 0x9D, 0x43, 0x4D, 0xB9, 0x5D, 0xD8, 0x63, + 0x1D, 0xF3, 0xD5, 0x2C, 0xAE, 0x6E, 0xCD, 0x5C + }, + { + 0xC4, 0x48, 0xD6, 0xFF, 0xBD, 0xCB, 0x9A, 0x33, + 0xEE, 0x8B, 0x2D, 0x91, 0x8D, 0xE2, 0xC0, 0xC6, + 0xB6, 0xAE, 0xAB, 0x65, 0x87, 0xD1, 0xCC, 0xBC, + 0x0B, 0x11, 0x54, 0xD6, 0x91, 0xFF, 0x80, 0xB4 + }, + { + 0xCD, 0x94, 0xFE, 0xCD, 0xB8, 0x64, 0xB2, 0x01, + 0x54, 0xCF, 0xE9, 0xB3, 0x81, 0xFD, 0x79, 0x42, + 0xFB, 0x23, 0xB2, 0xE8, 0xF7, 0x67, 0x48, 0x11, + 0xC9, 0x4F, 0x30, 0xD7, 0x49, 0x82, 0x4F, 0xFC + }, + { + 0x1D, 0x19, 0xFA, 0xE1, 0xDD, 0xFB, 0x92, 0x4C, + 0xB2, 0x36, 0x28, 0xDF, 0xE1, 0xE6, 0x64, 0x7A, + 0xCD, 0xAD, 0xB4, 0x64, 0xE5, 0xE2, 0x44, 0xC2, + 0x68, 0x49, 0x69, 0xC3, 0x0D, 0x4C, 0xBA, 0xEF + }, + { + 0xA8, 0x0C, 0x96, 0xB6, 0xD4, 0xAC, 0x7F, 0x9D, + 0xAA, 0xB1, 0x5F, 0xCD, 0xC2, 0x14, 0xE0, 0x60, + 0x4F, 0x46, 0x9C, 0x0A, 0x32, 0x7B, 0xBE, 0x75, + 0xB2, 0x86, 0xF4, 0x99, 0xCE, 0xFD, 0xA8, 0x8B + }, + { + 0x39, 0x68, 0x5D, 0x54, 0xBB, 0xF8, 0x22, 0x18, + 0x28, 0xD0, 0x48, 0x23, 0xD0, 0xA2, 0x63, 0xB8, + 0xE5, 0x0B, 0x4D, 0xA2, 0xB9, 0x62, 0x48, 0xE5, + 0x38, 0xE6, 0x5F, 0xAD, 0x44, 0xBC, 0x28, 0x07 + }, + { + 0xF3, 0x3F, 0xAB, 0x8A, 0x07, 0x12, 0x37, 0xEC, + 0x0D, 0x71, 0x7D, 0x9D, 0x00, 0xD7, 0x62, 0xB5, + 0xF2, 0xD3, 0xB6, 0xBC, 0x3F, 0x43, 0xB3, 0xBE, + 0x6D, 0x26, 0x93, 0xA7, 0xC8, 0x7E, 0x01, 0x34 + }, + { + 0x15, 0x8C, 0x62, 0xCE, 0x83, 0x03, 0x6F, 0x93, + 0xDF, 0x14, 0x98, 0x7F, 0xDD, 0x38, 0x3A, 0x0E, + 0x80, 0xEF, 0x0D, 0x40, 0xDB, 0x3D, 0x6C, 0xFE, + 0x80, 0x71, 0x17, 0xCB, 0x6C, 0x6E, 0x48, 0x66 + }, + { + 0x0B, 0xFF, 0x1D, 0x90, 0xED, 0xF9, 0x52, 0xEB, + 0x8B, 0x75, 0x8A, 0x2B, 0x16, 0xF3, 0xCB, 0x18, + 0x9C, 0x59, 0x16, 0x23, 0xC7, 0x01, 0x9E, 0x20, + 0x4E, 0xDE, 0x2F, 0xBC, 0x23, 0xC6, 0x9A, 0x0E + }, + { + 0x48, 0x31, 0x67, 0x2C, 0x4E, 0xA9, 0xE2, 0x7C, + 0x1A, 0x39, 0x10, 0x78, 0xEA, 0x15, 0x44, 0x42, + 0x4B, 0x36, 0x0A, 0x90, 0x21, 0x30, 0x95, 0xC1, + 0x0F, 0x66, 0x59, 0xC0, 0x87, 0x0A, 0x07, 0xD7 + }, + { + 0x36, 0xFE, 0xA1, 0x46, 0xD4, 0xAD, 0xA8, 0x17, + 0x3A, 0x73, 0xA3, 0x21, 0x12, 0x07, 0x04, 0xAA, + 0x7A, 0xB7, 0xCC, 0xA4, 0x20, 0xC6, 0x25, 0xE6, + 0x21, 0x9C, 0x59, 0x4F, 0x6A, 0xDF, 0x88, 0x58 + }, + { + 0xF2, 0x27, 0xC0, 0xC3, 0xB6, 0xED, 0xC8, 0x95, + 0xF5, 0xD8, 0x0C, 0xCE, 0xDE, 0xAE, 0x3C, 0x1D, + 0x9F, 0x14, 0xA0, 0x96, 0xBD, 0x1E, 0x81, 0x8D, + 0xFE, 0xEA, 0x13, 0x03, 0xB6, 0x65, 0xA1, 0x8D + }, + { + 0x4D, 0xD1, 0x70, 0xD1, 0x9B, 0x8C, 0x1E, 0x9B, + 0x63, 0x25, 0xD0, 0x89, 0x86, 0x7B, 0x09, 0x94, + 0x4A, 0xB0, 0xCA, 0x12, 0x0B, 0xAC, 0xCB, 0x13, + 0x54, 0x64, 0x35, 0x8E, 0x2C, 0x3F, 0x4F, 0xC8 + }, + { + 0x50, 0xA9, 0x52, 0x88, 0x23, 0xE4, 0x16, 0xFC, + 0xD0, 0x38, 0xDA, 0x54, 0x82, 0x24, 0xDC, 0xBC, + 0xE7, 0xBF, 0x3A, 0x68, 0x9A, 0x31, 0x75, 0x39, + 0x78, 0x7E, 0x48, 0xB4, 0x8D, 0x81, 0x0C, 0xF9 + }, + { + 0x9B, 0xD8, 0x8D, 0xD1, 0x88, 0x93, 0x6D, 0x83, + 0x11, 0x15, 0x69, 0xA9, 0xC3, 0x11, 0x07, 0x06, + 0x41, 0x54, 0x76, 0x90, 0xA8, 0x6D, 0x40, 0x3D, + 0xD3, 0x38, 0x92, 0xEB, 0xAB, 0x38, 0xA0, 0x22 + }, + { + 0x69, 0xC7, 0xF5, 0x3A, 0x2E, 0x11, 0x6E, 0xE4, + 0x1F, 0x37, 0x05, 0xF8, 0x2C, 0x8A, 0x70, 0xE1, + 0x0F, 0x57, 0x9A, 0x34, 0x4A, 0xBF, 0x34, 0x4D, + 0x38, 0x76, 0xA7, 0x26, 0x48, 0x30, 0x89, 0xDD + }, + { + 0x1B, 0x94, 0x23, 0x2B, 0x18, 0x52, 0x76, 0xCF, + 0xD8, 0x0A, 0x95, 0x18, 0x8D, 0xFD, 0x9E, 0xFC, + 0x13, 0x66, 0xDA, 0x89, 0x11, 0xA7, 0xA4, 0xF5, + 0xBA, 0xF4, 0x51, 0x95, 0xDA, 0x49, 0xD7, 0x4B + }, + { + 0x88, 0x5B, 0xDD, 0x5E, 0x3E, 0x6D, 0x20, 0x1B, + 0x6B, 0x6C, 0x72, 0x25, 0x3B, 0x03, 0x5B, 0xAA, + 0x03, 0x88, 0x1F, 0x9D, 0xA5, 0xEC, 0x22, 0x50, + 0xBB, 0xDF, 0x61, 0xE8, 0x50, 0x28, 0x33, 0x05 + }, + { + 0x02, 0x59, 0x70, 0xA5, 0x3E, 0x4D, 0x5B, 0x3A, + 0xA8, 0x66, 0xE4, 0x61, 0x64, 0xF7, 0x13, 0x2B, + 0xE9, 0x50, 0xFE, 0x04, 0xF2, 0x12, 0x07, 0xBD, + 0x13, 0x47, 0x12, 0xD9, 0xD7, 0xA8, 0x62, 0x02 + }, + { + 0x4A, 0xF2, 0x19, 0x4D, 0x51, 0x01, 0xF0, 0x2A, + 0x06, 0x1A, 0x89, 0x08, 0x42, 0xB5, 0x47, 0xA6, + 0x2D, 0x68, 0xE9, 0x55, 0xD9, 0x37, 0xB0, 0xC2, + 0x65, 0xC7, 0xAB, 0xCA, 0x40, 0x2E, 0x3E, 0x30 + }, + { + 0x5D, 0x58, 0xD5, 0x26, 0xB6, 0xEB, 0x27, 0xBC, + 0x0F, 0x6B, 0xC8, 0x3B, 0x02, 0x1F, 0xA6, 0xE9, + 0xE7, 0xA3, 0x07, 0x40, 0x81, 0xC4, 0xF5, 0x88, + 0x45, 0x49, 0x75, 0x7A, 0x15, 0xD9, 0x86, 0xA7 + }, + { + 0xC3, 0xCE, 0x53, 0x01, 0xBD, 0x1B, 0x4E, 0x54, + 0xEA, 0x7A, 0x30, 0x83, 0x94, 0x7A, 0xF4, 0x71, + 0x5C, 0xDF, 0x8E, 0x6A, 0x2D, 0x4D, 0xBC, 0x0E, + 0x61, 0xF0, 0x80, 0xD8, 0x79, 0x51, 0xF7, 0x98 + }, + { + 0x54, 0x59, 0xCD, 0xE6, 0x76, 0x78, 0x5D, 0x1E, + 0x8E, 0x0B, 0xE1, 0x44, 0x14, 0x1C, 0x96, 0x8A, + 0xF9, 0x26, 0xBC, 0x8C, 0x2B, 0x0D, 0xA2, 0x5E, + 0xD1, 0x8D, 0x8D, 0x64, 0xB3, 0xBD, 0x85, 0x96 + }, + { + 0xA4, 0x20, 0x35, 0x50, 0x09, 0x71, 0xF8, 0xAB, + 0xB2, 0x11, 0x0C, 0x0B, 0xCB, 0x28, 0x4A, 0xFB, + 0x26, 0xDB, 0xE0, 0x6B, 0x88, 0x36, 0xD0, 0xAA, + 0xF4, 0x6D, 0x21, 0xD9, 0xE0, 0xC2, 0x58, 0xDE + }, + { + 0x39, 0xCE, 0x17, 0x48, 0xC7, 0x63, 0x7E, 0xEC, + 0x84, 0xCD, 0x9F, 0x5D, 0xBC, 0xAC, 0x61, 0x60, + 0x71, 0x5C, 0xBC, 0x2D, 0x86, 0xF9, 0x57, 0x73, + 0x09, 0x6A, 0xC5, 0x90, 0x2B, 0xBC, 0xA6, 0xE0 + }, + { + 0x17, 0x59, 0x67, 0x5E, 0x6C, 0x72, 0x38, 0x81, + 0xBA, 0x57, 0x94, 0x3E, 0xA6, 0x85, 0x81, 0x4E, + 0xCF, 0xB3, 0x15, 0xF4, 0x8B, 0x13, 0xE2, 0x33, + 0x89, 0x39, 0x2D, 0x8C, 0x35, 0x07, 0x2C, 0x2B + }, + { + 0xED, 0x7C, 0x1C, 0x2F, 0xCB, 0x7C, 0xE7, 0xD6, + 0xC9, 0xCE, 0x12, 0x75, 0x5B, 0x35, 0xF6, 0x57, + 0x50, 0x9A, 0xEF, 0xD3, 0x9C, 0x39, 0x3C, 0x35, + 0x3A, 0x1F, 0xFC, 0x6B, 0x2C, 0xDB, 0x53, 0x8E + }, + { + 0x9A, 0x33, 0x24, 0xD0, 0x6C, 0x7D, 0x64, 0x05, + 0x35, 0x6D, 0xD1, 0xFF, 0xC7, 0xCB, 0xF7, 0x01, + 0xE5, 0xAF, 0x6C, 0x31, 0x6F, 0x87, 0x84, 0x8C, + 0x15, 0xF2, 0xC4, 0x06, 0xA4, 0x64, 0xAC, 0xB2 + }, + { + 0x40, 0x64, 0xD7, 0x5A, 0x4D, 0x94, 0x17, 0xF4, + 0x6D, 0x03, 0x3B, 0x24, 0xE5, 0xE1, 0x68, 0xBD, + 0xFA, 0x78, 0x72, 0x1B, 0xA3, 0xE6, 0xA9, 0xF8, + 0x5D, 0xD9, 0xFE, 0x57, 0xD3, 0x50, 0xF8, 0xAA + }, + { + 0xFC, 0x05, 0xBE, 0xAC, 0xDC, 0x62, 0xEB, 0x2F, + 0x61, 0x12, 0x94, 0x6D, 0xE2, 0x14, 0x64, 0x69, + 0x68, 0x7C, 0x12, 0x88, 0xD9, 0x1C, 0x8F, 0xFA, + 0x8E, 0xBC, 0x5A, 0x6D, 0xDB, 0x3B, 0x8D, 0x6A + }, + { + 0x4F, 0xD6, 0x7D, 0x15, 0xE6, 0x74, 0xCC, 0xF7, + 0xD1, 0x8D, 0x9E, 0x5F, 0xA5, 0x2D, 0xFF, 0x10, + 0xF1, 0x12, 0xB9, 0xA6, 0x2E, 0x5F, 0x10, 0x7F, + 0x87, 0x3D, 0xE4, 0xB7, 0x84, 0xDE, 0x87, 0x19 + }, + { + 0xB2, 0xB4, 0xFA, 0x46, 0xE3, 0xEF, 0xA3, 0xFD, + 0x82, 0xDA, 0x12, 0x54, 0x54, 0x51, 0xF6, 0x66, + 0xE2, 0x3F, 0x9F, 0x24, 0x34, 0x74, 0x5F, 0x8F, + 0xF2, 0x46, 0x13, 0x41, 0xED, 0x1B, 0x1D, 0xE7 + }, + { + 0x44, 0x8E, 0x59, 0x9F, 0x7E, 0x5B, 0xC8, 0xA8, + 0x4D, 0x53, 0x07, 0x11, 0x81, 0x23, 0xB0, 0x19, + 0x6B, 0x07, 0x58, 0xBE, 0xEE, 0x17, 0x4C, 0xDD, + 0xFE, 0xC1, 0x7F, 0x49, 0x85, 0x23, 0x4F, 0x56 + }, + { + 0xD9, 0x4A, 0x13, 0x4E, 0x76, 0xF9, 0x6E, 0xEE, + 0x8B, 0x51, 0x08, 0xA9, 0xDB, 0x5F, 0xF5, 0xB1, + 0xDD, 0x4C, 0xCE, 0x90, 0xC8, 0x36, 0xC1, 0x8B, + 0xC5, 0x7A, 0x0B, 0x77, 0xFF, 0xA4, 0x6D, 0x0F + }, + { + 0xFC, 0x80, 0xB0, 0x61, 0x86, 0x85, 0x7F, 0xF9, + 0xE7, 0x5D, 0x2B, 0x21, 0x50, 0x0E, 0x57, 0x21, + 0x80, 0x01, 0xE1, 0xE8, 0x62, 0x39, 0x81, 0x0A, + 0x1F, 0x45, 0x46, 0x68, 0xFF, 0x5F, 0x37, 0xD0 + }, + { + 0x25, 0xC2, 0x1B, 0xD9, 0xE0, 0x31, 0xD3, 0x86, + 0x0E, 0x47, 0x75, 0xA1, 0xF9, 0xD0, 0xE1, 0x3B, + 0x80, 0xF2, 0x51, 0x47, 0x63, 0x65, 0x5F, 0xB4, + 0x4A, 0xCB, 0x81, 0x33, 0x09, 0xFF, 0x5D, 0xB6 + }, + { + 0x18, 0x89, 0x93, 0x87, 0x09, 0x5C, 0x5A, 0xB2, + 0x36, 0xDA, 0xC3, 0x0B, 0x46, 0x59, 0x73, 0x50, + 0x4C, 0x3F, 0x84, 0xA5, 0x0F, 0xEB, 0x67, 0xF2, + 0xB2, 0x87, 0xAA, 0xC1, 0x21, 0xFF, 0x1A, 0x97 + }, + { + 0x51, 0x83, 0xCF, 0xBF, 0x37, 0x5B, 0xD7, 0x58, + 0xA4, 0x22, 0xB9, 0xF7, 0x97, 0x23, 0xC4, 0xBD, + 0xD3, 0x17, 0x03, 0x72, 0x3F, 0x16, 0x87, 0x66, + 0x18, 0x4A, 0x71, 0xF9, 0x6E, 0xC9, 0x68, 0x06 + }, + { + 0xDE, 0xE5, 0x96, 0xE7, 0xA0, 0x4A, 0x34, 0x46, + 0x56, 0xF3, 0xB3, 0x2B, 0x55, 0x18, 0x01, 0xEE, + 0x5A, 0xE6, 0x64, 0xC8, 0xE3, 0x2D, 0xA9, 0xC5, + 0x49, 0x5A, 0x23, 0x49, 0x0A, 0x0D, 0x1C, 0x58 + }, + { + 0xCD, 0x57, 0xA5, 0xF6, 0xA5, 0xA3, 0x02, 0x77, + 0xD4, 0x73, 0xA6, 0x42, 0x59, 0xE2, 0x9C, 0xD4, + 0x26, 0x6C, 0x7A, 0x20, 0x75, 0x82, 0xD9, 0x76, + 0x08, 0x7E, 0xA0, 0x7C, 0xD5, 0xA8, 0x29, 0x53 + }, + { + 0x00, 0xEA, 0xC5, 0xBA, 0xF4, 0x3E, 0x58, 0xA2, + 0x31, 0x4E, 0xE1, 0xA2, 0x74, 0x15, 0x00, 0x7F, + 0xDE, 0x36, 0x29, 0xAD, 0x0E, 0xD8, 0x23, 0x72, + 0xE3, 0xCE, 0xA4, 0x87, 0x76, 0x7B, 0x21, 0x4B + }, + { + 0xD7, 0x4D, 0x30, 0x87, 0xF2, 0xEE, 0xC8, 0x1A, + 0xA7, 0xF9, 0x16, 0x7E, 0xD5, 0x6A, 0xCD, 0x53, + 0x1E, 0x58, 0xF3, 0x7F, 0xAD, 0xE2, 0x92, 0xDB, + 0xB2, 0x96, 0x5E, 0x7B, 0x09, 0xF4, 0x1B, 0xDB + }, + { + 0xC9, 0x72, 0x6A, 0x5D, 0xE4, 0x0C, 0x46, 0x86, + 0x4B, 0xEA, 0x41, 0x20, 0x89, 0xCF, 0x40, 0x1C, + 0xCB, 0x03, 0x9E, 0x2A, 0x0A, 0x9E, 0xCB, 0xBF, + 0xF7, 0xFB, 0xDB, 0xC4, 0xBA, 0x4E, 0x1B, 0xC5 + }, + { + 0xCC, 0x56, 0xCE, 0xA7, 0x24, 0xFC, 0x99, 0x92, + 0xCC, 0x39, 0x3A, 0xD0, 0x06, 0xBD, 0x68, 0x29, + 0x11, 0x95, 0x67, 0xA3, 0x07, 0x09, 0xD0, 0xFE, + 0x3D, 0x41, 0xC0, 0x44, 0x3B, 0x68, 0x93, 0xF4 + }, + { + 0xBD, 0x6E, 0x57, 0x57, 0xF2, 0x66, 0x13, 0x0A, + 0x8E, 0xD8, 0xE1, 0x93, 0x14, 0xEC, 0xE1, 0xB5, + 0x84, 0xB0, 0x0B, 0x5A, 0xD3, 0x48, 0x73, 0x3B, + 0x7A, 0x73, 0x25, 0xB8, 0x98, 0x86, 0x49, 0xC7 + }, + { + 0xC3, 0x71, 0x8D, 0x25, 0x9E, 0x03, 0x30, 0x01, + 0x53, 0x7C, 0x60, 0x39, 0xF9, 0xDB, 0x81, 0x84, + 0xB7, 0xBD, 0xB5, 0xB7, 0x5E, 0x7C, 0x2D, 0x9D, + 0xC4, 0xDC, 0xDA, 0x4B, 0x1B, 0x06, 0xE0, 0x1E + }, + { + 0x82, 0x9C, 0x0C, 0x98, 0x95, 0x76, 0x50, 0x27, + 0x27, 0xD0, 0x7F, 0xB5, 0x97, 0x15, 0xEB, 0x16, + 0x96, 0x59, 0x7C, 0x16, 0xF9, 0x4A, 0x0E, 0xDC, + 0xAD, 0x63, 0x83, 0x23, 0x97, 0x88, 0xED, 0x01 + }, + { + 0x97, 0x95, 0xE2, 0xDC, 0xD7, 0x13, 0xE8, 0x98, + 0xE8, 0xE4, 0xF2, 0x7C, 0x2D, 0xA1, 0xCE, 0x2D, + 0x3B, 0x68, 0xE4, 0x02, 0xB5, 0x1A, 0x81, 0x67, + 0xC5, 0xAE, 0xEB, 0x62, 0xF8, 0x11, 0x94, 0x8E + }, + { + 0xF4, 0x97, 0x15, 0x7E, 0xED, 0x83, 0x38, 0xF8, + 0x88, 0x49, 0xC8, 0x5C, 0x05, 0x19, 0x85, 0x1D, + 0xCF, 0xDE, 0x5F, 0xCE, 0x66, 0x5E, 0x77, 0x34, + 0x44, 0xE2, 0xEC, 0x07, 0x9A, 0x6B, 0x3E, 0x3E + }, + { + 0xB3, 0x2B, 0x7B, 0x63, 0x96, 0x04, 0x07, 0x12, + 0x8C, 0x31, 0x1D, 0x82, 0xC9, 0x11, 0x29, 0x93, + 0x78, 0xEA, 0xB9, 0x0F, 0x91, 0x9D, 0xD5, 0x66, + 0xD1, 0xA9, 0x38, 0x41, 0xDF, 0x7A, 0x52, 0xAC + }, + { + 0x0B, 0xAA, 0x8C, 0x1B, 0xF6, 0x4C, 0x91, 0xB9, + 0xE2, 0xB0, 0x75, 0x89, 0x75, 0xC3, 0x20, 0x6B, + 0xFC, 0x82, 0xDE, 0xBB, 0x9A, 0xAE, 0x50, 0x0D, + 0x08, 0x95, 0x17, 0x82, 0x7E, 0xB4, 0x6B, 0x12 + }, + { + 0xEB, 0x12, 0xC0, 0x97, 0x33, 0xEE, 0xBA, 0xD4, + 0xC3, 0x99, 0x42, 0xE2, 0xB5, 0xD5, 0x2E, 0x81, + 0x3E, 0x3D, 0xEF, 0x8E, 0x1F, 0x83, 0x26, 0xF0, + 0x08, 0x59, 0xB6, 0x15, 0x63, 0xC4, 0x37, 0xA5 + }, + { + 0x76, 0xF8, 0x15, 0xE1, 0x20, 0xA6, 0xBD, 0x81, + 0xCA, 0xD9, 0x97, 0xD9, 0xAD, 0x51, 0x18, 0x7C, + 0xCD, 0x51, 0xEB, 0xBA, 0x1B, 0x4A, 0xD2, 0x20, + 0x89, 0x44, 0xD5, 0xDB, 0xB0, 0x88, 0x4C, 0xEF + }, + { + 0x96, 0x33, 0xA7, 0xF3, 0x48, 0x57, 0x52, 0xD4, + 0x83, 0x61, 0x77, 0x82, 0xBB, 0x9D, 0x06, 0x33, + 0x64, 0x3E, 0x36, 0x01, 0xDB, 0x23, 0xB3, 0x59, + 0xEE, 0xC5, 0x00, 0x7C, 0x82, 0x3B, 0x72, 0x7C + }, + { + 0x0B, 0xC8, 0x18, 0x51, 0xED, 0xBB, 0x72, 0xD1, + 0xFE, 0x9D, 0x77, 0x26, 0xB3, 0x52, 0x93, 0xE1, + 0xCA, 0xC1, 0x35, 0xE6, 0x9E, 0xA2, 0xDF, 0x57, + 0x7E, 0xB9, 0xD0, 0x8C, 0x0A, 0xE8, 0x3D, 0xAF + }, + { + 0xC7, 0x62, 0x91, 0x41, 0xED, 0x97, 0x8F, 0x6C, + 0xF0, 0xA4, 0x91, 0xC2, 0x90, 0x76, 0xF1, 0x64, + 0x35, 0x54, 0xEC, 0x43, 0xBD, 0x72, 0x09, 0xB4, + 0xD9, 0x7F, 0x4B, 0xD0, 0xA0, 0xC0, 0x38, 0xF5 + }, + { + 0x5D, 0x21, 0xB0, 0x05, 0x19, 0xB1, 0x0A, 0x36, + 0xF8, 0x7E, 0x2E, 0x1E, 0x37, 0x23, 0x81, 0xFF, + 0x56, 0xAF, 0x55, 0xE9, 0x79, 0xFE, 0x2E, 0x59, + 0xB2, 0xE2, 0xCD, 0xDB, 0xB4, 0x1D, 0x1F, 0xD2 + }, + { + 0xA2, 0x1F, 0x27, 0x38, 0xB7, 0x35, 0x3E, 0x0F, + 0x55, 0x1B, 0x86, 0x08, 0x1D, 0x84, 0x17, 0xF7, + 0x15, 0xC3, 0x92, 0x94, 0x08, 0x04, 0x58, 0xC1, + 0x32, 0x8E, 0x55, 0x2F, 0x60, 0x37, 0xEF, 0x10 + }, + { + 0x19, 0xFF, 0x7C, 0x83, 0x9D, 0xD0, 0x1D, 0xDE, + 0xB6, 0xB6, 0x4B, 0x76, 0x3C, 0xA0, 0xC1, 0x21, + 0x24, 0x4C, 0x36, 0xDC, 0xCD, 0xA0, 0x38, 0xA1, + 0xAD, 0x1F, 0x68, 0x0F, 0x71, 0xEB, 0xED, 0x33 + }, + { + 0x28, 0x6B, 0xB3, 0xEB, 0x07, 0x94, 0x18, 0xC3, + 0x46, 0xF8, 0x1E, 0xC2, 0xEB, 0x0A, 0xF6, 0x55, + 0xDA, 0x44, 0x97, 0xAA, 0xBA, 0x8B, 0xBB, 0x01, + 0x05, 0xFF, 0x36, 0xEA, 0xAA, 0xD8, 0xAD, 0xDE + }, + { + 0x2C, 0xDB, 0x0E, 0x2E, 0xCC, 0xBD, 0x3C, 0x52, + 0x79, 0xD9, 0xDE, 0x98, 0xB9, 0xC7, 0x95, 0x27, + 0x50, 0x2D, 0x78, 0x76, 0x09, 0x1D, 0x60, 0x13, + 0x8F, 0x8F, 0x21, 0x79, 0x46, 0xDD, 0x49, 0xD2 + }, + { + 0xF0, 0x38, 0x37, 0x4D, 0x81, 0x5E, 0x90, 0x05, + 0x6F, 0xBA, 0x62, 0x29, 0x62, 0xEE, 0xAE, 0xBD, + 0x86, 0xF5, 0xB7, 0x66, 0xA6, 0x91, 0xF4, 0x29, + 0x22, 0x54, 0xE8, 0x93, 0x4A, 0xA8, 0xBC, 0x5D + }, + { + 0xC7, 0x1A, 0xDA, 0xB2, 0x15, 0xDE, 0x60, 0x1C, + 0x3E, 0xBF, 0xFA, 0x3D, 0x45, 0xDF, 0x11, 0xD7, + 0xFA, 0x75, 0x72, 0x8D, 0x53, 0x98, 0x44, 0x64, + 0x10, 0x0E, 0x8B, 0xBB, 0xEC, 0x1C, 0x75, 0x95 + }, + { + 0xC9, 0x81, 0xEF, 0x88, 0x6A, 0xF0, 0xBD, 0xD6, + 0x58, 0x4A, 0xD1, 0x7B, 0x99, 0xFA, 0x51, 0x10, + 0xFF, 0x3B, 0x53, 0x87, 0x68, 0x22, 0x0A, 0x3B, + 0xD3, 0x97, 0x64, 0x51, 0xBE, 0xEB, 0x1A, 0x38 + }, + { + 0x63, 0x0E, 0x48, 0x09, 0x2F, 0x35, 0x26, 0x7E, + 0xF4, 0x3D, 0x6D, 0x9A, 0xCC, 0x7B, 0x9F, 0x58, + 0xD4, 0xC8, 0x0A, 0x7E, 0x6F, 0x2B, 0xB7, 0x37, + 0x4A, 0xBD, 0x1D, 0x52, 0x7F, 0x8B, 0xF7, 0xC5 + }, + { + 0xED, 0xE5, 0x87, 0xBF, 0x2D, 0xFE, 0xB4, 0x80, + 0x3A, 0x5C, 0xB3, 0x32, 0x18, 0x6E, 0x35, 0xA0, + 0x7B, 0xB9, 0xE4, 0x28, 0xBB, 0xE9, 0x1D, 0xA3, + 0x24, 0xCA, 0x46, 0xC3, 0x30, 0x23, 0xEC, 0x27 + }, + { + 0x2D, 0xB9, 0x32, 0x59, 0x9F, 0xD5, 0x85, 0x02, + 0x7A, 0x6B, 0x32, 0xB9, 0x57, 0x29, 0x8B, 0xB9, + 0x9F, 0x98, 0x25, 0x48, 0x43, 0xE4, 0x1E, 0xF3, + 0x01, 0xAC, 0x9C, 0x92, 0xD7, 0x3D, 0x45, 0x08 + }, + { + 0x19, 0x3B, 0x2B, 0xD4, 0x9A, 0xB1, 0x40, 0x88, + 0xB7, 0x79, 0x2A, 0x0D, 0x54, 0x6A, 0x4A, 0x16, + 0x45, 0x4D, 0x10, 0x05, 0x3C, 0x07, 0x47, 0x1A, + 0x71, 0x3C, 0x9D, 0xD8, 0xC0, 0xDC, 0xB9, 0xA8 + }, + { + 0x7C, 0x4B, 0xC1, 0xF9, 0xAB, 0x1B, 0x9D, 0x72, + 0xD7, 0xC1, 0xB7, 0xA9, 0xC5, 0x61, 0xD1, 0x33, + 0x6B, 0xAE, 0xCF, 0x06, 0x0F, 0xE6, 0x01, 0x8E, + 0x5F, 0x76, 0x3F, 0x17, 0x9F, 0x7B, 0x32, 0xB2 + }, + { + 0x01, 0x70, 0x90, 0x65, 0x6E, 0xED, 0xDD, 0x36, + 0x7F, 0x30, 0x80, 0xEB, 0x5D, 0x72, 0x00, 0xAF, + 0x38, 0x83, 0xD2, 0x2F, 0x40, 0xC5, 0x42, 0x7F, + 0xE6, 0x63, 0x9A, 0xFD, 0x08, 0xCD, 0xA1, 0x50 + }, + { + 0x8F, 0xB2, 0x4E, 0x7B, 0x3E, 0xD2, 0xFE, 0x2F, + 0xA8, 0x38, 0x1B, 0xD6, 0x14, 0xD1, 0xC6, 0xF4, + 0xF8, 0x6D, 0x15, 0xCF, 0x7B, 0x6A, 0x2D, 0xC9, + 0x51, 0x8B, 0x47, 0x0C, 0x81, 0x00, 0x44, 0xF6 + }, + { + 0x27, 0xEE, 0x21, 0x2E, 0x5B, 0xDF, 0x5C, 0x0C, + 0x17, 0x92, 0xEC, 0x4A, 0x69, 0x22, 0xE8, 0x14, + 0x5B, 0x0F, 0xC6, 0xAF, 0xD6, 0xF1, 0xEB, 0x79, + 0x35, 0x6D, 0x00, 0x87, 0xD9, 0x71, 0xB8, 0x4F + }, + { + 0x9C, 0x6F, 0xF7, 0x67, 0xFA, 0x83, 0x65, 0xF2, + 0xBF, 0x69, 0x2F, 0x8A, 0x1B, 0xCC, 0x1E, 0x40, + 0xBF, 0x39, 0xFA, 0xB5, 0x63, 0xA9, 0x8B, 0x1D, + 0x2C, 0xEC, 0x4E, 0x43, 0x76, 0x63, 0x33, 0x6F + }, + { + 0xAB, 0xCC, 0x9E, 0xCA, 0xC9, 0x62, 0x7B, 0x17, + 0x04, 0xA6, 0x11, 0xFD, 0x19, 0xBD, 0xF1, 0xC1, + 0x99, 0xF7, 0x8A, 0x31, 0x70, 0xBF, 0x43, 0xC0, + 0x9B, 0x5D, 0x6F, 0xC9, 0x20, 0xDD, 0x26, 0x01 + }, + { + 0xEE, 0xF0, 0x4C, 0x4C, 0x68, 0x7B, 0xF5, 0xF6, + 0xDF, 0x88, 0x3A, 0xC4, 0xAB, 0x63, 0xF6, 0x8F, + 0x27, 0x0E, 0x3D, 0x1F, 0xFA, 0x96, 0x9B, 0x29, + 0x11, 0xB4, 0xDE, 0x26, 0x4B, 0x52, 0x4B, 0xD7 + }, + { + 0x9C, 0x9E, 0x0E, 0x56, 0x68, 0xE0, 0x5F, 0x74, + 0x8D, 0xB2, 0x52, 0x69, 0xA0, 0x8E, 0xFA, 0xEC, + 0x93, 0x02, 0xE9, 0x45, 0x33, 0x93, 0x86, 0x5C, + 0xA4, 0xF9, 0xE0, 0xCF, 0xB3, 0xD4, 0xFF, 0x75 + }, + { + 0xBD, 0x9F, 0xAD, 0xC9, 0x7F, 0x4B, 0x1C, 0x70, + 0xE5, 0xA6, 0x4E, 0xBB, 0xF3, 0x4F, 0x3B, 0xB7, + 0xC2, 0x1C, 0x5F, 0x19, 0x81, 0x3E, 0x47, 0x98, + 0x29, 0xBB, 0xCF, 0xCC, 0x92, 0x6E, 0x08, 0xD3 + }, + { + 0x0C, 0xF0, 0x1D, 0x19, 0x2F, 0xA2, 0xF6, 0x90, + 0xB7, 0xBC, 0xBD, 0x16, 0xDB, 0x2F, 0x88, 0x53, + 0xAF, 0x8F, 0xD6, 0x0B, 0x76, 0x93, 0x55, 0xDD, + 0xA9, 0x20, 0x60, 0x62, 0x91, 0x8B, 0x90, 0xA2 + }, + { + 0x7C, 0x26, 0xD5, 0x52, 0x74, 0x1E, 0x8D, 0x13, + 0x77, 0x72, 0xD3, 0x52, 0xD3, 0x48, 0x59, 0x35, + 0x9C, 0xA4, 0x61, 0xF6, 0xEE, 0xB9, 0xC1, 0x92, + 0x6F, 0x53, 0x7B, 0x22, 0x4A, 0xF4, 0x92, 0x44 + }, + { + 0xFE, 0x43, 0x4E, 0x69, 0x8C, 0x42, 0x9E, 0xF6, + 0xD6, 0xBE, 0xD9, 0xB0, 0xEB, 0x36, 0x50, 0xC3, + 0x89, 0x5C, 0x0F, 0xFB, 0xC5, 0x60, 0x04, 0xB3, + 0xB7, 0x8F, 0x49, 0xCA, 0x77, 0x3D, 0x13, 0xBD + }, + { + 0x59, 0x8D, 0x3F, 0xC3, 0x3B, 0xFC, 0xB2, 0x76, + 0xD5, 0xD4, 0x8A, 0x69, 0x6B, 0xBB, 0x7E, 0xA6, + 0xA7, 0x6A, 0x11, 0x38, 0x07, 0xBB, 0xE0, 0x4B, + 0x5F, 0xBA, 0xAC, 0x44, 0x22, 0xBE, 0x16, 0x96 + }, + { + 0x39, 0xA9, 0x5D, 0x30, 0x5E, 0x8A, 0x55, 0x22, + 0xED, 0xF8, 0x9D, 0x98, 0x08, 0x29, 0x24, 0x30, + 0x47, 0x9B, 0x74, 0xB2, 0x57, 0xCA, 0x8D, 0xA0, + 0x08, 0x2C, 0x5A, 0x4E, 0xEE, 0x26, 0x7A, 0xB0 + }, + { + 0x9F, 0x6E, 0xA8, 0xF8, 0x28, 0x72, 0x38, 0xC7, + 0xD2, 0x30, 0xBA, 0x9D, 0x0C, 0xCA, 0x3C, 0x48, + 0x8A, 0x34, 0xB8, 0xF8, 0x5E, 0x68, 0xB1, 0xD6, + 0xFE, 0xA8, 0x11, 0xCF, 0x53, 0x1B, 0xA7, 0xF9 + }, + { + 0x7E, 0xB3, 0x00, 0xCB, 0x0F, 0x25, 0xB9, 0xEB, + 0xD6, 0xAE, 0xD5, 0x00, 0x9C, 0xBF, 0x8F, 0xB6, + 0x79, 0xC7, 0x86, 0x65, 0x3A, 0xE4, 0x08, 0xB8, + 0x37, 0x90, 0xB4, 0x5C, 0x5F, 0xA2, 0xB2, 0xCD + }, + { + 0xDC, 0x0C, 0x2E, 0x77, 0x85, 0x9F, 0xCF, 0x6C, + 0xD8, 0x12, 0x45, 0x59, 0x98, 0x2E, 0x80, 0xB5, + 0x94, 0x66, 0xF9, 0xDC, 0xA9, 0x0C, 0x7B, 0xEA, + 0x27, 0x81, 0x2A, 0xE5, 0xE3, 0x4C, 0x0C, 0xBF + }, + { + 0x41, 0x60, 0x45, 0xC4, 0xEB, 0xF4, 0xC8, 0xE1, + 0x11, 0x83, 0x08, 0xBF, 0x4B, 0xDC, 0xC9, 0x75, + 0x7E, 0x15, 0xCE, 0xC9, 0x6D, 0xD6, 0x47, 0xB7, + 0xCD, 0x02, 0xEE, 0xE4, 0xFF, 0xA4, 0xC9, 0x16 + }, + { + 0xCC, 0x5C, 0x79, 0xF7, 0x86, 0x1A, 0xE5, 0x26, + 0xFC, 0x59, 0xCC, 0x4C, 0x65, 0x0C, 0x5E, 0x6A, + 0x78, 0xFF, 0xC7, 0x17, 0xD8, 0x41, 0x04, 0xE7, + 0xCE, 0xC7, 0x33, 0xC2, 0xED, 0x8E, 0x5A, 0xBA + }, + { + 0x18, 0x05, 0x46, 0xBE, 0xBA, 0x7D, 0x8D, 0xC5, + 0xD5, 0xC4, 0x96, 0xF7, 0xE1, 0x81, 0xD2, 0x29, + 0x37, 0x43, 0xFF, 0xD6, 0x98, 0x69, 0x48, 0x28, + 0x9B, 0x43, 0xBD, 0xCE, 0xDA, 0x14, 0x3B, 0x26 + }, + { + 0x55, 0xAE, 0xA1, 0x3C, 0x33, 0x6C, 0xC9, 0x8B, + 0x8A, 0x0B, 0x79, 0xB0, 0x74, 0x8A, 0x88, 0x33, + 0xAB, 0xC2, 0xDC, 0x3D, 0x14, 0xE0, 0xF4, 0x80, + 0x35, 0xE4, 0xBC, 0x0B, 0x80, 0x39, 0xAC, 0xBB + }, + { + 0x40, 0x64, 0xE5, 0x6F, 0xF5, 0xD9, 0xAE, 0x9C, + 0xC9, 0xEA, 0xDA, 0x82, 0x46, 0x8B, 0x98, 0xC0, + 0xFE, 0x55, 0x9D, 0xC5, 0x9D, 0xBC, 0xD1, 0xB2, + 0xAE, 0xC9, 0x72, 0x12, 0x3B, 0x7D, 0xF1, 0xA0 + }, + { + 0xE7, 0xC0, 0xB0, 0x04, 0xCB, 0x58, 0xC4, 0x94, + 0x82, 0x37, 0x4B, 0xBC, 0xB2, 0xD0, 0xF6, 0x36, + 0x98, 0x52, 0x2B, 0x78, 0x3D, 0xBB, 0x7A, 0x57, + 0x46, 0x5D, 0xEF, 0x4A, 0x27, 0x9F, 0xDB, 0xF1 + }, + { + 0xFF, 0xAC, 0x05, 0x91, 0x35, 0x73, 0x13, 0xEE, + 0x8B, 0xD5, 0x71, 0x2C, 0x8F, 0xC3, 0x89, 0xCD, + 0x91, 0x8C, 0xBA, 0xBF, 0x8D, 0x82, 0xD4, 0xB7, + 0x62, 0xBF, 0xAC, 0x21, 0x31, 0xAD, 0x52, 0xEB + }, + { + 0x98, 0xBA, 0xD5, 0x39, 0x4D, 0x15, 0xA3, 0xD6, + 0xC8, 0x8C, 0xF5, 0xDB, 0xFC, 0xD1, 0x71, 0xA2, + 0xE9, 0x1C, 0xC1, 0x6D, 0x60, 0x90, 0x9D, 0xC6, + 0x30, 0x7E, 0x74, 0xEA, 0x60, 0x3C, 0xC6, 0xB4 + }, + { + 0x1B, 0xFE, 0xAA, 0x68, 0x22, 0xB7, 0xB1, 0xF3, + 0x9E, 0x50, 0x02, 0x89, 0x02, 0x16, 0x65, 0xFB, + 0x70, 0xE5, 0x97, 0x0A, 0x45, 0x80, 0x11, 0x5B, + 0xE3, 0x19, 0xD7, 0xB7, 0x6F, 0x20, 0xBA, 0x13 + }, + { + 0x31, 0x1D, 0xED, 0xD3, 0x47, 0xA9, 0x02, 0xC5, + 0xFF, 0xB8, 0x2E, 0xB3, 0x46, 0xCD, 0x43, 0xF6, + 0xBE, 0x6C, 0xE9, 0xF7, 0xC3, 0x4D, 0x3F, 0xFF, + 0x7E, 0xAB, 0xDB, 0x44, 0xE6, 0x04, 0x91, 0xAD + }, + { + 0xD2, 0x15, 0x75, 0xA7, 0x74, 0xA0, 0x51, 0x2E, + 0x73, 0x53, 0xD9, 0x1C, 0xE8, 0xEF, 0x50, 0xFD, + 0xA2, 0xF1, 0x81, 0x77, 0xED, 0xF3, 0xEE, 0x71, + 0xC1, 0x4D, 0x36, 0x98, 0x98, 0xC9, 0x70, 0x4E + }, + { + 0xA2, 0x82, 0x16, 0x58, 0xC1, 0x5F, 0x9C, 0x2B, + 0x47, 0xCF, 0x20, 0x06, 0xFA, 0x70, 0xB7, 0x28, + 0x8C, 0x85, 0xB3, 0x49, 0x13, 0x8A, 0x42, 0x89, + 0x5A, 0x02, 0x02, 0xA6, 0x8A, 0x92, 0xFF, 0x1B + }, + { + 0xC9, 0xA6, 0xC2, 0x8F, 0x88, 0x93, 0x0D, 0x3C, + 0xE4, 0x07, 0x45, 0x81, 0xEF, 0x15, 0x5E, 0x3E, + 0x44, 0x84, 0xAE, 0x7F, 0xD0, 0xE2, 0x5A, 0x56, + 0x68, 0x83, 0x2C, 0x4C, 0xEC, 0x97, 0xBC, 0x92 + }, + { + 0xFC, 0xDE, 0xA1, 0x95, 0xD3, 0x4B, 0x99, 0x6E, + 0x88, 0x77, 0xF8, 0x81, 0x71, 0x05, 0xFA, 0xFA, + 0x9A, 0x13, 0xC1, 0xF0, 0x14, 0x35, 0x7B, 0x6A, + 0xC9, 0x45, 0x9A, 0x9C, 0x6E, 0xC6, 0x88, 0xAE + }, + { + 0x76, 0xE2, 0x37, 0x58, 0x6D, 0x88, 0x04, 0x11, + 0x66, 0x9D, 0x5A, 0x54, 0xAE, 0x33, 0x89, 0x64, + 0x61, 0xBF, 0xD7, 0xA8, 0xB5, 0x91, 0x27, 0x60, + 0xFE, 0xB8, 0xD5, 0x39, 0x81, 0x6F, 0xD5, 0x47 + }, + { + 0xB7, 0x15, 0x9E, 0x51, 0x2E, 0xB9, 0x1E, 0xCC, + 0x98, 0x44, 0xDC, 0x80, 0x77, 0x3B, 0x06, 0x69, + 0x09, 0xA1, 0xE8, 0x5F, 0xC0, 0x58, 0xCA, 0xB8, + 0x42, 0x53, 0x56, 0x8A, 0xB0, 0xA4, 0x31, 0x64 + }, + { + 0xC6, 0xC6, 0xA1, 0xB1, 0xF5, 0x5E, 0x2D, 0xCF, + 0xA2, 0x25, 0x92, 0x0F, 0xB4, 0x0D, 0xEF, 0x08, + 0x44, 0x9C, 0x92, 0x16, 0x90, 0xC2, 0xCC, 0x39, + 0xAE, 0x3A, 0x5C, 0x75, 0x93, 0x26, 0x99, 0xC3 + }, + { + 0x97, 0x1C, 0x80, 0x9F, 0x17, 0x42, 0xB3, 0x41, + 0x8E, 0xE2, 0x47, 0x03, 0xF4, 0xD5, 0xDF, 0x3D, + 0x22, 0x2B, 0x51, 0x2B, 0x91, 0x9E, 0x5A, 0x12, + 0x06, 0x10, 0x6D, 0xC3, 0x4D, 0xF7, 0xEB, 0xC2 + }, + { + 0x1C, 0x4A, 0x67, 0xBB, 0x3B, 0x2A, 0x6F, 0x9A, + 0x29, 0xED, 0x69, 0x9F, 0x43, 0xF6, 0x99, 0xF0, + 0x7D, 0x07, 0xE2, 0x1A, 0xBC, 0xBB, 0x14, 0xC1, + 0x24, 0x3C, 0xBE, 0x79, 0x46, 0x3A, 0xD0, 0x84 + }, + { + 0x05, 0x6D, 0x61, 0xA3, 0x99, 0x4D, 0x97, 0xCD, + 0xF6, 0x42, 0x2A, 0xB6, 0x2F, 0x3D, 0x03, 0x3E, + 0x1B, 0x11, 0xD2, 0xE9, 0xB2, 0xAD, 0xD4, 0xCA, + 0x76, 0xA0, 0x5A, 0xE8, 0xF8, 0x60, 0x9D, 0x65 + }, + { + 0x06, 0x23, 0xFD, 0x2A, 0x6B, 0x25, 0x30, 0x52, + 0x5A, 0x54, 0x05, 0x25, 0x18, 0x7E, 0xDC, 0xBE, + 0xD3, 0xC3, 0x08, 0xE9, 0x5E, 0xDB, 0x00, 0x10, + 0xFF, 0x58, 0x58, 0x4A, 0x28, 0x5B, 0x2D, 0x0D + }, + { + 0x44, 0xDA, 0xDB, 0x58, 0xB4, 0x0C, 0x30, 0x78, + 0xB2, 0xDC, 0x2F, 0x3A, 0x4A, 0x00, 0xB2, 0x1C, + 0x24, 0xFA, 0x89, 0x5F, 0x21, 0xCC, 0xC9, 0x2A, + 0xF7, 0x83, 0x62, 0xF3, 0x55, 0xE1, 0xC6, 0xA9 + }, + { + 0x2D, 0xFC, 0xDD, 0x72, 0x03, 0xA7, 0x7E, 0x6C, + 0x86, 0x8C, 0x8B, 0xB3, 0x0F, 0xE8, 0x3B, 0x6E, + 0x76, 0xBE, 0xA3, 0xA2, 0x14, 0xA5, 0x7A, 0x80, + 0xD2, 0x3D, 0x4D, 0x61, 0x10, 0xCD, 0x34, 0xE5 + }, + { + 0x16, 0x6F, 0x21, 0xBE, 0x95, 0x0A, 0xD9, 0xF8, + 0x02, 0x0F, 0x09, 0x1F, 0xE0, 0xE3, 0xED, 0xDF, + 0xF2, 0x72, 0x19, 0x36, 0xBD, 0x35, 0xF2, 0xDF, + 0xFE, 0x71, 0x94, 0x05, 0xAF, 0x04, 0xB5, 0x64 + }, + { + 0xBD, 0x4F, 0x2E, 0x92, 0x93, 0x11, 0xAD, 0xCF, + 0x10, 0x5B, 0x26, 0x99, 0xB4, 0x08, 0x6E, 0xAF, + 0xCE, 0x97, 0x52, 0xA5, 0xAF, 0x1E, 0x21, 0x1D, + 0x4E, 0xB8, 0xA4, 0x59, 0xF1, 0x9D, 0x28, 0xFE + }, + { + 0x04, 0xBE, 0xA7, 0x29, 0x50, 0xC2, 0xE7, 0x11, + 0x84, 0x61, 0xCB, 0x02, 0x23, 0x89, 0x52, 0x80, + 0x35, 0xFC, 0x9D, 0xF4, 0x8A, 0xA4, 0x2D, 0x27, + 0x1D, 0x48, 0x52, 0xF0, 0x55, 0xC6, 0x78, 0xD0 + }, + { + 0xF6, 0x1E, 0x17, 0xAC, 0x8A, 0x51, 0x21, 0xB0, + 0x48, 0xBC, 0x3A, 0x07, 0x37, 0xAF, 0xA7, 0xCB, + 0xE6, 0x8C, 0x67, 0xB7, 0x40, 0xB4, 0x56, 0x9A, + 0x77, 0x3A, 0xFB, 0xE1, 0x18, 0x1D, 0xF0, 0xBE + }, + { + 0x64, 0xB0, 0xD3, 0x3C, 0x86, 0xE6, 0x0A, 0x38, + 0xC5, 0xF7, 0x3E, 0x5C, 0xFE, 0x63, 0x51, 0x52, + 0x5A, 0x00, 0xCD, 0x5B, 0x10, 0x8C, 0xD4, 0xDE, + 0xFE, 0xD3, 0x0F, 0x97, 0xA2, 0x33, 0x35, 0x10 + }, + { + 0xE2, 0xD0, 0x8E, 0x3D, 0x04, 0x63, 0xCA, 0xA8, + 0x25, 0xA6, 0x39, 0x0D, 0x71, 0x9A, 0xA2, 0x13, + 0xE6, 0x25, 0xF6, 0xC1, 0x3E, 0x95, 0x26, 0x3B, + 0x84, 0xE6, 0x6C, 0x2A, 0x3C, 0xB7, 0x28, 0xFB + }, + { + 0xF9, 0x23, 0x02, 0xE6, 0xCE, 0x84, 0xE1, 0xC0, + 0x59, 0xB3, 0xC1, 0x42, 0x67, 0xFB, 0xEF, 0x47, + 0x87, 0xC0, 0x25, 0x0E, 0xEC, 0x51, 0xDC, 0x0C, + 0x29, 0x27, 0x7D, 0x22, 0x63, 0x6D, 0xD9, 0x05 + }, + { + 0xE8, 0xC6, 0xA5, 0x37, 0x7C, 0x53, 0x3A, 0x66, + 0xF3, 0xD6, 0x87, 0x00, 0xD0, 0xA5, 0xA6, 0x8F, + 0x6E, 0x8D, 0xF2, 0x67, 0x1A, 0x4A, 0xDD, 0xB9, + 0x5D, 0x5E, 0x10, 0x71, 0xF3, 0xAC, 0x7E, 0x6B + }, + { + 0x40, 0x9E, 0xDD, 0x98, 0x2E, 0x82, 0x33, 0xEA, + 0x46, 0xE7, 0x44, 0x20, 0x55, 0xA3, 0x37, 0x30, + 0x1C, 0x44, 0x82, 0x62, 0xD5, 0x6E, 0x25, 0x56, + 0x4C, 0x86, 0xD6, 0xC2, 0x5B, 0x2F, 0xF4, 0x7A + }, + { + 0x10, 0xD3, 0x3E, 0xF0, 0xC1, 0x10, 0x9D, 0x22, + 0x00, 0x6A, 0x6A, 0x1C, 0xB2, 0xA5, 0x6F, 0x8C, + 0xD1, 0x42, 0x3B, 0xBD, 0x3B, 0x9F, 0xD7, 0x07, + 0xD4, 0xDF, 0x2D, 0xC4, 0x8A, 0x9D, 0x3D, 0x06 + }, + { + 0x3F, 0xE3, 0xB2, 0x60, 0xD7, 0x4D, 0xD8, 0x9C, + 0x43, 0x98, 0xB9, 0x04, 0xA0, 0xF7, 0xE6, 0x21, + 0xCE, 0x4F, 0x51, 0x99, 0x3E, 0xAF, 0x27, 0xB2, + 0xF0, 0x1B, 0xC1, 0x24, 0xF0, 0x40, 0x80, 0x44 + }, + { + 0x8E, 0x6C, 0x2D, 0x47, 0x48, 0x42, 0x89, 0xAF, + 0xAE, 0x77, 0x96, 0xE0, 0xB5, 0x79, 0x9A, 0x19, + 0xBE, 0xE5, 0x09, 0x05, 0xB6, 0xB8, 0x16, 0x3D, + 0xFF, 0x59, 0x06, 0xB9, 0x0E, 0x71, 0xFB, 0xF6 + }, + { + 0xC2, 0x9C, 0x5D, 0x52, 0x4A, 0xFC, 0xD0, 0x31, + 0xC4, 0xDF, 0x9E, 0x77, 0x71, 0x50, 0xAE, 0x66, + 0xE2, 0xDC, 0x47, 0x80, 0xBA, 0x50, 0x47, 0xD8, + 0xB4, 0x92, 0x4A, 0x1F, 0x84, 0xEA, 0x44, 0x19 + }, + { + 0xB0, 0xB5, 0x6E, 0xDB, 0xF5, 0xD5, 0x91, 0xCE, + 0x9A, 0xDD, 0x39, 0x1E, 0xB4, 0x3D, 0x88, 0xC5, + 0xEC, 0xD8, 0x10, 0x74, 0x0A, 0xBE, 0x1B, 0xF9, + 0x56, 0x5D, 0x9A, 0xDD, 0x1A, 0xB0, 0xF4, 0x63 + }, + { + 0x27, 0xE4, 0x87, 0xE1, 0x68, 0xFD, 0x7C, 0xA1, + 0xBF, 0x9A, 0x39, 0x94, 0x6A, 0xC1, 0x39, 0xED, + 0x13, 0x8B, 0x3C, 0x4D, 0xEC, 0xD4, 0x6C, 0x16, + 0xC1, 0x3A, 0xC4, 0x69, 0x89, 0x98, 0xE4, 0x14 + }, + { + 0x4D, 0x46, 0xE9, 0xFE, 0xEC, 0x13, 0x3B, 0x0D, + 0x01, 0x7B, 0x20, 0x5E, 0x9B, 0xD3, 0x20, 0x48, + 0x41, 0x8F, 0xD9, 0x48, 0xCD, 0x8A, 0x29, 0xC0, + 0x0F, 0x02, 0xAA, 0x07, 0x40, 0xA6, 0x75, 0xE5 + }, + { + 0xFD, 0xC2, 0xB5, 0x48, 0x60, 0xD5, 0x5A, 0x9C, + 0xFD, 0xBC, 0xED, 0xC6, 0x80, 0x55, 0x5F, 0x02, + 0x92, 0xF2, 0x2E, 0x06, 0x70, 0x2B, 0x56, 0x76, + 0xD4, 0x88, 0x98, 0x50, 0x70, 0x94, 0x57, 0x2B + }, + { + 0x9B, 0x44, 0x16, 0x8C, 0x20, 0x34, 0x1B, 0x6B, + 0x1D, 0x4D, 0x74, 0xDC, 0xE1, 0x9D, 0x70, 0x23, + 0x3A, 0x6D, 0xAC, 0x7C, 0xFD, 0x19, 0x96, 0x4F, + 0x38, 0xF2, 0x99, 0xD7, 0x59, 0xE7, 0xE2, 0x3A + }, + { + 0xFC, 0x8F, 0x5B, 0x76, 0x5E, 0xE8, 0x4A, 0x86, + 0xE3, 0x7E, 0x80, 0x42, 0x70, 0x71, 0x4B, 0x1D, + 0x18, 0xBB, 0xB3, 0x48, 0xBE, 0xAA, 0x46, 0xAE, + 0xB8, 0xA8, 0xFE, 0x34, 0x53, 0x66, 0xF9, 0x1E + }, + { + 0x42, 0x34, 0x8B, 0x54, 0xBA, 0x51, 0x6A, 0xEF, + 0xB8, 0x30, 0x68, 0x09, 0x8B, 0x80, 0x0B, 0x81, + 0x19, 0x43, 0x7A, 0x03, 0xDD, 0x32, 0xE7, 0x57, + 0x73, 0xDA, 0x8B, 0x74, 0x10, 0xE1, 0x4B, 0xAE + }, + { + 0xAD, 0xEF, 0x9A, 0x88, 0x39, 0x7C, 0x93, 0x1B, + 0x12, 0xB3, 0x67, 0xBE, 0xF1, 0xE5, 0xD1, 0x6A, + 0x0A, 0x62, 0x8B, 0x29, 0x78, 0x1B, 0xC7, 0x75, + 0xB6, 0x8E, 0xF9, 0xBE, 0xDF, 0x7E, 0x2F, 0x1D + }, + { + 0x43, 0xA0, 0x87, 0x52, 0x95, 0x31, 0xF8, 0x2A, + 0x05, 0xC6, 0x69, 0x45, 0x23, 0x7E, 0x7D, 0xD7, + 0xA9, 0x77, 0xA3, 0x73, 0x09, 0x12, 0xFF, 0xC9, + 0x80, 0xC4, 0xCC, 0xA7, 0x0A, 0xA1, 0x18, 0x10 + }, + { + 0x5F, 0x15, 0xF7, 0x25, 0xF4, 0x44, 0x33, 0x76, + 0x80, 0xD5, 0xFA, 0xDD, 0x90, 0xF3, 0x38, 0x8C, + 0x86, 0x2D, 0xD8, 0xE4, 0x85, 0x0C, 0xC6, 0x43, + 0x18, 0x34, 0xD0, 0xE3, 0xC9, 0x90, 0x1E, 0x73 + }, + { + 0xDD, 0xCC, 0xE0, 0xFB, 0x65, 0x3E, 0x4B, 0xB0, + 0xEE, 0x7A, 0xB6, 0x1E, 0xA6, 0x06, 0x16, 0x09, + 0xCA, 0x54, 0xEA, 0x63, 0x90, 0x02, 0x7E, 0x9D, + 0x3A, 0x3A, 0x70, 0xB7, 0xA3, 0x3B, 0x48, 0xBC + }, + { + 0xD9, 0x30, 0x01, 0x67, 0x76, 0xCC, 0x5F, 0x10, + 0xD1, 0xBB, 0x46, 0x20, 0x38, 0x96, 0x1C, 0x57, + 0xB0, 0xAA, 0x93, 0x19, 0xDB, 0xE0, 0xB2, 0x25, + 0xA5, 0x5F, 0x42, 0xB1, 0x12, 0x21, 0xE1, 0x15 + }, + { + 0xF1, 0x94, 0x98, 0x9E, 0x7D, 0xD1, 0xC1, 0xA6, + 0x41, 0x17, 0xB4, 0x6B, 0xB8, 0xAE, 0x94, 0x1C, + 0x2F, 0x3E, 0x91, 0x0B, 0x6C, 0xDC, 0x88, 0x27, + 0x94, 0x35, 0xB9, 0x1F, 0xA8, 0xDB, 0xAF, 0xC6 + }, + { + 0x9F, 0x04, 0x6D, 0x44, 0x6F, 0x2B, 0x26, 0x3C, + 0x64, 0x03, 0x09, 0x19, 0x35, 0xD6, 0xC2, 0x8C, + 0x0A, 0x9C, 0x4C, 0x3A, 0x96, 0x7B, 0x4D, 0xDF, + 0x60, 0x72, 0x8C, 0x4D, 0xC2, 0x2B, 0xDD, 0x30 + }, + { + 0x0F, 0x7B, 0x55, 0xA0, 0xF0, 0xD0, 0x24, 0x01, + 0x0F, 0x1C, 0xBD, 0x7E, 0x9C, 0xA5, 0xEB, 0x35, + 0x8B, 0x3C, 0x68, 0xA1, 0xFC, 0x1D, 0xEA, 0xE7, + 0x83, 0x55, 0x86, 0x15, 0xD4, 0x2B, 0x9E, 0x73 + }, + { + 0x24, 0x3A, 0xA6, 0x78, 0x9D, 0x51, 0xDE, 0x71, + 0xDA, 0x29, 0xDA, 0x17, 0x5F, 0xCF, 0x98, 0x3D, + 0x4E, 0x43, 0xD2, 0xE1, 0x42, 0x85, 0xFB, 0x0C, + 0x87, 0xB6, 0x68, 0xD7, 0xF2, 0xB5, 0x59, 0xD4 + }, + { + 0xC8, 0x68, 0xDE, 0xE1, 0xBE, 0xED, 0xA1, 0x59, + 0xD7, 0xE6, 0xE0, 0x93, 0x54, 0xB6, 0xB9, 0x77, + 0xF9, 0x2E, 0xE4, 0x30, 0x38, 0xFD, 0xC3, 0xA7, + 0x78, 0xAB, 0x0E, 0x85, 0x8F, 0xFB, 0x55, 0x7E + }, + { + 0x84, 0x4E, 0x61, 0xF9, 0xFA, 0x8B, 0xD5, 0xB2, + 0xFE, 0x11, 0x76, 0xC8, 0x17, 0xB4, 0x6D, 0x29, + 0x04, 0x82, 0x1E, 0xF9, 0x1C, 0xF2, 0x68, 0x92, + 0x8E, 0xF5, 0x97, 0xEE, 0xE0, 0xFB, 0x6A, 0xA4 + }, + { + 0x9B, 0xC0, 0x6B, 0x6C, 0xA0, 0xCD, 0x2F, 0xCF, + 0x8A, 0x74, 0x38, 0xC8, 0x67, 0x20, 0x98, 0xF8, + 0xCF, 0x41, 0x4E, 0x43, 0x8A, 0x23, 0x49, 0xD5, + 0x44, 0xE7, 0xAF, 0xDA, 0xAF, 0x82, 0xB9, 0x2B + }, + { + 0xF8, 0x28, 0x01, 0x67, 0x04, 0xDD, 0xB8, 0xBA, + 0x6A, 0x9D, 0x2E, 0x2C, 0xFF, 0x00, 0x03, 0xB9, + 0x62, 0x99, 0xA4, 0xFB, 0x11, 0xBC, 0x50, 0xFA, + 0x0C, 0x35, 0x01, 0x74, 0x5F, 0xA2, 0x57, 0xC1 + }, + { + 0xB6, 0x60, 0xBC, 0x41, 0x0D, 0xC7, 0xB9, 0x15, + 0x0D, 0x5E, 0x7D, 0x87, 0x88, 0x99, 0x35, 0xF5, + 0xD5, 0x1F, 0x6E, 0xF3, 0x0E, 0x46, 0x69, 0x2A, + 0xE6, 0x30, 0x25, 0xC4, 0xFD, 0x41, 0x3E, 0xF6 + }, + { + 0xF0, 0x9F, 0x7C, 0xBE, 0x75, 0x6A, 0x80, 0xBD, + 0x19, 0xFB, 0x89, 0xA6, 0x28, 0x44, 0xC7, 0x3C, + 0xC2, 0x63, 0x3A, 0x84, 0x7F, 0xFA, 0x0A, 0x69, + 0x53, 0xAF, 0x2A, 0xBC, 0x7B, 0x33, 0x64, 0xE5 + }, + { + 0xE8, 0x21, 0x55, 0x60, 0x0E, 0x5D, 0xAF, 0x33, + 0x0F, 0x02, 0x69, 0x2B, 0x0D, 0x69, 0x36, 0xB9, + 0x45, 0x7F, 0x68, 0xA3, 0xD0, 0xAD, 0x60, 0x1D, + 0x24, 0xB4, 0x20, 0x9F, 0xA1, 0x70, 0xD1, 0x6D + }, + { + 0x35, 0xF1, 0x6C, 0x9F, 0x0C, 0xCF, 0xA8, 0x5F, + 0x44, 0x8F, 0x53, 0x5A, 0xA1, 0x84, 0x9F, 0x92, + 0x5E, 0x07, 0x73, 0x36, 0x0A, 0xE5, 0xF9, 0x57, + 0xC0, 0xF3, 0x2F, 0x99, 0x41, 0x5F, 0xE3, 0x3F + }, + { + 0x02, 0x7F, 0xD6, 0xBC, 0x8F, 0xFD, 0x43, 0xC8, + 0x75, 0x44, 0xEE, 0x74, 0x50, 0xFD, 0x91, 0x2A, + 0x2F, 0xF7, 0x21, 0x84, 0xC1, 0xC2, 0x61, 0xF7, + 0x8A, 0x64, 0xD4, 0x49, 0x59, 0xA1, 0x63, 0x7A + }, + { + 0x18, 0x99, 0xC6, 0x72, 0xCA, 0x97, 0x79, 0x81, + 0x0A, 0x96, 0xA4, 0xA1, 0x79, 0xFA, 0x8D, 0x0A, + 0xB6, 0xEA, 0x3A, 0xC9, 0x8A, 0x0C, 0x98, 0xF6, + 0xDA, 0x4E, 0xC5, 0x88, 0x98, 0x4E, 0x05, 0xEB + }, + { + 0xDA, 0x6A, 0x0E, 0x85, 0xBA, 0xF7, 0x03, 0xAB, + 0x4C, 0x4E, 0x49, 0x8C, 0xD4, 0x3E, 0xDC, 0xD9, + 0x8D, 0x56, 0x1D, 0x44, 0xDE, 0x91, 0x8E, 0xC4, + 0xE8, 0x4D, 0xB9, 0x21, 0x36, 0x57, 0x72, 0x4E + }, + { + 0x06, 0xEB, 0x23, 0xDD, 0xF7, 0x32, 0xAB, 0xC6, + 0xC0, 0x7E, 0x3A, 0x03, 0xF1, 0xEA, 0x3F, 0xE8, + 0xCB, 0xBB, 0x00, 0xB3, 0x2A, 0x69, 0x97, 0x47, + 0x10, 0x73, 0x7B, 0x96, 0x24, 0xB9, 0x7C, 0x95 + }, + { + 0x5E, 0x6D, 0x98, 0x88, 0x0C, 0x88, 0x44, 0x99, + 0xBA, 0xA6, 0x38, 0x54, 0x6D, 0x08, 0x0E, 0x1C, + 0xB0, 0x50, 0xE8, 0x2D, 0xAA, 0x05, 0x38, 0xCB, + 0x46, 0xEF, 0x14, 0x70, 0x9D, 0xC8, 0x32, 0x89 + }, + { + 0x11, 0x89, 0x82, 0x8C, 0xA4, 0x87, 0x77, 0x1D, + 0x86, 0x9B, 0x1E, 0x14, 0x1D, 0x63, 0x52, 0xB9, + 0xF9, 0x9F, 0xD9, 0x05, 0x9B, 0xDF, 0xF8, 0xFE, + 0xA2, 0x3F, 0x76, 0xE0, 0x24, 0x20, 0x80, 0x4F + }, + { + 0x5A, 0xBA, 0x26, 0x8C, 0xBC, 0xEA, 0x95, 0xDF, + 0xB1, 0xAE, 0xCD, 0x8A, 0x9D, 0x0D, 0xE6, 0x3D, + 0xA8, 0x22, 0xDE, 0xAC, 0xF8, 0x52, 0x3D, 0x38, + 0xEB, 0x60, 0x10, 0xF4, 0x29, 0x87, 0x02, 0x12 + }, + { + 0x97, 0x16, 0x9E, 0x38, 0xB0, 0xC6, 0x99, 0x60, + 0x9F, 0xDE, 0x3A, 0x13, 0xFF, 0x11, 0xD5, 0xBE, + 0x40, 0x0A, 0x16, 0xE3, 0xAB, 0x3F, 0x9A, 0xFA, + 0xF5, 0x4B, 0x1E, 0xAE, 0xDB, 0xEE, 0x71, 0x7F + }, + { + 0x20, 0x7A, 0xBB, 0x0B, 0x98, 0xC4, 0x36, 0x36, + 0xB3, 0xD1, 0x83, 0xDA, 0x7B, 0x20, 0x7B, 0x1D, + 0xC2, 0x69, 0x1A, 0x07, 0x97, 0xAE, 0x5C, 0x41, + 0x83, 0x1D, 0x47, 0xDF, 0x1D, 0xB8, 0xC0, 0x28 + }, + { + 0x84, 0x9F, 0xC3, 0xAC, 0x9F, 0x61, 0x37, 0xE0, + 0xE9, 0x6D, 0x04, 0x5D, 0xCE, 0x27, 0xF3, 0x2E, + 0xA7, 0xF9, 0x4F, 0xF2, 0xF2, 0xCD, 0xC4, 0xDF, + 0x66, 0x27, 0xFA, 0x0C, 0xA2, 0xC0, 0x20, 0x32 + }, + { + 0x70, 0x52, 0xD1, 0x80, 0xB2, 0xD1, 0x43, 0x4A, + 0xE7, 0xB4, 0xC5, 0x64, 0x2B, 0x6C, 0xFA, 0x5A, + 0xB3, 0x30, 0x28, 0xE3, 0x83, 0xC8, 0x6A, 0x57, + 0x97, 0x92, 0x2F, 0x6C, 0x72, 0xB5, 0xFD, 0xDE + }, + { + 0xBA, 0xDA, 0xA3, 0xA5, 0xFE, 0x88, 0x71, 0xA5, + 0xC0, 0xC6, 0xCF, 0x60, 0xF3, 0x6E, 0x29, 0xED, + 0x6C, 0xD3, 0x9B, 0x97, 0xE8, 0x10, 0x7B, 0x20, + 0xEB, 0x3F, 0xDD, 0x50, 0x4E, 0x04, 0x7C, 0x56 + }, + { + 0x80, 0x14, 0x56, 0x5C, 0xA1, 0x0E, 0xF7, 0x22, + 0x63, 0x13, 0x18, 0x51, 0x0B, 0xE3, 0x63, 0x0F, + 0x40, 0x16, 0x66, 0x45, 0x48, 0xE4, 0x09, 0xAC, + 0x22, 0xF0, 0xBA, 0x85, 0x88, 0xEB, 0xA6, 0x71 + }, + { + 0xD1, 0x27, 0x37, 0x81, 0xE3, 0x2D, 0xDC, 0x60, + 0xE2, 0x8D, 0x4F, 0xD6, 0xE6, 0xED, 0xD6, 0x58, + 0x92, 0x8A, 0x8D, 0xD4, 0xBA, 0x1A, 0xB2, 0x17, + 0xA3, 0x14, 0x15, 0xB2, 0x32, 0xC6, 0xA8, 0x4A + }, + { + 0x28, 0x52, 0x52, 0xFB, 0x36, 0x19, 0x8B, 0x1A, + 0xE6, 0x00, 0x2C, 0x67, 0x4A, 0x61, 0x28, 0x46, + 0x60, 0x1C, 0xAA, 0x42, 0x33, 0x7D, 0xF5, 0x7E, + 0x1B, 0x7E, 0x88, 0x99, 0x29, 0xC6, 0xC2, 0x03 + }, + { + 0x78, 0x69, 0x07, 0xAE, 0xC8, 0xDC, 0x0C, 0x59, + 0xED, 0x58, 0x70, 0xBA, 0x29, 0x50, 0x4E, 0xCD, + 0xD2, 0xC5, 0x1D, 0x00, 0x7F, 0x1C, 0x24, 0xA3, + 0x0C, 0x41, 0xA9, 0x3B, 0xB5, 0xD5, 0xB8, 0x07 + }, + { + 0x57, 0x55, 0x75, 0x59, 0x51, 0x52, 0xB0, 0x98, + 0x71, 0x69, 0x11, 0x5C, 0x99, 0x83, 0x7A, 0xCE, + 0x76, 0x30, 0xC4, 0x7E, 0x3D, 0x7B, 0xE0, 0x89, + 0x18, 0x12, 0x55, 0x09, 0xDD, 0xC1, 0x07, 0xC2 + }, + { + 0x47, 0xBC, 0xBE, 0x4D, 0x9B, 0x34, 0xFE, 0xF0, + 0xA4, 0xBF, 0x56, 0xA6, 0x16, 0x27, 0x25, 0x4A, + 0x41, 0xBF, 0x4B, 0x9C, 0x7E, 0xB6, 0x59, 0x96, + 0xF6, 0xB4, 0x89, 0xC8, 0xB5, 0x08, 0x5F, 0xBF + }, + { + 0xC6, 0x60, 0x69, 0x6B, 0xD9, 0xA9, 0xC7, 0x51, + 0x39, 0x37, 0x69, 0xEF, 0x27, 0x04, 0xB1, 0x61, + 0xB2, 0x82, 0x72, 0x3A, 0xC8, 0xBD, 0x3D, 0x0E, + 0x49, 0xF5, 0x3D, 0x85, 0x5F, 0x73, 0xE6, 0xF1 + }, + { + 0x91, 0x91, 0x66, 0x1E, 0xA3, 0x98, 0x26, 0x7A, + 0xAC, 0x81, 0x3E, 0x34, 0x2E, 0xBA, 0x37, 0x9D, + 0xE0, 0x23, 0xBB, 0x5B, 0x84, 0x04, 0x9C, 0xC7, + 0x33, 0xDD, 0xDB, 0xF2, 0x3A, 0x7C, 0xCE, 0x1B + }, + { + 0x70, 0xEB, 0xA6, 0x79, 0x3C, 0xCF, 0xB6, 0x5C, + 0x05, 0xB6, 0x01, 0xFF, 0x16, 0xD3, 0x67, 0xFF, + 0x84, 0x93, 0x21, 0xD1, 0x9B, 0xD7, 0x90, 0xB7, + 0xB3, 0xB1, 0x26, 0xF4, 0xF2, 0x57, 0xCC, 0xFA + }, + { + 0x93, 0xB2, 0x65, 0x92, 0xCA, 0x52, 0xF7, 0xA5, + 0xF7, 0x50, 0xCD, 0x27, 0x5C, 0x7A, 0xB7, 0xF9, + 0x14, 0x62, 0xE9, 0x60, 0xD2, 0x36, 0x1A, 0xC8, + 0x5C, 0xE8, 0x37, 0x06, 0x2E, 0x1C, 0xFA, 0x26 + }, + { + 0x9F, 0xF7, 0x3B, 0xEE, 0x63, 0xC7, 0x6F, 0x66, + 0x3C, 0xB5, 0xE7, 0x3E, 0x7D, 0xC3, 0xDD, 0xAC, + 0xAC, 0x0F, 0x38, 0x41, 0x3F, 0xE1, 0x60, 0x95, + 0x34, 0x97, 0xEE, 0xA9, 0x7F, 0x19, 0xAD, 0xED + }, + { + 0x8B, 0x00, 0x14, 0xE9, 0x2C, 0xA9, 0x1E, 0x93, + 0xEA, 0x8C, 0x27, 0xFA, 0xBA, 0xE2, 0x2B, 0x46, + 0xFF, 0x51, 0xDD, 0x69, 0xD0, 0xAE, 0x31, 0x40, + 0x9F, 0x3F, 0x8C, 0xDC, 0xAF, 0x7B, 0xD7, 0x51 + }, + { + 0x40, 0x47, 0xDD, 0x08, 0x22, 0x04, 0xD6, 0x8F, + 0x40, 0x78, 0x1B, 0x77, 0x21, 0x63, 0x17, 0xB2, + 0x57, 0x9C, 0x1E, 0x61, 0x2F, 0x3B, 0x0D, 0xE0, + 0x08, 0x96, 0x41, 0x24, 0x5A, 0x7D, 0xC2, 0x95 + }, + { + 0x84, 0xE2, 0xF4, 0x4A, 0x14, 0xB0, 0xDF, 0xCF, + 0x67, 0x30, 0xF8, 0xB4, 0xE6, 0x5B, 0x3D, 0x95, + 0xF1, 0x1E, 0x1D, 0xFD, 0x0C, 0xB9, 0x48, 0xFC, + 0x6E, 0x43, 0x13, 0xBA, 0x4A, 0xCA, 0x71, 0x89 + }, + { + 0xC2, 0x85, 0x54, 0xBA, 0x46, 0x7C, 0x56, 0x04, + 0xF4, 0xE5, 0x0F, 0xF2, 0x70, 0x3C, 0x50, 0xD9, + 0xE2, 0x6D, 0x17, 0xCE, 0x03, 0x34, 0x67, 0x44, + 0x3B, 0x91, 0x55, 0xCA, 0x47, 0x42, 0x71, 0x6F + }, + { + 0x4C, 0x0E, 0x5E, 0xB4, 0x5D, 0x8E, 0x7D, 0xA4, + 0xF7, 0xEB, 0x50, 0xF8, 0x73, 0x53, 0x02, 0xF3, + 0xD0, 0xBD, 0xC3, 0x2A, 0xE6, 0xAE, 0x46, 0xC1, + 0x0B, 0x65, 0x2D, 0xEE, 0xAA, 0xCC, 0xB9, 0xAA + }, + { + 0x05, 0x84, 0xF7, 0x34, 0x02, 0x2A, 0xAD, 0xC7, + 0xF7, 0xB9, 0x54, 0x2C, 0xA0, 0x37, 0xDD, 0x51, + 0xBC, 0x05, 0x3D, 0x7E, 0x46, 0xBB, 0x90, 0xE3, + 0xD3, 0xE1, 0xE5, 0x61, 0x81, 0x24, 0x1F, 0x8C + }, + { + 0x85, 0x1F, 0x84, 0x0B, 0x21, 0x0F, 0x02, 0xC9, + 0xA6, 0x7D, 0x50, 0x18, 0xF0, 0x96, 0x8C, 0x14, + 0x12, 0xB5, 0xF0, 0x83, 0xA8, 0x5E, 0x16, 0x84, + 0xEE, 0xC6, 0xE0, 0xE3, 0x71, 0x7C, 0x43, 0x4B + }, + { + 0x94, 0x1B, 0x05, 0x89, 0x20, 0x33, 0x74, 0x77, + 0x00, 0x86, 0x81, 0xE0, 0x7A, 0x77, 0x8F, 0x68, + 0xDB, 0x82, 0xE8, 0x6E, 0xBF, 0x28, 0x52, 0x01, + 0x55, 0xE7, 0x3A, 0x32, 0xC2, 0x76, 0x21, 0x2A + }, + { + 0x87, 0x77, 0x27, 0x3F, 0x84, 0x6A, 0xF0, 0x96, + 0xD9, 0xFB, 0xA3, 0xDE, 0x52, 0x50, 0xA7, 0x6B, + 0x73, 0xB7, 0xEF, 0xE7, 0x90, 0x0C, 0xDF, 0x21, + 0xAA, 0xF2, 0xCE, 0x9F, 0xF0, 0x30, 0x1B, 0x0C + }, + { + 0x24, 0x44, 0x93, 0xF4, 0xE7, 0xC1, 0x44, 0x59, + 0xF2, 0xDF, 0x08, 0x1B, 0xCF, 0x2B, 0x2B, 0x25, + 0xBC, 0xC7, 0xC8, 0x47, 0xFE, 0x95, 0x0C, 0xC7, + 0xB2, 0xCE, 0x64, 0x45, 0x8A, 0xFA, 0x9E, 0xC7 + }, + { + 0x8F, 0xF6, 0x2D, 0x40, 0xE1, 0x0D, 0xA9, 0x05, + 0xF8, 0xF6, 0x23, 0x2A, 0xC2, 0xD4, 0x79, 0x8B, + 0x4E, 0x73, 0x18, 0x81, 0x33, 0x71, 0x11, 0x43, + 0x8A, 0xB9, 0x82, 0x89, 0x98, 0x49, 0xD2, 0x96 + }, + { + 0x92, 0x9B, 0x6A, 0x64, 0xD2, 0x6A, 0x3E, 0x81, + 0x51, 0x91, 0x9A, 0x38, 0x66, 0x85, 0xB9, 0x6C, + 0x2F, 0xF3, 0x9B, 0x56, 0x09, 0xA2, 0x0C, 0xAE, + 0x40, 0x6A, 0xC8, 0xA3, 0xC1, 0xA5, 0xA8, 0x83 + }, + { + 0x78, 0xBE, 0x66, 0x8C, 0x4D, 0x42, 0x6B, 0x16, + 0xAF, 0xE4, 0x85, 0x87, 0x20, 0x66, 0xDF, 0x77, + 0xA5, 0x70, 0x04, 0xF4, 0xA4, 0x19, 0x17, 0x38, + 0x2C, 0x28, 0x5D, 0xB0, 0x1E, 0xE9, 0x79, 0xB2 + }, + { + 0x88, 0x27, 0xBE, 0x83, 0x77, 0xE3, 0xC6, 0x25, + 0xF9, 0x11, 0x0B, 0x15, 0xCD, 0x62, 0xBF, 0x74, + 0x3C, 0xA5, 0x09, 0xAC, 0xDA, 0x44, 0xB0, 0x82, + 0x62, 0x71, 0xF4, 0x93, 0x1F, 0x34, 0x13, 0x15 + }, + { + 0x22, 0xE5, 0x84, 0xE7, 0x5B, 0x16, 0x57, 0x18, + 0x75, 0x3D, 0x50, 0xA4, 0x2E, 0xC7, 0xDD, 0x7C, + 0xE7, 0x0F, 0x52, 0xA8, 0x97, 0xE1, 0x9C, 0x05, + 0xE5, 0xD5, 0xAD, 0x76, 0x73, 0x67, 0x4D, 0x55 + }, + { + 0x61, 0x4B, 0x5A, 0x09, 0xA0, 0xC5, 0x72, 0xEF, + 0xC0, 0x69, 0x78, 0xFA, 0xB2, 0x19, 0x57, 0x6E, + 0xB5, 0xB1, 0x02, 0xB7, 0xA8, 0x51, 0xD1, 0xB4, + 0x14, 0x2E, 0x18, 0xC9, 0x9F, 0xD6, 0x79, 0x47 + }, + { + 0xD4, 0x71, 0xCB, 0x82, 0x82, 0xC2, 0xCD, 0x4E, + 0xA5, 0x34, 0x34, 0x21, 0x3E, 0xC4, 0x64, 0xB1, + 0x30, 0xD0, 0x42, 0xDB, 0x5E, 0x65, 0x8E, 0x1A, + 0x89, 0x64, 0x90, 0x98, 0xA8, 0x25, 0x99, 0x13 + }, + { + 0x9E, 0xF9, 0x78, 0xCC, 0x29, 0xCE, 0xF3, 0x6F, + 0xA7, 0x66, 0xED, 0x94, 0xAE, 0x65, 0xBB, 0x36, + 0x9B, 0x6C, 0xEC, 0x79, 0xDF, 0xBA, 0x0C, 0xC4, + 0x68, 0xF2, 0x2E, 0xD4, 0xDA, 0x8A, 0x9C, 0xE2 + }, + { + 0x3C, 0x02, 0x8E, 0x8B, 0xDA, 0xC3, 0x51, 0x2C, + 0x6E, 0x99, 0xBA, 0x96, 0x37, 0xB7, 0x26, 0xE3, + 0x5E, 0x16, 0xB2, 0x54, 0x30, 0x9E, 0xBB, 0xDE, + 0x6C, 0xBC, 0x40, 0x57, 0xB1, 0x38, 0xDB, 0x3E + }, + { + 0xEE, 0xD9, 0x73, 0x04, 0x56, 0x5D, 0x7F, 0x36, + 0x68, 0x23, 0xE9, 0x59, 0xEE, 0xFC, 0xC8, 0x67, + 0x87, 0x60, 0x54, 0x92, 0xAD, 0xE1, 0x32, 0x66, + 0x6F, 0x0E, 0xDC, 0x80, 0x62, 0x4E, 0x6A, 0xB9 + }, + { + 0x2A, 0xCD, 0x2E, 0xCE, 0x5C, 0x7C, 0xB4, 0xC4, + 0x8E, 0x7E, 0xE9, 0x87, 0xE6, 0x4D, 0x04, 0xBF, + 0x45, 0xBF, 0x58, 0xA1, 0xA0, 0xD0, 0xE2, 0x84, + 0xBE, 0x67, 0x37, 0xBB, 0x74, 0x29, 0x2A, 0x77 + }, + { + 0x82, 0xB2, 0x1A, 0x84, 0xE3, 0x21, 0x4D, 0xD3, + 0x9E, 0xB1, 0x4B, 0x3A, 0x62, 0x56, 0x49, 0xD0, + 0x6C, 0x59, 0xD3, 0xD8, 0x7F, 0xC8, 0x3E, 0x13, + 0x45, 0x16, 0x25, 0x6B, 0x5F, 0x9D, 0x10, 0x10 + }, + { + 0x16, 0x60, 0x26, 0xDD, 0xD4, 0xE5, 0x82, 0x4F, + 0x60, 0x45, 0x86, 0x41, 0xF3, 0xD0, 0x7A, 0xC3, + 0xBB, 0x9D, 0xA9, 0xE5, 0x86, 0x87, 0xC4, 0x97, + 0xFE, 0x59, 0x63, 0x2E, 0xBC, 0xDC, 0xB3, 0x2B + }, + { + 0xFC, 0x33, 0x16, 0x17, 0x00, 0xFD, 0x3D, 0x4A, + 0x93, 0xF2, 0x4F, 0x8D, 0x0F, 0x66, 0xF5, 0x1F, + 0xFF, 0x46, 0x57, 0x4A, 0x27, 0x48, 0x87, 0x9C, + 0x34, 0x21, 0x65, 0xEC, 0x6A, 0x47, 0xD6, 0x9D + }, + { + 0xD9, 0xFA, 0xDF, 0xD0, 0x31, 0xE5, 0x90, 0x52, + 0xD6, 0xFB, 0x4D, 0xE7, 0x30, 0x32, 0x89, 0xED, + 0x91, 0xAC, 0xC3, 0xD7, 0x4A, 0x78, 0x97, 0x9D, + 0x8D, 0xE3, 0x88, 0x86, 0x7B, 0xEA, 0xFD, 0x83 + }, + { + 0xC6, 0x6F, 0x04, 0x1B, 0xAB, 0x6B, 0x68, 0x74, + 0x57, 0xB1, 0x68, 0x92, 0x8E, 0x0B, 0x7A, 0x7B, + 0x05, 0xDB, 0x32, 0xED, 0x1B, 0x72, 0xA5, 0xC1, + 0xE0, 0x52, 0x66, 0xC1, 0xB2, 0x89, 0x5A, 0x5D + }, + { + 0x7D, 0xB8, 0x68, 0x22, 0x61, 0xFE, 0x45, 0x8B, + 0x51, 0x88, 0xCE, 0x7C, 0x30, 0x0D, 0x9A, 0xF2, + 0x3F, 0x5C, 0xA0, 0xC4, 0xEF, 0x72, 0x03, 0xA2, + 0x67, 0xDF, 0x83, 0xFF, 0x9E, 0x8E, 0x94, 0x9A + }, + { + 0xA0, 0x2C, 0x28, 0x3A, 0xA4, 0x66, 0x86, 0xA1, + 0x42, 0x8C, 0x24, 0xFC, 0xBC, 0x14, 0x7C, 0xC0, + 0x05, 0xF4, 0x1B, 0x61, 0xB5, 0xE1, 0x0A, 0x73, + 0xCC, 0x02, 0x93, 0x90, 0x12, 0x0C, 0x58, 0xD5 + }, + { + 0xE7, 0x09, 0x22, 0xB4, 0xF2, 0xB0, 0x95, 0xAC, + 0x4A, 0xD5, 0x77, 0xC2, 0x86, 0xF8, 0xC5, 0x21, + 0xCC, 0x23, 0xF2, 0x59, 0x8A, 0x89, 0x4D, 0xFA, + 0xB4, 0x62, 0xAB, 0x8D, 0xAA, 0x99, 0x8A, 0x33 + }, + { + 0xB5, 0xF9, 0xD7, 0x79, 0x91, 0x11, 0xED, 0xAF, + 0xC9, 0x32, 0x6F, 0xBF, 0x66, 0x7B, 0xE9, 0x81, + 0x40, 0xB5, 0xE2, 0x0C, 0xE5, 0xE1, 0x51, 0x79, + 0x3C, 0x59, 0x12, 0x5B, 0xF6, 0x54, 0xAC, 0x18 + }, + { + 0x45, 0x12, 0x7E, 0x41, 0xE7, 0x18, 0x4E, 0xBA, + 0xA3, 0xC6, 0xD0, 0x7B, 0x8E, 0x9D, 0xAF, 0xF8, + 0xCC, 0xB7, 0x87, 0x60, 0x23, 0xC2, 0xAC, 0x5B, + 0x9A, 0x67, 0x74, 0x7E, 0x5B, 0xA7, 0x6F, 0x95 + }, + { + 0x45, 0x12, 0xA9, 0x08, 0x78, 0x81, 0x31, 0x4A, + 0xB3, 0xA3, 0x98, 0x88, 0xB5, 0x15, 0xDA, 0x34, + 0x14, 0xB8, 0xE8, 0xFF, 0x92, 0xD4, 0xF5, 0x03, + 0x70, 0x78, 0x59, 0x42, 0x98, 0x77, 0xCD, 0x04 + }, + { + 0x29, 0x27, 0x29, 0x1B, 0x2A, 0x8D, 0x5D, 0xD3, + 0x92, 0x69, 0xF8, 0xB1, 0x5E, 0xEC, 0x60, 0xF1, + 0xB0, 0x35, 0x59, 0x21, 0x39, 0xD5, 0x3C, 0xA5, + 0x8A, 0xCB, 0xBD, 0x9A, 0x47, 0x69, 0x27, 0xCD + }, + { + 0x41, 0x7C, 0x7F, 0x63, 0xE9, 0x59, 0x29, 0x7F, + 0x11, 0x16, 0xE5, 0x6F, 0x0D, 0xEB, 0xB8, 0xD8, + 0xC8, 0x6A, 0xCE, 0x8C, 0x7A, 0x7F, 0x5B, 0x8B, + 0xFD, 0x20, 0x9C, 0x2A, 0x13, 0xD8, 0xB6, 0xBD + }, + { + 0xF9, 0x5F, 0x3F, 0x21, 0xA0, 0xB4, 0x5B, 0x4D, + 0xD5, 0x2C, 0x8E, 0x82, 0x4A, 0x1A, 0x36, 0xCA, + 0xB5, 0x28, 0x48, 0x68, 0x40, 0xDB, 0x23, 0x62, + 0xE3, 0x52, 0x3E, 0xE0, 0x81, 0x36, 0xC0, 0x36 + }, + { + 0x87, 0x9B, 0xB4, 0x34, 0x53, 0xDD, 0x79, 0x12, + 0xFF, 0x87, 0x42, 0xC2, 0x8E, 0x85, 0x80, 0xF4, + 0x78, 0xB3, 0x57, 0x58, 0x62, 0x8E, 0x98, 0xB8, + 0x38, 0x8C, 0x8F, 0x5D, 0xFF, 0x36, 0x8F, 0x7A + }, + { + 0x64, 0x4E, 0x7E, 0x79, 0x5E, 0x84, 0x74, 0x41, + 0x44, 0x69, 0x7A, 0x8D, 0x18, 0x99, 0xE2, 0xDC, + 0xF0, 0x17, 0xD5, 0x34, 0xF4, 0x8E, 0x2A, 0x71, + 0x87, 0xF5, 0x12, 0x2F, 0xE1, 0x4B, 0x43, 0x90 + }, + { + 0x0D, 0x46, 0x97, 0xE0, 0x06, 0x99, 0x6A, 0x00, + 0xE5, 0xA7, 0xB5, 0x0B, 0x75, 0xB4, 0x22, 0x6C, + 0x5D, 0x6F, 0x40, 0x0D, 0xAD, 0x4E, 0xEE, 0xB4, + 0xBD, 0x2F, 0x72, 0xFE, 0x6F, 0x95, 0x1B, 0x7D + }, + { + 0x5E, 0x7C, 0xEF, 0xF1, 0x44, 0xE9, 0x4C, 0x8E, + 0x25, 0x83, 0x82, 0x66, 0x97, 0xA2, 0x6F, 0xE8, + 0x9B, 0xED, 0x20, 0x1B, 0xB7, 0xC2, 0xDC, 0x43, + 0x13, 0xF9, 0xB4, 0x45, 0x9D, 0x86, 0x16, 0x3A + }, + { + 0x00, 0x55, 0xF4, 0x02, 0x09, 0x38, 0xA5, 0x7F, + 0x1B, 0xA2, 0xA9, 0xC1, 0x1B, 0xEB, 0x81, 0xF0, + 0x8F, 0xEA, 0xE3, 0x3B, 0x79, 0xDC, 0x98, 0xA3, + 0xB1, 0x12, 0x5A, 0x7E, 0xDE, 0x58, 0x94, 0x41 + }, + { + 0xF1, 0xBD, 0xB9, 0x7E, 0xA1, 0xB5, 0x4B, 0x82, + 0x6F, 0x9E, 0xD4, 0x86, 0x36, 0x68, 0xC3, 0xC2, + 0xB3, 0x2C, 0xB2, 0xD2, 0x92, 0xAD, 0xB1, 0x55, + 0x9A, 0x4A, 0xA9, 0x79, 0xDB, 0x80, 0xDB, 0x09 + }, + { + 0x6C, 0xF6, 0x25, 0xDA, 0xD8, 0x12, 0x61, 0xCA, + 0x32, 0xEC, 0x38, 0xAB, 0x45, 0x99, 0xAB, 0xC9, + 0xF1, 0x4A, 0xCC, 0xF7, 0x31, 0xF0, 0xDC, 0x4A, + 0x42, 0x78, 0xF3, 0x1D, 0xF7, 0x8A, 0x4C, 0x09 + }, + { + 0x2C, 0xC1, 0xA8, 0x25, 0x98, 0x9E, 0xBD, 0x1F, + 0xCF, 0x04, 0xE0, 0xC5, 0xCF, 0xAE, 0x57, 0xC4, + 0x17, 0x67, 0x8C, 0x2E, 0xCA, 0x07, 0x3F, 0xF2, + 0xD7, 0xC6, 0x53, 0x44, 0x93, 0x9B, 0x4A, 0xE6 + }, + { + 0xED, 0x89, 0x9A, 0x17, 0xEC, 0x65, 0xB0, 0x40, + 0x43, 0x91, 0x16, 0xA2, 0xF0, 0x41, 0xEB, 0x58, + 0xB5, 0x56, 0x59, 0x95, 0x15, 0x51, 0x4A, 0x0A, + 0x26, 0xB2, 0x77, 0xCC, 0xF7, 0xDF, 0xB2, 0x1F + }, + { + 0x72, 0x5B, 0xAC, 0xFD, 0x37, 0x94, 0xA6, 0x1F, + 0x0F, 0x6A, 0x60, 0xBC, 0x95, 0x47, 0xFD, 0x21, + 0x36, 0x8D, 0x61, 0xD2, 0x1F, 0x46, 0x3A, 0x28, + 0xDC, 0x1C, 0x76, 0x0C, 0xC0, 0xBC, 0xB5, 0x12 + }, + { + 0xD2, 0xD5, 0xEA, 0xE0, 0x15, 0xD7, 0xA5, 0x4B, + 0x9C, 0x8C, 0x39, 0x8F, 0xF2, 0x47, 0x44, 0x1D, + 0x47, 0xDE, 0xC3, 0xE1, 0xA5, 0xCC, 0x61, 0xF6, + 0xCC, 0x15, 0x5E, 0xC6, 0xF2, 0x58, 0x33, 0x61 + }, + { + 0xE9, 0x8B, 0xE5, 0xE7, 0x3B, 0x9D, 0x58, 0x3B, + 0x13, 0xEC, 0x15, 0x4D, 0xB1, 0xD4, 0xFD, 0xE3, + 0x7B, 0x28, 0xC8, 0x20, 0x9C, 0x87, 0x5D, 0x5E, + 0xA2, 0x2E, 0x0C, 0xE2, 0x3A, 0x95, 0xC2, 0x5C + }, + { + 0xD1, 0x2A, 0x18, 0xDC, 0x4D, 0xF8, 0x00, 0xE1, + 0x37, 0xAC, 0x02, 0xA4, 0x80, 0xEF, 0x72, 0xBD, + 0xAD, 0x1A, 0x9F, 0x22, 0xDA, 0x5A, 0x65, 0x3D, + 0xD4, 0x6D, 0x91, 0xB3, 0xD6, 0x94, 0x9E, 0xF1 + }, + { + 0xFA, 0x02, 0x31, 0x94, 0x9B, 0xFA, 0xD7, 0xED, + 0x17, 0x84, 0x1C, 0x32, 0xF7, 0x88, 0x88, 0x9A, + 0x5A, 0x2E, 0x78, 0x0F, 0xCD, 0xD9, 0xC8, 0xCD, + 0x81, 0x93, 0x79, 0x99, 0xF0, 0xA3, 0x49, 0x40 + }, + { + 0xA4, 0x94, 0x05, 0x89, 0x68, 0xE1, 0x84, 0x30, + 0x82, 0xE5, 0xEF, 0x0B, 0x5B, 0x98, 0x4B, 0x32, + 0x3B, 0xD1, 0x25, 0x9C, 0x49, 0xAE, 0x6C, 0xC8, + 0x98, 0xD2, 0xFA, 0x1E, 0xF5, 0xC0, 0x21, 0x94 + }, + { + 0x19, 0xDB, 0xC3, 0x48, 0x0B, 0xCD, 0x73, 0xCA, + 0xD8, 0x28, 0xAE, 0xDA, 0x3E, 0x2B, 0x31, 0x31, + 0x2C, 0x82, 0xF4, 0x6C, 0xF0, 0xF5, 0x7A, 0xA0, + 0xAC, 0x99, 0x69, 0x4A, 0x22, 0x1D, 0xB8, 0xEE + }, + { + 0x74, 0xC3, 0xEE, 0x3C, 0x6E, 0xB5, 0x7F, 0x27, + 0x93, 0x45, 0xAE, 0x43, 0x50, 0x68, 0xEB, 0xFF, + 0x1A, 0xA6, 0x9C, 0x08, 0xDC, 0xFF, 0x5F, 0xB8, + 0x9F, 0x6B, 0x45, 0x91, 0x13, 0x9C, 0x6D, 0x9D + }, + { + 0xD4, 0xFE, 0xDD, 0xC2, 0xAC, 0x18, 0x12, 0x49, + 0xFD, 0xE3, 0xDA, 0xA7, 0x31, 0xF6, 0x67, 0x94, + 0xB6, 0x81, 0x26, 0x10, 0xCF, 0x99, 0xC9, 0x16, + 0xDB, 0x50, 0xCD, 0xC7, 0x1E, 0xB3, 0x23, 0x0E + }, + { + 0xA0, 0x49, 0x45, 0x5A, 0xDD, 0x68, 0xF3, 0x8D, + 0x48, 0x84, 0x5E, 0x25, 0xA5, 0x2B, 0xA3, 0x10, + 0x0C, 0x4D, 0x08, 0x99, 0x17, 0x8C, 0x20, 0x2A, + 0xEC, 0x07, 0x36, 0x4F, 0xEC, 0xAC, 0xF6, 0x50 + }, + { + 0x20, 0xC6, 0x1D, 0x1C, 0xF0, 0x89, 0x5C, 0x12, + 0xCE, 0x9B, 0xF5, 0x70, 0xF9, 0x3B, 0x2C, 0x10, + 0xFE, 0x9B, 0x01, 0x0A, 0x88, 0x4C, 0xCD, 0x8E, + 0xB8, 0x3F, 0x05, 0xCE, 0x05, 0xDE, 0x00, 0x05 + }, + { + 0xDF, 0x6A, 0x93, 0x7C, 0xCD, 0x52, 0xB9, 0x07, + 0x52, 0x8E, 0xC0, 0xD8, 0x9D, 0xB2, 0xEC, 0x83, + 0xB1, 0xFA, 0x58, 0x34, 0xFA, 0x63, 0xA0, 0xAB, + 0x56, 0x81, 0x42, 0x5C, 0x23, 0x86, 0x26, 0xB7 + }, + { + 0x1D, 0x52, 0x6D, 0x0E, 0xC1, 0x87, 0x09, 0x77, + 0x8A, 0xEB, 0x08, 0xEB, 0x90, 0xA3, 0xAC, 0x5B, + 0xE5, 0xCE, 0xEC, 0x29, 0x53, 0x98, 0xF8, 0x99, + 0x19, 0x03, 0x66, 0xD5, 0x79, 0x33, 0x63, 0x6E + }, + { + 0x9D, 0x7F, 0xFB, 0x81, 0xAE, 0x4E, 0x11, 0xC2, + 0x37, 0x10, 0x8E, 0xBB, 0xDB, 0x56, 0x6D, 0xBC, + 0x2B, 0x64, 0xF1, 0xF1, 0x0A, 0xB4, 0x28, 0xAE, + 0xE3, 0xCC, 0xCA, 0xD5, 0xE9, 0x7E, 0xEB, 0x3E + }, + { + 0x55, 0x91, 0x3C, 0x64, 0x75, 0xA7, 0x90, 0xB4, + 0xFD, 0xF9, 0x7B, 0x3A, 0x42, 0xC4, 0xA8, 0xB7, + 0x1A, 0x46, 0x43, 0xAB, 0x99, 0x1A, 0x3F, 0x2F, + 0x22, 0x16, 0xC9, 0x51, 0x7C, 0x9E, 0x5A, 0xBE + }, + { + 0x36, 0x02, 0x36, 0x20, 0x9B, 0xAF, 0xD4, 0xCE, + 0x3B, 0x9F, 0xF7, 0xB2, 0x5B, 0xE8, 0xCE, 0x41, + 0xBF, 0x96, 0x09, 0x1F, 0x5C, 0xC3, 0xED, 0xFF, + 0x9E, 0x02, 0x59, 0xC6, 0xCE, 0x7C, 0x0C, 0x5F + }, + { + 0xB4, 0x7B, 0xE8, 0x08, 0x5F, 0xC1, 0x8B, 0xD6, + 0x94, 0xEA, 0xC9, 0x8A, 0x1B, 0x8A, 0x50, 0x20, + 0xC1, 0xD4, 0xBA, 0x8E, 0xD3, 0x29, 0x3F, 0xB5, + 0xC1, 0x82, 0x3F, 0x9F, 0x22, 0x48, 0xE8, 0x88 + }, + { + 0x6E, 0x25, 0x74, 0x41, 0xE0, 0x62, 0x43, 0x0A, + 0xD2, 0x43, 0x8C, 0xF5, 0xAE, 0x2A, 0xC5, 0x97, + 0x62, 0x99, 0xAB, 0x0C, 0xB8, 0x15, 0x4F, 0x67, + 0xC2, 0x2D, 0xCC, 0x5A, 0xEA, 0x1C, 0x57, 0x16 + }, + { + 0x27, 0x4E, 0xAF, 0x35, 0x14, 0x37, 0xFE, 0xF7, + 0x80, 0x7B, 0x75, 0xCE, 0x69, 0x20, 0xB8, 0xA7, + 0xB3, 0x97, 0x3A, 0x13, 0xB4, 0xBD, 0x47, 0x08, + 0xAA, 0xC5, 0xD8, 0x59, 0x42, 0x0A, 0x48, 0x8F + }, + { + 0xA6, 0xF2, 0x01, 0x8B, 0xEB, 0x32, 0x93, 0x01, + 0x27, 0x8F, 0xE2, 0x26, 0x0B, 0xA8, 0x08, 0x4A, + 0x91, 0x40, 0x3E, 0x32, 0x4A, 0x00, 0x0A, 0x34, + 0xC3, 0x4B, 0x18, 0xA3, 0x82, 0xCF, 0xB2, 0x7E + }, + { + 0x6D, 0x76, 0xFA, 0x60, 0x5B, 0x2D, 0xE0, 0x2F, + 0x7A, 0x90, 0x1D, 0x0D, 0x89, 0x00, 0xD3, 0x34, + 0x25, 0x51, 0x4E, 0x97, 0xBD, 0x0A, 0x21, 0xFA, + 0x9B, 0x65, 0x85, 0xEF, 0xF3, 0xEF, 0xF3, 0x0D + }, + { + 0x69, 0x72, 0xFC, 0x8B, 0xD5, 0x46, 0xEA, 0x64, + 0xDB, 0x45, 0x3C, 0xA0, 0x29, 0x50, 0x30, 0x0B, + 0xA6, 0xC3, 0xFB, 0xDA, 0xB7, 0xD1, 0x66, 0x52, + 0xC2, 0x0B, 0x8B, 0xAE, 0x13, 0x22, 0x38, 0x38 + }, + { + 0x8A, 0x29, 0x40, 0xAD, 0xB4, 0x60, 0x46, 0x47, + 0x4E, 0xB5, 0x0B, 0x2A, 0x75, 0x15, 0x1D, 0x25, + 0x2E, 0x96, 0xF0, 0x63, 0x01, 0x98, 0x0D, 0xC2, + 0x5D, 0x92, 0x8E, 0x45, 0x94, 0xB6, 0x26, 0x1C + }, + { + 0x3D, 0x1A, 0x32, 0x1F, 0x25, 0x48, 0x12, 0x56, + 0xB8, 0xD9, 0x50, 0x86, 0xA4, 0x0E, 0xF4, 0x06, + 0x0A, 0xB2, 0xCC, 0x3F, 0x81, 0x93, 0x3B, 0xFC, + 0xFF, 0x65, 0x10, 0x86, 0xB9, 0xE0, 0x00, 0xE0 + }, + { + 0x79, 0x34, 0x61, 0x87, 0x71, 0x9B, 0x02, 0x85, + 0x5B, 0x28, 0x17, 0x85, 0xDE, 0xDD, 0x59, 0xDC, + 0x61, 0x26, 0xC7, 0xDD, 0x41, 0x3D, 0x23, 0x4F, + 0x3F, 0x4F, 0x0E, 0x05, 0x28, 0x14, 0xAF, 0xBC + }, + { + 0x10, 0xC4, 0x0D, 0xF3, 0xF8, 0x3E, 0x37, 0xF0, + 0xFF, 0xF8, 0x1B, 0x81, 0x19, 0xB9, 0x5A, 0x06, + 0x96, 0x9C, 0x9D, 0xF9, 0x12, 0xC9, 0x43, 0x7B, + 0x10, 0x98, 0x3E, 0x2B, 0x25, 0xB5, 0xF5, 0x8B + }, + { + 0xBC, 0x40, 0x43, 0x68, 0xB0, 0x82, 0x77, 0x4B, + 0x2F, 0xD5, 0x83, 0xD4, 0x89, 0x7C, 0xFE, 0x41, + 0x15, 0x83, 0xB9, 0x45, 0x0D, 0x07, 0xF5, 0xD1, + 0x25, 0x6A, 0x52, 0x65, 0xEB, 0x3C, 0x98, 0x1F + }, + { + 0xEC, 0xF9, 0x33, 0x4E, 0xD9, 0x13, 0xBE, 0x44, + 0x45, 0x15, 0x8C, 0x70, 0x47, 0x84, 0x7D, 0xF3, + 0x24, 0x72, 0x9B, 0x57, 0xAF, 0xFC, 0x22, 0x4F, + 0x27, 0xD7, 0xAE, 0x8D, 0xEB, 0x59, 0x90, 0xC4 + }, + { + 0x33, 0xFB, 0x04, 0x4C, 0xFC, 0x8B, 0x46, 0xC8, + 0xDF, 0x27, 0x4F, 0x9D, 0xF3, 0x74, 0xED, 0x71, + 0x26, 0x97, 0x83, 0x36, 0x0A, 0x44, 0x25, 0x19, + 0x38, 0xA2, 0x52, 0x81, 0xF6, 0xE4, 0xE2, 0x58 + }, + { + 0xCF, 0xCF, 0xE8, 0x7A, 0xA4, 0xEB, 0xF2, 0x16, + 0x3E, 0x20, 0x75, 0xA3, 0xC5, 0x8F, 0xF8, 0xA7, + 0xFE, 0x2C, 0xF9, 0xA4, 0x20, 0x65, 0xF0, 0xCD, + 0x6E, 0xA3, 0x09, 0xD1, 0x2A, 0x57, 0x12, 0x94 + }, + { + 0x17, 0xC9, 0xA9, 0x2C, 0x4A, 0x62, 0x7A, 0xF3, + 0x6F, 0xEA, 0x84, 0x40, 0x50, 0x49, 0xF8, 0x38, + 0x51, 0xE7, 0x42, 0x9D, 0xEE, 0x46, 0xA9, 0xFA, + 0x51, 0xF4, 0xDA, 0x19, 0xE7, 0x44, 0x2B, 0x1C + }, + { + 0x95, 0x22, 0xC9, 0x19, 0xB4, 0x7A, 0x81, 0x91, + 0x69, 0xB7, 0xA9, 0x14, 0x93, 0x42, 0xE7, 0x61, + 0xB9, 0x04, 0x5D, 0x82, 0xC2, 0x82, 0xFD, 0x31, + 0x96, 0x4A, 0xC9, 0x0C, 0x90, 0xC1, 0x88, 0x43 + }, + { + 0xD0, 0x67, 0x60, 0x1D, 0x54, 0x32, 0xDE, 0x89, + 0xA0, 0xD6, 0x8A, 0xC5, 0x51, 0x95, 0xFF, 0xEE, + 0x96, 0x33, 0x8E, 0x4F, 0xDC, 0x05, 0xD5, 0x12, + 0x78, 0x01, 0xEB, 0xD4, 0xE1, 0x33, 0xCC, 0x6F + }, + { + 0xA7, 0xA1, 0x2D, 0xEA, 0x65, 0x90, 0x33, 0x9F, + 0x9F, 0xF2, 0x84, 0x87, 0x29, 0x1E, 0x3F, 0x6A, + 0xEA, 0x7C, 0x16, 0xA1, 0xEE, 0x08, 0x04, 0x20, + 0xB7, 0x2D, 0x5D, 0x6A, 0x81, 0x58, 0x59, 0x51 + }, + { + 0xE9, 0x89, 0xBC, 0x7B, 0x30, 0x27, 0x1A, 0xD8, + 0x9A, 0x02, 0xFA, 0xA5, 0x14, 0x87, 0x72, 0x62, + 0x11, 0xA3, 0x2E, 0xC2, 0xB7, 0x31, 0xFB, 0x53, + 0x92, 0xBA, 0x0C, 0xEC, 0x99, 0x06, 0x12, 0x7B + }, + { + 0x92, 0x11, 0x7C, 0x39, 0xB6, 0xAA, 0x29, 0xCB, + 0xFC, 0x38, 0x7F, 0x55, 0xBD, 0xF4, 0xF4, 0x65, + 0x13, 0x70, 0xC0, 0x9F, 0x33, 0xDD, 0xE8, 0x8F, + 0xAE, 0x41, 0x6C, 0xE6, 0x1D, 0xE9, 0x79, 0xC0 + }, + { + 0xDA, 0x6D, 0x1F, 0xB3, 0x79, 0xE1, 0xC0, 0x77, + 0x54, 0xD4, 0x38, 0x12, 0x3F, 0x02, 0xB3, 0x6A, + 0xAC, 0x7A, 0xFF, 0x40, 0xFC, 0x7B, 0xC1, 0x6C, + 0x8B, 0x2B, 0x74, 0x34, 0x33, 0xEE, 0x6C, 0xF9 + }, + { + 0x11, 0x0D, 0xF0, 0x08, 0xDE, 0x83, 0x16, 0x63, + 0x3F, 0x27, 0x97, 0xF6, 0x51, 0x8C, 0xDC, 0x2A, + 0xCA, 0x50, 0xA4, 0x92, 0x4E, 0x6C, 0xDA, 0xE3, + 0xA1, 0xAA, 0x18, 0xF8, 0x7E, 0x49, 0x1F, 0x47 + }, + { + 0x5F, 0x15, 0x43, 0xCF, 0xB7, 0x06, 0x54, 0xFD, + 0x96, 0xD0, 0x2C, 0x74, 0xD0, 0x8E, 0x7C, 0x20, + 0x97, 0xCC, 0x26, 0x6B, 0x79, 0x55, 0xAA, 0xDA, + 0xAF, 0x44, 0xDE, 0x70, 0x59, 0x26, 0x1F, 0x3D + }, + { + 0x0D, 0x4E, 0xBA, 0xEC, 0x23, 0xFD, 0x87, 0x3F, + 0xEF, 0xB5, 0x2F, 0x8D, 0xD0, 0x24, 0x91, 0x5B, + 0xC4, 0x96, 0xD2, 0x2E, 0x6F, 0x1A, 0x4A, 0x61, + 0x9A, 0xE5, 0xC8, 0x26, 0x0A, 0x1E, 0x51, 0x3E + }, + { + 0xA8, 0x2C, 0x35, 0xFC, 0xA2, 0xE8, 0x4B, 0xFB, + 0xBA, 0x25, 0x0D, 0x32, 0x25, 0x7C, 0x75, 0x47, + 0xCB, 0x68, 0x9A, 0x25, 0x16, 0x77, 0x1A, 0xDF, + 0x1A, 0x43, 0x4D, 0xC7, 0xEC, 0x8C, 0xD2, 0x63 + }, + { + 0x29, 0x33, 0xA0, 0xC7, 0xD0, 0x59, 0xD2, 0xA1, + 0x8B, 0x4B, 0x98, 0x19, 0x12, 0x95, 0x5F, 0xD6, + 0x77, 0x2C, 0x22, 0x04, 0x20, 0x0A, 0xBD, 0xF8, + 0xB3, 0x04, 0x90, 0x86, 0x74, 0xBC, 0xA2, 0xBF + }, + { + 0x9C, 0x6A, 0xA6, 0xCD, 0xED, 0xDD, 0xF9, 0xA3, + 0x96, 0x2E, 0xB2, 0x6C, 0x17, 0x9B, 0xAC, 0xEE, + 0x66, 0x4C, 0x2F, 0xAE, 0x81, 0x08, 0xC5, 0x3D, + 0xEA, 0xF7, 0x5E, 0xD4, 0x05, 0x1B, 0x64, 0x77 + }, + { + 0xF5, 0x4E, 0x42, 0x9B, 0x98, 0xEE, 0x2E, 0xE1, + 0xED, 0xAC, 0x67, 0xA7, 0xCE, 0x87, 0x70, 0xD6, + 0xCE, 0x33, 0xB0, 0x5A, 0xCC, 0xD7, 0xA4, 0x1A, + 0x87, 0xE9, 0x59, 0xC8, 0x54, 0x6B, 0x9E, 0x9D + }, + { + 0x94, 0x6B, 0xCA, 0x83, 0x0C, 0x36, 0xBE, 0x89, + 0x26, 0x92, 0x7F, 0xF8, 0x18, 0x37, 0x28, 0xFE, + 0x65, 0x02, 0xDF, 0xC7, 0x82, 0xA5, 0xDB, 0x0A, + 0xD1, 0x04, 0x4C, 0x22, 0x0C, 0x28, 0xC9, 0x70 + }, + { + 0x19, 0x15, 0x03, 0x95, 0x0F, 0xEE, 0x86, 0xAF, + 0x63, 0x1D, 0xE8, 0x2F, 0x17, 0xB0, 0x9A, 0x0C, + 0xEE, 0x1C, 0x24, 0x05, 0x1B, 0x0C, 0xEA, 0x38, + 0xAD, 0xFC, 0xBC, 0xD8, 0xC4, 0xF8, 0xCF, 0xC2 + }, + { + 0x94, 0x48, 0x99, 0x14, 0xFE, 0x6F, 0x87, 0x6A, + 0x7F, 0x85, 0x40, 0xB4, 0xF0, 0xFE, 0xBF, 0xB6, + 0x8C, 0x11, 0xA8, 0xFB, 0xD9, 0x8C, 0xA0, 0x7B, + 0x2B, 0xF2, 0xF8, 0x49, 0x7F, 0x0F, 0x21, 0xAE + }, + { + 0x61, 0x59, 0x67, 0x26, 0x37, 0x1E, 0x52, 0x36, + 0xBF, 0xFD, 0x20, 0x80, 0xBC, 0xAB, 0x29, 0x9C, + 0x3A, 0x07, 0xE8, 0x94, 0x73, 0x7C, 0x98, 0xE5, + 0x81, 0xE6, 0xF8, 0xE8, 0xFD, 0x5C, 0xD5, 0x7F + }, + { + 0x0F, 0xAC, 0x2B, 0xD2, 0x62, 0x60, 0x08, 0x1A, + 0x08, 0x75, 0xC5, 0xC5, 0x62, 0xF0, 0x2A, 0x4A, + 0xCE, 0xEE, 0x1B, 0xD3, 0x3D, 0x66, 0x93, 0xF3, + 0x0D, 0x49, 0x3D, 0x03, 0x5E, 0x3C, 0xF4, 0xF5 + }, + { + 0x4E, 0x02, 0x45, 0x22, 0x66, 0xC1, 0xC2, 0x80, + 0x89, 0xDC, 0x8F, 0xA5, 0xDB, 0xA8, 0x7C, 0xCB, + 0x85, 0x2E, 0xC2, 0xAD, 0x7F, 0x58, 0xA9, 0x7C, + 0x2A, 0x32, 0x15, 0xEF, 0x74, 0xE0, 0xD3, 0x6B + }, + { + 0x1A, 0x61, 0x01, 0x37, 0x42, 0xFA, 0x46, 0x3A, + 0x09, 0x42, 0xEB, 0xD7, 0x13, 0x39, 0xD9, 0x45, + 0x5D, 0x6E, 0xAF, 0x95, 0x57, 0x27, 0x23, 0x8A, + 0x65, 0x96, 0x36, 0x5F, 0xC8, 0x61, 0x16, 0x18 + }, + { + 0x56, 0x82, 0xAD, 0xBD, 0x9E, 0xF4, 0xC3, 0xA1, + 0x25, 0x74, 0x8A, 0x43, 0x66, 0xF0, 0xD9, 0x57, + 0xF1, 0x65, 0xE1, 0xEE, 0x04, 0x72, 0x00, 0xFA, + 0xB9, 0x5F, 0xB4, 0x37, 0xC8, 0xF4, 0xD6, 0xBA + }, + { + 0x10, 0x51, 0xD4, 0x9E, 0x48, 0x20, 0x12, 0x40, + 0xD8, 0x9E, 0xA0, 0x7A, 0x93, 0xAE, 0xEB, 0x20, + 0x4E, 0x08, 0xF1, 0x07, 0x27, 0x9C, 0x49, 0x20, + 0xFF, 0xBD, 0x86, 0x29, 0x23, 0xE2, 0x1B, 0xA4 + }, + { + 0xF9, 0x90, 0x2B, 0xC8, 0x11, 0x3D, 0x06, 0xA7, + 0x56, 0xD3, 0xFD, 0x16, 0xE5, 0x8E, 0xFC, 0x43, + 0xB7, 0x12, 0xE7, 0x93, 0xBE, 0xCA, 0xED, 0x47, + 0xD8, 0xB5, 0x2F, 0x96, 0xD0, 0xDD, 0x95, 0x6D + }, + { + 0x3D, 0x95, 0x4A, 0x5D, 0xFD, 0xF2, 0xD2, 0xAF, + 0x52, 0xCD, 0xA8, 0x29, 0x3B, 0xE7, 0x16, 0x4D, + 0xCD, 0x02, 0x09, 0x97, 0x90, 0x9B, 0x67, 0xCE, + 0x9B, 0x9F, 0xA5, 0xA3, 0x49, 0x7A, 0xF1, 0xBA + }, + { + 0x71, 0x53, 0x74, 0x52, 0x39, 0x7E, 0x8D, 0x6E, + 0x87, 0x9C, 0x35, 0x4E, 0x86, 0xDA, 0x14, 0x07, + 0xBC, 0xDD, 0x79, 0x39, 0x2D, 0x65, 0xFB, 0x9E, + 0x96, 0xD9, 0x28, 0xF1, 0xC8, 0x72, 0x14, 0x8D + }, + { + 0x46, 0x50, 0x27, 0x4B, 0x3E, 0x58, 0xC7, 0x80, + 0x8E, 0x5B, 0x48, 0xBB, 0xE2, 0xE9, 0xBD, 0x9E, + 0x18, 0x04, 0xF2, 0xF8, 0xC1, 0x4F, 0x2A, 0x0E, + 0xA4, 0xCA, 0xA2, 0xB3, 0x2A, 0xA0, 0x45, 0xCB + }, + { + 0x33, 0xD7, 0xD1, 0x98, 0x0D, 0x98, 0x58, 0x94, + 0x27, 0x36, 0xF3, 0x50, 0xB5, 0x2D, 0xC5, 0xCD, + 0x96, 0x48, 0x38, 0x0A, 0x4F, 0xEC, 0x30, 0x7E, + 0xF6, 0xE2, 0x59, 0x47, 0x57, 0x76, 0x3A, 0xFB + }, + { + 0xCD, 0x40, 0x87, 0xAF, 0x33, 0x7B, 0x5F, 0x61, + 0x07, 0xF2, 0xF7, 0xB4, 0xE1, 0x38, 0xAD, 0x64, + 0xEA, 0x0F, 0xAE, 0xC7, 0x3D, 0x9F, 0xC3, 0x42, + 0x18, 0xB8, 0x38, 0xC2, 0x4F, 0x44, 0xB8, 0x8B + }, + { + 0x10, 0x70, 0xF7, 0xC8, 0x7C, 0x4D, 0x26, 0xE4, + 0x0A, 0x68, 0x37, 0xA4, 0x9B, 0x86, 0x69, 0x96, + 0x7B, 0x79, 0x50, 0x8C, 0xF9, 0x74, 0x40, 0x6B, + 0xE1, 0x1D, 0xB0, 0x9C, 0xEF, 0xE9, 0x69, 0xFC + }, + { + 0x4F, 0xFB, 0x29, 0xEA, 0x4E, 0x51, 0x09, 0x8A, + 0x42, 0x66, 0x90, 0x13, 0xC6, 0x2F, 0xEF, 0xF1, + 0x03, 0x7D, 0x73, 0x36, 0xF0, 0x54, 0x5E, 0x76, + 0xB5, 0xD8, 0x25, 0x12, 0xB3, 0x56, 0xBF, 0x72 + }, + { + 0x65, 0x71, 0x27, 0xB2, 0xF9, 0x31, 0xAA, 0xE7, + 0x59, 0x24, 0xD6, 0x17, 0x93, 0x61, 0x68, 0x0F, + 0xC3, 0x1A, 0x34, 0xC4, 0x80, 0xA6, 0x98, 0xD5, + 0xE6, 0xB6, 0x85, 0xCF, 0x43, 0xFE, 0x3E, 0xDE + }, + { + 0x87, 0x42, 0xC5, 0x25, 0xBE, 0x96, 0xE2, 0x4C, + 0x25, 0xCC, 0x47, 0xE4, 0x72, 0x3B, 0x4B, 0xF5, + 0x54, 0x0A, 0x90, 0x9B, 0x7D, 0x6C, 0xA5, 0xA2, + 0xAE, 0x47, 0x62, 0x6D, 0x3B, 0xD6, 0x63, 0x93 + }, + { + 0x16, 0x31, 0xBA, 0xB9, 0xC1, 0xEC, 0xB5, 0xB0, + 0x86, 0xFF, 0xA6, 0x53, 0xC8, 0xC1, 0xA4, 0xE5, + 0xF9, 0xA3, 0x3A, 0x49, 0x1F, 0x8F, 0xE4, 0xDD, + 0x8E, 0xF9, 0x5E, 0x5C, 0x0D, 0x6A, 0xC8, 0xF4 + }, + { + 0xDD, 0xDC, 0x70, 0xDC, 0x97, 0xF2, 0x7B, 0x7C, + 0x88, 0x2B, 0x7F, 0xE1, 0x3D, 0x95, 0x63, 0x28, + 0x7B, 0x6C, 0x66, 0xB1, 0xB0, 0x5B, 0x0C, 0x96, + 0xCB, 0x3B, 0x68, 0x3D, 0x25, 0xC0, 0x3B, 0x42 + }, + { + 0xF1, 0x28, 0x40, 0x9C, 0x4C, 0x62, 0x24, 0xD3, + 0xCC, 0x06, 0xD2, 0x4E, 0x87, 0xFE, 0x04, 0x41, + 0xF5, 0x52, 0x36, 0x1A, 0x8D, 0x6E, 0xE2, 0xC7, + 0x44, 0x7E, 0xA3, 0xE9, 0x0E, 0x24, 0xF6, 0x12 + }, + { + 0x18, 0xCA, 0x5E, 0x39, 0xC6, 0xAB, 0xD4, 0xD6, + 0x94, 0xBC, 0x3B, 0xED, 0x4A, 0xCE, 0x30, 0xF5, + 0x28, 0x79, 0xD2, 0xDA, 0x8E, 0x2C, 0x87, 0x22, + 0xA7, 0xA4, 0x12, 0x89, 0x78, 0xF2, 0xF4, 0x75 + }, + { + 0xAD, 0xB7, 0xFB, 0xF4, 0xEF, 0x0C, 0xD3, 0x9B, + 0x37, 0x0B, 0x78, 0x43, 0x47, 0x47, 0xBB, 0xE5, + 0xD3, 0xB5, 0x95, 0xC9, 0xE4, 0x37, 0x4B, 0xEC, + 0x2D, 0x7C, 0x92, 0x3A, 0xB4, 0x8B, 0x3C, 0x9C + }, + { + 0x70, 0x8C, 0x1C, 0x16, 0x3A, 0x09, 0x1D, 0xE4, + 0x35, 0xF0, 0xBC, 0xAC, 0xC7, 0x5E, 0x24, 0x5B, + 0xB5, 0x97, 0x1E, 0x0F, 0x2D, 0x85, 0x34, 0xC3, + 0xC1, 0xC8, 0x51, 0x4F, 0xEA, 0x6C, 0xED, 0x41 + }, + { + 0x17, 0x11, 0x83, 0x33, 0xD9, 0x7B, 0x96, 0xDD, + 0x7E, 0x20, 0x90, 0xB1, 0x56, 0xE1, 0x74, 0x36, + 0x5C, 0x62, 0x64, 0xCB, 0x34, 0xEC, 0x52, 0xF8, + 0x2D, 0x71, 0x99, 0x99, 0x47, 0x00, 0x1F, 0x42 + }, + { + 0xCA, 0x10, 0x35, 0x6F, 0x74, 0x2C, 0xB1, 0x6E, + 0x07, 0x99, 0xAE, 0x58, 0xDE, 0x81, 0xF9, 0x32, + 0xC1, 0xF8, 0x95, 0xAE, 0xEF, 0x6D, 0x85, 0x17, + 0x03, 0x13, 0x50, 0x20, 0x37, 0x13, 0x9B, 0xBD + }, + { + 0x26, 0x8E, 0x9A, 0xEF, 0xE7, 0xCA, 0x8C, 0x8A, + 0xFE, 0xDB, 0x79, 0x52, 0xEF, 0xBE, 0x8E, 0x3E, + 0x60, 0xF2, 0xD1, 0xAC, 0xCE, 0x6D, 0x3D, 0x49, + 0xDB, 0xD2, 0x15, 0x1D, 0x17, 0x48, 0x1D, 0x87 + }, + { + 0x85, 0xAB, 0x4A, 0xD1, 0xD6, 0xB5, 0xEB, 0x5D, + 0xF6, 0xFF, 0x67, 0x11, 0x7A, 0xED, 0xA8, 0xD2, + 0xD9, 0x31, 0x61, 0x88, 0x4B, 0x22, 0xB5, 0x5E, + 0xC8, 0x67, 0xE9, 0xFF, 0x69, 0x1A, 0x95, 0xBA + }, + { + 0xBA, 0x81, 0x6B, 0xA5, 0x05, 0x6D, 0x9D, 0x08, + 0x89, 0x44, 0xDD, 0x64, 0xAD, 0x17, 0x7C, 0xD6, + 0x7A, 0x33, 0xEF, 0xAD, 0x17, 0xB1, 0x9A, 0xAF, + 0x8D, 0x28, 0x7F, 0xA3, 0x96, 0x17, 0xC7, 0x4B + }, + { + 0xCC, 0x1D, 0x2F, 0xDC, 0xC2, 0x32, 0x64, 0xD0, + 0x8A, 0x57, 0xBB, 0x5C, 0x53, 0x9A, 0xBF, 0x24, + 0x27, 0x95, 0xF8, 0xEC, 0x3D, 0xB7, 0x10, 0x1D, + 0x6F, 0x74, 0xB4, 0x0D, 0xCC, 0x98, 0x4D, 0x1A + }, + { + 0xE4, 0xAB, 0x4F, 0x7C, 0x57, 0x3B, 0x8F, 0x8C, + 0xCE, 0xA2, 0x6B, 0x32, 0x23, 0x5E, 0xF6, 0x1A, + 0x07, 0xA9, 0xA0, 0xEC, 0x5E, 0x23, 0x03, 0xE3, + 0x9C, 0xE4, 0xFE, 0x7A, 0x29, 0x5A, 0x6C, 0x37 + }, + { + 0xEE, 0xA3, 0x90, 0x2B, 0x8C, 0x8A, 0xFF, 0x01, + 0x4E, 0xE0, 0xFA, 0x2C, 0xBB, 0x63, 0xD3, 0x6C, + 0xF1, 0x1E, 0x9A, 0xD1, 0x4F, 0x4C, 0x6B, 0x08, + 0x40, 0xB6, 0x08, 0x00, 0xD5, 0xE0, 0x7B, 0x71 + }, + { + 0x65, 0x71, 0x54, 0xAE, 0xFB, 0x17, 0x60, 0x66, + 0x69, 0x59, 0x02, 0x89, 0x4E, 0xF9, 0xBA, 0x6D, + 0x65, 0xA0, 0x28, 0x38, 0x87, 0x20, 0x55, 0xF3, + 0x5B, 0x90, 0x55, 0xC3, 0x7C, 0x28, 0x31, 0x75 + }, + { + 0x01, 0x24, 0x7A, 0x9D, 0xA9, 0x8A, 0x15, 0xFD, + 0x6B, 0x11, 0xA2, 0x57, 0x96, 0x81, 0x85, 0x2E, + 0x64, 0x91, 0xEA, 0xB1, 0xA1, 0x6D, 0x48, 0x98, + 0x2A, 0x15, 0x0F, 0x9F, 0xD0, 0x92, 0xB3, 0x53 + }, + { + 0xA8, 0xA4, 0x37, 0x4E, 0x13, 0x84, 0x19, 0x5C, + 0x3D, 0x39, 0xBF, 0x56, 0x15, 0x8C, 0xE9, 0x93, + 0xC6, 0x46, 0x29, 0xC1, 0x8C, 0x53, 0x7C, 0x70, + 0x48, 0x4B, 0x12, 0x70, 0x90, 0xE5, 0x2D, 0x02 + }, + { + 0x86, 0xE0, 0xDE, 0x54, 0x58, 0x0B, 0x29, 0x1A, + 0x33, 0xBE, 0xA0, 0x5E, 0x86, 0x31, 0xF7, 0xB5, + 0x64, 0xBD, 0xCB, 0x32, 0x3E, 0x52, 0x34, 0xD1, + 0xBE, 0xA8, 0x1D, 0x73, 0x2F, 0x0E, 0xB0, 0x11 + }, + { + 0x32, 0x47, 0x6A, 0x14, 0xF1, 0x52, 0x4A, 0x33, + 0xF4, 0x48, 0xC6, 0x09, 0xDE, 0x9F, 0xE8, 0x12, + 0xCD, 0xB5, 0x0E, 0x15, 0x00, 0xC0, 0x72, 0x2A, + 0x13, 0xB3, 0xB1, 0x90, 0x04, 0x88, 0x6A, 0xE7 + }, + { + 0x9E, 0xE5, 0x51, 0xD4, 0x00, 0xA2, 0xAA, 0xD4, + 0x52, 0x28, 0xBD, 0x58, 0x13, 0xD7, 0xD6, 0x43, + 0x80, 0x2D, 0xAC, 0x9A, 0x41, 0xDA, 0x71, 0x34, + 0x22, 0x61, 0x4F, 0x94, 0xF2, 0xEC, 0x84, 0xC5 + }, + { + 0xF1, 0x50, 0xC7, 0x41, 0xC3, 0x60, 0x28, 0x3C, + 0xD3, 0x95, 0x8F, 0x3B, 0x42, 0x02, 0x15, 0x70, + 0xCE, 0xAB, 0x8C, 0x59, 0xBE, 0xFD, 0x5D, 0xFD, + 0x80, 0xF4, 0x39, 0x04, 0xE6, 0x73, 0x95, 0xF1 + }, + { + 0x7F, 0x49, 0x2D, 0xD4, 0x06, 0x16, 0xD2, 0x1A, + 0xB8, 0xB1, 0x70, 0x11, 0x9A, 0x69, 0xAC, 0x4D, + 0x8F, 0x59, 0x45, 0x46, 0xDB, 0x73, 0x79, 0xFF, + 0xC6, 0x71, 0x9A, 0x92, 0x91, 0xAD, 0xBF, 0xA1 + }, + { + 0xBD, 0xF9, 0xA2, 0x92, 0xD9, 0x30, 0xC3, 0xE0, + 0x35, 0x10, 0x4B, 0x96, 0x0B, 0x42, 0x72, 0x82, + 0x4E, 0xA2, 0xD2, 0xDA, 0xBF, 0xD0, 0x48, 0x91, + 0xF1, 0xD5, 0x18, 0xA9, 0x6C, 0x09, 0xF6, 0x1A + }, + { + 0x1F, 0x9D, 0xB3, 0xA3, 0xE2, 0x00, 0x4F, 0x3F, + 0xD0, 0x22, 0x2C, 0xAB, 0xBF, 0x81, 0x04, 0x06, + 0x78, 0x42, 0xA0, 0x84, 0x7C, 0xFF, 0xD1, 0xF2, + 0xA3, 0x43, 0xF5, 0x56, 0xC7, 0xA2, 0x8E, 0x92 + }, + { + 0x8F, 0x51, 0x94, 0xD4, 0xF2, 0x4D, 0x17, 0xFA, + 0x51, 0xA9, 0xCB, 0x6B, 0x1A, 0xF0, 0x38, 0xF6, + 0x66, 0x76, 0x2D, 0x73, 0xAB, 0x39, 0x0B, 0x0B, + 0xF7, 0x37, 0xD8, 0xB0, 0x16, 0x85, 0x7F, 0xA5 + }, + { + 0x40, 0x92, 0x00, 0x94, 0xB0, 0xC5, 0x4D, 0xF4, + 0x8B, 0xEA, 0x56, 0xA9, 0xA3, 0xE8, 0x1A, 0x72, + 0x7A, 0xA5, 0x10, 0xF6, 0x9D, 0x78, 0x6C, 0xBC, + 0xE5, 0x1F, 0xEC, 0xF3, 0xB3, 0xDB, 0xEE, 0xD7 + }, + { + 0x4B, 0x14, 0x72, 0x8F, 0x50, 0x4A, 0x44, 0x50, + 0xC4, 0x78, 0x66, 0xFA, 0x17, 0x9B, 0x01, 0x7D, + 0x97, 0x9C, 0x40, 0x14, 0xC8, 0x15, 0x76, 0xFE, + 0x2D, 0xCD, 0x83, 0xAA, 0x06, 0x38, 0x61, 0x70 + }, + { + 0xE4, 0xFC, 0x5E, 0x90, 0xD2, 0x61, 0xBB, 0x99, + 0xC0, 0xB4, 0xE6, 0x2F, 0x8B, 0x43, 0x99, 0xEB, + 0x88, 0xD7, 0x60, 0x17, 0xDC, 0x84, 0x60, 0x97, + 0xCB, 0x23, 0x9C, 0xFC, 0xAD, 0xDF, 0x28, 0x2B + }, + { + 0x9C, 0xB9, 0x38, 0x32, 0x2F, 0x36, 0x26, 0x83, + 0xD6, 0x6B, 0x8D, 0x1E, 0xAE, 0xAA, 0xC4, 0xF2, + 0x0F, 0xA5, 0x2D, 0x79, 0x62, 0x16, 0x6C, 0x98, + 0xBD, 0xCA, 0xB0, 0x25, 0x6F, 0x75, 0x95, 0x49 + }, + { + 0x7F, 0xB2, 0x39, 0xF6, 0xAF, 0x27, 0x4B, 0x29, + 0xD3, 0xC7, 0x44, 0x10, 0x16, 0x69, 0xAE, 0x13, + 0x56, 0x39, 0x75, 0xED, 0x03, 0xFC, 0x5D, 0x81, + 0x1F, 0x8F, 0x1D, 0x81, 0x31, 0x8E, 0x0F, 0x29 + }, + { + 0x64, 0xCD, 0x4F, 0x0A, 0x67, 0xF6, 0x64, 0xD9, + 0x6D, 0x41, 0x2D, 0x47, 0x94, 0x5F, 0x62, 0xCF, + 0x91, 0xFE, 0x81, 0x67, 0x0B, 0xE2, 0xE6, 0x4E, + 0x21, 0xDA, 0xEF, 0x1D, 0x06, 0xA7, 0xC8, 0xCC + }, + { + 0x4F, 0xD1, 0xFC, 0xFE, 0x59, 0x0E, 0xA9, 0x46, + 0xE1, 0xFA, 0x9C, 0xFC, 0x5A, 0x5C, 0x62, 0xCE, + 0x62, 0xD2, 0xC8, 0xF9, 0x50, 0x25, 0xDE, 0xC1, + 0xA2, 0x54, 0x0E, 0xFE, 0xAE, 0x5B, 0x38, 0x66 + }, + { + 0x3A, 0xF5, 0xBB, 0x1B, 0xC1, 0x31, 0x8D, 0x66, + 0x80, 0x1C, 0x21, 0x36, 0x6D, 0xB3, 0x2D, 0x0B, + 0x6C, 0xD0, 0xC3, 0xCD, 0x21, 0x89, 0x19, 0x71, + 0x87, 0xBA, 0xC6, 0xAF, 0x65, 0x0B, 0xD2, 0xE4 + }, + { + 0x18, 0xD6, 0xB0, 0xAD, 0x4B, 0xAF, 0xA1, 0xCC, + 0x51, 0x3B, 0x5B, 0x93, 0xBC, 0x1D, 0x6E, 0xC8, + 0x21, 0x44, 0x9A, 0xA4, 0xEB, 0xA2, 0x3F, 0x5E, + 0x10, 0xAB, 0x50, 0x92, 0x10, 0x82, 0x04, 0x55 + }, + { + 0xC3, 0x5C, 0x09, 0xF5, 0x29, 0xFE, 0x7A, 0x1E, + 0x54, 0x11, 0xFA, 0x3F, 0x61, 0x4B, 0xE5, 0x27, + 0x68, 0x01, 0x79, 0xB7, 0x4B, 0xA4, 0x5F, 0x73, + 0x7F, 0x3E, 0xB0, 0xC4, 0xA7, 0x7A, 0x60, 0xDB + }, + { + 0x36, 0xBC, 0x9C, 0x12, 0xE9, 0x0F, 0xA7, 0x35, + 0x31, 0xF7, 0x8E, 0x03, 0xEA, 0x95, 0x80, 0x05, + 0x4A, 0x6E, 0xA4, 0x23, 0xE7, 0xD8, 0xFF, 0xB6, + 0x4E, 0x5D, 0x1A, 0x4F, 0xDD, 0x61, 0x3C, 0x04 + }, + { + 0x26, 0xFF, 0x81, 0x0A, 0x4D, 0xED, 0x9A, 0x57, + 0xB6, 0x38, 0xFE, 0x9E, 0xBE, 0xF6, 0xDB, 0xC2, + 0xD0, 0xCB, 0x53, 0xDB, 0xB4, 0x5F, 0x3C, 0x13, + 0x49, 0x94, 0xFD, 0x3F, 0x25, 0xC4, 0x53, 0x18 + }, + { + 0x2A, 0xE1, 0x56, 0x67, 0xFA, 0x4D, 0x82, 0x41, + 0xA8, 0xAC, 0xC9, 0x67, 0xDF, 0xCC, 0x7F, 0x02, + 0xB8, 0x1F, 0xE1, 0x58, 0x96, 0x6D, 0xB7, 0x57, + 0x92, 0x62, 0x91, 0xDA, 0x7D, 0x31, 0x9D, 0x50 + }, + { + 0x59, 0x13, 0x99, 0xF3, 0x55, 0x3F, 0x22, 0x10, + 0x52, 0x94, 0x68, 0xCE, 0x19, 0x48, 0x00, 0xC7, + 0xB8, 0xA9, 0x1F, 0x79, 0xE1, 0x65, 0x06, 0x53, + 0xF0, 0xDE, 0xF0, 0x82, 0xE3, 0xE0, 0x11, 0xFC + }, + { + 0x27, 0xC9, 0x4F, 0xC1, 0x4A, 0x6B, 0x2F, 0xEB, + 0x6C, 0x63, 0xAD, 0xDD, 0x3F, 0xE7, 0xBA, 0x87, + 0xA9, 0xAE, 0x80, 0x04, 0x96, 0x8F, 0x08, 0x9C, + 0xC0, 0x60, 0x20, 0x81, 0x3E, 0x4F, 0xEF, 0xF0 + }, + { + 0xF8, 0xD2, 0x69, 0x82, 0xD5, 0xC9, 0x76, 0x75, + 0x69, 0x9C, 0xE9, 0x14, 0x86, 0x61, 0x50, 0x9A, + 0xA3, 0xAB, 0x8D, 0xF0, 0x14, 0xF9, 0xBB, 0x58, + 0x2D, 0x2C, 0xEA, 0xB4, 0x16, 0x90, 0x28, 0x13 + }, + { + 0x73, 0x5B, 0x4B, 0x2E, 0x73, 0x2F, 0xB0, 0xB4, + 0xBD, 0xC8, 0x6C, 0x11, 0x86, 0xD1, 0xE5, 0x7C, + 0x58, 0x8B, 0x11, 0xF8, 0x10, 0x73, 0x09, 0x41, + 0x1A, 0xCE, 0x41, 0xE1, 0x11, 0xBF, 0xD8, 0xD3 + }, + { + 0xBF, 0xE1, 0xA8, 0xFD, 0xA3, 0x35, 0x60, 0x44, + 0xB8, 0x36, 0xE8, 0x8C, 0x1F, 0xA7, 0x41, 0x82, + 0x71, 0x0C, 0x13, 0xB7, 0x62, 0xFD, 0xCE, 0x59, + 0x91, 0x85, 0xF7, 0x39, 0x37, 0xEC, 0x60, 0xD5 + }, + { + 0xE9, 0xC7, 0x2E, 0xD4, 0x34, 0x5A, 0xA5, 0x9B, + 0x98, 0x15, 0x57, 0xD5, 0xEA, 0x9A, 0x23, 0x78, + 0xDB, 0x18, 0x32, 0xD3, 0xDC, 0xFD, 0x6D, 0x54, + 0x4F, 0x6A, 0x38, 0x68, 0x51, 0xF4, 0xA8, 0x90 + }, + { + 0x38, 0x06, 0xD9, 0x3A, 0x47, 0xEE, 0x63, 0x6F, + 0x67, 0xAE, 0x26, 0x53, 0x64, 0xBD, 0xE5, 0x05, + 0xCC, 0x5C, 0xF2, 0xAE, 0x38, 0x9D, 0x47, 0xC8, + 0x49, 0x26, 0x6D, 0x44, 0xDD, 0xBC, 0x7A, 0xA5 + }, + { + 0x19, 0xE3, 0xB1, 0xB4, 0x64, 0xE1, 0xF1, 0x48, + 0x92, 0x0E, 0x42, 0xE8, 0x9D, 0xE5, 0xB8, 0xC8, + 0x91, 0x31, 0xD1, 0x2F, 0xA3, 0x3D, 0x17, 0x45, + 0xCF, 0x19, 0x61, 0xA7, 0xE2, 0x7E, 0x34, 0xAF + }, + { + 0xED, 0xEE, 0x88, 0x4B, 0xCA, 0x82, 0x2C, 0x13, + 0x90, 0xD1, 0x94, 0x96, 0xBB, 0x40, 0x01, 0xEF, + 0x4B, 0x56, 0x3A, 0xD0, 0xEE, 0x35, 0x28, 0xF7, + 0x9C, 0x5E, 0x9B, 0x08, 0xD2, 0x4F, 0x01, 0xE4 + }, + { + 0x85, 0xE0, 0x5B, 0xF4, 0xDB, 0xA0, 0x69, 0x4F, + 0x3E, 0xFF, 0xF7, 0x4B, 0x8D, 0x36, 0x10, 0x16, + 0x22, 0x09, 0x26, 0x34, 0xBE, 0xAB, 0x6E, 0x62, + 0xA0, 0x2A, 0x30, 0x69, 0x6A, 0x98, 0x51, 0xDE + }, + { + 0xE7, 0x45, 0x28, 0x1B, 0x5E, 0x8A, 0xC2, 0xB4, + 0x02, 0x97, 0xB3, 0xFF, 0x8F, 0x06, 0x0F, 0x70, + 0x0F, 0x68, 0xD5, 0xD7, 0x68, 0x4D, 0xFB, 0xC6, + 0xD8, 0xC2, 0x1B, 0xF0, 0x5C, 0xFE, 0x79, 0xF9 + }, + { + 0x42, 0x26, 0x67, 0x23, 0x6D, 0x44, 0xFD, 0xBD, + 0xAD, 0x7F, 0xD6, 0x96, 0x2A, 0x25, 0xD2, 0x9D, + 0x95, 0xC3, 0xD6, 0x8E, 0xA4, 0xFD, 0x93, 0xF3, + 0xA5, 0x7F, 0x9F, 0x6A, 0x45, 0xAB, 0x27, 0xF1 + }, + { + 0x19, 0x1F, 0xB1, 0x04, 0x58, 0x57, 0xC7, 0xA5, + 0x8D, 0xCC, 0x57, 0xFB, 0x74, 0x03, 0x89, 0x6D, + 0xCB, 0xA7, 0x4C, 0x5F, 0x28, 0xB9, 0xF3, 0xA7, + 0x7D, 0x2F, 0x2D, 0x4C, 0x47, 0xE4, 0x64, 0x08 + }, + { + 0x28, 0xC6, 0x96, 0xB3, 0x8E, 0xB9, 0xF4, 0xDB, + 0x53, 0x25, 0x85, 0x4C, 0x1A, 0x99, 0x17, 0x83, + 0xF5, 0x11, 0x9E, 0x81, 0x47, 0x37, 0xDE, 0x6F, + 0xCF, 0xB1, 0x9D, 0xFF, 0x4E, 0x1C, 0x30, 0x18 + }, + { + 0x71, 0x77, 0xB4, 0x3F, 0x7F, 0x6D, 0x07, 0x63, + 0x10, 0x6A, 0xAE, 0x83, 0x26, 0xF4, 0xFC, 0xE5, + 0x24, 0xA2, 0x27, 0xF3, 0x3A, 0xCE, 0xD9, 0x66, + 0xFE, 0xE9, 0x31, 0xC2, 0xBC, 0x29, 0x88, 0x7E + }, + { + 0x5E, 0x08, 0x66, 0xB6, 0x08, 0x47, 0x5C, 0xA8, + 0x08, 0xC1, 0x3B, 0x3E, 0x88, 0xAF, 0x8B, 0x23, + 0xE8, 0x54, 0x26, 0x18, 0xEC, 0xB1, 0xDC, 0x6A, + 0x22, 0xA2, 0x22, 0x58, 0xD9, 0x58, 0xF4, 0x38 + }, + { + 0x1D, 0xA4, 0x38, 0x51, 0x59, 0xCF, 0x40, 0x1E, + 0x49, 0x1A, 0xE8, 0xE6, 0xF5, 0xDF, 0x1E, 0xB4, + 0xEE, 0x9E, 0x8C, 0x98, 0x46, 0xEA, 0xA1, 0x3E, + 0x0B, 0x93, 0xEE, 0x10, 0xC9, 0xFA, 0x77, 0x9B + }, + { + 0x32, 0x37, 0xCD, 0xF6, 0x20, 0xC4, 0x88, 0x65, + 0xF9, 0x7F, 0x0A, 0x97, 0xF3, 0x4C, 0x86, 0xD5, + 0x75, 0xBE, 0xA4, 0x7C, 0x4A, 0xEE, 0x5F, 0x8A, + 0x6A, 0x2D, 0x65, 0xC3, 0x22, 0xB1, 0xEB, 0x7B + }, + { + 0x11, 0x01, 0x23, 0x2A, 0x8F, 0x43, 0x6F, 0x0B, + 0x49, 0x10, 0x47, 0x8A, 0x88, 0xF5, 0x39, 0xB6, + 0x84, 0xEF, 0x4B, 0x22, 0x5A, 0x5A, 0x53, 0xB0, + 0x3F, 0xC5, 0xAB, 0x0F, 0xED, 0x7E, 0xC7, 0xAD + }, + { + 0x36, 0xC1, 0x5C, 0xAB, 0x98, 0x1E, 0xD2, 0x93, + 0x21, 0x5E, 0xD8, 0xB8, 0xB0, 0xA0, 0x48, 0xC0, + 0xDF, 0x40, 0x7A, 0x01, 0x02, 0x8A, 0x58, 0x79, + 0xF9, 0xE5, 0xCF, 0x53, 0xAA, 0xA0, 0x54, 0xC1 + }, + { + 0x1B, 0x5C, 0xB0, 0xD8, 0xF5, 0x6F, 0xAE, 0xF8, + 0x47, 0xB2, 0x87, 0x03, 0xF3, 0x66, 0xA1, 0x1D, + 0x11, 0x1A, 0x9D, 0xA1, 0x8F, 0x1C, 0x95, 0x30, + 0x13, 0x7E, 0x6F, 0x33, 0x7C, 0x10, 0xAD, 0xE2 + }, + { + 0xE8, 0x28, 0x1F, 0x1E, 0xB2, 0xDF, 0x62, 0x36, + 0x77, 0x05, 0x11, 0x33, 0xF0, 0xF7, 0x9B, 0x45, + 0x53, 0x67, 0xED, 0x5B, 0x04, 0x0E, 0x61, 0xBA, + 0x57, 0x1E, 0x53, 0xA7, 0x76, 0x12, 0x5C, 0x9D + }, + { + 0x38, 0x08, 0x43, 0x39, 0xB3, 0x5E, 0x81, 0x46, + 0x33, 0x20, 0xC0, 0x25, 0x41, 0x0A, 0x37, 0x01, + 0x66, 0x85, 0x49, 0x95, 0xC4, 0xD7, 0x11, 0xCD, + 0x42, 0x53, 0xB7, 0x6F, 0x8A, 0xCF, 0x56, 0x6C + }, + { + 0x88, 0x04, 0xEF, 0x51, 0xBE, 0xA4, 0x11, 0x96, + 0x45, 0x57, 0x92, 0xC2, 0xAA, 0x78, 0x85, 0xB9, + 0x46, 0x39, 0x4A, 0xCA, 0x07, 0xBC, 0xD0, 0xC9, + 0x7C, 0x89, 0xA8, 0x0C, 0x56, 0x17, 0xE4, 0x73 + }, + { + 0x26, 0x41, 0x1C, 0x99, 0x36, 0xFE, 0x3E, 0x4E, + 0x02, 0xA2, 0x99, 0xDB, 0xFA, 0xA3, 0x64, 0xEE, + 0x57, 0x22, 0xEA, 0x86, 0xAA, 0x6D, 0x39, 0x58, + 0xEA, 0x5D, 0x0B, 0x64, 0x97, 0x3F, 0x53, 0x0C + }, + { + 0x24, 0x11, 0xE7, 0x30, 0x50, 0xEF, 0x25, 0xA6, + 0x4F, 0xBA, 0x4D, 0xC7, 0x9F, 0xDA, 0x25, 0xC5, + 0x68, 0x52, 0x5B, 0x60, 0xEB, 0x88, 0xB8, 0x43, + 0x36, 0x18, 0x69, 0xDC, 0x87, 0x0C, 0x48, 0x7F + }, + { + 0x35, 0xF3, 0x62, 0xAC, 0x5B, 0x00, 0xF6, 0x3D, + 0x86, 0x0B, 0x5F, 0x3F, 0x26, 0x74, 0x56, 0x03, + 0x9A, 0x9A, 0x56, 0x49, 0xD7, 0x3A, 0xA4, 0x45, + 0xF1, 0x77, 0x0B, 0x5B, 0x95, 0x3C, 0xDC, 0x6C + }, + { + 0x86, 0xE6, 0x5A, 0x0E, 0x07, 0x80, 0xB0, 0x49, + 0xDD, 0x2F, 0x16, 0x4D, 0xAD, 0x93, 0xF1, 0x65, + 0x2B, 0x4D, 0x6F, 0xB3, 0x50, 0x5A, 0x00, 0xB5, + 0x97, 0x8E, 0x83, 0xA5, 0xA9, 0xAE, 0xF7, 0xFD + }, + { + 0x7C, 0xFF, 0xCE, 0x41, 0x5B, 0x2E, 0xA0, 0xFF, + 0x3C, 0xB9, 0x4C, 0x95, 0x46, 0x48, 0x71, 0x34, + 0x63, 0xA3, 0xA3, 0x79, 0x2D, 0xFF, 0xC8, 0x99, + 0xF9, 0x5F, 0x96, 0x93, 0x9B, 0x1E, 0xF5, 0xFE + }, + { + 0xF9, 0xD4, 0xFF, 0x85, 0x66, 0x32, 0x2E, 0x23, + 0xF2, 0x4D, 0xB0, 0xAF, 0xF5, 0xA3, 0x5E, 0xFC, + 0xCD, 0x5E, 0x54, 0x12, 0x82, 0xCA, 0x99, 0x8A, + 0xCD, 0x23, 0xF3, 0x41, 0xA3, 0x0B, 0xBE, 0xB5 + }, + { + 0x29, 0xE5, 0x72, 0xEE, 0x34, 0x2E, 0xB0, 0x41, + 0x94, 0x16, 0xF5, 0x13, 0x8E, 0x70, 0x07, 0x83, + 0xB8, 0x35, 0x29, 0xEB, 0x48, 0x80, 0x82, 0x25, + 0xF0, 0xA3, 0xCF, 0x3E, 0x97, 0x5B, 0x20, 0xB5 + }, + { + 0x3A, 0xD7, 0x70, 0x22, 0x0B, 0x6A, 0x18, 0xBD, + 0x9E, 0x3D, 0x2C, 0xC6, 0x49, 0xE9, 0x14, 0xDC, + 0x94, 0xF5, 0x3D, 0xE1, 0x99, 0x3C, 0x41, 0xBC, + 0xDF, 0x54, 0xB3, 0xA8, 0xF6, 0xCB, 0xDB, 0x97 + }, + { + 0xFE, 0xB9, 0xEA, 0x6B, 0x1E, 0xD7, 0xD6, 0x53, + 0x96, 0xD2, 0x8C, 0x6F, 0xE7, 0xF7, 0xE7, 0xCC, + 0xEE, 0x7D, 0x6F, 0xF6, 0x45, 0x71, 0xA8, 0xD4, + 0x2D, 0x01, 0xAE, 0x8E, 0xBA, 0xAE, 0x21, 0x2D + }, + { + 0xAD, 0xC3, 0xC6, 0x2D, 0x2F, 0xB4, 0x69, 0xEB, + 0x75, 0xB1, 0xC1, 0x23, 0x8D, 0x6B, 0x73, 0x4E, + 0x4B, 0xD5, 0x73, 0xB9, 0xAE, 0x98, 0x7C, 0x0C, + 0x4F, 0xD2, 0x8E, 0xDD, 0x86, 0x6E, 0x0B, 0xD0 + }, + { + 0x19, 0x62, 0x7B, 0x50, 0x11, 0x7F, 0xA0, 0x5C, + 0xDC, 0x9A, 0xAE, 0xA4, 0xAA, 0x33, 0xC4, 0xC1, + 0xE5, 0x03, 0xC6, 0x03, 0xFC, 0x0B, 0xBD, 0xAC, + 0xD6, 0x1A, 0x48, 0x62, 0x8E, 0xEF, 0xD6, 0xCF + }, + { + 0xBA, 0x4D, 0x8D, 0xE5, 0x2D, 0x4C, 0x1B, 0xC2, + 0xA3, 0xCC, 0x7C, 0x3C, 0x71, 0x8E, 0xE3, 0x9F, + 0xE1, 0x63, 0x6D, 0x12, 0xF7, 0x89, 0x39, 0x2B, + 0xEC, 0xD0, 0x0D, 0x58, 0xAD, 0x0B, 0xFF, 0x2C + }, + { + 0xF2, 0xB5, 0x86, 0x05, 0x38, 0xC6, 0xC5, 0x6C, + 0x4D, 0xC4, 0xCF, 0xBE, 0x21, 0x6C, 0xA3, 0x64, + 0x8E, 0x5B, 0x47, 0x2D, 0x2F, 0xEB, 0x9E, 0x1A, + 0x1C, 0x20, 0xDC, 0x1A, 0x22, 0xAF, 0xB4, 0xB5 + }, + { + 0xE8, 0xA0, 0xB2, 0xF2, 0x3A, 0xD9, 0x17, 0xF2, + 0xB6, 0x65, 0x22, 0xD9, 0xC4, 0x73, 0x08, 0x21, + 0x42, 0x31, 0x89, 0xAF, 0x84, 0xAC, 0x79, 0xF1, + 0x1B, 0x11, 0x18, 0x79, 0x8E, 0xCC, 0x68, 0x14 + }, + { + 0xE8, 0x3E, 0xCB, 0x44, 0xDB, 0xF6, 0x83, 0xE9, + 0x73, 0xA7, 0xE6, 0x89, 0x22, 0xEA, 0xA3, 0x80, + 0x46, 0x98, 0x69, 0xD7, 0x77, 0x4C, 0x24, 0x4F, + 0x27, 0x44, 0x7C, 0xB4, 0xE8, 0xE5, 0x41, 0x6B + }, + { + 0xC4, 0x23, 0x5E, 0x92, 0x16, 0x27, 0x19, 0x67, + 0x1C, 0xFA, 0x05, 0x9F, 0x3C, 0x8C, 0xB9, 0x3D, + 0xAD, 0xD9, 0xDD, 0x0A, 0xA9, 0x63, 0xDC, 0xA2, + 0x65, 0xE8, 0xE3, 0xF7, 0x2B, 0x06, 0x62, 0xD9 + }, + { + 0x1B, 0x45, 0xB3, 0x70, 0xAC, 0x54, 0xEA, 0x48, + 0x09, 0x09, 0x72, 0x29, 0x70, 0xBF, 0xB9, 0x37, + 0x96, 0xBF, 0x1A, 0xBB, 0x50, 0xA3, 0x78, 0x94, + 0x7C, 0xBA, 0x47, 0x4D, 0xEF, 0x01, 0x1A, 0xC9 + }, + { + 0x3E, 0x4D, 0xB9, 0x00, 0x61, 0x58, 0xAE, 0xBA, + 0x6A, 0xB2, 0x91, 0xE2, 0xF0, 0x0E, 0x55, 0xC6, + 0xDD, 0x39, 0x4C, 0xF7, 0xD0, 0x08, 0xC1, 0x8E, + 0x8D, 0x49, 0x06, 0xF0, 0x38, 0xC0, 0x0F, 0xC6 + }, + { + 0x00, 0xD9, 0xDB, 0x77, 0xF4, 0x9B, 0xE7, 0x30, + 0x9F, 0x50, 0x1A, 0xFD, 0x3D, 0x15, 0x9D, 0x94, + 0x82, 0x97, 0x4B, 0x63, 0xBA, 0x10, 0xF3, 0xEE, + 0x13, 0x17, 0xCF, 0x03, 0xB8, 0xA2, 0x54, 0x3F + }, + { + 0xC0, 0x25, 0xF0, 0x96, 0x85, 0x6C, 0xEE, 0xB1, + 0x15, 0xF8, 0x7C, 0xA9, 0x5B, 0xDB, 0x21, 0xAE, + 0x63, 0xC8, 0x35, 0x13, 0x83, 0x6E, 0xED, 0xB6, + 0xB2, 0x92, 0x37, 0x96, 0xE0, 0xDD, 0xAC, 0x30 + }, + { + 0x70, 0x6B, 0x85, 0x9E, 0xE3, 0xE5, 0xA1, 0x2F, + 0x4F, 0x29, 0xD1, 0x4F, 0xF9, 0x3D, 0x57, 0xA7, + 0x75, 0x4C, 0x58, 0x19, 0x06, 0x93, 0x16, 0xDC, + 0x42, 0xCD, 0x8E, 0x92, 0x30, 0x41, 0xF7, 0x95 + }, + { + 0xDA, 0x9C, 0xBB, 0x8A, 0xF7, 0x08, 0x9B, 0xAF, + 0xE7, 0x23, 0xC9, 0x96, 0x41, 0xBC, 0x03, 0x2B, + 0x52, 0xC2, 0x30, 0x7E, 0x45, 0x4A, 0x4C, 0x9B, + 0x25, 0xB7, 0x76, 0x3E, 0xCA, 0x13, 0x54, 0x6C + }, + { + 0xD5, 0xEF, 0x56, 0x40, 0xB7, 0x31, 0xD9, 0x1B, + 0x20, 0x42, 0xD5, 0xEE, 0xF7, 0x9C, 0x30, 0x9C, + 0xA1, 0xCE, 0x4F, 0x59, 0xB0, 0xD9, 0x80, 0x99, + 0xD8, 0x54, 0x02, 0x6B, 0x22, 0xAA, 0x56, 0xAB + }, + { + 0xD1, 0x7E, 0xE8, 0x53, 0x99, 0x07, 0x38, 0xE7, + 0x11, 0xE4, 0x0F, 0xD0, 0x3D, 0x24, 0x16, 0xA7, + 0x58, 0xBC, 0x2E, 0x39, 0xD0, 0xFF, 0x97, 0x6C, + 0xAF, 0x8A, 0xE6, 0x33, 0x41, 0x95, 0x2F, 0x8D + }, + { + 0x0A, 0x3F, 0x2F, 0xFC, 0x5B, 0x1D, 0x14, 0x9D, + 0x2E, 0xFE, 0x94, 0xEE, 0xF9, 0x40, 0xE3, 0x79, + 0x7E, 0xD8, 0x5B, 0x42, 0x31, 0x63, 0x9E, 0x24, + 0x0F, 0xDB, 0xB8, 0xB8, 0xC6, 0xD5, 0xC1, 0xA5 + }, + { + 0xF1, 0x25, 0x76, 0x2C, 0xEA, 0x6A, 0x09, 0x59, + 0xAB, 0x11, 0x22, 0xEE, 0xFE, 0xBE, 0x7E, 0x36, + 0xA1, 0xCC, 0x49, 0xFD, 0x17, 0x9C, 0xF2, 0x67, + 0x09, 0xDA, 0xBD, 0x3A, 0xE2, 0x92, 0x53, 0x85 + }, + { + 0x4E, 0xA1, 0xBC, 0x97, 0xA3, 0xAF, 0x20, 0xAD, + 0x19, 0x42, 0x1C, 0xF4, 0x93, 0x8D, 0x42, 0x88, + 0xB5, 0x1D, 0xC6, 0x39, 0x33, 0xC2, 0x6C, 0x3E, + 0xA3, 0x1F, 0x31, 0x99, 0xC7, 0x11, 0x89, 0x37 + }, + { + 0xF9, 0x8C, 0x38, 0x20, 0x62, 0xC6, 0xBB, 0x36, + 0xB3, 0x5C, 0x4E, 0x3E, 0x04, 0x2C, 0xFA, 0x13, + 0x67, 0xA2, 0xC4, 0x18, 0xE1, 0x0C, 0x29, 0x2B, + 0xCE, 0x67, 0xF3, 0x2D, 0xA3, 0x59, 0x53, 0x3D + }, + { + 0x3A, 0xBB, 0xC0, 0x5D, 0x6F, 0x49, 0x5A, 0xAB, + 0xA0, 0x36, 0xC7, 0x27, 0x1A, 0x67, 0xAD, 0x9A, + 0x28, 0xB1, 0xAE, 0x43, 0x46, 0x4C, 0x95, 0x0B, + 0x8C, 0xCE, 0x36, 0x54, 0xEB, 0xA2, 0xA8, 0x0A + }, + { + 0x41, 0xAF, 0xB4, 0xAA, 0x1A, 0x9D, 0xF8, 0xD5, + 0x33, 0xA2, 0x61, 0xE6, 0xF7, 0x8A, 0x0A, 0x0A, + 0x37, 0xF8, 0xA1, 0xE6, 0x58, 0xC1, 0xBB, 0x64, + 0x9E, 0x57, 0x92, 0xD3, 0x33, 0x79, 0xF8, 0xDC + }, + { + 0x98, 0xDE, 0x9E, 0xCA, 0xB6, 0x7C, 0xE2, 0x59, + 0x91, 0x37, 0xDF, 0x3A, 0xDB, 0x8B, 0xD0, 0x99, + 0x16, 0x9E, 0x4B, 0x64, 0x72, 0xB1, 0x56, 0x62, + 0x2F, 0x9A, 0x4F, 0x03, 0x73, 0x38, 0x4F, 0xA7 + }, + { + 0xDA, 0x98, 0xE6, 0xBA, 0x42, 0xB8, 0x49, 0x0D, + 0x30, 0x0F, 0xEB, 0xC2, 0xE0, 0x56, 0xA4, 0xE4, + 0xEE, 0xDB, 0x8C, 0x06, 0x1D, 0xB4, 0x1F, 0xED, + 0xDE, 0xC5, 0xDF, 0x72, 0xB4, 0xB6, 0xAF, 0x4E + }, + { + 0xFF, 0xDA, 0x73, 0x88, 0x57, 0x4D, 0x72, 0x4C, + 0x2D, 0x6F, 0x9E, 0xDE, 0x98, 0x66, 0x99, 0x5D, + 0x76, 0x60, 0xB6, 0x8D, 0xD0, 0x60, 0xF7, 0x96, + 0x2F, 0x26, 0xDB, 0x61, 0x83, 0x9B, 0xA1, 0x06 + }, + { + 0x6B, 0x27, 0x88, 0x91, 0x94, 0x75, 0x39, 0x10, + 0xE2, 0xE2, 0x0B, 0x0D, 0xF9, 0xAC, 0xF2, 0x15, + 0xA6, 0x1C, 0x72, 0x86, 0xDC, 0xC5, 0xE8, 0x75, + 0xCB, 0x70, 0x0D, 0x18, 0x74, 0x49, 0xDA, 0xAC + }, + { + 0xBF, 0x00, 0x94, 0xB2, 0xBD, 0xE4, 0x72, 0x1B, + 0x0D, 0xB1, 0x5E, 0xD3, 0x5C, 0xD4, 0x8C, 0x0F, + 0xC3, 0x0C, 0xBA, 0xC7, 0x9A, 0x7D, 0x61, 0x72, + 0x10, 0xEF, 0xCE, 0x09, 0x74, 0x81, 0xBE, 0x18 + }, + { + 0x17, 0xCC, 0x85, 0xF0, 0x2F, 0x9A, 0xBD, 0x0D, + 0x7E, 0xB6, 0x50, 0x29, 0xEA, 0x9A, 0x8C, 0xF0, + 0x07, 0x5B, 0x13, 0x5C, 0x90, 0x5B, 0x1B, 0x68, + 0x1E, 0x0A, 0x9F, 0x35, 0x3D, 0xCE, 0x83, 0x16 + }, + { + 0xB0, 0x7B, 0x90, 0xD1, 0xD5, 0xCC, 0x32, 0xAE, + 0x37, 0x1B, 0x5E, 0x88, 0x74, 0x57, 0x3A, 0xA5, + 0x0C, 0xF6, 0xAC, 0x13, 0x91, 0x11, 0x67, 0x8D, + 0x5B, 0xEF, 0xBC, 0x15, 0xB9, 0x52, 0xB4, 0xBE + }, + { + 0xDE, 0x0D, 0xAC, 0x65, 0x02, 0xB4, 0xB9, 0x98, + 0x20, 0xB6, 0xE1, 0xE3, 0x9A, 0xC4, 0x58, 0x86, + 0x36, 0x7A, 0x93, 0xBB, 0x32, 0x94, 0xC4, 0x20, + 0xDC, 0x99, 0x85, 0x0F, 0xD5, 0x71, 0xA5, 0x03 + }, + { + 0x72, 0xC4, 0x60, 0x59, 0x1B, 0x09, 0x78, 0xC4, + 0x2C, 0x8E, 0x63, 0xE6, 0x89, 0x71, 0xE8, 0x1E, + 0xFD, 0x3E, 0xD3, 0xF6, 0xAF, 0xF9, 0x82, 0x47, + 0xCF, 0xC8, 0x06, 0x1B, 0x97, 0x7D, 0x60, 0x15 + }, + { + 0xFF, 0x4F, 0x68, 0x0D, 0x56, 0x99, 0xDD, 0x75, + 0x74, 0x51, 0xE0, 0xA5, 0xF9, 0x2D, 0xE1, 0xCA, + 0x53, 0x3F, 0x3B, 0x74, 0x56, 0x11, 0x86, 0x3C, + 0x10, 0x64, 0x8D, 0x92, 0x82, 0xBC, 0xFD, 0x90 + }, + { + 0xC4, 0x36, 0x62, 0x7B, 0xDF, 0xB1, 0x01, 0xD0, + 0x2B, 0x6C, 0x59, 0xAB, 0xDE, 0x2E, 0xC9, 0xFC, + 0x18, 0x68, 0x05, 0x32, 0xAF, 0x12, 0x77, 0x71, + 0x9D, 0x8D, 0x9C, 0xBB, 0xEF, 0x68, 0x6D, 0x14 + }, + { + 0x81, 0xE5, 0x6F, 0xB2, 0x6B, 0x16, 0xBD, 0xB3, + 0x3B, 0x46, 0xF6, 0xA9, 0xE4, 0x9C, 0x17, 0x97, + 0x89, 0xE5, 0x9F, 0xF7, 0xA6, 0xA1, 0x05, 0x6D, + 0x57, 0x46, 0xAE, 0x09, 0x9B, 0x09, 0x5B, 0xD0 + }, + { + 0xAE, 0x66, 0xC4, 0xEF, 0xE2, 0xD0, 0x3C, 0xA8, + 0xA4, 0x0F, 0xD6, 0xAC, 0xE5, 0xF9, 0x2C, 0xA5, + 0x4B, 0xC5, 0xB7, 0x85, 0x54, 0x48, 0x13, 0x65, + 0x04, 0xA0, 0x3F, 0xA6, 0xC1, 0xED, 0x70, 0x21 + }, + { + 0x99, 0x73, 0x8F, 0x38, 0xC5, 0x30, 0xB3, 0xED, + 0xA0, 0x26, 0x28, 0xE5, 0x8E, 0x66, 0xAB, 0x3E, + 0xC1, 0x73, 0xC2, 0x4D, 0xE6, 0x0E, 0x45, 0xB1, + 0x29, 0xEB, 0xAD, 0x54, 0x38, 0xCA, 0x79, 0xA1 + }, + { + 0x51, 0xE8, 0xAF, 0xF9, 0x2D, 0x8B, 0x0B, 0x76, + 0x8C, 0x74, 0x80, 0x3C, 0x6F, 0x1C, 0x6A, 0x70, + 0xAA, 0x73, 0x0F, 0x4C, 0x5C, 0x32, 0x10, 0xD5, + 0x0F, 0xB6, 0x98, 0x14, 0xC6, 0xF5, 0xAC, 0x09 + }, + { + 0x51, 0xEB, 0x7E, 0x35, 0x4E, 0xBB, 0xA3, 0xEC, + 0xAE, 0x3F, 0x18, 0x67, 0xD8, 0x94, 0xC1, 0xD2, + 0x59, 0x11, 0xE7, 0xAC, 0x74, 0x1C, 0x09, 0xDF, + 0x4B, 0x84, 0x98, 0xF9, 0x30, 0x89, 0x14, 0xB7 + }, + { + 0x45, 0x27, 0x87, 0x7D, 0x5E, 0x26, 0xB6, 0x02, + 0xB6, 0x7B, 0xD3, 0x98, 0xF5, 0x1D, 0xEC, 0x63, + 0xEA, 0x5B, 0x73, 0x4E, 0x5B, 0x48, 0x57, 0xF8, + 0x9E, 0xFA, 0x1D, 0x64, 0x1C, 0xBB, 0x4C, 0xFA + }, + { + 0x48, 0x55, 0x1C, 0x1A, 0xA6, 0xB5, 0x87, 0x8C, + 0xF0, 0x81, 0xB2, 0x5D, 0xD5, 0x26, 0xCC, 0xCD, + 0xF7, 0x41, 0xC9, 0x71, 0x7B, 0x1C, 0x46, 0xAA, + 0x36, 0x51, 0x32, 0x5D, 0xF3, 0x28, 0xE0, 0x0B + }, + { + 0x4B, 0xDA, 0xCC, 0x6A, 0x2A, 0xB8, 0xEE, 0x56, + 0x4D, 0x5F, 0xFE, 0x99, 0x7D, 0x59, 0x4B, 0xC4, + 0xEB, 0x94, 0x67, 0x57, 0xFF, 0x99, 0x87, 0xAF, + 0x05, 0xD6, 0x1F, 0x34, 0x7D, 0x2A, 0x2F, 0xC4 + }, + { + 0x3C, 0x59, 0xAC, 0x75, 0x79, 0xA2, 0xF6, 0xA7, + 0x6C, 0xE7, 0xD0, 0x54, 0x8C, 0x45, 0xE4, 0xBF, + 0x2A, 0xCB, 0xC1, 0x13, 0xFA, 0x59, 0xD4, 0x59, + 0xA9, 0xC6, 0x2E, 0xCE, 0xA4, 0xDA, 0xF0, 0x21 + }, + { + 0x59, 0x08, 0xE4, 0x92, 0xDC, 0x46, 0x47, 0xC9, + 0xD7, 0xA5, 0x5C, 0x95, 0x4E, 0xAD, 0xD2, 0xEC, + 0xFE, 0xB8, 0x03, 0xCF, 0x3C, 0x0D, 0xFB, 0x22, + 0xBD, 0x27, 0xA1, 0xA3, 0xDC, 0x51, 0xA1, 0xF7 + }, + { + 0x16, 0x94, 0x72, 0xE9, 0x8B, 0xDC, 0xC0, 0x70, + 0x9E, 0x64, 0x6D, 0x9A, 0x04, 0xA3, 0x18, 0x84, + 0xE9, 0xFC, 0x06, 0xDD, 0x1F, 0x4D, 0x95, 0x82, + 0x23, 0xCD, 0x53, 0xE7, 0x64, 0xB9, 0x44, 0xD2 + }, + { + 0xBA, 0x66, 0x2C, 0xB0, 0xF6, 0xA3, 0x87, 0x8C, + 0x3B, 0xAC, 0x2D, 0xFD, 0xC1, 0x01, 0xBF, 0xA6, + 0x43, 0x94, 0x90, 0x14, 0x28, 0x52, 0x18, 0xB3, + 0xDA, 0xD5, 0xCF, 0x53, 0xF1, 0x50, 0x24, 0xF6 + }, + { + 0x67, 0x02, 0x96, 0x7F, 0x1C, 0x81, 0xA7, 0x26, + 0x90, 0xDC, 0xE2, 0xC6, 0x23, 0xCE, 0xCB, 0x57, + 0xB3, 0x69, 0x3F, 0x33, 0x50, 0xE5, 0x83, 0x91, + 0x34, 0xF2, 0xA0, 0x0E, 0x9F, 0x81, 0x4E, 0x88 + }, + { + 0x2B, 0xBC, 0x14, 0x1B, 0x8E, 0x44, 0x6B, 0x2B, + 0x43, 0x53, 0x3B, 0x19, 0xDB, 0x77, 0x15, 0xDD, + 0x73, 0x7F, 0x5B, 0xDF, 0x69, 0x33, 0x0E, 0x26, + 0x3F, 0x64, 0x38, 0x89, 0xCF, 0x52, 0x22, 0x48 + }, + { + 0x44, 0x47, 0x95, 0x83, 0x90, 0x0D, 0x04, 0x76, + 0x55, 0xC2, 0x9C, 0x67, 0x5B, 0x46, 0x6E, 0xB9, + 0x52, 0x0E, 0xF7, 0x18, 0x49, 0x28, 0x61, 0xC4, + 0xFE, 0x40, 0xFB, 0x26, 0xF2, 0x62, 0xF1, 0x7A + }, + { + 0x69, 0x7E, 0x69, 0x4D, 0x6C, 0x2F, 0xC0, 0x56, + 0x37, 0xFD, 0x81, 0xBB, 0xE2, 0xF1, 0x53, 0x81, + 0x2D, 0xC2, 0xCA, 0x3D, 0x69, 0xDE, 0x20, 0x92, + 0xE7, 0xE1, 0x76, 0xEB, 0xC4, 0x89, 0xD8, 0xDD + }, + { + 0xDF, 0x59, 0xFD, 0x4C, 0x04, 0x3C, 0xCA, 0xF9, + 0x06, 0x04, 0xB6, 0x0B, 0xB3, 0xA9, 0x60, 0x1A, + 0x54, 0x1E, 0x01, 0x83, 0xF4, 0x39, 0xC9, 0xAF, + 0xE5, 0x14, 0xF9, 0x80, 0x1E, 0x44, 0xD5, 0x24 + }, + { + 0x8E, 0xC8, 0xC9, 0x9A, 0x02, 0xF6, 0xD6, 0xCF, + 0x4C, 0x97, 0x32, 0xC0, 0x96, 0x8C, 0x5C, 0x39, + 0xBA, 0x31, 0x7E, 0xE5, 0x87, 0x21, 0x69, 0x98, + 0xCC, 0x9B, 0xF6, 0x98, 0xE6, 0x14, 0xA0, 0x34 + }, + { + 0xE8, 0xB8, 0x28, 0x79, 0x88, 0x01, 0xDA, 0xC8, + 0x0B, 0x84, 0xE8, 0x49, 0x15, 0x69, 0xB2, 0x92, + 0x2B, 0xF1, 0x35, 0x91, 0x40, 0x94, 0x44, 0x85, + 0x6E, 0x25, 0x5A, 0x4C, 0x30, 0x63, 0xFA, 0xB7 + }, + { + 0xD6, 0xE8, 0x91, 0x11, 0xCE, 0x1E, 0xC7, 0xEB, + 0x2C, 0xE0, 0x87, 0xDF, 0x8B, 0xEE, 0x27, 0xF9, + 0x87, 0xA9, 0x41, 0x90, 0xD2, 0xBF, 0xDC, 0xF5, + 0x83, 0x79, 0xA0, 0xAE, 0x48, 0x25, 0x70, 0xFD + }, + { + 0xCB, 0x07, 0x80, 0x2C, 0xAB, 0xC5, 0x85, 0xCC, + 0xCB, 0xB8, 0x1C, 0x60, 0xA9, 0x9C, 0x79, 0x31, + 0x80, 0xEB, 0x3E, 0x2F, 0x00, 0x9C, 0xF6, 0xB3, + 0x8C, 0x7A, 0xEC, 0xCC, 0x23, 0x2A, 0x64, 0x1E + }, + { + 0x2B, 0x4F, 0xC3, 0x51, 0xD2, 0x15, 0x4F, 0x5D, + 0xDA, 0x4C, 0xCD, 0x1A, 0xB3, 0xBC, 0x9A, 0x49, + 0x3E, 0xA6, 0x57, 0x19, 0xD2, 0x00, 0x86, 0xE4, + 0x89, 0xBC, 0x9F, 0xA8, 0x88, 0x35, 0x03, 0x06 + }, + { + 0xFB, 0x8C, 0xB9, 0x3F, 0x1D, 0x52, 0x4A, 0x65, + 0x23, 0x2A, 0x37, 0x17, 0xD3, 0x77, 0x67, 0x8B, + 0xCE, 0x2C, 0x70, 0xEB, 0xC3, 0x5C, 0x68, 0x4C, + 0x68, 0xAC, 0xD9, 0x2E, 0x0D, 0xDB, 0xEB, 0x1D + }, + { + 0xA5, 0xC0, 0x7E, 0x95, 0x6C, 0x7E, 0x00, 0xD4, + 0x1D, 0xDE, 0xD8, 0x23, 0x70, 0x0E, 0x1D, 0xF3, + 0x98, 0xE0, 0xA7, 0x2F, 0x98, 0x4C, 0x76, 0x48, + 0xFE, 0x03, 0x36, 0xED, 0x40, 0x53, 0xB0, 0x11 + }, + { + 0x53, 0xB9, 0x69, 0xB1, 0xAA, 0x88, 0x54, 0x5C, + 0xC9, 0x76, 0x66, 0xC1, 0x92, 0x03, 0x50, 0xDB, + 0xD2, 0x6A, 0x95, 0x7D, 0x79, 0x50, 0x22, 0x1F, + 0x4C, 0x03, 0x2F, 0xEB, 0x91, 0x39, 0x33, 0xA6 + }, + { + 0x6E, 0xD5, 0xC7, 0x29, 0x02, 0x09, 0x57, 0xAF, + 0x84, 0x52, 0x2B, 0x9F, 0x0D, 0x8A, 0x6B, 0xBC, + 0x83, 0xD3, 0x58, 0x26, 0x0E, 0xCC, 0x21, 0x63, + 0x43, 0x4C, 0x27, 0x1D, 0x44, 0x7A, 0x67, 0xF2 + }, + { + 0x40, 0xF6, 0x39, 0xE1, 0x25, 0x3B, 0x00, 0xC0, + 0x3D, 0x7E, 0x0F, 0x11, 0xD2, 0xFE, 0xEE, 0x88, + 0x9F, 0xCB, 0xE0, 0xEB, 0x6B, 0xC9, 0x3D, 0x4D, + 0xE6, 0xBB, 0xA5, 0x5C, 0x8A, 0xCD, 0x1E, 0xFE + }, + { + 0x00, 0x45, 0xDB, 0xD6, 0x38, 0x75, 0xF9, 0xAD, + 0xAF, 0x7D, 0x02, 0xD9, 0xA0, 0x12, 0xDC, 0x07, + 0x55, 0x8F, 0x30, 0xE5, 0xE2, 0x97, 0x25, 0x5C, + 0x62, 0x9C, 0x04, 0xCB, 0x01, 0xF3, 0xB9, 0xD7 + }, + { + 0xF6, 0x38, 0x69, 0x9D, 0x16, 0x96, 0xA7, 0x69, + 0x02, 0x0F, 0xE9, 0x57, 0x31, 0x8C, 0x56, 0xEC, + 0xDA, 0xD2, 0xD2, 0x4B, 0xDD, 0x65, 0x1B, 0x17, + 0x33, 0xE5, 0x26, 0x5E, 0x75, 0x0F, 0x0C, 0x02 + }, + { + 0x89, 0x88, 0x47, 0x21, 0xEC, 0x23, 0x30, 0x6B, + 0x15, 0xF4, 0x7E, 0xE9, 0x03, 0x0C, 0x6E, 0xF3, + 0xED, 0x85, 0xFD, 0xF8, 0x18, 0xEB, 0x10, 0x63, + 0xA6, 0xE3, 0x36, 0x28, 0x24, 0xEC, 0x7B, 0xA4 + }, + { + 0x5B, 0x39, 0x46, 0xB7, 0x52, 0x33, 0x74, 0xF1, + 0x5D, 0x89, 0x47, 0x06, 0xCB, 0x47, 0x66, 0x29, + 0x4E, 0xA8, 0xB0, 0x8A, 0x69, 0x7D, 0x0F, 0x08, + 0x93, 0x67, 0x09, 0x41, 0x0F, 0xF3, 0xD6, 0xED + }, + { + 0xE2, 0x34, 0x32, 0x6D, 0xF9, 0xFC, 0x91, 0x66, + 0x92, 0xBA, 0x1A, 0xE4, 0xDF, 0x60, 0xB9, 0x5C, + 0x4F, 0x6E, 0x57, 0x9F, 0x2D, 0xC6, 0x8D, 0x99, + 0x51, 0x20, 0x70, 0x69, 0x6C, 0x80, 0x49, 0x52 + }, + { + 0xDF, 0x2F, 0x7A, 0x02, 0x79, 0x46, 0x47, 0xF8, + 0xBD, 0xB7, 0x99, 0xC4, 0x26, 0xEB, 0x56, 0xFE, + 0x03, 0x3A, 0x43, 0x88, 0x28, 0x5A, 0x0D, 0x32, + 0x9C, 0x05, 0xB3, 0xE4, 0x17, 0x02, 0x59, 0x13 + }, + { + 0xDB, 0xD4, 0x13, 0xA6, 0x51, 0xA7, 0x48, 0x7B, + 0xCE, 0xA6, 0x0A, 0x28, 0x26, 0x5A, 0x1F, 0xC5, + 0x00, 0xC3, 0xA8, 0x53, 0x01, 0x0D, 0x64, 0x7A, + 0x53, 0x4A, 0x6F, 0xF9, 0x9A, 0x18, 0xC5, 0xE9 + }, + { + 0x50, 0x37, 0xD0, 0x5D, 0x75, 0x15, 0x4F, 0x9B, + 0xAA, 0x0B, 0x79, 0x90, 0x37, 0x17, 0xFD, 0x71, + 0xF5, 0x80, 0xA5, 0xB7, 0x68, 0xF5, 0x85, 0x73, + 0xE9, 0xC8, 0x39, 0xD1, 0x1A, 0x35, 0xDF, 0x28 + }, + { + 0x61, 0xBB, 0xAA, 0xA5, 0x45, 0xCE, 0x01, 0xA1, + 0x4D, 0x48, 0x84, 0x44, 0xDF, 0x4D, 0x75, 0xC5, + 0xA1, 0x59, 0x49, 0xFF, 0xED, 0x45, 0x2B, 0x5B, + 0xDE, 0x7D, 0xF6, 0xC6, 0x97, 0x8B, 0x2F, 0x53 + }, + { + 0x6F, 0xAD, 0x9C, 0x50, 0xFF, 0xA0, 0x35, 0x1A, + 0x49, 0x6B, 0xB6, 0x47, 0x79, 0x65, 0xE9, 0x5F, + 0x95, 0x29, 0x7A, 0x3D, 0xCD, 0x39, 0x3D, 0x49, + 0x0D, 0x72, 0x43, 0x24, 0x67, 0xC9, 0x18, 0x7D + }, + { + 0xB6, 0x4C, 0x79, 0x79, 0xC8, 0x27, 0x9F, 0x6F, + 0x53, 0x2F, 0x24, 0x64, 0xF7, 0xA5, 0x9F, 0xBA, + 0x62, 0x19, 0xBD, 0x7B, 0x2A, 0x23, 0xC8, 0x57, + 0x21, 0xC2, 0xAF, 0xAC, 0x83, 0xF0, 0x9F, 0xDD + }, + { + 0x19, 0xC3, 0x2B, 0x6E, 0x67, 0xD0, 0x6A, 0x15, + 0xE6, 0x57, 0xFB, 0x8A, 0x23, 0x3E, 0xF6, 0x78, + 0xE7, 0x3D, 0x0E, 0x44, 0xFF, 0x2B, 0x5E, 0x31, + 0x0F, 0x09, 0x88, 0x72, 0x2F, 0x79, 0xEC, 0x9B + }, + { + 0x43, 0x6B, 0x44, 0xD1, 0x47, 0x0C, 0x86, 0xD1, + 0x0E, 0x3F, 0xE6, 0x64, 0xF0, 0xDA, 0xE7, 0x5B, + 0xC4, 0xB9, 0x7A, 0xA2, 0x76, 0x9C, 0xFE, 0x82, + 0xD9, 0x85, 0x7F, 0xC4, 0x59, 0x88, 0xD1, 0x93 + }, + { + 0x80, 0x2A, 0x52, 0xF2, 0x3E, 0xD9, 0xDD, 0x4D, + 0xFE, 0xFF, 0x39, 0x52, 0x42, 0xB6, 0x49, 0xF7, + 0xFF, 0x2E, 0xD6, 0x88, 0xB3, 0x4F, 0x3C, 0x7F, + 0x11, 0x6A, 0x42, 0xEE, 0x27, 0x1F, 0x9F, 0xA7 + }, + { + 0x11, 0xB1, 0x54, 0x4D, 0xA4, 0xE6, 0xD0, 0xDD, + 0x50, 0x79, 0x9B, 0x18, 0x6B, 0xDC, 0x22, 0x83, + 0x6F, 0x0D, 0xBC, 0xB3, 0x9E, 0xB2, 0xFE, 0x44, + 0xA9, 0xFA, 0xB7, 0x0E, 0xAF, 0xE1, 0xAE, 0x53 + }, + { + 0xCA, 0x7E, 0xFE, 0xFC, 0xE7, 0xD8, 0x53, 0x75, + 0x99, 0x34, 0xF5, 0xAE, 0x2C, 0x71, 0x14, 0xC4, + 0x63, 0x10, 0x25, 0x78, 0xA5, 0xA3, 0xE8, 0x45, + 0x15, 0x57, 0xBE, 0xF8, 0xB8, 0x6D, 0x43, 0x08 + }, + { + 0xD8, 0x82, 0x9D, 0x4A, 0xC2, 0xC3, 0xEE, 0x54, + 0x2B, 0x94, 0xB7, 0x36, 0x85, 0x9E, 0x13, 0xF0, + 0x29, 0xF7, 0x14, 0xB4, 0x2C, 0xA8, 0xA8, 0xE6, + 0x6D, 0x26, 0x7D, 0x81, 0x1C, 0x53, 0x1F, 0x00 + }, + { + 0xFB, 0xE0, 0xBF, 0x1C, 0xC6, 0xC9, 0x05, 0x0B, + 0x11, 0x21, 0xFC, 0x50, 0x38, 0xDD, 0x88, 0xC4, + 0x58, 0xBB, 0x6F, 0x45, 0xB4, 0x4A, 0x47, 0x16, + 0x8A, 0x6A, 0x92, 0x52, 0x5F, 0x9C, 0x58, 0xFF + }, + { + 0x66, 0x3B, 0x68, 0x88, 0xF6, 0x5A, 0x1F, 0xDF, + 0xEC, 0x39, 0x8A, 0x0E, 0x90, 0xED, 0x8A, 0x67, + 0x5F, 0x76, 0x75, 0xD9, 0x21, 0x51, 0x2B, 0xD1, + 0xED, 0xFE, 0x5F, 0x93, 0x48, 0xA9, 0x3C, 0x3C + }, + { + 0x7E, 0x98, 0x97, 0x2B, 0x27, 0x18, 0x60, 0x0C, + 0x3F, 0xFB, 0x79, 0x26, 0x32, 0x88, 0x34, 0xC2, + 0xEE, 0x5A, 0x81, 0x3B, 0x55, 0x57, 0x0B, 0xB1, + 0x2A, 0x5A, 0xA4, 0x35, 0x5A, 0xE7, 0x74, 0x30 + }, + { + 0x48, 0xE7, 0x52, 0x1A, 0xD1, 0xEB, 0xD9, 0x7C, + 0xBB, 0x06, 0x0C, 0x95, 0x6F, 0x01, 0xDC, 0x04, + 0x99, 0x1A, 0x40, 0xEF, 0x54, 0xBB, 0x06, 0xE6, + 0x4C, 0xC0, 0x4B, 0x33, 0x5B, 0x58, 0xE7, 0x8A + }, + { + 0x30, 0x7E, 0xBC, 0xEB, 0xF0, 0x33, 0xA9, 0xAF, + 0x79, 0xE5, 0x9F, 0x48, 0xE4, 0xAE, 0x09, 0x07, + 0x3B, 0x96, 0x38, 0xE5, 0xE1, 0x6C, 0x8C, 0x35, + 0xFD, 0x43, 0x15, 0x59, 0xCC, 0xD4, 0xC1, 0xB5 + }, + { + 0x3D, 0xA8, 0x32, 0x9B, 0x62, 0x99, 0x98, 0x38, + 0x36, 0x4D, 0xE7, 0x1E, 0xD5, 0x99, 0xB5, 0xA2, + 0xCD, 0x93, 0x12, 0xB7, 0x70, 0x4D, 0xC9, 0x86, + 0x56, 0x6F, 0x1B, 0x09, 0x85, 0xD5, 0x4F, 0xE8 + }, + { + 0x23, 0x73, 0x5D, 0x8F, 0x0A, 0xA9, 0xD6, 0xA7, + 0xED, 0xFD, 0xB9, 0xA9, 0x16, 0xC4, 0x78, 0xF1, + 0x88, 0xBD, 0x47, 0x12, 0xF2, 0x90, 0x6D, 0x12, + 0xB3, 0x28, 0xBE, 0x58, 0x7F, 0x54, 0x75, 0x17 + }, + { + 0xF2, 0x11, 0x7E, 0x3E, 0x57, 0x9C, 0x1C, 0xEE, + 0x04, 0x67, 0xF5, 0x83, 0xC3, 0x30, 0x99, 0x6A, + 0x80, 0x43, 0x7A, 0xAA, 0x8B, 0x53, 0x4E, 0x83, + 0xDD, 0xEA, 0x59, 0x33, 0xD0, 0xC5, 0x12, 0x89 + }, + { + 0x9C, 0xB5, 0x34, 0xA0, 0xBF, 0xF1, 0x39, 0xD1, + 0x06, 0x2E, 0x10, 0x23, 0xD3, 0xB7, 0xA8, 0x5E, + 0x0A, 0xC5, 0xED, 0xFB, 0xA8, 0xB4, 0xA2, 0xB2, + 0xB9, 0x40, 0x81, 0x02, 0x4B, 0x8E, 0x54, 0x87 + }, + { + 0x0B, 0x4C, 0x48, 0xCB, 0xDF, 0xCC, 0xF5, 0xF9, + 0xB5, 0x93, 0xE0, 0xE1, 0x77, 0xBE, 0x95, 0x83, + 0x59, 0xDC, 0xC2, 0x24, 0x6C, 0xDC, 0xDB, 0x8B, + 0x7D, 0xFD, 0x0D, 0xA9, 0xE4, 0x09, 0xCD, 0x25 + }, + { + 0x8D, 0xB4, 0xC8, 0x17, 0xE7, 0x88, 0xDA, 0x41, + 0x9D, 0x35, 0x94, 0x98, 0xB7, 0x6A, 0x92, 0xC6, + 0xED, 0xC5, 0x36, 0xCA, 0x5B, 0x13, 0x32, 0xA5, + 0x63, 0xB4, 0xCE, 0x73, 0x7C, 0x2D, 0x29, 0xA8 + }, + { + 0xAB, 0x67, 0x28, 0x08, 0x85, 0x7D, 0xAF, 0x92, + 0x87, 0xDB, 0x47, 0x0D, 0x4E, 0x04, 0xFC, 0x7E, + 0xD4, 0x3D, 0x92, 0xFF, 0x0E, 0x55, 0xE4, 0xB2, + 0x95, 0x89, 0x1C, 0x92, 0xC9, 0x9F, 0x5E, 0x2A + }, + { + 0xE9, 0x18, 0xF4, 0xD8, 0xA8, 0x03, 0x25, 0xE7, + 0x0E, 0x11, 0x20, 0x15, 0x1D, 0x13, 0x74, 0x7A, + 0xCA, 0xD1, 0x9C, 0xEC, 0xB7, 0xFF, 0x25, 0x36, + 0xDB, 0x5C, 0x06, 0x88, 0x54, 0x73, 0x94, 0x7C + }, + { + 0xBE, 0x60, 0x38, 0x4F, 0x03, 0x20, 0x48, 0xD4, + 0x6D, 0x9E, 0x47, 0x0E, 0xA1, 0x7B, 0xC9, 0x01, + 0xB1, 0xD3, 0x1C, 0x9D, 0x1D, 0xC6, 0xC6, 0x41, + 0x32, 0xE9, 0xAF, 0xD0, 0xB7, 0xF5, 0x4E, 0x67 + }, + { + 0xD8, 0x6E, 0xE6, 0xD4, 0x85, 0xC9, 0x94, 0x3F, + 0x10, 0xC0, 0x4A, 0x94, 0xE8, 0x4A, 0xAE, 0xC1, + 0x30, 0x2C, 0x7A, 0x28, 0x1D, 0x7C, 0x7F, 0x00, + 0x18, 0x0F, 0x66, 0xF3, 0xFE, 0x9B, 0xCD, 0x39 + }, + { + 0xE0, 0xE0, 0x6D, 0xDD, 0x7A, 0x9B, 0x8C, 0xEB, + 0x6F, 0x5B, 0x03, 0x6A, 0x8F, 0x45, 0xBF, 0x2F, + 0x01, 0x1A, 0xA9, 0x2E, 0x60, 0x6A, 0xD7, 0x7D, + 0x70, 0xFC, 0x03, 0xD7, 0x50, 0xDF, 0x10, 0xB7 + }, + { + 0xDE, 0xDB, 0xEE, 0xC9, 0x7A, 0x6B, 0x34, 0x5A, + 0x5A, 0xBA, 0x7D, 0x91, 0x81, 0x31, 0x29, 0xEA, + 0x56, 0x58, 0xA0, 0xB9, 0xA9, 0xE9, 0xA3, 0xB1, + 0x9F, 0xD2, 0x01, 0xFF, 0xA8, 0xDC, 0x0A, 0x3C + }, + { + 0x8A, 0x52, 0x42, 0x9B, 0x1E, 0x9E, 0x01, 0xCF, + 0x81, 0xB5, 0xE4, 0xA7, 0x67, 0x47, 0x26, 0x5B, + 0x32, 0x29, 0xE5, 0xB6, 0x4B, 0x46, 0xF0, 0xFB, + 0x03, 0x80, 0xE9, 0x92, 0x80, 0x8D, 0xB5, 0x54 + }, + { + 0x63, 0xE4, 0x02, 0x2F, 0x1C, 0xCF, 0x49, 0x3F, + 0xC0, 0xFF, 0xF7, 0xFA, 0xFA, 0xCB, 0xAF, 0xF7, + 0x72, 0x13, 0xD2, 0x4F, 0x64, 0x82, 0xAE, 0x61, + 0x20, 0x4C, 0x4F, 0x27, 0xF1, 0x52, 0xBD, 0xBC + }, + { + 0x7C, 0x25, 0xA1, 0xC5, 0x99, 0x4A, 0xDD, 0x11, + 0x53, 0xD3, 0xE0, 0x47, 0xCD, 0xFD, 0x8F, 0xC4, + 0x43, 0xC5, 0x20, 0x86, 0x21, 0xF7, 0xBD, 0x20, + 0xD1, 0x5D, 0xCA, 0x7A, 0xB1, 0x32, 0x22, 0xF4 + }, + { + 0x73, 0x55, 0x57, 0x5B, 0x15, 0x07, 0x78, 0x08, + 0x0B, 0x36, 0x1F, 0x29, 0xD8, 0x6C, 0xEE, 0xEA, + 0x85, 0x4F, 0x34, 0x93, 0x9C, 0x02, 0xE9, 0x1E, + 0x8F, 0x21, 0xD8, 0xFB, 0x52, 0x11, 0xD7, 0x81 + }, + { + 0x0C, 0xEF, 0xAA, 0xEA, 0x23, 0x69, 0xC6, 0x25, + 0x6D, 0xD3, 0xCA, 0xA1, 0x58, 0x26, 0xB8, 0x9A, + 0x9F, 0x3A, 0x98, 0x16, 0x4C, 0x54, 0x75, 0x10, + 0x43, 0xD3, 0xB3, 0x99, 0x31, 0xFD, 0xA9, 0xB7 + }, + { + 0x08, 0x7E, 0x0D, 0xCD, 0xB7, 0x2C, 0xD4, 0xE3, + 0xD2, 0xDA, 0xF6, 0x36, 0xFE, 0xCA, 0xD9, 0xDF, + 0x70, 0xEF, 0x6F, 0x87, 0xB1, 0xE8, 0x77, 0xC1, + 0x75, 0x2E, 0xAE, 0x1A, 0xAD, 0x71, 0x80, 0xF5 + }, + { + 0x0E, 0xC5, 0x6E, 0xF0, 0x5C, 0x89, 0x5E, 0x81, + 0xF6, 0x92, 0x3F, 0x94, 0xED, 0x81, 0xB5, 0x06, + 0x12, 0xA8, 0x98, 0xF9, 0xB2, 0x45, 0x94, 0xCE, + 0x7F, 0x36, 0x08, 0x4D, 0xAC, 0x14, 0x7D, 0xE0 + }, + { + 0xF7, 0x5B, 0x05, 0xC0, 0xFE, 0x72, 0x8D, 0xE5, + 0x61, 0x39, 0x6F, 0x9A, 0xD1, 0x9D, 0x81, 0x5F, + 0x55, 0xB7, 0x5D, 0xED, 0x16, 0x2F, 0x0D, 0xD0, + 0xDB, 0x1F, 0xC0, 0xA7, 0xFE, 0xBC, 0x98, 0xEB + }, + { + 0xAF, 0x33, 0x32, 0xD3, 0x4D, 0x06, 0xC7, 0x37, + 0x68, 0x71, 0x86, 0x58, 0x08, 0x18, 0xF3, 0x59, + 0xB8, 0xE0, 0x41, 0x28, 0x0C, 0x80, 0x66, 0x2C, + 0x3A, 0x2D, 0xFB, 0x0F, 0x25, 0x68, 0x7A, 0x88 + }, + { + 0x05, 0x3D, 0x06, 0xCA, 0x56, 0x7B, 0x72, 0xC7, + 0x4F, 0x42, 0x42, 0x79, 0x78, 0x5A, 0x69, 0xF7, + 0x52, 0x72, 0x98, 0xDB, 0xC4, 0xA1, 0xC9, 0x45, + 0x19, 0x64, 0xB2, 0x74, 0x01, 0x23, 0x81, 0x98 + }, + { + 0xEE, 0xBB, 0x80, 0x97, 0xB3, 0xC3, 0xCA, 0xBE, + 0xC3, 0xA2, 0x01, 0xDC, 0x6F, 0x6E, 0x44, 0xBD, + 0xF6, 0xE7, 0x25, 0xEF, 0x47, 0xBC, 0xF1, 0x05, + 0xD2, 0x86, 0x42, 0xE2, 0xFE, 0x84, 0xFE, 0xEF + }, + { + 0x84, 0x0F, 0x1A, 0xF8, 0x01, 0x38, 0xFC, 0x7E, + 0xA1, 0x42, 0x1F, 0x89, 0xD7, 0x27, 0x17, 0x13, + 0x5E, 0x2D, 0xCE, 0x8E, 0x97, 0x0B, 0x9C, 0x6E, + 0xE2, 0x15, 0x81, 0xDA, 0x2A, 0x7A, 0x33, 0xFD + }, + { + 0x8D, 0xFA, 0x4C, 0x45, 0xAD, 0x2F, 0xE2, 0xFF, + 0xD8, 0x86, 0x77, 0x70, 0x85, 0xDD, 0xCA, 0x27, + 0xDA, 0x17, 0x0E, 0x14, 0xD3, 0x8C, 0xD1, 0x7A, + 0x6E, 0xD9, 0xA4, 0x88, 0x28, 0x10, 0x30, 0xE0 + }, + { + 0x8C, 0x34, 0x27, 0x5B, 0x4B, 0x20, 0x7A, 0xE6, + 0x8D, 0x64, 0xD4, 0xC6, 0x39, 0x7B, 0xE9, 0x45, + 0xD1, 0x15, 0x94, 0xCE, 0xC8, 0x12, 0xD2, 0x35, + 0xD9, 0xCE, 0x6F, 0x86, 0x0B, 0xCD, 0xAA, 0x5E + }, + { + 0x6B, 0x8C, 0x0E, 0x56, 0x89, 0x7B, 0x2D, 0x1C, + 0xAD, 0xDB, 0xDA, 0xDD, 0x40, 0x3C, 0xD8, 0x6B, + 0x1F, 0xF0, 0xE0, 0xA3, 0xED, 0xD5, 0x34, 0x79, + 0x07, 0xA3, 0xCA, 0xFB, 0x55, 0x9C, 0x7A, 0xFB + }, + { + 0xA9, 0xD6, 0xE8, 0x65, 0x1B, 0x26, 0x6B, 0x49, + 0x38, 0xC7, 0x8D, 0xD4, 0xB1, 0x34, 0xC6, 0x68, + 0xA7, 0xD9, 0x8C, 0x5B, 0xDA, 0x90, 0xD8, 0x75, + 0xAD, 0xBA, 0xAF, 0xC8, 0x59, 0x96, 0xC0, 0xEB + }, + { + 0xDE, 0x73, 0x41, 0x7C, 0x01, 0xDC, 0xBF, 0x77, + 0xBC, 0x5D, 0x23, 0xA4, 0x53, 0x4D, 0x33, 0xEA, + 0x9E, 0xB4, 0x98, 0xB3, 0x1C, 0xDB, 0xA7, 0x8D, + 0x71, 0xEB, 0x79, 0x18, 0x62, 0x38, 0x83, 0xB5 + }, + { + 0xCD, 0xEC, 0xFB, 0xF3, 0x0F, 0xD1, 0x08, 0xA5, + 0xEA, 0x80, 0x81, 0xB3, 0xC2, 0xEA, 0x10, 0x77, + 0x61, 0x68, 0x55, 0x67, 0x3E, 0x63, 0x02, 0x2A, + 0x93, 0x66, 0xB3, 0x7A, 0xEC, 0x5E, 0x01, 0x38 + }, + { + 0x26, 0x6A, 0xC7, 0xE8, 0x0C, 0xC5, 0xA9, 0x0C, + 0x81, 0x12, 0x51, 0xD2, 0x62, 0x8B, 0x54, 0xD8, + 0x1D, 0xFB, 0x2E, 0xBB, 0x86, 0xAC, 0x55, 0x0D, + 0xB1, 0xEE, 0x3E, 0x5C, 0xD7, 0xD7, 0xFD, 0xAD + }, + { + 0x45, 0x19, 0x9C, 0x23, 0x8E, 0xAB, 0x97, 0xAF, + 0xA1, 0x4C, 0xAE, 0xBA, 0x39, 0xBE, 0xFD, 0x86, + 0x0B, 0x41, 0xC8, 0x9F, 0xF7, 0x99, 0x27, 0x38, + 0x02, 0x06, 0x91, 0xFF, 0x46, 0xD3, 0x07, 0x66 + }, + { + 0x69, 0x3B, 0x26, 0xE9, 0x3A, 0x42, 0x13, 0x61, + 0xE8, 0x79, 0x18, 0xA1, 0x62, 0xA3, 0x3B, 0x91, + 0x11, 0x81, 0x08, 0xC1, 0x40, 0x9B, 0x26, 0x8D, + 0x2A, 0x06, 0x5C, 0x74, 0xD0, 0x79, 0x57, 0xCB + }, + { + 0x7A, 0x79, 0x84, 0xF8, 0x1C, 0xB4, 0x35, 0xCC, + 0xD0, 0xFB, 0x4E, 0x8B, 0x2F, 0xA6, 0x3F, 0x35, + 0x24, 0x64, 0xA5, 0x1E, 0x5D, 0x74, 0xEB, 0x35, + 0x75, 0xBC, 0x76, 0x47, 0x75, 0x0C, 0x27, 0xE8 + }, + { + 0x05, 0x67, 0x75, 0x19, 0x1C, 0x94, 0x06, 0xE5, + 0x9F, 0x61, 0x32, 0x50, 0x91, 0x20, 0x34, 0x12, + 0x0B, 0x3C, 0x8B, 0xC7, 0x7E, 0xA1, 0xDD, 0x08, + 0x30, 0xC9, 0xB5, 0xF8, 0xB6, 0x84, 0xF6, 0x08 + }, + { + 0xFF, 0x5E, 0x08, 0xA1, 0x98, 0xAC, 0x3B, 0xBD, + 0xD9, 0x08, 0x30, 0x51, 0x97, 0x12, 0x51, 0x82, + 0x60, 0xD0, 0x83, 0x5A, 0x65, 0xBC, 0x6C, 0x8E, + 0xDF, 0x00, 0xA8, 0xCA, 0x7C, 0x4E, 0x58, 0x7A + }, + { + 0x1D, 0xE3, 0xF2, 0xF6, 0xF2, 0xF7, 0x52, 0xC8, + 0x62, 0xF0, 0x99, 0x1C, 0xAB, 0xED, 0x3E, 0x67, + 0x59, 0xC4, 0xD4, 0x77, 0x8F, 0x13, 0xFE, 0xB6, + 0x96, 0xA2, 0x87, 0xF2, 0x81, 0x4C, 0x7E, 0x51 + }, + { + 0x27, 0x43, 0x01, 0x3D, 0x93, 0xC6, 0xA8, 0x25, + 0x86, 0xFF, 0xC7, 0xA2, 0x79, 0x6C, 0xD7, 0x5D, + 0x23, 0xF5, 0x0A, 0x09, 0x2E, 0xC7, 0x78, 0xE1, + 0x07, 0xE9, 0x2D, 0x9C, 0xA6, 0x46, 0x80, 0x58 + }, + { + 0xA6, 0xF5, 0xB6, 0x98, 0x20, 0x1D, 0x07, 0xF2, + 0xC3, 0x4A, 0x4B, 0xF5, 0xDC, 0xFB, 0x91, 0x62, + 0xAC, 0xB2, 0x26, 0x99, 0xF2, 0x80, 0x2C, 0x23, + 0xA3, 0x41, 0xBB, 0xDD, 0xEF, 0x31, 0xF6, 0x41 + }, + { + 0x2B, 0xD2, 0x9E, 0x84, 0x91, 0xFC, 0x5C, 0x9E, + 0xEE, 0x49, 0x96, 0xD2, 0x47, 0x8A, 0x14, 0xAF, + 0x98, 0x83, 0x08, 0x6C, 0x4F, 0x24, 0x61, 0x40, + 0x5A, 0xC5, 0xE6, 0x77, 0xEC, 0x51, 0x9A, 0x60 + }, + { + 0xA0, 0xFF, 0xA1, 0x8F, 0x38, 0xAD, 0xAB, 0x16, + 0x7E, 0x79, 0xBD, 0xA2, 0xF9, 0xE2, 0xEC, 0x17, + 0x84, 0x6F, 0xC4, 0xCE, 0x05, 0xB1, 0xD5, 0xB6, + 0xE0, 0x50, 0x3A, 0x55, 0x1D, 0xB2, 0xEE, 0x94 + }, + { + 0xB3, 0xA0, 0x7D, 0x65, 0x1E, 0x3A, 0xF8, 0xB8, + 0x08, 0x3C, 0x57, 0xEB, 0x68, 0x39, 0x1D, 0xBC, + 0x48, 0x0B, 0x95, 0xBD, 0xAD, 0x85, 0x80, 0x24, + 0x6B, 0xED, 0x10, 0xBC, 0x79, 0x99, 0xCC, 0xC7 + }, + { + 0x2E, 0x4D, 0xB9, 0x07, 0x21, 0x99, 0x18, 0x36, + 0x85, 0x1B, 0x13, 0x6D, 0xCE, 0xEA, 0x33, 0xC6, + 0x75, 0xC3, 0x3D, 0x0E, 0x67, 0x92, 0x04, 0x89, + 0x30, 0x97, 0x59, 0x5B, 0x47, 0x5E, 0x45, 0xDC + }, + { + 0xBF, 0xD4, 0x47, 0x4A, 0xF2, 0x89, 0xC5, 0x4C, + 0x6D, 0x6A, 0xD4, 0x42, 0xD1, 0x42, 0xA0, 0xF6, + 0xB1, 0x20, 0x1E, 0x90, 0xBA, 0x3D, 0xE0, 0x0B, + 0x28, 0x4F, 0xFB, 0xEF, 0xCB, 0x2E, 0x8E, 0x54 + }, + { + 0xC8, 0x95, 0x3C, 0xEE, 0x0A, 0xB8, 0x9F, 0xC3, + 0xA9, 0xBB, 0x80, 0x8D, 0x1B, 0xEA, 0xAC, 0xE7, + 0x85, 0x88, 0xA0, 0x67, 0x73, 0x79, 0xD6, 0x4B, + 0x28, 0xF6, 0x73, 0x44, 0xCE, 0x2C, 0xD6, 0xDE + }, + { + 0x4D, 0x22, 0xBD, 0x3E, 0x62, 0x2A, 0xAF, 0x1E, + 0x24, 0x32, 0xA1, 0x2E, 0xE1, 0x72, 0xE3, 0x1A, + 0xFE, 0xF8, 0x05, 0x88, 0x7A, 0x73, 0x26, 0x1E, + 0xEB, 0x4A, 0x44, 0xA9, 0x2B, 0x67, 0x76, 0x94 + }, + { + 0x30, 0x91, 0x9E, 0x6C, 0xB4, 0x5A, 0xB4, 0x2D, + 0x69, 0x16, 0x1F, 0x16, 0x25, 0x55, 0x22, 0x90, + 0x7F, 0x4D, 0xEF, 0xA3, 0x32, 0x93, 0xA9, 0x6F, + 0x47, 0xFF, 0x0B, 0x17, 0x60, 0x9E, 0x7E, 0x45 + }, + { + 0x69, 0xB6, 0xE4, 0x8F, 0x9C, 0x22, 0xF6, 0xC5, + 0x51, 0x47, 0x54, 0x29, 0x9D, 0xEB, 0x51, 0xF1, + 0x32, 0x8C, 0x5A, 0x25, 0x34, 0x73, 0x61, 0x4A, + 0xCC, 0xA4, 0x23, 0x83, 0x3E, 0x08, 0xA1, 0x95 + }, + { + 0x98, 0xE7, 0xC3, 0x27, 0x42, 0x48, 0xD3, 0x6D, + 0x6E, 0x99, 0x3D, 0x58, 0x05, 0x53, 0x13, 0xD2, + 0x65, 0xE3, 0xD4, 0x29, 0xFE, 0x0C, 0x09, 0xAC, + 0x15, 0xE6, 0x5B, 0x3C, 0x9B, 0x93, 0xA1, 0xA2 + }, + { + 0xBE, 0x68, 0x27, 0x81, 0x23, 0x9F, 0x8E, 0x47, + 0x10, 0x18, 0xAC, 0xC6, 0x83, 0xA6, 0x30, 0x74, + 0x7B, 0x33, 0x9C, 0x63, 0x9E, 0x3C, 0x27, 0xBB, + 0xFC, 0xFA, 0x6A, 0x95, 0xD2, 0xE6, 0xB5, 0x40 + }, + { + 0x52, 0xEA, 0x24, 0x07, 0x58, 0xFB, 0xBC, 0xD2, + 0x7C, 0x60, 0x5D, 0xFB, 0x70, 0xEF, 0x09, 0x57, + 0xC9, 0x00, 0x93, 0x35, 0xD6, 0xD0, 0xA8, 0xD6, + 0x0D, 0x21, 0x9E, 0x61, 0x1B, 0xA2, 0xE2, 0x3F + }, + { + 0xF7, 0xE9, 0x98, 0xBF, 0x3E, 0xED, 0xD3, 0xC0, + 0x6E, 0x03, 0xE5, 0x4C, 0x7F, 0xB9, 0x8F, 0xC4, + 0x7E, 0x10, 0x8D, 0x0B, 0x6D, 0xCD, 0xB3, 0x8D, + 0x1E, 0x35, 0x9A, 0xA0, 0x27, 0x37, 0xBD, 0xCC + }, + { + 0xB7, 0xCD, 0x75, 0x9C, 0x17, 0xF6, 0x36, 0xA7, + 0x39, 0x14, 0x47, 0x7C, 0x87, 0x70, 0x92, 0x94, + 0x70, 0x97, 0x82, 0xB0, 0xFE, 0x1F, 0xC5, 0x72, + 0x08, 0x61, 0x33, 0xCD, 0xCC, 0x7C, 0x08, 0xCE + }, + { + 0xC1, 0x98, 0x28, 0x76, 0x40, 0x1C, 0x06, 0x6A, + 0xF1, 0xE4, 0xC3, 0x46, 0xC8, 0xB2, 0x69, 0x2D, + 0x24, 0x78, 0x05, 0x0F, 0x9C, 0x93, 0x22, 0xA5, + 0x66, 0x6C, 0x75, 0x21, 0xC4, 0x5E, 0x44, 0x11 + }, + { + 0x34, 0xF6, 0xA7, 0xD2, 0xEC, 0x77, 0xEC, 0x87, + 0x49, 0xD4, 0x52, 0xB5, 0xF4, 0x34, 0xB6, 0x23, + 0xF6, 0x76, 0x83, 0x41, 0xCD, 0xE0, 0x06, 0x08, + 0xFF, 0x48, 0xB4, 0x91, 0xF8, 0xE6, 0x2A, 0xE9 + }, + { + 0x85, 0x02, 0xCC, 0xFB, 0xFD, 0xCD, 0x9F, 0xD7, + 0xC2, 0x6E, 0xA6, 0x16, 0x83, 0xE9, 0x91, 0x8B, + 0x7C, 0x30, 0x6B, 0x32, 0x1B, 0xD2, 0xEE, 0xDE, + 0x20, 0xA2, 0xA7, 0xA3, 0x30, 0x61, 0x54, 0x5A + }, + { + 0x63, 0x70, 0x88, 0x3A, 0x49, 0xB5, 0xAA, 0x2E, + 0x6D, 0x27, 0x31, 0xED, 0x3F, 0x64, 0xC8, 0x29, + 0x0D, 0x5B, 0x92, 0xE2, 0x39, 0x73, 0xC4, 0x29, + 0xE8, 0x7D, 0xCE, 0xE9, 0x8D, 0x17, 0x15, 0xCE + }, + { + 0xA8, 0x67, 0x78, 0x30, 0x7E, 0x46, 0xCF, 0xB4, + 0x63, 0x04, 0x46, 0x64, 0xFE, 0xB1, 0x9E, 0x2E, + 0x90, 0x91, 0x3C, 0x36, 0x80, 0xF8, 0x85, 0xA6, + 0x20, 0x1D, 0x1D, 0xBD, 0xE3, 0x8A, 0x36, 0x11 + }, + { + 0xAD, 0x43, 0xA2, 0x2E, 0xA1, 0xBD, 0x62, 0x94, + 0x26, 0x15, 0x9A, 0x93, 0x93, 0x81, 0x52, 0x9C, + 0xCC, 0x1F, 0x26, 0xB1, 0x1F, 0x08, 0x59, 0x04, + 0xDD, 0x2F, 0x29, 0x25, 0x6E, 0x3F, 0x90, 0x21 + }, + { + 0x98, 0xB6, 0x60, 0x98, 0xDB, 0xDB, 0xF9, 0x37, + 0x02, 0xB1, 0x41, 0x21, 0x66, 0xF1, 0x68, 0x53, + 0x17, 0x7E, 0x21, 0x1E, 0x11, 0x60, 0xB9, 0x4B, + 0x0B, 0xC5, 0xBA, 0x9C, 0x8F, 0x68, 0xB5, 0xD6 + }, + { + 0x0B, 0xAA, 0x1D, 0x52, 0x68, 0xE8, 0xBB, 0xD8, + 0x21, 0xEB, 0x5A, 0x12, 0xBF, 0xEB, 0x5A, 0x60, + 0xFC, 0x02, 0x79, 0xCE, 0xE3, 0x5C, 0x35, 0x8A, + 0xBE, 0x8A, 0x14, 0xE7, 0x7E, 0x32, 0xA6, 0xD0 + }, + { + 0x01, 0x81, 0x4F, 0xAF, 0x01, 0x4C, 0x53, 0x67, + 0xEA, 0xD7, 0x3F, 0x87, 0xDE, 0xC2, 0xEA, 0x7C, + 0x59, 0xB7, 0xEF, 0x13, 0xDA, 0x00, 0x5F, 0xF2, + 0x7E, 0x26, 0x7D, 0x64, 0xA3, 0x07, 0x24, 0x9D + }, + { + 0x3D, 0xD2, 0xE3, 0x4E, 0x27, 0xE7, 0x46, 0x99, + 0x4F, 0x9E, 0x7D, 0x88, 0xA5, 0xF9, 0x80, 0xC7, + 0x36, 0x83, 0x4A, 0x8D, 0xC5, 0x4B, 0x7E, 0xEE, + 0x1D, 0xC7, 0x05, 0xA9, 0xC5, 0x00, 0xF9, 0xF4 + }, + { + 0xAC, 0xBF, 0x20, 0x22, 0x27, 0xC2, 0x53, 0x18, + 0xED, 0xF2, 0x9B, 0xF6, 0x99, 0x36, 0x29, 0x32, + 0x24, 0xC4, 0x24, 0xEF, 0xD4, 0x48, 0xCB, 0xF2, + 0xBC, 0xCB, 0x30, 0xCB, 0x2D, 0xBD, 0xD6, 0xAC + }, + { + 0x3F, 0x20, 0x7A, 0x12, 0x42, 0x54, 0x1C, 0xFA, + 0xB0, 0xBE, 0x08, 0x85, 0x10, 0x39, 0x87, 0xFC, + 0x4B, 0x5A, 0x6E, 0x52, 0x06, 0xA5, 0x55, 0x57, + 0x62, 0x34, 0x21, 0xFB, 0xA3, 0x95, 0xB9, 0x2A + }, + { + 0x95, 0xDF, 0xA1, 0xFE, 0x3C, 0x54, 0x2A, 0x7C, + 0x52, 0xD8, 0x98, 0x9E, 0x4D, 0xF1, 0x21, 0xE1, + 0x2A, 0x70, 0xC4, 0x61, 0x26, 0x6A, 0x66, 0x5A, + 0x65, 0x3D, 0x1C, 0xFE, 0xB9, 0x88, 0x25, 0xCD + }, + { + 0x26, 0x37, 0xFC, 0x72, 0x97, 0x9F, 0x2B, 0x76, + 0xDC, 0x23, 0x9A, 0x16, 0x00, 0x49, 0x2E, 0x29, + 0xD1, 0xE6, 0x03, 0xCB, 0x9B, 0x52, 0x87, 0xBF, + 0xE2, 0xC5, 0xF8, 0xBD, 0x7E, 0x44, 0x00, 0x67 + }, + { + 0x94, 0x1B, 0x41, 0xD6, 0x7A, 0x1C, 0xA2, 0x4D, + 0xDB, 0x8E, 0x1A, 0xA9, 0x84, 0xE6, 0x0D, 0xAA, + 0x38, 0xA0, 0x22, 0xF5, 0xCB, 0xA4, 0x36, 0x4D, + 0xEC, 0x0C, 0xB7, 0x97, 0xCD, 0x1D, 0x5A, 0xC6 + }, + { + 0xBF, 0x8B, 0x60, 0x24, 0xB6, 0x28, 0x8C, 0xED, + 0x4A, 0x5B, 0xD4, 0xAE, 0x6A, 0x5A, 0x3A, 0x4F, + 0x6E, 0x0F, 0x51, 0x24, 0x20, 0x8C, 0xC2, 0x8F, + 0x8E, 0x22, 0x47, 0xFF, 0xB1, 0xEA, 0x92, 0x5D + }, + { + 0x0D, 0x00, 0xA0, 0x77, 0xF3, 0xCD, 0x45, 0xFB, + 0xC5, 0x3D, 0x9F, 0x13, 0x7E, 0x81, 0x08, 0x49, + 0xD9, 0x13, 0x2F, 0x29, 0x92, 0x2B, 0x79, 0xD0, + 0x31, 0x79, 0x8A, 0x5D, 0x54, 0xA1, 0xEB, 0xB2 + }, + { + 0x0E, 0x3F, 0xB9, 0xEF, 0x28, 0x3C, 0x39, 0x92, + 0x5C, 0xE8, 0x7A, 0x70, 0x0F, 0x5A, 0x8C, 0x51, + 0xCA, 0x70, 0xC6, 0x1B, 0x69, 0x9B, 0x75, 0xD7, + 0x42, 0x0D, 0xA2, 0x36, 0x23, 0x09, 0x9A, 0x81 + }, + { + 0xA3, 0x18, 0x59, 0x3E, 0x70, 0x5A, 0x96, 0xE7, + 0xAB, 0x1D, 0xDB, 0x73, 0x15, 0xF4, 0x89, 0xDB, + 0x8C, 0x3E, 0x0D, 0xF6, 0x18, 0x0D, 0xBD, 0xCB, + 0x80, 0x31, 0xFA, 0xE5, 0x57, 0xAE, 0xC3, 0xA3 + }, + { + 0x2F, 0xC5, 0x74, 0x76, 0x78, 0x6F, 0x3C, 0xA7, + 0x0B, 0xB8, 0x2F, 0x01, 0xE7, 0x1C, 0xBB, 0x7A, + 0x0E, 0xA0, 0xFE, 0xBB, 0x44, 0xF2, 0x87, 0x1A, + 0x6F, 0x3E, 0x9F, 0x87, 0x35, 0x74, 0x11, 0xFA + }, + { + 0xAF, 0xD1, 0xAC, 0x3A, 0x5B, 0x2E, 0x4F, 0x91, + 0x80, 0x39, 0x8B, 0x92, 0x3E, 0x53, 0xBF, 0xB5, + 0x71, 0xFD, 0xA1, 0xE3, 0x10, 0xE8, 0xA3, 0x3E, + 0xCA, 0x58, 0x2A, 0x2E, 0x12, 0x35, 0xC5, 0xD1 + }, + { + 0x78, 0x26, 0x10, 0x49, 0x35, 0xAE, 0x39, 0x08, + 0x27, 0x6D, 0xB3, 0x6D, 0x02, 0xDC, 0xB7, 0x75, + 0xAF, 0x90, 0x8D, 0x8C, 0xF9, 0x20, 0xF7, 0xB4, + 0x8F, 0x9E, 0x56, 0x88, 0xA9, 0xDA, 0xF8, 0xE1 + }, + { + 0xE0, 0xC0, 0x89, 0xCD, 0x8E, 0x3C, 0xA5, 0x1E, + 0x95, 0xCA, 0xAE, 0x05, 0xEE, 0x2C, 0xD4, 0x15, + 0x46, 0x5C, 0xA1, 0xC0, 0xF8, 0xDF, 0xE9, 0x46, + 0x16, 0x53, 0xB6, 0xEA, 0xBB, 0x37, 0x09, 0x54 + }, + { + 0x30, 0xB4, 0x55, 0x1F, 0x39, 0x22, 0x9A, 0x85, + 0x2B, 0x79, 0x68, 0x61, 0x7C, 0x73, 0xC4, 0xBF, + 0xFD, 0x06, 0x28, 0x9C, 0x3D, 0xE3, 0xF3, 0xA4, + 0x8E, 0x6C, 0xF6, 0x4A, 0x54, 0x73, 0x7E, 0xCA + }, + { + 0x8E, 0xC6, 0xB0, 0x97, 0x3E, 0x20, 0x47, 0xDD, + 0xB9, 0x3A, 0x0C, 0x9F, 0xBA, 0x3B, 0x8B, 0xD5, + 0x61, 0xF7, 0x3B, 0x30, 0x1A, 0xCC, 0xB3, 0x1C, + 0xF2, 0xFC, 0xFC, 0x58, 0xF3, 0x99, 0x66, 0x1F + }, + { + 0xDE, 0x94, 0x99, 0xA8, 0x6C, 0xE7, 0x92, 0xCD, + 0xCE, 0xB8, 0x70, 0x0C, 0x9F, 0x0E, 0x7E, 0x71, + 0x00, 0x11, 0x46, 0x2F, 0xA8, 0x71, 0xCA, 0x31, + 0xCF, 0xF3, 0x6C, 0xC6, 0x4E, 0x11, 0x09, 0xF0 + }, + { + 0xEE, 0x51, 0x4C, 0x2A, 0x2E, 0xC8, 0xB6, 0x81, + 0xAC, 0x40, 0x12, 0x26, 0x27, 0x26, 0xD0, 0x50, + 0x0A, 0x6D, 0x0B, 0x6A, 0x35, 0x96, 0x93, 0xD7, + 0xB2, 0x00, 0x66, 0xCF, 0x89, 0x7C, 0x48, 0xF3 + }, + { + 0x11, 0x13, 0x36, 0xA2, 0x33, 0x93, 0xCD, 0xA9, + 0x6D, 0x35, 0x92, 0xF3, 0x82, 0x78, 0xB6, 0xCB, + 0x22, 0xD5, 0x7B, 0x1E, 0xD4, 0x74, 0x37, 0xAD, + 0x68, 0xEF, 0x4C, 0xCF, 0x6C, 0x78, 0x8A, 0xF3 + }, + { + 0x80, 0x5E, 0x6D, 0x67, 0xF8, 0xDD, 0xC4, 0x24, + 0x8B, 0x82, 0x30, 0x4C, 0x04, 0x7D, 0x2C, 0x09, + 0x8E, 0x69, 0xDC, 0xCB, 0xAD, 0xF0, 0x3E, 0x89, + 0xDD, 0x0C, 0x5A, 0xC2, 0x20, 0xE7, 0xAB, 0x41 + }, + { + 0xC6, 0x2D, 0xEA, 0xBE, 0x28, 0xC3, 0x0B, 0xFE, + 0x4E, 0x6E, 0x64, 0x20, 0xCF, 0xBD, 0x1C, 0xDC, + 0xA1, 0xC5, 0x45, 0x88, 0x48, 0xF8, 0xAC, 0xFE, + 0xC4, 0x29, 0x5F, 0x0D, 0xBB, 0xC9, 0xEA, 0xED + }, + { + 0x9A, 0xAD, 0x11, 0xE4, 0xE6, 0xA7, 0xCC, 0x49, + 0x48, 0x4D, 0xB4, 0xAB, 0xDE, 0xD3, 0x3F, 0x81, + 0x26, 0xA6, 0xC4, 0x81, 0xB8, 0xF2, 0x15, 0x74, + 0xCD, 0xF6, 0x73, 0xDB, 0xE7, 0xC9, 0x97, 0x92 + }, + { + 0x7A, 0x58, 0x01, 0x80, 0x18, 0xEB, 0xD3, 0xF8, + 0x41, 0xA0, 0xE7, 0x92, 0x6E, 0x62, 0x1B, 0x3C, + 0x2B, 0x97, 0x6A, 0x80, 0xCE, 0xCB, 0x2F, 0x37, + 0x14, 0x46, 0x80, 0xD9, 0x18, 0x19, 0x4F, 0x67 + }, + { + 0xE1, 0x8F, 0xD0, 0x48, 0x99, 0x33, 0x75, 0xC4, + 0xC0, 0x62, 0x3B, 0x7C, 0x14, 0xFB, 0x12, 0x06, + 0x30, 0x52, 0x85, 0xC0, 0xF9, 0x51, 0x36, 0x61, + 0x1C, 0xAD, 0x2C, 0xE5, 0x4D, 0x1F, 0x69, 0x3A + }, + { + 0x13, 0xDA, 0x21, 0x8E, 0xD7, 0x6B, 0x09, 0xB4, + 0x7F, 0x28, 0xFB, 0xEF, 0x47, 0xBF, 0x1D, 0x65, + 0x05, 0xD5, 0x76, 0xC5, 0x55, 0x69, 0xB6, 0x87, + 0x0A, 0x05, 0x21, 0xC4, 0x51, 0x0C, 0x34, 0x8E + }, + { + 0xDC, 0x83, 0x36, 0x0D, 0x51, 0xD8, 0xE5, 0x89, + 0xB2, 0x25, 0x38, 0xC9, 0xE4, 0xC5, 0x3D, 0x80, + 0x2E, 0xBB, 0xB5, 0xC6, 0xE7, 0x23, 0x72, 0x28, + 0x4D, 0x93, 0xE1, 0xF0, 0x1E, 0xA9, 0xC3, 0x34 + }, + { + 0x5C, 0x58, 0xE1, 0xC9, 0xC9, 0xE2, 0x62, 0xA4, + 0x0C, 0x26, 0xC9, 0xFC, 0xAD, 0x54, 0x70, 0x6C, + 0x7E, 0x54, 0x2C, 0xB2, 0x22, 0xCE, 0x32, 0x0A, + 0x29, 0x0F, 0xC4, 0x7B, 0x94, 0x6A, 0xD5, 0x38 + }, + { + 0x55, 0x04, 0x45, 0x77, 0x64, 0x43, 0xA5, 0xB9, + 0xAC, 0x86, 0x66, 0x36, 0x4C, 0x69, 0x23, 0xEC, + 0x02, 0x89, 0x73, 0x92, 0xB4, 0xD4, 0x2C, 0x42, + 0x1A, 0xC7, 0x90, 0x07, 0xA0, 0x42, 0xDA, 0x6C + }, + { + 0x33, 0x6F, 0xC9, 0xA9, 0xA0, 0x66, 0xE1, 0x8C, + 0x73, 0xC1, 0xBA, 0xE4, 0xE1, 0x17, 0x60, 0x93, + 0xA7, 0x03, 0x57, 0x4B, 0x35, 0xD0, 0xE2, 0xC1, + 0x1B, 0x35, 0x41, 0xF5, 0xAC, 0x71, 0x75, 0x9D + }, + { + 0x64, 0xD5, 0xC2, 0x22, 0x3F, 0x58, 0xD9, 0x00, + 0xE7, 0xD8, 0x86, 0xC5, 0xDC, 0x47, 0x74, 0x41, + 0x42, 0x8C, 0xD4, 0x20, 0x8E, 0x12, 0xA9, 0x3A, + 0xC2, 0xAA, 0x70, 0x5D, 0xA0, 0x81, 0xD1, 0xCA + }, + { + 0x06, 0xFD, 0x88, 0xCC, 0xE2, 0xCA, 0xC4, 0xF6, + 0x47, 0x6C, 0x41, 0x1F, 0xD6, 0x54, 0xDB, 0xA7, + 0xBD, 0x44, 0xBA, 0x10, 0x9B, 0x52, 0x1E, 0xCD, + 0x31, 0xEB, 0xE1, 0x25, 0x30, 0xDB, 0x8B, 0x7F + }, + { + 0x19, 0x04, 0x7F, 0x0F, 0x25, 0x4D, 0x6E, 0x3B, + 0xD9, 0x0E, 0xAA, 0xBE, 0xFE, 0x75, 0x8C, 0x85, + 0xF3, 0xE9, 0xC7, 0xE5, 0xD1, 0x00, 0xC9, 0x73, + 0x47, 0xBB, 0x23, 0x3C, 0x24, 0x8E, 0x91, 0xD9 + }, + { + 0x84, 0x04, 0x6A, 0xEF, 0x81, 0xB0, 0x1D, 0xAE, + 0xE8, 0x4C, 0x82, 0xE4, 0xD6, 0x0B, 0xCC, 0xBB, + 0xD4, 0x02, 0xEA, 0xAF, 0x1D, 0x72, 0x28, 0x2F, + 0xED, 0xCA, 0xB2, 0x2C, 0x70, 0x60, 0x1B, 0xA0 + }, + { + 0x86, 0x95, 0xB0, 0x76, 0xCC, 0x01, 0x4A, 0xD6, + 0x66, 0x57, 0xCB, 0x0F, 0x99, 0x81, 0x5A, 0x12, + 0x56, 0x9D, 0xB6, 0x24, 0xC7, 0x41, 0x77, 0x93, + 0x73, 0xF8, 0xDD, 0x75, 0xAF, 0x3E, 0x21, 0xA4 + }, + { + 0xC2, 0x90, 0x36, 0x5D, 0xF0, 0xC8, 0x36, 0x60, + 0xDC, 0x11, 0xE1, 0x0D, 0x87, 0x15, 0x7E, 0xFE, + 0xF5, 0x95, 0x1C, 0x75, 0x2E, 0x03, 0xFD, 0xFE, + 0xFD, 0xC5, 0xF1, 0x09, 0x32, 0x7F, 0xE9, 0x63 + }, + { + 0x48, 0x96, 0xBA, 0x2F, 0x30, 0xE4, 0x7F, 0x9D, + 0x6E, 0x7C, 0x9D, 0xBB, 0x9F, 0x2E, 0xC6, 0x79, + 0x3A, 0x29, 0xBB, 0x24, 0xF1, 0x5D, 0xA2, 0x1A, + 0xB6, 0x88, 0x72, 0x20, 0x22, 0x52, 0x22, 0x96 + }, + { + 0xEF, 0xA1, 0xF2, 0x34, 0x14, 0xCA, 0x4D, 0x56, + 0x09, 0xA9, 0x10, 0x79, 0x97, 0x22, 0x18, 0x26, + 0x35, 0x1A, 0x5E, 0xBA, 0xBA, 0x20, 0x9A, 0x89, + 0x3E, 0x81, 0x54, 0xC6, 0xEA, 0x2F, 0xD4, 0x99 + }, + { + 0xC5, 0x8F, 0xF6, 0xEE, 0x63, 0x48, 0x26, 0x58, + 0xE6, 0xB6, 0xF8, 0xDF, 0x49, 0x50, 0x94, 0x5A, + 0x9D, 0xEF, 0xCF, 0x76, 0xED, 0x5A, 0x98, 0x43, + 0x4C, 0x44, 0xE0, 0xE1, 0xAE, 0x45, 0x18, 0xED + }, + { + 0xBB, 0x4C, 0xAF, 0xA0, 0x0D, 0x14, 0x5A, 0xD9, + 0xF9, 0xEA, 0xE2, 0x6A, 0xC6, 0x4B, 0x8F, 0x81, + 0x97, 0xF7, 0xC2, 0xB7, 0x07, 0x51, 0x49, 0xE1, + 0x65, 0x71, 0x88, 0x68, 0x78, 0x0B, 0xDD, 0xB4 + }, + { + 0x26, 0xDC, 0x80, 0x54, 0xF5, 0x9D, 0x8E, 0x25, + 0xF9, 0xBF, 0x85, 0xD6, 0x56, 0x2A, 0xEE, 0xF1, + 0xF7, 0xD9, 0xFF, 0xD8, 0x95, 0xF3, 0x4D, 0x9A, + 0xAD, 0x0A, 0xE3, 0x70, 0x5B, 0x22, 0x52, 0xF6 + }, + { + 0xDD, 0xCE, 0xE4, 0x43, 0x58, 0x90, 0x97, 0x07, + 0x29, 0xD5, 0x53, 0x9F, 0xCA, 0x4F, 0x8E, 0xBE, + 0x71, 0x06, 0x80, 0x80, 0xBF, 0xF6, 0x95, 0xC7, + 0x5C, 0x97, 0x79, 0x87, 0x7A, 0xC6, 0x81, 0x40 + }, + { + 0x60, 0x12, 0xAB, 0xD4, 0x18, 0x5A, 0xB5, 0xC1, + 0x70, 0xBB, 0xD5, 0xA6, 0x85, 0x11, 0x35, 0x6D, + 0xC3, 0x4D, 0x4A, 0x1D, 0x2B, 0xCB, 0x6C, 0xBB, + 0x20, 0xE9, 0xC2, 0x61, 0xA9, 0x20, 0x84, 0xAD + }, + { + 0x9D, 0x5B, 0x7F, 0x4C, 0xB3, 0xD1, 0x4C, 0xE6, + 0xDA, 0x1E, 0xBA, 0x51, 0xB4, 0x37, 0xBD, 0x9B, + 0x39, 0x68, 0x26, 0xE3, 0xCC, 0x54, 0xAE, 0xC5, + 0x9D, 0xEE, 0x6A, 0x61, 0x6B, 0x0C, 0xBB, 0x02 + }, + { + 0x68, 0xC7, 0xED, 0x49, 0x16, 0x09, 0xC9, 0x8F, + 0x9A, 0xD4, 0xBA, 0xC2, 0x40, 0x43, 0x73, 0x3B, + 0x46, 0xB5, 0xF8, 0x9F, 0xB5, 0x98, 0x37, 0x9E, + 0x74, 0x9C, 0x83, 0x64, 0x08, 0x7B, 0x49, 0xC1 + }, + { + 0xA9, 0xA6, 0xA3, 0x37, 0x09, 0xC1, 0x51, 0x95, + 0xFB, 0x8D, 0x3F, 0x40, 0x95, 0xFE, 0xE8, 0xA0, + 0x28, 0x62, 0xEE, 0x28, 0xFF, 0xDB, 0x8B, 0x52, + 0xBD, 0x24, 0x3F, 0x67, 0x21, 0x8E, 0xB1, 0x9C + }, + { + 0xD6, 0xC6, 0x7A, 0x11, 0x8A, 0xCC, 0xE4, 0xA8, + 0x35, 0x7B, 0x40, 0xAC, 0xE0, 0x2F, 0x0E, 0xCD, + 0xCD, 0xD2, 0xC3, 0x03, 0xEB, 0x09, 0xF1, 0x5F, + 0x0E, 0x24, 0xDC, 0x84, 0xF0, 0x56, 0xA0, 0x6D + }, + { + 0xC9, 0x56, 0xB2, 0xB2, 0xA1, 0x32, 0x2B, 0xE4, + 0x20, 0x0A, 0xB7, 0xEB, 0x8F, 0x3B, 0x2F, 0xFD, + 0xB8, 0x4C, 0xCA, 0xFB, 0xC5, 0xAC, 0xE1, 0x35, + 0x20, 0x79, 0x6F, 0x7E, 0x2E, 0xE0, 0x9D, 0x69 + }, + { + 0x04, 0x56, 0x96, 0x2D, 0x01, 0x67, 0x48, 0x08, + 0x84, 0xDE, 0xE0, 0xC3, 0xF4, 0x4F, 0xA3, 0xE6, + 0xB4, 0xEB, 0x79, 0x25, 0x70, 0x34, 0x35, 0xDD, + 0xA3, 0x89, 0x85, 0xED, 0x51, 0xB8, 0x85, 0x0D + }, + { + 0xD8, 0x38, 0x09, 0xBA, 0x9E, 0xB0, 0xD7, 0x29, + 0x64, 0x08, 0x48, 0x88, 0x61, 0xE5, 0x66, 0x67, + 0xB5, 0xC0, 0x32, 0x0F, 0x6B, 0x2A, 0xED, 0x56, + 0xC4, 0x31, 0x12, 0xE5, 0x4C, 0xED, 0xD3, 0xBE + }, + { + 0xF6, 0x75, 0x3A, 0xBA, 0x55, 0x9F, 0x68, 0xEE, + 0xF9, 0xC9, 0x34, 0x34, 0x3A, 0x26, 0x9E, 0x80, + 0x81, 0xF3, 0x91, 0x19, 0x19, 0xC2, 0x98, 0x72, + 0x96, 0x44, 0x50, 0xFE, 0xF0, 0x4A, 0x1B, 0x16 + }, + { + 0x7C, 0xA3, 0x79, 0x15, 0x1E, 0x05, 0xAD, 0xFF, + 0x92, 0x6D, 0xA2, 0xB3, 0x61, 0xDA, 0xA1, 0x64, + 0xD9, 0x35, 0xA0, 0xF3, 0xBF, 0x19, 0x33, 0x92, + 0x69, 0x6E, 0x3F, 0xBF, 0x7A, 0x49, 0x85, 0xF1 + }, + { + 0x02, 0x58, 0x55, 0x84, 0x9C, 0xCB, 0x5D, 0x8D, + 0x2D, 0x3C, 0x6B, 0xA5, 0xB2, 0x3A, 0xB0, 0x04, + 0x2B, 0xDF, 0x35, 0xD0, 0x8D, 0xA3, 0x1A, 0xFC, + 0xA6, 0x11, 0xC1, 0x6F, 0x1D, 0x7F, 0x99, 0x1A + }, + { + 0xEA, 0x43, 0x32, 0x29, 0x84, 0xCE, 0xB8, 0x14, + 0xC0, 0x21, 0xFC, 0xFE, 0xD1, 0x11, 0xDC, 0x49, + 0xFE, 0x9A, 0xB7, 0xD5, 0x86, 0xE8, 0x7C, 0x95, + 0x26, 0x3A, 0x03, 0xA4, 0x36, 0xE1, 0x25, 0x47 + }, + { + 0x39, 0x20, 0x76, 0x3D, 0x88, 0x04, 0x86, 0x5D, + 0x39, 0xA0, 0xF9, 0x62, 0x4F, 0x67, 0x0A, 0xD7, + 0x91, 0xD8, 0x3D, 0xA1, 0xE7, 0x48, 0x9A, 0xC1, + 0x06, 0xE9, 0x74, 0xE3, 0xE7, 0xD1, 0xFD, 0xE6 + }, + { + 0x69, 0xCA, 0xEA, 0x54, 0xD7, 0x62, 0x2E, 0x6F, + 0xCF, 0x8C, 0xD8, 0xB0, 0x94, 0x9A, 0xD5, 0xB7, + 0xF7, 0x44, 0x4D, 0x4A, 0x99, 0xAE, 0x95, 0xEB, + 0x36, 0xBB, 0xAE, 0x94, 0x04, 0xEC, 0x4C, 0xE3 + }, + { + 0xF5, 0x82, 0x69, 0x63, 0xC1, 0x99, 0x3C, 0xAE, + 0xB5, 0x00, 0x66, 0x5C, 0x88, 0x06, 0x17, 0xE1, + 0x18, 0xA6, 0xDC, 0xA4, 0xB8, 0xDB, 0xDA, 0x66, + 0x81, 0xB3, 0xAD, 0x57, 0x66, 0x49, 0x96, 0x5D + }, + { + 0x7D, 0x6A, 0xAD, 0x9E, 0x20, 0x70, 0xAE, 0xC6, + 0x3A, 0xE4, 0x1F, 0xE8, 0x20, 0x04, 0x8A, 0xB5, + 0xC6, 0x70, 0x77, 0x52, 0xC1, 0x40, 0x12, 0x85, + 0x3B, 0x83, 0x1A, 0xF1, 0xC4, 0xC6, 0x2F, 0xFC + }, + { + 0xC8, 0x91, 0x45, 0x27, 0x3B, 0x07, 0x82, 0x26, + 0x45, 0xAE, 0x7C, 0x2C, 0x7C, 0x27, 0x97, 0x9C, + 0x2F, 0x62, 0x80, 0x1B, 0xAC, 0x76, 0xE4, 0x7A, + 0xB1, 0x7A, 0x05, 0xCE, 0xD4, 0xFB, 0x5B, 0x9D + }, + { + 0x52, 0x5A, 0xD2, 0xFC, 0x7A, 0xD7, 0x82, 0x1F, + 0x4C, 0x30, 0xD7, 0x43, 0x7B, 0x2D, 0x92, 0xF9, + 0x29, 0x7B, 0x62, 0x6B, 0x10, 0x1B, 0x29, 0x8C, + 0xC3, 0x6E, 0x21, 0x10, 0x65, 0x53, 0x0C, 0x1A + }, + { + 0x7D, 0x3A, 0xBE, 0xEC, 0x5A, 0xAC, 0x78, 0x2C, + 0xA3, 0x17, 0xFE, 0xE1, 0xC5, 0x1F, 0xEB, 0x07, + 0xB5, 0x8E, 0x16, 0x8A, 0xFF, 0xD9, 0x38, 0xB8, + 0x10, 0x65, 0xED, 0xB2, 0x76, 0x73, 0x22, 0xFC + }, + { + 0x5A, 0x40, 0xB7, 0x43, 0xD5, 0xD6, 0xCE, 0x04, + 0x8C, 0xD5, 0x1A, 0x15, 0xE9, 0x41, 0x95, 0xD3, + 0x4F, 0xFC, 0xBC, 0x2F, 0x43, 0xAB, 0x0E, 0xF4, + 0x1A, 0x3B, 0x3F, 0x6E, 0x10, 0xCC, 0x21, 0x96 + }, + { + 0x31, 0xE1, 0xEF, 0x3C, 0x3D, 0x8C, 0x66, 0x08, + 0xC0, 0xA4, 0xAA, 0x23, 0x89, 0x71, 0x20, 0xCA, + 0xE3, 0x92, 0x6A, 0xCA, 0x58, 0x55, 0xAE, 0x8C, + 0x1C, 0x0E, 0x6D, 0x56, 0x86, 0x27, 0x03, 0x1A + }, + { + 0x16, 0x13, 0xB4, 0x22, 0x2E, 0x50, 0x3A, 0xF1, + 0xEE, 0xE0, 0x6F, 0x96, 0x63, 0xC8, 0x89, 0xE3, + 0x59, 0x1B, 0x3D, 0x35, 0x7C, 0x15, 0x6B, 0x9E, + 0x92, 0xA5, 0xC2, 0xC4, 0x04, 0x4F, 0x56, 0xB2 + }, + { + 0xBB, 0x83, 0x3D, 0x3B, 0xBB, 0x16, 0x05, 0xEA, + 0x1D, 0x8D, 0xAC, 0xA9, 0xF8, 0x42, 0x5E, 0x56, + 0x09, 0xF7, 0xA6, 0x3E, 0xB6, 0x49, 0xF8, 0x15, + 0xB4, 0x26, 0x6B, 0x6A, 0x8C, 0x51, 0x01, 0x5A + }, + { + 0x12, 0xF2, 0x7E, 0x58, 0x2E, 0xC3, 0x6D, 0xA4, + 0xC8, 0x58, 0x6C, 0x81, 0x1D, 0x14, 0x1F, 0x09, + 0xC7, 0x7C, 0xCE, 0xD8, 0xBA, 0xD2, 0x20, 0xDC, + 0xC8, 0x15, 0x67, 0xCD, 0x88, 0x42, 0x5E, 0x94 + }, + { + 0xEF, 0x07, 0x68, 0x12, 0x64, 0x9A, 0xE8, 0xA3, + 0x18, 0x9B, 0x3D, 0xBE, 0xD6, 0x98, 0x22, 0x41, + 0xFE, 0x49, 0xEF, 0x54, 0x16, 0xA0, 0x35, 0x1B, + 0xEF, 0xE7, 0x1E, 0xBB, 0x05, 0x50, 0x22, 0x16 + }, + { + 0xA3, 0xDB, 0x97, 0xED, 0x79, 0xB7, 0xD7, 0x7C, + 0xC7, 0xA5, 0x85, 0x19, 0x5E, 0xE2, 0x5E, 0x8F, + 0x65, 0xF2, 0xC4, 0xBA, 0x6A, 0x02, 0xB2, 0x45, + 0x95, 0x9B, 0xA8, 0x90, 0xC3, 0x66, 0x46, 0xCE + }, + { + 0xB6, 0x50, 0xA6, 0x1C, 0x4E, 0x3F, 0x1E, 0x41, + 0xEE, 0xB7, 0xCD, 0x07, 0x45, 0x8A, 0xE3, 0x0B, + 0x7F, 0x09, 0xE6, 0xC8, 0x13, 0x8A, 0xA5, 0x42, + 0x9F, 0xFD, 0x37, 0x0E, 0x7C, 0x66, 0x8A, 0xC4 + }, + { + 0x1F, 0xD9, 0x43, 0x65, 0xFF, 0x3C, 0x5D, 0x28, + 0x93, 0x3A, 0xDB, 0xA0, 0x18, 0x11, 0x72, 0x73, + 0xD1, 0xD1, 0x91, 0xB1, 0xBE, 0x3B, 0x5A, 0x63, + 0x49, 0xC1, 0x39, 0xEE, 0x44, 0x42, 0xD5, 0xE7 + }, + { + 0xE1, 0x26, 0x67, 0x63, 0x71, 0x43, 0x74, 0x19, + 0xD4, 0x2C, 0xDA, 0x96, 0xE3, 0xE9, 0x42, 0xC0, + 0x8B, 0xFE, 0xE0, 0xB4, 0x50, 0xAD, 0x6A, 0xFD, + 0xEB, 0x5A, 0xD8, 0xDC, 0xA0, 0xC4, 0xB6, 0xD7 + }, + { + 0xB6, 0x07, 0xFD, 0x6F, 0x6D, 0xDF, 0x69, 0xC0, + 0x28, 0x53, 0xB9, 0x24, 0xDA, 0xC9, 0xA6, 0x38, + 0x80, 0x35, 0x04, 0xB6, 0xCF, 0xDE, 0x4C, 0x05, + 0xAC, 0x97, 0x48, 0x1C, 0xE8, 0x84, 0x7F, 0xD8 + }, + { + 0x1A, 0x57, 0xA4, 0x94, 0xAA, 0x91, 0x36, 0x3B, + 0x69, 0x41, 0xBB, 0xE3, 0xAC, 0xBF, 0x20, 0xD5, + 0x02, 0xAE, 0xAF, 0x32, 0x67, 0x49, 0x13, 0x93, + 0x2B, 0xE4, 0xA3, 0x60, 0xFE, 0x95, 0x2C, 0xDC + }, + { + 0x59, 0x36, 0xC9, 0x68, 0x9D, 0x85, 0x04, 0xF8, + 0x74, 0x33, 0xF8, 0xA8, 0x8A, 0x00, 0x3F, 0x8C, + 0xF4, 0x8F, 0xBF, 0x6A, 0x6F, 0x98, 0xB9, 0xDE, + 0x3D, 0xB7, 0x9A, 0x15, 0xA6, 0x0E, 0xAF, 0x92 + }, + { + 0xBF, 0xE7, 0xC6, 0xA7, 0x85, 0x8E, 0x29, 0xD8, + 0x00, 0x5C, 0xFC, 0xE0, 0xDE, 0xF2, 0x5A, 0x55, + 0xA7, 0x1E, 0x4E, 0x02, 0x55, 0x3C, 0xAF, 0x25, + 0x26, 0xA8, 0x4E, 0xBC, 0xBD, 0x89, 0xBC, 0x01 + }, + { + 0x2D, 0x00, 0x32, 0xD4, 0x8B, 0x83, 0x4D, 0xAE, + 0x02, 0xA9, 0x51, 0x17, 0x6E, 0x1B, 0xEB, 0x7F, + 0xA5, 0x1D, 0xE9, 0x09, 0xDA, 0xAF, 0x28, 0x17, + 0x3F, 0xEF, 0xA1, 0x67, 0x4F, 0xC4, 0x67, 0xF0 + }, + { + 0x7A, 0xF6, 0xDE, 0x6F, 0x6B, 0xF8, 0x5D, 0xFB, + 0x6B, 0x7E, 0x6B, 0xA6, 0x21, 0x82, 0x46, 0xF7, + 0x43, 0x43, 0xEC, 0x21, 0xFB, 0xC1, 0x6D, 0x51, + 0xF0, 0xF3, 0xF4, 0xA6, 0x49, 0x69, 0x49, 0x31 + }, + { + 0x44, 0xBE, 0x0A, 0xBB, 0x0B, 0xFB, 0xDA, 0x14, + 0xEB, 0x34, 0xFA, 0xB2, 0xFB, 0xF0, 0x89, 0x28, + 0xC5, 0x62, 0xF4, 0x55, 0x4D, 0xA7, 0xEA, 0xAE, + 0x72, 0x8F, 0xF1, 0x6D, 0x92, 0x59, 0xEA, 0xCC + }, + { + 0x25, 0x00, 0xCB, 0x0D, 0x67, 0xD1, 0x82, 0x34, + 0xBE, 0x6E, 0xA0, 0xC1, 0x7F, 0x81, 0x16, 0x2B, + 0x9D, 0x3F, 0x3D, 0xB8, 0x74, 0x3F, 0x56, 0x09, + 0x43, 0xAF, 0x30, 0x60, 0xAB, 0x08, 0x91, 0xCA + }, + { + 0xAC, 0x40, 0xEB, 0x7F, 0xA6, 0x41, 0xFC, 0xE5, + 0x4C, 0x1B, 0xF1, 0x7E, 0xED, 0x83, 0xA2, 0xC1, + 0x7B, 0x34, 0x9E, 0xA2, 0x91, 0x36, 0x8D, 0xFB, + 0x71, 0xD4, 0x8E, 0xC7, 0x69, 0xD9, 0x18, 0x37 + }, + { + 0xE0, 0xFA, 0x98, 0xC6, 0x37, 0x0B, 0x48, 0x96, + 0x2F, 0x86, 0x1D, 0x35, 0xAA, 0x69, 0x88, 0x76, + 0xD5, 0x54, 0x3A, 0xAA, 0x5A, 0x2C, 0x99, 0xF3, + 0xA2, 0x0D, 0xFD, 0x32, 0xDA, 0xB3, 0xDA, 0xCD + }, + { + 0xE2, 0xF0, 0x8B, 0x68, 0x2F, 0x57, 0xE5, 0x78, + 0x39, 0xBF, 0x29, 0x35, 0x13, 0x75, 0x1C, 0xBC, + 0xD7, 0xEE, 0x87, 0x8D, 0xB9, 0x14, 0x1D, 0xA9, + 0xE1, 0xB2, 0x56, 0x1E, 0x9F, 0xE5, 0x9F, 0xBA + }, + { + 0xA0, 0x16, 0xC6, 0x89, 0xC9, 0xA4, 0xF5, 0x76, + 0x6C, 0xCD, 0xE3, 0xC7, 0xB1, 0x63, 0x31, 0xEC, + 0x1C, 0x7D, 0xA6, 0x5F, 0x5D, 0xB9, 0x0D, 0xF0, + 0x2A, 0x01, 0x21, 0x54, 0x6F, 0x3A, 0x06, 0xE4 + }, + { + 0x11, 0x90, 0x86, 0xCA, 0x0E, 0x7F, 0x64, 0x09, + 0x2F, 0x82, 0xC1, 0x9A, 0xC0, 0x01, 0x2A, 0x6C, + 0xF3, 0x56, 0xF7, 0x33, 0xFD, 0xDE, 0xDB, 0xB9, + 0x58, 0x26, 0x65, 0x21, 0x55, 0x16, 0xAA, 0x85 + }, + { + 0x42, 0xD8, 0xA8, 0xD4, 0xEE, 0xFA, 0xF4, 0xA8, + 0x02, 0xD0, 0xC8, 0xDB, 0x94, 0x3B, 0x49, 0x9C, + 0x08, 0xB2, 0xD8, 0xC8, 0x52, 0x23, 0xAB, 0xE0, + 0x2F, 0xF7, 0x2A, 0x1E, 0x16, 0x1F, 0x08, 0x2A + }, + { + 0x39, 0xEE, 0xDC, 0x5C, 0x3F, 0xBE, 0xA8, 0x2C, + 0x5E, 0x93, 0xFA, 0xA1, 0x39, 0x77, 0x1C, 0xC9, + 0x42, 0x43, 0x5A, 0x97, 0xDF, 0x0E, 0x0E, 0x17, + 0xBE, 0x92, 0xD6, 0x69, 0x26, 0x1A, 0x42, 0xD5 + }, + { + 0xBF, 0x96, 0x8C, 0xA9, 0x68, 0x84, 0xD5, 0xF9, + 0x1A, 0xF8, 0x93, 0x9D, 0xE9, 0x6C, 0xF3, 0xD5, + 0x30, 0x77, 0x29, 0x95, 0xBE, 0x62, 0xD8, 0x2A, + 0xC0, 0x84, 0xF1, 0xC9, 0x7A, 0x4A, 0xD8, 0x87 + }, + { + 0x77, 0x50, 0xD7, 0xDB, 0x15, 0xFC, 0xA2, 0x81, + 0x6C, 0x72, 0x70, 0x72, 0x64, 0x01, 0x24, 0x01, + 0x99, 0x65, 0xE4, 0x1D, 0xFC, 0xEB, 0x0E, 0x99, + 0x70, 0x95, 0x05, 0xE4, 0x5E, 0x70, 0x83, 0x16 + }, + { + 0xEA, 0x99, 0x3C, 0x1D, 0x74, 0xE3, 0xC0, 0xE8, + 0xF8, 0xEF, 0xE5, 0x8E, 0xFE, 0x27, 0xF1, 0x40, + 0x12, 0xFA, 0xBC, 0x59, 0x39, 0xD9, 0xC6, 0x15, + 0x24, 0xF6, 0xDD, 0xA0, 0xFF, 0xD6, 0xE2, 0x6D + }, + { + 0xDB, 0x5A, 0xAB, 0x08, 0xB9, 0xCF, 0x20, 0xA8, + 0x52, 0x00, 0xCE, 0xAC, 0xD2, 0x6E, 0x68, 0xA7, + 0xD8, 0x3B, 0x4F, 0x0E, 0x53, 0x80, 0x4E, 0x59, + 0x73, 0x8F, 0x90, 0xFF, 0x47, 0xE2, 0x2D, 0x34 + }, + { + 0xD6, 0x2D, 0x82, 0xA9, 0x48, 0xC9, 0x40, 0x04, + 0x00, 0xDD, 0xD6, 0x94, 0xE1, 0x11, 0x0C, 0xC1, + 0x74, 0xCB, 0x9E, 0xE5, 0x7D, 0x9F, 0x22, 0x5B, + 0xB2, 0x81, 0xE4, 0xD9, 0x8C, 0x0C, 0x8F, 0x91 + }, + { + 0x60, 0xF3, 0xA3, 0x0B, 0x1A, 0x5F, 0x8D, 0xF6, + 0x85, 0x6E, 0xDB, 0xC3, 0x66, 0x92, 0xE7, 0x85, + 0xF9, 0xA4, 0x82, 0x27, 0x38, 0xD0, 0x0E, 0x4A, + 0xD4, 0xCF, 0x1E, 0x80, 0xFE, 0x79, 0xE4, 0x3A + }, + { + 0xB0, 0x68, 0x98, 0x2B, 0x65, 0x46, 0x21, 0xC7, + 0xE2, 0x5A, 0x3A, 0xDC, 0xD5, 0x6D, 0x24, 0xC1, + 0x7E, 0xEE, 0x93, 0x6A, 0xD4, 0x72, 0x33, 0xD3, + 0x7A, 0xBD, 0x4C, 0xD1, 0x9C, 0x99, 0xCD, 0x87 + }, + { + 0x79, 0x5D, 0x2E, 0xC4, 0x67, 0x39, 0x88, 0x3E, + 0x95, 0x69, 0x8B, 0x6B, 0x01, 0x28, 0x33, 0xFA, + 0x63, 0xB0, 0xFF, 0x2B, 0xF4, 0x46, 0x14, 0x3B, + 0x3F, 0x2E, 0xD4, 0x62, 0x1C, 0xA2, 0x06, 0xC9 + }, + { + 0x19, 0xCF, 0xC3, 0xE3, 0xDF, 0x59, 0x30, 0xBB, + 0x09, 0x62, 0x68, 0x4B, 0xFE, 0x1B, 0x9F, 0x72, + 0xB5, 0x7E, 0xF5, 0xEF, 0x1B, 0x5E, 0x2E, 0xF4, + 0xF0, 0xFA, 0x4C, 0xEC, 0x53, 0x5E, 0x76, 0xAE + }, + { + 0x30, 0x9E, 0x3E, 0x8E, 0x75, 0x36, 0x0B, 0x63, + 0xFF, 0x70, 0x67, 0x33, 0xC4, 0x55, 0x80, 0x6D, + 0x76, 0x4D, 0x78, 0x2C, 0xA5, 0x2D, 0xAD, 0x86, + 0x84, 0x02, 0x97, 0x64, 0x3A, 0x51, 0xC4, 0xAA + }, + { + 0xB3, 0xFB, 0xE0, 0x19, 0x12, 0xCE, 0xAF, 0xE4, + 0x62, 0xCD, 0x71, 0x9E, 0x53, 0xA3, 0xEC, 0xB5, + 0xCC, 0xE2, 0xFB, 0xE0, 0xF8, 0xF9, 0x15, 0x00, + 0x55, 0xA6, 0x24, 0x19, 0x61, 0xEB, 0x8A, 0x99 + }, + { + 0x48, 0xD8, 0x61, 0xCE, 0x0E, 0x3D, 0xD3, 0x80, + 0xF7, 0x03, 0xC6, 0xC8, 0x96, 0x84, 0xCF, 0xF5, + 0x1F, 0x84, 0x3D, 0xE8, 0xA1, 0x38, 0x04, 0x9B, + 0x66, 0x68, 0x86, 0x55, 0xCA, 0x41, 0x7A, 0x9E + }, + { + 0x6B, 0xAE, 0x22, 0x07, 0xC4, 0x03, 0xEA, 0x4E, + 0x0B, 0x4D, 0x9E, 0x1D, 0xDF, 0xB2, 0x4E, 0x42, + 0x26, 0x65, 0xE1, 0xB4, 0x0D, 0x80, 0x99, 0x10, + 0x23, 0x1A, 0xDD, 0x4D, 0xD2, 0x0F, 0x5D, 0xB0 + }, + { + 0x6C, 0xC8, 0x9A, 0x7E, 0x6E, 0xA7, 0x46, 0xAA, + 0xE6, 0xB1, 0xD0, 0x1F, 0xAF, 0x8E, 0xC5, 0x9C, + 0xC2, 0xEC, 0x1C, 0xE1, 0xA8, 0xE8, 0x79, 0xD3, + 0x8A, 0xCC, 0xE4, 0x3A, 0x13, 0xE6, 0xF9, 0x53 + }, + { + 0x5D, 0x0F, 0xE2, 0x5F, 0xA0, 0x3E, 0x61, 0x41, + 0x3E, 0x93, 0xE2, 0xB4, 0x87, 0xA7, 0xFE, 0xB6, + 0xCF, 0x3F, 0x80, 0xE5, 0x3B, 0xA9, 0xDA, 0x94, + 0x07, 0xA7, 0x8F, 0x77, 0x78, 0x7C, 0xDC, 0xC5 + }, + { + 0x31, 0x5A, 0xC7, 0xC4, 0x4F, 0x94, 0xE1, 0xC5, + 0xB5, 0x86, 0xA3, 0x8C, 0x4C, 0xCE, 0x81, 0x27, + 0x3B, 0xE5, 0xD0, 0x9F, 0x25, 0x8A, 0x39, 0x73, + 0x9B, 0x99, 0x72, 0x9A, 0x34, 0x2A, 0xF5, 0xC8 + }, + { + 0x4B, 0x23, 0xFE, 0x24, 0xCA, 0xF1, 0x7F, 0xF7, + 0x53, 0xFC, 0xB7, 0x0C, 0x9F, 0x77, 0xB3, 0x82, + 0x5F, 0x74, 0x86, 0xF3, 0x68, 0xA7, 0x5F, 0xDE, + 0x5F, 0x67, 0x1F, 0x6E, 0xAD, 0xF0, 0xA8, 0x0E + }, + { + 0x68, 0x50, 0xEF, 0x87, 0x7C, 0x79, 0xCF, 0x65, + 0x93, 0x1D, 0xB9, 0xB8, 0xE9, 0x0F, 0xCD, 0x3E, + 0xDD, 0xDB, 0xAB, 0x04, 0xD1, 0x0D, 0x7C, 0x9F, + 0x33, 0xF3, 0x69, 0x79, 0xC6, 0xED, 0x7B, 0x37 + }, + { + 0xA0, 0x38, 0xFD, 0xF7, 0xD4, 0xE1, 0x4E, 0xCE, + 0x57, 0x53, 0x7B, 0x28, 0x2A, 0xF4, 0x48, 0x38, + 0x1C, 0x8E, 0x44, 0xB2, 0x66, 0x63, 0x4B, 0x9D, + 0x2A, 0x2F, 0x53, 0xEA, 0xAE, 0xE0, 0x9B, 0x4A + }, + { + 0xEA, 0xD0, 0x63, 0x92, 0x24, 0xF8, 0x15, 0xD5, + 0x15, 0x33, 0xE3, 0x88, 0xE7, 0x39, 0x2A, 0x60, + 0x56, 0x94, 0x26, 0x4E, 0x83, 0xE1, 0x25, 0x16, + 0x14, 0x32, 0x1B, 0xEA, 0xD4, 0x9B, 0x5F, 0xBB + }, + { + 0x9C, 0x39, 0xBB, 0x18, 0x2F, 0x10, 0x33, 0x5F, + 0x39, 0x63, 0x8C, 0x33, 0x97, 0x28, 0xCD, 0x86, + 0x07, 0x4D, 0x3A, 0x8C, 0xA3, 0x1D, 0xF1, 0x53, + 0x25, 0xF3, 0x9C, 0x1A, 0x39, 0x61, 0x61, 0x85 + }, + { + 0xF9, 0xB0, 0x5C, 0x0A, 0xC0, 0x02, 0x55, 0x9A, + 0xF9, 0x21, 0x3E, 0x7B, 0xC9, 0x36, 0x34, 0x66, + 0x1D, 0xE9, 0x4A, 0xD4, 0xD8, 0x6B, 0x9E, 0x83, + 0xBF, 0x8E, 0x48, 0xA0, 0x34, 0xB4, 0x13, 0x18 + }, + { + 0x71, 0xE4, 0xD9, 0xAA, 0xCF, 0xBD, 0x5D, 0x98, + 0x54, 0x06, 0x44, 0xA8, 0x3C, 0x24, 0xDD, 0xCD, + 0x6A, 0x89, 0x0E, 0x36, 0x87, 0x1D, 0x34, 0x0C, + 0x71, 0xED, 0x1A, 0x76, 0x21, 0xCA, 0xDD, 0x0C + }, + { + 0x4A, 0x26, 0x05, 0x62, 0xCA, 0xCF, 0xBD, 0xD0, + 0xE8, 0x90, 0x53, 0xDB, 0xD2, 0x05, 0xAA, 0x4C, + 0x7F, 0xB5, 0x6D, 0x82, 0x72, 0xC7, 0x2C, 0x4D, + 0x97, 0x03, 0x2C, 0xB2, 0xAC, 0xA4, 0xFA, 0xE6 + }, + { + 0xF4, 0x28, 0xE4, 0x58, 0x4B, 0x7D, 0x07, 0xD2, + 0xD3, 0x3F, 0xA9, 0x28, 0xCD, 0x56, 0x2D, 0x6E, + 0x29, 0xF6, 0x73, 0xF3, 0x54, 0xC3, 0xA5, 0x5F, + 0x97, 0xC2, 0xEE, 0xF0, 0x1B, 0x58, 0xC2, 0x6D + }, + { + 0x6D, 0xCE, 0x20, 0x1F, 0x52, 0xC3, 0x5A, 0x64, + 0x8E, 0xBF, 0xA9, 0x49, 0x5C, 0x8D, 0xEA, 0xF4, + 0xD4, 0x11, 0xC9, 0xA5, 0x72, 0xF3, 0xAD, 0x1E, + 0xFB, 0x20, 0x9C, 0x65, 0x33, 0x31, 0x11, 0x96 + }, + { + 0x3E, 0x2F, 0xCA, 0xCF, 0xC0, 0x72, 0x6B, 0x3B, + 0xAF, 0x3A, 0x45, 0xD6, 0x3E, 0x92, 0xA0, 0x7F, + 0x9D, 0x2C, 0xB5, 0xF9, 0xB6, 0xC4, 0x49, 0x39, + 0x0E, 0x7F, 0x6A, 0xB8, 0xE6, 0x48, 0xD8, 0xB4 + }, + { + 0xC5, 0xA4, 0x49, 0xDE, 0x56, 0x1C, 0xB5, 0xD7, + 0x82, 0x1D, 0x25, 0xAC, 0x27, 0x77, 0x28, 0xE6, + 0x99, 0x00, 0x5F, 0xC7, 0x16, 0xDC, 0xBC, 0x26, + 0x23, 0x65, 0x4F, 0x39, 0x52, 0xDB, 0x55, 0xC6 + }, + { + 0x2A, 0x2C, 0x61, 0x07, 0x08, 0x2D, 0x6D, 0x54, + 0x58, 0x68, 0x56, 0xAD, 0x39, 0xBA, 0x11, 0x90, + 0xBD, 0xF1, 0x8F, 0x65, 0x9E, 0x37, 0xD9, 0x94, + 0x94, 0x38, 0x0D, 0x41, 0x58, 0x09, 0x0C, 0x7D + }, + { + 0x53, 0x0C, 0x1B, 0x08, 0xD3, 0x19, 0xFF, 0x3F, + 0x43, 0x74, 0x0E, 0xC1, 0xC0, 0x7D, 0xAE, 0x81, + 0x7A, 0xEE, 0x1A, 0x5D, 0xD5, 0x31, 0x8F, 0xBB, + 0x21, 0xA7, 0xB1, 0xA2, 0xC0, 0x01, 0x10, 0x9F + }, + { + 0xA9, 0xC3, 0xC8, 0x4B, 0xC1, 0x63, 0x7A, 0x26, + 0x9A, 0x86, 0x7C, 0x1D, 0x18, 0xC4, 0x63, 0xE9, + 0x97, 0x17, 0xF0, 0x82, 0x21, 0x8E, 0x2D, 0xC5, + 0x5A, 0x66, 0x6F, 0xEF, 0x86, 0xA4, 0x7A, 0xD6 + }, + { + 0xC2, 0x92, 0x99, 0xCC, 0xA4, 0xEE, 0xBC, 0x25, + 0xD7, 0x71, 0xAD, 0x88, 0xCC, 0xA9, 0xD3, 0xC2, + 0xBF, 0x98, 0x95, 0x3B, 0xFB, 0xA7, 0xA6, 0x89, + 0x6F, 0x69, 0x87, 0xD0, 0x80, 0x80, 0x85, 0xF0 + }, + { + 0xF5, 0x92, 0x0A, 0xDE, 0x89, 0xEE, 0xC5, 0xD1, + 0x51, 0x2E, 0x6A, 0x34, 0xEA, 0x1F, 0x3D, 0xDF, + 0x7C, 0x22, 0xC9, 0x8A, 0xD9, 0xBC, 0x0D, 0x9A, + 0x59, 0x24, 0x55, 0x7D, 0xF2, 0x4B, 0x05, 0xCB + }, + { + 0xB1, 0x34, 0x40, 0x7A, 0x0A, 0x3A, 0xD2, 0x75, + 0xF8, 0xC5, 0xD2, 0x06, 0xDB, 0x05, 0x3F, 0xC6, + 0xD8, 0x6F, 0x1F, 0x6B, 0x9B, 0x5B, 0x33, 0xC8, + 0x5C, 0xA6, 0xD3, 0x6D, 0x63, 0xD1, 0xBB, 0x2D + }, + { + 0x27, 0xAD, 0x56, 0x6F, 0x80, 0x58, 0x7B, 0xED, + 0xCC, 0x77, 0x8E, 0xCC, 0x0C, 0xD9, 0x3A, 0x32, + 0x33, 0x6E, 0x77, 0xED, 0xDF, 0x3B, 0x1C, 0x8A, + 0x26, 0xB9, 0xCB, 0x11, 0x35, 0xF5, 0x91, 0x97 + }, + { + 0xC5, 0x04, 0x33, 0xFE, 0x53, 0x1D, 0x5A, 0x02, + 0x77, 0x89, 0xF2, 0x4F, 0x6C, 0x56, 0x77, 0x19, + 0x0A, 0x72, 0x58, 0xCC, 0x71, 0xF9, 0xB9, 0x02, + 0xEF, 0x6C, 0xAB, 0xEC, 0xCE, 0x14, 0x26, 0x5A + }, + { + 0x83, 0xFF, 0xD1, 0xD5, 0xBB, 0x40, 0xE8, 0xF7, + 0x43, 0x9F, 0xE5, 0xB2, 0x41, 0x93, 0xCE, 0x46, + 0x8A, 0x72, 0x11, 0xF7, 0x57, 0x13, 0x3F, 0xDB, + 0xA8, 0xFB, 0x75, 0x47, 0x6A, 0x71, 0xED, 0x30 + }, + { + 0x2B, 0x71, 0x4A, 0x3F, 0xD8, 0x09, 0x63, 0x56, + 0x7C, 0xAD, 0x3E, 0x94, 0xF2, 0xD9, 0x6B, 0xDF, + 0x1B, 0x62, 0x15, 0x6B, 0x77, 0x56, 0xF1, 0x2E, + 0xE7, 0xFC, 0x33, 0xFA, 0xCB, 0x09, 0x84, 0x2B + }, + { + 0xDA, 0x50, 0xD3, 0xF9, 0x78, 0x7E, 0xF4, 0x5A, + 0x8B, 0xEE, 0xF3, 0x53, 0xA9, 0x66, 0xD5, 0xB7, + 0x46, 0x5F, 0x7A, 0x10, 0x63, 0x86, 0xE6, 0x3C, + 0x12, 0xAC, 0xAC, 0xE7, 0xF4, 0x3C, 0x2D, 0x16 + }, + { + 0x97, 0x79, 0x0B, 0x07, 0x54, 0x86, 0xC6, 0x3F, + 0xCA, 0x8F, 0x38, 0xF3, 0xDA, 0x91, 0x08, 0x91, + 0x2F, 0x33, 0x16, 0x56, 0xCD, 0x24, 0x9F, 0x23, + 0x49, 0x29, 0x9F, 0x35, 0xC2, 0x95, 0xB7, 0x45 + }, + { + 0x73, 0xD6, 0x5E, 0xF7, 0xB0, 0xE6, 0x15, 0x99, + 0x9C, 0x67, 0x03, 0x89, 0x4A, 0x14, 0x22, 0x2E, + 0x08, 0x5B, 0x92, 0xBC, 0x0F, 0xBB, 0xE7, 0x9B, + 0x80, 0xD1, 0xCB, 0x3A, 0x5B, 0xB1, 0x82, 0x69 + }, + { + 0xD4, 0x69, 0x53, 0x1D, 0x4C, 0x5E, 0x4B, 0x04, + 0x84, 0x84, 0x25, 0x6A, 0xB5, 0x59, 0xE1, 0x1F, + 0xC4, 0xCE, 0x20, 0x74, 0x5E, 0x31, 0xF7, 0x90, + 0x74, 0x35, 0x83, 0x61, 0x26, 0xC0, 0xE2, 0xA0 + }, + { + 0x26, 0x98, 0x1C, 0x50, 0x56, 0x47, 0xB3, 0x3B, + 0x16, 0x8F, 0xC9, 0xFC, 0x9A, 0x5C, 0x4E, 0x7F, + 0x3E, 0xA0, 0x2D, 0x0D, 0xC8, 0xF4, 0x3A, 0xD7, + 0xA0, 0x90, 0x3D, 0x99, 0xFD, 0x09, 0xC8, 0x68 + }, + { + 0x3D, 0x0C, 0x41, 0x0D, 0x17, 0x24, 0x8B, 0xE5, + 0xBE, 0x51, 0x4C, 0xC7, 0xB6, 0xDE, 0xEF, 0xCC, + 0xE3, 0xC0, 0x31, 0xC3, 0x63, 0xEB, 0x08, 0x21, + 0x36, 0x92, 0xF9, 0xE7, 0x3F, 0xA9, 0xB0, 0xDC + }, + { + 0x10, 0x1C, 0xFB, 0x87, 0x17, 0x59, 0x81, 0x92, + 0x2B, 0x45, 0xB1, 0x2A, 0x96, 0xA9, 0x5D, 0x28, + 0xFB, 0xB7, 0xF4, 0x84, 0xCA, 0x21, 0xC3, 0xC5, + 0x69, 0x40, 0x77, 0xBF, 0xE6, 0xE6, 0x40, 0x07 + }, + { + 0x99, 0x22, 0x15, 0x6D, 0x4A, 0xB3, 0x8F, 0xF7, + 0xF9, 0xBA, 0x71, 0x7B, 0x8C, 0xEE, 0x7A, 0xA4, + 0x63, 0x03, 0xF7, 0xC3, 0xF0, 0xD4, 0xB0, 0x26, + 0xC4, 0x77, 0xC6, 0xAC, 0xC3, 0x83, 0x56, 0x7D + }, + { + 0xD2, 0x4C, 0x99, 0x8F, 0x9A, 0xE6, 0xA0, 0xF9, + 0xFA, 0x14, 0x88, 0xDD, 0xFC, 0x32, 0x7A, 0xE2, + 0x5E, 0x06, 0x66, 0x5B, 0xCF, 0xC8, 0x77, 0x6E, + 0x0F, 0x49, 0xB0, 0xDD, 0xDE, 0xF9, 0x04, 0x62 + }, + { + 0xFA, 0xB7, 0x79, 0xF2, 0x12, 0x7D, 0xB4, 0x88, + 0x7E, 0x3E, 0x14, 0x7F, 0x32, 0x52, 0x0F, 0x3A, + 0x79, 0xB4, 0xD7, 0x92, 0xEE, 0x31, 0x35, 0xFE, + 0x6A, 0x07, 0x0B, 0x51, 0x64, 0x8B, 0x33, 0xB0 + }, + { + 0xFB, 0x54, 0x78, 0x2D, 0x53, 0xEE, 0x69, 0x24, + 0x01, 0x6E, 0xA8, 0x0E, 0x80, 0xBE, 0x91, 0xA4, + 0x1E, 0xCE, 0x99, 0x2B, 0xC9, 0x66, 0x13, 0xB1, + 0xBC, 0x02, 0x18, 0xED, 0x4A, 0xCD, 0x4D, 0xDD + }, + { + 0x26, 0x6E, 0x81, 0x8E, 0xFB, 0x2F, 0x8D, 0x87, + 0xFA, 0xEE, 0xAE, 0x62, 0xAF, 0xD5, 0xF0, 0x9D, + 0x53, 0xA3, 0x31, 0x13, 0x7F, 0x08, 0xC6, 0x20, + 0xF8, 0xE9, 0x51, 0x30, 0x98, 0xBC, 0xDE, 0xCC + }, + { + 0x98, 0xCF, 0xEE, 0x7D, 0x14, 0x25, 0x63, 0x99, + 0xAE, 0x6E, 0xC8, 0xDD, 0x8C, 0xAB, 0x4E, 0xF6, + 0xF9, 0x94, 0xB9, 0x84, 0xA9, 0x0B, 0xCA, 0xE3, + 0xFC, 0xC8, 0x1F, 0x2E, 0x0B, 0x4B, 0x7E, 0x98 + }, + { + 0x19, 0xC6, 0x65, 0x44, 0x1F, 0xC3, 0xAD, 0xB3, + 0x7B, 0x14, 0xC8, 0xA3, 0x0E, 0xD4, 0x9F, 0x98, + 0x49, 0x19, 0xC3, 0x9F, 0xCA, 0x53, 0x40, 0x0C, + 0x1C, 0x9A, 0xEB, 0x85, 0x8D, 0x69, 0x97, 0x5A + }, + { + 0x39, 0xAF, 0x1E, 0xF1, 0x24, 0x0C, 0x4A, 0xC1, + 0x66, 0xB3, 0x19, 0xAE, 0x2C, 0x3C, 0x7C, 0xB9, + 0xC9, 0x3C, 0x01, 0x73, 0xEC, 0x83, 0x4B, 0x85, + 0x5C, 0x61, 0x96, 0x45, 0x88, 0x8A, 0x7A, 0x7F + }, + { + 0x8F, 0xA9, 0x9C, 0xFF, 0x8E, 0xA8, 0xF8, 0x2C, + 0x04, 0x28, 0x6F, 0x62, 0xBF, 0x70, 0x12, 0x0B, + 0xBC, 0x51, 0x8B, 0x2B, 0x26, 0x24, 0x52, 0x34, + 0x8B, 0x59, 0x75, 0x1B, 0x58, 0x17, 0x68, 0xCB + }, + { + 0x57, 0x27, 0x68, 0xE4, 0x46, 0x24, 0xFA, 0x66, + 0xDF, 0xFC, 0x1B, 0xB7, 0xDF, 0x27, 0x5C, 0x3D, + 0xE2, 0xF4, 0xC0, 0x97, 0x15, 0x39, 0xE3, 0xA7, + 0xB0, 0x6A, 0xE0, 0xBF, 0xE2, 0xC9, 0x8D, 0x6E + }, + { + 0xA8, 0x18, 0xF4, 0xCF, 0x54, 0xC6, 0x3A, 0x1B, + 0xD7, 0x92, 0x5A, 0x14, 0xB5, 0xA6, 0x34, 0x7F, + 0x61, 0x2D, 0x53, 0x52, 0x75, 0x5F, 0x36, 0x70, + 0x74, 0x2C, 0x24, 0xE0, 0xBB, 0xC5, 0x6B, 0x69 + }, + { + 0xC4, 0x4E, 0x8B, 0x5C, 0x13, 0xEA, 0xB5, 0x78, + 0x96, 0x83, 0xA9, 0x80, 0xD3, 0x07, 0x99, 0x3C, + 0x1A, 0xD3, 0xC1, 0xB6, 0x7D, 0xE0, 0xAF, 0xB1, + 0xF1, 0x29, 0x05, 0xE3, 0xAA, 0xE3, 0xC8, 0x92 + }, + { + 0xEA, 0x1B, 0x62, 0xCA, 0x41, 0x4E, 0x8B, 0x2F, + 0xB1, 0x03, 0x32, 0x80, 0xA5, 0xDF, 0xC3, 0x1D, + 0x0D, 0x4B, 0xA0, 0xA3, 0x54, 0xFA, 0x72, 0x7A, + 0x9A, 0xA9, 0x78, 0xC8, 0xF1, 0xE5, 0xAE, 0x29 + }, + { + 0x5B, 0x80, 0x91, 0x9E, 0x1C, 0x75, 0xB9, 0x68, + 0x0A, 0xEF, 0x5D, 0xF2, 0xBC, 0xCA, 0x23, 0xA1, + 0x28, 0x75, 0xCF, 0xAB, 0x43, 0x4F, 0xDF, 0x47, + 0xA6, 0xBB, 0x58, 0x56, 0x04, 0x7D, 0x75, 0xA3 + }, + { + 0x45, 0xA3, 0x3D, 0xE3, 0x41, 0xFB, 0x02, 0xD7, + 0x98, 0xC0, 0x8F, 0x97, 0x2F, 0x4B, 0xBF, 0xDA, + 0x0C, 0x7D, 0xA4, 0x49, 0xC3, 0xBB, 0x67, 0x2C, + 0x82, 0xA9, 0xFB, 0x6B, 0x4B, 0x4E, 0x47, 0x47 + }, + { + 0x9C, 0xF4, 0x00, 0x95, 0xD2, 0xFF, 0x6C, 0xC0, + 0x2B, 0xED, 0x6D, 0xE9, 0x72, 0x2D, 0x44, 0x77, + 0x4C, 0x48, 0xF0, 0xAC, 0x4C, 0x91, 0xA7, 0x3E, + 0x8C, 0x99, 0x1B, 0xD3, 0x00, 0x62, 0x43, 0x63 + }, + { + 0xF9, 0x09, 0xD9, 0x8E, 0x6B, 0x5F, 0x09, 0xBC, + 0xD8, 0xFE, 0x7E, 0x5B, 0x37, 0x9B, 0x71, 0x63, + 0x38, 0x9F, 0xFB, 0xDB, 0xB4, 0x09, 0x2F, 0x0A, + 0xF0, 0xA9, 0xFE, 0xE3, 0xD6, 0x49, 0x5B, 0xA2 + }, + { + 0x4E, 0x69, 0x39, 0x24, 0x1B, 0x9D, 0x83, 0xED, + 0x3D, 0xD1, 0x31, 0xC1, 0x8A, 0x5C, 0x5B, 0x1B, + 0x73, 0x66, 0xE5, 0xED, 0xAF, 0x09, 0xDD, 0x2D, + 0x7C, 0xD7, 0x6A, 0x94, 0xCC, 0xC5, 0x3E, 0xB3 + }, + { + 0x69, 0xB7, 0x9F, 0x3D, 0xD5, 0xB7, 0xA1, 0x7E, + 0x6C, 0x89, 0x9A, 0x04, 0x17, 0xB9, 0xE3, 0xB7, + 0x74, 0xB2, 0x1A, 0x7D, 0x90, 0xD5, 0x25, 0x29, + 0x39, 0x1E, 0xD1, 0x47, 0x46, 0x4F, 0xF2, 0x6D + }, + { + 0x10, 0x03, 0xC2, 0xFF, 0xF3, 0xA6, 0xBC, 0x90, + 0xC2, 0xDD, 0xC7, 0xCF, 0x29, 0x9E, 0xFE, 0xE3, + 0xEC, 0x4F, 0xEA, 0x8D, 0x45, 0xBF, 0x6D, 0xC6, + 0xE4, 0xF3, 0xF8, 0xC4, 0xC8, 0x52, 0x83, 0xEC + }, + { + 0x19, 0xCA, 0x8C, 0x2D, 0x62, 0x60, 0xAB, 0x9C, + 0x5A, 0xEC, 0xDF, 0x0C, 0xE2, 0xB9, 0x1D, 0x39, + 0x4B, 0x36, 0x51, 0x40, 0x9B, 0xB3, 0x40, 0xD5, + 0xB4, 0xC1, 0x4F, 0x09, 0x61, 0x35, 0xD0, 0x39 + }, + { + 0xAB, 0xD4, 0x2A, 0xCA, 0xF8, 0xD5, 0x0D, 0xC2, + 0xB0, 0x38, 0xA1, 0x64, 0xB5, 0xC5, 0xC7, 0xD6, + 0x3B, 0xBB, 0xD5, 0x07, 0xFA, 0x02, 0xED, 0xC4, + 0xD7, 0x68, 0xA9, 0xBD, 0x4B, 0x44, 0xD9, 0x65 + }, + { + 0x1C, 0x9C, 0xA8, 0x55, 0x62, 0xAE, 0xB4, 0x90, + 0xE6, 0xC7, 0xF8, 0x02, 0xD1, 0x44, 0x5D, 0xB9, + 0x28, 0xC1, 0x15, 0xBC, 0x09, 0xBB, 0xC6, 0x16, + 0x99, 0xC5, 0x4C, 0x37, 0x66, 0x8F, 0x90, 0x8B + }, + { + 0x3E, 0x25, 0xBA, 0x35, 0x94, 0xC3, 0xAE, 0xD1, + 0xF8, 0x7D, 0x5E, 0x8A, 0xA2, 0x75, 0xDE, 0x96, + 0x03, 0x56, 0x29, 0x06, 0x44, 0x8B, 0x84, 0x3A, + 0x3F, 0x77, 0xC2, 0x44, 0x7F, 0xCE, 0xD1, 0x02 + }, + { + 0xB1, 0x6A, 0xD6, 0xD9, 0x11, 0x7A, 0xF6, 0x6C, + 0xA7, 0x4C, 0xA3, 0x2F, 0xB8, 0xFE, 0xAD, 0x94, + 0xA8, 0x7A, 0x5C, 0xFA, 0xBC, 0x70, 0x1D, 0x38, + 0x1F, 0x66, 0x23, 0xA4, 0xB7, 0xBC, 0xF3, 0xAE + }, + { + 0x35, 0xC0, 0x02, 0xFB, 0x14, 0xCC, 0x59, 0xF5, + 0x24, 0xFA, 0xB8, 0x78, 0xAE, 0xEF, 0xB8, 0x17, + 0x67, 0xC5, 0xF4, 0x9E, 0xB7, 0xFD, 0x4E, 0x8C, + 0x2E, 0x1F, 0x17, 0x7D, 0x8C, 0x1D, 0xF8, 0xD5 + }, + { + 0xE5, 0xEC, 0x62, 0x3E, 0x5F, 0x65, 0x8B, 0xAF, + 0x18, 0x5C, 0x11, 0xAC, 0x63, 0x9B, 0x01, 0x62, + 0x12, 0x9E, 0x53, 0x66, 0x16, 0x46, 0x77, 0x14, + 0xE9, 0x11, 0x8C, 0x5B, 0x4B, 0x5F, 0x6D, 0xFA + }, + { + 0xA2, 0x25, 0xE3, 0x98, 0xDD, 0xF8, 0xB8, 0xD6, + 0x69, 0x69, 0x5F, 0x42, 0xB2, 0x46, 0x3A, 0xC1, + 0xAD, 0x8B, 0x38, 0xA7, 0x56, 0x51, 0x82, 0xE0, + 0xA1, 0x37, 0x13, 0xB6, 0xB9, 0x66, 0x41, 0xC0 + }, + { + 0x58, 0xD2, 0x63, 0xAC, 0xFA, 0xAB, 0x1E, 0xA6, + 0x2A, 0x22, 0x46, 0x58, 0x26, 0xA1, 0xF2, 0x44, + 0x3E, 0x82, 0xA6, 0x8B, 0x2C, 0x3F, 0xBB, 0xCA, + 0x93, 0x9D, 0xBC, 0xA0, 0x8C, 0xCE, 0xF4, 0x40 + }, + { + 0x27, 0x56, 0xA4, 0x5E, 0x3C, 0x6F, 0xF0, 0x26, + 0x24, 0xE6, 0x33, 0xE3, 0x7E, 0x65, 0x80, 0x22, + 0xEB, 0x33, 0xDC, 0x30, 0x35, 0xB8, 0x95, 0x83, + 0x41, 0x0A, 0xB7, 0x64, 0x33, 0xFF, 0x2A, 0x02 + }, + { + 0x44, 0x4F, 0x47, 0x7A, 0xAE, 0xEA, 0xB1, 0x8C, + 0x0A, 0x64, 0xAC, 0x31, 0x39, 0x94, 0xB7, 0xD1, + 0x9C, 0xA6, 0x84, 0x44, 0x4D, 0xFC, 0x1C, 0x95, + 0x6B, 0xBC, 0x29, 0x1C, 0xAA, 0x68, 0x65, 0x27 + }, + { + 0x52, 0xDA, 0xE9, 0xFF, 0x0A, 0xA6, 0xAB, 0xA6, + 0x0F, 0x49, 0xD4, 0x81, 0xC8, 0xCF, 0xA9, 0x2D, + 0x27, 0x75, 0x13, 0x3C, 0xCC, 0xD2, 0xE2, 0xB8, + 0x6B, 0x47, 0xCF, 0x34, 0x7A, 0x23, 0x72, 0xA8 + }, + { + 0x1E, 0xA3, 0x6E, 0xD7, 0x38, 0x03, 0xAF, 0xD8, + 0xA5, 0xD6, 0x7B, 0x03, 0xA6, 0x9F, 0xEC, 0x3C, + 0xF3, 0xE3, 0x9C, 0xA4, 0xB0, 0xE7, 0x1F, 0xC1, + 0xBC, 0x82, 0x4C, 0x2B, 0x2B, 0xFB, 0x38, 0x2D + }, + { + 0x01, 0x5B, 0xFE, 0x8B, 0x45, 0x5B, 0xDC, 0xC7, + 0x47, 0x40, 0x7D, 0xCB, 0xF0, 0xF0, 0x39, 0xE5, + 0x38, 0xD7, 0xFB, 0x6F, 0x8F, 0x1C, 0xFC, 0x76, + 0x3D, 0x35, 0x51, 0x31, 0xF7, 0x9C, 0x04, 0xA5 + }, + { + 0x7F, 0x4B, 0xEE, 0x08, 0x12, 0xF1, 0x77, 0x61, + 0x58, 0xC7, 0x42, 0xD9, 0x95, 0x64, 0x86, 0x73, + 0x01, 0x4B, 0x53, 0xBF, 0x42, 0x15, 0xD8, 0xF5, + 0xC5, 0x63, 0xD9, 0xAD, 0x3B, 0xD7, 0xCF, 0x8B + }, + { + 0xD3, 0xE6, 0x56, 0x59, 0x42, 0xB2, 0x21, 0x79, + 0xDC, 0x4D, 0x9D, 0x63, 0x36, 0xE8, 0xA5, 0xB8, + 0xB9, 0xE9, 0x1C, 0x28, 0x70, 0xEA, 0xF5, 0xA8, + 0x3C, 0x7D, 0xBD, 0x12, 0xDA, 0xBD, 0x70, 0x7E + }, + { + 0x67, 0xD9, 0xB7, 0x84, 0x8A, 0xA5, 0x58, 0xE0, + 0x0E, 0xDA, 0x7B, 0x3F, 0x21, 0x04, 0xC0, 0x26, + 0xE2, 0xA4, 0xB5, 0xC6, 0x5D, 0xB6, 0x3E, 0x0E, + 0x42, 0xB0, 0x69, 0x2F, 0xF5, 0xFB, 0x87, 0x2D + }, + { + 0xDF, 0x21, 0xE8, 0xA1, 0x59, 0x47, 0x51, 0x4E, + 0x86, 0x4D, 0x08, 0x38, 0xA3, 0xC2, 0x2E, 0xCA, + 0xE0, 0x31, 0xEE, 0xCE, 0x68, 0x64, 0x24, 0xAC, + 0xD5, 0xA6, 0xF4, 0x8A, 0x1E, 0xFD, 0xAB, 0xF7 + }, + { + 0xE1, 0x98, 0x45, 0x85, 0xCB, 0xC3, 0xBB, 0xB3, + 0x65, 0xDC, 0x7E, 0x35, 0xC9, 0x35, 0x15, 0xD0, + 0x0B, 0x5F, 0x87, 0x8B, 0x21, 0x7E, 0xB5, 0x46, + 0xDD, 0x7D, 0x29, 0x91, 0xFF, 0xEB, 0x4B, 0xC9 + }, + { + 0x51, 0x58, 0x4A, 0xEF, 0x86, 0x25, 0xE2, 0x0E, + 0x82, 0x07, 0xCA, 0x83, 0x27, 0xC5, 0x91, 0x6A, + 0x48, 0x3A, 0x07, 0xA1, 0x55, 0x1A, 0x98, 0xF6, + 0x9B, 0x29, 0x3E, 0x08, 0x92, 0x91, 0xB1, 0xF8 + }, + { + 0xF4, 0x42, 0x8F, 0x43, 0xC9, 0xF7, 0x72, 0xE3, + 0x41, 0x6E, 0xBA, 0xAC, 0xBC, 0xD1, 0x80, 0xB2, + 0x35, 0x05, 0x14, 0x71, 0xD3, 0x93, 0xE8, 0x87, + 0x54, 0x35, 0xD0, 0xB3, 0xF5, 0xB9, 0xA8, 0x36 + }, + { + 0xD8, 0x08, 0x5E, 0xC7, 0xB0, 0x12, 0xCA, 0x2D, + 0x70, 0xA6, 0xB6, 0x5C, 0xF4, 0xA2, 0xDA, 0x74, + 0x06, 0xFB, 0x0B, 0x4D, 0x6B, 0x9D, 0xD2, 0x1A, + 0x57, 0xBE, 0x1E, 0x32, 0xD5, 0xBA, 0xE1, 0xEA + }, + { + 0x0E, 0x3B, 0xD4, 0x19, 0x2C, 0xB1, 0xDA, 0xE6, + 0x61, 0xAD, 0x1C, 0xE3, 0x0F, 0xBE, 0xF2, 0x33, + 0x1E, 0x64, 0xA3, 0xF2, 0x8C, 0xFA, 0x9E, 0xDE, + 0xDB, 0xA7, 0x77, 0x3D, 0x09, 0x20, 0x95, 0x28 + }, + { + 0x33, 0xA6, 0x95, 0x9E, 0xA8, 0x32, 0xBA, 0xF7, + 0xE1, 0x4F, 0x6D, 0x42, 0xEA, 0xC1, 0xFA, 0xCA, + 0xEB, 0x91, 0xF6, 0xB7, 0x6E, 0x30, 0x19, 0x4A, + 0x62, 0xB1, 0xAD, 0x37, 0x1C, 0x9A, 0xAE, 0x82 + }, + { + 0x3B, 0x76, 0x87, 0x43, 0x41, 0x96, 0xF0, 0xE9, + 0x3E, 0x88, 0x68, 0x3F, 0x5B, 0x27, 0x1C, 0xA9, + 0x1A, 0x9C, 0x57, 0xB9, 0xBD, 0x39, 0xDF, 0x3D, + 0x2F, 0x36, 0x2D, 0x5A, 0x85, 0x60, 0xB8, 0x70 + }, + { + 0x07, 0xEE, 0x18, 0x4C, 0x58, 0x1E, 0xAC, 0x2F, + 0xD9, 0x70, 0x42, 0xAB, 0xA9, 0xD2, 0x95, 0x41, + 0xB9, 0x97, 0x4C, 0xEC, 0xF1, 0x67, 0xFA, 0xDA, + 0xF5, 0xEB, 0x56, 0x45, 0x64, 0x44, 0x06, 0x38 + }, + { + 0xD5, 0x10, 0x69, 0x36, 0x8B, 0x0C, 0x02, 0xE7, + 0x6B, 0x57, 0x1B, 0xA8, 0x30, 0x07, 0x3B, 0x9A, + 0x8A, 0xE3, 0xFA, 0x8F, 0xD7, 0x7C, 0x10, 0xAA, + 0x07, 0x96, 0x2E, 0x47, 0xBA, 0x9F, 0x72, 0xC6 + }, + { + 0x84, 0x0B, 0x51, 0x10, 0x5B, 0x2E, 0xA6, 0x6A, + 0x9A, 0x47, 0x0B, 0x1E, 0xFF, 0xA4, 0xF3, 0x89, + 0xB3, 0x1C, 0xAD, 0xF6, 0x49, 0x40, 0x62, 0x8D, + 0x33, 0x40, 0x2D, 0x8A, 0x2F, 0x13, 0xF4, 0xFE + }, + { + 0x9E, 0x8B, 0x7D, 0xB8, 0x57, 0x93, 0x3D, 0x08, + 0x7E, 0xDA, 0x7E, 0xE2, 0x0C, 0x2E, 0x36, 0xA8, + 0x26, 0x21, 0x4F, 0xD2, 0xD1, 0xCF, 0x6E, 0x80, + 0xED, 0x1A, 0xF0, 0xA6, 0xF0, 0x73, 0xBB, 0x29 + }, + { + 0x71, 0xF5, 0x5A, 0x02, 0xB5, 0xEC, 0x44, 0x65, + 0x58, 0x1A, 0x94, 0xB2, 0x8A, 0xE8, 0xDD, 0xED, + 0xE3, 0xEE, 0xAF, 0xA3, 0x3C, 0xE4, 0xD2, 0xDC, + 0x62, 0x58, 0xD5, 0xD4, 0x74, 0xF7, 0x8A, 0xC4 + }, + { + 0x8D, 0x67, 0xD3, 0x25, 0x41, 0x88, 0xEC, 0x0F, + 0x14, 0xE3, 0xF0, 0xBE, 0x45, 0xE4, 0x36, 0xFE, + 0xE8, 0x6A, 0x47, 0x11, 0xCD, 0xD2, 0x03, 0x71, + 0xE5, 0x4F, 0x2C, 0x3B, 0x76, 0x96, 0x4A, 0xE2 + }, + { + 0x8D, 0x25, 0x7A, 0xDE, 0x96, 0x0D, 0x7E, 0x66, + 0x80, 0x55, 0x22, 0x83, 0x44, 0x8D, 0x9B, 0x7B, + 0x0A, 0x05, 0x41, 0x28, 0x6D, 0xA2, 0xB4, 0xE4, + 0x87, 0xAA, 0x64, 0xD1, 0xBC, 0xC4, 0x7D, 0x7D + }, + { + 0x43, 0x86, 0xC1, 0xCF, 0xDC, 0x7A, 0x3A, 0xCF, + 0x8C, 0x75, 0x94, 0xD3, 0xE5, 0x1E, 0x1E, 0x8C, + 0xDE, 0x08, 0x42, 0x86, 0xC1, 0xF2, 0xDD, 0xD4, + 0x2B, 0x06, 0x46, 0xE8, 0x92, 0xAE, 0x66, 0x15 + }, + { + 0xA7, 0xA5, 0xB1, 0x58, 0x63, 0x9B, 0xED, 0x1C, + 0x5C, 0x9E, 0xD3, 0x97, 0x8B, 0x07, 0xD9, 0x8A, + 0x28, 0x9A, 0x34, 0x7B, 0x56, 0xD1, 0x37, 0x8F, + 0xDC, 0xF0, 0xFE, 0x24, 0xA5, 0x6B, 0x8F, 0xD0 + }, + { + 0x25, 0xDE, 0x41, 0x9F, 0x0E, 0xEE, 0x6B, 0x68, + 0xD9, 0x56, 0xF2, 0x2F, 0x54, 0x23, 0x51, 0x47, + 0x54, 0x38, 0x73, 0xF2, 0x55, 0x63, 0xB4, 0xFE, + 0xB1, 0x63, 0x50, 0xF2, 0xCA, 0xF5, 0x51, 0x36 + }, + { + 0x15, 0xD0, 0x75, 0xC8, 0x8F, 0x13, 0xF0, 0x2B, + 0x59, 0xEB, 0xFC, 0x87, 0x24, 0xD4, 0xDD, 0xFE, + 0xA5, 0xFF, 0x61, 0x4C, 0x1D, 0xDC, 0x81, 0xB8, + 0xDD, 0x58, 0xB5, 0xE0, 0x1C, 0x2B, 0x38, 0x58 + }, + { + 0x08, 0x76, 0x10, 0xB8, 0xC5, 0x31, 0x8D, 0xF1, + 0x07, 0xA7, 0x4C, 0x1B, 0x6E, 0x04, 0xC6, 0x6C, + 0xE2, 0xAB, 0x22, 0xE4, 0x24, 0x67, 0x45, 0x6A, + 0x45, 0x2B, 0xEB, 0x8D, 0xF5, 0x74, 0x2B, 0x68 + }, + { + 0x06, 0x9D, 0x17, 0x36, 0x94, 0xF9, 0x22, 0x58, + 0xC5, 0xFF, 0x25, 0x04, 0xC7, 0x29, 0x29, 0xF9, + 0xF9, 0x33, 0x42, 0xD4, 0x65, 0x6B, 0x6F, 0x70, + 0x2B, 0x3B, 0xA1, 0x4F, 0x87, 0xCF, 0xF6, 0x09 + }, + { + 0x08, 0x7A, 0x65, 0xE0, 0xF1, 0xAE, 0xE3, 0x81, + 0x1F, 0xB6, 0x7B, 0x11, 0x2C, 0x05, 0x41, 0x8C, + 0xC9, 0xA0, 0xE3, 0x9E, 0xA7, 0x7F, 0xA3, 0xBC, + 0xC8, 0x85, 0x49, 0xA1, 0xF9, 0x5B, 0x83, 0x7F + }, + { + 0xE3, 0xD8, 0x79, 0xDE, 0x9D, 0x55, 0x66, 0x57, + 0x5C, 0x6B, 0x42, 0x69, 0xCC, 0x01, 0xE4, 0xF7, + 0xD0, 0xD5, 0xAD, 0xBE, 0xA8, 0xF6, 0xFE, 0x55, + 0xF4, 0x8F, 0x62, 0x09, 0x9C, 0xCD, 0xDD, 0x63 + }, + { + 0x96, 0xFE, 0x36, 0x85, 0xBD, 0x8E, 0xF3, 0x6A, + 0xA5, 0x13, 0xB6, 0x14, 0xCB, 0x61, 0xAD, 0xE0, + 0x0A, 0x61, 0x46, 0xCB, 0x5E, 0xAC, 0x06, 0x7E, + 0x42, 0x1B, 0xE3, 0x4D, 0x2F, 0xC2, 0x47, 0xB5 + }, + { + 0xA7, 0xFB, 0x95, 0x27, 0x98, 0x40, 0xCA, 0xBB, + 0x6E, 0x47, 0x78, 0xBB, 0x7F, 0x0E, 0x9B, 0x21, + 0x80, 0x6F, 0x4D, 0x2E, 0x7B, 0x4F, 0x64, 0xF9, + 0xE7, 0xBC, 0x64, 0xE7, 0x18, 0xFF, 0x22, 0x09 + }, + { + 0xC6, 0x65, 0x7C, 0x9B, 0x80, 0xC2, 0x19, 0x24, + 0x99, 0x0F, 0x22, 0xC4, 0x41, 0xC5, 0x78, 0xEE, + 0x28, 0xDB, 0xC1, 0x5E, 0xB7, 0xA3, 0x35, 0xA7, + 0x18, 0xCE, 0x2F, 0xDF, 0x25, 0x59, 0xB6, 0x42 + }, + { + 0xCB, 0xDF, 0xE9, 0xD8, 0x0B, 0xE6, 0xB5, 0x5F, + 0x35, 0xD4, 0x28, 0x9B, 0x6D, 0xE2, 0xA8, 0x45, + 0xDA, 0x61, 0xAB, 0x4B, 0x45, 0x2B, 0x53, 0x98, + 0x5A, 0x87, 0xA4, 0xA6, 0xD6, 0xFE, 0xC1, 0xF3 + }, + { + 0x90, 0x46, 0x45, 0xE4, 0xAB, 0x66, 0xE1, 0xE8, + 0xB3, 0x6C, 0xB2, 0x5E, 0xEE, 0xDE, 0xDE, 0x8D, + 0x0D, 0xAE, 0x2D, 0x34, 0x8B, 0x7C, 0xB1, 0xE4, + 0xFA, 0xF6, 0xA2, 0x35, 0x5F, 0xED, 0x64, 0xBF + }, + { + 0x60, 0x93, 0x87, 0x90, 0x12, 0xF6, 0x3A, 0x6B, + 0x15, 0x69, 0xF9, 0xDE, 0xA8, 0xDD, 0x74, 0x4A, + 0x71, 0x76, 0x34, 0x1A, 0xE3, 0x99, 0xCE, 0xF3, + 0xAB, 0x53, 0x09, 0xE9, 0xB6, 0x5E, 0xB6, 0x7E + }, + { + 0x06, 0x14, 0x6E, 0xCB, 0x48, 0x5B, 0x4F, 0x9E, + 0xCB, 0x49, 0x39, 0xA3, 0x68, 0x7C, 0xEA, 0x90, + 0x74, 0xC3, 0xDB, 0x1A, 0xCA, 0x05, 0xF8, 0xFB, + 0xD7, 0xE7, 0x06, 0xD8, 0x2D, 0x54, 0x9F, 0x27 + }, + { + 0x01, 0x1A, 0xF6, 0xA3, 0x55, 0x59, 0xF5, 0xFE, + 0x23, 0xE2, 0x3B, 0xF7, 0xE2, 0xCE, 0x65, 0x9D, + 0x62, 0x59, 0x53, 0x9B, 0xC8, 0x6F, 0x8A, 0x7A, + 0x36, 0xEB, 0x27, 0x07, 0xB3, 0x34, 0xC2, 0x71 + }, + { + 0x3F, 0xF9, 0xCC, 0x48, 0x4F, 0xFC, 0x29, 0xF3, + 0x9F, 0x0B, 0xB2, 0x37, 0xE5, 0xF6, 0x50, 0x25, + 0x72, 0x77, 0xD0, 0x23, 0x75, 0x6A, 0x11, 0xDC, + 0xA4, 0x62, 0xD8, 0x40, 0x86, 0xE5, 0x15, 0xC1 + }, + { + 0x60, 0xCF, 0xF1, 0xD0, 0xD2, 0xDB, 0xD4, 0x58, + 0xE9, 0x9B, 0xE2, 0x1B, 0x63, 0xDB, 0xF4, 0xAA, + 0x58, 0xA0, 0x82, 0x77, 0x1B, 0x74, 0xF3, 0x07, + 0xA4, 0x65, 0x22, 0xEA, 0x7F, 0x9E, 0x6F, 0x21 + }, + { + 0xD6, 0x72, 0xE5, 0xD1, 0x2C, 0x94, 0x10, 0xB0, + 0xDC, 0x6E, 0xC1, 0x72, 0x03, 0x88, 0xCB, 0x4F, + 0x4F, 0xDE, 0x2D, 0x45, 0x9C, 0xB4, 0x34, 0x69, + 0x7B, 0x68, 0xB9, 0x9E, 0x38, 0x70, 0x67, 0x78 + }, + { + 0x5A, 0x08, 0xDD, 0xB0, 0xB9, 0xE8, 0x9F, 0xD5, + 0xD6, 0x12, 0x1C, 0xD8, 0xBA, 0xD4, 0xAC, 0xEA, + 0xCC, 0x99, 0x9B, 0x45, 0xA7, 0x01, 0xB7, 0x2A, + 0x22, 0xCB, 0x9F, 0x55, 0x5D, 0x90, 0x2A, 0xEA + }, + { + 0xFC, 0xFE, 0x65, 0x9B, 0x96, 0xEE, 0x81, 0xC7, + 0x01, 0x94, 0x38, 0xEE, 0x86, 0xEF, 0x8C, 0xBE, + 0x33, 0x7E, 0x71, 0xDF, 0x4C, 0xEB, 0x33, 0x3E, + 0x18, 0x5D, 0xBD, 0x16, 0x6A, 0x0D, 0x63, 0x55 + }, + { + 0x49, 0x4B, 0x21, 0xA2, 0x7A, 0x4A, 0xA0, 0x32, + 0x6F, 0xCF, 0xEC, 0x1A, 0x74, 0x56, 0x72, 0x2A, + 0x53, 0x61, 0x23, 0x78, 0x55, 0xAB, 0x3E, 0x6D, + 0xF6, 0x78, 0xA4, 0xE5, 0x0E, 0xED, 0xCA, 0xD5 + }, + { + 0x13, 0x60, 0x58, 0xBD, 0x32, 0xA0, 0x30, 0x8E, + 0x22, 0x70, 0x2A, 0xF5, 0xE4, 0x5A, 0x5C, 0x08, + 0x1C, 0x80, 0x56, 0x59, 0xB7, 0x24, 0x6C, 0xD1, + 0x6B, 0xD2, 0x3A, 0x43, 0x6A, 0x07, 0xDB, 0x9F + }, + { + 0x4A, 0xE6, 0x5B, 0xBE, 0x52, 0x97, 0x7B, 0xCD, + 0x71, 0x09, 0x2F, 0x3B, 0xB6, 0x29, 0x42, 0xB0, + 0x67, 0xC1, 0xAE, 0x64, 0xA7, 0x2E, 0xEE, 0x4F, + 0x20, 0x32, 0xCE, 0x47, 0x11, 0xE2, 0x77, 0x45 + }, + { + 0x3D, 0x13, 0x99, 0x79, 0x74, 0x58, 0x16, 0x1D, + 0xDB, 0xCD, 0x9A, 0x8D, 0x63, 0x48, 0x5B, 0xA1, + 0xEF, 0xA9, 0x3E, 0x94, 0x9E, 0xA3, 0xE0, 0xC4, + 0x54, 0x08, 0xFB, 0xE5, 0xFA, 0x16, 0x91, 0x2D + }, + { + 0xF8, 0xEC, 0x9C, 0xC2, 0xC9, 0xD2, 0x66, 0xDE, + 0xB4, 0x0F, 0x3E, 0xA1, 0xC9, 0xE0, 0x81, 0x2E, + 0x39, 0xE2, 0xBB, 0x70, 0x69, 0x3E, 0xC5, 0xD4, + 0x92, 0xB8, 0x46, 0x99, 0x1C, 0xD3, 0xE3, 0x26 + }, + { + 0xBE, 0x3E, 0x85, 0xE5, 0x37, 0xC5, 0xF7, 0x88, + 0xCA, 0xDE, 0x0C, 0x2F, 0xF1, 0xF2, 0xB3, 0xEB, + 0x47, 0xA5, 0x42, 0xD8, 0xFD, 0xC6, 0x40, 0x0F, + 0x95, 0x97, 0x71, 0x20, 0xF5, 0xC3, 0xA8, 0x41 + }, + { + 0xEA, 0xE5, 0x02, 0x96, 0xF9, 0xEE, 0x16, 0x30, + 0x82, 0xDD, 0xA8, 0xB5, 0xE3, 0xB3, 0x66, 0x82, + 0xDF, 0x82, 0x7E, 0xEE, 0x35, 0x10, 0x06, 0x3F, + 0x92, 0x2A, 0xDE, 0x03, 0x2A, 0x77, 0x26, 0x4C + }, + { + 0xB1, 0xBA, 0x72, 0x77, 0x9C, 0xDA, 0x91, 0x99, + 0x8A, 0x6D, 0xDE, 0x02, 0x2D, 0xE0, 0x4F, 0x2A, + 0x3B, 0x88, 0x97, 0xB0, 0xFA, 0xEA, 0xF9, 0xAF, + 0xEB, 0x6D, 0xAD, 0x42, 0x89, 0x53, 0xB9, 0xFB + }, + { + 0xC1, 0xA4, 0x10, 0xA0, 0xDC, 0x66, 0xDA, 0x61, + 0x68, 0xCD, 0x78, 0x22, 0x60, 0x92, 0x67, 0x66, + 0xA3, 0xC8, 0x4B, 0x11, 0x39, 0x3B, 0x5B, 0xEB, + 0xDB, 0x56, 0x40, 0x56, 0x87, 0xA1, 0xE8, 0x45 + }, + { + 0x2D, 0x61, 0x3C, 0x25, 0x69, 0xDE, 0x2B, 0x6F, + 0xE6, 0x92, 0xD6, 0x50, 0x81, 0x57, 0x80, 0x43, + 0x8E, 0x25, 0x09, 0xD6, 0xA0, 0x2C, 0x2D, 0xAC, + 0x1A, 0x2F, 0x76, 0xFC, 0x80, 0x8C, 0x02, 0xA6 + }, + { + 0x87, 0xD3, 0xB0, 0xF0, 0x58, 0xAE, 0x8C, 0x3F, + 0x24, 0x8F, 0x03, 0x81, 0xC2, 0x2D, 0x36, 0x57, + 0xDD, 0xEA, 0xF0, 0x33, 0x76, 0x25, 0xA2, 0x66, + 0x4C, 0xFA, 0x59, 0xD2, 0xF3, 0xD3, 0x58, 0x7D + }, + { + 0x9E, 0x1B, 0x20, 0x96, 0x91, 0x7F, 0xB5, 0xF8, + 0x28, 0x86, 0xF9, 0x01, 0x05, 0x58, 0x9A, 0x50, + 0x9D, 0x5C, 0x55, 0xD3, 0x64, 0x23, 0x18, 0xAE, + 0xDA, 0x6D, 0xAA, 0x29, 0x4B, 0x34, 0xBC, 0x64 + }, + { + 0xFF, 0x2E, 0x4C, 0xB0, 0x1F, 0xDB, 0x4A, 0x53, + 0xDC, 0x36, 0xEC, 0x18, 0xA2, 0x37, 0xFD, 0x2C, + 0x83, 0x87, 0x93, 0x53, 0x0D, 0x83, 0x72, 0xED, + 0x79, 0xD6, 0x25, 0x02, 0xE0, 0x65, 0x83, 0x62 + }, + { + 0x0D, 0xD7, 0x5D, 0xA1, 0xF7, 0x17, 0xDB, 0xA9, + 0x76, 0x46, 0x04, 0x20, 0xFA, 0x31, 0xA0, 0x64, + 0x13, 0x0D, 0xF8, 0xB8, 0x1A, 0x87, 0xFC, 0xE9, + 0x59, 0xCE, 0x5D, 0x9D, 0x61, 0x50, 0xCE, 0x54 + }, + { + 0x4D, 0xE3, 0x26, 0xF8, 0xDB, 0x76, 0x28, 0xE6, + 0x74, 0x07, 0x6A, 0xE9, 0x9C, 0x14, 0x51, 0xF7, + 0x83, 0x22, 0x04, 0x10, 0xFB, 0x78, 0x3D, 0xCB, + 0x89, 0xE6, 0x1E, 0x16, 0x28, 0x30, 0x24, 0xBC + }, + { + 0x7D, 0x30, 0x01, 0xE7, 0xF6, 0x9B, 0xFD, 0x7E, + 0x78, 0x4E, 0x10, 0xF1, 0xF9, 0x03, 0xC1, 0xCE, + 0x46, 0xE2, 0xCE, 0x4E, 0xC9, 0x25, 0x0E, 0xB5, + 0x2A, 0xD5, 0xBD, 0xEB, 0x0E, 0x59, 0x4A, 0xB5 + }, + { + 0xFE, 0x79, 0x5D, 0xE2, 0xD7, 0x8F, 0x63, 0xF7, + 0x2F, 0x9C, 0x83, 0x5A, 0x2B, 0x63, 0x51, 0xF5, + 0x23, 0x56, 0x1F, 0x4F, 0xE7, 0xC9, 0x37, 0xC1, + 0xE3, 0x6D, 0xF2, 0x5A, 0x45, 0xCC, 0x6E, 0x2E + }, + { + 0xCD, 0x76, 0x25, 0x09, 0xAB, 0xE5, 0xBB, 0xCB, + 0x67, 0xB2, 0xA5, 0x46, 0x26, 0xC7, 0xAC, 0x0F, + 0x8E, 0x63, 0xD9, 0xB5, 0x91, 0xCE, 0xFE, 0x5E, + 0x17, 0x12, 0xE1, 0xF2, 0x51, 0x53, 0xCF, 0xB1 + }, + { + 0x28, 0x55, 0x95, 0x25, 0xC3, 0xC8, 0xEC, 0x1F, + 0x0B, 0x97, 0xAB, 0x34, 0x58, 0x64, 0x24, 0x56, + 0x1C, 0xE8, 0xD2, 0xD8, 0x7E, 0xE5, 0x7F, 0x9A, + 0x04, 0xC3, 0xB2, 0x4E, 0x40, 0x13, 0xD4, 0x72 + }, + { + 0x88, 0x24, 0x11, 0x53, 0x18, 0x0C, 0xB7, 0xC7, + 0xA6, 0xDE, 0xAF, 0x20, 0x24, 0x21, 0x5A, 0xF1, + 0xE7, 0x04, 0x27, 0x79, 0xB0, 0x05, 0x0A, 0xC2, + 0x9E, 0xBA, 0x98, 0xDE, 0xB4, 0x16, 0x27, 0x6D + }, + { + 0xAD, 0x94, 0x27, 0x30, 0x20, 0xAC, 0x0F, 0x5C, + 0xDD, 0x59, 0xE1, 0x02, 0xBC, 0xA0, 0xD4, 0x17, + 0x6C, 0x9E, 0x16, 0x51, 0x5F, 0xEC, 0x51, 0xA2, + 0xC1, 0x2D, 0x90, 0x05, 0x2F, 0xB7, 0xE8, 0xB4 + }, + { + 0xB5, 0xF6, 0x34, 0x79, 0xD0, 0x89, 0xF0, 0x1C, + 0xAB, 0x44, 0x95, 0xB1, 0xD3, 0xA3, 0x47, 0x3D, + 0x4C, 0xB0, 0xE4, 0x0D, 0x28, 0x58, 0x53, 0x0B, + 0x1F, 0xE5, 0xD6, 0x47, 0xA6, 0x96, 0xAD, 0x86 + }, + { + 0xC5, 0x4C, 0x11, 0x6D, 0xEC, 0xD0, 0x21, 0x36, + 0x99, 0xE4, 0x95, 0x4A, 0xAE, 0xFD, 0xFB, 0x80, + 0xAB, 0x77, 0x16, 0x22, 0x4D, 0xA0, 0xC5, 0x17, + 0xB5, 0xC2, 0xF8, 0x5D, 0xFD, 0xE2, 0x2A, 0x1E + }, + { + 0x0B, 0x68, 0x4A, 0x4C, 0x26, 0x0F, 0x05, 0x1A, + 0x14, 0x78, 0x0C, 0x24, 0x43, 0x8A, 0x12, 0xAC, + 0xDB, 0x0C, 0x94, 0x20, 0xDE, 0x89, 0xFC, 0x3B, + 0x6A, 0xD5, 0xB2, 0x4B, 0x3E, 0x78, 0x1E, 0x69 + }, + { + 0x4B, 0x1A, 0xF4, 0x45, 0x63, 0xD6, 0x92, 0x10, + 0x28, 0x86, 0xFA, 0x01, 0xE8, 0x63, 0x6E, 0x28, + 0x7D, 0xF1, 0x77, 0xC8, 0xD7, 0x87, 0x3A, 0xC6, + 0x9E, 0xD7, 0x0C, 0x3A, 0x62, 0x28, 0xAB, 0x9F + }, + { + 0x88, 0x23, 0x29, 0x1D, 0xBA, 0xDF, 0x1E, 0x99, + 0xA8, 0x78, 0x8F, 0x6C, 0x1C, 0x6B, 0x36, 0x73, + 0x9E, 0x3C, 0x7A, 0xB0, 0x4B, 0xCD, 0x00, 0x56, + 0x4B, 0xE1, 0xEB, 0x1D, 0xB2, 0xEB, 0x0D, 0x7D + }, + { + 0x51, 0x47, 0x31, 0xD2, 0x9C, 0x0F, 0xC3, 0x44, + 0xD3, 0x5D, 0x46, 0xB4, 0x03, 0xDF, 0x58, 0xA7, + 0x3E, 0x2A, 0x57, 0x98, 0x77, 0xE4, 0x94, 0x65, + 0x9A, 0xB9, 0x42, 0x02, 0xF5, 0xCD, 0x91, 0x98 + }, + { + 0x0F, 0xCE, 0xC0, 0x4E, 0x9F, 0x4B, 0xE7, 0xE5, + 0x2D, 0x9F, 0x75, 0xB3, 0xCB, 0xF8, 0x9B, 0x39, + 0xEF, 0x62, 0x88, 0xEE, 0x31, 0x7A, 0xDA, 0x05, + 0x7F, 0xDB, 0xDB, 0xF3, 0x07, 0xFF, 0x46, 0x20 + }, + { + 0x4E, 0xFF, 0x67, 0x6E, 0xE3, 0x8A, 0xC8, 0x4D, + 0x30, 0xF2, 0xCD, 0xB1, 0x09, 0xE8, 0xC0, 0xB5, + 0x6D, 0x39, 0x52, 0x84, 0xE3, 0x99, 0x43, 0x72, + 0x86, 0x64, 0xF4, 0x3D, 0xFA, 0x8C, 0x37, 0x2B + }, + { + 0x73, 0xBD, 0xE6, 0x50, 0xCF, 0xBA, 0x0A, 0xF8, + 0x60, 0xB1, 0xA4, 0xDC, 0xEB, 0x16, 0xB8, 0xA7, + 0x05, 0xD6, 0x48, 0x1B, 0x03, 0x51, 0x96, 0x87, + 0x0F, 0xA0, 0x78, 0xF5, 0xFA, 0x59, 0x0D, 0x87 + }, + { + 0x03, 0xE0, 0x77, 0xB6, 0xE7, 0x75, 0xF1, 0xDE, + 0x46, 0xD2, 0x95, 0x1C, 0x64, 0x6F, 0xA8, 0x46, + 0x4A, 0x57, 0xEB, 0xCA, 0x16, 0x99, 0xDE, 0x0C, + 0x08, 0x2E, 0x64, 0x13, 0xA4, 0xA0, 0x86, 0x62 + }, + { + 0x01, 0xFC, 0x2C, 0x2A, 0x61, 0xFE, 0x4D, 0xF3, + 0xA8, 0x32, 0xED, 0x93, 0xAA, 0xCD, 0x7B, 0xBE, + 0x8A, 0xAB, 0x44, 0x93, 0x41, 0x14, 0xD7, 0x62, + 0x5E, 0x32, 0xBD, 0xDC, 0x1F, 0x66, 0xF5, 0xE4 + }, + { + 0xBF, 0xCC, 0x11, 0xB2, 0x79, 0x0D, 0x67, 0x35, + 0x76, 0x11, 0x86, 0x51, 0x53, 0xC3, 0xCD, 0xCA, + 0x58, 0xE9, 0xF8, 0x8B, 0xD8, 0x47, 0x96, 0xBB, + 0x8E, 0x29, 0x47, 0xFF, 0x65, 0xB2, 0x9F, 0x63 + }, + { + 0x2F, 0x72, 0x07, 0xCF, 0x94, 0x98, 0xEA, 0xF7, + 0x2D, 0xA8, 0x41, 0x12, 0x48, 0x26, 0x0B, 0x54, + 0xA6, 0x5A, 0xD0, 0xEF, 0xCA, 0xDF, 0x5F, 0x95, + 0x14, 0xBD, 0x02, 0xEC, 0x5C, 0xB9, 0x2E, 0x7E + }, + { + 0xE9, 0xD4, 0x1B, 0xCA, 0x4F, 0x3A, 0xAB, 0xBA, + 0x28, 0x83, 0x05, 0x8F, 0x30, 0x3A, 0x98, 0xB7, + 0x1F, 0x7D, 0x73, 0x4E, 0x43, 0xF1, 0xAA, 0x05, + 0x7A, 0x0B, 0x77, 0x87, 0x2A, 0xC3, 0x4B, 0xDC + }, + { + 0xEF, 0xD2, 0x00, 0x77, 0xF4, 0x0B, 0x26, 0xBB, + 0x26, 0x65, 0x4E, 0x4D, 0xC2, 0x11, 0x89, 0xBB, + 0x5C, 0x0C, 0x1F, 0x38, 0x9D, 0xB0, 0x3D, 0xD1, + 0xFB, 0x4B, 0xE3, 0xEB, 0x40, 0x7F, 0xFF, 0x15 + }, + { + 0x49, 0xF7, 0xA9, 0x4E, 0x70, 0x45, 0xB9, 0xC3, + 0x03, 0xFD, 0x89, 0xD4, 0xB3, 0x11, 0x88, 0xF9, + 0x74, 0xD9, 0xEE, 0x97, 0x85, 0x92, 0x6C, 0x1A, + 0x0F, 0x22, 0xFC, 0x5D, 0xE9, 0x55, 0x8A, 0xAC + }, + { + 0xEE, 0x6C, 0xB4, 0x4E, 0x0D, 0x08, 0xCC, 0xF8, + 0x52, 0x48, 0xA6, 0xCB, 0x70, 0x89, 0xBA, 0x1F, + 0x26, 0x11, 0xA0, 0x0E, 0xE4, 0x0D, 0xB6, 0xDA, + 0x29, 0x8B, 0x49, 0xAD, 0xE7, 0xDF, 0x7F, 0xB0 + }, + { + 0x34, 0xA1, 0x8E, 0x31, 0xC7, 0x1E, 0x38, 0x44, + 0xBD, 0x43, 0x76, 0x96, 0x64, 0x84, 0xAC, 0x26, + 0x04, 0x7A, 0x5A, 0x5B, 0x80, 0x9A, 0xF3, 0x00, + 0x81, 0x96, 0xCA, 0x2C, 0xCB, 0x0F, 0x8B, 0xC5 + }, + { + 0xDE, 0x4A, 0xF0, 0xB8, 0x4B, 0x2C, 0xE1, 0xEF, + 0xD2, 0x74, 0x39, 0x32, 0x08, 0xDD, 0xCC, 0x6E, + 0x2C, 0x3E, 0x63, 0x7F, 0x0D, 0x77, 0x4F, 0x1B, + 0x13, 0x85, 0x2D, 0xFF, 0x97, 0x4F, 0x25, 0xB0 + }, + { + 0x3E, 0x4D, 0x51, 0x42, 0x4C, 0x9E, 0x07, 0xBC, + 0x62, 0xFD, 0xE8, 0xEB, 0x8D, 0xAD, 0x45, 0xC9, + 0x45, 0xD5, 0x31, 0xD8, 0x9D, 0xAD, 0x13, 0x88, + 0x22, 0x57, 0x58, 0x6B, 0x8F, 0xED, 0x6E, 0x4D + }, + { + 0x86, 0x09, 0x1A, 0x90, 0xB5, 0x66, 0x7E, 0xFA, + 0xF0, 0x58, 0x65, 0x97, 0x53, 0x6F, 0x7B, 0x52, + 0x7E, 0xAD, 0x27, 0x05, 0x19, 0x0D, 0x0A, 0x7B, + 0xAF, 0x8F, 0xCA, 0x28, 0xA0, 0xFE, 0x5B, 0xC7 + }, + { + 0xF5, 0x4E, 0x02, 0xD6, 0x0F, 0xBA, 0xFA, 0x52, + 0x8F, 0x0C, 0x67, 0xA9, 0xD2, 0xA0, 0x15, 0xA4, + 0x67, 0x63, 0xE9, 0x9A, 0x63, 0x88, 0xA5, 0x46, + 0x1B, 0x57, 0x60, 0x7B, 0x0A, 0x2F, 0x53, 0x63 + }, + { + 0xB2, 0xD0, 0xE3, 0x51, 0x26, 0x5A, 0xDD, 0x46, + 0x71, 0x86, 0xA2, 0x70, 0x4B, 0x98, 0x6B, 0x3B, + 0x02, 0xEB, 0xC3, 0xB0, 0xE0, 0xA5, 0x24, 0xD7, + 0x75, 0x60, 0x8D, 0x74, 0x0D, 0x2F, 0x2E, 0x55 + }, + { + 0x03, 0xAA, 0xCF, 0x65, 0x91, 0x0F, 0x93, 0x8A, + 0xEE, 0xA9, 0x19, 0x9B, 0xA6, 0x79, 0x18, 0xB9, + 0x6B, 0xC1, 0xD3, 0x2D, 0xFA, 0x26, 0x03, 0x3E, + 0x24, 0x3B, 0xA6, 0xFB, 0xC9, 0x42, 0x05, 0x65 + }, + { + 0xD4, 0xBE, 0x89, 0x42, 0x2C, 0xB6, 0x1A, 0x15, + 0xED, 0x08, 0x30, 0xA6, 0xEE, 0x57, 0x35, 0x22, + 0xC6, 0x0B, 0x08, 0x19, 0x40, 0x04, 0x03, 0xE1, + 0x16, 0xD2, 0xAE, 0x2C, 0x8F, 0xE4, 0x91, 0xDC + }, + { + 0x2B, 0x2F, 0x3D, 0x45, 0x5D, 0x27, 0x1C, 0xA7, + 0x45, 0xFF, 0xCF, 0xE7, 0x22, 0x52, 0xA1, 0xBC, + 0xAB, 0x4B, 0xBC, 0x62, 0x57, 0x4E, 0x28, 0x2B, + 0x2D, 0x6E, 0xA1, 0x72, 0x8B, 0xBC, 0xA5, 0xA8 + }, + { + 0x06, 0x03, 0xAE, 0x69, 0x4A, 0x40, 0xCC, 0xB1, + 0xC5, 0xF8, 0xCC, 0x94, 0x42, 0x08, 0x12, 0xD1, + 0x7D, 0xCE, 0x22, 0xDD, 0xB0, 0x43, 0x85, 0xAE, + 0x11, 0x20, 0x4B, 0x42, 0x25, 0x69, 0xE9, 0xB1 + }, + { + 0xF7, 0xAA, 0x95, 0x71, 0x4A, 0x50, 0x69, 0x7E, + 0x94, 0x12, 0x50, 0x04, 0xFF, 0xF7, 0x06, 0x5B, + 0x09, 0x7E, 0x73, 0x62, 0x48, 0x87, 0x14, 0xC1, + 0x7D, 0x85, 0x41, 0x92, 0x25, 0x8F, 0x27, 0x78 + }, + { + 0xCE, 0x6B, 0xF7, 0xAF, 0x35, 0x81, 0x40, 0xA8, + 0x3F, 0xCA, 0x6D, 0x76, 0x6D, 0x95, 0xA8, 0x29, + 0x59, 0xB5, 0xAA, 0xE8, 0xFA, 0xDC, 0x7A, 0xBA, + 0x2B, 0x83, 0x9B, 0x0B, 0x34, 0x37, 0x40, 0x43 + }, + { + 0x78, 0x53, 0x7D, 0xA2, 0xE3, 0x47, 0xE5, 0x15, + 0x28, 0xD6, 0x3E, 0xBC, 0x17, 0x07, 0xDB, 0x5D, + 0xF5, 0xA6, 0x98, 0xB7, 0xF5, 0x09, 0xB7, 0x69, + 0x96, 0x11, 0x75, 0xBF, 0xFB, 0x7B, 0x61, 0x89 + }, + { + 0x9B, 0x60, 0xB4, 0x47, 0xD5, 0x46, 0x68, 0x19, + 0x77, 0x8C, 0xBA, 0x3A, 0x69, 0xF3, 0xED, 0x6B, + 0x19, 0xBB, 0xB9, 0xA3, 0x25, 0x1C, 0xC6, 0xC5, + 0x8B, 0x89, 0xD9, 0x98, 0xCF, 0x1F, 0x81, 0xF4 + }, + { + 0xB2, 0xE4, 0xAC, 0xE1, 0x3A, 0x6A, 0xE2, 0x58, + 0xF7, 0xA0, 0x98, 0x24, 0x85, 0x77, 0x5F, 0x78, + 0xAD, 0x04, 0xB8, 0xF9, 0xC1, 0xBE, 0x8B, 0xAD, + 0xF6, 0x62, 0xE1, 0x85, 0xB3, 0x1D, 0x8C, 0x5C + }, + { + 0x6B, 0x86, 0x26, 0x8D, 0x2E, 0x32, 0x49, 0x12, + 0x9A, 0x5B, 0xBE, 0x76, 0xDC, 0xFB, 0x4A, 0xE2, + 0x52, 0x74, 0xF1, 0xED, 0x90, 0x14, 0x34, 0xD2, + 0x4F, 0x7A, 0x29, 0x86, 0x5D, 0xB8, 0x1C, 0x3A + }, + { + 0x79, 0x76, 0xF6, 0x4F, 0x36, 0x89, 0xD2, 0x66, + 0x06, 0x48, 0xCF, 0xE2, 0x89, 0xF1, 0x88, 0x2E, + 0xFC, 0x16, 0x9B, 0x27, 0xE6, 0x41, 0x1C, 0x0E, + 0x0B, 0x6E, 0xFD, 0x11, 0x39, 0xB0, 0x42, 0x87 + }, + { + 0xEB, 0x8A, 0xCE, 0xDC, 0x18, 0xB2, 0xB6, 0xCC, + 0xD8, 0x83, 0xB8, 0x44, 0x72, 0x35, 0x34, 0x8C, + 0x1A, 0x2B, 0xB5, 0xA2, 0x41, 0xA5, 0xC9, 0x08, + 0xCA, 0xBB, 0x53, 0xF1, 0xC9, 0x99, 0x54, 0x73 + }, + { + 0xA8, 0xEF, 0xB7, 0xF4, 0xB3, 0x87, 0x30, 0x94, + 0xC6, 0xD9, 0x78, 0x5E, 0x34, 0x3C, 0x5F, 0x9F, + 0xFC, 0x16, 0xE0, 0x11, 0x39, 0x6C, 0x1E, 0xDA, + 0xC2, 0xC4, 0xE4, 0x99, 0xCC, 0x0B, 0x0D, 0xA4 + }, + { + 0x69, 0x1F, 0x23, 0x8B, 0x6A, 0x4B, 0x13, 0x58, + 0x1D, 0x5D, 0x66, 0xB9, 0x3D, 0xEB, 0x72, 0xD6, + 0x4E, 0x30, 0xBA, 0xF9, 0xBB, 0xA2, 0x28, 0x7E, + 0xED, 0x8E, 0x56, 0xF6, 0x8D, 0x9A, 0x6A, 0x4B + }, + { + 0x45, 0xBE, 0x69, 0x88, 0x7F, 0x91, 0x93, 0x85, + 0xBA, 0x06, 0x72, 0x5D, 0xBB, 0x71, 0x4E, 0x74, + 0x0D, 0x3E, 0x72, 0x03, 0x1B, 0x93, 0x22, 0xA1, + 0x5E, 0xF0, 0xAE, 0x94, 0x5B, 0xE1, 0x4F, 0x3E + }, + { + 0x99, 0x98, 0x50, 0x43, 0x1A, 0xD9, 0x8D, 0xC3, + 0x2A, 0x2A, 0x5A, 0xD2, 0x7E, 0xC4, 0x49, 0x9E, + 0x0B, 0x21, 0x04, 0x0F, 0x4D, 0xAE, 0x10, 0x81, + 0x5D, 0x77, 0x54, 0xC4, 0x96, 0x1E, 0xB8, 0x61 + }, + { + 0xA5, 0xFC, 0x03, 0x9C, 0xFD, 0x97, 0xDF, 0x7C, + 0x10, 0x5F, 0xBB, 0x0D, 0x06, 0x99, 0xD4, 0x1F, + 0x19, 0x7B, 0x97, 0xBB, 0x1B, 0x5C, 0x0D, 0xAF, + 0x1A, 0xF4, 0x58, 0x87, 0xF8, 0x88, 0x08, 0xF2 + }, + { + 0xDF, 0x31, 0xE4, 0x7B, 0x1A, 0xBB, 0xAE, 0x9E, + 0xFE, 0x53, 0x47, 0x93, 0x5E, 0x3F, 0x8F, 0xCD, + 0xAC, 0x74, 0xD8, 0x64, 0x49, 0x8A, 0x2D, 0x9C, + 0x5B, 0x67, 0x64, 0xB1, 0x36, 0xE0, 0xE5, 0x54 + }, + { + 0xA6, 0x32, 0x59, 0x7A, 0x03, 0xB7, 0x6C, 0xCF, + 0xC1, 0xFE, 0x48, 0x32, 0xBE, 0xD4, 0x84, 0x70, + 0x77, 0xD0, 0xAA, 0xDD, 0xFA, 0x93, 0x14, 0x81, + 0x19, 0x28, 0xDC, 0x57, 0xF2, 0x53, 0x82, 0x8C + }, + { + 0x07, 0x77, 0x3B, 0xF8, 0x77, 0x43, 0x77, 0x99, + 0xA4, 0x29, 0xDA, 0x19, 0x8F, 0xE4, 0x2E, 0xB7, + 0x1E, 0xC2, 0xD6, 0x66, 0xE1, 0x07, 0xE8, 0xE9, + 0xA1, 0xCE, 0x15, 0xEE, 0x51, 0x5D, 0x1C, 0x8D + }, + { + 0x5D, 0xAE, 0x63, 0xEE, 0x7D, 0xEC, 0xFF, 0x76, + 0x16, 0xB9, 0x6A, 0xF6, 0x0C, 0xE8, 0xF9, 0xCE, + 0x26, 0x0F, 0xA5, 0x8E, 0x37, 0x4A, 0xAF, 0x13, + 0x0E, 0x03, 0xF7, 0x16, 0x03, 0x19, 0x16, 0xFF + }, + { + 0xC2, 0xF2, 0x96, 0x74, 0x87, 0xCB, 0x37, 0xBA, + 0x3B, 0xE3, 0x5A, 0x87, 0xCA, 0x30, 0xF0, 0x1D, + 0x74, 0x44, 0x19, 0x1F, 0xBA, 0xF1, 0xF5, 0x1A, + 0xCD, 0x36, 0xF4, 0x2F, 0xD9, 0x00, 0x93, 0xB9 + }, + { + 0x1F, 0xAF, 0x4A, 0x50, 0x37, 0xC8, 0x48, 0x4E, + 0x38, 0xD1, 0xCF, 0x08, 0xCC, 0x10, 0x3E, 0x96, + 0x03, 0x84, 0x3C, 0x03, 0xA7, 0xAA, 0xC0, 0x51, + 0x2D, 0x36, 0x33, 0x12, 0x11, 0x5A, 0xD7, 0x9D + }, + { + 0x8C, 0xCD, 0xBF, 0x81, 0xB9, 0x5B, 0x10, 0xB0, + 0x14, 0x70, 0x0C, 0xB3, 0xD8, 0xD8, 0xC9, 0xAF, + 0x80, 0x33, 0xF4, 0x3B, 0x7B, 0x6F, 0x6E, 0xC3, + 0x34, 0xE0, 0x51, 0x47, 0x3B, 0x79, 0x14, 0x06 + }, + { + 0x2E, 0xBA, 0x3D, 0x53, 0x4F, 0x09, 0x06, 0x34, + 0x01, 0xE6, 0x81, 0x4B, 0x5C, 0x6F, 0x24, 0x9E, + 0x33, 0xC2, 0xAE, 0x23, 0x8B, 0xB6, 0x41, 0x4F, + 0xE6, 0xE6, 0x1C, 0x60, 0x44, 0xA9, 0x24, 0x30 + }, + { + 0x93, 0x33, 0xA3, 0x68, 0x33, 0xED, 0x6D, 0xBD, + 0x23, 0xC7, 0x02, 0xA7, 0x9F, 0xE9, 0x04, 0xC6, + 0x3D, 0x24, 0x71, 0x09, 0xBE, 0xD3, 0x10, 0x37, + 0x97, 0x1E, 0x3E, 0x70, 0x96, 0xDC, 0xB2, 0x05 + }, + { + 0x73, 0xF0, 0x0F, 0x65, 0x7E, 0x21, 0xC9, 0x8B, + 0x6C, 0xED, 0x50, 0x6A, 0x05, 0xD2, 0x04, 0x0E, + 0x5C, 0x1E, 0x66, 0xD0, 0x61, 0xE9, 0xBE, 0x5F, + 0x67, 0xB1, 0x3F, 0x0C, 0x66, 0xD6, 0x04, 0x20 + }, + { + 0xB7, 0xC2, 0x1D, 0x6A, 0xC0, 0x00, 0xC3, 0x05, + 0x20, 0x98, 0xAD, 0xC8, 0x38, 0xA1, 0xF9, 0x4F, + 0x53, 0xE5, 0x39, 0xF2, 0x19, 0xD3, 0xEB, 0x3B, + 0x97, 0x02, 0x58, 0xB3, 0x9A, 0xCD, 0x67, 0x17 + }, + { + 0xD1, 0x98, 0x17, 0x62, 0x05, 0x81, 0xC2, 0x0D, + 0x70, 0x01, 0x2F, 0xA2, 0x0A, 0xF8, 0xD1, 0xF2, + 0x4B, 0x55, 0x37, 0x98, 0xD5, 0xD8, 0xFA, 0x44, + 0xCF, 0x30, 0x47, 0xCC, 0x30, 0x80, 0x21, 0xB3 + }, + { + 0xFB, 0x71, 0xCF, 0x01, 0x94, 0x24, 0x23, 0xD6, + 0x9E, 0xEA, 0x1A, 0x39, 0x70, 0xE9, 0x6C, 0x85, + 0x26, 0xC4, 0xBE, 0x8B, 0x53, 0xBC, 0x16, 0x22, + 0x8F, 0x7D, 0xC1, 0x68, 0xCE, 0xF2, 0x10, 0xBB + }, + { + 0x29, 0xF5, 0xD3, 0xD2, 0xDE, 0xA9, 0xAC, 0xC8, + 0x17, 0x07, 0x20, 0xD0, 0xAB, 0xA3, 0xFD, 0x24, + 0x2F, 0x4D, 0x8B, 0x83, 0x40, 0xDB, 0xE3, 0x29, + 0x5B, 0x64, 0x6E, 0x95, 0xA8, 0x38, 0x2F, 0x43 + }, + { + 0x0D, 0x18, 0x9A, 0x84, 0x53, 0x94, 0x02, 0x45, + 0x1F, 0xA4, 0x0C, 0xAB, 0x40, 0x99, 0xBB, 0x0C, + 0x9A, 0x5D, 0x43, 0xD5, 0xF7, 0x15, 0xEE, 0x07, + 0xA9, 0x25, 0xEB, 0xF8, 0xE0, 0x22, 0x1E, 0x1A + }, + { + 0x2A, 0x32, 0xED, 0x97, 0x99, 0x5E, 0x70, 0xBB, + 0x21, 0x95, 0xCE, 0x2C, 0xB8, 0x2C, 0x3D, 0xC0, + 0xAD, 0xB4, 0x4E, 0x5C, 0xA9, 0xD8, 0xE1, 0x1D, + 0xE2, 0x21, 0x4F, 0xED, 0xCC, 0xAE, 0xE7, 0xB4 + }, + { + 0x49, 0xC4, 0x8B, 0x29, 0x36, 0xA1, 0xCF, 0xB0, + 0xE2, 0x73, 0xFC, 0x8F, 0xCE, 0xB5, 0x34, 0xCC, + 0xC1, 0x41, 0x09, 0xB5, 0x8A, 0xBC, 0x7E, 0x58, + 0x72, 0x96, 0x26, 0xF0, 0x16, 0x56, 0x40, 0xCC + }, + { + 0x28, 0xE7, 0xD9, 0xB0, 0x99, 0xB4, 0xE6, 0x44, + 0x93, 0x8F, 0x69, 0xC3, 0xE1, 0x3B, 0x61, 0x70, + 0xBE, 0x35, 0x44, 0xDC, 0xC9, 0xD5, 0x0E, 0xEE, + 0xD0, 0x42, 0x96, 0x2F, 0x7A, 0xF4, 0x41, 0xA7 + }, + { + 0x2F, 0x63, 0x8A, 0xFF, 0xC4, 0x68, 0x57, 0xD0, + 0xCA, 0x6F, 0x8A, 0x65, 0x7B, 0x2B, 0x88, 0x6C, + 0xC9, 0x06, 0x91, 0x6A, 0x62, 0x36, 0xA0, 0xF3, + 0xEB, 0xAB, 0xFE, 0x01, 0x63, 0x4B, 0x35, 0x48 + }, + { + 0xF9, 0xF7, 0xAD, 0x4F, 0x4F, 0xA0, 0x7A, 0x3B, + 0x0C, 0xE7, 0x3B, 0xB9, 0x2C, 0x7C, 0x37, 0xCE, + 0xF9, 0x98, 0x35, 0x64, 0x6A, 0xC4, 0x78, 0xA1, + 0xC5, 0xC3, 0xE1, 0x7D, 0xDD, 0xEF, 0xBE, 0x0B + }, + { + 0x5A, 0x39, 0xA0, 0xEA, 0x9E, 0xE0, 0x90, 0x51, + 0x49, 0x14, 0x72, 0x0C, 0x74, 0x46, 0xFD, 0xC9, + 0xBE, 0xC2, 0x7C, 0x7F, 0x82, 0xA7, 0xBC, 0x02, + 0x75, 0x4E, 0x47, 0xF2, 0x66, 0xA4, 0x56, 0x84 + }, + { + 0x40, 0xE7, 0x4E, 0x39, 0xC8, 0x22, 0x71, 0x90, + 0x99, 0x1E, 0x99, 0xB5, 0x23, 0x0C, 0x9D, 0xE3, + 0x0C, 0xD1, 0xF5, 0x62, 0xA2, 0x10, 0xA5, 0x9A, + 0x21, 0xF9, 0x8C, 0x98, 0x49, 0xF7, 0x7C, 0xEF + }, + { + 0x6A, 0xA3, 0xCB, 0x6F, 0xE8, 0xA1, 0x60, 0x01, + 0x95, 0x4D, 0x6F, 0x09, 0x5D, 0x9C, 0x7F, 0xF4, + 0x2B, 0xC6, 0xFF, 0xE8, 0xDE, 0x9A, 0x89, 0xBB, + 0x86, 0xF1, 0x8D, 0x8E, 0x14, 0xC4, 0x84, 0x38 + }, + { + 0x07, 0x51, 0x89, 0x23, 0x13, 0x97, 0x22, 0x84, + 0xC7, 0x9A, 0x3F, 0x3F, 0x10, 0xA4, 0x9C, 0x7D, + 0x99, 0x71, 0x73, 0xAF, 0x05, 0x40, 0xEE, 0x3F, + 0x6E, 0x47, 0x61, 0x0A, 0x7A, 0x0D, 0x57, 0x10 + }, + { + 0x69, 0x7F, 0x25, 0x96, 0x63, 0xFF, 0x34, 0xA2, + 0x99, 0x3C, 0x64, 0x13, 0xFB, 0x15, 0xBA, 0xCF, + 0x9F, 0xE6, 0x4E, 0x32, 0xF6, 0xC6, 0xFF, 0x35, + 0x24, 0x92, 0x00, 0x25, 0x18, 0x66, 0x38, 0x35 + }, + { + 0x57, 0x72, 0x4D, 0x38, 0x35, 0xD9, 0xC7, 0xC0, + 0x08, 0x8E, 0xC6, 0xAA, 0xFD, 0xA7, 0x22, 0x73, + 0xFA, 0x6B, 0x82, 0xAF, 0x10, 0xDA, 0x9F, 0xC3, + 0x46, 0xCA, 0xA2, 0x11, 0xC8, 0x47, 0x8C, 0x75 + }, + { + 0x27, 0xE6, 0x39, 0x71, 0x0D, 0x05, 0x61, 0x7D, + 0x1C, 0x32, 0xD8, 0xE0, 0xD0, 0x9D, 0x41, 0xDC, + 0xEE, 0x59, 0xCE, 0x00, 0xC5, 0x8D, 0x8A, 0x20, + 0xEB, 0x55, 0xA6, 0xEB, 0xE2, 0xFF, 0x2C, 0xBD + }, + { + 0x4F, 0xF8, 0x19, 0x87, 0xE0, 0xF9, 0x52, 0xCC, + 0x6E, 0xE6, 0x7E, 0xC9, 0x00, 0xC3, 0xCB, 0x50, + 0xF2, 0xB6, 0x21, 0x1F, 0x9E, 0x1B, 0xB6, 0xE7, + 0xD7, 0x92, 0x7B, 0x01, 0x26, 0xD3, 0x41, 0x90 + }, + { + 0xF5, 0xC5, 0x8B, 0x12, 0xB2, 0x79, 0x09, 0x4B, + 0x14, 0x36, 0x8E, 0x98, 0xE5, 0xBF, 0xD5, 0x17, + 0xB8, 0xBE, 0x03, 0xFB, 0xE9, 0x3E, 0xCB, 0x51, + 0xFD, 0x51, 0x6F, 0x6E, 0xDC, 0x89, 0xEE, 0x19 + }, + { + 0xE6, 0xA5, 0xDF, 0xF8, 0xE4, 0xE2, 0xC5, 0x18, + 0x87, 0xAD, 0xAD, 0x81, 0xB8, 0x44, 0x76, 0xBF, + 0xFD, 0xBD, 0x0F, 0xBA, 0xBC, 0x4D, 0x74, 0x6C, + 0xE9, 0x3A, 0xF3, 0xF1, 0x10, 0x18, 0x8D, 0x5F + }, + { + 0xB4, 0x2D, 0x36, 0xCA, 0xC6, 0x36, 0xC7, 0x4C, + 0x8E, 0x63, 0x2E, 0x04, 0x6C, 0xA1, 0x08, 0x92, + 0x6C, 0x32, 0x0C, 0x73, 0x74, 0xF2, 0xC4, 0x7B, + 0xDF, 0x70, 0xA0, 0x71, 0xD2, 0x4E, 0x52, 0x9B + }, + { + 0x80, 0x04, 0xF1, 0x3D, 0x8F, 0x24, 0x46, 0x92, + 0xF2, 0xF4, 0xA0, 0x44, 0x52, 0x60, 0x8A, 0x18, + 0x2C, 0xEC, 0x93, 0x06, 0xC3, 0x6B, 0xD4, 0x19, + 0xB6, 0x13, 0xF8, 0x26, 0x60, 0x91, 0x1B, 0x0A + }, + { + 0xAE, 0x28, 0x99, 0x4D, 0x64, 0x00, 0xFF, 0xCF, + 0xFD, 0x86, 0xCB, 0x63, 0x04, 0xAA, 0x2C, 0x18, + 0xCB, 0x3B, 0x1F, 0xBA, 0x92, 0x86, 0xFB, 0x2C, + 0xE8, 0x1B, 0x2A, 0x53, 0xAC, 0x79, 0x33, 0x21 + }, + { + 0x07, 0x7D, 0x8A, 0x2C, 0x7D, 0xA1, 0x73, 0x56, + 0xBA, 0x1F, 0x5D, 0x61, 0x23, 0x51, 0x51, 0x1C, + 0xAE, 0x58, 0x05, 0x74, 0x56, 0xDC, 0x87, 0x32, + 0xB9, 0x8B, 0xFC, 0xFE, 0xEC, 0x14, 0xC9, 0xCA + }, + { + 0x89, 0xFF, 0x03, 0xB1, 0x5C, 0xFC, 0x07, 0x0F, + 0xC7, 0x77, 0x16, 0x15, 0x2B, 0x98, 0x1A, 0x0E, + 0x10, 0x09, 0x99, 0x15, 0xD4, 0xB9, 0x9A, 0xBD, + 0x96, 0x2D, 0x96, 0xD5, 0x4C, 0x0A, 0xB6, 0x71 + }, + { + 0x77, 0xFA, 0xB2, 0x78, 0xBB, 0x82, 0xD4, 0x8A, + 0x36, 0x3A, 0x10, 0xD3, 0x32, 0x8A, 0xC3, 0xA9, + 0xA7, 0x0D, 0x22, 0x1D, 0x18, 0x3D, 0xF6, 0x39, + 0xA7, 0xA5, 0x84, 0xE4, 0xF4, 0x60, 0x82, 0x6E + }, + { + 0x9E, 0x43, 0xB6, 0xAB, 0xAB, 0x1D, 0xA8, 0xCF, + 0x69, 0x2A, 0x2F, 0xF2, 0x01, 0x58, 0xE5, 0x72, + 0xC1, 0xB6, 0x0C, 0x77, 0x80, 0xE2, 0x7E, 0x68, + 0x71, 0xC8, 0xC8, 0x7B, 0x5E, 0x22, 0x52, 0x45 + }, + { + 0x8C, 0xFA, 0xFD, 0x5A, 0xFA, 0x0A, 0x2D, 0xE8, + 0x07, 0x63, 0x31, 0xEB, 0xD5, 0xE0, 0xF9, 0xFC, + 0x2A, 0x64, 0x3A, 0xC6, 0xCE, 0x1E, 0x22, 0xD1, + 0x84, 0x00, 0x05, 0x2B, 0x74, 0x46, 0x6F, 0x3D + }, + { + 0x4A, 0x76, 0xDC, 0x6F, 0xD3, 0xC5, 0x97, 0xF1, + 0x3B, 0x4F, 0x81, 0xF8, 0x97, 0xBC, 0x96, 0x5A, + 0xF3, 0x89, 0xF3, 0x1D, 0x1C, 0x86, 0xA4, 0xE0, + 0xC6, 0xC3, 0x1D, 0x2D, 0x2C, 0x15, 0x7A, 0x0E + }, + { + 0xC2, 0x5C, 0x1E, 0xD5, 0xB3, 0x9D, 0x7C, 0x2C, + 0xA6, 0x23, 0xA7, 0xCE, 0x58, 0x56, 0x99, 0x82, + 0x07, 0xB4, 0x8C, 0x8F, 0x4D, 0x78, 0x0B, 0x7D, + 0x2C, 0x65, 0x24, 0xA7, 0x1F, 0x79, 0xDC, 0xCB + }, + { + 0x2B, 0x06, 0x69, 0xFB, 0x54, 0x73, 0x96, 0x0B, + 0x95, 0xF7, 0xD0, 0x2C, 0x8C, 0xC1, 0xE2, 0xB0, + 0x04, 0x1B, 0x53, 0x45, 0x37, 0x68, 0x71, 0x21, + 0x9E, 0x0F, 0xCA, 0x48, 0x81, 0x8A, 0x5F, 0x7C + }, + { + 0xAE, 0xB3, 0xA8, 0x5A, 0x2A, 0x65, 0xBD, 0xAA, + 0x22, 0xA1, 0xCB, 0x9E, 0xA7, 0x04, 0xE2, 0x18, + 0x72, 0x64, 0x08, 0x84, 0x1F, 0x81, 0x66, 0x28, + 0xA2, 0x07, 0x0E, 0x93, 0x45, 0x7F, 0xAD, 0x9B + }, + { + 0xAB, 0xF8, 0x36, 0xA1, 0x09, 0x48, 0xE1, 0xBD, + 0x3E, 0x81, 0x8A, 0xE3, 0xCF, 0x9F, 0x47, 0xA8, + 0xD0, 0xF2, 0xB1, 0xA8, 0x7B, 0x69, 0xE5, 0x8B, + 0x45, 0xA7, 0x50, 0x7B, 0xB0, 0xB0, 0xAF, 0x29 + }, + { + 0x95, 0xDB, 0x9B, 0x81, 0x8F, 0xD8, 0x10, 0x82, + 0xE8, 0x4A, 0x9E, 0x04, 0x85, 0x67, 0x92, 0x3F, + 0xF9, 0x72, 0xAB, 0xC1, 0x13, 0x5A, 0xD3, 0xBC, + 0x8D, 0xE4, 0x7E, 0xFD, 0x4F, 0x29, 0x61, 0xCF + }, + { + 0x56, 0xF5, 0xDE, 0x9B, 0xC0, 0xE4, 0x40, 0xAC, + 0xFF, 0x71, 0x04, 0xD2, 0x5C, 0xE2, 0xB4, 0xA5, + 0x52, 0x82, 0x28, 0xAA, 0x20, 0xB1, 0x4F, 0xC3, + 0x49, 0xD9, 0xBF, 0xE2, 0x5E, 0x42, 0x82, 0x74 + }, + { + 0xFC, 0x84, 0xBA, 0xFC, 0xDE, 0xCE, 0x87, 0x74, + 0x45, 0x35, 0x97, 0x23, 0x95, 0xE9, 0x35, 0x13, + 0x9A, 0xBB, 0x98, 0x43, 0x44, 0xCB, 0xBC, 0xEB, + 0x8E, 0x22, 0x09, 0x04, 0xCC, 0xA8, 0xBC, 0x79 + }, + { + 0x29, 0x4A, 0xC3, 0xFE, 0x98, 0x85, 0x78, 0x8A, + 0xC5, 0x1E, 0x80, 0xF2, 0x78, 0x23, 0x20, 0x62, + 0x3C, 0x7C, 0xC8, 0xFA, 0x3A, 0x46, 0x20, 0x22, + 0xDC, 0xC0, 0x62, 0xAD, 0x25, 0x8D, 0x77, 0x78 + }, + { + 0xB4, 0x3B, 0x8E, 0xD9, 0xDB, 0x71, 0xC9, 0xE5, + 0xF2, 0x17, 0x13, 0xDC, 0x8E, 0x0B, 0x15, 0x3A, + 0x04, 0x93, 0xB0, 0x7A, 0x72, 0xB7, 0xDC, 0xEF, + 0x43, 0x69, 0x2A, 0x5D, 0xEC, 0x3F, 0x0F, 0xA5 + }, + { + 0x7F, 0x2E, 0x88, 0x3B, 0x5C, 0xE2, 0x30, 0x32, + 0x9D, 0x52, 0x76, 0x87, 0xE0, 0x24, 0xAE, 0x0E, + 0x31, 0x69, 0x4D, 0x26, 0x55, 0x38, 0x6A, 0x71, + 0x8C, 0x96, 0x41, 0x4F, 0x7E, 0x61, 0xAD, 0x53 + }, + { + 0xE4, 0x94, 0xAD, 0x76, 0xCC, 0xB7, 0xE0, 0xD2, + 0xE5, 0x0F, 0x6D, 0x61, 0x63, 0xD5, 0xC6, 0x52, + 0x2E, 0x90, 0xDC, 0x62, 0x49, 0x0E, 0x10, 0xFF, + 0x3D, 0xC1, 0xD3, 0x9E, 0x2E, 0xCE, 0x5C, 0x79 + }, + { + 0x57, 0x88, 0x7D, 0xB8, 0x3C, 0x70, 0x85, 0xCC, + 0xB9, 0x0F, 0x16, 0xBF, 0x95, 0xD7, 0xEE, 0x94, + 0x53, 0x65, 0xB3, 0x6A, 0x73, 0xB9, 0x05, 0xEC, + 0xDE, 0xD4, 0x48, 0x61, 0xFE, 0x33, 0xD7, 0xEF + }, + { + 0xF8, 0xA9, 0x06, 0x8A, 0xA9, 0x45, 0xC6, 0x6C, + 0x98, 0xBD, 0x6D, 0xEC, 0x18, 0xFC, 0x0B, 0x02, + 0xD7, 0x8F, 0x22, 0x99, 0xB3, 0xED, 0x97, 0x62, + 0xC4, 0x9C, 0xF3, 0xD8, 0x9C, 0xBB, 0x6A, 0xC2 + }, + { + 0xA4, 0x54, 0xE8, 0xF2, 0x7C, 0x72, 0x48, 0xC2, + 0x26, 0xDA, 0xDD, 0xE4, 0x02, 0x36, 0x79, 0xA2, + 0xC5, 0x74, 0x0A, 0x17, 0x14, 0x02, 0xDC, 0x4C, + 0xC1, 0x91, 0xAA, 0x32, 0xB1, 0xC9, 0x82, 0xD4 + }, + { + 0xA0, 0x6C, 0x3E, 0xC6, 0xCC, 0x1D, 0xCE, 0xAA, + 0x3D, 0x85, 0x90, 0x5E, 0x8F, 0x46, 0x13, 0x1F, + 0x11, 0xF8, 0xAA, 0xF5, 0x99, 0xB4, 0x4A, 0xCB, + 0x22, 0x68, 0x4D, 0xE5, 0xAE, 0xFD, 0x50, 0x2E + }, + { + 0x73, 0x1D, 0x96, 0xA4, 0x7A, 0x2A, 0x79, 0xCE, + 0x67, 0xFF, 0xEF, 0x0E, 0xDB, 0x9B, 0x15, 0xD9, + 0x3F, 0xC7, 0x46, 0xC7, 0x3D, 0xC6, 0x29, 0x09, + 0x3E, 0x80, 0xAA, 0x14, 0x85, 0x34, 0x13, 0x55 + }, + { + 0x3E, 0x94, 0x59, 0xA5, 0x68, 0x3F, 0x5C, 0x35, + 0x97, 0xC7, 0x39, 0x73, 0xE3, 0x86, 0x35, 0x27, + 0xDF, 0xA8, 0xEA, 0x90, 0x05, 0x0C, 0x59, 0xA0, + 0x60, 0x05, 0x9D, 0x72, 0x63, 0x32, 0xF1, 0x25 + }, + { + 0x93, 0x8C, 0xCD, 0xC1, 0x0A, 0xD5, 0x3A, 0x9C, + 0x04, 0x85, 0x53, 0xD1, 0x93, 0x31, 0x06, 0xA0, + 0x0D, 0x68, 0xAB, 0x94, 0x99, 0xBE, 0x46, 0x4B, + 0x88, 0x63, 0xB6, 0x1C, 0x63, 0xBC, 0x7E, 0x3E + }, + { + 0x3B, 0x48, 0xA2, 0xAB, 0x4C, 0xA5, 0x4A, 0xC3, + 0xE6, 0x53, 0x3B, 0x51, 0x16, 0x70, 0x1F, 0x43, + 0x46, 0x32, 0x18, 0x95, 0x66, 0x6C, 0xA5, 0x67, + 0xED, 0x80, 0x70, 0xA1, 0x4B, 0x3E, 0x7C, 0x68 + }, + { + 0x4A, 0x04, 0xC5, 0x3F, 0x5C, 0xDF, 0x2C, 0xA5, + 0xC1, 0x47, 0x73, 0x00, 0x3A, 0xF3, 0x3C, 0x2B, + 0x4F, 0x91, 0xFB, 0x78, 0xF6, 0x85, 0x6E, 0xF7, + 0x87, 0x3F, 0xD0, 0xCE, 0xAF, 0x71, 0x71, 0x53 + }, + { + 0x81, 0x43, 0x05, 0xBF, 0xF1, 0x42, 0xAA, 0x7B, + 0x45, 0x92, 0x4C, 0x97, 0x62, 0xA2, 0x12, 0x0E, + 0x14, 0xAA, 0x61, 0x97, 0x38, 0x37, 0x00, 0xF1, + 0xEA, 0xAD, 0xEA, 0x34, 0x2C, 0x2A, 0x1F, 0xE9 + }, + { + 0x41, 0xDB, 0x1E, 0xFE, 0x9F, 0x58, 0xFA, 0x99, + 0x21, 0xEA, 0x16, 0x43, 0x40, 0x6B, 0x03, 0x30, + 0xB7, 0xC4, 0xE7, 0xF2, 0x4D, 0xE6, 0x3C, 0x6F, + 0x13, 0x7E, 0x8C, 0xA2, 0xC0, 0x69, 0xE9, 0xA0 + }, + { + 0xD6, 0xE4, 0x41, 0xA5, 0x71, 0xB2, 0x8F, 0x6E, + 0xBE, 0x32, 0xDE, 0xE2, 0xA8, 0x2B, 0xF2, 0x6A, + 0xD2, 0x87, 0x70, 0xED, 0x77, 0x95, 0xC4, 0x0C, + 0x0F, 0xA0, 0x30, 0xFD, 0x72, 0x4C, 0x9D, 0x38 + }, + { + 0x39, 0x02, 0x26, 0x94, 0x57, 0xF8, 0x2A, 0x2C, + 0x14, 0x14, 0x90, 0xBB, 0x21, 0x63, 0x56, 0x5C, + 0xFA, 0x0B, 0x49, 0x37, 0x3F, 0xC8, 0x58, 0x8E, + 0x7E, 0x17, 0x99, 0x7A, 0x45, 0xD9, 0x5F, 0xF3 + }, + { + 0x90, 0x52, 0x51, 0x86, 0x31, 0xB5, 0x7F, 0x9C, + 0xC6, 0x50, 0x92, 0xF1, 0x3F, 0x9E, 0x41, 0x95, + 0x89, 0x88, 0x75, 0x68, 0xE6, 0xBA, 0x47, 0x00, + 0x9A, 0x69, 0x38, 0xC9, 0xDE, 0x7A, 0x44, 0xDE + }, + { + 0xB2, 0x22, 0x01, 0x04, 0x89, 0x0D, 0x45, 0xFC, + 0x95, 0x36, 0xFE, 0x16, 0x11, 0x2D, 0x5F, 0x46, + 0xBF, 0xB2, 0x91, 0x0B, 0xAE, 0xB4, 0xDB, 0x2A, + 0x0F, 0x3C, 0x7C, 0xD7, 0xCB, 0x8B, 0x6A, 0x96 + }, + { + 0x09, 0x1C, 0x1A, 0x36, 0xD6, 0xED, 0xDE, 0x11, + 0x8A, 0xAE, 0x7F, 0x91, 0x5D, 0xB9, 0xA4, 0x60, + 0x59, 0x49, 0x2F, 0x26, 0x71, 0x45, 0xCA, 0x30, + 0xD3, 0xC1, 0xD9, 0x65, 0x3C, 0x24, 0x1B, 0x65 + }, + { + 0x70, 0x02, 0x83, 0x51, 0x42, 0x98, 0x09, 0xB4, + 0xFB, 0xEC, 0xCF, 0xEC, 0x50, 0x43, 0xE0, 0x7F, + 0x8D, 0x93, 0xDF, 0x42, 0xF4, 0xB5, 0x0C, 0x21, + 0xD2, 0xD6, 0x61, 0x0B, 0x5C, 0x6A, 0x9B, 0xB0 + }, + { + 0x6A, 0x46, 0x1C, 0x77, 0x5C, 0x66, 0x36, 0x92, + 0x51, 0xAE, 0x0F, 0xDB, 0x51, 0x99, 0xAF, 0x57, + 0x73, 0x02, 0x7B, 0xEF, 0x6A, 0xFE, 0x1F, 0x16, + 0xB1, 0x58, 0xDD, 0x18, 0x17, 0x36, 0xD9, 0xCD + }, + { + 0x69, 0x0F, 0x42, 0xAD, 0xB1, 0xDD, 0x98, 0x7D, + 0xA8, 0x05, 0x43, 0x0C, 0xA2, 0xEA, 0xF9, 0x18, + 0x74, 0x61, 0x28, 0x8E, 0xD5, 0x62, 0xFD, 0x68, + 0xB7, 0x63, 0x54, 0x8F, 0x65, 0x00, 0xD1, 0x38 + }, + { + 0xE0, 0x38, 0xDA, 0x1B, 0xC9, 0x49, 0xD1, 0x77, + 0x44, 0x87, 0xC1, 0xE2, 0x45, 0xB0, 0x02, 0xB9, + 0xEB, 0xD7, 0xA9, 0x04, 0xAD, 0xB7, 0x92, 0x04, + 0x80, 0x67, 0x5D, 0x00, 0x90, 0xF1, 0x82, 0x7E + }, + { + 0xF9, 0x8E, 0x08, 0xCE, 0x00, 0xDD, 0xDE, 0xBA, + 0xDA, 0x01, 0x0E, 0xC0, 0x09, 0xAB, 0x71, 0x8F, + 0x6B, 0xD5, 0xAC, 0x82, 0x44, 0x68, 0x2B, 0x30, + 0x0A, 0xE7, 0x21, 0x81, 0xF8, 0x50, 0xBB, 0xF8 + }, + { + 0xEE, 0x3A, 0x90, 0xDD, 0x73, 0x62, 0xF8, 0xBB, + 0xE0, 0x83, 0xA1, 0x1D, 0x6D, 0x76, 0xC7, 0x66, + 0x54, 0x63, 0xED, 0x4C, 0xB9, 0x83, 0xA8, 0x3E, + 0xA6, 0xA5, 0x63, 0xA2, 0xB1, 0x9D, 0x41, 0x9C + }, + { + 0xC1, 0x33, 0x0B, 0x75, 0xA2, 0x52, 0x5A, 0x62, + 0x67, 0x88, 0x32, 0x8C, 0x9F, 0x59, 0x3D, 0xA7, + 0xD9, 0x05, 0xC6, 0xA1, 0x70, 0xB4, 0xE6, 0x2F, + 0xB2, 0x5C, 0x31, 0x5C, 0xCB, 0xC9, 0x1C, 0x73 + }, + { + 0xA2, 0x5C, 0x18, 0xD1, 0xA9, 0x08, 0x75, 0xB9, + 0x36, 0xA8, 0xCD, 0x5D, 0xE5, 0x18, 0x09, 0xC2, + 0xBB, 0xDD, 0xF6, 0x74, 0x70, 0xAB, 0x5A, 0x10, + 0x40, 0xB1, 0xA2, 0x1D, 0xB5, 0xC2, 0x67, 0x3E + }, + { + 0x85, 0xE9, 0xE2, 0xBD, 0xB5, 0xD2, 0x61, 0x19, + 0x3A, 0x74, 0xC2, 0xE5, 0xBD, 0xC7, 0xD6, 0xB5, + 0x62, 0x60, 0x27, 0xD3, 0xEB, 0x16, 0xB5, 0xA2, + 0x3B, 0xFA, 0x85, 0xD4, 0x99, 0xDA, 0x8F, 0x7A + }, + { + 0xD3, 0xF6, 0x9E, 0xC4, 0xCD, 0xA1, 0x8B, 0xFE, + 0x3A, 0x3F, 0x29, 0x40, 0xB4, 0x48, 0xE9, 0x89, + 0x14, 0x65, 0xF1, 0x70, 0xF9, 0xF4, 0x58, 0x42, + 0x17, 0xA3, 0x71, 0x44, 0x7D, 0xB5, 0xE6, 0x1D + }, + { + 0x13, 0x8F, 0x23, 0xB1, 0xFC, 0x08, 0xC0, 0xF0, + 0xD5, 0x75, 0x0B, 0xB8, 0xFE, 0x84, 0x50, 0x38, + 0x26, 0x2A, 0x33, 0xB8, 0x6B, 0xFA, 0x90, 0x40, + 0x1F, 0xAD, 0xB5, 0x98, 0x7D, 0x73, 0x7E, 0xEF + }, + { + 0xD5, 0x59, 0xBB, 0x4B, 0x2F, 0x35, 0x51, 0xEB, + 0x6D, 0x5F, 0x21, 0x17, 0x1B, 0xEB, 0x9E, 0x82, + 0xF6, 0x14, 0x0C, 0xD9, 0x74, 0x04, 0x08, 0x3A, + 0x9B, 0x9E, 0xBE, 0xBF, 0x9F, 0x03, 0xD4, 0x60 + }, + { + 0xCD, 0x4D, 0x90, 0xCD, 0x74, 0x8A, 0xCD, 0xC9, + 0x12, 0xF4, 0x88, 0xA4, 0xBA, 0x11, 0xD0, 0xC7, + 0xF7, 0xE0, 0x20, 0x81, 0xF1, 0xBA, 0x54, 0xBA, + 0xC3, 0xAC, 0x68, 0x5A, 0xFE, 0xC4, 0x56, 0x1B + }, + { + 0xF1, 0xFB, 0x90, 0xF8, 0x51, 0xC0, 0x8A, 0x06, + 0xCF, 0x17, 0x4C, 0xA9, 0x23, 0x49, 0x34, 0x90, + 0x5D, 0x86, 0xD2, 0x1E, 0xA7, 0x17, 0x4C, 0x54, + 0x0D, 0x1C, 0x9E, 0x09, 0xA4, 0xDB, 0x92, 0x0C + }, + { + 0x46, 0x62, 0x60, 0x1F, 0xB0, 0xAD, 0xDD, 0x63, + 0x93, 0xC0, 0x99, 0x58, 0x18, 0xDB, 0xC3, 0x13, + 0xDE, 0x5E, 0xCC, 0xB3, 0x69, 0x3E, 0xE5, 0xD5, + 0x11, 0xFE, 0xB6, 0x56, 0x81, 0xE8, 0x09, 0xDB + }, + { + 0x10, 0x40, 0xA3, 0xD8, 0xEA, 0x57, 0xD1, 0x19, + 0xF0, 0xAC, 0xD1, 0x66, 0x96, 0x15, 0x59, 0x5E, + 0xF2, 0x01, 0xBB, 0x5F, 0x9A, 0x76, 0x04, 0xBF, + 0x3A, 0xFA, 0xE8, 0x5F, 0x80, 0x08, 0x26, 0xA8 + }, + { + 0xEC, 0xF8, 0xA2, 0x7C, 0x09, 0x87, 0x96, 0x83, + 0x9B, 0xDE, 0x9E, 0x99, 0x46, 0xC9, 0x26, 0xE9, + 0x66, 0x1D, 0x81, 0x32, 0xCD, 0x9C, 0xB8, 0xE6, + 0xF1, 0xF5, 0x37, 0xCC, 0xA4, 0x35, 0xD2, 0xFE + }, + { + 0xA5, 0x0A, 0xC1, 0x27, 0x63, 0xA0, 0x34, 0x9F, + 0x91, 0x0A, 0x24, 0xBD, 0x70, 0xD8, 0xD2, 0x2A, + 0xDA, 0xEE, 0xF2, 0x22, 0x59, 0x4E, 0x23, 0x3F, + 0xAD, 0xC4, 0xBE, 0xDD, 0x32, 0x39, 0xC3, 0x8B + }, + { + 0xB7, 0x83, 0xFE, 0xA2, 0xCC, 0xEA, 0xFF, 0x1A, + 0x1D, 0x53, 0xEC, 0x96, 0x7B, 0x26, 0x60, 0xAD, + 0x84, 0xE3, 0xDD, 0xA6, 0x50, 0x47, 0xEF, 0xEF, + 0xF8, 0xCB, 0x3F, 0x65, 0xFF, 0x86, 0x9B, 0x82 + }, + { + 0xBB, 0xA9, 0x7D, 0x03, 0xA9, 0xC0, 0xDD, 0xBA, + 0x6C, 0xAA, 0xFF, 0xB8, 0x4A, 0x74, 0x77, 0x2C, + 0x9A, 0xAA, 0x76, 0xD0, 0x47, 0xAD, 0xD7, 0xF2, + 0x14, 0xFB, 0x39, 0x93, 0xFB, 0x41, 0xFD, 0x59 + }, + { + 0x20, 0x4B, 0xC6, 0x1E, 0xE4, 0xAE, 0x80, 0x8A, + 0x7F, 0x8D, 0x82, 0x13, 0xDB, 0x58, 0x2B, 0x20, + 0x6B, 0x7C, 0xCF, 0x51, 0x47, 0xC9, 0x41, 0x1C, + 0x0A, 0x15, 0x44, 0xF2, 0xA2, 0x0A, 0x6F, 0xF7 + }, + { + 0xBF, 0xDF, 0xF6, 0x01, 0xF0, 0x61, 0x65, 0xBA, + 0xF0, 0x96, 0xD2, 0xA0, 0x24, 0x6B, 0x52, 0x71, + 0xBA, 0x1F, 0xA9, 0x0A, 0xB9, 0x9E, 0xF1, 0x61, + 0xBD, 0x26, 0x0A, 0xE4, 0x69, 0x23, 0x6F, 0x60 + }, + { + 0xE6, 0xBF, 0xAB, 0xEE, 0xE2, 0x39, 0x2A, 0xA9, + 0x87, 0x6A, 0x46, 0x74, 0xEE, 0x37, 0x93, 0xAB, + 0x71, 0x71, 0x03, 0x30, 0xFD, 0x8C, 0x22, 0x52, + 0x5F, 0x9F, 0x49, 0xD7, 0x9D, 0xC4, 0x41, 0xBC + }, + { + 0x79, 0x49, 0x1F, 0x4D, 0xD0, 0xB5, 0x52, 0x54, + 0xA3, 0x69, 0x21, 0x05, 0x40, 0xB0, 0xCA, 0xF8, + 0x62, 0xCD, 0x9F, 0x59, 0x8A, 0x11, 0xDA, 0xFA, + 0x8F, 0x8D, 0x9A, 0x15, 0x19, 0xD1, 0xB5, 0xF3 + }, + { + 0xF5, 0x6D, 0x41, 0xB4, 0xD8, 0x3A, 0xA9, 0xA9, + 0xA9, 0x7C, 0x58, 0xAA, 0xAB, 0x64, 0x33, 0x7D, + 0x8C, 0x47, 0x36, 0xB3, 0x29, 0xD1, 0xF1, 0x6D, + 0xE1, 0x07, 0xF4, 0xD6, 0x02, 0x2A, 0x38, 0xD3 + }, + { + 0x4F, 0xCC, 0x1F, 0xB8, 0xA7, 0xD4, 0xDC, 0xEB, + 0x83, 0xEE, 0x72, 0x18, 0xEB, 0x92, 0xC2, 0xAC, + 0xF4, 0x03, 0xEC, 0x5A, 0x67, 0xC5, 0x8F, 0x3F, + 0x61, 0x9C, 0x99, 0xCA, 0xE9, 0xC6, 0x58, 0x90 + }, + { + 0xB3, 0x6E, 0x4F, 0xE5, 0x58, 0xBA, 0x22, 0x8D, + 0x62, 0xB7, 0x62, 0xB6, 0xD6, 0xB0, 0xA7, 0x11, + 0x07, 0x3E, 0x8B, 0x0C, 0x76, 0x47, 0xD4, 0xF8, + 0xE5, 0x7F, 0x53, 0x97, 0xAD, 0xDE, 0x08, 0x22 + }, + { + 0xEB, 0x8C, 0x7B, 0x40, 0x3F, 0xB8, 0x1C, 0x33, + 0x16, 0x7C, 0x9D, 0x52, 0x84, 0x60, 0x76, 0x6F, + 0x61, 0x9C, 0xC6, 0x5D, 0xA6, 0xD9, 0xC7, 0xD2, + 0x43, 0xBB, 0x76, 0x17, 0x57, 0x30, 0xB3, 0x00 + }, + { + 0x1D, 0xE1, 0x04, 0xB1, 0x58, 0x27, 0xDE, 0xE9, + 0x38, 0x00, 0x0A, 0x47, 0x94, 0x46, 0xAB, 0x4E, + 0x07, 0x66, 0xDA, 0x1A, 0x53, 0x82, 0xD1, 0x06, + 0x8B, 0x28, 0x5D, 0x0A, 0x88, 0xC8, 0x89, 0x05 + }, + { + 0xBF, 0x99, 0x6D, 0x6B, 0x51, 0xA2, 0x7B, 0xCB, + 0x6C, 0x89, 0xE1, 0xC7, 0x24, 0x08, 0x93, 0x92, + 0x89, 0x9A, 0xE7, 0x7D, 0x90, 0xC6, 0x27, 0x57, + 0x78, 0x7E, 0xFE, 0x3A, 0x43, 0xBE, 0x65, 0xA5 + }, + { + 0xF6, 0x28, 0x5E, 0x0F, 0xBB, 0xF6, 0x69, 0x8B, + 0x55, 0xAE, 0xA1, 0x08, 0x3D, 0x92, 0x22, 0x9C, + 0x99, 0xDE, 0xAC, 0x0E, 0xA8, 0x1B, 0xE6, 0x63, + 0xBA, 0x64, 0x0F, 0x35, 0x28, 0x86, 0x7C, 0x3E + }, + { + 0xDA, 0x89, 0xEB, 0xA6, 0x57, 0xFF, 0xA0, 0x4C, + 0xF6, 0x6E, 0xA6, 0xA3, 0xD7, 0xE0, 0x1C, 0xAA, + 0xFB, 0xB4, 0x53, 0x2E, 0x3E, 0x91, 0xAC, 0x7A, + 0x27, 0xC5, 0xEB, 0x2F, 0x23, 0xAD, 0x96, 0xEB + }, + { + 0x89, 0xE7, 0x35, 0xA8, 0x60, 0x2D, 0xE5, 0xC4, + 0x29, 0x22, 0x21, 0xDD, 0xA7, 0x01, 0xC5, 0x67, + 0x16, 0xFB, 0x5C, 0xD1, 0x73, 0x18, 0x35, 0xA4, + 0x46, 0xC2, 0xAC, 0x43, 0xA3, 0x1D, 0x7D, 0x47 + }, + { + 0xF3, 0x67, 0x2B, 0xFE, 0xFD, 0x37, 0x45, 0x4D, + 0xB8, 0x56, 0x70, 0x5B, 0x67, 0x14, 0x58, 0x7B, + 0x53, 0x43, 0x9B, 0xDB, 0x6A, 0xAD, 0xC5, 0x2B, + 0x2A, 0x26, 0x16, 0x08, 0x9F, 0xC7, 0xBF, 0x77 + }, + { + 0x34, 0xBA, 0x03, 0x3C, 0x63, 0x4C, 0x4A, 0x14, + 0x78, 0xAF, 0xCF, 0xB3, 0x83, 0x73, 0x25, 0x05, + 0x0B, 0x98, 0xA1, 0xB8, 0x04, 0x06, 0x3A, 0x70, + 0x6C, 0x36, 0xC9, 0x50, 0x66, 0xB4, 0xF6, 0x8A + }, + { + 0xA8, 0x9C, 0x1A, 0x3C, 0x3B, 0x3A, 0x08, 0x74, + 0xED, 0x31, 0xF7, 0x57, 0x01, 0xA2, 0x4D, 0xE2, + 0x03, 0xF0, 0x4D, 0x7D, 0xCE, 0x77, 0x4C, 0x8A, + 0xC7, 0xEB, 0xC3, 0xAB, 0x5F, 0x37, 0xCF, 0xD9 + }, + { + 0x19, 0x73, 0x88, 0x9C, 0xAE, 0xCE, 0xA4, 0x13, + 0x71, 0x95, 0xEC, 0x1F, 0x52, 0x1A, 0x05, 0xDB, + 0x42, 0x2C, 0xCF, 0xD9, 0x92, 0x4F, 0x6B, 0xE9, + 0xCB, 0x10, 0x62, 0xA3, 0xD2, 0x7C, 0x80, 0x3A + }, + { + 0xF0, 0x4B, 0x9F, 0x4E, 0xBA, 0xBD, 0xA4, 0xF3, + 0x25, 0x59, 0x84, 0x54, 0x97, 0xCB, 0x2C, 0x79, + 0x9A, 0x7B, 0x77, 0x98, 0xEA, 0x35, 0x14, 0xE9, + 0x52, 0x49, 0x07, 0x2C, 0x0A, 0xEE, 0xD0, 0xA0 + }, + { + 0x32, 0x66, 0x9B, 0xEB, 0x10, 0x48, 0x70, 0x7A, + 0x1C, 0xB1, 0x92, 0x36, 0x44, 0xCA, 0xFE, 0x91, + 0x47, 0xA9, 0x45, 0x37, 0xDC, 0xA4, 0x0C, 0x1C, + 0x69, 0x71, 0xC0, 0xD7, 0x9F, 0xEB, 0x70, 0xCB + }, + { + 0x40, 0xED, 0x59, 0xCC, 0x9F, 0x72, 0x44, 0x96, + 0xFC, 0xAC, 0x34, 0xC9, 0x22, 0x51, 0xF4, 0x36, + 0x82, 0x6C, 0x64, 0xDD, 0xBB, 0xD0, 0x93, 0x80, + 0x1F, 0x7F, 0xF1, 0x81, 0x42, 0xE5, 0xC4, 0x41 + }, + { + 0xA1, 0x2A, 0x94, 0x07, 0x91, 0xC2, 0xBE, 0xD8, + 0x10, 0x3D, 0x0D, 0xF3, 0x95, 0x9A, 0x10, 0xF8, + 0x53, 0x6F, 0x6F, 0xE4, 0x02, 0xA5, 0x46, 0x6A, + 0x43, 0x6C, 0xE2, 0x82, 0xA8, 0x08, 0x3D, 0x61 + }, + { + 0x98, 0xC9, 0x21, 0x82, 0x30, 0x6E, 0xFD, 0x2A, + 0x99, 0x26, 0x29, 0x0C, 0x6D, 0x28, 0x29, 0x97, + 0x83, 0xC0, 0x96, 0x85, 0xD8, 0xD3, 0x94, 0x42, + 0xA3, 0x89, 0x6F, 0xEA, 0x5D, 0x61, 0xE6, 0x4C + }, + { + 0xD2, 0xE2, 0x5D, 0xB5, 0x2E, 0x27, 0x05, 0x3E, + 0x7C, 0xB4, 0xCC, 0x32, 0x37, 0x2C, 0xEF, 0x3B, + 0x54, 0x77, 0x9F, 0xA5, 0x2E, 0xA9, 0xC9, 0x0D, + 0x74, 0x10, 0x50, 0x48, 0xD6, 0x56, 0xCC, 0x1A + }, + { + 0x38, 0x84, 0xD6, 0xD7, 0x1B, 0xC7, 0xC9, 0xB0, + 0x7D, 0xD1, 0x74, 0xE3, 0xAA, 0x26, 0x60, 0x07, + 0xA0, 0x23, 0x5D, 0xF5, 0x55, 0x4E, 0xE2, 0x6E, + 0xA0, 0xBB, 0xB0, 0x41, 0x92, 0x96, 0xC2, 0x60 + }, + { + 0x06, 0xAE, 0xB4, 0x89, 0xED, 0xF3, 0xE4, 0x75, + 0x79, 0x9B, 0xBD, 0x7F, 0x92, 0x21, 0x3F, 0x0A, + 0x00, 0x4B, 0x79, 0x5F, 0x99, 0x3E, 0x04, 0x41, + 0xAE, 0x12, 0x5B, 0x91, 0x8B, 0xA5, 0x82, 0xD7 + }, + { + 0x3D, 0x75, 0x1F, 0x9A, 0x3A, 0x6A, 0x50, 0x52, + 0xF7, 0xC9, 0x51, 0x2E, 0x98, 0xFC, 0xE7, 0xBD, + 0xCA, 0x36, 0x66, 0x18, 0x64, 0x91, 0xC7, 0xF9, + 0x62, 0x7C, 0xFC, 0x5A, 0xA7, 0xAF, 0xAD, 0x3B + }, + { + 0xCD, 0x80, 0x10, 0xC1, 0x65, 0x8B, 0x68, 0x9D, + 0x0C, 0x8C, 0xD5, 0xED, 0x3D, 0x9D, 0x21, 0x54, + 0x1A, 0x53, 0x1B, 0xC4, 0x2D, 0xA0, 0x14, 0xDF, + 0xFB, 0x55, 0xD0, 0x36, 0xD4, 0x1C, 0x7C, 0xED + }, + { + 0x25, 0x20, 0x18, 0xE6, 0x10, 0xCD, 0xA0, 0x04, + 0x50, 0xB9, 0x20, 0xB3, 0x01, 0x7F, 0x7C, 0xC4, + 0xCD, 0x33, 0xF2, 0x05, 0x0B, 0x05, 0x40, 0x3F, + 0x5F, 0x71, 0x61, 0xA9, 0x47, 0x22, 0x39, 0xA4 + }, + { + 0xBD, 0x15, 0x5F, 0xBD, 0x4C, 0xF4, 0x02, 0x6F, + 0xC2, 0x7D, 0xD5, 0x6D, 0xAB, 0x9C, 0x40, 0xD1, + 0xE8, 0xDD, 0x96, 0x0E, 0xE1, 0x54, 0x47, 0xB3, + 0x57, 0x82, 0x48, 0x96, 0x3B, 0x22, 0x4A, 0x80 + }, + { + 0x01, 0x84, 0xF9, 0x05, 0x9D, 0xB1, 0x91, 0x1C, + 0x3F, 0x65, 0x21, 0x0B, 0xAE, 0xF5, 0x35, 0xA5, + 0xE8, 0x93, 0x20, 0x3E, 0x52, 0xDC, 0x66, 0xEF, + 0x59, 0x26, 0x92, 0x89, 0x51, 0x0A, 0xE8, 0x5A + }, + { + 0xD5, 0x6D, 0x60, 0x9A, 0x20, 0x6B, 0x83, 0x81, + 0xA2, 0x4D, 0x20, 0x6D, 0x4C, 0x60, 0x75, 0x62, + 0xA1, 0xC1, 0x5A, 0x47, 0x9C, 0x50, 0xC2, 0x5C, + 0x2F, 0x8E, 0xCC, 0x8B, 0xF6, 0x67, 0x57, 0xD6 + }, + { + 0x0C, 0xAD, 0x6C, 0x38, 0xD8, 0xCA, 0x1F, 0x36, + 0x22, 0x19, 0x39, 0x0B, 0x52, 0x60, 0x4E, 0xAB, + 0x27, 0x04, 0x89, 0x2F, 0xB6, 0x68, 0xB8, 0xB5, + 0x98, 0x31, 0x0B, 0xA1, 0xB0, 0x91, 0x25, 0xB3 + }, + { + 0x8F, 0xD0, 0x5C, 0x01, 0x73, 0xB8, 0x28, 0x65, + 0xA4, 0xB3, 0xD9, 0xE8, 0x15, 0xC4, 0x5A, 0x8F, + 0xE2, 0x22, 0x82, 0x89, 0xBA, 0xEB, 0x47, 0xF9, + 0x93, 0xFF, 0xD0, 0x44, 0x28, 0x58, 0x81, 0x9C + }, + { + 0x78, 0xB0, 0xFE, 0x93, 0x93, 0xD1, 0x3B, 0x25, + 0x53, 0xAC, 0xDA, 0x53, 0xD6, 0x6E, 0x6E, 0x24, + 0xA4, 0x4E, 0x1E, 0x7B, 0xD4, 0x08, 0xF7, 0x5B, + 0xE5, 0x7C, 0xED, 0xE9, 0x3B, 0xC9, 0x07, 0x28 + }, + { + 0xBE, 0x15, 0x98, 0x88, 0x75, 0x3D, 0xFA, 0x93, + 0x97, 0x51, 0xE9, 0xBE, 0x8C, 0xE9, 0x70, 0x52, + 0xF3, 0x7D, 0xEC, 0xCF, 0xE5, 0x4C, 0x00, 0xDB, + 0xE5, 0xFD, 0x43, 0x8C, 0xA6, 0x43, 0x79, 0x6D + }, + { + 0x44, 0xD6, 0x3C, 0x67, 0x6D, 0x7A, 0xF2, 0x13, + 0x08, 0x9A, 0x60, 0x21, 0xCE, 0x3C, 0x79, 0xF7, + 0x36, 0x3D, 0x3E, 0x4D, 0x9A, 0x6E, 0x8E, 0x2C, + 0x2A, 0xC1, 0x77, 0xC6, 0x00, 0xAB, 0x27, 0x47 + }, + { + 0x78, 0x5B, 0xCD, 0x20, 0x69, 0x7F, 0x07, 0x68, + 0xDA, 0x29, 0x11, 0x50, 0xA2, 0xB7, 0x8C, 0xCD, + 0x04, 0xD4, 0x79, 0x5C, 0xA0, 0x2A, 0x23, 0xEC, + 0x76, 0x68, 0xF4, 0xB9, 0xB3, 0xD6, 0xC4, 0x29 + }, + { + 0x63, 0xD7, 0x5A, 0xF8, 0x3E, 0xD3, 0x3C, 0x6B, + 0xC8, 0xB2, 0x51, 0x89, 0xE5, 0xFD, 0x7B, 0x00, + 0xAE, 0xDF, 0x27, 0xF6, 0x00, 0xD0, 0xA8, 0x47, + 0x88, 0xD0, 0x97, 0x78, 0xBA, 0x09, 0x85, 0x5A + }, + { + 0xB0, 0x66, 0xE9, 0xF8, 0x0C, 0xB1, 0xF7, 0xF0, + 0xA4, 0x18, 0x12, 0x00, 0xE0, 0x97, 0x31, 0x1C, + 0xD8, 0x5C, 0x1A, 0xFB, 0xEC, 0xE0, 0x76, 0x25, + 0x39, 0xA8, 0x7F, 0xA2, 0x80, 0xFE, 0xEB, 0x67 + }, + { + 0x42, 0x9D, 0xFA, 0x9E, 0xE7, 0xA1, 0x2B, 0xC0, + 0x91, 0xBE, 0x12, 0xA4, 0x2D, 0xDB, 0xA9, 0x8D, + 0x22, 0x7D, 0xF5, 0x9E, 0x70, 0xE1, 0xB7, 0x74, + 0x16, 0x84, 0x47, 0xCF, 0xB3, 0xC9, 0xD1, 0xD3 + }, + { + 0x20, 0x38, 0x90, 0x7B, 0xFA, 0xBE, 0x12, 0xD9, + 0xF7, 0x3C, 0xCB, 0xEE, 0xDC, 0xAC, 0xA8, 0x33, + 0xA8, 0x21, 0x00, 0x94, 0xAA, 0x17, 0xF6, 0x4D, + 0x2C, 0x66, 0x44, 0x92, 0x86, 0x14, 0x7B, 0x82 + }, + { + 0x91, 0x30, 0x05, 0xB7, 0xA2, 0x79, 0xFC, 0x8F, + 0x36, 0x4E, 0x49, 0x3E, 0xE6, 0x74, 0xFA, 0x43, + 0xD5, 0x47, 0x27, 0xDB, 0xF0, 0xFA, 0x52, 0xCC, + 0x6F, 0xA1, 0x77, 0x61, 0x87, 0xB9, 0x8D, 0x8E + }, + { + 0xA1, 0x4C, 0x35, 0x35, 0x03, 0x68, 0xFE, 0x20, + 0x8D, 0xD0, 0x18, 0xA3, 0x43, 0x3F, 0xA9, 0x72, + 0x6C, 0x38, 0x3A, 0xFF, 0xB0, 0xDB, 0x7F, 0x05, + 0x71, 0x3F, 0x7B, 0xA2, 0x53, 0x0E, 0xD0, 0xEE + }, + { + 0xAF, 0x62, 0x8C, 0xFE, 0xDC, 0xE1, 0x70, 0x10, + 0x0A, 0xA1, 0xDE, 0xF7, 0x7D, 0x4E, 0x5A, 0xF6, + 0x7E, 0xCF, 0xF8, 0x5E, 0xA8, 0x56, 0x39, 0x52, + 0x97, 0x60, 0xD1, 0x4F, 0x98, 0xDF, 0x03, 0x46 + }, + { + 0x12, 0x6F, 0x80, 0x1C, 0x2B, 0xB2, 0xFE, 0xC5, + 0xCF, 0x30, 0x32, 0x92, 0x61, 0x77, 0x5D, 0x23, + 0x88, 0x01, 0x5E, 0xF8, 0xC9, 0xC6, 0x75, 0x22, + 0xF1, 0xA8, 0x1B, 0x4A, 0xFF, 0x2C, 0xD4, 0x5F + }, + { + 0x94, 0xA0, 0xE9, 0x05, 0xEC, 0x9B, 0xA1, 0xA6, + 0x9A, 0x98, 0x67, 0x13, 0x97, 0x05, 0xD1, 0x44, + 0xDA, 0xAA, 0x84, 0xA1, 0xF7, 0x36, 0x9A, 0x2D, + 0xD1, 0x0F, 0xF1, 0xB5, 0x55, 0x6D, 0x81, 0xD5 + }, + { + 0x41, 0xB9, 0x86, 0x6A, 0x87, 0x5A, 0xD7, 0x1E, + 0x51, 0x00, 0xDF, 0x9F, 0xAB, 0x70, 0x2A, 0x21, + 0xBB, 0x21, 0x45, 0x20, 0xC2, 0xD4, 0x6E, 0x8D, + 0x7A, 0xDB, 0x29, 0x4F, 0x7E, 0x8F, 0x29, 0x3D + }, + { + 0xB5, 0x79, 0x1B, 0x19, 0x30, 0x8E, 0x48, 0xA1, + 0x8F, 0x31, 0xC0, 0x16, 0x93, 0x86, 0xA7, 0xB2, + 0x16, 0x6A, 0x7B, 0x13, 0xE4, 0x72, 0x98, 0x5B, + 0x53, 0xEA, 0xB0, 0x5E, 0xBA, 0x1F, 0x23, 0xD3 + }, + { + 0xC0, 0xDD, 0x80, 0xFD, 0x86, 0x57, 0xAC, 0x8A, + 0x3A, 0xB0, 0x64, 0x32, 0x26, 0x9D, 0x29, 0x2C, + 0x11, 0x92, 0x92, 0x76, 0x20, 0x93, 0x48, 0xCA, + 0x15, 0x9A, 0x8C, 0x16, 0x00, 0x9C, 0x16, 0x5E + }, + { + 0x82, 0x87, 0xBE, 0xA6, 0xD3, 0x7A, 0xE1, 0x5C, + 0x35, 0xE7, 0xA1, 0x62, 0x21, 0x40, 0x72, 0x6D, + 0xE0, 0x36, 0xF3, 0x7A, 0x29, 0xCF, 0x73, 0x8A, + 0x55, 0x19, 0x84, 0x37, 0x4F, 0x1C, 0x69, 0x4D + }, + { + 0xA1, 0x69, 0x38, 0x34, 0x7A, 0x4F, 0x46, 0x45, + 0x8F, 0xFA, 0xAA, 0x39, 0xD8, 0xA9, 0xF9, 0xC8, + 0xC9, 0xEA, 0xF6, 0x4D, 0x3E, 0x50, 0xDC, 0x6F, + 0xE6, 0xED, 0xBA, 0xB4, 0x84, 0x6C, 0xF5, 0xF3 + }, + { + 0x91, 0x9E, 0xA7, 0x84, 0x30, 0x3E, 0x7C, 0x60, + 0x3D, 0x89, 0xFC, 0xDD, 0xC3, 0x18, 0x7A, 0x5F, + 0x2B, 0xF4, 0xF8, 0xDF, 0xCD, 0xB6, 0xA4, 0xAE, + 0xE9, 0x5D, 0x1C, 0xFA, 0x20, 0x45, 0x38, 0x59 + }, + { + 0x88, 0x8C, 0x0B, 0xF4, 0x47, 0xD4, 0x55, 0xF4, + 0x74, 0x31, 0xEC, 0x01, 0xDA, 0xB4, 0xB7, 0x42, + 0x2E, 0x9E, 0x08, 0x83, 0xFB, 0xE4, 0xCE, 0xCD, + 0x16, 0xA9, 0x7E, 0x3C, 0xF4, 0x30, 0x56, 0x6E + }, + { + 0xF9, 0x21, 0x27, 0x71, 0xB0, 0x48, 0x56, 0x95, + 0x75, 0x9F, 0x65, 0x54, 0x7D, 0xF3, 0x09, 0x0D, + 0xE8, 0xB5, 0x42, 0x31, 0x10, 0x6D, 0x68, 0xEF, + 0xEB, 0xA2, 0xB4, 0xF6, 0x5E, 0x63, 0x5F, 0x99 + }, + { + 0x80, 0xE9, 0xB7, 0x32, 0x77, 0xD2, 0x46, 0x23, + 0x9F, 0x71, 0x46, 0xE7, 0xAE, 0x55, 0xED, 0xA2, + 0x23, 0x5F, 0x87, 0x35, 0x42, 0x9C, 0xB8, 0xA7, + 0xD8, 0xAE, 0x69, 0xDC, 0x57, 0x4F, 0x11, 0xCE + }, + { + 0x0B, 0x36, 0xF8, 0xD7, 0x52, 0xD9, 0xF2, 0x74, + 0x87, 0x35, 0xC6, 0x60, 0xE0, 0x44, 0xDF, 0x23, + 0xD7, 0x60, 0xFA, 0x49, 0x03, 0x1F, 0xE6, 0xA8, + 0xDA, 0x0C, 0x77, 0x39, 0xED, 0x8A, 0x5F, 0x60 + }, + { + 0xDB, 0xC7, 0xD4, 0x95, 0xF5, 0xE8, 0xBB, 0x30, + 0x3A, 0x57, 0x72, 0xF3, 0x9D, 0x46, 0x3B, 0x97, + 0x3A, 0x28, 0x0E, 0x98, 0x34, 0x2E, 0x9B, 0xFB, + 0x7C, 0x5A, 0x88, 0x27, 0xC7, 0x50, 0xEA, 0x0C + }, + { + 0xE4, 0x2D, 0x76, 0xD3, 0xBB, 0x4B, 0x10, 0xEB, + 0x56, 0x0B, 0x01, 0x0E, 0x5B, 0x45, 0x5E, 0x44, + 0xE1, 0x0E, 0x63, 0x70, 0xA0, 0xF8, 0x68, 0x4E, + 0x91, 0xEE, 0xCB, 0xB2, 0x38, 0x67, 0x67, 0x05 + }, + { + 0xFA, 0xEC, 0x99, 0x56, 0x7C, 0xEE, 0x12, 0x39, + 0xAF, 0x45, 0x38, 0xE9, 0xE9, 0xBA, 0x68, 0x99, + 0xB1, 0xCA, 0xA4, 0x92, 0x72, 0xA1, 0x15, 0x1D, + 0x8F, 0x55, 0x3F, 0xDB, 0x8B, 0x1D, 0x0F, 0xB6 + }, + { + 0xC4, 0xA1, 0xA8, 0x1F, 0x88, 0x04, 0xDD, 0xD6, + 0x8F, 0x9D, 0xC6, 0x82, 0x9A, 0xBF, 0x3B, 0x84, + 0x29, 0x50, 0x6D, 0xC0, 0xC2, 0xCF, 0x46, 0xE5, + 0x0B, 0x2A, 0x83, 0x3A, 0x71, 0x63, 0x6C, 0x67 + }, + { + 0x0B, 0xA6, 0x3F, 0x8C, 0xF3, 0x15, 0x97, 0x1F, + 0x95, 0x3E, 0xC4, 0x32, 0xFD, 0x51, 0x6B, 0xFB, + 0x7F, 0x5F, 0x27, 0x82, 0x15, 0x76, 0x35, 0x53, + 0x2C, 0x27, 0xCC, 0xDE, 0xF8, 0x36, 0xC8, 0xA7 + }, + { + 0x3D, 0xF4, 0x81, 0x36, 0xD5, 0xA1, 0x72, 0x0B, + 0x42, 0xFF, 0xCC, 0x3C, 0x91, 0xF2, 0x43, 0xE4, + 0x84, 0x55, 0x69, 0xA8, 0x6E, 0x94, 0xCB, 0xC0, + 0xB7, 0xF1, 0x85, 0x03, 0x3D, 0x7B, 0xD2, 0x31 + }, + { + 0x4F, 0xF6, 0xC7, 0x65, 0x2A, 0x00, 0x31, 0xC9, + 0x4E, 0x9A, 0x42, 0x8C, 0xB3, 0x04, 0x09, 0x99, + 0xF7, 0xE9, 0x05, 0xBF, 0x75, 0x6F, 0x49, 0x49, + 0xE0, 0x2F, 0x5B, 0xA9, 0xE6, 0x43, 0xAF, 0x29 + }, + { + 0x33, 0x76, 0xFE, 0xE3, 0x81, 0x78, 0x02, 0x0A, + 0x88, 0x57, 0xF3, 0x15, 0xE8, 0x95, 0x8D, 0x02, + 0x1C, 0x31, 0xF4, 0xC6, 0xC9, 0x31, 0x5C, 0x68, + 0x97, 0x7B, 0x98, 0x6E, 0xDE, 0xA2, 0x26, 0x9D + }, + { + 0x50, 0xAD, 0x93, 0x48, 0xA0, 0xE6, 0x95, 0xDB, + 0x41, 0xEB, 0x6F, 0x83, 0xBC, 0xE9, 0xF2, 0x9E, + 0xD4, 0xE4, 0x3F, 0xAE, 0xFB, 0xC5, 0x7B, 0x1F, + 0xAE, 0x1B, 0x70, 0x4A, 0xFA, 0xF1, 0x74, 0x40 + }, + { + 0xF6, 0x35, 0x89, 0x25, 0xF4, 0x62, 0x38, 0x70, + 0x26, 0x5D, 0xC8, 0x59, 0x85, 0xF9, 0x4D, 0x1B, + 0x6A, 0xA1, 0xB7, 0x74, 0x14, 0x2F, 0x5B, 0x6A, + 0xC7, 0x0D, 0x86, 0xAC, 0x0C, 0xD7, 0x69, 0x59 + }, + { + 0x4F, 0x30, 0x38, 0x00, 0x7D, 0x84, 0x41, 0x56, + 0x91, 0xBF, 0x24, 0xE4, 0x3F, 0x35, 0x09, 0x40, + 0xB9, 0x5F, 0x76, 0xED, 0xB5, 0x89, 0x98, 0x45, + 0x01, 0x3E, 0xCA, 0x09, 0x19, 0xDC, 0x2E, 0x1A + }, + { + 0xD7, 0x5A, 0xC9, 0xAD, 0x5E, 0xA8, 0xA1, 0x88, + 0xC2, 0x30, 0xC5, 0xD9, 0xCF, 0x2E, 0x6C, 0x8C, + 0xBC, 0x6A, 0x80, 0x87, 0x98, 0x33, 0x88, 0x0E, + 0x72, 0xA0, 0x56, 0xF7, 0x32, 0xB5, 0x1E, 0x59 + }, + { + 0x94, 0x79, 0xF3, 0x98, 0xD8, 0xCB, 0x8E, 0x38, + 0x41, 0x75, 0xE2, 0xA6, 0x40, 0x42, 0xDD, 0xD0, + 0x61, 0x59, 0x78, 0xCF, 0x84, 0x9C, 0xC7, 0x51, + 0x42, 0x66, 0x32, 0x54, 0x5F, 0x87, 0xD8, 0x3F + }, + { + 0xAD, 0xD7, 0x0B, 0x06, 0x45, 0xBE, 0x0C, 0x91, + 0x9D, 0x11, 0x2B, 0xD4, 0xA1, 0x67, 0xC6, 0x67, + 0x18, 0xEF, 0x54, 0xEE, 0x33, 0xD9, 0x70, 0x35, + 0x3A, 0x64, 0x10, 0x05, 0x7F, 0x86, 0x91, 0x8C + }, + { + 0x26, 0xD5, 0xDE, 0xDA, 0x51, 0x1B, 0x90, 0x1F, + 0xEC, 0x01, 0xFB, 0x8E, 0xF1, 0x1A, 0x5B, 0x1B, + 0x20, 0x6A, 0xB6, 0xF1, 0xB3, 0x62, 0xE9, 0xE7, + 0x59, 0x67, 0x4E, 0x3C, 0x72, 0xAE, 0x9A, 0x5D + }, + { + 0x4E, 0x17, 0x2F, 0x28, 0x19, 0xCC, 0x64, 0x63, + 0x32, 0xCF, 0xE3, 0xF7, 0xBA, 0x22, 0x6B, 0x9C, + 0xD9, 0x38, 0x51, 0xCF, 0xAA, 0xCB, 0x4A, 0x93, + 0x76, 0x5A, 0xAB, 0xB0, 0xDC, 0xE4, 0x98, 0x2B + }, + { + 0x8D, 0xFF, 0x34, 0xEA, 0x8E, 0x2E, 0x37, 0x46, + 0x65, 0x88, 0x35, 0x29, 0x56, 0x7F, 0x9E, 0x6C, + 0xD1, 0xBD, 0x53, 0x43, 0x64, 0x54, 0xBC, 0x9D, + 0x64, 0x35, 0xE1, 0x30, 0x59, 0x1B, 0xE1, 0x2F + }, + { + 0x40, 0x41, 0x19, 0xD4, 0x8B, 0x64, 0x2E, 0xA9, + 0x7A, 0xA0, 0x9D, 0x70, 0x0E, 0x09, 0x29, 0x20, + 0xFB, 0x74, 0x6A, 0x21, 0x1A, 0xBE, 0x5B, 0x95, + 0x5E, 0x93, 0xB7, 0x30, 0x98, 0x8E, 0x0D, 0x5E + }, + { + 0xAB, 0xE3, 0x37, 0x1E, 0xEE, 0x7A, 0xE1, 0x7B, + 0x7A, 0x5D, 0x55, 0x90, 0xFE, 0x3F, 0x67, 0x57, + 0xE3, 0x1F, 0x40, 0x2B, 0x3F, 0x1F, 0x3D, 0x48, + 0xFC, 0x53, 0x1C, 0x46, 0xB6, 0xAF, 0xEA, 0xC2 + }, + { + 0xB7, 0x73, 0xEE, 0x02, 0x9E, 0xCF, 0x1B, 0xC0, + 0xEA, 0xED, 0xB5, 0x2F, 0xDD, 0x28, 0x9E, 0x0D, + 0xBF, 0xFE, 0xCF, 0xCB, 0xCB, 0x88, 0x46, 0xDF, + 0x45, 0x5B, 0xFE, 0x7D, 0x1A, 0xDF, 0x84, 0x44 + }, + { + 0x3A, 0x73, 0x54, 0xFB, 0xE3, 0x55, 0xD5, 0xAF, + 0x52, 0x2E, 0xB0, 0x34, 0x4C, 0x6A, 0x52, 0x81, + 0xA8, 0x8F, 0x11, 0xA6, 0x86, 0xDD, 0x6F, 0xB5, + 0x73, 0x1A, 0x9E, 0x9B, 0x8A, 0x02, 0x04, 0x5A + }, + { + 0x2D, 0x94, 0xDB, 0x5B, 0x9C, 0xC6, 0xF2, 0x83, + 0x25, 0xC5, 0x5A, 0xAB, 0xBA, 0x4D, 0xC5, 0x8B, + 0xFD, 0xCA, 0xB5, 0x99, 0xE8, 0x6B, 0xD8, 0x7D, + 0xEC, 0x75, 0x3B, 0xB7, 0x62, 0x86, 0xE4, 0x00 + }, + { + 0x77, 0xA7, 0x2B, 0x73, 0xB0, 0xAD, 0xAF, 0x99, + 0x59, 0x8E, 0x61, 0x9E, 0xCC, 0xB5, 0x4B, 0xB8, + 0xBA, 0x79, 0x11, 0xE3, 0x7B, 0x4C, 0xC6, 0x8E, + 0xE2, 0xCD, 0x48, 0x0E, 0x85, 0x0F, 0x6D, 0x82 + }, + { + 0x69, 0xE1, 0x5F, 0x14, 0xED, 0xF9, 0xF2, 0xD1, + 0x8F, 0x66, 0x36, 0xCF, 0x0B, 0xBD, 0x79, 0x13, + 0x9C, 0x6E, 0x3C, 0xFF, 0xA5, 0x31, 0x07, 0x22, + 0x6A, 0x16, 0xA6, 0xD8, 0x87, 0xDE, 0x15, 0x95 + }, + { + 0x67, 0xA4, 0x51, 0x9F, 0xAB, 0x46, 0xEE, 0xA3, + 0x26, 0x5E, 0xB6, 0x22, 0xAD, 0x6F, 0xE8, 0x52, + 0x19, 0xA2, 0x41, 0xE6, 0xBE, 0x62, 0x43, 0xE4, + 0x13, 0x92, 0x0A, 0x78, 0x0A, 0x23, 0xAB, 0x99 + }, + { + 0xC1, 0xF4, 0xBE, 0xCC, 0xBA, 0x63, 0xF1, 0x89, + 0x1E, 0x2F, 0xDE, 0xBD, 0x82, 0xFA, 0x8D, 0x11, + 0x25, 0x52, 0x9E, 0x1A, 0xC6, 0x05, 0x7B, 0x66, + 0x3A, 0x86, 0x4B, 0x28, 0x41, 0xD3, 0x6D, 0x43 + }, + { + 0x44, 0x83, 0x30, 0x55, 0x4F, 0xCF, 0x87, 0x44, + 0x7E, 0x4F, 0x87, 0xF7, 0x0F, 0xEE, 0x3F, 0x42, + 0xEB, 0x74, 0xDD, 0x21, 0x17, 0x57, 0x42, 0x62, + 0xBC, 0xF9, 0xE8, 0xFC, 0x5C, 0xB7, 0x78, 0xD8 + }, + { + 0x01, 0x9C, 0xEC, 0x37, 0x95, 0x3B, 0xCD, 0xDA, + 0xCD, 0xD9, 0x1D, 0xE4, 0xD7, 0x02, 0xB8, 0x69, + 0x48, 0x3F, 0xB9, 0xF3, 0xE8, 0x17, 0x08, 0xA6, + 0xF1, 0xF6, 0x5F, 0x69, 0x23, 0xF2, 0xB9, 0x55 + }, + { + 0x4A, 0xA8, 0xFE, 0x53, 0x21, 0x98, 0x7A, 0x49, + 0xE0, 0x11, 0x0C, 0xCE, 0xFA, 0x60, 0x58, 0xEB, + 0x1B, 0xA2, 0x44, 0xAF, 0x7B, 0x33, 0xC9, 0x8A, + 0x7F, 0xB1, 0xA8, 0x75, 0x4E, 0x67, 0x89, 0x25 + }, + { + 0xAE, 0x61, 0x9B, 0x4A, 0xA0, 0x6E, 0xB7, 0xB2, + 0xD9, 0xB0, 0x7C, 0x30, 0x5E, 0x7F, 0xE6, 0xD4, + 0xB3, 0xCD, 0xBB, 0xEA, 0xCA, 0x9E, 0x96, 0x3F, + 0xE5, 0x47, 0x8C, 0x43, 0xFC, 0xAD, 0xC0, 0x0B + }, + { + 0x04, 0x67, 0x67, 0x2F, 0x31, 0x25, 0xC9, 0xD0, + 0x41, 0x10, 0x48, 0x13, 0x21, 0x29, 0xC9, 0x1B, + 0xC6, 0x76, 0x41, 0xCE, 0x31, 0xA2, 0x1B, 0xB8, + 0x8D, 0x85, 0x49, 0xF3, 0x2E, 0xED, 0x13, 0xB5 + }, + { + 0xFD, 0x56, 0xCC, 0xD1, 0xC5, 0x87, 0x88, 0x8D, + 0x39, 0xBD, 0x31, 0x0E, 0x5E, 0x69, 0xE3, 0xAE, + 0x73, 0x81, 0x8D, 0x8B, 0x8B, 0xBF, 0x2D, 0x22, + 0x5B, 0x99, 0x60, 0x89, 0xDA, 0xF1, 0xE5, 0xE6 + }, + { + 0x99, 0x00, 0x2F, 0x07, 0x08, 0x7F, 0x41, 0xD8, + 0x75, 0x9F, 0xEB, 0xB1, 0xF2, 0x7A, 0xB7, 0x3F, + 0x5E, 0xB7, 0x5C, 0x33, 0x15, 0x6C, 0xA2, 0x59, + 0x7F, 0x20, 0x05, 0x22, 0x87, 0x9F, 0x57, 0xD8 + }, + { + 0x87, 0xB9, 0xAB, 0x8E, 0xAA, 0xF6, 0xA4, 0xC2, + 0xF2, 0xEC, 0x5F, 0x58, 0x56, 0xDD, 0x30, 0xFD, + 0x69, 0xB5, 0x0C, 0xA5, 0x99, 0xDF, 0x53, 0x4D, + 0x5D, 0x30, 0x45, 0x16, 0x89, 0x5E, 0xFA, 0xAD + }, + { + 0x52, 0x65, 0xF4, 0xB2, 0x9F, 0xAA, 0xC2, 0xC2, + 0xD6, 0x86, 0xE2, 0x10, 0xC3, 0xEE, 0x2A, 0xBD, + 0x20, 0xB5, 0x56, 0x59, 0x5C, 0xF8, 0x26, 0xD2, + 0x0A, 0x25, 0x03, 0x6E, 0xC3, 0x17, 0x3A, 0x88 + }, + { + 0xE0, 0x3D, 0x0B, 0xD6, 0xDF, 0x85, 0xB1, 0x4F, + 0x1A, 0x3F, 0xC3, 0xA8, 0xE2, 0x94, 0xC0, 0x48, + 0xCB, 0x93, 0x7E, 0xA3, 0x82, 0xEC, 0x45, 0x87, + 0x4E, 0x69, 0x9F, 0x83, 0x85, 0x4A, 0x10, 0xCB + }, + { + 0x98, 0xFF, 0xD8, 0x49, 0x32, 0x26, 0x94, 0x62, + 0x6B, 0x07, 0xAA, 0x42, 0x8B, 0x4E, 0xB8, 0x99, + 0x49, 0x64, 0x49, 0x2A, 0xFD, 0xEF, 0x59, 0xB3, + 0xFE, 0x1B, 0x18, 0xB2, 0xDD, 0x0B, 0x7D, 0x24 + }, + { + 0x16, 0xCD, 0xAF, 0xD1, 0xE1, 0x15, 0x5F, 0x8A, + 0x1B, 0xC7, 0x94, 0xB7, 0x83, 0xA1, 0x1D, 0x60, + 0xB7, 0xD3, 0xBC, 0xF4, 0x1C, 0x01, 0xD2, 0xE7, + 0x75, 0x01, 0x03, 0xC0, 0x32, 0x6D, 0xDC, 0xB5 + }, + { + 0xAB, 0xD9, 0xD3, 0x4B, 0xBD, 0xB6, 0x85, 0x0A, + 0x47, 0x23, 0x03, 0xE7, 0x25, 0x86, 0x75, 0xCA, + 0x5F, 0x39, 0x05, 0x4F, 0x7A, 0xF5, 0x73, 0x52, + 0xC2, 0x44, 0x05, 0x05, 0xB3, 0xE0, 0x7C, 0xD8 + }, + { + 0xA0, 0x5F, 0xA3, 0x26, 0xB0, 0x02, 0x81, 0x10, + 0x3E, 0xE9, 0x78, 0x10, 0xAD, 0xEB, 0xA3, 0x65, + 0xB0, 0x72, 0xF4, 0xDD, 0xE4, 0x82, 0x33, 0x13, + 0x8C, 0x34, 0xAB, 0x0C, 0xFD, 0x94, 0xE5, 0x10 + }, + { + 0x94, 0x84, 0x5C, 0x90, 0xD2, 0x35, 0x1E, 0xF9, + 0xA7, 0x55, 0x58, 0xB3, 0x9F, 0x8F, 0xFF, 0x5E, + 0x19, 0x96, 0x22, 0x1B, 0x33, 0x7A, 0xA5, 0xAB, + 0xC9, 0xF3, 0x2E, 0x24, 0x10, 0x71, 0xE1, 0x1C + }, + { + 0x35, 0x6B, 0x23, 0x37, 0x27, 0xBC, 0x78, 0x78, + 0xB2, 0x70, 0xD7, 0xED, 0xF6, 0x10, 0xCC, 0x4E, + 0xDD, 0x45, 0x06, 0x5B, 0x08, 0x44, 0x9C, 0x04, + 0x9C, 0x85, 0x18, 0xA9, 0x31, 0x50, 0x5B, 0x73 + }, + { + 0xB2, 0x5A, 0x53, 0x14, 0x69, 0x91, 0x40, 0x2A, + 0xB0, 0xA3, 0xCB, 0x23, 0x5F, 0x92, 0x38, 0xDC, + 0x2C, 0x2F, 0x71, 0x7E, 0x60, 0x21, 0x4E, 0xF3, + 0x01, 0x48, 0xEE, 0x7B, 0x5C, 0xD8, 0x9F, 0x9A + }, + { + 0xB9, 0xE5, 0xE1, 0x98, 0x54, 0x0C, 0xD6, 0xEF, + 0xC4, 0x19, 0x7D, 0x50, 0xA2, 0x07, 0xCC, 0x89, + 0x94, 0xC0, 0xAA, 0xD9, 0x0D, 0x47, 0xF5, 0x74, + 0x7A, 0x04, 0x17, 0xEB, 0xFB, 0x57, 0xE5, 0x6C + }, + { + 0x39, 0x48, 0x7E, 0xF3, 0x1D, 0xFE, 0xB2, 0x2D, + 0xE7, 0xE8, 0x56, 0x67, 0xA9, 0x2F, 0x85, 0x91, + 0x4D, 0xD7, 0x36, 0x10, 0xD4, 0x15, 0xBD, 0xC0, + 0xEC, 0x53, 0x82, 0xEC, 0xCA, 0x77, 0xF5, 0x92 + }, + { + 0x4E, 0x32, 0x1E, 0x39, 0x10, 0x2C, 0xD2, 0x25, + 0x2B, 0xA1, 0xB2, 0x55, 0xE3, 0xC3, 0xD4, 0xCD, + 0x9C, 0x92, 0x8B, 0xFE, 0xDA, 0x4F, 0x30, 0xA8, + 0x65, 0x1A, 0x8E, 0x07, 0x12, 0xFB, 0xFA, 0xE1 + }, + { + 0x70, 0x0F, 0xB0, 0xD7, 0x6B, 0x3E, 0x3F, 0x6D, + 0xE6, 0xA5, 0x93, 0xA8, 0x5D, 0x17, 0xA0, 0x20, + 0x75, 0xC4, 0x74, 0x31, 0x88, 0x59, 0xE5, 0xC0, + 0x8F, 0x57, 0x97, 0x4D, 0x91, 0xDC, 0x8B, 0x91 + }, + { + 0xC5, 0xB3, 0x13, 0x70, 0x8E, 0x36, 0xF1, 0x72, + 0x19, 0x2D, 0xD6, 0xAC, 0x87, 0x8E, 0xA2, 0xBF, + 0x57, 0xAE, 0x09, 0xE2, 0xE0, 0x2F, 0xCB, 0x74, + 0xF8, 0x4C, 0x22, 0xEB, 0x02, 0x0F, 0x49, 0x5E + }, + { + 0x7F, 0x8F, 0x91, 0xEB, 0x4A, 0xA6, 0xE1, 0xA6, + 0x25, 0xE2, 0x85, 0xFC, 0xB6, 0x2F, 0x15, 0xCA, + 0x15, 0x0D, 0x55, 0x0C, 0x60, 0x29, 0x5E, 0xCE, + 0xEE, 0xAC, 0x42, 0xFA, 0x9F, 0xDF, 0x38, 0xBF + }, + { + 0x4D, 0xE2, 0x9B, 0xAB, 0x1B, 0x13, 0x1A, 0x61, + 0xFD, 0xF8, 0x10, 0x33, 0xC5, 0x61, 0xA1, 0x86, + 0x27, 0x0B, 0xB2, 0x45, 0xE7, 0x71, 0xEC, 0x95, + 0xA8, 0x9D, 0xE2, 0x76, 0xEB, 0x63, 0x02, 0xAB + }, + { + 0x1D, 0x62, 0xF8, 0x84, 0x17, 0x18, 0x83, 0x0B, + 0xD6, 0x67, 0x9F, 0x9E, 0xCC, 0xA9, 0x08, 0xED, + 0xF8, 0xE6, 0x42, 0xB7, 0x7D, 0x4B, 0x42, 0x45, + 0xA8, 0x62, 0x8B, 0xBA, 0xDE, 0x97, 0x8C, 0x07 + }, + { + 0xCA, 0x17, 0xC6, 0xC2, 0x96, 0xEB, 0x34, 0x86, + 0xC8, 0x02, 0x11, 0xF1, 0x05, 0x06, 0xCC, 0xCC, + 0xE6, 0x86, 0x76, 0xB3, 0x82, 0xCF, 0x37, 0xB4, + 0x44, 0x02, 0xD7, 0x2F, 0x53, 0xA6, 0x4B, 0xD1 + }, + { + 0x9E, 0x02, 0x8D, 0xBC, 0xED, 0xDA, 0xB7, 0x0D, + 0x30, 0x09, 0x77, 0x1F, 0x79, 0xDE, 0xAD, 0x20, + 0x06, 0x80, 0x68, 0x9B, 0xA0, 0x65, 0x7F, 0x8E, + 0xB8, 0x5C, 0xB0, 0x66, 0x16, 0x96, 0xBF, 0x3D + }, + { + 0xED, 0x76, 0x54, 0x8A, 0x53, 0x84, 0xAB, 0x6C, + 0xDE, 0x86, 0xD6, 0xED, 0x61, 0x66, 0x28, 0xD8, + 0x67, 0x9C, 0x56, 0xE9, 0x03, 0x2D, 0xDA, 0xFD, + 0xDB, 0xE1, 0x3C, 0xC3, 0x91, 0x77, 0xD2, 0x69 + }, + { + 0xC0, 0x43, 0xB7, 0x1D, 0xDA, 0x85, 0x51, 0xBB, + 0x01, 0xF6, 0xF0, 0x72, 0x9E, 0x4A, 0x45, 0xF4, + 0x9C, 0x12, 0xB6, 0xC4, 0x99, 0x52, 0x67, 0x67, + 0x0B, 0x63, 0xC3, 0x3E, 0xE2, 0x65, 0xE7, 0x8C + }, + { + 0x96, 0x94, 0xFD, 0x91, 0xDB, 0xE8, 0xC0, 0xD5, + 0xEC, 0x8E, 0x01, 0x38, 0x0F, 0xC1, 0x7B, 0x93, + 0x2D, 0x68, 0x7C, 0x9C, 0x0E, 0x60, 0xE7, 0xDF, + 0x79, 0x94, 0x13, 0x93, 0x7E, 0x09, 0x63, 0x60 + }, + { + 0x64, 0xF5, 0x5D, 0x17, 0xC5, 0xA1, 0x93, 0xEA, + 0x3C, 0x3D, 0x05, 0x53, 0xF9, 0xE0, 0x68, 0xAD, + 0xFE, 0xD6, 0xC4, 0x21, 0xCA, 0x3F, 0xCD, 0xF2, + 0x01, 0x09, 0xDD, 0xD7, 0xD3, 0xEA, 0xFF, 0x61 + }, + { + 0xA1, 0x3B, 0xD6, 0xDE, 0xB1, 0x77, 0xA3, 0xD3, + 0xA5, 0x73, 0x1C, 0x46, 0xED, 0x79, 0xC6, 0xD7, + 0x28, 0x70, 0x00, 0x41, 0x60, 0xD3, 0x5A, 0xE5, + 0x78, 0x0B, 0x8E, 0x5F, 0x24, 0x69, 0x54, 0xF0 + }, + { + 0x8B, 0x54, 0x7E, 0xBD, 0x24, 0xE1, 0x8E, 0xAC, + 0x8C, 0x9D, 0x5B, 0xD6, 0xC2, 0xA0, 0xCC, 0x50, + 0x28, 0xCC, 0xE1, 0x7E, 0x87, 0x78, 0x71, 0x5D, + 0xFC, 0x29, 0x15, 0xDB, 0x61, 0x87, 0xC6, 0xA8 + }, + { + 0x33, 0x86, 0x8A, 0x1C, 0xDD, 0x94, 0x43, 0xA6, + 0x78, 0x67, 0x24, 0xD7, 0x3F, 0x10, 0x2B, 0x08, + 0xF6, 0x6D, 0x4F, 0x5B, 0x2A, 0xF3, 0x01, 0xEF, + 0x6D, 0xE2, 0x05, 0x39, 0xCB, 0x21, 0xEE, 0x84 + }, + { + 0xD6, 0xAF, 0xE7, 0x3B, 0x91, 0xA1, 0x4C, 0xC4, + 0x35, 0x4C, 0x9D, 0xD7, 0x57, 0x6D, 0x13, 0x33, + 0x6D, 0xC6, 0x90, 0xC5, 0x83, 0x3C, 0x6C, 0x39, + 0x7E, 0xBB, 0x95, 0x9C, 0x86, 0x4D, 0x98, 0x2B + }, + { + 0x7E, 0xBB, 0x4D, 0x97, 0x45, 0xDC, 0xE3, 0x43, + 0xAE, 0xFA, 0x01, 0x03, 0xEC, 0xCD, 0xDE, 0x5A, + 0x3D, 0x1A, 0xCB, 0xDA, 0xF2, 0x3B, 0x7C, 0x77, + 0x78, 0xE3, 0x15, 0x19, 0x03, 0x11, 0xA2, 0xE0 + }, + { + 0x37, 0x88, 0xDD, 0xE4, 0x36, 0x00, 0x93, 0x80, + 0x4B, 0xDC, 0x76, 0xA1, 0xDF, 0x5A, 0xC2, 0xE5, + 0xAB, 0x20, 0x01, 0x3A, 0x2D, 0xE8, 0x08, 0xE7, + 0x6A, 0x36, 0xFF, 0x70, 0x72, 0x02, 0x23, 0xE9 + }, + { + 0xB1, 0x0F, 0x0A, 0xC4, 0xC1, 0xAA, 0x0F, 0xDD, + 0x8D, 0x30, 0x71, 0x0F, 0x04, 0x87, 0xCE, 0x91, + 0x87, 0xA6, 0x1A, 0x7D, 0xB8, 0xAA, 0x2F, 0x95, + 0x35, 0xEB, 0xA7, 0x73, 0xF7, 0xBE, 0xC2, 0xB9 + }, + { + 0x8D, 0xAB, 0x6F, 0x91, 0x33, 0x37, 0xBE, 0x20, + 0x69, 0x88, 0x7C, 0x40, 0xFA, 0xFA, 0xA8, 0x0E, + 0x91, 0xB5, 0x8E, 0x4D, 0x4C, 0xD3, 0x2E, 0x93, + 0x66, 0x9F, 0x6F, 0x95, 0x1F, 0xD8, 0x65, 0xBA + }, + { + 0x19, 0x78, 0x96, 0xF1, 0x71, 0x3A, 0xA6, 0x6F, + 0x36, 0xBF, 0xFD, 0x35, 0x7B, 0x6B, 0x5C, 0x41, + 0xF4, 0x9D, 0x8E, 0x4B, 0x3E, 0xE0, 0x23, 0x26, + 0xA3, 0xB7, 0x1E, 0xC4, 0xAF, 0x11, 0xA7, 0x36 + }, + { + 0x33, 0xF1, 0xB2, 0x34, 0x94, 0xD9, 0x59, 0x75, + 0xC1, 0xE8, 0x2A, 0x9C, 0x77, 0x06, 0x35, 0x37, + 0x79, 0xD6, 0x61, 0xA6, 0x10, 0x36, 0xE6, 0x40, + 0x27, 0x63, 0x63, 0x1A, 0xDD, 0xE1, 0x07, 0x17 + }, + { + 0xB0, 0x1A, 0xD1, 0xB6, 0x6B, 0x2C, 0x73, 0x2C, + 0x8C, 0x16, 0xEB, 0xD6, 0xDA, 0x22, 0x78, 0xAB, + 0xC8, 0x63, 0x65, 0xEC, 0xB0, 0x29, 0xDC, 0x22, + 0x45, 0x7E, 0x7A, 0x4E, 0x35, 0x1D, 0x05, 0x3D + }, + { + 0x4E, 0x86, 0xB5, 0x59, 0x09, 0x60, 0xF1, 0xA6, + 0x09, 0x73, 0xD9, 0x04, 0x32, 0x6B, 0x0E, 0x18, + 0xDA, 0x8A, 0x92, 0xAC, 0xF2, 0x61, 0x6D, 0x99, + 0x61, 0xCC, 0x3F, 0x78, 0xD3, 0x19, 0xC5, 0xC8 + }, + { + 0xE6, 0xAA, 0xA6, 0xC0, 0x32, 0x20, 0x8B, 0x09, + 0x2E, 0x8D, 0x30, 0xD4, 0x56, 0xDA, 0xA1, 0x88, + 0x06, 0xFA, 0x72, 0x90, 0xE1, 0x22, 0xAB, 0x34, + 0x2D, 0x9B, 0xDB, 0xCA, 0xAB, 0xFB, 0x73, 0x68 + }, + { + 0x70, 0x0B, 0xDF, 0xED, 0x8E, 0x63, 0x1E, 0xE4, + 0x49, 0xE7, 0xF1, 0x24, 0xC1, 0x13, 0x22, 0x8D, + 0x17, 0x12, 0xB9, 0xF1, 0x6A, 0x4C, 0x25, 0x5A, + 0xB3, 0x34, 0x87, 0xBF, 0xEB, 0x27, 0x9A, 0x19 + }, + { + 0x6E, 0xD5, 0x15, 0x9F, 0x6B, 0xD4, 0x4C, 0xEE, + 0x36, 0x7A, 0x4E, 0xE2, 0x39, 0x9E, 0x65, 0x87, + 0xFE, 0xD0, 0xA1, 0x6C, 0x46, 0xFC, 0xE7, 0x60, + 0x31, 0x14, 0x70, 0xD7, 0xDE, 0x83, 0xB8, 0x17 + }, + { + 0xEB, 0xF3, 0xB5, 0x6A, 0x20, 0x64, 0xE1, 0xE0, + 0x31, 0xD5, 0x28, 0xC7, 0xC3, 0x8D, 0xDE, 0xA1, + 0x9C, 0x65, 0x84, 0xC8, 0xCA, 0xD5, 0x6F, 0x1D, + 0x8B, 0xF9, 0xB0, 0xEA, 0x08, 0x17, 0xB6, 0x45 + }, + { + 0xA2, 0x30, 0xEA, 0xA6, 0x22, 0x17, 0x32, 0xDC, + 0x8A, 0xB4, 0x19, 0xA5, 0x3E, 0x6B, 0x94, 0xC4, + 0x79, 0x06, 0x32, 0x00, 0x02, 0x53, 0xF6, 0xED, + 0x95, 0x14, 0xC1, 0x60, 0x7B, 0x7E, 0xE8, 0x5B + }, + { + 0x07, 0x03, 0xC5, 0xA8, 0xBA, 0x11, 0xEB, 0x91, + 0x06, 0x95, 0xB5, 0xBB, 0x3B, 0x5C, 0xF1, 0x6B, + 0x66, 0x61, 0x40, 0x10, 0x35, 0xDB, 0x62, 0xCB, + 0x7B, 0x1C, 0xB2, 0x8C, 0xDE, 0xB3, 0xF6, 0x61 + }, + { + 0xE1, 0xCE, 0x3B, 0xAC, 0x9E, 0xC9, 0xE0, 0x96, + 0x01, 0x40, 0x1C, 0xA4, 0xC1, 0x6A, 0x32, 0x05, + 0xD7, 0x44, 0x16, 0x33, 0x4E, 0x82, 0xB9, 0x50, + 0x58, 0x03, 0x83, 0x28, 0xB6, 0x35, 0x8A, 0xD1 + }, + { + 0x52, 0x60, 0x99, 0xA4, 0x5D, 0xA6, 0x76, 0x0D, + 0x46, 0xF4, 0xB4, 0xAD, 0x07, 0x3E, 0x37, 0x4E, + 0x12, 0xD5, 0x6A, 0x3A, 0xE1, 0xD9, 0x70, 0xE8, + 0x30, 0xE0, 0x03, 0xDC, 0x41, 0x02, 0x5F, 0x97 + }, + { + 0x07, 0xA2, 0x3E, 0xBE, 0x5A, 0xD9, 0x98, 0xAC, + 0x8F, 0xA9, 0x64, 0x2C, 0x1C, 0xC7, 0x0A, 0x85, + 0x06, 0xB7, 0xF0, 0x65, 0x20, 0x0B, 0x62, 0xF9, + 0xBE, 0x52, 0x61, 0x15, 0x8B, 0xCA, 0xB0, 0xE4 + }, + { + 0xA1, 0xEA, 0x74, 0x12, 0xF7, 0xB6, 0x94, 0x1A, + 0x0B, 0x02, 0x92, 0x02, 0xA4, 0x6C, 0x2D, 0x40, + 0xBC, 0x0F, 0x30, 0xBF, 0xC0, 0x7F, 0x78, 0xC8, + 0x4D, 0x5D, 0xEA, 0xC8, 0x1C, 0xF6, 0xC3, 0x5A + }, + { + 0x47, 0x59, 0x48, 0x85, 0x0D, 0xE5, 0x77, 0xDA, + 0x0A, 0x81, 0xD4, 0x08, 0xA7, 0xE2, 0xC3, 0xC7, + 0xED, 0xE0, 0x5B, 0xA4, 0x7D, 0x04, 0x40, 0x26, + 0x62, 0x8E, 0xCA, 0xE0, 0x4F, 0x27, 0x05, 0xBE + }, + { + 0xB3, 0x8B, 0xB6, 0x42, 0x5F, 0xB1, 0xC3, 0x36, + 0x1E, 0x57, 0x38, 0x36, 0x90, 0x86, 0x5F, 0xE2, + 0x31, 0xF4, 0xAE, 0xBE, 0xE2, 0x9A, 0x2A, 0xF8, + 0x7B, 0xF4, 0x1E, 0xC1, 0xFC, 0x3F, 0x3D, 0xDD + }, + { + 0x8A, 0x01, 0xEA, 0x93, 0x97, 0x06, 0xC1, 0x87, + 0x54, 0x29, 0x2C, 0xC9, 0xD8, 0x41, 0x2A, 0x51, + 0x2B, 0xBC, 0xF0, 0xB1, 0x8A, 0x8C, 0x3A, 0x6D, + 0xF2, 0x7C, 0x9F, 0xD3, 0x67, 0xD0, 0x43, 0x97 + }, + { + 0x39, 0xE6, 0x71, 0x60, 0x51, 0x23, 0xC5, 0x04, + 0xCD, 0x0D, 0xBF, 0x1D, 0x0D, 0x36, 0xD6, 0x94, + 0x4B, 0xF5, 0x4D, 0x58, 0xFD, 0x86, 0x06, 0x9B, + 0x07, 0xDA, 0xD1, 0x83, 0x51, 0x91, 0xF8, 0xF8 + }, + { + 0xDB, 0xC6, 0x43, 0x90, 0xC4, 0x61, 0xCC, 0x09, + 0x2C, 0xE9, 0x07, 0x3C, 0xE9, 0xF1, 0x3A, 0x6D, + 0x7F, 0xC3, 0x6E, 0xFA, 0x53, 0x07, 0xB1, 0xFE, + 0x96, 0x87, 0x6A, 0xD7, 0xA2, 0x68, 0x91, 0x0F + }, + { + 0x1A, 0x74, 0x1E, 0x1A, 0x6A, 0xF0, 0x7F, 0x4E, + 0xFD, 0xFB, 0x6C, 0xF1, 0xA9, 0xC9, 0xB1, 0x0A, + 0x45, 0x1D, 0xA4, 0x8D, 0x87, 0xC6, 0xDA, 0x94, + 0xBD, 0x0F, 0xA0, 0x23, 0x3B, 0x5B, 0xFB, 0x5F + }, + { + 0xFB, 0xA4, 0xDD, 0xFC, 0x96, 0xF6, 0xF5, 0xA4, + 0xDE, 0xA1, 0xC3, 0x5C, 0xBC, 0xB3, 0x6C, 0x41, + 0x17, 0x3A, 0x6A, 0x3A, 0x71, 0x9D, 0xFC, 0x80, + 0x7A, 0x61, 0xD7, 0xA9, 0xE8, 0x12, 0x9C, 0x58 + }, + { + 0x12, 0x6E, 0x86, 0x83, 0xFE, 0x9E, 0xCF, 0x37, + 0x63, 0x26, 0xEB, 0xA1, 0x5E, 0xB9, 0xE8, 0xC0, + 0x41, 0xAF, 0x12, 0x66, 0x61, 0x04, 0xA7, 0xB1, + 0x54, 0x92, 0x0F, 0xBA, 0xD8, 0xFB, 0xC8, 0xFB + }, + { + 0x67, 0xBC, 0xD5, 0xDF, 0x1A, 0xCC, 0x0F, 0xC5, + 0xF1, 0x98, 0x2B, 0xFC, 0xCF, 0x4F, 0x4B, 0x0A, + 0x15, 0xBF, 0x76, 0x42, 0x79, 0xE3, 0xD8, 0xE8, + 0x2D, 0xA6, 0x3B, 0xA4, 0x38, 0x80, 0x91, 0xB8 + }, + { + 0x32, 0x43, 0xDB, 0x42, 0xAF, 0x18, 0x4D, 0xB5, + 0xDF, 0x92, 0x7A, 0x10, 0x40, 0xC8, 0x00, 0x75, + 0xAB, 0xD3, 0x48, 0x91, 0x9B, 0xF1, 0x39, 0xCA, + 0x36, 0xE4, 0x3F, 0x76, 0xA6, 0xFF, 0xD6, 0xE0 + }, + { + 0x31, 0x93, 0x5F, 0x66, 0x7A, 0x30, 0xFD, 0x83, + 0x2D, 0x10, 0x13, 0x8B, 0x50, 0x52, 0xA4, 0x6D, + 0x9B, 0x41, 0x02, 0x73, 0xA5, 0x1D, 0x84, 0x63, + 0x81, 0x2F, 0x82, 0x6D, 0x2E, 0x73, 0xD4, 0x30 + }, + { + 0x0E, 0x6E, 0x8B, 0xA9, 0x07, 0xD9, 0x58, 0xBB, + 0xDB, 0xFD, 0x3E, 0xF4, 0x42, 0x7A, 0xB2, 0xDF, + 0x23, 0xD2, 0xDA, 0xA3, 0x5C, 0x65, 0xC8, 0xE0, + 0x66, 0x93, 0x0F, 0x45, 0xA6, 0x8A, 0xAF, 0x76 + }, + { + 0x66, 0x97, 0x54, 0x43, 0x0E, 0x16, 0xAB, 0x82, + 0x9D, 0x1F, 0x96, 0xF6, 0xFA, 0x6E, 0x9C, 0xDC, + 0x60, 0x15, 0x12, 0x3D, 0x8C, 0xA6, 0xEA, 0x8C, + 0x42, 0xF3, 0x07, 0xE8, 0x59, 0xAE, 0xE6, 0x1A + }, + { + 0x53, 0x2B, 0x47, 0x53, 0x38, 0x9C, 0x06, 0x29, + 0xE1, 0x5D, 0xBE, 0x92, 0x80, 0x3B, 0x7D, 0xEB, + 0xB2, 0x62, 0xEE, 0x0F, 0xDF, 0x26, 0xDC, 0x03, + 0xF7, 0xCD, 0x3E, 0xD9, 0xED, 0x9F, 0xCF, 0x26 + }, + { + 0xB2, 0x60, 0x78, 0x8C, 0x23, 0x79, 0xE6, 0x42, + 0x53, 0x46, 0x19, 0xF6, 0x0F, 0xFF, 0x90, 0x96, + 0x70, 0x34, 0xE8, 0x23, 0xD1, 0xDB, 0x1F, 0x3F, + 0x3C, 0x0A, 0xA2, 0x65, 0x1A, 0xCF, 0x04, 0xB4 + }, + { + 0x1E, 0xBA, 0x9C, 0xD8, 0x66, 0xD9, 0x15, 0xFE, + 0x5D, 0xB7, 0x6F, 0x5C, 0x62, 0x1E, 0xCB, 0xE3, + 0x45, 0x1E, 0xDC, 0xF1, 0x82, 0xF4, 0x50, 0x84, + 0x4E, 0x6F, 0xC9, 0x1E, 0x1D, 0x0A, 0xA1, 0xB6 + }, + { + 0x5A, 0xD0, 0xA4, 0x28, 0x22, 0xD4, 0xD0, 0xF5, + 0x84, 0x98, 0x0C, 0x73, 0x72, 0x37, 0x40, 0x86, + 0x80, 0x56, 0xEA, 0x5F, 0xA6, 0xE0, 0x8B, 0xBC, + 0xD7, 0xD9, 0x74, 0x26, 0x55, 0x7B, 0x9B, 0xEC + }, + { + 0x89, 0x06, 0xC0, 0x4B, 0x73, 0x7D, 0xD3, 0xD9, + 0xFF, 0x5A, 0xB4, 0xFB, 0xD0, 0xA5, 0x9B, 0x5D, + 0xA4, 0x0C, 0xCC, 0xFC, 0x7B, 0xD7, 0xC3, 0x61, + 0x0E, 0x74, 0x44, 0xBC, 0x57, 0xE0, 0xEF, 0x74 + }, + { + 0x14, 0xBE, 0x51, 0x0F, 0xBA, 0xA2, 0x11, 0xA5, + 0x44, 0xA3, 0x5B, 0x05, 0xCD, 0xCA, 0xA6, 0x56, + 0x16, 0xCD, 0x5E, 0x0B, 0xDD, 0xE5, 0xAF, 0x1C, + 0x45, 0xA1, 0x60, 0x42, 0x3C, 0x17, 0x07, 0x1F + }, + { + 0x18, 0x97, 0x71, 0x42, 0xE5, 0x2A, 0x05, 0xDD, + 0x42, 0x93, 0xE1, 0xBE, 0xF5, 0xAB, 0x6A, 0x46, + 0xD7, 0x0E, 0x0E, 0xF0, 0x0B, 0x34, 0xEC, 0x79, + 0x2B, 0xB1, 0x7D, 0xA7, 0xC5, 0x6F, 0xF4, 0x10 + }, + { + 0xF0, 0xA4, 0xC6, 0x04, 0x14, 0xE3, 0x15, 0xFD, + 0xAD, 0xDF, 0x3C, 0x8F, 0x3D, 0x8D, 0xD6, 0xB2, + 0x32, 0xA8, 0xAE, 0x5C, 0x7E, 0xEC, 0xC8, 0x73, + 0x6A, 0xB4, 0x62, 0xCE, 0xEA, 0xBA, 0xF7, 0x5C + }, + { + 0xEA, 0xDF, 0x52, 0x77, 0x8C, 0xC0, 0xBC, 0x11, + 0xCA, 0xD7, 0x45, 0xD3, 0xC4, 0x9B, 0x04, 0x2F, + 0x69, 0x02, 0xCD, 0xCF, 0x14, 0xF4, 0xD5, 0x37, + 0x7B, 0x58, 0x6A, 0xA0, 0x7A, 0x2A, 0xF2, 0x34 + }, + { + 0x1A, 0x27, 0x6A, 0x2B, 0x93, 0xA3, 0x6F, 0xD3, + 0xCD, 0xEC, 0x0B, 0x6B, 0x77, 0xD0, 0xF0, 0x07, + 0x0A, 0x33, 0xCE, 0x18, 0x99, 0x74, 0x07, 0xE8, + 0x95, 0xE3, 0xFC, 0x00, 0x3B, 0x6E, 0x95, 0x88 + }, + { + 0x9D, 0xA3, 0x5C, 0xBD, 0x9E, 0x80, 0x97, 0xCF, + 0x3B, 0x09, 0xE2, 0xDB, 0xD6, 0x2C, 0xC3, 0xD0, + 0xC3, 0x9A, 0x54, 0xC8, 0xC4, 0x3E, 0x81, 0xAF, + 0x1B, 0x1D, 0x33, 0xE1, 0x91, 0xB6, 0xC1, 0x52 + }, + { + 0x61, 0x94, 0x90, 0xC2, 0xDD, 0xF8, 0x94, 0x53, + 0x86, 0x64, 0xA0, 0xD9, 0x3A, 0xC9, 0x1D, 0xF9, + 0x1A, 0x2B, 0x62, 0x17, 0x67, 0x99, 0xCC, 0x5A, + 0x90, 0x79, 0xEB, 0xDD, 0x0D, 0xB4, 0xCF, 0x7E + }, + { + 0xF2, 0x56, 0x36, 0xB7, 0x3F, 0xE4, 0x58, 0x10, + 0x69, 0xE3, 0xEF, 0xDA, 0xC9, 0xEA, 0x1B, 0xDC, + 0x27, 0xC0, 0xAE, 0x5E, 0xF8, 0x07, 0x5F, 0xE1, + 0x97, 0xCB, 0x5A, 0x18, 0xF7, 0x17, 0x70, 0x62 + }, + { + 0x02, 0xFE, 0xA0, 0xFB, 0x69, 0xDC, 0xF8, 0x27, + 0x5E, 0x02, 0x77, 0xD9, 0xA4, 0x5F, 0xA2, 0xF0, + 0x2E, 0x68, 0x6B, 0xBA, 0x16, 0x0E, 0x26, 0x99, + 0x11, 0x05, 0xF5, 0xBC, 0x9C, 0x40, 0xA2, 0x8F + }, + { + 0x23, 0x77, 0xFA, 0x0E, 0xA7, 0x12, 0xAC, 0x82, + 0x0A, 0x80, 0x46, 0xBA, 0x8E, 0x26, 0x1D, 0x6F, + 0x93, 0x75, 0x73, 0x69, 0x00, 0xD0, 0x92, 0x79, + 0x9F, 0x6A, 0x8E, 0xC9, 0xBE, 0xB5, 0x82, 0x26 + }, + { + 0x61, 0x07, 0xCF, 0x95, 0x6F, 0x53, 0x42, 0xC1, + 0x34, 0xCE, 0x61, 0xCA, 0x7A, 0xAF, 0xDE, 0x9D, + 0x90, 0xBF, 0xE3, 0x59, 0x1C, 0xC1, 0xD5, 0xAD, + 0xAC, 0x8D, 0x4E, 0xAD, 0x2F, 0x3E, 0x22, 0xA4 + }, + { + 0xB6, 0x4F, 0x42, 0xA2, 0x67, 0x84, 0xC4, 0x28, + 0xE2, 0x09, 0x67, 0x49, 0xF2, 0x2D, 0xB9, 0xC8, + 0x48, 0x4C, 0xA3, 0xB9, 0x01, 0x97, 0x99, 0x46, + 0x9A, 0x00, 0x40, 0x5E, 0x84, 0x85, 0xD4, 0x9D + }, + { + 0xE4, 0xFA, 0xA4, 0xF2, 0x67, 0x28, 0x58, 0x8E, + 0xBA, 0x4C, 0x51, 0xB8, 0x98, 0x17, 0x65, 0x34, + 0xFF, 0xAF, 0x1C, 0x4B, 0xF9, 0x92, 0xBC, 0xB9, + 0xA1, 0xD0, 0xE5, 0xFB, 0xBF, 0xD2, 0x65, 0xB2 + }, + { + 0xCB, 0x98, 0x02, 0x78, 0x0F, 0xB9, 0x4D, 0x5A, + 0x7B, 0x21, 0xAE, 0xB8, 0xAF, 0x51, 0x7F, 0x88, + 0x83, 0x0A, 0x83, 0xE2, 0xDC, 0x95, 0xC0, 0xD0, + 0x61, 0xF4, 0x90, 0x8F, 0x9C, 0x88, 0x5B, 0x11 + }, + { + 0x39, 0xE6, 0x82, 0x12, 0xBE, 0xCF, 0x1A, 0x06, + 0x25, 0xA5, 0x1B, 0x0C, 0xC8, 0x4E, 0xF7, 0xF1, + 0x47, 0x87, 0x65, 0x85, 0xC6, 0xBB, 0x34, 0xAD, + 0x7F, 0xF5, 0xC5, 0xA7, 0x99, 0xAF, 0x87, 0xD0 + }, + { + 0x84, 0xE8, 0x33, 0x16, 0x31, 0x52, 0x28, 0x30, + 0xC5, 0x05, 0x09, 0x77, 0x07, 0xFD, 0x6B, 0x65, + 0xDD, 0xC2, 0x95, 0x35, 0xAF, 0x95, 0xEE, 0xFC, + 0xD4, 0xD4, 0x7C, 0xCB, 0x0B, 0xB3, 0xBF, 0x91 + }, + { + 0xDB, 0x4D, 0x2E, 0x6A, 0x08, 0x86, 0x8F, 0xE1, + 0x63, 0x98, 0x31, 0x5E, 0x4A, 0xEA, 0x30, 0xCC, + 0x48, 0x3C, 0x37, 0xF7, 0xE7, 0x27, 0xC9, 0xF4, + 0x99, 0xCF, 0xC3, 0x32, 0x14, 0xCB, 0xBE, 0x80 + }, + { + 0x76, 0x52, 0x7B, 0xA3, 0x98, 0x0A, 0xF7, 0xE3, + 0x10, 0x75, 0x3B, 0x8C, 0x62, 0x32, 0xEF, 0xCB, + 0x80, 0x95, 0xB1, 0x6E, 0x6E, 0x69, 0x9D, 0x2C, + 0xE9, 0x01, 0xC8, 0xF2, 0x18, 0x3C, 0xCF, 0x3D + }, + { + 0x1A, 0xE8, 0x29, 0x2A, 0xDC, 0xAB, 0xA1, 0x0A, + 0x69, 0x63, 0xD5, 0xAE, 0x90, 0xFB, 0x1A, 0x5F, + 0x78, 0x7D, 0x91, 0x1B, 0xEC, 0x69, 0x36, 0xF6, + 0xCE, 0x42, 0xA5, 0xA3, 0x3B, 0x0D, 0x97, 0xCE + }, + { + 0x48, 0x3C, 0x01, 0xB7, 0xEF, 0x12, 0xD8, 0xA7, + 0xF4, 0xFB, 0x15, 0x51, 0xA6, 0x16, 0x33, 0xF1, + 0xDE, 0x6A, 0x59, 0x6B, 0x80, 0xF8, 0x8F, 0x16, + 0x90, 0xDB, 0x82, 0xC1, 0xBD, 0xFD, 0x7C, 0x43 + }, + { + 0x88, 0x43, 0x8A, 0x6D, 0xEB, 0xC1, 0xF0, 0xF1, + 0xB8, 0xED, 0x45, 0xEA, 0xEA, 0x7D, 0x82, 0x3E, + 0x08, 0x63, 0x71, 0xB7, 0xC5, 0xDE, 0xD8, 0xA6, + 0x8A, 0xD6, 0x29, 0x3F, 0x52, 0x60, 0x80, 0x1B + }, + { + 0x07, 0x41, 0xC1, 0x51, 0x2A, 0x6B, 0x81, 0xB5, + 0xEB, 0x72, 0x08, 0x3A, 0xFB, 0x0E, 0x67, 0x47, + 0x4C, 0x9E, 0x8C, 0x01, 0xE8, 0x14, 0xBF, 0x10, + 0x78, 0x46, 0xD7, 0x35, 0x68, 0x80, 0x10, 0xB0 + }, + { + 0x55, 0x4D, 0x8F, 0x28, 0x27, 0x09, 0x4E, 0x75, + 0x74, 0x8C, 0x71, 0x38, 0x4F, 0xE3, 0x08, 0x43, + 0x82, 0xBE, 0x2B, 0xB5, 0x60, 0x53, 0xFF, 0x85, + 0x87, 0xC6, 0xE4, 0x11, 0x5C, 0x1A, 0x0C, 0x1B + }, + { + 0x12, 0x5F, 0x1E, 0x8A, 0x05, 0x18, 0xFA, 0x75, + 0x9C, 0x73, 0xDF, 0xBC, 0xDD, 0x36, 0x50, 0x03, + 0x1B, 0x9E, 0xEC, 0x9B, 0x2D, 0x03, 0xDA, 0x6A, + 0x1B, 0x65, 0x44, 0x19, 0xCA, 0x75, 0xF8, 0x4F + }, + { + 0x0B, 0x1B, 0x30, 0x0A, 0xA6, 0xA0, 0x2D, 0xFA, + 0x34, 0x20, 0xF2, 0x94, 0xCC, 0xD2, 0xC9, 0xD0, + 0x88, 0x22, 0xF9, 0xFD, 0x0F, 0x31, 0x17, 0x6B, + 0x3E, 0x6C, 0x7E, 0x8A, 0xB3, 0x99, 0x54, 0xF6 + }, + { + 0x78, 0x7A, 0xED, 0x4C, 0xB3, 0x57, 0xB9, 0xEB, + 0xDB, 0xA0, 0x40, 0x31, 0x9C, 0x5C, 0xCA, 0x7F, + 0x16, 0xEB, 0xB1, 0x36, 0xC4, 0xFB, 0x30, 0xCB, + 0x8C, 0x98, 0xAB, 0xA7, 0xDF, 0xEC, 0x0C, 0xE2 + }, + { + 0x52, 0xC0, 0x51, 0x78, 0x5F, 0x4F, 0x98, 0xAC, + 0xB3, 0xD6, 0x49, 0x75, 0xC6, 0x88, 0x76, 0x09, + 0x3C, 0xEF, 0x49, 0x5F, 0xB7, 0xD8, 0x78, 0xEA, + 0x1B, 0x6D, 0x00, 0x26, 0x02, 0x05, 0x5E, 0x9D + }, + { + 0xCA, 0x09, 0x07, 0xB9, 0xC6, 0x06, 0x5F, 0x45, + 0x43, 0x27, 0x93, 0xA5, 0x3F, 0x7F, 0x7B, 0x70, + 0xF9, 0x57, 0x8D, 0x51, 0x39, 0x0A, 0x42, 0xE6, + 0x6A, 0x7B, 0xAF, 0x4F, 0x17, 0x50, 0x0D, 0xD1 + }, + { + 0x9B, 0x47, 0x76, 0x08, 0xB6, 0xD7, 0x25, 0x14, + 0xE9, 0xE8, 0x2C, 0x75, 0x5A, 0xE8, 0xC7, 0xF9, + 0xD5, 0x12, 0x43, 0xEA, 0xF7, 0x5D, 0xFF, 0x58, + 0x00, 0xD3, 0xED, 0x8B, 0x17, 0x12, 0x46, 0xAC + }, + { + 0x53, 0xED, 0x57, 0x97, 0x4C, 0x7D, 0x17, 0x96, + 0xBA, 0x85, 0x71, 0x9E, 0xA3, 0x8B, 0xF9, 0xF5, + 0xC6, 0x73, 0x5D, 0xD7, 0x8D, 0x24, 0x05, 0x2F, + 0xB4, 0x35, 0xE9, 0xDA, 0x30, 0xDE, 0x31, 0xA5 + }, + { + 0x1F, 0x67, 0x8D, 0x39, 0x77, 0x48, 0xB6, 0x82, + 0xF6, 0x84, 0xEA, 0x11, 0xDC, 0x73, 0x59, 0x84, + 0x6E, 0x8A, 0xA2, 0x80, 0xC6, 0x2B, 0xFF, 0x5C, + 0x94, 0xD7, 0x25, 0x95, 0xE6, 0x89, 0x97, 0x63 + }, + { + 0x1A, 0x85, 0x61, 0x02, 0x5B, 0xFE, 0x19, 0x80, + 0xBA, 0xD9, 0xBA, 0xB1, 0x96, 0x99, 0x19, 0x74, + 0xBE, 0xB7, 0xDF, 0xCB, 0xC8, 0xA0, 0x04, 0xDF, + 0x4B, 0x7B, 0x98, 0x67, 0x45, 0x3A, 0x75, 0x96 + }, + { + 0x5A, 0xF5, 0x4D, 0xD4, 0xC7, 0x1B, 0x0D, 0xA1, + 0xBC, 0x70, 0x3B, 0x74, 0xF9, 0x87, 0x4E, 0x30, + 0x45, 0xE4, 0x78, 0x0E, 0x8D, 0xBC, 0xF4, 0xF9, + 0xAA, 0xC0, 0xF2, 0xF4, 0x74, 0x97, 0xE5, 0xF9 + }, + { + 0x8A, 0x12, 0x21, 0x3D, 0x1F, 0x9C, 0xD5, 0xCB, + 0xC7, 0x62, 0x75, 0xBE, 0xEE, 0x31, 0x75, 0x30, + 0x05, 0x69, 0xE2, 0x95, 0x51, 0xCA, 0xBC, 0x39, + 0x4E, 0xC4, 0x68, 0xA3, 0x9A, 0x42, 0xD7, 0x88 + }, + { + 0x7A, 0x4D, 0xCE, 0x16, 0xA7, 0xDF, 0xC6, 0x3D, + 0x84, 0xDB, 0x9F, 0x09, 0xE3, 0x03, 0xC9, 0x09, + 0x5D, 0xEC, 0xA8, 0x42, 0xE6, 0xB4, 0xC4, 0x28, + 0xF0, 0x31, 0xAC, 0xA6, 0x08, 0xCD, 0x2E, 0x47 + }, + { + 0x7B, 0xD1, 0xED, 0xEC, 0xA6, 0x9D, 0x19, 0xA7, + 0x26, 0x5C, 0x14, 0x7D, 0x28, 0x49, 0x2F, 0x74, + 0xC0, 0xA5, 0x52, 0x10, 0xBB, 0x78, 0x3C, 0x26, + 0xC9, 0xE0, 0x78, 0x16, 0x3E, 0xB2, 0x48, 0xEA + }, + { + 0xAF, 0x50, 0xF9, 0xC6, 0xEE, 0x5E, 0x37, 0xAD, + 0x37, 0x79, 0x38, 0xDE, 0xEE, 0x0B, 0x13, 0xAB, + 0x40, 0x89, 0xA6, 0x23, 0xE7, 0xFA, 0x1B, 0x99, + 0x58, 0xAE, 0x73, 0x2C, 0xBE, 0x9E, 0x78, 0x1A + }, + { + 0x2B, 0x40, 0x39, 0xA4, 0xD7, 0xE6, 0x67, 0x9B, + 0x5F, 0x51, 0x55, 0xC2, 0x37, 0x9C, 0xB1, 0x62, + 0x00, 0x5B, 0x22, 0x8C, 0xED, 0xA6, 0xF4, 0x87, + 0xBE, 0x80, 0x53, 0xB6, 0xF6, 0x34, 0xE6, 0x5F + }, + { + 0x18, 0xAE, 0xE5, 0x8F, 0x7F, 0x2C, 0x1A, 0xDB, + 0xCD, 0x89, 0x5E, 0x1D, 0xA5, 0x1F, 0xE7, 0x4F, + 0x27, 0x74, 0xC5, 0x3B, 0xA5, 0x0F, 0x3B, 0x88, + 0x21, 0x4E, 0xC4, 0x28, 0xDF, 0xB3, 0x3E, 0x19 + }, + { + 0xC4, 0x55, 0xF6, 0xED, 0x1A, 0xB0, 0xE7, 0xFA, + 0xE4, 0xDF, 0x5C, 0x76, 0xED, 0x08, 0xCF, 0xD2, + 0xF3, 0x05, 0xA6, 0x36, 0xD2, 0x17, 0xC2, 0xE5, + 0x31, 0xC2, 0x17, 0x02, 0x61, 0x7C, 0x57, 0xEF + }, + { + 0xEA, 0x56, 0x09, 0x14, 0x19, 0xF8, 0xA4, 0xDB, + 0xE3, 0x85, 0x9E, 0xEA, 0xBD, 0x99, 0xCD, 0x23, + 0x9A, 0x9B, 0x73, 0x94, 0x59, 0x15, 0x97, 0x86, + 0xD6, 0x14, 0xF9, 0x57, 0xFB, 0xC0, 0x1A, 0x81 + }, + { + 0xEE, 0x10, 0x7B, 0xF3, 0xBE, 0xDA, 0x55, 0x34, + 0xD9, 0xF3, 0xDF, 0xEB, 0xFD, 0x6A, 0x57, 0x9D, + 0x03, 0x9F, 0x1A, 0x48, 0xE1, 0xEB, 0x28, 0x7D, + 0x83, 0x18, 0xD5, 0x7D, 0xD4, 0x7C, 0x0F, 0xE6 + }, + { + 0x3A, 0x55, 0x60, 0xFD, 0xDE, 0xE4, 0x3B, 0xAC, + 0x43, 0x70, 0x40, 0x6F, 0xF3, 0xCD, 0x2A, 0xE7, + 0xC5, 0xDD, 0xE4, 0x33, 0x83, 0x93, 0x98, 0x7A, + 0xCD, 0x74, 0x8F, 0x4B, 0xAE, 0x8C, 0x38, 0x74 + }, + { + 0xE4, 0x49, 0xEE, 0x62, 0x71, 0xE1, 0x77, 0xBA, + 0xB6, 0xDA, 0x51, 0x04, 0x6F, 0x7C, 0x14, 0xC9, + 0x1A, 0xB5, 0x57, 0x11, 0x51, 0x2A, 0x9C, 0x11, + 0xB0, 0x36, 0x04, 0xF6, 0x99, 0x95, 0x2E, 0x6F + }, + { + 0x96, 0x89, 0x0D, 0x2B, 0x71, 0x2A, 0x5D, 0x1D, + 0x46, 0x70, 0x6F, 0x8C, 0x11, 0x84, 0x40, 0x10, + 0x22, 0x81, 0xE7, 0x53, 0x05, 0x24, 0x34, 0x6A, + 0xA3, 0x11, 0x06, 0x0E, 0xD6, 0x61, 0x42, 0xB7 + }, + { + 0xE1, 0xD9, 0x0E, 0xC6, 0xDA, 0xB0, 0x48, 0xCA, + 0x03, 0xC4, 0x71, 0x65, 0xEA, 0xD0, 0x9F, 0x37, + 0x35, 0x9D, 0x00, 0xC3, 0x62, 0x51, 0x6D, 0x99, + 0xA6, 0x26, 0x0D, 0x17, 0x0C, 0x86, 0xDA, 0x6B + }, + { + 0xF2, 0x2F, 0x7D, 0x58, 0xCD, 0x5A, 0x53, 0x70, + 0x70, 0x26, 0xC0, 0x0D, 0x6F, 0xBF, 0x75, 0x7E, + 0xC9, 0x7C, 0x5F, 0x3D, 0xA3, 0xD0, 0x00, 0xF5, + 0x35, 0x60, 0x04, 0x2D, 0xB1, 0x07, 0x63, 0x7E + }, + { + 0xF7, 0x1B, 0x59, 0xCF, 0xC9, 0xD2, 0x56, 0x19, + 0x09, 0x29, 0x3A, 0xB0, 0x42, 0x93, 0x11, 0x90, + 0x8B, 0x09, 0xDD, 0x82, 0x8B, 0xE0, 0xB9, 0xDB, + 0xA8, 0xC7, 0x5A, 0xCB, 0x70, 0xF3, 0x05, 0x46 + }, + { + 0xA7, 0x16, 0xBF, 0x7D, 0xCA, 0x26, 0xAF, 0xF2, + 0xF6, 0xC9, 0xD6, 0x2D, 0x3C, 0x77, 0x5E, 0x09, + 0x17, 0xE7, 0x2C, 0xB8, 0x9A, 0x2E, 0xD0, 0x98, + 0xE6, 0x58, 0x82, 0xEE, 0x18, 0x5D, 0x11, 0x14 + }, + { + 0x72, 0x35, 0xF7, 0xBC, 0x01, 0x6A, 0x7B, 0xB7, + 0x6C, 0x62, 0xFE, 0xEB, 0x35, 0xBD, 0x4F, 0x5C, + 0x05, 0x26, 0x9A, 0xB1, 0xE3, 0xA4, 0x08, 0x59, + 0x62, 0x3C, 0xAD, 0xB4, 0x88, 0x16, 0x74, 0x96 + }, + { + 0x7A, 0x1D, 0x34, 0xDA, 0x49, 0x24, 0x62, 0xAE, + 0x98, 0x89, 0xEC, 0xED, 0xC4, 0x80, 0xD7, 0xB4, + 0x08, 0xE7, 0x44, 0x21, 0x6A, 0xBB, 0x79, 0x29, + 0xBA, 0x5E, 0xD8, 0xFC, 0x37, 0xDA, 0x8C, 0xC4 + }, + { + 0x7E, 0x9D, 0xA8, 0x5F, 0x46, 0x05, 0x0D, 0x6E, + 0x6A, 0x20, 0xD9, 0xCF, 0xBB, 0x51, 0x04, 0x0B, + 0x97, 0x5C, 0x40, 0x1F, 0x85, 0xAF, 0x96, 0x2C, + 0x3E, 0x6B, 0x5C, 0x22, 0x13, 0x10, 0xF8, 0x93 + }, + { + 0x8D, 0xFE, 0x42, 0xD7, 0x2F, 0x8E, 0x5C, 0xF2, + 0xB7, 0x86, 0xFA, 0xF4, 0x08, 0x49, 0xCB, 0x7C, + 0x7B, 0x75, 0xBC, 0x58, 0x61, 0xDF, 0x20, 0xB2, + 0xA2, 0x63, 0x4B, 0x59, 0xF5, 0x63, 0x2D, 0xFB + }, + { + 0xA9, 0xE0, 0x30, 0x73, 0x98, 0x49, 0x72, 0xA3, + 0xEB, 0x0D, 0xDA, 0x77, 0x97, 0xF8, 0x8C, 0xDE, + 0xB6, 0x65, 0xBE, 0xC0, 0x0B, 0x3D, 0xE2, 0x40, + 0x47, 0x69, 0x7C, 0x9F, 0xD6, 0xE3, 0xB7, 0x70 + }, + { + 0x14, 0x22, 0xFD, 0xBE, 0xBE, 0xAB, 0xCA, 0x6C, + 0xA3, 0xDB, 0x36, 0x7D, 0xB4, 0xA6, 0x3F, 0xFD, + 0x8D, 0x7A, 0x39, 0x1E, 0x29, 0xF1, 0x1F, 0xD1, + 0x21, 0x57, 0x68, 0x46, 0xB2, 0x7B, 0x8A, 0xB1 + }, + { + 0x52, 0x83, 0x57, 0xC0, 0x66, 0x41, 0xAC, 0x1C, + 0x4D, 0x40, 0xDE, 0x4A, 0x31, 0x75, 0x56, 0xFB, + 0x4D, 0xB2, 0x2C, 0xDA, 0x73, 0xAB, 0x22, 0x85, + 0xC5, 0xC0, 0x12, 0xE7, 0x5B, 0xAF, 0x21, 0x4F + }, + { + 0xAA, 0x9D, 0x22, 0xDB, 0xF8, 0x2B, 0xDB, 0x88, + 0xF9, 0xFB, 0xF2, 0xD5, 0x92, 0xAE, 0x6C, 0x82, + 0x59, 0x28, 0xC2, 0xC3, 0x1C, 0xD1, 0xD5, 0x0F, + 0xAD, 0x49, 0xC9, 0x59, 0x3D, 0x29, 0x89, 0xFE + }, + { + 0x16, 0x61, 0x60, 0xED, 0x4E, 0x6B, 0xB8, 0xEC, + 0x3E, 0x46, 0x9E, 0xD5, 0x5D, 0x80, 0x23, 0x9B, + 0x74, 0x36, 0xEB, 0xAF, 0x12, 0x3B, 0x25, 0xA6, + 0xB9, 0x63, 0x26, 0x45, 0xC4, 0x3E, 0x64, 0x5C + }, + { + 0x78, 0xB4, 0xFD, 0xC5, 0x63, 0xF6, 0x42, 0xA1, + 0xB3, 0x64, 0xA3, 0x78, 0x86, 0x90, 0x39, 0xEE, + 0xB8, 0xA7, 0x8A, 0x32, 0x71, 0x89, 0x14, 0xEA, + 0x5F, 0x4F, 0x34, 0x54, 0x29, 0x29, 0xAC, 0xBA + }, + { + 0xC9, 0xC4, 0xFB, 0x2B, 0x5F, 0xA4, 0xEB, 0xCB, + 0x34, 0x11, 0x7F, 0x72, 0xDC, 0x79, 0x43, 0x2D, + 0x72, 0x78, 0xB9, 0xD9, 0x8A, 0x01, 0xD5, 0x57, + 0x1C, 0x9D, 0xC8, 0x26, 0x84, 0xAD, 0xCA, 0xA1 + }, + { + 0xBF, 0x54, 0x6C, 0x73, 0xF5, 0x0C, 0xFE, 0x45, + 0xC3, 0x04, 0x6F, 0x05, 0x05, 0x62, 0x6B, 0x8B, + 0xFC, 0xB5, 0x99, 0x16, 0xDF, 0x6E, 0xE5, 0xB6, + 0x3A, 0x5A, 0xB0, 0x99, 0x20, 0xF8, 0xE5, 0x23 + }, + { + 0x48, 0x5F, 0x78, 0x60, 0xF5, 0xDC, 0x82, 0xEC, + 0x61, 0xA0, 0x62, 0x92, 0xFF, 0xBF, 0x25, 0x5E, + 0xBB, 0x6C, 0xD3, 0xBC, 0x4C, 0x0A, 0x7E, 0x5F, + 0x71, 0x26, 0x7A, 0x8C, 0x85, 0xDA, 0x35, 0x67 + }, + { + 0xDE, 0x46, 0xED, 0xCE, 0x82, 0xEC, 0xAB, 0xDF, + 0x24, 0x5C, 0x24, 0x0F, 0x04, 0x2D, 0x3C, 0x78, + 0xDA, 0x3B, 0x0C, 0x5D, 0x8C, 0x53, 0xBF, 0x51, + 0x18, 0x71, 0xF3, 0x61, 0x44, 0x0C, 0xDF, 0x62 + }, + { + 0xBC, 0xCA, 0x61, 0x5E, 0xCC, 0x0A, 0xD0, 0x6E, + 0x61, 0x65, 0x4E, 0x6F, 0xFF, 0xDF, 0x7E, 0x04, + 0x74, 0x93, 0xDF, 0xCC, 0xC9, 0xF6, 0x6B, 0x16, + 0x13, 0xAC, 0x09, 0xBE, 0x4C, 0x8D, 0x41, 0x9A + }, + { + 0x3F, 0xBF, 0x96, 0x6D, 0x4D, 0x3F, 0x20, 0x67, + 0xDF, 0x8F, 0xD4, 0x15, 0xC2, 0x51, 0x8D, 0xEE, + 0x08, 0x69, 0xB1, 0x79, 0x88, 0x2F, 0x3E, 0x11, + 0xF4, 0x80, 0x73, 0x08, 0x2D, 0x17, 0xB9, 0xD7 + }, + { + 0x87, 0x5D, 0x13, 0x42, 0xDA, 0x70, 0xDA, 0xAC, + 0x1F, 0xF7, 0x22, 0xD9, 0x94, 0x23, 0x19, 0x10, + 0x37, 0x7F, 0x84, 0xD6, 0x06, 0x88, 0xC6, 0xD4, + 0x86, 0x93, 0x8F, 0xEA, 0x95, 0x8A, 0x50, 0x63 + }, + { + 0x37, 0x0C, 0x45, 0x88, 0x44, 0xE0, 0x58, 0x81, + 0x31, 0xD0, 0x9E, 0x5B, 0xE2, 0xD5, 0xE7, 0x49, + 0x3B, 0x0A, 0x7A, 0xD0, 0x9A, 0x68, 0xD8, 0x86, + 0x3E, 0x0F, 0x48, 0x1B, 0x5D, 0xCB, 0x98, 0x49 + }, + { + 0x69, 0xCD, 0x69, 0x8D, 0xF0, 0x46, 0x71, 0x0C, + 0x1A, 0xAC, 0x0E, 0xD0, 0x02, 0x77, 0x48, 0x82, + 0xEF, 0x54, 0xA9, 0x9D, 0xBA, 0x0D, 0x56, 0x7C, + 0x92, 0x6F, 0xD8, 0xD9, 0x90, 0xF3, 0x15, 0xC9 + }, + { + 0xF6, 0xC0, 0xA8, 0xC2, 0xEA, 0x42, 0x5B, 0x94, + 0xB1, 0x62, 0xB6, 0xB8, 0xB4, 0xAD, 0xC2, 0xB3, + 0x54, 0xF4, 0xB4, 0x44, 0x2C, 0xBC, 0x17, 0xE1, + 0xD1, 0xBA, 0x17, 0x24, 0x2E, 0x0C, 0x7A, 0x96 + }, + { + 0xC1, 0xDB, 0x0B, 0xD5, 0xBD, 0x0E, 0x65, 0xB8, + 0x0A, 0x92, 0x13, 0xFA, 0xA9, 0x3B, 0x9A, 0x62, + 0xBA, 0x40, 0xCF, 0xD0, 0xF8, 0xEE, 0x1D, 0x66, + 0x8D, 0x19, 0xD3, 0xC3, 0x7B, 0x45, 0x85, 0x13 + }, + { + 0xD1, 0xDA, 0xEA, 0x3C, 0xD4, 0x6C, 0xCD, 0xE4, + 0x69, 0x40, 0xD7, 0x98, 0x6E, 0x43, 0xCC, 0x7A, + 0x9B, 0x19, 0xC6, 0x03, 0xD1, 0x84, 0x0D, 0xCC, + 0x84, 0x96, 0x3F, 0x6F, 0x34, 0x18, 0x9A, 0x37 + }, + { + 0x6D, 0xBA, 0xE7, 0xE2, 0x82, 0x3C, 0x0D, 0x27, + 0xBB, 0x07, 0xD4, 0xAE, 0xEE, 0xC2, 0x6A, 0x81, + 0x95, 0x28, 0xCE, 0x27, 0x5A, 0xB5, 0x4B, 0x9F, + 0x93, 0x7E, 0xE7, 0x16, 0x44, 0x4E, 0xCE, 0xE2 + }, + { + 0x42, 0x80, 0xD3, 0x1B, 0xE6, 0x05, 0x05, 0x57, + 0xCC, 0x52, 0x47, 0x3D, 0xAD, 0x08, 0x10, 0x4F, + 0x9C, 0x2D, 0x70, 0x3B, 0x89, 0xB4, 0x3F, 0xEA, + 0x36, 0x33, 0xFB, 0xFC, 0x0D, 0x64, 0x4C, 0x6A + }, + { + 0xC1, 0x3E, 0x65, 0xE1, 0xF6, 0xD0, 0x5B, 0x26, + 0xB1, 0xBA, 0xF8, 0x26, 0x96, 0xD1, 0x07, 0x0E, + 0x6D, 0x5E, 0x07, 0x10, 0x61, 0x86, 0x1C, 0x98, + 0x3E, 0x94, 0x36, 0x67, 0x12, 0x64, 0x3F, 0x17 + }, + { + 0x61, 0x4B, 0x6F, 0x95, 0x96, 0x15, 0xFB, 0xC8, + 0x1B, 0xC4, 0x1C, 0xEA, 0xC4, 0x8C, 0x66, 0xDF, + 0x9A, 0x3C, 0x50, 0x0F, 0x56, 0x19, 0x97, 0x7C, + 0x87, 0x6A, 0xA7, 0x5E, 0x93, 0x4B, 0xD5, 0x6A + }, + { + 0x0E, 0x57, 0x2B, 0x9E, 0x6F, 0xC2, 0x27, 0x79, + 0x17, 0x3B, 0x9F, 0x67, 0x3B, 0x42, 0x29, 0x16, + 0x5C, 0x66, 0xF0, 0x01, 0xFA, 0x1B, 0x10, 0x0F, + 0xFA, 0xA4, 0xAC, 0x18, 0xB2, 0x9B, 0x1B, 0x23 + }, + { + 0x6D, 0x61, 0xE9, 0x9A, 0x4B, 0x64, 0x05, 0x0C, + 0x5E, 0x0F, 0xE7, 0x56, 0x10, 0x37, 0x8D, 0x9D, + 0xD4, 0xBB, 0xEE, 0x5E, 0x16, 0x3C, 0x84, 0x59, + 0xD2, 0xFE, 0xE5, 0xA5, 0x32, 0x7C, 0x81, 0x3D + }, + { + 0x0B, 0xA6, 0x51, 0x7D, 0xE4, 0x9A, 0x77, 0xC1, + 0x95, 0x7E, 0x05, 0xB3, 0xD0, 0xC0, 0x18, 0x54, + 0xDC, 0x8C, 0xAF, 0x3C, 0xED, 0x97, 0x90, 0x1E, + 0xAC, 0xCE, 0x23, 0x2A, 0x81, 0x83, 0x89, 0x8D + }, + { + 0x2F, 0x05, 0x31, 0x64, 0x33, 0xEA, 0xF4, 0x13, + 0x12, 0x60, 0x96, 0x6B, 0x85, 0x0E, 0x45, 0x01, + 0x18, 0x2D, 0x2A, 0xEB, 0x4B, 0x60, 0x09, 0xC4, + 0x25, 0x71, 0xAA, 0xE7, 0xB1, 0xA3, 0xE4, 0x61 + }, + { + 0x25, 0x17, 0xC6, 0x90, 0x7C, 0x82, 0x15, 0xF6, + 0xF1, 0xBC, 0x5A, 0xD2, 0x47, 0xDC, 0x4B, 0xCA, + 0xBE, 0xBD, 0xA2, 0x37, 0x72, 0xF1, 0x87, 0xB7, + 0x08, 0xB4, 0x6A, 0x48, 0x42, 0x68, 0xF4, 0x1B + }, + { + 0x65, 0xCF, 0xAA, 0xF5, 0x9C, 0x79, 0x01, 0x0A, + 0x8B, 0x54, 0x90, 0x81, 0xDA, 0x3F, 0xA7, 0xDA, + 0xEA, 0x4A, 0x73, 0xAD, 0x21, 0x59, 0xD6, 0x6B, + 0x45, 0x41, 0x41, 0x5B, 0x98, 0x37, 0x17, 0x03 + }, + { + 0x44, 0x80, 0x60, 0xBE, 0xBC, 0x63, 0x48, 0x40, + 0xE0, 0xD8, 0x57, 0xC6, 0x57, 0x77, 0xF3, 0xC3, + 0x33, 0x0E, 0xA8, 0xD9, 0xC4, 0x09, 0xBD, 0x06, + 0x71, 0xD3, 0x14, 0x96, 0x9C, 0x58, 0x73, 0x60 + }, + { + 0xCF, 0x69, 0xE1, 0x6A, 0xD6, 0xC1, 0xBA, 0xC2, + 0x08, 0x5B, 0xC7, 0x66, 0xF5, 0xDE, 0x13, 0x3C, + 0xFD, 0xF8, 0x7B, 0xE2, 0x96, 0x84, 0xF0, 0xBB, + 0x7D, 0x2B, 0xDA, 0x8D, 0xC7, 0x1E, 0x70, 0x0E + }, + { + 0x87, 0x1B, 0x35, 0xB7, 0xDB, 0x7F, 0x0D, 0xA1, + 0x88, 0x36, 0xBF, 0x66, 0xA8, 0x80, 0x81, 0x83, + 0xD7, 0x70, 0x35, 0x84, 0x9E, 0xF5, 0x94, 0x1D, + 0x0A, 0x2C, 0x43, 0xDE, 0xFA, 0x2B, 0xBF, 0x37 + }, + { + 0xE4, 0x31, 0x4A, 0x5D, 0x5F, 0xBF, 0xF3, 0xB2, + 0x15, 0xF9, 0x4B, 0x4F, 0x24, 0x49, 0x84, 0x61, + 0x23, 0x3A, 0xCA, 0xCA, 0xC4, 0xBA, 0x96, 0x76, + 0x38, 0xB8, 0x08, 0x03, 0x90, 0x4A, 0xFD, 0x9A + }, + { + 0x12, 0x48, 0x7E, 0xDB, 0x7E, 0x0F, 0x39, 0x30, + 0xE7, 0xBD, 0x47, 0x4D, 0x6A, 0x61, 0xC8, 0xE0, + 0x36, 0x58, 0x61, 0xD6, 0x42, 0xC2, 0xBF, 0x32, + 0x55, 0x62, 0xB3, 0xA8, 0xEE, 0x11, 0xE3, 0xB5 + }, + { + 0x62, 0x07, 0x52, 0xB3, 0x68, 0x86, 0x06, 0xE0, + 0xDC, 0x9C, 0x0A, 0xE7, 0x06, 0x27, 0x00, 0x19, + 0x89, 0x67, 0xB8, 0x7D, 0xFB, 0xB5, 0x1E, 0x4C, + 0x18, 0x1A, 0xAF, 0x34, 0x34, 0xEC, 0x6C, 0x68 + }, + { + 0x06, 0x55, 0x34, 0x18, 0xD7, 0x09, 0xC5, 0x29, + 0xE8, 0xC1, 0xE3, 0x67, 0xFE, 0x5A, 0x15, 0xFB, + 0x48, 0x37, 0x05, 0x59, 0xA2, 0x24, 0x01, 0xB3, + 0x2B, 0xEA, 0x4A, 0x92, 0x00, 0x36, 0x94, 0x39 + }, + { + 0x08, 0xE1, 0x47, 0x99, 0xE3, 0xEE, 0xD6, 0x09, + 0x5E, 0x23, 0xEE, 0x47, 0xB4, 0x87, 0x97, 0x35, + 0x3A, 0xE4, 0x43, 0x17, 0x84, 0x17, 0x39, 0x5C, + 0xFE, 0x97, 0x22, 0x4B, 0xBF, 0xF5, 0xEF, 0x23 + }, + { + 0xF5, 0xF0, 0x41, 0x47, 0x44, 0xB2, 0x5F, 0x77, + 0xA0, 0xA5, 0xC2, 0x6C, 0xC4, 0xDA, 0x8F, 0x57, + 0x54, 0x58, 0x98, 0xCF, 0xB2, 0x9A, 0x44, 0x4D, + 0x2E, 0xDA, 0x7F, 0xF2, 0x99, 0x0F, 0x53, 0x6F + }, + { + 0x52, 0x36, 0x51, 0x48, 0x6F, 0x5E, 0xD3, 0xA2, + 0xD9, 0xB2, 0xEA, 0x23, 0xA3, 0xCC, 0x3D, 0x62, + 0xA6, 0xE5, 0x72, 0xD7, 0x90, 0x09, 0xC8, 0x19, + 0x80, 0x57, 0xCF, 0xA5, 0xBA, 0x81, 0x54, 0xDA + }, + { + 0xA8, 0x4D, 0x97, 0x42, 0xFF, 0x43, 0xC6, 0xF6, + 0x7A, 0xA8, 0x12, 0x74, 0x44, 0x61, 0xD7, 0xAF, + 0xCE, 0x0A, 0x11, 0x59, 0xE9, 0x93, 0xED, 0x05, + 0xA4, 0xC1, 0x90, 0x34, 0x6F, 0xE8, 0x21, 0xD7 + }, + { + 0x79, 0xEF, 0x01, 0x29, 0x96, 0x53, 0xA9, 0xDA, + 0xD5, 0x7C, 0x23, 0xFF, 0xCA, 0x9B, 0x9A, 0x89, + 0x21, 0xE8, 0xFE, 0xBF, 0x62, 0xBD, 0x24, 0x50, + 0x41, 0x2E, 0x31, 0xD3, 0x01, 0x67, 0xE5, 0x30 + }, + { + 0xA2, 0xCD, 0xC5, 0xAF, 0x62, 0x9C, 0x73, 0xB3, + 0x37, 0x03, 0x41, 0xB4, 0x2C, 0xE1, 0x90, 0x0C, + 0x60, 0xE0, 0x7C, 0x7F, 0x65, 0x2D, 0x68, 0xD9, + 0xC9, 0x7D, 0x49, 0xB1, 0x1E, 0xB6, 0x92, 0x11 + }, + { + 0x8C, 0x04, 0x7E, 0x14, 0x92, 0xC5, 0x52, 0x8D, + 0xB9, 0xEE, 0x6C, 0x58, 0x16, 0x36, 0x37, 0x8A, + 0x30, 0x57, 0xD6, 0x32, 0x09, 0xB4, 0x96, 0xE5, + 0x35, 0xBD, 0xDA, 0xF1, 0x74, 0xD6, 0x0A, 0x99 + }, + { + 0xF2, 0x8B, 0x05, 0x0A, 0xFA, 0xAA, 0x17, 0x1E, + 0x01, 0xA5, 0xFD, 0x82, 0x8F, 0x60, 0x09, 0xFA, + 0xFF, 0xA7, 0x64, 0x24, 0xC6, 0x57, 0x43, 0x49, + 0xDD, 0x1A, 0x71, 0x80, 0xEF, 0x09, 0x78, 0xE4 + }, + { + 0x29, 0x47, 0xD7, 0xA3, 0x62, 0xC8, 0x2D, 0x4A, + 0x6E, 0x77, 0x01, 0xBE, 0x4A, 0x49, 0x4C, 0x99, + 0xB7, 0x0E, 0xAB, 0xC7, 0x1B, 0x92, 0x80, 0xB3, + 0xBC, 0x86, 0x8B, 0x0D, 0x79, 0xF0, 0x25, 0xDC + }, + { + 0x93, 0x3D, 0x4A, 0x03, 0x92, 0x72, 0x36, 0xEB, + 0x64, 0x5C, 0xF0, 0x4A, 0x3A, 0x12, 0x22, 0xE4, + 0xCA, 0x88, 0x93, 0xE0, 0x73, 0x9F, 0x61, 0x58, + 0x74, 0x53, 0xBC, 0x4A, 0xD7, 0xA7, 0x0D, 0x88 + }, + { + 0x56, 0x25, 0x77, 0x7F, 0x41, 0x3C, 0x46, 0x42, + 0x02, 0xC2, 0x82, 0xC0, 0xAB, 0xC6, 0x2A, 0xDE, + 0x2B, 0xF0, 0x30, 0xDF, 0x9F, 0x17, 0xAF, 0xF7, + 0x6D, 0xCF, 0x0F, 0x75, 0xC3, 0xD8, 0x17, 0xCA + }, + { + 0xE4, 0xAA, 0x95, 0x94, 0x63, 0x49, 0xBB, 0x6E, + 0xA2, 0xFB, 0x61, 0xD1, 0xA1, 0x23, 0x01, 0x88, + 0x65, 0xF6, 0x3F, 0x36, 0x3F, 0x0F, 0xC1, 0x82, + 0x61, 0x21, 0x7D, 0xBF, 0x03, 0x3A, 0xCB, 0x5D + }, + { + 0x5F, 0xCE, 0x48, 0xCB, 0x8A, 0xF4, 0xE3, 0x50, + 0x82, 0x09, 0x9F, 0x75, 0xE2, 0xAC, 0x01, 0xFA, + 0x62, 0xB9, 0x6A, 0xD3, 0x43, 0x7A, 0xCC, 0xA1, + 0x46, 0xC5, 0xD7, 0xE6, 0xDE, 0x86, 0x07, 0xDE + }, + { + 0x83, 0x69, 0x74, 0x97, 0x43, 0x2C, 0x60, 0x7D, + 0xDE, 0xF8, 0x8E, 0x29, 0xCF, 0xBB, 0xCA, 0x82, + 0x55, 0x72, 0x44, 0xF3, 0xC6, 0x97, 0x30, 0x7C, + 0x27, 0x6F, 0x1A, 0x68, 0xC9, 0xB6, 0x1F, 0x56 + }, + { + 0x76, 0xD4, 0x4A, 0xA6, 0xB2, 0xFC, 0x9D, 0xF3, + 0xBB, 0xE0, 0x36, 0x38, 0x49, 0x63, 0x45, 0x30, + 0x25, 0x4A, 0xA9, 0xE3, 0x93, 0xEB, 0x49, 0x42, + 0x74, 0xCE, 0xB0, 0xA6, 0xD4, 0x69, 0x5B, 0x38 + }, + { + 0x3A, 0xD7, 0xB6, 0x87, 0xA2, 0xBB, 0x8C, 0x29, + 0x57, 0xFC, 0x57, 0x91, 0x3F, 0xE2, 0xCD, 0x9B, + 0x7F, 0xF1, 0x83, 0x32, 0xAD, 0x7B, 0x47, 0xCE, + 0x7F, 0xB6, 0x8F, 0xA6, 0x07, 0xAD, 0xB3, 0x95 + }, + { + 0xAB, 0xA0, 0xF8, 0x1A, 0x9A, 0xBC, 0x95, 0x57, + 0xDF, 0x27, 0x0F, 0x94, 0x7A, 0xBC, 0x43, 0x7D, + 0xA8, 0x48, 0x08, 0x66, 0xA8, 0xC4, 0x81, 0xA2, + 0x7E, 0x90, 0xD9, 0x4E, 0x50, 0x5D, 0xD6, 0xEC + }, + { + 0x60, 0x48, 0x5F, 0xBC, 0x38, 0x9E, 0x9F, 0xE6, + 0xE1, 0x85, 0xCD, 0x71, 0xDB, 0x3D, 0xE0, 0x25, + 0xB0, 0xC7, 0x11, 0xA2, 0x7A, 0x97, 0x6A, 0xE0, + 0xE6, 0xF4, 0xC5, 0x3D, 0x8D, 0xC0, 0x15, 0xD0 + }, + { + 0x8B, 0x70, 0x67, 0x6E, 0x7C, 0xAD, 0x65, 0x14, + 0xDC, 0x54, 0xDE, 0x74, 0xC7, 0xF0, 0x69, 0x17, + 0x1A, 0x6C, 0x76, 0x6C, 0xE9, 0x90, 0x6A, 0xEF, + 0x1D, 0x62, 0xCA, 0x0C, 0x46, 0x38, 0x75, 0x87 + }, + { + 0xB8, 0x20, 0xC8, 0xEE, 0x17, 0x98, 0x34, 0x29, + 0xEC, 0xB3, 0x5D, 0x2E, 0xED, 0x17, 0xF8, 0x1C, + 0xD9, 0xC8, 0x8B, 0x35, 0x33, 0x45, 0xD2, 0xA1, + 0x57, 0xD8, 0x77, 0x4B, 0xE0, 0x82, 0xA4, 0xF1 + }, + { + 0x20, 0xC8, 0x36, 0x72, 0xE0, 0x63, 0xF4, 0x62, + 0xB5, 0x4C, 0x0B, 0x87, 0x8B, 0xDC, 0x0E, 0x4A, + 0x87, 0xE6, 0x81, 0xB2, 0x00, 0x1C, 0x00, 0x2E, + 0xA8, 0xE5, 0x71, 0xAA, 0x55, 0x25, 0x7E, 0xA4 + }, + { + 0xBF, 0xE7, 0x12, 0xB8, 0x44, 0xB3, 0x5D, 0x45, + 0x49, 0x27, 0x69, 0xE2, 0x07, 0x95, 0x30, 0xF2, + 0xC8, 0xB6, 0x20, 0x78, 0x6B, 0x37, 0x6F, 0x36, + 0xFD, 0x51, 0x39, 0x01, 0xB7, 0x48, 0x8A, 0x57 + }, + { + 0x69, 0x81, 0xB4, 0x59, 0xE5, 0x7C, 0x2B, 0x47, + 0xED, 0x23, 0x8D, 0xFC, 0xC6, 0x67, 0x39, 0xAF, + 0xEA, 0x3F, 0x66, 0x37, 0x37, 0x66, 0x63, 0x29, + 0x85, 0xB0, 0xE6, 0x6C, 0xFE, 0x43, 0x80, 0xDA + }, + { + 0xFC, 0xCA, 0x63, 0xD0, 0xC0, 0xB5, 0x0C, 0xE7, + 0xFE, 0xEA, 0x1D, 0xF5, 0x4F, 0x26, 0x58, 0x9D, + 0x2D, 0xF7, 0xFC, 0xE9, 0xC8, 0xC8, 0x89, 0x69, + 0x19, 0x25, 0x1B, 0xA3, 0x8F, 0x7F, 0x15, 0x49 + }, + { + 0xD3, 0x89, 0x14, 0x8B, 0x8F, 0x05, 0x34, 0xA0, + 0xB7, 0x20, 0x0E, 0x5A, 0xA8, 0x86, 0x73, 0x91, + 0xB6, 0x03, 0xC1, 0xD7, 0x5A, 0x6F, 0x5A, 0x29, + 0x3A, 0xFF, 0x23, 0x40, 0x25, 0x3E, 0xCF, 0x84 + }, + { + 0xA7, 0x46, 0x55, 0x20, 0xB8, 0x49, 0x9E, 0x90, + 0x9C, 0x0E, 0x67, 0x5E, 0x8B, 0xBF, 0xE6, 0x6A, + 0xE7, 0x83, 0xC1, 0x0B, 0xBB, 0x74, 0x03, 0x2C, + 0xA5, 0x85, 0x81, 0xD5, 0x4C, 0xC5, 0xF9, 0x4E + }, + { + 0x96, 0xA7, 0xFE, 0xB9, 0x4C, 0x65, 0x5E, 0xBF, + 0x2C, 0xF0, 0xF5, 0xB6, 0x2B, 0x25, 0x2C, 0xD9, + 0x21, 0x0A, 0x02, 0x1E, 0x7E, 0x8C, 0xDB, 0x76, + 0x15, 0x41, 0xB7, 0xEF, 0xF4, 0x6E, 0xD3, 0xB4 + }, + { + 0x3C, 0x1C, 0xC7, 0xD8, 0xA1, 0x50, 0x91, 0x9B, + 0xD0, 0x28, 0xC2, 0x7A, 0xF3, 0xA2, 0x0E, 0x67, + 0x09, 0x2C, 0xCE, 0xA2, 0xE9, 0x92, 0xE3, 0x65, + 0x61, 0xE2, 0x32, 0x23, 0xDC, 0xF9, 0x10, 0x2C + }, + { + 0x50, 0xB4, 0xAD, 0x39, 0x74, 0x9C, 0xD9, 0x96, + 0xE1, 0x37, 0x6D, 0x56, 0x84, 0xAC, 0x11, 0x46, + 0xF8, 0x0E, 0xD1, 0x90, 0x04, 0xBB, 0xDF, 0xA8, + 0xDF, 0xFD, 0x29, 0x92, 0xCC, 0x0F, 0xB4, 0x84 + }, + { + 0x59, 0x0A, 0x46, 0x9F, 0xD0, 0xF6, 0x48, 0xAB, + 0x1D, 0x91, 0xCE, 0x08, 0xA5, 0x21, 0x71, 0xD4, + 0x7D, 0x7B, 0xFE, 0x1A, 0x88, 0x89, 0xAB, 0x45, + 0xD5, 0xA8, 0xE6, 0x79, 0x24, 0xAF, 0x3B, 0xB7 + }, + { + 0xD0, 0xA9, 0x2F, 0xED, 0x1C, 0xAD, 0x6A, 0xCE, + 0xE3, 0x7C, 0x05, 0x56, 0xDA, 0x37, 0x37, 0xD3, + 0x99, 0x66, 0x09, 0x41, 0xB4, 0x51, 0xEF, 0x5D, + 0x2D, 0x67, 0x42, 0xDD, 0x69, 0x04, 0xD5, 0x80 + }, + { + 0x70, 0xDE, 0x30, 0xA1, 0x7C, 0xEB, 0x6D, 0x84, + 0xE2, 0x53, 0xED, 0x13, 0x89, 0xB1, 0x79, 0xA6, + 0x85, 0x50, 0x9D, 0x82, 0x0F, 0x45, 0x0C, 0xBB, + 0x8C, 0x68, 0xA2, 0xFE, 0x7A, 0x18, 0xBB, 0xAF + }, + { + 0xE8, 0xB8, 0x4C, 0x50, 0x37, 0xF5, 0xAF, 0x8F, + 0xD1, 0xC9, 0xEA, 0xE9, 0x9F, 0xEB, 0xE5, 0x87, + 0x89, 0x52, 0x1F, 0x8F, 0x7C, 0x75, 0x84, 0xD5, + 0x1F, 0x30, 0x44, 0x62, 0x34, 0x2D, 0xC5, 0x2B + }, + { + 0x21, 0x16, 0x32, 0x56, 0x1A, 0xE3, 0x2E, 0x2C, + 0x10, 0x02, 0x96, 0x7C, 0x72, 0x97, 0x7D, 0x59, + 0x77, 0x34, 0x94, 0x67, 0x8C, 0xC7, 0x40, 0xA4, + 0x64, 0x52, 0xF5, 0x68, 0x13, 0x44, 0xEB, 0x58 + }, + { + 0xA2, 0x95, 0x0D, 0x2A, 0x2E, 0xD2, 0x33, 0x79, + 0xE6, 0xD5, 0x20, 0x50, 0xB0, 0xED, 0x12, 0x64, + 0x70, 0xC3, 0xA8, 0x4B, 0xD2, 0x1A, 0x31, 0x99, + 0xD7, 0x62, 0xAD, 0x30, 0x50, 0x0A, 0x62, 0xB5 + }, + { + 0x7D, 0x27, 0x0F, 0x74, 0xCC, 0x4B, 0xD2, 0x63, + 0x64, 0x48, 0x91, 0xC8, 0xDB, 0xB3, 0x4B, 0x6C, + 0x95, 0xDA, 0x23, 0xC3, 0xD3, 0x4A, 0xE5, 0x6A, + 0xDD, 0xA8, 0xC2, 0x61, 0x88, 0x33, 0x83, 0x8D + }, + { + 0x91, 0xC3, 0x6B, 0x41, 0x99, 0x33, 0xEE, 0xB6, + 0x6D, 0xAA, 0x01, 0x2C, 0x96, 0x13, 0x62, 0xEA, + 0x9D, 0x00, 0x57, 0x1A, 0x7E, 0x02, 0xED, 0x98, + 0x7B, 0x88, 0xC1, 0x6D, 0xB0, 0xFD, 0x7D, 0xE9 + }, + { + 0xC1, 0x66, 0x55, 0x91, 0xA7, 0xB9, 0x1B, 0x06, + 0x19, 0xED, 0x08, 0x51, 0x88, 0xA5, 0x50, 0x42, + 0x5A, 0x13, 0x93, 0xDD, 0xDA, 0x42, 0x32, 0xAD, + 0x67, 0xB2, 0x69, 0x49, 0x7C, 0x4B, 0x0E, 0x0E + }, + { + 0xC6, 0x16, 0x3E, 0x31, 0x7A, 0x8D, 0xF7, 0xDC, + 0xA8, 0x5C, 0x0A, 0x20, 0x81, 0x38, 0x1D, 0xC4, + 0x02, 0xF3, 0x50, 0x4F, 0x78, 0x2F, 0x44, 0x70, + 0xA6, 0xC4, 0xCB, 0xF6, 0x1D, 0xEA, 0xFA, 0xB3 + }, + { + 0x39, 0xDB, 0x9E, 0xDA, 0x60, 0xEA, 0x72, 0x2D, + 0xE1, 0x38, 0x53, 0xE8, 0xB0, 0x5A, 0xE1, 0x0C, + 0x0E, 0xDE, 0x4A, 0xB7, 0xEC, 0xE9, 0xF6, 0x57, + 0xF1, 0x95, 0x3D, 0x6F, 0xAA, 0xCF, 0x75, 0xCA + }, + { + 0xA7, 0x64, 0x47, 0x8C, 0x79, 0x73, 0x9A, 0xD1, + 0x2B, 0xC6, 0xA7, 0x67, 0x80, 0xB6, 0x33, 0xAE, + 0x90, 0xA6, 0xB5, 0xD2, 0xB1, 0x83, 0x12, 0x0A, + 0xBB, 0xCA, 0xBE, 0xCA, 0x34, 0xF7, 0x63, 0x30 + }, + { + 0xFC, 0x14, 0xA0, 0x43, 0xBF, 0x06, 0xE3, 0x52, + 0xAB, 0xA7, 0xCE, 0x31, 0x31, 0xE7, 0x86, 0x3C, + 0xEB, 0x13, 0x43, 0xA5, 0x9E, 0xD6, 0xCA, 0xCD, + 0xD1, 0x4C, 0xC2, 0xFC, 0xC8, 0xD0, 0x71, 0x66 + }, + { + 0x4F, 0xEE, 0xBF, 0x87, 0x1B, 0xDD, 0x46, 0x01, + 0x5B, 0x80, 0x94, 0xE5, 0x18, 0xAD, 0x41, 0x28, + 0x54, 0x58, 0xBF, 0x12, 0xA7, 0x71, 0x66, 0x9E, + 0x19, 0xD4, 0xFE, 0x1D, 0x7A, 0xE1, 0x1F, 0x81 + }, + { + 0x64, 0x94, 0xF3, 0x54, 0xBA, 0x76, 0x93, 0x46, + 0x0C, 0xC2, 0x5C, 0xB8, 0x42, 0x88, 0x33, 0x95, + 0xCC, 0xE6, 0x0B, 0x8F, 0x1B, 0x81, 0x44, 0x34, + 0xF5, 0x51, 0xF4, 0x2F, 0x78, 0xD0, 0x4F, 0xE6 + }, + { + 0x84, 0x69, 0x3A, 0xB2, 0xCC, 0x22, 0x03, 0x06, + 0x8D, 0x99, 0x65, 0x20, 0xAB, 0x72, 0x98, 0x88, + 0x21, 0x35, 0xB8, 0x17, 0x9A, 0xC2, 0x84, 0x33, + 0xEF, 0x24, 0x2C, 0xA4, 0x2B, 0x03, 0x9B, 0x6E + }, + { + 0x86, 0x70, 0x72, 0x05, 0x62, 0x02, 0x64, 0x59, + 0xC3, 0x96, 0x07, 0x57, 0xA5, 0x27, 0x7D, 0xC3, + 0x2D, 0x8D, 0xED, 0x89, 0xF4, 0x8E, 0x98, 0x41, + 0x5C, 0x80, 0x7D, 0x80, 0x42, 0xAF, 0x31, 0x83 + }, + { + 0xED, 0x47, 0xFF, 0x70, 0xFA, 0x77, 0xB6, 0x17, + 0x68, 0x3D, 0x2F, 0x03, 0x17, 0x61, 0xC7, 0x41, + 0x1F, 0xAC, 0x4A, 0x0F, 0x63, 0x4E, 0x5A, 0x4D, + 0x7B, 0x72, 0x9D, 0x58, 0x9C, 0x6B, 0x21, 0x7E + }, + { + 0xF2, 0xAB, 0xC8, 0xAE, 0x31, 0x79, 0xE0, 0x3E, + 0xF2, 0x84, 0x7B, 0xD0, 0x0F, 0xF1, 0x8F, 0x17, + 0x9F, 0x0E, 0x5D, 0x95, 0x7A, 0x4E, 0x71, 0x63, + 0xE3, 0x70, 0x95, 0x9E, 0x10, 0x8D, 0x1E, 0x5D + }, + { + 0xB0, 0x62, 0xFA, 0x5A, 0x40, 0x1A, 0x72, 0xDC, + 0xAB, 0x8C, 0x25, 0x0B, 0x06, 0x99, 0xDD, 0x54, + 0x5E, 0x01, 0x70, 0xBD, 0x44, 0x4C, 0x54, 0xB7, + 0xF9, 0x35, 0x93, 0xE3, 0xAC, 0x18, 0xA4, 0xAE + }, + { + 0x39, 0xD9, 0x02, 0x31, 0x75, 0x95, 0xF9, 0x77, + 0x5A, 0x27, 0x50, 0x85, 0x71, 0xE7, 0x40, 0x0F, + 0x4C, 0xF4, 0xB1, 0xA8, 0x13, 0xB6, 0x59, 0xF9, + 0xCD, 0x5D, 0x10, 0x9C, 0xAA, 0xCA, 0x75, 0x7B + }, + { + 0xB6, 0x21, 0xAA, 0x1A, 0x2D, 0xBB, 0x4C, 0x8C, + 0xF0, 0x37, 0x47, 0x7F, 0x78, 0x10, 0x2C, 0x79, + 0x0C, 0xA3, 0x19, 0x17, 0xBD, 0x29, 0x7D, 0xE2, + 0x0E, 0xD5, 0x8B, 0xE3, 0x31, 0xE9, 0xAE, 0x17 + }, + { + 0xE7, 0x62, 0xAB, 0x5D, 0x25, 0xB9, 0x32, 0x84, + 0xC9, 0x00, 0x8E, 0xF4, 0x5A, 0xC1, 0x1B, 0x6A, + 0x19, 0x43, 0xE8, 0x1C, 0xB1, 0x5F, 0xB8, 0xD0, + 0x40, 0xBE, 0x42, 0x5F, 0x81, 0xDA, 0xAC, 0x68 + }, + { + 0x21, 0xAD, 0x63, 0x5E, 0xFE, 0x06, 0x0A, 0x8F, + 0x67, 0x94, 0x59, 0x6B, 0xAA, 0x1F, 0x28, 0x32, + 0xB0, 0xFE, 0xC8, 0xEB, 0x71, 0x72, 0xF1, 0x7A, + 0xCF, 0xEB, 0xAF, 0xFE, 0xCF, 0x80, 0x14, 0xFB + }, + { + 0x84, 0x6E, 0xEB, 0xB5, 0xD4, 0xD9, 0x39, 0xA5, + 0x42, 0x50, 0xED, 0x3F, 0xAE, 0x75, 0xB2, 0xCD, + 0x24, 0xCB, 0x9F, 0xDB, 0x3D, 0xB5, 0xCB, 0x49, + 0xC1, 0xDB, 0x85, 0x2C, 0x98, 0xE9, 0xA3, 0x8B + }, + { + 0xBC, 0xBA, 0x68, 0x95, 0xE3, 0xCB, 0x80, 0x59, + 0xFD, 0xF1, 0x70, 0x39, 0x36, 0x3C, 0x84, 0x25, + 0x49, 0x71, 0xA3, 0x26, 0xD1, 0x29, 0x68, 0x22, + 0x09, 0xC8, 0x2B, 0xA6, 0x17, 0x32, 0x5F, 0xEC + }, + { + 0xF2, 0x37, 0x20, 0x4F, 0xD7, 0xBB, 0x0E, 0x80, + 0x40, 0xD9, 0xE8, 0x37, 0xC9, 0x27, 0xA1, 0x76, + 0x37, 0x1F, 0x2B, 0x11, 0x9E, 0xEA, 0x03, 0x62, + 0x5D, 0xCB, 0xF1, 0x35, 0xDA, 0x9E, 0xB1, 0xB5 + }, + { + 0x52, 0x09, 0xD7, 0xAE, 0xF7, 0x63, 0xF9, 0xEA, + 0xC1, 0x51, 0xB2, 0x2A, 0xBB, 0x7A, 0x80, 0xFD, + 0x68, 0x99, 0x3B, 0x48, 0xC4, 0x8D, 0xC3, 0xC1, + 0x7C, 0x69, 0xB2, 0x80, 0xD9, 0x7C, 0x45, 0x36 + }, + { + 0xEA, 0xE4, 0xD1, 0x6E, 0x01, 0x8F, 0x77, 0x58, + 0xB5, 0xAE, 0x8E, 0x6E, 0x82, 0xB2, 0xA1, 0x87, + 0xBB, 0x30, 0x63, 0xBA, 0x8A, 0x68, 0x88, 0xA8, + 0x4B, 0x9E, 0x89, 0xBE, 0xF9, 0x70, 0x3D, 0x45 + }, + { + 0xD9, 0x62, 0x84, 0x8B, 0x7E, 0xA5, 0x6D, 0x9F, + 0x09, 0x5C, 0xDD, 0x27, 0x59, 0xC0, 0x4F, 0x98, + 0xE8, 0x52, 0x51, 0x32, 0x89, 0x13, 0x3F, 0x8A, + 0x8C, 0xCC, 0xA1, 0x7D, 0x3B, 0x17, 0xFA, 0x4B + }, + { + 0x31, 0xE6, 0x6C, 0x7F, 0xF0, 0xCA, 0x3C, 0x17, + 0x50, 0xF0, 0xF7, 0xDF, 0x69, 0x2E, 0x8E, 0x7C, + 0x15, 0x96, 0x12, 0xD7, 0xC9, 0x3B, 0x70, 0xCB, + 0xA3, 0x3B, 0x13, 0xE2, 0x6C, 0xB3, 0xDA, 0x4C + }, + { + 0x71, 0x50, 0xBC, 0x09, 0x49, 0xBE, 0x55, 0x7E, + 0x79, 0xD9, 0x78, 0xCC, 0x5F, 0x66, 0x5B, 0x79, + 0x6D, 0x9B, 0xFC, 0x26, 0xEC, 0x71, 0x1B, 0xBD, + 0x34, 0x42, 0xD7, 0x4A, 0x0F, 0xF2, 0x23, 0x3B + }, + { + 0x69, 0xFE, 0xA5, 0xC1, 0x70, 0xA4, 0x08, 0xCF, + 0x03, 0xDA, 0xAA, 0x31, 0xFD, 0x21, 0x79, 0xF2, + 0xA7, 0xF7, 0xCF, 0x92, 0xD3, 0x87, 0x23, 0x0D, + 0x8E, 0xFD, 0x00, 0x77, 0xC0, 0x67, 0xD6, 0xBB + }, + { + 0x5A, 0x85, 0xB8, 0x43, 0xE7, 0xB8, 0xC1, 0xEE, + 0xA8, 0xDD, 0x2E, 0x64, 0xA0, 0xBF, 0x0B, 0x3E, + 0x42, 0xE8, 0x21, 0xDD, 0x92, 0xE2, 0x01, 0x2A, + 0x28, 0xAD, 0xA5, 0xFA, 0x94, 0xD8, 0xD7, 0x40 + }, + { + 0x16, 0x9D, 0xA4, 0x88, 0x2B, 0x65, 0x63, 0x8B, + 0x63, 0x94, 0x01, 0x7C, 0xEE, 0x80, 0x25, 0xEC, + 0x35, 0x5C, 0xF4, 0x27, 0xA2, 0x84, 0xF2, 0x7C, + 0xC6, 0x61, 0xB9, 0xA4, 0xFE, 0xE1, 0x00, 0xDA + }, + { + 0x46, 0x50, 0xA7, 0x11, 0xEF, 0x19, 0xB2, 0x96, + 0x55, 0xD4, 0x14, 0x93, 0xBB, 0x36, 0xB7, 0xE2, + 0x5F, 0x0E, 0x85, 0x4A, 0x6F, 0x00, 0x4F, 0x19, + 0x06, 0xC2, 0xA6, 0x2F, 0x79, 0x65, 0xF8, 0x0A + }, + { + 0xA7, 0xE2, 0x51, 0x43, 0xE9, 0x25, 0x33, 0xCC, + 0x14, 0xDD, 0xB5, 0x76, 0xFA, 0xCF, 0x2F, 0xCA, + 0x5A, 0xC5, 0x96, 0x0E, 0x9F, 0xD9, 0x91, 0xB5, + 0xFA, 0x3F, 0xBA, 0xF9, 0x7D, 0xC6, 0xCD, 0x2A + }, + { + 0x41, 0x8B, 0xF0, 0xB5, 0x34, 0xDD, 0x37, 0x42, + 0xBB, 0xC4, 0x59, 0x6C, 0xA8, 0xE8, 0xD6, 0x6E, + 0x3F, 0x36, 0xC0, 0x68, 0x9E, 0xCB, 0xEC, 0x48, + 0x62, 0xE0, 0xD3, 0x66, 0x5D, 0x65, 0x9D, 0x6B + }, + { + 0x4A, 0x23, 0xB6, 0x2D, 0xCC, 0xC9, 0x83, 0x1E, + 0xE5, 0xF2, 0x1C, 0xAC, 0xA2, 0xDF, 0xB4, 0xB3, + 0x94, 0x4C, 0x19, 0xDC, 0x4D, 0x1D, 0x70, 0x4C, + 0x55, 0x65, 0x95, 0xED, 0x7C, 0x24, 0xA6, 0x13 + }, + { + 0x05, 0xE9, 0x9D, 0x44, 0xC8, 0xFD, 0x36, 0xBF, + 0xAA, 0x83, 0x84, 0x65, 0xD3, 0xA7, 0xCE, 0x9F, + 0xCB, 0x8C, 0x2F, 0x60, 0xC9, 0x86, 0x61, 0xD1, + 0xA1, 0x0C, 0x57, 0x29, 0x71, 0x9E, 0x07, 0x16 + }, + { + 0x77, 0xE1, 0xAD, 0x28, 0x17, 0x0B, 0x07, 0x83, + 0x03, 0x8F, 0x8F, 0x75, 0x48, 0x91, 0x2E, 0x66, + 0x68, 0x23, 0x59, 0x96, 0x6C, 0xCB, 0x57, 0x10, + 0x72, 0xAE, 0xD1, 0xD5, 0xAD, 0x6E, 0x08, 0xB9 + }, + { + 0x55, 0x22, 0xC7, 0x95, 0x25, 0x3D, 0xAF, 0xCC, + 0x58, 0xF2, 0x16, 0xF6, 0x52, 0x11, 0x59, 0xD7, + 0x8C, 0x91, 0xEB, 0xA2, 0xBE, 0xC7, 0x51, 0x0E, + 0x6D, 0xC3, 0xE2, 0xFA, 0x68, 0x74, 0x30, 0xD4 + }, + { + 0xBC, 0xEE, 0x36, 0xEB, 0x0B, 0xD4, 0xB2, 0x55, + 0xBD, 0x42, 0x0B, 0xAF, 0xAD, 0x00, 0xDE, 0xF4, + 0x06, 0x19, 0x92, 0x3B, 0x45, 0xF8, 0x0D, 0x78, + 0xFB, 0x33, 0x7C, 0x14, 0x03, 0xA8, 0x46, 0xED + }, + { + 0x56, 0xEE, 0xC3, 0xB6, 0x0C, 0x3A, 0x0C, 0x9C, + 0x30, 0x9C, 0x9E, 0x5F, 0xEC, 0xB4, 0x1D, 0xF6, + 0x9E, 0x6D, 0xA0, 0x9B, 0x99, 0x53, 0xE1, 0x3B, + 0x80, 0x6F, 0x6A, 0xD4, 0xB1, 0xBC, 0x4E, 0xAE + }, + { + 0x83, 0x49, 0xA5, 0x29, 0x86, 0x3D, 0x3C, 0xBD, + 0x74, 0x9D, 0x96, 0xAA, 0x0B, 0x80, 0x39, 0x76, + 0x0E, 0x42, 0xF0, 0x5A, 0xE1, 0xFC, 0x88, 0x71, + 0xBA, 0x7F, 0x07, 0x01, 0xFD, 0x5B, 0x65, 0x6A + }, + { + 0x5D, 0x93, 0x96, 0x78, 0xE0, 0x64, 0x82, 0x01, + 0x9F, 0x28, 0x4F, 0x67, 0x25, 0xFC, 0xE6, 0x90, + 0x7C, 0x5E, 0x76, 0x0E, 0x02, 0x1D, 0x81, 0xE0, + 0xB9, 0x4E, 0xEB, 0x1B, 0x61, 0x51, 0xFD, 0xF4 + }, + { + 0xD0, 0xC3, 0x88, 0x67, 0xAB, 0x4A, 0xC8, 0x64, + 0x3A, 0xF2, 0x13, 0xA5, 0xCB, 0xDD, 0xCC, 0x4D, + 0xB2, 0x85, 0x4C, 0x74, 0x2D, 0x58, 0xA1, 0x51, + 0x85, 0xDB, 0x42, 0x66, 0xF9, 0x35, 0x4A, 0xAF + }, + { + 0x78, 0x0D, 0xFA, 0x9B, 0x50, 0xA0, 0xCB, 0x51, + 0x7F, 0x13, 0x7D, 0x9E, 0x6A, 0x0A, 0x89, 0x57, + 0xB8, 0x23, 0x43, 0x1C, 0x1B, 0x74, 0x30, 0x6F, + 0xC7, 0x26, 0xE3, 0x55, 0x24, 0xE1, 0x5A, 0x16 + }, + { + 0x2C, 0x1D, 0x09, 0x06, 0x67, 0x90, 0xDE, 0xA0, + 0x21, 0x5F, 0x32, 0xEF, 0xCD, 0xCE, 0x14, 0x32, + 0xD0, 0x66, 0x28, 0xE4, 0x45, 0x84, 0xE8, 0x12, + 0x52, 0x94, 0x99, 0x8D, 0x6E, 0x67, 0x7C, 0x95 + }, + { + 0x09, 0xA5, 0xC4, 0x83, 0x49, 0xDD, 0x53, 0x86, + 0xE8, 0xA2, 0xFA, 0xD2, 0xEA, 0x1A, 0xF1, 0xF9, + 0xFD, 0x55, 0x1D, 0xBA, 0x2E, 0xD2, 0xCD, 0xF1, + 0x89, 0x52, 0xD5, 0x05, 0x42, 0xF9, 0x3F, 0x20 + }, + { + 0x8B, 0xDE, 0xB6, 0xBD, 0xA2, 0x4C, 0x57, 0x46, + 0x23, 0xC9, 0x6E, 0xC2, 0xA2, 0x1C, 0x24, 0xDB, + 0xB6, 0xED, 0x8F, 0x11, 0x4F, 0x49, 0x94, 0x4B, + 0xDB, 0x27, 0x58, 0x9E, 0xA7, 0xC2, 0x63, 0xF6 + }, + { + 0x42, 0x0E, 0xEF, 0x23, 0x2F, 0x0F, 0xFD, 0x19, + 0x30, 0xEA, 0xEB, 0x06, 0x5F, 0x3D, 0x57, 0x3B, + 0xBD, 0x14, 0x2C, 0xA9, 0xB5, 0x56, 0x70, 0x39, + 0x9E, 0x4B, 0xBE, 0xCA, 0xC7, 0x49, 0x36, 0xB5 + }, + { + 0x0D, 0x2A, 0x33, 0x75, 0x34, 0xF9, 0x6C, 0x38, + 0xE6, 0xE9, 0x7D, 0x94, 0x6C, 0x84, 0x8A, 0x2B, + 0xEB, 0x34, 0xD2, 0x5C, 0xC6, 0xE7, 0xD5, 0xB7, + 0x01, 0x98, 0x68, 0xCB, 0x90, 0xD2, 0x43, 0xAF + }, + { + 0x9F, 0x10, 0x31, 0x6A, 0xE9, 0x6D, 0xBD, 0x94, + 0x87, 0xAF, 0x58, 0x89, 0xF6, 0x6D, 0xC5, 0xCE, + 0x6C, 0x94, 0x44, 0x13, 0x7D, 0xCC, 0xC5, 0x15, + 0xA7, 0x0B, 0x3C, 0x4C, 0x53, 0x82, 0x2E, 0x5D + }, + { + 0x8B, 0xAD, 0x49, 0x64, 0xDE, 0x4E, 0x33, 0xF8, + 0x6A, 0x7A, 0x7E, 0x18, 0x04, 0xF2, 0x56, 0x5B, + 0x8C, 0x19, 0x0B, 0xD2, 0xEB, 0x9C, 0x63, 0x7A, + 0xD6, 0x6E, 0xC9, 0xB1, 0xB3, 0x94, 0xB6, 0x41 + }, + { + 0x3E, 0x85, 0x5B, 0xBD, 0x87, 0xF4, 0xB9, 0x14, + 0x2F, 0x38, 0x48, 0x4E, 0x15, 0xDA, 0x68, 0x0C, + 0x8A, 0x39, 0x0E, 0x63, 0x9C, 0xCD, 0x2B, 0xA8, + 0xF6, 0x28, 0xD1, 0xB2, 0xCC, 0x90, 0x67, 0xC4 + }, + { + 0x28, 0x88, 0xF3, 0xFD, 0xD5, 0x72, 0x9B, 0xC8, + 0x86, 0x82, 0xDB, 0x7A, 0x61, 0x11, 0x5C, 0xA0, + 0x87, 0xAE, 0xE9, 0x20, 0x22, 0x85, 0x21, 0x17, + 0xF2, 0x06, 0x14, 0x36, 0xDB, 0xD0, 0x4A, 0xE2 + }, + { + 0x81, 0xF8, 0x48, 0xC6, 0x6D, 0x1C, 0x24, 0x9D, + 0x3A, 0x48, 0xA2, 0x6E, 0x21, 0x00, 0xB9, 0x25, + 0x29, 0xA0, 0x54, 0x5B, 0x74, 0x8A, 0xE8, 0x94, + 0xF6, 0x22, 0xC1, 0xF1, 0x56, 0x08, 0x56, 0x02 + }, + { + 0xC8, 0xDD, 0xBB, 0xB4, 0xAF, 0x9F, 0x1A, 0x48, + 0x2E, 0x7C, 0x6B, 0xB2, 0x91, 0x2F, 0x7D, 0x6F, + 0xBA, 0xCF, 0xB5, 0x04, 0xD3, 0x21, 0x64, 0x2F, + 0x2C, 0xB8, 0x0C, 0x59, 0xCC, 0x66, 0x46, 0x27 + }, + { + 0x5C, 0x1A, 0x1C, 0x7C, 0x94, 0xA6, 0x09, 0xCB, + 0xE0, 0xDD, 0x6E, 0x47, 0x5E, 0x2F, 0xD1, 0x83, + 0xE7, 0x01, 0xE8, 0x84, 0xCB, 0x7A, 0x14, 0xCF, + 0xC2, 0x2B, 0x8B, 0x11, 0xEF, 0xF8, 0xCA, 0x2E + }, + { + 0x7B, 0xF4, 0x3E, 0xC5, 0xF4, 0x87, 0x95, 0xFA, + 0xA4, 0x9C, 0x91, 0x6C, 0x82, 0x56, 0x0D, 0x9B, + 0x79, 0x20, 0xFB, 0x4D, 0x01, 0xB7, 0xDE, 0x0B, + 0x0F, 0x4C, 0xB4, 0x2D, 0x70, 0x07, 0xA1, 0xD6 + }, + { + 0x6A, 0x3E, 0xCF, 0x35, 0x72, 0xCC, 0x5D, 0x9A, + 0xC2, 0x61, 0xF1, 0x75, 0xE1, 0x64, 0xF0, 0x6B, + 0x0E, 0x2D, 0x3A, 0x4D, 0x83, 0x15, 0x03, 0x5E, + 0x8D, 0x53, 0xE5, 0x0A, 0x49, 0x07, 0xE8, 0x48 + }, + { + 0x13, 0x4B, 0xEA, 0xB6, 0x88, 0x8A, 0xF7, 0x23, + 0x2E, 0x3E, 0x40, 0xAA, 0x23, 0x87, 0x7A, 0x36, + 0x3F, 0xF4, 0xB1, 0x96, 0xE7, 0xCB, 0xDD, 0x0B, + 0x4F, 0xA4, 0x0C, 0x75, 0x75, 0xB7, 0x3D, 0x61 + }, + { + 0xB1, 0x48, 0xCA, 0x9F, 0xBE, 0x8B, 0xE1, 0x30, + 0x03, 0xE7, 0x67, 0xCE, 0x25, 0xBE, 0x0C, 0x4B, + 0xF9, 0xC8, 0xDE, 0x53, 0x78, 0xEB, 0xC5, 0xE6, + 0x65, 0x6E, 0xE5, 0x7A, 0x54, 0xC6, 0xFB, 0xA9 + }, + { + 0xFD, 0x0E, 0x8F, 0x93, 0xFF, 0x93, 0x65, 0x0E, + 0x05, 0xD9, 0x75, 0xE8, 0xD8, 0x45, 0x02, 0x62, + 0x5A, 0x16, 0xE8, 0x5B, 0x94, 0x8A, 0xD1, 0xE8, + 0x8D, 0x7E, 0x16, 0x6C, 0x81, 0x2A, 0xD0, 0x0D + }, + { + 0xFA, 0x8E, 0x70, 0xE7, 0xBE, 0x30, 0x5F, 0xDE, + 0x42, 0x1F, 0x85, 0xA2, 0xDA, 0xD6, 0x1D, 0x02, + 0x00, 0x85, 0x3B, 0xCA, 0xFC, 0x51, 0x48, 0x22, + 0xAB, 0xFE, 0x02, 0xE1, 0xCD, 0x6D, 0xF5, 0xD0 + }, + { + 0x7C, 0xAE, 0xC5, 0xCE, 0x97, 0x69, 0x83, 0x1F, + 0x96, 0xB5, 0xFB, 0xDC, 0x33, 0x07, 0x97, 0x8E, + 0x7D, 0x46, 0xF1, 0xCA, 0xBC, 0x8B, 0x75, 0x3B, + 0x31, 0xC8, 0x92, 0x50, 0x57, 0xFE, 0x05, 0x10 + }, + { + 0x28, 0x69, 0x44, 0xE8, 0x63, 0xD1, 0x03, 0x51, + 0x57, 0xDE, 0x0B, 0x21, 0xCA, 0x43, 0xCB, 0xFD, + 0x20, 0x41, 0x77, 0x3A, 0xD6, 0x08, 0x29, 0xBE, + 0x29, 0x51, 0x02, 0x49, 0xA3, 0x7A, 0x65, 0x24 + }, + { + 0xF5, 0x57, 0xD0, 0x51, 0xCC, 0x53, 0xA5, 0x14, + 0x15, 0x8E, 0xB9, 0x99, 0x47, 0x1B, 0x02, 0x8F, + 0xB4, 0x02, 0x2B, 0xE7, 0x85, 0xD3, 0x16, 0xE6, + 0xB3, 0x6D, 0xF6, 0x4C, 0x13, 0x50, 0x75, 0x58 + }, + { + 0x61, 0x2D, 0xB2, 0x9E, 0x2E, 0x98, 0x9E, 0xBB, + 0x22, 0xCB, 0xDB, 0x81, 0x60, 0xD1, 0xA9, 0x9C, + 0xF5, 0x80, 0xAF, 0x8B, 0x22, 0x99, 0x0D, 0x4A, + 0xF9, 0x88, 0xF6, 0x81, 0xC0, 0xD3, 0x24, 0xB2 + }, + { + 0xD4, 0xCF, 0x21, 0xB2, 0xB4, 0x4B, 0xDF, 0x43, + 0x0B, 0x0C, 0x5C, 0x22, 0x44, 0xF0, 0xB6, 0x41, + 0x2D, 0x4F, 0x95, 0x8B, 0x84, 0xB5, 0x4E, 0xCD, + 0x97, 0x62, 0xF0, 0x48, 0x33, 0x85, 0xB4, 0x10 + }, + { + 0xBB, 0x26, 0x06, 0x48, 0x77, 0xA4, 0x5B, 0xD0, + 0x9C, 0x36, 0xEB, 0x81, 0x8C, 0xDC, 0x88, 0x48, + 0x75, 0x51, 0xDB, 0x77, 0x34, 0xB8, 0xED, 0x49, + 0xCC, 0x1F, 0x96, 0x2B, 0x02, 0xFD, 0x2D, 0xBC + }, + { + 0xF4, 0xB6, 0x47, 0xC8, 0x70, 0xC3, 0xF4, 0x18, + 0xF1, 0xDB, 0xF4, 0xEB, 0xFF, 0xF5, 0x7E, 0x0C, + 0x66, 0x73, 0x56, 0x5F, 0xB1, 0xDD, 0xB9, 0x5C, + 0x1B, 0x24, 0x21, 0xA2, 0xCA, 0xBC, 0x89, 0xC5 + }, + { + 0x86, 0x4C, 0x0D, 0x4C, 0x1A, 0x8C, 0xAC, 0x57, + 0x2E, 0xE0, 0x16, 0x0F, 0x1C, 0xA1, 0xE0, 0x9D, + 0x6A, 0x56, 0x91, 0x37, 0xE5, 0xAE, 0x27, 0x1F, + 0x24, 0x38, 0x97, 0xB9, 0x13, 0xC1, 0x32, 0x5D + }, + { + 0x1C, 0x2F, 0x5E, 0x84, 0x1D, 0xDF, 0x0A, 0xEB, + 0xDC, 0x67, 0xC9, 0x23, 0xF9, 0x8B, 0xF4, 0x39, + 0x4C, 0x0A, 0x5C, 0x22, 0x09, 0x04, 0x10, 0x10, + 0x8B, 0xEC, 0xE6, 0xEE, 0x0A, 0x46, 0xF3, 0x7F + }, + { + 0x9F, 0x0F, 0x74, 0x0B, 0xCE, 0x38, 0xE0, 0xC7, + 0xEA, 0xC4, 0x29, 0x26, 0x96, 0x74, 0x69, 0x82, + 0xFA, 0x42, 0x4D, 0x4F, 0xF9, 0xCA, 0x0F, 0x29, + 0x12, 0x83, 0xD4, 0x26, 0xE6, 0x2D, 0xF0, 0xE8 + }, + { + 0x3D, 0xA4, 0xDC, 0x42, 0x1E, 0x8F, 0xE0, 0x77, + 0x51, 0x54, 0x28, 0x8B, 0x6B, 0xC7, 0x2B, 0x4A, + 0x99, 0x65, 0xFA, 0xF2, 0x74, 0xE2, 0x12, 0x0C, + 0x32, 0x08, 0x2A, 0x72, 0x80, 0x2F, 0x48, 0x7F + }, + { + 0x66, 0x10, 0xDB, 0x5F, 0x1A, 0xD1, 0x8F, 0xE8, + 0x0C, 0xB7, 0x80, 0x83, 0xF1, 0x4A, 0x27, 0xAD, + 0xB7, 0xC9, 0x5F, 0x6E, 0x53, 0xD3, 0x23, 0x4B, + 0x42, 0xA2, 0xB2, 0x6B, 0x6A, 0x65, 0x5C, 0xE0 + }, + { + 0x68, 0xA4, 0x1D, 0xB2, 0xCF, 0x23, 0x7D, 0x83, + 0xA4, 0x9A, 0xDD, 0xF5, 0xBF, 0x50, 0xDC, 0x9B, + 0x57, 0x20, 0x8C, 0xA1, 0xEE, 0x60, 0x73, 0x4F, + 0x39, 0x78, 0x91, 0x75, 0x83, 0x40, 0x8E, 0x6C + }, + { + 0x0E, 0xC8, 0x66, 0x97, 0x3F, 0x4E, 0x00, 0x5D, + 0xF4, 0x8A, 0x64, 0x6E, 0xF7, 0x97, 0x5A, 0xCF, + 0xE4, 0x30, 0x0C, 0x7F, 0x0D, 0x6D, 0x9E, 0xDA, + 0x5F, 0xA6, 0x7C, 0xD8, 0x12, 0x5C, 0x41, 0xA9 + }, + { + 0xBB, 0x67, 0x5E, 0x62, 0x2D, 0xAB, 0x6E, 0xBC, + 0x4F, 0x2E, 0x83, 0x1A, 0xC2, 0xD2, 0x2A, 0x07, + 0xA5, 0xD1, 0x26, 0x84, 0x22, 0x8E, 0xA4, 0xFB, + 0x22, 0x57, 0x8B, 0xCF, 0x5D, 0x4F, 0xB4, 0xF7 + }, + { + 0x6C, 0xE8, 0xA5, 0x4E, 0x1F, 0x2A, 0xA8, 0xA8, + 0xF1, 0xFF, 0xB6, 0x62, 0x06, 0x06, 0x47, 0x39, + 0x4D, 0x15, 0xAA, 0x51, 0x5A, 0xAF, 0x85, 0xC9, + 0xBD, 0x5E, 0x74, 0xE6, 0x62, 0x1C, 0xE4, 0x65 + }, + { + 0x58, 0xA2, 0x54, 0xDA, 0x88, 0xDA, 0x23, 0x41, + 0x43, 0x3C, 0x2C, 0x4C, 0x5E, 0xD9, 0xA2, 0x6A, + 0xC9, 0x9D, 0x9E, 0x26, 0xCD, 0xA9, 0x4E, 0xDD, + 0x2E, 0x97, 0x46, 0x34, 0x9E, 0x2E, 0x1C, 0xC5 + }, + { + 0x2F, 0x67, 0xFC, 0x0D, 0xFF, 0x82, 0xAC, 0xBD, + 0x9C, 0x59, 0x12, 0xDA, 0x42, 0x93, 0x53, 0xB3, + 0x9B, 0x68, 0xB7, 0xC3, 0x87, 0x07, 0x23, 0xFA, + 0xDD, 0xF2, 0xED, 0x7D, 0x91, 0xB4, 0xBE, 0xB2 + }, + { + 0x7B, 0xC7, 0xA8, 0x49, 0xF8, 0x7F, 0x17, 0xB1, + 0xAC, 0x12, 0xBF, 0xC8, 0x69, 0xA8, 0xE9, 0x2A, + 0xFD, 0x17, 0xC9, 0x6B, 0xF4, 0x2F, 0x41, 0x9F, + 0xCE, 0x78, 0x57, 0x7B, 0x5E, 0x70, 0x82, 0x79 + }, + { + 0x07, 0x7F, 0x04, 0x96, 0x98, 0xA5, 0x96, 0xD3, + 0x14, 0x0C, 0xC7, 0xFE, 0xEA, 0x5A, 0x5D, 0x46, + 0x05, 0x9E, 0x62, 0x84, 0x52, 0x74, 0xAE, 0x89, + 0x46, 0xC2, 0x9C, 0x8E, 0x95, 0x67, 0x3C, 0x25 + }, + { + 0x38, 0xDD, 0xB9, 0xF3, 0x25, 0x22, 0xEA, 0xE9, + 0x01, 0x1C, 0x36, 0x58, 0x75, 0xC6, 0x58, 0x88, + 0x9A, 0x45, 0xAF, 0x8D, 0x50, 0x49, 0xAA, 0xC0, + 0xEF, 0x67, 0x47, 0xA8, 0x77, 0xCC, 0x10, 0xAC + }, + { + 0x5A, 0x4B, 0xA3, 0x6E, 0xA2, 0xD7, 0xC8, 0x4C, + 0x77, 0xD9, 0x29, 0x5E, 0xB1, 0x4A, 0xE7, 0xBE, + 0xD8, 0xF8, 0x73, 0xA3, 0x2C, 0xBB, 0xE4, 0x24, + 0x04, 0xDE, 0xDF, 0x1D, 0x77, 0xA3, 0x39, 0xCF + }, + { + 0x87, 0x37, 0x9B, 0x20, 0x0B, 0x80, 0x32, 0x0D, + 0xF9, 0xDC, 0x2C, 0xA2, 0x96, 0x86, 0x8B, 0x52, + 0x19, 0x50, 0xCA, 0x47, 0x0B, 0xE8, 0x09, 0x94, + 0x7A, 0x1A, 0x49, 0x09, 0x7F, 0x29, 0x09, 0x73 + }, + { + 0xCE, 0x44, 0xD4, 0xEA, 0xFF, 0x72, 0x7F, 0x26, + 0x0E, 0xDD, 0xE1, 0x00, 0x58, 0xBC, 0xAD, 0x73, + 0xFE, 0xB6, 0xDF, 0x5C, 0x2F, 0xF1, 0x1A, 0xD3, + 0xDE, 0xC8, 0xD6, 0xE5, 0xFA, 0xC1, 0xDD, 0xC8 + }, + { + 0x07, 0x33, 0x5B, 0xA6, 0x95, 0xCC, 0xB2, 0x1F, + 0x5D, 0x4A, 0x4F, 0x45, 0x14, 0x2F, 0x44, 0xB4, + 0x88, 0xFF, 0x78, 0x75, 0x90, 0xFD, 0x97, 0xFE, + 0x16, 0xCB, 0x92, 0x13, 0xFA, 0x6F, 0x1C, 0xDA + }, + { + 0x4D, 0x7A, 0xCA, 0x5B, 0x42, 0xB5, 0x2B, 0x00, + 0x83, 0x38, 0xC7, 0x5A, 0x1C, 0xBD, 0xF6, 0x88, + 0x32, 0x31, 0x8F, 0xDC, 0x23, 0xF7, 0xA8, 0xE9, + 0x8B, 0x4B, 0x9E, 0x82, 0xDF, 0x8A, 0xE1, 0xE2 + }, + { + 0xF2, 0x48, 0x48, 0xCE, 0x6C, 0x3E, 0x54, 0x45, + 0x99, 0x04, 0x70, 0x61, 0x6E, 0xD4, 0x9A, 0x62, + 0xE3, 0xA2, 0x5F, 0x13, 0x15, 0x9A, 0x2F, 0x4E, + 0xAD, 0x65, 0xE3, 0x52, 0x08, 0x74, 0x19, 0xD3 + }, + { + 0xBD, 0x47, 0x82, 0xD8, 0xCF, 0xF5, 0x17, 0xA6, + 0x76, 0x97, 0x88, 0x68, 0xE7, 0xF9, 0x68, 0x46, + 0x30, 0x69, 0x6F, 0x93, 0xA8, 0xDF, 0x65, 0xB5, + 0x95, 0x72, 0xA3, 0x52, 0xE6, 0x53, 0x70, 0x42 + }, + { + 0x2B, 0xB6, 0xDD, 0xB7, 0x21, 0x7C, 0x36, 0xCC, + 0x77, 0x7D, 0xFC, 0xB3, 0x6E, 0x79, 0xC6, 0xB3, + 0x40, 0xEF, 0xFD, 0xA3, 0x8B, 0x5A, 0x4A, 0xE2, + 0x80, 0x81, 0xBD, 0x24, 0xF6, 0x30, 0x8D, 0x97 + }, + { + 0xC2, 0xC8, 0x2D, 0xFA, 0x05, 0x34, 0xBB, 0x0E, + 0xBB, 0xF0, 0x66, 0x25, 0xF7, 0x57, 0xD0, 0x74, + 0x01, 0xE4, 0xE9, 0xF1, 0x3C, 0x8B, 0x63, 0x1B, + 0x44, 0x64, 0x4B, 0x81, 0xD3, 0x4A, 0x1C, 0x04 + }, + { + 0x7A, 0x76, 0xBC, 0xD4, 0x0D, 0x7C, 0x16, 0x83, + 0x64, 0xAF, 0x3B, 0x99, 0x5F, 0x21, 0x5D, 0xE4, + 0x13, 0x59, 0x92, 0xD2, 0x0B, 0xFE, 0x40, 0x74, + 0x0D, 0xC5, 0xAC, 0x79, 0x38, 0x04, 0x5D, 0x68 + }, + { + 0xC9, 0x6D, 0x4F, 0x97, 0x62, 0x57, 0xD6, 0x8D, + 0x87, 0x9A, 0xB4, 0xFD, 0x03, 0xCA, 0x50, 0x75, + 0xB7, 0x8E, 0x7C, 0x04, 0x7A, 0x52, 0x83, 0x62, + 0x05, 0x57, 0xE8, 0xB7, 0x44, 0xAF, 0xC5, 0x30 + }, + { + 0x03, 0xAB, 0x30, 0x5A, 0x22, 0x65, 0xD5, 0x01, + 0xCD, 0x97, 0x96, 0x7C, 0x16, 0x24, 0x1C, 0xAE, + 0x56, 0x14, 0x59, 0x84, 0x68, 0x78, 0x72, 0xFE, + 0x52, 0x5B, 0xFA, 0x4C, 0x17, 0x4A, 0xE6, 0xD3 + }, + { + 0x38, 0xF7, 0xC6, 0x37, 0x05, 0xF5, 0xA1, 0xA3, + 0xCF, 0x3B, 0x49, 0x9C, 0x4E, 0xFB, 0xC5, 0x7A, + 0x51, 0xAF, 0x2B, 0xDB, 0x96, 0x62, 0x41, 0x76, + 0x49, 0xC5, 0x73, 0xBC, 0xB1, 0x80, 0x21, 0x43 + }, + { + 0x94, 0x13, 0xA6, 0xE3, 0xC2, 0x64, 0x81, 0xCC, + 0x9B, 0x89, 0x00, 0x14, 0x92, 0xDC, 0x1A, 0xD7, + 0x15, 0x5C, 0x45, 0xE8, 0x8B, 0x89, 0xCB, 0x83, + 0x31, 0x16, 0x4C, 0xD1, 0x8E, 0xAF, 0x60, 0x3F + }, + { + 0x3B, 0xE0, 0x84, 0x8F, 0xC0, 0xD6, 0xC0, 0x2A, + 0x4B, 0xB3, 0xBB, 0x4F, 0x91, 0x71, 0xDC, 0xA9, + 0x4D, 0xB4, 0x92, 0x01, 0x20, 0x54, 0xF3, 0x93, + 0x87, 0x42, 0xBF, 0xD3, 0x02, 0x7F, 0x10, 0x9C + }, + { + 0x1D, 0x94, 0x65, 0xAC, 0x17, 0x6C, 0x01, 0x7E, + 0x2A, 0x6F, 0xDE, 0x3A, 0x29, 0x66, 0x23, 0x0A, + 0x78, 0xC5, 0xB7, 0x1C, 0xBF, 0xB5, 0x8D, 0x50, + 0x11, 0xD7, 0x82, 0x58, 0xCC, 0xD1, 0x4C, 0x16 + }, + { + 0xF8, 0xD2, 0x44, 0x66, 0x41, 0x32, 0x17, 0xC0, + 0x56, 0xBF, 0x9B, 0xB6, 0x56, 0x7A, 0x54, 0x80, + 0x80, 0xB6, 0x92, 0x92, 0xAA, 0x17, 0xD9, 0x83, + 0xC3, 0x5C, 0x34, 0x9D, 0xA0, 0x95, 0xBF, 0xAC + }, + { + 0x4F, 0x80, 0xDB, 0x57, 0x14, 0x72, 0x65, 0x86, + 0x59, 0xF4, 0x06, 0xF4, 0x28, 0xC0, 0x91, 0x0D, + 0x72, 0xA6, 0x0A, 0x7B, 0x42, 0xD9, 0x62, 0xB7, + 0x8D, 0xD6, 0xB7, 0x27, 0x6C, 0x51, 0x11, 0xB5 + }, + { + 0x09, 0xC2, 0xF1, 0x58, 0xCE, 0xC0, 0x1D, 0x7C, + 0x5A, 0x87, 0x9E, 0x99, 0xCB, 0x64, 0xBB, 0x49, + 0xBF, 0xAC, 0x28, 0xCE, 0x8B, 0x46, 0x0C, 0x22, + 0x70, 0x0F, 0x2F, 0x91, 0xCF, 0x99, 0x34, 0xB1 + }, + { + 0x29, 0xC0, 0x18, 0x21, 0x53, 0xB0, 0xB1, 0x3D, + 0x11, 0x2A, 0x00, 0x9E, 0xB1, 0x4F, 0x68, 0x89, + 0x2A, 0xD1, 0x24, 0x19, 0xE1, 0x07, 0x12, 0xCA, + 0x23, 0xD7, 0x99, 0x2F, 0xFE, 0x85, 0xF7, 0x59 + }, + { + 0xB2, 0x68, 0x64, 0x39, 0x58, 0xC9, 0xB2, 0xB5, + 0xE0, 0x65, 0xA8, 0x8D, 0x51, 0xFF, 0x8C, 0x22, + 0x47, 0x02, 0x43, 0x66, 0x4C, 0x7A, 0x5A, 0x60, + 0xF1, 0x37, 0x0F, 0xCF, 0x18, 0x1A, 0x27, 0x01 + }, + { + 0x84, 0xA8, 0x56, 0xBE, 0xDE, 0x25, 0xFE, 0x2D, + 0xE6, 0x55, 0x2B, 0xA0, 0xCA, 0x7F, 0x34, 0x98, + 0xCF, 0xE2, 0x3B, 0x64, 0x39, 0xC7, 0x1A, 0x84, + 0x0C, 0x62, 0x18, 0x2A, 0x82, 0xBE, 0x44, 0xD7 + }, + { + 0x91, 0x26, 0x8C, 0x0E, 0x6B, 0x5F, 0x34, 0x87, + 0x72, 0xFE, 0xEE, 0xD6, 0x0E, 0x00, 0x58, 0x5B, + 0x6A, 0x86, 0x48, 0xB4, 0x3B, 0x5F, 0x57, 0x45, + 0x26, 0x7F, 0xBD, 0xB2, 0xA6, 0x7B, 0xC8, 0x4D + }, + { + 0xE2, 0x3B, 0xCC, 0xB3, 0x6A, 0xC1, 0x42, 0x5F, + 0x60, 0x68, 0xE8, 0x92, 0x79, 0x3C, 0x57, 0x97, + 0x91, 0xD6, 0xE9, 0x8C, 0x6A, 0xD9, 0x5C, 0xD6, + 0x41, 0x6B, 0x47, 0x8B, 0x0B, 0x82, 0x37, 0x33 + }, + { + 0xAD, 0x7D, 0xA2, 0x78, 0x98, 0xE0, 0x49, 0x13, + 0x2A, 0x63, 0x63, 0xCC, 0x48, 0xE9, 0x41, 0xBC, + 0x1D, 0x28, 0x59, 0x95, 0xF0, 0x6A, 0xB9, 0x3C, + 0xD7, 0x2D, 0xD3, 0x71, 0x63, 0x61, 0xE0, 0x23 + }, + { + 0xDC, 0x36, 0x8F, 0x40, 0xD7, 0xEF, 0x8D, 0xAC, + 0x26, 0xF4, 0xFC, 0xEB, 0x00, 0x89, 0x43, 0x02, + 0x25, 0x05, 0x70, 0x0F, 0x76, 0x97, 0x5F, 0x13, + 0x8B, 0x71, 0x45, 0x81, 0xE0, 0x99, 0x2A, 0x50 + }, + { + 0x68, 0xF0, 0xDA, 0xF2, 0xF2, 0xB1, 0x3D, 0xFC, + 0xC4, 0xA0, 0x4B, 0xD3, 0x3C, 0x54, 0x6B, 0xA6, + 0xB1, 0x09, 0x59, 0x49, 0x66, 0xB4, 0x03, 0x44, + 0xB4, 0x2A, 0xED, 0x7F, 0x1A, 0x71, 0xDD, 0xA4 + }, + { + 0x65, 0x7D, 0x7D, 0x6C, 0x8C, 0x8B, 0xD9, 0x5B, + 0x09, 0x5E, 0x2A, 0x5D, 0xF4, 0x26, 0x68, 0xE4, + 0xE5, 0x7B, 0xD6, 0xC0, 0x34, 0xDC, 0x04, 0x60, + 0x7C, 0x9D, 0xDD, 0x58, 0x1D, 0x01, 0xA5, 0xE9 + }, + { + 0xEE, 0x82, 0xD8, 0x05, 0x87, 0xBD, 0x32, 0x5F, + 0xC0, 0x55, 0x1C, 0xC3, 0x30, 0x6D, 0xF7, 0x34, + 0xC3, 0xA7, 0x28, 0xBA, 0x22, 0xB0, 0xC3, 0xC8, + 0x59, 0x5E, 0xBE, 0xA8, 0xC6, 0x4D, 0x63, 0xF8 + }, + { + 0xC2, 0x47, 0xB9, 0x3C, 0xFB, 0x99, 0x03, 0x64, + 0x70, 0xCC, 0x2F, 0x05, 0xE5, 0x35, 0x19, 0x93, + 0x3C, 0x38, 0x11, 0x40, 0x1B, 0x43, 0x86, 0x7A, + 0x69, 0x92, 0xA2, 0x85, 0x28, 0xC0, 0x6E, 0x0D + }, + { + 0x2C, 0xDF, 0x39, 0x40, 0xB9, 0xB7, 0x33, 0x85, + 0x9B, 0x5D, 0x96, 0x02, 0xAE, 0xAA, 0x68, 0x02, + 0x24, 0xDE, 0xEC, 0x99, 0xA0, 0x8D, 0xC6, 0x9B, + 0x81, 0x44, 0x88, 0x5C, 0xF1, 0x2D, 0xC2, 0x03 + }, + { + 0x41, 0x90, 0xC4, 0x2A, 0x11, 0x77, 0x92, 0xD9, + 0x05, 0x27, 0x95, 0xDC, 0xDF, 0xA0, 0x41, 0x3D, + 0x34, 0x33, 0x17, 0xC8, 0xCF, 0xC4, 0xF6, 0x18, + 0x77, 0xFB, 0x20, 0x73, 0xD7, 0xFE, 0xE8, 0xAE + }, + { + 0x01, 0x2F, 0x05, 0xD2, 0x99, 0x58, 0xA4, 0xE7, + 0xF8, 0xE2, 0xE0, 0xB8, 0xBE, 0x1C, 0x29, 0x24, + 0x11, 0x81, 0x45, 0x35, 0xA2, 0x57, 0xA9, 0x71, + 0x0F, 0x28, 0xA2, 0x9A, 0x67, 0xBC, 0x44, 0x36 + }, + { + 0xCB, 0xF0, 0x7D, 0xD7, 0xE6, 0x55, 0x04, 0xE0, + 0xED, 0xB7, 0x26, 0x0C, 0x3D, 0x5C, 0xB6, 0xED, + 0x9C, 0x21, 0xCD, 0xA4, 0xD8, 0x34, 0x24, 0x86, + 0x52, 0xA9, 0x15, 0x49, 0xDB, 0x75, 0x3C, 0x9E + }, + { + 0xAD, 0x3D, 0xD1, 0x85, 0x5F, 0x28, 0xEA, 0xD8, + 0xD4, 0x37, 0x2D, 0x5D, 0xC1, 0xC6, 0xB2, 0x82, + 0x1F, 0x4C, 0xB6, 0xB0, 0xA6, 0x7F, 0xA4, 0x3D, + 0x1F, 0x5F, 0xC3, 0x59, 0x5D, 0x8F, 0x57, 0xAB + }, + { + 0x67, 0xDD, 0x4A, 0xB6, 0x63, 0xEE, 0xCF, 0x36, + 0x36, 0xB4, 0x19, 0x6E, 0x26, 0xB2, 0xD3, 0xD0, + 0x8B, 0xB4, 0xCA, 0x0D, 0xD9, 0x94, 0x10, 0x30, + 0x8C, 0x63, 0x74, 0x9D, 0x33, 0x16, 0xFE, 0xDE + }, + { + 0xA0, 0xDB, 0x5E, 0xF3, 0xF8, 0x4E, 0x75, 0x16, + 0xB7, 0x09, 0xA2, 0x65, 0xA7, 0x6A, 0x7D, 0x0C, + 0x33, 0x0D, 0xC5, 0xBA, 0xF3, 0x3B, 0x23, 0x1F, + 0xAE, 0xCF, 0x4B, 0x21, 0x31, 0x85, 0x4F, 0x3E + }, + { + 0x8F, 0x11, 0xA2, 0xD4, 0x0B, 0x7A, 0x8C, 0x7C, + 0xED, 0x00, 0x2E, 0x61, 0xE3, 0x82, 0xCF, 0x29, + 0xF0, 0xAF, 0x96, 0xF9, 0x3C, 0x71, 0x93, 0x52, + 0x2E, 0x36, 0x60, 0x14, 0x8C, 0x75, 0xBC, 0x57 + }, + { + 0xA0, 0x87, 0xDD, 0xFD, 0x7E, 0x52, 0x31, 0x1A, + 0x03, 0x0E, 0x9D, 0xBF, 0xB4, 0x1C, 0xCC, 0x7D, + 0x4B, 0x44, 0x08, 0x15, 0x44, 0xF4, 0xF4, 0x86, + 0x1B, 0x00, 0x49, 0x9B, 0x9E, 0xC6, 0x5A, 0x5C + }, + { + 0x7A, 0xA3, 0x35, 0x7A, 0xBB, 0x85, 0x21, 0xE2, + 0x44, 0x8F, 0x2C, 0xE6, 0xEB, 0x0B, 0x13, 0x23, + 0xA9, 0x28, 0xB1, 0x46, 0xD9, 0x4C, 0x24, 0x20, + 0x06, 0xAE, 0xFA, 0x61, 0x48, 0xD3, 0x03, 0x14 + }, + { + 0x62, 0xFD, 0x3E, 0x0D, 0x7B, 0x95, 0x2C, 0xCE, + 0x86, 0x70, 0x10, 0x49, 0x2C, 0x89, 0x74, 0x2A, + 0x85, 0xE0, 0x5F, 0x3C, 0x84, 0x93, 0xE7, 0x5F, + 0x0F, 0x20, 0x0C, 0xD6, 0x4B, 0x9A, 0x7C, 0x56 + }, + { + 0x50, 0xD3, 0xE4, 0x5E, 0xF8, 0xD2, 0x5C, 0x63, + 0xE1, 0xDB, 0x2F, 0x8E, 0x24, 0x4D, 0x6A, 0x80, + 0x38, 0x3B, 0x0C, 0x0F, 0x69, 0x77, 0x0B, 0x0C, + 0xAD, 0xE4, 0x91, 0xF9, 0xBE, 0xEE, 0xFA, 0xC1 + }, + { + 0x98, 0x4E, 0x81, 0xC8, 0x72, 0x20, 0xEA, 0x9B, + 0xD1, 0x29, 0xBA, 0x46, 0x77, 0xA3, 0x08, 0x78, + 0xAC, 0x8F, 0x6B, 0xF5, 0x24, 0x11, 0x59, 0xDB, + 0xE6, 0x9B, 0xCA, 0x83, 0x42, 0xE4, 0xDA, 0xB7 + }, + { + 0x70, 0x49, 0x59, 0xC3, 0xA8, 0xD6, 0x0E, 0x84, + 0xF3, 0xBE, 0x59, 0x1A, 0x9D, 0xC1, 0x02, 0x9A, + 0x49, 0xB9, 0x36, 0x6A, 0xE8, 0x0E, 0xBF, 0x51, + 0x0A, 0x45, 0xFF, 0xFF, 0x99, 0xD0, 0xE6, 0x89 + }, + { + 0xC2, 0x85, 0x24, 0x98, 0xDB, 0xE5, 0x7D, 0x12, + 0xEA, 0x1E, 0x6E, 0xE4, 0x80, 0x8D, 0x50, 0x84, + 0x04, 0x60, 0x74, 0x88, 0xD6, 0xC1, 0x58, 0xFA, + 0x7E, 0x33, 0xC2, 0x30, 0x59, 0x12, 0x55, 0xCB + }, + { + 0x0B, 0x7F, 0xD5, 0x96, 0x9D, 0xC8, 0x1E, 0x77, + 0x8A, 0x33, 0xCB, 0xA1, 0x7E, 0x76, 0xC7, 0x21, + 0x37, 0x22, 0xDB, 0xD6, 0x1B, 0xCC, 0xE0, 0x25, + 0xF7, 0x79, 0xE7, 0x64, 0x6B, 0xCE, 0x52, 0x12 + }, + { + 0x30, 0x81, 0x25, 0x27, 0xEB, 0xD2, 0x5C, 0x89, + 0x9A, 0x93, 0x0E, 0xB7, 0x2A, 0x6B, 0xB4, 0x67, + 0xCF, 0xE0, 0xCD, 0x13, 0x6F, 0xBE, 0xC5, 0x4F, + 0x9A, 0x3E, 0xBC, 0x72, 0xE8, 0x4A, 0x10, 0x5F + }, + { + 0x2D, 0x54, 0x84, 0xB9, 0xEB, 0xB9, 0xA5, 0x86, + 0xF2, 0x2E, 0x75, 0x7B, 0x61, 0x23, 0x8A, 0xD6, + 0x03, 0xB1, 0xE0, 0xC1, 0x8E, 0xD4, 0xAF, 0xCC, + 0x5C, 0x24, 0x9A, 0xD7, 0x17, 0xC8, 0xF2, 0x16 + }, + { + 0x1B, 0x1E, 0x8A, 0xAC, 0x95, 0x40, 0x9D, 0x40, + 0xF5, 0xF2, 0x01, 0x7A, 0x11, 0x30, 0x91, 0x69, + 0x95, 0xA6, 0x22, 0xB1, 0x64, 0x04, 0xBE, 0x58, + 0x17, 0x29, 0x08, 0x88, 0x09, 0xAA, 0x21, 0xDE + }, +}; + + + + +static const uint8_t blake2s_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2S_OUTBYTES] = +{ + { + 0x48, 0xA8, 0x99, 0x7D, 0xA4, 0x07, 0x87, 0x6B, + 0x3D, 0x79, 0xC0, 0xD9, 0x23, 0x25, 0xAD, 0x3B, + 0x89, 0xCB, 0xB7, 0x54, 0xD8, 0x6A, 0xB7, 0x1A, + 0xEE, 0x04, 0x7A, 0xD3, 0x45, 0xFD, 0x2C, 0x49 + }, + { + 0x40, 0xD1, 0x5F, 0xEE, 0x7C, 0x32, 0x88, 0x30, + 0x16, 0x6A, 0xC3, 0xF9, 0x18, 0x65, 0x0F, 0x80, + 0x7E, 0x7E, 0x01, 0xE1, 0x77, 0x25, 0x8C, 0xDC, + 0x0A, 0x39, 0xB1, 0x1F, 0x59, 0x80, 0x66, 0xF1 + }, + { + 0x6B, 0xB7, 0x13, 0x00, 0x64, 0x4C, 0xD3, 0x99, + 0x1B, 0x26, 0xCC, 0xD4, 0xD2, 0x74, 0xAC, 0xD1, + 0xAD, 0xEA, 0xB8, 0xB1, 0xD7, 0x91, 0x45, 0x46, + 0xC1, 0x19, 0x8B, 0xBE, 0x9F, 0xC9, 0xD8, 0x03 + }, + { + 0x1D, 0x22, 0x0D, 0xBE, 0x2E, 0xE1, 0x34, 0x66, + 0x1F, 0xDF, 0x6D, 0x9E, 0x74, 0xB4, 0x17, 0x04, + 0x71, 0x05, 0x56, 0xF2, 0xF6, 0xE5, 0xA0, 0x91, + 0xB2, 0x27, 0x69, 0x74, 0x45, 0xDB, 0xEA, 0x6B + }, + { + 0xF6, 0xC3, 0xFB, 0xAD, 0xB4, 0xCC, 0x68, 0x7A, + 0x00, 0x64, 0xA5, 0xBE, 0x6E, 0x79, 0x1B, 0xEC, + 0x63, 0xB8, 0x68, 0xAD, 0x62, 0xFB, 0xA6, 0x1B, + 0x37, 0x57, 0xEF, 0x9C, 0xA5, 0x2E, 0x05, 0xB2 + }, + { + 0x49, 0xC1, 0xF2, 0x11, 0x88, 0xDF, 0xD7, 0x69, + 0xAE, 0xA0, 0xE9, 0x11, 0xDD, 0x6B, 0x41, 0xF1, + 0x4D, 0xAB, 0x10, 0x9D, 0x2B, 0x85, 0x97, 0x7A, + 0xA3, 0x08, 0x8B, 0x5C, 0x70, 0x7E, 0x85, 0x98 + }, + { + 0xFD, 0xD8, 0x99, 0x3D, 0xCD, 0x43, 0xF6, 0x96, + 0xD4, 0x4F, 0x3C, 0xEA, 0x0F, 0xF3, 0x53, 0x45, + 0x23, 0x4E, 0xC8, 0xEE, 0x08, 0x3E, 0xB3, 0xCA, + 0xDA, 0x01, 0x7C, 0x7F, 0x78, 0xC1, 0x71, 0x43 + }, + { + 0xE6, 0xC8, 0x12, 0x56, 0x37, 0x43, 0x8D, 0x09, + 0x05, 0xB7, 0x49, 0xF4, 0x65, 0x60, 0xAC, 0x89, + 0xFD, 0x47, 0x1C, 0xF8, 0x69, 0x2E, 0x28, 0xFA, + 0xB9, 0x82, 0xF7, 0x3F, 0x01, 0x9B, 0x83, 0xA9 + }, + { + 0x19, 0xFC, 0x8C, 0xA6, 0x97, 0x9D, 0x60, 0xE6, + 0xED, 0xD3, 0xB4, 0x54, 0x1E, 0x2F, 0x96, 0x7C, + 0xED, 0x74, 0x0D, 0xF6, 0xEC, 0x1E, 0xAE, 0xBB, + 0xFE, 0x81, 0x38, 0x32, 0xE9, 0x6B, 0x29, 0x74 + }, + { + 0xA6, 0xAD, 0x77, 0x7C, 0xE8, 0x81, 0xB5, 0x2B, + 0xB5, 0xA4, 0x42, 0x1A, 0xB6, 0xCD, 0xD2, 0xDF, + 0xBA, 0x13, 0xE9, 0x63, 0x65, 0x2D, 0x4D, 0x6D, + 0x12, 0x2A, 0xEE, 0x46, 0x54, 0x8C, 0x14, 0xA7 + }, + { + 0xF5, 0xC4, 0xB2, 0xBA, 0x1A, 0x00, 0x78, 0x1B, + 0x13, 0xAB, 0xA0, 0x42, 0x52, 0x42, 0xC6, 0x9C, + 0xB1, 0x55, 0x2F, 0x3F, 0x71, 0xA9, 0xA3, 0xBB, + 0x22, 0xB4, 0xA6, 0xB4, 0x27, 0x7B, 0x46, 0xDD + }, + { + 0xE3, 0x3C, 0x4C, 0x9B, 0xD0, 0xCC, 0x7E, 0x45, + 0xC8, 0x0E, 0x65, 0xC7, 0x7F, 0xA5, 0x99, 0x7F, + 0xEC, 0x70, 0x02, 0x73, 0x85, 0x41, 0x50, 0x9E, + 0x68, 0xA9, 0x42, 0x38, 0x91, 0xE8, 0x22, 0xA3 + }, + { + 0xFB, 0xA1, 0x61, 0x69, 0xB2, 0xC3, 0xEE, 0x10, + 0x5B, 0xE6, 0xE1, 0xE6, 0x50, 0xE5, 0xCB, 0xF4, + 0x07, 0x46, 0xB6, 0x75, 0x3D, 0x03, 0x6A, 0xB5, + 0x51, 0x79, 0x01, 0x4A, 0xD7, 0xEF, 0x66, 0x51 + }, + { + 0xF5, 0xC4, 0xBE, 0xC6, 0xD6, 0x2F, 0xC6, 0x08, + 0xBF, 0x41, 0xCC, 0x11, 0x5F, 0x16, 0xD6, 0x1C, + 0x7E, 0xFD, 0x3F, 0xF6, 0xC6, 0x56, 0x92, 0xBB, + 0xE0, 0xAF, 0xFF, 0xB1, 0xFE, 0xDE, 0x74, 0x75 + }, + { + 0xA4, 0x86, 0x2E, 0x76, 0xDB, 0x84, 0x7F, 0x05, + 0xBA, 0x17, 0xED, 0xE5, 0xDA, 0x4E, 0x7F, 0x91, + 0xB5, 0x92, 0x5C, 0xF1, 0xAD, 0x4B, 0xA1, 0x27, + 0x32, 0xC3, 0x99, 0x57, 0x42, 0xA5, 0xCD, 0x6E + }, + { + 0x65, 0xF4, 0xB8, 0x60, 0xCD, 0x15, 0xB3, 0x8E, + 0xF8, 0x14, 0xA1, 0xA8, 0x04, 0x31, 0x4A, 0x55, + 0xBE, 0x95, 0x3C, 0xAA, 0x65, 0xFD, 0x75, 0x8A, + 0xD9, 0x89, 0xFF, 0x34, 0xA4, 0x1C, 0x1E, 0xEA + }, + { + 0x19, 0xBA, 0x23, 0x4F, 0x0A, 0x4F, 0x38, 0x63, + 0x7D, 0x18, 0x39, 0xF9, 0xD9, 0xF7, 0x6A, 0xD9, + 0x1C, 0x85, 0x22, 0x30, 0x71, 0x43, 0xC9, 0x7D, + 0x5F, 0x93, 0xF6, 0x92, 0x74, 0xCE, 0xC9, 0xA7 + }, + { + 0x1A, 0x67, 0x18, 0x6C, 0xA4, 0xA5, 0xCB, 0x8E, + 0x65, 0xFC, 0xA0, 0xE2, 0xEC, 0xBC, 0x5D, 0xDC, + 0x14, 0xAE, 0x38, 0x1B, 0xB8, 0xBF, 0xFE, 0xB9, + 0xE0, 0xA1, 0x03, 0x44, 0x9E, 0x3E, 0xF0, 0x3C + }, + { + 0xAF, 0xBE, 0xA3, 0x17, 0xB5, 0xA2, 0xE8, 0x9C, + 0x0B, 0xD9, 0x0C, 0xCF, 0x5D, 0x7F, 0xD0, 0xED, + 0x57, 0xFE, 0x58, 0x5E, 0x4B, 0xE3, 0x27, 0x1B, + 0x0A, 0x6B, 0xF0, 0xF5, 0x78, 0x6B, 0x0F, 0x26 + }, + { + 0xF1, 0xB0, 0x15, 0x58, 0xCE, 0x54, 0x12, 0x62, + 0xF5, 0xEC, 0x34, 0x29, 0x9D, 0x6F, 0xB4, 0x09, + 0x00, 0x09, 0xE3, 0x43, 0x4B, 0xE2, 0xF4, 0x91, + 0x05, 0xCF, 0x46, 0xAF, 0x4D, 0x2D, 0x41, 0x24 + }, + { + 0x13, 0xA0, 0xA0, 0xC8, 0x63, 0x35, 0x63, 0x5E, + 0xAA, 0x74, 0xCA, 0x2D, 0x5D, 0x48, 0x8C, 0x79, + 0x7B, 0xBB, 0x4F, 0x47, 0xDC, 0x07, 0x10, 0x50, + 0x15, 0xED, 0x6A, 0x1F, 0x33, 0x09, 0xEF, 0xCE + }, + { + 0x15, 0x80, 0xAF, 0xEE, 0xBE, 0xBB, 0x34, 0x6F, + 0x94, 0xD5, 0x9F, 0xE6, 0x2D, 0xA0, 0xB7, 0x92, + 0x37, 0xEA, 0xD7, 0xB1, 0x49, 0x1F, 0x56, 0x67, + 0xA9, 0x0E, 0x45, 0xED, 0xF6, 0xCA, 0x8B, 0x03 + }, + { + 0x20, 0xBE, 0x1A, 0x87, 0x5B, 0x38, 0xC5, 0x73, + 0xDD, 0x7F, 0xAA, 0xA0, 0xDE, 0x48, 0x9D, 0x65, + 0x5C, 0x11, 0xEF, 0xB6, 0xA5, 0x52, 0x69, 0x8E, + 0x07, 0xA2, 0xD3, 0x31, 0xB5, 0xF6, 0x55, 0xC3 + }, + { + 0xBE, 0x1F, 0xE3, 0xC4, 0xC0, 0x40, 0x18, 0xC5, + 0x4C, 0x4A, 0x0F, 0x6B, 0x9A, 0x2E, 0xD3, 0xC5, + 0x3A, 0xBE, 0x3A, 0x9F, 0x76, 0xB4, 0xD2, 0x6D, + 0xE5, 0x6F, 0xC9, 0xAE, 0x95, 0x05, 0x9A, 0x99 + }, + { + 0xE3, 0xE3, 0xAC, 0xE5, 0x37, 0xEB, 0x3E, 0xDD, + 0x84, 0x63, 0xD9, 0xAD, 0x35, 0x82, 0xE1, 0x3C, + 0xF8, 0x65, 0x33, 0xFF, 0xDE, 0x43, 0xD6, 0x68, + 0xDD, 0x2E, 0x93, 0xBB, 0xDB, 0xD7, 0x19, 0x5A + }, + { + 0x11, 0x0C, 0x50, 0xC0, 0xBF, 0x2C, 0x6E, 0x7A, + 0xEB, 0x7E, 0x43, 0x5D, 0x92, 0xD1, 0x32, 0xAB, + 0x66, 0x55, 0x16, 0x8E, 0x78, 0xA2, 0xDE, 0xCD, + 0xEC, 0x33, 0x30, 0x77, 0x76, 0x84, 0xD9, 0xC1 + }, + { + 0xE9, 0xBA, 0x8F, 0x50, 0x5C, 0x9C, 0x80, 0xC0, + 0x86, 0x66, 0xA7, 0x01, 0xF3, 0x36, 0x7E, 0x6C, + 0xC6, 0x65, 0xF3, 0x4B, 0x22, 0xE7, 0x3C, 0x3C, + 0x04, 0x17, 0xEB, 0x1C, 0x22, 0x06, 0x08, 0x2F + }, + { + 0x26, 0xCD, 0x66, 0xFC, 0xA0, 0x23, 0x79, 0xC7, + 0x6D, 0xF1, 0x23, 0x17, 0x05, 0x2B, 0xCA, 0xFD, + 0x6C, 0xD8, 0xC3, 0xA7, 0xB8, 0x90, 0xD8, 0x05, + 0xF3, 0x6C, 0x49, 0x98, 0x97, 0x82, 0x43, 0x3A + }, + { + 0x21, 0x3F, 0x35, 0x96, 0xD6, 0xE3, 0xA5, 0xD0, + 0xE9, 0x93, 0x2C, 0xD2, 0x15, 0x91, 0x46, 0x01, + 0x5E, 0x2A, 0xBC, 0x94, 0x9F, 0x47, 0x29, 0xEE, + 0x26, 0x32, 0xFE, 0x1E, 0xDB, 0x78, 0xD3, 0x37 + }, + { + 0x10, 0x15, 0xD7, 0x01, 0x08, 0xE0, 0x3B, 0xE1, + 0xC7, 0x02, 0xFE, 0x97, 0x25, 0x36, 0x07, 0xD1, + 0x4A, 0xEE, 0x59, 0x1F, 0x24, 0x13, 0xEA, 0x67, + 0x87, 0x42, 0x7B, 0x64, 0x59, 0xFF, 0x21, 0x9A + }, + { + 0x3C, 0xA9, 0x89, 0xDE, 0x10, 0xCF, 0xE6, 0x09, + 0x90, 0x94, 0x72, 0xC8, 0xD3, 0x56, 0x10, 0x80, + 0x5B, 0x2F, 0x97, 0x77, 0x34, 0xCF, 0x65, 0x2C, + 0xC6, 0x4B, 0x3B, 0xFC, 0x88, 0x2D, 0x5D, 0x89 + }, + { + 0xB6, 0x15, 0x6F, 0x72, 0xD3, 0x80, 0xEE, 0x9E, + 0xA6, 0xAC, 0xD1, 0x90, 0x46, 0x4F, 0x23, 0x07, + 0xA5, 0xC1, 0x79, 0xEF, 0x01, 0xFD, 0x71, 0xF9, + 0x9F, 0x2D, 0x0F, 0x7A, 0x57, 0x36, 0x0A, 0xEA + }, + { + 0xC0, 0x3B, 0xC6, 0x42, 0xB2, 0x09, 0x59, 0xCB, + 0xE1, 0x33, 0xA0, 0x30, 0x3E, 0x0C, 0x1A, 0xBF, + 0xF3, 0xE3, 0x1E, 0xC8, 0xE1, 0xA3, 0x28, 0xEC, + 0x85, 0x65, 0xC3, 0x6D, 0xEC, 0xFF, 0x52, 0x65 + }, + { + 0x2C, 0x3E, 0x08, 0x17, 0x6F, 0x76, 0x0C, 0x62, + 0x64, 0xC3, 0xA2, 0xCD, 0x66, 0xFE, 0xC6, 0xC3, + 0xD7, 0x8D, 0xE4, 0x3F, 0xC1, 0x92, 0x45, 0x7B, + 0x2A, 0x4A, 0x66, 0x0A, 0x1E, 0x0E, 0xB2, 0x2B + }, + { + 0xF7, 0x38, 0xC0, 0x2F, 0x3C, 0x1B, 0x19, 0x0C, + 0x51, 0x2B, 0x1A, 0x32, 0xDE, 0xAB, 0xF3, 0x53, + 0x72, 0x8E, 0x0E, 0x9A, 0xB0, 0x34, 0x49, 0x0E, + 0x3C, 0x34, 0x09, 0x94, 0x6A, 0x97, 0xAE, 0xEC + }, + { + 0x8B, 0x18, 0x80, 0xDF, 0x30, 0x1C, 0xC9, 0x63, + 0x41, 0x88, 0x11, 0x08, 0x89, 0x64, 0x83, 0x92, + 0x87, 0xFF, 0x7F, 0xE3, 0x1C, 0x49, 0xEA, 0x6E, + 0xBD, 0x9E, 0x48, 0xBD, 0xEE, 0xE4, 0x97, 0xC5 + }, + { + 0x1E, 0x75, 0xCB, 0x21, 0xC6, 0x09, 0x89, 0x02, + 0x03, 0x75, 0xF1, 0xA7, 0xA2, 0x42, 0x83, 0x9F, + 0x0B, 0x0B, 0x68, 0x97, 0x3A, 0x4C, 0x2A, 0x05, + 0xCF, 0x75, 0x55, 0xED, 0x5A, 0xAE, 0xC4, 0xC1 + }, + { + 0x62, 0xBF, 0x8A, 0x9C, 0x32, 0xA5, 0xBC, 0xCF, + 0x29, 0x0B, 0x6C, 0x47, 0x4D, 0x75, 0xB2, 0xA2, + 0xA4, 0x09, 0x3F, 0x1A, 0x9E, 0x27, 0x13, 0x94, + 0x33, 0xA8, 0xF2, 0xB3, 0xBC, 0xE7, 0xB8, 0xD7 + }, + { + 0x16, 0x6C, 0x83, 0x50, 0xD3, 0x17, 0x3B, 0x5E, + 0x70, 0x2B, 0x78, 0x3D, 0xFD, 0x33, 0xC6, 0x6E, + 0xE0, 0x43, 0x27, 0x42, 0xE9, 0xB9, 0x2B, 0x99, + 0x7F, 0xD2, 0x3C, 0x60, 0xDC, 0x67, 0x56, 0xCA + }, + { + 0x04, 0x4A, 0x14, 0xD8, 0x22, 0xA9, 0x0C, 0xAC, + 0xF2, 0xF5, 0xA1, 0x01, 0x42, 0x8A, 0xDC, 0x8F, + 0x41, 0x09, 0x38, 0x6C, 0xCB, 0x15, 0x8B, 0xF9, + 0x05, 0xC8, 0x61, 0x8B, 0x8E, 0xE2, 0x4E, 0xC3 + }, + { + 0x38, 0x7D, 0x39, 0x7E, 0xA4, 0x3A, 0x99, 0x4B, + 0xE8, 0x4D, 0x2D, 0x54, 0x4A, 0xFB, 0xE4, 0x81, + 0xA2, 0x00, 0x0F, 0x55, 0x25, 0x26, 0x96, 0xBB, + 0xA2, 0xC5, 0x0C, 0x8E, 0xBD, 0x10, 0x13, 0x47 + }, + { + 0x56, 0xF8, 0xCC, 0xF1, 0xF8, 0x64, 0x09, 0xB4, + 0x6C, 0xE3, 0x61, 0x66, 0xAE, 0x91, 0x65, 0x13, + 0x84, 0x41, 0x57, 0x75, 0x89, 0xDB, 0x08, 0xCB, + 0xC5, 0xF6, 0x6C, 0xA2, 0x97, 0x43, 0xB9, 0xFD + }, + { + 0x97, 0x06, 0xC0, 0x92, 0xB0, 0x4D, 0x91, 0xF5, + 0x3D, 0xFF, 0x91, 0xFA, 0x37, 0xB7, 0x49, 0x3D, + 0x28, 0xB5, 0x76, 0xB5, 0xD7, 0x10, 0x46, 0x9D, + 0xF7, 0x94, 0x01, 0x66, 0x22, 0x36, 0xFC, 0x03 + }, + { + 0x87, 0x79, 0x68, 0x68, 0x6C, 0x06, 0x8C, 0xE2, + 0xF7, 0xE2, 0xAD, 0xCF, 0xF6, 0x8B, 0xF8, 0x74, + 0x8E, 0xDF, 0x3C, 0xF8, 0x62, 0xCF, 0xB4, 0xD3, + 0x94, 0x7A, 0x31, 0x06, 0x95, 0x80, 0x54, 0xE3 + }, + { + 0x88, 0x17, 0xE5, 0x71, 0x98, 0x79, 0xAC, 0xF7, + 0x02, 0x47, 0x87, 0xEC, 0xCD, 0xB2, 0x71, 0x03, + 0x55, 0x66, 0xCF, 0xA3, 0x33, 0xE0, 0x49, 0x40, + 0x7C, 0x01, 0x78, 0xCC, 0xC5, 0x7A, 0x5B, 0x9F + }, + { + 0x89, 0x38, 0x24, 0x9E, 0x4B, 0x50, 0xCA, 0xDA, + 0xCC, 0xDF, 0x5B, 0x18, 0x62, 0x13, 0x26, 0xCB, + 0xB1, 0x52, 0x53, 0xE3, 0x3A, 0x20, 0xF5, 0x63, + 0x6E, 0x99, 0x5D, 0x72, 0x47, 0x8D, 0xE4, 0x72 + }, + { + 0xF1, 0x64, 0xAB, 0xBA, 0x49, 0x63, 0xA4, 0x4D, + 0x10, 0x72, 0x57, 0xE3, 0x23, 0x2D, 0x90, 0xAC, + 0xA5, 0xE6, 0x6A, 0x14, 0x08, 0x24, 0x8C, 0x51, + 0x74, 0x1E, 0x99, 0x1D, 0xB5, 0x22, 0x77, 0x56 + }, + { + 0xD0, 0x55, 0x63, 0xE2, 0xB1, 0xCB, 0xA0, 0xC4, + 0xA2, 0xA1, 0xE8, 0xBD, 0xE3, 0xA1, 0xA0, 0xD9, + 0xF5, 0xB4, 0x0C, 0x85, 0xA0, 0x70, 0xD6, 0xF5, + 0xFB, 0x21, 0x06, 0x6E, 0xAD, 0x5D, 0x06, 0x01 + }, + { + 0x03, 0xFB, 0xB1, 0x63, 0x84, 0xF0, 0xA3, 0x86, + 0x6F, 0x4C, 0x31, 0x17, 0x87, 0x76, 0x66, 0xEF, + 0xBF, 0x12, 0x45, 0x97, 0x56, 0x4B, 0x29, 0x3D, + 0x4A, 0xAB, 0x0D, 0x26, 0x9F, 0xAB, 0xDD, 0xFA + }, + { + 0x5F, 0xA8, 0x48, 0x6A, 0xC0, 0xE5, 0x29, 0x64, + 0xD1, 0x88, 0x1B, 0xBE, 0x33, 0x8E, 0xB5, 0x4B, + 0xE2, 0xF7, 0x19, 0x54, 0x92, 0x24, 0x89, 0x20, + 0x57, 0xB4, 0xDA, 0x04, 0xBA, 0x8B, 0x34, 0x75 + }, + { + 0xCD, 0xFA, 0xBC, 0xEE, 0x46, 0x91, 0x11, 0x11, + 0x23, 0x6A, 0x31, 0x70, 0x8B, 0x25, 0x39, 0xD7, + 0x1F, 0xC2, 0x11, 0xD9, 0xB0, 0x9C, 0x0D, 0x85, + 0x30, 0xA1, 0x1E, 0x1D, 0xBF, 0x6E, 0xED, 0x01 + }, + { + 0x4F, 0x82, 0xDE, 0x03, 0xB9, 0x50, 0x47, 0x93, + 0xB8, 0x2A, 0x07, 0xA0, 0xBD, 0xCD, 0xFF, 0x31, + 0x4D, 0x75, 0x9E, 0x7B, 0x62, 0xD2, 0x6B, 0x78, + 0x49, 0x46, 0xB0, 0xD3, 0x6F, 0x91, 0x6F, 0x52 + }, + { + 0x25, 0x9E, 0xC7, 0xF1, 0x73, 0xBC, 0xC7, 0x6A, + 0x09, 0x94, 0xC9, 0x67, 0xB4, 0xF5, 0xF0, 0x24, + 0xC5, 0x60, 0x57, 0xFB, 0x79, 0xC9, 0x65, 0xC4, + 0xFA, 0xE4, 0x18, 0x75, 0xF0, 0x6A, 0x0E, 0x4C + }, + { + 0x19, 0x3C, 0xC8, 0xE7, 0xC3, 0xE0, 0x8B, 0xB3, + 0x0F, 0x54, 0x37, 0xAA, 0x27, 0xAD, 0xE1, 0xF1, + 0x42, 0x36, 0x9B, 0x24, 0x6A, 0x67, 0x5B, 0x23, + 0x83, 0xE6, 0xDA, 0x9B, 0x49, 0xA9, 0x80, 0x9E + }, + { + 0x5C, 0x10, 0x89, 0x6F, 0x0E, 0x28, 0x56, 0xB2, + 0xA2, 0xEE, 0xE0, 0xFE, 0x4A, 0x2C, 0x16, 0x33, + 0x56, 0x5D, 0x18, 0xF0, 0xE9, 0x3E, 0x1F, 0xAB, + 0x26, 0xC3, 0x73, 0xE8, 0xF8, 0x29, 0x65, 0x4D + }, + { + 0xF1, 0x60, 0x12, 0xD9, 0x3F, 0x28, 0x85, 0x1A, + 0x1E, 0xB9, 0x89, 0xF5, 0xD0, 0xB4, 0x3F, 0x3F, + 0x39, 0xCA, 0x73, 0xC9, 0xA6, 0x2D, 0x51, 0x81, + 0xBF, 0xF2, 0x37, 0x53, 0x6B, 0xD3, 0x48, 0xC3 + }, + { + 0x29, 0x66, 0xB3, 0xCF, 0xAE, 0x1E, 0x44, 0xEA, + 0x99, 0x6D, 0xC5, 0xD6, 0x86, 0xCF, 0x25, 0xFA, + 0x05, 0x3F, 0xB6, 0xF6, 0x72, 0x01, 0xB9, 0xE4, + 0x6E, 0xAD, 0xE8, 0x5D, 0x0A, 0xD6, 0xB8, 0x06 + }, + { + 0xDD, 0xB8, 0x78, 0x24, 0x85, 0xE9, 0x00, 0xBC, + 0x60, 0xBC, 0xF4, 0xC3, 0x3A, 0x6F, 0xD5, 0x85, + 0x68, 0x0C, 0xC6, 0x83, 0xD5, 0x16, 0xEF, 0xA0, + 0x3E, 0xB9, 0x98, 0x5F, 0xAD, 0x87, 0x15, 0xFB + }, + { + 0x4C, 0x4D, 0x6E, 0x71, 0xAE, 0xA0, 0x57, 0x86, + 0x41, 0x31, 0x48, 0xFC, 0x7A, 0x78, 0x6B, 0x0E, + 0xCA, 0xF5, 0x82, 0xCF, 0xF1, 0x20, 0x9F, 0x5A, + 0x80, 0x9F, 0xBA, 0x85, 0x04, 0xCE, 0x66, 0x2C + }, + { + 0xFB, 0x4C, 0x5E, 0x86, 0xD7, 0xB2, 0x22, 0x9B, + 0x99, 0xB8, 0xBA, 0x6D, 0x94, 0xC2, 0x47, 0xEF, + 0x96, 0x4A, 0xA3, 0xA2, 0xBA, 0xE8, 0xED, 0xC7, + 0x75, 0x69, 0xF2, 0x8D, 0xBB, 0xFF, 0x2D, 0x4E + }, + { + 0xE9, 0x4F, 0x52, 0x6D, 0xE9, 0x01, 0x96, 0x33, + 0xEC, 0xD5, 0x4A, 0xC6, 0x12, 0x0F, 0x23, 0x95, + 0x8D, 0x77, 0x18, 0xF1, 0xE7, 0x71, 0x7B, 0xF3, + 0x29, 0x21, 0x1A, 0x4F, 0xAE, 0xED, 0x4E, 0x6D + }, + { + 0xCB, 0xD6, 0x66, 0x0A, 0x10, 0xDB, 0x3F, 0x23, + 0xF7, 0xA0, 0x3D, 0x4B, 0x9D, 0x40, 0x44, 0xC7, + 0x93, 0x2B, 0x28, 0x01, 0xAC, 0x89, 0xD6, 0x0B, + 0xC9, 0xEB, 0x92, 0xD6, 0x5A, 0x46, 0xC2, 0xA0 + }, + { + 0x88, 0x18, 0xBB, 0xD3, 0xDB, 0x4D, 0xC1, 0x23, + 0xB2, 0x5C, 0xBB, 0xA5, 0xF5, 0x4C, 0x2B, 0xC4, + 0xB3, 0xFC, 0xF9, 0xBF, 0x7D, 0x7A, 0x77, 0x09, + 0xF4, 0xAE, 0x58, 0x8B, 0x26, 0x7C, 0x4E, 0xCE + }, + { + 0xC6, 0x53, 0x82, 0x51, 0x3F, 0x07, 0x46, 0x0D, + 0xA3, 0x98, 0x33, 0xCB, 0x66, 0x6C, 0x5E, 0xD8, + 0x2E, 0x61, 0xB9, 0xE9, 0x98, 0xF4, 0xB0, 0xC4, + 0x28, 0x7C, 0xEE, 0x56, 0xC3, 0xCC, 0x9B, 0xCD + }, + { + 0x89, 0x75, 0xB0, 0x57, 0x7F, 0xD3, 0x55, 0x66, + 0xD7, 0x50, 0xB3, 0x62, 0xB0, 0x89, 0x7A, 0x26, + 0xC3, 0x99, 0x13, 0x6D, 0xF0, 0x7B, 0xAB, 0xAB, + 0xBD, 0xE6, 0x20, 0x3F, 0xF2, 0x95, 0x4E, 0xD4 + }, + { + 0x21, 0xFE, 0x0C, 0xEB, 0x00, 0x52, 0xBE, 0x7F, + 0xB0, 0xF0, 0x04, 0x18, 0x7C, 0xAC, 0xD7, 0xDE, + 0x67, 0xFA, 0x6E, 0xB0, 0x93, 0x8D, 0x92, 0x76, + 0x77, 0xF2, 0x39, 0x8C, 0x13, 0x23, 0x17, 0xA8 + }, + { + 0x2E, 0xF7, 0x3F, 0x3C, 0x26, 0xF1, 0x2D, 0x93, + 0x88, 0x9F, 0x3C, 0x78, 0xB6, 0xA6, 0x6C, 0x1D, + 0x52, 0xB6, 0x49, 0xDC, 0x9E, 0x85, 0x6E, 0x2C, + 0x17, 0x2E, 0xA7, 0xC5, 0x8A, 0xC2, 0xB5, 0xE3 + }, + { + 0x38, 0x8A, 0x3C, 0xD5, 0x6D, 0x73, 0x86, 0x7A, + 0xBB, 0x5F, 0x84, 0x01, 0x49, 0x2B, 0x6E, 0x26, + 0x81, 0xEB, 0x69, 0x85, 0x1E, 0x76, 0x7F, 0xD8, + 0x42, 0x10, 0xA5, 0x60, 0x76, 0xFB, 0x3D, 0xD3 + }, + { + 0xAF, 0x53, 0x3E, 0x02, 0x2F, 0xC9, 0x43, 0x9E, + 0x4E, 0x3C, 0xB8, 0x38, 0xEC, 0xD1, 0x86, 0x92, + 0x23, 0x2A, 0xDF, 0x6F, 0xE9, 0x83, 0x95, 0x26, + 0xD3, 0xC3, 0xDD, 0x1B, 0x71, 0x91, 0x0B, 0x1A + }, + { + 0x75, 0x1C, 0x09, 0xD4, 0x1A, 0x93, 0x43, 0x88, + 0x2A, 0x81, 0xCD, 0x13, 0xEE, 0x40, 0x81, 0x8D, + 0x12, 0xEB, 0x44, 0xC6, 0xC7, 0xF4, 0x0D, 0xF1, + 0x6E, 0x4A, 0xEA, 0x8F, 0xAB, 0x91, 0x97, 0x2A + }, + { + 0x5B, 0x73, 0xDD, 0xB6, 0x8D, 0x9D, 0x2B, 0x0A, + 0xA2, 0x65, 0xA0, 0x79, 0x88, 0xD6, 0xB8, 0x8A, + 0xE9, 0xAA, 0xC5, 0x82, 0xAF, 0x83, 0x03, 0x2F, + 0x8A, 0x9B, 0x21, 0xA2, 0xE1, 0xB7, 0xBF, 0x18 + }, + { + 0x3D, 0xA2, 0x91, 0x26, 0xC7, 0xC5, 0xD7, 0xF4, + 0x3E, 0x64, 0x24, 0x2A, 0x79, 0xFE, 0xAA, 0x4E, + 0xF3, 0x45, 0x9C, 0xDE, 0xCC, 0xC8, 0x98, 0xED, + 0x59, 0xA9, 0x7F, 0x6E, 0xC9, 0x3B, 0x9D, 0xAB + }, + { + 0x56, 0x6D, 0xC9, 0x20, 0x29, 0x3D, 0xA5, 0xCB, + 0x4F, 0xE0, 0xAA, 0x8A, 0xBD, 0xA8, 0xBB, 0xF5, + 0x6F, 0x55, 0x23, 0x13, 0xBF, 0xF1, 0x90, 0x46, + 0x64, 0x1E, 0x36, 0x15, 0xC1, 0xE3, 0xED, 0x3F + }, + { + 0x41, 0x15, 0xBE, 0xA0, 0x2F, 0x73, 0xF9, 0x7F, + 0x62, 0x9E, 0x5C, 0x55, 0x90, 0x72, 0x0C, 0x01, + 0xE7, 0xE4, 0x49, 0xAE, 0x2A, 0x66, 0x97, 0xD4, + 0xD2, 0x78, 0x33, 0x21, 0x30, 0x36, 0x92, 0xF9 + }, + { + 0x4C, 0xE0, 0x8F, 0x47, 0x62, 0x46, 0x8A, 0x76, + 0x70, 0x01, 0x21, 0x64, 0x87, 0x8D, 0x68, 0x34, + 0x0C, 0x52, 0xA3, 0x5E, 0x66, 0xC1, 0x88, 0x4D, + 0x5C, 0x86, 0x48, 0x89, 0xAB, 0xC9, 0x66, 0x77 + }, + { + 0x81, 0xEA, 0x0B, 0x78, 0x04, 0x12, 0x4E, 0x0C, + 0x22, 0xEA, 0x5F, 0xC7, 0x11, 0x04, 0xA2, 0xAF, + 0xCB, 0x52, 0xA1, 0xFA, 0x81, 0x6F, 0x3E, 0xCB, + 0x7D, 0xCB, 0x5D, 0x9D, 0xEA, 0x17, 0x86, 0xD0 + }, + { + 0xFE, 0x36, 0x27, 0x33, 0xB0, 0x5F, 0x6B, 0xED, + 0xAF, 0x93, 0x79, 0xD7, 0xF7, 0x93, 0x6E, 0xDE, + 0x20, 0x9B, 0x1F, 0x83, 0x23, 0xC3, 0x92, 0x25, + 0x49, 0xD9, 0xE7, 0x36, 0x81, 0xB5, 0xDB, 0x7B + }, + { + 0xEF, 0xF3, 0x7D, 0x30, 0xDF, 0xD2, 0x03, 0x59, + 0xBE, 0x4E, 0x73, 0xFD, 0xF4, 0x0D, 0x27, 0x73, + 0x4B, 0x3D, 0xF9, 0x0A, 0x97, 0xA5, 0x5E, 0xD7, + 0x45, 0x29, 0x72, 0x94, 0xCA, 0x85, 0xD0, 0x9F + }, + { + 0x17, 0x2F, 0xFC, 0x67, 0x15, 0x3D, 0x12, 0xE0, + 0xCA, 0x76, 0xA8, 0xB6, 0xCD, 0x5D, 0x47, 0x31, + 0x88, 0x5B, 0x39, 0xCE, 0x0C, 0xAC, 0x93, 0xA8, + 0x97, 0x2A, 0x18, 0x00, 0x6C, 0x8B, 0x8B, 0xAF + }, + { + 0xC4, 0x79, 0x57, 0xF1, 0xCC, 0x88, 0xE8, 0x3E, + 0xF9, 0x44, 0x58, 0x39, 0x70, 0x9A, 0x48, 0x0A, + 0x03, 0x6B, 0xED, 0x5F, 0x88, 0xAC, 0x0F, 0xCC, + 0x8E, 0x1E, 0x70, 0x3F, 0xFA, 0xAC, 0x13, 0x2C + }, + { + 0x30, 0xF3, 0x54, 0x83, 0x70, 0xCF, 0xDC, 0xED, + 0xA5, 0xC3, 0x7B, 0x56, 0x9B, 0x61, 0x75, 0xE7, + 0x99, 0xEE, 0xF1, 0xA6, 0x2A, 0xAA, 0x94, 0x32, + 0x45, 0xAE, 0x76, 0x69, 0xC2, 0x27, 0xA7, 0xB5 + }, + { + 0xC9, 0x5D, 0xCB, 0x3C, 0xF1, 0xF2, 0x7D, 0x0E, + 0xEF, 0x2F, 0x25, 0xD2, 0x41, 0x38, 0x70, 0x90, + 0x4A, 0x87, 0x7C, 0x4A, 0x56, 0xC2, 0xDE, 0x1E, + 0x83, 0xE2, 0xBC, 0x2A, 0xE2, 0xE4, 0x68, 0x21 + }, + { + 0xD5, 0xD0, 0xB5, 0xD7, 0x05, 0x43, 0x4C, 0xD4, + 0x6B, 0x18, 0x57, 0x49, 0xF6, 0x6B, 0xFB, 0x58, + 0x36, 0xDC, 0xDF, 0x6E, 0xE5, 0x49, 0xA2, 0xB7, + 0xA4, 0xAE, 0xE7, 0xF5, 0x80, 0x07, 0xCA, 0xAF + }, + { + 0xBB, 0xC1, 0x24, 0xA7, 0x12, 0xF1, 0x5D, 0x07, + 0xC3, 0x00, 0xE0, 0x5B, 0x66, 0x83, 0x89, 0xA4, + 0x39, 0xC9, 0x17, 0x77, 0xF7, 0x21, 0xF8, 0x32, + 0x0C, 0x1C, 0x90, 0x78, 0x06, 0x6D, 0x2C, 0x7E + }, + { + 0xA4, 0x51, 0xB4, 0x8C, 0x35, 0xA6, 0xC7, 0x85, + 0x4C, 0xFA, 0xAE, 0x60, 0x26, 0x2E, 0x76, 0x99, + 0x08, 0x16, 0x38, 0x2A, 0xC0, 0x66, 0x7E, 0x5A, + 0x5C, 0x9E, 0x1B, 0x46, 0xC4, 0x34, 0x2D, 0xDF + }, + { + 0xB0, 0xD1, 0x50, 0xFB, 0x55, 0xE7, 0x78, 0xD0, + 0x11, 0x47, 0xF0, 0xB5, 0xD8, 0x9D, 0x99, 0xEC, + 0xB2, 0x0F, 0xF0, 0x7E, 0x5E, 0x67, 0x60, 0xD6, + 0xB6, 0x45, 0xEB, 0x5B, 0x65, 0x4C, 0x62, 0x2B + }, + { + 0x34, 0xF7, 0x37, 0xC0, 0xAB, 0x21, 0x99, 0x51, + 0xEE, 0xE8, 0x9A, 0x9F, 0x8D, 0xAC, 0x29, 0x9C, + 0x9D, 0x4C, 0x38, 0xF3, 0x3F, 0xA4, 0x94, 0xC5, + 0xC6, 0xEE, 0xFC, 0x92, 0xB6, 0xDB, 0x08, 0xBC + }, + { + 0x1A, 0x62, 0xCC, 0x3A, 0x00, 0x80, 0x0D, 0xCB, + 0xD9, 0x98, 0x91, 0x08, 0x0C, 0x1E, 0x09, 0x84, + 0x58, 0x19, 0x3A, 0x8C, 0xC9, 0xF9, 0x70, 0xEA, + 0x99, 0xFB, 0xEF, 0xF0, 0x03, 0x18, 0xC2, 0x89 + }, + { + 0xCF, 0xCE, 0x55, 0xEB, 0xAF, 0xC8, 0x40, 0xD7, + 0xAE, 0x48, 0x28, 0x1C, 0x7F, 0xD5, 0x7E, 0xC8, + 0xB4, 0x82, 0xD4, 0xB7, 0x04, 0x43, 0x74, 0x95, + 0x49, 0x5A, 0xC4, 0x14, 0xCF, 0x4A, 0x37, 0x4B + }, + { + 0x67, 0x46, 0xFA, 0xCF, 0x71, 0x14, 0x6D, 0x99, + 0x9D, 0xAB, 0xD0, 0x5D, 0x09, 0x3A, 0xE5, 0x86, + 0x64, 0x8D, 0x1E, 0xE2, 0x8E, 0x72, 0x61, 0x7B, + 0x99, 0xD0, 0xF0, 0x08, 0x6E, 0x1E, 0x45, 0xBF + }, + { + 0x57, 0x1C, 0xED, 0x28, 0x3B, 0x3F, 0x23, 0xB4, + 0xE7, 0x50, 0xBF, 0x12, 0xA2, 0xCA, 0xF1, 0x78, + 0x18, 0x47, 0xBD, 0x89, 0x0E, 0x43, 0x60, 0x3C, + 0xDC, 0x59, 0x76, 0x10, 0x2B, 0x7B, 0xB1, 0x1B + }, + { + 0xCF, 0xCB, 0x76, 0x5B, 0x04, 0x8E, 0x35, 0x02, + 0x2C, 0x5D, 0x08, 0x9D, 0x26, 0xE8, 0x5A, 0x36, + 0xB0, 0x05, 0xA2, 0xB8, 0x04, 0x93, 0xD0, 0x3A, + 0x14, 0x4E, 0x09, 0xF4, 0x09, 0xB6, 0xAF, 0xD1 + }, + { + 0x40, 0x50, 0xC7, 0xA2, 0x77, 0x05, 0xBB, 0x27, + 0xF4, 0x20, 0x89, 0xB2, 0x99, 0xF3, 0xCB, 0xE5, + 0x05, 0x4E, 0xAD, 0x68, 0x72, 0x7E, 0x8E, 0xF9, + 0x31, 0x8C, 0xE6, 0xF2, 0x5C, 0xD6, 0xF3, 0x1D + }, + { + 0x18, 0x40, 0x70, 0xBD, 0x5D, 0x26, 0x5F, 0xBD, + 0xC1, 0x42, 0xCD, 0x1C, 0x5C, 0xD0, 0xD7, 0xE4, + 0x14, 0xE7, 0x03, 0x69, 0xA2, 0x66, 0xD6, 0x27, + 0xC8, 0xFB, 0xA8, 0x4F, 0xA5, 0xE8, 0x4C, 0x34 + }, + { + 0x9E, 0xDD, 0xA9, 0xA4, 0x44, 0x39, 0x02, 0xA9, + 0x58, 0x8C, 0x0D, 0x0C, 0xCC, 0x62, 0xB9, 0x30, + 0x21, 0x84, 0x79, 0xA6, 0x84, 0x1E, 0x6F, 0xE7, + 0xD4, 0x30, 0x03, 0xF0, 0x4B, 0x1F, 0xD6, 0x43 + }, + { + 0xE4, 0x12, 0xFE, 0xEF, 0x79, 0x08, 0x32, 0x4A, + 0x6D, 0xA1, 0x84, 0x16, 0x29, 0xF3, 0x5D, 0x3D, + 0x35, 0x86, 0x42, 0x01, 0x93, 0x10, 0xEC, 0x57, + 0xC6, 0x14, 0x83, 0x6B, 0x63, 0xD3, 0x07, 0x63 + }, + { + 0x1A, 0x2B, 0x8E, 0xDF, 0xF3, 0xF9, 0xAC, 0xC1, + 0x55, 0x4F, 0xCB, 0xAE, 0x3C, 0xF1, 0xD6, 0x29, + 0x8C, 0x64, 0x62, 0xE2, 0x2E, 0x5E, 0xB0, 0x25, + 0x96, 0x84, 0xF8, 0x35, 0x01, 0x2B, 0xD1, 0x3F + }, + { + 0x28, 0x8C, 0x4A, 0xD9, 0xB9, 0x40, 0x97, 0x62, + 0xEA, 0x07, 0xC2, 0x4A, 0x41, 0xF0, 0x4F, 0x69, + 0xA7, 0xD7, 0x4B, 0xEE, 0x2D, 0x95, 0x43, 0x53, + 0x74, 0xBD, 0xE9, 0x46, 0xD7, 0x24, 0x1C, 0x7B + }, + { + 0x80, 0x56, 0x91, 0xBB, 0x28, 0x67, 0x48, 0xCF, + 0xB5, 0x91, 0xD3, 0xAE, 0xBE, 0x7E, 0x6F, 0x4E, + 0x4D, 0xC6, 0xE2, 0x80, 0x8C, 0x65, 0x14, 0x3C, + 0xC0, 0x04, 0xE4, 0xEB, 0x6F, 0xD0, 0x9D, 0x43 + }, + { + 0xD4, 0xAC, 0x8D, 0x3A, 0x0A, 0xFC, 0x6C, 0xFA, + 0x7B, 0x46, 0x0A, 0xE3, 0x00, 0x1B, 0xAE, 0xB3, + 0x6D, 0xAD, 0xB3, 0x7D, 0xA0, 0x7D, 0x2E, 0x8A, + 0xC9, 0x18, 0x22, 0xDF, 0x34, 0x8A, 0xED, 0x3D + }, + { + 0xC3, 0x76, 0x61, 0x70, 0x14, 0xD2, 0x01, 0x58, + 0xBC, 0xED, 0x3D, 0x3B, 0xA5, 0x52, 0xB6, 0xEC, + 0xCF, 0x84, 0xE6, 0x2A, 0xA3, 0xEB, 0x65, 0x0E, + 0x90, 0x02, 0x9C, 0x84, 0xD1, 0x3E, 0xEA, 0x69 + }, + { + 0xC4, 0x1F, 0x09, 0xF4, 0x3C, 0xEC, 0xAE, 0x72, + 0x93, 0xD6, 0x00, 0x7C, 0xA0, 0xA3, 0x57, 0x08, + 0x7D, 0x5A, 0xE5, 0x9B, 0xE5, 0x00, 0xC1, 0xCD, + 0x5B, 0x28, 0x9E, 0xE8, 0x10, 0xC7, 0xB0, 0x82 + }, + { + 0x03, 0xD1, 0xCE, 0xD1, 0xFB, 0xA5, 0xC3, 0x91, + 0x55, 0xC4, 0x4B, 0x77, 0x65, 0xCB, 0x76, 0x0C, + 0x78, 0x70, 0x8D, 0xCF, 0xC8, 0x0B, 0x0B, 0xD8, + 0xAD, 0xE3, 0xA5, 0x6D, 0xA8, 0x83, 0x0B, 0x29 + }, + { + 0x09, 0xBD, 0xE6, 0xF1, 0x52, 0x21, 0x8D, 0xC9, + 0x2C, 0x41, 0xD7, 0xF4, 0x53, 0x87, 0xE6, 0x3E, + 0x58, 0x69, 0xD8, 0x07, 0xEC, 0x70, 0xB8, 0x21, + 0x40, 0x5D, 0xBD, 0x88, 0x4B, 0x7F, 0xCF, 0x4B + }, + { + 0x71, 0xC9, 0x03, 0x6E, 0x18, 0x17, 0x9B, 0x90, + 0xB3, 0x7D, 0x39, 0xE9, 0xF0, 0x5E, 0xB8, 0x9C, + 0xC5, 0xFC, 0x34, 0x1F, 0xD7, 0xC4, 0x77, 0xD0, + 0xD7, 0x49, 0x32, 0x85, 0xFA, 0xCA, 0x08, 0xA4 + }, + { + 0x59, 0x16, 0x83, 0x3E, 0xBB, 0x05, 0xCD, 0x91, + 0x9C, 0xA7, 0xFE, 0x83, 0xB6, 0x92, 0xD3, 0x20, + 0x5B, 0xEF, 0x72, 0x39, 0x2B, 0x2C, 0xF6, 0xBB, + 0x0A, 0x6D, 0x43, 0xF9, 0x94, 0xF9, 0x5F, 0x11 + }, + { + 0xF6, 0x3A, 0xAB, 0x3E, 0xC6, 0x41, 0xB3, 0xB0, + 0x24, 0x96, 0x4C, 0x2B, 0x43, 0x7C, 0x04, 0xF6, + 0x04, 0x3C, 0x4C, 0x7E, 0x02, 0x79, 0x23, 0x99, + 0x95, 0x40, 0x19, 0x58, 0xF8, 0x6B, 0xBE, 0x54 + }, + { + 0xF1, 0x72, 0xB1, 0x80, 0xBF, 0xB0, 0x97, 0x40, + 0x49, 0x31, 0x20, 0xB6, 0x32, 0x6C, 0xBD, 0xC5, + 0x61, 0xE4, 0x77, 0xDE, 0xF9, 0xBB, 0xCF, 0xD2, + 0x8C, 0xC8, 0xC1, 0xC5, 0xE3, 0x37, 0x9A, 0x31 + }, + { + 0xCB, 0x9B, 0x89, 0xCC, 0x18, 0x38, 0x1D, 0xD9, + 0x14, 0x1A, 0xDE, 0x58, 0x86, 0x54, 0xD4, 0xE6, + 0xA2, 0x31, 0xD5, 0xBF, 0x49, 0xD4, 0xD5, 0x9A, + 0xC2, 0x7D, 0x86, 0x9C, 0xBE, 0x10, 0x0C, 0xF3 + }, + { + 0x7B, 0xD8, 0x81, 0x50, 0x46, 0xFD, 0xD8, 0x10, + 0xA9, 0x23, 0xE1, 0x98, 0x4A, 0xAE, 0xBD, 0xCD, + 0xF8, 0x4D, 0x87, 0xC8, 0x99, 0x2D, 0x68, 0xB5, + 0xEE, 0xB4, 0x60, 0xF9, 0x3E, 0xB3, 0xC8, 0xD7 + }, + { + 0x60, 0x7B, 0xE6, 0x68, 0x62, 0xFD, 0x08, 0xEE, + 0x5B, 0x19, 0xFA, 0xCA, 0xC0, 0x9D, 0xFD, 0xBC, + 0xD4, 0x0C, 0x31, 0x21, 0x01, 0xD6, 0x6E, 0x6E, + 0xBD, 0x2B, 0x84, 0x1F, 0x1B, 0x9A, 0x93, 0x25 + }, + { + 0x9F, 0xE0, 0x3B, 0xBE, 0x69, 0xAB, 0x18, 0x34, + 0xF5, 0x21, 0x9B, 0x0D, 0xA8, 0x8A, 0x08, 0xB3, + 0x0A, 0x66, 0xC5, 0x91, 0x3F, 0x01, 0x51, 0x96, + 0x3C, 0x36, 0x05, 0x60, 0xDB, 0x03, 0x87, 0xB3 + }, + { + 0x90, 0xA8, 0x35, 0x85, 0x71, 0x7B, 0x75, 0xF0, + 0xE9, 0xB7, 0x25, 0xE0, 0x55, 0xEE, 0xEE, 0xB9, + 0xE7, 0xA0, 0x28, 0xEA, 0x7E, 0x6C, 0xBC, 0x07, + 0xB2, 0x09, 0x17, 0xEC, 0x03, 0x63, 0xE3, 0x8C + }, + { + 0x33, 0x6E, 0xA0, 0x53, 0x0F, 0x4A, 0x74, 0x69, + 0x12, 0x6E, 0x02, 0x18, 0x58, 0x7E, 0xBB, 0xDE, + 0x33, 0x58, 0xA0, 0xB3, 0x1C, 0x29, 0xD2, 0x00, + 0xF7, 0xDC, 0x7E, 0xB1, 0x5C, 0x6A, 0xAD, 0xD8 + }, + { + 0xA7, 0x9E, 0x76, 0xDC, 0x0A, 0xBC, 0xA4, 0x39, + 0x6F, 0x07, 0x47, 0xCD, 0x7B, 0x74, 0x8D, 0xF9, + 0x13, 0x00, 0x76, 0x26, 0xB1, 0xD6, 0x59, 0xDA, + 0x0C, 0x1F, 0x78, 0xB9, 0x30, 0x3D, 0x01, 0xA3 + }, + { + 0x44, 0xE7, 0x8A, 0x77, 0x37, 0x56, 0xE0, 0x95, + 0x15, 0x19, 0x50, 0x4D, 0x70, 0x38, 0xD2, 0x8D, + 0x02, 0x13, 0xA3, 0x7E, 0x0C, 0xE3, 0x75, 0x37, + 0x17, 0x57, 0xBC, 0x99, 0x63, 0x11, 0xE3, 0xB8 + }, + { + 0x77, 0xAC, 0x01, 0x2A, 0x3F, 0x75, 0x4D, 0xCF, + 0xEA, 0xB5, 0xEB, 0x99, 0x6B, 0xE9, 0xCD, 0x2D, + 0x1F, 0x96, 0x11, 0x1B, 0x6E, 0x49, 0xF3, 0x99, + 0x4D, 0xF1, 0x81, 0xF2, 0x85, 0x69, 0xD8, 0x25 + }, + { + 0xCE, 0x5A, 0x10, 0xDB, 0x6F, 0xCC, 0xDA, 0xF1, + 0x40, 0xAA, 0xA4, 0xDE, 0xD6, 0x25, 0x0A, 0x9C, + 0x06, 0xE9, 0x22, 0x2B, 0xC9, 0xF9, 0xF3, 0x65, + 0x8A, 0x4A, 0xFF, 0x93, 0x5F, 0x2B, 0x9F, 0x3A + }, + { + 0xEC, 0xC2, 0x03, 0xA7, 0xFE, 0x2B, 0xE4, 0xAB, + 0xD5, 0x5B, 0xB5, 0x3E, 0x6E, 0x67, 0x35, 0x72, + 0xE0, 0x07, 0x8D, 0xA8, 0xCD, 0x37, 0x5E, 0xF4, + 0x30, 0xCC, 0x97, 0xF9, 0xF8, 0x00, 0x83, 0xAF + }, + { + 0x14, 0xA5, 0x18, 0x6D, 0xE9, 0xD7, 0xA1, 0x8B, + 0x04, 0x12, 0xB8, 0x56, 0x3E, 0x51, 0xCC, 0x54, + 0x33, 0x84, 0x0B, 0x4A, 0x12, 0x9A, 0x8F, 0xF9, + 0x63, 0xB3, 0x3A, 0x3C, 0x4A, 0xFE, 0x8E, 0xBB + }, + { + 0x13, 0xF8, 0xEF, 0x95, 0xCB, 0x86, 0xE6, 0xA6, + 0x38, 0x93, 0x1C, 0x8E, 0x10, 0x76, 0x73, 0xEB, + 0x76, 0xBA, 0x10, 0xD7, 0xC2, 0xCD, 0x70, 0xB9, + 0xD9, 0x92, 0x0B, 0xBE, 0xED, 0x92, 0x94, 0x09 + }, + { + 0x0B, 0x33, 0x8F, 0x4E, 0xE1, 0x2F, 0x2D, 0xFC, + 0xB7, 0x87, 0x13, 0x37, 0x79, 0x41, 0xE0, 0xB0, + 0x63, 0x21, 0x52, 0x58, 0x1D, 0x13, 0x32, 0x51, + 0x6E, 0x4A, 0x2C, 0xAB, 0x19, 0x42, 0xCC, 0xA4 + }, + { + 0xEA, 0xAB, 0x0E, 0xC3, 0x7B, 0x3B, 0x8A, 0xB7, + 0x96, 0xE9, 0xF5, 0x72, 0x38, 0xDE, 0x14, 0xA2, + 0x64, 0xA0, 0x76, 0xF3, 0x88, 0x7D, 0x86, 0xE2, + 0x9B, 0xB5, 0x90, 0x6D, 0xB5, 0xA0, 0x0E, 0x02 + }, + { + 0x23, 0xCB, 0x68, 0xB8, 0xC0, 0xE6, 0xDC, 0x26, + 0xDC, 0x27, 0x76, 0x6D, 0xDC, 0x0A, 0x13, 0xA9, + 0x94, 0x38, 0xFD, 0x55, 0x61, 0x7A, 0xA4, 0x09, + 0x5D, 0x8F, 0x96, 0x97, 0x20, 0xC8, 0x72, 0xDF + }, + { + 0x09, 0x1D, 0x8E, 0xE3, 0x0D, 0x6F, 0x29, 0x68, + 0xD4, 0x6B, 0x68, 0x7D, 0xD6, 0x52, 0x92, 0x66, + 0x57, 0x42, 0xDE, 0x0B, 0xB8, 0x3D, 0xCC, 0x00, + 0x04, 0xC7, 0x2C, 0xE1, 0x00, 0x07, 0xA5, 0x49 + }, + { + 0x7F, 0x50, 0x7A, 0xBC, 0x6D, 0x19, 0xBA, 0x00, + 0xC0, 0x65, 0xA8, 0x76, 0xEC, 0x56, 0x57, 0x86, + 0x88, 0x82, 0xD1, 0x8A, 0x22, 0x1B, 0xC4, 0x6C, + 0x7A, 0x69, 0x12, 0x54, 0x1F, 0x5B, 0xC7, 0xBA + }, + { + 0xA0, 0x60, 0x7C, 0x24, 0xE1, 0x4E, 0x8C, 0x22, + 0x3D, 0xB0, 0xD7, 0x0B, 0x4D, 0x30, 0xEE, 0x88, + 0x01, 0x4D, 0x60, 0x3F, 0x43, 0x7E, 0x9E, 0x02, + 0xAA, 0x7D, 0xAF, 0xA3, 0xCD, 0xFB, 0xAD, 0x94 + }, + { + 0xDD, 0xBF, 0xEA, 0x75, 0xCC, 0x46, 0x78, 0x82, + 0xEB, 0x34, 0x83, 0xCE, 0x5E, 0x2E, 0x75, 0x6A, + 0x4F, 0x47, 0x01, 0xB7, 0x6B, 0x44, 0x55, 0x19, + 0xE8, 0x9F, 0x22, 0xD6, 0x0F, 0xA8, 0x6E, 0x06 + }, + { + 0x0C, 0x31, 0x1F, 0x38, 0xC3, 0x5A, 0x4F, 0xB9, + 0x0D, 0x65, 0x1C, 0x28, 0x9D, 0x48, 0x68, 0x56, + 0xCD, 0x14, 0x13, 0xDF, 0x9B, 0x06, 0x77, 0xF5, + 0x3E, 0xCE, 0x2C, 0xD9, 0xE4, 0x77, 0xC6, 0x0A + }, + { + 0x46, 0xA7, 0x3A, 0x8D, 0xD3, 0xE7, 0x0F, 0x59, + 0xD3, 0x94, 0x2C, 0x01, 0xDF, 0x59, 0x9D, 0xEF, + 0x78, 0x3C, 0x9D, 0xA8, 0x2F, 0xD8, 0x32, 0x22, + 0xCD, 0x66, 0x2B, 0x53, 0xDC, 0xE7, 0xDB, 0xDF + }, + { + 0xAD, 0x03, 0x8F, 0xF9, 0xB1, 0x4D, 0xE8, 0x4A, + 0x80, 0x1E, 0x4E, 0x62, 0x1C, 0xE5, 0xDF, 0x02, + 0x9D, 0xD9, 0x35, 0x20, 0xD0, 0xC2, 0xFA, 0x38, + 0xBF, 0xF1, 0x76, 0xA8, 0xB1, 0xD1, 0x69, 0x8C + }, + { + 0xAB, 0x70, 0xC5, 0xDF, 0xBD, 0x1E, 0xA8, 0x17, + 0xFE, 0xD0, 0xCD, 0x06, 0x72, 0x93, 0xAB, 0xF3, + 0x19, 0xE5, 0xD7, 0x90, 0x1C, 0x21, 0x41, 0xD5, + 0xD9, 0x9B, 0x23, 0xF0, 0x3A, 0x38, 0xE7, 0x48 + }, + { + 0x1F, 0xFF, 0xDA, 0x67, 0x93, 0x2B, 0x73, 0xC8, + 0xEC, 0xAF, 0x00, 0x9A, 0x34, 0x91, 0xA0, 0x26, + 0x95, 0x3B, 0xAB, 0xFE, 0x1F, 0x66, 0x3B, 0x06, + 0x97, 0xC3, 0xC4, 0xAE, 0x8B, 0x2E, 0x7D, 0xCB + }, + { + 0xB0, 0xD2, 0xCC, 0x19, 0x47, 0x2D, 0xD5, 0x7F, + 0x2B, 0x17, 0xEF, 0xC0, 0x3C, 0x8D, 0x58, 0xC2, + 0x28, 0x3D, 0xBB, 0x19, 0xDA, 0x57, 0x2F, 0x77, + 0x55, 0x85, 0x5A, 0xA9, 0x79, 0x43, 0x17, 0xA0 + }, + { + 0xA0, 0xD1, 0x9A, 0x6E, 0xE3, 0x39, 0x79, 0xC3, + 0x25, 0x51, 0x0E, 0x27, 0x66, 0x22, 0xDF, 0x41, + 0xF7, 0x15, 0x83, 0xD0, 0x75, 0x01, 0xB8, 0x70, + 0x71, 0x12, 0x9A, 0x0A, 0xD9, 0x47, 0x32, 0xA5 + }, + { + 0x72, 0x46, 0x42, 0xA7, 0x03, 0x2D, 0x10, 0x62, + 0xB8, 0x9E, 0x52, 0xBE, 0xA3, 0x4B, 0x75, 0xDF, + 0x7D, 0x8F, 0xE7, 0x72, 0xD9, 0xFE, 0x3C, 0x93, + 0xDD, 0xF3, 0xC4, 0x54, 0x5A, 0xB5, 0xA9, 0x9B + }, + { + 0xAD, 0xE5, 0xEA, 0xA7, 0xE6, 0x1F, 0x67, 0x2D, + 0x58, 0x7E, 0xA0, 0x3D, 0xAE, 0x7D, 0x7B, 0x55, + 0x22, 0x9C, 0x01, 0xD0, 0x6B, 0xC0, 0xA5, 0x70, + 0x14, 0x36, 0xCB, 0xD1, 0x83, 0x66, 0xA6, 0x26 + }, + { + 0x01, 0x3B, 0x31, 0xEB, 0xD2, 0x28, 0xFC, 0xDD, + 0xA5, 0x1F, 0xAB, 0xB0, 0x3B, 0xB0, 0x2D, 0x60, + 0xAC, 0x20, 0xCA, 0x21, 0x5A, 0xAF, 0xA8, 0x3B, + 0xDD, 0x85, 0x5E, 0x37, 0x55, 0xA3, 0x5F, 0x0B + }, + { + 0x33, 0x2E, 0xD4, 0x0B, 0xB1, 0x0D, 0xDE, 0x3C, + 0x95, 0x4A, 0x75, 0xD7, 0xB8, 0x99, 0x9D, 0x4B, + 0x26, 0xA1, 0xC0, 0x63, 0xC1, 0xDC, 0x6E, 0x32, + 0xC1, 0xD9, 0x1B, 0xAB, 0x7B, 0xBB, 0x7D, 0x16 + }, + { + 0xC7, 0xA1, 0x97, 0xB3, 0xA0, 0x5B, 0x56, 0x6B, + 0xCC, 0x9F, 0xAC, 0xD2, 0x0E, 0x44, 0x1D, 0x6F, + 0x6C, 0x28, 0x60, 0xAC, 0x96, 0x51, 0xCD, 0x51, + 0xD6, 0xB9, 0xD2, 0xCD, 0xEE, 0xEA, 0x03, 0x90 + }, + { + 0xBD, 0x9C, 0xF6, 0x4E, 0xA8, 0x95, 0x3C, 0x03, + 0x71, 0x08, 0xE6, 0xF6, 0x54, 0x91, 0x4F, 0x39, + 0x58, 0xB6, 0x8E, 0x29, 0xC1, 0x67, 0x00, 0xDC, + 0x18, 0x4D, 0x94, 0xA2, 0x17, 0x08, 0xFF, 0x60 + }, + { + 0x88, 0x35, 0xB0, 0xAC, 0x02, 0x11, 0x51, 0xDF, + 0x71, 0x64, 0x74, 0xCE, 0x27, 0xCE, 0x4D, 0x3C, + 0x15, 0xF0, 0xB2, 0xDA, 0xB4, 0x80, 0x03, 0xCF, + 0x3F, 0x3E, 0xFD, 0x09, 0x45, 0x10, 0x6B, 0x9A + }, + { + 0x3B, 0xFE, 0xFA, 0x33, 0x01, 0xAA, 0x55, 0xC0, + 0x80, 0x19, 0x0C, 0xFF, 0xDA, 0x8E, 0xAE, 0x51, + 0xD9, 0xAF, 0x48, 0x8B, 0x4C, 0x1F, 0x24, 0xC3, + 0xD9, 0xA7, 0x52, 0x42, 0xFD, 0x8E, 0xA0, 0x1D + }, + { + 0x08, 0x28, 0x4D, 0x14, 0x99, 0x3C, 0xD4, 0x7D, + 0x53, 0xEB, 0xAE, 0xCF, 0x0D, 0xF0, 0x47, 0x8C, + 0xC1, 0x82, 0xC8, 0x9C, 0x00, 0xE1, 0x85, 0x9C, + 0x84, 0x85, 0x16, 0x86, 0xDD, 0xF2, 0xC1, 0xB7 + }, + { + 0x1E, 0xD7, 0xEF, 0x9F, 0x04, 0xC2, 0xAC, 0x8D, + 0xB6, 0xA8, 0x64, 0xDB, 0x13, 0x10, 0x87, 0xF2, + 0x70, 0x65, 0x09, 0x8E, 0x69, 0xC3, 0xFE, 0x78, + 0x71, 0x8D, 0x9B, 0x94, 0x7F, 0x4A, 0x39, 0xD0 + }, + { + 0xC1, 0x61, 0xF2, 0xDC, 0xD5, 0x7E, 0x9C, 0x14, + 0x39, 0xB3, 0x1A, 0x9D, 0xD4, 0x3D, 0x8F, 0x3D, + 0x7D, 0xD8, 0xF0, 0xEB, 0x7C, 0xFA, 0xC6, 0xFB, + 0x25, 0xA0, 0xF2, 0x8E, 0x30, 0x6F, 0x06, 0x61 + }, + { + 0xC0, 0x19, 0x69, 0xAD, 0x34, 0xC5, 0x2C, 0xAF, + 0x3D, 0xC4, 0xD8, 0x0D, 0x19, 0x73, 0x5C, 0x29, + 0x73, 0x1A, 0xC6, 0xE7, 0xA9, 0x20, 0x85, 0xAB, + 0x92, 0x50, 0xC4, 0x8D, 0xEA, 0x48, 0xA3, 0xFC + }, + { + 0x17, 0x20, 0xB3, 0x65, 0x56, 0x19, 0xD2, 0xA5, + 0x2B, 0x35, 0x21, 0xAE, 0x0E, 0x49, 0xE3, 0x45, + 0xCB, 0x33, 0x89, 0xEB, 0xD6, 0x20, 0x8A, 0xCA, + 0xF9, 0xF1, 0x3F, 0xDA, 0xCC, 0xA8, 0xBE, 0x49 + }, + { + 0x75, 0x62, 0x88, 0x36, 0x1C, 0x83, 0xE2, 0x4C, + 0x61, 0x7C, 0xF9, 0x5C, 0x90, 0x5B, 0x22, 0xD0, + 0x17, 0xCD, 0xC8, 0x6F, 0x0B, 0xF1, 0xD6, 0x58, + 0xF4, 0x75, 0x6C, 0x73, 0x79, 0x87, 0x3B, 0x7F + }, + { + 0xE7, 0xD0, 0xED, 0xA3, 0x45, 0x26, 0x93, 0xB7, + 0x52, 0xAB, 0xCD, 0xA1, 0xB5, 0x5E, 0x27, 0x6F, + 0x82, 0x69, 0x8F, 0x5F, 0x16, 0x05, 0x40, 0x3E, + 0xFF, 0x83, 0x0B, 0xEA, 0x00, 0x71, 0xA3, 0x94 + }, + { + 0x2C, 0x82, 0xEC, 0xAA, 0x6B, 0x84, 0x80, 0x3E, + 0x04, 0x4A, 0xF6, 0x31, 0x18, 0xAF, 0xE5, 0x44, + 0x68, 0x7C, 0xB6, 0xE6, 0xC7, 0xDF, 0x49, 0xED, + 0x76, 0x2D, 0xFD, 0x7C, 0x86, 0x93, 0xA1, 0xBC + }, + { + 0x61, 0x36, 0xCB, 0xF4, 0xB4, 0x41, 0x05, 0x6F, + 0xA1, 0xE2, 0x72, 0x24, 0x98, 0x12, 0x5D, 0x6D, + 0xED, 0x45, 0xE1, 0x7B, 0x52, 0x14, 0x39, 0x59, + 0xC7, 0xF4, 0xD4, 0xE3, 0x95, 0x21, 0x8A, 0xC2 + }, + { + 0x72, 0x1D, 0x32, 0x45, 0xAA, 0xFE, 0xF2, 0x7F, + 0x6A, 0x62, 0x4F, 0x47, 0x95, 0x4B, 0x6C, 0x25, + 0x50, 0x79, 0x52, 0x6F, 0xFA, 0x25, 0xE9, 0xFF, + 0x77, 0xE5, 0xDC, 0xFF, 0x47, 0x3B, 0x15, 0x97 + }, + { + 0x9D, 0xD2, 0xFB, 0xD8, 0xCE, 0xF1, 0x6C, 0x35, + 0x3C, 0x0A, 0xC2, 0x11, 0x91, 0xD5, 0x09, 0xEB, + 0x28, 0xDD, 0x9E, 0x3E, 0x0D, 0x8C, 0xEA, 0x5D, + 0x26, 0xCA, 0x83, 0x93, 0x93, 0x85, 0x1C, 0x3A + }, + { + 0xB2, 0x39, 0x4C, 0xEA, 0xCD, 0xEB, 0xF2, 0x1B, + 0xF9, 0xDF, 0x2C, 0xED, 0x98, 0xE5, 0x8F, 0x1C, + 0x3A, 0x4B, 0xBB, 0xFF, 0x66, 0x0D, 0xD9, 0x00, + 0xF6, 0x22, 0x02, 0xD6, 0x78, 0x5C, 0xC4, 0x6E + }, + { + 0x57, 0x08, 0x9F, 0x22, 0x27, 0x49, 0xAD, 0x78, + 0x71, 0x76, 0x5F, 0x06, 0x2B, 0x11, 0x4F, 0x43, + 0xBA, 0x20, 0xEC, 0x56, 0x42, 0x2A, 0x8B, 0x1E, + 0x3F, 0x87, 0x19, 0x2C, 0x0E, 0xA7, 0x18, 0xC6 + }, + { + 0xE4, 0x9A, 0x94, 0x59, 0x96, 0x1C, 0xD3, 0x3C, + 0xDF, 0x4A, 0xAE, 0x1B, 0x10, 0x78, 0xA5, 0xDE, + 0xA7, 0xC0, 0x40, 0xE0, 0xFE, 0xA3, 0x40, 0xC9, + 0x3A, 0x72, 0x48, 0x72, 0xFC, 0x4A, 0xF8, 0x06 + }, + { + 0xED, 0xE6, 0x7F, 0x72, 0x0E, 0xFF, 0xD2, 0xCA, + 0x9C, 0x88, 0x99, 0x41, 0x52, 0xD0, 0x20, 0x1D, + 0xEE, 0x6B, 0x0A, 0x2D, 0x2C, 0x07, 0x7A, 0xCA, + 0x6D, 0xAE, 0x29, 0xF7, 0x3F, 0x8B, 0x63, 0x09 + }, + { + 0xE0, 0xF4, 0x34, 0xBF, 0x22, 0xE3, 0x08, 0x80, + 0x39, 0xC2, 0x1F, 0x71, 0x9F, 0xFC, 0x67, 0xF0, + 0xF2, 0xCB, 0x5E, 0x98, 0xA7, 0xA0, 0x19, 0x4C, + 0x76, 0xE9, 0x6B, 0xF4, 0xE8, 0xE1, 0x7E, 0x61 + }, + { + 0x27, 0x7C, 0x04, 0xE2, 0x85, 0x34, 0x84, 0xA4, + 0xEB, 0xA9, 0x10, 0xAD, 0x33, 0x6D, 0x01, 0xB4, + 0x77, 0xB6, 0x7C, 0xC2, 0x00, 0xC5, 0x9F, 0x3C, + 0x8D, 0x77, 0xEE, 0xF8, 0x49, 0x4F, 0x29, 0xCD + }, + { + 0x15, 0x6D, 0x57, 0x47, 0xD0, 0xC9, 0x9C, 0x7F, + 0x27, 0x09, 0x7D, 0x7B, 0x7E, 0x00, 0x2B, 0x2E, + 0x18, 0x5C, 0xB7, 0x2D, 0x8D, 0xD7, 0xEB, 0x42, + 0x4A, 0x03, 0x21, 0x52, 0x81, 0x61, 0x21, 0x9F + }, + { + 0x20, 0xDD, 0xD1, 0xED, 0x9B, 0x1C, 0xA8, 0x03, + 0x94, 0x6D, 0x64, 0xA8, 0x3A, 0xE4, 0x65, 0x9D, + 0xA6, 0x7F, 0xBA, 0x7A, 0x1A, 0x3E, 0xDD, 0xB1, + 0xE1, 0x03, 0xC0, 0xF5, 0xE0, 0x3E, 0x3A, 0x2C + }, + { + 0xF0, 0xAF, 0x60, 0x4D, 0x3D, 0xAB, 0xBF, 0x9A, + 0x0F, 0x2A, 0x7D, 0x3D, 0xDA, 0x6B, 0xD3, 0x8B, + 0xBA, 0x72, 0xC6, 0xD0, 0x9B, 0xE4, 0x94, 0xFC, + 0xEF, 0x71, 0x3F, 0xF1, 0x01, 0x89, 0xB6, 0xE6 + }, + { + 0x98, 0x02, 0xBB, 0x87, 0xDE, 0xF4, 0xCC, 0x10, + 0xC4, 0xA5, 0xFD, 0x49, 0xAA, 0x58, 0xDF, 0xE2, + 0xF3, 0xFD, 0xDB, 0x46, 0xB4, 0x70, 0x88, 0x14, + 0xEA, 0xD8, 0x1D, 0x23, 0xBA, 0x95, 0x13, 0x9B + }, + { + 0x4F, 0x8C, 0xE1, 0xE5, 0x1D, 0x2F, 0xE7, 0xF2, + 0x40, 0x43, 0xA9, 0x04, 0xD8, 0x98, 0xEB, 0xFC, + 0x91, 0x97, 0x54, 0x18, 0x75, 0x34, 0x13, 0xAA, + 0x09, 0x9B, 0x79, 0x5E, 0xCB, 0x35, 0xCE, 0xDB + }, + { + 0xBD, 0xDC, 0x65, 0x14, 0xD7, 0xEE, 0x6A, 0xCE, + 0x0A, 0x4A, 0xC1, 0xD0, 0xE0, 0x68, 0x11, 0x22, + 0x88, 0xCB, 0xCF, 0x56, 0x04, 0x54, 0x64, 0x27, + 0x05, 0x63, 0x01, 0x77, 0xCB, 0xA6, 0x08, 0xBD + }, + { + 0xD6, 0x35, 0x99, 0x4F, 0x62, 0x91, 0x51, 0x7B, + 0x02, 0x81, 0xFF, 0xDD, 0x49, 0x6A, 0xFA, 0x86, + 0x27, 0x12, 0xE5, 0xB3, 0xC4, 0xE5, 0x2E, 0x4C, + 0xD5, 0xFD, 0xAE, 0x8C, 0x0E, 0x72, 0xFB, 0x08 + }, + { + 0x87, 0x8D, 0x9C, 0xA6, 0x00, 0xCF, 0x87, 0xE7, + 0x69, 0xCC, 0x30, 0x5C, 0x1B, 0x35, 0x25, 0x51, + 0x86, 0x61, 0x5A, 0x73, 0xA0, 0xDA, 0x61, 0x3B, + 0x5F, 0x1C, 0x98, 0xDB, 0xF8, 0x12, 0x83, 0xEA + }, + { + 0xA6, 0x4E, 0xBE, 0x5D, 0xC1, 0x85, 0xDE, 0x9F, + 0xDD, 0xE7, 0x60, 0x7B, 0x69, 0x98, 0x70, 0x2E, + 0xB2, 0x34, 0x56, 0x18, 0x49, 0x57, 0x30, 0x7D, + 0x2F, 0xA7, 0x2E, 0x87, 0xA4, 0x77, 0x02, 0xD6 + }, + { + 0xCE, 0x50, 0xEA, 0xB7, 0xB5, 0xEB, 0x52, 0xBD, + 0xC9, 0xAD, 0x8E, 0x5A, 0x48, 0x0A, 0xB7, 0x80, + 0xCA, 0x93, 0x20, 0xE4, 0x43, 0x60, 0xB1, 0xFE, + 0x37, 0xE0, 0x3F, 0x2F, 0x7A, 0xD7, 0xDE, 0x01 + }, + { + 0xEE, 0xDD, 0xB7, 0xC0, 0xDB, 0x6E, 0x30, 0xAB, + 0xE6, 0x6D, 0x79, 0xE3, 0x27, 0x51, 0x1E, 0x61, + 0xFC, 0xEB, 0xBC, 0x29, 0xF1, 0x59, 0xB4, 0x0A, + 0x86, 0xB0, 0x46, 0xEC, 0xF0, 0x51, 0x38, 0x23 + }, + { + 0x78, 0x7F, 0xC9, 0x34, 0x40, 0xC1, 0xEC, 0x96, + 0xB5, 0xAD, 0x01, 0xC1, 0x6C, 0xF7, 0x79, 0x16, + 0xA1, 0x40, 0x5F, 0x94, 0x26, 0x35, 0x6E, 0xC9, + 0x21, 0xD8, 0xDF, 0xF3, 0xEA, 0x63, 0xB7, 0xE0 + }, + { + 0x7F, 0x0D, 0x5E, 0xAB, 0x47, 0xEE, 0xFD, 0xA6, + 0x96, 0xC0, 0xBF, 0x0F, 0xBF, 0x86, 0xAB, 0x21, + 0x6F, 0xCE, 0x46, 0x1E, 0x93, 0x03, 0xAB, 0xA6, + 0xAC, 0x37, 0x41, 0x20, 0xE8, 0x90, 0xE8, 0xDF + }, + { + 0xB6, 0x80, 0x04, 0xB4, 0x2F, 0x14, 0xAD, 0x02, + 0x9F, 0x4C, 0x2E, 0x03, 0xB1, 0xD5, 0xEB, 0x76, + 0xD5, 0x71, 0x60, 0xE2, 0x64, 0x76, 0xD2, 0x11, + 0x31, 0xBE, 0xF2, 0x0A, 0xDA, 0x7D, 0x27, 0xF4 + }, + { + 0xB0, 0xC4, 0xEB, 0x18, 0xAE, 0x25, 0x0B, 0x51, + 0xA4, 0x13, 0x82, 0xEA, 0xD9, 0x2D, 0x0D, 0xC7, + 0x45, 0x5F, 0x93, 0x79, 0xFC, 0x98, 0x84, 0x42, + 0x8E, 0x47, 0x70, 0x60, 0x8D, 0xB0, 0xFA, 0xEC + }, + { + 0xF9, 0x2B, 0x7A, 0x87, 0x0C, 0x05, 0x9F, 0x4D, + 0x46, 0x46, 0x4C, 0x82, 0x4E, 0xC9, 0x63, 0x55, + 0x14, 0x0B, 0xDC, 0xE6, 0x81, 0x32, 0x2C, 0xC3, + 0xA9, 0x92, 0xFF, 0x10, 0x3E, 0x3F, 0xEA, 0x52 + }, + { + 0x53, 0x64, 0x31, 0x26, 0x14, 0x81, 0x33, 0x98, + 0xCC, 0x52, 0x5D, 0x4C, 0x4E, 0x14, 0x6E, 0xDE, + 0xB3, 0x71, 0x26, 0x5F, 0xBA, 0x19, 0x13, 0x3A, + 0x2C, 0x3D, 0x21, 0x59, 0x29, 0x8A, 0x17, 0x42 + }, + { + 0xF6, 0x62, 0x0E, 0x68, 0xD3, 0x7F, 0xB2, 0xAF, + 0x50, 0x00, 0xFC, 0x28, 0xE2, 0x3B, 0x83, 0x22, + 0x97, 0xEC, 0xD8, 0xBC, 0xE9, 0x9E, 0x8B, 0xE4, + 0xD0, 0x4E, 0x85, 0x30, 0x9E, 0x3D, 0x33, 0x74 + }, + { + 0x53, 0x16, 0xA2, 0x79, 0x69, 0xD7, 0xFE, 0x04, + 0xFF, 0x27, 0xB2, 0x83, 0x96, 0x1B, 0xFF, 0xC3, + 0xBF, 0x5D, 0xFB, 0x32, 0xFB, 0x6A, 0x89, 0xD1, + 0x01, 0xC6, 0xC3, 0xB1, 0x93, 0x7C, 0x28, 0x71 + }, + { + 0x81, 0xD1, 0x66, 0x4F, 0xDF, 0x3C, 0xB3, 0x3C, + 0x24, 0xEE, 0xBA, 0xC0, 0xBD, 0x64, 0x24, 0x4B, + 0x77, 0xC4, 0xAB, 0xEA, 0x90, 0xBB, 0xE8, 0xB5, + 0xEE, 0x0B, 0x2A, 0xAF, 0xCF, 0x2D, 0x6A, 0x53 + }, + { + 0x34, 0x57, 0x82, 0xF2, 0x95, 0xB0, 0x88, 0x03, + 0x52, 0xE9, 0x24, 0xA0, 0x46, 0x7B, 0x5F, 0xBC, + 0x3E, 0x8F, 0x3B, 0xFB, 0xC3, 0xC7, 0xE4, 0x8B, + 0x67, 0x09, 0x1F, 0xB5, 0xE8, 0x0A, 0x94, 0x42 + }, + { + 0x79, 0x41, 0x11, 0xEA, 0x6C, 0xD6, 0x5E, 0x31, + 0x1F, 0x74, 0xEE, 0x41, 0xD4, 0x76, 0xCB, 0x63, + 0x2C, 0xE1, 0xE4, 0xB0, 0x51, 0xDC, 0x1D, 0x9E, + 0x9D, 0x06, 0x1A, 0x19, 0xE1, 0xD0, 0xBB, 0x49 + }, + { + 0x2A, 0x85, 0xDA, 0xF6, 0x13, 0x88, 0x16, 0xB9, + 0x9B, 0xF8, 0xD0, 0x8B, 0xA2, 0x11, 0x4B, 0x7A, + 0xB0, 0x79, 0x75, 0xA7, 0x84, 0x20, 0xC1, 0xA3, + 0xB0, 0x6A, 0x77, 0x7C, 0x22, 0xDD, 0x8B, 0xCB + }, + { + 0x89, 0xB0, 0xD5, 0xF2, 0x89, 0xEC, 0x16, 0x40, + 0x1A, 0x06, 0x9A, 0x96, 0x0D, 0x0B, 0x09, 0x3E, + 0x62, 0x5D, 0xA3, 0xCF, 0x41, 0xEE, 0x29, 0xB5, + 0x9B, 0x93, 0x0C, 0x58, 0x20, 0x14, 0x54, 0x55 + }, + { + 0xD0, 0xFD, 0xCB, 0x54, 0x39, 0x43, 0xFC, 0x27, + 0xD2, 0x08, 0x64, 0xF5, 0x21, 0x81, 0x47, 0x1B, + 0x94, 0x2C, 0xC7, 0x7C, 0xA6, 0x75, 0xBC, 0xB3, + 0x0D, 0xF3, 0x1D, 0x35, 0x8E, 0xF7, 0xB1, 0xEB + }, + { + 0xB1, 0x7E, 0xA8, 0xD7, 0x70, 0x63, 0xC7, 0x09, + 0xD4, 0xDC, 0x6B, 0x87, 0x94, 0x13, 0xC3, 0x43, + 0xE3, 0x79, 0x0E, 0x9E, 0x62, 0xCA, 0x85, 0xB7, + 0x90, 0x0B, 0x08, 0x6F, 0x6B, 0x75, 0xC6, 0x72 + }, + { + 0xE7, 0x1A, 0x3E, 0x2C, 0x27, 0x4D, 0xB8, 0x42, + 0xD9, 0x21, 0x14, 0xF2, 0x17, 0xE2, 0xC0, 0xEA, + 0xC8, 0xB4, 0x50, 0x93, 0xFD, 0xFD, 0x9D, 0xF4, + 0xCA, 0x71, 0x62, 0x39, 0x48, 0x62, 0xD5, 0x01 + }, + { + 0xC0, 0x47, 0x67, 0x59, 0xAB, 0x7A, 0xA3, 0x33, + 0x23, 0x4F, 0x6B, 0x44, 0xF5, 0xFD, 0x85, 0x83, + 0x90, 0xEC, 0x23, 0x69, 0x4C, 0x62, 0x2C, 0xB9, + 0x86, 0xE7, 0x69, 0xC7, 0x8E, 0xDD, 0x73, 0x3E + }, + { + 0x9A, 0xB8, 0xEA, 0xBB, 0x14, 0x16, 0x43, 0x4D, + 0x85, 0x39, 0x13, 0x41, 0xD5, 0x69, 0x93, 0xC5, + 0x54, 0x58, 0x16, 0x7D, 0x44, 0x18, 0xB1, 0x9A, + 0x0F, 0x2A, 0xD8, 0xB7, 0x9A, 0x83, 0xA7, 0x5B + }, + { + 0x79, 0x92, 0xD0, 0xBB, 0xB1, 0x5E, 0x23, 0x82, + 0x6F, 0x44, 0x3E, 0x00, 0x50, 0x5D, 0x68, 0xD3, + 0xED, 0x73, 0x72, 0x99, 0x5A, 0x5C, 0x3E, 0x49, + 0x86, 0x54, 0x10, 0x2F, 0xBC, 0xD0, 0x96, 0x4E + }, + { + 0xC0, 0x21, 0xB3, 0x00, 0x85, 0x15, 0x14, 0x35, + 0xDF, 0x33, 0xB0, 0x07, 0xCC, 0xEC, 0xC6, 0x9D, + 0xF1, 0x26, 0x9F, 0x39, 0xBA, 0x25, 0x09, 0x2B, + 0xED, 0x59, 0xD9, 0x32, 0xAC, 0x0F, 0xDC, 0x28 + }, + { + 0x91, 0xA2, 0x5E, 0xC0, 0xEC, 0x0D, 0x9A, 0x56, + 0x7F, 0x89, 0xC4, 0xBF, 0xE1, 0xA6, 0x5A, 0x0E, + 0x43, 0x2D, 0x07, 0x06, 0x4B, 0x41, 0x90, 0xE2, + 0x7D, 0xFB, 0x81, 0x90, 0x1F, 0xD3, 0x13, 0x9B + }, + { + 0x59, 0x50, 0xD3, 0x9A, 0x23, 0xE1, 0x54, 0x5F, + 0x30, 0x12, 0x70, 0xAA, 0x1A, 0x12, 0xF2, 0xE6, + 0xC4, 0x53, 0x77, 0x6E, 0x4D, 0x63, 0x55, 0xDE, + 0x42, 0x5C, 0xC1, 0x53, 0xF9, 0x81, 0x88, 0x67 + }, + { + 0xD7, 0x9F, 0x14, 0x72, 0x0C, 0x61, 0x0A, 0xF1, + 0x79, 0xA3, 0x76, 0x5D, 0x4B, 0x7C, 0x09, 0x68, + 0xF9, 0x77, 0x96, 0x2D, 0xBF, 0x65, 0x5B, 0x52, + 0x12, 0x72, 0xB6, 0xF1, 0xE1, 0x94, 0x48, 0x8E + }, + { + 0xE9, 0x53, 0x1B, 0xFC, 0x8B, 0x02, 0x99, 0x5A, + 0xEA, 0xA7, 0x5B, 0xA2, 0x70, 0x31, 0xFA, 0xDB, + 0xCB, 0xF4, 0xA0, 0xDA, 0xB8, 0x96, 0x1D, 0x92, + 0x96, 0xCD, 0x7E, 0x84, 0xD2, 0x5D, 0x60, 0x06 + }, + { + 0x34, 0xE9, 0xC2, 0x6A, 0x01, 0xD7, 0xF1, 0x61, + 0x81, 0xB4, 0x54, 0xA9, 0xD1, 0x62, 0x3C, 0x23, + 0x3C, 0xB9, 0x9D, 0x31, 0xC6, 0x94, 0x65, 0x6E, + 0x94, 0x13, 0xAC, 0xA3, 0xE9, 0x18, 0x69, 0x2F + }, + { + 0xD9, 0xD7, 0x42, 0x2F, 0x43, 0x7B, 0xD4, 0x39, + 0xDD, 0xD4, 0xD8, 0x83, 0xDA, 0xE2, 0xA0, 0x83, + 0x50, 0x17, 0x34, 0x14, 0xBE, 0x78, 0x15, 0x51, + 0x33, 0xFF, 0xF1, 0x96, 0x4C, 0x3D, 0x79, 0x72 + }, + { + 0x4A, 0xEE, 0x0C, 0x7A, 0xAF, 0x07, 0x54, 0x14, + 0xFF, 0x17, 0x93, 0xEA, 0xD7, 0xEA, 0xCA, 0x60, + 0x17, 0x75, 0xC6, 0x15, 0xDB, 0xD6, 0x0B, 0x64, + 0x0B, 0x0A, 0x9F, 0x0C, 0xE5, 0x05, 0xD4, 0x35 + }, + { + 0x6B, 0xFD, 0xD1, 0x54, 0x59, 0xC8, 0x3B, 0x99, + 0xF0, 0x96, 0xBF, 0xB4, 0x9E, 0xE8, 0x7B, 0x06, + 0x3D, 0x69, 0xC1, 0x97, 0x4C, 0x69, 0x28, 0xAC, + 0xFC, 0xFB, 0x40, 0x99, 0xF8, 0xC4, 0xEF, 0x67 + }, + { + 0x9F, 0xD1, 0xC4, 0x08, 0xFD, 0x75, 0xC3, 0x36, + 0x19, 0x3A, 0x2A, 0x14, 0xD9, 0x4F, 0x6A, 0xF5, + 0xAD, 0xF0, 0x50, 0xB8, 0x03, 0x87, 0xB4, 0xB0, + 0x10, 0xFB, 0x29, 0xF4, 0xCC, 0x72, 0x70, 0x7C + }, + { + 0x13, 0xC8, 0x84, 0x80, 0xA5, 0xD0, 0x0D, 0x6C, + 0x8C, 0x7A, 0xD2, 0x11, 0x0D, 0x76, 0xA8, 0x2D, + 0x9B, 0x70, 0xF4, 0xFA, 0x66, 0x96, 0xD4, 0xE5, + 0xDD, 0x42, 0xA0, 0x66, 0xDC, 0xAF, 0x99, 0x20 + }, + { + 0x82, 0x0E, 0x72, 0x5E, 0xE2, 0x5F, 0xE8, 0xFD, + 0x3A, 0x8D, 0x5A, 0xBE, 0x4C, 0x46, 0xC3, 0xBA, + 0x88, 0x9D, 0xE6, 0xFA, 0x91, 0x91, 0xAA, 0x22, + 0xBA, 0x67, 0xD5, 0x70, 0x54, 0x21, 0x54, 0x2B + }, + { + 0x32, 0xD9, 0x3A, 0x0E, 0xB0, 0x2F, 0x42, 0xFB, + 0xBC, 0xAF, 0x2B, 0xAD, 0x00, 0x85, 0xB2, 0x82, + 0xE4, 0x60, 0x46, 0xA4, 0xDF, 0x7A, 0xD1, 0x06, + 0x57, 0xC9, 0xD6, 0x47, 0x63, 0x75, 0xB9, 0x3E + }, + { + 0xAD, 0xC5, 0x18, 0x79, 0x05, 0xB1, 0x66, 0x9C, + 0xD8, 0xEC, 0x9C, 0x72, 0x1E, 0x19, 0x53, 0x78, + 0x6B, 0x9D, 0x89, 0xA9, 0xBA, 0xE3, 0x07, 0x80, + 0xF1, 0xE1, 0xEA, 0xB2, 0x4A, 0x00, 0x52, 0x3C + }, + { + 0xE9, 0x07, 0x56, 0xFF, 0x7F, 0x9A, 0xD8, 0x10, + 0xB2, 0x39, 0xA1, 0x0C, 0xED, 0x2C, 0xF9, 0xB2, + 0x28, 0x43, 0x54, 0xC1, 0xF8, 0xC7, 0xE0, 0xAC, + 0xCC, 0x24, 0x61, 0xDC, 0x79, 0x6D, 0x6E, 0x89 + }, + { + 0x12, 0x51, 0xF7, 0x6E, 0x56, 0x97, 0x84, 0x81, + 0x87, 0x53, 0x59, 0x80, 0x1D, 0xB5, 0x89, 0xA0, + 0xB2, 0x2F, 0x86, 0xD8, 0xD6, 0x34, 0xDC, 0x04, + 0x50, 0x6F, 0x32, 0x2E, 0xD7, 0x8F, 0x17, 0xE8 + }, + { + 0x3A, 0xFA, 0x89, 0x9F, 0xD9, 0x80, 0xE7, 0x3E, + 0xCB, 0x7F, 0x4D, 0x8B, 0x8F, 0x29, 0x1D, 0xC9, + 0xAF, 0x79, 0x6B, 0xC6, 0x5D, 0x27, 0xF9, 0x74, + 0xC6, 0xF1, 0x93, 0xC9, 0x19, 0x1A, 0x09, 0xFD + }, + { + 0xAA, 0x30, 0x5B, 0xE2, 0x6E, 0x5D, 0xED, 0xDC, + 0x3C, 0x10, 0x10, 0xCB, 0xC2, 0x13, 0xF9, 0x5F, + 0x05, 0x1C, 0x78, 0x5C, 0x5B, 0x43, 0x1E, 0x6A, + 0x7C, 0xD0, 0x48, 0xF1, 0x61, 0x78, 0x75, 0x28 + }, + { + 0x8E, 0xA1, 0x88, 0x4F, 0xF3, 0x2E, 0x9D, 0x10, + 0xF0, 0x39, 0xB4, 0x07, 0xD0, 0xD4, 0x4E, 0x7E, + 0x67, 0x0A, 0xBD, 0x88, 0x4A, 0xEE, 0xE0, 0xFB, + 0x75, 0x7A, 0xE9, 0x4E, 0xAA, 0x97, 0x37, 0x3D + }, + { + 0xD4, 0x82, 0xB2, 0x15, 0x5D, 0x4D, 0xEC, 0x6B, + 0x47, 0x36, 0xA1, 0xF1, 0x61, 0x7B, 0x53, 0xAA, + 0xA3, 0x73, 0x10, 0x27, 0x7D, 0x3F, 0xEF, 0x0C, + 0x37, 0xAD, 0x41, 0x76, 0x8F, 0xC2, 0x35, 0xB4 + }, + { + 0x4D, 0x41, 0x39, 0x71, 0x38, 0x7E, 0x7A, 0x88, + 0x98, 0xA8, 0xDC, 0x2A, 0x27, 0x50, 0x07, 0x78, + 0x53, 0x9E, 0xA2, 0x14, 0xA2, 0xDF, 0xE9, 0xB3, + 0xD7, 0xE8, 0xEB, 0xDC, 0xE5, 0xCF, 0x3D, 0xB3 + }, + { + 0x69, 0x6E, 0x5D, 0x46, 0xE6, 0xC5, 0x7E, 0x87, + 0x96, 0xE4, 0x73, 0x5D, 0x08, 0x91, 0x6E, 0x0B, + 0x79, 0x29, 0xB3, 0xCF, 0x29, 0x8C, 0x29, 0x6D, + 0x22, 0xE9, 0xD3, 0x01, 0x96, 0x53, 0x37, 0x1C + }, + { + 0x1F, 0x56, 0x47, 0xC1, 0xD3, 0xB0, 0x88, 0x22, + 0x88, 0x85, 0x86, 0x5C, 0x89, 0x40, 0x90, 0x8B, + 0xF4, 0x0D, 0x1A, 0x82, 0x72, 0x82, 0x19, 0x73, + 0xB1, 0x60, 0x00, 0x8E, 0x7A, 0x3C, 0xE2, 0xEB + }, + { + 0xB6, 0xE7, 0x6C, 0x33, 0x0F, 0x02, 0x1A, 0x5B, + 0xDA, 0x65, 0x87, 0x50, 0x10, 0xB0, 0xED, 0xF0, + 0x91, 0x26, 0xC0, 0xF5, 0x10, 0xEA, 0x84, 0x90, + 0x48, 0x19, 0x20, 0x03, 0xAE, 0xF4, 0xC6, 0x1C + }, + { + 0x3C, 0xD9, 0x52, 0xA0, 0xBE, 0xAD, 0xA4, 0x1A, + 0xBB, 0x42, 0x4C, 0xE4, 0x7F, 0x94, 0xB4, 0x2B, + 0xE6, 0x4E, 0x1F, 0xFB, 0x0F, 0xD0, 0x78, 0x22, + 0x76, 0x80, 0x79, 0x46, 0xD0, 0xD0, 0xBC, 0x55 + }, + { + 0x98, 0xD9, 0x26, 0x77, 0x43, 0x9B, 0x41, 0xB7, + 0xBB, 0x51, 0x33, 0x12, 0xAF, 0xB9, 0x2B, 0xCC, + 0x8E, 0xE9, 0x68, 0xB2, 0xE3, 0xB2, 0x38, 0xCE, + 0xCB, 0x9B, 0x0F, 0x34, 0xC9, 0xBB, 0x63, 0xD0 + }, + { + 0xEC, 0xBC, 0xA2, 0xCF, 0x08, 0xAE, 0x57, 0xD5, + 0x17, 0xAD, 0x16, 0x15, 0x8A, 0x32, 0xBF, 0xA7, + 0xDC, 0x03, 0x82, 0xEA, 0xED, 0xA1, 0x28, 0xE9, + 0x18, 0x86, 0x73, 0x4C, 0x24, 0xA0, 0xB2, 0x9D + }, + { + 0x94, 0x2C, 0xC7, 0xC0, 0xB5, 0x2E, 0x2B, 0x16, + 0xA4, 0xB8, 0x9F, 0xA4, 0xFC, 0x7E, 0x0B, 0xF6, + 0x09, 0xE2, 0x9A, 0x08, 0xC1, 0xA8, 0x54, 0x34, + 0x52, 0xB7, 0x7C, 0x7B, 0xFD, 0x11, 0xBB, 0x28 + }, + { + 0x8A, 0x06, 0x5D, 0x8B, 0x61, 0xA0, 0xDF, 0xFB, + 0x17, 0x0D, 0x56, 0x27, 0x73, 0x5A, 0x76, 0xB0, + 0xE9, 0x50, 0x60, 0x37, 0x80, 0x8C, 0xBA, 0x16, + 0xC3, 0x45, 0x00, 0x7C, 0x9F, 0x79, 0xCF, 0x8F + }, + { + 0x1B, 0x9F, 0xA1, 0x97, 0x14, 0x65, 0x9C, 0x78, + 0xFF, 0x41, 0x38, 0x71, 0x84, 0x92, 0x15, 0x36, + 0x10, 0x29, 0xAC, 0x80, 0x2B, 0x1C, 0xBC, 0xD5, + 0x4E, 0x40, 0x8B, 0xD8, 0x72, 0x87, 0xF8, 0x1F + }, + { + 0x8D, 0xAB, 0x07, 0x1B, 0xCD, 0x6C, 0x72, 0x92, + 0xA9, 0xEF, 0x72, 0x7B, 0x4A, 0xE0, 0xD8, 0x67, + 0x13, 0x30, 0x1D, 0xA8, 0x61, 0x8D, 0x9A, 0x48, + 0xAD, 0xCE, 0x55, 0xF3, 0x03, 0xA8, 0x69, 0xA1 + }, + { + 0x82, 0x53, 0xE3, 0xE7, 0xC7, 0xB6, 0x84, 0xB9, + 0xCB, 0x2B, 0xEB, 0x01, 0x4C, 0xE3, 0x30, 0xFF, + 0x3D, 0x99, 0xD1, 0x7A, 0xBB, 0xDB, 0xAB, 0xE4, + 0xF4, 0xD6, 0x74, 0xDE, 0xD5, 0x3F, 0xFC, 0x6B + }, + { + 0xF1, 0x95, 0xF3, 0x21, 0xE9, 0xE3, 0xD6, 0xBD, + 0x7D, 0x07, 0x45, 0x04, 0xDD, 0x2A, 0xB0, 0xE6, + 0x24, 0x1F, 0x92, 0xE7, 0x84, 0xB1, 0xAA, 0x27, + 0x1F, 0xF6, 0x48, 0xB1, 0xCA, 0xB6, 0xD7, 0xF6 + }, + { + 0x27, 0xE4, 0xCC, 0x72, 0x09, 0x0F, 0x24, 0x12, + 0x66, 0x47, 0x6A, 0x7C, 0x09, 0x49, 0x5F, 0x2D, + 0xB1, 0x53, 0xD5, 0xBC, 0xBD, 0x76, 0x19, 0x03, + 0xEF, 0x79, 0x27, 0x5E, 0xC5, 0x6B, 0x2E, 0xD8 + }, + { + 0x89, 0x9C, 0x24, 0x05, 0x78, 0x8E, 0x25, 0xB9, + 0x9A, 0x18, 0x46, 0x35, 0x5E, 0x64, 0x6D, 0x77, + 0xCF, 0x40, 0x00, 0x83, 0x41, 0x5F, 0x7D, 0xC5, + 0xAF, 0xE6, 0x9D, 0x6E, 0x17, 0xC0, 0x00, 0x23 + }, + { + 0xA5, 0x9B, 0x78, 0xC4, 0x90, 0x57, 0x44, 0x07, + 0x6B, 0xFE, 0xE8, 0x94, 0xDE, 0x70, 0x7D, 0x4F, + 0x12, 0x0B, 0x5C, 0x68, 0x93, 0xEA, 0x04, 0x00, + 0x29, 0x7D, 0x0B, 0xB8, 0x34, 0x72, 0x76, 0x32 + }, + { + 0x59, 0xDC, 0x78, 0xB1, 0x05, 0x64, 0x97, 0x07, + 0xA2, 0xBB, 0x44, 0x19, 0xC4, 0x8F, 0x00, 0x54, + 0x00, 0xD3, 0x97, 0x3D, 0xE3, 0x73, 0x66, 0x10, + 0x23, 0x04, 0x35, 0xB1, 0x04, 0x24, 0xB2, 0x4F + }, + { + 0xC0, 0x14, 0x9D, 0x1D, 0x7E, 0x7A, 0x63, 0x53, + 0xA6, 0xD9, 0x06, 0xEF, 0xE7, 0x28, 0xF2, 0xF3, + 0x29, 0xFE, 0x14, 0xA4, 0x14, 0x9A, 0x3E, 0xA7, + 0x76, 0x09, 0xBC, 0x42, 0xB9, 0x75, 0xDD, 0xFA + }, + { + 0xA3, 0x2F, 0x24, 0x14, 0x74, 0xA6, 0xC1, 0x69, + 0x32, 0xE9, 0x24, 0x3B, 0xE0, 0xCF, 0x09, 0xBC, + 0xDC, 0x7E, 0x0C, 0xA0, 0xE7, 0xA6, 0xA1, 0xB9, + 0xB1, 0xA0, 0xF0, 0x1E, 0x41, 0x50, 0x23, 0x77 + }, + { + 0xB2, 0x39, 0xB2, 0xE4, 0xF8, 0x18, 0x41, 0x36, + 0x1C, 0x13, 0x39, 0xF6, 0x8E, 0x2C, 0x35, 0x9F, + 0x92, 0x9A, 0xF9, 0xAD, 0x9F, 0x34, 0xE0, 0x1A, + 0xAB, 0x46, 0x31, 0xAD, 0x6D, 0x55, 0x00, 0xB0 + }, + { + 0x85, 0xFB, 0x41, 0x9C, 0x70, 0x02, 0xA3, 0xE0, + 0xB4, 0xB6, 0xEA, 0x09, 0x3B, 0x4C, 0x1A, 0xC6, + 0x93, 0x66, 0x45, 0xB6, 0x5D, 0xAC, 0x5A, 0xC1, + 0x5A, 0x85, 0x28, 0xB7, 0xB9, 0x4C, 0x17, 0x54 + }, + { + 0x96, 0x19, 0x72, 0x06, 0x25, 0xF1, 0x90, 0xB9, + 0x3A, 0x3F, 0xAD, 0x18, 0x6A, 0xB3, 0x14, 0x18, + 0x96, 0x33, 0xC0, 0xD3, 0xA0, 0x1E, 0x6F, 0x9B, + 0xC8, 0xC4, 0xA8, 0xF8, 0x2F, 0x38, 0x3D, 0xBF + }, + { + 0x7D, 0x62, 0x0D, 0x90, 0xFE, 0x69, 0xFA, 0x46, + 0x9A, 0x65, 0x38, 0x38, 0x89, 0x70, 0xA1, 0xAA, + 0x09, 0xBB, 0x48, 0xA2, 0xD5, 0x9B, 0x34, 0x7B, + 0x97, 0xE8, 0xCE, 0x71, 0xF4, 0x8C, 0x7F, 0x46 + }, + { + 0x29, 0x43, 0x83, 0x56, 0x85, 0x96, 0xFB, 0x37, + 0xC7, 0x5B, 0xBA, 0xCD, 0x97, 0x9C, 0x5F, 0xF6, + 0xF2, 0x0A, 0x55, 0x6B, 0xF8, 0x87, 0x9C, 0xC7, + 0x29, 0x24, 0x85, 0x5D, 0xF9, 0xB8, 0x24, 0x0E + }, + { + 0x16, 0xB1, 0x8A, 0xB3, 0x14, 0x35, 0x9C, 0x2B, + 0x83, 0x3C, 0x1C, 0x69, 0x86, 0xD4, 0x8C, 0x55, + 0xA9, 0xFC, 0x97, 0xCD, 0xE9, 0xA3, 0xC1, 0xF1, + 0x0A, 0x31, 0x77, 0x14, 0x0F, 0x73, 0xF7, 0x38 + }, + { + 0x8C, 0xBB, 0xDD, 0x14, 0xBC, 0x33, 0xF0, 0x4C, + 0xF4, 0x58, 0x13, 0xE4, 0xA1, 0x53, 0xA2, 0x73, + 0xD3, 0x6A, 0xDA, 0xD5, 0xCE, 0x71, 0xF4, 0x99, + 0xEE, 0xB8, 0x7F, 0xB8, 0xAC, 0x63, 0xB7, 0x29 + }, + { + 0x69, 0xC9, 0xA4, 0x98, 0xDB, 0x17, 0x4E, 0xCA, + 0xEF, 0xCC, 0x5A, 0x3A, 0xC9, 0xFD, 0xED, 0xF0, + 0xF8, 0x13, 0xA5, 0xBE, 0xC7, 0x27, 0xF1, 0xE7, + 0x75, 0xBA, 0xBD, 0xEC, 0x77, 0x18, 0x81, 0x6E + }, + { + 0xB4, 0x62, 0xC3, 0xBE, 0x40, 0x44, 0x8F, 0x1D, + 0x4F, 0x80, 0x62, 0x62, 0x54, 0xE5, 0x35, 0xB0, + 0x8B, 0xC9, 0xCD, 0xCF, 0xF5, 0x99, 0xA7, 0x68, + 0x57, 0x8D, 0x4B, 0x28, 0x81, 0xA8, 0xE3, 0xF0 + }, + { + 0x55, 0x3E, 0x9D, 0x9C, 0x5F, 0x36, 0x0A, 0xC0, + 0xB7, 0x4A, 0x7D, 0x44, 0xE5, 0xA3, 0x91, 0xDA, + 0xD4, 0xCE, 0xD0, 0x3E, 0x0C, 0x24, 0x18, 0x3B, + 0x7E, 0x8E, 0xCA, 0xBD, 0xF1, 0x71, 0x5A, 0x64 + }, + { + 0x7A, 0x7C, 0x55, 0xA5, 0x6F, 0xA9, 0xAE, 0x51, + 0xE6, 0x55, 0xE0, 0x19, 0x75, 0xD8, 0xA6, 0xFF, + 0x4A, 0xE9, 0xE4, 0xB4, 0x86, 0xFC, 0xBE, 0x4E, + 0xAC, 0x04, 0x45, 0x88, 0xF2, 0x45, 0xEB, 0xEA + }, + { + 0x2A, 0xFD, 0xF3, 0xC8, 0x2A, 0xBC, 0x48, 0x67, + 0xF5, 0xDE, 0x11, 0x12, 0x86, 0xC2, 0xB3, 0xBE, + 0x7D, 0x6E, 0x48, 0x65, 0x7B, 0xA9, 0x23, 0xCF, + 0xBF, 0x10, 0x1A, 0x6D, 0xFC, 0xF9, 0xDB, 0x9A + }, + { + 0x41, 0x03, 0x7D, 0x2E, 0xDC, 0xDC, 0xE0, 0xC4, + 0x9B, 0x7F, 0xB4, 0xA6, 0xAA, 0x09, 0x99, 0xCA, + 0x66, 0x97, 0x6C, 0x74, 0x83, 0xAF, 0xE6, 0x31, + 0xD4, 0xED, 0xA2, 0x83, 0x14, 0x4F, 0x6D, 0xFC + }, + { + 0xC4, 0x46, 0x6F, 0x84, 0x97, 0xCA, 0x2E, 0xEB, + 0x45, 0x83, 0xA0, 0xB0, 0x8E, 0x9D, 0x9A, 0xC7, + 0x43, 0x95, 0x70, 0x9F, 0xDA, 0x10, 0x9D, 0x24, + 0xF2, 0xE4, 0x46, 0x21, 0x96, 0x77, 0x9C, 0x5D + }, + { + 0x75, 0xF6, 0x09, 0x33, 0x8A, 0xA6, 0x7D, 0x96, + 0x9A, 0x2A, 0xE2, 0xA2, 0x36, 0x2B, 0x2D, 0xA9, + 0xD7, 0x7C, 0x69, 0x5D, 0xFD, 0x1D, 0xF7, 0x22, + 0x4A, 0x69, 0x01, 0xDB, 0x93, 0x2C, 0x33, 0x64 + }, + { + 0x68, 0x60, 0x6C, 0xEB, 0x98, 0x9D, 0x54, 0x88, + 0xFC, 0x7C, 0xF6, 0x49, 0xF3, 0xD7, 0xC2, 0x72, + 0xEF, 0x05, 0x5D, 0xA1, 0xA9, 0x3F, 0xAE, 0xCD, + 0x55, 0xFE, 0x06, 0xF6, 0x96, 0x70, 0x98, 0xCA + }, + { + 0x44, 0x34, 0x6B, 0xDE, 0xB7, 0xE0, 0x52, 0xF6, + 0x25, 0x50, 0x48, 0xF0, 0xD9, 0xB4, 0x2C, 0x42, + 0x5B, 0xAB, 0x9C, 0x3D, 0xD2, 0x41, 0x68, 0x21, + 0x2C, 0x3E, 0xCF, 0x1E, 0xBF, 0x34, 0xE6, 0xAE + }, + { + 0x8E, 0x9C, 0xF6, 0xE1, 0xF3, 0x66, 0x47, 0x1F, + 0x2A, 0xC7, 0xD2, 0xEE, 0x9B, 0x5E, 0x62, 0x66, + 0xFD, 0xA7, 0x1F, 0x8F, 0x2E, 0x41, 0x09, 0xF2, + 0x23, 0x7E, 0xD5, 0xF8, 0x81, 0x3F, 0xC7, 0x18 + }, + { + 0x84, 0xBB, 0xEB, 0x84, 0x06, 0xD2, 0x50, 0x95, + 0x1F, 0x8C, 0x1B, 0x3E, 0x86, 0xA7, 0xC0, 0x10, + 0x08, 0x29, 0x21, 0x83, 0x3D, 0xFD, 0x95, 0x55, + 0xA2, 0xF9, 0x09, 0xB1, 0x08, 0x6E, 0xB4, 0xB8 + }, + { + 0xEE, 0x66, 0x6F, 0x3E, 0xEF, 0x0F, 0x7E, 0x2A, + 0x9C, 0x22, 0x29, 0x58, 0xC9, 0x7E, 0xAF, 0x35, + 0xF5, 0x1C, 0xED, 0x39, 0x3D, 0x71, 0x44, 0x85, + 0xAB, 0x09, 0xA0, 0x69, 0x34, 0x0F, 0xDF, 0x88 + }, + { + 0xC1, 0x53, 0xD3, 0x4A, 0x65, 0xC4, 0x7B, 0x4A, + 0x62, 0xC5, 0xCA, 0xCF, 0x24, 0x01, 0x09, 0x75, + 0xD0, 0x35, 0x6B, 0x2F, 0x32, 0xC8, 0xF5, 0xDA, + 0x53, 0x0D, 0x33, 0x88, 0x16, 0xAD, 0x5D, 0xE6 + }, + { + 0x9F, 0xC5, 0x45, 0x01, 0x09, 0xE1, 0xB7, 0x79, + 0xF6, 0xC7, 0xAE, 0x79, 0xD5, 0x6C, 0x27, 0x63, + 0x5C, 0x8D, 0xD4, 0x26, 0xC5, 0xA9, 0xD5, 0x4E, + 0x25, 0x78, 0xDB, 0x98, 0x9B, 0x8C, 0x3B, 0x4E + }, + { + 0xD1, 0x2B, 0xF3, 0x73, 0x2E, 0xF4, 0xAF, 0x5C, + 0x22, 0xFA, 0x90, 0x35, 0x6A, 0xF8, 0xFC, 0x50, + 0xFC, 0xB4, 0x0F, 0x8F, 0x2E, 0xA5, 0xC8, 0x59, + 0x47, 0x37, 0xA3, 0xB3, 0xD5, 0xAB, 0xDB, 0xD7 + }, + { + 0x11, 0x03, 0x0B, 0x92, 0x89, 0xBB, 0xA5, 0xAF, + 0x65, 0x26, 0x06, 0x72, 0xAB, 0x6F, 0xEE, 0x88, + 0xB8, 0x74, 0x20, 0xAC, 0xEF, 0x4A, 0x17, 0x89, + 0xA2, 0x07, 0x3B, 0x7E, 0xC2, 0xF2, 0xA0, 0x9E + }, + { + 0x69, 0xCB, 0x19, 0x2B, 0x84, 0x44, 0x00, 0x5C, + 0x8C, 0x0C, 0xEB, 0x12, 0xC8, 0x46, 0x86, 0x07, + 0x68, 0x18, 0x8C, 0xDA, 0x0A, 0xEC, 0x27, 0xA9, + 0xC8, 0xA5, 0x5C, 0xDE, 0xE2, 0x12, 0x36, 0x32 + }, + { + 0xDB, 0x44, 0x4C, 0x15, 0x59, 0x7B, 0x5F, 0x1A, + 0x03, 0xD1, 0xF9, 0xED, 0xD1, 0x6E, 0x4A, 0x9F, + 0x43, 0xA6, 0x67, 0xCC, 0x27, 0x51, 0x75, 0xDF, + 0xA2, 0xB7, 0x04, 0xE3, 0xBB, 0x1A, 0x9B, 0x83 + }, + { + 0x3F, 0xB7, 0x35, 0x06, 0x1A, 0xBC, 0x51, 0x9D, + 0xFE, 0x97, 0x9E, 0x54, 0xC1, 0xEE, 0x5B, 0xFA, + 0xD0, 0xA9, 0xD8, 0x58, 0xB3, 0x31, 0x5B, 0xAD, + 0x34, 0xBD, 0xE9, 0x99, 0xEF, 0xD7, 0x24, 0xDD + }, + { + 0x52, 0x11, 0xD1, 0xAE, 0xFC, 0x00, 0x25, 0xBE, + 0x7F, 0x85, 0xC0, 0x6B, 0x3E, 0x14, 0xE0, 0xFC, + 0x64, 0x5A, 0xE1, 0x2B, 0xD4, 0x17, 0x46, 0x48, + 0x5E, 0xA6, 0xD8, 0xA3, 0x64, 0xA2, 0xEA, 0xEE + }, + { + 0x05, 0xD9, 0xA0, 0xBE, 0x63, 0x9D, 0x01, 0x21, + 0x80, 0x01, 0x8B, 0xBD, 0x1F, 0x27, 0xB8, 0x17, + 0xDA, 0x6E, 0xDF, 0xD9, 0x36, 0x49, 0x74, 0x8B, + 0xB6, 0x88, 0xF2, 0x22, 0x82, 0x90, 0xF0, 0xDE + }, + { + 0xF5, 0xEF, 0xD5, 0x02, 0xD4, 0x5B, 0xB1, 0x76, + 0x19, 0x24, 0x4B, 0x11, 0xA2, 0x92, 0xEE, 0xAB, + 0x97, 0x46, 0x7B, 0xEB, 0x5B, 0xC5, 0x08, 0x3D, + 0x6B, 0x0E, 0xE5, 0x3B, 0xC7, 0xD8, 0x62, 0xB7 + }, + { + 0x71, 0xBB, 0xB1, 0xF2, 0xAB, 0xFA, 0x7C, 0xA7, + 0x55, 0xC6, 0x2D, 0xB6, 0x9A, 0x2A, 0x1D, 0x01, + 0xBF, 0x79, 0xFC, 0x54, 0xEA, 0xD8, 0x16, 0x2B, + 0x24, 0x87, 0x72, 0xB7, 0x40, 0xD1, 0xBB, 0x4C + }, + { + 0x54, 0xD5, 0x20, 0x22, 0x06, 0xB2, 0xEA, 0xBB, + 0xFD, 0xC7, 0x8E, 0xF5, 0x90, 0x38, 0x88, 0x93, + 0x36, 0x08, 0x6D, 0x25, 0x31, 0x70, 0x96, 0xEA, + 0xAF, 0xAC, 0x86, 0xB8, 0xD6, 0x63, 0x14, 0x74 + }, + { + 0x49, 0xD0, 0xC2, 0x3A, 0xAA, 0xD0, 0xB9, 0x89, + 0x86, 0x9D, 0xF2, 0xF9, 0x99, 0xD4, 0xED, 0x71, + 0xD3, 0x5F, 0xD0, 0x64, 0x09, 0xB3, 0xA4, 0x6F, + 0x79, 0xD1, 0x73, 0x2A, 0x07, 0x2E, 0xB1, 0xFB + }, + { + 0x95, 0xDF, 0x2C, 0x18, 0x36, 0x44, 0xC8, 0x82, + 0x5F, 0x92, 0x38, 0xDA, 0x20, 0xDA, 0xC6, 0x68, + 0x26, 0x95, 0xDA, 0x18, 0xA2, 0xBB, 0x54, 0x13, + 0x79, 0x78, 0x52, 0xE2, 0x20, 0x3D, 0x84, 0x7B + }, + { + 0x9F, 0xEE, 0x45, 0x81, 0x16, 0xA1, 0x95, 0x07, + 0x06, 0xD6, 0xE2, 0xA5, 0xA3, 0xA8, 0x09, 0x5D, + 0x79, 0x82, 0xCC, 0x45, 0x39, 0xA5, 0xBB, 0x33, + 0x9F, 0x10, 0xC3, 0xC8, 0x57, 0x9A, 0xA7, 0x50 + }, + { + 0x5A, 0xA4, 0xC6, 0x26, 0x4F, 0x6A, 0x5C, 0xAE, + 0x2D, 0x03, 0xEA, 0xC0, 0x70, 0xB7, 0x68, 0x46, + 0x2F, 0x31, 0x31, 0x29, 0x50, 0xE7, 0x19, 0x4C, + 0x04, 0x91, 0xA7, 0x64, 0x97, 0x55, 0x2D, 0xA9 + }, + { + 0xA2, 0xA1, 0x5C, 0x4F, 0x15, 0x0F, 0x82, 0xE6, + 0x77, 0xA0, 0xFC, 0x87, 0x23, 0xB2, 0xA9, 0x82, + 0xE1, 0xA6, 0x4E, 0xA8, 0x1B, 0xF8, 0x3D, 0xB0, + 0x5A, 0x12, 0xF9, 0x71, 0xD5, 0x1C, 0xCF, 0x4F + }, + { + 0x7B, 0x3B, 0xC5, 0x9E, 0xDF, 0xA1, 0x96, 0x0E, + 0xAC, 0xCE, 0xF9, 0xE3, 0x15, 0x68, 0x38, 0x04, + 0xAF, 0x03, 0x03, 0x97, 0xDE, 0x5F, 0xBB, 0xBF, + 0x1E, 0x54, 0x0A, 0xF5, 0x40, 0xA7, 0x3E, 0x04 + }, + { + 0x11, 0xB8, 0x2A, 0xE1, 0x9D, 0x8A, 0xAE, 0x35, + 0x61, 0x4B, 0x77, 0x72, 0xE4, 0x51, 0xEB, 0x71, + 0x9D, 0xBC, 0xBA, 0x15, 0x81, 0xA3, 0x8D, 0xA6, + 0x88, 0x9E, 0x72, 0xC1, 0xB4, 0x68, 0xEF, 0xAB + }, + { + 0x81, 0xC4, 0x2C, 0x1A, 0xF3, 0x5E, 0xA9, 0x0D, + 0x69, 0x9D, 0x5E, 0x06, 0xE5, 0xC2, 0x9C, 0x68, + 0x7D, 0x18, 0x29, 0x8E, 0x37, 0xDB, 0xC3, 0x9F, + 0x76, 0x8C, 0xF7, 0xB2, 0xD5, 0xE5, 0x45, 0x34 + }, + { + 0x8F, 0xB9, 0x10, 0x9F, 0xAE, 0x70, 0x63, 0x6D, + 0x99, 0x5F, 0xB7, 0x43, 0x9F, 0xCE, 0xA7, 0x27, + 0x19, 0x8E, 0x1D, 0xC8, 0x2E, 0x2C, 0xF0, 0x72, + 0xAB, 0x26, 0xEA, 0xAD, 0xC1, 0xC0, 0x1F, 0xD3 + }, + { + 0xF1, 0xF2, 0xAA, 0x13, 0x90, 0x61, 0x67, 0xB5, + 0xAB, 0xEC, 0x7E, 0xD1, 0xA4, 0x49, 0x19, 0x7F, + 0xC5, 0xC4, 0xEB, 0x70, 0xE6, 0xBE, 0x66, 0xA9, + 0x47, 0x6F, 0x3F, 0xD0, 0x08, 0x69, 0x19, 0xDE + }, + { + 0xB6, 0xD7, 0xA9, 0xCE, 0x8B, 0x35, 0x8D, 0x46, + 0x71, 0x7B, 0xD0, 0xA3, 0x87, 0x29, 0x3D, 0xEE, + 0x29, 0xE8, 0xD3, 0x4C, 0xB7, 0x32, 0x78, 0x5D, + 0x15, 0xE8, 0x5A, 0x5E, 0xC9, 0x5A, 0xED, 0x42 + }, + { + 0x81, 0x46, 0xE4, 0xDF, 0x2E, 0x87, 0x9C, 0x12, + 0x90, 0x03, 0xC9, 0x3D, 0x1D, 0x03, 0xF9, 0x98, + 0xCE, 0x1F, 0xD7, 0x79, 0xF1, 0xC2, 0x54, 0x93, + 0xA1, 0x04, 0xAF, 0x3A, 0x60, 0x1C, 0x12, 0x70 + }, + { + 0x0A, 0x2F, 0x64, 0x8B, 0x2D, 0x82, 0x79, 0xAB, + 0xB0, 0xA5, 0x29, 0x13, 0xF5, 0x80, 0x11, 0x9D, + 0x01, 0x9B, 0x25, 0x29, 0x19, 0xC7, 0xAE, 0x4D, + 0xA9, 0xD1, 0xA4, 0x72, 0xF5, 0xDD, 0x36, 0xDA + }, + { + 0xE8, 0x3F, 0x9C, 0x02, 0x0B, 0x2A, 0x30, 0x18, + 0xE2, 0x5B, 0x23, 0xC6, 0x3B, 0x6F, 0x15, 0xB5, + 0xB1, 0xFC, 0x2D, 0xE3, 0x7C, 0x99, 0xBE, 0x7F, + 0x12, 0xA5, 0x9A, 0x57, 0xCA, 0xDF, 0xF1, 0x4F + }, + { + 0xD0, 0xC8, 0xD8, 0x6B, 0xD9, 0x5A, 0xA9, 0xA2, + 0x40, 0x35, 0xFC, 0xA5, 0x39, 0xDA, 0x1E, 0xE6, + 0xB9, 0x41, 0x60, 0xD6, 0xE8, 0xFF, 0x41, 0x36, + 0xFB, 0x65, 0x79, 0xE1, 0x06, 0x90, 0xD4, 0x4E + }, + { + 0x4E, 0x41, 0xA6, 0x09, 0xA2, 0xCD, 0x39, 0xA0, + 0x57, 0x1A, 0x2E, 0x9C, 0x76, 0x2C, 0x49, 0xB4, + 0x15, 0xAB, 0x27, 0xE3, 0x6B, 0x23, 0xF0, 0x17, + 0x89, 0xB3, 0xC7, 0x4B, 0x08, 0x81, 0xBC, 0xA8 + }, + { + 0x28, 0xEC, 0xEF, 0x04, 0x4E, 0x74, 0x43, 0x42, + 0x3F, 0x4F, 0xD1, 0x34, 0x07, 0x7C, 0xB8, 0xC4, + 0x53, 0x4F, 0xEC, 0x59, 0xEC, 0x14, 0xFA, 0x96, + 0xEE, 0xA7, 0xF2, 0xD0, 0x1C, 0xCB, 0x99, 0x59 + }, + { + 0xF5, 0xF8, 0x92, 0xDA, 0x09, 0xB3, 0x0E, 0x8F, + 0x6E, 0x22, 0xAF, 0x15, 0x69, 0x6F, 0x8C, 0x57, + 0x87, 0x36, 0x0B, 0x6F, 0x18, 0xCA, 0xF8, 0x4D, + 0xE1, 0xD6, 0xFE, 0x4C, 0x62, 0xE7, 0x43, 0x09 + }, + { + 0x4D, 0x23, 0x5A, 0xD1, 0x0D, 0x65, 0xA7, 0x09, + 0x7D, 0x0D, 0x10, 0x00, 0xFA, 0xB7, 0x26, 0x9E, + 0x59, 0xE0, 0x81, 0xD3, 0x03, 0x23, 0x34, 0xD2, + 0x6E, 0xEB, 0x24, 0x70, 0x95, 0x3F, 0x3A, 0xCE + }, + { + 0x50, 0xD8, 0xB4, 0xE0, 0xE9, 0x04, 0x52, 0x3A, + 0xF1, 0xFF, 0xAB, 0x18, 0x44, 0x17, 0x09, 0xD7, + 0x41, 0x25, 0xCB, 0x15, 0x11, 0x6A, 0x73, 0xD6, + 0x61, 0x51, 0xE4, 0x01, 0x78, 0x8A, 0xF5, 0x2B + }, + { + 0x23, 0x11, 0xE6, 0xCD, 0x15, 0x65, 0x1B, 0x9E, + 0xEC, 0x3B, 0x5B, 0x99, 0x54, 0x84, 0xF1, 0x2F, + 0x95, 0xCF, 0x6E, 0x27, 0x3C, 0x95, 0x0E, 0x8F, + 0xAA, 0x98, 0x7A, 0xD4, 0x01, 0x02, 0x59, 0x20 + }, + { + 0x27, 0xE5, 0x33, 0x1B, 0x20, 0x1F, 0x4A, 0x4C, + 0xEF, 0x88, 0x76, 0x30, 0xC4, 0x25, 0xC9, 0xAD, + 0xFB, 0xE5, 0x94, 0x46, 0x43, 0x01, 0xB5, 0xA5, + 0x9A, 0xAB, 0x05, 0x9A, 0x75, 0x16, 0x66, 0xE3 + }, + { + 0x0C, 0xE7, 0xF4, 0xF7, 0x74, 0x15, 0xAD, 0x60, + 0xB7, 0xA6, 0x15, 0x73, 0x3B, 0xD7, 0x0D, 0x41, + 0x99, 0x9A, 0xD9, 0x34, 0xD3, 0x4E, 0x16, 0xFC, + 0x36, 0xD4, 0x20, 0x05, 0xB9, 0x31, 0x12, 0x08 + }, + { + 0x99, 0xED, 0x07, 0x83, 0xE5, 0x51, 0xA3, 0xBE, + 0xC7, 0xBE, 0xD8, 0x79, 0x16, 0xC7, 0x04, 0xF8, + 0x73, 0x7A, 0xC7, 0x37, 0xCF, 0xFE, 0x68, 0x22, + 0x76, 0x76, 0xDD, 0x76, 0x47, 0xFF, 0x2A, 0x49 + }, + { + 0x40, 0x45, 0xED, 0xC3, 0x4C, 0x83, 0x49, 0xFA, + 0x83, 0x06, 0x73, 0xF5, 0x26, 0x08, 0x1E, 0xB9, + 0xAC, 0xEB, 0xBC, 0xA5, 0x51, 0x59, 0x1B, 0xFA, + 0x59, 0x05, 0xA7, 0x7A, 0xCA, 0xBF, 0xAC, 0x85 + }, + { + 0x4A, 0xA5, 0x38, 0x5E, 0x4E, 0x9C, 0xA8, 0x20, + 0x0F, 0xB9, 0x94, 0xD9, 0xEA, 0x40, 0xB8, 0x22, + 0xCD, 0x3C, 0x21, 0xEC, 0xF0, 0x3A, 0xAA, 0x7F, + 0xFF, 0x21, 0x86, 0xE7, 0x5B, 0xD3, 0xD7, 0x4F + }, + { + 0x7F, 0xA8, 0xB5, 0xD6, 0xB0, 0x84, 0x36, 0x91, + 0x61, 0xAF, 0xA3, 0xF8, 0x86, 0x78, 0xB6, 0xEE, + 0x70, 0x2E, 0x87, 0xF3, 0xA8, 0x27, 0xCC, 0xE1, + 0x02, 0x17, 0xED, 0xBC, 0x47, 0x5B, 0x8D, 0x85 + }, + { + 0xFF, 0x5D, 0x2C, 0xAF, 0x57, 0x9B, 0xA7, 0x6D, + 0xF2, 0xA0, 0xFD, 0xDA, 0xBD, 0x43, 0x34, 0x65, + 0xAD, 0x09, 0xDF, 0x32, 0x28, 0xC0, 0xE1, 0xED, + 0x08, 0x8A, 0x5F, 0xBF, 0x2B, 0x25, 0xC6, 0xB7 + }, + { + 0xE6, 0x77, 0x6B, 0x9A, 0xDC, 0xCA, 0x12, 0xE9, + 0x6F, 0xE1, 0x58, 0x7E, 0x07, 0xF1, 0xFE, 0x7C, + 0x5B, 0xAE, 0xE8, 0x37, 0xC8, 0xA8, 0x20, 0x18, + 0xCA, 0x42, 0xD0, 0xDE, 0x0A, 0x04, 0x34, 0x93 + }, + { + 0x1E, 0x5C, 0x33, 0xEC, 0x1C, 0x40, 0xDF, 0x6D, + 0x18, 0x7A, 0xF1, 0xAE, 0x94, 0xCC, 0xCB, 0x38, + 0x69, 0x10, 0xB5, 0xF5, 0x8E, 0x4D, 0x3B, 0xAF, + 0xD4, 0x32, 0x22, 0xA7, 0xD5, 0x7F, 0xE9, 0x77 + }, + { + 0x0E, 0x1C, 0x38, 0x77, 0x57, 0x25, 0xE6, 0xC6, + 0xC8, 0x0E, 0xA2, 0x1C, 0xA4, 0x90, 0x75, 0x84, + 0xE6, 0xF3, 0x21, 0xD3, 0xEB, 0x72, 0x0B, 0x63, + 0x3C, 0x0B, 0xFC, 0x71, 0xC8, 0x9F, 0xB0, 0xBA + }, + { + 0x3C, 0x3C, 0x14, 0x26, 0xA0, 0x60, 0x70, 0x43, + 0x80, 0x7D, 0x25, 0xA0, 0x4D, 0x05, 0x4E, 0x06, + 0xEC, 0x6B, 0x6F, 0x3E, 0x30, 0xCE, 0x86, 0xEE, + 0xA2, 0x5D, 0x72, 0x8B, 0x9E, 0xC7, 0x67, 0x71 + }, + { + 0xA5, 0xB3, 0xD6, 0x86, 0xCF, 0x0B, 0xEB, 0x07, + 0xBD, 0x67, 0xE0, 0x5F, 0xA5, 0xFA, 0xF7, 0x0E, + 0x52, 0xBD, 0x38, 0x27, 0x8E, 0xCA, 0x94, 0x42, + 0x32, 0x86, 0xAD, 0x43, 0xEA, 0x9A, 0x1E, 0xE2 + }, + { + 0xC7, 0x00, 0xCB, 0x5D, 0x59, 0x14, 0x13, 0x7B, + 0x25, 0x54, 0xF2, 0xC2, 0xB6, 0x2F, 0x65, 0x86, + 0x3A, 0x69, 0x29, 0x10, 0x83, 0xA4, 0x8A, 0x04, + 0xCC, 0xE1, 0x79, 0x56, 0x56, 0x85, 0x45, 0x11 + }, + { + 0xED, 0x41, 0x16, 0x3D, 0x3A, 0x44, 0x53, 0x5F, + 0x61, 0x96, 0x29, 0xFB, 0xB2, 0xFD, 0x42, 0x76, + 0xD0, 0x97, 0xAA, 0xCA, 0xF8, 0x1F, 0x00, 0x84, + 0x8F, 0x72, 0x68, 0xD5, 0xA3, 0x75, 0x15, 0x98 + }, + { + 0x66, 0x8E, 0xD0, 0x2F, 0xAC, 0x88, 0x7B, 0x16, + 0xCE, 0x93, 0xAB, 0x99, 0x56, 0x24, 0x88, 0x54, + 0x80, 0xBB, 0x95, 0xC0, 0xCD, 0xF8, 0x54, 0xFE, + 0x9C, 0x08, 0xD5, 0xB7, 0x42, 0x89, 0x82, 0x64 + }, + { + 0x65, 0xB4, 0xB5, 0xA4, 0x8C, 0x16, 0xE6, 0xFC, + 0x04, 0x6D, 0x6D, 0x56, 0x53, 0xA6, 0x78, 0x73, + 0x76, 0x3C, 0xB0, 0x9E, 0xB0, 0x97, 0x39, 0x25, + 0x21, 0x67, 0x1F, 0x56, 0x74, 0xEA, 0xEA, 0x8F + }, + { + 0x9D, 0x4B, 0xEA, 0x28, 0x05, 0x2F, 0x95, 0xFD, + 0xF8, 0x4B, 0xE2, 0xCE, 0x47, 0xD4, 0xFD, 0xF3, + 0x1C, 0x6D, 0x4E, 0xE7, 0x9B, 0x6C, 0x16, 0xB8, + 0x3A, 0xE0, 0xFE, 0x6A, 0x37, 0x4C, 0x4D, 0x4B + }, + { + 0x0D, 0x46, 0xEE, 0x60, 0x94, 0xF4, 0x86, 0x8F, + 0xB8, 0x8A, 0x1B, 0x26, 0xB5, 0x79, 0x65, 0x64, + 0x03, 0xA7, 0x8B, 0x19, 0x22, 0x64, 0xA9, 0x6E, + 0x88, 0x01, 0x8A, 0x06, 0x30, 0x26, 0x02, 0x2B + }, + { + 0xF6, 0x51, 0xE8, 0x69, 0xF8, 0xB0, 0x4D, 0xAB, + 0xC4, 0x69, 0x63, 0x24, 0xA1, 0xD7, 0x00, 0x53, + 0xD9, 0xCB, 0xCD, 0xBF, 0x64, 0x4F, 0x9B, 0xA9, + 0xEA, 0x1B, 0xE3, 0x0E, 0x0F, 0xB0, 0x1B, 0xFB + }, + { + 0x4D, 0xFD, 0x2C, 0xA4, 0xC7, 0x0A, 0x4A, 0xEC, + 0x20, 0x71, 0x34, 0x8C, 0xB9, 0xD7, 0x8E, 0x65, + 0x1E, 0x62, 0xF6, 0x8F, 0x7F, 0x11, 0x39, 0x8D, + 0x79, 0xAE, 0xAE, 0x4C, 0xE3, 0xBC, 0xF2, 0xFA + }, + { + 0x24, 0x95, 0x42, 0x31, 0xC0, 0x00, 0xE7, 0x9B, + 0x5E, 0x0E, 0xEE, 0xED, 0xE1, 0xD7, 0x87, 0x0F, + 0xC0, 0xBC, 0x1D, 0x3D, 0x88, 0x12, 0x2C, 0x5B, + 0x33, 0xB4, 0xBF, 0x69, 0xC0, 0x1B, 0x38, 0xB8 + }, + { + 0x0A, 0x6F, 0x2E, 0xC4, 0x7A, 0x01, 0x34, 0x10, + 0xFE, 0x1A, 0xDA, 0x55, 0xA3, 0x4B, 0xC8, 0xFB, + 0x17, 0xC7, 0xA4, 0x71, 0x2C, 0x08, 0x6B, 0x4B, + 0xD6, 0xA9, 0x29, 0xA6, 0x59, 0x39, 0xEA, 0x78 + }, + { + 0xCF, 0x84, 0x13, 0x1C, 0xE0, 0x9A, 0x1E, 0x59, + 0xC5, 0x46, 0x2D, 0xFA, 0x22, 0x01, 0x15, 0xA9, + 0x51, 0x3E, 0x87, 0xD2, 0xA6, 0x7C, 0x4B, 0x9D, + 0xF7, 0xB5, 0xF5, 0x83, 0x3D, 0xD4, 0x1F, 0x3B + }, + { + 0x57, 0x02, 0xA6, 0x77, 0x26, 0x2E, 0x3D, 0x75, + 0x4E, 0xF9, 0xEF, 0x21, 0xAD, 0xE8, 0x24, 0x91, + 0x62, 0x40, 0x8C, 0x97, 0xC2, 0xB9, 0x14, 0x36, + 0x39, 0xEA, 0x78, 0x47, 0x00, 0x55, 0x71, 0x38 + }, + { + 0x43, 0x18, 0x0C, 0xB6, 0x90, 0xA9, 0x54, 0xAD, + 0xDB, 0xF7, 0x95, 0x0B, 0xFD, 0xB9, 0xFF, 0x5A, + 0xF0, 0x69, 0x61, 0xC9, 0x32, 0x16, 0xBF, 0xCD, + 0x36, 0x65, 0x9A, 0x30, 0x64, 0x63, 0x2E, 0x51 + }, + { + 0x43, 0x8A, 0x14, 0xA0, 0x34, 0x1B, 0x68, 0x5F, + 0xF9, 0x7D, 0xF0, 0x5C, 0xE2, 0x69, 0x5B, 0xD5, + 0xAE, 0x25, 0x59, 0x47, 0x12, 0xE4, 0x6B, 0xED, + 0x79, 0x7D, 0x95, 0x24, 0x96, 0xFD, 0x02, 0x7A + }, + { + 0x2C, 0x35, 0xEC, 0x5A, 0x9B, 0xCB, 0xCD, 0xB2, + 0x4B, 0x8C, 0xCD, 0x52, 0x30, 0xBD, 0x72, 0x14, + 0x3C, 0xFA, 0x46, 0xF1, 0xBB, 0x59, 0x9E, 0x31, + 0x14, 0xC4, 0x9E, 0xA9, 0x61, 0xB4, 0xCA, 0xE6 + }, + { + 0x77, 0x16, 0xB9, 0xD6, 0x33, 0x9C, 0x3B, 0x9E, + 0x1B, 0x33, 0x3E, 0xFC, 0xED, 0x30, 0xEB, 0x3B, + 0xE2, 0x88, 0xA9, 0x49, 0x78, 0xF7, 0x5A, 0x01, + 0x79, 0xF9, 0x4B, 0x60, 0x32, 0xAE, 0x80, 0x23 + }, + { + 0x44, 0xE6, 0x98, 0x63, 0x72, 0x3A, 0x46, 0x4C, + 0xB1, 0xEA, 0xE6, 0xEB, 0xA4, 0x40, 0x9A, 0xB1, + 0x0B, 0xDF, 0x76, 0xE1, 0x90, 0xB4, 0x03, 0xED, + 0xC5, 0xAB, 0x15, 0x7D, 0x9E, 0x3F, 0x6C, 0xA2 + }, + { + 0xE5, 0xD0, 0xFC, 0x98, 0x6C, 0x34, 0x17, 0xFF, + 0x84, 0x29, 0xE2, 0x2C, 0x8D, 0x8F, 0x3B, 0x70, + 0xAF, 0x58, 0xAA, 0x3E, 0x66, 0x2C, 0x0B, 0x4F, + 0xDE, 0xF9, 0x96, 0x0B, 0x5F, 0x30, 0x2B, 0x60 + }, + { + 0xAC, 0xBB, 0xBA, 0x90, 0xC0, 0x29, 0xFA, 0x4D, + 0x7C, 0x7B, 0x0A, 0xB8, 0xF9, 0xC0, 0xFC, 0xC2, + 0x5A, 0xE2, 0x2B, 0xB7, 0x2D, 0x33, 0x6D, 0x6F, + 0x97, 0x0D, 0xEF, 0x9A, 0x42, 0xCB, 0x94, 0x7E + }, + { + 0xD2, 0x72, 0x04, 0xD6, 0x76, 0xCF, 0x5B, 0x8F, + 0x83, 0x1B, 0xEE, 0xA9, 0x8B, 0xF7, 0xFC, 0xF6, + 0x67, 0x56, 0x70, 0x95, 0x8E, 0x73, 0xB4, 0x63, + 0x4A, 0x40, 0xEE, 0x09, 0xD3, 0x23, 0xFB, 0xC7 + }, + { + 0x5C, 0x57, 0x84, 0xFC, 0xE2, 0x69, 0x2E, 0x98, + 0x6D, 0x1A, 0xBB, 0xC2, 0xC9, 0xEB, 0x39, 0x31, + 0x96, 0x57, 0x0E, 0xB9, 0xE7, 0x9B, 0x45, 0x3D, + 0x1D, 0x9E, 0xB7, 0xA7, 0x7C, 0x85, 0x5B, 0x7C + }, + { + 0x01, 0xD6, 0x6D, 0x40, 0x0A, 0x1A, 0xA8, 0xFF, + 0x4B, 0xE5, 0x0B, 0x65, 0xDB, 0x88, 0x93, 0xDD, + 0x29, 0x3C, 0xC5, 0x70, 0x87, 0xD6, 0xA0, 0xA3, + 0x96, 0xFE, 0xE0, 0x2D, 0x18, 0x4B, 0x2F, 0x0F + }, + { + 0xB8, 0x91, 0x19, 0x0B, 0x52, 0x6F, 0xEC, 0xB0, + 0x95, 0x3E, 0xD6, 0x45, 0x56, 0x28, 0x08, 0xB7, + 0xDD, 0xD2, 0x66, 0x38, 0xE3, 0x9F, 0xFD, 0x1A, + 0x11, 0x1E, 0x67, 0x08, 0x68, 0x73, 0xCD, 0x2C + }, + { + 0xE7, 0xD7, 0x50, 0x10, 0xCD, 0xBA, 0x3C, 0x97, + 0x14, 0xBD, 0xC8, 0x4B, 0x4C, 0x54, 0xFD, 0x16, + 0xCA, 0xCA, 0x99, 0xA8, 0x13, 0xC8, 0x0E, 0xB6, + 0x90, 0xB1, 0x72, 0x07, 0x0F, 0x8A, 0xC0, 0xF9 + }, + { + 0xE3, 0x3B, 0xA0, 0x5D, 0xE8, 0x83, 0x41, 0x54, + 0x69, 0x11, 0x29, 0x3F, 0xEC, 0x45, 0x11, 0x4D, + 0x50, 0x85, 0xBF, 0x57, 0x36, 0x1D, 0xCC, 0xEF, + 0xC9, 0x48, 0xF0, 0x3A, 0xAA, 0xDD, 0xA3, 0x58 + }, + { + 0x4D, 0x93, 0xFC, 0x1F, 0x05, 0x92, 0x5A, 0xDF, + 0x66, 0x15, 0xB4, 0x1B, 0xEE, 0xED, 0x6F, 0x52, + 0x46, 0xBF, 0xEB, 0x2D, 0x38, 0xB0, 0xD9, 0xBE, + 0x89, 0x91, 0xBE, 0xC1, 0x38, 0x03, 0xB7, 0x02 + }, + { + 0xFF, 0xF3, 0x1E, 0x97, 0xED, 0xC2, 0xBB, 0x1B, + 0xC1, 0xEA, 0x70, 0x11, 0xB0, 0x50, 0x8F, 0xA1, + 0x60, 0x42, 0x5A, 0x30, 0x88, 0xB8, 0xFD, 0xCC, + 0x86, 0xC1, 0xCA, 0xA0, 0x01, 0x00, 0x43, 0x4C + }, + { + 0x08, 0x27, 0xBC, 0x96, 0x2F, 0x9B, 0xB3, 0x9E, + 0x2C, 0x42, 0xF8, 0xF2, 0xA3, 0x6B, 0xD5, 0x55, + 0xC6, 0xA4, 0x2C, 0xC5, 0xA3, 0x7C, 0xE4, 0x4D, + 0x91, 0xF3, 0x8C, 0x86, 0xB1, 0x4A, 0x9C, 0x63 + }, + { + 0xA6, 0xB9, 0xCB, 0xD7, 0x84, 0xF1, 0xDE, 0xA6, + 0x44, 0x3C, 0xDA, 0x50, 0x9D, 0xCF, 0xCC, 0xE0, + 0x54, 0x7C, 0xD6, 0x06, 0xDB, 0xF5, 0x0C, 0x99, + 0x18, 0x64, 0xEA, 0xCE, 0x9F, 0x6F, 0xF4, 0x23 + }, + { + 0x2F, 0xDB, 0x5E, 0xF5, 0x4D, 0xFD, 0xC5, 0x6B, + 0xA4, 0x4E, 0x05, 0x75, 0x0B, 0x1C, 0x6D, 0x7A, + 0x31, 0x53, 0xF8, 0xE2, 0xAA, 0x45, 0x01, 0x01, + 0x23, 0x3B, 0xB2, 0x0F, 0x07, 0x84, 0x58, 0x03 + }, + { + 0xE8, 0x61, 0x65, 0x2D, 0x1B, 0x61, 0x15, 0x87, + 0xD0, 0x7B, 0x58, 0x5F, 0x3B, 0xC9, 0xD9, 0x4A, + 0x4A, 0x29, 0x87, 0x2D, 0x8E, 0x39, 0x0D, 0x6B, + 0xEF, 0x59, 0x01, 0xC3, 0x80, 0xB7, 0x15, 0x33 + }, + { + 0x87, 0xDE, 0x1A, 0x38, 0xA4, 0x54, 0x32, 0x7C, + 0x5C, 0x1E, 0xBF, 0xAA, 0x6E, 0x35, 0x01, 0x62, + 0xB3, 0xCC, 0x37, 0xF4, 0xF5, 0x15, 0x37, 0x9A, + 0x93, 0x7E, 0x13, 0x94, 0xF1, 0x29, 0x28, 0xCD + }, + { + 0x60, 0x7C, 0x8D, 0x72, 0x82, 0x52, 0x62, 0xDE, + 0x53, 0x21, 0xAE, 0x4B, 0x0B, 0x68, 0x57, 0x67, + 0x9F, 0x54, 0x1A, 0x27, 0xEF, 0x0B, 0x44, 0x32, + 0x96, 0x24, 0x3D, 0xB8, 0x4C, 0x79, 0x9C, 0xBE + }, + { + 0x3A, 0x50, 0x92, 0x1C, 0xE4, 0xE6, 0x82, 0xD4, + 0x23, 0x7B, 0xEB, 0x86, 0x67, 0xF4, 0x5E, 0x6A, + 0xB1, 0x01, 0x3F, 0xD5, 0x49, 0x91, 0x45, 0x68, + 0xF8, 0xCD, 0xB2, 0xF0, 0xEE, 0x92, 0xC0, 0x4B + }, + { + 0xD6, 0xDD, 0x3A, 0xBB, 0xC8, 0x1B, 0xF3, 0xD7, + 0x19, 0xC1, 0xDD, 0x41, 0x54, 0x5C, 0xC0, 0x8C, + 0x2A, 0x2E, 0x29, 0x29, 0xB6, 0xE1, 0x93, 0x15, + 0xE4, 0x59, 0xCA, 0x80, 0x2A, 0x6D, 0x4B, 0x94 + }, + { + 0xFC, 0xE8, 0x16, 0x1D, 0x33, 0x0C, 0xA4, 0xE3, + 0x4B, 0xE9, 0x33, 0xB8, 0x22, 0x27, 0xF9, 0xB6, + 0xE5, 0x4A, 0x2A, 0x6E, 0xF6, 0x8E, 0x8D, 0x77, + 0xFD, 0xE6, 0xC4, 0x24, 0xA5, 0xF2, 0xD8, 0x6F + }, + { + 0x7A, 0x6B, 0x2C, 0xD1, 0xAC, 0x9A, 0x60, 0xD5, + 0xE5, 0xC1, 0x08, 0x87, 0x7F, 0x72, 0x61, 0xC4, + 0xFF, 0xA9, 0x4B, 0x28, 0xB4, 0x87, 0xF2, 0x25, + 0xBA, 0x96, 0xEC, 0x7B, 0xA4, 0x2F, 0x9B, 0x1F + }, + { + 0xA6, 0x66, 0x32, 0x87, 0x73, 0x0D, 0xD7, 0xC7, + 0x47, 0x5C, 0x83, 0xEE, 0xEA, 0xF9, 0x7F, 0x9E, + 0xC3, 0xE1, 0xFD, 0x51, 0x9B, 0x3F, 0xA0, 0x67, + 0x58, 0xD5, 0x1A, 0x95, 0xB6, 0x27, 0xEA, 0x8B + }, + { + 0x92, 0x59, 0x50, 0x22, 0xF7, 0xA4, 0x9E, 0x4F, + 0x35, 0xE2, 0x8E, 0xF5, 0xB2, 0x51, 0x8E, 0x60, + 0x2B, 0xF7, 0xD9, 0x62, 0x00, 0x8F, 0xB6, 0x19, + 0x60, 0xAE, 0xD9, 0xA4, 0x67, 0x06, 0x42, 0xA7 + }, + { + 0x03, 0x39, 0x14, 0x67, 0xB8, 0x99, 0xE2, 0x24, + 0xC5, 0x71, 0x56, 0x5C, 0x8D, 0x08, 0x23, 0x2D, + 0x7F, 0x65, 0x8C, 0x95, 0xD6, 0x3A, 0x17, 0x03, + 0x8C, 0xC0, 0x4B, 0xBE, 0xDD, 0xAF, 0x65, 0x0D + }, + { + 0xC5, 0xC5, 0x8C, 0x08, 0x91, 0xD8, 0xC6, 0x73, + 0x7F, 0xD5, 0x7F, 0xA0, 0x48, 0xBE, 0x0C, 0x69, + 0x30, 0x9C, 0xDE, 0x0E, 0x5C, 0xE4, 0x14, 0x63, + 0x34, 0x28, 0x8D, 0xE6, 0x3F, 0x47, 0x02, 0x76 + }, + { + 0xCB, 0xF6, 0x4F, 0x37, 0x99, 0xBF, 0x1D, 0x1C, + 0x1A, 0x71, 0xA4, 0x89, 0x8F, 0x4E, 0xBE, 0xE1, + 0xA1, 0x4D, 0x8B, 0xAC, 0xCC, 0x93, 0x07, 0xBB, + 0x01, 0x31, 0x9D, 0xE9, 0x34, 0x36, 0xCC, 0x31 + }, + { + 0xFD, 0xB6, 0x7D, 0x4D, 0x0A, 0xC0, 0xB5, 0x94, + 0xF6, 0x8A, 0x1C, 0x4D, 0xFC, 0x43, 0x6B, 0xB5, + 0x18, 0xB4, 0xDE, 0x8C, 0xBE, 0x45, 0x55, 0xCC, + 0x2C, 0xB7, 0xAB, 0x07, 0x89, 0xAE, 0xF9, 0x05 + }, + { + 0x8E, 0x9A, 0x8F, 0xD3, 0x58, 0xFF, 0x52, 0x83, + 0x1A, 0xF3, 0x3C, 0x13, 0x26, 0xE6, 0xEB, 0xF5, + 0xE1, 0x38, 0xA9, 0x2D, 0x38, 0xB4, 0x55, 0xEE, + 0x00, 0xA5, 0x61, 0xEA, 0x6C, 0x1F, 0x9B, 0x46 + }, + { + 0xE8, 0x25, 0x69, 0xC2, 0x9A, 0x49, 0x95, 0x21, + 0x08, 0xEC, 0xD0, 0xB8, 0xB1, 0xDB, 0x68, 0x42, + 0x4B, 0x41, 0x29, 0x86, 0x6F, 0x82, 0xB9, 0xD2, + 0xD9, 0x03, 0xBF, 0x08, 0x4B, 0x94, 0x84, 0x58 + }, + { + 0x1E, 0xBD, 0x7B, 0x8A, 0x46, 0xAC, 0xBC, 0xAB, + 0x1F, 0x0B, 0x11, 0xF1, 0xB2, 0xC2, 0xD5, 0x9F, + 0xE3, 0xB3, 0x7A, 0xAE, 0x29, 0xC5, 0x46, 0x6E, + 0xFA, 0x71, 0xFB, 0x7C, 0xA3, 0x3E, 0xE0, 0x24 + }, + { + 0x8D, 0xDA, 0x01, 0x4A, 0x65, 0x0F, 0xF6, 0x69, + 0xDB, 0xD5, 0x40, 0x26, 0x0A, 0x28, 0x2D, 0xEF, + 0xD2, 0x76, 0xD0, 0xAA, 0xFD, 0xFD, 0x7C, 0xF1, + 0x64, 0x4B, 0x00, 0x3E, 0x29, 0xB7, 0xE7, 0xCA + }, + { + 0x62, 0x7D, 0xC8, 0x52, 0x6B, 0xE1, 0x93, 0x99, + 0x5D, 0x63, 0x29, 0xF4, 0x70, 0x33, 0x48, 0x89, + 0xAB, 0xEE, 0xEC, 0xEA, 0x1D, 0x13, 0xEC, 0xA1, + 0xA9, 0x86, 0x1B, 0x5E, 0xD8, 0xB1, 0x77, 0xE8 + }, + { + 0x42, 0xF4, 0xC5, 0x5C, 0xA3, 0xAE, 0x26, 0x63, + 0x39, 0x56, 0x15, 0x94, 0x1A, 0x28, 0x85, 0xD2, + 0x80, 0x24, 0x2D, 0x72, 0x36, 0x3E, 0xB6, 0xB7, + 0x6E, 0x92, 0xCC, 0x52, 0x03, 0x20, 0xCD, 0x0B + }, + { + 0x89, 0x50, 0x5F, 0xBD, 0xFA, 0xFB, 0x9D, 0xC2, + 0xAE, 0xC6, 0x64, 0x91, 0x88, 0x25, 0xAB, 0xF5, + 0x34, 0x29, 0x92, 0x1E, 0x7F, 0x96, 0xA2, 0xFB, + 0xFF, 0xA2, 0xF0, 0x88, 0x6B, 0x1A, 0x27, 0x1F + }, + { + 0x53, 0x54, 0x4C, 0x14, 0xE6, 0xE6, 0x7C, 0x46, + 0xE6, 0x0F, 0x21, 0xDB, 0xF6, 0xEB, 0xBB, 0xB5, + 0xD8, 0xFF, 0x32, 0x3B, 0x02, 0x4A, 0x82, 0x89, + 0x02, 0xFF, 0xB2, 0xB8, 0x85, 0x91, 0xEF, 0x80 + }, + { + 0xAC, 0x79, 0x74, 0x72, 0x29, 0x2C, 0x7E, 0xDF, + 0x98, 0xA9, 0x59, 0x76, 0xA1, 0xC5, 0x5B, 0xF6, + 0x25, 0xD3, 0x86, 0x74, 0x53, 0xAF, 0x51, 0xA5, + 0x88, 0x70, 0x2F, 0x8D, 0x8E, 0x37, 0x69, 0x39 + }, + { + 0x2B, 0x2B, 0x4F, 0x2E, 0x63, 0xAA, 0x67, 0x68, + 0x6A, 0x3C, 0x39, 0xEC, 0x61, 0x45, 0x66, 0x4F, + 0x20, 0x8B, 0x2B, 0xD0, 0x70, 0x61, 0xB0, 0xD2, + 0x47, 0x99, 0xA0, 0xFB, 0xF7, 0xCF, 0xC6, 0x31 + }, + { + 0xC6, 0x61, 0xAF, 0x75, 0xA1, 0xFD, 0x66, 0xB1, + 0x1A, 0x65, 0x7E, 0xA1, 0xB4, 0xEC, 0x44, 0xFC, + 0xA6, 0x07, 0xB2, 0xC5, 0x91, 0xE2, 0x3C, 0x2A, + 0xFA, 0x47, 0x20, 0x6E, 0xE4, 0x0F, 0x54, 0x6D + }, + { + 0x40, 0x58, 0x77, 0x48, 0x94, 0x02, 0xB2, 0x3A, + 0x51, 0xD6, 0x3C, 0x98, 0xB9, 0xF5, 0xC3, 0xE9, + 0x2F, 0x05, 0x2F, 0xBA, 0xBA, 0x6A, 0xA5, 0xE1, + 0x31, 0x61, 0x8B, 0xC2, 0x8F, 0xBF, 0x50, 0x84 + }, + { + 0x5A, 0xE0, 0xA2, 0x3A, 0x93, 0x0C, 0x7A, 0x34, + 0x8A, 0x8A, 0x0A, 0x04, 0xC6, 0xE1, 0x8E, 0xDA, + 0x08, 0x5D, 0xCE, 0x39, 0x8D, 0xDF, 0x42, 0xD8, + 0xDD, 0xF6, 0x86, 0x6B, 0x30, 0x0F, 0x77, 0x6D + }, + { + 0x58, 0x21, 0x93, 0x44, 0x5B, 0x0B, 0xB2, 0x80, + 0xDF, 0x62, 0xC6, 0xFA, 0x70, 0xB6, 0xDE, 0x0A, + 0x96, 0x20, 0xB5, 0x97, 0x61, 0xCD, 0xE0, 0xF5, + 0xB0, 0xE6, 0x37, 0x14, 0xF4, 0x7D, 0x7C, 0x28 + }, + { + 0x95, 0xBE, 0xF5, 0x53, 0x58, 0xAC, 0x28, 0xA3, + 0x4A, 0x48, 0x35, 0xA0, 0xA8, 0xDC, 0xEF, 0xA2, + 0xC8, 0x18, 0x9E, 0xB6, 0x03, 0xC8, 0x7C, 0x9E, + 0x26, 0x7C, 0x78, 0x5A, 0x24, 0x91, 0xCF, 0x95 + }, + { + 0xB2, 0x24, 0x89, 0x3C, 0xEC, 0x64, 0x2B, 0x46, + 0xF0, 0xF9, 0x12, 0xBD, 0x3D, 0xC1, 0xF4, 0xD1, + 0x4F, 0xDE, 0x4C, 0x89, 0x9F, 0x3C, 0xCB, 0xBD, + 0xF8, 0x25, 0x64, 0x31, 0xD3, 0xE4, 0xDF, 0x91 + }, + { + 0x04, 0x7D, 0xF3, 0x21, 0xDB, 0x8B, 0x97, 0xE5, + 0xEF, 0x39, 0x09, 0xF6, 0x1C, 0x21, 0xD4, 0xB0, + 0xE8, 0x60, 0xA2, 0x50, 0xA1, 0x3E, 0x80, 0xD6, + 0x55, 0x04, 0xF2, 0x30, 0x2E, 0x94, 0xBB, 0xCE + }, + { + 0xB3, 0xE6, 0xA0, 0x38, 0xF6, 0xBE, 0x78, 0xA9, + 0x7A, 0xA7, 0x02, 0x0C, 0xB4, 0x30, 0x8F, 0x47, + 0x65, 0x9C, 0xF3, 0x4B, 0x44, 0xF9, 0x82, 0xE1, + 0x5C, 0xBB, 0xAA, 0x0E, 0xDD, 0x06, 0x19, 0x75 + }, + { + 0x99, 0x46, 0x23, 0x8A, 0x22, 0x94, 0x60, 0x33, + 0x15, 0x58, 0x09, 0x6A, 0xE6, 0x9C, 0x6B, 0x1E, + 0x6A, 0xD3, 0x76, 0x22, 0x8B, 0xCE, 0x8D, 0x16, + 0x61, 0xD0, 0xD8, 0x12, 0xA7, 0xDF, 0xA5, 0x56 + }, + { + 0xD7, 0x01, 0x94, 0xF7, 0x4D, 0xA3, 0x52, 0x49, + 0x49, 0x7F, 0xA4, 0x78, 0xE3, 0x61, 0xEF, 0x5B, + 0x95, 0x12, 0x5E, 0xDB, 0xCE, 0x93, 0x7C, 0xC7, + 0x9D, 0xE1, 0x2F, 0xFE, 0xC5, 0x0B, 0xEB, 0xAB + }, + { + 0xD8, 0xB4, 0xC7, 0x58, 0x5B, 0x17, 0x0B, 0x60, + 0x9C, 0x97, 0x63, 0x20, 0xEB, 0x34, 0xF0, 0x26, + 0x9A, 0x55, 0x44, 0xA9, 0x72, 0x60, 0x39, 0x0D, + 0x1E, 0xC9, 0x92, 0x9B, 0xED, 0x17, 0x66, 0x03 + }, + { + 0x9D, 0x08, 0xBD, 0xBB, 0x2E, 0x82, 0x67, 0x46, + 0xFD, 0x4D, 0x4A, 0x44, 0x23, 0x2E, 0x39, 0xF2, + 0x96, 0x0B, 0x98, 0x7F, 0x11, 0x9D, 0xEC, 0x46, + 0x43, 0x20, 0x21, 0x62, 0xAC, 0xE8, 0x3D, 0x0A + }, + { + 0xCE, 0x32, 0x21, 0x2A, 0x2F, 0x84, 0x7E, 0x0B, + 0xEC, 0x60, 0x40, 0xD1, 0xB7, 0x8C, 0x88, 0x4D, + 0xFC, 0x07, 0x6A, 0x16, 0x68, 0x58, 0x26, 0xC6, + 0x0D, 0xEF, 0x2A, 0xEC, 0x7E, 0x63, 0x8D, 0x7A + }, + { + 0x47, 0x02, 0x59, 0x19, 0xA3, 0x9D, 0x73, 0xD0, + 0x2A, 0xE2, 0x7E, 0x89, 0x17, 0xD3, 0x87, 0x6D, + 0xC6, 0xCD, 0x6E, 0xAA, 0xBB, 0x16, 0x2E, 0xA3, + 0x12, 0x48, 0x02, 0xA7, 0x1D, 0x0C, 0xC7, 0xE1 + }, + { + 0x9F, 0xFA, 0xDA, 0xCE, 0x82, 0x67, 0x29, 0x89, + 0x8B, 0xA4, 0xF7, 0xE4, 0xDB, 0x38, 0x7E, 0x3F, + 0x84, 0xD4, 0xB0, 0x77, 0xD9, 0x7E, 0xFA, 0xD7, + 0x34, 0x1F, 0xED, 0x90, 0x21, 0x9B, 0x7F, 0x86 + }, + { + 0xF8, 0x44, 0xFE, 0xFC, 0xDA, 0x43, 0x9C, 0xAA, + 0xAB, 0x99, 0x0D, 0xF3, 0xB7, 0x71, 0x04, 0xAF, + 0xF9, 0x74, 0x0A, 0x2F, 0x89, 0xC4, 0x75, 0x49, + 0x35, 0x4F, 0x95, 0x82, 0xE6, 0x59, 0xE3, 0x9D + }, + { + 0xA3, 0xC9, 0x3D, 0xC3, 0xF2, 0xFE, 0xC9, 0xEA, + 0xF8, 0x6F, 0x9D, 0xA3, 0x9A, 0xD5, 0xFD, 0x0C, + 0xF1, 0x38, 0x82, 0x68, 0xC3, 0xF6, 0x56, 0x55, + 0x1D, 0x2B, 0xBA, 0x7C, 0xF1, 0x3F, 0xEC, 0x09 + }, + { + 0x73, 0x4A, 0x6D, 0x26, 0xE4, 0xD0, 0x35, 0xB3, + 0xA9, 0x13, 0x27, 0xF7, 0x3F, 0xD7, 0x44, 0x33, + 0x59, 0x27, 0x77, 0x27, 0x55, 0xBB, 0x87, 0x98, + 0xE6, 0xE6, 0xE7, 0xE0, 0x35, 0x6E, 0xA4, 0x76 + }, + { + 0xDD, 0x5C, 0x35, 0x24, 0x7A, 0x61, 0x25, 0x32, + 0x26, 0xEC, 0x3E, 0x28, 0xAC, 0x6D, 0x0C, 0xF7, + 0x6B, 0x12, 0xFB, 0x3D, 0x22, 0x3A, 0x47, 0x21, + 0x5B, 0xB5, 0x04, 0xC8, 0x1C, 0x85, 0x8A, 0xEA + }, + { + 0x62, 0x4B, 0xC1, 0xBA, 0x72, 0x55, 0xC2, 0xEA, + 0xB9, 0xD6, 0x8E, 0x1F, 0x8D, 0x2C, 0x03, 0xC8, + 0x52, 0xE2, 0x0F, 0xFC, 0x89, 0x31, 0xE2, 0xB1, + 0xE8, 0xA3, 0xCC, 0x9F, 0x79, 0x39, 0xED, 0x5D + }, + { + 0x36, 0x5B, 0x4C, 0xAD, 0x02, 0x48, 0x55, 0xEA, + 0x69, 0x17, 0x82, 0x75, 0x90, 0x52, 0x3E, 0x50, + 0xC8, 0x0F, 0xA1, 0x28, 0xDB, 0xAE, 0x81, 0x74, + 0xFA, 0x5D, 0xC2, 0x0A, 0x8C, 0x76, 0xF1, 0x21 + }, + { + 0x55, 0x46, 0xF1, 0xD4, 0x9E, 0x6D, 0x62, 0x6D, + 0x54, 0xE3, 0x1A, 0xD2, 0xAE, 0x69, 0x8E, 0x79, + 0xD8, 0x77, 0xE8, 0x83, 0x07, 0x46, 0x81, 0xCE, + 0x77, 0xCF, 0x05, 0xF9, 0xFF, 0x7D, 0x52, 0xF0 + }, + { + 0x29, 0x57, 0x38, 0x99, 0xE3, 0x90, 0x4D, 0xB3, + 0xAE, 0x32, 0x84, 0x39, 0x5D, 0x3A, 0x22, 0x79, + 0x17, 0xD9, 0xEF, 0xA2, 0x19, 0x83, 0x77, 0x38, + 0x36, 0x35, 0x2D, 0x60, 0xC2, 0x1C, 0xD8, 0x77 + }, + { + 0x37, 0xEE, 0xE8, 0xA2, 0x54, 0xC7, 0xD6, 0xAF, + 0x4D, 0x44, 0x64, 0x6D, 0xEC, 0xA7, 0xF5, 0xAF, + 0x4B, 0xDE, 0x24, 0x25, 0xDF, 0x69, 0x64, 0x6E, + 0x40, 0xE2, 0x0D, 0x0E, 0x60, 0xFC, 0xE2, 0xF9 + }, + { + 0x18, 0xD3, 0x77, 0x11, 0xE6, 0x99, 0xB0, 0x9D, + 0xFB, 0xF9, 0x09, 0x06, 0xCA, 0x8F, 0x39, 0x8A, + 0x9C, 0x9D, 0x44, 0x2E, 0x3B, 0x1A, 0x61, 0x45, + 0x27, 0x73, 0x3D, 0xD4, 0xED, 0x27, 0x61, 0x17 + }, + { + 0xF4, 0xD1, 0x70, 0xF6, 0x4B, 0x2B, 0xC2, 0xE5, + 0x56, 0x8E, 0x9C, 0xB0, 0x19, 0x34, 0x36, 0x87, + 0x41, 0xF9, 0x46, 0xC8, 0x2E, 0xFF, 0x0B, 0xB5, + 0x13, 0xE3, 0xE2, 0x16, 0x4A, 0x3F, 0x6B, 0xB3 + }, + { + 0x56, 0x3D, 0x5F, 0x14, 0x70, 0x98, 0x4E, 0x09, + 0xEB, 0xA3, 0xFE, 0x65, 0x79, 0x22, 0x27, 0x9C, + 0x70, 0x29, 0x67, 0xEB, 0x8F, 0x81, 0xC3, 0x3C, + 0x1D, 0x25, 0xD7, 0xB5, 0x70, 0x92, 0x40, 0xA4 + }, + { + 0x9D, 0xD9, 0x4E, 0x0A, 0x20, 0x1D, 0xC9, 0x17, + 0x61, 0x7D, 0xCD, 0xE9, 0x09, 0x29, 0xC9, 0x8B, + 0x4B, 0x2F, 0x0C, 0x8B, 0x47, 0x7A, 0xC1, 0x86, + 0x69, 0xE3, 0xB0, 0x70, 0xF9, 0x1B, 0x7D, 0x94 + }, + { + 0x9D, 0x56, 0xB5, 0x01, 0x1B, 0xC9, 0xA3, 0x34, + 0xBE, 0xF6, 0xB1, 0x17, 0xF7, 0x16, 0x56, 0x73, + 0xBA, 0xF3, 0xDE, 0x8C, 0x28, 0x1E, 0x90, 0x6E, + 0xC8, 0x48, 0x16, 0x20, 0x02, 0x65, 0x42, 0xB7 + }, + { + 0x7C, 0x71, 0xDC, 0xA5, 0x93, 0x59, 0x7D, 0x7E, + 0x1B, 0x34, 0x80, 0x52, 0x27, 0x78, 0x3D, 0x8D, + 0x25, 0xBB, 0x15, 0xA9, 0xD8, 0xF3, 0x8F, 0xBE, + 0x16, 0x7D, 0x92, 0x7E, 0xC0, 0x6F, 0x81, 0x9A + }, + { + 0x56, 0xA0, 0x84, 0xC5, 0x2D, 0x6F, 0xC9, 0x33, + 0xDE, 0xF8, 0xD5, 0xCF, 0x6E, 0xA6, 0xA1, 0xD2, + 0xB6, 0xA9, 0xDD, 0x7A, 0xA7, 0x79, 0x30, 0x8A, + 0x00, 0xC3, 0x7D, 0x89, 0x27, 0x06, 0xD5, 0x4B + }, + { + 0xB8, 0x7E, 0x81, 0xD0, 0x87, 0xEE, 0x52, 0x70, + 0x04, 0xC1, 0x2F, 0x8E, 0xB2, 0xFA, 0x1E, 0x1F, + 0x2B, 0xC9, 0xBA, 0xB2, 0x97, 0x67, 0xEF, 0x8A, + 0xE3, 0x68, 0x58, 0x50, 0x30, 0xDF, 0x38, 0x3A + }, + { + 0x98, 0xE7, 0xAF, 0x0A, 0xDF, 0xC4, 0xCA, 0x22, + 0xF2, 0xBC, 0x91, 0x60, 0x9F, 0x68, 0x86, 0x08, + 0x62, 0x8B, 0x89, 0xEC, 0xF6, 0xD0, 0xC2, 0x93, + 0x8A, 0x81, 0x9A, 0xEC, 0xEF, 0x9A, 0xAD, 0xAF + }, + { + 0xB5, 0x3B, 0x17, 0xF4, 0x4B, 0xE4, 0xA6, 0xE6, + 0x42, 0x66, 0xCE, 0x3C, 0x0A, 0x3E, 0xFD, 0xAB, + 0x75, 0x4C, 0x86, 0x91, 0x68, 0xBA, 0x7B, 0xDD, + 0x93, 0x49, 0x58, 0x8C, 0xB2, 0x31, 0x21, 0x71 + }, + { + 0xDE, 0x81, 0x7B, 0x43, 0x48, 0x2E, 0x21, 0x1A, + 0x95, 0x50, 0x67, 0xA0, 0x72, 0xE3, 0x32, 0x8F, + 0x56, 0xA7, 0x60, 0xBB, 0x06, 0xE5, 0x31, 0xB4, + 0x19, 0x29, 0x23, 0xDF, 0xE4, 0x40, 0x5B, 0x77 + }, + { + 0xD9, 0xB7, 0x75, 0xCF, 0x69, 0xF9, 0xF1, 0x56, + 0xF7, 0x42, 0x05, 0x91, 0x7F, 0xDA, 0x08, 0x25, + 0xC1, 0x97, 0x09, 0x71, 0x54, 0x06, 0x7A, 0x49, + 0xDF, 0x74, 0xC4, 0x64, 0x21, 0xF9, 0xD6, 0x92 + }, + { + 0x3B, 0x5D, 0xBF, 0x4A, 0x22, 0x64, 0xC0, 0xA8, + 0x04, 0x4B, 0x22, 0x05, 0xDE, 0x2D, 0x76, 0xBB, + 0x1E, 0x8D, 0xC0, 0x2E, 0x7B, 0x46, 0x6C, 0x2F, + 0x34, 0x18, 0x7B, 0xD0, 0x2E, 0x32, 0xB3, 0x56 + }, + { + 0x3F, 0x58, 0x71, 0xC1, 0x11, 0x00, 0x47, 0x1B, + 0xC1, 0x98, 0x7A, 0x0B, 0x94, 0xE4, 0x39, 0x3E, + 0xA5, 0x4A, 0xDA, 0x02, 0xF7, 0x28, 0x6E, 0x45, + 0x91, 0x56, 0x11, 0xC0, 0x3E, 0xB6, 0x89, 0x54 + }, + { + 0xBF, 0x7D, 0x40, 0xE7, 0x22, 0x85, 0xF3, 0x2C, + 0xF8, 0xE1, 0x5E, 0xEB, 0x94, 0xA5, 0x6F, 0xE9, + 0xB6, 0x07, 0x5A, 0x9C, 0xF9, 0xB5, 0xA7, 0x9F, + 0xAA, 0x27, 0x30, 0x26, 0xCD, 0xEF, 0x7B, 0xC1 + }, + { + 0xE7, 0x5D, 0x18, 0x02, 0x59, 0x24, 0xF6, 0x50, + 0x5B, 0x5D, 0xF0, 0xA9, 0xCC, 0x91, 0x71, 0x1A, + 0x14, 0xF6, 0x86, 0x63, 0x04, 0x39, 0xBB, 0x1A, + 0x39, 0x8B, 0x11, 0xB0, 0x09, 0xB0, 0x67, 0x4D + }, + { + 0x21, 0xEC, 0x2E, 0x6E, 0x9D, 0xC4, 0x47, 0x0A, + 0x96, 0x13, 0xC3, 0x7B, 0x99, 0x82, 0x9D, 0x4D, + 0x63, 0x3A, 0xC8, 0xCB, 0x46, 0xE9, 0x35, 0x19, + 0xA9, 0x53, 0x8B, 0x23, 0x99, 0x36, 0x90, 0x7A + }, + { + 0xCA, 0x4C, 0xC9, 0x47, 0xD1, 0x53, 0xA7, 0x6C, + 0x3D, 0x90, 0x85, 0x92, 0x69, 0x31, 0xEB, 0x04, + 0xCA, 0x22, 0x22, 0x24, 0x41, 0x1E, 0xA7, 0x36, + 0xB6, 0xE0, 0x4B, 0xFA, 0x7E, 0x7A, 0xF7, 0x38 + }, + { + 0x6D, 0xCE, 0xD6, 0xA2, 0x42, 0x9A, 0x88, 0x32, + 0x7C, 0x5A, 0xC8, 0xD8, 0xE7, 0x71, 0x79, 0xC2, + 0x43, 0xE7, 0x2F, 0xA2, 0x0B, 0xAC, 0x7D, 0x4A, + 0xEA, 0x53, 0x54, 0xFC, 0x62, 0x03, 0xCE, 0x95 + }, + { + 0x16, 0x0C, 0xF4, 0x38, 0x43, 0xAE, 0x34, 0xB0, + 0xAD, 0x1A, 0x4D, 0x07, 0xB9, 0x7E, 0x25, 0x1E, + 0x71, 0xBF, 0x62, 0x0E, 0xC7, 0xD0, 0x81, 0x7D, + 0x0F, 0x76, 0x3C, 0xD4, 0xAF, 0xCD, 0xFB, 0x9C + }, + { + 0xC7, 0x16, 0xF4, 0x16, 0x4F, 0x0E, 0xE6, 0x6E, + 0x7F, 0x83, 0xE7, 0xB0, 0x1E, 0x7E, 0xF1, 0xC2, + 0x39, 0x5F, 0x7C, 0xB0, 0xC9, 0x0B, 0x42, 0x73, + 0xAA, 0xE6, 0x43, 0x46, 0x34, 0x9A, 0x0F, 0xAE + }, + { + 0xA9, 0x58, 0x71, 0xBB, 0x3A, 0x51, 0x6F, 0x05, + 0xE4, 0xF8, 0xF6, 0x15, 0xF7, 0x5E, 0x83, 0xC5, + 0x97, 0x3B, 0xDD, 0x02, 0x4A, 0x81, 0xBE, 0x20, + 0x22, 0x0E, 0xEB, 0x6F, 0x94, 0x51, 0x5D, 0x42 + }, + { + 0x2B, 0x05, 0x49, 0xEB, 0x09, 0xD5, 0x0F, 0x28, + 0xFC, 0x71, 0xAE, 0x84, 0xE0, 0x6D, 0xE7, 0x71, + 0xCA, 0xB2, 0xF0, 0xD7, 0x7D, 0xCE, 0xA5, 0x1E, + 0xE3, 0x7C, 0x8F, 0x47, 0xE2, 0x06, 0xBD, 0xB5 + }, + { + 0xBF, 0xCC, 0x09, 0xCD, 0x8A, 0x07, 0xEC, 0x8F, + 0xA4, 0xD7, 0x87, 0xD5, 0xCF, 0x9C, 0xD4, 0x39, + 0x1D, 0x42, 0xBD, 0x0B, 0x2F, 0xEF, 0xB3, 0x55, + 0x03, 0x6B, 0x1F, 0xBB, 0x7F, 0x3B, 0x78, 0xCC + }, + { + 0x4C, 0x51, 0x44, 0x55, 0xF4, 0x48, 0xC4, 0xFA, + 0xD6, 0x84, 0x5D, 0x86, 0x87, 0xD6, 0x06, 0xC2, + 0xF2, 0xFB, 0x61, 0x89, 0xCB, 0xA6, 0x4A, 0xFA, + 0xAD, 0x88, 0x5D, 0x2F, 0xC3, 0x2F, 0x5C, 0xF8 + }, + { + 0x31, 0x97, 0x2E, 0x2F, 0x7E, 0xE1, 0x5B, 0x6B, + 0xBA, 0x2E, 0xC0, 0x04, 0xA4, 0x4E, 0x08, 0x01, + 0xE9, 0x21, 0x61, 0x84, 0x05, 0x76, 0xE0, 0x6A, + 0xAE, 0xBF, 0xD7, 0x68, 0xBA, 0xA5, 0xA2, 0x56 + }, + { + 0x10, 0x3A, 0xF8, 0x94, 0xFD, 0x47, 0x09, 0x44, + 0xEB, 0x8D, 0xDD, 0x13, 0x15, 0x47, 0x4D, 0xB2, + 0x12, 0x36, 0x8E, 0xAC, 0x64, 0x9E, 0xB9, 0x42, + 0x11, 0x98, 0x6A, 0x06, 0x14, 0x15, 0x17, 0x43 + }, + { + 0x59, 0x05, 0x80, 0x47, 0xA4, 0x02, 0x4B, 0x2F, + 0x7C, 0x29, 0x22, 0x5C, 0x41, 0x34, 0x5A, 0xF7, + 0x76, 0xCF, 0x06, 0xE4, 0xBA, 0xD1, 0x20, 0x57, + 0xB5, 0x69, 0x34, 0xE6, 0xDB, 0x35, 0x91, 0x18 + }, + { + 0x7C, 0x49, 0x23, 0x26, 0x93, 0x9A, 0x45, 0x21, + 0x89, 0x97, 0x21, 0xA1, 0x4B, 0x28, 0x4B, 0x36, + 0x13, 0x4C, 0x13, 0x0B, 0x40, 0xE4, 0x5E, 0x19, + 0xED, 0x62, 0xAF, 0xFD, 0xA0, 0xEE, 0x04, 0x88 + }, + { + 0x0E, 0xD5, 0xD7, 0x16, 0xC1, 0xA4, 0xA5, 0xE3, + 0x4A, 0xF5, 0x7A, 0xD6, 0xD9, 0x44, 0xCC, 0x6F, + 0x6D, 0x9B, 0xD1, 0x62, 0xBD, 0xF8, 0xB5, 0xAA, + 0x58, 0xBE, 0x62, 0xDD, 0x33, 0x25, 0x09, 0x8C + }, + { + 0x4F, 0xE7, 0xFE, 0x6B, 0x8C, 0x73, 0xB7, 0xAB, + 0xE4, 0xD7, 0x9E, 0x84, 0xF3, 0x3C, 0xD9, 0x0B, + 0x98, 0x1F, 0xDE, 0x22, 0x19, 0x19, 0xC6, 0xC6, + 0x5E, 0xBB, 0xE5, 0x0D, 0xBE, 0x84, 0x6F, 0x41 + }, + { + 0x58, 0x87, 0x63, 0x5D, 0x74, 0xE1, 0x1B, 0x25, + 0x3E, 0xA8, 0x33, 0xF5, 0xB0, 0x85, 0x00, 0xC6, + 0x66, 0x6C, 0xB3, 0xF8, 0xC9, 0xD0, 0x83, 0xBC, + 0x37, 0x3B, 0x8B, 0x4A, 0x1A, 0xE7, 0x90, 0x23 + }, + { + 0x3E, 0x57, 0x72, 0xCF, 0xB1, 0x19, 0x3E, 0x63, + 0xA8, 0xE9, 0x37, 0xFA, 0x66, 0xEC, 0xB3, 0x2B, + 0xEF, 0x66, 0x05, 0xF6, 0x5E, 0x76, 0xA9, 0x00, + 0x25, 0x23, 0x71, 0x56, 0xAD, 0xC9, 0xA6, 0xF8 + }, + { + 0x9F, 0x99, 0x21, 0xBE, 0x35, 0x37, 0x09, 0x9D, + 0xDB, 0xC5, 0xFE, 0xA1, 0xE1, 0xDB, 0x4D, 0xAF, + 0x9C, 0xE8, 0x45, 0x9F, 0xAF, 0xAD, 0x9F, 0x33, + 0xD2, 0x3C, 0x07, 0x05, 0x8D, 0x45, 0x54, 0x4A + }, + { + 0x29, 0x15, 0xAB, 0x35, 0x28, 0x8B, 0xD2, 0x36, + 0x70, 0xCC, 0x3C, 0xE5, 0x13, 0x4D, 0x20, 0x77, + 0xE5, 0x56, 0x79, 0xEE, 0x9A, 0xEB, 0xBE, 0x83, + 0xAB, 0xED, 0x23, 0xF4, 0xF0, 0xEA, 0xC3, 0xCE + }, + { + 0xFE, 0x78, 0xB5, 0x0D, 0x0F, 0xDE, 0xAC, 0x1D, + 0x11, 0x11, 0x06, 0x32, 0x9E, 0x60, 0x12, 0xCA, + 0xB3, 0x18, 0xAD, 0x11, 0x53, 0xF3, 0xA9, 0xBB, + 0xE6, 0x7A, 0x75, 0x1B, 0x8A, 0x5D, 0x77, 0x6E + }, + { + 0xF6, 0xA9, 0x25, 0xD6, 0x14, 0x35, 0xF2, 0xEA, + 0xE5, 0xFD, 0x8D, 0x73, 0x2E, 0x0E, 0x7D, 0xFF, + 0x80, 0x70, 0xC6, 0x26, 0x7D, 0x97, 0x66, 0x48, + 0x0C, 0xAA, 0x2D, 0x81, 0xEB, 0x9F, 0x4F, 0x55 + }, + { + 0x92, 0x18, 0x25, 0x65, 0xA8, 0x83, 0xCC, 0x2F, + 0xAB, 0x7F, 0x4F, 0xD8, 0x70, 0x4A, 0x64, 0x22, + 0x8A, 0x7D, 0x28, 0xFB, 0xD2, 0x3F, 0x88, 0xAD, + 0xC7, 0xE5, 0xFE, 0x45, 0xB3, 0x78, 0xFE, 0x73 + }, + { + 0x1C, 0x02, 0x09, 0xC8, 0xAE, 0xC0, 0x76, 0x2A, + 0xBE, 0x49, 0xCE, 0x76, 0xF3, 0xDE, 0xAC, 0xB3, + 0x71, 0xCA, 0x9C, 0xAA, 0x03, 0xE5, 0x80, 0x2D, + 0x6E, 0x8F, 0x97, 0x8D, 0xCD, 0xA3, 0x00, 0x85 + }, + { + 0xD7, 0xBA, 0xBB, 0x44, 0x79, 0x23, 0xEE, 0xAE, + 0xDE, 0x34, 0x01, 0xAB, 0xB4, 0x29, 0x51, 0x8B, + 0xD8, 0xC3, 0x0C, 0x67, 0x5A, 0xB3, 0xDF, 0x54, + 0x54, 0x5E, 0x05, 0x47, 0x42, 0x34, 0x67, 0x60 + }, + { + 0x44, 0x49, 0x2C, 0x9E, 0x49, 0x93, 0x3E, 0xFD, + 0x92, 0x5E, 0xA4, 0xAE, 0x1D, 0xA8, 0x56, 0x1A, + 0x04, 0xDE, 0x05, 0xB2, 0x72, 0x2D, 0x71, 0xF3, + 0x93, 0x2A, 0xBD, 0xD0, 0xCF, 0xC3, 0x87, 0x14 + }, + { + 0xC2, 0x75, 0xA0, 0xED, 0x1B, 0xF7, 0xFC, 0x8B, + 0x19, 0x33, 0xEE, 0x6D, 0x14, 0x61, 0x76, 0xA3, + 0xD6, 0x1C, 0x11, 0xF9, 0x6D, 0xBE, 0x6B, 0xBB, + 0x0A, 0x38, 0xFC, 0x30, 0x7A, 0xE7, 0xC7, 0x5A + }, + { + 0x07, 0x09, 0x61, 0x4B, 0xA2, 0xA3, 0xF5, 0x23, + 0x0C, 0x15, 0x54, 0x41, 0x7D, 0xE9, 0xE5, 0xF3, + 0x84, 0xC9, 0xED, 0x15, 0x04, 0xFF, 0x60, 0x18, + 0x99, 0x07, 0xC4, 0x6D, 0x76, 0x3C, 0xE7, 0x0B + }, + { + 0x01, 0x8E, 0xFC, 0x79, 0x59, 0x1A, 0x04, 0x32, + 0x57, 0x42, 0x92, 0x1B, 0x77, 0xE5, 0x05, 0x65, + 0x5F, 0xDE, 0x8C, 0x99, 0xCD, 0x30, 0xDE, 0x5F, + 0x8B, 0x45, 0xEE, 0x7F, 0x84, 0xE6, 0x8E, 0xCF + }, + { + 0x1C, 0xDC, 0xA1, 0x76, 0xBB, 0x97, 0x79, 0x38, + 0x52, 0x1E, 0x7A, 0x24, 0x2E, 0x57, 0xC1, 0x15, + 0xA8, 0x06, 0xF4, 0x81, 0xC2, 0x97, 0x6F, 0x54, + 0x09, 0x84, 0x2D, 0xB7, 0x0F, 0xEA, 0x27, 0x2B + }, + { + 0xBC, 0x9D, 0xD0, 0xD2, 0x69, 0xC5, 0xAD, 0x67, + 0x0F, 0xCF, 0x37, 0xAA, 0x0B, 0xF1, 0x6F, 0x8B, + 0xCE, 0xD2, 0x34, 0x50, 0xE9, 0xB2, 0x64, 0xA9, + 0xD3, 0xC9, 0xA5, 0x58, 0x46, 0x82, 0x75, 0xAF + }, + { + 0x7F, 0x61, 0x17, 0x6E, 0x33, 0xA8, 0x24, 0x06, + 0x55, 0xAE, 0x25, 0x5E, 0xFD, 0x06, 0x3E, 0xA1, + 0x1B, 0x9E, 0xB1, 0x15, 0xE9, 0x32, 0x39, 0x08, + 0x68, 0xC6, 0x41, 0x08, 0x29, 0xB4, 0x0D, 0x2B + }, + { + 0xD5, 0x78, 0x2D, 0xDE, 0x96, 0x03, 0x0F, 0x70, + 0x56, 0x9A, 0xEC, 0xE1, 0x8C, 0xDE, 0x6C, 0x7F, + 0xF8, 0x75, 0xD8, 0xF6, 0xAE, 0x0B, 0xB2, 0xE4, + 0x98, 0x37, 0xB6, 0x78, 0x1C, 0x5F, 0x85, 0x9C + }, + { + 0x1E, 0x0E, 0xA3, 0x47, 0x61, 0xB4, 0x53, 0xEB, + 0x6D, 0x92, 0x50, 0x4F, 0xBC, 0xA3, 0x8D, 0x2D, + 0x78, 0xCC, 0x69, 0x2C, 0x4A, 0xDE, 0x9E, 0x32, + 0xB3, 0xE0, 0x9A, 0x32, 0x26, 0xDA, 0xBD, 0x80 + }, + { + 0xF0, 0x80, 0x4E, 0x19, 0x93, 0x9F, 0xC3, 0x0C, + 0xA8, 0x59, 0x93, 0x36, 0xE0, 0x3F, 0xB6, 0x9C, + 0xEC, 0xAC, 0x0C, 0xC4, 0x52, 0x91, 0x44, 0x45, + 0xEF, 0xB1, 0xA5, 0xFB, 0xE7, 0x91, 0x97, 0x16 + }, + { + 0xD0, 0xCD, 0x17, 0x67, 0x74, 0x54, 0x67, 0x0B, + 0x7E, 0x5E, 0x5F, 0xE3, 0x0A, 0x6D, 0x17, 0xE7, + 0x78, 0x6F, 0xE5, 0xA7, 0xC8, 0xE8, 0x01, 0xD3, + 0xBE, 0xA3, 0xD4, 0x93, 0xD0, 0x86, 0xF7, 0x70 + }, + { + 0x1C, 0xCE, 0x46, 0x34, 0xE0, 0x33, 0xDE, 0xB4, + 0xE3, 0x4B, 0x34, 0x38, 0x5B, 0x71, 0x41, 0x15, + 0x68, 0x8E, 0x9C, 0xAB, 0x21, 0x0A, 0xA6, 0xA5, + 0x7F, 0xFE, 0x07, 0x39, 0xD5, 0xAB, 0x4E, 0xB3 + }, + { + 0x6C, 0x15, 0xD4, 0x78, 0x35, 0xBD, 0xC7, 0x3B, + 0xA6, 0xCE, 0x2D, 0xC9, 0x44, 0x70, 0x48, 0xAE, + 0x3C, 0x0A, 0xB5, 0xF9, 0xB1, 0x73, 0x00, 0xFF, + 0x79, 0x9D, 0x2D, 0xE5, 0x82, 0x8A, 0xE5, 0x98 + }, + { + 0xA5, 0x68, 0x1A, 0x36, 0x57, 0xCC, 0x18, 0xC1, + 0x4A, 0x53, 0x89, 0x0D, 0xDA, 0xAD, 0xC0, 0x22, + 0xD0, 0x9F, 0x14, 0x01, 0x0C, 0xFE, 0x60, 0x82, + 0x8E, 0x41, 0x20, 0x79, 0x99, 0x67, 0xEF, 0x79 + }, + { + 0x66, 0xA2, 0xD0, 0x94, 0x45, 0x8B, 0xA4, 0x23, + 0x25, 0x23, 0xD1, 0xC4, 0x2C, 0x42, 0xF4, 0xC1, + 0xAC, 0xB3, 0x47, 0xDC, 0xD7, 0x54, 0x09, 0xBF, + 0x96, 0xCC, 0x62, 0xE2, 0xF4, 0xDB, 0x82, 0xD4 + }, + { + 0x93, 0xF4, 0xC1, 0x7D, 0xEC, 0xDC, 0x20, 0xA4, + 0xF3, 0x84, 0xEA, 0x16, 0x5D, 0x29, 0xEA, 0xC9, + 0xAA, 0x4A, 0xD9, 0x12, 0x19, 0xAA, 0x9D, 0x93, + 0x3D, 0xE8, 0x54, 0x26, 0x8D, 0xCD, 0xAA, 0x91 + }, + { + 0x71, 0x2D, 0x13, 0x66, 0x63, 0x79, 0x97, 0xEF, + 0xDD, 0x04, 0x8F, 0x27, 0x0B, 0x3F, 0x7F, 0xDC, + 0xB9, 0x54, 0x12, 0xA7, 0xA7, 0x34, 0x55, 0xE4, + 0xBB, 0xA9, 0x29, 0x25, 0x7C, 0x55, 0x8A, 0xA6 + }, + { + 0xD0, 0x63, 0xBB, 0x4A, 0x4E, 0xCA, 0x7E, 0xD4, + 0x88, 0x03, 0x79, 0xB8, 0x11, 0xAE, 0x82, 0xB9, + 0xEE, 0xB5, 0x83, 0xE9, 0x31, 0xAC, 0xBD, 0x50, + 0x7B, 0xE8, 0x94, 0x70, 0x54, 0x3F, 0xCB, 0xDB + }, + { + 0x88, 0x16, 0x80, 0xBB, 0xC3, 0x7D, 0xBB, 0xFA, + 0xDF, 0x5E, 0xA1, 0xAD, 0xE0, 0xA7, 0xB0, 0x39, + 0xBD, 0xCE, 0xB2, 0x22, 0xF0, 0x04, 0x0E, 0x86, + 0xB7, 0x48, 0x55, 0x2A, 0xDA, 0x01, 0xC2, 0x99 + }, + { + 0xD1, 0x6D, 0xCC, 0xEB, 0x68, 0xCD, 0x11, 0xBD, + 0x7F, 0x54, 0x6D, 0x3D, 0xB1, 0xD7, 0xCE, 0x24, + 0x13, 0x2B, 0x29, 0x97, 0xAF, 0x88, 0xDA, 0x27, + 0xB5, 0x58, 0x1F, 0x5F, 0x74, 0xF2, 0x21, 0x74 + }, + { + 0xBE, 0xF1, 0x82, 0xC5, 0x86, 0xFD, 0x83, 0xBE, + 0xC6, 0xDC, 0x58, 0xE0, 0x60, 0xD2, 0x9D, 0x09, + 0xA6, 0x02, 0xB0, 0x39, 0x42, 0x44, 0xF8, 0x90, + 0xBB, 0x62, 0x18, 0xD1, 0x7F, 0xBB, 0xC4, 0xB4 + }, + { + 0x52, 0xB2, 0xCC, 0x81, 0x6A, 0x8B, 0x78, 0x7D, + 0x75, 0x81, 0x16, 0x34, 0xF6, 0x9D, 0xA5, 0xB1, + 0x8D, 0x1C, 0x44, 0x33, 0xDF, 0x03, 0x8C, 0xE9, + 0x53, 0xF5, 0x5A, 0x20, 0xAD, 0x17, 0x69, 0xDC + }, + { + 0xE4, 0xA4, 0xF8, 0x16, 0x9E, 0x15, 0xE6, 0x8E, + 0x6D, 0x28, 0x50, 0x46, 0xD7, 0x99, 0x39, 0x19, + 0xB3, 0xF9, 0xA2, 0x42, 0x64, 0xF8, 0x9C, 0x40, + 0x00, 0x0B, 0xE7, 0x65, 0x17, 0xED, 0x03, 0xB3 + }, + { + 0xB8, 0x86, 0x52, 0x65, 0x43, 0xEE, 0x19, 0x5F, + 0x87, 0xBF, 0x2C, 0x72, 0x1F, 0x2B, 0xDC, 0x85, + 0x4E, 0x2F, 0x0B, 0xAD, 0x43, 0xF0, 0x6F, 0xC8, + 0x9B, 0x6D, 0x87, 0x38, 0x8D, 0xAF, 0x5D, 0x1B + }, + { + 0xB8, 0x6C, 0x6D, 0x4C, 0x3E, 0x7B, 0x4A, 0xB3, + 0x21, 0xB8, 0x94, 0xB0, 0x24, 0x39, 0xFE, 0x22, + 0x55, 0x60, 0x58, 0x26, 0x6B, 0x01, 0xD0, 0x10, + 0xDA, 0x32, 0x14, 0xE3, 0x53, 0xA6, 0x82, 0x7E + }, + { + 0x5D, 0xC5, 0x8B, 0xEA, 0x1E, 0x0B, 0xC9, 0x46, + 0x09, 0x86, 0x70, 0x7E, 0xFD, 0xD2, 0x87, 0xBA, + 0x95, 0xDD, 0x07, 0x66, 0xB3, 0x72, 0xAC, 0x8A, + 0x07, 0x30, 0x97, 0xCC, 0x9F, 0x50, 0x7E, 0x89 + }, + { + 0x32, 0x12, 0xDC, 0x63, 0xF6, 0xFD, 0xE2, 0x0B, + 0xB5, 0x0A, 0x36, 0x91, 0xC3, 0x4B, 0x02, 0x67, + 0x20, 0xBB, 0xDD, 0xDB, 0xB7, 0x33, 0x20, 0x36, + 0xCC, 0x33, 0x21, 0x43, 0xE2, 0xCC, 0x39, 0x33 + }, + { + 0x2E, 0xC0, 0x2D, 0xBF, 0x7B, 0xDA, 0xD5, 0x34, + 0x26, 0x51, 0x3F, 0xB6, 0xA6, 0x3C, 0xB0, 0xCA, + 0x6D, 0x7D, 0xB2, 0x8D, 0xA9, 0x81, 0x7F, 0xBA, + 0x94, 0x98, 0x36, 0x75, 0x0A, 0xEA, 0x15, 0xCA + }, + { + 0x43, 0x33, 0x02, 0x64, 0x82, 0x68, 0x8B, 0xC3, + 0x9B, 0x22, 0xFC, 0x69, 0x50, 0x74, 0xC5, 0xC3, + 0xBA, 0x22, 0xC3, 0x38, 0x32, 0x00, 0x6C, 0xC9, + 0xDE, 0x70, 0x60, 0x4F, 0x24, 0xE9, 0xF5, 0x6E + }, + { + 0xC5, 0xB3, 0x14, 0x6C, 0xCC, 0x07, 0x51, 0x24, + 0x8C, 0x57, 0x65, 0xE2, 0x39, 0x66, 0x5E, 0x55, + 0x6C, 0x63, 0xF8, 0xDB, 0x88, 0x24, 0x90, 0x99, + 0x75, 0x19, 0x19, 0xC2, 0xDD, 0xA7, 0xC2, 0x8A + }, + { + 0x8F, 0xF2, 0xE8, 0x29, 0x03, 0x02, 0x1D, 0x16, + 0xEB, 0xD5, 0xDC, 0x12, 0xFA, 0x93, 0x87, 0xC3, + 0x24, 0xDB, 0x37, 0x90, 0x9D, 0x45, 0x72, 0xFF, + 0x59, 0xB4, 0x2F, 0x1A, 0x98, 0x72, 0x7D, 0x4B + }, + { + 0x9E, 0xB8, 0x26, 0x27, 0xE1, 0xBE, 0x7E, 0xEE, + 0x1E, 0x2B, 0x29, 0xCD, 0xEB, 0xBC, 0xB4, 0x88, + 0xA2, 0xB4, 0xF8, 0x90, 0xD3, 0xAC, 0x62, 0x9E, + 0xE6, 0x8B, 0x34, 0xBA, 0x69, 0x73, 0xD2, 0xC6 + }, + { + 0xD1, 0xBC, 0x54, 0x21, 0xEE, 0xD4, 0xE3, 0x2E, + 0x7E, 0xD2, 0xE6, 0xFA, 0x7C, 0xEA, 0x24, 0xF9, + 0x60, 0x95, 0x01, 0x27, 0x7C, 0xB9, 0x3E, 0xB8, + 0xD0, 0x20, 0x22, 0x7A, 0x34, 0xB5, 0xA0, 0x20 + }, + { + 0x79, 0x31, 0x52, 0xFE, 0xA2, 0x4F, 0x67, 0x0C, + 0x7B, 0xF4, 0x70, 0x4C, 0xAD, 0x01, 0xC2, 0x01, + 0x7A, 0xDF, 0xC8, 0x64, 0x78, 0xB6, 0xCB, 0x83, + 0x07, 0x18, 0x85, 0x52, 0x36, 0xB9, 0xAC, 0x54 + }, + { + 0xD7, 0xE9, 0x23, 0x3C, 0xAB, 0x65, 0xEE, 0x2B, + 0x2D, 0xA0, 0x2C, 0x99, 0x7E, 0xDB, 0x67, 0x14, + 0xF5, 0x55, 0x75, 0xFD, 0x56, 0x5B, 0xDD, 0x17, + 0xB4, 0x76, 0x80, 0x97, 0xD1, 0xDB, 0x7B, 0x69 + }, + { + 0x8A, 0x2D, 0x43, 0xCE, 0x3D, 0xD6, 0xE5, 0x60, + 0x2A, 0x91, 0x13, 0xC7, 0x15, 0x6D, 0x98, 0x1F, + 0xFB, 0x23, 0x63, 0xA4, 0x0B, 0x92, 0x63, 0xCB, + 0x3B, 0x9E, 0x9D, 0x11, 0x9A, 0xF5, 0xCD, 0xCA + }, + { + 0x82, 0x6B, 0xE7, 0x23, 0x0F, 0x1F, 0x02, 0x15, + 0xF1, 0x16, 0x56, 0x80, 0x25, 0xE5, 0xEA, 0xA1, + 0xB2, 0xB0, 0xFF, 0xD6, 0xE8, 0x18, 0x4A, 0x1F, + 0x00, 0x4A, 0xA0, 0x18, 0xA5, 0xFE, 0x65, 0x4C + }, + { + 0x4E, 0x1E, 0xC2, 0x71, 0x89, 0xA1, 0x9D, 0x7C, + 0x36, 0xDD, 0x69, 0x3E, 0x71, 0x1E, 0xEF, 0x20, + 0xB1, 0xC4, 0xA3, 0x23, 0x78, 0x3F, 0xC3, 0xDB, + 0x8F, 0x02, 0xCD, 0x73, 0xC3, 0x79, 0xB5, 0x1F + }, + { + 0xF3, 0xED, 0x38, 0x9B, 0xD4, 0x4D, 0x45, 0x7C, + 0xD9, 0xC9, 0x43, 0xA2, 0x15, 0x7D, 0xF7, 0xC6, + 0x44, 0x89, 0x38, 0x4B, 0x0E, 0x1A, 0xD7, 0xA1, + 0x17, 0xDE, 0xCF, 0xF7, 0xF0, 0x21, 0xA3, 0xB6 + }, + { + 0xE1, 0x6E, 0xEE, 0x4F, 0x1B, 0x5E, 0xC2, 0x51, + 0xC2, 0xF9, 0x3E, 0xC7, 0x2D, 0x29, 0xBD, 0x6C, + 0xAC, 0x81, 0x1E, 0x0D, 0xB3, 0x34, 0x39, 0x59, + 0x3B, 0xC0, 0xE3, 0x9A, 0x4C, 0xBD, 0x9D, 0xCF + }, + { + 0x3E, 0x66, 0x75, 0xB8, 0x4B, 0x65, 0x92, 0x06, + 0x43, 0xE1, 0xDF, 0x64, 0x3E, 0x64, 0xFC, 0xEC, + 0x91, 0x62, 0x3F, 0x66, 0xEB, 0xCA, 0x5E, 0xC1, + 0xFC, 0xBE, 0x71, 0x68, 0x3C, 0xCA, 0x8A, 0x11 + }, + { + 0x7D, 0x5A, 0x82, 0x81, 0x92, 0xB7, 0x4A, 0x39, + 0x91, 0x2B, 0xC8, 0x10, 0x9C, 0xA7, 0xE3, 0x3A, + 0x27, 0x55, 0x37, 0xDB, 0x0D, 0x0E, 0x13, 0x06, + 0x7C, 0x13, 0xE7, 0x61, 0x9C, 0x36, 0x78, 0x8B + }, + { + 0xC0, 0x6D, 0xC5, 0x6D, 0x09, 0x27, 0xD7, 0x6C, + 0x05, 0xAC, 0xD4, 0xCB, 0x46, 0x28, 0x3B, 0xAA, + 0xD5, 0x0B, 0x32, 0xDA, 0x5B, 0x99, 0x29, 0xCF, + 0x08, 0xAA, 0x7A, 0xE0, 0xF0, 0x5D, 0xA9, 0xE1 + }, + { + 0x7B, 0x61, 0x31, 0x4C, 0xA3, 0x03, 0x77, 0x91, + 0x7A, 0x62, 0xCE, 0x29, 0xC7, 0x94, 0x8B, 0x3B, + 0xB0, 0xC9, 0x67, 0xCC, 0x2A, 0xA2, 0x74, 0x9C, + 0x44, 0x24, 0x6E, 0x36, 0x93, 0x2E, 0x59, 0xAE + }, + { + 0x6C, 0x85, 0x2D, 0xA4, 0x13, 0xEC, 0x68, 0x7A, + 0x11, 0x69, 0x4A, 0xE1, 0xEA, 0x21, 0xC5, 0x33, + 0x82, 0xC1, 0x99, 0xF9, 0x2E, 0x66, 0x04, 0x54, + 0x42, 0x69, 0x0C, 0xEB, 0x57, 0x05, 0x91, 0xA0 + }, + { + 0x7B, 0x02, 0x6A, 0x04, 0x76, 0x57, 0xBE, 0x48, + 0x35, 0x46, 0xF4, 0xB7, 0x14, 0x00, 0x78, 0x29, + 0xBF, 0x46, 0x23, 0x88, 0xA0, 0xFA, 0x46, 0x67, + 0xAE, 0x10, 0x52, 0x86, 0x37, 0x46, 0x60, 0x83 + }, + { + 0x60, 0x22, 0xC1, 0x68, 0x42, 0x30, 0x72, 0x8F, + 0xE6, 0xE9, 0xF1, 0x94, 0xC6, 0xB0, 0x15, 0xA8, + 0xDC, 0x24, 0xEE, 0xEA, 0x2B, 0x01, 0xE5, 0xFD, + 0xDB, 0xF1, 0x48, 0xCE, 0xD3, 0x07, 0x25, 0x3E + }, + { + 0xAD, 0x82, 0x67, 0xB8, 0x14, 0x96, 0xFE, 0x5A, + 0x8F, 0x12, 0x86, 0x04, 0xEC, 0x3F, 0x0A, 0xD8, + 0xF5, 0xA4, 0xC7, 0x05, 0x95, 0x80, 0xEA, 0x4D, + 0xD4, 0x4C, 0x6C, 0x42, 0xC7, 0xEF, 0x8D, 0xE6 + }, + { + 0x21, 0x8A, 0xC0, 0xDA, 0x83, 0xFA, 0xE7, 0x42, + 0x45, 0xA6, 0xC6, 0x36, 0x09, 0xB9, 0xD1, 0x52, + 0x8C, 0xD7, 0x27, 0xE7, 0xDC, 0x7B, 0xB3, 0x29, + 0x4E, 0xD9, 0x4C, 0x70, 0x83, 0x2D, 0x3A, 0x34 + }, + { + 0x41, 0x99, 0xE1, 0x4A, 0xF4, 0x01, 0xB6, 0xD0, + 0x68, 0x21, 0xCF, 0x6F, 0x51, 0xB3, 0x94, 0xCC, + 0xBA, 0x57, 0xDA, 0x93, 0x98, 0xF2, 0x0F, 0x49, + 0xAC, 0xC6, 0x46, 0x1A, 0x13, 0x50, 0xE2, 0x1B + }, + { + 0x81, 0x32, 0xC2, 0x14, 0xBA, 0xD8, 0xF9, 0xF6, + 0xA5, 0x4D, 0xD3, 0x2C, 0x81, 0xD1, 0xCA, 0xA0, + 0xDE, 0xAA, 0xF1, 0x72, 0x59, 0xAE, 0x38, 0x7F, + 0xA2, 0x3D, 0x85, 0xC9, 0x6F, 0x25, 0xDB, 0x73 + }, + { + 0x68, 0x3C, 0x79, 0x02, 0x20, 0xDD, 0x46, 0x6F, + 0xB9, 0x2E, 0x30, 0xE0, 0x89, 0xB5, 0x23, 0xA5, + 0x4E, 0xEB, 0xF3, 0xF8, 0x51, 0xCE, 0x85, 0x29, + 0x14, 0x99, 0xBD, 0x3F, 0x9B, 0xEE, 0xF3, 0xF6 + }, + { + 0x83, 0xD8, 0xBA, 0x5B, 0x70, 0x36, 0xDA, 0x66, + 0x0A, 0x00, 0x2E, 0x43, 0x22, 0xF7, 0xD8, 0x0C, + 0x9C, 0xD4, 0xEA, 0xDC, 0x03, 0xB3, 0xBA, 0xC1, + 0xD3, 0x73, 0xFC, 0xA0, 0xBC, 0x25, 0x1E, 0x75 + }, + { + 0x2D, 0x60, 0xFC, 0xDC, 0xDA, 0x2A, 0xDA, 0x10, + 0x91, 0x16, 0x68, 0x8E, 0xEA, 0x34, 0xC7, 0x60, + 0xA1, 0xF6, 0x94, 0x48, 0x23, 0x2E, 0xAA, 0x21, + 0x9F, 0x4D, 0x42, 0x80, 0xE4, 0x08, 0xFE, 0xED + }, + { + 0xE8, 0xCA, 0xEB, 0xDE, 0xE4, 0xE7, 0xE1, 0xD7, + 0x18, 0x23, 0x82, 0xB5, 0xE5, 0x53, 0x51, 0x4D, + 0x7C, 0xD3, 0x0C, 0xEF, 0x03, 0x48, 0x6B, 0x5C, + 0x45, 0x37, 0x84, 0xB0, 0xE7, 0xF2, 0xCF, 0x70 + }, + { + 0x0D, 0xBA, 0x2E, 0x10, 0x39, 0xA3, 0xBA, 0xBD, + 0x81, 0x73, 0x8F, 0xC4, 0x2C, 0x42, 0x92, 0x34, + 0x04, 0x18, 0x26, 0x59, 0x91, 0xEE, 0x9C, 0xE0, + 0x88, 0x42, 0x44, 0x40, 0x59, 0xB5, 0x38, 0x5C + }, + { + 0x77, 0x64, 0x31, 0x27, 0x91, 0x47, 0x98, 0x7A, + 0x31, 0x59, 0x67, 0x52, 0xC1, 0xA5, 0x36, 0x12, + 0xF3, 0x88, 0x09, 0x2A, 0xDB, 0x14, 0x59, 0xA8, + 0xA1, 0x2D, 0x49, 0x34, 0x62, 0x63, 0x9D, 0xF5 + }, + { + 0x54, 0x38, 0x0A, 0x76, 0xF2, 0xDF, 0x8C, 0x08, + 0x19, 0xA8, 0xCA, 0x26, 0xE8, 0x47, 0x3D, 0x38, + 0x6F, 0x93, 0x08, 0xB0, 0x7A, 0x39, 0x89, 0xEB, + 0x44, 0x57, 0x27, 0xB4, 0x7C, 0x0B, 0x4D, 0x06 + }, + { + 0x78, 0xEA, 0xC0, 0xE0, 0x4F, 0x3A, 0x1E, 0xD2, + 0x31, 0xBA, 0x1E, 0x90, 0x98, 0x7A, 0xF1, 0x26, + 0x16, 0x37, 0x6A, 0x58, 0x2C, 0x01, 0xFC, 0xA2, + 0x5C, 0xB4, 0xBD, 0x3D, 0x33, 0x96, 0xA7, 0xCB + }, + { + 0x3C, 0x2A, 0x5E, 0xED, 0xE0, 0x72, 0xBC, 0x2E, + 0x6F, 0x0C, 0x11, 0x4B, 0xFB, 0xB1, 0x61, 0xD3, + 0x07, 0x19, 0x99, 0x4E, 0x13, 0x5B, 0x4E, 0x84, + 0xEF, 0x2E, 0x6E, 0x38, 0x55, 0xE3, 0x7F, 0xA2 + }, + { + 0x11, 0x99, 0x23, 0xF2, 0x23, 0x07, 0xBC, 0x3F, + 0x58, 0xBA, 0xE1, 0x0A, 0xB8, 0x80, 0x6B, 0x27, + 0x3C, 0xA2, 0x77, 0x15, 0x77, 0x3F, 0x58, 0x63, + 0x81, 0x1C, 0x0D, 0xFA, 0xB1, 0x70, 0xF1, 0x69 + }, + { + 0xB4, 0xE0, 0xC1, 0x9B, 0x86, 0x92, 0x9A, 0x78, + 0xCA, 0x17, 0xCB, 0x00, 0x54, 0x01, 0xA2, 0x2F, + 0x2D, 0xFD, 0xD0, 0x33, 0xA3, 0xB1, 0xB6, 0x9F, + 0x8E, 0x88, 0x2E, 0x9F, 0x4F, 0x82, 0x6F, 0xA8 + }, + { + 0xCD, 0x96, 0x40, 0x20, 0x40, 0x7C, 0x2C, 0x66, + 0x88, 0x97, 0x6B, 0xCF, 0x55, 0x52, 0xA7, 0xBB, + 0x31, 0xB1, 0xCF, 0x84, 0x2C, 0xBC, 0x60, 0xCF, + 0x76, 0x20, 0xB8, 0xB5, 0x18, 0x1B, 0xDC, 0xC5 + }, + { + 0x96, 0x79, 0x3B, 0x7E, 0x61, 0xED, 0xBC, 0x55, + 0xD7, 0xFA, 0x06, 0x68, 0x28, 0xCC, 0x5D, 0xBA, + 0xCE, 0xA7, 0x61, 0x31, 0xD4, 0xAF, 0x5F, 0x41, + 0x9F, 0x14, 0x5D, 0x9F, 0x3E, 0x6C, 0xEE, 0xAE + }, + { + 0x96, 0xB7, 0xBC, 0xCC, 0x1A, 0x9B, 0x66, 0x7C, + 0xE2, 0x46, 0x96, 0xE1, 0x44, 0xB1, 0xA0, 0x6B, + 0x43, 0x6E, 0x92, 0x33, 0x27, 0x79, 0xD3, 0x4B, + 0xDC, 0xF9, 0xE4, 0x17, 0x7F, 0x08, 0x9B, 0x01 + }, + { + 0x90, 0x3E, 0xEB, 0xE7, 0xF9, 0x9D, 0xA5, 0xE4, + 0x6C, 0x04, 0x61, 0x1B, 0xA5, 0x9F, 0x08, 0x1F, + 0x6E, 0x36, 0xE0, 0x54, 0xF7, 0x96, 0x27, 0x18, + 0x8D, 0x97, 0x8D, 0x85, 0xCB, 0xCB, 0x72, 0x69 + }, + { + 0xE4, 0x7D, 0x57, 0x56, 0x61, 0x72, 0x4B, 0x58, + 0x25, 0xDF, 0x03, 0x18, 0xF5, 0xE9, 0x20, 0x2C, + 0xC5, 0x68, 0x74, 0x69, 0xD3, 0x0B, 0x22, 0x43, + 0xDD, 0xCD, 0xB7, 0x96, 0x58, 0x34, 0xAE, 0xAB + }, + { + 0x94, 0x9C, 0x37, 0xE5, 0x83, 0xCA, 0xB6, 0x14, + 0x27, 0xD3, 0x0E, 0xA1, 0xC5, 0x55, 0x6E, 0x2B, + 0x11, 0x77, 0xE2, 0x0B, 0x1E, 0x28, 0x6C, 0xFF, + 0xBD, 0xD9, 0x48, 0x87, 0xAC, 0xCF, 0xDF, 0x74 + }, + { + 0x51, 0x32, 0xDF, 0x51, 0x17, 0xEE, 0xA9, 0x4D, + 0xAE, 0xC5, 0xE6, 0x6F, 0xCA, 0xFC, 0x60, 0x9D, + 0x74, 0x73, 0x0C, 0x57, 0x1A, 0xE1, 0x80, 0xBA, + 0x98, 0xF8, 0x1C, 0x70, 0x56, 0x30, 0x0E, 0x11 + }, + { + 0x0A, 0xFD, 0xAB, 0xE8, 0x89, 0x2A, 0xBB, 0x80, + 0x78, 0x68, 0xA1, 0x50, 0x9F, 0x06, 0x0F, 0xA8, + 0x8C, 0x34, 0x8B, 0xEF, 0xCA, 0x82, 0x1E, 0x4F, + 0xF6, 0xEA, 0x22, 0xCD, 0x19, 0x4F, 0xF7, 0xBB + }, + { + 0x7D, 0x51, 0xAF, 0x96, 0x7D, 0x98, 0x85, 0xB2, + 0x64, 0x83, 0x1A, 0x6D, 0xB1, 0x99, 0x3D, 0x32, + 0x35, 0xA4, 0x62, 0x80, 0x2B, 0x1C, 0xAF, 0x69, + 0xE3, 0xFD, 0x32, 0xF2, 0x41, 0x10, 0xB0, 0xD2 + }, + { + 0x8F, 0xDF, 0xF8, 0xE1, 0x89, 0x26, 0xB2, 0x73, + 0x2A, 0x75, 0x6E, 0xD4, 0x30, 0x63, 0x48, 0xD6, + 0xCA, 0x73, 0x3D, 0xE2, 0x7B, 0xF8, 0x52, 0xED, + 0x4E, 0xE0, 0x56, 0x03, 0xFB, 0xE6, 0xF7, 0x6C + }, + { + 0x82, 0xD6, 0x04, 0xB1, 0xE9, 0xC7, 0x63, 0x2C, + 0xF6, 0xE9, 0xA7, 0x28, 0x31, 0x29, 0x80, 0x98, + 0x4B, 0x0A, 0x10, 0x5B, 0xC4, 0x8E, 0x07, 0x8E, + 0xB0, 0x23, 0x34, 0x84, 0xD0, 0xA8, 0x7C, 0xF4 + }, + { + 0x00, 0x59, 0x1A, 0xE1, 0x4E, 0x3D, 0xEB, 0x9C, + 0x9F, 0x11, 0x4C, 0xCC, 0xC3, 0xA5, 0xA6, 0x11, + 0x23, 0xDB, 0x5C, 0x82, 0x12, 0x98, 0x67, 0x14, + 0xAC, 0x5E, 0xC3, 0xCA, 0x4B, 0x66, 0xEC, 0x06 + }, + { + 0xF8, 0x53, 0x2F, 0xF9, 0x41, 0x76, 0xDD, 0xF4, + 0x74, 0x00, 0xE1, 0x53, 0xEB, 0x85, 0x99, 0x08, + 0x56, 0x62, 0x9E, 0x04, 0x68, 0xE1, 0x5C, 0xDE, + 0xFA, 0x7C, 0x07, 0x9F, 0x87, 0x95, 0xF2, 0x9D + }, + { + 0x2E, 0xAD, 0x6B, 0x2E, 0x8D, 0x06, 0x6C, 0xCD, + 0x46, 0x09, 0x50, 0xFC, 0xA1, 0x4E, 0x74, 0x1B, + 0x48, 0x4B, 0xBB, 0xC0, 0x10, 0x10, 0xE1, 0x55, + 0x39, 0xDC, 0x37, 0x26, 0xB5, 0x30, 0xAF, 0x28 + }, + { + 0xC0, 0x74, 0xAE, 0x1F, 0x3D, 0x38, 0x9E, 0xD3, + 0x85, 0xDB, 0xA9, 0xD6, 0x01, 0xED, 0x15, 0x8B, + 0x54, 0x76, 0x90, 0xB2, 0x72, 0x90, 0xA7, 0x1B, + 0x5F, 0x1B, 0x10, 0x14, 0x29, 0xC4, 0xA9, 0x90 + }, + { + 0xB2, 0x92, 0x14, 0xB3, 0x14, 0xAD, 0x74, 0x01, + 0xBF, 0x65, 0x0F, 0xC3, 0x55, 0x43, 0x08, 0x5D, + 0x2B, 0xB2, 0x60, 0xB9, 0x1E, 0xD6, 0x6F, 0x8C, + 0x35, 0x79, 0x98, 0xB8, 0x0F, 0x27, 0xAC, 0xA7 + }, + { + 0xB6, 0x27, 0xD4, 0xB1, 0x1B, 0xC8, 0xD7, 0xB2, + 0x8B, 0xF2, 0x32, 0xE1, 0xD8, 0xBD, 0xE4, 0xBC, + 0xCA, 0x9D, 0xA9, 0x2E, 0xCD, 0x5E, 0x41, 0x8A, + 0xCE, 0x87, 0x99, 0xD9, 0xFE, 0x45, 0x09, 0xE8 + }, + { + 0x26, 0xCC, 0x33, 0x5D, 0xFA, 0x3B, 0xEC, 0x22, + 0x80, 0x5F, 0xED, 0x27, 0x22, 0x0A, 0x2B, 0xA5, + 0xDE, 0x21, 0xA8, 0xD6, 0x65, 0xF6, 0xCE, 0xB9, + 0x39, 0x3D, 0x10, 0xA6, 0x06, 0x5B, 0x2F, 0x12 + }, + { + 0x41, 0xBA, 0x15, 0xD2, 0x64, 0x38, 0x5A, 0x46, + 0x67, 0x0B, 0x01, 0x91, 0x45, 0x1F, 0x87, 0x3D, + 0x34, 0x23, 0x91, 0x61, 0xD7, 0x24, 0xE8, 0x99, + 0x98, 0x60, 0xB9, 0xEA, 0xB0, 0x5D, 0xC3, 0xAB + }, + { + 0x0B, 0x26, 0x49, 0xD6, 0x5C, 0x23, 0xFE, 0x7E, + 0x18, 0x66, 0x13, 0xFC, 0xA4, 0x58, 0x65, 0x6B, + 0x4C, 0x21, 0x3C, 0x7D, 0xA0, 0x6B, 0xF0, 0xD7, + 0x3D, 0x86, 0xC0, 0x6F, 0xCD, 0x94, 0x4F, 0xD8 + }, + { + 0x8A, 0x42, 0xCC, 0x20, 0xD4, 0x99, 0xBC, 0x09, + 0x56, 0xD2, 0x93, 0x15, 0x95, 0xAB, 0x75, 0x69, + 0xFC, 0xEE, 0xCC, 0x95, 0xD1, 0xFF, 0xA8, 0x3F, + 0x43, 0x67, 0x1B, 0x60, 0x93, 0x20, 0x85, 0xE8 + }, + { + 0xFB, 0x8D, 0xAA, 0x8D, 0xD0, 0x82, 0xBB, 0xEC, + 0x34, 0x7F, 0x3D, 0xF2, 0x5F, 0x04, 0x1D, 0x09, + 0x97, 0x56, 0x79, 0x2A, 0x24, 0x01, 0xEE, 0x3E, + 0xDF, 0x8C, 0x6C, 0xF5, 0xC0, 0xA4, 0x43, 0x71 + }, + { + 0x67, 0xB6, 0xE4, 0x48, 0x49, 0xC7, 0x2D, 0x5D, + 0x7E, 0x03, 0x8E, 0x48, 0x41, 0x54, 0x64, 0x0C, + 0x46, 0xDC, 0x0F, 0xC6, 0xC7, 0x66, 0x59, 0x0E, + 0x27, 0xEB, 0xB7, 0x34, 0xF0, 0x75, 0xEE, 0x80 + }, + { + 0xF1, 0x5B, 0x81, 0xF7, 0x56, 0x15, 0xFD, 0x83, + 0x0C, 0x99, 0xDF, 0x2A, 0xDA, 0xBC, 0xA3, 0xA5, + 0x48, 0xA0, 0x8C, 0x48, 0x75, 0x23, 0xEB, 0xD3, + 0xEE, 0x21, 0x71, 0xE5, 0x8B, 0x29, 0xBF, 0x12 + }, + { + 0xF5, 0x48, 0xC7, 0xD5, 0x4C, 0xA4, 0x36, 0x80, + 0x84, 0x9F, 0x42, 0x55, 0x25, 0xD4, 0xF3, 0xCB, + 0x09, 0xD1, 0x93, 0xE2, 0x57, 0xD0, 0x54, 0x97, + 0x48, 0x58, 0x31, 0xBF, 0x1A, 0x20, 0xCD, 0x50 + }, + { + 0x94, 0x38, 0x0C, 0x83, 0x62, 0x0B, 0x76, 0x1A, + 0xFF, 0xA0, 0xFC, 0x4B, 0x78, 0x6C, 0xD8, 0x77, + 0x5C, 0x31, 0xC5, 0xC9, 0x68, 0xFC, 0x72, 0xD0, + 0xEA, 0x55, 0x8E, 0xDC, 0xB1, 0x2E, 0x84, 0xF0 + }, + { + 0x6D, 0x34, 0x46, 0x8F, 0x1B, 0x0F, 0x38, 0x30, + 0xDA, 0x95, 0x6B, 0xB3, 0x6C, 0x83, 0x42, 0xF8, + 0xE4, 0x24, 0xE8, 0xDA, 0x74, 0x53, 0xB9, 0x60, + 0xAD, 0xD8, 0xFE, 0xBF, 0x2B, 0xDA, 0xC9, 0xC3 + }, + { + 0x07, 0x52, 0xE9, 0x48, 0x53, 0x0C, 0xE8, 0xEB, + 0xAD, 0xC9, 0xF3, 0xD2, 0x3E, 0xF7, 0x30, 0xA9, + 0xA3, 0x0E, 0xCB, 0x83, 0x4A, 0xB0, 0x1D, 0x1D, + 0x21, 0x57, 0x3A, 0x80, 0x9E, 0x1A, 0xD9, 0xC5 + }, + { + 0x50, 0x1D, 0x3D, 0x28, 0x6D, 0xAD, 0xD2, 0x41, + 0xDD, 0x6F, 0x5E, 0xE0, 0xF3, 0x46, 0xB0, 0x54, + 0xE5, 0x72, 0x4B, 0x8B, 0x15, 0x2A, 0xE0, 0xC4, + 0xB0, 0xB6, 0xD0, 0x8C, 0x28, 0xFD, 0xF8, 0x78 + }, + { + 0xCB, 0x5D, 0x0E, 0x95, 0xBD, 0x74, 0xC3, 0xA1, + 0x25, 0x9D, 0xC5, 0xA7, 0x09, 0x05, 0x06, 0x6E, + 0xD8, 0x56, 0x27, 0xA5, 0xA0, 0x24, 0x1E, 0x70, + 0x7F, 0x34, 0xDB, 0x72, 0xC7, 0xC1, 0x79, 0xB4 + }, + { + 0x0F, 0xD3, 0xE9, 0xF5, 0x51, 0x0C, 0xBD, 0x66, + 0xFD, 0xCC, 0x63, 0xDE, 0x6B, 0x5D, 0x8B, 0xDD, + 0x40, 0x31, 0x56, 0x11, 0xE4, 0xA4, 0x55, 0x27, + 0xCC, 0x69, 0x6D, 0x1E, 0x0C, 0x7E, 0xDE, 0x76 + }, + { + 0x96, 0x30, 0x31, 0x3F, 0xE1, 0xF3, 0x5E, 0x09, + 0x7A, 0x18, 0xF0, 0xAF, 0xC6, 0x93, 0xE2, 0x13, + 0x80, 0x64, 0xE0, 0x6B, 0xE7, 0xA1, 0xDA, 0x14, + 0x44, 0x16, 0xE6, 0x76, 0x4D, 0xBD, 0xBC, 0x8B + }, + { + 0x5F, 0x2F, 0x6B, 0x65, 0x7F, 0xBD, 0xCF, 0x1C, + 0x0A, 0x42, 0xCE, 0x9A, 0x09, 0xE6, 0xDD, 0xF6, + 0x7B, 0x6C, 0x9C, 0xA6, 0x58, 0x1D, 0x1C, 0x4F, + 0x9E, 0x61, 0xA5, 0x56, 0xB9, 0x2D, 0xA7, 0xCC + }, + { + 0x49, 0x8D, 0x60, 0xBF, 0x17, 0xDB, 0x16, 0xC8, + 0x10, 0xB8, 0x3F, 0xB9, 0x19, 0xC0, 0x80, 0x68, + 0x81, 0x36, 0xD2, 0xA2, 0x85, 0x3D, 0x11, 0xA1, + 0xF0, 0xBC, 0xA3, 0x52, 0xA9, 0xBB, 0xC7, 0xAE + }, + { + 0xD5, 0xAB, 0x1F, 0x0A, 0x08, 0x9E, 0xDD, 0x3B, + 0x55, 0x54, 0x9D, 0xEC, 0x97, 0x8C, 0xEF, 0x5C, + 0x8C, 0xCF, 0xBB, 0xED, 0xCA, 0x68, 0xBE, 0x6B, + 0x35, 0xDE, 0x65, 0xF8, 0x34, 0x90, 0xAD, 0xBE + }, + { + 0x91, 0x42, 0xF8, 0x06, 0x5F, 0x02, 0xF7, 0x05, + 0xA5, 0xFE, 0x26, 0x5C, 0xA6, 0x27, 0x0D, 0x9D, + 0x6E, 0x14, 0x97, 0x0E, 0x70, 0x8F, 0xB9, 0xC4, + 0xEB, 0x2E, 0x30, 0x92, 0x0F, 0x62, 0x90, 0xF8 + }, + { + 0xB7, 0xDC, 0x32, 0xA6, 0xD3, 0x42, 0xEB, 0x6F, + 0x69, 0x27, 0xD8, 0xD4, 0xE9, 0x2E, 0x88, 0x80, + 0x09, 0xA6, 0x69, 0x30, 0x1D, 0x3D, 0xBE, 0x4A, + 0xE0, 0xC8, 0xDF, 0x7E, 0x50, 0xEC, 0xFC, 0x11 + }, + { + 0xE9, 0x36, 0xF5, 0x83, 0x57, 0x25, 0xAA, 0xDF, + 0xC9, 0xC6, 0x00, 0x6B, 0x61, 0xA2, 0xA7, 0x81, + 0x00, 0xC2, 0x7D, 0x93, 0x9C, 0xA5, 0x3C, 0xD2, + 0xE6, 0xD5, 0xEC, 0x1F, 0x65, 0xD9, 0x61, 0x42 + }, + { + 0xE0, 0xFA, 0x0E, 0xEF, 0x26, 0x9A, 0x8A, 0xD2, + 0x70, 0xDA, 0x99, 0x54, 0xEE, 0xFC, 0xA8, 0x86, + 0x1F, 0xBB, 0x70, 0xC8, 0xCE, 0xE6, 0x56, 0x87, + 0xAF, 0x76, 0x44, 0xA1, 0xFE, 0x89, 0xA7, 0xEC + }, + { + 0x9C, 0x2F, 0x5C, 0x0B, 0x28, 0x15, 0xD3, 0x4E, + 0x73, 0x70, 0x34, 0xF9, 0x21, 0x93, 0x26, 0xE6, + 0x89, 0x62, 0x42, 0x91, 0x2E, 0x34, 0x8F, 0xFB, + 0x50, 0x9E, 0x80, 0x5D, 0x6F, 0xDA, 0x9F, 0x8B + }, + { + 0xB2, 0xA0, 0xF3, 0x8B, 0x9F, 0x4E, 0xAA, 0x86, + 0x80, 0xF1, 0x46, 0xEA, 0x90, 0xE0, 0xCB, 0x23, + 0x3F, 0xE5, 0x37, 0xF8, 0x41, 0xE2, 0xEF, 0x66, + 0xBD, 0x3C, 0xDE, 0x23, 0x9C, 0x41, 0x0D, 0xF6 + }, + { + 0x62, 0xD1, 0x68, 0x7D, 0x8E, 0x11, 0x95, 0x8B, + 0x32, 0x2C, 0x27, 0x69, 0xD3, 0xDC, 0xB3, 0x8F, + 0x8A, 0x7F, 0x2E, 0xB1, 0x5B, 0x88, 0x91, 0xEE, + 0x40, 0x00, 0x28, 0x8B, 0xB9, 0x35, 0xEE, 0x84 + }, + { + 0x75, 0x6C, 0x74, 0x06, 0xFE, 0x4C, 0xC6, 0xD9, + 0x2C, 0x4F, 0x1A, 0x6B, 0x76, 0xAA, 0xD4, 0x82, + 0xD0, 0xBD, 0xC1, 0xE8, 0x00, 0x2E, 0xDB, 0x23, + 0xB8, 0x8E, 0x63, 0xA6, 0xBB, 0x87, 0x14, 0xB2 + }, + { + 0x8A, 0xBB, 0xD1, 0xEE, 0x98, 0x0D, 0xBA, 0xB3, + 0xBA, 0xD2, 0x65, 0x85, 0xE6, 0x31, 0x99, 0x4E, + 0x67, 0xD1, 0x7D, 0x8B, 0x2D, 0x45, 0xC7, 0x4C, + 0xF7, 0x56, 0xB8, 0x24, 0x3D, 0xA3, 0xBB, 0xDD + }, + { + 0x92, 0x83, 0x9D, 0xD4, 0x45, 0xAE, 0x9A, 0x97, + 0x9B, 0x7A, 0xAF, 0x19, 0xED, 0x36, 0x99, 0x17, + 0x81, 0x7F, 0x2B, 0x20, 0x48, 0x07, 0x1A, 0xBC, + 0xF0, 0x5B, 0x5E, 0x8B, 0x0A, 0x1D, 0x08, 0x87 + }, + { + 0x75, 0xF6, 0xA7, 0x4F, 0xD5, 0x7F, 0x67, 0x54, + 0xF2, 0xF3, 0x50, 0x34, 0x28, 0x45, 0xBB, 0xEE, + 0x30, 0x9B, 0x8A, 0x37, 0xFE, 0xE3, 0x67, 0xDB, + 0xCC, 0x45, 0xE8, 0x1C, 0xDC, 0xC7, 0xC7, 0x05 + }, + { + 0x83, 0x4B, 0x89, 0x82, 0xA0, 0x6B, 0xC5, 0x1C, + 0x36, 0x1F, 0x85, 0x2F, 0x00, 0x26, 0xC9, 0xFC, + 0x06, 0xAA, 0x71, 0x18, 0x1E, 0x6E, 0xE4, 0xD0, + 0x6D, 0x99, 0x69, 0x69, 0x47, 0xC0, 0x57, 0x02 + }, + { + 0x04, 0x4F, 0xD2, 0x0F, 0x70, 0xBD, 0x5D, 0x76, + 0xCD, 0x3B, 0xF6, 0xCF, 0x5D, 0x65, 0xB2, 0x12, + 0x3A, 0x83, 0xEF, 0xD6, 0x88, 0x8A, 0x85, 0x8F, + 0x85, 0xC5, 0xE2, 0xB5, 0xB5, 0xF8, 0xE0, 0xF0 + }, + { + 0x79, 0xFA, 0xC0, 0x88, 0x9D, 0xA9, 0x1C, 0x8A, + 0xDB, 0x1D, 0xB0, 0xF6, 0xA7, 0x8E, 0xD2, 0x47, + 0xBB, 0x0F, 0x6B, 0xB0, 0x94, 0x42, 0x87, 0xB0, + 0x1B, 0x2A, 0xC1, 0x39, 0xE6, 0xD9, 0x23, 0x6C + }, + { + 0xD7, 0xD4, 0xEB, 0x08, 0x76, 0x48, 0xF8, 0x6E, + 0x31, 0xDF, 0xE7, 0x28, 0x49, 0x66, 0xAB, 0x66, + 0xFE, 0xB3, 0x75, 0xFA, 0x97, 0x31, 0x48, 0x93, + 0xFC, 0xF0, 0x57, 0x85, 0xAC, 0x00, 0x6D, 0xAD + }, + { + 0xE3, 0x94, 0x7E, 0x0C, 0xAE, 0x23, 0x43, 0xA0, + 0x1C, 0xE9, 0x1C, 0x0C, 0x3D, 0x9C, 0x0E, 0x77, + 0xEF, 0xEB, 0x4F, 0x61, 0xFF, 0x82, 0xC5, 0xB0, + 0xF2, 0x3F, 0x71, 0xA0, 0x61, 0x8F, 0x04, 0x02 + }, + { + 0x91, 0x60, 0x86, 0x40, 0x87, 0xF8, 0x76, 0x6B, + 0x63, 0x69, 0x65, 0xC5, 0x49, 0x9B, 0x98, 0x11, + 0xBA, 0xA0, 0xE6, 0x30, 0x61, 0x24, 0x03, 0x58, + 0x88, 0x6B, 0xB0, 0xA3, 0xAF, 0x57, 0x71, 0x60 + }, + { + 0xDC, 0xBE, 0x72, 0x3F, 0x2C, 0x8E, 0x76, 0xC5, + 0x1B, 0x50, 0xFD, 0xEE, 0x82, 0x71, 0x77, 0xFC, + 0x41, 0x72, 0xF1, 0x00, 0x60, 0x4E, 0x25, 0xC7, + 0xC5, 0x4D, 0x25, 0x5A, 0xA9, 0x43, 0xE1, 0xA1 + }, + { + 0xB7, 0x1A, 0x0E, 0x86, 0xD5, 0xCB, 0x58, 0x43, + 0xD8, 0x04, 0x46, 0xA4, 0xB9, 0x47, 0x77, 0xD5, + 0x68, 0x91, 0xF4, 0x03, 0x2B, 0x78, 0x52, 0xBA, + 0x8B, 0xC7, 0x86, 0xA0, 0xA9, 0x88, 0xD2, 0xDA + }, + { + 0xF0, 0x94, 0xC3, 0x8F, 0x6F, 0xB3, 0xD5, 0xAD, + 0x7F, 0xCA, 0xE0, 0x7D, 0xF7, 0xA4, 0xA7, 0x9C, + 0x97, 0x54, 0x8A, 0x5E, 0xFE, 0x4A, 0x54, 0x32, + 0x7C, 0xF6, 0x52, 0xE5, 0xE3, 0x22, 0x6C, 0x7E + }, + { + 0x76, 0x5F, 0x67, 0x2F, 0xCF, 0x62, 0x30, 0x1C, + 0x84, 0x3F, 0x98, 0x1C, 0x6D, 0xFE, 0x62, 0x44, + 0xE2, 0xA7, 0x44, 0xA1, 0x42, 0x73, 0xB4, 0x39, + 0xD0, 0xF9, 0x6E, 0xAF, 0xC3, 0x3A, 0x0D, 0xB4 + }, + { + 0x1F, 0xD9, 0x79, 0xFC, 0x22, 0x95, 0x96, 0x14, + 0x6D, 0x8C, 0xB7, 0x55, 0x0D, 0x12, 0x72, 0x1E, + 0xE8, 0x5A, 0xCA, 0x93, 0x16, 0xC7, 0xDB, 0xA5, + 0xFB, 0x4A, 0xC5, 0x30, 0x48, 0x66, 0xE3, 0x8E + }, + { + 0xA6, 0x5C, 0x32, 0x3A, 0xBF, 0x6F, 0x04, 0xAB, + 0xD1, 0xED, 0xF6, 0x0D, 0x35, 0xE9, 0x1D, 0x25, + 0xED, 0xEE, 0x71, 0x41, 0x5A, 0x8C, 0x3B, 0x5F, + 0x22, 0x4B, 0x17, 0x2E, 0x1D, 0x64, 0x67, 0x3E + }, + { + 0xDF, 0x92, 0xA8, 0xC8, 0x77, 0xF6, 0xFD, 0xDA, + 0x7B, 0x62, 0x4E, 0x8D, 0x6D, 0xCF, 0x34, 0x16, + 0x91, 0x53, 0x54, 0x32, 0xE8, 0x1E, 0x47, 0x71, + 0x31, 0xB8, 0x2C, 0x46, 0x49, 0x13, 0x83, 0xF1 + }, + { + 0x8F, 0x2F, 0xF7, 0x06, 0x54, 0x23, 0xFE, 0x25, + 0x4D, 0x0F, 0x24, 0xA8, 0xFF, 0xB6, 0x60, 0xFB, + 0xC1, 0x3B, 0x5B, 0xBD, 0xC0, 0x0B, 0x10, 0xA4, + 0x9A, 0x8C, 0x36, 0x0F, 0xA9, 0xC0, 0xFC, 0x4B + }, + { + 0x4D, 0x14, 0x66, 0xD9, 0x95, 0x05, 0x68, 0x21, + 0x0C, 0x37, 0x38, 0x77, 0xE5, 0xE2, 0xA3, 0x07, + 0x06, 0x8D, 0x8D, 0x6D, 0x96, 0x12, 0x5B, 0x26, + 0x74, 0xA3, 0x4E, 0x1C, 0x84, 0xFD, 0x58, 0x2A + }, + { + 0x35, 0x51, 0x5C, 0x7C, 0xE8, 0x31, 0xFB, 0xB9, + 0x35, 0x1B, 0x56, 0x3F, 0xE9, 0x39, 0x28, 0x27, + 0xE2, 0xAA, 0x5F, 0x61, 0x81, 0xD3, 0xE4, 0x0E, + 0x5C, 0x80, 0xE1, 0x43, 0x9F, 0x2E, 0x21, 0x2B + }, + { + 0x4F, 0x5B, 0x63, 0x9B, 0x73, 0x6F, 0xC5, 0xBB, + 0x00, 0xD9, 0xDE, 0xD8, 0x1C, 0xDE, 0x48, 0x36, + 0xEB, 0xD5, 0x14, 0x4B, 0xBD, 0x9C, 0x04, 0x73, + 0xE5, 0x6A, 0xAB, 0xF6, 0x8A, 0x72, 0x7E, 0xF4 + }, + { + 0x0A, 0x42, 0x02, 0xA2, 0x38, 0x04, 0x87, 0x35, + 0xC8, 0x09, 0xB0, 0x64, 0x43, 0xD6, 0x4F, 0x3E, + 0xD9, 0x2F, 0xE0, 0xFA, 0xB7, 0xC7, 0x80, 0x67, + 0x94, 0xD6, 0xB6, 0xC7, 0x01, 0x4E, 0x1E, 0xD1 + }, + { + 0x06, 0xFB, 0xFD, 0x31, 0x3B, 0xFD, 0x94, 0x84, + 0xD9, 0xBD, 0xC6, 0x33, 0x61, 0x56, 0x0A, 0x1C, + 0x47, 0x01, 0xB5, 0x9E, 0xDE, 0xE6, 0x85, 0x03, + 0x33, 0x8A, 0x16, 0xDC, 0x13, 0x8B, 0x4C, 0xFB + }, + { + 0x9A, 0x10, 0xBB, 0x9D, 0x69, 0xEB, 0x1E, 0x28, + 0xDF, 0x48, 0x3D, 0x89, 0xED, 0x67, 0x9F, 0xA4, + 0xEF, 0x2B, 0xAE, 0x6E, 0xF0, 0xD6, 0xD8, 0x93, + 0xE0, 0xC2, 0xD9, 0x96, 0xD4, 0xF6, 0xB2, 0x81 + }, + { + 0x5E, 0xDF, 0x2E, 0x6A, 0x89, 0xDF, 0xD0, 0xAB, + 0xC6, 0x65, 0x18, 0x1E, 0xE5, 0xC9, 0x31, 0x8D, + 0x89, 0x6A, 0x14, 0xC2, 0x94, 0xB9, 0x47, 0xA0, + 0x38, 0x46, 0x65, 0x23, 0x49, 0x8C, 0x3C, 0xAB + }, + { + 0xF0, 0xDE, 0x96, 0x73, 0x54, 0xD4, 0x97, 0xF6, + 0xF5, 0x36, 0xEB, 0x0C, 0xD0, 0x61, 0xB2, 0x8C, + 0x55, 0xCD, 0xD6, 0x1F, 0x1B, 0x9D, 0xC4, 0x04, + 0x5B, 0x65, 0x5C, 0xBA, 0xE6, 0x73, 0xD1, 0x68 + }, + { + 0x28, 0x44, 0xD6, 0x0D, 0x9C, 0xF4, 0x94, 0xC7, + 0x53, 0xFF, 0xDA, 0x31, 0xD6, 0x0D, 0x8C, 0x37, + 0x14, 0x94, 0xFF, 0x7D, 0x44, 0xEF, 0xE4, 0x4D, + 0xE6, 0x1C, 0x6D, 0xD0, 0x86, 0x9A, 0x27, 0x01 + }, + { + 0xC0, 0x9A, 0xE0, 0xC7, 0x36, 0x07, 0xFA, 0xEA, + 0x96, 0xEF, 0x26, 0x78, 0x54, 0x2D, 0x51, 0x98, + 0x8B, 0xDE, 0xD4, 0xDD, 0xE3, 0xAE, 0x1F, 0x9C, + 0x35, 0xF8, 0xD9, 0xE1, 0xCC, 0x61, 0x8E, 0xC5 + }, + { + 0xC5, 0x49, 0x9E, 0x9B, 0xE3, 0xB4, 0xEE, 0xA1, + 0x00, 0xF2, 0x49, 0xE0, 0x33, 0x22, 0x1F, 0x3A, + 0x02, 0x2D, 0x48, 0x28, 0x52, 0xB2, 0x86, 0x4A, + 0x58, 0x75, 0x07, 0xCA, 0x58, 0xFA, 0x6B, 0xE2 + }, + { + 0x6A, 0xD9, 0x04, 0xD1, 0xA0, 0x56, 0xFB, 0x2C, + 0xCC, 0xEE, 0xE8, 0x5C, 0x4C, 0xA4, 0x76, 0xC1, + 0x4D, 0xF7, 0xE8, 0x1E, 0x4D, 0x8F, 0xAC, 0x89, + 0xC1, 0x33, 0x14, 0xFA, 0x22, 0xC4, 0x54, 0xCF + }, + { + 0xAA, 0x3B, 0xBF, 0x96, 0x80, 0x22, 0x0F, 0xD3, + 0xAC, 0x16, 0x12, 0x63, 0x04, 0xBE, 0x15, 0xD6, + 0xC1, 0x11, 0xE3, 0xA7, 0x0F, 0x36, 0x3D, 0x3D, + 0x0B, 0x52, 0xAA, 0x42, 0xE1, 0xDC, 0x64, 0xA9 + }, + { + 0x47, 0x7E, 0x18, 0xB1, 0xCD, 0xED, 0xB2, 0x28, + 0xA4, 0x26, 0xA1, 0xDC, 0x7E, 0xE5, 0x61, 0xCF, + 0xCA, 0xC4, 0xA9, 0x6F, 0x9A, 0x72, 0x63, 0x8F, + 0xF4, 0x3B, 0xDF, 0x53, 0x7D, 0x75, 0x81, 0x48 + }, + { + 0xE9, 0x59, 0x0A, 0x7D, 0x76, 0xE2, 0x89, 0xB4, + 0x03, 0x39, 0xB3, 0xAB, 0x0B, 0x0A, 0x9D, 0xE2, + 0x28, 0xAE, 0x6B, 0xAB, 0x51, 0x4B, 0xDA, 0x37, + 0x84, 0x2F, 0xA5, 0x2F, 0x38, 0x9B, 0xCA, 0x74 + }, + { + 0xC9, 0x79, 0x0C, 0x7D, 0x7F, 0x98, 0xFA, 0x0E, + 0x05, 0xBC, 0xB3, 0x58, 0x44, 0x73, 0x3A, 0x8F, + 0xEF, 0x34, 0x1A, 0x04, 0xE4, 0xCE, 0x4E, 0x1F, + 0x01, 0x11, 0x12, 0xEA, 0xF4, 0x16, 0xDA, 0x02 + }, + { + 0x96, 0x56, 0x58, 0x43, 0xCD, 0xE5, 0xE0, 0xDA, + 0xA7, 0x06, 0x07, 0xF9, 0x72, 0xA9, 0x4D, 0x5C, + 0x47, 0x92, 0x3B, 0xA1, 0xFE, 0x5D, 0x72, 0x8C, + 0x25, 0xB3, 0xAB, 0x46, 0xFD, 0xDF, 0x75, 0xF8 + }, + { + 0xBC, 0xE7, 0xD3, 0x62, 0xFF, 0xC6, 0x5C, 0xF9, + 0xCC, 0x4E, 0x1D, 0x8B, 0xE6, 0x2C, 0xE2, 0xB7, + 0xA8, 0xD0, 0x3B, 0xCD, 0xDE, 0xB4, 0x8E, 0xB6, + 0xAA, 0xD2, 0x2F, 0x1C, 0xF2, 0x61, 0x5D, 0xEA + }, + { + 0x57, 0xD4, 0x37, 0x8D, 0x28, 0x01, 0x00, 0xEB, + 0x14, 0x1E, 0x4D, 0xF3, 0x11, 0x27, 0xB8, 0xC8, + 0xAA, 0x89, 0xCB, 0x0C, 0x04, 0x12, 0xA2, 0xD0, + 0xD3, 0x1A, 0x67, 0x9C, 0x60, 0x16, 0xEB, 0x9D + }, + { + 0xC8, 0xC1, 0x02, 0x38, 0xFD, 0xD9, 0x57, 0x27, + 0xDF, 0x0F, 0xDB, 0x9B, 0xC3, 0x53, 0x3D, 0x2A, + 0xA4, 0xDB, 0x40, 0x39, 0xB4, 0x1C, 0xAE, 0xE7, + 0x8B, 0x36, 0xC9, 0x7C, 0x99, 0x6D, 0xEF, 0xD6 + }, + { + 0xA6, 0xD3, 0x97, 0x41, 0xEA, 0xC7, 0x92, 0xBC, + 0x0A, 0xB7, 0x46, 0xDC, 0xA4, 0xAB, 0xC1, 0xE1, + 0x83, 0x1E, 0xDA, 0xC1, 0x2A, 0x16, 0xAE, 0x3E, + 0x4E, 0xDF, 0x11, 0x78, 0x2C, 0x24, 0x0E, 0x1B + }, + { + 0x6F, 0xCE, 0x36, 0x96, 0xCC, 0x8A, 0x25, 0x04, + 0x48, 0x4D, 0xE0, 0x3B, 0x64, 0xDB, 0xD3, 0xEE, + 0xCE, 0xB7, 0xE9, 0xDD, 0xD5, 0xAD, 0xC7, 0xEB, + 0xFF, 0x8A, 0xC1, 0x61, 0x3C, 0xD8, 0xC9, 0xBF + }, + { + 0x43, 0x60, 0xCD, 0xB1, 0xF7, 0x8F, 0x7A, 0xAB, + 0x07, 0xAA, 0x12, 0x65, 0x3C, 0xEA, 0x48, 0xA0, + 0x97, 0xEC, 0x2B, 0x82, 0x17, 0x2F, 0xD6, 0x70, + 0x82, 0xA2, 0xD9, 0x0B, 0x9E, 0xC0, 0xD7, 0x17 + }, + { + 0x31, 0xB6, 0x0E, 0xAB, 0x8D, 0xA3, 0xE4, 0x16, + 0x39, 0x1D, 0x41, 0x8A, 0x4C, 0xBC, 0xEF, 0xA9, + 0x81, 0x61, 0xEA, 0x55, 0x40, 0x30, 0x1F, 0xF8, + 0x31, 0xAF, 0x09, 0xE6, 0x90, 0xCD, 0xAA, 0x26 + }, + { + 0x89, 0x64, 0xA4, 0x25, 0xF8, 0x2D, 0xA4, 0xC2, + 0xCC, 0x8C, 0xB3, 0x04, 0x35, 0xFB, 0xD0, 0x51, + 0x89, 0x12, 0xE6, 0xAB, 0xB4, 0x42, 0xC8, 0xB8, + 0xA6, 0x13, 0x59, 0xE0, 0x90, 0x5A, 0xBE, 0x55 + }, + { + 0x48, 0xD2, 0xA4, 0x75, 0x77, 0x6E, 0xFD, 0xBD, + 0x5C, 0xC0, 0x63, 0x21, 0x38, 0xE2, 0x92, 0xE9, + 0x04, 0xE3, 0x0D, 0x98, 0x5D, 0x7F, 0x47, 0x17, + 0x86, 0x69, 0x5C, 0x2F, 0x8A, 0xC1, 0xAE, 0xD7 + }, + { + 0x38, 0x78, 0x30, 0x3D, 0x6E, 0x6B, 0xEA, 0x82, + 0x0C, 0xA8, 0x5D, 0xFF, 0xA2, 0xE0, 0xFE, 0x7F, + 0xE8, 0xB3, 0x9F, 0x94, 0x88, 0x5E, 0x6F, 0xE0, + 0x3F, 0x68, 0x40, 0x35, 0xD5, 0x5F, 0x48, 0x46 + }, + { + 0x80, 0x94, 0xE6, 0xAF, 0x9B, 0x7D, 0x60, 0x48, + 0x57, 0xC1, 0xCA, 0xB6, 0x13, 0xE9, 0x19, 0x13, + 0x55, 0xF5, 0xA9, 0x38, 0xB2, 0x37, 0xF6, 0xF2, + 0xDA, 0xB7, 0xA3, 0xA5, 0xFF, 0x2A, 0xA4, 0x4C + }, + { + 0xAC, 0x2C, 0x3A, 0x8A, 0xB4, 0xC0, 0x76, 0xA7, + 0x07, 0x9F, 0x23, 0x80, 0x7E, 0xDB, 0x2F, 0xEB, + 0x82, 0x72, 0xA4, 0xA0, 0x60, 0x4B, 0xCE, 0x17, + 0x84, 0x45, 0x54, 0x27, 0x94, 0xA7, 0xB0, 0x4C + }, + { + 0x45, 0x78, 0xE1, 0x8C, 0xAA, 0x10, 0x46, 0x2A, + 0x80, 0x7D, 0x03, 0xB3, 0x8E, 0x76, 0x9B, 0xD1, + 0x46, 0x2E, 0x0E, 0x98, 0x29, 0x34, 0x2C, 0x22, + 0x12, 0x91, 0x80, 0xB1, 0x5C, 0x39, 0xC0, 0xF6 + }, + { + 0xCF, 0x82, 0xCC, 0x36, 0x54, 0x54, 0x3D, 0x5B, + 0x88, 0xD5, 0xE0, 0xBA, 0x04, 0x7E, 0xB9, 0xD1, + 0x21, 0xD5, 0x66, 0x6A, 0x02, 0x5A, 0x20, 0x88, + 0x37, 0xC9, 0xC3, 0xF5, 0xD6, 0x81, 0x1F, 0x25 + }, + { + 0x12, 0xA3, 0xDA, 0x5D, 0xCC, 0x4F, 0x68, 0x58, + 0xD5, 0x74, 0xA8, 0x7F, 0x67, 0xC6, 0x97, 0x64, + 0x24, 0x58, 0x21, 0x08, 0xDE, 0x34, 0x54, 0xDD, + 0x0F, 0x52, 0xDE, 0x29, 0x8B, 0x08, 0xD4, 0xF4 + }, + { + 0x11, 0x28, 0x27, 0x96, 0xE1, 0x49, 0x0B, 0x30, + 0xCB, 0x35, 0x5A, 0x67, 0x26, 0xF4, 0x1E, 0x23, + 0x83, 0x77, 0x2F, 0x83, 0xB4, 0x32, 0x5F, 0xE6, + 0x83, 0xFA, 0xAA, 0x60, 0x64, 0x49, 0x0D, 0x08 + }, + { + 0x39, 0x4D, 0xB1, 0x4C, 0xF7, 0x39, 0x39, 0xAC, + 0x18, 0xFE, 0xEC, 0xEF, 0x21, 0x44, 0xDC, 0x66, + 0xDC, 0x09, 0xF5, 0x9E, 0x62, 0xA0, 0x04, 0x10, + 0x96, 0x49, 0x94, 0x37, 0x52, 0x1C, 0xD3, 0x86 + }, + { + 0x77, 0xF2, 0x97, 0xC4, 0x95, 0x67, 0xE7, 0x90, + 0x16, 0x0C, 0xE9, 0x2F, 0xD2, 0x90, 0x13, 0x61, + 0xDA, 0x64, 0xCF, 0x6C, 0xF2, 0xAE, 0x8A, 0x41, + 0xEE, 0x8B, 0xCB, 0x9C, 0x8A, 0x58, 0x70, 0x36 + }, + { + 0x74, 0xE8, 0xD6, 0xD5, 0x00, 0xC7, 0xE0, 0x63, + 0xDE, 0xDC, 0x67, 0x71, 0x70, 0x41, 0xB8, 0x47, + 0x7E, 0x17, 0xDD, 0x91, 0xBC, 0xD4, 0xDA, 0x7D, + 0x45, 0xB7, 0x1E, 0xA1, 0xCC, 0x71, 0xD5, 0xC9 + }, + { + 0xAF, 0xCB, 0x10, 0x01, 0x1B, 0x5A, 0x41, 0x3B, + 0x4E, 0xF5, 0x2A, 0xBA, 0x83, 0xCD, 0x3F, 0xD1, + 0x7A, 0xA3, 0xE2, 0x28, 0x28, 0x5E, 0xAF, 0x17, + 0x7C, 0xD9, 0xAB, 0x68, 0x6E, 0xF1, 0xEC, 0x1D + }, + { + 0x2F, 0xBD, 0x64, 0x2D, 0xE2, 0x8D, 0x1E, 0xCF, + 0x4B, 0xC5, 0xC1, 0x5B, 0x1D, 0x74, 0xF7, 0xB9, + 0xF3, 0x64, 0x01, 0xEC, 0x6B, 0x59, 0x61, 0xA8, + 0xF1, 0x82, 0xE2, 0x0D, 0xA7, 0x90, 0x76, 0x5F + }, + { + 0x59, 0x82, 0xDB, 0xEB, 0xDC, 0x8E, 0xAE, 0x6F, + 0xA4, 0xEE, 0xAA, 0x14, 0x09, 0xC5, 0x21, 0xB7, + 0x9B, 0x94, 0xC8, 0xDA, 0x7A, 0x54, 0x4D, 0x61, + 0xA2, 0xDE, 0xD7, 0xF9, 0x46, 0xE4, 0xF5, 0x62 + }, + { + 0x34, 0xDF, 0x8E, 0x39, 0x3F, 0xEC, 0xC2, 0x19, + 0x3B, 0xAD, 0xC7, 0xAA, 0x69, 0x03, 0xC2, 0x1A, + 0xC3, 0x32, 0xCC, 0xE4, 0x14, 0x39, 0x88, 0x11, + 0x0B, 0xDA, 0xA7, 0x3E, 0xA9, 0x0A, 0x57, 0xFA + }, + { + 0x30, 0x45, 0x5C, 0xE6, 0x02, 0x13, 0xB8, 0xF1, + 0x2A, 0x7C, 0x78, 0x96, 0x31, 0xA3, 0x89, 0x7D, + 0xD7, 0x9D, 0x90, 0x9D, 0x31, 0xD0, 0xE7, 0x56, + 0xBB, 0x33, 0xA3, 0x3E, 0x27, 0x76, 0x46, 0x90 + }, + { + 0xC6, 0x27, 0xB0, 0x40, 0x5B, 0xCF, 0x12, 0xC9, + 0x43, 0x81, 0x62, 0x89, 0x37, 0x3E, 0x6E, 0x54, + 0x9F, 0x19, 0xBD, 0x36, 0xD5, 0x38, 0x01, 0x83, + 0x40, 0xC6, 0xB1, 0x8A, 0xB7, 0x74, 0x20, 0x6A + }, + { + 0x5E, 0x26, 0x0F, 0x73, 0x63, 0x0A, 0x30, 0x33, + 0xBC, 0x41, 0x98, 0xDE, 0xF5, 0x99, 0x47, 0xA7, + 0x47, 0xD1, 0xAD, 0x64, 0x16, 0xCF, 0x29, 0xB7, + 0x63, 0x43, 0xCA, 0x6D, 0xB9, 0x33, 0xFC, 0x9C + }, + { + 0xAC, 0x5F, 0x3F, 0x6E, 0xA1, 0x36, 0xDF, 0x07, + 0xF5, 0x65, 0x56, 0x7C, 0x05, 0x13, 0xA5, 0x2E, + 0x54, 0x01, 0xF2, 0x79, 0x84, 0xE6, 0x9B, 0x65, + 0x37, 0xBA, 0x3F, 0x02, 0x93, 0x67, 0x95, 0xFF + }, + { + 0x06, 0xD6, 0x5F, 0x02, 0x74, 0x49, 0x16, 0x8E, + 0x51, 0x05, 0x83, 0xF6, 0xAD, 0x3A, 0x20, 0xC6, + 0x3F, 0x4E, 0xA0, 0x41, 0x36, 0x28, 0x92, 0x16, + 0x4B, 0xB8, 0x22, 0x6B, 0x65, 0x78, 0x68, 0x1A + }, + { + 0x92, 0x50, 0xB6, 0x9D, 0x67, 0xDC, 0x60, 0x93, + 0xDC, 0x73, 0xB6, 0x5A, 0xAF, 0xD8, 0x30, 0x7C, + 0xEC, 0x2F, 0xD5, 0x34, 0x53, 0xA7, 0x31, 0xCA, + 0xF3, 0x5A, 0xA7, 0xF7, 0x57, 0xE4, 0x5E, 0x30 + }, + { + 0x6B, 0x3E, 0x6E, 0xA4, 0x6F, 0xAB, 0xC2, 0x5F, + 0xD9, 0x42, 0xEC, 0x03, 0x50, 0x6D, 0xD3, 0xE8, + 0xE3, 0xF1, 0x0F, 0x0C, 0x1E, 0x9D, 0x49, 0x20, + 0x77, 0x4F, 0x1A, 0xD5, 0x0D, 0x2B, 0xFB, 0xD7 + }, + { + 0x06, 0x2B, 0xA8, 0x07, 0x60, 0x4A, 0xEF, 0xF5, + 0xD5, 0x09, 0xA7, 0xB3, 0x57, 0xD2, 0x35, 0x64, + 0x6A, 0x4D, 0xE4, 0xC7, 0x84, 0x6F, 0x32, 0xAB, + 0xA3, 0x24, 0x6B, 0x2F, 0x01, 0xEC, 0x9C, 0xCA + }, + { + 0x0E, 0x55, 0x58, 0xD8, 0x7A, 0x98, 0x3F, 0x06, + 0x42, 0x9E, 0xD0, 0x5B, 0x11, 0x93, 0xCA, 0x04, + 0x7A, 0xE6, 0x99, 0xFA, 0x15, 0x63, 0x14, 0x01, + 0x3A, 0xD7, 0xD7, 0x29, 0x85, 0xF2, 0x43, 0x99 + }, + { + 0xA4, 0x4A, 0x14, 0x13, 0x9F, 0x6D, 0x4F, 0x4B, + 0x05, 0xAE, 0xBD, 0x06, 0x90, 0x39, 0x9A, 0x66, + 0xDD, 0xC3, 0x49, 0xAD, 0x7D, 0x80, 0x6D, 0x2B, + 0x79, 0xB5, 0xB5, 0x63, 0x52, 0x59, 0xC7, 0xAF + }, + { + 0x7F, 0x49, 0x95, 0x3C, 0xFF, 0x95, 0x24, 0xCA, + 0x61, 0xFF, 0x71, 0x26, 0x11, 0xBF, 0xA8, 0xAE, + 0xA4, 0x5A, 0x3F, 0xB8, 0x1F, 0xD9, 0x9A, 0x15, + 0x50, 0x60, 0xCA, 0xDB, 0xA6, 0x40, 0x33, 0x25 + }, + { + 0x1D, 0x7E, 0x3E, 0xA9, 0x2D, 0xE1, 0xBB, 0xBC, + 0x09, 0x6B, 0x6B, 0x7F, 0x83, 0x41, 0x62, 0x37, + 0xA2, 0xFD, 0x4D, 0x8D, 0x8A, 0x4D, 0xDE, 0xB2, + 0xE5, 0x63, 0x30, 0xF5, 0x8E, 0xAD, 0x70, 0x47 + }, + { + 0xBF, 0xDB, 0xA4, 0xA5, 0x52, 0x23, 0x2D, 0x59, + 0x34, 0xC1, 0xFF, 0xE0, 0x12, 0xC8, 0x15, 0x39, + 0x38, 0x48, 0x38, 0x79, 0x54, 0xEF, 0x2E, 0x77, + 0x87, 0x04, 0xDC, 0xD6, 0xB7, 0x50, 0xB8, 0xD3 + }, + { + 0x3C, 0xE5, 0x83, 0x75, 0xD5, 0x97, 0x24, 0xAF, + 0xFC, 0x67, 0x1F, 0x96, 0x46, 0xE4, 0xF2, 0x43, + 0xDE, 0x13, 0xA2, 0x0E, 0x9C, 0x11, 0xE8, 0x94, + 0xDD, 0xA7, 0x74, 0x1C, 0x78, 0x3B, 0x0C, 0x61 + }, + { + 0x72, 0xA8, 0xC6, 0x70, 0xB1, 0x8B, 0xC6, 0xEA, + 0xB3, 0x8C, 0xB9, 0xBC, 0x3B, 0xC6, 0xE1, 0x0E, + 0x93, 0xD8, 0x5D, 0x7F, 0x3F, 0x67, 0xD1, 0x3D, + 0x9E, 0x8A, 0xC8, 0x46, 0x15, 0x8D, 0x23, 0xEF + }, + { + 0xB5, 0x48, 0x10, 0x14, 0x60, 0x97, 0x31, 0x66, + 0x01, 0x65, 0xCA, 0x2F, 0x8A, 0xAF, 0xA7, 0x05, + 0xE7, 0x5A, 0x90, 0x00, 0x21, 0x75, 0xFF, 0x9E, + 0xC0, 0xBF, 0x3E, 0xE4, 0xE9, 0xE1, 0x19, 0x8F + }, + { + 0xC9, 0x04, 0x66, 0x34, 0x93, 0xD2, 0xDA, 0xD0, + 0xA5, 0x31, 0xFD, 0xF6, 0x58, 0x09, 0xCF, 0xD6, + 0x67, 0xDA, 0x03, 0xC7, 0x0B, 0x59, 0xFE, 0x59, + 0x06, 0xA3, 0x11, 0xD5, 0xBB, 0xAE, 0x98, 0xB9 + }, + { + 0xD8, 0x4A, 0x23, 0x2F, 0x72, 0x66, 0xDC, 0xA4, + 0x5D, 0xC4, 0x17, 0x5A, 0x3C, 0xE2, 0xFD, 0xA6, + 0x54, 0xA0, 0xAC, 0x9C, 0x0C, 0x33, 0xDA, 0xDC, + 0xD6, 0xB4, 0x24, 0xE7, 0xEA, 0xE8, 0xDC, 0xC3 + }, + { + 0x21, 0x57, 0xFB, 0x61, 0xC2, 0x41, 0xE3, 0xF6, + 0xC1, 0x68, 0xA7, 0x1D, 0x55, 0xDA, 0x86, 0xE8, + 0x48, 0x23, 0x14, 0x89, 0x7E, 0x28, 0x13, 0x83, + 0xA6, 0x7A, 0x31, 0x00, 0xB7, 0x2A, 0xD7, 0xDC + }, + { + 0xEB, 0x17, 0xC6, 0x47, 0x20, 0xF9, 0x44, 0xB8, + 0xE8, 0x90, 0x61, 0x88, 0xC7, 0xA6, 0x57, 0xB4, + 0x89, 0x1B, 0xC2, 0xD6, 0xAA, 0xB2, 0x64, 0x56, + 0x62, 0xE0, 0xAB, 0x0B, 0x60, 0x13, 0xF1, 0x75 + }, + { + 0x69, 0x0C, 0xE3, 0xD3, 0x09, 0x52, 0x60, 0x4C, + 0xD9, 0xD8, 0x5C, 0x15, 0x5C, 0xF8, 0x27, 0x49, + 0xF4, 0xBC, 0x33, 0x5C, 0x49, 0x4A, 0x83, 0x40, + 0x01, 0xB8, 0x2A, 0xE1, 0xC8, 0xA2, 0x7A, 0xAF + }, + { + 0x8B, 0xCC, 0xE7, 0x0D, 0x29, 0xA8, 0x4C, 0x01, + 0x0C, 0x36, 0xCC, 0xDE, 0x3B, 0xF4, 0x54, 0x03, + 0xA3, 0x89, 0x9A, 0x34, 0x29, 0x79, 0x6A, 0x7D, + 0x2D, 0x22, 0xEE, 0xB0, 0xA5, 0x8A, 0xB7, 0xD7 + }, + { + 0xB8, 0x79, 0x59, 0xFD, 0x99, 0xB5, 0xCB, 0x2F, + 0x8A, 0x64, 0xF7, 0x4F, 0x47, 0x29, 0x19, 0x42, + 0xE9, 0xA9, 0x55, 0x51, 0x51, 0x3A, 0xD7, 0xC4, + 0x56, 0xA0, 0x38, 0xDC, 0xEB, 0x33, 0x1A, 0x0F + }, + { + 0xA8, 0xC4, 0xDF, 0x21, 0xD1, 0x04, 0xA7, 0xDF, + 0x9C, 0x6E, 0xD3, 0x48, 0x8B, 0x72, 0x4F, 0x92, + 0xB0, 0xC7, 0xCF, 0x87, 0x33, 0x64, 0x0B, 0xB1, + 0xC3, 0x3D, 0x14, 0xA3, 0x55, 0xB2, 0x0C, 0x9E + }, + { + 0xF6, 0x2B, 0x31, 0xD2, 0x6B, 0xA2, 0x24, 0xEC, + 0xC3, 0xFE, 0xAB, 0x52, 0x10, 0x43, 0x08, 0x9F, + 0xBC, 0x63, 0x2C, 0xAC, 0xF2, 0x07, 0x41, 0x41, + 0x84, 0xD1, 0xA6, 0x5A, 0xB4, 0x6B, 0x7E, 0x58 + }, + { + 0xF4, 0xD3, 0x6C, 0x86, 0x41, 0xA2, 0xD0, 0xA1, + 0xF3, 0x43, 0xE9, 0x4D, 0xB1, 0x85, 0x7A, 0x5A, + 0x38, 0x94, 0x55, 0x6D, 0xC8, 0x2B, 0x1D, 0x85, + 0x96, 0x41, 0x6C, 0x7F, 0x4B, 0x50, 0x4C, 0x20 + }, + { + 0x01, 0x54, 0x71, 0x54, 0x93, 0x95, 0xEA, 0xAA, + 0xF4, 0x55, 0xE0, 0xFE, 0x24, 0x69, 0x77, 0x2B, + 0x93, 0x02, 0x34, 0xC6, 0x0C, 0x77, 0x86, 0x03, + 0x57, 0xA3, 0xDD, 0xFF, 0x6F, 0x40, 0xCC, 0xD8 + }, + { + 0xCC, 0xAC, 0xBD, 0x40, 0x54, 0x37, 0x00, 0xF3, + 0xF1, 0x03, 0xEC, 0xE1, 0x19, 0x14, 0x20, 0xB0, + 0xD5, 0x90, 0x1E, 0x4A, 0xD6, 0xDC, 0x7C, 0x7A, + 0x48, 0x2A, 0x15, 0x28, 0x2F, 0x91, 0xA6, 0x13 + }, + { + 0xF6, 0x1D, 0xB2, 0x12, 0xBF, 0x60, 0x35, 0x6C, + 0x54, 0x9F, 0x4D, 0x5A, 0x95, 0x3C, 0x1D, 0x99, + 0x65, 0x86, 0x49, 0x0C, 0x83, 0x97, 0x28, 0x9A, + 0x7A, 0x47, 0x94, 0x6A, 0x8D, 0x51, 0xE1, 0xAC + }, + { + 0xDA, 0x36, 0xCB, 0x42, 0x12, 0x96, 0xA6, 0xCD, + 0x99, 0x7F, 0xF9, 0x1F, 0x22, 0x02, 0x3A, 0x25, + 0x90, 0x29, 0xF9, 0xED, 0xEF, 0xC0, 0x21, 0x5A, + 0x80, 0x4F, 0x86, 0x5B, 0x19, 0x1D, 0xAE, 0xF5 + }, + { + 0x3E, 0xAA, 0xFF, 0x68, 0xDC, 0xBF, 0x0E, 0xBF, + 0x12, 0x59, 0x6B, 0x10, 0x80, 0x0F, 0x25, 0x67, + 0x1C, 0xA5, 0x88, 0xE5, 0x9D, 0x5B, 0x37, 0xE0, + 0x54, 0x9C, 0x40, 0x48, 0x6F, 0xE1, 0xF2, 0x15 + }, + { + 0xA0, 0xBD, 0x8E, 0x0E, 0x34, 0x03, 0xA9, 0xB6, + 0x9A, 0xEB, 0xB0, 0xAD, 0xBD, 0xF7, 0x53, 0x5D, + 0x03, 0x2B, 0xCC, 0x7A, 0x2B, 0x2D, 0xF9, 0xBC, + 0x1E, 0x39, 0x5E, 0x52, 0x8A, 0x19, 0xED, 0xF0 + }, + { + 0x36, 0x42, 0x5E, 0x88, 0xA4, 0x2C, 0x67, 0x79, + 0x18, 0xA3, 0xD2, 0x51, 0x3C, 0xAF, 0xE9, 0xD5, + 0xB3, 0x50, 0x47, 0x3C, 0x9D, 0xB8, 0xE9, 0xB0, + 0xE3, 0x17, 0x20, 0xEC, 0x70, 0xE6, 0x1F, 0x55 + }, + { + 0x14, 0x63, 0x4F, 0x65, 0x71, 0x65, 0x82, 0x95, + 0x40, 0xF3, 0x89, 0x06, 0x54, 0x09, 0x35, 0xFF, + 0xDE, 0x73, 0xA3, 0xD1, 0x37, 0x95, 0x64, 0x40, + 0x67, 0x43, 0x8F, 0xD0, 0x91, 0x89, 0xE4, 0x7A + }, + { + 0x73, 0x47, 0x19, 0xE5, 0x97, 0x67, 0x60, 0x7E, + 0x68, 0x03, 0xDC, 0xBB, 0x9C, 0xD9, 0x59, 0x7D, + 0x64, 0x41, 0xFD, 0x30, 0x7F, 0xD4, 0xF1, 0xD9, + 0xF0, 0x67, 0xBD, 0x3D, 0x8A, 0x10, 0xB4, 0x5C + }, + { + 0x7E, 0xBB, 0x0F, 0xA3, 0x14, 0xF9, 0x5A, 0xF7, + 0x31, 0x0F, 0xD2, 0xC7, 0xBA, 0x5D, 0xA8, 0x41, + 0xB1, 0xE9, 0x8C, 0x67, 0x38, 0x4C, 0xBE, 0x7E, + 0xDD, 0xFA, 0x40, 0x1F, 0xB1, 0xB3, 0x75, 0x9A + }, + { + 0x5B, 0x84, 0x1E, 0xD7, 0x11, 0x9E, 0x58, 0xB7, + 0xC8, 0x04, 0x29, 0x9A, 0x23, 0x26, 0xE9, 0xBB, + 0xA3, 0xAD, 0xC5, 0x81, 0x2B, 0xBD, 0x35, 0x4D, + 0x6F, 0xC9, 0x78, 0x6B, 0x10, 0x6A, 0xC8, 0x5A + }, + { + 0x7C, 0xBB, 0xB0, 0xB6, 0x1F, 0x31, 0x48, 0xEF, + 0xAD, 0xCA, 0x5C, 0x15, 0x28, 0x3C, 0xAE, 0x44, + 0xCC, 0x8C, 0x6E, 0x33, 0xFE, 0x74, 0xC5, 0xB4, + 0x68, 0x10, 0x69, 0x34, 0x9D, 0xEA, 0x55, 0x4B + }, + { + 0xEF, 0xA2, 0x6E, 0xA5, 0x19, 0xAA, 0xFC, 0x8D, + 0x7D, 0x6A, 0x39, 0x37, 0xD4, 0x02, 0xD0, 0xFF, + 0x2B, 0x06, 0x35, 0x05, 0x39, 0x31, 0x05, 0x09, + 0x32, 0xC4, 0x6D, 0xAE, 0x75, 0x4D, 0x9B, 0x16 + }, + { + 0xB4, 0x17, 0x76, 0xC5, 0x50, 0xC4, 0x16, 0xB5, + 0x0A, 0x2E, 0x34, 0xEE, 0x13, 0xA3, 0x2D, 0x66, + 0xB2, 0xEE, 0x82, 0x81, 0xED, 0xE4, 0x12, 0xE1, + 0xA4, 0xCC, 0x59, 0xFB, 0x08, 0xD0, 0x9C, 0xD1 + }, + { + 0xB6, 0xEE, 0x50, 0xFF, 0x2B, 0xBB, 0xE9, 0x9E, + 0x2D, 0x23, 0x9B, 0x70, 0x59, 0x78, 0xA9, 0x97, + 0xAF, 0x4B, 0xEB, 0x82, 0x52, 0x5E, 0x63, 0xCF, + 0x1D, 0xB4, 0xF2, 0xD2, 0x83, 0xAB, 0x6D, 0x04 + }, + { + 0x70, 0xAE, 0x0B, 0xE6, 0xE0, 0xA3, 0xF0, 0x6F, + 0x56, 0x54, 0x89, 0x08, 0x47, 0xAF, 0xAB, 0x25, + 0xEA, 0xEE, 0xAE, 0xAC, 0x64, 0x9C, 0x34, 0x6C, + 0xBA, 0x21, 0x59, 0xC4, 0x1E, 0x11, 0xAE, 0xB4 + }, + { + 0xAE, 0xBD, 0x5C, 0x17, 0xFB, 0xEA, 0x66, 0xE7, + 0x52, 0xEB, 0x37, 0xE6, 0xF7, 0x98, 0x18, 0xEC, + 0xE1, 0x7F, 0xBE, 0xA9, 0x5E, 0x52, 0x4B, 0xB0, + 0x82, 0x87, 0x79, 0x36, 0x39, 0xC1, 0x45, 0x6A + }, + { + 0xFA, 0x42, 0xFC, 0x95, 0x34, 0x64, 0x65, 0xD1, + 0x04, 0x74, 0x83, 0x7E, 0xB3, 0xDC, 0x2B, 0xA1, + 0x0D, 0xC4, 0xD2, 0x4E, 0x0D, 0x77, 0xEC, 0x29, + 0x66, 0x44, 0xC7, 0x0B, 0xD9, 0xCD, 0xB4, 0x77 + }, + { + 0x16, 0x8A, 0x69, 0x31, 0xE3, 0xB7, 0xA0, 0xC4, + 0xFD, 0x89, 0xF7, 0x94, 0x55, 0xF3, 0xF5, 0x1E, + 0xCD, 0xCB, 0x3A, 0xF1, 0x45, 0xB2, 0x01, 0xB9, + 0xB6, 0x1D, 0x27, 0xAD, 0xF3, 0x87, 0x9A, 0x3B + }, + { + 0x57, 0xA2, 0xD1, 0xCF, 0x17, 0xB5, 0xCB, 0x6F, + 0x44, 0xCF, 0x25, 0xD9, 0xBC, 0x37, 0xA0, 0x6D, + 0x5A, 0xF1, 0xD5, 0xF9, 0xB4, 0x7A, 0xCC, 0x96, + 0x0A, 0x3A, 0xFC, 0x61, 0xCC, 0x4A, 0x79, 0x36 + }, + { + 0xF4, 0x0B, 0x27, 0xD2, 0x77, 0xF3, 0x09, 0x7E, + 0x3C, 0xFA, 0xF6, 0x69, 0xE5, 0xCB, 0xA4, 0xBB, + 0x73, 0x4C, 0x96, 0x39, 0x72, 0xA9, 0x16, 0xB9, + 0x9B, 0x2F, 0x18, 0x65, 0x20, 0xD2, 0xA6, 0x30 + }, + { + 0x0C, 0xBB, 0xE6, 0x0C, 0x99, 0x82, 0xAB, 0x57, + 0xF1, 0x7F, 0x38, 0x85, 0x85, 0x7A, 0xAF, 0x8D, + 0xB0, 0xB4, 0x89, 0x3E, 0x44, 0xF8, 0x7F, 0x2A, + 0x5B, 0xF9, 0xA7, 0xB9, 0xD5, 0xC4, 0xDE, 0xBE + }, + { + 0x4F, 0xE0, 0xF7, 0x5D, 0x23, 0x74, 0x53, 0x56, + 0xC5, 0xA7, 0x63, 0x0F, 0xA1, 0x6D, 0x7E, 0x5B, + 0x5F, 0x39, 0x91, 0x62, 0xC0, 0xAD, 0xCC, 0x36, + 0x70, 0x3A, 0x1A, 0xDD, 0xB2, 0x25, 0x84, 0x26 + }, + { + 0xD4, 0x75, 0x79, 0xBF, 0xB9, 0x7F, 0x19, 0x4B, + 0x74, 0xE1, 0xA7, 0x44, 0x96, 0xE5, 0x33, 0x7E, + 0x8C, 0x31, 0x90, 0xB8, 0xB1, 0x6E, 0x78, 0x35, + 0x09, 0x6E, 0xC6, 0x9D, 0x29, 0x2E, 0xFB, 0xF3 + }, + { + 0xCA, 0x47, 0xB7, 0x1E, 0xAB, 0xB3, 0x47, 0xF3, + 0x37, 0x83, 0xE3, 0x8E, 0x64, 0x70, 0xB3, 0xDF, + 0x68, 0x5B, 0x06, 0xE0, 0xFC, 0x27, 0x53, 0x55, + 0x38, 0xBD, 0x12, 0xFD, 0x26, 0x36, 0x6C, 0xB7 + }, + { + 0x73, 0x91, 0x4D, 0xE6, 0xD6, 0x61, 0xD9, 0x6F, + 0x7F, 0xEA, 0x20, 0xFF, 0xEF, 0x3A, 0x8F, 0x2A, + 0x82, 0x25, 0x36, 0x0D, 0x0C, 0x23, 0xC9, 0xB1, + 0x9F, 0x2D, 0x3B, 0x45, 0x7A, 0x3F, 0x9B, 0xC8 + }, + { + 0x7A, 0xD1, 0x6E, 0x9E, 0x31, 0x36, 0x07, 0x57, + 0x85, 0xCD, 0x2B, 0x03, 0x31, 0x81, 0x2D, 0x4C, + 0x18, 0x51, 0x00, 0x6E, 0x05, 0xCD, 0x92, 0x64, + 0x08, 0x37, 0x4E, 0x16, 0xE7, 0x8C, 0xB2, 0x29 + }, + { + 0x6B, 0x1E, 0x47, 0x1A, 0x5E, 0x10, 0x4F, 0x31, + 0x1E, 0x34, 0x7E, 0x61, 0x19, 0xC0, 0xB4, 0xC0, + 0xAD, 0xA7, 0xD8, 0xC2, 0xFF, 0x4A, 0xD0, 0xD7, + 0x26, 0xBA, 0x07, 0x82, 0xA7, 0x38, 0x39, 0x7B + }, + { + 0x82, 0x7C, 0xBC, 0x12, 0x11, 0xA2, 0x8F, 0x86, + 0x40, 0xEA, 0x5C, 0x6A, 0x66, 0x3D, 0x39, 0x24, + 0x9F, 0x16, 0x4C, 0xC8, 0xDF, 0xAC, 0x38, 0xC1, + 0x3A, 0xE1, 0x75, 0xA2, 0x2B, 0x6D, 0xE5, 0x18 + }, + { + 0xC2, 0x63, 0x1A, 0x19, 0xE4, 0xBD, 0x37, 0xDF, + 0x5E, 0xB1, 0xC9, 0xB9, 0x34, 0xE8, 0x5E, 0xDC, + 0x3A, 0xF5, 0xBA, 0x5C, 0x84, 0x4C, 0x20, 0xAB, + 0x42, 0xF2, 0x33, 0x5E, 0xCC, 0x60, 0x67, 0x30 + }, + { + 0xA2, 0x21, 0x51, 0x69, 0xF7, 0x10, 0xB8, 0x91, + 0x37, 0xA7, 0xEA, 0x9B, 0x54, 0xA4, 0x68, 0x20, + 0x57, 0x5E, 0xD3, 0x0C, 0xB0, 0xEC, 0x75, 0x98, + 0x81, 0x39, 0x5A, 0xE3, 0x3C, 0x81, 0x7F, 0xBD + }, + { + 0x0D, 0x51, 0x4E, 0xC1, 0x68, 0xC1, 0x56, 0x4D, + 0x7F, 0x54, 0x6C, 0x48, 0x70, 0x60, 0xB6, 0xEA, + 0x70, 0xC7, 0xA6, 0x39, 0x71, 0x37, 0x25, 0x98, + 0x3D, 0x9B, 0x29, 0x63, 0x08, 0x8A, 0x19, 0xDC + }, + { + 0x41, 0xA5, 0x8F, 0xAF, 0x31, 0xFA, 0x74, 0x7A, + 0x8C, 0x55, 0xD3, 0x17, 0xDB, 0xA1, 0x77, 0x14, + 0x9C, 0x6F, 0x1C, 0x81, 0x7F, 0x3A, 0xC7, 0x76, + 0x1B, 0xE9, 0x7B, 0xD1, 0x62, 0xE9, 0xD7, 0xF6 + }, + { + 0xFF, 0x83, 0x82, 0x30, 0x1D, 0x46, 0x65, 0x80, + 0x12, 0x3E, 0x48, 0xDB, 0x14, 0xEE, 0x65, 0x78, + 0x37, 0xEE, 0xCD, 0x47, 0xCC, 0x3F, 0x97, 0xDE, + 0x5A, 0xD4, 0x89, 0x22, 0x86, 0xD1, 0x5E, 0x6D + }, + { + 0x86, 0x69, 0xA6, 0xBD, 0x60, 0xFD, 0xE4, 0xCB, + 0xE2, 0x3E, 0x3E, 0xA1, 0x52, 0xCF, 0x87, 0xFE, + 0x7A, 0x83, 0x00, 0x8A, 0xF5, 0x4B, 0x65, 0x21, + 0x94, 0x4A, 0xA2, 0xE7, 0x81, 0x63, 0x64, 0x55 + }, + { + 0x06, 0x33, 0x98, 0xEA, 0xC1, 0x88, 0x7B, 0x46, + 0xD7, 0x84, 0x41, 0xD8, 0x6A, 0x89, 0x9C, 0x2F, + 0x2E, 0x4C, 0xF2, 0x6B, 0xBF, 0x87, 0x17, 0x5E, + 0x29, 0x4B, 0x74, 0xB0, 0x0B, 0xA0, 0xA0, 0x94 + }, + { + 0x78, 0x04, 0x12, 0x6E, 0x83, 0xC7, 0x9B, 0xC2, + 0x33, 0x61, 0x51, 0x9E, 0xAE, 0x67, 0xC4, 0x45, + 0x85, 0xDF, 0x35, 0x85, 0x2B, 0xE8, 0xA5, 0x49, + 0x83, 0x21, 0x44, 0xA0, 0xD8, 0x9D, 0xD8, 0x28 + }, + { + 0x7F, 0xF6, 0xE5, 0x1F, 0xEF, 0x17, 0x55, 0x4C, + 0x88, 0x6B, 0x25, 0xBE, 0x1D, 0xE9, 0x00, 0xEF, + 0x83, 0xFE, 0xAD, 0x63, 0xE7, 0x49, 0xA1, 0x6A, + 0xE7, 0x2D, 0x1E, 0xEA, 0x45, 0xDB, 0xDD, 0x1F + }, + { + 0xC1, 0xD3, 0x4C, 0xA6, 0x8F, 0x15, 0xC6, 0x3C, + 0x03, 0x35, 0x32, 0x34, 0x52, 0xF0, 0xED, 0x54, + 0x12, 0x7F, 0xAA, 0x34, 0xC1, 0xBA, 0x1D, 0xF0, + 0x32, 0x73, 0x33, 0x4C, 0x8C, 0xEC, 0x72, 0xE8 + }, + { + 0x93, 0x1B, 0x15, 0xBF, 0xC8, 0xAF, 0x3D, 0x7F, + 0x5F, 0x03, 0x75, 0x80, 0x2D, 0x6B, 0xD3, 0xB3, + 0x78, 0x84, 0xB8, 0xA8, 0x53, 0x53, 0x7F, 0xD0, + 0x69, 0x49, 0x90, 0xF8, 0xDF, 0x17, 0x2A, 0xBD + }, + { + 0xBC, 0xAE, 0xBF, 0xC3, 0xAC, 0x5B, 0x08, 0x5D, + 0x2E, 0xEC, 0x75, 0x9F, 0xAD, 0xDB, 0xA2, 0xBC, + 0xB3, 0x50, 0x3B, 0xC8, 0x6B, 0x57, 0x1B, 0x1E, + 0x96, 0x3D, 0x04, 0x89, 0x52, 0x46, 0x6E, 0x67 + }, + { + 0x44, 0x18, 0x4E, 0xAC, 0x44, 0x72, 0xC5, 0xDA, + 0x33, 0x28, 0x3D, 0x26, 0x55, 0xD2, 0x9B, 0xBF, + 0x07, 0x8E, 0x23, 0x1B, 0xBF, 0x0F, 0x81, 0x66, + 0xDE, 0xD7, 0x83, 0xEA, 0x37, 0x13, 0x4C, 0x04 + }, + { + 0x07, 0xA7, 0xD2, 0xB4, 0x13, 0x12, 0xC2, 0x80, + 0x14, 0x9D, 0x52, 0xDF, 0x0D, 0xE0, 0x05, 0x25, + 0x6D, 0x94, 0xD8, 0xCD, 0xAC, 0x2B, 0x30, 0xA2, + 0xED, 0x8A, 0x65, 0xFD, 0xF0, 0xCA, 0x48, 0x2D + }, + { + 0x17, 0x0A, 0xF7, 0xD7, 0x99, 0xCE, 0xD5, 0xC1, + 0xF1, 0xF9, 0x27, 0xD5, 0x25, 0xA8, 0x04, 0x9D, + 0x05, 0x04, 0x9D, 0xAB, 0xB0, 0x8A, 0xE6, 0xC1, + 0x42, 0x0A, 0x61, 0x23, 0xF3, 0xFB, 0x2A, 0x9B + }, + { + 0x77, 0x7D, 0x93, 0x2F, 0x4B, 0x3F, 0x63, 0x2E, + 0x04, 0xF6, 0xE3, 0xAB, 0xE2, 0xCE, 0x1B, 0x3C, + 0xE7, 0x64, 0x50, 0x30, 0x7B, 0x41, 0x1E, 0xCA, + 0x62, 0x09, 0x9F, 0x26, 0x59, 0x89, 0xD4, 0x4A + }, + { + 0x50, 0x9A, 0x59, 0xD8, 0x29, 0x5A, 0xB2, 0xD3, + 0x96, 0x40, 0x44, 0x0F, 0x42, 0x41, 0x5E, 0xDA, + 0x5D, 0x96, 0x94, 0xC4, 0x51, 0x56, 0x28, 0x96, + 0x58, 0x5B, 0x98, 0x5E, 0xE7, 0xBA, 0x0A, 0x22 + }, + { + 0x1B, 0xA4, 0x60, 0xAC, 0x4C, 0xB5, 0x90, 0xE9, + 0x9C, 0x8F, 0x93, 0x2A, 0x71, 0xAD, 0xE7, 0x2C, + 0xAC, 0xA3, 0xE5, 0x7B, 0x38, 0x60, 0x58, 0xCB, + 0x52, 0xDD, 0x48, 0x01, 0x04, 0xCE, 0xA5, 0x8A + }, + { + 0x2D, 0xA2, 0xB3, 0x6A, 0xC8, 0x6B, 0x3A, 0x8D, + 0x97, 0x44, 0xD0, 0x88, 0xBB, 0x31, 0xFC, 0x27, + 0x3B, 0xEA, 0x37, 0x25, 0xE0, 0xAC, 0x12, 0xC8, + 0x25, 0x61, 0x39, 0xB4, 0x54, 0xF9, 0x33, 0xC3 + }, + { + 0x8B, 0xB1, 0x4A, 0xF0, 0xFE, 0x55, 0xE5, 0xBC, + 0x59, 0x96, 0xF2, 0x80, 0x46, 0x8F, 0xAF, 0x1A, + 0xBE, 0xE4, 0x7E, 0x90, 0x6F, 0x50, 0xD6, 0xB3, + 0xB1, 0x77, 0x34, 0x54, 0x3A, 0x2D, 0x07, 0x9E + }, + { + 0x39, 0xF1, 0xC9, 0xD0, 0x59, 0x11, 0x0D, 0xE8, + 0xF0, 0xEF, 0x59, 0x74, 0x8E, 0x73, 0x63, 0x27, + 0x4A, 0xEF, 0xD5, 0x74, 0x41, 0x9C, 0x48, 0x87, + 0x22, 0x4B, 0xEC, 0x95, 0xC8, 0x11, 0x86, 0xDB + }, + { + 0x1C, 0xE3, 0xC6, 0xEA, 0x81, 0xA9, 0x42, 0x90, + 0x95, 0xF6, 0xB7, 0xBE, 0x07, 0x3C, 0x9F, 0xAE, + 0x80, 0x2F, 0xE0, 0x5D, 0x23, 0x00, 0x64, 0xE8, + 0x1A, 0xA9, 0x51, 0x96, 0xF3, 0x88, 0xFB, 0xA5 + }, + { + 0xC7, 0x07, 0x93, 0x4E, 0x5E, 0x63, 0x6D, 0xAF, + 0x44, 0xF7, 0xA7, 0xED, 0xF7, 0x7E, 0xD8, 0x43, + 0x7E, 0xC1, 0x6E, 0x0A, 0x16, 0xF8, 0xFB, 0x53, + 0xD6, 0x06, 0x86, 0xAF, 0x98, 0xB5, 0xCE, 0x75 + }, + { + 0xCD, 0x20, 0x22, 0xC1, 0x88, 0xA2, 0xD8, 0xD0, + 0xA0, 0xC4, 0x71, 0x80, 0x1B, 0x79, 0x9F, 0x74, + 0x2C, 0x66, 0xB4, 0xDB, 0xAE, 0xE1, 0x17, 0xB5, + 0xFD, 0x60, 0x06, 0x7E, 0x3C, 0x02, 0x3B, 0x2D + }, + { + 0x96, 0xF2, 0x21, 0xDD, 0xC0, 0x90, 0x32, 0xB6, + 0x38, 0xB0, 0x03, 0x81, 0x88, 0xAA, 0xDB, 0xDA, + 0x76, 0x5A, 0x90, 0x2F, 0x11, 0x07, 0xD1, 0x36, + 0x7B, 0x05, 0x81, 0x4A, 0xCE, 0xB9, 0xD4, 0x39 + }, + { + 0xE0, 0x82, 0x9D, 0xFE, 0xA3, 0x40, 0xED, 0x1C, + 0x01, 0x4E, 0xAF, 0x21, 0x7B, 0xE4, 0x85, 0x46, + 0xF1, 0x99, 0x83, 0xB5, 0x85, 0x61, 0xA9, 0x41, + 0xA5, 0x14, 0x16, 0x82, 0xA6, 0x61, 0x8A, 0x9E + }, + { + 0x95, 0x7C, 0xCA, 0x0B, 0xAE, 0x33, 0x65, 0xEF, + 0x7E, 0xE4, 0x62, 0x13, 0xAB, 0x2F, 0x07, 0x1A, + 0xA1, 0xF1, 0x1A, 0x14, 0xBB, 0xB2, 0xFB, 0x6F, + 0xF0, 0xBD, 0x16, 0x17, 0x40, 0x9F, 0x71, 0x49 + }, + { + 0xCD, 0xB5, 0xBD, 0x89, 0x50, 0x1C, 0x23, 0xAB, + 0xEF, 0x5A, 0x67, 0x54, 0x14, 0xF8, 0xE6, 0x0F, + 0xF8, 0x74, 0xB2, 0x5E, 0xD5, 0x0D, 0x53, 0x3C, + 0x7A, 0xC2, 0x10, 0xCE, 0x25, 0x4A, 0x4B, 0x94 + }, + { + 0x28, 0xDA, 0x3B, 0x0C, 0xE1, 0x4D, 0xDD, 0xB2, + 0xA5, 0x88, 0xCE, 0x2D, 0x5B, 0x9C, 0x09, 0xCA, + 0x0B, 0xE0, 0x6F, 0x61, 0x3C, 0xC8, 0x46, 0x62, + 0x64, 0x57, 0x16, 0xD0, 0xEC, 0xF0, 0xF1, 0xA9 + }, + { + 0xCE, 0x20, 0x02, 0x49, 0xCF, 0x55, 0x39, 0xE1, + 0x42, 0x00, 0x69, 0x43, 0x0B, 0x97, 0xA0, 0x1A, + 0xB3, 0xCA, 0xC7, 0x7A, 0x3E, 0x09, 0x24, 0xB0, + 0xDF, 0x25, 0x81, 0x87, 0x08, 0xCA, 0xA3, 0xA4 + }, + { + 0xD9, 0x4E, 0xD2, 0x8C, 0x07, 0x2E, 0x31, 0x4E, + 0x21, 0x8B, 0x58, 0xCD, 0x1E, 0xD0, 0x80, 0x7F, + 0xEA, 0x15, 0xFF, 0xE0, 0xE7, 0xF0, 0x2F, 0x0F, + 0xDE, 0xE8, 0xDE, 0xAF, 0x80, 0xDA, 0xA4, 0x25 + }, + { + 0xDE, 0x93, 0x51, 0xA2, 0x72, 0x82, 0x82, 0x98, + 0xA1, 0x62, 0xE8, 0x9E, 0x56, 0x11, 0xE6, 0x37, + 0x9A, 0xB7, 0x3C, 0xAA, 0x31, 0x1E, 0xCC, 0x73, + 0x38, 0x92, 0xFB, 0xEB, 0x5D, 0x78, 0x76, 0x97 + }, + { + 0xEB, 0x63, 0x1D, 0x9F, 0x6E, 0x48, 0x22, 0xC4, + 0x9B, 0x65, 0xEE, 0xA9, 0x42, 0x37, 0x62, 0x50, + 0x85, 0xFC, 0x9A, 0x74, 0x7B, 0x50, 0x5D, 0x29, + 0x55, 0xFA, 0x1B, 0x48, 0x5A, 0x75, 0x68, 0x9C + }, + { + 0x15, 0xDE, 0x5F, 0x9D, 0x1F, 0x45, 0xA0, 0xFD, + 0xDF, 0x00, 0xCB, 0x45, 0xB3, 0xA9, 0x3A, 0xBE, + 0x5D, 0x2C, 0x8D, 0x86, 0xDC, 0x7F, 0xA7, 0x50, + 0xA9, 0xB6, 0xE9, 0x65, 0x58, 0x5D, 0x39, 0x65 + }, + { + 0xA9, 0xE4, 0xAC, 0x13, 0x27, 0xD2, 0xEE, 0xFD, + 0xDF, 0xE6, 0x0E, 0x6C, 0xCC, 0xDA, 0x86, 0x63, + 0x2D, 0x28, 0x41, 0xB1, 0x95, 0xB0, 0x95, 0xB4, + 0xCB, 0x60, 0xCE, 0xD6, 0x05, 0x49, 0xF7, 0xA3 + }, + { + 0x8C, 0xD9, 0x2E, 0x89, 0x49, 0x15, 0x65, 0x82, + 0xA1, 0xE7, 0xBF, 0x9B, 0xB9, 0x90, 0xF7, 0xFE, + 0x04, 0x06, 0x16, 0x63, 0xF1, 0x02, 0xC0, 0x00, + 0xDF, 0x70, 0xAB, 0xCE, 0x3E, 0xFD, 0xDF, 0x7D + }, + { + 0x43, 0x15, 0x03, 0x1E, 0x32, 0x92, 0x13, 0xDC, + 0x28, 0x9C, 0xB4, 0xA9, 0x5E, 0x98, 0x79, 0xF5, + 0x77, 0xD1, 0x2E, 0xB1, 0xF3, 0xEF, 0x67, 0x0E, + 0xED, 0xEB, 0x76, 0x07, 0x3A, 0xE7, 0x12, 0x5A + }, + { + 0x11, 0x3A, 0x86, 0x42, 0x00, 0x9A, 0x4A, 0xF9, + 0x47, 0x64, 0xD4, 0xDB, 0xE9, 0x6D, 0x0A, 0x4B, + 0xFA, 0x4C, 0x42, 0x91, 0xD5, 0x3C, 0x2E, 0xB0, + 0xE8, 0xE8, 0xBB, 0x1A, 0xC0, 0x4F, 0x46, 0x7D + }, + { + 0x30, 0x71, 0x0B, 0x7F, 0x71, 0x14, 0xD1, 0x1B, + 0x46, 0x10, 0x75, 0x63, 0x1F, 0xAB, 0xF8, 0x69, + 0x0A, 0xB5, 0x9D, 0x07, 0x83, 0xD1, 0xCE, 0x63, + 0x8F, 0xD7, 0x80, 0x8C, 0x60, 0x79, 0x3D, 0xE1 + }, + { + 0x73, 0xD2, 0x84, 0x33, 0x8F, 0x31, 0x7A, 0xD1, + 0x2E, 0x70, 0x87, 0xCA, 0x66, 0x0C, 0xEE, 0x40, + 0xF0, 0x08, 0xB2, 0xFC, 0xF2, 0x30, 0x7C, 0xB5, + 0x2F, 0xC2, 0x2F, 0x51, 0xF7, 0x9C, 0x75, 0x01 + }, + { + 0xA5, 0xF1, 0x6E, 0x13, 0xA6, 0xFC, 0xC7, 0x1A, + 0xBC, 0xD3, 0x93, 0x50, 0x9E, 0x5B, 0x39, 0x3F, + 0x5A, 0x89, 0x66, 0x6D, 0x22, 0x27, 0x45, 0xB1, + 0xF9, 0xEE, 0xBB, 0xF4, 0x23, 0x7A, 0xC9, 0x24 + }, + { + 0x3C, 0x8B, 0x35, 0xA0, 0x66, 0xF5, 0x79, 0xC0, + 0x14, 0x08, 0x19, 0x13, 0x23, 0xC2, 0x18, 0xB8, + 0x7E, 0x93, 0xD2, 0xA7, 0x7D, 0xB4, 0x0B, 0xFD, + 0xCE, 0xD1, 0x25, 0xAE, 0x73, 0x01, 0x5A, 0x04 + }, + { + 0xE3, 0xF7, 0x12, 0x27, 0xB5, 0x8D, 0xA7, 0xCE, + 0x82, 0x5A, 0x4A, 0xC5, 0xD7, 0xBE, 0xF0, 0xC8, + 0x7F, 0x92, 0x44, 0x6B, 0x11, 0x77, 0x0F, 0x6F, + 0x6D, 0x03, 0xB1, 0x11, 0x53, 0x74, 0xB6, 0xF9 + }, + { + 0x67, 0x83, 0xFE, 0xCE, 0x96, 0xD8, 0x59, 0x37, + 0xE0, 0x72, 0x0C, 0x0A, 0xE8, 0xB7, 0xAB, 0x39, + 0x81, 0xD1, 0x0B, 0xAE, 0xB3, 0xEC, 0x88, 0xE6, + 0xAA, 0x65, 0xEA, 0xDD, 0x50, 0xB9, 0x74, 0x02 + }, + { + 0xCE, 0x39, 0xA2, 0x31, 0xE8, 0x00, 0x5F, 0x44, + 0xC8, 0x4D, 0xA6, 0x68, 0xC7, 0x02, 0x13, 0x9E, + 0x67, 0x5E, 0xD3, 0x1A, 0x20, 0x89, 0x47, 0x45, + 0x31, 0xA4, 0x69, 0x4B, 0x19, 0x7D, 0x2F, 0x5C + }, + { + 0x30, 0x65, 0x8D, 0x45, 0xEC, 0x27, 0x44, 0x52, + 0x04, 0x79, 0x93, 0x99, 0x13, 0xAC, 0xF4, 0x3B, + 0x76, 0x1E, 0x37, 0xB8, 0x35, 0xC3, 0x11, 0x97, + 0xE3, 0x2A, 0x23, 0x04, 0x10, 0xCE, 0xFC, 0x3A + }, + { + 0x16, 0x6F, 0x3B, 0xCE, 0x6C, 0xC1, 0x67, 0x4A, + 0x23, 0xA8, 0x42, 0x2C, 0x30, 0xC7, 0x42, 0xEE, + 0x97, 0xB9, 0x04, 0x5E, 0xFD, 0x7D, 0x9C, 0x79, + 0x80, 0xBC, 0xF6, 0x57, 0xC9, 0xCA, 0xA7, 0x8A + }, + { + 0xCC, 0xE5, 0xA1, 0xF9, 0x85, 0xC8, 0x05, 0x4F, + 0x01, 0xAD, 0x6B, 0xBA, 0xC8, 0x32, 0x9B, 0x42, + 0x5F, 0xF0, 0x05, 0x42, 0xB4, 0xB9, 0xA2, 0x92, + 0x8E, 0xFA, 0xBA, 0xC5, 0xFC, 0x3B, 0xD7, 0xCB + }, + { + 0xB5, 0xF8, 0x7F, 0x3F, 0x0B, 0xF0, 0x73, 0x73, + 0xB4, 0x57, 0x29, 0x7C, 0xCD, 0x0F, 0x87, 0xDA, + 0x2F, 0xA8, 0xAC, 0xE8, 0xCA, 0x5C, 0xD9, 0x09, + 0xF2, 0x94, 0xEE, 0x3F, 0x29, 0x86, 0x6D, 0x4D + }, + { + 0xFF, 0xA6, 0x87, 0xFD, 0xEC, 0x40, 0xDC, 0x96, + 0x81, 0xC3, 0x9D, 0x0B, 0x8A, 0x58, 0xDB, 0x63, + 0x84, 0xDD, 0x7D, 0x57, 0x02, 0x7F, 0xF7, 0xB1, + 0x23, 0x03, 0x0B, 0xEC, 0x85, 0x70, 0x8B, 0x87 + }, + { + 0x25, 0x64, 0x0C, 0xE3, 0x33, 0x6D, 0x88, 0x98, + 0xC7, 0xDB, 0xD0, 0x47, 0xCB, 0xE0, 0x14, 0xA4, + 0xA6, 0x58, 0xA1, 0xC4, 0x3E, 0xFF, 0x80, 0xED, + 0xEC, 0x70, 0x04, 0x05, 0x11, 0xA4, 0xEB, 0x7E + }, + { + 0x48, 0xBB, 0x97, 0xC2, 0x65, 0x84, 0x9F, 0x62, + 0x6F, 0x08, 0xEC, 0xBF, 0xE7, 0x1B, 0x7E, 0xCF, + 0xAF, 0xBB, 0x21, 0xD3, 0x74, 0x69, 0xE5, 0x14, + 0x23, 0xFD, 0xF8, 0xBB, 0x70, 0xCD, 0x2F, 0x58 + }, + { + 0x67, 0x27, 0xAA, 0x26, 0x84, 0x37, 0xDF, 0x75, + 0x06, 0x6C, 0x2F, 0x51, 0x89, 0x0A, 0x6A, 0x1F, + 0xC0, 0xB6, 0xE6, 0x3B, 0xDD, 0x66, 0xA5, 0x47, + 0x83, 0x57, 0x10, 0x2F, 0xFE, 0x8D, 0xDE, 0xFF + }, + { + 0x56, 0x4C, 0xFE, 0x03, 0x58, 0xFA, 0x23, 0xC9, + 0xB6, 0xDC, 0x7E, 0x53, 0xCA, 0xFD, 0x7D, 0x6E, + 0xAC, 0x08, 0x4D, 0x5F, 0xEA, 0xD8, 0x05, 0x30, + 0x4A, 0xF5, 0x60, 0xFB, 0xC7, 0xEF, 0xC3, 0xA5 + }, + { + 0x5B, 0x06, 0xA0, 0x94, 0xB9, 0xA9, 0xFD, 0xCB, + 0x74, 0xEB, 0xFF, 0xB3, 0xC9, 0x3A, 0xFF, 0x96, + 0xBC, 0xE7, 0xCE, 0xD5, 0x76, 0xFA, 0xF1, 0xBE, + 0xAF, 0x5D, 0xF2, 0xBD, 0x4B, 0x7A, 0x54, 0x92 + }, + { + 0x03, 0xFE, 0x83, 0xFF, 0x7D, 0xB9, 0xD2, 0x79, + 0x53, 0x8A, 0x1A, 0xE6, 0xDC, 0x22, 0x90, 0xD1, + 0x42, 0x84, 0x84, 0xAE, 0x16, 0x4B, 0xC4, 0x69, + 0x29, 0x43, 0xB4, 0xE6, 0x29, 0x89, 0xDC, 0x83 + }, + { + 0x5C, 0x8E, 0x22, 0xE3, 0x3F, 0x11, 0xC6, 0xCC, + 0x19, 0xF0, 0x74, 0x45, 0xF5, 0xF4, 0x55, 0xCD, + 0xA6, 0x3B, 0x7C, 0xA2, 0xB8, 0x44, 0xCB, 0x8E, + 0xC0, 0xCC, 0x68, 0xA4, 0x19, 0xB3, 0xB6, 0x76 + }, + { + 0xF1, 0x55, 0x12, 0x08, 0x02, 0x41, 0xB1, 0x46, + 0x84, 0x40, 0x36, 0x9F, 0x60, 0x40, 0xDA, 0x92, + 0xDB, 0x45, 0x4D, 0x6A, 0xA6, 0xE9, 0x22, 0x85, + 0x81, 0xA3, 0x51, 0xF6, 0xD9, 0x52, 0xE3, 0xDA + }, + { + 0x56, 0xB1, 0xE6, 0xC3, 0xC4, 0x72, 0x14, 0x97, + 0x9C, 0x84, 0x6F, 0x11, 0x49, 0x40, 0xDC, 0x54, + 0xD7, 0x7F, 0xD1, 0xF4, 0x70, 0x69, 0x97, 0x25, + 0x7F, 0xB8, 0xC8, 0x85, 0x1B, 0xCA, 0xE9, 0xC4 + }, + { + 0x08, 0xB2, 0x24, 0xBE, 0x4D, 0x72, 0xB5, 0xBA, + 0xF5, 0x01, 0x65, 0x02, 0xA9, 0xE5, 0x7D, 0x27, + 0x13, 0x34, 0x53, 0x89, 0xA4, 0x2F, 0xF4, 0x98, + 0xAB, 0x25, 0xE4, 0xA3, 0xC0, 0xF3, 0xC7, 0xB4 + }, + { + 0x61, 0x79, 0xE7, 0x07, 0xB0, 0x00, 0x88, 0x8F, + 0x09, 0x6F, 0x61, 0x9C, 0x99, 0x49, 0x10, 0x38, + 0xE0, 0xFA, 0x97, 0x8D, 0x2E, 0x51, 0xB3, 0x04, + 0x8E, 0x95, 0xDF, 0x31, 0xEE, 0x19, 0xFE, 0xA2 + }, + { + 0xD4, 0x4B, 0x43, 0xDF, 0xE2, 0xC3, 0x97, 0x25, + 0xF2, 0x44, 0xEA, 0x46, 0x4A, 0x38, 0xDD, 0x5C, + 0xD2, 0x98, 0x37, 0xFB, 0x3C, 0xA8, 0x94, 0xB3, + 0xA8, 0x96, 0x6D, 0x1C, 0xCE, 0x4C, 0xA7, 0x43 + }, + { + 0xB5, 0x33, 0x5B, 0x1C, 0xEB, 0xBA, 0x8F, 0x00, + 0x8A, 0x71, 0x26, 0x8B, 0xCC, 0xE6, 0x12, 0x76, + 0xAA, 0x86, 0x35, 0x5E, 0x4F, 0x75, 0xB7, 0x3E, + 0x1B, 0xAF, 0xFC, 0xB2, 0x29, 0xDD, 0x0C, 0xEF + }, + { + 0x13, 0xAF, 0x6D, 0x86, 0xA3, 0xF8, 0xD1, 0xB8, + 0x80, 0x62, 0xB3, 0xE4, 0x19, 0xBB, 0x23, 0xFF, + 0x31, 0xA1, 0xFF, 0x2D, 0x82, 0xFC, 0x58, 0x78, + 0x78, 0x1E, 0x61, 0x33, 0x33, 0xEB, 0x22, 0xB4 + }, + { + 0x77, 0x49, 0x12, 0xF8, 0x5A, 0xDE, 0x31, 0x26, + 0x10, 0x49, 0x08, 0x58, 0xDA, 0xD3, 0xE2, 0x92, + 0x73, 0x53, 0x9A, 0x0B, 0xDF, 0x1A, 0x09, 0x4A, + 0x80, 0x35, 0xBB, 0x67, 0xAD, 0x74, 0x9D, 0xAF + }, + { + 0xFE, 0x32, 0x23, 0x24, 0xCD, 0x58, 0x3A, 0xCD, + 0xDE, 0xE2, 0xA4, 0x67, 0x8D, 0xE3, 0x18, 0x3D, + 0x9C, 0xED, 0xA8, 0x6E, 0xA3, 0x6E, 0xB7, 0xC1, + 0x1A, 0x66, 0xFC, 0xE1, 0xD9, 0x56, 0x27, 0xEB + }, + { + 0x3F, 0xCE, 0xDF, 0x19, 0xC2, 0x76, 0x02, 0x79, + 0xF6, 0xA6, 0x0A, 0x05, 0xD5, 0xC6, 0xF1, 0x84, + 0xB3, 0x54, 0x19, 0xCB, 0xAD, 0x3A, 0x20, 0x66, + 0x7D, 0xEE, 0x74, 0xBB, 0x1B, 0x2C, 0x75, 0x3B + }, + { + 0x46, 0x75, 0xE7, 0x57, 0xE2, 0xAC, 0x5B, 0xD8, + 0x44, 0x8F, 0xD6, 0xAA, 0x02, 0x18, 0x25, 0x34, + 0xAF, 0x15, 0xB6, 0xE0, 0x67, 0x21, 0x8F, 0x59, + 0x33, 0x40, 0xED, 0xE9, 0xE7, 0x30, 0xE0, 0xB4 + }, + { + 0xD5, 0x39, 0x75, 0x36, 0x5B, 0xB5, 0x3E, 0xD5, + 0x14, 0xF9, 0x01, 0xB0, 0x93, 0xA8, 0x9A, 0xC3, + 0x1B, 0xEF, 0x59, 0x74, 0xFF, 0xD9, 0x45, 0x35, + 0xA8, 0x66, 0xC0, 0x5D, 0x06, 0xB5, 0x9C, 0xC5 + }, + { + 0x05, 0x20, 0xA6, 0x57, 0x3E, 0x11, 0xE5, 0x1A, + 0xE0, 0x34, 0xA9, 0x7E, 0xB6, 0x58, 0x2D, 0xAF, + 0x1D, 0x0A, 0xE6, 0xAC, 0x1A, 0x5A, 0x83, 0xD5, + 0x53, 0x2C, 0x4D, 0x7A, 0x53, 0x24, 0xED, 0xCE + }, + { + 0xBA, 0xEA, 0x4A, 0xA1, 0xAE, 0x41, 0x20, 0x49, + 0x7B, 0x47, 0x73, 0xD1, 0xFB, 0x39, 0x35, 0xA4, + 0xE8, 0xC5, 0x97, 0x1D, 0xE3, 0x86, 0x18, 0xCE, + 0x5B, 0x45, 0x04, 0x61, 0x72, 0x33, 0xA1, 0x11 + }, + { + 0x74, 0x59, 0xFD, 0x42, 0x4F, 0xA6, 0x8D, 0x5F, + 0x86, 0xA1, 0x20, 0x11, 0x85, 0x65, 0x5B, 0x54, + 0xB7, 0x2B, 0x7B, 0x9D, 0x1E, 0x27, 0x86, 0xF0, + 0xA7, 0x5C, 0xC6, 0x74, 0xD5, 0x69, 0xCC, 0x2E + }, + { + 0x7A, 0x35, 0x4D, 0xA8, 0xB8, 0xBA, 0xF0, 0x32, + 0xEA, 0xCB, 0x55, 0x9D, 0xA2, 0x2A, 0x42, 0x79, + 0xC6, 0xA4, 0xB5, 0xF9, 0x6D, 0x73, 0xD1, 0xEC, + 0xD1, 0x53, 0xFE, 0x52, 0x39, 0x42, 0xB5, 0x67 + }, + { + 0x51, 0x86, 0x1D, 0x41, 0x62, 0x2B, 0x65, 0x47, + 0xEA, 0xBE, 0xE5, 0xE8, 0xCC, 0x08, 0xDB, 0x29, + 0xDD, 0xDD, 0x7C, 0x2B, 0xB3, 0x12, 0xCD, 0xEE, + 0x19, 0x05, 0xF0, 0xCA, 0x96, 0x95, 0xC9, 0xCF + }, + { + 0xC1, 0x5D, 0xE1, 0xD4, 0x8F, 0x82, 0xCA, 0xBC, + 0x96, 0xFB, 0xF0, 0xBE, 0xFF, 0x44, 0x4E, 0x7A, + 0x1C, 0x65, 0xAD, 0x2E, 0xE9, 0xFF, 0x5B, 0x42, + 0x9F, 0xEC, 0x63, 0xF8, 0x05, 0x9E, 0x82, 0x59 + }, + { + 0x7B, 0x9C, 0xBE, 0x43, 0x82, 0x90, 0xA7, 0x7F, + 0xA7, 0x60, 0xA6, 0xF8, 0x79, 0x40, 0x89, 0x6F, + 0x74, 0x6A, 0x95, 0xE6, 0xA7, 0x03, 0xB8, 0x9E, + 0x02, 0xB0, 0x56, 0xFC, 0xB1, 0xB8, 0xED, 0x08 + }, + { + 0x60, 0x76, 0x31, 0xC7, 0xA2, 0xB7, 0xAD, 0xC2, + 0xB0, 0x20, 0x73, 0x19, 0x0C, 0xD3, 0xC1, 0xB0, + 0x36, 0x61, 0x83, 0x5E, 0x52, 0x42, 0x4F, 0x99, + 0x48, 0xF8, 0xE9, 0xD3, 0x76, 0x78, 0x7A, 0x17 + }, + { + 0xA5, 0x05, 0xE1, 0x11, 0x86, 0x9F, 0x40, 0xB6, + 0xDC, 0x52, 0x0A, 0x4D, 0xAA, 0x02, 0x9F, 0x83, + 0x2B, 0x15, 0xB8, 0x76, 0x27, 0xF4, 0xB2, 0xF5, + 0x3B, 0x02, 0xB8, 0x0B, 0xE8, 0x18, 0x44, 0xB5 + }, + { + 0x52, 0x86, 0x05, 0xF1, 0x9D, 0x99, 0xEA, 0x86, + 0x31, 0x68, 0x7B, 0x0E, 0x76, 0x6A, 0xD5, 0xD7, + 0x03, 0xBE, 0x6B, 0xC7, 0x89, 0xF6, 0xEB, 0x47, + 0x5F, 0x76, 0x02, 0xC5, 0xE0, 0xAC, 0x0E, 0xF0 + }, + { + 0xEB, 0x06, 0x5C, 0xF1, 0xE5, 0xB1, 0x24, 0x1B, + 0x5F, 0x8E, 0x3A, 0xCA, 0x16, 0x0A, 0xDA, 0xEF, + 0x32, 0x7A, 0x43, 0x26, 0xC7, 0xFE, 0x28, 0x14, + 0x56, 0x34, 0xF1, 0xCC, 0xFE, 0xFF, 0x4E, 0x1E + }, + { + 0x55, 0x6C, 0xBA, 0x0D, 0x6A, 0x83, 0x8D, 0x9C, + 0x29, 0xFD, 0x3F, 0x5D, 0x7A, 0x98, 0x59, 0x42, + 0x6F, 0x67, 0x9B, 0xD9, 0x58, 0x34, 0x62, 0x09, + 0x1D, 0x95, 0x0C, 0x65, 0x3C, 0x58, 0x26, 0xD4 + }, + { + 0xB0, 0x77, 0xA7, 0x7C, 0x47, 0xE6, 0xE8, 0x67, + 0xDA, 0xD1, 0x1E, 0x26, 0x73, 0x80, 0xAD, 0x9C, + 0x91, 0xD4, 0x4D, 0xB1, 0x17, 0x4E, 0x0E, 0x70, + 0xC0, 0x31, 0x00, 0xB9, 0x56, 0xF7, 0x3F, 0xF3 + }, + { + 0x38, 0xB3, 0xF1, 0x8D, 0xA9, 0x81, 0x0B, 0xD4, + 0x9C, 0x20, 0xA1, 0xAB, 0xCD, 0x34, 0x52, 0x91, + 0xDE, 0xBC, 0x75, 0xF6, 0x87, 0xE4, 0xC7, 0x89, + 0x8F, 0x03, 0xF7, 0xE4, 0x95, 0x39, 0x31, 0xB1 + }, + { + 0x27, 0x2D, 0xE9, 0xE1, 0xAA, 0x94, 0x05, 0x7D, + 0x6A, 0x66, 0x90, 0x08, 0x7B, 0x54, 0x59, 0x29, + 0xCE, 0x23, 0x73, 0x5D, 0x5D, 0xC1, 0x7E, 0x31, + 0x53, 0x4E, 0x59, 0x13, 0x1A, 0x16, 0x1B, 0xB4 + }, + { + 0xCC, 0x59, 0x47, 0x05, 0x49, 0xB9, 0x7B, 0x6E, + 0x55, 0x28, 0x8B, 0x41, 0xDB, 0x97, 0xC1, 0x7F, + 0x97, 0x37, 0x7D, 0x33, 0x6F, 0x4C, 0xE2, 0x47, + 0x95, 0xD3, 0x78, 0x6E, 0xA6, 0x97, 0xE3, 0x38 + }, + { + 0x7B, 0x67, 0xCE, 0x88, 0x6B, 0x75, 0x4F, 0xA5, + 0x81, 0xED, 0x59, 0xFA, 0x08, 0xF7, 0x4E, 0xD3, + 0x49, 0x97, 0xF3, 0x38, 0xC8, 0x2A, 0x48, 0xB7, + 0x35, 0x96, 0x55, 0x55, 0x4E, 0xDF, 0xD6, 0x99 + }, + { + 0xAC, 0x46, 0x1D, 0xB7, 0xA7, 0x15, 0xC8, 0x3B, + 0x91, 0x60, 0x85, 0x32, 0x8A, 0x1F, 0x7B, 0x53, + 0x41, 0x2C, 0xA1, 0xA0, 0x93, 0x99, 0x0B, 0x61, + 0x6B, 0xC5, 0xA3, 0x9D, 0xC0, 0x9E, 0xBC, 0x7D + }, + { + 0xA1, 0x3C, 0xC9, 0xE9, 0x3C, 0x46, 0xF5, 0x94, + 0x7F, 0x20, 0xD8, 0xF4, 0xB4, 0x6A, 0xEF, 0x0D, + 0xBE, 0xB2, 0xB3, 0xAF, 0xDC, 0xF0, 0xF5, 0x87, + 0x04, 0x0F, 0x55, 0x58, 0x98, 0x4E, 0x6C, 0xB3 + }, + { + 0x64, 0x16, 0x83, 0x87, 0x35, 0xFF, 0x61, 0x98, + 0xE8, 0xE3, 0x4B, 0x85, 0x4B, 0x3A, 0xA4, 0xA9, + 0xFD, 0xB1, 0x1C, 0xFE, 0xE7, 0x22, 0x42, 0x5B, + 0x69, 0xF4, 0x80, 0x2A, 0xCF, 0x94, 0xCE, 0x3B + }, + { + 0x54, 0xFC, 0xD6, 0xEA, 0x26, 0x7A, 0x27, 0xD6, + 0x2A, 0x3D, 0x64, 0x63, 0x03, 0x45, 0xEE, 0xE6, + 0x03, 0x50, 0x27, 0x98, 0x05, 0x45, 0x87, 0xEC, + 0x97, 0x07, 0x02, 0x07, 0xB3, 0xEB, 0x20, 0x6F + }, + { + 0x76, 0xA7, 0x96, 0x73, 0x48, 0xDF, 0x22, 0xEF, + 0xC7, 0x21, 0x37, 0x2C, 0x70, 0x02, 0x05, 0xBC, + 0xAF, 0x1F, 0x79, 0x8A, 0x9D, 0x2C, 0xE3, 0x8D, + 0x62, 0x40, 0xB0, 0xFD, 0xDB, 0xF9, 0xDD, 0x7F + }, + { + 0xE2, 0x56, 0xD2, 0xB7, 0x29, 0xB2, 0xDE, 0x7E, + 0xA0, 0xFD, 0x8E, 0xFF, 0x77, 0xC6, 0xC7, 0xC1, + 0xD8, 0x9C, 0xE3, 0x16, 0x72, 0x06, 0x55, 0x3B, + 0x87, 0x84, 0xD6, 0x63, 0x35, 0x04, 0x3F, 0xB6 + }, + { + 0xC2, 0x68, 0xBC, 0x0B, 0x25, 0x8E, 0x3A, 0x4A, + 0x47, 0xA3, 0xA8, 0xB3, 0x00, 0x88, 0x9B, 0xD4, + 0xCA, 0x3C, 0x67, 0xC7, 0x28, 0xBF, 0x24, 0x10, + 0x8E, 0xF2, 0xB4, 0xFF, 0x41, 0xD1, 0x22, 0xB2 + }, + { + 0x45, 0x92, 0x71, 0x13, 0x2D, 0x37, 0xDE, 0x56, + 0xD6, 0x94, 0x42, 0xDC, 0xE7, 0x66, 0x58, 0x80, + 0xF6, 0x4A, 0xE3, 0x42, 0xB5, 0x57, 0xE3, 0x3B, + 0xAB, 0x56, 0xA9, 0x18, 0x44, 0xA5, 0x46, 0x39 + }, + { + 0xEA, 0x14, 0x81, 0x09, 0xA6, 0xE0, 0xDB, 0x40, + 0xDA, 0x19, 0xFD, 0x07, 0xC4, 0x6F, 0x4E, 0x2A, + 0xEA, 0x6C, 0x13, 0x88, 0x21, 0x82, 0x4F, 0x5C, + 0xBA, 0xF9, 0x53, 0x6F, 0xA8, 0x56, 0x08, 0x80 + }, + { + 0xF3, 0x5C, 0xF3, 0xBF, 0x49, 0x92, 0x64, 0xF2, + 0x64, 0xEF, 0xBE, 0x1F, 0x98, 0x66, 0x2A, 0x36, + 0xEB, 0xC9, 0xBF, 0xA3, 0x05, 0x50, 0xD3, 0x46, + 0x43, 0xB0, 0x61, 0x2A, 0x3E, 0x23, 0x1A, 0x83 + }, + { + 0xBA, 0xE4, 0x65, 0x2C, 0xFC, 0x0B, 0x4D, 0xEF, + 0x30, 0xBF, 0x0A, 0x5A, 0x62, 0xD4, 0xB2, 0x71, + 0x63, 0x55, 0x0C, 0xDC, 0x90, 0x83, 0x8A, 0xCA, + 0x6C, 0x83, 0xE7, 0xA6, 0x62, 0x64, 0x69, 0x46 + }, + { + 0x11, 0x7F, 0x95, 0xA2, 0x5E, 0x03, 0x5D, 0x4C, + 0x87, 0x9B, 0x8A, 0x09, 0x6C, 0xCA, 0xCD, 0x37, + 0x9B, 0x41, 0xB4, 0x96, 0x88, 0xC3, 0xA3, 0xC9, + 0xB7, 0x29, 0xF6, 0xE7, 0x5D, 0xDF, 0x90, 0xC0 + }, + { + 0xD2, 0x65, 0xE3, 0x56, 0x66, 0x88, 0xB6, 0xF0, + 0xE9, 0xD3, 0xCD, 0xC0, 0x3F, 0xE6, 0xCE, 0x07, + 0xE5, 0x41, 0xA5, 0x10, 0xCE, 0xF5, 0xE8, 0xB0, + 0xB7, 0xED, 0x3D, 0x9F, 0x21, 0x35, 0x39, 0xC7 + }, + { + 0xCD, 0x33, 0x3B, 0x92, 0xD8, 0xF9, 0xA7, 0xF7, + 0x2F, 0x3F, 0x01, 0x57, 0x8E, 0x3F, 0x71, 0x2B, + 0x3E, 0xD5, 0x5E, 0x82, 0x3C, 0x79, 0xDE, 0x71, + 0xDC, 0xB6, 0xFC, 0xDE, 0x0F, 0xEB, 0x08, 0x77 + }, + { + 0x2C, 0x7E, 0x4E, 0x3C, 0xC3, 0xCD, 0xAE, 0x05, + 0x1C, 0x28, 0x2C, 0x82, 0x2F, 0x8C, 0x33, 0xB1, + 0x40, 0x40, 0x1D, 0xBC, 0x7D, 0x39, 0x33, 0xB4, + 0x4E, 0xC3, 0x5A, 0x66, 0x78, 0xA9, 0xC9, 0x30 + }, + { + 0x43, 0xDF, 0x03, 0xD4, 0xAC, 0x0F, 0x37, 0x9C, + 0xDB, 0x72, 0x87, 0x27, 0xE2, 0x17, 0xA2, 0x88, + 0x6B, 0xCD, 0x19, 0xB4, 0xF1, 0x37, 0x6B, 0xBC, + 0xA2, 0xD0, 0x86, 0xAC, 0x69, 0xD4, 0xE6, 0x3F + }, + { + 0x4E, 0xDC, 0xB7, 0x48, 0x2C, 0x0E, 0x1C, 0x96, + 0x3A, 0xC8, 0xB9, 0x4A, 0xE7, 0x60, 0xB1, 0xAC, + 0x56, 0x8D, 0x28, 0x78, 0xEC, 0xB6, 0x24, 0x60, + 0x38, 0x37, 0x60, 0x8A, 0x06, 0x05, 0xF8, 0x65 + }, + { + 0xE6, 0x88, 0xD2, 0x65, 0x66, 0x65, 0xEA, 0x2E, + 0x01, 0x0E, 0x0D, 0xCD, 0x80, 0xF2, 0xAE, 0x75, + 0x83, 0x1A, 0x86, 0xEC, 0x93, 0xD3, 0x96, 0x52, + 0xCD, 0xBA, 0x07, 0x7E, 0xF7, 0x60, 0x82, 0xAD + }, + { + 0xE4, 0x2F, 0x7E, 0xB6, 0xB6, 0x75, 0x44, 0xB0, + 0xDE, 0xB4, 0x45, 0x0D, 0xA1, 0x01, 0x63, 0xD5, + 0x94, 0xBE, 0xC7, 0x76, 0xBB, 0xE0, 0xB6, 0x07, + 0x2C, 0x58, 0x15, 0x20, 0x51, 0x1F, 0x39, 0xF4 + }, + { + 0x62, 0xE3, 0x7D, 0x81, 0x1B, 0xBF, 0xB0, 0xEA, + 0x56, 0x1C, 0xAA, 0x03, 0x63, 0x6C, 0x2F, 0x10, + 0xDA, 0xC8, 0x9F, 0x3B, 0xBC, 0x0F, 0x5D, 0x6A, + 0x3D, 0x71, 0x71, 0x3D, 0x6E, 0xC3, 0xC8, 0x99 + }, + { + 0xDB, 0xDF, 0x8E, 0x28, 0x7C, 0x63, 0x32, 0xE8, + 0x0C, 0x92, 0x7D, 0x4F, 0xD1, 0xF6, 0xDE, 0x4D, + 0x85, 0x6B, 0xD8, 0xD9, 0x5D, 0x42, 0x30, 0x49, + 0xBB, 0x6B, 0xD8, 0x5C, 0x71, 0x12, 0xF6, 0x88 + }, + { + 0x31, 0x02, 0xF3, 0x18, 0x42, 0xB6, 0xAB, 0x00, + 0xEB, 0x60, 0x19, 0x55, 0x03, 0x45, 0x23, 0xB0, + 0x9D, 0x99, 0xD1, 0x02, 0xE2, 0x27, 0xD6, 0x83, + 0xC3, 0xAE, 0x4D, 0x21, 0x4A, 0x1B, 0xB6, 0xCC + }, + { + 0xDE, 0x44, 0xE5, 0xCE, 0x96, 0x7E, 0xB1, 0xCA, + 0x20, 0x48, 0x49, 0x38, 0xE2, 0x55, 0xCD, 0x49, + 0x05, 0x94, 0x3C, 0x5E, 0x47, 0xA2, 0x83, 0xF8, + 0x77, 0x37, 0x46, 0x1A, 0xF7, 0xD8, 0xD1, 0xA2 + }, + { + 0x28, 0x1B, 0xFE, 0xA1, 0x68, 0x09, 0xFE, 0x1E, + 0xFF, 0x73, 0xA7, 0x76, 0xCB, 0xCB, 0xF6, 0xBA, + 0x44, 0xF6, 0xF3, 0x26, 0x90, 0x1F, 0x1E, 0x2F, + 0x20, 0xEC, 0x8C, 0x14, 0xDC, 0xB0, 0xD2, 0x50 + }, + { + 0x0B, 0x44, 0xB0, 0x36, 0xD3, 0x00, 0x34, 0x09, + 0x00, 0x94, 0xE0, 0x0A, 0xF2, 0xF9, 0x10, 0x67, + 0xF3, 0xBA, 0x4F, 0xF0, 0xC7, 0x16, 0x09, 0xB4, + 0xC0, 0x33, 0x79, 0xBF, 0xED, 0x4C, 0xE0, 0x83 + }, + { + 0x6A, 0x73, 0x37, 0xE8, 0x20, 0xCC, 0x80, 0xE6, + 0x23, 0xF2, 0xC9, 0x46, 0x0B, 0xFA, 0x41, 0xFF, + 0x54, 0x2E, 0xC8, 0xB2, 0x76, 0xC4, 0xB6, 0xBD, + 0xED, 0x30, 0xF2, 0xAD, 0xD4, 0xB4, 0x2B, 0x14 + }, + { + 0xA8, 0x19, 0x90, 0xB7, 0xB4, 0xEB, 0xB5, 0x19, + 0x5F, 0x95, 0xD3, 0xE2, 0x7A, 0x8D, 0xB9, 0x67, + 0x41, 0x9B, 0x3D, 0xA5, 0xF6, 0x41, 0xF0, 0x1F, + 0xB6, 0x82, 0x73, 0xA6, 0xC4, 0xC0, 0xBC, 0x9E + }, + { + 0x9B, 0x2F, 0xAA, 0x07, 0xD4, 0xA8, 0xA7, 0xE9, + 0xA8, 0x96, 0xF9, 0xC2, 0x6E, 0x47, 0xBF, 0x79, + 0x9F, 0x01, 0x65, 0xAD, 0xEF, 0xFC, 0x6C, 0xD5, + 0x08, 0xED, 0x4E, 0x50, 0xE7, 0xCF, 0x8E, 0x2F + }, + { + 0xF2, 0xA0, 0x3A, 0x9E, 0x43, 0xEC, 0x9F, 0x07, + 0xB5, 0x71, 0xFF, 0xF6, 0x3F, 0x45, 0xD4, 0xC9, + 0xED, 0xE7, 0x1A, 0x5C, 0xDF, 0xF8, 0xFB, 0x76, + 0x5F, 0x2A, 0xC1, 0x89, 0x24, 0x75, 0xE9, 0x73 + }, + { + 0xED, 0xC2, 0x9D, 0x7E, 0x73, 0x68, 0x91, 0x2A, + 0x2F, 0xDD, 0x09, 0xF4, 0x87, 0x33, 0x0E, 0x2D, + 0xC9, 0xFB, 0xF7, 0xA8, 0x32, 0x72, 0x8E, 0x47, + 0x9E, 0x59, 0x19, 0xAC, 0xC2, 0x8F, 0xBA, 0x4B + }, + { + 0x11, 0x27, 0x7F, 0x07, 0xCD, 0xC0, 0x74, 0x27, + 0xB8, 0x9D, 0x70, 0xFE, 0xB6, 0x81, 0x6D, 0x55, + 0x13, 0xE4, 0xF9, 0x30, 0x0F, 0x82, 0xD8, 0x93, + 0xE5, 0x75, 0x1A, 0x93, 0x99, 0xB2, 0xA5, 0x34 + }, + { + 0x0B, 0xD9, 0xC3, 0x59, 0xD7, 0xA0, 0xE4, 0xD5, + 0x09, 0x85, 0xD0, 0x8B, 0xEF, 0xEB, 0x13, 0x66, + 0x50, 0xC2, 0x7A, 0x54, 0xA3, 0x5D, 0xD6, 0xCA, + 0xA9, 0xB3, 0xBE, 0x04, 0x39, 0xD5, 0x47, 0x44 + }, + { + 0x25, 0xAC, 0x73, 0x08, 0xB7, 0x4D, 0x0C, 0xA8, + 0xDC, 0x71, 0xE4, 0x1B, 0x5E, 0xF9, 0x88, 0xE6, + 0x86, 0x80, 0x26, 0x54, 0x05, 0xAA, 0xDB, 0x58, + 0xE5, 0x1A, 0x0A, 0x5F, 0xEC, 0xB0, 0xBC, 0xB3 + }, + { + 0x7C, 0xF8, 0x68, 0x3F, 0xDF, 0xFB, 0xD5, 0x93, + 0xA4, 0xF1, 0xED, 0x02, 0x38, 0xA2, 0x64, 0x1E, + 0x1C, 0xEC, 0x33, 0x1F, 0x3C, 0x53, 0xED, 0x20, + 0x07, 0x26, 0xD2, 0x8D, 0xA5, 0x42, 0x73, 0xA9 + }, + { + 0x1B, 0x9F, 0x26, 0xE4, 0xD6, 0x31, 0xE1, 0x2E, + 0xED, 0x61, 0xD3, 0x1B, 0xDD, 0x2A, 0x59, 0x43, + 0xDC, 0x10, 0x7D, 0xC2, 0x1B, 0x24, 0xC3, 0x88, + 0x0D, 0x07, 0x2A, 0xF9, 0x77, 0x4A, 0x02, 0xE6 + }, + { + 0x4D, 0x86, 0x08, 0x7F, 0xB3, 0xA4, 0x1C, 0x23, + 0xF1, 0x59, 0x72, 0x86, 0x6E, 0x51, 0x1C, 0xE3, + 0x1B, 0x08, 0x31, 0xF5, 0x25, 0xA4, 0x53, 0xDB, + 0xF7, 0xE7, 0x86, 0x41, 0xE2, 0xBA, 0x20, 0x1F + }, + { + 0xE1, 0xD8, 0xA0, 0x92, 0xD4, 0x3E, 0x27, 0x93, + 0x97, 0x57, 0xE9, 0x30, 0x4D, 0x41, 0x56, 0x23, + 0x33, 0x2D, 0x98, 0x32, 0xCE, 0x08, 0x3A, 0x70, + 0x4B, 0x29, 0xA0, 0x80, 0x3F, 0x00, 0xE8, 0x89 + }, + { + 0xA6, 0xFF, 0x48, 0x32, 0xBF, 0x83, 0xDB, 0xB2, + 0x23, 0x6E, 0x8B, 0x2B, 0x38, 0xEA, 0x93, 0x78, + 0x96, 0xCA, 0x9D, 0xCA, 0x73, 0x01, 0xED, 0x35, + 0xD0, 0x93, 0x59, 0x10, 0xAF, 0x53, 0xF8, 0x5A + }, + { + 0x4F, 0xF8, 0x2F, 0x4B, 0xB7, 0x50, 0xFB, 0x3C, + 0x54, 0x70, 0x5E, 0xCF, 0xA6, 0x11, 0x82, 0xC9, + 0x30, 0x2A, 0xB3, 0xCA, 0x8A, 0x50, 0x8F, 0x7E, + 0xDD, 0xFC, 0x6F, 0xAB, 0x3B, 0x43, 0x81, 0xBE + }, + { + 0x74, 0xD9, 0x18, 0x81, 0xF1, 0x6E, 0x0C, 0xFE, + 0x66, 0x6F, 0xE3, 0x17, 0x6C, 0xEB, 0x94, 0x53, + 0x8C, 0x54, 0x24, 0x16, 0xDC, 0xC1, 0xDE, 0x4D, + 0x0F, 0xE9, 0x3B, 0x24, 0x6A, 0x0E, 0xF3, 0xD1 + }, + { + 0xED, 0xD7, 0x06, 0xBE, 0x20, 0xB7, 0x75, 0xC5, + 0x62, 0x8C, 0xAF, 0xE1, 0xBA, 0x78, 0x57, 0x5F, + 0x40, 0xDC, 0xFC, 0xA8, 0x1D, 0xD7, 0xBB, 0x1C, + 0x0C, 0xE3, 0x3A, 0x68, 0xDE, 0xE9, 0x8B, 0x0B + }, + { + 0x0C, 0xEA, 0x04, 0x80, 0x25, 0x21, 0xDD, 0xB9, + 0x6F, 0x74, 0x7B, 0xDA, 0xAD, 0x14, 0x66, 0x44, + 0x2A, 0xFF, 0xBF, 0x55, 0xA8, 0x7F, 0xF3, 0xB2, + 0x18, 0x68, 0x48, 0x81, 0x0D, 0xD6, 0xCD, 0xD5 + }, + { + 0x8F, 0x84, 0x0D, 0xE6, 0xAE, 0x24, 0xBE, 0x59, + 0x32, 0x10, 0x3A, 0xA4, 0x52, 0x55, 0x75, 0x33, + 0x32, 0x19, 0xDE, 0x4F, 0x35, 0xFF, 0x6B, 0xE4, + 0xB8, 0x0A, 0x8A, 0xC0, 0x67, 0x6F, 0x10, 0xED + }, + { + 0xEE, 0xA4, 0x70, 0x81, 0x02, 0x37, 0x75, 0x0D, + 0x65, 0x5E, 0x69, 0xF7, 0xD7, 0xE2, 0xA4, 0xA0, + 0xDB, 0x98, 0x1D, 0x4F, 0x76, 0xF3, 0x92, 0xC8, + 0xEA, 0xE4, 0x18, 0xDD, 0x9D, 0x8E, 0xE0, 0x7D + }, + { + 0x22, 0x4A, 0xA1, 0x6B, 0xC9, 0x37, 0xEA, 0x1F, + 0x4B, 0xD7, 0x37, 0xD8, 0xDB, 0xFA, 0x22, 0x71, + 0xD4, 0xFB, 0x54, 0x0A, 0x7F, 0x8F, 0xCE, 0xC7, + 0x17, 0x7E, 0xBC, 0x58, 0xA3, 0x8D, 0x34, 0x38 + }, + { + 0xA5, 0x6D, 0x3C, 0x1E, 0x9E, 0xDF, 0xE9, 0xEB, + 0x77, 0xD7, 0x55, 0xC6, 0x14, 0x55, 0xA8, 0x78, + 0xCE, 0x74, 0xDF, 0x0B, 0xA5, 0xC0, 0x62, 0x3B, + 0xDE, 0x41, 0x49, 0xC7, 0x19, 0x7D, 0x9E, 0x8D + }, + { + 0xDF, 0x92, 0x9C, 0xBA, 0x49, 0x5D, 0x20, 0xEE, + 0x62, 0xB9, 0x14, 0x78, 0xA3, 0xE6, 0x09, 0xFA, + 0x62, 0x32, 0xD5, 0xEF, 0x33, 0xB2, 0xF7, 0x40, + 0xCF, 0x82, 0x1A, 0xD9, 0x63, 0x96, 0x0E, 0xCE + }, + { + 0x1D, 0x8D, 0x41, 0x95, 0x99, 0x00, 0x5B, 0x2E, + 0xFE, 0x0F, 0x7A, 0x91, 0x06, 0x5C, 0xC4, 0x26, + 0xD5, 0x9C, 0xFF, 0xF4, 0x7D, 0x4E, 0x3E, 0x34, + 0x80, 0x9F, 0x45, 0x69, 0xDC, 0x55, 0x2A, 0x28 + }, + { + 0xFE, 0x4D, 0xBB, 0xE0, 0x04, 0x35, 0x09, 0xE3, + 0x45, 0x54, 0x92, 0x93, 0x86, 0x1C, 0x9F, 0xD7, + 0xDB, 0x2F, 0xC2, 0x32, 0x9B, 0xF0, 0x29, 0x31, + 0xB9, 0x9B, 0x58, 0x4E, 0xBB, 0x8A, 0x93, 0xC9 + }, + { + 0xAC, 0x3E, 0x84, 0x11, 0xCB, 0xC4, 0xDA, 0x28, + 0x61, 0x8A, 0x77, 0xEF, 0xCD, 0xE0, 0x1F, 0x24, + 0x2D, 0xC5, 0xA5, 0xBC, 0x2D, 0x5A, 0xC2, 0xAC, + 0x7E, 0x56, 0x18, 0xE5, 0x4F, 0x74, 0x95, 0xB8 + }, + { + 0xE6, 0x0D, 0x14, 0x44, 0x76, 0x8A, 0xB5, 0x12, + 0x33, 0xDF, 0xBB, 0x49, 0x7C, 0x65, 0x1D, 0x67, + 0x11, 0xDA, 0x49, 0xC8, 0xBD, 0x07, 0xB4, 0x2B, + 0x67, 0x7E, 0xD5, 0x60, 0x3F, 0x62, 0x94, 0xBE + }, + { + 0x71, 0x76, 0x3A, 0x2F, 0xAE, 0xB1, 0x03, 0x6F, + 0x79, 0x40, 0x0B, 0xD1, 0x4A, 0xB1, 0xD9, 0x73, + 0x0D, 0xE9, 0xA7, 0x04, 0x1C, 0xD5, 0xEF, 0xDE, + 0xB1, 0xBF, 0x02, 0xBB, 0xBE, 0x0D, 0x11, 0x52 + }, + { + 0xD4, 0xA3, 0xC4, 0x03, 0x7F, 0x4E, 0xF6, 0x4A, + 0xE1, 0x7D, 0xAC, 0xDA, 0xDE, 0xA6, 0x70, 0x7F, + 0x12, 0x34, 0x85, 0x72, 0xEA, 0x3B, 0xFD, 0x8E, + 0xD5, 0x98, 0xA6, 0x72, 0x3F, 0x38, 0xC6, 0x12 + }, + { + 0x24, 0x27, 0x18, 0x32, 0xF7, 0x3C, 0xF0, 0x95, + 0x50, 0x6C, 0x9B, 0x55, 0x7F, 0x03, 0x46, 0xFD, + 0xC6, 0x13, 0x12, 0x4F, 0x66, 0x06, 0x56, 0xB8, + 0x3D, 0xAC, 0x66, 0x44, 0x42, 0x26, 0x99, 0x21 + }, + { + 0x1B, 0x27, 0x7F, 0xAF, 0x11, 0xBD, 0xEA, 0x57, + 0x81, 0x2D, 0x20, 0xE0, 0x17, 0x5F, 0x6D, 0xFD, + 0x62, 0x77, 0x02, 0x60, 0xD1, 0x4C, 0xBB, 0x87, + 0x35, 0x65, 0x3F, 0x22, 0x85, 0x20, 0x38, 0xA2 + }, + { + 0x69, 0x8A, 0x53, 0xDA, 0xD7, 0x98, 0x24, 0xE4, + 0x5D, 0xBB, 0x77, 0xF0, 0xEA, 0x77, 0x4C, 0xC3, + 0xEB, 0x32, 0x61, 0xC0, 0xAF, 0x83, 0x5C, 0xD6, + 0xED, 0xBC, 0x25, 0x70, 0xE1, 0x0C, 0x4A, 0x61 + }, + { + 0x5C, 0xF0, 0x26, 0xDD, 0x1D, 0x66, 0x05, 0xFB, + 0xCC, 0x21, 0xEF, 0xD3, 0x70, 0xF8, 0xC2, 0x7D, + 0xD5, 0xEF, 0x81, 0x98, 0x3D, 0x36, 0xE8, 0xA8, + 0x86, 0x17, 0x70, 0x97, 0x8B, 0x8C, 0xBE, 0x4F + }, + { + 0x5D, 0xE2, 0xE9, 0x4A, 0x63, 0x37, 0x8F, 0x50, + 0xF0, 0xDE, 0xF4, 0x6E, 0x68, 0x7A, 0x8A, 0xAB, + 0x7A, 0xD1, 0xF5, 0x4B, 0xB7, 0x6C, 0x48, 0x73, + 0x2D, 0xD2, 0xA0, 0xBA, 0x5D, 0x76, 0x32, 0x8B + }, + { + 0x7D, 0x86, 0xD1, 0x56, 0xCF, 0x73, 0xD3, 0x07, + 0x5C, 0xFC, 0xD3, 0x4E, 0xAF, 0x03, 0x9B, 0xB5, + 0x4D, 0xF8, 0x67, 0x2C, 0xE8, 0xA2, 0x95, 0xA7, + 0x25, 0x7E, 0xB6, 0x02, 0x28, 0x0F, 0xD3, 0xCB + }, + { + 0xC1, 0xCF, 0x25, 0x92, 0x07, 0x92, 0x2B, 0x2D, + 0x3F, 0x60, 0x26, 0x52, 0xDE, 0x71, 0xD8, 0xFC, + 0xD8, 0x47, 0x3F, 0x62, 0x3E, 0xD2, 0x57, 0xD4, + 0xFA, 0x7B, 0xC5, 0xA2, 0x1D, 0x6D, 0x9E, 0x30 + }, + { + 0xAE, 0x01, 0xA6, 0xF4, 0x94, 0x94, 0xB3, 0x02, + 0x26, 0x8B, 0x2D, 0x98, 0x6A, 0xA5, 0xE2, 0xDA, + 0x7D, 0xD1, 0xEF, 0x11, 0xE2, 0x98, 0x33, 0x8A, + 0x5A, 0x65, 0x23, 0x10, 0xDD, 0x7A, 0x32, 0x84 + }, + { + 0x82, 0xB7, 0xFC, 0xC6, 0xE0, 0xDC, 0x81, 0xAF, + 0x2A, 0xE6, 0x87, 0x95, 0x6F, 0xEE, 0x27, 0xCA, + 0x8F, 0xCB, 0xEA, 0x69, 0x3A, 0x4F, 0xC2, 0xC7, + 0x23, 0x0F, 0x09, 0xB5, 0x37, 0x4E, 0xF4, 0x70 + }, + { + 0x37, 0x28, 0x27, 0x0D, 0x72, 0xCA, 0xD1, 0x5E, + 0x39, 0x62, 0x2A, 0xCA, 0xD6, 0x2F, 0xE6, 0xD0, + 0x16, 0x3E, 0xB2, 0x6D, 0xDE, 0x26, 0x00, 0xD5, + 0xC7, 0xF8, 0x08, 0x5C, 0x92, 0xD8, 0x26, 0xC9 + }, + { + 0x7E, 0x2D, 0x12, 0x98, 0x60, 0x0E, 0x50, 0x47, + 0x04, 0xAB, 0x5C, 0x73, 0x10, 0x70, 0x17, 0x2A, + 0x3C, 0xB6, 0x6C, 0x81, 0x65, 0xBA, 0x75, 0x97, + 0xFC, 0x70, 0x90, 0x91, 0x0A, 0x73, 0x11, 0x71 + }, + { + 0xF7, 0x4B, 0xA2, 0xC3, 0x4B, 0x10, 0xB1, 0xC8, + 0xC7, 0x48, 0x34, 0x69, 0x81, 0xDF, 0xBF, 0xE3, + 0x4C, 0xF7, 0x19, 0x6F, 0x99, 0x87, 0x02, 0x9C, + 0x8C, 0xDD, 0x89, 0x26, 0x44, 0xCE, 0x29, 0xDA + }, + { + 0xDF, 0x7A, 0x21, 0xE5, 0x8F, 0x86, 0xB8, 0x98, + 0x2A, 0x9B, 0x51, 0x29, 0x53, 0x76, 0x25, 0xB3, + 0xF7, 0xE8, 0x8D, 0xEA, 0xC2, 0xC3, 0x54, 0x49, + 0x55, 0x22, 0x34, 0x7E, 0xF0, 0xE5, 0x54, 0x18 + }, + { + 0xF5, 0x89, 0xE6, 0x6E, 0xF0, 0xCA, 0x56, 0xBB, + 0xFB, 0xB4, 0xB9, 0x48, 0x0C, 0x26, 0x6B, 0xED, + 0x82, 0x61, 0xDA, 0x13, 0xE3, 0x96, 0x9C, 0x7C, + 0x6C, 0xFD, 0xE6, 0x00, 0xDF, 0x29, 0x49, 0xD0 + }, + { + 0xFF, 0xCF, 0x37, 0xBD, 0xE9, 0x89, 0x5A, 0x35, + 0xB4, 0x8F, 0xF6, 0x78, 0x07, 0x87, 0x40, 0x0D, + 0x0D, 0xD8, 0x62, 0x98, 0xA8, 0x63, 0x09, 0x68, + 0x0D, 0x9B, 0x6A, 0xDD, 0x66, 0xFA, 0x3B, 0x20 + }, + { + 0x4B, 0x4C, 0x87, 0x22, 0xD1, 0x11, 0x29, 0x6E, + 0x83, 0xB8, 0x81, 0x1A, 0x13, 0xD1, 0xF3, 0xB6, + 0x70, 0xC6, 0x22, 0x71, 0x3C, 0x3F, 0xB2, 0xD5, + 0x48, 0xDC, 0x8E, 0x38, 0xDA, 0x86, 0x62, 0xA4 + }, + { + 0x3F, 0xBD, 0xFD, 0x6E, 0xA6, 0xD3, 0xB3, 0x22, + 0xC2, 0xF7, 0xEC, 0x62, 0xDA, 0xC7, 0x47, 0x23, + 0x29, 0x30, 0x5A, 0x7A, 0x50, 0x67, 0x13, 0x2F, + 0x09, 0xE8, 0x12, 0x91, 0xD4, 0x68, 0x98, 0x08 + }, + { + 0x43, 0xBC, 0xC6, 0x2A, 0x23, 0x11, 0xF1, 0xC9, + 0x64, 0x25, 0x80, 0x88, 0xDC, 0x60, 0xAB, 0x96, + 0x0C, 0x7D, 0x5A, 0x55, 0x8B, 0x69, 0xE1, 0x60, + 0x42, 0x5C, 0x18, 0xF5, 0x58, 0x40, 0x96, 0x6D + }, + { + 0xB7, 0xB4, 0xC4, 0xB0, 0x63, 0x18, 0xC0, 0xCE, + 0x78, 0x37, 0x43, 0x30, 0xE3, 0xDD, 0x88, 0x5F, + 0x7C, 0x21, 0xE6, 0x4E, 0x32, 0x51, 0xBA, 0x98, + 0x25, 0x8B, 0x90, 0x61, 0x0A, 0xD7, 0xC9, 0x7E + }, + { + 0x70, 0x59, 0xFC, 0xF8, 0xD5, 0xCC, 0xDB, 0xC0, + 0x68, 0xE8, 0x51, 0xA2, 0x25, 0x5C, 0x49, 0xCD, + 0x70, 0x63, 0x8B, 0xDD, 0xE5, 0xA1, 0xED, 0x36, + 0xAF, 0x0E, 0xA0, 0x7B, 0xCD, 0x8E, 0xE2, 0xFE + }, + { + 0x88, 0x92, 0x27, 0x60, 0x7B, 0x7B, 0xE1, 0xDC, + 0xCE, 0x17, 0x60, 0x4A, 0xCC, 0x5E, 0x61, 0x6F, + 0xA2, 0xE1, 0x43, 0x0A, 0x68, 0x57, 0xA9, 0xA0, + 0x15, 0xCF, 0xB0, 0x6A, 0xCC, 0xF9, 0x4E, 0xB9 + }, + { + 0xF7, 0xB1, 0x78, 0x74, 0x23, 0x07, 0xBF, 0xBD, + 0xB8, 0x98, 0x9B, 0x3C, 0xEB, 0x2E, 0x9E, 0x14, + 0x21, 0xBB, 0x9A, 0xC2, 0xFD, 0x1F, 0x91, 0x92, + 0x8E, 0x50, 0x4D, 0xE3, 0xA9, 0xF9, 0xD0, 0x6E + }, + { + 0x2C, 0x27, 0xE4, 0x2C, 0x45, 0xEF, 0x31, 0x5F, + 0x9F, 0xA0, 0x9C, 0xDD, 0xA5, 0x81, 0x1F, 0x87, + 0xD8, 0x2C, 0x1F, 0xCD, 0xC7, 0x8D, 0x75, 0x99, + 0x43, 0x77, 0xBD, 0x3C, 0x55, 0x95, 0x52, 0xE6 + }, + { + 0x57, 0x1D, 0x27, 0xF0, 0xAB, 0x61, 0x99, 0x94, + 0x39, 0xCD, 0x95, 0xD5, 0x8D, 0x4C, 0x9D, 0x4A, + 0x2E, 0x7D, 0x1B, 0x04, 0xE4, 0x00, 0x9C, 0xD2, + 0x8F, 0x60, 0x97, 0xB5, 0x44, 0xAE, 0xB3, 0x8F + }, + { + 0xCD, 0x84, 0xB7, 0xE1, 0x0C, 0x93, 0x41, 0x64, + 0x2C, 0x16, 0xDF, 0x31, 0xBB, 0x03, 0xE2, 0x68, + 0x8C, 0x2C, 0x14, 0x79, 0x46, 0xFD, 0x85, 0xE0, + 0xF7, 0x4B, 0x91, 0xAA, 0xC9, 0xD9, 0xB5, 0x63 + }, + { + 0xB9, 0xD4, 0x5F, 0x1C, 0xF5, 0x9D, 0x7E, 0x15, + 0x42, 0xEE, 0xC8, 0x31, 0x2E, 0xE2, 0x14, 0x88, + 0x59, 0x67, 0x2A, 0x23, 0xC1, 0xD3, 0x5A, 0xFF, + 0x89, 0x5D, 0x99, 0xA6, 0x1D, 0x30, 0x99, 0xC7 + }, + { + 0x40, 0x49, 0x86, 0x29, 0x6F, 0xB7, 0xEF, 0x48, + 0x31, 0xF1, 0x6F, 0x21, 0x6B, 0x4A, 0xF3, 0xB6, + 0xF2, 0x76, 0xB1, 0xA7, 0xF2, 0x16, 0x03, 0x29, + 0xF3, 0x52, 0x0E, 0x5E, 0x16, 0xAB, 0xE1, 0xCB + }, + { + 0xBD, 0x5C, 0xF0, 0xC6, 0x11, 0x1E, 0xE6, 0x5A, + 0x88, 0xA2, 0x86, 0xC8, 0xB7, 0x9E, 0x4D, 0x1E, + 0xB4, 0xCF, 0xE8, 0x82, 0xBE, 0xD2, 0x5F, 0x93, + 0x4A, 0x1C, 0xF2, 0xC9, 0x88, 0x32, 0xC7, 0x52 + }, + { + 0x94, 0xF8, 0xC2, 0x66, 0x28, 0xA4, 0x11, 0x67, + 0xDD, 0xB2, 0xA6, 0xD8, 0x17, 0xFE, 0xC2, 0x98, + 0x4B, 0x1D, 0xC7, 0x0A, 0x05, 0xC0, 0xF8, 0x10, + 0x35, 0x2B, 0x8E, 0x30, 0x02, 0x34, 0x6A, 0x50 + }, + { + 0x90, 0xFF, 0x88, 0x83, 0xAA, 0xEB, 0x37, 0x9C, + 0x71, 0xBB, 0x57, 0xA9, 0x93, 0xC3, 0xD9, 0xB2, + 0xB2, 0xED, 0x27, 0xB9, 0xCB, 0x7B, 0xA0, 0x9A, + 0x00, 0x45, 0x81, 0x5F, 0x33, 0x39, 0x97, 0x92 + }, + { + 0x01, 0xFD, 0x6C, 0x12, 0x38, 0x19, 0xD0, 0x01, + 0xD2, 0xE5, 0x97, 0x31, 0x15, 0x1E, 0xB0, 0x53, + 0xD1, 0x55, 0xE2, 0xED, 0xE9, 0x61, 0xC1, 0x0F, + 0xD4, 0x26, 0x12, 0x21, 0x76, 0xAA, 0x45, 0x18 + }, + { + 0x2D, 0x10, 0xA7, 0x12, 0x46, 0xA2, 0x12, 0x5A, + 0x9C, 0xF0, 0x08, 0x99, 0x6E, 0x96, 0xC0, 0x2A, + 0xCF, 0x56, 0xB0, 0xA9, 0x91, 0xF2, 0x17, 0x45, + 0xFB, 0x78, 0x77, 0xCB, 0xE2, 0x3F, 0x90, 0xF7 + }, + { + 0x0C, 0x77, 0x72, 0xFC, 0x3F, 0x6E, 0xB0, 0xF9, + 0x71, 0xCB, 0x2A, 0xEC, 0x61, 0xF2, 0x23, 0xE9, + 0x6B, 0xCE, 0x85, 0x27, 0xF5, 0x55, 0xA8, 0x52, + 0x63, 0x96, 0x43, 0x3B, 0x69, 0x79, 0xAD, 0xCA + }, + { + 0x8C, 0x67, 0x59, 0xB6, 0x7F, 0x52, 0xB5, 0xD0, + 0xFD, 0x64, 0xE8, 0xBB, 0x79, 0x3C, 0xD7, 0xBB, + 0xC2, 0x99, 0xAE, 0xEF, 0x77, 0x4C, 0x0C, 0x54, + 0x5B, 0x3C, 0x38, 0x8C, 0xD4, 0xCF, 0xDA, 0x60 + }, + { + 0x41, 0x43, 0x75, 0xE8, 0xE9, 0x18, 0x0D, 0xD1, + 0x55, 0x9F, 0x3E, 0x09, 0x02, 0x7E, 0x32, 0xF1, + 0xDE, 0xF5, 0x86, 0x7F, 0x67, 0x42, 0x77, 0xBE, + 0xD0, 0x83, 0x5F, 0x65, 0xEE, 0x21, 0xDF, 0x64 + }, + { + 0x63, 0xE4, 0x54, 0x91, 0x31, 0x2A, 0x7D, 0xED, + 0xEE, 0x32, 0x30, 0x1F, 0x54, 0xEA, 0xF2, 0xEB, + 0x9C, 0x4F, 0x0C, 0x9D, 0x30, 0xAB, 0x00, 0x5A, + 0xFC, 0xDE, 0x32, 0xDC, 0xE3, 0x43, 0x90, 0x0D + }, + { + 0x92, 0x49, 0xAE, 0xBD, 0x52, 0xA2, 0x45, 0x01, + 0x49, 0x91, 0x14, 0xF8, 0xEA, 0x7F, 0x89, 0x03, + 0x11, 0xD6, 0xEB, 0x09, 0x5F, 0x58, 0xB3, 0x53, + 0x36, 0xBB, 0x38, 0xA8, 0xD9, 0x16, 0x82, 0xF4 + }, + { + 0x44, 0x98, 0x0E, 0x37, 0xC6, 0x02, 0x46, 0x78, + 0xA1, 0x77, 0x57, 0x10, 0x85, 0xF1, 0x3C, 0x04, + 0x62, 0x42, 0x79, 0x21, 0x0F, 0x9F, 0x51, 0x01, + 0x33, 0x54, 0xEC, 0xC4, 0x1D, 0x38, 0xB7, 0x13 + }, + { + 0x63, 0x52, 0x6B, 0x0D, 0xE9, 0x30, 0xB0, 0x18, + 0x2E, 0x57, 0xA1, 0x1D, 0x72, 0xA6, 0xE4, 0xA8, + 0x50, 0xF8, 0x4D, 0xE9, 0x62, 0x41, 0x6C, 0xD5, + 0x9D, 0x99, 0x31, 0xCD, 0x72, 0x47, 0xD6, 0x5F + }, + { + 0x77, 0x08, 0x7C, 0x67, 0x27, 0x3D, 0xC6, 0xCB, + 0xA4, 0x35, 0x5E, 0xAC, 0x3F, 0xD2, 0xB8, 0xC6, + 0x49, 0x37, 0x1E, 0x31, 0x94, 0xC6, 0xD3, 0x3C, + 0x80, 0x1C, 0x17, 0x0F, 0xCB, 0x33, 0x8C, 0x5E + }, + { + 0x4B, 0xAD, 0x66, 0xC4, 0xC7, 0x55, 0x72, 0x0D, + 0xB5, 0xF6, 0x59, 0x11, 0x79, 0x7C, 0xA5, 0x88, + 0x0A, 0x46, 0x29, 0xD3, 0x15, 0x48, 0x87, 0xEB, + 0xCB, 0xBB, 0xA3, 0x62, 0x48, 0x32, 0x6D, 0x5E + }, + { + 0xEB, 0x76, 0xA3, 0xB6, 0xD7, 0x1B, 0x7E, 0xF2, + 0xC3, 0x31, 0x56, 0x3E, 0x41, 0xDB, 0xD1, 0x8D, + 0x5D, 0x2D, 0x6A, 0xDD, 0xFE, 0x0E, 0x97, 0xCD, + 0x40, 0x22, 0xA8, 0x5B, 0xED, 0xA9, 0x90, 0x66 + }, + { + 0x08, 0xC4, 0xCF, 0x70, 0xB0, 0xA3, 0xF2, 0x99, + 0xA3, 0x70, 0xAD, 0xA4, 0xF1, 0xD8, 0xEB, 0x06, + 0x95, 0x5E, 0xCA, 0x88, 0xF7, 0x5C, 0xD4, 0x37, + 0xF0, 0xFD, 0xCC, 0x5E, 0xC8, 0x51, 0xAC, 0x39 + }, + { + 0xC7, 0xB0, 0x02, 0xF8, 0xD1, 0x20, 0x2D, 0x5C, + 0xD3, 0x54, 0xC3, 0x50, 0x80, 0x8A, 0x24, 0xD4, + 0xBA, 0x35, 0xD5, 0xD9, 0xF4, 0x52, 0x91, 0x66, + 0x08, 0x70, 0xC6, 0xAE, 0xBD, 0x0F, 0xE4, 0x1D + }, + { + 0x1F, 0x55, 0x1E, 0x69, 0x6D, 0x61, 0x92, 0x10, + 0x15, 0xB6, 0x5B, 0x7D, 0xA7, 0xF4, 0x2A, 0x78, + 0xC2, 0xDF, 0x7B, 0x34, 0x5C, 0x8D, 0x1E, 0xED, + 0x15, 0x1D, 0x18, 0xEB, 0xBA, 0xD3, 0xD1, 0xF6 + }, + { + 0x4B, 0xFC, 0x57, 0xE0, 0x56, 0x49, 0xCB, 0x0D, + 0x6F, 0x4E, 0xF1, 0xC8, 0x3F, 0xDE, 0x26, 0x75, + 0xE3, 0x77, 0x04, 0xAF, 0xEA, 0x70, 0xDB, 0x77, + 0xD5, 0x79, 0x5F, 0xF5, 0x45, 0xCB, 0xC5, 0x5F + }, + { + 0x69, 0x2A, 0xC3, 0xBF, 0x55, 0x12, 0xD4, 0x61, + 0xBA, 0xEB, 0x26, 0xC1, 0xCF, 0xEF, 0x37, 0x5B, + 0x68, 0xF6, 0x8A, 0x83, 0x90, 0x8E, 0x16, 0x9E, + 0x7C, 0xB3, 0x86, 0xD4, 0xCB, 0x0C, 0x1A, 0x9C + }, + { + 0xCF, 0xEE, 0x08, 0xC4, 0x86, 0xE7, 0x09, 0xCB, + 0x79, 0x28, 0xA5, 0xF4, 0x5B, 0xFA, 0xA1, 0x26, + 0xD1, 0xA4, 0x66, 0xBF, 0xFA, 0x7D, 0x70, 0x1D, + 0xCE, 0x79, 0x49, 0x00, 0x57, 0x06, 0x33, 0x84 + }, + { + 0x13, 0x43, 0x5A, 0x95, 0x4B, 0x31, 0x66, 0x11, + 0x97, 0x07, 0x76, 0xA4, 0x71, 0xAA, 0x13, 0xAF, + 0x8D, 0xC2, 0xE1, 0x5B, 0x54, 0x61, 0xAE, 0x4B, + 0x81, 0xCE, 0xC5, 0x06, 0x89, 0xF5, 0x06, 0x6B + }, + { + 0x4B, 0x41, 0x91, 0xB3, 0x45, 0xCF, 0x9F, 0x96, + 0x4F, 0xAA, 0x65, 0x14, 0xE6, 0x0B, 0x92, 0xF4, + 0xED, 0x8A, 0xD7, 0xBA, 0x4D, 0xA3, 0x2C, 0x29, + 0x1B, 0x5F, 0xA8, 0x2B, 0xAD, 0x3D, 0x70, 0xAB + }, + { + 0xDD, 0xC4, 0x0A, 0xEE, 0x53, 0xC9, 0x83, 0xA4, + 0x0A, 0xB1, 0xFF, 0xDB, 0x3C, 0xEE, 0xA1, 0x76, + 0x3D, 0xF6, 0x17, 0x4F, 0xD6, 0x3B, 0x6E, 0x27, + 0xFB, 0x10, 0xB2, 0xF6, 0x59, 0x8E, 0xFE, 0x01 + }, + { + 0x37, 0x01, 0x17, 0xDE, 0xE9, 0xCE, 0xBA, 0x4E, + 0x64, 0x50, 0xF9, 0x21, 0x77, 0xCE, 0xE8, 0xBB, + 0xE5, 0xB0, 0x85, 0x30, 0x14, 0x41, 0xD0, 0xEA, + 0x56, 0xED, 0xB5, 0x62, 0xA6, 0xC9, 0xED, 0x16 + }, + { + 0x07, 0x6A, 0x01, 0x48, 0x67, 0x16, 0x36, 0x41, + 0xF9, 0x0F, 0x97, 0x39, 0xF4, 0x9F, 0xF3, 0x2D, + 0x41, 0xCB, 0x79, 0xCE, 0xE6, 0x19, 0xF2, 0xFA, + 0x68, 0x53, 0x58, 0x35, 0x01, 0x66, 0x3F, 0x51 + }, + { + 0x97, 0x08, 0x70, 0x09, 0xE9, 0x5E, 0x0D, 0xAE, + 0x2C, 0x65, 0xD9, 0x3B, 0x2C, 0x85, 0xE8, 0x1E, + 0xF4, 0xE1, 0xB5, 0xD5, 0x7B, 0xFF, 0xDF, 0x07, + 0x3D, 0x3F, 0xB1, 0xF8, 0x36, 0xD9, 0xBC, 0x21 + }, + { + 0x2B, 0x34, 0x1D, 0x4F, 0xAD, 0x0A, 0x3F, 0x89, + 0xD5, 0x73, 0xF4, 0xFA, 0x24, 0xF7, 0x5B, 0x2A, + 0xB1, 0xEC, 0x62, 0x77, 0xB7, 0xE7, 0xB8, 0xFD, + 0xB5, 0x8D, 0x76, 0x3B, 0x0C, 0x30, 0x17, 0xE6 + }, + { + 0x8F, 0xF3, 0xAE, 0x9D, 0x75, 0xFC, 0x8E, 0xB7, + 0xF9, 0xC0, 0x5B, 0x1C, 0x12, 0x7D, 0x37, 0x2A, + 0xAF, 0x05, 0x34, 0xA3, 0x0D, 0x0F, 0xF7, 0xCF, + 0x2B, 0x10, 0x5F, 0x36, 0x73, 0x4C, 0xB8, 0x16 + }, + { + 0xC0, 0x03, 0xE9, 0x1F, 0xEC, 0xD0, 0xF4, 0x4F, + 0x9B, 0x67, 0x7A, 0x24, 0x10, 0x61, 0x58, 0x31, + 0xB9, 0x01, 0x11, 0xDB, 0xC6, 0xA0, 0x4F, 0xD0, + 0x52, 0x16, 0xF5, 0x01, 0x0F, 0x44, 0x23, 0x96 + }, + { + 0xD3, 0x41, 0x8B, 0x89, 0x76, 0xB5, 0xBA, 0xF7, + 0xE0, 0xAA, 0xEF, 0xFA, 0xA6, 0x0D, 0x7E, 0xBB, + 0x53, 0x84, 0xA5, 0xD3, 0xAB, 0x61, 0x90, 0x0A, + 0xAE, 0xEC, 0x03, 0x9B, 0xA9, 0x58, 0xF8, 0x01 + }, + { + 0xE4, 0xC4, 0x18, 0x08, 0x7B, 0x83, 0xFC, 0x11, + 0x6B, 0xB4, 0xD4, 0x36, 0x2B, 0xEB, 0x47, 0x8F, + 0x0F, 0xF8, 0xAA, 0x5E, 0x93, 0x51, 0x45, 0x75, + 0x7F, 0x20, 0x8B, 0x12, 0x5F, 0x85, 0xAF, 0x41 + }, + { + 0x97, 0x92, 0x3D, 0x7A, 0xA2, 0x5A, 0x0D, 0xAE, + 0x1F, 0xB6, 0x2F, 0x98, 0x11, 0x43, 0x1C, 0x3E, + 0x4F, 0x4A, 0xE3, 0xD9, 0x4D, 0xEE, 0x0B, 0x61, + 0x0A, 0x64, 0x8B, 0x7C, 0xB1, 0x5C, 0x0F, 0x41 + }, + { + 0x62, 0x24, 0x8F, 0x58, 0xD1, 0x72, 0xF2, 0x4A, + 0x3B, 0xBE, 0x00, 0xE6, 0x55, 0xCF, 0x3D, 0xF3, + 0x46, 0x9C, 0x03, 0x52, 0xCC, 0x8C, 0xC6, 0x92, + 0xDD, 0x7F, 0xF5, 0x3F, 0x37, 0x7F, 0x98, 0x85 + }, + { + 0x56, 0x85, 0xD7, 0xFA, 0x72, 0x9B, 0x11, 0x15, + 0xB5, 0x0D, 0x34, 0xB8, 0xDA, 0x9D, 0xEE, 0x91, + 0x4D, 0x9A, 0xE1, 0x4F, 0x04, 0x1F, 0xB7, 0x3A, + 0x7A, 0xBC, 0xB4, 0x86, 0x91, 0xE8, 0x12, 0x2F + }, + { + 0x14, 0x82, 0x47, 0x9A, 0xE7, 0x1B, 0x6A, 0x9C, + 0x41, 0x59, 0x4A, 0x87, 0x16, 0x0A, 0xB8, 0x36, + 0xFF, 0x48, 0xA3, 0xA4, 0x07, 0x0A, 0x00, 0xF6, + 0x16, 0x69, 0xC9, 0x47, 0xFA, 0x46, 0x93, 0xDF + }, + { + 0x9B, 0xC5, 0x4F, 0x79, 0xDE, 0xA4, 0xA0, 0x2E, + 0xBB, 0x13, 0x04, 0x50, 0x91, 0x71, 0xAF, 0x4A, + 0x4B, 0xA3, 0x03, 0x9F, 0xD4, 0x5F, 0xD6, 0x5F, + 0xAE, 0xF1, 0x79, 0x09, 0x6C, 0x8A, 0xFB, 0x4E + }, + { + 0x09, 0x88, 0x7B, 0x9D, 0x41, 0xA6, 0x1F, 0xD8, + 0x86, 0xB1, 0x79, 0xD7, 0x8E, 0x53, 0xCE, 0x5C, + 0x12, 0x97, 0x81, 0x5E, 0x7B, 0x79, 0x7C, 0x7C, + 0x35, 0xB3, 0x40, 0xFB, 0x6C, 0x35, 0x99, 0x4F + }, + { + 0x25, 0x85, 0x6F, 0x13, 0x3F, 0x9B, 0x60, 0x9D, + 0xF3, 0xEC, 0x39, 0x72, 0xAC, 0x01, 0x81, 0x0D, + 0x3D, 0x1B, 0xC8, 0x59, 0x52, 0x8F, 0x57, 0xB9, + 0x1B, 0x45, 0x61, 0x33, 0x41, 0x0F, 0x93, 0x35 + }, + { + 0xE3, 0xFF, 0x31, 0x24, 0x87, 0x93, 0x49, 0x35, + 0x1F, 0x86, 0x51, 0xEF, 0x09, 0x96, 0x71, 0xD7, + 0x52, 0x40, 0x4C, 0x74, 0x9F, 0x33, 0x17, 0xD6, + 0xE0, 0x3C, 0x57, 0xF9, 0x62, 0x90, 0x18, 0x8F + }, + { + 0x7A, 0xEF, 0x6A, 0x4C, 0x73, 0x09, 0xC8, 0xA6, + 0x63, 0x7F, 0x82, 0x6A, 0x3C, 0xFD, 0x06, 0xDE, + 0x46, 0x17, 0xDE, 0xAA, 0x9F, 0xBC, 0x1E, 0x08, + 0xDC, 0x93, 0x8E, 0xDA, 0x26, 0x08, 0x7D, 0x8F + }, + { + 0x05, 0x77, 0xFC, 0xB1, 0x4E, 0x1E, 0xEB, 0xCB, + 0xEE, 0x65, 0xAB, 0x64, 0xBA, 0x4B, 0xAF, 0x99, + 0x56, 0x72, 0x0F, 0xA9, 0x2E, 0xF0, 0x7A, 0x37, + 0xF3, 0xA5, 0x9C, 0x4F, 0x69, 0x36, 0xD9, 0x4D + }, + { + 0xF8, 0xE7, 0x2B, 0x37, 0xD8, 0x85, 0x32, 0x64, + 0xC0, 0x82, 0x45, 0x4F, 0x77, 0x9A, 0xC0, 0x89, + 0xED, 0x8C, 0x1C, 0xA6, 0x42, 0xC6, 0x48, 0xFD, + 0x1D, 0x6E, 0xEF, 0xCF, 0x9C, 0x7D, 0xF3, 0xCF + }, + { + 0x9A, 0x7D, 0xA2, 0x66, 0x1A, 0xCE, 0xB4, 0x53, + 0xB6, 0xF8, 0xBB, 0x66, 0xF7, 0xCB, 0x74, 0x18, + 0x51, 0xFC, 0x9A, 0x39, 0xD3, 0xEE, 0x88, 0x76, + 0x84, 0xAB, 0x44, 0xFC, 0x14, 0x61, 0x29, 0x46 + }, + { + 0x90, 0xAE, 0x20, 0xDD, 0x20, 0x85, 0xDE, 0x7E, + 0xD9, 0x88, 0x99, 0x4B, 0xA9, 0xBC, 0xAB, 0xA1, + 0xCA, 0xC9, 0x85, 0x95, 0x57, 0x84, 0x4B, 0x19, + 0xC2, 0x5A, 0xEB, 0x1D, 0x97, 0x6A, 0xAB, 0x47 + }, + { + 0xC5, 0xE5, 0xFC, 0xB8, 0x49, 0xDB, 0xA5, 0xB7, + 0xB3, 0xF8, 0x98, 0xF0, 0xF4, 0xD8, 0x36, 0x15, + 0x19, 0x29, 0x1B, 0x1B, 0x1A, 0xD7, 0xF4, 0x1D, + 0xC6, 0x87, 0x12, 0xAA, 0x54, 0xA3, 0x32, 0xAD + }, + { + 0xB6, 0x50, 0x0B, 0xA9, 0xCA, 0x02, 0x82, 0xB4, + 0xE7, 0xE3, 0x3C, 0x7F, 0x7C, 0x6C, 0xD9, 0x8F, + 0xD6, 0xE6, 0xC3, 0x50, 0x8E, 0x47, 0x26, 0x6F, + 0x25, 0x6B, 0x0B, 0xFF, 0x68, 0x1D, 0xD6, 0x84 + }, + { + 0x9E, 0x71, 0x77, 0xE2, 0xE6, 0xF8, 0x96, 0x5A, + 0xB5, 0xCB, 0x7C, 0x15, 0x28, 0xB6, 0xA1, 0x13, + 0x58, 0x43, 0x32, 0x1E, 0x29, 0x84, 0x40, 0xE4, + 0x0C, 0x6C, 0x00, 0x86, 0xF9, 0x16, 0xA3, 0x14 + }, + { + 0xB7, 0xF2, 0x51, 0xDF, 0xB1, 0x2B, 0x08, 0xA1, + 0x82, 0x69, 0x60, 0x80, 0xE0, 0xD3, 0x59, 0xCC, + 0xFF, 0x4D, 0xAA, 0x69, 0x14, 0xA7, 0xD9, 0x34, + 0x1A, 0x9B, 0x2D, 0x5E, 0x47, 0x28, 0x1B, 0xDE + }, + { + 0x67, 0x11, 0x27, 0x26, 0xF5, 0x31, 0x6F, 0xAB, + 0xBA, 0x48, 0x65, 0x73, 0x12, 0x40, 0x29, 0x09, + 0xD8, 0x80, 0xFA, 0xB8, 0xF7, 0xDF, 0xF2, 0xFA, + 0x11, 0x80, 0x87, 0x8B, 0xBA, 0x7F, 0xCD, 0x71 + }, + { + 0xA1, 0x63, 0xD2, 0x53, 0x87, 0x61, 0x21, 0x41, + 0xE2, 0xE8, 0x15, 0xBA, 0x9F, 0xBF, 0x3A, 0x45, + 0x18, 0x81, 0xB6, 0x62, 0x17, 0xE0, 0xC2, 0xB6, + 0x85, 0xAA, 0x44, 0x43, 0x18, 0x87, 0xDD, 0x53 + }, + { + 0xB0, 0xD5, 0x1C, 0xA4, 0x0D, 0x09, 0x64, 0x97, + 0x83, 0xF6, 0x0F, 0xB3, 0xAD, 0x91, 0x14, 0x9F, + 0xD2, 0xCD, 0x0D, 0xB3, 0xC8, 0xF1, 0x63, 0x07, + 0x3A, 0x7C, 0x4A, 0x4D, 0x26, 0xE1, 0x4E, 0xB8 + }, + { + 0x70, 0xC6, 0xB4, 0xFC, 0x66, 0xE4, 0x1E, 0x7C, + 0x2D, 0xA1, 0x93, 0xD6, 0x4D, 0x91, 0xA0, 0xF6, + 0x54, 0x8C, 0x55, 0x5A, 0xE7, 0xEC, 0x2C, 0xDF, + 0x4C, 0xA8, 0xF0, 0xC4, 0x92, 0x6B, 0xB8, 0x6F + }, + { + 0x28, 0x1A, 0x36, 0x83, 0xB9, 0x6B, 0x4C, 0xE2, + 0x0B, 0x54, 0xFF, 0x42, 0xC3, 0xB1, 0x6C, 0x63, + 0xC4, 0x8D, 0x56, 0x53, 0xB5, 0xFA, 0x2D, 0xCE, + 0xC9, 0x1A, 0x3D, 0x56, 0xC9, 0x76, 0x2C, 0x39 + }, + { + 0xFC, 0xC0, 0x3E, 0x23, 0xAD, 0x37, 0x08, 0x8A, + 0xC3, 0x82, 0x6E, 0xA9, 0x7C, 0xFD, 0x35, 0x64, + 0x95, 0x19, 0xC4, 0x42, 0x5A, 0xDA, 0x66, 0xA3, + 0x87, 0x4E, 0x20, 0x58, 0x64, 0x76, 0x54, 0xCC + }, + { + 0x29, 0x87, 0x55, 0x2F, 0xD1, 0x77, 0x36, 0xE8, + 0x33, 0x44, 0x84, 0x89, 0x2D, 0xE1, 0xF3, 0x1C, + 0x99, 0x61, 0x01, 0x12, 0x43, 0xE8, 0xA6, 0x57, + 0x33, 0x7D, 0x22, 0x16, 0x94, 0x6D, 0x90, 0x86 + }, + { + 0x6A, 0x98, 0xF2, 0xAE, 0x33, 0x55, 0x72, 0xB1, + 0x76, 0x78, 0x97, 0xC7, 0xDE, 0x17, 0x4F, 0xB5, + 0x95, 0xCA, 0x70, 0x66, 0xDA, 0x59, 0x57, 0xC5, + 0x85, 0x48, 0xC3, 0xCD, 0x54, 0xAA, 0xE5, 0x79 + }, + { + 0xA7, 0x7C, 0xD7, 0x7E, 0xFD, 0xE9, 0x3D, 0xB4, + 0x58, 0xCA, 0xE0, 0x11, 0x91, 0x80, 0x2F, 0x84, + 0x90, 0x5A, 0x57, 0x1B, 0x9F, 0x3E, 0x58, 0xBB, + 0xB9, 0x36, 0xD9, 0xA5, 0x55, 0xE1, 0x35, 0x42 + }, + { + 0xFC, 0xE6, 0xF9, 0x25, 0x90, 0xE1, 0x33, 0x9C, + 0x7E, 0xE0, 0x00, 0x8E, 0x97, 0x33, 0x6C, 0x7B, + 0xE4, 0x6C, 0xC1, 0x35, 0x06, 0x30, 0xDB, 0x4F, + 0x35, 0x44, 0xE0, 0x99, 0x03, 0x27, 0x58, 0x59 + }, + { + 0x6B, 0x3C, 0x0E, 0x8B, 0x87, 0x45, 0x77, 0xB8, + 0x3C, 0xC4, 0x1A, 0xAE, 0xD3, 0x41, 0xF4, 0x17, + 0x43, 0x4D, 0x99, 0x53, 0xCA, 0x3A, 0xE5, 0xA5, + 0xA6, 0xFE, 0x40, 0x5F, 0x25, 0x3C, 0xDA, 0x3D + }, + { + 0x51, 0x50, 0xDE, 0x0E, 0xB0, 0xD1, 0x09, 0x87, + 0xBE, 0x51, 0x57, 0xAA, 0xF7, 0xDE, 0x93, 0xBB, + 0xA3, 0x33, 0x86, 0x98, 0x72, 0x21, 0x7D, 0xB4, + 0x16, 0x04, 0xBB, 0x46, 0x9A, 0x8E, 0xAD, 0x66 + }, + { + 0x1C, 0xA1, 0x21, 0x54, 0x30, 0x97, 0xB0, 0xC4, + 0x61, 0x9A, 0x7E, 0x1D, 0x33, 0xCD, 0x72, 0x3D, + 0x18, 0x5D, 0x58, 0xA1, 0x18, 0x1B, 0x85, 0x69, + 0x95, 0x3A, 0x65, 0x5D, 0x82, 0xD0, 0xAA, 0x57 + }, + { + 0x90, 0x5C, 0x98, 0xCE, 0xDA, 0xA2, 0x49, 0x8F, + 0xD0, 0xCB, 0xB3, 0xD4, 0xD7, 0xF7, 0xF8, 0x18, + 0x83, 0xB3, 0xAF, 0xC3, 0x3F, 0x91, 0x79, 0x0E, + 0x8B, 0xC7, 0xBC, 0xE5, 0x57, 0x8D, 0xD6, 0x1F + }, + { + 0x0E, 0xF6, 0x31, 0xA9, 0x08, 0x7C, 0x1E, 0x4A, + 0xFF, 0xC1, 0xFB, 0xD4, 0x9E, 0x10, 0xE1, 0xFB, + 0xE5, 0x8E, 0x24, 0x76, 0x39, 0xEB, 0x06, 0xB3, + 0x6B, 0xFC, 0xC9, 0x37, 0xB7, 0x8E, 0xAA, 0x19 + }, + { + 0xAE, 0xF8, 0x87, 0xEF, 0xD3, 0x4E, 0xC5, 0xA6, + 0x65, 0xB1, 0xF3, 0x11, 0x2B, 0x94, 0x5C, 0x80, + 0x3E, 0xC5, 0x51, 0xD2, 0x2F, 0xD1, 0x76, 0x37, + 0x68, 0x12, 0x14, 0xD7, 0xAF, 0xD2, 0x05, 0x82 + }, + { + 0xE0, 0x4F, 0xB3, 0x7C, 0x8F, 0x7B, 0x6F, 0x6E, + 0x7A, 0xDA, 0xB2, 0x60, 0x04, 0xE4, 0x52, 0x59, + 0xDE, 0x77, 0x72, 0x94, 0x23, 0xE3, 0x69, 0xCB, + 0xCD, 0x69, 0x2A, 0x1B, 0xB7, 0x55, 0xBF, 0x3D + }, + { + 0x92, 0x95, 0x23, 0xBA, 0x32, 0x66, 0x23, 0xD3, + 0xCD, 0xFB, 0x4A, 0x5A, 0x21, 0x18, 0xEA, 0x44, + 0x61, 0xAD, 0xF2, 0x88, 0x62, 0x15, 0xAA, 0xC2, + 0x26, 0x41, 0x8E, 0x5C, 0x25, 0x4D, 0x1E, 0x0B + }, + { + 0xC1, 0xBD, 0xC9, 0x16, 0x35, 0xE0, 0x83, 0x04, + 0x80, 0xA5, 0x33, 0x55, 0x53, 0x33, 0x9F, 0xD4, + 0x05, 0xE7, 0x40, 0x53, 0xC0, 0x71, 0xDB, 0x7D, + 0xD8, 0x39, 0xCB, 0x76, 0x76, 0x3C, 0x35, 0xA5 + }, + { + 0x18, 0x4D, 0xD7, 0x76, 0x18, 0xEB, 0xFF, 0x13, + 0x66, 0x76, 0x58, 0x42, 0x23, 0x2A, 0x47, 0x3B, + 0xBC, 0xC6, 0xDE, 0x85, 0x56, 0xDE, 0x99, 0x4B, + 0x50, 0x27, 0xB0, 0x8E, 0x7A, 0x08, 0x2E, 0x42 + }, + { + 0x05, 0x41, 0x78, 0x16, 0x48, 0x0C, 0x87, 0xD7, + 0xB3, 0xD5, 0x6D, 0x69, 0x84, 0x2F, 0xFA, 0xC8, + 0xA2, 0x5E, 0x31, 0xB9, 0x2F, 0x7D, 0x88, 0xDC, + 0xD6, 0x9B, 0xD8, 0xE3, 0x5C, 0xD0, 0x6B, 0xED + }, + { + 0xF3, 0x52, 0x1A, 0xB1, 0xC6, 0x57, 0xE4, 0xC0, + 0xEE, 0xC0, 0xCF, 0x84, 0x4A, 0xED, 0x5E, 0xC1, + 0x28, 0x16, 0xE0, 0x72, 0x5A, 0x9E, 0xD2, 0x98, + 0xB2, 0xA4, 0xCB, 0xB4, 0x85, 0x6C, 0xEF, 0x81 + }, + { + 0x60, 0x2D, 0x1D, 0xEC, 0xF0, 0x7B, 0xBC, 0x79, + 0xBE, 0x97, 0xCB, 0xA3, 0xD5, 0xCA, 0x0C, 0x3E, + 0xE9, 0xC3, 0x5C, 0xF7, 0xE3, 0xB6, 0x6A, 0x52, + 0x05, 0x02, 0x27, 0x5E, 0x8C, 0xCA, 0xFB, 0xDD + }, + { + 0xB7, 0x23, 0x1E, 0x25, 0x5B, 0xA9, 0x95, 0x35, + 0xEC, 0x1A, 0x75, 0x5F, 0x7F, 0x2E, 0xAA, 0x57, + 0xB2, 0x27, 0xC2, 0x35, 0x70, 0xE5, 0xCA, 0xB1, + 0xD2, 0x8C, 0xF9, 0xF8, 0x22, 0xB3, 0x49, 0xCC + }, + { + 0x01, 0x29, 0xBD, 0x31, 0x36, 0x2D, 0xD5, 0xCA, + 0xC8, 0x6C, 0xD1, 0x1D, 0xDC, 0x59, 0xDC, 0xAA, + 0x08, 0xC6, 0x74, 0x2F, 0x00, 0x66, 0xC1, 0x05, + 0x07, 0xC0, 0x23, 0x07, 0xB9, 0x18, 0x3D, 0x2C + }, + { + 0x3C, 0xA8, 0x30, 0x7C, 0x86, 0x93, 0x02, 0x68, + 0x33, 0xB7, 0x3C, 0xE7, 0xE4, 0x6D, 0x2D, 0x30, + 0x96, 0x29, 0x96, 0xED, 0x6A, 0xAA, 0xA1, 0x0C, + 0x5E, 0xB2, 0x30, 0x8C, 0x82, 0x46, 0x25, 0x2B + }, + { + 0x56, 0xBF, 0xDD, 0xEA, 0x76, 0x01, 0xA2, 0xAA, + 0xCB, 0xE3, 0x43, 0xCC, 0x73, 0x0F, 0x9D, 0x42, + 0xEE, 0xFE, 0x18, 0x77, 0xDA, 0x73, 0x7D, 0xC9, + 0x7A, 0xF9, 0x4A, 0x7F, 0x94, 0xE3, 0x4B, 0xFA + }, + { + 0x8D, 0xAC, 0x8F, 0x14, 0xC8, 0x50, 0x6E, 0x14, + 0x9C, 0x84, 0x57, 0xCC, 0x40, 0x95, 0xAE, 0x03, + 0x79, 0x87, 0xA9, 0xDB, 0x65, 0xC2, 0xB7, 0xF3, + 0xAA, 0x61, 0xB5, 0xC8, 0xF3, 0x72, 0x84, 0x73 + }, + { + 0x93, 0xED, 0xD3, 0x50, 0x08, 0xD2, 0xE6, 0x23, + 0x13, 0x8F, 0x8B, 0x64, 0xFB, 0x8E, 0x13, 0xCC, + 0x44, 0xD9, 0xCE, 0x92, 0x57, 0xE1, 0xF4, 0x19, + 0xD0, 0xFC, 0xFF, 0x04, 0x00, 0xD3, 0x1C, 0xE3 + }, + { + 0x53, 0x38, 0xA9, 0xED, 0x6D, 0xB4, 0x14, 0xDF, + 0xBB, 0x97, 0x73, 0x5E, 0xEB, 0x89, 0x3B, 0xFE, + 0x4D, 0x95, 0xE5, 0xDC, 0xCD, 0x9B, 0x00, 0xB1, + 0xC0, 0x2B, 0x73, 0xF6, 0x53, 0x96, 0x84, 0x8D + }, + { + 0x73, 0xCF, 0x27, 0x0B, 0xEC, 0x80, 0x72, 0x44, + 0x8C, 0x14, 0x67, 0xF0, 0x0D, 0xD7, 0x4F, 0x67, + 0x76, 0x51, 0x0E, 0x8B, 0x77, 0xA8, 0x4E, 0x82, + 0x9E, 0x57, 0x2C, 0x74, 0x24, 0x25, 0x21, 0x1D + }, + { + 0x5E, 0x50, 0xAC, 0x1D, 0x3C, 0xE8, 0x58, 0x83, + 0x0A, 0xD5, 0xF6, 0x52, 0x42, 0xD7, 0x41, 0xAA, + 0x30, 0x73, 0x1C, 0xB2, 0xEB, 0x81, 0x1D, 0xB6, + 0x71, 0x02, 0xB1, 0x8E, 0x40, 0x3D, 0x91, 0xE2 + }, + { + 0xD4, 0x88, 0xC5, 0xBE, 0xFC, 0x32, 0x9D, 0x32, + 0xCA, 0x27, 0xF0, 0xA0, 0x2D, 0xE9, 0x43, 0x8E, + 0x54, 0xAE, 0xE9, 0x5E, 0xC7, 0xD9, 0x98, 0x91, + 0x4C, 0x32, 0xD5, 0xB0, 0xC9, 0xB3, 0xD0, 0x56 + }, + { + 0x96, 0xDF, 0x70, 0x80, 0xF3, 0x2F, 0xE3, 0xD8, + 0x79, 0xFD, 0x5C, 0x23, 0xF3, 0xA3, 0x3D, 0x9D, + 0x73, 0x15, 0x70, 0x61, 0x20, 0x11, 0x1F, 0xDF, + 0xF5, 0x7D, 0x36, 0xB5, 0xC4, 0xF0, 0x28, 0x19 + }, + { + 0xE4, 0x67, 0x25, 0xF3, 0xED, 0x3A, 0x42, 0x2D, + 0x90, 0xAE, 0x3E, 0x13, 0x9D, 0x7E, 0xD6, 0x4A, + 0x4D, 0x6E, 0xFA, 0xB3, 0xE5, 0x2F, 0xFB, 0xE2, + 0x64, 0xBF, 0x89, 0x71, 0x50, 0xB2, 0x24, 0xC6 + }, + { + 0xA0, 0x52, 0x62, 0x0B, 0x66, 0x51, 0x86, 0x8A, + 0xB2, 0x96, 0xB7, 0x8E, 0x63, 0x02, 0x38, 0xAF, + 0xA9, 0xFE, 0x1D, 0x99, 0x0A, 0x5F, 0x9C, 0xE9, + 0x21, 0xF9, 0x6D, 0x4F, 0xDF, 0x2B, 0xD8, 0x4D + }, + { + 0xD3, 0x82, 0xB5, 0xA0, 0x91, 0xA7, 0x75, 0xC7, + 0x49, 0x46, 0x6B, 0x94, 0xD3, 0x5C, 0x67, 0x32, + 0x05, 0x77, 0xA6, 0x6D, 0xF5, 0xE6, 0x89, 0x7E, + 0x07, 0x25, 0x5C, 0x2C, 0x4E, 0xE2, 0x97, 0x69 + }, + { + 0x1C, 0x1C, 0x9F, 0xC2, 0x3C, 0x3F, 0xF3, 0x41, + 0xC8, 0x35, 0x82, 0xCE, 0xA3, 0x8F, 0x46, 0x45, + 0x7E, 0xC5, 0xA2, 0x6E, 0x51, 0x5B, 0x6A, 0x9F, + 0x30, 0xDE, 0x3A, 0x9B, 0xCE, 0xFE, 0x21, 0x13 + }, + { + 0x9E, 0x07, 0x18, 0x20, 0x36, 0xDA, 0x1F, 0xDE, + 0x6E, 0x2A, 0xE3, 0x36, 0x6C, 0xF4, 0xAA, 0xEB, + 0x03, 0x8A, 0x9D, 0xCA, 0xBE, 0x6B, 0x24, 0x28, + 0x12, 0xD1, 0x26, 0x74, 0x44, 0x4A, 0x6C, 0xC1 + }, + { + 0x65, 0xA5, 0x0A, 0x8D, 0xCB, 0x18, 0x5E, 0xAA, + 0x87, 0xD4, 0x00, 0x80, 0xBB, 0x0B, 0xA9, 0x16, + 0x71, 0xBB, 0x7A, 0x37, 0x73, 0xE1, 0xB5, 0x21, + 0xEB, 0xD9, 0x46, 0xC6, 0x09, 0x8F, 0x52, 0x70 + }, + { + 0xDE, 0xF2, 0x1D, 0xEA, 0x63, 0x10, 0xA7, 0xB0, + 0xA8, 0xE5, 0x83, 0x41, 0x3A, 0xC2, 0x90, 0x03, + 0x86, 0x7A, 0xE4, 0xFF, 0xCA, 0x98, 0xB3, 0x27, + 0x14, 0xD0, 0x60, 0x79, 0x80, 0xB9, 0x3F, 0xE8 + }, + { + 0x46, 0xE8, 0x68, 0xDC, 0xE5, 0x44, 0x9B, 0x91, + 0x29, 0x8B, 0xC0, 0x42, 0x29, 0x89, 0xA3, 0x8B, + 0x6B, 0x97, 0x8E, 0x89, 0x1C, 0x26, 0x6C, 0x79, + 0x33, 0xF5, 0xDA, 0x75, 0x8F, 0xAE, 0x61, 0x59 + }, + { + 0xF0, 0x46, 0xE4, 0xE1, 0xF5, 0x6A, 0x5D, 0xDA, + 0xDF, 0xA8, 0x7F, 0xC9, 0xDD, 0x58, 0xD5, 0xEA, + 0xEE, 0x55, 0x05, 0x91, 0x1C, 0x9C, 0x1C, 0x01, + 0x74, 0xAB, 0x54, 0x75, 0xDC, 0x74, 0xEB, 0x31 + }, + { + 0xCB, 0x98, 0x8B, 0x37, 0x86, 0x14, 0x7C, 0x1C, + 0xEA, 0x20, 0xF4, 0x5C, 0xE6, 0xB2, 0xAE, 0x3B, + 0x3E, 0xBD, 0x33, 0xC0, 0xA0, 0x2D, 0x93, 0xA9, + 0xD4, 0x54, 0xE5, 0xCC, 0xA7, 0xE6, 0x22, 0xF8 + }, + { + 0x7A, 0x38, 0xF3, 0x36, 0x3A, 0x67, 0xB6, 0x95, + 0xF2, 0xB9, 0xFE, 0x42, 0xC5, 0x47, 0x72, 0x98, + 0x8D, 0x9C, 0x51, 0x34, 0x3B, 0x6F, 0xE4, 0x4A, + 0x10, 0x6E, 0xAC, 0xC7, 0xF7, 0xDE, 0x30, 0x62 + }, + { + 0xCD, 0x04, 0xF9, 0x19, 0x27, 0xE8, 0x26, 0xFC, + 0x02, 0xC2, 0x48, 0x5A, 0xF6, 0x44, 0x9B, 0xD2, + 0xEE, 0x51, 0xC6, 0x45, 0x58, 0x0C, 0x5E, 0xA4, + 0xEB, 0x27, 0x27, 0xED, 0x26, 0x77, 0x8F, 0x45 + }, + { + 0xBB, 0x67, 0x39, 0xA1, 0xDC, 0x98, 0x70, 0x11, + 0xE7, 0x26, 0xE3, 0x8C, 0xA4, 0x4B, 0xD8, 0xE4, + 0x4D, 0xEE, 0x2B, 0x7F, 0x59, 0x71, 0x03, 0x51, + 0x4B, 0x24, 0xA7, 0x16, 0x49, 0x85, 0xBA, 0xEC + }, + { + 0x59, 0xB6, 0xA4, 0xEA, 0x36, 0xD8, 0x10, 0x77, + 0xFB, 0x20, 0x20, 0x61, 0x21, 0xE3, 0x8F, 0xB4, + 0xFE, 0xC5, 0x72, 0x48, 0x82, 0x20, 0xA5, 0xDE, + 0x72, 0x34, 0x2A, 0xCB, 0x1D, 0xFF, 0x04, 0xA5 + }, + { + 0xAA, 0xC0, 0x7F, 0x30, 0xA1, 0x18, 0x45, 0x2F, + 0x0A, 0xC1, 0x68, 0x43, 0x97, 0x52, 0x2D, 0xFD, + 0xAF, 0xAC, 0x71, 0xD3, 0x63, 0xED, 0x8B, 0x9E, + 0x9E, 0xA8, 0xCF, 0xAD, 0x21, 0x75, 0x34, 0x71 + }, + { + 0xCA, 0x30, 0x18, 0xF9, 0x96, 0x77, 0x02, 0x9C, + 0x86, 0x82, 0x01, 0xA8, 0xBB, 0x6D, 0xC1, 0x53, + 0x21, 0xE3, 0xDC, 0x84, 0x66, 0x38, 0xA6, 0xDA, + 0xEE, 0xC0, 0x5F, 0xE2, 0x79, 0x69, 0x2A, 0xDB + }, + { + 0x2B, 0xD6, 0x6A, 0x76, 0x17, 0xCC, 0xB1, 0xBE, + 0xF4, 0xC6, 0xAA, 0xAE, 0xF5, 0x2C, 0x81, 0x2E, + 0x39, 0x21, 0xBD, 0x9A, 0x9A, 0x60, 0xE6, 0xC3, + 0x1F, 0x6B, 0xBB, 0xB6, 0x3D, 0x8E, 0x15, 0x44 + }, + { + 0x2C, 0xC7, 0x43, 0x5C, 0x83, 0x34, 0x44, 0x43, + 0xA9, 0x1B, 0xAB, 0x7A, 0xF8, 0xBA, 0x45, 0x87, + 0xA5, 0x29, 0x4E, 0x26, 0x96, 0xF8, 0xF0, 0x9F, + 0x12, 0x93, 0xDB, 0x52, 0x77, 0x12, 0xE6, 0x9F + }, + { + 0xB8, 0x13, 0xDB, 0xC8, 0x18, 0xAA, 0x5A, 0x3F, + 0xE0, 0xDC, 0xF1, 0x6F, 0xB9, 0xE5, 0x0C, 0x47, + 0xC6, 0x84, 0x91, 0x2C, 0x65, 0x65, 0xD2, 0x2E, + 0x90, 0x09, 0x2F, 0x4F, 0x74, 0x43, 0x7A, 0xE1 + }, + { + 0x2F, 0xD5, 0xDD, 0x6D, 0xF2, 0xF2, 0x92, 0x0B, + 0xCF, 0x11, 0xB6, 0x2F, 0x92, 0xF0, 0x53, 0x02, + 0xA9, 0x7D, 0xC8, 0xBD, 0x05, 0xD1, 0x91, 0x59, + 0xF1, 0x3C, 0xC2, 0xA6, 0x48, 0x92, 0x4C, 0x07 + }, + { + 0x4D, 0x57, 0x1A, 0xD0, 0x0F, 0x57, 0x6F, 0x12, + 0x8D, 0xFB, 0xAE, 0x16, 0xA2, 0x6F, 0xA0, 0x60, + 0xF2, 0xE2, 0x1B, 0x63, 0x49, 0x93, 0xBF, 0x7C, + 0xF6, 0x82, 0xA2, 0xA4, 0x56, 0x79, 0x6E, 0x9F + }, + { + 0x44, 0xC8, 0x22, 0x26, 0x5B, 0x81, 0xF8, 0xFB, + 0x16, 0xDB, 0x15, 0xC5, 0xB9, 0x2C, 0x83, 0xB5, + 0x48, 0xBA, 0x5A, 0x71, 0x06, 0xB0, 0x28, 0x16, + 0x7B, 0xA6, 0x85, 0xEA, 0x88, 0x17, 0x88, 0x35 + }, + { + 0x08, 0xA2, 0xC7, 0xEA, 0x71, 0x3B, 0x99, 0x36, + 0xFE, 0x92, 0xAA, 0xD5, 0xAD, 0x51, 0xFE, 0x92, + 0x8C, 0xF0, 0x2B, 0x3A, 0xC8, 0x2B, 0x67, 0x6A, + 0x92, 0xBF, 0x9C, 0x25, 0x56, 0x00, 0xBE, 0x73 + }, + { + 0x50, 0x88, 0x64, 0x43, 0x12, 0x13, 0x4E, 0xD1, + 0xF9, 0x9A, 0x0E, 0xE7, 0x0A, 0xC6, 0xD4, 0xC2, + 0xBC, 0x29, 0x8E, 0x6C, 0x4C, 0x64, 0x05, 0x12, + 0xFC, 0xC4, 0x63, 0xB4, 0x24, 0xE1, 0x94, 0xCA + }, + { + 0x00, 0x3F, 0x79, 0x69, 0x77, 0x65, 0x8A, 0xD2, + 0x56, 0xC8, 0x26, 0xD1, 0x08, 0xC2, 0x9F, 0x46, + 0xEF, 0x48, 0x37, 0x6D, 0xFF, 0x02, 0x8B, 0xE0, + 0xE1, 0xCD, 0x8B, 0xD9, 0x13, 0x51, 0xF6, 0xB9 + }, + { + 0x2C, 0xC9, 0x58, 0x49, 0xD7, 0xC8, 0xD8, 0x95, + 0xE5, 0x86, 0x07, 0x23, 0xC8, 0x33, 0x1D, 0xA3, + 0x52, 0x09, 0xC5, 0x5C, 0x76, 0xC5, 0x3E, 0x2C, + 0x6A, 0x07, 0x40, 0x27, 0xE3, 0x53, 0x6D, 0x68 + }, + { + 0x33, 0x35, 0xCC, 0xA0, 0x63, 0x62, 0xC1, 0xD1, + 0x97, 0xBA, 0x68, 0x9C, 0xB0, 0x5D, 0x0C, 0xBA, + 0xB5, 0xEC, 0xC2, 0x17, 0x13, 0x84, 0xE4, 0x48, + 0x64, 0x6B, 0x6D, 0xCE, 0xF2, 0x47, 0x21, 0xF7 + }, + { + 0xC8, 0xCD, 0xD9, 0x02, 0x93, 0x68, 0x9A, 0x63, + 0x89, 0xAC, 0x6E, 0xFD, 0x67, 0x45, 0xCC, 0x29, + 0x9B, 0x20, 0xB1, 0xB2, 0x79, 0x4F, 0xA3, 0xF9, + 0x73, 0x12, 0xA2, 0x3C, 0x21, 0x33, 0xC9, 0x9E + }, + { + 0xE2, 0xF3, 0x6A, 0x77, 0x01, 0x27, 0xE1, 0xBF, + 0x0D, 0xDF, 0x48, 0xBF, 0x11, 0xE3, 0x10, 0x95, + 0xF0, 0xE2, 0x15, 0x76, 0x5C, 0x03, 0xA1, 0xCF, + 0xBE, 0x23, 0xFB, 0xA0, 0x2F, 0xA9, 0x2F, 0x0C + }, + { + 0x8F, 0x25, 0x7B, 0x7F, 0xF1, 0x35, 0xEA, 0x8A, + 0xF7, 0xBE, 0x98, 0xF2, 0xF2, 0xC0, 0x2E, 0x3A, + 0xB5, 0xF5, 0xD7, 0x1F, 0x95, 0xCE, 0x5C, 0x5A, + 0x66, 0x5B, 0x9E, 0xFC, 0x35, 0x78, 0x62, 0x30 + }, + { + 0x2B, 0x92, 0xDE, 0x7D, 0x6C, 0x05, 0x4D, 0x0D, + 0xD0, 0x25, 0xC8, 0xF1, 0x37, 0x0B, 0x84, 0xD7, + 0xF0, 0xB5, 0x1E, 0x8D, 0xB0, 0x92, 0xA9, 0x5D, + 0x0D, 0x49, 0x29, 0x2F, 0xB6, 0xC4, 0xD3, 0x75 + }, + { + 0x50, 0x94, 0xDF, 0x50, 0xD4, 0x8D, 0x36, 0x03, + 0x89, 0x87, 0x08, 0x45, 0xB1, 0x6E, 0xCF, 0xBC, + 0xCF, 0x7B, 0x24, 0xBD, 0xF6, 0xC3, 0x29, 0xC1, + 0x79, 0x23, 0x60, 0x46, 0x2F, 0xA5, 0x9F, 0xC4 + }, + { + 0x33, 0x0D, 0x5D, 0x7D, 0xAC, 0x60, 0x03, 0x2E, + 0xC7, 0xC2, 0xFA, 0x0D, 0xF1, 0x48, 0xB0, 0x82, + 0xF0, 0x6C, 0xA5, 0x3A, 0x7A, 0x8A, 0x93, 0x9C, + 0x8B, 0x4E, 0x76, 0xA7, 0x68, 0xBD, 0x39, 0x51 + }, + { + 0x4C, 0x4E, 0x91, 0x35, 0x5E, 0xDB, 0xCC, 0xDB, + 0x2B, 0xB1, 0x83, 0x8D, 0xB1, 0x2E, 0x31, 0x3A, + 0x43, 0xB8, 0x09, 0x9B, 0x42, 0x09, 0x36, 0xCC, + 0x80, 0x8E, 0xD9, 0x71, 0x67, 0x0B, 0xE4, 0x5D + }, + { + 0x6D, 0x43, 0x66, 0x57, 0xC8, 0x4A, 0x1D, 0x45, + 0x0E, 0x0D, 0x8C, 0x4D, 0xC6, 0x5A, 0x56, 0x3A, + 0xCB, 0x8E, 0xC4, 0x95, 0xF4, 0x76, 0x15, 0x61, + 0x2A, 0x4A, 0xA8, 0xD9, 0xAB, 0x2B, 0x43, 0x0E + }, + { + 0xD0, 0x14, 0xE6, 0x34, 0x09, 0xB4, 0xAF, 0x50, + 0x15, 0xDF, 0xC9, 0x5A, 0x39, 0xC0, 0x7B, 0x0F, + 0x6C, 0xD4, 0x52, 0x49, 0x59, 0x85, 0x90, 0x20, + 0x28, 0xA3, 0x01, 0x26, 0x82, 0x1F, 0x40, 0xF7 + }, + { + 0x89, 0x2B, 0x5E, 0x7B, 0x46, 0xBE, 0xE6, 0x05, + 0x05, 0x55, 0x05, 0x36, 0x91, 0xF4, 0xD7, 0x42, + 0xB6, 0x94, 0xD3, 0x78, 0xA6, 0xA8, 0x53, 0xD2, + 0xE0, 0x5F, 0xD9, 0xA9, 0xA5, 0xF8, 0xE4, 0x9D + }, + { + 0x58, 0xA6, 0xB4, 0x7D, 0x3C, 0xF2, 0x4A, 0x1E, + 0x03, 0x81, 0x02, 0x26, 0x53, 0x6D, 0xFB, 0x61, + 0x37, 0xAA, 0x0D, 0x12, 0x25, 0x7D, 0x32, 0x19, + 0xB0, 0xBB, 0xAE, 0xB3, 0x12, 0x9E, 0xCA, 0x35 + }, + { + 0xC1, 0x3E, 0xB2, 0xE6, 0xA9, 0x63, 0x39, 0x25, + 0xB2, 0x89, 0x07, 0x3A, 0xC5, 0x30, 0x7D, 0x9F, + 0x16, 0x8D, 0x2A, 0xF7, 0x02, 0x54, 0xD3, 0x1A, + 0x05, 0x5A, 0xCA, 0x04, 0xAA, 0xA8, 0x23, 0x8B + }, + { + 0x3C, 0x4D, 0x19, 0x76, 0xC4, 0x19, 0x06, 0xA7, + 0x66, 0x87, 0xE6, 0x6E, 0xAB, 0xEC, 0x70, 0x9C, + 0x67, 0xFE, 0x25, 0x4C, 0xD4, 0x45, 0x21, 0xA9, + 0xE2, 0x90, 0x8A, 0x47, 0x38, 0x4B, 0x7F, 0x50 + }, + { + 0x40, 0xB0, 0x16, 0x4C, 0x9C, 0xFC, 0xF3, 0x32, + 0x4D, 0xEC, 0x2C, 0x92, 0x42, 0x26, 0x8D, 0xE8, + 0x30, 0xD1, 0xBE, 0x3B, 0x2A, 0xC3, 0x43, 0xC7, + 0x2A, 0x5B, 0x24, 0x1D, 0xE5, 0x9E, 0x9F, 0xAD + }, + { + 0x05, 0x92, 0x82, 0x5A, 0xEC, 0xE8, 0xB5, 0xD2, + 0x6A, 0x22, 0x3E, 0x7D, 0xF6, 0x12, 0xF1, 0x17, + 0xF8, 0x50, 0x07, 0xB1, 0x20, 0x43, 0x01, 0xE2, + 0x7D, 0x15, 0xBD, 0x48, 0x74, 0x83, 0x14, 0x12 + }, + { + 0x03, 0x99, 0x46, 0x8A, 0x7A, 0x85, 0xD4, 0x88, + 0x93, 0x51, 0x51, 0x08, 0x4E, 0xA2, 0x1A, 0x9B, + 0x60, 0xE0, 0x75, 0xB5, 0xD0, 0xA4, 0x48, 0xCC, + 0x70, 0xF3, 0xA9, 0xE9, 0xAD, 0xDC, 0x1A, 0x64 + }, + { + 0xBB, 0x1A, 0x88, 0x12, 0x3E, 0x64, 0x17, 0x98, + 0xF9, 0xB9, 0x95, 0x9F, 0xD2, 0xD3, 0x89, 0x8D, + 0xC7, 0xD0, 0x59, 0x9D, 0x2B, 0x99, 0xA1, 0x72, + 0x1E, 0xE7, 0x23, 0xD2, 0xF4, 0x01, 0x86, 0x8E + }, + { + 0x0F, 0xE4, 0xF5, 0xD6, 0xA2, 0x97, 0x3C, 0x37, + 0x22, 0xB2, 0x23, 0x37, 0x5A, 0x80, 0x8F, 0x25, + 0x4A, 0xE8, 0x07, 0x27, 0x81, 0x69, 0x53, 0x3D, + 0xD4, 0x9E, 0x78, 0x37, 0xC2, 0xF4, 0x22, 0x71 + }, + { + 0x4C, 0xAF, 0xFB, 0x5A, 0x94, 0x13, 0x2C, 0x19, + 0xC7, 0xAE, 0x6C, 0xDE, 0xAF, 0x16, 0xA2, 0x74, + 0x7B, 0xBF, 0xA3, 0x5F, 0x4A, 0x40, 0x25, 0xBB, + 0x73, 0x21, 0xBE, 0xF9, 0xFE, 0x00, 0x34, 0x51 + }, + { + 0x07, 0x1C, 0x0C, 0x25, 0x87, 0x43, 0xB8, 0x28, + 0x93, 0x4F, 0x6A, 0x44, 0x54, 0x1F, 0x28, 0xF8, + 0x81, 0xA9, 0xF3, 0x97, 0x8F, 0x65, 0x20, 0x09, + 0x3B, 0x30, 0xBF, 0x4F, 0x6D, 0x11, 0x94, 0x30 + }, + { + 0x44, 0x3E, 0x4B, 0xC9, 0x5D, 0xE2, 0x42, 0x00, + 0xAF, 0x2B, 0x28, 0x6B, 0xA6, 0x84, 0xE8, 0x15, + 0x2E, 0x92, 0xBB, 0x99, 0xAE, 0xC3, 0xEB, 0x25, + 0x61, 0x14, 0x74, 0xD8, 0x4A, 0xB6, 0x29, 0x36 + }, + { + 0x93, 0x20, 0xC8, 0x57, 0x1E, 0xE0, 0xE2, 0xCF, + 0x3D, 0xAA, 0x09, 0xFC, 0x18, 0x13, 0xD6, 0x1E, + 0x8F, 0xC8, 0x08, 0xA4, 0x91, 0x11, 0x25, 0x96, + 0x3D, 0x72, 0x01, 0xF1, 0x04, 0x54, 0x78, 0xF8 + }, + { + 0xE4, 0x0A, 0x02, 0x22, 0x2D, 0x97, 0x99, 0xCD, + 0xE5, 0x5D, 0x7D, 0xE6, 0x9D, 0x24, 0x78, 0xA6, + 0x5A, 0x07, 0x81, 0x72, 0xED, 0x25, 0xDC, 0x32, + 0xE1, 0xE5, 0x09, 0x72, 0x8F, 0xDF, 0xDA, 0xA8 + }, + { + 0xE0, 0x5A, 0x22, 0x7A, 0x1B, 0xAE, 0x50, 0x33, + 0x27, 0xC6, 0xFA, 0x77, 0xE2, 0x68, 0x0A, 0x25, + 0x17, 0x1E, 0x04, 0x49, 0x2F, 0x90, 0x2E, 0x79, + 0x63, 0xCF, 0xF4, 0x72, 0x2E, 0x25, 0x98, 0x64 + }, + { + 0x66, 0x0F, 0x3D, 0xB6, 0x43, 0xCE, 0xB5, 0x69, + 0x22, 0x52, 0xFE, 0x52, 0xA1, 0x34, 0xC3, 0x43, + 0xFD, 0x18, 0x27, 0x83, 0x0C, 0xD8, 0xFE, 0x2F, + 0x2B, 0xDE, 0xE5, 0x51, 0x86, 0xBD, 0x6A, 0x82 + }, + { + 0x60, 0x4C, 0xCC, 0x2D, 0xF1, 0xBE, 0xAD, 0xAC, + 0x5A, 0xF1, 0x44, 0x0B, 0xBD, 0x2A, 0xF2, 0x45, + 0x6A, 0x5A, 0xF6, 0x88, 0xB8, 0x97, 0x21, 0xE7, + 0xD5, 0x8E, 0xA8, 0x2C, 0xDE, 0x93, 0x96, 0x40 + }, + { + 0x33, 0x1F, 0x74, 0x85, 0x62, 0x77, 0x9D, 0x8B, + 0x30, 0x48, 0xB4, 0x30, 0xD4, 0x16, 0x78, 0x80, + 0x77, 0x7B, 0xC1, 0x30, 0x35, 0x03, 0xCC, 0x7F, + 0x4E, 0x7D, 0x92, 0xFD, 0xF8, 0xFE, 0x7C, 0x0D + }, + { + 0x94, 0x07, 0xB7, 0x93, 0x7E, 0xD8, 0xD3, 0x53, + 0xFC, 0xC6, 0xD5, 0x69, 0x53, 0xE6, 0xA6, 0xFB, + 0xEB, 0x2C, 0x24, 0xFC, 0x78, 0x68, 0xBF, 0x55, + 0x83, 0x8D, 0xBB, 0xED, 0xE9, 0xF1, 0x96, 0x20 + }, + { + 0x70, 0x11, 0x24, 0xAD, 0xE3, 0x82, 0x52, 0x66, + 0x65, 0xB7, 0x1B, 0x16, 0xB4, 0xEE, 0x5E, 0x79, + 0x18, 0x7F, 0xF3, 0x37, 0xBC, 0x95, 0x7F, 0x7E, + 0xEC, 0x55, 0x74, 0x5F, 0x14, 0x78, 0x0A, 0x98 + }, + { + 0x67, 0xED, 0x3D, 0x66, 0x37, 0xBC, 0xA7, 0x5A, + 0xC8, 0x08, 0x07, 0x69, 0x0A, 0xC2, 0xBC, 0x33, + 0x81, 0xA9, 0x0E, 0xFA, 0xF8, 0x59, 0x1F, 0xB5, + 0xCF, 0x45, 0x17, 0xD6, 0xAE, 0x21, 0xBA, 0xD1 + }, + { + 0x9C, 0x84, 0xC4, 0x97, 0x06, 0xCD, 0xD0, 0x50, + 0x52, 0xAF, 0xFC, 0x3E, 0xD4, 0x63, 0x07, 0xB8, + 0x76, 0x0A, 0x06, 0x80, 0xF6, 0xBE, 0xD3, 0x3D, + 0x14, 0x9B, 0x2F, 0x68, 0x0D, 0xC6, 0x82, 0x50 + }, + { + 0x6E, 0x60, 0x66, 0xD6, 0x65, 0x91, 0xE9, 0x22, + 0x49, 0xDB, 0x8A, 0xD4, 0x90, 0x67, 0x2C, 0xBD, + 0x08, 0x92, 0x01, 0xDB, 0x04, 0x69, 0x26, 0xDD, + 0x83, 0x44, 0x3E, 0x88, 0x53, 0x0F, 0xA8, 0xDA + }, + { + 0xFD, 0x72, 0xB6, 0xB3, 0x4F, 0x9B, 0x39, 0xA7, + 0x9C, 0x12, 0xA4, 0xAD, 0xF7, 0x89, 0x1A, 0xF0, + 0x83, 0x41, 0x33, 0x66, 0x8B, 0xEE, 0x87, 0xBC, + 0x00, 0xA3, 0xB2, 0x6E, 0x54, 0x23, 0x93, 0xF1 + }, + { + 0x88, 0xB3, 0x73, 0xFD, 0xFB, 0x3F, 0x4C, 0xC5, + 0x55, 0x2F, 0x3D, 0x3F, 0x40, 0x1D, 0x04, 0x1D, + 0x0D, 0x5F, 0x7E, 0xEC, 0x75, 0x0E, 0xD6, 0xFD, + 0xF2, 0x0E, 0x1D, 0xF1, 0x07, 0xE3, 0xA2, 0x84 + }, + { + 0xDE, 0xCA, 0x86, 0x0A, 0xFA, 0x9B, 0x46, 0x40, + 0x81, 0xFE, 0xAD, 0x59, 0x81, 0x8D, 0xEF, 0x67, + 0x39, 0x52, 0x2A, 0x24, 0x5F, 0xB9, 0x62, 0xE0, + 0x81, 0xD6, 0x08, 0xC4, 0xBC, 0x58, 0x76, 0x6C + }, + { + 0xFF, 0xE2, 0x34, 0x68, 0x1B, 0xFE, 0x96, 0x85, + 0xD5, 0xEB, 0xD5, 0xC5, 0xEA, 0x47, 0x91, 0x4B, + 0x1C, 0x01, 0x63, 0xDF, 0x2D, 0x60, 0xA9, 0x4E, + 0x1F, 0x07, 0x55, 0x15, 0x22, 0x5E, 0xDA, 0x05 + }, + { + 0xE0, 0x3D, 0xAD, 0x10, 0xAA, 0xFC, 0x79, 0xD9, + 0xF1, 0xD5, 0x86, 0x11, 0xED, 0xE4, 0x28, 0xAC, + 0x36, 0x72, 0xDD, 0x87, 0x07, 0x15, 0x76, 0x42, + 0xD6, 0x6E, 0xD7, 0x72, 0x8D, 0x19, 0xC3, 0x5F + }, + { + 0x79, 0x8D, 0x89, 0xD6, 0x23, 0x66, 0xCF, 0x37, + 0xFA, 0x5B, 0xB2, 0x32, 0xDB, 0x8A, 0xB5, 0xF3, + 0xA6, 0xB2, 0xD4, 0xB4, 0xD6, 0x26, 0xF7, 0x76, + 0x1A, 0xE3, 0xBA, 0x42, 0x72, 0x9C, 0xCC, 0x0E + }, + { + 0xAC, 0x71, 0x4D, 0xB8, 0x29, 0xF1, 0xE6, 0x9C, + 0x96, 0x33, 0x76, 0x64, 0xAB, 0x84, 0x2D, 0x40, + 0x72, 0x8C, 0xD8, 0x60, 0x13, 0x8C, 0x8C, 0xFF, + 0x8B, 0x9B, 0x77, 0xEF, 0x6E, 0x09, 0xA3, 0xA8 + }, + { + 0xB7, 0xD1, 0x44, 0xB6, 0xA4, 0x8B, 0x51, 0xC5, + 0x5F, 0x60, 0xB9, 0xE6, 0x8F, 0x4E, 0x68, 0x38, + 0xD3, 0x08, 0x52, 0x48, 0x8F, 0xAA, 0x27, 0x6B, + 0x81, 0x4C, 0x2D, 0xE2, 0xE5, 0x2D, 0xD7, 0xAA + }, + { + 0xC5, 0x9F, 0xE7, 0xA1, 0xA7, 0xC8, 0x38, 0xEA, + 0xAC, 0xA4, 0x9D, 0x9A, 0x7E, 0x36, 0xE3, 0x12, + 0xDF, 0x71, 0xD8, 0xAA, 0xDE, 0xEE, 0xD3, 0xB3, + 0x12, 0x0B, 0x3B, 0x20, 0x16, 0x76, 0xF3, 0xF0 + }, + { + 0xCC, 0x6C, 0x42, 0x09, 0x34, 0xB7, 0xE7, 0xA2, + 0xB9, 0x93, 0x8D, 0xE8, 0x39, 0x08, 0x22, 0x63, + 0x71, 0x89, 0x35, 0x90, 0x3B, 0x6E, 0xA8, 0x4B, + 0x71, 0x8B, 0xFC, 0xFC, 0x5F, 0x82, 0x1D, 0x0F + }, + { + 0x87, 0x10, 0x83, 0xDF, 0x5A, 0x27, 0xB1, 0x72, + 0x4E, 0xA1, 0x77, 0x16, 0xAF, 0xFE, 0xB3, 0xA2, + 0x79, 0x39, 0x82, 0xC0, 0x73, 0x36, 0x88, 0x58, + 0x2A, 0xFE, 0x8F, 0x31, 0xBF, 0x46, 0x8F, 0x37 + }, + { + 0xEA, 0xCE, 0x38, 0xC5, 0x62, 0x68, 0xD9, 0x6F, + 0xF9, 0xBA, 0xE4, 0x9F, 0x0B, 0x16, 0x98, 0x3A, + 0x78, 0x50, 0xD2, 0xA6, 0xD7, 0xF4, 0x6D, 0x9E, + 0xBD, 0x4A, 0x47, 0x59, 0x8B, 0x24, 0xFE, 0x1D + }, + { + 0xC1, 0x1D, 0x25, 0x56, 0xAC, 0x08, 0x68, 0x18, + 0x72, 0x0B, 0x8D, 0xCB, 0xB2, 0x0A, 0x56, 0x62, + 0x52, 0x38, 0x6D, 0xF7, 0x04, 0xCB, 0xBC, 0xFD, + 0x8A, 0x04, 0x5B, 0xA1, 0xFC, 0x41, 0xCD, 0xE0 + }, + { + 0x85, 0x96, 0x29, 0x44, 0xA5, 0x56, 0x69, 0xA5, + 0xA7, 0xD3, 0xF2, 0xAA, 0x60, 0x26, 0xCF, 0xDE, + 0x86, 0xC8, 0x2E, 0x79, 0x70, 0x61, 0x4E, 0xA2, + 0xA3, 0x6C, 0x0B, 0x7B, 0x1A, 0x6E, 0xDC, 0xA6 + }, + { + 0x59, 0x91, 0x5F, 0xBA, 0x8A, 0x2B, 0xF7, 0x85, + 0x10, 0x57, 0x0D, 0x8F, 0x3B, 0xB6, 0xE7, 0xCC, + 0x15, 0x5D, 0xBD, 0xBE, 0xB1, 0x4B, 0x3F, 0x79, + 0xDE, 0xA7, 0x37, 0x24, 0x08, 0x2C, 0x27, 0xED + }, + { + 0xD0, 0x30, 0xAC, 0x5A, 0xDA, 0xDB, 0x03, 0x09, + 0x1A, 0x70, 0x1A, 0xC6, 0x0B, 0x1E, 0x99, 0xCE, + 0x9F, 0x8B, 0x0D, 0xBB, 0xDC, 0x9B, 0xFC, 0x5F, + 0x37, 0x79, 0x5E, 0x96, 0x7E, 0x5D, 0x78, 0xBC + }, + { + 0xA4, 0xEB, 0x6D, 0x2E, 0x89, 0x5E, 0xD3, 0x25, + 0xC0, 0x38, 0x89, 0x31, 0xE5, 0xB9, 0x61, 0xF9, + 0x4F, 0x88, 0xB1, 0xEF, 0x23, 0xF4, 0xF1, 0x4D, + 0xBE, 0x17, 0xF5, 0xC0, 0x67, 0x80, 0xEC, 0x3F + }, + { + 0x15, 0xE0, 0x5E, 0x71, 0xD3, 0x4C, 0x3E, 0x16, + 0x3A, 0x4E, 0xDF, 0xC9, 0x97, 0xE8, 0xE9, 0x01, + 0x49, 0x14, 0x9D, 0x81, 0x03, 0xC2, 0x24, 0x05, + 0xE1, 0xBB, 0xC2, 0x89, 0xA7, 0xEA, 0x24, 0xA1 + }, + { + 0xF0, 0x48, 0xE0, 0x05, 0xDE, 0xFC, 0xC2, 0x2D, + 0x93, 0xA4, 0xAA, 0xAF, 0x95, 0xEE, 0x13, 0x00, + 0x95, 0xA4, 0x7C, 0xE1, 0x08, 0xF8, 0xCE, 0x1E, + 0x84, 0xDE, 0x0F, 0xC1, 0x97, 0x41, 0x6E, 0x47 + }, + { + 0x06, 0x6C, 0xE8, 0x2A, 0x95, 0x22, 0xB3, 0xB7, + 0x21, 0xBB, 0x3A, 0xB8, 0xDD, 0x06, 0xCA, 0x43, + 0xA8, 0xA9, 0x97, 0x60, 0xE9, 0x63, 0xD2, 0xED, + 0xA0, 0xFF, 0x81, 0xA0, 0xBF, 0xAD, 0x5C, 0xF1 + }, + { + 0x14, 0x57, 0xE4, 0x7E, 0x89, 0x48, 0xD0, 0xCC, + 0x77, 0x22, 0x15, 0x00, 0x93, 0x9E, 0xB2, 0x08, + 0x86, 0x61, 0x2A, 0xCE, 0x66, 0x37, 0x89, 0xF8, + 0x95, 0x0B, 0xB5, 0x0C, 0xF4, 0x39, 0x7B, 0x2E + }, + { + 0x66, 0x42, 0x61, 0x4C, 0x6F, 0x63, 0x5F, 0xCB, + 0x89, 0x7C, 0x30, 0xF8, 0x2B, 0xD5, 0x74, 0x4A, + 0x9D, 0x81, 0xDD, 0x93, 0xF2, 0x36, 0x3E, 0x58, + 0x7F, 0x82, 0x9C, 0x86, 0x9C, 0x25, 0x11, 0xCF + }, + { + 0x32, 0x3E, 0xDD, 0xC8, 0x2E, 0xF4, 0x11, 0x5E, + 0x0D, 0x4E, 0xC8, 0x72, 0x67, 0xD5, 0xB5, 0x09, + 0x3B, 0x02, 0x11, 0x6B, 0xAC, 0xDC, 0x2A, 0x13, + 0xE4, 0x69, 0x93, 0xD8, 0x3F, 0x81, 0xF0, 0xAF + }, + { + 0x72, 0xFD, 0x43, 0xCA, 0xBD, 0xCD, 0xD9, 0x1A, + 0x23, 0x63, 0x26, 0xBC, 0x0A, 0x5C, 0x00, 0x33, + 0x2F, 0x67, 0x4D, 0xEB, 0xEA, 0xD9, 0x71, 0x0E, + 0x41, 0xAF, 0xE7, 0xDE, 0xDA, 0x55, 0x39, 0xCA + }, + { + 0x33, 0x76, 0x13, 0x99, 0x5E, 0x62, 0xDF, 0x6A, + 0x4E, 0x99, 0x82, 0xB6, 0xB3, 0xA5, 0x22, 0xDC, + 0xD5, 0x72, 0xEC, 0xAB, 0x32, 0x9A, 0x5C, 0xD7, + 0x83, 0xAF, 0xEF, 0x9F, 0xE2, 0xA5, 0x35, 0x62 + }, + { + 0x8A, 0xD0, 0xAA, 0x7B, 0x1A, 0x03, 0xB3, 0x3E, + 0x17, 0xBB, 0x48, 0xDC, 0xC9, 0x19, 0x68, 0xB2, + 0x1B, 0xF3, 0x3B, 0x3C, 0x2A, 0xFC, 0x32, 0xA9, + 0xE9, 0xA1, 0x8B, 0x94, 0xB1, 0x2A, 0xAC, 0x59 + }, + { + 0xB5, 0x4D, 0xD9, 0xC9, 0x89, 0x37, 0xFA, 0x72, + 0xCE, 0xDB, 0x45, 0xDB, 0x56, 0xEA, 0xA5, 0x20, + 0x06, 0x9F, 0xD1, 0xC6, 0xD0, 0xB3, 0x30, 0x07, + 0x7A, 0x46, 0x44, 0x86, 0x8B, 0x1C, 0x56, 0xE4 + }, + { + 0xEA, 0x28, 0x56, 0x2F, 0xA0, 0xFA, 0x3D, 0xFB, + 0xE3, 0x17, 0x6A, 0x6E, 0xFD, 0x97, 0xE7, 0x4B, + 0xE8, 0xAC, 0x2E, 0x59, 0x7F, 0x01, 0x18, 0x60, + 0x4F, 0x6D, 0xBB, 0x21, 0x64, 0x40, 0xDB, 0x33 + }, + { + 0x2A, 0x06, 0x9F, 0x83, 0x11, 0xF0, 0x0C, 0x05, + 0x1F, 0xEC, 0x11, 0xF6, 0xB3, 0x21, 0x30, 0x15, + 0xDA, 0x76, 0xEE, 0x73, 0x1E, 0x40, 0x57, 0x30, + 0x53, 0x25, 0x2B, 0x67, 0xE8, 0x17, 0xD4, 0x32 + }, + { + 0xD2, 0x0F, 0x7B, 0xB2, 0xB4, 0x3A, 0x81, 0x36, + 0xEB, 0x55, 0xB2, 0x62, 0x30, 0xD3, 0xB2, 0xB7, + 0x58, 0x46, 0xF9, 0xA1, 0xB6, 0x22, 0x36, 0x0A, + 0xBD, 0x6A, 0x11, 0xF4, 0x58, 0x2B, 0xB9, 0xF4 + }, + { + 0x36, 0xBF, 0x51, 0x45, 0x80, 0x93, 0x66, 0xB8, + 0x08, 0x1A, 0x6D, 0xAF, 0x5C, 0x68, 0xB3, 0x99, + 0xE2, 0x79, 0x74, 0xA8, 0x0D, 0x70, 0xC5, 0x51, + 0x88, 0xA1, 0xB0, 0x3C, 0x57, 0x3F, 0xE2, 0xB7 + }, + { + 0xD4, 0x91, 0x43, 0xDF, 0x0F, 0x63, 0x87, 0x0F, + 0xED, 0x8A, 0xC3, 0xEA, 0x69, 0x35, 0x69, 0x61, + 0xEA, 0xE1, 0x67, 0xA1, 0x47, 0x59, 0x29, 0x70, + 0x66, 0x61, 0xAD, 0xE5, 0x84, 0x76, 0xAA, 0x72 + }, + { + 0x56, 0x2D, 0xAA, 0x08, 0xF0, 0xFA, 0xC3, 0x7E, + 0xE2, 0x73, 0x45, 0x00, 0xBE, 0xB0, 0x89, 0x3E, + 0xFC, 0xD9, 0x52, 0x15, 0x46, 0xDC, 0x8C, 0x6E, + 0xA1, 0x1B, 0x2B, 0x68, 0x0C, 0x5D, 0x43, 0xAB + }, + { + 0x36, 0x7F, 0x5F, 0xDA, 0x58, 0x8B, 0xD0, 0x77, + 0x93, 0xFA, 0x76, 0x2A, 0x2D, 0x92, 0x7F, 0xB1, + 0x68, 0x46, 0x24, 0x99, 0xD3, 0xFD, 0xD2, 0x00, + 0x30, 0x08, 0x23, 0x12, 0xB8, 0x85, 0xCF, 0x51 + }, + { + 0x6E, 0x04, 0x77, 0xC0, 0x50, 0x56, 0x86, 0x6B, + 0xEC, 0xE3, 0xAE, 0x87, 0x8F, 0x6D, 0x04, 0x8E, + 0xBF, 0x30, 0xF8, 0xB5, 0x28, 0x68, 0x6C, 0xBC, + 0x20, 0x88, 0xFA, 0x7A, 0xB5, 0x68, 0x88, 0xF2 + }, + { + 0xC7, 0x7A, 0x81, 0xD2, 0xAF, 0xE1, 0x5D, 0x4C, + 0x6F, 0xC5, 0x8D, 0xA3, 0xDC, 0x65, 0x70, 0x6A, + 0x7F, 0x0B, 0x11, 0xC0, 0x87, 0x98, 0x76, 0xE1, + 0x54, 0x66, 0xCB, 0x9E, 0x80, 0x66, 0xBE, 0xFE + }, + { + 0x58, 0x0E, 0x26, 0xA5, 0x2C, 0x72, 0xAB, 0xD8, + 0x0C, 0x6A, 0x50, 0xD4, 0xBE, 0x8B, 0x07, 0x3E, + 0x08, 0x7D, 0xF3, 0x2C, 0x9F, 0x7A, 0xA9, 0xAB, + 0xD0, 0x99, 0xA9, 0xD4, 0xB4, 0xE9, 0x71, 0x1C + }, + { + 0xF3, 0xDC, 0xA5, 0x15, 0x6A, 0x4C, 0xB4, 0xCB, + 0x3E, 0xB1, 0xF6, 0xE7, 0x61, 0x17, 0x2F, 0x7E, + 0x42, 0xDF, 0x59, 0x76, 0xFA, 0xBE, 0x14, 0x04, + 0x8A, 0xAA, 0xBB, 0x84, 0x68, 0x99, 0x06, 0x25 + }, + { + 0x60, 0xF7, 0x0C, 0x80, 0x0E, 0xD6, 0xB4, 0x10, + 0xB3, 0x1C, 0x5C, 0x63, 0x83, 0xDC, 0x1A, 0x70, + 0x1C, 0xA6, 0x89, 0xD9, 0x7D, 0x95, 0xF6, 0x35, + 0x27, 0x9A, 0xE4, 0x5A, 0x56, 0x66, 0x0A, 0x93 + }, + { + 0x97, 0x64, 0x8E, 0xB9, 0xD6, 0x5D, 0x68, 0x95, + 0x62, 0xB7, 0x44, 0x39, 0x34, 0xAD, 0xF8, 0x82, + 0x17, 0xCA, 0xA6, 0x01, 0xF3, 0x94, 0xA4, 0xC6, + 0xC1, 0xCA, 0x8F, 0x74, 0x5D, 0xA3, 0x1C, 0x17 + }, + { + 0x7A, 0x76, 0x38, 0xDF, 0xC5, 0x96, 0xB8, 0xD0, + 0xB6, 0x29, 0x6A, 0x6E, 0xA9, 0x2C, 0x01, 0x3B, + 0xBC, 0x2E, 0xBD, 0x70, 0x85, 0xDE, 0x90, 0x10, + 0x45, 0xA9, 0xC3, 0x55, 0x75, 0xD1, 0x23, 0x8F + }, + { + 0x78, 0x2B, 0x9D, 0xE0, 0xAA, 0x46, 0xFD, 0xAF, + 0x52, 0x71, 0x09, 0xEE, 0x72, 0x4F, 0xCB, 0xDB, + 0x77, 0xE6, 0xC3, 0xF1, 0x0D, 0x78, 0xAA, 0xE2, + 0x20, 0xCC, 0xB8, 0x93, 0xB8, 0x01, 0xC3, 0x1A + }, + { + 0xB5, 0x56, 0xE7, 0x11, 0xB7, 0x4C, 0xC9, 0xCA, + 0xCC, 0x96, 0x7D, 0xBE, 0x3E, 0xD7, 0x0D, 0x29, + 0x1A, 0x0F, 0x7C, 0x34, 0xA2, 0xE2, 0x0F, 0x34, + 0x1D, 0xFD, 0x12, 0xCB, 0xF2, 0x00, 0x9F, 0x8D + }, + { + 0x89, 0x7F, 0xBD, 0x86, 0x5D, 0x3A, 0x90, 0x0A, + 0x44, 0xF8, 0xE3, 0xD0, 0xCD, 0x77, 0x36, 0x06, + 0x89, 0xCD, 0xF2, 0x10, 0xE8, 0x6A, 0x08, 0x6C, + 0xC5, 0xEF, 0xBC, 0xDF, 0x4C, 0xC5, 0x27, 0xA2 + }, + { + 0x94, 0x12, 0x3A, 0x86, 0x6A, 0x7C, 0x55, 0x8C, + 0xD3, 0x03, 0xEB, 0xBE, 0xD9, 0x8F, 0xCC, 0x16, + 0xF8, 0x2F, 0x5D, 0x4B, 0x3B, 0x5D, 0xC5, 0x4C, + 0xAE, 0x92, 0x08, 0x62, 0x5B, 0xB0, 0x56, 0x81 + }, + { + 0x43, 0x24, 0xAA, 0x65, 0x53, 0x10, 0xAC, 0x9A, + 0x5A, 0xA8, 0x41, 0x13, 0x07, 0x9A, 0x08, 0x3E, + 0xFF, 0x29, 0x51, 0x38, 0x89, 0x3D, 0x61, 0x31, + 0xFB, 0x9A, 0xE4, 0x25, 0x75, 0x48, 0x17, 0x77 + }, + { + 0x91, 0xE7, 0x99, 0x32, 0x58, 0xE5, 0xC7, 0xEA, + 0x24, 0x23, 0x59, 0x34, 0x89, 0x10, 0x48, 0x46, + 0x51, 0x43, 0x34, 0x0E, 0x6E, 0x81, 0x29, 0x7C, + 0x6A, 0xC2, 0x8E, 0x80, 0xB6, 0x64, 0xFD, 0xDF + }, + { + 0xAF, 0x83, 0x53, 0x88, 0xA6, 0xF6, 0xD9, 0x9D, + 0xF1, 0xD7, 0xB5, 0xF9, 0x37, 0x9B, 0x64, 0x82, + 0x46, 0x79, 0xE3, 0x80, 0xC0, 0x68, 0xDE, 0x06, + 0x10, 0x98, 0x0E, 0xCB, 0xBA, 0xB0, 0x20, 0x0F + }, + { + 0x1D, 0x43, 0x10, 0xAF, 0x73, 0xDD, 0x4A, 0x2A, + 0xB7, 0xE1, 0x02, 0x78, 0x2E, 0xE2, 0x16, 0x47, + 0x2C, 0x8B, 0x75, 0x1B, 0x2D, 0xC4, 0xE6, 0x3E, + 0x65, 0x95, 0x92, 0xEE, 0xBA, 0x4B, 0xAA, 0x17 + }, + { + 0x06, 0x72, 0xD5, 0x05, 0x01, 0x2B, 0xFC, 0x78, + 0x05, 0x26, 0x87, 0x3C, 0xDA, 0x10, 0xAA, 0x7C, + 0x44, 0x00, 0x3C, 0x7F, 0x1B, 0x1A, 0xF8, 0x19, + 0x5F, 0x05, 0x72, 0x9A, 0x21, 0xC4, 0x0E, 0x70 + }, + { + 0x46, 0x0F, 0xDD, 0x2D, 0x81, 0x90, 0x71, 0x18, + 0x17, 0xC8, 0x36, 0x89, 0x1D, 0xB7, 0x57, 0x56, + 0xC6, 0x94, 0xDF, 0x0B, 0xC1, 0x9A, 0x9B, 0xDB, + 0xBF, 0x2E, 0xA1, 0x71, 0x9C, 0x38, 0x5C, 0x23 + }, + { + 0x70, 0xD3, 0xDF, 0x81, 0x48, 0xB6, 0xB9, 0x99, + 0x13, 0x9F, 0xAE, 0x17, 0xCC, 0xBC, 0x27, 0xFF, + 0x8F, 0x45, 0x34, 0x5F, 0x33, 0x24, 0x8A, 0xAE, + 0x5D, 0xA9, 0xEB, 0x90, 0xFE, 0xEE, 0xFE, 0x6C + }, + { + 0xE0, 0x39, 0x77, 0xDB, 0x45, 0x4B, 0x4E, 0x16, + 0xA0, 0x45, 0x78, 0x9F, 0xCA, 0x19, 0x37, 0xB9, + 0x2C, 0xB2, 0xC8, 0xA2, 0x2B, 0x03, 0xC1, 0x38, + 0x3E, 0x3C, 0xBB, 0xC4, 0x4C, 0x2D, 0x42, 0x86 + }, + { + 0x12, 0xF1, 0xD3, 0xB3, 0xEA, 0x0D, 0x9C, 0xDB, + 0xA5, 0xC5, 0xE6, 0xB7, 0xC3, 0x8A, 0xC2, 0xF1, + 0xDD, 0x61, 0x2F, 0x9E, 0x4C, 0x8E, 0x89, 0x0E, + 0xBD, 0xFB, 0x17, 0x5C, 0x6C, 0x4D, 0xF8, 0xE8 + }, + { + 0x3F, 0xE6, 0x87, 0xE3, 0x29, 0xED, 0xA6, 0xCE, + 0xE0, 0x71, 0x47, 0x84, 0xB8, 0x83, 0xB6, 0x2E, + 0x05, 0x95, 0xE5, 0x56, 0x5E, 0xAD, 0x32, 0xC5, + 0xD1, 0x09, 0xE0, 0x92, 0x8F, 0x5E, 0xBB, 0xBA + }, + { + 0x8B, 0x10, 0x72, 0x0D, 0x45, 0x93, 0xDE, 0x9F, + 0x74, 0x2C, 0x3F, 0xDE, 0x80, 0xC7, 0x02, 0x21, + 0x17, 0x39, 0xF8, 0xF1, 0xBF, 0xC9, 0x97, 0x3B, + 0xAA, 0x33, 0x10, 0xF9, 0x86, 0xD6, 0x7E, 0x2D + }, + { + 0xED, 0xDA, 0x69, 0xA7, 0xD5, 0x97, 0xB4, 0x74, + 0x47, 0x51, 0x0C, 0x73, 0x9B, 0x81, 0x69, 0x64, + 0xEB, 0x71, 0xE1, 0xA9, 0x4B, 0xC3, 0x2F, 0x3D, + 0x2B, 0x0C, 0xDC, 0x84, 0xAD, 0xDA, 0xE4, 0xA7 + }, + { + 0x13, 0x89, 0x7C, 0xEE, 0xAE, 0xCB, 0xD6, 0x09, + 0x45, 0x26, 0xF1, 0x6A, 0x83, 0x24, 0xCB, 0x22, + 0x73, 0x79, 0xEE, 0xBE, 0x80, 0x7E, 0x5A, 0xFF, + 0xBD, 0x6E, 0xD1, 0x0B, 0xB2, 0x82, 0x36, 0xEB + }, + { + 0xFB, 0x8F, 0xDA, 0x6B, 0x17, 0x4D, 0x2F, 0xCF, + 0x83, 0x2D, 0x62, 0x53, 0x08, 0xD6, 0x70, 0x4A, + 0xF5, 0xE6, 0x76, 0x92, 0x24, 0xC6, 0x0F, 0x96, + 0x37, 0x12, 0x3B, 0xF9, 0x8F, 0xDA, 0x4B, 0xF2 + }, + { + 0xAF, 0xED, 0x7D, 0xD0, 0xF9, 0x6F, 0x2D, 0xFE, + 0x21, 0x48, 0xAC, 0x31, 0xBF, 0x81, 0x4E, 0x04, + 0x26, 0x48, 0xC4, 0xF0, 0xA0, 0x04, 0x3A, 0x5C, + 0x34, 0xED, 0x22, 0x89, 0xC4, 0x07, 0x46, 0xC9 + }, + { + 0x69, 0xE1, 0xA2, 0xD1, 0x86, 0x82, 0x43, 0xCF, + 0x2A, 0xC6, 0x29, 0xD7, 0x82, 0x63, 0x9D, 0xF2, + 0xAC, 0xF8, 0xAD, 0xC3, 0xED, 0x97, 0xFD, 0x94, + 0xBB, 0xBA, 0x53, 0x56, 0xBA, 0x8F, 0x1E, 0x0B + }, + { + 0xE1, 0xB8, 0x21, 0x2B, 0xBA, 0xB2, 0xBA, 0x56, + 0xF6, 0x65, 0x5A, 0x24, 0x10, 0x0D, 0xAF, 0xFB, + 0xA3, 0xBB, 0x5C, 0x57, 0x39, 0xF6, 0x1B, 0xAF, + 0xAE, 0xDC, 0x78, 0xC8, 0x30, 0x1F, 0x30, 0x9E + }, + { + 0x55, 0x7C, 0xCC, 0x48, 0x9B, 0xB0, 0x98, 0x21, + 0x3F, 0xB8, 0x92, 0xA8, 0x86, 0x64, 0x83, 0x75, + 0x8B, 0x3F, 0xC6, 0xC0, 0x73, 0xA3, 0xDE, 0x95, + 0x69, 0x3E, 0xA4, 0xA3, 0x3B, 0x2C, 0x1A, 0xF0 + }, + { + 0x40, 0xEF, 0x92, 0xDC, 0xD4, 0xDE, 0x6E, 0x94, + 0x94, 0x45, 0xCC, 0x3A, 0x9F, 0x17, 0x81, 0x99, + 0xFA, 0x3E, 0xA1, 0x5B, 0x77, 0xE1, 0x52, 0xBB, + 0x3C, 0x01, 0x4B, 0x09, 0xAE, 0xAB, 0xF2, 0x1E + }, + { + 0x57, 0x54, 0xFE, 0xAE, 0x2A, 0x6E, 0xEF, 0xFF, + 0xAE, 0x7D, 0x7C, 0x68, 0x9F, 0x24, 0x05, 0xD1, + 0xEC, 0x46, 0xC7, 0xE4, 0x8A, 0x9C, 0x61, 0x87, + 0xE7, 0x1C, 0x54, 0x21, 0xA7, 0x57, 0xB9, 0x5D + }, + { + 0x22, 0x5D, 0x8B, 0x57, 0xD0, 0xF5, 0x33, 0x0A, + 0x04, 0x35, 0x95, 0x74, 0x13, 0x70, 0xA9, 0x2E, + 0x76, 0xB9, 0x2E, 0x98, 0x2F, 0xB7, 0x03, 0x64, + 0xE5, 0xB1, 0xA2, 0xCD, 0x1D, 0xBF, 0x5D, 0xC2 + }, + { + 0xB1, 0xE4, 0xD4, 0x71, 0x90, 0x6F, 0x42, 0x86, + 0x97, 0xFA, 0xAA, 0xE3, 0xA9, 0x24, 0xB2, 0xA6, + 0x14, 0xA9, 0x9D, 0x8F, 0x00, 0xAD, 0xBF, 0x18, + 0x6C, 0xB9, 0x1C, 0x53, 0x9A, 0x83, 0xF4, 0x5E + }, + { + 0xD2, 0x04, 0xA0, 0x9D, 0x9F, 0x1F, 0x3F, 0x5C, + 0x4A, 0x9C, 0x2B, 0xAB, 0x09, 0x95, 0x20, 0x41, + 0xDA, 0x6B, 0xBB, 0xE6, 0xA3, 0x51, 0xDA, 0xF8, + 0x6A, 0x7F, 0xB2, 0x6F, 0x86, 0x1B, 0x0D, 0x60 + }, + { + 0xF1, 0x33, 0x6D, 0x57, 0xE3, 0xC6, 0x02, 0xC7, + 0x0A, 0x8F, 0xBF, 0xC3, 0xF2, 0x52, 0xDC, 0xA8, + 0xA1, 0xC9, 0x78, 0x18, 0xDF, 0xEF, 0xF9, 0xF8, + 0x20, 0x81, 0x5D, 0x1E, 0x4E, 0x94, 0x74, 0x4A + }, + { + 0x52, 0x0B, 0x4B, 0x10, 0xC8, 0x73, 0xB5, 0xA0, + 0xB1, 0x81, 0x81, 0x5C, 0x9A, 0x20, 0x34, 0x6C, + 0x14, 0xCE, 0x4B, 0x07, 0x67, 0x44, 0x1D, 0xED, + 0x6E, 0x49, 0xB0, 0x2B, 0x32, 0xD6, 0xD0, 0x8E + }, + { + 0x50, 0xAE, 0x54, 0x4B, 0x36, 0x0E, 0xA4, 0xBD, + 0xE8, 0x5E, 0xD6, 0x11, 0x5C, 0x82, 0x54, 0x36, + 0x8E, 0xF0, 0x61, 0x8B, 0x82, 0x1B, 0x16, 0x5F, + 0x11, 0x2B, 0xEB, 0xC8, 0xB6, 0x95, 0x98, 0x50 + }, + { + 0x6B, 0xDF, 0xC8, 0xA4, 0xDE, 0xF7, 0xEE, 0xEE, + 0xB2, 0x13, 0x44, 0xA5, 0xBE, 0x0F, 0x34, 0x27, + 0xDF, 0xDC, 0xA4, 0x3F, 0xE2, 0xBD, 0x56, 0xE2, + 0x97, 0x45, 0x45, 0x0B, 0xF7, 0x1C, 0xA4, 0xA0 + }, + { + 0xDA, 0x01, 0x93, 0x40, 0x54, 0x38, 0x4F, 0xAA, + 0x69, 0x1A, 0x1E, 0x45, 0xAA, 0x45, 0xBD, 0x28, + 0x72, 0x46, 0xDE, 0x15, 0xE5, 0xA3, 0x64, 0x71, + 0xAA, 0x58, 0xB9, 0x15, 0x53, 0xAE, 0x25, 0x4C + }, + { + 0xB4, 0x2B, 0xE8, 0x00, 0x94, 0xAD, 0x6D, 0xCB, + 0xAE, 0x2F, 0x43, 0x73, 0xD5, 0x05, 0xBB, 0xE5, + 0x79, 0x3D, 0xFE, 0x25, 0xF5, 0x95, 0x15, 0x80, + 0xED, 0xF8, 0x23, 0x78, 0xAE, 0xC3, 0x44, 0x69 + }, + { + 0x8F, 0xC7, 0xE3, 0x23, 0x69, 0xEE, 0xBC, 0x9F, + 0xB8, 0xD3, 0x3C, 0xC7, 0xAC, 0x20, 0xD7, 0x67, + 0xED, 0x40, 0xDC, 0xD7, 0x95, 0x21, 0x3F, 0xF2, + 0x27, 0x9F, 0x62, 0x81, 0x18, 0x1C, 0x8D, 0x45 + }, + { + 0x6C, 0x89, 0xDE, 0x63, 0x95, 0xA1, 0xE6, 0x35, + 0x7B, 0x23, 0xED, 0xB8, 0x83, 0x2A, 0x5E, 0xCC, + 0xB8, 0x44, 0x5A, 0xD3, 0xA0, 0x1A, 0xE8, 0x95, + 0x30, 0xC7, 0x73, 0xB9, 0x5E, 0xFE, 0x24, 0x22 + }, + { + 0x02, 0x5E, 0xDA, 0x9F, 0x05, 0x3B, 0x5D, 0x10, + 0xB5, 0x3E, 0xFA, 0x07, 0xFB, 0x04, 0x7B, 0xD5, + 0x3A, 0xA3, 0xFF, 0x6E, 0x75, 0x74, 0x0A, 0xF2, + 0xCB, 0x4B, 0x70, 0x45, 0xCC, 0x18, 0x17, 0xDB + }, + { + 0xFE, 0xFF, 0x71, 0x23, 0xDC, 0x85, 0xC3, 0x75, + 0x01, 0x69, 0xDA, 0xC6, 0xE2, 0x81, 0xAE, 0x2F, + 0x1F, 0x36, 0x16, 0x9C, 0x66, 0xE4, 0xF9, 0x38, + 0xE5, 0x70, 0x39, 0x2A, 0x6B, 0x09, 0xF5, 0x34 + }, + { + 0x92, 0x59, 0x60, 0xEF, 0xC5, 0xE5, 0x27, 0x0F, + 0x4C, 0x6E, 0x06, 0xE7, 0x9C, 0x6C, 0x5E, 0x36, + 0x90, 0x0F, 0x22, 0xA5, 0x50, 0x82, 0x74, 0x39, + 0x9B, 0x7B, 0x47, 0x48, 0x7B, 0xE7, 0xC9, 0x8F + }, + { + 0x88, 0x3E, 0xFC, 0xAB, 0x35, 0xF1, 0x03, 0xBA, + 0xD0, 0x59, 0xF3, 0x55, 0xCA, 0x44, 0x6E, 0x1C, + 0x3D, 0xE8, 0x66, 0xE7, 0x89, 0x06, 0x34, 0xD2, + 0x38, 0x37, 0x8D, 0x86, 0x45, 0xE8, 0xEC, 0x9D + }, + { + 0x49, 0x26, 0x86, 0xFA, 0x49, 0x42, 0xF3, 0x8A, + 0x4A, 0xD4, 0xC7, 0x74, 0x84, 0x1F, 0x36, 0x3D, + 0x26, 0xDB, 0x50, 0xC8, 0x2F, 0x8A, 0x70, 0x6A, + 0x96, 0x44, 0x50, 0x8B, 0xF7, 0xD6, 0x4E, 0x7E + }, + { + 0xB3, 0x4B, 0x38, 0x5C, 0xB6, 0xFA, 0x46, 0xC8, + 0x46, 0x2A, 0x03, 0x8C, 0x65, 0x69, 0x24, 0xFA, + 0x86, 0x62, 0x76, 0x41, 0x57, 0x94, 0xC3, 0xD4, + 0x13, 0x07, 0x28, 0xE9, 0xA8, 0xFE, 0x40, 0xB1 + }, + { + 0x58, 0xFB, 0xA8, 0x9F, 0x77, 0xCC, 0x03, 0x4B, + 0x95, 0x68, 0xB3, 0xCA, 0x48, 0xA4, 0xD9, 0xFA, + 0x2A, 0x8E, 0x70, 0x9B, 0xC2, 0xF5, 0x34, 0x64, + 0x29, 0x30, 0xC9, 0xAC, 0xF0, 0xF1, 0x62, 0xBE + }, + { + 0x22, 0xD4, 0xE2, 0x01, 0x66, 0x5D, 0xDF, 0xB1, + 0xFB, 0xD6, 0xF1, 0xC4, 0xDC, 0x61, 0xF8, 0x8D, + 0x2E, 0xCC, 0xE8, 0x9A, 0xDC, 0x56, 0x66, 0x93, + 0x6B, 0xA6, 0xAF, 0x3D, 0xA4, 0x13, 0x2B, 0xAF + }, + { + 0x67, 0x59, 0x94, 0x97, 0x0C, 0x9B, 0x0A, 0x0C, + 0x9E, 0x1B, 0xC0, 0xCD, 0x28, 0x82, 0xB5, 0xC1, + 0x6A, 0xFD, 0xCF, 0x06, 0xE8, 0x18, 0x8E, 0xEC, + 0x94, 0xC2, 0x41, 0xC6, 0x1D, 0x14, 0x7C, 0xDD + }, + { + 0xCC, 0x39, 0xEA, 0x75, 0xA4, 0x92, 0xFA, 0x0F, + 0x60, 0x60, 0x3F, 0x3E, 0x3B, 0x6E, 0xC0, 0xB7, + 0x51, 0x29, 0x29, 0x63, 0x4E, 0xFC, 0x57, 0xCC, + 0xD9, 0xB4, 0x8F, 0xEE, 0xEB, 0xA8, 0x4F, 0xA2 + }, + { + 0x44, 0xF0, 0x4D, 0xB7, 0x68, 0xEF, 0x63, 0x36, + 0xDA, 0xB1, 0x37, 0x01, 0x03, 0xED, 0x86, 0xB9, + 0x56, 0x5F, 0xA9, 0x19, 0xA7, 0x68, 0x92, 0x18, + 0xC2, 0x92, 0xDE, 0x63, 0x0D, 0xBF, 0xD4, 0xC9 + }, + { + 0x33, 0x64, 0xFF, 0x26, 0x88, 0x26, 0x2A, 0xDD, + 0xEC, 0x94, 0x5D, 0xC7, 0x0D, 0x1F, 0xCC, 0xE9, + 0x88, 0xAF, 0x78, 0xBD, 0x94, 0x22, 0xD2, 0xD8, + 0xEB, 0xCA, 0xCB, 0x9C, 0xC6, 0x20, 0xD2, 0xB4 + }, + { + 0x9A, 0xD2, 0x28, 0xE0, 0xF3, 0x8A, 0xE8, 0xE2, + 0xF5, 0xAB, 0x6B, 0x1C, 0x66, 0x8D, 0x6C, 0xD8, + 0x63, 0xE3, 0xE2, 0x72, 0x44, 0xE6, 0xD5, 0x2D, + 0x4F, 0x14, 0xE3, 0x03, 0x8A, 0xEC, 0xF4, 0x26 + }, + { + 0xCE, 0xA6, 0xA5, 0x52, 0xED, 0xE6, 0x77, 0xF7, + 0x44, 0xEC, 0x15, 0xA6, 0xBC, 0x25, 0x31, 0xD5, + 0x5D, 0x4A, 0xD3, 0x61, 0x61, 0x99, 0x70, 0x0B, + 0x20, 0x6C, 0x72, 0x90, 0x94, 0x7A, 0xA6, 0xE2 + }, + { + 0x2A, 0xCA, 0x46, 0x1C, 0x5B, 0x59, 0x9E, 0xDC, + 0x00, 0xB8, 0x42, 0xD3, 0x54, 0xF1, 0x00, 0x9C, + 0x42, 0xF8, 0x3C, 0x8F, 0x93, 0xC4, 0x2A, 0xEE, + 0x64, 0x05, 0x0A, 0x5B, 0xBE, 0x23, 0x74, 0x4D + }, + { + 0xAA, 0x79, 0x2D, 0xE7, 0x19, 0x97, 0xB6, 0xB6, + 0x62, 0xCC, 0x08, 0x7C, 0x13, 0x63, 0x08, 0x22, + 0xCA, 0x41, 0x6A, 0x96, 0x98, 0x50, 0x75, 0x7C, + 0x23, 0x87, 0x86, 0xAB, 0x7F, 0xBC, 0x7E, 0x82 + }, + { + 0x7F, 0xF7, 0xB4, 0x81, 0x59, 0x96, 0x44, 0x7B, + 0x3E, 0x24, 0x04, 0x15, 0xFE, 0xC4, 0x32, 0x5E, + 0x07, 0x7F, 0x6B, 0xBC, 0x98, 0x9C, 0xEB, 0x24, + 0x89, 0x26, 0x87, 0x27, 0xB6, 0x16, 0xE2, 0x23 + }, + { + 0x95, 0xB0, 0x71, 0x4D, 0x85, 0xA1, 0xC9, 0x2F, + 0xA8, 0x22, 0x0D, 0xA3, 0xBF, 0x23, 0xC6, 0x23, + 0xB5, 0x62, 0xC7, 0x29, 0xE4, 0xE2, 0x6C, 0xA0, + 0xD1, 0xC1, 0x26, 0x07, 0x7C, 0x1C, 0x0A, 0x76 + }, + { + 0xC0, 0xA4, 0xE2, 0xB4, 0x70, 0x6D, 0x94, 0x1F, + 0xA4, 0x63, 0x44, 0x2A, 0x5D, 0x34, 0x22, 0x6E, + 0xA4, 0x60, 0x44, 0x3E, 0x9B, 0x32, 0xC8, 0xD0, + 0xA6, 0x2E, 0x33, 0x05, 0xBE, 0x97, 0x88, 0xAF + }, + { + 0x7F, 0xEB, 0x46, 0xC2, 0xDB, 0x08, 0xF7, 0x62, + 0x88, 0x29, 0xCC, 0x81, 0x2A, 0x58, 0x48, 0xC8, + 0xBB, 0xEA, 0x06, 0x08, 0x3A, 0x8C, 0x79, 0x89, + 0xA6, 0x66, 0x89, 0x12, 0xA9, 0x77, 0xD4, 0x04 + }, + { + 0x5D, 0x5A, 0x10, 0x14, 0x85, 0x4C, 0x52, 0x25, + 0xED, 0x19, 0xBB, 0x61, 0x3F, 0xAE, 0x2A, 0x6E, + 0xFE, 0x59, 0x34, 0xC6, 0xE6, 0x40, 0xC7, 0xD2, + 0xBF, 0xDB, 0x25, 0x2F, 0x1E, 0x8A, 0x55, 0xFB + }, + { + 0xF9, 0x18, 0x41, 0x96, 0x9C, 0x3C, 0xBC, 0x3C, + 0x92, 0x56, 0x5D, 0x46, 0x10, 0x9B, 0xD5, 0xCF, + 0xF8, 0x1B, 0x5A, 0xF5, 0x48, 0x30, 0xA4, 0x40, + 0x19, 0xF7, 0x48, 0xE3, 0x3B, 0x20, 0x5F, 0xD9 + }, + { + 0x94, 0xAC, 0x89, 0x1E, 0x76, 0x75, 0x14, 0x83, + 0xAD, 0x65, 0x68, 0xBE, 0xBB, 0xE1, 0xC1, 0xEC, + 0x90, 0x5F, 0xD7, 0x9C, 0xC5, 0xB7, 0x44, 0xEC, + 0xEE, 0x0B, 0xAA, 0x35, 0xC1, 0x6D, 0xA7, 0x0B + }, + { + 0x08, 0x48, 0x4E, 0xB9, 0x26, 0xD8, 0x55, 0x7C, + 0x32, 0x1A, 0x12, 0xE0, 0x62, 0xFB, 0x74, 0xC2, + 0x1F, 0xEE, 0x13, 0x0D, 0xE6, 0xD1, 0x30, 0x67, + 0x2C, 0xAA, 0xD1, 0xE2, 0x4C, 0x6E, 0x13, 0x69 + }, + { + 0x72, 0xA8, 0x1A, 0x1C, 0x21, 0xF2, 0x07, 0xCC, + 0x69, 0x4F, 0x5D, 0x24, 0x0F, 0x74, 0xEC, 0xF9, + 0x16, 0xF1, 0xCE, 0x05, 0xD4, 0x7D, 0x60, 0x32, + 0x63, 0xFA, 0xAB, 0x53, 0xEC, 0x61, 0x7B, 0x1C + }, + { + 0x97, 0xEA, 0xDD, 0x0F, 0x01, 0x1D, 0x81, 0x44, + 0x54, 0x29, 0x27, 0x85, 0x2F, 0x43, 0xCB, 0x19, + 0x1C, 0xE2, 0x2B, 0xE1, 0x24, 0xD6, 0x1B, 0xAE, + 0xE8, 0x4C, 0xD7, 0x5C, 0x49, 0xBA, 0x6B, 0xCF + }, + { + 0x80, 0x76, 0x8B, 0xCC, 0x75, 0xB3, 0x0B, 0x4C, + 0xDE, 0x4D, 0x6D, 0xCF, 0xD2, 0xF3, 0xB1, 0xD1, + 0xBF, 0x23, 0xC9, 0xC1, 0xA9, 0xBC, 0xBD, 0x95, + 0x57, 0x75, 0xFE, 0xA9, 0x2C, 0xF4, 0x03, 0x38 + }, + { + 0x8D, 0x24, 0x1C, 0x40, 0x87, 0x01, 0xEF, 0x05, + 0x0E, 0xC8, 0x8F, 0x82, 0xD4, 0x5E, 0x18, 0x25, + 0xAE, 0x41, 0x37, 0x9E, 0x09, 0x4D, 0xF9, 0x67, + 0x00, 0xED, 0xE5, 0x7D, 0xE7, 0xA8, 0x07, 0xF1 + }, + { + 0x5E, 0x12, 0xCF, 0x9A, 0x18, 0x25, 0x96, 0xC7, + 0x97, 0x65, 0x19, 0xC4, 0x31, 0x53, 0xD3, 0xBB, + 0xBC, 0xDA, 0x96, 0x2A, 0xA6, 0x7A, 0x54, 0x04, + 0xBF, 0xE7, 0x2C, 0xA3, 0x93, 0xA7, 0x55, 0x8A + }, + { + 0x66, 0x83, 0xF8, 0xEF, 0x04, 0xC9, 0x1A, 0xC0, + 0x00, 0xE2, 0x27, 0xE9, 0x21, 0xC6, 0xD0, 0x00, + 0x5E, 0x56, 0xF6, 0x25, 0xBD, 0x5D, 0x99, 0xE6, + 0x3C, 0xFC, 0x67, 0x66, 0x92, 0xD0, 0x81, 0x14 + }, + { + 0xB3, 0x56, 0xEA, 0x2B, 0x58, 0xF5, 0x0C, 0xC9, + 0xBE, 0x9F, 0x77, 0x15, 0x5F, 0x75, 0xAF, 0xB1, + 0xC8, 0xEA, 0xD2, 0x37, 0xA7, 0xB8, 0x37, 0x1A, + 0x7F, 0x14, 0x0B, 0xBC, 0x7A, 0x56, 0xB5, 0x40 + }, + { + 0xC9, 0xF5, 0x10, 0x6D, 0x4A, 0x41, 0x53, 0x90, + 0x60, 0x47, 0xAC, 0xE2, 0x35, 0xCD, 0x99, 0xD3, + 0xBE, 0xE0, 0x1B, 0xB0, 0xF7, 0xB4, 0xB6, 0x2A, + 0xB4, 0x54, 0x39, 0xDB, 0x01, 0xB8, 0x38, 0x20 + }, + { + 0x15, 0x12, 0xD6, 0x5F, 0xB2, 0xA9, 0xAC, 0x69, + 0x30, 0x3F, 0xDE, 0x08, 0x92, 0x4E, 0x07, 0xC7, + 0x59, 0x10, 0x15, 0x68, 0x9E, 0xE0, 0x3D, 0x71, + 0x1E, 0x79, 0x93, 0xE7, 0xDD, 0x45, 0xC8, 0xFC + }, + { + 0xFD, 0x83, 0xDF, 0x5E, 0xF2, 0x0A, 0x90, 0x33, + 0x1F, 0x7C, 0xD6, 0xA5, 0x86, 0xD0, 0xA4, 0x27, + 0x44, 0xBF, 0x57, 0xC9, 0x3D, 0x6E, 0xED, 0x3A, + 0x95, 0x9A, 0x9E, 0x9F, 0x40, 0xBA, 0x68, 0xB4 + }, + { + 0xA6, 0x8C, 0x9C, 0x3A, 0x7B, 0x49, 0x30, 0x3F, + 0x28, 0xF0, 0xF1, 0xA7, 0x32, 0x49, 0xB4, 0xC9, + 0xFA, 0x16, 0xF0, 0x61, 0x83, 0x8E, 0xA7, 0x82, + 0x2B, 0x93, 0x72, 0x02, 0x14, 0x4A, 0x54, 0x2C + }, + { + 0xED, 0xA6, 0x98, 0x6D, 0x18, 0x2A, 0xD5, 0x7B, + 0x9D, 0x6C, 0xDE, 0xC1, 0x76, 0x2A, 0x52, 0x65, + 0xD5, 0xDC, 0xB3, 0xCC, 0xF7, 0xFC, 0xDD, 0xD3, + 0x49, 0x14, 0x9C, 0xE4, 0xC2, 0xC0, 0xDE, 0xC9 + }, + { + 0xE3, 0x86, 0x11, 0x8C, 0x2C, 0x6D, 0xFB, 0x7B, + 0x39, 0x34, 0x33, 0xF5, 0x02, 0xB0, 0x76, 0xB9, + 0xAA, 0x12, 0xCB, 0xB6, 0x87, 0x02, 0x18, 0xB0, + 0x05, 0x2B, 0x13, 0xFA, 0x20, 0x27, 0x32, 0x9C + }, + { + 0x58, 0xE2, 0x52, 0x74, 0xD3, 0xD9, 0x73, 0xA4, + 0x9A, 0x5B, 0xC5, 0x50, 0x7E, 0x94, 0x99, 0x3E, + 0xB9, 0xF1, 0x88, 0xCC, 0x5E, 0xDA, 0x7C, 0xDD, + 0xB8, 0x71, 0x0D, 0x9D, 0x4D, 0xD3, 0x4E, 0x9D + }, + { + 0xD3, 0x12, 0xC6, 0x9A, 0xB4, 0x16, 0x64, 0x21, + 0x26, 0xD1, 0xD5, 0xFA, 0xC7, 0x86, 0xB9, 0x5B, + 0x31, 0xEA, 0x60, 0x12, 0x1D, 0x66, 0xA0, 0x60, + 0x44, 0xD3, 0xFE, 0x77, 0xAC, 0xD4, 0xA7, 0x30 + }, + { + 0xE1, 0x71, 0xC9, 0xB1, 0xCA, 0x39, 0x8C, 0x9B, + 0x7A, 0x84, 0x5C, 0x68, 0xE4, 0x9B, 0x5C, 0x60, + 0xCC, 0x36, 0x96, 0x64, 0x2B, 0xD8, 0x82, 0x12, + 0x64, 0x2D, 0x4B, 0xAD, 0x0E, 0xFA, 0x16, 0x1D + }, + { + 0x4B, 0xED, 0x1E, 0xA9, 0x7C, 0x25, 0x5D, 0xDE, + 0xCB, 0xDD, 0xBA, 0xB4, 0xAE, 0xCE, 0x94, 0xCA, + 0xA3, 0xBE, 0x02, 0xD8, 0x2D, 0xFC, 0x47, 0xBA, + 0x6B, 0xCD, 0x8E, 0x16, 0x6D, 0x65, 0x06, 0x6F + }, + { + 0xAA, 0xCB, 0x41, 0x63, 0x61, 0x94, 0xD3, 0x93, + 0x36, 0x22, 0x56, 0x1B, 0x95, 0x89, 0x16, 0x7B, + 0x33, 0x97, 0x02, 0x13, 0xEB, 0x6F, 0xAA, 0x2A, + 0x2B, 0xDF, 0xC4, 0xE5, 0x2F, 0x2D, 0xF8, 0x80 + }, + { + 0xC6, 0x18, 0xC4, 0x39, 0x55, 0x5C, 0x95, 0xDC, + 0xF0, 0xFC, 0x11, 0x26, 0x63, 0x18, 0xEE, 0xE0, + 0xDA, 0x8B, 0x8A, 0x86, 0x17, 0x56, 0xC6, 0x4E, + 0x86, 0xE2, 0xC6, 0x1F, 0xD5, 0xD1, 0x46, 0x42 + }, + { + 0x45, 0x32, 0xF9, 0x40, 0x60, 0xCE, 0xFB, 0xDE, + 0xB7, 0x72, 0xE3, 0x0A, 0xB6, 0x6C, 0x27, 0xB6, + 0xED, 0x1A, 0x18, 0x3B, 0x87, 0x7F, 0xD8, 0x91, + 0x63, 0xAB, 0x3F, 0x37, 0x4A, 0x01, 0x67, 0x78 + }, + { + 0x08, 0x03, 0x56, 0xEE, 0xA0, 0x87, 0x6C, 0x36, + 0xAB, 0xA9, 0x81, 0xAA, 0x14, 0x19, 0x3D, 0x3C, + 0x38, 0xEE, 0xF9, 0x4E, 0xD0, 0xD1, 0x73, 0xA3, + 0xD7, 0x4A, 0xD8, 0xBB, 0xCA, 0x6E, 0xC0, 0x23 + }, + { + 0x04, 0xB6, 0x13, 0xC4, 0x11, 0x90, 0xEC, 0x17, + 0x16, 0x46, 0xE7, 0x52, 0x3A, 0xC7, 0x8C, 0x37, + 0x71, 0x22, 0xDA, 0x34, 0x11, 0x56, 0xB0, 0x43, + 0x85, 0x5D, 0xAA, 0x37, 0x55, 0x47, 0xBD, 0x1F + }, + { + 0xB2, 0xCF, 0xF2, 0xC7, 0xF3, 0xDB, 0xF3, 0x90, + 0xEC, 0x14, 0xD4, 0x51, 0x51, 0x20, 0xDF, 0x96, + 0x85, 0xDF, 0xB3, 0x33, 0xEF, 0xA1, 0xC5, 0xFA, + 0xB4, 0x8C, 0x62, 0x44, 0x32, 0xEB, 0x6A, 0x8C + }, + { + 0x47, 0xF6, 0x40, 0xB0, 0x1C, 0x7D, 0x54, 0x0E, + 0xE7, 0x73, 0x4E, 0xB4, 0x92, 0xB2, 0x67, 0x79, + 0x35, 0x6F, 0xE8, 0x6F, 0xDC, 0x9D, 0x62, 0xFC, + 0xE0, 0xAB, 0xD5, 0xFF, 0x1F, 0x7B, 0x9B, 0x99 + }, + { + 0x0C, 0xF1, 0xA3, 0xDB, 0x21, 0x71, 0xC6, 0xAC, + 0xCD, 0x21, 0x7E, 0xF8, 0xEB, 0xC2, 0x33, 0x0C, + 0xF4, 0x7F, 0xA6, 0xD8, 0xC0, 0x6F, 0x05, 0x9C, + 0x6F, 0x59, 0xF1, 0x00, 0x29, 0x34, 0x94, 0x01 + }, + { + 0x43, 0x6B, 0x5D, 0x61, 0x78, 0xB1, 0x63, 0x8B, + 0x68, 0xAE, 0x8C, 0xFB, 0x73, 0x58, 0x69, 0x12, + 0x0C, 0xF7, 0x67, 0xC5, 0x83, 0xA7, 0xF0, 0x01, + 0x11, 0x64, 0x88, 0xCF, 0x40, 0x7A, 0x1A, 0x78 + }, + { + 0x8B, 0xB1, 0x5A, 0x43, 0x95, 0x3A, 0x24, 0x30, + 0x49, 0x29, 0xCA, 0xC7, 0xB9, 0x8A, 0xB4, 0xE6, + 0x83, 0x91, 0xBA, 0x70, 0x11, 0xC2, 0x65, 0x08, + 0x11, 0x41, 0x28, 0xC9, 0x2F, 0xC1, 0xF5, 0x3D + }, + { + 0x48, 0x38, 0xEF, 0x57, 0x7A, 0xD2, 0x94, 0xDB, + 0x9C, 0x80, 0x8F, 0x43, 0x51, 0x06, 0x25, 0x89, + 0x13, 0xF3, 0x21, 0xAB, 0xF9, 0x84, 0x8D, 0xC7, + 0xA1, 0xFF, 0x16, 0x78, 0xF0, 0xF5, 0x8E, 0x96 + }, + { + 0x91, 0x9A, 0x57, 0xA7, 0xE1, 0xA2, 0xCB, 0xF5, + 0x34, 0x2B, 0x77, 0x10, 0xF1, 0x98, 0x5F, 0xDC, + 0x8A, 0xE0, 0x18, 0x9C, 0x2F, 0x45, 0x2C, 0x0B, + 0x1A, 0x4D, 0x53, 0x2C, 0xAD, 0x68, 0xF8, 0x77 + }, + { + 0x96, 0xC9, 0xEE, 0x7C, 0xF2, 0x13, 0x5C, 0x9C, + 0xFD, 0x51, 0x35, 0xC1, 0x7E, 0xB7, 0x04, 0x5D, + 0xAB, 0xC1, 0x99, 0x52, 0xDD, 0x42, 0x8C, 0x7E, + 0xF9, 0x84, 0xF2, 0xEF, 0x86, 0xFA, 0x01, 0x73 + }, + { + 0x1B, 0x07, 0xC9, 0xB6, 0x12, 0xA2, 0xD3, 0xA1, + 0x14, 0x39, 0x5A, 0xBD, 0x62, 0x1B, 0x1F, 0x47, + 0xB9, 0xFB, 0x7B, 0x37, 0x9B, 0xB4, 0x54, 0xCB, + 0x08, 0x46, 0x0A, 0x30, 0x3C, 0xA6, 0x8D, 0xCA + }, + { + 0xA5, 0xFC, 0x3E, 0x76, 0x31, 0x74, 0xF7, 0xB8, + 0x70, 0x9B, 0x2A, 0xE2, 0x84, 0x08, 0x5C, 0xC6, + 0x02, 0xE0, 0xF6, 0x5E, 0x3B, 0x31, 0x1E, 0xBE, + 0xD1, 0x1E, 0xD2, 0x91, 0x96, 0xAD, 0x15, 0xA6 + }, + { + 0x0B, 0xAD, 0xD9, 0xC9, 0x52, 0x4F, 0x1D, 0x8A, + 0xA3, 0x65, 0x85, 0xE7, 0xF2, 0x40, 0xE8, 0xCE, + 0x78, 0x62, 0xB4, 0xC7, 0xA0, 0x1D, 0x0F, 0x60, + 0x96, 0x3D, 0x3B, 0x07, 0xE7, 0x2E, 0x94, 0x62 + }, + { + 0xDC, 0x09, 0x2D, 0x60, 0x3B, 0xFA, 0x79, 0x56, + 0x22, 0x51, 0x43, 0xF6, 0xE7, 0x1A, 0x2B, 0x22, + 0xA9, 0x73, 0xA9, 0xEE, 0xCF, 0x25, 0x36, 0xDE, + 0xA2, 0x08, 0x92, 0x76, 0x12, 0x1D, 0xDA, 0x3C + }, + { + 0x2C, 0xE2, 0xE1, 0x6F, 0xE4, 0x58, 0x22, 0x81, + 0x41, 0x6D, 0x41, 0x57, 0xF4, 0x0F, 0x4B, 0x01, + 0xF2, 0x50, 0x91, 0x01, 0xA6, 0xE3, 0x57, 0x67, + 0x1D, 0x75, 0xB8, 0xE3, 0xDB, 0x23, 0xA5, 0x96 + }, + { + 0x88, 0xB6, 0xAA, 0x02, 0x43, 0xD5, 0x34, 0xD1, + 0xD7, 0x65, 0x2A, 0x21, 0xB8, 0xF2, 0x5A, 0xD6, + 0xB8, 0x7E, 0xE8, 0x3B, 0xE7, 0x28, 0x0E, 0x9A, + 0x6A, 0x60, 0xF1, 0x76, 0x13, 0x7A, 0x11, 0x5B + }, + { + 0x6F, 0xDF, 0x30, 0x29, 0x4B, 0x80, 0x96, 0x82, + 0xB5, 0x37, 0x4D, 0xF7, 0xAD, 0x0A, 0x3D, 0xA7, + 0x28, 0x2D, 0x0D, 0x7C, 0x28, 0x30, 0x4A, 0x6E, + 0x9E, 0x9C, 0x95, 0x21, 0xCE, 0x16, 0xD7, 0xB5 + }, + { + 0xE1, 0x6F, 0x17, 0x34, 0xFC, 0x15, 0xDB, 0x06, + 0x44, 0x3B, 0x86, 0x46, 0x83, 0xB0, 0xF6, 0xE3, + 0xAA, 0xCF, 0xA0, 0xBD, 0xEE, 0x24, 0x77, 0xFB, + 0x95, 0x84, 0xAA, 0x3E, 0xD8, 0x9F, 0x3F, 0x37 + }, + { + 0x4E, 0x3F, 0xFF, 0xEB, 0x77, 0x72, 0xA0, 0x95, + 0x82, 0x90, 0x9B, 0x87, 0x6D, 0x84, 0x68, 0x87, + 0xB7, 0x8C, 0xAE, 0x38, 0xC6, 0x19, 0x75, 0x92, + 0x90, 0xB4, 0xA2, 0x37, 0xB5, 0xA9, 0x27, 0x2E + }, + { + 0x6B, 0xE1, 0xDF, 0xB4, 0xD1, 0x62, 0x67, 0xE7, + 0x38, 0x8F, 0xE5, 0xAA, 0x20, 0xFA, 0xDE, 0x95, + 0xE9, 0x15, 0xF0, 0x4F, 0xFA, 0x47, 0x7E, 0x85, + 0xBB, 0xE0, 0x57, 0x1D, 0x6F, 0xF5, 0xCF, 0x22 + }, + { + 0x32, 0xA0, 0x23, 0x84, 0xDD, 0xCD, 0x3E, 0xE9, + 0x31, 0x1E, 0x07, 0x89, 0x38, 0x64, 0xBD, 0xBE, + 0x5B, 0xFA, 0xA6, 0x91, 0xA8, 0x76, 0x42, 0xA1, + 0xE6, 0x66, 0xD3, 0xC5, 0x6E, 0x5F, 0xF4, 0xFD + }, + { + 0x59, 0x3D, 0xC1, 0x73, 0x1E, 0xD5, 0xF0, 0xE5, + 0x08, 0x5D, 0x27, 0xC0, 0x83, 0x78, 0xF7, 0x37, + 0xDB, 0xA5, 0x24, 0x39, 0xA6, 0xFC, 0x3C, 0x7D, + 0xC6, 0x57, 0xCD, 0xD8, 0x32, 0x8B, 0x99, 0xF7 + }, + { + 0xAD, 0x90, 0x8A, 0xD4, 0x14, 0x36, 0x0C, 0xE9, + 0x44, 0x3B, 0x38, 0xA0, 0x8A, 0xFE, 0x9E, 0x39, + 0x50, 0x58, 0xE0, 0x42, 0xF0, 0x6F, 0x13, 0x73, + 0x90, 0xC0, 0x59, 0x38, 0xA7, 0x33, 0xED, 0x94 + }, + { + 0xCC, 0x6E, 0x53, 0xDA, 0x78, 0xF7, 0xEE, 0x7F, + 0x46, 0x17, 0x18, 0x40, 0x42, 0xB2, 0xC6, 0x82, + 0x1A, 0xBD, 0xF0, 0xC0, 0x29, 0x6E, 0x31, 0x60, + 0x72, 0x68, 0x7B, 0xCA, 0x86, 0x98, 0x7C, 0xE8 + }, + { + 0xD8, 0xC6, 0x21, 0x55, 0xE6, 0x5D, 0x3F, 0x98, + 0x81, 0x1E, 0x7A, 0xC0, 0x7E, 0x8A, 0xFD, 0xFB, + 0xA0, 0xC3, 0x12, 0xB4, 0xB4, 0x31, 0xA1, 0xB5, + 0xBB, 0x85, 0xE5, 0xBC, 0xB6, 0xCB, 0xF3, 0x18 + }, + { + 0x05, 0xE0, 0xEE, 0x2D, 0x57, 0x17, 0x28, 0x9A, + 0xDE, 0x79, 0x0B, 0xC9, 0x2A, 0xD6, 0x32, 0x40, + 0x50, 0xAF, 0xEE, 0x7B, 0xB5, 0x2C, 0xEE, 0xEF, + 0xAB, 0x91, 0x67, 0x84, 0x66, 0xB6, 0x10, 0x1F + }, + { + 0x1B, 0x71, 0xF3, 0x84, 0xEC, 0x90, 0xD7, 0xD0, + 0x75, 0xAF, 0x69, 0xB5, 0x9C, 0x87, 0xFB, 0x61, + 0xC1, 0x96, 0x5F, 0xA6, 0x73, 0x5F, 0xBA, 0xDA, + 0x2B, 0x91, 0xD6, 0xB5, 0xD3, 0x41, 0xBA, 0x9D + }, + { + 0x7B, 0xEF, 0x66, 0xDF, 0x6D, 0x6E, 0x31, 0xA7, + 0x8D, 0x1A, 0x8A, 0xD7, 0xAC, 0x4A, 0x15, 0x20, + 0x17, 0x2E, 0x7A, 0x2E, 0x99, 0x96, 0xEA, 0x02, + 0xF4, 0x69, 0x25, 0xB1, 0x78, 0x13, 0x60, 0x46 + }, + { + 0x3B, 0x9A, 0x3B, 0xA0, 0x15, 0x15, 0x01, 0x5E, + 0x7E, 0x46, 0xE7, 0x20, 0xCB, 0xD2, 0x6D, 0x70, + 0xE5, 0xFB, 0xAD, 0xD6, 0x8B, 0xB1, 0x02, 0x24, + 0x2E, 0xCD, 0x29, 0x92, 0x89, 0x78, 0x98, 0x5A + }, + { + 0x68, 0x78, 0x38, 0xB9, 0xA7, 0x8C, 0x4D, 0xAA, + 0x2F, 0x2F, 0xD5, 0x1E, 0xA4, 0x16, 0xC8, 0x85, + 0xC7, 0xA0, 0x60, 0xA4, 0xF4, 0x45, 0x4D, 0x4B, + 0x59, 0x0B, 0x51, 0xAD, 0x5A, 0x65, 0x18, 0x51 + }, + { + 0xBC, 0x01, 0x9D, 0x3E, 0x8A, 0x44, 0xBF, 0x63, + 0x54, 0xAE, 0x9D, 0x2A, 0xF2, 0x99, 0x3C, 0x57, + 0x35, 0xDF, 0x42, 0xDF, 0xE6, 0x34, 0x5D, 0x16, + 0xF3, 0xC4, 0xAD, 0x90, 0xAB, 0x1D, 0x8C, 0x44 + }, + { + 0xA2, 0x31, 0x29, 0x5E, 0x84, 0x46, 0xB1, 0x2D, + 0xA4, 0xE3, 0x05, 0xB4, 0x66, 0xE2, 0x6A, 0xC4, + 0x69, 0x3D, 0x9A, 0x45, 0xC2, 0xA1, 0x39, 0x38, + 0x17, 0x1D, 0xE2, 0xA0, 0xCD, 0x2B, 0x92, 0x1B + }, + { + 0x55, 0x0C, 0x8B, 0x92, 0xD2, 0x97, 0x7A, 0x55, + 0x81, 0xAB, 0x87, 0x5F, 0xC6, 0xD3, 0xB5, 0xE3, + 0xF4, 0xB7, 0x21, 0xA7, 0x00, 0x2A, 0x2E, 0x28, + 0x90, 0xCC, 0xB2, 0x73, 0xB7, 0xA6, 0xF6, 0x21 + }, + { + 0x4D, 0x88, 0xE1, 0x41, 0xBD, 0x2D, 0x03, 0x64, + 0xBD, 0x0A, 0x83, 0x13, 0xED, 0x2C, 0xA1, 0x7F, + 0xC3, 0x29, 0xD9, 0x44, 0x9D, 0xB9, 0x28, 0xD0, + 0x53, 0x50, 0x29, 0x4F, 0x1B, 0xA0, 0xBB, 0xC3 + }, + { + 0x35, 0xAC, 0x28, 0x83, 0x18, 0x3D, 0x04, 0xEC, + 0xA8, 0xC1, 0xBC, 0xF3, 0x1A, 0xA3, 0x07, 0x41, + 0x4B, 0xA7, 0x46, 0x31, 0x54, 0x73, 0x31, 0xBE, + 0x25, 0x00, 0xB2, 0xC8, 0x42, 0x4B, 0x37, 0x09 + }, + { + 0x70, 0x07, 0xE1, 0x3D, 0xFB, 0xD5, 0x4B, 0x52, + 0x31, 0x70, 0xAD, 0x5A, 0x7A, 0x81, 0xC1, 0xB6, + 0x31, 0x31, 0x3F, 0x22, 0x09, 0xFD, 0x6B, 0xBF, + 0x44, 0x45, 0x8A, 0x95, 0x16, 0x72, 0x90, 0x3D + }, + { + 0xF6, 0x24, 0x13, 0x73, 0x02, 0xA1, 0x95, 0x32, + 0x58, 0x50, 0x4B, 0xF8, 0x2F, 0x1E, 0x26, 0x4C, + 0x04, 0xAB, 0x32, 0x56, 0x59, 0x66, 0x91, 0xA0, + 0xEB, 0xC0, 0xEF, 0xD5, 0xF4, 0xF7, 0x98, 0xF6 + }, + { + 0x41, 0x30, 0x9B, 0xB0, 0x24, 0x1D, 0x09, 0x02, + 0x75, 0x9A, 0x63, 0x6A, 0x04, 0x5D, 0x21, 0x7D, + 0x67, 0x4C, 0x48, 0xE8, 0x06, 0x11, 0xA0, 0x7D, + 0xB0, 0x25, 0xF4, 0xE7, 0x43, 0x10, 0x3A, 0x68 + }, + { + 0x45, 0x68, 0x97, 0x4F, 0x3A, 0xFB, 0xCB, 0x58, + 0xA0, 0xD3, 0x9C, 0x7A, 0xCA, 0x5C, 0x34, 0xFD, + 0x9F, 0xAA, 0xF6, 0xD4, 0xBA, 0x54, 0x45, 0x7C, + 0xD2, 0x3F, 0x69, 0xF3, 0xFE, 0x5B, 0xDB, 0x60 + }, + { + 0x0B, 0x48, 0x72, 0x70, 0x86, 0x55, 0xCD, 0xE8, + 0x2B, 0x00, 0x7B, 0x33, 0x65, 0xB8, 0xDE, 0x3B, + 0xE7, 0x40, 0x92, 0x71, 0x22, 0xBB, 0x13, 0x0F, + 0x5B, 0x39, 0x9B, 0x3A, 0xEF, 0x6C, 0x66, 0x65 + }, + { + 0x0B, 0x26, 0xAA, 0x99, 0xCC, 0x9F, 0x1F, 0x6C, + 0xB4, 0x3C, 0x9F, 0xDA, 0x15, 0x75, 0x70, 0x7B, + 0x9F, 0xE6, 0x59, 0x79, 0xCF, 0x23, 0x6F, 0x2F, + 0x0B, 0xE1, 0xE0, 0xB1, 0x6B, 0x34, 0x36, 0xEC + }, + { + 0x80, 0x1A, 0x18, 0xCE, 0xDF, 0x52, 0xC3, 0x06, + 0x46, 0x99, 0xE8, 0x20, 0xB4, 0x99, 0xA4, 0x56, + 0x71, 0x63, 0x9F, 0x91, 0xAC, 0x99, 0x58, 0x85, + 0x00, 0xDB, 0x3A, 0x0E, 0x5E, 0x5D, 0x30, 0x31 + }, + { + 0x6D, 0x10, 0x6F, 0xF4, 0xC7, 0xF4, 0xB4, 0x7D, + 0x08, 0x02, 0x6A, 0xCD, 0xED, 0x0E, 0x8E, 0x7E, + 0x0E, 0x80, 0x3D, 0x77, 0xF9, 0x3B, 0xAF, 0xAA, + 0x5F, 0xC6, 0x8E, 0x80, 0x36, 0xB0, 0x0C, 0x48 + }, + { + 0x88, 0x0A, 0x54, 0x54, 0x6B, 0xA3, 0x6B, 0xF6, + 0x93, 0x1B, 0x8D, 0xFA, 0x62, 0x43, 0x5B, 0xED, + 0xCD, 0xF5, 0xD9, 0x11, 0x70, 0x9E, 0x90, 0xAC, + 0x6F, 0xE6, 0xD6, 0x42, 0xF6, 0x80, 0xB3, 0x9A + }, + { + 0xA0, 0x72, 0x5C, 0xE9, 0xAA, 0x29, 0x5A, 0xFC, + 0xD3, 0x42, 0xB9, 0xB6, 0xA9, 0xA7, 0xD0, 0x1B, + 0x9A, 0x40, 0x9D, 0x59, 0x5F, 0x5A, 0x77, 0xCF, + 0x58, 0xB1, 0x19, 0xA1, 0x2D, 0x33, 0xDD, 0x7F + }, + { + 0x5B, 0x8E, 0x9C, 0x53, 0xAE, 0x80, 0xFA, 0xBB, + 0xB3, 0xE2, 0x65, 0x74, 0x61, 0xBA, 0x33, 0x5E, + 0xA5, 0x74, 0xC8, 0xB4, 0x72, 0xB5, 0x32, 0xA2, + 0xE5, 0x3E, 0x95, 0xC8, 0x6D, 0x5A, 0xEE, 0x06 + }, + { + 0x75, 0xEF, 0xC3, 0x3F, 0x95, 0xB8, 0x0A, 0x60, + 0x54, 0xC0, 0xFF, 0xEC, 0xB7, 0xDF, 0x36, 0x86, + 0xD7, 0x3F, 0xEA, 0x7B, 0x80, 0x67, 0x0D, 0x37, + 0x5C, 0x91, 0x71, 0x51, 0x6B, 0x6F, 0x02, 0xE2 + }, + { + 0x9C, 0x81, 0x14, 0x45, 0x65, 0xC2, 0xCA, 0x36, + 0xC2, 0x09, 0xA1, 0x4A, 0x12, 0x0E, 0xD7, 0x98, + 0xEA, 0xA6, 0x3F, 0x13, 0xA0, 0x6B, 0x83, 0x5C, + 0xCE, 0x48, 0xC5, 0xC6, 0x18, 0x11, 0x81, 0x05 + }, + { + 0xB4, 0x99, 0x19, 0xBA, 0x7C, 0x85, 0xDA, 0xAB, + 0x48, 0xB6, 0x80, 0xB9, 0xA9, 0x24, 0x02, 0x5E, + 0x3A, 0x7E, 0x21, 0x72, 0x4E, 0x53, 0x3B, 0x18, + 0x2D, 0xE1, 0x0A, 0x22, 0x73, 0xFB, 0xA1, 0x03 + }, + { + 0x2A, 0xFE, 0xB0, 0xBF, 0x72, 0x9C, 0xFA, 0xF8, + 0x01, 0xDD, 0xCF, 0x4F, 0x2B, 0xCC, 0xBE, 0xE1, + 0x5E, 0x07, 0x7B, 0xBD, 0x0E, 0x62, 0x6F, 0x72, + 0x20, 0x41, 0xA8, 0xB7, 0x18, 0x22, 0x03, 0x99 + }, + { + 0x62, 0xBD, 0x45, 0x3E, 0x0C, 0xF6, 0x49, 0x7D, + 0xEA, 0xEE, 0x65, 0x0E, 0x0C, 0x0F, 0xF7, 0x2F, + 0xFE, 0xF2, 0x4E, 0x76, 0x09, 0xFA, 0x75, 0x5C, + 0xBB, 0xEB, 0x42, 0x9E, 0x22, 0xA3, 0x40, 0x7D + }, + { + 0x41, 0x65, 0xB4, 0x84, 0x89, 0x9D, 0xDC, 0x09, + 0x3A, 0xB1, 0xD9, 0x2E, 0xCB, 0xD4, 0xF6, 0x58, + 0x3C, 0x9F, 0x32, 0x40, 0x3B, 0x26, 0xB3, 0x45, + 0x0E, 0x8A, 0x2C, 0xD1, 0x14, 0x5E, 0x45, 0x0C + }, + { + 0x92, 0xB5, 0x6C, 0x3E, 0xC0, 0xAB, 0xC2, 0x35, + 0xC4, 0x8E, 0x74, 0xFD, 0xA7, 0x78, 0xF8, 0x7F, + 0x0B, 0x35, 0x01, 0x38, 0x19, 0x25, 0x24, 0x53, + 0x88, 0xD6, 0x49, 0xB4, 0x07, 0xBD, 0x02, 0x27 + }, + { + 0xB9, 0xBB, 0x02, 0x6E, 0x7E, 0xE3, 0x23, 0x45, + 0x7E, 0x2B, 0xA4, 0xC7, 0xF0, 0x29, 0xF3, 0x39, + 0x6B, 0xAF, 0xC3, 0x49, 0xD9, 0x4A, 0x2A, 0xC4, + 0x63, 0xD0, 0xB2, 0x1F, 0x4E, 0x17, 0x3D, 0x30 + }, + { + 0x57, 0x5F, 0xAC, 0x92, 0xDD, 0xBE, 0x7B, 0xDF, + 0x97, 0xD4, 0x0D, 0x79, 0x54, 0xC5, 0x60, 0x34, + 0xC6, 0x0E, 0xEC, 0xB6, 0x56, 0x51, 0x75, 0x69, + 0x32, 0x2C, 0xE3, 0xCB, 0xC7, 0xB9, 0x2E, 0xCC + }, + { + 0xE4, 0x72, 0x93, 0xC9, 0x1A, 0xA1, 0xC3, 0x14, + 0x4C, 0xB8, 0xAD, 0xA4, 0x19, 0xFF, 0x40, 0xC5, + 0x79, 0x74, 0xA4, 0x7F, 0xC5, 0x34, 0x0B, 0xBC, + 0x98, 0x62, 0x75, 0xAC, 0xEB, 0xD4, 0x29, 0x13 + }, + { + 0x8A, 0x06, 0x0E, 0x4B, 0x0B, 0x77, 0x6E, 0xD0, + 0x01, 0xA8, 0xBB, 0xA2, 0xCC, 0x19, 0x8E, 0x58, + 0xFF, 0xFC, 0x5B, 0x84, 0x78, 0xA3, 0x1D, 0x89, + 0x47, 0x3E, 0x4A, 0xC1, 0x58, 0x0F, 0xC4, 0x5B + }, + { + 0x5C, 0x40, 0x4A, 0x51, 0x33, 0x6B, 0x5A, 0x1C, + 0xC0, 0xD7, 0xCA, 0x03, 0x4D, 0xE1, 0x2D, 0x70, + 0xFF, 0xE8, 0x6A, 0x26, 0x56, 0x92, 0x98, 0xFE, + 0xDC, 0xCB, 0xF1, 0x50, 0x1D, 0xD5, 0x64, 0xC8 + }, + { + 0xF3, 0xF4, 0x15, 0x52, 0xC5, 0x0F, 0xEF, 0x16, + 0x73, 0x2B, 0xDB, 0x4C, 0x31, 0x37, 0x3B, 0x1D, + 0xF5, 0x90, 0x84, 0xBB, 0x18, 0xB0, 0xCB, 0xE1, + 0x44, 0x5A, 0x50, 0x01, 0x78, 0xFD, 0xFC, 0x71 + }, + { + 0xB1, 0xE8, 0xA3, 0xBB, 0xFB, 0xC0, 0x22, 0x65, + 0xE0, 0x01, 0x0E, 0x43, 0xF4, 0x2B, 0xF2, 0x55, + 0x9E, 0xF6, 0xC5, 0x80, 0x18, 0xB8, 0xAC, 0x16, + 0x65, 0x2F, 0xF1, 0x96, 0x10, 0x54, 0xF4, 0x79 + }, + { + 0x12, 0x76, 0xA7, 0xEB, 0x62, 0x5E, 0x5A, 0xD8, + 0xA8, 0x6E, 0x48, 0xC0, 0x1D, 0xF6, 0x74, 0x1C, + 0xFD, 0x66, 0x19, 0xBA, 0x44, 0x27, 0x35, 0x99, + 0x39, 0x27, 0x9C, 0xE0, 0x6B, 0xD3, 0x51, 0xE8 + }, + { + 0x7C, 0x09, 0x10, 0x28, 0xAB, 0x22, 0xB4, 0xC0, + 0x85, 0xB5, 0x3F, 0x1D, 0xBA, 0x09, 0xFC, 0x69, + 0x12, 0xB7, 0x30, 0x92, 0xA1, 0xE1, 0xA3, 0xA5, + 0xFD, 0xCE, 0xE1, 0x58, 0xF7, 0x56, 0x4A, 0xF6 + }, + { + 0x83, 0x25, 0xF7, 0xB8, 0xEB, 0xD2, 0xDC, 0x7D, + 0x10, 0xFF, 0x30, 0x3C, 0x17, 0x3F, 0x07, 0x06, + 0x1C, 0x20, 0xB8, 0x61, 0x9E, 0xCD, 0x15, 0x0C, + 0xC4, 0x1D, 0xD7, 0xAE, 0x98, 0x2C, 0xD6, 0x05 + }, + { + 0x5B, 0x00, 0x56, 0x64, 0xF8, 0x1F, 0x4B, 0xE0, + 0x4F, 0x82, 0xBA, 0x15, 0xA8, 0xB2, 0x24, 0xBF, + 0x69, 0x55, 0xDF, 0xF1, 0xD8, 0x38, 0x91, 0xD3, + 0xCB, 0x8C, 0xE2, 0xA1, 0xBF, 0x86, 0xDF, 0x29 + }, + { + 0x28, 0x49, 0x6E, 0xCD, 0xB9, 0x22, 0x16, 0x88, + 0x90, 0x3A, 0xA8, 0xB3, 0x06, 0x53, 0x6B, 0xD4, + 0x68, 0x4D, 0x52, 0x6D, 0xA4, 0x14, 0x0B, 0x0C, + 0xED, 0xD7, 0x12, 0x21, 0x98, 0x25, 0x00, 0xC5 + }, + { + 0x47, 0x33, 0xAD, 0xB7, 0xF3, 0xF1, 0xD6, 0x7D, + 0x33, 0xAF, 0xF8, 0xE7, 0x0B, 0xF6, 0x40, 0x59, + 0xCA, 0x8C, 0x34, 0xAC, 0x8D, 0x97, 0xD4, 0xFD, + 0x4C, 0x44, 0x0B, 0x59, 0x20, 0x0C, 0x16, 0xEA + }, + { + 0xD3, 0xBD, 0x9C, 0x88, 0x3C, 0xD4, 0xD8, 0xD4, + 0x11, 0x9C, 0xB1, 0xC5, 0x05, 0x9B, 0x1B, 0x14, + 0xA9, 0x6B, 0xA3, 0xEE, 0xD4, 0xE4, 0xA6, 0x15, + 0x98, 0x55, 0x36, 0x5D, 0xDA, 0x7E, 0x48, 0x19 + }, + { + 0x39, 0xF4, 0x5C, 0x76, 0x5C, 0xE2, 0x0A, 0x62, + 0x24, 0x86, 0xCF, 0x8C, 0xC5, 0xD0, 0xBF, 0xE0, + 0xA3, 0x06, 0x35, 0x17, 0x63, 0x5A, 0x91, 0x80, + 0xB5, 0xE4, 0xE4, 0x6D, 0x14, 0xBD, 0xBB, 0x3D + }, + { + 0xA9, 0xFB, 0x31, 0x64, 0xA7, 0xB3, 0x96, 0x82, + 0x02, 0x84, 0x56, 0x1C, 0x7D, 0x5A, 0x0F, 0xD8, + 0x87, 0x8A, 0xAF, 0xD4, 0x45, 0x2C, 0xB8, 0x0C, + 0x5D, 0x47, 0x1A, 0x15, 0xA7, 0xFE, 0x18, 0xC9 + }, + { + 0xBA, 0x4F, 0x1F, 0xAF, 0xC4, 0xDC, 0x72, 0xB5, + 0x47, 0x18, 0x96, 0xF2, 0x90, 0x56, 0x56, 0xE0, + 0xDB, 0xB6, 0x5C, 0x13, 0x48, 0x63, 0x75, 0xBC, + 0x5B, 0x3D, 0x03, 0x4A, 0xBD, 0xC8, 0x51, 0x26 + }, + { + 0x71, 0x5F, 0x94, 0xEF, 0x3D, 0x3D, 0xC2, 0xB2, + 0x0E, 0x02, 0x1E, 0xE0, 0xEE, 0x41, 0xCF, 0x75, + 0xC4, 0x7C, 0xE6, 0xB8, 0xC9, 0x09, 0x98, 0xA4, + 0x27, 0xCB, 0x6E, 0x3D, 0xFC, 0x47, 0x0C, 0x18 + }, + { + 0x29, 0x33, 0x9C, 0x48, 0x55, 0x22, 0x63, 0xED, + 0xAE, 0x47, 0xC5, 0x5A, 0x70, 0xA5, 0x46, 0xD0, + 0x97, 0x94, 0x71, 0x99, 0x8B, 0x87, 0x74, 0x1B, + 0x8A, 0xF0, 0x05, 0xB6, 0x2A, 0x9A, 0x40, 0x1E + }, + { + 0x2F, 0xA2, 0x83, 0xFE, 0x07, 0xC6, 0xF3, 0x5A, + 0xCC, 0x1C, 0x30, 0x89, 0xB3, 0xFF, 0xFF, 0xB0, + 0x06, 0xAA, 0xB7, 0x9E, 0xD9, 0x40, 0x35, 0x8B, + 0xB9, 0xAD, 0x14, 0xE2, 0x27, 0xD4, 0x07, 0xAA + }, + { + 0x1E, 0x11, 0x77, 0x89, 0x35, 0x8F, 0x12, 0x1E, + 0x94, 0x75, 0xC6, 0xEB, 0xC9, 0xD0, 0x64, 0xA1, + 0x51, 0x1D, 0xB3, 0x36, 0xB8, 0xE0, 0xA5, 0xF1, + 0xFA, 0x6B, 0x6A, 0x6B, 0xD9, 0xE4, 0x53, 0x40 + }, + { + 0x62, 0xF1, 0x65, 0x2C, 0x4C, 0xA5, 0x9C, 0x9C, + 0xF6, 0x46, 0xC0, 0x1A, 0xD0, 0x63, 0x08, 0xC4, + 0x8B, 0xE7, 0xE3, 0x6A, 0x06, 0xAD, 0x6F, 0xAE, + 0x5F, 0x5F, 0xC3, 0xC8, 0x39, 0x1D, 0x2A, 0xBE + }, + { + 0x2D, 0x99, 0x27, 0x8F, 0xB4, 0x88, 0x28, 0xCD, + 0x46, 0x1C, 0x3F, 0x36, 0xD9, 0x78, 0x5A, 0xF8, + 0xEA, 0x11, 0x8A, 0x4F, 0xDD, 0xD7, 0x71, 0x64, + 0xBF, 0xB2, 0x96, 0xE1, 0x66, 0x24, 0xE9, 0x89 + }, + { + 0x7A, 0xB2, 0x80, 0x2B, 0xB7, 0xBF, 0x79, 0x94, + 0x43, 0x7D, 0xD3, 0x06, 0xDC, 0xD0, 0xDC, 0xED, + 0x2F, 0xB5, 0x1E, 0x43, 0x90, 0x4F, 0x99, 0x2C, + 0xBF, 0xFD, 0x27, 0x64, 0x86, 0xD4, 0x17, 0x92 + }, + { + 0xDE, 0xFD, 0x76, 0x72, 0xC3, 0x41, 0x60, 0x46, + 0x27, 0xD6, 0xE2, 0xC3, 0x5A, 0x14, 0xD8, 0x9E, + 0xB5, 0x8D, 0x0C, 0xE5, 0x68, 0x34, 0x5D, 0x1D, + 0x79, 0x87, 0x8E, 0xF2, 0x14, 0x47, 0x8A, 0x72 + }, + { + 0x22, 0x79, 0x9F, 0xC1, 0xB7, 0x7E, 0x0A, 0xC2, + 0x08, 0x71, 0x3A, 0x79, 0xFF, 0x00, 0x45, 0x59, + 0xD6, 0x5B, 0x9B, 0xBB, 0xD3, 0x89, 0x55, 0xE6, + 0xB1, 0xA6, 0xA0, 0xB6, 0x21, 0x7B, 0x5A, 0x5E + }, + { + 0x27, 0x81, 0x15, 0x8F, 0xC5, 0xCA, 0x03, 0x4A, + 0x0A, 0x08, 0x5D, 0x4E, 0x47, 0xE5, 0x97, 0x03, + 0xD5, 0x8E, 0x01, 0x24, 0x32, 0x43, 0x9B, 0xE3, + 0x1F, 0xC6, 0x65, 0x5C, 0xB3, 0x1A, 0xFB, 0xD9 + }, + { + 0x95, 0x76, 0x9D, 0x03, 0xEB, 0x9F, 0xB5, 0xDC, + 0x49, 0x71, 0x19, 0xFD, 0x51, 0xE3, 0xD7, 0xF8, + 0x4E, 0x68, 0xC6, 0x2B, 0x8C, 0x93, 0x75, 0x7E, + 0x1D, 0x0F, 0xCC, 0xB4, 0x03, 0x26, 0xBF, 0x9F + }, + { + 0xEB, 0xDD, 0x72, 0x1F, 0x5A, 0x7B, 0xCD, 0x15, + 0x7C, 0x06, 0x88, 0x69, 0x12, 0xB9, 0x83, 0x1F, + 0xD4, 0xFA, 0x83, 0xB9, 0x73, 0x4B, 0xF2, 0x09, + 0x55, 0x30, 0xEF, 0xCF, 0xB8, 0x59, 0x21, 0xD3 + }, + { + 0x31, 0xEF, 0x50, 0xA6, 0x50, 0x9F, 0x6A, 0xB1, + 0x86, 0xB5, 0x4A, 0xFC, 0x10, 0x21, 0x52, 0x17, + 0x30, 0x90, 0x44, 0x0F, 0xAF, 0x6E, 0xAF, 0x4D, + 0xB9, 0x03, 0x8F, 0xA2, 0x7B, 0x59, 0xF1, 0xEE + }, + { + 0xCC, 0xEC, 0x70, 0xA4, 0x1D, 0x0F, 0x81, 0x6E, + 0xD5, 0x8E, 0x22, 0xB1, 0x54, 0xAE, 0xF9, 0x10, + 0x0C, 0x4C, 0xC0, 0xFD, 0xC4, 0xFC, 0xDD, 0x5B, + 0x37, 0x4C, 0x07, 0x51, 0x77, 0xEB, 0xA6, 0xBD + }, + { + 0xE1, 0x10, 0x1D, 0x83, 0xC0, 0x2F, 0x19, 0x24, + 0x3A, 0xF1, 0x1D, 0x21, 0x49, 0x7E, 0x87, 0x0A, + 0x95, 0x76, 0x51, 0x2C, 0x2B, 0x67, 0xE6, 0x9F, + 0x57, 0xAF, 0x83, 0x36, 0x4B, 0xB9, 0xA8, 0x82 + }, + { + 0x33, 0x66, 0x7C, 0x1E, 0x56, 0x36, 0x0A, 0x8C, + 0x03, 0x36, 0x52, 0xED, 0x7A, 0x7F, 0x1B, 0x59, + 0x5D, 0xD7, 0xA7, 0xE4, 0x8D, 0x99, 0x18, 0x18, + 0xDE, 0x56, 0xF4, 0x87, 0x8C, 0x47, 0x34, 0x86 + }, + { + 0x71, 0xB9, 0x68, 0xBB, 0x83, 0x64, 0x91, 0x47, + 0xFC, 0x6B, 0x75, 0x4F, 0x44, 0x9C, 0xD6, 0x6E, + 0x62, 0xBA, 0xD3, 0xA5, 0xBF, 0x3E, 0x9F, 0x73, + 0x7F, 0x1A, 0xD5, 0x2E, 0xEB, 0xCE, 0xE2, 0x91 + }, + { + 0x4A, 0x64, 0x68, 0xDA, 0xB5, 0xD9, 0xE9, 0x19, + 0x65, 0x93, 0x76, 0xD7, 0xBD, 0x92, 0xBE, 0x37, + 0xB4, 0x76, 0xE2, 0x52, 0x59, 0x8F, 0x09, 0xA8, + 0xD0, 0x4E, 0x27, 0x47, 0xFE, 0xEF, 0x4B, 0x62 + }, + { + 0x91, 0x45, 0xF9, 0x00, 0x83, 0xBA, 0x90, 0x90, + 0x18, 0x26, 0x35, 0x09, 0x8B, 0xA3, 0xCD, 0x9D, + 0x77, 0x73, 0x4A, 0x7D, 0x7E, 0xF6, 0x31, 0xA0, + 0x8C, 0x12, 0x34, 0xD9, 0xF9, 0xC5, 0xA6, 0x19 + }, + { + 0xA9, 0x25, 0xC8, 0x06, 0xB6, 0xC0, 0x5A, 0x30, + 0x4C, 0xBD, 0xB7, 0x69, 0x74, 0x2E, 0x21, 0x60, + 0xFE, 0x24, 0x54, 0x3C, 0x18, 0x1B, 0x1D, 0xF4, + 0x05, 0xE2, 0xC4, 0x94, 0x56, 0x74, 0xCB, 0x2B + }, + { + 0x09, 0x65, 0x08, 0x3B, 0x62, 0x99, 0x94, 0xD6, + 0x21, 0x16, 0xD3, 0x5D, 0x8A, 0x49, 0x57, 0x4B, + 0x2C, 0x2D, 0x6B, 0x99, 0x63, 0x01, 0x0E, 0xA5, + 0x20, 0xF2, 0xEF, 0xE2, 0x28, 0x6A, 0x7A, 0xCD + }, + { + 0x29, 0xE7, 0x03, 0x62, 0xC5, 0x91, 0x5B, 0x48, + 0x50, 0x4A, 0x37, 0x17, 0xA0, 0x15, 0x23, 0xE7, + 0x70, 0x23, 0x30, 0x72, 0x7A, 0xBD, 0x7A, 0x1B, + 0x7E, 0xE1, 0x21, 0x5F, 0x27, 0x91, 0x9D, 0xB4 + }, + { + 0x5B, 0xE4, 0xD7, 0xA8, 0x0C, 0x2A, 0x26, 0xD6, + 0x1C, 0x53, 0x63, 0x4E, 0xFD, 0xA7, 0x0A, 0x7D, + 0x8E, 0xE3, 0x6B, 0xA0, 0x63, 0x0B, 0x7E, 0xA1, + 0x28, 0xA7, 0xA5, 0xA8, 0x4C, 0xC2, 0x6C, 0xFC + }, + { + 0xBE, 0xEE, 0x20, 0x6E, 0xD0, 0x80, 0x4A, 0x06, + 0x42, 0xA2, 0xDC, 0xB6, 0xB3, 0x01, 0xEF, 0x4F, + 0xD4, 0x5A, 0xCF, 0xC1, 0xEA, 0x00, 0x92, 0xC2, + 0x13, 0x31, 0xE2, 0xAD, 0x6B, 0xBE, 0x7C, 0x29 + }, + { + 0x43, 0x35, 0x37, 0xE7, 0x7B, 0x61, 0xE6, 0xFE, + 0x1D, 0x7F, 0x4C, 0x7D, 0x5D, 0x28, 0x46, 0x43, + 0xEB, 0x38, 0xD3, 0xFE, 0x10, 0x24, 0xE5, 0x54, + 0x19, 0x66, 0xF5, 0x7C, 0xCD, 0x70, 0x67, 0xD4 + }, + { + 0xD1, 0xCB, 0xF4, 0xAB, 0x3E, 0x53, 0xCA, 0x5E, + 0x54, 0x61, 0x3D, 0x7E, 0x97, 0xDB, 0x9F, 0x45, + 0xD7, 0xEA, 0xF4, 0x00, 0xF4, 0xA5, 0x2C, 0x20, + 0x74, 0xCC, 0x05, 0x75, 0x3D, 0xA3, 0x79, 0x3D + }, + { + 0x04, 0xA6, 0x10, 0x42, 0x93, 0x2B, 0xE8, 0x01, + 0xCD, 0xA2, 0xE3, 0xCA, 0x32, 0x08, 0xFE, 0x56, + 0xC0, 0x29, 0x3E, 0x29, 0xBE, 0x43, 0x0B, 0x0E, + 0x22, 0xB4, 0x09, 0xA0, 0x54, 0x7F, 0xF6, 0x93 + }, + { + 0x91, 0x6A, 0xE7, 0xF7, 0x68, 0xB8, 0xD2, 0x94, + 0x26, 0x45, 0x91, 0x8F, 0x71, 0xB1, 0xD6, 0xB9, + 0x69, 0xE3, 0x29, 0xFD, 0x1C, 0xE4, 0x31, 0x18, + 0x0D, 0xAA, 0x32, 0xD2, 0xAE, 0xEB, 0x21, 0x48 + }, + { + 0xBD, 0x08, 0xBD, 0x7A, 0x80, 0x2D, 0x76, 0xD9, + 0x65, 0x84, 0xC0, 0x91, 0x28, 0x5F, 0xF8, 0xA8, + 0x02, 0x04, 0xB2, 0xF8, 0x12, 0x47, 0x9F, 0xFE, + 0x1D, 0xE7, 0x10, 0x87, 0x86, 0x79, 0x67, 0xCD + }, + { + 0x3D, 0xDD, 0x39, 0xC1, 0x1D, 0x0C, 0xC0, 0x93, + 0x2C, 0xC0, 0xE3, 0xDA, 0x32, 0xB9, 0x3B, 0x6A, + 0xC8, 0xBA, 0x4F, 0x6D, 0x8D, 0xA7, 0x08, 0x98, + 0x9D, 0x65, 0x6F, 0x43, 0x24, 0xD7, 0x15, 0xD8 + }, + { + 0xF1, 0x8D, 0x13, 0xAB, 0x1F, 0xCA, 0x8F, 0x5A, + 0xAA, 0x71, 0x21, 0xC2, 0x76, 0xF1, 0xDC, 0xCF, + 0xDA, 0x99, 0xD9, 0xF0, 0xA8, 0x3A, 0x64, 0xEF, + 0x88, 0x91, 0xA4, 0x6A, 0xD5, 0xE7, 0x4E, 0x3C + }, + { + 0x33, 0x02, 0xF1, 0x40, 0xBF, 0x03, 0x34, 0x9D, + 0x5D, 0xCC, 0xCD, 0xDD, 0x01, 0x71, 0x72, 0xAB, + 0xF2, 0xE7, 0xA1, 0xF2, 0x97, 0x3C, 0x29, 0x90, + 0x68, 0x8E, 0xCF, 0x77, 0x7E, 0x8A, 0x39, 0x52 + }, + { + 0xF4, 0xEA, 0x2C, 0x12, 0x8E, 0xA8, 0x86, 0xF1, + 0xCE, 0x22, 0x2B, 0xBD, 0x35, 0x4B, 0x73, 0x8F, + 0x07, 0xF1, 0x1A, 0x34, 0x89, 0x02, 0x33, 0xC0, + 0x17, 0x92, 0xC3, 0xE3, 0x41, 0x69, 0xCB, 0x40 + }, + { + 0x0B, 0xFF, 0xB6, 0x6D, 0x5E, 0x6B, 0x5C, 0x71, + 0x52, 0x71, 0xB6, 0x71, 0x9B, 0x2F, 0x30, 0xA0, + 0x08, 0x0D, 0x26, 0x54, 0xF5, 0x12, 0xE3, 0x97, + 0x6E, 0xF8, 0xB9, 0x5C, 0x62, 0x74, 0x3B, 0x3B + }, + { + 0xD4, 0x20, 0xFC, 0xD3, 0x49, 0x78, 0x7C, 0xD7, + 0x88, 0xAD, 0xFD, 0x74, 0x32, 0x4C, 0x27, 0x7B, + 0x12, 0x42, 0xC6, 0x0B, 0x33, 0x1D, 0x7F, 0x77, + 0x4D, 0x1F, 0x87, 0x73, 0xCC, 0x54, 0x82, 0x71 + }, + { + 0x48, 0x1D, 0x5F, 0x0F, 0x80, 0x5B, 0x56, 0x11, + 0xD8, 0xF3, 0x2B, 0x56, 0xAB, 0x7E, 0x8B, 0xB6, + 0x4C, 0xFA, 0xDF, 0x9C, 0x95, 0x7B, 0x31, 0xDA, + 0x5F, 0x6E, 0x40, 0xF5, 0x19, 0x37, 0x8E, 0xB2 + }, + { + 0xB3, 0x42, 0xCF, 0x45, 0x9E, 0x2F, 0x81, 0x8A, + 0xAD, 0x1D, 0xFB, 0x1F, 0xF9, 0xD9, 0xFE, 0x36, + 0xE2, 0x40, 0x49, 0x84, 0x88, 0x68, 0xB4, 0x0B, + 0x20, 0x63, 0x9C, 0xCA, 0xC4, 0xAC, 0x79, 0x32 + }, + { + 0x0E, 0x52, 0x06, 0x05, 0x73, 0x51, 0x0A, 0x9A, + 0x51, 0xBD, 0x60, 0x9C, 0xE0, 0xEE, 0xD0, 0x39, + 0x37, 0x1E, 0x25, 0xBB, 0xCF, 0x2B, 0x1D, 0x85, + 0xA9, 0x76, 0x17, 0xB0, 0x69, 0x35, 0xE2, 0xB9 + }, + { + 0x93, 0x07, 0xEB, 0xBA, 0x1D, 0x47, 0x60, 0x3D, + 0xEB, 0xC8, 0x95, 0x89, 0x75, 0x9E, 0x59, 0xC7, + 0x45, 0x5B, 0x5F, 0x17, 0x97, 0x5F, 0x5F, 0x55, + 0xAB, 0xF7, 0x91, 0xA7, 0x7A, 0xB0, 0x9E, 0xAD + }, + { + 0x5B, 0xF3, 0xDE, 0x46, 0x2B, 0x10, 0x99, 0xA6, + 0x63, 0x30, 0xB9, 0xE7, 0x66, 0x0B, 0xF8, 0x50, + 0xF9, 0xCE, 0xFD, 0xA1, 0x1A, 0xFB, 0xB1, 0xD7, + 0xD8, 0x8D, 0x79, 0xE1, 0xD7, 0x02, 0x3C, 0xDD + }, + { + 0x99, 0x2D, 0x34, 0x81, 0xA4, 0xDA, 0x5C, 0x49, + 0x51, 0xBD, 0x02, 0x91, 0x35, 0xAB, 0x68, 0x24, + 0x17, 0xB3, 0x9A, 0xE3, 0x86, 0xD9, 0xBB, 0xF2, + 0xF6, 0xAA, 0x19, 0x29, 0x09, 0x2A, 0x68, 0x93 + }, + { + 0x74, 0x7D, 0xD6, 0x0F, 0xF3, 0x31, 0x07, 0x7E, + 0xCA, 0xF9, 0x94, 0x5A, 0xBF, 0x1C, 0x91, 0xEA, + 0xAB, 0xD7, 0xB2, 0x80, 0x05, 0xDB, 0xBD, 0xA9, + 0xC0, 0x65, 0x4D, 0xA6, 0x69, 0xB5, 0x39, 0x04 + }, + { + 0xD1, 0xA5, 0xAD, 0x1E, 0x6A, 0xF8, 0x26, 0x0F, + 0xBA, 0xD4, 0xD6, 0xB2, 0x37, 0xC7, 0xC6, 0x53, + 0x9E, 0x7F, 0x4B, 0xF7, 0x87, 0xBF, 0x7E, 0xA6, + 0x28, 0x48, 0x25, 0x00, 0xD7, 0x92, 0xDA, 0x13 + }, + { + 0x89, 0x0B, 0xE0, 0x66, 0x08, 0x2A, 0xC6, 0x5E, + 0x42, 0xD6, 0xBF, 0x91, 0xE9, 0x84, 0x53, 0x98, + 0xFA, 0x08, 0x50, 0x9E, 0x43, 0x30, 0xF9, 0xF1, + 0xBB, 0x19, 0x04, 0x8B, 0xE9, 0xA9, 0x3E, 0xBB + }, + { + 0x9D, 0x2A, 0x0B, 0x0F, 0xCD, 0xA4, 0x14, 0x53, + 0x1D, 0x58, 0xDE, 0x91, 0x6F, 0x30, 0x24, 0x4B, + 0x1E, 0xA5, 0x98, 0x54, 0x1A, 0xED, 0xF5, 0x53, + 0x37, 0x1C, 0xE7, 0x7F, 0x28, 0xEF, 0xB5, 0x5F + }, + { + 0x32, 0x3D, 0x2B, 0x8D, 0x17, 0x4E, 0x3A, 0xF6, + 0x8C, 0x58, 0x0E, 0x0B, 0x6E, 0x1C, 0x9F, 0xDD, + 0x46, 0x79, 0xAE, 0x5D, 0xCD, 0xBF, 0x91, 0xB4, + 0x9F, 0xC0, 0x62, 0x3E, 0x08, 0x40, 0xF2, 0xDF + }, + { + 0x96, 0xCB, 0x02, 0x9F, 0xE3, 0x5C, 0x0C, 0x73, + 0x4F, 0xB1, 0x06, 0x01, 0xE3, 0x0E, 0x5F, 0x9A, + 0xA8, 0xA7, 0x49, 0x9C, 0xF9, 0x49, 0x79, 0x33, + 0x24, 0xD7, 0x2B, 0xD7, 0xB7, 0xF5, 0x2F, 0xD1 + }, + { + 0x5D, 0x89, 0x7F, 0x71, 0xF1, 0xFE, 0x0A, 0x95, + 0x39, 0x5B, 0xD2, 0x34, 0xC0, 0x53, 0x6D, 0xB2, + 0x4F, 0x95, 0x31, 0x42, 0x2A, 0x70, 0x60, 0xBB, + 0x0B, 0x96, 0x1A, 0x6F, 0xCC, 0x4C, 0x63, 0x44 + }, + { + 0xC7, 0x05, 0xCA, 0x18, 0xA2, 0x92, 0x54, 0x42, + 0xF1, 0x38, 0x6A, 0x01, 0x0E, 0x2F, 0xB8, 0x9E, + 0x30, 0xB7, 0x0D, 0xA6, 0x9D, 0x95, 0xEC, 0xE7, + 0x36, 0x23, 0xFC, 0x6D, 0x97, 0x2B, 0x63, 0x20 + }, + { + 0xEF, 0x0F, 0x82, 0x40, 0xDE, 0x9C, 0xFA, 0x4E, + 0x5A, 0xA4, 0x6F, 0xEC, 0xBA, 0x8F, 0x07, 0xF1, + 0x6C, 0x73, 0x2D, 0x54, 0xA8, 0xAD, 0xB3, 0x8B, + 0x45, 0x0D, 0x11, 0xC1, 0xD1, 0xF6, 0x11, 0x66 + }, + { + 0xD6, 0x3D, 0x27, 0xBA, 0x56, 0xFF, 0x7B, 0x44, + 0x8F, 0xE3, 0x6C, 0xA1, 0xB7, 0xD2, 0xC1, 0x2D, + 0x16, 0xC9, 0x1D, 0xD0, 0x89, 0x71, 0x08, 0xD5, + 0xB5, 0x02, 0x8F, 0xAA, 0xD4, 0x60, 0x1B, 0x29 + }, + { + 0xC5, 0x67, 0xDF, 0xBC, 0xF1, 0xF6, 0x7F, 0x05, + 0x69, 0xEC, 0xC1, 0xAD, 0x26, 0x50, 0x82, 0x55, + 0x2B, 0x9A, 0x8C, 0xAE, 0x70, 0xAF, 0xA0, 0x2C, + 0x02, 0x47, 0xB6, 0x47, 0x50, 0x82, 0xA6, 0xF2 + }, + { + 0xEE, 0x8F, 0xD4, 0x5F, 0x58, 0x25, 0x9B, 0xB1, + 0x10, 0x5C, 0xC4, 0x22, 0x35, 0x70, 0x07, 0xA1, + 0x10, 0x0D, 0xB1, 0x07, 0x8B, 0x9D, 0xD4, 0x14, + 0xA2, 0xC4, 0x48, 0x1D, 0xA0, 0x93, 0x41, 0xBB + }, + { + 0xE1, 0xEC, 0xD4, 0xBB, 0x8D, 0xF7, 0x60, 0xB3, + 0x01, 0xC3, 0x06, 0xAD, 0xAA, 0x62, 0x1E, 0x82, + 0x5B, 0xFF, 0xA5, 0xAD, 0x45, 0x8A, 0xA4, 0x32, + 0x59, 0xCD, 0x79, 0xBD, 0x14, 0x02, 0x25, 0xF5 + }, + { + 0x18, 0x8C, 0x7F, 0x8E, 0xBB, 0x7B, 0x0A, 0xC3, + 0x76, 0xF1, 0x9A, 0x1A, 0xD7, 0xD6, 0x36, 0x22, + 0x75, 0x3F, 0x6E, 0xD9, 0x57, 0x66, 0x7E, 0x54, + 0x61, 0x6A, 0x5E, 0x84, 0xB7, 0xBC, 0xDC, 0xB1 + }, + { + 0xB7, 0x34, 0x13, 0xAD, 0xF8, 0xE4, 0x3C, 0x11, + 0xCA, 0x46, 0x34, 0x6A, 0x9B, 0xB9, 0xBE, 0xC2, + 0x29, 0x68, 0xB6, 0xFE, 0x0F, 0xB1, 0xA6, 0x8E, + 0x62, 0x53, 0x5D, 0x8A, 0x23, 0x0A, 0x66, 0x37 + }, + { + 0xB3, 0xA4, 0xC7, 0x07, 0x4A, 0xF9, 0xA9, 0x26, + 0x13, 0xA4, 0x11, 0xB0, 0x3E, 0x88, 0x6F, 0x53, + 0x19, 0x4A, 0xD8, 0x6C, 0xFB, 0xF1, 0x37, 0x80, + 0x37, 0x1B, 0x30, 0xBA, 0xD9, 0xBA, 0x01, 0xF8 + }, + { + 0x48, 0x16, 0x52, 0x15, 0xD0, 0x13, 0x0F, 0x45, + 0x25, 0xFF, 0x3E, 0xFF, 0x0E, 0x65, 0xD1, 0xDD, + 0xFB, 0xB0, 0xC2, 0x22, 0x47, 0xD1, 0x8A, 0x6C, + 0x6A, 0x1A, 0x14, 0x5A, 0xE5, 0x3E, 0x03, 0x8E + }, + { + 0x28, 0x21, 0xBB, 0xFB, 0xA3, 0xA7, 0x53, 0xD9, + 0xE5, 0xF7, 0x97, 0x53, 0x39, 0x03, 0xCB, 0xDB, + 0x66, 0xC7, 0xB6, 0xB9, 0x15, 0x88, 0x80, 0xED, + 0xD6, 0x94, 0x4E, 0xA0, 0x09, 0xC4, 0x69, 0xB4 + }, + { + 0xB7, 0x27, 0x7C, 0xB3, 0x0D, 0x60, 0xD8, 0xFF, + 0x9E, 0x60, 0x5F, 0xD4, 0x65, 0x7D, 0xEA, 0xAE, + 0xBD, 0xCC, 0x98, 0x29, 0x17, 0xC2, 0x9E, 0x47, + 0x51, 0x2F, 0x4E, 0x8F, 0x53, 0x44, 0x1C, 0xBD + }, + { + 0x5D, 0x67, 0x1B, 0x54, 0xCC, 0xD8, 0xD8, 0x5B, + 0xA3, 0x2F, 0xC8, 0xF9, 0xE1, 0xB9, 0xEC, 0xF1, + 0x8E, 0xC3, 0x69, 0x61, 0xD0, 0x08, 0xA0, 0xBB, + 0xE0, 0x90, 0x6D, 0x78, 0x00, 0xCC, 0x65, 0xD9 + }, + { + 0x58, 0x1F, 0x37, 0x3B, 0xC2, 0xB2, 0x55, 0xC2, + 0xF1, 0xAA, 0xBB, 0x30, 0x50, 0x38, 0x29, 0x6C, + 0x15, 0x6B, 0xEC, 0x5E, 0x1D, 0xCC, 0x08, 0xB2, + 0xD4, 0x55, 0xCB, 0x31, 0xFA, 0xE9, 0x2F, 0x0B + }, + { + 0x98, 0x0A, 0xE6, 0x07, 0x51, 0x34, 0xFE, 0x94, + 0xC3, 0x0A, 0x42, 0x15, 0x12, 0x98, 0xD9, 0xC0, + 0x22, 0x4C, 0x49, 0xCB, 0x01, 0xCB, 0x1A, 0x79, + 0x3B, 0x03, 0x3B, 0x0A, 0xD1, 0x4C, 0xB5, 0x91 + }, + { + 0x51, 0xE3, 0x8E, 0xC1, 0xF5, 0x21, 0x0E, 0xC7, + 0xDB, 0x63, 0x6B, 0xE1, 0xA0, 0x3D, 0x84, 0x93, + 0x75, 0x07, 0xCE, 0x07, 0x3B, 0x6F, 0x49, 0xB1, + 0xC0, 0x51, 0x44, 0x67, 0x38, 0x91, 0x44, 0xF8 + }, + { + 0x1A, 0xBF, 0xE4, 0x59, 0x35, 0xFD, 0x25, 0x9F, + 0xB5, 0xA7, 0x00, 0x9E, 0x31, 0x53, 0xDC, 0x9E, + 0x00, 0xD7, 0xBD, 0x77, 0xCA, 0x94, 0x6D, 0x20, + 0x71, 0x44, 0xF2, 0xC4, 0xDE, 0x5C, 0x9D, 0x35 + }, + { + 0xD2, 0x1F, 0x78, 0x0A, 0xCB, 0x26, 0x5A, 0x09, + 0xC2, 0x34, 0x48, 0x2B, 0x38, 0x33, 0x89, 0xF1, + 0xBE, 0x3A, 0xAD, 0x9C, 0xCD, 0x40, 0x5E, 0x38, + 0xA1, 0xCD, 0x09, 0xC5, 0x60, 0x6F, 0xD8, 0x7C + }, + { + 0x9E, 0xD2, 0xAF, 0x15, 0x26, 0x03, 0x38, 0x8F, + 0x36, 0x17, 0x01, 0x2C, 0xB1, 0xBD, 0xE0, 0x5B, + 0x31, 0x15, 0xB0, 0x09, 0xB6, 0xE7, 0x9B, 0xA5, + 0xDB, 0xB3, 0xFD, 0x10, 0x35, 0xB4, 0xC7, 0x6C + }, + { + 0x37, 0x84, 0x2A, 0xCB, 0xF0, 0xE4, 0x19, 0xD0, + 0xB1, 0x9D, 0xD8, 0xCB, 0x21, 0xF4, 0x79, 0x50, + 0x96, 0x81, 0x0B, 0xEA, 0x01, 0x48, 0x4A, 0x25, + 0xEF, 0x07, 0x95, 0xA6, 0x89, 0x82, 0x7E, 0xF6 + }, + { + 0x15, 0x75, 0x4D, 0xB4, 0xB3, 0xE1, 0x2F, 0xD0, + 0x34, 0x14, 0x4A, 0x91, 0xD7, 0x96, 0xAF, 0x87, + 0x20, 0x72, 0x97, 0xB5, 0x61, 0x5D, 0xE4, 0x29, + 0x1A, 0xD6, 0x54, 0xA8, 0x12, 0x77, 0x3F, 0xF6 + }, + { + 0xC8, 0x4D, 0x61, 0x1D, 0x78, 0x53, 0x11, 0xDF, + 0xF2, 0x7C, 0xAE, 0x7C, 0xFC, 0x0F, 0xA0, 0xF7, + 0x9F, 0x28, 0x01, 0x22, 0xB6, 0xAE, 0x82, 0xCA, + 0x71, 0x62, 0xD7, 0xF1, 0xEB, 0xC9, 0xC9, 0xD0 + }, + { + 0x79, 0xC0, 0x67, 0x83, 0x0D, 0x3D, 0x31, 0xFA, + 0xDE, 0xE5, 0x3A, 0x2F, 0x63, 0x11, 0x0F, 0x0F, + 0x02, 0x6D, 0xD1, 0x43, 0x80, 0xAB, 0x6D, 0xDB, + 0x9A, 0xA3, 0x90, 0x28, 0x4D, 0xAF, 0xED, 0x45 + }, + { + 0x1E, 0xD5, 0x75, 0x23, 0xAF, 0x6E, 0xE0, 0x45, + 0xA7, 0x71, 0x46, 0x3E, 0x61, 0x53, 0x76, 0x43, + 0xED, 0xB1, 0x31, 0xAD, 0x95, 0x36, 0x7B, 0x92, + 0x1B, 0x86, 0x8F, 0xE9, 0x36, 0x82, 0xAE, 0xB7 + }, + { + 0x33, 0x91, 0x9B, 0x57, 0x23, 0x5C, 0xD1, 0x5D, + 0xB5, 0xE5, 0xEA, 0x19, 0x05, 0xF1, 0x50, 0x8F, + 0x09, 0x95, 0x71, 0x09, 0x0B, 0x92, 0x16, 0x14, + 0x9D, 0xD8, 0x33, 0x9E, 0x0D, 0xD1, 0x0F, 0xE2 + }, + { + 0x7D, 0xC9, 0x7B, 0x25, 0x84, 0x10, 0x4E, 0x33, + 0xFE, 0xAB, 0x76, 0x6D, 0xA6, 0x7D, 0x5E, 0xBA, + 0xF0, 0x18, 0x06, 0x19, 0xB0, 0xE6, 0xA6, 0x1B, + 0x1F, 0x9A, 0x26, 0x60, 0xA4, 0xB7, 0x70, 0xD9 + }, + { + 0xCB, 0x63, 0xD8, 0xF7, 0x5C, 0x08, 0x28, 0xE8, + 0x95, 0x05, 0x42, 0x3B, 0xB0, 0x85, 0x28, 0x77, + 0x3C, 0x9F, 0x8F, 0x52, 0x2D, 0xA3, 0x81, 0x61, + 0xE1, 0xDC, 0x9A, 0x85, 0x55, 0x59, 0xAA, 0x30 + }, + { + 0xF8, 0xEB, 0x87, 0x2E, 0x45, 0x16, 0x07, 0x9E, + 0xCB, 0x4A, 0x27, 0xB9, 0x1C, 0xC7, 0x9D, 0x08, + 0x71, 0x71, 0x0F, 0x2E, 0x67, 0x6B, 0xA3, 0x24, + 0x13, 0x9A, 0x9A, 0xC9, 0x82, 0xD7, 0xD4, 0xE4 + }, + { + 0xF4, 0x1B, 0xF3, 0x08, 0x1C, 0x68, 0x61, 0xEE, + 0x51, 0xE8, 0x0D, 0x4D, 0x57, 0x20, 0xB6, 0x5A, + 0xC2, 0x7B, 0xD6, 0x86, 0xB2, 0x5D, 0x0E, 0x05, + 0x64, 0x18, 0xA5, 0x02, 0x54, 0xAA, 0x25, 0x17 + }, + { + 0xD6, 0xD6, 0xA9, 0xE9, 0x40, 0xE8, 0x69, 0xFD, + 0x67, 0x26, 0x7A, 0x16, 0x0E, 0x79, 0x00, 0xBC, + 0x35, 0xB2, 0x66, 0xD6, 0x17, 0xEE, 0x40, 0xCB, + 0xB6, 0x27, 0xAE, 0xDA, 0xD4, 0xD8, 0xDE, 0x65 + }, + { + 0x2C, 0xBC, 0xA5, 0x11, 0xD9, 0xDD, 0xF2, 0x37, + 0x65, 0x41, 0xD7, 0xA5, 0x5C, 0x8E, 0x4A, 0x2D, + 0xBA, 0x05, 0x0F, 0x7D, 0x1F, 0x81, 0xBA, 0x5F, + 0x47, 0x6B, 0x5D, 0x7A, 0xE1, 0x39, 0x1A, 0x0F + }, + { + 0x90, 0x82, 0x63, 0x77, 0xAC, 0x75, 0x16, 0xDD, + 0x36, 0xFB, 0xFB, 0xD8, 0xE5, 0x07, 0x19, 0x8E, + 0x31, 0xA9, 0xC7, 0xBD, 0x0E, 0xA2, 0x58, 0xA0, + 0x58, 0x1E, 0x21, 0x4B, 0x47, 0x8A, 0xAB, 0xFC + }, + { + 0x75, 0xA5, 0xE9, 0xEF, 0xDB, 0x15, 0xBB, 0xA5, + 0x92, 0xA4, 0x1A, 0xE8, 0x2D, 0x06, 0xA1, 0x98, + 0xFD, 0x29, 0xE5, 0xEF, 0x7D, 0xD5, 0x9D, 0x5F, + 0xC8, 0xE9, 0x17, 0x4B, 0xCB, 0xC4, 0x1F, 0x41 + }, + { + 0xEF, 0x45, 0xF3, 0x55, 0x47, 0x18, 0xB5, 0x05, + 0x55, 0x89, 0x17, 0x3F, 0x0B, 0x1D, 0xDA, 0x6F, + 0xCC, 0x88, 0x4B, 0xA1, 0xEA, 0x76, 0xDD, 0x2D, + 0x88, 0xF7, 0xFA, 0x91, 0xE3, 0xBE, 0xFF, 0xEE + }, + { + 0x61, 0x45, 0x02, 0xF0, 0xE0, 0x31, 0xB0, 0x89, + 0x0A, 0xC4, 0xC1, 0x37, 0xBD, 0x9A, 0x4B, 0x66, + 0x6F, 0xE6, 0x93, 0x05, 0x65, 0xAB, 0xF1, 0xF4, + 0xD1, 0x98, 0x64, 0x0C, 0xB0, 0xBD, 0xCE, 0xDA + }, + { + 0x9C, 0xC7, 0x34, 0x60, 0x95, 0xA3, 0x82, 0x62, + 0xA4, 0x0E, 0xDB, 0xFF, 0x91, 0xD9, 0xA8, 0xCF, + 0x45, 0x60, 0x0F, 0xEA, 0xAE, 0x90, 0x4A, 0x41, + 0x9E, 0xC3, 0xF8, 0x3C, 0x12, 0x66, 0xA6, 0x56 + }, + { + 0xF5, 0xF8, 0x45, 0x55, 0x99, 0x5C, 0x04, 0x31, + 0xD1, 0xDB, 0xCD, 0xEC, 0x8A, 0x63, 0xA8, 0x7F, + 0x88, 0x36, 0x65, 0x79, 0xCA, 0xF4, 0xBB, 0xBB, + 0xF5, 0x49, 0x81, 0x13, 0x55, 0x0E, 0x5A, 0x5A + }, + { + 0xDB, 0x1A, 0x34, 0x44, 0x11, 0xD3, 0x0F, 0x4D, + 0xC7, 0xDC, 0x0A, 0x3C, 0x3E, 0x83, 0x94, 0x32, + 0x18, 0xF1, 0xD5, 0x4F, 0xA4, 0x73, 0x48, 0x0B, + 0x94, 0x41, 0x16, 0xAF, 0x01, 0x04, 0xF6, 0x1A + }, + { + 0xD9, 0x74, 0x84, 0xB5, 0x2A, 0x87, 0xC6, 0x37, + 0x9A, 0xAD, 0xB2, 0x35, 0xBF, 0x5B, 0x3A, 0x55, + 0x10, 0x0B, 0x83, 0xE2, 0xCD, 0xEE, 0x8D, 0xF6, + 0x35, 0xC9, 0xB8, 0xBD, 0xAA, 0x10, 0x78, 0x19 + }, + { + 0x38, 0x65, 0x4D, 0xF0, 0x79, 0xB7, 0x38, 0x3E, + 0xF0, 0x68, 0x64, 0xD6, 0x38, 0x50, 0x1B, 0x7A, + 0x43, 0xF7, 0x3D, 0x22, 0x76, 0xA6, 0x42, 0x39, + 0x14, 0xDB, 0x57, 0xF9, 0x95, 0x90, 0x11, 0x2F + }, + { + 0x72, 0xC7, 0x11, 0xF3, 0xC2, 0x2E, 0xB8, 0x03, + 0xC1, 0x79, 0xC8, 0xED, 0x8E, 0xFD, 0xF8, 0x92, + 0x40, 0x4C, 0xA2, 0x5E, 0xD2, 0x7B, 0x1D, 0xDC, + 0x0F, 0xF2, 0xC8, 0xE0, 0xAD, 0x55, 0x40, 0x6D + }, + { + 0x9C, 0xE8, 0x60, 0xFB, 0xA3, 0xE0, 0xDC, 0xAA, + 0x59, 0x35, 0x93, 0x5B, 0x34, 0x03, 0x1D, 0x79, + 0xFE, 0xB9, 0x5D, 0x6E, 0x86, 0x7D, 0x62, 0x2C, + 0x6A, 0xAE, 0xCC, 0x63, 0xF5, 0x97, 0x20, 0xB6 + }, + { + 0xD4, 0x4D, 0xA8, 0xDD, 0x15, 0xC5, 0x81, 0x80, + 0xA4, 0xF2, 0xA1, 0x71, 0xEE, 0xB2, 0x29, 0x01, + 0x56, 0xFB, 0x57, 0x39, 0x6B, 0xBE, 0xF7, 0xA2, + 0xA8, 0x64, 0x46, 0x59, 0x8F, 0xE8, 0xF6, 0x57 + }, + { + 0xE8, 0x28, 0x78, 0x31, 0xE7, 0x9B, 0x01, 0x8D, + 0xE7, 0xD9, 0x36, 0xE9, 0x75, 0x05, 0x74, 0xF4, + 0x41, 0x36, 0xE6, 0x8E, 0x68, 0x8E, 0x25, 0xAB, + 0x57, 0xF2, 0x7A, 0x91, 0xDF, 0x6F, 0x48, 0x7E + }, + { + 0xDF, 0xBC, 0xD1, 0x91, 0x2D, 0xDD, 0xCA, 0x1C, + 0xF5, 0xCB, 0x94, 0x96, 0xFA, 0xF8, 0x52, 0x5B, + 0x01, 0x53, 0x35, 0xA3, 0x9E, 0xB2, 0xF0, 0x4D, + 0x72, 0xEF, 0xDF, 0x14, 0xA0, 0xD5, 0x06, 0x09 + }, + { + 0x75, 0x89, 0x5A, 0x9C, 0x05, 0xB7, 0x6D, 0xF2, + 0x7D, 0x66, 0xF7, 0x52, 0x59, 0x30, 0xCF, 0x1E, + 0x71, 0xBA, 0xC7, 0x27, 0x75, 0x91, 0x8D, 0x9B, + 0x6F, 0x33, 0xDB, 0xAC, 0x80, 0x44, 0x09, 0x89 + }, + { + 0x77, 0x84, 0xDE, 0xDF, 0xE6, 0xB9, 0x10, 0xD5, + 0x40, 0xE2, 0xE0, 0x0E, 0xAD, 0x60, 0xFA, 0x8F, + 0xFC, 0xC0, 0xF2, 0xFB, 0x1B, 0x0F, 0x0F, 0x22, + 0x05, 0xCC, 0xEE, 0x54, 0x09, 0xAC, 0xAF, 0xCF + }, + { + 0x11, 0x22, 0x46, 0x9D, 0xCA, 0xAF, 0x1A, 0x83, + 0xF8, 0x09, 0x02, 0xF4, 0x97, 0x08, 0x8B, 0xDC, + 0x9B, 0xBC, 0x45, 0xA0, 0x59, 0x0D, 0xBA, 0x91, + 0x71, 0x1D, 0xED, 0xC5, 0xBF, 0x1E, 0xA0, 0xE9 + }, + { + 0x43, 0x93, 0x4E, 0x6C, 0xA9, 0xC8, 0x73, 0x4C, + 0x24, 0x5F, 0x29, 0x4A, 0xB7, 0xA9, 0x35, 0xAD, + 0x6B, 0x64, 0x8D, 0x88, 0xBA, 0x52, 0xD5, 0xB1, + 0x4F, 0xF6, 0x8F, 0x6A, 0x8D, 0x63, 0x6D, 0xAB + }, + { + 0xBB, 0x41, 0x85, 0xE5, 0xD5, 0x2B, 0xEA, 0xAD, + 0x78, 0x40, 0xA8, 0xA9, 0x31, 0xDC, 0x1F, 0xD2, + 0x19, 0x06, 0x12, 0xB8, 0x46, 0x8C, 0x24, 0x4B, + 0xED, 0xEF, 0x22, 0xC6, 0x80, 0xAE, 0x03, 0x87 + }, + { + 0xCF, 0xBB, 0x75, 0x20, 0x1A, 0x2D, 0xDB, 0xE0, + 0xB9, 0x09, 0x30, 0x16, 0x7E, 0x5C, 0xA8, 0xB3, + 0x03, 0x06, 0x35, 0xCD, 0x77, 0xDB, 0xBF, 0x32, + 0x9A, 0xC0, 0x25, 0x39, 0xF6, 0x3C, 0x5E, 0xBE + }, + { + 0x88, 0x55, 0x15, 0x8E, 0xD2, 0x90, 0x40, 0xAD, + 0x66, 0x74, 0x72, 0x12, 0x81, 0x7A, 0x03, 0x5F, + 0x64, 0x25, 0x1F, 0xCB, 0x44, 0x30, 0xE3, 0x51, + 0xC5, 0x47, 0x2C, 0xED, 0x28, 0xD4, 0xC7, 0xE3 + }, + { + 0xD7, 0x0E, 0xD7, 0x28, 0xF5, 0x54, 0x90, 0x68, + 0xA7, 0xC9, 0xCF, 0xCF, 0x92, 0x89, 0xC9, 0x17, + 0x36, 0x6B, 0x65, 0x92, 0x19, 0x6E, 0x8A, 0xAD, + 0x71, 0x31, 0x34, 0x46, 0xDE, 0xB9, 0x94, 0xBD + }, + { + 0x80, 0xB9, 0x7B, 0x76, 0x20, 0x8E, 0x4E, 0xAE, + 0x9E, 0xDE, 0xA2, 0xF1, 0xF4, 0x33, 0x14, 0x5B, + 0x45, 0x74, 0x85, 0xE4, 0x25, 0xF7, 0x7F, 0x49, + 0x14, 0x26, 0x1A, 0x58, 0xEB, 0x79, 0xE1, 0xF4 + }, + { + 0xA3, 0x1D, 0xFF, 0x5E, 0xDE, 0xEA, 0xEA, 0x07, + 0x32, 0xAF, 0x6D, 0x59, 0x21, 0x7B, 0xEA, 0x6C, + 0x0E, 0xE2, 0xDF, 0x7D, 0x50, 0xB7, 0x79, 0x25, + 0x31, 0x03, 0x20, 0xDB, 0x74, 0x96, 0x96, 0xEB + }, + { + 0xB7, 0x30, 0x05, 0x52, 0xD9, 0x11, 0x06, 0x53, + 0x31, 0x35, 0x31, 0xFE, 0x8D, 0x82, 0x03, 0xFB, + 0x40, 0x39, 0x58, 0xFD, 0xFA, 0xCD, 0x03, 0xBD, + 0x07, 0x7E, 0x68, 0x8B, 0x96, 0x4D, 0x0F, 0x47 + }, + { + 0x37, 0xE6, 0x2D, 0x8F, 0xAF, 0x87, 0x39, 0xE3, + 0xE1, 0x54, 0x18, 0x7C, 0x35, 0x30, 0xC3, 0x4E, + 0x18, 0x47, 0xA5, 0x46, 0x22, 0x72, 0x59, 0xE8, + 0x72, 0x4C, 0x3A, 0x27, 0x84, 0x32, 0x28, 0xBC + }, + { + 0xE2, 0x53, 0xC8, 0x5B, 0x40, 0x44, 0x0C, 0x4D, + 0xE3, 0x2F, 0xE6, 0xE7, 0xF6, 0x16, 0x21, 0xCA, + 0x31, 0x6E, 0x77, 0x9C, 0x3A, 0x14, 0xCB, 0x92, + 0x49, 0xB3, 0xB7, 0x91, 0x72, 0x41, 0xF7, 0x22 + }, + { + 0x5A, 0xF0, 0xD6, 0xF6, 0xFD, 0x8B, 0x05, 0xA5, + 0xA2, 0x07, 0x85, 0x20, 0x5B, 0xF6, 0x9F, 0x38, + 0x06, 0xDF, 0x57, 0x88, 0x66, 0xD3, 0xD4, 0x36, + 0x43, 0x64, 0xBA, 0xA4, 0x6C, 0x4C, 0xFF, 0xB1 + }, + { + 0xD4, 0x0F, 0x56, 0x68, 0x3B, 0xB9, 0x43, 0x67, + 0x44, 0x75, 0x0E, 0xD1, 0xD8, 0x4E, 0xEF, 0x0B, + 0x19, 0xE2, 0x14, 0xC9, 0x2A, 0xD2, 0x5D, 0xC7, + 0xAB, 0xC7, 0xE4, 0x13, 0x37, 0xF2, 0xDE, 0xEA + }, + { + 0x0E, 0x9B, 0x97, 0xB7, 0xDB, 0xDF, 0x6F, 0x35, + 0x7A, 0x68, 0x10, 0xFF, 0x84, 0x29, 0x3D, 0xC7, + 0x31, 0xD8, 0x4A, 0x95, 0xCF, 0x7D, 0xEA, 0x25, + 0xEB, 0xE6, 0x6E, 0x3F, 0x36, 0x57, 0xAD, 0xB1 + }, + { + 0x4F, 0xAC, 0x3E, 0xEF, 0x0E, 0x54, 0xE4, 0x8B, + 0x53, 0x7E, 0x57, 0x5A, 0xA3, 0x43, 0x4D, 0x1C, + 0xB2, 0x51, 0x83, 0xA5, 0x2F, 0xCE, 0x68, 0x10, + 0xE7, 0x50, 0xDD, 0x43, 0x20, 0xDB, 0x91, 0xF7 + }, + { + 0xD5, 0xC2, 0xF5, 0xA3, 0xBC, 0x65, 0x7B, 0x93, + 0xE7, 0xCB, 0xB7, 0x4F, 0xEC, 0xCE, 0x85, 0xEA, + 0x16, 0xFD, 0xD9, 0x94, 0x8E, 0xE4, 0x76, 0x68, + 0xEF, 0x34, 0x35, 0xD3, 0x6D, 0xD7, 0x80, 0x9D + }, + { + 0x6B, 0x8B, 0xD3, 0x08, 0x42, 0xD2, 0x1D, 0xC7, + 0xFA, 0x95, 0x80, 0xDD, 0x4A, 0xBE, 0x22, 0xB4, + 0xD1, 0xD1, 0x3E, 0x87, 0x7C, 0xC8, 0x75, 0x8D, + 0xD7, 0x90, 0x2E, 0x2E, 0xE1, 0x57, 0x2B, 0x76 + }, + { + 0xC5, 0x04, 0xF2, 0x8E, 0xF6, 0x8C, 0x91, 0xEA, + 0x7E, 0x75, 0xB1, 0xCC, 0xD4, 0x61, 0x04, 0x38, + 0x3A, 0x48, 0x0B, 0x84, 0xC8, 0x0C, 0xDC, 0x2D, + 0xE9, 0xF3, 0x16, 0xF9, 0xA5, 0xCE, 0x46, 0x85 + }, + { + 0x3C, 0xD1, 0x2C, 0x15, 0xD6, 0xA7, 0x1B, 0x95, + 0xE3, 0x20, 0x7D, 0x0C, 0x2F, 0x8B, 0x96, 0xF1, + 0x9A, 0x71, 0x78, 0xE1, 0x67, 0x64, 0xC9, 0x38, + 0xC1, 0x22, 0xCB, 0x75, 0x45, 0xDC, 0x27, 0xFD + }, + { + 0x8F, 0xB3, 0x4F, 0xC8, 0xE0, 0xF5, 0x48, 0x75, + 0xBF, 0xE9, 0x81, 0x4D, 0x9E, 0x80, 0x4F, 0x5E, + 0x5A, 0xFD, 0x02, 0x9B, 0x5B, 0x93, 0x39, 0x0D, + 0x31, 0x81, 0x15, 0xCA, 0x9E, 0x78, 0xD8, 0x30 + }, + { + 0x85, 0xCF, 0x92, 0x3A, 0x78, 0x26, 0x9F, 0xBF, + 0xD3, 0x04, 0x5C, 0xC9, 0x7F, 0x65, 0x7A, 0x66, + 0x77, 0x83, 0x31, 0x1D, 0xA8, 0xA3, 0x08, 0x8C, + 0xD0, 0xDB, 0xD8, 0x2B, 0xC3, 0x98, 0xDD, 0xC0 + }, + { + 0x77, 0x31, 0x17, 0xAF, 0x25, 0x00, 0x6E, 0x80, + 0xD7, 0xA0, 0x80, 0xC3, 0x26, 0xAD, 0xFE, 0xB4, + 0x01, 0x23, 0x88, 0x3C, 0x97, 0xE9, 0xB4, 0x31, + 0x15, 0xEC, 0xCE, 0x33, 0xA7, 0xDB, 0x6E, 0x8F + }, + { + 0xE9, 0x13, 0x67, 0x4F, 0x76, 0x67, 0x72, 0x5E, + 0xB9, 0x1D, 0x1C, 0x4E, 0x5D, 0xDA, 0x91, 0xC8, + 0x42, 0x6A, 0xE7, 0x56, 0x8C, 0x85, 0x04, 0x94, + 0x56, 0xB0, 0x6D, 0x82, 0x50, 0x60, 0xA9, 0x7E + }, + { + 0xFD, 0xDF, 0xF3, 0xA4, 0xAB, 0x86, 0x1E, 0xA3, + 0xCA, 0x63, 0xEB, 0x14, 0x91, 0xD9, 0x83, 0x08, + 0xB9, 0x8C, 0xDB, 0x7B, 0x7F, 0x76, 0x6D, 0x69, + 0x4C, 0xC1, 0x32, 0x24, 0x97, 0x7B, 0x7D, 0x18 + }, + { + 0x85, 0x5E, 0x66, 0xF8, 0xA1, 0x8F, 0xB9, 0x3D, + 0xF7, 0x52, 0x20, 0xDF, 0x7C, 0x24, 0x9F, 0x62, + 0xDD, 0xE5, 0x83, 0x2F, 0x7D, 0x17, 0xDD, 0x47, + 0xE7, 0x15, 0xA4, 0x80, 0x71, 0x36, 0x89, 0xB6 + }, + { + 0x9D, 0x55, 0x3F, 0x26, 0xC2, 0xF7, 0x85, 0xC4, + 0xF2, 0x82, 0x57, 0xC1, 0x8E, 0x77, 0x1C, 0x90, + 0xB2, 0xF1, 0xEB, 0xBB, 0x08, 0x21, 0x93, 0x68, + 0x53, 0x89, 0x7E, 0x76, 0x15, 0x5B, 0x4A, 0x80 + }, + { + 0xC9, 0x61, 0x22, 0xDD, 0xDD, 0x97, 0x38, 0xEA, + 0x31, 0x9D, 0xC0, 0x34, 0xCA, 0x43, 0x61, 0x83, + 0xD3, 0xC8, 0x59, 0x02, 0x82, 0xF2, 0x24, 0xFA, + 0x97, 0x76, 0x18, 0x5E, 0x0A, 0x52, 0x35, 0x77 + }, + { + 0x3A, 0x2C, 0x40, 0xBC, 0xA6, 0xCD, 0xBC, 0x48, + 0xF7, 0xB1, 0x9E, 0xCA, 0xBE, 0xC8, 0xE2, 0xB0, + 0x26, 0x35, 0xF8, 0x2F, 0xA7, 0xC5, 0x5F, 0x22, + 0x4B, 0x75, 0x0A, 0x8A, 0xF0, 0x76, 0xF7, 0xAC + }, + { + 0xBD, 0xA6, 0xA9, 0x91, 0x4A, 0xB2, 0x65, 0x54, + 0xF1, 0xBC, 0x85, 0xF8, 0x47, 0xD1, 0x96, 0x90, + 0xF3, 0x4C, 0xC3, 0x7E, 0x85, 0x34, 0x3C, 0x80, + 0xED, 0xDE, 0x3B, 0x5F, 0x13, 0xCC, 0xAA, 0xF3 + }, + { + 0xD4, 0x9A, 0xDD, 0xBE, 0xB9, 0xAE, 0xBE, 0x38, + 0x89, 0x9E, 0x1A, 0x35, 0xA1, 0x27, 0x79, 0xF3, + 0x97, 0x76, 0x87, 0x5A, 0x07, 0x6F, 0x84, 0x1E, + 0xDE, 0xDE, 0x70, 0xBA, 0x9F, 0xC8, 0x98, 0x51 + }, + { + 0xAB, 0xC2, 0x3A, 0x8E, 0xAF, 0xE0, 0x94, 0x6F, + 0x5C, 0xEC, 0x67, 0x3D, 0xED, 0x10, 0x52, 0x43, + 0x1E, 0xCD, 0x6A, 0xDC, 0x82, 0x8D, 0x65, 0x20, + 0xC8, 0xF1, 0xAC, 0x27, 0xC1, 0x8C, 0x8D, 0x38 + }, + { + 0xAE, 0x6D, 0x16, 0x81, 0xDC, 0x02, 0xDB, 0x04, + 0x36, 0xB3, 0x0C, 0xC8, 0x86, 0xF0, 0x7A, 0xBB, + 0x08, 0x31, 0x58, 0x68, 0x8C, 0x84, 0xEF, 0xCC, + 0xB3, 0x2E, 0x69, 0xC6, 0x5F, 0xEE, 0xA9, 0x58 + }, + { + 0x58, 0x89, 0xA2, 0xD4, 0xE7, 0x68, 0xE4, 0x81, + 0xFB, 0x48, 0x4B, 0x87, 0x19, 0x07, 0x4F, 0x1C, + 0xA1, 0x24, 0x0E, 0x74, 0xCD, 0xA6, 0xEE, 0x34, + 0xDD, 0x78, 0x42, 0x9A, 0x4B, 0x00, 0x13, 0xE9 + }, + { + 0xA9, 0x01, 0x34, 0x3F, 0x54, 0xFB, 0x1D, 0x3C, + 0x83, 0x4C, 0x8A, 0xDD, 0x27, 0xAA, 0x40, 0x78, + 0x20, 0x41, 0xB6, 0xAD, 0xE8, 0x2B, 0x80, 0x72, + 0x0B, 0x0A, 0x60, 0x7F, 0xD5, 0x8C, 0xC9, 0x92 + }, + { + 0x35, 0xD8, 0xC6, 0x02, 0xCE, 0xAC, 0xD9, 0x3C, + 0x63, 0xD0, 0x67, 0xCB, 0x42, 0x04, 0x6B, 0x28, + 0x64, 0xCA, 0x27, 0xE3, 0x8E, 0x3B, 0x76, 0x8A, + 0x08, 0x89, 0x27, 0x7A, 0x8D, 0x20, 0x79, 0xBE + }, + { + 0x1C, 0xF6, 0x07, 0xD2, 0x18, 0x54, 0x38, 0xE0, + 0x83, 0x30, 0xEB, 0x85, 0xFC, 0xF7, 0xDC, 0xFD, + 0x00, 0x8A, 0x97, 0xF5, 0x4A, 0x5A, 0x9E, 0x9D, + 0xAF, 0x42, 0xD9, 0x86, 0x9E, 0x0E, 0x3A, 0xAA + }, + { + 0x0E, 0x32, 0x74, 0x7F, 0x6A, 0xF1, 0x59, 0xC9, + 0x49, 0xA6, 0x2D, 0x36, 0xD1, 0x52, 0x42, 0xA3, + 0x73, 0x3B, 0x8F, 0x29, 0xE0, 0xBF, 0x89, 0xDC, + 0xEF, 0x4B, 0xA5, 0x8A, 0x6E, 0x40, 0x34, 0x97 + }, + { + 0xD2, 0xCA, 0x7A, 0xBE, 0x0F, 0x40, 0x66, 0x84, + 0x20, 0x40, 0xB4, 0x4E, 0x2C, 0xFE, 0xD6, 0xD1, + 0x78, 0x9F, 0x9B, 0xE2, 0x80, 0xC8, 0x71, 0xF8, + 0x8D, 0x58, 0x78, 0x59, 0xB6, 0xBC, 0xED, 0x18 + }, + { + 0x73, 0x00, 0xC2, 0x39, 0x57, 0xBB, 0xF8, 0x3F, + 0x85, 0xF0, 0x0E, 0xE2, 0x03, 0x3E, 0xD3, 0x6C, + 0xFD, 0x0F, 0x97, 0x85, 0x72, 0xF8, 0x03, 0x39, + 0x68, 0xF4, 0x54, 0x98, 0x91, 0xDA, 0x72, 0x1B + }, + { + 0x3A, 0x49, 0x34, 0xAB, 0xC4, 0x51, 0xEB, 0x47, + 0x38, 0xA3, 0xFF, 0xE9, 0x40, 0x42, 0x3B, 0x22, + 0x17, 0x66, 0x43, 0xE1, 0x30, 0xCB, 0xD8, 0xB1, + 0x8D, 0xD3, 0x8A, 0x20, 0xB4, 0xA2, 0x97, 0xCD + }, + { + 0x20, 0xAA, 0x8D, 0xEC, 0x4C, 0xA8, 0x85, 0xC8, + 0x09, 0xF0, 0x21, 0x1F, 0x7B, 0x9A, 0x84, 0xF2, + 0x96, 0x6E, 0x93, 0x01, 0x96, 0x5E, 0x64, 0xEB, + 0x44, 0x9D, 0x78, 0xBE, 0x7E, 0xCD, 0x87, 0xC9 + }, + { + 0x11, 0x2C, 0x87, 0x17, 0x1F, 0xE0, 0x73, 0xA3, + 0xE6, 0x49, 0x21, 0x4E, 0xF7, 0xB7, 0xB1, 0xDF, + 0xDF, 0x61, 0x5A, 0xFF, 0x1E, 0x90, 0x0F, 0x9E, + 0xE0, 0x09, 0xE9, 0x8D, 0x92, 0x3B, 0xC6, 0xCC + }, + { + 0xB8, 0x96, 0x5D, 0xFB, 0x68, 0xDF, 0xEF, 0x8B, + 0x45, 0xE2, 0x59, 0x8A, 0xF8, 0x86, 0xB8, 0xAD, + 0xB1, 0x7E, 0xC3, 0x39, 0x4B, 0x41, 0xB2, 0x70, + 0xB2, 0xEA, 0xEB, 0xF6, 0x68, 0x85, 0x67, 0x52 + }, + { + 0x67, 0xEB, 0xB6, 0x73, 0xE7, 0xAB, 0x92, 0x2F, + 0xFD, 0x0E, 0x24, 0x65, 0x3B, 0xB4, 0x77, 0xFE, + 0x0E, 0xE2, 0xC3, 0x80, 0xE3, 0xC5, 0x6F, 0x45, + 0xEF, 0x86, 0x1A, 0x11, 0xBD, 0x79, 0x75, 0x82 + }, + { + 0xAF, 0xFE, 0xED, 0xC7, 0x8F, 0xEC, 0x5D, 0xF1, + 0xEC, 0xAD, 0x21, 0x99, 0x7D, 0x1C, 0x54, 0x19, + 0x58, 0xF5, 0x0B, 0x5A, 0x91, 0xDB, 0x32, 0xFA, + 0x82, 0x1C, 0x96, 0xDD, 0xE3, 0xDA, 0x33, 0xC6 + }, + { + 0x94, 0x77, 0x1E, 0x2E, 0xB3, 0x53, 0xB9, 0x4D, + 0xC7, 0x9C, 0x30, 0xBB, 0x15, 0x0C, 0x85, 0x16, + 0x90, 0x5F, 0x9D, 0x34, 0x97, 0xC6, 0x55, 0xFF, + 0x75, 0x57, 0x00, 0x2F, 0x0E, 0x6E, 0xFA, 0x2B + }, + { + 0xD4, 0x88, 0x3E, 0xC3, 0x6B, 0x22, 0xED, 0x03, + 0xAE, 0x29, 0x7D, 0x01, 0xC6, 0xAC, 0xEF, 0x97, + 0x22, 0x80, 0x2F, 0x73, 0x88, 0x61, 0xA6, 0xD2, + 0x8C, 0x49, 0xA3, 0xF2, 0x77, 0x05, 0x47, 0x32 + }, + { + 0x0A, 0x19, 0xB5, 0x2A, 0x47, 0x5E, 0x0C, 0x10, + 0xFF, 0x71, 0x18, 0xEC, 0xF8, 0x03, 0x0E, 0x91, + 0x35, 0x99, 0xB3, 0x6F, 0x1E, 0xE9, 0x18, 0x51, + 0xAD, 0xE0, 0x92, 0x41, 0xCC, 0xF5, 0x1B, 0x7D + }, + { + 0x1A, 0x15, 0x6D, 0xB7, 0x88, 0x8D, 0x75, 0xB4, + 0xEF, 0xD0, 0xF9, 0xC3, 0x5A, 0xE2, 0x80, 0x6D, + 0x10, 0x7C, 0x2D, 0xCD, 0x23, 0x2C, 0x77, 0x83, + 0x3C, 0x64, 0x0B, 0x65, 0xCF, 0x85, 0xE1, 0x48 + }, + { + 0xE8, 0x90, 0xCC, 0xF7, 0x08, 0x0D, 0xDF, 0x35, + 0x3E, 0x9B, 0x13, 0x55, 0x92, 0x2D, 0x86, 0x63, + 0x3C, 0x8E, 0x81, 0x28, 0x53, 0xF9, 0x15, 0xC2, + 0xC4, 0x9C, 0xE3, 0x52, 0x10, 0x31, 0xAB, 0x31 + }, + { + 0x3C, 0xD9, 0x66, 0xEC, 0xFE, 0x24, 0x37, 0xA7, + 0x5A, 0x66, 0x1E, 0xA1, 0x65, 0xAB, 0xD1, 0xC2, + 0x43, 0xFA, 0xCF, 0x73, 0xAF, 0xF0, 0x0F, 0xE3, + 0x91, 0x50, 0xEA, 0x10, 0xD2, 0x9E, 0xCA, 0x15 + }, + { + 0x37, 0xA5, 0x3C, 0x23, 0x6D, 0xE3, 0x5A, 0x24, + 0x45, 0x89, 0xAB, 0xA2, 0xB0, 0x99, 0x32, 0x94, + 0xC3, 0x13, 0x8A, 0x45, 0x5D, 0x99, 0x5A, 0x02, + 0xEA, 0x29, 0x61, 0xC5, 0xAD, 0xDB, 0xD5, 0xFA + }, + { + 0x96, 0x68, 0xF9, 0x37, 0x10, 0x45, 0x95, 0x24, + 0x7F, 0x25, 0xB8, 0xD5, 0xC8, 0xBC, 0xAE, 0x57, + 0x72, 0x4C, 0x06, 0x40, 0xFB, 0xC6, 0x22, 0xF7, + 0x61, 0x08, 0x78, 0x55, 0xD9, 0x34, 0xC6, 0xDC + }, + { + 0x74, 0x0B, 0x4F, 0x98, 0x9F, 0x1D, 0xE9, 0x95, + 0x1C, 0xC1, 0x8C, 0xA2, 0x00, 0x61, 0xD4, 0xFC, + 0x55, 0xA4, 0xF4, 0xCD, 0x85, 0x9B, 0xB2, 0x99, + 0x93, 0x35, 0xFB, 0xC6, 0xFB, 0x67, 0x95, 0x84 + }, + { + 0xAF, 0x36, 0x9C, 0x0C, 0xEC, 0xB6, 0xBC, 0xD4, + 0xCE, 0xDB, 0x5C, 0x3C, 0x0A, 0xE0, 0x20, 0xEF, + 0x2A, 0x2B, 0x9D, 0x2F, 0x2D, 0x96, 0x66, 0xD0, + 0xD9, 0xF3, 0xA4, 0x51, 0x6D, 0x6E, 0x57, 0xE1 + }, + { + 0x72, 0x1D, 0x5A, 0x04, 0x45, 0xF8, 0x26, 0x95, + 0x0B, 0x97, 0xC0, 0xB8, 0x03, 0xCC, 0xEA, 0x9F, + 0xCE, 0x64, 0x4F, 0xEA, 0xAA, 0xAC, 0x2A, 0xD1, + 0xBE, 0xA7, 0xB7, 0x5E, 0x86, 0x85, 0x74, 0xC1 + }, + { + 0xC3, 0x5F, 0x5A, 0xE2, 0x0C, 0x93, 0x39, 0x6D, + 0x44, 0xDC, 0xC9, 0x95, 0xD3, 0x74, 0xB0, 0xBD, + 0xAD, 0xD8, 0x90, 0xF6, 0x5F, 0xA4, 0xC0, 0x94, + 0x3C, 0x81, 0x71, 0x70, 0x14, 0xE6, 0xE0, 0x4B + }, + { + 0x8B, 0xE6, 0xA8, 0xF1, 0xF4, 0x78, 0xD7, 0xAB, + 0x3B, 0x8B, 0x50, 0x33, 0xDC, 0x29, 0x41, 0x04, + 0x20, 0x7E, 0xD7, 0xCC, 0x40, 0x7D, 0x6F, 0x26, + 0x12, 0xCD, 0x24, 0xF2, 0xBF, 0x0D, 0xA8, 0x50 + }, + { + 0x21, 0x81, 0x18, 0xF9, 0x68, 0xA1, 0x61, 0xFE, + 0xA9, 0x8F, 0x6B, 0x78, 0x0B, 0xC1, 0x49, 0x9A, + 0xDF, 0xCB, 0x0D, 0x1E, 0x76, 0x9D, 0x9A, 0xDB, + 0xBD, 0x57, 0x1F, 0xA9, 0xC8, 0x20, 0x30, 0x10 + }, + { + 0x89, 0x75, 0xB7, 0xAD, 0x01, 0x57, 0x8E, 0x4A, + 0xE7, 0x04, 0x6A, 0xA4, 0xDE, 0x4F, 0x49, 0x50, + 0xB3, 0x9D, 0x33, 0xE3, 0xB5, 0x89, 0x23, 0x8B, + 0x45, 0x51, 0x2C, 0xE6, 0xA6, 0x0E, 0xDD, 0x56 + }, + { + 0x4B, 0xF8, 0xB6, 0x55, 0x73, 0xD5, 0x9E, 0xDB, + 0xA3, 0xE1, 0x57, 0xBB, 0xC7, 0xE2, 0x9D, 0x34, + 0xDD, 0x5B, 0x22, 0x50, 0x32, 0x8D, 0xCA, 0x32, + 0x56, 0x0B, 0x70, 0xD3, 0xA9, 0xF3, 0x4A, 0x51 + }, + { + 0x14, 0x62, 0xF5, 0x3F, 0x89, 0xB7, 0x31, 0x85, + 0xE7, 0x4B, 0x08, 0x4C, 0x12, 0x00, 0xB8, 0x76, + 0xC7, 0xD6, 0xDA, 0x18, 0x9B, 0x77, 0xB3, 0x0F, + 0x6B, 0x58, 0x30, 0xC8, 0x1A, 0x5D, 0x22, 0xA7 + }, + { + 0x80, 0xBF, 0xED, 0xED, 0x08, 0xBE, 0x61, 0xC7, + 0x99, 0xB7, 0x47, 0xA7, 0x06, 0x85, 0x94, 0x78, + 0xF7, 0xA2, 0xC4, 0xEA, 0x84, 0xA7, 0xBF, 0xD2, + 0x6E, 0x66, 0xFC, 0x58, 0x02, 0x46, 0x0C, 0x98 + }, + { + 0x7C, 0x44, 0xA6, 0x2D, 0xED, 0x67, 0x8B, 0xB4, + 0x6F, 0xBD, 0x95, 0x5F, 0xDA, 0x60, 0x96, 0x67, + 0xA6, 0xE5, 0x46, 0x97, 0x1E, 0xD4, 0xD3, 0xB0, + 0xB1, 0xC0, 0xFA, 0x9A, 0x5F, 0xC5, 0x1D, 0x26 + }, + { + 0x37, 0xF1, 0xC8, 0x3B, 0x15, 0xFB, 0x5F, 0x78, + 0x9E, 0x9E, 0xE5, 0x00, 0xA3, 0xF5, 0xDC, 0xCB, + 0x62, 0xDB, 0xCB, 0xF3, 0x80, 0xF7, 0x00, 0x2A, + 0x3A, 0x21, 0x66, 0xF3, 0xAF, 0x38, 0x3C, 0xED + }, + { + 0x25, 0x17, 0x67, 0x79, 0x69, 0x4A, 0xB6, 0x45, + 0x27, 0x3F, 0xC6, 0xE0, 0x4F, 0xC0, 0xC0, 0x47, + 0xFB, 0x4D, 0xD6, 0x88, 0xE0, 0x3A, 0xDD, 0x52, + 0xA6, 0x07, 0x79, 0x8A, 0x03, 0x4F, 0x56, 0x18 + }, + { + 0xBF, 0xB2, 0x9A, 0xC6, 0x99, 0x96, 0x62, 0xC3, + 0xD6, 0x00, 0xF3, 0x41, 0x2F, 0x6A, 0xAF, 0x96, + 0x19, 0x74, 0x18, 0xE8, 0xD2, 0xC3, 0x1D, 0x08, + 0x93, 0xFC, 0xE4, 0xD9, 0x30, 0x57, 0x0F, 0x58 + }, + { + 0x1F, 0xCA, 0xEF, 0x9B, 0x8E, 0xAB, 0x33, 0xF3, + 0xAA, 0x17, 0xD7, 0x95, 0x1D, 0x8F, 0xD3, 0x6D, + 0xE1, 0xB2, 0xEA, 0x4E, 0x24, 0x5C, 0x44, 0x80, + 0x75, 0x5E, 0x5B, 0x97, 0x18, 0xB0, 0xD3, 0x2D + }, + { + 0xA0, 0x6C, 0x53, 0x1D, 0xE6, 0xAD, 0x9E, 0x55, + 0xBD, 0x10, 0x72, 0xE9, 0xFB, 0xE5, 0xF8, 0x85, + 0x90, 0x9B, 0xB2, 0x34, 0x3B, 0xD6, 0x8E, 0xD9, + 0x3C, 0x60, 0x30, 0x07, 0x6C, 0x7B, 0xE2, 0x2A + }, + { + 0xD3, 0xF3, 0x9D, 0x4F, 0xD1, 0x83, 0x44, 0x67, + 0xD6, 0x5F, 0x13, 0xF7, 0xFF, 0x78, 0x9E, 0xD3, + 0x60, 0x78, 0xE0, 0xE7, 0xDF, 0x0F, 0x1A, 0xC1, + 0x6E, 0x87, 0xFE, 0xF3, 0xF3, 0xCC, 0xD4, 0xF0 + }, + { + 0xD3, 0x9C, 0x0C, 0x8E, 0x91, 0xAA, 0x8A, 0x03, + 0xDB, 0xF1, 0x05, 0x66, 0x2E, 0x3D, 0x95, 0x92, + 0xA3, 0xE4, 0xE6, 0xEE, 0x92, 0x34, 0x02, 0x61, + 0xAF, 0x66, 0xBC, 0x3B, 0x0A, 0x0A, 0x37, 0xBC + }, + { + 0xE4, 0xBE, 0xA0, 0x5A, 0xE7, 0x92, 0x38, 0x32, + 0x36, 0x00, 0xA2, 0xDA, 0x2D, 0xFF, 0x45, 0xF6, + 0x98, 0xCD, 0x11, 0x51, 0x27, 0xBC, 0x47, 0x4E, + 0x66, 0x21, 0xFE, 0x94, 0x72, 0x34, 0x78, 0xD1 + }, + { + 0x00, 0xBE, 0x46, 0xFB, 0xB2, 0x48, 0x68, 0xA9, + 0x59, 0xAF, 0x35, 0x27, 0xE5, 0xF2, 0xA4, 0xA6, + 0x95, 0x82, 0xC7, 0x51, 0x46, 0x6A, 0xCC, 0x7F, + 0x58, 0x33, 0xBA, 0xB7, 0x00, 0x1C, 0x80, 0x59 + }, + { + 0x74, 0x6F, 0x3F, 0xB8, 0x31, 0x1E, 0x0D, 0xA1, + 0xCB, 0x38, 0xAA, 0xE5, 0x3C, 0xF5, 0x3F, 0xEE, + 0xEA, 0x76, 0x96, 0xD9, 0x1D, 0x52, 0xDC, 0xD4, + 0xD4, 0x4B, 0xA2, 0x8B, 0x90, 0x33, 0xBE, 0x88 + }, + { + 0x43, 0x39, 0xA2, 0xC6, 0x01, 0xFA, 0x05, 0x42, + 0xED, 0xF5, 0xF9, 0x71, 0x3F, 0x57, 0x31, 0x9E, + 0x29, 0xC5, 0x49, 0x04, 0x6A, 0xB9, 0xE3, 0x71, + 0xC8, 0x24, 0xFB, 0xE7, 0x05, 0xAF, 0x8F, 0x04 + }, + { + 0x15, 0xAC, 0xD0, 0x07, 0xE8, 0x43, 0x5E, 0x1E, + 0x1C, 0xBC, 0xC6, 0xED, 0xE6, 0x07, 0x87, 0x5A, + 0x11, 0x38, 0xE7, 0x9C, 0x5F, 0x42, 0x62, 0x30, + 0x76, 0x33, 0x00, 0xC0, 0xFD, 0x4C, 0xE1, 0x40 + }, + { + 0x1E, 0x20, 0x2E, 0x46, 0x3A, 0x19, 0x68, 0x68, + 0x6B, 0xAB, 0x35, 0xD4, 0xEB, 0xA3, 0x89, 0xAF, + 0xD5, 0x30, 0xB4, 0x3B, 0x67, 0xA2, 0x85, 0xFD, + 0x4F, 0x82, 0x16, 0x47, 0x54, 0x91, 0x7B, 0x50 + }, + { + 0x3C, 0x5A, 0x0E, 0x5C, 0xC5, 0x8B, 0xE7, 0x6C, + 0x55, 0x2A, 0xA1, 0x14, 0x7C, 0x9B, 0x2F, 0x89, + 0x43, 0xDF, 0xA3, 0x07, 0x27, 0x65, 0xA1, 0xD6, + 0x55, 0x00, 0x7D, 0x8B, 0x7E, 0xCE, 0x72, 0x6E + }, + { + 0xFD, 0x6E, 0x46, 0xB9, 0x50, 0xC7, 0x57, 0x9D, + 0xA4, 0x15, 0x39, 0x78, 0xDE, 0x89, 0x6F, 0x25, + 0xA2, 0x40, 0x54, 0xAF, 0xBE, 0x74, 0xF4, 0x4B, + 0xAB, 0x3C, 0x41, 0xF5, 0x6E, 0xD2, 0xAE, 0x51 + }, + { + 0x5B, 0x09, 0x2D, 0x30, 0xD6, 0x68, 0xD0, 0x46, + 0xBC, 0x06, 0x24, 0xA5, 0x13, 0x32, 0x0F, 0xBA, + 0x8D, 0x9F, 0x8E, 0x5F, 0x55, 0x76, 0x8E, 0xAD, + 0x7B, 0xB0, 0x95, 0xAC, 0x74, 0x1C, 0x35, 0x29 + }, + { + 0xEF, 0x55, 0xA6, 0xF5, 0x0E, 0xC2, 0xF5, 0x6D, + 0x2F, 0x68, 0x7B, 0x48, 0x7F, 0xA0, 0x70, 0x75, + 0x5F, 0x50, 0xD2, 0x4C, 0xB1, 0x31, 0x46, 0x7A, + 0xF4, 0xA0, 0xDA, 0x2D, 0xA8, 0x95, 0x08, 0x08 + }, + { + 0x4D, 0x3E, 0x9A, 0xBB, 0x9C, 0x48, 0x09, 0xFE, + 0xF1, 0x01, 0x83, 0x32, 0x0E, 0x11, 0x65, 0x8B, + 0xBF, 0xDB, 0x14, 0x8D, 0x20, 0xFA, 0xBB, 0xF9, + 0xD1, 0xC6, 0x7A, 0xDA, 0x63, 0x6F, 0xD3, 0x13 + }, + { + 0xA6, 0x66, 0x4D, 0x40, 0x48, 0xFC, 0xE5, 0x7A, + 0xC2, 0x21, 0xF7, 0x4A, 0x85, 0xDB, 0xDD, 0x7A, + 0x42, 0x44, 0x10, 0x72, 0xB2, 0x6D, 0xD9, 0x3C, + 0xA7, 0xBA, 0x6C, 0xD8, 0x4A, 0xAA, 0x06, 0xAC + }, + { + 0x4F, 0x9B, 0xED, 0x3F, 0x44, 0x7A, 0x57, 0xCA, + 0xB3, 0x10, 0x7C, 0x7C, 0x9F, 0x6B, 0x25, 0x09, + 0x52, 0x42, 0xB3, 0xA3, 0x06, 0x17, 0x9C, 0x63, + 0x2D, 0x54, 0x1D, 0x66, 0xFD, 0xFF, 0x88, 0xC2 + }, + { + 0xA9, 0x58, 0xFB, 0x28, 0xB6, 0x92, 0x9A, 0x98, + 0x29, 0xBB, 0x19, 0x52, 0x42, 0x97, 0x3F, 0x57, + 0xB4, 0x3D, 0xE3, 0x12, 0x91, 0xA8, 0xB9, 0x37, + 0xF1, 0x0C, 0xCF, 0x2F, 0x41, 0xB7, 0x52, 0x4F + }, + { + 0xA0, 0xE9, 0x68, 0xDC, 0x35, 0xED, 0x9F, 0x59, + 0x33, 0xDC, 0x02, 0x87, 0xC4, 0x28, 0xAD, 0x87, + 0xF8, 0xDF, 0x20, 0xFB, 0xF7, 0x99, 0xB9, 0x8E, + 0x4F, 0x26, 0xE2, 0x58, 0xA5, 0x08, 0x30, 0xB6 + }, + { + 0x55, 0x7F, 0x3C, 0x3C, 0xAB, 0x7C, 0x66, 0x66, + 0xD7, 0x3F, 0x4B, 0xDF, 0xC2, 0x20, 0xF5, 0x69, + 0xC1, 0xD0, 0x77, 0xE3, 0x2C, 0x0F, 0xEA, 0x77, + 0xDF, 0x44, 0x26, 0x3B, 0x5F, 0x30, 0x96, 0xC1 + }, + { + 0x2B, 0x16, 0xF5, 0xE8, 0x4E, 0x6C, 0xA5, 0xBE, + 0xC6, 0x96, 0x44, 0x68, 0xB4, 0xD3, 0xF7, 0x37, + 0xB7, 0x07, 0x5A, 0x45, 0x72, 0xC1, 0x85, 0x57, + 0xB9, 0x95, 0x8C, 0x91, 0xB6, 0xB2, 0x69, 0xA2 + }, + { + 0x58, 0xDA, 0x96, 0xA8, 0x41, 0x1E, 0xD4, 0xD1, + 0x72, 0x9A, 0x18, 0x8D, 0x1C, 0xAB, 0xC5, 0x74, + 0x7F, 0xF7, 0xD6, 0xF8, 0x27, 0xF3, 0xB8, 0xA0, + 0x14, 0xAB, 0x0C, 0xC6, 0xF1, 0x5B, 0x84, 0xCB + }, + { + 0xF7, 0x2C, 0x02, 0x5F, 0x6B, 0xF7, 0xAC, 0x8D, + 0xEA, 0x05, 0x39, 0xEE, 0x86, 0x78, 0x69, 0x1E, + 0xD2, 0x6F, 0xDF, 0x9E, 0x06, 0xF6, 0xBA, 0x6E, + 0xEB, 0x13, 0x19, 0x09, 0xF5, 0x9F, 0x2B, 0x3C + }, + { + 0xDE, 0x45, 0x0B, 0x5F, 0xB6, 0x24, 0x2A, 0x97, + 0x7A, 0x76, 0xE3, 0x27, 0xAA, 0x9A, 0x18, 0xF0, + 0x30, 0x61, 0xD8, 0x33, 0x9F, 0xDC, 0x3D, 0xCD, + 0xFF, 0x5C, 0x1A, 0x60, 0xC5, 0xE5, 0xFC, 0xD5 + }, + { + 0x0E, 0xA7, 0xD5, 0xCE, 0xAB, 0xD3, 0x8D, 0x59, + 0x1E, 0x49, 0xB4, 0xB7, 0x69, 0x72, 0xFF, 0x72, + 0x3B, 0x7F, 0x0D, 0x2E, 0xEC, 0x7E, 0x4A, 0xCF, + 0x82, 0xDE, 0x90, 0x8E, 0x99, 0x81, 0xAA, 0xC3 + }, + { + 0x60, 0x35, 0x00, 0x06, 0xBE, 0xC1, 0x12, 0x99, + 0xBF, 0x68, 0x4B, 0x49, 0xB8, 0x7B, 0x6F, 0x99, + 0xF7, 0x8C, 0xAB, 0xD2, 0x80, 0x86, 0x85, 0x3A, + 0x31, 0xFA, 0x63, 0xB0, 0x33, 0xED, 0xC8, 0xF0 + }, + { + 0x88, 0xAA, 0x87, 0x70, 0x6E, 0x17, 0xFB, 0xC1, + 0x91, 0x1C, 0x32, 0xAE, 0xE7, 0x4F, 0xFB, 0x7E, + 0x08, 0xC6, 0x4A, 0x4F, 0xDE, 0xC2, 0x7B, 0x86, + 0xC2, 0xAD, 0xBE, 0xFB, 0x0E, 0x41, 0xF4, 0x8C + }, + { + 0xA9, 0xB1, 0x1D, 0x27, 0xCD, 0x68, 0x96, 0xAA, + 0xC5, 0x84, 0xAE, 0x19, 0x1F, 0x35, 0x86, 0x5D, + 0x22, 0xA1, 0xA7, 0x55, 0x3C, 0xD5, 0x92, 0x1D, + 0x1F, 0x38, 0xF0, 0x48, 0x45, 0x11, 0x15, 0x46 + }, + { + 0xB1, 0xF2, 0x44, 0x2C, 0xED, 0x46, 0x88, 0x8B, + 0xAC, 0xC3, 0xB5, 0x99, 0x7E, 0x0A, 0xAF, 0x90, + 0x9F, 0xC9, 0x8A, 0x15, 0x82, 0x41, 0x70, 0x60, + 0x65, 0xB8, 0x10, 0x66, 0x4E, 0xE6, 0x0E, 0x17 + }, + { + 0x20, 0xFC, 0x58, 0x5F, 0xC8, 0xCF, 0x2D, 0xF0, + 0x49, 0x51, 0x13, 0x4B, 0x85, 0x5E, 0x1C, 0x60, + 0xD2, 0x7F, 0x71, 0x44, 0xBF, 0x88, 0xD6, 0x8F, + 0x6C, 0xA2, 0x8D, 0x60, 0x9F, 0xE8, 0x10, 0x71 + }, + { + 0xD0, 0x3C, 0xF1, 0xC4, 0xF3, 0xA9, 0xA9, 0x82, + 0x3E, 0xE4, 0x3A, 0xCB, 0xA9, 0x7D, 0x57, 0x7F, + 0x93, 0x06, 0x73, 0x1B, 0x9C, 0x1C, 0x09, 0x2C, + 0x11, 0x4F, 0x2F, 0x1D, 0x17, 0xB8, 0xF7, 0x8C + }, + { + 0xB0, 0xE0, 0x7A, 0x68, 0x96, 0xB5, 0x96, 0xC4, + 0xC7, 0xA8, 0x8B, 0xDA, 0xA6, 0xBB, 0x61, 0xBA, + 0xDF, 0x87, 0xE2, 0x55, 0xF9, 0x17, 0x8E, 0xF7, + 0xB2, 0x16, 0xD5, 0x82, 0x27, 0x06, 0x3A, 0xC7 + }, + { + 0xE7, 0x8B, 0x07, 0xDF, 0xA1, 0xFD, 0xFE, 0xDA, + 0x7C, 0x61, 0x7D, 0x76, 0x4E, 0xF8, 0x63, 0xB4, + 0x08, 0x9A, 0x7A, 0x56, 0xAE, 0x3F, 0x62, 0xB5, + 0xE3, 0xEF, 0xC6, 0x87, 0x3C, 0xE6, 0xDC, 0xF3 + }, + { + 0xF0, 0xBF, 0x1C, 0x2B, 0x64, 0xEE, 0x14, 0x4D, + 0x53, 0x99, 0x2B, 0x7D, 0xEF, 0x97, 0x42, 0x9A, + 0x4E, 0x8D, 0x52, 0x1E, 0x04, 0x4B, 0x5F, 0xB7, + 0xF3, 0xB8, 0x68, 0x29, 0x1C, 0xE6, 0xFC, 0x58 + }, + { + 0x0A, 0xCD, 0xDD, 0x61, 0x6F, 0xF5, 0x76, 0xF5, + 0xE4, 0xDD, 0x40, 0x47, 0x8D, 0xB5, 0x6A, 0xE2, + 0xCC, 0x0F, 0x85, 0xDE, 0x2A, 0x5E, 0xE1, 0x97, + 0x61, 0x52, 0x74, 0xFB, 0xAA, 0xB9, 0xFE, 0x68 + }, + { + 0x85, 0xD4, 0x64, 0x18, 0xE7, 0xCF, 0xDB, 0xC9, + 0x91, 0x9C, 0x77, 0x3C, 0x30, 0x9B, 0xB8, 0x28, + 0x4B, 0xEF, 0x7B, 0x6B, 0x27, 0x30, 0x3A, 0x95, + 0xA2, 0xA6, 0x2E, 0x64, 0x3A, 0xFB, 0x19, 0xD1 + }, + { + 0xC4, 0x82, 0x44, 0x2F, 0x3D, 0xF9, 0x78, 0xC6, + 0x31, 0xB6, 0xE6, 0x5D, 0xA7, 0x35, 0xA1, 0x69, + 0xEE, 0x1B, 0xF3, 0x11, 0xC9, 0xD7, 0x1B, 0xD3, + 0x5E, 0x30, 0xFF, 0x26, 0x99, 0x7F, 0xCE, 0x42 + }, + { + 0xE3, 0x62, 0xE5, 0x4C, 0xF3, 0xD6, 0xBB, 0x02, + 0x74, 0x34, 0x38, 0xA6, 0x95, 0x00, 0x33, 0x5D, + 0x60, 0xB1, 0x5C, 0x2D, 0x64, 0x90, 0xD2, 0x44, + 0x98, 0x66, 0xA0, 0x56, 0x86, 0x0B, 0x7A, 0x9B + }, + { + 0x13, 0xEA, 0x04, 0xE8, 0xCA, 0xC0, 0x37, 0x25, + 0x52, 0x5C, 0x82, 0x20, 0xD3, 0xDE, 0xE9, 0x39, + 0xB8, 0xD6, 0x1B, 0xCA, 0xCC, 0x84, 0x9B, 0x1B, + 0x75, 0xFD, 0xFD, 0x77, 0x18, 0xCE, 0xC1, 0x85 + }, + { + 0x92, 0x47, 0x2F, 0xB7, 0xAA, 0xBE, 0x1F, 0xA0, + 0x22, 0x61, 0xA1, 0x07, 0x9C, 0x00, 0xCD, 0xDE, + 0xC6, 0x0E, 0x3E, 0xC4, 0x66, 0x00, 0xDA, 0x7D, + 0x2A, 0x50, 0x76, 0x98, 0x57, 0xF6, 0xC6, 0xB4 + }, + { + 0xA3, 0x45, 0x63, 0xE5, 0xC4, 0x5C, 0xB2, 0x9E, + 0x6E, 0xC2, 0xFB, 0x8E, 0x49, 0x0C, 0x71, 0x61, + 0xE1, 0x12, 0x12, 0xA8, 0xEA, 0x6B, 0x0A, 0x57, + 0x60, 0xEA, 0x73, 0x23, 0x72, 0xE2, 0xE9, 0x63 + }, + { + 0x9D, 0x77, 0xB8, 0x70, 0x2D, 0x72, 0x38, 0x6A, + 0xC6, 0x30, 0x49, 0x01, 0x97, 0x1E, 0xF1, 0x96, + 0x44, 0x71, 0x6B, 0x1B, 0xFA, 0x25, 0xA6, 0xCC, + 0x7C, 0xDB, 0xB5, 0x89, 0x6C, 0x10, 0xA4, 0x8B + }, + { + 0xEA, 0x9E, 0xA4, 0x26, 0xD6, 0xF3, 0x45, 0x20, + 0x69, 0xC1, 0x93, 0x47, 0x2B, 0xA5, 0x86, 0x4B, + 0xFB, 0x8F, 0x40, 0xD4, 0x84, 0x51, 0xBA, 0x40, + 0x77, 0x35, 0xB9, 0xA7, 0x0C, 0xDF, 0x15, 0x71 + }, + { + 0x8D, 0xEA, 0x35, 0xD1, 0x1A, 0x23, 0x90, 0x74, + 0x31, 0xD6, 0x8C, 0x8D, 0x70, 0x2F, 0xE9, 0x0E, + 0xF5, 0x09, 0x4C, 0x34, 0x41, 0xAF, 0xB8, 0xC3, + 0xE4, 0x25, 0x2E, 0xAB, 0xB9, 0x3B, 0x42, 0x83 + }, + { + 0x62, 0x18, 0x7E, 0xC3, 0x6D, 0x66, 0x5B, 0x3C, + 0xD4, 0xBF, 0x7D, 0xB1, 0xC4, 0xCF, 0xBA, 0x72, + 0xEC, 0x2D, 0x4C, 0xBC, 0x41, 0x99, 0x54, 0xE9, + 0x81, 0x30, 0xAC, 0xBC, 0xB2, 0xB5, 0xD7, 0x0A + }, + { + 0x81, 0x8C, 0x42, 0xCB, 0x6B, 0x93, 0x6D, 0x84, + 0xF5, 0x02, 0x18, 0x2F, 0xD1, 0xA1, 0xB4, 0x36, + 0x38, 0xC6, 0x43, 0xB1, 0xFB, 0x12, 0xE5, 0x80, + 0xB3, 0xC5, 0x17, 0xE4, 0x41, 0x58, 0x64, 0x88 + }, + { + 0x55, 0x4D, 0x77, 0xDE, 0x26, 0xA9, 0xA2, 0x86, + 0x36, 0x1F, 0x01, 0x11, 0x59, 0x22, 0x42, 0x43, + 0x40, 0x06, 0xDB, 0x53, 0x94, 0x3D, 0xAA, 0x6A, + 0xC7, 0xC0, 0xE7, 0x5B, 0xF4, 0x83, 0x91, 0xE7 + }, + { + 0xF7, 0x56, 0x65, 0xD9, 0x61, 0x7F, 0x74, 0x30, + 0xBD, 0x47, 0xFC, 0x95, 0xA9, 0x86, 0xF5, 0x7D, + 0x4B, 0xB6, 0x2E, 0x77, 0x77, 0x6F, 0x49, 0x1F, + 0xCF, 0x60, 0x16, 0x7C, 0x59, 0xAA, 0xBC, 0x83 + }, + { + 0xB2, 0x5C, 0x28, 0x3B, 0xF1, 0x0C, 0xFE, 0x36, + 0x65, 0x9F, 0x4A, 0x20, 0x54, 0xDD, 0x47, 0x6C, + 0x1A, 0x7B, 0x30, 0xB2, 0x22, 0x67, 0x29, 0x45, + 0x42, 0xCA, 0xDB, 0x73, 0xB1, 0xB9, 0x49, 0xC1 + }, + { + 0x27, 0xF1, 0x8D, 0x01, 0xAB, 0x81, 0xCC, 0x69, + 0x88, 0x4F, 0x80, 0x28, 0x8E, 0x34, 0x42, 0x01, + 0x77, 0xBB, 0xC1, 0xB9, 0x3D, 0x43, 0xC8, 0xE0, + 0x8E, 0x6A, 0xD3, 0xDA, 0xB8, 0x10, 0x4F, 0xA5 + }, + { + 0x4C, 0x33, 0xF0, 0x8E, 0x09, 0x5F, 0xFA, 0xDD, + 0x29, 0xF9, 0x32, 0x4E, 0x86, 0x65, 0x68, 0x86, + 0x94, 0xE2, 0x2D, 0xB5, 0x14, 0xBC, 0x40, 0xE7, + 0x66, 0x0B, 0x8F, 0x74, 0x8E, 0xE9, 0x27, 0x7F + }, + { + 0xB7, 0xB4, 0xA1, 0xBD, 0x5C, 0x8B, 0xED, 0x83, + 0x09, 0x70, 0xEE, 0x49, 0xEA, 0xEB, 0x01, 0x60, + 0x3C, 0x31, 0x37, 0xA1, 0x37, 0xED, 0x3F, 0xF7, + 0xEA, 0x47, 0xC1, 0x4E, 0x91, 0x79, 0xC4, 0x56 + }, + { + 0x6C, 0x7F, 0x3D, 0x70, 0xC4, 0xF7, 0x2C, 0x29, + 0xA7, 0xE3, 0x75, 0x12, 0x19, 0x06, 0x69, 0x59, + 0xC3, 0x83, 0xB3, 0x6F, 0x73, 0xD0, 0x87, 0xBC, + 0x1A, 0x06, 0xB7, 0xFA, 0x42, 0xF7, 0xFA, 0xB0 + }, + { + 0x2A, 0xE7, 0xCB, 0x86, 0xB5, 0xD5, 0xB5, 0x04, + 0x11, 0xFD, 0xAB, 0x6E, 0xF3, 0x22, 0x5F, 0x5D, + 0x5B, 0x05, 0xD0, 0xAD, 0x33, 0x12, 0xA6, 0x25, + 0xC4, 0x1B, 0x79, 0x07, 0x8B, 0xE4, 0xB7, 0x13 + }, + { + 0x5C, 0x9A, 0xD2, 0xFB, 0x85, 0x08, 0xFA, 0x5B, + 0x76, 0x3B, 0xF1, 0x04, 0xDA, 0x8D, 0xD8, 0x8E, + 0xEF, 0x91, 0xE0, 0xBB, 0x07, 0xE7, 0x1F, 0xCD, + 0xB4, 0xF6, 0x9D, 0x76, 0x15, 0xF8, 0x4A, 0x6D + }, + { + 0x9E, 0x7E, 0x37, 0x14, 0x8D, 0xFE, 0x86, 0xD3, + 0xE6, 0x0B, 0xB6, 0xE2, 0xA9, 0xE1, 0xEB, 0x25, + 0x44, 0x70, 0x20, 0x44, 0x05, 0x15, 0x4A, 0x1C, + 0xD9, 0xFA, 0x2D, 0x76, 0x2B, 0xF5, 0xC4, 0x2A + }, + { + 0xE5, 0x63, 0x51, 0xD6, 0x52, 0xF1, 0x31, 0xCF, + 0xB5, 0xDC, 0x0E, 0x8C, 0xA7, 0x4F, 0xCF, 0xBA, + 0x1F, 0xB3, 0x4C, 0xC0, 0xC1, 0x66, 0xC2, 0x8F, + 0x2A, 0xAA, 0x18, 0xE9, 0x7C, 0x49, 0x92, 0x96 + }, + { + 0xF1, 0xD5, 0x5F, 0x69, 0xE3, 0x85, 0x79, 0x1D, + 0xD2, 0xD3, 0x8B, 0x63, 0x2F, 0x71, 0xE1, 0x85, + 0x3D, 0xDB, 0x30, 0xBB, 0xA4, 0xDE, 0xB1, 0xC0, + 0x3B, 0x0B, 0x87, 0x4F, 0xA3, 0x45, 0xD4, 0x3B + }, + { + 0xB5, 0xA5, 0x7F, 0xB2, 0xFB, 0x98, 0x89, 0x14, + 0xF7, 0x9F, 0x98, 0x7D, 0x18, 0xFB, 0x86, 0x01, + 0x4E, 0x1A, 0x80, 0x48, 0x6C, 0x7A, 0x68, 0xDE, + 0x82, 0x06, 0x6A, 0x37, 0xBC, 0x03, 0xFC, 0xFB + }, + { + 0xFE, 0x7B, 0x59, 0xA9, 0x33, 0xC6, 0x02, 0x5C, + 0x1E, 0x6C, 0x8D, 0x31, 0xD7, 0x12, 0x73, 0x48, + 0x5C, 0x44, 0xA7, 0x74, 0xC9, 0x77, 0xAC, 0x18, + 0x4B, 0x5B, 0xC4, 0xC5, 0x22, 0x8C, 0x4E, 0xC2 + }, + { + 0xDB, 0x86, 0x4D, 0xC0, 0x1E, 0xA8, 0x50, 0xD0, + 0x29, 0xA1, 0x44, 0x93, 0xC9, 0xF1, 0x06, 0xB5, + 0x19, 0xFD, 0xB4, 0x1A, 0x12, 0xC2, 0x76, 0xAE, + 0x80, 0x35, 0xAC, 0x7F, 0xD7, 0xC3, 0xB5, 0x12 + }, + { + 0x52, 0x12, 0x9E, 0xDB, 0x14, 0xCB, 0x28, 0xD7, + 0x41, 0x3E, 0x00, 0xF2, 0x08, 0xFA, 0x11, 0xF4, + 0x7F, 0xF9, 0x0C, 0x00, 0xF0, 0x40, 0xA8, 0x3E, + 0x2D, 0xCC, 0xD0, 0x3A, 0x95, 0xAF, 0x56, 0x20 + }, + { + 0x63, 0x11, 0x24, 0x00, 0x32, 0xB9, 0xA9, 0x58, + 0x22, 0x0C, 0xE5, 0xC3, 0x66, 0x3F, 0x9D, 0x78, + 0x87, 0x87, 0x9C, 0x8C, 0x0E, 0xBB, 0xE1, 0x16, + 0x53, 0x54, 0x3D, 0xCB, 0xFF, 0xC0, 0xDA, 0x4B + }, + { + 0x50, 0x81, 0xA4, 0x4D, 0x86, 0x05, 0xAA, 0x6B, + 0x26, 0x31, 0xBA, 0x5D, 0xD9, 0x0E, 0x12, 0xBA, + 0x23, 0x01, 0xC0, 0xAA, 0xEB, 0x6B, 0x8E, 0x38, + 0xC3, 0xC9, 0x5D, 0x31, 0x3A, 0x6D, 0x5E, 0x05 + }, + { + 0xFD, 0x84, 0x06, 0xDD, 0xA6, 0x37, 0x92, 0xBF, + 0x16, 0x09, 0x32, 0xBE, 0x0A, 0x59, 0xD5, 0xCB, + 0xB2, 0x70, 0xDF, 0x78, 0x0B, 0xA1, 0x4C, 0x3E, + 0xB8, 0x9A, 0xC8, 0x6B, 0x09, 0xAF, 0x62, 0xF8 + }, + { + 0x65, 0x0F, 0x42, 0x34, 0x0B, 0xCD, 0x68, 0x1B, + 0x3A, 0xFB, 0xA8, 0x69, 0x83, 0x00, 0x06, 0x7B, + 0x18, 0x33, 0xE1, 0xFD, 0x57, 0x66, 0xD3, 0x88, + 0x66, 0x54, 0x83, 0x05, 0x90, 0x30, 0x3D, 0x7D + }, + { + 0xA7, 0xEA, 0xC8, 0x19, 0x03, 0x3B, 0xFF, 0xAF, + 0x29, 0xF0, 0x31, 0xFE, 0x3F, 0x1D, 0x95, 0xA0, + 0x95, 0x43, 0x5A, 0xF2, 0x0D, 0xC3, 0xFF, 0x59, + 0x51, 0xCC, 0x3B, 0xA1, 0x7F, 0x2C, 0x31, 0x27 + }, + { + 0x74, 0x2A, 0xB9, 0x62, 0x17, 0x2F, 0x06, 0x88, + 0x93, 0x70, 0xCA, 0x2A, 0x76, 0x8F, 0xF5, 0x7C, + 0x26, 0xE4, 0x34, 0xC5, 0x60, 0xF1, 0x69, 0x78, + 0x2E, 0xE4, 0x9D, 0x71, 0xB2, 0x2A, 0x1D, 0x93 + }, + { + 0xFD, 0x1B, 0x57, 0xD5, 0x3E, 0x4D, 0xC4, 0x3B, + 0x30, 0xCB, 0x73, 0x29, 0x7A, 0x24, 0x9E, 0x4E, + 0x11, 0x9B, 0x09, 0x10, 0xE4, 0xDD, 0x1A, 0x78, + 0x3F, 0x3F, 0x48, 0x0F, 0x4E, 0x57, 0xD7, 0xA2 + }, + { + 0x41, 0x6D, 0xE1, 0x01, 0x7E, 0xCA, 0x9C, 0xC2, + 0xAB, 0xC9, 0x0F, 0x93, 0x6E, 0x14, 0x34, 0x92, + 0xB7, 0xB2, 0xC6, 0xC0, 0x61, 0xD2, 0x50, 0xD4, + 0x5F, 0xBF, 0xE3, 0x53, 0x71, 0x6E, 0x2D, 0xFD + }, + { + 0xDE, 0xB8, 0xE7, 0x6D, 0x9D, 0x1C, 0x21, 0x7C, + 0x45, 0x51, 0xF1, 0xC2, 0x02, 0x43, 0x95, 0xF0, + 0xA5, 0x66, 0x00, 0xF3, 0xFD, 0x24, 0x9A, 0xBE, + 0x75, 0xDB, 0x55, 0x23, 0x07, 0x65, 0xF9, 0x34 + }, + { + 0x1A, 0xB1, 0xEE, 0xE9, 0xEF, 0x76, 0x88, 0x93, + 0x08, 0x44, 0x85, 0x5B, 0x19, 0x00, 0xAB, 0x08, + 0x21, 0x17, 0xC3, 0xEC, 0x05, 0x5F, 0x53, 0x72, + 0x61, 0x55, 0xDD, 0x66, 0xBD, 0x95, 0x76, 0xBC + }, + { + 0x07, 0xB7, 0x5B, 0xFC, 0xB9, 0x11, 0x22, 0xB4, + 0x2A, 0x81, 0x2B, 0x70, 0x69, 0x60, 0x47, 0x42, + 0x4C, 0x3A, 0x86, 0xFA, 0x87, 0x59, 0x60, 0x61, + 0x3E, 0xC3, 0xE6, 0xA0, 0xE1, 0x85, 0xCB, 0x99 + }, + { + 0xBF, 0x83, 0x20, 0x1B, 0x5A, 0xC9, 0x7A, 0xE4, + 0xC0, 0xD7, 0x47, 0x94, 0x63, 0x5E, 0x2C, 0x8A, + 0x51, 0x9E, 0x05, 0x2E, 0x83, 0x05, 0x98, 0x1E, + 0x50, 0x92, 0x7F, 0x42, 0x71, 0x98, 0x44, 0x5E + }, + { + 0x6C, 0xFC, 0xB6, 0x29, 0x3A, 0x67, 0xE5, 0x55, + 0x4F, 0x0B, 0x67, 0x25, 0xC0, 0xCE, 0x77, 0xB2, + 0xD0, 0x1C, 0xBD, 0xAB, 0x08, 0x08, 0x36, 0xB4, + 0x8F, 0x2B, 0x02, 0x64, 0x77, 0x40, 0xC1, 0x24 + }, + { + 0x84, 0x88, 0x14, 0x2C, 0xCA, 0x88, 0x8F, 0xC3, + 0xEB, 0x82, 0x1B, 0x34, 0x66, 0xA9, 0x24, 0xC0, + 0x3A, 0x85, 0x02, 0xBA, 0x56, 0x88, 0xCA, 0xFB, + 0xB8, 0xF1, 0xB2, 0x1B, 0xD1, 0x6E, 0x43, 0xC7 + }, + { + 0x55, 0x1E, 0xBE, 0xC7, 0x45, 0xEC, 0x09, 0x59, + 0x9E, 0x49, 0x9E, 0x30, 0xA9, 0xD6, 0x8F, 0xA4, + 0x19, 0x5B, 0xA7, 0xC5, 0x3A, 0xA2, 0x7F, 0xBB, + 0xC3, 0xE7, 0xB4, 0xA2, 0x17, 0x45, 0xD0, 0xEF + }, + { + 0xAB, 0xDB, 0x17, 0x2E, 0x5E, 0xF9, 0x39, 0x01, + 0x41, 0xDE, 0x9B, 0x2F, 0x9E, 0x18, 0x9F, 0x51, + 0x0C, 0x32, 0x82, 0xF5, 0xC6, 0x4D, 0x6F, 0x55, + 0xEF, 0x80, 0x95, 0xB9, 0xA2, 0xC7, 0xC1, 0x75 + }, + { + 0x90, 0xBC, 0x6B, 0x23, 0x3E, 0x1C, 0x41, 0x11, + 0x7B, 0x77, 0x97, 0xAC, 0xED, 0x28, 0x86, 0xC5, + 0x90, 0x65, 0x98, 0xE5, 0x20, 0x58, 0x02, 0xE7, + 0x7F, 0xC6, 0x65, 0x65, 0xC6, 0x1B, 0xB9, 0xD6 + }, + { + 0x98, 0xE6, 0xB6, 0x10, 0x4E, 0x8C, 0x38, 0x28, + 0x6A, 0x6C, 0xA5, 0x9D, 0x69, 0x6B, 0x55, 0x48, + 0x9F, 0x4D, 0xAA, 0x47, 0x46, 0xC7, 0x5A, 0xBF, + 0x00, 0xF8, 0xA3, 0x92, 0xC8, 0x36, 0x18, 0x5C + }, + { + 0xD1, 0x57, 0xC0, 0xCB, 0x1A, 0x76, 0x05, 0x01, + 0xCB, 0x2A, 0xED, 0xA3, 0x29, 0xB7, 0xDA, 0x9F, + 0x42, 0xFE, 0x0D, 0x5C, 0x80, 0x03, 0x71, 0x52, + 0xB0, 0x25, 0x7E, 0xE0, 0x90, 0x4E, 0x3A, 0x55 + }, + { + 0xAC, 0xE8, 0xBF, 0xF4, 0xD5, 0x09, 0x23, 0x3B, + 0x35, 0xA6, 0x27, 0x57, 0xCE, 0x33, 0x36, 0x33, + 0x71, 0x02, 0xDD, 0xFF, 0xDC, 0x2D, 0x47, 0x12, + 0x4C, 0x32, 0x60, 0xE4, 0x58, 0xF6, 0x83, 0xE0 + }, + { + 0x04, 0x7A, 0x09, 0x50, 0x8C, 0x8B, 0x9F, 0xA1, + 0x67, 0x87, 0xB4, 0xEB, 0xCA, 0x4F, 0x6C, 0x00, + 0x7E, 0xDE, 0xAD, 0x68, 0x72, 0xA7, 0x52, 0x71, + 0xA0, 0x97, 0xEF, 0x26, 0x00, 0x1D, 0x4E, 0x6D + }, + { + 0xD0, 0xD8, 0x2F, 0x4E, 0xD8, 0x6F, 0xA7, 0xB2, + 0xAD, 0xB2, 0x45, 0xF1, 0xFC, 0x65, 0x82, 0x59, + 0x2D, 0x29, 0x04, 0x37, 0x4B, 0x56, 0x22, 0xBB, + 0xE7, 0xC6, 0x7A, 0xD8, 0x3B, 0x43, 0xEB, 0x4E + }, + { + 0xA4, 0x36, 0x41, 0x1E, 0xDB, 0xB4, 0x8D, 0x7D, + 0xBA, 0x78, 0x70, 0xB0, 0xD9, 0x0F, 0x08, 0xB7, + 0xAD, 0xD6, 0x07, 0x39, 0x8C, 0x28, 0xF9, 0x93, + 0xCE, 0x62, 0xE3, 0xB4, 0x50, 0x7A, 0x99, 0x1E + }, + { + 0xCF, 0xC4, 0x44, 0x8D, 0x45, 0xC8, 0x65, 0xCC, + 0x89, 0x39, 0xE6, 0xE6, 0x02, 0x5B, 0x3C, 0x93, + 0x0F, 0x6F, 0x6B, 0xD5, 0x7C, 0x58, 0x42, 0x9D, + 0xC9, 0xBE, 0x57, 0xB1, 0xE5, 0xF2, 0xF2, 0xD2 + }, + { + 0x2B, 0xB7, 0x44, 0x02, 0x49, 0x16, 0x58, 0x07, + 0xCD, 0x0F, 0x64, 0x39, 0xF7, 0x28, 0x89, 0xAF, + 0x07, 0x42, 0x1D, 0xB1, 0xDA, 0x4D, 0x28, 0x41, + 0xEA, 0x2C, 0x2B, 0x40, 0x6D, 0xF7, 0x0C, 0x83 + }, + { + 0x89, 0x35, 0x32, 0x00, 0x33, 0x6E, 0xDC, 0x81, + 0x6B, 0xF0, 0x6F, 0x45, 0x11, 0xDD, 0x34, 0x78, + 0xDE, 0xCA, 0x7F, 0x29, 0x73, 0xEE, 0xA6, 0xFA, + 0x57, 0x8E, 0x59, 0x6C, 0xA3, 0xB8, 0x1A, 0x17 + }, + { + 0x79, 0xC7, 0xA3, 0x55, 0x82, 0x15, 0x81, 0x23, + 0xF6, 0xBC, 0xE5, 0x4F, 0x13, 0x46, 0x59, 0x5B, + 0xA3, 0x60, 0xB0, 0x0E, 0x69, 0xC0, 0x34, 0x26, + 0x14, 0x14, 0x55, 0x44, 0x2C, 0xC0, 0x8A, 0x2B + }, + { + 0x9F, 0x97, 0x73, 0x79, 0x7B, 0xBD, 0x10, 0x81, + 0xD1, 0x86, 0x00, 0x5C, 0x34, 0x8C, 0xC6, 0x2A, + 0xBD, 0x9C, 0x3A, 0x19, 0x04, 0xDF, 0x1A, 0x72, + 0x7A, 0x3C, 0x75, 0x97, 0xE9, 0xFB, 0x11, 0xE7 + }, + { + 0x0E, 0x3F, 0xE8, 0x44, 0x9B, 0x7E, 0x07, 0x6B, + 0x59, 0xC1, 0x44, 0xF9, 0xF0, 0xE1, 0xE6, 0xDF, + 0x6A, 0xD2, 0x84, 0x86, 0x41, 0x5C, 0x08, 0xE9, + 0x45, 0x45, 0xAA, 0x37, 0x50, 0x8C, 0x5F, 0x8B + }, + { + 0x66, 0x9D, 0x85, 0x75, 0x16, 0x5F, 0x40, 0xA7, + 0x2F, 0x9B, 0xE8, 0xBD, 0x85, 0x49, 0x77, 0x58, + 0x92, 0x19, 0xDB, 0x50, 0x58, 0x08, 0x85, 0xD7, + 0x6F, 0xEC, 0xF8, 0xEB, 0x3C, 0x2B, 0x94, 0xD2 + }, + { + 0xB4, 0xC7, 0xC0, 0x1E, 0xAB, 0x7E, 0x21, 0x59, + 0xB4, 0x91, 0x16, 0x15, 0x45, 0x3B, 0x9D, 0x63, + 0x46, 0x16, 0x5D, 0xE0, 0xFF, 0x55, 0x7B, 0x53, + 0x95, 0xB7, 0x95, 0x3F, 0x8C, 0x09, 0x64, 0x3A + }, + { + 0xD8, 0x58, 0x5F, 0xE9, 0x25, 0x08, 0x54, 0x58, + 0xAB, 0x4B, 0x6A, 0x0D, 0xBC, 0x26, 0x95, 0xB7, + 0xB2, 0xB4, 0xBA, 0x63, 0x03, 0xF8, 0xB5, 0x71, + 0xB4, 0x78, 0x8C, 0xE3, 0xF7, 0x42, 0xE7, 0x53 + }, + { + 0x3B, 0x54, 0x9E, 0xB3, 0x36, 0x43, 0x95, 0x0D, + 0x26, 0xCD, 0x8F, 0x0A, 0xB4, 0x40, 0x04, 0x67, + 0x61, 0x17, 0x23, 0xEF, 0x6E, 0xC0, 0x50, 0xE0, + 0x70, 0xDD, 0x96, 0x14, 0x22, 0xC8, 0x39, 0x46 + }, + { + 0xBA, 0x26, 0x23, 0xBE, 0xBD, 0xFD, 0x21, 0xF9, + 0x0F, 0xA9, 0xDA, 0x7C, 0xB9, 0xCF, 0xEE, 0x28, + 0xF0, 0x1B, 0x06, 0x1E, 0xD6, 0x12, 0x91, 0x5E, + 0x4D, 0xF7, 0x56, 0xB5, 0xD6, 0x63, 0x31, 0x5C + }, + { + 0x05, 0xA6, 0xE4, 0x15, 0xA1, 0xBD, 0x68, 0x36, + 0x52, 0x93, 0x31, 0xFE, 0x08, 0xB0, 0x97, 0x8C, + 0x08, 0xD7, 0x51, 0x85, 0xC9, 0xD6, 0xF8, 0x1D, + 0x76, 0x7B, 0x1D, 0xF1, 0xD6, 0xFE, 0x28, 0x21 + }, + { + 0x5A, 0x10, 0x45, 0x29, 0xAA, 0x90, 0xF9, 0x5E, + 0xE3, 0xDF, 0xEF, 0xC7, 0xAD, 0xEE, 0xD3, 0xD7, + 0xA4, 0x7B, 0xD2, 0x52, 0xA5, 0x51, 0xC6, 0x63, + 0x62, 0xD8, 0x49, 0x71, 0xBB, 0xB3, 0x32, 0x58 + }, + { + 0xBC, 0xE3, 0x5F, 0x62, 0xDE, 0x0B, 0xE7, 0x4E, + 0x19, 0x8F, 0xC4, 0xFC, 0x69, 0xFF, 0x5F, 0x6E, + 0x72, 0xB9, 0x29, 0x3E, 0x8D, 0x89, 0x79, 0x8F, + 0xF5, 0xB7, 0x36, 0xD4, 0xE7, 0x6C, 0xC7, 0xAA + }, + { + 0xD0, 0xF5, 0xAC, 0x58, 0x04, 0x49, 0x8A, 0xDB, + 0xDA, 0x50, 0xFD, 0x12, 0xAD, 0x7B, 0x9D, 0x76, + 0xA9, 0x6C, 0xF9, 0x15, 0x4B, 0x65, 0x3A, 0xFB, + 0x37, 0xF4, 0x60, 0xA9, 0x12, 0x31, 0xD8, 0x57 + }, + { + 0xF1, 0x94, 0x6B, 0xFF, 0x1E, 0xD0, 0x63, 0x0C, + 0x4B, 0x6F, 0x52, 0x5C, 0x43, 0xE7, 0xD4, 0x40, + 0x6A, 0x86, 0xCB, 0x9E, 0x1D, 0xEE, 0x38, 0x1B, + 0xC6, 0x37, 0xD3, 0x58, 0x3F, 0x81, 0x4B, 0x97 + }, + { + 0xDB, 0x29, 0x8E, 0x5F, 0xD3, 0xEE, 0xD9, 0x31, + 0x1B, 0x7E, 0x3D, 0xDE, 0xF1, 0xF9, 0x87, 0x9E, + 0x6D, 0x86, 0x73, 0x1A, 0x19, 0xBC, 0xC0, 0xF1, + 0xC9, 0xEA, 0x81, 0xF0, 0xA8, 0xBC, 0x64, 0x7F + }, + { + 0x70, 0xA7, 0x21, 0x73, 0x4E, 0xF0, 0xAD, 0x00, + 0xFF, 0x07, 0xBE, 0x9C, 0x0A, 0x1E, 0xD3, 0xCC, + 0x33, 0xCB, 0x67, 0xE3, 0x96, 0x83, 0x83, 0x3F, + 0x1A, 0x1E, 0x01, 0x32, 0x1A, 0xC8, 0x23, 0x77 + }, + { + 0x59, 0x65, 0xC8, 0xD4, 0x72, 0x80, 0x57, 0x4F, + 0x30, 0xF0, 0x5A, 0xDD, 0xEB, 0xF3, 0xA0, 0x0A, + 0xD1, 0x46, 0x41, 0xBE, 0xF5, 0xAA, 0xF4, 0x14, + 0x4C, 0xAB, 0x8A, 0x95, 0x8A, 0x4F, 0xFC, 0x50 + }, + { + 0xC1, 0xC9, 0xFD, 0x88, 0x10, 0xB8, 0x97, 0x86, + 0x79, 0xFA, 0x30, 0x41, 0xEE, 0x07, 0x10, 0xC7, + 0x8C, 0xE7, 0xC2, 0xB6, 0xE8, 0x96, 0x56, 0x90, + 0x7B, 0xB2, 0x45, 0x7D, 0x33, 0x64, 0x50, 0xFD + }, + { + 0x9E, 0xD6, 0xDF, 0xDC, 0x65, 0xB5, 0x85, 0x4A, + 0x78, 0x34, 0x04, 0xBD, 0x9F, 0x0E, 0x91, 0x7C, + 0x80, 0xA8, 0x95, 0xBF, 0x45, 0xCD, 0x10, 0x5A, + 0x47, 0x72, 0x8F, 0x5D, 0x96, 0x9E, 0x0F, 0x12 + }, + { + 0x5F, 0xD3, 0xA7, 0xE3, 0xD5, 0x32, 0xC7, 0x25, + 0x48, 0xAF, 0x2F, 0xC5, 0xB3, 0x9C, 0x12, 0x3D, + 0x3D, 0xE9, 0x38, 0x8E, 0xBD, 0x01, 0x23, 0xB4, + 0x2B, 0x19, 0xB2, 0x17, 0x8A, 0x60, 0xA7, 0x96 + }, + { + 0x02, 0x24, 0x8F, 0x7B, 0x94, 0xD0, 0x9D, 0x46, + 0x4C, 0x9D, 0x52, 0x2E, 0x59, 0xF6, 0x6B, 0xAF, + 0x87, 0x87, 0xD5, 0x7C, 0xD2, 0x66, 0x7E, 0x47, + 0xDC, 0x7B, 0x3B, 0x60, 0xC6, 0x02, 0xEC, 0xD6 + }, + { + 0xD8, 0xB1, 0xAF, 0x78, 0xD6, 0x01, 0x27, 0x1E, + 0x2F, 0xE7, 0xF5, 0xBF, 0xB4, 0xB2, 0x2B, 0x6A, + 0x57, 0x7B, 0x7C, 0xAB, 0x3E, 0x2F, 0xFB, 0xF2, + 0xF1, 0x60, 0xDB, 0x1E, 0x0F, 0x3F, 0xF0, 0x6F + }, + { + 0x47, 0xBA, 0x43, 0x90, 0x33, 0x4F, 0xCD, 0x8E, + 0x58, 0x40, 0x89, 0x8C, 0xB3, 0xA4, 0xE5, 0x74, + 0x50, 0x92, 0x7D, 0x12, 0xDD, 0xDE, 0x3F, 0x3E, + 0xB6, 0x05, 0x80, 0x84, 0x97, 0x75, 0x4B, 0x06 + }, + { + 0xCA, 0xB0, 0x74, 0x72, 0x25, 0x46, 0xA7, 0xE9, + 0x4F, 0x92, 0xA3, 0xF5, 0xAF, 0x1C, 0xAA, 0x5F, + 0x0F, 0xE3, 0xA8, 0xE5, 0xEE, 0xAA, 0x28, 0x05, + 0xDB, 0x86, 0x6A, 0x14, 0x1E, 0xD8, 0xDB, 0x83 + }, + { + 0x37, 0x16, 0x5D, 0xA3, 0xBE, 0x25, 0x67, 0xEC, + 0x9C, 0x74, 0xFE, 0xBE, 0x90, 0x96, 0x0B, 0xD3, + 0x4F, 0x29, 0x92, 0xA0, 0x79, 0xB5, 0xB8, 0x5B, + 0xE5, 0xD7, 0x92, 0x8B, 0x66, 0x4B, 0x1F, 0xD6 + }, + { + 0x06, 0xD1, 0x74, 0xA6, 0xA7, 0x96, 0x39, 0xF8, + 0x00, 0xA8, 0xC9, 0x13, 0x71, 0x64, 0x20, 0x39, + 0x15, 0x96, 0xD7, 0xF4, 0x95, 0x49, 0x70, 0x6B, + 0x82, 0x8C, 0x87, 0x51, 0xFD, 0xB0, 0x1F, 0xA6 + }, + { + 0x6C, 0xD4, 0x21, 0xD8, 0xEB, 0xB1, 0x5A, 0x70, + 0x96, 0xA2, 0x2A, 0x65, 0xAD, 0x34, 0x96, 0xBC, + 0xE5, 0xAF, 0xF9, 0x88, 0x09, 0x50, 0x04, 0x0D, + 0x0D, 0x61, 0xEB, 0x5B, 0xB7, 0x51, 0x0F, 0x8B + }, + { + 0xBE, 0xA2, 0x3B, 0x0F, 0x4E, 0xEB, 0x99, 0x38, + 0xB2, 0xFB, 0xB1, 0xAF, 0x2A, 0xBB, 0x50, 0xD1, + 0x39, 0xDF, 0x12, 0x80, 0x1C, 0x05, 0x96, 0x1B, + 0x0F, 0x8D, 0x32, 0xB6, 0x6C, 0x00, 0x69, 0x5A + }, + { + 0x76, 0x39, 0x1D, 0xD1, 0x34, 0x65, 0xB0, 0xB2, + 0x7D, 0xC3, 0x31, 0x18, 0xC5, 0xD5, 0xE5, 0xA9, + 0xBA, 0xBF, 0x48, 0x64, 0x1E, 0x57, 0x7E, 0xE7, + 0xD7, 0xE3, 0x92, 0x6B, 0x1F, 0xA4, 0xDB, 0x3B + }, + { + 0xF0, 0xA9, 0xD3, 0x19, 0x5B, 0x52, 0x4B, 0x49, + 0x99, 0x1E, 0xD2, 0x70, 0x0D, 0x53, 0xB7, 0xC3, + 0x90, 0x75, 0xF1, 0x92, 0xB9, 0xD4, 0xDC, 0xF2, + 0x75, 0xBB, 0x81, 0xCB, 0x8E, 0x71, 0xC7, 0x50 + }, + { + 0x63, 0x97, 0x7F, 0x85, 0xEE, 0x63, 0x68, 0x77, + 0xAF, 0x30, 0xC7, 0xC9, 0xD5, 0x5A, 0xAD, 0xCF, + 0x5E, 0xD6, 0x13, 0x39, 0x6C, 0x39, 0x12, 0xE5, + 0x04, 0x01, 0xA0, 0x9B, 0x66, 0xAF, 0x61, 0xE5 + }, + { + 0x50, 0xBC, 0x5E, 0x08, 0x4F, 0x15, 0xAD, 0x64, + 0x9F, 0x9F, 0x11, 0x90, 0x76, 0xE2, 0xC3, 0x89, + 0xEB, 0xDA, 0x51, 0x0C, 0xAD, 0xCD, 0xAD, 0xE2, + 0x1E, 0xAE, 0x2D, 0x25, 0xE8, 0xDD, 0xEF, 0xB0 + }, + { + 0x79, 0x46, 0x5A, 0xDC, 0xD5, 0x47, 0x67, 0x5F, + 0x1B, 0xC6, 0x72, 0xCF, 0x4B, 0x44, 0x85, 0x5B, + 0x85, 0x90, 0x5B, 0xBC, 0x88, 0x64, 0x29, 0xFF, + 0x2B, 0x42, 0x47, 0xD9, 0x01, 0xEE, 0xB5, 0x0C + }, + { + 0x23, 0xF2, 0x41, 0xF1, 0x69, 0xDE, 0x45, 0x88, + 0x4D, 0xEC, 0x95, 0x74, 0xB6, 0xAC, 0x63, 0x1D, + 0x75, 0xDB, 0x60, 0xE4, 0x03, 0xAF, 0x7A, 0x2C, + 0x7C, 0xEA, 0x3A, 0xA8, 0x91, 0xE2, 0xDB, 0x52 + }, + { + 0xC3, 0xDF, 0x4D, 0xF8, 0x75, 0x64, 0x06, 0x87, + 0xB6, 0x34, 0x25, 0x0A, 0x6D, 0xB3, 0x1D, 0xB9, + 0xCD, 0x09, 0xC5, 0x2B, 0x2B, 0x42, 0xF7, 0xF7, + 0x06, 0x49, 0x05, 0x73, 0x8B, 0xF5, 0x9C, 0x21 + }, + { + 0xE1, 0x30, 0xD2, 0x0E, 0xA5, 0x7D, 0xA5, 0x6B, + 0x10, 0xE0, 0x24, 0x89, 0x82, 0xD0, 0xBD, 0x42, + 0x9F, 0x99, 0xF9, 0x12, 0x18, 0xDC, 0xF7, 0x11, + 0xF2, 0xBA, 0x98, 0xB4, 0xD8, 0x7B, 0xE0, 0x4E + }, + { + 0x42, 0xBA, 0x04, 0xF6, 0xFA, 0x4E, 0x3E, 0x88, + 0x6C, 0x33, 0x4D, 0xAA, 0x28, 0x6F, 0x59, 0x11, + 0xFD, 0x6C, 0xFC, 0xBA, 0xF6, 0xD8, 0x12, 0xFE, + 0x8F, 0xF4, 0xDE, 0xB5, 0x9C, 0x33, 0x58, 0xD9 + }, + { + 0x9B, 0x29, 0x53, 0x6C, 0x47, 0x93, 0x68, 0xE8, + 0x1B, 0x5F, 0x8B, 0x52, 0x8C, 0x47, 0x2B, 0x3C, + 0x80, 0x2C, 0x34, 0x27, 0xE0, 0x28, 0xBE, 0xAF, + 0x62, 0xCD, 0x4A, 0x76, 0x63, 0x9C, 0x2B, 0x42 + }, + { + 0x45, 0xDB, 0xE4, 0x2B, 0x37, 0xBD, 0x38, 0xAD, + 0x7B, 0x5E, 0x79, 0x73, 0x53, 0x2D, 0xF9, 0x1E, + 0x6E, 0x09, 0x17, 0x9B, 0x23, 0x2D, 0x52, 0x39, + 0x52, 0x0C, 0x3B, 0x3D, 0x72, 0xDA, 0xB9, 0x55 + }, + { + 0x0C, 0x97, 0x03, 0x42, 0x56, 0xD1, 0xDD, 0xFA, + 0x55, 0x2B, 0x28, 0x29, 0x54, 0x31, 0x69, 0x4E, + 0x8D, 0x8B, 0x1F, 0x9C, 0x2B, 0xB5, 0x5F, 0x28, + 0xFE, 0x60, 0xEE, 0x62, 0xB8, 0xAE, 0x74, 0xFB + }, + { + 0xA2, 0x78, 0xCB, 0x56, 0x66, 0x63, 0xAB, 0x21, + 0x69, 0xEB, 0x30, 0x2C, 0x6F, 0xE8, 0xBE, 0x26, + 0x99, 0xFC, 0x0B, 0xC1, 0xB1, 0xAC, 0xB0, 0x3B, + 0xB9, 0xBF, 0x87, 0xE2, 0xEF, 0xCC, 0x56, 0x43 + }, + { + 0x8A, 0xD4, 0x87, 0x92, 0x2A, 0x10, 0x44, 0xF8, + 0xB8, 0xC6, 0xF1, 0x04, 0x44, 0xF1, 0x92, 0x0D, + 0x11, 0x7F, 0xC0, 0xA5, 0x9C, 0x0D, 0x89, 0x12, + 0x82, 0xF3, 0x33, 0x09, 0x62, 0x47, 0x0F, 0x1D + }, + { + 0xF1, 0x05, 0x57, 0x7B, 0x0F, 0xA6, 0xC0, 0x4E, + 0xF7, 0x85, 0x6D, 0x47, 0x9F, 0x82, 0x3E, 0xE1, + 0x7A, 0xE3, 0x68, 0xA7, 0x74, 0xAC, 0x34, 0x1C, + 0xD0, 0x0F, 0x7E, 0x5F, 0xE2, 0x33, 0x08, 0xB6 + }, + { + 0xD3, 0xF6, 0xDD, 0x48, 0x52, 0x2E, 0xE2, 0x4B, + 0x11, 0x38, 0x88, 0xD3, 0x1B, 0x09, 0x65, 0xC9, + 0x66, 0x5C, 0x99, 0x21, 0x79, 0xE9, 0xA6, 0xA3, + 0x70, 0x1A, 0x7C, 0x44, 0x4D, 0x85, 0x99, 0xF3 + }, + { + 0x41, 0x4C, 0xC4, 0x6A, 0x3F, 0xCF, 0x5C, 0xE2, + 0xBA, 0x01, 0xD2, 0xFA, 0xED, 0x0A, 0x0F, 0xF0, + 0x4B, 0xA8, 0x66, 0x3F, 0x93, 0xDE, 0xFF, 0x41, + 0xF1, 0x77, 0x5F, 0xC3, 0x54, 0x2D, 0xB1, 0x03 + }, + { + 0x7F, 0x84, 0x4D, 0xE3, 0xAB, 0xF2, 0x65, 0x85, + 0x0E, 0x48, 0xC6, 0xB2, 0xB7, 0x74, 0x66, 0x56, + 0xE8, 0x4F, 0x60, 0x90, 0x65, 0xBD, 0x62, 0xF8, + 0xF5, 0x9B, 0xB3, 0xA5, 0xA6, 0x69, 0xCD, 0x14 + }, + { + 0x13, 0xC0, 0x45, 0x6A, 0x9D, 0x29, 0x78, 0x09, + 0x2D, 0x3C, 0x1B, 0x20, 0x9D, 0x7F, 0x44, 0x2B, + 0x4A, 0x98, 0xAE, 0x43, 0x1E, 0x7F, 0x3F, 0x0B, + 0x7B, 0x59, 0x7B, 0xE2, 0xCC, 0x77, 0x49, 0x6C + }, + { + 0x9A, 0x16, 0x04, 0x56, 0xF7, 0xF6, 0x83, 0xA7, + 0xB4, 0x09, 0xA9, 0x15, 0xC2, 0x04, 0x79, 0x5D, + 0x0C, 0x12, 0xFC, 0x48, 0x20, 0x76, 0xA8, 0xBB, + 0x4F, 0x2C, 0x8D, 0x60, 0xCA, 0x8F, 0xCA, 0xB5 + }, + { + 0x04, 0xBC, 0xE9, 0x6F, 0x91, 0x39, 0x83, 0x14, + 0xD8, 0x5F, 0x07, 0xEA, 0x28, 0xAC, 0x69, 0x3B, + 0x03, 0xA7, 0xA1, 0x4F, 0x81, 0xC9, 0xF4, 0x13, + 0xD5, 0x75, 0xA6, 0x6E, 0x3D, 0x75, 0xA1, 0x70 + }, + { + 0xAB, 0x8D, 0xF6, 0x60, 0x61, 0x28, 0x26, 0x31, + 0x16, 0x31, 0x3B, 0xCE, 0x18, 0x2E, 0x0E, 0x5B, + 0xEB, 0x36, 0x06, 0x13, 0xEB, 0x31, 0xF5, 0xD8, + 0x57, 0xC6, 0x49, 0x79, 0xB4, 0x88, 0x5F, 0x81 + }, + { + 0x8A, 0x7B, 0x5F, 0x60, 0x2B, 0xD7, 0xD0, 0x92, + 0xF9, 0x92, 0x8A, 0xFE, 0x8F, 0x11, 0x77, 0xF0, + 0x79, 0x44, 0x5A, 0x18, 0x0B, 0xF8, 0x10, 0xA7, + 0xE9, 0xC0, 0x45, 0x4F, 0xBC, 0x95, 0xCB, 0xB9 + }, + { + 0x22, 0xA9, 0x53, 0x0D, 0x51, 0xC3, 0x5D, 0x02, + 0xAA, 0xED, 0xDE, 0x7C, 0x57, 0x6F, 0x76, 0x79, + 0x05, 0x34, 0x14, 0x16, 0xE3, 0xEF, 0x74, 0x8F, + 0x03, 0x9A, 0x97, 0xFA, 0x17, 0xD5, 0x03, 0xFD + }, + { + 0xAB, 0xA8, 0x02, 0xED, 0xD7, 0x9F, 0xBA, 0x09, + 0x7D, 0xCE, 0x52, 0x13, 0x7F, 0xF3, 0xC3, 0x18, + 0x7A, 0x31, 0x1D, 0x76, 0x77, 0x8D, 0xCD, 0x32, + 0x59, 0x7C, 0x1A, 0xA0, 0x3E, 0x64, 0x5C, 0x2F + }, + { + 0x90, 0x65, 0x3C, 0x4A, 0x61, 0xE2, 0xD5, 0x02, + 0xDA, 0xD2, 0xBF, 0xD1, 0x0E, 0x96, 0x27, 0x9A, + 0xA4, 0x9E, 0x7C, 0xB7, 0xF0, 0x20, 0x10, 0x86, + 0x9E, 0xE6, 0x6D, 0x19, 0xD0, 0xDD, 0xC9, 0x55 + }, + { + 0x18, 0xBC, 0xB7, 0x6C, 0x30, 0x2A, 0xA3, 0xF7, + 0x96, 0x99, 0x85, 0x8F, 0xE5, 0x2D, 0xA6, 0x7B, + 0xA1, 0xA2, 0x46, 0xEB, 0x51, 0x2C, 0x2A, 0xFA, + 0xE4, 0xB3, 0xC5, 0x59, 0x47, 0xDB, 0x2A, 0xAC + }, + { + 0x30, 0x75, 0xB4, 0x3D, 0x09, 0x48, 0x1C, 0x3D, + 0x67, 0x88, 0x82, 0x31, 0x9E, 0x42, 0x8A, 0x57, + 0x3F, 0x28, 0x9B, 0x61, 0x64, 0xBB, 0x21, 0x9A, + 0x9B, 0x13, 0x97, 0x18, 0x5D, 0x52, 0xF1, 0xEE + }, + { + 0x0D, 0xB9, 0xA4, 0x7A, 0x51, 0xD4, 0xF5, 0xA6, + 0x9E, 0x45, 0x3F, 0x72, 0x4D, 0xC4, 0x97, 0xEA, + 0x96, 0xE0, 0x58, 0x84, 0xB4, 0x49, 0x81, 0x4B, + 0xE9, 0xA4, 0x65, 0xC2, 0xD6, 0x37, 0x17, 0xFB + }, + { + 0x2D, 0x06, 0x7E, 0xB7, 0x70, 0xF2, 0x81, 0x6C, + 0x97, 0x5B, 0x37, 0xAE, 0xCA, 0x79, 0x7E, 0x75, + 0xB6, 0x3D, 0x35, 0x1E, 0x89, 0x3F, 0xEF, 0x06, + 0x7D, 0x99, 0xDB, 0x73, 0x9D, 0x57, 0x38, 0x42 + }, + { + 0xAD, 0xEA, 0xDA, 0x9E, 0x2B, 0x53, 0xB9, 0xA4, + 0x22, 0x78, 0xAE, 0xBD, 0x1D, 0x45, 0x9B, 0xB8, + 0x5A, 0x2D, 0x24, 0x57, 0x40, 0x7C, 0x98, 0x90, + 0xBB, 0x18, 0xDD, 0x77, 0x0D, 0xE1, 0xD8, 0x0E + }, + { + 0x3B, 0x6F, 0x38, 0xF3, 0x57, 0x22, 0x1D, 0x29, + 0xDD, 0x07, 0xA9, 0xE7, 0x18, 0x65, 0xD7, 0x7C, + 0xCD, 0xA7, 0xFF, 0xCF, 0x95, 0x51, 0x8A, 0x4C, + 0x61, 0xC9, 0x76, 0x59, 0x60, 0x36, 0xBA, 0x7D + }, + { + 0x6F, 0x74, 0x70, 0x4F, 0xCD, 0x61, 0x56, 0x0E, + 0x10, 0xC7, 0xE3, 0x0C, 0x73, 0x13, 0xFE, 0x62, + 0xE2, 0x50, 0xEF, 0x3E, 0x1B, 0x36, 0x7F, 0xEE, + 0xD4, 0xB8, 0x23, 0x7C, 0xFD, 0x12, 0x9D, 0xF3 + }, + { + 0x86, 0x03, 0x32, 0x50, 0xA8, 0xA2, 0x25, 0xE0, + 0x13, 0x74, 0xFC, 0x9F, 0xC5, 0x56, 0x0C, 0x33, + 0x86, 0xCA, 0x06, 0x00, 0x1D, 0x5A, 0x08, 0x5A, + 0xC2, 0x08, 0xB6, 0xA8, 0xFE, 0x5B, 0xB7, 0x20 + }, + { + 0xA7, 0x30, 0x6F, 0x13, 0xB8, 0xBE, 0x07, 0x2B, + 0x60, 0xE5, 0x44, 0xD8, 0xFA, 0xF7, 0xC7, 0xFC, + 0x7B, 0x27, 0x5A, 0x75, 0xBA, 0xA2, 0xB7, 0x5C, + 0xE4, 0x6C, 0x6B, 0x33, 0x47, 0x26, 0xBC, 0x88 + }, + { + 0xAB, 0xC9, 0x4E, 0x86, 0x11, 0xE8, 0xDB, 0xCC, + 0x2D, 0x4F, 0xE7, 0x8E, 0x3A, 0x62, 0x05, 0xF7, + 0xE5, 0x5F, 0xDF, 0x82, 0x46, 0x85, 0xAF, 0xB5, + 0xD2, 0x5D, 0x6C, 0x91, 0x8B, 0xD2, 0x0F, 0x91 + }, + { + 0x6C, 0x32, 0x52, 0x9E, 0xF1, 0x49, 0xE4, 0xE3, + 0xC6, 0xD6, 0x8D, 0x07, 0xF2, 0x77, 0x58, 0x9C, + 0x95, 0xC5, 0x5D, 0xF5, 0x07, 0xF6, 0xF9, 0x75, + 0x2D, 0x4F, 0xD6, 0x34, 0xE5, 0x14, 0x4F, 0xF7 + }, + { + 0x3E, 0x72, 0x07, 0x8D, 0x34, 0x06, 0xE7, 0xDC, + 0xB1, 0x56, 0x79, 0xE0, 0x0B, 0xC3, 0x09, 0x68, + 0xDB, 0xE0, 0x7D, 0x17, 0x02, 0x4A, 0x23, 0x3F, + 0x5E, 0xF5, 0x3A, 0x7B, 0xD3, 0xC7, 0x1E, 0xB4 + }, + { + 0x01, 0xB9, 0xE6, 0x7F, 0xDD, 0x2B, 0x42, 0x8C, + 0xD3, 0xFF, 0xA7, 0x18, 0x3A, 0xAB, 0x02, 0x7F, + 0x32, 0x18, 0x24, 0x01, 0x15, 0xC0, 0x83, 0x03, + 0xDE, 0x93, 0xB3, 0x11, 0x3D, 0xC7, 0xEC, 0x5A + }, + { + 0xB3, 0xF9, 0x8E, 0xB6, 0x9F, 0x70, 0xB5, 0xEA, + 0x59, 0xDD, 0xEB, 0x0C, 0x3A, 0x1E, 0xB8, 0x27, + 0xE4, 0xAC, 0x30, 0xD1, 0x3D, 0xFF, 0xDF, 0x1F, + 0x75, 0x62, 0xC6, 0x12, 0xB6, 0x8C, 0x32, 0xBB + }, + { + 0x83, 0xC4, 0xD7, 0x60, 0x05, 0x7F, 0x1A, 0xBA, + 0xC1, 0x5A, 0xBC, 0x34, 0x92, 0xFD, 0x2F, 0x94, + 0x01, 0x03, 0x84, 0x33, 0x74, 0xED, 0xDB, 0x30, + 0x62, 0x46, 0x06, 0xA8, 0x69, 0xE3, 0x35, 0xC8 + }, + { + 0x0B, 0x57, 0x8F, 0xE9, 0xFE, 0xAB, 0xEC, 0xB7, + 0x54, 0xE4, 0xD7, 0x0F, 0x66, 0x22, 0xF4, 0xD9, + 0x0D, 0x56, 0x61, 0xE6, 0x32, 0x2D, 0x05, 0x8B, + 0xBC, 0xF3, 0x9A, 0x62, 0x71, 0xB6, 0xCA, 0xE2 + }, + { + 0x00, 0xB0, 0x11, 0x4B, 0xB3, 0xCF, 0x74, 0xB0, + 0x3B, 0xF5, 0x36, 0x68, 0x88, 0xF2, 0x1F, 0xF6, + 0x0A, 0x1F, 0x5F, 0xDF, 0xCC, 0xF8, 0xE5, 0xF1, + 0x9C, 0x50, 0x5E, 0x0A, 0x5A, 0xB5, 0x4B, 0x99 + }, + { + 0xB3, 0x3D, 0x0C, 0xA1, 0x85, 0x92, 0x1D, 0xCA, + 0xA6, 0x42, 0x23, 0xEB, 0xE1, 0x2D, 0xFF, 0x56, + 0xAA, 0x9E, 0x7B, 0x66, 0xB8, 0xEC, 0x14, 0x0A, + 0x60, 0xA6, 0x94, 0x3B, 0xEB, 0x10, 0xC3, 0x40 + }, + { + 0xD7, 0xCA, 0x5C, 0x89, 0xBB, 0x46, 0x55, 0x8C, + 0xF2, 0xB8, 0x4B, 0x71, 0x33, 0x11, 0x14, 0x04, + 0x1D, 0x1A, 0xF4, 0x13, 0x67, 0x3B, 0x53, 0x04, + 0xEF, 0x47, 0xB1, 0x2E, 0x04, 0x76, 0x70, 0x43 + }, + { + 0x2C, 0x11, 0x67, 0xF3, 0x60, 0x6A, 0xCF, 0x13, + 0x23, 0x73, 0xFC, 0x7A, 0x40, 0xDD, 0xF8, 0xA3, + 0xC1, 0x19, 0x35, 0x4D, 0xE9, 0x2B, 0xEA, 0x5B, + 0xC6, 0xEF, 0x89, 0x53, 0xC4, 0xA8, 0x3A, 0x25 + }, + { + 0xF8, 0x33, 0xA2, 0xC8, 0x75, 0xB3, 0xD7, 0x7E, + 0x18, 0x9F, 0x90, 0x9D, 0xE3, 0x2B, 0xED, 0x45, + 0x8D, 0x6B, 0x81, 0x23, 0xF8, 0xD7, 0x9A, 0xAD, + 0xD1, 0xD9, 0x20, 0x92, 0x49, 0xC9, 0xD5, 0x30 + }, + { + 0x40, 0xC7, 0xF1, 0xA3, 0xDD, 0x83, 0xB4, 0x00, + 0x36, 0x31, 0x32, 0x5D, 0x60, 0x42, 0x8A, 0xC0, + 0x8A, 0x03, 0xE4, 0x0A, 0xAC, 0x59, 0xAE, 0xCA, + 0xF8, 0xAC, 0x3C, 0x93, 0x7C, 0x62, 0x21, 0xAC + }, + { + 0x73, 0x3F, 0xF8, 0x21, 0x51, 0x67, 0xD0, 0x9D, + 0xEC, 0x24, 0x46, 0xA4, 0xC5, 0xB7, 0xC7, 0xA0, + 0x13, 0xB9, 0x45, 0x6F, 0x10, 0x5F, 0x00, 0x7F, + 0x86, 0xCC, 0xB4, 0x95, 0xD8, 0xF8, 0x09, 0x0D + }, + { + 0x47, 0xEB, 0x7F, 0xD8, 0x49, 0xDE, 0xD6, 0xB4, + 0xC9, 0xC7, 0x69, 0xB5, 0x02, 0xD5, 0x8F, 0x58, + 0xD8, 0x13, 0xE9, 0x75, 0xCC, 0x40, 0x16, 0x2C, + 0x3B, 0x52, 0x42, 0x44, 0xEF, 0xA3, 0xF1, 0xBB + }, + { + 0xC5, 0x7C, 0x45, 0x81, 0x81, 0xA3, 0xFA, 0x57, + 0x07, 0x31, 0x58, 0x3B, 0x71, 0x8A, 0x0A, 0xC8, + 0x54, 0xC6, 0x7E, 0xBB, 0x5C, 0x44, 0xD9, 0xBE, + 0x8E, 0xA0, 0xFA, 0x5A, 0x5C, 0x47, 0x78, 0x20 + }, + { + 0x8E, 0x48, 0xD8, 0x4A, 0x1B, 0x21, 0xF1, 0x77, + 0x37, 0x10, 0x28, 0x1D, 0xF2, 0x89, 0xF6, 0x9E, + 0x50, 0xE3, 0x44, 0x4A, 0x93, 0x22, 0x70, 0xDC, + 0xCA, 0x16, 0x19, 0x76, 0x43, 0x28, 0x92, 0x00 + }, + { + 0x1C, 0x47, 0x2E, 0x73, 0xF7, 0x0C, 0x49, 0x79, + 0xA0, 0xB4, 0x1D, 0xF6, 0x21, 0x41, 0x5D, 0xC5, + 0xF2, 0x6F, 0xED, 0x35, 0x35, 0xB6, 0x6E, 0xBC, + 0x46, 0x18, 0xC1, 0x1E, 0xB8, 0x4E, 0x21, 0x35 + }, + { + 0x2E, 0xDB, 0x88, 0x73, 0xCC, 0x2C, 0x2B, 0x1D, + 0xDD, 0xE5, 0x73, 0xEA, 0xBF, 0x57, 0x14, 0x53, + 0x14, 0xDA, 0x1A, 0x11, 0x24, 0x47, 0xB9, 0x57, + 0xD0, 0x29, 0x4B, 0xD5, 0xB5, 0xAA, 0xE0, 0x3C + }, + { + 0xAB, 0xFC, 0x7B, 0x86, 0xB7, 0xA2, 0xB4, 0x53, + 0xA3, 0xE8, 0x8B, 0xFD, 0xC5, 0x7B, 0x9B, 0x11, + 0x73, 0x63, 0xA7, 0x5B, 0x05, 0x8C, 0x1D, 0xC8, + 0xB3, 0x77, 0x1B, 0xE8, 0x34, 0x9F, 0x43, 0xD4 + }, + { + 0xA7, 0xF6, 0x17, 0x49, 0x33, 0x0F, 0xB9, 0x60, + 0xF3, 0xBA, 0xA3, 0xDC, 0x66, 0x6E, 0x57, 0x05, + 0x9B, 0x84, 0x92, 0x58, 0x29, 0x6B, 0xDA, 0x0B, + 0xAF, 0x76, 0x7A, 0x2C, 0x09, 0x8B, 0x5E, 0x65 + }, + { + 0x14, 0x0A, 0x80, 0x1A, 0x18, 0x34, 0xB9, 0x14, + 0x97, 0x95, 0x23, 0x63, 0xF7, 0x5E, 0xB2, 0x6A, + 0x95, 0x73, 0x06, 0xB0, 0x6B, 0x5E, 0xAB, 0x8D, + 0xFE, 0x7D, 0xA7, 0x02, 0xBA, 0xF8, 0x80, 0xF2 + }, + { + 0xF0, 0xB3, 0x86, 0x3B, 0xF7, 0x45, 0x43, 0x06, + 0x16, 0x80, 0x4F, 0x48, 0xE8, 0xC1, 0xF4, 0xBB, + 0x4E, 0x89, 0x04, 0x7F, 0x77, 0x68, 0x23, 0xC3, + 0x73, 0x04, 0xB2, 0x38, 0xF4, 0x90, 0x1A, 0xEE + }, + { + 0x50, 0xE2, 0xC4, 0x68, 0x14, 0x13, 0x16, 0x63, + 0x3F, 0x39, 0x6B, 0x23, 0x60, 0xD4, 0x92, 0xB6, + 0x8B, 0x00, 0x3F, 0x82, 0x28, 0x80, 0x80, 0x65, + 0x70, 0x92, 0xA7, 0x95, 0x34, 0x34, 0x0C, 0xE6 + }, + { + 0xBA, 0x21, 0xB4, 0xFB, 0x4B, 0xC0, 0x5F, 0x63, + 0xFB, 0xCE, 0x67, 0x8B, 0xD7, 0x6C, 0x28, 0x72, + 0x06, 0xE4, 0x09, 0xDA, 0xB6, 0x63, 0xA2, 0x10, + 0x13, 0xFF, 0xBF, 0x27, 0x64, 0x06, 0xF4, 0x9B + }, + { + 0xD6, 0x3D, 0x5C, 0x9C, 0xDA, 0x0D, 0x83, 0x23, + 0x23, 0xE2, 0x8B, 0x26, 0xEE, 0x51, 0x66, 0x5E, + 0x18, 0xA8, 0xCE, 0x6F, 0xE9, 0xC2, 0x19, 0xB0, + 0x69, 0x99, 0x13, 0x9D, 0xC3, 0x85, 0xB5, 0x25 + }, + { + 0x6C, 0xB7, 0xDB, 0x4C, 0x64, 0xA2, 0xAE, 0x53, + 0xD1, 0x4F, 0xB6, 0x6D, 0xE3, 0xB6, 0xB2, 0x7F, + 0x39, 0x11, 0xAA, 0xE3, 0x78, 0x56, 0x52, 0xC7, + 0xCE, 0x41, 0x4F, 0x14, 0xBA, 0xF3, 0x8B, 0x27 + }, + { + 0xE1, 0x39, 0x26, 0xF1, 0xD7, 0x9C, 0x0F, 0x7C, + 0xFD, 0xC7, 0x2C, 0xEC, 0xEC, 0xAE, 0x88, 0x66, + 0x84, 0x8D, 0x1A, 0x85, 0x31, 0x0F, 0xE7, 0x64, + 0xA3, 0x3B, 0x61, 0xD7, 0x66, 0xB0, 0xE8, 0x72 + }, + { + 0x6F, 0x83, 0x00, 0x99, 0xF0, 0x04, 0x43, 0x22, + 0x25, 0xD8, 0x3B, 0x24, 0xCA, 0x7D, 0x06, 0x7C, + 0x07, 0x75, 0xDA, 0x1C, 0xC6, 0x3D, 0x3D, 0x6E, + 0x99, 0x59, 0xCE, 0xC3, 0x81, 0x1D, 0xFA, 0x5E + }, + { + 0x83, 0x2C, 0xA2, 0x43, 0xA7, 0x6B, 0xC1, 0xE8, + 0x5E, 0x0D, 0x03, 0x3B, 0x25, 0x8E, 0x0B, 0x9D, + 0x5A, 0x48, 0xCA, 0x6A, 0x34, 0x9D, 0x6A, 0x94, + 0xF2, 0xCF, 0xD1, 0x01, 0xDF, 0x7B, 0x57, 0xBD + }, + { + 0x4D, 0x79, 0x7D, 0x75, 0x2A, 0x55, 0xF0, 0x75, + 0x7B, 0x0B, 0x1D, 0xEC, 0xCD, 0xB6, 0xCE, 0x44, + 0x7C, 0xE2, 0xC5, 0x9C, 0x36, 0x3B, 0x3F, 0x3A, + 0x3E, 0x8B, 0x72, 0x94, 0x4D, 0x68, 0x9D, 0xD7 + }, + { + 0xD6, 0x2A, 0xA4, 0x1B, 0x11, 0xAD, 0xD2, 0x7D, + 0xA6, 0x07, 0x89, 0xA1, 0x18, 0x5C, 0x26, 0x84, + 0x58, 0xAA, 0x43, 0xCD, 0xEB, 0x4F, 0x17, 0xD2, + 0x10, 0xA8, 0x27, 0x15, 0x9C, 0xF4, 0x0B, 0xCA + }, + { + 0x75, 0x65, 0xB3, 0xC4, 0xC0, 0x3F, 0x35, 0x11, + 0xA2, 0x61, 0x92, 0x74, 0x84, 0xCD, 0xD3, 0x31, + 0xAD, 0x3F, 0xBF, 0x82, 0x11, 0xD1, 0x23, 0x7C, + 0x8C, 0x0F, 0xC1, 0x7B, 0x3D, 0x59, 0xF7, 0x5C + }, + { + 0x29, 0x9F, 0xAD, 0x22, 0x7A, 0x35, 0xCB, 0x2E, + 0xF0, 0x77, 0x15, 0x98, 0x1A, 0xEC, 0x1E, 0xA7, + 0xD2, 0x5C, 0xFD, 0x00, 0x83, 0x0D, 0x41, 0x7C, + 0x62, 0xEC, 0x45, 0x49, 0x0A, 0x6F, 0x8E, 0x91 + }, + { + 0x10, 0x49, 0x01, 0xCE, 0x5A, 0xC6, 0x68, 0xCC, + 0x1A, 0x3E, 0x91, 0xDD, 0xD8, 0x1A, 0xF6, 0x6D, + 0xC9, 0xC2, 0x63, 0x8E, 0xF6, 0x76, 0xA8, 0x76, + 0x1D, 0xB4, 0xE4, 0xDD, 0x15, 0x01, 0xBD, 0x4F + }, + { + 0xED, 0x9D, 0x50, 0xF5, 0xFF, 0x39, 0x60, 0x56, + 0x5D, 0xB5, 0xCB, 0x63, 0xDF, 0x7E, 0xA5, 0xE1, + 0xC2, 0x6B, 0x58, 0x59, 0x80, 0xB6, 0x52, 0x63, + 0x89, 0x8C, 0xAE, 0x05, 0xD6, 0xFE, 0x7C, 0xEB + }, + { + 0x36, 0xB1, 0xAF, 0xB9, 0x56, 0x48, 0x4F, 0x4C, + 0x9B, 0xA9, 0x81, 0x84, 0xE6, 0x5B, 0xB6, 0x26, + 0x87, 0xD7, 0xC9, 0x87, 0x67, 0xE2, 0x60, 0x4A, + 0xE7, 0x18, 0x4E, 0xB5, 0x90, 0x42, 0x34, 0x64 + }, + { + 0x80, 0xEE, 0xF3, 0x21, 0x04, 0xD7, 0x99, 0xD3, + 0x7E, 0x9A, 0xD1, 0x3A, 0xA8, 0xA3, 0x70, 0x6E, + 0xCA, 0x91, 0x33, 0xB0, 0xA2, 0x14, 0xA5, 0xC6, + 0xD1, 0xDD, 0x14, 0x3E, 0x42, 0xD9, 0x94, 0x24 + }, + { + 0x97, 0x4B, 0xA2, 0x15, 0x84, 0x34, 0x78, 0xBA, + 0x4C, 0xD0, 0x2F, 0x07, 0x7D, 0x8C, 0x24, 0x98, + 0xE5, 0x1B, 0x45, 0x20, 0x24, 0x33, 0x75, 0x19, + 0x07, 0xDD, 0x4A, 0x8F, 0xE2, 0xC6, 0x5F, 0xE1 + }, + { + 0xCD, 0xB1, 0xBB, 0xB1, 0xF0, 0x97, 0xA3, 0x94, + 0x51, 0xDD, 0xAC, 0x3C, 0xF0, 0xDA, 0x05, 0x2C, + 0x59, 0x09, 0xA3, 0x35, 0xA4, 0x0E, 0x18, 0x68, + 0xFB, 0xF0, 0x62, 0x0F, 0x59, 0xC2, 0x8A, 0xFD + }, + { + 0xBB, 0x7E, 0xCD, 0x80, 0x87, 0x4B, 0xC8, 0xF6, + 0xBA, 0xF7, 0x1C, 0x3A, 0x36, 0x14, 0xC2, 0x53, + 0x2F, 0x51, 0x05, 0x01, 0x91, 0x34, 0xAE, 0x7C, + 0x88, 0x39, 0x6D, 0x44, 0x79, 0x9A, 0xE2, 0x8B + }, + { + 0x83, 0x6D, 0xD8, 0xA4, 0x0E, 0x8A, 0xEE, 0x4A, + 0xD0, 0x32, 0x8E, 0xF6, 0xC5, 0x51, 0xFF, 0x97, + 0xAA, 0x94, 0xC8, 0x30, 0xA6, 0x04, 0x00, 0xCA, + 0x1B, 0xC5, 0x7A, 0x26, 0xD1, 0xE8, 0x8F, 0x21 + }, + { + 0xF2, 0xE8, 0x4F, 0xFE, 0x62, 0x40, 0x9F, 0xEA, + 0x3A, 0x22, 0x6A, 0x40, 0xA1, 0x2D, 0xB9, 0x63, + 0x8C, 0x09, 0xA9, 0x0C, 0x7F, 0x77, 0x59, 0x34, + 0x6E, 0x32, 0x32, 0x36, 0x06, 0x52, 0x94, 0x03 + }, + { + 0x89, 0x1B, 0x6A, 0x6E, 0xF5, 0x8C, 0xA7, 0x4A, + 0x36, 0xE4, 0x78, 0x33, 0x6C, 0x19, 0xBF, 0x39, + 0xEC, 0x75, 0xDD, 0x28, 0xD3, 0xC4, 0xBE, 0x8E, + 0x62, 0x6A, 0xB1, 0x36, 0x14, 0x83, 0xA6, 0xB7 + }, + { + 0xA2, 0x47, 0x73, 0x40, 0x59, 0x2A, 0xCB, 0xE7, + 0x45, 0x70, 0xF8, 0x15, 0x28, 0xDC, 0x27, 0x9A, + 0x08, 0x1B, 0xA9, 0x75, 0xEE, 0x04, 0x38, 0x93, + 0xAA, 0x33, 0x3E, 0x94, 0x86, 0xC2, 0x2C, 0xE5 + }, + { + 0xEE, 0x86, 0x7D, 0x6D, 0xBD, 0xE3, 0x03, 0xD5, + 0xB3, 0xC6, 0xB7, 0x73, 0x86, 0xEA, 0x20, 0x6B, + 0x52, 0x2C, 0x50, 0xFA, 0xF8, 0xE9, 0xDB, 0xFC, + 0x45, 0x5F, 0xA2, 0x44, 0x85, 0x37, 0x5B, 0x0B + }, + { + 0xF5, 0x9C, 0x41, 0xB9, 0x8E, 0x6E, 0x70, 0x91, + 0xC1, 0x75, 0x37, 0xD2, 0xF8, 0x5C, 0xFD, 0x97, + 0x43, 0x58, 0xFB, 0x0E, 0x37, 0x0E, 0x87, 0x08, + 0x73, 0x86, 0x5B, 0x14, 0x20, 0xBE, 0xBB, 0x25 + }, + { + 0xDA, 0x97, 0x9E, 0x61, 0xEC, 0x46, 0x71, 0xE8, + 0x76, 0x3D, 0xED, 0x29, 0x19, 0x47, 0x04, 0x6B, + 0x43, 0xC7, 0x52, 0xD9, 0x2B, 0x96, 0x24, 0xAC, + 0x2C, 0x60, 0xB7, 0x82, 0xD3, 0x00, 0x1A, 0xE7 + }, + { + 0x20, 0x07, 0x93, 0x47, 0xBA, 0xCA, 0x28, 0xBB, + 0x90, 0x40, 0x21, 0x20, 0x30, 0x08, 0x44, 0xA2, + 0x75, 0xDD, 0xE0, 0xE7, 0xAD, 0x4A, 0x10, 0xCF, + 0xC3, 0x1D, 0xDD, 0x68, 0x24, 0x2E, 0x17, 0x6E + }, + { + 0x57, 0xAA, 0x83, 0x72, 0x01, 0xE3, 0x2F, 0x33, + 0x0A, 0x45, 0x20, 0xE6, 0x1A, 0x75, 0x30, 0xDD, + 0xD6, 0xCC, 0x14, 0xF9, 0x3F, 0x18, 0xBB, 0x4C, + 0x92, 0x9E, 0x1E, 0x1D, 0xE0, 0x1D, 0x2A, 0x8C + }, + { + 0x00, 0x26, 0x5B, 0x50, 0xAD, 0x6A, 0xCD, 0xA2, + 0x7D, 0xA2, 0xBF, 0x85, 0x28, 0x44, 0x9F, 0x9C, + 0x57, 0x80, 0x66, 0x7F, 0xDD, 0xF7, 0x79, 0x40, + 0xAA, 0x71, 0x63, 0x81, 0x57, 0xFC, 0x35, 0xAF + }, + { + 0xC3, 0xAB, 0x99, 0xE7, 0x8B, 0x75, 0x4F, 0x53, + 0x20, 0x37, 0xEE, 0x20, 0xEC, 0x01, 0x13, 0x4B, + 0xB4, 0x2A, 0xE0, 0x18, 0xCE, 0xD6, 0x53, 0x5B, + 0x58, 0xE2, 0xDE, 0x04, 0x15, 0x50, 0x4F, 0x21 + }, + { + 0x25, 0x4E, 0xB7, 0xB1, 0xBE, 0xEE, 0xE5, 0xF7, + 0xAF, 0xD3, 0xF9, 0x70, 0x51, 0x1E, 0xEE, 0x69, + 0x6C, 0x1C, 0x25, 0x38, 0x41, 0x74, 0xFA, 0xAA, + 0xB1, 0xC5, 0x5A, 0x88, 0xBF, 0x82, 0xD4, 0x38 + }, + { + 0xF8, 0xE3, 0xE7, 0x85, 0x87, 0x85, 0x06, 0xDB, + 0x87, 0x15, 0xC5, 0x14, 0x70, 0x49, 0xA6, 0x8C, + 0x5A, 0x2E, 0x4F, 0x1B, 0xE2, 0x3B, 0x0F, 0x61, + 0x03, 0xAA, 0xC8, 0x9B, 0x0F, 0x3B, 0x3A, 0x22 + }, + { + 0x48, 0xB4, 0xF7, 0x0A, 0x28, 0x56, 0x4B, 0x3E, + 0x06, 0x10, 0x2D, 0xFD, 0x66, 0x58, 0x8F, 0x46, + 0x89, 0x96, 0x00, 0x8B, 0xD5, 0xA6, 0x28, 0xA8, + 0x1B, 0x2B, 0x0A, 0x1B, 0xAF, 0x8C, 0x56, 0x13 + }, + { + 0xED, 0xED, 0xCC, 0x92, 0x2B, 0xE2, 0x9D, 0x3C, + 0x98, 0xCF, 0xF6, 0x6E, 0x7D, 0xEC, 0xC2, 0x5D, + 0x25, 0x4E, 0xA2, 0xDF, 0xA9, 0xF9, 0xEC, 0xFE, + 0xCA, 0x63, 0x8D, 0x81, 0xDA, 0x59, 0x7A, 0xE4 + }, + { + 0xDE, 0x05, 0x8B, 0x59, 0xD5, 0xAE, 0xE3, 0x50, + 0x87, 0xD8, 0xFE, 0xEE, 0xE6, 0xD0, 0x88, 0x47, + 0xB8, 0xA6, 0xDA, 0x25, 0x14, 0xC3, 0x5A, 0x5F, + 0xF3, 0xA7, 0x83, 0x98, 0xD0, 0x1F, 0xBD, 0xD8 + }, + { + 0x05, 0x37, 0x18, 0x5A, 0xB2, 0x22, 0xE1, 0x46, + 0x24, 0x8B, 0x24, 0xC1, 0x34, 0x76, 0x35, 0xD4, + 0x8F, 0x40, 0x4A, 0x3F, 0xA8, 0x52, 0xE5, 0x48, + 0xCC, 0x7A, 0x2C, 0xF1, 0x26, 0x41, 0xB8, 0x3A + }, + { + 0x15, 0x9E, 0x51, 0x81, 0x09, 0xF8, 0x1D, 0x61, + 0xDC, 0x3D, 0x99, 0xBB, 0x30, 0xD7, 0xB0, 0xE5, + 0x73, 0xD6, 0x4F, 0xA3, 0x30, 0xE0, 0x38, 0x84, + 0xBE, 0x3E, 0x58, 0x28, 0x78, 0x19, 0x9D, 0xCF + }, + { + 0x06, 0x7A, 0xFB, 0x1B, 0x56, 0x3D, 0x85, 0xDD, + 0x07, 0x12, 0x2F, 0x46, 0x9B, 0xF1, 0x4F, 0x72, + 0x4A, 0xD2, 0x86, 0xC1, 0x5D, 0x14, 0x90, 0x96, + 0xC7, 0xF6, 0x5C, 0xBF, 0x9B, 0xBB, 0x58, 0xCB + }, + { + 0xCF, 0x90, 0x11, 0x77, 0x28, 0xAE, 0xAC, 0x61, + 0x91, 0xA7, 0x17, 0x1C, 0xBF, 0xAF, 0x77, 0x56, + 0xC0, 0x29, 0x35, 0xDA, 0x93, 0xA1, 0xCB, 0x62, + 0xB8, 0x4D, 0x84, 0x21, 0x29, 0xA4, 0xCA, 0xBD + }, + { + 0xA4, 0x41, 0x8C, 0x49, 0x68, 0x8C, 0x90, 0xE8, + 0xDF, 0x6E, 0x49, 0xD0, 0x7C, 0x6B, 0x4F, 0x17, + 0x6D, 0x2B, 0x47, 0xAB, 0x56, 0xA2, 0xB6, 0x0E, + 0x8B, 0x6A, 0x1F, 0x15, 0xD6, 0x32, 0x04, 0x48 + }, + { + 0x01, 0x44, 0x9A, 0x18, 0x68, 0x47, 0x5C, 0x7B, + 0x08, 0x0B, 0xC9, 0x7B, 0xFB, 0xA7, 0xEA, 0xD9, + 0xB5, 0x5B, 0x8E, 0x50, 0x19, 0x83, 0x6A, 0xB9, + 0xC3, 0x7A, 0x91, 0x05, 0x64, 0xCD, 0x16, 0xF1 + }, + { + 0xB6, 0x73, 0x06, 0x7B, 0xB7, 0x56, 0x51, 0xC2, + 0xF5, 0x58, 0x84, 0xE9, 0x94, 0x0D, 0xBF, 0xA7, + 0xF6, 0x2F, 0xAA, 0x1A, 0xF8, 0x87, 0xDC, 0x06, + 0x86, 0xF9, 0xF4, 0xDD, 0x1D, 0x65, 0xDC, 0xF0 + }, + { + 0x74, 0x08, 0xA0, 0x6D, 0xC4, 0x70, 0xA4, 0x8F, + 0x75, 0x9C, 0xFB, 0x96, 0xD9, 0x0E, 0x3F, 0x8B, + 0xEE, 0x9C, 0x7F, 0x5B, 0xD5, 0x2A, 0xA5, 0x28, + 0xC6, 0x10, 0x15, 0xB5, 0x25, 0xF7, 0x4B, 0xAC + }, + { + 0x14, 0xCC, 0x74, 0x01, 0x75, 0x82, 0x59, 0xF4, + 0xF0, 0x67, 0x37, 0xD0, 0xED, 0x33, 0x6E, 0xC8, + 0x48, 0xAB, 0x13, 0xC2, 0x35, 0x4F, 0xDC, 0xD0, + 0x06, 0x31, 0xE4, 0x35, 0xDA, 0x35, 0x1A, 0x0A + }, + { + 0xA9, 0xDE, 0x97, 0x8C, 0xB4, 0xA7, 0xFE, 0x27, + 0x3B, 0x7A, 0xFB, 0x5C, 0x52, 0xE6, 0x63, 0x25, + 0x40, 0x25, 0x5C, 0x2D, 0x54, 0x5A, 0xBD, 0x35, + 0xBE, 0xF7, 0x47, 0x63, 0x7D, 0x0A, 0xFA, 0x70 + }, + { + 0x8D, 0x65, 0x7B, 0x82, 0xEE, 0x1C, 0xE2, 0x84, + 0xFB, 0xF0, 0x68, 0x0F, 0x0E, 0x1D, 0xCB, 0x7A, + 0x1D, 0x1B, 0x64, 0x81, 0x10, 0x06, 0xEF, 0x0A, + 0x5E, 0x46, 0x40, 0x44, 0xAD, 0x21, 0xEB, 0xA7 + }, + { + 0x41, 0x39, 0xB1, 0x6F, 0x5D, 0x79, 0x95, 0x48, + 0x58, 0x99, 0x68, 0x2C, 0x1B, 0x64, 0xF4, 0x0E, + 0xBC, 0x6B, 0xE5, 0x18, 0xE4, 0xA8, 0x0C, 0x40, + 0x22, 0xAD, 0x9A, 0x1D, 0x0B, 0x75, 0x23, 0x87 + }, + { + 0xDD, 0xB7, 0x21, 0x85, 0x57, 0x41, 0x00, 0x3D, + 0xB6, 0xE9, 0x1C, 0xAB, 0xC2, 0xED, 0x86, 0x2B, + 0xFF, 0xD2, 0x83, 0x36, 0xEF, 0xF9, 0x0E, 0x07, + 0xFF, 0xB2, 0x55, 0xA9, 0x53, 0xE3, 0xEA, 0x92 + }, + { + 0x22, 0x40, 0xAC, 0xCC, 0x4E, 0xB1, 0x73, 0x8C, + 0x6D, 0x95, 0x33, 0x8B, 0xDB, 0x41, 0xE2, 0xF8, + 0xAE, 0xAC, 0xF4, 0x24, 0x62, 0x68, 0xA7, 0x97, + 0x01, 0xF3, 0x85, 0xB1, 0x00, 0x45, 0x8A, 0x2D + }, + { + 0x8E, 0xC5, 0xFE, 0x01, 0x8E, 0x52, 0xE9, 0xB1, + 0x93, 0x33, 0x9C, 0xD6, 0x7A, 0xC3, 0x98, 0x33, + 0xCB, 0xE2, 0xA1, 0xB5, 0xFC, 0x42, 0xA8, 0x87, + 0xBE, 0x2A, 0x1B, 0xA6, 0xD6, 0x89, 0x2E, 0x05 + }, + { + 0x68, 0x1F, 0x43, 0x00, 0x95, 0x9B, 0xC5, 0x07, + 0x83, 0x6D, 0x4B, 0xDA, 0x91, 0x2E, 0xB9, 0xC5, + 0x98, 0x99, 0xB8, 0x53, 0x4F, 0x04, 0x8D, 0xA9, + 0x40, 0x2D, 0x8B, 0x53, 0x1A, 0xF4, 0xA1, 0x16 + }, + { + 0x42, 0xC8, 0xC3, 0xA3, 0x1F, 0x6B, 0xF6, 0x9C, + 0xE5, 0xDC, 0xCA, 0x62, 0x34, 0x3F, 0x94, 0x0D, + 0xE5, 0x18, 0x55, 0x8C, 0x44, 0xA9, 0x4A, 0xE0, + 0x42, 0x83, 0x14, 0xBB, 0x0D, 0xB3, 0x42, 0xF8 + }, + { + 0x49, 0x39, 0xAF, 0x00, 0xA2, 0xD1, 0xC2, 0x90, + 0x60, 0xB8, 0x2E, 0x70, 0xB4, 0xE9, 0x34, 0xEC, + 0xAA, 0xBE, 0x14, 0xDA, 0x01, 0x8F, 0x7D, 0x64, + 0xAF, 0x49, 0x11, 0x6F, 0xF3, 0xF9, 0xE3, 0x22 + }, + { + 0x34, 0x69, 0x75, 0xF3, 0x94, 0x38, 0x4A, 0x40, + 0x5F, 0x8E, 0x80, 0x0A, 0x5E, 0xD1, 0x40, 0xD7, + 0x4A, 0xF1, 0xAC, 0x7E, 0x82, 0x7B, 0x94, 0xCF, + 0x8C, 0x90, 0xFC, 0x62, 0x68, 0x23, 0x27, 0xA7 + }, + { + 0x7A, 0x89, 0x11, 0x42, 0x26, 0x76, 0x3E, 0xAB, + 0xD0, 0x08, 0x4B, 0xAD, 0xC1, 0xA5, 0x20, 0x01, + 0xD3, 0xEA, 0xAF, 0x8D, 0xFC, 0x2C, 0x39, 0xA4, + 0xA2, 0xD1, 0x2A, 0xF2, 0x4D, 0xFD, 0x08, 0x83 + }, + { + 0x28, 0x80, 0x5E, 0x17, 0xBD, 0x6F, 0xFD, 0x04, + 0x57, 0xEB, 0xDC, 0x6F, 0xCD, 0x3D, 0x59, 0x0A, + 0xF9, 0xCF, 0xF1, 0x76, 0x50, 0x9D, 0xC1, 0x15, + 0x41, 0x95, 0x57, 0x45, 0x92, 0xB5, 0x6E, 0xF5 + }, + { + 0x49, 0x8D, 0x9E, 0x18, 0x48, 0x53, 0x93, 0x75, + 0x90, 0x22, 0xE1, 0x3C, 0x04, 0x50, 0x35, 0xE6, + 0xCD, 0xDD, 0xF0, 0x6B, 0xEE, 0x5C, 0xA8, 0x84, + 0x02, 0x67, 0x28, 0xDF, 0x85, 0x64, 0x5D, 0xED + }, + { + 0x2B, 0x01, 0x56, 0x6E, 0x52, 0x4D, 0xF5, 0x92, + 0xA3, 0xCC, 0x13, 0x09, 0x05, 0x47, 0xCC, 0xA7, + 0x61, 0x62, 0xAB, 0xA8, 0x3A, 0x3D, 0xE1, 0x2C, + 0x0D, 0xC2, 0x00, 0x22, 0x6E, 0xBE, 0xC6, 0xAE + }, + { + 0x22, 0xAE, 0x93, 0x67, 0x17, 0xCD, 0x88, 0xF5, + 0xA9, 0xCF, 0xEF, 0x40, 0xC2, 0xE7, 0xB4, 0x01, + 0xFA, 0x55, 0x39, 0xA5, 0xB3, 0xA0, 0xA3, 0x58, + 0xCC, 0x9D, 0x01, 0x44, 0x57, 0xF8, 0xDA, 0x9D + }, + { + 0x5C, 0x6D, 0x24, 0x27, 0x3C, 0xD6, 0x17, 0x3E, + 0xF8, 0x06, 0xBE, 0xFE, 0x7A, 0x3E, 0x27, 0x5A, + 0x4F, 0x8A, 0xE0, 0xBF, 0x63, 0xC6, 0xBD, 0xB3, + 0x7E, 0x49, 0x35, 0x6B, 0x4C, 0x98, 0x75, 0x1B + }, + { + 0x75, 0x6E, 0x62, 0xF9, 0x23, 0x07, 0x2E, 0xA6, + 0xD9, 0x01, 0xBF, 0x6C, 0xF4, 0x62, 0xB0, 0xDF, + 0xBD, 0x25, 0x9C, 0xD0, 0x83, 0x3A, 0x28, 0xBA, + 0x2A, 0xAC, 0x08, 0x0B, 0x01, 0x88, 0x0C, 0x5B + }, + { + 0x4B, 0x07, 0x1A, 0x77, 0x62, 0x8D, 0xCB, 0xB9, + 0x84, 0xC6, 0xC2, 0xBA, 0xFC, 0x4D, 0x1D, 0xFC, + 0x73, 0xEA, 0x97, 0xD6, 0x7F, 0x28, 0x36, 0xB8, + 0xFF, 0xBF, 0xCD, 0x48, 0xA9, 0x5F, 0x99, 0x50 + }, + { + 0xC5, 0xE9, 0x62, 0xAB, 0xB1, 0xAD, 0x44, 0x5C, + 0x3A, 0x3F, 0xC1, 0xB2, 0x34, 0x9C, 0xA5, 0xFF, + 0x79, 0x3E, 0xEE, 0x8A, 0xED, 0x26, 0xB6, 0x54, + 0x66, 0x07, 0xE9, 0x63, 0x71, 0xCA, 0x84, 0xC3 + }, + { + 0x10, 0x80, 0xFF, 0xE6, 0x46, 0x8E, 0xFA, 0x1C, + 0xE8, 0xB7, 0x8B, 0x03, 0x0A, 0xF9, 0xA6, 0xAA, + 0xE1, 0x07, 0x13, 0xC1, 0x12, 0x17, 0xA1, 0x5F, + 0x84, 0x64, 0x04, 0xCB, 0xA5, 0x18, 0x99, 0xD4 + }, + { + 0x51, 0x7D, 0x31, 0x2F, 0x75, 0xC1, 0xFD, 0xB1, + 0xE1, 0xFC, 0x81, 0x38, 0x0A, 0x68, 0xE6, 0x0D, + 0x3F, 0xCF, 0x98, 0x3D, 0x27, 0x0C, 0xA6, 0xD2, + 0x66, 0xEC, 0x95, 0x31, 0x82, 0xBF, 0x7F, 0xC4 + }, + { + 0x7F, 0xA4, 0xC3, 0x7E, 0x79, 0xBB, 0x1D, 0x58, + 0x74, 0x14, 0x13, 0x8E, 0xBE, 0x18, 0xE5, 0x82, + 0xBD, 0x2C, 0xB2, 0xF8, 0x93, 0xBB, 0xF0, 0x41, + 0x21, 0xF5, 0x20, 0x13, 0xA2, 0xC9, 0x9F, 0x78 + }, + { + 0xFA, 0x6E, 0x02, 0x22, 0x55, 0x67, 0xD0, 0xF4, + 0x3A, 0x61, 0x5B, 0xDF, 0xDC, 0x00, 0x86, 0x12, + 0x12, 0x2F, 0xF7, 0x38, 0xA2, 0x4D, 0x1C, 0x20, + 0xE8, 0xB0, 0x87, 0x43, 0x86, 0x94, 0xD2, 0xF9 + }, + { + 0xD7, 0xEB, 0x36, 0x3F, 0x15, 0x17, 0xEC, 0xED, + 0xDE, 0xAB, 0x08, 0xC9, 0x61, 0x48, 0xFA, 0xA6, + 0xB2, 0xA9, 0x4C, 0x46, 0xB6, 0xBA, 0x89, 0x25, + 0x38, 0x3B, 0x8E, 0x34, 0x70, 0x30, 0xB4, 0x91 + }, + { + 0xA3, 0x16, 0x6A, 0x67, 0x10, 0x1D, 0xFA, 0x15, + 0xA3, 0x8D, 0x05, 0x4B, 0x6F, 0x84, 0xC6, 0x26, + 0x26, 0x7C, 0x0E, 0x6D, 0x6D, 0x63, 0xE2, 0xDE, + 0x3E, 0x68, 0x3E, 0xFF, 0x4D, 0x20, 0xDB, 0x76 + }, + { + 0x7A, 0xB9, 0x03, 0x56, 0x3A, 0xD5, 0x4C, 0x4A, + 0x82, 0x0D, 0x07, 0x9B, 0x85, 0x78, 0xE5, 0x3D, + 0x71, 0x5C, 0xB0, 0xF5, 0xC0, 0x7E, 0x7A, 0x10, + 0x0B, 0xAF, 0x65, 0x8C, 0xB3, 0x36, 0x91, 0x86 + }, + { + 0xD8, 0x27, 0x39, 0x8C, 0xD0, 0x34, 0x29, 0x22, + 0xCE, 0xFB, 0xD1, 0x5F, 0x95, 0x27, 0x56, 0x6E, + 0x44, 0xF5, 0x8B, 0xB4, 0xB2, 0x1B, 0xA5, 0x7A, + 0x81, 0x0E, 0x70, 0x57, 0xFF, 0xC5, 0xED, 0x9D + }, + { + 0x82, 0xC8, 0xA5, 0x45, 0x96, 0x76, 0x7C, 0xFF, + 0xA2, 0x72, 0xD9, 0xC8, 0x32, 0x86, 0xDF, 0xA6, + 0x4F, 0xD3, 0x45, 0xAC, 0x7E, 0x97, 0x10, 0xC0, + 0x69, 0x79, 0x5E, 0xE8, 0x98, 0x74, 0xC9, 0x24 + }, + { + 0xD7, 0x7E, 0x52, 0x6A, 0x4A, 0xF1, 0x39, 0x99, + 0x47, 0xDD, 0x6C, 0xE8, 0x03, 0x87, 0x14, 0x05, + 0x65, 0x37, 0x24, 0xF6, 0x8D, 0xA6, 0x99, 0xE8, + 0xC9, 0x83, 0xF1, 0x0E, 0x86, 0x88, 0x47, 0x0F + }, + { + 0xF9, 0x4A, 0xB6, 0xF0, 0xC3, 0xB2, 0xD1, 0xD6, + 0xFB, 0xD0, 0xE8, 0x79, 0x95, 0xE6, 0x62, 0x31, + 0xA9, 0x73, 0xCE, 0xB0, 0xB3, 0x06, 0x2C, 0xA0, + 0xBC, 0x79, 0x14, 0xD4, 0x73, 0xBE, 0xD5, 0x2B + }, + { + 0x54, 0x87, 0xBF, 0x23, 0xEB, 0x9D, 0x48, 0xF7, + 0x9E, 0xAC, 0x0E, 0x86, 0xD6, 0x79, 0xFA, 0x04, + 0x7E, 0x56, 0x23, 0x95, 0x97, 0x9E, 0x06, 0x9F, + 0xFA, 0xAD, 0xB6, 0xC5, 0x22, 0x52, 0x70, 0xA3 + }, + { + 0xB0, 0x0C, 0xA0, 0xF6, 0xCE, 0x1D, 0xC9, 0xFD, + 0xF5, 0x09, 0x87, 0x01, 0xF6, 0x1E, 0xF1, 0xBA, + 0xE6, 0xEA, 0x25, 0x3C, 0x94, 0x96, 0x7E, 0xC9, + 0x32, 0x88, 0x80, 0x14, 0x19, 0x82, 0x44, 0x69 + }, + { + 0x83, 0x4B, 0xDA, 0x00, 0x06, 0x33, 0x21, 0x02, + 0xED, 0xC6, 0xD6, 0x9D, 0xAF, 0x7A, 0xA9, 0xE0, + 0x49, 0x46, 0x33, 0x04, 0xD5, 0xF5, 0x57, 0x3C, + 0x9C, 0xF5, 0x77, 0x0A, 0xD7, 0x4F, 0xF2, 0x64 + }, + { + 0x1E, 0x68, 0xC9, 0x96, 0x04, 0xD5, 0x19, 0x9B, + 0x16, 0xF1, 0xEA, 0x90, 0xD9, 0xC9, 0x6B, 0x03, + 0xCA, 0x80, 0xE7, 0x2E, 0x22, 0x00, 0xA8, 0xF3, + 0x6F, 0xC3, 0x74, 0xEB, 0x9B, 0x99, 0xAB, 0x3E + }, + { + 0xE5, 0x0B, 0x59, 0x4B, 0xD4, 0x76, 0xEB, 0x5A, + 0xE2, 0x76, 0xB0, 0x21, 0xA1, 0xFD, 0xEB, 0x1D, + 0xFD, 0xDB, 0xED, 0x6F, 0xF3, 0x7F, 0xCB, 0xF9, + 0xA9, 0xFB, 0x0B, 0x17, 0x97, 0x1E, 0x3D, 0x2E + }, + { + 0xDE, 0x39, 0xEB, 0x79, 0x29, 0xE4, 0xED, 0x46, + 0xE2, 0x01, 0xE1, 0x4E, 0xA0, 0x9C, 0x28, 0x4F, + 0xFA, 0x86, 0x5B, 0xFD, 0x9F, 0xC6, 0xC1, 0x8B, + 0xD4, 0xEF, 0xF5, 0xE8, 0xE6, 0xDA, 0x21, 0x61 + }, + { + 0xF7, 0xD0, 0x0B, 0x55, 0xAD, 0x7C, 0x95, 0x9D, + 0x9B, 0x60, 0xB1, 0x3A, 0x5C, 0xE6, 0x1C, 0x40, + 0x57, 0x87, 0x9A, 0x47, 0xB5, 0x99, 0x27, 0x81, + 0xEB, 0xFE, 0xF9, 0x4C, 0xCD, 0x1A, 0xCB, 0x1A + }, + { + 0xFE, 0x59, 0xB8, 0x19, 0x6D, 0x47, 0xEE, 0x67, + 0x13, 0xE8, 0xC8, 0x10, 0x2C, 0x53, 0x53, 0xD0, + 0x6C, 0xE3, 0x80, 0x63, 0x2A, 0x38, 0xBF, 0x73, + 0x47, 0x8F, 0xAD, 0xEE, 0x8D, 0xD3, 0x4D, 0xA8 + }, + { + 0x51, 0x0C, 0x8C, 0xB1, 0x22, 0x87, 0x1A, 0x08, + 0xB8, 0x50, 0x3A, 0x29, 0x5F, 0x08, 0x69, 0x47, + 0xDB, 0xF6, 0xF7, 0x25, 0x4D, 0x99, 0x70, 0x01, + 0xDD, 0xFB, 0x6B, 0x9E, 0xDF, 0x28, 0x7D, 0x7D + }, + { + 0x0C, 0x27, 0x7D, 0x1B, 0x94, 0x4B, 0x5B, 0x09, + 0x4A, 0xBF, 0x1E, 0x74, 0x66, 0xBB, 0x14, 0x27, + 0x23, 0x4A, 0x8A, 0x40, 0xFA, 0x1B, 0x52, 0xED, + 0xE5, 0xE2, 0x62, 0xCC, 0x24, 0xC2, 0x34, 0x3A + }, + { + 0x88, 0xD6, 0x82, 0x25, 0xDA, 0x1C, 0xAA, 0x93, + 0x5B, 0x96, 0x22, 0x37, 0xD5, 0xB3, 0xE2, 0x8C, + 0x42, 0x29, 0xBE, 0x58, 0x4C, 0x6C, 0x27, 0x0B, + 0x72, 0x5B, 0xB0, 0x3B, 0x10, 0x01, 0x49, 0x28 + }, + { + 0x3A, 0x25, 0x49, 0xDB, 0xCA, 0x9F, 0x86, 0x39, + 0x13, 0xB6, 0xDC, 0x37, 0xAD, 0x49, 0x2A, 0xF9, + 0x97, 0x22, 0x2E, 0x89, 0x1B, 0xAB, 0x8D, 0xD1, + 0x9D, 0xC3, 0x80, 0x7D, 0xB5, 0xF8, 0xB1, 0x04 + }, + { + 0xC0, 0x36, 0x49, 0x95, 0xF3, 0x3F, 0xC0, 0xB7, + 0x55, 0x88, 0xD9, 0x3B, 0xF3, 0x72, 0xDB, 0x74, + 0x2F, 0x3F, 0x8E, 0x58, 0x87, 0x1A, 0xD6, 0x73, + 0xDB, 0xE7, 0xD9, 0x6E, 0x02, 0x6E, 0xF4, 0xC3 + }, + { + 0x59, 0x8D, 0x45, 0xAF, 0xAB, 0xB7, 0x52, 0xE0, + 0x70, 0x16, 0x09, 0xE2, 0x97, 0xFB, 0x48, 0xD8, + 0x0B, 0x1D, 0xED, 0x8A, 0xF0, 0x86, 0xB0, 0x61, + 0x1F, 0x7B, 0x7D, 0x74, 0xFC, 0x68, 0x34, 0x70 + }, + { + 0x55, 0xFF, 0xCF, 0xF0, 0x8D, 0xFC, 0xC8, 0x61, + 0xE5, 0x4A, 0x2D, 0x39, 0x9E, 0x16, 0xA9, 0xB1, + 0xDD, 0x68, 0x3B, 0xB0, 0x4A, 0xCD, 0x40, 0x97, + 0xFC, 0xDB, 0x8E, 0x00, 0xD1, 0x7D, 0xC9, 0x8C + }, + { + 0x7F, 0xE5, 0xEE, 0xF7, 0x94, 0x7D, 0xAC, 0x41, + 0x83, 0xB5, 0x41, 0x29, 0x5A, 0x21, 0xD3, 0x41, + 0x7B, 0x4B, 0x78, 0xFB, 0xBA, 0x96, 0x45, 0x5F, + 0xB6, 0x7C, 0x51, 0x45, 0x91, 0x95, 0x70, 0x60 + }, + { + 0x70, 0x7F, 0x30, 0x0B, 0xDE, 0x63, 0x4A, 0x26, + 0x11, 0xC8, 0x6F, 0x8A, 0xF6, 0xC6, 0x1A, 0xA4, + 0x1B, 0x48, 0x02, 0x1C, 0xE8, 0x10, 0x4D, 0xB1, + 0xE6, 0x97, 0xDD, 0x48, 0x8A, 0x50, 0xAE, 0xB0 + }, + { + 0xF2, 0xA7, 0xDC, 0xB6, 0x9A, 0x86, 0x0F, 0x92, + 0x34, 0x77, 0x2D, 0x57, 0x53, 0x10, 0x87, 0x46, + 0xDC, 0x0A, 0xC3, 0x7A, 0xA4, 0xCD, 0x47, 0x62, + 0xBE, 0xD2, 0x59, 0x72, 0x22, 0x08, 0xB0, 0x5E + }, + { + 0x6B, 0x57, 0x26, 0xFE, 0xFB, 0x2A, 0xE6, 0x47, + 0x44, 0x37, 0x1B, 0xBA, 0xAF, 0xD7, 0x29, 0x6E, + 0x3E, 0x67, 0x98, 0x99, 0x9B, 0x56, 0xF3, 0x79, + 0xFB, 0x70, 0x1B, 0xE7, 0xFF, 0x1E, 0xC9, 0x72 + }, + { + 0x71, 0x66, 0xE2, 0xA0, 0x95, 0xE2, 0xD0, 0xB1, + 0xCE, 0xE4, 0xD1, 0x80, 0x8A, 0x2D, 0x36, 0x45, + 0xB2, 0x01, 0x9C, 0x1E, 0x67, 0x8C, 0x6C, 0xDB, + 0xE6, 0x17, 0xC1, 0x76, 0x6F, 0x98, 0xD2, 0xA3 + }, + { + 0x15, 0x28, 0x49, 0x7D, 0x39, 0x68, 0x53, 0xAE, + 0x2E, 0x47, 0xB5, 0x37, 0x7A, 0x1D, 0x2F, 0xBC, + 0x21, 0x57, 0xDF, 0x92, 0xFF, 0xB5, 0x28, 0xD8, + 0xC9, 0x12, 0x59, 0x23, 0x73, 0x47, 0x02, 0x70 + }, + { + 0x4E, 0xC4, 0x1B, 0xE2, 0x04, 0x6C, 0x72, 0x22, + 0x07, 0xB3, 0x8A, 0xF5, 0x28, 0x6C, 0xCB, 0xB1, + 0x67, 0xA3, 0x2B, 0xA5, 0x95, 0xA2, 0x69, 0x9E, + 0x4E, 0x38, 0xB1, 0x64, 0xA8, 0xFF, 0x15, 0xA9 + }, + { + 0x34, 0x2D, 0xDC, 0x4D, 0xD8, 0xE2, 0xE5, 0x86, + 0x4E, 0x08, 0x30, 0x66, 0xEB, 0xD5, 0x6F, 0xCA, + 0xF2, 0xF7, 0xB8, 0x40, 0xD3, 0xB4, 0x11, 0x1C, + 0xC6, 0x82, 0xBD, 0xC9, 0xD9, 0x72, 0x06, 0x88 + }, + { + 0x5A, 0xDD, 0x56, 0xFC, 0x20, 0x48, 0x9D, 0xF3, + 0x01, 0x96, 0xFE, 0x81, 0xBA, 0x85, 0xD7, 0xCF, + 0xDC, 0x90, 0x1A, 0x33, 0x67, 0x09, 0x7C, 0x35, + 0xED, 0xA6, 0x6A, 0x06, 0xE8, 0xFE, 0xF2, 0xB5 + }, + { + 0xC6, 0x42, 0xA6, 0xAE, 0x49, 0x62, 0x09, 0x34, + 0x0C, 0x6F, 0x12, 0x38, 0x90, 0x62, 0x34, 0x70, + 0x1D, 0x76, 0xD9, 0xBD, 0x9F, 0x62, 0x30, 0x0A, + 0xC7, 0xC1, 0xDA, 0x06, 0xA0, 0x89, 0x77, 0x11 + }, + { + 0x4F, 0x68, 0x54, 0xD7, 0x1E, 0x12, 0xE8, 0x4D, + 0xE5, 0x85, 0xE6, 0xEB, 0xCB, 0x3C, 0x8A, 0x08, + 0xFE, 0xEF, 0x01, 0x9D, 0x66, 0x30, 0x5A, 0x0F, + 0x65, 0xB7, 0xA4, 0xEA, 0xB7, 0x8E, 0x1D, 0x6D + }, + { + 0x9A, 0xAB, 0xBD, 0xE5, 0xA6, 0xE9, 0xAF, 0x28, + 0x29, 0xDF, 0xFE, 0xBF, 0x78, 0x85, 0x6B, 0xF0, + 0x60, 0x36, 0x24, 0xB7, 0xAA, 0x5C, 0xFA, 0xD6, + 0x07, 0x5C, 0xE1, 0xAD, 0x5F, 0xB1, 0xDF, 0xAC + }, + { + 0x5E, 0x95, 0xDD, 0xD2, 0xAF, 0x73, 0xCB, 0xB0, + 0x08, 0x55, 0x9C, 0x4A, 0xAC, 0x82, 0x66, 0xCD, + 0x56, 0xAB, 0x02, 0xB3, 0x0E, 0xE0, 0xAA, 0x4E, + 0xC2, 0xCC, 0x57, 0x8A, 0x94, 0x55, 0x7B, 0xB6 + }, + { + 0x1B, 0x66, 0xDE, 0xAA, 0x71, 0x81, 0x3A, 0xA4, + 0xA6, 0x86, 0x98, 0xEB, 0x55, 0xBE, 0x14, 0xE7, + 0x0E, 0xC0, 0x7E, 0x45, 0x3D, 0x00, 0x8C, 0x01, + 0x42, 0x27, 0x06, 0xB7, 0x52, 0xBF, 0x76, 0x26 + }, + { + 0x90, 0xA3, 0xC8, 0xEC, 0x46, 0x3F, 0x0F, 0x03, + 0xDD, 0x6B, 0x9F, 0xC7, 0xBE, 0x9D, 0xA9, 0xD3, + 0x22, 0xE4, 0x24, 0xDC, 0x2E, 0x55, 0x17, 0xE5, + 0xB5, 0x69, 0xB5, 0x3F, 0x6E, 0x48, 0x4F, 0xD0 + }, + { + 0x48, 0x10, 0xDD, 0x46, 0x3C, 0x06, 0x96, 0x7D, + 0x49, 0xBC, 0x54, 0xB5, 0xEB, 0x73, 0x06, 0xAB, + 0xDC, 0x44, 0xA1, 0x78, 0x64, 0xB8, 0xE1, 0x9A, + 0xF3, 0x22, 0xBC, 0x4E, 0x00, 0x55, 0x3D, 0xD0 + }, + { + 0x01, 0x41, 0x49, 0x36, 0xD1, 0x82, 0xBC, 0xF9, + 0x3A, 0xD7, 0x02, 0x25, 0x2E, 0x90, 0x36, 0x9B, + 0xA3, 0x0C, 0x18, 0x9D, 0x92, 0x99, 0xB3, 0xA2, + 0x42, 0x9F, 0x85, 0x82, 0xC6, 0x0C, 0xFC, 0x1C + }, + { + 0x11, 0x28, 0xCA, 0xBF, 0x53, 0xE4, 0x81, 0x9F, + 0xD5, 0xD8, 0x85, 0x45, 0xFB, 0xCF, 0x20, 0xD1, + 0x6C, 0x5A, 0x04, 0x0A, 0xFA, 0x47, 0x3A, 0xDA, + 0x4C, 0xB9, 0x3A, 0x85, 0x7F, 0x32, 0xF1, 0x44 + }, + { + 0x42, 0x28, 0x97, 0xA6, 0x52, 0xA4, 0xE8, 0xBB, + 0xD8, 0xD4, 0x92, 0xCD, 0xD6, 0xC3, 0xD9, 0x7F, + 0x6C, 0x22, 0xF3, 0x30, 0xDE, 0xF3, 0x88, 0xC6, + 0xC8, 0x53, 0x28, 0x39, 0x68, 0x71, 0x7B, 0xF0 + }, + { + 0x16, 0xD9, 0xCF, 0x11, 0x1C, 0x40, 0x0C, 0x0E, + 0x4A, 0xD7, 0x5D, 0x29, 0x8E, 0xF1, 0xF3, 0x64, + 0xE7, 0x53, 0x45, 0x8D, 0x71, 0xF2, 0x59, 0xEB, + 0x58, 0xA6, 0x43, 0xAE, 0xF6, 0x3A, 0x84, 0x81 + }, + { + 0x73, 0x98, 0x1B, 0xDE, 0xA1, 0x29, 0xF2, 0xA5, + 0x42, 0x10, 0xE3, 0x14, 0xFD, 0x63, 0x42, 0x5F, + 0x38, 0x43, 0xF6, 0xE3, 0x0F, 0x45, 0x55, 0xCC, + 0xF3, 0x2C, 0xC4, 0x37, 0x04, 0x71, 0x29, 0xAB + }, + { + 0xA0, 0x9E, 0x8B, 0xE7, 0xD6, 0x62, 0x22, 0xA9, + 0xEE, 0xAA, 0xCB, 0xDE, 0x5D, 0xE9, 0x3B, 0x55, + 0x1F, 0xCA, 0xFB, 0x02, 0xA2, 0x7F, 0xC2, 0x03, + 0xC2, 0x5A, 0x09, 0xF3, 0x7C, 0x82, 0xF1, 0x9E + }, + { + 0x15, 0xB4, 0x2B, 0x56, 0x45, 0x4E, 0x3F, 0x46, + 0xC3, 0x41, 0x9B, 0x01, 0x46, 0x05, 0x2B, 0x7B, + 0x25, 0x80, 0x94, 0x95, 0x0B, 0xF7, 0x7B, 0xCD, + 0x9F, 0x86, 0x84, 0x38, 0x55, 0x9A, 0x96, 0x21 + }, + { + 0x41, 0xF2, 0xAB, 0x38, 0x6E, 0x41, 0x7C, 0x52, + 0x78, 0x39, 0xA6, 0x94, 0xE0, 0xB1, 0x09, 0x8A, + 0x0B, 0x0A, 0x17, 0x57, 0xAD, 0xC8, 0x34, 0x83, + 0xD8, 0x53, 0x97, 0x8F, 0xA6, 0x0A, 0x56, 0x49 + }, + { + 0xE2, 0x2E, 0x2F, 0xE6, 0xC4, 0xCB, 0xC5, 0x69, + 0xD8, 0x09, 0xB9, 0x33, 0x17, 0x06, 0xF2, 0xB4, + 0x22, 0xB6, 0x92, 0x74, 0x07, 0x2A, 0x62, 0xB5, + 0x46, 0x0F, 0x2D, 0x39, 0x5F, 0xE2, 0x1B, 0x7A + }, + { + 0xAE, 0x87, 0xC9, 0x5A, 0x8B, 0x8E, 0x0E, 0x55, + 0x87, 0xF3, 0x41, 0x98, 0x00, 0xC7, 0xAA, 0xEB, + 0xEC, 0xEB, 0xCA, 0x54, 0x3D, 0xA8, 0x10, 0x58, + 0x5C, 0xBD, 0x19, 0x30, 0x4F, 0x96, 0x3E, 0x75 + }, + { + 0x69, 0xB8, 0x84, 0x51, 0xC8, 0xC4, 0x51, 0x41, + 0x82, 0x18, 0xED, 0x31, 0xD6, 0xC0, 0xBB, 0x80, + 0x19, 0xCA, 0x07, 0xF3, 0xE2, 0xDE, 0x27, 0xD9, + 0x02, 0xBA, 0x2A, 0x26, 0x0E, 0xA1, 0x5A, 0x9A + }, + { + 0x58, 0x19, 0x4B, 0x8B, 0xE1, 0xD2, 0x4D, 0x5A, + 0xED, 0xE7, 0x1F, 0x25, 0xCB, 0xF5, 0x93, 0xD6, + 0xD1, 0x74, 0xA2, 0x3B, 0xF7, 0x6C, 0x1B, 0xBA, + 0x5B, 0x38, 0x0C, 0x66, 0xB3, 0x23, 0x82, 0xBB + }, + { + 0xA5, 0x63, 0xF6, 0xBC, 0xC3, 0xAD, 0xF0, 0x6A, + 0xA0, 0x77, 0x10, 0x41, 0x7A, 0xF1, 0x50, 0xCA, + 0x73, 0xD9, 0xDC, 0xDD, 0x0F, 0x33, 0x2A, 0x92, + 0x17, 0x1F, 0x1B, 0xB2, 0xF1, 0xB5, 0xE9, 0x3C + }, + { + 0x12, 0xFF, 0xE8, 0x65, 0xF9, 0x89, 0x48, 0x3F, + 0xF5, 0x71, 0xD4, 0x9A, 0x3D, 0x32, 0x0A, 0xB1, + 0x76, 0xC7, 0xDC, 0xB6, 0x10, 0x59, 0x52, 0x27, + 0xF7, 0xAC, 0xA8, 0x22, 0xEA, 0xEC, 0x0C, 0x93 + }, + { + 0x4E, 0x93, 0xE3, 0x41, 0x5B, 0x49, 0x07, 0x70, + 0xBD, 0x1F, 0x9A, 0x53, 0x9F, 0x54, 0x1D, 0x66, + 0x08, 0xA7, 0xBB, 0xA6, 0xAF, 0x86, 0x29, 0x33, + 0x30, 0x79, 0x48, 0xFD, 0x76, 0x67, 0x22, 0xC6 + }, + { + 0x06, 0x31, 0x1D, 0xD6, 0x60, 0x80, 0x52, 0x3A, + 0x16, 0xC1, 0x40, 0x75, 0x4F, 0xB1, 0xB0, 0xE7, + 0xBD, 0x75, 0x72, 0x76, 0x8C, 0x9D, 0xDB, 0x57, + 0xF8, 0x7F, 0x0E, 0x4F, 0xD4, 0xAE, 0xA4, 0xD4 + }, + { + 0x4E, 0x91, 0xC3, 0x8F, 0x64, 0x56, 0x97, 0x17, + 0x9E, 0x2E, 0x5D, 0xF1, 0x9E, 0x0C, 0xCF, 0x71, + 0xB0, 0x22, 0x75, 0x95, 0xEF, 0x6F, 0xE0, 0xB1, + 0x28, 0x9E, 0x72, 0x0D, 0x07, 0x1D, 0x4B, 0xEF + }, + { + 0x93, 0x58, 0x9B, 0xDD, 0xBD, 0xE7, 0x43, 0xF4, + 0x27, 0x25, 0x2D, 0x65, 0x09, 0x68, 0xE6, 0x13, + 0x71, 0x8F, 0x5D, 0xBD, 0x55, 0xAF, 0x03, 0x0A, + 0x17, 0x85, 0x01, 0x6C, 0x0E, 0xFA, 0xAF, 0xCD + }, + { + 0x3C, 0x3E, 0xE4, 0xBD, 0x93, 0xA8, 0x42, 0x66, + 0xA3, 0x5B, 0x4A, 0x2C, 0xD9, 0x5C, 0x90, 0xB2, + 0xDA, 0xB6, 0xD8, 0xBA, 0xFF, 0x31, 0x1A, 0x9E, + 0xEF, 0x7A, 0xB4, 0xE4, 0x81, 0x1A, 0xA9, 0x86 + }, + { + 0xC6, 0x10, 0x96, 0x09, 0xB6, 0x49, 0x81, 0xFA, + 0xAE, 0xE4, 0xFA, 0x30, 0x9A, 0x45, 0xFA, 0x45, + 0xF7, 0xDC, 0xB6, 0x44, 0xF0, 0x54, 0xFF, 0xBC, + 0xBC, 0xD7, 0x54, 0x1C, 0xD3, 0xF4, 0x22, 0x9A + }, + { + 0xFC, 0x2C, 0xDC, 0x5D, 0xC4, 0x85, 0x52, 0xDD, + 0x02, 0x76, 0x44, 0xC9, 0xB9, 0x67, 0x33, 0xFC, + 0x94, 0x7C, 0x5A, 0x4D, 0x9E, 0x05, 0xDE, 0x1E, + 0xA1, 0x58, 0x30, 0x66, 0xAE, 0xD4, 0x7E, 0xAF + }, + { + 0xFC, 0x9A, 0x21, 0xEC, 0xB2, 0x32, 0xDE, 0x8E, + 0x94, 0x8A, 0x45, 0xC6, 0x93, 0x29, 0x43, 0x95, + 0xF8, 0xE4, 0xB0, 0xF6, 0xA1, 0x19, 0x6B, 0x3F, + 0xE2, 0x7D, 0x29, 0x26, 0xB7, 0xAA, 0x4A, 0x7D + }, + { + 0x09, 0xB6, 0x4D, 0x5B, 0xD3, 0x6E, 0x9A, 0x00, + 0x16, 0x5D, 0xC3, 0x50, 0x7D, 0xD0, 0x28, 0xA6, + 0xBC, 0x0E, 0x45, 0xB3, 0x72, 0xF1, 0x55, 0xA3, + 0x5B, 0xD7, 0xB6, 0xAB, 0xE3, 0x09, 0x81, 0x6B + }, + { + 0x02, 0xA9, 0x4A, 0x2F, 0xC6, 0x76, 0xC0, 0x7F, + 0xE2, 0x06, 0x75, 0x24, 0x86, 0x35, 0xFF, 0xE8, + 0xDF, 0x65, 0xF9, 0xD9, 0x5E, 0x1F, 0x7A, 0xBD, + 0xD9, 0x1A, 0x2C, 0x7D, 0xF5, 0x22, 0xC1, 0x25 + }, + { + 0x74, 0x02, 0x54, 0x58, 0x6C, 0xBD, 0xEB, 0x33, + 0xBC, 0x5E, 0xE3, 0xDC, 0x4D, 0x35, 0x9A, 0xF6, + 0xAE, 0x01, 0x06, 0xB0, 0xC0, 0x5A, 0x6A, 0xFA, + 0x58, 0x02, 0x63, 0xBA, 0x6A, 0x4B, 0x20, 0x41 + }, + { + 0x8C, 0x18, 0x49, 0xDA, 0x84, 0x48, 0xCA, 0x95, + 0x0C, 0xA6, 0x9D, 0xAD, 0x19, 0x10, 0x9B, 0x10, + 0xDA, 0x4B, 0x3A, 0x4E, 0xF2, 0x43, 0x5F, 0x96, + 0x9F, 0x89, 0xF3, 0xE6, 0xA5, 0xCD, 0x57, 0x67 + }, + { + 0x94, 0xCA, 0x10, 0x35, 0xB5, 0x4E, 0xF3, 0xD9, + 0x1C, 0xE5, 0x9E, 0x42, 0x5B, 0x29, 0x09, 0x23, + 0x0D, 0x1F, 0x8C, 0xC0, 0x42, 0xEF, 0x1A, 0xDC, + 0xF6, 0x5B, 0xFF, 0xFA, 0x1F, 0x0C, 0x47, 0x32 + }, + { + 0x08, 0x1A, 0x0C, 0x84, 0x8A, 0xCA, 0x73, 0xB7, + 0x7E, 0x73, 0xD6, 0xF7, 0xD5, 0x93, 0x1A, 0x3B, + 0xF0, 0xA6, 0x93, 0xAA, 0xE8, 0x7E, 0x32, 0xAC, + 0x3D, 0x68, 0x27, 0x7B, 0xA8, 0xAE, 0xD2, 0x27 + }, + { + 0xDD, 0x66, 0xA1, 0x7A, 0xE7, 0xAA, 0xE4, 0x02, + 0xAD, 0xBD, 0x57, 0xB4, 0xB1, 0x52, 0x6D, 0x6B, + 0x79, 0xC7, 0xD8, 0xE4, 0x10, 0x9C, 0x69, 0xBD, + 0x4C, 0x90, 0xAA, 0xD6, 0xE2, 0x61, 0xAC, 0x12 + }, + { + 0x64, 0x8C, 0xCE, 0x1F, 0xC6, 0x13, 0xED, 0xE3, + 0xD8, 0x3B, 0x54, 0x34, 0xD3, 0x1D, 0x15, 0x7D, + 0x6E, 0xDC, 0x6B, 0xD7, 0xDB, 0x03, 0xC4, 0xFB, + 0xD1, 0xD2, 0x91, 0xA7, 0x58, 0xDC, 0xD0, 0xB4 + }, + { + 0xE6, 0x26, 0xED, 0xCE, 0xD1, 0x95, 0x98, 0x56, + 0x8C, 0x3F, 0x05, 0x99, 0x3D, 0xB4, 0xB2, 0x7D, + 0xB3, 0xE6, 0xCB, 0x98, 0x1B, 0x18, 0x98, 0x90, + 0xE8, 0x55, 0x8E, 0xB2, 0xDC, 0xBB, 0x8F, 0x40 + }, + { + 0x86, 0xCF, 0x7F, 0x03, 0x32, 0x5D, 0x1A, 0x07, + 0xB8, 0x2E, 0xC0, 0x4F, 0x92, 0x36, 0xF0, 0x0C, + 0x95, 0xB3, 0x3E, 0x1D, 0xAF, 0x58, 0xA5, 0x07, + 0xCE, 0x7F, 0x6C, 0x93, 0xA3, 0x97, 0x30, 0x18 + }, + { + 0x6C, 0xF1, 0x13, 0x13, 0xAA, 0x98, 0xF5, 0xDC, + 0xBA, 0xF8, 0x6B, 0x09, 0x3C, 0x73, 0x89, 0xFE, + 0xB8, 0x75, 0x03, 0x14, 0x0D, 0x85, 0xF7, 0x4C, + 0x6B, 0x4B, 0x21, 0xEA, 0x6D, 0x28, 0x59, 0xCD + }, + { + 0xCB, 0xB5, 0x26, 0x8D, 0xAD, 0xA7, 0x8A, 0x26, + 0x16, 0x0C, 0xA0, 0x13, 0xFE, 0xC3, 0x1E, 0x77, + 0xE3, 0x76, 0xFA, 0x88, 0x3F, 0x8A, 0xFF, 0xD0, + 0x93, 0x6A, 0x61, 0x05, 0xF9, 0xD2, 0xE3, 0x81 + }, + { + 0x8A, 0xFA, 0xB0, 0xA4, 0xF1, 0x8E, 0x6B, 0xD5, + 0x61, 0x38, 0xAF, 0x44, 0x0D, 0x89, 0x8C, 0xE6, + 0x23, 0x40, 0xE5, 0x07, 0xE2, 0xE3, 0x63, 0x34, + 0x4C, 0x73, 0xE4, 0x61, 0xCC, 0xCF, 0x9C, 0xF8 + }, + { + 0x29, 0xA9, 0x90, 0x98, 0x43, 0xFF, 0x9F, 0xA7, + 0x2F, 0x70, 0xA8, 0x4A, 0xFD, 0xC1, 0x06, 0x83, + 0x25, 0x4D, 0x1A, 0x05, 0x61, 0x3A, 0xB6, 0x5E, + 0x23, 0x84, 0xB0, 0xA0, 0xBC, 0xDE, 0x6E, 0x58 + }, + { + 0x88, 0x53, 0xA9, 0x2F, 0x50, 0xC1, 0x49, 0x85, + 0x52, 0xCC, 0xF1, 0x9E, 0xD0, 0xFE, 0x82, 0x68, + 0xCB, 0x1F, 0x0A, 0xD4, 0xE1, 0x00, 0x16, 0xC9, + 0x1B, 0x2D, 0x49, 0x40, 0x94, 0xD3, 0x1C, 0xDC + }, + { + 0x6C, 0x92, 0x61, 0xB1, 0x3B, 0x93, 0x72, 0x52, + 0x3E, 0x9F, 0x5C, 0x32, 0x07, 0xDB, 0x0E, 0x55, + 0x1A, 0xBE, 0xDA, 0x13, 0x89, 0x3A, 0xC2, 0x9B, + 0xE1, 0xC2, 0x80, 0x1A, 0xEE, 0xBD, 0x8F, 0xE5 + }, + { + 0x66, 0x05, 0x0B, 0xD4, 0x8B, 0x3A, 0xD7, 0x28, + 0xDD, 0x6D, 0x71, 0x7C, 0xEB, 0x8A, 0x56, 0x5D, + 0xCD, 0x86, 0xCB, 0xC6, 0xC9, 0x8D, 0x7F, 0x5D, + 0x98, 0x26, 0x04, 0x23, 0x0D, 0x50, 0xD2, 0x3C + }, + { + 0xD5, 0x11, 0x38, 0xEA, 0x3B, 0x88, 0x7F, 0xF2, + 0x54, 0xE7, 0xC9, 0x7D, 0x69, 0x58, 0x25, 0x7F, + 0xE0, 0xF2, 0x71, 0xE1, 0xAD, 0xD3, 0x60, 0x1F, + 0x6A, 0x23, 0x28, 0xEA, 0x1F, 0x7E, 0x4B, 0x46 + }, + { + 0x00, 0x4D, 0x18, 0x10, 0x0A, 0xF7, 0x7E, 0x9F, + 0x90, 0xA4, 0x69, 0xF2, 0x9B, 0xC2, 0xC1, 0xAB, + 0x23, 0xF4, 0x8C, 0x90, 0x40, 0xBC, 0xED, 0xBE, + 0x9D, 0xD9, 0xA9, 0x76, 0x17, 0xD2, 0x58, 0xCE + }, + { + 0xCC, 0xC8, 0xE2, 0xFF, 0x53, 0xA1, 0x3E, 0x52, + 0x60, 0x28, 0x72, 0xCF, 0x61, 0x59, 0x27, 0xEB, + 0x23, 0xCC, 0x8D, 0xB3, 0x73, 0x18, 0x31, 0xA7, + 0xEE, 0xC5, 0x4B, 0xED, 0x43, 0x84, 0x43, 0x96 + }, + { + 0xEB, 0x45, 0xD2, 0xF9, 0xFB, 0xA0, 0xA1, 0x71, + 0x51, 0x19, 0xA2, 0x84, 0xE8, 0x07, 0xAC, 0x4D, + 0x8D, 0x44, 0x70, 0x95, 0x2B, 0x63, 0xD2, 0x32, + 0x45, 0x8B, 0x99, 0x04, 0xDE, 0x2C, 0xD6, 0x4B + }, + { + 0x55, 0xFC, 0x97, 0x52, 0x37, 0xE0, 0x70, 0xB3, + 0xA0, 0x46, 0x81, 0x7D, 0x38, 0xAE, 0x93, 0x75, + 0x58, 0xE8, 0x10, 0x04, 0xF4, 0x39, 0xBF, 0x39, + 0x6F, 0x68, 0xF3, 0x2F, 0xCA, 0x2B, 0xCB, 0xAB + }, + { + 0x76, 0xA2, 0x45, 0xA9, 0x11, 0x5B, 0xA5, 0x66, + 0x58, 0xCA, 0x92, 0xEE, 0x84, 0x2D, 0x06, 0x3E, + 0xFA, 0x16, 0x0A, 0x9D, 0x42, 0x32, 0x9F, 0x04, + 0x26, 0x9B, 0xCF, 0xF5, 0x06, 0xB8, 0x31, 0xD9 + }, + { + 0xD5, 0x2D, 0x8C, 0x9A, 0xBC, 0xB5, 0x0C, 0x7B, + 0xF5, 0x10, 0xD6, 0x83, 0xA0, 0x3D, 0xB0, 0x7F, + 0xB0, 0xD3, 0x67, 0xB9, 0xE0, 0xC5, 0x32, 0x34, + 0x99, 0x0C, 0x64, 0xAD, 0x39, 0x9F, 0xAF, 0x19 + }, + { + 0x03, 0xDC, 0xD9, 0xF4, 0xE9, 0xEE, 0x16, 0x6B, + 0xA2, 0xEB, 0xEC, 0x9B, 0x83, 0xAC, 0xE3, 0x85, + 0xF9, 0x48, 0x96, 0x70, 0xC8, 0xC2, 0xEC, 0x53, + 0x2B, 0x43, 0xEC, 0x5A, 0x08, 0xD6, 0xF9, 0x2D + }, + { + 0x3B, 0x79, 0x37, 0x9F, 0xA5, 0x1A, 0x8A, 0xD1, + 0xBF, 0x9D, 0xE4, 0x45, 0x6F, 0x64, 0x29, 0xC7, + 0x3F, 0x80, 0xD8, 0xA4, 0xAF, 0x21, 0x28, 0x0A, + 0x34, 0xD8, 0x05, 0xD0, 0x22, 0x03, 0xB9, 0x99 + }, + { + 0x90, 0xDB, 0x67, 0x51, 0x71, 0xDB, 0x97, 0x12, + 0x98, 0x23, 0x2B, 0x36, 0x54, 0x00, 0x6C, 0x0C, + 0x22, 0x50, 0x35, 0x15, 0xAC, 0xA2, 0xAC, 0x14, + 0x0A, 0x84, 0xFE, 0x1D, 0x2C, 0x36, 0xEB, 0xC0 + }, + { + 0x00, 0xDC, 0x79, 0x6D, 0xED, 0x07, 0xA7, 0xDA, + 0xB7, 0x6C, 0xA6, 0xA1, 0x74, 0x99, 0x47, 0x5B, + 0x58, 0x73, 0x67, 0x4A, 0x74, 0x33, 0x8D, 0x46, + 0xB1, 0x60, 0x02, 0x30, 0x4D, 0xBE, 0xC5, 0x2A + }, + { + 0x81, 0x27, 0xD6, 0x4C, 0xAC, 0xEB, 0xCE, 0x08, + 0xF3, 0xAD, 0xAD, 0x26, 0x90, 0xF1, 0x89, 0x92, + 0xAE, 0xB3, 0x03, 0xBE, 0x3A, 0xEF, 0xE0, 0x8C, + 0xC8, 0xC9, 0xD2, 0x65, 0x17, 0x31, 0x72, 0xB5 + }, + { + 0x10, 0x12, 0xD6, 0x40, 0x3A, 0xDB, 0xF4, 0x68, + 0x93, 0x14, 0xD0, 0x11, 0x22, 0xB1, 0xB4, 0xDC, + 0xC7, 0xE4, 0xF0, 0xAB, 0xAF, 0xF6, 0xA6, 0xE2, + 0xBB, 0x76, 0xC1, 0xC4, 0x65, 0xBE, 0x08, 0x91 + }, + { + 0xF5, 0x36, 0x9F, 0x64, 0xBD, 0x26, 0x74, 0x4C, + 0xF4, 0xC8, 0xB1, 0x70, 0xBB, 0x13, 0x2D, 0xD7, + 0xA6, 0x7F, 0x8B, 0x9B, 0xE6, 0xEE, 0xE4, 0x96, + 0x3B, 0x71, 0x07, 0xD9, 0x74, 0xBD, 0xC3, 0x30 + }, + { + 0x7C, 0x3A, 0x93, 0xD4, 0x7A, 0x5E, 0x4E, 0x93, + 0x4D, 0x3D, 0x1C, 0x76, 0x13, 0x15, 0xAC, 0xED, + 0x7B, 0xA0, 0xC0, 0x7D, 0xD5, 0x06, 0x10, 0x0D, + 0x7A, 0xE4, 0x98, 0x15, 0x84, 0xB6, 0xF0, 0x28 + }, + { + 0x4F, 0xFE, 0xD9, 0xDB, 0x88, 0x47, 0xB6, 0x5F, + 0xD9, 0xDF, 0xD8, 0xBC, 0x1D, 0xC6, 0x78, 0xF1, + 0x7F, 0x78, 0x9B, 0x59, 0x50, 0xA8, 0x66, 0x78, + 0x42, 0xAD, 0x03, 0xFE, 0xC5, 0xFE, 0x65, 0x9B + }, + { + 0x2F, 0xAA, 0xC1, 0x97, 0x11, 0x76, 0x43, 0x97, + 0xD6, 0x9F, 0x93, 0xDC, 0x06, 0xA0, 0xE9, 0x16, + 0x71, 0xF8, 0x12, 0x12, 0x17, 0x05, 0x39, 0x89, + 0x70, 0x5E, 0x02, 0x40, 0xA2, 0x53, 0x1D, 0x5B + }, + { + 0xD5, 0x97, 0x58, 0xC1, 0x4D, 0xC6, 0x60, 0x70, + 0x3F, 0x92, 0x3E, 0xAD, 0xC6, 0x01, 0xFC, 0x03, + 0xAA, 0x49, 0xB0, 0x91, 0x0F, 0xBE, 0x1C, 0x1E, + 0x45, 0xCB, 0x49, 0x10, 0x46, 0x64, 0x49, 0xF9 + }, + { + 0x46, 0x71, 0x1D, 0x20, 0xF1, 0xE0, 0xE0, 0x26, + 0xF9, 0x40, 0x2B, 0x4D, 0x02, 0x6D, 0x81, 0x2C, + 0xDC, 0x6C, 0xA5, 0x3C, 0xA4, 0x94, 0x13, 0x00, + 0x27, 0x67, 0xD9, 0xA0, 0x43, 0x54, 0x32, 0x5E + }, + { + 0xA2, 0xB5, 0xBF, 0x99, 0xAA, 0xD2, 0xA2, 0x18, + 0x79, 0xC5, 0xBA, 0xA9, 0x4F, 0x32, 0x37, 0xBA, + 0xFA, 0xFD, 0x73, 0xC3, 0xC0, 0x41, 0x09, 0x5A, + 0x94, 0xA3, 0x77, 0xAC, 0x00, 0xD2, 0xEB, 0xDF + }, + { + 0x04, 0x2C, 0x5B, 0x99, 0xA1, 0x8F, 0x47, 0x0F, + 0x34, 0x9A, 0x2E, 0x2D, 0xC1, 0x3A, 0xD1, 0x20, + 0x6D, 0x14, 0xCF, 0xE3, 0x97, 0x86, 0x68, 0x7F, + 0xC2, 0x4D, 0x26, 0xB8, 0xBC, 0x9B, 0x93, 0x78 + }, + { + 0x5A, 0xD3, 0x35, 0xCE, 0x04, 0x5C, 0x46, 0x9A, + 0x77, 0xF1, 0x6C, 0x9D, 0x95, 0xAA, 0x02, 0xC8, + 0x44, 0xDC, 0x2E, 0xE5, 0xEE, 0x8F, 0x32, 0xCB, + 0x5C, 0xBD, 0x71, 0x12, 0x77, 0x88, 0x2B, 0x67 + }, + { + 0xDE, 0xC6, 0xC5, 0xDB, 0xA4, 0x74, 0xE2, 0x10, + 0x2B, 0xFF, 0x00, 0xD0, 0xAA, 0x85, 0xBE, 0xA0, + 0xBA, 0x38, 0x1B, 0xEE, 0xDA, 0x20, 0x88, 0x4D, + 0x97, 0x33, 0x22, 0x78, 0x48, 0x5C, 0x55, 0x92 + }, + { + 0xBF, 0x7E, 0x3B, 0x26, 0x60, 0xE4, 0x5E, 0xEA, + 0x88, 0x86, 0x40, 0x23, 0x2A, 0x74, 0x2A, 0x7D, + 0x9A, 0xF6, 0xB3, 0x68, 0x4C, 0x2A, 0xF6, 0x9D, + 0x40, 0x10, 0x98, 0x60, 0x92, 0xB7, 0x63, 0x37 + }, + { + 0x69, 0x21, 0xA4, 0x41, 0x5E, 0x0E, 0xEB, 0x01, + 0xC1, 0x2F, 0xCE, 0xF7, 0x1E, 0xFD, 0xAB, 0xB6, + 0xBC, 0x0F, 0x9F, 0x4C, 0xDF, 0x37, 0x83, 0x44, + 0xC3, 0x32, 0x55, 0x25, 0xC0, 0xF2, 0x30, 0x76 + }, + { + 0x32, 0xE9, 0x1B, 0xF3, 0x0C, 0x50, 0xD9, 0xA1, + 0x42, 0x58, 0x59, 0xCE, 0xDB, 0xAD, 0xD0, 0x07, + 0x7F, 0xB7, 0x2D, 0xDB, 0xAD, 0x16, 0xF3, 0x3F, + 0x44, 0x98, 0x96, 0x32, 0xC6, 0xCF, 0x69, 0xEC + }, + { + 0xFE, 0xB8, 0x44, 0xB9, 0x3C, 0xFC, 0xE2, 0x44, + 0x1D, 0xCC, 0xF3, 0x9C, 0x75, 0xA6, 0x39, 0xDC, + 0x77, 0x5D, 0x4D, 0x3E, 0x24, 0xD9, 0x8C, 0xDF, + 0x75, 0x7F, 0xD2, 0xB5, 0x5A, 0x27, 0x14, 0xC9 + }, + { + 0xC2, 0x70, 0x63, 0x70, 0x1A, 0x85, 0x07, 0x77, + 0xBA, 0x46, 0xC1, 0xAC, 0xD7, 0x9C, 0x70, 0x2F, + 0xB5, 0x9C, 0xA3, 0x81, 0xBA, 0x23, 0x94, 0x01, + 0xF2, 0x06, 0xB7, 0x01, 0x32, 0xC8, 0x0A, 0x14 + }, + { + 0xFA, 0xC4, 0x00, 0x29, 0x74, 0xF7, 0xFC, 0xC5, + 0x2C, 0x34, 0x85, 0xC8, 0x69, 0x22, 0x78, 0xFE, + 0xD0, 0x43, 0xC9, 0x59, 0xBE, 0x3A, 0x4F, 0xA1, + 0xDD, 0xD5, 0x61, 0xFC, 0xF7, 0x68, 0xE1, 0xDF + }, + { + 0xC7, 0x5C, 0x98, 0xFC, 0x7C, 0xE5, 0xC3, 0x33, + 0x66, 0x25, 0x30, 0x96, 0x26, 0x6D, 0x22, 0xAD, + 0x05, 0xB5, 0xB9, 0xA6, 0x76, 0x39, 0x7B, 0x8A, + 0xD9, 0x3E, 0xC6, 0xC6, 0xF2, 0x81, 0x2A, 0xB2 + }, + { + 0x52, 0x70, 0xCC, 0x9B, 0xEC, 0xE4, 0x4A, 0x45, + 0xF5, 0xD5, 0x74, 0xC0, 0xA9, 0xE8, 0x91, 0xF1, + 0x8E, 0xD3, 0x63, 0xA2, 0xE0, 0xAD, 0x00, 0xF5, + 0x85, 0x0C, 0x96, 0x70, 0x26, 0xAB, 0xBA, 0x1D + }, + { + 0x62, 0x98, 0xB8, 0x29, 0x4E, 0x15, 0x4F, 0xFC, + 0xF7, 0xBA, 0x20, 0xA7, 0x3E, 0x76, 0x2D, 0x8D, + 0x4B, 0x98, 0x57, 0x38, 0x4B, 0xA9, 0x82, 0xE1, + 0x83, 0x35, 0xF6, 0x37, 0x32, 0xF5, 0x5A, 0xB5 + }, + { + 0x45, 0x60, 0xDE, 0x12, 0xA4, 0xE2, 0x55, 0xAF, + 0xA3, 0x0B, 0xF6, 0x02, 0xD9, 0x19, 0x22, 0xC8, + 0x9A, 0xA9, 0x62, 0x2E, 0x60, 0xF0, 0x35, 0x24, + 0x66, 0xCF, 0x75, 0x8E, 0x88, 0x03, 0x9A, 0x92 + }, + { + 0xF0, 0xAB, 0xA1, 0x11, 0x72, 0xA7, 0x07, 0xC1, + 0xAB, 0xDC, 0xD6, 0xEC, 0x4A, 0x13, 0x91, 0xBD, + 0x19, 0x93, 0x30, 0x22, 0xC9, 0x7D, 0x6F, 0xF8, + 0xCF, 0xAF, 0x0F, 0xB3, 0xC5, 0x12, 0xBD, 0x3B + }, + { + 0xE0, 0x35, 0x12, 0x86, 0x38, 0xB0, 0xAA, 0x26, + 0xB6, 0xDE, 0xBC, 0x0B, 0xB7, 0x73, 0x15, 0x12, + 0xA6, 0x30, 0x8A, 0x13, 0x3A, 0xF8, 0x4D, 0xEB, + 0xD1, 0x41, 0x3E, 0x99, 0xB3, 0x62, 0x60, 0x69 + }, + { + 0xAD, 0xDA, 0xAA, 0xF4, 0x1F, 0xB3, 0x88, 0xD6, + 0xE2, 0xB8, 0x2F, 0x20, 0xE3, 0x63, 0xAA, 0x1C, + 0x08, 0x1B, 0xCC, 0x53, 0xC6, 0xD8, 0x94, 0x52, + 0x3E, 0x6E, 0x07, 0x5F, 0x86, 0xCA, 0x02, 0x8A + }, + { + 0x99, 0x3D, 0x6D, 0xE2, 0x62, 0x11, 0x87, 0xE8, + 0xD4, 0x34, 0x4D, 0xA6, 0xC8, 0xBC, 0xAC, 0x8A, + 0xF5, 0x79, 0x16, 0xC1, 0x16, 0x00, 0x2E, 0x43, + 0x2B, 0x2D, 0x91, 0x18, 0xE6, 0x00, 0xF6, 0x70 + }, + { + 0x5C, 0x6B, 0x25, 0x41, 0xDD, 0x3E, 0x3B, 0xB5, + 0x03, 0x1A, 0xAE, 0xA8, 0x4A, 0xB5, 0x32, 0x5F, + 0xC2, 0x98, 0xEC, 0xB7, 0xF9, 0xD6, 0xA8, 0xB2, + 0xA8, 0x40, 0x20, 0xD7, 0xEB, 0xF4, 0x7A, 0xF6 + }, + { + 0xDC, 0x85, 0x11, 0x17, 0xE0, 0xF8, 0x81, 0x1C, + 0x7C, 0x3F, 0xB2, 0xFC, 0x65, 0xB8, 0xBA, 0x42, + 0x92, 0xB7, 0xAE, 0x73, 0x89, 0xA6, 0x2E, 0x07, + 0x1C, 0x5B, 0x40, 0xE9, 0xCB, 0x38, 0x0F, 0x33 + }, + { + 0x67, 0x90, 0x76, 0x19, 0xCE, 0x4B, 0x7F, 0x15, + 0x72, 0x8A, 0xFB, 0x2A, 0xF6, 0x59, 0x7D, 0xB6, + 0x42, 0x40, 0x97, 0x56, 0x9C, 0x07, 0x7D, 0x5F, + 0x28, 0x56, 0xA9, 0x5D, 0x64, 0x1A, 0x36, 0x48 + }, + { + 0x91, 0x0A, 0xDE, 0x47, 0x9A, 0x50, 0xDC, 0x71, + 0xA1, 0x34, 0xEF, 0x99, 0x37, 0xA4, 0x21, 0x42, + 0x5F, 0x47, 0x16, 0xA5, 0x3E, 0x40, 0x07, 0xFA, + 0x75, 0x3C, 0x47, 0xCE, 0x2E, 0x44, 0x32, 0xD3 + }, + { + 0x1D, 0x43, 0x59, 0x8A, 0x39, 0x53, 0xF6, 0xE8, + 0xD9, 0x74, 0x6E, 0x48, 0x54, 0x01, 0x62, 0x35, + 0x9C, 0xB9, 0xBD, 0x68, 0xE2, 0x59, 0x09, 0x22, + 0x54, 0xC0, 0xA7, 0xC4, 0x8E, 0x0F, 0xAE, 0x73 + }, + { + 0x63, 0x9F, 0x42, 0xD6, 0xCD, 0xA9, 0x0C, 0x28, + 0x0C, 0x7F, 0xE9, 0x3C, 0x58, 0x1C, 0x94, 0x8F, + 0x15, 0xE7, 0xBC, 0x6F, 0x1A, 0xA6, 0x06, 0xB9, + 0x38, 0xE5, 0x10, 0x8F, 0x44, 0xBB, 0x7C, 0x5C + }, + { + 0x02, 0x9C, 0x27, 0x54, 0xDA, 0xED, 0xAE, 0xEB, + 0xBC, 0xAF, 0x3F, 0xE1, 0xE9, 0x79, 0x02, 0x7B, + 0xB2, 0x3C, 0x57, 0x98, 0xBB, 0xE7, 0xF1, 0x7F, + 0x92, 0x51, 0xD1, 0x13, 0xAE, 0x0D, 0xBD, 0x6C + }, + { + 0xED, 0x72, 0x24, 0xDD, 0x79, 0x55, 0x08, 0x69, + 0x7B, 0xDC, 0x90, 0x22, 0x94, 0x3C, 0x0C, 0x66, + 0x1B, 0x22, 0xAB, 0x6B, 0xC6, 0x2F, 0xCD, 0xE6, + 0xDA, 0xD9, 0xCA, 0xB7, 0xBC, 0x89, 0x6B, 0x27 + }, + { + 0xC7, 0x1E, 0x1C, 0x30, 0xC4, 0x75, 0x90, 0x68, + 0xD7, 0x48, 0x96, 0x65, 0x55, 0x9A, 0x48, 0xA2, + 0x5E, 0x43, 0x80, 0xD1, 0x9E, 0x2F, 0xF0, 0xAA, + 0x94, 0x10, 0x8F, 0x97, 0x72, 0x41, 0x0F, 0xA8 + }, + { + 0x3B, 0x0C, 0x5B, 0xC5, 0x8C, 0x09, 0x13, 0x22, + 0x1E, 0xF7, 0xBC, 0xD6, 0xB6, 0x6A, 0x43, 0xDE, + 0x34, 0xF9, 0x79, 0xBC, 0x2A, 0x33, 0x0B, 0x58, + 0x4C, 0xFE, 0xCE, 0x83, 0x68, 0xD2, 0xA6, 0x3A + }, + { + 0x70, 0xCD, 0x34, 0x1F, 0x55, 0xCE, 0xCF, 0x05, + 0xF4, 0x6B, 0x7C, 0x8B, 0xCE, 0x6F, 0x02, 0x1E, + 0x7C, 0x95, 0xB9, 0xDD, 0xB8, 0x7B, 0xB3, 0x1E, + 0x94, 0xCE, 0xD4, 0x72, 0xC8, 0x56, 0x48, 0x1B + }, + { + 0xB9, 0x4C, 0x93, 0xA4, 0xFE, 0x84, 0x96, 0xEC, + 0xE6, 0x3A, 0x68, 0x16, 0x59, 0x40, 0x29, 0x8D, + 0xC2, 0xB4, 0x07, 0xE2, 0xF3, 0xB8, 0x18, 0xDF, + 0xC2, 0x74, 0x9D, 0x06, 0xDD, 0x12, 0xB6, 0x69 + }, + { + 0xDE, 0xEB, 0xD9, 0xD9, 0x20, 0x9A, 0xD3, 0xED, + 0x53, 0xC3, 0x3F, 0x04, 0xAE, 0xD3, 0xC4, 0x35, + 0x6E, 0x73, 0x47, 0xBC, 0xBC, 0x50, 0x46, 0x8D, + 0x26, 0xFF, 0xFA, 0x4F, 0x5C, 0x00, 0xFD, 0x3C + }, + { + 0xE5, 0xE6, 0xA0, 0xBA, 0x00, 0x67, 0x9B, 0xCE, + 0xEC, 0x30, 0x79, 0x81, 0xC3, 0xFF, 0xB1, 0xB6, + 0x57, 0x9B, 0x8F, 0xAC, 0x58, 0x57, 0xAC, 0x68, + 0xF8, 0xDF, 0xBD, 0x7C, 0x56, 0xB2, 0x05, 0xD1 + }, + { + 0x24, 0xFB, 0x76, 0x21, 0xF0, 0xDE, 0xE7, 0xD8, + 0x06, 0x55, 0x7E, 0x86, 0x33, 0xB9, 0x6D, 0x8A, + 0x76, 0x4C, 0x43, 0xDA, 0x6B, 0xD3, 0xF1, 0xCE, + 0x5A, 0x99, 0x19, 0x9E, 0x67, 0xE1, 0xEA, 0x7D + }, + { + 0x52, 0x97, 0x4D, 0xBF, 0x81, 0x3C, 0x3C, 0x41, + 0x79, 0x9E, 0x80, 0x97, 0x91, 0xDA, 0x9D, 0x6E, + 0xE7, 0x7D, 0x2D, 0x39, 0x0B, 0x3B, 0x14, 0x95, + 0x2D, 0xF3, 0x8F, 0xDC, 0x6B, 0x02, 0x53, 0x0A + }, + { + 0x1E, 0x52, 0x40, 0xCE, 0x33, 0xC9, 0xCE, 0x6F, + 0x20, 0x99, 0xE7, 0xE6, 0xD8, 0x23, 0x2E, 0x48, + 0x38, 0x15, 0xAF, 0xB4, 0xC5, 0xDE, 0x02, 0x06, + 0x76, 0x51, 0x9A, 0x6D, 0xDF, 0x6B, 0x2B, 0x1F + }, + { + 0xE7, 0x1D, 0x38, 0xF7, 0x31, 0x61, 0xB7, 0x88, + 0xC0, 0x53, 0x45, 0xAC, 0x5F, 0x22, 0xAF, 0xE2, + 0xE3, 0x6D, 0xF4, 0xED, 0xEF, 0x00, 0x17, 0x9A, + 0x5A, 0x06, 0x47, 0x9D, 0xE7, 0xE3, 0x30, 0x66 + }, + { + 0x01, 0x9E, 0xEE, 0xB3, 0x9E, 0xC0, 0xFF, 0x5A, + 0xC3, 0xC8, 0xA8, 0x41, 0xFC, 0x07, 0xD0, 0x5B, + 0x1F, 0xE3, 0x32, 0xAF, 0x00, 0xA0, 0xD5, 0x7E, + 0x7E, 0xB8, 0xD6, 0x24, 0x47, 0x43, 0x87, 0xED + }, + { + 0x52, 0x4C, 0x94, 0xBA, 0xF3, 0x84, 0x6D, 0x2C, + 0x64, 0xC8, 0x85, 0x12, 0xB4, 0x16, 0x23, 0x95, + 0x8D, 0x36, 0x3C, 0x3A, 0xFD, 0x03, 0x87, 0xCF, + 0x2F, 0x42, 0xAB, 0x9A, 0xCF, 0xB9, 0x1C, 0x2F + }, + { + 0x35, 0x92, 0xA1, 0xC7, 0x51, 0x00, 0xB1, 0x94, + 0x2C, 0x0C, 0xF0, 0x2D, 0xEE, 0xAF, 0x00, 0x9E, + 0x64, 0x2F, 0x2A, 0xB3, 0xFF, 0x2C, 0xB0, 0xC9, + 0x48, 0xDA, 0x7D, 0xC1, 0x4E, 0x37, 0xF0, 0x00 + }, + { + 0x50, 0xCE, 0xA3, 0x08, 0xF1, 0x3F, 0x2C, 0x84, + 0x48, 0x3D, 0x90, 0x27, 0x37, 0x38, 0xA0, 0xA5, + 0x8E, 0xE8, 0x0F, 0x77, 0x71, 0xD0, 0xCC, 0xC0, + 0x74, 0x32, 0xC2, 0xA9, 0xD4, 0x96, 0xA1, 0xC8 + }, + { + 0x60, 0xEF, 0xD8, 0xEA, 0x83, 0xA3, 0x2D, 0x13, + 0x94, 0x69, 0x47, 0x6F, 0xA0, 0x04, 0x59, 0xE1, + 0x88, 0x88, 0x70, 0x50, 0xDC, 0xD5, 0x6E, 0xAA, + 0x10, 0x75, 0x25, 0xD4, 0x6C, 0x8B, 0xCE, 0xA9 + }, + { + 0x7B, 0x77, 0xEE, 0x4F, 0x6D, 0xCB, 0x33, 0xAA, + 0xB4, 0xA7, 0x3D, 0x2A, 0xF7, 0x0F, 0x34, 0xAC, + 0x88, 0x6F, 0xEA, 0xF0, 0xD7, 0xCC, 0xBC, 0x31, + 0x8B, 0x08, 0x34, 0xC5, 0x61, 0x5F, 0x41, 0x1E + }, + { + 0x64, 0x24, 0x15, 0xA3, 0x4E, 0x76, 0x0E, 0x4B, + 0xBB, 0x1D, 0xF3, 0x73, 0x13, 0x56, 0xF6, 0x67, + 0x63, 0x6C, 0x0B, 0x8F, 0x33, 0x0B, 0x01, 0x43, + 0xF7, 0x26, 0x0B, 0xC7, 0x0D, 0xB1, 0x9C, 0x10 + }, + { + 0x4E, 0x6A, 0x13, 0xED, 0xA2, 0x95, 0x2C, 0x3D, + 0xC0, 0x88, 0x10, 0xC5, 0x9C, 0xAD, 0x51, 0x35, + 0xD5, 0x52, 0x16, 0xBA, 0x94, 0x14, 0x70, 0x31, + 0xF0, 0x2A, 0xE7, 0x85, 0x30, 0x46, 0x1D, 0x68 + }, + { + 0x8A, 0x21, 0x9D, 0x61, 0x1A, 0xCB, 0xF6, 0xE3, + 0x2D, 0xD8, 0xD7, 0xED, 0x34, 0x26, 0xF1, 0x43, + 0x23, 0xC5, 0x32, 0xAC, 0xF4, 0xDB, 0x80, 0xFC, + 0x40, 0xCB, 0x24, 0x30, 0x9C, 0xE2, 0xB2, 0x2B + }, + { + 0x6F, 0x7D, 0x06, 0x84, 0x9B, 0x70, 0x69, 0xB6, + 0xDC, 0x66, 0x02, 0x62, 0xDC, 0x19, 0x29, 0xE5, + 0x01, 0x41, 0x3F, 0x52, 0xA6, 0xFD, 0x8C, 0x66, + 0xDF, 0x7E, 0xD2, 0xA1, 0x3C, 0x84, 0x57, 0x94 + }, + { + 0xAC, 0xE7, 0xE3, 0xCC, 0x22, 0x2E, 0x73, 0x6C, + 0xB5, 0x0F, 0x90, 0x5D, 0x9D, 0x48, 0xB8, 0x23, + 0x65, 0xE6, 0x0F, 0xAE, 0x2E, 0xAE, 0x65, 0x30, + 0xEC, 0x5C, 0x16, 0x75, 0x80, 0x73, 0xE4, 0xBB + }, + { + 0xB3, 0x95, 0xD4, 0x8A, 0x40, 0xEE, 0x12, 0x6F, + 0x29, 0xF5, 0x17, 0x26, 0xE7, 0x74, 0x83, 0x99, + 0xCF, 0x7A, 0xBB, 0xEE, 0xCD, 0xC8, 0xAC, 0x33, + 0xCA, 0xDA, 0xAA, 0x0E, 0xCB, 0xC0, 0xB8, 0xB7 + }, + { + 0x38, 0xDE, 0x12, 0xD9, 0xEC, 0x1E, 0x4D, 0x8F, + 0xA7, 0xCB, 0x1B, 0x73, 0x02, 0x8E, 0x1B, 0x5C, + 0x64, 0xCA, 0x62, 0x35, 0x22, 0x22, 0xC1, 0x34, + 0x97, 0x96, 0x5E, 0xCD, 0x60, 0x90, 0x10, 0xA2 + }, + { + 0xAD, 0x84, 0x4B, 0xE4, 0xE3, 0xFB, 0xD8, 0x26, + 0x27, 0xDC, 0x2C, 0x7D, 0xA9, 0xA6, 0xBB, 0xAB, + 0x45, 0xC6, 0xE3, 0x07, 0xD0, 0x70, 0xA6, 0xA0, + 0x2C, 0x8C, 0x3A, 0xAE, 0x16, 0x1F, 0x5E, 0x84 + }, + { + 0xF0, 0x64, 0x3A, 0x5E, 0x56, 0x26, 0x79, 0x80, + 0x5B, 0x44, 0x31, 0x13, 0x8E, 0xB8, 0x16, 0xDB, + 0x0A, 0xCC, 0x30, 0x6D, 0xB2, 0x12, 0x59, 0xD8, + 0xE6, 0x46, 0xCB, 0x7B, 0x6C, 0x0D, 0x1C, 0xE4 + }, + { + 0xA5, 0x54, 0x25, 0x0A, 0x04, 0x7A, 0x54, 0x67, + 0xC8, 0xA6, 0x8A, 0xDA, 0xE9, 0xF7, 0x24, 0x20, + 0x69, 0x5E, 0x44, 0x23, 0xA3, 0x36, 0x82, 0xC7, + 0xC7, 0x6D, 0x95, 0x5D, 0x1E, 0x27, 0xAF, 0xA8 + }, + { + 0xE2, 0x59, 0xC5, 0x9D, 0xE6, 0x60, 0xBA, 0x06, + 0x40, 0xDD, 0xF8, 0x9A, 0xAB, 0x93, 0xC3, 0x75, + 0xAE, 0x54, 0xD2, 0x65, 0x51, 0x6F, 0x16, 0x10, + 0x16, 0x9D, 0xCB, 0x4D, 0xE9, 0x01, 0xB9, 0x01 + }, + { + 0xAB, 0xDA, 0x39, 0x0D, 0x10, 0x24, 0xA6, 0xEB, + 0xD9, 0x2E, 0x50, 0x10, 0xC5, 0x69, 0x1B, 0x07, + 0x23, 0x63, 0x96, 0x82, 0xAF, 0xAD, 0x1D, 0xDE, + 0x81, 0x4D, 0xC6, 0x6A, 0x4B, 0x48, 0x3C, 0x1F + }, + { + 0x89, 0x42, 0xB9, 0x3C, 0xAF, 0x25, 0xD4, 0xE9, + 0xCD, 0x8C, 0xD3, 0x06, 0x00, 0x63, 0x6A, 0x51, + 0x62, 0xF5, 0x93, 0xD1, 0xE0, 0x7E, 0xD7, 0xD4, + 0x2E, 0xE9, 0xD2, 0xB2, 0x8A, 0xBF, 0x36, 0x22 + }, + { + 0x3A, 0x3F, 0x98, 0x95, 0xA1, 0xB6, 0x5C, 0x15, + 0x51, 0x74, 0x1C, 0x24, 0x51, 0xD6, 0x64, 0x12, + 0x2C, 0x3A, 0x6B, 0x7F, 0xF4, 0x51, 0xC4, 0x75, + 0xF4, 0x95, 0x22, 0xF2, 0x44, 0x6B, 0x81, 0xD6 + }, + { + 0x60, 0x18, 0xF8, 0x1F, 0x30, 0x3D, 0x21, 0x3D, + 0x15, 0xC7, 0x13, 0x6E, 0xCB, 0x03, 0xBD, 0xE4, + 0x27, 0x4A, 0xFC, 0xAC, 0x26, 0x76, 0x80, 0xFA, + 0x78, 0x40, 0x51, 0x58, 0x49, 0x30, 0xE1, 0x99 + }, + { + 0xF1, 0xBF, 0x7B, 0xAC, 0x0F, 0x5E, 0x02, 0x39, + 0x52, 0x46, 0xC3, 0x2F, 0xDB, 0x80, 0xCB, 0xCA, + 0x83, 0x7D, 0x50, 0x4E, 0x27, 0x9E, 0xD1, 0xD0, + 0x6D, 0x6E, 0x2E, 0x6D, 0xA0, 0xA4, 0x19, 0xFF + }, + { + 0xC5, 0xFA, 0xDF, 0xA8, 0xBF, 0x45, 0x78, 0x70, + 0xA4, 0x51, 0xA7, 0xB0, 0xEC, 0x12, 0xCC, 0xD4, + 0xAE, 0x51, 0xCB, 0x19, 0x5B, 0x7A, 0x4F, 0x9B, + 0x03, 0xFD, 0x83, 0x7B, 0x41, 0xAA, 0x01, 0x96 + }, + { + 0x2D, 0x5A, 0xC2, 0xA4, 0xD7, 0x53, 0x2B, 0x1B, + 0xC4, 0xF8, 0x0D, 0xD7, 0x28, 0x00, 0xAF, 0x07, + 0xE3, 0xC8, 0x4B, 0x8D, 0xB2, 0x9D, 0x3F, 0xD5, + 0xFE, 0xCC, 0xEC, 0x9A, 0x79, 0x87, 0x04, 0xCE + }, + { + 0xAB, 0xC4, 0x42, 0xF7, 0x54, 0x86, 0x1E, 0x86, + 0x64, 0xA6, 0xF4, 0x5A, 0x09, 0xFA, 0x4C, 0x3F, + 0xFB, 0xF9, 0xF6, 0x5F, 0xE2, 0x95, 0x1C, 0xE6, + 0xD8, 0xE0, 0xEF, 0x14, 0xF3, 0xEF, 0x70, 0xFF + }, + { + 0x07, 0x9B, 0xF9, 0xAE, 0xA1, 0x2E, 0xB7, 0x3D, + 0xEB, 0xD4, 0x68, 0xC0, 0x91, 0x0F, 0xBF, 0xC1, + 0x27, 0x5D, 0x02, 0x96, 0x55, 0x3F, 0x0A, 0x97, + 0x86, 0x82, 0x7B, 0xE8, 0xF1, 0xF8, 0xFC, 0x3F + }, + { + 0x07, 0xFA, 0xB9, 0x49, 0xB3, 0xD1, 0xA2, 0x23, + 0x01, 0x8C, 0xA9, 0x29, 0x41, 0x28, 0xA0, 0xD9, + 0xD3, 0x24, 0x1B, 0x6F, 0x3C, 0xC5, 0x59, 0x31, + 0xFB, 0x1E, 0x69, 0x5C, 0x8D, 0x5E, 0x7C, 0x71 + }, + { + 0x61, 0x4A, 0xDC, 0xB9, 0x08, 0x0C, 0x7D, 0x92, + 0xF7, 0x73, 0xC3, 0xC7, 0x36, 0x66, 0x61, 0x29, + 0xF3, 0x0B, 0x8F, 0x1D, 0x52, 0x40, 0x89, 0x3D, + 0x0B, 0x8C, 0xB9, 0xB6, 0x6E, 0x60, 0x58, 0x99 + }, + { + 0x56, 0xF7, 0x1B, 0x0E, 0x40, 0x3A, 0x33, 0x0A, + 0xA7, 0x37, 0xA2, 0xE3, 0x2B, 0x92, 0x6A, 0x09, + 0x7D, 0x93, 0x3A, 0x3A, 0xDB, 0x82, 0x4E, 0x3F, + 0x13, 0xFF, 0xC9, 0x40, 0xFD, 0x2E, 0xAC, 0xD7 + }, + { + 0x39, 0x1A, 0xBF, 0xA0, 0xD8, 0x71, 0x96, 0x12, + 0x9E, 0x1D, 0x9E, 0x89, 0x21, 0xD6, 0x95, 0x81, + 0x0D, 0x17, 0x16, 0xA2, 0x18, 0xCD, 0x0F, 0xAA, + 0x7A, 0xC6, 0x71, 0xA8, 0x72, 0x28, 0x49, 0xE7 + }, + { + 0x6F, 0xAC, 0x3E, 0x85, 0x55, 0x3E, 0x75, 0x1F, + 0xE7, 0x96, 0x36, 0x5C, 0x14, 0x24, 0xC7, 0x90, + 0xF0, 0x75, 0x21, 0x82, 0xC8, 0xAC, 0x23, 0x7B, + 0xAA, 0x4D, 0x70, 0x5F, 0xAD, 0x9F, 0xA0, 0x98 + }, + { + 0xB4, 0xC4, 0xD9, 0xAB, 0xF5, 0x02, 0x55, 0x50, + 0xB4, 0xF8, 0xC8, 0xF1, 0xAC, 0x61, 0x7B, 0xFC, + 0xA4, 0xEF, 0x2B, 0x7A, 0xA6, 0xA5, 0x0C, 0x43, + 0x5A, 0xF7, 0xCE, 0xF6, 0x2E, 0x28, 0x8F, 0x3C + }, + { + 0x52, 0x9F, 0x80, 0xFC, 0x14, 0x09, 0x6F, 0x97, + 0x83, 0xBA, 0x78, 0x33, 0xE6, 0xA9, 0x00, 0xFE, + 0x28, 0x29, 0x16, 0xB0, 0x18, 0xC5, 0x9E, 0xA4, + 0x70, 0xBC, 0x5F, 0x68, 0x0A, 0xE6, 0x33, 0x87 + }, + { + 0xA4, 0xCF, 0x44, 0x7E, 0xDF, 0xFB, 0x82, 0x00, + 0xC0, 0xD4, 0xD5, 0x08, 0xBA, 0x28, 0x88, 0x01, + 0x61, 0xD6, 0xA1, 0xF6, 0x0F, 0x76, 0x9B, 0x5A, + 0x14, 0xE8, 0x1E, 0xF7, 0x73, 0xF6, 0xD1, 0x95 + }, + { + 0x58, 0x1E, 0x63, 0xA4, 0xF9, 0xD2, 0x6D, 0x9B, + 0x83, 0x26, 0xBD, 0x3C, 0x41, 0x12, 0x4A, 0xFB, + 0xEE, 0x1C, 0x10, 0x7C, 0x1E, 0xE8, 0x2A, 0xA8, + 0x3A, 0x4B, 0xD7, 0xAC, 0x9A, 0xB7, 0x26, 0xE3 + }, + { + 0xE1, 0x87, 0x37, 0x4C, 0x95, 0x42, 0x79, 0xD7, + 0x39, 0x8F, 0x9A, 0x8D, 0x68, 0x04, 0x23, 0x6F, + 0x21, 0x5A, 0x60, 0x9B, 0x0B, 0xF0, 0x82, 0x24, + 0xEF, 0x1E, 0x65, 0x65, 0xA1, 0x5C, 0xA7, 0xA3 + }, + { + 0x65, 0x85, 0x79, 0x6B, 0xED, 0xEC, 0xD0, 0x22, + 0x44, 0x3F, 0xC6, 0x85, 0x36, 0x8E, 0x81, 0x98, + 0xFC, 0xDA, 0xDE, 0x7C, 0xBB, 0xBE, 0x49, 0x32, + 0xEF, 0x29, 0x47, 0x7B, 0x62, 0xC1, 0x7B, 0x36 + }, + { + 0xBE, 0xED, 0x89, 0x87, 0xD5, 0xCC, 0xDA, 0xB2, + 0xD1, 0x71, 0x51, 0x43, 0x6F, 0x0A, 0xDA, 0xD1, + 0xD8, 0x41, 0x19, 0x77, 0x0A, 0x87, 0x46, 0x6E, + 0x11, 0x44, 0x36, 0x94, 0xD2, 0xBD, 0xDD, 0x34 + }, + { + 0xDD, 0x31, 0x11, 0x82, 0xB7, 0x14, 0xD2, 0x43, + 0xFD, 0x97, 0x55, 0xB4, 0x38, 0x89, 0x03, 0x68, + 0xE6, 0x0E, 0xBC, 0xBB, 0x98, 0xFA, 0x59, 0x3B, + 0x24, 0xCF, 0x5D, 0x41, 0x70, 0xF5, 0xB9, 0x36 + }, + { + 0xF1, 0xEE, 0x3F, 0x32, 0x03, 0x77, 0xEB, 0x8B, + 0xA7, 0xAC, 0x86, 0xA4, 0xCF, 0xE5, 0xC9, 0xBB, + 0x50, 0x90, 0xF6, 0x7E, 0x6E, 0x65, 0xDC, 0x1A, + 0x6B, 0x11, 0x2E, 0xCE, 0x93, 0xC6, 0x95, 0xFE + }, + { + 0x82, 0x79, 0xA3, 0xAF, 0x3D, 0x39, 0x5F, 0xAF, + 0x2C, 0x00, 0x21, 0x49, 0xAD, 0x35, 0x61, 0x98, + 0xE2, 0x91, 0x9A, 0x96, 0xE8, 0x28, 0xD7, 0xF3, + 0x9A, 0xC5, 0x39, 0x56, 0xCE, 0x30, 0x9E, 0x25 + }, + { + 0xD9, 0x41, 0x54, 0x1F, 0xEB, 0x6E, 0x77, 0xEF, + 0xF1, 0x08, 0x13, 0x75, 0xF9, 0xBF, 0x74, 0xD2, + 0x00, 0x16, 0x7C, 0x6D, 0xA9, 0x85, 0x82, 0x83, + 0x33, 0x33, 0x83, 0x7A, 0xDF, 0xC4, 0x4D, 0xFF + }, + { + 0x23, 0xBE, 0x11, 0xF0, 0xF9, 0x27, 0xBD, 0x8A, + 0xE8, 0x4E, 0x20, 0x0C, 0xCD, 0xBC, 0xF1, 0x91, + 0xF9, 0x86, 0xDC, 0x65, 0x99, 0x00, 0x6F, 0x55, + 0xCE, 0xF6, 0xAE, 0xBB, 0xFF, 0xFF, 0x8F, 0xDE + }, + { + 0x28, 0xD0, 0xA1, 0xCD, 0x86, 0x12, 0x7E, 0x75, + 0xD5, 0x46, 0x93, 0x72, 0x8D, 0x18, 0x97, 0x93, + 0x0A, 0x91, 0x2B, 0x24, 0x25, 0x21, 0x7C, 0xAF, + 0xCB, 0xA0, 0x01, 0xCC, 0xD5, 0xEC, 0x60, 0xC5 + }, + { + 0x77, 0x0A, 0x9B, 0x24, 0x04, 0xAE, 0x6D, 0xE9, + 0x99, 0x79, 0xE1, 0x3C, 0xC2, 0x10, 0xF6, 0x47, + 0x71, 0xFA, 0xEE, 0x63, 0xF8, 0x94, 0x31, 0xB2, + 0x97, 0xB4, 0x93, 0x30, 0xA9, 0x54, 0xE3, 0x9D + }, + { + 0x8B, 0xEE, 0xCE, 0xCE, 0x25, 0xCB, 0x9E, 0x17, + 0x1D, 0x17, 0xE8, 0x76, 0x88, 0x0D, 0xA8, 0x79, + 0x91, 0xF3, 0x78, 0xB7, 0xC0, 0xF6, 0x5F, 0xC4, + 0x88, 0x20, 0x95, 0xBE, 0x00, 0x61, 0xD9, 0x4E + }, + { + 0x7B, 0x70, 0x2C, 0xA9, 0x46, 0x0A, 0x9E, 0x6A, + 0xCD, 0x88, 0xA5, 0x25, 0x23, 0x83, 0xFD, 0xB6, + 0x54, 0x09, 0xE1, 0xAF, 0xF1, 0x7D, 0x37, 0x47, + 0x04, 0x43, 0x2B, 0xEF, 0xDB, 0x16, 0xC5, 0x47 + }, + { + 0x38, 0x8D, 0x52, 0x9C, 0xBB, 0xBE, 0x53, 0x7C, + 0x47, 0x80, 0xBB, 0xA3, 0xE9, 0x55, 0xB5, 0x40, + 0x60, 0x03, 0x03, 0x2D, 0xF0, 0x06, 0xD0, 0x58, + 0xBC, 0x39, 0xAE, 0x78, 0x83, 0xDC, 0x46, 0x90 + }, + { + 0x33, 0xB2, 0xFA, 0xE3, 0x7B, 0x89, 0xA2, 0xCE, + 0xCA, 0xDA, 0x12, 0x42, 0xF1, 0x71, 0x3C, 0xD1, + 0x45, 0x42, 0x27, 0xD4, 0x6D, 0xA9, 0x54, 0x85, + 0x4A, 0xCB, 0xD0, 0x0A, 0x9E, 0x15, 0x32, 0x97 + }, + { + 0x20, 0x41, 0xC3, 0xE2, 0x4F, 0xA4, 0xA5, 0xF7, + 0xCA, 0x09, 0x0E, 0xE0, 0x91, 0x4F, 0x42, 0x16, + 0xC8, 0xD4, 0xA6, 0xB9, 0xDA, 0xAC, 0xD5, 0x34, + 0xA2, 0x7A, 0xD1, 0xDD, 0x5E, 0xDB, 0x69, 0x84 + }, + { + 0x5D, 0x21, 0xDE, 0x37, 0xF2, 0xC6, 0x6A, 0xEA, + 0x88, 0xBF, 0x0C, 0x48, 0x0E, 0x30, 0xD2, 0x4D, + 0x31, 0x0A, 0xBB, 0x1A, 0xAA, 0x19, 0x8A, 0x21, + 0x1F, 0xAF, 0x1C, 0x18, 0xA3, 0xD3, 0x4E, 0x39 + }, + { + 0xC7, 0x49, 0xA0, 0x32, 0xCD, 0x43, 0x5C, 0x99, + 0xF7, 0x9A, 0xF4, 0xE7, 0x99, 0x42, 0x0D, 0xF4, + 0x0A, 0x1C, 0xC9, 0xB8, 0xDA, 0x24, 0x29, 0xB7, + 0x86, 0x9C, 0xDE, 0x95, 0x58, 0x83, 0xD0, 0x16 + }, + { + 0xFB, 0x4B, 0x6E, 0x35, 0xFE, 0xF7, 0xF8, 0xCF, + 0xEC, 0x8A, 0xFA, 0x54, 0x25, 0x35, 0xF5, 0x02, + 0xD8, 0x9F, 0x1B, 0x76, 0x1A, 0x2E, 0xAC, 0x32, + 0xF0, 0x68, 0x1B, 0xD3, 0xFA, 0xA0, 0x09, 0x0F + }, + { + 0x98, 0x19, 0xC3, 0xD9, 0xF0, 0x7D, 0xFE, 0x05, + 0xB5, 0x7E, 0x1D, 0x72, 0xCD, 0x07, 0x9D, 0x7A, + 0xD2, 0x16, 0x23, 0x77, 0x0D, 0x4F, 0xE4, 0x2C, + 0x80, 0x74, 0x2B, 0xF5, 0xC4, 0xFF, 0xE9, 0x28 + }, + { + 0x63, 0x7E, 0xE0, 0x50, 0xC6, 0x50, 0xFA, 0xAA, + 0xAE, 0x20, 0x90, 0x52, 0x30, 0xD6, 0x4B, 0x9F, + 0x65, 0x90, 0x53, 0xD4, 0x7C, 0xFD, 0xB7, 0xAC, + 0xAD, 0x44, 0xF0, 0x91, 0x32, 0x52, 0xC7, 0x97 + }, + { + 0x9D, 0x8B, 0xC0, 0x1D, 0xAF, 0x9D, 0xC6, 0x0C, + 0xAC, 0x10, 0x3D, 0xC3, 0x56, 0x62, 0xD4, 0x9A, + 0xD0, 0xED, 0xF5, 0x9E, 0xCA, 0x82, 0x31, 0x4A, + 0x4B, 0xDC, 0x19, 0xF2, 0x59, 0x2D, 0x2A, 0x9B + }, + { + 0xA7, 0x75, 0x29, 0xAF, 0x39, 0xF3, 0xD8, 0x25, + 0x61, 0x90, 0x01, 0x6E, 0x3C, 0xC8, 0xEA, 0x4B, + 0x14, 0xBE, 0xCF, 0x71, 0x8B, 0x76, 0xD8, 0xA4, + 0x41, 0x31, 0x54, 0x6B, 0x65, 0x57, 0x11, 0xFB + }, + { + 0xAD, 0xC2, 0x80, 0x66, 0xC7, 0x0B, 0x58, 0xC5, + 0xFA, 0x24, 0x16, 0xFC, 0xDD, 0x11, 0x7B, 0x8F, + 0xB5, 0xD1, 0xFB, 0x06, 0xD1, 0x26, 0x97, 0x2A, + 0x69, 0x1A, 0xEA, 0xCE, 0xBD, 0xE1, 0xF3, 0x44 + }, + { + 0xD1, 0x41, 0x53, 0x50, 0x90, 0x92, 0xC0, 0x2A, + 0xC9, 0x3A, 0xD4, 0xCF, 0x21, 0x20, 0x38, 0xF2, + 0x3E, 0xD6, 0xB1, 0x14, 0x54, 0x06, 0x24, 0xD0, + 0xB3, 0x24, 0x2D, 0x18, 0x66, 0x12, 0x5A, 0x4B + }, + { + 0x34, 0xC8, 0xB6, 0x60, 0xB3, 0x76, 0x19, 0x40, + 0x77, 0x8C, 0x3E, 0xCF, 0xF6, 0xBB, 0xB5, 0x21, + 0xF1, 0xD3, 0x9A, 0x32, 0x5F, 0x44, 0x91, 0x05, + 0xA3, 0xAB, 0x4B, 0xEA, 0x57, 0x3A, 0xD4, 0x57 + }, + { + 0xF8, 0x3C, 0x7D, 0xD7, 0xA7, 0xC1, 0xCB, 0x4C, + 0x45, 0x89, 0x16, 0x19, 0x32, 0x14, 0x8B, 0x6E, + 0x37, 0x17, 0x1C, 0x9F, 0x11, 0xBB, 0x36, 0x98, + 0x61, 0x94, 0xFA, 0x9F, 0x6D, 0x7C, 0x8D, 0xC2 + }, + { + 0x51, 0x83, 0x39, 0xEA, 0xA9, 0x32, 0xD4, 0x5D, + 0x68, 0x9A, 0x3F, 0x7F, 0x1C, 0x69, 0x90, 0xBD, + 0x67, 0x90, 0xF2, 0xAB, 0x0D, 0x44, 0x7A, 0xDA, + 0x60, 0x5B, 0x82, 0x85, 0x03, 0xFE, 0x5B, 0xF8 + }, + { + 0x8F, 0x0F, 0x80, 0x1A, 0x29, 0x88, 0x52, 0x41, + 0x13, 0xE3, 0x13, 0xE1, 0x4B, 0xEA, 0x2C, 0xB0, + 0xD7, 0x6A, 0xDC, 0x02, 0x3C, 0x7C, 0x0E, 0x6D, + 0x4E, 0xB1, 0xAB, 0x46, 0x8C, 0x81, 0x5B, 0xC5 + }, + { + 0xA6, 0x8A, 0xC8, 0x64, 0x4C, 0x2F, 0xEB, 0x90, + 0x9E, 0x6C, 0xD2, 0xCF, 0x7E, 0xF1, 0xA9, 0x96, + 0x36, 0x2D, 0x94, 0x8C, 0x21, 0x53, 0x2A, 0x96, + 0x95, 0xD6, 0xDE, 0x9D, 0xFD, 0xFD, 0x30, 0xB4 + }, + { + 0x0A, 0x0C, 0x4E, 0x65, 0x4C, 0xD9, 0x46, 0x2B, + 0xE0, 0x19, 0x0A, 0x37, 0xE1, 0x90, 0x76, 0xEC, + 0x25, 0xF2, 0xF3, 0x58, 0xE9, 0x60, 0xBF, 0x77, + 0xDF, 0x45, 0xBA, 0x14, 0x12, 0xF4, 0xF7, 0x96 + }, + { + 0x4E, 0x99, 0x1A, 0x3A, 0x6D, 0x5E, 0x61, 0xC5, + 0xBE, 0x0E, 0x0C, 0xEB, 0xE8, 0x15, 0x91, 0x16, + 0x1B, 0x42, 0x4A, 0xA3, 0x8B, 0x55, 0xD3, 0x06, + 0x40, 0xE8, 0x79, 0xA7, 0x2B, 0x6B, 0x06, 0x83 + }, + { + 0x4C, 0x0A, 0xBD, 0x86, 0x1C, 0xB0, 0xF0, 0xF3, + 0xDC, 0xB3, 0x80, 0x5E, 0xC5, 0x13, 0xD6, 0x80, + 0x45, 0x71, 0x42, 0x71, 0xBA, 0x11, 0x32, 0xE6, + 0xC7, 0x6F, 0x23, 0xC2, 0x48, 0xCE, 0x9F, 0x3C + }, + { + 0xC6, 0xD8, 0x65, 0x60, 0x0D, 0x8E, 0x41, 0xE2, + 0xD2, 0xF7, 0xAC, 0x64, 0xD7, 0x02, 0x6B, 0x25, + 0x76, 0xFE, 0x61, 0x67, 0x37, 0xCD, 0x81, 0xEB, + 0x60, 0x21, 0xE5, 0x7B, 0xD4, 0xEE, 0x5F, 0x7C + }, + { + 0x39, 0x11, 0x44, 0x24, 0x94, 0xC2, 0x6B, 0xEC, + 0x40, 0x04, 0xFA, 0x74, 0x58, 0xE3, 0xE0, 0xB1, + 0x01, 0x68, 0x8F, 0xCA, 0xCE, 0x61, 0x5F, 0x4F, + 0xAB, 0xBC, 0x95, 0xF1, 0xCC, 0x7F, 0x6C, 0xF8 + }, + { + 0x8C, 0x85, 0x69, 0xE2, 0xC4, 0x9A, 0x9F, 0xA3, + 0x7E, 0x27, 0xED, 0x81, 0xD0, 0xDA, 0x58, 0x38, + 0x4E, 0x98, 0x28, 0x12, 0x4B, 0x29, 0x04, 0xF5, + 0xC2, 0x82, 0x42, 0xD4, 0x8C, 0x17, 0x38, 0x1C + }, + { + 0x96, 0x38, 0xFA, 0xD9, 0xE7, 0xF8, 0xB6, 0x75, + 0x89, 0x4E, 0xCE, 0xAD, 0x11, 0x23, 0xC7, 0xC7, + 0x84, 0x2E, 0xC8, 0xD5, 0x41, 0x6D, 0xE1, 0x0B, + 0xDD, 0xF8, 0x96, 0xF0, 0x01, 0xF8, 0x26, 0x46 + }, + { + 0x5D, 0x86, 0x89, 0xAB, 0xF9, 0x5F, 0x77, 0xD1, + 0x3E, 0x92, 0x60, 0x04, 0x0B, 0x43, 0xDE, 0x39, + 0x03, 0xED, 0x48, 0xE2, 0x9B, 0x74, 0x41, 0x45, + 0x8E, 0xF7, 0x8B, 0xB2, 0x23, 0x35, 0x1B, 0xD6 + }, + { + 0x91, 0x4D, 0xFC, 0x7B, 0x2C, 0xC8, 0xF3, 0x81, + 0xA9, 0x84, 0x79, 0x97, 0xE8, 0xCB, 0x60, 0x2D, + 0xF7, 0xFB, 0x2B, 0x20, 0x4E, 0xC6, 0x14, 0x2A, + 0x08, 0xD1, 0x2C, 0x55, 0x54, 0xD8, 0x2B, 0xFD + }, + { + 0xB1, 0x4E, 0x67, 0x61, 0xCA, 0xAE, 0x41, 0x5F, + 0x73, 0x44, 0x00, 0x10, 0xE7, 0x06, 0x41, 0xB1, + 0xA5, 0x7D, 0xC5, 0xF9, 0xD4, 0xD2, 0xDF, 0xDA, + 0x8A, 0xE2, 0x0A, 0x86, 0x4A, 0x1D, 0x64, 0xCD + }, + { + 0xE8, 0xB9, 0xB8, 0xEB, 0x97, 0x31, 0x38, 0x88, + 0x35, 0x59, 0x20, 0x08, 0xB0, 0x4C, 0x74, 0xC5, + 0x5B, 0xF8, 0x71, 0xC2, 0x1B, 0xF8, 0x4D, 0xE4, + 0x53, 0xC5, 0x34, 0x99, 0x75, 0x31, 0x91, 0xDF + }, + { + 0x95, 0xB7, 0x12, 0x81, 0xF1, 0xFF, 0x98, 0xDD, + 0x78, 0xB4, 0xEC, 0x1C, 0x5A, 0x03, 0x1B, 0x7C, + 0x24, 0x57, 0xBD, 0xD6, 0x25, 0xD0, 0x49, 0xF9, + 0xCB, 0xF8, 0x0F, 0x8B, 0x5A, 0x34, 0xA3, 0xF6 + }, + { + 0xEB, 0x03, 0x0A, 0x12, 0x39, 0x28, 0x72, 0x32, + 0x40, 0x5C, 0x79, 0x7F, 0x04, 0xB4, 0x61, 0x03, + 0x84, 0x03, 0xB4, 0xF8, 0x93, 0xD8, 0xE2, 0xD0, + 0xC7, 0x7F, 0x88, 0xE2, 0x00, 0xAE, 0xCC, 0x2F + }, + { + 0x09, 0xC2, 0xFF, 0x57, 0x0F, 0x7D, 0xB8, 0xC6, + 0x6E, 0x4C, 0x6C, 0x0A, 0xEF, 0xC5, 0x46, 0x12, + 0xE3, 0xEC, 0x3D, 0x81, 0x9C, 0xF0, 0xCB, 0x62, + 0x98, 0x97, 0x87, 0x5E, 0xC4, 0x7D, 0x98, 0x63 + }, + { + 0x34, 0x09, 0x9D, 0x29, 0x9E, 0x90, 0x48, 0x37, + 0x3D, 0x27, 0xD0, 0x17, 0x24, 0x04, 0xDB, 0x79, + 0x6D, 0xB9, 0xE8, 0x26, 0x4D, 0x56, 0xCD, 0x09, + 0x1D, 0x9E, 0xA8, 0xBE, 0x4B, 0xF8, 0xD4, 0x03 + }, + { + 0xB8, 0xBD, 0x27, 0x17, 0x47, 0x9C, 0xF1, 0x1F, + 0xA1, 0xDC, 0x61, 0x40, 0x0A, 0x11, 0xD4, 0xE4, + 0x36, 0xCC, 0xA6, 0x55, 0x64, 0xE4, 0x16, 0xAC, + 0x7B, 0x5F, 0xB2, 0x6F, 0xE4, 0x3E, 0x50, 0xE0 + }, + { + 0x91, 0x30, 0x7D, 0x3C, 0x20, 0xA1, 0xAF, 0xA3, + 0x74, 0xF9, 0x2E, 0x9F, 0xD8, 0x4B, 0x72, 0xE6, + 0xC6, 0x4E, 0x92, 0xD5, 0x29, 0xC1, 0x01, 0x7F, + 0x73, 0x2D, 0x54, 0x83, 0x5D, 0x5D, 0xEB, 0x1C + }, + { + 0xF6, 0x31, 0xDB, 0x6E, 0x79, 0xB5, 0x9C, 0x8B, + 0xBE, 0x70, 0xBE, 0x51, 0x13, 0xFB, 0xD0, 0x39, + 0xC3, 0xBA, 0x42, 0x6D, 0xBD, 0x82, 0x0B, 0xBE, + 0xFC, 0xE2, 0xFA, 0x36, 0x25, 0x95, 0xFD, 0x10 + }, + { + 0x45, 0xBD, 0x19, 0x19, 0xA4, 0xBA, 0x33, 0x4D, + 0xE1, 0xB5, 0xD3, 0x98, 0x67, 0x90, 0xF5, 0x5C, + 0x65, 0x06, 0xE9, 0x99, 0xC5, 0x26, 0x52, 0x9A, + 0x42, 0x50, 0x30, 0x91, 0xFB, 0xE1, 0x9D, 0x53 + }, + { + 0x26, 0xD9, 0x14, 0x41, 0x5C, 0x3A, 0xCF, 0x55, + 0x21, 0x69, 0x4E, 0x8B, 0x4C, 0xFF, 0xBE, 0x43, + 0x35, 0xFF, 0x0F, 0xB1, 0x93, 0x6B, 0x7D, 0x33, + 0xD4, 0x0A, 0x90, 0xE4, 0x40, 0xF8, 0x1D, 0xFE + }, + { + 0x0A, 0xB6, 0xDF, 0x0E, 0x1F, 0x11, 0x8B, 0x83, + 0x1A, 0xB9, 0x25, 0x38, 0xDE, 0x8E, 0x9E, 0xE3, + 0x6D, 0xE9, 0x13, 0x69, 0x73, 0x2C, 0x93, 0x2A, + 0x25, 0x43, 0x3C, 0x33, 0xA8, 0xF2, 0xE9, 0x79 + }, + { + 0xF5, 0x2D, 0x3B, 0x14, 0xB3, 0x07, 0xCF, 0x01, + 0xD4, 0x70, 0xE1, 0x73, 0x55, 0x42, 0x24, 0xB0, + 0x1C, 0xE4, 0xDC, 0x90, 0x48, 0x6A, 0x4B, 0x71, + 0x69, 0xA4, 0xAD, 0xBC, 0xD5, 0x79, 0x80, 0x9A + }, + { + 0x67, 0xC9, 0x1D, 0x19, 0xAE, 0xF9, 0x10, 0xD3, + 0x8D, 0xA2, 0x76, 0xA9, 0x5F, 0x82, 0x6C, 0x06, + 0x9E, 0x2B, 0x0C, 0xCB, 0x1C, 0x3B, 0xC8, 0x9B, + 0x22, 0x9E, 0x22, 0x11, 0x33, 0x7D, 0x5F, 0x37 + }, + { + 0x8F, 0x9B, 0x4C, 0x21, 0xAE, 0x60, 0x9E, 0x55, + 0x10, 0x14, 0xF0, 0xA3, 0x1A, 0x58, 0x6E, 0xB6, + 0xB8, 0x06, 0xE8, 0x1C, 0x46, 0xB7, 0x30, 0x73, + 0x4D, 0xF3, 0x6B, 0x72, 0xA8, 0xB8, 0x0D, 0x63 + }, + { + 0xC4, 0xA2, 0x7A, 0xA4, 0x7B, 0x03, 0xA7, 0x48, + 0x5F, 0x76, 0x86, 0xCB, 0x4E, 0x3D, 0x05, 0xEC, + 0xA9, 0xDA, 0x0C, 0xDE, 0xB8, 0xF9, 0x18, 0xBE, + 0x05, 0xA3, 0xD4, 0xA2, 0x77, 0x70, 0x8B, 0x39 + }, + { + 0xC7, 0xFB, 0xE1, 0x5C, 0x66, 0x6F, 0x55, 0x4B, + 0x4F, 0xBB, 0x11, 0x4B, 0xD4, 0xB7, 0x72, 0x0C, + 0xD3, 0xB1, 0x16, 0xD0, 0xB9, 0x74, 0xCD, 0x93, + 0x9E, 0x4D, 0x9F, 0xB6, 0xF8, 0xD7, 0x9C, 0x01 + }, + { + 0x5F, 0x7D, 0x0B, 0x27, 0x93, 0x37, 0xE3, 0x95, + 0xE4, 0x2B, 0x57, 0xFF, 0x0E, 0x13, 0xAA, 0xAF, + 0xA5, 0x5D, 0xFE, 0xEE, 0xD4, 0x83, 0x3A, 0x1B, + 0x1A, 0x4D, 0x45, 0x28, 0xAE, 0x83, 0x0B, 0xB9 + }, + { + 0xAB, 0x33, 0xB0, 0xA0, 0x91, 0xB4, 0xA0, 0x8D, + 0x5E, 0x6C, 0xD0, 0xB1, 0x9C, 0x48, 0xFE, 0xE3, + 0xA1, 0x4A, 0xD7, 0x5A, 0xE6, 0xE3, 0xDF, 0x7C, + 0x28, 0xE6, 0x10, 0xE9, 0x2F, 0x4C, 0xDD, 0xFC + }, + { + 0x6A, 0xBF, 0x23, 0xD0, 0x25, 0xC0, 0x3A, 0x6A, + 0x96, 0x85, 0xEE, 0xAB, 0x09, 0x9D, 0x6C, 0x1E, + 0xC2, 0x70, 0x74, 0x3F, 0x27, 0xD8, 0xA7, 0x92, + 0x47, 0x75, 0x20, 0x01, 0xFD, 0xDA, 0x1D, 0xD0 + }, + { + 0x6B, 0x37, 0x2F, 0xD0, 0x5B, 0x63, 0xF4, 0xE0, + 0x8D, 0x71, 0xA9, 0x18, 0xD0, 0xAD, 0x15, 0xC9, + 0x05, 0x91, 0x81, 0x91, 0xD2, 0x0E, 0x9C, 0x2C, + 0xBD, 0x58, 0x59, 0x15, 0x40, 0xEE, 0xBF, 0x78 + }, + { + 0x43, 0xB7, 0x08, 0x39, 0x1C, 0xC9, 0xCD, 0xAD, + 0xD4, 0x2A, 0xC2, 0x4A, 0x1B, 0xCD, 0xE8, 0xD5, + 0x05, 0xC2, 0xD3, 0xA6, 0x82, 0x1A, 0xD7, 0xF6, + 0x50, 0x10, 0x2A, 0x54, 0xB4, 0x94, 0xDB, 0x62 + }, + { + 0x32, 0x5C, 0x18, 0xE6, 0x6F, 0x6A, 0x7B, 0x48, + 0x95, 0x44, 0x5C, 0x16, 0x7F, 0xCA, 0x32, 0xA7, + 0xC0, 0x6C, 0xDF, 0xCF, 0xCC, 0x89, 0x34, 0x62, + 0x6B, 0x5E, 0xD4, 0xC4, 0x7F, 0xE5, 0x3C, 0x94 + }, + { + 0xC7, 0x30, 0x91, 0x5A, 0x02, 0x3D, 0x09, 0xFA, + 0x6E, 0x4A, 0x6A, 0x6E, 0xAD, 0x46, 0xFD, 0xBB, + 0x89, 0x4E, 0x0B, 0x4E, 0x55, 0xBD, 0xAA, 0x13, + 0x7E, 0x00, 0x2E, 0x85, 0xB4, 0x6B, 0x00, 0xE0 + }, + { + 0x81, 0x0F, 0x87, 0x14, 0x35, 0xED, 0xEC, 0xB3, + 0x4C, 0x3B, 0x94, 0x9D, 0x60, 0xDD, 0x2B, 0x05, + 0xFA, 0x1F, 0x95, 0xFF, 0x26, 0xC6, 0xB6, 0xF9, + 0x0B, 0x44, 0x5B, 0x06, 0x42, 0x7C, 0x95, 0x04 + }, + { + 0x01, 0x10, 0xB3, 0xB6, 0x39, 0xC2, 0xDB, 0xC9, + 0xBE, 0xBA, 0xED, 0xC7, 0xED, 0x7B, 0x95, 0x5E, + 0x6C, 0xD0, 0x52, 0x65, 0x08, 0x78, 0xFB, 0x04, + 0x12, 0xC5, 0x04, 0x37, 0x3A, 0x5B, 0x9D, 0xB0 + }, + { + 0xC9, 0x81, 0x67, 0x51, 0x46, 0xF7, 0x24, 0xC3, + 0x8C, 0x8D, 0xA0, 0xA6, 0xC1, 0xCD, 0xBB, 0x23, + 0x67, 0xA0, 0xF3, 0x98, 0xAB, 0xF2, 0x0C, 0xFD, + 0x6F, 0x65, 0x57, 0x05, 0x3E, 0x3C, 0xE8, 0x58 + }, + { + 0x5C, 0x00, 0x4B, 0x96, 0x83, 0x62, 0x5C, 0x85, + 0x29, 0xE9, 0x8F, 0x48, 0x44, 0x03, 0xFB, 0xDC, + 0x9A, 0xFE, 0xD9, 0xB6, 0x92, 0x65, 0x50, 0x63, + 0x78, 0x57, 0xC9, 0xF0, 0x70, 0xFB, 0x7D, 0x93 + }, + { + 0xC3, 0xA8, 0x5E, 0xE8, 0x9A, 0x06, 0x47, 0x6E, + 0x38, 0x0E, 0xF6, 0x86, 0x73, 0xF8, 0xB5, 0x83, + 0xE7, 0x5B, 0x58, 0x0F, 0x3F, 0x52, 0x94, 0xE2, + 0x47, 0xA5, 0xBF, 0x48, 0xB0, 0xAC, 0x1D, 0x92 + }, + { + 0x25, 0x1F, 0xF3, 0x23, 0xA9, 0x1D, 0xA0, 0xFA, + 0x2A, 0x66, 0xDA, 0x87, 0x98, 0xD1, 0x04, 0xDA, + 0x22, 0x6C, 0x28, 0xEF, 0x41, 0x87, 0xD4, 0xE9, + 0xB5, 0x45, 0x34, 0x99, 0xF3, 0xA8, 0xB8, 0xFE + }, + { + 0x8A, 0x87, 0xCD, 0x4F, 0xB7, 0x67, 0x3C, 0x9D, + 0x26, 0xB9, 0x71, 0x55, 0x88, 0xFB, 0xD8, 0x7E, + 0xA2, 0x26, 0x56, 0x96, 0xD4, 0x44, 0x54, 0x2D, + 0x7D, 0xEE, 0x45, 0x24, 0x66, 0xE5, 0xD9, 0xAC + }, + { + 0x47, 0x1C, 0xDD, 0x67, 0xCC, 0x8B, 0xE0, 0x1E, + 0x06, 0xED, 0x79, 0xCF, 0x8A, 0x2E, 0x42, 0x8C, + 0xB6, 0x4D, 0x70, 0xC6, 0xEB, 0x0D, 0xF2, 0x2E, + 0x6C, 0xE8, 0x5A, 0x8E, 0x3A, 0x76, 0x78, 0xF6 + }, + { + 0x7A, 0xB4, 0xE3, 0xF8, 0x92, 0xBB, 0xF3, 0xB9, + 0x2A, 0x1C, 0x1E, 0xC5, 0x5A, 0x0D, 0xCF, 0x34, + 0xB3, 0x4C, 0x6F, 0xDB, 0x43, 0x2B, 0x0B, 0x86, + 0x70, 0x41, 0xF6, 0xFA, 0x0D, 0x77, 0x48, 0x44 + }, + { + 0x1A, 0x4E, 0xE0, 0xEB, 0x5B, 0x9D, 0x88, 0xCF, + 0xD4, 0x67, 0x65, 0xFA, 0x01, 0x6F, 0xCB, 0x56, + 0xA9, 0x9B, 0xF5, 0xBF, 0x79, 0xEA, 0xE4, 0xB0, + 0x26, 0xCA, 0x42, 0xCD, 0xEE, 0xB0, 0xBC, 0x93 + }, + { + 0x48, 0x46, 0x87, 0xD1, 0x3A, 0x4F, 0x4C, 0xDD, + 0xB7, 0x11, 0x28, 0x70, 0x83, 0x54, 0xCD, 0x7B, + 0x14, 0x40, 0x97, 0x5A, 0x25, 0xD2, 0xFD, 0x31, + 0xF6, 0x47, 0x8D, 0x8C, 0xBE, 0xD6, 0x54, 0xA5 + }, + { + 0x0D, 0xD3, 0x8B, 0x3D, 0x68, 0x98, 0x06, 0x46, + 0x21, 0xC6, 0xCF, 0x18, 0x2C, 0x45, 0xCA, 0x9F, + 0x37, 0x62, 0x00, 0x80, 0x06, 0xA5, 0x0C, 0x31, + 0x39, 0xF5, 0x86, 0x95, 0xD1, 0xE8, 0x5F, 0x2E + }, + { + 0x49, 0xAD, 0xF4, 0x8F, 0xB4, 0x6E, 0x1A, 0x6E, + 0x0D, 0x4D, 0xCE, 0x74, 0xA1, 0x3E, 0xA3, 0x6A, + 0xF8, 0x75, 0x91, 0x04, 0x82, 0xE9, 0x03, 0x32, + 0x55, 0xCA, 0x6D, 0x3F, 0x49, 0x7A, 0xD5, 0xBA + }, + { + 0x76, 0x07, 0x90, 0x9B, 0x13, 0xB4, 0xE4, 0x6A, + 0x51, 0x5E, 0xA0, 0x4E, 0x6D, 0x83, 0x58, 0xB9, + 0x9D, 0x74, 0x62, 0xF4, 0xCC, 0x42, 0x3A, 0x00, + 0x10, 0x7F, 0x7F, 0x8E, 0x99, 0xB4, 0x54, 0xC2 + }, + { + 0xEC, 0x1B, 0x17, 0xB1, 0x5C, 0xEC, 0x82, 0x04, + 0x85, 0x77, 0x81, 0xD0, 0xD9, 0x8B, 0xAA, 0x04, + 0x46, 0xF8, 0x1F, 0x3C, 0x5F, 0x2D, 0xE3, 0x0F, + 0x6A, 0xD9, 0x78, 0xDA, 0x57, 0x2B, 0x55, 0x25 + }, + { + 0x76, 0xA8, 0xD5, 0xA6, 0xEE, 0xC6, 0x50, 0x7A, + 0x64, 0x80, 0xC5, 0x5A, 0x7D, 0xE4, 0xBF, 0x2C, + 0xEB, 0x02, 0x05, 0x6E, 0x99, 0x04, 0x0E, 0x19, + 0x71, 0x48, 0xAE, 0x70, 0x68, 0x6D, 0xCA, 0xD8 + }, + { + 0xBE, 0x1A, 0xBE, 0xFA, 0x77, 0xE3, 0xF6, 0x66, + 0xB2, 0xFC, 0x4C, 0x9A, 0x3D, 0x0A, 0xF6, 0x47, + 0x2B, 0x10, 0x64, 0xC4, 0xA9, 0xED, 0xB6, 0x93, + 0x49, 0x7B, 0xD4, 0x0F, 0x0C, 0x69, 0xE5, 0x5E + }, + { + 0x0D, 0xA4, 0x15, 0x24, 0x90, 0x5E, 0x1D, 0x39, + 0x36, 0xDE, 0xE4, 0x89, 0xE8, 0xF1, 0x7A, 0xFB, + 0x25, 0x49, 0xFB, 0x61, 0x5A, 0x97, 0x89, 0x3F, + 0x73, 0x70, 0xA0, 0xE3, 0xDD, 0x2B, 0xB1, 0x6E + }, + { + 0x90, 0x80, 0xE8, 0x00, 0x7C, 0x1F, 0xA9, 0x28, + 0xF2, 0x19, 0x83, 0xF4, 0x3E, 0x60, 0xCC, 0xCB, + 0x6B, 0xED, 0x67, 0xA1, 0x17, 0xA5, 0x12, 0xC1, + 0x1D, 0x93, 0x9A, 0xC1, 0x47, 0x85, 0xAE, 0xD8 + }, + { + 0xD7, 0xA0, 0x7A, 0x23, 0x3F, 0x1B, 0x4D, 0x23, + 0x16, 0x4C, 0xDA, 0x1A, 0x6B, 0x87, 0x80, 0xD5, + 0xD4, 0xF5, 0xF6, 0x92, 0xA3, 0x02, 0x84, 0xFD, + 0x8A, 0xE8, 0x28, 0xAE, 0xCD, 0x3A, 0xE9, 0x43 + }, + { + 0x4C, 0x46, 0xCB, 0xA4, 0xC4, 0x25, 0x2F, 0xCE, + 0x3B, 0xA4, 0xDD, 0xC3, 0x94, 0xB5, 0xB3, 0xAD, + 0x9B, 0xFF, 0x1A, 0x57, 0x6B, 0x96, 0x4C, 0x45, + 0x6E, 0xA6, 0x49, 0x1C, 0xE7, 0x4B, 0x5F, 0x4F + }, + { + 0xF4, 0x2B, 0x64, 0x88, 0x91, 0x4C, 0xC8, 0xED, + 0x2F, 0xC5, 0x86, 0x99, 0xC6, 0xC6, 0xBF, 0xC2, + 0xB3, 0xB2, 0xB6, 0xFA, 0x80, 0xE5, 0x3E, 0xE9, + 0x65, 0xEC, 0xF0, 0xED, 0x82, 0x92, 0x13, 0x52 + }, + { + 0xC1, 0x00, 0xA1, 0xF0, 0x8F, 0xD4, 0xD1, 0x01, + 0xB6, 0xFA, 0xD7, 0x1D, 0x57, 0x12, 0x44, 0x97, + 0x4D, 0x6C, 0x3B, 0xB2, 0x40, 0x33, 0x0D, 0x62, + 0x44, 0xD4, 0x7A, 0x5C, 0x69, 0x33, 0xE4, 0xEE + }, + { + 0xFF, 0x87, 0x7E, 0x6A, 0x8E, 0x0B, 0x8F, 0x32, + 0x23, 0x11, 0xD3, 0x1A, 0x1E, 0x66, 0x29, 0xD6, + 0xF2, 0xBF, 0xB0, 0x9A, 0x53, 0xEC, 0x89, 0x14, + 0xFA, 0x16, 0x5F, 0x96, 0xDB, 0x07, 0xDA, 0x77 + }, + { + 0x3F, 0x7B, 0x93, 0x66, 0xDF, 0x68, 0xC8, 0x4B, + 0x92, 0xE6, 0x94, 0x79, 0x17, 0xAE, 0x28, 0x9D, + 0x23, 0x19, 0x2B, 0xA6, 0xC5, 0x39, 0x36, 0x2F, + 0x18, 0x48, 0x62, 0x1B, 0xFD, 0xC6, 0x10, 0x16 + }, + { + 0x3E, 0xE2, 0xB9, 0x71, 0xC8, 0x38, 0xD4, 0xFE, + 0xA1, 0x55, 0xBF, 0xFD, 0x55, 0x79, 0x6C, 0xC0, + 0x34, 0x25, 0x80, 0x2C, 0x88, 0xE2, 0xA3, 0x5A, + 0x2D, 0x36, 0xDC, 0x19, 0xD8, 0xDD, 0xFC, 0x9F + }, + { + 0xBD, 0xC5, 0x6C, 0x1B, 0x72, 0x82, 0x71, 0x79, + 0x1C, 0xC6, 0x24, 0x40, 0x19, 0x90, 0x5E, 0x6F, + 0xB4, 0x9E, 0xA9, 0x04, 0xE8, 0xA9, 0xB3, 0x8B, + 0xE8, 0xF9, 0x2A, 0x93, 0x71, 0x74, 0xA1, 0xF7 + }, + { + 0x57, 0x94, 0xC3, 0xBA, 0x10, 0x9C, 0xE7, 0x23, + 0xFA, 0xF2, 0x6B, 0x81, 0xDA, 0xB1, 0x5E, 0xA6, + 0x50, 0x2B, 0x2C, 0x5D, 0x46, 0x15, 0x0C, 0xB2, + 0x1F, 0xD3, 0x7B, 0xA2, 0xFC, 0xD2, 0x13, 0xDF + }, + { + 0x87, 0xD5, 0x50, 0xAA, 0x89, 0x22, 0xF2, 0xDE, + 0x86, 0xCA, 0x42, 0x6A, 0x7F, 0x90, 0xFF, 0x92, + 0xCB, 0xCE, 0x9D, 0xC7, 0xC0, 0xDE, 0xE9, 0x72, + 0x71, 0xEF, 0xA5, 0x37, 0x63, 0xAA, 0x17, 0x1D + }, + { + 0x8C, 0xE0, 0x27, 0x92, 0xC8, 0xDC, 0xFD, 0x78, + 0x0E, 0xC0, 0xA1, 0x11, 0x80, 0xA7, 0x7D, 0x52, + 0x4F, 0x99, 0x26, 0x15, 0xBA, 0xBF, 0x7F, 0x11, + 0x77, 0xF5, 0xCF, 0x07, 0x77, 0xB6, 0x6E, 0x6A + }, + { + 0xA2, 0x8F, 0x7A, 0x23, 0x83, 0x18, 0x83, 0xBC, + 0xD0, 0xAC, 0x9F, 0x71, 0x55, 0x40, 0xB8, 0x52, + 0x18, 0x74, 0x9D, 0x55, 0x34, 0xE0, 0x5A, 0xAA, + 0xB6, 0x8C, 0x79, 0xB4, 0x1B, 0xF2, 0x8F, 0x26 + }, + { + 0xD6, 0xF6, 0x73, 0xE5, 0x44, 0xCA, 0xD5, 0x42, + 0x6D, 0x6C, 0xF5, 0x35, 0x5E, 0x47, 0xD5, 0x55, + 0xC7, 0xC2, 0x23, 0x8D, 0x03, 0xA1, 0x0C, 0xD2, + 0x09, 0x04, 0xD6, 0xED, 0xED, 0x90, 0xD3, 0xD8 + }, + { + 0xCE, 0x0B, 0x29, 0x08, 0x24, 0x1F, 0xE5, 0x2D, + 0x7D, 0xC0, 0xC0, 0xCF, 0xA2, 0xBD, 0xE0, 0x36, + 0x74, 0xEC, 0xA2, 0xFE, 0x4B, 0x97, 0xD8, 0xA6, + 0x97, 0x29, 0xC3, 0xD4, 0x55, 0x66, 0x08, 0xB0 + }, + { + 0x2D, 0x1C, 0x70, 0xB7, 0xF6, 0xA2, 0x6A, 0x82, + 0x17, 0xAC, 0xFE, 0x70, 0x9F, 0x42, 0xF4, 0x0A, + 0xAD, 0x4A, 0xF8, 0xEA, 0xDC, 0x5E, 0x17, 0x84, + 0x80, 0xD1, 0x23, 0xF1, 0x1C, 0x24, 0x40, 0xC5 + }, + { + 0x4D, 0xC6, 0x6C, 0x90, 0xD3, 0xEE, 0x80, 0xCF, + 0x43, 0xF7, 0x78, 0xB0, 0x59, 0x5D, 0x82, 0xBF, + 0x5E, 0x88, 0xD0, 0x22, 0xC5, 0xB9, 0x8A, 0x3B, + 0x50, 0x70, 0xCE, 0x12, 0x4C, 0x58, 0x9F, 0xCA + }, + { + 0x82, 0x5C, 0x80, 0x52, 0xF4, 0x76, 0xAC, 0x86, + 0xE9, 0xA4, 0xC3, 0xFB, 0xB3, 0xD7, 0xF6, 0x91, + 0x51, 0x7F, 0xCA, 0x0E, 0x47, 0x12, 0x73, 0x4E, + 0x93, 0xE6, 0x1D, 0x3C, 0x30, 0x0C, 0xA3, 0x2A + }, + { + 0x57, 0x6F, 0x4C, 0x1C, 0xF5, 0x7D, 0x3D, 0x40, + 0xC5, 0x99, 0x72, 0x6C, 0xD4, 0x9B, 0xEB, 0x18, + 0x25, 0x5E, 0xB2, 0x91, 0xFF, 0xE8, 0x09, 0x3F, + 0x0B, 0xFC, 0x21, 0xBC, 0xC0, 0x3E, 0x7B, 0x5A + }, + { + 0xEF, 0x8E, 0x4B, 0xD1, 0x28, 0x96, 0xDA, 0xD4, + 0x40, 0xDF, 0x1C, 0xF7, 0xD1, 0x21, 0xBC, 0x62, + 0x77, 0x82, 0x43, 0xB9, 0x10, 0xDD, 0x5B, 0xD7, + 0x42, 0x32, 0xB6, 0x2B, 0x36, 0x3F, 0x97, 0xEF + }, + { + 0x09, 0xA0, 0x3F, 0xE9, 0xD1, 0x08, 0x66, 0xBB, + 0xF0, 0xD2, 0x83, 0x92, 0x8F, 0x0F, 0x8E, 0x01, + 0xE3, 0x2F, 0xB5, 0xAD, 0x5F, 0x29, 0xB7, 0x03, + 0x4D, 0xAE, 0x97, 0x9E, 0xB9, 0xEC, 0x4D, 0x46 + }, + { + 0x28, 0x9C, 0x52, 0x80, 0x0B, 0x37, 0x3F, 0x14, + 0xCA, 0x76, 0x3F, 0xF1, 0x04, 0xBA, 0xE8, 0x94, + 0xC8, 0x93, 0x1A, 0xF6, 0x45, 0xC2, 0x46, 0x9B, + 0x70, 0x8C, 0xEC, 0x02, 0x56, 0xB5, 0x9B, 0x32 + }, + { + 0xCE, 0x99, 0xC9, 0xE1, 0x18, 0xC6, 0xA2, 0x09, + 0xE8, 0x6E, 0x3C, 0x73, 0x12, 0x00, 0x14, 0x7D, + 0x66, 0x3E, 0x0E, 0x99, 0xC5, 0xB1, 0x45, 0xD4, + 0x6D, 0xDF, 0xFC, 0x86, 0x9E, 0x4F, 0x1E, 0x77 + }, + { + 0x3C, 0xBE, 0x75, 0xC5, 0xB2, 0x02, 0x78, 0x94, + 0xE7, 0x40, 0x8E, 0x26, 0x35, 0x91, 0x2C, 0xF0, + 0xE1, 0xE0, 0xB0, 0x8C, 0x4D, 0xAB, 0x33, 0x96, + 0xFD, 0x27, 0x88, 0xE6, 0x4D, 0x14, 0x7E, 0x35 + }, + { + 0x56, 0x6A, 0x80, 0x0A, 0xC8, 0x88, 0xC0, 0x4F, + 0x41, 0xB7, 0xCA, 0x22, 0xA9, 0xDD, 0xE2, 0x69, + 0x81, 0x6F, 0xE5, 0x30, 0xE5, 0x1D, 0x10, 0x02, + 0x88, 0x5B, 0x17, 0xFE, 0xD3, 0x3E, 0x08, 0x26 + }, + { + 0x41, 0x62, 0xE9, 0x67, 0x10, 0x87, 0x31, 0xDE, + 0xBA, 0x2A, 0x08, 0x5D, 0x8F, 0xFC, 0x3E, 0x92, + 0x13, 0x52, 0xEF, 0xF8, 0x09, 0x46, 0x8F, 0x60, + 0x17, 0x9A, 0x84, 0x21, 0x28, 0x50, 0xF7, 0x48 + }, + { + 0xC5, 0x4F, 0x3A, 0x40, 0x94, 0x1A, 0x71, 0x13, + 0xF4, 0x59, 0x0B, 0xBC, 0x25, 0x85, 0x0C, 0x84, + 0x8D, 0xE7, 0x3C, 0x6B, 0x63, 0xC5, 0x7E, 0x7D, + 0x54, 0x1D, 0xB4, 0x81, 0x9A, 0x5A, 0x45, 0xCA + }, + { + 0xAB, 0xA0, 0x6B, 0x10, 0x04, 0x8E, 0x3D, 0x5C, + 0x08, 0x73, 0x30, 0xFE, 0x3F, 0x3F, 0xFE, 0x1F, + 0x5E, 0x1C, 0xD2, 0x26, 0x76, 0xF1, 0x3A, 0xCE, + 0x2E, 0x12, 0xBE, 0x40, 0x8A, 0x54, 0x47, 0x73 + }, + { + 0xAA, 0x4D, 0x27, 0x12, 0xD8, 0xF8, 0xAC, 0x10, + 0xD5, 0xD9, 0x9C, 0x98, 0x12, 0xA8, 0x06, 0x81, + 0x4D, 0x52, 0x1A, 0x97, 0xFD, 0x77, 0x7B, 0x5A, + 0x6C, 0xF0, 0x74, 0x9A, 0x12, 0x55, 0xAC, 0x8D + }, + { + 0x05, 0x24, 0x0F, 0xB5, 0x8C, 0xD8, 0x9F, 0x29, + 0x67, 0xEA, 0x0E, 0xD5, 0xEB, 0x8F, 0x63, 0xDD, + 0xE3, 0x83, 0xF0, 0x3B, 0x60, 0x2A, 0xF9, 0xE5, + 0x80, 0xAA, 0x84, 0xDF, 0x9D, 0x6C, 0xA3, 0xD3 + }, + { + 0x82, 0xFE, 0x85, 0x22, 0xE9, 0xDA, 0xCE, 0x50, + 0xEA, 0x99, 0xF9, 0x5B, 0x53, 0x59, 0x0C, 0xB7, + 0x88, 0x90, 0xB1, 0x68, 0x24, 0xB1, 0x57, 0x47, + 0xF3, 0x21, 0xAA, 0x01, 0xC2, 0x0A, 0xB1, 0x6F + }, + { + 0x1D, 0x73, 0xFC, 0xC5, 0xF0, 0x32, 0x99, 0xE4, + 0x34, 0xB3, 0x58, 0xEE, 0x65, 0xC1, 0x3F, 0xE1, + 0xFE, 0xBA, 0xC3, 0x01, 0x1F, 0x5D, 0x49, 0xDA, + 0x0C, 0xBD, 0x88, 0xD9, 0x24, 0x00, 0x06, 0xF4 + }, + { + 0xDC, 0x0D, 0x6A, 0x70, 0xC6, 0xAC, 0x3E, 0x15, + 0xEF, 0xA9, 0xBF, 0xFA, 0x7A, 0x82, 0x0B, 0xE7, + 0x25, 0x2B, 0x6C, 0xC4, 0x08, 0x37, 0x90, 0x37, + 0x13, 0x39, 0xCE, 0x0F, 0x66, 0xB9, 0x5D, 0x64 + }, + { + 0xC9, 0x46, 0x1E, 0x06, 0x38, 0xE5, 0x30, 0x65, + 0x17, 0xB8, 0xCB, 0xCA, 0x55, 0x8F, 0x05, 0xD4, + 0x06, 0x48, 0x78, 0x34, 0x54, 0x1A, 0x10, 0x8F, + 0xF4, 0x39, 0xE4, 0x15, 0x18, 0xC3, 0xF0, 0x58 + }, + { + 0xAF, 0x47, 0x62, 0xB9, 0xAC, 0x75, 0x11, 0x0E, + 0xE0, 0xD9, 0x3D, 0x2A, 0x0F, 0x85, 0x77, 0x9F, + 0x17, 0xD0, 0x2F, 0x74, 0x9E, 0xC4, 0x7A, 0xAE, + 0xEA, 0x52, 0xE6, 0xDE, 0xE5, 0x6B, 0x5F, 0x51 + }, + { + 0xF4, 0x8D, 0x22, 0x19, 0xF5, 0x72, 0x80, 0xEF, + 0x67, 0xD9, 0xB8, 0x4B, 0x78, 0x4C, 0xC3, 0xFE, + 0x7D, 0x6D, 0x66, 0x37, 0xE8, 0xC6, 0xEA, 0xA9, + 0x94, 0xB5, 0x4D, 0xFF, 0x2B, 0x28, 0x6C, 0x37 + }, + { + 0x58, 0xEB, 0x82, 0xC8, 0x13, 0x3D, 0x3D, 0x27, + 0x82, 0xFC, 0x4B, 0x05, 0x0B, 0xDF, 0x44, 0x64, + 0xAD, 0x91, 0x91, 0x84, 0x7F, 0x14, 0x65, 0x74, + 0x55, 0x13, 0x28, 0x66, 0x0A, 0x11, 0x98, 0x08 + }, + { + 0x8A, 0x6C, 0x50, 0x03, 0x54, 0x6F, 0xF2, 0xB0, + 0x43, 0x18, 0x93, 0xA0, 0x31, 0x69, 0xC8, 0xD3, + 0x4D, 0x6A, 0x2D, 0x22, 0x89, 0x42, 0x30, 0x19, + 0x7F, 0x87, 0x87, 0x22, 0x9A, 0x38, 0x60, 0xA2 + }, + { + 0xEF, 0x9E, 0x5F, 0x2D, 0x6C, 0x89, 0x1B, 0x91, + 0xDD, 0x78, 0x47, 0xEE, 0xF1, 0xEE, 0x69, 0xA1, + 0x8F, 0x4B, 0xE5, 0x2B, 0xC6, 0x2A, 0x47, 0xE8, + 0xBB, 0x1B, 0xF6, 0xA7, 0x69, 0xD2, 0x02, 0xB9 + }, + { + 0x64, 0x2A, 0x9E, 0x63, 0x6C, 0x5D, 0xCB, 0xFE, + 0xA6, 0x1B, 0x4C, 0x27, 0x5A, 0x51, 0xA2, 0x94, + 0x95, 0x6B, 0x48, 0x93, 0x3A, 0xAA, 0x12, 0xB4, + 0x55, 0x54, 0xFE, 0x2A, 0x61, 0x2D, 0xEA, 0x08 + }, + { + 0x78, 0x08, 0x58, 0x5D, 0x99, 0x4B, 0x7A, 0x83, + 0x7E, 0x95, 0x04, 0xB6, 0x27, 0xD3, 0x1A, 0xF1, + 0xA3, 0xB4, 0xF2, 0xFA, 0xD7, 0x69, 0xD6, 0xD6, + 0xED, 0x49, 0xF0, 0xAB, 0x77, 0x37, 0xEF, 0xF9 + }, + { + 0x68, 0x88, 0x9B, 0x97, 0x3C, 0x0B, 0xA6, 0xB7, + 0xAD, 0xFA, 0x57, 0x7D, 0xE7, 0x4D, 0x98, 0x7E, + 0x69, 0xC0, 0x40, 0x60, 0xCD, 0x42, 0x9D, 0x53, + 0xDA, 0xB7, 0x89, 0xAE, 0xFC, 0x33, 0xC8, 0xD5 + }, + { + 0x66, 0xE0, 0x1F, 0x42, 0xF4, 0xDE, 0x75, 0x1E, + 0x2B, 0xD4, 0xAE, 0x6D, 0xDD, 0xCF, 0xCD, 0x21, + 0x84, 0x1C, 0x91, 0x1A, 0x07, 0xEB, 0xAC, 0x68, + 0x5D, 0x13, 0x7C, 0xF4, 0xD2, 0x2B, 0xB6, 0xE8 + }, + { + 0xF6, 0x14, 0xCA, 0xD4, 0x78, 0x85, 0x34, 0xA3, + 0xDF, 0x49, 0xA9, 0x0E, 0x84, 0xA6, 0x1D, 0x54, + 0xD3, 0xB1, 0x18, 0xA3, 0x17, 0x94, 0x1F, 0x03, + 0xA9, 0xF5, 0xD6, 0x53, 0x9E, 0x52, 0x64, 0x4E + }, + { + 0xE7, 0x38, 0x1A, 0xDE, 0x51, 0xA1, 0xF3, 0x5F, + 0x5F, 0x0D, 0xC9, 0x7F, 0x1A, 0x25, 0xCE, 0x10, + 0x96, 0x7B, 0x5C, 0x47, 0x89, 0x88, 0x10, 0x6C, + 0x17, 0xE4, 0xCC, 0x26, 0xE4, 0x0A, 0x37, 0x1F + }, + { + 0x92, 0xCE, 0xFB, 0xC5, 0xF5, 0xFC, 0x8D, 0xE1, + 0x19, 0x47, 0x32, 0x75, 0x56, 0x90, 0x0E, 0xA4, + 0x9C, 0x8A, 0x1F, 0x1D, 0x22, 0xF6, 0xA5, 0x2F, + 0xE6, 0x6B, 0xE8, 0xB9, 0x80, 0x9E, 0xB4, 0xBB + }, + { + 0xA1, 0x22, 0xE5, 0x42, 0xC3, 0xCF, 0x07, 0x3B, + 0x90, 0x5B, 0x83, 0x64, 0x90, 0xED, 0x99, 0xAC, + 0x42, 0x1C, 0x12, 0x2D, 0xA4, 0x59, 0x62, 0x92, + 0xE1, 0x46, 0x27, 0xFE, 0x38, 0x73, 0xC6, 0x5C + }, + { + 0xE5, 0xAD, 0x1F, 0x93, 0x68, 0x97, 0xA4, 0x90, + 0xDF, 0x5B, 0xD9, 0x65, 0xCA, 0x06, 0xFF, 0x1F, + 0xD6, 0xE8, 0x92, 0xF6, 0xC4, 0xC3, 0x85, 0xDF, + 0xDF, 0x79, 0x12, 0x8B, 0x80, 0x1D, 0x03, 0x8A + }, + { + 0x38, 0x76, 0x67, 0x74, 0x61, 0x0E, 0x12, 0x96, + 0x14, 0x40, 0x25, 0xF8, 0x49, 0x68, 0x19, 0xC2, + 0xA8, 0xB4, 0xE3, 0x8D, 0x02, 0xC9, 0xDD, 0x36, + 0x8B, 0x36, 0x78, 0xBD, 0x86, 0xCC, 0xA5, 0x7D + }, + { + 0x32, 0x65, 0x02, 0xB9, 0xDD, 0xD4, 0x69, 0x3C, + 0x15, 0x94, 0x35, 0xD1, 0xFD, 0x08, 0xBB, 0x7A, + 0x52, 0xE9, 0x9A, 0x13, 0x32, 0xCF, 0xC6, 0x00, + 0xC3, 0x66, 0x67, 0xA5, 0x34, 0x01, 0xC7, 0x8E + }, + { + 0xEB, 0xC8, 0x92, 0x9B, 0x7A, 0x50, 0x76, 0x17, + 0x2D, 0x3D, 0x95, 0xFE, 0x04, 0x04, 0x79, 0x53, + 0x2D, 0xEE, 0xF9, 0x23, 0x6F, 0xBF, 0x08, 0x78, + 0x1E, 0xB2, 0x6B, 0x04, 0x07, 0xB9, 0xE8, 0x8B + }, + { + 0x3F, 0xEE, 0x4F, 0x94, 0x4F, 0x24, 0x7E, 0x1B, + 0xC0, 0x56, 0x0B, 0xF5, 0xFE, 0xBC, 0x04, 0x4D, + 0x57, 0x39, 0x17, 0x35, 0x0A, 0x87, 0xE1, 0x2B, + 0x12, 0xDE, 0x31, 0x5B, 0x8E, 0x50, 0x12, 0x38 + }, + { + 0x84, 0x6B, 0x47, 0x64, 0xDE, 0xE4, 0xCA, 0x0B, + 0x1E, 0x70, 0xC1, 0xFA, 0x66, 0x6D, 0x6F, 0xE5, + 0x10, 0x5C, 0x82, 0x1A, 0xE3, 0x2D, 0x65, 0x0D, + 0x15, 0x78, 0x25, 0x76, 0xEE, 0xAB, 0xF2, 0xB5 + }, + { + 0xC8, 0x79, 0xA0, 0xB7, 0xA4, 0xFD, 0x6B, 0x47, + 0xB1, 0xF5, 0x18, 0x54, 0xE1, 0xB1, 0xE5, 0xEA, + 0x24, 0xF0, 0xB4, 0xC7, 0x15, 0x4D, 0xF0, 0x8F, + 0xBE, 0xD6, 0xC2, 0x4A, 0x93, 0xDA, 0xD7, 0xFB + }, + { + 0xD3, 0x7D, 0x9F, 0x43, 0x28, 0xED, 0x36, 0x27, + 0x85, 0x60, 0x69, 0x5A, 0x27, 0x94, 0xF3, 0xE9, + 0x12, 0x73, 0xA5, 0x40, 0xC6, 0x84, 0xDA, 0xC5, + 0xD2, 0x54, 0x85, 0xF0, 0x6C, 0x6F, 0x9F, 0xF1 + }, + { + 0xB4, 0x11, 0x9F, 0xED, 0xE8, 0xB4, 0xCA, 0xD6, + 0x3C, 0x6E, 0x5C, 0x21, 0x14, 0x99, 0xAC, 0x81, + 0xA6, 0x71, 0x9A, 0x03, 0xF7, 0xF0, 0x8C, 0xFA, + 0x7D, 0x9E, 0xDB, 0x55, 0x05, 0xBA, 0xE9, 0x44 + }, + { + 0x25, 0xBA, 0xFC, 0xE3, 0xBE, 0xFD, 0xEA, 0xF1, + 0x31, 0xF6, 0x1D, 0x68, 0x15, 0x83, 0x7B, 0xE5, + 0x7E, 0x7F, 0xDF, 0xF7, 0xFA, 0xF4, 0xC4, 0x93, + 0x96, 0xDF, 0x6F, 0x06, 0xA1, 0x4A, 0xEC, 0x73 + }, + { + 0x1D, 0x41, 0x65, 0xB2, 0x67, 0x47, 0x3F, 0xB9, + 0x05, 0x90, 0xFB, 0x9C, 0x4B, 0xE9, 0x3E, 0xBD, + 0x3D, 0x8C, 0xEE, 0x01, 0xEF, 0x32, 0x04, 0x82, + 0x1D, 0xDD, 0xDC, 0x41, 0xCF, 0x3E, 0x7A, 0x62 + }, + { + 0xF3, 0xFA, 0x80, 0x49, 0xC9, 0x5E, 0x71, 0x20, + 0xD4, 0xF8, 0xDD, 0x07, 0xF7, 0x65, 0xC0, 0x71, + 0xD2, 0x7B, 0xB2, 0x9E, 0x1B, 0x69, 0x4C, 0x12, + 0xBD, 0x73, 0xBF, 0x13, 0x53, 0xE3, 0xC6, 0x2B + }, + { + 0x89, 0x43, 0xC8, 0x33, 0x21, 0xA5, 0xBA, 0xE7, + 0x8D, 0x5E, 0x3D, 0x1B, 0x97, 0x0E, 0x7A, 0x81, + 0xE9, 0x53, 0xC0, 0x7E, 0xF9, 0x1E, 0xAF, 0x32, + 0x9A, 0x92, 0x06, 0x31, 0x48, 0xCA, 0xC1, 0x15 + }, + { + 0x3F, 0x7E, 0x3C, 0x99, 0x35, 0xF3, 0x89, 0x90, + 0x32, 0xB4, 0x1C, 0x98, 0x1A, 0xCC, 0x0F, 0x43, + 0x6B, 0xC6, 0x3A, 0x5A, 0xB8, 0xEB, 0x43, 0x5B, + 0x17, 0x29, 0x64, 0x4E, 0xFF, 0xA4, 0xC2, 0x34 + }, + { + 0x08, 0xF4, 0x4A, 0x1B, 0xF1, 0x81, 0x51, 0x78, + 0xEC, 0x2D, 0x87, 0x03, 0x16, 0x19, 0x5D, 0x4C, + 0xC0, 0x4D, 0x50, 0x45, 0x22, 0x5A, 0x86, 0xA0, + 0x23, 0xFB, 0x37, 0x7E, 0x6B, 0x72, 0x31, 0x0A + }, + { + 0x4F, 0xB1, 0x80, 0x5F, 0x21, 0x21, 0xD4, 0xBA, + 0x8C, 0x82, 0x95, 0xFF, 0xE2, 0xF3, 0x24, 0xBC, + 0x51, 0x9E, 0xCB, 0xC4, 0x7E, 0x6F, 0xF8, 0xD1, + 0xC4, 0xDB, 0x85, 0x02, 0xE1, 0x46, 0x78, 0x9A + }, + { + 0xD8, 0xE7, 0xFA, 0xEB, 0x50, 0x6A, 0x81, 0x0A, + 0xB4, 0x17, 0xE2, 0x3C, 0x7C, 0xDD, 0x85, 0x73, + 0xDD, 0x94, 0x70, 0x7C, 0x6C, 0x82, 0x5D, 0x2D, + 0x0C, 0xA6, 0xD8, 0x31, 0xF4, 0x0C, 0xE0, 0x2D + }, + { + 0x74, 0xA9, 0x1F, 0xD6, 0xC5, 0xE7, 0xB0, 0x50, + 0x30, 0x71, 0x77, 0x85, 0xB4, 0xD4, 0x82, 0x6E, + 0x02, 0xB7, 0x90, 0x1F, 0xAF, 0xF6, 0x35, 0xD3, + 0xC1, 0xA3, 0x90, 0x79, 0xB7, 0xA3, 0x23, 0x04 + }, + { + 0x3E, 0xA2, 0x93, 0xD4, 0xDB, 0xDE, 0x92, 0x80, + 0x46, 0x50, 0x6D, 0x06, 0x6F, 0x5B, 0xFA, 0x76, + 0xA5, 0xF3, 0x81, 0xB3, 0xA4, 0x4F, 0xC7, 0x97, + 0xCA, 0xD1, 0xC0, 0x35, 0xDD, 0x7C, 0x31, 0xFC + }, + { + 0x7A, 0xFF, 0x6D, 0x37, 0xEC, 0xF0, 0xE1, 0xC7, + 0xE3, 0x81, 0x7A, 0x7C, 0xD7, 0x2E, 0x0A, 0x8C, + 0x8B, 0x93, 0x1F, 0x2D, 0x5C, 0xDE, 0x1A, 0x88, + 0x3C, 0x73, 0xF9, 0x7C, 0xF5, 0x2E, 0x5F, 0x35 + }, + { + 0xFE, 0x77, 0x46, 0x9F, 0x78, 0x5C, 0x94, 0xB2, + 0x7B, 0x4C, 0xEA, 0xCF, 0xD5, 0x12, 0x4B, 0xD7, + 0x63, 0x55, 0x4A, 0xFD, 0x92, 0x71, 0x56, 0xC9, + 0xC1, 0x89, 0x05, 0x3D, 0xB5, 0xE3, 0x06, 0x94 + }, + { + 0xF0, 0xA6, 0x2E, 0xED, 0x4B, 0xA7, 0x54, 0x6C, + 0xF9, 0x9B, 0xE6, 0xB6, 0xF6, 0x0A, 0x9D, 0x0A, + 0x63, 0x15, 0x0F, 0xF7, 0xD9, 0xE0, 0x24, 0xF3, + 0x72, 0x9F, 0x8B, 0x40, 0xEE, 0x35, 0xB6, 0xE8 + }, + { + 0x53, 0x05, 0xA8, 0xFF, 0x6C, 0x6B, 0x29, 0x5D, + 0xE5, 0x13, 0x17, 0xA1, 0xCC, 0xF0, 0xA3, 0x88, + 0x59, 0x01, 0xAD, 0x94, 0x2F, 0x4D, 0x98, 0x7B, + 0x1B, 0x23, 0x03, 0x74, 0x0F, 0x2D, 0x51, 0xD5 + }, + { + 0x15, 0x16, 0xD6, 0x21, 0x4A, 0x33, 0x44, 0x0C, + 0x42, 0x67, 0x72, 0x09, 0xEC, 0xF1, 0x8A, 0xC5, + 0x8A, 0xD1, 0x3A, 0xE4, 0xEC, 0x69, 0x2B, 0xA9, + 0x80, 0x69, 0xCB, 0x1F, 0x3C, 0x94, 0x36, 0xEB + }, + { + 0x43, 0x9D, 0x28, 0x48, 0x06, 0xA1, 0x64, 0x55, + 0x86, 0x4F, 0xFD, 0xAE, 0x56, 0x90, 0x42, 0x4F, + 0x7C, 0xC2, 0x33, 0xE2, 0x93, 0x98, 0xEF, 0x80, + 0x89, 0x2B, 0x11, 0x28, 0xF6, 0x15, 0x28, 0xF3 + }, + { + 0xF6, 0x50, 0x10, 0xCB, 0xBF, 0xAC, 0xAC, 0x86, + 0xD4, 0x99, 0xDD, 0xC8, 0x45, 0xB5, 0x90, 0x66, + 0xA6, 0x95, 0x32, 0x49, 0xAB, 0xF4, 0xB0, 0xA2, + 0x3D, 0xAA, 0x0A, 0x9D, 0xC1, 0x16, 0x41, 0xED + }, + { + 0xD6, 0xC7, 0xD1, 0x7C, 0x2F, 0x3C, 0x63, 0x3B, + 0x72, 0x51, 0xE4, 0xCE, 0xF2, 0x68, 0x82, 0x7E, + 0xEB, 0xD5, 0xFF, 0xFE, 0x83, 0xCA, 0x0E, 0xB6, + 0xF7, 0x5F, 0xBF, 0x26, 0xD3, 0x3E, 0x7C, 0x23 + }, + { + 0xF7, 0xED, 0x5D, 0x88, 0x81, 0xBA, 0x7F, 0xD4, + 0x42, 0x08, 0x19, 0x8A, 0x62, 0xBB, 0x5B, 0x2F, + 0x67, 0xCE, 0x95, 0xB8, 0x0D, 0x44, 0x4F, 0x56, + 0xA3, 0xA4, 0xEC, 0xCB, 0x84, 0x0A, 0x8A, 0xC4 + }, + { + 0xDA, 0x63, 0xCB, 0xB0, 0x28, 0x33, 0x97, 0xFB, + 0xFF, 0x3F, 0xFC, 0xA4, 0xA3, 0xD8, 0xE2, 0xAC, + 0x9A, 0xF0, 0x0B, 0x65, 0x09, 0xFA, 0xD4, 0x40, + 0x8D, 0x0E, 0x9F, 0xBC, 0x0F, 0x90, 0xCF, 0xBF + }, + { + 0xF3, 0x2C, 0x86, 0x25, 0xA5, 0x6D, 0xC9, 0xD1, + 0x6F, 0xB3, 0x71, 0xA0, 0xC1, 0x95, 0x8E, 0xFA, + 0x3D, 0xC0, 0xEA, 0x0F, 0x21, 0x7C, 0x4B, 0x02, + 0xF8, 0xE4, 0x78, 0x6C, 0x7F, 0x85, 0x37, 0xC2 + }, + { + 0x5E, 0xE2, 0x83, 0x39, 0x43, 0x1B, 0xD1, 0x90, + 0x16, 0x06, 0xD7, 0xA1, 0xF8, 0x33, 0x55, 0x2A, + 0x82, 0xB9, 0x0D, 0x64, 0x43, 0x43, 0x81, 0x04, + 0xA7, 0x18, 0x86, 0x2B, 0x5E, 0x7A, 0xE6, 0x4D + }, + { + 0xDE, 0x9F, 0x4D, 0xDB, 0x4A, 0x04, 0x0D, 0xBD, + 0xF0, 0x77, 0x15, 0xE0, 0x84, 0x33, 0xA5, 0xBF, + 0xD9, 0x0C, 0x82, 0x73, 0x8A, 0x23, 0xF8, 0x8E, + 0x07, 0xA6, 0x04, 0x3A, 0xFA, 0xF7, 0x55, 0x6B + }, + { + 0x32, 0x62, 0x4A, 0xFF, 0xCD, 0x03, 0xAB, 0xAF, + 0xFF, 0xF3, 0xCF, 0x7D, 0xA6, 0x6F, 0x2F, 0xB2, + 0x7F, 0x14, 0x61, 0xD7, 0x43, 0x92, 0xBE, 0xA3, + 0x2D, 0x80, 0x57, 0x80, 0xEA, 0x7A, 0x00, 0x89 + }, + { + 0x6E, 0x75, 0x3D, 0x88, 0x86, 0xA2, 0xAE, 0xD7, + 0xC3, 0x88, 0x3A, 0xCE, 0x61, 0xD1, 0xE4, 0xA3, + 0x03, 0xB8, 0x3E, 0xD1, 0x32, 0x11, 0x80, 0x1A, + 0x99, 0x74, 0xA1, 0x2F, 0x55, 0xDD, 0x99, 0x40 + }, + { + 0x25, 0xC8, 0xB3, 0xAA, 0x8E, 0xDD, 0x0E, 0x6F, + 0x18, 0x23, 0x58, 0x43, 0x9F, 0xD0, 0x5D, 0x31, + 0xD2, 0xD8, 0xDE, 0xDC, 0x37, 0xAA, 0x2B, 0x57, + 0xF9, 0x01, 0x22, 0x10, 0x91, 0xF5, 0xBF, 0xB6 + }, + { + 0x72, 0x68, 0x4B, 0xA8, 0xB0, 0x63, 0x79, 0x93, + 0x04, 0xD2, 0xF4, 0x2A, 0x9C, 0x29, 0x2B, 0xEE, + 0xFD, 0xBD, 0xD1, 0x50, 0x32, 0x76, 0x3D, 0x17, + 0xA9, 0x22, 0xD4, 0x40, 0xEA, 0xD4, 0xB5, 0x59 + }, + { + 0x29, 0x49, 0xE6, 0x69, 0x61, 0xBA, 0xF4, 0x48, + 0x0A, 0xA9, 0xF6, 0x59, 0xEA, 0xEE, 0x09, 0x96, + 0x1E, 0x98, 0x0D, 0xF2, 0x36, 0xF6, 0x99, 0x92, + 0xAD, 0xC7, 0xD9, 0x68, 0x1F, 0xB0, 0xDF, 0x80 + }, + { + 0x49, 0x36, 0xE6, 0x90, 0x4D, 0x9C, 0xD8, 0xF1, + 0x4D, 0xB8, 0xD7, 0x9B, 0xDB, 0x65, 0x22, 0x1A, + 0x5D, 0xD6, 0x47, 0x7D, 0xEF, 0xFD, 0xFF, 0xB0, + 0x82, 0x48, 0x15, 0xDD, 0xF8, 0xFB, 0x0B, 0x52 + }, + { + 0xF0, 0xDD, 0xF1, 0xB1, 0x91, 0x93, 0xD3, 0x28, + 0xB3, 0xF9, 0x0C, 0xF3, 0xEA, 0xA5, 0x4C, 0xD5, + 0x8E, 0x58, 0x37, 0x2D, 0x4F, 0x7D, 0x6B, 0x3A, + 0x8D, 0x51, 0x73, 0xC1, 0xFF, 0xA6, 0xBE, 0x3B + }, + { + 0x4C, 0x2A, 0xB9, 0x2D, 0x7A, 0x51, 0x6F, 0xE7, + 0x98, 0x1D, 0x28, 0xA0, 0x84, 0xDA, 0xB7, 0xF6, + 0x96, 0x71, 0xF6, 0x63, 0xB7, 0x97, 0x99, 0xAC, + 0x0E, 0x1E, 0xAD, 0x08, 0x2F, 0x50, 0xF0, 0x18 + }, + { + 0xF5, 0x7E, 0x02, 0x7E, 0xB0, 0x5F, 0xB6, 0xF4, + 0x86, 0xB5, 0xF3, 0x1B, 0xE8, 0xF4, 0x85, 0xF1, + 0x1B, 0xB8, 0x02, 0x5B, 0xA6, 0xFA, 0x51, 0x3B, + 0xA5, 0x06, 0x99, 0x5D, 0x9B, 0x57, 0x27, 0x57 + }, + { + 0xE0, 0x56, 0x99, 0x5A, 0x04, 0x4A, 0x4A, 0x4E, + 0x86, 0x2D, 0x61, 0x95, 0x81, 0x9F, 0x1F, 0xBD, + 0xF6, 0x4E, 0xE8, 0x98, 0x70, 0xE7, 0x3A, 0xBD, + 0x7E, 0xD6, 0x79, 0x92, 0x4B, 0xA5, 0x00, 0x5C + }, + { + 0x3C, 0x0F, 0x42, 0x90, 0x4B, 0x4D, 0xC3, 0xA9, + 0x04, 0x5F, 0x3C, 0xF9, 0x21, 0x79, 0xCE, 0x35, + 0xD2, 0x04, 0x93, 0x0D, 0x7C, 0x83, 0x34, 0x09, + 0x0A, 0xAE, 0xEE, 0x8A, 0x52, 0xBA, 0x9F, 0x60 + }, + { + 0xF0, 0x95, 0x36, 0x5C, 0xC6, 0x27, 0xF7, 0x0E, + 0xD0, 0x5A, 0x27, 0x8E, 0xC3, 0xBC, 0xF7, 0xCB, + 0xF3, 0x5E, 0xBC, 0x0B, 0xDD, 0xAD, 0x7D, 0x95, + 0x88, 0x10, 0x82, 0x4B, 0x46, 0x17, 0x95, 0xDC + }, + { + 0xF5, 0xD8, 0x21, 0x47, 0x71, 0x86, 0xF1, 0x4B, + 0x71, 0xE3, 0x4B, 0x77, 0x01, 0xEC, 0xBC, 0x2E, + 0x35, 0xCF, 0x8D, 0x05, 0x9D, 0xF7, 0x85, 0x0F, + 0x5F, 0xE9, 0x00, 0x04, 0x04, 0x76, 0xBD, 0xD9 + }, + { + 0x9A, 0x54, 0x27, 0x50, 0x6C, 0xB6, 0x12, 0x3F, + 0x8A, 0x95, 0x05, 0xA3, 0xC1, 0x7E, 0xD3, 0xF1, + 0x52, 0x2D, 0x7D, 0x60, 0x01, 0x21, 0xF0, 0x1A, + 0xC4, 0x29, 0x57, 0x54, 0xEF, 0x04, 0x67, 0xB4 + }, + { + 0xDE, 0x48, 0xD6, 0xEF, 0x5E, 0x59, 0x4B, 0xE5, + 0x0D, 0x26, 0x2C, 0x9C, 0x7C, 0xF4, 0xA6, 0x30, + 0x9A, 0xE2, 0x4D, 0xF7, 0x66, 0x34, 0xAD, 0xD5, + 0x9C, 0xE7, 0x17, 0x18, 0x2F, 0x46, 0xDE, 0x48 + }, + { + 0x7A, 0x9E, 0x30, 0xEC, 0x19, 0xD0, 0xF8, 0xB0, + 0x3B, 0xF0, 0x1A, 0x69, 0xE7, 0x20, 0x45, 0xC3, + 0x7F, 0xD5, 0xDC, 0x95, 0x7A, 0x08, 0xAE, 0x68, + 0xFC, 0x61, 0xFF, 0x6A, 0xAD, 0xA6, 0x74, 0x66 + }, + { + 0x07, 0xE2, 0xB8, 0xC8, 0xBA, 0x5E, 0x0A, 0xED, + 0x81, 0x13, 0xBC, 0xF4, 0x94, 0x67, 0x41, 0x1E, + 0x63, 0x37, 0xF3, 0x4B, 0x44, 0x73, 0xCC, 0xCE, + 0x4C, 0xE5, 0x09, 0x30, 0x1B, 0xE3, 0x7F, 0xF0 + }, + { + 0x94, 0xCE, 0xCD, 0x81, 0xAB, 0x00, 0x9C, 0x42, + 0x96, 0xF0, 0xA0, 0xE1, 0x32, 0x9C, 0xD8, 0xD3, + 0x26, 0xBB, 0x14, 0x3C, 0xC3, 0xC6, 0x49, 0xE1, + 0xDC, 0x09, 0x7D, 0xA6, 0x1D, 0x79, 0xAE, 0xB9 + }, + { + 0x57, 0xC5, 0x3E, 0xB7, 0xB8, 0xC3, 0xEB, 0xE3, + 0xCC, 0xA2, 0x65, 0xC8, 0x27, 0x10, 0x44, 0xA7, + 0x65, 0x59, 0x83, 0xAF, 0x05, 0xFC, 0xFF, 0x7F, + 0x81, 0x1B, 0x26, 0x20, 0x04, 0x6C, 0x4C, 0x87 + }, + { + 0x6E, 0x98, 0x88, 0xC5, 0x83, 0x16, 0xA2, 0xE8, + 0xAF, 0xC4, 0x00, 0x8A, 0x54, 0x07, 0x0E, 0x31, + 0xBA, 0x96, 0x6E, 0xDA, 0xAE, 0x5C, 0xB6, 0xE4, + 0x76, 0xE9, 0xC5, 0xFD, 0x35, 0x9C, 0x7D, 0xFE + }, + { + 0x55, 0x65, 0xF6, 0x25, 0x07, 0x4B, 0x5C, 0x3F, + 0xBB, 0x34, 0xD0, 0x4B, 0x5E, 0x0C, 0x8C, 0x70, + 0x36, 0xE7, 0x3D, 0x05, 0xC7, 0xFC, 0x73, 0xB5, + 0x87, 0x47, 0xAD, 0x95, 0xD0, 0x36, 0x39, 0x20 + }, + { + 0xB5, 0xD0, 0xC3, 0x8A, 0xCC, 0x7B, 0x3F, 0xFD, + 0x6B, 0xE9, 0x2D, 0x67, 0xD0, 0x4A, 0x2E, 0x9A, + 0xB4, 0x17, 0x9D, 0x27, 0x2E, 0x26, 0xB8, 0x97, + 0x49, 0x29, 0x03, 0x73, 0xF2, 0x8A, 0xFE, 0xA7 + }, + { + 0xF4, 0x68, 0x07, 0x04, 0x7F, 0x92, 0xB9, 0xCD, + 0x46, 0xDE, 0x80, 0xA1, 0x08, 0x70, 0x10, 0x8C, + 0x69, 0x53, 0xFC, 0xE1, 0xC5, 0xA7, 0x63, 0xCA, + 0x94, 0xB1, 0xAD, 0x58, 0xF7, 0x8D, 0xA4, 0x43 + }, + { + 0x58, 0xC7, 0xAD, 0x11, 0xE9, 0x47, 0x61, 0x6E, + 0x02, 0xC4, 0x1C, 0xEE, 0x71, 0x15, 0xC9, 0xAF, + 0x9A, 0x1B, 0x3E, 0xB4, 0xB9, 0x24, 0xCE, 0x0A, + 0x38, 0xBD, 0x15, 0x8D, 0x1E, 0x5F, 0x4D, 0xB0 + }, + { + 0xA9, 0x37, 0x6A, 0xFE, 0xEC, 0xC2, 0x74, 0x68, + 0x7D, 0x0E, 0xB8, 0xC9, 0xC0, 0x06, 0x1C, 0x18, + 0xFB, 0x4A, 0x27, 0xF1, 0x34, 0x81, 0x89, 0x40, + 0x67, 0x96, 0xAD, 0xE7, 0x9D, 0xDE, 0xD6, 0x0F + }, + { + 0x87, 0x1C, 0xAF, 0xD2, 0x73, 0x48, 0xB3, 0xC1, + 0xD0, 0x29, 0x88, 0x10, 0x86, 0x49, 0x62, 0x23, + 0x50, 0x9C, 0x2F, 0x1F, 0xDA, 0xC4, 0xCF, 0x7A, + 0xE9, 0xBE, 0x65, 0x54, 0x32, 0x28, 0xD3, 0xB8 + }, + { + 0x07, 0x65, 0x0D, 0x8B, 0x8A, 0xD5, 0xC2, 0x3F, + 0xE8, 0xDC, 0xDD, 0x65, 0x56, 0xE6, 0x15, 0x1C, + 0xD0, 0x20, 0x40, 0xE9, 0xE3, 0xA2, 0x9A, 0xAC, + 0x8D, 0x2C, 0x9F, 0xDC, 0xAC, 0x4D, 0x19, 0xEC + }, + { + 0xA1, 0xE3, 0x8C, 0xD6, 0x70, 0xC1, 0x6A, 0xF2, + 0xA3, 0x29, 0x7B, 0x71, 0x09, 0xD3, 0x6F, 0x56, + 0x9D, 0xCA, 0x80, 0xFE, 0xEF, 0x3C, 0x90, 0xC4, + 0x54, 0x57, 0x66, 0x93, 0x81, 0x03, 0x9E, 0x1E + }, + { + 0x5C, 0x94, 0xE4, 0x9D, 0x33, 0x3F, 0xBF, 0x6A, + 0xA1, 0x24, 0x06, 0x17, 0xCA, 0x0B, 0xDC, 0x83, + 0x12, 0x0C, 0x52, 0x8B, 0x52, 0x3C, 0x60, 0x64, + 0x4D, 0xFA, 0x23, 0x7C, 0x22, 0x05, 0xC7, 0x01 + }, + { + 0x3D, 0x4B, 0x56, 0x28, 0xCC, 0x6A, 0xF0, 0xB5, + 0xCF, 0x00, 0x55, 0xC9, 0x93, 0x03, 0xA8, 0x27, + 0x39, 0xF7, 0x72, 0x50, 0xC0, 0x6F, 0xFD, 0x7F, + 0xE2, 0xE4, 0x01, 0x98, 0x5F, 0xDE, 0x16, 0x22 + }, + { + 0x81, 0xC5, 0x20, 0x09, 0x8F, 0x98, 0x33, 0x66, + 0x42, 0xFD, 0xEC, 0xD6, 0xE8, 0xCA, 0x7A, 0x15, + 0x5B, 0x40, 0xA3, 0xE0, 0xFF, 0x8C, 0xDA, 0x78, + 0xEE, 0x8A, 0x74, 0xAD, 0xC5, 0xD6, 0x11, 0x5B + }, + { + 0xBF, 0x30, 0x97, 0xE8, 0x1B, 0xF4, 0x69, 0x5F, + 0x7C, 0x17, 0x74, 0xDD, 0xC5, 0x5F, 0x6E, 0x18, + 0xFF, 0xE1, 0x1B, 0x18, 0x79, 0xAB, 0x94, 0x8C, + 0x40, 0x9E, 0xCF, 0x8A, 0xB1, 0x8D, 0xC5, 0x9C + }, + { + 0xAA, 0xED, 0xF8, 0x23, 0x6C, 0x62, 0xA6, 0x24, + 0x54, 0x7D, 0x2F, 0xDF, 0x4D, 0x3D, 0xC0, 0x5B, + 0x2D, 0x68, 0xD9, 0x50, 0xF6, 0x3D, 0xFE, 0x92, + 0x50, 0x1C, 0x4D, 0x16, 0x11, 0x72, 0x0F, 0x52 + }, + { + 0x38, 0x35, 0xCE, 0xCB, 0x29, 0xC6, 0x57, 0x51, + 0xFD, 0x32, 0xEF, 0x5F, 0xC3, 0xAE, 0x6E, 0xA2, + 0x01, 0x44, 0xE5, 0xE8, 0x83, 0x78, 0xAA, 0x0E, + 0x3A, 0xA2, 0x5E, 0x47, 0x5F, 0x5E, 0x50, 0x7E + }, + { + 0x07, 0x81, 0x4D, 0x13, 0x90, 0xE6, 0x27, 0x97, + 0x10, 0x76, 0x0E, 0xF6, 0x56, 0xD2, 0xF1, 0xAC, + 0x2C, 0xA9, 0x09, 0x05, 0x76, 0x02, 0xF4, 0xCF, + 0xC4, 0xE4, 0xAF, 0x7D, 0xFF, 0x22, 0xF3, 0x72 + }, + { + 0x3E, 0x2D, 0x79, 0x59, 0x84, 0x97, 0x93, 0x3C, + 0xE7, 0xC4, 0xA0, 0x12, 0x09, 0x72, 0x06, 0x26, + 0xCA, 0x9B, 0x52, 0xE5, 0xD5, 0x6F, 0x7A, 0x72, + 0x71, 0x4C, 0xBC, 0xFB, 0x46, 0x92, 0x49, 0xB7 + }, + { + 0xA6, 0x06, 0x8B, 0x15, 0x57, 0xB3, 0xA2, 0xB8, + 0x49, 0x1C, 0x45, 0x2D, 0x76, 0x14, 0xAD, 0x2C, + 0x62, 0xB6, 0x41, 0x3C, 0xD4, 0x13, 0xD1, 0x11, + 0xF2, 0x08, 0x47, 0xC6, 0x0C, 0x2A, 0xA4, 0x37 + }, + { + 0x2D, 0xE6, 0x00, 0x29, 0x0D, 0x24, 0xFB, 0xC1, + 0x80, 0xA9, 0xB4, 0xF4, 0xA0, 0x6D, 0x5C, 0x87, + 0x32, 0xA8, 0x21, 0xBD, 0x80, 0x64, 0xC6, 0x30, + 0xF5, 0x7B, 0x35, 0x41, 0x40, 0x66, 0xCA, 0x03 + }, + { + 0x07, 0x66, 0x6C, 0x6A, 0x26, 0xD7, 0x85, 0x2F, + 0xA6, 0x5B, 0x80, 0x09, 0xC0, 0xEC, 0xB8, 0xD1, + 0x70, 0x95, 0x34, 0xE9, 0x79, 0xF3, 0x74, 0x43, + 0x4B, 0x0A, 0xE7, 0xB3, 0xC7, 0xED, 0x8E, 0xA6 + }, + { + 0x2E, 0xC8, 0xC5, 0x6B, 0x85, 0x6C, 0x4B, 0xC7, + 0xFA, 0xAE, 0xD8, 0xD4, 0x2A, 0xC9, 0xF5, 0x7C, + 0x1E, 0x81, 0xD0, 0xB8, 0x85, 0x0C, 0xB8, 0x65, + 0xB3, 0xAB, 0x6C, 0xE3, 0xBA, 0xD6, 0xBC, 0x38 + }, + { + 0x5C, 0x50, 0x26, 0x92, 0x5C, 0x15, 0x95, 0xD8, + 0xEA, 0x4C, 0x40, 0x4A, 0xF8, 0x1F, 0x7E, 0x8F, + 0x22, 0x79, 0xF7, 0x89, 0xFA, 0x66, 0xAF, 0xAE, + 0x32, 0x6D, 0x6A, 0x03, 0x34, 0x06, 0xE3, 0xFC + }, + { + 0x73, 0xC9, 0x9D, 0xE8, 0x20, 0x55, 0x08, 0x26, + 0x31, 0x29, 0x30, 0xAB, 0x06, 0xAC, 0xB4, 0xEB, + 0x0E, 0x9A, 0x91, 0x5D, 0x01, 0xE2, 0xBF, 0xC5, + 0xB9, 0xE5, 0x72, 0xA8, 0xFD, 0xB9, 0xC2, 0x01 + }, + { + 0x5C, 0x11, 0x16, 0x11, 0x83, 0x7D, 0x99, 0x38, + 0xD9, 0xA1, 0xB6, 0x5D, 0x3E, 0x29, 0xE4, 0xE5, + 0x85, 0x05, 0xE2, 0x2F, 0x83, 0xF1, 0x88, 0xD3, + 0xDA, 0x86, 0x1E, 0x79, 0x6F, 0x38, 0x61, 0x7A + }, + { + 0x9B, 0xDE, 0x7C, 0xE0, 0x47, 0xD5, 0x82, 0x58, + 0x7D, 0xBC, 0x54, 0x7E, 0x21, 0x3E, 0x15, 0x33, + 0x42, 0x19, 0x78, 0x3C, 0x76, 0xD5, 0x77, 0x6A, + 0x92, 0xAB, 0xE7, 0x1A, 0x28, 0xCF, 0xF6, 0x41 + }, + { + 0x4A, 0xAA, 0x68, 0xB1, 0x38, 0xA7, 0xF6, 0x17, + 0x7D, 0x3B, 0xEA, 0x11, 0x15, 0xFC, 0x18, 0x54, + 0xAA, 0x86, 0x5C, 0xF0, 0x60, 0x24, 0xE6, 0x51, + 0x29, 0x13, 0x43, 0x14, 0xC5, 0x92, 0x39, 0x5E + }, + { + 0x39, 0xA6, 0xDE, 0xDD, 0x66, 0x46, 0x18, 0x6C, + 0x3E, 0x08, 0x03, 0x14, 0xFA, 0xD7, 0xAA, 0xF3, + 0x97, 0x7B, 0x8B, 0x01, 0xAE, 0x6A, 0x75, 0x6D, + 0x6B, 0x86, 0xBF, 0xA3, 0xEB, 0xD8, 0xAB, 0x5B + }, + { + 0xA0, 0x5C, 0xF7, 0x9F, 0x06, 0x11, 0xA6, 0x70, + 0x65, 0xCF, 0x1B, 0x76, 0x3C, 0xF0, 0x31, 0xAD, + 0x3B, 0xAD, 0x1B, 0x61, 0x2B, 0x27, 0x1B, 0xE7, + 0x46, 0x1D, 0x9F, 0xD8, 0xB0, 0x05, 0x83, 0x83 + }, + { + 0x85, 0xB3, 0x6C, 0x4C, 0x9B, 0x47, 0x3F, 0x37, + 0x4A, 0x9B, 0x47, 0x15, 0x16, 0xB1, 0x95, 0xD1, + 0x60, 0xF7, 0x84, 0xEC, 0xFE, 0xF5, 0x9A, 0x77, + 0x69, 0xDE, 0x78, 0x94, 0x1A, 0x99, 0x10, 0x2F + }, + { + 0xE8, 0x0C, 0xFF, 0x58, 0xF8, 0xB4, 0x8F, 0x3C, + 0x57, 0x17, 0x53, 0x42, 0x7F, 0xD8, 0x95, 0x37, + 0x5B, 0x4D, 0xE1, 0x07, 0x43, 0xDB, 0x4F, 0xE1, + 0x53, 0xD5, 0x0D, 0xBA, 0xEB, 0x3E, 0x10, 0xBE + }, + { + 0x61, 0x93, 0x04, 0x51, 0x1F, 0xE7, 0xE3, 0xCD, + 0xF8, 0xB1, 0xD6, 0x92, 0x83, 0x2E, 0x40, 0xCC, + 0x67, 0x92, 0x8A, 0x26, 0xA7, 0x25, 0x2B, 0x8E, + 0x3A, 0x21, 0x48, 0x6A, 0x6B, 0xAC, 0x11, 0x70 + }, + { + 0x9C, 0x63, 0x88, 0x85, 0x96, 0x9A, 0x74, 0x2A, + 0x40, 0x3D, 0x0E, 0x1A, 0x5A, 0x6C, 0x41, 0x2C, + 0x60, 0x3C, 0x39, 0x3E, 0xEC, 0xD5, 0x4B, 0xBC, + 0x61, 0x6A, 0x9E, 0x95, 0x38, 0xC6, 0xF7, 0x79 + }, + { + 0xD6, 0x9D, 0x9E, 0x00, 0x43, 0xF0, 0xB1, 0xA0, + 0x01, 0x78, 0x70, 0xB0, 0x12, 0xD3, 0xFD, 0x1D, + 0xD6, 0xAD, 0xC8, 0xC8, 0x6C, 0x7F, 0x74, 0x4C, + 0x98, 0x31, 0x47, 0xB7, 0x74, 0x74, 0x9A, 0x7E + }, + { + 0x38, 0xA6, 0x5E, 0x60, 0x46, 0xC5, 0x84, 0x50, + 0x09, 0x3C, 0xED, 0x7C, 0xEF, 0x1C, 0x32, 0xDB, + 0xAC, 0xF1, 0xE0, 0x7E, 0xAF, 0x22, 0x50, 0xC3, + 0x4B, 0xD3, 0xA1, 0xCC, 0x7E, 0x4D, 0x92, 0x6D + }, + { + 0x04, 0x5A, 0xBC, 0xFB, 0xB4, 0xFF, 0x62, 0x33, + 0x4B, 0xF5, 0xA4, 0x57, 0x7E, 0x7C, 0x58, 0xAC, + 0x06, 0x34, 0xFF, 0x91, 0x5A, 0xD2, 0xDF, 0xEB, + 0xDF, 0x80, 0x85, 0x5E, 0xCD, 0x66, 0x50, 0x8B + }, + { + 0xFA, 0xC7, 0x25, 0x6F, 0x3F, 0x40, 0x42, 0xB4, + 0x19, 0x14, 0x73, 0x86, 0x7D, 0x95, 0x60, 0x9F, + 0xB6, 0xE4, 0x67, 0xC2, 0x35, 0x85, 0x63, 0x89, + 0x5D, 0x68, 0x91, 0x85, 0x4D, 0x40, 0xE2, 0xCF + }, + { + 0x13, 0x6B, 0xAE, 0xE7, 0x87, 0x0A, 0x1D, 0x33, + 0x89, 0xB9, 0x85, 0x98, 0x31, 0x0B, 0x4F, 0xCE, + 0x3A, 0x86, 0x80, 0x7E, 0x56, 0xDA, 0x62, 0x7E, + 0xB8, 0xF6, 0x97, 0xAB, 0x62, 0x13, 0xFA, 0xF2 + }, + { + 0xF1, 0x94, 0x2B, 0x59, 0x32, 0x24, 0xF3, 0x48, + 0x94, 0x47, 0x8C, 0xC1, 0xB2, 0x12, 0x11, 0xEF, + 0x0C, 0x96, 0xEB, 0xF9, 0xAE, 0x61, 0x95, 0x1D, + 0xF4, 0xB0, 0xAE, 0x70, 0xC0, 0x19, 0xB2, 0x52 + }, + { + 0xFE, 0x40, 0x7A, 0x2C, 0xA2, 0x01, 0x3E, 0x7C, + 0xC3, 0xE7, 0x21, 0x03, 0x22, 0x78, 0xBB, 0xF9, + 0x79, 0x16, 0x26, 0x8B, 0x31, 0xE7, 0x8E, 0x6D, + 0x24, 0xE3, 0xAD, 0x0B, 0x49, 0xB8, 0xEE, 0x64 + }, + { + 0x76, 0x1D, 0x68, 0xC0, 0xB1, 0x30, 0x47, 0xC1, + 0x57, 0xD6, 0x3E, 0xAF, 0x1F, 0xE5, 0x83, 0x1B, + 0x47, 0xE5, 0x88, 0x68, 0x17, 0xB0, 0x1E, 0xCC, + 0xFC, 0xFE, 0x72, 0x8B, 0x32, 0x0C, 0xC6, 0xD4 + }, + { + 0x68, 0x2A, 0xD1, 0x7E, 0xD4, 0xCA, 0x6B, 0x99, + 0x8E, 0x01, 0xDD, 0xEF, 0xCA, 0x03, 0x32, 0x31, + 0x16, 0x31, 0xAB, 0xBF, 0xFC, 0x70, 0x39, 0xD6, + 0xFF, 0x4E, 0xBB, 0x3B, 0xA8, 0xD2, 0x65, 0xCC + }, + { + 0xC7, 0xF9, 0xF7, 0xCF, 0x6A, 0x82, 0x36, 0x25, + 0x9D, 0x0C, 0x63, 0x4A, 0x22, 0x27, 0x70, 0x30, + 0x72, 0x75, 0x8F, 0x34, 0x93, 0x80, 0x25, 0xDD, + 0x99, 0xC0, 0xB7, 0x59, 0xA3, 0x3A, 0x3C, 0x08 + }, + { + 0xB6, 0x61, 0xF6, 0xB4, 0x5E, 0x6D, 0xCB, 0x1F, + 0x64, 0x44, 0xD1, 0xEF, 0x1A, 0xA5, 0x97, 0x37, + 0x51, 0x93, 0xAC, 0xBC, 0x1D, 0xEA, 0x59, 0xFE, + 0xB9, 0xF1, 0x12, 0x48, 0xF8, 0x38, 0xA2, 0xBC + }, + { + 0x08, 0x0E, 0x63, 0x2B, 0x82, 0xD7, 0x6A, 0x70, + 0xB0, 0xE6, 0x76, 0x75, 0x18, 0xD6, 0xE0, 0x48, + 0x12, 0x1D, 0x4D, 0xB3, 0x87, 0x9B, 0xE1, 0xA9, + 0x55, 0xA6, 0xEB, 0x25, 0x31, 0xFC, 0x2F, 0x29 + }, + { + 0x2F, 0xC4, 0xB3, 0x15, 0x4D, 0x2D, 0x1F, 0xA4, + 0xDA, 0x2A, 0xA9, 0xD6, 0xB0, 0xA2, 0x36, 0x68, + 0xAF, 0x4E, 0x7D, 0x39, 0x7B, 0x90, 0xDD, 0x00, + 0x38, 0x42, 0x39, 0x2A, 0x11, 0x35, 0xC6, 0x78 + }, + { + 0xC1, 0xF4, 0x7F, 0x11, 0xD9, 0xAA, 0xB4, 0xE8, + 0x63, 0xD2, 0xC2, 0x7C, 0xFB, 0xED, 0x2F, 0x42, + 0x04, 0x4B, 0xB7, 0x2A, 0xAA, 0xA1, 0x84, 0xBC, + 0x7D, 0x5B, 0x1B, 0x04, 0x90, 0x4B, 0x60, 0x6F + }, + { + 0xB0, 0xAF, 0x7A, 0x6C, 0xCF, 0xD5, 0xAD, 0x59, + 0x38, 0x31, 0xAA, 0x23, 0x8B, 0x45, 0x4E, 0x09, + 0xD2, 0xA1, 0xF2, 0x36, 0xB1, 0x33, 0x6E, 0xAF, + 0x59, 0x5B, 0xB8, 0x9A, 0xE9, 0x0F, 0xC6, 0xA2 + }, + { + 0x7C, 0xFF, 0xB3, 0xB1, 0xD7, 0xBF, 0x5B, 0xAD, + 0xB3, 0x12, 0x3B, 0xFE, 0x9E, 0x78, 0x39, 0x0B, + 0x24, 0x2D, 0xF2, 0x1E, 0x55, 0x4F, 0xF8, 0xAC, + 0x80, 0x38, 0x9B, 0x06, 0x3A, 0x17, 0xC0, 0x83 + }, + { + 0x60, 0xD8, 0x7D, 0xBB, 0xEB, 0xB6, 0x56, 0x3B, + 0xD6, 0xC6, 0x2A, 0xE6, 0xDF, 0x5F, 0x50, 0x10, + 0x2D, 0xB6, 0x49, 0x5B, 0x35, 0xE3, 0x5E, 0x1D, + 0xC3, 0xCB, 0x17, 0xC8, 0xD3, 0x80, 0x0C, 0x09 + }, + { + 0x6E, 0x40, 0xAB, 0x9F, 0x89, 0xEF, 0xE7, 0xA5, + 0x85, 0xA9, 0x51, 0x3F, 0xE2, 0x2E, 0xE6, 0x1C, + 0xE5, 0x68, 0xB1, 0xCD, 0x7E, 0xED, 0xBC, 0xCA, + 0xB3, 0xC2, 0x8A, 0xEC, 0x49, 0x94, 0x40, 0x73 + }, + { + 0x5F, 0xD4, 0xCF, 0x18, 0xA2, 0x5F, 0x80, 0xD9, + 0x0C, 0x00, 0xFA, 0x8F, 0x70, 0x9F, 0xB5, 0x12, + 0x66, 0x31, 0xC1, 0xAD, 0x09, 0x67, 0x36, 0xE8, + 0xC4, 0x09, 0x9C, 0x5B, 0x62, 0x62, 0x8F, 0x38 + }, + { + 0x1F, 0x82, 0x46, 0xEF, 0xC7, 0x83, 0x56, 0xAC, + 0xF7, 0x81, 0xEC, 0xA1, 0xCB, 0x25, 0xC3, 0x1F, + 0xE9, 0xA3, 0x74, 0x91, 0x77, 0xB3, 0xD8, 0x7B, + 0x0F, 0xFE, 0xB0, 0x22, 0x85, 0xBD, 0x16, 0xF7 + }, + { + 0x70, 0xDD, 0x43, 0xBC, 0x4F, 0xDE, 0xC4, 0xC3, + 0x6D, 0xF0, 0xA2, 0xC0, 0x55, 0xE9, 0x89, 0x17, + 0x0E, 0x55, 0x90, 0x8B, 0x4D, 0xD7, 0xBF, 0xFC, + 0x69, 0x2A, 0x93, 0xF7, 0x10, 0x71, 0xA9, 0xB5 + }, + { + 0x43, 0xBD, 0x07, 0x89, 0x7E, 0x72, 0x36, 0x04, + 0x37, 0x59, 0x72, 0xD4, 0xA8, 0xF7, 0xA3, 0xB4, + 0x7F, 0x6D, 0xEB, 0xEF, 0x75, 0xBF, 0xA7, 0xF9, + 0x87, 0x51, 0xCF, 0xB9, 0x52, 0x48, 0x08, 0x5B + }, + { + 0x3A, 0xF2, 0xA3, 0x75, 0x60, 0x11, 0x46, 0x7F, + 0x8B, 0x81, 0xBC, 0xA9, 0x41, 0x99, 0x80, 0x0C, + 0x00, 0xA8, 0x1F, 0xAE, 0x5C, 0x48, 0x64, 0x41, + 0x45, 0xEF, 0xD6, 0x69, 0x86, 0xD1, 0xA5, 0xCA + }, + { + 0xAB, 0x68, 0xFC, 0xE3, 0x6F, 0x30, 0x9D, 0x4D, + 0x91, 0x1C, 0x1B, 0x56, 0x3B, 0x14, 0x42, 0x27, + 0x20, 0x30, 0xB2, 0x10, 0x96, 0x3D, 0x7F, 0x2C, + 0xDE, 0x5F, 0x0F, 0x77, 0x47, 0x69, 0xF1, 0x33 + }, + { + 0xCC, 0xC1, 0x0E, 0xA2, 0x40, 0x03, 0xE6, 0x4A, + 0xFD, 0xD4, 0x06, 0xF3, 0x72, 0x7E, 0xE2, 0xB1, + 0x89, 0x56, 0xC3, 0x35, 0x7D, 0xBA, 0xBD, 0x95, + 0x6A, 0xF1, 0x18, 0x28, 0x13, 0x4E, 0xB0, 0x38 + }, + { + 0x2A, 0xD6, 0xC0, 0xCC, 0x5B, 0x0B, 0x37, 0x0A, + 0x31, 0x4E, 0x40, 0x33, 0xE5, 0x30, 0xC8, 0x80, + 0x34, 0x9B, 0x2C, 0xC1, 0xE8, 0xF0, 0x96, 0x57, + 0x2F, 0xCB, 0xD7, 0x48, 0x0D, 0xF6, 0xF0, 0xCD + }, + { + 0xCF, 0x54, 0x47, 0xEA, 0x57, 0xBC, 0xC6, 0xB2, + 0x97, 0x3C, 0x41, 0x37, 0x8D, 0x55, 0xFE, 0xAA, + 0xDC, 0xBA, 0xF4, 0xC2, 0x1B, 0xB6, 0x25, 0xC1, + 0xDC, 0x79, 0x66, 0x21, 0x1A, 0xE1, 0xF9, 0x2F + }, + { + 0x9A, 0x63, 0x99, 0xC1, 0xC5, 0xBF, 0xC3, 0x47, + 0xEC, 0x3F, 0xB9, 0xA7, 0x8F, 0x3E, 0xC1, 0x2C, + 0xF9, 0xAF, 0xE3, 0x8B, 0xCC, 0x9E, 0xEB, 0x6A, + 0xCD, 0x5A, 0xA2, 0x7F, 0x97, 0xA6, 0xA0, 0x06 + }, + { + 0x19, 0x0E, 0xC5, 0xBE, 0xA6, 0x08, 0x62, 0x6F, + 0x5B, 0x83, 0x7B, 0xB7, 0xC9, 0x5F, 0x1F, 0x88, + 0x93, 0x79, 0xEF, 0xA9, 0x9F, 0x30, 0xAE, 0x34, + 0x20, 0x00, 0x90, 0xB4, 0xCB, 0x5C, 0xF2, 0x22 + }, + { + 0x40, 0x4A, 0xC5, 0x16, 0xE6, 0x9B, 0x66, 0x7E, + 0x8B, 0xEC, 0xCA, 0x33, 0x11, 0xE1, 0x50, 0x79, + 0xAC, 0x4C, 0x02, 0x43, 0xAF, 0xB5, 0xFC, 0xFB, + 0x43, 0x08, 0xDD, 0x3A, 0xA1, 0xE9, 0x56, 0x0C + }, + { + 0x82, 0x4F, 0x3F, 0xFF, 0x59, 0x7E, 0x28, 0x3E, + 0x64, 0x47, 0x39, 0x25, 0xAD, 0xE9, 0x78, 0x00, + 0x64, 0x89, 0xA9, 0x60, 0x35, 0x98, 0x6F, 0x28, + 0x59, 0xC9, 0xB5, 0x7E, 0x6C, 0x15, 0x00, 0xC8 + }, + { + 0x3E, 0x69, 0x36, 0x97, 0x78, 0xD2, 0x1C, 0xC2, + 0x23, 0x4F, 0x5C, 0x54, 0x74, 0xD7, 0x50, 0xAB, + 0x79, 0xC1, 0xE2, 0x1B, 0x30, 0x2F, 0x19, 0x2E, + 0xDE, 0x94, 0x95, 0x4B, 0x38, 0x28, 0x4D, 0x8C + }, + { + 0x13, 0x51, 0x02, 0x1E, 0x41, 0xC5, 0x70, 0x92, + 0x95, 0xA2, 0x72, 0xBB, 0x19, 0x19, 0x58, 0xC2, + 0x59, 0x61, 0x0B, 0xEF, 0xAD, 0xF4, 0x51, 0x95, + 0xE8, 0x65, 0x0D, 0xE6, 0x2C, 0xC6, 0x93, 0x52 + }, + { + 0x90, 0xAE, 0xE4, 0x8A, 0x6A, 0x8D, 0xF2, 0x9C, + 0x14, 0x9C, 0x89, 0xA2, 0xB5, 0xAB, 0xE7, 0xD8, + 0xA8, 0xA7, 0x38, 0x88, 0x5A, 0xBF, 0xBD, 0x3F, + 0x5F, 0x6C, 0x9F, 0x0A, 0xF3, 0xA7, 0xEE, 0xC6 + }, + { + 0x6C, 0x93, 0xC7, 0x81, 0xD3, 0xF0, 0x65, 0xBD, + 0x7C, 0x46, 0x07, 0x52, 0x55, 0x12, 0xF6, 0xEC, + 0xE7, 0xFD, 0x66, 0xAE, 0xDE, 0x25, 0xAF, 0x99, + 0xE6, 0x17, 0x1E, 0x20, 0x0E, 0x77, 0xB4, 0xB9 + }, + { + 0x8F, 0xED, 0xF7, 0x9A, 0x04, 0xE6, 0xAB, 0x91, + 0xC4, 0xDB, 0x44, 0x99, 0x2F, 0x8F, 0x9C, 0x05, + 0xD2, 0x2A, 0x4A, 0x96, 0x5F, 0xB3, 0xC8, 0x06, + 0x6D, 0x41, 0x9A, 0xDD, 0x0D, 0x5A, 0x71, 0xBF + }, + { + 0x3E, 0xD8, 0x57, 0x8D, 0xEB, 0x89, 0xEC, 0x90, + 0xD2, 0x09, 0xFF, 0xA2, 0xD7, 0x37, 0x26, 0x4A, + 0x0C, 0xC6, 0x40, 0x43, 0xCF, 0x94, 0xC8, 0x78, + 0xC6, 0x6D, 0x77, 0x0F, 0x93, 0x56, 0x38, 0xF1 + }, + { + 0x5B, 0x08, 0xF1, 0xF2, 0x82, 0xA9, 0xCA, 0xE5, + 0xEA, 0x01, 0x15, 0x3C, 0xF2, 0xAE, 0x09, 0x6B, + 0x16, 0xC0, 0x7D, 0xFE, 0x30, 0x37, 0xF1, 0x84, + 0x57, 0x6E, 0x60, 0xC5, 0xF5, 0xC7, 0xC8, 0x30 + }, + { + 0x7A, 0x6F, 0x0E, 0x87, 0x58, 0xFD, 0x18, 0x6F, + 0x24, 0x0E, 0x51, 0xE0, 0x67, 0x7D, 0x73, 0x1E, + 0x17, 0xCB, 0xB0, 0xA1, 0xDF, 0xC2, 0x43, 0x96, + 0x10, 0x10, 0x40, 0xEC, 0x3E, 0x85, 0xD2, 0x6E + }, + { + 0xA2, 0xE8, 0x17, 0x16, 0xF5, 0xA2, 0x5C, 0x83, + 0x3F, 0x58, 0x02, 0x97, 0x3B, 0x15, 0xFA, 0x2A, + 0x47, 0x79, 0x72, 0x18, 0x22, 0x12, 0x70, 0xB4, + 0x9C, 0x93, 0x63, 0x54, 0x92, 0x37, 0x0F, 0xFA + }, + { + 0xAE, 0xB9, 0x52, 0xC6, 0xF4, 0x94, 0xFF, 0xBC, + 0xE8, 0x82, 0x9B, 0x19, 0xDB, 0xA2, 0x91, 0xA1, + 0xAF, 0x29, 0xC0, 0x33, 0xB1, 0xC7, 0x0E, 0x62, + 0x96, 0xCE, 0x2D, 0x8B, 0x4C, 0x6A, 0x3E, 0x81 + }, + { + 0xB1, 0xAE, 0xB5, 0xF7, 0xE3, 0xD1, 0x3C, 0x31, + 0xDB, 0x0A, 0x02, 0x7C, 0xA5, 0x3D, 0x99, 0xC0, + 0x42, 0x6A, 0x1D, 0x60, 0x2E, 0x94, 0x53, 0xCF, + 0xBC, 0x81, 0x60, 0x69, 0x43, 0xE6, 0x7B, 0x5E + }, + { + 0x1B, 0x6B, 0x71, 0x8A, 0x4A, 0x58, 0xF7, 0xAE, + 0x51, 0xA8, 0x96, 0x44, 0x85, 0x7B, 0xE1, 0xEB, + 0x7D, 0xCC, 0xAA, 0xB4, 0x50, 0x5E, 0xB2, 0xA2, + 0xDB, 0x60, 0xBB, 0xC4, 0x61, 0x90, 0x9F, 0x84 + }, + { + 0x49, 0x92, 0x59, 0x9E, 0xE2, 0xBF, 0x1C, 0xCA, + 0x4E, 0xF2, 0xD5, 0x91, 0xE5, 0x45, 0xEB, 0x98, + 0x72, 0x6D, 0xFD, 0xF7, 0x53, 0x43, 0x83, 0x46, + 0xD8, 0x45, 0x2D, 0x8C, 0xE0, 0x15, 0x46, 0x96 + }, + { + 0xD2, 0x8D, 0x39, 0x19, 0x23, 0xFA, 0x12, 0xF5, + 0x73, 0x76, 0x6E, 0x6F, 0x25, 0xE5, 0xDC, 0xA7, + 0xD5, 0x47, 0x0B, 0xC6, 0x63, 0xA2, 0x24, 0xD4, + 0xA1, 0x99, 0xBF, 0x25, 0xD3, 0x9A, 0x79, 0xCC + }, + { + 0xC2, 0xBE, 0x45, 0x37, 0x32, 0xD3, 0x1E, 0x9D, + 0x9B, 0xCB, 0x39, 0x0D, 0x11, 0xDC, 0x44, 0x1C, + 0xD8, 0xE4, 0xE7, 0xBD, 0xF2, 0x5B, 0x8A, 0x27, + 0x58, 0x58, 0x6C, 0xA7, 0x76, 0x60, 0x72, 0xC8 + }, + { + 0x65, 0x31, 0xC5, 0x2C, 0xAB, 0x71, 0xF1, 0x4E, + 0x0A, 0x50, 0x52, 0x9C, 0x10, 0x88, 0x9B, 0xD4, + 0x0D, 0x01, 0xDA, 0xBF, 0xFB, 0x2D, 0xEA, 0xD6, + 0xB5, 0x1D, 0xDA, 0xAB, 0xAC, 0x94, 0x3D, 0x6E + }, + { + 0x4C, 0x2B, 0xA4, 0x37, 0x2B, 0x17, 0xE5, 0x3A, + 0x4C, 0x74, 0x3C, 0x25, 0xDB, 0x78, 0xFB, 0xD7, + 0x0E, 0xD6, 0x82, 0x32, 0x23, 0x03, 0x29, 0x90, + 0x60, 0x79, 0xC1, 0x62, 0x92, 0x21, 0x4C, 0x97 + }, + { + 0x84, 0x1B, 0xA8, 0x52, 0xA0, 0xAA, 0x7F, 0x73, + 0x05, 0x5F, 0x6A, 0xE5, 0x03, 0x95, 0x6B, 0x8B, + 0x7E, 0x5C, 0xF9, 0xF4, 0x79, 0xF3, 0x48, 0xB1, + 0xDA, 0x5A, 0xF5, 0x44, 0x2A, 0x3F, 0x40, 0xA0 + }, + { + 0xD1, 0xD9, 0xC4, 0x66, 0x9E, 0x29, 0x75, 0x00, + 0x33, 0xDF, 0x4C, 0x11, 0xF2, 0x20, 0x51, 0xCE, + 0x80, 0x10, 0x67, 0xF9, 0x3A, 0x59, 0x26, 0xBC, + 0xAD, 0x87, 0x81, 0x3D, 0x4C, 0x58, 0x26, 0xF1 + }, + { + 0x68, 0x7A, 0xE0, 0x8C, 0x47, 0xC5, 0x56, 0xB2, + 0x89, 0xBF, 0x1D, 0x2C, 0xA0, 0x36, 0x1D, 0xFC, + 0x0B, 0xFD, 0xDE, 0xAF, 0xBD, 0xF4, 0xA6, 0x41, + 0xB9, 0x75, 0x88, 0x10, 0xAC, 0x80, 0xA5, 0xC9 + }, + { + 0xD7, 0xD3, 0xEB, 0x2E, 0xFA, 0xAA, 0x37, 0xE1, + 0x5B, 0x5F, 0x0F, 0x92, 0xD9, 0x9C, 0xD8, 0x54, + 0xFC, 0x3B, 0x3B, 0xA9, 0x12, 0x5C, 0xB9, 0x45, + 0x2E, 0x6F, 0xCB, 0x63, 0xAC, 0xAE, 0x3E, 0x1A + }, + { + 0x14, 0x1A, 0xEA, 0x63, 0xCD, 0x47, 0x87, 0xD3, + 0x2D, 0xA8, 0xD0, 0x6A, 0x15, 0x19, 0xFF, 0x20, + 0xE7, 0xC1, 0x04, 0x32, 0x40, 0xD5, 0xB3, 0x3B, + 0xF5, 0x90, 0x61, 0xF7, 0x22, 0x60, 0x52, 0xF7 + }, + { + 0xE4, 0x2D, 0xB7, 0xAC, 0xBE, 0x97, 0x2C, 0xAD, + 0xD7, 0x6A, 0x85, 0xEE, 0xCC, 0x55, 0xF6, 0x4A, + 0x8E, 0x90, 0x90, 0x11, 0xFC, 0x6F, 0x01, 0x43, + 0x0B, 0x54, 0xA9, 0xC3, 0xD9, 0x72, 0xEB, 0x0C + }, + { + 0x9B, 0x58, 0xFA, 0x03, 0x82, 0x2A, 0xC3, 0x6E, + 0xD4, 0xBD, 0x99, 0x51, 0x29, 0x3E, 0x39, 0xD3, + 0xED, 0x98, 0x63, 0x77, 0xB8, 0xB5, 0x5F, 0x47, + 0x9B, 0xE7, 0x19, 0x90, 0x96, 0xE6, 0xB1, 0x32 + }, + { + 0x97, 0xCF, 0x50, 0xE7, 0x41, 0x0B, 0x5A, 0x69, + 0x09, 0xE5, 0xD2, 0x3C, 0x85, 0x97, 0x20, 0x9E, + 0x84, 0x86, 0x20, 0xA4, 0x53, 0x77, 0xF7, 0x99, + 0x5E, 0x1F, 0xF3, 0xF4, 0x5C, 0x8F, 0x46, 0x12 + }, + { + 0xC7, 0x5C, 0xF3, 0x38, 0x0A, 0x52, 0x55, 0x1E, + 0x92, 0x4C, 0x7A, 0x6D, 0x1E, 0x24, 0xEF, 0x92, + 0x2E, 0x9E, 0x9D, 0x09, 0x08, 0x4A, 0x53, 0x35, + 0x13, 0x2F, 0xEF, 0xB9, 0x1B, 0xED, 0x87, 0xA3 + }, + { + 0x4C, 0xB2, 0x65, 0x31, 0x3D, 0xC6, 0xCF, 0x94, + 0x1F, 0xCF, 0xFE, 0x2F, 0xF4, 0xF0, 0xA2, 0xA8, + 0x7A, 0xE3, 0x04, 0x07, 0x06, 0x20, 0x93, 0x46, + 0x29, 0x31, 0xC2, 0x20, 0x09, 0x68, 0xCC, 0x29 + }, + { + 0xB3, 0x5A, 0xE4, 0xE9, 0xCE, 0x49, 0xF8, 0x4E, + 0x3F, 0xA4, 0xF5, 0x8E, 0x6F, 0xA3, 0x1C, 0xEF, + 0x5E, 0xC9, 0x9C, 0x1F, 0x65, 0xD3, 0x30, 0xDA, + 0x69, 0xFD, 0x0E, 0xDF, 0x51, 0xA6, 0x5A, 0xC9 + }, + { + 0xD7, 0xE6, 0x35, 0x4E, 0x9D, 0xB1, 0xA8, 0x43, + 0x12, 0xB3, 0xB7, 0xC5, 0xDB, 0x61, 0x61, 0xA6, + 0x43, 0xAF, 0x90, 0x1E, 0x70, 0x28, 0xFA, 0xD9, + 0xA1, 0x4F, 0x08, 0xD4, 0x06, 0xC6, 0xD0, 0xAB + }, + { + 0x06, 0x5E, 0x61, 0xA0, 0x66, 0xAA, 0x21, 0xD0, + 0x05, 0xF8, 0xA8, 0xFE, 0x01, 0xFC, 0xCE, 0x7E, + 0x1D, 0xFA, 0x29, 0x7D, 0xE3, 0xF5, 0x9F, 0x3C, + 0x6B, 0x7A, 0x6A, 0x7F, 0xD5, 0x7E, 0x9C, 0xE1 + }, + { + 0xB2, 0x9E, 0x4F, 0xB5, 0xD2, 0x98, 0x2D, 0x17, + 0x0D, 0xE4, 0x08, 0x83, 0x39, 0xF3, 0x4D, 0x78, + 0x58, 0x80, 0xD7, 0x10, 0xAA, 0x75, 0x55, 0x15, + 0x8D, 0x99, 0x6B, 0x05, 0x68, 0x40, 0x31, 0x22 + }, + { + 0x96, 0xF3, 0xA9, 0x5F, 0xD4, 0x93, 0x84, 0xDB, + 0x48, 0x53, 0x5C, 0x1D, 0x93, 0x82, 0x69, 0x5B, + 0x0A, 0xB9, 0x15, 0x76, 0x65, 0x44, 0xD5, 0x0F, + 0xBE, 0xCB, 0xF4, 0xAC, 0xF7, 0xF9, 0x70, 0x7D + }, + { + 0x47, 0x83, 0xA5, 0x77, 0x7E, 0x31, 0x4D, 0x1B, + 0xB8, 0x6F, 0x33, 0xB7, 0x1C, 0xFD, 0x68, 0x29, + 0xFB, 0x30, 0xF7, 0x81, 0x5D, 0x86, 0x19, 0x9E, + 0x06, 0x3B, 0x94, 0x48, 0x0C, 0x81, 0x83, 0x7C + }, + { + 0x5C, 0x52, 0xB8, 0x2C, 0x08, 0x81, 0xDA, 0xF1, + 0xDC, 0xE5, 0xAA, 0x9B, 0xA3, 0xFA, 0x78, 0x30, + 0x25, 0x6B, 0x8C, 0xB2, 0x6D, 0x68, 0x05, 0x4E, + 0x70, 0x31, 0x1C, 0xE5, 0xC8, 0xF5, 0x59, 0xB1 + }, + { + 0xA9, 0xAD, 0x68, 0x08, 0x60, 0x51, 0x53, 0xFA, + 0x62, 0x3E, 0xF1, 0xC0, 0xD4, 0x8A, 0x59, 0x95, + 0x56, 0x47, 0x70, 0x0E, 0x6E, 0x5C, 0x23, 0xDD, + 0x63, 0x9A, 0x4B, 0x5C, 0x5C, 0x74, 0xD8, 0x44 + }, + { + 0x4E, 0x8C, 0x48, 0x84, 0xB7, 0xAF, 0xAA, 0x64, + 0x2A, 0x63, 0x46, 0x4F, 0x7D, 0x6F, 0x9B, 0xDC, + 0xC0, 0xD1, 0xF1, 0x8C, 0x11, 0xAC, 0x35, 0x76, + 0x69, 0xA2, 0x20, 0x65, 0x62, 0xBD, 0x47, 0x0E + }, + { + 0x0D, 0x54, 0x5F, 0xD0, 0xCD, 0xCF, 0x93, 0x91, + 0x28, 0xFF, 0x0D, 0xFE, 0xBE, 0x84, 0xB5, 0xE1, + 0x43, 0xED, 0xC6, 0xC9, 0x43, 0xCD, 0xE2, 0x7D, + 0xF2, 0xA7, 0xE7, 0x8D, 0xB4, 0x3E, 0x7F, 0xD8 + }, + { + 0xF4, 0x99, 0x67, 0x33, 0xDA, 0xD6, 0x02, 0x76, + 0x0A, 0x9E, 0x67, 0x32, 0x3E, 0xBF, 0x7F, 0xB2, + 0x9A, 0x44, 0x34, 0x4D, 0x8E, 0x40, 0x08, 0x49, + 0xB7, 0x96, 0x7C, 0xA4, 0x6A, 0x3A, 0x61, 0x84 + }, + { + 0x66, 0x7B, 0xFD, 0x06, 0xDC, 0x4E, 0xE0, 0xC1, + 0xE0, 0x77, 0x1F, 0xBF, 0xBE, 0xF2, 0xC0, 0x96, + 0xEE, 0x67, 0xFE, 0xAF, 0xB9, 0x6F, 0xF4, 0x22, + 0x12, 0xCF, 0xBD, 0x63, 0x79, 0xDC, 0x21, 0x4C + }, + { + 0x6C, 0xCC, 0x26, 0x6D, 0xBB, 0x6B, 0x94, 0x47, + 0xA4, 0x97, 0xB7, 0x36, 0x5A, 0xA8, 0x86, 0xA9, + 0x69, 0x41, 0x97, 0x7C, 0xE5, 0xC0, 0xC1, 0x17, + 0xC9, 0x2D, 0x9A, 0x2B, 0x13, 0x09, 0x39, 0x65 + }, + { + 0xB3, 0xD3, 0xF9, 0x58, 0x8A, 0xAF, 0x76, 0x0B, + 0x11, 0x17, 0x97, 0x1D, 0x4D, 0x26, 0xFB, 0x06, + 0x42, 0x45, 0x49, 0x81, 0x07, 0x5B, 0x92, 0x1E, + 0x4E, 0x9B, 0xA1, 0xE8, 0x5C, 0x12, 0xC7, 0xDB + }, + { + 0x95, 0xBB, 0x30, 0x1C, 0xDD, 0x64, 0xBF, 0xEF, + 0x62, 0x06, 0xA4, 0xAE, 0x81, 0x81, 0xF6, 0x89, + 0x17, 0xAB, 0xA5, 0x89, 0x4F, 0xCF, 0x56, 0x02, + 0xB4, 0xFD, 0xC0, 0x11, 0x4D, 0x6E, 0x4D, 0x79 + }, + { + 0x66, 0x32, 0xAB, 0xA0, 0x6D, 0x21, 0x43, 0x5A, + 0xBC, 0x50, 0x93, 0x8C, 0xFE, 0x74, 0x0B, 0x5E, + 0xD4, 0x3F, 0x1A, 0xE6, 0xB3, 0x38, 0xFF, 0xF0, + 0xA2, 0x48, 0xDC, 0x69, 0xF0, 0x4C, 0x49, 0x4C + }, + { + 0xB0, 0x00, 0xC2, 0xF7, 0xE5, 0x36, 0xD0, 0x20, + 0xD0, 0xF9, 0x93, 0x86, 0x40, 0x8A, 0xF2, 0x13, + 0x88, 0xF8, 0x0D, 0x4A, 0x08, 0x37, 0x6C, 0xF4, + 0x39, 0xF5, 0x23, 0xB0, 0x48, 0x54, 0xB7, 0x95 + }, + { + 0x03, 0xA7, 0x39, 0xAF, 0x6B, 0x71, 0xED, 0x59, + 0x93, 0xE9, 0x72, 0xC7, 0x88, 0xA4, 0x93, 0xE7, + 0xD6, 0x69, 0xED, 0x0C, 0xA3, 0xA0, 0x44, 0x24, + 0x89, 0x0F, 0x3E, 0x7C, 0x7A, 0x84, 0xE8, 0x36 + }, + { + 0xFC, 0x50, 0x86, 0x90, 0xA5, 0x7E, 0x8D, 0x20, + 0x5C, 0xDB, 0x62, 0xD4, 0xCA, 0xA9, 0x43, 0x9C, + 0x43, 0x20, 0x88, 0xF4, 0xF3, 0xA1, 0xC3, 0x1A, + 0x6E, 0xBA, 0x58, 0x67, 0x88, 0x4F, 0xB8, 0x6E + }, + { + 0xB6, 0x77, 0xB9, 0x53, 0xA9, 0xFC, 0x8F, 0xAF, + 0x36, 0x52, 0x67, 0x26, 0xEB, 0x53, 0x77, 0x15, + 0x43, 0xAF, 0xC9, 0xD5, 0x60, 0x8D, 0xCF, 0xE2, + 0xF5, 0x9E, 0x57, 0x75, 0x0F, 0x41, 0xDC, 0xFD + }, + { + 0x38, 0xD3, 0xDB, 0xB6, 0x22, 0x3A, 0xB9, 0xE9, + 0xD3, 0x11, 0x18, 0x2D, 0xF7, 0xF6, 0xA5, 0xAD, + 0xB0, 0xFB, 0x7C, 0xFA, 0x37, 0xCE, 0x5D, 0x40, + 0xA9, 0x08, 0xBA, 0x27, 0x5C, 0x9C, 0xCD, 0xFC + }, + { + 0x95, 0xE1, 0xCC, 0xBF, 0x17, 0x54, 0xBB, 0x57, + 0x90, 0xEA, 0x3F, 0x7F, 0x37, 0xA2, 0x90, 0x89, + 0x1F, 0xA6, 0x12, 0x2F, 0xE9, 0x54, 0x16, 0x96, + 0xAF, 0x92, 0xB9, 0xFC, 0x13, 0x0E, 0xF7, 0xF4 + }, + { + 0x8F, 0x54, 0x4D, 0x3E, 0xDB, 0xB2, 0x39, 0xAE, + 0x8A, 0xA5, 0x41, 0x2D, 0x9D, 0x2F, 0xBD, 0x7C, + 0x50, 0x45, 0x3F, 0x0F, 0xD8, 0xC3, 0x15, 0x97, + 0xFB, 0xB6, 0xBA, 0x14, 0x04, 0xA1, 0xBA, 0x6D + }, + { + 0x62, 0x1C, 0x88, 0xF3, 0x4A, 0x56, 0xCA, 0x3F, + 0xFA, 0xCE, 0xE5, 0xD1, 0x2C, 0xF5, 0xC4, 0x86, + 0x6A, 0x08, 0xA5, 0x7E, 0xA8, 0x4F, 0xC6, 0xAC, + 0xAA, 0x30, 0x67, 0xD7, 0xD5, 0xE1, 0xC2, 0x60 + }, + { + 0xB3, 0x8D, 0xE3, 0x4D, 0x5F, 0xCD, 0x91, 0x57, + 0xDD, 0x28, 0x7E, 0x58, 0x53, 0xF6, 0x4B, 0xF2, + 0x4E, 0xDD, 0x9C, 0xF4, 0x99, 0x6C, 0x4C, 0x52, + 0x66, 0xEC, 0xA6, 0x2B, 0x3E, 0xF5, 0x27, 0x2D + }, + { + 0xC7, 0x2E, 0xE3, 0xFA, 0xDB, 0x8C, 0xD1, 0xDE, + 0x8E, 0xEA, 0x23, 0x8F, 0xB9, 0x6B, 0xFB, 0xF0, + 0x50, 0xD2, 0xAE, 0xEA, 0x3D, 0x7C, 0xBF, 0x87, + 0x9A, 0x37, 0x41, 0xF9, 0x40, 0xD0, 0xA8, 0x9F + }, + { + 0x0F, 0xA4, 0xF0, 0x8F, 0x41, 0x22, 0x10, 0xA3, + 0x36, 0xC2, 0xE9, 0xC6, 0xA8, 0x18, 0xDB, 0x9C, + 0x5B, 0x62, 0xD7, 0x97, 0x42, 0x30, 0x19, 0x73, + 0x08, 0x1E, 0x6F, 0x09, 0xF1, 0xA4, 0x73, 0x35 + }, + { + 0x0A, 0x12, 0x53, 0xCF, 0xB3, 0x92, 0x5A, 0x4B, + 0x19, 0xCE, 0x41, 0xA2, 0x7B, 0x73, 0xEE, 0x69, + 0x80, 0xBA, 0xA0, 0x44, 0xDD, 0x1F, 0xDE, 0x51, + 0x4F, 0x3C, 0x70, 0xD8, 0x76, 0xCD, 0x7B, 0x6A + }, + { + 0x9D, 0x9B, 0x78, 0x3C, 0xBB, 0xEB, 0x4C, 0xBF, + 0x11, 0xEF, 0x9D, 0xA8, 0x0C, 0x46, 0x6A, 0x4E, + 0xAD, 0x5E, 0xAF, 0xFE, 0x72, 0xEF, 0xE4, 0xE5, + 0x6D, 0x6F, 0xC1, 0x3F, 0x0D, 0xCB, 0xFB, 0x37 + }, + { + 0xDB, 0xB9, 0x94, 0x23, 0xE5, 0xD8, 0x89, 0x90, + 0x67, 0x62, 0x34, 0x6E, 0xEC, 0x0A, 0x73, 0x19, + 0x0E, 0xAB, 0x96, 0x07, 0x47, 0xA1, 0xCE, 0x7E, + 0xD0, 0xB2, 0xED, 0x20, 0x2F, 0x46, 0x5C, 0x22 + }, + { + 0x53, 0x10, 0x07, 0xA1, 0xF4, 0xF0, 0xAC, 0xB8, + 0x9A, 0x83, 0xE7, 0x32, 0xAC, 0xF9, 0xEC, 0xD5, + 0x36, 0xDE, 0x44, 0x81, 0x24, 0x3C, 0x5C, 0xCC, + 0xF1, 0x94, 0x5A, 0x84, 0xC1, 0x1C, 0x44, 0x3F + }, + { + 0x64, 0xA0, 0xBA, 0x40, 0xCE, 0xCE, 0xAB, 0x01, + 0xC7, 0x5E, 0xB9, 0x48, 0x4A, 0x36, 0x57, 0x07, + 0xB8, 0x3E, 0xC2, 0xCF, 0x51, 0x29, 0x41, 0xF8, + 0x95, 0x4D, 0x70, 0xCE, 0x7E, 0x04, 0x6A, 0x47 + }, + { + 0xFE, 0x8F, 0x76, 0xD0, 0x70, 0x4C, 0x0E, 0x49, + 0xB9, 0xB6, 0xDD, 0xE6, 0x3E, 0xDA, 0x68, 0xB3, + 0x2F, 0x12, 0xA7, 0xCD, 0xDE, 0xE8, 0x71, 0x50, + 0x00, 0x45, 0xD0, 0x98, 0xD5, 0x18, 0xC9, 0xC6 + }, + { + 0x8C, 0xE3, 0xE6, 0xB2, 0xD8, 0x14, 0xD7, 0x64, + 0xE6, 0xDA, 0x33, 0xC1, 0xC1, 0x47, 0xF4, 0x44, + 0xE1, 0x06, 0x12, 0x4F, 0x9B, 0xDB, 0xD2, 0xF6, + 0xB8, 0x87, 0x37, 0x6C, 0xA7, 0x51, 0xB3, 0xE7 + }, + { + 0x23, 0x0D, 0x64, 0x50, 0xD5, 0xBD, 0x5B, 0xEE, + 0xD4, 0x4F, 0xBA, 0x5D, 0x6A, 0xCE, 0x64, 0xB4, + 0x74, 0x0D, 0x96, 0xB0, 0x1C, 0x4C, 0x65, 0x7E, + 0x8F, 0x7E, 0x02, 0x68, 0xD4, 0xE9, 0x65, 0x09 + }, + { + 0x4E, 0x33, 0x3E, 0x92, 0x68, 0xC9, 0x4A, 0x90, + 0x53, 0xB3, 0x0F, 0x07, 0xE6, 0x17, 0x62, 0x48, + 0xCA, 0x5C, 0x45, 0x81, 0x23, 0x16, 0xC8, 0xC2, + 0x2D, 0x59, 0xB2, 0xB4, 0xBB, 0xE2, 0x16, 0x91 + }, + { + 0xD6, 0x6A, 0x2F, 0x55, 0x8B, 0xFE, 0x27, 0xBA, + 0x07, 0x71, 0x65, 0xAD, 0x9F, 0x75, 0x62, 0x6E, + 0xB5, 0xA3, 0xF7, 0xA2, 0x9B, 0x1D, 0x36, 0x5C, + 0x5C, 0xE4, 0xED, 0xDA, 0x3D, 0x3D, 0xA0, 0x23 + }, + { + 0x96, 0xFB, 0x7A, 0x61, 0x6E, 0x13, 0xD0, 0xB3, + 0x0E, 0x22, 0x29, 0xEA, 0x37, 0xF4, 0x34, 0x05, + 0x74, 0xAB, 0x90, 0xB8, 0x5D, 0xF6, 0x23, 0x54, + 0x2B, 0xF1, 0x2A, 0x62, 0x40, 0x8B, 0xE5, 0x7A + }, + { + 0x0F, 0x6A, 0x9D, 0x0D, 0x89, 0x84, 0x7B, 0xBB, + 0xBA, 0x84, 0x56, 0x0A, 0x57, 0x29, 0xE1, 0xDB, + 0xE2, 0x70, 0x3B, 0x87, 0x27, 0x2C, 0x03, 0xB2, + 0x9E, 0xD7, 0xE6, 0x5F, 0x7E, 0x0A, 0x41, 0x70 + }, + { + 0xAC, 0xB8, 0x51, 0x00, 0x14, 0xFA, 0x49, 0x87, + 0x24, 0x0B, 0x2D, 0xAD, 0xA5, 0x54, 0x85, 0xC9, + 0x02, 0x87, 0x15, 0x09, 0x35, 0x5E, 0x47, 0x72, + 0x07, 0xA7, 0x25, 0x71, 0x6C, 0xDB, 0x67, 0x39 + }, + { + 0x64, 0x8A, 0xFA, 0x41, 0x46, 0x4E, 0xF8, 0x72, + 0x6D, 0xFB, 0xCD, 0x9A, 0xE2, 0xBB, 0x4F, 0x1C, + 0x67, 0x79, 0x49, 0x90, 0x15, 0x6E, 0x4B, 0xBD, + 0x8D, 0xB3, 0xDC, 0x04, 0x69, 0x8F, 0x10, 0x38 + }, + { + 0xDD, 0x48, 0x21, 0xD9, 0xF6, 0x9C, 0xE3, 0x2F, + 0x96, 0xF1, 0x05, 0x44, 0x25, 0x64, 0xD5, 0xA3, + 0xF2, 0xD8, 0x33, 0xF0, 0x37, 0x97, 0x25, 0x65, + 0xBD, 0xC4, 0xEA, 0xD1, 0x6D, 0xF0, 0x7F, 0xB0 + }, + { + 0x76, 0x94, 0x85, 0x0B, 0x91, 0xEA, 0xC1, 0xDE, + 0xC7, 0xB6, 0x0D, 0x87, 0x55, 0xEB, 0xB9, 0xE8, + 0x60, 0x8E, 0xC2, 0x2C, 0x55, 0xC9, 0xE7, 0x42, + 0xE6, 0x97, 0x47, 0x52, 0xB0, 0x3B, 0xB9, 0xFD + }, + { + 0xD7, 0xBA, 0x8A, 0x72, 0xFB, 0x20, 0x42, 0xD5, + 0x76, 0x9B, 0x96, 0x85, 0x9A, 0x11, 0xAA, 0x46, + 0xF0, 0xCB, 0x26, 0x00, 0xEC, 0xE1, 0xD8, 0x3D, + 0xDA, 0x5E, 0x7D, 0x86, 0x37, 0x77, 0x76, 0x00 + }, + { + 0xF6, 0x7B, 0x8B, 0xF6, 0x37, 0x9A, 0xEA, 0xBB, + 0x99, 0x21, 0x42, 0x53, 0xC9, 0xD1, 0x40, 0xA0, + 0x3F, 0xD6, 0xAE, 0xCA, 0x9D, 0x54, 0x7B, 0x20, + 0xE6, 0xFA, 0xE2, 0x7B, 0x9F, 0x28, 0x29, 0x72 + }, + { + 0x7B, 0x50, 0x55, 0xC9, 0x7E, 0x34, 0x6F, 0x7D, + 0xB7, 0xE4, 0x89, 0x93, 0x0E, 0x77, 0x89, 0x8E, + 0xCC, 0xCE, 0x36, 0x1E, 0x9A, 0xCD, 0xA8, 0x92, + 0x38, 0x49, 0x5F, 0x9A, 0x49, 0xFB, 0xF9, 0xDF + }, + { + 0xB0, 0xA8, 0x8E, 0x95, 0x36, 0x45, 0xDD, 0x14, + 0xA6, 0xA7, 0x67, 0xD1, 0x63, 0x2B, 0xCD, 0x5F, + 0xA7, 0xBC, 0x73, 0x26, 0x4D, 0xD1, 0xC9, 0xCA, + 0xE4, 0x72, 0x33, 0xB4, 0x5A, 0x1D, 0x05, 0x43 + }, + { + 0xC7, 0x34, 0x76, 0x98, 0x59, 0xB8, 0xDF, 0x33, + 0xA7, 0xD9, 0xFD, 0xAD, 0x58, 0xDB, 0x6D, 0x60, + 0xCB, 0x24, 0x7D, 0x9B, 0x72, 0xA6, 0x66, 0xD8, + 0x68, 0x6B, 0x0D, 0x64, 0x01, 0x01, 0x1A, 0x97 + }, + { + 0xD8, 0x30, 0x8B, 0xB3, 0xFC, 0xE6, 0x48, 0xE5, + 0x2E, 0xD6, 0x7B, 0x6E, 0x41, 0xDB, 0x06, 0x1C, + 0x47, 0x6D, 0x15, 0x1D, 0xC3, 0xDE, 0xAC, 0x7D, + 0xA1, 0xEC, 0xAC, 0xC9, 0x68, 0x01, 0xC4, 0xD5 + }, + { + 0x79, 0x93, 0xA1, 0x72, 0x9E, 0x6F, 0x58, 0xBB, + 0x14, 0xD8, 0x24, 0xC7, 0x29, 0xD9, 0x45, 0x16, + 0x4B, 0x38, 0x53, 0x9E, 0x79, 0xDD, 0xD3, 0x5C, + 0x25, 0x8E, 0x18, 0xCF, 0x9D, 0xAB, 0x55, 0x58 + }, + { + 0x3E, 0x27, 0xEE, 0xAF, 0x46, 0x48, 0xEE, 0x40, + 0xC4, 0x04, 0xF2, 0x9F, 0xC0, 0xC2, 0xCC, 0x4E, + 0x59, 0x1A, 0xAE, 0x73, 0x60, 0x66, 0x0D, 0x93, + 0xE2, 0x51, 0x5D, 0xDF, 0xDD, 0xF4, 0x52, 0x0F + }, + { + 0xD5, 0xEC, 0x3D, 0x80, 0x71, 0x3C, 0xC0, 0xB3, + 0x36, 0x78, 0xFD, 0x95, 0x25, 0x10, 0x21, 0x35, + 0x08, 0x5C, 0x3A, 0xFF, 0xF4, 0x44, 0xCE, 0x4E, + 0xB9, 0x83, 0xC5, 0xCD, 0x23, 0xA4, 0xAD, 0x49 + }, + { + 0x18, 0xDB, 0x3A, 0x87, 0xB8, 0x5A, 0x86, 0x15, + 0x02, 0x26, 0xD1, 0x8C, 0xC5, 0x1F, 0xC4, 0xFF, + 0xEE, 0xD2, 0xF9, 0x27, 0xD0, 0x35, 0x6D, 0x56, + 0x14, 0xB8, 0x7A, 0x93, 0x57, 0x90, 0x1A, 0x79 + }, + { + 0xD4, 0x5B, 0x31, 0xC4, 0xD6, 0x21, 0x2F, 0x7A, + 0x2E, 0xED, 0x1F, 0x3F, 0x4D, 0xAE, 0x6F, 0xE3, + 0x24, 0xAC, 0x3C, 0xD2, 0x0D, 0x47, 0xF2, 0x05, + 0x59, 0x2D, 0x50, 0xA6, 0x01, 0xAE, 0x80, 0xF4 + }, + { + 0x32, 0xBA, 0x12, 0xA6, 0x29, 0xC1, 0xD0, 0xA9, + 0xD5, 0xDF, 0xD8, 0x15, 0xB9, 0xDF, 0x51, 0x4C, + 0x8D, 0x4C, 0x29, 0xE0, 0x76, 0x91, 0x79, 0x10, + 0xE2, 0xA2, 0x8C, 0x92, 0xAD, 0x03, 0x73, 0xC3 + }, + { + 0xFC, 0x6D, 0x95, 0xA0, 0xC5, 0xC3, 0x37, 0x92, + 0x47, 0x8A, 0x63, 0x6C, 0xC2, 0x54, 0x16, 0xEB, + 0x39, 0x8B, 0x68, 0x72, 0xEB, 0x82, 0x55, 0x16, + 0x2F, 0x95, 0xF3, 0xCA, 0xCF, 0xC0, 0x13, 0xC2 + }, + { + 0x19, 0xCF, 0x8A, 0x22, 0x9E, 0x5E, 0x55, 0x9F, + 0x9B, 0x92, 0x55, 0xD4, 0x7F, 0x7F, 0xA4, 0x69, + 0x0A, 0x84, 0x44, 0x43, 0xFF, 0xAB, 0x59, 0x82, + 0x55, 0x77, 0x66, 0x75, 0xF2, 0x93, 0x8E, 0xCD + }, + { + 0x10, 0x20, 0x2D, 0x1C, 0xC6, 0x01, 0x2E, 0x58, + 0x08, 0x7E, 0x40, 0x56, 0xDD, 0x8B, 0xEF, 0x17, + 0xFF, 0xCF, 0x10, 0xA3, 0x54, 0x36, 0xAB, 0xF2, + 0xFB, 0xD2, 0xBD, 0xB6, 0x03, 0xD9, 0xC5, 0x55 + }, + { + 0x7A, 0x2E, 0x7D, 0xC0, 0x7B, 0x6D, 0x6F, 0xAA, + 0x76, 0xC2, 0xA2, 0xCB, 0x17, 0xAF, 0x99, 0xB9, + 0xD5, 0x6A, 0xF5, 0x1E, 0x49, 0xB5, 0x9C, 0x5A, + 0x76, 0xF2, 0x09, 0x2D, 0x97, 0xA2, 0x72, 0x1B + }, + { + 0xB3, 0xCB, 0x09, 0xA8, 0x27, 0x3A, 0x81, 0xDA, + 0xE2, 0x5A, 0x2F, 0xF0, 0x73, 0x1E, 0x86, 0xB6, + 0x27, 0x0A, 0x19, 0x16, 0x8C, 0xC9, 0x75, 0x8B, + 0x5A, 0xA3, 0x5D, 0x06, 0x29, 0x68, 0xF8, 0x55 + }, + { + 0xAB, 0x18, 0x0C, 0xD8, 0xCF, 0xBC, 0xBE, 0x72, + 0xC7, 0xF6, 0xED, 0x50, 0xD8, 0x9B, 0x62, 0x99, + 0x3F, 0x48, 0x7F, 0x65, 0x32, 0xDD, 0x70, 0x72, + 0xB0, 0x12, 0x4F, 0x21, 0xBD, 0xCC, 0x8D, 0xAD + }, + { + 0x84, 0x36, 0x74, 0xCE, 0x16, 0x34, 0x28, 0x39, + 0x66, 0xA8, 0x8A, 0xE4, 0xCD, 0xE3, 0x69, 0x51, + 0x8B, 0x47, 0x5C, 0x08, 0x98, 0xC1, 0xC5, 0xBD, + 0xD2, 0x3F, 0x20, 0x4C, 0xCA, 0x7F, 0x86, 0x45 + }, + { + 0x68, 0x31, 0x96, 0xEA, 0xC8, 0x8D, 0x98, 0x24, + 0xD0, 0x0B, 0x94, 0xDC, 0x4C, 0xFB, 0x4B, 0xCE, + 0x86, 0x3A, 0x4D, 0x58, 0x53, 0x8E, 0x9F, 0xC2, + 0xB2, 0x10, 0xD1, 0x2C, 0x8C, 0x2A, 0x08, 0x9F + }, + { + 0x5C, 0xCB, 0xA8, 0xD1, 0xD4, 0xEA, 0xFE, 0x06, + 0x37, 0x85, 0x7F, 0xD0, 0xD3, 0x36, 0xCC, 0x3A, + 0x1D, 0x92, 0xCE, 0xE2, 0xD6, 0x3F, 0x5C, 0x39, + 0x93, 0x66, 0x3C, 0x32, 0xD5, 0x17, 0x04, 0x7B + }, + { + 0xF4, 0x96, 0xF3, 0xC3, 0x14, 0x08, 0xF0, 0x8B, + 0x4F, 0xB4, 0xD6, 0xD7, 0x30, 0xDF, 0x50, 0x8D, + 0x50, 0xB9, 0x46, 0xA2, 0x0A, 0x51, 0x67, 0x5C, + 0xD7, 0x2B, 0x4C, 0x6B, 0x79, 0xFD, 0x8F, 0x49 + }, + { + 0x79, 0x3D, 0x48, 0x74, 0xE5, 0x3A, 0x19, 0x76, + 0xEB, 0xD6, 0x2C, 0xCA, 0x51, 0x2E, 0x83, 0x63, + 0x71, 0x86, 0xF1, 0xF1, 0x8F, 0x15, 0x07, 0x7C, + 0xE0, 0xD4, 0x32, 0x5A, 0x8C, 0x03, 0x6B, 0xEE + }, + { + 0xEE, 0x1E, 0x46, 0x60, 0x7E, 0x76, 0xDE, 0xDE, + 0x99, 0xAF, 0xAA, 0x9C, 0x2A, 0x46, 0x78, 0x21, + 0x3B, 0xDE, 0x2D, 0x17, 0x85, 0x31, 0xD4, 0x44, + 0xD7, 0xE2, 0xF5, 0x53, 0x5A, 0xF9, 0x1D, 0x54 + }, + { + 0xA2, 0x0A, 0xBA, 0x35, 0xFB, 0x4F, 0xE6, 0xAD, + 0x61, 0x50, 0x2F, 0xA2, 0x96, 0x3B, 0xBD, 0x96, + 0x4E, 0x2F, 0x17, 0x77, 0xDD, 0xFE, 0x7F, 0x73, + 0xC3, 0xE5, 0xE3, 0x17, 0xC5, 0x66, 0x9E, 0xAF + }, + { + 0xD2, 0x84, 0x0C, 0x25, 0x95, 0x9F, 0x05, 0x2E, + 0x94, 0x75, 0x43, 0x44, 0x11, 0xD1, 0x54, 0x5E, + 0x71, 0x9E, 0x03, 0x9B, 0x5E, 0x4F, 0x60, 0xD9, + 0x43, 0xF2, 0x9F, 0x91, 0x73, 0x67, 0x28, 0xAB + }, + { + 0xDD, 0x12, 0x85, 0x54, 0x01, 0x09, 0x12, 0x93, + 0x57, 0x9D, 0x63, 0x93, 0xA2, 0x5B, 0xAE, 0xB1, + 0xAD, 0x30, 0xE7, 0x79, 0x58, 0xC3, 0x39, 0x6C, + 0x67, 0x6E, 0x72, 0x42, 0xF3, 0x73, 0x79, 0x8F + }, + { + 0xF1, 0x84, 0x90, 0xEE, 0x83, 0xFD, 0x51, 0x61, + 0x67, 0xA7, 0xFF, 0x3A, 0x7F, 0xD1, 0x48, 0x57, + 0xE2, 0x63, 0x6B, 0x8F, 0xB4, 0x4D, 0x48, 0xDF, + 0xD1, 0x9A, 0x4B, 0xB0, 0x19, 0x99, 0x75, 0xC8 + }, + { + 0x3B, 0x68, 0x39, 0x61, 0x2A, 0xAC, 0x1C, 0xFD, + 0x42, 0xF5, 0x0E, 0x16, 0x8E, 0x87, 0x64, 0xFA, + 0xE7, 0x94, 0x98, 0x57, 0x18, 0xCA, 0x42, 0xAE, + 0x2B, 0xED, 0xC1, 0xC3, 0x13, 0x92, 0x9D, 0xB3 + }, + { + 0x05, 0xA9, 0xDD, 0x9F, 0xC5, 0xE5, 0xFC, 0xAA, + 0x5A, 0x9E, 0x1B, 0x3C, 0x27, 0x42, 0x5E, 0x81, + 0x86, 0x3E, 0x3E, 0x83, 0x1D, 0x79, 0xD0, 0x46, + 0xD6, 0x87, 0x4F, 0x07, 0xCB, 0xD5, 0x62, 0xC8 + }, + { + 0x11, 0x01, 0xC2, 0x57, 0x39, 0xBD, 0xC4, 0xEA, + 0xE7, 0xBF, 0x4B, 0xA5, 0x42, 0x93, 0x51, 0xC7, + 0x9C, 0xE2, 0x6B, 0x48, 0xAA, 0x04, 0xF0, 0xA3, + 0x5E, 0xAA, 0xDF, 0x48, 0x75, 0x03, 0x42, 0x80 + }, + { + 0x59, 0x49, 0x8D, 0x5C, 0xEC, 0x1B, 0x2E, 0xD5, + 0x10, 0xCB, 0xC7, 0xAF, 0x9E, 0xE3, 0x12, 0xE6, + 0xB1, 0x09, 0xF5, 0x4E, 0xD7, 0x10, 0xA5, 0xC5, + 0x16, 0xDD, 0x22, 0xA0, 0x79, 0xD3, 0x81, 0x5F + }, + { + 0xC6, 0xE8, 0x15, 0x92, 0x21, 0x9C, 0x66, 0xCC, + 0x07, 0x50, 0x3E, 0x3F, 0x70, 0xE5, 0xB5, 0x9A, + 0x68, 0xCC, 0x48, 0x38, 0xC8, 0xAE, 0x83, 0x11, + 0x75, 0x14, 0x33, 0x7B, 0x13, 0xB8, 0xC0, 0x52 + }, + { + 0x31, 0x89, 0xDC, 0xB7, 0x6D, 0x3B, 0xB8, 0xF6, + 0x03, 0x8C, 0x06, 0x07, 0xAE, 0xC4, 0xED, 0xF8, + 0x7F, 0xFC, 0x27, 0xCA, 0x46, 0x2D, 0xCB, 0x47, + 0x48, 0xBB, 0xAC, 0x36, 0x4C, 0x17, 0x1A, 0xDE + }, + { + 0xB6, 0xA3, 0x7A, 0xF4, 0xE4, 0x19, 0xBF, 0x10, + 0x46, 0x33, 0xC3, 0x33, 0xA9, 0xF2, 0xE4, 0x71, + 0x48, 0x61, 0x38, 0xA9, 0xD1, 0x0A, 0x17, 0xF7, + 0x00, 0x8A, 0x51, 0xF4, 0x19, 0x1E, 0xE9, 0x21 + }, + { + 0x51, 0x09, 0xC2, 0x44, 0x02, 0xA5, 0x9A, 0xA2, + 0x7A, 0xB4, 0xCC, 0x20, 0xB9, 0xA7, 0x1C, 0x93, + 0x15, 0x78, 0xD8, 0xD0, 0x41, 0xB3, 0x3C, 0xA0, + 0xAB, 0xEC, 0xA7, 0xF2, 0x0D, 0x85, 0x02, 0xB4 + }, + { + 0x8D, 0x96, 0x51, 0xBF, 0x5C, 0xBA, 0x34, 0xE4, + 0xBD, 0xB4, 0x9B, 0x01, 0x85, 0xF6, 0x73, 0x06, + 0xDF, 0xEF, 0xB7, 0x64, 0x06, 0x4F, 0x58, 0xCC, + 0x77, 0xD2, 0x2A, 0x6F, 0x93, 0x46, 0xFA, 0x09 + }, + { + 0x2F, 0x61, 0xAC, 0xAD, 0x19, 0x9F, 0xE4, 0x39, + 0x74, 0xD1, 0xF4, 0xD6, 0x3C, 0x6C, 0x1C, 0x77, + 0xFA, 0x0D, 0x5B, 0x0F, 0xEB, 0xF8, 0xDB, 0x40, + 0x85, 0xE2, 0x31, 0xB7, 0x8B, 0x66, 0x2F, 0x6B + }, + { + 0x6E, 0x7C, 0xF1, 0x85, 0xA5, 0xE4, 0x67, 0x61, + 0xE4, 0x49, 0xC5, 0x90, 0xAB, 0x1E, 0xBD, 0xF0, + 0xAE, 0xC0, 0xD6, 0x02, 0xD7, 0xA2, 0x10, 0x24, + 0x2C, 0x1B, 0x10, 0x87, 0xDB, 0x7E, 0x73, 0xA7 + }, + { + 0x75, 0xB4, 0xFE, 0x1A, 0x64, 0x2C, 0xC2, 0x9D, + 0x73, 0x1F, 0xCE, 0xA4, 0x1E, 0x28, 0x57, 0x9D, + 0x4F, 0x4D, 0x24, 0x67, 0xC6, 0x00, 0x04, 0xFA, + 0xD1, 0x2E, 0xCC, 0x73, 0x2C, 0x3E, 0x50, 0xC8 + }, + { + 0xDC, 0x86, 0xD7, 0x7C, 0x30, 0xF4, 0xBD, 0x0A, + 0x7E, 0x12, 0x30, 0x55, 0xE3, 0xBB, 0x6B, 0xCA, + 0xB8, 0x07, 0xB1, 0xB1, 0x68, 0x00, 0xE6, 0x8C, + 0x29, 0x8B, 0x0D, 0xFA, 0xE9, 0xB4, 0x71, 0x3D + }, + { + 0xF2, 0xD9, 0x5E, 0x28, 0xA7, 0xEC, 0xE9, 0x97, + 0xD2, 0xF9, 0xAE, 0xBA, 0xA1, 0xC7, 0xDB, 0x7B, + 0x73, 0x8B, 0x49, 0x80, 0x5A, 0xF1, 0x41, 0x7D, + 0xCA, 0x59, 0xB9, 0x73, 0xDC, 0xFE, 0x42, 0x98 + }, + { + 0x7D, 0x20, 0xA9, 0x0E, 0x14, 0x01, 0xC3, 0xE6, + 0x13, 0x43, 0x95, 0xAF, 0xE7, 0x72, 0x8D, 0x5D, + 0x0B, 0xB6, 0x39, 0xA7, 0x74, 0xB3, 0xDB, 0x7E, + 0x9D, 0x4A, 0xA1, 0x90, 0xBD, 0xB2, 0xFA, 0x58 + }, +}; + + + + +static const uint8_t blake2b_kat[BLAKE2_KAT_LENGTH][BLAKE2B_OUTBYTES] = +{ + { + 0x78, 0x6A, 0x02, 0xF7, 0x42, 0x01, 0x59, 0x03, + 0xC6, 0xC6, 0xFD, 0x85, 0x25, 0x52, 0xD2, 0x72, + 0x91, 0x2F, 0x47, 0x40, 0xE1, 0x58, 0x47, 0x61, + 0x8A, 0x86, 0xE2, 0x17, 0xF7, 0x1F, 0x54, 0x19, + 0xD2, 0x5E, 0x10, 0x31, 0xAF, 0xEE, 0x58, 0x53, + 0x13, 0x89, 0x64, 0x44, 0x93, 0x4E, 0xB0, 0x4B, + 0x90, 0x3A, 0x68, 0x5B, 0x14, 0x48, 0xB7, 0x55, + 0xD5, 0x6F, 0x70, 0x1A, 0xFE, 0x9B, 0xE2, 0xCE + }, + { + 0x2F, 0xA3, 0xF6, 0x86, 0xDF, 0x87, 0x69, 0x95, + 0x16, 0x7E, 0x7C, 0x2E, 0x5D, 0x74, 0xC4, 0xC7, + 0xB6, 0xE4, 0x8F, 0x80, 0x68, 0xFE, 0x0E, 0x44, + 0x20, 0x83, 0x44, 0xD4, 0x80, 0xF7, 0x90, 0x4C, + 0x36, 0x96, 0x3E, 0x44, 0x11, 0x5F, 0xE3, 0xEB, + 0x2A, 0x3A, 0xC8, 0x69, 0x4C, 0x28, 0xBC, 0xB4, + 0xF5, 0xA0, 0xF3, 0x27, 0x6F, 0x2E, 0x79, 0x48, + 0x7D, 0x82, 0x19, 0x05, 0x7A, 0x50, 0x6E, 0x4B + }, + { + 0x1C, 0x08, 0x79, 0x8D, 0xC6, 0x41, 0xAB, 0xA9, + 0xDE, 0xE4, 0x35, 0xE2, 0x25, 0x19, 0xA4, 0x72, + 0x9A, 0x09, 0xB2, 0xBF, 0xE0, 0xFF, 0x00, 0xEF, + 0x2D, 0xCD, 0x8E, 0xD6, 0xF8, 0xA0, 0x7D, 0x15, + 0xEA, 0xF4, 0xAE, 0xE5, 0x2B, 0xBF, 0x18, 0xAB, + 0x56, 0x08, 0xA6, 0x19, 0x0F, 0x70, 0xB9, 0x04, + 0x86, 0xC8, 0xA7, 0xD4, 0x87, 0x37, 0x10, 0xB1, + 0x11, 0x5D, 0x3D, 0xEB, 0xBB, 0x43, 0x27, 0xB5 + }, + { + 0x40, 0xA3, 0x74, 0x72, 0x73, 0x02, 0xD9, 0xA4, + 0x76, 0x9C, 0x17, 0xB5, 0xF4, 0x09, 0xFF, 0x32, + 0xF5, 0x8A, 0xA2, 0x4F, 0xF1, 0x22, 0xD7, 0x60, + 0x3E, 0x4F, 0xDA, 0x15, 0x09, 0xE9, 0x19, 0xD4, + 0x10, 0x7A, 0x52, 0xC5, 0x75, 0x70, 0xA6, 0xD9, + 0x4E, 0x50, 0x96, 0x7A, 0xEA, 0x57, 0x3B, 0x11, + 0xF8, 0x6F, 0x47, 0x3F, 0x53, 0x75, 0x65, 0xC6, + 0x6F, 0x70, 0x39, 0x83, 0x0A, 0x85, 0xD1, 0x86 + }, + { + 0x77, 0xDD, 0xF4, 0xB1, 0x44, 0x25, 0xEB, 0x3D, + 0x05, 0x3C, 0x1E, 0x84, 0xE3, 0x46, 0x9D, 0x92, + 0xC4, 0xCD, 0x91, 0x0E, 0xD2, 0x0F, 0x92, 0x03, + 0x5E, 0x0C, 0x99, 0xD8, 0xA7, 0xA8, 0x6C, 0xEC, + 0xAF, 0x69, 0xF9, 0x66, 0x3C, 0x20, 0xA7, 0xAA, + 0x23, 0x0B, 0xC8, 0x2F, 0x60, 0xD2, 0x2F, 0xB4, + 0xA0, 0x0B, 0x09, 0xD3, 0xEB, 0x8F, 0xC6, 0x5E, + 0xF5, 0x47, 0xFE, 0x63, 0xC8, 0xD3, 0xDD, 0xCE + }, + { + 0xCB, 0xAA, 0x0B, 0xA7, 0xD4, 0x82, 0xB1, 0xF3, + 0x01, 0x10, 0x9A, 0xE4, 0x10, 0x51, 0x99, 0x1A, + 0x32, 0x89, 0xBC, 0x11, 0x98, 0x00, 0x5A, 0xF2, + 0x26, 0xC5, 0xE4, 0xF1, 0x03, 0xB6, 0x65, 0x79, + 0xF4, 0x61, 0x36, 0x10, 0x44, 0xC8, 0xBA, 0x34, + 0x39, 0xFF, 0x12, 0xC5, 0x15, 0xFB, 0x29, 0xC5, + 0x21, 0x61, 0xB7, 0xEB, 0x9C, 0x28, 0x37, 0xB7, + 0x6A, 0x5D, 0xC3, 0x3F, 0x7C, 0xB2, 0xE2, 0xE8 + }, + { + 0xF9, 0x5D, 0x45, 0xCF, 0x69, 0xAF, 0x5C, 0x20, + 0x23, 0xBD, 0xB5, 0x05, 0x82, 0x1E, 0x62, 0xE8, + 0x5D, 0x7C, 0xAE, 0xDF, 0x7B, 0xED, 0xA1, 0x2C, + 0x02, 0x48, 0x77, 0x5B, 0x0C, 0x88, 0x20, 0x5E, + 0xEB, 0x35, 0xAF, 0x3A, 0x90, 0x81, 0x6F, 0x66, + 0x08, 0xCE, 0x7D, 0xD4, 0x4E, 0xC2, 0x8D, 0xB1, + 0x14, 0x06, 0x14, 0xE1, 0xDD, 0xEB, 0xF3, 0xAA, + 0x9C, 0xD1, 0x84, 0x3E, 0x0F, 0xAD, 0x2C, 0x36 + }, + { + 0x8F, 0x94, 0x5B, 0xA7, 0x00, 0xF2, 0x53, 0x0E, + 0x5C, 0x2A, 0x7D, 0xF7, 0xD5, 0xDC, 0xE0, 0xF8, + 0x3F, 0x9E, 0xFC, 0x78, 0xC0, 0x73, 0xFE, 0x71, + 0xAE, 0x1F, 0x88, 0x20, 0x4A, 0x4F, 0xD1, 0xCF, + 0x70, 0xA0, 0x73, 0xF5, 0xD1, 0xF9, 0x42, 0xED, + 0x62, 0x3A, 0xA1, 0x6E, 0x90, 0xA8, 0x71, 0x24, + 0x6C, 0x90, 0xC4, 0x5B, 0x62, 0x1B, 0x34, 0x01, + 0xA5, 0xDD, 0xBD, 0x9D, 0xF6, 0x26, 0x41, 0x65 + }, + { + 0xE9, 0x98, 0xE0, 0xDC, 0x03, 0xEC, 0x30, 0xEB, + 0x99, 0xBB, 0x6B, 0xFA, 0xAF, 0x66, 0x18, 0xAC, + 0xC6, 0x20, 0x32, 0x0D, 0x72, 0x20, 0xB3, 0xAF, + 0x2B, 0x23, 0xD1, 0x12, 0xD8, 0xE9, 0xCB, 0x12, + 0x62, 0xF3, 0xC0, 0xD6, 0x0D, 0x18, 0x3B, 0x1E, + 0xE7, 0xF0, 0x96, 0xD1, 0x2D, 0xAE, 0x42, 0xC9, + 0x58, 0x41, 0x86, 0x00, 0x21, 0x4D, 0x04, 0xF5, + 0xED, 0x6F, 0x5E, 0x71, 0x8B, 0xE3, 0x55, 0x66 + }, + { + 0x6A, 0x9A, 0x09, 0x0C, 0x61, 0xB3, 0x41, 0x0A, + 0xED, 0xE7, 0xEC, 0x91, 0x38, 0x14, 0x6C, 0xEB, + 0x2C, 0x69, 0x66, 0x2F, 0x46, 0x0C, 0x3D, 0xA5, + 0x3C, 0x65, 0x15, 0xC1, 0xEB, 0x31, 0xF4, 0x1C, + 0xA3, 0xD2, 0x80, 0xE5, 0x67, 0x88, 0x2F, 0x95, + 0xCF, 0x66, 0x4A, 0x94, 0x14, 0x7D, 0x78, 0xF4, + 0x2C, 0xFC, 0x71, 0x4A, 0x40, 0xD2, 0x2E, 0xF1, + 0x94, 0x70, 0xE0, 0x53, 0x49, 0x35, 0x08, 0xA2 + }, + { + 0x29, 0x10, 0x25, 0x11, 0xD7, 0x49, 0xDB, 0x3C, + 0xC9, 0xB4, 0xE3, 0x35, 0xFA, 0x1F, 0x5E, 0x8F, + 0xAC, 0xA8, 0x42, 0x1D, 0x55, 0x8F, 0x6A, 0x3F, + 0x33, 0x21, 0xD5, 0x0D, 0x04, 0x4A, 0x24, 0x8B, + 0xA5, 0x95, 0xCF, 0xC3, 0xEF, 0xD3, 0xD2, 0xAD, + 0xC9, 0x73, 0x34, 0xDA, 0x73, 0x24, 0x13, 0xF5, + 0xCB, 0xF4, 0x75, 0x1C, 0x36, 0x2B, 0xA1, 0xD5, + 0x38, 0x62, 0xAC, 0x1E, 0x8D, 0xAB, 0xEE, 0xE8 + }, + { + 0xC9, 0x7A, 0x47, 0x79, 0xD4, 0x7E, 0x6F, 0x77, + 0x72, 0x9B, 0x59, 0x17, 0xD0, 0x13, 0x8A, 0xBB, + 0x35, 0x98, 0x0A, 0xB6, 0x41, 0xBD, 0x73, 0xA8, + 0x85, 0x9E, 0xB1, 0xAC, 0x98, 0xC0, 0x53, 0x62, + 0xED, 0x7D, 0x60, 0x8F, 0x2E, 0x95, 0x87, 0xD6, + 0xBA, 0x9E, 0x27, 0x1D, 0x34, 0x31, 0x25, 0xD4, + 0x0D, 0x93, 0x3A, 0x8E, 0xD0, 0x4E, 0xC1, 0xFE, + 0x75, 0xEC, 0x40, 0x7C, 0x7A, 0x53, 0xC3, 0x4E + }, + { + 0x10, 0xF0, 0xDC, 0x91, 0xB9, 0xF8, 0x45, 0xFB, + 0x95, 0xFA, 0xD6, 0x86, 0x0E, 0x6C, 0xE1, 0xAD, + 0xFA, 0x00, 0x2C, 0x7F, 0xC3, 0x27, 0x11, 0x6D, + 0x44, 0xD0, 0x47, 0xCD, 0x7D, 0x58, 0x70, 0xD7, + 0x72, 0xBB, 0x12, 0xB5, 0xFA, 0xC0, 0x0E, 0x02, + 0xB0, 0x8A, 0xC2, 0xA0, 0x17, 0x4D, 0x04, 0x46, + 0xC3, 0x6A, 0xB3, 0x5F, 0x14, 0xCA, 0x31, 0x89, + 0x4C, 0xD6, 0x1C, 0x78, 0xC8, 0x49, 0xB4, 0x8A + }, + { + 0xDE, 0xA9, 0x10, 0x1C, 0xAC, 0x62, 0xB8, 0xF6, + 0xA3, 0xC6, 0x50, 0xF9, 0x0E, 0xEA, 0x5B, 0xFA, + 0xE2, 0x65, 0x3A, 0x4E, 0xAF, 0xD6, 0x3A, 0x6D, + 0x1F, 0x0F, 0x13, 0x2D, 0xB9, 0xE4, 0xF2, 0xB1, + 0xB6, 0x62, 0x43, 0x2E, 0xC8, 0x5B, 0x17, 0xBC, + 0xAC, 0x41, 0xE7, 0x75, 0x63, 0x78, 0x81, 0xF6, + 0xAA, 0xB3, 0x8D, 0xD6, 0x6D, 0xCB, 0xD0, 0x80, + 0xF0, 0x99, 0x0A, 0x7A, 0x6E, 0x98, 0x54, 0xFE + }, + { + 0x44, 0x1F, 0xFA, 0xA0, 0x8C, 0xD7, 0x9D, 0xFF, + 0x4A, 0xFC, 0x9B, 0x9E, 0x5B, 0x56, 0x20, 0xEE, + 0xC0, 0x86, 0x73, 0x0C, 0x25, 0xF6, 0x61, 0xB1, + 0xD6, 0xFB, 0xFB, 0xD1, 0xCE, 0xC3, 0x14, 0x8D, + 0xD7, 0x22, 0x58, 0xC6, 0x56, 0x41, 0xF2, 0xFC, + 0xA5, 0xEB, 0x15, 0x5F, 0xAD, 0xBC, 0xAB, 0xB1, + 0x3C, 0x6E, 0x21, 0xDC, 0x11, 0xFA, 0xF7, 0x2C, + 0x2A, 0x28, 0x1B, 0x7D, 0x56, 0x14, 0x5F, 0x19 + }, + { + 0x44, 0x4B, 0x24, 0x0F, 0xE3, 0xED, 0x86, 0xD0, + 0xE2, 0xEF, 0x4C, 0xE7, 0xD8, 0x51, 0xED, 0xDE, + 0x22, 0x15, 0x55, 0x82, 0xAA, 0x09, 0x14, 0x79, + 0x7B, 0x72, 0x6C, 0xD0, 0x58, 0xB6, 0xF4, 0x59, + 0x32, 0xE0, 0xE1, 0x29, 0x51, 0x68, 0x76, 0x52, + 0x7B, 0x1D, 0xD8, 0x8F, 0xC6, 0x6D, 0x71, 0x19, + 0xF4, 0xAB, 0x3B, 0xED, 0x93, 0xA6, 0x1A, 0x0E, + 0x2D, 0x2D, 0x2A, 0xEA, 0xC3, 0x36, 0xD9, 0x58 + }, + { + 0xBF, 0xBA, 0xBB, 0xEF, 0x45, 0x55, 0x4C, 0xCF, + 0xA0, 0xDC, 0x83, 0x75, 0x2A, 0x19, 0xCC, 0x35, + 0xD5, 0x92, 0x09, 0x56, 0xB3, 0x01, 0xD5, 0x58, + 0xD7, 0x72, 0x28, 0x2B, 0xC8, 0x67, 0x00, 0x91, + 0x68, 0xE9, 0xE9, 0x86, 0x06, 0xBB, 0x5B, 0xA7, + 0x3A, 0x38, 0x5D, 0xE5, 0x74, 0x92, 0x28, 0xC9, + 0x25, 0xA8, 0x50, 0x19, 0xB7, 0x1F, 0x72, 0xFE, + 0x29, 0xB3, 0xCD, 0x37, 0xCA, 0x52, 0xEF, 0xE6 + }, + { + 0x9C, 0x4D, 0x0C, 0x3E, 0x1C, 0xDB, 0xBF, 0x48, + 0x5B, 0xEC, 0x86, 0xF4, 0x1C, 0xEC, 0x7C, 0x98, + 0x37, 0x3F, 0x0E, 0x09, 0xF3, 0x92, 0x84, 0x9A, + 0xAA, 0x22, 0x9E, 0xBF, 0xBF, 0x39, 0x7B, 0x22, + 0x08, 0x55, 0x29, 0xCB, 0x7E, 0xF3, 0x9F, 0x9C, + 0x7C, 0x22, 0x22, 0xA5, 0x14, 0x18, 0x2B, 0x1E, + 0xFF, 0xAA, 0x17, 0x8C, 0xC3, 0x68, 0x7B, 0x1B, + 0x2B, 0x6C, 0xBC, 0xB6, 0xFD, 0xEB, 0x96, 0xF8 + }, + { + 0x47, 0x71, 0x76, 0xB3, 0xBF, 0xCB, 0xAD, 0xD7, + 0x65, 0x7C, 0x23, 0xC2, 0x46, 0x25, 0xE4, 0xD0, + 0xD6, 0x74, 0xD1, 0x86, 0x8F, 0x00, 0x60, 0x06, + 0x39, 0x8A, 0xF9, 0x7A, 0xA4, 0x18, 0x77, 0xC8, + 0xE7, 0x0D, 0x3D, 0x14, 0xC3, 0xBB, 0xC9, 0xBB, + 0xCD, 0xCE, 0xA8, 0x01, 0xBD, 0x0E, 0x15, 0x99, + 0xAF, 0x1F, 0x3E, 0xEC, 0x67, 0x40, 0x51, 0x70, + 0xF4, 0xE2, 0x6C, 0x96, 0x4A, 0x57, 0xA8, 0xB7 + }, + { + 0xA7, 0x8C, 0x49, 0x0E, 0xDA, 0x31, 0x73, 0xBB, + 0x3F, 0x10, 0xDE, 0xE5, 0x2F, 0x11, 0x0F, 0xB1, + 0xC0, 0x8E, 0x03, 0x02, 0x23, 0x0B, 0x85, 0xDD, + 0xD7, 0xC1, 0x12, 0x57, 0xD9, 0x2D, 0xE1, 0x48, + 0x78, 0x5E, 0xF0, 0x0C, 0x03, 0x9C, 0x0B, 0xB8, + 0xEB, 0x98, 0x08, 0xA3, 0x5B, 0x2D, 0x8C, 0x08, + 0x0F, 0x57, 0x28, 0x59, 0x71, 0x4C, 0x9D, 0x40, + 0x69, 0xC5, 0xBC, 0xAF, 0x09, 0x0E, 0x89, 0x8E + }, + { + 0x58, 0xD0, 0x23, 0x39, 0x7B, 0xEB, 0x5B, 0x41, + 0x45, 0xCB, 0x22, 0x55, 0xB0, 0x7D, 0x74, 0x29, + 0x0B, 0x36, 0xD9, 0xFD, 0x1E, 0x59, 0x4A, 0xFB, + 0xD8, 0xEE, 0xA4, 0x7C, 0x20, 0x5B, 0x2E, 0xFB, + 0xFE, 0x6F, 0x46, 0x19, 0x0F, 0xAF, 0x95, 0xAF, + 0x50, 0x4A, 0xB0, 0x72, 0xE3, 0x6F, 0x6C, 0x85, + 0xD7, 0x67, 0xA3, 0x21, 0xBF, 0xD7, 0xF2, 0x26, + 0x87, 0xA4, 0xAB, 0xBF, 0x49, 0x4A, 0x68, 0x9C + }, + { + 0x40, 0x01, 0xEC, 0x74, 0xD5, 0xA4, 0x6F, 0xD2, + 0x9C, 0x2C, 0x3C, 0xDB, 0xE5, 0xD1, 0xB9, 0xF2, + 0x0E, 0x51, 0xA9, 0x41, 0xBE, 0x98, 0xD2, 0xA4, + 0xE1, 0xE2, 0xFB, 0xF8, 0x66, 0xA6, 0x72, 0x12, + 0x1D, 0xB6, 0xF8, 0x1A, 0x51, 0x4C, 0xFD, 0x10, + 0xE7, 0x35, 0x8D, 0x57, 0x1B, 0xDB, 0xA4, 0x8E, + 0x4C, 0xE7, 0x08, 0xB9, 0xD1, 0x24, 0x89, 0x4B, + 0xC0, 0xB5, 0xED, 0x55, 0x49, 0x35, 0xF7, 0x3A + }, + { + 0xCC, 0xD1, 0xB2, 0x2D, 0xAB, 0x65, 0x11, 0x22, + 0x5D, 0x24, 0x01, 0xEA, 0x2D, 0x86, 0x25, 0xD2, + 0x06, 0xA1, 0x24, 0x73, 0xCC, 0x73, 0x2B, 0x61, + 0x5E, 0x56, 0x40, 0xCE, 0xFF, 0xF0, 0xA4, 0xAD, + 0xF9, 0x71, 0xB0, 0xE8, 0x27, 0xA6, 0x19, 0xE0, + 0xA8, 0x0F, 0x5D, 0xB9, 0xCC, 0xD0, 0x96, 0x23, + 0x29, 0x01, 0x0D, 0x07, 0xE3, 0x4A, 0x20, 0x64, + 0xE7, 0x31, 0xC5, 0x20, 0x81, 0x7B, 0x21, 0x83 + }, + { + 0xB4, 0xA0, 0xA9, 0xE3, 0x57, 0x4E, 0xDB, 0x9E, + 0x1E, 0x72, 0xAA, 0x31, 0xE3, 0x9C, 0xC5, 0xF3, + 0x0D, 0xBF, 0x94, 0x3F, 0x8C, 0xAB, 0xC4, 0x08, + 0x44, 0x96, 0x54, 0xA3, 0x91, 0x31, 0xE6, 0x6D, + 0x71, 0x8A, 0x18, 0x81, 0x91, 0x43, 0xE3, 0xEA, + 0x96, 0xB4, 0xA1, 0x89, 0x59, 0x88, 0xA1, 0xC0, + 0x05, 0x6C, 0xF2, 0xB6, 0xE0, 0x4F, 0x9A, 0xC1, + 0x9D, 0x65, 0x73, 0x83, 0xC2, 0x91, 0x0C, 0x44 + }, + { + 0x44, 0x7B, 0xEC, 0xAB, 0x16, 0x63, 0x06, 0x08, + 0xD3, 0x9F, 0x4F, 0x05, 0x8B, 0x16, 0xF7, 0xAF, + 0x95, 0xB8, 0x5A, 0x76, 0xAA, 0x0F, 0xA7, 0xCE, + 0xA2, 0xB8, 0x07, 0x55, 0xFB, 0x76, 0xE9, 0xC8, + 0x04, 0xF2, 0xCA, 0x78, 0xF0, 0x26, 0x43, 0xC9, + 0x15, 0xFB, 0xF2, 0xFC, 0xE5, 0xE1, 0x9D, 0xE8, + 0x60, 0x00, 0xDE, 0x03, 0xB1, 0x88, 0x61, 0x81, + 0x5A, 0x83, 0x12, 0x60, 0x71, 0xF8, 0xA3, 0x7B + }, + { + 0x54, 0xE6, 0xDA, 0xB9, 0x97, 0x73, 0x80, 0xA5, + 0x66, 0x58, 0x22, 0xDB, 0x93, 0x37, 0x4E, 0xDA, + 0x52, 0x8D, 0x9B, 0xEB, 0x62, 0x6F, 0x9B, 0x94, + 0x02, 0x70, 0x71, 0xCB, 0x26, 0x67, 0x5E, 0x11, + 0x2B, 0x4A, 0x7F, 0xEC, 0x94, 0x1E, 0xE6, 0x0A, + 0x81, 0xE4, 0xD2, 0xEA, 0x3F, 0xF7, 0xBC, 0x52, + 0xCF, 0xC4, 0x5D, 0xFB, 0xFE, 0x73, 0x5A, 0x1C, + 0x64, 0x6B, 0x2C, 0xF6, 0xD6, 0xA4, 0x9B, 0x62 + }, + { + 0x3E, 0xA6, 0x26, 0x25, 0x94, 0x9E, 0x36, 0x46, + 0x70, 0x4D, 0x7E, 0x3C, 0x90, 0x6F, 0x82, 0xF6, + 0xC0, 0x28, 0xF5, 0x40, 0xF5, 0xF7, 0x2A, 0x79, + 0x4B, 0x0C, 0x57, 0xBF, 0x97, 0xB7, 0x64, 0x9B, + 0xFE, 0xB9, 0x0B, 0x01, 0xD3, 0xCA, 0x3E, 0x82, + 0x9D, 0xE2, 0x1B, 0x38, 0x26, 0xE6, 0xF8, 0x70, + 0x14, 0xD3, 0xC7, 0x73, 0x50, 0xCB, 0x5A, 0x15, + 0xFF, 0x5D, 0x46, 0x8A, 0x81, 0xBE, 0xC1, 0x60 + }, + { + 0x21, 0x3C, 0xFE, 0x14, 0x5C, 0x54, 0xA3, 0x36, + 0x91, 0x56, 0x99, 0x80, 0xE5, 0x93, 0x8C, 0x88, + 0x83, 0xA4, 0x6D, 0x84, 0xD1, 0x49, 0xC8, 0xFF, + 0x1A, 0x67, 0xCD, 0x28, 0x7B, 0x4D, 0x49, 0xC6, + 0xDA, 0x69, 0xD3, 0xA0, 0x35, 0x44, 0x3D, 0xB0, + 0x85, 0x98, 0x3D, 0x0E, 0xFE, 0x63, 0x70, 0x6B, + 0xD5, 0xB6, 0xF1, 0x5A, 0x7D, 0xA4, 0x59, 0xE8, + 0xD5, 0x0A, 0x19, 0x09, 0x3D, 0xB5, 0x5E, 0x80 + }, + { + 0x57, 0x16, 0xC4, 0xA3, 0x8F, 0x38, 0xDB, 0x10, + 0x4E, 0x49, 0x4A, 0x0A, 0x27, 0xCB, 0xE8, 0x9A, + 0x26, 0xA6, 0xBB, 0x6F, 0x49, 0x9E, 0xC0, 0x1C, + 0x8C, 0x01, 0xAA, 0x7C, 0xB8, 0x84, 0x97, 0xE7, + 0x51, 0x48, 0xCD, 0x6E, 0xEE, 0x12, 0xA7, 0x16, + 0x8B, 0x6F, 0x78, 0xAB, 0x74, 0xE4, 0xBE, 0x74, + 0x92, 0x51, 0xA1, 0xA7, 0x4C, 0x38, 0xC8, 0x6D, + 0x61, 0x29, 0x17, 0x7E, 0x28, 0x89, 0xE0, 0xB6 + }, + { + 0x03, 0x04, 0x60, 0xA9, 0x8B, 0xDF, 0x9F, 0xF1, + 0x7C, 0xD9, 0x64, 0x04, 0xF2, 0x8F, 0xC3, 0x04, + 0xF2, 0xB7, 0xC0, 0x4E, 0xAA, 0xDE, 0x53, 0x67, + 0x7F, 0xD2, 0x8F, 0x78, 0x8C, 0xA2, 0x21, 0x86, + 0xB8, 0xBC, 0x80, 0xDD, 0x21, 0xD1, 0x7F, 0x85, + 0x49, 0xC7, 0x11, 0xAF, 0xF0, 0xE5, 0x14, 0xE1, + 0x9D, 0x4E, 0x15, 0xF5, 0x99, 0x02, 0x52, 0xA0, + 0x3E, 0x08, 0x2F, 0x28, 0xDC, 0x20, 0x52, 0xF6 + }, + { + 0x19, 0xE7, 0xF1, 0xCC, 0xEE, 0x88, 0xA1, 0x06, + 0x72, 0x33, 0x3E, 0x39, 0x0C, 0xF2, 0x20, 0x13, + 0xA8, 0xC7, 0x34, 0xC6, 0xCB, 0x9E, 0xAB, 0x41, + 0xF1, 0x7C, 0x3C, 0x80, 0x32, 0xA2, 0xE4, 0xAC, + 0xA0, 0x56, 0x9E, 0xA3, 0x6F, 0x08, 0x60, 0xC7, + 0xA1, 0xAF, 0x28, 0xFA, 0x47, 0x68, 0x40, 0xD6, + 0x60, 0x11, 0x16, 0x88, 0x59, 0x33, 0x4A, 0x9E, + 0x4E, 0xF9, 0xCC, 0x2E, 0x61, 0xA0, 0xE2, 0x9E + }, + { + 0x29, 0xF8, 0xB8, 0xC7, 0x8C, 0x80, 0xF2, 0xFC, + 0xB4, 0xBD, 0xF7, 0x82, 0x5E, 0xD9, 0x0A, 0x70, + 0xD6, 0x25, 0xFF, 0x78, 0x5D, 0x26, 0x26, 0x77, + 0xE2, 0x50, 0xC0, 0x4F, 0x37, 0x20, 0xC8, 0x88, + 0xD0, 0x3F, 0x80, 0x45, 0xE4, 0xED, 0xF3, 0xF5, + 0x28, 0x5B, 0xD3, 0x9D, 0x92, 0x8A, 0x10, 0xA7, + 0xD0, 0xA5, 0xDF, 0x00, 0xB8, 0x48, 0x4A, 0xC2, + 0x86, 0x81, 0x42, 0xA1, 0xE8, 0xBE, 0xA3, 0x51 + }, + { + 0x5C, 0x52, 0x92, 0x0A, 0x72, 0x63, 0xE3, 0x9D, + 0x57, 0x92, 0x0C, 0xA0, 0xCB, 0x75, 0x2A, 0xC6, + 0xD7, 0x9A, 0x04, 0xFE, 0xF8, 0xA7, 0xA2, 0x16, + 0xA1, 0xEC, 0xB7, 0x11, 0x5C, 0xE0, 0x6D, 0x89, + 0xFD, 0x7D, 0x73, 0x5B, 0xD6, 0xF4, 0x27, 0x25, + 0x55, 0xDB, 0xA2, 0x2C, 0x2D, 0x1C, 0x96, 0xE6, + 0x35, 0x23, 0x22, 0xC6, 0x2C, 0x56, 0x30, 0xFD, + 0xE0, 0xF4, 0x77, 0x7A, 0x76, 0xC3, 0xDE, 0x2C + }, + { + 0x83, 0xB0, 0x98, 0xF2, 0x62, 0x25, 0x1B, 0xF6, + 0x60, 0x06, 0x4A, 0x9D, 0x35, 0x11, 0xCE, 0x76, + 0x87, 0xA0, 0x9E, 0x6D, 0xFB, 0xB8, 0x78, 0x29, + 0x9C, 0x30, 0xE9, 0x3D, 0xFB, 0x43, 0xA9, 0x31, + 0x4D, 0xB9, 0xA6, 0x00, 0x33, 0x7D, 0xB2, 0x6E, + 0xBE, 0xED, 0xAF, 0x22, 0x56, 0xA9, 0x6D, 0xAB, + 0xE9, 0xB2, 0x9E, 0x75, 0x73, 0xAD, 0x11, 0xC3, + 0x52, 0x3D, 0x87, 0x4D, 0xDE, 0x5B, 0xE7, 0xED + }, + { + 0x94, 0x47, 0xD9, 0x8A, 0xA5, 0xC9, 0x33, 0x13, + 0x52, 0xF4, 0x3D, 0x3E, 0x56, 0xD0, 0xA9, 0xA9, + 0xF9, 0x58, 0x18, 0x65, 0x99, 0x8E, 0x28, 0x85, + 0xCC, 0x56, 0xDD, 0x0A, 0x0B, 0xD5, 0xA7, 0xB5, + 0x05, 0x95, 0xBD, 0x10, 0xF7, 0x52, 0x9B, 0xCD, + 0x31, 0xF3, 0x7D, 0xC1, 0x6A, 0x14, 0x65, 0xD5, + 0x94, 0x07, 0x96, 0x67, 0xDA, 0x2A, 0x3F, 0xCB, + 0x70, 0x40, 0x14, 0x98, 0x83, 0x7C, 0xED, 0xEB + }, + { + 0x86, 0x77, 0x32, 0xF2, 0xFE, 0xEB, 0x23, 0x89, + 0x30, 0x97, 0x56, 0x1A, 0xC7, 0x10, 0xA4, 0xBF, + 0xF4, 0x53, 0xBE, 0x9C, 0xFB, 0xED, 0xBA, 0x8B, + 0xA3, 0x24, 0xF9, 0xD3, 0x12, 0xA8, 0x2D, 0x73, + 0x2E, 0x1B, 0x83, 0xB8, 0x29, 0xFD, 0xCD, 0x17, + 0x7B, 0x88, 0x2C, 0xA0, 0xC1, 0xBF, 0x54, 0x4B, + 0x22, 0x3B, 0xE5, 0x29, 0x92, 0x4A, 0x24, 0x6A, + 0x63, 0xCF, 0x05, 0x9B, 0xFD, 0xC5, 0x0A, 0x1B + }, + { + 0xF1, 0x5A, 0xB2, 0x6D, 0x4C, 0xDF, 0xCF, 0x56, + 0xE1, 0x96, 0xBB, 0x6B, 0xA1, 0x70, 0xA8, 0xFC, + 0xCC, 0x41, 0x4D, 0xE9, 0x28, 0x5A, 0xFD, 0x98, + 0xA3, 0xD3, 0xCF, 0x2F, 0xB8, 0x8F, 0xCB, 0xC0, + 0xF1, 0x98, 0x32, 0xAC, 0x43, 0x3A, 0x5B, 0x2C, + 0xC2, 0x39, 0x2A, 0x4C, 0xE3, 0x43, 0x32, 0x98, + 0x7D, 0x8D, 0x2C, 0x2B, 0xEF, 0x6C, 0x34, 0x66, + 0x13, 0x8D, 0xB0, 0xC6, 0xE4, 0x2F, 0xA4, 0x7B + }, + { + 0x28, 0x13, 0x51, 0x6D, 0x68, 0xED, 0x4A, 0x08, + 0xB3, 0x9D, 0x64, 0x8A, 0xA6, 0xAA, 0xCD, 0x81, + 0xE9, 0xD6, 0x55, 0xEC, 0xD5, 0xF0, 0xC1, 0x35, + 0x56, 0xC6, 0x0F, 0xDF, 0x0D, 0x33, 0x3E, 0xA3, + 0x84, 0x64, 0xB3, 0x6C, 0x02, 0xBA, 0xCC, 0xD7, + 0x46, 0xE9, 0x57, 0x5E, 0x96, 0xC6, 0x30, 0x14, + 0xF0, 0x74, 0xAE, 0x34, 0xA0, 0xA2, 0x5B, 0x32, + 0x0F, 0x0F, 0xBE, 0xDD, 0x6A, 0xCF, 0x76, 0x65 + }, + { + 0xD3, 0x25, 0x9A, 0xFC, 0xA8, 0xA4, 0x89, 0x62, + 0xFA, 0x89, 0x2E, 0x14, 0x5A, 0xCF, 0x54, 0x7F, + 0x26, 0x92, 0x3A, 0xE8, 0xD4, 0x92, 0x4C, 0x8A, + 0x53, 0x15, 0x81, 0x52, 0x6B, 0x04, 0xB4, 0x4C, + 0x7A, 0xF8, 0x3C, 0x64, 0x3E, 0xF5, 0xA0, 0xBC, + 0x28, 0x2D, 0x36, 0xF3, 0xFB, 0x04, 0xC8, 0x4E, + 0x28, 0xB3, 0x51, 0xF4, 0x0C, 0x74, 0xB6, 0x9D, + 0xC7, 0x84, 0x0B, 0xC7, 0x17, 0xB6, 0xF1, 0x5F + }, + { + 0xF1, 0x4B, 0x06, 0x1A, 0xE3, 0x59, 0xFA, 0x31, + 0xB9, 0x89, 0xE3, 0x03, 0x32, 0xBF, 0xE8, 0xDE, + 0x8C, 0xC8, 0xCD, 0xB5, 0x68, 0xE1, 0x4B, 0xE2, + 0x14, 0xA2, 0x22, 0x3B, 0x84, 0xCA, 0xAB, 0x74, + 0x19, 0x54, 0x9E, 0xCF, 0xCC, 0x96, 0xCE, 0x2A, + 0xCE, 0xC1, 0x19, 0x48, 0x5D, 0x87, 0xD1, 0x57, + 0xD3, 0xA8, 0x73, 0x4F, 0xC4, 0x26, 0x59, 0x7D, + 0x64, 0xF3, 0x65, 0x70, 0xCE, 0xAF, 0x22, 0x4D + }, + { + 0x55, 0xE7, 0x0B, 0x01, 0xD1, 0xFB, 0xF8, 0xB2, + 0x3B, 0x57, 0xFB, 0x62, 0xE2, 0x6C, 0x2C, 0xE5, + 0x4F, 0x13, 0xF8, 0xFA, 0x24, 0x64, 0xE6, 0xEB, + 0x98, 0xD1, 0x6A, 0x61, 0x17, 0x02, 0x6D, 0x8B, + 0x90, 0x81, 0x90, 0x12, 0x49, 0x6D, 0x40, 0x71, + 0xEB, 0xE2, 0xE5, 0x95, 0x57, 0xEC, 0xE3, 0x51, + 0x9A, 0x7A, 0xA4, 0x58, 0x02, 0xF9, 0x61, 0x53, + 0x74, 0x87, 0x73, 0x32, 0xB7, 0x34, 0x90, 0xB3 + }, + { + 0x25, 0x26, 0x1E, 0xB2, 0x96, 0x97, 0x1D, 0x6E, + 0x4A, 0x71, 0xB2, 0x92, 0x8E, 0x64, 0x83, 0x9C, + 0x67, 0xD4, 0x22, 0x87, 0x2B, 0xF9, 0xF3, 0xC3, + 0x19, 0x93, 0x61, 0x52, 0x22, 0xDE, 0x9F, 0x8F, + 0x0B, 0x2C, 0x4B, 0xE8, 0x54, 0x85, 0x59, 0xB4, + 0xB3, 0x54, 0xE7, 0x36, 0x41, 0x6E, 0x32, 0x18, + 0xD4, 0xE8, 0xA1, 0xE2, 0x19, 0xA4, 0xA6, 0xD4, + 0x3E, 0x1A, 0x9A, 0x52, 0x1D, 0x0E, 0x75, 0xFC + }, + { + 0x08, 0x30, 0x7F, 0x34, 0x7C, 0x41, 0x29, 0x4E, + 0x34, 0xBB, 0x54, 0xCB, 0x42, 0xB1, 0x52, 0x2D, + 0x22, 0xF8, 0x24, 0xF7, 0xB6, 0xE5, 0xDB, 0x50, + 0xFD, 0xA0, 0x96, 0x79, 0x8E, 0x18, 0x1A, 0x8F, + 0x02, 0x6F, 0xA2, 0x7B, 0x4A, 0xE4, 0x5D, 0x52, + 0xA6, 0x2C, 0xAF, 0x9D, 0x51, 0x98, 0xE2, 0x4A, + 0x49, 0x13, 0xC6, 0x67, 0x17, 0x75, 0xB2, 0xD7, + 0x23, 0xC1, 0x23, 0x9B, 0xFB, 0xF0, 0x16, 0xD7 + }, + { + 0x1E, 0x5C, 0x62, 0xE7, 0xE9, 0xBF, 0xA1, 0xB1, + 0x18, 0x74, 0x7A, 0x2D, 0xE0, 0x8B, 0x3C, 0xA1, + 0x01, 0x12, 0xAF, 0x96, 0xA4, 0x6E, 0x4B, 0x22, + 0xC3, 0xFC, 0x06, 0xF9, 0xBF, 0xEE, 0x4E, 0xB5, + 0xC4, 0x9E, 0x05, 0x7A, 0x4A, 0x48, 0x86, 0x23, + 0x43, 0x24, 0x57, 0x25, 0x76, 0xBB, 0x9B, 0x5E, + 0xCF, 0xDE, 0x0D, 0x99, 0xB0, 0xDE, 0x4F, 0x98, + 0xEC, 0x16, 0xE4, 0xD1, 0xB8, 0x5F, 0xA9, 0x47 + }, + { + 0xC7, 0x4A, 0x77, 0x39, 0x5F, 0xB8, 0xBC, 0x12, + 0x64, 0x47, 0x45, 0x48, 0x38, 0xE5, 0x61, 0xE9, + 0x62, 0x85, 0x3D, 0xC7, 0xEB, 0x49, 0xA1, 0xE3, + 0xCB, 0x67, 0xC3, 0xD0, 0x85, 0x1F, 0x3E, 0x39, + 0x51, 0x7B, 0xE8, 0xC3, 0x50, 0xAC, 0x91, 0x09, + 0x03, 0xD4, 0x9C, 0xD2, 0xBF, 0xDF, 0x54, 0x5C, + 0x99, 0x31, 0x6D, 0x03, 0x46, 0x17, 0x0B, 0x73, + 0x9F, 0x0A, 0xDD, 0x5D, 0x53, 0x3C, 0x2C, 0xFC + }, + { + 0x0D, 0xD5, 0x7B, 0x42, 0x3C, 0xC0, 0x1E, 0xB2, + 0x86, 0x13, 0x91, 0xEB, 0x88, 0x6A, 0x0D, 0x17, + 0x07, 0x9B, 0x93, 0x3F, 0xC7, 0x6E, 0xB3, 0xFC, + 0x08, 0xA1, 0x9F, 0x8A, 0x74, 0x95, 0x2C, 0xB6, + 0x8F, 0x6B, 0xCD, 0xC6, 0x44, 0xF7, 0x73, 0x70, + 0x96, 0x6E, 0x4D, 0x13, 0xE8, 0x05, 0x60, 0xBC, + 0xF0, 0x82, 0xEF, 0x04, 0x79, 0xD4, 0x8F, 0xBB, + 0xAB, 0x4D, 0xF0, 0x3B, 0x53, 0xA4, 0xE1, 0x78 + }, + { + 0x4D, 0x8D, 0xC3, 0x92, 0x3E, 0xDC, 0xCD, 0xFC, + 0xE7, 0x00, 0x72, 0x39, 0x8B, 0x8A, 0x3D, 0xA5, + 0xC3, 0x1F, 0xCB, 0x3E, 0xE3, 0xB6, 0x45, 0xC8, + 0x5F, 0x71, 0x7C, 0xBA, 0xEB, 0x4B, 0x67, 0x3A, + 0x19, 0x39, 0x44, 0x25, 0xA5, 0x85, 0xBF, 0xB4, + 0x64, 0xD9, 0x2F, 0x15, 0x97, 0xD0, 0xB7, 0x54, + 0xD1, 0x63, 0xF9, 0x7C, 0xED, 0x34, 0x3B, 0x25, + 0xDB, 0x5A, 0x70, 0xEF, 0x48, 0xEB, 0xB3, 0x4F + }, + { + 0xF0, 0xA5, 0x05, 0x53, 0xE4, 0xDF, 0xB0, 0xC4, + 0xE3, 0xE3, 0xD3, 0xBA, 0x82, 0x03, 0x48, 0x57, + 0xE3, 0xB1, 0xE5, 0x09, 0x18, 0xF5, 0xB8, 0xA7, + 0xD6, 0x98, 0xE1, 0x0D, 0x24, 0x2B, 0x0F, 0xB5, + 0x44, 0xAF, 0x6C, 0x92, 0xD0, 0xC3, 0xAA, 0xF9, + 0x93, 0x22, 0x20, 0x41, 0x61, 0x17, 0xB4, 0xE7, + 0x8E, 0xCB, 0x8A, 0x8F, 0x43, 0x0E, 0x13, 0xB8, + 0x2A, 0x59, 0x15, 0x29, 0x0A, 0x58, 0x19, 0xC5 + }, + { + 0xB1, 0x55, 0x43, 0xF3, 0xF7, 0x36, 0x08, 0x66, + 0x27, 0xCC, 0x53, 0x65, 0xE7, 0xE8, 0x98, 0x8C, + 0x2E, 0xF1, 0x55, 0xC0, 0xFD, 0x4F, 0x42, 0x89, + 0x61, 0xB0, 0x0D, 0x15, 0x26, 0xF0, 0x4D, 0x6D, + 0x6A, 0x65, 0x8B, 0x4B, 0x8E, 0xD3, 0x2C, 0x5D, + 0x86, 0x21, 0xE7, 0xF4, 0xF8, 0xE8, 0xA9, 0x33, + 0xD9, 0xEC, 0xC9, 0xDD, 0x1B, 0x83, 0x33, 0xCB, + 0xE2, 0x8C, 0xFC, 0x37, 0xD9, 0x71, 0x9E, 0x1C + }, + { + 0x7B, 0x4F, 0xA1, 0x58, 0xE4, 0x15, 0xFE, 0xF0, + 0x23, 0x24, 0x72, 0x64, 0xCB, 0xBE, 0x15, 0xD1, + 0x6D, 0x91, 0xA4, 0x44, 0x24, 0xA8, 0xDB, 0x70, + 0x7E, 0xB1, 0xE2, 0x03, 0x3C, 0x30, 0xE9, 0xE1, + 0xE7, 0xC8, 0xC0, 0x86, 0x45, 0x95, 0xD2, 0xCB, + 0x8C, 0x58, 0x0E, 0xB4, 0x7E, 0x9D, 0x16, 0xAB, + 0xBD, 0x7E, 0x44, 0xE8, 0x24, 0xF7, 0xCE, 0xDB, + 0x7D, 0xEF, 0x57, 0x13, 0x0E, 0x52, 0xCF, 0xE9 + }, + { + 0x60, 0x42, 0x4F, 0xF2, 0x32, 0x34, 0xC3, 0x4D, + 0xC9, 0x68, 0x7A, 0xD5, 0x02, 0x86, 0x93, 0x72, + 0xCC, 0x31, 0xA5, 0x93, 0x80, 0x18, 0x6B, 0xC2, + 0x36, 0x1C, 0x83, 0x5D, 0x97, 0x2F, 0x49, 0x66, + 0x6E, 0xB1, 0xAC, 0x69, 0x62, 0x9D, 0xE6, 0x46, + 0xF0, 0x3F, 0x9B, 0x4D, 0xB9, 0xE2, 0xAC, 0xE0, + 0x93, 0xFB, 0xFD, 0xF8, 0xF2, 0x0A, 0xB5, 0xF9, + 0x85, 0x41, 0x97, 0x8B, 0xE8, 0xEF, 0x54, 0x9F + }, + { + 0x74, 0x06, 0x01, 0x8C, 0xE7, 0x04, 0xD8, 0x4F, + 0x5E, 0xB9, 0xC7, 0x9F, 0xEA, 0x97, 0xDA, 0x34, + 0x56, 0x99, 0x46, 0x8A, 0x35, 0x0E, 0xE0, 0xB2, + 0xD0, 0xF3, 0xA4, 0xBF, 0x20, 0x70, 0x30, 0x4E, + 0xA8, 0x62, 0xD7, 0x2A, 0x51, 0xC5, 0x7D, 0x30, + 0x64, 0x94, 0x72, 0x86, 0xF5, 0x31, 0xE0, 0xEA, + 0xF7, 0x56, 0x37, 0x02, 0x26, 0x2E, 0x6C, 0x72, + 0x4A, 0xBF, 0x5E, 0xD8, 0xC8, 0x39, 0x8D, 0x17 + }, + { + 0x14, 0xEF, 0x5C, 0x6D, 0x64, 0x7B, 0x3B, 0xD1, + 0xE6, 0xE3, 0x20, 0x06, 0xC2, 0x31, 0x19, 0x98, + 0x10, 0xDE, 0x5C, 0x4D, 0xC8, 0x8E, 0x70, 0x24, + 0x02, 0x73, 0xB0, 0xEA, 0x18, 0xE6, 0x51, 0xA3, + 0xEB, 0x4F, 0x5C, 0xA3, 0x11, 0x4B, 0x8A, 0x56, + 0x71, 0x69, 0x69, 0xC7, 0xCD, 0xA2, 0x7E, 0x0C, + 0x8D, 0xB8, 0x32, 0xAD, 0x5E, 0x89, 0xA2, 0xDC, + 0x6C, 0xB0, 0xAD, 0xBE, 0x7D, 0x93, 0xAB, 0xD1 + }, + { + 0x38, 0xCF, 0x6C, 0x24, 0xE3, 0xE0, 0x8B, 0xCF, + 0x1F, 0x6C, 0xF3, 0xD1, 0xB1, 0xF6, 0x5B, 0x90, + 0x52, 0x39, 0xA3, 0x11, 0x80, 0x33, 0x24, 0x9E, + 0x44, 0x81, 0x13, 0xEC, 0x63, 0x2E, 0xA6, 0xDC, + 0x34, 0x6F, 0xEE, 0xB2, 0x57, 0x1C, 0x38, 0xBD, + 0x9A, 0x73, 0x98, 0xB2, 0x22, 0x12, 0x80, 0x32, + 0x80, 0x02, 0xB2, 0x3E, 0x1A, 0x45, 0xAD, 0xAF, + 0xFE, 0x66, 0xD9, 0x3F, 0x65, 0x64, 0xEA, 0xA2 + }, + { + 0x6C, 0xD7, 0x20, 0x8A, 0x4B, 0xC7, 0xE7, 0xE5, + 0x62, 0x01, 0xBB, 0xBA, 0x02, 0xA0, 0xF4, 0x89, + 0xCD, 0x38, 0x4A, 0xBE, 0x40, 0xAF, 0xD4, 0x22, + 0x2F, 0x15, 0x8B, 0x3D, 0x98, 0x6E, 0xE7, 0x2A, + 0x54, 0xC5, 0x0F, 0xB6, 0x4F, 0xD4, 0xED, 0x25, + 0x30, 0xED, 0xA2, 0xC8, 0xAF, 0x29, 0x28, 0xA0, + 0xDA, 0x6D, 0x4F, 0x83, 0x0A, 0xE1, 0xC9, 0xDB, + 0x46, 0x9D, 0xFD, 0x97, 0x0F, 0x12, 0xA5, 0x6F + }, + { + 0x65, 0x98, 0x58, 0xF0, 0xB5, 0xC9, 0xED, 0xAB, + 0x5B, 0x94, 0xFD, 0x73, 0x2F, 0x6E, 0x6B, 0x17, + 0xC5, 0x1C, 0xC0, 0x96, 0x10, 0x4F, 0x09, 0xBE, + 0xB3, 0xAF, 0xC3, 0xAA, 0x46, 0x7C, 0x2E, 0xCF, + 0x88, 0x5C, 0x4C, 0x65, 0x41, 0xEF, 0xFA, 0x90, + 0x23, 0xD3, 0xB5, 0x73, 0x8A, 0xE5, 0xA1, 0x4D, + 0x86, 0x7E, 0x15, 0xDB, 0x06, 0xFE, 0x1F, 0x9D, + 0x11, 0x27, 0xB7, 0x7E, 0x1A, 0xAB, 0xB5, 0x16 + }, + { + 0x26, 0xCC, 0xA0, 0x12, 0x6F, 0x5D, 0x1A, 0x81, + 0x3C, 0x62, 0xE5, 0xC7, 0x10, 0x01, 0xC0, 0x46, + 0xF9, 0xC9, 0x20, 0x95, 0x70, 0x45, 0x50, 0xBE, + 0x58, 0x73, 0xA4, 0x95, 0xA9, 0x99, 0xAD, 0x01, + 0x0A, 0x4F, 0x79, 0x49, 0x1F, 0x24, 0xF2, 0x86, + 0x50, 0x0A, 0xDC, 0xE1, 0xA1, 0x37, 0xBC, 0x20, + 0x84, 0xE4, 0x94, 0x9F, 0x5B, 0x72, 0x94, 0xCE, + 0xFE, 0x51, 0xEC, 0xAF, 0xF8, 0xE9, 0x5C, 0xBA + }, + { + 0x41, 0x47, 0xC1, 0xF5, 0x51, 0x72, 0x78, 0x8C, + 0x55, 0x67, 0xC5, 0x61, 0xFE, 0xEF, 0x87, 0x6F, + 0x62, 0x1F, 0xFF, 0x1C, 0xE8, 0x77, 0x86, 0xB8, + 0x46, 0x76, 0x37, 0xE7, 0x0D, 0xFB, 0xCD, 0x0D, + 0xBD, 0xB6, 0x41, 0x5C, 0xB6, 0x00, 0x95, 0x4A, + 0xB9, 0xC0, 0x4C, 0x0E, 0x45, 0x7E, 0x62, 0x5B, + 0x40, 0x72, 0x22, 0xC0, 0xFE, 0x1A, 0xE2, 0x1B, + 0x21, 0x43, 0x68, 0x8A, 0xDA, 0x94, 0xDC, 0x58 + }, + { + 0x5B, 0x1B, 0xF1, 0x54, 0xC6, 0x2A, 0x8A, 0xF6, + 0xE9, 0x3D, 0x35, 0xF1, 0x8F, 0x7F, 0x90, 0xAB, + 0xB1, 0x6A, 0x6E, 0xF0, 0xE8, 0xD1, 0xAE, 0xCD, + 0x11, 0x8B, 0xF7, 0x01, 0x67, 0xBA, 0xB2, 0xAF, + 0x08, 0x93, 0x5C, 0x6F, 0xDC, 0x06, 0x63, 0xCE, + 0x74, 0x48, 0x2D, 0x17, 0xA8, 0xE5, 0x4B, 0x54, + 0x6D, 0x1C, 0x29, 0x66, 0x31, 0xC6, 0x5F, 0x3B, + 0x52, 0x2A, 0x51, 0x58, 0x39, 0xD4, 0x3D, 0x71 + }, + { + 0x9F, 0x60, 0x04, 0x19, 0xA4, 0xE8, 0xF4, 0xFB, + 0x83, 0x4C, 0x24, 0xB0, 0xF7, 0xFC, 0x13, 0xBF, + 0x4E, 0x27, 0x9D, 0x98, 0xE8, 0xA3, 0xC7, 0x65, + 0xEE, 0x93, 0x49, 0x17, 0x40, 0x3E, 0x3A, 0x66, + 0x09, 0x71, 0x82, 0xEA, 0x21, 0x45, 0x3C, 0xB6, + 0x3E, 0xBB, 0xE8, 0xB7, 0x3A, 0x9C, 0x21, 0x67, + 0x59, 0x64, 0x46, 0x43, 0x8C, 0x57, 0x62, 0x7F, + 0x33, 0x0B, 0xAD, 0xD4, 0xF5, 0x69, 0xF7, 0xD6 + }, + { + 0x45, 0x7E, 0xF6, 0x46, 0x6A, 0x89, 0x24, 0xFD, + 0x80, 0x11, 0xA3, 0x44, 0x71, 0xA5, 0xA1, 0xAC, + 0x8C, 0xCD, 0x9B, 0xD0, 0xD0, 0x7A, 0x97, 0x41, + 0x4A, 0xC9, 0x43, 0x02, 0x1C, 0xE4, 0xB9, 0xE4, + 0xB9, 0xC8, 0xDB, 0x0A, 0x28, 0xF0, 0x16, 0xED, + 0x43, 0xB1, 0x54, 0x24, 0x81, 0x99, 0x00, 0x22, + 0x14, 0x7B, 0x31, 0x3E, 0x19, 0x46, 0x71, 0x13, + 0x1E, 0x70, 0x8D, 0xD4, 0x3A, 0x3E, 0xD7, 0xDC + }, + { + 0x99, 0x97, 0xB2, 0x19, 0x4D, 0x9A, 0xF6, 0xDF, + 0xCB, 0x91, 0x43, 0xF4, 0x1C, 0x0E, 0xD8, 0x3D, + 0x3A, 0x3F, 0x43, 0x88, 0x36, 0x11, 0x03, 0xD3, + 0x8C, 0x2A, 0x49, 0xB2, 0x80, 0xA5, 0x81, 0x21, + 0x27, 0x15, 0xFD, 0x90, 0x8D, 0x41, 0xC6, 0x51, + 0xF5, 0xC7, 0x15, 0xCA, 0x38, 0xC0, 0xCE, 0x28, + 0x30, 0xA3, 0x7E, 0x00, 0xE5, 0x08, 0xCE, 0xD1, + 0xBC, 0xDC, 0x32, 0x0E, 0x5E, 0x4D, 0x1E, 0x2E + }, + { + 0x5C, 0x6B, 0xBF, 0x16, 0xBA, 0xA1, 0x80, 0xF9, + 0x86, 0xBD, 0x40, 0xA1, 0x28, 0x7E, 0xD4, 0xC5, + 0x49, 0x77, 0x0E, 0x72, 0x84, 0x85, 0x8F, 0xC4, + 0x7B, 0xC2, 0x1A, 0xB9, 0x5E, 0xBB, 0xF3, 0x37, + 0x4B, 0x4E, 0xE3, 0xFD, 0x9F, 0x2A, 0xF6, 0x0F, + 0x33, 0x95, 0x22, 0x1B, 0x2A, 0xCC, 0x76, 0xF2, + 0xD3, 0x4C, 0x13, 0x29, 0x54, 0x04, 0x9F, 0x8A, + 0x3A, 0x99, 0x6F, 0x1E, 0x32, 0xEC, 0x84, 0xE5 + }, + { + 0xD1, 0x0B, 0xF9, 0xA1, 0x5B, 0x1C, 0x9F, 0xC8, + 0xD4, 0x1F, 0x89, 0xBB, 0x14, 0x0B, 0xF0, 0xBE, + 0x08, 0xD2, 0xF3, 0x66, 0x61, 0x76, 0xD1, 0x3B, + 0xAA, 0xC4, 0xD3, 0x81, 0x35, 0x8A, 0xD0, 0x74, + 0xC9, 0xD4, 0x74, 0x8C, 0x30, 0x05, 0x20, 0xEB, + 0x02, 0x6D, 0xAE, 0xAE, 0xA7, 0xC5, 0xB1, 0x58, + 0x89, 0x2F, 0xDE, 0x4E, 0x8E, 0xC1, 0x7D, 0xC9, + 0x98, 0xDC, 0xD5, 0x07, 0xDF, 0x26, 0xEB, 0x63 + }, + { + 0x2F, 0xC6, 0xE6, 0x9F, 0xA2, 0x6A, 0x89, 0xA5, + 0xED, 0x26, 0x90, 0x92, 0xCB, 0x9B, 0x2A, 0x44, + 0x9A, 0x44, 0x09, 0xA7, 0xA4, 0x40, 0x11, 0xEE, + 0xCA, 0xD1, 0x3D, 0x7C, 0x4B, 0x04, 0x56, 0x60, + 0x2D, 0x40, 0x2F, 0xA5, 0x84, 0x4F, 0x1A, 0x7A, + 0x75, 0x81, 0x36, 0xCE, 0x3D, 0x5D, 0x8D, 0x0E, + 0x8B, 0x86, 0x92, 0x1F, 0xFF, 0xF4, 0xF6, 0x92, + 0xDD, 0x95, 0xBD, 0xC8, 0xE5, 0xFF, 0x00, 0x52 + }, + { + 0xFC, 0xBE, 0x8B, 0xE7, 0xDC, 0xB4, 0x9A, 0x32, + 0xDB, 0xDF, 0x23, 0x94, 0x59, 0xE2, 0x63, 0x08, + 0xB8, 0x4D, 0xFF, 0x1E, 0xA4, 0x80, 0xDF, 0x8D, + 0x10, 0x4E, 0xEF, 0xF3, 0x4B, 0x46, 0xFA, 0xE9, + 0x86, 0x27, 0xB4, 0x50, 0xC2, 0x26, 0x7D, 0x48, + 0xC0, 0x94, 0x6A, 0x69, 0x7C, 0x5B, 0x59, 0x53, + 0x14, 0x52, 0xAC, 0x04, 0x84, 0xF1, 0xC8, 0x4E, + 0x3A, 0x33, 0xD0, 0xC3, 0x39, 0xBB, 0x2E, 0x28 + }, + { + 0xA1, 0x90, 0x93, 0xA6, 0xE3, 0xBC, 0xF5, 0x95, + 0x2F, 0x85, 0x0F, 0x20, 0x30, 0xF6, 0x9B, 0x96, + 0x06, 0xF1, 0x47, 0xF9, 0x0B, 0x8B, 0xAE, 0xE3, + 0x36, 0x2D, 0xA7, 0x1D, 0x9F, 0x35, 0xB4, 0x4E, + 0xF9, 0xD8, 0xF0, 0xA7, 0x71, 0x2B, 0xA1, 0x87, + 0x7F, 0xDD, 0xCD, 0x2D, 0x8E, 0xA8, 0xF1, 0xE5, + 0xA7, 0x73, 0xD0, 0xB7, 0x45, 0xD4, 0x72, 0x56, + 0x05, 0x98, 0x3A, 0x2D, 0xE9, 0x01, 0xF8, 0x03 + }, + { + 0x3C, 0x20, 0x06, 0x42, 0x3F, 0x73, 0xE2, 0x68, + 0xFA, 0x59, 0xD2, 0x92, 0x03, 0x77, 0xEB, 0x29, + 0xA4, 0xF9, 0xA8, 0xB4, 0x62, 0xBE, 0x15, 0x98, + 0x3E, 0xE3, 0xB8, 0x5A, 0xE8, 0xA7, 0x8E, 0x99, + 0x26, 0x33, 0x58, 0x1A, 0x90, 0x99, 0x89, 0x3B, + 0x63, 0xDB, 0x30, 0x24, 0x1C, 0x34, 0xF6, 0x43, + 0x02, 0x7D, 0xC8, 0x78, 0x27, 0x9A, 0xF5, 0x85, + 0x0D, 0x7E, 0x2D, 0x4A, 0x26, 0x53, 0x07, 0x3A + }, + { + 0xD0, 0xF2, 0xF2, 0xE3, 0x78, 0x76, 0x53, 0xF7, + 0x7C, 0xCE, 0x2F, 0xA2, 0x48, 0x35, 0x78, 0x5B, + 0xBD, 0x0C, 0x43, 0x3F, 0xC7, 0x79, 0x46, 0x5A, + 0x11, 0x51, 0x49, 0x90, 0x5A, 0x9D, 0xD1, 0xCB, + 0x82, 0x7A, 0x62, 0x85, 0x06, 0xD4, 0x57, 0xFC, + 0xF1, 0x24, 0xA0, 0xC2, 0xAE, 0xF9, 0xCE, 0x2D, + 0x2A, 0x0A, 0x0F, 0x63, 0x54, 0x55, 0x70, 0xD8, + 0x66, 0x7F, 0xF9, 0xE2, 0xEB, 0xA0, 0x73, 0x34 + }, + { + 0x78, 0xA9, 0xFC, 0x04, 0x8E, 0x25, 0xC6, 0xDC, + 0xB5, 0xDE, 0x45, 0x66, 0x7D, 0xE8, 0xFF, 0xDD, + 0x3A, 0x93, 0x71, 0x11, 0x41, 0xD5, 0x94, 0xE9, + 0xFA, 0x62, 0xA9, 0x59, 0x47, 0x5D, 0xA6, 0x07, + 0x5E, 0xA8, 0xF0, 0x91, 0x6E, 0x84, 0xE4, 0x5A, + 0xD9, 0x11, 0xB7, 0x54, 0x67, 0x07, 0x7E, 0xE5, + 0x2D, 0x2C, 0x9A, 0xEB, 0xF4, 0xD5, 0x8F, 0x20, + 0xCE, 0x4A, 0x3A, 0x00, 0x45, 0x8B, 0x05, 0xD4 + }, + { + 0x45, 0x81, 0x3F, 0x44, 0x17, 0x69, 0xAB, 0x6E, + 0xD3, 0x7D, 0x34, 0x9F, 0xF6, 0xE7, 0x22, 0x67, + 0xD7, 0x6A, 0xE6, 0xBB, 0x3E, 0x3C, 0x61, 0x2E, + 0xC0, 0x5C, 0x6E, 0x02, 0xA1, 0x2A, 0xF5, 0xA3, + 0x7C, 0x91, 0x8B, 0x52, 0xBF, 0x74, 0x26, 0x7C, + 0x3F, 0x6A, 0x3F, 0x18, 0x3A, 0x80, 0x64, 0xFF, + 0x84, 0xC0, 0x7B, 0x19, 0x3D, 0x08, 0x06, 0x67, + 0x89, 0xA0, 0x1A, 0xCC, 0xDB, 0x6F, 0x93, 0x40 + }, + { + 0x95, 0x6D, 0xA1, 0xC6, 0x8D, 0x83, 0xA7, 0xB8, + 0x81, 0xE0, 0x1B, 0x9A, 0x96, 0x6C, 0x3C, 0x0B, + 0xF2, 0x7F, 0x68, 0x60, 0x6A, 0x8B, 0x71, 0xD4, + 0x57, 0xBD, 0x01, 0x6D, 0x4C, 0x41, 0xDD, 0x8A, + 0x38, 0x0C, 0x70, 0x9A, 0x29, 0x6C, 0xB4, 0xC6, + 0x54, 0x47, 0x92, 0x92, 0x0F, 0xD7, 0x88, 0x83, + 0x57, 0x71, 0xA0, 0x7D, 0x4A, 0x16, 0xFB, 0x52, + 0xED, 0x48, 0x05, 0x03, 0x31, 0xDC, 0x4C, 0x8B + }, + { + 0xDF, 0x18, 0x6C, 0x2D, 0xC0, 0x9C, 0xAA, 0x48, + 0xE1, 0x4E, 0x94, 0x2F, 0x75, 0xDE, 0x5A, 0xC1, + 0xB7, 0xA2, 0x1E, 0x4F, 0x9F, 0x07, 0x2A, 0x5B, + 0x37, 0x1E, 0x09, 0xE0, 0x73, 0x45, 0xB0, 0x74, + 0x0C, 0x76, 0x17, 0x7B, 0x01, 0x27, 0x88, 0x08, + 0xFE, 0xC0, 0x25, 0xED, 0xED, 0x98, 0x22, 0xC1, + 0x22, 0xAF, 0xD1, 0xC6, 0x3E, 0x6F, 0x0C, 0xE2, + 0xE3, 0x26, 0x31, 0x04, 0x10, 0x63, 0x14, 0x5C + }, + { + 0x87, 0x47, 0x56, 0x40, 0x96, 0x6A, 0x9F, 0xDC, + 0xD6, 0xD3, 0xA3, 0xB5, 0xA2, 0xCC, 0xA5, 0xC0, + 0x8F, 0x0D, 0x88, 0x2B, 0x10, 0x24, 0x3C, 0x0E, + 0xC1, 0xBF, 0x3C, 0x6B, 0x1C, 0x37, 0xF2, 0xCD, + 0x32, 0x12, 0xF1, 0x9A, 0x05, 0x78, 0x64, 0x47, + 0x7D, 0x5E, 0xAF, 0x8F, 0xAE, 0xD7, 0x3F, 0x29, + 0x37, 0xC7, 0x68, 0xA0, 0xAF, 0x41, 0x5E, 0x84, + 0xBB, 0xCE, 0x6B, 0xD7, 0xDE, 0x23, 0xB6, 0x60 + }, + { + 0xC3, 0xB5, 0x73, 0xBB, 0xE1, 0x09, 0x49, 0xA0, + 0xFB, 0xD4, 0xFF, 0x88, 0x4C, 0x44, 0x6F, 0x22, + 0x29, 0xB7, 0x69, 0x02, 0xF9, 0xDF, 0xDB, 0xB8, + 0xA0, 0x35, 0x3D, 0xA5, 0xC8, 0x3C, 0xA1, 0x4E, + 0x81, 0x51, 0xBB, 0xAA, 0xC8, 0x2F, 0xD1, 0x57, + 0x6A, 0x00, 0x9A, 0xDC, 0x6F, 0x19, 0x35, 0xCF, + 0x26, 0xED, 0xD4, 0xF1, 0xFB, 0x8D, 0xA4, 0x83, + 0xE6, 0xC5, 0xCD, 0x9D, 0x89, 0x23, 0xAD, 0xC3 + }, + { + 0xB0, 0x9D, 0x8D, 0x0B, 0xBA, 0x8A, 0x72, 0x86, + 0xE4, 0x35, 0x68, 0xF7, 0x90, 0x75, 0x50, 0xE4, + 0x20, 0x36, 0xD6, 0x74, 0xE3, 0xC8, 0xFC, 0x34, + 0xD8, 0xCA, 0x46, 0xF7, 0x71, 0xD6, 0x46, 0x6B, + 0x70, 0xFB, 0x60, 0x58, 0x75, 0xF6, 0xA8, 0x63, + 0xC8, 0x77, 0xD1, 0x2F, 0x07, 0x06, 0x3F, 0xDC, + 0x2E, 0x90, 0xCC, 0xD4, 0x59, 0xB1, 0x91, 0x0D, + 0xCD, 0x52, 0xD8, 0xF1, 0x0B, 0x2B, 0x0A, 0x15 + }, + { + 0xAF, 0x3A, 0x22, 0xBF, 0x75, 0xB2, 0x1A, 0xBF, + 0xB0, 0xAC, 0xD5, 0x44, 0x22, 0xBA, 0x1B, 0x73, + 0x00, 0xA9, 0x52, 0xEF, 0xF0, 0x2E, 0xBE, 0xB6, + 0x5B, 0x5C, 0x23, 0x44, 0x71, 0xA9, 0x8D, 0xF3, + 0x2F, 0x4F, 0x96, 0x43, 0xCE, 0x19, 0x04, 0x10, + 0x8A, 0x16, 0x87, 0x67, 0x92, 0x42, 0x80, 0xBD, + 0x76, 0xC8, 0x3F, 0x8C, 0x82, 0xD9, 0xA7, 0x9D, + 0x92, 0x59, 0xB1, 0x95, 0x36, 0x2A, 0x2A, 0x04 + }, + { + 0xBF, 0x4F, 0xF2, 0x22, 0x1B, 0x7E, 0x69, 0x57, + 0xA7, 0x24, 0xCD, 0x96, 0x4A, 0xA3, 0xD5, 0xD0, + 0xD9, 0x94, 0x1F, 0x54, 0x04, 0x13, 0x75, 0x2F, + 0x46, 0x99, 0xD8, 0x10, 0x1B, 0x3E, 0x53, 0x75, + 0x08, 0xBF, 0x09, 0xF8, 0x50, 0x8B, 0x31, 0x77, + 0x36, 0xFF, 0xD2, 0x65, 0xF2, 0x84, 0x7A, 0xA7, + 0xD8, 0x4B, 0xD2, 0xD9, 0x75, 0x69, 0xC4, 0x9D, + 0x63, 0x2A, 0xED, 0x99, 0x45, 0xE5, 0xFA, 0x5E + }, + { + 0x9C, 0x6B, 0x6B, 0x78, 0x19, 0x9B, 0x1B, 0xDA, + 0xCB, 0x43, 0x00, 0xE3, 0x14, 0x79, 0xFA, 0x62, + 0x2A, 0x6B, 0x5B, 0xC8, 0x0D, 0x46, 0x78, 0xA6, + 0x07, 0x8F, 0x88, 0xA8, 0x26, 0x8C, 0xD7, 0x20, + 0x6A, 0x27, 0x99, 0xE8, 0xD4, 0x62, 0x1A, 0x46, + 0x4E, 0xF6, 0xB4, 0x3D, 0xD8, 0xAD, 0xFF, 0xE9, + 0x7C, 0xAF, 0x22, 0x1B, 0x22, 0xB6, 0xB8, 0x77, + 0x8B, 0x14, 0x9A, 0x82, 0x2A, 0xEF, 0xBB, 0x09 + }, + { + 0x89, 0x06, 0x56, 0xF0, 0x9C, 0x99, 0xD2, 0x80, + 0xB5, 0xEC, 0xB3, 0x81, 0xF5, 0x64, 0x27, 0xB8, + 0x13, 0x75, 0x1B, 0xC6, 0x52, 0xC7, 0x82, 0x80, + 0x78, 0xB2, 0x3A, 0x4A, 0xF8, 0x3B, 0x4E, 0x3A, + 0x61, 0xFD, 0xBA, 0xC6, 0x1F, 0x89, 0xBE, 0xE8, + 0x4E, 0xA6, 0xBE, 0xE7, 0x60, 0xC0, 0x47, 0xF2, + 0x5C, 0x6B, 0x0A, 0x20, 0x1C, 0x69, 0xA3, 0x8F, + 0xD6, 0xFD, 0x97, 0x1A, 0xF1, 0x85, 0x88, 0xBB + }, + { + 0x31, 0xA0, 0x46, 0xF7, 0x88, 0x2F, 0xFE, 0x6F, + 0x83, 0xCE, 0x47, 0x2E, 0x9A, 0x07, 0x01, 0x83, + 0x2E, 0xC7, 0xB3, 0xF7, 0x6F, 0xBC, 0xFD, 0x1D, + 0xF6, 0x0F, 0xE3, 0xEA, 0x48, 0xFD, 0xE1, 0x65, + 0x12, 0x54, 0x24, 0x7C, 0x3F, 0xD9, 0x5E, 0x10, + 0x0F, 0x91, 0x72, 0x73, 0x1E, 0x17, 0xFD, 0x52, + 0x97, 0xC1, 0x1F, 0x4B, 0xB3, 0x28, 0x36, 0x3C, + 0xA3, 0x61, 0x62, 0x4A, 0x81, 0xAF, 0x79, 0x7C + }, + { + 0x27, 0xA6, 0x0B, 0x2D, 0x00, 0xE7, 0xA6, 0x71, + 0xD4, 0x7D, 0x0A, 0xEC, 0x2A, 0x68, 0x6A, 0x0A, + 0xC0, 0x4B, 0x52, 0xF4, 0x0A, 0xB6, 0x62, 0x90, + 0x28, 0xEB, 0x7D, 0x13, 0xF4, 0xBA, 0xA9, 0x9A, + 0xC0, 0xFE, 0x46, 0xEE, 0x6C, 0x81, 0x49, 0x44, + 0xF2, 0xF4, 0xB4, 0xD2, 0x0E, 0x93, 0x78, 0xE4, + 0x84, 0x7E, 0xA4, 0x4C, 0x13, 0x17, 0x80, 0x91, + 0xE2, 0x77, 0xB8, 0x7E, 0xA7, 0xA5, 0x57, 0x11 + }, + { + 0x8B, 0x5C, 0xCE, 0xF1, 0x94, 0x16, 0x2C, 0x1F, + 0x19, 0xD6, 0x8F, 0x91, 0xE0, 0xB0, 0x92, 0x8F, + 0x28, 0x9E, 0xC5, 0x28, 0x37, 0x20, 0x84, 0x0C, + 0x2F, 0x73, 0xD2, 0x53, 0x11, 0x12, 0x38, 0xDC, + 0xFE, 0x94, 0xAF, 0x2B, 0x59, 0xC2, 0xC1, 0xCA, + 0x25, 0x91, 0x90, 0x1A, 0x7B, 0xC0, 0x60, 0xE7, + 0x45, 0x9B, 0x6C, 0x47, 0xDF, 0x0F, 0x71, 0x70, + 0x1A, 0x35, 0xCC, 0x0A, 0xA8, 0x31, 0xB5, 0xB6 + }, + { + 0x57, 0xAB, 0x6C, 0x4B, 0x22, 0x29, 0xAE, 0xB3, + 0xB7, 0x04, 0x76, 0xD8, 0x03, 0xCD, 0x63, 0x81, + 0x2F, 0x10, 0x7C, 0xE6, 0xDA, 0x17, 0xFE, 0xD9, + 0xB1, 0x78, 0x75, 0xE8, 0xF8, 0x6C, 0x72, 0x4F, + 0x49, 0xE0, 0x24, 0xCB, 0xF3, 0xA1, 0xB8, 0xB1, + 0x19, 0xC5, 0x03, 0x57, 0x65, 0x2B, 0x81, 0x87, + 0x9D, 0x2A, 0xDE, 0x2D, 0x58, 0x8B, 0x9E, 0x4F, + 0x7C, 0xED, 0xBA, 0x0E, 0x46, 0x44, 0xC9, 0xEE + }, + { + 0x01, 0x90, 0xA8, 0xDA, 0xC3, 0x20, 0xA7, 0x39, + 0xF3, 0x22, 0xE1, 0x57, 0x31, 0xAA, 0x14, 0x0D, + 0xDA, 0xF5, 0xBE, 0xD2, 0x94, 0xD5, 0xC8, 0x2E, + 0x54, 0xFE, 0xF2, 0x9F, 0x21, 0x4E, 0x18, 0xAA, + 0xFA, 0xA8, 0x4F, 0x8B, 0xE9, 0x9A, 0xF6, 0x29, + 0x50, 0x26, 0x6B, 0x8F, 0x90, 0x1F, 0x15, 0xDD, + 0x4C, 0x5D, 0x35, 0x51, 0x6F, 0xC3, 0x5B, 0x4C, + 0xAB, 0x2E, 0x96, 0xE4, 0x69, 0x5B, 0xBE, 0x1C + }, + { + 0xD1, 0x4D, 0x7C, 0x4C, 0x41, 0x5E, 0xEB, 0x0E, + 0x10, 0xB1, 0x59, 0x22, 0x4B, 0xEA, 0x12, 0x7E, + 0xBD, 0x84, 0xF9, 0x59, 0x1C, 0x70, 0x2A, 0x33, + 0x0F, 0x5B, 0xB7, 0xBB, 0x7A, 0xA4, 0x4E, 0xA3, + 0x9D, 0xE6, 0xED, 0x01, 0xF1, 0x8D, 0xA7, 0xAD, + 0xF4, 0x0C, 0xFB, 0x97, 0xC5, 0xD1, 0x52, 0xC2, + 0x75, 0x28, 0x82, 0x4B, 0x21, 0xE2, 0x39, 0x52, + 0x6A, 0xF8, 0xF3, 0x6B, 0x21, 0x4E, 0x0C, 0xFB + }, + { + 0xBE, 0x28, 0xC4, 0xBE, 0x70, 0x69, 0x70, 0x48, + 0x8F, 0xAC, 0x7D, 0x29, 0xC3, 0xBD, 0x5C, 0x4E, + 0x98, 0x60, 0x85, 0xC4, 0xC3, 0x33, 0x2F, 0x1F, + 0x3F, 0xD3, 0x09, 0x73, 0xDB, 0x61, 0x41, 0x64, + 0xBA, 0x2F, 0x31, 0xA7, 0x88, 0x75, 0xFF, 0xDC, + 0x15, 0x03, 0x25, 0xC8, 0x83, 0x27, 0xA9, 0x44, + 0x3E, 0xD0, 0x4F, 0xDF, 0xE5, 0xBE, 0x93, 0x87, + 0x6D, 0x16, 0x28, 0x56, 0x0C, 0x76, 0x4A, 0x80 + }, + { + 0x03, 0x1D, 0xA1, 0x06, 0x9E, 0x3A, 0x2E, 0x9C, + 0x33, 0x82, 0xE4, 0x36, 0xFF, 0xD7, 0x9D, 0xF7, + 0x4B, 0x1C, 0xA6, 0xA8, 0xAD, 0xB2, 0xDE, 0xAB, + 0xE6, 0x76, 0xAB, 0x45, 0x99, 0x4C, 0xBC, 0x05, + 0x4F, 0x03, 0x7D, 0x2F, 0x0E, 0xAC, 0xE8, 0x58, + 0xD3, 0x2C, 0x14, 0xE2, 0xD1, 0xC8, 0xB4, 0x60, + 0x77, 0x30, 0x8E, 0x3B, 0xDC, 0x2C, 0x1B, 0x53, + 0x17, 0x2E, 0xCF, 0x7A, 0x8C, 0x14, 0xE3, 0x49 + }, + { + 0x46, 0x65, 0xCE, 0xF8, 0xBA, 0x4D, 0xB4, 0xD0, + 0xAC, 0xB1, 0x18, 0xF2, 0x98, 0x7F, 0x0B, 0xB0, + 0x9F, 0x8F, 0x86, 0xAA, 0x44, 0x5A, 0xA3, 0xD5, + 0xFC, 0x9A, 0x8B, 0x34, 0x68, 0x64, 0x78, 0x74, + 0x89, 0xE8, 0xFC, 0xEC, 0xC1, 0x25, 0xD1, 0x7E, + 0x9B, 0x56, 0xE1, 0x29, 0x88, 0xEA, 0xC5, 0xEC, + 0xC7, 0x28, 0x68, 0x83, 0xDB, 0x06, 0x61, 0xB8, + 0xFF, 0x05, 0xDA, 0x2A, 0xFF, 0xF3, 0x0F, 0xE4 + }, + { + 0x63, 0xB7, 0x03, 0x2E, 0x5F, 0x93, 0x0C, 0xC9, + 0x93, 0x95, 0x17, 0xF9, 0xE9, 0x86, 0x81, 0x6C, + 0xFB, 0xEC, 0x2B, 0xE5, 0x9B, 0x95, 0x68, 0xB1, + 0x3F, 0x2E, 0xAD, 0x05, 0xBA, 0xE7, 0x77, 0x7C, + 0xAB, 0x62, 0x0C, 0x66, 0x59, 0x40, 0x4F, 0x74, + 0x09, 0xE4, 0x19, 0x9A, 0x3B, 0xE5, 0xF7, 0x86, + 0x5A, 0xA7, 0xCB, 0xDF, 0x8C, 0x42, 0x53, 0xF7, + 0xE8, 0x21, 0x9B, 0x1B, 0xD5, 0xF4, 0x6F, 0xEA + }, + { + 0x9F, 0x09, 0xBF, 0x09, 0x3A, 0x2B, 0x0F, 0xF8, + 0xC2, 0x63, 0x4B, 0x49, 0xE3, 0x7F, 0x1B, 0x21, + 0x35, 0xB4, 0x47, 0xAA, 0x91, 0x44, 0xC9, 0x78, + 0x7D, 0xBF, 0xD9, 0x21, 0x29, 0x31, 0x6C, 0x99, + 0xE8, 0x8A, 0xAB, 0x8A, 0x21, 0xFD, 0xEF, 0x23, + 0x72, 0xD1, 0x18, 0x9A, 0xEC, 0x50, 0x0F, 0x95, + 0x77, 0x5F, 0x1F, 0x92, 0xBF, 0xB4, 0x55, 0x45, + 0xE4, 0x25, 0x9F, 0xB9, 0xB7, 0xB0, 0x2D, 0x14 + }, + { + 0xF9, 0xF8, 0x49, 0x3C, 0x68, 0x08, 0x88, 0x07, + 0xDF, 0x7F, 0x6A, 0x26, 0x93, 0xD6, 0x4E, 0xA5, + 0x9F, 0x03, 0xE9, 0xE0, 0x5A, 0x22, 0x3E, 0x68, + 0x52, 0x4C, 0xA3, 0x21, 0x95, 0xA4, 0x73, 0x4B, + 0x65, 0x4F, 0xCE, 0xA4, 0xD2, 0x73, 0x4C, 0x86, + 0x6C, 0xF9, 0x5C, 0x88, 0x9F, 0xB1, 0x0C, 0x49, + 0x15, 0x9B, 0xE2, 0xF5, 0x04, 0x3D, 0xC9, 0x8B, + 0xB5, 0x5E, 0x02, 0xEF, 0x7B, 0xDC, 0xB0, 0x82 + }, + { + 0x3C, 0x9A, 0x73, 0x59, 0xAB, 0x4F, 0xEB, 0xCE, + 0x07, 0xB2, 0x0A, 0xC4, 0x47, 0xB0, 0x6A, 0x24, + 0x0B, 0x7F, 0xE1, 0xDA, 0xE5, 0x43, 0x9C, 0x49, + 0xB6, 0x0B, 0x58, 0x19, 0xF7, 0x81, 0x2E, 0x4C, + 0x17, 0x24, 0x06, 0xC1, 0xAA, 0xC3, 0x16, 0x71, + 0x3C, 0xF0, 0xDD, 0xED, 0x10, 0x38, 0x07, 0x72, + 0x58, 0xE2, 0xEF, 0xF5, 0xB3, 0x39, 0x13, 0xD9, + 0xD9, 0x5C, 0xAE, 0xB4, 0xE6, 0xC6, 0xB9, 0x70 + }, + { + 0xAD, 0x6A, 0xAB, 0x80, 0x84, 0x51, 0x0E, 0x82, + 0x2C, 0xFC, 0xE8, 0x62, 0x5D, 0x62, 0xCF, 0x4D, + 0xE6, 0x55, 0xF4, 0x76, 0x38, 0x84, 0xC7, 0x1E, + 0x80, 0xBA, 0xB9, 0xAC, 0x9D, 0x53, 0x18, 0xDB, + 0xA4, 0xA6, 0x03, 0x3E, 0xD2, 0x90, 0x84, 0xE6, + 0x52, 0x16, 0xC0, 0x31, 0x60, 0x6C, 0xA1, 0x76, + 0x15, 0xDC, 0xFE, 0x3B, 0xA1, 0x1D, 0x26, 0x85, + 0x1A, 0xE0, 0x99, 0x9C, 0xA6, 0xE2, 0x32, 0xCF + }, + { + 0x15, 0x6E, 0x9E, 0x62, 0x61, 0x37, 0x4C, 0x9D, + 0xC8, 0x84, 0xF3, 0x6E, 0x70, 0xF0, 0xFE, 0x1A, + 0xB9, 0x29, 0x79, 0x97, 0xB8, 0x36, 0xFA, 0x7D, + 0x17, 0x0A, 0x9C, 0x9E, 0xBF, 0x57, 0x5B, 0x88, + 0x1E, 0x7B, 0xCE, 0xA4, 0x4D, 0x6C, 0x02, 0x48, + 0xD3, 0x55, 0x97, 0x90, 0x71, 0x54, 0x82, 0x89, + 0x55, 0xBE, 0x19, 0x13, 0x58, 0x52, 0xF9, 0x22, + 0x88, 0x15, 0xEC, 0xA0, 0x24, 0xA8, 0xAD, 0xFB + }, + { + 0x42, 0x15, 0x40, 0x76, 0x33, 0xF4, 0xCC, 0xA9, + 0xB6, 0x78, 0x8B, 0xE9, 0x3E, 0x6A, 0xA3, 0xD9, + 0x63, 0xC7, 0xD6, 0xCE, 0x4B, 0x14, 0x72, 0x47, + 0x09, 0x9F, 0x46, 0xA3, 0xAC, 0xB5, 0x00, 0xA3, + 0x00, 0x38, 0xCB, 0x3E, 0x78, 0x8C, 0x3D, 0x29, + 0xF1, 0x32, 0xAD, 0x84, 0x4E, 0x80, 0xE9, 0xE9, + 0x92, 0x51, 0xF6, 0xDB, 0x96, 0xAC, 0xD8, 0xA0, + 0x91, 0xCF, 0xC7, 0x70, 0xAF, 0x53, 0x84, 0x7B + }, + { + 0x1C, 0x07, 0x7E, 0x27, 0x9D, 0xE6, 0x54, 0x85, + 0x23, 0x50, 0x2B, 0x6D, 0xF8, 0x00, 0xFF, 0xDA, + 0xB5, 0xE2, 0xC3, 0xE9, 0x44, 0x2E, 0xB8, 0x38, + 0xF5, 0x8C, 0x29, 0x5F, 0x3B, 0x14, 0x7C, 0xEF, + 0x9D, 0x70, 0x1C, 0x41, 0xC3, 0x21, 0x28, 0x3F, + 0x00, 0xC7, 0x1A, 0xFF, 0xA0, 0x61, 0x93, 0x10, + 0x39, 0x91, 0x26, 0x29, 0x5B, 0x78, 0xDD, 0x4D, + 0x1A, 0x74, 0x57, 0x2E, 0xF9, 0xED, 0x51, 0x35 + }, + { + 0xF0, 0x7A, 0x55, 0x5F, 0x49, 0xFE, 0x48, 0x1C, + 0xF4, 0xCD, 0x0A, 0x87, 0xB7, 0x1B, 0x82, 0xE4, + 0xA9, 0x50, 0x64, 0xD0, 0x66, 0x77, 0xFD, 0xD9, + 0x0A, 0x0E, 0xB5, 0x98, 0x87, 0x7B, 0xA1, 0xC8, + 0x3D, 0x46, 0x77, 0xB3, 0x93, 0xC3, 0xA3, 0xB6, + 0x66, 0x1C, 0x42, 0x1F, 0x5B, 0x12, 0xCB, 0x99, + 0xD2, 0x03, 0x76, 0xBA, 0x72, 0x75, 0xC2, 0xF3, + 0xA8, 0xF5, 0xA9, 0xB7, 0x82, 0x17, 0x20, 0xDA + }, + { + 0xB5, 0x91, 0x1B, 0x38, 0x0D, 0x20, 0xC7, 0xB0, + 0x43, 0x23, 0xE4, 0x02, 0x6B, 0x38, 0xE2, 0x00, + 0xF5, 0x34, 0x25, 0x92, 0x33, 0xB5, 0x81, 0xE0, + 0x2C, 0x1E, 0x3E, 0x2D, 0x84, 0x38, 0xD6, 0xC6, + 0x6D, 0x5A, 0x4E, 0xB2, 0x01, 0xD5, 0xA8, 0xB7, + 0x50, 0x72, 0xC4, 0xEC, 0x29, 0x10, 0x63, 0x34, + 0xDA, 0x70, 0xBC, 0x79, 0x52, 0x1B, 0x0C, 0xED, + 0x2C, 0xFD, 0x53, 0x3F, 0x5F, 0xF8, 0x4F, 0x95 + }, + { + 0x01, 0xF0, 0x70, 0xA0, 0x9B, 0xAE, 0x91, 0x12, + 0x96, 0x36, 0x1F, 0x91, 0xAA, 0x0E, 0x8E, 0x0D, + 0x09, 0xA7, 0x72, 0x54, 0x78, 0x53, 0x6D, 0x9D, + 0x48, 0xC5, 0xFE, 0x1E, 0x5E, 0x7C, 0x3C, 0x5B, + 0x9B, 0x9D, 0x6E, 0xB0, 0x77, 0x96, 0xF6, 0xDA, + 0x57, 0xAE, 0x56, 0x2A, 0x7D, 0x70, 0xE8, 0x82, + 0xE3, 0x7A, 0xDF, 0xDE, 0x83, 0xF0, 0xC4, 0x33, + 0xC2, 0xCD, 0x36, 0x35, 0x36, 0xBB, 0x22, 0xC8 + }, + { + 0x6F, 0x79, 0x3E, 0xB4, 0x37, 0x4A, 0x48, 0xB0, + 0x77, 0x5A, 0xCA, 0xF9, 0xAD, 0xCF, 0x8E, 0x45, + 0xE5, 0x42, 0x70, 0xC9, 0x47, 0x5F, 0x00, 0x4A, + 0xD8, 0xD5, 0x97, 0x3E, 0x2A, 0xCA, 0x52, 0x74, + 0x7F, 0xF4, 0xED, 0x04, 0xAE, 0x96, 0x72, 0x75, + 0xB9, 0xF9, 0xEB, 0x0E, 0x1F, 0xF7, 0x5F, 0xB4, + 0xF7, 0x94, 0xFA, 0x8B, 0xE9, 0xAD, 0xD7, 0xA4, + 0x13, 0x04, 0x86, 0x8D, 0x10, 0x3F, 0xAB, 0x10 + }, + { + 0x96, 0x5F, 0x20, 0xF1, 0x39, 0x76, 0x5F, 0xCC, + 0x4C, 0xE4, 0xBA, 0x37, 0x94, 0x67, 0x58, 0x63, + 0xCA, 0xC2, 0x4D, 0xB4, 0x72, 0xCD, 0x2B, 0x79, + 0x9D, 0x03, 0x5B, 0xCE, 0x3D, 0xBE, 0xA5, 0x02, + 0xDA, 0x7B, 0x52, 0x48, 0x65, 0xF6, 0xB8, 0x11, + 0xD8, 0xC5, 0x82, 0x8D, 0x3A, 0x88, 0x96, 0x46, + 0xFE, 0x64, 0xA3, 0x80, 0xDA, 0x1A, 0xA7, 0xC7, + 0x04, 0x4E, 0x9F, 0x24, 0x5D, 0xCE, 0xD1, 0x28 + }, + { + 0xEC, 0x29, 0x5B, 0x57, 0x83, 0x60, 0x12, 0x44, + 0xC3, 0x0E, 0x46, 0x41, 0xE3, 0xB4, 0x5B, 0xE2, + 0x22, 0xC4, 0xDC, 0xE7, 0x7A, 0x58, 0x70, 0x0F, + 0x53, 0xBC, 0x8E, 0xC5, 0x2A, 0x94, 0x16, 0x90, + 0xB4, 0xD0, 0xB0, 0x87, 0xFB, 0x6F, 0xCB, 0x3F, + 0x39, 0x83, 0x2B, 0x9D, 0xE8, 0xF7, 0x5E, 0xC2, + 0x0B, 0xD4, 0x30, 0x79, 0x81, 0x17, 0x49, 0xCD, + 0xC9, 0x07, 0xED, 0xB9, 0x41, 0x57, 0xD1, 0x80 + }, + { + 0x61, 0xC7, 0x2F, 0x8C, 0xCC, 0x91, 0xDB, 0xB5, + 0x4C, 0xA6, 0x75, 0x0B, 0xC4, 0x89, 0x67, 0x2D, + 0xE0, 0x9F, 0xAE, 0xDB, 0x8F, 0xDD, 0x4F, 0x94, + 0xFF, 0x23, 0x20, 0x90, 0x9A, 0x30, 0x3F, 0x5D, + 0x5A, 0x98, 0x48, 0x1C, 0x0B, 0xC1, 0xA6, 0x25, + 0x41, 0x9F, 0xB4, 0xDE, 0xBF, 0xBF, 0x7F, 0x8A, + 0x53, 0xBB, 0x07, 0xEC, 0x3D, 0x98, 0x5E, 0x8E, + 0xA1, 0x1E, 0x72, 0xD5, 0x59, 0x94, 0x07, 0x80 + }, + { + 0xAF, 0xD8, 0x14, 0x5B, 0x25, 0x9E, 0xEF, 0xC8, + 0xD1, 0x26, 0x20, 0xC3, 0xC5, 0xB0, 0x3E, 0x1E, + 0xD8, 0xFD, 0x2C, 0xCE, 0xFE, 0x03, 0x65, 0x07, + 0x8C, 0x80, 0xFD, 0x42, 0xC1, 0x77, 0x0E, 0x28, + 0xB4, 0x49, 0x48, 0xF2, 0x7E, 0x65, 0xA1, 0x88, + 0x66, 0x90, 0x11, 0x0D, 0xB8, 0x14, 0x39, 0x7B, + 0x68, 0xE4, 0x3D, 0x80, 0xD1, 0xBA, 0x16, 0xDF, + 0xA3, 0x58, 0xE7, 0x39, 0xC8, 0x98, 0xCF, 0xA3 + }, + { + 0x55, 0x2F, 0xC7, 0x89, 0x3C, 0xF1, 0xCE, 0x93, + 0x3A, 0xDA, 0x35, 0xC0, 0xDA, 0x98, 0x84, 0x4E, + 0x41, 0x54, 0x5E, 0x24, 0x4C, 0x31, 0x57, 0xA1, + 0x42, 0x8D, 0x7B, 0x4C, 0x21, 0xF9, 0xCD, 0x7E, + 0x40, 0x71, 0xAE, 0xD7, 0x7B, 0x7C, 0xA9, 0xF1, + 0xC3, 0x8F, 0xBA, 0x32, 0x23, 0x74, 0x12, 0xEF, + 0x21, 0xA3, 0x42, 0x74, 0x2E, 0xC8, 0x32, 0x43, + 0x78, 0xF2, 0x1E, 0x50, 0x7F, 0xAF, 0xDD, 0x88 + }, + { + 0x46, 0x7A, 0x33, 0xFB, 0xAD, 0xF5, 0xEB, 0xC5, + 0x25, 0x96, 0xEF, 0x86, 0xAA, 0xAE, 0xFC, 0x6F, + 0xAB, 0xA8, 0xEE, 0x65, 0x1B, 0x1C, 0xE0, 0x4D, + 0xE3, 0x68, 0xA0, 0x3A, 0x5A, 0x90, 0x40, 0xEF, + 0x28, 0x35, 0xE0, 0x0A, 0xDB, 0x09, 0xAB, 0xB3, + 0xFB, 0xD2, 0xBC, 0xE8, 0x18, 0xA2, 0x41, 0x3D, + 0x0B, 0x02, 0x53, 0xB5, 0xBD, 0xA4, 0xFC, 0x5B, + 0x2F, 0x6F, 0x85, 0xF3, 0xFD, 0x5B, 0x55, 0xF2 + }, + { + 0x22, 0xEF, 0xF8, 0xE6, 0xDD, 0x52, 0x36, 0xF5, + 0xF5, 0x7D, 0x94, 0xED, 0xE8, 0x74, 0xD6, 0xC9, + 0x42, 0x8E, 0x8F, 0x5D, 0x56, 0x6F, 0x17, 0xCD, + 0x6D, 0x18, 0x48, 0xCD, 0x75, 0x2F, 0xE1, 0x3C, + 0x65, 0x5C, 0xB1, 0x0F, 0xBA, 0xAF, 0xF7, 0x68, + 0x72, 0xF2, 0xBF, 0x2D, 0xA9, 0x9E, 0x15, 0xDC, + 0x62, 0x40, 0x75, 0xE1, 0xEC, 0x2F, 0x58, 0xA3, + 0xF6, 0x40, 0x72, 0x12, 0x18, 0x38, 0x56, 0x9E + }, + { + 0x9C, 0xEC, 0x6B, 0xBF, 0x62, 0xC4, 0xBC, 0xE4, + 0x13, 0x8A, 0xBA, 0xE1, 0xCB, 0xEC, 0x8D, 0xAD, + 0x31, 0x95, 0x04, 0x44, 0xE9, 0x03, 0x21, 0xB1, + 0x34, 0x71, 0x96, 0x83, 0x4C, 0x11, 0x4B, 0x86, + 0x4A, 0xF3, 0xF3, 0xCC, 0x35, 0x08, 0xF8, 0x37, + 0x51, 0xFF, 0xB4, 0xED, 0xA7, 0xC8, 0x4D, 0x14, + 0x07, 0x34, 0xBB, 0x42, 0x63, 0xC3, 0x62, 0x5C, + 0x00, 0xF0, 0x4F, 0x4C, 0x80, 0x68, 0x98, 0x1B + }, + { + 0xA8, 0xB6, 0x0F, 0xA4, 0xFC, 0x24, 0x42, 0xF6, + 0xF1, 0x51, 0x4A, 0xD7, 0x40, 0x26, 0x26, 0x92, + 0x0C, 0xC7, 0xC2, 0xC9, 0xF7, 0x21, 0x24, 0xB8, + 0xCB, 0xA8, 0xEE, 0x2C, 0xB7, 0xC4, 0x58, 0x6F, + 0x65, 0x8A, 0x44, 0x10, 0xCF, 0xFC, 0xC0, 0xAB, + 0x88, 0x34, 0x39, 0x55, 0xE0, 0x94, 0xC6, 0xAF, + 0x0D, 0x20, 0xD0, 0xC7, 0x14, 0xFB, 0x0A, 0x98, + 0x8F, 0x54, 0x3F, 0x30, 0x0F, 0x58, 0xD3, 0x89 + }, + { + 0x82, 0x71, 0xCC, 0x45, 0xDF, 0xA5, 0xE4, 0x17, + 0x0E, 0x84, 0x7E, 0x86, 0x30, 0xB9, 0x52, 0xCF, + 0x9C, 0x2A, 0xA7, 0x77, 0xD0, 0x6F, 0x26, 0xA7, + 0x58, 0x5B, 0x83, 0x81, 0xF1, 0x88, 0xDA, 0xCC, + 0x73, 0x37, 0x39, 0x1C, 0xFC, 0xC9, 0x4B, 0x05, + 0x3D, 0xC4, 0xEC, 0x29, 0xCC, 0x17, 0xF0, 0x77, + 0x87, 0x04, 0x28, 0xF1, 0xAC, 0x23, 0xFD, 0xDD, + 0xA1, 0x65, 0xEF, 0x5A, 0x3F, 0x15, 0x5F, 0x39 + }, + { + 0xBF, 0x23, 0xC0, 0xC2, 0x5C, 0x80, 0x60, 0xE4, + 0xF6, 0x99, 0x5F, 0x16, 0x23, 0xA3, 0xBE, 0xBE, + 0xCA, 0xA9, 0x6E, 0x30, 0x86, 0x80, 0x00, 0x0A, + 0x8A, 0xA3, 0xCD, 0x56, 0xBB, 0x1A, 0x6D, 0xA0, + 0x99, 0xE1, 0x0D, 0x92, 0x31, 0xB3, 0x7F, 0x45, + 0x19, 0xB2, 0xEF, 0xD2, 0xC2, 0x4D, 0xE7, 0x2F, + 0x31, 0xA5, 0xF1, 0x95, 0x35, 0x24, 0x1B, 0x4A, + 0x59, 0xFA, 0x3C, 0x03, 0xCE, 0xB7, 0x90, 0xE7 + }, + { + 0x87, 0x7F, 0xD6, 0x52, 0xC0, 0x52, 0x81, 0x00, + 0x9C, 0x0A, 0x52, 0x50, 0xE7, 0xA3, 0xA6, 0x71, + 0xF8, 0xB1, 0x8C, 0x10, 0x88, 0x17, 0xFE, 0x4A, + 0x87, 0x4D, 0xE2, 0x2D, 0xA8, 0xE4, 0x5D, 0xB1, + 0x19, 0x58, 0xA6, 0x00, 0xC5, 0xF6, 0x2E, 0x67, + 0xD3, 0x6C, 0xBF, 0x84, 0x47, 0x4C, 0xF2, 0x44, + 0xA9, 0xC2, 0xB0, 0x3A, 0x9F, 0xB9, 0xDC, 0x71, + 0x1C, 0xD1, 0xA2, 0xCA, 0xB6, 0xF3, 0xFA, 0xE0 + }, + { + 0x29, 0xDF, 0x4D, 0x87, 0xEA, 0x44, 0x4B, 0xAF, + 0x5B, 0xCD, 0xF5, 0xF4, 0xE4, 0x15, 0x79, 0xE2, + 0x8A, 0x67, 0xDE, 0x84, 0x14, 0x9F, 0x06, 0xC0, + 0x3F, 0x11, 0x0E, 0xA8, 0x4F, 0x57, 0x2A, 0x9F, + 0x67, 0x6A, 0xDD, 0xD0, 0x4C, 0x48, 0x78, 0xF4, + 0x9C, 0x5C, 0x00, 0xAC, 0xCD, 0xA4, 0x41, 0xB1, + 0xA3, 0x87, 0xCA, 0xCE, 0xB2, 0xE9, 0x93, 0xBB, + 0x7A, 0x10, 0xCD, 0x8C, 0x2D, 0x67, 0x17, 0xE1 + }, + { + 0x71, 0x0D, 0xAC, 0xB1, 0x66, 0x84, 0x46, 0x39, + 0xCD, 0x7B, 0x63, 0x7C, 0x27, 0x42, 0x09, 0x42, + 0x4E, 0x24, 0x49, 0xDC, 0x35, 0xD7, 0x90, 0xBB, + 0xFA, 0x4F, 0x76, 0x17, 0x70, 0x54, 0xA3, 0x6B, + 0x3B, 0x76, 0xFA, 0xC0, 0xCA, 0x6E, 0x61, 0xDF, + 0x1E, 0x68, 0x70, 0x00, 0x67, 0x8A, 0xC0, 0x74, + 0x6D, 0xF7, 0x5D, 0x0A, 0x39, 0x54, 0x89, 0x76, + 0x81, 0xFD, 0x39, 0x3A, 0x15, 0x5A, 0x1B, 0xB4 + }, + { + 0xC1, 0xD5, 0xF9, 0x3B, 0x8D, 0xEA, 0x1F, 0x25, + 0x71, 0xBA, 0xBC, 0xCB, 0xC0, 0x17, 0x64, 0x54, + 0x1A, 0x0C, 0xDA, 0x87, 0xE4, 0x44, 0xD6, 0x73, + 0xC5, 0x09, 0x66, 0xCA, 0x55, 0x9C, 0x33, 0x35, + 0x4B, 0x3A, 0xCB, 0x26, 0xE5, 0xD5, 0x78, 0x1F, + 0xFB, 0x28, 0x84, 0x7A, 0x4B, 0x47, 0x54, 0xD7, + 0x70, 0x08, 0xC6, 0x2A, 0x83, 0x58, 0x35, 0xF5, + 0x00, 0xDE, 0xA7, 0xC3, 0xB5, 0x8B, 0xDA, 0xE2 + }, + { + 0xA4, 0x1E, 0x41, 0x27, 0x1C, 0xDA, 0xB8, 0xAF, + 0x4D, 0x72, 0xB1, 0x04, 0xBF, 0xB2, 0xAD, 0x04, + 0x1A, 0xC4, 0xDF, 0x14, 0x67, 0x7D, 0xA6, 0x71, + 0xD8, 0x56, 0x40, 0xC4, 0xB1, 0x87, 0xF5, 0x0C, + 0x2B, 0x66, 0x51, 0x3C, 0x46, 0x19, 0xFB, 0xD5, + 0xD5, 0xDC, 0x4F, 0xE6, 0x5D, 0xD3, 0x7B, 0x90, + 0x42, 0xE9, 0x84, 0x8D, 0xDA, 0x55, 0x6A, 0x50, + 0x4C, 0xAA, 0x2B, 0x1C, 0x6A, 0xFE, 0x47, 0x30 + }, + { + 0xE7, 0xBC, 0xBA, 0xCD, 0xC3, 0x79, 0xC4, 0x3D, + 0x81, 0xEB, 0xAD, 0xCB, 0x37, 0x78, 0x15, 0x52, + 0xFC, 0x1D, 0x75, 0x3E, 0x8C, 0xF3, 0x10, 0xD9, + 0x68, 0x39, 0x2D, 0x06, 0xC9, 0x1F, 0x1D, 0x64, + 0xCC, 0x9E, 0x90, 0xCE, 0x1D, 0x22, 0xC3, 0x2D, + 0x27, 0x7F, 0xC6, 0xCD, 0xA4, 0x33, 0xA4, 0xD4, + 0x42, 0xC7, 0x62, 0xE9, 0xEA, 0xCF, 0x2C, 0x25, + 0x9F, 0x32, 0xD6, 0x4C, 0xF9, 0xDA, 0x3A, 0x22 + }, + { + 0x51, 0x75, 0x5B, 0x4A, 0xC5, 0x45, 0x6B, 0x13, + 0x21, 0x8A, 0x19, 0xC5, 0xB9, 0x24, 0x2F, 0x57, + 0xC4, 0xA9, 0x81, 0xE4, 0xD4, 0xEC, 0xDC, 0xE0, + 0x9A, 0x31, 0x93, 0x36, 0x2B, 0x80, 0x8A, 0x57, + 0x93, 0x45, 0xD4, 0x88, 0x1C, 0x26, 0x07, 0xA5, + 0x65, 0x34, 0xDD, 0x7F, 0x21, 0x95, 0x6A, 0xFF, + 0x72, 0xC2, 0xF4, 0x17, 0x3A, 0x6E, 0x7B, 0x6C, + 0xC2, 0x21, 0x2B, 0xA0, 0xE3, 0xDA, 0xEE, 0x1F + }, + { + 0xDC, 0xC2, 0xC4, 0xBE, 0xB9, 0xC1, 0xF2, 0x60, + 0x7B, 0x78, 0x6C, 0x20, 0xC6, 0x31, 0x97, 0x23, + 0x47, 0x03, 0x4C, 0x1C, 0xC0, 0x2F, 0xCC, 0x7D, + 0x02, 0xFF, 0x01, 0x09, 0x9C, 0xFE, 0x1C, 0x69, + 0x89, 0x84, 0x0A, 0xC2, 0x13, 0x92, 0x36, 0x29, + 0x11, 0x3A, 0xA8, 0xBA, 0xD7, 0x13, 0xCC, 0xF0, + 0xFE, 0x4C, 0xE1, 0x32, 0x64, 0xFB, 0x32, 0xB8, + 0xB0, 0xFE, 0x37, 0x2D, 0xA3, 0x82, 0x54, 0x4A + }, + { + 0x3D, 0x55, 0x17, 0x6A, 0xCE, 0xA4, 0xA7, 0xE3, + 0xA6, 0x5F, 0xFA, 0x9F, 0xB1, 0x0A, 0x7A, 0x17, + 0x67, 0x19, 0x9C, 0xF0, 0x77, 0xCE, 0xE9, 0xF7, + 0x15, 0x32, 0xD6, 0x7C, 0xD7, 0xC7, 0x3C, 0x9F, + 0x93, 0xCF, 0xC3, 0x7C, 0xCD, 0xCC, 0x1F, 0xDE, + 0xF5, 0x0A, 0xAD, 0x46, 0xA5, 0x04, 0xA6, 0x50, + 0xD2, 0x98, 0xD5, 0x97, 0xA3, 0xA9, 0xFA, 0x95, + 0xC6, 0xC4, 0x0C, 0xB7, 0x1F, 0xA5, 0xE7, 0x25 + }, + { + 0xD0, 0x77, 0x13, 0xC0, 0x05, 0xDE, 0x96, 0xDD, + 0x21, 0xD2, 0xEB, 0x8B, 0xBE, 0xCA, 0x66, 0x74, + 0x6E, 0xA5, 0x1A, 0x31, 0xAE, 0x92, 0x2A, 0x3E, + 0x74, 0x86, 0x48, 0x89, 0x54, 0x0A, 0x48, 0xDB, + 0x27, 0xD7, 0xE4, 0xC9, 0x03, 0x11, 0x63, 0x8B, + 0x22, 0x4B, 0xF0, 0x20, 0x1B, 0x50, 0x18, 0x91, + 0x75, 0x48, 0x48, 0x11, 0x3C, 0x26, 0x61, 0x08, + 0xD0, 0xAD, 0xB1, 0x3D, 0xB7, 0x19, 0x09, 0xC7 + }, + { + 0x58, 0x98, 0x3C, 0x21, 0x43, 0x3D, 0x95, 0x0C, + 0xAA, 0x23, 0xE4, 0xBC, 0x18, 0x54, 0x3B, 0x8E, + 0x60, 0x1C, 0x20, 0x43, 0x18, 0x53, 0x21, 0x52, + 0xDA, 0xF5, 0xE1, 0x59, 0xA0, 0xCD, 0x14, 0x80, + 0x18, 0x3D, 0x29, 0x28, 0x5C, 0x05, 0xF1, 0x29, + 0xCB, 0x0C, 0xC3, 0x16, 0x46, 0x87, 0x92, 0x80, + 0x86, 0xFF, 0xE3, 0x80, 0x15, 0x8D, 0xF1, 0xD3, + 0x94, 0xC6, 0xAC, 0x0D, 0x42, 0x88, 0xBC, 0xA8 + }, + { + 0x81, 0x00, 0xA8, 0xDC, 0x52, 0x8D, 0x2B, 0x68, + 0x2A, 0xB4, 0x25, 0x08, 0x01, 0xBA, 0x33, 0xF0, + 0x2A, 0x3E, 0x94, 0xC5, 0x4D, 0xAC, 0x0A, 0xE1, + 0x48, 0x2A, 0xA2, 0x1F, 0x51, 0xEF, 0x3A, 0x82, + 0xF3, 0x80, 0x7E, 0x6F, 0xAC, 0xB0, 0xAE, 0xB0, + 0x59, 0x47, 0xBF, 0x7A, 0xA2, 0xAD, 0xCB, 0x03, + 0x43, 0x56, 0xF9, 0x0F, 0xA4, 0x56, 0x0E, 0xDE, + 0x02, 0x20, 0x1A, 0x37, 0xE4, 0x11, 0xEC, 0x1A + }, + { + 0x07, 0x02, 0x5F, 0x1B, 0xB6, 0xC7, 0x84, 0xF3, + 0xFE, 0x49, 0xDE, 0x5C, 0x14, 0xB9, 0x36, 0xA5, + 0xAC, 0xAC, 0xAC, 0xAA, 0xB3, 0x3F, 0x6A, 0xC4, + 0xD0, 0xE0, 0x0A, 0xB6, 0xA1, 0x24, 0x83, 0xD6, + 0xBE, 0xC0, 0x0B, 0x4F, 0xE6, 0x7C, 0x7C, 0xA5, + 0xCC, 0x50, 0x8C, 0x2A, 0x53, 0xEF, 0xB5, 0xBF, + 0xA5, 0x39, 0x87, 0x69, 0xD8, 0x43, 0xFF, 0x0D, + 0x9E, 0x8B, 0x14, 0xD3, 0x6A, 0x01, 0xA7, 0x7F + }, + { + 0xBA, 0x6A, 0xEF, 0xD9, 0x72, 0xB6, 0x18, 0x6E, + 0x02, 0x7A, 0x76, 0x27, 0x3A, 0x4A, 0x72, 0x33, + 0x21, 0xA3, 0xF5, 0x80, 0xCF, 0xA8, 0x94, 0xDA, + 0x5A, 0x9C, 0xE8, 0xE7, 0x21, 0xC8, 0x28, 0x55, + 0x2C, 0x64, 0xDA, 0xCE, 0xE3, 0xA7, 0xFD, 0x2D, + 0x74, 0x3B, 0x5C, 0x35, 0xAD, 0x0C, 0x8E, 0xFA, + 0x71, 0xF8, 0xCE, 0x99, 0xBF, 0x96, 0x33, 0x47, + 0x10, 0xE2, 0xC2, 0x34, 0x6E, 0x8F, 0x3C, 0x52 + }, + { + 0xE0, 0x72, 0x1E, 0x02, 0x51, 0x7A, 0xED, 0xFA, + 0x4E, 0x7E, 0x9B, 0xA5, 0x03, 0xE0, 0x25, 0xFD, + 0x46, 0xE7, 0x14, 0x56, 0x6D, 0xC8, 0x89, 0xA8, + 0x4C, 0xBF, 0xE5, 0x6A, 0x55, 0xDF, 0xBE, 0x2F, + 0xC4, 0x93, 0x8A, 0xC4, 0x12, 0x05, 0x88, 0x33, + 0x5D, 0xEA, 0xC8, 0xEF, 0x3F, 0xA2, 0x29, 0xAD, + 0xC9, 0x64, 0x7F, 0x54, 0xAD, 0x2E, 0x34, 0x72, + 0x23, 0x4F, 0x9B, 0x34, 0xEF, 0xC4, 0x65, 0x43 + }, + { + 0xB6, 0x29, 0x26, 0x69, 0xCC, 0xD3, 0x8D, 0x5F, + 0x01, 0xCA, 0xAE, 0x96, 0xBA, 0x27, 0x2C, 0x76, + 0xA8, 0x79, 0xA4, 0x57, 0x43, 0xAF, 0xA0, 0x72, + 0x5D, 0x83, 0xB9, 0xEB, 0xB2, 0x66, 0x65, 0xB7, + 0x31, 0xF1, 0x84, 0x8C, 0x52, 0xF1, 0x19, 0x72, + 0xB6, 0x64, 0x4F, 0x55, 0x4C, 0x06, 0x4F, 0xA9, + 0x07, 0x80, 0xDB, 0xBB, 0xF3, 0xA8, 0x9D, 0x4F, + 0xC3, 0x1F, 0x67, 0xDF, 0x3E, 0x58, 0x57, 0xEF + }, + { + 0x23, 0x19, 0xE3, 0x78, 0x9C, 0x47, 0xE2, 0xDA, + 0xA5, 0xFE, 0x80, 0x7F, 0x61, 0xBE, 0xC2, 0xA1, + 0xA6, 0x53, 0x7F, 0xA0, 0x3F, 0x19, 0xFF, 0x32, + 0xE8, 0x7E, 0xEC, 0xBF, 0xD6, 0x4B, 0x7E, 0x0E, + 0x8C, 0xCF, 0xF4, 0x39, 0xAC, 0x33, 0x3B, 0x04, + 0x0F, 0x19, 0xB0, 0xC4, 0xDD, 0xD1, 0x1A, 0x61, + 0xE2, 0x4A, 0xC1, 0xFE, 0x0F, 0x10, 0xA0, 0x39, + 0x80, 0x6C, 0x5D, 0xCC, 0x0D, 0xA3, 0xD1, 0x15 + }, + { + 0xF5, 0x97, 0x11, 0xD4, 0x4A, 0x03, 0x1D, 0x5F, + 0x97, 0xA9, 0x41, 0x3C, 0x06, 0x5D, 0x1E, 0x61, + 0x4C, 0x41, 0x7E, 0xDE, 0x99, 0x85, 0x90, 0x32, + 0x5F, 0x49, 0xBA, 0xD2, 0xFD, 0x44, 0x4D, 0x3E, + 0x44, 0x18, 0xBE, 0x19, 0xAE, 0xC4, 0xE1, 0x14, + 0x49, 0xAC, 0x1A, 0x57, 0x20, 0x78, 0x98, 0xBC, + 0x57, 0xD7, 0x6A, 0x1B, 0xCF, 0x35, 0x66, 0x29, + 0x2C, 0x20, 0xC6, 0x83, 0xA5, 0xC4, 0x64, 0x8F + }, + { + 0xDF, 0x0A, 0x9D, 0x0C, 0x21, 0x28, 0x43, 0xA6, + 0xA9, 0x34, 0xE3, 0x90, 0x2B, 0x2D, 0xD3, 0x0D, + 0x17, 0xFB, 0xA5, 0xF9, 0x69, 0xD2, 0x03, 0x0B, + 0x12, 0xA5, 0x46, 0xD8, 0xA6, 0xA4, 0x5E, 0x80, + 0xCF, 0x56, 0x35, 0xF0, 0x71, 0xF0, 0x45, 0x2E, + 0x9C, 0x91, 0x92, 0x75, 0xDA, 0x99, 0xBE, 0xD5, + 0x1E, 0xB1, 0x17, 0x3C, 0x1A, 0xF0, 0x51, 0x87, + 0x26, 0xB7, 0x5B, 0x0E, 0xC3, 0xBA, 0xE2, 0xB5 + }, + { + 0xA3, 0xEB, 0x6E, 0x6C, 0x7B, 0xF2, 0xFB, 0x8B, + 0x28, 0xBF, 0xE8, 0xB1, 0x5E, 0x15, 0xBB, 0x50, + 0x0F, 0x78, 0x1E, 0xCC, 0x86, 0xF7, 0x78, 0xC3, + 0xA4, 0xE6, 0x55, 0xFC, 0x58, 0x69, 0xBF, 0x28, + 0x46, 0xA2, 0x45, 0xD4, 0xE3, 0x3B, 0x7B, 0x14, + 0x43, 0x6A, 0x17, 0xE6, 0x3B, 0xE7, 0x9B, 0x36, + 0x65, 0x5C, 0x22, 0x6A, 0x50, 0xFF, 0xBC, 0x71, + 0x24, 0x20, 0x7B, 0x02, 0x02, 0x34, 0x2D, 0xB5 + }, + { + 0x56, 0xD4, 0xCB, 0xCD, 0x07, 0x05, 0x63, 0x42, + 0x6A, 0x01, 0x70, 0x69, 0x42, 0x5C, 0x2C, 0xD2, + 0xAE, 0x54, 0x06, 0x68, 0x28, 0x7A, 0x5F, 0xB9, + 0xDA, 0xC4, 0x32, 0xEB, 0x8A, 0xB1, 0xA3, 0x53, + 0xA3, 0x0F, 0x2F, 0xE1, 0xF4, 0x0D, 0x83, 0x33, + 0x3A, 0xFE, 0x69, 0x6A, 0x26, 0x77, 0x95, 0x40, + 0x8A, 0x92, 0xFE, 0x7D, 0xA0, 0x7A, 0x0C, 0x18, + 0x14, 0xCF, 0x77, 0xF3, 0x6E, 0x10, 0x5E, 0xE8 + }, + { + 0xE5, 0x9B, 0x99, 0x87, 0xD4, 0x28, 0xB3, 0xED, + 0xA3, 0x7D, 0x80, 0xAB, 0xDB, 0x16, 0xCD, 0x2B, + 0x0A, 0xEF, 0x67, 0x4C, 0x2B, 0x1D, 0xDA, 0x44, + 0x32, 0xEA, 0x91, 0xEE, 0x6C, 0x93, 0x5C, 0x68, + 0x4B, 0x48, 0xB4, 0x42, 0x8A, 0x8C, 0xC7, 0x40, + 0xE5, 0x79, 0xA3, 0x0D, 0xEF, 0xF3, 0x5A, 0x80, + 0x30, 0x13, 0x82, 0x0D, 0xD2, 0x3F, 0x14, 0xAE, + 0x1D, 0x84, 0x13, 0xB5, 0xC8, 0x67, 0x2A, 0xEC + }, + { + 0xCD, 0x9F, 0xCC, 0x99, 0xF9, 0x9D, 0x4C, 0xC1, + 0x6D, 0x03, 0x19, 0x00, 0xB2, 0xA7, 0x36, 0xE1, + 0x50, 0x8D, 0xB4, 0xB5, 0x86, 0x81, 0x4E, 0x63, + 0x45, 0x85, 0x7F, 0x35, 0x4A, 0x70, 0xCC, 0xEC, + 0xB1, 0xDF, 0x3B, 0x50, 0xA1, 0x9A, 0xDA, 0xF4, + 0x3C, 0x27, 0x8E, 0xFA, 0x42, 0x3F, 0xF4, 0xBB, + 0x6C, 0x52, 0x3E, 0xC7, 0xFD, 0x78, 0x59, 0xB9, + 0x7B, 0x16, 0x8A, 0x7E, 0xBF, 0xF8, 0x46, 0x7C + }, + { + 0x06, 0x02, 0x18, 0x5D, 0x8C, 0x3A, 0x78, 0x73, + 0x8B, 0x99, 0x16, 0x4B, 0x8B, 0xC6, 0xFF, 0xB2, + 0x1C, 0x7D, 0xEB, 0xEB, 0xBF, 0x80, 0x63, 0x72, + 0xE0, 0xDA, 0x44, 0xD1, 0x21, 0x54, 0x55, 0x97, + 0xB9, 0xC6, 0x62, 0xA2, 0x55, 0xDC, 0x31, 0x54, + 0x2C, 0xF9, 0x95, 0xEC, 0xBE, 0x6A, 0x50, 0xFB, + 0x5E, 0x6E, 0x0E, 0xE4, 0xEF, 0x24, 0x0F, 0xE5, + 0x57, 0xED, 0xED, 0x11, 0x88, 0x08, 0x7E, 0x86 + }, + { + 0xC0, 0x8A, 0xFA, 0x5B, 0x92, 0x7B, 0xF0, 0x80, + 0x97, 0xAF, 0xC5, 0xFF, 0xF9, 0xCA, 0x4E, 0x78, + 0x00, 0x12, 0x5C, 0x1F, 0x52, 0xF2, 0xAF, 0x35, + 0x53, 0xFA, 0x2B, 0x89, 0xE1, 0xE3, 0x01, 0x5C, + 0x4F, 0x87, 0xD5, 0xE0, 0xA4, 0x89, 0x56, 0xAD, + 0x31, 0x45, 0x0B, 0x08, 0x3D, 0xAD, 0x14, 0x7F, + 0xFB, 0x5E, 0xC0, 0x34, 0x34, 0xA2, 0x68, 0x30, + 0xCF, 0x37, 0xD1, 0x03, 0xAB, 0x50, 0xC5, 0xDA + }, + { + 0x36, 0xF1, 0xE1, 0xC1, 0x1D, 0x6E, 0xF6, 0xBC, + 0x3B, 0x53, 0x6D, 0x50, 0x5D, 0x54, 0x4A, 0x87, + 0x15, 0x22, 0xC5, 0xC2, 0xA2, 0x53, 0x06, 0x7E, + 0xC9, 0x93, 0x3B, 0x6E, 0xC2, 0x54, 0x64, 0xDA, + 0xF9, 0x85, 0x52, 0x5F, 0x5B, 0x95, 0x60, 0xA1, + 0x6D, 0x89, 0x02, 0x59, 0xAC, 0x1B, 0xB5, 0xCC, + 0x67, 0xC0, 0xC4, 0x69, 0xCD, 0xE1, 0x33, 0xDE, + 0xF0, 0x00, 0xEA, 0x1D, 0x68, 0x6F, 0x4F, 0x5D + }, + { + 0xBF, 0x2A, 0xB2, 0xE2, 0x47, 0x0F, 0x54, 0x38, + 0xC3, 0xB6, 0x89, 0xE6, 0x6E, 0x76, 0x86, 0xFF, + 0xFA, 0x0C, 0xB1, 0xE1, 0x79, 0x8A, 0xD3, 0xA8, + 0x6F, 0xF9, 0x90, 0x75, 0xBF, 0x61, 0x38, 0xE3, + 0x3D, 0x9C, 0x0C, 0xE5, 0x9A, 0xFB, 0x24, 0xAC, + 0x67, 0xA0, 0x2A, 0xF3, 0x44, 0x28, 0x19, 0x1A, + 0x9A, 0x0A, 0x60, 0x41, 0xC0, 0x74, 0x71, 0xB7, + 0xC3, 0xB1, 0xA7, 0x52, 0xD6, 0xFC, 0x0B, 0x8B + }, + { + 0xD4, 0x00, 0x60, 0x1F, 0x97, 0x28, 0xCC, 0xC4, + 0xC9, 0x23, 0x42, 0xD9, 0x78, 0x7D, 0x8D, 0x28, + 0xAB, 0x32, 0x3A, 0xF3, 0x75, 0xCA, 0x56, 0x24, + 0xB4, 0xBB, 0x91, 0xD1, 0x72, 0x71, 0xFB, 0xAE, + 0x86, 0x2E, 0x41, 0x3B, 0xE7, 0x3F, 0x1F, 0x68, + 0xE6, 0x15, 0xB8, 0xC5, 0xC3, 0x91, 0xBE, 0x0D, + 0xBD, 0x91, 0x44, 0x74, 0x6E, 0xB3, 0x39, 0xAD, + 0x54, 0x15, 0x47, 0xBA, 0x9C, 0x46, 0x8A, 0x17 + }, + { + 0x79, 0xFE, 0x2F, 0xE1, 0x57, 0xEB, 0x85, 0xA0, + 0x38, 0xAB, 0xB8, 0xEB, 0xBC, 0x64, 0x77, 0x31, + 0xD2, 0xC8, 0x3F, 0x51, 0xB0, 0xAC, 0x6E, 0xE1, + 0x4A, 0xA2, 0x84, 0xCB, 0x6A, 0x35, 0x49, 0xA4, + 0xDC, 0xCE, 0xB3, 0x00, 0x74, 0x0A, 0x82, 0x5F, + 0x52, 0xF5, 0xFB, 0x30, 0xB0, 0x3B, 0x8C, 0x4D, + 0x8B, 0x0F, 0x4A, 0xA6, 0x7A, 0x63, 0xF4, 0xA9, + 0x4E, 0x33, 0x03, 0xC4, 0xED, 0xA4, 0xC0, 0x2B + }, + { + 0x75, 0x35, 0x13, 0x13, 0xB5, 0x2A, 0x85, 0x29, + 0x29, 0x8D, 0x8C, 0x18, 0x6B, 0x17, 0x68, 0x66, + 0x6D, 0xCC, 0xA8, 0x59, 0x53, 0x17, 0xD7, 0xA4, + 0x81, 0x6E, 0xB8, 0x8C, 0x06, 0x20, 0x20, 0xC0, + 0xC8, 0xEF, 0xC5, 0x54, 0xBB, 0x34, 0x1B, 0x64, + 0x68, 0x8D, 0xB5, 0xCC, 0xAF, 0xC3, 0x5F, 0x3C, + 0x3C, 0xD0, 0x9D, 0x65, 0x64, 0xB3, 0x6D, 0x7B, + 0x04, 0xA2, 0x48, 0xE1, 0x46, 0x98, 0x0D, 0x4B + }, + { + 0xE3, 0x12, 0x8B, 0x1D, 0x31, 0x1D, 0x02, 0x17, + 0x9D, 0x7F, 0x25, 0xF9, 0x7A, 0x5A, 0x8B, 0xEE, + 0x2C, 0xC8, 0xC8, 0x63, 0x03, 0x64, 0x4F, 0xCD, + 0x66, 0x4E, 0x15, 0x7D, 0x1F, 0xEF, 0x00, 0xF2, + 0x3E, 0x46, 0xF9, 0xA5, 0xE8, 0xE5, 0xC8, 0x90, + 0xCE, 0x56, 0x5B, 0xB6, 0xAB, 0xD4, 0x30, 0x2C, + 0xE0, 0x64, 0x69, 0xD5, 0x2A, 0x5B, 0xD5, 0x3E, + 0x1C, 0x5A, 0x54, 0xD0, 0x46, 0x49, 0xDC, 0x03 + }, + { + 0xC2, 0x38, 0x2A, 0x72, 0xD2, 0xD3, 0xAC, 0xE9, + 0xD5, 0x93, 0x3D, 0x00, 0xB6, 0x08, 0x27, 0xED, + 0x38, 0x0C, 0xDA, 0x08, 0xD0, 0xBA, 0x5F, 0x6D, + 0xD4, 0x1E, 0x29, 0xEE, 0x6D, 0xBE, 0x8E, 0xCB, + 0x92, 0x35, 0xF0, 0x6B, 0xE9, 0x5D, 0x83, 0xB6, + 0x81, 0x6A, 0x2F, 0xB7, 0xA5, 0xAD, 0x47, 0x03, + 0x5E, 0x8A, 0x4B, 0x69, 0xA4, 0x88, 0x4B, 0x99, + 0xE4, 0xBE, 0xCE, 0x58, 0xCA, 0xB2, 0x5D, 0x44 + }, + { + 0x6B, 0x1C, 0x69, 0x46, 0x0B, 0xBD, 0x50, 0xAC, + 0x2E, 0xD6, 0xF3, 0x2E, 0x6E, 0x88, 0x7C, 0xFE, + 0xD4, 0x07, 0xD4, 0x7D, 0xCF, 0x0A, 0xAA, 0x60, + 0x38, 0x7F, 0xE3, 0x20, 0xD7, 0x80, 0xBD, 0x03, + 0xEA, 0xB6, 0xD7, 0xBA, 0xEB, 0x2A, 0x07, 0xD1, + 0x0C, 0xD5, 0x52, 0xA3, 0x00, 0x34, 0x13, 0x54, + 0xEA, 0x9A, 0x5F, 0x03, 0x18, 0x3A, 0x62, 0x3F, + 0x92, 0xA2, 0xD4, 0xD9, 0xF0, 0x09, 0x26, 0xAF + }, + { + 0x6C, 0xDA, 0x20, 0x6C, 0x80, 0xCD, 0xC9, 0xC4, + 0x4B, 0xA9, 0x90, 0xE0, 0x32, 0x8C, 0x31, 0x4F, + 0x81, 0x9B, 0x14, 0x2D, 0x00, 0x63, 0x04, 0x04, + 0xC4, 0x8C, 0x05, 0xDC, 0x76, 0xD1, 0xB0, 0x0C, + 0xE4, 0xD7, 0x2F, 0xC6, 0xA4, 0x8E, 0x14, 0x69, + 0xDD, 0xEF, 0x60, 0x94, 0x12, 0xC3, 0x64, 0x82, + 0x08, 0x54, 0x21, 0x4B, 0x48, 0x69, 0xAF, 0x09, + 0x0F, 0x00, 0xD3, 0xC1, 0xBA, 0x44, 0x3E, 0x1B + }, + { + 0x7F, 0xFC, 0x8C, 0x26, 0xFB, 0xD6, 0xA0, 0xF7, + 0xA6, 0x09, 0xE6, 0xE1, 0x93, 0x9F, 0x6A, 0x9E, + 0xDF, 0x1B, 0x0B, 0x06, 0x66, 0x41, 0xFB, 0x76, + 0xC4, 0xF9, 0x60, 0x2E, 0xD7, 0x48, 0xD1, 0x16, + 0x02, 0x49, 0x6B, 0x35, 0x35, 0x5B, 0x1A, 0xA2, + 0x55, 0x85, 0x0A, 0x50, 0x9D, 0x2F, 0x8E, 0xE1, + 0x8C, 0x8F, 0x3E, 0x1D, 0x7D, 0xCB, 0xC3, 0x7A, + 0x13, 0x65, 0x98, 0xF5, 0x6A, 0x59, 0xED, 0x17 + }, + { + 0x70, 0xDE, 0x1F, 0x08, 0xDD, 0x4E, 0x09, 0xD5, + 0xFC, 0x15, 0x1F, 0x17, 0xFC, 0x99, 0x1A, 0x23, + 0xAB, 0xFC, 0x05, 0x10, 0x42, 0x90, 0xD5, 0x04, + 0x68, 0x88, 0x2E, 0xFA, 0xF5, 0x82, 0xB6, 0xEC, + 0x2F, 0x14, 0xF5, 0x77, 0xC0, 0xD6, 0x8C, 0x3A, + 0xD0, 0x66, 0x26, 0x91, 0x6E, 0x3C, 0x86, 0xE6, + 0xDA, 0xAB, 0x6C, 0x53, 0xE5, 0x16, 0x3E, 0x82, + 0xB6, 0xBD, 0x0C, 0xE4, 0x9F, 0xC0, 0xD8, 0xDF + }, + { + 0x4F, 0x81, 0x93, 0x57, 0x56, 0xED, 0x35, 0xEE, + 0x20, 0x58, 0xEE, 0x0C, 0x6A, 0x61, 0x10, 0xD6, + 0xFA, 0xC5, 0xCB, 0x6A, 0x4F, 0x46, 0xAA, 0x94, + 0x11, 0x60, 0x3F, 0x99, 0x96, 0x58, 0x23, 0xB6, + 0xDA, 0x48, 0x38, 0x27, 0x6C, 0x5C, 0x06, 0xBC, + 0x78, 0x80, 0xE3, 0x76, 0xD9, 0x27, 0x58, 0x36, + 0x9E, 0xE7, 0x30, 0x5B, 0xCE, 0xC8, 0xD3, 0xCF, + 0xD2, 0x8C, 0xCA, 0xBB, 0x7B, 0x4F, 0x05, 0x79 + }, + { + 0xAB, 0xCB, 0x61, 0xCB, 0x36, 0x83, 0xD1, 0x8F, + 0x27, 0xAD, 0x52, 0x79, 0x08, 0xED, 0x2D, 0x32, + 0xA0, 0x42, 0x6C, 0xB7, 0xBB, 0x4B, 0xF1, 0x80, + 0x61, 0x90, 0x3A, 0x7D, 0xC4, 0x2E, 0x7E, 0x76, + 0xF9, 0x82, 0x38, 0x23, 0x04, 0xD1, 0x8A, 0xF8, + 0xC8, 0x0D, 0x91, 0xDD, 0x58, 0xDD, 0x47, 0xAF, + 0x76, 0xF8, 0xE2, 0xC3, 0x6E, 0x28, 0xAF, 0x24, + 0x76, 0xB4, 0xBC, 0xCF, 0x82, 0xE8, 0x9F, 0xDF + }, + { + 0x02, 0xD2, 0x61, 0xAD, 0x56, 0xA5, 0x26, 0x33, + 0x1B, 0x64, 0x3D, 0xD2, 0x18, 0x6D, 0xE9, 0xA8, + 0x2E, 0x72, 0xA5, 0x82, 0x23, 0xCD, 0x1E, 0x72, + 0x36, 0x86, 0xC5, 0x3D, 0x86, 0x9B, 0x83, 0xB9, + 0x46, 0x32, 0xB7, 0xB6, 0x47, 0xAB, 0x2A, 0xFC, + 0x0D, 0x52, 0x2E, 0x29, 0xDA, 0x3A, 0x56, 0x15, + 0xB7, 0x41, 0xD8, 0x28, 0x52, 0xE0, 0xDF, 0x41, + 0xB6, 0x60, 0x07, 0xDB, 0xCB, 0xA9, 0x05, 0x43 + }, + { + 0xC5, 0x83, 0x27, 0x41, 0xFA, 0x30, 0xC5, 0x43, + 0x68, 0x23, 0x01, 0x53, 0x83, 0xD2, 0x97, 0xFF, + 0x4C, 0x4A, 0x5D, 0x72, 0x76, 0xC3, 0xF9, 0x02, + 0x12, 0x20, 0x66, 0xE0, 0x4B, 0xE5, 0x43, 0x1B, + 0x1A, 0x85, 0xFA, 0xF7, 0x3B, 0x91, 0x84, 0x34, + 0xF9, 0x30, 0x09, 0x63, 0xD1, 0xDE, 0xA9, 0xE8, + 0xAC, 0x39, 0x24, 0xEF, 0x49, 0x02, 0x26, 0xED, + 0xEE, 0xA5, 0xF7, 0x43, 0xE4, 0x10, 0x66, 0x9F + }, + { + 0xCF, 0xAE, 0xAB, 0x26, 0x8C, 0xD0, 0x75, 0xA5, + 0xA6, 0xAE, 0xD5, 0x15, 0x02, 0x3A, 0x03, 0x2D, + 0x54, 0xF2, 0xF2, 0xFF, 0x73, 0x3C, 0xE0, 0xCB, + 0xC7, 0x8D, 0xB5, 0x1D, 0xB4, 0x50, 0x4D, 0x67, + 0x59, 0x23, 0xF8, 0x27, 0x46, 0xD6, 0x59, 0x46, + 0x06, 0xAD, 0x5D, 0x67, 0x73, 0x4B, 0x11, 0xA6, + 0x7C, 0xC6, 0xA4, 0x68, 0xC2, 0x03, 0x2E, 0x43, + 0xCA, 0x1A, 0x94, 0xC6, 0x27, 0x3A, 0x98, 0x5E + }, + { + 0x86, 0x08, 0x50, 0xF9, 0x2E, 0xB2, 0x68, 0x27, + 0x2B, 0x67, 0xD1, 0x33, 0x60, 0x9B, 0xD6, 0x4E, + 0x34, 0xF6, 0x1B, 0xF0, 0x3F, 0x4C, 0x17, 0x38, + 0x64, 0x5C, 0x17, 0xFE, 0xC8, 0x18, 0x46, 0x5D, + 0x7E, 0xCD, 0x2B, 0xE2, 0x90, 0x76, 0x41, 0x13, + 0x00, 0x25, 0xFD, 0xA7, 0x94, 0x70, 0xAB, 0x73, + 0x16, 0x46, 0xE7, 0xF6, 0x94, 0x40, 0xE8, 0x36, + 0x7E, 0xA7, 0x6A, 0xC4, 0xCE, 0xE8, 0xA1, 0xDF + }, + { + 0x84, 0xB1, 0x54, 0xED, 0x29, 0xBB, 0xED, 0xEF, + 0xA6, 0x48, 0x28, 0x68, 0x39, 0x04, 0x6F, 0x4B, + 0x5A, 0xA3, 0x44, 0x30, 0xE2, 0xD6, 0x7F, 0x74, + 0x96, 0xE4, 0xC3, 0x9F, 0x2C, 0x7E, 0xA7, 0x89, + 0x95, 0xF6, 0x9E, 0x12, 0x92, 0x20, 0x00, 0x16, + 0xF1, 0x6A, 0xC3, 0xB3, 0x77, 0x00, 0xE6, 0xC7, + 0xE7, 0x86, 0x1A, 0xFC, 0x39, 0x6B, 0x64, 0xA5, + 0x9A, 0x1D, 0xBF, 0x47, 0xA5, 0x5C, 0x4B, 0xBC + }, + { + 0xAE, 0xEE, 0xC2, 0x60, 0xA5, 0xD8, 0xEF, 0xF5, + 0xCC, 0xAB, 0x8B, 0x95, 0xDA, 0x43, 0x5A, 0x63, + 0xED, 0x7A, 0x21, 0xEA, 0x7F, 0xC7, 0x55, 0x94, + 0x13, 0xFD, 0x61, 0x7E, 0x33, 0x60, 0x9F, 0x8C, + 0x29, 0x0E, 0x64, 0xBB, 0xAC, 0xC5, 0x28, 0xF6, + 0xC0, 0x80, 0x26, 0x22, 0x88, 0xB0, 0xF0, 0xA3, + 0x21, 0x9B, 0xE2, 0x23, 0xC9, 0x91, 0xBE, 0xE9, + 0x2E, 0x72, 0x34, 0x95, 0x93, 0xE6, 0x76, 0x38 + }, + { + 0x8A, 0xD7, 0x8A, 0x9F, 0x26, 0x60, 0x1D, 0x12, + 0x7E, 0x8D, 0x2F, 0x2F, 0x97, 0x6E, 0x63, 0xD1, + 0x9A, 0x05, 0x4A, 0x17, 0xDC, 0xF5, 0x9E, 0x0F, + 0x01, 0x3A, 0xB5, 0x4A, 0x68, 0x87, 0xBB, 0xDF, + 0xFD, 0xE7, 0xAA, 0xAE, 0x11, 0x7E, 0x0F, 0xBF, + 0x32, 0x71, 0x01, 0x65, 0x95, 0xB9, 0xD9, 0xC7, + 0x12, 0xC0, 0x1B, 0x2C, 0x53, 0xE9, 0x65, 0x5A, + 0x38, 0x2B, 0xC4, 0x52, 0x2E, 0x61, 0x66, 0x45 + }, + { + 0x89, 0x34, 0x15, 0x9D, 0xAD, 0xE1, 0xAC, 0x74, + 0x14, 0x7D, 0xFA, 0x28, 0x2C, 0x75, 0x95, 0x4F, + 0xCE, 0xF4, 0x43, 0xEF, 0x25, 0xF8, 0x0D, 0xFE, + 0x9F, 0xB6, 0xEA, 0x63, 0x3B, 0x85, 0x45, 0x11, + 0x1D, 0x08, 0xB3, 0x4E, 0xF4, 0x3F, 0xFF, 0x17, + 0x02, 0x6C, 0x79, 0x64, 0xF5, 0xDE, 0xAC, 0x6D, + 0x2B, 0x3C, 0x29, 0xDA, 0xCF, 0x27, 0x47, 0xF0, + 0x22, 0xDF, 0x59, 0x67, 0xDF, 0xDC, 0x1A, 0x0A + }, + { + 0xCD, 0x36, 0xDD, 0x0B, 0x24, 0x06, 0x14, 0xCF, + 0x2F, 0xA2, 0xB9, 0xE9, 0x59, 0x67, 0x9D, 0xCD, + 0xD7, 0x2E, 0xC0, 0xCD, 0x58, 0xA4, 0x3D, 0xA3, + 0x79, 0x0A, 0x92, 0xF6, 0xCD, 0xEB, 0x9E, 0x1E, + 0x79, 0x5E, 0x47, 0x8A, 0x0A, 0x47, 0xD3, 0x71, + 0x10, 0x0D, 0x34, 0x0C, 0x5C, 0xED, 0xCD, 0xBB, + 0xC9, 0xE6, 0x8B, 0x3F, 0x46, 0x08, 0x18, 0xE5, + 0xBD, 0xFF, 0x7B, 0x4C, 0xDA, 0x4C, 0x27, 0x44 + }, + { + 0x00, 0xDF, 0x4E, 0x09, 0x9B, 0x80, 0x71, 0x37, + 0xA8, 0x59, 0x90, 0xF4, 0x9D, 0x3A, 0x94, 0x31, + 0x5E, 0x5A, 0x5F, 0x7F, 0x7A, 0x60, 0x76, 0xB3, + 0x03, 0xE9, 0x6B, 0x05, 0x6F, 0xB9, 0x38, 0x00, + 0x11, 0x1F, 0x47, 0x96, 0x28, 0xE2, 0xF8, 0xDB, + 0x59, 0xAE, 0xB6, 0xAC, 0x70, 0xC3, 0xB6, 0x1F, + 0x51, 0xF9, 0xB4, 0x6E, 0x80, 0xFF, 0xDE, 0xAE, + 0x25, 0xEB, 0xDD, 0xB4, 0xAF, 0x6C, 0xB4, 0xEE + }, + { + 0x2B, 0x9C, 0x95, 0x5E, 0x6C, 0xAE, 0xD4, 0xB7, + 0xC9, 0xE2, 0x46, 0xB8, 0x6F, 0x9A, 0x17, 0x26, + 0xE8, 0x10, 0xC5, 0x9D, 0x12, 0x6C, 0xEE, 0x66, + 0xED, 0x71, 0xBF, 0x01, 0x5B, 0x83, 0x55, 0x8A, + 0x4B, 0x6D, 0x84, 0xD1, 0x8D, 0xC3, 0xFF, 0x46, + 0x20, 0xC2, 0xFF, 0xB7, 0x22, 0x35, 0x9F, 0xDE, + 0xF8, 0x5B, 0xA0, 0xD4, 0xE2, 0xD2, 0x2E, 0xCB, + 0xE0, 0xED, 0x78, 0x4F, 0x99, 0xAF, 0xE5, 0x87 + }, + { + 0x18, 0x1D, 0xF0, 0xA2, 0x61, 0xA2, 0xF7, 0xD2, + 0x9E, 0xA5, 0xA1, 0x57, 0x72, 0x71, 0x51, 0x05, + 0xD4, 0x50, 0xA4, 0xB6, 0xC2, 0x36, 0xF6, 0x99, + 0xF4, 0x62, 0xD6, 0x0C, 0xA7, 0x64, 0x87, 0xFE, + 0xED, 0xFC, 0x9F, 0x5E, 0xB9, 0x2D, 0xF8, 0x38, + 0xE8, 0xFB, 0x5D, 0xC3, 0x69, 0x4E, 0x84, 0xC5, + 0xE0, 0xF4, 0xA1, 0x0B, 0x76, 0x1F, 0x50, 0x67, + 0x62, 0xBE, 0x05, 0x2C, 0x74, 0x5A, 0x6E, 0xE8 + }, + { + 0x21, 0xFB, 0x20, 0x34, 0x58, 0xBF, 0x3A, 0x7E, + 0x9A, 0x80, 0x43, 0x9F, 0x9A, 0x90, 0x28, 0x99, + 0xCD, 0x5D, 0xE0, 0x13, 0x9D, 0xFD, 0x56, 0xF7, + 0x11, 0x0C, 0x9D, 0xEC, 0x84, 0x37, 0xB2, 0x6B, + 0xDA, 0x63, 0xDE, 0x2F, 0x56, 0x59, 0x26, 0xD8, + 0x5E, 0xDB, 0x1D, 0x6C, 0x68, 0x25, 0x66, 0x97, + 0x43, 0xDD, 0x99, 0x92, 0x65, 0x3D, 0x13, 0x97, + 0x95, 0x44, 0xD5, 0xDC, 0x82, 0x28, 0xBF, 0xAA + }, + { + 0xEF, 0x02, 0x1F, 0x29, 0xC5, 0xFF, 0xB8, 0x30, + 0xE6, 0x4B, 0x9A, 0xA9, 0x05, 0x8D, 0xD6, 0x60, + 0xFD, 0x2F, 0xCB, 0x81, 0xC4, 0x97, 0xA7, 0xE6, + 0x98, 0xBC, 0xFB, 0xF5, 0x9D, 0xE5, 0xAD, 0x4A, + 0x86, 0xFF, 0x93, 0xC1, 0x0A, 0x4B, 0x9D, 0x1A, + 0xE5, 0x77, 0x47, 0x25, 0xF9, 0x07, 0x2D, 0xCD, + 0xE9, 0xE1, 0xF1, 0x99, 0xBA, 0xB9, 0x1F, 0x8B, + 0xFF, 0x92, 0x18, 0x64, 0xAA, 0x50, 0x2E, 0xEE + }, + { + 0xB3, 0xCF, 0xDA, 0x40, 0x52, 0x6B, 0x7F, 0x1D, + 0x37, 0x56, 0x9B, 0xDF, 0xCD, 0xF9, 0x11, 0xE5, + 0xA6, 0xEF, 0xE6, 0xB2, 0xEC, 0x90, 0xA0, 0x45, + 0x4C, 0x47, 0xB2, 0xC0, 0x46, 0xBF, 0x13, 0x0F, + 0xC3, 0xB3, 0x52, 0xB3, 0x4D, 0xF4, 0x81, 0x3D, + 0x48, 0xD3, 0x3A, 0xB8, 0xE2, 0x69, 0xB6, 0x9B, + 0x07, 0x56, 0x76, 0xCB, 0x6D, 0x00, 0xA8, 0xDC, + 0xF9, 0xE1, 0xF9, 0x67, 0xEC, 0x19, 0x1B, 0x2C + }, + { + 0xB4, 0xC6, 0xC3, 0xB2, 0x67, 0x07, 0x1E, 0xEF, + 0xB9, 0xC8, 0xC7, 0x2E, 0x0E, 0x2B, 0x94, 0x12, + 0x93, 0x64, 0x1F, 0x86, 0x73, 0xCB, 0x70, 0xC1, + 0xCC, 0x26, 0xAD, 0x1E, 0x73, 0xCF, 0x14, 0x17, + 0x55, 0x86, 0x0A, 0xD1, 0x9B, 0x34, 0xC2, 0xF3, + 0x4E, 0xD3, 0x5B, 0xB5, 0x2E, 0xC4, 0x50, 0x7C, + 0xC1, 0xFE, 0x59, 0x04, 0x77, 0x43, 0xA5, 0xF0, + 0xC6, 0xFE, 0xBD, 0xE6, 0x25, 0xE2, 0x60, 0x91 + }, + { + 0x57, 0xA3, 0x4F, 0x2B, 0xCC, 0xA6, 0x0D, 0x4B, + 0x85, 0x10, 0x3B, 0x83, 0x0C, 0x9D, 0x79, 0x52, + 0xA4, 0x16, 0xBE, 0x52, 0x63, 0xAE, 0x42, 0x9C, + 0x9E, 0x5E, 0x53, 0xFE, 0x85, 0x90, 0xA8, 0xF7, + 0x8E, 0xC6, 0x5A, 0x51, 0x10, 0x9E, 0xA8, 0x5D, + 0xCD, 0xF7, 0xB6, 0x22, 0x3F, 0x9F, 0x2B, 0x34, + 0x05, 0x39, 0xFA, 0xD8, 0x19, 0x23, 0xDB, 0xF8, + 0xED, 0xAB, 0xF9, 0x51, 0x29, 0xE4, 0xDF, 0xF6 + }, + { + 0x9C, 0xF4, 0x66, 0x62, 0xFC, 0xD6, 0x1A, 0x23, + 0x22, 0x77, 0xB6, 0x85, 0x66, 0x3B, 0x8B, 0x5D, + 0xA8, 0x32, 0xDF, 0xD9, 0xA3, 0xB8, 0xCC, 0xFE, + 0xEC, 0x99, 0x3E, 0xC6, 0xAC, 0x41, 0x5A, 0xD0, + 0x7E, 0x04, 0x8A, 0xDF, 0xE4, 0x14, 0xDF, 0x27, + 0x27, 0x70, 0xDB, 0xA8, 0x67, 0xDA, 0x5C, 0x12, + 0x24, 0xC6, 0xFD, 0x0A, 0xA0, 0xC2, 0x18, 0x7D, + 0x42, 0x6A, 0xC6, 0x47, 0xE9, 0x88, 0x73, 0x61 + }, + { + 0x5C, 0xE1, 0x04, 0x2A, 0xB4, 0xD5, 0x42, 0xC2, + 0xF9, 0xEE, 0x9D, 0x17, 0x26, 0x2A, 0xF8, 0x16, + 0x40, 0x98, 0x93, 0x5B, 0xEF, 0x17, 0x3D, 0x0E, + 0x18, 0x48, 0x9B, 0x04, 0x84, 0x17, 0x46, 0xCD, + 0x2F, 0x2D, 0xF8, 0x66, 0xBD, 0x7D, 0xA6, 0xE5, + 0xEF, 0x90, 0x24, 0xC6, 0x48, 0x02, 0x3E, 0xC7, + 0x23, 0xAB, 0x9C, 0x62, 0xFD, 0x80, 0x28, 0x57, + 0x39, 0xD8, 0x4F, 0x15, 0xD2, 0xAB, 0x51, 0x5A + }, + { + 0x84, 0x88, 0x39, 0x6B, 0xD4, 0xA8, 0x72, 0x9B, + 0x7A, 0x47, 0x31, 0x78, 0xF2, 0x32, 0xDA, 0xDF, + 0x3F, 0x0F, 0x8E, 0x22, 0x67, 0x8B, 0xA5, 0xA4, + 0x3E, 0x04, 0x1E, 0x72, 0xDA, 0x1E, 0x2C, 0xF8, + 0x21, 0x94, 0xC3, 0x07, 0x20, 0x7A, 0x54, 0xCB, + 0x81, 0x56, 0x29, 0x33, 0x39, 0xEA, 0xEC, 0x69, + 0x3F, 0xF6, 0x6B, 0xFC, 0xD5, 0xEF, 0xC6, 0x5E, + 0x95, 0xE4, 0xEC, 0xAF, 0x54, 0x53, 0x0A, 0xBD + }, + { + 0xF5, 0x98, 0xDA, 0x90, 0x1C, 0x38, 0x35, 0xBC, + 0xA5, 0x60, 0x77, 0x90, 0x37, 0xDF, 0xDE, 0x9F, + 0x0C, 0x51, 0xDC, 0x61, 0xC0, 0xB7, 0x60, 0xFC, + 0x15, 0x22, 0xD7, 0xB4, 0x70, 0xEE, 0x63, 0xF5, + 0xBD, 0xC6, 0x49, 0x84, 0x76, 0xE8, 0x60, 0x49, + 0xAD, 0x86, 0xE4, 0xE2, 0x1A, 0xF2, 0x85, 0x4A, + 0x98, 0x4C, 0xC9, 0x05, 0x42, 0x7D, 0x2F, 0x17, + 0xF6, 0x6B, 0x1F, 0x41, 0xC3, 0xDA, 0x6F, 0x61 + }, + { + 0x5F, 0x93, 0x26, 0x97, 0x98, 0xCF, 0x02, 0x13, + 0x21, 0x07, 0x33, 0x76, 0x60, 0xA8, 0xD7, 0xA1, + 0x77, 0x35, 0x4C, 0x02, 0x12, 0xEB, 0x93, 0xE5, + 0x55, 0xE7, 0xC3, 0x7A, 0x08, 0xAE, 0xF3, 0xD8, + 0xDC, 0xE0, 0x12, 0x17, 0x01, 0x1C, 0xD9, 0x65, + 0xC0, 0x4D, 0xD2, 0xC1, 0x05, 0xF2, 0xE2, 0xB6, + 0xCA, 0xE5, 0xE4, 0xE6, 0xBC, 0xAF, 0x09, 0xDF, + 0xBE, 0xE3, 0xE0, 0xA6, 0xA6, 0x35, 0x7C, 0x37 + }, + { + 0x0E, 0xCF, 0x58, 0x1D, 0x47, 0xBA, 0xC9, 0x23, + 0x09, 0x86, 0xFA, 0xAB, 0xD7, 0x0C, 0x2F, 0x5B, + 0x80, 0xE9, 0x10, 0x66, 0xF0, 0xEC, 0x55, 0xA8, + 0x42, 0x93, 0x78, 0x82, 0x28, 0x6D, 0x2C, 0xA0, + 0x07, 0xBB, 0x4E, 0x97, 0x3B, 0x0B, 0x09, 0x1D, + 0x52, 0x16, 0x7F, 0xF7, 0xC4, 0x00, 0x9C, 0x7A, + 0xB4, 0xAD, 0x38, 0xFF, 0xF1, 0xDC, 0xEA, 0xCD, + 0xB7, 0xBE, 0x81, 0xEF, 0x4A, 0x45, 0x29, 0x52 + }, + { + 0x5A, 0xEC, 0xA8, 0xAB, 0xE1, 0x52, 0x85, 0x82, + 0xB2, 0xA3, 0x07, 0xB4, 0x00, 0x95, 0x85, 0x49, + 0x8A, 0x3D, 0x46, 0x7C, 0xA6, 0x10, 0x1C, 0xB0, + 0xC5, 0x12, 0x6F, 0x99, 0x76, 0x05, 0x6E, 0x9F, + 0xFC, 0x12, 0x3C, 0xC2, 0x0C, 0x30, 0x2B, 0x2A, + 0x73, 0x7F, 0x49, 0x2C, 0x75, 0xD2, 0x1F, 0x01, + 0x51, 0x2C, 0x90, 0xCA, 0x05, 0x41, 0xDF, 0xA5, + 0x6E, 0x95, 0x0A, 0x32, 0x1D, 0xCB, 0x28, 0xD8 + }, + { + 0x73, 0x2F, 0xBF, 0x8F, 0x1C, 0xB2, 0xB8, 0x32, + 0x92, 0x63, 0xED, 0xE2, 0x78, 0x58, 0xFE, 0x46, + 0xF8, 0xD3, 0x35, 0x4D, 0x37, 0x6B, 0xCD, 0xA0, + 0x54, 0x8E, 0x7C, 0xE1, 0xFA, 0x9D, 0xD1, 0x1F, + 0x85, 0xEB, 0x66, 0x1F, 0xE9, 0x50, 0xB5, 0x43, + 0xAA, 0x63, 0x5C, 0xA4, 0xD3, 0xF0, 0x4E, 0xDE, + 0x5B, 0x32, 0xD6, 0xB6, 0x56, 0xE5, 0xCE, 0x1C, + 0x44, 0xD3, 0x5C, 0x4A, 0x6C, 0x56, 0xCF, 0xF8 + }, + { + 0xD5, 0xE9, 0x38, 0x73, 0x5D, 0x63, 0x78, 0x8C, + 0x80, 0x10, 0x0A, 0xEF, 0xD1, 0x86, 0x48, 0xD1, + 0x8C, 0xF2, 0x72, 0xF6, 0x9F, 0x20, 0xFF, 0x24, + 0xCF, 0xE2, 0x89, 0x5C, 0x08, 0x8A, 0xD0, 0x8B, + 0x01, 0x04, 0xDA, 0x16, 0x72, 0xA4, 0xEB, 0x26, + 0xFC, 0x52, 0x54, 0x5C, 0xC7, 0xD7, 0xA0, 0x1B, + 0x26, 0x6C, 0xF5, 0x46, 0xC4, 0x03, 0xC4, 0x5B, + 0xD1, 0x29, 0xEB, 0x41, 0xBD, 0xD9, 0x20, 0x0B + }, + { + 0x65, 0xA2, 0x45, 0xB4, 0x93, 0x52, 0xEE, 0x29, + 0x7D, 0x91, 0xAF, 0x8C, 0x8B, 0xE0, 0x05, 0x28, + 0xAC, 0x6E, 0x04, 0x6D, 0xD8, 0x3A, 0xC7, 0xBD, + 0x46, 0x5A, 0x98, 0x81, 0x6D, 0xD6, 0x8F, 0x3E, + 0x00, 0xE1, 0xAE, 0x8F, 0x89, 0x53, 0x27, 0xA7, + 0xE9, 0xA8, 0xC9, 0x32, 0x65, 0x98, 0x37, 0x9A, + 0x29, 0xC9, 0xFC, 0x91, 0xEC, 0x0C, 0x6E, 0xEF, + 0x08, 0xF3, 0xE2, 0xB2, 0x16, 0xC1, 0x10, 0x08 + }, + { + 0xC9, 0x56, 0x54, 0xB6, 0x30, 0x19, 0x13, 0x0A, + 0xB4, 0x5D, 0xD0, 0xFB, 0x49, 0x41, 0xB9, 0x8A, + 0xEB, 0x3A, 0xF2, 0xA1, 0x23, 0x91, 0x3E, 0xCA, + 0x2C, 0xE9, 0x9B, 0x3E, 0x97, 0x41, 0x0A, 0x7B, + 0xF8, 0x66, 0x1C, 0xC7, 0xFB, 0xAA, 0x2B, 0xC1, + 0xCF, 0x2B, 0x13, 0x11, 0x3B, 0x1E, 0xD4, 0x0A, + 0x01, 0x18, 0xB8, 0x8E, 0x5F, 0xFF, 0xC3, 0x54, + 0x27, 0x59, 0xEA, 0x00, 0x7E, 0xD4, 0xC5, 0x8D + }, + { + 0x1E, 0xB2, 0x62, 0xF3, 0x8F, 0xA4, 0x94, 0x43, + 0x1F, 0x01, 0x7D, 0xAD, 0x44, 0xC0, 0xDF, 0xB6, + 0x93, 0x24, 0xAC, 0x03, 0x2F, 0x04, 0xB6, 0x57, + 0xFC, 0x91, 0xA8, 0x86, 0x47, 0xBB, 0x74, 0x76, + 0x0F, 0x24, 0xE7, 0xC9, 0x56, 0x51, 0x4F, 0x0C, + 0xF0, 0x02, 0x99, 0x0B, 0x18, 0x2C, 0x16, 0x42, + 0xB9, 0xB2, 0x42, 0x6E, 0x96, 0xA6, 0x11, 0x87, + 0xE4, 0xE0, 0x12, 0xF0, 0x0E, 0x21, 0x7D, 0x84 + }, + { + 0x3B, 0x95, 0x5A, 0xEE, 0xBF, 0xA5, 0x15, 0x1A, + 0xC1, 0xAB, 0x8E, 0x3F, 0x5C, 0xC1, 0xE3, 0x76, + 0x70, 0x84, 0xC8, 0x42, 0xA5, 0x75, 0xD3, 0x62, + 0x69, 0x83, 0x6E, 0x97, 0x35, 0x3D, 0x41, 0x62, + 0x2B, 0x73, 0x1D, 0xDD, 0xCD, 0x5F, 0x26, 0x95, + 0x50, 0xA3, 0xA5, 0xB8, 0x7B, 0xE1, 0xE9, 0x03, + 0x26, 0x34, 0x0B, 0x6E, 0x0E, 0x62, 0x55, 0x58, + 0x15, 0xD9, 0x60, 0x05, 0x97, 0xAC, 0x6E, 0xF9 + }, + { + 0x68, 0x28, 0x9F, 0x66, 0x05, 0x47, 0x3B, 0xA0, + 0xE4, 0xF2, 0x41, 0xBA, 0xF7, 0x47, 0x7A, 0x98, + 0x85, 0x42, 0x6A, 0x85, 0x8F, 0x19, 0xEF, 0x2A, + 0x18, 0xB0, 0xD4, 0x0E, 0xF8, 0xE4, 0x12, 0x82, + 0xED, 0x55, 0x26, 0xB5, 0x19, 0x79, 0x9E, 0x27, + 0x0F, 0x13, 0x88, 0x13, 0x27, 0x91, 0x82, 0x78, + 0x75, 0x57, 0x11, 0x07, 0x1D, 0x85, 0x11, 0xFE, + 0x96, 0x3E, 0x3B, 0x56, 0x06, 0xAA, 0x37, 0x16 + }, + { + 0x80, 0xA3, 0x37, 0x87, 0x54, 0x26, 0x12, 0xC3, + 0x8F, 0x6B, 0xCD, 0x7C, 0xD8, 0x6C, 0xAB, 0x46, + 0x02, 0x27, 0x50, 0x9B, 0x1C, 0xBA, 0xD5, 0xEC, + 0x40, 0x8A, 0x91, 0x41, 0x3D, 0x51, 0x15, 0x5A, + 0x04, 0x76, 0xDA, 0xDB, 0xF3, 0xA2, 0x51, 0x8E, + 0x4A, 0x6E, 0x77, 0xCC, 0x34, 0x66, 0x22, 0xE3, + 0x47, 0xA4, 0x69, 0xBF, 0x8B, 0xAA, 0x5F, 0x04, + 0xEB, 0x2D, 0x98, 0x70, 0x53, 0x55, 0xD0, 0x63 + }, + { + 0x34, 0x62, 0x9B, 0xC6, 0xD8, 0x31, 0x39, 0x1C, + 0x4C, 0xDF, 0x8A, 0xF1, 0xB4, 0xB7, 0xB6, 0xB8, + 0xE8, 0xEE, 0x17, 0xCF, 0x98, 0xC7, 0x0E, 0x5D, + 0xD5, 0x86, 0xCD, 0x99, 0xF1, 0x4B, 0x11, 0xDF, + 0x94, 0x51, 0x66, 0x23, 0x6A, 0x95, 0x71, 0xE6, + 0xD5, 0x91, 0xBB, 0x83, 0xEE, 0x4D, 0x16, 0x4D, + 0x46, 0xF6, 0xB9, 0xD8, 0xEF, 0x86, 0xFF, 0x86, + 0x5A, 0x81, 0xBF, 0xB9, 0x1B, 0x00, 0x42, 0x4B + }, + { + 0x8B, 0x7C, 0xC3, 0x39, 0x16, 0x38, 0x63, 0xBB, + 0x43, 0x83, 0xE5, 0x42, 0xB0, 0xEF, 0x0E, 0x7C, + 0xF3, 0x6B, 0x84, 0xAD, 0x93, 0x2C, 0xDF, 0x5A, + 0x80, 0x41, 0x9E, 0xC9, 0xAD, 0x69, 0x2E, 0x7A, + 0x7E, 0x78, 0x4D, 0x2C, 0x7C, 0xB3, 0x79, 0x6A, + 0x18, 0xB8, 0xF8, 0x00, 0x03, 0x5F, 0x3A, 0xA0, + 0x6C, 0x82, 0x41, 0x00, 0x61, 0x11, 0x20, 0xA7, + 0xBD, 0xEB, 0x35, 0x61, 0x8C, 0xCB, 0x81, 0xB7 + }, + { + 0x4F, 0x08, 0x4E, 0x49, 0x39, 0xDD, 0x5A, 0x7F, + 0x5A, 0x65, 0x8F, 0xAD, 0x58, 0xA1, 0x8A, 0x15, + 0xC2, 0x5C, 0x32, 0xEC, 0x1C, 0x7F, 0xD5, 0xC5, + 0xC6, 0xC3, 0xE8, 0x92, 0xB3, 0x97, 0x1A, 0xEA, + 0xAC, 0x30, 0x83, 0x04, 0xEF, 0x17, 0xB1, 0xC4, + 0x72, 0x39, 0xEA, 0x4B, 0xB3, 0x98, 0xB3, 0xFD, + 0x6D, 0x45, 0x28, 0xD8, 0xDE, 0x8E, 0x76, 0x8A, + 0xE0, 0xF1, 0xA5, 0xA5, 0xC6, 0xB5, 0xC2, 0x97 + }, + { + 0x48, 0xF4, 0x07, 0xA1, 0xAF, 0x5B, 0x80, 0x09, + 0xB2, 0x05, 0x17, 0x42, 0xE8, 0xCF, 0x5C, 0xD5, + 0x65, 0x66, 0x69, 0xE7, 0xD7, 0x22, 0xEE, 0x8E, + 0x7B, 0xD2, 0x02, 0x06, 0x08, 0x49, 0x44, 0x21, + 0x68, 0xD8, 0xFA, 0xCC, 0x11, 0x7C, 0x01, 0x2B, + 0xFB, 0x7B, 0xF4, 0x49, 0xD9, 0x9B, 0xEF, 0xFF, + 0x6A, 0x34, 0xAE, 0xA2, 0x03, 0xF1, 0xD8, 0xD3, + 0x52, 0x72, 0x2B, 0xE5, 0x01, 0x4E, 0xC8, 0x18 + }, + { + 0xA6, 0xAA, 0x82, 0xCD, 0x1E, 0x42, 0x6F, 0x9A, + 0x73, 0xBF, 0xA3, 0x9A, 0x29, 0x03, 0x78, 0x76, + 0x11, 0x46, 0x55, 0xB8, 0xC2, 0x2D, 0x6D, 0x3F, + 0xF8, 0xB6, 0x38, 0xAE, 0x7D, 0xEA, 0x6B, 0x17, + 0x84, 0x3E, 0x09, 0xE5, 0x2E, 0xB6, 0x6F, 0xA1, + 0xE4, 0x75, 0xE4, 0xA8, 0xA3, 0xDE, 0x42, 0x9B, + 0x7D, 0x0F, 0x4A, 0x77, 0x6F, 0xCB, 0x8B, 0xDC, + 0x9B, 0x9F, 0xED, 0xE7, 0xD5, 0x2E, 0x81, 0x5F + }, + { + 0x58, 0x17, 0x02, 0x7D, 0x6B, 0xDD, 0x00, 0xC5, + 0xDD, 0x10, 0xAC, 0x59, 0x3C, 0xD5, 0x60, 0x37, + 0x22, 0x70, 0x77, 0x5A, 0x18, 0x52, 0x6D, 0x7E, + 0x6F, 0x13, 0x87, 0x2A, 0x2E, 0x20, 0xEA, 0xB6, + 0x64, 0x62, 0x5B, 0xE7, 0x16, 0x8A, 0xC4, 0xBD, + 0x7C, 0x9E, 0x0C, 0xE7, 0xFC, 0x40, 0x99, 0xE0, + 0xF4, 0x84, 0x42, 0xE2, 0xC7, 0x67, 0x19, 0x1C, + 0x6E, 0x12, 0x84, 0xE9, 0xB2, 0xCC, 0xEA, 0x8C + }, + { + 0x08, 0xE4, 0x10, 0x28, 0x34, 0x0A, 0x45, 0xC7, + 0x4E, 0x40, 0x52, 0xB3, 0xA8, 0xD6, 0x38, 0x9E, + 0x22, 0xE0, 0x43, 0xA1, 0xAD, 0xAB, 0x5E, 0x28, + 0xD9, 0x76, 0x19, 0x45, 0x0D, 0x72, 0x34, 0x69, + 0xB6, 0x20, 0xCA, 0xA5, 0x19, 0xB8, 0x1C, 0x14, + 0x52, 0x38, 0x54, 0xF6, 0x19, 0xFD, 0x30, 0x27, + 0xE3, 0x84, 0x7B, 0xD0, 0x32, 0x76, 0xE6, 0x06, + 0x04, 0xA8, 0x0D, 0xDB, 0x4D, 0xE8, 0x76, 0xD6 + }, + { + 0x13, 0x0B, 0x84, 0x20, 0x53, 0x7E, 0xB0, 0x7D, + 0x72, 0xAB, 0xDA, 0x07, 0xC8, 0x5A, 0xCB, 0xD8, + 0xB9, 0xA4, 0x4F, 0x16, 0x32, 0x1D, 0xD0, 0x42, + 0x21, 0x45, 0xF8, 0x09, 0x67, 0x3D, 0x30, 0xF2, + 0xB5, 0x32, 0x13, 0x26, 0xE2, 0xBF, 0xF3, 0x17, + 0xEF, 0x3F, 0xEF, 0x98, 0x3C, 0x51, 0xC4, 0xF8, + 0xAB, 0x24, 0xA3, 0x25, 0xD2, 0x98, 0xE3, 0x4A, + 0xFC, 0xE5, 0x69, 0xA8, 0x25, 0x55, 0x77, 0x4C + }, + { + 0xAC, 0x49, 0xB8, 0x44, 0xAF, 0xAA, 0x01, 0x2E, + 0x31, 0xC4, 0x74, 0xCA, 0x26, 0x36, 0x48, 0x84, + 0x4F, 0xD2, 0xF6, 0x30, 0x79, 0x92, 0xC2, 0xF7, + 0x52, 0xAC, 0xA0, 0x2C, 0x38, 0x28, 0x96, 0x51, + 0x75, 0x79, 0x4D, 0xEE, 0xE2, 0xD2, 0xEE, 0x95, + 0xC6, 0x1C, 0xD2, 0x84, 0xF6, 0xB5, 0xA2, 0xD7, + 0x5E, 0x2E, 0xF2, 0xB2, 0x9E, 0xE8, 0x14, 0x9E, + 0x77, 0xFB, 0x81, 0x44, 0x7B, 0x2F, 0xD0, 0x4B + }, + { + 0xB9, 0xD7, 0xCA, 0x81, 0xCC, 0x60, 0xBB, 0x95, + 0x78, 0xE4, 0x40, 0x24, 0xE5, 0xA0, 0xA0, 0xBE, + 0x80, 0xF2, 0x73, 0x36, 0xA6, 0xA9, 0xF4, 0xE5, + 0x3D, 0xF3, 0x99, 0x9C, 0xB1, 0x91, 0x28, 0x0B, + 0x09, 0x0E, 0x2A, 0xC2, 0xD2, 0x9C, 0x5B, 0xAA, + 0xD9, 0xD7, 0x14, 0x15, 0xBD, 0xC1, 0x29, 0xE6, + 0x9A, 0xA2, 0x66, 0x7A, 0xF6, 0xA7, 0xFD, 0x5E, + 0x18, 0x9F, 0xCC, 0xDC, 0xEE, 0x81, 0x73, 0x40 + }, + { + 0xA7, 0x55, 0xE1, 0x13, 0x38, 0x65, 0x72, 0xC7, + 0x5C, 0xED, 0x61, 0xD7, 0x19, 0x70, 0x60, 0x70, + 0xB9, 0x14, 0x60, 0x48, 0xE4, 0x2A, 0x9F, 0x8C, + 0xD3, 0x56, 0x67, 0xA0, 0x88, 0xB4, 0x2F, 0x08, + 0x80, 0x8A, 0xBD, 0xF7, 0x7E, 0x61, 0x8A, 0xBD, + 0x95, 0x9A, 0xFC, 0x75, 0x73, 0x79, 0xCA, 0x2C, + 0x00, 0xBC, 0xC1, 0xA4, 0x83, 0x90, 0xFA, 0x2B, + 0xFF, 0x61, 0x8B, 0x1E, 0x00, 0x78, 0xA6, 0x13 + }, + { + 0xA7, 0x3C, 0x7D, 0xEB, 0xED, 0x32, 0x6F, 0x1C, + 0x0D, 0xB0, 0x79, 0x5E, 0xE7, 0xD6, 0xE3, 0x94, + 0x68, 0x94, 0xB8, 0x26, 0xB1, 0xF8, 0x10, 0x1C, + 0x56, 0xC8, 0x23, 0xBA, 0x17, 0x16, 0x83, 0x12, + 0xE7, 0xF5, 0x3F, 0xC7, 0xDB, 0xE5, 0x2C, 0x3E, + 0x11, 0xE6, 0x98, 0x52, 0xC4, 0x04, 0x85, 0xE2, + 0xEF, 0x18, 0x24, 0x77, 0x86, 0x2E, 0xA6, 0xA3, + 0x4E, 0xC1, 0x36, 0xE2, 0xDF, 0xEE, 0xA6, 0xF4 + }, + { + 0x6C, 0xB8, 0xF9, 0xD5, 0x2C, 0x56, 0xD8, 0x2C, + 0xAC, 0x28, 0xF3, 0x9E, 0xA1, 0x59, 0x3E, 0x8B, + 0xB2, 0x50, 0x62, 0x93, 0xAC, 0x0D, 0x68, 0x37, + 0x6A, 0x17, 0x09, 0xB6, 0x2A, 0x46, 0xDF, 0x14, + 0xA4, 0xAE, 0x64, 0xB2, 0xD8, 0xFA, 0xB7, 0x67, + 0x33, 0xA1, 0xCE, 0xD2, 0xD5, 0x48, 0xE3, 0xF3, + 0xC6, 0xFC, 0xB4, 0x9D, 0x40, 0xC3, 0xD5, 0x80, + 0x8E, 0x44, 0x9C, 0xD8, 0x3D, 0x1C, 0x2A, 0xA2 + }, + { + 0x68, 0x3F, 0xA2, 0xB2, 0x36, 0x9A, 0x10, 0x16, + 0x2C, 0x1C, 0x1C, 0x7B, 0x24, 0xBC, 0x97, 0x0E, + 0xE6, 0x7D, 0xA2, 0x20, 0x56, 0x4F, 0x32, 0x20, + 0x3F, 0x62, 0x56, 0x96, 0xC0, 0x35, 0x2A, 0x0B, + 0x9A, 0xD9, 0x66, 0x24, 0x36, 0x2D, 0x95, 0x2D, + 0x84, 0x46, 0x3C, 0x11, 0x06, 0xA2, 0xDB, 0xA7, + 0xA0, 0x92, 0x59, 0x98, 0x84, 0xB3, 0x5A, 0x0B, + 0x89, 0xC8, 0xF1, 0xB6, 0xA9, 0xB5, 0xA6, 0x1E + }, + { + 0xAA, 0xD9, 0xAD, 0x44, 0x61, 0x01, 0x18, 0xB7, + 0x7D, 0x50, 0x8A, 0xEB, 0x1B, 0xBC, 0xD1, 0xC1, + 0xB7, 0xD0, 0x17, 0x13, 0x97, 0xFB, 0x51, 0x0A, + 0x40, 0x1B, 0xBC, 0x0E, 0xC3, 0x46, 0x23, 0x67, + 0x0D, 0x86, 0xA2, 0xDC, 0x3C, 0x8F, 0x3A, 0xB5, + 0xA2, 0x04, 0x4D, 0xF7, 0x30, 0x25, 0x67, 0x27, + 0x54, 0x5F, 0x08, 0x60, 0xCE, 0x21, 0xA1, 0xEA, + 0xC7, 0x17, 0xDF, 0xC4, 0x8F, 0x5D, 0x22, 0x8E + }, + { + 0xC4, 0x25, 0x78, 0xDE, 0x23, 0xB4, 0xC9, 0x87, + 0xD5, 0xE1, 0xAC, 0x4D, 0x68, 0x9E, 0xD5, 0xDE, + 0x4B, 0x04, 0x17, 0xF9, 0x70, 0x4B, 0xC6, 0xBC, + 0xE9, 0x69, 0xFA, 0x13, 0x47, 0x15, 0x85, 0xD6, + 0x2C, 0x2C, 0xB1, 0x21, 0x2A, 0x94, 0x4F, 0x39, + 0x7F, 0xC9, 0xCA, 0x2C, 0x37, 0x47, 0xC3, 0xBE, + 0xB6, 0x94, 0xEC, 0x4C, 0x5B, 0xE6, 0x88, 0x28, + 0xDD, 0xA5, 0x3E, 0xF4, 0x3F, 0xAE, 0xC6, 0xC0 + }, + { + 0x47, 0x0F, 0x00, 0x84, 0x1E, 0xE8, 0x24, 0x4E, + 0x63, 0xED, 0x2C, 0x7E, 0xA3, 0x0E, 0x2E, 0x41, + 0x98, 0x97, 0xC1, 0x97, 0x46, 0x2E, 0xCC, 0xCE, + 0xCF, 0x71, 0x3B, 0x42, 0xA5, 0x06, 0x5F, 0xFF, + 0x59, 0x14, 0xBC, 0x9B, 0x79, 0xAF, 0xFE, 0x8F, + 0x6B, 0x65, 0x78, 0x75, 0xE7, 0x89, 0xAE, 0x21, + 0x3B, 0xD9, 0x14, 0xCD, 0x35, 0xBD, 0x17, 0x4D, + 0x46, 0xE9, 0xD1, 0x8B, 0xD8, 0x43, 0x77, 0x3D + }, + { + 0x34, 0xFC, 0x42, 0x13, 0x73, 0x0F, 0x47, 0xA5, + 0xE9, 0xA3, 0x58, 0x0F, 0x64, 0x3E, 0x12, 0x94, + 0x5C, 0xFC, 0xB3, 0x1B, 0xF2, 0x06, 0xF6, 0xAD, + 0x45, 0x0C, 0xE5, 0x28, 0xDA, 0x3F, 0xA4, 0x32, + 0xE0, 0x05, 0xD6, 0xB0, 0xEC, 0xCE, 0x10, 0xDC, + 0xA7, 0xC5, 0x99, 0x5F, 0x6A, 0xAC, 0xC5, 0x15, + 0x0E, 0x1B, 0x00, 0x9E, 0x19, 0x75, 0x1E, 0x83, + 0x09, 0xF8, 0x85, 0x95, 0x31, 0x84, 0x43, 0x74 + }, + { + 0xFB, 0x3C, 0x1F, 0x0F, 0x56, 0xA5, 0x6F, 0x8E, + 0x31, 0x6F, 0xDF, 0x5D, 0x85, 0x3C, 0x8C, 0x87, + 0x2C, 0x39, 0x63, 0x5D, 0x08, 0x36, 0x34, 0xC3, + 0x90, 0x4F, 0xC3, 0xAC, 0x07, 0xD1, 0xB5, 0x78, + 0xE8, 0x5F, 0xF0, 0xE4, 0x80, 0xE9, 0x2D, 0x44, + 0xAD, 0xE3, 0x3B, 0x62, 0xE8, 0x93, 0xEE, 0x32, + 0x34, 0x3E, 0x79, 0xDD, 0xF6, 0xEF, 0x29, 0x2E, + 0x89, 0xB5, 0x82, 0xD3, 0x12, 0x50, 0x23, 0x14 + }, + { + 0xC7, 0xC9, 0x7F, 0xC6, 0x5D, 0xD2, 0xB9, 0xE3, + 0xD3, 0xD6, 0x07, 0xD3, 0x15, 0x98, 0xD3, 0xF8, + 0x42, 0x61, 0xE9, 0x91, 0x92, 0x51, 0xE9, 0xC8, + 0xE5, 0x7B, 0xB5, 0xF8, 0x29, 0x37, 0x7D, 0x5F, + 0x73, 0xEA, 0xBB, 0xED, 0x55, 0xC6, 0xC3, 0x81, + 0x18, 0x0F, 0x29, 0xAD, 0x02, 0xE5, 0xBE, 0x79, + 0x7F, 0xFE, 0xC7, 0xE5, 0x7B, 0xDE, 0xCB, 0xC5, + 0x0A, 0xD3, 0xD0, 0x62, 0xF0, 0x99, 0x3A, 0xB0 + }, + { + 0xA5, 0x7A, 0x49, 0xCD, 0xBE, 0x67, 0xAE, 0x7D, + 0x9F, 0x79, 0x7B, 0xB5, 0xCC, 0x7E, 0xFC, 0x2D, + 0xF0, 0x7F, 0x4E, 0x1B, 0x15, 0x95, 0x5F, 0x85, + 0xDA, 0xE7, 0x4B, 0x76, 0xE2, 0xEC, 0xB8, 0x5A, + 0xFB, 0x6C, 0xD9, 0xEE, 0xED, 0x88, 0x88, 0xD5, + 0xCA, 0x3E, 0xC5, 0xAB, 0x65, 0xD2, 0x7A, 0x7B, + 0x19, 0xE5, 0x78, 0x47, 0x57, 0x60, 0xA0, 0x45, + 0xAC, 0x3C, 0x92, 0xE1, 0x3A, 0x93, 0x8E, 0x77 + }, + { + 0xC7, 0x14, 0x3F, 0xCE, 0x96, 0x14, 0xA1, 0x7F, + 0xD6, 0x53, 0xAE, 0xB1, 0x40, 0x72, 0x6D, 0xC9, + 0xC3, 0xDB, 0xB1, 0xDE, 0x6C, 0xC5, 0x81, 0xB2, + 0x72, 0x68, 0x97, 0xEC, 0x24, 0xB7, 0xA5, 0x03, + 0x59, 0xAD, 0x49, 0x22, 0x43, 0xBE, 0x66, 0xD9, + 0xED, 0xD8, 0xC9, 0x33, 0xB5, 0xB8, 0x0E, 0x0B, + 0x91, 0xBB, 0x61, 0xEA, 0x98, 0x05, 0x60, 0x06, + 0x51, 0x69, 0x76, 0xFA, 0xE8, 0xD9, 0x9A, 0x35 + }, + { + 0x65, 0xBB, 0x58, 0xD0, 0x7F, 0x93, 0x7E, 0x2D, + 0x3C, 0x7E, 0x65, 0x38, 0x5F, 0x9C, 0x54, 0x73, + 0x0B, 0x70, 0x41, 0x05, 0xCC, 0xDB, 0x69, 0x1F, + 0x6E, 0x14, 0x6D, 0x4E, 0xE8, 0xF6, 0xC0, 0x86, + 0xF4, 0x95, 0x11, 0x03, 0x51, 0x10, 0xA9, 0xAD, + 0x60, 0x31, 0xFD, 0xCE, 0xB9, 0x43, 0xE0, 0xF9, + 0x61, 0x3B, 0xCB, 0x27, 0x6D, 0xD4, 0x0F, 0x06, + 0x24, 0xEF, 0x0F, 0x92, 0x4F, 0x80, 0x97, 0x83 + }, + { + 0xE5, 0x40, 0x27, 0x7F, 0x68, 0x3B, 0x11, 0x86, + 0xDD, 0x3B, 0x5B, 0x3F, 0x61, 0x43, 0x33, 0x96, + 0x58, 0x1A, 0x35, 0xFE, 0xB1, 0x20, 0x02, 0xBE, + 0x8C, 0x6A, 0x62, 0x31, 0xFC, 0x40, 0xFF, 0xA7, + 0x0F, 0x08, 0x08, 0x1B, 0xC5, 0x8B, 0x2D, 0x94, + 0xF7, 0x64, 0x95, 0x43, 0x61, 0x4A, 0x43, 0x5F, + 0xAA, 0x2D, 0x62, 0x11, 0x0E, 0x13, 0xDA, 0xBC, + 0x7B, 0x86, 0x62, 0x9B, 0x63, 0xAF, 0x9C, 0x24 + }, + { + 0x41, 0x85, 0x00, 0x87, 0x8C, 0x5F, 0xBC, 0xB5, + 0x84, 0xC4, 0x32, 0xF4, 0x28, 0x5E, 0x05, 0xE4, + 0x9F, 0x2E, 0x3E, 0x07, 0x53, 0x99, 0xA0, 0xDB, + 0xFC, 0xF8, 0x74, 0xEB, 0xF8, 0xC0, 0x3D, 0x02, + 0xBF, 0x16, 0xBC, 0x69, 0x89, 0xD1, 0x61, 0xC7, + 0x7C, 0xA0, 0x78, 0x6B, 0x05, 0x05, 0x3C, 0x6C, + 0x70, 0x94, 0x33, 0x71, 0x23, 0x19, 0x19, 0x21, + 0x28, 0x83, 0x5C, 0xF0, 0xB6, 0x60, 0x59, 0x5B + }, + { + 0x88, 0x90, 0x90, 0xDB, 0xB1, 0x94, 0x4B, 0xDC, + 0x94, 0x33, 0xEE, 0x5E, 0xF1, 0x01, 0x0C, 0x7A, + 0x4A, 0x24, 0xA8, 0xE7, 0x1E, 0xCE, 0xA8, 0xE1, + 0x2A, 0x31, 0x31, 0x8C, 0xE4, 0x9D, 0xCA, 0xB0, + 0xAC, 0xA5, 0xC3, 0x80, 0x23, 0x34, 0xAA, 0xB2, + 0xCC, 0x84, 0xB1, 0x4C, 0x6B, 0x93, 0x21, 0xFE, + 0x58, 0x6B, 0xF3, 0xF8, 0x76, 0xF1, 0x9C, 0xD4, + 0x06, 0xEB, 0x11, 0x27, 0xFB, 0x94, 0x48, 0x01 + }, + { + 0x53, 0xB6, 0xA2, 0x89, 0x10, 0xAA, 0x92, 0xE2, + 0x7E, 0x53, 0x6F, 0xB5, 0x49, 0xCF, 0x9B, 0x99, + 0x18, 0x79, 0x10, 0x60, 0x89, 0x8E, 0x0B, 0x9F, + 0xE1, 0x83, 0x57, 0x7F, 0xF4, 0x3B, 0x5E, 0x9C, + 0x76, 0x89, 0xC7, 0x45, 0xB3, 0x2E, 0x41, 0x22, + 0x69, 0x83, 0x7C, 0x31, 0xB8, 0x9E, 0x6C, 0xC1, + 0x2B, 0xF7, 0x6E, 0x13, 0xCA, 0xD3, 0x66, 0xB7, + 0x4E, 0xCE, 0x48, 0xBB, 0x85, 0xFD, 0x09, 0xE9 + }, + { + 0x7C, 0x09, 0x20, 0x80, 0xC6, 0xA8, 0x0D, 0x67, + 0x24, 0x09, 0xD0, 0x81, 0xD3, 0xD1, 0x77, 0x10, + 0x6B, 0xCD, 0x63, 0x56, 0x77, 0x85, 0x14, 0x07, + 0x19, 0x49, 0x09, 0x50, 0xAE, 0x07, 0xAE, 0x8F, + 0xCA, 0xAB, 0xBA, 0xAA, 0xB3, 0x30, 0xCF, 0xBC, + 0xF7, 0x37, 0x44, 0x82, 0xC2, 0x20, 0xAF, 0x2E, + 0xAD, 0xEE, 0xB7, 0x3D, 0xCB, 0xB3, 0x5E, 0xD8, + 0x23, 0x34, 0x4E, 0x14, 0x4E, 0x7D, 0x48, 0x99 + }, + { + 0x9C, 0xCD, 0xE5, 0x66, 0xD2, 0x40, 0x05, 0x09, + 0x18, 0x11, 0x11, 0xF3, 0x2D, 0xDE, 0x4C, 0xD6, + 0x32, 0x09, 0xFE, 0x59, 0xA3, 0x0C, 0x11, 0x45, + 0x46, 0xAD, 0x27, 0x76, 0xD8, 0x89, 0xA4, 0x1B, + 0xAD, 0x8F, 0xA1, 0xBB, 0x46, 0x8C, 0xB2, 0xF9, + 0xD4, 0x2C, 0xA9, 0x92, 0x8A, 0x77, 0x70, 0xFE, + 0xF8, 0xE8, 0xBA, 0x4D, 0x0C, 0x81, 0x2D, 0x9A, + 0x1E, 0x75, 0xC3, 0xD8, 0xD2, 0xCC, 0xD7, 0x5A + }, + { + 0x6E, 0x29, 0x3B, 0xF5, 0xD0, 0x3F, 0xE4, 0x39, + 0x77, 0xCF, 0xE3, 0xF5, 0x7C, 0xCD, 0xB3, 0xAE, + 0x28, 0x2A, 0x85, 0x45, 0x5D, 0xCA, 0x33, 0xF3, + 0x7F, 0x4B, 0x74, 0xF8, 0x39, 0x8C, 0xC6, 0x12, + 0x43, 0x3D, 0x75, 0x5C, 0xBE, 0xC4, 0x12, 0xF8, + 0xF8, 0x2A, 0x3B, 0xD3, 0xBC, 0x4A, 0x27, 0x8F, + 0x7E, 0xCD, 0x0D, 0xFA, 0x9B, 0xBD, 0xC4, 0x0B, + 0xE7, 0xA7, 0x87, 0xC8, 0xF1, 0x59, 0xB2, 0xDF + }, + { + 0xC5, 0x65, 0x46, 0xFB, 0x21, 0x78, 0x45, 0x6F, + 0x33, 0x61, 0x64, 0xC1, 0x8B, 0x90, 0xDE, 0xFF, + 0xC8, 0x3A, 0xE2, 0xB5, 0xA3, 0xAC, 0xA7, 0x7B, + 0x68, 0x84, 0xD3, 0x6D, 0x2C, 0x1D, 0xB3, 0x95, + 0x01, 0xB3, 0xE6, 0x5E, 0x36, 0xC7, 0x58, 0xC6, + 0x6E, 0x31, 0x88, 0x45, 0x1F, 0xDB, 0x35, 0x15, + 0xEE, 0x16, 0x2C, 0x00, 0x1F, 0x06, 0xC3, 0xE8, + 0xCB, 0x57, 0x3A, 0xDF, 0x30, 0xF7, 0xA1, 0x01 + }, + { + 0x6F, 0x82, 0xF8, 0x9F, 0x29, 0x9E, 0xBC, 0xA2, + 0xFE, 0x01, 0x4B, 0x59, 0xBF, 0xFE, 0x1A, 0xA8, + 0x4E, 0x88, 0xB1, 0x91, 0x5F, 0xE2, 0x56, 0xAF, + 0xB6, 0x46, 0xFD, 0x84, 0x48, 0xAF, 0x2B, 0x88, + 0x91, 0xA7, 0xFA, 0xB3, 0x7A, 0x4E, 0xA6, 0xF9, + 0xA5, 0x0E, 0x6C, 0x31, 0x70, 0x39, 0xD8, 0xCF, + 0x87, 0x8F, 0x4C, 0x8E, 0x1A, 0x0D, 0xD4, 0x64, + 0xF0, 0xB4, 0xD6, 0xFF, 0x1C, 0x7E, 0xA8, 0x53 + }, + { + 0x2B, 0x85, 0x99, 0xFF, 0x9C, 0x3D, 0x61, 0x98, + 0x63, 0x7A, 0xD5, 0x1E, 0x57, 0xD1, 0x99, 0x8B, + 0x0D, 0x75, 0x31, 0x3F, 0xE2, 0xDD, 0x61, 0xA5, + 0x33, 0xC9, 0x64, 0xA6, 0xDD, 0x96, 0x07, 0xC6, + 0xF7, 0x23, 0xE9, 0x45, 0x2C, 0xE4, 0x6E, 0x01, + 0x4B, 0x1C, 0x1D, 0x6D, 0xE7, 0x7B, 0xA5, 0xB8, + 0x8C, 0x91, 0x4D, 0x1C, 0x59, 0x7B, 0xF1, 0xEA, + 0xE1, 0x34, 0x74, 0xB4, 0x29, 0x0E, 0x89, 0xB2 + }, + { + 0x08, 0xBF, 0x34, 0x6D, 0x38, 0xE1, 0xDF, 0x06, + 0xC8, 0x26, 0x0E, 0xDB, 0x1D, 0xA7, 0x55, 0x79, + 0x27, 0x59, 0x48, 0xD5, 0xC0, 0xA0, 0xAA, 0x9E, + 0xD2, 0x88, 0x6F, 0x88, 0x56, 0xDE, 0x54, 0x17, + 0xA1, 0x56, 0x99, 0x87, 0x58, 0xF5, 0xB1, 0x7E, + 0x52, 0xF1, 0x01, 0xCA, 0x95, 0x7A, 0x71, 0x13, + 0x74, 0x73, 0xDF, 0xD1, 0x8D, 0x7D, 0x20, 0x9C, + 0x4C, 0x10, 0xD9, 0x23, 0x3C, 0x93, 0x69, 0x1D + }, + { + 0x6D, 0xF2, 0x15, 0x6D, 0x77, 0x31, 0x14, 0xD3, + 0x10, 0xB6, 0x3D, 0xB9, 0xEE, 0x53, 0x50, 0xD7, + 0x7E, 0x6B, 0xCF, 0x25, 0xB0, 0x5F, 0xCD, 0x91, + 0x0F, 0x9B, 0x31, 0xBC, 0x42, 0xBB, 0x13, 0xFE, + 0x82, 0x25, 0xEB, 0xCB, 0x2A, 0x23, 0xA6, 0x22, + 0x80, 0x77, 0x7B, 0x6B, 0xF7, 0x4E, 0x2C, 0xD0, + 0x91, 0x7C, 0x76, 0x40, 0xB4, 0x3D, 0xEF, 0xE4, + 0x68, 0xCD, 0x1E, 0x18, 0xC9, 0x43, 0xC6, 0x6A + }, + { + 0x7C, 0x70, 0x38, 0xBC, 0x13, 0xA9, 0x11, 0x51, + 0x82, 0x8A, 0x5B, 0xA8, 0x2B, 0x4A, 0x96, 0x04, + 0x0F, 0x25, 0x8A, 0x4D, 0xFB, 0x1B, 0x13, 0x73, + 0xF0, 0xD3, 0x59, 0x16, 0x8A, 0xFB, 0x05, 0x17, + 0xA2, 0x0B, 0x28, 0xA1, 0x2D, 0x36, 0x44, 0x04, + 0x6B, 0xE6, 0x6B, 0x8D, 0x08, 0xD8, 0xAE, 0x7F, + 0x6A, 0x92, 0x3E, 0xA1, 0xC0, 0x01, 0x87, 0xC6, + 0xD1, 0x1D, 0xC5, 0x02, 0xBA, 0xC7, 0x13, 0x05 + }, + { + 0xBC, 0xD1, 0xB3, 0x0D, 0x80, 0x8F, 0xB7, 0x39, + 0xB9, 0x87, 0xCB, 0xF1, 0x54, 0xBE, 0xA0, 0x0D, + 0xA9, 0xD4, 0x03, 0x80, 0xB8, 0x61, 0xD4, 0xC1, + 0xD6, 0x37, 0x71, 0x22, 0xDA, 0xDD, 0x61, 0xC0, + 0xE5, 0x90, 0x18, 0xB7, 0x19, 0x41, 0xCF, 0xB6, + 0x2E, 0x00, 0xDC, 0xD7, 0x0A, 0xEB, 0x9A, 0xBF, + 0x04, 0x73, 0xE8, 0x0F, 0x0A, 0x7E, 0xCA, 0x6B, + 0x6D, 0xEA, 0x24, 0x6A, 0xB2, 0x29, 0xDD, 0x2B + }, + { + 0x7E, 0xD4, 0x46, 0x8D, 0x96, 0x85, 0x30, 0xFE, + 0x7A, 0xB2, 0xC3, 0x35, 0x40, 0xB2, 0x6D, 0x8C, + 0x3B, 0xD3, 0xED, 0x44, 0xB3, 0x4F, 0xBE, 0x8C, + 0x2A, 0x9D, 0x7F, 0x80, 0x5B, 0x5A, 0xDA, 0x0E, + 0xA2, 0x52, 0xEE, 0xAD, 0xE4, 0xFC, 0xE9, 0x7F, + 0x89, 0x72, 0x8A, 0xD8, 0x5B, 0xC8, 0xBB, 0x24, + 0x30, 0xB1, 0xBE, 0xF2, 0xCD, 0xDD, 0x32, 0xC8, + 0x44, 0x6E, 0x59, 0xB8, 0xE8, 0xBA, 0x3C, 0x67 + }, + { + 0x6D, 0x30, 0xB7, 0xC6, 0xCE, 0x8A, 0x32, 0x36, + 0xC0, 0xCA, 0x2F, 0x8D, 0x72, 0x8B, 0x10, 0x88, + 0xCA, 0x06, 0x98, 0x3A, 0x80, 0x43, 0xE6, 0x21, + 0xD5, 0xDC, 0xF0, 0xC5, 0x37, 0xD1, 0x3B, 0x08, + 0x79, 0x1E, 0xDE, 0xB0, 0x1A, 0x3C, 0xF0, 0x94, + 0x3E, 0xC1, 0xC8, 0x90, 0xAB, 0x6E, 0x29, 0xB1, + 0x46, 0xA2, 0x36, 0xCD, 0x46, 0xBC, 0xB9, 0xD9, + 0x3B, 0xF5, 0x16, 0xFB, 0x67, 0xC6, 0x3F, 0xE5 + }, + { + 0x97, 0xFE, 0x03, 0xCE, 0xF3, 0x14, 0x38, 0x50, + 0x89, 0x11, 0xBD, 0xED, 0x97, 0x59, 0x80, 0xA6, + 0x60, 0x29, 0x30, 0x5D, 0xC5, 0xE3, 0xFA, 0x8A, + 0xD1, 0xB4, 0xFB, 0x22, 0xFC, 0xDF, 0x5A, 0x19, + 0xA7, 0x33, 0x32, 0x03, 0x27, 0xD8, 0xF7, 0x1C, + 0xCF, 0x49, 0x6C, 0xB3, 0xA4, 0x4A, 0x77, 0xAF, + 0x56, 0xE3, 0xDD, 0xE7, 0x3D, 0x3A, 0x5F, 0x17, + 0x68, 0x96, 0xCC, 0x57, 0xC9, 0xA5, 0xAD, 0x99 + }, + { + 0x78, 0x5A, 0x9D, 0x0F, 0xBD, 0x21, 0x13, 0x6D, + 0xBC, 0xE8, 0xFA, 0x7E, 0xAF, 0xD6, 0x3C, 0x9D, + 0xAD, 0x22, 0x00, 0x52, 0x97, 0x84, 0x16, 0xB3, + 0x1D, 0x97, 0x53, 0xEA, 0xA1, 0x49, 0x09, 0x78, + 0x47, 0xED, 0x9B, 0x30, 0xA6, 0x5C, 0x70, 0x50, + 0x7E, 0xFF, 0x01, 0x87, 0x91, 0x49, 0xED, 0x5C, + 0xF0, 0x47, 0x1D, 0x37, 0x79, 0x8E, 0xDC, 0x05, + 0xAB, 0xD5, 0x6A, 0xD4, 0xA2, 0xCC, 0xCB, 0x1D + }, + { + 0xAD, 0x40, 0x8D, 0x2A, 0xBD, 0xDF, 0xD3, 0x7B, + 0x3B, 0xF3, 0x47, 0x94, 0xC1, 0xA3, 0x37, 0x1D, + 0x92, 0x8E, 0xD7, 0xFC, 0x8D, 0x96, 0x62, 0x25, + 0x33, 0x35, 0x84, 0xC5, 0x66, 0x58, 0x17, 0x83, + 0x2A, 0x37, 0xC0, 0x7F, 0x0D, 0xC7, 0xCB, 0x5A, + 0xA8, 0x74, 0xCD, 0x7D, 0x20, 0xFE, 0x8F, 0xAB, + 0x8E, 0xAB, 0xCB, 0x9B, 0x33, 0xD2, 0xE0, 0x84, + 0x1F, 0x6E, 0x20, 0x09, 0x60, 0x89, 0x9D, 0x95 + }, + { + 0x97, 0x66, 0x8F, 0x74, 0x5B, 0x60, 0x32, 0xFC, + 0x81, 0x5D, 0x95, 0x79, 0x32, 0x27, 0x69, 0xDC, + 0xCD, 0x95, 0x01, 0xA5, 0x08, 0x00, 0x29, 0xB8, + 0xAE, 0x82, 0x6B, 0xEF, 0xB6, 0x74, 0x23, 0x31, + 0xBD, 0x9F, 0x76, 0xEF, 0xEB, 0x3E, 0x2B, 0x8E, + 0x81, 0xA9, 0x78, 0x6B, 0x28, 0x2F, 0x50, 0x68, + 0xA3, 0xA2, 0x42, 0x46, 0x97, 0xA7, 0x7C, 0x41, + 0x87, 0x6B, 0x7E, 0x75, 0x3F, 0x4C, 0x77, 0x67 + }, + { + 0x26, 0xBB, 0x98, 0x5F, 0x47, 0xE7, 0xFE, 0xE0, + 0xCF, 0xD2, 0x52, 0xD4, 0xEF, 0x96, 0xBE, 0xD4, + 0x2B, 0x9C, 0x37, 0x0C, 0x1C, 0x6A, 0x3E, 0x8C, + 0x9E, 0xB0, 0x4E, 0xF7, 0xF7, 0x81, 0x8B, 0x83, + 0x3A, 0x0D, 0x1F, 0x04, 0x3E, 0xBA, 0xFB, 0x91, + 0x1D, 0xC7, 0x79, 0xE0, 0x27, 0x40, 0xA0, 0x2A, + 0x44, 0xD3, 0xA1, 0xEA, 0x45, 0xED, 0x4A, 0xD5, + 0x5E, 0x68, 0x6C, 0x92, 0x7C, 0xAF, 0xE9, 0x7E + }, + { + 0x5B, 0xFE, 0x2B, 0x1D, 0xCF, 0x7F, 0xE9, 0xB9, + 0x50, 0x88, 0xAC, 0xED, 0xB5, 0x75, 0xC1, 0x90, + 0x16, 0xC7, 0x43, 0xB2, 0xE7, 0x63, 0xBF, 0x58, + 0x51, 0xAC, 0x40, 0x7C, 0x9E, 0xDA, 0x43, 0x71, + 0x5E, 0xDF, 0xA4, 0x8B, 0x48, 0x25, 0x49, 0x2C, + 0x51, 0x79, 0x59, 0x3F, 0xFF, 0x21, 0x35, 0x1B, + 0x76, 0xE8, 0xB7, 0xE0, 0x34, 0xE4, 0xC5, 0x3C, + 0x79, 0xF6, 0x1F, 0x29, 0xC4, 0x79, 0xBD, 0x08 + }, + { + 0xC7, 0x65, 0x09, 0xEF, 0x72, 0xF4, 0xA6, 0xF9, + 0xC9, 0xC4, 0x06, 0x18, 0xED, 0x52, 0xB2, 0x08, + 0x4F, 0x83, 0x50, 0x22, 0x32, 0xE0, 0xAC, 0x8B, + 0xDA, 0xF3, 0x26, 0x43, 0x68, 0xE4, 0xD0, 0x18, + 0x0F, 0x68, 0x54, 0xC4, 0xAB, 0xF4, 0xF6, 0x50, + 0x9C, 0x79, 0xCA, 0xAF, 0xC4, 0x4C, 0xF3, 0x19, + 0x4A, 0xFC, 0x57, 0xBD, 0x07, 0x7B, 0xD7, 0xB3, + 0xC9, 0xBD, 0xA3, 0xD4, 0xB8, 0x77, 0x58, 0x16 + }, + { + 0xD6, 0x6F, 0x2B, 0xEA, 0xB9, 0x90, 0xE3, 0x54, + 0xCC, 0xB9, 0x10, 0xE4, 0xE9, 0xC7, 0xAC, 0x61, + 0x8C, 0x7B, 0x63, 0xEF, 0x29, 0x2A, 0x96, 0xB5, + 0x52, 0x34, 0x1D, 0xE7, 0x8D, 0xC4, 0x6D, 0x3E, + 0xC8, 0xCF, 0xAB, 0xC6, 0x99, 0xB5, 0x0A, 0xF4, + 0x1F, 0xDA, 0x39, 0xCF, 0x1B, 0x01, 0x73, 0x66, + 0x09, 0x23, 0x51, 0x0A, 0xD6, 0x7F, 0xAE, 0xDE, + 0xF5, 0x20, 0x7C, 0xFF, 0xE8, 0x64, 0x1D, 0x20 + }, + { + 0x7D, 0x8F, 0x06, 0x72, 0x99, 0x2B, 0x79, 0xBE, + 0x3A, 0x36, 0x4D, 0x8E, 0x59, 0x04, 0xF4, 0xAB, + 0x71, 0x3B, 0xBC, 0x8A, 0xB0, 0x1B, 0x4F, 0x30, + 0x9A, 0xD8, 0xCC, 0xF2, 0x23, 0xCE, 0x10, 0x34, + 0xA8, 0x60, 0xDC, 0xB0, 0xB0, 0x05, 0x50, 0x61, + 0x2C, 0xC2, 0xFA, 0x17, 0xF2, 0x96, 0x9E, 0x18, + 0xF2, 0x2E, 0x14, 0x27, 0xD2, 0x54, 0xB4, 0xA8, + 0x2B, 0x3A, 0x03, 0xA3, 0xEB, 0x39, 0x4A, 0xDF + }, + { + 0xA5, 0x6D, 0x67, 0x25, 0xBF, 0xB3, 0xDE, 0x47, + 0xC1, 0x41, 0x4A, 0xDF, 0x25, 0xFC, 0x8F, 0x0F, + 0xC9, 0x84, 0x6F, 0x69, 0x87, 0x72, 0x2B, 0xC0, + 0x63, 0x66, 0xD5, 0xCA, 0x4E, 0x89, 0x72, 0x29, + 0x25, 0xEB, 0xBC, 0x88, 0x14, 0x18, 0x84, 0x40, + 0x75, 0x39, 0x7A, 0x0C, 0xA8, 0x98, 0x42, 0xC7, + 0xB9, 0xE9, 0xE0, 0x7E, 0x1D, 0x9D, 0x18, 0x3E, + 0xBE, 0xB3, 0x9E, 0x12, 0x0B, 0x48, 0x3B, 0xF7 + }, + { + 0xAF, 0x5E, 0x03, 0xD7, 0xFE, 0x60, 0xC6, 0x7E, + 0x10, 0x31, 0x33, 0x44, 0x43, 0x4E, 0x79, 0x48, + 0x5A, 0x03, 0xA7, 0x58, 0xD6, 0xDC, 0xE9, 0x85, + 0x57, 0x47, 0x45, 0x76, 0x3C, 0x1C, 0x5C, 0x77, + 0xD4, 0xFB, 0x3E, 0x6F, 0xB1, 0x22, 0x30, 0x36, + 0x83, 0x70, 0x99, 0x3B, 0xF9, 0x0F, 0xEE, 0xD0, + 0xC5, 0xD1, 0x60, 0x75, 0x24, 0x56, 0x2D, 0x7C, + 0x09, 0xC0, 0xC2, 0x10, 0xED, 0x39, 0x3D, 0x7C + }, + { + 0x7A, 0x20, 0x54, 0x0C, 0xC0, 0x7B, 0xF7, 0x2B, + 0x58, 0x24, 0x21, 0xFC, 0x34, 0x2E, 0x82, 0xF5, + 0x21, 0x34, 0xB6, 0x98, 0x41, 0xEC, 0x28, 0xED, + 0x18, 0x9E, 0x2E, 0xA6, 0xA2, 0x9D, 0xD2, 0xF8, + 0x2A, 0x64, 0x03, 0x52, 0xD2, 0x22, 0xB5, 0x2F, + 0x29, 0x11, 0xDC, 0x72, 0xA7, 0xDA, 0xB3, 0x1C, + 0xAA, 0xDD, 0x80, 0xC6, 0x11, 0x8F, 0x13, 0xC5, + 0x6B, 0x2A, 0x1E, 0x43, 0x73, 0xBE, 0x0E, 0xA3 + }, + { + 0x48, 0x6F, 0x02, 0xC6, 0x3E, 0x54, 0x67, 0xEA, + 0x1F, 0xDD, 0xE7, 0xE8, 0x2B, 0xFA, 0xCC, 0x2C, + 0x1B, 0xA5, 0xD6, 0x36, 0xD9, 0xF3, 0xD0, 0x8B, + 0x21, 0x0D, 0xA3, 0xF3, 0x72, 0xF7, 0x06, 0xEC, + 0x21, 0x8C, 0xC1, 0x7F, 0xF6, 0x0A, 0xEF, 0x70, + 0x3B, 0xBE, 0x0C, 0x15, 0xC3, 0x8A, 0xE5, 0x5D, + 0x28, 0x6A, 0x68, 0x4F, 0x86, 0x4C, 0x78, 0x21, + 0x1C, 0xCA, 0xB4, 0x17, 0x8C, 0x92, 0xAD, 0xBA + }, + { + 0x1C, 0x7A, 0x5C, 0x1D, 0xED, 0xCD, 0x04, 0xA9, + 0x21, 0x78, 0x8F, 0x7E, 0xB2, 0x33, 0x61, 0xCA, + 0x19, 0x53, 0xB0, 0x4B, 0x9C, 0x7A, 0xEC, 0x35, + 0xD6, 0x5E, 0xA3, 0xE4, 0x99, 0x6D, 0xB2, 0x6F, + 0x28, 0x12, 0x78, 0xEA, 0x4A, 0xE6, 0x66, 0xAD, + 0x81, 0x02, 0x7D, 0x98, 0xAF, 0x57, 0x26, 0x2C, + 0xDB, 0xFA, 0x4C, 0x08, 0x5F, 0x42, 0x10, 0x56, + 0x8C, 0x7E, 0x15, 0xEE, 0xC7, 0x80, 0x51, 0x14 + }, + { + 0x9C, 0xE3, 0xFA, 0x9A, 0x86, 0x0B, 0xDB, 0xD5, + 0x37, 0x8F, 0xD6, 0xD7, 0xB8, 0xB6, 0x71, 0xC6, + 0xCB, 0x76, 0x92, 0x91, 0x0C, 0xE8, 0xF9, 0xB6, + 0xCB, 0x41, 0x22, 0xCB, 0xCB, 0xE6, 0xAC, 0x06, + 0xCA, 0x04, 0x22, 0xCE, 0xF1, 0x22, 0x59, 0x35, + 0x05, 0x3B, 0x7D, 0x19, 0x3A, 0x81, 0xB9, 0xE9, + 0x72, 0xEB, 0x85, 0xA1, 0xD3, 0x07, 0x4F, 0x14, + 0xCB, 0xB5, 0xEC, 0x9F, 0x05, 0x73, 0x89, 0x2D + }, + { + 0xA9, 0x11, 0x87, 0xBE, 0x5C, 0x37, 0x1C, 0x42, + 0x65, 0xC1, 0x74, 0xFD, 0x46, 0x53, 0xB8, 0xAB, + 0x70, 0x85, 0x51, 0xF8, 0x3D, 0x1F, 0xEE, 0x1C, + 0xC1, 0x47, 0x95, 0x81, 0xBC, 0x00, 0x6D, 0x6F, + 0xB7, 0x8F, 0xCC, 0x9A, 0x5D, 0xEE, 0x1D, 0xB3, + 0x66, 0x6F, 0x50, 0x8F, 0x97, 0x80, 0xA3, 0x75, + 0x93, 0xEB, 0xCC, 0xCF, 0x5F, 0xBE, 0xD3, 0x96, + 0x67, 0xDC, 0x63, 0x61, 0xE9, 0x21, 0xF7, 0x79 + }, + { + 0x46, 0x25, 0x76, 0x7D, 0x7B, 0x1D, 0x3D, 0x3E, + 0xD2, 0xFB, 0xC6, 0x74, 0xAF, 0x14, 0xE0, 0x24, + 0x41, 0x52, 0xF2, 0xA4, 0x02, 0x1F, 0xCF, 0x33, + 0x11, 0x50, 0x5D, 0x89, 0xBD, 0x81, 0xE2, 0xF9, + 0xF9, 0xA5, 0x00, 0xC3, 0xB1, 0x99, 0x91, 0x4D, + 0xB4, 0x95, 0x00, 0xB3, 0xC9, 0x8D, 0x03, 0xEA, + 0x93, 0x28, 0x67, 0x51, 0xA6, 0x86, 0xA3, 0xB8, + 0x75, 0xDA, 0xAB, 0x0C, 0xCD, 0x63, 0xB4, 0x4F + }, + { + 0x43, 0xDF, 0xDF, 0xE1, 0xB0, 0x14, 0xFE, 0xD3, + 0xA2, 0xAC, 0xAB, 0xB7, 0xF3, 0xE9, 0xA1, 0x82, + 0xF2, 0xAA, 0x18, 0x01, 0x9D, 0x27, 0xE3, 0xE6, + 0xCD, 0xCF, 0x31, 0xA1, 0x5B, 0x42, 0x8E, 0x91, + 0xE7, 0xB0, 0x8C, 0xF5, 0xE5, 0xC3, 0x76, 0xFC, + 0xE2, 0xD8, 0xA2, 0x8F, 0xF8, 0x5A, 0xB0, 0xA0, + 0xA1, 0x65, 0x6E, 0xDB, 0x4A, 0x0A, 0x91, 0x53, + 0x26, 0x20, 0x09, 0x6D, 0x9A, 0x5A, 0x65, 0x2D + }, + { + 0x27, 0x9E, 0x32, 0x02, 0xBE, 0x39, 0x89, 0xBA, + 0x31, 0x12, 0x77, 0x25, 0x85, 0x17, 0x74, 0x87, + 0xE4, 0xFE, 0x3E, 0xE3, 0xEA, 0xB4, 0x9C, 0x2F, + 0x7F, 0xA7, 0xFE, 0x87, 0xCF, 0xE7, 0xB8, 0x0D, + 0x3E, 0x03, 0x55, 0xED, 0xFF, 0x6D, 0x03, 0x1E, + 0x6C, 0x96, 0xC7, 0x95, 0xDB, 0x1C, 0x6F, 0x04, + 0x18, 0x80, 0xEC, 0x38, 0x24, 0xDE, 0xFA, 0xCF, + 0x92, 0x63, 0x82, 0x0A, 0x8E, 0x73, 0x27, 0xDE + }, + { + 0xEA, 0x2D, 0x06, 0x6A, 0xC2, 0x29, 0xD4, 0xD4, + 0xB6, 0x16, 0xA8, 0xBE, 0xDE, 0xC7, 0x34, 0x32, + 0x52, 0x24, 0xE4, 0xB4, 0xE5, 0x8F, 0x1A, 0xE6, + 0xDA, 0xD7, 0xE4, 0x0C, 0x2D, 0xA2, 0x91, 0x96, + 0xC3, 0xB1, 0xEA, 0x95, 0x71, 0xDA, 0xCC, 0x81, + 0xE8, 0x73, 0x28, 0xCA, 0xA0, 0x21, 0x1E, 0x09, + 0x02, 0x7B, 0x05, 0x24, 0xAA, 0x3F, 0x4A, 0x84, + 0x99, 0x17, 0xB3, 0x58, 0x67, 0x47, 0xEB, 0xBB + }, + { + 0x49, 0xF0, 0x14, 0xF5, 0xC6, 0x18, 0x22, 0xC8, + 0x99, 0xAB, 0x5C, 0xAE, 0x51, 0xBE, 0x40, 0x44, + 0xA4, 0x49, 0x5E, 0x77, 0x7D, 0xEB, 0x7D, 0xA9, + 0xB6, 0xD8, 0x49, 0x0E, 0xFB, 0xB8, 0x75, 0x30, + 0xAD, 0xF2, 0x93, 0xDA, 0xF0, 0x79, 0xF9, 0x4C, + 0x33, 0xB7, 0x04, 0x4E, 0xF6, 0x2E, 0x2E, 0x5B, + 0xB3, 0xEB, 0x11, 0xE1, 0x73, 0x04, 0xF8, 0x45, + 0x3E, 0xE6, 0xCE, 0x24, 0xF0, 0x33, 0xDD, 0xB0 + }, + { + 0x92, 0x33, 0x49, 0x03, 0x44, 0xE5, 0xB0, 0xDC, + 0x59, 0x12, 0x67, 0x1B, 0x7A, 0xE5, 0x4C, 0xEE, + 0x77, 0x30, 0xDB, 0xE1, 0xF4, 0xC7, 0xD9, 0x2A, + 0x4D, 0x3E, 0x3A, 0xAB, 0x50, 0x57, 0x17, 0x08, + 0xDB, 0x51, 0xDC, 0xF9, 0xC2, 0x94, 0x45, 0x91, + 0xDB, 0x65, 0x1D, 0xB3, 0x2D, 0x22, 0x93, 0x5B, + 0x86, 0x94, 0x49, 0x69, 0xBE, 0x77, 0xD5, 0xB5, + 0xFE, 0xAE, 0x6C, 0x38, 0x40, 0xA8, 0xDB, 0x26 + }, + { + 0xB6, 0xE7, 0x5E, 0x6F, 0x4C, 0x7F, 0x45, 0x3B, + 0x74, 0x65, 0xD2, 0x5B, 0x5A, 0xC8, 0xC7, 0x19, + 0x69, 0x02, 0xEA, 0xA9, 0x53, 0x87, 0x52, 0x28, + 0xC8, 0x63, 0x4E, 0x16, 0xE2, 0xAE, 0x1F, 0x38, + 0xBC, 0x32, 0x75, 0x30, 0x43, 0x35, 0xF5, 0x98, + 0x9E, 0xCC, 0xC1, 0xE3, 0x41, 0x67, 0xD4, 0xE6, + 0x8D, 0x77, 0x19, 0x96, 0x8F, 0xBA, 0x8E, 0x2F, + 0xE6, 0x79, 0x47, 0xC3, 0x5C, 0x48, 0xE8, 0x06 + }, + { + 0xCC, 0x14, 0xCA, 0x66, 0x5A, 0xF1, 0x48, 0x3E, + 0xFB, 0xC3, 0xAF, 0x80, 0x08, 0x0E, 0x65, 0x0D, + 0x50, 0x46, 0xA3, 0x93, 0x2F, 0x4F, 0x51, 0xF3, + 0xFE, 0x90, 0xA0, 0x70, 0x5E, 0xC2, 0x51, 0x04, + 0xAD, 0xF0, 0x78, 0x39, 0x26, 0x5D, 0xC5, 0x1D, + 0x43, 0x40, 0x14, 0x11, 0x24, 0x6E, 0x47, 0x4F, + 0x0D, 0x5E, 0x56, 0x37, 0xAF, 0x94, 0x76, 0x72, + 0x83, 0xD5, 0x3E, 0x06, 0x17, 0xE9, 0x81, 0xF4 + }, + { + 0x23, 0x0A, 0x1C, 0x85, 0x7C, 0xB2, 0xE7, 0x85, + 0x2E, 0x41, 0xB6, 0x47, 0xE9, 0x0E, 0x45, 0x85, + 0xD2, 0xD8, 0x81, 0xE1, 0x73, 0x4D, 0xC3, 0x89, + 0x55, 0x35, 0x6E, 0x8D, 0xD7, 0xBF, 0xF3, 0x90, + 0x53, 0x09, 0x2C, 0x6B, 0x38, 0xE2, 0x36, 0xE1, + 0x89, 0x95, 0x25, 0x64, 0x70, 0x73, 0xDD, 0xDF, + 0x68, 0x95, 0xD6, 0x42, 0x06, 0x32, 0x5E, 0x76, + 0x47, 0xF2, 0x75, 0x56, 0x7B, 0x25, 0x59, 0x09 + }, + { + 0xCB, 0xB6, 0x53, 0x21, 0xAC, 0x43, 0x6E, 0x2F, + 0xFD, 0xAB, 0x29, 0x36, 0x35, 0x9C, 0xE4, 0x90, + 0x23, 0xF7, 0xDE, 0xE7, 0x61, 0x4E, 0xF2, 0x8D, + 0x17, 0x3C, 0x3D, 0x27, 0xC5, 0xD1, 0xBF, 0xFA, + 0x51, 0x55, 0x3D, 0x43, 0x3F, 0x8E, 0xE3, 0xC9, + 0xE4, 0x9C, 0x05, 0xA2, 0xB8, 0x83, 0xCC, 0xE9, + 0x54, 0xC9, 0xA8, 0x09, 0x3B, 0x80, 0x61, 0x2A, + 0x0C, 0xDD, 0x47, 0x32, 0xE0, 0x41, 0xF9, 0x95 + }, + { + 0x3E, 0x7E, 0x57, 0x00, 0x74, 0x33, 0x72, 0x75, + 0xEF, 0xB5, 0x13, 0x15, 0x58, 0x80, 0x34, 0xC3, + 0xCF, 0x0D, 0xDD, 0xCA, 0x20, 0xB4, 0x61, 0x2E, + 0x0B, 0xD5, 0xB8, 0x81, 0xE7, 0xE5, 0x47, 0x6D, + 0x31, 0x9C, 0xE4, 0xFE, 0x9F, 0x19, 0x18, 0x6E, + 0x4C, 0x08, 0x26, 0xF4, 0x4F, 0x13, 0x1E, 0xB0, + 0x48, 0xE6, 0x5B, 0xE2, 0x42, 0xB1, 0x17, 0x2C, + 0x63, 0xBA, 0xDB, 0x12, 0x3A, 0xB0, 0xCB, 0xE8 + }, + { + 0xD3, 0x2E, 0x9E, 0xC0, 0x2D, 0x38, 0xD4, 0xE1, + 0xB8, 0x24, 0x9D, 0xF8, 0xDC, 0xB0, 0x0C, 0x5B, + 0x9C, 0x68, 0xEB, 0x89, 0x22, 0x67, 0x2E, 0x35, + 0x05, 0x39, 0x3B, 0x6A, 0x21, 0x0B, 0xA5, 0x6F, + 0x94, 0x96, 0xE5, 0xEE, 0x04, 0x90, 0xEF, 0x38, + 0x7C, 0x3C, 0xDE, 0xC0, 0x61, 0xF0, 0x6B, 0xC0, + 0x38, 0x2D, 0x93, 0x04, 0xCA, 0xFB, 0xB8, 0xE0, + 0xCD, 0x33, 0xD5, 0x70, 0x29, 0xE6, 0x2D, 0xF2 + }, + { + 0x8C, 0x15, 0x12, 0x46, 0x60, 0x89, 0xF0, 0x5B, + 0x37, 0x75, 0xC2, 0x62, 0xB6, 0x2D, 0x22, 0xB8, + 0x38, 0x54, 0xA8, 0x32, 0x18, 0x13, 0x0B, 0x4E, + 0xC9, 0x1B, 0x3C, 0xCB, 0xD2, 0x93, 0xD2, 0xA5, + 0x43, 0x02, 0xCE, 0xCA, 0xAB, 0x9B, 0x10, 0x0C, + 0x68, 0xD1, 0xE6, 0xDD, 0xC8, 0xF0, 0x7C, 0xDD, + 0xBD, 0xFE, 0x6F, 0xDA, 0xAA, 0xF0, 0x99, 0xCC, + 0x09, 0xD6, 0xB7, 0x25, 0x87, 0x9C, 0x63, 0x69 + }, + { + 0x91, 0xA7, 0xF6, 0x1C, 0x97, 0xC2, 0x91, 0x1E, + 0x4C, 0x81, 0x2E, 0xF7, 0x1D, 0x78, 0x0A, 0xD8, + 0xFA, 0x78, 0x87, 0x94, 0x56, 0x1D, 0x08, 0x30, + 0x3F, 0xD1, 0xC1, 0xCB, 0x60, 0x8A, 0x46, 0xA1, + 0x25, 0x63, 0x08, 0x6E, 0xC5, 0xB3, 0x9D, 0x47, + 0x1A, 0xED, 0x94, 0xFB, 0x0F, 0x6C, 0x67, 0x8A, + 0x43, 0xB8, 0x79, 0x29, 0x32, 0xF9, 0x02, 0x8D, + 0x77, 0x2A, 0x22, 0x76, 0x8E, 0xA2, 0x3A, 0x9B + }, + { + 0x4F, 0x6B, 0xB2, 0x22, 0xA3, 0x95, 0xE8, 0xB1, + 0x8F, 0x6B, 0xA1, 0x55, 0x47, 0x7A, 0xED, 0x3F, + 0x07, 0x29, 0xAC, 0x9E, 0x83, 0xE1, 0x6D, 0x31, + 0xA2, 0xA8, 0xBC, 0x65, 0x54, 0x22, 0xB8, 0x37, + 0xC8, 0x91, 0xC6, 0x19, 0x9E, 0x6F, 0x0D, 0x75, + 0x79, 0x9E, 0x3B, 0x69, 0x15, 0x25, 0xC5, 0x81, + 0x95, 0x35, 0x17, 0xF2, 0x52, 0xC4, 0xB9, 0xE3, + 0xA2, 0x7A, 0x28, 0xFB, 0xAF, 0x49, 0x64, 0x4C + }, + { + 0x5D, 0x06, 0xC0, 0x7E, 0x7A, 0x64, 0x6C, 0x41, + 0x3A, 0x50, 0x1C, 0x3F, 0x4B, 0xB2, 0xFC, 0x38, + 0x12, 0x7D, 0xE7, 0x50, 0x9B, 0x70, 0x77, 0xC4, + 0xD9, 0xB5, 0x61, 0x32, 0x01, 0xC1, 0xAA, 0x02, + 0xFD, 0x5F, 0x79, 0xD2, 0x74, 0x59, 0x15, 0xDD, + 0x57, 0xFB, 0xCB, 0x4C, 0xE0, 0x86, 0x95, 0xF6, + 0xEF, 0xC0, 0xCB, 0x3D, 0x2D, 0x33, 0x0E, 0x19, + 0xB4, 0xB0, 0xE6, 0x00, 0x4E, 0xA6, 0x47, 0x1E + }, + { + 0xB9, 0x67, 0x56, 0xE5, 0x79, 0x09, 0x96, 0x8F, + 0x14, 0xB7, 0x96, 0xA5, 0xD3, 0x0F, 0x4C, 0x9D, + 0x67, 0x14, 0x72, 0xCF, 0x82, 0xC8, 0xCF, 0xB2, + 0xCA, 0xCA, 0x7A, 0xC7, 0xA4, 0x4C, 0xA0, 0xA1, + 0x4C, 0x98, 0x42, 0xD0, 0x0C, 0x82, 0xE3, 0x37, + 0x50, 0x2C, 0x94, 0xD5, 0x96, 0x0A, 0xCA, 0x4C, + 0x49, 0x2E, 0xA7, 0xB0, 0xDF, 0x91, 0x9D, 0xDF, + 0x1A, 0xAD, 0xA2, 0xA2, 0x75, 0xBB, 0x10, 0xD4 + }, + { + 0xFF, 0x0A, 0x01, 0x5E, 0x98, 0xDB, 0x9C, 0x99, + 0xF0, 0x39, 0x77, 0x71, 0x0A, 0xAC, 0x3E, 0x65, + 0x8C, 0x0D, 0x89, 0x6F, 0x6D, 0x71, 0xD6, 0x18, + 0xBA, 0x79, 0xDC, 0x6C, 0xF7, 0x2A, 0xC7, 0x5B, + 0x7C, 0x03, 0x8E, 0xB6, 0x86, 0x2D, 0xED, 0xE4, + 0x54, 0x3E, 0x14, 0x54, 0x13, 0xA6, 0x36, 0x8D, + 0x69, 0xF5, 0x72, 0x2C, 0x82, 0x7B, 0xA3, 0xEF, + 0x25, 0xB6, 0xAE, 0x64, 0x40, 0xD3, 0x92, 0x76 + }, + { + 0x5B, 0x21, 0xC5, 0xFD, 0x88, 0x68, 0x36, 0x76, + 0x12, 0x47, 0x4F, 0xA2, 0xE7, 0x0E, 0x9C, 0xFA, + 0x22, 0x01, 0xFF, 0xEE, 0xE8, 0xFA, 0xFA, 0xB5, + 0x79, 0x7A, 0xD5, 0x8F, 0xEF, 0xA1, 0x7C, 0x9B, + 0x5B, 0x10, 0x7D, 0xA4, 0xA3, 0xDB, 0x63, 0x20, + 0xBA, 0xAF, 0x2C, 0x86, 0x17, 0xD5, 0xA5, 0x1D, + 0xF9, 0x14, 0xAE, 0x88, 0xDA, 0x38, 0x67, 0xC2, + 0xD4, 0x1F, 0x0C, 0xC1, 0x4F, 0xA6, 0x79, 0x28 + }, + { + 0x1E, 0xCC, 0x89, 0x6F, 0x34, 0xD3, 0xF9, 0xCA, + 0xC4, 0x84, 0xC7, 0x3F, 0x75, 0xF6, 0xA5, 0xFB, + 0x58, 0xEE, 0x67, 0x84, 0xBE, 0x41, 0xB3, 0x5F, + 0x46, 0x06, 0x7B, 0x9C, 0x65, 0xC6, 0x3A, 0x67, + 0x94, 0xD3, 0xD7, 0x44, 0x11, 0x2C, 0x65, 0x3F, + 0x73, 0xDD, 0x7D, 0xEB, 0x66, 0x66, 0x20, 0x4C, + 0x5A, 0x9B, 0xFA, 0x5B, 0x46, 0x08, 0x1F, 0xC1, + 0x0F, 0xDB, 0xE7, 0x88, 0x4F, 0xA5, 0xCB, 0xF8 + }, + { + 0xD8, 0xBF, 0xE0, 0x68, 0xDE, 0x0B, 0x4F, 0x9F, + 0xA8, 0x76, 0xA3, 0xF8, 0x02, 0x4E, 0xB9, 0xF7, + 0xB0, 0x02, 0x9F, 0xD5, 0xDC, 0xF2, 0x51, 0x19, + 0x9E, 0x06, 0x5C, 0xEE, 0x89, 0xE1, 0xA2, 0x82, + 0xC8, 0xDB, 0xF0, 0x44, 0x2F, 0x2A, 0xDE, 0x72, + 0x94, 0xAC, 0x1C, 0x6B, 0xE1, 0x9B, 0x38, 0x8D, + 0xC9, 0x90, 0xC3, 0x4D, 0x8C, 0xB7, 0x9F, 0x5F, + 0x10, 0xC5, 0x4F, 0xA8, 0x13, 0x83, 0x4F, 0xDA + }, + { + 0xC1, 0xBB, 0x4F, 0x2E, 0x91, 0x99, 0xF4, 0x8C, + 0x95, 0xFF, 0xFA, 0x33, 0xAD, 0x37, 0x19, 0x96, + 0xA6, 0x2A, 0xF2, 0x34, 0xF2, 0x4F, 0x68, 0xA4, + 0xF8, 0x6C, 0x34, 0x94, 0x44, 0xB6, 0x24, 0xB3, + 0x2D, 0x90, 0xC8, 0xB2, 0xC9, 0xF0, 0xD6, 0xCA, + 0xCC, 0xAA, 0x6A, 0x7D, 0x25, 0xBE, 0xE9, 0x4E, + 0x39, 0x7F, 0x3D, 0x3F, 0x5D, 0x48, 0xC9, 0x64, + 0x17, 0x11, 0xB7, 0x23, 0x82, 0x64, 0x51, 0xBC + }, + { + 0x04, 0xC7, 0xF3, 0xC1, 0x2A, 0x7C, 0x14, 0x75, + 0x33, 0xE9, 0xCC, 0xB3, 0xD0, 0xFD, 0x56, 0xF7, + 0xD6, 0x36, 0xEB, 0xDE, 0x70, 0x19, 0x2C, 0xE4, + 0x24, 0x1A, 0x63, 0x1B, 0x5E, 0x34, 0xFD, 0x6E, + 0x63, 0x58, 0x0C, 0x3A, 0xB4, 0xDC, 0x9F, 0x28, + 0xA5, 0x49, 0x04, 0xA4, 0x59, 0x93, 0x8C, 0xC0, + 0xD6, 0xED, 0x82, 0x59, 0x9D, 0x11, 0x81, 0x86, + 0x6D, 0x95, 0xAA, 0x84, 0xF3, 0x3E, 0x5D, 0x55 + }, + { + 0xE9, 0x56, 0x13, 0x04, 0xFF, 0xE3, 0xBD, 0xC8, + 0x3D, 0x44, 0xAB, 0x65, 0x11, 0xC5, 0xC9, 0x48, + 0x49, 0x2B, 0x91, 0x17, 0x3F, 0x43, 0x31, 0x2C, + 0x5D, 0xB4, 0x7B, 0x36, 0x75, 0x7E, 0x4C, 0x6C, + 0x28, 0xD7, 0xD7, 0x49, 0x6B, 0x13, 0x70, 0xB0, + 0xD9, 0x51, 0xD8, 0x93, 0x21, 0x31, 0x7B, 0xE2, + 0xEA, 0x15, 0xD3, 0xD3, 0xCD, 0xFD, 0xCB, 0x86, + 0x52, 0x2D, 0x0F, 0xE6, 0x81, 0x18, 0x05, 0xC0 + }, + { + 0x43, 0xA5, 0x4F, 0xBC, 0x88, 0x0D, 0xFC, 0x4D, + 0x8F, 0x09, 0x23, 0x11, 0x1E, 0xCD, 0xD2, 0x10, + 0xF3, 0x79, 0x17, 0xDB, 0xE7, 0x2E, 0xEE, 0xC1, + 0x19, 0xE4, 0x4B, 0xA2, 0x2C, 0x05, 0x50, 0x6C, + 0x27, 0xA0, 0xF0, 0xBD, 0xD6, 0x4A, 0x1F, 0xAE, + 0x3E, 0x67, 0xEE, 0xC5, 0x14, 0x57, 0x9F, 0xF8, + 0x13, 0xFA, 0x62, 0xFE, 0x3A, 0x28, 0xBD, 0xA6, + 0x03, 0xB4, 0x59, 0x3C, 0xD0, 0xC8, 0x73, 0x5B + }, + { + 0xD5, 0xEF, 0x36, 0x9F, 0x56, 0x72, 0x44, 0x95, + 0xB2, 0x22, 0xAB, 0xCE, 0xEB, 0xB7, 0x3B, 0xBD, + 0xC6, 0x6B, 0x66, 0x46, 0x27, 0x58, 0x90, 0x07, + 0xA9, 0x2F, 0x54, 0xE1, 0x23, 0x17, 0xAA, 0x05, + 0x8B, 0x23, 0xB0, 0x03, 0x09, 0x6E, 0xE9, 0x29, + 0xF0, 0xB6, 0x61, 0x8E, 0x8D, 0x64, 0x5A, 0x81, + 0x03, 0x24, 0x24, 0x29, 0x2B, 0x7F, 0x50, 0x6E, + 0xA4, 0x6C, 0x4D, 0x3E, 0xD6, 0x9D, 0x55, 0x8D + }, + { + 0xF5, 0x7A, 0x7C, 0xCC, 0xFC, 0x1F, 0x44, 0x3C, + 0x41, 0x5B, 0x5B, 0x9D, 0xF2, 0xCA, 0x23, 0x67, + 0x75, 0xBB, 0x90, 0x12, 0x9C, 0x9C, 0x37, 0x79, + 0xBC, 0xEF, 0x23, 0xD5, 0xCA, 0xF7, 0x00, 0xF3, + 0xA2, 0x59, 0xFB, 0x7D, 0xDF, 0x1F, 0xD7, 0x62, + 0xE0, 0x82, 0xDB, 0xF6, 0x0F, 0x21, 0x0B, 0xE7, + 0x27, 0x79, 0xB8, 0x28, 0x9C, 0x07, 0x2F, 0xFB, + 0x51, 0x8D, 0x8F, 0x6A, 0x0F, 0xB0, 0x4A, 0xFB + }, + { + 0xF2, 0xC1, 0x68, 0x94, 0x0F, 0x3A, 0x1B, 0x1F, + 0x57, 0xC6, 0x2E, 0x43, 0xAF, 0x8D, 0xA3, 0xF9, + 0xD5, 0x6A, 0xCE, 0x4D, 0x20, 0x5C, 0x1D, 0x45, + 0x4A, 0x8F, 0x68, 0x0D, 0x9A, 0x14, 0xD8, 0x3E, + 0xA9, 0x60, 0x59, 0xC2, 0x78, 0xF1, 0x4A, 0x34, + 0x41, 0x14, 0xC1, 0xEA, 0xB7, 0xC4, 0x66, 0xF9, + 0x62, 0x82, 0x1B, 0xA8, 0x69, 0xB5, 0x14, 0xE7, + 0xEF, 0x76, 0x5F, 0x94, 0x4F, 0xD0, 0xBF, 0x93 + }, + { + 0xF0, 0xAF, 0x5C, 0xD6, 0x9C, 0x40, 0xB7, 0x48, + 0x74, 0xA7, 0x16, 0x4F, 0x57, 0xCA, 0xBD, 0xBA, + 0x88, 0xA3, 0xD7, 0xA8, 0x98, 0x41, 0x93, 0x33, + 0x25, 0x6E, 0xF5, 0x76, 0x70, 0x0A, 0x20, 0x4D, + 0x28, 0xD1, 0x98, 0x5B, 0x3E, 0x73, 0x1F, 0xD6, + 0xF5, 0xF8, 0xA3, 0xC9, 0x81, 0xE3, 0xF2, 0x55, + 0x84, 0x84, 0x44, 0x41, 0x8F, 0x34, 0x25, 0x2A, + 0x6D, 0x71, 0xEC, 0x2C, 0x89, 0xA7, 0x43, 0xA3 + }, + { + 0x3E, 0xC1, 0x8A, 0x85, 0x5A, 0x02, 0x2A, 0xA8, + 0x61, 0x4C, 0x9C, 0x3B, 0xBE, 0x3A, 0x56, 0xB9, + 0x6F, 0xC6, 0x13, 0x97, 0x53, 0x1E, 0x81, 0x81, + 0xE4, 0x6B, 0x36, 0x81, 0x8E, 0xA9, 0x05, 0xAE, + 0xC7, 0x7D, 0x6E, 0x83, 0x46, 0xF8, 0xD5, 0xEB, + 0x1A, 0x10, 0xB1, 0xFE, 0x26, 0x1B, 0x4D, 0xD3, + 0xA3, 0xD0, 0x8C, 0x3D, 0x91, 0x78, 0x14, 0x5F, + 0x2A, 0x2F, 0x51, 0x92, 0x2B, 0xA5, 0x6D, 0x5F + }, + { + 0xAD, 0x69, 0xEA, 0xF3, 0x71, 0xF2, 0x95, 0x36, + 0x3D, 0x94, 0x8C, 0xB9, 0x30, 0xF5, 0xCE, 0x5E, + 0xF3, 0x90, 0xE7, 0xFF, 0xB8, 0x91, 0x4E, 0x22, + 0xDA, 0x8E, 0x2B, 0xFA, 0x15, 0xBE, 0x5D, 0xA9, + 0x3C, 0xC3, 0x08, 0x10, 0xF0, 0x44, 0x44, 0xE0, + 0xC7, 0xB7, 0x9A, 0x03, 0x3E, 0x08, 0x39, 0x78, + 0x17, 0xB7, 0x87, 0x47, 0x30, 0x09, 0x56, 0x34, + 0x29, 0x0E, 0x1E, 0x16, 0x73, 0x99, 0x8A, 0x8F + }, + { + 0xE8, 0xE5, 0x3D, 0x5A, 0x46, 0x77, 0x30, 0xAC, + 0x01, 0x0A, 0xF6, 0xE0, 0x2E, 0x0D, 0xA3, 0x98, + 0x16, 0x90, 0xCF, 0x86, 0x73, 0x0F, 0xA8, 0x0E, + 0x45, 0xB9, 0x4B, 0x69, 0x2D, 0x86, 0x82, 0x6F, + 0xC5, 0x06, 0xE4, 0x47, 0x7F, 0x59, 0x91, 0x05, + 0x74, 0xDD, 0xD2, 0x51, 0x45, 0x92, 0xD7, 0x92, + 0xCB, 0x52, 0x0F, 0x83, 0xD8, 0xEA, 0x41, 0x76, + 0x35, 0xA8, 0x1C, 0x1A, 0x9D, 0x3B, 0xAF, 0x15 + }, + { + 0xD8, 0x43, 0xF0, 0xE0, 0x15, 0xD2, 0x7D, 0xA1, + 0x23, 0x15, 0xD5, 0xDA, 0x68, 0x50, 0x5E, 0xB1, + 0x45, 0x9A, 0x52, 0xDC, 0xBA, 0xC1, 0x83, 0xBF, + 0x42, 0x76, 0xF5, 0xDC, 0xFA, 0xC2, 0x25, 0x72, + 0x8E, 0x87, 0xA1, 0x8A, 0x13, 0x3D, 0xB6, 0xB3, + 0x3B, 0xB4, 0xCE, 0xBC, 0xEE, 0x2E, 0x55, 0x07, + 0xBC, 0x18, 0xB7, 0x64, 0x3F, 0xF5, 0xD1, 0xB2, + 0xFB, 0x02, 0xE3, 0x5C, 0x26, 0xE6, 0xDA, 0x6C + }, + { + 0x8E, 0x06, 0x30, 0x20, 0x05, 0xFE, 0x74, 0xC3, + 0xE5, 0x67, 0xF1, 0x24, 0x7C, 0x62, 0x71, 0x00, + 0x8D, 0x86, 0x1C, 0xD5, 0xE2, 0x93, 0x8E, 0x0E, + 0xEA, 0x73, 0x49, 0x6E, 0xE5, 0xA2, 0x7D, 0xB6, + 0x41, 0x4D, 0xE1, 0x3A, 0x8D, 0x61, 0xD8, 0x11, + 0x88, 0x8D, 0xD2, 0xB8, 0x6B, 0x35, 0xE6, 0x7A, + 0xBA, 0xBB, 0xEB, 0xD1, 0xC9, 0x2E, 0xCE, 0x1F, + 0x7E, 0xF4, 0xA4, 0xB1, 0xBA, 0x0D, 0xBD, 0x18 + }, + { + 0xF9, 0xFF, 0xE5, 0x22, 0x2A, 0x19, 0x20, 0x4D, + 0x53, 0x01, 0x61, 0xD5, 0xE1, 0xC4, 0xF8, 0x9B, + 0x9E, 0x70, 0x72, 0x49, 0xD8, 0xC5, 0x3A, 0xAC, + 0x1D, 0xC8, 0xC6, 0x51, 0x05, 0x88, 0xE6, 0x77, + 0x53, 0xEF, 0x11, 0xA1, 0x48, 0x0D, 0xF2, 0x3E, + 0x94, 0x2F, 0x84, 0x48, 0xC3, 0xB8, 0xD8, 0xDB, + 0xB1, 0xC1, 0x83, 0xB8, 0x13, 0xE5, 0xD2, 0x19, + 0x8A, 0x7E, 0x34, 0x32, 0xEF, 0xC7, 0xBB, 0x74 + }, + { + 0xFD, 0xD4, 0x73, 0x81, 0xC5, 0xB0, 0x46, 0xA9, + 0xC8, 0x4F, 0xD4, 0x35, 0x38, 0x96, 0xD9, 0xBE, + 0xC2, 0xB6, 0x61, 0xD4, 0xF8, 0xBF, 0xAE, 0xE3, + 0x8E, 0xA0, 0x9E, 0xE4, 0x8D, 0xAD, 0x4C, 0x3D, + 0x14, 0x49, 0xEB, 0x47, 0xD7, 0xEB, 0xD6, 0x42, + 0xA0, 0x3E, 0xF7, 0x68, 0x67, 0x26, 0x86, 0x10, + 0x85, 0xBB, 0x00, 0x2E, 0x24, 0x8E, 0xF7, 0x24, + 0x7C, 0x64, 0xE1, 0x00, 0x3F, 0x75, 0xA5, 0xFE + }, + { + 0xE2, 0x43, 0xB3, 0x23, 0x28, 0xB8, 0xC9, 0xEC, + 0xCB, 0xE5, 0x8F, 0xB8, 0xB1, 0x5F, 0x8B, 0x91, + 0x72, 0xF9, 0x18, 0xBD, 0x4D, 0x91, 0x76, 0x65, + 0xB7, 0x0C, 0x00, 0xD8, 0xBA, 0x36, 0x43, 0x98, + 0x9E, 0x2F, 0xE7, 0x0A, 0x6D, 0x18, 0x06, 0x89, + 0xDB, 0xE6, 0xEF, 0xF3, 0xC5, 0xBF, 0x37, 0xED, + 0xC4, 0x02, 0x33, 0x4E, 0xAE, 0xC2, 0x84, 0xD3, + 0xAE, 0xDB, 0x2B, 0x27, 0x45, 0x66, 0xE5, 0xF9 + }, + { + 0x89, 0x48, 0x72, 0xE3, 0xF4, 0x63, 0x71, 0xA3, + 0xCC, 0x5A, 0x5D, 0xD1, 0x07, 0x1E, 0x4A, 0xA0, + 0x51, 0x61, 0xAC, 0xD1, 0x48, 0x7E, 0x85, 0xA2, + 0x65, 0xD1, 0x92, 0xEC, 0xE4, 0xDC, 0x2A, 0x65, + 0x06, 0xF4, 0x02, 0x58, 0xB0, 0x7A, 0x5B, 0x9F, + 0x0E, 0x1F, 0xEA, 0x60, 0xBF, 0x54, 0x14, 0x02, + 0x64, 0x8A, 0x76, 0x07, 0x61, 0xB6, 0x58, 0x61, + 0xE2, 0x89, 0x1E, 0x1B, 0x37, 0x3C, 0x4D, 0xE0 + }, + { + 0x36, 0x77, 0x21, 0xF5, 0x17, 0x87, 0x34, 0x79, + 0xFA, 0xBA, 0xB9, 0x3B, 0x02, 0xF0, 0x4C, 0x73, + 0xB3, 0xDC, 0x16, 0xA9, 0x85, 0x92, 0x21, 0x31, + 0x51, 0xF8, 0x66, 0xCF, 0x8D, 0xF8, 0x23, 0x6A, + 0x96, 0xDF, 0x76, 0x7A, 0x9F, 0x9F, 0x39, 0x27, + 0x8C, 0x1E, 0xF9, 0x40, 0xA8, 0xC5, 0xB3, 0xC0, + 0xD6, 0xB6, 0x88, 0x03, 0x4C, 0xD7, 0xD2, 0x3F, + 0x1A, 0x7F, 0x31, 0x87, 0x73, 0x66, 0x0F, 0x68 + }, + { + 0xA7, 0xA8, 0x18, 0xCE, 0x44, 0xC4, 0x0C, 0xE7, + 0x92, 0x22, 0x81, 0x0E, 0x45, 0x3D, 0x48, 0xEF, + 0xB9, 0x41, 0x97, 0xE4, 0x14, 0x0C, 0x6A, 0x37, + 0xF3, 0x2F, 0xB9, 0x9B, 0x7C, 0xE0, 0xF8, 0xC3, + 0x49, 0xAF, 0x0B, 0xF3, 0x38, 0xF9, 0xBA, 0x8C, + 0xE2, 0xC9, 0xD0, 0x4A, 0x2A, 0x54, 0x42, 0xA2, + 0x64, 0xA1, 0xC3, 0xA0, 0xBD, 0x8E, 0x62, 0xC5, + 0xFD, 0xBB, 0xFC, 0x85, 0xAA, 0x5F, 0xCB, 0xD5 + }, + { + 0x68, 0xC2, 0xBA, 0x94, 0x1D, 0x90, 0x06, 0xFD, + 0xB9, 0xF7, 0xED, 0xD7, 0xC8, 0x21, 0x63, 0x48, + 0x14, 0x1A, 0xF1, 0xB2, 0xC0, 0x56, 0x94, 0xFE, + 0xB2, 0x4F, 0x79, 0xF9, 0x6E, 0x68, 0x28, 0x54, + 0x65, 0x51, 0x57, 0xD2, 0x2E, 0xF4, 0x47, 0x8A, + 0x16, 0xCD, 0x19, 0x88, 0x4F, 0x69, 0x77, 0x62, + 0x94, 0x56, 0xD2, 0x28, 0x90, 0xD3, 0xD8, 0x71, + 0x5F, 0x3F, 0x85, 0x5B, 0x0F, 0x56, 0xE7, 0xF3 + }, + { + 0x9D, 0x46, 0x70, 0xCA, 0xF9, 0x82, 0x94, 0x51, + 0x6C, 0x6A, 0x10, 0x2B, 0xB7, 0x66, 0xA2, 0xD0, + 0x27, 0xB5, 0x89, 0x5A, 0xF0, 0x8B, 0x95, 0xAF, + 0xF7, 0xEE, 0x36, 0x42, 0x00, 0xF6, 0xA6, 0xFA, + 0x34, 0x36, 0x90, 0xF1, 0x22, 0x0B, 0xE2, 0x93, + 0xF3, 0x09, 0xA6, 0xA4, 0x98, 0x79, 0xAA, 0x25, + 0x16, 0x48, 0xB0, 0x26, 0x2A, 0x2A, 0x2C, 0x3A, + 0x9E, 0xFB, 0x38, 0x4F, 0xF7, 0x96, 0x1F, 0xB2 + }, + { + 0x49, 0x1B, 0xBE, 0x54, 0x1D, 0x7C, 0x23, 0x0F, + 0xC5, 0x6D, 0x0D, 0x30, 0x08, 0x74, 0x3D, 0x35, + 0x8A, 0xEB, 0xDA, 0x97, 0xDA, 0x75, 0x76, 0xC9, + 0x5B, 0x03, 0x3D, 0x3C, 0xC5, 0xBB, 0x8E, 0x69, + 0x53, 0x09, 0x00, 0x1F, 0x56, 0x84, 0xC0, 0xE4, + 0xD3, 0x5A, 0x8A, 0x05, 0xE4, 0x2B, 0xE0, 0x5B, + 0xA7, 0x2C, 0x94, 0xE7, 0x82, 0x68, 0x95, 0x81, + 0x93, 0x3D, 0x64, 0x43, 0xC5, 0x22, 0xAD, 0x35 + }, + { + 0x52, 0x74, 0xBA, 0x74, 0xFE, 0x8C, 0xA8, 0x4E, + 0xD2, 0xAD, 0x30, 0x9A, 0xEE, 0xA6, 0x67, 0xA0, + 0x6F, 0x6F, 0xF6, 0x3E, 0x4E, 0x24, 0xC8, 0x89, + 0xEE, 0xF8, 0xF9, 0x76, 0x37, 0xB2, 0xB2, 0x21, + 0x2A, 0x1B, 0xFB, 0x31, 0xC8, 0xCD, 0x52, 0xE5, + 0x7D, 0x17, 0x48, 0xEE, 0x02, 0xAC, 0xC8, 0xDB, + 0x78, 0xF5, 0xF7, 0x36, 0x69, 0x9C, 0x94, 0x2A, + 0xE0, 0x18, 0x0D, 0xDB, 0xB5, 0x92, 0xB5, 0x8C + }, + { + 0xB9, 0x41, 0x8E, 0x8A, 0xDB, 0xB2, 0xE7, 0x11, + 0x54, 0x3E, 0xBB, 0x93, 0x16, 0xF5, 0xCD, 0x94, + 0x6C, 0x68, 0x37, 0x58, 0x50, 0x9C, 0x75, 0xA0, + 0x54, 0x70, 0x51, 0x37, 0x08, 0x42, 0xE9, 0xA0, + 0x84, 0x45, 0x9E, 0x4C, 0xC7, 0x3B, 0x35, 0x0F, + 0xE6, 0x92, 0xCC, 0x15, 0x51, 0x75, 0x4E, 0xB6, + 0xB7, 0x5E, 0x85, 0xF3, 0x79, 0x5C, 0x07, 0x02, + 0xD3, 0x92, 0xED, 0xAC, 0x50, 0x91, 0x6C, 0x37 + }, + { + 0x7C, 0xAF, 0x96, 0xB0, 0xC3, 0xAA, 0xD3, 0x1F, + 0xEE, 0x5E, 0x8F, 0x6F, 0x9F, 0x4B, 0xA9, 0x3C, + 0x4B, 0x30, 0x34, 0xB9, 0xF7, 0xEE, 0x86, 0x52, + 0xFC, 0x07, 0xF6, 0x38, 0x34, 0x1A, 0xB8, 0xD4, + 0x02, 0x48, 0x88, 0x37, 0xC0, 0xE3, 0xBE, 0xC5, + 0x6C, 0x41, 0x0F, 0xC7, 0x46, 0x26, 0x2C, 0xF7, + 0x11, 0x43, 0xA0, 0xD9, 0xE1, 0x0B, 0x31, 0xFD, + 0xA5, 0x45, 0x37, 0x24, 0xF4, 0x11, 0xC3, 0x2A + }, + { + 0x5E, 0x05, 0x43, 0x7A, 0x1F, 0xBF, 0xFF, 0x88, + 0xB6, 0x15, 0x65, 0x28, 0xA9, 0x07, 0xC8, 0xFD, + 0x79, 0x6E, 0x7C, 0x3C, 0x42, 0x0F, 0x5A, 0x0C, + 0x2A, 0x84, 0x52, 0x82, 0x01, 0xEF, 0x3D, 0x12, + 0xD7, 0xF7, 0x72, 0x1A, 0x36, 0x95, 0x9A, 0x93, + 0x08, 0x84, 0xA5, 0xAA, 0x19, 0x61, 0xBB, 0x7C, + 0x09, 0xC9, 0x07, 0x56, 0x81, 0x6C, 0x3C, 0x4F, + 0x77, 0x61, 0x60, 0x72, 0x8F, 0xFE, 0xC9, 0xDB + }, + { + 0x26, 0x07, 0x6C, 0x88, 0xDB, 0x0F, 0xB3, 0x33, + 0xD7, 0x31, 0x2E, 0x64, 0xBD, 0x95, 0x68, 0x94, + 0x8B, 0xD0, 0x5E, 0x2D, 0x51, 0x76, 0x8A, 0x5A, + 0x1F, 0xA6, 0x0F, 0xD1, 0x94, 0x81, 0x07, 0xCE, + 0x4D, 0x1E, 0x77, 0x9C, 0x92, 0xEF, 0x4E, 0x25, + 0x1D, 0xBA, 0x73, 0xE4, 0x96, 0x79, 0xF3, 0xA2, + 0xF7, 0xF7, 0x0B, 0x5E, 0x43, 0x0D, 0x53, 0x39, + 0x3D, 0xF0, 0xA8, 0x25, 0x0A, 0x8D, 0xF1, 0xD2 + }, + { + 0x36, 0x25, 0x44, 0x85, 0x46, 0x10, 0x00, 0x35, + 0x69, 0xC7, 0x54, 0xBD, 0x2A, 0xD7, 0x44, 0x56, + 0xD4, 0xF5, 0xA9, 0x79, 0x87, 0xAF, 0x2B, 0x76, + 0x34, 0xBA, 0x3D, 0x2E, 0x91, 0xDB, 0xC1, 0x3C, + 0x60, 0x2E, 0x64, 0x49, 0x13, 0xB3, 0x0F, 0x48, + 0xCD, 0x57, 0x69, 0xEE, 0x57, 0x34, 0x31, 0x5A, + 0xAF, 0xCF, 0xAF, 0x39, 0x9D, 0x43, 0xA0, 0xD5, + 0x15, 0x02, 0xD9, 0x93, 0x6B, 0x1B, 0x11, 0x31 + }, + { + 0x5D, 0x8B, 0x21, 0x95, 0xD4, 0xC6, 0xE7, 0xA8, + 0x9A, 0x25, 0xFA, 0xA1, 0xB4, 0x84, 0x39, 0x51, + 0xAB, 0xDA, 0x71, 0xA4, 0x8C, 0xF0, 0x02, 0xA4, + 0x65, 0xB9, 0x2A, 0x48, 0x0D, 0xF8, 0xA9, 0xD6, + 0x22, 0xD8, 0x75, 0x11, 0x51, 0xC5, 0xBD, 0x48, + 0xBB, 0x67, 0xBE, 0x5E, 0xB0, 0xA7, 0x6B, 0xCF, + 0x6A, 0x65, 0xF5, 0xA6, 0x03, 0x65, 0x46, 0x18, + 0x09, 0xBB, 0x44, 0xB1, 0x3B, 0x5D, 0x12, 0x1B + }, + { + 0x70, 0x28, 0x14, 0x1D, 0xFF, 0x80, 0x41, 0xAC, + 0xF5, 0x94, 0x06, 0x35, 0x8F, 0x45, 0x45, 0x05, + 0x74, 0xD2, 0x1F, 0xD2, 0x4D, 0xF3, 0x39, 0x2E, + 0x95, 0xAD, 0xAF, 0x02, 0x96, 0x71, 0xC9, 0x51, + 0xDD, 0x8F, 0x0C, 0x35, 0x1F, 0x3F, 0x82, 0xB9, + 0xD5, 0xA1, 0x60, 0x4B, 0x61, 0x68, 0x3D, 0x3B, + 0x4B, 0x3F, 0x71, 0x85, 0xD3, 0x95, 0xC1, 0xE1, + 0xF7, 0x77, 0xAE, 0x96, 0xF4, 0x28, 0xF7, 0x78 + }, + { + 0xC7, 0x00, 0x3F, 0x3D, 0x3C, 0x77, 0xB0, 0xD9, + 0xB2, 0x78, 0xAD, 0xD0, 0x65, 0x58, 0x33, 0xDA, + 0x04, 0x8B, 0x8C, 0x7A, 0x27, 0xC7, 0x82, 0xC8, + 0x18, 0x13, 0x4A, 0x94, 0x23, 0x0F, 0x2E, 0x8B, + 0x1C, 0x61, 0x02, 0x40, 0xF8, 0x0D, 0x19, 0xDA, + 0x5F, 0x7E, 0xED, 0x25, 0xA4, 0x74, 0x36, 0x7B, + 0xEA, 0x46, 0x8C, 0xE4, 0xE2, 0x20, 0x86, 0x53, + 0x8A, 0xB5, 0xB5, 0x20, 0x44, 0x9C, 0x5E, 0xE3 + }, + { + 0x5B, 0x64, 0xA1, 0x87, 0xFC, 0xD2, 0x18, 0xF0, + 0x9A, 0x9D, 0x0F, 0xAD, 0x61, 0x5E, 0xC1, 0x05, + 0x83, 0x79, 0xB4, 0xFC, 0x1C, 0xD2, 0x7F, 0xD3, + 0xBC, 0xBE, 0xB8, 0xEF, 0x9B, 0x2E, 0xB1, 0x4F, + 0xA2, 0x67, 0x23, 0xF2, 0x2C, 0x6D, 0x9E, 0x47, + 0xCF, 0x14, 0x78, 0x84, 0x58, 0x97, 0x68, 0x2F, + 0x44, 0xFB, 0x26, 0x31, 0xE7, 0x8B, 0x6D, 0x65, + 0xD5, 0x17, 0x08, 0xE6, 0xE4, 0x04, 0x6F, 0xBA + }, + { + 0x9D, 0x6A, 0x59, 0xFB, 0x2C, 0x71, 0x20, 0xD1, + 0x59, 0xE1, 0xAA, 0x0C, 0x65, 0xFA, 0xE7, 0x4E, + 0x23, 0x65, 0xBE, 0x26, 0xBF, 0xB3, 0x85, 0xD2, + 0x6D, 0x7B, 0xB3, 0xAF, 0x66, 0xB5, 0x5D, 0x6E, + 0x56, 0x02, 0x08, 0xDE, 0x81, 0x55, 0x79, 0xF4, + 0x72, 0xBF, 0x03, 0x0F, 0x0E, 0x09, 0xB7, 0x7A, + 0x66, 0x9B, 0xBC, 0x1C, 0x98, 0x31, 0xD4, 0x19, + 0x90, 0xE2, 0x3D, 0xC3, 0x95, 0x84, 0xF1, 0xE1 + }, + { + 0xAA, 0xEF, 0x8E, 0xF7, 0x1D, 0xDB, 0xBB, 0x81, + 0x7C, 0xF7, 0x79, 0x92, 0x4F, 0x2E, 0x3F, 0x84, + 0x26, 0x5E, 0xB3, 0x3F, 0x09, 0x60, 0x9F, 0x95, + 0x38, 0xF0, 0x83, 0xDC, 0x0E, 0x1A, 0xFB, 0x20, + 0x93, 0x73, 0x1A, 0x10, 0x44, 0x3F, 0x10, 0xB6, + 0xE7, 0x1D, 0xB2, 0x37, 0x4C, 0xE4, 0x2E, 0xF2, + 0x59, 0xC2, 0xA6, 0xE5, 0x73, 0x55, 0xE6, 0x3D, + 0xA3, 0x3F, 0x92, 0x08, 0xFE, 0x4C, 0xEA, 0xC4 + }, + { + 0x40, 0x77, 0x6B, 0x80, 0x18, 0xAA, 0xB6, 0xA1, + 0x84, 0xD0, 0xA2, 0xED, 0x80, 0x60, 0x64, 0x74, + 0x11, 0x68, 0x6C, 0xF9, 0x1F, 0x11, 0x1A, 0xB2, + 0x20, 0x30, 0xE5, 0x01, 0x02, 0x5C, 0x11, 0xA3, + 0x5A, 0x83, 0x5A, 0xAE, 0x1F, 0x24, 0xFA, 0xFB, + 0x4C, 0x52, 0x78, 0xBD, 0x31, 0x44, 0x9E, 0xC8, + 0x6D, 0xD3, 0xEF, 0x0E, 0xBE, 0x02, 0x88, 0x58, + 0x69, 0x8C, 0x35, 0xBE, 0x48, 0xEB, 0x62, 0xAE + }, + { + 0xEB, 0xC0, 0x06, 0x80, 0x15, 0x77, 0xC8, 0x2A, + 0xD0, 0xAD, 0xE0, 0xF9, 0x38, 0xF7, 0x60, 0x57, + 0x3B, 0xE9, 0x98, 0xD3, 0xA3, 0xDC, 0x21, 0x09, + 0xFF, 0xE5, 0x36, 0xE2, 0x71, 0x9A, 0xC6, 0x61, + 0x6B, 0x87, 0x73, 0xE9, 0xD0, 0xE8, 0x5E, 0x63, + 0x2A, 0x99, 0x6C, 0x68, 0x42, 0xBD, 0xC3, 0x81, + 0x11, 0xE4, 0xCF, 0xBA, 0x19, 0xF7, 0xA6, 0x9E, + 0xE1, 0xEA, 0x54, 0xAD, 0x7C, 0xEF, 0xD3, 0x01 + }, + { + 0x96, 0xF4, 0x76, 0x47, 0xAC, 0xD7, 0x73, 0xB1, + 0xBE, 0xAA, 0x36, 0x9A, 0xCF, 0x7E, 0x69, 0xEC, + 0xDB, 0xD1, 0xCB, 0x89, 0x9E, 0x9E, 0xDE, 0x3A, + 0xE9, 0x01, 0x60, 0x3D, 0xBC, 0xCA, 0x48, 0xA6, + 0x5A, 0xF2, 0xFE, 0xFE, 0xFC, 0x7F, 0x4B, 0x0A, + 0x8C, 0x6F, 0x78, 0x3B, 0xDD, 0x5E, 0x19, 0x11, + 0x32, 0x38, 0x4E, 0x7B, 0xA9, 0xE0, 0x3B, 0x20, + 0x65, 0xAF, 0x0E, 0x45, 0x12, 0x5E, 0x75, 0x50 + }, + { + 0x55, 0x31, 0x38, 0xB0, 0x3C, 0x10, 0xBA, 0x81, + 0x89, 0x25, 0x7D, 0xC1, 0x1A, 0x21, 0xD0, 0xFA, + 0x08, 0x91, 0xEC, 0xA0, 0xC5, 0xDC, 0xAF, 0xD7, + 0x3B, 0x79, 0x92, 0xD3, 0x73, 0xE8, 0x19, 0xAC, + 0x96, 0x51, 0xDE, 0x64, 0x48, 0x8A, 0x00, 0x73, + 0xDA, 0x45, 0xED, 0x78, 0xD2, 0x8F, 0xF2, 0x9B, + 0xBD, 0x0F, 0x3E, 0xB6, 0x03, 0x30, 0x3E, 0xF0, + 0x60, 0xA5, 0xDC, 0x59, 0xCF, 0xFB, 0x1F, 0xC9 + }, + { + 0x1B, 0xC7, 0x24, 0x4A, 0xBE, 0xF2, 0x0B, 0x10, + 0xA1, 0x78, 0xE3, 0xB6, 0xB7, 0xAE, 0x0D, 0xC5, + 0x63, 0xA3, 0x62, 0xB7, 0x46, 0x9A, 0x02, 0x1E, + 0x03, 0x47, 0x73, 0xB5, 0x73, 0x23, 0xEE, 0xFE, + 0x36, 0x12, 0xD7, 0x69, 0x3C, 0xE6, 0xA5, 0xD2, + 0xC6, 0x0D, 0x68, 0x7C, 0x0A, 0xC3, 0xC9, 0x55, + 0x70, 0x44, 0xAC, 0x3B, 0x5F, 0x82, 0x89, 0x8D, + 0x2E, 0xEC, 0xB3, 0x70, 0x89, 0xF9, 0xEF, 0x92 + }, + { + 0x34, 0x05, 0xD7, 0xA5, 0x14, 0xCC, 0xFA, 0xB2, + 0x12, 0xFB, 0x20, 0xAE, 0xF1, 0x37, 0x68, 0x27, + 0xDC, 0x69, 0x54, 0xD7, 0x65, 0xC5, 0x5F, 0x5A, + 0x26, 0xF5, 0xA6, 0xA9, 0x47, 0x0F, 0xCD, 0x6E, + 0x28, 0x2C, 0xFE, 0xC9, 0x11, 0xC4, 0xA3, 0xF6, + 0x7A, 0x90, 0x26, 0xC3, 0xD0, 0x7D, 0x29, 0x51, + 0xF2, 0xD7, 0x9A, 0x54, 0xB7, 0xC3, 0x7B, 0xCF, + 0x39, 0xFF, 0xC0, 0xFE, 0xBD, 0xD5, 0x8F, 0x76 + }, + { + 0x3F, 0xB3, 0x78, 0xAB, 0x54, 0x90, 0x30, 0xC5, + 0xA4, 0x7C, 0x3E, 0xA8, 0x4E, 0x6B, 0xBF, 0xE6, + 0x0A, 0x3D, 0x67, 0xE3, 0x2D, 0x19, 0xE6, 0x32, + 0xC2, 0xE7, 0xA7, 0x88, 0x4A, 0x83, 0x85, 0x0C, + 0x32, 0xA4, 0x79, 0xC0, 0x61, 0xA3, 0xC8, 0x3B, + 0x6D, 0xCA, 0xB8, 0xC0, 0x73, 0x51, 0x84, 0x4B, + 0xF5, 0x9F, 0x6B, 0x69, 0x21, 0x53, 0x11, 0xBD, + 0x5D, 0x1E, 0x2F, 0x16, 0xBC, 0x0B, 0x71, 0x72 + }, + { + 0xDA, 0x2E, 0xED, 0x64, 0x94, 0x4C, 0x0F, 0xF8, + 0x09, 0x88, 0xBF, 0xF2, 0x4F, 0xBD, 0x1B, 0xFF, + 0xEB, 0x4E, 0xD9, 0xFD, 0x58, 0x63, 0x14, 0x46, + 0x4D, 0x81, 0xC7, 0x6D, 0x6C, 0x39, 0x04, 0xCE, + 0x29, 0x06, 0x0A, 0xC0, 0x38, 0xE4, 0x0B, 0x8B, + 0xF3, 0x70, 0x7D, 0x47, 0x3E, 0x37, 0x09, 0x08, + 0x63, 0x2A, 0x73, 0xEB, 0x0F, 0xBC, 0xB4, 0xE3, + 0xCE, 0xE4, 0x6A, 0x5E, 0x45, 0xAD, 0x3A, 0xF3 + }, + { + 0xD9, 0xCF, 0x59, 0x83, 0xDC, 0x6B, 0x34, 0xC0, + 0xFA, 0x1F, 0x02, 0x26, 0x92, 0x68, 0x55, 0xAD, + 0x3E, 0xCC, 0xD2, 0xBC, 0xDC, 0xD8, 0xF8, 0x05, + 0x3B, 0x9A, 0x80, 0x66, 0x4D, 0x33, 0xB5, 0xAF, + 0xCC, 0x32, 0xFD, 0x21, 0xC7, 0x0E, 0xA1, 0x4F, + 0x4E, 0xF5, 0x0C, 0xA9, 0x7C, 0x32, 0x03, 0xC4, + 0xD1, 0x80, 0x31, 0x59, 0xF0, 0xE0, 0x1B, 0xB6, + 0xCB, 0x1D, 0x1C, 0x83, 0xDB, 0x52, 0xB6, 0x3C + }, + { + 0xE3, 0x98, 0xB3, 0x71, 0x11, 0x7B, 0xB1, 0xE5, + 0x88, 0x74, 0x4A, 0x14, 0x04, 0x3E, 0x84, 0xB2, + 0x37, 0xFA, 0xAE, 0x0A, 0x4D, 0xE6, 0xA1, 0xE6, + 0x91, 0xB6, 0xEA, 0xDB, 0xE0, 0x00, 0x95, 0xBE, + 0xEE, 0x6A, 0x79, 0xB5, 0x68, 0x10, 0xCB, 0x34, + 0xBE, 0xFC, 0x73, 0x14, 0xD7, 0x1D, 0xA4, 0xA4, + 0x73, 0x84, 0x14, 0x1A, 0xF8, 0x14, 0x88, 0x12, + 0xBC, 0x71, 0xEB, 0x39, 0xC5, 0x91, 0xD3, 0xD2 + }, + { + 0x8E, 0x51, 0x93, 0xC2, 0x82, 0x74, 0xD1, 0xF5, + 0x2D, 0xBC, 0x08, 0x94, 0x3F, 0x77, 0xEA, 0xE6, + 0xDA, 0xF9, 0xE3, 0x73, 0x23, 0x0A, 0x5A, 0x09, + 0x5D, 0x2A, 0x08, 0x1E, 0x6E, 0x59, 0xC3, 0xE2, + 0xB9, 0xDE, 0x36, 0x95, 0x5B, 0xA2, 0x29, 0xFD, + 0x7C, 0xB4, 0x23, 0x21, 0xFA, 0x31, 0x74, 0x35, + 0x3A, 0x12, 0x8D, 0x08, 0xF9, 0xBB, 0x39, 0x49, + 0x71, 0x92, 0xA2, 0x65, 0xAF, 0x36, 0x82, 0x31 + }, + { + 0x9C, 0xBD, 0x8A, 0x32, 0x99, 0x38, 0x4A, 0x16, + 0xD6, 0xA3, 0x09, 0xAA, 0x50, 0x24, 0x9C, 0x65, + 0xF1, 0xC6, 0xDF, 0x3C, 0x1C, 0xC8, 0x13, 0xF5, + 0x84, 0x3C, 0xD3, 0x32, 0x77, 0xB2, 0xE7, 0x0F, + 0xF5, 0x92, 0xD0, 0x67, 0xDB, 0x51, 0xBB, 0x8D, + 0x7B, 0x33, 0xC6, 0x28, 0x0E, 0x61, 0x78, 0xF5, + 0x66, 0x60, 0xAA, 0xA3, 0x28, 0x12, 0xBB, 0x04, + 0x63, 0x6C, 0x06, 0x84, 0xB9, 0xDA, 0x28, 0x57 + }, + { + 0xE5, 0x7D, 0x57, 0xEB, 0x6F, 0xF1, 0x3F, 0x4B, + 0x09, 0x33, 0x32, 0x51, 0x9A, 0xB6, 0x03, 0x80, + 0x87, 0xF7, 0x56, 0x48, 0x63, 0x5F, 0xBE, 0x4C, + 0xC5, 0x37, 0xAD, 0x34, 0x34, 0x54, 0xDF, 0xB0, + 0xE3, 0x96, 0xAE, 0xAB, 0x0F, 0x90, 0x10, 0x0E, + 0xCC, 0x52, 0x20, 0x4F, 0x5B, 0x7A, 0x5B, 0xB8, + 0x12, 0xB6, 0x8B, 0xBA, 0x8C, 0xE8, 0x9E, 0x10, + 0xC3, 0x11, 0xFA, 0x6A, 0x7F, 0x33, 0x5F, 0x55 + }, + { + 0x6E, 0x54, 0x52, 0x4B, 0xC7, 0xC6, 0x0B, 0xA5, + 0xE4, 0x15, 0xA2, 0x75, 0x20, 0xB8, 0x7C, 0x92, + 0x3B, 0xD1, 0xA5, 0x95, 0xE9, 0x52, 0x26, 0x41, + 0x0B, 0x78, 0xB1, 0x33, 0x81, 0x49, 0xA0, 0x31, + 0x64, 0x2C, 0xD5, 0xCE, 0x0D, 0x46, 0x15, 0xCC, + 0x9D, 0x1F, 0x7A, 0x7E, 0x09, 0xA0, 0x41, 0x1C, + 0x03, 0xA3, 0x96, 0xE6, 0x94, 0x96, 0xE6, 0x94, + 0x42, 0x65, 0xE9, 0x0B, 0x14, 0xDB, 0x73, 0xF7 + }, + { + 0x71, 0x7F, 0x35, 0xBE, 0x61, 0xC0, 0x88, 0xBB, + 0x2D, 0xCA, 0x8C, 0x05, 0x73, 0xBA, 0xB4, 0xA4, + 0xC6, 0x2B, 0x9D, 0xAB, 0x98, 0x3F, 0x1D, 0x8B, + 0x97, 0xFB, 0x66, 0xE5, 0x08, 0x92, 0x5E, 0xA1, + 0x46, 0xBF, 0xA1, 0xA2, 0xEC, 0xDB, 0x51, 0xFB, + 0x70, 0xC6, 0x5A, 0x00, 0x82, 0x3F, 0x15, 0x0A, + 0xC6, 0x98, 0x44, 0x27, 0xCF, 0xC3, 0xC0, 0x5A, + 0x9C, 0xF6, 0x05, 0x14, 0x77, 0x4B, 0xC2, 0x69 + }, + { + 0x46, 0x60, 0x47, 0xC2, 0x39, 0x95, 0xB6, 0x77, + 0xFB, 0x4C, 0xCF, 0x5F, 0x3A, 0xC7, 0xAE, 0xC4, + 0x05, 0x56, 0xA5, 0x03, 0x36, 0x74, 0x64, 0xC9, + 0xCE, 0xAF, 0x5D, 0x36, 0xC5, 0x73, 0x64, 0x85, + 0xB7, 0x7E, 0x18, 0x31, 0x51, 0x29, 0xD4, 0xBD, + 0xFC, 0x17, 0xEA, 0x8E, 0xCA, 0xED, 0xD9, 0xF4, + 0xAB, 0x5D, 0x87, 0x8E, 0xB1, 0x87, 0x0C, 0xB9, + 0xDF, 0xB0, 0x51, 0x98, 0x31, 0x93, 0x84, 0xD1 + }, + { + 0x9C, 0x2B, 0x99, 0x91, 0xCF, 0x9D, 0x45, 0xC6, + 0x63, 0x21, 0x76, 0xBA, 0x88, 0x22, 0xBA, 0xBD, + 0xE5, 0xFE, 0x5E, 0xF7, 0xC8, 0xD3, 0x5F, 0xDB, + 0xAC, 0xBD, 0xAD, 0x15, 0x70, 0xB4, 0x6A, 0xBB, + 0x06, 0xF0, 0xE8, 0x53, 0xF2, 0xAE, 0x57, 0x9E, + 0x39, 0xEB, 0xEE, 0x89, 0x4D, 0xA3, 0x2B, 0x32, + 0x1B, 0x05, 0x50, 0x78, 0x20, 0x8D, 0xAD, 0x4E, + 0x8B, 0x3F, 0xB7, 0xAB, 0xFA, 0x64, 0xDC, 0x1D + }, + { + 0x10, 0xF1, 0x4F, 0x9C, 0xD2, 0xD0, 0x24, 0x2B, + 0x30, 0x76, 0x8C, 0xE2, 0x1A, 0x74, 0xC4, 0x20, + 0x25, 0xA3, 0x40, 0x09, 0x0F, 0x49, 0x3B, 0x16, + 0x08, 0x14, 0xE7, 0x59, 0x33, 0xE3, 0x3A, 0x81, + 0xDB, 0x04, 0x82, 0xCE, 0x6F, 0x63, 0x20, 0xD0, + 0x6F, 0x59, 0x7A, 0xB9, 0xF2, 0xEC, 0x4C, 0xEF, + 0x85, 0xC7, 0x34, 0x64, 0x77, 0x12, 0x9D, 0x1B, + 0x9B, 0x5E, 0xA1, 0x80, 0x4F, 0xB7, 0xCB, 0x82 + }, + { + 0xFB, 0x06, 0xAC, 0x2E, 0x05, 0x80, 0x07, 0x44, + 0x1E, 0x75, 0x94, 0xEC, 0xC8, 0x01, 0x3A, 0x30, + 0x47, 0x8A, 0xCB, 0x84, 0xED, 0xAD, 0xD2, 0x01, + 0x2F, 0x60, 0xC9, 0x5A, 0xBB, 0x56, 0x0F, 0x71, + 0x8F, 0x23, 0xB5, 0xC2, 0xCC, 0x1B, 0x06, 0xDF, + 0xEC, 0x24, 0x64, 0xE0, 0x5A, 0xF6, 0xE6, 0xFF, + 0x35, 0xE2, 0x0C, 0x63, 0x7E, 0xCD, 0x1C, 0xDE, + 0x00, 0xC8, 0x26, 0xBC, 0x52, 0xF8, 0xEB, 0xFF + }, + { + 0x04, 0x3B, 0x10, 0x53, 0x82, 0xDA, 0x76, 0x88, + 0x5A, 0xF3, 0x64, 0x1B, 0x98, 0xAA, 0xC9, 0x5C, + 0xA7, 0xBF, 0xB8, 0xC4, 0xC5, 0x4A, 0xAD, 0x4F, + 0x44, 0xCC, 0x19, 0x46, 0x4D, 0x97, 0xAB, 0xDB, + 0x60, 0x58, 0x5F, 0xB7, 0x67, 0xB0, 0x61, 0x37, + 0xAB, 0x49, 0x62, 0xFE, 0x5F, 0x00, 0x7A, 0x60, + 0xE4, 0x1D, 0xD8, 0x98, 0xB0, 0xE1, 0xD9, 0x47, + 0x88, 0x86, 0x49, 0xF5, 0xAB, 0xCB, 0xB2, 0x08 + }, + { + 0xA3, 0x0C, 0x56, 0xDE, 0x03, 0xC1, 0xBB, 0x2E, + 0xAA, 0xBD, 0x7A, 0xC3, 0xDE, 0x12, 0x85, 0x2E, + 0x66, 0x03, 0x23, 0x9E, 0x05, 0xE9, 0x21, 0x5D, + 0x8A, 0x2B, 0x60, 0xD9, 0xFA, 0xA4, 0x60, 0xF6, + 0x79, 0x30, 0x65, 0x7B, 0x00, 0xC1, 0x04, 0x78, + 0x69, 0x71, 0x20, 0x71, 0x2C, 0x2D, 0x75, 0x58, + 0x9A, 0xB1, 0x5A, 0x78, 0x63, 0x4A, 0x7A, 0x48, + 0x93, 0x03, 0x8E, 0x28, 0xBB, 0x92, 0x53, 0x38 + }, + { + 0xF8, 0xD7, 0x8F, 0xDF, 0xFF, 0x92, 0x6E, 0x05, + 0x36, 0x4C, 0x52, 0xF0, 0xF8, 0xCB, 0xD8, 0x44, + 0x15, 0x44, 0x1B, 0xE8, 0x93, 0xB3, 0x34, 0x4E, + 0x3F, 0x0E, 0x7E, 0x8B, 0x12, 0x3B, 0x9F, 0x16, + 0x6A, 0x3F, 0x40, 0xED, 0xB4, 0x65, 0xFA, 0x92, + 0x5B, 0x57, 0x0E, 0x43, 0x6F, 0xEC, 0xC8, 0x4A, + 0x19, 0x75, 0x0B, 0xBF, 0xB0, 0xBA, 0x1E, 0x09, + 0x7F, 0x7C, 0xCE, 0x3F, 0x36, 0xB1, 0xB8, 0x44 + }, + { + 0x40, 0x68, 0x7F, 0x43, 0x81, 0x57, 0x02, 0xDE, + 0x57, 0xDE, 0x97, 0x8B, 0x4B, 0x5A, 0x12, 0x85, + 0x5A, 0xD1, 0xD3, 0xD3, 0x04, 0xCC, 0xB1, 0x6F, + 0x22, 0x3B, 0xAB, 0x3A, 0x68, 0xD4, 0x55, 0xFB, + 0xF1, 0x7C, 0xC6, 0x79, 0x56, 0x68, 0xC0, 0x02, + 0x3D, 0x0A, 0xD0, 0x10, 0xFD, 0x2A, 0x33, 0x6A, + 0xC5, 0x1A, 0x8D, 0x2A, 0x2D, 0x2E, 0x00, 0xD9, + 0xB6, 0xBD, 0xB4, 0x16, 0x24, 0xED, 0x02, 0x36 + }, + { + 0x56, 0x40, 0x29, 0xCE, 0xEE, 0xB6, 0xD3, 0x39, + 0x1D, 0x21, 0x3C, 0xB4, 0x61, 0x25, 0x82, 0x7F, + 0x4C, 0xD1, 0xAE, 0xBD, 0xBE, 0xA4, 0x10, 0x49, + 0xFE, 0x61, 0x89, 0xBB, 0xFD, 0x31, 0xF4, 0x44, + 0x6E, 0x84, 0x43, 0x46, 0xD8, 0xA5, 0xC8, 0xA1, + 0xD1, 0x9F, 0x8D, 0xA0, 0xA1, 0xC4, 0x5B, 0x23, + 0xC4, 0xDA, 0x89, 0xE1, 0xF2, 0xD0, 0x6B, 0x8D, + 0x6C, 0x40, 0xEC, 0x45, 0x27, 0xC8, 0xE3, 0xD1 + }, + { + 0xB5, 0x62, 0x97, 0x78, 0x05, 0x0B, 0x76, 0x2F, + 0x91, 0xC7, 0x49, 0x93, 0xDB, 0xD7, 0xCA, 0x03, + 0x26, 0x88, 0xBF, 0x17, 0x0D, 0x8D, 0x35, 0xD3, + 0x4C, 0xAA, 0x98, 0x6F, 0x7D, 0x10, 0xCE, 0xFD, + 0x3D, 0xA5, 0x73, 0x51, 0x46, 0x71, 0xDB, 0x69, + 0xD9, 0x18, 0x15, 0xD1, 0xE8, 0xFE, 0xAC, 0xCA, + 0x06, 0x6D, 0x09, 0x76, 0x12, 0xBC, 0xA8, 0x17, + 0xDA, 0x13, 0x96, 0xE1, 0x83, 0xFD, 0xEE, 0x7F + }, + { + 0xE6, 0xF7, 0xB7, 0xF6, 0xA0, 0xC4, 0x3A, 0x40, + 0x87, 0x7B, 0xC4, 0xE3, 0x4E, 0xD2, 0x01, 0x27, + 0x1D, 0x1D, 0xCA, 0x7A, 0xFF, 0x79, 0x42, 0xBC, + 0xE4, 0x65, 0x57, 0x43, 0x0B, 0x91, 0x49, 0x9E, + 0xE0, 0xD7, 0x83, 0xF5, 0xDF, 0x7C, 0xF2, 0xCE, + 0x74, 0xDD, 0xF5, 0x43, 0x72, 0x08, 0xF9, 0x95, + 0xCE, 0xCE, 0xEA, 0x69, 0x34, 0x84, 0xF0, 0xD2, + 0x98, 0x18, 0xB9, 0x0D, 0xBF, 0xCF, 0x61, 0x00 + }, + { + 0x7F, 0xA3, 0x1D, 0x90, 0xD8, 0x55, 0x11, 0xF6, + 0xF9, 0x15, 0xB9, 0xC2, 0x13, 0x38, 0xA2, 0x7A, + 0x08, 0x80, 0x78, 0x72, 0x11, 0xDC, 0xDD, 0x7E, + 0x87, 0x8F, 0x55, 0x15, 0x88, 0xA5, 0x8A, 0x7D, + 0xBE, 0x0F, 0xDA, 0x1E, 0x87, 0x00, 0xF1, 0x54, + 0x7E, 0x11, 0x1A, 0x43, 0xB0, 0x80, 0x65, 0x1C, + 0x87, 0x25, 0x66, 0x48, 0xD7, 0xCC, 0x85, 0x34, + 0xBE, 0x90, 0x19, 0xE1, 0x65, 0xFD, 0x65, 0x31 + }, + { + 0x9A, 0x22, 0x45, 0xF4, 0xCE, 0x57, 0x93, 0x78, + 0x8A, 0x37, 0xA6, 0x47, 0x67, 0x4E, 0x17, 0x69, + 0x51, 0xCB, 0xA0, 0xB5, 0x85, 0xD5, 0xFA, 0x1B, + 0xC3, 0x61, 0xA4, 0x0F, 0xEF, 0x6F, 0x4D, 0x23, + 0xC4, 0xFC, 0xEA, 0xB3, 0x7E, 0x94, 0x7E, 0x94, + 0x1B, 0x34, 0x53, 0x29, 0xB8, 0xB3, 0xB7, 0x32, + 0x0E, 0x86, 0x64, 0xBC, 0x96, 0x5D, 0x17, 0x51, + 0xDD, 0x7E, 0xBE, 0x21, 0x4B, 0xCB, 0x62, 0x53 + }, + { + 0xD9, 0x9D, 0x20, 0x26, 0xC7, 0xA4, 0xEA, 0xAE, + 0x09, 0xCE, 0xA4, 0xCD, 0x26, 0x4B, 0x4C, 0xC9, + 0xD4, 0x11, 0x61, 0xDC, 0x01, 0x79, 0x52, 0xF4, + 0xEA, 0xAF, 0x0A, 0x5F, 0x20, 0x51, 0xD8, 0xF0, + 0xDC, 0x5E, 0x34, 0x89, 0x41, 0x7E, 0x22, 0x89, + 0x52, 0x56, 0x34, 0x6D, 0xBA, 0x33, 0x27, 0xCD, + 0x82, 0xBF, 0x7B, 0x33, 0xFF, 0x67, 0x3C, 0x6D, + 0x44, 0x13, 0x5A, 0xD4, 0xFC, 0x6C, 0xBE, 0x3F + }, + { + 0x3D, 0xD7, 0xFF, 0xA0, 0xF2, 0xC7, 0x0F, 0xEC, + 0x9E, 0xA2, 0x97, 0x5A, 0x30, 0x56, 0x1B, 0xBC, + 0x02, 0x06, 0xCD, 0x2E, 0x69, 0xD2, 0x4E, 0x5E, + 0x84, 0xF1, 0xA2, 0x01, 0x5F, 0x7C, 0x46, 0xFC, + 0x3B, 0x3E, 0x10, 0x5E, 0xF7, 0xB3, 0x38, 0x42, + 0x04, 0x7F, 0xAA, 0x8C, 0xD1, 0xA8, 0xBD, 0x46, + 0x77, 0x2C, 0x7C, 0x46, 0x1A, 0x16, 0x35, 0x96, + 0xB0, 0x8F, 0x9D, 0x5B, 0x48, 0x7E, 0x77, 0x22 + }, + { + 0x9C, 0xFB, 0x27, 0x25, 0x68, 0x2E, 0xD1, 0xA1, + 0x36, 0x4B, 0xD7, 0x3C, 0x28, 0xAF, 0xD9, 0x26, + 0x1C, 0x31, 0x26, 0x82, 0x22, 0xED, 0xA9, 0xE6, + 0xCA, 0x0A, 0xD3, 0x54, 0x9C, 0x38, 0x0C, 0x81, + 0xD6, 0x4B, 0x59, 0x7D, 0xDC, 0x77, 0xF6, 0xF0, + 0x1B, 0xEA, 0xD0, 0x13, 0x2F, 0x7A, 0xE9, 0x28, + 0x24, 0x2A, 0x60, 0x85, 0x48, 0x70, 0x69, 0xD3, + 0x66, 0xE4, 0x8C, 0xC8, 0x32, 0x78, 0xB8, 0x0A + }, + { + 0x79, 0x4D, 0x48, 0xD6, 0x2B, 0xA9, 0xF1, 0xB9, + 0x63, 0x95, 0x5F, 0x1F, 0x9E, 0x56, 0xBD, 0x93, + 0x0F, 0x7B, 0xD3, 0xEC, 0x7B, 0x59, 0xC5, 0xB3, + 0x01, 0xB7, 0x8F, 0x99, 0xF0, 0x12, 0x95, 0x24, + 0xEB, 0x58, 0xCA, 0xAE, 0x06, 0x02, 0x89, 0x52, + 0x10, 0x43, 0x29, 0x30, 0xDC, 0xE9, 0x1A, 0x60, + 0xCE, 0x87, 0x75, 0xFD, 0xC6, 0x7F, 0x59, 0x18, + 0x18, 0x0B, 0xFB, 0x00, 0x3F, 0x74, 0xBE, 0xA6 + }, + { + 0xAE, 0x8E, 0x9B, 0x8E, 0xD2, 0x34, 0x3B, 0x2B, + 0xC6, 0x55, 0x8D, 0x53, 0x39, 0xA1, 0x8C, 0x61, + 0xE5, 0x61, 0x77, 0x05, 0xF0, 0xAC, 0x46, 0x2D, + 0x3E, 0x77, 0x42, 0x3D, 0x21, 0x85, 0x18, 0xE6, + 0xDB, 0x09, 0xC4, 0x20, 0x55, 0x64, 0x59, 0x53, + 0x20, 0x5B, 0x00, 0x79, 0x32, 0xBB, 0x39, 0xE6, + 0x2D, 0x2E, 0xF1, 0x42, 0xFE, 0xDF, 0xD9, 0x9A, + 0xB9, 0xCC, 0x77, 0xC3, 0x8F, 0x20, 0x76, 0x2D + }, + { + 0x4C, 0x66, 0xF2, 0x3E, 0x87, 0xAC, 0x68, 0x40, + 0x1A, 0x17, 0xB0, 0xD6, 0x13, 0x34, 0x96, 0x34, + 0x47, 0x1A, 0xD2, 0x41, 0x33, 0x21, 0x40, 0x77, + 0x77, 0x64, 0x17, 0x3C, 0x10, 0x26, 0xA2, 0xA4, + 0x52, 0xEE, 0xAE, 0x14, 0xA5, 0xE3, 0x0C, 0xA1, + 0xD5, 0xC6, 0x33, 0x1E, 0x3A, 0x3D, 0xD2, 0xC2, + 0x47, 0xE2, 0x23, 0x36, 0x05, 0x75, 0x17, 0x2F, + 0x69, 0xCF, 0x31, 0xF6, 0x97, 0xD1, 0x02, 0x0F + }, + { + 0x6B, 0x6B, 0x0C, 0x2D, 0xBC, 0xB1, 0x31, 0xD7, + 0x39, 0x2F, 0x18, 0x99, 0x81, 0xE5, 0xB5, 0xC4, + 0x67, 0xCF, 0x8F, 0xD3, 0x08, 0x86, 0x59, 0x12, + 0xDD, 0x4F, 0x2E, 0x75, 0xD2, 0xDE, 0xC2, 0x87, + 0x1C, 0xD4, 0xEA, 0x2A, 0xEB, 0xE9, 0x37, 0xEB, + 0xF3, 0x5C, 0x18, 0x5E, 0x37, 0x2E, 0x71, 0xE1, + 0x4A, 0x44, 0xB2, 0x46, 0x75, 0xF3, 0x13, 0xAB, + 0xD3, 0x85, 0x52, 0x3B, 0x4B, 0x76, 0x00, 0x73 + }, + { + 0xD9, 0xC2, 0x46, 0xCF, 0x2E, 0x80, 0x95, 0x4A, + 0xF8, 0x92, 0xC2, 0x42, 0xAE, 0xC8, 0xE9, 0xDA, + 0xA4, 0xD4, 0x45, 0x85, 0x80, 0x6E, 0xEF, 0x8A, + 0xDC, 0x4C, 0x51, 0xF2, 0x3F, 0xB3, 0x1F, 0x53, + 0x44, 0xE3, 0x8B, 0xC1, 0x33, 0xB4, 0x6F, 0xD8, + 0x28, 0x5D, 0x36, 0x08, 0x61, 0x34, 0x37, 0x9D, + 0xB7, 0x45, 0x27, 0x5E, 0x1F, 0xBF, 0xD1, 0xF4, + 0x0F, 0x79, 0xF6, 0x2E, 0xE3, 0xDC, 0xD7, 0x22 + }, + { + 0x60, 0x20, 0x60, 0x6D, 0xDB, 0xE6, 0xA8, 0x2E, + 0xF7, 0x83, 0x81, 0x71, 0x8B, 0x11, 0x12, 0xFC, + 0xAB, 0xDE, 0xAD, 0xAE, 0x14, 0xBD, 0x12, 0x86, + 0xF8, 0x8C, 0x5E, 0xD1, 0x06, 0x01, 0x41, 0xE4, + 0xEE, 0x93, 0x23, 0x1E, 0x45, 0x5D, 0x54, 0x4F, + 0x1B, 0xC9, 0xCB, 0x73, 0xBF, 0x1E, 0x05, 0xA5, + 0x49, 0xC7, 0xFE, 0x23, 0xAB, 0xE1, 0xF8, 0xE6, + 0x4A, 0x8F, 0x8C, 0xE1, 0x39, 0x2F, 0xA4, 0x0E + }, + { + 0x4C, 0xE8, 0x36, 0x39, 0xA2, 0x90, 0x27, 0x58, + 0xE3, 0x7E, 0xAB, 0x2E, 0x2B, 0x6D, 0xDE, 0x86, + 0x41, 0x68, 0x01, 0x36, 0x5C, 0x49, 0x52, 0xE9, + 0xAA, 0xC8, 0xF1, 0x84, 0x48, 0x15, 0xCC, 0xA0, + 0x80, 0xDB, 0x17, 0xFC, 0x00, 0xAF, 0xE8, 0x85, + 0xE3, 0x82, 0x75, 0x4D, 0xF9, 0xAD, 0x4D, 0x42, + 0xA1, 0xC0, 0x12, 0x8C, 0x3D, 0x0F, 0x5F, 0xEC, + 0xE4, 0xBD, 0x83, 0xC5, 0xD3, 0x2A, 0xBA, 0xF6 + }, + { + 0x4D, 0x7F, 0xAB, 0x24, 0x23, 0x2C, 0x5A, 0xD2, + 0x2C, 0xF8, 0xFA, 0xF7, 0x91, 0xD7, 0xB4, 0x95, + 0xD9, 0x3D, 0x00, 0x10, 0x48, 0x6C, 0x57, 0xC1, + 0xEA, 0x73, 0xA7, 0xBA, 0x9F, 0xA2, 0xEA, 0x3E, + 0x0C, 0xEF, 0x5E, 0xAF, 0xAD, 0xBC, 0x84, 0x57, + 0xCE, 0x45, 0xF1, 0x3F, 0x12, 0xB0, 0xB9, 0xC3, + 0xAD, 0x0F, 0x24, 0x7F, 0x77, 0xF1, 0xF3, 0xE3, + 0x4A, 0x39, 0xF3, 0x66, 0x80, 0xA7, 0x1C, 0xE9 + }, + { + 0xF8, 0xD7, 0x76, 0x95, 0x56, 0x0A, 0x78, 0xD5, + 0x2E, 0x27, 0xA3, 0xD6, 0xBD, 0x60, 0x6C, 0x01, + 0xB2, 0x6B, 0x0E, 0x87, 0xB8, 0x4C, 0xC6, 0x05, + 0x1B, 0x7C, 0xA0, 0xB3, 0x39, 0xE7, 0x6D, 0x62, + 0x61, 0x73, 0x97, 0xBB, 0xFC, 0x2E, 0xBB, 0xB4, + 0x5A, 0x85, 0x76, 0x68, 0x22, 0x29, 0x8C, 0xC3, + 0xA1, 0x86, 0x29, 0x1D, 0x02, 0x1A, 0x60, 0x09, + 0x11, 0xCC, 0xE1, 0x54, 0x2A, 0x3D, 0x7F, 0xA3 + }, + { + 0xD2, 0x0C, 0xB8, 0x2A, 0x7C, 0x38, 0xBF, 0xB7, + 0xBC, 0x7B, 0x2D, 0x81, 0x69, 0x0A, 0x7B, 0xC7, + 0xDE, 0xE7, 0xE4, 0x5A, 0xC6, 0x23, 0x1E, 0xC8, + 0xBF, 0x57, 0xEE, 0x93, 0x24, 0x6B, 0x50, 0x6F, + 0xC6, 0xE7, 0xE5, 0xD7, 0x80, 0xAD, 0xE7, 0x9E, + 0xEF, 0x37, 0xE6, 0x0F, 0x14, 0x12, 0xCE, 0x71, + 0xD6, 0xFF, 0x62, 0x3B, 0xF3, 0x7B, 0xE9, 0xC5, + 0x2D, 0x65, 0xA9, 0x87, 0x5D, 0x4A, 0x64, 0x6A + }, + { + 0x80, 0x62, 0xE9, 0x23, 0x54, 0xBD, 0x8D, 0xB6, + 0xFC, 0x13, 0xFA, 0x29, 0x8A, 0x7A, 0xC9, 0xD1, + 0x6D, 0x71, 0x35, 0x81, 0xA0, 0xF5, 0x0E, 0x64, + 0x0F, 0xAC, 0xCB, 0x5F, 0x93, 0xC5, 0x6F, 0x4D, + 0x0F, 0xCC, 0x9F, 0x87, 0x85, 0x6C, 0xD9, 0x15, + 0x1A, 0x32, 0xE5, 0xBC, 0x5C, 0xF6, 0x61, 0xCE, + 0xF0, 0xFB, 0x7A, 0x2B, 0xE5, 0x9E, 0x9D, 0x09, + 0x4E, 0xF1, 0xC9, 0x46, 0x4E, 0x1E, 0x69, 0x38 + }, + { + 0x5B, 0xCC, 0x2F, 0x00, 0x52, 0xDB, 0xFC, 0x5E, + 0xFE, 0x8E, 0x8C, 0x7C, 0x8A, 0x45, 0xFD, 0xDF, + 0xE8, 0x86, 0x43, 0x84, 0x7D, 0xB4, 0x0A, 0x81, + 0x87, 0x56, 0x6C, 0xB9, 0xBC, 0x59, 0xD4, 0x73, + 0x53, 0x40, 0x0C, 0x1C, 0x3A, 0x31, 0x8F, 0x1A, + 0x5A, 0xCE, 0x47, 0xCB, 0x4E, 0xED, 0x54, 0x55, + 0x59, 0x28, 0xBA, 0x77, 0xDB, 0x38, 0x8D, 0x68, + 0x98, 0xEF, 0x45, 0xE1, 0x01, 0xB1, 0x80, 0x8C + }, + { + 0x88, 0x74, 0x85, 0x91, 0xA7, 0x2A, 0xAB, 0x29, + 0x2D, 0xC0, 0xD8, 0x3D, 0x76, 0x57, 0x01, 0x71, + 0x5C, 0xE6, 0x6A, 0xB7, 0x66, 0x08, 0xF5, 0xFF, + 0xA4, 0x6F, 0x5D, 0x49, 0x90, 0xDD, 0x4C, 0x65, + 0x60, 0xDC, 0xCC, 0x57, 0xCF, 0x87, 0x1B, 0x1F, + 0xDE, 0x91, 0xA9, 0x0F, 0x5D, 0x28, 0x56, 0xFA, + 0x27, 0x0D, 0x67, 0x2D, 0x1D, 0xB9, 0x9A, 0x91, + 0xF6, 0x10, 0xEB, 0x7C, 0x80, 0x01, 0xDF, 0xDB + }, + { + 0x4A, 0xD4, 0x03, 0x80, 0x14, 0xCC, 0x65, 0x72, + 0xB3, 0x5E, 0x47, 0x53, 0xFD, 0xD9, 0x23, 0x5E, + 0x3E, 0x02, 0xD0, 0x9A, 0xB3, 0x3E, 0xCC, 0xE2, + 0xD1, 0xCC, 0x01, 0xBF, 0x5D, 0x1E, 0xB7, 0x38, + 0x49, 0x4C, 0x2F, 0x3F, 0x5D, 0x40, 0xE7, 0x48, + 0x82, 0x4D, 0xD5, 0x06, 0x3B, 0x42, 0xD0, 0x67, + 0x86, 0x11, 0x49, 0xE1, 0x4D, 0x07, 0x12, 0xB5, + 0x91, 0x1A, 0x47, 0x4E, 0xB1, 0xD8, 0x0E, 0x05 + }, + { + 0x3C, 0x11, 0x42, 0x70, 0x1A, 0x83, 0xD2, 0xE4, + 0x17, 0x69, 0x2E, 0xDA, 0x7C, 0x3D, 0x5C, 0x0D, + 0xE0, 0x84, 0xDB, 0xF9, 0xA7, 0x77, 0x5D, 0xE2, + 0x94, 0x4E, 0xC7, 0xDF, 0x82, 0x55, 0x3D, 0x2F, + 0x12, 0x07, 0x8E, 0x82, 0x16, 0x26, 0x93, 0x17, + 0x56, 0xE7, 0xC8, 0x93, 0x11, 0x70, 0x8E, 0x40, + 0xC3, 0x2F, 0xF4, 0xB3, 0xDE, 0xB9, 0xEB, 0x37, + 0xBC, 0x30, 0x4E, 0x3A, 0xF7, 0xBF, 0x3C, 0x42 + }, + { + 0x57, 0xB4, 0x5D, 0xFA, 0x9A, 0xB5, 0x6D, 0xB6, + 0xA9, 0x7B, 0x29, 0x1B, 0x15, 0x9F, 0x07, 0x3E, + 0x9B, 0xBD, 0x41, 0x6C, 0xF4, 0x43, 0xD6, 0xF3, + 0x48, 0x9E, 0xAA, 0xED, 0x9D, 0xD0, 0xDC, 0x21, + 0x0D, 0x05, 0x41, 0xCC, 0x14, 0x79, 0xE8, 0x2F, + 0x4A, 0x2D, 0x7B, 0x64, 0x09, 0x45, 0x63, 0xF5, + 0x93, 0x30, 0x3F, 0x53, 0x29, 0x5D, 0x83, 0x6D, + 0xA0, 0x3B, 0xAC, 0x39, 0x6D, 0x82, 0x29, 0x94 + }, + { + 0xA7, 0x47, 0xFB, 0xD1, 0x79, 0x99, 0x4B, 0x57, + 0x81, 0x82, 0x46, 0x5F, 0x4C, 0x25, 0x5B, 0x11, + 0xFE, 0x48, 0x39, 0x76, 0x27, 0x17, 0x13, 0xC4, + 0xF6, 0xF3, 0xA3, 0xE3, 0x4D, 0x44, 0x1B, 0xAA, + 0x96, 0x04, 0x6A, 0x5B, 0x99, 0x8A, 0x99, 0xE0, + 0x4F, 0xA4, 0xB0, 0x18, 0x4D, 0x1D, 0x84, 0xC8, + 0x93, 0xCE, 0x45, 0x86, 0xEE, 0xFA, 0xA8, 0xC1, + 0xE3, 0xFE, 0x19, 0xEB, 0x61, 0xEE, 0x09, 0xE4 + }, + { + 0x77, 0xEF, 0x5E, 0xDA, 0xD1, 0x72, 0x6A, 0x1D, + 0x1E, 0xD1, 0xC1, 0xAF, 0x72, 0xA0, 0x08, 0x44, + 0xE1, 0xB4, 0x97, 0x87, 0x8E, 0x6D, 0xCE, 0x6C, + 0x36, 0x6D, 0x9D, 0x87, 0x07, 0x64, 0xAA, 0xEC, + 0x13, 0xB2, 0xB4, 0x80, 0x02, 0x61, 0xFF, 0xB0, + 0x37, 0x02, 0x4B, 0x55, 0x5D, 0xB2, 0xD0, 0xD6, + 0xCB, 0x05, 0x54, 0x51, 0x4F, 0x39, 0xD6, 0x02, + 0x2B, 0x2C, 0x29, 0x99, 0x28, 0xA6, 0x9B, 0xC7 + }, + { + 0xC7, 0x06, 0x14, 0x11, 0xFF, 0xEE, 0x76, 0xA7, + 0x14, 0xE3, 0xF4, 0x1A, 0xFC, 0x02, 0x39, 0x36, + 0x5D, 0x2C, 0x7F, 0x3B, 0x30, 0x26, 0x8E, 0x64, + 0x8A, 0x3E, 0x64, 0xB7, 0x23, 0x94, 0x73, 0x3F, + 0x56, 0x66, 0xBE, 0xB8, 0xBA, 0x7C, 0x1F, 0x1D, + 0xA1, 0x28, 0xD8, 0x9B, 0xB0, 0x21, 0xE2, 0xC9, + 0x95, 0x3D, 0x9A, 0x24, 0xFC, 0x24, 0xB6, 0xDF, + 0xAD, 0x0D, 0x6F, 0x4D, 0xCA, 0x11, 0x3B, 0x19 + }, + { + 0x9D, 0x08, 0xEA, 0xC5, 0xA8, 0xE5, 0x5A, 0x1A, + 0x11, 0xD0, 0x85, 0x64, 0x17, 0x0F, 0xD6, 0xF1, + 0x8D, 0x05, 0x2D, 0xD9, 0x16, 0x91, 0x5B, 0xD3, + 0x32, 0x6C, 0x70, 0xE9, 0xA1, 0xE5, 0x79, 0xA5, + 0x6D, 0x76, 0xB5, 0xFB, 0x3B, 0x9B, 0xFB, 0xCF, + 0x6A, 0x35, 0xAD, 0x2F, 0xBA, 0xB1, 0xC1, 0x3A, + 0x7E, 0xB1, 0x26, 0x9E, 0xE7, 0xD6, 0x52, 0x84, + 0xF1, 0xD9, 0x10, 0x96, 0x14, 0x16, 0x1E, 0x95 + }, + { + 0xCC, 0xD6, 0xC9, 0x3B, 0x72, 0xAF, 0x8F, 0xE9, + 0x0C, 0xAA, 0xA0, 0xE4, 0x6B, 0x1A, 0x82, 0xAF, + 0x87, 0xAD, 0xD7, 0x24, 0xD1, 0xFF, 0xA2, 0x3D, + 0xC2, 0x31, 0xE2, 0xAF, 0xB4, 0x25, 0x6B, 0x48, + 0x19, 0x44, 0xA5, 0x1A, 0x48, 0x21, 0x3E, 0xCF, + 0x8D, 0xA4, 0x99, 0xDD, 0x95, 0x1B, 0xC7, 0x07, + 0x08, 0x64, 0x02, 0x64, 0x0A, 0xAA, 0x81, 0x2A, + 0x67, 0x05, 0xF4, 0x64, 0x5F, 0x34, 0x3D, 0xD0 + }, + { + 0x6B, 0xE6, 0x51, 0xF9, 0x10, 0x08, 0x11, 0x67, + 0x6E, 0x87, 0xA0, 0x09, 0xAA, 0x42, 0x69, 0x45, + 0x9C, 0xD6, 0xCE, 0xFB, 0x7A, 0x1C, 0xF1, 0xE5, + 0x3F, 0x3E, 0xC3, 0x89, 0x83, 0x68, 0x95, 0xC3, + 0x97, 0x8A, 0xCA, 0x61, 0xE6, 0x45, 0x1F, 0xE4, + 0x52, 0x6D, 0xF2, 0xA1, 0xB4, 0xAC, 0xA9, 0xCC, + 0x78, 0x26, 0x2F, 0xD5, 0x38, 0x48, 0x72, 0xF3, + 0x98, 0x65, 0x14, 0x41, 0x4C, 0x83, 0x27, 0xAA + }, + { + 0x6B, 0x47, 0x09, 0x52, 0xBB, 0x4B, 0xA1, 0x2A, + 0xFC, 0x7F, 0x09, 0x2D, 0x00, 0xA9, 0xB9, 0xF4, + 0x43, 0x8E, 0x3E, 0x4F, 0x76, 0x44, 0x07, 0x51, + 0x91, 0x50, 0x6D, 0xF4, 0x12, 0x9D, 0x88, 0xA8, + 0x6D, 0xC5, 0x2E, 0xE1, 0x68, 0xB9, 0x2D, 0x3F, + 0x92, 0xD2, 0xC0, 0xD3, 0x71, 0x6E, 0xC2, 0x0F, + 0x79, 0x1A, 0x5E, 0xA2, 0xDF, 0x94, 0xE9, 0x14, + 0xC8, 0xF6, 0xF9, 0x32, 0x8D, 0x99, 0x10, 0x05 + }, + { + 0x9C, 0x8E, 0x56, 0x91, 0x35, 0x12, 0x8F, 0x11, + 0x26, 0x48, 0x7B, 0x46, 0xA0, 0xC5, 0x36, 0xAB, + 0x71, 0x76, 0x4D, 0x8B, 0x39, 0xEF, 0x4D, 0x46, + 0xE8, 0xB3, 0x3F, 0x8C, 0xD9, 0xBB, 0xA5, 0x80, + 0x54, 0x5F, 0xFF, 0xDD, 0xFA, 0x02, 0x13, 0x78, + 0x6A, 0xB7, 0x0E, 0x1D, 0x17, 0xD4, 0xDB, 0x6C, + 0x28, 0x85, 0x12, 0x24, 0xB5, 0xEB, 0x63, 0xC6, + 0x6C, 0x68, 0x00, 0x53, 0x51, 0x0A, 0x7E, 0xDC + }, + { + 0x0E, 0x4B, 0x67, 0x56, 0xFE, 0xB5, 0xBB, 0x93, + 0x28, 0xD5, 0xF7, 0x88, 0x6E, 0x79, 0xE3, 0x10, + 0x5D, 0x8D, 0x27, 0xA0, 0x6D, 0x1C, 0x2F, 0x54, + 0xEB, 0x79, 0x57, 0xB3, 0xCE, 0x94, 0x01, 0xE0, + 0x4E, 0x54, 0x1A, 0x1B, 0x70, 0x9B, 0x05, 0x81, + 0x33, 0xEF, 0x42, 0x7B, 0xD3, 0x69, 0xFC, 0x2B, + 0x20, 0x6C, 0xC0, 0x97, 0x76, 0x00, 0x2A, 0x72, + 0x50, 0xAE, 0x0E, 0xDD, 0x7D, 0x62, 0x7B, 0x9C + }, + { + 0x72, 0x66, 0x23, 0x6F, 0xB5, 0x6E, 0x71, 0xC4, + 0x1B, 0xC8, 0xC9, 0x87, 0x8B, 0xFA, 0xA7, 0xD1, + 0x07, 0x2A, 0x8A, 0xB5, 0x04, 0xCB, 0x40, 0x48, + 0x65, 0xF4, 0xF0, 0xB2, 0xDC, 0x38, 0xAE, 0xF1, + 0x37, 0x5C, 0x73, 0x32, 0x10, 0x25, 0x63, 0xE4, + 0x9B, 0xF3, 0x95, 0x40, 0xBB, 0x94, 0xEA, 0xD7, + 0x2F, 0x6E, 0x78, 0xEF, 0x8B, 0x4F, 0x3C, 0x24, + 0xC0, 0x67, 0xBD, 0x4A, 0x8E, 0xD9, 0x21, 0x82 + }, + { + 0x60, 0x6E, 0xA8, 0xCC, 0xDB, 0xA6, 0x94, 0xEF, + 0xCC, 0xA8, 0xA9, 0xC3, 0x02, 0xFD, 0xB6, 0x2A, + 0xD3, 0xB1, 0xEA, 0xB7, 0x40, 0x71, 0x1D, 0x50, + 0x41, 0x81, 0x84, 0x47, 0x77, 0xC1, 0x9F, 0x13, + 0xA2, 0x6D, 0x8C, 0xCE, 0x17, 0xE7, 0x10, 0xDF, + 0x13, 0x2C, 0x14, 0xE7, 0x79, 0x3D, 0x2E, 0xF1, + 0x58, 0x49, 0x51, 0xD4, 0xB8, 0xF4, 0x6F, 0x1D, + 0x90, 0x21, 0x9F, 0x96, 0x9F, 0x69, 0xB5, 0x1F + }, + { + 0x32, 0xB5, 0x3F, 0xD2, 0xAA, 0x72, 0xF7, 0xC9, + 0x0F, 0x01, 0x58, 0xE0, 0xB4, 0xC1, 0x44, 0x49, + 0x59, 0xD2, 0xDC, 0xB7, 0xC5, 0x39, 0x08, 0x10, + 0x33, 0x28, 0x27, 0xB3, 0xAD, 0x71, 0x24, 0x30, + 0x2F, 0x48, 0xC4, 0xE0, 0xB8, 0x31, 0x2A, 0x1C, + 0xF2, 0x90, 0xBF, 0xE7, 0x96, 0xC8, 0x84, 0x24, + 0x1E, 0xC8, 0x60, 0xFD, 0x32, 0x63, 0xF3, 0x26, + 0x56, 0x70, 0xEC, 0xCB, 0x8F, 0x34, 0x64, 0x09 + }, + { + 0xDF, 0x59, 0xDC, 0x87, 0x97, 0x4C, 0xF6, 0x2F, + 0x60, 0xBB, 0x57, 0xE4, 0x59, 0xD1, 0xA5, 0xD3, + 0xA6, 0xCA, 0xA2, 0xEB, 0xEE, 0x42, 0x28, 0x36, + 0xAB, 0x48, 0x1E, 0x00, 0xB9, 0xBC, 0x40, 0x41, + 0x2D, 0xE4, 0xAC, 0x10, 0xBD, 0x4D, 0xEE, 0x02, + 0x9F, 0x92, 0xB8, 0x69, 0x39, 0x3A, 0x57, 0x99, + 0x8B, 0x27, 0x2D, 0xAD, 0xB8, 0x71, 0x6C, 0x72, + 0xB2, 0xFC, 0x32, 0xCF, 0x5A, 0xC1, 0x19, 0x7F + }, + { + 0xAF, 0x31, 0xAA, 0xC7, 0x0A, 0xC4, 0xB5, 0x2E, + 0xED, 0xE0, 0x18, 0xA9, 0x23, 0xA5, 0x9B, 0x58, + 0xA5, 0xC6, 0x36, 0xC6, 0x40, 0x86, 0x50, 0x99, + 0xD9, 0x57, 0x42, 0x41, 0x8F, 0x61, 0xEA, 0xAB, + 0x87, 0x65, 0xD3, 0xD3, 0x68, 0x15, 0xD3, 0x73, + 0x48, 0x2D, 0x48, 0x62, 0x02, 0xAE, 0x7B, 0xBA, + 0x7A, 0xFD, 0x87, 0x42, 0xDC, 0x81, 0x82, 0x36, + 0xCE, 0x9C, 0xE1, 0xB3, 0xF0, 0xB2, 0xF2, 0x51 + }, + { + 0x39, 0x4B, 0x13, 0x8E, 0xCC, 0x8F, 0xDB, 0xFB, + 0x3F, 0x53, 0xF8, 0xAA, 0xBD, 0x53, 0x7B, 0x37, + 0xA1, 0x77, 0xF5, 0xF8, 0x90, 0x32, 0x30, 0x61, + 0xA8, 0x8F, 0xA3, 0x3C, 0xD1, 0xE0, 0x52, 0x0D, + 0x21, 0xB8, 0xBF, 0xDD, 0x47, 0xC8, 0x13, 0x1C, + 0x44, 0x49, 0x41, 0xE2, 0x25, 0x1D, 0xC4, 0xBE, + 0x73, 0xFD, 0x33, 0x68, 0x60, 0x9B, 0x1D, 0x90, + 0x11, 0xC5, 0xA4, 0x0D, 0xE6, 0x4F, 0xCF, 0x58 + }, + { + 0xF9, 0x34, 0x7F, 0xD7, 0x9E, 0x7B, 0x82, 0xF2, + 0xC4, 0xC1, 0xFC, 0xA4, 0x07, 0x75, 0x50, 0x47, + 0x89, 0xC8, 0xEB, 0x81, 0x6C, 0xD6, 0xC6, 0x58, + 0x70, 0xE7, 0x21, 0x4D, 0xBF, 0x61, 0x54, 0x2E, + 0x33, 0xD6, 0xF0, 0x05, 0x40, 0xF4, 0x94, 0xA1, + 0xAD, 0x38, 0x3D, 0x43, 0x03, 0xA0, 0xF0, 0x6C, + 0x39, 0x17, 0x13, 0x13, 0x37, 0xEA, 0x07, 0x32, + 0x8C, 0xF4, 0x4B, 0x90, 0x06, 0x3D, 0x1D, 0x04 + }, + { + 0xD0, 0xA9, 0x4D, 0xF7, 0x4B, 0xAB, 0x71, 0xB2, + 0x24, 0x51, 0xCD, 0x78, 0x43, 0x04, 0x42, 0x4B, + 0x72, 0x5B, 0x52, 0xC5, 0x3D, 0xA1, 0x1D, 0x89, + 0x6D, 0x0B, 0x0B, 0x7A, 0x05, 0x0D, 0xBD, 0x65, + 0x01, 0x93, 0xDF, 0x0C, 0x31, 0x08, 0xFA, 0xF8, + 0xD7, 0x29, 0x0E, 0x8A, 0x2F, 0xB7, 0x5D, 0x33, + 0x8C, 0x15, 0xAE, 0xA1, 0xF1, 0xD6, 0x51, 0xC6, + 0xAA, 0xF7, 0x11, 0xC0, 0x15, 0x3F, 0x85, 0xCC + }, + { + 0x29, 0xC0, 0x87, 0x59, 0xA2, 0x23, 0x72, 0xB4, + 0x3C, 0xFD, 0x2D, 0x1D, 0x3B, 0xA3, 0x0A, 0x0A, + 0x86, 0x9A, 0x9C, 0x3A, 0xE1, 0x80, 0x1F, 0x3E, + 0x34, 0xC6, 0xA4, 0x1E, 0xD7, 0xF2, 0xEC, 0x4E, + 0xEC, 0x54, 0xB0, 0xAB, 0xEB, 0xD9, 0xE6, 0x24, + 0x93, 0xB1, 0xE7, 0xE0, 0xF0, 0xBB, 0x0D, 0x48, + 0x4E, 0x45, 0x60, 0x8F, 0x21, 0xFF, 0x78, 0xD8, + 0xB5, 0xC1, 0xF0, 0xFE, 0x93, 0x62, 0x73, 0xD7 + }, + { + 0x6D, 0x24, 0xA2, 0x41, 0xEA, 0x20, 0x88, 0xB0, + 0x47, 0x69, 0xCB, 0x54, 0x09, 0x8E, 0xF0, 0xC8, + 0x75, 0xAF, 0xEB, 0x9E, 0xF8, 0x80, 0x03, 0x42, + 0x40, 0x04, 0x90, 0x19, 0xCF, 0x50, 0xF9, 0x5C, + 0xBA, 0xD6, 0x55, 0xAE, 0x11, 0xEF, 0x6D, 0x62, + 0x35, 0x8C, 0xF7, 0xE4, 0x63, 0x8F, 0x5C, 0x59, + 0x6A, 0x7E, 0x67, 0x93, 0x6D, 0x01, 0x35, 0xFF, + 0x97, 0x68, 0xFD, 0x12, 0xA9, 0x02, 0xFB, 0x0F + }, + { + 0x6D, 0xE8, 0x7A, 0xCF, 0xF9, 0xDD, 0xB8, 0x9C, + 0xF1, 0x43, 0xA5, 0xB3, 0x4C, 0x5B, 0xD9, 0x9D, + 0x13, 0xB3, 0xF8, 0x2E, 0xC3, 0x9B, 0xE9, 0xD0, + 0xE2, 0xF7, 0xDA, 0x6A, 0xCA, 0x16, 0xA5, 0x76, + 0xF7, 0x3E, 0x11, 0x1C, 0x31, 0x2F, 0xAF, 0xDD, + 0x46, 0x9A, 0x80, 0xF8, 0xB5, 0x9A, 0x17, 0x7A, + 0xE9, 0xDE, 0x8B, 0x47, 0xEE, 0x68, 0xE5, 0x02, + 0x8B, 0x5F, 0x1F, 0x51, 0xBD, 0xAB, 0x34, 0x0A + }, + { + 0xFB, 0x21, 0xCD, 0xDF, 0x31, 0xCB, 0x2E, 0x78, + 0x87, 0xEE, 0x78, 0x8A, 0x7F, 0x42, 0x92, 0x1F, + 0x20, 0x9C, 0xAE, 0xFA, 0x78, 0x44, 0xB0, 0x8F, + 0x13, 0x59, 0xFE, 0xF3, 0x9E, 0x04, 0x33, 0x3A, + 0xC8, 0x5F, 0x6C, 0x91, 0x67, 0xBD, 0xAE, 0xD5, + 0x2C, 0x5C, 0xE7, 0x2E, 0xEC, 0x45, 0x2C, 0x94, + 0x72, 0xE5, 0x1A, 0x44, 0x3D, 0xB4, 0xC7, 0x82, + 0xE8, 0x16, 0x66, 0xE6, 0xF1, 0xDA, 0xB3, 0x7E + }, + { + 0x3C, 0xC1, 0x16, 0x30, 0x61, 0x3D, 0x51, 0x48, + 0xB7, 0x6A, 0x40, 0x42, 0x14, 0xE1, 0x7D, 0xBD, + 0xD9, 0x0F, 0xFD, 0x88, 0x42, 0x75, 0x45, 0x68, + 0xC1, 0x0C, 0xE4, 0x76, 0xAB, 0x25, 0xDF, 0x0C, + 0x81, 0xF0, 0x7E, 0x9E, 0xA7, 0xE9, 0x6B, 0x5C, + 0x9B, 0xC3, 0x1C, 0xB0, 0xCA, 0x09, 0x6C, 0x26, + 0xD5, 0x01, 0x5E, 0xAB, 0x2C, 0xDD, 0xF1, 0x68, + 0xE6, 0x9B, 0x4A, 0x65, 0xB7, 0xF5, 0xE8, 0x00 + }, + { + 0x5C, 0xE7, 0xC2, 0xF1, 0xC6, 0xC0, 0xD5, 0x2F, + 0xCC, 0x48, 0xE4, 0xCF, 0x83, 0xF8, 0x5A, 0xB1, + 0x7D, 0x22, 0x26, 0x7A, 0x87, 0x72, 0x4D, 0x0C, + 0x88, 0x39, 0x06, 0xC9, 0x39, 0xF8, 0x9C, 0x44, + 0x99, 0xC3, 0xB9, 0x46, 0xC3, 0xD8, 0xA4, 0xEF, + 0x8C, 0xD2, 0x64, 0x34, 0x40, 0x6F, 0xCE, 0x9E, + 0x94, 0xCF, 0xD2, 0xB4, 0x23, 0xE0, 0xFB, 0x62, + 0x2A, 0x6C, 0x6D, 0x95, 0x25, 0x62, 0x5A, 0x84 + }, + { + 0x1A, 0x3C, 0xF3, 0x6E, 0x94, 0xAC, 0x20, 0xE3, + 0x68, 0x65, 0x13, 0xD6, 0x02, 0xA6, 0x0C, 0xD9, + 0x3A, 0x4B, 0xD9, 0x49, 0x48, 0x2F, 0x91, 0x29, + 0xE0, 0x95, 0xC1, 0xBA, 0x26, 0xF4, 0xF4, 0xB8, + 0x72, 0xD7, 0x9B, 0x45, 0x76, 0x29, 0xC3, 0xF4, + 0xEE, 0x5C, 0xDE, 0x23, 0x90, 0x7F, 0x3F, 0x12, + 0x09, 0x9B, 0x92, 0x8C, 0xEA, 0x08, 0x35, 0xC3, + 0x86, 0x03, 0xA5, 0x96, 0xBF, 0x87, 0x7F, 0x41 + }, + { + 0x23, 0x73, 0x6A, 0xBF, 0x06, 0xD6, 0xCC, 0xEC, + 0x4E, 0x96, 0xE3, 0x21, 0x1A, 0x5D, 0xD7, 0x4C, + 0x89, 0x1C, 0x2B, 0xFE, 0x3F, 0x7A, 0xC6, 0x6E, + 0x0F, 0x85, 0x09, 0x72, 0x37, 0x4F, 0xFE, 0x5B, + 0x63, 0x98, 0x13, 0xD7, 0xA4, 0x6A, 0x37, 0xCE, + 0x36, 0x33, 0x05, 0x9E, 0xAD, 0x56, 0x3F, 0x4A, + 0x77, 0x39, 0x0C, 0x7B, 0x8A, 0xE9, 0x63, 0xAE, + 0x73, 0xE4, 0xB7, 0xA9, 0x1E, 0x31, 0x92, 0x85 + }, + { + 0xD2, 0xC9, 0xAB, 0x64, 0x89, 0xC0, 0xDE, 0x6A, + 0x8E, 0x0F, 0x5A, 0x66, 0x1F, 0xE7, 0xB2, 0x22, + 0x76, 0x44, 0x0B, 0x0F, 0x84, 0xF9, 0x07, 0x7C, + 0xD8, 0x7F, 0x5D, 0xA5, 0xC9, 0x5C, 0x84, 0x73, + 0xAB, 0x57, 0xB4, 0xCF, 0x24, 0x02, 0xBE, 0xE6, + 0x8A, 0x21, 0xF0, 0x60, 0x46, 0x8B, 0xAE, 0xB3, + 0x31, 0x65, 0x69, 0x3D, 0x88, 0x18, 0xDE, 0xCC, + 0x4B, 0xD5, 0x98, 0xF2, 0xC5, 0xDF, 0xFE, 0xB6 + }, + { + 0xE7, 0xB4, 0x3A, 0x27, 0x39, 0x99, 0x1D, 0x50, + 0x53, 0xD8, 0xEB, 0xAC, 0x00, 0x31, 0x59, 0xD9, + 0xD2, 0x89, 0x3B, 0x66, 0x4C, 0x2D, 0x52, 0xFD, + 0xE1, 0x09, 0x56, 0xC2, 0x03, 0x80, 0x85, 0x74, + 0xA9, 0x7B, 0xBF, 0xFA, 0x9D, 0x2D, 0xC3, 0x70, + 0x94, 0xC7, 0x4E, 0x22, 0x47, 0xFB, 0x81, 0x59, + 0x10, 0xC3, 0x88, 0x7F, 0x99, 0xD0, 0x81, 0x20, + 0xC3, 0x01, 0xB2, 0x1F, 0x9D, 0x61, 0xE0, 0x95 + }, + { + 0x74, 0x4E, 0xB0, 0x6C, 0x3C, 0x36, 0x24, 0x44, + 0x7A, 0x87, 0x19, 0xDA, 0x6D, 0xEB, 0x57, 0x56, + 0xF5, 0x36, 0x19, 0xD7, 0xBA, 0x6E, 0x7E, 0x32, + 0xAC, 0xB7, 0xC7, 0xD7, 0x24, 0x3E, 0xDC, 0x70, + 0x0F, 0xA7, 0xE4, 0x9D, 0x98, 0xA7, 0xEC, 0x07, + 0x99, 0xC8, 0x19, 0xB6, 0x9D, 0x00, 0x28, 0x7C, + 0x39, 0xEB, 0x92, 0x0A, 0x46, 0xA2, 0x41, 0xA0, + 0x20, 0x63, 0xEE, 0x04, 0x2F, 0x72, 0xE9, 0xBB + }, + { + 0x7E, 0xEF, 0x25, 0xAE, 0xB3, 0x6A, 0xAD, 0x43, + 0x90, 0x68, 0xD5, 0xC7, 0x9B, 0xE0, 0x4B, 0x56, + 0x3A, 0x2C, 0x82, 0xDD, 0x0C, 0x87, 0x54, 0x9D, + 0x96, 0x67, 0x3C, 0x7A, 0x00, 0x30, 0x35, 0x1F, + 0xC8, 0x9A, 0x95, 0x84, 0x07, 0xAD, 0x2E, 0xF0, + 0xBF, 0x4A, 0x81, 0x04, 0x38, 0x29, 0x10, 0x3F, + 0x94, 0x3A, 0x5A, 0xBC, 0x80, 0xD9, 0x62, 0xE3, + 0xFA, 0x71, 0x91, 0xA3, 0x8B, 0x9B, 0x0A, 0x02 + }, + { + 0x7B, 0x66, 0x83, 0x0A, 0xC7, 0x6C, 0xBA, 0xD2, + 0x90, 0x98, 0x7E, 0x34, 0xA0, 0x35, 0x40, 0x7C, + 0xA3, 0x40, 0x93, 0x29, 0x66, 0x39, 0x72, 0x06, + 0xBC, 0x13, 0x7B, 0xC8, 0xB2, 0xE0, 0x34, 0x67, + 0xD2, 0xB5, 0x30, 0x52, 0x94, 0x7D, 0x31, 0xFD, + 0xAF, 0xF9, 0x10, 0x9F, 0xAC, 0x7C, 0x89, 0x0F, + 0x84, 0xFA, 0x78, 0x0D, 0xB6, 0x0A, 0x6F, 0x41, + 0x0F, 0xD8, 0x7B, 0xA7, 0x42, 0x79, 0xF1, 0xF3 + }, + { + 0xBB, 0x87, 0x1F, 0x90, 0xFF, 0xC9, 0x73, 0xA2, + 0x6B, 0xF5, 0x22, 0x36, 0xE7, 0x59, 0x12, 0x2E, + 0xF1, 0xC7, 0xA7, 0x7B, 0x66, 0xFD, 0x6C, 0x67, + 0x81, 0x78, 0x51, 0x17, 0x73, 0x64, 0xD7, 0x12, + 0x3C, 0xDB, 0x91, 0x1E, 0x0C, 0xDE, 0xD9, 0xE3, + 0xFD, 0x49, 0x99, 0xC7, 0x06, 0xA9, 0xFB, 0x92, + 0x2F, 0x5A, 0x94, 0x88, 0x05, 0xFC, 0x6E, 0x7D, + 0x0F, 0x00, 0x32, 0xAF, 0x5D, 0x8A, 0xB0, 0xC0 + }, + { + 0x79, 0x29, 0x7E, 0x2E, 0xE0, 0x37, 0xBA, 0xE1, + 0x22, 0xE7, 0x4C, 0xC9, 0x68, 0x2F, 0xD7, 0xDB, + 0x09, 0x97, 0x49, 0xC0, 0x46, 0x38, 0x5B, 0x85, + 0x3A, 0x50, 0xF7, 0x46, 0x86, 0xAE, 0x65, 0x65, + 0x04, 0x37, 0x66, 0x9C, 0x38, 0x49, 0x11, 0x93, + 0xE6, 0xA2, 0x32, 0xEB, 0x23, 0xAF, 0xC4, 0xF3, + 0x95, 0x59, 0x07, 0xF8, 0xE5, 0x98, 0x2A, 0xCD, + 0xEE, 0x08, 0x34, 0xF5, 0xB2, 0xF1, 0xFE, 0xE4 + }, + { + 0xD8, 0xDF, 0xC4, 0x24, 0xD3, 0x39, 0x8C, 0x28, + 0x3B, 0x6F, 0x6F, 0xCA, 0x86, 0x72, 0xEC, 0x37, + 0x13, 0x32, 0x79, 0xF0, 0x05, 0xCC, 0x0F, 0xCA, + 0x34, 0x67, 0x86, 0xC3, 0x98, 0x2F, 0xE1, 0x6A, + 0xCD, 0xD7, 0xCB, 0x1F, 0x98, 0xD3, 0x50, 0x25, + 0xD7, 0x10, 0xB3, 0xD2, 0x4C, 0xF9, 0x88, 0x0B, + 0x56, 0x7F, 0x65, 0x6B, 0x5E, 0xB6, 0x15, 0x3E, + 0x7B, 0x09, 0xF3, 0xA6, 0x42, 0x5E, 0xF1, 0x93 + }, + { + 0x71, 0xE9, 0x88, 0x59, 0x86, 0xA3, 0x40, 0x9C, + 0x7A, 0xAA, 0x39, 0xCF, 0x90, 0x05, 0x0F, 0x1C, + 0xFE, 0x3C, 0x9C, 0x33, 0xE4, 0x78, 0x60, 0xB6, + 0x12, 0x9C, 0x78, 0x9B, 0x1C, 0x63, 0x26, 0x33, + 0x78, 0x30, 0x41, 0x43, 0x26, 0x0B, 0x46, 0x77, + 0xCC, 0xE4, 0xE0, 0xDE, 0xDA, 0x6E, 0xAB, 0xCC, + 0xD0, 0x78, 0x77, 0x65, 0x66, 0x7D, 0xD1, 0x85, + 0xE1, 0xA5, 0xE0, 0x85, 0x5A, 0x44, 0xD7, 0xFD + }, + { + 0xAF, 0x22, 0x4F, 0x6D, 0x72, 0xE8, 0x07, 0xA4, + 0x94, 0xF9, 0xB2, 0xEF, 0xD1, 0x0A, 0x1C, 0x06, + 0x05, 0xB0, 0x9B, 0x5D, 0x8A, 0x20, 0x5B, 0x87, + 0xAF, 0xDD, 0x5E, 0x27, 0xD4, 0x89, 0xF1, 0x85, + 0xE8, 0x1A, 0x1C, 0x98, 0xB0, 0x12, 0x53, 0x64, + 0xA8, 0x66, 0x4F, 0x94, 0xD1, 0x40, 0x1D, 0x91, + 0xAD, 0xD7, 0xD2, 0xFC, 0x96, 0x33, 0x65, 0xB1, + 0x26, 0xD5, 0xF0, 0x66, 0x3C, 0xA3, 0x63, 0xD9 + }, + { + 0xB7, 0x50, 0x02, 0x6C, 0x63, 0x5F, 0x8A, 0xCD, + 0x24, 0x55, 0xAD, 0x7C, 0xD7, 0x4D, 0xA6, 0x11, + 0x1C, 0x50, 0xEB, 0xBE, 0x0B, 0x70, 0xFF, 0xA7, + 0xBA, 0x68, 0x69, 0xCA, 0x62, 0xA6, 0x37, 0xBD, + 0x65, 0x15, 0xDC, 0x8B, 0x76, 0x33, 0x34, 0xA8, + 0xCB, 0x06, 0x5F, 0x3F, 0xD6, 0x3A, 0xEB, 0xCA, + 0x27, 0xE8, 0xAF, 0xFB, 0xBA, 0xB6, 0x9A, 0x0F, + 0x9E, 0xA4, 0xD0, 0xF3, 0x70, 0xFB, 0xB2, 0x87 + }, + { + 0xC0, 0xB8, 0xF4, 0x6F, 0x31, 0xB2, 0x4B, 0x46, + 0x21, 0xB3, 0x9D, 0xE1, 0x75, 0x5B, 0xC9, 0x37, + 0x3E, 0xF4, 0xA8, 0x71, 0x5C, 0x53, 0x42, 0xAA, + 0x3B, 0x19, 0xCF, 0xA2, 0xA7, 0x85, 0x41, 0xDF, + 0x84, 0xD2, 0xA4, 0x10, 0x79, 0x07, 0x54, 0x2C, + 0x79, 0xB6, 0xDC, 0xDB, 0xBD, 0x33, 0x86, 0xFA, + 0x27, 0x3F, 0x66, 0xD6, 0xD1, 0x91, 0x5D, 0xD1, + 0xF4, 0x7E, 0xB2, 0x2E, 0xFD, 0xBC, 0x2B, 0xA0 + }, + { + 0x22, 0x9D, 0x67, 0x5B, 0xF1, 0x84, 0x43, 0x04, + 0x29, 0xD2, 0x2F, 0x04, 0x10, 0x42, 0xC1, 0x8A, + 0x5D, 0xF4, 0x40, 0x00, 0x9B, 0x07, 0x88, 0x23, + 0x86, 0xDE, 0x5C, 0xEE, 0xF0, 0x35, 0xA2, 0xBA, + 0xC7, 0x22, 0xF7, 0xA8, 0xC4, 0xA8, 0x7F, 0x91, + 0xFC, 0x5C, 0x84, 0xFC, 0x7B, 0xA3, 0xBB, 0x23, + 0x0B, 0xFE, 0x21, 0x4E, 0x17, 0x5E, 0xBE, 0x46, + 0xFC, 0x66, 0x99, 0xF9, 0x6A, 0x16, 0x8E, 0x9B + }, + { + 0x0B, 0xB6, 0xB8, 0x07, 0x65, 0x0E, 0xFC, 0xB1, + 0xAF, 0x1F, 0x89, 0x8A, 0x2D, 0xE2, 0xFA, 0xDC, + 0xE5, 0x4B, 0x28, 0x13, 0x80, 0xB4, 0xE1, 0x12, + 0xD6, 0x76, 0x31, 0xC0, 0x75, 0x4C, 0x4B, 0xF7, + 0xDF, 0x00, 0xE8, 0xD5, 0x5F, 0x49, 0xC3, 0x9C, + 0xF7, 0x5E, 0x1F, 0x9F, 0x90, 0x3B, 0xA9, 0xDA, + 0xF6, 0xA6, 0x62, 0x01, 0x5E, 0x98, 0x25, 0x53, + 0x31, 0xB2, 0x83, 0x2A, 0xB4, 0x0B, 0x8E, 0xA8 + }, + { + 0xE0, 0xBC, 0xE2, 0xCF, 0x68, 0x37, 0x04, 0x1C, + 0x7A, 0x89, 0xDD, 0xBC, 0xBC, 0x2D, 0x48, 0xB6, + 0xB6, 0x76, 0xD9, 0x01, 0xA0, 0x04, 0x97, 0x1F, + 0x82, 0x35, 0x09, 0x78, 0x7A, 0xCA, 0x0D, 0x3D, + 0xC4, 0x6B, 0xCC, 0x4E, 0x5E, 0x45, 0xFB, 0x8E, + 0xA0, 0xD1, 0x4D, 0x11, 0x07, 0xB3, 0xFC, 0x88, + 0x16, 0xE7, 0xE7, 0x10, 0x03, 0xA3, 0x5C, 0x1F, + 0x26, 0x5B, 0xFA, 0x10, 0x73, 0x10, 0x4C, 0xD4 + }, + { + 0x53, 0x46, 0x00, 0x46, 0x9F, 0xDD, 0xC6, 0x39, + 0x11, 0x25, 0x2E, 0x66, 0x34, 0x60, 0xA8, 0xED, + 0x8B, 0xE1, 0x2F, 0x58, 0x95, 0x23, 0x36, 0xCB, + 0x47, 0x43, 0x82, 0xB4, 0x63, 0x3D, 0x8C, 0xC7, + 0xAC, 0x0B, 0xAB, 0x13, 0x0D, 0xFF, 0xBB, 0x3E, + 0xBA, 0xE2, 0x3B, 0xDB, 0x96, 0xAD, 0x47, 0x13, + 0xD5, 0xDB, 0xB2, 0x13, 0x81, 0x8C, 0xFF, 0xE4, + 0xCA, 0xE1, 0x98, 0xAA, 0x7D, 0xFC, 0x49, 0x99 + }, + { + 0xFD, 0x19, 0xE1, 0xBB, 0x9E, 0xB0, 0x34, 0x21, + 0xA8, 0x47, 0xDC, 0xD2, 0x3A, 0x3A, 0x30, 0xAD, + 0x7F, 0xF3, 0x4C, 0xA9, 0x33, 0xDD, 0xB4, 0xD6, + 0x99, 0xED, 0x89, 0x30, 0x34, 0xA7, 0x71, 0x28, + 0x7A, 0x73, 0x7F, 0x56, 0x82, 0x3D, 0xDD, 0x06, + 0xC5, 0x47, 0x65, 0x13, 0x72, 0xE8, 0x58, 0xC7, + 0xC9, 0xAB, 0x27, 0xA0, 0x98, 0x2C, 0x82, 0xBC, + 0x95, 0x1E, 0x8D, 0xD5, 0x25, 0xAD, 0x90, 0x75 + }, + { + 0xEF, 0x47, 0xA5, 0xDB, 0xF0, 0x14, 0xBD, 0x35, + 0x2C, 0x8E, 0x78, 0xFD, 0x71, 0x65, 0xD3, 0xEA, + 0xDF, 0x9D, 0x29, 0x8C, 0x17, 0x1A, 0x7F, 0x62, + 0xCD, 0x81, 0x3E, 0x4C, 0xF2, 0xC2, 0x2D, 0xDA, + 0xED, 0xC0, 0x9D, 0x8B, 0x1B, 0x03, 0x17, 0x50, + 0xE8, 0x09, 0xB8, 0x2F, 0x8E, 0x26, 0x39, 0xB8, + 0x4D, 0x51, 0xDC, 0x50, 0x06, 0xEB, 0xC9, 0xDD, + 0xC9, 0xA1, 0xA3, 0xBD, 0xB6, 0x3C, 0xD7, 0x09 + }, + { + 0xB8, 0x1B, 0xF3, 0xC2, 0xCE, 0x6F, 0xE6, 0xCA, + 0xFF, 0xDA, 0x02, 0xF3, 0xD4, 0x68, 0xC3, 0x5D, + 0x64, 0x98, 0xA0, 0x53, 0x6A, 0x23, 0xF5, 0x89, + 0x02, 0x65, 0xB6, 0x57, 0x22, 0xCA, 0xD6, 0x39, + 0x5E, 0x2C, 0x67, 0x27, 0x6B, 0x8A, 0xD1, 0x79, + 0x0D, 0x7A, 0x7F, 0xD3, 0x2C, 0xEB, 0xEB, 0x4A, + 0x94, 0x94, 0x51, 0x4C, 0x53, 0x0D, 0xEE, 0x06, + 0x41, 0x34, 0x0A, 0x2B, 0x2B, 0x79, 0xC0, 0x41 + }, + { + 0x6A, 0xF2, 0x3F, 0x91, 0xCA, 0x3C, 0xA4, 0x9B, + 0x5C, 0x82, 0x67, 0xEA, 0x6E, 0x6E, 0x65, 0x97, + 0xD3, 0x4B, 0x0A, 0xE2, 0x2D, 0x17, 0x63, 0x4D, + 0x2F, 0x48, 0xE6, 0x87, 0x7F, 0x92, 0x80, 0x9C, + 0xC0, 0xA4, 0xF3, 0xFD, 0x93, 0x44, 0xCE, 0x15, + 0x48, 0x14, 0x49, 0x3B, 0xD3, 0x5C, 0x77, 0x69, + 0x23, 0xF9, 0x49, 0x2E, 0x37, 0x33, 0xAC, 0x8C, + 0xBC, 0x60, 0x0E, 0x96, 0x3D, 0xC7, 0x82, 0x57 + }, + { + 0x49, 0xB3, 0xD0, 0x1A, 0x1F, 0x21, 0x43, 0x1D, + 0x4A, 0x9B, 0x65, 0xE0, 0x45, 0x0B, 0xB0, 0x44, + 0x4B, 0x7D, 0x1D, 0xEB, 0x81, 0x13, 0x1D, 0x65, + 0x0D, 0x9C, 0xBE, 0xFC, 0xAD, 0x74, 0x36, 0xA0, + 0xE5, 0x10, 0x50, 0x44, 0x5A, 0xF3, 0x9F, 0x3F, + 0x13, 0x12, 0xDB, 0xE3, 0xE2, 0xD0, 0x36, 0x01, + 0xBA, 0x30, 0x9D, 0x3B, 0xC3, 0xC4, 0x6B, 0xC5, + 0xBD, 0xC7, 0x68, 0xFE, 0xEB, 0xE1, 0x76, 0xFB + }, + { + 0x49, 0xB5, 0xB1, 0x92, 0xAB, 0x4B, 0xC1, 0x1A, + 0x8B, 0xDF, 0x3A, 0x09, 0x2D, 0x66, 0xB0, 0x76, + 0xAE, 0xC5, 0x6C, 0xAA, 0xB4, 0x54, 0x9D, 0x85, + 0x0B, 0x33, 0xC3, 0x7C, 0xAA, 0xCE, 0x60, 0x92, + 0x5F, 0x55, 0x60, 0x73, 0x08, 0x1F, 0x35, 0xD0, + 0xB9, 0x5A, 0x4C, 0x92, 0x53, 0x39, 0x40, 0xBC, + 0xEB, 0x11, 0x5A, 0xDF, 0xB5, 0x18, 0x42, 0xDE, + 0x6D, 0x45, 0xA6, 0x2B, 0x54, 0xE0, 0x30, 0x83 + }, + { + 0xD1, 0x68, 0xC7, 0x18, 0x42, 0x0F, 0x53, 0xC3, + 0xBB, 0x1F, 0xF2, 0x3B, 0x3D, 0x8C, 0x06, 0x7B, + 0xD8, 0x7C, 0x70, 0xBF, 0x96, 0x69, 0x80, 0xCC, + 0x6E, 0xA3, 0x5C, 0x04, 0xB0, 0x1B, 0x5A, 0x19, + 0x5C, 0x6B, 0xFF, 0x57, 0x57, 0xA2, 0xB7, 0xF1, + 0xF4, 0x1D, 0xDE, 0xE9, 0x94, 0x11, 0x08, 0x8B, + 0x82, 0x69, 0x90, 0xE2, 0x87, 0x1F, 0x81, 0x82, + 0x5E, 0xA1, 0x8E, 0x2A, 0xE7, 0x23, 0xD5, 0xDE + }, + { + 0xAF, 0x68, 0xEC, 0xCC, 0x0C, 0xB7, 0x51, 0xAA, + 0xC5, 0x30, 0x1B, 0x18, 0xBD, 0xEC, 0x1D, 0x9A, + 0x19, 0xDF, 0xDE, 0x0C, 0x90, 0x63, 0x9F, 0x9C, + 0xF3, 0xC8, 0x55, 0xE9, 0x85, 0x5E, 0x99, 0xA8, + 0x89, 0xE8, 0xD5, 0x02, 0xE6, 0x34, 0xFB, 0xDF, + 0xA4, 0xCC, 0x67, 0xFF, 0x01, 0x91, 0x65, 0x5C, + 0xA9, 0x9F, 0x2F, 0xB0, 0xD2, 0x22, 0xFF, 0xB6, + 0xB8, 0x7B, 0x0A, 0x60, 0xCB, 0xF6, 0xD9, 0x9C + }, + { + 0xE9, 0x85, 0xB5, 0x2A, 0xE2, 0x37, 0x87, 0xFA, + 0x70, 0x38, 0x5A, 0xFA, 0x9A, 0x7A, 0x6F, 0xD8, + 0x24, 0x68, 0xA8, 0x99, 0x25, 0x62, 0x62, 0x27, + 0x5C, 0xCE, 0x5A, 0x9B, 0xE2, 0xCB, 0xC2, 0xC0, + 0x93, 0x19, 0x42, 0x89, 0x18, 0xFD, 0x2E, 0x17, + 0x17, 0xBD, 0xF0, 0x62, 0x0D, 0x0D, 0x99, 0x48, + 0x0E, 0xD8, 0x2D, 0xC1, 0xAF, 0x4E, 0xA8, 0x26, + 0xD2, 0xCD, 0x64, 0xE9, 0x43, 0x27, 0x6D, 0x98 + }, + { + 0x29, 0x16, 0xA6, 0xD7, 0x8C, 0xE3, 0xEA, 0xF1, + 0x85, 0xBD, 0x8C, 0x7B, 0x85, 0xD9, 0x77, 0x3A, + 0xD8, 0x28, 0xE8, 0x52, 0x5F, 0xC0, 0xCC, 0x7B, + 0x07, 0x62, 0xCF, 0xC3, 0x94, 0x85, 0xB4, 0x95, + 0x30, 0x10, 0xEA, 0xFB, 0xB6, 0xA5, 0x2F, 0xDF, + 0x83, 0x36, 0xBE, 0x13, 0x02, 0xBC, 0x7C, 0x04, + 0x0D, 0xEE, 0xF1, 0xF7, 0xE4, 0x4E, 0x16, 0x37, + 0x18, 0x3E, 0xF1, 0xD1, 0x84, 0xC2, 0x4B, 0x5D + }, + { + 0x8E, 0x80, 0x27, 0xBF, 0x51, 0xC8, 0x48, 0xBC, + 0x02, 0xAE, 0x76, 0x62, 0x30, 0xFE, 0xF5, 0x6B, + 0xE4, 0xF7, 0x14, 0x0E, 0x88, 0xBA, 0xA7, 0xE2, + 0xD7, 0x26, 0x82, 0x39, 0x33, 0x06, 0x25, 0xC9, + 0x2C, 0x3E, 0xCE, 0x02, 0x18, 0x55, 0xF5, 0x47, + 0x8D, 0x2A, 0x99, 0x0A, 0xD7, 0xF9, 0xB9, 0xC1, + 0xE5, 0x19, 0xCD, 0x7F, 0x54, 0x2A, 0x6D, 0x9D, + 0x9E, 0x82, 0x92, 0x52, 0xB3, 0x90, 0x41, 0x57 + }, + { + 0x54, 0xC0, 0x8C, 0xCA, 0xF8, 0xD8, 0x18, 0xF7, + 0xED, 0xA1, 0xD1, 0xBF, 0xA7, 0xED, 0xA0, 0x29, + 0xD5, 0xD8, 0xC2, 0x44, 0xED, 0xAC, 0x06, 0x7E, + 0xB8, 0x3E, 0x35, 0x71, 0xF0, 0xE3, 0x46, 0x22, + 0x77, 0x52, 0x61, 0xA6, 0x8A, 0x37, 0x9D, 0xF9, + 0xD0, 0x95, 0xA6, 0x0E, 0x3C, 0x4C, 0x41, 0xAC, + 0xE6, 0xBD, 0xBB, 0xF0, 0xE9, 0x7A, 0x61, 0x63, + 0xCE, 0x5C, 0x4E, 0xFA, 0xF7, 0x5D, 0x75, 0x0E + }, + { + 0xA0, 0xB3, 0xF6, 0x8C, 0x03, 0xFA, 0x19, 0x09, + 0xDC, 0x13, 0xC5, 0x7A, 0xA1, 0x48, 0xB5, 0xF4, + 0x35, 0xED, 0x89, 0x6B, 0xC5, 0x1C, 0xA8, 0xB5, + 0x8A, 0xF4, 0xCD, 0x37, 0xBC, 0x61, 0x22, 0xAB, + 0x78, 0x74, 0x21, 0xF3, 0x1E, 0x1D, 0xFF, 0xC2, + 0x02, 0x1C, 0x49, 0x70, 0x19, 0x0E, 0x80, 0xE3, + 0xF6, 0xF1, 0xB5, 0xE9, 0x30, 0xAA, 0x99, 0x8E, + 0xE8, 0xF1, 0xA5, 0x81, 0x5D, 0x68, 0x95, 0xC1 + }, + { + 0x63, 0xFB, 0x28, 0xFD, 0xA9, 0x50, 0xB4, 0x79, + 0x1C, 0x87, 0xA1, 0xD7, 0x2F, 0x58, 0x3B, 0xF6, + 0x80, 0x03, 0x9A, 0x82, 0x4F, 0xEA, 0x37, 0xD0, + 0xE3, 0xE1, 0xEF, 0x0B, 0x1F, 0xA6, 0xF6, 0xEC, + 0xF2, 0xE7, 0x3D, 0xA6, 0xEB, 0x68, 0x4D, 0x34, + 0xBB, 0x02, 0xAC, 0x38, 0x84, 0x6B, 0x47, 0x3C, + 0x0B, 0xC7, 0x47, 0xF2, 0xED, 0xA6, 0xE0, 0x8C, + 0xB2, 0xD2, 0x4C, 0xB5, 0x67, 0x96, 0xF4, 0x29 + }, + { + 0x2D, 0xB3, 0xDC, 0x65, 0x72, 0xCF, 0x52, 0xEA, + 0x1D, 0x8C, 0xBA, 0xA1, 0x43, 0x1F, 0x11, 0x9D, + 0x87, 0x88, 0x24, 0xC2, 0x72, 0xDF, 0xB1, 0x86, + 0xCD, 0x11, 0x11, 0x03, 0x16, 0x12, 0xEC, 0x40, + 0xDA, 0xEE, 0x85, 0xAB, 0x98, 0xB9, 0x4C, 0x45, + 0x49, 0x80, 0x07, 0x3C, 0x9D, 0xF6, 0x72, 0xFB, + 0xB8, 0xCF, 0x07, 0x50, 0x3E, 0xDA, 0x0B, 0x20, + 0xE8, 0x8C, 0xBE, 0x05, 0x1B, 0xCB, 0x70, 0x55 + }, + { + 0x28, 0x47, 0xAF, 0x4D, 0x2E, 0x38, 0xAE, 0xA6, + 0x49, 0x83, 0x8A, 0xA2, 0x37, 0xB8, 0xC8, 0x62, + 0x2C, 0x1A, 0xE6, 0x56, 0x4C, 0x13, 0x71, 0xFB, + 0xE5, 0x0E, 0xF9, 0x6E, 0x07, 0x91, 0xF3, 0xB3, + 0xD4, 0x6E, 0x1D, 0xAF, 0x58, 0x96, 0xF5, 0xEC, + 0x90, 0xB6, 0x84, 0xA4, 0xF9, 0x6B, 0xD8, 0x02, + 0x88, 0xFD, 0x38, 0x66, 0xC9, 0x07, 0x9D, 0x68, + 0xB0, 0x8F, 0x7A, 0x8E, 0x0E, 0x9A, 0x7F, 0x3C + }, + { + 0xA6, 0xBA, 0xDC, 0x43, 0x8C, 0xAA, 0x08, 0xAC, + 0x44, 0xA2, 0xCA, 0x00, 0x71, 0x74, 0xEC, 0x6C, + 0x4E, 0xD1, 0x81, 0xC5, 0x0B, 0xFB, 0x36, 0x71, + 0x40, 0x2A, 0x1D, 0xF8, 0xEF, 0x21, 0x40, 0x13, + 0x0E, 0x9C, 0x29, 0x65, 0xE8, 0x36, 0x0E, 0x62, + 0x15, 0x4A, 0xA5, 0x39, 0xF6, 0x57, 0x67, 0x38, + 0x1D, 0xAE, 0x8B, 0x57, 0x9D, 0xB2, 0x4E, 0x92, + 0x3F, 0xF6, 0xBA, 0x73, 0xF7, 0xB1, 0x09, 0x6A + }, + { + 0x00, 0xB9, 0xE3, 0x7B, 0xF4, 0x0E, 0x45, 0x23, + 0xA3, 0x02, 0x7C, 0xBF, 0x13, 0x16, 0x40, 0x77, + 0x4F, 0x04, 0xE7, 0x0C, 0x3E, 0x82, 0x4A, 0xF8, + 0x3F, 0xFD, 0x22, 0xBC, 0x8F, 0x93, 0xF1, 0xEF, + 0x26, 0xE8, 0x49, 0x62, 0x8E, 0x5F, 0xB8, 0xB9, + 0x56, 0xFF, 0x6F, 0xB1, 0xAE, 0xCE, 0x95, 0x3E, + 0x12, 0xA0, 0x70, 0xBC, 0x58, 0x77, 0xE2, 0x98, + 0x3B, 0x3E, 0x6B, 0xC2, 0x8E, 0xC4, 0x15, 0x2D + }, + { + 0xD4, 0xEA, 0xC9, 0x23, 0x6D, 0x78, 0xD4, 0x3D, + 0x3F, 0x9C, 0xFB, 0x95, 0x22, 0xEB, 0x91, 0x96, + 0xB2, 0x60, 0xA1, 0xB9, 0x92, 0xE5, 0xB1, 0x21, + 0x8D, 0x9D, 0xFB, 0xEB, 0xD9, 0xB1, 0x17, 0x12, + 0xDB, 0xB9, 0xEC, 0x8A, 0x66, 0x06, 0x03, 0x06, + 0xB2, 0x6F, 0x00, 0xB3, 0x2F, 0xDC, 0xB0, 0x0D, + 0x3F, 0x6A, 0x5C, 0x9A, 0x70, 0x84, 0xC0, 0xCA, + 0x35, 0xB1, 0x70, 0x41, 0xC4, 0x52, 0xB0, 0xE8 + }, + { + 0xFC, 0x81, 0x13, 0xD7, 0xE4, 0x57, 0x5C, 0x73, + 0x5C, 0x6B, 0xF8, 0xE3, 0xA3, 0x50, 0x5D, 0xB7, + 0xD7, 0xF9, 0x17, 0x2D, 0x84, 0xEE, 0xBC, 0x56, + 0x39, 0x34, 0xAE, 0xF1, 0x4C, 0xCA, 0xB0, 0x75, + 0xE7, 0x56, 0x84, 0xF1, 0x11, 0xFF, 0xF5, 0xC4, + 0xFF, 0x27, 0x46, 0x1B, 0x6D, 0xE0, 0x5B, 0xA0, + 0x81, 0x49, 0xCD, 0xEB, 0x40, 0xD0, 0x44, 0xB4, + 0x0B, 0x83, 0x78, 0xD9, 0xD2, 0x8A, 0x9D, 0x6A + }, + { + 0x45, 0x36, 0xD7, 0xDC, 0xEB, 0x4D, 0xAE, 0x37, + 0x3F, 0x98, 0x91, 0xC4, 0x06, 0x7C, 0x83, 0xBE, + 0x8F, 0x5B, 0xDD, 0x56, 0xBC, 0x08, 0x03, 0xE6, + 0x0D, 0x15, 0x72, 0x9C, 0x6A, 0xAB, 0x96, 0x83, + 0x1A, 0x90, 0xFC, 0x6B, 0xAE, 0xE8, 0x74, 0xFB, + 0xBE, 0x63, 0x2E, 0x9E, 0xDB, 0x1F, 0x9E, 0xD5, + 0xC2, 0x56, 0x40, 0x69, 0x05, 0x1C, 0x79, 0xC2, + 0x63, 0x08, 0x81, 0xCB, 0x5A, 0x4F, 0x5B, 0xA1 + }, + { + 0x35, 0x75, 0x7E, 0xAB, 0x28, 0x08, 0xF1, 0xF8, + 0x9E, 0x00, 0x4A, 0x0D, 0x39, 0x9E, 0x03, 0xB8, + 0x7A, 0x3D, 0x05, 0xB5, 0x69, 0xBF, 0x6B, 0x56, + 0xC4, 0xF5, 0x38, 0x5B, 0xF9, 0x35, 0x2F, 0xC2, + 0x00, 0xD2, 0x20, 0x34, 0x3F, 0x86, 0x10, 0x6D, + 0x1A, 0x10, 0xCE, 0x12, 0xF6, 0xE0, 0xF7, 0xE4, + 0x03, 0x22, 0x8A, 0x1E, 0xDB, 0xB8, 0x0C, 0x3E, + 0xC6, 0xCB, 0x0A, 0x05, 0xE5, 0x27, 0x41, 0x04 + }, + { + 0x08, 0xB4, 0xD7, 0x3F, 0x65, 0xE0, 0x99, 0x59, + 0x27, 0x5A, 0x7B, 0x4E, 0x43, 0x9D, 0xD7, 0x9C, + 0xAF, 0xB0, 0x84, 0x48, 0x33, 0x88, 0x95, 0x31, + 0x5B, 0xD9, 0xC2, 0x3E, 0x65, 0x95, 0x33, 0x4C, + 0x90, 0xB8, 0x0D, 0x9E, 0x16, 0x6D, 0x95, 0x8D, + 0xE0, 0x7C, 0x93, 0xC4, 0x32, 0x39, 0xD6, 0x08, + 0x79, 0x56, 0x74, 0xAA, 0xB8, 0xC1, 0x88, 0x56, + 0xB2, 0xDC, 0x38, 0x02, 0x78, 0x39, 0xDD, 0x09 + }, + { + 0x29, 0xD5, 0xBB, 0xC9, 0x45, 0x42, 0xB5, 0x72, + 0xC0, 0x36, 0xE7, 0x7C, 0xF1, 0xDF, 0xE4, 0xCE, + 0xFD, 0x21, 0x5A, 0xDB, 0x89, 0x25, 0x97, 0xF6, + 0xF7, 0x8B, 0x31, 0x76, 0x28, 0x5E, 0x44, 0x23, + 0x33, 0x07, 0x89, 0xFE, 0xDE, 0x5E, 0x9C, 0x2D, + 0x0F, 0xE2, 0xC0, 0xC9, 0x69, 0xBC, 0x24, 0xBE, + 0xF3, 0x9E, 0xCD, 0xCA, 0xE2, 0x4B, 0xDC, 0x79, + 0x38, 0xD6, 0xA4, 0xFE, 0x7C, 0xFF, 0x98, 0x6A + }, + { + 0x22, 0x24, 0xD7, 0xA1, 0x4E, 0xF4, 0x21, 0xAC, + 0xB7, 0x97, 0x89, 0xC1, 0xD9, 0x68, 0x1A, 0x6D, + 0x24, 0x37, 0xEC, 0xA0, 0x1F, 0xBC, 0xC1, 0x70, + 0x01, 0xDE, 0x61, 0x2B, 0x24, 0x97, 0x06, 0xA2, + 0xE1, 0x6D, 0x06, 0xCD, 0x29, 0x53, 0xAB, 0xCE, + 0x72, 0x1C, 0xE0, 0xDD, 0xCD, 0xCE, 0xD9, 0x4F, + 0xAF, 0x5E, 0xC5, 0xE7, 0x36, 0x68, 0x10, 0x44, + 0x09, 0xBD, 0xF3, 0x75, 0x20, 0xE0, 0x43, 0x7C + }, + { + 0x06, 0xB4, 0x86, 0xCF, 0x1D, 0x8C, 0x70, 0x62, + 0xFA, 0xFD, 0x30, 0x10, 0x54, 0x11, 0x3B, 0x63, + 0xD5, 0x86, 0xCF, 0x94, 0x35, 0xC4, 0x4D, 0xFD, + 0x3E, 0xD1, 0x24, 0x81, 0xC8, 0x02, 0xAB, 0xD2, + 0x7D, 0x5A, 0xEE, 0x7D, 0xB9, 0xB4, 0x38, 0x7A, + 0x77, 0x02, 0xAB, 0x62, 0xF5, 0xDF, 0x5D, 0x28, + 0x4C, 0xCE, 0xB9, 0x20, 0xA6, 0xA0, 0xA4, 0x4D, + 0x89, 0x8A, 0x24, 0x23, 0xF5, 0xC8, 0xD0, 0x4E + }, + { + 0x7D, 0x9F, 0x27, 0x3C, 0x3F, 0xAF, 0x13, 0x1E, + 0x34, 0xF4, 0xFE, 0x86, 0xC8, 0xD6, 0x73, 0x23, + 0x9D, 0x12, 0x85, 0x84, 0x3C, 0xF5, 0xDE, 0x6A, + 0x0C, 0x7B, 0x6D, 0x68, 0xD8, 0xBC, 0x92, 0xAC, + 0x3F, 0xD5, 0x1E, 0x6C, 0x43, 0xC2, 0x64, 0x02, + 0x83, 0x8C, 0xA9, 0x4A, 0x3F, 0xD3, 0xEE, 0x0C, + 0xE8, 0xF9, 0x47, 0xE6, 0x9C, 0xD5, 0x57, 0x2E, + 0x17, 0x55, 0xE9, 0x95, 0xF0, 0x6F, 0xEF, 0xB7 + }, + { + 0x44, 0xF8, 0xC6, 0x5B, 0x4C, 0x6D, 0x11, 0xB9, + 0xE9, 0xAE, 0x06, 0x5D, 0xE6, 0x12, 0x9C, 0xB7, + 0xFF, 0x45, 0x5F, 0xCB, 0xAA, 0x44, 0xC2, 0x38, + 0x99, 0xD7, 0x2F, 0xD5, 0xC6, 0xB6, 0xED, 0x1F, + 0xB4, 0x65, 0xB3, 0x53, 0x56, 0x13, 0x91, 0x0F, + 0x4B, 0xBB, 0xA7, 0x33, 0x4C, 0x3A, 0x3E, 0x86, + 0xC1, 0xC2, 0x03, 0x04, 0xBF, 0x2C, 0x1A, 0x59, + 0x40, 0xA9, 0xFE, 0x03, 0xD4, 0x72, 0x7D, 0x24 + }, + { + 0x02, 0x98, 0xBA, 0xD1, 0xAF, 0x2E, 0x92, 0x42, + 0xE2, 0xC3, 0xFA, 0x1B, 0xA1, 0x33, 0xD1, 0xBB, + 0x3E, 0x59, 0xE2, 0xE6, 0xBE, 0xB0, 0x68, 0x10, + 0xCE, 0x15, 0x12, 0x8D, 0x45, 0xEE, 0x9B, 0x2B, + 0xE8, 0x1D, 0xA0, 0x20, 0x79, 0xE5, 0xE7, 0x14, + 0x26, 0xDB, 0xAD, 0x9E, 0xFF, 0x5E, 0x7E, 0x25, + 0xD6, 0x37, 0x93, 0x68, 0x47, 0x39, 0x7C, 0x4C, + 0x32, 0x81, 0x79, 0x0E, 0xC6, 0xB9, 0x74, 0x24 + }, + { + 0x3F, 0x3C, 0x28, 0x7D, 0x35, 0x89, 0xD7, 0xBE, + 0x29, 0x28, 0xCF, 0xB1, 0xB8, 0x48, 0x60, 0xA8, + 0x1E, 0x74, 0x22, 0x8D, 0x48, 0x90, 0x64, 0x7B, + 0x12, 0x5F, 0x1B, 0x11, 0xF1, 0xC5, 0x75, 0xA6, + 0x04, 0x00, 0x3F, 0x80, 0x60, 0xEE, 0xE2, 0xC4, + 0x24, 0x5A, 0xD0, 0xCB, 0x28, 0xAB, 0x2C, 0x2B, + 0xAE, 0xC2, 0x3A, 0x7E, 0x4C, 0x7A, 0x43, 0x46, + 0xA0, 0xB8, 0x1E, 0x97, 0xA9, 0x05, 0x6F, 0xB5 + }, + { + 0xAF, 0xE2, 0xD8, 0x7D, 0x57, 0x50, 0x60, 0x36, + 0xAD, 0x11, 0xF2, 0x3A, 0x8C, 0xA8, 0x91, 0x02, + 0x45, 0x68, 0xD1, 0xE3, 0xE8, 0x17, 0x4E, 0x9C, + 0x64, 0x3E, 0x28, 0x3B, 0x71, 0xA8, 0x91, 0x97, + 0x79, 0x1E, 0x6E, 0x97, 0x0F, 0xB9, 0xC2, 0x7D, + 0xF2, 0xF3, 0x4D, 0xFD, 0x57, 0xB7, 0x47, 0xBD, + 0x83, 0xA8, 0xC5, 0xFD, 0xE6, 0x6D, 0x6F, 0x9C, + 0x26, 0xA7, 0x26, 0x98, 0x23, 0x2B, 0x38, 0x7A + }, + { + 0xA0, 0xCB, 0xEF, 0x9D, 0xC8, 0x1C, 0xED, 0xFC, + 0xE7, 0x24, 0x94, 0xD0, 0x23, 0x40, 0x77, 0x4C, + 0x28, 0x4C, 0x8A, 0x0A, 0x65, 0xC8, 0xD4, 0xAB, + 0x81, 0x13, 0xC8, 0xCF, 0xB4, 0xDD, 0x83, 0x88, + 0x9B, 0x33, 0x44, 0xD0, 0xAD, 0x7B, 0xAA, 0x38, + 0xD1, 0xE7, 0x13, 0x88, 0x40, 0xD9, 0xB3, 0x5D, + 0x0F, 0x8A, 0x76, 0x5B, 0x68, 0x2D, 0xC9, 0x18, + 0x49, 0xE7, 0x72, 0x7D, 0x3F, 0xD7, 0x0A, 0xCD + }, + { + 0xCA, 0xB1, 0xD4, 0x21, 0xDB, 0x68, 0xE2, 0x1A, + 0xAE, 0x46, 0xC1, 0x39, 0x18, 0x00, 0xA9, 0xF7, + 0x5F, 0xCE, 0xCA, 0x9A, 0x3B, 0x27, 0xF9, 0x0F, + 0xD0, 0x80, 0x9C, 0xC6, 0x59, 0x8A, 0x7C, 0xC6, + 0x7C, 0x53, 0x78, 0x56, 0xD9, 0xEE, 0xBE, 0xD9, + 0xBA, 0xAA, 0xB7, 0xDD, 0x3D, 0x03, 0xD8, 0x23, + 0xB2, 0xBA, 0x35, 0x43, 0x75, 0x1B, 0x69, 0x61, + 0x2E, 0x9B, 0x40, 0x14, 0x00, 0xE6, 0x8E, 0x4B + }, + { + 0xC7, 0xA5, 0x3D, 0xEB, 0xEB, 0x6A, 0xAB, 0x65, + 0x23, 0x8D, 0xFB, 0xAF, 0x2D, 0x18, 0x2C, 0x03, + 0x92, 0x98, 0x99, 0x5D, 0x74, 0x46, 0xA9, 0x28, + 0xFC, 0x09, 0x85, 0xC8, 0x3D, 0x79, 0x30, 0x76, + 0x22, 0xC7, 0xD2, 0x10, 0xD5, 0xDA, 0xCC, 0xCC, + 0x0D, 0xAE, 0x9E, 0x67, 0xAA, 0x28, 0x81, 0x7A, + 0x3E, 0x9E, 0x78, 0x04, 0x8B, 0xB1, 0xE0, 0x23, + 0xC7, 0x32, 0xB6, 0x7F, 0xE0, 0x12, 0x24, 0x60 + }, + { + 0x0B, 0x95, 0xA4, 0xF1, 0x15, 0x02, 0x9A, 0x00, + 0x94, 0x03, 0xB1, 0xBB, 0xB8, 0xD8, 0x62, 0x58, + 0x42, 0x4F, 0x52, 0xE4, 0xFD, 0xBD, 0x07, 0x08, + 0x91, 0x6A, 0xF7, 0xEF, 0xA5, 0x0E, 0x32, 0x5F, + 0x97, 0xF5, 0x9B, 0x62, 0x27, 0x3D, 0xED, 0x0D, + 0xFF, 0xD0, 0x57, 0x73, 0xA8, 0x5B, 0x3C, 0x64, + 0xE6, 0x01, 0x00, 0xC8, 0xC8, 0xFF, 0xB9, 0xF8, + 0xA4, 0x9B, 0x2E, 0x54, 0xA0, 0xD8, 0x93, 0x1F + }, + { + 0xBC, 0xFE, 0x1A, 0xF6, 0x8D, 0xF1, 0x02, 0x4B, + 0x6C, 0x25, 0x42, 0xBC, 0x6D, 0x63, 0x73, 0xAC, + 0x7C, 0x3F, 0x0D, 0x78, 0x52, 0x55, 0x8D, 0x26, + 0x76, 0x77, 0x04, 0x28, 0x2F, 0x99, 0x1A, 0x77, + 0x3E, 0x71, 0x89, 0xBB, 0x63, 0xC8, 0x4A, 0xB9, + 0x52, 0x4C, 0x6B, 0x7A, 0x0F, 0xFE, 0x0F, 0xAD, + 0x35, 0xD5, 0x72, 0x3D, 0xDB, 0xAA, 0x27, 0x11, + 0x36, 0x7B, 0x99, 0xEA, 0xED, 0xA6, 0x82, 0x76 + }, + { + 0x52, 0xC5, 0x39, 0xCB, 0xEE, 0x86, 0xE7, 0xEF, + 0x8B, 0x87, 0xAD, 0xAD, 0x4C, 0xFD, 0xD6, 0x0E, + 0xFC, 0xCE, 0xC9, 0x8E, 0x69, 0x4E, 0xAD, 0xC0, + 0x2E, 0x5B, 0x51, 0xAD, 0x99, 0x97, 0x71, 0xDA, + 0xEF, 0x95, 0xB2, 0x43, 0x95, 0xAC, 0x68, 0x3B, + 0xD7, 0xCC, 0xBF, 0xE1, 0x92, 0x44, 0x0C, 0x0F, + 0x77, 0x61, 0xFB, 0xBB, 0x1F, 0x50, 0x51, 0x32, + 0xB2, 0xCC, 0x7C, 0xD7, 0x38, 0xF2, 0xDA, 0xB7 + }, + { + 0x43, 0x91, 0x3B, 0x16, 0x19, 0xC2, 0x87, 0xFF, + 0xE0, 0x09, 0xA9, 0x6D, 0x5B, 0xCB, 0x6D, 0x6E, + 0xA9, 0x17, 0x73, 0x1A, 0x91, 0x76, 0xE7, 0x1A, + 0x5E, 0xC7, 0xD2, 0x84, 0x3B, 0xBF, 0x31, 0xBB, + 0x85, 0x30, 0xBA, 0x73, 0xF6, 0x3C, 0xA1, 0xF7, + 0x43, 0x6B, 0x1A, 0xDD, 0x72, 0x37, 0x92, 0x2B, + 0xAC, 0x2D, 0x20, 0x7C, 0xE5, 0x14, 0xB1, 0x8F, + 0x9C, 0x2F, 0xD9, 0xE4, 0x75, 0x0A, 0xD8, 0xCC + }, + { + 0x63, 0xEB, 0x15, 0x93, 0x91, 0xA2, 0x96, 0xD6, + 0xA7, 0xF0, 0x3A, 0xF9, 0x00, 0xC6, 0x47, 0x72, + 0x82, 0x97, 0x4D, 0x5A, 0xDB, 0xB3, 0xE6, 0x80, + 0x11, 0xB1, 0x49, 0xB8, 0x1A, 0xBC, 0x53, 0x6E, + 0xE4, 0xA4, 0xDA, 0x4B, 0xE4, 0x66, 0x3D, 0x68, + 0x5A, 0x36, 0xCA, 0x7B, 0xC8, 0xF0, 0x74, 0xFC, + 0x06, 0x53, 0xC5, 0xE4, 0x06, 0x32, 0xED, 0xB6, + 0x3D, 0x0A, 0x2D, 0x69, 0x8B, 0xF9, 0x52, 0x6F + }, + { + 0x0C, 0xAB, 0x8B, 0x8B, 0x00, 0x15, 0xE2, 0xC1, + 0x8F, 0xEF, 0x62, 0xD2, 0x5C, 0x76, 0x1E, 0xCB, + 0xE4, 0x56, 0x56, 0x46, 0xFE, 0xCB, 0x47, 0x60, + 0x12, 0xCF, 0xAE, 0xC3, 0xD3, 0xE8, 0x7B, 0x24, + 0x61, 0x3B, 0xAD, 0xB7, 0x36, 0x00, 0x7A, 0x43, + 0x5B, 0x6E, 0xCE, 0x08, 0x0E, 0xD1, 0xA9, 0x30, + 0x72, 0xC1, 0x61, 0x16, 0x34, 0xAA, 0x7A, 0x41, + 0xB1, 0x88, 0x60, 0x3B, 0x69, 0x8B, 0xFC, 0xD9 + }, + { + 0xD3, 0xC0, 0xD5, 0xA2, 0x6B, 0xAC, 0x2C, 0x38, + 0xD9, 0x7A, 0x67, 0x0C, 0xE6, 0x56, 0xB9, 0xDA, + 0xA6, 0x5B, 0xDD, 0x64, 0xA7, 0xEF, 0x03, 0xAE, + 0xDE, 0x67, 0x43, 0xB5, 0x5C, 0x0D, 0x7B, 0x3C, + 0xB0, 0x28, 0x0D, 0xD9, 0x6A, 0x09, 0x3E, 0x1B, + 0x9F, 0x21, 0xAC, 0x4F, 0x83, 0xB2, 0x6D, 0xDE, + 0x34, 0x06, 0xE1, 0xED, 0x0C, 0xA9, 0xE6, 0x4C, + 0x31, 0x18, 0x0B, 0x09, 0x01, 0xEC, 0x38, 0xBB + }, + { + 0x0F, 0xEB, 0xAC, 0x23, 0xE3, 0x83, 0xFB, 0xE4, + 0x54, 0x8F, 0xAF, 0x12, 0xE5, 0xB9, 0xAA, 0x16, + 0xF4, 0xA7, 0x25, 0x41, 0x72, 0x39, 0xA2, 0x91, + 0xA8, 0xC1, 0x47, 0x42, 0x32, 0x7D, 0xA6, 0x08, + 0xBF, 0x79, 0xA3, 0xA0, 0x58, 0x4E, 0xE6, 0xC8, + 0x77, 0x0A, 0xD3, 0xD2, 0xC6, 0x33, 0xDC, 0xB6, + 0x9E, 0x18, 0x87, 0x0B, 0xB0, 0x67, 0x25, 0x65, + 0x44, 0x1E, 0x3C, 0xC0, 0x24, 0x43, 0x6D, 0x35 + }, + { + 0xEE, 0x58, 0x20, 0xC1, 0xB4, 0xDF, 0x5F, 0x74, + 0x85, 0x7F, 0xD3, 0x54, 0x75, 0x48, 0x6C, 0x8B, + 0x7D, 0x82, 0xBA, 0xD6, 0x6E, 0xE5, 0x48, 0x73, + 0xC6, 0xBC, 0xF2, 0x8B, 0x16, 0x51, 0x02, 0x89, + 0x11, 0xF4, 0x78, 0x1A, 0xDF, 0x06, 0x38, 0xD6, + 0x22, 0xEA, 0x23, 0x36, 0xBD, 0x8D, 0x4B, 0xEC, + 0x6D, 0xB1, 0x28, 0x34, 0x5B, 0xAE, 0xBE, 0x77, + 0x98, 0x7A, 0xCA, 0xE5, 0xAC, 0x6B, 0xC3, 0xB4 + }, + { + 0xD2, 0x2E, 0x99, 0xF8, 0x49, 0x44, 0x69, 0x75, + 0x57, 0xAC, 0x3D, 0x43, 0x43, 0xD2, 0x0B, 0x80, + 0xE7, 0xDA, 0xAA, 0x49, 0xB4, 0x64, 0x4F, 0xD9, + 0x4F, 0x53, 0x01, 0x47, 0xF7, 0xB1, 0x6B, 0x94, + 0xB1, 0x51, 0xAA, 0x99, 0xD2, 0xB6, 0xC3, 0x69, + 0xC5, 0x88, 0x64, 0xC7, 0xEC, 0x81, 0xD8, 0x4B, + 0x16, 0x61, 0xDC, 0x59, 0xF0, 0x3C, 0x55, 0x29, + 0x02, 0xC2, 0xD6, 0xD9, 0x24, 0x89, 0xCE, 0xBA + }, + { + 0xDA, 0x00, 0x7E, 0xF4, 0x5F, 0xF9, 0xB5, 0xFE, + 0x5E, 0x72, 0xDB, 0x08, 0x9D, 0x02, 0x15, 0x21, + 0xEC, 0xA3, 0x36, 0x3A, 0xA6, 0x8C, 0x14, 0xF6, + 0xF4, 0xD5, 0x74, 0xFF, 0x67, 0x90, 0xE8, 0x1E, + 0x08, 0xA9, 0xC9, 0x3C, 0xE6, 0x76, 0xAD, 0x22, + 0x11, 0x31, 0xD4, 0x40, 0x92, 0x87, 0x55, 0xB9, + 0x52, 0x82, 0xA4, 0x50, 0xE0, 0x07, 0x48, 0x6C, + 0xFA, 0xD3, 0x02, 0xBE, 0x6F, 0x68, 0xD4, 0x1B + }, + { + 0x3B, 0xA6, 0xB8, 0xC6, 0x74, 0x86, 0x77, 0x37, + 0x00, 0xE5, 0xBA, 0x93, 0xF1, 0xF3, 0xEF, 0xF7, + 0x10, 0xDD, 0xD3, 0x6C, 0x85, 0x0B, 0x80, 0x16, + 0x10, 0xD8, 0xF0, 0x47, 0x4F, 0x73, 0x3D, 0x68, + 0xCC, 0xD6, 0xF6, 0x2C, 0x16, 0x15, 0xD3, 0x82, + 0x3A, 0x85, 0x67, 0x26, 0xC1, 0x6B, 0xF4, 0x48, + 0x1F, 0xBF, 0xCC, 0x8B, 0xC0, 0x19, 0x32, 0xE7, + 0x9B, 0xEC, 0xB1, 0x59, 0xA1, 0x7B, 0x17, 0x14 + }, + { + 0xBA, 0x51, 0x7D, 0xEC, 0x1F, 0xF7, 0x6B, 0xEB, + 0xB9, 0xFD, 0xCD, 0x0C, 0x17, 0x5D, 0x5D, 0xC0, + 0xCA, 0x9D, 0x41, 0xC5, 0x3D, 0x10, 0x46, 0x85, + 0x14, 0xB7, 0x0C, 0x8E, 0x60, 0x7E, 0x4A, 0x24, + 0x73, 0xBA, 0x06, 0x86, 0x46, 0xAF, 0xF0, 0x80, + 0xBF, 0xFE, 0xDC, 0x7C, 0x7D, 0x26, 0x40, 0x6B, + 0xAE, 0x1B, 0xAC, 0x32, 0x16, 0x66, 0x62, 0xB0, + 0x40, 0x14, 0xD8, 0x48, 0x13, 0x30, 0x7E, 0x44 + }, + { + 0xC6, 0x7F, 0x9A, 0x98, 0x09, 0x57, 0x4F, 0x39, + 0x06, 0x12, 0x45, 0xC2, 0xC9, 0x82, 0xA4, 0x24, + 0x01, 0xAC, 0x93, 0x1D, 0x68, 0xC0, 0xD8, 0x5D, + 0x8C, 0xB7, 0xFB, 0x58, 0x0F, 0x38, 0x4D, 0x3F, + 0xCD, 0x2E, 0x14, 0xE7, 0x3C, 0x72, 0x4D, 0xDA, + 0x6E, 0xA5, 0x26, 0x7E, 0xAE, 0xCC, 0x11, 0xCC, + 0x90, 0xAE, 0x23, 0x73, 0x10, 0x2B, 0x11, 0x90, + 0x5C, 0xF8, 0x9F, 0x5E, 0xDD, 0xCC, 0xD3, 0x26 + }, + { + 0x1C, 0x35, 0x66, 0x78, 0x70, 0x14, 0xED, 0x78, + 0x56, 0x3F, 0x24, 0x4B, 0x44, 0x78, 0x99, 0x79, + 0xDF, 0x25, 0xF7, 0xC9, 0x48, 0xF2, 0xF4, 0x48, + 0xB2, 0xFF, 0xC3, 0x66, 0xB0, 0xD0, 0x80, 0x15, + 0x38, 0x1C, 0xB5, 0x7F, 0x0F, 0x7D, 0xDD, 0x6B, + 0x17, 0x8C, 0xCD, 0x92, 0xAD, 0xE6, 0x60, 0xB2, + 0xB3, 0xDA, 0xE5, 0x66, 0x4A, 0xC5, 0x39, 0xCF, + 0x97, 0xAC, 0x6B, 0x36, 0xD3, 0xFD, 0xF1, 0x82 + }, + { + 0x0D, 0xCB, 0x79, 0x4A, 0xF7, 0x4E, 0x67, 0x9E, + 0x34, 0xF5, 0xA3, 0x50, 0x74, 0x6A, 0xFE, 0xCF, + 0xD1, 0x5C, 0x97, 0x40, 0x2F, 0xFD, 0x08, 0xE2, + 0xB9, 0xCD, 0x8F, 0x2E, 0x9B, 0xC9, 0x61, 0x52, + 0x14, 0xD2, 0x52, 0x52, 0x2D, 0xBB, 0x18, 0xE2, + 0x21, 0x39, 0x25, 0xB7, 0x9C, 0x3B, 0x30, 0x48, + 0xCB, 0x75, 0xEA, 0x7B, 0x46, 0x8E, 0x95, 0xB3, + 0x6E, 0x02, 0xCA, 0x66, 0xD9, 0xDA, 0xF9, 0x53 + }, + { + 0xC1, 0xB2, 0xDD, 0xF4, 0x55, 0x2C, 0x64, 0x25, + 0x38, 0x21, 0x5E, 0x0D, 0x82, 0x28, 0xC2, 0xBB, + 0xC4, 0x46, 0xA6, 0x78, 0x92, 0x55, 0x6B, 0x55, + 0xA4, 0xD9, 0x14, 0x22, 0xD4, 0x1C, 0x64, 0xCF, + 0x5E, 0x6C, 0x33, 0x4F, 0x88, 0xC9, 0x81, 0x8E, + 0x09, 0x9F, 0x2D, 0x46, 0x06, 0xBC, 0x59, 0x60, + 0xB4, 0x6C, 0x6C, 0x1A, 0x25, 0x04, 0xC2, 0x50, + 0xA3, 0x48, 0xBA, 0x6C, 0xF6, 0x85, 0x31, 0x11 + }, + { + 0x1E, 0x81, 0xCC, 0xB9, 0xF6, 0xE1, 0x22, 0xB3, + 0x7B, 0x12, 0x13, 0x08, 0x81, 0x6F, 0xD4, 0xCB, + 0x16, 0xAA, 0x73, 0xE3, 0x09, 0xD9, 0x63, 0xF0, + 0x6A, 0xF3, 0x44, 0x71, 0x42, 0xEE, 0x48, 0x50, + 0x52, 0x38, 0x6F, 0x00, 0xC7, 0xD5, 0xF7, 0x7C, + 0x0E, 0xCB, 0x3D, 0x7F, 0x09, 0x89, 0xDA, 0x37, + 0xF9, 0xD4, 0xF7, 0xC8, 0xA7, 0x67, 0x71, 0x28, + 0xEE, 0x83, 0x30, 0x2A, 0xB9, 0x7F, 0x51, 0x0A + }, + { + 0xB0, 0x3C, 0x67, 0x36, 0x83, 0x47, 0x5C, 0xE6, + 0xB1, 0xD0, 0x8F, 0xAA, 0xB4, 0x36, 0x6B, 0xB6, + 0x21, 0x8C, 0x11, 0xAA, 0x57, 0xA6, 0x71, 0x5B, + 0xD3, 0xEC, 0x7B, 0x57, 0xB2, 0xF2, 0x39, 0x60, + 0xFC, 0x18, 0xE8, 0x37, 0x17, 0xD2, 0x12, 0x72, + 0xF9, 0xA6, 0x03, 0x36, 0xD0, 0xE1, 0x16, 0xB9, + 0x05, 0x7A, 0x79, 0xC4, 0x75, 0x36, 0x5B, 0x92, + 0xA8, 0x4C, 0xEE, 0x9C, 0x9F, 0x94, 0xAF, 0xCA + }, + { + 0x4F, 0xED, 0x51, 0xEE, 0x8B, 0x26, 0x0E, 0x5C, + 0x6F, 0xCC, 0x23, 0xAC, 0x01, 0x88, 0x3D, 0xAD, + 0x31, 0xA9, 0xDE, 0x19, 0x17, 0x8D, 0x69, 0x7A, + 0xF1, 0x51, 0x9A, 0x07, 0xC2, 0x9A, 0x03, 0x51, + 0x8D, 0xBC, 0x45, 0xB6, 0xE1, 0x49, 0xCE, 0xE7, + 0x63, 0x2B, 0x15, 0xC0, 0xA5, 0xC6, 0x4D, 0x7E, + 0xCD, 0x40, 0x34, 0x79, 0x04, 0x6F, 0xF9, 0xBF, + 0xFD, 0x33, 0xD3, 0x5E, 0x35, 0x09, 0x79, 0xD0 + }, + { + 0x0E, 0x6A, 0xDB, 0xCD, 0xA1, 0x54, 0x8D, 0x5F, + 0xD4, 0xF6, 0x02, 0x97, 0x4B, 0xCA, 0x36, 0xE5, + 0x41, 0x36, 0x71, 0x96, 0x8E, 0xB2, 0x91, 0x1A, + 0xB3, 0x95, 0x62, 0x1D, 0xAA, 0x09, 0x60, 0x88, + 0xDA, 0x1E, 0xFE, 0x4C, 0x7D, 0xA5, 0xAF, 0x4D, + 0xD7, 0x56, 0x52, 0x81, 0xEE, 0x98, 0x95, 0x40, + 0xC2, 0x11, 0x92, 0x08, 0x4D, 0x4D, 0x9F, 0xC7, + 0xD4, 0xD4, 0x5E, 0x24, 0xCC, 0xB4, 0x93, 0x12 + }, + { + 0xB5, 0x9F, 0xA3, 0xE2, 0xAC, 0x2F, 0x50, 0x5B, + 0x2B, 0x1B, 0x49, 0x60, 0xE9, 0xC5, 0xAB, 0x4B, + 0x5E, 0xCC, 0x1B, 0x0F, 0x70, 0xB0, 0xEB, 0x18, + 0xCF, 0x90, 0x06, 0xA6, 0xBA, 0x84, 0x12, 0xEA, + 0x18, 0x73, 0x7A, 0x82, 0x57, 0xF8, 0x77, 0xC2, + 0x45, 0x74, 0xCE, 0xF3, 0x72, 0x42, 0x2B, 0x2F, + 0xE5, 0x53, 0x50, 0x6D, 0x7F, 0x83, 0xB1, 0x14, + 0xE2, 0x87, 0x1A, 0xCA, 0xA9, 0xAD, 0x4F, 0x10 + }, + { + 0xD3, 0x45, 0xC4, 0x58, 0x01, 0x88, 0xE9, 0x0B, + 0x46, 0x28, 0x71, 0x14, 0x49, 0x40, 0x6E, 0xB9, + 0xE2, 0x4E, 0xF6, 0xDA, 0x07, 0xBD, 0x93, 0x29, + 0x64, 0xD1, 0xC0, 0x82, 0xEE, 0x57, 0x46, 0x19, + 0x4F, 0x76, 0x56, 0xE9, 0xD5, 0xC6, 0x28, 0x00, + 0x70, 0x32, 0x9E, 0x32, 0xF6, 0x01, 0xD2, 0x79, + 0xA7, 0xCA, 0x0E, 0x58, 0x48, 0xE1, 0xBE, 0x08, + 0xE3, 0xF8, 0x91, 0xDF, 0xB2, 0x86, 0x95, 0x05 + }, + { + 0x91, 0xFA, 0x12, 0x36, 0x91, 0xAA, 0x8D, 0x8F, + 0x02, 0x88, 0xC8, 0x4E, 0x41, 0x7A, 0x61, 0xCE, + 0x74, 0xDE, 0xC4, 0x5B, 0x43, 0x6A, 0x46, 0xB7, + 0x42, 0x34, 0x57, 0x39, 0x60, 0x74, 0x28, 0xCF, + 0x20, 0xD1, 0x49, 0xFD, 0x43, 0x8B, 0xC9, 0x3E, + 0x6E, 0x88, 0x91, 0x97, 0x7D, 0x8F, 0xDE, 0x77, + 0xAB, 0x42, 0x82, 0xF0, 0xA3, 0x22, 0xA6, 0x65, + 0x50, 0x73, 0xF6, 0x2B, 0x66, 0xC0, 0x92, 0x46 + }, + { + 0x2E, 0x2D, 0x97, 0x7C, 0xEB, 0x45, 0x7E, 0xC9, + 0x65, 0xF9, 0xFC, 0xE2, 0x06, 0x22, 0x9C, 0x67, + 0x98, 0x2B, 0x51, 0xDE, 0x87, 0x5F, 0x93, 0xCB, + 0xA5, 0x0B, 0x77, 0x88, 0xB1, 0xEF, 0xFF, 0xD1, + 0xB7, 0x39, 0x0F, 0x5F, 0x8B, 0x77, 0xFA, 0x94, + 0xA5, 0x54, 0x04, 0xA7, 0x0B, 0x84, 0x00, 0x8D, + 0xF0, 0xD1, 0xF0, 0xF4, 0x37, 0xA5, 0xB6, 0x30, + 0x4C, 0xDB, 0x73, 0x39, 0x43, 0x23, 0xF4, 0x58 + }, + { + 0x06, 0xD9, 0xCF, 0x01, 0x43, 0xA4, 0x4F, 0x35, + 0x35, 0x28, 0xF2, 0x53, 0x7C, 0xEF, 0x8E, 0xFF, + 0x1E, 0xA0, 0xA0, 0xC5, 0xF4, 0x05, 0x20, 0xB2, + 0xA1, 0x70, 0xAF, 0x73, 0x63, 0xD9, 0x4D, 0x42, + 0x34, 0x31, 0x3C, 0x73, 0xF3, 0xF9, 0x45, 0xDF, + 0x5A, 0x15, 0x8B, 0x5B, 0x05, 0x60, 0xC9, 0x16, + 0x59, 0xFD, 0x7A, 0x18, 0xFE, 0xE1, 0x27, 0x78, + 0x6F, 0x5A, 0xD7, 0xC6, 0xD8, 0xDC, 0xB8, 0x6D + }, + { + 0x69, 0xE2, 0x19, 0x39, 0xF2, 0x29, 0x8C, 0x0D, + 0xF3, 0x08, 0x9D, 0xA4, 0xC2, 0xE6, 0x2C, 0x53, + 0xAA, 0x1D, 0x70, 0x97, 0x94, 0xEF, 0x26, 0x5B, + 0xAB, 0xDA, 0xFF, 0x48, 0xE2, 0xB0, 0xBA, 0xFB, + 0x30, 0xDB, 0x1B, 0x3B, 0x86, 0xB4, 0x2E, 0x28, + 0x54, 0x2C, 0x62, 0x48, 0x9D, 0x58, 0x0F, 0xF3, + 0xC7, 0x40, 0x6D, 0x9B, 0xB3, 0xC6, 0xCE, 0xA4, + 0xA0, 0xA5, 0x6F, 0x6E, 0x33, 0xEA, 0xA9, 0x8D + }, + { + 0x2A, 0xD0, 0x39, 0x03, 0x5E, 0x12, 0x99, 0x20, + 0xF7, 0xD0, 0xE2, 0x5B, 0x47, 0xDE, 0x5B, 0x09, + 0x40, 0x4F, 0x97, 0xBB, 0xB8, 0xBC, 0x55, 0xF5, + 0x19, 0x51, 0x7F, 0x5B, 0xAE, 0x01, 0xA7, 0xD6, + 0xC1, 0xC7, 0xD7, 0x30, 0x0E, 0xB2, 0x23, 0xE0, + 0xAF, 0xE7, 0xDA, 0xF7, 0xDA, 0xEF, 0x7B, 0x1B, + 0xDB, 0xC0, 0xAE, 0x96, 0xBA, 0x43, 0x31, 0xDB, + 0x57, 0xFB, 0x9C, 0xCA, 0x04, 0xF3, 0xA9, 0x55 + }, + { + 0x94, 0xC2, 0x66, 0x60, 0xFD, 0x6B, 0x3E, 0xD8, + 0xA8, 0x1D, 0x9D, 0x7F, 0x15, 0xEA, 0x54, 0x02, + 0x4F, 0x48, 0xB3, 0x57, 0x13, 0xBA, 0xA3, 0x81, + 0x3A, 0x75, 0x0D, 0xE5, 0xF5, 0x7C, 0x9A, 0x3A, + 0xBB, 0xE6, 0x2F, 0x47, 0x52, 0xD9, 0x83, 0x72, + 0xFA, 0x1B, 0x48, 0x31, 0x1B, 0xA4, 0xBF, 0xC0, + 0x7E, 0xEB, 0x82, 0xEF, 0x6D, 0x4E, 0x65, 0x66, + 0x90, 0x40, 0x3F, 0x84, 0x2A, 0x41, 0x51, 0x08 + }, + { + 0x3A, 0x39, 0x69, 0xC5, 0xEB, 0xA2, 0x08, 0xBE, + 0xA6, 0x9E, 0x05, 0x62, 0xDE, 0xC0, 0x34, 0x77, + 0x69, 0x54, 0x5A, 0x01, 0x5C, 0xC9, 0xFB, 0x99, + 0x4E, 0x8C, 0x6B, 0x56, 0x22, 0x72, 0x36, 0xA3, + 0xA3, 0x6A, 0x1D, 0x5C, 0x88, 0x55, 0xAB, 0x15, + 0x15, 0x46, 0xA9, 0xD4, 0x7B, 0xC8, 0x7E, 0x21, + 0x07, 0x78, 0xF8, 0xE7, 0x44, 0x5E, 0x5D, 0x7C, + 0x83, 0x13, 0xBD, 0x44, 0x92, 0x9E, 0x49, 0x31 + }, + { + 0x20, 0x07, 0xAE, 0xA5, 0x10, 0x62, 0xC8, 0x55, + 0x27, 0x4A, 0x77, 0xA9, 0x63, 0x97, 0xA5, 0x69, + 0xAE, 0x5F, 0x07, 0x63, 0xDE, 0x76, 0x69, 0x37, + 0x32, 0xC8, 0xCD, 0x1D, 0x84, 0x6A, 0x33, 0x4E, + 0x68, 0x18, 0x09, 0xBC, 0x81, 0x73, 0x09, 0xD0, + 0xF2, 0xBC, 0x6F, 0xA9, 0x84, 0xF2, 0x7E, 0x87, + 0x75, 0x2A, 0x22, 0x8F, 0xAC, 0x53, 0x61, 0x6A, + 0xDF, 0x0F, 0xB5, 0xCC, 0x36, 0x09, 0xDA, 0x6B + }, + { + 0x05, 0x7C, 0x2C, 0x9C, 0x25, 0x7B, 0x28, 0x9C, + 0xB3, 0x8F, 0x20, 0xAE, 0xFC, 0x5C, 0x64, 0x4F, + 0xAC, 0x3F, 0xE1, 0x8B, 0xCE, 0x91, 0x0C, 0x5B, + 0xF5, 0x43, 0x86, 0x57, 0x2D, 0xE6, 0x4D, 0x8C, + 0xC5, 0x0D, 0xD2, 0x59, 0xA2, 0xE1, 0xE9, 0x98, + 0x1F, 0x42, 0x4B, 0x10, 0xCB, 0x44, 0x76, 0x7B, + 0xDB, 0x6D, 0x5F, 0x7D, 0x7E, 0xFC, 0x49, 0xF7, + 0xC4, 0xB5, 0xF9, 0xBC, 0x12, 0xDA, 0x8B, 0x27 + }, + { + 0xBA, 0x85, 0xFE, 0x52, 0xD0, 0xE9, 0x2C, 0xF8, + 0xE2, 0xFC, 0xA0, 0xEB, 0xC7, 0x0A, 0x6E, 0x9E, + 0x0C, 0x4D, 0x80, 0x81, 0x2C, 0x84, 0xEC, 0xEA, + 0x1D, 0xB2, 0x03, 0xD7, 0xD8, 0xFF, 0xEE, 0x31, + 0x59, 0x57, 0xBF, 0x51, 0x5B, 0x5C, 0xEC, 0xFD, + 0x6A, 0x8F, 0x93, 0xAF, 0xC3, 0xCE, 0x10, 0x5D, + 0x7A, 0x74, 0xD1, 0xE6, 0x1A, 0x1C, 0x5A, 0x92, + 0xBF, 0xA2, 0xD2, 0xFE, 0x75, 0xD4, 0x4A, 0x88 + }, + { + 0x07, 0xAE, 0x74, 0xD3, 0x7B, 0x45, 0x59, 0xE6, + 0x86, 0x28, 0x71, 0x5F, 0x99, 0xC5, 0x08, 0xAE, + 0xA6, 0xAE, 0xFF, 0x96, 0xD4, 0xED, 0x66, 0x44, + 0xC4, 0x16, 0x56, 0x47, 0x2A, 0x62, 0x0A, 0x7B, + 0x1B, 0x19, 0xB8, 0x29, 0x0B, 0x2B, 0x23, 0x6D, + 0xE8, 0xD2, 0xA7, 0x5E, 0x28, 0x04, 0x28, 0xB1, + 0x50, 0x96, 0xC7, 0x55, 0x9C, 0x50, 0x64, 0x9E, + 0x41, 0xC8, 0x6C, 0x22, 0x8D, 0x8C, 0xD3, 0x94 + }, + { + 0x3F, 0x41, 0xCA, 0x31, 0x3D, 0xF2, 0xDF, 0x27, + 0x1B, 0xEE, 0x53, 0xB7, 0x9C, 0xB1, 0x6A, 0xBC, + 0xFA, 0x77, 0x31, 0x7F, 0xFF, 0x92, 0x68, 0x4A, + 0x21, 0x6F, 0x1D, 0xB5, 0x5D, 0x8F, 0x00, 0xBC, + 0x95, 0xF9, 0x4D, 0x37, 0xD6, 0xC2, 0xC8, 0xC0, + 0xDC, 0xAB, 0xE3, 0x79, 0x44, 0x96, 0x3B, 0x14, + 0xF5, 0xE8, 0xE9, 0xC6, 0xCF, 0xAA, 0xD7, 0x88, + 0x89, 0x49, 0x19, 0x48, 0x0C, 0xFE, 0x6B, 0xF8 + }, + { + 0xE3, 0x2A, 0xEB, 0x86, 0x22, 0x55, 0x56, 0x49, + 0xAA, 0xBC, 0x24, 0xE6, 0x84, 0xDA, 0xE2, 0x66, + 0xFA, 0x23, 0xE1, 0xF8, 0xEA, 0x50, 0xFA, 0x60, + 0x0D, 0xD5, 0xEE, 0xAE, 0x45, 0x3A, 0x66, 0x2A, + 0xF4, 0xF6, 0x4A, 0xD8, 0x5D, 0xB9, 0x29, 0x1E, + 0xF9, 0xCD, 0xB1, 0x34, 0x18, 0xDA, 0x42, 0x6D, + 0x3E, 0xFF, 0x41, 0x8A, 0x6C, 0x1A, 0x61, 0x76, + 0xDC, 0x92, 0xB9, 0xEE, 0x06, 0x8F, 0x2B, 0x33 + }, + { + 0x7D, 0x2B, 0xFB, 0x1F, 0xBA, 0xE8, 0x7C, 0x66, + 0x20, 0xB1, 0xE6, 0x00, 0xDE, 0x15, 0x21, 0x07, + 0xAE, 0x71, 0xE5, 0xE2, 0xA0, 0xF6, 0xC9, 0xB5, + 0x9A, 0xA9, 0x16, 0x9D, 0xD2, 0x18, 0xE7, 0x10, + 0x1F, 0x08, 0xE1, 0xA3, 0xE8, 0x60, 0x0B, 0x85, + 0x38, 0x00, 0x91, 0xD3, 0xFD, 0x1B, 0x81, 0x2D, + 0xFB, 0xF0, 0xBF, 0x95, 0xF6, 0xC9, 0x92, 0x52, + 0x9F, 0x46, 0x33, 0x07, 0x65, 0xAD, 0x36, 0x15 + }, + { + 0x7F, 0x29, 0x5A, 0xEE, 0x36, 0x45, 0x76, 0x17, + 0x0F, 0xCE, 0xE1, 0xF0, 0x7C, 0xC4, 0xB0, 0x4E, + 0xC0, 0x99, 0xCD, 0x52, 0xAB, 0x0A, 0x0A, 0xE4, + 0x42, 0x82, 0x56, 0xFC, 0x10, 0x4D, 0x94, 0x00, + 0xEE, 0x9C, 0x98, 0x60, 0x2D, 0x78, 0xB2, 0xF6, + 0xE9, 0x94, 0x08, 0x62, 0x48, 0x04, 0xE0, 0xB8, + 0x33, 0x74, 0xD0, 0xCD, 0x5B, 0xAD, 0x00, 0x87, + 0xF4, 0x42, 0xC2, 0x29, 0xE4, 0x6B, 0x65, 0xAC + }, + { + 0x43, 0xED, 0x0C, 0x94, 0x16, 0xB9, 0xE3, 0x15, + 0xF7, 0x9C, 0x2F, 0xB6, 0xC5, 0x20, 0x7D, 0x2A, + 0x90, 0x2B, 0xEA, 0x2D, 0x3A, 0x73, 0xD2, 0x99, + 0x21, 0x3E, 0x8E, 0x0B, 0x38, 0x7B, 0xD2, 0x0D, + 0xD7, 0x1F, 0xD7, 0xD3, 0xD2, 0x62, 0xC8, 0xFB, + 0xE1, 0x1C, 0x52, 0xF6, 0x28, 0x4B, 0x5D, 0xC7, + 0x98, 0x87, 0x6F, 0x5B, 0x9D, 0xC8, 0xBD, 0x27, + 0x9A, 0x9F, 0xF6, 0xAF, 0xE3, 0xC8, 0xC0, 0x93 + }, + { + 0x39, 0x9F, 0x48, 0xCC, 0xD1, 0xE1, 0xC7, 0xDD, + 0xFB, 0xE9, 0x85, 0x87, 0x96, 0xDE, 0x6D, 0xEF, + 0xFA, 0x32, 0xC6, 0x37, 0xBD, 0x70, 0x72, 0xEB, + 0x83, 0x8B, 0xF3, 0x74, 0x38, 0x3B, 0x30, 0x8A, + 0x4D, 0x41, 0x88, 0xB9, 0x12, 0xBB, 0x62, 0x07, + 0x75, 0xFF, 0x5C, 0x4E, 0xA5, 0xC4, 0x7D, 0x09, + 0xC3, 0x30, 0x03, 0x5D, 0x21, 0x76, 0x27, 0xF1, + 0xCD, 0x2C, 0xC1, 0x40, 0x3B, 0xD1, 0x35, 0x31 + }, + { + 0xCA, 0x77, 0x5F, 0xFB, 0x0D, 0x9C, 0x6C, 0x4F, + 0x4C, 0x93, 0xF3, 0x44, 0x20, 0xF2, 0x08, 0xC8, + 0x7E, 0x9A, 0x1D, 0xFF, 0x21, 0x7E, 0xEB, 0xC3, + 0x04, 0xA9, 0x81, 0x45, 0x88, 0xAD, 0x4E, 0xCF, + 0x3F, 0xD8, 0x60, 0xE2, 0x30, 0x1B, 0x1C, 0x60, + 0xBA, 0x6F, 0xED, 0xDB, 0x8A, 0x04, 0x55, 0x4F, + 0x64, 0x24, 0xEB, 0xEE, 0xB4, 0xE8, 0xE3, 0x23, + 0xCE, 0x96, 0x70, 0x79, 0x10, 0x48, 0xCD, 0x3B + }, + { + 0x48, 0xC5, 0xAB, 0x50, 0xF2, 0xB6, 0x17, 0xFF, + 0x96, 0x42, 0xCC, 0xD7, 0x61, 0x5F, 0x2D, 0xE7, + 0x21, 0x26, 0xDC, 0x8A, 0x64, 0xA1, 0x5C, 0xF0, + 0xEC, 0x2D, 0x81, 0xBD, 0xE5, 0x3A, 0x07, 0xDC, + 0x3B, 0x9C, 0x4C, 0xCC, 0x52, 0xA4, 0xE7, 0xD3, + 0xBE, 0x6A, 0x73, 0xD4, 0xA2, 0x54, 0xD0, 0x69, + 0xD7, 0x79, 0x0E, 0x04, 0xCC, 0x6E, 0x02, 0x8A, + 0x38, 0x7A, 0x86, 0xE6, 0x70, 0xFF, 0x74, 0x37 + }, + { + 0xB4, 0x86, 0x4A, 0x2A, 0x09, 0x92, 0xF1, 0xB5, + 0x62, 0xE3, 0x15, 0xC3, 0x57, 0xF9, 0xCD, 0xA2, + 0xE8, 0x35, 0xC4, 0x05, 0x05, 0xE2, 0x3C, 0xCF, + 0x48, 0x84, 0x40, 0xBF, 0x3E, 0x86, 0xAE, 0x88, + 0x9A, 0xD1, 0x45, 0x41, 0xB2, 0x98, 0x19, 0x41, + 0xAF, 0x2A, 0x40, 0xD3, 0xF1, 0xE0, 0xA5, 0x88, + 0x85, 0x16, 0x1E, 0xB7, 0x62, 0xA7, 0x10, 0x37, + 0xA5, 0xEE, 0x63, 0x89, 0x12, 0xB5, 0x77, 0x14 + }, + { + 0x14, 0x9C, 0x9E, 0xA6, 0x53, 0x90, 0x8F, 0xBA, + 0x25, 0x79, 0xE4, 0x71, 0x68, 0xEA, 0x34, 0x19, + 0x87, 0xC2, 0x36, 0x13, 0x51, 0x8E, 0x37, 0x65, + 0xB8, 0x22, 0xE2, 0xC1, 0x04, 0x49, 0x24, 0x52, + 0x91, 0x31, 0xEE, 0x70, 0x5B, 0x4F, 0x4F, 0x82, + 0x81, 0xA7, 0x76, 0xDA, 0x32, 0x4C, 0xB0, 0x26, + 0xF3, 0x17, 0xB0, 0x31, 0x4C, 0xCB, 0xCB, 0x81, + 0x73, 0xB9, 0x03, 0x52, 0x57, 0x37, 0xCF, 0x30 + }, + { + 0xFC, 0x75, 0xE1, 0xED, 0xBD, 0xF7, 0x67, 0xF6, + 0x08, 0xA0, 0x48, 0xD2, 0xC8, 0x0F, 0x67, 0x90, + 0xCB, 0x01, 0xB3, 0x66, 0xC9, 0x9E, 0x0E, 0xB8, + 0x3A, 0xC4, 0x5C, 0xCF, 0xF9, 0xFE, 0x6B, 0x53, + 0x6D, 0xB4, 0x16, 0xDA, 0xA2, 0xFB, 0x3E, 0x7A, + 0x7A, 0x61, 0xF8, 0x01, 0xFD, 0x98, 0x8D, 0xE5, + 0xB9, 0xD8, 0x95, 0xF9, 0x3A, 0xBC, 0xE7, 0x8F, + 0x50, 0x5D, 0x46, 0x88, 0x2D, 0xEE, 0x16, 0xB7 + }, + { + 0xEA, 0xA4, 0xA0, 0x34, 0x42, 0x9E, 0x9E, 0x83, + 0x69, 0x88, 0xE7, 0xD0, 0x73, 0x25, 0xDA, 0xEE, + 0xDC, 0x1F, 0x9E, 0x25, 0xD9, 0xD8, 0x15, 0xC8, + 0xD4, 0xB1, 0x21, 0x97, 0x6D, 0xB4, 0xDA, 0x27, + 0x57, 0x04, 0x19, 0x55, 0x7F, 0xF2, 0x92, 0x45, + 0x74, 0x6D, 0x32, 0xA7, 0x35, 0xFE, 0x68, 0x9B, + 0x76, 0x3C, 0xE2, 0x5F, 0x44, 0xCC, 0x29, 0x38, + 0xC6, 0xAD, 0x40, 0x39, 0x56, 0x2A, 0x2B, 0x3C + }, + { + 0x9B, 0xB6, 0xAE, 0x31, 0x70, 0x3D, 0x99, 0xAE, + 0xAE, 0xE7, 0x27, 0xB9, 0xBE, 0xB7, 0x7D, 0xA8, + 0xFA, 0x21, 0x70, 0xB4, 0x6F, 0x25, 0xC0, 0xBD, + 0xDB, 0x2C, 0x29, 0x8A, 0x3B, 0x0A, 0xC4, 0x13, + 0x3D, 0xBF, 0x20, 0x06, 0x2F, 0xD4, 0x3F, 0xD4, + 0xD9, 0xF2, 0xEC, 0xC7, 0x0C, 0x69, 0xED, 0x52, + 0x7A, 0x0E, 0xAB, 0x6B, 0xC6, 0xF3, 0x57, 0x11, + 0xDE, 0x16, 0x02, 0xDF, 0xDE, 0xE1, 0x07, 0x27 + }, + { + 0x11, 0x14, 0x22, 0x91, 0x6A, 0x80, 0xD1, 0x7A, + 0x5F, 0xE1, 0xEC, 0x73, 0x31, 0x17, 0x94, 0x60, + 0xD7, 0xC3, 0xA3, 0xA8, 0x39, 0x23, 0x8E, 0xBB, + 0x5A, 0x5C, 0x2B, 0x92, 0x41, 0x0C, 0xF6, 0xDF, + 0x35, 0x93, 0xA5, 0xA2, 0xBE, 0x5A, 0x0C, 0x66, + 0xDC, 0x09, 0x5C, 0xB3, 0x32, 0x1F, 0xFD, 0xCC, + 0xF5, 0x3A, 0xF3, 0x40, 0xBB, 0x8F, 0xE5, 0xAF, + 0x68, 0x8C, 0xD9, 0xA9, 0xFD, 0xF8, 0x2E, 0xD8 + }, + { + 0x9B, 0xE3, 0xD9, 0x2C, 0xC5, 0xF1, 0x2D, 0xF9, + 0x17, 0xD7, 0xD7, 0x13, 0xE4, 0x67, 0x15, 0xDF, + 0xFC, 0xF2, 0xC1, 0x56, 0xF1, 0x66, 0xE1, 0x3C, + 0x08, 0xF3, 0xB6, 0x05, 0x75, 0x60, 0xAB, 0xC2, + 0x5C, 0x93, 0x52, 0x61, 0x2F, 0xEE, 0xE4, 0x28, + 0x8F, 0x37, 0x69, 0x1A, 0x40, 0xC7, 0x1E, 0x96, + 0x7B, 0xDB, 0x02, 0xCD, 0x8F, 0xE6, 0x8E, 0xAA, + 0xD4, 0x8D, 0x61, 0xFB, 0xCB, 0x73, 0xBE, 0x00 + }, + { + 0xC8, 0xBC, 0xF0, 0x94, 0x27, 0xB6, 0x44, 0xF8, + 0x6B, 0x29, 0xB0, 0xC5, 0x1A, 0xB0, 0x73, 0xEA, + 0xC4, 0x48, 0x65, 0x35, 0x1E, 0x5D, 0x72, 0x60, + 0xC4, 0x82, 0x9D, 0x41, 0x0F, 0xC6, 0xAA, 0xAE, + 0x1E, 0xE8, 0xAA, 0x4F, 0xC4, 0x32, 0x0A, 0x2C, + 0x5F, 0x4B, 0xC2, 0xFA, 0x29, 0x16, 0x58, 0x07, + 0xEF, 0x17, 0xB7, 0x29, 0xB9, 0xAF, 0xAE, 0xB4, + 0x92, 0x18, 0x96, 0x85, 0x39, 0xB2, 0xDF, 0x79 + }, + { + 0x28, 0x11, 0xE9, 0x8A, 0xBC, 0xCC, 0xAF, 0xA2, + 0xA6, 0x62, 0x63, 0x93, 0x39, 0x3A, 0xF7, 0x24, + 0x51, 0x70, 0x08, 0x9C, 0xF6, 0xA4, 0x5D, 0x69, + 0xB6, 0xF5, 0x56, 0x35, 0xA6, 0xC2, 0x64, 0x9F, + 0x60, 0x40, 0x4E, 0xF9, 0x8E, 0xB9, 0xC9, 0x5B, + 0xB2, 0x3E, 0xF9, 0xDD, 0x2E, 0x97, 0x71, 0xE8, + 0x37, 0xE7, 0x7B, 0x3C, 0x16, 0xD4, 0x6E, 0x6C, + 0xC8, 0xFF, 0x8D, 0x84, 0x08, 0x06, 0x31, 0x97 + }, + { + 0x2A, 0x96, 0xC9, 0xFB, 0xE6, 0xDB, 0x10, 0x77, + 0x80, 0x56, 0xC5, 0x12, 0x03, 0x5E, 0x1A, 0x0D, + 0x04, 0x75, 0xE1, 0x33, 0x32, 0x41, 0x6D, 0xDF, + 0x60, 0x57, 0xD0, 0x9F, 0xA8, 0x0F, 0x68, 0x57, + 0xAD, 0x1E, 0x69, 0xAF, 0x83, 0x9D, 0x0B, 0x3B, + 0xBB, 0x81, 0xA9, 0xC2, 0x00, 0x53, 0xB6, 0x5F, + 0x2E, 0xDE, 0xDC, 0xF2, 0x0C, 0x1A, 0xCB, 0xA2, + 0x2C, 0x23, 0x41, 0xD6, 0xF9, 0xCD, 0x0B, 0x88 + }, + { + 0xE0, 0x7E, 0x60, 0x90, 0x03, 0x9E, 0x20, 0x0C, + 0xD4, 0x63, 0x73, 0x30, 0xF3, 0x71, 0x55, 0x1F, + 0x63, 0x9C, 0x95, 0x44, 0x3E, 0x3B, 0x28, 0x65, + 0xDD, 0xD2, 0x1C, 0x94, 0xAE, 0x36, 0x2F, 0xD9, + 0x51, 0xB8, 0x43, 0xF6, 0x3E, 0x02, 0x7B, 0xBC, + 0x49, 0xF8, 0xD2, 0xDB, 0x21, 0x37, 0x59, 0x22, + 0x3D, 0x3B, 0x63, 0x62, 0x0A, 0xDD, 0x1E, 0x6A, + 0x69, 0xE4, 0x49, 0x86, 0x35, 0x3D, 0x78, 0x83 + }, + { + 0x2A, 0x06, 0xD0, 0x17, 0x19, 0x91, 0x8B, 0x9B, + 0x51, 0x56, 0x5E, 0xFF, 0xAA, 0x74, 0xD5, 0x9C, + 0xF8, 0xDF, 0x00, 0x2E, 0x98, 0x6C, 0x04, 0x49, + 0x2E, 0x97, 0x04, 0xDA, 0x21, 0x6B, 0x82, 0x3E, + 0xFF, 0xA4, 0xA0, 0xAF, 0x1E, 0xDF, 0xA0, 0x2D, + 0x58, 0xC8, 0x70, 0x21, 0xDA, 0x00, 0x36, 0xCD, + 0xA5, 0x66, 0x62, 0x57, 0x15, 0x20, 0x27, 0x5D, + 0xE4, 0xAB, 0x09, 0xBF, 0x9A, 0x28, 0xAE, 0x9E + }, + { + 0xD2, 0xF7, 0xC4, 0x80, 0x62, 0xD8, 0x60, 0x3B, + 0x76, 0x34, 0xB1, 0xF3, 0x66, 0xBA, 0x82, 0x4F, + 0x6D, 0x64, 0xD6, 0x17, 0x56, 0xB7, 0x3B, 0xA8, + 0xFE, 0xB7, 0x05, 0xAE, 0x1C, 0xD3, 0xDC, 0xFB, + 0x4A, 0xF8, 0x6B, 0xF8, 0xD8, 0x95, 0xA1, 0x98, + 0x53, 0x00, 0x18, 0x3A, 0x56, 0xD9, 0xB6, 0x7B, + 0xC6, 0x97, 0x23, 0xCF, 0x1A, 0x73, 0xE3, 0x25, + 0x19, 0x4D, 0x0E, 0x78, 0xFB, 0x40, 0xE9, 0x92 + }, + { + 0x7C, 0x88, 0x1D, 0x31, 0x10, 0x88, 0xEE, 0x38, + 0x6F, 0xC3, 0x97, 0x3C, 0xDC, 0x59, 0xD9, 0x99, + 0x71, 0xC6, 0xCE, 0x52, 0xF2, 0x5F, 0xFE, 0xD1, + 0x57, 0x76, 0x04, 0xE8, 0x41, 0xCF, 0xAE, 0x0D, + 0x9D, 0x34, 0x4F, 0x84, 0x35, 0xF9, 0x9C, 0xE2, + 0x8B, 0x09, 0x8D, 0xB8, 0xEA, 0xF4, 0xF7, 0x10, + 0x10, 0xED, 0xC7, 0x03, 0x1A, 0x0F, 0xEE, 0xEB, + 0x2D, 0xE4, 0x95, 0x66, 0x3D, 0x21, 0xB4, 0x66 + }, + { + 0xE1, 0x3C, 0xFB, 0x85, 0xCF, 0x80, 0x87, 0xA8, + 0x86, 0x52, 0x78, 0xCA, 0xBF, 0xE1, 0xC5, 0x00, + 0xBF, 0xC2, 0xC4, 0x06, 0x92, 0xC9, 0xEC, 0x5B, + 0xC7, 0xCB, 0x33, 0xC8, 0x02, 0xB3, 0xFC, 0xA8, + 0xEC, 0x25, 0xC8, 0x55, 0xB2, 0x5C, 0x7B, 0xD1, + 0x6B, 0x8B, 0xCC, 0xB0, 0x1F, 0xAB, 0x12, 0xCF, + 0x2F, 0x4A, 0xF7, 0x3E, 0x36, 0x1E, 0xF4, 0x41, + 0x49, 0x2D, 0x8B, 0x7E, 0x1D, 0xB3, 0x03, 0x39 + }, + { + 0xFB, 0x95, 0x9A, 0xCC, 0xF4, 0x63, 0xE0, 0x70, + 0x22, 0x0F, 0xF7, 0xF5, 0x2E, 0x6C, 0x19, 0xC9, + 0xF2, 0x0E, 0xA3, 0x71, 0xA1, 0x08, 0x39, 0x52, + 0xE3, 0xE5, 0x79, 0x01, 0x87, 0x1F, 0xDA, 0xA3, + 0x07, 0x5D, 0xEA, 0xFB, 0xED, 0xDF, 0x9D, 0x35, + 0x3F, 0x56, 0xC2, 0x10, 0x44, 0x3B, 0x5A, 0xE1, + 0xE0, 0x51, 0x69, 0x93, 0xB9, 0x24, 0x70, 0xB9, + 0x55, 0x4B, 0xD9, 0x29, 0x52, 0x57, 0x5B, 0x60 + }, + { + 0x46, 0xE5, 0xE0, 0x04, 0x7E, 0x4C, 0x4A, 0x74, + 0xF9, 0xED, 0xF7, 0x7D, 0xCF, 0x0F, 0xE0, 0xC8, + 0xFE, 0xD4, 0xDA, 0xD2, 0x46, 0xC7, 0x69, 0xD7, + 0xF2, 0x31, 0x33, 0x57, 0x3B, 0x2B, 0x25, 0xB6, + 0x77, 0x7A, 0xAC, 0x53, 0x7E, 0x38, 0xB0, 0x89, + 0x5E, 0x69, 0x91, 0x0A, 0xEA, 0xA6, 0x4A, 0x5B, + 0xDF, 0x6E, 0xC3, 0xEE, 0xB5, 0x08, 0x8C, 0x24, + 0xE7, 0x33, 0x00, 0xF2, 0xD1, 0x6D, 0xA8, 0xD5 + }, + { + 0x98, 0x1E, 0x72, 0x2A, 0x6D, 0x84, 0x49, 0x18, + 0x81, 0x02, 0xFF, 0xC6, 0x6F, 0x6A, 0xDC, 0x94, + 0x26, 0x81, 0x35, 0x81, 0x8A, 0xF6, 0x65, 0x3D, + 0x6F, 0x6B, 0x31, 0x65, 0x95, 0xE2, 0x33, 0x72, + 0x19, 0xA7, 0x97, 0x06, 0xD6, 0x9E, 0x14, 0x5C, + 0xB2, 0xFF, 0xF3, 0x91, 0xEE, 0xE8, 0x70, 0x12, + 0x5E, 0xBF, 0x9A, 0x10, 0xA1, 0x54, 0x4A, 0xC7, + 0x08, 0x01, 0x7E, 0x1C, 0x01, 0x1C, 0x45, 0xD2 + }, + { + 0x5F, 0x86, 0x77, 0x5F, 0xDF, 0x5E, 0x28, 0x1B, + 0xB1, 0xD8, 0x63, 0x08, 0xA2, 0x53, 0xA6, 0xE8, + 0x2C, 0x8A, 0xA7, 0x52, 0xAC, 0x6B, 0x83, 0xFC, + 0xE9, 0xFA, 0xC5, 0xB7, 0xE1, 0xE0, 0x06, 0x0F, + 0x40, 0x40, 0x9A, 0x43, 0x79, 0x45, 0xA3, 0x1D, + 0xE7, 0xE9, 0xC4, 0x94, 0x97, 0xDD, 0x2C, 0x63, + 0xD9, 0xB4, 0x7B, 0x3A, 0xD0, 0x57, 0xD1, 0x74, + 0x74, 0xD9, 0xB7, 0xD9, 0x4F, 0x5B, 0xC5, 0x32 + }, + { + 0x86, 0x59, 0x37, 0x6E, 0x0F, 0x5A, 0x64, 0xD5, + 0xC4, 0xB2, 0x43, 0x49, 0xCA, 0x93, 0xC4, 0x6D, + 0x97, 0x13, 0xA1, 0x5C, 0xEA, 0x0D, 0xDA, 0xC5, + 0xC7, 0xD8, 0xD2, 0x9D, 0x13, 0xA4, 0x74, 0xEE, + 0xA6, 0x41, 0xB4, 0x5B, 0x92, 0xA0, 0xEB, 0x2E, + 0xB6, 0x2A, 0xF8, 0xB7, 0x3A, 0x7B, 0x97, 0x94, + 0x56, 0xEA, 0xB2, 0xE6, 0xFA, 0x06, 0x93, 0x1F, + 0x55, 0x06, 0xE5, 0xCA, 0xE5, 0x08, 0x28, 0xAA + }, + { + 0x74, 0x42, 0x36, 0x09, 0xAE, 0x2C, 0x38, 0x95, + 0xFA, 0x98, 0x3D, 0x31, 0xF6, 0x67, 0xF6, 0xA7, + 0x96, 0xFD, 0x33, 0x17, 0xC2, 0x67, 0xD5, 0x60, + 0xBD, 0x4C, 0x38, 0x3D, 0x03, 0x18, 0x18, 0x07, + 0x5E, 0x67, 0xC6, 0x10, 0xC9, 0x56, 0x26, 0xA5, + 0xB5, 0xC9, 0x24, 0xFA, 0xBA, 0x23, 0x65, 0xC6, + 0x2F, 0xD3, 0xFF, 0x69, 0xFC, 0x9E, 0x6D, 0x68, + 0x75, 0x8E, 0xA0, 0x77, 0xEA, 0xA2, 0x99, 0xEA + }, + { + 0x73, 0x1C, 0x3C, 0xA7, 0x88, 0x65, 0x9F, 0x59, + 0xB5, 0x9D, 0xFA, 0x7D, 0xC0, 0xC6, 0x93, 0x5C, + 0x30, 0x61, 0x7B, 0x78, 0xFC, 0x48, 0xFE, 0x5E, + 0x8C, 0xDF, 0x9F, 0x28, 0x5F, 0x42, 0x33, 0x88, + 0x1E, 0x06, 0x09, 0x4D, 0xCE, 0xBE, 0x59, 0x0A, + 0x92, 0xFA, 0x8B, 0x6C, 0x0F, 0x90, 0x16, 0x7D, + 0xD7, 0x30, 0x33, 0xE0, 0x26, 0xFB, 0x35, 0x49, + 0x09, 0x00, 0x55, 0x00, 0x6B, 0xD8, 0x20, 0x48 + }, + { + 0x1C, 0x8B, 0xA5, 0x9F, 0xDF, 0x24, 0x7C, 0xA4, + 0x11, 0x6F, 0x46, 0xEB, 0x21, 0x4B, 0x59, 0x4A, + 0x3A, 0x6F, 0x25, 0xBE, 0xCC, 0x37, 0x79, 0xA9, + 0xE2, 0x19, 0x69, 0xA6, 0x25, 0xDB, 0x58, 0x3D, + 0x0F, 0x95, 0x2B, 0xC9, 0x7D, 0xFD, 0x8E, 0xBE, + 0xE8, 0x57, 0x3E, 0xC6, 0xBD, 0x95, 0x7B, 0xD6, + 0x6A, 0xDB, 0x6C, 0xC7, 0x9F, 0x39, 0xD2, 0x65, + 0xD1, 0xD3, 0x7A, 0xC4, 0x93, 0x55, 0x00, 0xAB + }, + { + 0x4A, 0x46, 0x1E, 0xCD, 0xC6, 0x38, 0x5B, 0x56, + 0x6D, 0x4A, 0x03, 0xEF, 0xA1, 0xF1, 0x1D, 0xC9, + 0x53, 0x66, 0x35, 0xF5, 0xED, 0xDE, 0x73, 0xE8, + 0xF1, 0xC1, 0x8F, 0x8E, 0xC7, 0x7C, 0x31, 0x84, + 0x3E, 0x5A, 0x59, 0x24, 0x82, 0x39, 0x25, 0x79, + 0x09, 0x1E, 0xF6, 0x93, 0x13, 0x1C, 0x5D, 0x58, + 0xF0, 0xC0, 0xD7, 0xEC, 0x8B, 0xB9, 0xB4, 0x5D, + 0xCD, 0xCD, 0xC6, 0x2A, 0x67, 0x3B, 0x3B, 0xCD + }, + { + 0xFE, 0x14, 0x32, 0x28, 0xA4, 0xC3, 0x7A, 0xF3, + 0xCE, 0x30, 0x90, 0x15, 0x49, 0x8E, 0x74, 0x44, + 0xEA, 0xA9, 0x1D, 0x5C, 0x72, 0x0B, 0x68, 0x1F, + 0x3F, 0x87, 0x3A, 0xB2, 0xB7, 0x5E, 0xB7, 0x0C, + 0x08, 0xB2, 0x14, 0x7A, 0x56, 0x22, 0xC9, 0x1B, + 0xFB, 0x80, 0xED, 0x01, 0x60, 0xEA, 0xDE, 0x5E, + 0x95, 0xFE, 0xEB, 0x8A, 0x33, 0xA5, 0x63, 0xCE, + 0x44, 0x68, 0xEB, 0xF0, 0xA8, 0x9E, 0xDE, 0xF2 + }, + { + 0x22, 0xC0, 0xB7, 0xBD, 0x79, 0xC7, 0xA0, 0x65, + 0x6D, 0x74, 0xB9, 0x92, 0xD7, 0x31, 0xD7, 0x1B, + 0x6C, 0xFD, 0x25, 0x14, 0x12, 0x63, 0x96, 0x93, + 0xC7, 0x99, 0xCD, 0xDF, 0x9C, 0x96, 0x82, 0x2C, + 0xCF, 0xA3, 0x00, 0xBC, 0xAE, 0xA1, 0x4A, 0x00, + 0x99, 0x6E, 0xE1, 0x2E, 0x11, 0xB4, 0x89, 0xD4, + 0x3B, 0xFA, 0x6C, 0xA3, 0x2D, 0x7F, 0x7B, 0x42, + 0xC4, 0x64, 0xD7, 0x61, 0x71, 0x32, 0x12, 0x09 + }, + { + 0xE0, 0xC4, 0xC6, 0x5B, 0xF1, 0x65, 0x9A, 0xE4, + 0xF6, 0x53, 0xD7, 0x06, 0x11, 0xCA, 0x68, 0x5B, + 0xE2, 0xB3, 0xF6, 0x51, 0x63, 0x48, 0x10, 0x30, + 0xCA, 0x09, 0x9E, 0x2C, 0x3A, 0xC5, 0x87, 0xAB, + 0x84, 0x31, 0x64, 0x07, 0xBF, 0xB6, 0xB4, 0xCA, + 0xEE, 0x72, 0x6F, 0x84, 0xAA, 0xC9, 0xF6, 0xCA, + 0x92, 0xB7, 0x81, 0x34, 0xFF, 0xFB, 0x6D, 0x83, + 0xD9, 0xB2, 0x62, 0x50, 0xDB, 0xDB, 0x6E, 0x8B + }, + { + 0xD1, 0x0D, 0xB6, 0x6A, 0xD2, 0x98, 0x52, 0xD8, + 0x1F, 0xC9, 0xA6, 0xFF, 0xCE, 0xA8, 0xFC, 0xF4, + 0x6C, 0x74, 0xC6, 0x37, 0xF8, 0xC9, 0xE6, 0x24, + 0x09, 0x52, 0x36, 0xE9, 0x92, 0xB6, 0x93, 0x48, + 0x59, 0x91, 0x5B, 0xF7, 0xF1, 0x50, 0x1A, 0xF1, + 0x5D, 0x40, 0x8C, 0x8A, 0x5D, 0x12, 0xF4, 0x0A, + 0x59, 0x66, 0xBB, 0xD8, 0xD7, 0xDC, 0xB7, 0x12, + 0xEA, 0x0C, 0x8F, 0xCD, 0x11, 0xAA, 0xFA, 0x2C + }, + { + 0x19, 0x1C, 0x6F, 0x9C, 0x25, 0xF3, 0x60, 0x7B, + 0x3D, 0xB6, 0x61, 0x18, 0x9A, 0x3C, 0x6B, 0x84, + 0xB5, 0x01, 0x90, 0x38, 0xAE, 0xD4, 0x40, 0x48, + 0xE0, 0x27, 0x62, 0x2F, 0xE8, 0x26, 0x4B, 0xAF, + 0xD9, 0x74, 0xA0, 0xF9, 0x4B, 0xCF, 0x9E, 0xDE, + 0x26, 0x1B, 0x93, 0x32, 0x89, 0x3F, 0x93, 0xAC, + 0xD5, 0xFE, 0x2A, 0x15, 0x16, 0xAF, 0x6E, 0xDA, + 0x97, 0x6E, 0x45, 0xB1, 0xC5, 0x38, 0xD8, 0x34 + }, + { + 0xAB, 0xE0, 0xBF, 0x31, 0xB4, 0x7A, 0xC5, 0x7C, + 0x5B, 0x3B, 0x89, 0x28, 0xD5, 0xAA, 0x8D, 0x16, + 0xF8, 0xFA, 0x57, 0x08, 0x9C, 0x46, 0x1E, 0x8F, + 0x67, 0x4A, 0xE4, 0xC2, 0xA6, 0x09, 0xA0, 0xEC, + 0x40, 0xED, 0xB7, 0x80, 0x11, 0xE5, 0xA7, 0x9A, + 0xFA, 0xCA, 0xD3, 0x8C, 0x52, 0x84, 0x36, 0xC4, + 0x03, 0xBD, 0x5A, 0x72, 0x6F, 0x94, 0x74, 0x82, + 0x47, 0x39, 0xDF, 0xAF, 0x0A, 0x7E, 0x68, 0x62 + }, + { + 0xCC, 0x8A, 0xAB, 0x15, 0x30, 0x17, 0xBF, 0x93, + 0x5E, 0x3E, 0x51, 0x9E, 0xFD, 0x1B, 0x10, 0x03, + 0x1E, 0x1F, 0xD6, 0x87, 0xF0, 0x29, 0x4A, 0x83, + 0x63, 0x7B, 0x92, 0xB3, 0x5C, 0x36, 0x8E, 0x45, + 0xA6, 0xCC, 0xA2, 0x73, 0xFA, 0xD9, 0xFB, 0x72, + 0x02, 0xD2, 0xEA, 0xD5, 0x3F, 0x90, 0xC4, 0x57, + 0x5A, 0x01, 0xCA, 0x83, 0x5E, 0xB8, 0x7D, 0x1B, + 0x4D, 0x66, 0xD0, 0x6B, 0x94, 0xB7, 0x1C, 0x01 + }, + { + 0xE5, 0x4C, 0xEC, 0x63, 0xEB, 0xE6, 0xA1, 0x1A, + 0xF6, 0x4D, 0xB5, 0x71, 0x8B, 0x93, 0xBC, 0xC6, + 0x5B, 0xC5, 0x1D, 0x5F, 0x40, 0x56, 0x5B, 0x51, + 0x99, 0xF3, 0x39, 0xE6, 0xA4, 0x49, 0x0E, 0xA7, + 0x97, 0x3C, 0xFA, 0x63, 0x63, 0x94, 0x17, 0x5F, + 0x22, 0xAB, 0xAB, 0xF2, 0x0D, 0x03, 0xB4, 0xA9, + 0x8D, 0x59, 0x7C, 0x32, 0x5A, 0x7D, 0x91, 0xD5, + 0xEF, 0xFD, 0xAD, 0x80, 0x7D, 0x57, 0xB9, 0xB2 + }, + { + 0x42, 0xD4, 0x94, 0x91, 0xAD, 0xE1, 0xA8, 0x8A, + 0x47, 0x5F, 0x9B, 0x85, 0x35, 0xE9, 0x71, 0xD3, + 0x4B, 0xE1, 0x2E, 0x55, 0x69, 0xEA, 0x0A, 0xAD, + 0x57, 0x11, 0x9D, 0x2A, 0xB2, 0x01, 0xB4, 0x38, + 0xA7, 0x9D, 0x34, 0x25, 0x20, 0xB2, 0xE7, 0x91, + 0x60, 0x32, 0x12, 0xE7, 0xBA, 0x70, 0x64, 0x05, + 0x8A, 0x03, 0x90, 0xD6, 0x31, 0x74, 0xD1, 0x7F, + 0x9B, 0xE0, 0xD0, 0x35, 0x3F, 0xE0, 0x7F, 0xBC + }, + { + 0xF4, 0xCF, 0x99, 0x8C, 0x9B, 0x21, 0x98, 0xDE, + 0x98, 0x75, 0x7B, 0xBD, 0x77, 0x90, 0x26, 0x95, + 0x62, 0x62, 0xFE, 0xCA, 0x4B, 0xAB, 0x90, 0x9C, + 0xE8, 0xB4, 0xD2, 0xBD, 0x85, 0x84, 0x70, 0x16, + 0xAB, 0x8E, 0xEC, 0x61, 0xD0, 0x36, 0xCF, 0xE3, + 0x6F, 0x23, 0x21, 0x6C, 0xFF, 0x9F, 0xC9, 0x95, + 0xAE, 0x94, 0x07, 0xB3, 0xE3, 0xFB, 0x48, 0x2B, + 0xEB, 0xE2, 0x21, 0x74, 0x15, 0x86, 0xFF, 0xAD + }, + { + 0x5D, 0x5F, 0x2D, 0xAB, 0x09, 0xBE, 0x93, 0xF6, + 0xA2, 0x00, 0xB1, 0xF8, 0xFE, 0x7E, 0xCA, 0x40, + 0x84, 0x76, 0xB1, 0x42, 0x64, 0x62, 0xCB, 0x42, + 0xF0, 0x52, 0xE6, 0x7A, 0x8F, 0x76, 0x6D, 0x77, + 0xA7, 0xF2, 0xB6, 0x60, 0xC0, 0xCB, 0xD6, 0xE0, + 0x0B, 0xD3, 0x35, 0x10, 0x77, 0x74, 0xEA, 0x4E, + 0x99, 0xB8, 0xEA, 0x76, 0x29, 0x2B, 0x5F, 0x55, + 0x56, 0xA0, 0x42, 0x72, 0xA9, 0x8A, 0x53, 0x4C + }, + { + 0xBA, 0xF9, 0xF6, 0xD8, 0xF4, 0x0B, 0x98, 0xF5, + 0x43, 0xDE, 0x75, 0x60, 0xAF, 0xE6, 0x0E, 0x7F, + 0x04, 0xDF, 0xCA, 0x48, 0x35, 0x93, 0x37, 0x70, + 0x1F, 0xA7, 0x97, 0xF7, 0x52, 0xDF, 0xF7, 0xD4, + 0xA4, 0x86, 0x53, 0xBF, 0x31, 0x56, 0xF0, 0xB5, + 0xD0, 0xF0, 0x09, 0x41, 0x8E, 0x08, 0x7E, 0xE5, + 0x98, 0xC9, 0x03, 0x80, 0xB1, 0xF5, 0xD0, 0x37, + 0x7C, 0xDD, 0x99, 0x43, 0xE9, 0x0A, 0xD7, 0x69 + }, + { + 0x10, 0xF8, 0x6D, 0xEC, 0xFF, 0x61, 0x45, 0xA6, + 0x04, 0x21, 0x55, 0xC9, 0xB6, 0x0C, 0x26, 0x82, + 0x43, 0x91, 0xBE, 0x6A, 0xDA, 0xE0, 0x2F, 0xA8, + 0x7A, 0x59, 0xB6, 0x4E, 0x4F, 0xA8, 0x28, 0x9D, + 0x05, 0x20, 0xE5, 0xAA, 0x79, 0xA4, 0xC8, 0x1E, + 0xC9, 0x6E, 0xE0, 0xB9, 0xD7, 0xA1, 0xED, 0xA6, + 0x7F, 0x62, 0xF7, 0x75, 0x5A, 0xF7, 0x3B, 0x73, + 0xE4, 0x53, 0xB4, 0xC5, 0x12, 0x28, 0xDB, 0x0A + }, + { + 0x0F, 0xD7, 0xFA, 0xFB, 0xA7, 0x97, 0x30, 0x95, + 0x18, 0x93, 0xDF, 0xF4, 0x12, 0x8F, 0xCA, 0xD4, + 0x46, 0xA2, 0xDB, 0x03, 0xC5, 0x44, 0x86, 0xED, + 0x71, 0x13, 0x55, 0xB3, 0x9E, 0xDC, 0x7E, 0xD9, + 0xBD, 0x3B, 0x03, 0x78, 0x5E, 0x25, 0xED, 0xB5, + 0x74, 0xD3, 0x6F, 0x20, 0x88, 0x05, 0x91, 0xFB, + 0x81, 0x06, 0x7D, 0x1B, 0x4D, 0x7F, 0x1A, 0xF1, + 0x52, 0xBC, 0x37, 0x58, 0x2D, 0x89, 0x5A, 0xA6 + }, + { + 0x66, 0xD8, 0xA6, 0xB7, 0xCB, 0xC0, 0x7F, 0x87, + 0xBC, 0xDE, 0x24, 0x82, 0x84, 0xB9, 0x72, 0x01, + 0xD3, 0x13, 0x4D, 0x3E, 0xC6, 0xA4, 0xC9, 0xBC, + 0xEC, 0xEE, 0x06, 0x1D, 0xA8, 0xE4, 0xEE, 0x5F, + 0x92, 0xD1, 0x37, 0xD6, 0xF6, 0xD5, 0x96, 0x90, + 0xED, 0xEF, 0x19, 0x7B, 0x68, 0x9C, 0x19, 0x93, + 0xBA, 0x59, 0xA7, 0xDA, 0xD2, 0x57, 0xBF, 0x73, + 0x09, 0xC4, 0x9F, 0x01, 0x35, 0x61, 0x1A, 0xD7 + }, + { + 0x6C, 0x2D, 0x6A, 0x15, 0xE1, 0xDA, 0x29, 0xDB, + 0x30, 0x6F, 0xB2, 0x64, 0xFB, 0x0E, 0xF3, 0x08, + 0x57, 0xAE, 0x40, 0xFD, 0xA6, 0xFF, 0x95, 0xBC, + 0x54, 0x2B, 0xE8, 0x14, 0xC7, 0x00, 0xF5, 0x61, + 0xD4, 0x4A, 0xE3, 0x3F, 0x4C, 0x62, 0x85, 0x2E, + 0x12, 0xEA, 0x45, 0x02, 0x7F, 0x90, 0x23, 0xF2, + 0x44, 0x25, 0xDD, 0x16, 0x4F, 0xAE, 0x09, 0x48, + 0x48, 0xFF, 0xF3, 0x89, 0x1E, 0x02, 0x81, 0xCD + }, + { + 0xB8, 0x30, 0x05, 0x40, 0xF4, 0x45, 0xBA, 0x5A, + 0x5E, 0xAB, 0xEB, 0x9F, 0x43, 0x76, 0x91, 0x29, + 0xDA, 0x39, 0x9E, 0xB4, 0xE4, 0x4E, 0xE1, 0x09, + 0xA5, 0x79, 0x9D, 0x88, 0x0B, 0x27, 0x06, 0xE4, + 0x35, 0x37, 0x57, 0xD7, 0x14, 0x95, 0x89, 0x74, + 0xF6, 0x87, 0x93, 0x39, 0xB2, 0x4E, 0x44, 0xEC, + 0xB3, 0xBE, 0x52, 0x88, 0xCA, 0x81, 0x67, 0xA4, + 0x46, 0x8D, 0x1D, 0x89, 0x27, 0xFB, 0xF7, 0x16 + }, + { + 0x69, 0x02, 0x27, 0xE4, 0xC4, 0xCC, 0x3D, 0x38, + 0xD7, 0xFB, 0x23, 0x6C, 0x0D, 0x52, 0xF9, 0xE3, + 0x6E, 0xFC, 0x0C, 0xED, 0x6F, 0x42, 0x44, 0x63, + 0x25, 0x8C, 0x53, 0x85, 0x11, 0xEE, 0xDA, 0x6A, + 0xE3, 0x0B, 0xF1, 0x1F, 0x4A, 0xC2, 0x38, 0xE8, + 0xAE, 0x54, 0xB3, 0xBD, 0x2B, 0xA7, 0xD4, 0x04, + 0x84, 0xDF, 0x4C, 0xEF, 0x9A, 0xC5, 0x6D, 0x3E, + 0x78, 0xC1, 0x6C, 0xA5, 0x38, 0xCF, 0x76, 0x3F + }, + { + 0x1D, 0x99, 0x3C, 0x1E, 0x29, 0x69, 0xD6, 0x3E, + 0x20, 0x1E, 0xDC, 0xAD, 0x18, 0x23, 0xCE, 0x0D, + 0x2F, 0x2D, 0xB5, 0x30, 0x27, 0x78, 0xC9, 0xE1, + 0xE7, 0x94, 0xDD, 0xE4, 0x9F, 0xD4, 0xEE, 0x40, + 0xD5, 0x65, 0xAA, 0xB1, 0x7E, 0x67, 0xC1, 0xA3, + 0xD3, 0x85, 0xEA, 0xA3, 0x03, 0x8C, 0xA7, 0xCE, + 0x19, 0xEA, 0xCF, 0xD1, 0x45, 0xF3, 0x86, 0x89, + 0xF7, 0xFB, 0x3B, 0x83, 0x6A, 0x03, 0x5B, 0xD2 + }, + { + 0x76, 0x2A, 0x14, 0x00, 0x4C, 0x55, 0x57, 0xF1, + 0x2B, 0xCC, 0xDE, 0xA1, 0x03, 0x80, 0xB9, 0xE9, + 0x2A, 0xDA, 0xD7, 0x3C, 0x78, 0xC6, 0xA6, 0x74, + 0x74, 0xE0, 0xF7, 0x12, 0xD2, 0xF6, 0xCA, 0x92, + 0xE0, 0xD3, 0xDC, 0x0B, 0x7D, 0x19, 0x25, 0xD0, + 0x85, 0xBC, 0xAC, 0xDA, 0xDB, 0x48, 0xA5, 0xED, + 0x4D, 0x89, 0x94, 0xCF, 0x90, 0x60, 0xF1, 0x33, + 0x8D, 0xCC, 0x50, 0x06, 0xB2, 0x95, 0xFC, 0x7D + }, + { + 0x43, 0x96, 0x72, 0x05, 0x75, 0x39, 0x48, 0xBC, + 0xA0, 0xE7, 0x4C, 0xBE, 0xEC, 0x51, 0xF2, 0xF8, + 0x6A, 0xAF, 0xAF, 0xDF, 0x89, 0x7E, 0x60, 0x82, + 0xD9, 0x12, 0x6A, 0x94, 0x3D, 0x8A, 0x39, 0x64, + 0xA6, 0x5C, 0x78, 0x55, 0x6D, 0x05, 0x8F, 0xBA, + 0x44, 0xC0, 0x59, 0x0E, 0x2C, 0x16, 0x26, 0xC0, + 0xA2, 0x72, 0x28, 0xAA, 0xD0, 0xA3, 0x0E, 0x18, + 0x53, 0x10, 0x0E, 0x78, 0x18, 0xCF, 0x7A, 0x6C + }, + { + 0x54, 0x27, 0x4F, 0x8B, 0x10, 0x9C, 0x24, 0xF9, + 0x95, 0xDB, 0xB0, 0xA3, 0x29, 0xB9, 0x07, 0x7F, + 0xBB, 0xC1, 0x3A, 0x96, 0x95, 0x0E, 0x63, 0xC1, + 0xF5, 0x42, 0x27, 0x3A, 0xE4, 0x88, 0x03, 0x33, + 0x4E, 0xED, 0x17, 0xDE, 0x81, 0xA8, 0x4A, 0x74, + 0xF0, 0x66, 0x64, 0x18, 0x90, 0xE4, 0x26, 0xC5, + 0xE2, 0xCC, 0xA2, 0x86, 0xB7, 0x7C, 0x15, 0x8B, + 0x08, 0x8A, 0x78, 0xEB, 0xF1, 0xE9, 0x65, 0xBD + }, + { + 0x40, 0x23, 0xED, 0x3C, 0x68, 0x46, 0xBC, 0xAA, + 0xB0, 0xDE, 0xAB, 0xC7, 0xC8, 0x89, 0x18, 0x5E, + 0xE0, 0x68, 0x55, 0xB2, 0xA3, 0x57, 0xBE, 0x60, + 0x30, 0x5A, 0x87, 0x27, 0xF9, 0xA9, 0xC1, 0xB9, + 0xAA, 0xAF, 0xEE, 0x28, 0x21, 0x12, 0x8F, 0xDD, + 0xFA, 0xA3, 0x15, 0x93, 0x24, 0x1C, 0x72, 0x56, + 0xE1, 0xF3, 0x26, 0x39, 0xB2, 0x5B, 0xA7, 0x0A, + 0x48, 0x3B, 0xF3, 0x18, 0x55, 0x8E, 0xCB, 0x29 + }, + { + 0x1F, 0x2B, 0x58, 0x77, 0xD8, 0xF1, 0xFA, 0x52, + 0x82, 0x3B, 0x80, 0x87, 0xC4, 0x26, 0x0D, 0x0F, + 0x99, 0xED, 0xCC, 0xF0, 0xF8, 0x39, 0xC0, 0x71, + 0x85, 0xDB, 0xD4, 0x52, 0x60, 0xAD, 0x45, 0x3A, + 0x25, 0xA9, 0x69, 0xA7, 0x19, 0x06, 0x16, 0x98, + 0x2F, 0x69, 0x3A, 0x2C, 0x38, 0x5A, 0x8C, 0x4A, + 0x1C, 0xD4, 0xD7, 0x2D, 0x05, 0xBC, 0x70, 0x9A, + 0x26, 0x43, 0xE6, 0xE8, 0x8F, 0xC0, 0x62, 0x4B + }, + { + 0xC4, 0x96, 0x51, 0x66, 0xB4, 0x1F, 0x96, 0xA2, + 0x61, 0x78, 0xFA, 0x47, 0x80, 0xE6, 0xA1, 0x87, + 0x4F, 0x8C, 0x12, 0xC5, 0x39, 0x81, 0x48, 0xED, + 0x7A, 0xD2, 0xDC, 0xBF, 0xBA, 0x87, 0x89, 0x33, + 0x6D, 0xA1, 0x0F, 0xA4, 0xE5, 0xD7, 0xAD, 0x13, + 0xB5, 0xBB, 0x8C, 0xA4, 0x63, 0xD7, 0x85, 0xA4, + 0x08, 0x58, 0x53, 0x1D, 0xC5, 0x52, 0x6F, 0x31, + 0x56, 0x7B, 0xC6, 0x84, 0x62, 0x65, 0x27, 0x37 + }, + { + 0xF1, 0x39, 0x12, 0x9A, 0x48, 0xAC, 0x80, 0x85, + 0x54, 0x63, 0x42, 0x78, 0x1D, 0x5C, 0x7E, 0x7B, + 0x2B, 0xFD, 0xC8, 0x36, 0x0A, 0x19, 0x79, 0xFE, + 0x22, 0x93, 0x39, 0x4E, 0xD8, 0x6E, 0xFD, 0x37, + 0x09, 0xDE, 0xA8, 0x17, 0x26, 0x21, 0xEB, 0xD1, + 0x51, 0x7A, 0x4E, 0x3F, 0x98, 0xA2, 0xA1, 0x51, + 0xC2, 0x45, 0xCB, 0x0D, 0xA8, 0x06, 0xF0, 0x8D, + 0xA2, 0x52, 0xB6, 0x6E, 0x89, 0x70, 0x4E, 0x20 + }, + { + 0xB8, 0x5C, 0xBF, 0xE4, 0xD0, 0xE5, 0x9D, 0xB0, + 0xD2, 0xF7, 0x46, 0x33, 0x27, 0xEF, 0x85, 0xA9, + 0x38, 0xF5, 0xC2, 0x8A, 0x74, 0x1D, 0x42, 0x0D, + 0x59, 0xA8, 0x93, 0xED, 0xC2, 0xE3, 0x03, 0xD3, + 0xF4, 0xBA, 0x04, 0x05, 0xC2, 0xFA, 0x8A, 0x90, + 0x28, 0xF3, 0x2D, 0xBF, 0x8F, 0xE3, 0x8A, 0xB5, + 0xC6, 0x4C, 0xA8, 0x79, 0xD6, 0x7C, 0x67, 0x7A, + 0xB0, 0xB7, 0x7F, 0x32, 0x34, 0x1D, 0x1B, 0x5D + }, + { + 0x7F, 0x31, 0x45, 0xE1, 0x91, 0xA2, 0x6C, 0x14, + 0x71, 0x23, 0xB7, 0x9D, 0x90, 0xFC, 0x2E, 0x66, + 0x87, 0x75, 0xD1, 0x36, 0xB3, 0x64, 0xF6, 0xA6, + 0x43, 0x0A, 0x98, 0xCA, 0xCB, 0x6B, 0xB9, 0xD4, + 0x1E, 0x9D, 0x3A, 0x25, 0x8B, 0x6B, 0x95, 0x52, + 0xB5, 0x22, 0x6C, 0xCD, 0x3C, 0xB7, 0x62, 0x5B, + 0x12, 0x36, 0xD7, 0x0F, 0xDF, 0x83, 0x60, 0xC2, + 0xCC, 0x43, 0x73, 0x16, 0x4F, 0xDE, 0xCC, 0x93 + }, + { + 0x37, 0x04, 0x19, 0x6A, 0x31, 0x4E, 0x66, 0x3C, + 0xCB, 0x27, 0xE1, 0x50, 0x39, 0x9C, 0x58, 0x7F, + 0xFC, 0xF8, 0xF9, 0xBB, 0xBD, 0x56, 0x65, 0x0A, + 0x7E, 0xC9, 0xC7, 0x5F, 0x2D, 0xF3, 0xD3, 0x03, + 0xD5, 0x67, 0xA1, 0xD2, 0x01, 0xCA, 0xB7, 0xA2, + 0x60, 0x7A, 0x11, 0xA1, 0x84, 0xBE, 0xE9, 0x72, + 0x62, 0x3D, 0x14, 0x55, 0xEA, 0x94, 0xC4, 0xB8, + 0xC1, 0xBF, 0x1C, 0x8C, 0x9F, 0x64, 0xAE, 0xC7 + }, + { + 0x17, 0xD4, 0xB1, 0xAC, 0xBB, 0xE1, 0xDB, 0xB9, + 0xBF, 0xFD, 0x41, 0x10, 0xF6, 0x26, 0x57, 0xEC, + 0xF5, 0xC2, 0x13, 0xBB, 0xEA, 0xA3, 0xBE, 0x51, + 0x3C, 0x3F, 0x9B, 0x94, 0x1A, 0xA6, 0x1B, 0x50, + 0x21, 0x01, 0xBE, 0x99, 0x01, 0xF7, 0x85, 0x28, + 0x3D, 0xFC, 0x85, 0x02, 0x61, 0x09, 0xFB, 0x37, + 0xD9, 0x05, 0x15, 0xAE, 0x13, 0xBF, 0xDA, 0x71, + 0x1A, 0xB2, 0x04, 0xD2, 0x56, 0x88, 0x12, 0xE1 + }, + { + 0x2E, 0xB8, 0xB6, 0x39, 0x32, 0x0B, 0xD1, 0x1F, + 0x1C, 0xC9, 0xF1, 0xDB, 0x65, 0xF5, 0x2F, 0xB4, + 0x15, 0x09, 0xAC, 0x73, 0x74, 0xC7, 0x8D, 0xBC, + 0xBB, 0x12, 0x12, 0x93, 0x07, 0xD3, 0xF5, 0xB4, + 0x9F, 0xA0, 0x5F, 0x40, 0xF6, 0x42, 0xC2, 0xEB, + 0x73, 0xAB, 0x4B, 0x6F, 0x92, 0x82, 0xD7, 0x15, + 0x7C, 0x17, 0xA8, 0x48, 0xB8, 0xA3, 0xC6, 0x56, + 0xEB, 0x11, 0x38, 0xAE, 0x5A, 0x0A, 0xD9, 0x2E + }, + { + 0x13, 0x16, 0x83, 0x77, 0xCC, 0x36, 0x95, 0x41, + 0xF6, 0x81, 0x9B, 0x43, 0x6D, 0x22, 0xA2, 0x60, + 0xD3, 0xE8, 0x24, 0xEC, 0x54, 0xA1, 0xAE, 0x69, + 0xD9, 0x7B, 0x57, 0x07, 0x27, 0x15, 0xE5, 0x4F, + 0x1C, 0x49, 0x62, 0xBB, 0x27, 0x80, 0x11, 0x0B, + 0x18, 0xFB, 0xB2, 0x58, 0xEB, 0x4A, 0x47, 0x38, + 0x1A, 0x70, 0x9E, 0x60, 0x91, 0x81, 0x7D, 0x15, + 0x56, 0xF8, 0x56, 0xE6, 0xFA, 0xC2, 0xA9, 0xB4 + }, + { + 0xC5, 0x9A, 0xB1, 0x09, 0x5C, 0xA4, 0x57, 0x95, + 0x25, 0x33, 0x8B, 0x6B, 0x74, 0x68, 0x9F, 0xF2, + 0x34, 0xBC, 0x3F, 0xE9, 0x76, 0x5F, 0xE2, 0x6D, + 0xFB, 0x04, 0xDD, 0xCE, 0xAE, 0xE0, 0xAB, 0x84, + 0xDF, 0xD8, 0x96, 0x75, 0x94, 0xCB, 0x26, 0x1F, + 0xCD, 0x88, 0x68, 0x7F, 0x44, 0x54, 0xD8, 0x0F, + 0x71, 0x81, 0x16, 0xC1, 0xB3, 0xC3, 0x2F, 0x9F, + 0x7E, 0x16, 0x93, 0x57, 0x46, 0x8C, 0xBE, 0x67 + }, + { + 0x68, 0x81, 0x2F, 0x69, 0x5B, 0xBB, 0x6B, 0xDE, + 0xD5, 0xE1, 0x2B, 0xB3, 0x7C, 0x08, 0xA9, 0x9F, + 0xBA, 0xB6, 0xE7, 0x1B, 0x18, 0xB0, 0x45, 0x22, + 0x30, 0x82, 0x79, 0x1B, 0x12, 0x0D, 0x85, 0x88, + 0xA9, 0xC4, 0x24, 0x66, 0x97, 0x0A, 0xDA, 0xDD, + 0xDE, 0xB7, 0x70, 0xEF, 0x5F, 0x1C, 0xDE, 0xBD, + 0x24, 0xC8, 0x1A, 0x35, 0x19, 0xAF, 0x97, 0x7E, + 0x6B, 0x53, 0x93, 0x66, 0xC8, 0x38, 0xCF, 0xAA + }, + { + 0x07, 0x48, 0xF6, 0xE9, 0xE8, 0xC2, 0xDA, 0xBD, + 0xB8, 0xA1, 0xEB, 0xFD, 0xD6, 0x58, 0x5B, 0x90, + 0x25, 0xCA, 0x95, 0xD8, 0xDB, 0xFE, 0xE8, 0xAA, + 0x30, 0x57, 0xF4, 0x51, 0x20, 0x17, 0xA2, 0x91, + 0x8B, 0xFD, 0x86, 0x35, 0xE6, 0x3D, 0x92, 0xE2, + 0xC1, 0x02, 0xF5, 0x46, 0xAF, 0xEA, 0x64, 0xB8, + 0xE3, 0x6C, 0x71, 0x11, 0xE2, 0xAF, 0x85, 0x51, + 0xAB, 0x07, 0x54, 0x0B, 0xE4, 0x08, 0xAF, 0x9A + }, + { + 0x1A, 0x1B, 0x59, 0xC7, 0x0E, 0x8D, 0x28, 0x4E, + 0x9C, 0x52, 0xEF, 0xD6, 0x5A, 0x98, 0xCB, 0xE3, + 0x88, 0x3C, 0xD7, 0xE0, 0xD5, 0x43, 0x22, 0x1B, + 0x09, 0x77, 0x5C, 0x09, 0x27, 0x3D, 0x7E, 0xEC, + 0x8B, 0x8D, 0x26, 0x8A, 0xB3, 0x4B, 0xED, 0x64, + 0x2B, 0x59, 0x49, 0xD8, 0xA6, 0x1B, 0x2B, 0x52, + 0x71, 0xDB, 0x5E, 0x72, 0xEA, 0xFD, 0x32, 0xB3, + 0x0B, 0x24, 0x81, 0x59, 0xFC, 0x60, 0x0D, 0xA4 + }, + { + 0x19, 0x0F, 0xE8, 0x49, 0x3C, 0x13, 0x14, 0xED, + 0xCB, 0x5A, 0x49, 0x48, 0xDC, 0x67, 0x1B, 0xAE, + 0xED, 0x07, 0x9B, 0x23, 0x48, 0xB1, 0x3D, 0xCF, + 0x6C, 0xE1, 0x0A, 0x6E, 0x5C, 0x2F, 0x05, 0x32, + 0x42, 0x92, 0xCB, 0x07, 0xCF, 0x34, 0x3A, 0x79, + 0x91, 0x6C, 0x04, 0xF5, 0x82, 0x5F, 0x3D, 0x34, + 0x41, 0x52, 0xC8, 0x2A, 0x2D, 0x40, 0x96, 0xCD, + 0x68, 0x02, 0xA4, 0xDB, 0x78, 0xB2, 0x46, 0x54 + }, + { + 0xB8, 0x54, 0x3E, 0x90, 0x6C, 0x52, 0xEB, 0xD2, + 0xBB, 0x88, 0xE0, 0x70, 0x36, 0x3E, 0xC3, 0xB9, + 0x3D, 0xF0, 0x53, 0xE4, 0x50, 0xB1, 0x3B, 0x83, + 0x9F, 0xFC, 0x00, 0x0D, 0x7C, 0xAB, 0x84, 0xB9, + 0xF9, 0x8B, 0xC2, 0xB6, 0x0F, 0xB5, 0xF6, 0xE2, + 0x3D, 0x67, 0x63, 0x9B, 0x80, 0x70, 0x3D, 0x93, + 0xD9, 0xD6, 0xC5, 0xFA, 0x2C, 0x4C, 0xAB, 0xB2, + 0x93, 0xFD, 0xC9, 0x7B, 0xF9, 0x0F, 0x2C, 0x05 + }, + { + 0xF8, 0x82, 0x0F, 0xDD, 0xF8, 0x64, 0xE9, 0xA3, + 0x34, 0xAF, 0xEF, 0x7A, 0x22, 0xA5, 0xE2, 0x0C, + 0x87, 0x82, 0xD8, 0x82, 0x17, 0xD2, 0x6A, 0xA8, + 0x4E, 0xDE, 0xCF, 0x09, 0x16, 0x9D, 0x35, 0x76, + 0x41, 0x32, 0x01, 0x03, 0x4A, 0xDA, 0x18, 0xE3, + 0x00, 0xB5, 0x96, 0xFB, 0x1D, 0xA3, 0x7E, 0xD1, + 0xF1, 0xBF, 0x9F, 0xFC, 0x30, 0x20, 0x07, 0x66, + 0xA6, 0x56, 0x3B, 0x96, 0xA8, 0xE3, 0x7D, 0x55 + }, + { + 0x51, 0xC8, 0xB6, 0xB9, 0xA1, 0x0A, 0xAE, 0xA0, + 0x97, 0xD0, 0xE0, 0xD3, 0x9E, 0xAB, 0xAC, 0x9A, + 0xF7, 0xCE, 0x4D, 0x58, 0x09, 0xD1, 0x5E, 0xA7, + 0x5B, 0xD9, 0x6D, 0xC3, 0xF1, 0x1C, 0x5F, 0x5A, + 0xAE, 0xE9, 0xA7, 0x66, 0xB2, 0x0A, 0x24, 0x76, + 0x61, 0x7C, 0xF6, 0xCE, 0xBD, 0x95, 0xE6, 0xE2, + 0x1B, 0x49, 0x8F, 0x64, 0x23, 0xD7, 0xDB, 0x4D, + 0x8A, 0x36, 0x74, 0x1A, 0xE6, 0xEC, 0x6D, 0xF0 + }, + { + 0x3F, 0x80, 0x3D, 0x60, 0x3B, 0x49, 0x73, 0x6D, + 0x96, 0x04, 0x96, 0x49, 0x57, 0xFA, 0xFA, 0x6A, + 0x57, 0x4C, 0x7C, 0xF4, 0x3D, 0xC8, 0x17, 0x76, + 0xF2, 0xDC, 0xF6, 0xEC, 0xE4, 0xB0, 0xC9, 0xE4, + 0xEE, 0x79, 0x32, 0xE1, 0xCA, 0xBE, 0x36, 0x25, + 0xF0, 0xB1, 0xD1, 0x30, 0xDB, 0xD0, 0xC3, 0x94, + 0x44, 0x5D, 0x50, 0x29, 0xF1, 0x96, 0xCA, 0x85, + 0xDA, 0xDC, 0xAE, 0xEB, 0x44, 0x53, 0xEB, 0x9B + }, + { + 0x24, 0x4F, 0xE0, 0x4F, 0x33, 0x34, 0x55, 0x7A, + 0xF1, 0x19, 0x4F, 0x0A, 0x03, 0xC9, 0x74, 0xEC, + 0x51, 0x68, 0x22, 0x81, 0x97, 0xFC, 0xD9, 0x28, + 0xDF, 0x36, 0x05, 0xC2, 0x17, 0x52, 0x81, 0x52, + 0xE0, 0x42, 0xA3, 0x54, 0xDE, 0x24, 0xE6, 0x67, + 0xCA, 0x80, 0x17, 0xC8, 0x7C, 0x4B, 0x5B, 0xFE, + 0x48, 0x97, 0x24, 0xA2, 0x3B, 0x27, 0xE4, 0xE0, + 0xD9, 0xAD, 0x09, 0x30, 0x93, 0x63, 0x99, 0x6B + }, + { + 0xC0, 0x4A, 0xFD, 0x62, 0x7F, 0x4E, 0x63, 0x92, + 0x18, 0x42, 0x65, 0x79, 0x48, 0x35, 0xE8, 0x02, + 0x62, 0xBA, 0x3C, 0x03, 0x61, 0x90, 0x6D, 0x2A, + 0x3D, 0x60, 0x21, 0xC2, 0x4C, 0xE1, 0x69, 0x02, + 0xEF, 0xB3, 0x56, 0xDD, 0x2A, 0xEC, 0xFD, 0xE5, + 0xDB, 0xFE, 0x06, 0x2C, 0x8B, 0xB2, 0xB2, 0x19, + 0xA6, 0x75, 0x1F, 0x1A, 0x04, 0x47, 0xC9, 0xE6, + 0x80, 0x9D, 0xE8, 0x01, 0x1C, 0x77, 0xBB, 0x99 + }, + { + 0xC8, 0xA4, 0x6F, 0x6B, 0x7F, 0xC4, 0x91, 0x19, + 0x10, 0x8E, 0x9B, 0xE5, 0x3E, 0x98, 0x16, 0xD7, + 0x31, 0x8C, 0x8A, 0xB2, 0x7B, 0x20, 0xC0, 0x22, + 0xE5, 0x58, 0x23, 0xEE, 0xAB, 0x48, 0x24, 0x01, + 0xF8, 0x2C, 0xD0, 0x21, 0x05, 0xBE, 0x6E, 0x9F, + 0xCC, 0x2E, 0x9B, 0x7B, 0xE7, 0x88, 0x9C, 0x59, + 0x00, 0x28, 0x58, 0x39, 0xD9, 0xF5, 0x38, 0x8C, + 0x65, 0x6F, 0x18, 0xF3, 0x81, 0x63, 0xF5, 0xFC + }, + { + 0x25, 0x17, 0x7D, 0x4A, 0xE7, 0xEE, 0xAC, 0x1D, + 0x18, 0x0F, 0xBC, 0x90, 0xB0, 0xDC, 0xB6, 0xC3, + 0xB2, 0x20, 0x2A, 0xEB, 0x17, 0x46, 0x47, 0x2E, + 0x80, 0x3B, 0x6D, 0x6C, 0x6F, 0xC8, 0x88, 0x67, + 0x1B, 0xAD, 0x3B, 0x99, 0x4A, 0x50, 0xDA, 0xC2, + 0xAC, 0xB8, 0x26, 0xC2, 0x42, 0x8F, 0x13, 0x75, + 0xA4, 0x1E, 0xA8, 0x39, 0x13, 0xA4, 0x3F, 0x01, + 0x4C, 0xD6, 0xC0, 0x58, 0x6F, 0x4F, 0xA6, 0x79 + }, + { + 0x71, 0xB1, 0xBC, 0xF0, 0xFB, 0xE2, 0xE0, 0x93, + 0x2C, 0x79, 0xB1, 0x17, 0xB1, 0xC0, 0x42, 0x08, + 0x49, 0x96, 0x91, 0xB4, 0x10, 0xF7, 0x1F, 0x92, + 0x9A, 0x96, 0xA8, 0x46, 0x3A, 0x43, 0xB0, 0x6E, + 0xCC, 0xF2, 0x26, 0x14, 0xEF, 0x64, 0xFA, 0xF2, + 0x76, 0x0B, 0xB3, 0xDA, 0x5D, 0x6C, 0xE8, 0xDB, + 0x46, 0x5A, 0x39, 0xDA, 0x34, 0x2F, 0x84, 0x90, + 0x00, 0x33, 0xBA, 0x7F, 0x03, 0x26, 0x3F, 0x44 + }, + { + 0x8E, 0xC5, 0x96, 0x0B, 0x4E, 0x3A, 0xD4, 0x4D, + 0xF3, 0xED, 0x2B, 0x3E, 0x4E, 0x32, 0x0C, 0xE9, + 0x87, 0x72, 0x6C, 0x54, 0xD5, 0x7C, 0x83, 0xB5, + 0x80, 0xAA, 0xDD, 0x7B, 0x41, 0x00, 0xB0, 0xF8, + 0x89, 0x79, 0xED, 0x1A, 0x28, 0x7A, 0xCB, 0xE1, + 0xE5, 0xBA, 0x50, 0x70, 0x2B, 0x64, 0x6E, 0x2B, + 0x04, 0x00, 0xBB, 0x1E, 0x98, 0xAE, 0x96, 0xDA, + 0xB0, 0x9A, 0xCC, 0x21, 0x73, 0x3A, 0x00, 0x7D + }, + { + 0xBF, 0xE9, 0x73, 0x60, 0xAF, 0x64, 0x7E, 0xE8, + 0x73, 0xE3, 0xBB, 0x9F, 0x4E, 0xFD, 0xEE, 0xFC, + 0x14, 0x0E, 0x6C, 0x38, 0x01, 0x0F, 0x94, 0xA5, + 0xA2, 0x7B, 0x9E, 0x46, 0x38, 0x54, 0x87, 0x4C, + 0xF1, 0x18, 0x01, 0xCC, 0x85, 0x5F, 0xCE, 0x90, + 0x88, 0x6B, 0xD3, 0x07, 0xAA, 0xFE, 0x17, 0x59, + 0x3C, 0xBC, 0x74, 0x72, 0xED, 0x7C, 0x42, 0xEB, + 0xD3, 0xD1, 0x12, 0x4A, 0xC4, 0x39, 0xC7, 0x1E + }, + { + 0xB0, 0xC1, 0x86, 0xAD, 0x8C, 0xCA, 0xD5, 0x71, + 0xCF, 0x7E, 0xB8, 0x5D, 0x03, 0x32, 0xD4, 0xE4, + 0x50, 0xA6, 0x4E, 0xEF, 0x1B, 0xBD, 0xD8, 0x61, + 0x1C, 0x9F, 0xB6, 0x75, 0xB7, 0x4A, 0xCB, 0x07, + 0x47, 0x8F, 0xB6, 0x61, 0x4A, 0x4F, 0x2D, 0x79, + 0x05, 0x35, 0x62, 0xE8, 0xB6, 0x9B, 0x27, 0xD1, + 0xC2, 0x68, 0x39, 0xEE, 0x34, 0x39, 0x36, 0xFE, + 0xEB, 0x53, 0xAE, 0x91, 0xBC, 0xF3, 0xBF, 0x6B + }, + { + 0x64, 0x7B, 0xF1, 0x56, 0x0B, 0x47, 0x14, 0x97, + 0xF0, 0xBE, 0xFA, 0x84, 0xB3, 0x45, 0x7D, 0x3D, + 0x50, 0x39, 0x06, 0x8F, 0x26, 0xA8, 0x6D, 0x65, + 0xAD, 0x86, 0xF0, 0x5D, 0x59, 0x7B, 0xF3, 0xF5, + 0x9A, 0x04, 0xFA, 0x33, 0x4A, 0xDE, 0xE0, 0x99, + 0x5B, 0x8E, 0x4C, 0xC2, 0x79, 0x4D, 0x5C, 0xC3, + 0xDC, 0x1C, 0xFF, 0x84, 0x90, 0x91, 0x6D, 0xC4, + 0xE5, 0x67, 0x94, 0x8F, 0x57, 0x60, 0x56, 0xBF + }, + { + 0xBD, 0xD4, 0x19, 0x62, 0x0E, 0x46, 0xA3, 0x35, + 0x01, 0xE4, 0xA6, 0xFF, 0x91, 0x9A, 0x50, 0x81, + 0x0B, 0xDD, 0x36, 0x1E, 0x54, 0xAA, 0x33, 0xEB, + 0x41, 0x60, 0xC1, 0x4D, 0x41, 0x80, 0x1D, 0x81, + 0x98, 0xCA, 0x63, 0xCD, 0x4A, 0x82, 0xC7, 0xED, + 0x7F, 0x82, 0xF9, 0xD7, 0xD5, 0xFF, 0x08, 0x0C, + 0x0C, 0xD4, 0xAB, 0xDA, 0xFA, 0xA5, 0xF2, 0xB4, + 0x55, 0x3A, 0x06, 0x2C, 0x29, 0x8D, 0x5F, 0x48 + }, + { + 0x84, 0x72, 0x6D, 0x43, 0x31, 0x90, 0x6E, 0x43, + 0x41, 0x5B, 0xD4, 0x79, 0x45, 0xA9, 0xC5, 0x81, + 0x2E, 0x8F, 0xED, 0x00, 0xBD, 0x3F, 0x10, 0xCE, + 0xD1, 0x67, 0x35, 0xEE, 0x92, 0x6D, 0x11, 0x5E, + 0x4D, 0xC9, 0xE3, 0x2F, 0xD5, 0xF4, 0x0D, 0x3C, + 0xA3, 0x48, 0xB8, 0x42, 0xA8, 0x88, 0x70, 0xAD, + 0xE4, 0x24, 0x97, 0xF2, 0x14, 0x73, 0x7E, 0xC1, + 0xAB, 0xB1, 0xE7, 0xE6, 0xF0, 0x22, 0x8F, 0x9D + }, + { + 0x3D, 0x80, 0x9B, 0x3C, 0xE2, 0x4C, 0x71, 0x72, + 0x13, 0xD1, 0x5A, 0x9A, 0xC6, 0x74, 0xC2, 0x4D, + 0xA4, 0x4B, 0x3C, 0xD1, 0xC4, 0x7C, 0xEB, 0x0A, + 0x97, 0x7C, 0x44, 0xD5, 0x65, 0xB0, 0x1B, 0xB9, + 0xBC, 0x0D, 0xA4, 0x91, 0xB9, 0x51, 0x1C, 0x05, + 0x9F, 0x4C, 0x4F, 0x32, 0xD3, 0x6E, 0x0C, 0x62, + 0x49, 0x4F, 0x3E, 0x52, 0x6E, 0x8B, 0x1E, 0x27, + 0x10, 0x9E, 0xBF, 0xB0, 0x69, 0x01, 0x75, 0x17 + }, + { + 0xCD, 0xBD, 0x97, 0x0D, 0xCA, 0x99, 0xA0, 0x07, + 0x62, 0xA7, 0xB2, 0xF3, 0x3B, 0xEB, 0x57, 0x20, + 0xD7, 0xFD, 0x89, 0x67, 0x87, 0xBA, 0x33, 0x2F, + 0x4D, 0x6B, 0xB8, 0x1D, 0x5F, 0x90, 0xCD, 0x5D, + 0x2D, 0x4C, 0x8D, 0x9C, 0x26, 0xD5, 0x88, 0x6A, + 0xFF, 0xB2, 0x48, 0x61, 0x44, 0x7A, 0xEC, 0xEC, + 0x6B, 0x49, 0x03, 0xC1, 0xFE, 0x1B, 0xEC, 0x8A, + 0x15, 0xDF, 0x0D, 0x7E, 0x18, 0xC4, 0xCF, 0x63 + }, + { + 0xA5, 0x2D, 0xBA, 0xB0, 0xCB, 0x5D, 0xF7, 0x16, + 0x09, 0xFA, 0x4C, 0x95, 0x19, 0xE1, 0x12, 0x01, + 0x4B, 0x49, 0x5D, 0x05, 0x80, 0x21, 0xBA, 0xFF, + 0xA7, 0x84, 0x7E, 0xFF, 0x68, 0x7E, 0xB8, 0xC9, + 0xEA, 0x92, 0x96, 0xB4, 0x6E, 0x4B, 0x0F, 0x2F, + 0xE1, 0x8C, 0xFF, 0xE7, 0x56, 0xB9, 0xC1, 0xD4, + 0xC9, 0x1C, 0x56, 0x72, 0xD0, 0xFA, 0xEC, 0x17, + 0x77, 0x35, 0x8D, 0xE1, 0xB4, 0x64, 0x61, 0x9C + }, + { + 0x76, 0x6E, 0xD9, 0x90, 0x61, 0x0B, 0x6A, 0x36, + 0x38, 0x82, 0x3A, 0x7F, 0xF9, 0x76, 0x9A, 0x5F, + 0xDF, 0xF0, 0xB4, 0x10, 0x73, 0xD0, 0x9E, 0x38, + 0x86, 0x01, 0x36, 0xD5, 0x98, 0x9B, 0xA2, 0x8A, + 0x56, 0xD3, 0xC9, 0x19, 0x1B, 0x1B, 0x4E, 0x42, + 0x74, 0x11, 0x88, 0x9F, 0x46, 0x1A, 0x79, 0x4D, + 0xDD, 0xEF, 0xFE, 0x59, 0x2F, 0x44, 0x6C, 0xE1, + 0x4F, 0x2A, 0x1B, 0x17, 0x6C, 0xDA, 0x77, 0x44 + }, + { + 0x37, 0x1C, 0x16, 0xBC, 0x7F, 0xDE, 0xD1, 0x8F, + 0xE5, 0x5D, 0x40, 0x29, 0xB5, 0x00, 0x6A, 0x2D, + 0x78, 0x48, 0x05, 0x0E, 0x6B, 0x43, 0x9F, 0xF0, + 0x80, 0x07, 0xCC, 0x60, 0x20, 0x0F, 0x1A, 0xA7, + 0x9F, 0x50, 0x56, 0x5B, 0x5C, 0x5D, 0x30, 0x73, + 0xF1, 0x12, 0xAC, 0x05, 0x6C, 0x6E, 0x2A, 0x5F, + 0x1D, 0xB2, 0xF4, 0xC9, 0xDA, 0x11, 0x8E, 0x33, + 0x1B, 0x42, 0x34, 0x5D, 0x55, 0xD3, 0x59, 0xBE + }, + { + 0x4A, 0x13, 0x9D, 0x09, 0xC5, 0x8D, 0xB2, 0xC1, + 0xA9, 0xDB, 0x2E, 0x21, 0x6E, 0x57, 0x3F, 0x44, + 0x9A, 0x56, 0x3C, 0xA4, 0x1A, 0xDE, 0x35, 0x81, + 0xD4, 0xAA, 0x3A, 0x42, 0xE0, 0xE9, 0xA4, 0xFE, + 0xC6, 0x05, 0xEC, 0x9A, 0x4C, 0x87, 0x34, 0x20, + 0xD2, 0xDE, 0x12, 0xF1, 0xF1, 0x4E, 0xA6, 0x4D, + 0x0E, 0xB3, 0xE7, 0xCF, 0x5B, 0x61, 0x0C, 0x26, + 0x99, 0x6D, 0xE3, 0xBA, 0xEE, 0xAE, 0x6C, 0x1B + }, + { + 0x18, 0x59, 0x08, 0x71, 0xE2, 0x46, 0x43, 0xE1, + 0x42, 0xFF, 0x97, 0x35, 0x4C, 0x9D, 0x30, 0x60, + 0xE4, 0xF0, 0x57, 0x01, 0xE6, 0x7E, 0x64, 0x6D, + 0x21, 0xC1, 0xDB, 0x98, 0x26, 0xC6, 0x3A, 0x91, + 0x55, 0xE7, 0xAF, 0x73, 0xA3, 0x9A, 0x5C, 0x7B, + 0x5B, 0xDB, 0x8D, 0x02, 0x10, 0xE1, 0x67, 0x73, + 0x41, 0x22, 0xDC, 0x83, 0xCB, 0x23, 0x68, 0x2D, + 0x3B, 0xB2, 0x9E, 0x72, 0x18, 0xAA, 0xA5, 0x0C + }, + { + 0xB7, 0x54, 0x44, 0x19, 0x5F, 0x01, 0x61, 0x53, + 0x36, 0x3E, 0xBF, 0xCF, 0x4B, 0x6A, 0x6F, 0x49, + 0x08, 0x3D, 0x4B, 0x51, 0x5B, 0xA6, 0x7D, 0x34, + 0xB4, 0x7B, 0xD2, 0x24, 0xFC, 0x3C, 0x10, 0xD5, + 0x19, 0x70, 0xBB, 0x61, 0x9F, 0x07, 0xC6, 0xA1, + 0xD2, 0xCB, 0x7B, 0x08, 0x29, 0xFE, 0xFA, 0x47, + 0x0A, 0x8F, 0x9B, 0xEC, 0x77, 0xF5, 0xC3, 0x8F, + 0xBB, 0xC4, 0x74, 0xF5, 0x1E, 0xBA, 0xFE, 0xC3 + }, + { + 0xCA, 0xA9, 0x84, 0x86, 0x06, 0xD6, 0x30, 0x1C, + 0xB5, 0x02, 0xB9, 0xF4, 0x6B, 0xE8, 0x31, 0x5A, + 0xD6, 0x39, 0x12, 0x50, 0x1C, 0xE1, 0x97, 0x3D, + 0xF3, 0x47, 0x82, 0x69, 0x28, 0xFB, 0x61, 0xF5, + 0x0C, 0x1F, 0x6C, 0xFC, 0x52, 0x94, 0x6D, 0x8B, + 0x25, 0x57, 0xFE, 0x8C, 0xFB, 0x81, 0x29, 0x42, + 0xEF, 0x6D, 0x1D, 0xB8, 0x64, 0x97, 0x1E, 0xD3, + 0x7D, 0x39, 0xCC, 0x3E, 0x4B, 0xC1, 0x5C, 0x96 + }, + { + 0xFE, 0xFF, 0xAF, 0x72, 0x60, 0xC1, 0xFF, 0xDF, + 0x96, 0xD9, 0xED, 0x8E, 0x08, 0x56, 0xBC, 0x84, + 0xCC, 0x27, 0x84, 0x8A, 0x2C, 0xBF, 0x9E, 0x45, + 0x8E, 0xF6, 0x6F, 0x03, 0x7A, 0xC5, 0xD4, 0xE9, + 0x38, 0x37, 0x38, 0xE1, 0x90, 0xD4, 0x70, 0xEE, + 0x5A, 0xE8, 0x23, 0x8C, 0xED, 0x11, 0x9E, 0xF2, + 0x97, 0x3F, 0xA6, 0xA6, 0x8A, 0x8F, 0x76, 0x9B, + 0x9A, 0x87, 0xBE, 0xF3, 0x82, 0x7B, 0xD1, 0x40 + }, + { + 0xFB, 0x22, 0x36, 0xA0, 0x8C, 0x51, 0xC3, 0xD4, + 0x41, 0xC2, 0x36, 0xA7, 0x95, 0xF5, 0x77, 0x56, + 0xD1, 0x1E, 0xA0, 0x9D, 0xFB, 0x2B, 0xF1, 0x8C, + 0xF7, 0x73, 0x58, 0x78, 0x61, 0xE4, 0x91, 0xBD, + 0xA0, 0xC6, 0x08, 0xFF, 0xAD, 0xED, 0x81, 0x4A, + 0xF2, 0x71, 0x07, 0x7F, 0x2B, 0xD9, 0xD7, 0x73, + 0xB8, 0xB3, 0x11, 0xC9, 0x1C, 0xB9, 0xC7, 0x44, + 0xB8, 0x6A, 0xBE, 0x68, 0x7C, 0x40, 0x20, 0xD5 + }, + { + 0x6C, 0xD7, 0x05, 0xE1, 0x4F, 0x7A, 0xEE, 0x44, + 0x33, 0xCA, 0x80, 0xD6, 0x60, 0xEA, 0x54, 0x90, + 0x29, 0x91, 0x6F, 0x5F, 0xDA, 0x20, 0x7C, 0xDA, + 0x3D, 0x45, 0x24, 0xE1, 0x12, 0x89, 0xDE, 0x57, + 0x5F, 0x6E, 0x24, 0x74, 0xEE, 0x2A, 0x03, 0x61, + 0x00, 0x69, 0xEE, 0xD4, 0xBC, 0xD8, 0x27, 0x54, + 0x99, 0x2E, 0x27, 0x2E, 0x7E, 0xEB, 0xC1, 0x77, + 0x15, 0x85, 0x8A, 0x67, 0xA5, 0xF1, 0x54, 0xFB + }, + { + 0x4B, 0x70, 0xC2, 0xA9, 0xE8, 0xB6, 0xAD, 0x6D, + 0xDE, 0x32, 0x29, 0xEA, 0xB3, 0x78, 0xD6, 0xC3, + 0x9D, 0x62, 0x48, 0x64, 0x3A, 0x9E, 0x11, 0xC6, + 0x72, 0x04, 0x49, 0xE1, 0x79, 0xEB, 0x8F, 0x01, + 0xCA, 0xE2, 0xA0, 0xE9, 0x0F, 0x66, 0xF4, 0x58, + 0x34, 0xC6, 0x5A, 0x76, 0xD1, 0x51, 0x1F, 0xEE, + 0x11, 0x10, 0xB7, 0xB3, 0x2B, 0x6C, 0xEA, 0x42, + 0x1B, 0xF6, 0x71, 0x65, 0x59, 0x9C, 0x96, 0x97 + }, + { + 0x8E, 0x3B, 0x3B, 0x9D, 0xB3, 0xDB, 0x70, 0x8C, + 0x83, 0x0A, 0xBA, 0xF7, 0x8C, 0xD7, 0x93, 0x19, + 0x90, 0xB1, 0xAF, 0xA5, 0xC4, 0xEF, 0x81, 0x60, + 0x8B, 0xC3, 0xDD, 0xC2, 0x28, 0x25, 0x03, 0x25, + 0xF5, 0xEA, 0xC0, 0x2C, 0xAB, 0x0D, 0xAA, 0x5A, + 0x07, 0x0B, 0x0C, 0x38, 0x90, 0xA9, 0x4A, 0x6A, + 0x13, 0x34, 0x10, 0x52, 0xF3, 0x45, 0x01, 0x9B, + 0x9E, 0x0A, 0x99, 0x25, 0x62, 0x2D, 0x74, 0x6A + }, + { + 0x95, 0xA8, 0xAE, 0xA8, 0x74, 0x0B, 0xB5, 0x6D, + 0x1D, 0x9D, 0xAD, 0xB1, 0x55, 0xCE, 0xC9, 0xDE, + 0xDF, 0x2A, 0xB3, 0x8D, 0x2A, 0x03, 0xB8, 0x58, + 0x82, 0x1A, 0xCE, 0xC3, 0x38, 0xC1, 0x75, 0xE6, + 0xF3, 0x91, 0x0B, 0x4B, 0x42, 0x5A, 0xB1, 0xE4, + 0x8A, 0x30, 0x0E, 0x06, 0xD7, 0x67, 0xDF, 0xED, + 0x98, 0x47, 0x62, 0xB8, 0x37, 0xB2, 0x52, 0x7C, + 0x44, 0x88, 0xBA, 0xFC, 0x6D, 0xFD, 0x76, 0xB5 + }, + { + 0x09, 0xE8, 0xBA, 0xF5, 0xA0, 0x5F, 0xD9, 0x9B, + 0xA1, 0xAB, 0xD0, 0x27, 0x9F, 0x26, 0x7F, 0x02, + 0xED, 0x43, 0xA4, 0x00, 0xA6, 0x6C, 0xD3, 0xB5, + 0x16, 0x51, 0x20, 0xD6, 0x35, 0x35, 0xAE, 0x1A, + 0xAC, 0x01, 0xAF, 0x9B, 0x99, 0xEF, 0x59, 0xCE, + 0x7E, 0x6B, 0x12, 0xAB, 0x47, 0xB8, 0x94, 0xFF, + 0xEA, 0x81, 0x78, 0x3E, 0x2E, 0x79, 0x70, 0xEB, + 0xEF, 0xBC, 0xA4, 0x04, 0x4A, 0xD6, 0x5E, 0x27 + }, + { + 0x50, 0xF6, 0x8B, 0xA4, 0xD7, 0xE6, 0x2F, 0xEC, + 0xC1, 0x54, 0x05, 0xBB, 0x99, 0x30, 0xA0, 0x85, + 0x2F, 0x3B, 0x17, 0xD3, 0x77, 0xE6, 0x68, 0xD3, + 0xB4, 0x40, 0x2E, 0xC2, 0x0A, 0xA3, 0x88, 0xDC, + 0x4E, 0x24, 0x3B, 0x4B, 0xD8, 0xA4, 0xB7, 0xC9, + 0x0B, 0xA4, 0xB9, 0x67, 0x96, 0x47, 0x68, 0x9E, + 0x68, 0xCA, 0x5C, 0x67, 0x9F, 0xB2, 0xDA, 0xC5, + 0x31, 0xD3, 0x9A, 0x30, 0xEC, 0x9C, 0x74, 0xF8 + }, + { + 0x2D, 0xE6, 0x15, 0xAA, 0x3B, 0x79, 0x03, 0x6E, + 0x48, 0x02, 0x03, 0x35, 0xA4, 0x8D, 0xAA, 0x61, + 0x98, 0xFC, 0xA2, 0x93, 0x1A, 0x07, 0xD7, 0xF0, + 0x31, 0xB5, 0x8F, 0x07, 0x38, 0xF9, 0xEC, 0x91, + 0xB8, 0x28, 0x60, 0x28, 0xBD, 0xE9, 0x41, 0xEE, + 0x02, 0xEC, 0x88, 0x01, 0x92, 0x1C, 0xDF, 0x29, + 0x1A, 0x8D, 0xB0, 0x51, 0xBB, 0xA6, 0x97, 0x1E, + 0x67, 0xB1, 0x85, 0xF4, 0x58, 0xCD, 0x3C, 0x98 + }, + { + 0xC3, 0x1C, 0xD3, 0x33, 0xBA, 0x18, 0x26, 0xF7, + 0xD3, 0xAF, 0xF6, 0x9E, 0xF9, 0xDC, 0x42, 0x5C, + 0x86, 0x13, 0x64, 0x71, 0x4A, 0xC1, 0xFC, 0x64, + 0x14, 0xB5, 0x10, 0xC9, 0x16, 0x94, 0xFA, 0xB3, + 0x46, 0x54, 0x97, 0xCB, 0xF1, 0x0C, 0xB5, 0x71, + 0x6F, 0x9D, 0x9E, 0x07, 0xA3, 0xBD, 0x94, 0xE1, + 0xAE, 0x35, 0xF2, 0x78, 0x04, 0xA2, 0xDB, 0xCE, + 0xB2, 0x9A, 0x0B, 0x50, 0xE4, 0x8C, 0x00, 0xCE + }, + { + 0x5A, 0xE7, 0x8F, 0xC9, 0xEB, 0x8D, 0x3E, 0xEE, + 0x4A, 0x71, 0xAB, 0x7A, 0x6B, 0x14, 0x58, 0xE2, + 0x70, 0xB3, 0xD6, 0xDC, 0x1B, 0x4F, 0xA1, 0xA7, + 0xAF, 0xEB, 0xC2, 0x2D, 0x93, 0x10, 0x65, 0xE6, + 0x3E, 0x1E, 0x32, 0xAF, 0x2A, 0x7A, 0xB0, 0xB7, + 0x93, 0x29, 0x51, 0x41, 0xF4, 0x4C, 0x30, 0xAA, + 0xF3, 0xFD, 0xAA, 0xB7, 0x72, 0x1F, 0x13, 0x6F, + 0x0A, 0x3D, 0x39, 0x0D, 0x18, 0x0F, 0x00, 0xEC + }, + { + 0x25, 0x66, 0xDB, 0x5E, 0xD7, 0xF6, 0x0B, 0x84, + 0x1A, 0x8A, 0x92, 0x28, 0x24, 0x1C, 0x4C, 0xB7, + 0x5B, 0x21, 0x55, 0x69, 0xF9, 0xE6, 0xBB, 0x89, + 0xC4, 0x03, 0x5F, 0xC7, 0x29, 0x39, 0x94, 0xE3, + 0xAE, 0xD9, 0x43, 0x3B, 0x3C, 0x3A, 0x27, 0xFD, + 0xAD, 0x9D, 0xEF, 0xB5, 0x1B, 0x89, 0xA0, 0x93, + 0x6F, 0x4D, 0x97, 0xF5, 0x9D, 0x1A, 0xF2, 0xD0, + 0x98, 0xD1, 0x57, 0xD9, 0x9B, 0x47, 0x06, 0x82 + }, + { + 0x8A, 0xD4, 0x5D, 0xF1, 0xC8, 0x44, 0x4B, 0xAE, + 0xE2, 0x4C, 0x2A, 0x20, 0x24, 0xE9, 0x46, 0xF0, + 0x0D, 0x50, 0x78, 0x84, 0x5F, 0x28, 0xCD, 0x2E, + 0xDE, 0xC5, 0x63, 0xA9, 0x03, 0x97, 0xC4, 0xB1, + 0xA1, 0x6C, 0x17, 0x99, 0x6F, 0x1F, 0x03, 0xED, + 0x94, 0x8B, 0x31, 0x15, 0xEB, 0x98, 0x15, 0x16, + 0xDE, 0xE4, 0x8C, 0x59, 0xB8, 0x8E, 0xF2, 0xC7, + 0x58, 0x1C, 0xF9, 0xF5, 0x41, 0x00, 0x4F, 0x9A + }, + { + 0x45, 0x49, 0x66, 0x64, 0xFC, 0xE0, 0x60, 0x94, + 0xDF, 0x7F, 0xCB, 0xA6, 0x5E, 0xF4, 0x6E, 0xD2, + 0x3D, 0x62, 0x2C, 0x38, 0xA2, 0x4F, 0x98, 0x39, + 0x55, 0x2C, 0x91, 0xA2, 0x7B, 0x22, 0x47, 0x96, + 0x10, 0x1C, 0x47, 0x3A, 0x56, 0x45, 0x4D, 0x4C, + 0xBA, 0x48, 0xB7, 0x28, 0xD1, 0xBE, 0xE3, 0x80, + 0x39, 0xD3, 0x1E, 0x7D, 0x33, 0xF6, 0x9B, 0xF9, + 0xCF, 0x10, 0x95, 0x28, 0x32, 0x51, 0xE2, 0xE4 + }, + { + 0x09, 0xA0, 0xD4, 0xDC, 0x93, 0x57, 0x94, 0x99, + 0xD3, 0xED, 0xDD, 0x9D, 0x3D, 0x50, 0x44, 0xB2, + 0x4F, 0x74, 0x74, 0x74, 0x5C, 0x10, 0xE9, 0x02, + 0xC1, 0x3E, 0x77, 0xD1, 0xD6, 0x32, 0x27, 0x21, + 0xF9, 0x18, 0x3B, 0x51, 0x0C, 0x90, 0xC3, 0x21, + 0x74, 0x29, 0x97, 0xF3, 0x93, 0x8D, 0x99, 0x5D, + 0x56, 0x5D, 0x32, 0x8D, 0x33, 0x5C, 0xDD, 0xF3, + 0xC8, 0x93, 0x11, 0x89, 0x32, 0x8C, 0x14, 0xD4 + }, + { + 0xB2, 0x44, 0xE9, 0xCC, 0x8C, 0xD1, 0xD3, 0xDB, + 0x32, 0xA4, 0xE9, 0x03, 0xC5, 0x85, 0x31, 0x58, + 0x22, 0xD7, 0x6B, 0xA5, 0x2F, 0xF4, 0xF5, 0x42, + 0x87, 0x17, 0x6B, 0x56, 0x51, 0x68, 0x99, 0x69, + 0xE8, 0x34, 0x8E, 0x14, 0x7F, 0xFD, 0x1C, 0x64, + 0xD5, 0x1C, 0xAC, 0xF0, 0xD8, 0xA8, 0x4C, 0xCE, + 0xC7, 0x87, 0x9C, 0x7B, 0x9F, 0xF1, 0x4D, 0x49, + 0x8D, 0x35, 0xDB, 0xDD, 0x08, 0xAE, 0x5E, 0x8B + }, + { + 0x28, 0xC9, 0x31, 0x2D, 0x01, 0xAF, 0x39, 0xC7, + 0x74, 0x83, 0x8E, 0x52, 0x54, 0x19, 0xD0, 0xA2, + 0xD3, 0x82, 0xF5, 0x0B, 0x29, 0xDE, 0xCE, 0x4D, + 0x74, 0x93, 0x78, 0xE9, 0x8B, 0x0A, 0xC0, 0x84, + 0x7B, 0xC5, 0x4D, 0xE7, 0xBC, 0x2E, 0x8A, 0x73, + 0x66, 0x35, 0xF4, 0x04, 0xB1, 0x7B, 0xFE, 0x7D, + 0x84, 0x6F, 0xE6, 0x23, 0x24, 0x10, 0x98, 0xD4, + 0xCB, 0x9B, 0x33, 0x57, 0x54, 0x4C, 0x29, 0x97 + }, + { + 0x77, 0xE4, 0xB2, 0xCC, 0xD0, 0xC7, 0x08, 0x6F, + 0x3B, 0x33, 0x86, 0x89, 0x28, 0xB6, 0x4E, 0x32, + 0x65, 0x06, 0x28, 0x01, 0x07, 0x8B, 0xDB, 0x62, + 0xA8, 0x8E, 0x86, 0xFE, 0x3D, 0x7B, 0x0A, 0x95, + 0x84, 0xA0, 0xAF, 0x7A, 0xF6, 0xEB, 0x62, 0xE1, + 0x0A, 0x85, 0xB4, 0x12, 0xDB, 0xBC, 0x2A, 0x3F, + 0xB7, 0x9A, 0xB4, 0x8D, 0x61, 0x45, 0xB9, 0x08, + 0x29, 0xFC, 0x75, 0xFA, 0xA7, 0xCA, 0x73, 0xA5 + }, + { + 0x5E, 0x4B, 0x48, 0xA4, 0xF7, 0x8E, 0xD7, 0xEC, + 0xEF, 0x0C, 0x88, 0x17, 0xD9, 0xFC, 0xA8, 0x2E, + 0x4A, 0x7A, 0x3F, 0xD2, 0x0A, 0x14, 0xE8, 0xF0, + 0xE6, 0xF2, 0xFD, 0x15, 0x63, 0x99, 0x80, 0x4F, + 0xF0, 0xAD, 0x30, 0x11, 0x4E, 0xA2, 0xA7, 0xF0, + 0x96, 0x7A, 0xAC, 0xE1, 0xE6, 0x53, 0xAA, 0xD5, + 0x96, 0xCC, 0x9E, 0xD2, 0x7C, 0xE1, 0xB8, 0xBF, + 0xA3, 0xFF, 0x26, 0x63, 0x1C, 0x7F, 0x6B, 0x59 + }, + { + 0x04, 0xC6, 0x43, 0xBA, 0xEB, 0x43, 0x84, 0xD3, + 0x43, 0x1E, 0x35, 0xA0, 0x3A, 0xE4, 0x1C, 0x78, + 0xEB, 0xD2, 0x12, 0xE8, 0x33, 0x1D, 0x94, 0x42, + 0xE6, 0xCB, 0x48, 0x88, 0xD9, 0xEB, 0xC2, 0x93, + 0x3F, 0x54, 0x67, 0x35, 0x5D, 0x0D, 0x41, 0x2E, + 0xB7, 0xFE, 0x36, 0x09, 0xB4, 0x3A, 0x02, 0xB7, + 0x0B, 0x56, 0x05, 0xA4, 0x00, 0xF4, 0xD7, 0x77, + 0xCC, 0xB1, 0x6E, 0x38, 0xFD, 0x13, 0x67, 0x16 + }, + { + 0x96, 0x3D, 0x44, 0xAC, 0xF8, 0x0A, 0x54, 0xEC, + 0x6A, 0x1D, 0x52, 0x0B, 0xB4, 0x38, 0x46, 0x6C, + 0x4A, 0x10, 0x81, 0xE6, 0xB4, 0x87, 0xF3, 0xC5, + 0xFD, 0xC9, 0xC4, 0xE0, 0xC8, 0x32, 0x2F, 0x32, + 0x9E, 0xC4, 0xE9, 0xF7, 0xFA, 0xED, 0xB2, 0xDB, + 0xEB, 0x5D, 0x7B, 0xF4, 0x1B, 0x95, 0xA7, 0xB6, + 0x7C, 0x42, 0xEC, 0xE5, 0x8E, 0x65, 0x46, 0xE7, + 0x82, 0x5D, 0x0C, 0x81, 0x58, 0x6A, 0x5A, 0xAF + }, + { + 0x25, 0x79, 0xD6, 0xA5, 0x40, 0x79, 0x13, 0x86, + 0x94, 0x86, 0xA0, 0xAC, 0x1B, 0x2A, 0x99, 0xF8, + 0x2C, 0x58, 0x1C, 0xE3, 0x71, 0x39, 0x39, 0x81, + 0xF2, 0xBA, 0x0F, 0x24, 0x5B, 0xF5, 0xC7, 0x69, + 0x53, 0xF1, 0x2B, 0xAA, 0xCB, 0xDD, 0xEE, 0x80, + 0x12, 0xE5, 0x29, 0x0A, 0xD4, 0x5C, 0xB9, 0x26, + 0x95, 0x97, 0xA5, 0xB1, 0x55, 0x74, 0x86, 0x5E, + 0x19, 0xBC, 0xA2, 0xFF, 0xEB, 0x95, 0xF3, 0x26 + }, + { + 0xBE, 0xF1, 0x26, 0x91, 0x00, 0x9D, 0xD8, 0xBA, + 0x21, 0xA8, 0x86, 0x3E, 0x39, 0x81, 0xB5, 0x47, + 0x53, 0xB8, 0x8F, 0x92, 0x12, 0xBA, 0x78, 0x59, + 0xC8, 0x75, 0xEC, 0xA3, 0x6E, 0x2A, 0x66, 0x91, + 0x57, 0x3A, 0x7E, 0x25, 0xAC, 0xE5, 0xA9, 0x7A, + 0x31, 0xAB, 0x60, 0x52, 0xF9, 0x8A, 0x52, 0x4A, + 0xB7, 0xE9, 0x16, 0xD6, 0x8A, 0x16, 0xC6, 0x66, + 0x27, 0xDE, 0x4D, 0x2F, 0x42, 0x47, 0x49, 0x72 + }, + { + 0x16, 0x94, 0x14, 0x2B, 0x42, 0x3B, 0x29, 0x55, + 0xC0, 0x76, 0xA6, 0xB3, 0xA8, 0xCD, 0x1A, 0x50, + 0x3F, 0x4E, 0x3C, 0x34, 0x06, 0x5D, 0xE8, 0x3F, + 0x67, 0xA8, 0xBE, 0xF3, 0xD7, 0xD8, 0xB2, 0x5C, + 0xB6, 0x7F, 0x97, 0x39, 0xD1, 0x0A, 0xAA, 0xBE, + 0x60, 0x27, 0xBF, 0x7A, 0x08, 0x5D, 0x2E, 0xCE, + 0x24, 0x9D, 0x94, 0x8C, 0x09, 0x12, 0x62, 0xE0, + 0x11, 0x47, 0x7D, 0x39, 0xB1, 0xA5, 0x6C, 0x4B + }, + { + 0xE3, 0x0F, 0x87, 0x9F, 0x2E, 0xE0, 0x22, 0x12, + 0xC4, 0x51, 0x8A, 0x57, 0x81, 0x68, 0x3B, 0x3C, + 0xAC, 0xBF, 0x1C, 0x20, 0x12, 0xC1, 0x92, 0x5B, + 0x09, 0x14, 0x71, 0x7C, 0xF2, 0x69, 0xE0, 0x96, + 0x35, 0xF2, 0x0B, 0xDF, 0x44, 0x29, 0x01, 0xDD, + 0x17, 0xD0, 0xCD, 0x7D, 0x22, 0x0B, 0x7D, 0xC3, + 0x1B, 0x96, 0xBA, 0x9D, 0x2B, 0x5B, 0x33, 0xC1, + 0xB5, 0x64, 0xAE, 0x72, 0x19, 0xB3, 0x59, 0x38 + }, + { + 0xE0, 0x56, 0x9C, 0x8D, 0x5A, 0x3A, 0x36, 0x06, + 0xA3, 0x15, 0x5D, 0xD8, 0xB4, 0xC7, 0x8D, 0x51, + 0x42, 0xEF, 0xD7, 0x40, 0x6D, 0x2F, 0x5C, 0xF6, + 0xFE, 0x5E, 0x7B, 0xBD, 0xBD, 0x9C, 0x1B, 0xD6, + 0x0B, 0x7D, 0x02, 0x18, 0xB4, 0xEF, 0x32, 0x7A, + 0x95, 0x1D, 0x36, 0xBB, 0x56, 0x1F, 0xFE, 0xD9, + 0xFB, 0xA7, 0x78, 0x90, 0x9F, 0x7E, 0x47, 0xEE, + 0xF6, 0xD0, 0xC4, 0x85, 0x34, 0x57, 0x6E, 0xC7 + }, + { + 0x52, 0x85, 0xED, 0xAD, 0x92, 0x43, 0x9F, 0x36, + 0x67, 0xD4, 0x61, 0x92, 0xBC, 0xB0, 0xFD, 0x9D, + 0x2C, 0x1B, 0x9C, 0xEE, 0xD7, 0xAB, 0xAC, 0x44, + 0x5F, 0xD6, 0xBD, 0xB2, 0xD9, 0x82, 0xA5, 0x7B, + 0xB1, 0xA7, 0x75, 0x6F, 0x7D, 0x66, 0xEF, 0x4A, + 0x8C, 0xE5, 0xE3, 0x05, 0xA1, 0x64, 0x5D, 0xB0, + 0x94, 0x5F, 0x06, 0xDC, 0xC0, 0x55, 0xC7, 0xBC, + 0x79, 0xEF, 0xA2, 0xB3, 0xE6, 0x36, 0x77, 0x9D + }, + { + 0xF0, 0x0A, 0x1E, 0x8E, 0x59, 0x1C, 0x78, 0x6D, + 0x17, 0x9B, 0x01, 0x3E, 0xCC, 0x12, 0x31, 0x31, + 0x50, 0xF7, 0x1B, 0x2E, 0xE8, 0xDA, 0x12, 0xD3, + 0xDD, 0xC1, 0x31, 0x7F, 0xEF, 0x43, 0xB0, 0x88, + 0xFF, 0xE4, 0x0B, 0xD0, 0x91, 0x5C, 0x60, 0xD1, + 0xC6, 0x88, 0x46, 0xB5, 0xB9, 0xCD, 0xA2, 0xD4, + 0x45, 0x2F, 0x5B, 0xA9, 0xEB, 0x5D, 0x03, 0x73, + 0x3F, 0x1F, 0x1B, 0xF0, 0x06, 0x7E, 0x60, 0x0A + }, + { + 0x40, 0x0B, 0xC1, 0x42, 0x6A, 0xD3, 0x5F, 0x1E, + 0xC5, 0x5C, 0x4A, 0x32, 0xD0, 0x44, 0x62, 0x39, + 0x9B, 0xAF, 0x36, 0xB6, 0x65, 0x3E, 0xEF, 0xEF, + 0x25, 0x1D, 0x7D, 0x8E, 0x31, 0x10, 0x8A, 0x67, + 0xCC, 0x71, 0x82, 0xA6, 0x42, 0x1B, 0x21, 0x63, + 0x1C, 0x51, 0x20, 0x76, 0x95, 0xD3, 0xF3, 0xD6, + 0x49, 0x18, 0x40, 0x36, 0xC6, 0xCE, 0x9B, 0xC3, + 0xC9, 0x0A, 0x2C, 0x0C, 0x3A, 0x36, 0xE0, 0xB9 + }, + { + 0xD1, 0x6E, 0x21, 0x96, 0x6B, 0x2D, 0x66, 0x3E, + 0x67, 0x4D, 0x34, 0xCD, 0xDE, 0x62, 0x82, 0xE1, + 0x11, 0x49, 0xAB, 0xF5, 0xF5, 0xB3, 0xA9, 0x40, + 0x8E, 0xBE, 0x78, 0xD7, 0x6E, 0x19, 0x28, 0x92, + 0xA5, 0x8B, 0xAE, 0xE8, 0x4D, 0x19, 0x45, 0x1B, + 0x5E, 0xBC, 0x69, 0x7A, 0xD2, 0xC8, 0x77, 0x04, + 0xFE, 0x06, 0xC5, 0x9C, 0x41, 0xAA, 0x9D, 0x8F, + 0x48, 0x06, 0x85, 0xF7, 0x35, 0x77, 0x0F, 0x97 + }, + { + 0xF9, 0x80, 0x35, 0xBF, 0x43, 0xDE, 0xF6, 0xC6, + 0xE2, 0xF6, 0xD1, 0x1F, 0x0C, 0x0C, 0x64, 0x98, + 0x92, 0xA3, 0xF2, 0x56, 0xD0, 0x0D, 0x36, 0x82, + 0x69, 0x11, 0x18, 0x7F, 0x95, 0x38, 0xAE, 0xE6, + 0xC8, 0x99, 0x3A, 0xAC, 0x51, 0x26, 0xF1, 0xF8, + 0x48, 0x07, 0x1C, 0xA8, 0x4C, 0x9D, 0xD1, 0xD5, + 0x21, 0x1B, 0x7D, 0xFA, 0xF6, 0xC6, 0x56, 0x3A, + 0x97, 0x11, 0x34, 0xFB, 0x18, 0x77, 0x7B, 0x2F + }, + { + 0xA3, 0x9E, 0xF8, 0x6D, 0xCC, 0x82, 0x4F, 0x26, + 0x86, 0x35, 0xDA, 0x9E, 0x3D, 0xDB, 0xD8, 0x6A, + 0x33, 0xF8, 0x9F, 0x16, 0x93, 0x44, 0xB8, 0x7E, + 0xC1, 0xA5, 0x0A, 0xBE, 0x3E, 0x27, 0x1E, 0x7E, + 0xA9, 0x90, 0x70, 0xED, 0x50, 0xFC, 0x09, 0x90, + 0xE7, 0x15, 0x22, 0x0F, 0xB3, 0x82, 0x06, 0x88, + 0x2D, 0x60, 0x75, 0x40, 0x87, 0x5E, 0x53, 0x8B, + 0x84, 0x72, 0x88, 0x5D, 0x88, 0xFA, 0x27, 0x61 + }, + { + 0xF8, 0xF7, 0x38, 0xB5, 0x5B, 0x89, 0x87, 0x95, + 0x95, 0x34, 0x3B, 0x8E, 0xCE, 0x21, 0xD9, 0xF3, + 0xFD, 0xB5, 0x5C, 0xDA, 0x05, 0x75, 0x97, 0xD0, + 0xA8, 0x13, 0xC4, 0x2F, 0x7D, 0x75, 0x36, 0xAE, + 0xB0, 0x6A, 0x2B, 0xAF, 0xD2, 0x96, 0x95, 0xD8, + 0x34, 0xAC, 0x67, 0x83, 0x35, 0xE5, 0x72, 0xBD, + 0xFC, 0x9B, 0x8D, 0xAE, 0x3A, 0x3C, 0x37, 0xC4, + 0x05, 0x8A, 0x6D, 0xEA, 0xEB, 0xF3, 0x97, 0xE6 + }, + { + 0x8B, 0xAD, 0x08, 0xD7, 0xFF, 0xE4, 0xCB, 0xF0, + 0x78, 0xFB, 0x89, 0xB6, 0xD0, 0xB0, 0x9F, 0xB8, + 0x20, 0xC9, 0xD7, 0x9B, 0x76, 0x83, 0xBF, 0xE8, + 0xC6, 0x0F, 0xF6, 0x40, 0xE2, 0xD1, 0xF8, 0x55, + 0xB4, 0xB4, 0xEF, 0x53, 0x3F, 0x29, 0x6B, 0x82, + 0x92, 0x0F, 0x2D, 0xBF, 0xAB, 0x00, 0xC1, 0x05, + 0x4B, 0x5E, 0xEE, 0x44, 0x68, 0xC4, 0x58, 0x24, + 0xBB, 0xFD, 0x39, 0x6B, 0xA2, 0xBB, 0xCC, 0x87 + }, + { + 0xD6, 0xB5, 0xCF, 0x30, 0xC9, 0xF9, 0x34, 0x8D, + 0x63, 0x82, 0x9E, 0x1D, 0x2A, 0x85, 0x79, 0x24, + 0xCE, 0x2B, 0x1B, 0x13, 0xBB, 0xD1, 0x62, 0x8E, + 0xB0, 0x93, 0xD3, 0x9D, 0xD3, 0x36, 0x57, 0x0E, + 0xF5, 0x87, 0xE4, 0x98, 0x25, 0xC3, 0xB2, 0xE9, + 0x5E, 0x5B, 0xD7, 0x65, 0x2E, 0x3B, 0xDF, 0x48, + 0xCE, 0x7D, 0xAE, 0xE6, 0xEC, 0xEB, 0xF7, 0xBE, + 0x50, 0x67, 0x52, 0x2E, 0x61, 0x6C, 0xDB, 0x79 + }, + { + 0xA6, 0x95, 0x67, 0xEB, 0x92, 0xFA, 0xC9, 0xFF, + 0x9B, 0x9A, 0x5B, 0x41, 0x94, 0x94, 0xB8, 0xA7, + 0x1A, 0x04, 0x65, 0xAC, 0x23, 0xE4, 0x2E, 0xBD, + 0x28, 0xA5, 0x0D, 0x17, 0x25, 0xE4, 0x99, 0x42, + 0x5D, 0x93, 0x68, 0x72, 0x43, 0x02, 0x90, 0x77, + 0x36, 0x07, 0x1C, 0x0E, 0x5A, 0xC1, 0x0C, 0x50, + 0x57, 0x33, 0x76, 0x40, 0x3B, 0xE1, 0x74, 0x55, + 0x85, 0x7C, 0x8D, 0x82, 0xFD, 0xCA, 0xC8, 0x56 + }, + { + 0x39, 0xCB, 0x49, 0xEE, 0x67, 0x27, 0xC2, 0xD8, + 0xB7, 0x7F, 0x96, 0xF8, 0x76, 0x94, 0x82, 0x53, + 0xCC, 0x6B, 0x7F, 0x9F, 0x83, 0xBA, 0xDE, 0xF9, + 0xA6, 0xBB, 0x45, 0xF2, 0x58, 0xDA, 0x38, 0x4E, + 0xC3, 0x1D, 0xE4, 0x58, 0x23, 0x7E, 0xB8, 0x21, + 0x20, 0x9B, 0x28, 0x89, 0xC5, 0x3D, 0x63, 0x91, + 0xF3, 0x52, 0xEF, 0x35, 0xE1, 0x3D, 0xA7, 0xFB, + 0x55, 0x2F, 0xFD, 0x2F, 0x0C, 0x70, 0xF9, 0xAF + }, + { + 0x97, 0x1C, 0x4C, 0x3A, 0x79, 0x6C, 0xDA, 0xAF, + 0x09, 0x6C, 0xC3, 0x0D, 0xCA, 0x5D, 0x63, 0x83, + 0x4F, 0x61, 0x0A, 0xDD, 0x5C, 0x8B, 0x10, 0xAF, + 0xAA, 0x62, 0x6E, 0x05, 0xBC, 0x76, 0x19, 0x3D, + 0x05, 0xBA, 0x24, 0xC7, 0x7D, 0x0F, 0x6B, 0x62, + 0xEA, 0x2E, 0x58, 0xA7, 0x57, 0x0E, 0xBF, 0x01, + 0x0A, 0x51, 0xF2, 0xC3, 0xE8, 0x40, 0xD9, 0x0A, + 0xFE, 0x56, 0x69, 0x9B, 0x07, 0x50, 0xFE, 0x45 + }, + { + 0x66, 0x5F, 0xC6, 0x51, 0x18, 0x8F, 0xE3, 0xD8, + 0x95, 0x3A, 0x28, 0xBB, 0xE2, 0xA2, 0x8A, 0xC6, + 0x1A, 0xB2, 0x16, 0x15, 0x91, 0xC6, 0x9B, 0x52, + 0xCD, 0x4E, 0xBE, 0x77, 0x36, 0x5C, 0x20, 0xD0, + 0xC8, 0x14, 0x30, 0xAB, 0x2D, 0xD2, 0x21, 0x3E, + 0x0C, 0x49, 0xAB, 0x39, 0x46, 0xAF, 0x49, 0x5C, + 0xF3, 0x2C, 0x9D, 0x84, 0xE3, 0x26, 0x6D, 0xC0, + 0xC1, 0xC8, 0xDC, 0x93, 0x08, 0x7F, 0x46, 0x7C + }, + { + 0x41, 0xC3, 0xB9, 0xFC, 0x88, 0x75, 0x21, 0xD1, + 0xF2, 0x43, 0xEE, 0x6B, 0xC9, 0x49, 0xAC, 0xAF, + 0x10, 0xCA, 0x9D, 0xD4, 0x2E, 0x1B, 0xC4, 0xFF, + 0xCC, 0xC7, 0xB4, 0x13, 0x92, 0x12, 0x62, 0xAE, + 0xF1, 0x1E, 0x81, 0xD9, 0x24, 0x98, 0x78, 0xC8, + 0xF8, 0x2C, 0x69, 0x3A, 0x0A, 0x14, 0x09, 0xCB, + 0xCA, 0x4A, 0xF2, 0x32, 0x15, 0x32, 0x79, 0x45, + 0x1C, 0xE6, 0x79, 0xFA, 0xF8, 0x63, 0x69, 0x50 + }, + { + 0x06, 0x2B, 0x31, 0xFC, 0x30, 0xA0, 0xBE, 0xBB, + 0x39, 0xD1, 0x5A, 0x7F, 0x28, 0xFA, 0x53, 0x1D, + 0x02, 0xE3, 0x4D, 0x14, 0xD5, 0x3F, 0xCB, 0x8A, + 0xF4, 0xF9, 0x68, 0x0B, 0x47, 0x3A, 0x0A, 0xF8, + 0xF8, 0x19, 0x7F, 0x4B, 0x57, 0x60, 0xAD, 0x24, + 0x88, 0xA0, 0x6C, 0x0F, 0xD4, 0x60, 0xF4, 0xE2, + 0x22, 0xA5, 0x3D, 0x5C, 0x28, 0x3D, 0xFD, 0xB0, + 0xC5, 0x1B, 0x87, 0xE2, 0xB1, 0x3B, 0x27, 0x58 + }, + { + 0xCB, 0x54, 0xDD, 0x50, 0x50, 0x1E, 0xBE, 0x6D, + 0x08, 0x5D, 0xE8, 0xF0, 0x59, 0xB1, 0x7D, 0x7C, + 0x95, 0x71, 0x89, 0x98, 0x79, 0x92, 0x30, 0x10, + 0x41, 0xB3, 0xA5, 0x82, 0xDF, 0xD3, 0xEB, 0x82, + 0xC6, 0x85, 0x89, 0xCE, 0x97, 0x60, 0x43, 0x47, + 0x90, 0xFB, 0xA0, 0xFC, 0xEC, 0x5D, 0x7B, 0x71, + 0xF1, 0xC7, 0x62, 0xBE, 0x22, 0x00, 0x50, 0x0A, + 0x8F, 0x65, 0x7F, 0xEE, 0x09, 0x60, 0xE6, 0x5B + }, + { + 0xCE, 0x1F, 0x18, 0x8E, 0x54, 0xD3, 0xC9, 0x0A, + 0xD5, 0x0F, 0x6D, 0xB2, 0x86, 0x2F, 0xA1, 0x1E, + 0x9B, 0x33, 0x0F, 0x66, 0xC4, 0x1B, 0x01, 0xCA, + 0xD1, 0xC6, 0xA3, 0x56, 0x60, 0x55, 0xC7, 0x8D, + 0x11, 0xE3, 0x6E, 0x60, 0xAA, 0x74, 0xB9, 0x3C, + 0xA4, 0x12, 0xDD, 0x45, 0xBD, 0xA7, 0x11, 0xEB, + 0x00, 0x06, 0x27, 0xC8, 0x9D, 0xE3, 0x4C, 0x66, + 0x3A, 0x35, 0xE7, 0x34, 0x5F, 0x39, 0x6D, 0x22 + }, + { + 0x0A, 0xB9, 0x16, 0x7A, 0x55, 0xAF, 0xBB, 0x0E, + 0xAE, 0xA1, 0xF0, 0x3E, 0xD0, 0xAC, 0x9E, 0xA9, + 0xC3, 0x14, 0xA0, 0xAD, 0x5C, 0xA2, 0xE4, 0xBA, + 0xBF, 0x53, 0x4E, 0xBD, 0x67, 0x88, 0x07, 0xCD, + 0x69, 0x1A, 0x9D, 0xFA, 0xF7, 0x49, 0x8E, 0x47, + 0x26, 0x3B, 0x57, 0xB8, 0x37, 0x01, 0xA4, 0x99, + 0x7F, 0x5B, 0xB3, 0xF9, 0xB7, 0x51, 0x78, 0xC4, + 0x6B, 0xA8, 0xFB, 0x41, 0xE4, 0x42, 0xEC, 0x3D + }, + { + 0x1C, 0x29, 0x7A, 0x4E, 0xE8, 0xBC, 0x4D, 0x84, + 0xEA, 0xB4, 0x44, 0x9C, 0xDD, 0xE4, 0x7A, 0x7F, + 0xFD, 0x7A, 0xC0, 0xBD, 0xDF, 0x90, 0xA8, 0x37, + 0x81, 0x85, 0x56, 0x4D, 0x51, 0x0F, 0x0A, 0x14, + 0xC1, 0xBF, 0x99, 0x32, 0x07, 0x4F, 0x89, 0x09, + 0xF1, 0x4D, 0x32, 0xB0, 0x96, 0xA3, 0xB2, 0x4E, + 0xF8, 0x25, 0x20, 0x38, 0xA8, 0xC8, 0x66, 0x05, + 0xAD, 0xC8, 0x0C, 0x55, 0xF4, 0x69, 0x4F, 0xE5 + }, + { + 0x08, 0x3C, 0x0C, 0xD6, 0xD0, 0x7F, 0x47, 0xF1, + 0x4E, 0x4B, 0x20, 0x41, 0x24, 0xDB, 0x26, 0xF6, + 0x7E, 0x8D, 0xDD, 0x7F, 0xB7, 0x66, 0x1A, 0xAE, + 0xD1, 0xAE, 0x4E, 0xF2, 0xCC, 0xCA, 0x51, 0xA1, + 0xC9, 0x13, 0x05, 0x5E, 0xB5, 0x9D, 0x80, 0xD8, + 0x5A, 0xC1, 0xA6, 0x84, 0x8A, 0x6F, 0x61, 0xF6, + 0xD2, 0x0A, 0xE2, 0x34, 0xA7, 0x73, 0x3A, 0x71, + 0xF4, 0xF9, 0xF9, 0xE1, 0x0A, 0x91, 0x26, 0xC1 + }, + { + 0x5C, 0x74, 0xFE, 0xED, 0xC3, 0xFA, 0x28, 0xE3, + 0x83, 0x36, 0x95, 0x57, 0x10, 0xD9, 0x41, 0xB3, + 0x7F, 0x55, 0x1B, 0x74, 0x7F, 0xB8, 0x62, 0xF6, + 0xF5, 0x2D, 0xDE, 0x4E, 0x58, 0xFE, 0x57, 0x03, + 0x12, 0x68, 0x36, 0x2F, 0x3A, 0x99, 0x86, 0x63, + 0xF1, 0xC2, 0x15, 0xC4, 0x2D, 0x90, 0x44, 0x66, + 0x0D, 0x22, 0x11, 0x80, 0x22, 0xE8, 0xE5, 0x9B, + 0x62, 0xC9, 0x5A, 0x91, 0x1A, 0xD4, 0x35, 0x5D + }, + { + 0x57, 0xB9, 0xA5, 0xE8, 0xCE, 0xC0, 0xCF, 0xD8, + 0xD8, 0x6F, 0x43, 0x4D, 0x2F, 0x24, 0xFF, 0x25, + 0x79, 0x36, 0x4C, 0x88, 0xB5, 0x40, 0xDE, 0x23, + 0x41, 0x90, 0x9D, 0x4E, 0xC8, 0xD4, 0x05, 0x0E, + 0x9C, 0xF7, 0x13, 0x88, 0xCC, 0x76, 0xD4, 0x16, + 0xF7, 0x21, 0x13, 0x9B, 0xA3, 0xAB, 0x7D, 0x78, + 0x81, 0x65, 0xB9, 0x6B, 0x73, 0xF7, 0xA3, 0x37, + 0xDE, 0xE8, 0x50, 0x87, 0x0A, 0x9F, 0x7C, 0x45 + }, + { + 0x1A, 0x9E, 0x74, 0xAE, 0x18, 0x63, 0x21, 0x89, + 0xE3, 0x5C, 0xB1, 0x47, 0x73, 0x47, 0xD5, 0x5F, + 0x7F, 0x2F, 0xF6, 0xB4, 0xBC, 0x94, 0xD6, 0xE9, + 0x65, 0x5A, 0x66, 0xF6, 0x3C, 0xB2, 0x57, 0x07, + 0x4A, 0xE2, 0x81, 0x9B, 0xCD, 0x43, 0x92, 0x68, + 0x11, 0x82, 0xDD, 0x54, 0xCB, 0x1B, 0x87, 0x39, + 0xAA, 0x8B, 0x31, 0x38, 0xBB, 0x6D, 0x95, 0x00, + 0x53, 0x2B, 0x03, 0x1C, 0x5F, 0xBF, 0x81, 0x38 + }, + { + 0x7D, 0xB5, 0xF0, 0xBB, 0xBF, 0xD5, 0x11, 0xD8, + 0xC7, 0x6A, 0xFA, 0x24, 0xAE, 0x19, 0x2D, 0x28, + 0xAE, 0x70, 0xD0, 0x21, 0xB3, 0xAC, 0xB9, 0x66, + 0x9F, 0x6E, 0x86, 0x57, 0xE9, 0xE1, 0xA2, 0x81, + 0x7C, 0xCA, 0xFD, 0xF6, 0xC4, 0x78, 0xDE, 0x4B, + 0xC6, 0x59, 0x64, 0x2E, 0xBD, 0xD0, 0x25, 0x8F, + 0xEB, 0xE1, 0x3F, 0x5F, 0x7C, 0xC7, 0xB8, 0x67, + 0x6C, 0x79, 0x5B, 0x9C, 0x07, 0x8A, 0x3B, 0xA5 + }, + { + 0x7F, 0x67, 0x5C, 0xA7, 0xC1, 0x48, 0x2E, 0xE0, + 0xDB, 0x7A, 0x78, 0xAF, 0x3B, 0x28, 0x66, 0x3B, + 0x93, 0x09, 0x4A, 0xF2, 0x82, 0xE3, 0x36, 0x90, + 0x5D, 0x90, 0x43, 0x7C, 0x49, 0xB1, 0x04, 0xC1, + 0x16, 0x39, 0xCA, 0xD0, 0x10, 0xDB, 0x7D, 0x94, + 0x40, 0xC1, 0x45, 0xF6, 0xD5, 0xE4, 0x75, 0xE9, + 0x9B, 0x8E, 0x74, 0x94, 0xC6, 0x86, 0xE0, 0x44, + 0x26, 0xE0, 0x08, 0x98, 0xF8, 0x63, 0xB4, 0x25 + }, + { + 0xD7, 0x6E, 0x86, 0xAC, 0x42, 0x26, 0x64, 0xF5, + 0xFF, 0x17, 0x05, 0x9A, 0x48, 0x0B, 0xA2, 0x53, + 0x37, 0x4C, 0x8C, 0xCD, 0xA6, 0xE5, 0x0A, 0x6C, + 0xAE, 0x0F, 0x1A, 0xD3, 0xBC, 0x58, 0xF1, 0x29, + 0x69, 0xCF, 0x85, 0x3C, 0xE6, 0xE7, 0xB6, 0x33, + 0x99, 0xAA, 0xBB, 0x21, 0xD0, 0x14, 0xDC, 0x71, + 0x3C, 0x99, 0xBD, 0xDC, 0x14, 0x11, 0xD9, 0x0E, + 0x67, 0x24, 0x90, 0xFD, 0x6C, 0x39, 0x7D, 0x76 + }, + { + 0xC6, 0x45, 0x62, 0x6A, 0x89, 0xFB, 0x0D, 0x23, + 0xA3, 0xEC, 0x25, 0xBD, 0xF6, 0x85, 0xBB, 0x7B, + 0xC5, 0x0C, 0xC8, 0x23, 0x17, 0x40, 0x6A, 0xA1, + 0xF6, 0x34, 0x2D, 0x6C, 0x70, 0xBD, 0x29, 0xE1, + 0x47, 0xD0, 0xC5, 0x88, 0x59, 0x0E, 0x3B, 0xE5, + 0xC7, 0x94, 0x1E, 0x26, 0x93, 0xCE, 0xEE, 0x65, + 0xDB, 0xDC, 0xFA, 0x38, 0x00, 0xD7, 0x4E, 0x1C, + 0x1A, 0x87, 0xB6, 0x22, 0x95, 0xC0, 0x49, 0xAC + }, + { + 0xA7, 0x35, 0x28, 0x40, 0x3B, 0x08, 0xCB, 0x3D, + 0xC0, 0x90, 0x82, 0xAD, 0x9B, 0x06, 0x6A, 0x52, + 0x19, 0xD8, 0x7B, 0x36, 0x9A, 0xAE, 0x3F, 0xEB, + 0x12, 0x53, 0xA4, 0xE8, 0xD9, 0x3D, 0xFE, 0x40, + 0x66, 0x33, 0x7B, 0x45, 0xE0, 0xCF, 0x3B, 0x01, + 0x1C, 0x12, 0xC4, 0x0E, 0xA3, 0xC0, 0x83, 0x96, + 0x10, 0xC4, 0x27, 0xE3, 0xEE, 0x2F, 0x01, 0x6E, + 0x18, 0x6D, 0xE2, 0x0F, 0xB4, 0xCD, 0xD9, 0x52 + }, + { + 0x60, 0x1E, 0x43, 0xDE, 0xC1, 0xE7, 0x28, 0x15, + 0xED, 0x96, 0x8B, 0x76, 0xE1, 0x4C, 0x75, 0x2B, + 0xC4, 0x09, 0xD5, 0x6A, 0xD8, 0xAF, 0xE6, 0xE8, + 0xF1, 0x42, 0x51, 0x84, 0x3F, 0xA1, 0x19, 0xB6, + 0x77, 0x91, 0xF7, 0x54, 0x13, 0x24, 0x68, 0x4F, + 0x23, 0x97, 0x2D, 0xA0, 0xE3, 0xCC, 0xB8, 0x36, + 0x39, 0x2E, 0x36, 0xB7, 0xBF, 0x64, 0x4F, 0x83, + 0x44, 0x4F, 0x29, 0x22, 0x55, 0x13, 0xB6, 0xF1 + }, + { + 0x57, 0x1D, 0xC4, 0xDA, 0x87, 0x3F, 0xBB, 0x35, + 0xA3, 0xEB, 0xA7, 0x34, 0x6A, 0x5C, 0x6E, 0x4C, + 0x84, 0x72, 0xF0, 0x69, 0x5D, 0xA3, 0x80, 0x24, + 0x83, 0x3D, 0x18, 0xC9, 0x08, 0x84, 0xBC, 0x84, + 0x78, 0xF0, 0x2F, 0x30, 0x81, 0x4C, 0x22, 0x51, + 0xA4, 0x0B, 0xD9, 0x90, 0x24, 0xAF, 0xD0, 0x26, + 0x12, 0x8F, 0x72, 0x29, 0xFD, 0x42, 0xCE, 0x61, + 0x2E, 0xAA, 0xBF, 0x28, 0x9F, 0x4B, 0xD7, 0x35 + }, + { + 0x1A, 0x5B, 0x4E, 0x0D, 0x53, 0xF7, 0x1C, 0x01, + 0x4C, 0x0B, 0xC9, 0xBE, 0x4C, 0x23, 0x2C, 0x78, + 0xDA, 0xAA, 0xC6, 0x0C, 0xC1, 0x14, 0xC0, 0x42, + 0x76, 0x62, 0xAE, 0x27, 0x06, 0x23, 0xB0, 0x19, + 0x26, 0x18, 0xC7, 0xA7, 0x0F, 0x95, 0x67, 0xF1, + 0x3A, 0x5C, 0xBD, 0x13, 0x91, 0x7D, 0x18, 0x28, + 0xCE, 0x28, 0x25, 0x43, 0x9B, 0x2C, 0xE8, 0xAB, + 0xE3, 0x2C, 0x14, 0x7C, 0xC0, 0xA2, 0xCE, 0x7F + }, + { + 0xED, 0x55, 0x70, 0xD6, 0xAE, 0xAB, 0x03, 0x3F, + 0x31, 0x16, 0x46, 0xC2, 0x49, 0x94, 0x63, 0x3D, + 0xCF, 0x61, 0x62, 0x35, 0x53, 0xF2, 0xFE, 0x29, + 0xDC, 0xB6, 0x32, 0x87, 0x97, 0x4F, 0x29, 0x13, + 0x83, 0xF4, 0x7B, 0x93, 0xAB, 0xEE, 0x35, 0xB7, + 0x03, 0x16, 0xFE, 0xF6, 0x6E, 0xD1, 0xE6, 0x21, + 0x19, 0xB9, 0x1D, 0xEB, 0xC0, 0xA1, 0x69, 0xF6, + 0x94, 0x32, 0x2B, 0x1C, 0x4B, 0x0D, 0xCC, 0xD0 + }, + { + 0xCB, 0xD2, 0x81, 0xC0, 0x22, 0x5F, 0x7E, 0x75, + 0x9F, 0x96, 0xC6, 0x2F, 0x1A, 0xBF, 0x8A, 0xFD, + 0x6C, 0xFD, 0x55, 0xBC, 0x2B, 0xD6, 0x99, 0x66, + 0x24, 0xC1, 0x3A, 0x02, 0x4E, 0xFA, 0xB0, 0x35, + 0xD1, 0x67, 0x51, 0x78, 0x83, 0x70, 0xBC, 0x1C, + 0x94, 0xAA, 0xDD, 0xB8, 0x15, 0x33, 0x86, 0xF2, + 0x95, 0xC6, 0xAC, 0x54, 0x90, 0x72, 0x27, 0x01, + 0x92, 0x86, 0x8C, 0xF0, 0x75, 0xEC, 0x4E, 0xF2 + }, + { + 0xC2, 0xD4, 0xF0, 0x8D, 0x71, 0x2B, 0x7A, 0x2A, + 0xE0, 0xC9, 0xDB, 0x9E, 0x5E, 0xCF, 0xBB, 0x53, + 0xA9, 0xB0, 0x8B, 0x18, 0xA6, 0x24, 0xF0, 0x76, + 0xD8, 0x44, 0x58, 0xA5, 0x55, 0x4D, 0x02, 0x5F, + 0x8B, 0xFB, 0x0D, 0x87, 0xB5, 0x0D, 0x89, 0x70, + 0xF7, 0xEB, 0x88, 0xB4, 0xC1, 0xED, 0xCB, 0x97, + 0x4F, 0x73, 0xDE, 0x95, 0x8E, 0xD4, 0x7E, 0x56, + 0x40, 0xCE, 0xAF, 0xE4, 0xAD, 0x6F, 0x9E, 0xAF + }, + { + 0xC1, 0xCC, 0x61, 0xF0, 0x42, 0xE1, 0xBB, 0x5A, + 0x25, 0x94, 0x99, 0xE6, 0xC1, 0xFA, 0x68, 0x02, + 0x32, 0x81, 0x84, 0x3E, 0xC1, 0x47, 0xA0, 0x7D, + 0x9D, 0x02, 0xA3, 0x43, 0xFC, 0x24, 0xF1, 0xFC, + 0xDE, 0xD0, 0x19, 0xDA, 0xA5, 0xF9, 0x46, 0x49, + 0xD6, 0xE5, 0x13, 0x5E, 0xE3, 0x68, 0xFB, 0xF1, + 0x2C, 0x5A, 0x17, 0x9C, 0x42, 0xCF, 0xA5, 0xC2, + 0x00, 0xC6, 0x6F, 0x97, 0xCE, 0xB9, 0xF6, 0x1E + }, + { + 0x53, 0x30, 0x49, 0x79, 0x81, 0xFB, 0xCA, 0xE5, + 0x3A, 0xA3, 0xD8, 0x4F, 0x66, 0x92, 0x0E, 0xDA, + 0x97, 0x8D, 0x1B, 0x74, 0xA0, 0xC9, 0xF0, 0x3D, + 0x17, 0x0B, 0x2A, 0x63, 0xF2, 0xC5, 0xCB, 0xAB, + 0x1C, 0x2B, 0x23, 0x4F, 0x5C, 0x5F, 0x5A, 0x10, + 0x87, 0x62, 0x8A, 0xD6, 0x24, 0x5F, 0xBF, 0x89, + 0x11, 0x08, 0x30, 0xAA, 0xD9, 0x34, 0xF4, 0x3C, + 0xEA, 0x3E, 0x42, 0x83, 0xE3, 0xFA, 0x20, 0xFA + }, + { + 0x9F, 0x85, 0x0E, 0x2E, 0x54, 0x07, 0x10, 0xB8, + 0x19, 0x9C, 0x88, 0x1D, 0xA2, 0x81, 0x21, 0x10, + 0x0B, 0x0D, 0x90, 0x40, 0x89, 0xDC, 0xCD, 0x9C, + 0x68, 0xD7, 0x8E, 0x26, 0x9E, 0xBC, 0x13, 0x5D, + 0xF9, 0x23, 0xDA, 0x27, 0xDB, 0xC3, 0x83, 0xF1, + 0xB5, 0x8F, 0xE9, 0xD3, 0x58, 0xFB, 0x5D, 0xB7, + 0x1B, 0x0D, 0xB3, 0x45, 0xA8, 0x34, 0xB0, 0x20, + 0x6F, 0x93, 0xE6, 0x41, 0x0B, 0xA1, 0xA8, 0x99 + }, + { + 0x9B, 0x7F, 0x7C, 0xBF, 0xFE, 0xE4, 0x61, 0x23, + 0x83, 0x49, 0x54, 0xA0, 0xB5, 0x34, 0x84, 0x4C, + 0x02, 0xB4, 0x3E, 0x60, 0x08, 0x8E, 0xF5, 0x39, + 0x53, 0x08, 0xF7, 0xC3, 0x88, 0x24, 0xA9, 0x1D, + 0x0D, 0x7A, 0x9C, 0x2B, 0x4C, 0x6E, 0x8F, 0x0B, + 0xED, 0x93, 0x11, 0x2C, 0xD5, 0x40, 0x5A, 0xF1, + 0x03, 0xB1, 0xD2, 0xB8, 0x04, 0x9B, 0xED, 0x1E, + 0x9A, 0x37, 0xE2, 0x87, 0x28, 0x99, 0xFE, 0x85 + }, + { + 0xFE, 0x4D, 0xB3, 0x50, 0x8C, 0xEB, 0x5A, 0xE7, + 0xB6, 0xBE, 0x77, 0x3A, 0x03, 0x1C, 0xB3, 0xF6, + 0x7A, 0x3B, 0xAC, 0x81, 0x40, 0x92, 0x9F, 0x70, + 0xD2, 0xE9, 0xA0, 0x90, 0x6C, 0x2F, 0x80, 0x90, + 0x08, 0xEE, 0x16, 0xD9, 0x39, 0xEA, 0xD6, 0x29, + 0xC7, 0x40, 0xBC, 0x48, 0xE7, 0x9F, 0xA1, 0x15, + 0xC3, 0xDE, 0x92, 0x1D, 0x01, 0x73, 0xF6, 0x28, + 0xCE, 0xB2, 0x91, 0x4E, 0xA0, 0x18, 0xBA, 0x78 + }, + { + 0x8D, 0x67, 0xC8, 0xD3, 0xBA, 0x4F, 0x97, 0x9A, + 0x4A, 0xB9, 0x84, 0x89, 0x91, 0x04, 0x49, 0xF2, + 0x2B, 0xA4, 0xEC, 0xA9, 0x6A, 0x41, 0x1F, 0xD2, + 0x4D, 0xAA, 0x6E, 0xDC, 0x54, 0x4B, 0x56, 0xD7, + 0x7E, 0x3F, 0x7C, 0xDF, 0xE4, 0x0A, 0xFD, 0x5F, + 0xFD, 0xC7, 0x83, 0x6A, 0xA9, 0xDE, 0x17, 0xDA, + 0x5F, 0x87, 0x45, 0x05, 0xCE, 0xCB, 0x60, 0x8E, + 0xC3, 0x46, 0x29, 0x5A, 0xF6, 0xE7, 0x01, 0xBC + }, + { + 0xAE, 0x9F, 0xC2, 0xE9, 0xA8, 0x1F, 0xDF, 0xFD, + 0x6A, 0x95, 0x82, 0xF5, 0xCA, 0x1A, 0x85, 0x5A, + 0x53, 0xFD, 0xCE, 0xCE, 0x5A, 0xB1, 0x4A, 0xC3, + 0xB9, 0x76, 0x35, 0x90, 0x27, 0x6B, 0xFE, 0x4C, + 0x09, 0x53, 0x02, 0xB4, 0x6C, 0x85, 0x85, 0xD5, + 0x8D, 0xF7, 0x96, 0x42, 0x70, 0x87, 0xB3, 0x6E, + 0x9D, 0x8B, 0x30, 0x6C, 0x90, 0x5B, 0x4D, 0x5A, + 0xB4, 0x12, 0x68, 0x29, 0xC8, 0x9D, 0x6B, 0xA0 + }, + { + 0x68, 0x07, 0x40, 0xE6, 0xA4, 0xB2, 0x13, 0x85, + 0xBE, 0x44, 0x94, 0x79, 0xAB, 0xAD, 0xDE, 0x98, + 0xE1, 0xC3, 0x28, 0x78, 0xEE, 0xCB, 0x6B, 0xAE, + 0xC1, 0xFC, 0x6F, 0xE9, 0xC7, 0x70, 0x64, 0x0F, + 0x2D, 0xC9, 0x7B, 0xD3, 0xD1, 0xA3, 0xC6, 0xC1, + 0x4E, 0xA0, 0xE1, 0x7E, 0xBC, 0xDE, 0x25, 0x0D, + 0xF9, 0x0A, 0xC1, 0x72, 0xC2, 0x4B, 0xA0, 0xEA, + 0xAF, 0xFE, 0x65, 0x0B, 0xAB, 0xE7, 0xCC, 0x42 + }, + { + 0x88, 0x3F, 0x42, 0xF8, 0xED, 0xF2, 0x1B, 0x97, + 0x57, 0x57, 0xD9, 0x2C, 0xF2, 0xB4, 0x2A, 0x96, + 0x91, 0x67, 0xA0, 0x52, 0xE7, 0xB8, 0xA2, 0xBB, + 0x7C, 0x22, 0xC7, 0xE2, 0xD3, 0xCE, 0x87, 0xB6, + 0xB6, 0x6B, 0xE8, 0x59, 0xA4, 0x3F, 0x7D, 0xC6, + 0x45, 0xF2, 0xA3, 0xCE, 0x2F, 0x44, 0x8B, 0xCA, + 0x46, 0xCC, 0x60, 0x45, 0x3E, 0x95, 0xE8, 0x4A, + 0xE3, 0xAE, 0x98, 0x52, 0x69, 0xBB, 0x49, 0x71 + }, + { + 0x9F, 0xE2, 0x6A, 0x10, 0xD8, 0x9F, 0x0C, 0xCB, + 0x9C, 0x80, 0x8C, 0xE7, 0x99, 0x9C, 0xC4, 0xF1, + 0xE1, 0xE2, 0x4B, 0x70, 0xF4, 0x65, 0xFC, 0x45, + 0x56, 0x8F, 0xEB, 0x3B, 0x52, 0x61, 0xEB, 0x7F, + 0x7B, 0x53, 0x6A, 0xC9, 0x81, 0xB9, 0x74, 0x1F, + 0x04, 0x0E, 0x99, 0xDE, 0x85, 0xD0, 0x9E, 0xC7, + 0x37, 0x48, 0x84, 0x8F, 0xC1, 0xAF, 0x56, 0x2A, + 0xD1, 0x24, 0x5C, 0x95, 0x60, 0x04, 0xE8, 0x84 + }, + { + 0x5B, 0x67, 0x35, 0x10, 0xD0, 0xAF, 0xD0, 0x7D, + 0xC8, 0x05, 0x2A, 0x53, 0x08, 0x81, 0x0A, 0xB5, + 0x76, 0x1F, 0x19, 0xAD, 0xEB, 0x1E, 0x11, 0x5A, + 0x3B, 0x24, 0x72, 0x52, 0x72, 0xED, 0xF9, 0x8D, + 0x0B, 0xD0, 0x9A, 0x4A, 0xC7, 0x5D, 0x41, 0xD3, + 0x48, 0xA6, 0xDA, 0x69, 0x3F, 0xF8, 0xFB, 0xA5, + 0x7A, 0x6A, 0xA9, 0x23, 0x4A, 0x89, 0xDC, 0xD0, + 0x75, 0x6A, 0xE7, 0x74, 0xEE, 0xE0, 0xF8, 0x24 + }, + { + 0x8E, 0x08, 0xE0, 0x3A, 0x67, 0x5D, 0xD1, 0xC5, + 0x1B, 0x6A, 0xE0, 0xEC, 0x5B, 0x43, 0xFE, 0x1A, + 0x5A, 0x9D, 0xA2, 0x16, 0x6D, 0xCD, 0x6E, 0xAB, + 0x11, 0xF4, 0x1E, 0xE3, 0x47, 0xC9, 0x08, 0x0C, + 0x71, 0x9D, 0x1C, 0xA2, 0xB9, 0x2D, 0x67, 0x52, + 0x36, 0xF3, 0x9F, 0x6A, 0x43, 0x42, 0x58, 0x3A, + 0x6C, 0x3F, 0x96, 0x4E, 0x6C, 0x61, 0x35, 0x53, + 0xC3, 0x30, 0x1F, 0x4E, 0x71, 0xA1, 0x30, 0x17 + }, + { + 0x79, 0x1F, 0x80, 0x86, 0x6B, 0xA6, 0xAC, 0xB3, + 0x88, 0xCB, 0xC3, 0x14, 0xF4, 0x6E, 0x4A, 0x5A, + 0x9F, 0x1B, 0xF9, 0xEE, 0x30, 0xA0, 0x02, 0x6C, + 0x83, 0xDA, 0x72, 0x65, 0xD4, 0x45, 0x7E, 0x9A, + 0xF3, 0xD0, 0xC6, 0x18, 0x13, 0xD4, 0x1D, 0x10, + 0x79, 0x72, 0xB6, 0xF2, 0x85, 0x66, 0x7B, 0xD5, + 0xFD, 0x55, 0xF0, 0xA3, 0x8C, 0x5C, 0x37, 0xAD, + 0xA7, 0xA1, 0xE5, 0x20, 0x09, 0x4F, 0xAD, 0x5E + }, + { + 0x70, 0xC6, 0xCC, 0xA2, 0xB5, 0x62, 0xFF, 0x8C, + 0x3C, 0x59, 0xCB, 0x0C, 0x30, 0xD6, 0xC4, 0x5D, + 0x25, 0xCD, 0x64, 0x6B, 0x32, 0x95, 0xCB, 0xA7, + 0x00, 0xF8, 0xB3, 0x56, 0x18, 0xD0, 0x9B, 0x50, + 0x0E, 0x6F, 0x80, 0xC0, 0xEF, 0xE3, 0x21, 0xC0, + 0x3F, 0x08, 0x9D, 0x1B, 0x10, 0x58, 0xB2, 0x04, + 0x7A, 0x33, 0xE0, 0xD0, 0x4F, 0x8F, 0x21, 0xBC, + 0xFB, 0x86, 0x15, 0x3E, 0xAA, 0x74, 0xAD, 0x40 + }, + { + 0x9A, 0xCF, 0xDD, 0x26, 0xAC, 0x82, 0x2B, 0x70, + 0x1D, 0x50, 0x2B, 0xAA, 0x18, 0x54, 0xEB, 0xBF, + 0x00, 0x13, 0x38, 0xC7, 0x3E, 0xF3, 0xDD, 0x4F, + 0x1A, 0xB2, 0x72, 0xC9, 0x16, 0x86, 0xDE, 0x13, + 0x4C, 0x46, 0x87, 0x2F, 0x23, 0x81, 0x58, 0xEF, + 0xDD, 0xCB, 0x8C, 0xCA, 0x8D, 0xE0, 0x5C, 0x42, + 0x9B, 0x76, 0xD0, 0xFE, 0x36, 0x2E, 0x11, 0xAF, + 0xE3, 0xED, 0x18, 0x99, 0x9E, 0xBF, 0x7D, 0xA3 + }, + { + 0x0C, 0xBA, 0x3A, 0xBA, 0xB6, 0x2E, 0x12, 0x63, + 0x4A, 0x94, 0xB3, 0xAA, 0xD9, 0x26, 0x7C, 0x5D, + 0xD6, 0x93, 0xDD, 0x91, 0x4B, 0xAA, 0x31, 0x6B, + 0x21, 0xBB, 0x00, 0x57, 0x4A, 0xDC, 0xB5, 0xC6, + 0x6B, 0x8D, 0xFB, 0x6C, 0x72, 0x48, 0x26, 0x2F, + 0xDB, 0x99, 0x2F, 0x48, 0x5F, 0x3E, 0x90, 0x00, + 0xCF, 0x06, 0x06, 0x7C, 0x1A, 0x5E, 0x35, 0x4B, + 0x92, 0xEC, 0x6D, 0x5C, 0x12, 0xA6, 0x6B, 0xC1 + }, + { + 0x25, 0x72, 0x2C, 0x99, 0x13, 0xCC, 0xA2, 0xCC, + 0x99, 0x4B, 0xBD, 0x41, 0xF2, 0x1B, 0x12, 0xAA, + 0x23, 0xC1, 0xD8, 0x28, 0xED, 0xBB, 0xE4, 0xA2, + 0x94, 0x5F, 0xEB, 0x25, 0x14, 0x0A, 0xA4, 0xFC, + 0xCB, 0x03, 0x90, 0x56, 0x2C, 0x0D, 0x2E, 0x8B, + 0xFE, 0x3C, 0x59, 0xE2, 0x6B, 0x38, 0xDB, 0x60, + 0xD5, 0x10, 0xE7, 0x95, 0xDA, 0xF9, 0x8F, 0x99, + 0xE8, 0x21, 0x4B, 0x0F, 0x7E, 0xCD, 0xD7, 0xC1 + }, + { + 0xA1, 0x29, 0xA6, 0xC9, 0x31, 0x57, 0xDA, 0x14, + 0xAE, 0x49, 0xB8, 0x4B, 0xDD, 0x68, 0x83, 0xD5, + 0x9E, 0xA5, 0xC5, 0x0D, 0x2C, 0xC9, 0xA4, 0xBB, + 0x2A, 0x4C, 0x34, 0x33, 0xCB, 0xEA, 0x43, 0xF3, + 0x03, 0x83, 0x61, 0xBD, 0x81, 0x3D, 0xF7, 0x9F, + 0x74, 0xB7, 0xA9, 0xCE, 0x52, 0xAC, 0x68, 0x21, + 0xA3, 0x45, 0xB3, 0xD6, 0xF8, 0xFE, 0x90, 0x74, + 0x87, 0x9A, 0x98, 0xA4, 0xD9, 0x74, 0x68, 0x6E + }, + { + 0x23, 0x08, 0x53, 0x8C, 0x47, 0x85, 0x3C, 0x50, + 0x9D, 0x6B, 0x86, 0x2F, 0xD4, 0x56, 0xC5, 0x6C, + 0xAE, 0x7D, 0x4F, 0xA4, 0x23, 0x60, 0xC1, 0x1F, + 0xDB, 0x92, 0x4D, 0x9D, 0x6B, 0x03, 0xC5, 0x1F, + 0x2B, 0x30, 0x8E, 0xC3, 0x3C, 0x36, 0xD7, 0xBC, + 0x89, 0x07, 0x64, 0xFC, 0x31, 0xF8, 0x7A, 0x49, + 0x9B, 0x35, 0xE0, 0xB5, 0x7F, 0x55, 0x71, 0x88, + 0x44, 0x80, 0x3D, 0x7C, 0x37, 0x7A, 0x2D, 0xF2 + }, + { + 0x1E, 0xE9, 0xB4, 0xCF, 0x9A, 0x1E, 0xEF, 0x7A, + 0x8D, 0x2E, 0xC8, 0x6B, 0xA8, 0x78, 0x37, 0xC3, + 0xB7, 0x29, 0x35, 0x9A, 0x53, 0x74, 0x85, 0x6B, + 0x93, 0xCB, 0x24, 0x84, 0xF9, 0x03, 0xF8, 0x73, + 0xAE, 0x15, 0xAD, 0x60, 0x05, 0xE3, 0x10, 0x82, + 0x0B, 0xF9, 0x4C, 0x3C, 0x77, 0x72, 0x2F, 0x32, + 0x4A, 0x25, 0x98, 0xEB, 0x8C, 0xC0, 0x5A, 0xD3, + 0x7D, 0xB8, 0xC1, 0x53, 0x70, 0x4A, 0x3F, 0xE4 + }, + { + 0x1C, 0xDA, 0x4A, 0x1D, 0x8D, 0xFA, 0xA9, 0xF2, + 0x86, 0xB7, 0xB7, 0x58, 0x6F, 0x4F, 0xC1, 0xD9, + 0xC1, 0x9D, 0x8C, 0xE5, 0xC2, 0x25, 0xE3, 0xC2, + 0xF6, 0x8D, 0x7D, 0x76, 0x1F, 0x17, 0x7F, 0x38, + 0x65, 0xD7, 0x20, 0x8A, 0xFB, 0x58, 0xAB, 0x2D, + 0xA5, 0xB1, 0xB6, 0x2A, 0xF6, 0xD8, 0x3F, 0x66, + 0x01, 0x1F, 0x12, 0x1F, 0x30, 0xE5, 0xF9, 0x39, + 0x7F, 0x63, 0x3E, 0xF2, 0x3F, 0xDC, 0x57, 0xDD + }, + { + 0xF3, 0x72, 0xBA, 0x90, 0xF7, 0x44, 0xB0, 0xB5, + 0xCC, 0x68, 0xB3, 0x71, 0x98, 0xFE, 0x1E, 0x6A, + 0xB3, 0x49, 0xEA, 0xF9, 0x1F, 0xFD, 0x31, 0x13, + 0x8B, 0x3C, 0x11, 0x1F, 0x8C, 0x9D, 0x7A, 0xB1, + 0xFE, 0xD7, 0xB3, 0x56, 0x4D, 0x2C, 0x86, 0x77, + 0xE3, 0x9E, 0x30, 0x03, 0x3A, 0x61, 0x17, 0xE2, + 0xA1, 0x8C, 0xE6, 0x89, 0x38, 0x12, 0x12, 0x8F, + 0xAC, 0x03, 0x11, 0x84, 0x61, 0x19, 0x3B, 0x65 + }, + { + 0x0E, 0x2B, 0xA5, 0x44, 0x1F, 0xEC, 0x03, 0x81, + 0xD0, 0x4E, 0x33, 0x89, 0xFE, 0x0B, 0x27, 0x00, + 0x01, 0x1E, 0x2A, 0xB9, 0x5C, 0x8D, 0xCD, 0xB1, + 0xDA, 0x1B, 0x8F, 0x20, 0x7E, 0x49, 0xE8, 0x65, + 0x59, 0x46, 0x68, 0x0A, 0xCE, 0x0D, 0xC7, 0x84, + 0xF9, 0xD3, 0xD7, 0x1B, 0x41, 0xE4, 0xF5, 0xCB, + 0x80, 0x6C, 0x66, 0xEE, 0xE6, 0xE1, 0x98, 0x6A, + 0x1D, 0x5F, 0x1A, 0x2E, 0x7C, 0xB7, 0x6D, 0x7B + }, + { + 0xB6, 0x8C, 0xC9, 0x9B, 0xA5, 0xCE, 0xFF, 0x7C, + 0xA3, 0x40, 0xAC, 0x8A, 0x3A, 0xB3, 0x52, 0x4D, + 0x97, 0x87, 0x59, 0xC1, 0x63, 0xAC, 0x20, 0x5B, + 0x13, 0x3A, 0x1E, 0xC5, 0x15, 0xB0, 0xC6, 0x6C, + 0x8A, 0x7A, 0x87, 0x96, 0x45, 0x1B, 0x17, 0xE4, + 0x00, 0x17, 0x74, 0xE8, 0x44, 0x7A, 0x59, 0x60, + 0x44, 0x19, 0x62, 0x43, 0xD2, 0x6B, 0xB7, 0x1B, + 0x0B, 0x0B, 0xED, 0xEB, 0xB0, 0x31, 0x00, 0x74 + }, + { + 0xB9, 0x11, 0x9E, 0xE8, 0x87, 0xE3, 0x2E, 0x3A, + 0xF3, 0xBB, 0x4B, 0x52, 0x90, 0x96, 0x3C, 0xE5, + 0x99, 0xF8, 0x28, 0x68, 0x3A, 0xFC, 0x99, 0x1D, + 0xEF, 0x83, 0x9E, 0x06, 0xF0, 0xED, 0x96, 0x28, + 0xF9, 0xFF, 0x29, 0xD2, 0x62, 0xA9, 0x59, 0x2C, + 0x56, 0x56, 0xBB, 0xA9, 0x96, 0xB7, 0x14, 0xB8, + 0x73, 0x79, 0xE2, 0x8D, 0x7A, 0x35, 0x49, 0xED, + 0x7B, 0x73, 0x32, 0xA3, 0xC6, 0x68, 0x8B, 0x86 + }, + { + 0x5A, 0xC2, 0xF2, 0x52, 0x7E, 0x0E, 0xA9, 0x20, + 0xAA, 0x86, 0x9C, 0xD6, 0x35, 0x7E, 0xF6, 0xDF, + 0x17, 0xA1, 0x81, 0x84, 0x15, 0xE2, 0x5D, 0x6F, + 0xDD, 0xB1, 0xCA, 0xEF, 0x26, 0x86, 0x73, 0x70, + 0xE0, 0x23, 0x73, 0x76, 0x6D, 0x7E, 0x9C, 0xDC, + 0xBD, 0x04, 0xB4, 0xCD, 0x8D, 0x20, 0x25, 0xB9, + 0xFD, 0x60, 0xFF, 0x03, 0x52, 0x33, 0xFB, 0xC6, + 0xD7, 0xAA, 0xCA, 0xB8, 0x5C, 0x70, 0xB6, 0x35 + }, + { + 0xA8, 0x67, 0x25, 0x59, 0x28, 0xA5, 0xE3, 0x79, + 0x46, 0xC5, 0xBF, 0x33, 0xC2, 0x03, 0xBF, 0x92, + 0xCC, 0xF7, 0xBF, 0x23, 0xB5, 0x5D, 0x7C, 0x90, + 0x4A, 0x3A, 0x6D, 0x2B, 0x90, 0x08, 0xE2, 0x79, + 0x5F, 0xB4, 0x4E, 0x67, 0x80, 0x72, 0xFC, 0x67, + 0xD6, 0x9A, 0x69, 0xE9, 0x28, 0xB5, 0x7C, 0x35, + 0x42, 0x30, 0x8F, 0xF8, 0x1B, 0xAB, 0xEF, 0xFA, + 0x16, 0x24, 0xF6, 0x3E, 0x24, 0x5C, 0x20, 0x8F + }, + { + 0x1D, 0x77, 0x40, 0xEC, 0x0E, 0x5E, 0xFE, 0x78, + 0xE4, 0xBE, 0x5F, 0x1E, 0x5A, 0xD7, 0xCE, 0x1B, + 0xC2, 0x09, 0x2C, 0xEB, 0x56, 0x41, 0x08, 0x52, + 0x5D, 0x0C, 0x32, 0xA6, 0xCE, 0x2B, 0x43, 0x6D, + 0xD2, 0x62, 0xB8, 0x9B, 0x49, 0xBA, 0x56, 0x12, + 0x72, 0x30, 0x59, 0x89, 0x9D, 0x7D, 0xD0, 0x70, + 0x50, 0x60, 0xF7, 0xFB, 0xA8, 0x5D, 0x09, 0xBF, + 0xEB, 0x60, 0x59, 0x2C, 0x04, 0xC6, 0x63, 0x3F + }, + { + 0x62, 0x24, 0xD2, 0x62, 0x76, 0x82, 0xF1, 0x7B, + 0x6B, 0x77, 0x6A, 0xA1, 0x25, 0x44, 0x2D, 0x61, + 0x1D, 0xAC, 0xB6, 0x5D, 0xC2, 0x94, 0xDA, 0xFF, + 0xBA, 0x54, 0x8F, 0x3E, 0x5A, 0xDF, 0x28, 0x3A, + 0xB2, 0xBE, 0x09, 0x21, 0x08, 0x2E, 0x3D, 0x30, + 0x23, 0x4F, 0x35, 0xBB, 0x0F, 0xA7, 0x4B, 0xA0, + 0x17, 0x98, 0x13, 0x8F, 0x14, 0xBF, 0x5E, 0xD4, + 0x40, 0x0E, 0xCD, 0x0E, 0xCE, 0x2A, 0x6D, 0x33 + }, + { + 0xA2, 0x34, 0x59, 0xB3, 0xFF, 0x19, 0x76, 0x56, + 0xA6, 0x7C, 0xB5, 0xBA, 0x97, 0x97, 0xD5, 0xB9, + 0x7B, 0xE2, 0x54, 0xEB, 0x70, 0x63, 0x47, 0xB9, + 0x2C, 0xAD, 0xFB, 0xB7, 0x23, 0xB1, 0x86, 0x9B, + 0x2B, 0x50, 0x96, 0x8A, 0x96, 0x76, 0xC7, 0xD6, + 0xDE, 0x66, 0xFB, 0xB1, 0xC0, 0x0A, 0x5B, 0x8A, + 0xFF, 0x4A, 0xB5, 0xDE, 0x4E, 0x2A, 0x43, 0x10, + 0x45, 0xBD, 0xAC, 0xF3, 0x76, 0xEF, 0x0C, 0x5E + }, + { + 0xDA, 0x90, 0x04, 0x93, 0x24, 0xB5, 0x59, 0x0E, + 0xE4, 0x76, 0x50, 0x51, 0x50, 0xBB, 0x59, 0xE5, + 0xBF, 0x10, 0x72, 0xC5, 0xDD, 0x8E, 0x4B, 0x89, + 0x88, 0x32, 0x02, 0x37, 0xCC, 0xFC, 0x14, 0x15, + 0xD5, 0x32, 0x02, 0x69, 0x5B, 0x51, 0x10, 0xEE, + 0x0B, 0x7F, 0xFA, 0x1F, 0x4B, 0x49, 0x2A, 0x91, + 0x0A, 0xFA, 0x18, 0xDE, 0x12, 0xC2, 0x8D, 0x2D, + 0xE9, 0xB5, 0xFE, 0x88, 0x68, 0x26, 0x8E, 0xE7 + }, + { + 0xD6, 0x30, 0xF8, 0x73, 0x2D, 0x08, 0x41, 0xD3, + 0x40, 0xC8, 0x17, 0xC6, 0xDF, 0x03, 0x2F, 0x72, + 0xD7, 0xBD, 0x8F, 0xAF, 0x9A, 0xAA, 0xE1, 0x1A, + 0x8E, 0x46, 0xA4, 0x6D, 0x5B, 0x2C, 0x60, 0xD6, + 0x25, 0xEB, 0x3D, 0x59, 0x0F, 0x29, 0x73, 0x9D, + 0xE2, 0x8D, 0x58, 0xA1, 0xEF, 0x9A, 0xBB, 0xD9, + 0x9E, 0x61, 0x2F, 0xDE, 0x44, 0x60, 0x89, 0xEC, + 0xC7, 0x5A, 0x64, 0x1B, 0xF6, 0xCB, 0xFD, 0x07 + }, + { + 0x38, 0x80, 0xE7, 0x94, 0x48, 0x5C, 0x9A, 0xBC, + 0xAA, 0x9D, 0x9C, 0xF8, 0xF3, 0x62, 0x63, 0x36, + 0x43, 0x3C, 0x9A, 0x79, 0xAD, 0x5F, 0x65, 0xE4, + 0x3D, 0x12, 0xBB, 0x3C, 0xA9, 0x2D, 0xFA, 0xAB, + 0x57, 0x21, 0xE6, 0xC8, 0x4C, 0x33, 0x4A, 0x4C, + 0xC3, 0x8F, 0xF0, 0x37, 0x86, 0xC2, 0x9E, 0xA6, + 0xBE, 0x0D, 0xC3, 0xCA, 0x60, 0x7E, 0x30, 0xF2, + 0xED, 0x74, 0x12, 0x51, 0x5A, 0x03, 0x9B, 0xC9 + }, + { + 0x11, 0x68, 0x6A, 0x7E, 0xC0, 0xA4, 0x9F, 0x5B, + 0xE2, 0xD5, 0x67, 0x5F, 0xE0, 0xF0, 0xEC, 0x15, + 0x4B, 0x19, 0xF3, 0xEF, 0x72, 0x03, 0x07, 0x9F, + 0x98, 0xB6, 0xA0, 0x8F, 0xFB, 0x41, 0x70, 0x2D, + 0x78, 0x13, 0xF7, 0xB1, 0x01, 0x1A, 0xBC, 0x7C, + 0x4A, 0x75, 0x71, 0xBC, 0xF0, 0x04, 0x67, 0xE5, + 0x64, 0x77, 0xFC, 0x36, 0x83, 0x0E, 0xA1, 0x75, + 0xCE, 0xEE, 0xD0, 0xD8, 0xC4, 0x05, 0xF3, 0x1D + }, + { + 0x73, 0xC9, 0x65, 0x48, 0x7D, 0xB9, 0xDE, 0x71, + 0x23, 0x95, 0x2E, 0xFA, 0xC5, 0x32, 0x68, 0x3C, + 0x1C, 0x5A, 0xF7, 0xAE, 0x6A, 0xAF, 0x6E, 0x34, + 0xBD, 0x29, 0xD4, 0x71, 0x5A, 0x70, 0x19, 0xCD, + 0xE4, 0x6E, 0xF2, 0xD5, 0x5F, 0xB4, 0x9F, 0x3D, + 0x84, 0x28, 0x18, 0xCF, 0x84, 0xA3, 0x54, 0xCF, + 0xB4, 0x99, 0xCD, 0x00, 0xB3, 0xE9, 0x38, 0x49, + 0x47, 0xDD, 0xC9, 0x5C, 0x9D, 0x63, 0x8C, 0x32 + }, + { + 0x58, 0x00, 0x3E, 0xEF, 0x24, 0x7A, 0x7E, 0xA5, + 0x60, 0x58, 0x06, 0x26, 0x37, 0x6C, 0x00, 0xAB, + 0x7B, 0xA1, 0x38, 0x8F, 0x35, 0xBE, 0x5C, 0x9D, + 0x50, 0x57, 0xC4, 0x57, 0xAF, 0x53, 0x88, 0x35, + 0x31, 0x65, 0x84, 0x29, 0x17, 0xE7, 0xC4, 0xD2, + 0x9C, 0x9F, 0x02, 0xFF, 0x5D, 0xD9, 0x0D, 0xA9, + 0xBA, 0x49, 0x31, 0xA1, 0x92, 0x08, 0xE6, 0xCF, + 0x94, 0x37, 0x72, 0x86, 0xC8, 0xD2, 0xB9, 0xDC + }, + { + 0xD7, 0x75, 0xE5, 0xA3, 0x8F, 0xF5, 0x1B, 0x1A, + 0x6E, 0x8D, 0xA8, 0xF5, 0x39, 0x85, 0x14, 0x7D, + 0xC7, 0xF7, 0x92, 0x91, 0x4C, 0xB7, 0x23, 0xE2, + 0xBA, 0xDF, 0xC4, 0x2E, 0xE6, 0x13, 0x7E, 0x98, + 0xD5, 0x19, 0xF2, 0x94, 0x9E, 0xB7, 0x1F, 0x58, + 0x82, 0xF7, 0x6B, 0x11, 0x75, 0xA9, 0x45, 0x6D, + 0x19, 0x6C, 0x3B, 0x47, 0xBD, 0x48, 0x58, 0x12, + 0xDC, 0xFD, 0x84, 0xCA, 0x17, 0x20, 0xB4, 0x86 + }, + { + 0x5A, 0xA3, 0xA4, 0x3F, 0x95, 0x79, 0x56, 0x3F, + 0x2F, 0xDC, 0x33, 0x6F, 0x85, 0xA7, 0x01, 0xCF, + 0xBA, 0x3B, 0xF7, 0x0F, 0xD4, 0xDB, 0x70, 0x61, + 0x0E, 0x12, 0x81, 0x13, 0xA9, 0x70, 0xFB, 0x46, + 0x26, 0xDB, 0x83, 0xDE, 0xC3, 0x18, 0xD4, 0x35, + 0xA2, 0x49, 0x47, 0x07, 0x81, 0xCB, 0x7A, 0x8E, + 0xE1, 0xF4, 0x89, 0x47, 0x91, 0xAD, 0x37, 0xF6, + 0xAC, 0x80, 0x9E, 0x3C, 0x26, 0x36, 0x38, 0x43 + }, + { + 0x80, 0xDC, 0x75, 0xFC, 0x5F, 0xB0, 0x4B, 0x94, + 0xDC, 0x74, 0x33, 0x3B, 0x02, 0x9D, 0xC4, 0x68, + 0x08, 0x5E, 0x6C, 0x1F, 0x97, 0x66, 0x43, 0xD6, + 0x9F, 0xBE, 0x2D, 0x82, 0xEC, 0x05, 0x37, 0xA9, + 0xC4, 0x25, 0xFC, 0x7D, 0x0D, 0x8C, 0x4E, 0xC3, + 0x24, 0x45, 0x8B, 0xF4, 0x6E, 0xE5, 0x43, 0x15, + 0x94, 0x52, 0x13, 0x89, 0xFD, 0x84, 0x84, 0x95, + 0x38, 0xF4, 0x79, 0x95, 0x01, 0x64, 0x24, 0xA2 + }, + { + 0x60, 0x1A, 0x4C, 0xCB, 0x60, 0x21, 0xC9, 0xD6, + 0xF8, 0x3B, 0xAB, 0x50, 0xBE, 0xEB, 0x45, 0x0E, + 0xCA, 0xE3, 0x4B, 0x60, 0x21, 0xD3, 0xF1, 0xBF, + 0xFA, 0x72, 0xE4, 0xF5, 0x3E, 0x63, 0x12, 0xCC, + 0x38, 0xF0, 0x75, 0x70, 0xED, 0x4B, 0x2D, 0xF5, + 0x35, 0xDD, 0x0C, 0x0A, 0x71, 0x35, 0xA1, 0x99, + 0x91, 0xFB, 0xAC, 0xF6, 0x3F, 0x32, 0x22, 0x28, + 0x4F, 0x13, 0xDF, 0x51, 0x4B, 0x26, 0x7B, 0x40 + }, + { + 0x3A, 0x88, 0x0D, 0xF7, 0xB1, 0xF0, 0x4C, 0x0A, + 0xC4, 0xB9, 0xAE, 0xF1, 0x93, 0x46, 0xBC, 0x08, + 0x85, 0x61, 0x08, 0x87, 0x1F, 0xEB, 0xE5, 0x95, + 0x12, 0x3B, 0xBA, 0xC1, 0xAD, 0xFC, 0x3A, 0x8F, + 0x67, 0xD7, 0xCA, 0xEC, 0x29, 0xB1, 0x30, 0xAC, + 0x63, 0xF6, 0x94, 0x68, 0x01, 0x4D, 0x6D, 0x0D, + 0xCC, 0xD6, 0x35, 0x6B, 0xBE, 0xF6, 0x7A, 0x71, + 0xAF, 0x8C, 0x55, 0x84, 0x0A, 0xD5, 0xC8, 0x84 + }, + { + 0x6C, 0xDA, 0x19, 0x7C, 0xB4, 0x53, 0x56, 0x2F, + 0x8E, 0x3C, 0x87, 0xB4, 0x14, 0x35, 0x4E, 0x62, + 0x77, 0x8D, 0xE2, 0xD0, 0xEE, 0xE2, 0xAE, 0x6E, + 0xFE, 0x7A, 0xD1, 0xBD, 0x7B, 0x78, 0x45, 0x61, + 0xA7, 0x50, 0x6B, 0xAD, 0x4B, 0xB8, 0x52, 0x12, + 0x3F, 0xC0, 0x81, 0x0E, 0x5F, 0x21, 0x8D, 0x26, + 0xD2, 0x5B, 0x29, 0x53, 0x2B, 0x9F, 0xE3, 0x13, + 0x6F, 0xBC, 0x23, 0x76, 0x53, 0x53, 0x95, 0x94 + }, + { + 0x81, 0xF6, 0x68, 0xB9, 0xEF, 0x7E, 0xBC, 0x39, + 0x32, 0xCC, 0x4F, 0x9D, 0xB8, 0xCD, 0x08, 0xBA, + 0xBF, 0xA5, 0x31, 0x82, 0xB1, 0xF9, 0x7B, 0x8F, + 0x2C, 0xAA, 0x11, 0xC5, 0xCB, 0x88, 0xDB, 0xDB, + 0xE8, 0x6B, 0x85, 0x83, 0x48, 0x1D, 0x9D, 0xEC, + 0x2E, 0x27, 0x5E, 0x5C, 0x03, 0xFA, 0xCC, 0xEE, + 0x30, 0x6A, 0x01, 0x11, 0x97, 0x68, 0xB4, 0x67, + 0x54, 0x8F, 0xF1, 0x19, 0xFF, 0x20, 0x51, 0xD4 + }, + { + 0x59, 0x84, 0x9A, 0xEA, 0xD1, 0x8B, 0xF8, 0x57, + 0x83, 0x18, 0x8B, 0x1D, 0xD7, 0x9C, 0xF4, 0x62, + 0xE6, 0x06, 0x9A, 0xCF, 0x72, 0xC6, 0x79, 0x9F, + 0x1F, 0x1A, 0xF9, 0x96, 0x06, 0x22, 0x76, 0x45, + 0x23, 0x55, 0xFF, 0xCD, 0x2E, 0x0B, 0x30, 0x9E, + 0x80, 0x1F, 0x85, 0x6E, 0xEB, 0x3D, 0x94, 0x75, + 0xD6, 0xBB, 0xED, 0x97, 0x85, 0x73, 0x8C, 0xC2, + 0xF6, 0xE5, 0xF9, 0x32, 0xC0, 0x63, 0x48, 0xA8 + }, + { + 0x4A, 0x27, 0xDB, 0x58, 0x05, 0x17, 0x54, 0xFB, + 0xA2, 0xF4, 0x14, 0x92, 0xB8, 0xC8, 0x82, 0x54, + 0xD6, 0x17, 0xB9, 0x56, 0x9D, 0x40, 0x64, 0x2B, + 0xCC, 0x8D, 0x5A, 0x8A, 0xD5, 0x69, 0xBC, 0x20, + 0xFB, 0x8B, 0x79, 0x4B, 0x20, 0xBA, 0x1B, 0x9B, + 0xCA, 0xA9, 0x4B, 0xBF, 0xF7, 0xFD, 0x3F, 0x5D, + 0x48, 0xD4, 0x16, 0xCB, 0x17, 0x1C, 0xCB, 0x56, + 0x20, 0xBB, 0x5D, 0x66, 0xC1, 0x6D, 0x54, 0x46 + }, + { + 0xB4, 0xC2, 0x5C, 0xC5, 0xD5, 0xEC, 0x32, 0x63, + 0x97, 0xB6, 0x08, 0xD6, 0xCD, 0x99, 0x19, 0x5A, + 0x2B, 0xA6, 0x06, 0xE6, 0xB3, 0x37, 0xB6, 0x92, + 0x82, 0x82, 0xB2, 0x3A, 0xBA, 0x7C, 0x33, 0x43, + 0x45, 0x27, 0xAE, 0x7A, 0x43, 0xA0, 0xA8, 0xA1, + 0x68, 0x19, 0x55, 0x62, 0xC4, 0x94, 0xEF, 0xBB, + 0xCE, 0x02, 0x51, 0xE5, 0x4E, 0x4D, 0xB4, 0xDC, + 0xDA, 0xAA, 0x48, 0x41, 0x21, 0x02, 0x34, 0x49 + }, + { + 0x16, 0x77, 0xB8, 0x8C, 0x2D, 0xBF, 0xA1, 0xF0, + 0x5A, 0x3F, 0x47, 0x9E, 0xAC, 0x24, 0xEF, 0xA0, + 0x08, 0x66, 0x81, 0xC6, 0xB0, 0x47, 0x84, 0x83, + 0x46, 0x42, 0xFB, 0x2F, 0x7C, 0x1C, 0xA1, 0xF6, + 0xAC, 0x32, 0x0C, 0x3E, 0xA7, 0xD1, 0xCF, 0x2F, + 0xF5, 0x07, 0xE1, 0x4C, 0x7F, 0xEC, 0x75, 0x6F, + 0x16, 0x04, 0x96, 0x9F, 0xB5, 0x12, 0xEB, 0xE2, + 0x61, 0x3F, 0xE2, 0x6B, 0xCF, 0x5B, 0xA4, 0x50 + }, + { + 0x55, 0xC3, 0xE0, 0xA5, 0x6D, 0x27, 0xA8, 0xDC, + 0x69, 0xA2, 0xA8, 0xBB, 0x14, 0x76, 0x05, 0xAD, + 0x6A, 0x40, 0xDA, 0x3C, 0x53, 0xDA, 0xCB, 0xFD, + 0x5A, 0x49, 0x1B, 0xCB, 0x1C, 0x74, 0xC9, 0x06, + 0x37, 0x2F, 0x7A, 0xEA, 0xB0, 0x7E, 0x38, 0x9A, + 0xFE, 0x5C, 0x21, 0x1D, 0xEC, 0x00, 0x5B, 0xD8, + 0x77, 0x52, 0x98, 0x4B, 0x46, 0xB8, 0x20, 0xDC, + 0xAC, 0xA3, 0xD6, 0x1D, 0xDD, 0x86, 0x5A, 0xD0 + }, + { + 0x98, 0xFA, 0x90, 0x7A, 0x8F, 0x32, 0x80, 0x79, + 0xD3, 0x8F, 0xB4, 0x3F, 0xE1, 0xB4, 0x2F, 0x54, + 0xAF, 0xC3, 0x01, 0xB4, 0x9C, 0x23, 0xD1, 0x2C, + 0xEF, 0x60, 0x4E, 0xFA, 0xA5, 0x1D, 0xA8, 0xDB, + 0xB0, 0x50, 0xC5, 0x46, 0x0C, 0xDB, 0xED, 0x6D, + 0x51, 0x71, 0x6E, 0x9A, 0x41, 0xA3, 0x71, 0xB3, + 0xF0, 0xC2, 0x57, 0x12, 0xB3, 0x45, 0x87, 0x34, + 0x98, 0x13, 0xC3, 0xD7, 0xBF, 0xD4, 0xE7, 0x31 + }, + { + 0x68, 0x02, 0x0A, 0x24, 0xC1, 0x6D, 0xFD, 0x29, + 0xE4, 0xF5, 0x3B, 0x03, 0xEF, 0xD8, 0x88, 0x59, + 0xFA, 0x25, 0xD4, 0xA4, 0x14, 0x44, 0xDD, 0x0E, + 0x47, 0xA4, 0xC1, 0x6F, 0xEC, 0xE2, 0x64, 0x25, + 0xE3, 0x31, 0x58, 0x6F, 0x92, 0xD6, 0x52, 0x71, + 0x57, 0x65, 0xBC, 0xD1, 0x96, 0x4C, 0x23, 0xD9, + 0x24, 0x65, 0x27, 0xC3, 0x9F, 0x42, 0x49, 0x72, + 0xB0, 0x20, 0x50, 0x33, 0x44, 0x33, 0xE1, 0x7B + }, + { + 0x9A, 0xD3, 0x42, 0x60, 0xB0, 0xDB, 0xC4, 0xF3, + 0xCE, 0xCE, 0xAC, 0x1E, 0x62, 0xD7, 0xC4, 0x89, + 0x55, 0x47, 0x22, 0xA5, 0x3F, 0x52, 0xA8, 0x23, + 0x0B, 0xAD, 0xEA, 0x27, 0x2C, 0x80, 0x8B, 0x3A, + 0xC0, 0x00, 0xD3, 0xC4, 0xA9, 0x1E, 0xA2, 0xB8, + 0x53, 0xAC, 0x2D, 0x32, 0x2B, 0x79, 0x21, 0x17, + 0xA5, 0x7B, 0xF7, 0xBB, 0x2D, 0x3B, 0x53, 0x0A, + 0xCF, 0xEF, 0xA4, 0x1C, 0x4C, 0x57, 0xFC, 0x41 + }, + { + 0xFF, 0x27, 0x57, 0x84, 0xB4, 0xAB, 0xBA, 0xAD, + 0xC4, 0xAD, 0x10, 0x94, 0xE4, 0x92, 0xFE, 0x96, + 0x6C, 0x0B, 0xE6, 0x38, 0x18, 0xC6, 0xA1, 0xFA, + 0x30, 0x66, 0x7B, 0xE0, 0xA5, 0x67, 0x57, 0xEC, + 0x62, 0xA1, 0x20, 0xA3, 0xE1, 0xD8, 0x78, 0xBA, + 0xA2, 0xA6, 0x95, 0x20, 0x2E, 0xA8, 0x99, 0x7D, + 0x7C, 0x4D, 0xE2, 0xBD, 0xFC, 0x55, 0xCA, 0x15, + 0x73, 0xAA, 0x61, 0x37, 0xDA, 0x5B, 0x58, 0xA4 + }, + { + 0xBB, 0xEA, 0x99, 0x53, 0x5A, 0x3C, 0x0F, 0xD3, + 0x9D, 0x57, 0x3D, 0x8E, 0x74, 0x29, 0x00, 0x94, + 0x1A, 0xEA, 0xA6, 0x4F, 0xC9, 0xBE, 0x38, 0x9C, + 0xA0, 0x3A, 0xFD, 0xF1, 0xE8, 0xDB, 0x5B, 0xB1, + 0x55, 0x0A, 0x6F, 0x6F, 0x87, 0x18, 0xB7, 0x5A, + 0xB3, 0x80, 0x94, 0x58, 0x7C, 0x67, 0x5A, 0x7C, + 0xB8, 0xC9, 0xCA, 0xBB, 0xA5, 0x30, 0x34, 0x80, + 0x28, 0x25, 0x26, 0x31, 0x1B, 0x5A, 0x49, 0x11 + }, + { + 0x49, 0xD9, 0xD5, 0x24, 0xA8, 0x43, 0x31, 0x5F, + 0x03, 0x63, 0x93, 0x95, 0xCA, 0x0D, 0xF8, 0xC2, + 0xE3, 0x9F, 0x6E, 0x8D, 0x28, 0xF3, 0x34, 0x34, + 0xE5, 0x37, 0xEF, 0xBE, 0x49, 0x4C, 0x39, 0x12, + 0xA6, 0xBB, 0x59, 0x77, 0x10, 0x05, 0x5A, 0x41, + 0x65, 0x47, 0xDF, 0xDD, 0x98, 0xE4, 0x80, 0x6F, + 0xB5, 0xD4, 0x54, 0x27, 0xA2, 0xF2, 0x73, 0xED, + 0x3A, 0x91, 0xD2, 0x12, 0x63, 0xA3, 0x6E, 0x3B + }, + { + 0xFD, 0xC2, 0x3A, 0x90, 0x00, 0xF1, 0xE5, 0x10, + 0x5D, 0x4F, 0x48, 0x49, 0xC7, 0x3B, 0x7D, 0x01, + 0x7B, 0xA7, 0x9D, 0xD6, 0xF2, 0x30, 0x1C, 0x86, + 0xBC, 0x0E, 0x98, 0x1B, 0x29, 0xBC, 0x6D, 0x88, + 0x72, 0xE4, 0x7E, 0x82, 0x4F, 0x27, 0xA7, 0x0A, + 0xC0, 0x15, 0x26, 0x0F, 0x22, 0xE9, 0x9E, 0xCF, + 0x53, 0xB5, 0xAA, 0x7F, 0x55, 0xF9, 0x35, 0xF0, + 0x66, 0x95, 0x93, 0xF9, 0xCD, 0x39, 0x80, 0xEB + }, + { + 0xAB, 0x01, 0x08, 0x8A, 0x6C, 0x67, 0xE0, 0xAF, + 0xCB, 0x88, 0x80, 0x14, 0x42, 0x90, 0xA3, 0xBC, + 0x32, 0x68, 0x36, 0xC4, 0x14, 0x95, 0x06, 0x23, + 0x61, 0xD6, 0x70, 0x84, 0xF5, 0xCD, 0x2C, 0x5A, + 0x0E, 0x46, 0xBF, 0x29, 0xBE, 0x25, 0xD8, 0xC8, + 0x36, 0xD4, 0xE1, 0x61, 0xBD, 0x5E, 0x53, 0xE0, + 0xDE, 0x60, 0x64, 0x52, 0x75, 0xF3, 0xDC, 0xA3, + 0x72, 0x42, 0x54, 0x8A, 0x8C, 0x31, 0xC2, 0x79 + }, + { + 0xFA, 0x64, 0xD7, 0xC4, 0x3F, 0xEF, 0xFD, 0x68, + 0x64, 0x00, 0x8C, 0xE5, 0x6D, 0x14, 0x17, 0xDE, + 0x56, 0x00, 0x8F, 0xCC, 0x36, 0x56, 0x2A, 0x07, + 0x78, 0xC4, 0xF6, 0xD4, 0x8F, 0x6D, 0x03, 0x83, + 0x18, 0x26, 0x20, 0x70, 0x5E, 0x1D, 0x2B, 0x5C, + 0x5F, 0xE0, 0xB1, 0xBC, 0xBB, 0x4B, 0x58, 0x06, + 0xD1, 0x6A, 0xD7, 0xEC, 0x90, 0xD9, 0x3C, 0xD8, + 0xD9, 0xBB, 0x35, 0x66, 0x54, 0x60, 0xBE, 0xFB + }, + { + 0x3D, 0x87, 0x68, 0xA4, 0xA7, 0x6D, 0xD5, 0xC6, + 0x1A, 0x74, 0x53, 0x26, 0x22, 0x45, 0xF1, 0x31, + 0x36, 0x8B, 0xBF, 0x32, 0x15, 0xD1, 0x78, 0xC8, + 0x3A, 0xBF, 0xEC, 0x3C, 0x1B, 0x69, 0x14, 0xFC, + 0x61, 0x9F, 0xBD, 0x88, 0xE3, 0xC5, 0x97, 0xE7, + 0x23, 0x31, 0x0E, 0xEF, 0xC3, 0xE0, 0x55, 0xD5, + 0xFF, 0xFE, 0x40, 0xD5, 0xB2, 0xA9, 0xCE, 0x06, + 0x48, 0x35, 0xB8, 0xA8, 0x18, 0x95, 0x2E, 0xBD + }, + { + 0xD7, 0x5D, 0xE4, 0xF3, 0x36, 0xCA, 0x73, 0x6F, + 0x77, 0xA0, 0x56, 0xFC, 0xBF, 0x02, 0x53, 0x4C, + 0x51, 0x84, 0xA6, 0x4A, 0x6F, 0x6A, 0xA1, 0xEB, + 0x13, 0x4A, 0xD6, 0x17, 0xE6, 0xAB, 0x45, 0x8E, + 0x29, 0xAF, 0x43, 0x63, 0x68, 0x6F, 0x59, 0xFB, + 0x61, 0x33, 0x3C, 0xF7, 0xAD, 0x2A, 0xB8, 0x50, + 0xE5, 0x7F, 0x97, 0x44, 0x79, 0x6C, 0xBB, 0x49, + 0xA1, 0x42, 0xC7, 0xC7, 0x81, 0x81, 0x54, 0x19 + }, + { + 0x1B, 0x3B, 0xA7, 0x53, 0x81, 0x48, 0x35, 0x22, + 0xC0, 0xB6, 0x8F, 0xEA, 0x22, 0x66, 0xBA, 0xE9, + 0x5B, 0x88, 0x24, 0x75, 0xC6, 0xB1, 0xDB, 0x0D, + 0x39, 0xD3, 0x55, 0xA1, 0xF7, 0x76, 0xFC, 0xFC, + 0x20, 0x19, 0x7E, 0x3D, 0xC7, 0xF1, 0x8D, 0x58, + 0x9D, 0x97, 0xF2, 0x93, 0xC0, 0xE1, 0x48, 0x62, + 0xD6, 0xFD, 0x8F, 0xA6, 0x5D, 0x36, 0x99, 0xCE, + 0x3D, 0x4E, 0x87, 0xB6, 0x12, 0x8F, 0x7F, 0x83 + }, + { + 0xF0, 0x0F, 0xDF, 0xE5, 0xEC, 0x3C, 0xD9, 0x72, + 0xD5, 0xDD, 0x29, 0xE6, 0x5D, 0xD4, 0x39, 0xAB, + 0x26, 0x0C, 0xCD, 0x21, 0xD7, 0x94, 0xDE, 0x9B, + 0xD8, 0x4E, 0x6A, 0xF0, 0x35, 0xD2, 0x90, 0xDF, + 0x21, 0xD7, 0x6F, 0x59, 0xE7, 0x99, 0x29, 0x5B, + 0xA1, 0x86, 0xC6, 0xEE, 0x22, 0xA0, 0x5F, 0x0F, + 0x18, 0xF0, 0x3F, 0x90, 0x63, 0xD6, 0x93, 0x6B, + 0xF8, 0x15, 0xAD, 0x32, 0xB3, 0x8F, 0x4A, 0x7A + }, + { + 0xD1, 0x43, 0xBB, 0xD2, 0xD1, 0x7C, 0xCE, 0x5F, + 0x0D, 0xF2, 0x7A, 0xA4, 0xCA, 0x80, 0x9E, 0xF1, + 0x29, 0x72, 0xED, 0x95, 0x3B, 0x5C, 0x6B, 0xD2, + 0xD0, 0xFF, 0x5E, 0xEC, 0x0B, 0xEF, 0x1A, 0xBF, + 0x5C, 0x02, 0xF7, 0x8D, 0x85, 0xE8, 0x23, 0xB1, + 0xB5, 0x69, 0x8F, 0xB7, 0x4F, 0xAD, 0xFA, 0xE3, + 0xD1, 0x12, 0x2B, 0x6D, 0x2B, 0xC5, 0x47, 0x3E, + 0x2B, 0x56, 0x7E, 0x1B, 0xCB, 0x46, 0xE2, 0x95 + }, + { + 0xC8, 0xC7, 0xEC, 0x1E, 0x2A, 0xC4, 0x60, 0xB8, + 0x69, 0xAA, 0xA4, 0x0A, 0xBD, 0x28, 0xFC, 0x99, + 0xD1, 0xFF, 0xA2, 0xDB, 0xD8, 0x7D, 0x11, 0x3E, + 0xF2, 0x02, 0xA6, 0x41, 0x38, 0x8E, 0x40, 0xD6, + 0xF4, 0xA0, 0xE7, 0x5E, 0x6F, 0x74, 0x5A, 0x9F, + 0xFC, 0x6D, 0xC1, 0xE1, 0x9D, 0xC8, 0x8C, 0xBC, + 0x90, 0xCA, 0xE7, 0x2C, 0x25, 0x14, 0x29, 0x2D, + 0xDC, 0x89, 0x16, 0x50, 0xE5, 0xBB, 0xF2, 0x6B + }, + { + 0x28, 0xB9, 0x51, 0x69, 0xCB, 0x93, 0x21, 0x62, + 0x9F, 0x69, 0xA6, 0x96, 0x46, 0x76, 0x8F, 0xC9, + 0xD9, 0x41, 0x09, 0x88, 0xD0, 0x41, 0x98, 0x2D, + 0x71, 0x83, 0x23, 0x5C, 0x9B, 0x2A, 0x0C, 0x1E, + 0x95, 0xFE, 0x57, 0xFC, 0xBA, 0xB6, 0x3F, 0xCE, + 0x5D, 0x44, 0xE8, 0x6B, 0x4B, 0x05, 0x72, 0x9F, + 0x36, 0xDC, 0xDC, 0x7C, 0xD8, 0x07, 0x43, 0xAF, + 0xF7, 0x92, 0x4C, 0xC0, 0xF6, 0x6E, 0x0A, 0xEA + }, + { + 0x78, 0xD5, 0x62, 0xCA, 0x1B, 0xE3, 0x29, 0x65, + 0xA1, 0xDD, 0x21, 0xE0, 0x0C, 0xDA, 0xA2, 0x60, + 0x96, 0x3B, 0x52, 0x7C, 0x73, 0x2B, 0x83, 0x46, + 0x0C, 0x94, 0x45, 0x33, 0xF7, 0x85, 0x11, 0x18, + 0xA6, 0x1B, 0x46, 0x3A, 0x65, 0xF9, 0x2A, 0xF3, + 0x65, 0x72, 0x39, 0x8B, 0x02, 0x7B, 0x15, 0x8B, + 0x30, 0xEB, 0x7C, 0x16, 0x9F, 0x11, 0x8A, 0xE2, + 0x63, 0x84, 0x0B, 0xB4, 0x7E, 0xA8, 0x04, 0x26 + }, + { + 0x52, 0x9C, 0xA6, 0x40, 0x5D, 0x65, 0x02, 0xFF, + 0x4F, 0x8C, 0xAF, 0x59, 0x28, 0x6C, 0xE2, 0xB2, + 0x7C, 0x2C, 0x54, 0xDE, 0x20, 0x03, 0x05, 0xF4, + 0x36, 0xB9, 0xF2, 0x00, 0xEA, 0x44, 0xA0, 0x48, + 0xBF, 0xCC, 0x96, 0x1F, 0xCE, 0xC9, 0x55, 0x02, + 0x9B, 0x69, 0x4D, 0xD7, 0x7D, 0xB6, 0x5D, 0x9A, + 0xB9, 0x7C, 0x4A, 0x29, 0x57, 0x49, 0x44, 0x7D, + 0x87, 0x76, 0x39, 0xDA, 0x03, 0x59, 0x32, 0x81 + }, + { + 0x3B, 0x6C, 0x73, 0xB8, 0xCF, 0x5B, 0x34, 0x6B, + 0xCD, 0x5E, 0x9D, 0x04, 0xD0, 0xE0, 0x51, 0x9B, + 0x1A, 0x81, 0x91, 0x2B, 0xB2, 0xCB, 0x25, 0x65, + 0xF8, 0x38, 0x98, 0x24, 0xD8, 0x15, 0xE4, 0xDE, + 0x60, 0x93, 0x86, 0x1D, 0xD9, 0x4E, 0x84, 0x16, + 0xFE, 0x5A, 0x6B, 0xDA, 0x1A, 0xFD, 0x91, 0xF6, + 0xF8, 0xD9, 0x1C, 0xDA, 0xE6, 0xED, 0x62, 0xAA, + 0x39, 0x12, 0x15, 0x82, 0x00, 0x37, 0x53, 0xF3 + }, + { + 0xDB, 0xFF, 0x55, 0xC3, 0x94, 0x92, 0xF9, 0x76, + 0x95, 0x0F, 0x3B, 0x7F, 0xC7, 0xF0, 0xF4, 0x56, + 0x86, 0xBB, 0x2F, 0xD5, 0x05, 0x50, 0x1B, 0x91, + 0xA0, 0xAF, 0x6D, 0x1F, 0xF3, 0xA5, 0x06, 0x46, + 0x1A, 0x35, 0xC9, 0xCD, 0x43, 0x6F, 0xD0, 0x9B, + 0x7C, 0xC4, 0x48, 0x49, 0x67, 0x46, 0x95, 0xF2, + 0x62, 0x00, 0xEB, 0x17, 0x8F, 0xE1, 0x85, 0xC8, + 0x42, 0x9C, 0xF1, 0x31, 0xA4, 0xDA, 0x5D, 0x0E + }, + { + 0x4B, 0x6A, 0xDD, 0xE5, 0xF7, 0x64, 0x9D, 0x4E, + 0x32, 0x54, 0x56, 0xEC, 0xBD, 0xDC, 0xF8, 0x13, + 0x12, 0x8D, 0x78, 0x2E, 0xD6, 0x6F, 0xDE, 0x93, + 0x1D, 0x5E, 0x64, 0x50, 0x20, 0x0C, 0xD5, 0x4C, + 0x08, 0xE7, 0x13, 0xE4, 0x04, 0xF1, 0x53, 0xFC, + 0xA4, 0x77, 0xEE, 0x0F, 0x33, 0x43, 0x27, 0x79, + 0x83, 0x53, 0xE2, 0x02, 0xD6, 0xA9, 0x03, 0x0E, + 0xBF, 0xD9, 0x3A, 0x37, 0xD4, 0x97, 0xBE, 0xAF + }, + { + 0xAD, 0x45, 0x96, 0x63, 0x6D, 0x44, 0x0D, 0x6F, + 0x24, 0x8C, 0xA6, 0xEB, 0x7F, 0x8D, 0x0F, 0x19, + 0x98, 0xD3, 0xA1, 0xD3, 0xE3, 0x9C, 0xA4, 0x13, + 0xCB, 0x49, 0x47, 0xA3, 0x63, 0x18, 0xC7, 0x69, + 0xB2, 0x01, 0x44, 0x24, 0xD1, 0xC3, 0x7C, 0xE1, + 0x59, 0x02, 0xAE, 0xAF, 0xA8, 0x68, 0xA6, 0x04, + 0x9A, 0x3D, 0x1D, 0x27, 0xD9, 0x75, 0xD7, 0x78, + 0xEC, 0x28, 0x5A, 0xEC, 0x91, 0x69, 0x27, 0x08 + }, + { + 0x26, 0x6D, 0xC1, 0x4A, 0xC5, 0xCD, 0x6C, 0x3B, + 0x0A, 0x1B, 0x95, 0x6C, 0x40, 0x86, 0x98, 0xCD, + 0x26, 0x96, 0x2E, 0x5A, 0x97, 0xBD, 0x37, 0xA5, + 0x67, 0xFE, 0x79, 0x31, 0xF2, 0x3A, 0xE6, 0xB0, + 0x3C, 0x2B, 0x5D, 0x94, 0x1E, 0xBB, 0xC5, 0x44, + 0x2E, 0xDD, 0x5B, 0x59, 0x19, 0x2A, 0x40, 0xA1, + 0xCC, 0x10, 0xA8, 0x05, 0x21, 0x90, 0x9D, 0xA1, + 0xDB, 0xBC, 0x59, 0x36, 0x89, 0x9B, 0x1F, 0x7F + }, + { + 0xA3, 0x41, 0xF3, 0xBF, 0x81, 0x24, 0xA0, 0x14, + 0x52, 0xAA, 0xF9, 0xC5, 0xF7, 0x45, 0x45, 0x41, + 0xE5, 0xDA, 0x47, 0x01, 0xFE, 0x5F, 0x3D, 0x23, + 0xDC, 0x68, 0xC3, 0x07, 0x80, 0x07, 0x77, 0x28, + 0x9B, 0x35, 0x1E, 0x8E, 0xC4, 0xB4, 0x6D, 0xC4, + 0x1B, 0xA0, 0x7B, 0x6C, 0x09, 0xDB, 0x6E, 0x44, + 0x57, 0x45, 0xE1, 0xFE, 0xE6, 0xDF, 0xEA, 0x6B, + 0x3E, 0xE0, 0x20, 0x64, 0x4C, 0x70, 0x86, 0x67 + }, + { + 0x67, 0xC8, 0x23, 0x55, 0x98, 0x58, 0x85, 0x85, + 0xA6, 0xCA, 0x74, 0x59, 0x48, 0x98, 0x52, 0xF1, + 0xB3, 0x59, 0x31, 0x1C, 0x0C, 0x72, 0xFE, 0xB7, + 0x59, 0xA3, 0xD7, 0x83, 0x65, 0x51, 0xE0, 0x02, + 0xBD, 0x70, 0x0A, 0xCD, 0xF4, 0xC4, 0x7A, 0xF8, + 0x55, 0xE3, 0x12, 0x8D, 0x03, 0x17, 0xBF, 0x45, + 0x2E, 0x39, 0xE0, 0x67, 0x13, 0xC0, 0x06, 0xD5, + 0x87, 0xA3, 0xEE, 0x58, 0x67, 0xC4, 0x03, 0x83 + }, + { + 0xD7, 0x1D, 0xE0, 0xBF, 0x4D, 0x64, 0x5B, 0xD7, + 0x4D, 0xC0, 0x6E, 0x6A, 0x04, 0x99, 0x38, 0x30, + 0x46, 0xD8, 0x7A, 0xF6, 0x55, 0xC7, 0xC6, 0x0A, + 0x01, 0x63, 0x3D, 0x24, 0x24, 0x61, 0xE9, 0x1E, + 0x16, 0xE8, 0x37, 0xEA, 0x59, 0x65, 0x86, 0x04, + 0x00, 0x88, 0x94, 0x4B, 0xD6, 0xC0, 0x16, 0xC7, + 0x77, 0x47, 0x74, 0x8E, 0x02, 0x28, 0x26, 0xB4, + 0x66, 0x74, 0xD7, 0x27, 0xD8, 0xB2, 0x9E, 0xEE + }, + { + 0xD2, 0xF7, 0xC4, 0x14, 0x9E, 0x59, 0x00, 0x5E, + 0xD3, 0xB5, 0xEF, 0x36, 0x33, 0x64, 0x22, 0x3C, + 0x00, 0x2C, 0x6C, 0xA2, 0xEB, 0x52, 0x29, 0x36, + 0x23, 0xCD, 0x24, 0x6E, 0x1A, 0x5B, 0xAB, 0x74, + 0xB7, 0xA7, 0x1A, 0xC4, 0x4A, 0xF9, 0x4C, 0x08, + 0x26, 0xEC, 0x8F, 0x2B, 0x23, 0x59, 0xC0, 0xE8, + 0xC6, 0x39, 0xA8, 0x6B, 0x86, 0xA2, 0x00, 0x18, + 0x77, 0xC3, 0x5E, 0xB3, 0x71, 0xF2, 0x42, 0xE9 + }, + { + 0xD5, 0xB8, 0x64, 0x3B, 0x46, 0x14, 0x24, 0xC8, + 0x86, 0x19, 0xDE, 0x7F, 0x2B, 0xA7, 0x18, 0xFA, + 0xC7, 0x3B, 0x96, 0xF4, 0x9D, 0xAF, 0x93, 0x4F, + 0x57, 0x89, 0x17, 0x8E, 0xF8, 0xF1, 0x8B, 0x46, + 0x18, 0xBE, 0xA3, 0xA6, 0xBE, 0x1D, 0x0A, 0xE0, + 0x00, 0xD4, 0x6D, 0xE6, 0xE5, 0xA0, 0xAE, 0x78, + 0xF5, 0x4A, 0x31, 0x2C, 0x1A, 0xA1, 0x44, 0xA3, + 0x89, 0xC1, 0x1E, 0xB7, 0xCC, 0x9C, 0xAB, 0x6E + }, + { + 0x89, 0x96, 0x99, 0x0B, 0x9D, 0x6B, 0xF8, 0x79, + 0xC8, 0x09, 0x5B, 0xEC, 0xF9, 0x4D, 0x37, 0xE7, + 0x12, 0x81, 0xF8, 0x87, 0x98, 0x12, 0xED, 0xD0, + 0x26, 0xA9, 0x32, 0xBB, 0xF7, 0x1A, 0x8A, 0xD5, + 0xB3, 0xE5, 0x78, 0xE0, 0x66, 0x1B, 0xAE, 0x17, + 0xE5, 0x9D, 0x6C, 0x80, 0x7E, 0x4E, 0x79, 0x1D, + 0x6A, 0x52, 0x1A, 0x9B, 0x3F, 0xCA, 0x97, 0x5E, + 0x59, 0x70, 0x42, 0xA3, 0x73, 0x47, 0x28, 0xAF + }, + { + 0x30, 0xC0, 0x1D, 0x59, 0xFC, 0x19, 0xCA, 0xE0, + 0x31, 0x0C, 0x5C, 0x2D, 0x02, 0x69, 0x73, 0x09, + 0xD6, 0x13, 0xD9, 0xEC, 0x91, 0xBC, 0x02, 0x43, + 0xB9, 0x54, 0xEC, 0x95, 0xA4, 0xBD, 0x60, 0xD1, + 0x9F, 0x5F, 0x99, 0x1F, 0xD6, 0x70, 0x4C, 0x5D, + 0x45, 0x68, 0x7C, 0x9C, 0xB5, 0x2F, 0xE1, 0x8F, + 0x29, 0x2E, 0x6E, 0x9E, 0xC1, 0xA8, 0x29, 0xA3, + 0xB0, 0x16, 0x60, 0x08, 0xED, 0x5E, 0x4D, 0xFD + }, + { + 0x80, 0x2E, 0x27, 0x57, 0xC8, 0xF3, 0x32, 0x5B, + 0x74, 0xED, 0x71, 0xF3, 0x5C, 0x9F, 0xBD, 0xE2, + 0x42, 0x0E, 0xCA, 0x2F, 0x85, 0x70, 0x46, 0x3D, + 0x16, 0x75, 0x85, 0xDE, 0x14, 0x4B, 0x67, 0x0B, + 0x0A, 0xE2, 0xF9, 0x9A, 0x7E, 0x07, 0xB0, 0xC2, + 0xB9, 0xA5, 0xEF, 0x89, 0xF5, 0x1F, 0xC2, 0x5A, + 0x8C, 0x62, 0x77, 0x9F, 0x41, 0xC2, 0xB9, 0x70, + 0x11, 0x6C, 0x04, 0xD0, 0xA2, 0xD6, 0x75, 0x15 + }, + { + 0x57, 0x83, 0x2F, 0x38, 0xF8, 0x5F, 0x81, 0xC8, + 0xF3, 0x31, 0x29, 0xB2, 0x24, 0x4E, 0x58, 0xA7, + 0x86, 0xA5, 0xDA, 0xF9, 0x4A, 0xF5, 0x39, 0xCB, + 0xF0, 0x75, 0xC4, 0x0C, 0xF6, 0xA2, 0x05, 0x4C, + 0xD2, 0x71, 0xBF, 0x7B, 0x36, 0x31, 0xE3, 0xC5, + 0x47, 0xC5, 0xCB, 0xAC, 0x0B, 0x7D, 0x89, 0x0F, + 0x2B, 0xAE, 0x82, 0xB6, 0x50, 0x94, 0x4D, 0x93, + 0xFD, 0x6C, 0xAA, 0x64, 0x69, 0xBA, 0x8F, 0xA5 + }, + { + 0x66, 0xD2, 0x41, 0x66, 0x57, 0xD8, 0x54, 0x8B, + 0xD9, 0x84, 0x16, 0xD2, 0x7A, 0x08, 0x28, 0x3E, + 0x0D, 0x26, 0xC4, 0x6F, 0x9B, 0xB6, 0x0A, 0x47, + 0x60, 0x06, 0x1C, 0x08, 0xF5, 0xC7, 0xE5, 0x4B, + 0x29, 0x90, 0x9E, 0xFE, 0x39, 0x9C, 0x3C, 0xE9, + 0x5D, 0x75, 0xB0, 0x64, 0x3A, 0xA6, 0x7D, 0x38, + 0xB7, 0x8C, 0xAD, 0xD3, 0xD6, 0x8F, 0x97, 0x56, + 0xC1, 0x7A, 0xBE, 0xF3, 0x68, 0x1B, 0x3A, 0x53 + }, + { + 0xA5, 0x06, 0xBF, 0x4D, 0xE7, 0xE0, 0xDE, 0x01, + 0x9F, 0x73, 0xA3, 0x93, 0x09, 0xB1, 0x03, 0x6A, + 0xC2, 0xE5, 0xAC, 0xDF, 0x22, 0x10, 0x6D, 0xA5, + 0xC3, 0x6C, 0x96, 0x7F, 0xD0, 0x4F, 0x0F, 0xB4, + 0x18, 0x4B, 0xC2, 0x37, 0x21, 0x53, 0xEF, 0xEA, + 0xCF, 0x4D, 0xED, 0x39, 0x7C, 0x7B, 0xB4, 0xDE, + 0xC6, 0x3E, 0x3D, 0x18, 0x86, 0x6C, 0x4B, 0xEA, + 0xE3, 0x90, 0x2B, 0x2E, 0xFE, 0xC5, 0x63, 0xE1 + }, + { + 0xB4, 0x6D, 0x4D, 0xB2, 0x69, 0x86, 0x10, 0x4B, + 0xB3, 0x86, 0x94, 0xAA, 0x98, 0x3B, 0x54, 0x64, + 0x37, 0x73, 0xAF, 0xD4, 0xC1, 0x07, 0xA0, 0x2E, + 0xB7, 0x8E, 0x6C, 0x89, 0x45, 0xB2, 0xAA, 0xA8, + 0x39, 0x71, 0xE4, 0xFA, 0x5B, 0xC4, 0x4E, 0x09, + 0x54, 0x64, 0xAB, 0x4D, 0x4E, 0x69, 0x6A, 0x32, + 0x6C, 0x04, 0x59, 0xD6, 0x97, 0xD6, 0x84, 0x6F, + 0xEE, 0x80, 0x53, 0x3B, 0x09, 0x86, 0x8B, 0xC9 + }, + { + 0x81, 0x79, 0xE3, 0xFD, 0xCD, 0xDA, 0x84, 0xF1, + 0x86, 0x21, 0x53, 0xD1, 0x73, 0x8B, 0x44, 0xB0, + 0x02, 0xD3, 0xCF, 0xE8, 0x39, 0x94, 0x8A, 0x53, + 0x1C, 0x76, 0x80, 0x6F, 0xA1, 0x12, 0xDE, 0x12, + 0x88, 0x4C, 0x7A, 0x48, 0xB0, 0x3B, 0xCB, 0xA5, + 0xCE, 0xF8, 0xE4, 0xD7, 0xAA, 0x6F, 0x81, 0x75, + 0x19, 0x34, 0xF6, 0xE5, 0xCC, 0xB0, 0x65, 0x0A, + 0x92, 0x8C, 0xE7, 0x34, 0x8B, 0x18, 0x20, 0x1D + }, + { + 0x63, 0x3A, 0x71, 0x2D, 0x4D, 0x6B, 0x45, 0x9B, + 0x53, 0x69, 0x85, 0xA9, 0x97, 0x22, 0xA7, 0x3C, + 0xFC, 0xAA, 0xA2, 0x55, 0xE6, 0x13, 0xC3, 0x40, + 0xC1, 0x92, 0x89, 0xF3, 0x1A, 0xF2, 0x34, 0x29, + 0x61, 0x0F, 0x7D, 0xC8, 0xB0, 0x1E, 0x9B, 0x85, + 0xF1, 0x4E, 0x00, 0xC5, 0x4D, 0x85, 0x52, 0x14, + 0x02, 0x51, 0x75, 0x4B, 0xD0, 0x28, 0x14, 0x24, + 0x32, 0xAC, 0xB4, 0x8D, 0xE3, 0x4D, 0x49, 0x1F + }, + { + 0x8F, 0x58, 0x48, 0x66, 0xA0, 0xE1, 0x32, 0x7D, + 0x48, 0x8D, 0x25, 0xCB, 0x64, 0x04, 0x50, 0x94, + 0xD9, 0xD4, 0xAE, 0x26, 0xF3, 0xC9, 0x37, 0x39, + 0x6E, 0x29, 0xE3, 0xE9, 0x8D, 0xE0, 0x06, 0x1C, + 0xC9, 0xAE, 0x15, 0xEE, 0xE4, 0x21, 0xFE, 0x46, + 0xBA, 0xF8, 0xCB, 0xA1, 0xD8, 0x4D, 0xD8, 0x84, + 0xAC, 0xEB, 0x3B, 0xC9, 0x9B, 0x5B, 0x58, 0xCA, + 0xC4, 0x99, 0x25, 0x24, 0x00, 0x4A, 0xFD, 0x1C + }, + { + 0xCE, 0x85, 0xCE, 0xAD, 0xFB, 0xA6, 0x3B, 0x2D, + 0x1E, 0xE6, 0x5B, 0x49, 0x7B, 0x4C, 0xC5, 0xB3, + 0x93, 0x8F, 0x46, 0xAD, 0x89, 0x28, 0x73, 0x6F, + 0x71, 0x11, 0x0F, 0xE5, 0x73, 0x8F, 0x07, 0xAF, + 0xAD, 0x92, 0xEF, 0x70, 0xAA, 0x81, 0xDC, 0x00, + 0xE6, 0x2D, 0xB3, 0xCE, 0xFE, 0x31, 0x13, 0x66, + 0xCC, 0x9C, 0x4F, 0x04, 0xBE, 0xE0, 0xAD, 0x85, + 0x09, 0xB0, 0x63, 0x0B, 0xA1, 0x91, 0x0F, 0x3A + }, + { + 0x5C, 0x9D, 0x2B, 0xE0, 0xCF, 0xA1, 0xAE, 0x99, + 0x86, 0x04, 0x6B, 0x1C, 0x08, 0xE1, 0xA3, 0x64, + 0x56, 0x77, 0x61, 0x25, 0x7E, 0xBA, 0x0C, 0xE3, + 0x2A, 0x93, 0x95, 0x9E, 0x97, 0xAF, 0x5A, 0x2F, + 0x5D, 0x9A, 0xA3, 0xCC, 0x5C, 0x35, 0xA0, 0xCC, + 0x0F, 0xA0, 0x37, 0xB7, 0xB2, 0x0A, 0x3D, 0x0A, + 0x22, 0x90, 0xE0, 0x70, 0xAE, 0x08, 0x1F, 0xB8, + 0x9A, 0xB0, 0x0C, 0x9B, 0xBE, 0x85, 0xE1, 0x74 + }, + { + 0x71, 0x7B, 0x11, 0x1C, 0x89, 0x38, 0x57, 0xBA, + 0xC1, 0xC8, 0x5B, 0x7E, 0xE0, 0xF6, 0xEF, 0x11, + 0x37, 0x14, 0xEB, 0x7B, 0x71, 0xFF, 0x7F, 0x0A, + 0xF7, 0xCF, 0x3F, 0x21, 0x47, 0x1C, 0x1D, 0xE2, + 0x3B, 0xE8, 0xB6, 0x0E, 0x7C, 0xC2, 0x4A, 0x33, + 0x92, 0x01, 0x45, 0xAC, 0xD1, 0x9B, 0x29, 0x97, + 0x2A, 0xFF, 0x5E, 0x23, 0x5F, 0xCA, 0xC2, 0x62, + 0xBA, 0xA6, 0x45, 0xD4, 0xE1, 0x46, 0xA7, 0xC4 + }, + { + 0x93, 0x03, 0xE6, 0xF4, 0xC3, 0x32, 0x55, 0x1C, + 0xA6, 0x57, 0xB9, 0xEC, 0xCF, 0xAB, 0x3A, 0xB6, + 0x76, 0xF3, 0x49, 0x86, 0x9D, 0xA2, 0xE9, 0xCF, + 0xF3, 0xEB, 0x02, 0x12, 0x02, 0xE9, 0x24, 0x04, + 0xD2, 0x10, 0xE6, 0x58, 0x6F, 0x59, 0xB6, 0xEF, + 0x4F, 0x14, 0x03, 0x80, 0x49, 0xC3, 0xCA, 0xE8, + 0xFD, 0xE0, 0x06, 0xE2, 0xE1, 0x66, 0x15, 0xD1, + 0x4E, 0xB2, 0x8C, 0xC2, 0x82, 0xDB, 0xC3, 0xA8 + }, + { + 0x80, 0xAA, 0xE9, 0xA0, 0x0C, 0xAD, 0x0D, 0xF5, + 0x8F, 0x89, 0xD8, 0xAE, 0xEA, 0x24, 0x89, 0x6B, + 0x38, 0x0E, 0x53, 0x5A, 0x77, 0xB8, 0xBD, 0x4D, + 0x67, 0x4A, 0x8B, 0xF5, 0xCF, 0x8D, 0x3A, 0xFF, + 0x50, 0xF8, 0x7B, 0x91, 0xA7, 0xF6, 0x2B, 0xFC, + 0xF3, 0xBD, 0x44, 0x79, 0xEA, 0xDC, 0xE5, 0x88, + 0x4D, 0x9D, 0xB5, 0x13, 0xB6, 0xC7, 0x1B, 0x09, + 0x22, 0x1A, 0xAD, 0x88, 0xE1, 0xA7, 0xBB, 0x17 + }, + { + 0xB7, 0x39, 0x04, 0xA1, 0x3C, 0xBD, 0xA4, 0xA8, + 0xD0, 0x06, 0x68, 0xBA, 0x08, 0x0D, 0x1F, 0x8D, + 0x84, 0x4D, 0x37, 0x10, 0x84, 0xD4, 0xCE, 0x68, + 0x04, 0xD3, 0x33, 0x93, 0x00, 0x2F, 0x61, 0x21, + 0x19, 0x5D, 0x91, 0x56, 0x46, 0x89, 0xF1, 0x23, + 0x26, 0x34, 0xE9, 0x34, 0x6A, 0x46, 0xA7, 0x4C, + 0x55, 0x9E, 0x5B, 0xFD, 0xA2, 0x94, 0x5A, 0x4E, + 0x3B, 0xE1, 0x51, 0x28, 0x4E, 0xD4, 0x74, 0x1D + }, + { + 0xE9, 0x62, 0xBB, 0x69, 0x72, 0xD2, 0x5E, 0xB8, + 0xC9, 0xAA, 0xFA, 0x8C, 0xA0, 0x80, 0xBE, 0x1D, + 0xEC, 0x3C, 0x4B, 0x3F, 0xA6, 0x6A, 0xF8, 0x4B, + 0x0A, 0x6C, 0x64, 0xBE, 0x87, 0xDE, 0x1B, 0xD9, + 0xAB, 0x08, 0x7D, 0x9B, 0xDD, 0xD5, 0x5F, 0xE7, + 0xDA, 0x75, 0x42, 0x58, 0x8B, 0x0E, 0xB7, 0x93, + 0x7A, 0x8D, 0xB7, 0x73, 0x31, 0x46, 0x97, 0xDC, + 0xCF, 0xAF, 0x0B, 0x3C, 0xA9, 0x16, 0x44, 0xEC + }, + { + 0xA6, 0xD2, 0x52, 0x82, 0x19, 0xB8, 0x5B, 0x32, + 0xA0, 0x53, 0x34, 0xB3, 0xAD, 0x17, 0x2B, 0xEB, + 0x0B, 0xC5, 0x3F, 0xE5, 0xB3, 0x07, 0x25, 0x3D, + 0xCF, 0x2A, 0x12, 0x89, 0x9A, 0x56, 0x59, 0xD3, + 0x8F, 0xA1, 0xE7, 0x79, 0x48, 0x99, 0x8D, 0x41, + 0xA3, 0x9F, 0xE5, 0xC0, 0x49, 0x8E, 0x97, 0x02, + 0x8F, 0x97, 0x23, 0x74, 0x61, 0xA5, 0x87, 0x17, + 0x89, 0x8B, 0xCA, 0x4D, 0x31, 0xD8, 0xFF, 0x65 + }, + { + 0xBD, 0x07, 0xB9, 0x70, 0x9B, 0xC5, 0xDF, 0xCA, + 0x70, 0x63, 0xA4, 0x22, 0xCA, 0x56, 0xC2, 0x3D, + 0xE7, 0xC3, 0xD3, 0xF3, 0x46, 0x63, 0xDA, 0xB7, + 0xEF, 0x43, 0x75, 0x5B, 0xA6, 0xE2, 0xD5, 0x7B, + 0x46, 0x15, 0xD7, 0x36, 0xE0, 0x4C, 0x94, 0x13, + 0xFF, 0x53, 0xBC, 0xE9, 0xE4, 0x1E, 0x72, 0x52, + 0x52, 0xEC, 0xE5, 0xC4, 0x02, 0xFF, 0xA4, 0x5A, + 0x4F, 0x62, 0x74, 0xD4, 0xBD, 0x29, 0x8C, 0x93 + }, + { + 0xD1, 0x52, 0x66, 0x79, 0x64, 0x62, 0x8E, 0x40, + 0x4B, 0x82, 0x07, 0x64, 0x4D, 0xEB, 0xDE, 0x2D, + 0x2E, 0x13, 0xF6, 0x86, 0xE5, 0xDE, 0x87, 0x9B, + 0x09, 0x73, 0x2C, 0x32, 0xC5, 0x9B, 0xD2, 0xBA, + 0x3A, 0x75, 0xA9, 0xC5, 0xDF, 0xB9, 0xFD, 0x2D, + 0x81, 0xC1, 0xFF, 0x6E, 0xF6, 0xA8, 0x25, 0xD1, + 0x6C, 0xCF, 0xE9, 0x6B, 0x49, 0x9B, 0x41, 0x4F, + 0x29, 0xBD, 0x0A, 0x9E, 0x9F, 0x52, 0x33, 0xE0 + }, + { + 0xB2, 0xC3, 0x73, 0x62, 0x3E, 0x21, 0x91, 0xB8, + 0xA8, 0x10, 0x79, 0xA0, 0x85, 0xE2, 0x8E, 0xE4, + 0xAE, 0x13, 0xCF, 0x5B, 0x8F, 0x8A, 0x7B, 0xF4, + 0x51, 0xF8, 0xA8, 0x9F, 0xCD, 0x08, 0xA3, 0x2F, + 0x81, 0xF1, 0x49, 0x58, 0xE2, 0x8A, 0x41, 0xB0, + 0xFE, 0x5D, 0x5A, 0x36, 0x82, 0xAA, 0x51, 0x95, + 0xFB, 0xF8, 0xEC, 0x24, 0xBD, 0xB6, 0x5B, 0xB8, + 0x68, 0xAF, 0xC6, 0x2E, 0xAD, 0xAA, 0x38, 0x6D + }, + { + 0x15, 0x38, 0xB6, 0xD5, 0x4D, 0xA4, 0x2D, 0xE6, + 0xBE, 0x39, 0x32, 0x35, 0x92, 0x48, 0xFA, 0xE4, + 0xC3, 0x3B, 0xBF, 0xED, 0x49, 0xA9, 0x55, 0x42, + 0x41, 0x04, 0xCF, 0x3F, 0x52, 0x71, 0xF5, 0x4C, + 0x0C, 0x86, 0x50, 0x45, 0x87, 0x67, 0x23, 0xBC, + 0x0A, 0x16, 0x97, 0x2D, 0x1A, 0xDA, 0x96, 0x1B, + 0xC9, 0xF7, 0x52, 0x51, 0xBA, 0x30, 0x51, 0x4D, + 0x7D, 0xE1, 0x2D, 0x9F, 0x25, 0x57, 0x62, 0x54 + }, + { + 0xA6, 0x65, 0xF5, 0x78, 0x46, 0x73, 0x06, 0x65, + 0xD4, 0xF8, 0x47, 0x8E, 0x5F, 0x1B, 0x52, 0x03, + 0x69, 0x18, 0xE0, 0xBC, 0xD7, 0xAC, 0xDD, 0xAD, + 0x57, 0x0B, 0x6E, 0x5C, 0x89, 0xD6, 0x0A, 0x21, + 0x83, 0x28, 0x59, 0xB9, 0xF9, 0xF0, 0x49, 0xA4, + 0x50, 0xD1, 0x51, 0x81, 0x2D, 0x89, 0xBC, 0x94, + 0x11, 0x5E, 0x75, 0x0D, 0xCA, 0x41, 0x00, 0x64, + 0x5F, 0xA5, 0x19, 0x82, 0x0E, 0xF6, 0x2D, 0xC1 + }, + { + 0xDE, 0x16, 0xAA, 0x1F, 0x66, 0x00, 0x39, 0xAC, + 0xD7, 0xFA, 0x38, 0x4F, 0x10, 0xA7, 0xEF, 0x34, + 0x7C, 0x05, 0x6C, 0x81, 0x92, 0xCB, 0x4F, 0xB1, + 0x19, 0x0B, 0x79, 0x7D, 0xC6, 0x86, 0x68, 0x74, + 0x6E, 0x8B, 0x2F, 0xA7, 0x76, 0x1D, 0x5C, 0x40, + 0x02, 0xFA, 0xDE, 0x55, 0x84, 0x97, 0x99, 0xA3, + 0x78, 0x4A, 0xB3, 0xA3, 0x47, 0x9E, 0x2C, 0xC1, + 0x0D, 0x2D, 0xAA, 0x7E, 0x73, 0x9D, 0xF8, 0x43 + }, + { + 0x07, 0x10, 0x8E, 0x6C, 0xDC, 0x51, 0x1E, 0x83, + 0x56, 0x53, 0x2E, 0x16, 0x00, 0xBF, 0xD7, 0x67, + 0x13, 0x44, 0xE6, 0xF6, 0x4A, 0x68, 0xFE, 0xBF, + 0xC6, 0x33, 0xEF, 0x50, 0xF5, 0xD9, 0x83, 0x36, + 0x72, 0x6C, 0x6A, 0x6B, 0x56, 0x35, 0x54, 0x1C, + 0x0B, 0x3F, 0xDF, 0xD7, 0x4D, 0x25, 0x12, 0x88, + 0x62, 0xFF, 0xD4, 0x4B, 0x8F, 0x61, 0xDD, 0x42, + 0xE3, 0x8B, 0xB2, 0x54, 0xF4, 0x65, 0x22, 0x36 + }, + { + 0x77, 0xD6, 0xE2, 0x51, 0x07, 0x55, 0xB7, 0x53, + 0x35, 0x57, 0x3B, 0x7A, 0x29, 0x98, 0x05, 0x15, + 0xB0, 0x41, 0xC0, 0x4B, 0x06, 0xFD, 0x38, 0x40, + 0xBB, 0xA2, 0xE5, 0x12, 0xF2, 0x4B, 0xE8, 0x6A, + 0x2A, 0xFD, 0x78, 0x40, 0xB4, 0x69, 0x3E, 0x92, + 0x43, 0x8B, 0xD7, 0xA7, 0x2A, 0x75, 0x79, 0x26, + 0x42, 0x10, 0x94, 0x18, 0x7B, 0x23, 0x87, 0xEB, + 0xDA, 0x54, 0x57, 0xAA, 0x8A, 0xE7, 0x17, 0xAB + }, + { + 0x54, 0x8B, 0xB3, 0xE7, 0xD3, 0x56, 0x78, 0xC5, + 0x64, 0x33, 0x2B, 0x4D, 0xA1, 0x28, 0xD6, 0x8E, + 0x46, 0xA9, 0xEE, 0x70, 0x03, 0x0F, 0xE9, 0x75, + 0xAE, 0xC4, 0x80, 0x47, 0xB7, 0x1A, 0x16, 0xB7, + 0x1D, 0xBC, 0x91, 0x29, 0x2E, 0x3A, 0x53, 0xAB, + 0x2D, 0xEF, 0xF7, 0x9E, 0xD7, 0xDB, 0x71, 0x55, + 0x0A, 0x6F, 0x5D, 0x1D, 0x7E, 0x52, 0x4C, 0xA0, + 0x74, 0xFD, 0xFD, 0x28, 0xE4, 0xD8, 0x64, 0xAC + }, + { + 0x8C, 0xBC, 0x40, 0x72, 0x0D, 0x5B, 0x62, 0x9C, + 0xAE, 0x5F, 0xB9, 0xC7, 0x5B, 0x7E, 0xD9, 0xCF, + 0x47, 0x42, 0xCB, 0xB2, 0x06, 0x14, 0x7A, 0x96, + 0x87, 0x14, 0x1C, 0x55, 0xF1, 0x78, 0x3A, 0xAA, + 0xD2, 0x59, 0xF6, 0xF8, 0x34, 0x51, 0x26, 0x85, + 0x02, 0xAE, 0x15, 0x15, 0x38, 0x2B, 0x22, 0x34, + 0x12, 0xAF, 0x4B, 0xBA, 0x76, 0xAB, 0x21, 0x51, + 0x64, 0xF7, 0x4A, 0x8C, 0xF8, 0xF6, 0x13, 0x12 + }, + { + 0x42, 0x63, 0x77, 0xC1, 0x73, 0x96, 0x1D, 0x16, + 0x90, 0xB9, 0x65, 0xBF, 0xCE, 0x93, 0x7B, 0x2A, + 0xF4, 0x4F, 0x70, 0xB5, 0x8C, 0x11, 0x14, 0x47, + 0x79, 0xE9, 0x3D, 0xA3, 0x1F, 0xCC, 0xD4, 0x1A, + 0xDA, 0x4A, 0xC2, 0xAE, 0x32, 0x4B, 0x55, 0x1B, + 0x3C, 0x0C, 0x2F, 0xB1, 0xF0, 0x96, 0x46, 0x92, + 0x1D, 0xFB, 0xB6, 0x9D, 0x3E, 0xFF, 0x8F, 0x87, + 0x02, 0xAF, 0xB8, 0x49, 0xD4, 0x68, 0x1A, 0x42 + }, + { + 0x23, 0x83, 0xC7, 0x9B, 0x79, 0x39, 0x69, 0x82, + 0xEC, 0xEC, 0x72, 0x68, 0xE3, 0x0E, 0xD2, 0xA2, + 0x1F, 0x6A, 0x5C, 0xBF, 0x60, 0x05, 0x43, 0x72, + 0x5A, 0x7C, 0xDC, 0xD5, 0x05, 0xBC, 0xAB, 0xD3, + 0xD8, 0xA8, 0xCC, 0xD2, 0x06, 0x6B, 0xAA, 0x6D, + 0xA5, 0x77, 0xD8, 0xD6, 0x71, 0xC7, 0x59, 0xC2, + 0xDF, 0x9E, 0xF3, 0xA8, 0x76, 0x9A, 0x88, 0xF5, + 0xF4, 0xA9, 0xC9, 0xBD, 0x84, 0xEA, 0xD2, 0x06 + }, + { + 0xB5, 0xA3, 0xD0, 0xAF, 0xBC, 0x70, 0xDF, 0x0D, + 0xA1, 0xA3, 0x94, 0xBD, 0x02, 0x3D, 0xDF, 0x49, + 0xF5, 0x47, 0x54, 0x09, 0x93, 0x54, 0x5B, 0xED, + 0x6C, 0xE6, 0xE3, 0x74, 0x2C, 0x5E, 0x72, 0xB2, + 0x54, 0xAB, 0x45, 0x20, 0xA5, 0x74, 0x4E, 0xA3, + 0xD2, 0x35, 0x11, 0x98, 0xE1, 0x57, 0xE2, 0xB5, + 0x72, 0x72, 0xF8, 0x9D, 0x39, 0x8A, 0x22, 0xAA, + 0x9F, 0x93, 0x84, 0x68, 0x44, 0x6B, 0xEA, 0x17 + }, + { + 0xCA, 0x4B, 0x98, 0x16, 0x82, 0x3A, 0xF0, 0x74, + 0x72, 0x42, 0x51, 0x5A, 0xDB, 0x96, 0x4D, 0x4C, + 0x15, 0x74, 0xD5, 0x57, 0xDB, 0x2E, 0x46, 0x4C, + 0xB7, 0xF9, 0x1E, 0x21, 0x70, 0xF2, 0x70, 0xAB, + 0x27, 0x8F, 0x51, 0xA4, 0xA5, 0x75, 0x8B, 0xFC, + 0x16, 0xE4, 0xAC, 0xBE, 0xDC, 0x73, 0x60, 0x83, + 0x1A, 0xD6, 0x0C, 0xED, 0x71, 0x01, 0xBD, 0xC0, + 0xA3, 0xCE, 0xA2, 0x6E, 0xB3, 0x11, 0x43, 0x27 + }, + { + 0x5F, 0xA4, 0xFF, 0x34, 0x42, 0x7E, 0x1B, 0x09, + 0x77, 0x4B, 0x6B, 0xA5, 0x02, 0x45, 0xF9, 0x56, + 0xD4, 0x20, 0x35, 0x8B, 0xA8, 0xFD, 0xB9, 0x73, + 0x0B, 0x78, 0x61, 0xA2, 0x4C, 0x3D, 0x6D, 0xC5, + 0x12, 0x7A, 0x6D, 0x45, 0x78, 0xE4, 0x7F, 0xCB, + 0xFE, 0x84, 0xBB, 0xEF, 0x93, 0x71, 0x25, 0x79, + 0xCF, 0x7D, 0xBC, 0x78, 0x39, 0x18, 0x12, 0x21, + 0x8D, 0x88, 0xEE, 0x52, 0x9E, 0xEF, 0x38, 0xB3 + }, + { + 0x15, 0x3A, 0xE1, 0x9F, 0xB0, 0x11, 0x9C, 0xF9, + 0xE2, 0x90, 0xD3, 0xAD, 0x26, 0xBC, 0xEE, 0x3B, + 0x04, 0xB7, 0x94, 0x86, 0x91, 0x01, 0x64, 0x8E, + 0x8D, 0x7E, 0xDC, 0x93, 0x45, 0x69, 0x94, 0x77, + 0xA7, 0xD8, 0x06, 0xEA, 0x0D, 0x5C, 0x41, 0xEA, + 0xD4, 0x39, 0x6E, 0xF2, 0xD5, 0x7D, 0xF8, 0x47, + 0x5B, 0xFA, 0xB8, 0x0B, 0xE3, 0x12, 0xF4, 0x95, + 0xCB, 0x4F, 0x1A, 0x9F, 0x45, 0xA7, 0x4E, 0xB4 + }, + { + 0x91, 0x71, 0xA5, 0xC5, 0x48, 0x67, 0xA3, 0xAE, + 0xD2, 0xBC, 0x9D, 0xDA, 0x90, 0x43, 0x55, 0x46, + 0x1A, 0xD7, 0xF6, 0x82, 0xC3, 0xE9, 0x7C, 0x5B, + 0xBD, 0xF2, 0xDE, 0x2D, 0xF2, 0x32, 0x34, 0xE5, + 0x25, 0x97, 0x2C, 0x4B, 0x85, 0xD8, 0xD9, 0xB1, + 0x76, 0xDE, 0x88, 0x2F, 0x6F, 0xCF, 0x14, 0xD3, + 0x65, 0x2F, 0xAE, 0x4A, 0x8E, 0x06, 0x3B, 0x75, + 0x0E, 0x90, 0xF1, 0x0E, 0xBB, 0xB7, 0x4A, 0xCB + }, + { + 0x81, 0x56, 0x84, 0xBF, 0x6B, 0x93, 0x7C, 0x62, + 0x65, 0x83, 0x6D, 0x53, 0x39, 0xC7, 0x9A, 0xC5, + 0x0B, 0xEA, 0xBD, 0xBD, 0xDD, 0x11, 0x62, 0xD1, + 0xD8, 0x16, 0x58, 0xA0, 0x91, 0x64, 0x6A, 0xBB, + 0xA3, 0x6F, 0x61, 0x6E, 0xAB, 0x3C, 0x5D, 0xAD, + 0x58, 0x02, 0xEF, 0x97, 0xC4, 0x55, 0x61, 0xDC, + 0xC4, 0xDB, 0x26, 0x14, 0x56, 0x38, 0x93, 0x1B, + 0xF2, 0x51, 0x78, 0x37, 0x43, 0xCE, 0xE5, 0x09 + }, + { + 0xDB, 0x01, 0xCF, 0xCC, 0x00, 0x63, 0x8B, 0xEB, + 0x8E, 0xFC, 0x9B, 0xB8, 0xCF, 0x41, 0xFE, 0x2C, + 0x86, 0x3E, 0x01, 0xE9, 0x6E, 0x2B, 0x65, 0xE4, + 0xB3, 0x60, 0xB6, 0xAD, 0x69, 0x88, 0x6F, 0xD8, + 0x55, 0x17, 0x9D, 0x0D, 0xEC, 0x16, 0x9B, 0x2E, + 0xB4, 0x61, 0x6C, 0xF3, 0x27, 0xB0, 0x45, 0x32, + 0x29, 0xBE, 0x63, 0xA6, 0x8B, 0xEF, 0x48, 0x3B, + 0xEA, 0x94, 0x1C, 0x6B, 0xE9, 0xEC, 0x22, 0x9C + }, + { + 0xDC, 0x21, 0xD1, 0x78, 0x80, 0x29, 0xDA, 0xE0, + 0x8B, 0xA8, 0xE8, 0x5F, 0x88, 0xD1, 0x12, 0x40, + 0x36, 0x35, 0xB1, 0xCF, 0xC7, 0xEA, 0xF9, 0x90, + 0x69, 0x6B, 0xF9, 0x27, 0xBC, 0xC2, 0x4C, 0x64, + 0x8A, 0x00, 0xDC, 0xBF, 0x87, 0x1B, 0x02, 0xD8, + 0x5D, 0x0B, 0xE5, 0x03, 0xD6, 0xE0, 0x2B, 0x7B, + 0x14, 0x25, 0x97, 0xF2, 0xFB, 0xB6, 0xFA, 0xF7, + 0x56, 0xDD, 0xC2, 0xCE, 0x13, 0x76, 0xAD, 0x39 + }, + { + 0x62, 0x13, 0x88, 0xED, 0xE1, 0x42, 0xA6, 0x03, + 0x2E, 0x7D, 0xF8, 0x94, 0x9A, 0xF8, 0xAE, 0x48, + 0x22, 0xC6, 0x2D, 0xDB, 0x94, 0xFF, 0x00, 0x37, + 0xCB, 0x8C, 0x51, 0x02, 0xFC, 0x3E, 0x1A, 0xD4, + 0x10, 0x9D, 0x8D, 0xC8, 0xE0, 0x8E, 0x69, 0xCC, + 0xA2, 0x17, 0x4C, 0x31, 0xCF, 0x94, 0xF8, 0x4A, + 0x41, 0x2D, 0x45, 0xFC, 0xDA, 0x08, 0xA4, 0x6B, + 0x31, 0x48, 0x55, 0xFA, 0xC6, 0xB9, 0x1E, 0xD1 + }, + { + 0xB1, 0xE2, 0xE2, 0x06, 0xCF, 0xB1, 0xE9, 0x59, + 0xF0, 0x91, 0x76, 0xA5, 0x59, 0x18, 0x13, 0xB8, + 0x05, 0xBF, 0x90, 0x54, 0xDD, 0xE8, 0x3D, 0x95, + 0x3E, 0x02, 0x0C, 0x8A, 0x0E, 0x42, 0xB1, 0x8E, + 0x63, 0xFD, 0x82, 0x66, 0x96, 0xEF, 0x07, 0xB4, + 0x78, 0x8E, 0x86, 0x4F, 0x7D, 0x8F, 0x8D, 0xE5, + 0x85, 0x42, 0xEA, 0xA8, 0x3F, 0xE2, 0x0C, 0xB9, + 0x5E, 0x5E, 0x25, 0x06, 0xE0, 0x76, 0x30, 0x95 + }, + { + 0xDC, 0xA8, 0x2B, 0x64, 0xB3, 0xDD, 0x25, 0xCA, + 0x26, 0x19, 0x67, 0x2D, 0x6F, 0x24, 0xE8, 0xDB, + 0x6F, 0xEB, 0xC5, 0xDA, 0xA6, 0xF8, 0x7E, 0x8E, + 0xAC, 0xF4, 0x69, 0xC0, 0x20, 0xBA, 0x3C, 0xC9, + 0x8E, 0xAB, 0x2C, 0xCD, 0x35, 0xC2, 0xF6, 0x16, + 0x3F, 0x4F, 0x9A, 0x69, 0x9C, 0xBB, 0x46, 0xAB, + 0x35, 0xB5, 0xB3, 0x1F, 0x39, 0x30, 0xFC, 0xAC, + 0x46, 0x27, 0x92, 0x70, 0x6B, 0x4E, 0x28, 0x09 + }, + { + 0x5A, 0x0B, 0x8E, 0x82, 0x4C, 0xC7, 0x0D, 0x46, + 0x34, 0xE7, 0x4B, 0xD3, 0x4D, 0x8A, 0x3B, 0x86, + 0x37, 0x7A, 0x68, 0x44, 0x19, 0x5F, 0xE9, 0x24, + 0xB5, 0x4C, 0x67, 0x11, 0x50, 0xF1, 0x85, 0xE6, + 0xA0, 0x49, 0x47, 0x45, 0x11, 0x58, 0xF1, 0x3A, + 0x8C, 0x54, 0xD6, 0x6B, 0x4D, 0x3A, 0x48, 0xF5, + 0xC3, 0xAC, 0xE5, 0xDF, 0xB3, 0x49, 0xFA, 0x08, + 0x0E, 0xE1, 0x9F, 0xB5, 0x95, 0x45, 0x4D, 0x7F + }, + { + 0x83, 0xE4, 0xA0, 0x38, 0x0D, 0x53, 0xF3, 0x9F, + 0x3A, 0xA9, 0xDE, 0x99, 0x67, 0x36, 0xAE, 0x48, + 0x2D, 0xFB, 0x75, 0xE4, 0x9D, 0x5C, 0xD5, 0xEA, + 0x1A, 0xC3, 0xF5, 0x01, 0x15, 0xAC, 0xF5, 0xE3, + 0xDC, 0xCB, 0xC4, 0x26, 0x84, 0xE4, 0x5F, 0x32, + 0x50, 0x2E, 0x60, 0x70, 0x13, 0xC8, 0x81, 0x07, + 0x1C, 0x67, 0xFD, 0x49, 0xBF, 0xA3, 0x58, 0xA7, + 0xCF, 0xBA, 0x78, 0xAE, 0x9A, 0x64, 0x04, 0x31 + }, + { + 0x02, 0x4E, 0xAD, 0xEE, 0xFA, 0x7A, 0x61, 0x1A, + 0x79, 0x90, 0xAE, 0x58, 0x6B, 0x96, 0xCF, 0x71, + 0x45, 0x3E, 0x58, 0x59, 0xC0, 0x6A, 0x84, 0xBF, + 0xE8, 0x7A, 0x7D, 0x0B, 0x37, 0x5E, 0xA9, 0xF6, + 0xE7, 0x9D, 0xD6, 0xD0, 0x1B, 0xFF, 0xFB, 0x72, + 0x8A, 0xB9, 0x89, 0x36, 0x02, 0xB9, 0x5D, 0xE0, + 0xA2, 0xA4, 0xB6, 0x46, 0xE8, 0x75, 0x88, 0xD9, + 0xAA, 0x57, 0x1E, 0xF9, 0x34, 0xA4, 0x54, 0x8F + }, + { + 0x85, 0xF6, 0x98, 0x45, 0xBA, 0x2C, 0xDD, 0xDC, + 0x68, 0x7B, 0x8B, 0xEA, 0x29, 0x8C, 0x7A, 0x38, + 0x28, 0x38, 0xBB, 0x3C, 0xD4, 0xAC, 0x56, 0x1F, + 0xC0, 0xD9, 0x70, 0xB9, 0xF0, 0x3F, 0xC9, 0x5D, + 0x68, 0xC4, 0x43, 0x7A, 0xC9, 0xC6, 0x33, 0x12, + 0xD6, 0x8C, 0x05, 0x39, 0xBC, 0xC4, 0x8F, 0xEC, + 0x08, 0xD7, 0x23, 0x99, 0xBB, 0x83, 0x3A, 0xF7, + 0x19, 0x2B, 0xFD, 0xDD, 0xE2, 0x3F, 0xF1, 0xF7 + }, + { + 0x76, 0xE0, 0xE4, 0x01, 0x0B, 0x6F, 0xDE, 0x86, + 0x4E, 0xAA, 0x79, 0x4B, 0x2A, 0x02, 0xC3, 0x7F, + 0x3E, 0x91, 0x75, 0xD6, 0x72, 0x88, 0x11, 0x08, + 0x2F, 0x22, 0x98, 0xDE, 0xDB, 0xF5, 0xEE, 0x59, + 0xC5, 0xE2, 0x5B, 0x1D, 0xDB, 0x39, 0x7A, 0x34, + 0x50, 0x2A, 0xAA, 0xA1, 0x09, 0xDD, 0xB5, 0x0E, + 0x16, 0x2D, 0xD9, 0xCB, 0xC9, 0x83, 0xBD, 0x00, + 0x0A, 0x49, 0x31, 0x67, 0x87, 0xD0, 0x27, 0x4A + }, + { + 0xCA, 0xDE, 0x73, 0xD2, 0x5A, 0x95, 0x2F, 0x67, + 0x15, 0xA0, 0xB5, 0x7D, 0x16, 0xBE, 0x78, 0x7E, + 0x6A, 0x0A, 0x78, 0x5D, 0x46, 0xEE, 0xE0, 0xDB, + 0xF3, 0xBF, 0x4F, 0xDF, 0x1E, 0x7D, 0xF3, 0xB5, + 0x6F, 0xB6, 0x15, 0x02, 0xBF, 0xBF, 0xF5, 0x26, + 0x7A, 0xF7, 0x51, 0x18, 0x56, 0x02, 0xC2, 0xC2, + 0xEB, 0x89, 0x02, 0x37, 0x43, 0x30, 0x22, 0xCD, + 0x54, 0xC0, 0x4C, 0x52, 0xC2, 0xDD, 0x23, 0xF5 + }, + { + 0xA9, 0xF4, 0x4F, 0x3B, 0x7E, 0xDC, 0x02, 0x0E, + 0x84, 0x87, 0xC8, 0x2F, 0x14, 0xE4, 0xC1, 0xEA, + 0x55, 0x35, 0x5C, 0x93, 0xF3, 0xB0, 0x5E, 0x0E, + 0x41, 0xDE, 0x2E, 0x7A, 0x7F, 0xAC, 0x4E, 0xA8, + 0xE7, 0xC1, 0x34, 0xD7, 0xC1, 0xCD, 0x32, 0x52, + 0xBB, 0x33, 0xB6, 0xA4, 0x7A, 0x94, 0x46, 0xBE, + 0x9D, 0xAE, 0xF0, 0x3C, 0x2E, 0x82, 0x96, 0x1E, + 0x9F, 0x0B, 0x00, 0x1F, 0x71, 0x9E, 0xCB, 0xBD + }, + { + 0xAC, 0xF3, 0x36, 0x8A, 0x69, 0x45, 0xD2, 0x70, + 0x7F, 0x71, 0x7E, 0xA4, 0x05, 0x87, 0x58, 0xCA, + 0xEA, 0x23, 0x41, 0x37, 0x93, 0x5B, 0x28, 0x20, + 0xBA, 0xE7, 0x48, 0x2D, 0xE0, 0x30, 0xB4, 0xAC, + 0x66, 0xA7, 0x1E, 0x74, 0x83, 0xA9, 0x6A, 0xF9, + 0x3E, 0x24, 0xA5, 0xDC, 0x61, 0x60, 0x75, 0x3E, + 0x44, 0xEF, 0xBE, 0xB4, 0xC8, 0xAD, 0xDD, 0x9C, + 0x46, 0x16, 0xCA, 0x69, 0x14, 0x73, 0xCA, 0x2F + }, + { + 0x77, 0x7F, 0x9C, 0x4D, 0x68, 0xF1, 0xC2, 0xD7, + 0x29, 0x1A, 0x97, 0x43, 0xCE, 0x89, 0xC0, 0x70, + 0x89, 0xB2, 0x1C, 0xA6, 0x24, 0x83, 0xEB, 0x74, + 0xBE, 0x87, 0xFC, 0x53, 0xA7, 0x9A, 0x2A, 0x04, + 0x00, 0x09, 0x4D, 0x77, 0x88, 0x9D, 0x3B, 0xA5, + 0x9F, 0x5E, 0x06, 0x66, 0x6A, 0x55, 0x2A, 0x29, + 0xF8, 0xDB, 0xBB, 0xDF, 0x04, 0x76, 0xA9, 0xBD, + 0x7D, 0x38, 0x2B, 0x45, 0x3B, 0x66, 0xAD, 0x55 + }, + { + 0x01, 0x67, 0x11, 0xDE, 0xC1, 0x7D, 0xB2, 0x17, + 0x19, 0x8A, 0xAD, 0x2D, 0xA3, 0xC5, 0x57, 0xC8, + 0x23, 0x78, 0xFB, 0x16, 0x34, 0x72, 0x4C, 0xF0, + 0x9A, 0xDF, 0xCF, 0x86, 0x99, 0xC0, 0x0C, 0xD9, + 0xDA, 0x72, 0xAD, 0x8B, 0x3E, 0x0F, 0xE5, 0xBB, + 0x46, 0x54, 0x3B, 0x57, 0xB5, 0x29, 0xBC, 0xDB, + 0x8D, 0xBC, 0x12, 0x91, 0x70, 0xE8, 0xC7, 0x10, + 0x7E, 0xCB, 0x3E, 0x4D, 0x9F, 0xCD, 0xDD, 0x35 + }, + { + 0x89, 0x91, 0xB2, 0x69, 0x68, 0xCC, 0x8B, 0xF4, + 0x85, 0x68, 0x52, 0xEA, 0x20, 0x06, 0xEF, 0x30, + 0x35, 0xAF, 0x8D, 0x96, 0x73, 0x3C, 0x50, 0x64, + 0x65, 0x93, 0xBF, 0x42, 0x2C, 0x7E, 0x58, 0xCE, + 0x58, 0xD5, 0xC5, 0xDC, 0xC4, 0xA5, 0x99, 0x10, + 0x4B, 0xC3, 0x1E, 0x5B, 0x66, 0x4A, 0x38, 0x45, + 0x6A, 0xFD, 0x15, 0xF7, 0x40, 0xD0, 0x0F, 0x9F, + 0xC7, 0x12, 0x19, 0x8B, 0x46, 0x09, 0x10, 0xFA + }, + { + 0x2A, 0x52, 0xA4, 0x02, 0x0B, 0xE2, 0x4A, 0xF8, + 0x9A, 0x70, 0x7A, 0x22, 0x0B, 0x1F, 0x9F, 0x3C, + 0x8B, 0x7F, 0x90, 0x19, 0x19, 0xC6, 0x61, 0x8E, + 0xD0, 0xC2, 0xF0, 0x81, 0x22, 0xC9, 0xBE, 0x99, + 0xEB, 0xE0, 0x4B, 0xA3, 0xEA, 0x11, 0x02, 0x18, + 0x36, 0x31, 0x1F, 0x50, 0x42, 0x79, 0x8E, 0xD8, + 0x5C, 0xF1, 0x79, 0xD8, 0x2B, 0x87, 0x07, 0x08, + 0x80, 0x83, 0xD7, 0x3F, 0x15, 0xAA, 0x00, 0x12 + }, + { + 0x1F, 0xD5, 0x01, 0x1D, 0x0F, 0xD6, 0x18, 0x4D, + 0x33, 0x8A, 0x95, 0x6C, 0xC6, 0x01, 0x02, 0xA1, + 0xA6, 0xFC, 0xF6, 0x0E, 0x26, 0x94, 0x07, 0x65, + 0x0D, 0x16, 0x83, 0xBE, 0xF3, 0x09, 0x37, 0xCD, + 0xE6, 0x88, 0x29, 0xB0, 0x6A, 0xB9, 0x5E, 0x4C, + 0x60, 0xF3, 0x13, 0x0F, 0x9F, 0x9F, 0x50, 0x30, + 0xBC, 0x00, 0xA6, 0xBE, 0x9A, 0x7C, 0x94, 0xA0, + 0x9C, 0xE7, 0xD9, 0xFE, 0xB9, 0x40, 0xD2, 0xA3 + }, + { + 0xA5, 0xE7, 0x15, 0x59, 0x06, 0x5D, 0x20, 0x69, + 0x60, 0x0E, 0x56, 0x98, 0x96, 0x70, 0x74, 0xB9, + 0xDF, 0x90, 0x42, 0x38, 0x18, 0xBA, 0xD5, 0xCB, + 0x30, 0xC5, 0x9E, 0xD6, 0x8A, 0xDC, 0xBE, 0x5D, + 0xB3, 0xAA, 0xEA, 0x50, 0x16, 0xCD, 0xAA, 0xE0, + 0x7F, 0xDD, 0xFC, 0x77, 0x16, 0xEA, 0xCC, 0x41, + 0x3B, 0x22, 0xC5, 0x63, 0x51, 0x1A, 0x6A, 0x4F, + 0x3D, 0x93, 0x11, 0xF8, 0x2C, 0x02, 0xE0, 0x39 + }, + { + 0x0B, 0x0C, 0x14, 0x15, 0x7C, 0x2F, 0x71, 0x63, + 0xEB, 0x3A, 0x80, 0xB4, 0x26, 0x70, 0x95, 0x58, + 0x57, 0xF1, 0xC8, 0x52, 0x82, 0xB0, 0xD8, 0x73, + 0xA3, 0xBF, 0x86, 0x31, 0xE5, 0x4C, 0x3C, 0x47, + 0x78, 0x1C, 0xB7, 0x6D, 0x7E, 0x3E, 0xEC, 0x7B, + 0x19, 0x67, 0x13, 0x10, 0x7B, 0xCE, 0x6D, 0x11, + 0x7E, 0x30, 0x98, 0x6A, 0x47, 0xD8, 0xD5, 0xA8, + 0x4F, 0x3F, 0xA9, 0x00, 0x6A, 0x2A, 0x9C, 0x69 + }, + { + 0x27, 0xD8, 0xC3, 0x85, 0x36, 0xDF, 0xDE, 0x63, + 0x35, 0xE9, 0xF2, 0xB7, 0x39, 0x5B, 0xA1, 0x49, + 0x2A, 0x35, 0xC6, 0x79, 0x0F, 0x4B, 0x8D, 0xFC, + 0xAE, 0x85, 0x0D, 0xBA, 0x92, 0xA8, 0x42, 0xE4, + 0xD1, 0xFD, 0x2D, 0x05, 0x2A, 0xDC, 0xC8, 0xD8, + 0x54, 0xD1, 0xE5, 0x01, 0xAE, 0xFA, 0x6E, 0xD8, + 0x9B, 0x93, 0x6A, 0x56, 0xB1, 0x0D, 0x73, 0x36, + 0x85, 0x49, 0xEB, 0xCA, 0x11, 0xBD, 0x5E, 0xBE + }, + { + 0x6E, 0x3A, 0x95, 0x3D, 0xC0, 0x86, 0xEC, 0x28, + 0xA5, 0x71, 0x90, 0x26, 0xC3, 0x73, 0x20, 0x59, + 0x2E, 0x06, 0x0B, 0x16, 0xB5, 0x0E, 0x63, 0xFF, + 0x07, 0xE9, 0x51, 0xDC, 0x3B, 0xDC, 0x41, 0x4A, + 0x28, 0xE2, 0xDC, 0x5B, 0x2D, 0x3D, 0x79, 0x6A, + 0x03, 0xFA, 0x63, 0xAA, 0xDE, 0x07, 0x03, 0x49, + 0x4F, 0x4E, 0x19, 0x05, 0xBF, 0x7E, 0x2B, 0x3B, + 0x62, 0xF2, 0x5C, 0x8F, 0x31, 0xAE, 0x50, 0x1F + }, + { + 0x46, 0xBF, 0xCD, 0x6F, 0xC7, 0xEA, 0x04, 0x66, + 0xD0, 0x65, 0xEB, 0x08, 0x5E, 0x9C, 0x69, 0x61, + 0x71, 0x63, 0x7A, 0xA1, 0xC7, 0xA7, 0x26, 0x85, + 0x8E, 0x85, 0xEF, 0x1A, 0x7F, 0xC9, 0xB2, 0xE0, + 0x21, 0xD9, 0x8D, 0x8F, 0x84, 0x78, 0xB8, 0x07, + 0x6A, 0xFE, 0xFB, 0x13, 0xC7, 0x48, 0xF3, 0xF3, + 0xEC, 0xAB, 0xB3, 0xA1, 0x88, 0x10, 0xBF, 0xEB, + 0x32, 0x38, 0xD0, 0x9B, 0x73, 0x0A, 0xC5, 0xFB + }, + { + 0xCE, 0x1C, 0xED, 0x32, 0x5B, 0xD9, 0x89, 0xD2, + 0xAE, 0x8D, 0xB3, 0xC1, 0xCA, 0x3C, 0xF0, 0xE0, + 0xA8, 0x01, 0x92, 0xA8, 0x93, 0x8D, 0x22, 0x58, + 0xA4, 0x2E, 0x56, 0x35, 0x8F, 0xA2, 0x01, 0x24, + 0xFA, 0xC1, 0xFD, 0x83, 0x3F, 0x8B, 0x2B, 0x61, + 0x5E, 0xE0, 0xB0, 0x60, 0x83, 0xC6, 0x2A, 0x46, + 0xAE, 0xD9, 0x2A, 0xBC, 0xBD, 0x83, 0x87, 0xD9, + 0x3F, 0x5A, 0x69, 0x40, 0xC7, 0xAA, 0xA7, 0x72 + }, + { + 0xBC, 0xE0, 0xB6, 0x1C, 0x4D, 0x48, 0x17, 0xC2, + 0xF5, 0xC4, 0xFA, 0x0E, 0x41, 0xE2, 0xAC, 0xF3, + 0xBD, 0xE2, 0x80, 0x6C, 0xB5, 0xB5, 0x15, 0x6A, + 0xE1, 0x06, 0x63, 0x04, 0xEF, 0xA6, 0xA4, 0x3C, + 0xDC, 0xA2, 0x41, 0x97, 0x2E, 0xB4, 0x19, 0x42, + 0xB1, 0x3C, 0xCE, 0xFC, 0xB6, 0x8B, 0x8C, 0x56, + 0x29, 0xF0, 0x57, 0xF6, 0x7E, 0x09, 0x3C, 0x20, + 0x2C, 0xF9, 0x76, 0x40, 0x3F, 0xA4, 0xBB, 0xD9 + }, + { + 0x57, 0x65, 0x39, 0x7B, 0x0B, 0x41, 0x7A, 0xA7, + 0x36, 0x49, 0x6E, 0x45, 0x0A, 0x32, 0xC1, 0x0B, + 0x0A, 0xA0, 0x91, 0xB6, 0x5E, 0xD3, 0xD6, 0x76, + 0x09, 0x3F, 0x33, 0xB5, 0xC8, 0xB4, 0xAA, 0x52, + 0x6C, 0xB8, 0x18, 0x31, 0xEB, 0x34, 0x57, 0x2E, + 0xAA, 0xCF, 0x32, 0xD8, 0x29, 0xC5, 0x12, 0x0F, + 0x67, 0x7C, 0xC9, 0x84, 0xF6, 0xA7, 0x6E, 0x6A, + 0x33, 0xA9, 0x7E, 0xCC, 0x17, 0x70, 0xFC, 0x60 + }, + { + 0xD5, 0x93, 0x3A, 0xE7, 0x3E, 0xB3, 0x00, 0x88, + 0x9E, 0xD7, 0xF6, 0xC3, 0x5A, 0xB2, 0xE5, 0x9C, + 0x5B, 0xD7, 0x0A, 0xE2, 0x43, 0xCC, 0xD6, 0xE9, + 0x46, 0x7F, 0x62, 0xF2, 0x09, 0x8F, 0xAC, 0x41, + 0xE9, 0x1A, 0x1B, 0xEB, 0x9D, 0x5A, 0xA2, 0x62, + 0xE0, 0x83, 0x7E, 0xE4, 0x88, 0x3F, 0x5D, 0x68, + 0x90, 0x6D, 0x9F, 0x8A, 0xF9, 0x9B, 0xE5, 0x47, + 0x04, 0x38, 0xCD, 0x63, 0xC7, 0xEC, 0x83, 0x9C + }, + { + 0xC3, 0x85, 0x5F, 0x70, 0x8A, 0x70, 0x58, 0x86, + 0x8B, 0x13, 0x98, 0x12, 0xA5, 0x34, 0x1B, 0xF9, + 0xAC, 0xDE, 0xE4, 0x35, 0x1C, 0x30, 0x5D, 0x8F, + 0xFF, 0xC2, 0xAE, 0x7F, 0x2E, 0x65, 0xA0, 0xD3, + 0xA2, 0xB9, 0xC4, 0x6A, 0x0A, 0x32, 0x0D, 0xA9, + 0x25, 0x92, 0x07, 0xC9, 0x06, 0xD0, 0x82, 0xC2, + 0xD4, 0x23, 0xFD, 0xA6, 0x24, 0x47, 0x19, 0x38, + 0x44, 0xB3, 0x89, 0xED, 0x4E, 0xB7, 0xFA, 0x96 + }, + { + 0x1C, 0x11, 0x6B, 0x96, 0xEE, 0xAA, 0x4B, 0xB4, + 0xB1, 0x1B, 0xDD, 0xEB, 0x0E, 0x50, 0xE5, 0x0E, + 0x43, 0x9B, 0x7D, 0x5F, 0x67, 0xB0, 0xD8, 0x7F, + 0xC9, 0x2D, 0xC1, 0x81, 0x9D, 0x1A, 0xE6, 0x1A, + 0xFE, 0xA1, 0xFF, 0xFC, 0x13, 0x97, 0xFD, 0xB7, + 0x30, 0xDC, 0x3F, 0x40, 0x11, 0xC2, 0xE8, 0x3F, + 0x69, 0xCB, 0x9A, 0xF0, 0x19, 0xC9, 0xBA, 0x9E, + 0xB4, 0xC0, 0x48, 0x31, 0x3F, 0xA5, 0xFA, 0x74 + }, + { + 0x3C, 0xB0, 0x13, 0xF0, 0x1F, 0x6F, 0x3F, 0x48, + 0x10, 0xCF, 0x97, 0xED, 0x29, 0x9D, 0x0F, 0xF1, + 0x84, 0xB1, 0x3C, 0xF6, 0x23, 0x22, 0x25, 0x5E, + 0x1C, 0x07, 0xC6, 0x51, 0xFC, 0xBC, 0xAE, 0x26, + 0x75, 0x28, 0xF8, 0xED, 0xFB, 0x5C, 0x8C, 0x34, + 0xD6, 0x0E, 0xDC, 0x05, 0xF4, 0x45, 0x70, 0x6C, + 0x9F, 0x7A, 0x86, 0xDF, 0xD6, 0x1D, 0xBE, 0x1E, + 0xD5, 0x00, 0x16, 0xE3, 0x13, 0x2F, 0x70, 0x88 + }, + { + 0xAA, 0xD7, 0xC7, 0x57, 0x93, 0xC2, 0x0C, 0x5D, + 0xD4, 0xDA, 0x17, 0x67, 0xFB, 0xBF, 0x2F, 0x42, + 0x0F, 0xAA, 0x97, 0xC9, 0x62, 0xA2, 0xCA, 0x9F, + 0x08, 0x1C, 0x05, 0x71, 0xB9, 0xDF, 0x1C, 0x13, + 0xEF, 0x07, 0x0C, 0x3B, 0x24, 0x17, 0x05, 0xCA, + 0x30, 0x2A, 0x9B, 0xD7, 0x88, 0x06, 0x35, 0x06, + 0x79, 0xBD, 0xBD, 0x82, 0xDB, 0xD4, 0xA3, 0xC8, + 0xA7, 0x90, 0x76, 0x1D, 0x1E, 0x0B, 0xF3, 0x3D + }, + { + 0x58, 0x08, 0x88, 0xAA, 0xD8, 0xC1, 0x85, 0xC5, + 0xC6, 0xA7, 0x0D, 0x8D, 0x12, 0x99, 0x98, 0xED, + 0xEA, 0x87, 0x1B, 0xFA, 0x90, 0xA0, 0x95, 0x6E, + 0x3C, 0xE3, 0xB1, 0x5E, 0x5D, 0x82, 0xD8, 0xA6, + 0x02, 0xA4, 0xD8, 0x1F, 0xB7, 0xE8, 0x22, 0x86, + 0x1E, 0xCD, 0x9C, 0x98, 0xAF, 0x19, 0xE3, 0xE0, + 0xE5, 0x29, 0x45, 0x70, 0xF8, 0x7D, 0x5A, 0x31, + 0x18, 0x4D, 0x23, 0xB4, 0x4E, 0x69, 0xD2, 0xED + }, + { + 0x58, 0xA7, 0x55, 0x9A, 0x32, 0xA9, 0x35, 0xF3, + 0x9C, 0x3C, 0x46, 0x53, 0x55, 0x2C, 0x3B, 0x80, + 0xC2, 0xFC, 0xCD, 0x33, 0x9F, 0xD7, 0x98, 0x5A, + 0x9E, 0x7E, 0xD5, 0xC6, 0x8D, 0xDB, 0xD8, 0xA8, + 0xDB, 0x3E, 0x35, 0x00, 0xF5, 0x78, 0x8B, 0x3E, + 0x0E, 0x82, 0xF7, 0x3A, 0x94, 0x59, 0x80, 0xC6, + 0x5E, 0x60, 0x99, 0xC1, 0x21, 0xDD, 0x9C, 0x6D, + 0x6E, 0xE3, 0x05, 0xF6, 0xF2, 0x78, 0x50, 0x15 + }, + { + 0xD0, 0x45, 0xDE, 0x52, 0x81, 0x1E, 0x7C, 0xBD, + 0x28, 0xCC, 0x88, 0xC4, 0x8C, 0xCC, 0x45, 0x16, + 0xFC, 0xE9, 0x09, 0x02, 0xD5, 0x95, 0x88, 0x9E, + 0x34, 0x1A, 0xE2, 0xC5, 0x35, 0xB4, 0xDC, 0xE8, + 0xBB, 0x90, 0x3B, 0x4E, 0x49, 0x9E, 0x89, 0xCC, + 0x30, 0x77, 0x34, 0x0D, 0x56, 0xCA, 0x87, 0xA5, + 0x92, 0x8D, 0xDE, 0xF0, 0x3A, 0x46, 0x20, 0xE4, + 0x2E, 0x33, 0xF0, 0x54, 0x15, 0xEF, 0x74, 0xA2 + }, + { + 0x95, 0x3F, 0x90, 0x6C, 0xE3, 0xBC, 0x68, 0x8C, + 0x15, 0x07, 0xA9, 0x2E, 0x93, 0x06, 0xEC, 0x07, + 0x60, 0x64, 0x09, 0x17, 0x45, 0x7C, 0x9B, 0x71, + 0xFF, 0x7F, 0x8C, 0x68, 0xAC, 0x4B, 0xE1, 0xAB, + 0x57, 0xA3, 0x4C, 0x6C, 0xD9, 0xF4, 0xFB, 0x31, + 0xAE, 0x53, 0x0E, 0x48, 0x50, 0x6A, 0x0A, 0x74, + 0xE8, 0x2B, 0x64, 0xF6, 0xC8, 0x90, 0x5D, 0xC5, + 0xC5, 0xF7, 0xB8, 0x09, 0xFB, 0xD8, 0x9A, 0xAB + }, + { + 0xFA, 0xF1, 0x4F, 0x15, 0x59, 0xB4, 0x3B, 0x3F, + 0x01, 0x71, 0x2D, 0x3D, 0xF3, 0x18, 0x0F, 0x73, + 0x6F, 0x9A, 0x21, 0xC7, 0xF2, 0xF6, 0x59, 0xEC, + 0xD7, 0x95, 0x74, 0xCF, 0x02, 0x1C, 0x5E, 0xB9, + 0x80, 0x1B, 0x9F, 0x25, 0x1A, 0x6A, 0xD2, 0x7E, + 0x3D, 0x1F, 0x7B, 0x60, 0xCF, 0xC8, 0x5E, 0xC6, + 0xED, 0xEB, 0xF7, 0xB5, 0x46, 0x06, 0x56, 0x4B, + 0x60, 0x04, 0xE3, 0x3B, 0xCD, 0xDD, 0xD7, 0xC2 + }, + { + 0x86, 0xF7, 0x7F, 0xDE, 0xFF, 0xCF, 0x7A, 0x74, + 0xF8, 0x07, 0x6D, 0x37, 0x8D, 0x6B, 0x6F, 0xEB, + 0xE3, 0x8A, 0xCD, 0x5C, 0x7D, 0x4C, 0x85, 0xF4, + 0x9F, 0x30, 0x65, 0x5F, 0x75, 0xE0, 0xA1, 0xF5, + 0x65, 0xF8, 0x2D, 0x83, 0x81, 0x62, 0x5C, 0xBC, + 0x87, 0xBD, 0x7B, 0xE9, 0x58, 0x6F, 0x79, 0x9B, + 0x84, 0x52, 0x76, 0xCF, 0xA6, 0xD4, 0x1B, 0x75, + 0xE5, 0xA5, 0xE1, 0x92, 0x85, 0x30, 0x50, 0x74 + }, + { + 0xB6, 0xB6, 0x67, 0xAE, 0xF1, 0xFA, 0x64, 0xE1, + 0x1A, 0x01, 0x8D, 0x9F, 0x3E, 0xED, 0x1E, 0xD3, + 0xE5, 0x55, 0xC8, 0xDC, 0xAF, 0xB5, 0xFF, 0xA0, + 0x68, 0x3F, 0x55, 0x74, 0x8E, 0x24, 0x57, 0x80, + 0x08, 0xD6, 0x81, 0x2B, 0x8D, 0xB9, 0x75, 0xAC, + 0xA9, 0x4C, 0x85, 0x69, 0xA9, 0xCA, 0x74, 0x71, + 0x35, 0x24, 0x8D, 0x7E, 0x8C, 0x48, 0x0D, 0x27, + 0x13, 0x98, 0x33, 0x9B, 0x73, 0xB9, 0x8D, 0x85 + }, + { + 0xFE, 0x12, 0xB6, 0x4D, 0x78, 0x7C, 0xD0, 0x5B, + 0x83, 0x00, 0x96, 0x94, 0xC4, 0x5D, 0xB0, 0x96, + 0x5A, 0x6E, 0x8D, 0x28, 0xCE, 0x87, 0x7D, 0x10, + 0xEC, 0xE7, 0xE5, 0xC1, 0xCA, 0xA4, 0x00, 0x34, + 0x69, 0xFD, 0x80, 0xC5, 0x64, 0xBB, 0x1B, 0xA5, + 0xD3, 0x97, 0x0E, 0xBF, 0x60, 0x70, 0xBF, 0xD0, + 0x32, 0x9D, 0x88, 0xF3, 0x7B, 0xDD, 0x52, 0x58, + 0xAC, 0xEE, 0xE9, 0xB8, 0x26, 0x46, 0xD1, 0x06 + }, + { + 0x21, 0x55, 0x02, 0xFF, 0xBF, 0xBA, 0x8A, 0x7B, + 0x71, 0x56, 0x8C, 0xBE, 0xC9, 0x0D, 0xD1, 0xFD, + 0x98, 0xB6, 0xD5, 0x0D, 0x0D, 0x08, 0x4D, 0x4D, + 0x1F, 0x69, 0x61, 0xE4, 0xAA, 0xE1, 0x6E, 0x0C, + 0x80, 0x41, 0x33, 0x18, 0x41, 0x39, 0xDF, 0x03, + 0xB1, 0xB2, 0x57, 0x3A, 0xE8, 0x64, 0xE6, 0x11, + 0xC2, 0x78, 0x36, 0x8C, 0xA8, 0x46, 0x6B, 0x64, + 0x55, 0xAA, 0x25, 0xB4, 0xA6, 0x50, 0xDD, 0xA6 + }, + { + 0x37, 0xFB, 0xCF, 0xF5, 0xCB, 0xED, 0x34, 0xDD, + 0x6C, 0x51, 0xD5, 0x90, 0xAC, 0xB7, 0x18, 0xC4, + 0xEA, 0xDA, 0x2C, 0xFF, 0x25, 0x41, 0xDE, 0xC9, + 0xA0, 0x34, 0xFC, 0x63, 0x1C, 0x89, 0x90, 0x59, + 0x68, 0x29, 0x96, 0x10, 0x43, 0x69, 0x21, 0xFE, + 0xFF, 0x47, 0x9B, 0x97, 0x4F, 0xA4, 0x5A, 0xEB, + 0x96, 0xA9, 0xC3, 0xFA, 0x82, 0x93, 0xC3, 0x1D, + 0x00, 0xB9, 0x38, 0xCF, 0x26, 0x8B, 0xE7, 0xA5 + }, + { + 0x4D, 0xCF, 0xC3, 0xD9, 0x32, 0xFF, 0x1B, 0x2A, + 0x4B, 0x19, 0xA6, 0x9D, 0xC5, 0xB1, 0x5D, 0xC0, + 0x39, 0x9B, 0xF8, 0x5D, 0x45, 0xA1, 0xDF, 0xE8, + 0xD7, 0x17, 0xDC, 0x7E, 0xBB, 0x45, 0x31, 0xC5, + 0x5B, 0xC6, 0xCF, 0x4F, 0xF0, 0xE0, 0x82, 0xF1, + 0x14, 0x41, 0x43, 0x2C, 0xCC, 0xED, 0x65, 0x2C, + 0x4B, 0x7B, 0x9F, 0x86, 0xF5, 0x2C, 0x77, 0xE0, + 0x0A, 0x7C, 0x1B, 0x90, 0x3E, 0xEB, 0xF5, 0xFB + }, + { + 0x85, 0x94, 0x3C, 0xC3, 0xCE, 0x8D, 0x09, 0x90, + 0x6F, 0xFA, 0xAF, 0x20, 0x62, 0xCB, 0xF7, 0x93, + 0x03, 0x9F, 0xA9, 0x84, 0x65, 0x9A, 0x25, 0x0C, + 0x6C, 0xE4, 0x5B, 0x0D, 0x1E, 0x10, 0x53, 0x4B, + 0x98, 0x5E, 0x51, 0x3A, 0x86, 0x6B, 0x91, 0x71, + 0x23, 0x9E, 0x7D, 0x12, 0xE4, 0xCF, 0x1E, 0xFB, + 0x8A, 0xCA, 0x25, 0xBA, 0xF2, 0xA3, 0x93, 0x6B, + 0x7A, 0x52, 0x58, 0x30, 0xEE, 0xD3, 0xEE, 0xF1 + }, + { + 0xA2, 0x85, 0x95, 0x51, 0x64, 0xD5, 0x4F, 0x2A, + 0x6D, 0x97, 0xE9, 0x7B, 0x94, 0x8E, 0x07, 0x54, + 0x3A, 0x45, 0xC9, 0x99, 0xA7, 0xB2, 0x8F, 0x65, + 0x41, 0xB4, 0x69, 0xD4, 0x00, 0x0E, 0xE8, 0xCF, + 0x5D, 0x96, 0x0E, 0x95, 0xC1, 0x53, 0x73, 0x31, + 0xFB, 0x92, 0xC1, 0x3A, 0x46, 0x7E, 0x41, 0xE7, + 0xB5, 0x6D, 0xFC, 0x06, 0xC0, 0x6D, 0x7B, 0x99, + 0x09, 0xDD, 0xB7, 0x9B, 0x07, 0x19, 0x77, 0x70 + }, + { + 0x47, 0x08, 0x36, 0xB0, 0x35, 0x9D, 0xE1, 0x90, + 0x09, 0x95, 0xBF, 0x49, 0x30, 0xB3, 0xB4, 0x6C, + 0x7D, 0x46, 0xDB, 0x4D, 0x7B, 0x10, 0x79, 0x3E, + 0x95, 0x3D, 0x04, 0x14, 0xF0, 0x48, 0x18, 0xD9, + 0xDF, 0x6D, 0x0D, 0x1A, 0xAF, 0xB1, 0xD6, 0x29, + 0xA4, 0x00, 0x3C, 0xEB, 0x1C, 0x7E, 0x6E, 0xE4, + 0x72, 0x9F, 0x4F, 0x47, 0xCA, 0xA4, 0xAA, 0x0C, + 0x64, 0xB7, 0x76, 0x48, 0x0E, 0x2C, 0xFC, 0xE0 + }, + { + 0x07, 0xBD, 0xBA, 0x0A, 0xE1, 0x3F, 0xB7, 0x40, + 0x27, 0xCB, 0x68, 0x71, 0xDD, 0x3D, 0x70, 0xCF, + 0x44, 0x5E, 0x75, 0x37, 0x7D, 0x8E, 0x62, 0x07, + 0x4E, 0x2D, 0xDE, 0xFF, 0xF2, 0xAF, 0x1C, 0x7B, + 0x81, 0x90, 0x25, 0xEB, 0xB8, 0xB4, 0xA0, 0x36, + 0xC2, 0x2D, 0x7B, 0x04, 0xB8, 0xA5, 0xE3, 0x5E, + 0x50, 0xEA, 0x12, 0x88, 0xC2, 0x13, 0x90, 0x08, + 0xF6, 0xD9, 0x5B, 0x39, 0x1B, 0xAC, 0x43, 0x8C + }, + { + 0x33, 0xA1, 0xF1, 0xDF, 0x0F, 0xC1, 0xC5, 0x39, + 0xA5, 0xDB, 0x46, 0xA1, 0x12, 0xC7, 0xC7, 0x0B, + 0x8A, 0x42, 0x48, 0xA0, 0x78, 0xAE, 0x7A, 0xE3, + 0x0D, 0xD7, 0xFD, 0xD8, 0x57, 0x89, 0xB6, 0x24, + 0x04, 0x36, 0xA4, 0x4B, 0x9A, 0x56, 0x5D, 0x68, + 0xCF, 0x7F, 0x97, 0xB7, 0xE5, 0x21, 0x89, 0x4C, + 0xE1, 0x76, 0xF4, 0x5F, 0xB8, 0xD3, 0x02, 0xFB, + 0x25, 0xD8, 0x3A, 0x11, 0x9C, 0xEC, 0x33, 0x4A + }, + { + 0x07, 0x8B, 0xD1, 0x43, 0x48, 0x7D, 0xF7, 0x15, + 0x72, 0xDD, 0x73, 0xB2, 0xA6, 0x05, 0xDB, 0xF4, + 0x55, 0x31, 0x84, 0x33, 0x2E, 0x2E, 0xCC, 0x5F, + 0x9F, 0x8C, 0x03, 0x66, 0x57, 0x25, 0xCE, 0x44, + 0x61, 0xA1, 0x18, 0x73, 0x01, 0xB4, 0xEC, 0x82, + 0xC1, 0xBF, 0x70, 0xDE, 0x1F, 0x81, 0x7D, 0x65, + 0x31, 0x18, 0x43, 0xF2, 0xDE, 0xFB, 0xF4, 0xD2, + 0x06, 0x07, 0x30, 0x84, 0xFE, 0x7E, 0x12, 0x81 + }, + { + 0x1E, 0xA5, 0x41, 0xAA, 0x69, 0x6C, 0x41, 0xBC, + 0x42, 0x42, 0xF5, 0xBE, 0x09, 0xD6, 0x3C, 0xF8, + 0x74, 0x0E, 0x3F, 0x14, 0x9E, 0x40, 0x83, 0x4B, + 0xF8, 0xF7, 0x8F, 0xCD, 0x6F, 0x17, 0x83, 0x77, + 0xB3, 0xA3, 0x98, 0x63, 0x42, 0x4F, 0xAD, 0x22, + 0x92, 0x9A, 0xF1, 0xF9, 0x11, 0xF2, 0x33, 0x0C, + 0xAF, 0x91, 0x2B, 0x4D, 0x6B, 0x1A, 0x92, 0x89, + 0x0B, 0xBD, 0xE9, 0x86, 0xDC, 0xCD, 0x43, 0xA8 + }, + { + 0xCE, 0x99, 0xF8, 0xF1, 0xC1, 0x2C, 0xE3, 0x2B, + 0xEC, 0x32, 0x84, 0x2F, 0x84, 0x85, 0x01, 0x35, + 0x83, 0xAE, 0xBD, 0x49, 0x06, 0x1A, 0xCA, 0x10, + 0x0D, 0x12, 0x62, 0x40, 0x00, 0x1E, 0xC2, 0x35, + 0xD9, 0x00, 0xF3, 0x93, 0x58, 0xC1, 0xE6, 0xBE, + 0x2D, 0xF1, 0x0F, 0x6E, 0xAC, 0xA2, 0x2F, 0xB8, + 0x1D, 0x0E, 0x9C, 0x3F, 0x03, 0xA2, 0xEB, 0x85, + 0xD7, 0x88, 0xBD, 0xC6, 0x6C, 0xB0, 0xE1, 0xD9 + }, + { + 0x25, 0xB7, 0x6E, 0x81, 0xDD, 0x1B, 0x57, 0x04, + 0x95, 0x86, 0x1C, 0x9B, 0x42, 0xF7, 0x96, 0x67, + 0x5F, 0x0C, 0xAE, 0x75, 0xD1, 0x15, 0x39, 0x24, + 0xCE, 0x0A, 0xAD, 0xCF, 0x74, 0xC1, 0xF5, 0x2C, + 0x7A, 0xBC, 0x10, 0x5C, 0xEA, 0xEE, 0x46, 0xE0, + 0x43, 0xC0, 0xA3, 0x56, 0x4E, 0xC8, 0x3C, 0xCF, + 0xD9, 0x4F, 0x00, 0xE2, 0x25, 0xE7, 0x74, 0x2B, + 0x7F, 0x9E, 0x86, 0xAF, 0x52, 0x74, 0x7D, 0x9F + }, + { + 0xA5, 0xBC, 0x58, 0xC5, 0xE8, 0xEB, 0x29, 0xCB, + 0x62, 0xA2, 0x81, 0x34, 0x94, 0xC3, 0x29, 0xF0, + 0x39, 0x63, 0xC2, 0x68, 0xE5, 0x11, 0x9B, 0x57, + 0x36, 0xC3, 0x6D, 0xF8, 0x11, 0x6D, 0x1A, 0x1C, + 0x35, 0x04, 0x91, 0x3C, 0xF6, 0xA4, 0x99, 0x23, + 0xBF, 0x2E, 0x40, 0xC6, 0xD5, 0x63, 0xDA, 0xD9, + 0x0F, 0x4B, 0x90, 0x8C, 0x2B, 0xC4, 0xA3, 0xC5, + 0xC9, 0x86, 0x84, 0xED, 0x93, 0x90, 0x9B, 0xAB + }, + { + 0xAB, 0x98, 0xE5, 0x08, 0xA8, 0x82, 0x77, 0x0A, + 0x2C, 0xA2, 0x3B, 0x3F, 0xC1, 0x82, 0xBC, 0x6F, + 0x94, 0xB9, 0x20, 0xDB, 0x05, 0xFD, 0xA3, 0x6F, + 0xC6, 0x14, 0x40, 0xCD, 0xE4, 0x74, 0x2C, 0x8F, + 0x36, 0x05, 0x6A, 0x99, 0xDB, 0x3B, 0x19, 0x54, + 0x47, 0x88, 0x23, 0x7E, 0x13, 0x42, 0xD2, 0xBD, + 0x9B, 0xEF, 0x97, 0xD3, 0x79, 0x75, 0x4E, 0xAA, + 0x6F, 0xB6, 0xE8, 0xC6, 0xC3, 0xD1, 0xF7, 0x50 + }, + { + 0x7A, 0xB3, 0x62, 0x06, 0x59, 0x21, 0x8F, 0x67, + 0x3B, 0xAE, 0x2F, 0x37, 0xF6, 0x3D, 0x77, 0x1F, + 0xC8, 0x56, 0xFF, 0x11, 0x1F, 0xEE, 0xDA, 0xC5, + 0x63, 0x92, 0xA6, 0xA1, 0x56, 0xA3, 0xBE, 0xA2, + 0xE4, 0x31, 0xD4, 0x6A, 0x23, 0xF8, 0xD1, 0x18, + 0x1D, 0x82, 0x9D, 0x00, 0xFD, 0x60, 0x39, 0x68, + 0xEC, 0x89, 0xD1, 0x1C, 0x46, 0xB6, 0x87, 0x90, + 0x8C, 0xAB, 0x34, 0xB8, 0xF2, 0x2B, 0xDD, 0x5D + }, + { + 0x4D, 0x34, 0xC7, 0x87, 0xC6, 0xDB, 0x64, 0xD5, + 0x98, 0xA0, 0xB0, 0x19, 0x98, 0x6B, 0x80, 0x1E, + 0xD9, 0x4C, 0xF6, 0x67, 0xEF, 0xD7, 0x87, 0xA6, + 0xA9, 0x04, 0x78, 0x97, 0xB4, 0x2F, 0xDC, 0xE8, + 0xFA, 0x4C, 0x93, 0x26, 0x9A, 0xDA, 0xFB, 0x90, + 0xF6, 0x90, 0xC6, 0x32, 0xA4, 0xF5, 0x41, 0x96, + 0xDE, 0x0A, 0x4B, 0x61, 0xF1, 0x35, 0x91, 0x7A, + 0x22, 0x07, 0xAB, 0xA6, 0xFE, 0x69, 0xDE, 0x36 + }, + { + 0x32, 0x3E, 0x97, 0xA7, 0xA8, 0x59, 0xEE, 0x63, + 0xC9, 0x01, 0x3D, 0xEB, 0xB0, 0xCA, 0x99, 0x58, + 0x11, 0xE7, 0x31, 0x17, 0xA2, 0xF5, 0x74, 0x72, + 0x34, 0x16, 0xE5, 0x96, 0xEB, 0xC1, 0x84, 0xE3, + 0x7A, 0x59, 0xB6, 0x6D, 0x2F, 0x59, 0x7D, 0xF4, + 0xA7, 0xC1, 0xB0, 0xD1, 0xD4, 0x1A, 0x1A, 0x7F, + 0x28, 0x77, 0x4F, 0x46, 0xA6, 0x86, 0x4D, 0x56, + 0xC5, 0x7B, 0x9D, 0x6C, 0x5F, 0x73, 0x02, 0xFB + }, + { + 0x83, 0x7F, 0xC4, 0x33, 0x9B, 0x83, 0x51, 0x83, + 0x99, 0x1C, 0x00, 0xCB, 0x56, 0x3B, 0xBB, 0x2B, + 0x22, 0x93, 0x4F, 0x1C, 0x5A, 0x65, 0xC8, 0x4C, + 0xB3, 0xEB, 0xBC, 0x63, 0x4B, 0xDB, 0xAD, 0xF9, + 0x23, 0x57, 0x51, 0xAA, 0x01, 0x9E, 0xDE, 0xF2, + 0xD3, 0x74, 0xDD, 0x36, 0x29, 0x32, 0x04, 0xAC, + 0x0A, 0x43, 0x57, 0x43, 0x8A, 0xA3, 0x1C, 0x65, + 0x02, 0xF0, 0x4A, 0xAD, 0xE3, 0x18, 0xAB, 0xDA + }, + { + 0xC3, 0xAE, 0x58, 0xD0, 0x60, 0x50, 0xB6, 0x94, + 0xB9, 0x0A, 0x62, 0x9F, 0x95, 0x32, 0xE9, 0x61, + 0xB4, 0x04, 0x43, 0xAC, 0xEE, 0xC5, 0x6D, 0xAF, + 0x8E, 0xDF, 0x9F, 0xA5, 0x6B, 0xDF, 0xC6, 0x31, + 0xAF, 0x8C, 0x67, 0xCC, 0x59, 0x7F, 0xEF, 0xB6, + 0x80, 0xD5, 0xA9, 0xF1, 0x0D, 0x02, 0x39, 0x34, + 0x67, 0xD3, 0x98, 0x30, 0x7F, 0xD7, 0xFF, 0x25, + 0xD5, 0xA6, 0x76, 0xB0, 0x99, 0x25, 0x98, 0x94 + }, + { + 0x3A, 0x16, 0x3C, 0xA7, 0x3C, 0x8F, 0x6C, 0x9D, + 0xCD, 0x69, 0x70, 0x0A, 0xE2, 0x99, 0xCB, 0x8C, + 0x21, 0x38, 0x61, 0xC0, 0x01, 0x39, 0x8E, 0x67, + 0xFC, 0x69, 0xA3, 0x58, 0xF9, 0xC4, 0xB1, 0x38, + 0x1E, 0xA9, 0x17, 0x49, 0xEE, 0x72, 0x35, 0xA2, + 0xBC, 0x35, 0xF4, 0xF9, 0x82, 0x96, 0xE8, 0xAA, + 0xC4, 0x6D, 0x29, 0x96, 0xE4, 0x6A, 0x0A, 0x5A, + 0xBB, 0x83, 0x19, 0x8D, 0xA2, 0x27, 0xFE, 0x65 + }, + { + 0xF5, 0x3A, 0xDB, 0xC8, 0x6B, 0xE1, 0x7E, 0x16, + 0x1E, 0x0A, 0x1C, 0xEA, 0x16, 0xAB, 0xB4, 0x88, + 0x6D, 0x73, 0xBE, 0x6D, 0x3C, 0x51, 0x5D, 0x24, + 0x11, 0x7D, 0x29, 0x07, 0xE9, 0x9B, 0xFE, 0x55, + 0xCC, 0xE1, 0x7B, 0x51, 0x60, 0x76, 0x46, 0xCD, + 0xDC, 0xA3, 0x76, 0x2B, 0xB2, 0x91, 0x52, 0x90, + 0xFE, 0xB6, 0x13, 0xC8, 0xE2, 0xB0, 0x85, 0xBC, + 0xB0, 0x8C, 0xDC, 0x48, 0xCA, 0x6B, 0xA8, 0xB9 + }, + { + 0x0E, 0x1B, 0x29, 0x91, 0xE5, 0xFA, 0xAF, 0xFF, + 0xBE, 0x0E, 0xA0, 0x79, 0x41, 0xCE, 0x1D, 0xE8, + 0x4F, 0xA4, 0x10, 0x2A, 0x68, 0x5E, 0x99, 0xAE, + 0xB4, 0x8C, 0x07, 0x22, 0xE4, 0x37, 0x26, 0xEA, + 0x1D, 0x5F, 0x6C, 0x7A, 0x98, 0x95, 0x28, 0xD5, + 0xE7, 0x87, 0x71, 0x06, 0x97, 0x44, 0x16, 0xDE, + 0x90, 0xE0, 0x07, 0x3F, 0x6D, 0x5A, 0x65, 0x75, + 0x54, 0xBB, 0xD2, 0x21, 0x6A, 0xE3, 0x9E, 0x5B + }, + { + 0x28, 0x36, 0xDD, 0xDE, 0x84, 0xD6, 0xB9, 0x25, + 0x28, 0xF7, 0x22, 0x01, 0x5B, 0x15, 0xC6, 0x5C, + 0xDE, 0xF0, 0x45, 0xA7, 0x5E, 0x4B, 0x86, 0x03, + 0x5E, 0x67, 0x18, 0x5E, 0xAA, 0x09, 0xC5, 0xDF, + 0xE2, 0xE3, 0x3C, 0xA0, 0x56, 0x7D, 0xD0, 0x53, + 0x4A, 0x2D, 0xD7, 0xBD, 0x82, 0xA3, 0xC6, 0x0B, + 0x1E, 0xC3, 0xEE, 0x9F, 0x54, 0xBB, 0x45, 0xA9, + 0xDC, 0x23, 0x1B, 0x92, 0xE4, 0x4E, 0x6C, 0xA4 + }, + { + 0xE2, 0x9F, 0x64, 0x6C, 0x0C, 0x39, 0x33, 0xC7, + 0xCD, 0xE5, 0xFE, 0xA6, 0x96, 0x9C, 0x08, 0x0B, + 0xFE, 0xC1, 0x71, 0x43, 0xED, 0x9A, 0x93, 0xDB, + 0xBD, 0x28, 0xFE, 0x7E, 0xF4, 0x29, 0x91, 0xDC, + 0x65, 0x4E, 0x2E, 0x31, 0x04, 0xB2, 0xA5, 0x65, + 0x12, 0xEB, 0xA0, 0xAE, 0x65, 0xBF, 0x26, 0xEA, + 0x3B, 0x59, 0x03, 0x4D, 0xC7, 0xCA, 0xD8, 0x90, + 0x04, 0xDC, 0x97, 0xE9, 0x07, 0xCE, 0xC0, 0x3D + }, + { + 0xD7, 0x75, 0xD4, 0xAE, 0x58, 0xD5, 0xEA, 0xFF, + 0x41, 0x40, 0x20, 0x38, 0xED, 0x4E, 0x97, 0x0D, + 0xD9, 0x69, 0xD2, 0xB0, 0x50, 0xB1, 0x14, 0x9D, + 0x0F, 0xD0, 0xC8, 0xEA, 0x8E, 0x0C, 0xAE, 0xEC, + 0x7A, 0x5D, 0xE7, 0xDF, 0xA1, 0x59, 0xE3, 0x89, + 0xD4, 0xC5, 0x74, 0xC7, 0x66, 0x86, 0x26, 0x85, + 0xBE, 0xB5, 0x4E, 0x54, 0xAB, 0xD7, 0x74, 0xBB, + 0x1E, 0xD3, 0x6B, 0x4F, 0x60, 0x76, 0x51, 0xE0 + }, + { + 0x3A, 0x82, 0x6A, 0xF1, 0x2B, 0x2C, 0xCB, 0x02, + 0xEE, 0x77, 0x82, 0xB9, 0xF1, 0x43, 0x1C, 0x9D, + 0xAE, 0x61, 0x42, 0xD4, 0xC6, 0xFB, 0x64, 0xD5, + 0xFA, 0x00, 0x04, 0x7C, 0x22, 0x03, 0x38, 0xA6, + 0x2F, 0xF9, 0x50, 0xDC, 0x99, 0xB0, 0x42, 0xE8, + 0x8C, 0xA0, 0x72, 0x96, 0x38, 0xE7, 0x4D, 0x8C, + 0x73, 0xC3, 0xFA, 0xDE, 0x81, 0xEC, 0x58, 0x92, + 0x43, 0x77, 0x99, 0x24, 0x60, 0x5F, 0xF4, 0x61 + }, + { + 0x58, 0x7B, 0xA5, 0xCE, 0x50, 0xB6, 0xAE, 0xFF, + 0x32, 0x5F, 0xC4, 0x32, 0xD0, 0x2E, 0x85, 0x7F, + 0xE3, 0xE7, 0xDA, 0x20, 0x7E, 0x4D, 0xA3, 0x5B, + 0xD1, 0xEB, 0x28, 0x81, 0x5E, 0x7E, 0xC7, 0xE1, + 0x6E, 0x9F, 0xD4, 0xED, 0xC6, 0x6F, 0x4B, 0x93, + 0xFC, 0x34, 0x7B, 0xD3, 0x44, 0x80, 0x2D, 0x41, + 0xEC, 0x64, 0xB7, 0x7E, 0x40, 0x1E, 0x42, 0xF7, + 0xB3, 0x21, 0x63, 0x19, 0x62, 0xA2, 0x0D, 0x8C + }, + { + 0x3D, 0xB3, 0x87, 0x05, 0x50, 0x50, 0xB2, 0x12, + 0xCA, 0x0C, 0x71, 0xB8, 0xCE, 0x4F, 0xE0, 0x07, + 0x24, 0xE6, 0x46, 0x06, 0x1C, 0x7C, 0xD5, 0x40, + 0xDE, 0x57, 0x5C, 0x98, 0x88, 0x91, 0x48, 0x9B, + 0xDF, 0x70, 0x24, 0xFB, 0x05, 0x08, 0xE0, 0xB9, + 0xA6, 0xB2, 0x03, 0xBC, 0x71, 0xA5, 0x27, 0x4B, + 0x81, 0x03, 0x68, 0x67, 0x37, 0x71, 0x12, 0x3B, + 0xB6, 0x4C, 0xE6, 0x4B, 0x38, 0x27, 0x77, 0xD6 + }, + { + 0xAC, 0xEF, 0xEB, 0xB5, 0x01, 0xE0, 0xA5, 0xBA, + 0xF3, 0x75, 0x82, 0xE9, 0xB8, 0xA0, 0xAA, 0x6A, + 0x41, 0xC7, 0xC2, 0x24, 0x9E, 0x04, 0xD4, 0x41, + 0xDC, 0xAB, 0x33, 0xCE, 0x1B, 0x1F, 0x06, 0xC0, + 0x4B, 0x1B, 0xF0, 0x8F, 0xEE, 0x92, 0x0F, 0x8E, + 0x0A, 0xB1, 0xD0, 0x47, 0x8A, 0xA9, 0x3A, 0xD3, + 0x84, 0xEE, 0x47, 0xA1, 0xBD, 0x94, 0x2A, 0x0B, + 0x28, 0x13, 0x9D, 0x7F, 0xF1, 0xED, 0xF7, 0x37 + }, + { + 0x75, 0xCE, 0x4C, 0x82, 0x14, 0xA0, 0x7C, 0x86, + 0x54, 0xD5, 0x7E, 0x0C, 0xFD, 0x1C, 0x43, 0xCD, + 0xA9, 0x38, 0x41, 0x70, 0xD5, 0x13, 0xCB, 0x9B, + 0xD6, 0x48, 0x62, 0x24, 0x67, 0x5D, 0x60, 0x40, + 0x3D, 0xA9, 0x55, 0x9D, 0xEF, 0x14, 0xF1, 0x2F, + 0x3F, 0x35, 0x9B, 0x03, 0x2C, 0xE2, 0xE9, 0x5B, + 0xAD, 0x5B, 0xAC, 0x09, 0x2B, 0xEA, 0xC8, 0xA6, + 0xFF, 0xFF, 0xFC, 0x5F, 0x13, 0xEF, 0x0A, 0xB9 + }, + { + 0x55, 0xEA, 0x59, 0x7F, 0x72, 0xEF, 0xC6, 0xBE, + 0x6D, 0x74, 0x06, 0xB9, 0x47, 0x99, 0x6B, 0x34, + 0xC4, 0xD6, 0xBB, 0x45, 0xC1, 0x6E, 0xE4, 0x3E, + 0x26, 0x30, 0x39, 0x68, 0xBE, 0x53, 0xFD, 0xA3, + 0xF2, 0x0A, 0x03, 0x59, 0x28, 0x1C, 0x7A, 0x2B, + 0xFA, 0x57, 0xA6, 0x48, 0x5F, 0x31, 0xE2, 0xDE, + 0x7E, 0x0A, 0x86, 0x8E, 0xFF, 0x1C, 0xB5, 0xA7, + 0x60, 0xBC, 0x8D, 0x2A, 0x27, 0xE8, 0x38, 0x8C + }, + { + 0xA1, 0x48, 0x6A, 0x3C, 0x60, 0xF7, 0x9F, 0xF3, + 0xE8, 0x65, 0xF2, 0x5A, 0x56, 0xD9, 0x3A, 0x56, + 0x69, 0xB9, 0x43, 0xD5, 0x8B, 0x54, 0xCC, 0xAF, + 0x8A, 0x2C, 0x87, 0xF6, 0x6D, 0xFA, 0xE8, 0x77, + 0x90, 0x1E, 0x4F, 0xF5, 0x8D, 0x26, 0x67, 0x7C, + 0xF4, 0x28, 0xE8, 0xC3, 0x54, 0x8C, 0xA0, 0x2C, + 0x9C, 0x15, 0xA0, 0xEE, 0xC5, 0xB5, 0xF1, 0xCF, + 0x6E, 0x43, 0x8C, 0xFB, 0x17, 0xAD, 0xE0, 0x90 + }, + { + 0x43, 0x54, 0x59, 0x62, 0xAE, 0x6A, 0x94, 0x40, + 0xA8, 0x18, 0xDB, 0x06, 0xE0, 0xB4, 0xDD, 0x14, + 0xBD, 0x5F, 0x23, 0x64, 0x13, 0x48, 0xA6, 0xE4, + 0xF2, 0x04, 0x0E, 0xB2, 0xC6, 0x24, 0xAF, 0xF0, + 0x74, 0x95, 0x46, 0xD8, 0x29, 0xC8, 0xD7, 0x43, + 0xF0, 0xE1, 0x21, 0xC3, 0x93, 0xDB, 0x75, 0xA4, + 0xC1, 0xF2, 0xD4, 0x50, 0xB1, 0xD8, 0x4A, 0x26, + 0x11, 0x8F, 0x6F, 0x7C, 0xD4, 0x57, 0x07, 0x38 + }, + { + 0x12, 0xC8, 0xB9, 0x40, 0xF2, 0xE2, 0xDD, 0x5A, + 0xB4, 0xE2, 0x1F, 0x6B, 0xC5, 0xFD, 0x31, 0xDC, + 0xC0, 0x02, 0xF3, 0x7D, 0x4A, 0x99, 0x86, 0xE4, + 0xC7, 0x62, 0x2D, 0x2A, 0x1C, 0xE9, 0x64, 0x4E, + 0x29, 0x30, 0x24, 0xC7, 0x85, 0x06, 0x93, 0xD3, + 0x17, 0x7D, 0x2F, 0x45, 0xCE, 0x01, 0xDA, 0xAB, + 0x36, 0x3B, 0xCD, 0xC5, 0xC1, 0x8A, 0x84, 0x18, + 0xC1, 0x6E, 0x33, 0x6C, 0x13, 0x18, 0x30, 0x52 + }, + { + 0xBB, 0xF4, 0x8C, 0xA5, 0xA7, 0xB5, 0xD4, 0x27, + 0x2B, 0x0F, 0xEF, 0x90, 0xEE, 0x6B, 0xC3, 0x19, + 0xB4, 0x83, 0xB5, 0xBF, 0xCD, 0xF5, 0x6D, 0xBC, + 0x58, 0xD8, 0x03, 0x51, 0xE6, 0x95, 0x46, 0xBB, + 0x28, 0x1F, 0x87, 0x35, 0x6A, 0xB4, 0x13, 0x79, + 0xE7, 0x03, 0x97, 0x7E, 0xA3, 0xEC, 0xA6, 0x99, + 0x54, 0xF3, 0xBC, 0x77, 0xF9, 0x13, 0xBB, 0xE7, + 0xD7, 0xE9, 0xE4, 0x51, 0x91, 0x4B, 0x0B, 0xFA + }, + { + 0xA5, 0x92, 0x7B, 0xBE, 0xA9, 0x5C, 0xC1, 0x29, + 0x20, 0x0E, 0x25, 0x74, 0x74, 0x79, 0x0C, 0x0D, + 0x3D, 0xA0, 0x9A, 0xB3, 0xC4, 0x55, 0x57, 0x96, + 0xAB, 0x6C, 0x5F, 0x4E, 0xBC, 0xF8, 0x96, 0x59, + 0xBD, 0xDF, 0x1E, 0xF4, 0x75, 0xAF, 0xA8, 0x11, + 0x0F, 0x27, 0x8D, 0x8F, 0x2D, 0x4E, 0xB4, 0x68, + 0x34, 0x3C, 0xCE, 0xBB, 0x3E, 0x90, 0xF4, 0x55, + 0x6D, 0xAB, 0xF8, 0xFF, 0x0B, 0xD3, 0xFC, 0xB9 + }, + { + 0xE4, 0xDC, 0x06, 0xB2, 0xF0, 0xB6, 0x26, 0xB4, + 0x48, 0x9A, 0x00, 0x2E, 0xBE, 0xCA, 0xE4, 0x4D, + 0x22, 0xBD, 0x64, 0xBB, 0x8A, 0x51, 0x60, 0x8E, + 0x18, 0x67, 0x7C, 0xD7, 0x5C, 0xED, 0x56, 0xD6, + 0x03, 0xA9, 0xE1, 0x92, 0x3D, 0xB9, 0xD9, 0xB9, + 0x08, 0x2E, 0x4C, 0x63, 0xC4, 0xDF, 0xA0, 0x18, + 0x61, 0xFE, 0xB3, 0x64, 0x7A, 0xEA, 0xB7, 0xC7, + 0x90, 0x38, 0xF8, 0x8F, 0xE0, 0x50, 0x9B, 0xF7 + }, + { + 0x72, 0xC2, 0x89, 0x9B, 0x7A, 0x9C, 0xEC, 0x7C, + 0x5D, 0x2F, 0xF0, 0x50, 0xE3, 0x5C, 0x76, 0xB3, + 0xB9, 0x61, 0x48, 0x47, 0xEC, 0xAA, 0xEE, 0x32, + 0x30, 0xD7, 0xCE, 0x2A, 0xCA, 0x6A, 0x64, 0xFA, + 0x8B, 0x31, 0x55, 0xF3, 0xFE, 0xBD, 0x11, 0x69, + 0x09, 0x60, 0x32, 0x53, 0xED, 0xAD, 0x08, 0x5F, + 0x67, 0x25, 0x46, 0x3C, 0xBB, 0x65, 0xCC, 0x3C, + 0xCA, 0x7F, 0x4C, 0x9B, 0xDB, 0xB1, 0x06, 0x6B + }, + { + 0xF3, 0x10, 0x58, 0x87, 0x5D, 0x1A, 0x2D, 0xEC, + 0xAD, 0x5C, 0x6E, 0xA8, 0x77, 0x10, 0x15, 0xBC, + 0xA7, 0xF4, 0xB9, 0xB4, 0xE9, 0x9D, 0x1E, 0xC3, + 0xCD, 0xD0, 0x13, 0xC7, 0x0A, 0x23, 0x4B, 0x8A, + 0xF3, 0x1A, 0x37, 0x9B, 0x06, 0xB9, 0x2B, 0xB5, + 0x4C, 0xB9, 0x44, 0x67, 0x33, 0xCB, 0x7C, 0x71, + 0x72, 0x13, 0xDA, 0xBC, 0x7F, 0xF3, 0x97, 0xA4, + 0xB9, 0xEA, 0xFC, 0xE4, 0x89, 0x32, 0x2F, 0xEC + }, + { + 0x08, 0x27, 0x10, 0xBD, 0xDB, 0x53, 0x0C, 0x17, + 0xDE, 0xA4, 0x4C, 0x11, 0x80, 0x99, 0x7E, 0x6F, + 0xA3, 0xC8, 0xF8, 0x7A, 0x69, 0x08, 0x1A, 0x3E, + 0x67, 0xA7, 0x3D, 0xB4, 0xB6, 0x29, 0x66, 0x16, + 0xA0, 0x0A, 0x58, 0xF7, 0x9A, 0x41, 0x0C, 0xA0, + 0x9F, 0x21, 0xB3, 0xC6, 0x6F, 0x02, 0xB9, 0x99, + 0x78, 0x92, 0x9D, 0x1F, 0x4C, 0x03, 0x8F, 0xBF, + 0x4A, 0x8F, 0x27, 0xF6, 0x0D, 0x4F, 0x1E, 0x8D + }, + { + 0xE3, 0x60, 0x4E, 0x0E, 0x9E, 0x83, 0x2E, 0x3B, + 0xEA, 0x33, 0xD1, 0xD3, 0x4B, 0x99, 0xCE, 0xC3, + 0x9D, 0x12, 0x4C, 0xFC, 0x87, 0xBC, 0xCF, 0xE2, + 0xAE, 0xE6, 0xE0, 0x19, 0x42, 0xD4, 0x7E, 0x02, + 0xA9, 0xA1, 0xB3, 0xE2, 0xE6, 0xC8, 0x86, 0x3F, + 0x30, 0x8F, 0xF1, 0x81, 0x2D, 0xA3, 0x9B, 0x0E, + 0x9E, 0xB0, 0x74, 0x5B, 0x0C, 0x6A, 0xB6, 0xB1, + 0xA4, 0x1A, 0xB5, 0x8D, 0xCE, 0x05, 0xC7, 0x5F + }, + { + 0x8E, 0x7E, 0x14, 0xBD, 0x30, 0x37, 0x3F, 0x45, + 0x83, 0x09, 0xF0, 0x5F, 0xD6, 0xF7, 0x95, 0x64, + 0x67, 0x2E, 0x8E, 0x11, 0x11, 0x6D, 0xB3, 0xEA, + 0xFC, 0xA4, 0x41, 0xE3, 0x01, 0xA3, 0x57, 0x42, + 0xFC, 0x82, 0x9E, 0xDC, 0xE7, 0x73, 0xD5, 0x66, + 0xF7, 0x4F, 0x4E, 0x5D, 0x63, 0x61, 0xFE, 0xDA, + 0x12, 0xDE, 0x66, 0xA6, 0xF6, 0x82, 0xE3, 0x56, + 0xAC, 0x6B, 0xA0, 0x06, 0x02, 0x31, 0xB5, 0xC5 + }, + { + 0xD0, 0x77, 0x6F, 0x7A, 0x11, 0x98, 0xC4, 0x73, + 0x07, 0xF9, 0x0A, 0xFA, 0x1C, 0x65, 0xD2, 0xEE, + 0x58, 0x5B, 0x9E, 0xFB, 0x9A, 0x54, 0xE6, 0x30, + 0x99, 0x26, 0xED, 0x19, 0x65, 0x9A, 0x28, 0x41, + 0x67, 0x23, 0x60, 0x76, 0x09, 0xED, 0xF6, 0x55, + 0x6D, 0xC1, 0xFE, 0xF0, 0x36, 0xF9, 0x97, 0xBF, + 0x33, 0x1C, 0xF5, 0x24, 0xCB, 0x36, 0x5D, 0x5F, + 0x96, 0x32, 0x21, 0x0B, 0xF5, 0xEF, 0xF2, 0x83 + }, + { + 0x06, 0x7B, 0xCC, 0x5A, 0x09, 0x7F, 0x30, 0xA4, + 0x13, 0xAA, 0x02, 0xA3, 0x86, 0x12, 0x0A, 0xCF, + 0xCF, 0xB3, 0x54, 0x64, 0x2C, 0x9E, 0x1E, 0xE3, + 0x1F, 0x45, 0x73, 0xE1, 0xE3, 0xF6, 0x83, 0x2C, + 0x4A, 0x0A, 0x04, 0x0C, 0x8A, 0x8D, 0xD6, 0xF3, + 0xC1, 0xDC, 0x24, 0x34, 0x0D, 0x28, 0x4B, 0xCA, + 0x36, 0xCC, 0x19, 0x4B, 0x4D, 0xB6, 0x7E, 0x8F, + 0x97, 0xAB, 0x89, 0x32, 0x27, 0xA8, 0xB7, 0x1F + }, + { + 0x2A, 0x08, 0x13, 0x52, 0xEE, 0xC7, 0xB9, 0xB9, + 0xCC, 0xF8, 0xC2, 0xEF, 0x34, 0x78, 0xF1, 0x61, + 0x5A, 0x74, 0x48, 0xFE, 0x7F, 0x11, 0xBE, 0x67, + 0x3F, 0xB3, 0x40, 0x51, 0x66, 0x4A, 0x6F, 0x2F, + 0x25, 0xCB, 0xCB, 0x13, 0xAE, 0xA0, 0x40, 0x34, + 0xAD, 0xFE, 0x2A, 0x47, 0x63, 0x90, 0x71, 0x68, + 0xD8, 0xCA, 0xF1, 0xAD, 0xC0, 0xC0, 0x12, 0x77, + 0xF3, 0x22, 0x10, 0x48, 0x69, 0xFD, 0x5B, 0xFA + }, + { + 0x44, 0xBF, 0x41, 0x41, 0x3A, 0x57, 0xDB, 0x45, + 0x61, 0x57, 0x7F, 0x03, 0xBF, 0x1F, 0x71, 0xED, + 0x06, 0x60, 0x88, 0x19, 0x69, 0xB1, 0x87, 0x31, + 0x0E, 0x7A, 0x91, 0xC7, 0xB5, 0x70, 0x8D, 0x4C, + 0xD7, 0xB1, 0xBF, 0x2D, 0x1B, 0x18, 0xD2, 0x63, + 0x3E, 0x3F, 0x70, 0x7A, 0x2C, 0x43, 0x88, 0x03, + 0x39, 0x27, 0x73, 0x49, 0xB4, 0xC3, 0xF0, 0x25, + 0x01, 0x1A, 0xB6, 0x48, 0x16, 0x20, 0xEB, 0xF7 + }, + { + 0xBD, 0xBE, 0xED, 0xC2, 0x9D, 0x7B, 0x19, 0xC5, + 0x9E, 0x41, 0xCA, 0x1E, 0x1B, 0xCF, 0xC8, 0x79, + 0x4D, 0x85, 0xF6, 0x4E, 0x6F, 0xE2, 0x77, 0xD4, + 0x4D, 0x85, 0xB8, 0x2F, 0x33, 0xA2, 0x7C, 0x8A, + 0xA3, 0x1E, 0x3F, 0x43, 0x93, 0xC8, 0xF4, 0x54, + 0xF6, 0xFB, 0xC8, 0x59, 0x98, 0x1D, 0xCA, 0x42, + 0xAE, 0x54, 0x36, 0x9E, 0x76, 0x01, 0x4D, 0x9E, + 0xA8, 0x59, 0xEC, 0xE4, 0x2C, 0x91, 0xB4, 0x2F + }, + { + 0x19, 0x30, 0xFE, 0xC7, 0x2B, 0x72, 0x9B, 0xC8, + 0xA6, 0xB1, 0x53, 0x27, 0xDB, 0x49, 0x13, 0x7D, + 0xDF, 0x23, 0x5E, 0x45, 0x45, 0x6B, 0x76, 0x65, + 0xF4, 0x5E, 0x3B, 0x40, 0x3F, 0xE3, 0xD2, 0x3B, + 0xBF, 0xB8, 0xE7, 0x9D, 0xB4, 0xDE, 0xD6, 0x0F, + 0xA1, 0xDC, 0xA7, 0x04, 0x72, 0x4F, 0x1B, 0x82, + 0x29, 0x4F, 0xD5, 0x19, 0xDE, 0xE8, 0xC5, 0x36, + 0xBC, 0x67, 0xE3, 0x99, 0x30, 0x19, 0x48, 0xF4 + }, + { + 0xA1, 0xEE, 0xB6, 0xDA, 0x13, 0x19, 0xBD, 0x05, + 0x33, 0xC7, 0x61, 0xC7, 0x4C, 0x18, 0xB0, 0xBA, + 0x1E, 0xD8, 0x2F, 0x1C, 0xC5, 0xEB, 0x8E, 0x5F, + 0x76, 0x7E, 0x9D, 0x15, 0x9C, 0x5E, 0x8C, 0xD0, + 0x8C, 0x2A, 0xBB, 0x87, 0xBE, 0x22, 0x52, 0x26, + 0x9B, 0xEE, 0x5A, 0x43, 0x99, 0xF1, 0x8F, 0x64, + 0x3C, 0x51, 0xA7, 0x49, 0x83, 0x8B, 0x09, 0x98, + 0xDC, 0xFB, 0x58, 0x61, 0x11, 0x7A, 0x19, 0x09 + }, + { + 0x02, 0xB0, 0xA8, 0x09, 0xF7, 0x47, 0xED, 0xAC, + 0x48, 0xC4, 0x89, 0x37, 0x60, 0xB3, 0xF9, 0x65, + 0xD0, 0xB3, 0xE0, 0x9A, 0x00, 0xB8, 0x4A, 0xFE, + 0xC0, 0xCD, 0x91, 0x3D, 0x03, 0x96, 0x78, 0xB9, + 0x2A, 0x27, 0xA7, 0x33, 0xA7, 0xD6, 0x68, 0x78, + 0xDB, 0xAA, 0xBB, 0x1C, 0xB4, 0x06, 0xDA, 0x3F, + 0xA5, 0x1D, 0x5C, 0x9D, 0xCB, 0x7E, 0x2D, 0xAC, + 0xA6, 0x8E, 0x56, 0x72, 0xCC, 0x0E, 0xD9, 0x48 + }, + { + 0xC9, 0xFB, 0xA4, 0xE4, 0xB5, 0xA4, 0xED, 0xBD, + 0x6C, 0x2A, 0x31, 0x6C, 0x77, 0x29, 0x33, 0x60, + 0xA0, 0x7E, 0x2D, 0xFC, 0x48, 0xBD, 0xE9, 0xCF, + 0x68, 0x40, 0xAF, 0x6B, 0xCD, 0x75, 0xF0, 0xFA, + 0x64, 0xF9, 0xC8, 0x4D, 0xE3, 0x5C, 0x2C, 0x9F, + 0x26, 0xE7, 0x49, 0xB8, 0x44, 0x3A, 0x60, 0xAD, + 0x2E, 0x84, 0x16, 0x38, 0xF6, 0xA7, 0x54, 0xCC, + 0x38, 0xA5, 0x86, 0xD9, 0xFB, 0xAC, 0xCC, 0x92 + }, + { + 0x7A, 0x92, 0x0A, 0x13, 0x8A, 0x32, 0x80, 0xC2, + 0x92, 0xCB, 0x83, 0x3B, 0x7B, 0xB8, 0x07, 0x3C, + 0x33, 0x1B, 0x0B, 0x40, 0xD5, 0xBA, 0x09, 0x98, + 0x3C, 0x08, 0x49, 0x7F, 0x03, 0xA5, 0xBA, 0x21, + 0x1B, 0xAE, 0xFE, 0xF8, 0xC3, 0x50, 0xBA, 0xC9, + 0xC7, 0x97, 0x59, 0x61, 0x05, 0x9F, 0x31, 0x81, + 0xF4, 0x33, 0x9A, 0x50, 0x45, 0x4B, 0xC9, 0x1B, + 0x09, 0x4A, 0x3D, 0x5E, 0xF7, 0x78, 0x4E, 0xDB + }, + { + 0xBB, 0x0D, 0xA1, 0xCE, 0xA6, 0x7F, 0x49, 0x20, + 0x03, 0xEB, 0xB6, 0xF2, 0xED, 0xFF, 0xB2, 0xBE, + 0xE1, 0xC5, 0xE4, 0xF6, 0x28, 0x73, 0x03, 0x61, + 0x23, 0x03, 0x91, 0x75, 0xF2, 0x5C, 0xDC, 0xB9, + 0xC2, 0xC3, 0x72, 0x49, 0xFD, 0x11, 0x66, 0xE1, + 0x56, 0xAF, 0xB2, 0x71, 0x7E, 0x84, 0x55, 0x3C, + 0x97, 0xA0, 0x62, 0xAC, 0x2A, 0xF6, 0x93, 0xBA, + 0x5B, 0x9E, 0xC7, 0x0B, 0xAC, 0x65, 0x1D, 0x13 + }, + { + 0x5E, 0x3E, 0x6C, 0xBA, 0xCA, 0x6F, 0x29, 0x40, + 0xFB, 0x2D, 0xBF, 0x4B, 0x59, 0xC1, 0xA0, 0xA3, + 0xFF, 0x39, 0xCB, 0x17, 0xA2, 0xEB, 0x53, 0x00, + 0xCC, 0x67, 0x4E, 0x2D, 0xB1, 0x3B, 0xD5, 0xFF, + 0x78, 0x4E, 0xDD, 0x3B, 0xCC, 0x04, 0x0B, 0x76, + 0xDF, 0x1C, 0x4E, 0xC7, 0x9B, 0x43, 0x41, 0x54, + 0xE4, 0xAE, 0x71, 0x07, 0x03, 0x26, 0x59, 0x77, + 0x4B, 0xC3, 0xB8, 0x8A, 0xB8, 0xDD, 0x83, 0x0A + }, + { + 0x56, 0xFD, 0x39, 0x28, 0x6C, 0x69, 0x63, 0xC5, + 0xF8, 0xD1, 0xF1, 0x1A, 0x4D, 0xE0, 0x91, 0x51, + 0xB3, 0x34, 0xEF, 0x1C, 0xA0, 0x98, 0xC8, 0x19, + 0x14, 0xFE, 0xE8, 0x41, 0x13, 0x29, 0xDF, 0xA3, + 0x7B, 0x12, 0xFE, 0x4B, 0x96, 0x95, 0x79, 0x67, + 0x9C, 0x4E, 0x69, 0x18, 0x98, 0xBF, 0x76, 0xEC, + 0xEF, 0x7B, 0xAD, 0x47, 0x87, 0x0B, 0xDC, 0xD0, + 0x44, 0xCA, 0xCD, 0x1B, 0x14, 0x0E, 0x6E, 0x60 + }, + { + 0x25, 0x92, 0x29, 0x59, 0xE3, 0xE2, 0x5F, 0x14, + 0x38, 0x38, 0xC6, 0xBE, 0x66, 0xF1, 0xF5, 0xAC, + 0x98, 0x35, 0xE4, 0xD7, 0x60, 0x38, 0x30, 0xC4, + 0x6D, 0x1C, 0x28, 0x2A, 0xF6, 0x15, 0x06, 0xA9, + 0xAC, 0x03, 0x6A, 0x67, 0x21, 0x1A, 0x33, 0x5F, + 0x40, 0xAF, 0x60, 0x33, 0xD7, 0x87, 0xD4, 0xF9, + 0x0B, 0xE7, 0x0B, 0xD2, 0xCE, 0xAD, 0x42, 0x48, + 0xE5, 0xF4, 0x47, 0x1F, 0x10, 0x4E, 0x96, 0xD8 + }, + { + 0x5D, 0xD8, 0x3B, 0x44, 0xF0, 0x82, 0xE2, 0x61, + 0xD6, 0x58, 0x6F, 0xAF, 0x95, 0xBA, 0x62, 0x81, + 0x84, 0xAE, 0xE4, 0x12, 0x28, 0x71, 0x86, 0xB2, + 0x6C, 0x6D, 0x59, 0x8D, 0xAD, 0x8D, 0xD0, 0x85, + 0x62, 0x26, 0x26, 0x80, 0x5B, 0x3E, 0x42, 0xE6, + 0x17, 0x7A, 0xC9, 0xE6, 0x3E, 0xB7, 0xEB, 0x8A, + 0x1D, 0xC6, 0x03, 0x29, 0x91, 0xC6, 0x98, 0x2C, + 0x7C, 0x13, 0x6D, 0x89, 0xFB, 0xF8, 0x1E, 0xD5 + }, + { + 0x56, 0x8E, 0x82, 0xE8, 0x42, 0xF5, 0x9D, 0xFC, + 0x73, 0x3F, 0xEA, 0x8C, 0x03, 0x88, 0x32, 0xFE, + 0x77, 0x62, 0x76, 0xC1, 0x1B, 0xA9, 0x68, 0x9E, + 0x73, 0xA7, 0xBE, 0x76, 0x8D, 0x5A, 0xB5, 0x82, + 0x65, 0xFD, 0xF6, 0x43, 0xA3, 0xBA, 0x66, 0xFE, + 0x5D, 0x58, 0x20, 0xD4, 0xA3, 0x88, 0x0C, 0x74, + 0x7E, 0x9E, 0x1F, 0x1A, 0x7B, 0x51, 0x36, 0x74, + 0x08, 0x88, 0x15, 0xB8, 0x30, 0xBE, 0xA3, 0x13 + }, + { + 0xC7, 0xC7, 0xAF, 0x27, 0x5E, 0x98, 0xB0, 0x34, + 0x3B, 0x99, 0x6D, 0xDC, 0xD8, 0x63, 0xA2, 0x1C, + 0x4D, 0xA2, 0x54, 0xE2, 0xAE, 0x44, 0x1C, 0x2E, + 0x71, 0xC2, 0x2F, 0x65, 0x34, 0xAC, 0xD1, 0x3F, + 0xB4, 0x1C, 0x9C, 0x20, 0x0C, 0x66, 0xDD, 0x6B, + 0xB6, 0x06, 0xF5, 0x9D, 0x2E, 0xF8, 0x32, 0xBA, + 0x7E, 0x45, 0xFA, 0xAB, 0x85, 0xBC, 0x9B, 0x39, + 0xD0, 0x25, 0xEE, 0xF1, 0xA2, 0x10, 0x74, 0xBD + }, + { + 0xFA, 0x8D, 0x42, 0xDB, 0x84, 0xFB, 0x75, 0xA0, + 0x63, 0x3F, 0x23, 0xA0, 0x04, 0x08, 0x25, 0xBD, + 0x10, 0x7C, 0xE7, 0x48, 0x8B, 0xF5, 0xB7, 0x05, + 0x16, 0x1F, 0xF3, 0xB1, 0x3E, 0xFF, 0x58, 0x6D, + 0x23, 0xC4, 0x20, 0xC4, 0x16, 0xDE, 0xC8, 0x27, + 0xD6, 0x78, 0x14, 0x50, 0x24, 0x5E, 0x3A, 0xEC, + 0xA9, 0x63, 0x06, 0xF1, 0xAA, 0x99, 0xF4, 0xC0, + 0xD9, 0x97, 0xCE, 0xC1, 0xAC, 0x47, 0xAB, 0xDC + }, + { + 0x7D, 0x54, 0xC7, 0xA4, 0x68, 0x85, 0x3B, 0x81, + 0xE4, 0x43, 0x79, 0x81, 0x4F, 0x2D, 0x5F, 0x66, + 0xB1, 0x86, 0x54, 0x4F, 0xF3, 0x65, 0x45, 0xD4, + 0xD3, 0x72, 0xDE, 0x7F, 0x67, 0xD4, 0xC5, 0x10, + 0x28, 0x88, 0xA8, 0x77, 0xBC, 0xC1, 0xCC, 0x3C, + 0x7E, 0xA2, 0x24, 0xA1, 0x83, 0xC2, 0xC4, 0x8F, + 0x6B, 0x99, 0xCE, 0x6E, 0x00, 0x06, 0x4A, 0x2D, + 0xFF, 0x75, 0x3F, 0xDB, 0x2E, 0x91, 0x94, 0x4D + }, + { + 0x48, 0x37, 0x3E, 0x5D, 0xB8, 0xFC, 0x47, 0x45, + 0xC8, 0x16, 0xCA, 0x75, 0x9A, 0x8E, 0xEC, 0xC7, + 0x50, 0x7C, 0x5E, 0xAD, 0x16, 0xF1, 0xC8, 0xFF, + 0x22, 0xBC, 0xA3, 0xE8, 0x77, 0x75, 0x21, 0x5B, + 0x52, 0x91, 0x69, 0x4E, 0x77, 0x3C, 0x25, 0x99, + 0x3F, 0x89, 0x41, 0xDC, 0xF8, 0x83, 0x68, 0xE7, + 0xA6, 0x69, 0x61, 0x30, 0x69, 0x1B, 0x9B, 0x06, + 0x15, 0xE0, 0xB9, 0x01, 0xF8, 0x73, 0x75, 0x77 + }, + { + 0xC8, 0x19, 0x57, 0x1F, 0x23, 0x33, 0x76, 0xCA, + 0xFB, 0x5F, 0x35, 0x0C, 0xF9, 0x31, 0xF2, 0x34, + 0x6A, 0xF9, 0xCB, 0x37, 0xB3, 0xF7, 0x91, 0x11, + 0xB3, 0x5B, 0x3D, 0x0A, 0x1C, 0x9C, 0x58, 0xFF, + 0xE0, 0xF1, 0x78, 0xF4, 0x7A, 0xAF, 0x60, 0xDD, + 0xBC, 0x05, 0xD8, 0xFA, 0x31, 0x81, 0xD4, 0x66, + 0x1E, 0xDC, 0xC3, 0x34, 0x57, 0xBD, 0xA4, 0xDB, + 0xE4, 0xF4, 0x37, 0xE3, 0x5B, 0x04, 0xA4, 0x75 + }, + { + 0x28, 0x67, 0xB1, 0x72, 0x40, 0xA1, 0x09, 0x79, + 0xFF, 0x74, 0x25, 0x83, 0x46, 0x1F, 0x98, 0x83, + 0x2E, 0x5D, 0x75, 0xDE, 0x03, 0x1E, 0x0A, 0x02, + 0x40, 0xA2, 0x68, 0xCB, 0x3B, 0x9A, 0x91, 0x06, + 0xEC, 0x36, 0xC3, 0xB8, 0x03, 0x24, 0xFC, 0xB5, + 0x91, 0x59, 0xA9, 0xA4, 0x53, 0xCF, 0x5F, 0xCC, + 0x62, 0x8B, 0x86, 0xFD, 0xBD, 0x68, 0x15, 0xB1, + 0xB3, 0x40, 0x30, 0xDA, 0xAF, 0x5D, 0x65, 0xFA + }, + { + 0xF0, 0xCE, 0xA5, 0x74, 0x0D, 0x75, 0xC5, 0x49, + 0x0A, 0x06, 0xA4, 0x67, 0x06, 0x35, 0x67, 0xE9, + 0x8D, 0xCC, 0x85, 0x6E, 0x3C, 0x53, 0x6D, 0x95, + 0x12, 0x65, 0x62, 0x89, 0x8D, 0xF9, 0x7F, 0x69, + 0xD3, 0x9D, 0x0D, 0x18, 0x3B, 0x9A, 0x1E, 0x0E, + 0x27, 0x50, 0x64, 0x65, 0x0F, 0x33, 0x97, 0xB3, + 0x24, 0xC6, 0x9B, 0x92, 0x8E, 0x03, 0xC1, 0x82, + 0xB7, 0xB3, 0xA5, 0xED, 0xBB, 0x56, 0x25, 0xD4 + }, + { + 0x41, 0x54, 0x1B, 0xA1, 0x8D, 0x65, 0x8C, 0xA1, + 0x79, 0x08, 0x15, 0x3C, 0x45, 0xA3, 0x49, 0x4A, + 0xA5, 0x00, 0x8A, 0xBC, 0x0B, 0x3B, 0xB9, 0x6D, + 0x96, 0x01, 0x13, 0x5C, 0xCD, 0xF0, 0xEE, 0x17, + 0x1E, 0x58, 0xA2, 0xBF, 0x45, 0x7F, 0xDE, 0x39, + 0x58, 0xB5, 0x91, 0x02, 0x00, 0xE0, 0x18, 0x3A, + 0x8E, 0xE9, 0xA2, 0x60, 0xDA, 0xEF, 0xAF, 0xB8, + 0xBD, 0x91, 0xED, 0xE6, 0xB5, 0x05, 0x5F, 0x15 + }, + { + 0x3A, 0x2D, 0x97, 0x2D, 0x39, 0x83, 0x43, 0xB6, + 0xEB, 0x00, 0x92, 0xE6, 0x9D, 0x91, 0x9E, 0xE7, + 0xD7, 0x0A, 0xB4, 0xF4, 0x0F, 0xCE, 0xB0, 0x62, + 0xCF, 0xA1, 0xE1, 0x91, 0x05, 0x2E, 0x7F, 0xBA, + 0x70, 0x08, 0xA7, 0x9E, 0x56, 0x43, 0x11, 0x9F, + 0x8B, 0x1D, 0x81, 0x37, 0x0D, 0x78, 0x5D, 0x90, + 0x32, 0x3F, 0x76, 0xA7, 0x01, 0x74, 0xD0, 0xFE, + 0x70, 0x6C, 0x7B, 0x07, 0x24, 0x93, 0x6D, 0x0C + }, + { + 0xB5, 0x9C, 0xED, 0xE1, 0xCB, 0x57, 0x94, 0x9E, + 0xAF, 0x97, 0xBF, 0xB7, 0xB3, 0x4B, 0x6C, 0x78, + 0xC9, 0x48, 0xE0, 0xAF, 0x41, 0x6E, 0x9F, 0xF4, + 0x2A, 0x59, 0xB4, 0x85, 0x86, 0x11, 0xB5, 0x89, + 0xD1, 0xB1, 0x41, 0x93, 0x80, 0xA4, 0xE5, 0x5B, + 0xC6, 0x25, 0x46, 0xFB, 0x76, 0x8C, 0x37, 0x07, + 0x87, 0x5D, 0x0D, 0xF1, 0x40, 0x07, 0xA2, 0x1F, + 0x95, 0x1C, 0xA1, 0x08, 0x22, 0x35, 0x58, 0x72 + }, + { + 0xD5, 0x33, 0xA0, 0x7A, 0xCD, 0x63, 0x57, 0xA3, + 0x9F, 0x37, 0xDD, 0x4F, 0x3E, 0xE2, 0x77, 0x6E, + 0xE4, 0xBE, 0xBE, 0x6C, 0xD2, 0x94, 0xED, 0x2A, + 0x77, 0xD1, 0x86, 0x7D, 0x61, 0x0A, 0xDA, 0x2C, + 0x88, 0xBE, 0x60, 0x9C, 0x7D, 0x8E, 0x9B, 0xE6, + 0xEA, 0x2D, 0xD1, 0xCD, 0x37, 0x9B, 0xDE, 0x17, + 0x69, 0x42, 0xE9, 0xB5, 0x7E, 0x85, 0x21, 0xE7, + 0x20, 0x00, 0xE1, 0x7A, 0x40, 0x78, 0xD4, 0x4C + }, + { + 0x40, 0x4A, 0x97, 0x1B, 0x48, 0xBF, 0x8C, 0x1F, + 0x5A, 0x2F, 0x52, 0x2E, 0x9B, 0x0C, 0xC0, 0x1C, + 0x73, 0xC7, 0xEF, 0x32, 0xEB, 0x3E, 0xF7, 0x2E, + 0xE8, 0x70, 0xBC, 0x33, 0x44, 0x17, 0x69, 0xE4, + 0xC9, 0x30, 0x2F, 0xC1, 0xE7, 0x39, 0xB3, 0x70, + 0x9C, 0xF6, 0xDA, 0xF8, 0x83, 0x66, 0x29, 0x3F, + 0x14, 0xAB, 0x5A, 0x5B, 0x79, 0xD9, 0xDE, 0xC8, + 0x34, 0xED, 0xCE, 0x38, 0xD4, 0x62, 0xA8, 0x18 + }, + { + 0x0C, 0xE6, 0x45, 0x97, 0xB8, 0x96, 0x18, 0x18, + 0x15, 0x6C, 0x20, 0xE8, 0x81, 0xBA, 0x63, 0x2F, + 0xDB, 0xB8, 0xC9, 0xBE, 0x8F, 0xD9, 0xF5, 0x6A, + 0xD1, 0x2B, 0xB4, 0x3C, 0x7C, 0x86, 0x66, 0x81, + 0x8F, 0x3B, 0x16, 0xC2, 0x11, 0x97, 0xC7, 0xF4, + 0xE2, 0x58, 0x5F, 0x72, 0xAF, 0x8C, 0x5E, 0x44, + 0x13, 0xB9, 0xAE, 0x24, 0xED, 0x1C, 0x0C, 0xB8, + 0x53, 0xEE, 0x8C, 0xD1, 0x16, 0x8F, 0xD9, 0xB9 + }, + { + 0xD1, 0x1C, 0x43, 0x1A, 0xD8, 0x61, 0x5A, 0xAF, + 0x34, 0xBF, 0x88, 0xB2, 0xE2, 0x97, 0x74, 0x32, + 0x5D, 0x3B, 0x85, 0x3E, 0xF5, 0xB1, 0x97, 0xB1, + 0x0E, 0x61, 0x2B, 0x30, 0xC8, 0xB1, 0x93, 0xF9, + 0xE5, 0xF4, 0x85, 0xD9, 0xC7, 0x8E, 0x48, 0x24, + 0x65, 0xF0, 0xD4, 0xCC, 0x35, 0x29, 0x03, 0x4F, + 0xC9, 0x5F, 0xF0, 0x11, 0xBD, 0x5A, 0x93, 0x10, + 0x74, 0x67, 0xC4, 0x9F, 0x5E, 0xA9, 0x6C, 0x6D + }, + { + 0x23, 0xBB, 0x31, 0x46, 0xF8, 0xA3, 0x5D, 0x62, + 0xB7, 0x66, 0x37, 0xD0, 0x8C, 0x84, 0x82, 0x01, + 0x03, 0x7F, 0x87, 0xC8, 0x7D, 0x37, 0x14, 0xAA, + 0xB1, 0x25, 0x6A, 0x38, 0xDF, 0x75, 0x5D, 0x2C, + 0xA2, 0x66, 0xD9, 0x1A, 0x3F, 0xC4, 0x92, 0x80, + 0x91, 0xC2, 0xB4, 0x11, 0xA0, 0x40, 0x57, 0xAD, + 0xC6, 0x56, 0x36, 0xEE, 0x6F, 0xFC, 0x1D, 0x42, + 0x1A, 0x54, 0xE8, 0xC0, 0x73, 0xB5, 0xD6, 0x93 + }, + { + 0xCB, 0x04, 0xF1, 0xF0, 0x2A, 0x70, 0xEF, 0xA0, + 0xF2, 0x71, 0x93, 0x5F, 0x5C, 0x70, 0x47, 0x3B, + 0x17, 0xF9, 0x78, 0xAD, 0xA6, 0x50, 0xB0, 0x87, + 0x5D, 0x53, 0x9A, 0x12, 0xB7, 0x45, 0xCF, 0x6D, + 0x83, 0x7F, 0xB6, 0x81, 0x6A, 0x36, 0xF7, 0x0F, + 0x3F, 0xE7, 0xC2, 0xF3, 0xA3, 0xDE, 0xF3, 0x99, + 0x00, 0x87, 0xDB, 0x23, 0x83, 0x07, 0x68, 0x71, + 0xC0, 0x44, 0x3C, 0x96, 0xC5, 0x26, 0x2D, 0xFF + }, + { + 0x17, 0x51, 0x91, 0x2E, 0x9C, 0x78, 0x78, 0x56, + 0x1C, 0x21, 0x23, 0xE4, 0xFB, 0x42, 0x5D, 0x83, + 0xF1, 0x0F, 0xF8, 0x96, 0x27, 0x23, 0x45, 0xC0, + 0x4F, 0xDA, 0x95, 0xF9, 0x43, 0xC9, 0xC9, 0xC8, + 0xAC, 0x3D, 0x13, 0xFF, 0xF9, 0x44, 0xC5, 0x25, + 0x6B, 0x2C, 0x42, 0xC0, 0x67, 0xAB, 0x85, 0x2B, + 0x4F, 0x27, 0x59, 0xD9, 0x95, 0xDD, 0x00, 0xE5, + 0xBD, 0x85, 0xC7, 0xE6, 0xB9, 0xCC, 0x92, 0xEA + }, + { + 0x40, 0x99, 0xC6, 0xD4, 0xE1, 0x77, 0xCB, 0xFA, + 0xC7, 0x3C, 0x30, 0x90, 0xCE, 0xB3, 0x16, 0x94, + 0x53, 0x0A, 0x37, 0xC6, 0xEA, 0x4F, 0x0F, 0x60, + 0x59, 0x80, 0xD1, 0xDA, 0xC9, 0x0E, 0x11, 0x78, + 0x4B, 0xBF, 0xD3, 0x81, 0x6B, 0x12, 0x30, 0xDF, + 0x11, 0x8F, 0xB0, 0xBF, 0xB0, 0xA3, 0x49, 0xDF, + 0x79, 0x62, 0x6D, 0xA9, 0x58, 0x60, 0x97, 0x74, + 0x61, 0xAA, 0xDB, 0xE9, 0x35, 0xDE, 0x62, 0x65 + }, + { + 0x10, 0x69, 0x3A, 0x4A, 0xFB, 0x5B, 0x65, 0x8C, + 0xBC, 0xE2, 0x56, 0xA9, 0x35, 0xDB, 0xAD, 0x83, + 0x92, 0x4B, 0x70, 0x64, 0x51, 0xDB, 0x8F, 0x1D, + 0xD3, 0xAA, 0x77, 0xCB, 0x03, 0xCF, 0x80, 0xC8, + 0x35, 0xDB, 0x50, 0xA9, 0x7A, 0x58, 0x29, 0x6D, + 0x4F, 0x81, 0xD4, 0xF6, 0xB2, 0x00, 0xBA, 0xA5, + 0xF2, 0x73, 0xA0, 0xC7, 0x03, 0xCC, 0xB6, 0xCC, + 0xF6, 0x1B, 0x49, 0x31, 0x66, 0x9A, 0xA8, 0x6D + }, + { + 0x97, 0xFC, 0x91, 0x93, 0xA9, 0x33, 0x85, 0xAF, + 0xC7, 0x8F, 0x56, 0xD8, 0x9C, 0xE4, 0xA5, 0x2A, + 0x69, 0x8C, 0x85, 0x93, 0xA1, 0x25, 0xDD, 0xC8, + 0x6A, 0x60, 0xD4, 0x43, 0x7F, 0xBE, 0x7C, 0x0E, + 0x57, 0x79, 0x2E, 0x9A, 0x24, 0xDE, 0xF1, 0x04, + 0x08, 0x70, 0x5C, 0xE0, 0x79, 0xD6, 0xDB, 0x62, + 0xBA, 0xCA, 0x26, 0xBA, 0x53, 0x89, 0x92, 0xCE, + 0x43, 0xA8, 0xA3, 0xBC, 0xD7, 0xB2, 0xCB, 0x2C + }, + { + 0x91, 0x11, 0x3D, 0x7B, 0x6E, 0xB3, 0xBD, 0x49, + 0x75, 0x91, 0xB0, 0xBB, 0x18, 0x9C, 0x42, 0x66, + 0x76, 0x06, 0x34, 0x33, 0x3A, 0x09, 0x33, 0x9F, + 0x44, 0xE2, 0x57, 0x23, 0xA8, 0x81, 0x4F, 0x70, + 0xC5, 0x37, 0x75, 0xD4, 0xE3, 0x85, 0xFC, 0xDB, + 0x98, 0x1C, 0x4B, 0xBE, 0x5A, 0x22, 0x6D, 0x04, + 0x1C, 0xA6, 0x3C, 0xE7, 0x2B, 0x6F, 0x71, 0xD2, + 0x86, 0x1B, 0xB0, 0x37, 0xD0, 0x83, 0xF7, 0x38 + }, + { + 0xB0, 0xBE, 0xD6, 0xC2, 0xF7, 0x37, 0x5C, 0xA8, + 0x9A, 0x3F, 0x1D, 0x50, 0xF9, 0x4D, 0x2E, 0x9B, + 0x44, 0x12, 0x62, 0xF4, 0x3E, 0x15, 0x63, 0x7A, + 0xE8, 0x7B, 0xDD, 0xF4, 0xE8, 0xDE, 0x1A, 0xD0, + 0xF8, 0x2D, 0xF8, 0x01, 0xF3, 0xF9, 0xAD, 0x92, + 0xC2, 0x50, 0xB4, 0x75, 0x93, 0x7C, 0xEB, 0xDE, + 0xBD, 0x31, 0x9E, 0xF3, 0x17, 0x32, 0x9C, 0x2F, + 0xB1, 0x66, 0xB5, 0x84, 0x1B, 0x9A, 0xB1, 0xF7 + }, + { + 0xCB, 0x93, 0x6E, 0x14, 0xD7, 0x3C, 0x3F, 0xE8, + 0x3C, 0x1C, 0x95, 0xCD, 0x91, 0x02, 0x95, 0x61, + 0xCA, 0x18, 0xAF, 0xA0, 0xE3, 0x88, 0x26, 0x0F, + 0xF3, 0x64, 0x95, 0x94, 0x7B, 0xE6, 0x91, 0x89, + 0x69, 0x33, 0xEA, 0xC2, 0x1D, 0xDF, 0xFD, 0x02, + 0x18, 0xBF, 0x19, 0x9B, 0xA1, 0xF6, 0x7E, 0x5F, + 0xFC, 0x0A, 0xFB, 0xF8, 0xFE, 0xC9, 0xBB, 0x1A, + 0x93, 0xDB, 0x43, 0x70, 0x7F, 0x23, 0xB7, 0xB7 + }, + { + 0xA3, 0x5F, 0xFE, 0xD2, 0xE0, 0x98, 0x78, 0xC1, + 0x2C, 0xE1, 0xB6, 0x4B, 0x80, 0x27, 0x60, 0x76, + 0xC9, 0xA1, 0x7C, 0x02, 0x9B, 0x91, 0xD5, 0xF4, + 0x52, 0xA6, 0x5E, 0x41, 0x3F, 0x60, 0xFA, 0xE0, + 0x41, 0x91, 0x51, 0x84, 0xBC, 0x7F, 0x3D, 0xC1, + 0xDA, 0x85, 0x74, 0xD5, 0x90, 0x8B, 0xFD, 0xFF, + 0xAC, 0x4A, 0x5E, 0x11, 0x47, 0x4F, 0xB8, 0xD9, + 0xD6, 0x8D, 0x95, 0xA8, 0xA4, 0xD2, 0x58, 0xBA + }, + { + 0x03, 0x6B, 0x60, 0x23, 0x7C, 0x01, 0x26, 0xDC, + 0x08, 0x73, 0x88, 0xD5, 0xAD, 0xB8, 0x03, 0x69, + 0xFE, 0xED, 0x3C, 0x0C, 0x61, 0x86, 0x3C, 0xF9, + 0xE4, 0xD9, 0xF9, 0x15, 0xC5, 0x49, 0x7B, 0x13, + 0xD7, 0x4A, 0xA7, 0x52, 0x1F, 0x1A, 0x60, 0xF3, + 0x1D, 0x98, 0xCF, 0x0E, 0x2C, 0x04, 0x37, 0x45, + 0x10, 0x41, 0xF4, 0x09, 0x38, 0x19, 0x46, 0x7F, + 0x85, 0xBA, 0xAA, 0xC6, 0x97, 0x94, 0x51, 0x41 + }, + { + 0x53, 0x4F, 0xDE, 0x2C, 0xE4, 0x1A, 0x3C, 0x4E, + 0x0D, 0x59, 0x30, 0x5D, 0xC5, 0x81, 0x33, 0x7B, + 0xF7, 0xD2, 0x2A, 0xD0, 0xF5, 0x99, 0x7A, 0x56, + 0xE8, 0x89, 0xBD, 0x54, 0xE1, 0x38, 0x93, 0x34, + 0x41, 0xE9, 0xB8, 0x12, 0x7F, 0x4D, 0x3B, 0x2F, + 0xBE, 0x6C, 0x87, 0x20, 0x2A, 0x91, 0xC1, 0x84, + 0xEA, 0x60, 0xB5, 0x34, 0x09, 0xA4, 0x76, 0x9D, + 0xC2, 0x95, 0x0F, 0x59, 0xD5, 0xB6, 0xFC, 0x0D + }, + { + 0x38, 0x78, 0xDA, 0xF2, 0x7B, 0x0C, 0xE8, 0x08, + 0xC5, 0x84, 0x59, 0x2D, 0xC2, 0x9B, 0x4A, 0x51, + 0x6A, 0xF6, 0x6E, 0x64, 0xBE, 0x5C, 0x2C, 0x6A, + 0x6D, 0x21, 0xA0, 0xDB, 0x48, 0x98, 0x13, 0xD8, + 0xF4, 0x78, 0x1A, 0x02, 0x25, 0x05, 0xF2, 0x28, + 0x4F, 0xBB, 0x6A, 0xB1, 0x61, 0x57, 0xB9, 0xB8, + 0x26, 0x1C, 0xAF, 0x15, 0x30, 0xD3, 0x56, 0x48, + 0x5E, 0x4A, 0x71, 0xE9, 0x96, 0x13, 0x8E, 0xB6 + }, + { + 0x90, 0xA5, 0xE4, 0xDD, 0x2E, 0x1D, 0x31, 0xFA, + 0xE1, 0x91, 0x92, 0x81, 0xF5, 0x40, 0xBD, 0x2C, + 0xFC, 0x85, 0x1C, 0x83, 0xA6, 0x44, 0xB7, 0x57, + 0x65, 0x02, 0x59, 0xA7, 0xA5, 0x1E, 0x0B, 0xF6, + 0xB7, 0xDC, 0xD0, 0x09, 0x77, 0x31, 0x15, 0x27, + 0x89, 0x26, 0x25, 0x6C, 0x95, 0x23, 0xFB, 0x67, + 0xBF, 0xB3, 0x6C, 0xE2, 0x45, 0x95, 0x6F, 0x27, + 0x99, 0x5B, 0xAD, 0x21, 0x81, 0x55, 0x51, 0xE8 + }, + { + 0x62, 0xBD, 0x75, 0xD2, 0xD7, 0xA4, 0x6A, 0x23, + 0x1B, 0x20, 0x58, 0x01, 0x71, 0x26, 0xF7, 0xE2, + 0x2D, 0x55, 0x7F, 0x87, 0xB2, 0xBA, 0x1D, 0x3B, + 0x62, 0x31, 0x89, 0x00, 0x67, 0x95, 0xFB, 0xDD, + 0xC2, 0xFF, 0xF8, 0x1A, 0x29, 0xEB, 0xC6, 0x58, + 0x71, 0x52, 0x9E, 0x17, 0x07, 0x69, 0xFE, 0x76, + 0x89, 0x63, 0xB9, 0xA6, 0x6E, 0xCA, 0x35, 0x61, + 0xBE, 0xB4, 0x9F, 0xD6, 0x87, 0x1E, 0x8D, 0x5B + }, + { + 0x98, 0x37, 0x32, 0x66, 0xDE, 0x4E, 0x7D, 0xC6, + 0x12, 0x02, 0xFD, 0x82, 0xBC, 0xA7, 0x6B, 0x16, + 0x52, 0x5D, 0xBE, 0x42, 0x65, 0x9E, 0xA9, 0x52, + 0x67, 0x4E, 0x92, 0x0E, 0x4E, 0xA9, 0x6D, 0x35, + 0x3B, 0xEC, 0x73, 0x47, 0xFE, 0xB0, 0x61, 0xF6, + 0x86, 0x37, 0x11, 0xB1, 0xB5, 0xA1, 0x66, 0x2D, + 0xE9, 0x96, 0x17, 0x97, 0xF2, 0x29, 0xF1, 0x20, + 0x97, 0xC4, 0x85, 0x4F, 0xC0, 0x61, 0x21, 0xBE + }, + { + 0x1E, 0x51, 0x37, 0xF0, 0x8D, 0x78, 0x61, 0xA3, + 0x84, 0xD7, 0xA3, 0xEF, 0x56, 0x9B, 0x1C, 0x6B, + 0x2F, 0x78, 0x18, 0xCF, 0x4A, 0x35, 0x0D, 0x63, + 0xFB, 0x3E, 0x5F, 0xAA, 0x00, 0x7C, 0x6F, 0x7A, + 0x5D, 0xED, 0x58, 0xDF, 0xC0, 0xD1, 0xDD, 0x46, + 0x90, 0x55, 0xAB, 0x10, 0xD3, 0x04, 0xD3, 0x8D, + 0x87, 0x7B, 0x7E, 0xC5, 0xE5, 0x71, 0x50, 0xE3, + 0x6D, 0xD8, 0x69, 0xB2, 0xB8, 0x91, 0x14, 0xCF + }, + { + 0x86, 0x05, 0xC2, 0x69, 0x7B, 0x50, 0x0C, 0x46, + 0xC7, 0xD4, 0x98, 0xBC, 0x83, 0xB5, 0xF3, 0x09, + 0xED, 0x3E, 0x3A, 0xF8, 0xBC, 0x24, 0xA8, 0xFC, + 0xC2, 0xA2, 0x3D, 0x8C, 0xE8, 0xD1, 0xB2, 0x54, + 0xFB, 0x72, 0x9A, 0x37, 0xDA, 0x1A, 0xCF, 0x25, + 0x81, 0x0A, 0x4B, 0x93, 0x25, 0x0E, 0x84, 0xF6, + 0xBD, 0x6E, 0x40, 0x9E, 0x52, 0xBC, 0xDA, 0x94, + 0x83, 0xB4, 0x0A, 0xED, 0x0C, 0x31, 0x93, 0x3A + }, + { + 0x83, 0x2C, 0x94, 0x1C, 0x4E, 0x64, 0x6A, 0x8C, + 0x3C, 0xC1, 0x5E, 0x1C, 0x45, 0x7E, 0x2F, 0x39, + 0x5A, 0x3D, 0x0A, 0x92, 0x59, 0xB2, 0x25, 0x69, + 0x89, 0xAE, 0x3C, 0x86, 0xA8, 0x7F, 0x0F, 0x20, + 0x14, 0x57, 0x7D, 0x86, 0x46, 0xE5, 0x35, 0x62, + 0x87, 0x75, 0xF5, 0xDE, 0xC0, 0xD9, 0x4C, 0x3C, + 0x3B, 0x1C, 0xCE, 0xEB, 0xCE, 0xE4, 0xAB, 0xBD, + 0xCC, 0x9C, 0x36, 0x1C, 0xE0, 0x04, 0x8F, 0x37 + }, + { + 0xD1, 0xFB, 0xFE, 0x54, 0x85, 0x5E, 0xF4, 0x1E, + 0x4C, 0x86, 0x02, 0x7D, 0xF0, 0xC8, 0x31, 0x3A, + 0x46, 0x6B, 0xAB, 0x4A, 0x62, 0x93, 0xEA, 0x23, + 0xED, 0x34, 0x9E, 0x2C, 0x1B, 0x93, 0x38, 0x78, + 0xA4, 0xE8, 0x31, 0xD4, 0x35, 0x80, 0xC3, 0x08, + 0x60, 0x83, 0x86, 0xC2, 0x4E, 0xB6, 0xDE, 0x51, + 0xB0, 0xE8, 0x03, 0x10, 0xD6, 0xCE, 0x35, 0xC4, + 0xBE, 0x47, 0x8E, 0x7A, 0xD2, 0xCC, 0xD3, 0xAE + }, + { + 0x6F, 0x3C, 0x22, 0x00, 0x52, 0x4D, 0x10, 0x9A, + 0x6E, 0xDD, 0x5D, 0x52, 0x4B, 0xEF, 0x01, 0x43, + 0xEE, 0x46, 0x3A, 0xA8, 0x88, 0x02, 0x77, 0xA5, + 0x66, 0x8A, 0xAB, 0x6C, 0x7D, 0xD6, 0xA6, 0x2F, + 0x56, 0x2B, 0xBF, 0xFB, 0x91, 0x7B, 0xE6, 0x29, + 0x78, 0x42, 0xAD, 0x0A, 0x3E, 0x05, 0x20, 0x62, + 0xC6, 0x23, 0xA2, 0x3D, 0xD3, 0xA2, 0x74, 0x5D, + 0x75, 0x62, 0xC2, 0xA3, 0x72, 0x70, 0xD0, 0x75 + }, + { + 0xB1, 0xB7, 0xFF, 0xAC, 0xB5, 0x06, 0x78, 0xBA, + 0xD7, 0x48, 0xAD, 0xEB, 0x54, 0xF7, 0x49, 0x70, + 0x24, 0x89, 0x4A, 0x45, 0xB8, 0x09, 0xB6, 0x98, + 0xEB, 0xE3, 0xC8, 0x95, 0xDF, 0x0E, 0xA6, 0xC2, + 0x11, 0xB4, 0x8F, 0xE8, 0x38, 0xED, 0x77, 0xB1, + 0x7F, 0xBB, 0x02, 0xF7, 0x38, 0x04, 0x81, 0x7B, + 0x81, 0xCE, 0xE0, 0x2E, 0x2D, 0x21, 0xF1, 0xA9, + 0x02, 0xD7, 0x52, 0xEB, 0x8B, 0x50, 0x2D, 0xFD + }, + { + 0xA6, 0x8F, 0x68, 0xD7, 0xE3, 0x3E, 0x5C, 0x3E, + 0x6E, 0xD7, 0xAF, 0x2C, 0x9B, 0xA2, 0x82, 0x47, + 0x77, 0x51, 0x28, 0x6D, 0x97, 0x64, 0x1E, 0xEB, + 0x9F, 0xF8, 0xAE, 0xE2, 0xD5, 0x7C, 0xF3, 0x9D, + 0xE7, 0x21, 0x0A, 0xD1, 0x28, 0x3D, 0xEE, 0xD5, + 0xA5, 0x44, 0x26, 0xC0, 0xCE, 0x7D, 0x97, 0xC4, + 0xFC, 0xAB, 0x4D, 0x47, 0x25, 0x0C, 0xDA, 0x33, + 0x99, 0xF9, 0x79, 0xE2, 0xC6, 0xDC, 0x50, 0x6B + }, + { + 0x2F, 0x20, 0xBF, 0xFE, 0x7D, 0x4F, 0xBE, 0x50, + 0x96, 0x4E, 0x06, 0x43, 0x24, 0x5A, 0x1E, 0x61, + 0x33, 0x7E, 0xBC, 0x29, 0x45, 0x72, 0x7D, 0x60, + 0xCC, 0x52, 0x43, 0x2D, 0x5C, 0x3F, 0xDB, 0x70, + 0x77, 0x25, 0x7F, 0x85, 0x0D, 0x8B, 0xC1, 0xFD, + 0x4D, 0xB9, 0xD4, 0x1C, 0xEF, 0x1F, 0x24, 0x7C, + 0x5E, 0xCF, 0xE9, 0x57, 0x98, 0x1F, 0x8E, 0x5E, + 0x91, 0xB1, 0x21, 0xE2, 0x70, 0x21, 0xFD, 0x7A + }, + { + 0xC7, 0xD3, 0x29, 0xDB, 0x1D, 0xAD, 0xBD, 0x4C, + 0x5B, 0x9F, 0x3F, 0x79, 0xBC, 0xA9, 0x6B, 0x7B, + 0x9A, 0x86, 0xDE, 0x55, 0x52, 0xDF, 0xBD, 0xC0, + 0x7B, 0xE7, 0x07, 0x9D, 0xC9, 0xEE, 0x69, 0x9B, + 0xC4, 0x18, 0x3F, 0xA7, 0xE0, 0xE3, 0x5C, 0x82, + 0xBA, 0x09, 0x81, 0x04, 0xD0, 0x64, 0xFB, 0x8F, + 0x57, 0x48, 0xC2, 0x45, 0xC0, 0xDD, 0xA5, 0x10, + 0x06, 0x1D, 0x1D, 0x57, 0xCD, 0x58, 0xA8, 0x0F + }, + { + 0xCE, 0x60, 0x04, 0x70, 0x5D, 0xFB, 0x22, 0x7A, + 0xA8, 0x76, 0xE8, 0x02, 0xCF, 0x1C, 0xE5, 0x47, + 0xED, 0xCC, 0x1F, 0x73, 0x3D, 0xAE, 0x9E, 0xF9, + 0xEC, 0x39, 0xCA, 0x0B, 0x3E, 0x18, 0xF8, 0xCF, + 0xE4, 0xB9, 0xCB, 0xF0, 0x7C, 0xD8, 0x14, 0xD3, + 0x58, 0xA3, 0xD7, 0xE9, 0xAA, 0x2B, 0xD7, 0xCB, + 0xED, 0x08, 0x41, 0x04, 0x96, 0x8C, 0x52, 0xC6, + 0x84, 0x00, 0xFB, 0x00, 0x28, 0xC0, 0x88, 0xE6 + }, + { + 0x50, 0x0E, 0xC7, 0x76, 0x17, 0x9A, 0x7C, 0x22, + 0x63, 0x41, 0x41, 0x25, 0x93, 0x7A, 0xFD, 0x65, + 0x78, 0x8E, 0xEA, 0x7D, 0x8F, 0x86, 0x0B, 0xB3, + 0x8F, 0xD8, 0xA4, 0x1E, 0x7E, 0xA6, 0x00, 0x3E, + 0x32, 0x0F, 0x9A, 0x42, 0x25, 0xEF, 0x8B, 0x33, + 0x97, 0x76, 0x5F, 0xFB, 0x8F, 0x76, 0x01, 0x14, + 0x87, 0x53, 0x67, 0x12, 0xFF, 0xDC, 0xC4, 0xA5, + 0x47, 0xD7, 0x91, 0x98, 0x16, 0x8D, 0xAB, 0xF1 + }, + { + 0x7D, 0xFF, 0x83, 0xB9, 0x95, 0xCD, 0x45, 0xBA, + 0x15, 0x0B, 0xDE, 0xF1, 0x25, 0x54, 0xB3, 0x36, + 0xC1, 0x60, 0x7D, 0x96, 0xD4, 0xA1, 0x00, 0x4B, + 0xD7, 0xF1, 0x26, 0xE6, 0xDF, 0xA6, 0x8E, 0xE1, + 0xC3, 0x9C, 0x44, 0xAD, 0xE0, 0xE7, 0x74, 0xA2, + 0x65, 0x7E, 0xF8, 0xB2, 0xAA, 0x71, 0xF8, 0x15, + 0x69, 0x6A, 0xAB, 0xB0, 0x08, 0xC2, 0x1E, 0x51, + 0x6F, 0x0C, 0x9C, 0x17, 0xCD, 0x1D, 0xFF, 0x68 + }, + { + 0x8D, 0x09, 0x60, 0x86, 0x62, 0xD1, 0x71, 0x8E, + 0x0E, 0x6C, 0xDD, 0x76, 0x22, 0x8D, 0xDC, 0x64, + 0xCF, 0x97, 0xD0, 0x63, 0x64, 0xA0, 0xBB, 0xFA, + 0xBC, 0x00, 0x8F, 0x5C, 0x1C, 0xE5, 0x63, 0xA5, + 0x9F, 0x3A, 0xD0, 0x8E, 0x5C, 0xB6, 0x67, 0x5D, + 0x31, 0xA2, 0xF1, 0xD8, 0x55, 0xE1, 0x55, 0x30, + 0xB5, 0x73, 0x45, 0x4D, 0x47, 0x34, 0x5A, 0xA7, + 0xC8, 0xC4, 0xCC, 0xC9, 0xBE, 0x0A, 0x3C, 0xEE + }, + { + 0xA1, 0x12, 0xC7, 0xB6, 0x0F, 0xE2, 0x1D, 0xF1, + 0xB5, 0xC9, 0x6F, 0x1D, 0x99, 0x80, 0x46, 0x14, + 0xA4, 0xA4, 0x81, 0x10, 0x2E, 0x1F, 0xD6, 0x1B, + 0x8A, 0x79, 0x85, 0xDF, 0x8D, 0xE4, 0x8C, 0x65, + 0x9C, 0x4A, 0xBF, 0x96, 0xCB, 0xF3, 0xA3, 0x20, + 0xDE, 0xC9, 0x4F, 0x02, 0xB9, 0x53, 0xA4, 0xE6, + 0xE7, 0xDC, 0x10, 0xFB, 0xAC, 0xBC, 0x05, 0xEB, + 0xAC, 0x3A, 0x32, 0x77, 0x83, 0x0D, 0xD8, 0xB0 + }, + { + 0xF6, 0x63, 0x0A, 0x9C, 0x7A, 0x48, 0x38, 0x91, + 0x86, 0xA0, 0xE2, 0x44, 0x59, 0x31, 0xC1, 0x26, + 0x0B, 0xBB, 0x27, 0xAB, 0x7F, 0x08, 0x03, 0x14, + 0x59, 0xBE, 0x9E, 0x1D, 0x72, 0x9E, 0x71, 0x07, + 0x87, 0x54, 0x16, 0xB2, 0x63, 0x74, 0x94, 0xF7, + 0x56, 0x16, 0xB9, 0xA4, 0x6B, 0x2E, 0x24, 0x2E, + 0x00, 0x17, 0x56, 0xD9, 0x24, 0xA2, 0x5F, 0xE3, + 0x39, 0xBD, 0x1E, 0x12, 0x2C, 0x6D, 0xE1, 0xF6 + }, + { + 0x2F, 0x7D, 0x26, 0x61, 0x2B, 0x84, 0xF0, 0x0A, + 0x84, 0xCD, 0x6E, 0xA1, 0x51, 0xD6, 0xAA, 0xF0, + 0xD8, 0x19, 0xC4, 0xB7, 0xF0, 0x2A, 0xDC, 0x24, + 0xEB, 0xD5, 0x79, 0xA9, 0x09, 0xA3, 0xFA, 0x34, + 0x2A, 0xFF, 0x6F, 0x33, 0xF7, 0x89, 0x4F, 0x51, + 0x40, 0x55, 0x21, 0x32, 0xE9, 0x55, 0xEE, 0x0E, + 0xC3, 0x04, 0x8F, 0x78, 0x37, 0x79, 0xC0, 0x91, + 0x45, 0xAE, 0xEE, 0x6F, 0x90, 0x9F, 0x8F, 0x96 + }, + { + 0x47, 0x09, 0x3C, 0xF5, 0x66, 0x82, 0x59, 0xBF, + 0xDB, 0x17, 0x02, 0x1D, 0xCC, 0xBE, 0xF9, 0x62, + 0x8D, 0x9C, 0x47, 0xFF, 0x5A, 0x43, 0xC6, 0x7D, + 0x3E, 0x79, 0x91, 0xF7, 0x5D, 0x62, 0x9B, 0x5B, + 0xD6, 0xE4, 0x59, 0x03, 0x57, 0xB5, 0xED, 0xF8, + 0x7A, 0xA9, 0x7E, 0x41, 0xE2, 0x35, 0xFC, 0xA6, + 0xC0, 0x84, 0x97, 0x96, 0x43, 0x6F, 0x9B, 0x7B, + 0x9D, 0xE9, 0x44, 0x6E, 0x88, 0x91, 0x55, 0x4F + }, + { + 0xE5, 0x67, 0x9E, 0xF9, 0x7E, 0xE3, 0xCF, 0x67, + 0xE7, 0xB8, 0x85, 0x47, 0x33, 0xAB, 0x6D, 0xEA, + 0xC7, 0x03, 0x85, 0xB2, 0x66, 0x8D, 0x88, 0x91, + 0xDB, 0x13, 0x74, 0x0E, 0x66, 0x15, 0xEA, 0xDE, + 0x23, 0x01, 0x38, 0x50, 0x54, 0xF4, 0x08, 0xBB, + 0x1F, 0x14, 0xF5, 0xA6, 0x66, 0x7F, 0xAD, 0x9B, + 0xF3, 0x4F, 0x2C, 0x7B, 0x3B, 0x78, 0x53, 0xB5, + 0x5D, 0xFA, 0x31, 0x36, 0x69, 0xB7, 0xA7, 0x53 + }, + { + 0xB8, 0xA0, 0x56, 0x55, 0x18, 0x14, 0x89, 0x31, + 0x2B, 0xF1, 0x2E, 0x9F, 0x77, 0xC1, 0xE9, 0xB5, + 0x29, 0x25, 0xAD, 0x66, 0x7D, 0x1F, 0xCB, 0x75, + 0x4E, 0xC4, 0x29, 0xC4, 0xEF, 0x46, 0x7D, 0xBE, + 0x80, 0xF6, 0x01, 0xEC, 0x1B, 0xD1, 0x24, 0x42, + 0xDB, 0x37, 0x1F, 0xEC, 0x7E, 0x6C, 0x56, 0xC5, + 0xB3, 0xC0, 0xE8, 0xEC, 0x63, 0x0D, 0x59, 0x9A, + 0xAE, 0xC4, 0xF9, 0xF7, 0xC1, 0x74, 0xD1, 0x9F + }, + { + 0xD6, 0xED, 0x1E, 0xB5, 0xAA, 0x72, 0x74, 0x3B, + 0xDE, 0x3F, 0x13, 0xD0, 0x9F, 0xCC, 0xE3, 0x2D, + 0x9D, 0xEE, 0xBB, 0x6A, 0xCC, 0x47, 0x29, 0x78, + 0x89, 0xC3, 0xB0, 0xC2, 0xF8, 0xB0, 0xD5, 0x0C, + 0xCC, 0x23, 0x62, 0x21, 0x17, 0xFD, 0x76, 0xF2, + 0x5F, 0x15, 0xCB, 0xD2, 0xB9, 0x93, 0x26, 0x7E, + 0xE4, 0xBD, 0xEF, 0x93, 0xC0, 0x10, 0x75, 0xC3, + 0x0A, 0x0B, 0x67, 0xFC, 0xDC, 0x4D, 0x1B, 0xCD + }, + { + 0xAE, 0xB1, 0x47, 0x14, 0x43, 0x6A, 0x91, 0x8D, + 0x5E, 0x67, 0x71, 0x17, 0x2D, 0xB2, 0x28, 0x29, + 0x49, 0x86, 0x96, 0x3F, 0xD7, 0x25, 0xA6, 0xE1, + 0x66, 0x56, 0xE2, 0x3D, 0xC9, 0x66, 0x4D, 0x48, + 0xC0, 0xB0, 0x0C, 0x4C, 0x0F, 0x21, 0x05, 0xF9, + 0x5E, 0xE8, 0xF1, 0xAA, 0x3A, 0x64, 0x7E, 0x45, + 0x87, 0x72, 0x1D, 0x82, 0x2F, 0x6D, 0xA3, 0xE2, + 0xC5, 0x99, 0xEB, 0x7F, 0x0E, 0xEA, 0x4A, 0x9B + }, + { + 0x97, 0x05, 0x1F, 0x34, 0xE7, 0x05, 0x11, 0x9E, + 0x1B, 0xA3, 0x45, 0x00, 0xEF, 0xE1, 0xEB, 0xE6, + 0x9E, 0xEB, 0x1B, 0xA7, 0x8D, 0xC3, 0x3D, 0x33, + 0x7E, 0x0A, 0xB8, 0x3C, 0xB6, 0x55, 0x2F, 0x39, + 0x53, 0x3A, 0x7E, 0x19, 0x0C, 0xC2, 0x70, 0x86, + 0x5E, 0x63, 0x57, 0x81, 0xAE, 0x21, 0xB7, 0x1D, + 0x16, 0x7C, 0xF3, 0xEE, 0xC8, 0x77, 0x77, 0xF4, + 0x41, 0x2B, 0x14, 0x19, 0x84, 0x4C, 0x4F, 0xC6 + }, + { + 0xDE, 0x4A, 0x68, 0x4A, 0xDF, 0xC0, 0x10, 0x6D, + 0xF7, 0x1C, 0x67, 0x05, 0xE3, 0x95, 0x15, 0x0F, + 0xA2, 0x26, 0xC0, 0x0B, 0x2C, 0xEE, 0x28, 0x23, + 0x44, 0x81, 0x31, 0xBA, 0x88, 0x33, 0xC8, 0x15, + 0xF9, 0x9C, 0x06, 0x00, 0xDF, 0x17, 0x56, 0xE2, + 0xDF, 0xA5, 0xC4, 0x8C, 0x4E, 0x9E, 0xBE, 0xF7, + 0x93, 0xC7, 0x07, 0x87, 0x52, 0x18, 0xC2, 0x73, + 0xC4, 0xDF, 0xC0, 0xFB, 0x90, 0xA5, 0x21, 0xD2 + }, + { + 0x69, 0xD7, 0x06, 0x87, 0x15, 0xE7, 0xD5, 0xA4, + 0xAA, 0xC2, 0x83, 0xDD, 0xD1, 0x13, 0xCA, 0x10, + 0x7F, 0x3A, 0xDE, 0xF4, 0xEE, 0xF3, 0xD0, 0x7E, + 0x46, 0x9E, 0xF5, 0x5F, 0xD6, 0x0D, 0x04, 0xC9, + 0x3A, 0x99, 0x7D, 0x96, 0xD4, 0x0C, 0x38, 0x15, + 0x69, 0xB0, 0x8C, 0x03, 0x78, 0xDC, 0x6A, 0xB0, + 0x2A, 0x4A, 0x9C, 0x3A, 0xCD, 0xF1, 0x5E, 0x83, + 0x2D, 0xF6, 0x1C, 0xDA, 0x0B, 0x51, 0x4B, 0x81 + }, + { + 0xA4, 0xED, 0x4B, 0xF7, 0x53, 0x32, 0xCE, 0x4F, + 0xCA, 0xFE, 0x8B, 0x79, 0x97, 0x53, 0x02, 0x72, + 0xDF, 0xC5, 0x4D, 0x4D, 0xFE, 0xCE, 0x7B, 0xEC, + 0xD2, 0x5A, 0x9F, 0xA7, 0xD1, 0xB6, 0x97, 0x9F, + 0xC8, 0x44, 0x00, 0xEA, 0xED, 0xA4, 0x55, 0x4A, + 0xCD, 0x17, 0x5A, 0x03, 0x8D, 0xF3, 0xE2, 0x0D, + 0x7B, 0xA6, 0xB0, 0x68, 0xFB, 0xEE, 0xB8, 0x01, + 0x82, 0xF8, 0x80, 0xBE, 0xBD, 0xA0, 0x57, 0x87 + }, + { + 0x2F, 0xD2, 0xF3, 0x6C, 0x0C, 0x99, 0xA8, 0x3E, + 0x5E, 0xE5, 0x57, 0xDF, 0x43, 0x6A, 0x6E, 0x91, + 0xE2, 0x0F, 0x36, 0x7D, 0xAA, 0x07, 0x44, 0x78, + 0x69, 0x36, 0x5B, 0xC6, 0xBA, 0x8E, 0x64, 0xBB, + 0x65, 0x9D, 0x52, 0xCB, 0x12, 0x75, 0x89, 0x3B, + 0x36, 0x6B, 0xAC, 0x56, 0x04, 0xA0, 0x77, 0x62, + 0x35, 0x3E, 0xEF, 0x45, 0xB7, 0xDE, 0x29, 0xED, + 0x56, 0xE9, 0x29, 0x44, 0x75, 0xE9, 0xCA, 0xF2 + }, + { + 0xA4, 0x19, 0xD1, 0x4B, 0x1C, 0x79, 0xA4, 0xB1, + 0xC7, 0xF3, 0x72, 0xE4, 0x62, 0xE6, 0x69, 0xDE, + 0xBD, 0xCC, 0xF4, 0x05, 0x7B, 0x48, 0x8C, 0xB0, + 0x5A, 0x96, 0x86, 0x84, 0x6A, 0x93, 0x1D, 0xEC, + 0xB1, 0x02, 0x11, 0xD9, 0xA6, 0x18, 0x50, 0x25, + 0x60, 0x93, 0x46, 0x27, 0x15, 0xED, 0xBF, 0xA3, + 0x24, 0x14, 0x6E, 0x7B, 0x53, 0xA3, 0xE9, 0xCA, + 0x4E, 0x6F, 0x4E, 0x53, 0xF9, 0x1D, 0x58, 0xAB + }, + { + 0xB9, 0x12, 0x1C, 0x7F, 0x33, 0xC1, 0x83, 0x6E, + 0x3D, 0xFB, 0xEA, 0xEF, 0xEE, 0x49, 0x03, 0x45, + 0xAC, 0x86, 0x6A, 0x0E, 0xCA, 0x5B, 0xF7, 0xCB, + 0x44, 0x6E, 0x9E, 0x1C, 0x5C, 0xFD, 0xED, 0x34, + 0x3F, 0x22, 0x19, 0x78, 0x36, 0xC3, 0x38, 0x12, + 0x6C, 0x0E, 0xE4, 0xCC, 0x21, 0xCF, 0x24, 0xDF, + 0x92, 0x3A, 0xD5, 0x6F, 0x2C, 0x32, 0x61, 0x60, + 0xCE, 0xFE, 0x0D, 0x61, 0xDF, 0xBB, 0x8A, 0x7D + }, + { + 0x49, 0x39, 0x80, 0x65, 0xFF, 0x2C, 0x2F, 0xD5, + 0x37, 0x30, 0xD7, 0x09, 0xB5, 0x22, 0xA1, 0x2D, + 0xD9, 0xD4, 0x7D, 0x65, 0x45, 0x9B, 0xA7, 0xFA, + 0x1C, 0x0C, 0x0A, 0xCE, 0xE2, 0xC4, 0x19, 0x71, + 0x8F, 0x86, 0x32, 0xD6, 0xAD, 0x8F, 0x61, 0x0F, + 0x4F, 0xDE, 0x13, 0xDD, 0x0D, 0xE2, 0xEC, 0xE7, + 0xD4, 0x84, 0x85, 0x09, 0x09, 0xB9, 0x6F, 0x9B, + 0xAE, 0x11, 0x7E, 0x00, 0x22, 0xB5, 0x8A, 0xC7 + }, + { + 0xE8, 0x2C, 0x3E, 0x84, 0xF6, 0x5F, 0xE2, 0x62, + 0x57, 0x41, 0x64, 0x16, 0x34, 0xDD, 0x4A, 0xDE, + 0xDA, 0x5A, 0xA4, 0x8B, 0xE2, 0x1F, 0x43, 0x20, + 0x45, 0x0B, 0xCF, 0xBF, 0xBE, 0xF0, 0x16, 0x08, + 0xED, 0x24, 0x8B, 0xDC, 0xEA, 0xD2, 0x81, 0xC9, + 0x8D, 0x2F, 0x5B, 0xFD, 0xC3, 0xA3, 0xFA, 0x1D, + 0x84, 0xE9, 0x70, 0x70, 0xC2, 0xB5, 0xB7, 0x4F, + 0x20, 0x09, 0x5A, 0xB9, 0xEC, 0x39, 0x9F, 0x1D + }, + { + 0xB6, 0x8F, 0xA9, 0x01, 0xD5, 0xE2, 0x0E, 0x2C, + 0x4A, 0xCF, 0x76, 0x89, 0xF9, 0xE0, 0x4F, 0x83, + 0x2A, 0x4A, 0xFF, 0xEE, 0xD7, 0xA8, 0x1C, 0x33, + 0x74, 0xDE, 0x38, 0x2E, 0xFF, 0xB9, 0x8E, 0xE2, + 0x46, 0xE8, 0x17, 0xDE, 0x18, 0xA8, 0x6D, 0xCD, + 0xE0, 0xA6, 0x9B, 0x72, 0x3F, 0x18, 0xB3, 0x1A, + 0x38, 0x83, 0xBD, 0xF3, 0xA5, 0xFF, 0x0E, 0x90, + 0xA0, 0x6A, 0x08, 0xB0, 0x90, 0x2D, 0xC6, 0x0B + }, + { + 0xE4, 0x64, 0x98, 0x50, 0xDA, 0xB1, 0xB7, 0xE7, + 0x17, 0x99, 0x95, 0xAD, 0x98, 0xC0, 0x46, 0xE7, + 0xA6, 0xC0, 0x17, 0xB4, 0xB0, 0xD2, 0xAE, 0xB1, + 0x39, 0x65, 0xDB, 0x6B, 0x84, 0x1C, 0xC4, 0x6D, + 0x0A, 0xFA, 0x50, 0xA7, 0xBE, 0xEF, 0x30, 0xE6, + 0xC1, 0xD3, 0x94, 0xA3, 0xC2, 0x2B, 0x91, 0x2D, + 0x1D, 0xDF, 0xDC, 0xB5, 0xE8, 0xC5, 0x60, 0x33, + 0x7D, 0x15, 0x0C, 0x93, 0xC4, 0x4F, 0x0B, 0x45 + }, + { + 0x48, 0xF8, 0x6F, 0x37, 0x27, 0xF9, 0x61, 0xD8, + 0x1F, 0x6B, 0xF8, 0x8D, 0x64, 0xFB, 0xC8, 0x97, + 0x6F, 0x0D, 0x7C, 0x55, 0x47, 0x07, 0x4D, 0xCB, + 0x47, 0x39, 0x0C, 0x0F, 0x14, 0x9E, 0x6A, 0x9E, + 0x12, 0x23, 0xAF, 0xF1, 0x4C, 0x4E, 0x4F, 0xA5, + 0x38, 0x28, 0x1D, 0x18, 0x1E, 0xC9, 0xE1, 0xB1, + 0x06, 0x09, 0x7B, 0x79, 0xEC, 0xBC, 0x66, 0xBA, + 0xE2, 0x4C, 0x55, 0x76, 0xA9, 0x58, 0x8C, 0xBA + }, + { + 0x0A, 0x3F, 0x7E, 0xCE, 0xE3, 0x59, 0xE8, 0xA5, + 0x5D, 0xC2, 0xA7, 0x5F, 0xFC, 0xBB, 0xB4, 0x65, + 0x65, 0xFB, 0x7D, 0x09, 0xCA, 0x43, 0x30, 0x8D, + 0xE5, 0x79, 0xE9, 0xC5, 0xE7, 0xA5, 0x1E, 0x17, + 0x58, 0xFD, 0xC4, 0xF3, 0x93, 0x70, 0x5F, 0x9B, + 0xAF, 0xAF, 0x85, 0xD3, 0x61, 0x49, 0x54, 0x22, + 0x79, 0xC9, 0xD1, 0x50, 0x98, 0xE6, 0xF2, 0xE6, + 0x53, 0x97, 0xB9, 0xFF, 0xC2, 0x6D, 0xEE, 0x8B + }, + { + 0x40, 0xEF, 0x5D, 0x0F, 0x97, 0x5A, 0xD6, 0xBD, + 0xF7, 0xE9, 0x3E, 0x27, 0x2E, 0x87, 0x86, 0x6B, + 0x52, 0x0D, 0x23, 0xD0, 0x22, 0xD2, 0xDD, 0xFE, + 0x6E, 0xEA, 0x3B, 0x5B, 0xFF, 0x35, 0x1F, 0x20, + 0xF1, 0x64, 0x9A, 0x3F, 0x88, 0x7F, 0xB9, 0x0B, + 0x16, 0x6B, 0x9C, 0x66, 0x46, 0x5F, 0xD5, 0x14, + 0xAD, 0x26, 0x9A, 0xBD, 0x02, 0x23, 0xA5, 0xA9, + 0x86, 0x6B, 0xA4, 0x0C, 0x2A, 0xD9, 0x5F, 0x7D + }, + { + 0x76, 0x23, 0x4F, 0x3D, 0xF2, 0xB0, 0x4E, 0x26, + 0x91, 0x2B, 0xF8, 0x25, 0xA5, 0xDB, 0xB4, 0x33, + 0x02, 0xBD, 0xA7, 0x84, 0x14, 0x54, 0x22, 0xEA, + 0xBD, 0x9B, 0xD1, 0xEC, 0x2F, 0x4D, 0x0A, 0xC6, + 0xA2, 0x54, 0xE6, 0x29, 0x2D, 0xD1, 0x89, 0x2E, + 0x09, 0xBB, 0xCA, 0xCE, 0xE2, 0xEB, 0xA1, 0x52, + 0x50, 0x0D, 0x6F, 0xD7, 0xC5, 0xAA, 0x19, 0xD4, + 0x59, 0xB9, 0x33, 0xF6, 0xF5, 0x19, 0x29, 0x8E + }, + { + 0x7F, 0xED, 0x13, 0x1D, 0xA8, 0x62, 0x31, 0x31, + 0x95, 0xC2, 0xEF, 0xC6, 0x51, 0x1E, 0xCC, 0x47, + 0x33, 0x6E, 0x7E, 0xF1, 0x30, 0xD9, 0x15, 0x85, + 0x60, 0x51, 0xDF, 0xAD, 0x0B, 0x7F, 0x3C, 0x95, + 0x0A, 0x2B, 0xA4, 0xCB, 0x8E, 0x4D, 0xE6, 0x65, + 0xCB, 0xF9, 0xAB, 0x4B, 0x02, 0xC8, 0xCB, 0x70, + 0x4D, 0x8C, 0x27, 0xB7, 0x2E, 0xF1, 0xBF, 0x03, + 0x85, 0x79, 0xC5, 0x38, 0x42, 0xE1, 0xD5, 0x3D + }, + { + 0x20, 0x03, 0x20, 0xBC, 0x37, 0xD7, 0xC3, 0xEC, + 0x9F, 0xAF, 0xB6, 0xBB, 0x55, 0xA5, 0xD3, 0xA1, + 0xDB, 0xB3, 0x93, 0x39, 0xBF, 0xBB, 0xE4, 0x3A, + 0x32, 0x85, 0x9A, 0xF3, 0xF9, 0x76, 0x20, 0xCC, + 0x10, 0xA1, 0x5E, 0xDC, 0x87, 0xC8, 0x8C, 0x89, + 0x65, 0xB7, 0xC4, 0xFF, 0x25, 0xBD, 0x65, 0xAD, + 0x97, 0xA4, 0x79, 0xDC, 0x8A, 0xE7, 0x74, 0x66, + 0xD4, 0xC3, 0xAD, 0x70, 0x83, 0xFF, 0x5F, 0x38 + }, + { + 0x42, 0xA7, 0xA3, 0xFF, 0x19, 0xF2, 0xF4, 0x9B, + 0x22, 0x57, 0x08, 0x67, 0x99, 0x01, 0xE4, 0xF4, + 0x45, 0x8E, 0xA2, 0x6B, 0xE8, 0x4D, 0x5C, 0x77, + 0x11, 0x6A, 0xFA, 0x8A, 0xD4, 0xD3, 0x05, 0x11, + 0xD4, 0x97, 0xD4, 0x1D, 0xD9, 0x52, 0x33, 0x7D, + 0x24, 0x7E, 0x82, 0x81, 0x6D, 0x57, 0xA1, 0x5C, + 0xFE, 0x9C, 0x46, 0x47, 0xAF, 0x7C, 0xC1, 0x64, + 0x62, 0xB4, 0x24, 0x6C, 0x17, 0x63, 0xBA, 0x3C + }, + { + 0x20, 0x03, 0x9D, 0xEF, 0xF4, 0x93, 0x9C, 0x99, + 0xBC, 0x06, 0xAA, 0x6F, 0x26, 0xA1, 0x13, 0xC6, + 0x88, 0x2F, 0xC1, 0xE4, 0x98, 0x76, 0x78, 0xCD, + 0x6C, 0x8E, 0xF3, 0x47, 0xB3, 0xBB, 0x2C, 0xE1, + 0xD0, 0xFA, 0x5D, 0x60, 0x1B, 0xB8, 0x40, 0x1C, + 0x98, 0x68, 0xE9, 0xFE, 0x00, 0x38, 0x43, 0x42, + 0xD9, 0x81, 0x58, 0x3D, 0x0E, 0x7F, 0x34, 0xB7, + 0xAE, 0x83, 0x09, 0x8F, 0x08, 0x73, 0xE8, 0x68 + }, + { + 0xDD, 0x1D, 0x0A, 0x0A, 0x4E, 0x29, 0xEE, 0xDD, + 0x85, 0xC3, 0x1D, 0xD5, 0x94, 0xE4, 0x64, 0x99, + 0x34, 0x16, 0x7B, 0xEE, 0xAA, 0x34, 0x9B, 0x04, + 0x9D, 0xF4, 0x36, 0x57, 0xC5, 0x7D, 0x8D, 0x9A, + 0xBF, 0x87, 0xF3, 0x46, 0x4B, 0x3A, 0x48, 0x0E, + 0x0D, 0xE8, 0x53, 0xDC, 0x12, 0x0C, 0xEE, 0x8B, + 0x28, 0xE9, 0xEE, 0x40, 0xCE, 0x65, 0x0A, 0xD9, + 0x96, 0xD1, 0x8D, 0xAC, 0xC7, 0x89, 0x09, 0x2D + }, + { + 0x87, 0xB3, 0xA9, 0x2D, 0x8B, 0xD8, 0x76, 0xEE, + 0x25, 0xF9, 0x53, 0x71, 0x50, 0x75, 0x53, 0xA8, + 0x44, 0xF7, 0xC6, 0x60, 0x64, 0xD8, 0x80, 0x75, + 0x2B, 0xB2, 0x55, 0xC9, 0x6D, 0x91, 0xF4, 0x26, + 0xA3, 0x9C, 0x9F, 0x38, 0xEB, 0x45, 0x1A, 0xAE, + 0xE5, 0x61, 0xD4, 0x5B, 0x12, 0xBC, 0x63, 0x37, + 0x52, 0xC2, 0x4F, 0x1C, 0xF4, 0x3A, 0x79, 0x9A, + 0x56, 0x0D, 0x65, 0x54, 0x8A, 0xA4, 0x1C, 0x5B + }, + { + 0x50, 0x1E, 0xFB, 0xF2, 0xBE, 0x51, 0xC6, 0x2F, + 0x0B, 0xC9, 0x38, 0xFB, 0xEA, 0x11, 0xFE, 0xBF, + 0xA8, 0x0F, 0xA2, 0xE2, 0x7B, 0xBB, 0xFE, 0x53, + 0x45, 0x43, 0x20, 0x59, 0x05, 0x54, 0x63, 0xE0, + 0xB8, 0x47, 0x70, 0xE4, 0x65, 0x57, 0x8A, 0xCB, + 0x76, 0x7A, 0xEF, 0x2E, 0xCA, 0x64, 0x03, 0x64, + 0x59, 0xF9, 0x69, 0x46, 0x6B, 0x8F, 0x55, 0x17, + 0x8C, 0x23, 0xBE, 0xC0, 0xB6, 0x99, 0xC2, 0x88 + }, + { + 0x07, 0xC7, 0x79, 0xCC, 0x62, 0xE3, 0xF2, 0xD1, + 0xA9, 0x01, 0x6C, 0x88, 0x8B, 0x3A, 0x28, 0x02, + 0xC7, 0xE7, 0xBA, 0xC7, 0x33, 0x21, 0x91, 0x40, + 0x07, 0x0D, 0xEA, 0xAF, 0x6F, 0x43, 0xA0, 0x52, + 0xFB, 0x40, 0x43, 0xED, 0x2C, 0xC5, 0xA3, 0x9D, + 0x11, 0xFC, 0xDA, 0x51, 0xBF, 0xA3, 0xEE, 0x6A, + 0x20, 0x4E, 0xAF, 0x45, 0x12, 0x1C, 0x49, 0x0E, + 0x22, 0x77, 0xBC, 0xEF, 0xBE, 0x13, 0xB8, 0xE8 + }, + { + 0x1D, 0x3D, 0x1A, 0xA0, 0xE9, 0xA3, 0xB6, 0x60, + 0x9A, 0x92, 0x78, 0x23, 0xC9, 0x26, 0xB5, 0xC7, + 0x11, 0x64, 0x23, 0x85, 0x6C, 0x95, 0x24, 0xFE, + 0xDF, 0xD5, 0x4A, 0x21, 0x67, 0x44, 0x04, 0x0D, + 0xBD, 0x80, 0x6B, 0x00, 0xEF, 0x43, 0xD8, 0xF4, + 0x24, 0xEA, 0xFE, 0x39, 0x0E, 0x32, 0x7E, 0xD1, + 0xA7, 0xE5, 0xEE, 0xDD, 0x0E, 0xDC, 0x45, 0xC0, + 0x35, 0x90, 0x9C, 0x06, 0x6E, 0xFF, 0x51, 0x19 + }, + { + 0xBB, 0x5E, 0x3A, 0x7B, 0xC6, 0x70, 0x9D, 0x54, + 0x1B, 0x3E, 0xC8, 0x17, 0x75, 0xBE, 0x61, 0xFA, + 0xC9, 0xE3, 0x6C, 0xE1, 0x86, 0xB3, 0x5E, 0x14, + 0xF9, 0xF0, 0x80, 0xC1, 0x06, 0xA0, 0xF5, 0x91, + 0x09, 0x75, 0x3D, 0x91, 0x21, 0x80, 0x67, 0x4C, + 0x2A, 0x8A, 0x22, 0x33, 0x00, 0x48, 0x97, 0x4E, + 0xA3, 0x6F, 0xB8, 0x21, 0x92, 0x31, 0xED, 0xC1, + 0xE0, 0xBD, 0xAB, 0x13, 0xEE, 0x09, 0x1D, 0xE6 + }, + { + 0x9C, 0xF9, 0x45, 0xAE, 0xC1, 0x34, 0x20, 0x06, + 0x48, 0x51, 0x7C, 0x93, 0xB3, 0xE7, 0x70, 0x16, + 0x63, 0xB9, 0x11, 0xB5, 0xD6, 0xA4, 0x7C, 0xA3, + 0x1F, 0x55, 0xC9, 0x3F, 0x97, 0x03, 0xE9, 0x56, + 0xD0, 0x68, 0xEB, 0x58, 0x54, 0xF0, 0xD8, 0x60, + 0x14, 0x3A, 0x77, 0xBE, 0x2B, 0xEB, 0x83, 0x86, + 0x3D, 0xD5, 0xCA, 0x1C, 0x42, 0x70, 0x91, 0xE5, + 0x14, 0xE3, 0x8F, 0x85, 0x8C, 0xB9, 0xA5, 0x0B + }, + { + 0xB3, 0xB2, 0x8F, 0xFD, 0x02, 0xAB, 0x22, 0xCE, + 0x59, 0xEA, 0xD2, 0xBD, 0xD4, 0x06, 0xBB, 0x5E, + 0x18, 0xAE, 0x57, 0xD2, 0x78, 0xB2, 0xE6, 0xC0, + 0xAD, 0x9A, 0x04, 0x6D, 0xDE, 0x84, 0x68, 0x20, + 0xE3, 0xDB, 0xAC, 0x95, 0x41, 0x7E, 0x5B, 0x1A, + 0xB1, 0x46, 0xC5, 0x03, 0x35, 0x9A, 0x92, 0x06, + 0xA8, 0xDC, 0x4F, 0x2D, 0x98, 0xB6, 0x99, 0x7D, + 0xAB, 0x36, 0xE1, 0xF8, 0xA8, 0x2D, 0x4F, 0x13 + }, + { + 0x83, 0xA7, 0x64, 0x24, 0x6D, 0x64, 0x78, 0xA3, + 0x9F, 0x84, 0x79, 0xB7, 0x6E, 0xB6, 0x73, 0x67, + 0xE1, 0x73, 0xD3, 0x9B, 0xD4, 0xF8, 0x21, 0x3F, + 0x5F, 0x14, 0xD1, 0x5C, 0x0A, 0xCC, 0xC5, 0x3D, + 0xAF, 0xC9, 0x23, 0x83, 0x14, 0x14, 0xBE, 0xAD, + 0x65, 0x0B, 0xF8, 0xAC, 0xF6, 0xB0, 0x7F, 0xF3, + 0x1C, 0x74, 0x82, 0x39, 0x7B, 0xC1, 0xC2, 0xFA, + 0x49, 0x5E, 0x35, 0x18, 0x7D, 0x36, 0xEF, 0x5F + }, + { + 0xFE, 0xFB, 0x69, 0xC8, 0x0A, 0x62, 0xC0, 0x40, + 0xBA, 0x36, 0x2F, 0xDB, 0x3D, 0x79, 0x7F, 0xEF, + 0x99, 0xC4, 0x96, 0x5D, 0xBF, 0xFB, 0x65, 0x31, + 0x9D, 0x1F, 0x2E, 0x64, 0x12, 0x8C, 0xD2, 0xD2, + 0xAF, 0xA9, 0x9E, 0x8D, 0x25, 0xEE, 0xAC, 0x83, + 0x93, 0xC4, 0x41, 0xDE, 0xFD, 0x55, 0xC1, 0xD1, + 0xAB, 0x5C, 0x79, 0xFB, 0x2A, 0x4B, 0x5A, 0x31, + 0x90, 0x31, 0xDC, 0x02, 0xF0, 0xD8, 0xD3, 0x5B + }, + { + 0xBE, 0xDA, 0x2B, 0xBB, 0x09, 0x09, 0x3A, 0xE8, + 0xB8, 0x9E, 0x76, 0x9C, 0x74, 0x88, 0xDE, 0xE8, + 0x5E, 0xB8, 0x1B, 0x7A, 0xE5, 0x34, 0x2F, 0xE6, + 0x29, 0xD3, 0x49, 0x63, 0xAA, 0xD9, 0x25, 0x62, + 0xB6, 0x0F, 0x98, 0x60, 0x68, 0x6B, 0xBA, 0x89, + 0x5A, 0x59, 0x6E, 0x61, 0xE6, 0x3E, 0xA7, 0xDD, + 0xED, 0x7A, 0x48, 0x0E, 0x1D, 0x41, 0x52, 0x07, + 0x12, 0x16, 0x1B, 0x82, 0x88, 0x9E, 0x20, 0x90 + }, + { + 0x6B, 0x13, 0x25, 0x35, 0x79, 0x51, 0x2F, 0x4C, + 0xFD, 0xA3, 0xF8, 0x52, 0xE5, 0x4A, 0xDE, 0x5C, + 0x53, 0x9E, 0x15, 0x08, 0x70, 0x14, 0xEB, 0x37, + 0x9A, 0xD2, 0xBC, 0x65, 0x26, 0x24, 0x9D, 0xEF, + 0xE6, 0x5A, 0x5C, 0xEF, 0x77, 0xBE, 0xEE, 0x93, + 0xEE, 0x45, 0x94, 0x34, 0x27, 0x6E, 0x09, 0xC1, + 0x18, 0x59, 0x85, 0x35, 0x4C, 0x84, 0x05, 0xCA, + 0x2C, 0x92, 0xC5, 0xFD, 0x49, 0x5D, 0x7F, 0x45 + }, + { + 0x52, 0xBE, 0x44, 0x87, 0xF9, 0x50, 0xF7, 0x63, + 0xD6, 0x4B, 0x74, 0xA8, 0x1D, 0x65, 0x7A, 0xA4, + 0x1B, 0x62, 0x53, 0x99, 0x7F, 0x58, 0xF9, 0xA8, + 0x30, 0xFE, 0xBA, 0xB0, 0x13, 0x62, 0x59, 0x82, + 0xD9, 0xE2, 0x69, 0xE0, 0x6E, 0xFE, 0xBE, 0x47, + 0x2A, 0xA8, 0x80, 0xF0, 0xCD, 0x34, 0x12, 0xD1, + 0x64, 0xA8, 0xAD, 0xB6, 0x5D, 0x40, 0x19, 0x32, + 0x71, 0xCB, 0x0F, 0x10, 0x3E, 0x8A, 0x0F, 0x0E + }, + { + 0x41, 0xB3, 0xDC, 0xFF, 0x68, 0xD0, 0xF4, 0xA6, + 0x70, 0x1C, 0x1C, 0xD0, 0x39, 0x45, 0x27, 0x92, + 0x6B, 0xD0, 0x9A, 0xF2, 0xB1, 0xD7, 0x76, 0x00, + 0x27, 0x63, 0xE6, 0x7C, 0x41, 0xBF, 0x84, 0x61, + 0x71, 0xA6, 0x01, 0x8D, 0xD8, 0x36, 0xB0, 0x0A, + 0x40, 0xE4, 0x50, 0x3C, 0x9A, 0x1F, 0xF8, 0xBB, + 0xE0, 0xE8, 0x0E, 0x6B, 0x39, 0x0A, 0xF1, 0x6E, + 0xFD, 0x64, 0x2D, 0x76, 0x3D, 0x1D, 0x02, 0x34 + }, + { + 0x5E, 0xA2, 0x7F, 0x84, 0x08, 0x8A, 0xAF, 0xD5, + 0xA3, 0xE1, 0x29, 0x31, 0x02, 0xC9, 0x60, 0xDA, + 0x70, 0x75, 0x74, 0x4E, 0x10, 0x62, 0xFA, 0x49, + 0x69, 0xA1, 0xAE, 0xC0, 0xC4, 0x50, 0x99, 0x4A, + 0x59, 0xCB, 0x61, 0xEC, 0xC0, 0xD1, 0x38, 0x4C, + 0x81, 0x9B, 0xA8, 0xBC, 0x8B, 0x5D, 0x48, 0x96, + 0xAB, 0x42, 0xBC, 0x3D, 0x63, 0x16, 0xAF, 0xC1, + 0x17, 0x5A, 0x1E, 0x57, 0xD5, 0xD9, 0xFA, 0x6E + }, + { + 0x9B, 0x9B, 0x60, 0x0E, 0x65, 0xBA, 0x90, 0xDE, + 0x8E, 0x67, 0x30, 0x22, 0x4D, 0xD4, 0x80, 0x0E, + 0xC0, 0xE6, 0x82, 0xBB, 0x03, 0xD6, 0x60, 0xE7, + 0x16, 0x8D, 0x14, 0x5F, 0x20, 0x91, 0xDB, 0x4B, + 0x71, 0x4E, 0x34, 0x4C, 0xDF, 0x02, 0x9F, 0x57, + 0x5D, 0x09, 0x65, 0x47, 0xAE, 0x6E, 0xD1, 0x80, + 0x73, 0x9B, 0xA1, 0x19, 0x3A, 0x75, 0xA2, 0x18, + 0x8F, 0xDD, 0x4B, 0xFD, 0xD8, 0x83, 0xA9, 0xD8 + }, + { + 0xE6, 0x03, 0xF3, 0x43, 0xBC, 0x24, 0x09, 0xC2, + 0x6D, 0x05, 0x08, 0x2B, 0x19, 0x89, 0x19, 0xE9, + 0x96, 0xA8, 0x7D, 0x59, 0x76, 0x44, 0xB7, 0x27, + 0x48, 0x1E, 0xBA, 0xD2, 0xEC, 0xB7, 0x47, 0x71, + 0x7B, 0x00, 0x11, 0xDF, 0xFC, 0x96, 0x31, 0x08, + 0xA3, 0xEC, 0x38, 0x1A, 0x2E, 0xD5, 0x94, 0x60, + 0x0F, 0xD3, 0x01, 0xE1, 0x77, 0x7F, 0x2E, 0x4E, + 0xA4, 0xF1, 0xF9, 0x41, 0x4B, 0x76, 0x38, 0x8A + }, + { + 0xB0, 0x3B, 0xB0, 0xED, 0xBD, 0xB8, 0xDE, 0xAB, + 0x75, 0x77, 0xE1, 0xE3, 0xDC, 0x88, 0x55, 0x4B, + 0xFF, 0xD4, 0x6F, 0x2F, 0x2A, 0x8E, 0xBF, 0x6E, + 0x9C, 0x8E, 0xF0, 0x90, 0xAD, 0x22, 0xDA, 0x76, + 0x74, 0xC4, 0x23, 0xF7, 0x12, 0xF7, 0x6F, 0xEA, + 0xDA, 0x6B, 0x15, 0x32, 0x20, 0x63, 0xFA, 0x08, + 0x39, 0xBA, 0x14, 0x07, 0x64, 0xEB, 0xE4, 0x6B, + 0xFF, 0x6E, 0x17, 0xAD, 0x2D, 0x82, 0x71, 0x53 + }, + { + 0xCA, 0xA7, 0x9B, 0xB9, 0xF4, 0xCA, 0x7E, 0xF9, + 0xBF, 0x10, 0x81, 0x4E, 0xD7, 0xE7, 0xE1, 0x89, + 0xA8, 0x1F, 0xAD, 0x1C, 0xF5, 0x53, 0x26, 0x68, + 0x6F, 0x27, 0x01, 0x30, 0x2A, 0xAB, 0x5B, 0xDF, + 0x81, 0xEA, 0xD6, 0x56, 0x1B, 0xFC, 0x9C, 0x74, + 0x1E, 0x25, 0xC4, 0x89, 0x47, 0xB8, 0x17, 0x9A, + 0x79, 0x40, 0x40, 0x47, 0xE3, 0x5A, 0xE9, 0x29, + 0xD1, 0xB7, 0x7D, 0x53, 0x72, 0x52, 0x7C, 0x8A + }, + { + 0xB5, 0xF7, 0x32, 0x74, 0xDB, 0x36, 0xF2, 0xF8, + 0xA9, 0x9A, 0x27, 0x90, 0xCC, 0xBC, 0xDB, 0xCB, + 0x6C, 0x82, 0x21, 0xA2, 0x4F, 0x6F, 0xA7, 0x32, + 0x4A, 0xD4, 0xA4, 0x23, 0x4D, 0xF1, 0x79, 0xFF, + 0x93, 0xEB, 0xD3, 0x26, 0x15, 0xBB, 0x6A, 0xA1, + 0xF9, 0xB4, 0x71, 0x77, 0x1E, 0x66, 0xF8, 0xC7, + 0xEC, 0x08, 0xD2, 0xBE, 0xC0, 0x2B, 0x8F, 0x1E, + 0x29, 0x4F, 0x97, 0x96, 0xD2, 0x0D, 0x34, 0x7F + }, + { + 0xB7, 0x03, 0xEC, 0xD8, 0xAD, 0x14, 0x9E, 0x9C, + 0xAE, 0x20, 0xC4, 0xD1, 0x9B, 0x5D, 0x38, 0x8A, + 0xB7, 0xD2, 0x2D, 0x17, 0xE0, 0xEC, 0xB1, 0x74, + 0x70, 0xA5, 0x96, 0x6E, 0x03, 0x5F, 0x1B, 0xB6, + 0x56, 0x37, 0x70, 0x77, 0x57, 0x97, 0x94, 0x97, + 0xF5, 0x9C, 0x4B, 0x76, 0x72, 0x7B, 0x03, 0xD7, + 0x3F, 0xC9, 0x56, 0xCB, 0x46, 0xAB, 0xA3, 0x8D, + 0x09, 0x3D, 0x8F, 0x77, 0xF9, 0x0A, 0xD0, 0x37 + }, + { + 0xCD, 0x12, 0x77, 0xC7, 0x79, 0xC0, 0x71, 0xA9, + 0xE4, 0x33, 0x09, 0xAA, 0x7F, 0x5D, 0x53, 0xFE, + 0xA7, 0x3D, 0x27, 0xBC, 0xBD, 0x85, 0xB9, 0x87, + 0x6E, 0xB3, 0x3F, 0x1E, 0xE2, 0x55, 0xF2, 0x79, + 0x70, 0xF1, 0xAF, 0x26, 0x3C, 0x05, 0xFF, 0xAD, + 0xD2, 0xFB, 0xE7, 0x92, 0xAF, 0xE7, 0xE1, 0x3C, + 0x29, 0xD5, 0x16, 0x4B, 0x27, 0x7C, 0x01, 0x22, + 0xA5, 0x6E, 0x35, 0x99, 0x97, 0x14, 0xBA, 0x99 + }, + { + 0x77, 0x4C, 0x58, 0xB5, 0x56, 0x7F, 0x47, 0x92, + 0x53, 0xC7, 0x83, 0xB2, 0x65, 0x06, 0xCE, 0x58, + 0x79, 0xC2, 0xE7, 0xB5, 0x80, 0x3E, 0x1F, 0x34, + 0x71, 0x3B, 0xEF, 0x7F, 0x9C, 0xC5, 0x2F, 0x10, + 0xF9, 0xC7, 0x75, 0x44, 0x42, 0x57, 0x9F, 0xC4, + 0x67, 0x67, 0xD5, 0xC9, 0x07, 0xDB, 0x7F, 0xBE, + 0x1D, 0xFD, 0xD0, 0x16, 0xFB, 0xEC, 0x83, 0xA3, + 0xA0, 0x76, 0x4E, 0x83, 0xCF, 0x43, 0xF4, 0x84 + }, + { + 0x53, 0xC3, 0x6E, 0x66, 0xBA, 0xCD, 0x90, 0xC3, + 0x43, 0x4C, 0x14, 0x17, 0xC3, 0xAE, 0xEE, 0xE1, + 0xA5, 0x85, 0x12, 0xB7, 0x29, 0x92, 0x2B, 0x5F, + 0x31, 0xF4, 0x49, 0x51, 0xB4, 0x5E, 0xD5, 0x20, + 0x73, 0x69, 0x0B, 0x53, 0x97, 0xEC, 0x0B, 0xB9, + 0x42, 0xC0, 0x90, 0x0C, 0x75, 0xDE, 0x50, 0xB1, + 0xE3, 0x7F, 0xA3, 0x5D, 0x70, 0x77, 0x38, 0xD5, + 0xD7, 0x5F, 0x9C, 0xC0, 0x38, 0x6C, 0x3C, 0x27 + }, + { + 0x92, 0xDB, 0x80, 0xE7, 0x73, 0x8D, 0xB8, 0xA0, + 0xCE, 0xB0, 0x97, 0x10, 0x92, 0x1B, 0xF6, 0x99, + 0x5E, 0xF7, 0x4E, 0xC9, 0x31, 0x1B, 0x19, 0x78, + 0x7B, 0x21, 0xF2, 0x10, 0x83, 0x2C, 0x6F, 0x98, + 0x52, 0x70, 0x80, 0x6A, 0x73, 0x39, 0x36, 0x77, + 0x38, 0x65, 0xA7, 0xE3, 0x60, 0x11, 0xFE, 0x67, + 0xC4, 0x27, 0x7B, 0x19, 0xE0, 0x02, 0x65, 0x82, + 0xED, 0x51, 0x5A, 0x29, 0x90, 0x1F, 0xBC, 0x58 + }, + { + 0xB4, 0xC1, 0xB3, 0x91, 0x45, 0xAB, 0xC0, 0x1B, + 0x1D, 0xAA, 0x81, 0x13, 0xD4, 0x4C, 0x07, 0x73, + 0x29, 0x50, 0x81, 0x6B, 0x23, 0x44, 0x55, 0x57, + 0x7B, 0xA7, 0x9D, 0x82, 0x3C, 0xD3, 0xC6, 0x2F, + 0xE4, 0x4E, 0x17, 0x51, 0xC3, 0xCD, 0x02, 0x9A, + 0x73, 0x03, 0xB2, 0x69, 0xC1, 0x1F, 0x00, 0x5A, + 0x85, 0xB9, 0xEB, 0xEC, 0x35, 0x3A, 0x4A, 0x4D, + 0xDC, 0xD6, 0x2E, 0x9F, 0x93, 0x46, 0x27, 0xEB + }, + { + 0x3F, 0x34, 0xBC, 0x53, 0x4D, 0x8B, 0x86, 0x27, + 0xFD, 0xD8, 0x83, 0x1E, 0xC1, 0x0A, 0xDF, 0xDC, + 0xBD, 0xBE, 0x5D, 0x7A, 0x85, 0x2B, 0x6E, 0x5D, + 0x94, 0x43, 0x89, 0xD6, 0xA6, 0xEC, 0xD2, 0x28, + 0xAF, 0x40, 0xE1, 0x0E, 0x3F, 0x00, 0x79, 0x71, + 0x15, 0x22, 0xC0, 0x28, 0xC7, 0x59, 0x30, 0x3B, + 0xC9, 0x39, 0xCB, 0x85, 0x31, 0xD8, 0xB4, 0xDE, + 0xEE, 0x51, 0x61, 0x86, 0x8B, 0xA2, 0x26, 0x66 + }, + { + 0x13, 0x74, 0xF8, 0xE1, 0x68, 0xFB, 0x30, 0x3F, + 0xDB, 0xD3, 0x7C, 0x6D, 0x95, 0x94, 0x58, 0x84, + 0x86, 0x9A, 0x23, 0x9F, 0x73, 0xCB, 0x17, 0x83, + 0x02, 0xFE, 0x92, 0xA5, 0xBE, 0x9F, 0x70, 0x18, + 0xEA, 0x0C, 0x01, 0xCE, 0x84, 0xD2, 0xEF, 0xDB, + 0x27, 0xF3, 0x29, 0x73, 0x6D, 0xF2, 0x8A, 0x9F, + 0x98, 0xA8, 0x7B, 0x27, 0xE5, 0xE4, 0x4A, 0x32, + 0x25, 0x1A, 0xB7, 0x76, 0xC7, 0xA3, 0xDB, 0x76 + }, + { + 0xB6, 0xF5, 0x37, 0x16, 0x6D, 0xDD, 0x22, 0xEA, + 0x55, 0x4A, 0x60, 0xD8, 0x31, 0xDB, 0xC9, 0x3B, + 0x52, 0xEF, 0xFF, 0xA3, 0x90, 0x5B, 0xFF, 0x77, + 0xBB, 0x6C, 0x42, 0xB9, 0x8B, 0x49, 0x2E, 0x1F, + 0x45, 0x16, 0xD0, 0xEE, 0x8D, 0xA8, 0x1D, 0x37, + 0x17, 0xB9, 0x32, 0x34, 0x3F, 0xAC, 0x9E, 0x6E, + 0x0C, 0xF0, 0x40, 0x2F, 0x43, 0xFF, 0x77, 0xD4, + 0x47, 0xC5, 0xE0, 0xFB, 0x84, 0x04, 0xF4, 0xC2 + }, + { + 0x35, 0x12, 0x5E, 0x0A, 0x7F, 0x6F, 0xC6, 0x4D, + 0xBF, 0xF9, 0x56, 0xC6, 0xB2, 0x52, 0x21, 0xE6, + 0xE6, 0x04, 0xA9, 0x0B, 0x43, 0x19, 0x15, 0x57, + 0x09, 0x70, 0x36, 0x19, 0x8B, 0xB3, 0x6B, 0x7E, + 0x87, 0x41, 0xFA, 0x75, 0xCF, 0xA5, 0x9E, 0x08, + 0x99, 0x8F, 0xDD, 0x91, 0xAA, 0xD8, 0xBC, 0x54, + 0xFC, 0xFA, 0xFF, 0xEF, 0xEE, 0x18, 0x0A, 0x02, + 0xA0, 0x18, 0xA1, 0x01, 0x1F, 0x9D, 0x0B, 0x93 + }, + { + 0x54, 0xF7, 0x60, 0x28, 0x4B, 0xE4, 0xC5, 0x4B, + 0x20, 0x09, 0x47, 0xE9, 0xC7, 0x35, 0xEF, 0xE5, + 0x29, 0x7F, 0x8E, 0xB1, 0x6C, 0xAF, 0x1C, 0x27, + 0xEE, 0x6E, 0x4B, 0x5D, 0x17, 0xCB, 0xB7, 0xDD, + 0x70, 0xD4, 0xFE, 0xB3, 0xBB, 0x92, 0x97, 0xE0, + 0x7B, 0x87, 0x7D, 0xD2, 0x5D, 0xEF, 0x16, 0x80, + 0xB9, 0xB3, 0x98, 0xA4, 0x09, 0xC4, 0x1F, 0xBC, + 0x0E, 0x9B, 0xF2, 0x59, 0x5A, 0x1A, 0x3A, 0x20 + }, + { + 0x37, 0x79, 0x2C, 0xDA, 0x03, 0x02, 0x38, 0x4B, + 0x48, 0x52, 0xD8, 0x64, 0x87, 0x2B, 0x70, 0x90, + 0xD4, 0x22, 0x0A, 0x06, 0x11, 0xFA, 0xC9, 0xF8, + 0xF4, 0x49, 0xE1, 0x7C, 0xC6, 0x0C, 0xC2, 0x95, + 0xB9, 0x8E, 0xF8, 0x6C, 0x31, 0xCB, 0x3C, 0xE4, + 0x97, 0xC1, 0x62, 0x32, 0x14, 0xFE, 0xA9, 0x7E, + 0xA6, 0x05, 0xEF, 0x15, 0xB7, 0xB8, 0x1D, 0xAA, + 0xB5, 0xE6, 0x81, 0x6B, 0x79, 0x9A, 0xBB, 0x9E + }, + { + 0x80, 0xB6, 0x40, 0xD5, 0x5E, 0x65, 0x64, 0xCA, + 0x67, 0x18, 0x70, 0xC6, 0x8A, 0xED, 0x06, 0xD4, + 0x04, 0xEF, 0x71, 0x07, 0x0A, 0x72, 0x90, 0xD5, + 0x5D, 0x74, 0x3A, 0x2C, 0x57, 0xFC, 0x34, 0xC8, + 0xB0, 0x5C, 0x9D, 0x9A, 0xC3, 0xFE, 0x28, 0x03, + 0x21, 0x25, 0x8B, 0x60, 0x53, 0x40, 0xBB, 0x37, + 0x23, 0xCC, 0x27, 0xBE, 0xE2, 0x3D, 0x63, 0x35, + 0x2B, 0xB7, 0xC7, 0x64, 0x83, 0xCD, 0x32, 0xE0 + }, + { + 0x58, 0x40, 0xD5, 0x4F, 0xB3, 0xF7, 0x22, 0x7F, + 0xDC, 0x32, 0x57, 0x76, 0x70, 0x16, 0xCF, 0xBD, + 0xD1, 0x0D, 0xA7, 0x12, 0x70, 0xCE, 0x4A, 0x5B, + 0xDF, 0xE0, 0x2F, 0xDB, 0x1F, 0xD6, 0x3F, 0x97, + 0x04, 0x7C, 0x67, 0x9B, 0x06, 0xA1, 0xBA, 0x96, + 0xCE, 0x72, 0xD2, 0xB6, 0x0B, 0xD5, 0x76, 0x35, + 0xA4, 0x1C, 0xAE, 0x74, 0xA4, 0xA7, 0xB6, 0x0D, + 0xCB, 0x8E, 0x3A, 0x65, 0x1B, 0x79, 0xC7, 0x84 + }, + { + 0x2D, 0x02, 0x03, 0x07, 0x7E, 0x2F, 0x36, 0x0D, + 0x86, 0xC3, 0xAB, 0x9B, 0x3A, 0x92, 0x78, 0x6F, + 0x6E, 0x90, 0xDC, 0xCD, 0x19, 0x19, 0x00, 0xA3, + 0x4A, 0xEB, 0x39, 0x84, 0x96, 0x18, 0x47, 0xC4, + 0xB9, 0x9D, 0x4E, 0xCC, 0xFE, 0x24, 0x3A, 0x6B, + 0x5D, 0x68, 0x38, 0x22, 0xCE, 0x77, 0x7C, 0x72, + 0x65, 0x6B, 0x1D, 0xE1, 0x48, 0x8D, 0x43, 0x23, + 0x49, 0x6E, 0x48, 0x46, 0xB1, 0x25, 0xCA, 0x99 + }, + { + 0xB4, 0xB8, 0xDD, 0x15, 0xE2, 0xCA, 0x25, 0x93, + 0xA6, 0xA7, 0xA7, 0x32, 0x4B, 0x9C, 0x70, 0xF6, + 0xCE, 0xD7, 0x8D, 0x65, 0x69, 0x9F, 0x67, 0xF7, + 0x5B, 0x68, 0x87, 0xA9, 0xB4, 0xA4, 0x29, 0xE5, + 0xCF, 0x5D, 0x8F, 0x72, 0xE1, 0x44, 0x29, 0x91, + 0xA6, 0xF1, 0x0C, 0x7D, 0xE4, 0x0D, 0x4B, 0x2B, + 0xE0, 0xCD, 0x6A, 0x1F, 0x35, 0xFE, 0xAA, 0xDB, + 0x29, 0xA5, 0xA8, 0xDD, 0x8D, 0x33, 0x78, 0xDF + }, + { + 0x16, 0x3A, 0xD1, 0x96, 0x4A, 0x22, 0x58, 0x62, + 0x4E, 0xC7, 0x4A, 0x0A, 0x6C, 0x97, 0x14, 0x19, + 0x2D, 0xD8, 0x2F, 0x7A, 0x4B, 0x46, 0x2A, 0xDD, + 0xCE, 0x72, 0xAF, 0x7D, 0x98, 0x17, 0x25, 0x67, + 0x60, 0xD4, 0x90, 0xD2, 0x7B, 0xEA, 0x14, 0xBA, + 0x59, 0x05, 0x33, 0x9B, 0x35, 0x53, 0x7D, 0xDF, + 0x9E, 0xEC, 0x59, 0xAF, 0xF1, 0x2D, 0x04, 0xFA, + 0xC2, 0xA0, 0x26, 0x2D, 0x5D, 0xF2, 0x67, 0xB1 + }, + { + 0x9B, 0xD0, 0x30, 0x73, 0xED, 0x8C, 0x32, 0x17, + 0xC4, 0x4E, 0x71, 0x62, 0xDA, 0xBC, 0x7E, 0xB0, + 0x7E, 0x31, 0x99, 0xA0, 0x11, 0x63, 0xF5, 0x6D, + 0x69, 0x0E, 0x1F, 0xBE, 0xC5, 0x98, 0x49, 0xAB, + 0xF9, 0x0E, 0x9D, 0x44, 0x55, 0x54, 0x5B, 0x03, + 0x8D, 0xA3, 0x48, 0x0F, 0x9F, 0x28, 0x93, 0x61, + 0x53, 0x0C, 0xFE, 0x17, 0xDF, 0xC4, 0x82, 0x3A, + 0x8D, 0x91, 0x0D, 0xA7, 0x1E, 0xE6, 0x40, 0xEB + }, + { + 0xDA, 0xDB, 0x6B, 0x94, 0x71, 0x59, 0x7F, 0x63, + 0x6F, 0x92, 0x1B, 0x46, 0xDB, 0xDD, 0x07, 0xED, + 0x1E, 0xDE, 0x4F, 0x08, 0xE9, 0x1E, 0xA9, 0x8C, + 0xDD, 0x34, 0x1F, 0xD5, 0x9D, 0x81, 0xC0, 0x09, + 0xD8, 0x63, 0x5C, 0xCF, 0x0B, 0xFF, 0x18, 0x0C, + 0x2B, 0x4A, 0x30, 0x5B, 0xBA, 0xC8, 0x09, 0x72, + 0xBE, 0x79, 0x1F, 0xEF, 0xC7, 0x8B, 0x22, 0x2D, + 0xAD, 0xF5, 0x3F, 0xBC, 0x21, 0x3D, 0x7C, 0xF9 + }, + { + 0x72, 0x30, 0xE0, 0x81, 0x1E, 0xE6, 0x23, 0xFE, + 0x76, 0xD2, 0x79, 0x5E, 0x48, 0x21, 0xA9, 0x66, + 0x2D, 0x1A, 0x14, 0x76, 0xD7, 0xC5, 0xFB, 0x55, + 0xFA, 0x02, 0xBD, 0x4A, 0x3B, 0x7D, 0x8D, 0x5B, + 0x0F, 0xC0, 0xE9, 0x6D, 0x13, 0x73, 0x87, 0xC6, + 0xCE, 0xA1, 0xE6, 0xF0, 0x00, 0x57, 0xCB, 0x6B, + 0xFA, 0x50, 0xF5, 0x91, 0x80, 0xAD, 0xD5, 0xF6, + 0x4D, 0xD0, 0x4F, 0xB4, 0x61, 0xDF, 0xBC, 0xF8 + }, + { + 0xDB, 0x7A, 0x7D, 0x45, 0xF2, 0xAA, 0xD1, 0xB8, + 0x33, 0x4D, 0x45, 0x1F, 0x03, 0x05, 0x3A, 0x1B, + 0x74, 0x1B, 0xEB, 0xE0, 0x13, 0x70, 0xCC, 0xAF, + 0x4A, 0xF0, 0xF9, 0xA6, 0x0E, 0x8E, 0x5E, 0x5C, + 0x41, 0x92, 0x07, 0x3F, 0xB8, 0xC9, 0x96, 0x17, + 0xE2, 0x5E, 0x35, 0x8D, 0xEE, 0xC6, 0x9C, 0x1B, + 0x8C, 0x6F, 0x36, 0xCF, 0x1C, 0xB1, 0xC3, 0x8C, + 0xE9, 0x2A, 0x7D, 0xEC, 0xF2, 0x06, 0x9A, 0x90 + }, + { + 0x92, 0x91, 0x55, 0xD3, 0xBC, 0x70, 0x6A, 0x3B, + 0x86, 0x59, 0x96, 0xF7, 0x91, 0x96, 0x80, 0x5D, + 0xF5, 0xFB, 0xFD, 0x64, 0xBA, 0x92, 0xED, 0xA0, + 0x27, 0x92, 0x92, 0x00, 0x0A, 0x4F, 0xE7, 0x5A, + 0x45, 0xA1, 0xF6, 0x76, 0x2A, 0x8E, 0xE5, 0xAD, + 0xB2, 0x10, 0x2E, 0x19, 0x8E, 0xE8, 0x2F, 0xFF, + 0x8B, 0xFE, 0x2B, 0x8A, 0x23, 0x6C, 0x1E, 0x9D, + 0xEC, 0x49, 0x6C, 0xF3, 0x24, 0x77, 0x71, 0xFC + }, + { + 0xCC, 0xD1, 0xDA, 0x32, 0xBC, 0xEB, 0x9F, 0xED, + 0xFC, 0x09, 0xF7, 0x38, 0x77, 0xFE, 0x42, 0x54, + 0x40, 0x98, 0x6F, 0x04, 0x7E, 0xEB, 0x2F, 0xE1, + 0xD3, 0x7F, 0xD9, 0x71, 0x5B, 0x9E, 0x15, 0x03, + 0xE7, 0x2A, 0xC6, 0xAA, 0xF7, 0x69, 0x86, 0xF9, + 0x9C, 0xB1, 0x14, 0x74, 0xEF, 0x75, 0x0A, 0xC0, + 0x61, 0xB5, 0xBE, 0xB0, 0x56, 0x5D, 0x29, 0xB6, + 0x4A, 0x7E, 0x08, 0x8B, 0x44, 0x5C, 0x0B, 0xFA + }, + { + 0x31, 0x1E, 0xFB, 0x89, 0xE6, 0x56, 0x9F, 0xFF, + 0xCA, 0x2A, 0xB1, 0xFC, 0x58, 0x97, 0x85, 0x59, + 0xDF, 0x9F, 0xC7, 0x0D, 0x93, 0xEE, 0x05, 0x4F, + 0x25, 0x48, 0x38, 0xC8, 0xC5, 0x8F, 0x7E, 0x47, + 0xED, 0xF0, 0xCA, 0xF5, 0x89, 0x19, 0x48, 0xAF, + 0x01, 0x2B, 0xF9, 0x97, 0xF3, 0x46, 0x4A, 0xC9, + 0x05, 0xA7, 0x58, 0x63, 0x08, 0xAB, 0xED, 0x2B, + 0xEC, 0xCC, 0xA4, 0x71, 0xB8, 0xEE, 0x40, 0xF7 + }, + { + 0xB2, 0xD2, 0x6D, 0x35, 0xD7, 0x92, 0xEF, 0xCB, + 0xB6, 0xF1, 0xD7, 0x99, 0x38, 0x0A, 0x88, 0x5A, + 0x34, 0xE0, 0xFF, 0xB5, 0x13, 0xF1, 0xA9, 0x7E, + 0xF9, 0x4C, 0xFE, 0x46, 0xB0, 0x17, 0xBD, 0x01, + 0x66, 0x1B, 0x6A, 0x20, 0x6C, 0xF4, 0x88, 0x15, + 0x6C, 0xFA, 0xAE, 0x31, 0x1B, 0x94, 0x2B, 0xED, + 0x87, 0x62, 0x7B, 0xF7, 0x5E, 0x32, 0x91, 0xE4, + 0xB3, 0x92, 0x0F, 0x14, 0x87, 0x15, 0x11, 0xB3 + }, + { + 0xE4, 0x94, 0x3E, 0x0E, 0xDD, 0x7C, 0xF8, 0x2C, + 0xD4, 0xCF, 0x37, 0x34, 0x9A, 0xE5, 0x54, 0x64, + 0x17, 0xF0, 0x3C, 0xA2, 0x27, 0x0F, 0xEC, 0xAF, + 0xA0, 0xA6, 0xEB, 0xA7, 0x53, 0xD0, 0xBB, 0xD7, + 0x92, 0xC8, 0x9C, 0x78, 0xA8, 0x6B, 0x2F, 0xFE, + 0xE5, 0xD3, 0x02, 0x20, 0x72, 0x89, 0xF3, 0x67, + 0xD1, 0xEE, 0xE2, 0x6C, 0x2E, 0x4E, 0x83, 0x09, + 0xE4, 0x23, 0x84, 0xA3, 0x10, 0x3C, 0x0D, 0x8E + }, + { + 0x47, 0x11, 0x25, 0xE4, 0x31, 0xFE, 0x3B, 0x62, + 0xEB, 0xAE, 0xB5, 0xAB, 0xDC, 0x27, 0xE8, 0xA6, + 0x83, 0x7F, 0xA7, 0x0E, 0x4C, 0x5D, 0x70, 0x04, + 0xE2, 0x66, 0x68, 0xE8, 0x5B, 0x41, 0x0F, 0x8E, + 0x75, 0x26, 0xB1, 0xC6, 0xEC, 0x7A, 0xDF, 0xCE, + 0xC3, 0x7D, 0xE3, 0xCD, 0xB8, 0x4E, 0x3F, 0x19, + 0xE0, 0xAA, 0xBA, 0xEE, 0x21, 0xB1, 0x1A, 0xE2, + 0x73, 0x12, 0xEE, 0xFE, 0x32, 0x69, 0xD7, 0x9C + }, + { + 0xEA, 0xAD, 0x86, 0x06, 0x54, 0x19, 0x3E, 0xC3, + 0x73, 0xC1, 0x77, 0x6B, 0x52, 0x9D, 0xBC, 0xC7, + 0x18, 0x03, 0x81, 0xA9, 0x3B, 0x53, 0xB8, 0xF7, + 0xDF, 0xE8, 0xE2, 0x92, 0x26, 0xF4, 0x84, 0xCB, + 0xC8, 0x98, 0x5F, 0x46, 0x10, 0xD6, 0xA8, 0xF9, + 0x45, 0xC6, 0x79, 0xE5, 0xB5, 0x5A, 0x8D, 0x24, + 0xE8, 0x14, 0xF4, 0xC5, 0xDF, 0x48, 0x3C, 0x6A, + 0xF5, 0x86, 0x84, 0x96, 0xE0, 0xBB, 0x0B, 0x17 + }, + { + 0x3B, 0x0A, 0xB7, 0x8F, 0xF3, 0xEB, 0xA5, 0xE5, + 0x68, 0x12, 0x5F, 0xEF, 0x79, 0x00, 0x0D, 0x42, + 0x11, 0xE7, 0xE0, 0x21, 0x2A, 0x28, 0x27, 0x1D, + 0x0F, 0x90, 0xD2, 0xAB, 0xFE, 0xC9, 0x69, 0x35, + 0x9E, 0x2E, 0x6D, 0x74, 0xEE, 0x4F, 0x38, 0x56, + 0xD6, 0x9F, 0xCA, 0x90, 0x1A, 0x88, 0xFE, 0xC0, + 0xC5, 0x11, 0x2B, 0xD9, 0xE7, 0x7E, 0xB1, 0x3B, + 0xC7, 0x6C, 0x6A, 0x0F, 0x07, 0x08, 0x83, 0x1C + }, + { + 0x4F, 0x45, 0xEF, 0xC6, 0x69, 0x58, 0x80, 0x51, + 0xAC, 0x63, 0x70, 0x34, 0x80, 0x7C, 0x67, 0xA2, + 0xC7, 0xF8, 0x11, 0xDA, 0xFE, 0x53, 0xA5, 0x94, + 0x2C, 0xCD, 0x5C, 0x7E, 0xF0, 0x8D, 0xF5, 0xEC, + 0x31, 0xFC, 0x37, 0xE5, 0x58, 0x68, 0xD9, 0xB4, + 0xB5, 0xBD, 0x8D, 0x93, 0xCB, 0xE3, 0x96, 0x14, + 0xA4, 0x17, 0xC1, 0x35, 0x63, 0x97, 0x4D, 0xF9, + 0xB0, 0xDE, 0xAF, 0x5A, 0x53, 0x7F, 0x7D, 0x60 + }, + { + 0x55, 0x3A, 0xCC, 0x98, 0xE9, 0xA2, 0xB5, 0x85, + 0x86, 0x34, 0x85, 0xD0, 0x07, 0xF7, 0x17, 0x74, + 0x1E, 0x4C, 0x12, 0x79, 0x44, 0xD4, 0x79, 0xB3, + 0xFE, 0x9B, 0xAE, 0x2A, 0x4B, 0x79, 0xDC, 0x36, + 0xF1, 0x14, 0x83, 0xEB, 0x9F, 0xDE, 0xD2, 0xA8, + 0x28, 0xA1, 0x70, 0xAB, 0x32, 0x13, 0xD6, 0xBC, + 0x04, 0x9A, 0x01, 0x37, 0xCF, 0x36, 0xAC, 0x58, + 0x35, 0x27, 0xA8, 0xDE, 0xC7, 0x4F, 0xDD, 0x64 + }, + { + 0x19, 0xE5, 0x9D, 0xF2, 0x02, 0x1E, 0xA0, 0x52, + 0xFB, 0xF8, 0xED, 0x4F, 0x07, 0xDF, 0x4A, 0x2C, + 0x14, 0xC9, 0x1D, 0x3B, 0xAD, 0x26, 0x67, 0x02, + 0xE8, 0x7A, 0xD7, 0x6C, 0x28, 0x1A, 0xF5, 0xE2, + 0xFB, 0x20, 0x6B, 0xA8, 0xE6, 0x4B, 0xE1, 0x10, + 0xC2, 0xE2, 0x00, 0xE7, 0xF5, 0x18, 0x2E, 0xC7, + 0x0E, 0x04, 0x13, 0xB1, 0xE4, 0x9D, 0x1C, 0xA4, + 0xA6, 0x02, 0xEC, 0x83, 0x36, 0xE7, 0x03, 0x22 + }, + { + 0xC2, 0x45, 0x2F, 0xC5, 0x9D, 0x8D, 0xB5, 0x01, + 0x54, 0x67, 0x20, 0x6C, 0x42, 0x80, 0x7D, 0x2F, + 0x38, 0x20, 0xA9, 0x5E, 0x1E, 0x80, 0xF1, 0x12, + 0xD9, 0x14, 0x4D, 0x93, 0x41, 0x47, 0x37, 0xF8, + 0x7E, 0x83, 0x50, 0x05, 0x08, 0xE9, 0x45, 0x83, + 0xB4, 0xD9, 0x3F, 0x6E, 0x38, 0x7D, 0xAD, 0xE8, + 0xB1, 0x3A, 0xBB, 0xCC, 0x7D, 0x37, 0xAF, 0xDD, + 0x65, 0x22, 0x60, 0x01, 0x80, 0x61, 0xAF, 0x25 + }, + { + 0x4A, 0x12, 0xC8, 0xA7, 0x7E, 0xF5, 0x77, 0xB5, + 0x31, 0x0E, 0xCF, 0xBC, 0xC7, 0x4C, 0x30, 0xB7, + 0x87, 0x6D, 0x61, 0x78, 0xAC, 0x66, 0xE7, 0x16, + 0x4F, 0x14, 0x0F, 0x3D, 0x96, 0x06, 0xA1, 0x91, + 0x09, 0x79, 0xAC, 0xBB, 0xA3, 0xDE, 0xEB, 0x16, + 0xCC, 0x45, 0x5E, 0xAE, 0x66, 0xE0, 0x9E, 0x84, + 0x95, 0x5F, 0xAE, 0xB9, 0xE5, 0xEA, 0x6C, 0xA1, + 0xAE, 0x1C, 0xCA, 0xA7, 0x48, 0xF4, 0x85, 0xF9 + }, + { + 0xAC, 0x1A, 0x05, 0xF8, 0x5A, 0x29, 0xE1, 0x19, + 0x10, 0xBE, 0xE1, 0x38, 0x8C, 0x6F, 0x9E, 0x7B, + 0x14, 0x22, 0x23, 0x9C, 0xE0, 0x40, 0x0A, 0x91, + 0xC3, 0xE6, 0xD2, 0xD1, 0xF8, 0x62, 0x0E, 0x21, + 0x01, 0x17, 0x22, 0xFA, 0x4F, 0xF7, 0x7A, 0x22, + 0x1F, 0x61, 0xDF, 0xE3, 0x5C, 0xC3, 0xBC, 0xB1, + 0xE9, 0x8E, 0x66, 0x6E, 0xAF, 0xC4, 0x65, 0x04, + 0x03, 0x3C, 0xEC, 0x4C, 0x3F, 0xB6, 0xEC, 0x5F + }, + { + 0xCA, 0x33, 0x03, 0x89, 0x7E, 0xBA, 0xE6, 0xC7, + 0xB8, 0x3B, 0x6E, 0x4E, 0x48, 0x4D, 0x85, 0x78, + 0xB9, 0xDE, 0x59, 0x1D, 0xC1, 0x6C, 0x15, 0x5B, + 0x99, 0x5E, 0xE7, 0xBC, 0xBA, 0xEE, 0x74, 0x3D, + 0x6A, 0xAC, 0xC0, 0xAB, 0x8C, 0x38, 0xF8, 0xF3, + 0x8D, 0x9D, 0xDA, 0xFD, 0x99, 0xE4, 0xAC, 0xBE, + 0xC9, 0xE9, 0xA6, 0xFC, 0xC2, 0x2D, 0x88, 0x95, + 0x80, 0x55, 0xC9, 0x16, 0x30, 0x28, 0x62, 0x9D + }, + { + 0x8F, 0x05, 0xD7, 0xEC, 0xA4, 0x1D, 0x3A, 0xB2, + 0xCC, 0x2D, 0xC7, 0x4F, 0x7D, 0x0E, 0x62, 0x45, + 0x28, 0x9D, 0xE6, 0x47, 0x3B, 0xF8, 0xE4, 0x0C, + 0xAC, 0x85, 0xE3, 0xC4, 0x67, 0x59, 0xBD, 0xD5, + 0xB2, 0x75, 0x2F, 0x71, 0x38, 0xDC, 0xA2, 0xFE, + 0x57, 0x57, 0x63, 0xED, 0x80, 0x6F, 0xE5, 0x51, + 0x15, 0x09, 0xAF, 0xFC, 0x3D, 0x49, 0x42, 0xF8, + 0x02, 0x82, 0xB5, 0xB0, 0xE9, 0x99, 0xE9, 0xC6 + }, + { + 0x5F, 0xF3, 0xB4, 0xD8, 0x89, 0x8D, 0x3E, 0x96, + 0x92, 0x3E, 0x4F, 0x0F, 0x2A, 0x6D, 0xFC, 0x18, + 0xFF, 0xDD, 0xE7, 0xDC, 0xDB, 0xEC, 0x64, 0x5C, + 0x59, 0x43, 0x79, 0x3B, 0x01, 0x54, 0x36, 0xF9, + 0xC1, 0xAD, 0x78, 0x3D, 0x75, 0xEC, 0x61, 0x59, + 0x91, 0x6F, 0x58, 0x84, 0xBA, 0xEE, 0x90, 0x79, + 0x72, 0x7E, 0x6D, 0xE3, 0xF5, 0x24, 0xAF, 0xAF, + 0x70, 0xAE, 0xBE, 0x75, 0x1F, 0xCF, 0x80, 0x46 + }, + { + 0x5F, 0x28, 0xA8, 0x64, 0x06, 0x9D, 0xB0, 0xBD, + 0x8A, 0x6B, 0x43, 0xBB, 0xA4, 0x56, 0x74, 0x73, + 0x75, 0x51, 0x66, 0xFC, 0xEA, 0x68, 0x9B, 0xB1, + 0x2E, 0x33, 0xBE, 0xAA, 0x66, 0x91, 0x48, 0xD2, + 0xA2, 0x52, 0x60, 0x8D, 0xE4, 0x9B, 0xE4, 0x16, + 0x6E, 0x81, 0x95, 0x6F, 0x08, 0x9E, 0x76, 0x49, + 0x5A, 0xA5, 0xBD, 0xC0, 0x57, 0xCD, 0x4B, 0xCC, + 0x8E, 0xD2, 0x3F, 0x67, 0x75, 0x0D, 0xD8, 0x2B + }, + { + 0xB2, 0xE3, 0x97, 0xFB, 0x00, 0xF2, 0xAA, 0xFA, + 0x6B, 0xAE, 0x48, 0x4B, 0x41, 0x05, 0xB0, 0x45, + 0xC8, 0xBA, 0x38, 0x56, 0x8B, 0x93, 0x3D, 0x83, + 0x46, 0x64, 0x2B, 0x4F, 0x71, 0xAB, 0xAC, 0x56, + 0x75, 0x59, 0x40, 0xAA, 0xF4, 0x11, 0xEA, 0x66, + 0xC4, 0xEE, 0x4B, 0x87, 0x9B, 0x37, 0x92, 0xC0, + 0x03, 0x88, 0x45, 0x4A, 0x9C, 0x76, 0x4C, 0xB1, + 0xEA, 0x48, 0xEA, 0x33, 0xD8, 0x6B, 0x95, 0xAA + }, + { + 0xB7, 0xBA, 0xD4, 0x08, 0x17, 0xE9, 0xC9, 0xAF, + 0xF7, 0x63, 0x79, 0xEA, 0xC1, 0x5D, 0xAD, 0x84, + 0x3C, 0x48, 0xD4, 0x2C, 0x30, 0xD5, 0x71, 0x38, + 0xE7, 0x20, 0x73, 0x76, 0x91, 0x7A, 0xF7, 0xDD, + 0xBF, 0x22, 0x01, 0xCC, 0x16, 0x6E, 0x85, 0x33, + 0x16, 0x35, 0x88, 0x1A, 0x7B, 0x3F, 0xE0, 0x7A, + 0x93, 0x06, 0x49, 0xEA, 0x41, 0xEB, 0xD8, 0x4F, + 0xB5, 0x31, 0xD7, 0x84, 0xFF, 0x44, 0xB1, 0x9E + }, + { + 0x23, 0x3B, 0x71, 0x2E, 0x5C, 0x16, 0x86, 0xF6, + 0x8B, 0x23, 0xB7, 0xDE, 0x50, 0x86, 0x8E, 0xA1, + 0x98, 0x66, 0x03, 0x4A, 0xE4, 0x53, 0x73, 0xD6, + 0xCE, 0x1D, 0x59, 0x12, 0x53, 0x24, 0x44, 0xAB, + 0xA1, 0xF9, 0xE2, 0xB2, 0x57, 0x1D, 0xBD, 0xAA, + 0xF5, 0x75, 0x11, 0x71, 0x4A, 0xCC, 0x76, 0x9E, + 0x06, 0x0F, 0xC4, 0x90, 0x91, 0xF7, 0x10, 0x68, + 0xF5, 0x0D, 0xB6, 0xD3, 0x19, 0xA2, 0x9C, 0xDA + }, + { + 0x91, 0x7E, 0xF1, 0xC9, 0x9D, 0x1E, 0xDF, 0xB4, + 0x17, 0xA3, 0x8E, 0xCC, 0x56, 0x26, 0x8D, 0x89, + 0xAD, 0xBF, 0xFB, 0x50, 0xB8, 0x15, 0x00, 0x5B, + 0xE7, 0xE7, 0x45, 0xCE, 0x28, 0x20, 0xDF, 0x83, + 0xED, 0x15, 0x2A, 0x2C, 0xE8, 0xD8, 0x3E, 0x12, + 0x8B, 0x9B, 0x6B, 0x5B, 0x2E, 0x2F, 0x85, 0x89, + 0x82, 0x16, 0x94, 0x73, 0xE7, 0xC7, 0x0D, 0x97, + 0x4B, 0x81, 0xEE, 0xB6, 0x4F, 0x30, 0x69, 0x0C + }, + { + 0xC0, 0x1E, 0x59, 0x12, 0x2A, 0x90, 0x0A, 0x46, + 0x2F, 0x97, 0xAB, 0x6B, 0x5F, 0x4F, 0x59, 0xF0, + 0xFE, 0x79, 0xC6, 0xAD, 0x63, 0x88, 0xB0, 0xD6, + 0xFE, 0x57, 0x89, 0x0A, 0xB8, 0x30, 0x29, 0x5B, + 0x94, 0x30, 0xFF, 0x3C, 0xBF, 0x1F, 0x68, 0x3A, + 0x54, 0xC6, 0xD1, 0xBA, 0xCF, 0xA7, 0x79, 0x37, + 0x94, 0xB3, 0x14, 0xE2, 0xC4, 0x67, 0x5B, 0x02, + 0x12, 0x3D, 0x97, 0xED, 0xC3, 0x2D, 0x2D, 0x67 + }, + { + 0xC7, 0x41, 0xF0, 0x70, 0x6C, 0xA8, 0xAC, 0xDC, + 0x6B, 0x34, 0xBA, 0x2B, 0xBC, 0x9D, 0xFA, 0x15, + 0x5B, 0xBA, 0x5C, 0x16, 0x32, 0x5C, 0x60, 0xD1, + 0x33, 0x4C, 0x80, 0x52, 0x09, 0x87, 0x3A, 0x93, + 0x35, 0x5A, 0x3A, 0x27, 0xB3, 0x08, 0x29, 0xEC, + 0xE0, 0x6B, 0x5E, 0xD7, 0x46, 0xD6, 0xEA, 0xAA, + 0x99, 0xFD, 0x32, 0xBF, 0x02, 0xE1, 0x42, 0x03, + 0x7A, 0x05, 0x57, 0xE5, 0xC8, 0x5B, 0xB5, 0xB6 + }, + { + 0x62, 0xED, 0xA0, 0x03, 0x57, 0xD7, 0x2B, 0x65, + 0x38, 0x5D, 0xAE, 0x85, 0xB7, 0x1C, 0x9D, 0x31, + 0x3C, 0x9E, 0xBE, 0xA4, 0xCD, 0xF5, 0x20, 0x13, + 0x3C, 0x15, 0x34, 0xBF, 0x46, 0xBB, 0x81, 0xCB, + 0xAC, 0x4E, 0xD8, 0xAD, 0x4D, 0x5C, 0xC7, 0x6B, + 0xF4, 0xB8, 0x35, 0x3C, 0x54, 0xDA, 0xCB, 0x29, + 0x10, 0x37, 0xE8, 0x08, 0xF7, 0x5D, 0xA4, 0x94, + 0xEF, 0x1A, 0xD9, 0x12, 0x3E, 0xE3, 0xA5, 0xC8 + }, + { + 0x88, 0xEC, 0x51, 0x54, 0x8A, 0xB1, 0x9F, 0x34, + 0xA3, 0x5C, 0xFF, 0xD1, 0xB8, 0xA3, 0xE0, 0xD2, + 0xD5, 0xBB, 0xF8, 0xCA, 0xF8, 0x4B, 0x27, 0x66, + 0x99, 0xBA, 0xB1, 0x87, 0x81, 0x5A, 0xB5, 0x59, + 0x05, 0x95, 0xD5, 0x2A, 0xC2, 0x8A, 0x9E, 0x90, + 0xAC, 0x28, 0x39, 0x57, 0xCD, 0x2C, 0xBA, 0xAD, + 0x89, 0xF4, 0x1A, 0x25, 0xA5, 0x3C, 0x8E, 0x7A, + 0xA2, 0xD3, 0x08, 0xC0, 0x82, 0x5A, 0x6F, 0x87 + }, + { + 0xA3, 0x5F, 0x19, 0x7B, 0x76, 0x4F, 0x1C, 0x24, + 0x11, 0x05, 0xE7, 0xCC, 0x7C, 0xB5, 0x17, 0x1C, + 0x04, 0xF6, 0xBF, 0xCD, 0xA4, 0x60, 0x02, 0x59, + 0x57, 0x1E, 0xBC, 0x30, 0x50, 0x6C, 0xCB, 0x44, + 0xAE, 0xFD, 0x19, 0x54, 0x7A, 0x98, 0x74, 0x2D, + 0xA7, 0xC4, 0xB6, 0xB3, 0xEB, 0x54, 0xC6, 0x02, + 0xE9, 0x32, 0xB3, 0x7E, 0x6B, 0x97, 0x84, 0x33, + 0xA6, 0x1D, 0xCF, 0xE6, 0xD5, 0x1B, 0xA7, 0xFD + }, + { + 0xBF, 0xFF, 0x79, 0xDC, 0xC9, 0xA0, 0x07, 0x27, + 0x18, 0xFD, 0xE5, 0x37, 0x9B, 0x87, 0x20, 0xD1, + 0xBE, 0x98, 0xF8, 0x2E, 0x04, 0x52, 0x01, 0xDD, + 0xD7, 0x38, 0x99, 0xA2, 0x85, 0x8E, 0x5A, 0x02, + 0xD9, 0xE0, 0x02, 0x2F, 0xAD, 0x21, 0x80, 0x19, + 0x72, 0xC2, 0x39, 0x4C, 0x90, 0x54, 0xA5, 0x98, + 0xD3, 0x9C, 0x2A, 0xD3, 0xB3, 0xDD, 0xA4, 0x03, + 0x57, 0x95, 0xC3, 0x4F, 0xC5, 0x2B, 0xF4, 0x43 + }, + { + 0x24, 0x87, 0x06, 0xFD, 0xDF, 0x65, 0x09, 0xA5, + 0x38, 0x2E, 0x74, 0x8B, 0x36, 0x3C, 0xC6, 0x9D, + 0xEE, 0xA9, 0x8B, 0xA0, 0x42, 0x49, 0x18, 0xBF, + 0xD8, 0xB8, 0x1E, 0x62, 0x5A, 0x83, 0x66, 0xEA, + 0x77, 0xEB, 0x73, 0x62, 0x47, 0x9F, 0x1F, 0xBE, + 0x1B, 0x36, 0x17, 0xD8, 0xB1, 0x64, 0x4B, 0x4F, + 0xC9, 0xED, 0xCC, 0x7C, 0xB7, 0x9B, 0x1F, 0x9C, + 0x50, 0xF7, 0x84, 0x89, 0xA8, 0xFA, 0x73, 0xA8 + }, + { + 0xF3, 0xD5, 0xAD, 0x85, 0xC7, 0xBF, 0xFE, 0x10, + 0x01, 0x94, 0x39, 0x4B, 0x2E, 0xF5, 0x28, 0x4A, + 0x8C, 0x54, 0x75, 0x70, 0xF2, 0x90, 0x6B, 0x54, + 0x79, 0x8C, 0x91, 0xB0, 0xD3, 0x40, 0xA1, 0x49, + 0xD4, 0x87, 0xC2, 0x48, 0x61, 0xFC, 0x6C, 0x75, + 0xD8, 0x9E, 0xC5, 0x0C, 0x93, 0xC4, 0x8E, 0x31, + 0x62, 0xB0, 0x09, 0xC9, 0x47, 0x83, 0xD8, 0x1E, + 0x13, 0x38, 0x81, 0xF7, 0x1A, 0xE2, 0x50, 0x63 + }, + { + 0xEA, 0x2C, 0xBA, 0x1F, 0x7F, 0xA0, 0xA6, 0x73, + 0x35, 0x53, 0x5B, 0x2A, 0x24, 0xDD, 0x5C, 0x62, + 0xB3, 0x2B, 0x99, 0x4E, 0x4B, 0x85, 0x64, 0x8E, + 0x14, 0xD7, 0x5D, 0x47, 0x97, 0x42, 0x9B, 0xEC, + 0x8A, 0x5A, 0x42, 0x4E, 0xFA, 0x8D, 0xAC, 0x76, + 0x6A, 0x58, 0x32, 0xEF, 0x78, 0xF3, 0x9F, 0xF8, + 0xFC, 0xCB, 0xDD, 0x14, 0xEA, 0xE4, 0x40, 0x36, + 0xA4, 0xCB, 0xD3, 0xBE, 0x67, 0x86, 0x2B, 0x3D + }, + { + 0x95, 0x4A, 0xE8, 0x01, 0x7C, 0x96, 0x17, 0x2E, + 0xE1, 0x33, 0xDD, 0x95, 0xA0, 0x86, 0x7C, 0xFF, + 0xBF, 0xB2, 0xC5, 0x8A, 0xA0, 0xD3, 0xDF, 0x53, + 0xDA, 0x45, 0xF1, 0x0B, 0xF6, 0x58, 0x87, 0x46, + 0x6F, 0x32, 0xD4, 0xB6, 0x10, 0x4E, 0x2C, 0x75, + 0xEA, 0x13, 0x30, 0xF6, 0xB8, 0x70, 0x8E, 0x73, + 0x8A, 0xEA, 0xCC, 0x22, 0xD6, 0xE5, 0xD9, 0xF3, + 0xE5, 0x88, 0xD7, 0x13, 0x68, 0x56, 0xCC, 0x4B + }, + { + 0x2D, 0x5B, 0xE7, 0xC9, 0x90, 0x90, 0xE1, 0xED, + 0x16, 0x84, 0xE1, 0x19, 0x83, 0x32, 0xB1, 0x1A, + 0xED, 0xF7, 0x67, 0x3A, 0xC7, 0x15, 0xB2, 0x0E, + 0x9F, 0xD7, 0x32, 0x0B, 0xF4, 0x53, 0x97, 0x4C, + 0x28, 0xAC, 0xD4, 0x10, 0x87, 0xFA, 0x37, 0x8B, + 0xE9, 0x08, 0x4E, 0x62, 0x40, 0xD3, 0x10, 0x44, + 0x40, 0x3A, 0x71, 0xA2, 0xA1, 0xAC, 0x14, 0x2D, + 0xF4, 0x97, 0x97, 0xF4, 0x92, 0xA3, 0xDA, 0xBB + }, + { + 0xD7, 0x9A, 0xCC, 0x64, 0x95, 0x74, 0xCC, 0x07, + 0x42, 0xF0, 0x3A, 0x95, 0xA7, 0xE3, 0xF9, 0x06, + 0x2C, 0x57, 0x74, 0x1D, 0xF1, 0xCB, 0x59, 0x62, + 0x4B, 0xC1, 0x01, 0xF6, 0xD0, 0xAB, 0x3A, 0xA1, + 0xB6, 0x85, 0x2D, 0x38, 0xBE, 0x10, 0x04, 0xDF, + 0x92, 0x39, 0x76, 0xC5, 0x70, 0x27, 0x33, 0xBB, + 0x5F, 0x21, 0x9A, 0x0F, 0x17, 0xBC, 0x7B, 0x3E, + 0x30, 0xDB, 0x1C, 0x42, 0x0D, 0x59, 0x2D, 0x5D + }, + { + 0xD6, 0xC8, 0x6F, 0xE1, 0x01, 0xE4, 0xA6, 0xE6, + 0x1F, 0x4F, 0x80, 0x0E, 0x5E, 0x70, 0xE5, 0x7C, + 0x64, 0xED, 0x10, 0x6C, 0xD5, 0xFE, 0xBE, 0xF1, + 0xE4, 0x74, 0xD4, 0x04, 0x2E, 0xA8, 0x3C, 0x59, + 0xE0, 0xC3, 0xC2, 0x2E, 0x57, 0xE0, 0x91, 0x4A, + 0x65, 0x50, 0xFB, 0xD9, 0x8D, 0x65, 0x2D, 0x70, + 0xA0, 0x0E, 0x65, 0x56, 0xEF, 0xCC, 0x09, 0xC9, + 0xBB, 0x12, 0xE5, 0x98, 0x5D, 0xB1, 0x50, 0x5B + }, + { + 0x0B, 0xAD, 0x73, 0xA5, 0x75, 0x9A, 0x5E, 0x10, + 0x1D, 0xB8, 0x6F, 0xDF, 0x20, 0x95, 0x97, 0xD8, + 0x24, 0x88, 0xF5, 0x99, 0xEA, 0xCC, 0x16, 0xD2, + 0x56, 0x7F, 0x2E, 0xA3, 0x92, 0x66, 0x6C, 0x3B, + 0x33, 0xE4, 0x87, 0x26, 0x32, 0x8B, 0xC3, 0x29, + 0xCC, 0x75, 0x2B, 0x6A, 0x70, 0x31, 0xD8, 0x77, + 0x0F, 0xCD, 0x59, 0xC1, 0xAD, 0xF5, 0x45, 0xEE, + 0x69, 0xC8, 0x03, 0x3C, 0xD0, 0x9B, 0x4B, 0xEA + }, + { + 0x0C, 0xB6, 0x1F, 0x8E, 0x71, 0x31, 0xCB, 0x6E, + 0x90, 0x4F, 0x63, 0xFB, 0x0A, 0x18, 0x0F, 0x0B, + 0x51, 0x66, 0x6B, 0x1D, 0x0F, 0xA4, 0x32, 0x59, + 0x7F, 0xBE, 0x34, 0xF4, 0xD0, 0x6F, 0x3B, 0xD4, + 0x3C, 0x7A, 0xC8, 0xB4, 0x9B, 0x67, 0x02, 0x37, + 0x14, 0x15, 0x8D, 0xE2, 0x0C, 0xD7, 0x50, 0x2D, + 0x61, 0x9C, 0x95, 0x79, 0x26, 0xF9, 0x4C, 0xCD, + 0x44, 0x18, 0x29, 0xEE, 0x03, 0x31, 0x7E, 0x4F + }, + { + 0xAB, 0xD0, 0xF0, 0x0F, 0x61, 0xED, 0xBC, 0x60, + 0x32, 0x6F, 0x88, 0x5A, 0x58, 0x86, 0xC9, 0x1E, + 0x36, 0x51, 0xF1, 0x71, 0xFC, 0xA6, 0x41, 0x1D, + 0x21, 0x55, 0xDC, 0x5F, 0x28, 0x9B, 0xEF, 0xC3, + 0x8B, 0x26, 0xDD, 0x29, 0xF0, 0x20, 0x03, 0x60, + 0x02, 0x8D, 0x07, 0xA4, 0x8F, 0xAA, 0x54, 0x57, + 0xBB, 0x32, 0x52, 0x0C, 0x61, 0x64, 0x69, 0x65, + 0x3F, 0x81, 0x53, 0x3E, 0x0A, 0x44, 0x4E, 0xE2 + }, + { + 0x2A, 0xF0, 0x90, 0x1E, 0x05, 0xA6, 0xDE, 0x0E, + 0x97, 0x2A, 0x5E, 0x0B, 0xC5, 0x0E, 0x87, 0xD1, + 0xCE, 0xDC, 0x1D, 0x43, 0x83, 0xA1, 0xDE, 0x25, + 0x27, 0xE9, 0x3A, 0xF7, 0x40, 0xDA, 0x72, 0x7A, + 0x4E, 0x89, 0xF3, 0xF3, 0x3D, 0x68, 0xD8, 0x46, + 0x98, 0x1B, 0xDA, 0xDC, 0x8C, 0x35, 0x81, 0x05, + 0x28, 0xAE, 0x9B, 0x6C, 0xA5, 0x41, 0x7A, 0x50, + 0xBB, 0xF8, 0xF0, 0x25, 0x8D, 0x5B, 0x61, 0x53 + }, + { + 0x38, 0x55, 0x5E, 0x06, 0xB6, 0x44, 0x5A, 0x4B, + 0x34, 0xE0, 0xB0, 0x7A, 0x0E, 0xFA, 0xB0, 0x42, + 0x95, 0xCF, 0x5C, 0x79, 0x61, 0xF8, 0x26, 0x09, + 0x3B, 0x11, 0xA4, 0xDC, 0xE9, 0xC7, 0xE1, 0x25, + 0x55, 0x09, 0xC2, 0x05, 0xC2, 0x8B, 0x57, 0x35, + 0x63, 0x82, 0x46, 0x40, 0x98, 0xFC, 0x3A, 0x63, + 0x20, 0xB9, 0xC9, 0x24, 0x93, 0x44, 0xAA, 0x39, + 0x20, 0xCA, 0xB4, 0xB7, 0xAE, 0x91, 0xA7, 0x97 + }, + { + 0x36, 0x2C, 0x28, 0x0A, 0xE3, 0x03, 0x58, 0x26, + 0xF2, 0x4D, 0xC3, 0x7D, 0x88, 0x35, 0x4A, 0x0C, + 0xC4, 0x36, 0x06, 0xEF, 0x71, 0xBE, 0xE8, 0xB5, + 0xA0, 0xBF, 0xA4, 0x1F, 0x53, 0x21, 0x53, 0xC1, + 0x67, 0xDD, 0x17, 0xC9, 0xE4, 0x2F, 0x95, 0x67, + 0x74, 0xE1, 0xF4, 0x4E, 0x70, 0x81, 0xFF, 0x87, + 0x55, 0x2A, 0x0D, 0x4A, 0x16, 0x72, 0xF3, 0xDD, + 0x81, 0x4F, 0xDF, 0xDB, 0xF6, 0xD1, 0x0C, 0x87 + }, + { + 0x8E, 0xB7, 0xBB, 0x7B, 0x3A, 0xD4, 0xF9, 0xBF, + 0xF7, 0xCA, 0x19, 0x4B, 0x14, 0x23, 0x55, 0xC6, + 0x1E, 0xC2, 0x81, 0xB3, 0xC0, 0x80, 0x45, 0x86, + 0x5A, 0x7D, 0x04, 0xE5, 0x46, 0xF8, 0x05, 0x22, + 0x3D, 0xBF, 0x2D, 0x05, 0x76, 0xC3, 0x0E, 0xD7, + 0x5C, 0x00, 0x83, 0x11, 0xF9, 0xEF, 0x90, 0x52, + 0x9F, 0x40, 0xDC, 0xC4, 0xC1, 0xF2, 0xB1, 0x8C, + 0x8A, 0x0F, 0x6E, 0xF2, 0x00, 0x78, 0x26, 0x6A + }, + { + 0xFE, 0x1E, 0x44, 0x2B, 0xEA, 0x9F, 0xC7, 0x54, + 0x42, 0xAD, 0xA0, 0x4E, 0x80, 0xBE, 0x5F, 0xC3, + 0xA6, 0x9A, 0x5D, 0x86, 0xD8, 0x5B, 0xD8, 0xCF, + 0xB4, 0x8D, 0x20, 0x63, 0x04, 0x04, 0xF4, 0xA7, + 0x1B, 0x76, 0x18, 0x2F, 0x01, 0x29, 0x58, 0xCF, + 0x61, 0x89, 0xC9, 0xAB, 0x40, 0x42, 0xB0, 0x5E, + 0x79, 0xC4, 0x0C, 0x53, 0x6A, 0x95, 0x15, 0xA6, + 0x47, 0x04, 0x84, 0xDF, 0xE6, 0x93, 0x0B, 0x2C + }, + { + 0x21, 0x00, 0xEF, 0x75, 0x55, 0x5C, 0x67, 0x75, + 0x72, 0xA6, 0x47, 0x4D, 0x94, 0xA8, 0xBB, 0x68, + 0x2F, 0x11, 0xE4, 0x5C, 0xDA, 0xE4, 0x98, 0xB1, + 0x17, 0x71, 0xBD, 0xBB, 0x02, 0xD5, 0xB8, 0x16, + 0xA6, 0x9B, 0xB4, 0xE3, 0x37, 0x54, 0x10, 0xF9, + 0x73, 0x85, 0xF6, 0xBB, 0xE8, 0xC0, 0x6C, 0x81, + 0xB0, 0x74, 0xC5, 0xA5, 0x74, 0x1E, 0x94, 0xB4, + 0x18, 0x39, 0x8C, 0x7D, 0x97, 0xC4, 0xF3, 0x86 + }, + { + 0x23, 0x00, 0xF7, 0xC2, 0x20, 0x4D, 0x39, 0x6C, + 0x62, 0x01, 0x53, 0x27, 0x2B, 0x81, 0x2A, 0x20, + 0x0F, 0xAF, 0x30, 0xF8, 0x3C, 0x1F, 0x11, 0x56, + 0xF3, 0x33, 0x88, 0x3F, 0x06, 0x21, 0x5C, 0xE2, + 0x4D, 0x49, 0x08, 0xFA, 0x73, 0xB0, 0x6E, 0x7A, + 0xAE, 0x77, 0x0F, 0x8E, 0xE3, 0xF5, 0x8B, 0x74, + 0x03, 0xF1, 0xD1, 0xA4, 0x9D, 0x3F, 0xF4, 0xD5, + 0xC4, 0x58, 0x4F, 0x39, 0xB1, 0xF8, 0x5E, 0xAE + }, + { + 0x69, 0xF9, 0x91, 0x4B, 0xD5, 0x44, 0x24, 0xB9, + 0x1C, 0xAB, 0x7E, 0x9B, 0x6D, 0xAC, 0x49, 0xCA, + 0xD9, 0x59, 0x53, 0x93, 0xD8, 0x05, 0xE9, 0xAF, + 0x8C, 0x99, 0xC8, 0x30, 0x05, 0x91, 0x02, 0xA6, + 0x8E, 0xDD, 0x6F, 0x8E, 0xFE, 0x88, 0x26, 0x85, + 0x74, 0x2C, 0xDA, 0xF2, 0x8B, 0x82, 0xD6, 0x97, + 0x3F, 0x44, 0x4B, 0x4F, 0x12, 0x98, 0xDB, 0x1A, + 0x29, 0xDC, 0x6D, 0x70, 0x15, 0xD8, 0x0F, 0xD2 + }, + { + 0xED, 0xFE, 0x7A, 0x3C, 0x09, 0x8C, 0x73, 0xED, + 0xFD, 0xFA, 0xB4, 0x2E, 0xE0, 0xA2, 0x07, 0x96, + 0xD2, 0xD2, 0x72, 0xE6, 0xA2, 0x9D, 0x7E, 0x3C, + 0x03, 0x14, 0xFC, 0x43, 0x97, 0xE3, 0x1F, 0x69, + 0x06, 0xE4, 0xA8, 0xFB, 0x02, 0x36, 0xE0, 0x33, + 0xFA, 0x16, 0x53, 0x2C, 0x7A, 0x5F, 0x29, 0xCA, + 0x36, 0xA7, 0x50, 0xA0, 0x72, 0x2A, 0x72, 0x30, + 0xB3, 0xBA, 0x23, 0x3A, 0xFB, 0x9B, 0x34, 0xF7 + }, + { + 0x80, 0x5D, 0xA7, 0x23, 0x75, 0xEB, 0xDE, 0x90, + 0x72, 0x12, 0x30, 0x13, 0x09, 0xC4, 0x49, 0x45, + 0xC0, 0x10, 0x52, 0x8C, 0x7D, 0xEE, 0xC7, 0xB0, + 0x0A, 0x25, 0xDF, 0xBD, 0xB6, 0xE6, 0xDB, 0x3A, + 0xC7, 0xC4, 0x49, 0xA4, 0x96, 0xF4, 0x2B, 0x25, + 0xC3, 0x49, 0xAD, 0x65, 0xA2, 0x84, 0xA5, 0x6E, + 0xEC, 0x19, 0x72, 0xA1, 0x3B, 0xB6, 0xB9, 0xF4, + 0x71, 0x83, 0x27, 0x04, 0xB0, 0x43, 0x45, 0x8C + }, + { + 0x1B, 0x4F, 0x03, 0x3C, 0xD8, 0xAA, 0xA4, 0x42, + 0x06, 0xB2, 0x9E, 0x14, 0xDA, 0x30, 0x86, 0x37, + 0x48, 0x9D, 0x8E, 0x5B, 0xC3, 0x81, 0xED, 0xAD, + 0x62, 0xF8, 0xFA, 0xE9, 0x47, 0x24, 0x52, 0x91, + 0xE6, 0x6A, 0x26, 0xAA, 0x34, 0xB3, 0xC4, 0xB2, + 0x5B, 0xE9, 0xF0, 0xAD, 0x10, 0x67, 0x9C, 0xBD, + 0xB5, 0x76, 0xE6, 0x49, 0x27, 0x51, 0xFE, 0xA0, + 0x53, 0x3E, 0x19, 0xBC, 0xB5, 0xCA, 0xF6, 0x44 + }, + { + 0x28, 0x57, 0x31, 0xBA, 0xCD, 0xC8, 0x52, 0xD6, + 0xBD, 0xB4, 0xF2, 0x53, 0x19, 0x9D, 0xD3, 0xA2, + 0x5D, 0x13, 0xD4, 0x09, 0x96, 0xE6, 0xB2, 0xF6, + 0x1B, 0xE2, 0xD7, 0x3C, 0x54, 0x22, 0x17, 0x53, + 0xD6, 0x83, 0xDE, 0x5C, 0xDB, 0x7A, 0x1E, 0xBF, + 0x79, 0x01, 0x63, 0x83, 0x49, 0x70, 0x14, 0x6E, + 0x82, 0xA9, 0x3A, 0x0A, 0xA0, 0x19, 0x8A, 0x76, + 0x2F, 0x9A, 0x84, 0xF9, 0x37, 0xCA, 0x10, 0xD3 + }, + { + 0xBC, 0xB2, 0xFC, 0x9F, 0x9B, 0x3D, 0x78, 0x65, + 0x3E, 0x7B, 0x43, 0xFF, 0x84, 0x26, 0x5B, 0xA8, + 0xEA, 0xD8, 0x1F, 0xC2, 0xDB, 0x7D, 0x0C, 0x6E, + 0xCF, 0x6F, 0x3A, 0x40, 0x7A, 0xA6, 0x5D, 0x59, + 0x60, 0x15, 0xDC, 0x59, 0x61, 0xEA, 0x71, 0x21, + 0x53, 0x21, 0x35, 0x57, 0x91, 0x42, 0xAB, 0x03, + 0x02, 0x23, 0xC1, 0xA5, 0xFF, 0xC5, 0xEF, 0x1B, + 0xAD, 0xC9, 0x26, 0x09, 0x39, 0xAB, 0xBC, 0x2A + }, + { + 0x47, 0x76, 0xD2, 0xA9, 0x73, 0xE0, 0xC4, 0xBA, + 0x2F, 0x84, 0xCE, 0x3E, 0xE8, 0xD8, 0x8E, 0x81, + 0x10, 0xC4, 0x95, 0x37, 0xD0, 0x79, 0xE3, 0x04, + 0x51, 0xE0, 0x6E, 0xD9, 0xDF, 0xBB, 0xA6, 0x4A, + 0xD5, 0x15, 0xF3, 0x89, 0xE2, 0x94, 0xAB, 0x59, + 0x34, 0x9E, 0x29, 0x22, 0x26, 0xA5, 0x6C, 0x79, + 0x72, 0x2E, 0xF4, 0xCD, 0xDE, 0x32, 0x99, 0x6A, + 0x56, 0x66, 0x71, 0xD2, 0x75, 0x7F, 0x15, 0xF8 + }, + { + 0xF4, 0x16, 0x73, 0x24, 0xC9, 0xC3, 0x37, 0x91, + 0x25, 0xC8, 0x0A, 0x40, 0x3B, 0x77, 0xC8, 0x7B, + 0x4E, 0x12, 0x40, 0x4D, 0x20, 0x9C, 0xB9, 0x9F, + 0xA3, 0x6F, 0x68, 0xDF, 0x50, 0xFD, 0x84, 0x36, + 0x03, 0x75, 0x83, 0xC9, 0x3C, 0x1F, 0x89, 0xDE, + 0x90, 0x17, 0x0E, 0x15, 0xE3, 0x5F, 0x95, 0xC7, + 0xAA, 0x4B, 0xCF, 0x28, 0x80, 0xC5, 0xC4, 0x2E, + 0x90, 0xB0, 0x25, 0xA7, 0x1A, 0xE2, 0xBA, 0xAA + }, + { + 0x08, 0xC8, 0x40, 0x1E, 0xE6, 0xD7, 0x0E, 0xA2, + 0x81, 0x98, 0x49, 0x92, 0x4A, 0x4D, 0x8E, 0x2B, + 0x79, 0xB5, 0xEB, 0xBA, 0xEA, 0xB3, 0x1C, 0x0E, + 0xA9, 0x93, 0xA7, 0xF7, 0x6D, 0xB4, 0x26, 0xC0, + 0x66, 0x20, 0xC3, 0x6C, 0xBF, 0x5F, 0xE8, 0x08, + 0x03, 0x86, 0x8A, 0x2B, 0x43, 0xC5, 0x0D, 0x78, + 0xA7, 0x94, 0x6F, 0xA4, 0xF5, 0x7A, 0x75, 0xF2, + 0x20, 0x96, 0x7C, 0xFA, 0x90, 0xD3, 0xFA, 0xA2 + }, + { + 0xA8, 0x6C, 0xAD, 0xFF, 0xD2, 0xBC, 0xCD, 0xBC, + 0x26, 0x1F, 0x82, 0x2E, 0x93, 0x38, 0x4C, 0x93, + 0x2E, 0x0B, 0x39, 0xA3, 0x8F, 0x9E, 0x08, 0xBE, + 0x4C, 0x6C, 0x4A, 0xF5, 0x7C, 0x07, 0xB0, 0x73, + 0x1D, 0x86, 0x55, 0x2B, 0x22, 0xA7, 0x91, 0x21, + 0x4E, 0xE9, 0x5B, 0x6A, 0x48, 0x76, 0xA2, 0x79, + 0xA4, 0x37, 0xC9, 0x21, 0x7C, 0x50, 0x5D, 0x35, + 0xC4, 0x7F, 0x81, 0x4B, 0x26, 0xE9, 0x99, 0x6C + }, + { + 0xF4, 0x81, 0xF4, 0xEC, 0x29, 0xFC, 0x01, 0x24, + 0x8F, 0xB5, 0x33, 0x28, 0xC6, 0xED, 0x22, 0xB6, + 0xB5, 0x37, 0xB1, 0x17, 0xA7, 0x08, 0xE7, 0xA4, + 0xC7, 0x76, 0xF3, 0xEC, 0xC2, 0xBF, 0xA0, 0x54, + 0xBC, 0x01, 0x6A, 0xE9, 0x2D, 0x75, 0x11, 0x29, + 0x2D, 0x40, 0x76, 0x97, 0x80, 0xBC, 0x12, 0x88, + 0x9C, 0x08, 0x63, 0x3A, 0x6D, 0x46, 0xC6, 0x75, + 0xD5, 0xF8, 0xA1, 0x4D, 0xA6, 0xEE, 0x30, 0x78 + }, + { + 0xB0, 0x49, 0xB8, 0x21, 0x1B, 0x63, 0x2D, 0x8E, + 0x88, 0x96, 0x8F, 0x49, 0x93, 0x7D, 0x75, 0x64, + 0xEC, 0xD1, 0x46, 0x6C, 0xF3, 0xB3, 0x8D, 0x7B, + 0xA9, 0xF1, 0x9C, 0x25, 0xF4, 0xD5, 0xEA, 0x4F, + 0x93, 0x42, 0xA3, 0xBB, 0xEB, 0x4C, 0x1C, 0x7B, + 0x1F, 0xA2, 0x2F, 0x24, 0x65, 0x71, 0x23, 0xE8, + 0x59, 0x0C, 0xA0, 0x2B, 0x23, 0x8E, 0x71, 0x6F, + 0xE7, 0x07, 0x9A, 0xC0, 0x25, 0x9B, 0xD2, 0xB9 + }, + { + 0x96, 0xC0, 0x0A, 0xC1, 0x82, 0x8C, 0xE4, 0x86, + 0xD4, 0x3D, 0x04, 0x5A, 0xE1, 0xC2, 0x48, 0xBB, + 0x6E, 0x61, 0x18, 0x86, 0x53, 0xCA, 0xC1, 0xD9, + 0x70, 0x28, 0x64, 0xD4, 0x39, 0xF1, 0x40, 0x7D, + 0xD1, 0xB3, 0xF1, 0xA9, 0x68, 0xE4, 0xE5, 0xE2, + 0x9F, 0x2A, 0x07, 0x05, 0xAA, 0x4B, 0xDF, 0x02, + 0x3F, 0xCF, 0xF1, 0xE9, 0xD1, 0x4D, 0x7D, 0xAF, + 0x24, 0xA6, 0xDB, 0x77, 0x2E, 0x15, 0x81, 0xFC + }, + { + 0xC8, 0x5C, 0x44, 0xB5, 0xFB, 0xCA, 0x38, 0xB7, + 0x31, 0x16, 0xAC, 0xD1, 0x30, 0xCF, 0x59, 0x7B, + 0x16, 0xA0, 0xD7, 0xD1, 0xA4, 0xBC, 0xBB, 0x98, + 0xBE, 0x5C, 0xE5, 0x1A, 0xCC, 0xF0, 0xC4, 0xBD, + 0x5B, 0x4B, 0xB1, 0xFD, 0x14, 0x7D, 0x8A, 0xC4, + 0xF3, 0xF3, 0x3D, 0x47, 0xD9, 0x3A, 0x8B, 0xAC, + 0xFD, 0x62, 0x0A, 0x9A, 0x10, 0xE0, 0x58, 0x60, + 0xDE, 0x79, 0x09, 0x7B, 0x28, 0x06, 0x51, 0xE8 + }, + { + 0x36, 0x6F, 0x09, 0xFE, 0x24, 0x0C, 0xE9, 0x0A, + 0x2E, 0xB1, 0x80, 0xCF, 0xFC, 0xF1, 0x00, 0x4E, + 0x93, 0xD8, 0x83, 0x02, 0x61, 0x95, 0x8B, 0x26, + 0xD7, 0x09, 0x06, 0x86, 0x23, 0x38, 0xFF, 0x46, + 0xFA, 0x98, 0x75, 0xA4, 0x59, 0xB2, 0xBA, 0xE1, + 0x9B, 0x49, 0x6B, 0x5D, 0x97, 0x75, 0x73, 0x28, + 0x27, 0xC9, 0x39, 0xB5, 0x43, 0x11, 0x80, 0x30, + 0x29, 0xC5, 0x8A, 0xCD, 0xA2, 0x49, 0x48, 0x50 + }, + { + 0x2A, 0xCA, 0x60, 0xF6, 0x2F, 0x4C, 0x3A, 0x6C, + 0x04, 0x4A, 0xB3, 0x7E, 0x19, 0x53, 0x1C, 0xB5, + 0xF9, 0x16, 0x1D, 0xEE, 0x4B, 0x28, 0xD2, 0x89, + 0x07, 0x28, 0x02, 0x0F, 0x64, 0xE0, 0xC4, 0x3C, + 0xDA, 0xBA, 0x33, 0x4F, 0x1D, 0x8B, 0xC5, 0xB6, + 0x9F, 0x27, 0x1A, 0x21, 0x94, 0x9C, 0x8A, 0x05, + 0x3C, 0x6B, 0xD1, 0x00, 0x24, 0x3D, 0xE6, 0x04, + 0xFB, 0x9A, 0xC6, 0x5E, 0xBF, 0xC9, 0x11, 0x27 + }, + { + 0x87, 0xAC, 0x67, 0x57, 0x13, 0x06, 0xE0, 0xA6, + 0xA1, 0xF3, 0xC0, 0x96, 0x99, 0xD1, 0xBE, 0x9E, + 0x09, 0x55, 0x24, 0x10, 0x8E, 0xCF, 0x35, 0x9A, + 0xF9, 0x7D, 0xED, 0xA0, 0xD1, 0x70, 0x91, 0x0C, + 0x27, 0x6E, 0xDC, 0xD3, 0x17, 0x2D, 0x7F, 0x51, + 0x9A, 0xE7, 0x97, 0x44, 0xEF, 0x51, 0xCB, 0xF9, + 0xE2, 0xF2, 0x3F, 0xB6, 0xD8, 0x81, 0x54, 0xF2, + 0x83, 0x58, 0x94, 0xDF, 0x9C, 0x43, 0xC5, 0xBF + }, + { + 0x4F, 0x94, 0x69, 0xC7, 0xD6, 0x34, 0x25, 0xE3, + 0xB1, 0xA5, 0xDD, 0x4D, 0x3A, 0x1C, 0xEF, 0x02, + 0x47, 0xC9, 0x59, 0x33, 0x04, 0xC5, 0xDA, 0xF0, + 0xB4, 0xFE, 0xBC, 0x94, 0xA3, 0x3D, 0x2F, 0xF5, + 0x70, 0x65, 0xC7, 0x84, 0x21, 0x92, 0x19, 0x02, + 0x2E, 0xBF, 0x2B, 0xC9, 0x99, 0xEF, 0xBE, 0xE3, + 0x4D, 0xA9, 0xA6, 0x41, 0x53, 0x90, 0x5A, 0xA0, + 0x15, 0x67, 0x40, 0x14, 0x5B, 0x86, 0x41, 0xB2 + }, + { + 0xEB, 0xD2, 0x0B, 0xAD, 0x2D, 0x67, 0x7D, 0xC1, + 0x3C, 0xDA, 0x25, 0x14, 0x64, 0x04, 0x55, 0xB3, + 0x50, 0xFF, 0x01, 0xF1, 0x1E, 0x9B, 0x26, 0xB0, + 0xF9, 0x81, 0x9B, 0xD1, 0x50, 0x4B, 0xD7, 0x24, + 0x28, 0xDE, 0xDB, 0x0A, 0x0D, 0x00, 0x17, 0x60, + 0x8E, 0xED, 0xA6, 0x8E, 0xF7, 0xD7, 0xC6, 0x50, + 0x5B, 0x93, 0x4B, 0x5B, 0xDD, 0x9B, 0x4A, 0x65, + 0x0A, 0x0F, 0x4B, 0x4E, 0xD1, 0x56, 0xA4, 0xAC + }, + { + 0xFC, 0x99, 0xFF, 0x68, 0x41, 0x51, 0x1D, 0xC5, + 0x11, 0x40, 0xCE, 0x1A, 0x7C, 0x8B, 0x95, 0x67, + 0x58, 0xF5, 0x9F, 0xC5, 0xE1, 0xA4, 0x83, 0x13, + 0x92, 0x52, 0xB8, 0x0E, 0x95, 0x2D, 0x26, 0x33, + 0x68, 0xA8, 0x23, 0x3E, 0x85, 0x92, 0x76, 0x0B, + 0x5C, 0xD6, 0x6B, 0x3D, 0x79, 0x81, 0x1D, 0x97, + 0x22, 0x3A, 0x6F, 0xD8, 0x3D, 0xA2, 0x45, 0x80, + 0x85, 0x0A, 0x02, 0xB4, 0xA7, 0x6D, 0x47, 0x91 + }, + { + 0x46, 0xDC, 0x7F, 0x4F, 0x78, 0x0E, 0xA8, 0xFC, + 0xD3, 0x5D, 0x99, 0xC2, 0x4A, 0x13, 0x7C, 0xB9, + 0xF1, 0x09, 0xAE, 0xD3, 0x06, 0xA3, 0x7A, 0xEE, + 0x6D, 0x30, 0xAF, 0x28, 0x60, 0x9C, 0x92, 0x36, + 0x0B, 0xC7, 0xD4, 0x54, 0xE0, 0xC6, 0x67, 0x6C, + 0x2D, 0xD6, 0x20, 0xCA, 0x3C, 0xCA, 0xCB, 0xDE, + 0x54, 0x32, 0xC4, 0x45, 0xE9, 0x92, 0x50, 0x03, + 0x6E, 0x00, 0x1B, 0xA2, 0x03, 0x7D, 0xD4, 0x55 + }, + { + 0x31, 0x48, 0x0E, 0xDE, 0xC3, 0xCB, 0x2D, 0x19, + 0xE5, 0x1F, 0xA1, 0x2A, 0x92, 0xCA, 0x4E, 0x55, + 0x9A, 0xF2, 0x85, 0x83, 0x5A, 0x4C, 0x01, 0x8A, + 0xD0, 0x43, 0x53, 0x6C, 0xA6, 0x04, 0xDD, 0xCC, + 0x82, 0x58, 0x63, 0xCC, 0x33, 0xCF, 0x65, 0x40, + 0x60, 0x5C, 0x22, 0xAE, 0xD9, 0xB7, 0x53, 0x8C, + 0xDE, 0x6A, 0x70, 0x45, 0x84, 0xC5, 0x1F, 0xCD, + 0x69, 0x37, 0x47, 0x0E, 0x22, 0xED, 0x45, 0x42 + }, + { + 0x1E, 0x18, 0xE0, 0x50, 0x2E, 0xC1, 0x0D, 0x3A, + 0xF2, 0x98, 0x4F, 0xBC, 0x14, 0xF9, 0xC5, 0x5B, + 0x1E, 0x60, 0x92, 0xF9, 0x70, 0x74, 0x60, 0xEA, + 0x9C, 0x12, 0xFF, 0xF9, 0x58, 0xBD, 0xA6, 0x1D, + 0x33, 0xA6, 0xC2, 0xD7, 0xEF, 0xF6, 0x97, 0x31, + 0xAC, 0x24, 0x59, 0xDD, 0xFB, 0x4E, 0x26, 0x70, + 0x28, 0x67, 0x81, 0x53, 0x71, 0xDC, 0xE6, 0xDD, + 0x9A, 0x4E, 0x22, 0x62, 0x68, 0x75, 0xEF, 0x5A + }, + { + 0xD3, 0xFD, 0xE0, 0x04, 0xFE, 0x3B, 0x8B, 0x15, + 0x6E, 0x04, 0xA8, 0xAB, 0x1D, 0xA8, 0x9B, 0xFB, + 0x13, 0xFC, 0xBF, 0x89, 0xC3, 0x62, 0x12, 0x1B, + 0x57, 0xDB, 0xFD, 0xFF, 0xA8, 0x93, 0xFC, 0xC2, + 0xF7, 0x51, 0xEE, 0x37, 0xA4, 0xA3, 0xBA, 0x1A, + 0x1F, 0x92, 0x4F, 0x78, 0x3E, 0x56, 0xB4, 0x6A, + 0xF9, 0x93, 0x52, 0x59, 0xED, 0x18, 0xE3, 0x80, + 0x8F, 0xBC, 0xFA, 0x46, 0xB1, 0xB0, 0x8C, 0x70 + }, + { + 0xC8, 0x52, 0xEE, 0xD4, 0xD2, 0x72, 0xA4, 0x81, + 0x97, 0x99, 0xB7, 0x94, 0x25, 0x03, 0xFD, 0x26, + 0xE3, 0xE5, 0xBA, 0xCB, 0x0F, 0xAC, 0xE6, 0x9A, + 0x06, 0x51, 0x10, 0xA7, 0xC8, 0x58, 0x38, 0x33, + 0x6D, 0x0E, 0xE8, 0x21, 0xAD, 0x4B, 0x9E, 0x0A, + 0xEA, 0x2A, 0x36, 0xB3, 0x64, 0x34, 0xDA, 0xFC, + 0x9A, 0xCD, 0x30, 0xF2, 0x13, 0x0D, 0xF5, 0x5E, + 0xD8, 0x82, 0xF4, 0x5B, 0x14, 0xAC, 0xD8, 0x5E + }, + { + 0xA3, 0x20, 0x1D, 0xA6, 0x83, 0xAA, 0x41, 0xE2, + 0x01, 0x7A, 0xC9, 0xB0, 0xB0, 0x5B, 0x22, 0xB8, + 0x21, 0x86, 0x3E, 0x60, 0x88, 0xE4, 0x1D, 0x5A, + 0x39, 0xFC, 0x65, 0x1D, 0xCC, 0xFE, 0x8F, 0xA9, + 0x1C, 0x37, 0xC9, 0xC9, 0xCE, 0xAD, 0x3B, 0x98, + 0x54, 0xCD, 0x1F, 0x95, 0x91, 0x00, 0x7A, 0xC9, + 0xAC, 0x29, 0x04, 0x1E, 0xA3, 0x0F, 0xE2, 0x96, + 0x8E, 0xBB, 0x6C, 0xC5, 0x34, 0x9F, 0x9E, 0xF0 + }, + { + 0xE0, 0xBF, 0x3F, 0xF7, 0xD3, 0xBF, 0xEB, 0x0E, + 0xA9, 0x21, 0x9E, 0x8F, 0xC2, 0x78, 0x51, 0x1D, + 0xDB, 0x92, 0x43, 0x38, 0xD3, 0x97, 0xEF, 0xF2, + 0x2D, 0x85, 0x7A, 0x60, 0xC5, 0x02, 0x91, 0x9E, + 0x7B, 0xB0, 0xC7, 0x97, 0x2F, 0xA2, 0xD7, 0x4A, + 0x71, 0x1B, 0x05, 0x95, 0xA6, 0x14, 0xC7, 0xBA, + 0x07, 0xC6, 0xF0, 0x17, 0x83, 0xA2, 0x21, 0x9E, + 0x9B, 0xE4, 0x79, 0x8C, 0xF8, 0xF7, 0x60, 0xE0 + }, + { + 0x10, 0x65, 0x17, 0x19, 0x7A, 0xD3, 0x43, 0x61, + 0x9F, 0x97, 0x80, 0xEA, 0x90, 0xB9, 0xEA, 0x88, + 0x6C, 0xBE, 0xE7, 0x80, 0xD0, 0x46, 0xA3, 0x27, + 0xAA, 0xE7, 0x44, 0x17, 0x2E, 0x6D, 0x86, 0xC9, + 0xC6, 0x04, 0x0F, 0x32, 0xA5, 0xE9, 0x3A, 0x51, + 0xF3, 0x7F, 0xCA, 0x28, 0x5B, 0x16, 0x42, 0x2B, + 0xEB, 0x13, 0xB2, 0x76, 0xDE, 0xFE, 0x94, 0x36, + 0x65, 0xDD, 0xA8, 0x3D, 0x1E, 0xDD, 0xB5, 0x04 + }, + { + 0x24, 0xBF, 0x95, 0x6B, 0x41, 0x55, 0x14, 0xC9, + 0xA6, 0xAA, 0xE9, 0x5F, 0x4F, 0x14, 0xE4, 0x15, + 0xCC, 0x63, 0xB8, 0x43, 0x2C, 0xE2, 0x5A, 0x71, + 0xAD, 0x6C, 0xA4, 0x74, 0x54, 0x4F, 0x60, 0x28, + 0x32, 0x63, 0x61, 0xBD, 0xB9, 0xBC, 0x55, 0x9F, + 0xCB, 0xF0, 0x79, 0xFA, 0x99, 0x79, 0x99, 0x49, + 0xF0, 0x23, 0xEA, 0x13, 0x6E, 0xB1, 0xE1, 0x8A, + 0x5C, 0x51, 0x09, 0x74, 0xA9, 0xD6, 0x07, 0xC5 + }, + { + 0x16, 0x02, 0x1D, 0xCB, 0x0E, 0xD5, 0x33, 0x2E, + 0x1D, 0xA9, 0x25, 0xD1, 0x6C, 0x9C, 0xD4, 0xF1, + 0x07, 0xC0, 0xA7, 0xB2, 0x9F, 0x40, 0xDB, 0xBC, + 0xEC, 0x22, 0xA0, 0x33, 0x15, 0xDC, 0xE3, 0xD3, + 0xEB, 0xF4, 0xE6, 0xC2, 0x7B, 0x8E, 0xD0, 0x6D, + 0x3B, 0x86, 0x9F, 0x45, 0x67, 0x7D, 0x83, 0x0E, + 0xCA, 0xC8, 0x8C, 0xE6, 0xAE, 0x3A, 0x9C, 0x85, + 0x21, 0xFF, 0xCB, 0xDC, 0xEA, 0xE3, 0x30, 0xA6 + }, + { + 0xFC, 0x0F, 0xA6, 0xD7, 0xDA, 0xED, 0x1B, 0x4B, + 0x6D, 0xF6, 0xAA, 0xE9, 0xD8, 0x52, 0xB4, 0x66, + 0x17, 0x60, 0x73, 0x9F, 0xCD, 0x34, 0x58, 0xAA, + 0x90, 0x74, 0x71, 0x15, 0xAC, 0x09, 0x39, 0xAD, + 0x33, 0xF1, 0xEC, 0xAB, 0x94, 0x03, 0x33, 0x0E, + 0x0D, 0x82, 0x09, 0xBF, 0x85, 0x8D, 0xFA, 0x3D, + 0xD2, 0xCA, 0x84, 0x38, 0xD4, 0xBA, 0x50, 0x5E, + 0x21, 0xCF, 0x3A, 0x89, 0xD6, 0x38, 0x1D, 0xD2 + }, + { + 0x55, 0xB5, 0xEE, 0x4B, 0xAE, 0x3B, 0x77, 0xDA, + 0x33, 0x51, 0xFF, 0xFB, 0x2D, 0xA0, 0x69, 0xB2, + 0x38, 0x76, 0xFA, 0x79, 0xC9, 0x87, 0xF5, 0x7F, + 0x15, 0x0F, 0xC6, 0xC0, 0x9E, 0x2E, 0xFE, 0x56, + 0x54, 0xF6, 0x32, 0x98, 0x44, 0x04, 0x7E, 0xE7, + 0x08, 0x5C, 0x1A, 0xB8, 0xA2, 0xA9, 0x60, 0xFB, + 0x7C, 0xA7, 0xCF, 0x26, 0x0A, 0xCA, 0xC3, 0x37, + 0x2D, 0x38, 0xD1, 0xF5, 0xD4, 0x89, 0x74, 0x50 + }, + { + 0x6E, 0x51, 0x20, 0x71, 0xC3, 0x3C, 0x03, 0xD6, + 0x95, 0xC3, 0xF4, 0xAF, 0xCF, 0xDB, 0x16, 0x62, + 0x92, 0xE6, 0x52, 0xA1, 0xA4, 0x0B, 0x92, 0xDC, + 0x5A, 0xDE, 0x82, 0x3A, 0xD5, 0xEB, 0xB1, 0xA2, + 0xCE, 0xB1, 0xE8, 0x59, 0x52, 0x6E, 0xF4, 0xAF, + 0x40, 0x65, 0xAF, 0xDE, 0x67, 0x0A, 0x89, 0x7C, + 0x4B, 0x8E, 0xE8, 0xB9, 0x77, 0x4B, 0x9D, 0x56, + 0x37, 0xE8, 0x7B, 0x11, 0xF1, 0x4A, 0x39, 0xB4 + }, + { + 0xC8, 0x02, 0xAA, 0x0E, 0xA2, 0x0A, 0x4B, 0x38, + 0xA1, 0x31, 0x87, 0xA5, 0x17, 0x54, 0x50, 0xD8, + 0xC1, 0x68, 0xE5, 0x52, 0xA1, 0xAA, 0x97, 0x87, + 0x28, 0xCC, 0x92, 0x0E, 0x05, 0x87, 0xD6, 0xFE, + 0xBF, 0xDB, 0x36, 0x68, 0x4E, 0xF0, 0x34, 0x80, + 0x6D, 0x3A, 0x06, 0xAD, 0x39, 0x64, 0xB6, 0x41, + 0x1B, 0x6A, 0x3F, 0xA2, 0xA6, 0xDC, 0x00, 0x92, + 0x4A, 0xB0, 0x57, 0xDB, 0x92, 0x4B, 0x95, 0x3E + }, + { + 0x9F, 0xE6, 0x87, 0x12, 0x6E, 0x65, 0x66, 0x31, + 0x30, 0x81, 0xB4, 0x31, 0x67, 0xCB, 0xFA, 0x0B, + 0x4F, 0x72, 0x1B, 0x45, 0xA5, 0xAF, 0xD4, 0x07, + 0x6A, 0xF3, 0x27, 0x76, 0x5D, 0x63, 0xA6, 0x16, + 0x47, 0x8F, 0xFB, 0xD1, 0xCD, 0x5F, 0xBE, 0x40, + 0x33, 0xE8, 0x63, 0x8B, 0x8B, 0xCF, 0x8D, 0xE6, + 0xB3, 0x97, 0x8B, 0x54, 0xA3, 0x0F, 0x1D, 0x9D, + 0x8D, 0x68, 0xFB, 0xE6, 0x6C, 0x2B, 0x74, 0xCF + }, + { + 0x72, 0x95, 0xC0, 0x12, 0x75, 0xAE, 0x0E, 0x88, + 0x98, 0x18, 0x96, 0x8B, 0x48, 0xB0, 0x82, 0xE7, + 0x49, 0xF2, 0x77, 0x5D, 0x63, 0x9A, 0x98, 0xBD, + 0x72, 0x40, 0x0B, 0x5D, 0xB7, 0x6C, 0x1C, 0x5B, + 0x75, 0xC9, 0x48, 0xE6, 0xC7, 0xCF, 0x9C, 0xE2, + 0x80, 0x09, 0xE7, 0xD4, 0x66, 0xBB, 0x26, 0x7C, + 0xC9, 0xBA, 0xFA, 0xA9, 0xF7, 0x76, 0x36, 0x49, + 0x21, 0x97, 0xDA, 0x1F, 0x94, 0x43, 0xE9, 0xB8 + }, + { + 0x7C, 0xFB, 0x2A, 0xD2, 0x3D, 0xB5, 0x84, 0xD5, + 0xD4, 0x44, 0x23, 0x3D, 0x7F, 0xAC, 0xDC, 0xC4, + 0x2A, 0xE9, 0x63, 0x83, 0x75, 0x0E, 0xAD, 0x71, + 0x00, 0xFF, 0xDD, 0xF5, 0x35, 0x0D, 0x9E, 0x6E, + 0xC1, 0xC0, 0x96, 0x1F, 0xF1, 0x78, 0x9E, 0x2A, + 0x9D, 0xBC, 0x77, 0xA8, 0x81, 0x77, 0x67, 0xBF, + 0xC1, 0xA2, 0xA4, 0xDE, 0xA7, 0x8D, 0xCF, 0xA6, + 0x38, 0x02, 0x85, 0xE6, 0x8E, 0x0A, 0xDA, 0xEF + }, + { + 0x59, 0x7F, 0x85, 0xB6, 0x29, 0x53, 0xBE, 0xD5, + 0x00, 0x9C, 0xD3, 0x71, 0xAD, 0xBE, 0x4C, 0x97, + 0x2D, 0xA4, 0xF0, 0x64, 0x7F, 0x6E, 0xE0, 0x05, + 0x67, 0x8C, 0xA1, 0xA9, 0xEC, 0xAD, 0xB4, 0xAB, + 0xBA, 0x7B, 0xD9, 0x1A, 0xFB, 0xDF, 0x6A, 0xB9, + 0x62, 0xB6, 0xFF, 0x3F, 0x66, 0xC4, 0x69, 0x51, + 0x67, 0xF2, 0x71, 0x03, 0x6F, 0xB2, 0x3E, 0x7D, + 0x7D, 0x59, 0x10, 0x14, 0xFB, 0xCA, 0xEB, 0xB5 + }, + { + 0xBF, 0x93, 0x5E, 0x07, 0xC7, 0xF9, 0x4E, 0x84, + 0xF7, 0x7A, 0x8E, 0xCF, 0x7D, 0xBA, 0xAF, 0xC7, + 0x7B, 0x59, 0xE0, 0x1F, 0x14, 0x09, 0x96, 0x8C, + 0x4F, 0x20, 0xB2, 0xFD, 0x82, 0x75, 0x79, 0x42, + 0xA0, 0x37, 0x43, 0xE3, 0x98, 0x53, 0xAE, 0x2F, + 0xF1, 0xF7, 0xE9, 0x7F, 0xC8, 0x03, 0x14, 0x82, + 0xBE, 0x98, 0x11, 0xB4, 0xB8, 0xA6, 0x34, 0xFE, + 0x36, 0xD5, 0xF0, 0x12, 0xA7, 0xFE, 0x06, 0xB9 + }, + { + 0x80, 0x4E, 0x19, 0x75, 0xD6, 0x2A, 0x25, 0x72, + 0x12, 0xAC, 0x13, 0xB4, 0xF5, 0x3E, 0x42, 0x28, + 0x36, 0x3B, 0x43, 0x9F, 0x36, 0x06, 0x69, 0xA1, + 0x54, 0xE1, 0x39, 0x39, 0x6B, 0xD2, 0xA1, 0x5A, + 0xB6, 0xDE, 0x32, 0x03, 0xF8, 0x07, 0xFE, 0x09, + 0xBD, 0x70, 0x2E, 0x3A, 0xBD, 0x32, 0x1A, 0x60, + 0xD5, 0xE5, 0xDD, 0x01, 0xB7, 0x19, 0x5B, 0xDF, + 0x6E, 0x2D, 0x41, 0x7D, 0x8A, 0x52, 0x1B, 0xA3 + }, + { + 0x16, 0xD0, 0x01, 0xDA, 0x18, 0xDA, 0xB2, 0x6A, + 0x22, 0x02, 0xD5, 0x4B, 0x2C, 0x49, 0x6B, 0xE8, + 0x05, 0xCA, 0x9D, 0x27, 0x6C, 0xBD, 0xD3, 0x72, + 0x1B, 0x9D, 0x41, 0xD7, 0xD2, 0x9B, 0xE9, 0x88, + 0x61, 0xC1, 0xE3, 0x06, 0x46, 0x8D, 0x53, 0x2B, + 0xF0, 0x7F, 0x91, 0xD2, 0x77, 0x92, 0x67, 0xE3, + 0x10, 0x02, 0xC4, 0xE9, 0x20, 0xCE, 0xF4, 0x2A, + 0x95, 0xA3, 0x98, 0x7E, 0xBD, 0xA1, 0x46, 0x9F + }, + { + 0xB3, 0x38, 0xE7, 0x40, 0x6A, 0xA2, 0x98, 0x8E, + 0xCF, 0x77, 0x7E, 0x68, 0x0A, 0xEC, 0xE1, 0x14, + 0x3B, 0x2F, 0x38, 0x3A, 0x85, 0x5B, 0x4D, 0x2B, + 0x70, 0x87, 0x3D, 0xA9, 0x69, 0xE9, 0x3F, 0x0C, + 0xC1, 0x34, 0x93, 0x1E, 0x12, 0x3E, 0x04, 0xEE, + 0xBE, 0x13, 0x15, 0x73, 0xB1, 0x45, 0x16, 0x69, + 0xEC, 0xDF, 0x12, 0x60, 0xBD, 0x7D, 0x17, 0x97, + 0xF6, 0x53, 0xBC, 0xA9, 0x4A, 0xF0, 0x79, 0x41 + }, + { + 0x7B, 0x63, 0x86, 0xFD, 0x76, 0x33, 0x24, 0xDF, + 0x1C, 0xA8, 0xC4, 0xC5, 0xF4, 0x56, 0x1C, 0x87, + 0x0A, 0xE3, 0xBA, 0xA5, 0xD2, 0x15, 0x34, 0x3F, + 0xC2, 0xCA, 0xF7, 0xCB, 0x64, 0x17, 0x28, 0x0E, + 0x2C, 0x80, 0xBC, 0x55, 0x9A, 0xD5, 0x31, 0x0D, + 0xCB, 0x95, 0xC8, 0x56, 0xD1, 0xEF, 0x42, 0xFC, + 0xE9, 0xFC, 0x3D, 0x36, 0xAF, 0x69, 0x86, 0x6A, + 0x58, 0x0C, 0xB5, 0x6A, 0x0B, 0xB0, 0xC6, 0x28 + }, + { + 0xED, 0xCA, 0x56, 0xDA, 0x38, 0x8C, 0x82, 0xF1, + 0x15, 0x65, 0x79, 0xA1, 0x73, 0x19, 0x84, 0x47, + 0x07, 0xC1, 0x50, 0x44, 0xE7, 0xE4, 0x12, 0x3A, + 0x07, 0x10, 0x82, 0x3E, 0x3B, 0x01, 0x67, 0xBB, + 0x7D, 0xBE, 0xF6, 0x9F, 0x36, 0xBB, 0x98, 0x85, + 0x9C, 0x67, 0xC3, 0xBF, 0x55, 0x75, 0xF3, 0x3D, + 0xF3, 0x67, 0x86, 0x10, 0x3B, 0x05, 0x90, 0x6C, + 0x85, 0xE8, 0xF7, 0xD7, 0x08, 0x7B, 0x4B, 0x6D + }, + { + 0x28, 0x8D, 0x2A, 0x6B, 0x79, 0x7A, 0xC7, 0x90, + 0x40, 0x87, 0xBF, 0xD0, 0xE3, 0x8D, 0x3A, 0x36, + 0xC4, 0xFD, 0x51, 0x25, 0xA4, 0x16, 0xDF, 0x37, + 0xDA, 0xFE, 0xAB, 0x38, 0x54, 0x37, 0x61, 0x2D, + 0xC9, 0x8F, 0x55, 0x9F, 0x5D, 0x0E, 0x6C, 0xE5, + 0xFE, 0x82, 0xE8, 0x41, 0xC8, 0x63, 0x96, 0xFF, + 0xE3, 0x07, 0x62, 0xD6, 0xC9, 0xB7, 0x0D, 0x07, + 0x07, 0xE5, 0x41, 0xF9, 0x1C, 0x91, 0x0D, 0x18 + }, + { + 0xB2, 0x8D, 0xD0, 0x77, 0x06, 0xEE, 0xCE, 0xAA, + 0x66, 0x67, 0x36, 0x01, 0x21, 0x33, 0x4C, 0x9C, + 0x12, 0xBD, 0xBF, 0x2D, 0x26, 0x39, 0x4A, 0xD3, + 0x15, 0x9C, 0x26, 0x68, 0xF3, 0x9F, 0x57, 0x4C, + 0x52, 0x86, 0x7E, 0x38, 0x26, 0x2E, 0xAB, 0x41, + 0xAF, 0xCD, 0xFD, 0x28, 0x08, 0xFA, 0x8A, 0x42, + 0x16, 0x65, 0x9E, 0xA2, 0x34, 0xD9, 0xF6, 0x78, + 0x51, 0xE0, 0x67, 0xBC, 0x2A, 0x00, 0x0B, 0xCE + }, + { + 0x3B, 0x49, 0x28, 0x8C, 0x5F, 0xC1, 0x84, 0x3A, + 0x8A, 0x80, 0x16, 0xC4, 0xB1, 0x41, 0x06, 0xAA, + 0x00, 0xD0, 0x6E, 0xB6, 0x34, 0x6C, 0x75, 0x4F, + 0x88, 0x56, 0x5D, 0x8C, 0xD0, 0x26, 0x8E, 0x6D, + 0x31, 0x93, 0x32, 0x29, 0x52, 0x8D, 0x9E, 0xCD, + 0x4A, 0xFA, 0x8E, 0x65, 0x2F, 0x2E, 0x32, 0x37, + 0xF1, 0x82, 0xDF, 0xAC, 0xEA, 0xD1, 0xC6, 0x6A, + 0x80, 0x30, 0x5D, 0xC9, 0xE6, 0x7E, 0xE8, 0x1D + }, + { + 0x6F, 0xC5, 0x89, 0xEB, 0x12, 0xA0, 0x32, 0xEF, + 0xCB, 0x30, 0xC8, 0x00, 0xF4, 0x7A, 0x22, 0xFE, + 0x09, 0x90, 0x72, 0xD8, 0x93, 0x09, 0x0F, 0x72, + 0x2B, 0x56, 0xF5, 0x29, 0x82, 0x79, 0xEB, 0x2F, + 0xE7, 0xF0, 0x76, 0xEA, 0x10, 0x19, 0xA9, 0xC2, + 0x26, 0xF1, 0x9B, 0x44, 0x53, 0x44, 0xC8, 0x56, + 0xBC, 0x94, 0x06, 0x98, 0x98, 0x32, 0x55, 0x04, + 0x39, 0x22, 0x12, 0x48, 0x6B, 0x82, 0x80, 0x5A + }, + { + 0xC0, 0xAE, 0xC2, 0xC3, 0xAF, 0x64, 0xBD, 0x3C, + 0xC6, 0xA5, 0x1D, 0xD7, 0x53, 0xE9, 0x31, 0xC0, + 0xEE, 0x3C, 0x5C, 0x99, 0x9F, 0xFC, 0x1B, 0x68, + 0xCE, 0xD2, 0x23, 0x74, 0xA8, 0x98, 0x50, 0xD2, + 0x98, 0x86, 0x59, 0x23, 0xCF, 0xD0, 0x81, 0xA8, + 0x32, 0x48, 0xB5, 0x75, 0x5B, 0x6E, 0xA9, 0x04, + 0x1A, 0x1A, 0x1B, 0x04, 0xC0, 0x48, 0x60, 0xC0, + 0xE6, 0x83, 0x17, 0xD9, 0x72, 0x2E, 0xC7, 0xAD + }, + { + 0x4A, 0xDC, 0x1C, 0xFD, 0xE1, 0xEF, 0xE6, 0x3C, + 0x00, 0x66, 0xB7, 0xA9, 0x0B, 0x1F, 0x3A, 0x67, + 0x70, 0xA1, 0x6B, 0x51, 0xE6, 0x75, 0x57, 0x19, + 0x1B, 0x28, 0x53, 0x01, 0x90, 0xBC, 0x8B, 0xD9, + 0x83, 0x98, 0x34, 0xE9, 0xC3, 0xFC, 0xAA, 0xAF, + 0xBE, 0x44, 0x5F, 0xF8, 0xC9, 0x96, 0xD9, 0x88, + 0xFF, 0xFA, 0xF8, 0x3A, 0x90, 0x64, 0x34, 0x74, + 0x69, 0xF2, 0x87, 0xA2, 0x56, 0xC3, 0x24, 0xE1 + }, + { + 0xFB, 0x5F, 0x70, 0x71, 0xB5, 0xDD, 0x4D, 0x31, + 0x84, 0xCE, 0x0A, 0xA9, 0xEB, 0x7C, 0x8A, 0xDC, + 0xD6, 0x31, 0x43, 0x0C, 0x10, 0xC0, 0x71, 0xAE, + 0x07, 0x9C, 0x74, 0x0B, 0x3C, 0x0F, 0x24, 0xA9, + 0xCC, 0xA0, 0x57, 0x70, 0x46, 0xAC, 0xDC, 0x31, + 0x30, 0xCB, 0x31, 0x42, 0xD6, 0x46, 0x8E, 0x99, + 0xDC, 0x54, 0x78, 0x27, 0x31, 0xFA, 0x3F, 0x40, + 0x4F, 0x8F, 0x61, 0xB5, 0x09, 0xF4, 0x86, 0x17 + }, + { + 0xB4, 0xEA, 0xA7, 0x83, 0xCD, 0x71, 0x90, 0x5C, + 0x22, 0x3C, 0x0F, 0xAD, 0x93, 0xC1, 0x85, 0x61, + 0x7E, 0x87, 0x36, 0x71, 0x55, 0x9F, 0x10, 0x83, + 0xF5, 0xC6, 0x20, 0xA8, 0xE3, 0xDE, 0x5B, 0x14, + 0x06, 0x71, 0x5C, 0xDA, 0x29, 0x89, 0x5C, 0x8B, + 0xE8, 0x6C, 0x53, 0xA5, 0x8F, 0x34, 0x89, 0xDA, + 0x81, 0xB2, 0x23, 0xEC, 0x95, 0xF4, 0x33, 0x49, + 0x41, 0xFC, 0x94, 0xA2, 0xFE, 0x48, 0x56, 0x6B + }, + { + 0x73, 0xD5, 0xC7, 0x50, 0x9C, 0x1A, 0x80, 0xD5, + 0x8B, 0x3F, 0x11, 0x48, 0xB8, 0x11, 0xDD, 0xE2, + 0x6F, 0xC2, 0x3B, 0xC7, 0xC5, 0x10, 0x0E, 0x3A, + 0x57, 0x39, 0xBB, 0x76, 0x93, 0x6D, 0x6C, 0x23, + 0xAA, 0x36, 0xB6, 0xE4, 0xCF, 0xCF, 0xFE, 0x31, + 0xDD, 0xFC, 0x89, 0xAD, 0xCF, 0x80, 0xBE, 0xF7, + 0x62, 0x29, 0x83, 0x61, 0x1D, 0x6D, 0x4E, 0xBC, + 0x50, 0xBB, 0xFB, 0x2F, 0xAB, 0x8D, 0xC9, 0x5E + }, + { + 0x58, 0xE6, 0x72, 0xF4, 0x7B, 0xA7, 0xA2, 0xD4, + 0x1B, 0xA3, 0x3A, 0x7C, 0xBB, 0xEF, 0xF2, 0x0B, + 0x4A, 0xB7, 0xFE, 0x31, 0x46, 0xDC, 0x59, 0x65, + 0xF7, 0x7C, 0x40, 0xE0, 0x6A, 0x47, 0xF4, 0x6C, + 0xC2, 0x4B, 0x2D, 0x18, 0x72, 0x89, 0x08, 0xEB, + 0xB7, 0xD1, 0x07, 0xE5, 0x68, 0x9E, 0x22, 0xCB, + 0xD3, 0x61, 0xFF, 0xA0, 0x07, 0x13, 0xB7, 0x9B, + 0xA8, 0xDD, 0x52, 0x50, 0x86, 0x0E, 0xA6, 0x9F + }, + { + 0xB6, 0x57, 0xC8, 0x58, 0x2E, 0xA1, 0x9E, 0x73, + 0x4D, 0xEB, 0x06, 0xFA, 0xB9, 0x24, 0xD5, 0x77, + 0xAD, 0x3C, 0x67, 0x6E, 0x31, 0x08, 0xF5, 0xC1, + 0x6D, 0x26, 0x30, 0xFA, 0xB9, 0x8E, 0xAF, 0x66, + 0x2B, 0x01, 0x66, 0xA0, 0x40, 0x26, 0xAE, 0x6B, + 0xEC, 0x53, 0xF2, 0x60, 0x5E, 0xB1, 0x50, 0x84, + 0xE1, 0xBD, 0xA5, 0xA5, 0x73, 0x77, 0xB5, 0xF7, + 0xC3, 0x3C, 0x99, 0xAC, 0x7D, 0x5C, 0xC5, 0x79 + }, + { + 0x9F, 0xE9, 0x69, 0x75, 0xD4, 0x12, 0xDD, 0xA8, + 0x65, 0x53, 0x52, 0x7D, 0xEC, 0xC6, 0x30, 0xBE, + 0x25, 0x90, 0xBC, 0x61, 0xDF, 0xAC, 0x63, 0x65, + 0x19, 0xCC, 0xE8, 0x14, 0xD9, 0x55, 0x93, 0xB4, + 0x9F, 0x71, 0x1A, 0x5B, 0xA8, 0x21, 0xE2, 0x34, + 0xC8, 0x94, 0x92, 0x03, 0xBF, 0x59, 0x9E, 0xFE, + 0x15, 0x65, 0x0C, 0xB7, 0x4C, 0xD9, 0x3B, 0xE9, + 0xD9, 0x11, 0x5B, 0x87, 0x3A, 0x9A, 0x03, 0xEA + }, + { + 0xE1, 0xE2, 0x12, 0x92, 0x06, 0x91, 0x91, 0x7A, + 0x51, 0x8D, 0xDF, 0x7C, 0x51, 0x5A, 0x5D, 0x73, + 0xB1, 0xB2, 0x1E, 0xF1, 0x1B, 0xFC, 0xBF, 0x31, + 0xC4, 0x8A, 0xB2, 0xD4, 0x74, 0x28, 0x42, 0x8A, + 0x99, 0xA0, 0xE9, 0x4C, 0xAE, 0x52, 0x5C, 0x79, + 0x25, 0x96, 0xF8, 0xB4, 0x65, 0xFB, 0xB6, 0xA6, + 0x27, 0xEC, 0xBC, 0x5A, 0x79, 0x65, 0xF6, 0x01, + 0x86, 0xAC, 0x88, 0xF6, 0x01, 0x37, 0x4D, 0xD5 + }, + { + 0x7F, 0x09, 0x1A, 0xAF, 0xD3, 0xD5, 0xFA, 0x54, + 0x92, 0x39, 0xF2, 0xE1, 0xB3, 0x82, 0xE9, 0x47, + 0xFB, 0x7F, 0x13, 0x6E, 0x0C, 0x04, 0x37, 0x04, + 0x3C, 0xBB, 0xB6, 0x41, 0x31, 0x5A, 0xD1, 0x5C, + 0x04, 0xDA, 0x58, 0x3B, 0x77, 0xAB, 0xBA, 0x66, + 0x0E, 0x44, 0x3A, 0xD9, 0xB4, 0xAA, 0xE4, 0x8A, + 0xF9, 0x36, 0x4F, 0x94, 0x62, 0x1E, 0x3A, 0x13, + 0x99, 0x89, 0xBE, 0x08, 0xDE, 0x79, 0xD1, 0x70 + }, + { + 0x6B, 0x49, 0x0F, 0x42, 0xE9, 0x02, 0xF6, 0x1B, + 0x1E, 0xE1, 0x2D, 0x3C, 0x85, 0xE3, 0x41, 0x52, + 0xE3, 0x7C, 0x94, 0xD0, 0x7A, 0xB9, 0xEA, 0x57, + 0x7C, 0xAD, 0x6A, 0x6E, 0xB4, 0x69, 0x0F, 0xAD, + 0x38, 0x06, 0x4F, 0x53, 0xA1, 0x9C, 0x22, 0x57, + 0x03, 0xA5, 0xC5, 0x2C, 0xDC, 0x9A, 0x85, 0xAD, + 0xD7, 0x1B, 0x33, 0x9D, 0x32, 0x7E, 0x16, 0x30, + 0xEE, 0x34, 0x32, 0xB9, 0x20, 0x24, 0x0E, 0x8A + }, + { + 0x4C, 0xE7, 0xBA, 0xD7, 0x3D, 0x5C, 0xA6, 0xE7, + 0x6C, 0x99, 0x36, 0x44, 0x89, 0xDC, 0xA5, 0xBE, + 0x09, 0xC6, 0x6E, 0x65, 0x5B, 0xA2, 0xCD, 0xAD, + 0x3E, 0xFE, 0x44, 0x53, 0x0C, 0x43, 0xBE, 0xBF, + 0xC2, 0x27, 0x16, 0x6D, 0xFF, 0x4F, 0x4A, 0x7D, + 0x9C, 0x61, 0xE6, 0xD8, 0x19, 0x3F, 0xED, 0x18, + 0x9F, 0xF4, 0x29, 0x53, 0x29, 0x51, 0x70, 0xB9, + 0x93, 0xBF, 0xA0, 0x70, 0xC4, 0x18, 0xBF, 0x27 + }, + { + 0xF2, 0x5E, 0x35, 0x44, 0x4D, 0x7D, 0x04, 0xD8, + 0xD1, 0x91, 0x39, 0xCC, 0x87, 0x3E, 0x06, 0x35, + 0x11, 0x0A, 0x2D, 0x99, 0x8C, 0x7F, 0x97, 0x19, + 0xD3, 0x4D, 0x05, 0x25, 0x40, 0x4B, 0xCA, 0xEA, + 0xCA, 0xCA, 0x75, 0x0F, 0x77, 0x1C, 0x44, 0x76, + 0x9C, 0xEB, 0xA3, 0x7E, 0x7C, 0xAC, 0x20, 0x97, + 0x5B, 0x67, 0xEE, 0x48, 0x0C, 0x2E, 0xA8, 0xFA, + 0x8D, 0xB7, 0xE4, 0x3A, 0xD4, 0x9C, 0x61, 0xB4 + }, + { + 0x85, 0xAC, 0x7A, 0x8D, 0x90, 0xDD, 0x68, 0xE0, + 0x84, 0xD8, 0x12, 0x2A, 0xE1, 0xAE, 0x85, 0x68, + 0x01, 0x14, 0xD6, 0x5F, 0xBB, 0x4D, 0x74, 0xDC, + 0x4A, 0xD8, 0x87, 0x7B, 0x3B, 0x04, 0x31, 0x00, + 0xBD, 0x56, 0x4C, 0x2A, 0x6F, 0xA1, 0x3D, 0x50, + 0x64, 0x13, 0xA4, 0x49, 0x46, 0x64, 0x87, 0xC4, + 0xDA, 0x58, 0x05, 0xC0, 0x0E, 0xF2, 0xF7, 0xD1, + 0x7C, 0xE5, 0x74, 0x81, 0xC4, 0x92, 0x74, 0xA8 + }, + { + 0x16, 0xB8, 0x8B, 0xF9, 0x51, 0x40, 0x9B, 0x6A, + 0xDE, 0xF3, 0x46, 0xE6, 0x5E, 0xE0, 0x9F, 0xBC, + 0x5D, 0x13, 0xE9, 0x19, 0xF5, 0x78, 0xEF, 0x40, + 0x63, 0x53, 0x67, 0x9E, 0xA1, 0xC0, 0x49, 0x9B, + 0xF5, 0xCE, 0x74, 0x15, 0xD1, 0xB5, 0x27, 0x39, + 0xB8, 0xDA, 0xB3, 0xCF, 0xDB, 0x48, 0x6B, 0x36, + 0xD1, 0xFE, 0xF0, 0x2C, 0x18, 0x8E, 0xCE, 0xDC, + 0xBE, 0x2F, 0xEE, 0xC6, 0xC5, 0x35, 0xA3, 0x3A + }, + { + 0x6D, 0xF8, 0x3D, 0xDD, 0x53, 0xF3, 0xDA, 0xB6, + 0x2F, 0xC6, 0x55, 0xCB, 0x9C, 0xC7, 0x2D, 0xD5, + 0x4C, 0x6C, 0xBB, 0xCA, 0x32, 0xCE, 0x49, 0x6C, + 0x3A, 0xCF, 0xE3, 0xD6, 0x38, 0x9C, 0xC8, 0xE6, + 0x9A, 0xE7, 0xD6, 0xC1, 0x07, 0x40, 0x27, 0x78, + 0x21, 0x86, 0xFD, 0x3A, 0x33, 0xB1, 0x04, 0x8E, + 0x2F, 0x1D, 0x83, 0x25, 0x86, 0x62, 0x11, 0x61, + 0x56, 0x0A, 0x6B, 0x8E, 0x77, 0xD6, 0x27, 0x6A + }, + { + 0x96, 0xB5, 0xB9, 0x84, 0xE8, 0x0B, 0x43, 0x27, + 0x45, 0x45, 0x58, 0x23, 0x2A, 0xC7, 0x06, 0xF7, + 0xE1, 0xB9, 0xF8, 0x57, 0x06, 0xF2, 0x1C, 0x00, + 0x17, 0xED, 0x9A, 0xF1, 0xE0, 0x85, 0x69, 0xF5, + 0x79, 0x01, 0x83, 0x73, 0x6C, 0xAD, 0x65, 0x88, + 0xE8, 0xE7, 0x41, 0x7C, 0xB6, 0x5A, 0x3E, 0x95, + 0x69, 0x9C, 0x3F, 0xB0, 0xBF, 0xA3, 0x52, 0x64, + 0x4E, 0xA0, 0x7D, 0xF2, 0x1D, 0xCE, 0x8F, 0x45 + }, + { + 0x84, 0x66, 0x23, 0x82, 0xB5, 0xD7, 0xA7, 0x4F, + 0x8E, 0xA7, 0x8F, 0x3F, 0xDD, 0xED, 0xEB, 0xC1, + 0xA5, 0x18, 0x17, 0xF7, 0xC2, 0x65, 0x8F, 0x4B, + 0xEE, 0x24, 0x2C, 0x82, 0x5E, 0x56, 0xE7, 0x5C, + 0xA9, 0x29, 0x46, 0x8C, 0xFD, 0xDA, 0xCB, 0xE9, + 0x5E, 0xAB, 0xC4, 0x62, 0xF8, 0x44, 0x46, 0xB5, + 0x7A, 0x89, 0x71, 0x45, 0x9C, 0x7F, 0x1C, 0xFD, + 0xB5, 0xF3, 0x7B, 0xA9, 0x42, 0x9E, 0x05, 0xCC + }, + { + 0xA0, 0x11, 0x28, 0x8A, 0xAA, 0x5B, 0xDE, 0xD8, + 0x9C, 0xF9, 0x1B, 0x7D, 0x64, 0xE4, 0xA2, 0xBB, + 0x52, 0xC8, 0x71, 0x0A, 0x65, 0x00, 0x8A, 0x0B, + 0xF8, 0xFE, 0x19, 0x8D, 0x98, 0x11, 0x89, 0x70, + 0x2A, 0xDA, 0x70, 0xD4, 0x3B, 0xBA, 0x08, 0xBD, + 0xCC, 0xDA, 0x47, 0x23, 0x45, 0xF6, 0xCF, 0xF1, + 0x33, 0x40, 0x6A, 0x36, 0xEF, 0x81, 0x5D, 0xD5, + 0xF7, 0xBE, 0x36, 0xA8, 0x7B, 0x36, 0x4B, 0xC9 + }, + { + 0x47, 0x7F, 0x58, 0xF2, 0xFE, 0x67, 0x8D, 0x5E, + 0xDD, 0xF4, 0x44, 0xDD, 0x08, 0x14, 0x80, 0xCA, + 0xD8, 0x19, 0xF4, 0xEC, 0x30, 0x46, 0xE1, 0xA0, + 0xC0, 0x90, 0x83, 0xD6, 0x86, 0xB3, 0x25, 0xA4, + 0x56, 0x8B, 0x3E, 0x60, 0x29, 0xDA, 0x0A, 0x53, + 0x4F, 0x06, 0x56, 0x28, 0x12, 0xAD, 0x88, 0x5E, + 0x11, 0xC5, 0x01, 0xDD, 0x1F, 0x45, 0x82, 0x46, + 0x24, 0x27, 0x3D, 0xC6, 0x64, 0x5E, 0x2D, 0xCF + }, + { + 0x0A, 0x6A, 0x66, 0x3A, 0xF6, 0x2B, 0x0E, 0x50, + 0xE1, 0x73, 0x3D, 0x2F, 0xFA, 0xBF, 0x8C, 0x75, + 0xB7, 0x2B, 0xD0, 0x8A, 0xD9, 0x30, 0x40, 0xE1, + 0x13, 0xE6, 0xDF, 0xB1, 0xA1, 0xAE, 0x46, 0x43, + 0xE3, 0x56, 0xE3, 0x2E, 0x0D, 0x14, 0x9F, 0xA0, + 0xBA, 0x35, 0x4C, 0x4D, 0x49, 0x6E, 0x95, 0xE8, + 0x96, 0x97, 0xD9, 0xB1, 0x33, 0xE0, 0xEB, 0x62, + 0xF7, 0x53, 0xD7, 0xFD, 0x2D, 0x8D, 0x49, 0xB1 + }, + { + 0x28, 0xC8, 0xE4, 0xCB, 0x7F, 0xA5, 0xA0, 0xA7, + 0x4F, 0xC7, 0x26, 0xB4, 0x9F, 0x44, 0x1B, 0x06, + 0x05, 0x15, 0x9F, 0x9B, 0x9D, 0x14, 0x91, 0xA3, + 0x7F, 0xBB, 0x65, 0x38, 0x61, 0x4D, 0x59, 0x90, + 0xCF, 0x7C, 0x0A, 0x25, 0x07, 0xE8, 0xB6, 0xC5, + 0x1D, 0xE1, 0x2C, 0x2F, 0x9A, 0xF1, 0x9A, 0xE7, + 0x86, 0xC8, 0x1D, 0x48, 0x69, 0xA9, 0x70, 0x2C, + 0x48, 0x2D, 0x6A, 0xB6, 0x36, 0x50, 0x1C, 0x0C + }, + { + 0xB7, 0xBE, 0xED, 0x20, 0x19, 0xA3, 0x4A, 0xF5, + 0x70, 0xED, 0xA1, 0x8A, 0xB5, 0x87, 0x04, 0xE7, + 0x4A, 0x9B, 0x06, 0x7D, 0x83, 0xFA, 0x77, 0x49, + 0x88, 0x97, 0xD1, 0x8B, 0x99, 0x28, 0xDF, 0x79, + 0x15, 0xA2, 0x79, 0xE8, 0xDC, 0xA8, 0x21, 0x89, + 0xFC, 0x83, 0xB5, 0xBE, 0x5B, 0xF1, 0xEA, 0x99, + 0xA9, 0x48, 0x84, 0xEE, 0x4A, 0x4D, 0x76, 0x41, + 0xAD, 0xD2, 0x81, 0x2C, 0x4C, 0x0B, 0xEB, 0xD7 + }, + { + 0x1C, 0xBC, 0xA8, 0xE6, 0xA8, 0xF9, 0xA9, 0x94, + 0xD0, 0xAC, 0x7B, 0xC8, 0x02, 0x31, 0xEC, 0xBD, + 0x7A, 0x7A, 0xC9, 0x22, 0x61, 0xD3, 0x7A, 0x28, + 0xF2, 0xC3, 0xA9, 0xBE, 0xD1, 0xE9, 0xA7, 0x9E, + 0xD8, 0xEB, 0xE6, 0x1D, 0x43, 0x7F, 0xBC, 0x63, + 0x0E, 0x64, 0xBB, 0xB1, 0xEC, 0xD3, 0x5A, 0x83, + 0xAA, 0xBB, 0x63, 0x5C, 0xC5, 0xAF, 0x8A, 0x50, + 0x0C, 0xD4, 0xA7, 0x90, 0xF1, 0x6B, 0x86, 0x38 + }, + { + 0x3D, 0x12, 0x45, 0x7E, 0x85, 0xC0, 0x2E, 0xF0, + 0x4C, 0xE2, 0x57, 0x5E, 0x4F, 0x54, 0xDD, 0x66, + 0x86, 0x7B, 0x4A, 0x8E, 0xC7, 0xD8, 0x7E, 0x16, + 0x9C, 0xB8, 0x7A, 0x1E, 0xC8, 0xEC, 0x70, 0xEC, + 0x75, 0x7B, 0xF9, 0x85, 0x21, 0x5E, 0x4E, 0x4D, + 0x08, 0xA7, 0x9E, 0x48, 0xCB, 0x83, 0xB7, 0x4A, + 0x62, 0xA5, 0x88, 0xB5, 0x66, 0x46, 0x92, 0xBB, + 0xE6, 0x02, 0x01, 0x7D, 0x0C, 0xD1, 0x21, 0xE8 + }, + { + 0xEC, 0x1E, 0x0C, 0xD7, 0x49, 0x04, 0xB0, 0x54, + 0x08, 0xD3, 0x28, 0xE9, 0x26, 0xB5, 0xD2, 0xE0, + 0x22, 0x94, 0x02, 0xAA, 0x2B, 0x13, 0x15, 0xE5, + 0xAB, 0xDD, 0xA6, 0x6C, 0x5E, 0x5B, 0x2E, 0xB5, + 0x08, 0x86, 0x99, 0x77, 0x32, 0x0C, 0x96, 0xC1, + 0xD6, 0x40, 0x21, 0x5A, 0x60, 0x14, 0xFE, 0xE4, + 0x94, 0xB3, 0xF9, 0x32, 0xD4, 0xF7, 0xCA, 0x5B, + 0xCA, 0x7F, 0x0C, 0x0A, 0x0F, 0x1C, 0x03, 0xF4 + }, + { + 0x8A, 0xF8, 0x5B, 0xE0, 0x9B, 0xCC, 0xF3, 0x33, + 0xC6, 0xF0, 0xC0, 0xE9, 0x82, 0xB3, 0xC9, 0x6B, + 0xBE, 0x91, 0x5A, 0x0B, 0x2C, 0xE3, 0x25, 0x29, + 0x3A, 0x56, 0xE5, 0xB5, 0x96, 0x3E, 0x80, 0xCA, + 0xF4, 0x9B, 0x14, 0x86, 0x85, 0xD3, 0x15, 0x0A, + 0x45, 0xA7, 0x59, 0xC7, 0x10, 0x78, 0x3D, 0x84, + 0xDA, 0x52, 0xFB, 0x71, 0xF3, 0x25, 0x73, 0x14, + 0x56, 0x78, 0x40, 0x26, 0xD2, 0x82, 0xB0, 0x39 + }, + { + 0x47, 0x09, 0x31, 0xE4, 0x87, 0x5E, 0x0F, 0x27, + 0x80, 0x68, 0xBE, 0x75, 0x08, 0xFD, 0xBA, 0x0A, + 0x01, 0x9C, 0x33, 0xDF, 0x44, 0x7D, 0x5E, 0x76, + 0xC3, 0x42, 0xB4, 0x00, 0x7C, 0x0A, 0x23, 0x3C, + 0xE4, 0x8E, 0xC0, 0xD7, 0x8C, 0x33, 0x72, 0x0B, + 0xA5, 0xDC, 0x42, 0x7D, 0x8C, 0xA1, 0xEF, 0x7C, + 0xC6, 0xD9, 0x9F, 0xF4, 0x3C, 0xE4, 0x17, 0x5D, + 0x02, 0x14, 0x6A, 0x66, 0xE0, 0x40, 0x7D, 0x18 + }, + { + 0x31, 0xD8, 0x12, 0x0D, 0x57, 0x68, 0xB5, 0xA2, + 0xC3, 0x32, 0xBE, 0x12, 0xE2, 0x87, 0x2D, 0x57, + 0xC2, 0x1C, 0x7F, 0x85, 0xB4, 0x32, 0x1E, 0xCC, + 0xD7, 0x20, 0x4E, 0x60, 0x07, 0x4E, 0xCD, 0xDE, + 0x45, 0x8D, 0x13, 0xA6, 0x2B, 0x20, 0x35, 0x0B, + 0x5C, 0xF1, 0x4B, 0x04, 0xF8, 0x82, 0xD5, 0xB9, + 0xD0, 0xD0, 0x47, 0x4B, 0xBD, 0xB5, 0xE8, 0xAA, + 0x65, 0x90, 0xA1, 0x0C, 0x1C, 0x5C, 0x7B, 0x77 + }, + { + 0x3F, 0xB7, 0x72, 0x18, 0x1A, 0xD1, 0x0E, 0x48, + 0x28, 0xE9, 0x76, 0xEC, 0xAD, 0x88, 0x86, 0xA6, + 0x5F, 0x68, 0xAD, 0x4B, 0xED, 0x0A, 0xFA, 0x05, + 0xA0, 0xBD, 0x89, 0x47, 0xB4, 0x2E, 0x16, 0x75, + 0x3A, 0x23, 0xF9, 0xBB, 0x43, 0x19, 0x2F, 0x73, + 0x4A, 0x0B, 0x19, 0x18, 0x58, 0x2D, 0xBF, 0xA2, + 0xCE, 0x62, 0x0B, 0xCF, 0xC2, 0x4A, 0x98, 0x43, + 0xFC, 0x0D, 0x3B, 0xBC, 0x48, 0x32, 0x18, 0xF8 + }, + { + 0xFE, 0x86, 0x2A, 0xC4, 0xC6, 0xD9, 0x84, 0x3E, + 0x3C, 0x05, 0xB2, 0xCF, 0xBA, 0x2D, 0x7A, 0xFB, + 0x9A, 0xEE, 0xE6, 0x2E, 0x7A, 0xE6, 0xC4, 0x46, + 0x2A, 0x29, 0x1E, 0x8E, 0x3C, 0x65, 0x43, 0x44, + 0xE2, 0x42, 0x26, 0x73, 0x30, 0x2D, 0x0A, 0x97, + 0xBF, 0x96, 0xB6, 0x52, 0x9D, 0x09, 0x89, 0x8E, + 0x32, 0xAE, 0xBB, 0xCF, 0xF9, 0x10, 0xDE, 0xE0, + 0x49, 0x28, 0x50, 0xB1, 0xF3, 0x84, 0x7D, 0xDC + }, + { + 0xE9, 0x02, 0x5A, 0x17, 0x82, 0xC2, 0x54, 0xCD, + 0x2B, 0x34, 0x84, 0x9D, 0x82, 0xFE, 0x0B, 0x7C, + 0x14, 0x35, 0x61, 0x58, 0x13, 0x39, 0x09, 0x74, + 0x46, 0x8A, 0x01, 0xBE, 0x1E, 0x0F, 0xCA, 0x4A, + 0x21, 0x0F, 0xA9, 0x53, 0xD2, 0x8E, 0x5F, 0x76, + 0x9A, 0x9B, 0x82, 0x5B, 0xE7, 0x47, 0x65, 0xC7, + 0x27, 0x2F, 0xFE, 0x4D, 0xD4, 0x55, 0xC6, 0x05, + 0x40, 0xDD, 0x23, 0xDD, 0xE0, 0x1B, 0x30, 0x6F + }, + { + 0x18, 0x68, 0x5E, 0x55, 0x87, 0x49, 0x0C, 0x7A, + 0x53, 0x7A, 0xFB, 0x4E, 0xDB, 0x12, 0x9A, 0x54, + 0x57, 0x6D, 0x68, 0xBD, 0x2D, 0xF9, 0x91, 0x4C, + 0x51, 0x6A, 0x36, 0x8C, 0xAF, 0x4F, 0xD7, 0x99, + 0x68, 0x4F, 0x77, 0x2C, 0x8B, 0xDC, 0xAD, 0xFF, + 0xD1, 0xF8, 0x3D, 0x00, 0x95, 0x69, 0xEA, 0x41, + 0x13, 0x7E, 0x10, 0xC7, 0x93, 0xD0, 0xC6, 0xAE, + 0x2B, 0xB6, 0x12, 0x33, 0x41, 0x3A, 0xAD, 0xA0 + }, + { + 0xD0, 0x5A, 0xC4, 0x33, 0x30, 0xD6, 0xBB, 0x0B, + 0x43, 0x3D, 0xA1, 0x2F, 0x28, 0xA3, 0x89, 0x90, + 0x0F, 0xBC, 0x0B, 0x88, 0xA3, 0xAB, 0x56, 0x38, + 0x17, 0xD3, 0xD0, 0xAD, 0xED, 0x2F, 0x25, 0xF4, + 0xA2, 0x7D, 0x14, 0xE4, 0x20, 0x6B, 0x50, 0x50, + 0xCA, 0x19, 0xE0, 0xBF, 0x68, 0xA0, 0x43, 0xDF, + 0xFD, 0xF1, 0x5D, 0xB0, 0xFB, 0x12, 0x5D, 0x0D, + 0xF1, 0xD4, 0x21, 0x98, 0x0A, 0xD8, 0xA1, 0xB6 + }, + { + 0x1B, 0x52, 0x24, 0x05, 0xBD, 0x93, 0x0D, 0x63, + 0xFB, 0x75, 0x3D, 0x7A, 0x65, 0x9D, 0x76, 0xAE, + 0x61, 0xF4, 0x42, 0x1C, 0x6B, 0xB0, 0x9D, 0x8C, + 0xCB, 0xCE, 0xE5, 0x0C, 0xD4, 0x2D, 0xB5, 0x93, + 0x6D, 0xCE, 0xA7, 0x90, 0x89, 0x84, 0x7D, 0x23, + 0xF9, 0xC9, 0xD9, 0x3A, 0xD7, 0x33, 0x31, 0xC9, + 0xB3, 0x5C, 0x43, 0x06, 0x33, 0xE3, 0x14, 0x32, + 0x58, 0xDE, 0x7F, 0xE3, 0xF8, 0x81, 0xED, 0xDA + }, + { + 0xBA, 0xB0, 0xFA, 0xC6, 0xAD, 0x0D, 0x2A, 0x37, + 0x08, 0x17, 0x52, 0x51, 0xB1, 0xFC, 0xB9, 0x3D, + 0x9D, 0x0A, 0x9C, 0x31, 0xAE, 0xB2, 0xEB, 0xFB, + 0x20, 0x01, 0x54, 0x4B, 0xF8, 0x50, 0x43, 0x35, + 0xAD, 0x19, 0xA5, 0x41, 0xBF, 0xFB, 0x01, 0x98, + 0x4C, 0xE6, 0xBB, 0x11, 0x9E, 0xE5, 0x02, 0x03, + 0x55, 0xBD, 0x06, 0x4B, 0xED, 0xF5, 0x3B, 0xFD, + 0xE7, 0xCA, 0x3D, 0x27, 0x08, 0x35, 0xC6, 0x32 + }, + { + 0xE2, 0x5D, 0xD2, 0xEB, 0x20, 0x43, 0x3F, 0xE8, + 0xAE, 0xB2, 0xD5, 0x21, 0x15, 0x6C, 0x06, 0xBE, + 0x36, 0x30, 0x9F, 0xD6, 0x12, 0x2F, 0xC6, 0x0B, + 0xCC, 0x4C, 0x02, 0x53, 0xD3, 0x37, 0x5B, 0xDE, + 0x1A, 0xA1, 0x90, 0x98, 0x87, 0xA6, 0x24, 0xE2, + 0x91, 0x39, 0xD6, 0xA0, 0x75, 0x69, 0xA1, 0xA9, + 0xD0, 0xC7, 0x2A, 0x9C, 0xC2, 0x28, 0x28, 0x24, + 0x4E, 0x43, 0x9C, 0x93, 0x87, 0x22, 0x89, 0x29 + }, + { + 0x84, 0xFC, 0x8F, 0xEC, 0x38, 0xF1, 0x27, 0x85, + 0x57, 0xAD, 0x37, 0xDD, 0xDF, 0x54, 0xC4, 0xC7, + 0x73, 0x6E, 0x46, 0x6E, 0x2B, 0xBC, 0x98, 0xB2, + 0xC6, 0x81, 0xFE, 0xDF, 0x32, 0x8C, 0xEE, 0x4B, + 0x7A, 0x0C, 0x8F, 0x8C, 0x01, 0xCE, 0xFA, 0xA7, + 0xEB, 0xF3, 0xF5, 0xDA, 0x78, 0x14, 0x0E, 0x33, + 0x34, 0xEA, 0xB0, 0x84, 0xA8, 0x1C, 0x3A, 0xF4, + 0x4A, 0xBF, 0xBC, 0x97, 0x06, 0x85, 0xBD, 0x8C + }, + { + 0x31, 0x51, 0x98, 0x7F, 0x67, 0xA7, 0xF1, 0xA7, + 0x3E, 0xAD, 0x1D, 0x73, 0x22, 0xBE, 0x5D, 0x04, + 0x47, 0x20, 0x4F, 0x57, 0x22, 0x4A, 0x1F, 0xD8, + 0x7E, 0x93, 0xEE, 0x52, 0xFF, 0xD4, 0x7B, 0x65, + 0x55, 0xA5, 0x7E, 0xD0, 0xB0, 0xD2, 0xCC, 0x44, + 0x35, 0x02, 0x9E, 0xCD, 0x11, 0x63, 0x73, 0x96, + 0xB0, 0x18, 0xAF, 0xBA, 0x37, 0x2F, 0x89, 0xD1, + 0xCF, 0xA4, 0xB6, 0x4F, 0x2E, 0xA0, 0xB4, 0x42 + }, + { + 0x21, 0x21, 0x94, 0xF9, 0x71, 0xB9, 0xB2, 0x5D, + 0x81, 0x5B, 0x26, 0x1E, 0xF1, 0x4F, 0x01, 0x2C, + 0xFA, 0x42, 0x8E, 0xC1, 0xA2, 0xAF, 0xA7, 0x44, + 0x61, 0x82, 0xC8, 0x40, 0x66, 0x60, 0x28, 0x83, + 0x19, 0x30, 0x01, 0x12, 0x47, 0x70, 0x2B, 0x90, + 0x40, 0x66, 0x5D, 0x25, 0xCE, 0x4D, 0x2D, 0x2E, + 0xA5, 0x9A, 0xE5, 0x57, 0xC2, 0x92, 0xFC, 0x29, + 0xA6, 0x54, 0xCD, 0x47, 0x20, 0x48, 0xEE, 0xD5 + }, + { + 0x1D, 0xC2, 0x68, 0xAE, 0x0A, 0xD8, 0xC7, 0x2A, + 0x28, 0x22, 0x66, 0x55, 0x60, 0x5C, 0x3D, 0xF7, + 0x10, 0xDB, 0x51, 0x7C, 0x65, 0x4A, 0xD7, 0xDB, + 0x1D, 0x84, 0x9A, 0xE0, 0xC4, 0x16, 0xED, 0xB7, + 0x12, 0xB0, 0xF4, 0x3C, 0x91, 0xEB, 0xF3, 0xDE, + 0x4F, 0xAD, 0x06, 0x9A, 0x06, 0xAC, 0xB6, 0xEB, + 0x2E, 0x57, 0xAA, 0x52, 0x52, 0xB5, 0x35, 0x67, + 0x6A, 0xE4, 0x33, 0xFF, 0x36, 0xB3, 0x90, 0x29 + }, + { + 0xC1, 0xE1, 0x1F, 0x1D, 0xAF, 0x0D, 0xE6, 0x8E, + 0x27, 0x09, 0xBF, 0xB8, 0x3E, 0x22, 0x6E, 0xA1, + 0xB4, 0xBF, 0xD5, 0xFA, 0xB1, 0xA2, 0x56, 0xA9, + 0x34, 0x54, 0x03, 0xB1, 0x43, 0x85, 0xE4, 0x88, + 0xEA, 0x25, 0xED, 0x64, 0x48, 0x26, 0x55, 0xFA, + 0x36, 0x91, 0x18, 0xBA, 0xBC, 0xD5, 0x27, 0x4F, + 0x90, 0x9B, 0x8B, 0x80, 0x86, 0x69, 0xA2, 0x79, + 0x79, 0x04, 0x9A, 0xE1, 0x21, 0x0F, 0xC4, 0xDD + }, + { + 0x00, 0x33, 0x22, 0xD7, 0x35, 0xD0, 0x1A, 0x35, + 0x5F, 0x2E, 0x3B, 0x74, 0x5B, 0x38, 0x24, 0xBC, + 0xCC, 0x2E, 0xB0, 0xDB, 0xE5, 0xA4, 0xDC, 0xD8, + 0xEE, 0xE4, 0x80, 0x42, 0x1F, 0x1B, 0x1B, 0x20, + 0xAA, 0x62, 0xC2, 0xC9, 0xF5, 0x7B, 0x7A, 0x45, + 0xC9, 0x52, 0xD4, 0x3B, 0xDE, 0x20, 0x6E, 0x81, + 0x43, 0x9F, 0x57, 0xAB, 0x7D, 0x98, 0x13, 0xED, + 0x08, 0x6E, 0xCC, 0x55, 0xD4, 0x2E, 0x05, 0xD0 + }, + { + 0xE5, 0xEE, 0x77, 0x81, 0xBB, 0x08, 0x3D, 0xEB, + 0x6D, 0xE3, 0x70, 0x8B, 0x60, 0xAB, 0x41, 0xBA, + 0x92, 0x72, 0xA9, 0x15, 0xFF, 0x63, 0x28, 0x6B, + 0x20, 0x22, 0x23, 0x20, 0xFE, 0xE5, 0xF7, 0x56, + 0x30, 0x79, 0x63, 0x46, 0x2E, 0xB6, 0x4F, 0x97, + 0xEC, 0x6A, 0x66, 0xD3, 0xDC, 0xBB, 0x2B, 0x69, + 0xB8, 0x93, 0x4F, 0xCA, 0x5C, 0xD1, 0x7D, 0x59, + 0x66, 0x07, 0x5B, 0xBC, 0xED, 0xEE, 0x4A, 0x2E + }, + { + 0xE3, 0xD4, 0xE5, 0xD4, 0xAF, 0xA6, 0x64, 0x5A, + 0xD2, 0x62, 0x1C, 0x52, 0x8A, 0xE1, 0x2F, 0x05, + 0x6D, 0x37, 0x48, 0xA6, 0x17, 0x25, 0x0B, 0x61, + 0xEC, 0x99, 0x5B, 0x57, 0xAF, 0x4D, 0xD8, 0xA1, + 0x0B, 0x53, 0x01, 0x9E, 0x43, 0x4E, 0x0E, 0x85, + 0xA0, 0x15, 0x04, 0x3F, 0xD6, 0x20, 0xC7, 0x28, + 0x71, 0xD2, 0x22, 0xD3, 0x3B, 0xBF, 0x59, 0xFC, + 0x72, 0x69, 0x71, 0x97, 0xB9, 0x56, 0xA9, 0x9F + }, + { + 0xA6, 0xFB, 0x36, 0xE7, 0x7D, 0x21, 0xBC, 0x0C, + 0x52, 0x87, 0xFD, 0xC9, 0x19, 0x1C, 0x37, 0x95, + 0xE3, 0x6D, 0x4E, 0xD5, 0xAE, 0xBB, 0x68, 0x6D, + 0x58, 0x4C, 0x52, 0xB8, 0xBA, 0x0E, 0xBD, 0x01, + 0xC8, 0x1E, 0x43, 0x1D, 0x6E, 0xE0, 0xEC, 0xA6, + 0xC8, 0x4E, 0x83, 0xF1, 0x62, 0xBB, 0xA7, 0xD2, + 0x00, 0xE8, 0x68, 0x48, 0x42, 0x6E, 0x66, 0x9D, + 0x41, 0x0F, 0x01, 0xC3, 0x19, 0x8D, 0x67, 0x0E + }, + { + 0xEC, 0xAE, 0x4E, 0xBF, 0xF6, 0x8E, 0x66, 0x66, + 0xF2, 0xBD, 0xDD, 0x5C, 0x26, 0xC5, 0x14, 0x6A, + 0xD2, 0x89, 0x39, 0xF3, 0xFD, 0x1F, 0x8E, 0x7A, + 0xF0, 0x99, 0xFD, 0x39, 0x2B, 0x31, 0xB2, 0xFD, + 0x39, 0x9E, 0x11, 0x61, 0xA4, 0xA9, 0xA1, 0xCC, + 0x4D, 0x0D, 0x11, 0xC7, 0xB1, 0x3D, 0xBD, 0xB8, + 0x1C, 0x3B, 0xB0, 0xE6, 0x32, 0x8B, 0x36, 0x07, + 0x50, 0xEC, 0xF2, 0xA6, 0x7A, 0x60, 0x9E, 0xED + }, + { + 0x8D, 0xEC, 0x3F, 0x87, 0x13, 0x59, 0xFC, 0x52, + 0xCD, 0x92, 0xDE, 0x29, 0x9C, 0xF0, 0x78, 0x4C, + 0x8B, 0x9E, 0x3D, 0x10, 0xB1, 0xAE, 0x1B, 0x7C, + 0x88, 0x9F, 0x82, 0xD2, 0xA7, 0x13, 0xCE, 0xFC, + 0xC0, 0x1F, 0x68, 0x52, 0x3D, 0x4A, 0x01, 0x17, + 0x47, 0x70, 0xB0, 0xD7, 0x56, 0x76, 0xCC, 0x6E, + 0xCA, 0x49, 0xA7, 0x0A, 0x26, 0x41, 0x6C, 0xDD, + 0x42, 0xAD, 0xD5, 0x2D, 0x09, 0x11, 0x6B, 0x1D + }, + { + 0xFC, 0x3A, 0xDF, 0x29, 0xDE, 0xC1, 0x71, 0x6A, + 0x92, 0x1F, 0x5E, 0x91, 0x64, 0x52, 0x10, 0x02, + 0x2A, 0x13, 0xF2, 0x96, 0x70, 0xC0, 0x7A, 0x36, + 0x3B, 0xD7, 0xC3, 0x0E, 0xDF, 0xF5, 0x51, 0xC3, + 0x08, 0x37, 0x55, 0xA1, 0x07, 0xAF, 0x58, 0x47, + 0x68, 0x81, 0x31, 0x40, 0x3E, 0x87, 0x91, 0x21, + 0x6C, 0x0E, 0xA5, 0xAF, 0xE3, 0x6C, 0x82, 0x56, + 0xB7, 0xF7, 0x5F, 0x56, 0x6D, 0xFE, 0x0E, 0x6E + }, + { + 0xF4, 0x7D, 0x57, 0x8A, 0x37, 0x05, 0x4C, 0xBD, + 0x07, 0x47, 0x6D, 0x74, 0xE3, 0x5B, 0x68, 0x87, + 0x46, 0x5F, 0x99, 0x6B, 0xDA, 0x84, 0x66, 0xA7, + 0x1F, 0x3A, 0x50, 0x28, 0x93, 0x2E, 0x91, 0xF2, + 0x95, 0xA1, 0x68, 0xD1, 0x75, 0xE6, 0xA4, 0xE9, + 0xF1, 0x24, 0x47, 0x5A, 0x80, 0x83, 0xDD, 0x53, + 0x72, 0x87, 0xDC, 0x2E, 0x3B, 0x84, 0x57, 0x0B, + 0xF3, 0x0E, 0x57, 0xB5, 0x4A, 0xC7, 0x84, 0x37 + }, + { + 0x8F, 0x94, 0x2C, 0x74, 0x06, 0x28, 0xF5, 0xAD, + 0xA4, 0x61, 0xCC, 0x5D, 0x2F, 0xC2, 0x1D, 0x8C, + 0x88, 0xD3, 0x83, 0x56, 0x1E, 0x34, 0x2D, 0x5F, + 0x1E, 0x73, 0xB6, 0xA4, 0x5F, 0x08, 0x41, 0xF3, + 0xC7, 0x3E, 0x71, 0x0F, 0xF6, 0xC3, 0x6E, 0x86, + 0x1E, 0xAA, 0x54, 0x5B, 0x45, 0x6C, 0x2E, 0x23, + 0xC8, 0x90, 0xE9, 0x6B, 0x11, 0xB2, 0x3D, 0x08, + 0x85, 0xAB, 0xFB, 0xB8, 0xAE, 0x8E, 0x51, 0xAE + }, + { + 0x5C, 0x31, 0xAC, 0xE6, 0x18, 0x69, 0x6E, 0x78, + 0x46, 0x13, 0xBA, 0x5E, 0xF5, 0xCE, 0xEE, 0x9A, + 0x2D, 0xFB, 0x5D, 0x8A, 0xBA, 0xB1, 0xA7, 0xA1, + 0xC2, 0x52, 0x3E, 0x37, 0x5D, 0xF7, 0x7A, 0x92, + 0xEB, 0x69, 0xFC, 0xA2, 0x02, 0xFF, 0x62, 0xB1, + 0x76, 0x78, 0x88, 0x6C, 0x45, 0x02, 0x48, 0x69, + 0x28, 0xFE, 0xC9, 0xAC, 0x26, 0x3B, 0x27, 0x4F, + 0xF1, 0x05, 0x3C, 0x67, 0x03, 0xAF, 0xE6, 0xAD + }, + { + 0x40, 0xC7, 0xB5, 0xF4, 0xDA, 0x12, 0x56, 0x80, + 0xA6, 0xBA, 0x41, 0x9C, 0x74, 0x5E, 0x59, 0x16, + 0x27, 0xFE, 0xC7, 0xD1, 0xEE, 0x5F, 0x52, 0x8F, + 0x86, 0x79, 0xC4, 0x3A, 0xFF, 0x24, 0x29, 0x4D, + 0x35, 0xFA, 0x2C, 0xDD, 0x32, 0xCD, 0x7F, 0x19, + 0xDF, 0x04, 0x03, 0x6A, 0x82, 0x80, 0x6F, 0xDD, + 0xB7, 0x9C, 0x24, 0x6A, 0xED, 0x08, 0x58, 0xE3, + 0xA0, 0x2B, 0x2C, 0xBB, 0x72, 0x61, 0x16, 0x7A + }, + { + 0xAC, 0xE0, 0x58, 0x4B, 0xC5, 0x35, 0xC8, 0x24, + 0x81, 0x0A, 0x61, 0x82, 0x9C, 0x47, 0x27, 0x3D, + 0x2E, 0x53, 0x64, 0xEC, 0x60, 0x9D, 0x2C, 0x35, + 0x7B, 0x01, 0x68, 0x6F, 0xEC, 0x6F, 0x31, 0xA6, + 0x52, 0x7A, 0x70, 0xBF, 0xDE, 0x6F, 0xEF, 0xAB, + 0xF6, 0x39, 0xA6, 0x38, 0x9E, 0x49, 0xAB, 0xD7, + 0x2C, 0x62, 0xEF, 0x30, 0xB4, 0xA7, 0x99, 0xDB, + 0x55, 0x34, 0x0F, 0x48, 0x5D, 0x48, 0x1F, 0x60 + }, + { + 0x9D, 0x06, 0xAB, 0xC9, 0x9F, 0x6B, 0xB5, 0x2F, + 0x68, 0x3B, 0x51, 0x72, 0x6E, 0x62, 0x67, 0x7C, + 0x82, 0x40, 0xCF, 0x92, 0xB5, 0x84, 0x7D, 0xBE, + 0xE7, 0x1F, 0xF1, 0x18, 0xD0, 0x54, 0x2D, 0xF8, + 0x08, 0x17, 0xFF, 0x5D, 0xF9, 0x89, 0x27, 0xCF, + 0x07, 0x0E, 0x19, 0x1C, 0x40, 0x24, 0x7F, 0x1A, + 0x9A, 0xC1, 0x7B, 0xFA, 0x5B, 0x81, 0xAD, 0xBE, + 0x98, 0x25, 0x29, 0x96, 0xD2, 0xD2, 0xF9, 0x81 + }, + { + 0x0C, 0x76, 0xDD, 0xE7, 0xB1, 0x10, 0x60, 0xE8, + 0x7A, 0x4E, 0x5B, 0xC8, 0x02, 0x0B, 0xEF, 0x57, + 0xDE, 0x55, 0xAA, 0x76, 0x0A, 0xC7, 0xA9, 0x37, + 0xD8, 0xCD, 0xFF, 0x67, 0xC8, 0x6E, 0x88, 0x40, + 0xF1, 0xE4, 0xDD, 0x76, 0x87, 0x67, 0x75, 0xB6, + 0x45, 0xB6, 0xA2, 0x03, 0x0E, 0x5B, 0x76, 0x8C, + 0xF0, 0x43, 0x74, 0x9B, 0x95, 0xEB, 0x74, 0xD2, + 0x91, 0xFC, 0xC8, 0x23, 0xAD, 0x61, 0xDC, 0xA9 + }, + { + 0xD8, 0xA9, 0xE4, 0xE8, 0x38, 0x85, 0x78, 0x2C, + 0x2B, 0xA6, 0x13, 0xAD, 0x1C, 0x16, 0xAB, 0xE2, + 0x2A, 0xC8, 0x53, 0x8C, 0xAA, 0x1B, 0x73, 0x49, + 0x28, 0xBE, 0xB1, 0x9C, 0x50, 0x31, 0x1A, 0x33, + 0x89, 0x05, 0x30, 0xA2, 0x6D, 0xA3, 0xB5, 0xDB, + 0x9B, 0xA3, 0x8C, 0x96, 0xF2, 0x63, 0xA7, 0x48, + 0x1E, 0x06, 0xCC, 0x05, 0x46, 0x02, 0xD5, 0xAF, + 0x68, 0xDC, 0x18, 0x83, 0x7B, 0x15, 0x6B, 0xB9 + }, + { + 0xE5, 0x0A, 0x40, 0xBC, 0xE1, 0xF6, 0xD4, 0x9A, + 0x17, 0xA0, 0x6D, 0x84, 0x5F, 0x61, 0x08, 0xD8, + 0xE1, 0x2D, 0x83, 0x97, 0xA1, 0xC0, 0x06, 0x2C, + 0xB2, 0xB2, 0x68, 0x25, 0x5F, 0x81, 0xDC, 0x99, + 0x6A, 0x3E, 0x0C, 0x11, 0x46, 0x8C, 0xD6, 0x79, + 0x4D, 0x9D, 0x2A, 0x5F, 0x46, 0xB1, 0x1F, 0xE4, + 0x63, 0xC0, 0x69, 0xD8, 0x43, 0xA4, 0xD7, 0x80, + 0x6B, 0x89, 0xBA, 0x3E, 0xA1, 0x56, 0xEE, 0x19 + }, + { + 0x60, 0x16, 0xE3, 0x2C, 0xF9, 0xB6, 0x13, 0xE7, + 0x4A, 0x9E, 0x37, 0xA4, 0x5E, 0xCC, 0x9F, 0x90, + 0x01, 0xF5, 0xD8, 0xA3, 0x77, 0x2F, 0x92, 0x6C, + 0x02, 0x38, 0x39, 0x3B, 0xE7, 0xD9, 0x7C, 0xEA, + 0x74, 0x0A, 0x0B, 0xBB, 0x3E, 0x4F, 0xB7, 0xEE, + 0x96, 0xC4, 0xFA, 0xB7, 0xA6, 0x26, 0x40, 0x6C, + 0x6C, 0x2A, 0xD6, 0xBE, 0xCF, 0xDE, 0xD4, 0x2D, + 0x2F, 0x7C, 0x94, 0x20, 0xBC, 0x91, 0x71, 0x33 + }, + { + 0xEB, 0x10, 0x7B, 0xCB, 0x87, 0x80, 0x7A, 0xDD, + 0xFB, 0x6E, 0x40, 0xEA, 0x97, 0x17, 0xE9, 0x34, + 0x9A, 0x33, 0x6E, 0x69, 0x42, 0x29, 0x87, 0x6C, + 0x13, 0xD3, 0x70, 0x63, 0x6C, 0x45, 0x6F, 0xF4, + 0xC7, 0x64, 0x78, 0x5E, 0x7B, 0xFB, 0xB1, 0xBD, + 0xA8, 0x0E, 0xFC, 0xE2, 0xD7, 0x62, 0xC8, 0xCA, + 0x99, 0x6D, 0xB0, 0xB3, 0x8D, 0x2B, 0xD4, 0xA9, + 0xA2, 0x51, 0x84, 0x77, 0x09, 0xA8, 0x04, 0x7E + }, + { + 0xEE, 0xF8, 0x96, 0xB5, 0x0C, 0xE1, 0xD5, 0x4E, + 0x10, 0xD8, 0xDE, 0x24, 0x3B, 0x16, 0x54, 0x24, + 0x47, 0xC8, 0xDF, 0xA3, 0xED, 0x99, 0xCB, 0x14, + 0xE5, 0x64, 0xB0, 0x61, 0x07, 0x01, 0x3D, 0x09, + 0x54, 0x55, 0x66, 0x5B, 0x93, 0x4F, 0x22, 0xDB, + 0x3F, 0x31, 0x68, 0x37, 0x0F, 0x7C, 0x03, 0xFC, + 0xE4, 0x86, 0x43, 0xD1, 0x00, 0xE8, 0xC0, 0x44, + 0xD6, 0x16, 0xFA, 0xD4, 0xAD, 0x93, 0x47, 0xC6 + }, + { + 0x76, 0x32, 0x42, 0x29, 0x82, 0x06, 0x4F, 0x91, + 0x53, 0x29, 0xE6, 0xCA, 0xFF, 0xBA, 0x30, 0xF0, + 0xE1, 0xA0, 0x37, 0x0E, 0x13, 0xD7, 0x07, 0xFF, + 0x84, 0xB5, 0x2A, 0x96, 0x33, 0x35, 0x80, 0x95, + 0x0F, 0x7B, 0x36, 0x13, 0x96, 0x27, 0x9F, 0x7E, + 0xE2, 0x58, 0x3F, 0x69, 0x5C, 0x37, 0xAB, 0xEA, + 0xA7, 0x3B, 0x75, 0x85, 0x00, 0xBF, 0x65, 0xB5, + 0x99, 0x73, 0xF3, 0xC4, 0x39, 0x94, 0xD2, 0x3E + }, + { + 0x8A, 0x16, 0x2F, 0x2A, 0x20, 0xA2, 0x35, 0x82, + 0x0E, 0xAC, 0x1F, 0x3E, 0x64, 0x3B, 0x0C, 0xC0, + 0x10, 0x41, 0x8C, 0x39, 0xB0, 0x77, 0x50, 0x5F, + 0xE7, 0xE3, 0x87, 0x8A, 0xD4, 0x87, 0x95, 0xCF, + 0xBD, 0x5D, 0xAE, 0xB7, 0x78, 0x3A, 0x6B, 0x8D, + 0x22, 0xA2, 0x0A, 0x9B, 0xB3, 0x8C, 0x81, 0xFA, + 0x36, 0x56, 0xBE, 0xEA, 0x71, 0x65, 0x70, 0xCC, + 0xB9, 0xA4, 0x78, 0x47, 0x52, 0xB2, 0xC0, 0x7C + }, + { + 0xB3, 0x58, 0x9A, 0x07, 0xDB, 0x52, 0xAC, 0xD8, + 0x9B, 0xC3, 0xED, 0x05, 0x31, 0xCC, 0x8B, 0x92, + 0x39, 0x54, 0x9C, 0xBC, 0xA8, 0xC7, 0x3B, 0x4D, + 0x8F, 0x71, 0x60, 0x17, 0x15, 0x49, 0xF4, 0x28, + 0x90, 0xA9, 0xF7, 0x35, 0x5A, 0xF7, 0x6C, 0x60, + 0xBD, 0x04, 0x0E, 0xAF, 0x9B, 0x5B, 0x2B, 0x8F, + 0xF8, 0x7F, 0x0D, 0x70, 0x7A, 0x8B, 0x6D, 0xA9, + 0x41, 0x1D, 0x3F, 0xF5, 0x13, 0xE0, 0x7F, 0xAD + }, + { + 0x91, 0xD3, 0x88, 0x1E, 0x78, 0xA8, 0x00, 0x56, + 0x71, 0xC2, 0xDC, 0x39, 0x71, 0xFD, 0x17, 0x51, + 0xAE, 0x50, 0xCF, 0xD4, 0x49, 0x6D, 0xA4, 0xBF, + 0x42, 0xCF, 0x1D, 0x81, 0x7A, 0xF8, 0x8A, 0xFB, + 0xC9, 0x3F, 0x8D, 0x8B, 0x7F, 0xAB, 0x3D, 0x1A, + 0x7C, 0x15, 0xBD, 0x5F, 0xF9, 0x2C, 0x62, 0x33, + 0xA0, 0x8C, 0xAB, 0xF8, 0x43, 0x10, 0x63, 0xB2, + 0x8D, 0x08, 0x5A, 0x74, 0x19, 0xFB, 0xD3, 0xCF + }, + { + 0xCA, 0x10, 0x8A, 0x94, 0xA8, 0x21, 0x7D, 0x53, + 0x24, 0x1B, 0x17, 0x5A, 0x0F, 0x84, 0xA5, 0x25, + 0xDD, 0x8B, 0x1F, 0xFA, 0xEA, 0x25, 0xB5, 0xC8, + 0xBC, 0x22, 0xAE, 0xDA, 0x34, 0x9B, 0x08, 0x74, + 0xEA, 0x5A, 0x1E, 0xEA, 0x68, 0xFB, 0x02, 0x93, + 0xF7, 0x32, 0xFD, 0x60, 0x73, 0xC6, 0x30, 0x6E, + 0xE4, 0xB4, 0x2F, 0x43, 0xD1, 0x1F, 0x2D, 0xFE, + 0x11, 0x56, 0xFB, 0x67, 0x82, 0x5B, 0x6F, 0xDA + }, + { + 0xD2, 0x7F, 0xA4, 0x54, 0x7B, 0x5B, 0xD6, 0x30, + 0xF5, 0x53, 0xA6, 0xA0, 0xAA, 0x3F, 0x00, 0xD5, + 0x63, 0x8F, 0x77, 0xFD, 0x9A, 0x69, 0xF3, 0x22, + 0x24, 0x73, 0xFD, 0xF1, 0xC6, 0xDE, 0x48, 0xFC, + 0x3C, 0x43, 0xAA, 0xA4, 0xF5, 0xCF, 0x18, 0xED, + 0x08, 0xC6, 0xF5, 0x61, 0x3B, 0xF3, 0x1E, 0x00, + 0x67, 0x1B, 0x5D, 0xFA, 0xC0, 0x77, 0x9A, 0x1C, + 0xE6, 0xCE, 0x7C, 0xB8, 0xA3, 0xAC, 0x7A, 0x99 + }, + { + 0xAE, 0xC5, 0x45, 0x55, 0x0C, 0xE9, 0xA8, 0x8D, + 0x33, 0xD0, 0x51, 0xA8, 0x39, 0xCB, 0x91, 0x6E, + 0x76, 0xF2, 0xAA, 0x75, 0x17, 0xD5, 0x1F, 0x6B, + 0x3F, 0xAC, 0xE6, 0x76, 0xCC, 0x57, 0xEB, 0xE9, + 0x2F, 0x34, 0x3D, 0x86, 0x5C, 0x6C, 0x04, 0x3A, + 0xD4, 0xDB, 0x58, 0x2D, 0x9C, 0xBB, 0xD2, 0x0B, + 0x06, 0xC4, 0x8A, 0x43, 0x80, 0xBF, 0xFE, 0x2B, + 0xD4, 0xAC, 0x95, 0xAA, 0xCF, 0xC7, 0x85, 0x55 + }, + { + 0x29, 0x1C, 0x16, 0x2B, 0x44, 0x95, 0x33, 0xFA, + 0x79, 0x31, 0x67, 0x67, 0xBC, 0xAA, 0x6C, 0xD0, + 0x05, 0x0D, 0x87, 0x74, 0x98, 0xE7, 0x17, 0x43, + 0x32, 0x6D, 0x92, 0xC6, 0x96, 0xA1, 0xF2, 0x2F, + 0x80, 0x61, 0x14, 0x8E, 0xA2, 0xD2, 0x02, 0xCE, + 0x8A, 0x72, 0x48, 0xBD, 0x64, 0xD1, 0x49, 0x8E, + 0xDD, 0x1A, 0xDD, 0x47, 0x21, 0x81, 0x5E, 0xA4, + 0xE7, 0xE5, 0x28, 0x88, 0xB9, 0xF5, 0xFA, 0x32 + }, + { + 0x38, 0xEF, 0x26, 0x3C, 0x42, 0x9B, 0x0E, 0xE8, + 0x2C, 0x24, 0x21, 0x59, 0x2D, 0x96, 0x97, 0x58, + 0x0A, 0xC6, 0xDC, 0x66, 0x9F, 0x7A, 0x07, 0x3A, + 0x2D, 0xEB, 0x66, 0x7B, 0xB2, 0x4D, 0xC2, 0x85, + 0x95, 0x1A, 0x8B, 0xA1, 0x99, 0xC4, 0x66, 0xF8, + 0x5D, 0x7A, 0x7E, 0x84, 0xEF, 0x50, 0xA5, 0xA0, + 0xC5, 0xBB, 0xBF, 0x8C, 0xF9, 0xF1, 0x87, 0x2D, + 0xAB, 0x7B, 0x5B, 0xA4, 0x16, 0x41, 0x63, 0x49 + }, + { + 0xA9, 0x5C, 0xA0, 0x72, 0x79, 0x01, 0x49, 0x5F, + 0xCA, 0x57, 0x1A, 0xBD, 0xEB, 0xCC, 0x0F, 0xA8, + 0x8B, 0xED, 0x05, 0xAE, 0xA0, 0xED, 0x9F, 0x7B, + 0x43, 0x7E, 0xDF, 0x9B, 0x24, 0xAD, 0xC6, 0x50, + 0xD6, 0xE1, 0x27, 0x9D, 0x9D, 0x46, 0xDB, 0x52, + 0xFE, 0x21, 0x89, 0x7A, 0xE3, 0x9C, 0x3A, 0xCA, + 0x99, 0xC8, 0xA0, 0xE7, 0x73, 0x95, 0x06, 0x31, + 0xCC, 0x12, 0xCA, 0xC6, 0x14, 0xF5, 0xED, 0xF3 + }, + { + 0xC7, 0x0C, 0xFF, 0x82, 0x95, 0xEB, 0xFE, 0x37, + 0x2D, 0x32, 0xE6, 0xEA, 0x24, 0x9C, 0x0E, 0x14, + 0xA1, 0xAB, 0x1A, 0x49, 0xFD, 0x74, 0x90, 0x1A, + 0xD9, 0xE7, 0x65, 0x36, 0xE0, 0x1F, 0x25, 0xD4, + 0x5D, 0x9C, 0x1A, 0x93, 0x0D, 0xAE, 0xDA, 0x4F, + 0x63, 0x5C, 0xAA, 0xBA, 0xDA, 0x56, 0x13, 0x80, + 0x5E, 0x6C, 0xDB, 0x43, 0x0A, 0xB5, 0x5D, 0x9E, + 0x88, 0x2D, 0xFA, 0xA9, 0x68, 0x7C, 0xF6, 0x7C + }, + { + 0xFC, 0x88, 0xBB, 0xEB, 0xC9, 0xF3, 0xDA, 0x3A, + 0xBC, 0x74, 0xF7, 0xB2, 0x8E, 0xB9, 0x01, 0x48, + 0x39, 0x9F, 0x6D, 0xC4, 0x43, 0xCF, 0x0E, 0x6E, + 0x1A, 0xEC, 0xE2, 0x5F, 0x99, 0x2B, 0x77, 0x6D, + 0xE2, 0xAA, 0xA8, 0xA6, 0x78, 0xCB, 0xAE, 0xE6, + 0xED, 0x00, 0x7B, 0x32, 0x37, 0xEB, 0xF9, 0x29, + 0xD6, 0xFF, 0x2A, 0x97, 0xF2, 0x5C, 0x6D, 0x87, + 0x66, 0x3B, 0x06, 0xF7, 0x4F, 0x6B, 0x87, 0xC0 + }, + { + 0xE5, 0x5D, 0x79, 0x67, 0xC9, 0x97, 0xC6, 0xB6, + 0x69, 0x7C, 0x63, 0x55, 0x2A, 0xD6, 0x6B, 0x9E, + 0x86, 0x1A, 0x39, 0xDF, 0x85, 0xFE, 0x68, 0x46, + 0x4E, 0x6A, 0x36, 0x7D, 0x9F, 0xB6, 0xE3, 0xEF, + 0x0A, 0x7C, 0xF5, 0xDC, 0xAB, 0xE3, 0xE7, 0x3C, + 0x09, 0xFC, 0x01, 0x70, 0x0E, 0xFD, 0x93, 0x5D, + 0xFB, 0x41, 0x9C, 0xC5, 0x35, 0x4D, 0xDB, 0x39, + 0x94, 0x0B, 0x94, 0x23, 0x18, 0x44, 0x81, 0x23 + }, + { + 0x6C, 0x02, 0xE3, 0xBB, 0x6B, 0xEA, 0x55, 0x34, + 0xC8, 0x7A, 0x99, 0x50, 0x8A, 0xE4, 0xA9, 0x35, + 0x1E, 0x06, 0x1D, 0x72, 0xE8, 0xC3, 0x94, 0xE6, + 0xA5, 0xD6, 0x55, 0xE0, 0x07, 0xF2, 0x97, 0x09, + 0xE9, 0xF6, 0xC3, 0x73, 0x08, 0xAE, 0xEF, 0x3A, + 0x32, 0x98, 0x71, 0x55, 0x48, 0xFF, 0xA3, 0xBC, + 0x62, 0xE7, 0x22, 0x19, 0x71, 0xF0, 0x0A, 0xA2, + 0x6C, 0x1A, 0x50, 0x23, 0x1D, 0xD9, 0x59, 0x3B + }, + { + 0x57, 0x86, 0x89, 0x71, 0xB2, 0x62, 0xEA, 0xAC, + 0xDE, 0xFA, 0xAD, 0x06, 0xB5, 0x1C, 0xF3, 0xD1, + 0x90, 0x6F, 0x6E, 0x9B, 0x20, 0xD2, 0x17, 0x3A, + 0x77, 0x9F, 0x79, 0x32, 0x3D, 0x85, 0x22, 0xFF, + 0x1C, 0x70, 0x49, 0x39, 0x6C, 0x4A, 0x95, 0x18, + 0x1D, 0x31, 0xCE, 0x32, 0x87, 0x50, 0xE7, 0xD9, + 0xAC, 0x90, 0x2C, 0xB0, 0x70, 0x5D, 0x98, 0x90, + 0x21, 0x09, 0x0E, 0xF7, 0x01, 0xA7, 0x92, 0x44 + }, + { + 0xC6, 0xDD, 0xE3, 0x7D, 0x48, 0xE7, 0xCD, 0xB3, + 0x79, 0x65, 0x07, 0x4C, 0x1D, 0xCC, 0xDD, 0x4E, + 0x67, 0x6A, 0xD2, 0x2F, 0x7B, 0x31, 0xE0, 0xDC, + 0xFF, 0xA8, 0x02, 0x3B, 0x29, 0xE4, 0x7C, 0x78, + 0xCC, 0x6F, 0x53, 0x2E, 0x36, 0xF8, 0x6A, 0x5D, + 0xDB, 0xA8, 0xFD, 0xDF, 0xBB, 0x9E, 0xDB, 0xD3, + 0x20, 0x33, 0x2E, 0x21, 0x99, 0xB2, 0x5E, 0x1E, + 0x64, 0xB6, 0x1E, 0xA8, 0xBE, 0xCA, 0xE9, 0x09 + }, + { + 0x1D, 0xDD, 0xE1, 0x63, 0x63, 0x0E, 0x85, 0xA1, + 0x40, 0x15, 0x31, 0x7E, 0xFC, 0xF2, 0x33, 0xDE, + 0x0C, 0xEC, 0x09, 0x6A, 0x56, 0xB3, 0xA5, 0x98, + 0x49, 0x5B, 0xCA, 0xB2, 0xD7, 0x93, 0x04, 0x43, + 0x52, 0x9D, 0xF9, 0xF4, 0x6E, 0x36, 0x9A, 0x13, + 0xA8, 0x19, 0xEF, 0x3C, 0x47, 0xBE, 0xB4, 0x1E, + 0x01, 0x3C, 0xFA, 0xEE, 0x3E, 0x19, 0xE4, 0x5B, + 0x35, 0xCE, 0xB7, 0x0F, 0x7D, 0xC9, 0xB9, 0x46 + }, + { + 0x18, 0x7F, 0x78, 0x69, 0xFF, 0x41, 0x65, 0xC9, + 0xC8, 0xC0, 0xA6, 0x0F, 0x23, 0xB9, 0x21, 0x9D, + 0x77, 0x82, 0x74, 0x85, 0xC4, 0x78, 0xA0, 0x43, + 0xCC, 0x86, 0x7B, 0xCD, 0xE2, 0xC6, 0xBF, 0xBB, + 0x04, 0x1A, 0x2B, 0x55, 0x0F, 0xAE, 0xB8, 0x6D, + 0xB8, 0x3B, 0xD1, 0x52, 0x77, 0x97, 0xDE, 0x4E, + 0x0C, 0x37, 0x09, 0x22, 0x74, 0x0A, 0x48, 0xEC, + 0x8A, 0x3D, 0xDC, 0xEE, 0x77, 0xBF, 0x73, 0x4B + }, + { + 0x66, 0xBE, 0x82, 0x2C, 0x3A, 0xB7, 0xE4, 0xF4, + 0xB3, 0xF2, 0x98, 0x98, 0x9A, 0x79, 0x7F, 0x53, + 0x83, 0x43, 0x99, 0x32, 0x49, 0x81, 0xBD, 0x6C, + 0xB2, 0x00, 0x4A, 0xF7, 0xC2, 0x80, 0x0E, 0xBC, + 0xB3, 0x95, 0xA3, 0xA9, 0x51, 0x2B, 0x9D, 0x81, + 0x26, 0x4B, 0xA8, 0xE3, 0x78, 0xC2, 0x92, 0x02, + 0x6F, 0xB9, 0x4B, 0x84, 0x10, 0xBD, 0x51, 0xAC, + 0xA7, 0xCE, 0xAF, 0x28, 0x7A, 0xCE, 0x41, 0x82 + }, + { + 0x36, 0x39, 0x97, 0x88, 0xF2, 0x10, 0x01, 0x64, + 0xD5, 0xC8, 0x5E, 0xF7, 0x19, 0xFA, 0x7F, 0xE5, + 0x85, 0x22, 0x4E, 0x9A, 0xA6, 0x23, 0x13, 0x25, + 0xB3, 0x92, 0x48, 0xCC, 0x31, 0x8E, 0x7E, 0xEA, + 0x08, 0x9E, 0x94, 0x52, 0xDF, 0x2F, 0x02, 0xC3, + 0xCD, 0xC8, 0xDF, 0x49, 0xF8, 0x28, 0x2A, 0x1E, + 0x45, 0x16, 0x53, 0x81, 0x31, 0x67, 0x8D, 0x15, + 0x8E, 0x06, 0xD8, 0xDA, 0x9D, 0x52, 0x73, 0x9E + }, + { + 0xC2, 0xC5, 0x9D, 0x45, 0x0B, 0x77, 0xDF, 0xBA, + 0xC0, 0x20, 0xBA, 0xE4, 0xBA, 0xC8, 0x42, 0xDE, + 0xC5, 0x26, 0x78, 0xF8, 0x26, 0xB3, 0x24, 0x2F, + 0xD3, 0xA8, 0x25, 0x79, 0x8C, 0x18, 0xB2, 0xDA, + 0xD5, 0x12, 0x59, 0xA1, 0x12, 0xD6, 0x4C, 0x76, + 0xC8, 0x99, 0x7D, 0x0C, 0x25, 0xA1, 0xAA, 0xC2, + 0x73, 0x90, 0x5C, 0x88, 0x86, 0x72, 0x9D, 0x4B, + 0xDE, 0x2B, 0x78, 0xAB, 0x00, 0xD6, 0xA7, 0x65 + }, + { + 0x95, 0x03, 0x28, 0x7B, 0x43, 0x84, 0x3F, 0xDE, + 0x95, 0x87, 0xAE, 0x29, 0x15, 0x8F, 0x35, 0x8A, + 0xB1, 0xC2, 0x13, 0x9A, 0x0B, 0x94, 0xAA, 0x15, + 0x9B, 0x38, 0x68, 0xAF, 0x06, 0x07, 0xB5, 0x9C, + 0xD2, 0xDC, 0x08, 0x3A, 0x05, 0xB8, 0xF9, 0x70, + 0x1F, 0x58, 0x77, 0x3F, 0xAE, 0x61, 0xFE, 0xD1, + 0x8E, 0x7D, 0x43, 0xEE, 0xC9, 0x04, 0xB8, 0xB9, + 0x9B, 0xE4, 0x73, 0x88, 0x55, 0xA6, 0xF5, 0x8F + }, + { + 0xC2, 0x39, 0x1E, 0x71, 0x02, 0xA2, 0xEF, 0x3C, + 0x99, 0x75, 0xFD, 0xE5, 0x1B, 0x5B, 0xA2, 0x0F, + 0x85, 0x7E, 0x69, 0x70, 0x31, 0x59, 0x34, 0x77, + 0x92, 0xE9, 0xF6, 0x70, 0xE3, 0x3F, 0xD6, 0xD1, + 0xE1, 0x1D, 0x91, 0x00, 0x81, 0x4D, 0x76, 0x3E, + 0xC7, 0xD7, 0x60, 0x14, 0x33, 0x1F, 0x2B, 0x1F, + 0x1F, 0xB2, 0xAC, 0x25, 0x6A, 0x35, 0x3E, 0x58, + 0x86, 0xDC, 0xCB, 0x63, 0x03, 0x7C, 0x1B, 0x3D + }, + { + 0x85, 0x89, 0x54, 0x3F, 0xFE, 0x22, 0x48, 0x69, + 0x7B, 0x39, 0x80, 0x16, 0x56, 0x23, 0xE9, 0xD5, + 0x18, 0xB8, 0x4B, 0x6D, 0x7C, 0x52, 0xC5, 0x8E, + 0xD5, 0x92, 0x40, 0x94, 0x94, 0x1B, 0x6C, 0xD7, + 0x35, 0x9B, 0x3A, 0x92, 0x3F, 0x73, 0x8C, 0xAC, + 0x52, 0xD1, 0x06, 0x7E, 0x61, 0xF6, 0xE7, 0x6C, + 0x73, 0x49, 0x4F, 0x96, 0x2D, 0xE9, 0xFC, 0xD1, + 0x13, 0x4F, 0xE8, 0x33, 0x72, 0x5D, 0x48, 0x04 + }, + { + 0x9E, 0x2A, 0x63, 0x11, 0xDB, 0x58, 0x06, 0x13, + 0xC6, 0x72, 0x44, 0x36, 0x0F, 0xC2, 0x29, 0x67, + 0x12, 0x19, 0xB7, 0xDD, 0xFF, 0x9B, 0xC7, 0x78, + 0x37, 0xBF, 0x2F, 0x8B, 0x12, 0xB7, 0x97, 0xA8, + 0x7A, 0xE4, 0x13, 0x77, 0x0C, 0x18, 0x6F, 0xC7, + 0x68, 0xD0, 0x96, 0x8A, 0x7B, 0xFB, 0x81, 0x37, + 0x67, 0x10, 0x1D, 0xE0, 0x89, 0xCC, 0x59, 0x77, + 0x6B, 0xD5, 0xFF, 0x8D, 0xBA, 0x0C, 0x9E, 0x07 + }, + { + 0x53, 0x21, 0x93, 0xB1, 0xC0, 0xF9, 0x10, 0x61, + 0x93, 0x7B, 0x2B, 0x75, 0xDE, 0x1B, 0xF2, 0xDB, + 0x28, 0x39, 0x74, 0x0B, 0x3E, 0x57, 0xD1, 0x11, + 0x2B, 0x8D, 0x72, 0xAE, 0x35, 0xAA, 0x6C, 0x1A, + 0xEA, 0x24, 0xB1, 0x30, 0x6F, 0xDB, 0xF0, 0x14, + 0xF9, 0x71, 0xBB, 0xF1, 0x35, 0xD6, 0xA9, 0x86, + 0x66, 0x18, 0xCC, 0x6F, 0x61, 0xB9, 0xBA, 0x99, + 0x70, 0xDE, 0x45, 0x91, 0x5E, 0x59, 0x75, 0xD9 + }, + { + 0xA0, 0x89, 0x77, 0x18, 0xBB, 0xFF, 0x75, 0x0E, + 0x41, 0x49, 0x29, 0xED, 0x5E, 0x59, 0xF6, 0x8F, + 0x3C, 0x15, 0x37, 0xA7, 0x7A, 0x44, 0x96, 0x4B, + 0xEF, 0x67, 0xCE, 0x0D, 0xE3, 0xFB, 0xA9, 0xAC, + 0x70, 0xB9, 0x2B, 0xEA, 0x73, 0x60, 0xC9, 0xE0, + 0x31, 0x6B, 0x4F, 0xF3, 0x0E, 0x5B, 0xDA, 0x21, + 0x9A, 0xE7, 0x6C, 0x64, 0x20, 0xEF, 0x14, 0xE7, + 0x4D, 0x99, 0x52, 0xD1, 0xFD, 0x17, 0x4A, 0x6B + }, + { + 0x88, 0xDD, 0x60, 0xB3, 0x61, 0xCC, 0x8D, 0xE0, + 0x74, 0xE2, 0xB8, 0x89, 0x3A, 0xAF, 0x5C, 0x95, + 0xAB, 0xEB, 0xF1, 0x0D, 0x03, 0xD7, 0xC3, 0x76, + 0x62, 0xF8, 0x39, 0x1E, 0xE9, 0xAB, 0x72, 0xFA, + 0x9D, 0xE1, 0x35, 0x08, 0x51, 0x07, 0x17, 0x4C, + 0x6C, 0x24, 0xFF, 0x18, 0x2F, 0x40, 0xBA, 0x35, + 0x43, 0xA8, 0x6A, 0x43, 0x7C, 0x16, 0x77, 0x11, + 0xC7, 0xE5, 0x00, 0xC2, 0x9C, 0x5C, 0x54, 0x4E + }, + { + 0x41, 0x4F, 0x77, 0x07, 0x2D, 0x61, 0x46, 0xC6, + 0x96, 0xCA, 0x9B, 0x86, 0xC0, 0x7B, 0x42, 0xF7, + 0xD1, 0xBC, 0x4B, 0x51, 0xD7, 0xD4, 0xA8, 0x06, + 0x22, 0x8A, 0x5B, 0xC5, 0xBC, 0x9A, 0xBC, 0x2A, + 0xC3, 0x1B, 0x59, 0x09, 0x32, 0x7C, 0x18, 0xD8, + 0xE9, 0x6D, 0x88, 0x96, 0xB3, 0x4F, 0x2B, 0xF8, + 0x08, 0xD6, 0xEE, 0x66, 0x37, 0xCD, 0xB6, 0xBF, + 0x42, 0xF8, 0xF9, 0x18, 0x5D, 0x41, 0xA5, 0xD3 + }, + { + 0xC0, 0xB3, 0x67, 0xA1, 0x62, 0x6B, 0x0C, 0xA9, + 0xC9, 0x04, 0x32, 0x96, 0xF9, 0x42, 0xCC, 0x1F, + 0x88, 0xC4, 0x95, 0x1C, 0x3C, 0x16, 0xAD, 0x64, + 0xF9, 0x03, 0x68, 0x6B, 0x35, 0xD1, 0xF9, 0x53, + 0x59, 0x13, 0xEF, 0x16, 0x6A, 0x69, 0xA7, 0x3E, + 0xCE, 0x46, 0x51, 0xD4, 0xFA, 0xFA, 0x0E, 0x98, + 0x13, 0x09, 0x98, 0x64, 0xFE, 0x7E, 0x1D, 0xCF, + 0xD5, 0x18, 0x8A, 0x55, 0x1C, 0x71, 0xD6, 0xF4 + }, + { + 0xFB, 0xC0, 0xA3, 0x5F, 0x36, 0x0D, 0xC0, 0xF4, + 0xC5, 0x42, 0xE4, 0xC9, 0x7F, 0xCD, 0x8D, 0xB7, + 0xCE, 0xEA, 0x83, 0x67, 0x3A, 0x1D, 0x93, 0x3E, + 0x5E, 0x89, 0x6A, 0x46, 0xF3, 0x0F, 0xE4, 0x46, + 0x95, 0x00, 0x60, 0x2D, 0xCD, 0xA0, 0xE3, 0x73, + 0xF0, 0x7D, 0x4B, 0x17, 0xFD, 0xD5, 0x74, 0x01, + 0x8E, 0xA2, 0xD1, 0xE3, 0x31, 0x06, 0x79, 0x51, + 0x97, 0x3E, 0x39, 0xBD, 0xF0, 0xA2, 0x89, 0xBF + }, + { + 0xCF, 0x91, 0x6A, 0x34, 0xB0, 0x06, 0x23, 0xC1, + 0x1E, 0x2D, 0x04, 0xA4, 0x6E, 0xDE, 0xE2, 0xF1, + 0x8F, 0x09, 0x25, 0x01, 0xEF, 0xA1, 0x17, 0x67, + 0xE9, 0xC3, 0x0F, 0xD8, 0x11, 0x7B, 0x6F, 0xBA, + 0xFE, 0x6A, 0x0E, 0x97, 0xED, 0xB4, 0x13, 0xD8, + 0xFE, 0xDC, 0x2C, 0xDB, 0x1D, 0x54, 0xDD, 0x08, + 0x9D, 0x98, 0xA0, 0xFB, 0xB8, 0x92, 0xD2, 0x17, + 0x20, 0x8D, 0xAC, 0x06, 0x80, 0xF0, 0x25, 0x35 + }, + { + 0xE4, 0xE2, 0x92, 0xE5, 0xD2, 0xAB, 0xAE, 0xE1, + 0xE4, 0xBD, 0xA1, 0xA9, 0x42, 0x3D, 0x36, 0x57, + 0xD0, 0x42, 0xBE, 0x73, 0x82, 0xA3, 0xB2, 0x7D, + 0xB7, 0x23, 0xE1, 0x79, 0x93, 0x45, 0xB3, 0x01, + 0xF7, 0x0D, 0x2E, 0xF7, 0x59, 0x47, 0x76, 0xCB, + 0x3D, 0x14, 0x67, 0xEF, 0xEC, 0x6A, 0x00, 0x7C, + 0xFB, 0xC1, 0x69, 0xAC, 0xE6, 0x2B, 0x56, 0x53, + 0x19, 0x24, 0x93, 0x91, 0x0A, 0x1F, 0xD8, 0x20 + }, + { + 0x46, 0x53, 0x32, 0xDF, 0x64, 0x2D, 0x3A, 0x2A, + 0xC6, 0xDD, 0x19, 0xA3, 0xC8, 0x98, 0x07, 0xFE, + 0xCC, 0x1B, 0xBA, 0xBA, 0x0E, 0x44, 0xF9, 0xFB, + 0xCC, 0xC7, 0x0B, 0x81, 0x05, 0xEB, 0xB7, 0x2A, + 0x43, 0x8F, 0x99, 0x7F, 0xD5, 0x1D, 0x1F, 0x02, + 0xAA, 0xE8, 0x40, 0x1B, 0xB7, 0x71, 0x32, 0xE7, + 0x59, 0x32, 0x08, 0xD7, 0x18, 0xAD, 0x89, 0x65, + 0x9F, 0xED, 0x73, 0xAB, 0xCC, 0xF1, 0xC1, 0xAD + }, + { + 0x2E, 0x2D, 0x21, 0x83, 0x21, 0x3B, 0x7A, 0xC4, + 0xE3, 0x68, 0x48, 0x90, 0x3A, 0xC7, 0x76, 0x09, + 0x6E, 0xA7, 0x60, 0x06, 0x8E, 0x31, 0x83, 0x4A, + 0x25, 0x00, 0x3E, 0x40, 0x38, 0x42, 0x2A, 0x84, + 0x22, 0xBC, 0xFC, 0x5A, 0xB8, 0x1B, 0x32, 0x2E, + 0x7D, 0xEA, 0x37, 0xB2, 0x57, 0xA4, 0xB7, 0xF0, + 0x8D, 0x24, 0x5C, 0xE2, 0x18, 0x04, 0xB7, 0xD1, + 0x21, 0x2B, 0x29, 0xF0, 0xB3, 0x4D, 0xF8, 0x89 + }, + { + 0x7D, 0xE5, 0xD6, 0x4C, 0x62, 0x38, 0x55, 0x87, + 0x9F, 0x6B, 0xAC, 0x0C, 0x6C, 0x86, 0xBF, 0xF4, + 0x31, 0x5A, 0x93, 0x49, 0xBE, 0x2F, 0x61, 0x05, + 0x6F, 0x03, 0x9C, 0x4C, 0x0D, 0xA3, 0x8C, 0x1D, + 0x95, 0xCB, 0x2E, 0x40, 0x28, 0x2B, 0x3C, 0x92, + 0x3B, 0x86, 0xC8, 0xCA, 0x77, 0xF5, 0x2C, 0xDC, + 0xF2, 0x14, 0x8B, 0x88, 0x75, 0xDB, 0x1A, 0x95, + 0x88, 0xC8, 0x06, 0xA6, 0x46, 0x5B, 0x69, 0xDF + }, + { + 0xDB, 0x2F, 0xE6, 0x40, 0x0E, 0x04, 0x17, 0xBC, + 0x6F, 0xC9, 0xA8, 0xDD, 0x19, 0x4B, 0xB9, 0xE7, + 0x4E, 0xB7, 0x47, 0x7E, 0xA8, 0x98, 0xD2, 0x11, + 0x63, 0xB8, 0x88, 0x51, 0x5B, 0xB4, 0xB9, 0x50, + 0xCD, 0x99, 0xEC, 0x00, 0x7E, 0x62, 0x89, 0x7A, + 0x22, 0xBF, 0x7B, 0x8D, 0xF9, 0x46, 0x56, 0x0F, + 0xF4, 0xC5, 0xBC, 0xCF, 0x98, 0x18, 0x1E, 0xFE, + 0x32, 0x86, 0xD5, 0xC1, 0x7C, 0xA2, 0x9F, 0x6F + }, + { + 0x65, 0xC0, 0x98, 0x97, 0x24, 0xBD, 0x80, 0x54, + 0x34, 0x1D, 0xCF, 0x40, 0x47, 0xE6, 0xB4, 0x1E, + 0x1C, 0xB9, 0xA9, 0x27, 0xDA, 0x7B, 0x0B, 0xDC, + 0xFB, 0x34, 0xCA, 0xBB, 0xC1, 0xC7, 0x56, 0xE4, + 0x98, 0x58, 0xAE, 0xF6, 0x09, 0x78, 0x88, 0x8D, + 0x2A, 0x2D, 0x78, 0xCB, 0x24, 0xF0, 0x80, 0xA5, + 0x86, 0xB7, 0x66, 0xEE, 0x4E, 0xC9, 0x77, 0x50, + 0x36, 0x33, 0x59, 0xFF, 0x72, 0xD9, 0x58, 0x27 + }, + { + 0x41, 0x6C, 0x81, 0x84, 0x4D, 0x2B, 0xE0, 0xA5, + 0x99, 0x9E, 0x62, 0xA1, 0xD6, 0xD5, 0x73, 0x81, + 0x72, 0x46, 0x6C, 0x47, 0x29, 0x4B, 0x51, 0x2C, + 0x26, 0xC2, 0xE6, 0x45, 0x08, 0x45, 0x92, 0xEE, + 0xE8, 0xA9, 0x7F, 0xCB, 0x17, 0x14, 0x84, 0x5D, + 0x58, 0xAF, 0x52, 0x2B, 0xE7, 0x2A, 0x39, 0xE4, + 0xBC, 0x08, 0x3D, 0xC5, 0xF3, 0x8A, 0x62, 0x2A, + 0xC0, 0x54, 0x22, 0xA1, 0xFA, 0x30, 0xC7, 0xFE + }, + { + 0x8C, 0xEA, 0x45, 0x0E, 0x4F, 0x51, 0x80, 0xE8, + 0xED, 0x96, 0xA8, 0x6A, 0x59, 0xCB, 0x95, 0x42, + 0x30, 0x08, 0xB4, 0x89, 0x87, 0xE3, 0x30, 0x72, + 0x77, 0xC7, 0x04, 0x8E, 0xBC, 0x7D, 0x2C, 0xE4, + 0xE8, 0xFF, 0x7B, 0xB2, 0x82, 0x26, 0xB2, 0x0C, + 0x40, 0x03, 0x81, 0xC1, 0xAC, 0x1D, 0x8F, 0x66, + 0x41, 0x7E, 0x02, 0xF5, 0x83, 0x3A, 0xA9, 0xA8, + 0x06, 0x27, 0xC8, 0x82, 0x6A, 0x86, 0x6D, 0x7C + }, + { + 0xA5, 0xB7, 0x83, 0x89, 0xEE, 0x94, 0x7E, 0x30, + 0x41, 0xDF, 0x4A, 0xFB, 0xBA, 0x47, 0x05, 0xD3, + 0x7D, 0x4A, 0xB3, 0x11, 0x56, 0x93, 0xC6, 0x6F, + 0xA0, 0x09, 0x4D, 0xF8, 0x24, 0xE9, 0x06, 0x76, + 0x53, 0x1B, 0xCB, 0xBC, 0x5E, 0xAB, 0x38, 0xFB, + 0x47, 0xE8, 0x0C, 0xF7, 0xEA, 0x98, 0xA7, 0xB4, + 0x54, 0xB0, 0x15, 0x1A, 0x41, 0x9D, 0x23, 0xD0, + 0x60, 0x6F, 0xD1, 0x58, 0x0D, 0xE7, 0xF1, 0x9F + }, + { + 0x4E, 0xB9, 0x97, 0x5E, 0x69, 0x49, 0x81, 0x4F, + 0x18, 0xCA, 0xFA, 0xB1, 0x03, 0x90, 0x99, 0x31, + 0x15, 0x05, 0xC7, 0xCD, 0xF4, 0x8A, 0xB5, 0x64, + 0x38, 0xAA, 0xC5, 0xC7, 0x25, 0xDF, 0x6F, 0x11, + 0xC4, 0x2F, 0x50, 0xB1, 0x88, 0x27, 0x9F, 0xD8, + 0xE8, 0xF4, 0xC5, 0x89, 0x81, 0xE5, 0x22, 0xE5, + 0x0A, 0x5F, 0x90, 0xBB, 0xEC, 0x19, 0x24, 0x38, + 0x3D, 0x0A, 0xDC, 0xCC, 0xB9, 0x3E, 0x70, 0xFA + }, + { + 0x7A, 0x28, 0x30, 0xC8, 0x92, 0x68, 0x0F, 0x79, + 0x93, 0xEB, 0x2A, 0x78, 0xC5, 0x8B, 0x98, 0x21, + 0x22, 0xE4, 0xD9, 0x07, 0xBD, 0x27, 0x35, 0xC6, + 0x5F, 0xF3, 0xEA, 0x8B, 0x6A, 0xA6, 0x0D, 0x99, + 0xD6, 0x25, 0x7B, 0x00, 0x03, 0x5F, 0x56, 0xAD, + 0x62, 0x49, 0x7D, 0x25, 0xFE, 0x62, 0xD4, 0xC3, + 0x48, 0xDF, 0x41, 0x76, 0xA6, 0x0F, 0xB8, 0x8E, + 0xA9, 0x22, 0x34, 0xDA, 0xDE, 0xE7, 0xC3, 0x57 + }, + { + 0xFB, 0xF2, 0x6A, 0x3E, 0x55, 0x57, 0xA5, 0xB4, + 0x32, 0x1B, 0xF9, 0xA0, 0x00, 0xDB, 0xB1, 0xE5, + 0x30, 0xAB, 0x4E, 0x8E, 0x2A, 0xCA, 0x3A, 0x13, + 0xF3, 0x9C, 0xD6, 0x8A, 0xAC, 0x78, 0x75, 0x2A, + 0x14, 0x53, 0x7D, 0x7F, 0x6D, 0xB8, 0xE4, 0x98, + 0xA5, 0x77, 0x7D, 0xB7, 0xDE, 0xC8, 0x09, 0x09, + 0x04, 0x51, 0xC1, 0x97, 0xE5, 0xCC, 0xBE, 0xF4, + 0xF1, 0x99, 0x4E, 0x5E, 0x12, 0x35, 0x99, 0x3D + }, + { + 0x47, 0xEB, 0xC2, 0xF8, 0x2C, 0xF3, 0x47, 0x1C, + 0x7D, 0x66, 0xC4, 0xA8, 0x5C, 0x5C, 0x02, 0x4E, + 0x5E, 0x56, 0x78, 0xD5, 0x0A, 0x58, 0x80, 0x55, + 0x9C, 0x1A, 0x38, 0x60, 0x93, 0xA9, 0x40, 0x15, + 0xB1, 0xE7, 0x53, 0x1A, 0xE0, 0xE0, 0x91, 0x30, + 0xDF, 0x00, 0x35, 0x09, 0xE5, 0xBF, 0xFB, 0xA6, + 0xCF, 0xE8, 0x4B, 0xDA, 0x2C, 0x09, 0x95, 0xD9, + 0xFB, 0xFE, 0x60, 0x32, 0xF2, 0xAB, 0xE8, 0xC1 + }, + { + 0x95, 0x9E, 0xBF, 0xE4, 0x32, 0x80, 0x91, 0xEB, + 0x99, 0x81, 0x58, 0x78, 0xE3, 0xF4, 0x4F, 0xF8, + 0x87, 0x4C, 0x1D, 0x93, 0xD8, 0x32, 0xEE, 0xBE, + 0x58, 0x3B, 0x84, 0x21, 0xE6, 0x5D, 0x2B, 0x0E, + 0x26, 0x95, 0xBD, 0x84, 0x03, 0x57, 0x08, 0xC0, + 0xD7, 0x88, 0x3E, 0xD6, 0x80, 0x52, 0xC6, 0x77, + 0x44, 0x56, 0x1D, 0x5E, 0xA7, 0xFA, 0x59, 0x31, + 0xDB, 0x16, 0x99, 0x6B, 0x40, 0x03, 0x68, 0x20 + }, + { + 0xBE, 0x71, 0x1F, 0xC5, 0x06, 0x54, 0x96, 0x6F, + 0xCD, 0xEE, 0xF6, 0x86, 0x79, 0xFC, 0x90, 0x52, + 0xDA, 0xCA, 0x0D, 0xA8, 0xF0, 0x01, 0xF4, 0x77, + 0x4E, 0x25, 0x88, 0x96, 0x56, 0x63, 0xA6, 0x74, + 0xC6, 0xBE, 0xEA, 0x48, 0xE5, 0x81, 0x40, 0x4B, + 0x5E, 0xB0, 0xDE, 0xC3, 0xEF, 0x74, 0x68, 0x14, + 0xEE, 0x7C, 0x81, 0xE4, 0x46, 0xD9, 0xF6, 0x25, + 0x5A, 0xCB, 0x7D, 0x4B, 0x4C, 0x95, 0x9A, 0x5B + }, + { + 0x8B, 0xD2, 0x3C, 0xBB, 0xE7, 0xFA, 0x7F, 0x36, + 0xC3, 0x00, 0x21, 0x3A, 0x20, 0x63, 0xFB, 0xD6, + 0x47, 0x40, 0x27, 0xA2, 0x0B, 0xD7, 0x9A, 0x0D, + 0xF7, 0x39, 0xA3, 0xAA, 0x92, 0x68, 0xFD, 0x15, + 0x2D, 0xD8, 0x08, 0xB4, 0x4C, 0x36, 0x65, 0x03, + 0xEE, 0x19, 0x90, 0xA0, 0x1C, 0x2A, 0x6D, 0x26, + 0xE9, 0x96, 0xC0, 0x92, 0xB9, 0x50, 0xC1, 0x96, + 0x80, 0x58, 0x80, 0x64, 0x7F, 0xB1, 0x32, 0xBC + }, + { + 0x57, 0x3F, 0xA1, 0x45, 0x7D, 0xAB, 0x3D, 0x5B, + 0x20, 0xB1, 0xCB, 0xD8, 0x8B, 0x9F, 0xAD, 0x2A, + 0x65, 0x7C, 0x01, 0xF3, 0xFE, 0x9A, 0x4F, 0x93, + 0x71, 0xA0, 0x4F, 0x8C, 0xD6, 0x64, 0x47, 0x7F, + 0x65, 0x7C, 0x70, 0x54, 0xE5, 0x7B, 0x50, 0xEA, + 0xB7, 0xF6, 0x6F, 0xF2, 0x05, 0xAD, 0x0A, 0xFF, + 0x9F, 0x5E, 0xEF, 0x75, 0x02, 0xC6, 0x90, 0xA7, + 0x4E, 0x6C, 0x2A, 0x2C, 0x8F, 0x23, 0x8A, 0xAE + }, + { + 0xA2, 0x3B, 0x91, 0xDA, 0xF2, 0x44, 0xCE, 0xC3, + 0x13, 0x08, 0xB6, 0x33, 0x94, 0xAF, 0xCC, 0x1F, + 0xC3, 0xC5, 0x1D, 0x16, 0x73, 0x8D, 0x3B, 0x0B, + 0x1F, 0x0A, 0x45, 0xBE, 0x7E, 0xF3, 0x60, 0x39, + 0xE9, 0x8B, 0x84, 0xBE, 0x90, 0x60, 0x53, 0xFB, + 0x5F, 0x30, 0x57, 0x9E, 0xB6, 0x32, 0xB7, 0x04, + 0xCF, 0x4A, 0x9B, 0x1B, 0x20, 0x4D, 0x98, 0xE4, + 0x14, 0x7E, 0x9D, 0x95, 0x9F, 0xBD, 0xEC, 0x09 + }, + { + 0x0A, 0x4F, 0xFE, 0x46, 0xCD, 0x47, 0x92, 0xC0, + 0xBD, 0x92, 0xFC, 0xDF, 0xDD, 0x09, 0x6A, 0xA6, + 0x38, 0xA2, 0x8A, 0x34, 0xCD, 0x7A, 0xED, 0x3E, + 0xE4, 0x25, 0xED, 0xFB, 0x94, 0xE6, 0x27, 0x26, + 0x73, 0x5D, 0xC8, 0x0E, 0x2C, 0x60, 0xE4, 0x44, + 0x13, 0xE2, 0x72, 0xD6, 0x0F, 0x5A, 0x62, 0x42, + 0x9D, 0x4F, 0x03, 0xCC, 0xD0, 0x1F, 0xDB, 0xDB, + 0x11, 0x0F, 0x9E, 0x79, 0x1D, 0x70, 0x50, 0x10 + }, + { + 0x91, 0x27, 0xEE, 0xD6, 0x01, 0xAD, 0x7C, 0x10, + 0x18, 0xB9, 0x55, 0x14, 0x03, 0xB0, 0x52, 0x3E, + 0xEE, 0x28, 0xF7, 0xEF, 0x73, 0x44, 0xBA, 0x28, + 0x76, 0x57, 0xEC, 0x85, 0x2E, 0x28, 0xEC, 0x84, + 0xD9, 0x51, 0xAF, 0x5E, 0x3D, 0x7B, 0x45, 0xA7, + 0x18, 0x31, 0x02, 0xD4, 0x18, 0x94, 0xF3, 0x53, + 0xE4, 0x24, 0x6F, 0x23, 0x4F, 0x27, 0x6E, 0xC1, + 0x92, 0x30, 0xE2, 0x15, 0x0D, 0x5F, 0x2C, 0xFC + }, + { + 0x9F, 0x46, 0xCA, 0x29, 0x08, 0xED, 0x88, 0x09, + 0x1E, 0x95, 0x33, 0x78, 0x78, 0x07, 0x14, 0xB1, + 0x74, 0x5D, 0x72, 0x54, 0x0A, 0x6D, 0xA8, 0xE2, + 0xF0, 0xD9, 0x3B, 0x39, 0xA8, 0x3E, 0x29, 0x62, + 0x2F, 0x56, 0xAE, 0xC3, 0xE2, 0x4E, 0x85, 0xDD, + 0x7B, 0xC5, 0xFC, 0x2E, 0xBA, 0x93, 0xA3, 0xF4, + 0x90, 0xBC, 0xB4, 0x0D, 0xD5, 0xB0, 0xBB, 0xA2, + 0x6F, 0xF7, 0x1A, 0x2A, 0x58, 0xCD, 0x36, 0xEE + }, + { + 0xD0, 0xD6, 0x03, 0x88, 0x76, 0x16, 0xBA, 0xC4, + 0x2E, 0x5D, 0x56, 0xED, 0x89, 0xAD, 0x04, 0xF5, + 0x11, 0xF2, 0x4A, 0x61, 0x0A, 0xA6, 0xC1, 0x10, + 0xFB, 0x28, 0x99, 0x1E, 0x18, 0x56, 0xEF, 0x8B, + 0x20, 0x02, 0x69, 0xAE, 0x00, 0x2C, 0x58, 0x91, + 0x7F, 0x37, 0x8D, 0xA4, 0x43, 0x7F, 0x6B, 0xE5, + 0xF0, 0xD9, 0xE8, 0xFD, 0x9C, 0x73, 0x02, 0x39, + 0x12, 0x86, 0x0C, 0x50, 0xDA, 0x0C, 0x95, 0x78 + }, + { + 0xF8, 0x81, 0xCB, 0xD7, 0x64, 0x4E, 0xCB, 0x5D, + 0xF1, 0xE4, 0xD9, 0x36, 0xDA, 0xF2, 0xF2, 0x95, + 0xCB, 0x7F, 0x22, 0x24, 0xC8, 0xBA, 0x25, 0xA5, + 0x34, 0x7B, 0x33, 0x08, 0x0B, 0x25, 0xDA, 0x60, + 0x2F, 0xD6, 0x78, 0xF1, 0xAF, 0xD3, 0x83, 0x2B, + 0xC3, 0xC4, 0x70, 0x49, 0xCB, 0x73, 0xA5, 0x34, + 0x41, 0x46, 0x56, 0xF3, 0xF8, 0xD8, 0x5A, 0xFC, + 0xDF, 0x17, 0xC1, 0xB5, 0xA0, 0x34, 0xE1, 0xF3 + }, + { + 0x36, 0x4D, 0xF2, 0x68, 0x4C, 0x85, 0x5D, 0x59, + 0x30, 0x9B, 0x08, 0x16, 0xCC, 0x66, 0xC7, 0xD0, + 0x9C, 0x26, 0xBF, 0x86, 0xBD, 0xD8, 0x56, 0x67, + 0xBE, 0xFD, 0x79, 0x7B, 0x5D, 0x35, 0x8E, 0xA3, + 0xD2, 0xC8, 0xCF, 0xE4, 0x58, 0xC6, 0xC9, 0x6E, + 0x94, 0xD2, 0xBC, 0x91, 0xE5, 0xD8, 0xAC, 0x50, + 0xC7, 0x22, 0x98, 0x4B, 0x29, 0xB7, 0x7B, 0xAE, + 0x69, 0xD6, 0x22, 0x68, 0x34, 0x21, 0x31, 0xE5 + }, + { + 0x7C, 0xDC, 0x09, 0x17, 0xB0, 0xB9, 0x5F, 0xB6, + 0xC6, 0x02, 0x03, 0x51, 0x72, 0xBB, 0xB1, 0xDC, + 0x7F, 0x2E, 0x21, 0x21, 0xA9, 0x0F, 0xD2, 0x19, + 0x1A, 0xBE, 0x41, 0x79, 0xCB, 0xB7, 0xE9, 0xDE, + 0x59, 0x7D, 0x29, 0x3C, 0x11, 0x35, 0x70, 0x77, + 0x1E, 0x66, 0x5F, 0x91, 0x6E, 0x84, 0x34, 0xF1, + 0x09, 0x4F, 0xDC, 0x4D, 0x2F, 0xF3, 0xA6, 0x11, + 0xCC, 0x56, 0xA2, 0xE1, 0x38, 0x20, 0x7E, 0xEF + }, + { + 0x88, 0x73, 0x10, 0x16, 0x3C, 0xE1, 0x8C, 0x33, + 0xB1, 0xDD, 0xE9, 0xAC, 0x83, 0xEF, 0x81, 0x3A, + 0x9C, 0x0C, 0x91, 0xD5, 0xC4, 0x0B, 0xF7, 0x1F, + 0x13, 0x8E, 0xAF, 0x48, 0xCA, 0x1E, 0x63, 0x4B, + 0x05, 0x33, 0x4A, 0xEE, 0x1F, 0x78, 0xD6, 0x84, + 0x4C, 0x34, 0xD0, 0xC7, 0xA4, 0x83, 0x99, 0x86, + 0x0A, 0xC5, 0xB1, 0xF2, 0x41, 0x28, 0x09, 0xDE, + 0x83, 0x72, 0x28, 0xF2, 0x5F, 0x89, 0x3F, 0x63 + }, + { + 0x65, 0x91, 0x9D, 0x5A, 0x6E, 0xE1, 0xB5, 0xED, + 0x10, 0xB8, 0x5B, 0xBF, 0x98, 0x1B, 0x1A, 0x41, + 0x7B, 0x6C, 0x12, 0x98, 0xB1, 0x67, 0xDB, 0xD8, + 0x3A, 0x56, 0x66, 0xD1, 0xCC, 0x58, 0x87, 0xE3, + 0x5D, 0x2B, 0x5A, 0x49, 0xFE, 0xA9, 0x92, 0xB9, + 0xA2, 0x70, 0x97, 0xB5, 0xC3, 0x7A, 0x92, 0x57, + 0xE0, 0x08, 0xCB, 0x6C, 0x26, 0x60, 0xAC, 0x3A, + 0x00, 0x80, 0xE3, 0x3B, 0x83, 0x5D, 0xC1, 0x44 + }, + { + 0x5A, 0x6B, 0x90, 0x3C, 0x58, 0xEF, 0x47, 0xD1, + 0x35, 0xEF, 0xB1, 0x10, 0xD0, 0xB7, 0x8C, 0x27, + 0xBD, 0x4D, 0xBB, 0xB6, 0x3E, 0xEB, 0x37, 0x6C, + 0xA2, 0xED, 0x49, 0x8A, 0x67, 0x7B, 0x23, 0x23, + 0xD3, 0x9E, 0x11, 0x96, 0x79, 0xD6, 0xF5, 0x8A, + 0x42, 0x2F, 0x9F, 0xFB, 0x61, 0x8F, 0xA1, 0xC2, + 0x47, 0xED, 0x3F, 0xBF, 0xFF, 0x9F, 0xB3, 0xC0, + 0x6F, 0x09, 0xD2, 0xE9, 0x18, 0x7A, 0xD1, 0xAB + }, + { + 0x57, 0x88, 0xEB, 0x8B, 0xEB, 0x56, 0x15, 0x58, + 0x2F, 0x66, 0xC2, 0xBF, 0x4D, 0xA0, 0xCA, 0x74, + 0xB8, 0x26, 0x67, 0x0C, 0xCE, 0xFB, 0xC4, 0xF2, + 0x43, 0x36, 0xA7, 0x28, 0x22, 0x09, 0x3C, 0xB0, + 0x88, 0xB2, 0xEF, 0x3B, 0xDF, 0x1D, 0xC7, 0xA3, + 0x6E, 0xE1, 0xF7, 0x24, 0xD5, 0x3D, 0x2D, 0x77, + 0xAF, 0xEB, 0x05, 0x52, 0x9A, 0x75, 0x69, 0x95, + 0x82, 0xD5, 0x29, 0xC6, 0x19, 0x36, 0x39, 0x70 + }, + { + 0xE8, 0x54, 0xE8, 0x7D, 0xC3, 0x1B, 0x33, 0x79, + 0x9F, 0x9F, 0x0C, 0xA0, 0x55, 0x79, 0xEA, 0xD0, + 0x67, 0x9E, 0xF7, 0x56, 0x77, 0x79, 0x1D, 0x92, + 0x60, 0x8E, 0xF9, 0x84, 0x99, 0xA2, 0x7D, 0x2B, + 0x94, 0x52, 0xFA, 0xD6, 0xA4, 0x49, 0x60, 0x9D, + 0x25, 0x89, 0x5C, 0xE0, 0x32, 0x73, 0x93, 0xE3, + 0x7A, 0xB4, 0x02, 0x35, 0xB6, 0x16, 0xEB, 0xCC, + 0x8B, 0xA9, 0x16, 0xEB, 0x9E, 0xDB, 0x94, 0x53 + }, + { + 0x3E, 0xF5, 0xE1, 0x5A, 0x8F, 0xF2, 0xAE, 0xF6, + 0xA3, 0xF2, 0xF9, 0x8F, 0xED, 0x4D, 0x6A, 0x39, + 0x5E, 0xDD, 0x7E, 0x54, 0x98, 0x45, 0x52, 0xB9, + 0xC3, 0x53, 0xA9, 0xE1, 0x70, 0x75, 0xA1, 0x84, + 0x83, 0x57, 0xC8, 0x9F, 0x55, 0xE9, 0x9B, 0x90, + 0x67, 0x19, 0xB5, 0x18, 0x38, 0x5B, 0xD2, 0xED, + 0xF6, 0x05, 0x33, 0xAD, 0xFD, 0x43, 0x69, 0xD6, + 0xF1, 0x5C, 0x3A, 0x7C, 0xC1, 0xE0, 0xAB, 0x8A + }, + { + 0x5F, 0x39, 0x3B, 0xAC, 0x4B, 0x33, 0xF9, 0x41, + 0x95, 0x65, 0x4F, 0xCB, 0x55, 0x43, 0xE2, 0x2B, + 0x96, 0x47, 0x5C, 0xB9, 0xB8, 0x6B, 0x99, 0x95, + 0x80, 0x62, 0x95, 0x17, 0x01, 0xE1, 0x74, 0xD5, + 0x40, 0x32, 0x56, 0x8F, 0xE9, 0x04, 0x89, 0x92, + 0xEE, 0x4C, 0x28, 0x5A, 0xAF, 0x21, 0x23, 0xC1, + 0xC4, 0x6F, 0x32, 0x21, 0x01, 0xA9, 0xCD, 0xB4, + 0x6C, 0xE3, 0x6A, 0xDD, 0xAB, 0x9C, 0xBC, 0x72 + }, + { + 0xB7, 0x92, 0x9A, 0x45, 0xB3, 0xDD, 0xA8, 0xD5, + 0xB5, 0x6A, 0x46, 0x02, 0x2C, 0xAB, 0x29, 0xDF, + 0xD6, 0x9C, 0xC4, 0x6A, 0xDC, 0x63, 0x2F, 0x6B, + 0x7A, 0xC2, 0x13, 0x96, 0x97, 0x03, 0x8A, 0x9D, + 0xB3, 0xF0, 0x06, 0xC7, 0x91, 0x5E, 0xA7, 0x1B, + 0x0B, 0x63, 0xE7, 0x79, 0x0A, 0x39, 0xCD, 0x96, + 0x95, 0xE6, 0x3B, 0x8A, 0xA4, 0xB8, 0x1B, 0xF7, + 0x31, 0xF9, 0xC4, 0x1F, 0x06, 0x40, 0x2C, 0x2D + }, + { + 0x8A, 0xBF, 0xD7, 0x42, 0xBA, 0xB1, 0x4B, 0x24, + 0x83, 0x78, 0x9E, 0xBE, 0xAE, 0x4E, 0x19, 0xCC, + 0xDF, 0x3D, 0xC9, 0x8E, 0x64, 0x1F, 0xA6, 0xA3, + 0x05, 0x63, 0x3F, 0x32, 0x55, 0x37, 0x2F, 0x12, + 0x94, 0x58, 0x25, 0xD7, 0xA5, 0x28, 0xE0, 0xC3, + 0x0C, 0x3D, 0x25, 0x7D, 0x41, 0x20, 0x7B, 0xD9, + 0xCA, 0x4E, 0xC4, 0xCB, 0x4E, 0xA6, 0x5F, 0x71, + 0xC7, 0x3F, 0x38, 0x27, 0xC2, 0x45, 0x8B, 0x8C + }, + { + 0x70, 0x44, 0xB1, 0xC4, 0x6D, 0x7C, 0x85, 0xCE, + 0x35, 0xC1, 0xF9, 0x7A, 0xF3, 0x99, 0x0F, 0x67, + 0x6F, 0xA9, 0x0D, 0xC3, 0xF8, 0x3C, 0xCB, 0xE3, + 0x6B, 0x15, 0x71, 0x50, 0x73, 0x14, 0xF4, 0xD4, + 0x8A, 0x9A, 0xAD, 0xCB, 0x05, 0x96, 0x65, 0x66, + 0x90, 0x11, 0x65, 0x8A, 0x8B, 0x1F, 0x79, 0x5D, + 0x71, 0x6F, 0x2B, 0x2A, 0x27, 0xEE, 0xEF, 0xE8, + 0x6A, 0x99, 0x4A, 0x32, 0x09, 0x69, 0x8D, 0xC6 + }, + { + 0x95, 0xAC, 0x37, 0x36, 0xD8, 0x18, 0x81, 0x12, + 0xAF, 0xF2, 0xA1, 0xC5, 0xA3, 0x1A, 0xCD, 0x09, + 0x40, 0x06, 0xD6, 0xDD, 0x5D, 0xC7, 0x65, 0xE8, + 0xAF, 0x23, 0xAE, 0x9C, 0x26, 0x58, 0x97, 0x6E, + 0x0F, 0xFF, 0x0E, 0x67, 0xC5, 0xD2, 0x7A, 0xB1, + 0xC7, 0xB5, 0x2B, 0x96, 0x4F, 0xD4, 0xAC, 0x93, + 0x5E, 0x63, 0xC1, 0x76, 0x05, 0xC0, 0xDA, 0xA1, + 0xCB, 0x85, 0x95, 0xB9, 0xA4, 0x2C, 0xE8, 0x63 + }, + { + 0xD8, 0xA3, 0x43, 0x2E, 0x6C, 0xE8, 0x1B, 0xFE, + 0xF2, 0x0D, 0x86, 0x37, 0x1F, 0xB9, 0x66, 0xFA, + 0x7A, 0xF6, 0xAC, 0x1E, 0x03, 0x03, 0xC0, 0xB9, + 0x42, 0x1C, 0x95, 0x36, 0xBA, 0x19, 0x8A, 0x9D, + 0x80, 0xF5, 0x58, 0x45, 0xC4, 0xE7, 0x5A, 0xB8, + 0xAB, 0x16, 0x28, 0x13, 0x1D, 0xBD, 0x52, 0xE7, + 0xB5, 0x64, 0x81, 0x1D, 0x50, 0x4B, 0xEE, 0xED, + 0xC4, 0x88, 0x1D, 0xAD, 0x8B, 0x6B, 0x01, 0x28 + }, + { + 0x9E, 0x8B, 0x79, 0xC8, 0x39, 0xB1, 0x7F, 0x6F, + 0xF4, 0xE3, 0x24, 0xD0, 0xF5, 0xFA, 0xCC, 0xB2, + 0x0F, 0x7A, 0x33, 0x4B, 0x33, 0x34, 0xD5, 0x33, + 0x20, 0xB7, 0x56, 0xBA, 0x4E, 0x7B, 0x8D, 0x00, + 0x54, 0x6D, 0xFC, 0xF0, 0xCC, 0x8A, 0xC0, 0x27, + 0x15, 0xEC, 0x9A, 0x20, 0x0A, 0xEB, 0x7E, 0x1D, + 0x9E, 0x3C, 0xF3, 0x1E, 0xEA, 0x56, 0xAA, 0xEA, + 0x26, 0x7F, 0x0A, 0xBA, 0xD3, 0xAD, 0x4C, 0x74 + }, + { + 0x81, 0x53, 0x02, 0x9A, 0xFD, 0x59, 0x80, 0xB8, + 0x22, 0xD5, 0x39, 0x58, 0xAF, 0xB1, 0x3D, 0x6F, + 0x3F, 0x7F, 0xD8, 0xB7, 0x5B, 0xE5, 0x0D, 0x32, + 0x3D, 0xC8, 0x9F, 0x5B, 0x13, 0x4F, 0x01, 0xD1, + 0x90, 0x9A, 0xA8, 0x81, 0x5D, 0x90, 0x83, 0x49, + 0x06, 0xA6, 0xC2, 0x04, 0x6C, 0xAF, 0x25, 0xEF, + 0x45, 0xB0, 0xA0, 0xD8, 0x53, 0x50, 0xDA, 0xC9, + 0x92, 0x18, 0x2C, 0xEF, 0x05, 0x57, 0xB3, 0xC3 + }, + { + 0xF6, 0x7F, 0x43, 0x9A, 0xCA, 0xCE, 0x59, 0xD3, + 0x1F, 0xAC, 0x73, 0xEA, 0xBC, 0x04, 0xBC, 0x65, + 0xBF, 0x06, 0xD9, 0x39, 0x4C, 0x63, 0xA4, 0xCB, + 0x9F, 0xDC, 0xA4, 0xA7, 0x70, 0x82, 0x67, 0xDD, + 0xF2, 0xF3, 0x42, 0x77, 0x2F, 0x91, 0xF7, 0x61, + 0x03, 0x4C, 0x3A, 0x85, 0x7F, 0x14, 0x3E, 0x47, + 0xF0, 0x3F, 0x4A, 0x6D, 0xAD, 0x7E, 0x59, 0x70, + 0xC6, 0x0A, 0xAB, 0x09, 0xD4, 0x5D, 0xA7, 0xFD + }, + { + 0x3E, 0x85, 0x70, 0xC1, 0xEA, 0xAD, 0x7D, 0x12, + 0x83, 0x8B, 0xC4, 0x19, 0x43, 0x21, 0x44, 0xFB, + 0x65, 0xE5, 0xE1, 0x7D, 0xEE, 0x85, 0x89, 0xA2, + 0xE5, 0x60, 0x4B, 0x95, 0x61, 0xB7, 0x86, 0x18, + 0x8E, 0x47, 0x73, 0x1A, 0xBE, 0x5E, 0x19, 0xA4, + 0x3F, 0x77, 0xD6, 0x33, 0x3F, 0x11, 0x2B, 0x51, + 0x01, 0xDB, 0x13, 0x3D, 0x9D, 0xD8, 0x21, 0xA0, + 0xEA, 0xCC, 0x04, 0x78, 0x93, 0x72, 0x1F, 0x82 + }, + { + 0x84, 0x0E, 0x11, 0x87, 0x5F, 0x4E, 0x58, 0x95, + 0x8C, 0xAE, 0x24, 0x0C, 0x42, 0xBB, 0x9E, 0x2E, + 0x9D, 0xD7, 0x37, 0xB3, 0xF2, 0xD7, 0x74, 0xC3, + 0xDB, 0x13, 0x7E, 0xBC, 0xB8, 0x50, 0xF3, 0x18, + 0x74, 0xAE, 0x74, 0x95, 0x2D, 0x64, 0x5D, 0x7D, + 0xC2, 0x26, 0x09, 0xD2, 0xF8, 0xE4, 0xF4, 0x7F, + 0x10, 0x1F, 0xD3, 0x23, 0x12, 0x4D, 0xC4, 0xAB, + 0xDD, 0xAD, 0x57, 0xF2, 0xED, 0x47, 0x1B, 0x53 + }, + { + 0xAA, 0x55, 0xAD, 0x7B, 0xCF, 0x40, 0x70, 0x14, + 0xFA, 0xF9, 0x38, 0xB7, 0xC9, 0x9A, 0xA8, 0xD1, + 0x1E, 0xD4, 0xA6, 0xCC, 0x5D, 0x15, 0x0D, 0x1A, + 0xDD, 0xFD, 0xE3, 0x32, 0xBA, 0x14, 0x58, 0x15, + 0x3A, 0x0A, 0x08, 0xE5, 0xA9, 0xD4, 0x0F, 0x57, + 0x04, 0xAD, 0x55, 0x2E, 0xAD, 0x13, 0xBF, 0x14, + 0x30, 0x1B, 0xE5, 0xF7, 0x64, 0xE7, 0x50, 0x5A, + 0xD8, 0xAF, 0xA1, 0x8A, 0x31, 0xE5, 0x9D, 0x75 + }, + { + 0x4E, 0xEA, 0xDD, 0x4B, 0x6A, 0x6B, 0x98, 0x51, + 0x56, 0xF2, 0x8E, 0x5B, 0x6C, 0xDE, 0x21, 0xEF, + 0xDD, 0x7A, 0x7C, 0x39, 0x60, 0xDA, 0x6E, 0x77, + 0x70, 0x00, 0x7B, 0x71, 0xFB, 0xB3, 0xC0, 0x08, + 0x4F, 0x46, 0xB4, 0x6C, 0x62, 0x43, 0x47, 0x6D, + 0xD3, 0xAA, 0x4B, 0x42, 0x04, 0xBD, 0xD2, 0x56, + 0x99, 0x15, 0xB7, 0x22, 0x6D, 0x35, 0xEB, 0xC0, + 0xAD, 0x3A, 0xE3, 0xE9, 0x64, 0x2B, 0x5E, 0x2D + }, + { + 0x65, 0xF8, 0xAE, 0x91, 0xD8, 0x36, 0xF1, 0xCA, + 0x92, 0x86, 0xC6, 0x2D, 0x81, 0xAE, 0x1B, 0x0D, + 0x59, 0xEA, 0x6A, 0x8C, 0x5A, 0x51, 0xA7, 0xD7, + 0x80, 0x17, 0xF7, 0x75, 0xB3, 0x1C, 0x81, 0x2F, + 0x48, 0x05, 0xBA, 0xF3, 0x4E, 0xD1, 0x9A, 0x53, + 0xBA, 0xB8, 0x83, 0x5F, 0x1D, 0x61, 0x0F, 0xCE, + 0x40, 0x1C, 0xF5, 0x59, 0x22, 0xE8, 0x0D, 0xC2, + 0xF2, 0x10, 0x7E, 0xD7, 0xC7, 0xF6, 0x88, 0x46 + }, + { + 0x94, 0x08, 0x28, 0x09, 0x2A, 0x81, 0x06, 0x3C, + 0x56, 0x68, 0xC4, 0x0F, 0xFE, 0xF5, 0x43, 0x78, + 0xAC, 0x42, 0xBF, 0x49, 0x0D, 0xF0, 0x22, 0xE7, + 0xB0, 0xC8, 0x49, 0x0B, 0x56, 0xBA, 0x80, 0x9F, + 0xD2, 0x3A, 0x0D, 0xD3, 0x35, 0x28, 0xEF, 0xDB, + 0x07, 0xAA, 0xE8, 0x1F, 0x41, 0x50, 0x7B, 0xDF, + 0x75, 0xD0, 0x4F, 0x56, 0x0E, 0x0D, 0x9D, 0x81, + 0xDD, 0xA6, 0x31, 0x57, 0x9F, 0x09, 0x7F, 0x4B + }, + { + 0xBD, 0xB2, 0x3F, 0x0B, 0x98, 0x38, 0x2E, 0x6C, + 0xEF, 0x1E, 0xCB, 0xCE, 0x7B, 0x73, 0x16, 0xEB, + 0x7B, 0x01, 0xF3, 0xE3, 0x0D, 0x81, 0x24, 0x19, + 0xF6, 0x24, 0x77, 0xCF, 0x32, 0xBA, 0x2E, 0x0A, + 0x44, 0x8B, 0x49, 0xC0, 0xD4, 0xE0, 0xA8, 0xE9, + 0x77, 0x43, 0xB8, 0xFB, 0x6D, 0xF4, 0xE2, 0x20, + 0xB6, 0xDE, 0x31, 0xDD, 0x62, 0x85, 0x79, 0x19, + 0xC9, 0x23, 0xF4, 0xC5, 0x68, 0x92, 0xE9, 0x60 + }, + { + 0xCD, 0x26, 0x1B, 0x6A, 0x7F, 0xEF, 0x4A, 0xD3, + 0x3E, 0x30, 0x3E, 0x03, 0x4A, 0xD7, 0x0F, 0xDB, + 0x17, 0x32, 0x5D, 0x07, 0x08, 0x70, 0x84, 0x92, + 0x48, 0x6F, 0x85, 0xEE, 0x49, 0x48, 0x41, 0xC5, + 0x82, 0x3C, 0x06, 0x9A, 0xC8, 0xD8, 0x5C, 0x4C, + 0xF6, 0x0A, 0x09, 0xB6, 0x97, 0x41, 0xEE, 0x56, + 0x38, 0xAC, 0xE0, 0x16, 0x33, 0x9E, 0x7D, 0xD0, + 0x7D, 0x5C, 0x8B, 0xF2, 0xB0, 0x11, 0xE1, 0x0C + }, + { + 0xE3, 0x07, 0x02, 0xCE, 0x9C, 0x08, 0xE2, 0x6A, + 0x26, 0xF3, 0xDD, 0x70, 0x31, 0x59, 0x56, 0xC6, + 0x94, 0xE8, 0xDC, 0x4A, 0xFA, 0xB5, 0xAC, 0xA0, + 0xCB, 0x13, 0x07, 0xF9, 0xA6, 0x35, 0x37, 0x8D, + 0x2E, 0xBC, 0x82, 0x01, 0x94, 0x66, 0x5E, 0xD8, + 0xE8, 0x72, 0x59, 0xDA, 0x8B, 0xE5, 0xFF, 0x0E, + 0xF0, 0x5F, 0xAA, 0x17, 0x51, 0x57, 0xF7, 0xAE, + 0x0C, 0x1A, 0xC4, 0xB0, 0xE8, 0xE0, 0x71, 0x9B + }, + { + 0xC1, 0x0C, 0x53, 0x67, 0x9C, 0x5E, 0x40, 0x4B, + 0x65, 0x1A, 0x72, 0x0B, 0x10, 0x33, 0x09, 0x6B, + 0x08, 0x37, 0xF4, 0x61, 0x3D, 0x77, 0xD2, 0xF9, + 0x20, 0x2C, 0x2E, 0xCE, 0x0B, 0x56, 0x9A, 0xE3, + 0x0B, 0x52, 0x3A, 0xA6, 0x13, 0x0F, 0xCE, 0x4B, + 0x44, 0x0E, 0x86, 0xC1, 0x95, 0x8A, 0x11, 0xB0, + 0x0C, 0xEA, 0xC1, 0xE6, 0xB4, 0xC6, 0x7E, 0x5A, + 0xF1, 0x42, 0x02, 0xFC, 0xB4, 0x89, 0x6A, 0x4F + }, + { + 0xE7, 0xCF, 0x80, 0xCD, 0xBD, 0x46, 0xB2, 0x87, + 0x43, 0xFF, 0xB8, 0x7D, 0x62, 0xDE, 0x56, 0xB1, + 0x5B, 0xE3, 0x67, 0x2F, 0x6F, 0x32, 0x18, 0x6B, + 0x32, 0x9E, 0x79, 0x69, 0xDD, 0xE2, 0xAE, 0xF1, + 0xB5, 0xD7, 0xDD, 0x44, 0x45, 0x62, 0xA2, 0xC1, + 0x5C, 0xAB, 0x27, 0xBC, 0xA7, 0x48, 0xF0, 0xBC, + 0x89, 0x65, 0x96, 0x89, 0x36, 0x66, 0x40, 0x61, + 0x0C, 0xC8, 0x0E, 0x9C, 0x04, 0x4F, 0xFF, 0x70 + }, + { + 0x6F, 0xB6, 0x73, 0xEC, 0x9E, 0x9C, 0xB1, 0xBE, + 0x64, 0xC1, 0x53, 0x05, 0xDA, 0x05, 0xF1, 0x38, + 0xFF, 0x56, 0xA5, 0x53, 0x34, 0xDF, 0xDF, 0x23, + 0x68, 0x3D, 0x45, 0x6D, 0x9B, 0xDF, 0xFD, 0x29, + 0xCB, 0x22, 0xF1, 0x6E, 0xB6, 0x1A, 0x28, 0x50, + 0xC9, 0xED, 0x05, 0xAA, 0x07, 0x38, 0x99, 0xEA, + 0x8A, 0x8D, 0x0C, 0xE1, 0xB7, 0x37, 0x90, 0x3E, + 0x8A, 0x3A, 0x52, 0xC7, 0x2D, 0x08, 0x01, 0xF8 + }, + { + 0x61, 0x39, 0x55, 0xEA, 0xB8, 0x54, 0xAE, 0x08, + 0xF5, 0x9C, 0xA5, 0x28, 0x1F, 0xA1, 0xF9, 0xA7, + 0x86, 0x7C, 0xA2, 0x67, 0x86, 0xB6, 0x9B, 0x9C, + 0xE0, 0xF0, 0x51, 0x5D, 0xFD, 0x0C, 0x96, 0xF3, + 0x0B, 0x6A, 0x25, 0x56, 0x46, 0x1B, 0x43, 0xD9, + 0x25, 0x56, 0x84, 0xD2, 0x4B, 0x36, 0x19, 0x60, + 0xCD, 0x73, 0x1E, 0xE7, 0xF1, 0x2D, 0x7D, 0xED, + 0x93, 0xEB, 0xD1, 0x52, 0x9A, 0x75, 0x7A, 0x20 + }, + { + 0x44, 0x8E, 0xA1, 0x09, 0x9E, 0x73, 0x06, 0xBE, + 0xDA, 0x5C, 0x1E, 0x55, 0xD3, 0x2A, 0xBD, 0xF2, + 0x4F, 0xB0, 0xAC, 0x99, 0xD7, 0x9B, 0xB9, 0x86, + 0x56, 0xD4, 0x12, 0x81, 0xD5, 0x34, 0xFE, 0x30, + 0xBE, 0xC0, 0x2C, 0xCB, 0xA6, 0x25, 0x11, 0xD3, + 0x35, 0x56, 0x29, 0x98, 0x46, 0xE9, 0xB7, 0x6E, + 0x8E, 0xA1, 0x99, 0x5E, 0x46, 0x95, 0xC8, 0x49, + 0xA2, 0x87, 0x9B, 0x71, 0x5B, 0x8D, 0x8D, 0x46 + }, + { + 0x18, 0xAA, 0x63, 0x7A, 0x03, 0xA8, 0x2A, 0x6C, + 0x96, 0x45, 0xA6, 0x0A, 0x33, 0x11, 0x9F, 0xF3, + 0xA1, 0xFC, 0x4C, 0x55, 0xCD, 0x32, 0xEA, 0xD7, + 0xBC, 0x2C, 0x8E, 0x73, 0x7D, 0xBE, 0xAC, 0x0B, + 0x42, 0x2D, 0x07, 0x83, 0xC0, 0x67, 0xDE, 0xAA, + 0x16, 0xAF, 0xF6, 0x00, 0x59, 0x8E, 0xD3, 0xEA, + 0x69, 0x77, 0x96, 0xB1, 0xE0, 0x5D, 0x34, 0x2D, + 0xDB, 0x3F, 0xC5, 0x70, 0x56, 0xDC, 0xCA, 0x99 + }, + { + 0xF4, 0x2A, 0x02, 0xB8, 0x8B, 0x2C, 0xD4, 0x47, + 0x36, 0x66, 0x4B, 0x18, 0x90, 0xA1, 0x51, 0x3F, + 0x0E, 0x8C, 0x9A, 0x0C, 0xE5, 0x02, 0x41, 0x7E, + 0x56, 0xEE, 0x94, 0xA9, 0xB2, 0xEC, 0x77, 0xEC, + 0x6A, 0x4F, 0xEB, 0xDB, 0xA8, 0x18, 0x1D, 0xDB, + 0x1C, 0xA9, 0x16, 0x3F, 0x8C, 0xA0, 0xD8, 0x32, + 0x2B, 0x9F, 0xA0, 0xB5, 0x27, 0xBB, 0xA2, 0x1A, + 0x0B, 0x3D, 0x0E, 0xD3, 0xCC, 0x1C, 0xC9, 0x17 + }, + { + 0xC1, 0xB8, 0x2B, 0xD5, 0x2C, 0x2D, 0x64, 0x23, + 0x8F, 0xE1, 0xD3, 0x57, 0x41, 0xAB, 0xF9, 0x86, + 0x58, 0x94, 0x6B, 0x50, 0xA1, 0x60, 0xE7, 0x69, + 0xC6, 0xFF, 0xD0, 0xAE, 0x2B, 0xB9, 0x4A, 0x41, + 0x2D, 0x24, 0x01, 0x57, 0xDD, 0x5A, 0x7D, 0x61, + 0x23, 0x40, 0xF9, 0x07, 0x2A, 0xF5, 0x47, 0x88, + 0xA5, 0x6D, 0x3F, 0x3F, 0x66, 0x85, 0x48, 0x68, + 0x17, 0x4C, 0xA0, 0xE3, 0x7A, 0x13, 0x94, 0x67 + }, + { + 0xAB, 0xBD, 0x9D, 0x2A, 0x11, 0x59, 0x12, 0xE7, + 0x12, 0x36, 0x3C, 0x1C, 0x68, 0x5A, 0x3A, 0xAA, + 0x42, 0xE4, 0x42, 0x62, 0x90, 0x49, 0x22, 0x96, + 0x8C, 0xA9, 0x6A, 0xB6, 0x59, 0x02, 0x4C, 0xA3, + 0xD3, 0x8B, 0xB1, 0x77, 0x33, 0x08, 0xD3, 0x81, + 0x6D, 0x10, 0x2F, 0xF7, 0x77, 0xD1, 0x49, 0xB4, + 0x01, 0xBD, 0x5C, 0xAB, 0xC5, 0x97, 0x10, 0x97, + 0x32, 0x0E, 0x71, 0x9B, 0x7A, 0xFA, 0xBF, 0x5E + }, + { + 0x02, 0xE7, 0x08, 0x8D, 0x2D, 0x5B, 0x10, 0xFD, + 0x97, 0x85, 0xE9, 0x74, 0x6F, 0x06, 0x20, 0xE6, + 0x36, 0x47, 0x18, 0x1A, 0x35, 0x30, 0x8E, 0xA5, + 0xF3, 0xE3, 0x63, 0x22, 0xCE, 0xF7, 0x19, 0xC0, + 0x57, 0x1C, 0x68, 0x91, 0x88, 0xDF, 0x8C, 0x08, + 0x52, 0xBE, 0x10, 0x36, 0xA9, 0x66, 0xF0, 0x08, + 0x5C, 0x4E, 0x92, 0xA3, 0x9E, 0x24, 0x84, 0x87, + 0x96, 0x76, 0xC1, 0xD6, 0xBC, 0x22, 0x58, 0x8A + }, + { + 0x83, 0x85, 0xA0, 0xF7, 0xD3, 0x77, 0x92, 0xC4, + 0x23, 0x66, 0x11, 0xF7, 0xB1, 0x52, 0xAB, 0x4E, + 0x2D, 0xF6, 0x2A, 0x55, 0x47, 0x08, 0x37, 0x95, + 0xC4, 0xB1, 0xAF, 0xF3, 0xF0, 0x16, 0xDC, 0x2F, + 0xD8, 0x6A, 0xC2, 0x11, 0xB8, 0xBE, 0x86, 0xC6, + 0xD5, 0xF5, 0xAF, 0x95, 0xA2, 0xDF, 0x7A, 0xF8, + 0x39, 0xFA, 0x12, 0xC0, 0x3B, 0x26, 0x4E, 0x2F, + 0xC1, 0xF8, 0x42, 0xC8, 0xD2, 0xE1, 0x3B, 0x5A + }, + { + 0x8A, 0x76, 0x94, 0x77, 0x25, 0x3B, 0xA2, 0x14, + 0x5D, 0x96, 0x17, 0x95, 0x37, 0xB9, 0x76, 0xAD, + 0x9C, 0xCC, 0x06, 0x99, 0x81, 0x46, 0x5A, 0x6B, + 0xA6, 0x76, 0x32, 0xCA, 0x93, 0x8B, 0xA3, 0x8B, + 0xE8, 0x9E, 0x79, 0xA9, 0xF4, 0x28, 0x08, 0x86, + 0x48, 0xF6, 0xB2, 0xAB, 0x38, 0x76, 0x31, 0xB7, + 0xA6, 0xCD, 0x15, 0x4C, 0x0D, 0x39, 0xE2, 0xD7, + 0x36, 0xB4, 0x4D, 0x73, 0xB3, 0x7B, 0x24, 0xEC + }, + { + 0x90, 0xD1, 0x71, 0xC7, 0x01, 0x2E, 0x15, 0x0B, + 0x6E, 0x16, 0x51, 0x3B, 0xF9, 0x59, 0x2F, 0x6E, + 0x57, 0x97, 0x9E, 0x36, 0x90, 0x1B, 0xBB, 0xB7, + 0x77, 0xE1, 0xF8, 0x6F, 0x03, 0xC1, 0x67, 0xA2, + 0xCD, 0xD7, 0x86, 0xCF, 0xD8, 0x6A, 0xD8, 0xA7, + 0x11, 0x08, 0x59, 0x04, 0x45, 0x4A, 0x4B, 0xDB, + 0x14, 0xB9, 0x07, 0x73, 0xBD, 0x2D, 0xE1, 0x18, + 0x59, 0x3E, 0xD6, 0x2A, 0x77, 0x96, 0x8E, 0xCF + }, + { + 0x92, 0xE2, 0xB7, 0x2A, 0xCA, 0xA0, 0xD8, 0xE9, + 0xB7, 0xC4, 0xC0, 0x23, 0x4C, 0x91, 0xAF, 0x00, + 0xFF, 0x2D, 0xC8, 0xE8, 0x0A, 0x30, 0xE8, 0x51, + 0x59, 0x98, 0x07, 0xED, 0xFF, 0x67, 0xBF, 0xD1, + 0x72, 0x16, 0x63, 0x67, 0xDA, 0x7A, 0xA8, 0x1B, + 0x3E, 0x26, 0x3F, 0xD0, 0xA2, 0x2F, 0x77, 0xAE, + 0x8F, 0x80, 0x63, 0x78, 0xC5, 0xAE, 0x4A, 0x74, + 0x13, 0x8E, 0x0A, 0x1E, 0xD8, 0x06, 0x97, 0xEA + }, + { + 0x7C, 0x0F, 0x91, 0x81, 0xD3, 0xA7, 0xC2, 0xBC, + 0x53, 0xFF, 0x1D, 0x43, 0xCD, 0x63, 0x44, 0xBC, + 0x67, 0xFC, 0x6D, 0x32, 0x16, 0xB2, 0x93, 0xB4, + 0x8C, 0x96, 0x8C, 0x54, 0xB3, 0xEE, 0xA9, 0x44, + 0xB7, 0x1F, 0x4B, 0xB0, 0xCE, 0x66, 0x7C, 0x10, + 0x96, 0xEC, 0x2F, 0xCC, 0xEF, 0x41, 0x7E, 0x15, + 0xD8, 0x81, 0x56, 0x58, 0x62, 0x85, 0xAD, 0x6C, + 0x12, 0x99, 0xE9, 0x57, 0x6B, 0x3C, 0xDD, 0x47 + }, + { + 0x23, 0x68, 0x8B, 0xF2, 0x61, 0xC8, 0x51, 0xA2, + 0x12, 0x5B, 0xEC, 0xD1, 0xC3, 0x83, 0x51, 0xB3, + 0x9A, 0x25, 0x16, 0x52, 0xEC, 0xD8, 0xA4, 0x0F, + 0x7C, 0xFC, 0x29, 0x37, 0x3C, 0x87, 0x91, 0x63, + 0xF4, 0xD3, 0x4F, 0xCE, 0x4F, 0x6F, 0x14, 0xFD, + 0x21, 0xC8, 0x6A, 0x4E, 0xBB, 0x88, 0x3C, 0xB1, + 0xF7, 0xFC, 0x68, 0x80, 0x71, 0x4A, 0x50, 0xE6, + 0x66, 0x83, 0xF8, 0x96, 0x69, 0x27, 0x31, 0x6B + }, + { + 0x37, 0x8C, 0x49, 0x51, 0x65, 0x7F, 0x87, 0x2F, + 0xF5, 0xEE, 0x09, 0x91, 0x74, 0x17, 0x64, 0xBB, + 0xC7, 0x64, 0x49, 0x1C, 0x6E, 0x43, 0x44, 0x98, + 0x14, 0x16, 0x5C, 0x5A, 0xAA, 0x1A, 0x02, 0x6B, + 0xA2, 0x76, 0x95, 0xB8, 0x82, 0x7B, 0x27, 0x74, + 0x35, 0x63, 0x50, 0x47, 0xA7, 0xCA, 0x1F, 0x91, + 0xD1, 0xDD, 0x9A, 0x08, 0x83, 0x91, 0x6F, 0x85, + 0x33, 0x05, 0xC8, 0x6E, 0x42, 0x54, 0xBD, 0x7E + }, + { + 0x4D, 0x52, 0xFA, 0x53, 0x98, 0x87, 0xC9, 0xC8, + 0xBE, 0x99, 0x68, 0x62, 0x28, 0xF7, 0x04, 0x53, + 0x28, 0x9E, 0xCE, 0x06, 0x63, 0x99, 0x11, 0x9B, + 0x3F, 0xC2, 0xF8, 0xF0, 0x9A, 0x73, 0x79, 0xE6, + 0x1C, 0x37, 0x79, 0x88, 0x93, 0x8A, 0x5D, 0x75, + 0x19, 0xD9, 0xD9, 0x29, 0x7F, 0x79, 0x62, 0x66, + 0x79, 0x42, 0x99, 0x44, 0xF8, 0xA6, 0xCD, 0x18, + 0xAA, 0x38, 0xCF, 0xE3, 0x51, 0xBD, 0x7C, 0xC1 + }, + { + 0x40, 0x0E, 0x77, 0x56, 0x91, 0x14, 0xF1, 0x93, + 0x9C, 0xC2, 0xB1, 0xF7, 0x70, 0x63, 0x76, 0xF7, + 0xF8, 0x5A, 0x26, 0x6C, 0xE9, 0x1B, 0x8D, 0x1D, + 0xD9, 0xBC, 0x30, 0x9D, 0x2E, 0x7C, 0x0C, 0x44, + 0x88, 0xDD, 0x98, 0x6E, 0xDC, 0x11, 0x28, 0x90, + 0xAF, 0x53, 0x16, 0xAC, 0x5D, 0xCD, 0xA2, 0x6C, + 0xC4, 0xB5, 0x46, 0xE7, 0x94, 0x1D, 0x3D, 0x62, + 0x04, 0x2E, 0xC1, 0x0A, 0x8C, 0x13, 0xD7, 0x5D + }, + { + 0x3C, 0xEE, 0x24, 0xB2, 0xF2, 0x88, 0xBD, 0x1B, + 0x7C, 0x48, 0x6C, 0x82, 0xA2, 0x4A, 0x33, 0x7B, + 0x93, 0xA3, 0x7E, 0xB4, 0x53, 0x17, 0x1D, 0xBA, + 0x84, 0xE1, 0x48, 0xBC, 0xAE, 0xAE, 0x1D, 0xAF, + 0x69, 0xAA, 0xF8, 0xDD, 0xBE, 0xB7, 0x52, 0x63, + 0x4C, 0xE9, 0x3F, 0x1D, 0x71, 0x37, 0x0C, 0xE8, + 0x54, 0x77, 0x37, 0x11, 0x62, 0xB6, 0xAD, 0x81, + 0xDD, 0x84, 0xBE, 0x99, 0x4E, 0xF3, 0xE6, 0x2F + }, + { + 0x00, 0xD6, 0xFF, 0xDD, 0x9C, 0xCC, 0xEE, 0xE6, + 0xE7, 0xB0, 0xA1, 0x17, 0xF5, 0xA4, 0xF6, 0x9D, + 0x5A, 0x4E, 0xE2, 0x70, 0x97, 0x3E, 0x55, 0x68, + 0xA3, 0xC2, 0xD0, 0xF0, 0x7D, 0x44, 0x4B, 0xFE, + 0xD6, 0x06, 0x5E, 0xE4, 0xB6, 0xF1, 0xAD, 0x28, + 0xCA, 0x58, 0x7B, 0x6B, 0xA9, 0x1B, 0xA6, 0xC3, + 0xCA, 0x44, 0x69, 0x40, 0x45, 0xA9, 0xA6, 0xA6, + 0x11, 0x04, 0x99, 0x1B, 0xE7, 0x70, 0xAA, 0xE2 + }, + { + 0x33, 0x28, 0x52, 0x4E, 0xD8, 0x7B, 0x5F, 0x6E, + 0x5D, 0xD5, 0xE8, 0x92, 0x33, 0x04, 0xA4, 0x15, + 0x85, 0x3E, 0x63, 0xD7, 0xE6, 0x51, 0xDD, 0x77, + 0x44, 0x30, 0x7A, 0x69, 0xD5, 0x78, 0x42, 0x50, + 0xE1, 0x6C, 0x38, 0x44, 0x27, 0x38, 0xC1, 0x34, + 0xF7, 0x88, 0xE6, 0x9E, 0x3C, 0x1A, 0x9F, 0xDC, + 0x0B, 0x86, 0xBC, 0x1D, 0x48, 0xB2, 0xEB, 0xDE, + 0xAA, 0x42, 0xFE, 0x19, 0x1F, 0xAD, 0x8E, 0x94 + }, + { + 0x45, 0xA0, 0x2F, 0x7B, 0xCE, 0x47, 0xD8, 0x15, + 0x2A, 0xFC, 0xDE, 0xAD, 0x21, 0xB1, 0x14, 0x31, + 0x5A, 0xA6, 0x2C, 0xD8, 0x8B, 0x48, 0xCF, 0x27, + 0xFF, 0xDF, 0x3D, 0xCA, 0xD3, 0x4F, 0x3D, 0xA8, + 0x56, 0x09, 0xDD, 0xC2, 0x1E, 0x22, 0x6A, 0x24, + 0xBF, 0x50, 0xA6, 0xE1, 0x6B, 0xC9, 0x83, 0xE4, + 0x10, 0x4D, 0x4A, 0x79, 0xEC, 0x05, 0xAC, 0x53, + 0x65, 0x57, 0xDC, 0x7F, 0xAF, 0xF8, 0x00, 0xB0 + }, + { + 0xDF, 0x97, 0xB5, 0x50, 0xF4, 0x13, 0x1E, 0xA3, + 0x0C, 0x7C, 0x4E, 0xBE, 0xF0, 0x08, 0x28, 0x17, + 0xFD, 0xA7, 0xEE, 0x08, 0xAA, 0xDF, 0x92, 0xEB, + 0x37, 0x0E, 0x4A, 0xB4, 0xC8, 0x02, 0x03, 0xE3, + 0xB8, 0x3A, 0xFB, 0x10, 0xD0, 0xAB, 0x16, 0xEF, + 0xD5, 0xAC, 0x5E, 0x75, 0x67, 0x4E, 0xEB, 0xF0, + 0xC7, 0x03, 0x72, 0xFD, 0xF5, 0xF8, 0x01, 0x60, + 0x5B, 0xF1, 0x25, 0x1A, 0x9C, 0x0A, 0x7B, 0xF5 + }, + { + 0xDD, 0x0A, 0x38, 0xC7, 0xE8, 0xBE, 0x3B, 0xC9, + 0xAB, 0x3C, 0xAA, 0x26, 0x6C, 0xB2, 0xE1, 0x51, + 0xA8, 0x0B, 0xF6, 0x92, 0x16, 0xCB, 0x10, 0xBE, + 0x28, 0xF0, 0x2D, 0xE5, 0x52, 0x5A, 0xF7, 0xA8, + 0xDE, 0x4C, 0xA1, 0x1F, 0x79, 0xC8, 0x44, 0x9E, + 0xA8, 0xC4, 0xF3, 0x15, 0x38, 0x10, 0xFE, 0x33, + 0x13, 0x2C, 0xBF, 0xB7, 0xB1, 0x92, 0x4F, 0xA9, + 0x6A, 0x0B, 0xB5, 0xF5, 0xAA, 0x93, 0x22, 0x85 + }, + { + 0x92, 0xDF, 0x11, 0xC7, 0xE2, 0x17, 0xEE, 0x96, + 0x4C, 0x55, 0xB1, 0x08, 0x90, 0xAA, 0x3D, 0x28, + 0xBD, 0x34, 0x87, 0x2F, 0x71, 0xCB, 0x7A, 0xAF, + 0x28, 0x90, 0x98, 0x40, 0x2E, 0xC5, 0x6E, 0x3D, + 0x34, 0x89, 0x00, 0x51, 0x50, 0x9C, 0xD5, 0xC9, + 0xEA, 0xF6, 0x94, 0x38, 0xFD, 0xCC, 0x77, 0x32, + 0x8B, 0x24, 0xC8, 0x62, 0x4E, 0x38, 0xDA, 0xF8, + 0xBE, 0xF2, 0x4A, 0xBC, 0xEF, 0x00, 0x80, 0x8F + }, + { + 0xA3, 0x17, 0xFC, 0xB9, 0x55, 0x4A, 0x00, 0x96, + 0x35, 0x0B, 0x00, 0x88, 0xF3, 0x16, 0xDC, 0x87, + 0xBF, 0x09, 0x8D, 0x0C, 0xCC, 0x1E, 0xAF, 0x19, + 0xB2, 0xF9, 0xBE, 0x98, 0xC3, 0xA1, 0xD2, 0xD5, + 0x33, 0xC5, 0x4C, 0x0B, 0x18, 0x7A, 0x11, 0xB1, + 0x02, 0xF9, 0x84, 0xD5, 0x82, 0xBF, 0xF3, 0x52, + 0x52, 0xF5, 0x2E, 0x1D, 0x5D, 0x1D, 0xFE, 0x1A, + 0x33, 0x6E, 0x74, 0x75, 0x2D, 0x6F, 0x62, 0x47 + }, + { + 0x7C, 0xF1, 0x53, 0x0E, 0x16, 0xDD, 0xBA, 0xDE, + 0x66, 0xF3, 0x04, 0x74, 0x68, 0xDC, 0x02, 0xCD, + 0x86, 0xE9, 0x43, 0xAC, 0x88, 0x38, 0xA8, 0x8D, + 0x54, 0x19, 0x2D, 0xC8, 0x36, 0x3E, 0x89, 0x99, + 0x2D, 0x8A, 0x17, 0xF9, 0xB9, 0x77, 0x4E, 0xD3, + 0x24, 0xCF, 0x79, 0x7B, 0x95, 0xE2, 0x93, 0xC9, + 0xF3, 0x98, 0x24, 0x02, 0xD3, 0x2F, 0xC6, 0x47, + 0xBA, 0x16, 0x9A, 0x51, 0xF0, 0xF7, 0x0C, 0x47 + }, + { + 0x81, 0xCE, 0x45, 0x2A, 0x00, 0xD3, 0xBF, 0xE9, + 0xFB, 0x15, 0x1E, 0xC7, 0xD6, 0x09, 0x41, 0xA9, + 0x79, 0x13, 0xA2, 0x80, 0xCE, 0x22, 0x67, 0x21, + 0x5A, 0x8B, 0x8D, 0x3A, 0x51, 0xD9, 0x7A, 0x1A, + 0xE9, 0x6F, 0x25, 0x96, 0x9E, 0x1A, 0xD8, 0xE0, + 0xA0, 0xE8, 0x9C, 0x19, 0x82, 0x31, 0x28, 0x2E, + 0xA3, 0x30, 0xB9, 0x06, 0x4C, 0xED, 0x5E, 0x33, + 0xD7, 0xBD, 0x90, 0xAE, 0x64, 0xEF, 0xFE, 0xED + }, + { + 0x13, 0x9D, 0x0B, 0x26, 0x3A, 0x11, 0x48, 0x7C, + 0x17, 0xDE, 0x86, 0x72, 0x05, 0x5F, 0x5C, 0x70, + 0xFB, 0x2E, 0x02, 0x4D, 0xB6, 0x4D, 0x8E, 0xA6, + 0xD4, 0x8A, 0x1D, 0xBB, 0xE2, 0xD0, 0xF9, 0xF6, + 0x78, 0x43, 0xFC, 0x32, 0x47, 0x8C, 0x0A, 0x34, + 0x30, 0x8B, 0x05, 0x34, 0xE6, 0x6D, 0x47, 0x5C, + 0xAC, 0x1B, 0x45, 0x77, 0x4D, 0x43, 0x89, 0xB4, + 0xB9, 0x14, 0x51, 0x16, 0xC4, 0x9F, 0x6C, 0x05 + }, + { + 0x33, 0x82, 0x18, 0xB2, 0xD3, 0x6A, 0x16, 0xE3, + 0xE4, 0x95, 0x9B, 0x49, 0x1F, 0xC5, 0x34, 0x84, + 0xBE, 0xD8, 0x98, 0x63, 0x18, 0x1F, 0xD5, 0x53, + 0x61, 0xAF, 0xA2, 0xAD, 0xC5, 0xF1, 0xE1, 0xEF, + 0x3A, 0xB3, 0x1E, 0x1E, 0xA8, 0xB4, 0x3C, 0xA7, + 0x9A, 0x9A, 0x89, 0x87, 0x47, 0xAD, 0x26, 0xD2, + 0xE4, 0x64, 0x0B, 0xC6, 0x53, 0x06, 0x88, 0x8C, + 0xFD, 0xA1, 0x5A, 0xD6, 0x65, 0xDD, 0x14, 0xE0 + }, + { + 0xE3, 0xFF, 0xFB, 0xF5, 0x55, 0xB5, 0x6F, 0xDE, + 0x5A, 0x0F, 0x45, 0xA0, 0x4B, 0x99, 0x5A, 0x00, + 0x23, 0xF7, 0x61, 0xA1, 0xBC, 0x02, 0x2E, 0x7E, + 0xBF, 0xCC, 0x52, 0xE3, 0x88, 0xB9, 0x2C, 0x3B, + 0x90, 0x3D, 0x98, 0x59, 0x22, 0x64, 0xD1, 0x4E, + 0xF3, 0x96, 0x8A, 0xC6, 0x68, 0xA1, 0xB1, 0x25, + 0xA6, 0x75, 0xB2, 0x9D, 0x42, 0x06, 0x22, 0xC2, + 0x85, 0x2E, 0x82, 0xFB, 0x52, 0xD8, 0x04, 0xA8 + }, + { + 0x57, 0x20, 0x61, 0x32, 0x59, 0x92, 0x89, 0x35, + 0xD1, 0x02, 0x11, 0x72, 0x8B, 0x77, 0x9E, 0x3F, + 0x79, 0x84, 0xFB, 0x0A, 0xE2, 0xC1, 0xDE, 0xCE, + 0xDC, 0xDE, 0xD5, 0x85, 0x53, 0x44, 0x55, 0x66, + 0x88, 0xF3, 0x80, 0x49, 0x3D, 0xF0, 0x30, 0x5E, + 0x8B, 0x6A, 0xCE, 0xFA, 0x04, 0x1E, 0xC5, 0x09, + 0x55, 0xA4, 0xFA, 0x83, 0x05, 0xDA, 0xC9, 0x3E, + 0x57, 0xCA, 0x16, 0xDD, 0xB5, 0xC0, 0xD6, 0xF6 + }, + { + 0xD9, 0x50, 0xB5, 0x0B, 0x35, 0x20, 0x8B, 0x7A, + 0x1E, 0x10, 0xCC, 0xB5, 0x23, 0x76, 0xC3, 0xBF, + 0xD1, 0x58, 0x86, 0x13, 0xFA, 0xF8, 0x86, 0x94, + 0x1E, 0xE5, 0x2C, 0x5C, 0x8E, 0x78, 0x51, 0x5C, + 0x59, 0xDB, 0x18, 0x57, 0x3C, 0x31, 0x43, 0x58, + 0x02, 0xA5, 0xED, 0xC2, 0xF2, 0x7C, 0x65, 0x14, + 0x29, 0xA2, 0xC5, 0xC8, 0x42, 0x1C, 0x75, 0x74, + 0xAE, 0x89, 0x07, 0x40, 0x93, 0xAA, 0x68, 0x1B + }, + { + 0x41, 0x3D, 0x45, 0x3B, 0xEC, 0x25, 0x87, 0x33, + 0xCD, 0xE5, 0x88, 0x3A, 0x62, 0xD1, 0xD0, 0xA6, + 0x43, 0x27, 0xE2, 0xB9, 0x2C, 0x48, 0x8C, 0x89, + 0x66, 0xFC, 0xAA, 0xB5, 0x60, 0x32, 0xDE, 0xCB, + 0xDE, 0x71, 0x97, 0xFD, 0xE8, 0x81, 0xAA, 0x27, + 0xD0, 0xCE, 0x96, 0xCD, 0xBE, 0xC0, 0x2F, 0x41, + 0x62, 0x20, 0x27, 0xF2, 0x8C, 0xA3, 0xF2, 0x03, + 0x5A, 0x6F, 0x9A, 0x02, 0x90, 0xA5, 0x75, 0xBA + }, + { + 0x22, 0xD0, 0x25, 0x7A, 0x70, 0xC6, 0xA6, 0x19, + 0xEB, 0x1F, 0xE5, 0xD6, 0x17, 0xA0, 0xFB, 0xEE, + 0x8E, 0x7B, 0x3A, 0x3F, 0x9A, 0x36, 0xF8, 0xF6, + 0xA4, 0xBD, 0xF4, 0x4E, 0x38, 0xB5, 0xDE, 0xE8, + 0xDB, 0x4F, 0x1E, 0x64, 0xA2, 0xE4, 0xFF, 0x59, + 0xFB, 0x6E, 0xC5, 0xE7, 0xD0, 0x67, 0x50, 0x83, + 0xD8, 0x6E, 0x4E, 0x1C, 0xA0, 0x85, 0x34, 0x7E, + 0xA6, 0x9D, 0x0D, 0x37, 0xB3, 0x82, 0x85, 0x28 + }, + { + 0xAE, 0xA7, 0x89, 0x47, 0xC1, 0x35, 0xBC, 0xCD, + 0x44, 0xBF, 0xB6, 0xA1, 0x17, 0xE8, 0x4F, 0xF0, + 0xFC, 0xD9, 0xA7, 0xFE, 0x86, 0x49, 0x7C, 0x13, + 0x2C, 0x99, 0x5C, 0x5A, 0x0D, 0xA4, 0x6C, 0x99, + 0xD3, 0x55, 0x5F, 0xE0, 0x6C, 0x64, 0xFA, 0xF1, + 0x3B, 0x89, 0x11, 0x43, 0x00, 0xCC, 0xE1, 0x72, + 0x62, 0xA1, 0xCB, 0x3E, 0x82, 0xBB, 0x71, 0x54, + 0x5D, 0xF0, 0xB4, 0xBD, 0xDC, 0x8E, 0xC5, 0x71 + }, + { + 0x0D, 0xF7, 0x5A, 0x1A, 0x98, 0x42, 0xC9, 0x13, + 0x74, 0x69, 0x1F, 0xBB, 0x68, 0xA3, 0x2C, 0x09, + 0x75, 0xE0, 0x7B, 0xA8, 0x7F, 0xF3, 0xC5, 0x0F, + 0x07, 0x9A, 0x59, 0xDC, 0x05, 0xA5, 0xAD, 0xEB, + 0x2A, 0xAE, 0x06, 0xAC, 0x4B, 0x7F, 0x17, 0x16, + 0x7F, 0x7A, 0x1B, 0x0A, 0x4A, 0xEB, 0xF0, 0xD8, + 0x82, 0x1E, 0xE6, 0x99, 0x7E, 0xEC, 0xAD, 0xC7, + 0xC6, 0x95, 0x92, 0x13, 0x53, 0x2A, 0x5C, 0xEA + }, + { + 0xFF, 0x3F, 0xAA, 0x7D, 0x85, 0xCF, 0xF0, 0x72, + 0xF9, 0x72, 0xE3, 0xC4, 0x69, 0xAE, 0xAB, 0x94, + 0xA0, 0x40, 0x33, 0x90, 0x89, 0x91, 0xA9, 0x21, + 0x37, 0xCB, 0xF1, 0xCC, 0x31, 0x96, 0x09, 0xE2, + 0x4F, 0xDE, 0xF4, 0x35, 0x2A, 0xD9, 0x40, 0xDB, + 0xBC, 0xA5, 0x94, 0x4D, 0xCE, 0x93, 0x47, 0x1A, + 0xDD, 0xB6, 0x16, 0x57, 0x6D, 0xB9, 0xFF, 0xE6, + 0x2F, 0x29, 0xD8, 0x59, 0x56, 0x09, 0xBD, 0xCD + }, + { + 0x06, 0x96, 0x20, 0xE3, 0x72, 0x26, 0x30, 0x99, + 0x6E, 0x01, 0x34, 0x4C, 0xD5, 0xE7, 0x03, 0xE8, + 0x5F, 0xDD, 0x14, 0x1D, 0xB2, 0x46, 0x30, 0x8B, + 0x61, 0x84, 0xEC, 0x03, 0x91, 0x50, 0x5A, 0xA5, + 0x67, 0x12, 0x00, 0x57, 0xB8, 0xE5, 0x81, 0xFD, + 0x1F, 0xC5, 0x2E, 0xDD, 0xFE, 0x24, 0x57, 0x84, + 0x2B, 0x78, 0xFF, 0xA0, 0xAA, 0xF7, 0xA1, 0x16, + 0x81, 0x20, 0xD3, 0x93, 0xFC, 0x69, 0x69, 0xCB + }, + { + 0x45, 0x45, 0x3C, 0xA0, 0xDB, 0xAF, 0xAA, 0x08, + 0xAF, 0xA0, 0xC8, 0x46, 0xC1, 0x84, 0xAA, 0x5D, + 0x25, 0x6F, 0xCB, 0xAE, 0x95, 0x68, 0x42, 0x75, + 0xE2, 0x71, 0x66, 0x4F, 0x80, 0xFD, 0xAD, 0x33, + 0x0A, 0x30, 0x89, 0x4F, 0xE0, 0x0F, 0x23, 0x9C, + 0xA2, 0xC3, 0x2C, 0xDF, 0xB3, 0xF1, 0x61, 0x76, + 0x89, 0x2D, 0x78, 0xF0, 0xFA, 0xB2, 0x37, 0x8A, + 0xE6, 0x05, 0x28, 0xCE, 0x15, 0xBF, 0x46, 0x82 + }, + { + 0x4F, 0x3B, 0x1C, 0x20, 0x96, 0xFF, 0x25, 0x40, + 0x03, 0xAB, 0xEE, 0x68, 0xB4, 0x06, 0xDA, 0x09, + 0x9B, 0x77, 0xAA, 0x12, 0xC2, 0xEB, 0x65, 0xE2, + 0x29, 0xA9, 0xD1, 0xFA, 0x73, 0x1A, 0xA7, 0x32, + 0xD2, 0xAF, 0xDB, 0xDF, 0x61, 0x9A, 0x62, 0x36, + 0x5A, 0x32, 0xFF, 0x22, 0x18, 0x80, 0x93, 0xAA, + 0x72, 0x19, 0x48, 0x4B, 0x68, 0x34, 0x7E, 0x3C, + 0x85, 0x60, 0xDF, 0xC6, 0xCB, 0xEF, 0x8C, 0xA0 + }, + { + 0x63, 0x7D, 0xDC, 0xE1, 0xD4, 0xE3, 0xAE, 0x5E, + 0x06, 0xB6, 0xE6, 0x7B, 0xE7, 0x9A, 0x89, 0x02, + 0x3D, 0xC8, 0x55, 0xED, 0xA0, 0x82, 0x7B, 0xF9, + 0x69, 0x7C, 0xCA, 0xBB, 0x8D, 0x75, 0x39, 0x88, + 0x59, 0x6C, 0x88, 0xAD, 0x07, 0x7F, 0x0A, 0x73, + 0x9E, 0xCA, 0xC3, 0xB8, 0x58, 0x45, 0xAE, 0x9A, + 0x17, 0x84, 0xC0, 0x33, 0x26, 0x44, 0x53, 0xD9, + 0xEF, 0x96, 0xB2, 0x1B, 0x50, 0x1D, 0x64, 0x4C + }, + { + 0x0C, 0x4F, 0x9B, 0x4E, 0xE3, 0x7C, 0x7B, 0xC3, + 0xDF, 0xA4, 0x69, 0x59, 0x98, 0xA7, 0x63, 0xA2, + 0x6E, 0x18, 0x17, 0xFA, 0xD1, 0x78, 0x90, 0x96, + 0x54, 0x8A, 0xE8, 0xFE, 0xD1, 0x34, 0x89, 0xE8, + 0xC2, 0x1A, 0x6A, 0xCD, 0x16, 0xB1, 0xE6, 0xDF, + 0x78, 0x40, 0xCE, 0x8A, 0x1E, 0x25, 0x1B, 0x8D, + 0xDC, 0xA4, 0xAF, 0xAE, 0x2D, 0x03, 0x31, 0x03, + 0xB7, 0x42, 0x35, 0x25, 0x20, 0xFF, 0x82, 0xCE + }, + { + 0x8D, 0x52, 0x2C, 0x08, 0xA8, 0x9F, 0x15, 0xAB, + 0x47, 0xDD, 0x3F, 0x2C, 0x29, 0x05, 0xB9, 0x0F, + 0xE7, 0x38, 0x2D, 0xAC, 0x26, 0x14, 0x25, 0x72, + 0x23, 0x7D, 0xC0, 0x62, 0x4E, 0xCD, 0x79, 0x18, + 0xBA, 0x7F, 0x1D, 0x69, 0x12, 0x61, 0xA1, 0xF9, + 0xB7, 0x97, 0xA3, 0xF8, 0xC2, 0xDB, 0xB3, 0x8E, + 0xFF, 0xB1, 0x0F, 0x74, 0x1F, 0xA4, 0xD9, 0xE6, + 0x76, 0x24, 0x7E, 0xF8, 0xAC, 0x8F, 0xDE, 0x42 + }, + { + 0xC5, 0x64, 0x6B, 0x54, 0x15, 0x7B, 0xC7, 0xA3, + 0xDE, 0xAC, 0x89, 0x24, 0x13, 0x47, 0x4B, 0x61, + 0xA7, 0x09, 0x6F, 0xF0, 0x45, 0x1B, 0x7E, 0x54, + 0x8D, 0x60, 0x69, 0xFE, 0x50, 0xD1, 0x06, 0x4A, + 0x38, 0xA7, 0x0A, 0x5C, 0xA5, 0x53, 0x5B, 0x44, + 0xD2, 0x02, 0x4A, 0x4A, 0x5F, 0x8D, 0x96, 0x81, + 0xDE, 0x7B, 0xCE, 0xFC, 0xB2, 0x46, 0x0A, 0x02, + 0x80, 0xE8, 0x06, 0x68, 0x1C, 0x8C, 0x07, 0x11 + }, + { + 0x61, 0xA4, 0xEC, 0xAE, 0xD0, 0x2D, 0x21, 0x38, + 0x8E, 0xD2, 0xD0, 0xAA, 0x95, 0xCA, 0x26, 0xCA, + 0xA2, 0x68, 0xD8, 0xC9, 0xC9, 0x2E, 0xC1, 0xBE, + 0x46, 0x15, 0x1A, 0x53, 0x4B, 0x80, 0x25, 0x01, + 0xBA, 0x7A, 0x90, 0x78, 0x74, 0x1C, 0xD0, 0x24, + 0x39, 0x79, 0x72, 0xCD, 0x5B, 0x2F, 0x8E, 0xF6, + 0x1C, 0x90, 0x82, 0x26, 0x9C, 0x38, 0xEE, 0x5C, + 0x05, 0x73, 0xB8, 0xE6, 0x26, 0x55, 0xCB, 0xBB + }, + { + 0x95, 0x49, 0x51, 0xE3, 0x2F, 0x9D, 0xCC, 0x9C, + 0x32, 0x64, 0x4F, 0x89, 0x39, 0x2D, 0xDE, 0xEF, + 0xB6, 0xF4, 0xE8, 0xF8, 0xD2, 0x58, 0x72, 0xC0, + 0xC7, 0x6A, 0x50, 0x30, 0xE5, 0xF1, 0xE6, 0x1F, + 0x9F, 0x9D, 0x99, 0x88, 0x74, 0xE4, 0xAE, 0xF2, + 0x83, 0x8E, 0x46, 0x63, 0x89, 0x1C, 0x48, 0x7F, + 0xC5, 0x74, 0x3C, 0xEC, 0x98, 0xB8, 0x32, 0xE6, + 0xC3, 0xA3, 0x09, 0xE3, 0x51, 0x4A, 0x42, 0x43 + }, + { + 0xD1, 0xC6, 0xFD, 0x6A, 0x16, 0xE8, 0x1C, 0x1A, + 0xF3, 0xAA, 0x49, 0xB7, 0x0C, 0x2A, 0xE3, 0x8B, + 0x47, 0xA3, 0x6F, 0x2D, 0x84, 0xFF, 0xCE, 0x17, + 0xC0, 0x6C, 0xE5, 0x31, 0xC4, 0x87, 0x13, 0x99, + 0xCB, 0x96, 0xDC, 0x23, 0xC8, 0xFD, 0x7F, 0x64, + 0x38, 0x63, 0x91, 0x19, 0xE8, 0xB1, 0x22, 0x74, + 0xEF, 0x32, 0xD4, 0x16, 0xED, 0x2E, 0xD6, 0x23, + 0x59, 0x8C, 0x64, 0xD0, 0x77, 0x52, 0xB0, 0x4A + }, + { + 0xA1, 0xC6, 0x01, 0x4E, 0xC0, 0x7C, 0x42, 0x5A, + 0xF4, 0x37, 0x89, 0x19, 0x36, 0xC2, 0xC9, 0x06, + 0x58, 0xFB, 0x57, 0xC0, 0xF8, 0x02, 0x53, 0xD2, + 0x77, 0x7D, 0xBC, 0x4B, 0x4F, 0xC8, 0xBB, 0xE9, + 0x84, 0x55, 0xD5, 0x8F, 0xDA, 0x51, 0xC8, 0xCA, + 0x99, 0xCD, 0x67, 0xCB, 0xD6, 0x04, 0x14, 0xC0, + 0xF0, 0x40, 0x51, 0x78, 0x5B, 0x39, 0xD3, 0x9E, + 0x5B, 0xD6, 0x62, 0x32, 0x5A, 0xD8, 0x08, 0xB0 + }, + { + 0x7F, 0x27, 0xFC, 0x1A, 0x0C, 0xB8, 0xA8, 0xE7, + 0xF7, 0x9B, 0xC9, 0x08, 0xB8, 0x7F, 0x3E, 0x61, + 0x06, 0xE7, 0x8B, 0x9B, 0xD4, 0x01, 0x8A, 0x34, + 0xA4, 0x36, 0xEE, 0x90, 0x88, 0x6F, 0x61, 0xA1, + 0x95, 0xAB, 0x55, 0x21, 0x69, 0x2A, 0x2E, 0xF3, + 0x4A, 0xF2, 0x1B, 0x65, 0x13, 0x5B, 0x84, 0xE4, + 0x77, 0xDC, 0xB5, 0xC9, 0x46, 0xDC, 0x53, 0xE5, + 0x43, 0x52, 0x4C, 0x7C, 0x7D, 0x4C, 0xF0, 0x63 + }, + { + 0x27, 0xBE, 0x0C, 0xBA, 0x82, 0x9E, 0xDF, 0x78, + 0xE0, 0xC4, 0xA7, 0xC4, 0x4F, 0xC0, 0xA5, 0x4C, + 0x05, 0xC4, 0x4B, 0x9E, 0xAB, 0xD7, 0x6B, 0xCC, + 0xBE, 0x84, 0x92, 0x53, 0x2A, 0x41, 0x73, 0x99, + 0xF6, 0xEA, 0xC5, 0x7F, 0x59, 0xD5, 0xA6, 0x48, + 0xA9, 0x96, 0x4E, 0x98, 0x14, 0x83, 0xCB, 0x1E, + 0xAF, 0x92, 0x1E, 0x92, 0x85, 0x3A, 0x8E, 0x06, + 0xBB, 0x04, 0x84, 0x97, 0x86, 0x7F, 0xBF, 0x0D + }, + { + 0x1C, 0x33, 0xEA, 0x3E, 0x25, 0x82, 0x0D, 0xCA, + 0xEB, 0x52, 0x4E, 0x40, 0xF7, 0x59, 0x4A, 0xD9, + 0x74, 0x7D, 0x2D, 0x23, 0x49, 0xD7, 0xC5, 0xFF, + 0x4C, 0x86, 0xDF, 0x1E, 0x67, 0xA0, 0x9A, 0x1A, + 0xCD, 0x3F, 0x2B, 0x65, 0x3F, 0x3C, 0xF9, 0x77, + 0xDA, 0x88, 0x42, 0x19, 0xE0, 0x0E, 0xA5, 0x38, + 0xA7, 0x4B, 0x1F, 0xB4, 0xD8, 0x1A, 0x4D, 0xDF, + 0x03, 0xCE, 0xA5, 0xFC, 0xEA, 0x3F, 0x07, 0xAB + }, + { + 0xA4, 0xA1, 0xA4, 0x5E, 0x1E, 0xFD, 0x50, 0x84, + 0xAF, 0xB1, 0xAF, 0xAB, 0x18, 0x87, 0x2D, 0x79, + 0xE8, 0x63, 0x11, 0x6D, 0x12, 0xC6, 0x08, 0xC0, + 0xA5, 0x50, 0x1F, 0xE8, 0x8E, 0xCB, 0xEA, 0x23, + 0x24, 0x62, 0xE0, 0xFC, 0x68, 0xBA, 0x94, 0x15, + 0xFC, 0xBA, 0x40, 0x0D, 0xC0, 0x6E, 0xE8, 0x0B, + 0xF6, 0x21, 0x90, 0x61, 0x35, 0x67, 0x4B, 0x77, + 0x12, 0x30, 0xCC, 0xCD, 0x98, 0xD3, 0xC7, 0x44 + }, + { + 0x63, 0x2D, 0x01, 0xE0, 0x62, 0x22, 0x8C, 0xCC, + 0x7F, 0x29, 0xC3, 0x21, 0x06, 0x7C, 0x9D, 0xC6, + 0xE6, 0xC5, 0x04, 0x1D, 0xFE, 0xC9, 0xDB, 0x37, + 0xD2, 0x43, 0x5F, 0x50, 0x6B, 0x9E, 0x8C, 0x5C, + 0x8D, 0x85, 0x8D, 0xD2, 0xA9, 0x24, 0xFC, 0x9C, + 0x69, 0xEF, 0xA3, 0x2E, 0x6A, 0xDE, 0x9C, 0xB2, + 0x0F, 0x2C, 0x73, 0x9E, 0xF2, 0x4E, 0x5C, 0x16, + 0x0B, 0xC8, 0xE8, 0xD6, 0xB4, 0xE4, 0x07, 0xC7 + }, + { + 0xA9, 0x4E, 0xEE, 0xD8, 0xE9, 0xC2, 0xBC, 0x47, + 0x06, 0x45, 0x1E, 0xA1, 0x49, 0x43, 0xEE, 0x3F, + 0xA4, 0x30, 0xAB, 0x70, 0x3D, 0x8B, 0x8E, 0x03, + 0x8A, 0xD4, 0x54, 0xCB, 0x00, 0x94, 0xBA, 0x2D, + 0x55, 0x5B, 0x3F, 0x75, 0x34, 0x17, 0x5A, 0xF2, + 0x55, 0x14, 0xBE, 0x53, 0xE0, 0x45, 0x7A, 0xAD, + 0xDD, 0xE0, 0xEA, 0x5F, 0x11, 0xC3, 0xC2, 0x55, + 0x59, 0xD1, 0xB9, 0xA0, 0x1C, 0x8D, 0x03, 0x8A + }, + { + 0x5A, 0x83, 0x8E, 0x7A, 0xDB, 0x13, 0x17, 0x6D, + 0x1E, 0x04, 0x8F, 0xE2, 0x2B, 0x60, 0x38, 0x64, + 0x5A, 0xA8, 0x6D, 0xBC, 0x6F, 0x81, 0x82, 0x85, + 0xEC, 0x96, 0x08, 0xF0, 0xA4, 0x09, 0xA6, 0xB1, + 0x38, 0x63, 0x04, 0x17, 0x2D, 0x3E, 0xF9, 0x13, + 0x1D, 0xB0, 0xA8, 0xB6, 0x2A, 0x94, 0xF2, 0x37, + 0x8D, 0xB0, 0xBE, 0x19, 0x50, 0x91, 0x54, 0x2D, + 0x26, 0x5C, 0x99, 0x0F, 0x61, 0xB4, 0x67, 0x2F + }, + { + 0xA1, 0xF0, 0x62, 0xA8, 0xE5, 0xC4, 0x3A, 0xB1, + 0xD7, 0xD3, 0xAB, 0xF3, 0x27, 0xD9, 0xE5, 0x21, + 0x39, 0x3F, 0xCD, 0x9C, 0xBC, 0xFA, 0x88, 0x69, + 0x27, 0xA5, 0x44, 0x93, 0x36, 0x7C, 0x3F, 0xF0, + 0x3F, 0x51, 0x7C, 0x06, 0x80, 0x7D, 0x15, 0x17, + 0x72, 0xEC, 0x38, 0x2B, 0x69, 0x55, 0x66, 0xD2, + 0xA6, 0xC8, 0x45, 0x40, 0x34, 0x04, 0x0C, 0xC7, + 0xEE, 0x92, 0xCB, 0xED, 0xA9, 0x00, 0xA1, 0xD5 + }, + { + 0xAD, 0x8C, 0x72, 0xCB, 0xBD, 0x21, 0x4C, 0x48, + 0x75, 0xC6, 0x11, 0x7F, 0x4A, 0x7A, 0x48, 0xD3, + 0xD3, 0xF3, 0x3A, 0x69, 0xA0, 0xB1, 0x89, 0x6E, + 0x8E, 0x28, 0x7C, 0x29, 0x9D, 0x4D, 0x74, 0xF3, + 0x54, 0xC7, 0x44, 0xFF, 0xCD, 0x4A, 0x30, 0xA1, + 0x2F, 0x81, 0x66, 0x7D, 0x99, 0x9D, 0xF2, 0xE6, + 0xC5, 0x21, 0x89, 0x7C, 0xF6, 0x6E, 0x6B, 0x9F, + 0x78, 0x58, 0x5C, 0x51, 0xD8, 0x5F, 0x1E, 0x39 + }, + { + 0x5B, 0xA1, 0xCE, 0x0D, 0x24, 0x5B, 0xE6, 0xD0, + 0x6F, 0xAD, 0xDF, 0x3B, 0x65, 0x41, 0x90, 0x50, + 0xD9, 0xA8, 0xD0, 0x5C, 0x03, 0x21, 0x06, 0xFB, + 0xB3, 0x57, 0x4B, 0x59, 0xE6, 0x7C, 0x8C, 0xD3, + 0x7F, 0x7F, 0x06, 0x89, 0x4C, 0xB8, 0x5E, 0xCA, + 0xB6, 0x91, 0x2C, 0x5C, 0xE6, 0x8D, 0x98, 0x2E, + 0x3F, 0x60, 0x80, 0xED, 0x16, 0x25, 0x47, 0x57, + 0xE5, 0xCF, 0x9C, 0x57, 0x2C, 0x78, 0xBD, 0x05 + }, + { + 0x23, 0x2F, 0xFA, 0xFD, 0x38, 0x11, 0xA1, 0x4D, + 0xE6, 0x17, 0x88, 0xB5, 0xC4, 0xF0, 0x87, 0xF7, + 0x33, 0xEA, 0xA5, 0xF6, 0x60, 0xC1, 0xEE, 0x52, + 0x1E, 0xB7, 0xAF, 0xAA, 0x18, 0xE8, 0x00, 0x2F, + 0x22, 0xF5, 0x50, 0x8D, 0x05, 0x91, 0xD8, 0x4C, + 0xCB, 0x2E, 0xF0, 0x79, 0x5B, 0x8F, 0xDF, 0x47, + 0x11, 0xEA, 0xC7, 0x5F, 0x82, 0x18, 0xC1, 0x7F, + 0xBC, 0x13, 0xDE, 0x47, 0x2F, 0xFB, 0x02, 0x60 + }, + { + 0x9E, 0xAE, 0xBC, 0xB3, 0xDD, 0xE7, 0x23, 0xA8, + 0xA0, 0xC7, 0xD5, 0xB6, 0x04, 0x61, 0x06, 0xBE, + 0xEB, 0x36, 0x30, 0x07, 0xC5, 0x15, 0x4E, 0x53, + 0x16, 0x4A, 0x0E, 0x8C, 0xEA, 0x6F, 0x7F, 0xA6, + 0x9B, 0xBD, 0x49, 0x3F, 0x99, 0x2B, 0x42, 0x42, + 0x89, 0xA1, 0xE3, 0xE8, 0xAD, 0x69, 0x00, 0x05, + 0x51, 0x27, 0xE6, 0x9C, 0xD4, 0x23, 0xB1, 0xE8, + 0x45, 0xAB, 0x42, 0x09, 0x44, 0x2A, 0x69, 0x3F + }, + { + 0xBE, 0x33, 0xA7, 0xCB, 0x14, 0x4C, 0x4F, 0xE1, + 0x80, 0x43, 0xA3, 0x7A, 0x22, 0xC7, 0x72, 0x5F, + 0x98, 0x6A, 0x5A, 0xF1, 0x83, 0x74, 0xE7, 0x55, + 0x91, 0x36, 0xCE, 0x6B, 0x83, 0x1C, 0x57, 0x78, + 0x6F, 0xBE, 0x7E, 0x83, 0x0C, 0x48, 0x17, 0xA1, + 0x22, 0x52, 0x3F, 0x17, 0x06, 0x3B, 0xD8, 0xC7, + 0xE7, 0xE7, 0xEE, 0x2E, 0xF9, 0xDA, 0x6B, 0xF8, + 0x76, 0x12, 0x4F, 0x6E, 0x3E, 0xEF, 0x64, 0xF9 + }, + { + 0x75, 0xC1, 0xDA, 0x12, 0xA7, 0xA6, 0xA3, 0x1B, + 0xB2, 0xCB, 0xEC, 0x34, 0xDB, 0x90, 0xEE, 0xAD, + 0xE2, 0xA2, 0x8E, 0x8A, 0x0A, 0x57, 0xF1, 0x5A, + 0x43, 0x51, 0xBD, 0x4C, 0x79, 0x39, 0x2E, 0x62, + 0xAB, 0x88, 0x7D, 0x4C, 0xE4, 0x19, 0xA5, 0xDC, + 0xDD, 0x07, 0xE4, 0xC1, 0x02, 0xED, 0x17, 0x9F, + 0xED, 0x87, 0x82, 0xB3, 0x76, 0xF3, 0x7C, 0xCA, + 0xE2, 0x5F, 0x78, 0xA2, 0xD5, 0xD6, 0xA0, 0xEF + }, + { + 0xD6, 0x9F, 0x73, 0xEA, 0xC7, 0x19, 0x82, 0x30, + 0xC7, 0xA6, 0xA0, 0x50, 0xA9, 0x6F, 0xF2, 0x88, + 0x2F, 0xD4, 0xA1, 0x43, 0x82, 0xF5, 0x02, 0x30, + 0x01, 0xD4, 0x3D, 0xBD, 0x12, 0x9A, 0xBF, 0xD5, + 0x11, 0xF7, 0xB8, 0x65, 0xE3, 0x8A, 0x5D, 0x57, + 0xD1, 0xA6, 0xEF, 0xF4, 0x97, 0xC2, 0x9E, 0xD1, + 0xCB, 0x0E, 0xAC, 0xE0, 0x8D, 0x00, 0x46, 0x45, + 0x9B, 0xB6, 0x77, 0xB2, 0x8A, 0x0C, 0x06, 0x15 + }, + { + 0x43, 0xEF, 0x39, 0x4B, 0xA7, 0x9F, 0xCC, 0x65, + 0xB0, 0xBC, 0x3A, 0x39, 0xB3, 0xCE, 0xEC, 0x35, + 0x13, 0x61, 0xAD, 0x19, 0x8F, 0xB3, 0x1E, 0xC6, + 0x31, 0xA4, 0xCA, 0x81, 0xCF, 0x40, 0xF3, 0xF3, + 0xE7, 0x2E, 0x6F, 0xC2, 0x16, 0xEC, 0xFE, 0x90, + 0x20, 0xC5, 0x33, 0x2F, 0x97, 0xEB, 0x9A, 0x28, + 0x69, 0x14, 0xDB, 0xBF, 0x95, 0x34, 0x86, 0xCF, + 0x03, 0x90, 0x9B, 0xBD, 0x8B, 0xF7, 0x94, 0xF9 + }, + { + 0xFC, 0x1A, 0xFF, 0xF0, 0x79, 0x40, 0xF8, 0x6A, + 0x24, 0x18, 0x10, 0xC0, 0x88, 0x03, 0x00, 0xBF, + 0x88, 0x05, 0xA7, 0xF6, 0xD1, 0x59, 0x1D, 0x80, + 0x92, 0x75, 0x24, 0x59, 0x48, 0x8A, 0x44, 0x35, + 0x9D, 0x5E, 0xBA, 0x21, 0x2E, 0xAF, 0x7B, 0xF9, + 0xD3, 0x83, 0xCA, 0xF4, 0x04, 0x42, 0xA2, 0xBA, + 0x78, 0x89, 0xFE, 0xB3, 0x5A, 0xCC, 0x7E, 0xBF, + 0x95, 0x1A, 0x1E, 0x18, 0x9A, 0xEA, 0xA9, 0x75 + }, + { + 0x61, 0x4B, 0xBD, 0x2B, 0xCD, 0x7F, 0x1B, 0x02, + 0x34, 0xD9, 0x40, 0x16, 0x94, 0x7B, 0x26, 0x1B, + 0x06, 0x24, 0x84, 0xA1, 0x5D, 0x20, 0xA1, 0xEF, + 0x16, 0x9B, 0xD6, 0xB0, 0xF4, 0xC4, 0x91, 0xA4, + 0x70, 0xF0, 0x6E, 0x9D, 0x55, 0x5B, 0xD8, 0x55, + 0x83, 0xBB, 0xEB, 0x0C, 0x81, 0x9B, 0x91, 0x28, + 0xA8, 0xD4, 0xD1, 0x4B, 0x8F, 0x2B, 0x60, 0x6E, + 0x6D, 0x84, 0x59, 0xB9, 0x28, 0x74, 0xAE, 0x18 + }, + { + 0xC2, 0xE7, 0xFD, 0xBA, 0x28, 0x07, 0xD9, 0x99, + 0x7F, 0xB8, 0x8F, 0x7D, 0x04, 0x50, 0x90, 0x2D, + 0x2D, 0x63, 0xA3, 0x0B, 0x30, 0x92, 0x34, 0x96, + 0xC5, 0x23, 0x7A, 0xEC, 0xAF, 0x23, 0x81, 0x2B, + 0xB8, 0x4F, 0x4E, 0x09, 0x79, 0x2E, 0x38, 0x7C, + 0x81, 0x40, 0xD6, 0x04, 0x07, 0xFB, 0x16, 0xCD, + 0x30, 0x04, 0xA6, 0x9F, 0x88, 0x7D, 0x22, 0xA1, + 0x64, 0x11, 0xA7, 0xD4, 0x38, 0x06, 0x2B, 0xC1 + }, + { + 0x3D, 0xEB, 0xE5, 0xC7, 0x22, 0xCD, 0xE0, 0xD2, + 0x21, 0xA9, 0xDF, 0xC0, 0x5B, 0x37, 0x3B, 0xBD, + 0x86, 0x41, 0x47, 0x55, 0xBF, 0xAA, 0x68, 0x8E, + 0xA8, 0x37, 0x84, 0x3E, 0x47, 0xF0, 0x54, 0x90, + 0x00, 0xA0, 0x46, 0xF7, 0x49, 0x33, 0xFD, 0xCE, + 0xBA, 0xAB, 0xF1, 0xD2, 0xD6, 0x63, 0x06, 0x55, + 0x04, 0xD8, 0x46, 0xC8, 0x42, 0x73, 0x83, 0x9F, + 0x4C, 0x82, 0xB2, 0x3A, 0x0A, 0xC8, 0x4D, 0x7D + }, + { + 0xDD, 0xA2, 0x08, 0xAC, 0x15, 0xA4, 0x5F, 0xDC, + 0xB8, 0xA6, 0xD5, 0xE8, 0x3D, 0x0B, 0x3C, 0x85, + 0xE5, 0x53, 0x38, 0x99, 0xB9, 0x10, 0xD6, 0x71, + 0xF0, 0x5D, 0x8F, 0xB9, 0x3B, 0x15, 0x37, 0x7C, + 0xF8, 0xB6, 0x9E, 0xF5, 0xB5, 0x5F, 0x73, 0xE8, + 0x73, 0x6D, 0x9E, 0xDC, 0x33, 0x23, 0xD6, 0x00, + 0x93, 0x52, 0xD7, 0xB1, 0x17, 0x56, 0x4A, 0x3F, + 0xBE, 0x32, 0x26, 0xD5, 0x49, 0xB0, 0x97, 0xE5 + }, + { + 0x17, 0x4C, 0xCB, 0x7D, 0x78, 0x87, 0x8E, 0xE5, + 0x51, 0xD5, 0xEA, 0xC1, 0x82, 0x7E, 0x2C, 0xA3, + 0x77, 0x96, 0x1A, 0x16, 0x0E, 0x86, 0x82, 0xFB, + 0xB3, 0x9D, 0x27, 0xE7, 0x31, 0x43, 0x3C, 0x8F, + 0x4B, 0x9E, 0xEC, 0x3C, 0x73, 0xFA, 0x44, 0xDC, + 0x8E, 0xAA, 0x4D, 0xD2, 0x54, 0xA7, 0xC6, 0x92, + 0xA8, 0x5E, 0x9D, 0x1B, 0xEE, 0xDA, 0x15, 0xF3, + 0x32, 0x9E, 0x5E, 0x29, 0x3B, 0xD2, 0xD8, 0x59 + }, + { + 0xA2, 0x41, 0xC4, 0xC8, 0xF3, 0x28, 0x0F, 0x0C, + 0x4E, 0xDE, 0xE0, 0x97, 0x06, 0x32, 0x41, 0x5D, + 0xF2, 0x19, 0xC9, 0xB0, 0xEA, 0xD1, 0xBB, 0x39, + 0x87, 0xF1, 0x45, 0x86, 0x83, 0xCF, 0x78, 0xD0, + 0x9F, 0x8B, 0x9D, 0xD0, 0x7C, 0x55, 0x55, 0xE2, + 0xBC, 0x3F, 0x4F, 0xFC, 0x0B, 0xC7, 0x36, 0x2A, + 0xD0, 0xBC, 0xC6, 0xAB, 0x42, 0x0C, 0x47, 0x58, + 0xF1, 0x2C, 0x4E, 0xA2, 0x54, 0xF4, 0xD6, 0xDC + }, + { + 0x73, 0xD5, 0xF0, 0x5F, 0xAB, 0x07, 0x22, 0x86, + 0x2B, 0x75, 0xB9, 0x96, 0x4B, 0x06, 0x8B, 0x72, + 0xE6, 0x33, 0x59, 0x27, 0x02, 0xED, 0xB8, 0xF8, + 0xB1, 0x75, 0xD0, 0x9D, 0xD9, 0x67, 0x67, 0xE8, + 0x82, 0x82, 0xBB, 0xAB, 0xC2, 0xFD, 0x7F, 0x62, + 0xA0, 0xD1, 0x97, 0xF4, 0xBD, 0x43, 0x89, 0x39, + 0x87, 0xFF, 0x56, 0x06, 0x06, 0xE6, 0xA7, 0x1E, + 0xB6, 0xA7, 0x0E, 0xB2, 0x2F, 0x1F, 0x61, 0x86 + }, + { + 0xB4, 0x33, 0x2E, 0xC5, 0x78, 0x97, 0x0A, 0xF3, + 0x78, 0xDF, 0x34, 0x13, 0xF3, 0x0E, 0xC8, 0xA5, + 0x6E, 0x21, 0x7E, 0x12, 0xAB, 0xEA, 0x91, 0x28, + 0x36, 0xCC, 0xF6, 0x65, 0x27, 0xD2, 0xBC, 0xFB, + 0x1F, 0xED, 0xDE, 0x72, 0x62, 0x15, 0x48, 0x19, + 0xCA, 0x4F, 0xC3, 0xAD, 0x46, 0x9C, 0xDE, 0x50, + 0xA2, 0x21, 0xFF, 0x47, 0x20, 0xEC, 0xDF, 0xC5, + 0x5B, 0x41, 0xD1, 0xC3, 0x71, 0x80, 0x29, 0x28 + }, + { + 0x49, 0x32, 0x3F, 0xC1, 0xC2, 0x79, 0x89, 0xCE, + 0x62, 0x1E, 0x7D, 0x6C, 0xB5, 0x54, 0x41, 0xDB, + 0x56, 0x6D, 0x34, 0xA7, 0xF6, 0xD1, 0x33, 0xEE, + 0x04, 0x95, 0x60, 0x85, 0x9F, 0xB3, 0x63, 0x9F, + 0x7B, 0xB0, 0x52, 0xB9, 0xDB, 0x91, 0x93, 0x4B, + 0xF9, 0xD1, 0xB0, 0xD9, 0xA8, 0x7C, 0x9F, 0x83, + 0xB0, 0xAA, 0x6D, 0xBF, 0xD4, 0x79, 0x1B, 0x5F, + 0x4E, 0x87, 0x60, 0x86, 0xD5, 0xF5, 0x6E, 0x70 + }, + { + 0x96, 0x6D, 0x3D, 0xF2, 0x8B, 0xC1, 0xFC, 0x02, + 0x59, 0xE1, 0x28, 0x4C, 0x02, 0x8E, 0xD6, 0x38, + 0x31, 0x79, 0x19, 0xDA, 0x51, 0xD4, 0x41, 0x39, + 0x9E, 0x7B, 0xE1, 0x2F, 0x39, 0x72, 0x24, 0x8F, + 0x34, 0xE0, 0x91, 0xEA, 0x36, 0x65, 0x06, 0x62, + 0x5C, 0x83, 0x25, 0x84, 0x6B, 0x4B, 0xBF, 0x3B, + 0xD1, 0xFF, 0x2F, 0x4A, 0x0A, 0x8D, 0x6E, 0x74, + 0x7A, 0x49, 0xEE, 0x71, 0xE1, 0xD2, 0x44, 0x7D + }, + { + 0x29, 0xCC, 0x0B, 0x6D, 0x91, 0x16, 0x28, 0x40, + 0x64, 0x4D, 0x35, 0x78, 0x82, 0x24, 0x1A, 0xC4, + 0xBD, 0x3B, 0xF7, 0x93, 0xAE, 0x90, 0x80, 0x64, + 0x7C, 0xE2, 0x12, 0x8D, 0xAD, 0x6E, 0xF0, 0x9E, + 0x1C, 0xFC, 0x8B, 0xA1, 0x89, 0x80, 0x3B, 0xE0, + 0xC6, 0xC2, 0x81, 0x29, 0x7D, 0xD8, 0x32, 0x99, + 0x10, 0xE5, 0x1B, 0x06, 0x9A, 0xFA, 0x3B, 0xDE, + 0xBF, 0x65, 0x47, 0xA6, 0x2A, 0xC1, 0xB8, 0xA8 + }, + { + 0x90, 0xEF, 0xBE, 0xA1, 0x16, 0x9C, 0x45, 0x41, + 0x57, 0xAC, 0x94, 0x51, 0x87, 0xC1, 0x60, 0xF5, + 0xF1, 0xC5, 0x24, 0xBA, 0xE3, 0xF8, 0x7C, 0xD9, + 0xC5, 0xDB, 0x14, 0xA4, 0x5F, 0x19, 0x16, 0xFA, + 0xCD, 0xDF, 0x78, 0xDF, 0xA3, 0x76, 0x78, 0x32, + 0x1E, 0x00, 0x13, 0x7C, 0x6D, 0x11, 0x11, 0x16, + 0xB5, 0x61, 0x45, 0x48, 0x96, 0xA7, 0x98, 0x79, + 0xE8, 0x7E, 0x28, 0x4A, 0xDF, 0x33, 0xFC, 0x66 + }, + { + 0xD0, 0xAA, 0x3E, 0x14, 0x55, 0x13, 0x10, 0xE8, + 0x6F, 0x92, 0x76, 0xCC, 0xAE, 0x08, 0xCC, 0x22, + 0xE9, 0xC1, 0x40, 0xF4, 0x4A, 0xBE, 0x3B, 0x3D, + 0x57, 0x31, 0xBF, 0x6F, 0x94, 0x68, 0xBE, 0x89, + 0x77, 0x91, 0xD9, 0xB8, 0xD9, 0x3D, 0x73, 0xAD, + 0xCA, 0x92, 0x63, 0x2B, 0xEA, 0x6D, 0x45, 0x1D, + 0xB4, 0x69, 0x17, 0x6E, 0x28, 0xC0, 0x06, 0x41, + 0xF1, 0xAE, 0x5F, 0xD9, 0x36, 0x62, 0xFF, 0x19 + }, + { + 0xC0, 0x48, 0x4D, 0x68, 0x06, 0x9A, 0x5B, 0x4D, + 0x87, 0xCE, 0x61, 0x01, 0xD6, 0x53, 0x18, 0xD0, + 0xD8, 0xDD, 0x2C, 0x01, 0x13, 0xF5, 0x4D, 0xEC, + 0x59, 0x52, 0xCB, 0xEE, 0x98, 0xA5, 0x5D, 0x64, + 0x79, 0x1D, 0xC1, 0x8F, 0x2C, 0x04, 0xDD, 0x27, + 0x3D, 0x49, 0xEE, 0x33, 0xFE, 0x4F, 0x49, 0xAF, + 0x9E, 0xF8, 0x84, 0xE0, 0x85, 0x00, 0xAE, 0xB7, + 0x85, 0x70, 0xBE, 0x91, 0x9B, 0x51, 0x71, 0x35 + }, + { + 0x7C, 0x5F, 0x55, 0xA4, 0x80, 0xD4, 0xA1, 0xA2, + 0x27, 0x40, 0x53, 0x85, 0x34, 0x54, 0x29, 0xC7, + 0x99, 0x06, 0x9B, 0xF7, 0xCB, 0x72, 0xAE, 0x98, + 0x97, 0x2D, 0x6E, 0x47, 0x46, 0x85, 0x7B, 0x88, + 0x1B, 0xE9, 0x38, 0x2E, 0x41, 0x7E, 0x72, 0x06, + 0x68, 0xC6, 0x7F, 0xA1, 0x70, 0xEE, 0x45, 0xF4, + 0x46, 0xBB, 0x50, 0xA3, 0x8D, 0x4B, 0x71, 0x07, + 0x67, 0xE8, 0xCE, 0xB1, 0x10, 0x89, 0xDF, 0x49 + }, + { + 0x4B, 0xC0, 0x13, 0x28, 0x93, 0x8B, 0xE1, 0x50, + 0xEF, 0xA4, 0x5D, 0xE9, 0x8B, 0xCD, 0xB0, 0xFB, + 0x6A, 0xF8, 0xDF, 0xE3, 0x96, 0x0C, 0x17, 0x0E, + 0x57, 0x78, 0x51, 0x29, 0xE8, 0x6E, 0xD9, 0xF9, + 0x38, 0x04, 0x2F, 0x34, 0x47, 0x6F, 0x5A, 0x37, + 0x4A, 0x16, 0x68, 0xED, 0x5E, 0xDE, 0xF1, 0xD1, + 0x44, 0x02, 0x32, 0x76, 0x85, 0x7C, 0xBC, 0x76, + 0x02, 0x12, 0x8A, 0xB7, 0xBD, 0x6A, 0x18, 0xD2 + }, + { + 0x26, 0x8F, 0xFD, 0x93, 0xF5, 0xFC, 0xB0, 0xCA, + 0xBB, 0x4D, 0xBD, 0x8E, 0x6E, 0xC2, 0x8E, 0x52, + 0x15, 0xEE, 0xDC, 0x43, 0xB3, 0xD6, 0xB0, 0x45, + 0xC8, 0x96, 0x57, 0xC3, 0xEE, 0xFB, 0xBC, 0xD1, + 0x83, 0x00, 0xBD, 0xDB, 0xD7, 0xEE, 0xAD, 0x11, + 0xD0, 0xFD, 0xE6, 0x5C, 0x12, 0x12, 0xB5, 0xA1, + 0x2E, 0xFC, 0xDA, 0xF9, 0xDE, 0x19, 0xE9, 0x47, + 0x86, 0x61, 0x48, 0x6B, 0xAA, 0xD3, 0xD8, 0xC5 + }, + { + 0xD4, 0x30, 0xD1, 0x83, 0x88, 0x35, 0xE6, 0x2A, + 0xF7, 0x3F, 0x12, 0x26, 0xA5, 0xDA, 0x16, 0x2F, + 0x66, 0x54, 0xC9, 0x8E, 0x25, 0xCF, 0xE2, 0xC8, + 0x7F, 0x4C, 0x9F, 0x23, 0x2B, 0xCB, 0xFA, 0x47, + 0x61, 0x1D, 0xFB, 0x54, 0x05, 0x2B, 0x17, 0x7E, + 0xA9, 0x6D, 0x3A, 0x2E, 0xBB, 0x8C, 0x2F, 0xD5, + 0x3E, 0xA8, 0x6C, 0xE9, 0x95, 0xCF, 0x8A, 0x7A, + 0xEF, 0xA6, 0xB2, 0xE0, 0x9B, 0xC2, 0xA0, 0x51 + }, + { + 0x7D, 0x36, 0xFA, 0x81, 0x3F, 0x1D, 0xEF, 0xB5, + 0x13, 0x1B, 0x20, 0xDC, 0x35, 0x52, 0xDC, 0xDD, + 0xAD, 0xFB, 0x32, 0x19, 0xA6, 0xF1, 0x90, 0x10, + 0x04, 0xC0, 0x1B, 0xEF, 0x53, 0x58, 0x5E, 0xDE, + 0xCF, 0xD4, 0x00, 0xF6, 0x18, 0x78, 0x83, 0xE9, + 0xC6, 0x09, 0xF6, 0x00, 0x6D, 0x4E, 0xB2, 0xE9, + 0x1E, 0xB2, 0x96, 0x74, 0x6F, 0xB1, 0x58, 0x5F, + 0xFD, 0x67, 0x57, 0x50, 0xD8, 0xCE, 0x2C, 0xCA + }, + { + 0x23, 0x78, 0x2B, 0xB0, 0x27, 0xE8, 0xCD, 0x45, + 0xE8, 0x36, 0x69, 0x2D, 0x8F, 0x9E, 0xFD, 0xD0, + 0x8D, 0xE5, 0xD1, 0x13, 0x2F, 0x67, 0x02, 0xCA, + 0x73, 0x17, 0x29, 0x6C, 0x63, 0x31, 0x54, 0x5E, + 0x69, 0x6A, 0x97, 0x25, 0x4F, 0x98, 0x0A, 0x7A, + 0x56, 0x1A, 0x38, 0x34, 0x7F, 0xD6, 0x23, 0x4B, + 0xB0, 0xC9, 0x9F, 0x5A, 0x1B, 0x29, 0x46, 0x84, + 0xBE, 0x42, 0xA7, 0x98, 0x4E, 0x9F, 0x7D, 0x08 + }, + { + 0x68, 0x45, 0x60, 0xFC, 0x48, 0x5A, 0xF0, 0x6C, + 0x8D, 0xE1, 0x75, 0x81, 0x9A, 0xD0, 0xE2, 0x5E, + 0xA8, 0xF7, 0x90, 0xBC, 0x29, 0xBA, 0xC0, 0xF8, + 0xAC, 0xD5, 0x19, 0x39, 0x06, 0x0B, 0x2E, 0x5E, + 0xC9, 0x46, 0xEE, 0xCE, 0x7D, 0x05, 0xFE, 0x8B, + 0xAB, 0x92, 0x7B, 0xB4, 0xC0, 0x9B, 0xF8, 0xEF, + 0xEE, 0xBF, 0x63, 0x7F, 0xA6, 0x48, 0xB0, 0x3E, + 0x1C, 0x31, 0xB3, 0x05, 0x29, 0xFE, 0x92, 0xA3 + }, + { + 0xA6, 0x77, 0xBB, 0xE4, 0x8C, 0x74, 0xE8, 0xCC, + 0x3A, 0x8D, 0x65, 0x75, 0x16, 0x30, 0xDD, 0x15, + 0xC0, 0x9B, 0x38, 0x1B, 0xBE, 0x44, 0x0C, 0x4B, + 0x8A, 0x8C, 0x5F, 0x47, 0x9F, 0x35, 0x59, 0x6B, + 0xB0, 0x50, 0x05, 0xAB, 0xD1, 0x93, 0x42, 0xE2, + 0x3F, 0xE8, 0x6F, 0x43, 0xC1, 0x42, 0x66, 0x35, + 0x8B, 0xA2, 0x73, 0xFC, 0xB2, 0xC8, 0xB8, 0xB9, + 0x4B, 0x35, 0xBE, 0x11, 0x0A, 0x87, 0x3A, 0xFA + }, + { + 0xA0, 0xE7, 0x77, 0x44, 0x5B, 0xCF, 0x56, 0x96, + 0x14, 0x90, 0x04, 0x72, 0x8C, 0xD1, 0x0B, 0x1E, + 0xD3, 0x5B, 0x95, 0xBB, 0x54, 0x2D, 0xBA, 0xF5, + 0xA1, 0x8E, 0x2D, 0xC8, 0x31, 0x47, 0x1A, 0xA2, + 0x06, 0xE3, 0xD0, 0xC2, 0x7D, 0xB8, 0x48, 0x62, + 0xC1, 0x58, 0x18, 0x9A, 0xE7, 0xB8, 0xEB, 0x4A, + 0xBB, 0x1D, 0x2B, 0x71, 0x1D, 0x0D, 0x71, 0x59, + 0x15, 0x26, 0xC5, 0xFC, 0x65, 0xBF, 0x40, 0x39 + }, + { + 0x84, 0xD6, 0x5E, 0xDE, 0x4C, 0xB8, 0x53, 0x00, + 0xF4, 0xD0, 0x97, 0xA4, 0x9B, 0x49, 0x1D, 0xAD, + 0x4A, 0x70, 0xD3, 0xDC, 0xDB, 0xBE, 0x5F, 0xD6, + 0x3C, 0x6F, 0xC3, 0xB8, 0x35, 0x4B, 0xC1, 0xCC, + 0xD3, 0xDE, 0x1F, 0x40, 0xA4, 0x8F, 0x8E, 0xB8, + 0x0E, 0xD2, 0x99, 0x32, 0xC4, 0xD9, 0xC6, 0xA9, + 0xAA, 0xA5, 0x25, 0x16, 0x0B, 0xFF, 0x67, 0x41, + 0x45, 0xFD, 0x8D, 0x16, 0x42, 0x17, 0x83, 0x7A + }, + { + 0xE9, 0x06, 0xA8, 0x97, 0x02, 0xB2, 0x7C, 0x7B, + 0x29, 0x2C, 0x2A, 0xCA, 0xE5, 0xB6, 0x7C, 0xC5, + 0xF9, 0x47, 0xD6, 0x24, 0xCD, 0x50, 0x1C, 0x27, + 0x46, 0x8F, 0xE1, 0x98, 0xF0, 0xD1, 0x27, 0xD7, + 0x99, 0x0D, 0x1A, 0x0E, 0x55, 0x7C, 0x97, 0xA3, + 0x5F, 0x4C, 0x8D, 0xC3, 0x18, 0xBA, 0xD1, 0xDD, + 0xD3, 0x20, 0x3A, 0xCC, 0xE7, 0xE7, 0xD9, 0x13, + 0x0B, 0xF6, 0xF5, 0x55, 0x4D, 0xAA, 0x17, 0xFC + }, + { + 0xFC, 0x6E, 0x59, 0x8F, 0x2A, 0x0E, 0xAD, 0xAD, + 0xF9, 0xE0, 0x83, 0x4A, 0x72, 0x7F, 0xBF, 0x87, + 0xF5, 0x34, 0xCD, 0xDD, 0x05, 0x22, 0xAD, 0xC5, + 0x85, 0x3C, 0xC2, 0x14, 0xC3, 0xAD, 0x5A, 0x4C, + 0x41, 0x91, 0x34, 0x0B, 0xCF, 0x6A, 0xC9, 0x0A, + 0x6D, 0xCB, 0xF1, 0x73, 0x34, 0x57, 0x40, 0xC4, + 0xDB, 0x51, 0xF2, 0xA1, 0xF3, 0x0E, 0x14, 0xD6, + 0x86, 0x62, 0xB7, 0xF6, 0x56, 0xD1, 0x36, 0x16 + }, + { + 0x35, 0xDD, 0x64, 0xE2, 0xDB, 0xC5, 0xF9, 0xE6, + 0x7B, 0xBB, 0xC8, 0xE9, 0xA5, 0x01, 0xFE, 0xF8, + 0xB1, 0x94, 0xCC, 0xA8, 0x06, 0xA2, 0xFA, 0x74, + 0x72, 0xFF, 0x6A, 0x52, 0x08, 0x5C, 0x8D, 0xA1, + 0x7F, 0x47, 0x93, 0x19, 0x26, 0x45, 0x00, 0xD6, + 0xF0, 0xC8, 0x08, 0x57, 0xF5, 0xE7, 0x54, 0x18, + 0xB2, 0x52, 0x7D, 0x52, 0x89, 0x4D, 0xC2, 0x7F, + 0xD1, 0xDC, 0x55, 0x09, 0xBB, 0xDB, 0x4A, 0xB8 + }, + { + 0xC4, 0x56, 0x2D, 0x7B, 0xF0, 0xC3, 0xC3, 0x8B, + 0xEE, 0x18, 0x77, 0x77, 0xF4, 0x58, 0xD7, 0xBF, + 0x3B, 0x1F, 0xA7, 0x42, 0x57, 0xD5, 0x89, 0x71, + 0x48, 0x96, 0xEA, 0xCA, 0xBC, 0x9B, 0xF4, 0x4C, + 0x5F, 0xA8, 0xF7, 0xB8, 0xD7, 0x2E, 0x62, 0x1F, + 0xDE, 0x43, 0x7A, 0xF8, 0x55, 0x40, 0xDF, 0xB3, + 0xFB, 0xBE, 0x6D, 0x0C, 0x31, 0xF1, 0x7A, 0x47, + 0xFD, 0xCE, 0x8C, 0xB0, 0xE8, 0x19, 0x5B, 0x80 + }, + { + 0xA1, 0xA8, 0x6D, 0x7B, 0x4A, 0x2F, 0xEB, 0x7A, + 0x7A, 0xAD, 0x73, 0x76, 0xC9, 0xE3, 0x28, 0xDC, + 0xC9, 0x8C, 0xF2, 0x11, 0x0E, 0xE1, 0xC6, 0xF3, + 0xA5, 0x23, 0xBA, 0x69, 0xA4, 0xC8, 0x76, 0x43, + 0x9B, 0x5A, 0x2A, 0x5B, 0x47, 0xB7, 0x4D, 0xDE, + 0xDE, 0x9F, 0xC2, 0x72, 0x2D, 0xD0, 0x3F, 0x89, + 0x89, 0xF4, 0x0C, 0x6A, 0x0D, 0x7E, 0xFA, 0xBF, + 0x93, 0xEF, 0xD6, 0xA7, 0x89, 0xE4, 0xD6, 0xF9 + }, + { + 0xF5, 0x28, 0x55, 0xA7, 0xDF, 0x00, 0x33, 0x70, + 0x45, 0x41, 0xC7, 0xF5, 0xF3, 0x2E, 0x2C, 0x40, + 0x94, 0x2F, 0xFB, 0x97, 0xC2, 0xA7, 0x17, 0xEA, + 0xD0, 0x51, 0x1F, 0x25, 0xEB, 0x45, 0xD6, 0xBC, + 0x94, 0x76, 0x4F, 0xFB, 0xDE, 0x17, 0x66, 0x03, + 0xA4, 0x6B, 0xE1, 0xA8, 0x4B, 0xE1, 0x8D, 0x05, + 0x47, 0xDD, 0xE6, 0x3A, 0x1C, 0xD3, 0xE4, 0xB5, + 0x96, 0xF3, 0x17, 0x58, 0x08, 0x9B, 0x10, 0x48 + }, + { + 0x2F, 0x39, 0x7D, 0xC0, 0xC5, 0x5E, 0xDA, 0x4F, + 0xE6, 0xA6, 0xA7, 0xAB, 0x31, 0x24, 0x8A, 0x7C, + 0x03, 0x58, 0x4B, 0x78, 0x6E, 0x11, 0x8A, 0x44, + 0x4C, 0x39, 0x57, 0x79, 0x6A, 0x59, 0xB8, 0x32, + 0x95, 0x26, 0x2D, 0x43, 0x1B, 0xEE, 0x5C, 0xA2, + 0x4F, 0x57, 0xBC, 0xB9, 0xD4, 0xA7, 0x8F, 0x72, + 0xFF, 0xE3, 0x9D, 0x37, 0xA8, 0xFD, 0x0D, 0x89, + 0x50, 0x7A, 0xBA, 0xE6, 0x61, 0x29, 0xC9, 0xA2 + }, + { + 0x86, 0x43, 0xD4, 0xAF, 0xDE, 0x4C, 0x08, 0xE9, + 0x19, 0x70, 0xD3, 0x25, 0x5A, 0xA6, 0x25, 0xC3, + 0xE3, 0xCB, 0x46, 0x1D, 0xAD, 0xA5, 0x6B, 0x40, + 0x3A, 0x37, 0x09, 0xE9, 0x4D, 0x57, 0x9D, 0x6F, + 0x80, 0x2A, 0x5C, 0xB6, 0x90, 0x1D, 0x5F, 0x5C, + 0x84, 0x45, 0xE6, 0x7E, 0x11, 0x64, 0xD0, 0xD7, + 0xE2, 0xE7, 0xBC, 0x84, 0x55, 0xDC, 0x0E, 0x0E, + 0xD5, 0x68, 0x7D, 0x67, 0xA2, 0x65, 0xF4, 0x6A + }, + { + 0x02, 0x43, 0x5A, 0x6D, 0x58, 0x7A, 0x14, 0x68, + 0x10, 0xE5, 0xC1, 0x72, 0x81, 0x05, 0xD6, 0xEC, + 0x7D, 0xAA, 0x68, 0xDF, 0x3E, 0xFD, 0xA4, 0xA1, + 0x32, 0x91, 0x13, 0xF6, 0xE9, 0x47, 0xBC, 0x31, + 0x92, 0xEC, 0xA6, 0x83, 0x3D, 0x75, 0x4C, 0x19, + 0xE2, 0x5D, 0x27, 0xD7, 0x65, 0x28, 0x06, 0x99, + 0x4A, 0x46, 0xAD, 0x52, 0xE1, 0xEB, 0xE1, 0x37, + 0x9B, 0xE1, 0x4D, 0x47, 0x98, 0x7C, 0x61, 0x7C + }, + { + 0xE4, 0xCD, 0xE6, 0x59, 0x29, 0x8F, 0xFD, 0xDC, + 0x42, 0x80, 0xA5, 0x03, 0xD9, 0x51, 0xF0, 0x7D, + 0xB8, 0x01, 0x64, 0x3B, 0x96, 0x70, 0x58, 0x9B, + 0x6E, 0x0D, 0xD8, 0x75, 0xCF, 0x14, 0x41, 0xD0, + 0x15, 0xBC, 0xC5, 0x08, 0xD2, 0x9A, 0xC8, 0x52, + 0x06, 0xF5, 0xD3, 0xEA, 0x81, 0xFC, 0xD3, 0x70, + 0xAA, 0x61, 0x7C, 0x67, 0x82, 0x99, 0x3F, 0xE5, + 0x90, 0xC8, 0x6A, 0xDD, 0x26, 0x9C, 0xF1, 0x2B + }, + { + 0x02, 0x18, 0xA3, 0xFA, 0x20, 0xDA, 0xD8, 0x3A, + 0x68, 0x4A, 0xD8, 0x93, 0xEF, 0x1E, 0xE4, 0xD3, + 0x0B, 0x93, 0x32, 0x55, 0xC3, 0xB2, 0xC5, 0xB3, + 0x25, 0x7F, 0xF7, 0xD6, 0xD8, 0xCD, 0x0D, 0x46, + 0x19, 0x76, 0xB4, 0x7A, 0xEE, 0x01, 0x0A, 0x0E, + 0x2E, 0xFF, 0xF6, 0x6A, 0x84, 0xAE, 0x37, 0x3E, + 0xA2, 0x65, 0x4B, 0x18, 0x9E, 0x1F, 0x5F, 0x25, + 0xAC, 0xF7, 0x5C, 0x01, 0x18, 0x3F, 0xD9, 0x3D + }, + { + 0x74, 0xFD, 0xEC, 0xB5, 0x2C, 0xCA, 0x49, 0xB3, + 0x56, 0xA0, 0xA9, 0x6E, 0xBE, 0x34, 0xAA, 0x0B, + 0x73, 0x69, 0xF0, 0x95, 0x5B, 0x96, 0x84, 0x85, + 0x88, 0x5C, 0xFC, 0x54, 0x25, 0x7D, 0xEC, 0x8A, + 0xD5, 0x49, 0xA6, 0x7F, 0x53, 0x54, 0xA7, 0xF5, + 0xCA, 0x9B, 0x44, 0x43, 0x58, 0x7C, 0x08, 0xE5, + 0x52, 0x84, 0xEA, 0xAC, 0x91, 0xBA, 0xA6, 0xE6, + 0x0D, 0x2A, 0x1D, 0x72, 0x86, 0x83, 0xEE, 0x9A + }, + { + 0x1F, 0x32, 0xF9, 0x3F, 0x03, 0xF2, 0xF8, 0x6D, + 0xFA, 0xBF, 0x3B, 0xC4, 0x12, 0xF2, 0x91, 0x25, + 0x84, 0x12, 0xF4, 0x4B, 0x01, 0x95, 0xF1, 0x0A, + 0x7D, 0xB6, 0x60, 0x73, 0xE8, 0x7E, 0x3D, 0xD9, + 0x98, 0x98, 0x11, 0x9E, 0x65, 0x18, 0x95, 0xCB, + 0x79, 0x2F, 0x69, 0x9C, 0x0E, 0x76, 0x96, 0x3D, + 0x3A, 0x60, 0x49, 0x65, 0x16, 0x8D, 0x4E, 0x2F, + 0x33, 0x02, 0x3F, 0xC2, 0xB8, 0x35, 0xC5, 0x81 + }, + { + 0x64, 0xE8, 0xB0, 0x47, 0x04, 0xBD, 0x86, 0xD7, + 0x02, 0x94, 0x51, 0xE1, 0x16, 0x29, 0x6D, 0x36, + 0x44, 0x0C, 0x59, 0xBB, 0xD7, 0x68, 0x69, 0xA8, + 0x52, 0x0F, 0x05, 0xA6, 0x9A, 0x37, 0x82, 0x41, + 0x9C, 0x15, 0x95, 0x86, 0x6C, 0xFF, 0x4B, 0xCD, + 0x24, 0xCD, 0x18, 0x11, 0x16, 0x95, 0x24, 0x5C, + 0x4A, 0x38, 0x74, 0xC2, 0x1C, 0x89, 0x90, 0x29, + 0x0A, 0xE9, 0xF6, 0xB4, 0x85, 0x31, 0x53, 0x30 + }, + { + 0x69, 0x0A, 0xFF, 0xEB, 0x09, 0xCD, 0x7E, 0xD8, + 0xA9, 0xA0, 0x34, 0x20, 0x53, 0x56, 0x79, 0x55, + 0x35, 0x2B, 0xEF, 0xB1, 0xA1, 0x62, 0x04, 0x85, + 0x2C, 0x8D, 0xB9, 0x42, 0xF5, 0xD0, 0x29, 0xD9, + 0x73, 0x4F, 0x69, 0xF2, 0x2B, 0x55, 0x8A, 0x61, + 0xFA, 0x60, 0x1C, 0x8C, 0x21, 0x76, 0x8C, 0x79, + 0x41, 0x6C, 0x43, 0xB8, 0x1C, 0x28, 0x24, 0xBE, + 0x36, 0x02, 0x5A, 0x6A, 0x29, 0xA9, 0xAE, 0xC8 + }, + { + 0x6A, 0x01, 0xA3, 0xCE, 0x67, 0xCC, 0xFC, 0xE9, + 0x12, 0x70, 0x63, 0x36, 0xB4, 0x3F, 0xAF, 0x20, + 0x63, 0xEC, 0x07, 0x3F, 0x48, 0x10, 0x3A, 0xEE, + 0x79, 0x08, 0xBA, 0x9A, 0x8A, 0x92, 0xC4, 0x6A, + 0xCB, 0xF2, 0x2B, 0x5E, 0x51, 0x53, 0xD7, 0xEC, + 0x00, 0x8B, 0xC2, 0x2F, 0xC3, 0x54, 0x65, 0x92, + 0x0C, 0xED, 0x95, 0x4E, 0x31, 0xE4, 0x72, 0x28, + 0xC9, 0x6F, 0xA9, 0x51, 0x00, 0x57, 0xE5, 0x25 + }, + { + 0x9B, 0x23, 0xAB, 0xB5, 0x1D, 0xE3, 0xE2, 0x3C, + 0x3C, 0xE7, 0x14, 0xF7, 0xEE, 0x0B, 0x3D, 0x1A, + 0xDD, 0x96, 0x15, 0x4E, 0x22, 0x44, 0x07, 0x01, + 0x8F, 0x6C, 0xE5, 0x50, 0xA5, 0xE7, 0xD7, 0xCA, + 0xA3, 0xCE, 0xFD, 0xBF, 0x6F, 0xFD, 0xAA, 0x33, + 0x81, 0x3F, 0x1D, 0xAE, 0xC1, 0x94, 0xE6, 0x99, + 0x9E, 0x1F, 0x31, 0x9F, 0xAE, 0x6E, 0x7A, 0x5C, + 0x6C, 0xEE, 0x0C, 0x68, 0x3E, 0xCC, 0xAE, 0xB9 + }, + { + 0xA9, 0x48, 0xC2, 0x1F, 0x3E, 0x2D, 0x4A, 0x6D, + 0x05, 0xBB, 0xCF, 0x7E, 0x2D, 0x70, 0xC5, 0x70, + 0x30, 0xFE, 0x68, 0xDD, 0x19, 0x19, 0xE3, 0xCA, + 0x44, 0xF2, 0xF4, 0xA7, 0x52, 0x53, 0xA7, 0x81, + 0xFB, 0x2C, 0xA4, 0xF4, 0x75, 0x2B, 0x27, 0x5B, + 0xB0, 0x67, 0x37, 0x16, 0x0D, 0x02, 0xEB, 0x8F, + 0x39, 0xF8, 0x12, 0xEC, 0x75, 0xE3, 0xDE, 0x6C, + 0xBE, 0xFB, 0xFF, 0x24, 0xCC, 0x01, 0x51, 0x73 + }, + { + 0x56, 0x18, 0xFD, 0x4E, 0x65, 0xC0, 0x42, 0x93, + 0x30, 0x1C, 0xAA, 0xB6, 0xDA, 0x77, 0xDC, 0x20, + 0x7D, 0x33, 0x52, 0x6C, 0x53, 0xA6, 0xF3, 0xD4, + 0x46, 0x8C, 0xFB, 0x31, 0x9A, 0x35, 0xCA, 0x39, + 0x3B, 0x02, 0x94, 0x2B, 0xC3, 0xF0, 0x3A, 0x90, + 0x4A, 0xDB, 0x77, 0xEE, 0x4C, 0xCA, 0x1A, 0xC6, + 0x22, 0x05, 0x7F, 0xCF, 0x9F, 0xDD, 0x82, 0xEB, + 0xD9, 0xAD, 0xD7, 0x9F, 0x36, 0xE2, 0x14, 0xAA + }, + { + 0xA5, 0x49, 0x64, 0x0A, 0xE0, 0x41, 0x3E, 0x0B, + 0x49, 0x92, 0xD8, 0xFD, 0xC3, 0x95, 0x11, 0xFF, + 0x13, 0xFF, 0x4A, 0x9F, 0x67, 0x40, 0x19, 0x14, + 0xB4, 0xF7, 0xF8, 0xD4, 0x4F, 0xAC, 0xE5, 0xBF, + 0x75, 0x6D, 0x18, 0x19, 0xFE, 0x20, 0x79, 0xFA, + 0xDF, 0x15, 0x8E, 0x57, 0x6E, 0xDD, 0x12, 0x28, + 0x41, 0x77, 0xDB, 0x40, 0xFF, 0xE6, 0x6B, 0xE4, + 0x10, 0x99, 0x3E, 0xF8, 0x77, 0x56, 0x3A, 0x0F + }, + { + 0x8F, 0x94, 0xF1, 0xBD, 0x58, 0x30, 0x9F, 0xD0, + 0x6E, 0xA9, 0xF3, 0x22, 0xF7, 0x8E, 0x1D, 0xA2, + 0xB6, 0x85, 0xC4, 0xFE, 0x7E, 0xA3, 0xE4, 0x8E, + 0x6C, 0xE4, 0x53, 0x4D, 0x9A, 0xF8, 0x77, 0x2D, + 0xC5, 0x8D, 0x0A, 0xA3, 0x7B, 0x9F, 0xBF, 0xBD, + 0xB9, 0xC1, 0xC1, 0xD9, 0xD1, 0x66, 0x05, 0xAA, + 0xEA, 0xCD, 0x7B, 0xE2, 0xA0, 0x32, 0xE1, 0xEA, + 0xB1, 0xAA, 0xE1, 0x7E, 0xC0, 0x51, 0x34, 0x63 + }, + { + 0xE6, 0x09, 0x51, 0x63, 0xAF, 0x0A, 0xA3, 0x18, + 0xCB, 0x88, 0x28, 0xCE, 0x14, 0xFF, 0x90, 0x38, + 0x88, 0xAF, 0x73, 0x28, 0x31, 0x60, 0x9D, 0x59, + 0xA7, 0x50, 0x5E, 0x7E, 0xDB, 0xEF, 0xF8, 0x33, + 0xFA, 0xC1, 0x30, 0x99, 0x3B, 0xDD, 0xD2, 0x91, + 0xA1, 0x79, 0xD0, 0x7E, 0xE5, 0x56, 0xC4, 0xFF, + 0xC3, 0xF3, 0x6A, 0xBC, 0x87, 0x44, 0xB2, 0x67, + 0xAA, 0x59, 0x88, 0x8E, 0xBF, 0x7C, 0x99, 0xC7 + }, + { + 0x4E, 0x2B, 0x4D, 0x75, 0xC2, 0xE2, 0x96, 0x5C, + 0x7E, 0x30, 0xF4, 0x02, 0xF5, 0xE7, 0xDE, 0x65, + 0x58, 0x5F, 0x5D, 0x9F, 0x30, 0xDF, 0x18, 0x41, + 0xAE, 0xCB, 0x0B, 0x08, 0x2D, 0x99, 0x67, 0xDC, + 0x90, 0x64, 0xD8, 0x95, 0x3E, 0xD5, 0x8A, 0x5F, + 0x5C, 0x6D, 0xE6, 0x1A, 0x1A, 0xB4, 0x31, 0x65, + 0x96, 0xD1, 0x77, 0xD3, 0x73, 0x43, 0x91, 0xD9, + 0x57, 0x28, 0x41, 0xDC, 0xD6, 0xAF, 0xC8, 0x2E + }, + { + 0xF9, 0xDC, 0x51, 0x0B, 0x98, 0xF0, 0x32, 0x4F, + 0x7B, 0x5A, 0xAD, 0x3C, 0xC7, 0x34, 0x43, 0x2C, + 0x65, 0xE7, 0xA4, 0xCF, 0xA9, 0x66, 0x4B, 0xE0, + 0x07, 0x3B, 0x4E, 0x88, 0x8D, 0x43, 0xC2, 0xB4, + 0x73, 0x28, 0x64, 0xF4, 0x5A, 0x39, 0xAF, 0x2B, + 0xE1, 0xE3, 0x70, 0x7B, 0xB1, 0xD0, 0x89, 0xA5, + 0xB5, 0x2A, 0x5D, 0x40, 0x95, 0x31, 0x3E, 0xD7, + 0x8C, 0xC1, 0x9F, 0x2D, 0xDC, 0xC0, 0xC5, 0x2D + }, + { + 0xF1, 0xC9, 0x62, 0xF7, 0xE7, 0x17, 0x47, 0xCF, + 0xEB, 0xCE, 0xF1, 0x7A, 0xFD, 0x3F, 0x0F, 0x1E, + 0xCA, 0x65, 0xA7, 0x29, 0x3C, 0x2B, 0xEB, 0x68, + 0x88, 0xA1, 0x07, 0x19, 0x06, 0x8C, 0xDD, 0x73, + 0xCD, 0xB2, 0xFC, 0xCF, 0x07, 0xB6, 0x95, 0x1B, + 0x08, 0xF3, 0x2F, 0xB0, 0xC8, 0x5B, 0x92, 0xFA, + 0x52, 0xD7, 0x33, 0x15, 0x90, 0x2E, 0x72, 0xF9, + 0xE3, 0x22, 0xD2, 0x46, 0x1F, 0x31, 0x71, 0x2D + }, + { + 0x11, 0x22, 0x5C, 0x38, 0x11, 0x10, 0x41, 0x25, + 0x9A, 0x51, 0xFF, 0x96, 0x48, 0x97, 0x4A, 0x65, + 0x9D, 0xA7, 0xA4, 0xB4, 0x49, 0xB1, 0xA8, 0xDC, + 0xF8, 0x97, 0x8A, 0x92, 0x02, 0x45, 0xCD, 0xAF, + 0x6F, 0xFF, 0x11, 0x74, 0x06, 0x89, 0x4A, 0x2A, + 0x34, 0xA5, 0x83, 0x5E, 0xBF, 0x64, 0x38, 0x14, + 0x3D, 0x4A, 0x2D, 0xDE, 0xE9, 0xF5, 0x4C, 0x30, + 0x03, 0x53, 0x8B, 0xCA, 0x6A, 0x25, 0x49, 0xDD + }, + { + 0xF2, 0x88, 0x8A, 0xBD, 0x10, 0x67, 0x71, 0xE0, + 0x78, 0x30, 0x2B, 0xB4, 0xE8, 0x12, 0x81, 0xD7, + 0x1F, 0x3F, 0x08, 0x9C, 0x09, 0xCF, 0x5B, 0xAE, + 0x1C, 0x9B, 0xB8, 0xDC, 0x52, 0x92, 0x5E, 0x07, + 0x39, 0x20, 0x8D, 0xE3, 0xFC, 0xA6, 0x62, 0xA2, + 0xBB, 0x59, 0x22, 0x81, 0xC1, 0x12, 0x8D, 0x60, + 0xB3, 0x1A, 0x43, 0x46, 0x78, 0x10, 0x5C, 0xAF, + 0xEE, 0x92, 0xED, 0x21, 0x1E, 0xC2, 0x8D, 0x27 + }, + { + 0x03, 0xEF, 0xA8, 0x2F, 0xC7, 0x9D, 0xF3, 0xC6, + 0x49, 0xCB, 0x3F, 0x51, 0x9E, 0xA8, 0x11, 0xCC, + 0x79, 0xE9, 0x7A, 0x71, 0xF4, 0x6C, 0xFE, 0x58, + 0x30, 0x5F, 0xAC, 0xDC, 0x17, 0x5E, 0xDD, 0xBD, + 0xA4, 0x1B, 0x9C, 0x4D, 0xA2, 0x68, 0x50, 0x5F, + 0x64, 0xB6, 0x66, 0xA5, 0x3B, 0x8F, 0x19, 0x6A, + 0xAB, 0x16, 0x7E, 0x3F, 0xF1, 0x6F, 0xE7, 0xB0, + 0x13, 0xCA, 0xD1, 0x99, 0x29, 0x12, 0xA9, 0x4B + }, + { + 0x46, 0x96, 0xDF, 0xCA, 0xA4, 0x64, 0x4D, 0x15, + 0x50, 0xD9, 0x48, 0xCD, 0x38, 0xB4, 0x75, 0x5F, + 0x75, 0xD2, 0xFB, 0x66, 0xDE, 0xF1, 0x04, 0xE3, + 0x0F, 0x8B, 0xD3, 0xBC, 0xBC, 0x7A, 0xAA, 0x08, + 0xDC, 0xA5, 0xAA, 0xF0, 0x7F, 0x85, 0x1A, 0x1C, + 0x1E, 0xBA, 0xD0, 0x20, 0xEF, 0x6D, 0x72, 0x50, + 0x39, 0xA1, 0x7A, 0x4C, 0xE6, 0xBA, 0xB7, 0x4C, + 0xB9, 0x86, 0x65, 0xC2, 0xA3, 0xC9, 0x43, 0xF3 + }, + { + 0xC5, 0x2E, 0x92, 0x16, 0x05, 0x71, 0xDE, 0x8D, + 0x2B, 0x46, 0xAB, 0xA1, 0x4D, 0x5D, 0xDC, 0x8C, + 0x99, 0x54, 0xC0, 0x98, 0x75, 0x17, 0x51, 0x87, + 0x25, 0x6C, 0x1F, 0xED, 0xBD, 0x4F, 0x00, 0x41, + 0x17, 0x6F, 0x74, 0xCE, 0xBB, 0xB1, 0x4A, 0xBA, + 0xF1, 0x92, 0xA6, 0x59, 0x5F, 0x53, 0x62, 0xF8, + 0x0C, 0x30, 0x37, 0xC6, 0xFE, 0x54, 0x62, 0x9E, + 0x55, 0x1E, 0xFB, 0x4F, 0x4E, 0x8A, 0xEC, 0xB1 + }, + { + 0x9E, 0x66, 0xD0, 0x9D, 0xD0, 0x42, 0xA3, 0xB0, + 0x76, 0xE6, 0x62, 0xEF, 0xDC, 0xE1, 0x54, 0x08, + 0x55, 0xCB, 0xD6, 0x75, 0xE2, 0x31, 0x85, 0x30, + 0x77, 0xF8, 0x4E, 0xB1, 0xEA, 0x26, 0xC8, 0x81, + 0x18, 0xCC, 0xCB, 0x37, 0x47, 0xFD, 0xC9, 0x2E, + 0xB4, 0xF8, 0x78, 0x71, 0x7F, 0xD8, 0xF2, 0x28, + 0xC8, 0xD8, 0x93, 0x5C, 0x2C, 0xD4, 0x16, 0xB3, + 0x1B, 0xCC, 0x6B, 0x88, 0x39, 0xEB, 0x60, 0xCF + }, + { + 0xDE, 0x4D, 0x7C, 0x73, 0xD5, 0x51, 0x66, 0xBA, + 0x7B, 0x1E, 0x9A, 0xEC, 0x66, 0x1B, 0x93, 0x70, + 0xF3, 0x43, 0x33, 0xEF, 0x4F, 0xF7, 0x07, 0xC8, + 0x32, 0x96, 0x11, 0x30, 0x00, 0x22, 0xEC, 0x2F, + 0x42, 0x04, 0xEE, 0x3F, 0x5E, 0x8D, 0xBE, 0xDF, + 0xBC, 0xC7, 0x6B, 0x83, 0x4A, 0xB1, 0x73, 0x54, + 0xBB, 0x7D, 0xE1, 0xDD, 0x8D, 0xBD, 0x03, 0xDE, + 0xDA, 0x37, 0x67, 0xED, 0x8F, 0xE3, 0x1F, 0x02 + }, + { + 0x50, 0x50, 0xCF, 0x88, 0x0F, 0xFE, 0xFA, 0x7F, + 0xA2, 0x44, 0xE4, 0x48, 0xE8, 0xEA, 0xB2, 0x48, + 0x71, 0x90, 0x63, 0x2A, 0x37, 0xD6, 0x7B, 0x06, + 0xA8, 0x69, 0xB1, 0xB3, 0xDA, 0xD7, 0x3E, 0x56, + 0x29, 0xB4, 0x35, 0x10, 0x9A, 0x8C, 0x3F, 0x6B, + 0x9F, 0x8B, 0xBB, 0x41, 0xE8, 0xCA, 0x9F, 0x78, + 0x9C, 0xDB, 0x11, 0x1A, 0xF1, 0xA7, 0xAF, 0xD9, + 0x16, 0x5C, 0xF8, 0x41, 0x53, 0xD1, 0xC5, 0x89 + }, + { + 0xA8, 0x6B, 0x78, 0x4C, 0x74, 0x8F, 0x99, 0x0B, + 0x99, 0x8E, 0x6D, 0x30, 0xD7, 0x1E, 0x20, 0xCC, + 0x95, 0x22, 0x8D, 0x2B, 0x08, 0xDD, 0x85, 0xE2, + 0x9F, 0x63, 0xE4, 0xDE, 0x8D, 0x88, 0x39, 0xBD, + 0xF9, 0x35, 0xF4, 0x29, 0x15, 0x37, 0xAF, 0x50, + 0x14, 0xFE, 0x44, 0xC0, 0xB5, 0x78, 0xA0, 0x73, + 0xE4, 0xC9, 0x21, 0x7C, 0x7B, 0x05, 0x54, 0x2D, + 0x0C, 0x45, 0x07, 0x84, 0xC3, 0x0B, 0xAC, 0x8A + }, + { + 0x4B, 0xCD, 0x17, 0xEA, 0x40, 0x94, 0xF9, 0x4C, + 0x72, 0x94, 0xC8, 0xAC, 0xA2, 0xBA, 0x1C, 0xBF, + 0x2B, 0x7E, 0x7E, 0x68, 0xA2, 0x33, 0x02, 0xDE, + 0x1B, 0xC8, 0xA6, 0xC7, 0x4A, 0x2E, 0xCC, 0x4B, + 0x84, 0xA4, 0x94, 0x43, 0xF0, 0xB5, 0x40, 0x17, + 0x09, 0xDA, 0x07, 0xCB, 0x38, 0xEF, 0x7D, 0x4D, + 0x9B, 0xFF, 0x6D, 0x2D, 0xB9, 0x61, 0xFB, 0x6E, + 0x6A, 0xDE, 0x5A, 0x8F, 0x9C, 0x84, 0x09, 0x3C + }, + { + 0x48, 0x62, 0x2E, 0xAB, 0xFA, 0xAF, 0x24, 0xA6, + 0xEF, 0xFD, 0x1C, 0xE6, 0xBB, 0x9D, 0x62, 0xD4, + 0x70, 0xFE, 0x99, 0x60, 0x90, 0xBA, 0x33, 0x33, + 0xA6, 0x24, 0xDF, 0x86, 0x5A, 0x8C, 0x89, 0xDE, + 0xB3, 0xDA, 0x24, 0x93, 0x9F, 0x4F, 0xC5, 0x96, + 0x82, 0x5B, 0xFA, 0x85, 0x81, 0x65, 0x6D, 0xEB, + 0xF0, 0x44, 0x20, 0x39, 0x62, 0xBD, 0xAA, 0x6F, + 0x9D, 0xC3, 0x90, 0x9D, 0xBD, 0x9F, 0xDA, 0x38 + }, + { + 0x48, 0xE2, 0x0E, 0x67, 0xA3, 0x1F, 0x96, 0x1B, + 0x1C, 0xDA, 0x98, 0x04, 0xF8, 0x26, 0x4D, 0x05, + 0xC2, 0x57, 0x08, 0x11, 0x69, 0x56, 0x74, 0x3D, + 0x09, 0x31, 0x20, 0xD4, 0x5A, 0x0D, 0xE9, 0x3F, + 0x76, 0x01, 0x02, 0x26, 0xD2, 0x7C, 0xA6, 0x5D, + 0xA7, 0x7D, 0x15, 0x4F, 0xA9, 0x6F, 0x9A, 0x8C, + 0x6C, 0x7E, 0x83, 0x22, 0xCE, 0x3B, 0xFF, 0x58, + 0xB9, 0x71, 0x06, 0xD8, 0x59, 0xFF, 0xB8, 0x3F + }, + { + 0xA9, 0x07, 0x5D, 0xD4, 0x6E, 0x01, 0x22, 0x36, + 0xE6, 0x93, 0x1A, 0xD4, 0x3C, 0x30, 0x91, 0x0C, + 0xA8, 0x10, 0x55, 0x72, 0x32, 0x24, 0xE1, 0x7D, + 0x77, 0x55, 0xEF, 0xFD, 0xFE, 0xB2, 0x10, 0x16, + 0x21, 0x45, 0x84, 0x62, 0x76, 0x9E, 0xFE, 0x52, + 0xD2, 0xD7, 0x40, 0x66, 0x5C, 0x1C, 0xB7, 0xAD, + 0x90, 0xA2, 0x8C, 0xAB, 0x34, 0x98, 0xEA, 0x8A, + 0x6C, 0x6C, 0xED, 0x14, 0x23, 0x8C, 0xFF, 0x96 + }, + { + 0xAC, 0xD4, 0xF6, 0x50, 0x1B, 0xEE, 0xEF, 0x4F, + 0xE0, 0x36, 0xEC, 0xD6, 0x0D, 0x21, 0x64, 0xF9, + 0x9D, 0xB5, 0xD8, 0x66, 0xF3, 0x0E, 0xF0, 0x98, + 0xBD, 0x98, 0x45, 0x86, 0x31, 0x1C, 0x68, 0x61, + 0x4F, 0x4A, 0x08, 0x9E, 0x37, 0xED, 0xA8, 0xCA, + 0xF2, 0x10, 0x4F, 0xCB, 0xF8, 0x0E, 0xC1, 0xC9, + 0x64, 0xDB, 0xB0, 0x4B, 0xB3, 0x47, 0x01, 0xE7, + 0x7B, 0x8B, 0x86, 0xC7, 0x33, 0x54, 0x11, 0x65 + }, + { + 0x09, 0x7C, 0x4E, 0xBB, 0x6E, 0xBB, 0x7C, 0x76, + 0x99, 0xC5, 0xE3, 0x0D, 0x9B, 0x5A, 0xB4, 0xD5, + 0x59, 0x7B, 0x04, 0xE9, 0xE4, 0x2F, 0xFD, 0x76, + 0x0A, 0x67, 0xFB, 0x32, 0x47, 0x31, 0x2A, 0x80, + 0x30, 0x3E, 0x66, 0x6F, 0xC1, 0x72, 0xF9, 0x09, + 0x87, 0x9B, 0x61, 0x25, 0xDA, 0xF6, 0xAA, 0xDB, + 0x89, 0xFE, 0xA3, 0x76, 0xF4, 0xB9, 0xC7, 0x2A, + 0x56, 0xE4, 0x80, 0xC2, 0xAD, 0xC1, 0xD4, 0x62 + }, + { + 0xA6, 0x2D, 0xD8, 0x88, 0x79, 0xE5, 0xC4, 0xE9, + 0x1B, 0x8D, 0x59, 0xDB, 0xAC, 0xE7, 0x1C, 0x54, + 0xBD, 0xFD, 0x16, 0xD4, 0x96, 0x4F, 0x2A, 0x51, + 0x08, 0x1F, 0xEE, 0x3B, 0xFA, 0x12, 0xEA, 0xAA, + 0x08, 0xB5, 0x02, 0x34, 0x19, 0x0E, 0x22, 0xE5, + 0x36, 0xCA, 0xDE, 0xCD, 0x7A, 0x46, 0x04, 0x6E, + 0x22, 0x76, 0x16, 0xB5, 0xD4, 0xC1, 0xEF, 0xE9, + 0x86, 0x44, 0x16, 0x2F, 0x16, 0x58, 0x75, 0x0B + }, + { + 0xFE, 0x44, 0x38, 0xAD, 0x52, 0xEC, 0xF4, 0x25, + 0x34, 0x96, 0x4C, 0xC7, 0x69, 0xDD, 0x0A, 0xB9, + 0xD1, 0x2D, 0x85, 0x2E, 0xCA, 0x90, 0xFF, 0x4D, + 0xDE, 0x55, 0xB1, 0x17, 0xE5, 0x5C, 0x64, 0x40, + 0x21, 0x7F, 0x80, 0x24, 0x46, 0x8B, 0xF7, 0xB0, + 0xF7, 0x09, 0x08, 0x3D, 0x23, 0x10, 0xF0, 0xC4, + 0x1E, 0xD4, 0x04, 0x4F, 0x58, 0x6F, 0x21, 0x1E, + 0x57, 0xAF, 0x31, 0xAD, 0x7E, 0x92, 0x3F, 0xB3 + }, + { + 0xC9, 0x55, 0x0C, 0xFB, 0xE7, 0x63, 0xA9, 0xB7, + 0x55, 0x26, 0x6F, 0x98, 0x66, 0x9C, 0xE1, 0xD4, + 0x28, 0xA9, 0x41, 0xC6, 0x21, 0x10, 0x76, 0x37, + 0x7B, 0xAF, 0x97, 0x8E, 0x47, 0x40, 0x5F, 0xCE, + 0x03, 0x18, 0x61, 0x5F, 0xE6, 0x2D, 0xE6, 0xEF, + 0x4F, 0xC5, 0xC0, 0xA5, 0xA9, 0xDA, 0xF6, 0xF7, + 0x87, 0x1F, 0xC7, 0x14, 0x0F, 0x30, 0xF6, 0x57, + 0x25, 0x0E, 0xDE, 0xC8, 0xD5, 0x61, 0x61, 0x76 + }, + { + 0x88, 0x49, 0xD8, 0x37, 0xDC, 0x30, 0xC3, 0x81, + 0x62, 0xA6, 0x8B, 0x3D, 0x11, 0x4E, 0xD6, 0x3C, + 0xA2, 0x02, 0xEB, 0x25, 0x03, 0x19, 0x10, 0x8A, + 0x27, 0x15, 0x1C, 0x7A, 0x46, 0x9B, 0x47, 0xFF, + 0xEE, 0xFA, 0x53, 0xDB, 0x88, 0x70, 0x96, 0xDF, + 0xBF, 0x28, 0xE1, 0x0F, 0x3D, 0xB6, 0x19, 0xB1, + 0x59, 0x09, 0xBF, 0x56, 0x07, 0x65, 0xED, 0x4E, + 0x4B, 0x16, 0xD0, 0x00, 0x90, 0xDC, 0xAB, 0xBE + }, + { + 0xF7, 0x5D, 0x93, 0x08, 0x55, 0xDA, 0xC0, 0xF8, + 0xE3, 0x1C, 0xBC, 0x36, 0xFF, 0x1E, 0xA8, 0xA5, + 0x34, 0x75, 0x8D, 0xF6, 0x46, 0x91, 0xDE, 0xFC, + 0x12, 0x57, 0x9B, 0x7E, 0x97, 0x80, 0x38, 0x89, + 0x02, 0x9A, 0xFA, 0x10, 0x19, 0x9B, 0x54, 0x65, + 0x98, 0xB2, 0x1D, 0xCE, 0xB6, 0xAE, 0x5F, 0x7D, + 0x28, 0x6B, 0x08, 0x24, 0xF6, 0xB8, 0xBC, 0x51, + 0x41, 0x6F, 0xCB, 0xE4, 0x76, 0xD4, 0x78, 0x16 + }, + { + 0xF1, 0x98, 0x65, 0x8F, 0x28, 0x35, 0xEF, 0x8E, + 0x8E, 0xA9, 0x2D, 0x1A, 0x81, 0xAB, 0x0B, 0x23, + 0x39, 0x88, 0x73, 0xB1, 0x43, 0x20, 0xD7, 0xA1, + 0x4A, 0x68, 0x86, 0x3B, 0x16, 0x37, 0xBF, 0xC9, + 0x47, 0x9B, 0x4D, 0xC7, 0x8B, 0x99, 0xFB, 0x90, + 0x60, 0x27, 0xEB, 0xD1, 0x6A, 0x72, 0xCF, 0xCA, + 0xFD, 0x69, 0xE4, 0xAE, 0x0D, 0x4F, 0x97, 0xB8, + 0x58, 0x4B, 0x99, 0x3E, 0x77, 0x03, 0x3C, 0x6F + }, + { + 0x85, 0x45, 0x9C, 0x3A, 0xE2, 0xD5, 0xCA, 0x42, + 0x91, 0x3C, 0x39, 0xFF, 0x27, 0x06, 0xEF, 0x6E, + 0x20, 0x4C, 0xC6, 0x14, 0x82, 0xB2, 0x9A, 0x25, + 0xF6, 0xDD, 0x4D, 0x9A, 0x1D, 0x2D, 0x8D, 0x93, + 0xAC, 0xE4, 0x54, 0x6D, 0x33, 0x0B, 0xC5, 0x4D, + 0xC5, 0x0A, 0x24, 0xA7, 0x12, 0x3B, 0xCE, 0x4C, + 0x52, 0x1C, 0x68, 0x5C, 0xDB, 0xEB, 0x4C, 0x50, + 0xAB, 0xB4, 0xD0, 0x33, 0xE3, 0xE8, 0xB9, 0x88 + }, + { + 0x88, 0x3D, 0x12, 0xDA, 0x9E, 0xEE, 0x1C, 0xD7, + 0xE0, 0x73, 0xFD, 0x83, 0xB4, 0x8D, 0x50, 0xE9, + 0xB3, 0x6C, 0x60, 0xD1, 0xB5, 0x33, 0xCB, 0x98, + 0xA2, 0x44, 0xF7, 0xC9, 0x5D, 0x42, 0x7C, 0x17, + 0x76, 0x56, 0x08, 0xDE, 0x15, 0x0A, 0xE7, 0x9D, + 0xBE, 0xD8, 0x86, 0x83, 0x68, 0x6A, 0xA6, 0xC7, + 0xFB, 0x3B, 0x86, 0xF4, 0x7A, 0xCA, 0xE4, 0x41, + 0xF9, 0x5A, 0xFC, 0x11, 0x81, 0xE0, 0x17, 0x09 + }, + { + 0xF8, 0x29, 0x9F, 0x4F, 0x8C, 0x0F, 0x09, 0x6B, + 0x14, 0xB3, 0xE8, 0x7F, 0xCC, 0x88, 0x23, 0x15, + 0x26, 0x76, 0xD5, 0x98, 0x7A, 0x89, 0x92, 0xF4, + 0x7D, 0xEF, 0xDC, 0xDC, 0x0A, 0xFA, 0xF6, 0x84, + 0xB6, 0x6C, 0x05, 0x3B, 0xE4, 0xFE, 0xD1, 0x5D, + 0x35, 0x85, 0x86, 0x74, 0x68, 0xCD, 0xC9, 0xA0, + 0x5D, 0x17, 0x59, 0x3A, 0xC4, 0x53, 0xA7, 0x8D, + 0xF7, 0x0A, 0x57, 0xAB, 0xE5, 0x6B, 0x6D, 0x58 + }, + { + 0x5D, 0x5B, 0x24, 0x6D, 0x90, 0x9D, 0xB3, 0xED, + 0x29, 0x0B, 0xB6, 0x37, 0xA4, 0x04, 0xB3, 0x60, + 0x10, 0x7C, 0x7C, 0x00, 0x91, 0x2F, 0x49, 0x29, + 0xEC, 0x10, 0xE7, 0x04, 0x2C, 0x5E, 0xAE, 0xD2, + 0x83, 0xAD, 0x5C, 0xF2, 0xD0, 0x36, 0x5B, 0x67, + 0x61, 0x5C, 0xB4, 0x56, 0x34, 0x5A, 0xEF, 0x50, + 0xF4, 0x8A, 0x2B, 0x81, 0xEA, 0x92, 0x59, 0xDA, + 0x7E, 0x82, 0xC1, 0x0B, 0x5E, 0x82, 0xFE, 0x9A + }, + { + 0xC5, 0x90, 0xC3, 0x62, 0x23, 0x6D, 0xFA, 0xC4, + 0x60, 0x10, 0xDC, 0x85, 0x2A, 0x9B, 0xCF, 0x53, + 0x26, 0xCD, 0x69, 0xD9, 0x22, 0xDC, 0x0B, 0x9B, + 0x27, 0x4C, 0xD6, 0xBA, 0x08, 0x43, 0xD7, 0xFA, + 0x3B, 0x76, 0x5C, 0x07, 0xC8, 0x77, 0xA0, 0x3E, + 0x99, 0x90, 0xEA, 0xA9, 0x4F, 0x47, 0x77, 0x54, + 0x0F, 0x14, 0xB2, 0x47, 0x92, 0xA5, 0xF1, 0xBC, + 0x99, 0x67, 0x8B, 0xA5, 0xED, 0xF7, 0xA8, 0x15 + }, + { + 0x23, 0x65, 0xF1, 0xFC, 0xB5, 0x77, 0x65, 0x92, + 0x87, 0x71, 0x8A, 0x29, 0x59, 0xE7, 0x03, 0x88, + 0xC8, 0x04, 0xA8, 0xDB, 0x86, 0x18, 0x3D, 0xD6, + 0x3D, 0x58, 0x1A, 0xB1, 0x15, 0x7B, 0xF4, 0xA0, + 0x05, 0x79, 0x90, 0x1D, 0xE1, 0xAF, 0xC6, 0x7B, + 0xA6, 0x4C, 0xF6, 0x6A, 0x70, 0xEB, 0xF9, 0x2F, + 0x37, 0x74, 0x4D, 0x13, 0xDF, 0xFC, 0xAE, 0xF1, + 0x0E, 0xC2, 0x11, 0x96, 0x31, 0xB2, 0x17, 0x7B + }, + { + 0xEE, 0xC8, 0x81, 0x2B, 0x11, 0x00, 0x22, 0x19, + 0xD6, 0x71, 0x84, 0x27, 0x4C, 0x8A, 0xAB, 0xFF, + 0xC0, 0x5A, 0x37, 0x14, 0xD7, 0x5C, 0x24, 0xB8, + 0xAD, 0x92, 0x11, 0x94, 0x9F, 0xE1, 0x1F, 0x0F, + 0xE1, 0x7F, 0xD3, 0xA5, 0xEE, 0x21, 0xB9, 0x10, + 0xBC, 0xF1, 0x78, 0xB3, 0x4E, 0x13, 0x52, 0xB1, + 0x61, 0xC7, 0x86, 0x7C, 0x14, 0xED, 0x0C, 0x3B, + 0x9D, 0xF0, 0xDB, 0xCA, 0x15, 0xA4, 0xF5, 0x01 + }, + { + 0x7B, 0xA1, 0x97, 0xA8, 0x4C, 0x4E, 0x3D, 0xE1, + 0x91, 0xDF, 0x2A, 0xAC, 0x99, 0x7C, 0x88, 0x6F, + 0xC6, 0x58, 0x1F, 0x2B, 0xEC, 0xD0, 0xDD, 0x28, + 0xD8, 0xC3, 0x6F, 0xD1, 0xA8, 0xB4, 0x3E, 0x34, + 0xDD, 0xDE, 0xFE, 0x94, 0xAD, 0xD2, 0xB8, 0xC1, + 0x76, 0x6C, 0xF4, 0x78, 0x0D, 0x77, 0xDA, 0x21, + 0x95, 0x6B, 0xBE, 0xB6, 0xCA, 0x95, 0xE9, 0x0A, + 0x25, 0x04, 0x8B, 0x1B, 0xA0, 0x24, 0xE2, 0x8C + }, + { + 0xD9, 0x20, 0x2F, 0x82, 0x68, 0x19, 0xCD, 0x75, + 0x5A, 0x42, 0xE4, 0xC7, 0x1B, 0xCE, 0x7C, 0x09, + 0xFD, 0xB2, 0xF5, 0x70, 0x77, 0xA2, 0x0E, 0x68, + 0x93, 0x06, 0xEF, 0xFB, 0x16, 0x5C, 0x33, 0xE5, + 0x7A, 0x27, 0x46, 0xED, 0xE6, 0xC0, 0x52, 0x2B, + 0xFA, 0xBA, 0x78, 0xA1, 0x51, 0x2A, 0xD8, 0x79, + 0x6B, 0xF1, 0x8D, 0x2C, 0x32, 0x53, 0xA6, 0xCE, + 0x47, 0x40, 0x77, 0xF7, 0x97, 0x94, 0x28, 0xE3 + }, + { + 0x9F, 0xDE, 0xCD, 0x2E, 0x34, 0xBC, 0x21, 0x57, + 0x39, 0x45, 0x97, 0x07, 0xF9, 0x62, 0x1C, 0x29, + 0xC2, 0x66, 0xD8, 0x2C, 0x7D, 0x98, 0x04, 0xB8, + 0x55, 0xF0, 0x3F, 0x33, 0x73, 0x32, 0xBD, 0x7E, + 0x5C, 0x85, 0xFF, 0x98, 0x77, 0xA0, 0x39, 0x5A, + 0x6F, 0x9A, 0x6E, 0x1F, 0x56, 0x27, 0x0F, 0xB6, + 0x08, 0x06, 0x42, 0xFD, 0x17, 0xD6, 0x2A, 0x01, + 0x8B, 0xAA, 0x5B, 0xF0, 0xEC, 0xFF, 0x83, 0x24 + }, + { + 0x27, 0x63, 0xF6, 0x43, 0x23, 0x18, 0x96, 0xA6, + 0xE6, 0xAC, 0xC4, 0xA7, 0x57, 0x74, 0x6D, 0x1B, + 0x59, 0xFD, 0xF8, 0xBA, 0x63, 0x2A, 0x0D, 0x8B, + 0x51, 0x71, 0xD5, 0x32, 0x7A, 0x97, 0x00, 0x70, + 0xCE, 0xC3, 0xC5, 0x50, 0xEC, 0xDF, 0x63, 0xD0, + 0x91, 0xAD, 0x85, 0x06, 0x63, 0x15, 0x6C, 0x0B, + 0x54, 0x1F, 0xB8, 0xD0, 0x3E, 0xAB, 0xB8, 0xA5, + 0x64, 0x61, 0x72, 0x0C, 0x2E, 0xA7, 0xCA, 0xE7 + }, + { + 0x0A, 0x93, 0x8C, 0x7E, 0xD3, 0x79, 0xA8, 0xC6, + 0x89, 0x80, 0x18, 0xF2, 0xB2, 0xAD, 0x92, 0xBF, + 0xC0, 0xA5, 0x99, 0xCB, 0x52, 0xAF, 0xF1, 0x69, + 0x10, 0x36, 0xE0, 0xC2, 0x59, 0xD4, 0xEB, 0x35, + 0x6E, 0xB2, 0x91, 0xE6, 0x16, 0xAF, 0x24, 0xF8, + 0x57, 0xF9, 0x06, 0xB5, 0x51, 0x82, 0xE2, 0x8A, + 0xFE, 0x3C, 0x90, 0x49, 0x5C, 0xCD, 0x50, 0xAC, + 0x1C, 0xBF, 0x99, 0x79, 0x97, 0x49, 0x35, 0x38 + }, + { + 0x1E, 0x02, 0x37, 0x38, 0xEB, 0x63, 0x8A, 0x27, + 0x1D, 0xAE, 0xE9, 0x2F, 0xC3, 0x35, 0xC5, 0x7F, + 0xF5, 0x66, 0x7A, 0xF4, 0xB8, 0xBB, 0xD3, 0x89, + 0x11, 0x66, 0x0B, 0x93, 0xC6, 0xBA, 0x43, 0x4E, + 0x89, 0x29, 0x0F, 0x4F, 0x68, 0xB2, 0x8C, 0x07, + 0xA1, 0xFD, 0x25, 0x06, 0xB9, 0x91, 0x21, 0xC0, + 0x3F, 0x2D, 0x0E, 0x4D, 0x15, 0x9D, 0x6B, 0xAB, + 0x34, 0x98, 0xE0, 0x2B, 0xE2, 0xFF, 0x02, 0x19 + }, + { + 0x38, 0xB2, 0xB1, 0x83, 0x0F, 0x6A, 0x2D, 0xF3, + 0xFB, 0xCA, 0x34, 0xB4, 0x11, 0xCA, 0x56, 0xDC, + 0x27, 0xAA, 0x23, 0x94, 0x36, 0xEC, 0x03, 0x3B, + 0x2F, 0x40, 0x23, 0x80, 0x9A, 0xE0, 0x0D, 0x31, + 0xAC, 0x24, 0x97, 0x8D, 0x26, 0xA7, 0x21, 0xE5, + 0x37, 0x78, 0xA3, 0x5D, 0xEE, 0x93, 0xC9, 0x54, + 0xE5, 0xE5, 0x7D, 0xED, 0x89, 0xBD, 0xE7, 0xCF, + 0xC2, 0x92, 0x5F, 0x9B, 0x2A, 0x3C, 0x89, 0x92 + }, + { + 0xC7, 0x32, 0xB5, 0x78, 0x25, 0x6F, 0x91, 0x74, + 0xCF, 0x99, 0x0C, 0x50, 0xDB, 0x74, 0xB2, 0x2D, + 0x74, 0xBF, 0x17, 0xBB, 0x0F, 0xAC, 0x77, 0x68, + 0x2B, 0xF2, 0x22, 0x50, 0x59, 0x94, 0xA7, 0xD1, + 0xD4, 0xBC, 0xC2, 0xB7, 0x44, 0x6F, 0x1D, 0xCF, + 0x8D, 0x8B, 0x95, 0x32, 0x76, 0xFB, 0x43, 0x6A, + 0xA2, 0xA4, 0xE0, 0x9B, 0x63, 0xDC, 0xD4, 0xCD, + 0xAA, 0xFD, 0x24, 0x0C, 0xC5, 0x03, 0x5F, 0x4F + }, + { + 0xF6, 0xDD, 0x0A, 0x98, 0x3D, 0x0C, 0xBB, 0x51, + 0xFA, 0x5F, 0x48, 0xE3, 0x6C, 0xB2, 0x0C, 0xEF, + 0x02, 0x04, 0x3C, 0xAC, 0x12, 0x5A, 0xF6, 0x20, + 0x84, 0x13, 0x78, 0x13, 0x0A, 0x32, 0x72, 0xDF, + 0xDC, 0xDF, 0x88, 0x73, 0xA3, 0x71, 0x05, 0xBA, + 0xA5, 0xD7, 0xF0, 0xA0, 0xC9, 0x3E, 0xC5, 0x09, + 0xC8, 0x7F, 0x6A, 0xC5, 0xC6, 0x00, 0x58, 0x32, + 0xED, 0xF0, 0x8A, 0x5A, 0x3E, 0xFE, 0xD0, 0x5B + }, + { + 0x46, 0xDE, 0x92, 0x41, 0xC0, 0x26, 0x87, 0xF5, + 0xEF, 0xE6, 0xAD, 0xA6, 0xFE, 0x0A, 0x32, 0xD9, + 0x15, 0x52, 0x3B, 0xDA, 0x7F, 0xB1, 0x55, 0x41, + 0x98, 0xA0, 0x44, 0xE2, 0x0B, 0x6F, 0x73, 0x8F, + 0x16, 0x89, 0x3E, 0x60, 0xC3, 0xCE, 0x24, 0xDD, + 0xFC, 0x8F, 0x04, 0x9C, 0xAE, 0xCF, 0x23, 0x9C, + 0xAD, 0xCF, 0x38, 0x42, 0xC7, 0x02, 0x8C, 0x4D, + 0x70, 0x2C, 0x7E, 0x6A, 0x0C, 0x70, 0x95, 0x12 + }, + { + 0x3F, 0xAA, 0x99, 0x14, 0x9D, 0xE3, 0x54, 0x76, + 0x8B, 0x96, 0x8F, 0xC2, 0xBC, 0x0D, 0x5C, 0xA2, + 0xE9, 0xE9, 0xC9, 0xFE, 0x3D, 0x3A, 0x00, 0xA8, + 0x2A, 0x40, 0xD0, 0x09, 0xF9, 0x97, 0x7B, 0x1D, + 0x5B, 0xBE, 0x1B, 0xCA, 0x35, 0xBB, 0x34, 0xA3, + 0xF8, 0xFF, 0x8F, 0xEE, 0xE6, 0x5A, 0x72, 0x01, + 0x4C, 0x87, 0x19, 0x6D, 0xC1, 0xA9, 0x02, 0xEC, + 0xEF, 0x3E, 0x88, 0xB7, 0xB2, 0xC0, 0xAA, 0xC6 + }, + { + 0xAB, 0x56, 0x52, 0xD1, 0xE5, 0x47, 0xBC, 0xAB, + 0x93, 0x26, 0x32, 0xEE, 0x67, 0x75, 0xED, 0x5F, + 0x06, 0xBD, 0x9C, 0x43, 0x6B, 0xFB, 0xD9, 0xD3, + 0xE3, 0xE9, 0xFC, 0xEB, 0xBA, 0x0A, 0x9C, 0x27, + 0x81, 0x54, 0x09, 0x4A, 0x4C, 0x1F, 0xC1, 0x4C, + 0x79, 0xE5, 0x99, 0x0E, 0x85, 0x81, 0x55, 0xB3, + 0x9C, 0xDF, 0x66, 0x26, 0x42, 0x19, 0xE6, 0x7E, + 0x84, 0x1F, 0x8B, 0xF7, 0xDF, 0xF0, 0xEB, 0xD4 + }, + { + 0x27, 0xA0, 0x35, 0x7A, 0x4D, 0x97, 0xC7, 0xBA, + 0xD0, 0x7A, 0xA6, 0xB5, 0xB1, 0x16, 0x89, 0x50, + 0xDF, 0x84, 0x3D, 0x34, 0xF6, 0x54, 0x73, 0xD2, + 0x1D, 0x06, 0xB1, 0x11, 0x65, 0xB0, 0x89, 0xD4, + 0x58, 0x56, 0xA5, 0x09, 0xBC, 0x4B, 0x7D, 0x26, + 0x2B, 0x31, 0x69, 0x52, 0x8A, 0xC4, 0xBF, 0x87, + 0xE8, 0xEC, 0xB7, 0x09, 0xF1, 0x65, 0x7A, 0xA2, + 0x71, 0xB0, 0xC1, 0xB8, 0xE2, 0x03, 0xA0, 0x4E + }, + { + 0x1F, 0x4E, 0x59, 0x8B, 0xC1, 0xA2, 0x19, 0x93, + 0x2F, 0x22, 0x8F, 0x83, 0xE5, 0x2F, 0xEF, 0xBC, + 0x6B, 0x7C, 0x86, 0x1F, 0x1A, 0x55, 0xDE, 0xCB, + 0x17, 0xCB, 0x11, 0x8C, 0x15, 0x10, 0xC2, 0xAF, + 0x63, 0xFB, 0x37, 0x5C, 0x01, 0x0C, 0x92, 0xC4, + 0xE4, 0xB7, 0x48, 0x01, 0x9A, 0xBC, 0x8B, 0xE0, + 0x1C, 0x84, 0xF9, 0x04, 0x59, 0x2A, 0xFE, 0xC4, + 0x96, 0x3E, 0xEC, 0x31, 0x6C, 0xE9, 0x26, 0xF5 + }, + { + 0x3B, 0xA9, 0xB4, 0xC8, 0xE1, 0x08, 0x9D, 0x41, + 0x33, 0x43, 0x80, 0x06, 0x66, 0x42, 0x38, 0x91, + 0xBB, 0x66, 0xC9, 0xC9, 0xE0, 0x90, 0x42, 0x80, + 0x67, 0x92, 0xB4, 0x37, 0x3C, 0xEF, 0x2B, 0x56, + 0xA9, 0xD7, 0xB6, 0xFE, 0xDD, 0xF2, 0x6F, 0xF0, + 0xFD, 0x2B, 0xDB, 0x7B, 0xB2, 0xA9, 0xAB, 0x84, + 0x3B, 0x17, 0xD1, 0x29, 0x70, 0xB1, 0x28, 0x8D, + 0x98, 0x89, 0xF0, 0x5F, 0xE2, 0xC3, 0x38, 0xA3 + }, + { + 0xA6, 0x69, 0x85, 0x19, 0xE1, 0x9E, 0x75, 0xB6, + 0x19, 0xB9, 0x53, 0x88, 0x0B, 0xD7, 0x70, 0xD8, + 0x0A, 0x6E, 0xCE, 0xDB, 0x82, 0x1E, 0x25, 0xA9, + 0x68, 0x72, 0x12, 0xF4, 0x52, 0x31, 0x20, 0xAF, + 0x90, 0xCA, 0x2C, 0xF4, 0xEF, 0x5F, 0x08, 0xE3, + 0x14, 0x84, 0x8C, 0x0F, 0x8C, 0xAF, 0x46, 0xFC, + 0x46, 0x42, 0x6E, 0x54, 0x95, 0x3D, 0xDA, 0xA5, + 0xE4, 0x1A, 0x5A, 0x4D, 0xFE, 0x0A, 0x45, 0x3D + }, + { + 0x76, 0x1A, 0x86, 0x06, 0xD1, 0x35, 0xA9, 0xD4, + 0x2D, 0xA2, 0x05, 0x2B, 0xA6, 0x86, 0xE3, 0x71, + 0x88, 0x9C, 0xF0, 0xF3, 0x05, 0xF8, 0xDB, 0x42, + 0x2F, 0x92, 0xF8, 0x23, 0x8B, 0x98, 0x55, 0xC5, + 0xA4, 0x28, 0xD0, 0x77, 0xBF, 0x96, 0x28, 0x5E, + 0x81, 0x82, 0x8F, 0xDB, 0x45, 0xA9, 0x3C, 0x2B, + 0xB1, 0xD9, 0xAA, 0xE0, 0x09, 0xCB, 0xC5, 0x8C, + 0x4D, 0x46, 0xB2, 0xA8, 0xBE, 0x07, 0x27, 0x19 + }, + { + 0x84, 0xA1, 0x4B, 0xAF, 0x5A, 0x02, 0x50, 0xA6, + 0x27, 0xEC, 0xDB, 0x87, 0xAF, 0x3E, 0x01, 0xC5, + 0xF9, 0xAB, 0x1E, 0x54, 0x20, 0x7D, 0x98, 0xAE, + 0xAE, 0x6D, 0x57, 0xBD, 0x68, 0x80, 0xB1, 0xD7, + 0xDC, 0xA4, 0x04, 0xDB, 0x3B, 0x90, 0x78, 0x9F, + 0x21, 0x70, 0xE5, 0x4A, 0xE4, 0x94, 0x8F, 0xA4, + 0x76, 0x47, 0xC2, 0x8C, 0x19, 0x3D, 0x22, 0x5B, + 0xB8, 0x57, 0xAA, 0x9A, 0x86, 0x78, 0xB4, 0x2F + }, + { + 0x15, 0xDC, 0xAD, 0x59, 0x9F, 0x7D, 0x97, 0x1A, + 0x12, 0x50, 0x55, 0xE6, 0x9D, 0x23, 0xB8, 0xEC, + 0xBD, 0x04, 0x2F, 0xAF, 0xB6, 0x9D, 0xB3, 0xC2, + 0x1E, 0xF9, 0xAC, 0x4B, 0xD2, 0x5A, 0xF4, 0xA8, + 0x87, 0x84, 0x28, 0xF0, 0x4B, 0x56, 0xD5, 0x16, + 0x72, 0xED, 0xC9, 0xD6, 0x81, 0xA9, 0x54, 0xC1, + 0xE7, 0x17, 0x67, 0x5A, 0x72, 0x50, 0xCA, 0xDA, + 0xEE, 0xE7, 0x5D, 0x9F, 0x48, 0x13, 0x39, 0xEF + }, + { + 0x8D, 0x23, 0x48, 0xFB, 0xF0, 0x39, 0x7B, 0x97, + 0x89, 0x4C, 0x4F, 0xCA, 0x74, 0x6A, 0x1A, 0xCE, + 0x0B, 0x38, 0x52, 0xFA, 0x7A, 0x02, 0x93, 0x97, + 0x68, 0x43, 0x10, 0x2A, 0x4D, 0xC9, 0xFB, 0xB8, + 0xC2, 0x1D, 0x8F, 0x52, 0x65, 0x43, 0x77, 0xE3, + 0x0A, 0x56, 0x15, 0x70, 0x39, 0x5B, 0x8C, 0xC5, + 0xCF, 0xCA, 0x3B, 0x41, 0x56, 0xEE, 0x48, 0x4E, + 0xAF, 0xA1, 0x0E, 0x94, 0x85, 0xD3, 0xC0, 0x38 + }, + { + 0x97, 0x12, 0x39, 0xC9, 0xCC, 0x49, 0xA4, 0x33, + 0x87, 0x91, 0xFE, 0xF6, 0xFC, 0x71, 0xEC, 0x87, + 0x43, 0xA8, 0x06, 0xF3, 0x42, 0xDF, 0x81, 0x5A, + 0x48, 0xE8, 0xD5, 0x9B, 0xC6, 0x69, 0x44, 0xFD, + 0xB7, 0x5D, 0xBC, 0xBE, 0x55, 0x32, 0x4D, 0x0A, + 0xC4, 0x64, 0xEF, 0xFF, 0x41, 0xDB, 0xC6, 0xFD, + 0x60, 0xEE, 0x68, 0x56, 0x3B, 0xF3, 0x78, 0xFF, + 0x5F, 0xD5, 0x6A, 0x42, 0x59, 0xE3, 0x73, 0xA1 + }, + { + 0xC7, 0xF1, 0x6C, 0xF4, 0xE3, 0x7D, 0x25, 0xF0, + 0x09, 0xB9, 0x95, 0xDE, 0xA1, 0x1D, 0x52, 0x9C, + 0xBA, 0x55, 0xF0, 0xAB, 0xF8, 0x78, 0x97, 0x24, + 0xA8, 0x0A, 0xA6, 0xAC, 0x7C, 0xEC, 0x1B, 0xBC, + 0xBA, 0x02, 0xDD, 0x5E, 0xDF, 0xE3, 0xC0, 0xC3, + 0x0A, 0x75, 0xC8, 0x36, 0xE7, 0x45, 0x1E, 0x0C, + 0x62, 0x64, 0x1A, 0x96, 0x2C, 0x63, 0xB2, 0x06, + 0xF7, 0x14, 0x05, 0x67, 0xC4, 0x0D, 0xDA, 0xBB + }, + { + 0x04, 0x1B, 0x0F, 0x52, 0x1E, 0xD8, 0xB9, 0xE4, + 0x0C, 0xCE, 0x96, 0xDC, 0xC6, 0x28, 0xCD, 0xED, + 0x49, 0x17, 0x17, 0x9D, 0xB6, 0x13, 0x93, 0xBE, + 0x75, 0xAF, 0x7C, 0x91, 0x75, 0x5E, 0x29, 0xB3, + 0xE5, 0xC0, 0x22, 0xEF, 0x7D, 0xCC, 0x16, 0x29, + 0xDD, 0x9C, 0x2C, 0xB4, 0xAA, 0xBB, 0xE5, 0x43, + 0x2B, 0x56, 0xB8, 0xCB, 0xD4, 0x54, 0xCF, 0x21, + 0x4F, 0xEE, 0x2C, 0xE2, 0x51, 0x3B, 0xCC, 0xAA + }, + { + 0x4F, 0x39, 0xEE, 0x2F, 0x9D, 0x16, 0x6D, 0xA7, + 0x06, 0x16, 0xE8, 0x76, 0x02, 0xF7, 0xE2, 0xB1, + 0xDA, 0x8A, 0xC6, 0x6E, 0x1F, 0x80, 0x5B, 0x66, + 0xA2, 0xAF, 0xAB, 0xA7, 0x50, 0x68, 0x7E, 0x0E, + 0xBF, 0xD3, 0x09, 0xA0, 0xED, 0x67, 0xB1, 0xDB, + 0xFE, 0x3A, 0xC2, 0xD9, 0x00, 0x17, 0xC3, 0x92, + 0x78, 0xD3, 0x73, 0xF7, 0x3F, 0x8D, 0xD1, 0x35, + 0xC4, 0x65, 0xFA, 0xBF, 0xD6, 0xD2, 0xF0, 0x36 + }, + { + 0xDE, 0x50, 0x17, 0x91, 0xF2, 0x10, 0xB1, 0x8E, + 0x40, 0x2A, 0x43, 0x8D, 0xD2, 0x22, 0x41, 0x7D, + 0x43, 0x29, 0xF4, 0x6D, 0xA1, 0x67, 0xB9, 0xC7, + 0x98, 0xEC, 0xF0, 0x36, 0xD7, 0xB5, 0x63, 0x40, + 0x58, 0x22, 0xBB, 0x99, 0xA6, 0x55, 0x80, 0x9C, + 0x59, 0x58, 0x18, 0xC8, 0xA5, 0x93, 0xAA, 0xDD, + 0xB4, 0xE0, 0x7B, 0x1F, 0x42, 0x90, 0xBE, 0x87, + 0xB7, 0x45, 0x76, 0x3C, 0xDF, 0x7C, 0x4B, 0x90 + }, + { + 0x39, 0xFA, 0xA8, 0xDA, 0x53, 0x46, 0xF2, 0x8F, + 0x24, 0x45, 0xF2, 0x9E, 0xE9, 0x5B, 0x2D, 0x2A, + 0x56, 0x82, 0x1F, 0x03, 0x2A, 0x29, 0x20, 0x42, + 0x91, 0xEF, 0xDE, 0x5E, 0x0E, 0x09, 0xC7, 0xB5, + 0x49, 0x64, 0x53, 0xE7, 0x55, 0x00, 0x98, 0xAE, + 0x46, 0xDE, 0xC0, 0xF2, 0x13, 0xEF, 0xD2, 0x80, + 0x08, 0xC3, 0xA1, 0x11, 0xED, 0xBA, 0x2A, 0x82, + 0x30, 0xAA, 0x4C, 0x29, 0xAD, 0x6B, 0x2D, 0x5B + }, + { + 0x3C, 0x1E, 0x90, 0xB1, 0x98, 0x8C, 0x3E, 0xB9, + 0x4C, 0xBC, 0x1F, 0x5A, 0x14, 0x8A, 0xD7, 0xAE, + 0x6E, 0x8B, 0x53, 0x8D, 0xCC, 0xC3, 0x93, 0xB7, + 0x10, 0xE3, 0x16, 0x3F, 0x04, 0xB5, 0x0D, 0xFB, + 0xF3, 0xAE, 0xF5, 0x14, 0x4A, 0x0A, 0x40, 0x54, + 0x93, 0xC6, 0x11, 0x91, 0x6B, 0x20, 0xEF, 0x8C, + 0x62, 0xFA, 0x10, 0x9C, 0xF6, 0xDB, 0x93, 0x87, + 0xB1, 0x21, 0x0C, 0xC1, 0x12, 0x53, 0x84, 0x68 + }, + { + 0x74, 0x23, 0xBF, 0x6A, 0x6F, 0xE7, 0x09, 0x3A, + 0x2E, 0x02, 0x11, 0xFA, 0xCA, 0x4A, 0x7B, 0xEA, + 0xF7, 0x85, 0x1B, 0x42, 0xCD, 0xE8, 0x79, 0x07, + 0x18, 0x13, 0x8D, 0x07, 0x10, 0x8D, 0xC1, 0xC1, + 0x23, 0x63, 0xB2, 0xCA, 0x08, 0x1C, 0xE9, 0x63, + 0xCF, 0x8F, 0x76, 0xA3, 0xA4, 0x33, 0x34, 0x8B, + 0xA6, 0x30, 0xC9, 0x82, 0x45, 0x70, 0xF9, 0x8F, + 0x66, 0x08, 0xC4, 0x48, 0xE6, 0xB6, 0xF9, 0x60 + }, + { + 0x3E, 0x62, 0x80, 0xE1, 0x69, 0x6D, 0xDE, 0xA3, + 0x7B, 0x80, 0x55, 0x0B, 0xF0, 0xBC, 0x8F, 0xF4, + 0xEE, 0x24, 0xBB, 0x96, 0x3F, 0xAB, 0xE9, 0xE8, + 0x0F, 0x2F, 0xC0, 0xD0, 0x4C, 0x98, 0xD7, 0x84, + 0xD8, 0xD7, 0x18, 0xDE, 0x8B, 0xCA, 0x66, 0xCA, + 0xC0, 0x37, 0x76, 0x67, 0x68, 0x71, 0x59, 0xC6, + 0xAF, 0x04, 0xD2, 0x0B, 0xB1, 0xF2, 0xF3, 0x40, + 0xDE, 0x96, 0x9F, 0x45, 0x2F, 0xB0, 0x3C, 0x33 + }, + { + 0x96, 0x62, 0xB7, 0xE7, 0x91, 0x43, 0xBE, 0x62, + 0x1A, 0x4E, 0x37, 0x75, 0xAD, 0x70, 0x00, 0xD7, + 0x84, 0xF8, 0x25, 0x5E, 0x1B, 0xEB, 0x03, 0x78, + 0x5C, 0x5D, 0xC3, 0xD6, 0xFF, 0xBF, 0xAB, 0x03, + 0x71, 0x64, 0x06, 0x78, 0xA4, 0xA3, 0xE3, 0x75, + 0x1F, 0x87, 0xAC, 0x6E, 0x9A, 0x99, 0xE6, 0xA2, + 0x75, 0x30, 0xFE, 0xD6, 0xAC, 0xC6, 0xC1, 0x1A, + 0x3D, 0x7C, 0x89, 0x8B, 0xCE, 0xEE, 0x62, 0x0C + }, + { + 0x61, 0x38, 0x00, 0xF6, 0x1A, 0x04, 0x45, 0x8A, + 0xCB, 0xDE, 0x74, 0xB2, 0xF4, 0xFC, 0x6B, 0x6C, + 0xA2, 0xE9, 0x14, 0x0D, 0xD2, 0x28, 0x1B, 0x5C, + 0xAC, 0x72, 0xDD, 0xEA, 0x31, 0x8D, 0x43, 0x01, + 0xEE, 0xBE, 0xA3, 0x7A, 0x15, 0xFB, 0x97, 0xA1, + 0x5E, 0x77, 0x78, 0x93, 0x85, 0xB0, 0xC6, 0x49, + 0x9D, 0xDD, 0x69, 0x12, 0x29, 0x9E, 0xD2, 0x1E, + 0x9F, 0x0F, 0x26, 0xAF, 0xA9, 0xE4, 0xFE, 0x43 + }, + { + 0xB5, 0xDD, 0x26, 0x3A, 0x27, 0x19, 0x2E, 0x32, + 0x45, 0x8C, 0x5E, 0xE7, 0x7E, 0x01, 0xD3, 0x24, + 0x19, 0x71, 0x2D, 0xEC, 0x5D, 0x7A, 0x0B, 0xCA, + 0xDD, 0xFF, 0xA8, 0xF2, 0x36, 0xDC, 0xE6, 0xEA, + 0x33, 0x46, 0xC1, 0x63, 0x0E, 0x10, 0xEB, 0x05, + 0xDD, 0xD9, 0xE7, 0x3F, 0xDA, 0x33, 0x39, 0x89, + 0x2D, 0xDF, 0xA7, 0x38, 0x12, 0x99, 0x85, 0xC8, + 0x61, 0x55, 0x65, 0xD8, 0xFC, 0xFA, 0x25, 0x7A + }, + { + 0x59, 0xBB, 0xFD, 0x86, 0x1D, 0x93, 0xBD, 0x10, + 0x03, 0x96, 0x28, 0xF6, 0x39, 0xD5, 0xE9, 0xCF, + 0xBE, 0xBF, 0x8A, 0x48, 0xFB, 0xEA, 0x1D, 0x8B, + 0x77, 0xB7, 0x8F, 0x91, 0x3F, 0xFB, 0xC0, 0x0B, + 0x8E, 0xD6, 0xD9, 0x95, 0xC7, 0x2D, 0xCF, 0x7E, + 0xA1, 0x80, 0x86, 0x8C, 0xA1, 0xD3, 0x8F, 0xE3, + 0x43, 0xD1, 0xF3, 0x4D, 0xFF, 0x1F, 0xF3, 0x28, + 0xD2, 0x8C, 0x2B, 0x5F, 0xB3, 0xF0, 0x13, 0xBF + }, + { + 0x27, 0x3F, 0xB1, 0x3D, 0x50, 0x07, 0x19, 0xEA, + 0x7D, 0x35, 0xF6, 0xB3, 0x9F, 0xC8, 0xD4, 0xB9, + 0x46, 0xB6, 0x26, 0x4F, 0xC5, 0x15, 0x8F, 0x54, + 0x20, 0x8F, 0xB8, 0x7D, 0x86, 0xD3, 0xCA, 0x50, + 0x22, 0x78, 0x54, 0x9C, 0xFC, 0x7E, 0x4C, 0x30, + 0x6E, 0x05, 0x35, 0xB4, 0x8B, 0x19, 0xE6, 0x9C, + 0xCA, 0x3D, 0x34, 0x3C, 0x57, 0xFB, 0x6E, 0x6B, + 0x23, 0xA5, 0x42, 0x3E, 0xB8, 0x9B, 0xAF, 0x05 + }, + { + 0x32, 0x86, 0x45, 0xCF, 0x59, 0x7D, 0xA4, 0xFC, + 0x0A, 0x91, 0xF4, 0x28, 0x52, 0x3F, 0x41, 0xB0, + 0x43, 0xF1, 0x98, 0xFE, 0x39, 0xBA, 0x9B, 0x3B, + 0xC5, 0x55, 0x99, 0x51, 0xFF, 0xF7, 0x2A, 0xD3, + 0xF0, 0x7E, 0x5F, 0xF6, 0xE0, 0xD0, 0xD7, 0x52, + 0x03, 0xBE, 0x7B, 0xD9, 0x36, 0x1B, 0x2B, 0x62, + 0x46, 0x80, 0x63, 0x48, 0x22, 0x6F, 0x13, 0x2F, + 0x5A, 0x9D, 0xC4, 0x68, 0x19, 0xA1, 0x09, 0xC9 + }, + { + 0xBF, 0xA5, 0x7F, 0x51, 0x40, 0xED, 0x48, 0x05, + 0x2A, 0x34, 0x52, 0xB2, 0xCC, 0x66, 0x8C, 0x97, + 0x27, 0xC5, 0x3A, 0xC6, 0x0F, 0x2E, 0xBF, 0xA6, + 0xB6, 0x01, 0x06, 0x97, 0xB2, 0x90, 0x84, 0x79, + 0xEA, 0x31, 0x6A, 0x2F, 0xE0, 0xC5, 0x0B, 0xBB, + 0xD4, 0x28, 0x72, 0xC5, 0xA9, 0xAF, 0x1D, 0x6F, + 0x7E, 0x7E, 0x11, 0x20, 0x06, 0x28, 0xE5, 0x4C, + 0x8E, 0x28, 0xB1, 0x49, 0xBC, 0x18, 0x76, 0xE5 + }, + { + 0x13, 0xBA, 0xBA, 0x23, 0x22, 0xD3, 0x9A, 0x8E, + 0x60, 0xEE, 0xBE, 0x1D, 0xE2, 0xB7, 0x4F, 0x30, + 0xA4, 0x5F, 0xCF, 0x91, 0x09, 0xEC, 0x43, 0x9F, + 0x08, 0x28, 0xF2, 0x5D, 0xB7, 0x37, 0x93, 0x94, + 0xDC, 0x06, 0xD3, 0x85, 0x71, 0x51, 0x7A, 0xE6, + 0xC4, 0x3C, 0xFC, 0x7E, 0x55, 0x55, 0xFF, 0x19, + 0xBC, 0x5E, 0x8C, 0x54, 0xBA, 0x73, 0x2F, 0x84, + 0x4B, 0xCE, 0xA4, 0xBB, 0xC4, 0x77, 0xE8, 0xAF + }, + { + 0x58, 0x79, 0xF6, 0xC5, 0xBF, 0xC2, 0xC4, 0x58, + 0x6A, 0xA0, 0x3B, 0x84, 0x81, 0xCC, 0x3D, 0x13, + 0xE5, 0x83, 0xDC, 0xDB, 0xCA, 0xA8, 0xED, 0x07, + 0x4C, 0xC1, 0x1E, 0x9B, 0xE5, 0x5F, 0xBA, 0xC8, + 0xA8, 0xEC, 0xA6, 0x18, 0x3F, 0xCD, 0xE0, 0x64, + 0x3E, 0x50, 0x74, 0x79, 0xD3, 0x14, 0xC0, 0x13, + 0xE1, 0x4E, 0xC0, 0xF6, 0x1D, 0xEF, 0x33, 0xDD, + 0x4E, 0x1B, 0xC1, 0xED, 0xFF, 0x52, 0x5C, 0xA5 + }, + { + 0x14, 0xF3, 0x50, 0x73, 0xD8, 0x5E, 0xDD, 0x15, + 0x39, 0xC2, 0xB9, 0xB8, 0x0A, 0x70, 0x5E, 0xD9, + 0x4E, 0xEA, 0x46, 0x4C, 0x6C, 0x54, 0xD7, 0x28, + 0xC5, 0x98, 0xF0, 0x9B, 0x12, 0x63, 0x21, 0xEC, + 0x18, 0xD0, 0xAE, 0xF4, 0x9C, 0x1E, 0x8D, 0xBB, + 0x48, 0xBD, 0x73, 0xAA, 0xAC, 0x67, 0x58, 0x01, + 0x7D, 0x3F, 0x06, 0xAF, 0xF8, 0x5C, 0xC5, 0x54, + 0x66, 0xE8, 0xFA, 0x3C, 0x1F, 0xEC, 0xDC, 0x9B + }, + { + 0xE0, 0xFE, 0x7D, 0x1E, 0xD5, 0xED, 0x47, 0x74, + 0x54, 0x08, 0x8C, 0x6D, 0xDE, 0x11, 0x08, 0x67, + 0x1F, 0xD0, 0xE8, 0xA6, 0x40, 0xD1, 0x6D, 0xA0, + 0xE7, 0x03, 0x13, 0xDA, 0x0F, 0xDC, 0xFA, 0x55, + 0x79, 0x68, 0xFF, 0xBB, 0x7A, 0xF1, 0x47, 0x8E, + 0xCF, 0xC8, 0x2C, 0xD2, 0xE2, 0x31, 0x51, 0xA6, + 0x49, 0x3B, 0x49, 0xD1, 0xA9, 0x59, 0xDB, 0xF2, + 0x2F, 0x8E, 0xE9, 0x3B, 0x18, 0xA6, 0x33, 0x60 + }, + { + 0x09, 0x6D, 0x73, 0xC9, 0xA7, 0xEE, 0xC3, 0x15, + 0x96, 0x9D, 0x4D, 0x56, 0xB8, 0xEB, 0x28, 0x05, + 0x7D, 0xE6, 0x0A, 0xEB, 0x8A, 0x52, 0x53, 0xF1, + 0xB1, 0x38, 0x63, 0xD9, 0x69, 0xBD, 0xD8, 0xCE, + 0xB0, 0x1D, 0xFD, 0xE9, 0x7E, 0xE4, 0x3B, 0x70, + 0x42, 0x18, 0x6C, 0xD9, 0xBD, 0x4D, 0x06, 0x05, + 0xB2, 0x6C, 0x7E, 0x7E, 0x6D, 0x92, 0xA9, 0x71, + 0x96, 0x91, 0xAD, 0x5E, 0x39, 0x30, 0x2C, 0x8C + }, + { + 0xB5, 0x1E, 0x39, 0x49, 0xB9, 0xE0, 0xA0, 0xD9, + 0x38, 0xFE, 0xDE, 0x4A, 0x38, 0x9B, 0xEC, 0xB4, + 0xF1, 0x37, 0x03, 0x89, 0x47, 0xC2, 0x71, 0x69, + 0xE6, 0xC7, 0x65, 0x82, 0x44, 0xE6, 0x2B, 0x38, + 0xC6, 0x89, 0x7D, 0xF6, 0x52, 0xC3, 0xA9, 0x74, + 0x6A, 0x8D, 0x86, 0xBE, 0x0A, 0xC7, 0x25, 0x61, + 0x38, 0xB7, 0x31, 0xE6, 0xC3, 0x49, 0x8A, 0xF4, + 0x48, 0x84, 0x6F, 0xBE, 0x40, 0xDF, 0xC8, 0x72 + }, + { + 0x4D, 0x31, 0xDC, 0xAB, 0x24, 0x18, 0x5E, 0x7D, + 0x7D, 0xA5, 0x6A, 0x04, 0xF6, 0x77, 0xF9, 0xC0, + 0xB0, 0x49, 0x7D, 0x79, 0x2A, 0x3D, 0xDE, 0x86, + 0xC1, 0xEB, 0x7E, 0x72, 0x37, 0xC4, 0x62, 0x41, + 0x00, 0x2D, 0x59, 0x93, 0xE7, 0x1B, 0x3F, 0x5C, + 0x1E, 0xA3, 0xF5, 0x25, 0x0B, 0x93, 0x60, 0x72, + 0x48, 0x57, 0xD2, 0xCF, 0xD8, 0xBD, 0xBB, 0x1C, + 0xB8, 0x25, 0x17, 0xEA, 0x6E, 0x67, 0xD1, 0x48 + }, + { + 0xF9, 0x85, 0x3D, 0xE5, 0x92, 0x90, 0xF6, 0xC9, + 0x80, 0x57, 0x98, 0x68, 0xF7, 0x58, 0xC2, 0x0B, + 0xBF, 0x44, 0x05, 0x74, 0xDA, 0xF8, 0x72, 0x32, + 0x91, 0xF6, 0x18, 0xF0, 0x86, 0xDB, 0xB0, 0x70, + 0x98, 0xE6, 0xD9, 0x26, 0xA9, 0x28, 0xA1, 0xA7, + 0x1B, 0xB1, 0xE8, 0x51, 0xEB, 0x9D, 0x47, 0xA5, + 0x57, 0x93, 0x16, 0x40, 0xEC, 0x6F, 0xED, 0x9B, + 0xE9, 0xF8, 0x58, 0x47, 0x7D, 0xBF, 0x27, 0xDC + }, + { + 0x48, 0xF2, 0x8D, 0x88, 0x5D, 0x51, 0x72, 0x99, + 0x8B, 0x09, 0x7C, 0xD1, 0x98, 0x5C, 0x45, 0x29, + 0x30, 0x66, 0x0C, 0xDD, 0xE7, 0x99, 0xF7, 0xC4, + 0xCC, 0x36, 0xCB, 0x9E, 0x33, 0x9D, 0x67, 0x59, + 0x0C, 0xE0, 0x84, 0x11, 0x65, 0x5B, 0x74, 0x12, + 0x37, 0x7E, 0xCA, 0x20, 0xCC, 0xA7, 0x58, 0x73, + 0x96, 0xEF, 0x9F, 0x12, 0xA4, 0x3D, 0x22, 0x8A, + 0x7D, 0xFB, 0x30, 0x06, 0x52, 0x3B, 0x53, 0xA3 + }, + { + 0x84, 0x60, 0xAA, 0xB5, 0x62, 0x83, 0x37, 0x20, + 0xED, 0x16, 0x8D, 0x3A, 0x47, 0x2E, 0x1D, 0xDF, + 0x99, 0xFE, 0x1B, 0x08, 0x4C, 0xBA, 0x8A, 0xBE, + 0x1B, 0x9F, 0xE5, 0xF7, 0xEB, 0x60, 0x09, 0x1F, + 0x98, 0xF6, 0x65, 0xA0, 0xFF, 0x86, 0x78, 0xD7, + 0xA6, 0xB0, 0x05, 0x34, 0x94, 0xBC, 0x0F, 0x1A, + 0x14, 0x37, 0xC5, 0xFB, 0xE1, 0x10, 0x81, 0x11, + 0x31, 0xC7, 0x22, 0xC9, 0x69, 0xCC, 0xFA, 0x60 + }, + { + 0xE3, 0x95, 0x1F, 0xA6, 0xA0, 0xE3, 0x65, 0xBA, + 0x91, 0x95, 0x20, 0xE1, 0x58, 0x9A, 0x36, 0xE7, + 0x7C, 0xAE, 0x47, 0x96, 0x83, 0xDF, 0x55, 0x7D, + 0x9C, 0x66, 0x72, 0x77, 0x48, 0x42, 0xAB, 0xB6, + 0x90, 0x59, 0x37, 0x0B, 0x14, 0xA1, 0x71, 0x52, + 0xA4, 0x5B, 0xF0, 0x66, 0x3A, 0xD6, 0xA4, 0x9F, + 0xB3, 0xB1, 0x2C, 0xBE, 0x93, 0x3D, 0x59, 0x61, + 0x59, 0x42, 0x3A, 0x0C, 0xF1, 0xED, 0xB2, 0xE0 + }, + { + 0x2B, 0x06, 0xB4, 0x14, 0xC5, 0xF9, 0x5A, 0x20, + 0xB2, 0xA3, 0x5C, 0xA8, 0x5C, 0xCC, 0xA5, 0xA1, + 0xA8, 0x16, 0x9E, 0xD2, 0xEC, 0xF5, 0xD5, 0x92, + 0x8F, 0xB7, 0xF4, 0x73, 0xCE, 0x74, 0xDD, 0xD7, + 0xEE, 0xB8, 0x3E, 0xDF, 0x6A, 0x42, 0xC5, 0xB5, + 0xAD, 0x57, 0x7A, 0xD1, 0x42, 0x11, 0x80, 0x66, + 0xF1, 0xE7, 0x2A, 0xDF, 0x2E, 0x36, 0x40, 0x89, + 0xC6, 0xB8, 0x10, 0x1B, 0x55, 0xEC, 0x2E, 0x7B + }, + { + 0x02, 0x55, 0x48, 0x0F, 0x06, 0x00, 0x06, 0xA4, + 0xF0, 0x3E, 0xE4, 0xFF, 0xC9, 0xBD, 0x33, 0x8F, + 0xF9, 0x6C, 0x00, 0xCE, 0x4D, 0xF2, 0xE6, 0xD7, + 0x90, 0xE2, 0x54, 0x58, 0x30, 0x42, 0x19, 0xC5, + 0xDF, 0xAD, 0x9E, 0xCB, 0x8B, 0x9C, 0x6D, 0x99, + 0x3D, 0x4B, 0xCA, 0xAE, 0xD3, 0x71, 0x30, 0x3F, + 0x9B, 0x01, 0xC2, 0x9E, 0x4B, 0x36, 0xEF, 0xE8, + 0x01, 0x28, 0x54, 0xE2, 0xBB, 0xAE, 0x03, 0xAF + }, + { + 0x1C, 0xDF, 0xAA, 0xB1, 0xB4, 0xFE, 0x91, 0x2A, + 0xBF, 0x8D, 0x5E, 0x79, 0x91, 0x03, 0xD9, 0x39, + 0x48, 0x39, 0x0D, 0x0E, 0x94, 0xCD, 0x7B, 0xF5, + 0x4B, 0x12, 0xFA, 0xDD, 0xEB, 0x7B, 0x12, 0x0E, + 0xEE, 0x6B, 0xA5, 0x0A, 0x5D, 0xB3, 0x58, 0x27, + 0x72, 0xA2, 0x5E, 0x4C, 0xCF, 0x11, 0x3F, 0x38, + 0x7A, 0x3D, 0xAF, 0x48, 0xF3, 0x70, 0x60, 0x08, + 0xA1, 0x61, 0x07, 0x6C, 0xAC, 0xAD, 0x26, 0x04 + }, + { + 0xB5, 0x76, 0xDA, 0x20, 0x9E, 0x36, 0x60, 0x6C, + 0x5C, 0x48, 0x89, 0xC9, 0xD7, 0x15, 0x9D, 0x73, + 0x2E, 0xEC, 0xBC, 0x28, 0x16, 0x6C, 0xAB, 0xBF, + 0x13, 0xE7, 0x8C, 0x31, 0x9A, 0xA1, 0xA0, 0x91, + 0xD3, 0xEF, 0xF0, 0x17, 0x23, 0x36, 0xAA, 0x58, + 0x0C, 0x7B, 0x18, 0x81, 0x2F, 0xE6, 0x30, 0x0A, + 0xB5, 0x55, 0xF2, 0x6E, 0x3F, 0xF4, 0x40, 0x18, + 0x45, 0x09, 0x46, 0x71, 0xAF, 0x5A, 0xA6, 0x68 + }, + { + 0x73, 0xF6, 0xB3, 0xDE, 0xD6, 0x7A, 0xD4, 0xFF, + 0xB2, 0x6F, 0x5F, 0xA3, 0xED, 0x08, 0x18, 0xD1, + 0x19, 0x76, 0xC4, 0xC2, 0x16, 0x40, 0x31, 0xE7, + 0x49, 0xB5, 0xE3, 0xD9, 0xF4, 0xEA, 0xCB, 0x43, + 0xEB, 0xCF, 0x2E, 0x89, 0x0F, 0xF7, 0x32, 0x64, + 0x30, 0x1E, 0xFF, 0x94, 0xFA, 0x30, 0x81, 0x10, + 0xF9, 0x65, 0x22, 0x4E, 0x94, 0x56, 0x53, 0x17, + 0x5A, 0x41, 0x02, 0x20, 0x0A, 0xF6, 0x35, 0xE7 + }, + { + 0x2E, 0xD1, 0xB8, 0x4C, 0xD8, 0x10, 0x10, 0x0C, + 0x26, 0x45, 0x32, 0x73, 0x1B, 0xBF, 0x76, 0x03, + 0x53, 0x3E, 0xFF, 0x08, 0x7E, 0xE5, 0x0C, 0xE8, + 0x0D, 0x28, 0x2C, 0x5B, 0xD2, 0xEC, 0x3C, 0x2F, + 0xF8, 0x3E, 0x90, 0x66, 0x50, 0x14, 0xCB, 0x7F, + 0x0C, 0x1D, 0xAA, 0x48, 0x76, 0xB7, 0xB8, 0x3B, + 0x95, 0x2A, 0xD8, 0xAC, 0xFF, 0x9F, 0x5E, 0x49, + 0x41, 0x73, 0x2D, 0x48, 0xF5, 0x4D, 0x19, 0xB4 + }, + { + 0x39, 0xE5, 0x3C, 0x8F, 0xE2, 0xB7, 0xAD, 0x27, + 0xDF, 0x7C, 0xF9, 0x84, 0xED, 0x03, 0x26, 0xF2, + 0x81, 0xC1, 0x3D, 0xDB, 0x5A, 0x2E, 0xE7, 0x99, + 0x68, 0xE9, 0x5C, 0x96, 0xEC, 0x47, 0x35, 0xB5, + 0xA6, 0xA6, 0xEE, 0x03, 0x2F, 0x30, 0xDB, 0xA1, + 0x27, 0xA8, 0x3F, 0x34, 0xE9, 0xC7, 0xD8, 0x93, + 0xF8, 0x17, 0x5D, 0x0C, 0x9A, 0x32, 0x15, 0x8D, + 0x8E, 0x93, 0xEE, 0x0C, 0x08, 0x55, 0xC6, 0x43 + }, + { + 0x40, 0xF0, 0x8F, 0xD4, 0xBD, 0x42, 0xC4, 0x19, + 0xE7, 0x6F, 0x97, 0x07, 0x9A, 0xB3, 0xF0, 0x09, + 0x08, 0xCB, 0x3E, 0x4F, 0xD4, 0xB1, 0xB0, 0xE0, + 0xEF, 0x31, 0xF7, 0xA0, 0xE7, 0xF2, 0xD2, 0x9B, + 0x35, 0x51, 0x9E, 0x5A, 0x74, 0x2A, 0x9E, 0x41, + 0xD4, 0x13, 0x54, 0x8B, 0x79, 0x0F, 0xC1, 0xFA, + 0xF8, 0xCF, 0xE2, 0xAF, 0xF7, 0xFF, 0x4A, 0x49, + 0x50, 0xA7, 0xCA, 0x93, 0xF5, 0xEE, 0x04, 0xB4 + }, + { + 0xEF, 0xB8, 0x16, 0xDE, 0xCD, 0x00, 0x23, 0xCF, + 0x51, 0x79, 0x02, 0xEC, 0x0D, 0x4A, 0x60, 0xF1, + 0x69, 0x61, 0x48, 0x09, 0x9E, 0xF2, 0xDD, 0x81, + 0x0D, 0x59, 0x3E, 0xFF, 0x4E, 0x26, 0x13, 0xDF, + 0x0C, 0x84, 0xAE, 0x94, 0x1D, 0x94, 0x8D, 0xD4, + 0xD5, 0xE0, 0x23, 0xAA, 0xBA, 0xDD, 0x5F, 0xF0, + 0xAD, 0xAA, 0xEE, 0x32, 0x0C, 0xDA, 0xB6, 0x18, + 0x75, 0x9F, 0xC6, 0x49, 0x43, 0xA8, 0x71, 0xE8 + }, + { + 0x24, 0x89, 0x4C, 0x3F, 0x4D, 0xF9, 0x82, 0xD4, + 0x9B, 0x82, 0xB3, 0xE2, 0x35, 0x63, 0x80, 0xDD, + 0x43, 0x2F, 0x54, 0xD7, 0xD0, 0x9C, 0x40, 0x6C, + 0xB7, 0xDD, 0xC9, 0xB9, 0xB4, 0x03, 0x13, 0x8B, + 0xE2, 0x35, 0xFF, 0x05, 0x32, 0x7B, 0xDC, 0x03, + 0x8E, 0xFC, 0x1B, 0x81, 0xC2, 0x88, 0xBD, 0xD1, + 0xF1, 0x47, 0x42, 0xBF, 0x03, 0xF3, 0xB5, 0x8C, + 0x53, 0x35, 0xE3, 0xAE, 0x10, 0x61, 0xC5, 0xDF + }, + { + 0xCA, 0x55, 0x06, 0xD7, 0x98, 0x21, 0xB0, 0x47, + 0x25, 0x7F, 0x21, 0xC4, 0x3F, 0x6C, 0x5F, 0x84, + 0x72, 0xD8, 0xB3, 0xC9, 0x7E, 0xBF, 0x2D, 0x65, + 0x61, 0x68, 0xC2, 0x99, 0xF4, 0x32, 0x6D, 0xF5, + 0x14, 0x21, 0x2A, 0x45, 0xC2, 0xC0, 0x2F, 0xC7, + 0x87, 0xDA, 0x7E, 0x85, 0x4B, 0x15, 0x56, 0x39, + 0x9B, 0xB9, 0x5A, 0x16, 0x8B, 0x72, 0x5A, 0xFC, + 0x0B, 0x9C, 0x07, 0xA6, 0x2F, 0x5E, 0xAC, 0xD5 + }, + { + 0x99, 0xE9, 0x70, 0xE5, 0x19, 0x33, 0x6A, 0xEE, + 0xF1, 0x58, 0x4A, 0xE8, 0x9B, 0x48, 0x11, 0x66, + 0x0C, 0x57, 0xA2, 0x5E, 0x96, 0xCB, 0x6B, 0xDC, + 0x39, 0xAB, 0x4C, 0x01, 0x02, 0x4C, 0x9C, 0xE5, + 0x8C, 0x1D, 0x3C, 0x5C, 0x52, 0xF8, 0x94, 0x43, + 0x28, 0x48, 0xF9, 0x56, 0xC1, 0xA5, 0x88, 0x88, + 0x92, 0xBA, 0xAF, 0x8E, 0xD5, 0xB5, 0x59, 0xB0, + 0x84, 0x6E, 0xDC, 0x74, 0x7D, 0xC3, 0xCE, 0x1D + }, + { + 0xE7, 0x20, 0x77, 0x79, 0xEF, 0x7C, 0x66, 0x3B, + 0x25, 0x05, 0x12, 0x89, 0x7F, 0xF2, 0xA5, 0x17, + 0xDB, 0x3D, 0x20, 0x23, 0x4A, 0x42, 0xA2, 0x7B, + 0x89, 0xB7, 0x0A, 0x89, 0x01, 0xF8, 0xAE, 0x80, + 0xD1, 0x93, 0xB6, 0xA1, 0xBF, 0x06, 0x61, 0x16, + 0xE4, 0x52, 0xE6, 0x9E, 0x5D, 0x37, 0xB9, 0x9F, + 0x88, 0x65, 0xA4, 0x1B, 0xA9, 0x63, 0x96, 0x74, + 0x33, 0xBF, 0x90, 0xBC, 0xEB, 0x46, 0x7D, 0x4E + }, + { + 0x7F, 0xA1, 0x6A, 0x0B, 0xEF, 0x5B, 0x89, 0x8A, + 0xED, 0x97, 0xD3, 0x3D, 0x62, 0x7F, 0xAA, 0xD0, + 0x31, 0x59, 0x22, 0x05, 0xF2, 0x7F, 0x07, 0x9C, + 0xAE, 0x40, 0xC0, 0x63, 0x05, 0x13, 0x72, 0xDD, + 0xCB, 0x78, 0xF2, 0x54, 0xC2, 0xB5, 0xD1, 0xC7, + 0x37, 0xF3, 0x3C, 0x1C, 0xAD, 0xDD, 0x2C, 0x15, + 0xEA, 0xF8, 0x8B, 0x73, 0x46, 0x18, 0x3D, 0x61, + 0xF5, 0x83, 0xBF, 0x07, 0x46, 0xE7, 0xCD, 0x59 + }, + { + 0x2A, 0xB5, 0x4E, 0xA3, 0x89, 0x5D, 0xF0, 0xFA, + 0x28, 0xF3, 0x30, 0x52, 0x92, 0x38, 0x62, 0x2D, + 0x37, 0x31, 0xEE, 0xE5, 0x3E, 0xE4, 0xAD, 0x3A, + 0x83, 0xB7, 0xA2, 0x82, 0xBB, 0xB4, 0x94, 0xC1, + 0x54, 0xC0, 0x07, 0x57, 0x34, 0xE4, 0x82, 0x86, + 0xA7, 0xEA, 0xAA, 0x33, 0x60, 0x46, 0x4C, 0xB7, + 0xC3, 0x06, 0x7A, 0x8A, 0xA0, 0x09, 0x24, 0x52, + 0x66, 0x22, 0xAF, 0x5B, 0x06, 0x46, 0xAB, 0x9E + }, + { + 0x14, 0xE6, 0x24, 0x79, 0x26, 0x71, 0xFD, 0x05, + 0xF9, 0x70, 0x49, 0xE0, 0xF0, 0xA8, 0x89, 0xE7, + 0x1D, 0x4B, 0xBC, 0xB6, 0xDE, 0xAA, 0xE3, 0x15, + 0x50, 0xCD, 0xC0, 0x70, 0x57, 0xE3, 0x93, 0xDF, + 0x50, 0x5C, 0x5E, 0xD4, 0x35, 0x0D, 0x96, 0x34, + 0x47, 0x3E, 0x1D, 0x40, 0xF2, 0x1E, 0x86, 0x0D, + 0x29, 0xE7, 0x1B, 0x29, 0x8A, 0x5C, 0xE9, 0xED, + 0x42, 0x8D, 0xD2, 0x4D, 0xEC, 0xAF, 0x0A, 0x5D + }, + { + 0x10, 0xA4, 0x98, 0x69, 0x99, 0xD3, 0x95, 0x63, + 0xA2, 0xBF, 0xFB, 0x43, 0x8A, 0x03, 0x2C, 0x9E, + 0x63, 0xF1, 0xA6, 0x43, 0x44, 0x0C, 0xF7, 0xC3, + 0xF3, 0x03, 0xF7, 0x2E, 0x2B, 0x9F, 0x46, 0x3E, + 0x41, 0x4C, 0xAB, 0x03, 0x82, 0x2F, 0xED, 0xA2, + 0xD8, 0xDD, 0xC4, 0xF6, 0x1B, 0xA3, 0x25, 0x43, + 0x5A, 0x7A, 0x57, 0x8A, 0x0F, 0x8B, 0x1D, 0xF7, + 0xB8, 0x6E, 0x28, 0x3D, 0x26, 0x0C, 0x0B, 0xBA + }, + { + 0xB6, 0xEB, 0x79, 0x7E, 0xC0, 0x25, 0xFE, 0x3B, + 0x73, 0x60, 0xE0, 0xBD, 0x86, 0x8D, 0x45, 0xF3, + 0x18, 0x17, 0x58, 0x5A, 0xDC, 0x95, 0x81, 0x54, + 0xAE, 0xF5, 0x12, 0x2F, 0x44, 0xE0, 0x4F, 0xFC, + 0x05, 0x24, 0xB1, 0x11, 0x1D, 0x3C, 0xC3, 0x9D, + 0x72, 0x9E, 0xFC, 0x3C, 0x9A, 0x69, 0x80, 0x0D, + 0x0D, 0xFD, 0x5F, 0x89, 0x44, 0xDE, 0x88, 0x2B, + 0x63, 0x1E, 0xA2, 0x35, 0x94, 0xD4, 0x08, 0x9D + }, + { + 0xA2, 0x96, 0x41, 0x0D, 0x8E, 0x76, 0x45, 0x47, + 0x9C, 0x13, 0xE1, 0x1C, 0xFF, 0x37, 0x44, 0x32, + 0x5C, 0xDA, 0x6F, 0xA6, 0x2F, 0x91, 0x80, 0xDA, + 0x5B, 0x2F, 0xFD, 0x5C, 0x22, 0x0C, 0x62, 0x24, + 0x06, 0x0B, 0xD8, 0xB6, 0x01, 0x6B, 0xE5, 0xFF, + 0xE6, 0x38, 0x1C, 0x2F, 0x5C, 0xBB, 0x7C, 0xFD, + 0x98, 0x0D, 0xDC, 0x41, 0x42, 0x90, 0x2B, 0xED, + 0x00, 0x28, 0xFF, 0x5F, 0x6B, 0x2C, 0x92, 0xA9 + }, + { + 0x01, 0xB6, 0x07, 0x23, 0x02, 0x61, 0x3A, 0xA8, + 0x02, 0x85, 0x5D, 0xEF, 0x26, 0x95, 0x90, 0x06, + 0x1C, 0xD3, 0x80, 0x1B, 0x33, 0x48, 0xF4, 0xCD, + 0x57, 0x78, 0x99, 0x19, 0x31, 0x1E, 0xF0, 0x1D, + 0xA9, 0x38, 0x6D, 0x76, 0x6F, 0x69, 0xFA, 0xE6, + 0x80, 0x08, 0x69, 0xB3, 0x86, 0xBC, 0x26, 0x56, + 0x8D, 0x6A, 0x8B, 0x8E, 0x6E, 0x27, 0x1B, 0xF6, + 0xD2, 0x44, 0xA1, 0x47, 0xC6, 0x25, 0x8D, 0x26 + }, + { + 0x42, 0xEF, 0x94, 0x01, 0x9D, 0xA6, 0xEC, 0xB8, + 0x38, 0x6B, 0x95, 0x53, 0xB6, 0xF8, 0x07, 0xBA, + 0xE4, 0x51, 0x9D, 0x1C, 0xDC, 0x5C, 0x08, 0x09, + 0x2C, 0xE8, 0xD1, 0xE0, 0xF0, 0x8B, 0x07, 0x50, + 0x4C, 0x8B, 0xDA, 0xFD, 0xD7, 0x5E, 0x9F, 0x42, + 0x05, 0x8A, 0xD9, 0x77, 0x4A, 0xC6, 0x27, 0xB8, + 0x8A, 0x3A, 0xE0, 0x93, 0xA4, 0xB4, 0x43, 0xBA, + 0xCC, 0x55, 0xAB, 0x01, 0x5C, 0x2C, 0xF9, 0x62 + }, + { + 0x07, 0xBE, 0xC9, 0x7F, 0xD3, 0xE8, 0x00, 0x17, + 0xBD, 0xD8, 0x6C, 0xAE, 0x90, 0xE4, 0x9B, 0x90, + 0x99, 0x9C, 0x62, 0x75, 0x3B, 0x83, 0xB5, 0x9C, + 0x10, 0xEC, 0x7D, 0x67, 0xD9, 0xF5, 0x0E, 0xCD, + 0x35, 0x7B, 0x99, 0x07, 0xA0, 0x48, 0x64, 0x18, + 0x92, 0x3D, 0xE5, 0x60, 0x9D, 0x42, 0xC3, 0xEF, + 0x22, 0x3D, 0xE6, 0xAC, 0xD5, 0x45, 0x12, 0xA2, + 0x11, 0x56, 0x72, 0xE9, 0xD2, 0xB8, 0x2C, 0x76 + }, + { + 0x11, 0xB8, 0x0D, 0xDD, 0x2E, 0x8C, 0x4D, 0x20, + 0x60, 0x64, 0x50, 0x7F, 0x80, 0x74, 0x67, 0x2F, + 0x39, 0xEF, 0x05, 0x11, 0x36, 0x39, 0x42, 0xE9, + 0x2F, 0x65, 0x98, 0x58, 0x44, 0x79, 0xA5, 0x74, + 0x98, 0x54, 0x58, 0x74, 0xB9, 0x7B, 0xCC, 0x86, + 0x93, 0x58, 0x98, 0x17, 0x02, 0xC2, 0xF7, 0xA4, + 0x1C, 0x2A, 0x8C, 0xCE, 0x10, 0x9F, 0x47, 0xF6, + 0xE8, 0xC9, 0x61, 0x9F, 0x5C, 0x45, 0x7A, 0xE6 + }, + { + 0xFD, 0xBB, 0xD5, 0x01, 0xB8, 0x47, 0xFF, 0xBA, + 0xC9, 0x1B, 0x49, 0x93, 0x1F, 0xEC, 0x94, 0x29, + 0xBC, 0xB9, 0xC9, 0xD3, 0x89, 0xF9, 0x7F, 0x22, + 0x81, 0x69, 0x6F, 0x9E, 0xDD, 0x03, 0x2D, 0xF4, + 0x7A, 0x97, 0x4A, 0x48, 0xDD, 0xEA, 0x3B, 0x56, + 0x5E, 0xA6, 0xAC, 0xDA, 0x1D, 0xC4, 0x10, 0x91, + 0xD3, 0xEE, 0x20, 0x97, 0x3A, 0xDB, 0x8A, 0xCD, + 0x38, 0x4F, 0xD8, 0xB6, 0x7B, 0x82, 0x83, 0x20 + }, + { + 0x0D, 0xBD, 0xCA, 0xF5, 0x21, 0xE4, 0x49, 0x74, + 0x53, 0x16, 0x09, 0xB7, 0xD4, 0x00, 0x3D, 0x88, + 0x68, 0xB3, 0x2B, 0x39, 0xF5, 0x54, 0x66, 0xD1, + 0x36, 0xC3, 0x8F, 0xFA, 0xCB, 0x82, 0xB7, 0xC6, + 0xC4, 0xE3, 0xB6, 0x49, 0x39, 0x7B, 0xE7, 0xC6, + 0x92, 0xCD, 0x84, 0xDA, 0x62, 0x39, 0xAC, 0xED, + 0x55, 0x8D, 0x7B, 0xAB, 0x73, 0xF8, 0xC1, 0xB3, + 0x77, 0x62, 0x98, 0x48, 0xA5, 0x10, 0x85, 0x07 + }, + { + 0x0F, 0xD5, 0xA9, 0x43, 0xE5, 0x78, 0x41, 0x01, + 0xBB, 0xFC, 0x12, 0xBB, 0xF0, 0x14, 0x4D, 0x0B, + 0x45, 0x0A, 0xAA, 0xB6, 0x45, 0x31, 0xE7, 0x33, + 0x1C, 0xDE, 0x75, 0x3C, 0xF8, 0x03, 0x0D, 0x57, + 0xF9, 0x46, 0xD5, 0x89, 0x82, 0x5C, 0x61, 0xB5, + 0x71, 0x8E, 0x96, 0x73, 0x25, 0xED, 0xA1, 0x79, + 0x68, 0x50, 0xCE, 0xBB, 0xD5, 0xD2, 0x8D, 0x75, + 0xE6, 0x31, 0x43, 0x7B, 0x11, 0xA9, 0x3E, 0xA1 + }, + { + 0x46, 0xF1, 0xF2, 0x80, 0xDE, 0x34, 0xC6, 0x50, + 0xDF, 0x7C, 0xD2, 0x26, 0x6B, 0x01, 0xC5, 0xAA, + 0xA4, 0x0A, 0x15, 0x84, 0xC3, 0xA3, 0x2A, 0x44, + 0xF4, 0x1B, 0x0D, 0xED, 0x4E, 0xEA, 0x5A, 0x72, + 0x4F, 0x31, 0x80, 0xC3, 0x1F, 0x4B, 0x7D, 0x06, + 0x8E, 0x00, 0xD6, 0x3F, 0xF5, 0x12, 0x96, 0xAF, + 0xD5, 0x2A, 0xFB, 0x77, 0x17, 0x10, 0x2A, 0xEC, + 0xA8, 0xEE, 0x83, 0x9F, 0xD2, 0x52, 0x64, 0xBB + }, + { + 0xE0, 0xA6, 0x96, 0xE7, 0xA0, 0x29, 0x0A, 0xEE, + 0xC1, 0x0F, 0x5F, 0x3F, 0x0B, 0x8D, 0x7B, 0xBB, + 0x98, 0x76, 0xA9, 0x07, 0x04, 0x24, 0x83, 0x75, + 0x48, 0x51, 0x16, 0xBA, 0x5C, 0x4F, 0x61, 0xA8, + 0xD6, 0xE0, 0xD3, 0xF4, 0x95, 0xDD, 0x8F, 0x3F, + 0xF8, 0xCD, 0x5E, 0x04, 0xDA, 0x21, 0xD9, 0xBB, + 0x68, 0x74, 0x92, 0x7D, 0xF2, 0xCB, 0xF6, 0x6A, + 0xDE, 0xBC, 0xAD, 0x81, 0xA8, 0xC4, 0x6E, 0x88 + }, + { + 0x07, 0xBA, 0x21, 0xE2, 0x92, 0x2A, 0xBA, 0x36, + 0xE7, 0xED, 0xC5, 0x1C, 0xD4, 0x86, 0x6F, 0xEA, + 0x5F, 0xAA, 0x01, 0xAA, 0xC6, 0x89, 0x43, 0xBE, + 0x51, 0x7D, 0x0A, 0x27, 0xF1, 0x70, 0xB4, 0x22, + 0x9C, 0x5F, 0x24, 0x1C, 0x16, 0xAE, 0xDC, 0x4A, + 0x2A, 0xD6, 0x38, 0x1E, 0x71, 0x5C, 0x63, 0x94, + 0x95, 0x1D, 0xE3, 0x59, 0xD0, 0x86, 0x24, 0x9C, + 0x14, 0x1C, 0xA9, 0xAE, 0xDC, 0xA2, 0xE7, 0xFB + }, + { + 0x50, 0xC4, 0x4A, 0x2A, 0x45, 0xB4, 0xEB, 0x39, + 0x27, 0xEF, 0x0F, 0x64, 0xE7, 0x13, 0xB4, 0xA3, + 0xB5, 0x8D, 0xA2, 0x0B, 0xE5, 0xA7, 0x62, 0xC4, + 0x2C, 0x22, 0x8A, 0x9F, 0x41, 0x62, 0xFF, 0x1F, + 0xC4, 0xA8, 0x75, 0x59, 0xDC, 0x3F, 0xAE, 0x25, + 0x99, 0xDF, 0xDC, 0x26, 0xCE, 0x19, 0x23, 0x90, + 0xDB, 0xEE, 0x12, 0x1A, 0xF6, 0x82, 0x6A, 0x4F, + 0xF9, 0x73, 0x84, 0x8E, 0x17, 0x2A, 0xF7, 0x08 + }, + { + 0x75, 0xCD, 0x44, 0x7B, 0xAD, 0xE1, 0xC7, 0x43, + 0x5D, 0x1F, 0x5A, 0x4C, 0xF5, 0x1B, 0xFB, 0xE1, + 0x48, 0x1B, 0x94, 0x8E, 0xE2, 0x89, 0x3C, 0x6D, + 0x82, 0xB7, 0xDC, 0x68, 0xF5, 0x8A, 0x2D, 0x74, + 0xF5, 0x78, 0x1B, 0x64, 0x6B, 0xB8, 0x80, 0x6E, + 0xF0, 0x3C, 0xE8, 0x0B, 0x79, 0x26, 0x60, 0x21, + 0xEE, 0x81, 0x9B, 0x19, 0xE7, 0x4C, 0x95, 0x58, + 0x8F, 0xA5, 0x4B, 0x2C, 0xF6, 0x30, 0x6D, 0x3F + }, + { + 0x46, 0xCF, 0xB8, 0x38, 0xB4, 0xD4, 0xFC, 0xBD, + 0x0D, 0x98, 0x96, 0xE2, 0x0D, 0x78, 0xEE, 0x69, + 0x0E, 0x54, 0x3C, 0x54, 0xF0, 0x62, 0xC0, 0xC8, + 0x46, 0x9E, 0x5C, 0xA8, 0x5D, 0xB5, 0x0E, 0xA3, + 0x37, 0x47, 0xCA, 0x81, 0x1C, 0x6C, 0xE2, 0x55, + 0x9B, 0xEE, 0x6B, 0x70, 0xF5, 0xD0, 0xD1, 0x00, + 0x99, 0xDE, 0xB0, 0x8C, 0x93, 0xE5, 0x7A, 0x02, + 0xFF, 0x66, 0x29, 0x89, 0x8C, 0xB8, 0x22, 0xF4 + }, + { + 0x6C, 0x44, 0x20, 0x39, 0xB1, 0xCB, 0xBF, 0xB4, + 0x2F, 0xDB, 0x2D, 0xA3, 0x33, 0xB9, 0x2B, 0xE7, + 0x97, 0xFD, 0x07, 0xC0, 0x49, 0x5E, 0x2F, 0x65, + 0x87, 0xC6, 0xB5, 0xBC, 0x6A, 0xAB, 0xDE, 0x64, + 0xE5, 0x0A, 0x08, 0x28, 0x51, 0xB5, 0x0F, 0xA3, + 0x22, 0xA9, 0x7C, 0xBF, 0xE2, 0xFC, 0x2C, 0xBB, + 0x23, 0x42, 0xE6, 0x9C, 0xD3, 0xE6, 0x51, 0x7C, + 0x3F, 0x33, 0x97, 0xD2, 0x8C, 0xE4, 0xEC, 0xB4 + }, + { + 0xB5, 0x03, 0x39, 0x5B, 0x01, 0xB6, 0xEA, 0xE5, + 0x94, 0x66, 0x6B, 0xFB, 0xE7, 0x1C, 0x4A, 0xBE, + 0xFD, 0x70, 0x89, 0x35, 0xC6, 0xC4, 0x30, 0xFE, + 0x7C, 0x83, 0x93, 0x8C, 0xAF, 0x49, 0x67, 0x5D, + 0xA4, 0x82, 0x34, 0xD8, 0x18, 0x67, 0xB8, 0xD3, + 0xF8, 0xA4, 0xF2, 0xB7, 0xEA, 0x63, 0x3C, 0x7B, + 0x6E, 0xA3, 0x63, 0x23, 0xF1, 0x72, 0xF3, 0x0D, + 0x66, 0x5D, 0xDE, 0xFE, 0xD4, 0xD0, 0xB6, 0x54 + }, + { + 0xE5, 0x56, 0x88, 0xE9, 0x0B, 0x5E, 0xCF, 0x71, + 0x6F, 0xA6, 0x5D, 0x15, 0xAF, 0xC9, 0x96, 0x89, + 0xD9, 0x4B, 0x7D, 0xB4, 0x1E, 0x15, 0xFF, 0x00, + 0xCE, 0x20, 0x5A, 0xDF, 0x18, 0xFB, 0xBD, 0x05, + 0x8B, 0xC7, 0xB1, 0x31, 0x94, 0x06, 0x6D, 0xAF, + 0x16, 0x28, 0x84, 0x28, 0x45, 0xC8, 0xF8, 0x8B, + 0x24, 0xF5, 0x72, 0x91, 0xFC, 0x65, 0xE1, 0x59, + 0xFB, 0xAE, 0x0D, 0x15, 0xBA, 0x1C, 0xF4, 0x2D + }, + { + 0x90, 0xF8, 0x7C, 0xD9, 0x54, 0x1A, 0x9A, 0x44, + 0x06, 0x8D, 0x24, 0x4F, 0x6A, 0x3F, 0x02, 0xD5, + 0x98, 0xBA, 0x28, 0x30, 0x9E, 0xDB, 0xC1, 0x29, + 0xB0, 0x7F, 0x0F, 0x79, 0xBF, 0x8B, 0xBE, 0x0B, + 0x3E, 0xA3, 0x06, 0x15, 0xB0, 0xC8, 0x23, 0x0F, + 0x04, 0x50, 0xB9, 0xDF, 0x21, 0x9B, 0x12, 0x86, + 0x0C, 0xDE, 0x39, 0x13, 0xDC, 0x5E, 0x81, 0xE9, + 0xB2, 0xBB, 0xBD, 0xA1, 0x79, 0x44, 0x06, 0x00 + }, + { + 0xF9, 0x21, 0x26, 0x26, 0xB1, 0x51, 0x8C, 0xC1, + 0xCF, 0xDE, 0xB7, 0x9E, 0x51, 0x60, 0x9C, 0xDF, + 0xF4, 0xDB, 0xE9, 0x46, 0xCB, 0xC8, 0xBA, 0xA6, + 0x22, 0x85, 0x69, 0xDD, 0xCB, 0xBA, 0x03, 0x72, + 0xCA, 0x7D, 0xC1, 0x77, 0x25, 0xCB, 0x5B, 0x57, + 0x18, 0xB1, 0x7E, 0x11, 0xCB, 0xAF, 0x91, 0xE8, + 0x98, 0xDA, 0xFF, 0x01, 0xFB, 0x1A, 0x09, 0xA4, + 0x53, 0x59, 0xA5, 0xF0, 0x9A, 0x33, 0xB7, 0x9D + }, + { + 0x94, 0x93, 0xA5, 0x9B, 0x0C, 0x39, 0x4C, 0x65, + 0x7B, 0xCA, 0x3B, 0x92, 0xA2, 0x8C, 0xDB, 0x0B, + 0xF0, 0xE1, 0x29, 0xC2, 0x92, 0xB9, 0xC9, 0x7A, + 0x0C, 0x86, 0x10, 0xEC, 0x28, 0x64, 0x48, 0x28, + 0xF7, 0xC6, 0x47, 0x93, 0xFD, 0xB2, 0xE9, 0x8D, + 0xE6, 0xC0, 0xC6, 0xC2, 0xAD, 0x2E, 0xF5, 0xE9, + 0x15, 0x4A, 0xA0, 0x0C, 0xD4, 0x69, 0x3D, 0x11, + 0xB9, 0x7A, 0x2C, 0xA0, 0x1B, 0x12, 0xA8, 0xB0 + }, + { + 0xE5, 0x16, 0xE3, 0xC3, 0x22, 0xAC, 0x54, 0x7A, + 0x3A, 0x66, 0xCC, 0x86, 0xAC, 0x96, 0xA1, 0x65, + 0x39, 0x74, 0x20, 0xF4, 0x9F, 0x8C, 0x56, 0x69, + 0x23, 0xB8, 0xCB, 0xB6, 0xDC, 0x2C, 0xC0, 0x8C, + 0xDA, 0x68, 0x56, 0xB9, 0xD3, 0xAF, 0xAE, 0xC7, + 0xEB, 0x6E, 0x5E, 0xD2, 0xC4, 0x84, 0x90, 0x5F, + 0xCA, 0x6B, 0x4C, 0xCD, 0x3C, 0xCA, 0x75, 0x22, + 0x6B, 0xF4, 0xDD, 0xCB, 0x6B, 0xAF, 0x23, 0x6D + }, + { + 0x01, 0xB9, 0x57, 0x0A, 0xF9, 0xC5, 0x85, 0x88, + 0x44, 0x89, 0xFB, 0xC7, 0x89, 0x30, 0xB8, 0x14, + 0xE5, 0xA2, 0x69, 0x9C, 0x20, 0xE5, 0xA7, 0xCA, + 0xEA, 0xF0, 0x2C, 0x08, 0x07, 0x4F, 0xCB, 0x55, + 0x40, 0x21, 0xDF, 0x61, 0x97, 0x78, 0x3D, 0x9F, + 0x33, 0xE1, 0xCE, 0x3D, 0x0C, 0x63, 0xCB, 0xA5, + 0x04, 0xAA, 0xD2, 0xF3, 0x52, 0xD7, 0xF7, 0x20, + 0xE6, 0x4A, 0x58, 0x42, 0x15, 0xED, 0xEC, 0x6C + }, + { + 0x7D, 0x47, 0x45, 0xAE, 0x4A, 0x57, 0x00, 0x88, + 0xD0, 0x33, 0xC0, 0x84, 0x2D, 0x7F, 0x71, 0xEB, + 0x7E, 0xCA, 0xCF, 0x63, 0xED, 0xD2, 0x6A, 0xD0, + 0xC4, 0x4E, 0xD1, 0xFF, 0x59, 0xAB, 0x12, 0xFA, + 0xBF, 0xB2, 0x04, 0xBD, 0xC6, 0xEF, 0xB2, 0xF0, + 0x7C, 0xB2, 0x53, 0x9B, 0xA0, 0xF8, 0x5C, 0x44, + 0xC3, 0xAC, 0xAB, 0x70, 0xCB, 0xBA, 0xAE, 0xFD, + 0x2F, 0x1D, 0x20, 0xAC, 0x0B, 0x6B, 0xB3, 0x14 + }, + { + 0x88, 0x94, 0x26, 0x5D, 0x10, 0x53, 0x49, 0x49, + 0x06, 0xBA, 0xCA, 0x0C, 0x84, 0xD7, 0xEE, 0xAE, + 0x58, 0xEF, 0xE3, 0x2C, 0xC9, 0xD6, 0xCD, 0x84, + 0x44, 0x2B, 0xAB, 0xF4, 0xCA, 0x8C, 0x16, 0x5D, + 0xA3, 0x8D, 0x3A, 0x60, 0x87, 0x9F, 0xCB, 0x93, + 0x2C, 0xBA, 0x64, 0xA4, 0x5A, 0xF8, 0xC5, 0x4E, + 0xA9, 0x2B, 0x97, 0xEF, 0x24, 0x62, 0x6D, 0x4E, + 0xA8, 0x27, 0x17, 0xBC, 0xE6, 0x01, 0x52, 0x95 + }, + { + 0xA2, 0xC2, 0xEF, 0x52, 0x63, 0x86, 0x50, 0x62, + 0x5D, 0x83, 0xF2, 0x32, 0x2B, 0x94, 0x1F, 0xE8, + 0x91, 0xBD, 0x1E, 0x4F, 0x28, 0xB6, 0x7B, 0xF3, + 0x1D, 0x5C, 0x0F, 0x5E, 0x01, 0x33, 0xC3, 0xBB, + 0x4E, 0xD2, 0x5D, 0x2A, 0x49, 0x46, 0xB3, 0x99, + 0xCE, 0x0E, 0xD7, 0xC8, 0x9A, 0xA5, 0xA1, 0x35, + 0xEF, 0xD3, 0x4C, 0x48, 0x0F, 0x94, 0x3E, 0xC3, + 0xF4, 0x08, 0x99, 0x83, 0x68, 0xD0, 0xF9, 0xDA + }, + { + 0xFE, 0x32, 0x88, 0xD7, 0x36, 0x61, 0xA5, 0xEA, + 0xD3, 0x73, 0xFB, 0x50, 0xC5, 0xD5, 0x02, 0x18, + 0x05, 0x82, 0xC6, 0x7C, 0x46, 0x23, 0xA0, 0x52, + 0x8F, 0xB1, 0xED, 0x60, 0x74, 0x22, 0xB3, 0x6E, + 0x37, 0x63, 0x2A, 0xBE, 0x54, 0x98, 0xA3, 0x4C, + 0x73, 0xA1, 0x00, 0xEF, 0x45, 0x4E, 0x1B, 0xFB, + 0x7B, 0x43, 0xE7, 0x65, 0x1A, 0x47, 0xA9, 0xC0, + 0x68, 0x38, 0x1F, 0x1A, 0xB1, 0x75, 0x61, 0x59 + }, + { + 0x2B, 0x2D, 0x0E, 0x99, 0x39, 0xAA, 0x6A, 0xD2, + 0x31, 0x21, 0x1C, 0xCD, 0x2D, 0x76, 0xD8, 0x9B, + 0x52, 0x1B, 0x60, 0x64, 0xD6, 0x1F, 0x6A, 0x6D, + 0x93, 0x68, 0x42, 0x16, 0xCA, 0xB6, 0x9B, 0x8D, + 0xAE, 0x35, 0x6B, 0x89, 0xBD, 0x1C, 0xCA, 0x1C, + 0xAA, 0x15, 0x6B, 0xE8, 0x35, 0x25, 0x4C, 0x4D, + 0xAC, 0xA1, 0x3A, 0x0F, 0x05, 0xDC, 0xA4, 0xBC, + 0xF1, 0x4A, 0x7B, 0x50, 0x6F, 0xB6, 0x1B, 0x93 + }, + { + 0x01, 0x44, 0xC2, 0x22, 0xAD, 0x7E, 0x46, 0x9C, + 0x83, 0x32, 0x8A, 0xF3, 0x9D, 0x6B, 0x4E, 0xDE, + 0x9C, 0xC8, 0x6B, 0x4B, 0xE7, 0xE1, 0xCC, 0x47, + 0xB9, 0xD3, 0x1D, 0xD1, 0xBA, 0x0F, 0x58, 0x44, + 0x1F, 0x47, 0x9F, 0x38, 0x07, 0x11, 0x17, 0x2F, + 0x77, 0xAB, 0xF2, 0xA4, 0x4C, 0x96, 0xF0, 0x8B, + 0xE0, 0x26, 0x6E, 0x53, 0x6F, 0x16, 0xD1, 0xC2, + 0x5A, 0xEF, 0x86, 0xA8, 0xB6, 0x66, 0x2F, 0x11 + }, + { + 0xE2, 0xCC, 0xFB, 0x0E, 0xAA, 0x57, 0x4D, 0xCC, + 0x34, 0x81, 0x28, 0x20, 0xA6, 0x89, 0x06, 0x95, + 0x48, 0x12, 0x58, 0x3A, 0x38, 0xA2, 0x4B, 0x80, + 0xCA, 0x33, 0xCB, 0x58, 0x6F, 0x7A, 0x46, 0x51, + 0x76, 0x0B, 0x02, 0x9B, 0x26, 0x95, 0x09, 0xB5, + 0xAB, 0x52, 0x51, 0x2C, 0x45, 0x97, 0x20, 0xC4, + 0x8B, 0x55, 0xDA, 0xFD, 0x0A, 0xFF, 0x13, 0x19, + 0x2F, 0x2F, 0x12, 0x26, 0xCE, 0x5A, 0xFD, 0xDD + }, + { + 0x25, 0x47, 0x10, 0xCE, 0xFB, 0x8C, 0xB9, 0xA5, + 0x2B, 0xCC, 0x81, 0xF9, 0xBA, 0x59, 0x95, 0x95, + 0x77, 0x33, 0x55, 0x01, 0x21, 0xD4, 0x1F, 0x8A, + 0x61, 0x7F, 0x55, 0x21, 0x92, 0x6F, 0x4E, 0xF1, + 0x4C, 0x93, 0xA9, 0x50, 0x57, 0x0B, 0xD3, 0x39, + 0xAC, 0xD3, 0xF5, 0xBE, 0xB9, 0x59, 0x90, 0x7F, + 0x95, 0x48, 0x02, 0xD1, 0x4B, 0x02, 0x53, 0xE5, + 0x58, 0xDE, 0x6E, 0x28, 0xE6, 0xA5, 0x9B, 0xDC + }, + { + 0x62, 0xA0, 0x38, 0xC1, 0x17, 0x95, 0x0B, 0x02, + 0x54, 0xAC, 0x88, 0x90, 0x61, 0x32, 0x9E, 0xF4, + 0x37, 0xC8, 0xDE, 0x04, 0x36, 0xB5, 0xBC, 0x09, + 0x93, 0x01, 0xFF, 0x22, 0x87, 0x87, 0x88, 0x34, + 0xA3, 0x43, 0xB7, 0xF4, 0x93, 0x6D, 0x18, 0xC4, + 0x58, 0xAD, 0x88, 0x31, 0xB2, 0x46, 0xBE, 0x70, + 0xDB, 0xA0, 0x6F, 0xD3, 0xB1, 0x74, 0x2E, 0xC2, + 0xDD, 0xB2, 0x3C, 0xBA, 0x66, 0xB7, 0x60, 0xFC + }, + { + 0x62, 0xD1, 0xB8, 0x50, 0x2D, 0x1A, 0xFA, 0x83, + 0x57, 0x21, 0x79, 0x62, 0xB5, 0x2C, 0xAE, 0xAA, + 0xD8, 0x37, 0x44, 0x3D, 0xC5, 0x49, 0xAC, 0x89, + 0xC3, 0xF5, 0xF7, 0xA9, 0xBB, 0xF0, 0xED, 0x72, + 0xDB, 0x73, 0xD2, 0xDA, 0xC8, 0x38, 0x3E, 0xA6, + 0x7F, 0xF8, 0x10, 0x83, 0x7F, 0x30, 0x8F, 0x83, + 0x39, 0x1B, 0x45, 0x8A, 0xB6, 0x9A, 0x4E, 0xA9, + 0x2F, 0xFA, 0x63, 0x0E, 0x66, 0x93, 0xA2, 0xDD + }, + { + 0x56, 0xEF, 0x12, 0x52, 0x90, 0xCC, 0x34, 0x9C, + 0xB9, 0xB0, 0x42, 0xD0, 0xB4, 0xD5, 0x3F, 0xB7, + 0x2E, 0x5E, 0xD0, 0x1D, 0x35, 0xE3, 0xF5, 0xFA, + 0xE0, 0x2A, 0xB7, 0x05, 0xF7, 0xA4, 0xBD, 0x3F, + 0x9D, 0xEA, 0x18, 0x64, 0x54, 0x17, 0x06, 0x48, + 0x08, 0x77, 0x62, 0x51, 0x3C, 0x6B, 0xF8, 0xCD, + 0xF1, 0xA2, 0x77, 0x2A, 0x99, 0x1B, 0xD8, 0x37, + 0x08, 0x7F, 0x04, 0x0B, 0x20, 0x4F, 0x07, 0x57 + }, + { + 0x84, 0xD0, 0xBE, 0x76, 0xD9, 0x08, 0x32, 0xD7, + 0x46, 0xEB, 0x8B, 0xA8, 0x57, 0x34, 0x77, 0x83, + 0xC4, 0xBD, 0x68, 0x59, 0x30, 0xB0, 0x69, 0xE8, + 0x6D, 0xFB, 0x10, 0x4A, 0x39, 0x3D, 0xD6, 0x68, + 0xD0, 0x69, 0x69, 0x96, 0xF0, 0x27, 0x9A, 0xC6, + 0x9B, 0x21, 0x03, 0xCF, 0x74, 0xEC, 0x44, 0x63, + 0x2B, 0xD3, 0x3A, 0xE3, 0xFB, 0x33, 0xB8, 0xAD, + 0xAA, 0x23, 0x26, 0x58, 0x56, 0xCC, 0x2F, 0xEB + }, + { + 0x5A, 0x4D, 0x35, 0xDB, 0xE0, 0x66, 0xBF, 0x1F, + 0xA8, 0x6F, 0x4D, 0x3E, 0xEE, 0x4B, 0x05, 0x10, + 0xE0, 0x80, 0x16, 0x52, 0x7E, 0xEF, 0xDA, 0x35, + 0x06, 0xEE, 0x72, 0xB7, 0x43, 0x7B, 0xF4, 0x2D, + 0x77, 0x80, 0x99, 0x41, 0x15, 0xE8, 0xF5, 0xFF, + 0x41, 0x81, 0x4A, 0x07, 0xDE, 0xAF, 0x27, 0x6A, + 0x5C, 0x1F, 0xDA, 0xF5, 0x34, 0x9D, 0xC4, 0x41, + 0x62, 0xD5, 0x3D, 0xC2, 0x59, 0x59, 0x20, 0x1C + }, + { + 0x54, 0x0B, 0x3A, 0x74, 0x05, 0x26, 0xF6, 0x52, + 0x5D, 0x4C, 0xBD, 0xB9, 0x51, 0x9C, 0x89, 0x40, + 0x57, 0x26, 0x61, 0xBB, 0xF5, 0x22, 0x1E, 0x96, + 0x18, 0x0B, 0x24, 0x39, 0x05, 0xEB, 0x50, 0x1F, + 0x87, 0xE6, 0x8E, 0xBD, 0x8C, 0xE4, 0xB6, 0x5A, + 0xC2, 0x51, 0x23, 0xF2, 0x92, 0x92, 0xD0, 0xB6, + 0xAA, 0xD3, 0xA6, 0xCF, 0x8A, 0xFC, 0x34, 0x3B, + 0x03, 0x6D, 0x0C, 0xF5, 0x01, 0x11, 0xD5, 0xB0 + }, + { + 0xF9, 0x0E, 0xB2, 0x6D, 0x01, 0xEB, 0xDC, 0xC3, + 0x0C, 0x42, 0x0A, 0x78, 0xDD, 0x91, 0x24, 0xF3, + 0xE2, 0x45, 0xE9, 0x66, 0xBA, 0x04, 0x3C, 0x77, + 0x07, 0x7A, 0x03, 0x4A, 0x66, 0x70, 0x90, 0x15, + 0x8E, 0xF0, 0x3F, 0x2E, 0x93, 0xDD, 0x1F, 0x18, + 0x70, 0x10, 0x5B, 0x53, 0x42, 0x58, 0x08, 0x5A, + 0x5A, 0xE3, 0x05, 0x6B, 0x5A, 0xAF, 0xD8, 0xE2, + 0xBE, 0x3B, 0xCA, 0x14, 0xFA, 0x23, 0xF2, 0xC1 + }, + { + 0x88, 0xBF, 0xB9, 0x1C, 0x4C, 0xD2, 0x49, 0xA5, + 0x28, 0x8C, 0xD7, 0x60, 0x6D, 0x32, 0xFF, 0x38, + 0xA5, 0xB2, 0xD8, 0xA4, 0xEE, 0x53, 0x61, 0x5E, + 0x55, 0x25, 0x3C, 0x0E, 0xD8, 0x59, 0xB3, 0x30, + 0xDF, 0x7F, 0x73, 0xE1, 0x5B, 0x43, 0x43, 0x35, + 0x24, 0xF9, 0x03, 0x5E, 0x3A, 0x1A, 0x6B, 0x20, + 0xC1, 0x71, 0x0B, 0x91, 0x58, 0xD2, 0x1A, 0xAE, + 0x25, 0x67, 0xCC, 0x56, 0x2F, 0xD6, 0xEE, 0x18 + }, + { + 0xAF, 0xF7, 0x5F, 0x5E, 0x9F, 0xF3, 0x4B, 0x30, + 0x05, 0x11, 0x21, 0x77, 0x82, 0x25, 0x74, 0x6E, + 0x7C, 0x20, 0x56, 0x1B, 0x7B, 0x96, 0x6E, 0x2F, + 0x58, 0x0F, 0x1F, 0xBB, 0x6B, 0x58, 0xF7, 0xAB, + 0xB4, 0xBB, 0x65, 0x5D, 0x09, 0xB4, 0xBF, 0xA0, + 0xD6, 0xAB, 0xF1, 0x9F, 0x59, 0x67, 0xAA, 0xB1, + 0xB6, 0x7E, 0x55, 0xF2, 0x2B, 0xC4, 0xA4, 0x66, + 0xDA, 0x68, 0x15, 0x95, 0xF1, 0x20, 0x5E, 0x37 + }, + { + 0xAF, 0xEE, 0x36, 0x7B, 0x5B, 0xB9, 0xA4, 0x74, + 0x4D, 0xBA, 0xBB, 0x67, 0x5D, 0x0A, 0x13, 0x69, + 0x9C, 0x59, 0x83, 0x31, 0x76, 0x50, 0x9A, 0xF1, + 0x3D, 0xCF, 0x70, 0xFF, 0x96, 0x6B, 0x58, 0x4D, + 0xBE, 0x19, 0x86, 0x02, 0xE0, 0x54, 0x6B, 0xFF, + 0x26, 0xF2, 0x67, 0xEF, 0x52, 0x27, 0x75, 0x19, + 0x9F, 0x92, 0xDA, 0xB7, 0xCA, 0xB4, 0xD7, 0x90, + 0x65, 0x38, 0xC5, 0x6E, 0x9D, 0xC8, 0xB4, 0x54 + }, + { + 0xFF, 0x47, 0xE4, 0x82, 0xA8, 0xDE, 0x2C, 0x17, + 0x43, 0xDF, 0xD2, 0xAA, 0x76, 0x49, 0xA9, 0x54, + 0x67, 0x2B, 0x5F, 0x4C, 0xD5, 0x4B, 0x1E, 0xF4, + 0xD0, 0xE8, 0x38, 0x44, 0xCB, 0xEE, 0xE6, 0x35, + 0xD8, 0x52, 0x56, 0x33, 0xC9, 0x4D, 0xCF, 0x1A, + 0xCF, 0xAE, 0xFA, 0xC1, 0x91, 0x09, 0xD6, 0x0F, + 0xE7, 0x11, 0x9F, 0x63, 0x06, 0xAD, 0xFA, 0x5F, + 0x70, 0x7A, 0xA7, 0xD1, 0x05, 0x54, 0xCD, 0x95 + }, + { + 0xDC, 0x4B, 0xAB, 0x96, 0x65, 0x26, 0x00, 0x19, + 0x22, 0x50, 0x68, 0xDE, 0x3F, 0xD6, 0x9C, 0xE1, + 0x5E, 0x5F, 0x53, 0x81, 0x37, 0x04, 0xDB, 0x50, + 0x7F, 0xD7, 0x79, 0xD8, 0x11, 0x96, 0xA0, 0x49, + 0xE3, 0xBA, 0xAF, 0x86, 0x6D, 0x97, 0xE4, 0x0C, + 0x2A, 0x86, 0x50, 0x6E, 0xD8, 0x98, 0xCE, 0x3D, + 0xA5, 0xE6, 0x06, 0xCD, 0x6A, 0x65, 0x95, 0x3F, + 0x82, 0x3E, 0xEB, 0x13, 0x59, 0x24, 0xF9, 0x8C + }, + { + 0x75, 0xC4, 0x71, 0x6B, 0xE1, 0xFB, 0xE0, 0x0A, + 0xE6, 0x2C, 0x11, 0xF8, 0x77, 0x52, 0x11, 0x7E, + 0xE3, 0xAB, 0x74, 0x03, 0x99, 0x29, 0xD7, 0xEA, + 0xD8, 0x97, 0x7F, 0x39, 0x3C, 0xEC, 0x59, 0xFE, + 0xAA, 0x3E, 0xFA, 0xBC, 0x59, 0x58, 0xBE, 0x14, + 0x04, 0x5D, 0x5D, 0x54, 0x67, 0xF9, 0x40, 0x86, + 0xA6, 0xFD, 0xB3, 0x1A, 0x35, 0xDF, 0xA0, 0x09, + 0xE6, 0x09, 0xA4, 0x67, 0xD4, 0x6A, 0x0F, 0xE6 + }, + { + 0x3E, 0x26, 0x56, 0x60, 0x8B, 0xF2, 0xED, 0xA3, + 0x9B, 0x0A, 0xF3, 0x26, 0x91, 0x0B, 0x4C, 0x1F, + 0xA4, 0x29, 0x9C, 0x68, 0xBB, 0x13, 0xFD, 0x11, + 0x1A, 0x12, 0x2F, 0xF5, 0x7E, 0xD2, 0x8F, 0x4A, + 0x34, 0x58, 0x31, 0x6C, 0x4F, 0x3D, 0xF0, 0x38, + 0xEA, 0xEE, 0x62, 0x81, 0x7B, 0x29, 0xF6, 0x34, + 0x4D, 0x6D, 0x72, 0x20, 0x5B, 0x4B, 0x95, 0x5B, + 0xED, 0x6B, 0xC2, 0xF8, 0x43, 0xF1, 0x4F, 0x04 + }, + { + 0x20, 0xFA, 0x8A, 0x05, 0x73, 0x7C, 0x7C, 0x77, + 0x46, 0x58, 0x47, 0x82, 0xAA, 0xFF, 0x68, 0xA0, + 0xEC, 0x98, 0xFD, 0x77, 0xB6, 0xF5, 0xC6, 0x8B, + 0x4F, 0x94, 0x11, 0x7C, 0x59, 0xE9, 0x27, 0x3C, + 0x75, 0xEA, 0x5D, 0x53, 0xBD, 0x32, 0x12, 0x0C, + 0x0C, 0x3D, 0x4B, 0x88, 0xD5, 0x65, 0x50, 0x18, + 0x35, 0x5C, 0x55, 0x2C, 0xC5, 0xF7, 0xDE, 0xC3, + 0x37, 0xE8, 0xE8, 0x12, 0x5A, 0xD1, 0xCD, 0xCA + }, + { + 0xB7, 0x36, 0x47, 0x59, 0x27, 0x0E, 0xBF, 0x9C, + 0xF5, 0xC1, 0x89, 0x4F, 0x30, 0xE2, 0x63, 0x66, + 0x52, 0x45, 0x2F, 0xC6, 0x75, 0xBA, 0x68, 0x09, + 0x3A, 0xFB, 0xA1, 0x42, 0x95, 0x7F, 0x9A, 0xE6, + 0xE0, 0x9B, 0xC2, 0xC7, 0xB1, 0x8D, 0x2B, 0x00, + 0xEC, 0x15, 0x62, 0xF4, 0x3A, 0xB6, 0x7B, 0x5A, + 0xB5, 0x34, 0xAD, 0x37, 0xC4, 0x8E, 0xCA, 0xC7, + 0xFF, 0xF2, 0xF8, 0x9A, 0xE3, 0x17, 0x25, 0xE1 + }, + { + 0x57, 0x4D, 0xEE, 0x16, 0x87, 0x99, 0xC0, 0x85, + 0xB7, 0x6B, 0x92, 0xF6, 0x39, 0x6E, 0x02, 0xEF, + 0xCB, 0xCC, 0x09, 0xCD, 0x32, 0x3D, 0x14, 0x81, + 0x30, 0xFA, 0xEF, 0x3C, 0xCA, 0x33, 0xB5, 0x07, + 0x3B, 0xAA, 0xE9, 0xF0, 0x5E, 0xFF, 0xE4, 0x26, + 0x96, 0xB8, 0xD3, 0x26, 0x40, 0xEC, 0xA1, 0x92, + 0x3C, 0xAA, 0x93, 0x82, 0x53, 0x65, 0xF6, 0x0D, + 0xA3, 0xC4, 0x76, 0x46, 0xEF, 0x05, 0x98, 0x5D + }, + { + 0x5A, 0x0A, 0x3B, 0x15, 0x36, 0x54, 0x6E, 0x11, + 0x9F, 0x25, 0xF5, 0xFF, 0x29, 0xE1, 0x44, 0x4B, + 0xAE, 0x46, 0x2A, 0xAC, 0x24, 0xB8, 0x1A, 0xFF, + 0x16, 0xE6, 0xE8, 0x84, 0xBE, 0x41, 0xFC, 0xF0, + 0xFC, 0x26, 0x80, 0xDD, 0xB3, 0x3F, 0x17, 0x98, + 0x02, 0x14, 0x13, 0xF4, 0xE4, 0x0D, 0x59, 0x1A, + 0xBD, 0x5D, 0x8C, 0x89, 0x29, 0xB9, 0x6F, 0xFB, + 0x99, 0x31, 0xE5, 0xFE, 0x36, 0xA1, 0x4C, 0x66 + }, + { + 0x10, 0x78, 0xE4, 0x48, 0xCA, 0xE1, 0x3E, 0x76, + 0x30, 0xE5, 0x8C, 0x51, 0x91, 0x63, 0x2E, 0x2F, + 0xC7, 0x27, 0xD9, 0x60, 0xB6, 0xD7, 0x98, 0x1F, + 0x6B, 0xD8, 0x30, 0xB7, 0x41, 0x52, 0xB4, 0xC8, + 0x26, 0x58, 0x57, 0x36, 0xF3, 0x9A, 0xA4, 0xF9, + 0x6A, 0x31, 0xB6, 0x85, 0x5B, 0x4A, 0x05, 0x63, + 0x63, 0x39, 0xC6, 0x2F, 0xAA, 0x70, 0x36, 0xD6, + 0xCB, 0x90, 0x9B, 0xAF, 0xC3, 0x22, 0x25, 0x37 + }, + { + 0x8D, 0x91, 0x15, 0x66, 0x6B, 0x61, 0xA4, 0xE2, + 0xAD, 0xFB, 0x17, 0xB7, 0x88, 0x7F, 0xFF, 0x35, + 0xB2, 0x7E, 0xC2, 0xF0, 0xC4, 0x45, 0x64, 0xF3, + 0xD2, 0x17, 0xC7, 0xC3, 0x75, 0xD6, 0xA0, 0x5D, + 0x62, 0xBE, 0xAC, 0xDB, 0x1D, 0x13, 0x46, 0x81, + 0x19, 0x51, 0xCF, 0x7A, 0x01, 0xE8, 0x94, 0x73, + 0x7C, 0x49, 0x2F, 0xED, 0x78, 0xB7, 0x0D, 0x5A, + 0x45, 0x3C, 0xB0, 0x98, 0x41, 0x9E, 0x70, 0xD7 + }, + { + 0xBD, 0xF1, 0x05, 0x15, 0x01, 0x48, 0x16, 0x62, + 0x10, 0x09, 0xB7, 0x1B, 0x1D, 0xCC, 0xB0, 0x21, + 0x29, 0xCC, 0x3D, 0xE1, 0x8E, 0xE8, 0x82, 0x38, + 0x4C, 0x5D, 0x3D, 0x50, 0x52, 0xE2, 0xDC, 0x97, + 0x64, 0x9E, 0x3C, 0x52, 0x94, 0xBB, 0x1E, 0x06, + 0xDE, 0x88, 0x68, 0x50, 0xC5, 0xFB, 0x99, 0x24, + 0xD8, 0x42, 0x30, 0xB2, 0x09, 0x83, 0x01, 0x30, + 0x81, 0x18, 0x9D, 0xD2, 0xFF, 0x88, 0x54, 0x82 + }, + { + 0xC1, 0xE5, 0xB9, 0xD8, 0x63, 0xF6, 0x3B, 0xE0, + 0xBE, 0x36, 0x47, 0xEF, 0x57, 0x21, 0x4D, 0xAF, + 0xC6, 0xB8, 0x9F, 0x89, 0xE9, 0xC2, 0x8B, 0xE7, + 0xB2, 0x39, 0x7E, 0xD0, 0x2A, 0xCA, 0x63, 0x05, + 0x0D, 0x09, 0xDA, 0xD7, 0xB7, 0xD8, 0x27, 0xBF, + 0x86, 0xD0, 0x38, 0x4B, 0x99, 0x8B, 0xF2, 0x05, + 0x63, 0x6A, 0x50, 0xE5, 0xEE, 0xC6, 0x86, 0x84, + 0xFB, 0x46, 0xF5, 0xA2, 0x21, 0x0A, 0x1F, 0xEF + }, + { + 0x6C, 0xEA, 0xE0, 0x44, 0x1A, 0x0B, 0x09, 0x5C, + 0xFE, 0xA8, 0xFC, 0x1F, 0x31, 0x2A, 0x4E, 0x05, + 0xF2, 0x15, 0x9C, 0xFA, 0x0E, 0x62, 0xB2, 0x3C, + 0xB3, 0x7E, 0xAC, 0x03, 0x22, 0x8D, 0x23, 0x15, + 0x4A, 0xAE, 0x01, 0xBE, 0x30, 0xD5, 0x27, 0xF9, + 0xE3, 0xBE, 0x46, 0xFF, 0x2C, 0xE9, 0x25, 0x1A, + 0x2C, 0xE8, 0x24, 0x87, 0x0A, 0xED, 0x3C, 0x06, + 0xA1, 0x89, 0x08, 0x20, 0x7E, 0x9D, 0x06, 0x4E + }, + { + 0x59, 0xC8, 0xB5, 0x21, 0x03, 0x83, 0xDA, 0xA6, + 0xF3, 0xC7, 0xB6, 0xE9, 0xE3, 0x16, 0x44, 0xFC, + 0x45, 0x4F, 0xCE, 0xAB, 0x49, 0xD7, 0xAA, 0x7A, + 0xC3, 0xC5, 0x03, 0xA0, 0x6C, 0x2E, 0x45, 0x42, + 0xB7, 0x12, 0xA1, 0x3B, 0x09, 0x36, 0xD4, 0xE7, + 0xD4, 0xFE, 0x6F, 0x81, 0x3A, 0xD1, 0x50, 0xBA, + 0xA1, 0xD5, 0xBA, 0x0A, 0x5A, 0x62, 0x73, 0x45, + 0xE6, 0x91, 0x89, 0x00, 0x12, 0xA7, 0x48, 0x29 + }, + { + 0x0E, 0x5D, 0xE5, 0x56, 0x2F, 0xB2, 0x08, 0xE6, + 0x02, 0x2D, 0xBC, 0x83, 0xAB, 0xB1, 0x16, 0xA9, + 0x86, 0xD8, 0xF3, 0x2E, 0x45, 0xBF, 0x31, 0x61, + 0xE1, 0x1F, 0xD2, 0x05, 0x6A, 0xF8, 0xC6, 0x3B, + 0x46, 0x34, 0xE7, 0x6C, 0xF8, 0xBF, 0xE8, 0x5C, + 0xB4, 0xFA, 0xBC, 0x07, 0x05, 0xD5, 0xEE, 0x0A, + 0xA6, 0x0E, 0x41, 0x0D, 0x8B, 0x7C, 0xC7, 0xDB, + 0xB2, 0xA2, 0x6C, 0xF1, 0xC5, 0x51, 0x8C, 0x87 + }, + { + 0x97, 0xD4, 0x03, 0xC1, 0x4C, 0x3E, 0x8A, 0x55, + 0xBE, 0x02, 0x3C, 0xBC, 0xB1, 0x0D, 0x0B, 0xB2, + 0xBD, 0x29, 0x3E, 0x9B, 0x7A, 0x88, 0x57, 0xDA, + 0x7E, 0x30, 0x07, 0x4C, 0x07, 0xC8, 0x01, 0x5F, + 0x16, 0xFC, 0x77, 0x1F, 0x26, 0xA0, 0xF4, 0xF7, + 0xCB, 0x12, 0x2B, 0x0C, 0x09, 0xDE, 0x25, 0xD7, + 0x56, 0x79, 0xB4, 0x1F, 0xCF, 0x6A, 0x43, 0xAF, + 0x51, 0x48, 0x03, 0x1A, 0x36, 0x5D, 0x53, 0xBE + }, + { + 0x1E, 0xF8, 0x5C, 0xF4, 0x8A, 0x79, 0xAD, 0xA0, + 0x5F, 0x39, 0xFA, 0x52, 0xC6, 0xFD, 0x3F, 0x30, + 0xEC, 0xCD, 0x78, 0xE2, 0xCB, 0x32, 0x0D, 0xC8, + 0x23, 0xD6, 0x6C, 0x99, 0x31, 0x57, 0xDF, 0xAA, + 0xC7, 0xF6, 0x46, 0x62, 0x48, 0x4A, 0x09, 0xCF, + 0x27, 0x2F, 0x32, 0x8E, 0x20, 0x34, 0xCB, 0xE3, + 0x9E, 0x42, 0x89, 0x6D, 0xB3, 0x25, 0x8B, 0x6D, + 0x57, 0x26, 0xF2, 0x37, 0x37, 0x09, 0x23, 0xFB + }, + { + 0x56, 0xB2, 0x11, 0xAC, 0x06, 0xAC, 0x13, 0x7F, + 0x1E, 0x4C, 0x0E, 0xEA, 0x23, 0x61, 0x7E, 0x8F, + 0x99, 0xFB, 0x55, 0x96, 0x56, 0x74, 0xE3, 0x18, + 0x52, 0xF3, 0xBA, 0x80, 0x5B, 0xDC, 0xD2, 0xB2, + 0xFA, 0xC4, 0x0F, 0x7A, 0x3F, 0xF9, 0x01, 0xC4, + 0x20, 0xCC, 0xE9, 0x04, 0x70, 0xF5, 0x6F, 0xF9, + 0x16, 0x36, 0xF4, 0xDC, 0x83, 0x03, 0x8A, 0xBE, + 0x9C, 0x26, 0xBD, 0x61, 0xFE, 0xEE, 0xCA, 0x62 + }, + { + 0xE8, 0x7C, 0xE7, 0x7D, 0x2A, 0xB6, 0x5F, 0xD9, + 0x56, 0x33, 0x73, 0x19, 0xA6, 0x74, 0x3E, 0xC7, + 0xFA, 0x55, 0x48, 0x7A, 0x88, 0xA4, 0x8E, 0xB1, + 0xB7, 0x8B, 0x2F, 0xA8, 0x7D, 0x80, 0x3E, 0xFB, + 0x71, 0x78, 0x57, 0x5C, 0x59, 0x30, 0xF8, 0xBB, + 0x89, 0xD8, 0x94, 0x60, 0xFD, 0x48, 0x83, 0x2D, + 0xB3, 0xEE, 0xBA, 0x8B, 0xAC, 0x8D, 0xB8, 0xF3, + 0x8C, 0x11, 0x86, 0x77, 0x9F, 0x90, 0xAE, 0xE4 + }, + { + 0xDA, 0x69, 0x8A, 0x06, 0xE3, 0x5C, 0x21, 0x1D, + 0x3D, 0xFD, 0x56, 0xD1, 0x91, 0x2D, 0x02, 0x70, + 0x49, 0x8F, 0xA9, 0x8C, 0x4E, 0xEB, 0x70, 0x4D, + 0x98, 0x75, 0x2B, 0x8E, 0x77, 0x57, 0xC8, 0x11, + 0x66, 0x5C, 0x78, 0x4E, 0xA9, 0x9A, 0x47, 0x61, + 0x73, 0x0D, 0xC7, 0x91, 0x94, 0x65, 0x48, 0x21, + 0x5B, 0x05, 0x07, 0x6C, 0x03, 0x1A, 0xA0, 0xBA, + 0x44, 0x21, 0x18, 0xF9, 0xEC, 0xB2, 0xA5, 0x46 + }, + { + 0xB7, 0x6B, 0xC1, 0x89, 0xED, 0xE7, 0x25, 0x9A, + 0xA6, 0xCD, 0x9C, 0xAA, 0x45, 0x4A, 0xA3, 0xC5, + 0x44, 0x54, 0x10, 0xDF, 0xAA, 0x5F, 0x17, 0x71, + 0xBB, 0x89, 0xD6, 0x75, 0x6A, 0x6E, 0xD5, 0xD6, + 0xEF, 0xBF, 0x66, 0xFB, 0x43, 0xA4, 0x83, 0xA8, + 0x67, 0xE6, 0xE5, 0x2A, 0xD2, 0x9D, 0x43, 0xD6, + 0xDA, 0xC9, 0x66, 0x6A, 0x67, 0x1D, 0x09, 0x06, + 0x5F, 0xC7, 0xED, 0x74, 0xAF, 0x77, 0x0E, 0x2B + }, + { + 0x04, 0xA9, 0x05, 0xFF, 0x09, 0x77, 0x63, 0xBE, + 0x72, 0x7A, 0xB6, 0xD6, 0x62, 0xA6, 0x8B, 0x2E, + 0xC7, 0x90, 0x10, 0x5E, 0xC9, 0x29, 0x57, 0x1D, + 0x70, 0x2A, 0xB9, 0x15, 0x65, 0xA3, 0x37, 0xE2, + 0xA6, 0x80, 0x7E, 0x6A, 0xB0, 0x8C, 0x20, 0xC1, + 0xAD, 0xB8, 0xA3, 0x2F, 0x32, 0xAE, 0xE0, 0x33, + 0xB0, 0x89, 0x29, 0x16, 0x13, 0xF6, 0x44, 0x53, + 0xA9, 0x8C, 0x3E, 0x66, 0xE3, 0xB1, 0xE1, 0xC9 + }, + { + 0x8F, 0x9A, 0x01, 0x32, 0xA5, 0x0E, 0xEC, 0x92, + 0xED, 0x3A, 0xB0, 0x85, 0xA0, 0x3A, 0xCB, 0x64, + 0x7A, 0x5A, 0x8C, 0x6F, 0x12, 0x91, 0x11, 0x14, + 0x75, 0x23, 0xD7, 0x69, 0x19, 0xD1, 0x39, 0x3E, + 0x5E, 0x82, 0x8C, 0xAD, 0x8E, 0xD7, 0x32, 0x2B, + 0x71, 0xAE, 0xDE, 0x34, 0x3F, 0x5C, 0x5D, 0xA2, + 0x6C, 0x11, 0xAB, 0x1D, 0xFA, 0x55, 0xB4, 0x10, + 0x5A, 0x05, 0xE4, 0x12, 0x7B, 0xDA, 0x2D, 0x83 + }, + { + 0x8E, 0x22, 0x37, 0xB9, 0x84, 0x7D, 0xC2, 0xD7, + 0x39, 0x36, 0x62, 0x8B, 0xA5, 0x59, 0x38, 0x4A, + 0xD8, 0xF5, 0xFB, 0x19, 0x92, 0x0E, 0x62, 0xCE, + 0x4C, 0xCD, 0x9E, 0xC8, 0x58, 0x62, 0x87, 0xA9, + 0xF1, 0x01, 0x3D, 0xB3, 0xD8, 0xE5, 0x42, 0x35, + 0x8C, 0x20, 0xD2, 0x5F, 0xC7, 0xC9, 0xA3, 0xA8, + 0x90, 0x40, 0x0E, 0x3C, 0xAE, 0x6E, 0xCC, 0x7A, + 0xEC, 0xDA, 0xEB, 0xF9, 0xBD, 0x64, 0x3F, 0x94 + }, + { + 0xAE, 0xA0, 0x4E, 0x4A, 0x9D, 0x83, 0xC1, 0xAC, + 0x4B, 0x73, 0x1A, 0x33, 0xFC, 0x82, 0x8D, 0xBE, + 0x05, 0xA1, 0x37, 0x1E, 0xF3, 0xB2, 0xCE, 0xF8, + 0x1B, 0x4B, 0xAD, 0xCC, 0x12, 0xF5, 0x96, 0xFF, + 0x9E, 0x7E, 0x9F, 0xFE, 0x6F, 0x8F, 0xA9, 0xC7, + 0xBA, 0xDC, 0x50, 0xC3, 0xFC, 0x3C, 0x48, 0x59, + 0xB5, 0xC2, 0xE1, 0x58, 0xB3, 0xC7, 0xCB, 0x5A, + 0x3F, 0xF5, 0x54, 0x2C, 0x68, 0x69, 0xAC, 0xE2 + }, + { + 0x6A, 0x82, 0x4F, 0x8F, 0x00, 0xBA, 0xE4, 0xF7, + 0x70, 0x4D, 0xB5, 0xAC, 0x3F, 0x67, 0xE8, 0x7C, + 0x69, 0x88, 0x1E, 0x31, 0xD0, 0x9D, 0xA0, 0x4D, + 0xEC, 0xC9, 0x80, 0xD8, 0x6C, 0xBA, 0x4A, 0x60, + 0xCE, 0x40, 0x74, 0x45, 0x7B, 0x3E, 0x3D, 0x1E, + 0xA1, 0x4F, 0xDD, 0xC9, 0x35, 0x39, 0xB9, 0xE0, + 0xC1, 0xCC, 0x25, 0x95, 0xF8, 0x31, 0x5C, 0x68, + 0x4A, 0x64, 0x8A, 0x19, 0xE7, 0xA7, 0x57, 0xFD + }, + { + 0x65, 0xF1, 0x7B, 0x7C, 0x2E, 0x10, 0x8B, 0x32, + 0x40, 0xBC, 0xA4, 0x76, 0xD4, 0xAA, 0xB2, 0xBA, + 0xA6, 0x20, 0x30, 0x71, 0x80, 0xC5, 0xB2, 0x19, + 0x2E, 0x4F, 0xFE, 0x0A, 0xB8, 0x6A, 0xD7, 0xFE, + 0x90, 0x96, 0xBA, 0xBE, 0x8E, 0xD2, 0xC9, 0xEE, + 0xCD, 0x68, 0xBB, 0x38, 0x0E, 0x8D, 0x8D, 0x66, + 0x57, 0x5B, 0x35, 0xF0, 0x7E, 0x84, 0xBF, 0xEF, + 0x44, 0x18, 0x76, 0x45, 0xFC, 0xCB, 0xC2, 0x60 + }, + { + 0x4D, 0x9E, 0x86, 0x3A, 0x4E, 0x78, 0x6C, 0x71, + 0x22, 0x6E, 0x4E, 0xAE, 0x0D, 0x18, 0x11, 0xE8, + 0x33, 0xE1, 0x29, 0x82, 0x9A, 0x24, 0xCF, 0x75, + 0x97, 0xA6, 0x18, 0x72, 0x37, 0x2B, 0xB6, 0x46, + 0xB1, 0xA5, 0x53, 0xF0, 0x88, 0x4D, 0x4D, 0xFE, + 0xB0, 0x0B, 0xDC, 0xC7, 0x9C, 0x08, 0xCB, 0x4D, + 0x87, 0xD7, 0x55, 0xFC, 0x14, 0xD3, 0x54, 0x4C, + 0x80, 0x42, 0x9B, 0x00, 0x2C, 0xB0, 0x03, 0x4F + }, + { + 0x63, 0xA4, 0xA0, 0x8D, 0x7A, 0x90, 0xCD, 0xB3, + 0x08, 0x5E, 0x83, 0x29, 0xB4, 0xC3, 0x8F, 0x69, + 0x2E, 0x33, 0x65, 0x55, 0xFC, 0x50, 0x8F, 0x9D, + 0x65, 0x8F, 0x31, 0xAF, 0x10, 0x9C, 0x0A, 0x14, + 0x2D, 0xD8, 0x18, 0xA5, 0xEB, 0x98, 0xD8, 0x39, + 0xCA, 0xE1, 0xC4, 0xA5, 0x6B, 0x50, 0x0E, 0xE1, + 0x3D, 0x45, 0x7E, 0x87, 0x31, 0xDD, 0xCB, 0x9B, + 0x87, 0xBD, 0x1D, 0xCD, 0x0D, 0x42, 0xB4, 0x61 + }, + { + 0xDB, 0x64, 0x56, 0xA6, 0x5A, 0x99, 0xFE, 0xA2, + 0xA2, 0xE7, 0xD3, 0xBC, 0x2D, 0xF6, 0xCC, 0xC4, + 0x6F, 0xF3, 0x9A, 0xAF, 0x48, 0x01, 0x9E, 0x94, + 0x6F, 0x4E, 0x60, 0x4B, 0x16, 0xF7, 0x1B, 0x46, + 0xF4, 0x3E, 0xB5, 0x9C, 0xDE, 0x01, 0x00, 0x60, + 0x5F, 0x06, 0x97, 0xD3, 0xD7, 0xAC, 0x76, 0x65, + 0x5E, 0x2F, 0xD2, 0xA6, 0x34, 0xF3, 0x6E, 0xF8, + 0x4C, 0x6E, 0xEE, 0x3E, 0x53, 0x21, 0x30, 0x74 + }, + { + 0x84, 0x19, 0x4D, 0x94, 0xF6, 0x9E, 0x08, 0x04, + 0xBF, 0xEB, 0x1D, 0xBF, 0x42, 0x7C, 0xF2, 0xC8, + 0x7C, 0x41, 0xEC, 0x18, 0x35, 0x2D, 0x37, 0x90, + 0xC2, 0x9E, 0x68, 0x3E, 0x83, 0xA1, 0xAF, 0xCF, + 0xDA, 0xE9, 0xD9, 0xE7, 0x3F, 0x46, 0x8E, 0xFD, + 0x37, 0x1B, 0x50, 0x62, 0xA5, 0x0B, 0x66, 0x0F, + 0x1F, 0x86, 0x13, 0x69, 0x57, 0x11, 0x47, 0xEA, + 0x10, 0x7E, 0x0F, 0xD4, 0x4B, 0xD0, 0xEF, 0x76 + }, + { + 0xB3, 0x83, 0x68, 0x6F, 0xE9, 0xD0, 0x90, 0xA8, + 0x74, 0x7B, 0x11, 0x6A, 0xBE, 0xDF, 0x3D, 0x54, + 0x46, 0xE1, 0xB4, 0xC6, 0x94, 0x75, 0xFC, 0x7F, + 0x27, 0xD2, 0x69, 0xE4, 0xD7, 0xB0, 0xBA, 0x64, + 0x1E, 0x50, 0xB7, 0x8F, 0xCE, 0x6B, 0xDF, 0xE6, + 0xA4, 0xE6, 0x15, 0x23, 0x98, 0x1C, 0x37, 0xC2, + 0x68, 0x73, 0xE8, 0xE5, 0xA5, 0xFA, 0x6A, 0x9E, + 0xC0, 0x75, 0xFB, 0x84, 0xB9, 0xC7, 0xA0, 0x6A + }, + { + 0x5E, 0xAF, 0xB3, 0xC7, 0xA0, 0xBC, 0xA9, 0xD1, + 0x50, 0x14, 0x1B, 0xC8, 0x82, 0x54, 0xEC, 0xE8, + 0x28, 0x03, 0x31, 0x88, 0x4B, 0x9B, 0x73, 0xDC, + 0x3A, 0x91, 0x3A, 0xC2, 0x7C, 0xC8, 0xD5, 0x62, + 0x35, 0x49, 0x12, 0xE2, 0x01, 0x29, 0x5E, 0x82, + 0x2E, 0x4E, 0x41, 0xBE, 0x68, 0xD9, 0x8F, 0xBB, + 0x1E, 0xE9, 0xA6, 0x62, 0x3D, 0xF8, 0x91, 0x0A, + 0x61, 0xD3, 0xC1, 0x3E, 0x00, 0xE1, 0x17, 0xFE + }, + { + 0x8A, 0x9E, 0xF4, 0x0F, 0xA6, 0x56, 0x46, 0x04, + 0x0A, 0x18, 0x4F, 0xCD, 0xEB, 0xB5, 0xF4, 0x19, + 0xE7, 0x63, 0xA5, 0x53, 0x80, 0xE0, 0xA8, 0xB7, + 0x12, 0xF1, 0x2D, 0x93, 0x25, 0x56, 0xBC, 0x61, + 0x77, 0xB9, 0x70, 0xB3, 0xC2, 0x62, 0x14, 0xC5, + 0x93, 0x46, 0xE7, 0x4E, 0x5E, 0x6C, 0x84, 0xAB, + 0x9C, 0x49, 0xB7, 0xA7, 0xE9, 0xA7, 0x5E, 0x60, + 0x80, 0x60, 0xBD, 0x1A, 0xED, 0xC0, 0x54, 0xE0 + }, + { + 0x0D, 0xA5, 0xD5, 0xC9, 0x4F, 0x97, 0xE0, 0xFE, + 0x07, 0xA7, 0x3E, 0x08, 0x50, 0x50, 0x53, 0xAD, + 0xA7, 0x4B, 0xC9, 0xD4, 0x60, 0x40, 0xD9, 0xC0, + 0xD8, 0x08, 0xD5, 0xFC, 0xFA, 0xFB, 0x91, 0xAA, + 0x0D, 0x3F, 0xE8, 0xB2, 0xEB, 0xD4, 0xDF, 0x2D, + 0x75, 0xEE, 0x0C, 0xCD, 0x16, 0x96, 0xF9, 0xAD, + 0x07, 0x87, 0x82, 0x75, 0x17, 0xA6, 0xF3, 0xE6, + 0xCA, 0xAF, 0x4D, 0x7D, 0xFE, 0xFF, 0x11, 0x4C + }, + { + 0x10, 0xCC, 0xC8, 0x89, 0xA5, 0xB7, 0x6E, 0xBA, + 0xD6, 0xB9, 0x27, 0x38, 0x48, 0xC0, 0x54, 0x67, + 0xDA, 0x31, 0x46, 0x57, 0x39, 0xBB, 0x55, 0xD9, + 0xE6, 0x75, 0xA0, 0x49, 0x35, 0x5A, 0x53, 0xD4, + 0x00, 0x5A, 0x1A, 0x8A, 0x9B, 0xF1, 0x17, 0x70, + 0xC7, 0xA2, 0x26, 0xDC, 0x0F, 0xFB, 0x49, 0xDE, + 0x9E, 0xC6, 0xC3, 0x13, 0x5F, 0x18, 0xE0, 0x17, + 0x1B, 0x73, 0x4D, 0xCA, 0x9B, 0x7D, 0x82, 0xF7 + }, + { + 0x24, 0xD2, 0x64, 0xB4, 0xE7, 0xD5, 0x4C, 0x3A, + 0xD7, 0xE2, 0xF9, 0xBC, 0xF2, 0xD6, 0x7B, 0xE5, + 0xBB, 0x4E, 0x03, 0x29, 0x50, 0xFF, 0xCC, 0x32, + 0xF9, 0x28, 0x6A, 0x07, 0x05, 0x68, 0x07, 0x58, + 0x13, 0x4F, 0x8B, 0x5A, 0xC6, 0xBE, 0x17, 0x7A, + 0xCA, 0xF6, 0x0F, 0x0F, 0xAA, 0xCE, 0x27, 0x87, + 0xFF, 0x98, 0x19, 0x21, 0x76, 0xC9, 0x52, 0x04, + 0xFF, 0x80, 0x51, 0xD5, 0x1C, 0x5E, 0x13, 0x1D + }, + { + 0xAE, 0x19, 0xCE, 0x9D, 0xC2, 0x39, 0x09, 0xCE, + 0x67, 0xFA, 0x36, 0x80, 0x1C, 0x6F, 0xAF, 0x9C, + 0x2F, 0x14, 0xE9, 0x6A, 0x03, 0xA5, 0x42, 0xB1, + 0x6B, 0x9C, 0x28, 0x8B, 0xE1, 0xFE, 0xD8, 0x11, + 0xAC, 0x5D, 0xFD, 0xC6, 0x39, 0xCB, 0xF5, 0x24, + 0x8C, 0x07, 0x1B, 0xC2, 0x2E, 0x55, 0xEC, 0x14, + 0x50, 0x06, 0x15, 0x5F, 0x46, 0x12, 0xE2, 0x2F, + 0xDF, 0xF7, 0x87, 0x04, 0x3A, 0x01, 0x84, 0x66 + }, + { + 0x60, 0x69, 0xD0, 0x51, 0x54, 0xC4, 0x50, 0x45, + 0x2A, 0xBE, 0x85, 0x87, 0x34, 0x86, 0x68, 0x69, + 0x55, 0xB1, 0x7F, 0x0A, 0x95, 0xEE, 0x06, 0xD2, + 0xE0, 0xC0, 0x1A, 0xA8, 0x82, 0x4D, 0xF9, 0xBD, + 0x92, 0x1C, 0xC0, 0xD1, 0xCE, 0xC8, 0xD9, 0x6E, + 0xAF, 0xC5, 0x12, 0x6D, 0xE1, 0x97, 0x42, 0xE3, + 0x7B, 0x17, 0x76, 0x2B, 0x50, 0xEB, 0x36, 0xE8, + 0x23, 0xBB, 0x28, 0x66, 0x32, 0x7C, 0x62, 0xC0 + }, + { + 0xBF, 0xDE, 0x01, 0xB3, 0xDC, 0x14, 0x4A, 0x63, + 0xCD, 0x20, 0x65, 0xB0, 0xA0, 0xAB, 0x3C, 0x2C, + 0xC3, 0x9E, 0x38, 0x5B, 0xA8, 0x8F, 0xF4, 0xB7, + 0xB4, 0x34, 0xA3, 0x29, 0x28, 0xF1, 0x89, 0xFC, + 0x4B, 0xA5, 0x58, 0xED, 0xE8, 0x72, 0x01, 0xB8, + 0x67, 0xD0, 0x87, 0xCE, 0x93, 0x33, 0xD9, 0x32, + 0x1A, 0x31, 0x79, 0x7D, 0x9F, 0xCE, 0xBE, 0x52, + 0xB9, 0x39, 0xA7, 0x87, 0x73, 0xCB, 0xC3, 0x77 + }, + { + 0xC9, 0x80, 0xA8, 0x0D, 0x0D, 0x14, 0xD7, 0xD7, + 0x1D, 0x57, 0x0A, 0xFD, 0x97, 0x4D, 0xA9, 0x91, + 0xD5, 0x9C, 0x7B, 0x59, 0x63, 0xA9, 0xE0, 0xE5, + 0x0E, 0xD9, 0xB1, 0xA0, 0x04, 0x01, 0xD0, 0xBB, + 0x29, 0x9E, 0xA1, 0x3B, 0xB9, 0x44, 0xCD, 0xB5, + 0xBC, 0x77, 0x64, 0xBE, 0xCA, 0x99, 0xDB, 0xA2, + 0x89, 0x94, 0xC9, 0x96, 0x0D, 0x97, 0xC3, 0x8D, + 0x65, 0x66, 0x8C, 0x25, 0x0B, 0xA3, 0x75, 0xC9 + }, + { + 0xFD, 0x0E, 0x00, 0x10, 0xE2, 0xCE, 0x0F, 0x07, + 0xBB, 0xAC, 0x66, 0x0F, 0x6F, 0x28, 0xDE, 0xAD, + 0x5A, 0xA0, 0xF9, 0x1B, 0x3F, 0x13, 0x31, 0x54, + 0x73, 0x6E, 0xB5, 0xA4, 0x32, 0xB7, 0x8B, 0x59, + 0x59, 0x3E, 0xD6, 0xB8, 0xB5, 0x46, 0x88, 0x9C, + 0x27, 0x16, 0x70, 0x50, 0x06, 0xA2, 0x13, 0x04, + 0x2E, 0x8A, 0xCE, 0x3B, 0x91, 0xCC, 0x67, 0xC3, + 0xFB, 0xC4, 0x04, 0x5B, 0x7A, 0x1D, 0x9E, 0x50 + }, + { + 0xE9, 0xAE, 0xDE, 0x0B, 0xBA, 0x00, 0xEF, 0x9D, + 0x39, 0x7D, 0xAF, 0x8F, 0x9B, 0x50, 0x83, 0x1E, + 0xB6, 0x55, 0x46, 0x02, 0x67, 0x26, 0x0C, 0x9F, + 0xF2, 0x98, 0xB8, 0x14, 0xF2, 0x7C, 0xA8, 0x44, + 0x78, 0xB9, 0x4A, 0xC6, 0x50, 0xFF, 0xE6, 0x33, + 0x18, 0x7A, 0x53, 0x8F, 0x73, 0xB7, 0x68, 0x81, + 0x9A, 0x2C, 0x0B, 0x40, 0xD1, 0xAC, 0x5C, 0xF5, + 0x7B, 0xA3, 0xBF, 0x92, 0xC7, 0xBD, 0x77, 0xBE + }, + { + 0xDB, 0x65, 0x3C, 0x40, 0x4B, 0xE3, 0x4C, 0x50, + 0x06, 0x78, 0xCF, 0xF0, 0x23, 0x53, 0xDE, 0xEE, + 0x18, 0x26, 0x69, 0xBE, 0x08, 0xAD, 0xA6, 0x57, + 0x42, 0xA9, 0xFA, 0xA0, 0xC0, 0x1E, 0xB0, 0xB9, + 0x03, 0x71, 0xAE, 0x66, 0x07, 0xB6, 0x49, 0x95, + 0xCF, 0xAA, 0xB6, 0xCB, 0x62, 0xA1, 0x8F, 0x7D, + 0xF6, 0x92, 0xB9, 0x2E, 0x4E, 0x4D, 0xB1, 0x76, + 0x4F, 0x7C, 0xB9, 0x5E, 0x7C, 0x1C, 0x8D, 0x7E + }, + { + 0x54, 0xA3, 0x59, 0x78, 0x88, 0x0D, 0x57, 0x41, + 0x4B, 0x7C, 0x12, 0x07, 0x7C, 0x14, 0x78, 0xC0, + 0x66, 0xC3, 0x2B, 0x85, 0x81, 0x84, 0xD3, 0xCB, + 0x88, 0x40, 0x35, 0x5B, 0x85, 0xE6, 0xEE, 0x21, + 0x0A, 0x3B, 0x08, 0x19, 0xA2, 0x2C, 0xD5, 0x71, + 0x13, 0xD5, 0x36, 0xA8, 0x4F, 0xE2, 0x94, 0x80, + 0x60, 0xF9, 0x99, 0xFB, 0x80, 0x23, 0x46, 0x11, + 0x17, 0x1F, 0x7F, 0x2C, 0x7B, 0x4B, 0x1B, 0xB7 + }, + { + 0xCC, 0x1E, 0xFB, 0x96, 0x90, 0x7F, 0x79, 0x13, + 0x41, 0x6A, 0xC2, 0x13, 0xF5, 0x1C, 0x41, 0x63, + 0x7A, 0x24, 0xF1, 0x40, 0x56, 0x0F, 0x5A, 0xE5, + 0x4A, 0xEA, 0x1E, 0x30, 0x9E, 0xF3, 0xDA, 0xAB, + 0xA2, 0xD6, 0x4D, 0x44, 0x67, 0x33, 0x63, 0x6F, + 0x3B, 0xBA, 0xB8, 0x3B, 0xB5, 0x8A, 0x8D, 0x56, + 0xA6, 0x59, 0xC3, 0x6B, 0xFC, 0x19, 0x73, 0x1E, + 0x3F, 0xDD, 0x3A, 0x07, 0xA9, 0x0B, 0x4E, 0xB5 + }, + { + 0x7A, 0x58, 0xBB, 0xED, 0x87, 0x5B, 0x6C, 0x15, + 0x70, 0x3A, 0xA9, 0x0C, 0x2E, 0x67, 0xB2, 0x92, + 0x36, 0xAC, 0xAD, 0x9D, 0x10, 0xCE, 0x15, 0xC5, + 0xE5, 0xCE, 0x86, 0x51, 0x5D, 0xD1, 0xE0, 0x4A, + 0xCA, 0x41, 0xAB, 0x92, 0x18, 0xD0, 0x87, 0x15, + 0x25, 0xC0, 0x33, 0x29, 0x93, 0x33, 0xA9, 0xD4, + 0xA6, 0x0C, 0x4C, 0x96, 0xC0, 0x5E, 0x59, 0xB1, + 0x71, 0x67, 0x1E, 0x49, 0x58, 0xC9, 0xB7, 0x8E + }, + { + 0x59, 0xFA, 0x49, 0x46, 0x98, 0x76, 0x9D, 0xFE, + 0xAC, 0x5B, 0xA9, 0xB0, 0x9E, 0x3F, 0x3D, 0x6B, + 0x21, 0x59, 0xE5, 0x63, 0x8A, 0x74, 0x7A, 0x87, + 0x74, 0xCB, 0xBE, 0x9E, 0xE2, 0x94, 0x6E, 0x9A, + 0xD6, 0xFF, 0xA2, 0xEE, 0xDB, 0xFB, 0x48, 0xE9, + 0x79, 0xD6, 0x24, 0xBE, 0x21, 0x64, 0x76, 0x8C, + 0xAF, 0x44, 0xB7, 0x26, 0x5D, 0x5D, 0x2B, 0xB7, + 0xA2, 0x49, 0x09, 0xC9, 0xBE, 0x54, 0xE6, 0x95 + }, + { + 0x2C, 0x0F, 0x82, 0x64, 0x84, 0x66, 0x0D, 0x7F, + 0x40, 0x76, 0x4A, 0xB9, 0xAC, 0xE9, 0x8F, 0xE1, + 0xEC, 0x93, 0x9D, 0xFD, 0x8B, 0xF9, 0x89, 0x29, + 0x09, 0x7E, 0x51, 0x79, 0xF0, 0xFE, 0x91, 0x13, + 0xB8, 0xF9, 0x57, 0x38, 0x3C, 0x15, 0x5B, 0x73, + 0xB0, 0x69, 0x25, 0x1C, 0xB3, 0x20, 0xA3, 0xCC, + 0x71, 0x6C, 0x96, 0xFF, 0x5E, 0xA8, 0x80, 0x2E, + 0xFB, 0x68, 0x3D, 0xAD, 0x56, 0x88, 0x0C, 0x6B + }, + { + 0x29, 0x4C, 0x44, 0x36, 0x6F, 0xC3, 0x7A, 0x1F, + 0xE6, 0xB2, 0xFE, 0xD8, 0x68, 0x0E, 0xF2, 0x38, + 0x1D, 0xC5, 0xB9, 0xFF, 0x4E, 0xDC, 0xAD, 0xD9, + 0x36, 0x94, 0x78, 0x25, 0x16, 0x92, 0x6E, 0xF2, + 0x82, 0xB0, 0x3B, 0xA5, 0x9F, 0x8F, 0xAA, 0x8E, + 0x4C, 0x7C, 0xC8, 0x38, 0xD1, 0xEA, 0xC8, 0x7F, + 0xB3, 0x5E, 0xBB, 0x27, 0x68, 0xBF, 0x4B, 0xF2, + 0x3A, 0x11, 0xF2, 0x59, 0xE6, 0x41, 0x99, 0x31 + }, + { + 0x6E, 0x4D, 0x47, 0xC7, 0xFF, 0x9E, 0xA0, 0x31, + 0x8D, 0xDD, 0x03, 0x02, 0x3E, 0x7D, 0x56, 0xB7, + 0x8E, 0xBF, 0x02, 0xDB, 0x7B, 0x2E, 0x76, 0xE4, + 0xAF, 0x75, 0x39, 0x5D, 0xB6, 0x1E, 0xC0, 0xC7, + 0x02, 0x87, 0xEA, 0xCE, 0x72, 0xED, 0xAC, 0x66, + 0x90, 0xC0, 0x26, 0xBC, 0xCE, 0xC6, 0xB9, 0x17, + 0xB2, 0x5E, 0x64, 0x84, 0x03, 0xA7, 0x9F, 0xD9, + 0xFD, 0xBC, 0xA1, 0x57, 0x3E, 0x07, 0xDB, 0xF8 + }, + { + 0x2D, 0xF4, 0x67, 0xB6, 0x03, 0x9D, 0xB0, 0x32, + 0xEA, 0xAF, 0x93, 0x85, 0x7B, 0x72, 0x83, 0xC7, + 0x63, 0xA3, 0xF1, 0xE0, 0xDD, 0xB7, 0xE8, 0xFE, + 0xD4, 0x48, 0x33, 0xCD, 0xB6, 0x3F, 0xEB, 0xE2, + 0x7A, 0xA8, 0xB4, 0x7D, 0xAD, 0xFA, 0xFB, 0x0D, + 0x37, 0x01, 0x64, 0xEE, 0x9D, 0x7E, 0x01, 0xC3, + 0xA6, 0x09, 0x18, 0x40, 0xAB, 0x1E, 0x50, 0xB4, + 0xCE, 0x6E, 0xED, 0x13, 0x09, 0xE4, 0x3D, 0xBE + }, + { + 0xBD, 0xA1, 0x96, 0xD9, 0xB1, 0x97, 0x4E, 0x10, + 0xF4, 0xD0, 0xD9, 0xF4, 0x97, 0xB8, 0x0F, 0x60, + 0x73, 0xBE, 0xD6, 0x4E, 0x74, 0xF7, 0x83, 0xB3, + 0x84, 0x7D, 0x47, 0x92, 0xFD, 0x69, 0xD5, 0x76, + 0x94, 0x4B, 0x91, 0xCA, 0xA7, 0x4D, 0x72, 0xB9, + 0x26, 0xC1, 0xE3, 0xD6, 0xCE, 0x48, 0x20, 0x24, + 0x3D, 0x89, 0x03, 0x2F, 0x05, 0x68, 0x19, 0x60, + 0xCA, 0x5B, 0x6A, 0xF2, 0x64, 0x03, 0x56, 0x05 + }, + { + 0xE4, 0xB4, 0xAA, 0x12, 0x57, 0xB3, 0x9C, 0x98, + 0x01, 0x4B, 0x98, 0xDF, 0xA6, 0x26, 0x60, 0x6D, + 0x22, 0xFF, 0xD9, 0xBB, 0xC3, 0x14, 0xCB, 0x77, + 0xDC, 0xD9, 0xC9, 0x0D, 0xC3, 0x8D, 0xCD, 0x70, + 0xC3, 0x97, 0x46, 0x31, 0x39, 0xC2, 0x71, 0x5E, + 0xB7, 0xF8, 0x72, 0xB7, 0x08, 0x21, 0x44, 0x46, + 0x11, 0x42, 0x3E, 0xBE, 0xA4, 0xFE, 0x92, 0x26, + 0xFC, 0x85, 0x0B, 0x1A, 0xA7, 0x7F, 0x8A, 0x1D + }, + { + 0x91, 0x8C, 0x2F, 0x07, 0xB5, 0x8C, 0xEB, 0x50, + 0x36, 0x11, 0x54, 0xB8, 0x02, 0x8C, 0x5A, 0x9A, + 0x2A, 0x4F, 0x71, 0xB9, 0x09, 0x1B, 0x75, 0x24, + 0x9E, 0x4B, 0x91, 0x72, 0xDA, 0xB8, 0x6F, 0xE0, + 0x02, 0x91, 0x8E, 0x75, 0xAD, 0x51, 0x87, 0xB2, + 0xA1, 0x6B, 0x0A, 0x84, 0xDF, 0x19, 0x70, 0xCD, + 0x23, 0xFB, 0x95, 0x5B, 0x90, 0xCA, 0xD3, 0x3B, + 0xD5, 0x38, 0xEF, 0xE2, 0x72, 0x6D, 0x38, 0xCF + }, + { + 0x1C, 0xB4, 0x45, 0x61, 0xCC, 0x70, 0x62, 0x05, + 0x5C, 0x8A, 0xCE, 0x80, 0x20, 0x98, 0x6F, 0x86, + 0x54, 0xC1, 0x0B, 0xDF, 0x12, 0x5C, 0x4F, 0x5C, + 0x4D, 0x94, 0xD9, 0xFF, 0x58, 0x40, 0x31, 0x59, + 0xD2, 0x8E, 0xB5, 0xE2, 0xC5, 0x5B, 0x05, 0xD3, + 0x5A, 0xD3, 0x67, 0x87, 0x8A, 0xFF, 0xC5, 0x73, + 0xEB, 0xF3, 0x46, 0xDD, 0x3F, 0x34, 0xDD, 0xCA, + 0x54, 0x58, 0xC9, 0x77, 0xA7, 0xA6, 0xD7, 0x44 + }, + { + 0x4F, 0xFD, 0x90, 0x21, 0xC8, 0x73, 0xBC, 0x06, + 0x1F, 0x1A, 0x1B, 0xA7, 0x31, 0xA3, 0x09, 0x3B, + 0x47, 0x33, 0x6A, 0xB4, 0xCC, 0x41, 0x49, 0x5B, + 0x73, 0xD7, 0xDF, 0xB2, 0x00, 0xC0, 0xA4, 0x40, + 0xE0, 0xDA, 0xAE, 0xA9, 0x93, 0x6D, 0xC5, 0x71, + 0xF0, 0x76, 0x5C, 0x6B, 0xFB, 0x52, 0x21, 0x8F, + 0x84, 0x58, 0xD7, 0x9A, 0x59, 0x61, 0xF6, 0xA2, + 0x63, 0xE0, 0x8D, 0x95, 0x6A, 0x0A, 0xD2, 0x1A + }, + { + 0xCC, 0xF3, 0xE5, 0x3E, 0xB3, 0x95, 0xA0, 0x12, + 0x88, 0xE7, 0x89, 0x7F, 0x74, 0x6D, 0xE5, 0xAA, + 0xFE, 0x06, 0x19, 0x46, 0xE5, 0x45, 0xF4, 0x4C, + 0x51, 0xD9, 0x70, 0x27, 0x47, 0xFE, 0x46, 0xDC, + 0x10, 0x73, 0xFC, 0x5D, 0x7F, 0x85, 0xB0, 0x4C, + 0xF0, 0xF1, 0xD4, 0xE8, 0xF7, 0x41, 0x54, 0xBD, + 0xC6, 0x84, 0xB9, 0x42, 0x66, 0x81, 0xD7, 0x92, + 0x65, 0x4B, 0x69, 0x18, 0xE6, 0x88, 0x1C, 0xA9 + }, + { + 0xA6, 0x7F, 0x45, 0xED, 0x1B, 0xBD, 0x18, 0xAD, + 0xAB, 0xB8, 0x1E, 0xB8, 0xE2, 0x24, 0x20, 0x84, + 0x1A, 0xC0, 0xB5, 0x66, 0xCB, 0x10, 0x66, 0x5D, + 0x02, 0xD9, 0x73, 0x27, 0xD9, 0x1E, 0x03, 0x83, + 0x5B, 0x22, 0x07, 0x0F, 0x96, 0x5D, 0x8C, 0xCB, + 0x55, 0x2B, 0xF0, 0x22, 0x56, 0xD4, 0xAB, 0xD7, + 0x1C, 0xDE, 0x0E, 0xD8, 0x99, 0x73, 0xE0, 0x65, + 0x7D, 0xB8, 0x71, 0xAE, 0x53, 0x2C, 0xCA, 0xB9 + }, + { + 0xF5, 0x36, 0x71, 0x6D, 0xC2, 0xDD, 0xAF, 0xAE, + 0x26, 0xD5, 0x29, 0x03, 0x9C, 0x2B, 0x97, 0xDE, + 0x27, 0xFE, 0xC9, 0xFF, 0x1E, 0x39, 0x7B, 0x62, + 0x17, 0x11, 0x19, 0xEF, 0xB8, 0x96, 0x57, 0x82, + 0x68, 0xC1, 0xAA, 0x8E, 0xC2, 0x63, 0xAA, 0x67, + 0xBC, 0x0C, 0x1A, 0x7E, 0x52, 0x2E, 0x68, 0x8F, + 0x83, 0xCA, 0xD0, 0x86, 0xAB, 0x5E, 0xA9, 0xBC, + 0xBE, 0xD8, 0x59, 0xFA, 0x5A, 0xBD, 0x05, 0xB9 + }, + { + 0x87, 0x28, 0x8F, 0x0A, 0xC9, 0x9D, 0x03, 0xB5, + 0xBE, 0xAE, 0x7B, 0xA4, 0x3E, 0xF9, 0x3D, 0x59, + 0xDC, 0x7A, 0x18, 0x34, 0x93, 0xA6, 0x3F, 0xD1, + 0x50, 0x6E, 0x5C, 0x90, 0x25, 0x82, 0xE5, 0x49, + 0x7B, 0x07, 0xF6, 0xED, 0x0D, 0x86, 0x66, 0xAE, + 0xDD, 0xEA, 0xCB, 0x58, 0xF0, 0xE5, 0xC3, 0x76, + 0x32, 0xB9, 0x37, 0x3E, 0x5C, 0xBB, 0xBF, 0x38, + 0x33, 0x35, 0x4A, 0xCD, 0x74, 0xF3, 0xAE, 0xB9 + }, + { + 0x89, 0x4C, 0x67, 0x27, 0x32, 0x4B, 0x35, 0xCA, + 0x01, 0xC0, 0xEC, 0xEC, 0xBF, 0xAF, 0xBA, 0x8D, + 0x09, 0x08, 0x2F, 0x6E, 0x8F, 0x86, 0x9E, 0x9D, + 0x8C, 0x81, 0xC8, 0xD5, 0x2C, 0xC3, 0xBD, 0x80, + 0xCE, 0xD3, 0x47, 0xBC, 0xA5, 0xEA, 0xDA, 0xC6, + 0x3C, 0xF3, 0x8E, 0xE5, 0x8E, 0xA0, 0xAF, 0xC4, + 0x15, 0xC7, 0xE8, 0x7C, 0xFD, 0xF1, 0x13, 0xD9, + 0xC9, 0x8A, 0x10, 0x87, 0x31, 0x2C, 0xE2, 0x0E + }, + { + 0xF4, 0xE8, 0x1E, 0xEB, 0xBC, 0x27, 0xF4, 0xE2, + 0x99, 0xAD, 0xC0, 0xED, 0xCE, 0x1C, 0xFC, 0x5B, + 0x09, 0x40, 0xEA, 0xB4, 0x82, 0x47, 0xDF, 0xC9, + 0x1E, 0x0F, 0xB4, 0x08, 0x10, 0xC9, 0xF1, 0xE5, + 0xFF, 0x5D, 0x23, 0x64, 0x8D, 0x14, 0x14, 0xC1, + 0xC9, 0x66, 0x5C, 0xCE, 0x95, 0x15, 0x34, 0x0B, + 0x2C, 0x99, 0xE5, 0x31, 0x35, 0x67, 0x6E, 0xF2, + 0x68, 0x5A, 0x5F, 0x2B, 0x03, 0x38, 0xD8, 0x5B + }, + { + 0x58, 0xA6, 0x88, 0x6D, 0xA1, 0xE0, 0x14, 0x2D, + 0xE2, 0xC5, 0x97, 0xE1, 0x50, 0xBB, 0xED, 0xE3, + 0x74, 0x79, 0x09, 0xA7, 0xF9, 0xC3, 0x88, 0xCA, + 0x2D, 0x8F, 0x8E, 0xBD, 0xDB, 0x16, 0xF2, 0x62, + 0xB8, 0xEA, 0x24, 0x2D, 0xD4, 0x43, 0x69, 0xD2, + 0xBA, 0x11, 0x74, 0x08, 0x0B, 0xB9, 0x52, 0xB4, + 0x2E, 0xE8, 0xC1, 0x3A, 0x37, 0xA3, 0x21, 0x50, + 0x7B, 0x88, 0x74, 0xDE, 0x7B, 0xB1, 0x40, 0x30 + }, + { + 0x90, 0x43, 0x8C, 0x48, 0xB9, 0xED, 0x9D, 0x07, + 0xDE, 0x75, 0x6B, 0x1C, 0x07, 0x2A, 0x82, 0x49, + 0xBB, 0xA9, 0x96, 0x33, 0xEB, 0x78, 0x88, 0x21, + 0xA2, 0xD8, 0x15, 0x88, 0x5E, 0xB7, 0xA0, 0xC3, + 0xA9, 0x1E, 0xBF, 0x87, 0x4E, 0x54, 0x09, 0xF9, + 0x07, 0xAE, 0x04, 0xC5, 0x1F, 0x70, 0xA5, 0xE5, + 0xE7, 0xB5, 0x70, 0x70, 0x52, 0x6E, 0xBA, 0x24, + 0x6B, 0xC0, 0xB2, 0x03, 0x45, 0xD6, 0x80, 0x90 + }, + { + 0x6E, 0xBD, 0xAC, 0x8A, 0x5B, 0xDB, 0xA7, 0xB9, + 0x6A, 0x6F, 0x0B, 0xAD, 0x0E, 0x90, 0xE4, 0xF7, + 0xEF, 0x29, 0x75, 0x9B, 0xE7, 0xB9, 0x07, 0x7B, + 0x49, 0xF1, 0x33, 0xD1, 0x2B, 0xAF, 0x2A, 0x38, + 0x6D, 0xF1, 0x3F, 0x50, 0x2F, 0x0E, 0x7A, 0x06, + 0xA3, 0xC2, 0xC2, 0xB5, 0x07, 0xB0, 0xE3, 0xD2, + 0x29, 0xE8, 0x9D, 0x3F, 0xD0, 0x1B, 0x3F, 0x4E, + 0x34, 0x7F, 0xD8, 0x92, 0x2E, 0xC0, 0xFD, 0x40 + }, + { + 0x95, 0x08, 0x21, 0xE0, 0x08, 0xDF, 0x4B, 0xE8, + 0xAA, 0xBB, 0x43, 0x0B, 0x50, 0xCB, 0x8D, 0x92, + 0xD4, 0x08, 0x18, 0xCE, 0x14, 0xC7, 0x9A, 0x92, + 0x95, 0x03, 0x14, 0xCC, 0x3D, 0x32, 0x11, 0xEE, + 0x90, 0x7D, 0x27, 0x22, 0x2E, 0xCC, 0xED, 0x4E, + 0xE9, 0xC3, 0xBE, 0xAC, 0x63, 0x09, 0xD5, 0x71, + 0x8D, 0x23, 0x4C, 0x1D, 0xCE, 0x15, 0x05, 0x35, + 0x37, 0xE4, 0x9F, 0x0E, 0x08, 0xE6, 0xC2, 0x54 + }, + { + 0x73, 0xD6, 0x77, 0xC9, 0x7B, 0xB8, 0xAA, 0x45, + 0x5C, 0x2C, 0x7D, 0xB5, 0x2E, 0x67, 0xAE, 0xF2, + 0x89, 0x24, 0x2F, 0x70, 0xFE, 0x75, 0x7E, 0xF4, + 0x04, 0xC9, 0x97, 0xB8, 0x84, 0x4F, 0xA0, 0x1C, + 0xBE, 0x49, 0x94, 0x2B, 0x54, 0xD7, 0x81, 0xCE, + 0x98, 0xE1, 0xD4, 0x43, 0xA4, 0x8B, 0x20, 0x81, + 0x62, 0x45, 0x55, 0xF7, 0xA0, 0xF5, 0xAB, 0x77, + 0x99, 0x45, 0xFF, 0x0E, 0x3D, 0x91, 0xCB, 0x46 + }, + { + 0x7B, 0x5B, 0xBB, 0x62, 0x4E, 0x07, 0xDB, 0x10, + 0x56, 0xDE, 0x83, 0x83, 0xF1, 0xB5, 0xAF, 0xF3, + 0x94, 0x46, 0xDB, 0x77, 0xC3, 0xD6, 0x5E, 0x9C, + 0x59, 0xC2, 0xE4, 0xB9, 0x82, 0xD8, 0x65, 0xBA, + 0xCE, 0x22, 0x0E, 0x53, 0xA6, 0x8C, 0x69, 0x12, + 0xE5, 0xA4, 0xCE, 0xA2, 0x6F, 0xA1, 0xEA, 0x02, + 0xB2, 0x4B, 0x2A, 0x1A, 0xE3, 0x96, 0x56, 0xA7, + 0xC0, 0xB0, 0x0F, 0xB9, 0x50, 0x02, 0x55, 0x4A + }, + { + 0x1F, 0x29, 0x8C, 0xAB, 0x1B, 0xEC, 0x6E, 0x9F, + 0x67, 0x12, 0xF8, 0xB3, 0xF4, 0xFB, 0x6B, 0x23, + 0xCB, 0xF0, 0x5C, 0x18, 0xD3, 0x8E, 0x11, 0x11, + 0x3D, 0x3E, 0x1A, 0xCE, 0xDA, 0x3A, 0x4D, 0xCA, + 0xDC, 0xC1, 0xC0, 0xE2, 0xA2, 0x47, 0xEB, 0x99, + 0x3D, 0xC0, 0xBC, 0xC9, 0xD9, 0xDA, 0x59, 0x79, + 0xF2, 0x87, 0x1B, 0x28, 0x59, 0x9D, 0x4F, 0x86, + 0x9C, 0xB9, 0x92, 0xDF, 0x23, 0x63, 0xA0, 0x36 + }, + { + 0xCC, 0x69, 0xCD, 0xB9, 0x4A, 0x7E, 0x03, 0xB6, + 0x18, 0x5B, 0xEC, 0xDA, 0xC6, 0x0A, 0x62, 0x42, + 0xBE, 0xD2, 0xED, 0x14, 0x80, 0xEE, 0x7C, 0xA9, + 0x8E, 0xFD, 0xE8, 0xD6, 0x9B, 0x11, 0xAC, 0x54, + 0x34, 0xA1, 0xC3, 0x44, 0xAA, 0x42, 0x21, 0xE3, + 0x12, 0x14, 0x10, 0x17, 0x40, 0x63, 0x05, 0xA3, + 0x1F, 0xB1, 0x68, 0x7F, 0x77, 0x56, 0x9D, 0x2E, + 0x89, 0x57, 0x1D, 0x66, 0x32, 0xD8, 0xC2, 0x03 + }, + { + 0xA5, 0x18, 0xFC, 0x7E, 0x23, 0x54, 0x2A, 0x84, + 0xE9, 0x27, 0x68, 0x6F, 0xB3, 0x0E, 0x19, 0x86, + 0x19, 0x0A, 0x1A, 0x77, 0x0B, 0x42, 0xED, 0x28, + 0xD7, 0x60, 0x16, 0xE5, 0xB2, 0xAC, 0x1B, 0x9B, + 0xBD, 0xB2, 0xF2, 0xC0, 0xB2, 0x12, 0x62, 0xE9, + 0x7B, 0x5F, 0x1A, 0xA9, 0x4C, 0x04, 0xB0, 0xD5, + 0x09, 0xEA, 0x6A, 0x53, 0x9A, 0x47, 0x5E, 0x17, + 0x43, 0x7A, 0x89, 0x53, 0xCB, 0xC9, 0x2E, 0x2E + }, + { + 0x83, 0xB2, 0x1A, 0x58, 0xE5, 0xD6, 0x49, 0xAF, + 0x48, 0x81, 0x8C, 0x0E, 0x0D, 0xBC, 0x9C, 0xBC, + 0x4E, 0x0B, 0xFB, 0x85, 0xEF, 0x2F, 0x30, 0x3D, + 0x65, 0x5C, 0xBB, 0x8B, 0x84, 0xB5, 0x9F, 0x6B, + 0xFB, 0xEB, 0x41, 0xF9, 0xF4, 0x96, 0xDE, 0xCC, + 0x98, 0xBA, 0xDB, 0x08, 0xAB, 0xB7, 0xA1, 0x05, + 0x5F, 0x36, 0x9D, 0x12, 0x72, 0xF0, 0xDE, 0x9A, + 0x18, 0xF0, 0x2E, 0x15, 0x16, 0x5E, 0xAF, 0xD6 + }, + { + 0xF4, 0xCD, 0xC2, 0x3D, 0x32, 0xC2, 0x80, 0xA9, + 0x13, 0xBD, 0xA4, 0x11, 0xAC, 0x4F, 0xD9, 0xF9, + 0x47, 0x90, 0xFF, 0x4B, 0xBE, 0xDA, 0x1D, 0xCC, + 0xF1, 0x6C, 0x05, 0xF0, 0x30, 0x33, 0x5C, 0x3D, + 0x77, 0x25, 0xD5, 0x7B, 0x24, 0x9B, 0xAA, 0x1C, + 0xE3, 0xA3, 0xA8, 0x8B, 0x4D, 0xD1, 0xCE, 0xA8, + 0x93, 0x37, 0x54, 0x94, 0x2E, 0x3C, 0xD9, 0x21, + 0x76, 0x41, 0xEF, 0xD0, 0x35, 0x8F, 0xD1, 0x5D + }, + { + 0xDF, 0xA8, 0x2C, 0xB8, 0xCE, 0x95, 0xE9, 0x17, + 0xCB, 0x9E, 0x86, 0xE4, 0x7F, 0x03, 0x12, 0x6E, + 0x26, 0x4D, 0x8B, 0x1B, 0x66, 0xED, 0x39, 0x7D, + 0x89, 0xEE, 0xC9, 0xCB, 0x51, 0x62, 0xE1, 0x1D, + 0x75, 0x4B, 0xDB, 0x8C, 0xC1, 0xE3, 0xD1, 0xF3, + 0x41, 0x62, 0xAF, 0x34, 0xF8, 0x7B, 0x53, 0x5B, + 0xE1, 0x49, 0xCA, 0x2E, 0xD3, 0x8A, 0x57, 0x49, + 0x82, 0xBC, 0x25, 0x0B, 0x9C, 0x79, 0x39, 0xEE + }, + { + 0x69, 0xD4, 0xE7, 0x03, 0x63, 0xDC, 0x5C, 0xA6, + 0x75, 0x40, 0xBA, 0x98, 0x43, 0x37, 0x9D, 0xF6, + 0x33, 0x00, 0x96, 0x17, 0x68, 0xC8, 0x03, 0x85, + 0x97, 0x7C, 0x1D, 0x54, 0x51, 0xBE, 0x44, 0x07, + 0x07, 0x64, 0xF1, 0xA3, 0x78, 0xBB, 0xE0, 0x41, + 0x83, 0x21, 0x91, 0x56, 0x4C, 0xE9, 0xB8, 0x38, + 0xF5, 0x56, 0xA8, 0xF1, 0x6B, 0x93, 0x0F, 0x1B, + 0x82, 0x48, 0x6A, 0x4D, 0xD6, 0xA7, 0x98, 0x48 + }, + { + 0x78, 0x35, 0xE4, 0x23, 0x9F, 0x74, 0xD9, 0x9F, + 0x3D, 0x63, 0xEA, 0x5F, 0x9B, 0x55, 0xC9, 0x4F, + 0xD9, 0x53, 0x98, 0x53, 0xD3, 0x1A, 0x25, 0x8C, + 0xE6, 0x01, 0x6D, 0x11, 0xCE, 0x20, 0xEB, 0x07, + 0xCE, 0xB9, 0x2D, 0x0E, 0xF0, 0x22, 0x0D, 0x1F, + 0xE4, 0x56, 0x66, 0x30, 0x8F, 0xE4, 0xA0, 0x43, + 0x49, 0xF8, 0xBF, 0xB6, 0xA9, 0x54, 0xDF, 0x93, + 0x4A, 0x1C, 0x3E, 0x9D, 0x46, 0xAD, 0x6C, 0xDC + }, + { + 0x01, 0x59, 0x69, 0xBE, 0xA8, 0x83, 0x24, 0x39, + 0xCB, 0xE3, 0x27, 0x2C, 0xF7, 0x39, 0xEF, 0x8F, + 0x77, 0x76, 0x5A, 0xE5, 0xC7, 0xF0, 0x99, 0x15, + 0x3D, 0x14, 0x15, 0xBF, 0xF2, 0x6E, 0x67, 0x46, + 0xB2, 0xBC, 0xEF, 0x04, 0x41, 0xFA, 0x88, 0x5A, + 0xB2, 0xB0, 0x19, 0xF1, 0xCD, 0xED, 0xCC, 0x28, + 0x6A, 0x73, 0x31, 0x8D, 0x43, 0x8E, 0xA2, 0xA3, + 0x11, 0x28, 0x68, 0x38, 0xCF, 0x79, 0x5E, 0x8F + }, + { + 0x15, 0x94, 0x26, 0x62, 0x8E, 0x47, 0xF9, 0xD9, + 0x33, 0xB0, 0x28, 0xCD, 0x1C, 0x69, 0xC7, 0xED, + 0xFE, 0x82, 0xDC, 0x7A, 0xA4, 0xCE, 0x8A, 0x82, + 0x0D, 0x72, 0x04, 0xF9, 0x14, 0xEB, 0x04, 0x02, + 0x5B, 0x7D, 0x2A, 0x6F, 0x36, 0x25, 0x61, 0x87, + 0xBD, 0xB9, 0x90, 0x30, 0x1E, 0xB6, 0x63, 0x82, + 0xB8, 0xA6, 0x9A, 0xDD, 0x0E, 0x4A, 0x13, 0xE6, + 0xBE, 0x5B, 0x77, 0xB6, 0x35, 0x17, 0xBC, 0x72 + }, + { + 0x0A, 0x37, 0x27, 0xC3, 0x13, 0x71, 0x83, 0xF3, + 0xD5, 0x46, 0xB8, 0x11, 0x32, 0x12, 0xB3, 0xE5, + 0xD4, 0x01, 0x13, 0x30, 0xCD, 0x3F, 0x70, 0x1F, + 0x71, 0xBA, 0x92, 0x22, 0xC4, 0x48, 0xE1, 0x26, + 0xD3, 0x3C, 0x2F, 0xF4, 0xE8, 0xF4, 0x9F, 0x53, + 0x63, 0x71, 0x85, 0x31, 0x77, 0x5C, 0xFD, 0x0E, + 0x8D, 0xA9, 0xD8, 0x1B, 0x24, 0x39, 0x80, 0xB9, + 0x85, 0xE0, 0x88, 0xCD, 0xF6, 0x6F, 0xFD, 0xA2 + }, + { + 0xC5, 0x9F, 0x08, 0x23, 0x81, 0x00, 0x68, 0xFB, + 0xCD, 0x7A, 0xC6, 0xA5, 0xCC, 0x52, 0xB8, 0x88, + 0x97, 0x1B, 0x54, 0x47, 0x32, 0x60, 0xA3, 0x0D, + 0xF8, 0xA2, 0x03, 0xB0, 0x50, 0xB7, 0xAF, 0x1D, + 0xCB, 0xE7, 0xB0, 0xB7, 0xD7, 0xE1, 0xAD, 0xAC, + 0x67, 0x3E, 0x12, 0xDC, 0x5E, 0x79, 0x06, 0xC2, + 0xE2, 0x63, 0xA6, 0x39, 0x3E, 0x0A, 0xFA, 0x92, + 0xB2, 0x55, 0x03, 0xF0, 0x79, 0x07, 0x9E, 0x7C + }, + { + 0xAA, 0x8C, 0xDD, 0x96, 0xE3, 0x5C, 0xB5, 0xFB, + 0x04, 0x17, 0x98, 0xB1, 0x1C, 0xC7, 0xC9, 0xE3, + 0x93, 0xD9, 0x0C, 0xB7, 0x3A, 0x2E, 0xF3, 0x3E, + 0x1B, 0x26, 0x2A, 0x2F, 0x78, 0x09, 0xB5, 0x4F, + 0x31, 0xEF, 0x1B, 0xDB, 0xBC, 0xE9, 0x44, 0x34, + 0x46, 0xD7, 0x21, 0x36, 0xBA, 0x39, 0x6E, 0xEA, + 0x5D, 0x11, 0x20, 0x2A, 0xAE, 0x42, 0x26, 0xFA, + 0x73, 0x61, 0x11, 0xFD, 0x75, 0x09, 0x05, 0x12 + }, + { + 0xD0, 0x01, 0x06, 0x9E, 0x80, 0x9E, 0x5F, 0x83, + 0x7C, 0x4F, 0x01, 0x5A, 0x35, 0xCC, 0x99, 0x23, + 0xB8, 0x85, 0x89, 0x11, 0x38, 0xD5, 0x9E, 0x23, + 0xA8, 0x83, 0x84, 0x0E, 0x79, 0xA1, 0x02, 0xFA, + 0x34, 0x6E, 0xBD, 0xE1, 0xD4, 0x89, 0xD9, 0x97, + 0xC4, 0x4F, 0xB2, 0x95, 0xAE, 0xE2, 0xC9, 0x26, + 0x96, 0xEA, 0xCA, 0xF1, 0xC5, 0xD0, 0x6A, 0xAB, + 0xDA, 0x80, 0x41, 0x88, 0xA7, 0xD2, 0xC9, 0xBF + }, + { + 0x02, 0xD2, 0x91, 0x96, 0x19, 0xA3, 0x07, 0xD8, + 0xBA, 0x52, 0x87, 0xFD, 0xA6, 0x6C, 0x19, 0x8D, + 0x9E, 0x84, 0xE4, 0x22, 0x9B, 0x43, 0x26, 0x04, + 0x10, 0xEF, 0x45, 0x86, 0x94, 0xEE, 0xB4, 0xB7, + 0x4F, 0xD5, 0xE0, 0xF1, 0xFE, 0xBE, 0x7D, 0x64, + 0xC8, 0xC5, 0xB7, 0xC2, 0x09, 0xA3, 0x03, 0xBD, + 0xAD, 0x0B, 0xFE, 0x46, 0xFC, 0xC8, 0xD3, 0xCC, + 0x0B, 0xC8, 0x57, 0x75, 0x45, 0xE8, 0xDD, 0xBF + }, + { + 0x07, 0xA8, 0x8D, 0xE6, 0xD8, 0xA0, 0x11, 0xBA, + 0x13, 0xE5, 0x71, 0x1B, 0x85, 0xF0, 0xEF, 0xB9, + 0x98, 0xF6, 0x71, 0x43, 0x37, 0x62, 0x65, 0xC0, + 0xDA, 0x05, 0x7D, 0x3B, 0x80, 0x15, 0x6B, 0x80, + 0x99, 0x16, 0xF2, 0xA7, 0x43, 0x8C, 0x35, 0x34, + 0x29, 0xDF, 0xA8, 0x6B, 0x71, 0xE7, 0x16, 0x35, + 0xE8, 0x6A, 0xDD, 0x66, 0x48, 0x4F, 0x7E, 0x5E, + 0xD4, 0xA0, 0x35, 0x85, 0x80, 0xAF, 0xEE, 0x66 + }, + { + 0x47, 0x52, 0x95, 0xB0, 0x1F, 0x08, 0xAA, 0xD2, + 0xC1, 0xFB, 0xB9, 0x25, 0x74, 0x9F, 0x84, 0xAA, + 0x73, 0x54, 0x85, 0xE9, 0xC3, 0xDC, 0xF5, 0xE1, + 0xFD, 0x79, 0x12, 0x50, 0x22, 0x3B, 0x09, 0x2C, + 0x2C, 0x12, 0xA2, 0xF2, 0x0B, 0x84, 0xF8, 0xC1, + 0xF8, 0x6D, 0x8B, 0x89, 0x35, 0x2C, 0x8C, 0xBC, + 0xE4, 0x1B, 0xD7, 0xEB, 0x14, 0xA7, 0x5C, 0x5D, + 0x06, 0x7B, 0x28, 0x49, 0xC1, 0x58, 0xC0, 0x57 + }, + { + 0xFA, 0x92, 0xC5, 0x6A, 0x62, 0xD8, 0x9E, 0xA8, + 0x00, 0xE8, 0x9C, 0xC4, 0xE8, 0x9E, 0x73, 0x52, + 0xCD, 0x97, 0x54, 0x9E, 0xC7, 0xA1, 0x72, 0xAA, + 0xB1, 0x43, 0x59, 0x8F, 0xF4, 0xC8, 0x8D, 0x13, + 0xC1, 0x87, 0xB1, 0x7A, 0x48, 0xD6, 0xD9, 0xB5, + 0xD8, 0x44, 0x83, 0x71, 0x1A, 0x9F, 0x88, 0xBF, + 0x6A, 0x61, 0xAB, 0x70, 0x33, 0xAD, 0x59, 0xE0, + 0x05, 0x3D, 0x79, 0xD9, 0xE5, 0xB2, 0x6E, 0x67 + }, + { + 0xF6, 0xCA, 0xFB, 0x2E, 0xCB, 0x5A, 0x77, 0x50, + 0xDA, 0xA5, 0xD9, 0x89, 0x2B, 0xAF, 0x26, 0xBE, + 0xA4, 0x3F, 0xA2, 0x44, 0xEE, 0x22, 0x9A, 0x64, + 0x93, 0xDC, 0xE7, 0x19, 0xF0, 0x75, 0x97, 0xD2, + 0x3A, 0x86, 0x55, 0x98, 0x6A, 0xA5, 0xF5, 0xF4, + 0xC9, 0x10, 0xDA, 0x0A, 0xFF, 0xAE, 0x5C, 0x8B, + 0x03, 0xBD, 0x14, 0x5A, 0x7A, 0x59, 0xF1, 0x69, + 0x0C, 0x69, 0x2F, 0xB4, 0x09, 0x6F, 0x66, 0x7D + }, + { + 0x7B, 0x39, 0xB6, 0x1B, 0x8A, 0xB3, 0x8F, 0x21, + 0x34, 0xBB, 0x75, 0x57, 0xD3, 0x62, 0x08, 0x3A, + 0x61, 0xEA, 0x26, 0x82, 0xE2, 0xD1, 0xE1, 0x4D, + 0x4F, 0x87, 0xCB, 0xD9, 0x21, 0x32, 0x04, 0x32, + 0xEB, 0xF4, 0xD3, 0xD2, 0x02, 0x9E, 0x7C, 0x29, + 0x83, 0x14, 0x8E, 0x5C, 0x01, 0xEB, 0x49, 0x76, + 0x91, 0x02, 0x6F, 0xB2, 0xCD, 0x3E, 0x25, 0xE8, + 0xE2, 0x68, 0x4C, 0x03, 0xDD, 0xCC, 0xB6, 0xF4 + }, + { + 0x12, 0xC0, 0xCE, 0x1A, 0x4A, 0xF6, 0xC1, 0xA7, + 0x6C, 0xF5, 0xD1, 0x94, 0xC4, 0x6C, 0xB9, 0xC3, + 0xFC, 0x77, 0x65, 0xF8, 0xA8, 0x05, 0x47, 0x13, + 0x7A, 0x2B, 0x6E, 0x3A, 0xF3, 0x5B, 0xF0, 0x79, + 0x68, 0x41, 0xFB, 0x17, 0x08, 0x43, 0xDB, 0x2E, + 0x55, 0x2D, 0x56, 0x51, 0x7B, 0xEB, 0xAC, 0xCD, + 0xC6, 0xED, 0x73, 0xA9, 0xA6, 0xE6, 0x6E, 0x46, + 0xCB, 0x8B, 0xDF, 0x8F, 0xF1, 0x76, 0x2E, 0x42 + }, + { + 0x73, 0x03, 0xD8, 0xF9, 0x3C, 0x4F, 0x50, 0x79, + 0x6F, 0x8A, 0x40, 0xAB, 0x66, 0xA0, 0x90, 0x20, + 0x1B, 0xA9, 0x0F, 0x66, 0x0D, 0x80, 0xC5, 0x11, + 0x04, 0x0E, 0x71, 0xD7, 0x11, 0xE9, 0xFD, 0x39, + 0xB9, 0xB2, 0x87, 0xA9, 0x7F, 0xEC, 0x46, 0xE8, + 0x2B, 0x37, 0x5B, 0x7C, 0x3B, 0x0D, 0x1A, 0x4E, + 0xED, 0xF3, 0x8E, 0x02, 0xD3, 0x13, 0xBD, 0xE5, + 0x1C, 0xB6, 0x74, 0xCA, 0xFA, 0x2E, 0x2E, 0xC0 + }, + { + 0x92, 0x82, 0x86, 0x23, 0x20, 0x30, 0x17, 0xC7, + 0xC7, 0x77, 0xF4, 0xB4, 0xD3, 0xA3, 0xCD, 0x1D, + 0x08, 0xE0, 0x62, 0x5D, 0x5A, 0x08, 0x35, 0x9A, + 0xCA, 0x88, 0xA5, 0xA1, 0x98, 0x37, 0x66, 0x41, + 0x7C, 0xBB, 0x4C, 0x0B, 0xFD, 0x74, 0x45, 0x39, + 0xAC, 0x28, 0xEA, 0x0E, 0x22, 0x57, 0x6F, 0x1C, + 0x2D, 0xC4, 0x04, 0x0A, 0xC9, 0xC0, 0xF0, 0xA8, + 0x79, 0x02, 0x51, 0x8E, 0x9F, 0xF1, 0x0A, 0xD6 + }, + { + 0x12, 0x68, 0x2B, 0xAC, 0xB3, 0xDA, 0x20, 0x20, + 0x1A, 0xCC, 0xD4, 0xA0, 0x74, 0x76, 0x69, 0x3A, + 0xAC, 0x47, 0xF4, 0xE3, 0x8A, 0x96, 0x40, 0x8D, + 0xD3, 0xE1, 0x3A, 0x88, 0x24, 0x07, 0x7E, 0xA7, + 0xE0, 0xDD, 0xBA, 0x9D, 0xF4, 0x91, 0x42, 0x4F, + 0x6A, 0xBE, 0x43, 0xD4, 0xA3, 0x5C, 0x43, 0x9A, + 0x16, 0x60, 0xEF, 0x1D, 0x8B, 0x21, 0x02, 0x07, + 0x59, 0x13, 0xF2, 0x9D, 0x00, 0x75, 0xF2, 0xB3 + }, + { + 0xA1, 0x0F, 0xC8, 0xE0, 0x51, 0x15, 0xAB, 0xB1, + 0xC7, 0x47, 0x05, 0xEB, 0x83, 0x6B, 0xC7, 0x0A, + 0x1E, 0x77, 0x36, 0x20, 0x84, 0x6D, 0xEC, 0x9C, + 0xE9, 0x5B, 0xDF, 0x77, 0x03, 0x75, 0xDE, 0x94, + 0xE4, 0xE2, 0x78, 0x15, 0xC0, 0x55, 0x99, 0x05, + 0xD3, 0x66, 0x9E, 0xD2, 0xF0, 0xB2, 0x13, 0x5C, + 0x1D, 0x93, 0x6B, 0xDE, 0xBE, 0x9E, 0x6B, 0x2F, + 0x34, 0x2C, 0x63, 0x74, 0xAC, 0x0B, 0x51, 0x3C + }, + { + 0x30, 0x6D, 0xB9, 0xB2, 0xD5, 0x27, 0xBE, 0x52, + 0xAE, 0x23, 0x58, 0x1D, 0xF6, 0xB4, 0x0D, 0x91, + 0x84, 0x26, 0x95, 0x9B, 0x8B, 0xBB, 0xAF, 0xDA, + 0x29, 0xC1, 0x69, 0x2B, 0x32, 0x54, 0x21, 0xEE, + 0xE5, 0x85, 0x94, 0xB2, 0x0A, 0xD5, 0xAA, 0x9E, + 0xC6, 0x0A, 0x95, 0xE0, 0x3C, 0xC8, 0xA1, 0x47, + 0xDF, 0x9F, 0x52, 0x7D, 0x4F, 0x5A, 0x5A, 0xB2, + 0xF4, 0xA6, 0x69, 0x8D, 0xAA, 0xAA, 0x04, 0xDB + }, + { + 0xC8, 0xD8, 0x61, 0x4C, 0x3F, 0xA7, 0x1F, 0xDD, + 0x5A, 0x23, 0xA0, 0x24, 0xCA, 0x39, 0x86, 0x42, + 0x00, 0x2E, 0xA5, 0x97, 0x48, 0x7A, 0x1D, 0x54, + 0xFD, 0x3B, 0x59, 0x84, 0x28, 0x6D, 0x56, 0x4D, + 0x38, 0xC5, 0x72, 0x8A, 0x51, 0xDF, 0x22, 0xD3, + 0x27, 0x79, 0x5B, 0x84, 0x3A, 0x1E, 0xF2, 0x38, + 0xCD, 0x36, 0x26, 0xB1, 0xDD, 0xB1, 0x35, 0xA0, + 0x38, 0xE8, 0x6E, 0x51, 0x1F, 0x8D, 0x19, 0xA7 + }, + { + 0xB8, 0xA6, 0xA5, 0x36, 0xCA, 0x59, 0x01, 0x63, + 0x74, 0x5C, 0x14, 0x12, 0x21, 0xA8, 0x1C, 0x79, + 0x3C, 0xF2, 0x36, 0x68, 0xC4, 0xA6, 0xD1, 0x76, + 0x34, 0xDC, 0xE0, 0x7B, 0xE6, 0xD7, 0x48, 0xDD, + 0x0A, 0x13, 0x53, 0x66, 0xA6, 0x4A, 0x58, 0x48, + 0x90, 0xE1, 0x37, 0x19, 0x70, 0xCD, 0x84, 0x5E, + 0xAD, 0x99, 0x6C, 0x70, 0xB2, 0x4C, 0xD3, 0xD8, + 0x91, 0x30, 0xE7, 0x28, 0x4A, 0xF5, 0x5E, 0x74 + }, + { + 0xBB, 0x9D, 0xCB, 0xA8, 0x4A, 0x72, 0x12, 0x8C, + 0x34, 0x41, 0x74, 0x0F, 0x71, 0x95, 0x50, 0x8A, + 0x84, 0x95, 0x29, 0x16, 0x4D, 0x69, 0xB5, 0x84, + 0x8D, 0x39, 0x9D, 0x06, 0x92, 0xA3, 0x0A, 0x29, + 0x1D, 0x7E, 0x1C, 0xBA, 0x57, 0x0F, 0x1D, 0x38, + 0xA9, 0x68, 0x6F, 0x46, 0x31, 0xD2, 0x22, 0x27, + 0xD0, 0xBA, 0x3F, 0x28, 0xF2, 0x9A, 0x7D, 0x1D, + 0xB5, 0x70, 0x4C, 0xF7, 0xF8, 0x0B, 0x4A, 0xD6 + }, + { + 0xC4, 0x4C, 0x3E, 0x0C, 0x2B, 0xF5, 0x33, 0x52, + 0xFA, 0x95, 0x3A, 0xBE, 0x64, 0x65, 0x2D, 0xA4, + 0x51, 0x16, 0x1A, 0xBA, 0xA8, 0xF1, 0x8F, 0x30, + 0x28, 0x73, 0x78, 0x03, 0x5B, 0x91, 0x5B, 0x2C, + 0xCD, 0x7C, 0x97, 0x21, 0xEC, 0x67, 0x5C, 0x4D, + 0xD8, 0x2D, 0x59, 0xE5, 0x80, 0x42, 0xA9, 0x00, + 0x29, 0xB4, 0xEC, 0x76, 0x6B, 0x75, 0x56, 0x7A, + 0x67, 0x8F, 0x35, 0xE3, 0x6D, 0xA8, 0x3B, 0xE3 + }, + { + 0x00, 0xE7, 0x99, 0xD5, 0xAC, 0x99, 0xB6, 0xFC, + 0x5D, 0xF0, 0xD0, 0xA2, 0x95, 0xD6, 0x8F, 0x76, + 0x70, 0x26, 0x0A, 0xB3, 0xB1, 0xB8, 0x0F, 0xED, + 0xEF, 0xBE, 0xE1, 0x84, 0x65, 0x10, 0x09, 0x01, + 0x48, 0xFF, 0x80, 0xCA, 0xF0, 0x1C, 0x97, 0x42, + 0xC7, 0x99, 0xEC, 0x6F, 0xD7, 0x13, 0x08, 0x22, + 0x76, 0xFE, 0xF3, 0x2A, 0x2E, 0xE8, 0xD0, 0xE4, + 0x29, 0x01, 0x32, 0x2F, 0x20, 0x32, 0xCE, 0xB8 + }, + { + 0xAA, 0xF4, 0x53, 0xB5, 0x7C, 0x3C, 0x6A, 0x1C, + 0x7B, 0x6B, 0x41, 0x1A, 0xC5, 0xE1, 0x1A, 0xA7, + 0x89, 0x92, 0x79, 0xA7, 0x2A, 0xE2, 0x52, 0x5C, + 0x44, 0xBA, 0x73, 0x8F, 0x86, 0xBA, 0x3B, 0xB7, + 0x2F, 0xB9, 0x99, 0xF7, 0x0D, 0x0A, 0x39, 0x18, + 0xB8, 0xC3, 0x71, 0xCD, 0x75, 0xE1, 0xDA, 0xA4, + 0x73, 0x97, 0x90, 0x15, 0xAE, 0xBC, 0xDE, 0xCE, + 0x02, 0xD0, 0xA1, 0xA7, 0x6E, 0x9D, 0x4A, 0x47 + }, + { + 0xA6, 0x09, 0xF9, 0x36, 0x91, 0x91, 0xE3, 0x9B, + 0x12, 0x96, 0x6A, 0x2A, 0x30, 0x8B, 0xDE, 0x3F, + 0x09, 0xF9, 0x76, 0x37, 0xAF, 0x74, 0x4D, 0x6E, + 0x4E, 0x14, 0xD3, 0x1B, 0x89, 0x48, 0x14, 0xAE, + 0x3A, 0x99, 0xB1, 0xD2, 0x9A, 0x3E, 0x2D, 0x47, + 0xFF, 0x60, 0xEE, 0x52, 0x3C, 0xB4, 0x6B, 0x39, + 0x3A, 0x2F, 0xB8, 0x93, 0x75, 0x76, 0xDA, 0x69, + 0x15, 0x39, 0xE6, 0x85, 0x6A, 0x06, 0x6E, 0x90 + }, + { + 0xF3, 0x84, 0x4B, 0x22, 0x2D, 0x0A, 0x1D, 0x47, + 0x62, 0x74, 0xB5, 0xFF, 0xF3, 0x90, 0x26, 0xFF, + 0xF9, 0xFD, 0x61, 0xCC, 0x5B, 0x4D, 0x79, 0xEC, + 0xE6, 0x3B, 0x20, 0x01, 0xFF, 0xA6, 0x9D, 0x70, + 0xEC, 0x61, 0x0F, 0xEA, 0x62, 0x05, 0xEE, 0x7E, + 0xA5, 0xDB, 0x2C, 0x34, 0xB2, 0xB3, 0xBD, 0xCE, + 0xB7, 0x9F, 0x3A, 0xA4, 0xC7, 0x35, 0x39, 0x0E, + 0xCC, 0xD9, 0x05, 0x47, 0x99, 0x0B, 0x38, 0x29 + }, + { + 0x8E, 0xF3, 0x99, 0x37, 0xBB, 0x32, 0xF1, 0x6A, + 0x55, 0x10, 0x3C, 0x37, 0x27, 0x6A, 0x29, 0x36, + 0x8F, 0x79, 0x00, 0x87, 0x65, 0x10, 0x91, 0xF5, + 0xA4, 0x60, 0x39, 0xC2, 0xAD, 0xAE, 0x8D, 0x09, + 0x0A, 0x1F, 0xEA, 0x5C, 0x07, 0x5F, 0xF1, 0x9E, + 0x9A, 0x01, 0x28, 0xD2, 0x35, 0xB0, 0xA8, 0x85, + 0xCA, 0x4B, 0x5A, 0x08, 0xB1, 0x2C, 0x94, 0x4A, + 0x9A, 0x09, 0x2C, 0x5E, 0x95, 0x74, 0x4A, 0xD1 + }, + { + 0xFF, 0xC1, 0x2D, 0xAA, 0xC3, 0xBA, 0x72, 0x8D, + 0xB9, 0x04, 0x98, 0xAC, 0xF8, 0x22, 0x25, 0x2E, + 0x2A, 0xAD, 0x2B, 0x31, 0x67, 0x6E, 0x5A, 0x99, + 0xD0, 0xF9, 0x40, 0x79, 0x45, 0x05, 0x50, 0x41, + 0xB1, 0xEB, 0x07, 0xD1, 0x92, 0x1B, 0xC1, 0x77, + 0xC5, 0x4A, 0x23, 0xC2, 0xE8, 0x9E, 0x4D, 0xF8, + 0xD8, 0x03, 0x20, 0x2F, 0xD4, 0x41, 0x90, 0x88, + 0xE0, 0x4D, 0x74, 0x67, 0x84, 0xDD, 0x32, 0xC3 + }, + { + 0x31, 0x49, 0x37, 0x3A, 0xCB, 0x72, 0x93, 0xD8, + 0xB0, 0x3E, 0x6D, 0xC8, 0xD7, 0xA8, 0xB8, 0x4B, + 0x6A, 0x5F, 0x28, 0x13, 0x5F, 0x5D, 0x37, 0x77, + 0x03, 0xB6, 0x0F, 0xDD, 0x70, 0x7C, 0x4C, 0x8E, + 0xF1, 0x8C, 0xD6, 0xF2, 0xCD, 0x03, 0x70, 0x53, + 0x5D, 0x97, 0x2A, 0x32, 0x33, 0xEF, 0xD1, 0x39, + 0xDD, 0x6B, 0xD2, 0xF3, 0x60, 0xA5, 0x20, 0xE9, + 0x07, 0x2D, 0x0A, 0xE3, 0xBB, 0x9B, 0xCD, 0x20 + }, + { + 0x9B, 0xC8, 0xE4, 0x9D, 0x7D, 0xD5, 0xA9, 0xB7, + 0x99, 0x6A, 0x40, 0xF6, 0x47, 0xDD, 0x2D, 0xB1, + 0x0F, 0xD5, 0xB4, 0xF7, 0x19, 0x00, 0xC3, 0x28, + 0x4C, 0x5A, 0x7F, 0x75, 0x11, 0x32, 0x1F, 0xBB, + 0xE1, 0x3C, 0x65, 0x31, 0xC7, 0xBD, 0xE2, 0x7F, + 0x50, 0xE3, 0x54, 0x6F, 0xAE, 0xD1, 0xA8, 0x1B, + 0xAA, 0x92, 0xE7, 0xD2, 0x22, 0x8D, 0xCA, 0xB9, + 0x52, 0x05, 0x18, 0x33, 0xB4, 0xCC, 0xEA, 0xE9 + }, + { + 0x25, 0x20, 0x41, 0x7C, 0x6A, 0xA6, 0x90, 0xE9, + 0x9C, 0x4E, 0xD1, 0x34, 0x40, 0x30, 0x6D, 0x5E, + 0x2D, 0xC5, 0xBB, 0xEF, 0x12, 0x10, 0xA4, 0xE8, + 0x7F, 0xCB, 0x07, 0x7F, 0x7E, 0x41, 0xBA, 0xBE, + 0xC0, 0xCB, 0x04, 0x57, 0x29, 0xF2, 0x44, 0xE9, + 0xAE, 0x32, 0x89, 0x31, 0xB8, 0x2E, 0x96, 0x54, + 0x8C, 0x20, 0x84, 0x20, 0xDD, 0x78, 0x5E, 0x1B, + 0x59, 0x8D, 0xC4, 0x29, 0xDD, 0x10, 0xF1, 0x76 + }, + { + 0x14, 0x96, 0x9B, 0xCA, 0x34, 0xAA, 0x44, 0xFF, + 0xA9, 0xB9, 0x6F, 0x6D, 0x97, 0x21, 0x1F, 0x9F, + 0xBC, 0xE5, 0x4F, 0xAC, 0x08, 0xA3, 0x13, 0x8E, + 0xC0, 0x81, 0x32, 0x58, 0x8E, 0xCC, 0x0C, 0xC8, + 0xC4, 0x8B, 0x8F, 0xB6, 0x8B, 0x50, 0xD1, 0x98, + 0xA1, 0x1B, 0xC9, 0xBF, 0x90, 0x9E, 0x91, 0xC7, + 0xC1, 0xD6, 0x3F, 0xD8, 0x85, 0x12, 0x7D, 0x88, + 0xC2, 0x39, 0x82, 0x02, 0x63, 0xBF, 0x14, 0xCA + }, + { + 0xEE, 0x7C, 0x24, 0x7F, 0x25, 0x51, 0xFA, 0x5B, + 0x19, 0x88, 0x9D, 0xEB, 0xF1, 0x1A, 0x82, 0x7A, + 0x9B, 0x92, 0xB5, 0x96, 0xD9, 0x88, 0x6F, 0xC4, + 0x77, 0x38, 0x78, 0x05, 0xD0, 0x4F, 0x33, 0xD5, + 0xDB, 0x9E, 0xA8, 0x43, 0xAF, 0x3D, 0x33, 0xC1, + 0xE0, 0x79, 0xFA, 0xFB, 0x76, 0x79, 0x4F, 0xD9, + 0xD8, 0xEA, 0x86, 0xB9, 0xBD, 0x3E, 0x87, 0x78, + 0x42, 0x0E, 0x3C, 0xED, 0xB7, 0x4B, 0xC0, 0x49 + }, + { + 0x1D, 0x78, 0x82, 0x6A, 0xA8, 0x8A, 0x6C, 0xB6, + 0x46, 0x37, 0xCF, 0x54, 0xC7, 0x52, 0x3C, 0x0E, + 0xA3, 0x42, 0xE4, 0xD8, 0x60, 0x63, 0xDE, 0x2A, + 0x0C, 0xB8, 0xB2, 0x9C, 0x6E, 0xAF, 0x30, 0xD5, + 0xBC, 0x57, 0x78, 0xA8, 0xC8, 0xB9, 0x12, 0x18, + 0x8C, 0x67, 0xE2, 0xC1, 0x01, 0x69, 0xCD, 0x00, + 0xE6, 0xF6, 0x8D, 0xAE, 0x82, 0xA5, 0xEC, 0x8C, + 0xE2, 0xD3, 0x4E, 0xFE, 0x01, 0x7C, 0xE3, 0x9F + }, + { + 0xB7, 0x8D, 0xD0, 0x03, 0xA7, 0x89, 0xDE, 0xDC, + 0x76, 0x55, 0x84, 0x59, 0x10, 0x77, 0xE7, 0x05, + 0xA1, 0x5A, 0x2A, 0xAF, 0x35, 0x23, 0xDC, 0x04, + 0x72, 0x72, 0x95, 0x69, 0x98, 0xFD, 0x01, 0x9E, + 0xB6, 0x4E, 0x1C, 0xC1, 0x1D, 0xAF, 0x06, 0x13, + 0x2C, 0xDE, 0x36, 0x72, 0x29, 0x7C, 0xCC, 0xD7, + 0x45, 0xE2, 0x21, 0x97, 0xB4, 0xF0, 0x6A, 0x19, + 0x73, 0x48, 0x29, 0xE3, 0xB4, 0x0F, 0xFD, 0x41 + }, + { + 0x78, 0xE6, 0xC1, 0x99, 0x76, 0x30, 0x01, 0xB7, + 0x9D, 0xB7, 0xC2, 0x34, 0x46, 0x4C, 0x39, 0xDE, + 0x6A, 0x71, 0x49, 0x6F, 0xDC, 0xF9, 0x69, 0x13, + 0xDD, 0xEA, 0xFF, 0x9B, 0xBE, 0xBC, 0x95, 0x3E, + 0xB8, 0x14, 0xA4, 0x1F, 0x98, 0x10, 0x44, 0x69, + 0xD1, 0xFA, 0x28, 0x11, 0x40, 0x90, 0x85, 0xF5, + 0x6A, 0x7B, 0xED, 0x55, 0x90, 0xF1, 0xC3, 0x81, + 0x01, 0xC6, 0x0F, 0x97, 0xBD, 0xB5, 0xA1, 0xEC + }, + { + 0x2A, 0x8E, 0xB7, 0x2F, 0x9B, 0x19, 0x28, 0x0D, + 0x54, 0x70, 0x98, 0x36, 0x1B, 0x5A, 0x5D, 0xE8, + 0x02, 0x62, 0x73, 0xA5, 0x91, 0x8A, 0xD6, 0x02, + 0xC8, 0xEB, 0x57, 0x98, 0xEA, 0x01, 0xA5, 0x58, + 0xD3, 0x8A, 0xFF, 0xDF, 0x3B, 0x55, 0x21, 0x54, + 0x83, 0xED, 0xEE, 0x31, 0x97, 0x9F, 0xB1, 0xFB, + 0x6B, 0xA2, 0xA3, 0xE2, 0xE5, 0x0E, 0x7B, 0xDB, + 0x24, 0x0D, 0xB6, 0x1C, 0x0D, 0xC9, 0x31, 0xF6 + }, + { + 0xE6, 0x6C, 0x38, 0x95, 0x42, 0xC4, 0xBB, 0xFA, + 0x47, 0x1C, 0xF7, 0x6E, 0x0E, 0xFD, 0xE3, 0xBD, + 0x78, 0x4B, 0x60, 0xBB, 0x94, 0x25, 0xA6, 0x2C, + 0xFC, 0x72, 0xC2, 0x2B, 0x1B, 0xE5, 0x7A, 0x96, + 0x0F, 0x1B, 0x26, 0x64, 0x78, 0x67, 0xBC, 0xB0, + 0x51, 0xE5, 0xC5, 0x9F, 0x32, 0x22, 0x96, 0x7F, + 0x1F, 0x3D, 0xD0, 0x3C, 0x97, 0x10, 0x31, 0x6D, + 0xFD, 0xD9, 0x6B, 0x53, 0x0C, 0x66, 0x09, 0xB4 + }, + { + 0x8D, 0xB4, 0x8E, 0x05, 0x4F, 0x3A, 0xBD, 0xA8, + 0xE9, 0x24, 0xB1, 0x4A, 0x1B, 0x1D, 0x41, 0x7E, + 0x49, 0x36, 0x3C, 0x6D, 0x3A, 0xFF, 0x15, 0x90, + 0x38, 0xD7, 0x2C, 0xFD, 0x49, 0x9A, 0x62, 0x45, + 0xEE, 0xEC, 0x49, 0x0D, 0xA7, 0xBA, 0xFD, 0x96, + 0x69, 0xE3, 0xFD, 0xE5, 0xB5, 0x8E, 0xAE, 0xF3, + 0x35, 0xAF, 0x93, 0x2A, 0xB3, 0x31, 0x9C, 0x12, + 0x18, 0x05, 0xAF, 0xE5, 0x88, 0x6F, 0xF8, 0x46 + }, + { + 0x79, 0x50, 0x6C, 0xA6, 0x37, 0xD1, 0x7A, 0x5A, + 0x07, 0x9E, 0x01, 0x14, 0xF4, 0x3D, 0x33, 0xA4, + 0x8C, 0xAC, 0x3A, 0x2C, 0x8C, 0x5F, 0x34, 0x2C, + 0xE4, 0xFA, 0x19, 0xD2, 0xD0, 0xF5, 0x03, 0xD6, + 0x80, 0x4B, 0x0C, 0xCE, 0x5F, 0x5B, 0xC5, 0xCA, + 0xBA, 0x60, 0xD8, 0x1E, 0x06, 0xF5, 0x70, 0xA9, + 0x2E, 0xDB, 0x5C, 0x63, 0xD9, 0xAF, 0xBD, 0x2C, + 0x98, 0xCA, 0x91, 0x6C, 0x2A, 0x2B, 0x16, 0x2A + }, + { + 0xBF, 0x17, 0x12, 0x27, 0x58, 0x41, 0xF5, 0x31, + 0x76, 0xB1, 0x7A, 0x1C, 0xB0, 0x79, 0x68, 0xD8, + 0xE9, 0x61, 0xD4, 0x47, 0x0E, 0x5B, 0x2E, 0xAA, + 0xC0, 0x7B, 0x33, 0x17, 0x2C, 0x6F, 0x05, 0x8E, + 0x23, 0x0B, 0x0D, 0x01, 0x57, 0xE3, 0xC6, 0x6F, + 0x45, 0xD7, 0x69, 0x50, 0x83, 0xAF, 0x96, 0x0A, + 0x07, 0x00, 0xDB, 0x77, 0xC8, 0xE8, 0xD7, 0x80, + 0x26, 0x75, 0x1B, 0x13, 0x0F, 0x82, 0xB1, 0x8E + }, + { + 0x5F, 0x72, 0x3A, 0x74, 0x24, 0x7B, 0xBC, 0x90, + 0x5A, 0x06, 0xE4, 0x53, 0xD4, 0xF7, 0x6C, 0xEA, + 0x12, 0x5D, 0x0B, 0x19, 0x8D, 0x90, 0x33, 0x6D, + 0x37, 0xDE, 0x03, 0x0D, 0x05, 0xF1, 0x78, 0x6A, + 0x09, 0x95, 0xF1, 0xC5, 0xAB, 0x30, 0xF3, 0x5D, + 0x03, 0xF6, 0xCC, 0x4B, 0xAE, 0xBC, 0x7E, 0x4C, + 0x33, 0xAC, 0x4E, 0x4C, 0xB0, 0x00, 0x12, 0xA2, + 0x2C, 0xFB, 0x10, 0xD1, 0x0F, 0x7B, 0x07, 0x19 + }, + { + 0x2D, 0x1F, 0x80, 0xED, 0xC9, 0x22, 0x89, 0x67, + 0x8C, 0x93, 0xE2, 0xE4, 0x2A, 0xA5, 0x80, 0x93, + 0xCF, 0xF8, 0x16, 0x41, 0x34, 0x60, 0x96, 0x3A, + 0xDD, 0x4E, 0xE0, 0xFF, 0x74, 0xB1, 0xA2, 0x84, + 0xBE, 0x9A, 0x80, 0xB2, 0xE0, 0x2A, 0xCA, 0x2C, + 0xC3, 0x83, 0xA3, 0xA8, 0xF3, 0xC7, 0x81, 0xCC, + 0x6E, 0x7D, 0x69, 0xF7, 0x0E, 0x53, 0x1B, 0x6B, + 0xD9, 0xE0, 0x33, 0x6D, 0x0D, 0x2A, 0x33, 0x58 + }, + { + 0x71, 0xB3, 0x8D, 0x90, 0x92, 0x3A, 0xEE, 0x3E, + 0x7F, 0x73, 0xB0, 0x40, 0xA9, 0x9A, 0x60, 0x0A, + 0x40, 0x41, 0xFF, 0x7A, 0x4E, 0xB6, 0x51, 0xC9, + 0x05, 0x35, 0xE9, 0xD6, 0xEA, 0xDD, 0x88, 0x60, + 0xEF, 0x9C, 0x03, 0xE7, 0xE4, 0xC3, 0xB6, 0xC9, + 0x50, 0xFA, 0xC2, 0xE1, 0x28, 0x3A, 0x55, 0x07, + 0xFC, 0x73, 0xE5, 0x81, 0x09, 0x5D, 0xEA, 0x3D, + 0x3A, 0x30, 0xAB, 0xBF, 0xAB, 0x34, 0x18, 0x84 + }, + { + 0x88, 0xD3, 0xE8, 0xB8, 0x8D, 0xCD, 0xE0, 0x56, + 0x56, 0x44, 0x66, 0xF9, 0x5D, 0xF6, 0x77, 0x74, + 0x7E, 0x0D, 0x95, 0x10, 0x48, 0xEB, 0x56, 0x6D, + 0xE4, 0x5E, 0x53, 0x77, 0xED, 0x7A, 0x50, 0x5C, + 0x0B, 0xFB, 0x81, 0x71, 0x3C, 0xBD, 0xE5, 0x4C, + 0x6A, 0xF6, 0xF3, 0x00, 0x27, 0x36, 0xB0, 0x2F, + 0x9A, 0x28, 0x10, 0xB0, 0x6B, 0x6A, 0xB2, 0xE6, + 0x39, 0xF6, 0xDF, 0xAC, 0x61, 0x74, 0x0D, 0x66 + }, + { + 0x9E, 0xBC, 0x3C, 0x2C, 0x47, 0x32, 0x76, 0xA7, + 0xB2, 0x67, 0xA4, 0xC1, 0x47, 0x79, 0xDD, 0xCE, + 0x48, 0x90, 0x73, 0x21, 0x5E, 0xE0, 0x20, 0x18, + 0x4E, 0xFB, 0x9E, 0xE4, 0x60, 0xF9, 0x46, 0x93, + 0x82, 0x59, 0x3D, 0x27, 0x54, 0x44, 0xB6, 0x49, + 0x08, 0xC5, 0x02, 0x46, 0x7E, 0x25, 0x61, 0x15, + 0xC6, 0x96, 0x28, 0x63, 0x4B, 0xA9, 0x5D, 0x51, + 0xD4, 0xF3, 0xA1, 0x1A, 0xE7, 0xDC, 0x48, 0x2B + }, + { + 0x80, 0x4A, 0x16, 0x56, 0x00, 0x3C, 0x12, 0x0C, + 0x59, 0xD9, 0xB3, 0xAD, 0xFC, 0x25, 0x8C, 0x56, + 0x71, 0x52, 0x11, 0x32, 0xC9, 0x9A, 0xE4, 0x47, + 0x69, 0x38, 0x0C, 0x26, 0x95, 0x61, 0xC4, 0xF9, + 0x9B, 0x8F, 0x1E, 0xB0, 0x8F, 0x89, 0xD5, 0x54, + 0x66, 0x45, 0x31, 0x73, 0x5D, 0x68, 0x49, 0x8D, + 0xD2, 0x7F, 0x3C, 0xB4, 0x14, 0xDF, 0xCE, 0x1F, + 0x50, 0xFD, 0x7C, 0x9A, 0x3C, 0x9D, 0x14, 0x1D + }, + { + 0xAE, 0xBC, 0xC4, 0xE3, 0xB3, 0xF7, 0x99, 0xE3, + 0x15, 0x44, 0x69, 0x69, 0x33, 0x7C, 0x74, 0x2F, + 0x21, 0x32, 0xF8, 0xFB, 0xBF, 0x63, 0x5C, 0x45, + 0xDB, 0x3A, 0xCB, 0xB9, 0xC1, 0x39, 0x4A, 0xB9, + 0x91, 0x41, 0x16, 0x0A, 0xA3, 0xB1, 0x99, 0xF3, + 0xD7, 0x31, 0x9B, 0xEE, 0xCB, 0xCE, 0xC8, 0x8A, + 0x3C, 0xEF, 0x7A, 0x29, 0x64, 0x22, 0x18, 0x2D, + 0x26, 0x20, 0x9F, 0x30, 0xED, 0xBB, 0x38, 0xA1 + }, + { + 0xC6, 0x86, 0x71, 0xDC, 0x32, 0x77, 0xBF, 0xDD, + 0x7A, 0x02, 0x2B, 0x09, 0x77, 0xD8, 0xC8, 0x7F, + 0x68, 0x10, 0x76, 0x34, 0xB8, 0x9B, 0x51, 0xA9, + 0x7B, 0xD5, 0x49, 0x91, 0xA1, 0x1D, 0xF9, 0xA3, + 0x47, 0x3B, 0x02, 0xEC, 0x11, 0x49, 0x41, 0xB9, + 0x7E, 0x46, 0xE4, 0x1A, 0x3F, 0x5F, 0x21, 0x85, + 0xC4, 0x85, 0x54, 0x92, 0x38, 0xD8, 0xCE, 0x12, + 0xD6, 0x31, 0x4B, 0xD1, 0xFF, 0x7F, 0x73, 0xD3 + }, + { + 0x1E, 0x16, 0xBD, 0x16, 0xC5, 0xA9, 0x8F, 0x59, + 0x2F, 0xEB, 0x21, 0xC7, 0x24, 0x11, 0xCC, 0x7B, + 0x90, 0xD1, 0x75, 0x16, 0x86, 0x5A, 0xE4, 0x2F, + 0x78, 0x40, 0x98, 0xAE, 0x1F, 0xBB, 0xC4, 0x42, + 0xBF, 0x14, 0xD6, 0xC8, 0xE4, 0xBB, 0x1D, 0xA8, + 0x82, 0x16, 0xF4, 0xF8, 0x5D, 0x77, 0x54, 0xA0, + 0xA6, 0xF5, 0x1E, 0x10, 0x90, 0xDA, 0xA6, 0xD0, + 0x1D, 0xD6, 0xC7, 0x75, 0x90, 0x16, 0x87, 0x21 + }, + { + 0x70, 0x3D, 0x4C, 0x03, 0x41, 0xE7, 0x1D, 0xE4, + 0x0F, 0x78, 0xD4, 0x2D, 0x8E, 0x25, 0xC0, 0xE9, + 0xE0, 0x3A, 0xC0, 0xEC, 0x65, 0x35, 0xF0, 0x20, + 0x2B, 0xA6, 0xAB, 0xF7, 0x7D, 0x93, 0xA6, 0xC4, + 0x62, 0xEB, 0x84, 0xF2, 0x4F, 0x2F, 0x38, 0x12, + 0xA6, 0x98, 0xB9, 0x97, 0x9F, 0xD1, 0x7E, 0xA7, + 0x0E, 0x9F, 0x8C, 0x11, 0x03, 0x49, 0xE8, 0x7C, + 0xD4, 0x68, 0x36, 0xDC, 0xFC, 0x6F, 0xA1, 0xAD + }, + { + 0x82, 0xAD, 0xB4, 0xFD, 0xF1, 0xE1, 0xD6, 0x63, + 0x85, 0x37, 0x0F, 0x22, 0x4F, 0x85, 0x99, 0xA2, + 0x20, 0x57, 0x89, 0x5F, 0x11, 0xBD, 0xD2, 0x6B, + 0x22, 0x8D, 0xD3, 0xFA, 0x0B, 0x61, 0x16, 0x42, + 0x19, 0xA1, 0x04, 0x17, 0xA0, 0x5E, 0x60, 0xEB, + 0x9E, 0xD8, 0x13, 0x09, 0xAA, 0x81, 0xB6, 0x65, + 0x08, 0xED, 0xEF, 0xF4, 0x4E, 0x62, 0xEE, 0x7F, + 0x69, 0x2D, 0x7F, 0xF3, 0x69, 0xDC, 0x0D, 0xAF + }, + { + 0x9D, 0x6A, 0x05, 0x03, 0x70, 0xE6, 0x3C, 0x2A, + 0xEE, 0x1E, 0x62, 0x39, 0xE9, 0xC7, 0x6A, 0x27, + 0x18, 0x67, 0x6A, 0x2E, 0xBA, 0x49, 0x1F, 0x13, + 0x4A, 0x2F, 0xC6, 0x1F, 0xE8, 0x28, 0x68, 0xD9, + 0xD2, 0x8A, 0xB6, 0x01, 0xB0, 0x3B, 0xE0, 0x96, + 0xA3, 0x9E, 0xC4, 0x93, 0xCE, 0x3F, 0x67, 0x9E, + 0x48, 0x01, 0x00, 0xF3, 0x2C, 0xFC, 0x44, 0x68, + 0xDD, 0x1E, 0xD8, 0x31, 0xCB, 0xBB, 0xB5, 0x28 + }, + { + 0x6A, 0x34, 0x7E, 0x1A, 0x63, 0x3F, 0x05, 0x96, + 0xC1, 0x73, 0x48, 0xCE, 0xA3, 0x26, 0x9A, 0x54, + 0x1E, 0x93, 0x63, 0x83, 0xF5, 0x57, 0x01, 0xAB, + 0xA6, 0xA0, 0xCB, 0x64, 0x48, 0xB2, 0x4F, 0x97, + 0xD6, 0x30, 0x85, 0x13, 0xA3, 0x1B, 0x13, 0x8A, + 0xC7, 0x8C, 0x44, 0xDC, 0xAF, 0xF9, 0x96, 0xBC, + 0x56, 0x3E, 0xDB, 0x6F, 0xE4, 0x63, 0x7E, 0x7C, + 0xC9, 0x43, 0x4F, 0x1C, 0x63, 0x11, 0x52, 0x66 + }, + { + 0xE0, 0x30, 0x7A, 0xA5, 0x7D, 0x85, 0xDB, 0x28, + 0xC9, 0x92, 0x36, 0xC3, 0x65, 0x67, 0x0B, 0xFC, + 0xE7, 0xC8, 0x48, 0x65, 0x34, 0xC9, 0x02, 0x1D, + 0x6C, 0x6A, 0x17, 0xC4, 0xAD, 0x8F, 0xE0, 0x2E, + 0x26, 0x85, 0x88, 0x90, 0x48, 0x57, 0x55, 0xF8, + 0x38, 0x19, 0x00, 0xF2, 0x35, 0xBF, 0x97, 0x5E, + 0x2E, 0x04, 0xE9, 0x45, 0x53, 0xA6, 0x0D, 0x80, + 0x0B, 0x26, 0xE7, 0x11, 0xC9, 0xB8, 0xF6, 0x8E + }, + { + 0xBB, 0xEA, 0x1E, 0xD2, 0x78, 0x21, 0x31, 0xAB, + 0xF8, 0xFD, 0x12, 0x56, 0x33, 0x37, 0x54, 0xF6, + 0x55, 0x4B, 0xC7, 0xD8, 0xA7, 0x1F, 0xC4, 0x3C, + 0x87, 0x93, 0x63, 0x4A, 0x94, 0x0E, 0x09, 0x67, + 0xEF, 0xC9, 0x94, 0x7C, 0x54, 0xC2, 0x2B, 0x7B, + 0xE7, 0x27, 0x53, 0xB8, 0x0A, 0x36, 0x5F, 0x51, + 0x7D, 0xBD, 0xEA, 0x9C, 0x9A, 0x0B, 0xDC, 0xEB, + 0xB9, 0xD3, 0x6A, 0x04, 0xD8, 0x5A, 0xDB, 0x79 + }, + { + 0x87, 0x1A, 0x82, 0x99, 0x8B, 0x3E, 0x68, 0xAE, + 0xA1, 0x46, 0xD7, 0x42, 0x0C, 0xD6, 0x52, 0x97, + 0x6B, 0x39, 0x61, 0x1D, 0xA8, 0x66, 0xFD, 0x3F, + 0x46, 0xF7, 0xBD, 0xDE, 0x43, 0xD1, 0x88, 0x8B, + 0xAD, 0x59, 0x7A, 0x39, 0xA5, 0x94, 0x71, 0xDB, + 0x93, 0x5D, 0x58, 0x05, 0xBD, 0x4E, 0xFA, 0xE9, + 0x2C, 0x33, 0x9F, 0xC4, 0xC1, 0x67, 0x07, 0x3E, + 0x18, 0x7B, 0x81, 0xB5, 0xEF, 0xED, 0xCB, 0x69 + }, + { + 0x3F, 0x49, 0x52, 0xCC, 0xD8, 0xBF, 0x61, 0xCB, + 0xF1, 0x19, 0x7E, 0xC7, 0x2D, 0x35, 0xB1, 0xE7, + 0x38, 0xA6, 0x47, 0x0D, 0xAD, 0xA6, 0xA2, 0x1F, + 0xA3, 0x2B, 0x55, 0x0A, 0x15, 0xB6, 0xE6, 0x10, + 0x85, 0x2D, 0xC2, 0xD8, 0xEE, 0x70, 0x6B, 0x29, + 0x14, 0xDE, 0xC5, 0x09, 0xFE, 0x3A, 0x4E, 0x1F, + 0xEC, 0xF1, 0x86, 0x39, 0x0F, 0x76, 0xC0, 0x67, + 0x7A, 0x2F, 0x15, 0xC8, 0xBF, 0xAD, 0x22, 0x84 + }, + { + 0x30, 0x16, 0xA4, 0x15, 0xB5, 0x7E, 0x44, 0xBB, + 0x4A, 0xE6, 0xE2, 0xAF, 0xD0, 0x9C, 0xD1, 0x93, + 0x8A, 0xA5, 0x9C, 0x84, 0x9E, 0x5E, 0xC7, 0x7A, + 0x39, 0xEA, 0xED, 0x79, 0xDE, 0x25, 0x74, 0xBC, + 0x51, 0x77, 0x9B, 0x76, 0x33, 0x12, 0xFD, 0xD4, + 0xF1, 0x07, 0x5E, 0x0C, 0x81, 0x1F, 0x3D, 0xAB, + 0xE7, 0x49, 0x96, 0xB6, 0x3B, 0x6A, 0x86, 0xD3, + 0xDB, 0x2C, 0xCD, 0x32, 0x12, 0x27, 0xEE, 0x7A + }, + { + 0xED, 0xC5, 0xC1, 0xFA, 0xC8, 0xC1, 0x7A, 0x12, + 0x79, 0x6B, 0xCF, 0xC2, 0x8C, 0x17, 0xA2, 0x7E, + 0x14, 0xA5, 0x5F, 0xC5, 0x6D, 0x4F, 0xAD, 0x77, + 0x75, 0xE2, 0x9F, 0x54, 0x26, 0xAE, 0x57, 0xB2, + 0x15, 0x49, 0x0C, 0x3D, 0x4D, 0x7A, 0x63, 0xCE, + 0x16, 0xFF, 0x41, 0x5C, 0x27, 0x83, 0x01, 0x0D, + 0xAE, 0xA2, 0x14, 0xFA, 0xF0, 0x51, 0xE3, 0xF0, + 0xCA, 0xA7, 0x90, 0x3B, 0x9F, 0xCE, 0x13, 0x6B + }, + { + 0x7F, 0x12, 0x54, 0x89, 0xC3, 0x03, 0x32, 0x89, + 0x25, 0x7E, 0x90, 0xDD, 0x80, 0xCD, 0x36, 0xA1, + 0x5E, 0xF3, 0xBB, 0x1C, 0x29, 0xE9, 0x99, 0xF7, + 0xD4, 0x5A, 0xEA, 0x7D, 0x0D, 0xB0, 0x96, 0xA5, + 0x33, 0x7B, 0xFA, 0xB8, 0xBD, 0xBE, 0x76, 0x6D, + 0x8C, 0x2D, 0x38, 0x6B, 0x77, 0x7C, 0xC6, 0x12, + 0x6B, 0xD5, 0xE7, 0x87, 0x76, 0x85, 0x6C, 0xC4, + 0xE9, 0x8E, 0x3F, 0x29, 0x7C, 0xE9, 0xA7, 0x23 + }, + { + 0x56, 0x66, 0x35, 0xEE, 0xAA, 0x6A, 0xCE, 0xBE, + 0xFA, 0x84, 0x3A, 0x4A, 0x40, 0xF6, 0x8B, 0x5E, + 0xE7, 0x05, 0xB9, 0x6C, 0xC3, 0x5B, 0xE5, 0x35, + 0x70, 0xEE, 0xC2, 0x73, 0xA2, 0xD3, 0x78, 0x2E, + 0x8A, 0x37, 0xDF, 0x2E, 0x32, 0x6D, 0x8A, 0xA3, + 0x54, 0x39, 0xCE, 0x51, 0xF9, 0x89, 0xD2, 0x74, + 0xC1, 0xDC, 0xBC, 0xF7, 0x4A, 0xE9, 0x78, 0xE9, + 0x2D, 0x60, 0x2B, 0x79, 0x9F, 0x8D, 0x55, 0x16 + }, + { + 0xBF, 0x22, 0x11, 0xCA, 0xD5, 0x44, 0x72, 0x0F, + 0x23, 0x47, 0x94, 0x45, 0xE7, 0x4B, 0x30, 0x33, + 0x57, 0xE9, 0x5C, 0x2D, 0x6F, 0xBB, 0xA4, 0x4E, + 0x3F, 0x84, 0xD8, 0xD9, 0xCE, 0x69, 0x2E, 0xE0, + 0xD4, 0x8D, 0x09, 0xBF, 0x88, 0x35, 0x50, 0x47, + 0x09, 0x23, 0x6D, 0x6D, 0xAA, 0x04, 0x1B, 0xF5, + 0x18, 0xFE, 0x19, 0xDC, 0x7F, 0x60, 0x76, 0x50, + 0x01, 0x3C, 0xFE, 0x41, 0xAD, 0x8F, 0xB6, 0x9D + }, + { + 0x48, 0x13, 0x48, 0xFC, 0x0B, 0x3C, 0xFF, 0x53, + 0x70, 0xBF, 0x50, 0x42, 0x48, 0xFD, 0x4B, 0x8E, + 0x27, 0xE2, 0x54, 0x59, 0x01, 0xF8, 0xD7, 0x2D, + 0x8F, 0x0C, 0x16, 0xA1, 0x3B, 0xFF, 0x75, 0x05, + 0x75, 0xE4, 0x65, 0xA5, 0xB8, 0x25, 0xF0, 0x5B, + 0xA7, 0x72, 0xE2, 0x33, 0xDC, 0x1F, 0x96, 0x84, + 0xF7, 0xD6, 0xF6, 0x53, 0xF7, 0x09, 0x5E, 0x5D, + 0xD7, 0x77, 0xBE, 0x37, 0x4F, 0xAD, 0xEF, 0x6F + }, + { + 0x36, 0xC3, 0x60, 0x12, 0xC8, 0xB6, 0xE5, 0x8B, + 0x58, 0x81, 0x1D, 0x3E, 0xCE, 0x05, 0x2A, 0x8A, + 0x63, 0x29, 0x6A, 0x3F, 0x18, 0xB2, 0x60, 0xE4, + 0x1F, 0x66, 0xFB, 0xA9, 0xD4, 0xAC, 0x32, 0x9A, + 0x05, 0xBD, 0x2D, 0xCC, 0xA0, 0xC9, 0x10, 0x37, + 0x12, 0x94, 0xA4, 0x25, 0x77, 0x33, 0x5B, 0x8C, + 0xE4, 0x86, 0xDE, 0xFE, 0x88, 0x6E, 0xB1, 0x12, + 0x51, 0x15, 0x50, 0xFE, 0x68, 0xC1, 0x47, 0xFF + }, + { + 0x7C, 0x50, 0xF8, 0xDD, 0x0E, 0xAE, 0x37, 0x35, + 0x3F, 0x20, 0xEB, 0x00, 0x11, 0xD3, 0x10, 0x3C, + 0x63, 0xF8, 0x28, 0xC2, 0x6D, 0xEB, 0xB6, 0x24, + 0xD8, 0xAE, 0x82, 0x78, 0x9F, 0x06, 0xEF, 0x32, + 0x25, 0x3B, 0xBC, 0x05, 0x76, 0x25, 0x18, 0x2C, + 0x99, 0xE6, 0x47, 0xCF, 0x01, 0xC9, 0x57, 0xFE, + 0xBE, 0x81, 0xA1, 0x16, 0xCF, 0x08, 0xA5, 0x4C, + 0x26, 0x18, 0x9C, 0x69, 0x6F, 0xC7, 0xD0, 0xE9 + }, + { + 0x69, 0x46, 0x89, 0xAE, 0xDE, 0x5F, 0xCF, 0xE9, + 0xCA, 0x06, 0xA7, 0x10, 0x5B, 0x3E, 0x56, 0x7F, + 0xED, 0x67, 0x5B, 0x35, 0x53, 0xE0, 0xD9, 0x2A, + 0x72, 0x59, 0xA4, 0x5A, 0xA0, 0x51, 0x0C, 0xE4, + 0x5C, 0x6F, 0xBB, 0x1B, 0x6F, 0x4A, 0x58, 0xCB, + 0x36, 0x5F, 0xE4, 0x45, 0xAE, 0x71, 0x7E, 0x2E, + 0xE5, 0x51, 0x56, 0x46, 0xDB, 0x06, 0xF0, 0x2D, + 0x38, 0x54, 0x80, 0x73, 0x22, 0xFA, 0x7E, 0xFE + }, + { + 0x25, 0x57, 0x6F, 0x59, 0x46, 0xE4, 0xE2, 0xA8, + 0x2E, 0x87, 0x22, 0xCE, 0xAD, 0x59, 0xF1, 0xDB, + 0x6B, 0x32, 0xA3, 0xB5, 0x15, 0x94, 0x22, 0xA8, + 0x93, 0x67, 0xCB, 0x02, 0x41, 0x32, 0xD3, 0x4B, + 0xF0, 0x59, 0x98, 0xFA, 0x90, 0xEE, 0xCB, 0x9E, + 0x1D, 0xF5, 0x9D, 0x0C, 0xFB, 0xD8, 0x1B, 0xAC, + 0x77, 0x1E, 0x7E, 0xF6, 0xE5, 0xB8, 0xD7, 0x6C, + 0x96, 0x7C, 0xB3, 0x50, 0x11, 0xEC, 0xA4, 0xC9 + }, + { + 0x30, 0x75, 0x23, 0xED, 0xD9, 0xD7, 0xCA, 0xBC, + 0xA3, 0xE3, 0x3D, 0x88, 0x87, 0x11, 0x80, 0x46, + 0xB8, 0x4C, 0xBF, 0x5B, 0xD5, 0xF6, 0xE0, 0x9C, + 0xE9, 0x5E, 0xF9, 0xAA, 0x55, 0xBF, 0x26, 0xE9, + 0x85, 0x50, 0x52, 0x46, 0x5C, 0xF8, 0x3D, 0x1D, + 0x7B, 0x2E, 0x9D, 0x2F, 0x39, 0x2F, 0xF9, 0x6E, + 0x0A, 0x06, 0x6B, 0xD0, 0x22, 0x69, 0x8D, 0xD2, + 0x75, 0xE0, 0x56, 0x47, 0x9C, 0x53, 0xBF, 0x9F + }, + { + 0xB1, 0xFD, 0x92, 0x82, 0xA5, 0x37, 0x6E, 0xB5, + 0xB6, 0x47, 0x6A, 0x1A, 0x83, 0xF6, 0xDB, 0x37, + 0x98, 0x68, 0x6F, 0xCC, 0xA2, 0x8F, 0x37, 0xB2, + 0x1A, 0x4F, 0x71, 0xC2, 0x4D, 0x99, 0xD1, 0x92, + 0x70, 0xF6, 0xF5, 0xBE, 0xE1, 0x77, 0xD9, 0x1E, + 0x0E, 0xDB, 0xA4, 0xED, 0xB6, 0xD4, 0x5B, 0xE1, + 0xDB, 0x89, 0xF7, 0x80, 0x7C, 0x53, 0x69, 0x31, + 0xFF, 0x15, 0x35, 0xBF, 0x96, 0x99, 0x37, 0xD3 + }, + { + 0xEF, 0x9D, 0x17, 0xEF, 0x5F, 0x5F, 0x58, 0xEC, + 0x08, 0x2E, 0x82, 0x10, 0x29, 0xD2, 0x13, 0x24, + 0xE2, 0x0D, 0xCB, 0xD9, 0x10, 0xBA, 0xC7, 0xA0, + 0x11, 0xDD, 0x52, 0xF9, 0x2F, 0x5A, 0x14, 0xD7, + 0x4D, 0x28, 0xDC, 0x00, 0xA8, 0xC5, 0x7E, 0xAE, + 0x89, 0xEE, 0x63, 0xF7, 0xF3, 0xFB, 0x2E, 0x31, + 0x6F, 0xAC, 0xAB, 0xD5, 0x58, 0xE6, 0x53, 0x46, + 0x10, 0x5C, 0x05, 0x17, 0x7F, 0xE9, 0x3B, 0x14 + }, + { + 0xCB, 0xB8, 0xC6, 0xFF, 0xF6, 0xE5, 0xB6, 0xD7, + 0x1D, 0x71, 0x96, 0x22, 0xD8, 0x00, 0x40, 0xE9, + 0x99, 0x3F, 0xBC, 0x4A, 0xA6, 0x3C, 0xE9, 0x91, + 0x61, 0x21, 0xF1, 0x69, 0xC1, 0x11, 0xB6, 0xF4, + 0xEE, 0x3E, 0x90, 0x1C, 0x17, 0x6A, 0x4B, 0x93, + 0xA2, 0xD9, 0x50, 0x15, 0x2A, 0xF3, 0x2C, 0xF3, + 0x3F, 0x59, 0x04, 0x81, 0x72, 0xB4, 0xD0, 0xDC, + 0x39, 0xED, 0xCF, 0xB5, 0x5E, 0x8D, 0x7F, 0x87 + }, + { + 0xDD, 0x0F, 0xB4, 0xB3, 0x59, 0x92, 0xE2, 0xFF, + 0x77, 0xEA, 0xEA, 0x6C, 0xF9, 0x10, 0x8B, 0xE6, + 0x64, 0x1E, 0x2D, 0x81, 0xF3, 0x7F, 0x73, 0x02, + 0x6D, 0x0F, 0xAE, 0x46, 0x63, 0xEE, 0xA5, 0x60, + 0x19, 0x9E, 0x72, 0x9F, 0x1D, 0xCA, 0xDE, 0x12, + 0xCF, 0xD9, 0x39, 0x54, 0x15, 0xE4, 0x27, 0xFD, + 0x59, 0xFD, 0x85, 0xD4, 0x44, 0xE0, 0xFA, 0xE0, + 0x94, 0xBA, 0x74, 0x60, 0x61, 0xC2, 0x21, 0xEA + }, + { + 0xAA, 0xAD, 0x23, 0xFE, 0x63, 0xF3, 0xB3, 0x10, + 0xF4, 0x1E, 0xE0, 0x00, 0x67, 0x19, 0x40, 0xE4, + 0x9D, 0x76, 0x86, 0xA2, 0x8E, 0x8B, 0xD6, 0xD5, + 0x12, 0x99, 0xC4, 0x23, 0x86, 0xC6, 0x0C, 0x0F, + 0x73, 0x10, 0x74, 0x6E, 0xE6, 0x1D, 0xC1, 0x75, + 0xC6, 0x45, 0x07, 0x4E, 0xA1, 0xE8, 0x29, 0xC0, + 0xE1, 0xE8, 0x78, 0x0A, 0xA6, 0xDF, 0x34, 0x9B, + 0xB6, 0x7E, 0xB4, 0xC9, 0x2F, 0xF1, 0xAF, 0x7B + }, + { + 0x54, 0x05, 0x61, 0x04, 0x50, 0x39, 0x5B, 0xEC, + 0xC5, 0x51, 0x12, 0xCA, 0xE1, 0xCF, 0xA8, 0xDA, + 0xB8, 0x30, 0x0D, 0x30, 0x87, 0x7A, 0x25, 0xC0, + 0x27, 0x2E, 0x9A, 0x9C, 0x86, 0xAE, 0xA7, 0x9E, + 0x31, 0x11, 0x07, 0xDF, 0x5D, 0x3E, 0x00, 0xE8, + 0xBE, 0x18, 0x37, 0xDD, 0xBC, 0x19, 0x7D, 0xCA, + 0xDF, 0x56, 0xBA, 0xE2, 0x49, 0x16, 0xD3, 0x37, + 0xE9, 0xEA, 0x15, 0xD0, 0x6A, 0x6D, 0xD0, 0x46 + }, + { + 0x43, 0x45, 0x43, 0x2B, 0x17, 0x59, 0x7B, 0x9E, + 0x6E, 0x50, 0xBF, 0x1A, 0x95, 0x7A, 0x81, 0xA0, + 0xD5, 0xB1, 0x88, 0x06, 0x48, 0x00, 0xC5, 0xB6, + 0xF5, 0x39, 0x90, 0x8B, 0x37, 0x37, 0xA6, 0x49, + 0xA5, 0xE6, 0x31, 0xFF, 0x67, 0xC0, 0x01, 0x94, + 0xD0, 0xE1, 0xF1, 0x80, 0xCB, 0x0F, 0x9A, 0x67, + 0x54, 0xF7, 0x12, 0xF4, 0x01, 0x83, 0x24, 0x16, + 0x46, 0x95, 0x47, 0xF7, 0xA4, 0xF2, 0x65, 0x73 + }, + { + 0xD9, 0xE3, 0x8D, 0x8E, 0xB0, 0xD7, 0x20, 0x65, + 0xC9, 0x1C, 0xC1, 0x40, 0x4C, 0xC7, 0xB2, 0x42, + 0xEA, 0x8C, 0x71, 0xDA, 0x65, 0xF7, 0xD7, 0xAE, + 0x55, 0x1B, 0x78, 0x3F, 0x94, 0xC6, 0xDA, 0xB8, + 0x51, 0xE2, 0x16, 0xF4, 0x38, 0x41, 0xC4, 0x7B, + 0x71, 0x75, 0x92, 0xC7, 0x51, 0x7B, 0x96, 0x01, + 0xDA, 0x36, 0xED, 0xB6, 0x12, 0x4A, 0x12, 0x35, + 0x8A, 0x2D, 0xFF, 0xB3, 0x08, 0xA0, 0xB6, 0xB3 + }, + { + 0x09, 0x70, 0x44, 0x5E, 0x13, 0x2A, 0x1D, 0xCC, + 0x48, 0x66, 0xB7, 0xD5, 0xD7, 0xA3, 0x43, 0xB4, + 0xEA, 0x2C, 0x2E, 0xBE, 0xDB, 0xAE, 0x41, 0x27, + 0x4B, 0xB0, 0xA2, 0x3C, 0xCF, 0xDD, 0xC7, 0x7A, + 0xAB, 0x18, 0xA5, 0xEA, 0xD5, 0x22, 0x65, 0xFD, + 0x06, 0x04, 0x09, 0xDF, 0x75, 0xE7, 0xB3, 0x9A, + 0x2E, 0x21, 0x44, 0x1A, 0x00, 0x3F, 0xB7, 0xC4, + 0xF4, 0x87, 0xC9, 0x31, 0x11, 0xD0, 0xA7, 0x97 + }, + { + 0x9E, 0x00, 0x99, 0x69, 0x7D, 0x5A, 0xBF, 0x12, + 0x62, 0x16, 0x30, 0x80, 0x18, 0x39, 0x87, 0x2B, + 0x78, 0xC6, 0xE7, 0x59, 0x46, 0xCF, 0xC9, 0xB1, + 0x95, 0xD3, 0x65, 0xB0, 0x11, 0x87, 0x0D, 0x43, + 0x43, 0xCC, 0x63, 0x31, 0xD3, 0xAD, 0x22, 0x61, + 0x5F, 0x8C, 0x11, 0x63, 0x3A, 0x71, 0xCB, 0x2A, + 0x7A, 0x4B, 0x50, 0xF6, 0x6B, 0xCF, 0x0E, 0xCA, + 0x07, 0x25, 0xF0, 0x02, 0xA3, 0x5C, 0x76, 0x79 + }, + { + 0xF4, 0xDF, 0xFC, 0x7B, 0xEE, 0x6A, 0x72, 0x1A, + 0x90, 0x4B, 0x8D, 0xA4, 0xD6, 0x62, 0x31, 0xA3, + 0xEB, 0x70, 0xAC, 0x3B, 0xFC, 0x6F, 0x7E, 0x20, + 0x0A, 0x6B, 0xE0, 0xD7, 0x05, 0x70, 0x68, 0xD5, + 0x2B, 0xA6, 0x53, 0xBD, 0x43, 0x15, 0x53, 0xD7, + 0x78, 0xDC, 0x70, 0xDC, 0x34, 0xB9, 0x72, 0xCC, + 0x41, 0xD9, 0xFF, 0x7C, 0xEA, 0xFD, 0x90, 0x98, + 0xBB, 0x17, 0xF5, 0x94, 0x72, 0x7B, 0x15, 0x31 + }, + { + 0x02, 0x8F, 0x4B, 0xD0, 0xEE, 0x65, 0x4E, 0x38, + 0x98, 0x01, 0xB7, 0x0D, 0xEF, 0x0F, 0x7A, 0x36, + 0xE7, 0xCB, 0x7A, 0x5F, 0x50, 0x9E, 0x55, 0x8D, + 0x72, 0x24, 0xC9, 0x4E, 0xF6, 0x3B, 0xBC, 0xFA, + 0xE4, 0x45, 0x02, 0x94, 0x0F, 0x3A, 0x83, 0x0F, + 0x28, 0xB3, 0x23, 0x41, 0x5C, 0xEF, 0x80, 0x78, + 0x0C, 0xBB, 0x3A, 0x82, 0x39, 0xFC, 0x07, 0x8D, + 0xFB, 0x9F, 0xB4, 0xB3, 0x97, 0x75, 0x33, 0xEA + }, + { + 0x07, 0x96, 0x9E, 0xED, 0x9A, 0x1A, 0xAF, 0x44, + 0x35, 0x04, 0x19, 0x77, 0x65, 0x96, 0x4F, 0x38, + 0x55, 0x11, 0xEE, 0xE5, 0x90, 0x10, 0xA4, 0x7C, + 0x89, 0x10, 0x68, 0xAE, 0xFE, 0x53, 0x66, 0x4E, + 0xE5, 0xA7, 0x34, 0x49, 0x0B, 0xC3, 0xCB, 0x94, + 0x13, 0x9D, 0x33, 0x72, 0x9B, 0x1C, 0xF9, 0xA8, + 0xE8, 0xAE, 0xBA, 0x13, 0x69, 0xE1, 0x29, 0x1E, + 0x58, 0x0D, 0x2A, 0xD1, 0x24, 0x30, 0x93, 0xB3 + }, + { + 0xEF, 0x76, 0x92, 0xE3, 0x53, 0xFA, 0xB9, 0xD1, + 0x10, 0x6B, 0x61, 0x2E, 0xFE, 0x17, 0x8F, 0x38, + 0xF6, 0x8F, 0xD7, 0xE7, 0x04, 0x0A, 0x29, 0x90, + 0x7B, 0x08, 0x1D, 0x1B, 0x53, 0xA0, 0xC3, 0xD2, + 0x59, 0x7F, 0xAC, 0x28, 0xF1, 0xE5, 0x6D, 0x6F, + 0xA7, 0x1A, 0xCB, 0x1B, 0xF9, 0x7E, 0xE9, 0x38, + 0x44, 0x2D, 0x7B, 0x47, 0xA3, 0xBA, 0x88, 0x4B, + 0x12, 0x7C, 0x33, 0x9A, 0xBC, 0xA8, 0xB9, 0xB0 + }, + { + 0x3D, 0xA9, 0x6C, 0xE8, 0x02, 0x31, 0x1B, 0x6F, + 0xBA, 0x40, 0x36, 0x15, 0x86, 0x42, 0x75, 0x30, + 0x6B, 0xDF, 0x9B, 0x3D, 0xCD, 0x82, 0x09, 0x82, + 0xAF, 0xF0, 0x32, 0xAA, 0x38, 0x26, 0x3A, 0x65, + 0xB1, 0x96, 0x57, 0xE9, 0x5C, 0xB7, 0xE8, 0xBD, + 0x19, 0xA3, 0x96, 0xA0, 0x42, 0x9E, 0xDD, 0xED, + 0xDB, 0xA0, 0x8E, 0xDF, 0x66, 0x8F, 0xE7, 0xAE, + 0xF9, 0x8C, 0xA8, 0x3A, 0x10, 0xFC, 0x20, 0x5E + }, + { + 0x3A, 0xBC, 0xF4, 0x76, 0xFC, 0x50, 0x0C, 0x0C, + 0x13, 0x79, 0x9D, 0x73, 0x7B, 0x87, 0xDF, 0x3B, + 0x9E, 0x6A, 0x01, 0x74, 0xAE, 0xD9, 0x4E, 0xB0, + 0xAF, 0x1F, 0xEA, 0x9E, 0x36, 0x69, 0xE9, 0x4D, + 0x18, 0x14, 0x94, 0xD3, 0xA4, 0x23, 0xF5, 0xA9, + 0x0D, 0xF8, 0x62, 0x0D, 0x1E, 0xF0, 0xF1, 0x67, + 0x74, 0x36, 0xE2, 0xF7, 0x99, 0x9F, 0x7B, 0x33, + 0xA1, 0x8C, 0x6E, 0x9B, 0xFC, 0x77, 0x14, 0xA1 + }, + { + 0xF9, 0xCA, 0x5F, 0xD1, 0xF4, 0x8A, 0x97, 0x66, + 0xDF, 0x55, 0xC9, 0x93, 0x80, 0x19, 0x8D, 0x44, + 0x20, 0x35, 0x11, 0x8B, 0x09, 0xCD, 0x56, 0xF6, + 0x49, 0x46, 0x29, 0xBF, 0x06, 0xF3, 0xD1, 0x4E, + 0xA5, 0xF9, 0x86, 0x0B, 0x83, 0x13, 0x2D, 0xDA, + 0x7A, 0xDE, 0x48, 0xD2, 0x37, 0xC2, 0xB9, 0xA6, + 0x6A, 0xFF, 0xE1, 0xB3, 0xC4, 0xE6, 0xF4, 0x37, + 0x21, 0x9F, 0xD7, 0x90, 0xE6, 0x9D, 0xD0, 0xD4 + }, + { + 0xD0, 0x01, 0xCB, 0x88, 0x1A, 0x60, 0x5E, 0xF1, + 0x77, 0x9A, 0x0B, 0x8B, 0xA5, 0xF0, 0xE6, 0x7A, + 0xF3, 0xA6, 0xE3, 0x62, 0xD8, 0x60, 0x7C, 0xE3, + 0xE4, 0x5A, 0x3C, 0x26, 0x7B, 0xD5, 0xFB, 0xC4, + 0x11, 0x7C, 0x28, 0xE7, 0x71, 0x25, 0x62, 0x74, + 0x78, 0x45, 0x5D, 0x35, 0x8B, 0xA9, 0x71, 0xFF, + 0xE4, 0x24, 0x62, 0xFB, 0xD9, 0xE2, 0xE7, 0xA0, + 0xD3, 0x7B, 0xA8, 0x79, 0x57, 0x7D, 0xC1, 0xE1 + }, + { + 0x55, 0x73, 0x5D, 0x74, 0x89, 0x4D, 0x4F, 0xA1, + 0x73, 0xC2, 0x7B, 0x36, 0x33, 0x15, 0xBB, 0x63, + 0x16, 0xC0, 0xCD, 0xF4, 0xEC, 0xD8, 0x6F, 0x93, + 0x85, 0xF7, 0x8A, 0xB2, 0x5F, 0x6A, 0x89, 0x45, + 0x7E, 0xDF, 0x30, 0x4B, 0xF9, 0xC9, 0xDB, 0x77, + 0x35, 0xA8, 0xB5, 0x9B, 0xD5, 0x19, 0xEF, 0xE5, + 0x92, 0xF9, 0xE3, 0xBA, 0xF3, 0x33, 0x91, 0x10, + 0x63, 0x42, 0x65, 0x77, 0x1B, 0xC5, 0xFA, 0x79 + }, + { + 0x2F, 0xCF, 0x7B, 0xEE, 0xEB, 0xED, 0x46, 0x23, + 0xEB, 0xF7, 0xA6, 0x78, 0xBF, 0x18, 0x90, 0x69, + 0x2D, 0x5B, 0xDE, 0x92, 0xB6, 0x06, 0x8D, 0x86, + 0xEF, 0xA4, 0x8D, 0x55, 0x90, 0xB3, 0xA3, 0x57, + 0xCB, 0x61, 0x4F, 0x19, 0x06, 0x6B, 0x4B, 0xEC, + 0x1B, 0x92, 0xC6, 0xE2, 0xC8, 0x18, 0x4A, 0x0E, + 0x11, 0xA3, 0x4D, 0x08, 0x69, 0xB4, 0x82, 0x58, + 0xB9, 0x4B, 0xD9, 0xBE, 0x21, 0x83, 0xFF, 0x0E + }, + { + 0xC0, 0xC4, 0x23, 0x78, 0xEC, 0xC4, 0x04, 0x83, + 0x9C, 0xAE, 0x43, 0xC2, 0x7D, 0x2D, 0xC9, 0xE7, + 0xE7, 0x3C, 0xF0, 0x45, 0x2B, 0x58, 0x8D, 0xCB, + 0xBE, 0xEF, 0x8F, 0x1F, 0x86, 0x98, 0xB9, 0x37, + 0x2B, 0x25, 0xDB, 0xE4, 0x93, 0xE1, 0x04, 0x9B, + 0x6A, 0x1D, 0x3A, 0x73, 0xA7, 0x7F, 0x26, 0x7A, + 0x21, 0xA1, 0x81, 0x45, 0x1D, 0xB6, 0x3A, 0x9B, + 0xF3, 0xBB, 0x71, 0xE6, 0xCD, 0x00, 0x78, 0x6D + }, + { + 0x47, 0x9F, 0x42, 0x85, 0xF7, 0x54, 0x97, 0xC9, + 0x9C, 0xBE, 0x59, 0x18, 0x4E, 0x0D, 0x55, 0x69, + 0xB0, 0x60, 0x04, 0x3E, 0x93, 0x6E, 0x4F, 0x55, + 0x85, 0x88, 0xBA, 0x38, 0x89, 0xFB, 0x77, 0xBC, + 0xE0, 0xF6, 0x18, 0xF5, 0x5D, 0xCB, 0x9C, 0xB8, + 0x72, 0xB9, 0x08, 0x2D, 0x89, 0x74, 0x42, 0x01, + 0xB2, 0xFF, 0x38, 0xAA, 0xA8, 0x0F, 0x70, 0x33, + 0x23, 0xE7, 0xE6, 0x04, 0xF1, 0x98, 0x5B, 0x05 + }, + { + 0x70, 0x76, 0x57, 0x76, 0xFC, 0x78, 0x1F, 0x9C, + 0x67, 0x79, 0xB6, 0x79, 0x9E, 0xCB, 0x27, 0x68, + 0x8F, 0x54, 0x0C, 0x8A, 0xC1, 0xB9, 0xD6, 0x82, + 0xED, 0xAB, 0x6A, 0xDA, 0x46, 0x3E, 0x2A, 0xB7, + 0xD1, 0x6A, 0x19, 0x08, 0xE3, 0x81, 0x30, 0x22, + 0xF2, 0xA9, 0xE2, 0xC1, 0xA1, 0xFF, 0x9D, 0xF4, + 0xD9, 0x10, 0x59, 0x0E, 0x40, 0xAD, 0x66, 0x1B, + 0x89, 0x7F, 0x54, 0x83, 0x67, 0xB3, 0x7A, 0xA6 + }, + { + 0xDB, 0xD0, 0xAD, 0x09, 0x44, 0x1A, 0xFA, 0x21, + 0xE6, 0xC2, 0x29, 0x70, 0x6E, 0xAA, 0x4F, 0xD5, + 0xA8, 0x53, 0xF4, 0x8D, 0x9D, 0xE1, 0x7A, 0xD7, + 0xEA, 0xC5, 0x7B, 0x92, 0xD2, 0xA7, 0x1A, 0x3B, + 0xE3, 0x36, 0xEB, 0xF6, 0xE6, 0x37, 0xB0, 0xAC, + 0x97, 0x13, 0xC2, 0x5D, 0xE8, 0xA8, 0x3D, 0x06, + 0x39, 0x22, 0x5A, 0xB3, 0xFC, 0xDB, 0xD6, 0x14, + 0x68, 0x28, 0x22, 0xC1, 0x2B, 0x06, 0x5D, 0xF0 + }, + { + 0xED, 0x0E, 0xF0, 0x58, 0x71, 0xA1, 0xAF, 0x74, + 0xFA, 0xEF, 0x1F, 0x51, 0xBA, 0xC8, 0xDF, 0x1E, + 0xC0, 0x4C, 0xEF, 0x16, 0x5B, 0x2C, 0x5E, 0x89, + 0x9D, 0xF2, 0x52, 0x59, 0xDC, 0xF6, 0xCD, 0xD3, + 0x04, 0xD9, 0x8D, 0x82, 0x19, 0xE0, 0x6B, 0xF8, + 0x37, 0x07, 0x0A, 0x1E, 0x85, 0xF5, 0x5B, 0xB3, + 0xE6, 0x79, 0xE2, 0xA0, 0x00, 0x41, 0x6D, 0x96, + 0xBA, 0x77, 0x75, 0x30, 0x82, 0x2C, 0x70, 0xBD + }, + { + 0x20, 0x56, 0x72, 0xCA, 0xB2, 0x7A, 0xB3, 0x7F, + 0xE2, 0xC6, 0x2E, 0x62, 0x9D, 0x4A, 0xA9, 0xEA, + 0xFB, 0xDD, 0x10, 0x76, 0x95, 0x2D, 0x47, 0x63, + 0xD6, 0x79, 0x2D, 0x42, 0x37, 0x13, 0xEE, 0xBC, + 0xD0, 0xCD, 0x19, 0x5B, 0xCC, 0x51, 0xF3, 0xD9, + 0x1E, 0xE1, 0x00, 0xB4, 0x8D, 0xD9, 0x59, 0xF7, + 0x4A, 0x3C, 0x5C, 0x83, 0xB0, 0x98, 0xD1, 0xC4, + 0x3F, 0xA5, 0x04, 0x62, 0x0B, 0x95, 0x92, 0xBA + }, + { + 0x82, 0xDD, 0x16, 0x1C, 0x1D, 0x64, 0x4F, 0x45, + 0x64, 0x3E, 0x20, 0xB7, 0x65, 0xB5, 0x40, 0xEC, + 0x75, 0x6E, 0xCD, 0xF6, 0x54, 0x30, 0x0B, 0xE8, + 0xCA, 0x15, 0x8E, 0xB7, 0xD0, 0x1F, 0x22, 0x10, + 0x56, 0x35, 0xD3, 0x57, 0x98, 0x4B, 0xE8, 0x5F, + 0x01, 0x0F, 0xEC, 0xE3, 0x7F, 0x38, 0x25, 0xB0, + 0xCE, 0x2C, 0x3D, 0x70, 0xB9, 0x61, 0xEC, 0xB1, + 0xBE, 0xCF, 0xE9, 0x6A, 0xFE, 0x35, 0x9F, 0x2A + }, + { + 0x73, 0xA8, 0x1B, 0x1B, 0x43, 0xC3, 0x8F, 0x32, + 0xCE, 0xAB, 0x46, 0x11, 0x25, 0x10, 0x8F, 0xC0, + 0x94, 0xFB, 0x11, 0xCB, 0x95, 0x70, 0xA5, 0x27, + 0xDA, 0xB5, 0x06, 0xAC, 0x84, 0x3A, 0x6B, 0x5D, + 0x6C, 0x2C, 0xA0, 0xBF, 0xB3, 0x5E, 0x97, 0xAF, + 0xD3, 0xC7, 0xBF, 0x56, 0x50, 0xDF, 0x59, 0x9E, + 0x90, 0x37, 0x15, 0x5E, 0xF2, 0x68, 0x22, 0x90, + 0x20, 0xCD, 0x2E, 0x68, 0x49, 0x1A, 0x9D, 0x8E + }, + { + 0x05, 0x0D, 0x1C, 0x6B, 0x34, 0xD2, 0x91, 0x74, + 0x2B, 0x62, 0x20, 0x6C, 0xEF, 0x63, 0x0E, 0xB1, + 0x9F, 0x8B, 0x3B, 0xDE, 0xB4, 0x00, 0xCE, 0x56, + 0xFE, 0xCF, 0x8C, 0xD0, 0x00, 0x6E, 0x26, 0x72, + 0x7D, 0x19, 0xD0, 0xCC, 0xD7, 0x2F, 0xBA, 0x0C, + 0x15, 0x3C, 0x38, 0x67, 0x48, 0x66, 0xF3, 0x0C, + 0x12, 0x26, 0x3F, 0x4A, 0x96, 0x08, 0x36, 0xFE, + 0xC4, 0x09, 0xAE, 0x6F, 0x8E, 0xB9, 0xC9, 0xEE + }, + { + 0x13, 0x1D, 0xEB, 0xC7, 0x8E, 0x41, 0xDD, 0x18, + 0x8F, 0x2F, 0x19, 0xA6, 0x05, 0x29, 0xDF, 0xBA, + 0x36, 0x42, 0xE2, 0xED, 0x0E, 0xFB, 0x9A, 0x75, + 0x48, 0xEF, 0xB0, 0x51, 0xB1, 0xC2, 0x40, 0xE0, + 0x9F, 0xB5, 0xBF, 0x5C, 0x6D, 0x75, 0x08, 0xF5, + 0xD0, 0x53, 0x95, 0x2C, 0xF7, 0x68, 0x67, 0x18, + 0xB3, 0xD8, 0x9A, 0xFB, 0xC0, 0xC4, 0x48, 0x3D, + 0x56, 0x0E, 0x2E, 0xF9, 0x75, 0xD0, 0xAA, 0x1B + }, + { + 0x71, 0x5B, 0x21, 0x6B, 0x0F, 0x2C, 0x5D, 0xED, + 0xF6, 0x03, 0xF7, 0x22, 0xD5, 0x3C, 0x3A, 0x5E, + 0xED, 0x3A, 0xFB, 0xD3, 0xE6, 0xD6, 0x6B, 0x3F, + 0x0C, 0x9D, 0xFB, 0x19, 0x19, 0x86, 0x49, 0x1B, + 0x96, 0xCE, 0xE9, 0x73, 0xA2, 0x71, 0xC4, 0x77, + 0x17, 0x47, 0xD7, 0xA4, 0x3C, 0x94, 0x4A, 0xC2, + 0xAD, 0x35, 0x59, 0x18, 0xBA, 0xA9, 0x30, 0x44, + 0xD2, 0x11, 0x53, 0x35, 0xCD, 0x7F, 0xC5, 0x2C + }, + { + 0x24, 0x8E, 0x79, 0x35, 0x29, 0x2C, 0x78, 0x2B, + 0x53, 0xD2, 0x47, 0x36, 0x15, 0x6C, 0x0D, 0xAB, + 0x64, 0x96, 0x17, 0xCF, 0x9F, 0xA9, 0x8C, 0x2F, + 0x7B, 0x57, 0x22, 0x94, 0xC5, 0x32, 0x89, 0x4E, + 0x14, 0x6E, 0x50, 0x13, 0x57, 0x04, 0xB5, 0x5C, + 0x29, 0xFD, 0xF8, 0xEA, 0xA1, 0x91, 0x0A, 0xFC, + 0x74, 0xC1, 0xFD, 0x74, 0xAA, 0x6B, 0x8F, 0xF3, + 0x15, 0x71, 0xF0, 0x70, 0x3F, 0x5A, 0x6A, 0xE2 + }, + { + 0x21, 0xFF, 0xDD, 0xAE, 0xAE, 0xB7, 0x1C, 0x75, + 0x00, 0x5F, 0xA2, 0x7D, 0x3A, 0x11, 0xCE, 0x7D, + 0x03, 0x57, 0x85, 0xA4, 0x8D, 0xB3, 0x43, 0xF2, + 0x17, 0x44, 0xCD, 0x29, 0xA9, 0x0F, 0x96, 0xC8, + 0x71, 0x24, 0x84, 0x67, 0xD1, 0x41, 0xAD, 0xCA, + 0x06, 0xEC, 0x03, 0x08, 0xF6, 0xF8, 0xC7, 0x78, + 0xA5, 0xFC, 0xCF, 0x75, 0x86, 0x11, 0x1A, 0x2B, + 0x40, 0xE0, 0xDA, 0x2C, 0xAB, 0x66, 0x8F, 0xC9 + }, + { + 0xA6, 0xC1, 0xAB, 0xFB, 0x5E, 0x93, 0x67, 0xE8, + 0xC9, 0x9C, 0x4D, 0x47, 0x2F, 0x74, 0xAD, 0x25, + 0x81, 0x96, 0x9D, 0x00, 0x59, 0x0C, 0x49, 0xE6, + 0xF7, 0x3E, 0xE7, 0x5F, 0x7B, 0x93, 0x85, 0x9D, + 0x63, 0xBA, 0x8E, 0x30, 0x81, 0x7B, 0x10, 0x78, + 0x95, 0xB9, 0xC4, 0x67, 0xFA, 0x50, 0xC0, 0xFF, + 0xDF, 0x9D, 0xC8, 0xB1, 0x41, 0x1B, 0x6C, 0x24, + 0x90, 0x3F, 0xCD, 0x56, 0xB3, 0xAD, 0xAA, 0x65 + }, + { + 0xCC, 0x85, 0x93, 0x67, 0xAA, 0x38, 0xE2, 0x33, + 0x54, 0x6D, 0xCD, 0xC4, 0x38, 0x6F, 0xE6, 0x97, + 0xA0, 0x15, 0x4E, 0x5A, 0x12, 0xA6, 0x0C, 0x8C, + 0x4C, 0x38, 0xB1, 0x81, 0xEC, 0x0E, 0x48, 0x6A, + 0xF8, 0xD2, 0xA7, 0x97, 0xE2, 0x21, 0xE9, 0xE9, + 0x49, 0xC1, 0xBA, 0x5F, 0x3B, 0x40, 0x44, 0x69, + 0x25, 0xB8, 0x7D, 0xB8, 0xDB, 0x83, 0xCF, 0xB1, + 0x87, 0xCA, 0x1D, 0x7F, 0x2F, 0x82, 0xE1, 0x0A + }, + { + 0x6C, 0xEE, 0x13, 0xD4, 0x77, 0x72, 0x18, 0x70, + 0x3B, 0xC9, 0x76, 0xF5, 0x8A, 0x78, 0x6A, 0xFE, + 0xC7, 0x43, 0x75, 0xAE, 0xA5, 0x97, 0x68, 0x66, + 0xA7, 0x35, 0x59, 0x44, 0x47, 0xE5, 0x56, 0xE3, + 0x42, 0x76, 0x35, 0x03, 0x96, 0xC2, 0x2A, 0xBE, + 0x3C, 0xF8, 0xF5, 0xBC, 0x47, 0x95, 0x00, 0xBA, + 0xFF, 0x94, 0x45, 0xF9, 0xD3, 0x4D, 0xCA, 0xC6, + 0xA1, 0x58, 0x80, 0xFE, 0xF0, 0x19, 0x1A, 0x70 + }, + { + 0x0C, 0xBD, 0xE5, 0x52, 0x46, 0x0A, 0x43, 0x4E, + 0x5C, 0xAF, 0xC3, 0x7B, 0xE9, 0x95, 0xFF, 0xE7, + 0xBC, 0x45, 0xF2, 0x71, 0xC2, 0x52, 0x1F, 0xF7, + 0x28, 0xA6, 0x4B, 0xB1, 0x53, 0xD0, 0x26, 0x35, + 0x7A, 0x30, 0xDA, 0x1A, 0x6F, 0xF8, 0xEE, 0xEF, + 0xA2, 0xEA, 0x11, 0x78, 0x8F, 0xDB, 0xB8, 0xE4, + 0x3F, 0x34, 0x03, 0x9E, 0x44, 0xD3, 0x2F, 0x94, + 0xE9, 0x8D, 0x60, 0xEE, 0xD1, 0x75, 0xA8, 0x63 + }, + { + 0xA4, 0x4F, 0x48, 0x78, 0x42, 0x0A, 0xDB, 0x6D, + 0x7E, 0x43, 0x93, 0x86, 0x58, 0x0C, 0x1B, 0xD3, + 0x79, 0x97, 0x63, 0xFE, 0x3E, 0x6C, 0x32, 0x10, + 0x24, 0xDD, 0x04, 0x2C, 0x5C, 0xF8, 0xA1, 0x27, + 0xA8, 0xCC, 0xD2, 0xAC, 0x5B, 0x72, 0xBF, 0xF2, + 0x4E, 0x59, 0xB0, 0x95, 0x73, 0x2B, 0x28, 0x80, + 0xFB, 0x0D, 0x38, 0xF9, 0xF3, 0xF2, 0x5F, 0xA2, + 0x5D, 0xFD, 0x3E, 0xE0, 0x9A, 0x52, 0x0A, 0xFA + }, + { + 0xD0, 0x22, 0x3E, 0x21, 0x43, 0x5E, 0xA1, 0x6A, + 0xC5, 0x2B, 0x1A, 0xED, 0xE0, 0xC8, 0x4C, 0x2F, + 0x95, 0xDC, 0xB0, 0xBE, 0xCF, 0xB4, 0xA8, 0xE9, + 0x13, 0x28, 0xEB, 0xFC, 0x08, 0x81, 0x10, 0x2E, + 0x67, 0xDB, 0xDE, 0x3F, 0x82, 0x50, 0x09, 0x71, + 0xFB, 0x51, 0xFE, 0xA4, 0x7A, 0x60, 0xC7, 0x7F, + 0xB4, 0x00, 0x70, 0x67, 0x7A, 0x81, 0xCD, 0xCD, + 0x50, 0x14, 0xBD, 0x01, 0xD7, 0xDD, 0xC6, 0xBF + }, + { + 0x9E, 0x0D, 0x07, 0xB4, 0x98, 0x97, 0x90, 0x17, + 0xE9, 0xF5, 0x5B, 0x8D, 0x89, 0x4E, 0x90, 0x0E, + 0xCE, 0xAC, 0x3B, 0x40, 0xBB, 0x2D, 0x02, 0x5C, + 0x4A, 0x8A, 0x15, 0x8B, 0xCE, 0xBE, 0x1E, 0xBB, + 0xF5, 0xE8, 0x72, 0xF7, 0x69, 0x0D, 0x2D, 0xE5, + 0x45, 0xA7, 0x0A, 0xF9, 0x86, 0x64, 0x03, 0x76, + 0x06, 0x3E, 0x55, 0xE9, 0x11, 0x54, 0x30, 0x12, + 0x32, 0x5C, 0xB9, 0x3C, 0x8C, 0xE3, 0xAC, 0x06 + }, + { + 0x8C, 0x4B, 0x30, 0xDA, 0x5D, 0xC4, 0x42, 0xAD, + 0x63, 0x8A, 0xE3, 0x6E, 0x9C, 0xF5, 0xAB, 0x30, + 0xA1, 0x8D, 0x44, 0xF2, 0x99, 0x79, 0x40, 0x11, + 0x11, 0x04, 0x3A, 0x55, 0xE6, 0x3E, 0x13, 0xBF, + 0x0F, 0x6E, 0x03, 0xFB, 0x94, 0xCC, 0xA1, 0xDD, + 0x2E, 0xAD, 0xF5, 0xC8, 0xBF, 0xBF, 0xC7, 0xB5, + 0x7A, 0x96, 0x9F, 0x06, 0x06, 0x55, 0x1F, 0x7D, + 0x76, 0x7D, 0xAD, 0x98, 0x93, 0x69, 0xA3, 0xAC + }, + { + 0x60, 0xFF, 0xD1, 0x40, 0x9F, 0x58, 0x96, 0x97, + 0xEE, 0x54, 0x5E, 0x58, 0xEE, 0x12, 0xD4, 0x81, + 0x95, 0x08, 0x75, 0xAE, 0x65, 0xCD, 0x43, 0x6D, + 0xB7, 0x62, 0x0E, 0x46, 0x28, 0xDE, 0xF9, 0xA3, + 0xD8, 0x64, 0x7E, 0x1C, 0xA1, 0xF5, 0xD6, 0x43, + 0x04, 0x65, 0xB5, 0xF4, 0xA8, 0xF9, 0x09, 0x87, + 0xFA, 0xC0, 0x40, 0x12, 0x43, 0x9E, 0x0D, 0x74, + 0x2D, 0xBA, 0x25, 0x70, 0x2F, 0x5C, 0xF7, 0xEE + }, + { + 0xF4, 0xA4, 0x5D, 0x36, 0x86, 0x74, 0xCD, 0x39, + 0x26, 0x4B, 0x55, 0xA7, 0xC7, 0x8E, 0xB2, 0x55, + 0x40, 0x01, 0x46, 0x91, 0x3B, 0xE0, 0xFE, 0x1C, + 0x61, 0x2C, 0x78, 0x04, 0xB2, 0xC1, 0x3A, 0x9A, + 0x99, 0xEF, 0xE9, 0x75, 0xCD, 0x78, 0x56, 0x0B, + 0x7A, 0xFA, 0x4F, 0xE4, 0xF6, 0x8F, 0x78, 0x7A, + 0xEE, 0xDA, 0xEA, 0xBD, 0xA6, 0xF4, 0xAF, 0xE8, + 0xDF, 0x64, 0xB1, 0xDF, 0x1D, 0xC9, 0xC7, 0x06 + }, + { + 0x6A, 0x73, 0xC6, 0xFA, 0xE7, 0x8B, 0xED, 0xBC, + 0xD2, 0x55, 0xFA, 0xC8, 0x86, 0xEA, 0xF4, 0xE7, + 0x19, 0xAE, 0x41, 0xC6, 0x0D, 0x82, 0x42, 0x99, + 0xF7, 0x98, 0xF1, 0x0E, 0x59, 0x58, 0x14, 0x48, + 0xBA, 0x03, 0xAE, 0x50, 0x5C, 0x48, 0x4E, 0x75, + 0xC6, 0x9C, 0x3C, 0x14, 0x6C, 0x79, 0x7F, 0x32, + 0xA0, 0xC9, 0x79, 0xB4, 0x50, 0xD8, 0x2D, 0x91, + 0x5D, 0xBB, 0x09, 0x69, 0xEF, 0x5F, 0xAD, 0xD8 + }, + { + 0x1C, 0x86, 0x41, 0x77, 0xCB, 0x7E, 0xC2, 0xDD, + 0x1B, 0x08, 0xE7, 0x1F, 0xD6, 0x09, 0x5E, 0xD6, + 0xFE, 0x65, 0x43, 0xFD, 0xFF, 0xB6, 0x3E, 0xAD, + 0xE8, 0x19, 0xFB, 0x85, 0x45, 0x69, 0x5E, 0x85, + 0xDE, 0x40, 0xF0, 0x60, 0xBB, 0x25, 0x2C, 0x5B, + 0x9E, 0x6F, 0xA8, 0xEC, 0x76, 0xEA, 0x5B, 0xE2, + 0x91, 0xC9, 0x0B, 0x65, 0xEF, 0x83, 0xCA, 0x09, + 0x77, 0x09, 0x51, 0x0C, 0xC4, 0x9B, 0xAA, 0x07 + }, + { + 0xC9, 0x50, 0x93, 0x18, 0xAB, 0x18, 0xE2, 0x80, + 0xEE, 0x67, 0x2E, 0x98, 0x60, 0x4F, 0x89, 0xC1, + 0x19, 0x5F, 0xB3, 0x2C, 0x38, 0xC6, 0x30, 0xB9, + 0x65, 0x55, 0x56, 0x44, 0x11, 0x36, 0xB7, 0x35, + 0x77, 0x09, 0x05, 0xBC, 0x91, 0xBC, 0xC9, 0xBF, + 0xDC, 0x02, 0xBC, 0x7A, 0xC7, 0xA8, 0xC8, 0xF5, + 0x21, 0x6F, 0x52, 0x4B, 0xBA, 0xEF, 0x05, 0x9A, + 0xDD, 0x71, 0x37, 0x05, 0x87, 0xA4, 0xF4, 0x3A + }, + { + 0x98, 0x3B, 0xA6, 0xCB, 0x3C, 0xE9, 0x00, 0x30, + 0xB8, 0x71, 0x10, 0x95, 0x83, 0x2A, 0x1D, 0x26, + 0x04, 0xE0, 0x8C, 0x66, 0xCD, 0x30, 0xB2, 0x2F, + 0xE6, 0x60, 0xA9, 0xBE, 0x78, 0x3C, 0xD6, 0x0F, + 0xFC, 0x06, 0x99, 0xBE, 0xE8, 0x00, 0x98, 0xCC, + 0x04, 0x9F, 0x07, 0x64, 0xD3, 0xCD, 0x6A, 0x2A, + 0xB5, 0x3D, 0x23, 0x90, 0xFB, 0x16, 0xB0, 0x30, + 0x1B, 0x2E, 0x9D, 0x00, 0x62, 0xAD, 0x1B, 0x6C + }, + { + 0x2B, 0x81, 0x8E, 0x64, 0x8D, 0x18, 0x47, 0xF6, + 0x9D, 0x5A, 0xE6, 0x1B, 0xC1, 0x5F, 0xBD, 0xDA, + 0x8A, 0x69, 0x43, 0xE5, 0xCF, 0xE5, 0x07, 0x37, + 0x50, 0x9A, 0x98, 0x33, 0xA8, 0x59, 0x70, 0x8B, + 0x40, 0x17, 0x5D, 0x2B, 0xA6, 0x0B, 0x57, 0x01, + 0xE3, 0x36, 0x12, 0xB4, 0x49, 0xF2, 0x45, 0xB1, + 0xDE, 0x5B, 0x49, 0x6F, 0x02, 0xF8, 0xE0, 0xF3, + 0x9D, 0xA7, 0xA4, 0x1A, 0x59, 0x13, 0x64, 0xE5 + }, + { + 0xBE, 0xEE, 0x79, 0x15, 0x02, 0xCE, 0x24, 0xFF, + 0x03, 0x34, 0xE6, 0xF6, 0x56, 0x3D, 0x4E, 0x0D, + 0x19, 0x8E, 0x92, 0xF4, 0x6A, 0x48, 0xF1, 0x6B, + 0xFC, 0x4D, 0xB7, 0xB8, 0x26, 0xF3, 0x86, 0x70, + 0xB9, 0x21, 0x6F, 0xF0, 0x65, 0x52, 0xB6, 0x52, + 0x16, 0x03, 0xAC, 0x23, 0x91, 0xB7, 0x01, 0xD5, + 0xF5, 0x68, 0x6F, 0x46, 0x25, 0x3C, 0xAA, 0xB4, + 0xFE, 0xE4, 0x1F, 0xD7, 0x91, 0x02, 0x13, 0x50 + }, + { + 0x4B, 0x8D, 0x9D, 0xAD, 0x66, 0xB6, 0x3E, 0x1B, + 0xFD, 0x8B, 0x32, 0xD1, 0x8E, 0x6A, 0x2F, 0x93, + 0xF2, 0x49, 0x4A, 0x70, 0xE5, 0x10, 0x4D, 0xDE, + 0x62, 0xD1, 0xC7, 0xE0, 0xF2, 0x40, 0x8A, 0x19, + 0x2D, 0x7F, 0x15, 0x3E, 0x10, 0x5E, 0xC4, 0x4A, + 0x79, 0x19, 0x2F, 0xC9, 0x50, 0x76, 0x42, 0xF5, + 0x95, 0x29, 0x26, 0x58, 0x9C, 0x5E, 0x64, 0x8A, + 0xA8, 0x24, 0x7C, 0xE1, 0xD3, 0x74, 0xFF, 0x46 + }, + { + 0x8D, 0x9E, 0x34, 0xA7, 0x1D, 0x12, 0x17, 0x4B, + 0x3E, 0x92, 0xCD, 0xC4, 0xAF, 0xB5, 0xB3, 0x32, + 0x20, 0x9B, 0xEB, 0xC7, 0xA2, 0xD0, 0x23, 0x73, + 0x67, 0x31, 0x07, 0xC3, 0x63, 0xA4, 0x9D, 0x3D, + 0xB8, 0xF4, 0x11, 0x7A, 0xF5, 0x1E, 0x1F, 0x8E, + 0xCC, 0xF3, 0x91, 0x56, 0x92, 0xD0, 0x80, 0x56, + 0xEB, 0x05, 0x4F, 0x72, 0x83, 0x87, 0x2E, 0x95, + 0xBF, 0xA3, 0x05, 0xB9, 0x03, 0x91, 0x28, 0x68 + }, + { + 0xA6, 0xC2, 0x4A, 0x23, 0xBB, 0x19, 0x78, 0xC5, + 0x8F, 0x1F, 0xEF, 0x81, 0x00, 0xC6, 0x84, 0xF2, + 0xCC, 0xF8, 0xBC, 0x36, 0x6A, 0xE4, 0xE9, 0x74, + 0x05, 0x33, 0x5B, 0xDE, 0xA0, 0x2C, 0xA6, 0xD0, + 0x94, 0xF8, 0xA1, 0x1E, 0x20, 0x7F, 0xA1, 0xE3, + 0x5D, 0x3C, 0x3D, 0x58, 0x12, 0x40, 0xC5, 0x1B, + 0x6D, 0x3E, 0xAA, 0xAA, 0x6A, 0xCC, 0x5A, 0x3A, + 0xDD, 0xB8, 0xE6, 0x1C, 0x87, 0x78, 0xDC, 0x4C + }, + { + 0x94, 0x91, 0x62, 0x12, 0x2D, 0x31, 0xB1, 0x46, + 0x68, 0xF5, 0x3F, 0x5B, 0xE8, 0x7F, 0x9C, 0x00, + 0xC9, 0x35, 0x6E, 0x96, 0xDB, 0x79, 0x1A, 0xFF, + 0x2F, 0xD0, 0xF0, 0x71, 0x7E, 0xFD, 0x0B, 0x70, + 0x4E, 0xE1, 0xC6, 0xE5, 0x30, 0xAD, 0xA3, 0x17, + 0xC9, 0x72, 0x5F, 0x54, 0x0A, 0x01, 0x3E, 0x4F, + 0x7A, 0x27, 0x35, 0x04, 0xE6, 0x4A, 0xE2, 0x6E, + 0x1C, 0xD4, 0x75, 0x82, 0x1E, 0xA0, 0x49, 0x15 + }, + { + 0x62, 0xEF, 0xD8, 0x9E, 0x0F, 0x39, 0x3D, 0x55, + 0x6A, 0xEE, 0xDD, 0x09, 0xCC, 0x9E, 0x34, 0x79, + 0x60, 0xE8, 0xDB, 0xBC, 0xC2, 0x43, 0xE8, 0x93, + 0x72, 0x20, 0x47, 0xB5, 0xE7, 0x34, 0xA7, 0x80, + 0xC9, 0x76, 0x4E, 0xFC, 0xF3, 0x2F, 0x1B, 0xD7, + 0xDE, 0xB8, 0xFC, 0xBA, 0xBA, 0x98, 0x07, 0x43, + 0xFC, 0xFB, 0xC3, 0x88, 0xD8, 0xF7, 0x24, 0x4D, + 0xD1, 0x98, 0x97, 0xBA, 0x3E, 0x37, 0x00, 0x12 + }, + { + 0x72, 0xBA, 0x60, 0x7F, 0x77, 0xF5, 0xB3, 0xB9, + 0x3A, 0xDE, 0x3F, 0x9B, 0x88, 0xD8, 0xA9, 0x89, + 0x37, 0xA9, 0xC1, 0xF1, 0x5B, 0xA8, 0x47, 0x18, + 0x4C, 0x49, 0x8D, 0xA9, 0xFE, 0x57, 0x95, 0x55, + 0xB6, 0x66, 0x4B, 0x89, 0x2A, 0xD3, 0x56, 0x98, + 0xED, 0x4B, 0x3A, 0xEF, 0xE4, 0xDE, 0x79, 0x49, + 0x00, 0x38, 0x87, 0x8E, 0x4F, 0x1B, 0x3A, 0x14, + 0x98, 0x1D, 0x9F, 0xB8, 0x15, 0x8D, 0x4D, 0xAA + }, + { + 0x8A, 0xBB, 0xEA, 0x37, 0x27, 0x79, 0x9F, 0x46, + 0x2F, 0x2E, 0x3B, 0xC2, 0x28, 0x5C, 0xBF, 0xC8, + 0xC3, 0xA9, 0xD0, 0xAD, 0x7F, 0xCB, 0x29, 0x16, + 0x47, 0xE6, 0x83, 0x45, 0x45, 0x9C, 0x9F, 0xC9, + 0xCB, 0xEC, 0x07, 0x31, 0x92, 0x9E, 0xA2, 0x3C, + 0xEF, 0x66, 0x40, 0xDB, 0x67, 0x40, 0x72, 0xC6, + 0xC3, 0x44, 0xB6, 0xCD, 0x0A, 0x24, 0xE9, 0x31, + 0xEA, 0x94, 0xE0, 0x19, 0x89, 0x22, 0x6E, 0x45 + }, + { + 0xAB, 0xFF, 0x2B, 0x2D, 0xA4, 0x5F, 0x22, 0xE6, + 0xD7, 0x22, 0x98, 0x0F, 0xB3, 0xB2, 0xF1, 0xA3, + 0xEE, 0x85, 0x00, 0xDA, 0x31, 0x4D, 0xE0, 0xD3, + 0xD4, 0x02, 0xFF, 0x0C, 0x97, 0x11, 0x46, 0x00, + 0x52, 0xE5, 0x40, 0x2A, 0x1E, 0x7B, 0x95, 0x4B, + 0x7E, 0x2F, 0xFB, 0xC5, 0x28, 0x0D, 0xFA, 0x3F, + 0xF6, 0xDD, 0x75, 0x9F, 0x78, 0x31, 0xEF, 0xA2, + 0xE1, 0xCA, 0xEA, 0xAE, 0x1C, 0x0E, 0x96, 0x61 + }, + { + 0xEC, 0xAB, 0x63, 0xB6, 0xDA, 0xA5, 0xD0, 0x18, + 0x50, 0xFE, 0xFD, 0xBE, 0xC6, 0x33, 0xEF, 0xA0, + 0xED, 0x09, 0x9B, 0xE3, 0x9C, 0x38, 0x5B, 0x80, + 0x51, 0xD4, 0x85, 0x7B, 0xA4, 0x37, 0xB6, 0x3A, + 0x22, 0xAC, 0x66, 0x1B, 0x20, 0x84, 0xAF, 0x04, + 0xD6, 0x1D, 0x82, 0x28, 0x93, 0xA1, 0xDD, 0x35, + 0xDF, 0xA0, 0xCA, 0xFD, 0xF8, 0x5B, 0x2B, 0xFE, + 0x29, 0xF6, 0xEF, 0xCB, 0xFB, 0x17, 0xDF, 0xBC + }, + { + 0x0B, 0x71, 0x91, 0x0A, 0x63, 0x04, 0xA9, 0x7A, + 0xF1, 0x28, 0x88, 0x5D, 0x9C, 0xD0, 0x02, 0xD0, + 0x30, 0x4B, 0x5D, 0x5D, 0x02, 0xA4, 0x5E, 0x67, + 0xC4, 0x9D, 0xE1, 0xF1, 0xB0, 0x41, 0x59, 0xE7, + 0xFB, 0xA5, 0x9A, 0x39, 0xBE, 0xE8, 0x9B, 0xE3, + 0x77, 0xCE, 0xE9, 0xD0, 0xF5, 0x9F, 0x19, 0x81, + 0x32, 0xCA, 0x99, 0xA5, 0x9E, 0x77, 0x80, 0x2E, + 0x89, 0x2A, 0x75, 0xD5, 0xB2, 0x96, 0xDB, 0xD5 + }, + { + 0xC4, 0xDB, 0xCD, 0x58, 0x96, 0x92, 0x91, 0x7D, + 0xA0, 0x9F, 0x9F, 0xA1, 0x5D, 0x79, 0xC2, 0x9F, + 0x79, 0xD0, 0x9C, 0xDD, 0x79, 0xA2, 0x14, 0xE8, + 0x5D, 0xAB, 0x43, 0x0E, 0xF3, 0xA1, 0x11, 0xC3, + 0x09, 0xB6, 0x00, 0x84, 0x55, 0xE2, 0xC3, 0x68, + 0x37, 0x63, 0xD7, 0xB9, 0x9D, 0x91, 0x24, 0xF5, + 0xDC, 0x07, 0xE0, 0x63, 0xDD, 0xF1, 0x23, 0x38, + 0x50, 0xED, 0xF2, 0x62, 0xA0, 0x5D, 0x65, 0x54 + }, + { + 0x2D, 0xAE, 0xD6, 0xD7, 0x8C, 0x99, 0x80, 0xF4, + 0x24, 0x53, 0x0B, 0xDC, 0xBC, 0x81, 0x75, 0xB9, + 0xD9, 0x60, 0xB5, 0xE8, 0x5C, 0x21, 0xBE, 0xA2, + 0x73, 0x1F, 0x8E, 0x82, 0xDE, 0xAA, 0xC4, 0x7E, + 0x67, 0xAD, 0x47, 0x8A, 0xFC, 0x62, 0x4E, 0x60, + 0xE4, 0xE9, 0x9B, 0xC8, 0x11, 0xFA, 0x8A, 0xAB, + 0x84, 0x12, 0xCF, 0x81, 0xA0, 0x64, 0xDD, 0x7E, + 0xD6, 0xC1, 0x0B, 0xCA, 0xD4, 0x1C, 0xE7, 0x92 + }, + { + 0xB1, 0x94, 0x6F, 0xB9, 0xDE, 0x29, 0x9B, 0x9D, + 0xAE, 0x64, 0x8B, 0x64, 0x57, 0x1F, 0x89, 0xA6, + 0x33, 0x9E, 0xB9, 0x2E, 0xE6, 0x1D, 0x96, 0x4F, + 0x0A, 0xBA, 0xD3, 0x10, 0xF5, 0xEB, 0x26, 0x1B, + 0x23, 0x74, 0x93, 0x54, 0xBC, 0xE3, 0xA7, 0xFB, + 0x18, 0x55, 0x38, 0xE5, 0x77, 0xB2, 0x4D, 0x63, + 0x7E, 0x5C, 0x61, 0xA1, 0x1C, 0xB0, 0xC4, 0xCE, + 0xF2, 0xDF, 0x82, 0x2E, 0x38, 0x74, 0x78, 0x79 + }, + { + 0xF8, 0xC6, 0x72, 0x51, 0x64, 0xE8, 0xFC, 0xCA, + 0x7F, 0xA9, 0xBA, 0xDB, 0x1E, 0x5F, 0x34, 0xA2, + 0x50, 0x95, 0x92, 0x07, 0x92, 0x75, 0xD4, 0x00, + 0x88, 0xB9, 0x1B, 0x38, 0x90, 0xDD, 0xA0, 0x2F, + 0xE7, 0xAC, 0xA6, 0x43, 0x8E, 0x9A, 0x5A, 0x9B, + 0x5C, 0x2B, 0xE3, 0xC0, 0x0A, 0xF0, 0xA6, 0xD1, + 0x06, 0x8F, 0xDD, 0xFF, 0x4E, 0x04, 0x5F, 0xA2, + 0x93, 0x1D, 0x39, 0xC5, 0x14, 0xCE, 0x24, 0xA5 + }, + { + 0x61, 0x7F, 0xD9, 0x94, 0x21, 0xA2, 0x17, 0x90, + 0x05, 0x0C, 0x71, 0x5A, 0x01, 0xC2, 0xCC, 0xCE, + 0xB3, 0x66, 0x76, 0x82, 0x8C, 0xFD, 0xBB, 0x6D, + 0xC0, 0x23, 0x14, 0x2B, 0xD1, 0xA0, 0x64, 0x77, + 0xD0, 0x14, 0x62, 0xFE, 0x07, 0xB2, 0xB9, 0xF1, + 0x8F, 0x48, 0xFF, 0x60, 0xB8, 0x49, 0xF9, 0xFF, + 0xDF, 0x2F, 0xC5, 0xC1, 0x1A, 0xE4, 0x1D, 0x94, + 0xE8, 0x88, 0x30, 0x94, 0x30, 0x43, 0x10, 0x08 + }, + { + 0x3A, 0x88, 0x50, 0x01, 0x40, 0x4E, 0x91, 0x0C, + 0x4A, 0xA8, 0x99, 0x50, 0xBD, 0xEB, 0xE9, 0xDC, + 0x0C, 0xA8, 0xC7, 0xF5, 0xC6, 0x3C, 0x05, 0x54, + 0xF1, 0xCD, 0x60, 0x87, 0xAA, 0x89, 0xA8, 0x2C, + 0xE0, 0x40, 0xF8, 0xED, 0x1C, 0x73, 0x39, 0x80, + 0xD4, 0x77, 0xC5, 0x88, 0xF3, 0x02, 0x52, 0x43, + 0x90, 0xD6, 0x16, 0xC2, 0x01, 0xF5, 0x23, 0xCA, + 0xF3, 0x46, 0x16, 0xEC, 0xA7, 0x30, 0x31, 0x76 + }, + { + 0x85, 0xCC, 0xA4, 0x9D, 0x6F, 0xAF, 0xEA, 0x6E, + 0x84, 0xE8, 0x3D, 0x52, 0xC3, 0xB1, 0xA0, 0x78, + 0xDE, 0xA9, 0x12, 0x34, 0x7F, 0x77, 0x47, 0x22, + 0xA4, 0x78, 0x04, 0xF4, 0x00, 0x78, 0x5A, 0xB6, + 0xC1, 0xEF, 0x5A, 0x40, 0x2E, 0xAA, 0x67, 0xD9, + 0xDD, 0xAB, 0xEC, 0xB7, 0x0C, 0x18, 0xDC, 0xFB, + 0x1B, 0x44, 0xAA, 0x79, 0xA2, 0x7E, 0x74, 0x40, + 0x4A, 0xF6, 0xAE, 0x89, 0x85, 0x8C, 0xC9, 0xF6 + }, + { + 0xD0, 0xC6, 0xC3, 0x0D, 0x55, 0xFF, 0x0B, 0xCE, + 0x4D, 0x06, 0x16, 0xA6, 0xEA, 0x8D, 0x44, 0x1E, + 0x4F, 0xA0, 0xC8, 0xA8, 0xCD, 0x2D, 0xED, 0x44, + 0x80, 0xF8, 0x4B, 0x17, 0xCC, 0xC7, 0x86, 0xDB, + 0x09, 0xB4, 0x2C, 0x0E, 0x3D, 0x35, 0xAA, 0x47, + 0xFC, 0xBD, 0xA9, 0xF3, 0xB1, 0x2B, 0x34, 0x21, + 0xA5, 0x25, 0x46, 0x73, 0x16, 0x8C, 0x38, 0x34, + 0x70, 0xAC, 0x0D, 0xC6, 0x5D, 0xA9, 0xB5, 0x9D + }, + { + 0x1C, 0xDC, 0x27, 0xA3, 0xB6, 0x0C, 0x93, 0x48, + 0x00, 0x3B, 0xE1, 0x14, 0xA7, 0xC0, 0x8C, 0xCD, + 0x58, 0x4F, 0x33, 0x38, 0x43, 0x62, 0x37, 0x86, + 0x1B, 0xAB, 0x85, 0x80, 0x79, 0x22, 0xDA, 0x0B, + 0x3F, 0x9C, 0xE6, 0x91, 0xE5, 0x81, 0x78, 0xF2, + 0x60, 0x71, 0xD2, 0xAC, 0xC1, 0x37, 0x3C, 0xA4, + 0x91, 0x31, 0x97, 0x0C, 0xA9, 0xBB, 0x70, 0xD7, + 0x39, 0xA3, 0x25, 0x99, 0x65, 0xE7, 0x40, 0x21 + }, + { + 0xA7, 0x42, 0xDD, 0x3B, 0x04, 0x36, 0xFE, 0xC7, + 0xA1, 0x12, 0x65, 0x22, 0xB1, 0xCF, 0x8F, 0xBC, + 0xEE, 0x37, 0xBA, 0xCD, 0x6D, 0x86, 0x80, 0xD1, + 0x60, 0x8A, 0x7D, 0x6A, 0x49, 0xE3, 0xAF, 0xDA, + 0x00, 0xE2, 0xC1, 0x16, 0x09, 0x80, 0x6C, 0xBB, + 0x09, 0xEE, 0xB4, 0x14, 0xD1, 0xB5, 0xCA, 0x6A, + 0xFD, 0x75, 0x9B, 0x87, 0x74, 0xDE, 0x19, 0x34, + 0x26, 0x4F, 0x6B, 0x59, 0xDC, 0x6F, 0x01, 0x37 + }, + { + 0xF0, 0xC1, 0xF3, 0x5B, 0x02, 0xA7, 0xE9, 0x3A, + 0x2A, 0xE8, 0xA7, 0x95, 0xDA, 0x16, 0x6C, 0x95, + 0x3E, 0xCF, 0x06, 0x10, 0xBC, 0x69, 0x70, 0xA6, + 0xF4, 0xF3, 0x21, 0xD4, 0xA6, 0x4A, 0xCA, 0x26, + 0x75, 0xC9, 0xF8, 0x89, 0x9C, 0xAD, 0xFD, 0xAF, + 0x9B, 0xD0, 0x20, 0x5A, 0xE8, 0x56, 0x3C, 0xD7, + 0xDE, 0xE8, 0xE1, 0xDB, 0xC9, 0xAD, 0x48, 0xB0, + 0xF3, 0xEC, 0x33, 0x68, 0x44, 0xFE, 0x59, 0x69 + }, + { + 0x7D, 0x0B, 0x63, 0x60, 0x6A, 0xF8, 0x71, 0x7F, + 0x40, 0xD2, 0x9F, 0x16, 0x75, 0xD1, 0x67, 0xC6, + 0x42, 0xE0, 0x7C, 0xE7, 0x12, 0xB9, 0x80, 0xC6, + 0x52, 0xE1, 0x9E, 0x66, 0x76, 0x9C, 0x61, 0x21, + 0x85, 0x94, 0x10, 0xC4, 0x76, 0x47, 0x57, 0xD3, + 0x10, 0x6D, 0x51, 0xEC, 0x53, 0xC5, 0x70, 0x27, + 0x66, 0x1A, 0x86, 0xCF, 0xEE, 0x59, 0x6F, 0x27, + 0x44, 0x86, 0xEE, 0xA0, 0x8E, 0x8A, 0xFB, 0x16 + }, + { + 0xA3, 0xB4, 0x7D, 0x4C, 0x92, 0x97, 0x3F, 0xC1, + 0xDC, 0xF6, 0x8F, 0xC1, 0xB3, 0x01, 0xC1, 0xF5, + 0x3A, 0xE7, 0x26, 0x13, 0x93, 0xFD, 0xA0, 0x7D, + 0x5D, 0xA7, 0x7A, 0xB8, 0x65, 0xEE, 0x20, 0x19, + 0xFB, 0x6A, 0xB7, 0x98, 0x31, 0x63, 0xDF, 0xF1, + 0xE0, 0x4E, 0x63, 0xCE, 0xDF, 0x41, 0xE3, 0xC1, + 0x2E, 0xBF, 0x44, 0xFA, 0x5A, 0x4B, 0x49, 0x17, + 0x33, 0xE8, 0x38, 0xD7, 0x84, 0x12, 0xDA, 0x3E + }, + { + 0xB6, 0x97, 0x6B, 0x15, 0x55, 0x01, 0x8D, 0x30, + 0x3B, 0x41, 0xAD, 0xAB, 0x1C, 0xB5, 0xEC, 0x23, + 0x69, 0x57, 0x22, 0x4B, 0xC3, 0xB9, 0xA8, 0xD5, + 0xB6, 0x24, 0xDD, 0x0E, 0x70, 0x6A, 0xB3, 0xEC, + 0xF9, 0xDF, 0xD2, 0x8F, 0x06, 0x56, 0x45, 0xCF, + 0x63, 0x02, 0x14, 0xB0, 0x57, 0xC6, 0xD2, 0x64, + 0xB3, 0x19, 0x3A, 0xD6, 0xAF, 0xBF, 0xEF, 0x08, + 0xBF, 0x86, 0xFF, 0x01, 0x9A, 0xE3, 0xC5, 0x2A + }, + { + 0xE3, 0x2F, 0x43, 0xAD, 0xC8, 0xC6, 0x7C, 0xA8, + 0xB3, 0xF1, 0x65, 0x8F, 0xD8, 0x82, 0xB5, 0xDF, + 0x4C, 0x08, 0x36, 0x33, 0x9E, 0x97, 0x6B, 0xC0, + 0x3B, 0x8C, 0x11, 0xE0, 0x7C, 0x59, 0xB5, 0x1D, + 0xD7, 0x1D, 0x34, 0x1C, 0xDF, 0x40, 0x99, 0x90, + 0xB4, 0x8E, 0xB1, 0x4D, 0x74, 0x90, 0x14, 0xAE, + 0x50, 0xE5, 0xE4, 0xBA, 0x03, 0x40, 0x9B, 0xDF, + 0xBE, 0x85, 0x15, 0x16, 0x4B, 0x2A, 0x90, 0x87 + }, + { + 0x6E, 0x5C, 0xE6, 0x95, 0x16, 0x8D, 0xD4, 0x0C, + 0x02, 0xE8, 0x54, 0x92, 0x67, 0x48, 0x71, 0xDD, + 0x4F, 0xFE, 0x02, 0xB2, 0xFC, 0xE0, 0xEF, 0x92, + 0x37, 0x0B, 0x8C, 0x38, 0x5C, 0x4E, 0x29, 0x1A, + 0x7D, 0x92, 0x0A, 0xB3, 0x86, 0x9E, 0x25, 0x20, + 0x21, 0x16, 0x1E, 0xF9, 0x47, 0xC4, 0xB7, 0x46, + 0xB1, 0x6A, 0xCB, 0x87, 0x9D, 0x9F, 0x41, 0xCD, + 0x65, 0x7F, 0x7F, 0x32, 0x92, 0xE5, 0x72, 0x45 + }, + { + 0x71, 0x2C, 0x14, 0xCC, 0x8B, 0x0C, 0x1E, 0x1B, + 0xD6, 0x9B, 0x69, 0x71, 0x2A, 0x9C, 0x9D, 0x6A, + 0xC0, 0xF7, 0x58, 0xC1, 0x83, 0xB1, 0xA4, 0x74, + 0xD3, 0x11, 0xF7, 0xB6, 0xD5, 0x88, 0xE8, 0x4A, + 0x6A, 0x9D, 0x65, 0xC4, 0x75, 0x38, 0x41, 0xF8, + 0x6F, 0x2D, 0x4F, 0xD2, 0xA4, 0x08, 0xB8, 0x80, + 0xB5, 0x5E, 0x9F, 0x7F, 0x8C, 0x17, 0x8A, 0xBB, + 0xDA, 0x73, 0xA2, 0xBF, 0x7F, 0x5D, 0x89, 0xE3 + }, + { + 0xF4, 0x95, 0xB2, 0xB0, 0x9B, 0xA8, 0xB4, 0xB6, + 0x76, 0x6E, 0x6C, 0xA4, 0x2F, 0x60, 0x1D, 0x13, + 0xC1, 0x87, 0xB4, 0x68, 0xED, 0x16, 0x49, 0x0E, + 0xCE, 0xF7, 0xDA, 0x66, 0x8B, 0x27, 0xCE, 0xDB, + 0xA4, 0x2A, 0xB2, 0x85, 0x27, 0x69, 0x68, 0x6F, + 0x81, 0x18, 0xF9, 0x14, 0x8E, 0xE9, 0x5F, 0x63, + 0xD0, 0x73, 0xDF, 0xC2, 0xD6, 0xF7, 0x84, 0xDA, + 0x5D, 0x73, 0x67, 0x58, 0x4E, 0x08, 0x8E, 0x9F + }, + { + 0xB9, 0xA1, 0x1B, 0x76, 0xA9, 0xAC, 0x57, 0xFE, + 0x6D, 0xC2, 0x6F, 0x6F, 0xAC, 0x5E, 0x70, 0x8D, + 0x09, 0x8A, 0x02, 0xC7, 0x07, 0x0C, 0x4A, 0x1E, + 0x8C, 0x60, 0x12, 0xC2, 0x94, 0xC5, 0x38, 0x4F, + 0x58, 0xF8, 0xB6, 0x3F, 0xE4, 0x3D, 0x2C, 0x65, + 0xA9, 0x2A, 0x0E, 0x77, 0x7E, 0x83, 0x2A, 0x55, + 0xB3, 0x3C, 0xDE, 0xE6, 0xF8, 0x94, 0x0E, 0xE1, + 0x56, 0x27, 0x2D, 0x14, 0xD8, 0xB9, 0x7B, 0xFF + }, + { + 0xFE, 0xC1, 0x97, 0x41, 0x46, 0x55, 0xBA, 0x8A, + 0x5E, 0x1D, 0xAE, 0x9B, 0xAB, 0x9F, 0xB2, 0x47, + 0x46, 0x75, 0x17, 0x09, 0x91, 0x9D, 0x82, 0x87, + 0xF5, 0xA0, 0x25, 0xEE, 0x4C, 0x21, 0x45, 0x90, + 0xAD, 0xC9, 0x50, 0xD0, 0x28, 0x9F, 0xC6, 0x57, + 0x8B, 0xE8, 0x32, 0x90, 0x36, 0xA1, 0x5C, 0x4C, + 0x81, 0x97, 0x7E, 0x4B, 0x1B, 0x33, 0x3B, 0xEC, + 0xAD, 0x2E, 0xAE, 0xAD, 0x65, 0x54, 0x1E, 0x49 + }, + { + 0x6D, 0x5A, 0x2D, 0x8E, 0xA1, 0x2A, 0xDC, 0x3E, + 0xFA, 0xDD, 0xC0, 0xC4, 0x5A, 0x7C, 0x52, 0xFC, + 0x5C, 0x46, 0xAB, 0x70, 0x4C, 0x6F, 0x06, 0xC7, + 0x90, 0xF4, 0x22, 0x77, 0x44, 0xBD, 0x72, 0xFE, + 0xF1, 0xC3, 0x3A, 0xDE, 0x94, 0x33, 0xE6, 0x03, + 0xC3, 0xC2, 0xD5, 0x3E, 0x32, 0x7F, 0xE4, 0x60, + 0xA7, 0x1F, 0x70, 0x53, 0x6D, 0x32, 0x2E, 0xC7, + 0x13, 0x76, 0x8F, 0xB5, 0xB1, 0x54, 0x8F, 0x3A + }, + { + 0xDE, 0x44, 0x35, 0x29, 0xC1, 0xD0, 0xC1, 0x0E, + 0xE8, 0xC1, 0x23, 0x0B, 0x9E, 0xF8, 0xA0, 0x3E, + 0x39, 0x2D, 0x7A, 0xB4, 0x26, 0x28, 0x0C, 0x51, + 0xB1, 0xC3, 0x9F, 0x64, 0x06, 0x61, 0xD5, 0x37, + 0x84, 0xDA, 0x26, 0xE7, 0xA0, 0x0E, 0xD4, 0xD0, + 0x3B, 0xAB, 0x48, 0x8F, 0x47, 0xFA, 0xCF, 0x78, + 0x06, 0x6A, 0x42, 0xF4, 0x9F, 0x12, 0xD3, 0x26, + 0x24, 0x1A, 0x51, 0xB0, 0x00, 0x6F, 0x1F, 0x36 + }, + { + 0xBA, 0x7A, 0xD8, 0x0F, 0x7D, 0xBB, 0xDB, 0x0F, + 0x67, 0xC8, 0xEE, 0xBC, 0xA6, 0xFB, 0xCC, 0x68, + 0xF0, 0x50, 0x95, 0xEA, 0x8D, 0xCF, 0x9E, 0x37, + 0x37, 0xDF, 0xF3, 0xDC, 0xB0, 0x76, 0xA7, 0xEF, + 0x80, 0x00, 0x57, 0xA4, 0xD5, 0x48, 0x26, 0x05, + 0xEC, 0xF9, 0x3D, 0xD8, 0xC1, 0xD9, 0xDB, 0x04, + 0x65, 0xCE, 0xEA, 0x45, 0x84, 0xEC, 0xF6, 0xFC, + 0xF2, 0x34, 0x0E, 0x11, 0x31, 0xD3, 0x01, 0xF2 + }, + { + 0x01, 0xA6, 0x51, 0x7A, 0xBC, 0xB6, 0xAA, 0x8D, + 0xE9, 0xB6, 0x78, 0x23, 0xA6, 0xC7, 0xDF, 0x16, + 0xEB, 0x4A, 0xAF, 0xD9, 0x75, 0xD9, 0x9F, 0xFE, + 0x48, 0xA1, 0xD0, 0xE6, 0xF8, 0x93, 0x33, 0x8B, + 0x04, 0x0F, 0x1D, 0xEB, 0x36, 0x0A, 0xB5, 0xC8, + 0x41, 0x30, 0xB5, 0x57, 0xE3, 0xC4, 0x28, 0xF7, + 0xC1, 0xDC, 0xF2, 0x38, 0x36, 0xE0, 0x56, 0xDA, + 0x14, 0x7D, 0x5C, 0xC5, 0x90, 0xB1, 0xE6, 0x25 + }, + { + 0x95, 0x33, 0x5A, 0xD7, 0xDD, 0x6F, 0x50, 0xAD, + 0xAA, 0xF8, 0x6C, 0xF3, 0x5B, 0xD9, 0x9A, 0xFF, + 0x6B, 0x07, 0x46, 0x55, 0x79, 0x6F, 0x4E, 0x65, + 0x33, 0x50, 0x30, 0x6C, 0x2E, 0x8B, 0x37, 0x52, + 0xF1, 0xC1, 0x61, 0x83, 0xCA, 0x02, 0xF9, 0x6C, + 0xE7, 0x27, 0xF2, 0xA6, 0x93, 0xDB, 0x9A, 0x3D, + 0x52, 0x9C, 0xA6, 0xA6, 0x7C, 0xF3, 0x7B, 0xEF, + 0xC2, 0x78, 0xB3, 0x17, 0x0F, 0xD7, 0x4B, 0xA0 + }, + { + 0x52, 0x17, 0x1E, 0xCA, 0x87, 0x91, 0xDF, 0xF2, + 0x86, 0xE2, 0xE3, 0x28, 0x61, 0xB2, 0x93, 0xFF, + 0xF5, 0xAF, 0xFE, 0x4A, 0x69, 0xA2, 0x94, 0xF8, + 0xF7, 0xC3, 0xA0, 0x1C, 0x58, 0xA6, 0x28, 0x38, + 0x62, 0x86, 0x02, 0xC5, 0xC6, 0xFD, 0x09, 0xC4, + 0xCF, 0xEE, 0x13, 0x8C, 0x76, 0x66, 0x5B, 0xC1, + 0xDE, 0xD2, 0x11, 0xF2, 0xAC, 0x76, 0xC7, 0xC1, + 0xB5, 0xA0, 0x7E, 0x36, 0xB3, 0xA2, 0xD9, 0xF2 + }, + { + 0x06, 0x60, 0x65, 0x3A, 0xAA, 0xC1, 0x5A, 0x7C, + 0xD4, 0x44, 0x4C, 0x87, 0x76, 0x32, 0xE9, 0x8D, + 0xD6, 0xF9, 0x11, 0xE5, 0x05, 0x6D, 0x85, 0x1D, + 0x4B, 0x53, 0x1C, 0x91, 0x47, 0x87, 0x5E, 0xE8, + 0xE3, 0x56, 0xEB, 0x47, 0xD6, 0xF6, 0xA8, 0xBF, + 0x7D, 0x17, 0x53, 0x15, 0x96, 0x33, 0x07, 0x77, + 0x1B, 0x90, 0xE0, 0xCC, 0xAD, 0xE6, 0xB1, 0x8E, + 0x9A, 0x68, 0x6D, 0x74, 0x4E, 0xC3, 0x97, 0xB2 + }, + { + 0x05, 0x80, 0x24, 0x8D, 0xDC, 0x50, 0xCF, 0x95, + 0xD5, 0xBE, 0x1B, 0x49, 0x87, 0x88, 0x1F, 0xD9, + 0x9C, 0x19, 0xBA, 0xA6, 0xC6, 0x12, 0xF9, 0x15, + 0x79, 0x19, 0x27, 0x48, 0xB4, 0xFA, 0xF0, 0x02, + 0x46, 0xEC, 0xA4, 0x3B, 0xA4, 0xF7, 0x01, 0xB0, + 0xAB, 0x21, 0x6A, 0x71, 0x43, 0x58, 0xF5, 0x14, + 0x5E, 0xA9, 0x20, 0xCA, 0xFC, 0x5E, 0xD8, 0x94, + 0xE6, 0x4B, 0x54, 0x13, 0xB5, 0x72, 0x26, 0xA5 + }, + { + 0x47, 0xFF, 0xA0, 0xF0, 0x28, 0x86, 0xBA, 0xD2, + 0xF4, 0x6B, 0xC8, 0x33, 0xDB, 0x30, 0x72, 0x41, + 0x80, 0x48, 0x75, 0xE9, 0x30, 0xE1, 0xA4, 0xD5, + 0x04, 0xDE, 0x80, 0x18, 0x41, 0x47, 0xBC, 0xD0, + 0x64, 0x9E, 0x55, 0xE4, 0x02, 0x18, 0x2A, 0xCE, + 0xE3, 0x55, 0x24, 0xCA, 0x33, 0x07, 0x15, 0x3B, + 0x13, 0xB2, 0xD4, 0xAB, 0x56, 0xAC, 0x9E, 0x7A, + 0x45, 0x18, 0x9B, 0x2C, 0x7A, 0x0F, 0x41, 0x07 + }, + { + 0xD5, 0x9A, 0xE5, 0xEE, 0x16, 0x3F, 0xBF, 0x57, + 0x63, 0x61, 0x85, 0xA9, 0x66, 0x43, 0xD5, 0x02, + 0xD1, 0x60, 0xD4, 0x7A, 0x7D, 0x65, 0xBD, 0x2E, + 0xB5, 0x07, 0x6A, 0x1B, 0x51, 0xAB, 0x3A, 0x6E, + 0x18, 0x5A, 0x67, 0xD2, 0x4E, 0xD5, 0xDB, 0x47, + 0x13, 0x6A, 0x00, 0x3C, 0xF4, 0x47, 0x22, 0xD4, + 0xFA, 0xAE, 0xDD, 0x68, 0xBC, 0x3E, 0x00, 0xFA, + 0x16, 0x70, 0x79, 0xA7, 0xD2, 0x3A, 0xE9, 0x1F + }, + { + 0xA9, 0xA4, 0xF4, 0x39, 0x98, 0x8E, 0x72, 0x83, + 0x0E, 0x78, 0xC6, 0x56, 0xCB, 0x7D, 0x9C, 0x95, + 0xC4, 0x64, 0xFE, 0x67, 0xC8, 0x99, 0x08, 0xBD, + 0x01, 0xA9, 0x8E, 0x47, 0x19, 0xE2, 0x89, 0x05, + 0xB7, 0xA1, 0xE4, 0xAF, 0x85, 0xF0, 0x98, 0xCF, + 0x9D, 0x75, 0x91, 0xEC, 0xB7, 0xAA, 0xBC, 0x4B, + 0x48, 0x6C, 0xAB, 0xF8, 0x91, 0x7C, 0x50, 0xC4, + 0x4C, 0xE5, 0xCE, 0x4A, 0x51, 0x35, 0xA5, 0x23 + }, + { + 0xBB, 0x3E, 0xAF, 0xCC, 0x04, 0xD3, 0x0F, 0xBA, + 0x8E, 0x34, 0x1D, 0x6B, 0xD2, 0x8D, 0x3C, 0x24, + 0x8B, 0x94, 0x36, 0xB3, 0x38, 0x8D, 0x0C, 0xE2, + 0x1C, 0xBD, 0xEB, 0x68, 0x83, 0x8F, 0x5A, 0x00, + 0x93, 0xAD, 0x92, 0xEA, 0x9C, 0xF6, 0x7E, 0x95, + 0x32, 0xC8, 0x76, 0x6C, 0x1C, 0xE1, 0xE9, 0xB4, + 0x27, 0x98, 0xE1, 0x0E, 0x04, 0xFA, 0x69, 0x32, + 0x7A, 0x57, 0x3D, 0x5B, 0x3B, 0xC2, 0xC6, 0xF0 + }, + { + 0xA1, 0x2C, 0x09, 0x26, 0x26, 0x3A, 0xCA, 0x90, + 0x12, 0x4F, 0xD6, 0xBD, 0x20, 0x0E, 0x6C, 0x52, + 0x22, 0x91, 0x5F, 0x21, 0x1D, 0xD1, 0xBC, 0xC1, + 0x62, 0x6C, 0x14, 0x8E, 0x45, 0x13, 0x5D, 0xEF, + 0xDE, 0x08, 0x72, 0x4A, 0x93, 0x84, 0xA0, 0x35, + 0xCB, 0x8B, 0xF9, 0xF5, 0xAB, 0xF9, 0x59, 0xB2, + 0x20, 0xF1, 0x2E, 0x4F, 0xCA, 0x69, 0xFA, 0xAE, + 0x19, 0x6F, 0x7A, 0x8F, 0xBE, 0xEA, 0x7E, 0xD7 + }, + { + 0x7A, 0x63, 0x30, 0x64, 0x90, 0x15, 0x0F, 0x79, + 0xC7, 0x9C, 0x28, 0x84, 0x3F, 0x0E, 0x82, 0x67, + 0xC7, 0x10, 0x37, 0x98, 0xA2, 0x74, 0xE2, 0x41, + 0x2E, 0xE8, 0x58, 0x3A, 0x0B, 0xE5, 0x29, 0xFF, + 0x1D, 0xCD, 0xB2, 0xA0, 0xF0, 0x80, 0x5A, 0x03, + 0x90, 0xDF, 0x82, 0xFA, 0x9E, 0xCC, 0x19, 0xD5, + 0x16, 0x0B, 0xF9, 0x36, 0x6E, 0x75, 0xA5, 0x70, + 0xBB, 0x69, 0xDF, 0xFC, 0x11, 0xE3, 0xF6, 0x02 + }, + { + 0x3A, 0x05, 0x05, 0x71, 0x44, 0x17, 0x8B, 0xE5, + 0xF4, 0xFB, 0xB2, 0xB4, 0x45, 0x82, 0x3A, 0xD0, + 0x3F, 0x0D, 0x79, 0x3A, 0x0D, 0x45, 0xF6, 0x87, + 0xFD, 0x2D, 0x73, 0xAE, 0x5E, 0x5B, 0xD1, 0x21, + 0x53, 0xA7, 0x86, 0x74, 0xBE, 0x9E, 0x9F, 0x21, + 0x53, 0x0E, 0xE2, 0xD4, 0x35, 0xD8, 0x17, 0x5A, + 0xF2, 0x3A, 0xA0, 0xB4, 0xC5, 0x21, 0x6F, 0xA3, + 0x5A, 0x4A, 0x9D, 0xBF, 0xC8, 0xB5, 0xCD, 0x2A + }, + { + 0x11, 0x53, 0x71, 0xC7, 0x21, 0xC8, 0x52, 0x07, + 0x83, 0xBE, 0xC7, 0x32, 0x4C, 0x47, 0x55, 0x14, + 0x6B, 0x8E, 0x5C, 0xFA, 0x2E, 0x47, 0x06, 0x95, + 0x7F, 0x85, 0xD3, 0xC0, 0xBA, 0xDC, 0x57, 0x9D, + 0xEC, 0xE0, 0xDD, 0xEA, 0xD0, 0x4F, 0xE5, 0xDB, + 0x79, 0x7A, 0x4A, 0xEA, 0x15, 0x3E, 0x3A, 0xB3, + 0x1C, 0x84, 0xA1, 0x57, 0xE1, 0x47, 0x1F, 0xC9, + 0xAA, 0xF4, 0xCA, 0x66, 0xFE, 0x8F, 0x68, 0x3A + }, + { + 0x34, 0x8B, 0xFD, 0xA7, 0x69, 0x9A, 0xD1, 0x2C, + 0x8C, 0xF4, 0x24, 0xC3, 0xFD, 0x2F, 0x32, 0x8C, + 0x98, 0x6E, 0x6D, 0xCF, 0x42, 0xFC, 0xA5, 0xD4, + 0xB4, 0xCD, 0xAC, 0x48, 0x7B, 0x47, 0x84, 0x09, + 0x27, 0x85, 0x6F, 0x1C, 0xEA, 0x5B, 0xAE, 0x06, + 0x17, 0xAE, 0x10, 0xE7, 0xA2, 0x07, 0x4B, 0xE1, + 0xBB, 0x01, 0xB6, 0x09, 0x27, 0xF1, 0x16, 0x9B, + 0xAA, 0xF3, 0x9A, 0x90, 0xBE, 0xA5, 0x63, 0xA3 + }, + { + 0xD1, 0x8C, 0x67, 0x27, 0xE4, 0x85, 0x00, 0x04, + 0x06, 0x9F, 0x9F, 0x27, 0x22, 0xE9, 0xB6, 0x40, + 0x84, 0xE0, 0x0F, 0x03, 0x71, 0xD8, 0xD3, 0xAF, + 0x80, 0xAB, 0x3C, 0xA7, 0x8A, 0x9E, 0x6F, 0xA1, + 0x86, 0xFA, 0x98, 0xBB, 0x7B, 0x59, 0x8A, 0x57, + 0x76, 0x20, 0xD2, 0xAD, 0x70, 0x15, 0xD7, 0x15, + 0xF9, 0x9E, 0xD2, 0xE6, 0x88, 0x77, 0x2C, 0x9D, + 0x2C, 0x41, 0xDF, 0x0C, 0x37, 0xE9, 0xEB, 0x95 + }, + { + 0xDA, 0x63, 0xF5, 0x0C, 0xC2, 0xA7, 0x46, 0x37, + 0x7B, 0x67, 0x40, 0xE5, 0x3A, 0x2F, 0xC0, 0xE9, + 0xCF, 0xF6, 0xEC, 0xC1, 0xBF, 0xE2, 0x5D, 0x00, + 0xDC, 0xE7, 0x19, 0x6E, 0x2D, 0xC1, 0xC6, 0x8F, + 0xF6, 0x34, 0x42, 0x22, 0x10, 0x23, 0x4B, 0xC3, + 0xCA, 0x06, 0xB9, 0x01, 0x98, 0x2F, 0xFE, 0xA9, + 0xB6, 0xAB, 0xAC, 0x0A, 0xBD, 0xF6, 0x79, 0xD5, + 0xAF, 0xD3, 0x82, 0x9F, 0x03, 0x28, 0x02, 0x86 + }, + { + 0x80, 0x81, 0x54, 0x16, 0xF3, 0x5F, 0x94, 0xEE, + 0xD4, 0xC7, 0x5D, 0x7E, 0xC0, 0x8E, 0x81, 0x24, + 0x47, 0xB9, 0xBD, 0x40, 0xE8, 0xB1, 0xCB, 0x55, + 0x3A, 0x08, 0x58, 0xF3, 0x29, 0xA9, 0x02, 0xD0, + 0xCC, 0x48, 0xBF, 0xCD, 0x98, 0xA7, 0xB6, 0x0C, + 0xEB, 0x68, 0x4F, 0x12, 0x87, 0x5A, 0x48, 0x7A, + 0x3A, 0x91, 0x86, 0x2F, 0xD1, 0x39, 0xB7, 0x6F, + 0xD0, 0xA5, 0x7B, 0x7E, 0xB4, 0x75, 0x13, 0xAF + }, + { + 0x4B, 0xDA, 0x84, 0x17, 0x68, 0x5F, 0x27, 0x2C, + 0x05, 0xB5, 0xC3, 0x44, 0x41, 0xE5, 0xA8, 0x57, + 0xBE, 0xAB, 0xA1, 0xE7, 0x02, 0x1D, 0xE2, 0x65, + 0x27, 0x9A, 0x3B, 0x08, 0xCA, 0x3A, 0x46, 0x8F, + 0x55, 0x0A, 0xB7, 0xD6, 0x34, 0x4A, 0x67, 0x17, + 0x23, 0x1A, 0x28, 0x62, 0x3C, 0xEA, 0x21, 0x84, + 0x21, 0xFB, 0x59, 0x83, 0x43, 0xA1, 0xDE, 0xF3, + 0x07, 0x2B, 0x76, 0x6B, 0xFF, 0x13, 0xD5, 0x57 + }, + { + 0x1D, 0x4A, 0xBD, 0x5C, 0xE1, 0xE2, 0x72, 0x7E, + 0x10, 0x33, 0xFF, 0x75, 0xA2, 0xA2, 0x6D, 0x9C, + 0xE4, 0x9C, 0xBD, 0xDE, 0x74, 0x6B, 0xA1, 0x53, + 0x76, 0xC1, 0x1C, 0x9C, 0xAC, 0xAB, 0xFF, 0xD6, + 0x84, 0x8E, 0x3B, 0xE2, 0x73, 0xEC, 0xEA, 0x7F, + 0x51, 0x15, 0x32, 0x1F, 0x8D, 0x43, 0x91, 0x6B, + 0x25, 0x65, 0x05, 0xC8, 0x94, 0xDF, 0xA9, 0x68, + 0xEC, 0xF3, 0x01, 0xDE, 0xE0, 0x9D, 0x46, 0x11 + }, + { + 0x0A, 0x8F, 0x3C, 0x2C, 0x34, 0x11, 0xF7, 0x90, + 0xD3, 0x4A, 0x66, 0x6A, 0x51, 0xB7, 0xE3, 0xCA, + 0xC7, 0x50, 0xE8, 0x81, 0x6F, 0x59, 0xAB, 0x71, + 0xB1, 0x0E, 0xF7, 0x2E, 0xB3, 0x17, 0xEE, 0x7E, + 0xF0, 0x65, 0xBE, 0xB3, 0xE1, 0x7E, 0x5D, 0x30, + 0x75, 0x43, 0xEE, 0xAF, 0x60, 0x67, 0xDD, 0x02, + 0xA3, 0xE5, 0xDE, 0xD2, 0xA3, 0xEF, 0x9D, 0xAC, + 0x5B, 0x0F, 0xBF, 0x7E, 0xD9, 0xB8, 0x79, 0xCC + }, + { + 0xD4, 0x84, 0x12, 0x25, 0xD2, 0x54, 0xD4, 0x67, + 0xF2, 0x8D, 0xAA, 0xBE, 0xE1, 0x98, 0x32, 0xF0, + 0xB6, 0xAF, 0xA2, 0xBE, 0x78, 0x53, 0x5F, 0x22, + 0x3A, 0xD9, 0x36, 0x90, 0x9D, 0x8B, 0xC0, 0x13, + 0xCB, 0x69, 0x02, 0xB7, 0xDF, 0xB9, 0x86, 0x63, + 0x4D, 0xD5, 0x75, 0x42, 0x97, 0xC2, 0x02, 0xFE, + 0x19, 0x0D, 0xD8, 0xD0, 0x66, 0x75, 0xD4, 0x4B, + 0x33, 0x3E, 0x3A, 0xF0, 0xC2, 0xAE, 0xA0, 0x4D + }, + { + 0xEE, 0xE1, 0xCD, 0x7E, 0xFB, 0x23, 0xE3, 0x6C, + 0x5B, 0x68, 0x6A, 0x80, 0x3C, 0x5B, 0x76, 0xE1, + 0x7B, 0x08, 0xC1, 0xCF, 0x14, 0x05, 0x8B, 0x48, + 0x70, 0x08, 0x71, 0x0F, 0x1F, 0x1C, 0xCC, 0xF2, + 0xA0, 0x91, 0x8F, 0xC6, 0x17, 0xAA, 0x1A, 0x40, + 0x96, 0xFD, 0xC5, 0xA0, 0xDD, 0x1E, 0x52, 0x51, + 0xF7, 0x85, 0x00, 0xC6, 0x0E, 0x77, 0x0A, 0xA4, + 0xFA, 0x67, 0x1B, 0x8F, 0x4E, 0x8C, 0x4E, 0xB4 + }, + { + 0xCE, 0x4F, 0xA9, 0x08, 0x40, 0x4C, 0x09, 0x85, + 0xB5, 0xF8, 0x9A, 0x7F, 0x07, 0x54, 0x93, 0x5A, + 0x69, 0xB1, 0xF5, 0xDD, 0x33, 0xFE, 0x47, 0x44, + 0x6F, 0x08, 0x34, 0x19, 0x8F, 0xB0, 0x92, 0x6F, + 0xBD, 0x78, 0x05, 0xC9, 0x1E, 0xDC, 0x71, 0x39, + 0x1F, 0x75, 0xA3, 0x16, 0x88, 0xEF, 0xE2, 0x5C, + 0x10, 0x66, 0x94, 0x02, 0xFA, 0x21, 0x0B, 0x82, + 0x28, 0x43, 0x83, 0xD2, 0x1C, 0xD8, 0x65, 0x6E + }, + { + 0x4A, 0xC0, 0x44, 0xC4, 0xAF, 0x51, 0x45, 0x42, + 0xF4, 0x5D, 0xFE, 0xEA, 0x85, 0x88, 0x07, 0xFA, + 0x6F, 0x54, 0xE6, 0x77, 0xA8, 0x33, 0x1E, 0x88, + 0xDE, 0x41, 0x1F, 0x63, 0x0B, 0xDE, 0x22, 0xC9, + 0x25, 0x9D, 0xC8, 0xC6, 0xE7, 0x48, 0x83, 0x38, + 0x92, 0xC5, 0x23, 0x0E, 0x57, 0x38, 0x71, 0x05, + 0x2F, 0x77, 0x49, 0x16, 0x89, 0x5D, 0x27, 0xF8, + 0x62, 0x75, 0x21, 0xC8, 0xAA, 0x24, 0xA4, 0x1B + }, + { + 0xCE, 0x19, 0xBD, 0xC0, 0x62, 0x0B, 0x0D, 0x8F, + 0xA0, 0x57, 0x96, 0xEA, 0xD2, 0xD7, 0x9A, 0xD3, + 0x21, 0x7A, 0x9F, 0x7E, 0x39, 0x10, 0x53, 0x4B, + 0x5C, 0x07, 0x87, 0x0D, 0x96, 0xB6, 0xC9, 0xC6, + 0x37, 0x16, 0xF3, 0x6D, 0x69, 0xA4, 0x31, 0x03, + 0xEE, 0xF0, 0x3F, 0xA1, 0x7E, 0xBD, 0xDF, 0x0E, + 0xFF, 0x02, 0xBC, 0x7F, 0x2E, 0x40, 0x73, 0xA4, + 0xA8, 0x1C, 0xA1, 0x31, 0x72, 0x56, 0x6F, 0x62 + }, + { + 0xB8, 0x79, 0x0A, 0x20, 0xF2, 0xCF, 0xE8, 0xCC, + 0xF9, 0x0E, 0xD4, 0x7A, 0xFF, 0x2E, 0xF1, 0xD5, + 0x82, 0x8F, 0x2D, 0xAB, 0x7C, 0x7E, 0x4B, 0x14, + 0x22, 0x99, 0x8C, 0xFF, 0xC8, 0x39, 0xF1, 0x22, + 0xC3, 0xD8, 0xA9, 0x57, 0x21, 0xCC, 0x59, 0x6B, + 0x24, 0xB1, 0x98, 0xBE, 0x74, 0x0E, 0xA2, 0xF5, + 0x4F, 0x0B, 0xC8, 0x49, 0x22, 0x41, 0x6E, 0x56, + 0x8C, 0x2B, 0x9F, 0xC2, 0xCB, 0xE4, 0x52, 0x01 + }, + { + 0x75, 0xD8, 0xAA, 0x23, 0xFA, 0xC3, 0x90, 0x92, + 0xEE, 0x04, 0x12, 0xC2, 0x87, 0xE0, 0xE3, 0xF7, + 0xDD, 0x76, 0xBF, 0x6C, 0x4E, 0xE5, 0x02, 0x99, + 0x24, 0xDB, 0xA6, 0x2B, 0x0A, 0x16, 0x20, 0x6A, + 0xDB, 0xAD, 0x2F, 0xF7, 0xE3, 0x07, 0x50, 0x82, + 0x00, 0x02, 0x9C, 0x83, 0xD7, 0x5E, 0xAD, 0xA5, + 0x3F, 0xCA, 0x85, 0x2B, 0x9D, 0x47, 0x80, 0x5B, + 0x1E, 0x03, 0x26, 0x9E, 0xF7, 0x50, 0xC4, 0x84 + }, + { + 0x41, 0x01, 0x6F, 0x7F, 0x13, 0x2A, 0x1C, 0xCA, + 0x55, 0xDB, 0xF7, 0x5D, 0x24, 0x0A, 0x20, 0xA4, + 0xAD, 0x02, 0x41, 0xD5, 0xD1, 0xFE, 0xB4, 0xC2, + 0x50, 0x5E, 0x1C, 0x96, 0xD4, 0x51, 0x80, 0x99, + 0xD4, 0x2C, 0x1C, 0x1E, 0xB6, 0x97, 0xEC, 0x27, + 0x74, 0xBC, 0x6F, 0x0B, 0x61, 0x0E, 0x99, 0xA5, + 0x54, 0xAC, 0xA5, 0x69, 0xF2, 0x9E, 0x35, 0x6C, + 0xB0, 0x36, 0x77, 0x06, 0x6E, 0x27, 0xE6, 0x67 + }, + { + 0x82, 0x98, 0x51, 0x0D, 0x7E, 0x90, 0xF4, 0x0E, + 0xAF, 0xD5, 0x83, 0x0D, 0xF0, 0x04, 0xED, 0x55, + 0xAA, 0x8D, 0x96, 0x0B, 0x37, 0x52, 0x17, 0x2B, + 0x20, 0x5A, 0x26, 0x33, 0xE4, 0x83, 0xBE, 0xB1, + 0x94, 0x78, 0xA7, 0x84, 0x2D, 0xB1, 0x81, 0xDA, + 0xFD, 0xB5, 0x2B, 0xA8, 0xDC, 0x68, 0x10, 0xBD, + 0xF9, 0x24, 0xD3, 0x9F, 0xE8, 0x67, 0x09, 0xA6, + 0x87, 0xBF, 0xC4, 0x9C, 0xEF, 0x46, 0x32, 0x18 + }, + { + 0xE5, 0xEA, 0xB1, 0xD8, 0xAB, 0xF5, 0x25, 0x9A, + 0x6A, 0xF5, 0xAE, 0x36, 0x6B, 0xB7, 0x13, 0x0A, + 0x7D, 0xCB, 0xE4, 0xF0, 0x12, 0x69, 0x3C, 0x29, + 0x72, 0x51, 0x8D, 0xEB, 0x0A, 0x41, 0x76, 0xEA, + 0xA5, 0xA5, 0x2C, 0xA1, 0x79, 0xA6, 0x34, 0x78, + 0x5D, 0x6E, 0x95, 0xE5, 0xF8, 0x51, 0x3D, 0x63, + 0xAD, 0x00, 0xC3, 0x0B, 0x5E, 0x7F, 0xFC, 0x75, + 0xEC, 0xDB, 0xB6, 0xCB, 0x5C, 0x67, 0x0E, 0x45 + }, + { + 0x82, 0x33, 0xBB, 0x52, 0xE7, 0x77, 0x0D, 0xF4, + 0x72, 0x7B, 0x8F, 0xEA, 0xC9, 0x77, 0x9A, 0x2C, + 0x12, 0x4F, 0x2B, 0xC1, 0x72, 0xCF, 0x5B, 0x3A, + 0x4B, 0x0D, 0x82, 0x3F, 0x6B, 0x70, 0xB8, 0xC0, + 0x03, 0xDD, 0xBC, 0x33, 0x25, 0xD8, 0x5D, 0xFB, + 0x39, 0xF7, 0x0B, 0xD9, 0xB3, 0x67, 0xA7, 0x67, + 0xBB, 0x86, 0x03, 0x33, 0x6B, 0x32, 0xD0, 0x8D, + 0x92, 0x9D, 0x89, 0x2C, 0x6F, 0x11, 0x8D, 0xCE + }, + { + 0xE1, 0x8E, 0x08, 0xA8, 0x78, 0xFC, 0x62, 0x31, + 0xFE, 0x4B, 0x76, 0xA5, 0x7F, 0x60, 0xCA, 0x3A, + 0xFE, 0xAE, 0x0D, 0x49, 0xA3, 0x3C, 0xED, 0x1E, + 0x77, 0x54, 0xB5, 0x15, 0xEB, 0xF0, 0x90, 0xD6, + 0xE0, 0x15, 0x57, 0x5D, 0xF7, 0x3F, 0x74, 0x89, + 0xD5, 0x67, 0x03, 0x9E, 0x72, 0x7D, 0xC3, 0xAC, + 0x7F, 0xA3, 0x06, 0x17, 0xF6, 0xB4, 0x20, 0x72, + 0xB0, 0x5A, 0x93, 0xB6, 0x7D, 0xC9, 0x2D, 0xD7 + }, + { + 0xCA, 0xF9, 0x74, 0x3D, 0xA5, 0x6A, 0x1B, 0xC2, + 0xC3, 0xC7, 0x80, 0x06, 0x59, 0x7A, 0xF0, 0x5A, + 0x25, 0x22, 0xAB, 0xDB, 0x33, 0x04, 0x6F, 0xB7, + 0x34, 0x39, 0x97, 0xC4, 0xF6, 0xF8, 0xC9, 0x32, + 0x9D, 0x48, 0xA6, 0x0E, 0x7A, 0xC9, 0x67, 0xCA, + 0xEA, 0x0B, 0x70, 0x30, 0xC7, 0x26, 0xBC, 0x33, + 0x6E, 0x8C, 0xBD, 0xA0, 0x61, 0xED, 0x5C, 0xB5, + 0x6D, 0x34, 0xFE, 0xC1, 0x24, 0x7E, 0xB0, 0xA0 + }, + { + 0x32, 0xF6, 0x8A, 0x39, 0x97, 0xAF, 0xB6, 0x05, + 0x2A, 0xEA, 0x6A, 0x4D, 0x8B, 0x70, 0xC1, 0x2B, + 0xE4, 0x1D, 0xC0, 0xCE, 0x2D, 0x27, 0x46, 0x79, + 0x6E, 0x60, 0x7A, 0x64, 0x7A, 0x4E, 0x30, 0x2F, + 0xC4, 0xBE, 0x2F, 0x78, 0xD8, 0xE4, 0xEC, 0x99, + 0x3E, 0xAC, 0x98, 0xD6, 0x0E, 0xF4, 0xD9, 0xE2, + 0xE3, 0xB6, 0x31, 0xE4, 0x5E, 0x62, 0x7A, 0x33, + 0xF2, 0x1B, 0x2E, 0x5F, 0x4B, 0x38, 0xD6, 0x16 + }, + { + 0x5B, 0x39, 0x9B, 0x6D, 0x45, 0xAB, 0xA7, 0x5A, + 0x17, 0xF8, 0x1F, 0xDB, 0x31, 0x0D, 0x39, 0xC8, + 0x3E, 0xB8, 0x7D, 0x5B, 0x5D, 0xDB, 0x95, 0x53, + 0xBF, 0xED, 0x2E, 0xA1, 0x65, 0x2A, 0x0B, 0x59, + 0x91, 0x2C, 0xE0, 0x37, 0xFF, 0xB6, 0x97, 0x7A, + 0xCB, 0xD9, 0x28, 0xC4, 0x66, 0x26, 0x8A, 0x2C, + 0x0D, 0x78, 0x23, 0x9F, 0x3E, 0x7E, 0x46, 0x05, + 0x74, 0x0C, 0x39, 0xC6, 0x35, 0xD8, 0xFE, 0xFA + }, + { + 0xA7, 0x7D, 0x99, 0x5E, 0x80, 0x31, 0xCE, 0x11, + 0x66, 0x17, 0xA7, 0x28, 0xB8, 0xCC, 0x7E, 0xBF, + 0xC9, 0x21, 0x2B, 0xAD, 0x77, 0x63, 0xF6, 0x9B, + 0x6B, 0xD4, 0x99, 0x77, 0x07, 0xC7, 0xA6, 0x37, + 0x28, 0xC4, 0xC6, 0x22, 0x9A, 0xFE, 0x7A, 0x5D, + 0x7E, 0xB3, 0xFD, 0x17, 0x7A, 0x02, 0x78, 0x4D, + 0xDD, 0x0B, 0xEC, 0xF1, 0xDC, 0xF8, 0x12, 0xFB, + 0x4D, 0xC5, 0x8C, 0x2F, 0x74, 0x73, 0x26, 0x50 + }, + { + 0xAD, 0xE5, 0xD7, 0xAC, 0x92, 0x6E, 0x15, 0xBB, + 0x2D, 0x63, 0x58, 0x8C, 0xF3, 0xC7, 0xDC, 0xEA, + 0x5B, 0xC9, 0x3E, 0x95, 0xD1, 0x52, 0x67, 0x1C, + 0x36, 0x06, 0xC2, 0x90, 0x28, 0x6D, 0x79, 0x69, + 0x7C, 0xF6, 0x69, 0x98, 0x6D, 0xA5, 0xFB, 0x1C, + 0xC2, 0xA3, 0x97, 0x9D, 0x15, 0xEA, 0x2F, 0xA5, + 0x94, 0x8D, 0x48, 0xC8, 0x58, 0xAB, 0xBD, 0xB3, + 0x54, 0xD2, 0x78, 0xD5, 0xDE, 0xCC, 0x53, 0x4C + }, + { + 0x46, 0x79, 0xA8, 0x2D, 0xA5, 0x0C, 0xC2, 0x28, + 0x70, 0x76, 0x38, 0x11, 0x9C, 0xA6, 0x2C, 0x16, + 0x9B, 0xDE, 0x70, 0x34, 0xAA, 0xFC, 0x2B, 0x53, + 0xF3, 0x22, 0x46, 0xE6, 0xE0, 0x3D, 0x0A, 0x48, + 0xF6, 0xAE, 0xA5, 0x04, 0xBF, 0xFF, 0x9B, 0x55, + 0x1C, 0xED, 0xB5, 0x83, 0x99, 0x93, 0xF8, 0x0B, + 0x86, 0xDC, 0x9E, 0x14, 0xC7, 0x88, 0x7F, 0x5C, + 0x4D, 0x03, 0x22, 0x23, 0x12, 0x79, 0x75, 0xE2 + }, + { + 0x60, 0x90, 0x84, 0xF1, 0x0B, 0xE4, 0x93, 0x96, + 0x16, 0x4A, 0x2D, 0x2F, 0x08, 0x3F, 0xC3, 0x33, + 0xC2, 0x99, 0xB3, 0x35, 0xB6, 0xA8, 0x29, 0x72, + 0x45, 0x57, 0xB1, 0x3B, 0x24, 0x1F, 0xD0, 0x2E, + 0xF8, 0x97, 0xE5, 0xA8, 0xF1, 0x0A, 0xC7, 0x68, + 0x62, 0xEA, 0x50, 0xC9, 0x36, 0xCF, 0x1C, 0x2C, + 0x6A, 0xDC, 0x39, 0x87, 0x19, 0x6A, 0xBC, 0xAC, + 0xCA, 0x09, 0x10, 0x69, 0xB0, 0x86, 0xD7, 0x53 + }, + { + 0x5E, 0xCA, 0x65, 0xDA, 0x94, 0xB4, 0x2C, 0x82, + 0x63, 0x1B, 0xB2, 0xF6, 0x9C, 0x11, 0x13, 0xEE, + 0xDA, 0x62, 0x7C, 0x06, 0x5D, 0xFD, 0xFB, 0x71, + 0x9A, 0x6D, 0x49, 0x2E, 0x8A, 0x1D, 0xF4, 0x63, + 0xD2, 0xC8, 0x5B, 0x09, 0x75, 0xFE, 0x37, 0xBE, + 0xFE, 0x3A, 0xA1, 0xFC, 0x17, 0x26, 0xD4, 0xE3, + 0x01, 0x56, 0xDE, 0x79, 0xF4, 0x4C, 0x6B, 0x61, + 0x5B, 0x1B, 0x47, 0x45, 0x4A, 0x82, 0x63, 0x9A + }, + { + 0x2E, 0x94, 0x93, 0x94, 0x44, 0x8E, 0x6B, 0x59, + 0x14, 0xDC, 0x60, 0xB0, 0x43, 0xFF, 0x88, 0xF3, + 0x74, 0xB3, 0x94, 0x2B, 0x28, 0xC8, 0xF6, 0x4F, + 0xB4, 0xFC, 0x68, 0xD8, 0xF8, 0x5A, 0x26, 0x65, + 0x60, 0xF2, 0xC6, 0x08, 0x22, 0xBC, 0x4C, 0xD2, + 0x77, 0x2E, 0xEB, 0x2F, 0x9F, 0xE2, 0xF7, 0x21, + 0x2A, 0xBF, 0x20, 0x09, 0x58, 0x3E, 0x82, 0x3C, + 0x33, 0x17, 0x6B, 0x10, 0xEC, 0x95, 0x0D, 0x5E + }, + { + 0x4C, 0xC6, 0xF1, 0x0A, 0x69, 0xC3, 0x43, 0x68, + 0xFB, 0x9F, 0x6A, 0xB6, 0x62, 0x54, 0x5E, 0x4D, + 0x30, 0x9D, 0x52, 0x25, 0xE3, 0xFC, 0x70, 0xB1, + 0xB6, 0xC2, 0x4F, 0x55, 0x62, 0xEF, 0xA5, 0xEF, + 0x23, 0xD9, 0xF0, 0x28, 0x67, 0xE2, 0xA7, 0x39, + 0x5E, 0x8C, 0x02, 0x74, 0xC9, 0x59, 0x27, 0x27, + 0x3B, 0x9A, 0xB2, 0xF7, 0x1B, 0x6C, 0xC2, 0xE5, + 0x3E, 0xE7, 0x46, 0x1D, 0x3C, 0x88, 0x62, 0x9F + }, + { + 0xFB, 0x06, 0x7F, 0x9C, 0xE3, 0x64, 0xB7, 0x5D, + 0x1C, 0x57, 0x04, 0xFC, 0x5F, 0xCE, 0xEC, 0x95, + 0xB3, 0xDD, 0x0F, 0x42, 0x04, 0xBD, 0x91, 0xAB, + 0x2C, 0x30, 0xFF, 0x7F, 0x93, 0xAD, 0xFF, 0x23, + 0xB8, 0x28, 0x38, 0x8B, 0x24, 0x9B, 0x49, 0xE6, + 0x4F, 0x3C, 0xF1, 0x02, 0xD6, 0xA5, 0xFF, 0x02, + 0xED, 0x43, 0x42, 0x51, 0xB5, 0xE0, 0xB1, 0xD6, + 0x46, 0x7F, 0x23, 0xB8, 0xFF, 0x47, 0xCE, 0x77 + }, + { + 0xF3, 0xB9, 0x55, 0xD3, 0x74, 0xD6, 0x2E, 0x58, + 0x24, 0xA6, 0x47, 0x1D, 0x1C, 0x2E, 0xED, 0xD8, + 0x55, 0xB9, 0x7B, 0x35, 0x95, 0x05, 0x8D, 0x69, + 0x62, 0xBA, 0x53, 0x0B, 0x49, 0x48, 0x12, 0x93, + 0x6E, 0xD6, 0xD5, 0x90, 0x0D, 0x3D, 0xCA, 0x3C, + 0x5A, 0x73, 0x4B, 0x90, 0x22, 0xC5, 0x8B, 0x5E, + 0x33, 0xB9, 0x93, 0xC6, 0xCC, 0xA5, 0x6E, 0x13, + 0x6A, 0x6F, 0x54, 0x12, 0xCA, 0x47, 0xB5, 0x61 + }, + { + 0x89, 0x95, 0x80, 0x2B, 0xC1, 0x8D, 0x93, 0xC1, + 0xB1, 0x51, 0xAA, 0xAF, 0xEB, 0xDF, 0xC7, 0x63, + 0x13, 0xE9, 0x94, 0xD4, 0x3B, 0x68, 0x7D, 0x08, + 0xB2, 0x90, 0x85, 0x57, 0x61, 0x9B, 0x7B, 0x71, + 0xCF, 0xB7, 0x5B, 0x8D, 0x67, 0x2A, 0x3A, 0xBC, + 0x51, 0x4D, 0xA3, 0x12, 0xC3, 0x42, 0x9E, 0x98, + 0x3C, 0xF4, 0xFC, 0xCB, 0x01, 0xF6, 0x8C, 0x07, + 0xC7, 0x9F, 0xCC, 0xF4, 0xA5, 0xF6, 0xA3, 0x36 + }, + { + 0x4C, 0xED, 0x6C, 0x9A, 0x6C, 0xF4, 0x59, 0x76, + 0x31, 0x9E, 0x2C, 0x82, 0xFE, 0xBF, 0x57, 0x8F, + 0xA5, 0xE4, 0x49, 0x06, 0xEC, 0xE8, 0x51, 0xCE, + 0x72, 0x8A, 0xE2, 0x74, 0x18, 0xA1, 0x55, 0x58, + 0x69, 0xB1, 0xC9, 0xCF, 0xBF, 0xA1, 0x48, 0xDD, + 0x7B, 0xF6, 0x71, 0x1B, 0xAE, 0xF6, 0xE3, 0x2C, + 0x17, 0x74, 0xA6, 0x2F, 0xF4, 0x0F, 0xC1, 0x52, + 0x8A, 0x87, 0x44, 0x75, 0xC3, 0x13, 0x29, 0xB1 + }, + { + 0x1C, 0x86, 0x76, 0x82, 0x3A, 0xA7, 0x56, 0x4B, + 0x25, 0xB7, 0x7A, 0x57, 0x18, 0x5F, 0xD1, 0x5A, + 0x1F, 0x65, 0x23, 0x1B, 0xD0, 0xFC, 0xB4, 0x1A, + 0xD3, 0x6C, 0xAB, 0x6C, 0xDC, 0x2D, 0x35, 0x2A, + 0x83, 0x55, 0x52, 0x0B, 0x3F, 0xA8, 0x87, 0x98, + 0x63, 0x1F, 0x0A, 0x81, 0xD9, 0x0B, 0x6C, 0x63, + 0xAB, 0x51, 0x8F, 0x89, 0xA4, 0xA0, 0xF3, 0x9E, + 0x8F, 0x83, 0x46, 0x3B, 0x04, 0x4D, 0x9C, 0xED + }, + { + 0x91, 0x75, 0x57, 0x5D, 0xFC, 0x3C, 0x37, 0xCD, + 0xD3, 0x17, 0x0D, 0xAB, 0xB2, 0xA3, 0x09, 0xE7, + 0xD7, 0xB1, 0xF9, 0xF2, 0xA8, 0xE0, 0x35, 0x1C, + 0x5D, 0xD7, 0x73, 0x75, 0xF7, 0x22, 0x7F, 0x55, + 0xB8, 0x46, 0x28, 0xA0, 0x46, 0xA9, 0xFF, 0xB6, + 0x30, 0xC5, 0x8A, 0x16, 0x86, 0xD5, 0xAB, 0xC0, + 0x36, 0xA1, 0x15, 0xEA, 0x5C, 0x6E, 0x9F, 0x52, + 0x25, 0x38, 0x21, 0x89, 0x20, 0x22, 0x7F, 0xA9 + }, + { + 0xA7, 0xB8, 0x7E, 0x0F, 0x3C, 0xE8, 0x5D, 0x00, + 0xFA, 0x1A, 0x2A, 0x31, 0x92, 0x6E, 0x73, 0x52, + 0x0A, 0x2D, 0x02, 0xAE, 0x45, 0x2D, 0xB3, 0x7A, + 0xE6, 0xF2, 0x69, 0x2D, 0x04, 0xA3, 0x24, 0x46, + 0xC0, 0xAB, 0x11, 0x15, 0xD3, 0xBA, 0xFB, 0x33, + 0x85, 0x3F, 0xCE, 0x19, 0xA9, 0x3E, 0xED, 0xBC, + 0x27, 0x2A, 0xDE, 0x75, 0xC7, 0x4C, 0x74, 0x9E, + 0xAA, 0xDC, 0x75, 0xEA, 0x67, 0xCC, 0x2E, 0x7F + }, + { + 0xC5, 0x4C, 0xD9, 0x22, 0x98, 0x4E, 0x60, 0xD6, + 0x2C, 0xF5, 0x53, 0xBA, 0x05, 0x75, 0x11, 0x6E, + 0xE4, 0x73, 0x51, 0x4B, 0xF1, 0xE6, 0x74, 0x34, + 0x63, 0x00, 0x39, 0xBE, 0xAA, 0xBC, 0xA7, 0x7B, + 0xD4, 0x00, 0x94, 0x77, 0xA1, 0x32, 0xFE, 0x9E, + 0x47, 0xFF, 0x2F, 0x88, 0x72, 0xAD, 0x28, 0x16, + 0x3B, 0xDA, 0x0C, 0xBE, 0xC4, 0xFA, 0x83, 0xA4, + 0xEA, 0xF9, 0x12, 0x95, 0xA6, 0x9C, 0x19, 0x79 + }, + { + 0x42, 0x7F, 0xF4, 0x3E, 0xC6, 0x66, 0xD3, 0x40, + 0x5B, 0xA1, 0x9B, 0xC7, 0x3F, 0x7A, 0x7A, 0x60, + 0x46, 0xFC, 0x85, 0xA2, 0x65, 0x19, 0xB6, 0x33, + 0x28, 0xC0, 0x1D, 0x52, 0xBE, 0x0D, 0xFC, 0xB0, + 0x00, 0x24, 0x5A, 0x7F, 0x6D, 0x85, 0x1B, 0xA3, + 0x93, 0xE2, 0xB3, 0x5E, 0x35, 0xB6, 0x0E, 0x6C, + 0x4A, 0x95, 0x35, 0xE4, 0x53, 0xC3, 0xF2, 0xC9, + 0xD3, 0xB4, 0x73, 0xDE, 0xF8, 0x99, 0x16, 0x10 + }, + { + 0x10, 0x5A, 0xD4, 0xC5, 0xA6, 0x26, 0xE4, 0xDB, + 0x30, 0x4B, 0x16, 0x69, 0xB4, 0x10, 0x0C, 0xB1, + 0x99, 0xEA, 0xF6, 0x03, 0x5F, 0xD2, 0x1A, 0x55, + 0x71, 0xE4, 0x64, 0xC2, 0x4A, 0xF7, 0xC1, 0x75, + 0x2E, 0x7C, 0xB1, 0xB6, 0xDE, 0x63, 0x23, 0xF2, + 0x92, 0xB0, 0x53, 0x35, 0xF5, 0x2B, 0x62, 0xE1, + 0x28, 0x24, 0x0E, 0x75, 0xA0, 0x8A, 0xC4, 0x0C, + 0x1B, 0xAC, 0x4E, 0x54, 0x54, 0x56, 0xEC, 0xA6 + }, + { + 0xA0, 0x05, 0xB3, 0xBE, 0xE8, 0x9B, 0x9F, 0x82, + 0xC8, 0x68, 0xFD, 0x14, 0x84, 0xD1, 0xE0, 0xC2, + 0x01, 0xEE, 0xAE, 0x49, 0x63, 0x9F, 0x6D, 0xA4, + 0x62, 0x82, 0x3E, 0xE5, 0x7E, 0xD6, 0x82, 0xD7, + 0x66, 0x92, 0x48, 0x65, 0xBD, 0x27, 0xA9, 0xAC, + 0x14, 0x45, 0xA5, 0xC5, 0xC4, 0xA2, 0xF1, 0x02, + 0x5F, 0x63, 0xDA, 0x18, 0xE7, 0xF9, 0x0E, 0xDA, + 0xCE, 0x01, 0xC2, 0x65, 0x7E, 0xB7, 0xBB, 0xC1 + }, + { + 0x41, 0x5A, 0xA0, 0x56, 0x6D, 0xE6, 0x6E, 0x8A, + 0x27, 0x9C, 0x3C, 0x37, 0x25, 0x3B, 0x31, 0xFF, + 0x77, 0x93, 0x48, 0x8E, 0xFE, 0xAE, 0x36, 0x0F, + 0xF7, 0xCE, 0x31, 0xB8, 0xBE, 0xE7, 0x82, 0x95, + 0x11, 0x62, 0x17, 0xA1, 0x83, 0xF2, 0xF1, 0xB1, + 0xF1, 0x02, 0xA4, 0x01, 0xD3, 0xC4, 0x80, 0xC9, + 0x81, 0x84, 0xD5, 0xCF, 0xCA, 0x9D, 0x81, 0xC4, + 0x67, 0xC4, 0x72, 0xF8, 0x7C, 0x6C, 0x3B, 0xEC + }, + { + 0xAA, 0xBD, 0xD1, 0x39, 0x0A, 0x76, 0x90, 0x72, + 0x4D, 0x5A, 0xDB, 0xA5, 0x94, 0xB0, 0xA6, 0xCC, + 0xBD, 0x38, 0x52, 0x72, 0xD3, 0x34, 0xA2, 0x56, + 0xFE, 0x69, 0xC8, 0x99, 0x83, 0x78, 0xBB, 0xC7, + 0x62, 0x1A, 0x42, 0xF2, 0x07, 0x40, 0x44, 0x4D, + 0xD4, 0x8E, 0x35, 0xB2, 0xB4, 0xB7, 0x5F, 0xD0, + 0x8E, 0x3A, 0x04, 0x46, 0xF8, 0xB3, 0x4C, 0xB6, + 0x73, 0x78, 0xDD, 0xAE, 0x35, 0xED, 0x92, 0xAE + }, + { + 0xFD, 0xDF, 0x0E, 0x62, 0x18, 0x98, 0x7B, 0x32, + 0x97, 0x24, 0x07, 0x79, 0x4A, 0x1B, 0x66, 0x0D, + 0x76, 0x32, 0xC4, 0xBF, 0xC4, 0x23, 0xAA, 0x4C, + 0xC2, 0x90, 0x19, 0xA3, 0xE7, 0xE7, 0x35, 0x5F, + 0x66, 0xC8, 0x61, 0x4D, 0xC8, 0x30, 0x8E, 0x8E, + 0xE8, 0x76, 0x9A, 0x20, 0xB0, 0x87, 0x85, 0x7C, + 0xB4, 0x22, 0xA4, 0x05, 0x68, 0x8A, 0xAC, 0x76, + 0x82, 0xF3, 0x5D, 0xCF, 0x2E, 0x67, 0x7E, 0xD4 + }, + { + 0xAA, 0x26, 0x38, 0x76, 0xA1, 0x60, 0x1A, 0x9E, + 0xA1, 0x17, 0x5D, 0x4B, 0x6B, 0x43, 0x3C, 0x02, + 0x60, 0xDC, 0x56, 0x59, 0xC3, 0xBB, 0x00, 0x06, + 0x8A, 0x73, 0x6D, 0x19, 0x9E, 0x43, 0xCF, 0xFC, + 0xBA, 0xA9, 0x31, 0x81, 0x7F, 0x61, 0x2A, 0xE4, + 0x0C, 0x7B, 0x2C, 0x13, 0xD0, 0xBF, 0xC1, 0x5F, + 0xF7, 0x9B, 0x6C, 0x3E, 0x49, 0xA3, 0x15, 0x59, + 0xCA, 0xF8, 0x91, 0xED, 0xB9, 0x61, 0x38, 0x9A + }, + { + 0x2B, 0x9C, 0x10, 0x56, 0xBD, 0x03, 0xA0, 0xB5, + 0x26, 0x0D, 0x7D, 0xC0, 0x4D, 0x6D, 0x73, 0xB9, + 0x41, 0xAD, 0x9A, 0x34, 0xCE, 0x46, 0x31, 0xC5, + 0xBE, 0x05, 0x4F, 0xAE, 0xCE, 0xD8, 0x1F, 0xFC, + 0x69, 0x39, 0xB5, 0x7F, 0xA0, 0x48, 0xC3, 0xB0, + 0x8F, 0xA2, 0x1E, 0xDC, 0x24, 0x27, 0x74, 0x8F, + 0xBE, 0x88, 0x5B, 0x8E, 0x1B, 0xB7, 0x9C, 0x3E, + 0x4D, 0xF3, 0x57, 0xF2, 0xB7, 0xCA, 0x44, 0x66 + }, + { + 0x61, 0x80, 0xA8, 0xB3, 0xB9, 0x50, 0x3E, 0x7C, + 0xB2, 0x44, 0x63, 0x90, 0xD4, 0x6B, 0xE1, 0x6A, + 0xB4, 0xA3, 0x20, 0x08, 0xD4, 0x1A, 0x53, 0x54, + 0xC9, 0x82, 0xCA, 0xAD, 0x5E, 0x18, 0x10, 0xC4, + 0xBB, 0x95, 0xF0, 0x61, 0x14, 0x70, 0x25, 0xA5, + 0xD6, 0xE7, 0xDE, 0xBE, 0x31, 0x42, 0xC4, 0x3E, + 0x7A, 0xAD, 0x54, 0xB3, 0x56, 0x68, 0x48, 0x90, + 0xA8, 0xB5, 0x95, 0xFD, 0xFF, 0x7C, 0xD3, 0x75 + }, + { + 0xC6, 0xCA, 0x39, 0x4E, 0xEB, 0x2C, 0x86, 0x3F, + 0x21, 0x9C, 0x27, 0x1E, 0x59, 0x52, 0x27, 0x67, + 0xEB, 0x58, 0xEF, 0xB5, 0x38, 0x2A, 0x29, 0x90, + 0x27, 0x41, 0x7A, 0x94, 0x3C, 0x10, 0xC1, 0xAF, + 0xFB, 0xD7, 0x0B, 0xC5, 0x12, 0x49, 0x69, 0x7F, + 0x6D, 0xE1, 0x9E, 0x6A, 0x2A, 0x3C, 0x04, 0x9F, + 0xE1, 0xD5, 0x97, 0xCA, 0xD9, 0x8E, 0x2C, 0x98, + 0x88, 0x71, 0x16, 0x09, 0x04, 0x66, 0xC7, 0xB8 + }, + { + 0xDE, 0x9D, 0xFD, 0x36, 0x01, 0xFE, 0xA9, 0x1D, + 0x9A, 0x2C, 0x93, 0xA6, 0x5C, 0xF5, 0x8B, 0x76, + 0x92, 0x9D, 0xFB, 0x1F, 0x0A, 0xF2, 0x8A, 0xC0, + 0x64, 0x11, 0xE3, 0xF1, 0xCB, 0xC0, 0xC4, 0x7B, + 0xFD, 0xDC, 0x88, 0x74, 0x6D, 0xEE, 0xF7, 0x1E, + 0xC4, 0xE8, 0x8A, 0x53, 0x65, 0x0E, 0x63, 0x03, + 0xA3, 0x72, 0x58, 0x19, 0xDB, 0x88, 0x8D, 0xE7, + 0x1E, 0xAE, 0xED, 0x0D, 0xBE, 0x71, 0xC8, 0x34 + }, + { + 0x37, 0x07, 0xF5, 0xF2, 0x70, 0xAC, 0xF1, 0x73, + 0xC3, 0x9F, 0x0E, 0xDB, 0xEF, 0xD8, 0x79, 0x4A, + 0x50, 0x43, 0x39, 0x0D, 0x3D, 0x36, 0x3A, 0xB6, + 0xF3, 0x79, 0x1D, 0x6B, 0x4E, 0x4A, 0x7D, 0x69, + 0x52, 0xCC, 0xD1, 0xDD, 0x77, 0x30, 0xD7, 0x43, + 0x79, 0x99, 0xCF, 0x79, 0xC1, 0xF5, 0x0F, 0xFC, + 0x48, 0x03, 0x73, 0x93, 0x4C, 0x7B, 0x27, 0xC5, + 0xBC, 0x78, 0x65, 0x91, 0xD2, 0xF2, 0xDF, 0xC2 + }, + { + 0x81, 0x38, 0x27, 0x67, 0x33, 0x92, 0x39, 0x89, + 0x10, 0x9F, 0xD5, 0xEB, 0x3D, 0xE7, 0x57, 0x65, + 0x9C, 0x92, 0xA4, 0xF7, 0x32, 0xC0, 0x6F, 0x67, + 0x86, 0x86, 0x30, 0xE7, 0xEA, 0xDE, 0x45, 0x3D, + 0x1E, 0x70, 0xE6, 0xF5, 0xB7, 0x23, 0x19, 0x1E, + 0x75, 0x9F, 0x36, 0x6F, 0xB9, 0x4F, 0xC2, 0x9E, + 0x15, 0xF5, 0xB5, 0xE0, 0x39, 0xED, 0x4F, 0x6D, + 0x76, 0x64, 0x02, 0x44, 0x1E, 0x68, 0xFA, 0xAA + }, + { + 0x49, 0xEF, 0xCE, 0x89, 0x3D, 0xD6, 0xAB, 0x15, + 0x9F, 0x57, 0x50, 0xB8, 0xC0, 0x63, 0xBB, 0xA6, + 0x0F, 0x52, 0x95, 0x6F, 0x35, 0xA4, 0x59, 0x2C, + 0xB8, 0xC9, 0xE2, 0xB4, 0x6B, 0xCF, 0x53, 0xAC, + 0xC9, 0x61, 0xD3, 0x72, 0xC7, 0x6F, 0x35, 0x26, + 0xE6, 0xC2, 0xA3, 0x9B, 0xB3, 0x00, 0x93, 0x51, + 0x2F, 0x0A, 0x8E, 0x43, 0x74, 0xD3, 0xE8, 0x0A, + 0x5E, 0xEA, 0xD4, 0x98, 0xCA, 0xB3, 0xF2, 0x3C + }, + { + 0x0B, 0x4A, 0x37, 0x2D, 0xB7, 0xA7, 0x84, 0x99, + 0x01, 0x67, 0x77, 0xEA, 0xC3, 0xF6, 0xA1, 0x94, + 0xB6, 0xA5, 0xC9, 0x7C, 0x7A, 0xE4, 0x26, 0x5E, + 0x8A, 0xE1, 0x2A, 0xAE, 0x40, 0x6F, 0xCC, 0x51, + 0x91, 0xED, 0xB3, 0x20, 0x7B, 0xF2, 0x0F, 0x1E, + 0x9C, 0x6D, 0x64, 0xC6, 0xDA, 0xBF, 0x2B, 0xB3, + 0x10, 0xD7, 0x97, 0x4B, 0xB2, 0x62, 0x4D, 0x3F, + 0x70, 0x29, 0x40, 0x79, 0x9C, 0x40, 0xA7, 0x97 + }, + { + 0x25, 0x85, 0x06, 0x8D, 0x8F, 0x98, 0x30, 0xED, + 0x94, 0xB6, 0x32, 0x00, 0xB9, 0x4C, 0x27, 0xC0, + 0x1B, 0x1D, 0x1B, 0x5B, 0x09, 0xAC, 0x94, 0xE8, + 0x9B, 0xC2, 0x7D, 0xBE, 0x48, 0x0F, 0xCA, 0x8D, + 0xEE, 0x8B, 0xB8, 0x16, 0x59, 0x53, 0xFB, 0x4C, + 0x81, 0x07, 0x5F, 0xEB, 0x51, 0x06, 0x56, 0x23, + 0x6A, 0xA6, 0xCC, 0x91, 0x3D, 0x4E, 0xED, 0x83, + 0xC3, 0x8C, 0x47, 0xCF, 0x93, 0xD8, 0xBC, 0x4E + }, + { + 0x01, 0x85, 0x29, 0xDA, 0xC4, 0x40, 0x00, 0x9F, + 0xC0, 0x47, 0x28, 0x64, 0x94, 0x90, 0x76, 0x37, + 0x80, 0xCC, 0x9A, 0x84, 0x8A, 0x18, 0xE2, 0x53, + 0xC9, 0x68, 0x32, 0x75, 0xA8, 0x98, 0x7E, 0xE4, + 0xA8, 0x98, 0x5D, 0xE7, 0x8B, 0x36, 0xDB, 0x15, + 0xF7, 0xB8, 0x0B, 0x6B, 0xDD, 0xCD, 0x2E, 0x35, + 0xDC, 0xC8, 0xA9, 0x3F, 0xA6, 0xDE, 0xDE, 0x3A, + 0x27, 0xE5, 0xDC, 0x6C, 0x3C, 0x50, 0x33, 0xC3 + }, + { + 0xD2, 0xC6, 0xDA, 0x9F, 0x0B, 0x8B, 0xF4, 0xAB, + 0x4C, 0x7F, 0x14, 0x11, 0x20, 0x5B, 0x76, 0x4C, + 0xCA, 0x85, 0xFC, 0x68, 0xDF, 0x00, 0x05, 0xAC, + 0xDE, 0xC6, 0xC6, 0xF1, 0xF3, 0xEF, 0xDF, 0x63, + 0xCD, 0xB4, 0xD8, 0xA4, 0xD5, 0xA8, 0x47, 0x6B, + 0xC3, 0x55, 0x2D, 0x75, 0xE8, 0x0B, 0x5F, 0x2D, + 0x7B, 0x90, 0x16, 0xCC, 0xAB, 0xDF, 0x10, 0x79, + 0xFA, 0x58, 0x22, 0x03, 0x9E, 0x2E, 0x2B, 0xAD + }, + { + 0x1B, 0x9D, 0x94, 0xF7, 0x93, 0xAF, 0x59, 0x8E, + 0x6A, 0x75, 0x6F, 0xC0, 0x8D, 0x8D, 0xF5, 0x02, + 0xA2, 0x71, 0x0A, 0x6B, 0x0A, 0xD5, 0x5A, 0xDF, + 0x24, 0xF2, 0x46, 0x3A, 0x0B, 0xAD, 0xBB, 0xB2, + 0xAA, 0x0D, 0x81, 0x58, 0xB5, 0xF9, 0xEF, 0xE5, + 0x63, 0x04, 0x0E, 0x8B, 0xE6, 0x96, 0x7E, 0xEA, + 0x9F, 0x58, 0x68, 0x5C, 0x50, 0xB7, 0x26, 0x02, + 0xCA, 0xAC, 0x8B, 0xA3, 0x96, 0x3C, 0xE4, 0xD0 + }, + { + 0xE0, 0xDD, 0xC7, 0xAB, 0x7F, 0xCE, 0xA3, 0x76, + 0x32, 0x73, 0xFF, 0xAB, 0xEA, 0x75, 0x26, 0x34, + 0x1B, 0x5C, 0x80, 0x9B, 0x16, 0x3B, 0xA0, 0x31, + 0xDA, 0x59, 0x86, 0x23, 0xBD, 0xF4, 0x61, 0x55, + 0xB0, 0x91, 0x0C, 0x7E, 0x0E, 0x75, 0x02, 0xC8, + 0x48, 0x90, 0x16, 0xD6, 0xA3, 0xDB, 0xC4, 0x1D, + 0x73, 0x06, 0xB1, 0x03, 0xE2, 0x9C, 0x49, 0xF2, + 0x74, 0x53, 0xE5, 0xD3, 0x3D, 0x2D, 0x3F, 0xBC + }, + { + 0xFF, 0x2B, 0x9B, 0x96, 0xCA, 0x18, 0x24, 0xA1, + 0xB6, 0x86, 0xD0, 0x13, 0x69, 0xFE, 0xE7, 0x07, + 0x92, 0x3C, 0xD1, 0x9C, 0x48, 0x0C, 0xBF, 0x84, + 0xBA, 0xDD, 0xF0, 0xA4, 0x05, 0x47, 0x19, 0xDC, + 0x17, 0xB7, 0x60, 0xF9, 0xC1, 0xD9, 0xA9, 0x7D, + 0x2C, 0x91, 0xE8, 0xE6, 0xD8, 0x73, 0xEF, 0xF1, + 0xB0, 0x29, 0x72, 0x45, 0xC7, 0x4A, 0xA8, 0x44, + 0x6C, 0x09, 0xC2, 0xDD, 0xD0, 0x3C, 0xBA, 0xE7 + }, + { + 0x32, 0xA6, 0x7A, 0xD5, 0x1E, 0x27, 0xF2, 0xC5, + 0x2B, 0x56, 0xD4, 0x78, 0x9E, 0x93, 0x02, 0xCE, + 0x53, 0x77, 0xE5, 0xD5, 0x55, 0x87, 0xAE, 0xA6, + 0x15, 0xF2, 0x64, 0xEC, 0x7D, 0x28, 0xDD, 0x34, + 0x48, 0xB2, 0x7A, 0x41, 0x69, 0xC5, 0x6F, 0x58, + 0x95, 0x3B, 0xC0, 0x5B, 0x99, 0x23, 0xC8, 0x2F, + 0x1E, 0x4F, 0x41, 0x93, 0x34, 0x10, 0x55, 0x2A, + 0x16, 0xC9, 0xA2, 0xBE, 0xC0, 0xA1, 0x02, 0x42 + }, + { + 0x00, 0x51, 0x6D, 0x77, 0x12, 0x7D, 0x41, 0x5C, + 0x48, 0xF5, 0x16, 0x8B, 0xE3, 0x3A, 0xFC, 0x87, + 0xD6, 0x5B, 0x7F, 0x88, 0x63, 0x6A, 0x7B, 0xCF, + 0x38, 0x74, 0xB4, 0xAA, 0xB7, 0x17, 0x31, 0x0B, + 0x42, 0xD9, 0xF2, 0xCB, 0x26, 0xC4, 0x74, 0xF2, + 0xD1, 0x31, 0x95, 0xB2, 0x75, 0x95, 0x98, 0x68, + 0x59, 0x1F, 0xEC, 0xC9, 0xD1, 0xDA, 0x6A, 0x72, + 0xF0, 0xF6, 0x0D, 0x38, 0xAB, 0xEF, 0xAB, 0xB7 + }, + { + 0xF5, 0xA3, 0xEA, 0x36, 0x66, 0xBA, 0x3A, 0x5E, + 0xAC, 0x38, 0x91, 0xB2, 0xD7, 0xF2, 0xE2, 0xE1, + 0xFB, 0x05, 0x31, 0xA9, 0x6D, 0x31, 0x5C, 0x6C, + 0xE8, 0xDD, 0xD7, 0x12, 0x2A, 0x6B, 0x7F, 0x00, + 0x57, 0x09, 0x01, 0xA7, 0xD2, 0xD9, 0x1B, 0xC4, + 0x3F, 0x7B, 0xB3, 0x58, 0xF4, 0x45, 0x27, 0x01, + 0x23, 0x87, 0x53, 0xE6, 0x46, 0x11, 0x41, 0xAB, + 0x8E, 0xCE, 0x31, 0x3C, 0xB1, 0x23, 0x9A, 0xB6 + }, + { + 0x78, 0x35, 0xD9, 0x66, 0xA9, 0x49, 0x95, 0xBB, + 0x82, 0x27, 0xDC, 0x42, 0xAF, 0xCE, 0x9D, 0x83, + 0x83, 0x69, 0x02, 0x4C, 0xEF, 0x22, 0xD4, 0x67, + 0x38, 0x03, 0x1A, 0x50, 0xCB, 0x79, 0x46, 0x1F, + 0x53, 0xCF, 0xAC, 0x4D, 0xF0, 0x3C, 0x46, 0x52, + 0xFF, 0x3F, 0xE4, 0x1A, 0x64, 0x0E, 0x6C, 0x7C, + 0x30, 0x9B, 0xA2, 0x61, 0x0C, 0x9D, 0xBB, 0x44, + 0x9C, 0xE4, 0xFD, 0x51, 0x42, 0xE6, 0x9C, 0xE3 + }, + { + 0x4D, 0xD3, 0xB7, 0x00, 0x80, 0x53, 0x43, 0x57, + 0x52, 0xD2, 0x97, 0xA8, 0x5B, 0xC2, 0x32, 0x29, + 0xD1, 0xD4, 0xB7, 0x3E, 0x30, 0x51, 0x7A, 0x70, + 0x90, 0xDF, 0x52, 0x7E, 0xDF, 0x5F, 0x85, 0x35, + 0x25, 0x78, 0x67, 0x60, 0xD6, 0x62, 0x58, 0xBC, + 0x8C, 0xD5, 0xDF, 0xEA, 0x28, 0xFD, 0xD6, 0x24, + 0x7A, 0x54, 0x68, 0x91, 0x6F, 0xF1, 0xA8, 0xAA, + 0x87, 0xF4, 0xA2, 0xA4, 0x3E, 0xDA, 0xF1, 0x2E + }, + { + 0xBF, 0xA5, 0xD7, 0xD6, 0x06, 0xC9, 0x9F, 0x2E, + 0x0F, 0x38, 0xD0, 0x45, 0x24, 0x82, 0x4B, 0xE3, + 0x8D, 0xA6, 0x3E, 0x1A, 0xDC, 0xEE, 0x95, 0xB6, + 0x87, 0x1C, 0x66, 0x5C, 0x86, 0x63, 0xBE, 0x83, + 0xF3, 0x4E, 0x67, 0x27, 0x49, 0xC0, 0xB0, 0xB3, + 0x35, 0x99, 0xB2, 0x98, 0x5C, 0x14, 0x40, 0xB5, + 0x91, 0x7F, 0xAB, 0xEA, 0x24, 0x32, 0xC5, 0x4E, + 0xF7, 0xB5, 0xC9, 0xE1, 0x6D, 0xE8, 0x72, 0x62 + }, + { + 0x0A, 0x93, 0x33, 0x82, 0x02, 0xAE, 0x5E, 0x6C, + 0x96, 0x9F, 0x09, 0xB7, 0x25, 0x5C, 0x9A, 0x77, + 0xFB, 0xF1, 0x95, 0x3C, 0x5F, 0xAE, 0x6D, 0x6A, + 0x04, 0x73, 0x04, 0x8B, 0x40, 0x1D, 0x06, 0xBA, + 0xA9, 0x49, 0xED, 0xD0, 0x29, 0x17, 0x17, 0x5F, + 0x3A, 0xD2, 0x50, 0xF0, 0x1D, 0x04, 0x8C, 0xC8, + 0x8F, 0x0E, 0xB9, 0x53, 0x51, 0xCA, 0x8B, 0xA8, + 0x3C, 0xAB, 0x06, 0x0B, 0x4B, 0x0E, 0x67, 0x23 + }, + { + 0x61, 0x8B, 0x7E, 0x56, 0xDB, 0xF8, 0x6C, 0x44, + 0x50, 0x05, 0xF1, 0x3B, 0x31, 0x61, 0x1A, 0x5F, + 0xBA, 0xB9, 0x85, 0xE3, 0xE7, 0xF0, 0x24, 0x36, + 0x58, 0x3B, 0x36, 0x05, 0xA9, 0x9F, 0x0A, 0x78, + 0xF1, 0xCC, 0x8A, 0xFB, 0x18, 0x82, 0xB7, 0xF1, + 0xAB, 0xF1, 0x3B, 0x28, 0xA5, 0xF5, 0x49, 0x36, + 0xBA, 0x62, 0xD8, 0xCB, 0x62, 0x6C, 0x6E, 0x36, + 0xF2, 0xB7, 0x55, 0x9D, 0xC2, 0x63, 0x64, 0x77 + }, + { + 0xF8, 0x02, 0x9D, 0x23, 0x1E, 0xF7, 0x35, 0x37, + 0x49, 0xBF, 0xAF, 0xAD, 0x84, 0xD3, 0xEC, 0xB8, + 0x41, 0x80, 0xB1, 0xD5, 0x19, 0x8B, 0x02, 0x38, + 0x64, 0x3B, 0xD3, 0x7A, 0xC9, 0x39, 0xC5, 0x27, + 0x92, 0xDD, 0x46, 0x51, 0x07, 0xBC, 0xD9, 0xC0, + 0xE7, 0xA4, 0x55, 0x68, 0x10, 0xA0, 0xD6, 0x26, + 0x69, 0xA2, 0xF3, 0xD2, 0x1F, 0x1C, 0xA1, 0xC0, + 0x94, 0x42, 0x04, 0x4F, 0x95, 0x39, 0xD4, 0x39 + }, + { + 0xCC, 0x72, 0x22, 0xBB, 0xFA, 0x5B, 0x4D, 0x09, + 0x35, 0x05, 0x2E, 0xFC, 0x6C, 0x22, 0x64, 0x0A, + 0x2D, 0x28, 0x04, 0xD5, 0x1A, 0xF6, 0x8F, 0x80, + 0xB1, 0xDB, 0x91, 0x8B, 0x0A, 0x90, 0xF6, 0x61, + 0xC5, 0x54, 0x71, 0x86, 0x70, 0x75, 0x3B, 0xE2, + 0x04, 0x29, 0xD8, 0x19, 0xD1, 0xE7, 0xC9, 0x37, + 0x2D, 0x13, 0x2A, 0x3B, 0x42, 0xE9, 0x40, 0x6B, + 0x25, 0xAD, 0x8B, 0x1A, 0x1D, 0x49, 0x3F, 0x0E + }, + { + 0x95, 0xC1, 0xFB, 0x27, 0xA9, 0x76, 0x3E, 0xE1, + 0x4E, 0x5F, 0x0A, 0xFD, 0xB9, 0xEF, 0x2B, 0x51, + 0x59, 0x4C, 0xC5, 0xBB, 0x59, 0x19, 0x11, 0x9D, + 0xAD, 0x38, 0xA7, 0x60, 0xC5, 0x1E, 0x3E, 0x47, + 0x7B, 0x53, 0x16, 0x34, 0x6D, 0x32, 0x15, 0x22, + 0xD0, 0xC6, 0xE8, 0xA5, 0x51, 0x70, 0xAC, 0x2E, + 0x35, 0xB3, 0xA4, 0x5A, 0x58, 0x4C, 0x47, 0x56, + 0x7E, 0xC9, 0x39, 0x55, 0x4B, 0xB0, 0x6F, 0x63 + }, + { + 0x40, 0xF9, 0xF4, 0x05, 0x6E, 0x36, 0x17, 0xD4, + 0x5E, 0x43, 0x63, 0x9A, 0x92, 0x8B, 0xD1, 0xA8, + 0xD7, 0xE2, 0xF3, 0x0B, 0x04, 0x84, 0xA3, 0xA1, + 0xDA, 0x98, 0x65, 0x97, 0xB9, 0xDB, 0x63, 0x4C, + 0x8D, 0xE4, 0x2C, 0xB3, 0xDF, 0xD3, 0x68, 0xBE, + 0x94, 0xC3, 0xA6, 0x74, 0xC1, 0x82, 0xDD, 0xA5, + 0x51, 0x48, 0xE5, 0xB4, 0x5A, 0xB2, 0x93, 0x0B, + 0x82, 0xB7, 0xB5, 0x2D, 0xAF, 0x6E, 0x40, 0x13 + }, + { + 0xCA, 0xE5, 0x1F, 0x07, 0x3D, 0x9A, 0xAD, 0x1D, + 0xDF, 0xA8, 0x35, 0x92, 0x5C, 0xC2, 0x99, 0x44, + 0x68, 0x4C, 0xE1, 0x69, 0x60, 0x3B, 0x10, 0x2F, + 0x52, 0xDC, 0x86, 0x36, 0x4D, 0x5E, 0xFE, 0x49, + 0x00, 0x81, 0x20, 0x9D, 0x86, 0x09, 0x48, 0x26, + 0xF5, 0x35, 0xBF, 0x5E, 0xD3, 0xD0, 0xF5, 0xB8, + 0x34, 0x55, 0x45, 0xE7, 0x9C, 0x30, 0x07, 0x6C, + 0xB7, 0x52, 0x1A, 0x0D, 0x85, 0x79, 0xCD, 0xD8 + }, + { + 0xBD, 0x99, 0x85, 0x56, 0x43, 0x5D, 0xC4, 0x2C, + 0x7C, 0x01, 0xD3, 0x12, 0x18, 0xD8, 0xF8, 0xAF, + 0x66, 0x53, 0x6A, 0xDC, 0xE6, 0xB7, 0x20, 0xC0, + 0xB9, 0x0E, 0xAF, 0x48, 0x9C, 0xB3, 0xFF, 0xD4, + 0x91, 0xDC, 0xF0, 0x32, 0xB5, 0x9B, 0xA1, 0x04, + 0x25, 0xAF, 0xCC, 0x6E, 0x41, 0xCA, 0x97, 0x73, + 0xD4, 0xAE, 0x89, 0x2A, 0xCF, 0xAB, 0x50, 0x62, + 0xFC, 0x30, 0xE2, 0x7F, 0xD7, 0xBD, 0x07, 0x64 + }, + { + 0x77, 0x17, 0x43, 0x8B, 0x4E, 0x4A, 0xF9, 0xC0, + 0xCA, 0x98, 0x42, 0x27, 0xFB, 0x9A, 0x6E, 0x0E, + 0xAF, 0xD0, 0x21, 0xAD, 0x7E, 0x1F, 0x17, 0x0F, + 0x85, 0x3E, 0x55, 0x55, 0xE6, 0x9A, 0xD5, 0x83, + 0x5A, 0xEB, 0x88, 0x15, 0xE6, 0x5E, 0x77, 0x14, + 0x34, 0x0E, 0x91, 0x6D, 0x93, 0x4D, 0x26, 0x7D, + 0x06, 0xD1, 0x8D, 0x90, 0x59, 0x1D, 0x59, 0xE0, + 0xAD, 0x29, 0xBD, 0x82, 0xE7, 0xE0, 0xC0, 0x30 + }, + { + 0x4E, 0x21, 0x89, 0x12, 0x5E, 0x98, 0x72, 0xAC, + 0x3C, 0x17, 0xF7, 0xEA, 0x46, 0xB9, 0x58, 0x9A, + 0xB1, 0x24, 0x11, 0xFA, 0x34, 0x0C, 0x2F, 0x58, + 0xAF, 0x3B, 0x83, 0x3F, 0x3B, 0xF9, 0x3E, 0xDD, + 0x03, 0xA9, 0xDC, 0x61, 0x18, 0x2A, 0x47, 0x82, + 0xD6, 0x93, 0xE4, 0xE4, 0x2E, 0xB8, 0xD5, 0xD2, + 0x79, 0x7A, 0x23, 0x12, 0xF0, 0x08, 0x14, 0x69, + 0xB4, 0x25, 0xD9, 0x3B, 0x77, 0x1F, 0x9C, 0xD3 + }, + { + 0x3E, 0x5D, 0x22, 0xAA, 0x70, 0x11, 0xC2, 0x3F, + 0xC1, 0x86, 0xD9, 0x65, 0x4A, 0x9D, 0x64, 0x5D, + 0x97, 0xB0, 0x36, 0xDB, 0xDC, 0xD7, 0x9D, 0xEF, + 0x90, 0x87, 0x8E, 0xFE, 0x0C, 0xA3, 0xF5, 0xB2, + 0xA1, 0x71, 0x60, 0xE1, 0x0A, 0xF0, 0xF3, 0x2E, + 0x3A, 0xB1, 0x55, 0xA2, 0x0B, 0x59, 0x6B, 0x78, + 0x5E, 0x31, 0x56, 0x65, 0xCE, 0xB1, 0xEE, 0x43, + 0x7D, 0xBB, 0x71, 0x32, 0x97, 0x8A, 0x0B, 0xC1 + }, + { + 0x90, 0xA3, 0x52, 0x88, 0x78, 0xC1, 0x4C, 0x6D, + 0xF0, 0xC4, 0x4A, 0x49, 0xC1, 0xBF, 0x3E, 0xB8, + 0x86, 0x6B, 0x1F, 0x6E, 0xA7, 0xA9, 0x0C, 0x8F, + 0x97, 0x2E, 0x75, 0xFD, 0xB3, 0x2E, 0xA5, 0x12, + 0x9F, 0x53, 0x56, 0x8D, 0xAF, 0xCE, 0x90, 0x62, + 0x35, 0xBC, 0xA3, 0x29, 0xC4, 0x45, 0x6A, 0x91, + 0x39, 0xF5, 0xAB, 0x05, 0xE3, 0x70, 0x1F, 0xF3, + 0x32, 0x88, 0xE8, 0xC5, 0x43, 0x47, 0x05, 0x87 + }, + { + 0xF4, 0x07, 0x2D, 0xF2, 0xBD, 0xD2, 0x09, 0xDD, + 0x58, 0xA4, 0x67, 0xDB, 0x85, 0xBD, 0x74, 0x73, + 0xB0, 0xEB, 0x0F, 0xBA, 0x16, 0x74, 0xCE, 0x04, + 0x37, 0x37, 0xDF, 0x9C, 0xF2, 0x38, 0x03, 0x40, + 0xAB, 0x28, 0x74, 0x67, 0x6B, 0x95, 0x47, 0x0E, + 0xF1, 0x17, 0x62, 0x5C, 0xF8, 0xDC, 0xD7, 0xDA, + 0x59, 0xAE, 0x61, 0x40, 0x9E, 0x7A, 0xBC, 0x00, + 0x66, 0x44, 0x4C, 0xD6, 0xB8, 0xBA, 0xAE, 0x78 + }, + { + 0x28, 0xE4, 0x3D, 0xC0, 0x05, 0x14, 0x5A, 0x1F, + 0x91, 0xE7, 0xF4, 0x9B, 0x89, 0x65, 0x89, 0x14, + 0xB4, 0xF3, 0x9F, 0x4B, 0xDF, 0x78, 0xCC, 0xC5, + 0x1C, 0xDB, 0x0D, 0xE9, 0xC9, 0x6A, 0xBC, 0x4C, + 0x3A, 0x3A, 0x0B, 0xE8, 0xBC, 0xB0, 0x73, 0x79, + 0xCD, 0x9D, 0x9B, 0x54, 0x88, 0x47, 0x7C, 0xB0, + 0x46, 0xF5, 0x0C, 0xDA, 0x8C, 0xB5, 0x13, 0x80, + 0x50, 0x4A, 0x15, 0x80, 0x7B, 0x65, 0xBC, 0x20 + }, + { + 0xF0, 0x29, 0x19, 0x1A, 0xD1, 0x1D, 0xFA, 0x2E, + 0x95, 0x18, 0x27, 0x2E, 0x7A, 0x88, 0x2F, 0x72, + 0x8E, 0x3E, 0x8D, 0xEB, 0xA2, 0xF6, 0x64, 0x4A, + 0x14, 0x34, 0xD9, 0x06, 0x0E, 0x8B, 0x5D, 0xC8, + 0x9A, 0x80, 0xC0, 0xA1, 0xBC, 0x30, 0x9B, 0x09, + 0xE1, 0xAF, 0xB8, 0xB4, 0x1C, 0xBE, 0x17, 0x72, + 0x5C, 0x87, 0x0A, 0x8C, 0x06, 0x9A, 0x4B, 0x49, + 0xF1, 0x54, 0x78, 0x8F, 0xBC, 0x22, 0x86, 0x30 + }, + { + 0x16, 0xC5, 0x39, 0x33, 0x88, 0xC4, 0x01, 0x15, + 0xF3, 0x5E, 0x1E, 0xD6, 0x41, 0x9F, 0xC2, 0x36, + 0xEA, 0x24, 0xDF, 0x11, 0x28, 0x8C, 0xFF, 0xB9, + 0x74, 0xC7, 0x3D, 0x90, 0x47, 0x2C, 0x42, 0xF2, + 0x3D, 0x2D, 0x62, 0xA9, 0xCA, 0x76, 0x83, 0x4A, + 0x3A, 0x06, 0xC9, 0x27, 0x5B, 0x35, 0xBB, 0x36, + 0xA9, 0x70, 0x07, 0x0E, 0x32, 0xC0, 0x68, 0x27, + 0xDA, 0x06, 0x25, 0x7F, 0xA0, 0x40, 0x65, 0x69 + }, + { + 0xD6, 0x85, 0x18, 0x01, 0x84, 0x65, 0xEB, 0xA9, + 0x85, 0x36, 0x67, 0xFE, 0x5A, 0x97, 0x04, 0xB1, + 0xF8, 0xEE, 0x38, 0xDB, 0x25, 0x55, 0xA1, 0x9F, + 0x7A, 0x83, 0x0B, 0x11, 0xE3, 0x7A, 0x56, 0x91, + 0xD6, 0x17, 0x4D, 0x2F, 0x9C, 0x16, 0xB8, 0xCE, + 0xEC, 0x88, 0x4A, 0xE7, 0x4C, 0x15, 0x51, 0x3E, + 0x80, 0x59, 0x18, 0x5D, 0xD9, 0xAE, 0x8A, 0x7B, + 0x2C, 0x25, 0x90, 0xA0, 0xC9, 0xB1, 0x88, 0x01 + }, + { + 0xB3, 0x8C, 0x4C, 0x98, 0xEB, 0x1C, 0x58, 0xE9, + 0x7D, 0x15, 0x81, 0x8A, 0xA6, 0xC8, 0xC7, 0x28, + 0xC6, 0x9F, 0x43, 0x50, 0xC0, 0x2E, 0x0D, 0x76, + 0x38, 0x73, 0xE2, 0xB8, 0xE1, 0xCD, 0x4D, 0x39, + 0xEF, 0xE4, 0xB5, 0xCF, 0x4E, 0xFA, 0x2C, 0x2D, + 0x04, 0xE5, 0x80, 0x81, 0x49, 0xD5, 0x80, 0xF1, + 0xC5, 0x15, 0xE2, 0x0D, 0xD7, 0x5A, 0xE6, 0x40, + 0x0A, 0xBB, 0xAF, 0x3B, 0x28, 0x7C, 0xAB, 0x9A + }, + { + 0x9D, 0x7B, 0x22, 0xFC, 0x8C, 0x37, 0xB6, 0x67, + 0xFF, 0x3F, 0x3E, 0x78, 0x67, 0x02, 0x1E, 0x8C, + 0xA6, 0x8F, 0x56, 0x3E, 0x26, 0xE4, 0xCD, 0x00, + 0x49, 0x86, 0xA4, 0x12, 0x52, 0x93, 0x82, 0xF6, + 0x6C, 0x26, 0xE1, 0x43, 0x37, 0xD9, 0xD0, 0x20, + 0x3F, 0x0C, 0x1E, 0x4F, 0xB4, 0x71, 0x30, 0x28, + 0x3C, 0x16, 0xB8, 0xB3, 0x3D, 0x01, 0x6A, 0xB5, + 0x2C, 0xF7, 0x1F, 0xB8, 0x59, 0x8F, 0xF1, 0x74 + }, + { + 0xF4, 0x6D, 0x52, 0x02, 0xF8, 0x9A, 0xF7, 0xB8, + 0x75, 0x48, 0x1E, 0xFF, 0x65, 0xE8, 0x95, 0x55, + 0x3C, 0x69, 0x43, 0xB2, 0x80, 0xC5, 0x52, 0x10, + 0xE7, 0x8B, 0x81, 0x24, 0x89, 0x62, 0x58, 0xC8, + 0xB3, 0x98, 0x7B, 0x5E, 0x84, 0xCF, 0x4C, 0x4A, + 0xA9, 0x9C, 0xA3, 0x71, 0x83, 0x88, 0xD6, 0x4A, + 0xBB, 0x2A, 0xD9, 0xEE, 0x52, 0x5E, 0x7B, 0xAD, + 0xAB, 0xF5, 0x03, 0x88, 0x2A, 0xA6, 0x77, 0xE7 + }, + { + 0x27, 0xEF, 0x8A, 0x4D, 0x70, 0xFC, 0x50, 0x5D, + 0x15, 0xBC, 0x38, 0x63, 0x87, 0x77, 0xDB, 0xCA, + 0xFC, 0x33, 0xDD, 0x45, 0xAD, 0x3D, 0xB3, 0x17, + 0xD7, 0x27, 0xAB, 0xD8, 0x33, 0x92, 0xF8, 0x22, + 0x45, 0xFF, 0xED, 0x05, 0xB7, 0xA5, 0xFD, 0xCF, + 0xA3, 0xD1, 0xB0, 0x79, 0xA7, 0x70, 0x8B, 0x92, + 0x13, 0x1B, 0xAE, 0x10, 0x0D, 0xC7, 0x09, 0xDF, + 0x39, 0xFB, 0x92, 0x30, 0xB7, 0x6B, 0xA1, 0x23 + }, + { + 0xC6, 0xE4, 0x96, 0xAE, 0x0B, 0xD6, 0xCE, 0x75, + 0x16, 0x63, 0x26, 0x0D, 0x11, 0x2A, 0xE7, 0x62, + 0x2C, 0xFA, 0xE1, 0xBA, 0xC3, 0x4F, 0x63, 0x6C, + 0x15, 0xBC, 0x6E, 0xEC, 0x20, 0xE8, 0x08, 0x48, + 0xE7, 0x74, 0x8D, 0x84, 0xF3, 0xA4, 0xD1, 0xF6, + 0xB6, 0x44, 0xC1, 0xC7, 0xD7, 0x4B, 0x70, 0x6B, + 0x54, 0x8E, 0x0B, 0xD1, 0x0E, 0x7D, 0x6A, 0x85, + 0x4E, 0x5C, 0x8F, 0xAE, 0xC7, 0x24, 0xE5, 0xF4 + }, + { + 0x2B, 0xD5, 0x62, 0x63, 0xC8, 0xC4, 0xC9, 0x6D, + 0x7F, 0x72, 0xA5, 0x40, 0x8D, 0x21, 0xE0, 0x60, + 0xA6, 0x61, 0x59, 0x79, 0x56, 0x74, 0x2D, 0xF8, + 0x9A, 0xAD, 0x1A, 0xBC, 0x8F, 0x6A, 0xE4, 0x80, + 0x44, 0x85, 0x08, 0x21, 0x9B, 0x0C, 0x24, 0xDE, + 0x3F, 0x7D, 0x56, 0x8F, 0x92, 0xA6, 0x82, 0x0B, + 0x73, 0xA0, 0xE4, 0x14, 0xB3, 0x5D, 0x45, 0x2D, + 0xD0, 0xAB, 0xD8, 0x6A, 0x9A, 0xEC, 0x79, 0x29 + }, + { + 0x83, 0xAD, 0x2E, 0x1D, 0xDA, 0xF6, 0x34, 0x65, + 0xEE, 0x81, 0xD1, 0x2B, 0xE2, 0xD5, 0x9F, 0xBB, + 0xE2, 0x5A, 0x52, 0x38, 0xAF, 0x83, 0x8C, 0xE5, + 0x97, 0x2A, 0x6E, 0x9B, 0x85, 0xE0, 0xD5, 0xD8, + 0x0D, 0x94, 0xA4, 0xC8, 0x86, 0x56, 0x03, 0x62, + 0x5C, 0x73, 0xBC, 0x70, 0x50, 0x26, 0x87, 0x83, + 0xB6, 0x9A, 0x04, 0x80, 0x71, 0x10, 0x8D, 0x88, + 0x12, 0xB7, 0x8C, 0xA8, 0x5F, 0x05, 0xD0, 0x7E + }, + { + 0x8D, 0xC9, 0x0A, 0x14, 0xC5, 0x5D, 0x49, 0x0A, + 0x81, 0x95, 0x46, 0x2E, 0xC4, 0xF0, 0xD6, 0x85, + 0x58, 0xB7, 0x1E, 0x92, 0x36, 0xF6, 0xC1, 0xA6, + 0x17, 0xCF, 0x66, 0x49, 0xD4, 0x7B, 0xE4, 0x6C, + 0xFB, 0x20, 0x3F, 0xFF, 0x14, 0x23, 0xBD, 0xF8, + 0x0D, 0x14, 0x89, 0x66, 0x26, 0x0F, 0xE6, 0x38, + 0x18, 0x88, 0xBB, 0xF9, 0xB9, 0xCD, 0xB7, 0x78, + 0x06, 0x56, 0x66, 0xD3, 0x96, 0x21, 0x2C, 0xD9 + }, + { + 0xD9, 0xB0, 0xFC, 0x3B, 0xA2, 0x27, 0x9A, 0xA8, + 0x30, 0xC9, 0x66, 0xEE, 0xA5, 0x41, 0xA0, 0x9C, + 0x91, 0xD5, 0x7E, 0x86, 0x19, 0x07, 0xA0, 0x6C, + 0x6C, 0x27, 0x66, 0xDD, 0x19, 0xF7, 0xFE, 0x74, + 0x6B, 0x1F, 0x8E, 0x87, 0x25, 0x2F, 0x04, 0x28, + 0x70, 0xA8, 0xD1, 0x27, 0xCD, 0x03, 0xAE, 0xF5, + 0x4A, 0xDD, 0xA8, 0x13, 0x3A, 0xE7, 0x44, 0x82, + 0x13, 0x8B, 0xB8, 0x5A, 0x18, 0xE0, 0xF6, 0x58 + }, + { + 0x05, 0x39, 0x49, 0x8F, 0xE1, 0x26, 0xCC, 0x1F, + 0x39, 0x72, 0xF4, 0xB7, 0x16, 0x14, 0xC6, 0x4D, + 0x11, 0xE0, 0xE8, 0x20, 0xB1, 0x95, 0xB9, 0xF1, + 0xA0, 0xA4, 0x87, 0x9B, 0x31, 0x4C, 0x53, 0x9E, + 0x5C, 0xB1, 0x67, 0xFC, 0xBD, 0xDD, 0x18, 0xE1, + 0x5E, 0x7F, 0xC8, 0x92, 0x7A, 0x5D, 0x74, 0x95, + 0x32, 0xD2, 0x3B, 0x25, 0xF7, 0xC5, 0x72, 0x69, + 0x01, 0xAA, 0xBE, 0xB1, 0x14, 0xAB, 0x1F, 0x6E + }, + { + 0x72, 0xBF, 0xA1, 0x14, 0x16, 0x24, 0xAB, 0x67, + 0x09, 0x6C, 0x39, 0x8B, 0x04, 0xF1, 0xEF, 0x24, + 0x8A, 0x86, 0xAE, 0x4F, 0xE5, 0x08, 0xDB, 0x93, + 0x6B, 0x1A, 0x5E, 0x0D, 0xE7, 0x17, 0xF7, 0x31, + 0xD6, 0x27, 0x12, 0x44, 0x06, 0x2F, 0x2F, 0x2F, + 0xC9, 0x78, 0x7A, 0x5B, 0x46, 0xE4, 0x18, 0x5B, + 0x3C, 0x77, 0x95, 0x73, 0xFE, 0xC1, 0x1C, 0x6F, + 0x14, 0xFF, 0x2D, 0x52, 0xB1, 0xF6, 0x57, 0xFC + }, + { + 0xFA, 0xD4, 0xCB, 0x64, 0xCB, 0x46, 0x38, 0xCE, + 0x2D, 0xC5, 0x83, 0x66, 0x84, 0x4B, 0xA4, 0x77, + 0x89, 0xF0, 0x9F, 0x3A, 0x84, 0x20, 0xDD, 0xAD, + 0xBE, 0xF5, 0x30, 0xC6, 0x29, 0x73, 0x77, 0xC3, + 0x05, 0x1C, 0xF0, 0x68, 0x61, 0x3B, 0x6F, 0x40, + 0x27, 0xAD, 0x86, 0x48, 0x64, 0x54, 0x1F, 0x05, + 0x5B, 0x28, 0x3A, 0x46, 0xC5, 0x2C, 0x53, 0xFA, + 0x27, 0x9F, 0xF8, 0x59, 0x76, 0xCB, 0xE6, 0x5B + }, + { + 0xA2, 0xB9, 0x2B, 0xD8, 0x03, 0x1B, 0xD7, 0xEC, + 0xF6, 0xAB, 0x87, 0xCD, 0xB9, 0xC2, 0x14, 0xBD, + 0x4E, 0xD1, 0xB8, 0x25, 0x97, 0x6A, 0xE6, 0xEB, + 0xD6, 0x5F, 0x2C, 0xD4, 0x5F, 0xF1, 0x42, 0x2C, + 0x66, 0x08, 0x3E, 0xE6, 0x29, 0xEB, 0x73, 0xF4, + 0xEB, 0xDD, 0xE0, 0xA0, 0x19, 0x23, 0xDB, 0x86, + 0x2B, 0x58, 0x6C, 0xD6, 0x3E, 0x50, 0x36, 0x1A, + 0xF1, 0x85, 0xF0, 0x2D, 0xC6, 0xFD, 0xD5, 0x27 + }, + { + 0x1E, 0x13, 0xB7, 0xD9, 0x36, 0xAF, 0x3C, 0x70, + 0xF8, 0x70, 0x4D, 0x77, 0x25, 0x2A, 0xFF, 0x9B, + 0xCB, 0x3C, 0x38, 0x7B, 0x60, 0xCB, 0xE0, 0x78, + 0x74, 0x3A, 0x3F, 0xD1, 0x53, 0xDC, 0xEE, 0xD3, + 0xC0, 0x1A, 0x0B, 0x17, 0x16, 0x38, 0x51, 0x02, + 0x42, 0x57, 0xA5, 0x8F, 0xB9, 0x6E, 0x3D, 0x31, + 0xE3, 0xE2, 0x9D, 0xFB, 0x67, 0x89, 0xE2, 0x54, + 0x6A, 0x9C, 0xC2, 0x45, 0x7D, 0xF8, 0x1C, 0xE7 + }, + { + 0x86, 0xD6, 0xCE, 0x8C, 0x7E, 0xED, 0x83, 0x94, + 0xDC, 0x94, 0x6A, 0x7C, 0xCD, 0x55, 0x71, 0xD6, + 0x90, 0x28, 0xA7, 0xEE, 0xBD, 0x52, 0xB9, 0x10, + 0x0C, 0x31, 0x23, 0x52, 0x66, 0x79, 0xD0, 0x03, + 0x11, 0x50, 0x0E, 0xC2, 0x4C, 0xBE, 0xB3, 0xAD, + 0xE0, 0xC2, 0xC4, 0x3C, 0x7D, 0x03, 0x3D, 0x12, + 0xD0, 0x6D, 0xEF, 0x4F, 0x13, 0x44, 0x31, 0x1E, + 0xFF, 0x91, 0xEA, 0x5C, 0x14, 0x9F, 0xA1, 0xBB + }, + { + 0xBF, 0x06, 0xCC, 0x4A, 0xE3, 0x74, 0x19, 0xDB, + 0x41, 0xEA, 0x32, 0x77, 0xDA, 0xF0, 0xE8, 0x6A, + 0xAD, 0x48, 0xFF, 0x2D, 0xF0, 0x7F, 0x63, 0x67, + 0x31, 0x04, 0x89, 0x55, 0xE5, 0xC7, 0x2C, 0xB1, + 0x5F, 0xAA, 0x47, 0x74, 0xA0, 0x98, 0x7F, 0x94, + 0xA0, 0x81, 0xC2, 0x1A, 0x1B, 0x0D, 0x68, 0x68, + 0x52, 0x09, 0x47, 0x21, 0xA3, 0x70, 0xEC, 0x21, + 0x45, 0x36, 0x58, 0x8B, 0xA8, 0xD7, 0x78, 0x07 + }, + { + 0x24, 0xFE, 0x32, 0x02, 0xE8, 0x81, 0x0A, 0x32, + 0xA8, 0xDF, 0x9F, 0xF2, 0x52, 0xD3, 0x31, 0xB1, + 0x2F, 0xC3, 0xDE, 0x12, 0x4A, 0x93, 0x71, 0x10, + 0xFF, 0x49, 0x1F, 0xEA, 0x5A, 0x2D, 0xD9, 0x19, + 0x46, 0x56, 0xED, 0x17, 0xD5, 0x4B, 0x30, 0x84, + 0x89, 0x60, 0xA3, 0x9A, 0xDC, 0x5F, 0xAD, 0x86, + 0xB6, 0x82, 0x11, 0xCC, 0xA5, 0xBA, 0xD2, 0xB7, + 0xFA, 0x3B, 0xD9, 0x2E, 0xFC, 0xBB, 0x7D, 0x18 + }, + { + 0x9E, 0xDF, 0x84, 0x4E, 0x42, 0x7B, 0x30, 0xAD, + 0x86, 0xF5, 0x2D, 0xB9, 0xBA, 0xA3, 0x5E, 0x1E, + 0x9A, 0x9F, 0x7A, 0x17, 0x00, 0xBF, 0xAA, 0x9B, + 0x83, 0x94, 0x8F, 0x7A, 0x09, 0x8B, 0x4C, 0x67, + 0xAA, 0x96, 0xAC, 0xE2, 0xB1, 0xB9, 0xC6, 0x9C, + 0x64, 0xEA, 0xE3, 0x2E, 0xE9, 0x5C, 0x24, 0x16, + 0xB8, 0x39, 0x82, 0x26, 0xA0, 0x16, 0x21, 0x90, + 0x47, 0xBD, 0x9B, 0x71, 0xB8, 0x31, 0x47, 0x74 + }, + { + 0xAB, 0xF4, 0x5C, 0x4A, 0x0E, 0x0F, 0x3F, 0xEF, + 0xC5, 0x04, 0xFB, 0xDF, 0x5E, 0x78, 0x7B, 0x55, + 0xEA, 0x08, 0x9C, 0x6D, 0xDA, 0x9D, 0xFE, 0xBF, + 0x5A, 0x5F, 0x68, 0x4C, 0x3B, 0xD5, 0xBF, 0x58, + 0x8B, 0x32, 0x7E, 0xA5, 0x72, 0x3D, 0x30, 0xC4, + 0xB2, 0x95, 0x2E, 0x40, 0x02, 0xA1, 0x62, 0x80, + 0x1B, 0x48, 0xFD, 0x3B, 0x26, 0x3E, 0xD6, 0xC1, + 0x41, 0x7A, 0x6B, 0x2A, 0x12, 0x50, 0x21, 0x69 + }, + { + 0x17, 0x07, 0x1E, 0xC0, 0x84, 0xA3, 0x1C, 0x51, + 0x5F, 0xBD, 0xAF, 0x1D, 0xFF, 0x8C, 0x76, 0xDE, + 0xF3, 0x70, 0x22, 0xDF, 0x99, 0x0E, 0xD0, 0xCC, + 0x02, 0xB5, 0x2F, 0xDA, 0x49, 0x04, 0xB2, 0x39, + 0xF6, 0xE1, 0x2A, 0x8F, 0xE2, 0xA6, 0x48, 0x3E, + 0x41, 0xAD, 0x1D, 0xA9, 0x8D, 0x3A, 0x52, 0x80, + 0xA9, 0x91, 0x07, 0xC1, 0xDB, 0x0C, 0xA7, 0xBD, + 0xA0, 0xDA, 0x91, 0xEC, 0x64, 0xA7, 0x9F, 0xBA + }, + { + 0x1D, 0x78, 0xA4, 0xE2, 0x44, 0xA9, 0x22, 0x15, + 0x93, 0x74, 0xAD, 0x90, 0x2E, 0x64, 0xEA, 0x58, + 0x1B, 0xD5, 0x45, 0x86, 0x85, 0xF8, 0xBB, 0xFA, + 0x07, 0x95, 0xB5, 0xC7, 0x41, 0xE3, 0x39, 0x4D, + 0xBA, 0x65, 0x1B, 0xF4, 0x46, 0x1D, 0xAB, 0xAD, + 0x87, 0xED, 0x26, 0xC6, 0x37, 0x2C, 0xB5, 0x91, + 0xE6, 0x13, 0xD2, 0x88, 0xFF, 0x4C, 0x96, 0xCD, + 0xAB, 0x51, 0x4C, 0xFB, 0x73, 0x28, 0x95, 0x3E + }, + { + 0x72, 0x54, 0xBD, 0x73, 0x2C, 0xE5, 0x8A, 0x88, + 0xEC, 0x93, 0x2B, 0x3A, 0x60, 0x3E, 0x9D, 0xA9, + 0x0F, 0x04, 0x72, 0xF9, 0x5D, 0x45, 0x82, 0xB1, + 0x72, 0x7D, 0xA7, 0x93, 0xB2, 0x30, 0xEA, 0x67, + 0x83, 0x7E, 0xF9, 0x5A, 0xE6, 0x1F, 0x35, 0x2E, + 0x06, 0x46, 0x9B, 0x17, 0x1D, 0x31, 0x7A, 0xA6, + 0xA9, 0xD1, 0x03, 0x6F, 0xA1, 0x58, 0x97, 0x80, + 0x03, 0x66, 0x80, 0x4D, 0x38, 0x16, 0x2D, 0x80 + }, + { + 0xBE, 0xA2, 0x4E, 0xF0, 0x1F, 0xD1, 0x6D, 0xA4, + 0x9B, 0x35, 0x38, 0x11, 0xCF, 0x04, 0x29, 0x69, + 0x51, 0xC5, 0x23, 0xA3, 0x18, 0x56, 0x70, 0x85, + 0x1A, 0xA0, 0x98, 0xF7, 0xB7, 0x37, 0x65, 0xE7, + 0xAB, 0xF5, 0xCC, 0x50, 0xD5, 0x6B, 0xD8, 0x53, + 0x08, 0x33, 0xBC, 0x05, 0x7E, 0xDB, 0xDB, 0x60, + 0x09, 0x60, 0xC5, 0xB2, 0x88, 0x25, 0x1C, 0xE8, + 0xCE, 0x5C, 0x0D, 0x2F, 0x7B, 0x89, 0x77, 0x76 + }, + { + 0x86, 0xE6, 0xC4, 0xB0, 0xD8, 0xD7, 0x45, 0x90, + 0xB5, 0xC1, 0x97, 0xA4, 0xE1, 0xE8, 0x44, 0x12, + 0x50, 0xC9, 0xA6, 0xCA, 0x89, 0xC3, 0xD7, 0xE1, + 0xED, 0x65, 0xE4, 0xAB, 0x27, 0x24, 0x92, 0xEA, + 0x0A, 0x77, 0xDB, 0xE3, 0x24, 0x26, 0x55, 0xCE, + 0x70, 0xD2, 0xA9, 0x60, 0xFD, 0xBD, 0xF6, 0xFC, + 0x60, 0x61, 0x3D, 0xF9, 0xBF, 0xC9, 0x76, 0x66, + 0x8F, 0xF0, 0x96, 0xA3, 0x96, 0xBB, 0xDE, 0x8B + }, + { + 0xC7, 0xBB, 0xF1, 0x46, 0x38, 0x38, 0xA0, 0xD9, + 0x3E, 0xA9, 0xCE, 0x8E, 0x2E, 0xBC, 0xEC, 0x5B, + 0x72, 0x05, 0x1C, 0xCC, 0x0F, 0x60, 0x57, 0xB5, + 0xF0, 0x82, 0x55, 0x83, 0x3D, 0x49, 0xA9, 0x2E, + 0x8F, 0xBF, 0x96, 0xB0, 0xC9, 0xCE, 0x76, 0x24, + 0xD7, 0xB4, 0xB2, 0x5F, 0xF2, 0x5D, 0xF0, 0xD5, + 0x17, 0xE1, 0xDB, 0xC8, 0xB8, 0x14, 0x5B, 0x5F, + 0xCC, 0xBB, 0x2D, 0x2E, 0x5E, 0x0F, 0x87, 0x75 + }, + { + 0xFD, 0xE6, 0x0B, 0x7B, 0xA0, 0x64, 0x69, 0x20, + 0xB2, 0x33, 0x35, 0x0B, 0x72, 0x9D, 0x32, 0xC3, + 0x64, 0x50, 0x03, 0x60, 0x1D, 0x42, 0x77, 0xE4, + 0xC3, 0xA1, 0x15, 0x06, 0xD2, 0x34, 0x58, 0x95, + 0x3B, 0x7B, 0xC6, 0x25, 0x0A, 0xDF, 0xFD, 0x76, + 0x4B, 0x20, 0xBA, 0x1C, 0x79, 0x37, 0x1C, 0x8B, + 0xFC, 0xD7, 0x87, 0x6D, 0xE7, 0xDC, 0x31, 0x8C, + 0x35, 0x80, 0x73, 0x19, 0xE3, 0x75, 0x50, 0x8D + }, + { + 0x29, 0x1A, 0x75, 0x40, 0x25, 0x45, 0x68, 0x09, + 0xC4, 0xAA, 0xB1, 0x57, 0x6E, 0x91, 0x55, 0x8F, + 0x1C, 0x36, 0x8D, 0x5F, 0x5E, 0x50, 0xF5, 0x62, + 0x20, 0x66, 0xD3, 0xC6, 0x3C, 0x69, 0x1B, 0x3D, + 0x85, 0x5E, 0xCB, 0x5B, 0x3D, 0xE3, 0xB0, 0xC8, + 0x6A, 0x00, 0xEA, 0x01, 0x85, 0x5C, 0x0D, 0x95, + 0x89, 0xE0, 0x1E, 0x3E, 0x12, 0x6B, 0xC5, 0xBB, + 0x36, 0x86, 0x4E, 0x17, 0x44, 0x51, 0x50, 0xEF + }, + { + 0xC3, 0xA2, 0x44, 0xC6, 0xC1, 0xFE, 0x11, 0x97, + 0x53, 0xF1, 0x1E, 0x5F, 0x6F, 0xEC, 0x64, 0x1D, + 0x57, 0x44, 0x1F, 0xC2, 0xD2, 0x62, 0xD1, 0xD6, + 0x08, 0x00, 0x99, 0x90, 0xCA, 0xAD, 0x9E, 0x32, + 0x94, 0x05, 0xB4, 0x86, 0x65, 0x42, 0x2D, 0x8B, + 0xAE, 0x87, 0xFD, 0x39, 0xD2, 0x2F, 0xB2, 0x20, + 0xDE, 0xC1, 0xBD, 0xFC, 0x2C, 0x70, 0xBB, 0x35, + 0x36, 0xB2, 0xC1, 0x9E, 0x1F, 0x4B, 0x2C, 0xD7 + }, + { + 0x6E, 0xF3, 0xFB, 0x80, 0xF7, 0x0D, 0xC0, 0xD4, + 0xD6, 0xAC, 0xD9, 0x85, 0x17, 0x74, 0x3D, 0xB2, + 0x2A, 0x72, 0x60, 0xA1, 0x4C, 0x39, 0xB8, 0x09, + 0xE6, 0xEC, 0xDA, 0x35, 0x3B, 0x41, 0xA9, 0x1B, + 0x47, 0x3A, 0x47, 0xD4, 0x63, 0x25, 0x70, 0xD9, + 0x5B, 0xB0, 0x66, 0x57, 0x9A, 0x26, 0x88, 0xF0, + 0x3B, 0x79, 0x8F, 0x21, 0x9D, 0x59, 0x16, 0x51, + 0x03, 0x75, 0x82, 0xFC, 0xE8, 0xCD, 0x60, 0xC2 + }, + { + 0x4C, 0xCB, 0x49, 0x09, 0x55, 0xB3, 0x10, 0x77, + 0x33, 0x8B, 0x00, 0xBD, 0x3D, 0x6C, 0xA8, 0x71, + 0xB7, 0xB4, 0x8D, 0x5A, 0x79, 0x6E, 0xAE, 0x21, + 0x0F, 0x84, 0x35, 0xA1, 0x34, 0x42, 0x20, 0xBB, + 0x35, 0x83, 0xCE, 0x7A, 0x70, 0x44, 0xC9, 0x12, + 0x76, 0x79, 0x19, 0x12, 0x54, 0x1E, 0xDB, 0x99, + 0xC0, 0x6E, 0xD6, 0x4C, 0x7E, 0x0B, 0x31, 0x65, + 0x9B, 0x18, 0xFC, 0x67, 0xCF, 0xBC, 0x60, 0xF4 + }, + { + 0x84, 0xF9, 0x19, 0x46, 0x0C, 0xD4, 0x81, 0xB8, + 0x35, 0xCF, 0x5D, 0x44, 0x43, 0xA4, 0x50, 0x06, + 0x3A, 0x21, 0x83, 0x39, 0x90, 0xC0, 0x37, 0x91, + 0xCE, 0x1B, 0x37, 0x2A, 0x17, 0xFD, 0x5C, 0x99, + 0xEB, 0xC1, 0x59, 0xD5, 0x0F, 0x46, 0xE4, 0x2A, + 0x02, 0xAA, 0x7E, 0xDF, 0x32, 0x3A, 0x14, 0x26, + 0xD9, 0x96, 0xA7, 0x12, 0x33, 0xF5, 0xA3, 0x4A, + 0x18, 0x03, 0x0A, 0xCB, 0x48, 0x7B, 0xDA, 0x51 + }, + { + 0x57, 0x16, 0x19, 0x70, 0xB8, 0x04, 0xE5, 0x9E, + 0xE2, 0xE8, 0xCF, 0xD4, 0x8D, 0x7B, 0x4F, 0xC2, + 0xC3, 0x6C, 0x54, 0x88, 0x72, 0x70, 0x16, 0x65, + 0xDA, 0xD8, 0xC1, 0x24, 0xCA, 0xCB, 0xF2, 0x19, + 0xB3, 0x2F, 0x7C, 0x36, 0x19, 0x8C, 0xAE, 0x9E, + 0xA0, 0x85, 0x99, 0x6C, 0x31, 0x80, 0x42, 0x60, + 0xD4, 0x08, 0x5C, 0x97, 0xAE, 0x97, 0xD7, 0x52, + 0xAA, 0xFC, 0x3B, 0xAB, 0x48, 0x54, 0x16, 0x82 + }, + { + 0x7F, 0x1B, 0x23, 0x5D, 0xF6, 0x85, 0xD8, 0x2D, + 0x95, 0x29, 0x15, 0x12, 0x3A, 0x44, 0xEC, 0x5D, + 0x76, 0x46, 0x8E, 0xA9, 0x5B, 0x83, 0x68, 0x4D, + 0x17, 0xAD, 0x7A, 0x64, 0xE4, 0xCE, 0xA6, 0xBD, + 0xAE, 0x8A, 0x7F, 0x34, 0x88, 0x7B, 0x6D, 0x22, + 0x2F, 0xC7, 0x9E, 0x27, 0x00, 0xA9, 0xFB, 0xA6, + 0xB4, 0x6F, 0x1B, 0x2B, 0xD5, 0x76, 0x10, 0x37, + 0xD4, 0x8C, 0xFA, 0x76, 0xAB, 0x92, 0xA1, 0x45 + }, + { + 0xB4, 0xEA, 0x10, 0x8E, 0x26, 0xBD, 0xF5, 0xF3, + 0x5D, 0xF2, 0x2A, 0x19, 0x75, 0x7F, 0xA3, 0x25, + 0xFE, 0x2E, 0xF8, 0x38, 0x67, 0xE4, 0x6C, 0x65, + 0xAC, 0x10, 0x44, 0xD0, 0x92, 0xB8, 0xA3, 0xD7, + 0xD4, 0x4D, 0xA0, 0xBF, 0xD7, 0x42, 0xF2, 0xC2, + 0xB8, 0xCC, 0xEA, 0x5A, 0xAB, 0xC1, 0xA4, 0x08, + 0xC7, 0x8E, 0xE3, 0x7D, 0xCD, 0x42, 0x16, 0x0F, + 0xAC, 0xDF, 0xF8, 0xE3, 0x57, 0x77, 0x04, 0x59 + }, + { + 0x13, 0x50, 0x18, 0x13, 0x15, 0xCD, 0x9A, 0xFC, + 0xC5, 0xD8, 0x42, 0x75, 0xEE, 0xD0, 0x86, 0xD6, + 0x28, 0x00, 0x29, 0x9C, 0xED, 0x13, 0x95, 0xDE, + 0x7C, 0xF0, 0x18, 0xF0, 0xF3, 0x35, 0x5F, 0x1D, + 0xC5, 0xD1, 0x83, 0xA6, 0x22, 0x7F, 0x05, 0xF1, + 0x75, 0xC6, 0x4E, 0x21, 0xAD, 0x50, 0x20, 0xD3, + 0x59, 0xBB, 0x6B, 0xD4, 0xE5, 0xE2, 0xBC, 0x92, + 0xDB, 0xA0, 0x1B, 0x83, 0x37, 0x3E, 0x11, 0x6C + }, + { + 0x2B, 0x3E, 0x62, 0x3C, 0x9B, 0xE7, 0x55, 0xE5, + 0x60, 0xAC, 0x4E, 0x99, 0x3F, 0xCC, 0x5C, 0x15, + 0xD1, 0xF3, 0x79, 0x9A, 0xCA, 0x21, 0x2C, 0xDF, + 0x38, 0xCE, 0xF6, 0xBC, 0x9B, 0x64, 0x32, 0x96, + 0x38, 0x6F, 0x21, 0x68, 0x7A, 0x28, 0xDB, 0x45, + 0x38, 0x2B, 0x29, 0x3B, 0xCF, 0xEC, 0xE9, 0xF4, + 0x22, 0x59, 0xD2, 0x9B, 0x15, 0xA6, 0x36, 0x34, + 0x5C, 0x51, 0x8D, 0x22, 0xEE, 0x70, 0x04, 0x01 + }, + { + 0xD6, 0x12, 0xFC, 0x18, 0xE9, 0x3E, 0xD7, 0xC3, + 0x85, 0x95, 0xEC, 0xC0, 0x3A, 0x12, 0x8E, 0x9D, + 0x62, 0x57, 0xE8, 0x39, 0x05, 0xC5, 0x2A, 0x50, + 0xE3, 0xA0, 0x33, 0xEB, 0xC5, 0xF4, 0xC3, 0x08, + 0xD7, 0x06, 0xD5, 0x21, 0x8F, 0x93, 0x7E, 0x52, + 0xD3, 0xA6, 0xFF, 0xC9, 0x58, 0x01, 0x12, 0xB9, + 0xE7, 0x1B, 0x88, 0x32, 0xEF, 0x97, 0x0D, 0xE0, + 0x98, 0xE0, 0x3E, 0x50, 0xF3, 0xC9, 0x04, 0x00 + }, + { + 0x21, 0x61, 0xDC, 0x45, 0x01, 0x0D, 0x2B, 0x39, + 0xC1, 0x9C, 0x8C, 0xC4, 0xD4, 0x7F, 0x51, 0x11, + 0x7F, 0xE9, 0xD5, 0xF5, 0x82, 0xA1, 0xBA, 0x97, + 0x2F, 0xB8, 0xB7, 0xDA, 0x84, 0xE9, 0x3E, 0xCA, + 0xA8, 0xE3, 0x03, 0x43, 0x93, 0x59, 0x81, 0x52, + 0x36, 0x97, 0xBC, 0xAD, 0x0F, 0x1D, 0xD2, 0x25, + 0x4F, 0xF4, 0xC9, 0x51, 0x13, 0x28, 0x80, 0x2B, + 0x52, 0xEE, 0x54, 0x2B, 0x46, 0xB1, 0x55, 0xA9 + }, + { + 0x44, 0xAE, 0x25, 0x35, 0x4C, 0x87, 0x91, 0x84, + 0x8B, 0x1A, 0x03, 0x70, 0x13, 0xED, 0x2F, 0x03, + 0xD0, 0x67, 0x17, 0xFB, 0xB4, 0x25, 0x40, 0xEE, + 0x90, 0x70, 0x21, 0xE8, 0x08, 0x76, 0x60, 0xD8, + 0x27, 0x10, 0xF8, 0x5E, 0x6F, 0xAF, 0x52, 0x2D, + 0x56, 0x55, 0x9F, 0xE4, 0x9B, 0x88, 0xBC, 0x66, + 0x34, 0x6A, 0x63, 0x93, 0x18, 0x20, 0xBA, 0x11, + 0x98, 0xCB, 0xDC, 0x51, 0x5E, 0x54, 0x3E, 0x83 + }, + { + 0xEF, 0x0A, 0x2F, 0x79, 0x9F, 0x0B, 0xA6, 0x9D, + 0xE8, 0xD6, 0xB1, 0x26, 0xDD, 0x77, 0x90, 0x0A, + 0xC7, 0x54, 0x3D, 0x2C, 0xC7, 0x0F, 0x7C, 0x81, + 0x4C, 0x57, 0x7D, 0x71, 0xF5, 0x8B, 0x03, 0x37, + 0x31, 0xA5, 0xAC, 0x0E, 0xCC, 0xDD, 0x56, 0x86, + 0x5B, 0xF1, 0xDB, 0xAD, 0xA4, 0xE8, 0x15, 0xB5, + 0xE1, 0x98, 0xE5, 0x5A, 0x2C, 0xED, 0x81, 0x7D, + 0x73, 0x4F, 0x94, 0xE8, 0x01, 0x69, 0x08, 0x8E + }, + { + 0x01, 0x76, 0x1C, 0x66, 0x48, 0x66, 0x2E, 0xAE, + 0xB3, 0x30, 0xA2, 0x50, 0x84, 0xF4, 0x84, 0x2F, + 0xD4, 0x76, 0x74, 0xFD, 0x5B, 0x8E, 0x57, 0xA9, + 0x58, 0x56, 0xD2, 0x0B, 0x9A, 0xD0, 0x8C, 0x4D, + 0x0A, 0x55, 0x06, 0x3F, 0x91, 0x55, 0xC8, 0xDB, + 0x19, 0x1D, 0x6B, 0x21, 0x49, 0x91, 0x04, 0x0E, + 0x3E, 0x51, 0x53, 0x3C, 0x7D, 0x4F, 0x48, 0x70, + 0xA8, 0xC0, 0xB2, 0xE7, 0x67, 0x5C, 0x8D, 0x23 + }, + { + 0x71, 0x1B, 0x6C, 0xE5, 0x76, 0xA0, 0x74, 0xFE, + 0x66, 0xDA, 0x59, 0xE2, 0x99, 0x63, 0xD2, 0x1C, + 0x74, 0xFF, 0x2A, 0x39, 0xBD, 0xA3, 0xCE, 0xB3, + 0xE5, 0x30, 0xCE, 0x55, 0x2C, 0xF5, 0xA6, 0x2A, + 0x1C, 0xED, 0x65, 0x5F, 0xFF, 0x9B, 0x89, 0xB2, + 0x38, 0x9E, 0x95, 0xD5, 0x85, 0x13, 0xFC, 0xB8, + 0xB5, 0x3A, 0xDD, 0x55, 0x0B, 0x0C, 0x12, 0xDB, + 0xA9, 0x3B, 0x14, 0x46, 0x85, 0x12, 0x89, 0x00 + }, + { + 0xAB, 0xE3, 0x70, 0x99, 0x8D, 0x16, 0x6A, 0xC6, + 0x3D, 0x37, 0x8E, 0xAA, 0x21, 0x32, 0x86, 0xA5, + 0x8A, 0x04, 0xEA, 0x3D, 0x32, 0xD2, 0xD4, 0x1E, + 0xEC, 0xC2, 0x6A, 0xDF, 0x76, 0x81, 0xAA, 0x60, + 0xF4, 0x06, 0x73, 0x74, 0x49, 0xB9, 0xB7, 0x6C, + 0x19, 0x6F, 0xD4, 0xB1, 0x68, 0x5A, 0xF3, 0x23, + 0x3C, 0x54, 0xFE, 0xF7, 0xBE, 0xAC, 0x51, 0x05, + 0xAA, 0x50, 0x07, 0x46, 0xA5, 0x6D, 0xE3, 0x9C + }, + { + 0xFD, 0x9D, 0xC7, 0x9B, 0xB4, 0xAA, 0x8C, 0x97, + 0x6D, 0x17, 0xC5, 0xB7, 0x70, 0x5B, 0x3D, 0x8C, + 0x19, 0x09, 0x8B, 0x30, 0xBA, 0x7B, 0xBA, 0x0A, + 0xA1, 0x16, 0x15, 0xC2, 0xAA, 0xD9, 0xEB, 0x65, + 0x19, 0xC5, 0x9D, 0xF9, 0xB1, 0x5A, 0xDA, 0xE8, + 0xB0, 0x68, 0x95, 0x9A, 0xE3, 0x98, 0xC9, 0x20, + 0xB2, 0xB5, 0x38, 0xFD, 0x6E, 0xBC, 0xF2, 0x66, + 0xEF, 0x2D, 0x72, 0x14, 0xA0, 0x3F, 0x98, 0x81 + }, + { + 0xC2, 0xD8, 0x1B, 0x66, 0xBA, 0x9E, 0x0A, 0x5C, + 0x8C, 0xA4, 0x38, 0x66, 0xAF, 0xAD, 0xF7, 0x73, + 0x60, 0x4E, 0xBE, 0xF3, 0x3D, 0x2E, 0xF7, 0xFA, + 0xD8, 0x22, 0xA2, 0x47, 0x80, 0x55, 0x8B, 0x9B, + 0x6C, 0x9C, 0xE1, 0x6E, 0x22, 0x98, 0xD5, 0x45, + 0x48, 0x01, 0x06, 0x09, 0x2D, 0xE5, 0xFC, 0x57, + 0x37, 0x83, 0x5B, 0x0C, 0xCF, 0x08, 0x88, 0x3D, + 0x05, 0xF7, 0xE4, 0x60, 0xE3, 0xEF, 0x42, 0xD1 + }, + { + 0xD3, 0x12, 0x2E, 0xC4, 0x55, 0x37, 0x47, 0x4E, + 0x05, 0x7E, 0xA9, 0x55, 0x31, 0xF8, 0x3B, 0x90, + 0x87, 0x5F, 0xBA, 0xD5, 0x72, 0x3A, 0x1D, 0xB5, + 0x01, 0xF9, 0xAF, 0x21, 0x9B, 0x96, 0x82, 0x84, + 0x02, 0xFA, 0x5D, 0xCF, 0xCF, 0xDA, 0x46, 0x0C, + 0x84, 0x95, 0x32, 0x54, 0x5A, 0x78, 0x3A, 0xBA, + 0xF3, 0x34, 0x9E, 0xFD, 0x2B, 0xFD, 0xDE, 0x14, + 0xF5, 0x68, 0xD0, 0x4F, 0xD7, 0x7A, 0x81, 0xB3 + }, + { + 0x1C, 0xDF, 0x2D, 0xA8, 0xF7, 0x6E, 0xBA, 0xEC, + 0xD6, 0x6F, 0x8D, 0x4E, 0x6E, 0x8D, 0x08, 0xC7, + 0x02, 0x86, 0xD4, 0xDD, 0xB5, 0x04, 0x66, 0x09, + 0x1B, 0x82, 0x8F, 0x9B, 0xF6, 0xE7, 0xC7, 0x33, + 0x03, 0xA8, 0x70, 0x14, 0xE7, 0x6F, 0x66, 0x12, + 0x94, 0x60, 0x47, 0x4A, 0x67, 0x8E, 0xA1, 0x8B, + 0x53, 0xB0, 0x8F, 0xC2, 0x78, 0xD4, 0xD9, 0x19, + 0x89, 0xCC, 0x69, 0x0C, 0x33, 0x36, 0x3F, 0xC6 + }, + { + 0x9C, 0xE3, 0x01, 0x5B, 0x94, 0xDD, 0x4E, 0x2D, + 0x17, 0x61, 0xEC, 0xDF, 0x2A, 0x3B, 0x0D, 0x25, + 0x47, 0xA0, 0x9F, 0xD9, 0x7B, 0x9C, 0x33, 0xC5, + 0x0A, 0x89, 0xF5, 0x51, 0x50, 0x98, 0x12, 0xF6, + 0x17, 0xC0, 0xDB, 0x82, 0x7D, 0xBC, 0x6B, 0xD3, + 0x9F, 0xC6, 0xC2, 0xE5, 0x2D, 0xE6, 0xE7, 0x3B, + 0x4B, 0x55, 0xC0, 0x4B, 0x3A, 0xD0, 0xDB, 0x65, + 0x2E, 0x0E, 0x02, 0xDA, 0xC0, 0xC5, 0x6B, 0xDD + }, + { + 0xFC, 0x75, 0x28, 0x03, 0xAB, 0x67, 0x52, 0x2D, + 0x7B, 0x92, 0x1E, 0xBB, 0x9B, 0xC7, 0x86, 0x73, + 0xE8, 0x64, 0x66, 0x4E, 0xBF, 0x77, 0xE3, 0x08, + 0x1F, 0x86, 0x9F, 0x8C, 0xB0, 0x52, 0x31, 0x9F, + 0x5F, 0xBB, 0xA4, 0xDD, 0x96, 0x2E, 0x29, 0x0C, + 0x50, 0xD8, 0x80, 0xF9, 0x3A, 0x64, 0x58, 0xCD, + 0x2A, 0xC8, 0x13, 0xA3, 0x9C, 0x5D, 0xB0, 0xC7, + 0x47, 0xB4, 0x00, 0x03, 0x4E, 0x91, 0xA8, 0xF1 + }, + { + 0xA4, 0xD4, 0x28, 0x23, 0x16, 0xAE, 0xBC, 0x40, + 0x2E, 0x65, 0xDB, 0x8B, 0xA5, 0xC6, 0x3F, 0xFF, + 0xF9, 0x4D, 0xE7, 0xB6, 0x98, 0xC8, 0x8E, 0x7C, + 0x49, 0xAA, 0x3E, 0xFB, 0x57, 0x3D, 0x77, 0x46, + 0x0C, 0xBC, 0x3E, 0x54, 0xA4, 0xE4, 0x18, 0x33, + 0xAF, 0x76, 0xD0, 0x6C, 0x2E, 0x5A, 0x21, 0xD1, + 0x6D, 0x06, 0x55, 0x51, 0x82, 0xC7, 0xA9, 0x4A, + 0x87, 0x47, 0xB0, 0x3B, 0x07, 0x60, 0x7B, 0xE3 + }, + { + 0x81, 0xCE, 0x82, 0x63, 0x7D, 0x81, 0x87, 0xBC, + 0x6C, 0x09, 0x67, 0xF6, 0x1D, 0x0E, 0xE5, 0x0B, + 0x63, 0x11, 0x03, 0xF4, 0xA2, 0xB0, 0x27, 0xE9, + 0x4A, 0x72, 0xBE, 0x24, 0x65, 0xD5, 0x31, 0xD7, + 0xDA, 0x4C, 0x8B, 0x61, 0xA7, 0xAC, 0xCC, 0xC3, + 0x41, 0x48, 0x11, 0x92, 0x01, 0xD0, 0xF3, 0xC4, + 0x10, 0x87, 0xA7, 0x86, 0x2B, 0x1F, 0x0B, 0x3F, + 0xCD, 0xEB, 0x62, 0xB2, 0xFB, 0x10, 0x1C, 0xAB + }, + { + 0x95, 0xAC, 0xBB, 0x8B, 0xB3, 0xA1, 0x04, 0x9F, + 0x0B, 0x39, 0xFB, 0x1A, 0x6D, 0x59, 0x8A, 0x6E, + 0x4D, 0xD2, 0x90, 0x34, 0x29, 0x82, 0xE5, 0xB5, + 0x5F, 0x21, 0x7B, 0xE1, 0x97, 0x81, 0xB3, 0x67, + 0x0D, 0xD1, 0xA6, 0x43, 0xF1, 0xE2, 0xD9, 0x4A, + 0xAC, 0x31, 0xA9, 0x74, 0xA3, 0x49, 0x7B, 0xB2, + 0x65, 0xBC, 0x24, 0x23, 0x49, 0x2F, 0xDE, 0x06, + 0xF5, 0x83, 0x15, 0xF4, 0xFE, 0x9D, 0x1B, 0xC6 + }, + { + 0xC3, 0x29, 0x8D, 0x51, 0x31, 0x5E, 0x1C, 0x07, + 0xDB, 0xB8, 0x8D, 0xE4, 0xC9, 0x41, 0xE1, 0x1B, + 0xE5, 0x23, 0x51, 0x52, 0x77, 0xAE, 0xB4, 0x4C, + 0xC0, 0x00, 0x47, 0xAE, 0x49, 0x58, 0x6E, 0x6F, + 0xA6, 0xDE, 0x2B, 0xF1, 0x76, 0xE5, 0xA6, 0xD5, + 0xEA, 0xA6, 0xD2, 0x10, 0x19, 0x2D, 0x5A, 0x59, + 0x55, 0x9A, 0x16, 0x18, 0x94, 0x8E, 0xEE, 0xF8, + 0x99, 0xA3, 0x6B, 0xE8, 0xBA, 0xB7, 0xAB, 0x4A + }, + { + 0xBD, 0xA9, 0xC7, 0x4E, 0x52, 0xE7, 0xF6, 0xC9, + 0x63, 0x38, 0x80, 0xE2, 0xE6, 0x90, 0xB0, 0x8D, + 0x4E, 0x74, 0xCD, 0x24, 0x77, 0xF1, 0xCE, 0x73, + 0x37, 0x85, 0x2A, 0x47, 0x07, 0x06, 0x03, 0x68, + 0x6E, 0x6A, 0x64, 0x3E, 0x61, 0xC0, 0x9C, 0x1B, + 0x86, 0x02, 0xAA, 0x23, 0xCB, 0x0F, 0xB1, 0x96, + 0x93, 0x13, 0x6E, 0x81, 0xD4, 0x90, 0xCF, 0x19, + 0xBF, 0x5A, 0xCE, 0x3C, 0xD9, 0x4F, 0x0D, 0x4B + }, + { + 0x31, 0xB5, 0xEF, 0x54, 0x5B, 0x83, 0x3D, 0x7B, + 0xF9, 0x93, 0x32, 0x99, 0x89, 0x87, 0xA2, 0xDF, + 0x4A, 0x99, 0xFF, 0x77, 0x51, 0xED, 0x71, 0x47, + 0x8A, 0x92, 0x1F, 0x9C, 0x76, 0x07, 0xB4, 0xEE, + 0xD0, 0xAF, 0xA8, 0x98, 0x2D, 0xC1, 0xF4, 0xB7, + 0x8D, 0x8A, 0x24, 0x77, 0x28, 0x9F, 0x11, 0x5E, + 0xDC, 0x6F, 0x75, 0x30, 0xB8, 0x40, 0xE6, 0xB7, + 0x0E, 0xE2, 0x7E, 0xDC, 0x13, 0xA0, 0x31, 0x13 + }, + { + 0x71, 0x10, 0x93, 0xBC, 0xD9, 0xC7, 0xDA, 0x6E, + 0x6A, 0x48, 0x59, 0x47, 0x07, 0xC5, 0xC6, 0xBF, + 0xC7, 0x3D, 0xE1, 0x97, 0x78, 0xAA, 0x03, 0xCB, + 0x16, 0x9E, 0xDE, 0x97, 0xF1, 0x27, 0xC9, 0xFA, + 0xF4, 0x27, 0x68, 0xDF, 0x6B, 0xDA, 0x0F, 0xA6, + 0x9C, 0xB1, 0x32, 0x75, 0xD7, 0x6E, 0x18, 0x1E, + 0x9C, 0xBD, 0x2C, 0x38, 0xEA, 0x4D, 0xF5, 0x6A, + 0x0F, 0x04, 0xAD, 0xC4, 0x84, 0xD6, 0x2E, 0x66 + }, + { + 0xAA, 0xB4, 0xFF, 0x6F, 0x97, 0x05, 0xF7, 0x29, + 0x82, 0xDD, 0x08, 0x02, 0xDB, 0xBF, 0xFE, 0xA1, + 0xDB, 0xAA, 0x6A, 0x08, 0x2D, 0x0C, 0xA4, 0xFE, + 0x67, 0xED, 0xF2, 0x7F, 0x09, 0x41, 0x3E, 0x97, + 0xCE, 0x59, 0x0B, 0x17, 0xC7, 0x7A, 0x1D, 0x07, + 0x93, 0x1C, 0x0E, 0x2F, 0xD0, 0xFC, 0x1D, 0xBC, + 0x19, 0xE1, 0xB8, 0x44, 0x0E, 0x1F, 0xD2, 0xC6, + 0x1F, 0xF1, 0x8D, 0xD8, 0x5F, 0xEF, 0x91, 0x0D + }, + { + 0x0D, 0x5C, 0x02, 0x98, 0xE8, 0xA3, 0x3E, 0x1E, + 0x55, 0x35, 0x2B, 0xC1, 0x07, 0x79, 0xCD, 0x3D, + 0xF8, 0x09, 0x2A, 0xC7, 0x6C, 0xC8, 0x9C, 0x66, + 0x61, 0x7A, 0x8F, 0x26, 0x40, 0x6A, 0x66, 0xD5, + 0xBE, 0x6F, 0x72, 0x15, 0xB0, 0x30, 0x05, 0x48, + 0x36, 0x9D, 0x89, 0x33, 0x7A, 0xF4, 0xD9, 0x65, + 0xD8, 0xF8, 0xC4, 0xEF, 0x97, 0x95, 0xA2, 0x08, + 0xA7, 0x0B, 0xEA, 0x44, 0x61, 0xF9, 0x9C, 0x04 + }, + { + 0x51, 0x88, 0xE6, 0xC3, 0xA1, 0x39, 0xCC, 0x48, + 0x77, 0xAC, 0x78, 0xBF, 0x84, 0x52, 0x53, 0xDD, + 0x4F, 0x32, 0x62, 0x57, 0xAA, 0xE4, 0x5F, 0x26, + 0xD9, 0xD0, 0xA1, 0x2F, 0x5A, 0x3B, 0xA6, 0x35, + 0x41, 0x2B, 0x39, 0x58, 0x2E, 0x65, 0xAD, 0x48, + 0xA4, 0x2A, 0x0A, 0xE1, 0x88, 0xEF, 0xDF, 0x93, + 0xFC, 0x9A, 0x57, 0x52, 0x50, 0x0C, 0xEE, 0xCE, + 0x46, 0x3A, 0x39, 0xDC, 0x29, 0x31, 0xDB, 0x55 + }, + { + 0x2D, 0x18, 0x3B, 0x48, 0xA8, 0x65, 0x8F, 0xB7, + 0x30, 0x5A, 0x44, 0xF5, 0xA2, 0xBF, 0x2F, 0x6E, + 0xE1, 0xF3, 0x34, 0x54, 0xB9, 0xC8, 0xF0, 0x5C, + 0x7B, 0xD5, 0xF7, 0xAA, 0x9E, 0x3E, 0x18, 0xA6, + 0xEA, 0xCF, 0x24, 0x2F, 0x65, 0xEA, 0xAA, 0x87, + 0x72, 0x2D, 0xF0, 0x7C, 0xF0, 0xE7, 0x42, 0x07, + 0xA9, 0x2C, 0x8E, 0x41, 0xF4, 0xCD, 0x3B, 0x1D, + 0x6D, 0xF0, 0x83, 0x0B, 0xBA, 0x65, 0x2D, 0x83 + }, + { + 0x8E, 0x8F, 0x0A, 0xE5, 0xAE, 0x6A, 0x57, 0x5F, + 0xFA, 0xF1, 0x63, 0x01, 0xF4, 0xFD, 0x96, 0x8E, + 0x33, 0xC2, 0x63, 0x64, 0x4A, 0x40, 0x39, 0x79, + 0xC8, 0x31, 0xFC, 0xAB, 0x1C, 0x94, 0xB9, 0x68, + 0x80, 0x10, 0x08, 0x3A, 0x56, 0x92, 0xC8, 0x11, + 0x0F, 0x8B, 0x25, 0x97, 0x96, 0xAC, 0x6E, 0x66, + 0xE2, 0x3C, 0x53, 0x4E, 0x7C, 0xC6, 0xC5, 0x17, + 0x0F, 0x7D, 0xF0, 0xCA, 0xA6, 0x2E, 0x34, 0x89 + }, + { + 0xDE, 0x22, 0x75, 0x28, 0x0C, 0xC1, 0xE4, 0xBE, + 0xCD, 0x28, 0xC6, 0x48, 0xFC, 0xD1, 0xDF, 0xE0, + 0x80, 0x4A, 0x8E, 0x40, 0x10, 0xD3, 0x39, 0x6D, + 0x55, 0xBE, 0x81, 0x69, 0xB1, 0x59, 0x3C, 0xDD, + 0xF3, 0x6E, 0x31, 0x3A, 0x9F, 0x66, 0x25, 0xA6, + 0xCD, 0x3C, 0xD0, 0x95, 0x9A, 0xA5, 0xE8, 0x16, + 0x7D, 0xD7, 0x84, 0x91, 0xCC, 0x36, 0xD1, 0x21, + 0x42, 0x91, 0x49, 0xBA, 0x74, 0xAF, 0x1E, 0xD3 + }, + { + 0x8E, 0xC1, 0xAD, 0x8D, 0x67, 0x39, 0x71, 0xC7, + 0xA5, 0x46, 0x6E, 0x67, 0x44, 0xF7, 0x1E, 0xFE, + 0x36, 0xB4, 0xB6, 0x62, 0x8C, 0x56, 0xDF, 0x2E, + 0x1A, 0x2B, 0x21, 0xCA, 0x6B, 0x25, 0xFF, 0xFC, + 0x70, 0xDD, 0x00, 0xD9, 0x46, 0xAD, 0x44, 0x61, + 0xF2, 0x66, 0x3D, 0xBD, 0xBF, 0xF6, 0xB9, 0x20, + 0x01, 0x16, 0x82, 0x11, 0xAB, 0xDB, 0xB2, 0xDA, + 0x54, 0x44, 0xF3, 0x19, 0xB7, 0x21, 0x14, 0x13 + }, + { + 0xD1, 0x81, 0x56, 0xDE, 0x8A, 0xDB, 0x68, 0x88, + 0x9C, 0xC5, 0xCC, 0x7D, 0x92, 0x85, 0x5F, 0x98, + 0xDF, 0xBA, 0x72, 0x1A, 0x6F, 0xF6, 0xAC, 0xD8, + 0x7B, 0xD2, 0x1A, 0xD8, 0xA4, 0xC1, 0x6A, 0x47, + 0xE7, 0x09, 0x3B, 0x2F, 0x4A, 0x74, 0x94, 0xE9, + 0x1C, 0x67, 0xE6, 0x70, 0x6B, 0xF7, 0x5A, 0x2C, + 0xF8, 0x46, 0xED, 0xD2, 0xB8, 0xC6, 0x5D, 0xDF, + 0xB2, 0xD7, 0x47, 0xAC, 0xC2, 0x18, 0x38, 0x59 + }, + { + 0x1B, 0xF1, 0xC9, 0x72, 0xC7, 0x94, 0xA5, 0x35, + 0x64, 0x77, 0x9D, 0x4A, 0x06, 0x52, 0x88, 0x12, + 0xFF, 0x66, 0x31, 0x94, 0xD0, 0x7A, 0xCD, 0x0F, + 0x40, 0x9D, 0xE5, 0x07, 0x80, 0x1C, 0xA7, 0x41, + 0x02, 0xF8, 0x89, 0xA5, 0x19, 0x88, 0x5E, 0x6C, + 0x16, 0xD3, 0x19, 0x91, 0xDB, 0x98, 0xBD, 0xAB, + 0xBC, 0x60, 0x9D, 0x46, 0x59, 0xE3, 0xEC, 0x53, + 0x4D, 0x17, 0x0C, 0x9A, 0xFA, 0x20, 0x13, 0xF9 + }, + { + 0x83, 0xA0, 0x44, 0x5A, 0xF8, 0xB3, 0xCF, 0x9C, + 0xCC, 0xE1, 0xC2, 0x51, 0xE1, 0x0D, 0x02, 0xBE, + 0xF5, 0xE1, 0xAF, 0xF6, 0x83, 0x43, 0xD3, 0x20, + 0x84, 0xF6, 0x8D, 0xA3, 0x52, 0xDB, 0xA1, 0x49, + 0x44, 0x2B, 0xDD, 0x32, 0x31, 0x0C, 0x8D, 0xD0, + 0xD7, 0xFD, 0x90, 0x42, 0xED, 0x0B, 0xF6, 0xDF, + 0x63, 0xB6, 0x6C, 0xF7, 0x81, 0xBD, 0x52, 0xA4, + 0xA6, 0x9C, 0xF7, 0x3F, 0xF0, 0xC0, 0x4C, 0x02 + }, + { + 0xBE, 0x34, 0xC1, 0x22, 0xCE, 0x41, 0x76, 0xFB, + 0xAB, 0xCA, 0xCB, 0x68, 0xCB, 0x46, 0x6E, 0xB6, + 0x63, 0x01, 0x8C, 0x55, 0x76, 0x4C, 0x1B, 0x56, + 0xAD, 0x51, 0x03, 0xC5, 0x04, 0x4F, 0xCB, 0xEB, + 0x30, 0x3C, 0x00, 0xD9, 0xE6, 0xB0, 0xB9, 0x92, + 0x7D, 0x31, 0x9B, 0xB5, 0xD4, 0x6A, 0x0F, 0x52, + 0xCA, 0xEC, 0xED, 0xE0, 0x55, 0x2A, 0x4E, 0x78, + 0x8E, 0x67, 0xB7, 0x95, 0x13, 0xB8, 0xB1, 0xE6 + }, + { + 0xE0, 0xF1, 0xDB, 0xBB, 0x42, 0x4B, 0x74, 0x11, + 0xBE, 0x2F, 0xA8, 0x92, 0x11, 0x5E, 0x07, 0x45, + 0xED, 0xD2, 0x8C, 0x6D, 0x36, 0x66, 0x6A, 0xE0, + 0xCB, 0x4C, 0x47, 0x7E, 0x8B, 0x4E, 0x79, 0xEC, + 0x2B, 0x12, 0x28, 0x7E, 0xEF, 0xB3, 0x75, 0xC7, + 0x21, 0x98, 0x4C, 0x13, 0x97, 0xDB, 0x02, 0x26, + 0x95, 0x09, 0xEA, 0x06, 0x99, 0x33, 0x02, 0x63, + 0xB7, 0xA0, 0x86, 0x7E, 0x69, 0x22, 0xBF, 0xB1 + }, + { + 0x5C, 0x90, 0x22, 0xEF, 0x8B, 0x12, 0x24, 0xF6, + 0xBE, 0x5B, 0xE0, 0x33, 0x74, 0x5B, 0x00, 0x0B, + 0x56, 0xE2, 0x53, 0xA9, 0x8A, 0xEB, 0x08, 0x02, + 0x0D, 0xE2, 0x26, 0xE1, 0x63, 0x6E, 0x27, 0x5B, + 0x04, 0x7D, 0x86, 0x23, 0xCF, 0x69, 0xFA, 0x5E, + 0xC1, 0x7F, 0xB5, 0x5E, 0x20, 0xA0, 0x55, 0xB8, + 0xD7, 0x55, 0xF9, 0x7C, 0x79, 0x7C, 0xC3, 0x9F, + 0xC4, 0x48, 0x96, 0xDD, 0xA8, 0xB3, 0x97, 0x3A + }, + { + 0x4B, 0x7D, 0xED, 0x05, 0xE4, 0x34, 0x54, 0x38, + 0xB6, 0x80, 0x1E, 0x77, 0x5B, 0xB6, 0x71, 0x8F, + 0x94, 0xDC, 0xD3, 0xE0, 0xFF, 0x09, 0xF8, 0x94, + 0x23, 0x99, 0x91, 0x41, 0xC9, 0x99, 0xDE, 0x5B, + 0xFA, 0x4A, 0x91, 0x1F, 0x8B, 0x07, 0x08, 0xD0, + 0xEE, 0x9E, 0x5C, 0x8A, 0xB6, 0xC5, 0xF6, 0x51, + 0x26, 0x60, 0x93, 0xBE, 0xF1, 0xEA, 0x96, 0x59, + 0xC2, 0x1A, 0xBB, 0x77, 0x9D, 0x68, 0xB9, 0x44 + }, + { + 0x1E, 0x89, 0xE3, 0x5A, 0xAB, 0x37, 0xB2, 0xB3, + 0x9A, 0x27, 0x4C, 0xE5, 0x0C, 0x84, 0x4E, 0xC3, + 0xE5, 0x9E, 0xBA, 0xCF, 0x29, 0x72, 0x54, 0x67, + 0x9E, 0x20, 0x19, 0x38, 0x83, 0xB4, 0xA3, 0x5B, + 0x4A, 0x7F, 0x68, 0x86, 0x6A, 0x9F, 0xAE, 0x64, + 0x7C, 0x1F, 0xBD, 0xDF, 0x24, 0xB6, 0x92, 0x51, + 0xDF, 0x6F, 0xF4, 0x9F, 0x51, 0xF4, 0xB9, 0xD7, + 0xB9, 0x99, 0xE1, 0x2F, 0x7A, 0xDE, 0x23, 0x75 + }, + { + 0x73, 0x22, 0xA9, 0xEF, 0x70, 0xB4, 0x05, 0x33, + 0x73, 0x73, 0x61, 0xD9, 0xBE, 0xAA, 0x5F, 0x4B, + 0xEA, 0x73, 0x73, 0x51, 0xAB, 0xCA, 0xE0, 0x04, + 0x7D, 0x72, 0xCE, 0xA4, 0xAE, 0xE2, 0x0D, 0xEC, + 0x07, 0x53, 0xC7, 0xD3, 0xD5, 0xFF, 0xF5, 0xEA, + 0x27, 0x87, 0x9F, 0x5B, 0x3F, 0x06, 0xDD, 0xBA, + 0x92, 0xE2, 0xBD, 0xBF, 0x96, 0xA6, 0x71, 0xB3, + 0x16, 0x01, 0xF8, 0x0B, 0xEF, 0x6D, 0x61, 0x2F + }, + { + 0x7A, 0x72, 0x7B, 0x46, 0x25, 0x2B, 0x7E, 0x74, + 0x34, 0xF3, 0x1A, 0xE6, 0x7A, 0xF0, 0x68, 0x4A, + 0xB5, 0x0C, 0x20, 0xA1, 0x55, 0x60, 0x1C, 0x26, + 0xDA, 0xF5, 0x07, 0x25, 0x54, 0x28, 0xDF, 0xDA, + 0x6D, 0xE5, 0x8B, 0x7E, 0x50, 0xE8, 0xA1, 0x45, + 0x74, 0x2D, 0xB8, 0xBF, 0x7B, 0xDB, 0xFD, 0x1B, + 0x57, 0x3A, 0xA9, 0xD1, 0x74, 0x42, 0xDD, 0xAB, + 0x19, 0x3B, 0xE1, 0xB5, 0x1A, 0x1C, 0x92, 0x99 + }, + { + 0xD6, 0xB6, 0xCA, 0x44, 0x71, 0x20, 0x64, 0xD3, + 0x0B, 0x55, 0xD7, 0x08, 0x64, 0x2C, 0xBE, 0x9C, + 0x40, 0xFB, 0x9F, 0xAB, 0x96, 0x6D, 0xD4, 0x7A, + 0xA4, 0x9C, 0x1E, 0xD4, 0xF5, 0xFA, 0x04, 0x75, + 0xC9, 0x6F, 0x25, 0x39, 0x62, 0xD3, 0xF2, 0x26, + 0xA6, 0xD6, 0xF2, 0x54, 0x3B, 0xEF, 0xB4, 0x6D, + 0x0C, 0x19, 0xDD, 0xC1, 0x71, 0xF0, 0xA0, 0xC4, + 0xA7, 0x11, 0x8E, 0xFD, 0x75, 0x72, 0xA4, 0x56 + }, + { + 0x47, 0xF5, 0x6D, 0x1B, 0xE7, 0x57, 0xAC, 0xFB, + 0x63, 0xFA, 0xFC, 0xB0, 0xCF, 0x07, 0x32, 0xCD, + 0xCE, 0xD5, 0xE4, 0xFD, 0x73, 0x03, 0x50, 0x80, + 0xBC, 0x0B, 0x29, 0xFF, 0xA8, 0x40, 0xD5, 0x1E, + 0x80, 0xC6, 0x56, 0xFF, 0x88, 0xDD, 0x40, 0xA8, + 0xF7, 0xA0, 0xE9, 0x8E, 0x03, 0xF5, 0x05, 0x1B, + 0x1A, 0xF2, 0x98, 0x63, 0x06, 0xC0, 0xCB, 0x89, + 0xD0, 0x79, 0x67, 0x8D, 0x5A, 0xB9, 0xC2, 0x6E + }, + { + 0x0B, 0xEE, 0xA3, 0x4C, 0x84, 0xDC, 0x70, 0xD5, + 0x27, 0x3D, 0xB7, 0xB4, 0xC7, 0x20, 0x76, 0xA2, + 0x34, 0x3C, 0x4B, 0xCD, 0x0A, 0xE5, 0x80, 0x9B, + 0x49, 0x45, 0x2A, 0x62, 0xD7, 0xF6, 0x34, 0x4B, + 0x47, 0xE0, 0x3B, 0x03, 0x58, 0x6E, 0x9E, 0x5F, + 0x2F, 0x01, 0xA9, 0x9A, 0x76, 0xE5, 0x7C, 0x24, + 0x43, 0x06, 0x57, 0x8E, 0xA3, 0xA5, 0xC7, 0xF2, + 0x76, 0x78, 0x58, 0xAA, 0x59, 0xBD, 0xCF, 0x3D + }, + { + 0x4D, 0x1C, 0x9D, 0xCD, 0xA7, 0x62, 0xFD, 0x15, + 0x2E, 0x8B, 0x04, 0x7D, 0x79, 0x9B, 0xA9, 0x86, + 0xDA, 0xEC, 0xBC, 0xB2, 0x25, 0x0A, 0xCF, 0x60, + 0x68, 0x41, 0xBB, 0xDE, 0x60, 0xEE, 0xA7, 0xB6, + 0x90, 0x3A, 0x92, 0x90, 0x1B, 0xB9, 0x6E, 0x79, + 0x67, 0x5C, 0x5A, 0xA9, 0xB4, 0xF8, 0xC2, 0x93, + 0x0B, 0xD7, 0x72, 0x23, 0x70, 0x48, 0x71, 0x8A, + 0x34, 0x9A, 0x24, 0xAE, 0x98, 0xDF, 0xB3, 0x7D + }, + { + 0xA1, 0xE4, 0x20, 0xD7, 0x84, 0x02, 0xC1, 0x7B, + 0xBF, 0x43, 0xCF, 0xA2, 0x4B, 0xE5, 0x97, 0xCD, + 0xD0, 0x14, 0x89, 0xEC, 0x64, 0x28, 0x4D, 0x4F, + 0xBF, 0x6B, 0xEA, 0xC9, 0xAC, 0x61, 0x35, 0x2A, + 0xC1, 0x1A, 0x98, 0x72, 0xA2, 0x6D, 0x90, 0x6E, + 0x91, 0x6B, 0x78, 0x2F, 0x7C, 0xC9, 0x6E, 0x5C, + 0x3F, 0xC3, 0xBF, 0x27, 0x2E, 0xA3, 0x72, 0xCF, + 0xD5, 0xFC, 0xDB, 0x97, 0xCB, 0x84, 0xBA, 0x4E + }, + { + 0x66, 0x2E, 0x8D, 0x39, 0x4A, 0x4C, 0x09, 0x24, + 0xC1, 0xFF, 0x32, 0xC1, 0xBF, 0xD6, 0xF5, 0xA7, + 0xE9, 0x11, 0x1B, 0x67, 0x1B, 0xA1, 0xA6, 0x0C, + 0xBC, 0xF3, 0x82, 0x14, 0xD7, 0x1B, 0x24, 0x33, + 0x1F, 0x0E, 0x0B, 0xB6, 0xFB, 0xA0, 0xAF, 0x1D, + 0x4B, 0xC4, 0x6A, 0x11, 0x67, 0xEA, 0xA0, 0x28, + 0x72, 0xA6, 0x81, 0x28, 0xB0, 0xAC, 0x88, 0x9B, + 0x97, 0xC2, 0x66, 0x3F, 0x15, 0xCD, 0x6E, 0x94 + }, + { + 0x6E, 0xEB, 0xFA, 0xE6, 0x4F, 0x39, 0x1F, 0xD7, + 0x02, 0xA6, 0xCB, 0x5A, 0x70, 0x70, 0x91, 0xA5, + 0x0C, 0x84, 0x78, 0x85, 0x17, 0xBB, 0x53, 0x81, + 0x13, 0x2F, 0x26, 0x38, 0x6D, 0x2C, 0xDF, 0x32, + 0xB2, 0x02, 0x06, 0xF4, 0x3F, 0x15, 0x7A, 0x96, + 0x0D, 0x6A, 0x3F, 0xAC, 0xA5, 0x4D, 0x72, 0xF7, + 0xAF, 0xC6, 0x19, 0xF2, 0x3A, 0x1C, 0xA9, 0xB7, + 0x08, 0x0D, 0x4B, 0x91, 0x11, 0x22, 0x0B, 0xAF + }, + { + 0x87, 0xAC, 0xDA, 0x33, 0x52, 0x76, 0xF1, 0xD9, + 0x2F, 0x74, 0x49, 0x89, 0xBA, 0x4B, 0xC2, 0x09, + 0xDA, 0x01, 0xEB, 0x34, 0xBA, 0x34, 0x60, 0x5E, + 0xC0, 0xA0, 0x20, 0x2F, 0x3B, 0xF6, 0xB7, 0x77, + 0x65, 0xBB, 0x03, 0x27, 0x22, 0x09, 0xCA, 0xE8, + 0x29, 0xF9, 0xD4, 0x65, 0x2E, 0x6E, 0x5D, 0xD2, + 0xE1, 0x7B, 0x24, 0xAF, 0xBB, 0xFA, 0xDD, 0x05, + 0x87, 0xF9, 0x08, 0xAD, 0x71, 0x49, 0xF6, 0xD0 + }, + { + 0xBC, 0x27, 0x0C, 0x1F, 0x41, 0x55, 0xA4, 0x49, + 0x0C, 0x61, 0x83, 0x8B, 0xE9, 0x0D, 0x38, 0x5B, + 0x63, 0x98, 0xD0, 0xD2, 0xC9, 0xFE, 0x8F, 0x86, + 0x61, 0x8F, 0x88, 0xCE, 0x66, 0xEF, 0x43, 0x43, + 0xCD, 0x1C, 0xF3, 0x1B, 0x64, 0xC5, 0xFE, 0x34, + 0x78, 0x42, 0x43, 0x33, 0x8D, 0x21, 0xE5, 0x51, + 0xE0, 0x07, 0x36, 0x31, 0x91, 0x3F, 0xF7, 0x6E, + 0x02, 0x9A, 0x10, 0x31, 0x7F, 0xA8, 0x91, 0xC1 + }, + { + 0xA0, 0x53, 0x53, 0x02, 0x42, 0x18, 0x77, 0x1E, + 0xD6, 0x53, 0xDB, 0x1D, 0xE4, 0x2B, 0x4A, 0x16, + 0xF1, 0x11, 0x3A, 0xB6, 0xB0, 0x3D, 0x9F, 0x58, + 0x0D, 0xDA, 0x92, 0x1E, 0x70, 0x2A, 0x9C, 0x86, + 0x78, 0xD8, 0x88, 0xA8, 0xC0, 0x3C, 0x79, 0x62, + 0xC0, 0x7E, 0x54, 0xE8, 0xEC, 0xC4, 0xE3, 0xE3, + 0x54, 0x02, 0x4D, 0xFF, 0x49, 0x88, 0x74, 0x2B, + 0x53, 0xA2, 0x77, 0x73, 0xE6, 0x4B, 0x44, 0x4A + }, + { + 0xC2, 0x72, 0x38, 0xBE, 0x7F, 0x04, 0xB3, 0xBD, + 0x90, 0x0E, 0x9B, 0xE7, 0xAA, 0x09, 0xFE, 0x00, + 0xFE, 0xCE, 0xFD, 0x0F, 0x59, 0xB0, 0x41, 0x5B, + 0xB8, 0x6C, 0xFB, 0x14, 0xC0, 0xA1, 0x1C, 0xE4, + 0x51, 0xE6, 0xD6, 0xDA, 0xBE, 0xB4, 0xEE, 0x47, + 0x6D, 0xEF, 0xA1, 0xBD, 0x89, 0xA0, 0xD9, 0xC7, + 0x91, 0xE0, 0x63, 0x93, 0x57, 0x6C, 0x2E, 0x9D, + 0x0F, 0x8F, 0x7F, 0xAA, 0x3F, 0x0A, 0xED, 0x92 + }, + { + 0x10, 0x75, 0x2E, 0x42, 0x2A, 0x47, 0x6F, 0xE0, + 0x7A, 0xE1, 0x37, 0xB1, 0x1B, 0x2F, 0x7F, 0xF3, + 0x51, 0x8A, 0x97, 0x1A, 0x0E, 0x81, 0xFE, 0xBE, + 0xB2, 0x52, 0x51, 0xE1, 0x5C, 0x9F, 0x5D, 0x56, + 0x69, 0xFB, 0x34, 0x9D, 0x0E, 0x2A, 0xE0, 0x8C, + 0x6D, 0x52, 0x2B, 0x64, 0x6A, 0xD9, 0xF1, 0xFF, + 0xAF, 0x84, 0x5C, 0x11, 0xDA, 0xC9, 0xF7, 0x88, + 0xDD, 0x94, 0x69, 0xBC, 0xC7, 0x21, 0x55, 0x58 + }, + { + 0xD4, 0x55, 0x39, 0xC8, 0x3B, 0x98, 0x40, 0x47, + 0x04, 0x93, 0x5D, 0xD7, 0x35, 0x24, 0xB9, 0x91, + 0x3D, 0x71, 0xC9, 0x25, 0x78, 0xC8, 0x04, 0xF3, + 0x2E, 0x80, 0xDD, 0x08, 0x23, 0x14, 0x70, 0x8F, + 0x72, 0xCC, 0xB7, 0x0E, 0x4D, 0xFB, 0x4D, 0xD8, + 0x26, 0x38, 0xC6, 0xC9, 0x55, 0x93, 0x97, 0xCE, + 0xE3, 0x8D, 0x31, 0xF0, 0x13, 0x9A, 0x17, 0x0D, + 0x18, 0x9C, 0x13, 0x66, 0x37, 0xC4, 0x4E, 0x9A + }, + { + 0xCB, 0xA9, 0x2C, 0xB6, 0x1E, 0x6D, 0xF8, 0x08, + 0x30, 0x8A, 0xA1, 0x72, 0xF1, 0x36, 0x1A, 0xF8, + 0x63, 0x60, 0x47, 0x84, 0xB2, 0xCA, 0xBF, 0x1E, + 0x38, 0x9A, 0xF4, 0xEB, 0x70, 0x85, 0xFA, 0x60, + 0xD2, 0x0C, 0xF4, 0xBE, 0xFE, 0xB8, 0x43, 0x11, + 0x11, 0xAE, 0x8A, 0x93, 0x9F, 0x92, 0x76, 0x58, + 0x0A, 0x6C, 0xBE, 0x00, 0x98, 0xFF, 0x08, 0xAE, + 0x79, 0x54, 0x15, 0xA4, 0xE9, 0x7A, 0xA5, 0x87 + }, + { + 0xBC, 0x5D, 0x00, 0x69, 0xAC, 0xAD, 0x3F, 0x52, + 0x25, 0x2B, 0x6C, 0x99, 0xD7, 0x54, 0x66, 0xBD, + 0x3A, 0x80, 0x81, 0x46, 0x59, 0xE0, 0xE2, 0x1E, + 0xC2, 0x59, 0xFD, 0x6D, 0xF0, 0x82, 0x70, 0x92, + 0xFE, 0x8A, 0x6C, 0x64, 0x8E, 0xBD, 0x94, 0x2D, + 0x25, 0x1A, 0xCA, 0x83, 0xAC, 0xCC, 0x79, 0x1D, + 0x16, 0xA7, 0xBC, 0x2B, 0xCC, 0xC7, 0x7B, 0x4B, + 0xC7, 0xCE, 0x1F, 0xC2, 0x02, 0xDD, 0xEA, 0x90 + }, + { + 0x4A, 0x2C, 0x9B, 0x6C, 0x37, 0x7A, 0x81, 0x62, + 0xA5, 0x0B, 0x3A, 0x24, 0xC3, 0x2D, 0x85, 0xE4, + 0x53, 0xC2, 0x58, 0x11, 0xE6, 0xBA, 0xE3, 0x39, + 0x80, 0x61, 0xE2, 0x3E, 0xF5, 0xBA, 0x17, 0x34, + 0x28, 0x54, 0x95, 0xBD, 0x0B, 0xE2, 0xEC, 0x9C, + 0x11, 0x23, 0xE1, 0x27, 0xC2, 0x56, 0x10, 0xB6, + 0x60, 0x7A, 0xAF, 0xB3, 0x48, 0xE7, 0x25, 0xC6, + 0xA2, 0xA9, 0x70, 0x2A, 0xEA, 0x32, 0x8D, 0xA8 + }, + { + 0x78, 0x45, 0xFF, 0x4A, 0xDF, 0x9E, 0x5F, 0x36, + 0xB5, 0xC8, 0xF9, 0xAA, 0x3F, 0xFB, 0xDD, 0xA6, + 0x69, 0xFD, 0x58, 0xDB, 0x68, 0x52, 0x9B, 0x80, + 0xF3, 0x8D, 0xCB, 0x13, 0x77, 0xEF, 0xF8, 0xBE, + 0xD7, 0xAF, 0xFA, 0xB8, 0xD0, 0x7A, 0x72, 0x9D, + 0x0A, 0xA9, 0x78, 0x3F, 0xA0, 0x01, 0x3C, 0x4F, + 0x9C, 0x36, 0x3B, 0x48, 0xA8, 0xD3, 0x91, 0x31, + 0xFD, 0x72, 0x6A, 0xD7, 0x39, 0xB3, 0x50, 0x2B + }, + { + 0xE4, 0x2A, 0xF5, 0x8A, 0x09, 0x74, 0x31, 0xE2, + 0x7E, 0x83, 0xFC, 0x49, 0xCA, 0x86, 0xBC, 0xCA, + 0x8C, 0xAE, 0xFD, 0x55, 0xFA, 0x34, 0xBB, 0xEB, + 0x22, 0x20, 0xEE, 0x89, 0x2B, 0x8D, 0x72, 0x93, + 0x9E, 0x85, 0x98, 0x89, 0x0A, 0x7D, 0xB9, 0x43, + 0xCB, 0x69, 0x9C, 0x21, 0x9D, 0x54, 0xB7, 0x4D, + 0x6F, 0x0B, 0xC2, 0x82, 0x80, 0xBE, 0x26, 0x39, + 0xC0, 0x50, 0x76, 0x64, 0x4A, 0x64, 0x50, 0x3D + }, + { + 0x8C, 0xA7, 0x2E, 0x22, 0xB2, 0x05, 0xBC, 0x78, + 0x4B, 0x3A, 0x95, 0x96, 0xE2, 0xB9, 0xCF, 0x3A, + 0xE0, 0x2D, 0x3F, 0x22, 0x06, 0xF4, 0x6F, 0xC3, + 0x68, 0xE4, 0x81, 0xB4, 0xA0, 0xD1, 0x7F, 0x82, + 0xE1, 0x0C, 0xBF, 0x90, 0x19, 0x73, 0x11, 0x25, + 0xDB, 0xE3, 0x4E, 0x79, 0x58, 0x58, 0xCD, 0x7F, + 0xA8, 0x65, 0xFA, 0x88, 0x66, 0x8F, 0x27, 0x35, + 0xE0, 0x33, 0xA4, 0xC1, 0xC5, 0x5F, 0x0A, 0x58 + }, + { + 0x97, 0x38, 0xAD, 0x45, 0x0F, 0xB2, 0xD0, 0x4C, + 0xD0, 0x48, 0x4F, 0x62, 0xBE, 0xD0, 0xAF, 0x21, + 0x9C, 0x5E, 0xD7, 0x68, 0x82, 0xBD, 0x62, 0xA9, + 0xB3, 0x20, 0xE2, 0xAB, 0xA8, 0xB9, 0x0E, 0xEE, + 0x6D, 0xB1, 0x17, 0x0A, 0x7F, 0x66, 0x38, 0xD9, + 0xBF, 0x04, 0xAB, 0x04, 0x29, 0xF3, 0xB8, 0x37, + 0x5F, 0xEA, 0xC9, 0x27, 0xB2, 0x63, 0xC7, 0xAA, + 0xF9, 0xA3, 0xE3, 0x52, 0xB1, 0x61, 0xD4, 0xAD + }, + { + 0x60, 0x43, 0xF9, 0x4A, 0xBB, 0x52, 0xBF, 0xD5, + 0x95, 0xF5, 0xED, 0x44, 0x45, 0xE9, 0xDA, 0xD3, + 0x28, 0x49, 0xBC, 0x9C, 0xFA, 0x25, 0xC4, 0xF6, + 0xC4, 0xA3, 0x40, 0x80, 0xA7, 0xD8, 0x9C, 0x4F, + 0x2E, 0xA6, 0x37, 0xBF, 0x9D, 0xD7, 0xA0, 0x47, + 0xC5, 0xC0, 0xF7, 0xED, 0x65, 0x4A, 0xAC, 0x00, + 0x02, 0x64, 0xAB, 0xE6, 0x1B, 0xB4, 0xDA, 0xA2, + 0x5A, 0xEA, 0x04, 0x47, 0xE3, 0xCB, 0x56, 0x0E + }, + { + 0xDA, 0xB8, 0xB7, 0x3E, 0xD9, 0x6F, 0x6E, 0xB5, + 0x5F, 0xAD, 0x2B, 0x81, 0xCF, 0xD8, 0xB4, 0xBE, + 0x6F, 0xBB, 0x26, 0x1C, 0x10, 0x57, 0x1D, 0x32, + 0xEA, 0x25, 0xAC, 0x72, 0x89, 0x4E, 0x6A, 0xE7, + 0x05, 0xA0, 0x7C, 0xFD, 0x5E, 0x3F, 0xB7, 0x74, + 0x1B, 0x42, 0xAB, 0x82, 0x50, 0x03, 0x7B, 0x7E, + 0xE2, 0x68, 0x43, 0x32, 0x89, 0xDE, 0x15, 0xF6, + 0x22, 0xC1, 0x84, 0x8F, 0xC9, 0xDC, 0x47, 0x3F + }, + { + 0xE6, 0xF9, 0x8F, 0xF9, 0xA2, 0xD5, 0x80, 0x5A, + 0x0B, 0x44, 0xBC, 0x9E, 0xB8, 0x51, 0x14, 0x42, + 0x18, 0x70, 0xFA, 0x05, 0x96, 0x21, 0xF2, 0xF3, + 0xF0, 0x14, 0x04, 0x85, 0xF4, 0x46, 0xE9, 0x14, + 0x09, 0x8A, 0x46, 0x5A, 0x61, 0xDB, 0x8E, 0xC8, + 0x2C, 0x90, 0x1C, 0xFE, 0x76, 0x31, 0x4E, 0x17, + 0x14, 0xD5, 0x5D, 0x1D, 0x4B, 0xE3, 0x8E, 0x9D, + 0x52, 0x54, 0x9F, 0x81, 0x50, 0x7A, 0x52, 0x8E + }, + { + 0x3F, 0xFB, 0x5A, 0x78, 0x22, 0xE1, 0x81, 0xF0, + 0x4F, 0x87, 0x6F, 0x25, 0x3F, 0x0E, 0xC0, 0x40, + 0xBC, 0x1B, 0x49, 0x3B, 0x03, 0x33, 0xFB, 0xE2, + 0x0F, 0x0A, 0xB2, 0x3D, 0x46, 0xCF, 0xF1, 0x39, + 0x7A, 0xA7, 0xC4, 0x34, 0x23, 0x42, 0xD7, 0x9F, + 0x8A, 0xF4, 0x72, 0xC7, 0x40, 0x76, 0x82, 0xD0, + 0x8C, 0x5A, 0x95, 0x22, 0xA0, 0xB5, 0xB4, 0x7F, + 0x9C, 0x2F, 0x7C, 0xED, 0x5E, 0x90, 0x62, 0x06 + }, + { + 0xBD, 0x19, 0xDA, 0xF7, 0x5F, 0xFC, 0x5D, 0x84, + 0x77, 0xD6, 0x16, 0xCF, 0xE2, 0x0B, 0xE3, 0x60, + 0x15, 0xB7, 0x95, 0x24, 0x20, 0xB9, 0x15, 0x0F, + 0x68, 0xEE, 0x95, 0xD4, 0x22, 0xF1, 0xCC, 0xFD, + 0xA8, 0xAF, 0x0A, 0x8B, 0x28, 0x1B, 0x6E, 0x13, + 0xF3, 0xFE, 0xDE, 0x91, 0xE7, 0xB1, 0x53, 0xC0, + 0x52, 0x38, 0x7D, 0xEB, 0x44, 0x69, 0x3E, 0x16, + 0xE3, 0xA1, 0x37, 0x89, 0x88, 0xFA, 0x92, 0x16 + }, + { + 0xD5, 0x54, 0x9B, 0x07, 0x57, 0xEB, 0xE9, 0xE3, + 0x70, 0x58, 0xF0, 0xB4, 0xFB, 0x6E, 0x77, 0xFF, + 0xA5, 0x03, 0x6C, 0xD2, 0x33, 0x8D, 0xC2, 0xE7, + 0x1D, 0x30, 0x4C, 0xCA, 0x14, 0x36, 0xD7, 0xD2, + 0x7A, 0xD5, 0x2F, 0x26, 0xC1, 0xFC, 0x55, 0x16, + 0xCA, 0x73, 0x34, 0xB3, 0x6E, 0x27, 0x2F, 0xD0, + 0xC7, 0xB3, 0x1E, 0x82, 0x38, 0xBD, 0x69, 0xE8, + 0x33, 0x53, 0x35, 0xB6, 0x3A, 0x09, 0xB2, 0x65 + }, + { + 0xFE, 0x9F, 0xD8, 0xBD, 0x7A, 0x23, 0xC3, 0xB6, + 0x64, 0x55, 0xA7, 0x2F, 0x6F, 0x5E, 0x21, 0x3D, + 0x73, 0x7E, 0x4D, 0x07, 0x9A, 0x66, 0xF3, 0x88, + 0x79, 0xD4, 0x2D, 0x9F, 0x45, 0xC5, 0xC7, 0x32, + 0x6C, 0x06, 0x9B, 0x86, 0xF3, 0x1C, 0x88, 0xD3, + 0xB2, 0x1F, 0x9C, 0x75, 0x01, 0xBA, 0x9A, 0x0F, + 0x42, 0x16, 0x33, 0xAC, 0x65, 0xA3, 0xA5, 0x47, + 0x43, 0x79, 0x00, 0x33, 0xF0, 0x9E, 0x73, 0x30 + }, + { + 0x60, 0xDA, 0x31, 0xB6, 0xBF, 0x04, 0xB0, 0xE8, + 0x5C, 0xAF, 0x69, 0x8C, 0xF2, 0xD5, 0xD4, 0xA6, + 0x68, 0xC8, 0xA1, 0x59, 0x3F, 0x94, 0x18, 0x12, + 0xBF, 0xAE, 0xE3, 0xC3, 0xE4, 0x9D, 0x3F, 0x25, + 0x6A, 0x76, 0xA8, 0x7B, 0xA7, 0x96, 0x36, 0xF8, + 0xD0, 0x52, 0x9F, 0x65, 0x95, 0x40, 0xBB, 0xE0, + 0xFB, 0xF3, 0x54, 0x88, 0xC2, 0x86, 0x05, 0xF4, + 0x23, 0x8C, 0x90, 0x22, 0x16, 0x99, 0x72, 0x59 + }, + { + 0x1B, 0x72, 0x48, 0x53, 0xA8, 0x40, 0xAA, 0x7B, + 0x68, 0xE7, 0x80, 0x85, 0xB3, 0xC6, 0x02, 0x3D, + 0x6B, 0x86, 0x98, 0xD4, 0x37, 0xF1, 0x12, 0xA6, + 0x71, 0x40, 0xE7, 0xE7, 0x33, 0x38, 0xC7, 0x16, + 0xA7, 0xDC, 0x6A, 0x4A, 0x73, 0x9F, 0x97, 0xAB, + 0x8B, 0x4E, 0x16, 0x03, 0x25, 0x54, 0xD6, 0x53, + 0x18, 0x96, 0x38, 0x6B, 0x71, 0x93, 0x02, 0xDE, + 0x81, 0x21, 0x64, 0x59, 0x6B, 0xB6, 0x49, 0xF9 + }, + { + 0xA3, 0xAE, 0x0E, 0x89, 0x19, 0xDB, 0x5E, 0xDB, + 0x0C, 0xD0, 0x7A, 0xA4, 0x29, 0xD6, 0x5D, 0x7D, + 0x35, 0xBD, 0x50, 0x3A, 0x3B, 0xF7, 0xEE, 0x63, + 0x7D, 0xC3, 0x8F, 0xEE, 0xFA, 0xF6, 0x9E, 0x6F, + 0x1D, 0x64, 0xE5, 0x3E, 0x44, 0xD6, 0x2E, 0x41, + 0x37, 0x20, 0x0E, 0xEC, 0x63, 0xDE, 0xEE, 0x2D, + 0xEA, 0x45, 0x2D, 0x95, 0xED, 0x7F, 0x14, 0xE8, + 0xD0, 0x76, 0x9F, 0x80, 0x83, 0x25, 0xD6, 0x8F + }, + { + 0x75, 0x12, 0xA6, 0xC8, 0x6C, 0x7B, 0x5B, 0x78, + 0x74, 0x35, 0xD2, 0xBE, 0x05, 0x20, 0x69, 0xB1, + 0x22, 0x3E, 0x96, 0x24, 0xFF, 0x8F, 0xE1, 0x60, + 0x02, 0x41, 0xD7, 0xFE, 0x59, 0xC5, 0x95, 0x6A, + 0x9A, 0xCA, 0xCC, 0x59, 0x21, 0xF1, 0x58, 0xF6, + 0xD0, 0x1D, 0x50, 0xDF, 0x91, 0xD4, 0xA3, 0x63, + 0x6D, 0xAA, 0xF3, 0x2B, 0x7F, 0x56, 0x8B, 0xBC, + 0x37, 0x76, 0x2E, 0xBD, 0xB8, 0x31, 0x59, 0xB2 + }, + { + 0xD9, 0x54, 0x68, 0xF2, 0x4D, 0x0E, 0x41, 0x0F, + 0x32, 0xF6, 0xB5, 0x95, 0x5E, 0x4A, 0xC0, 0xCD, + 0xC1, 0xD0, 0xF5, 0x44, 0x9E, 0xCB, 0xF3, 0x5A, + 0xBE, 0xA9, 0x82, 0x1D, 0x0D, 0x0E, 0xB1, 0xA1, + 0xB6, 0x41, 0xCF, 0x90, 0x05, 0xC2, 0xD6, 0x75, + 0x8A, 0xCA, 0x81, 0x02, 0x8A, 0xD6, 0x35, 0xF1, + 0x8A, 0x81, 0xED, 0x80, 0xBC, 0xD6, 0xAB, 0xBC, + 0xFB, 0xB2, 0x57, 0x6A, 0x7C, 0x77, 0x13, 0x14 + }, + { + 0x5D, 0x05, 0x63, 0x48, 0xD8, 0xA1, 0x99, 0x48, + 0x62, 0x02, 0x61, 0x05, 0x86, 0x8C, 0xCD, 0x45, + 0x49, 0x05, 0x16, 0xAF, 0x2F, 0xF9, 0xA4, 0x0E, + 0xA5, 0xB2, 0x0C, 0x35, 0x38, 0xE9, 0xAC, 0x41, + 0x2E, 0xE6, 0x6F, 0x78, 0xCA, 0x44, 0xED, 0x54, + 0xF3, 0x00, 0xF1, 0x65, 0x55, 0xD5, 0x24, 0xD9, + 0x3A, 0xBE, 0x30, 0x93, 0x6F, 0x7B, 0x59, 0x9B, + 0xCD, 0x43, 0x4B, 0x78, 0xBA, 0x37, 0x52, 0x8A + }, + { + 0xC9, 0x33, 0x1D, 0x08, 0x15, 0x71, 0xB2, 0xA9, + 0x02, 0x97, 0x14, 0xF0, 0x7B, 0x76, 0xC8, 0x1D, + 0x58, 0xE1, 0xF6, 0x83, 0xD0, 0xF6, 0xB9, 0x24, + 0x9B, 0x2D, 0x89, 0x3D, 0x39, 0xB3, 0x8B, 0xDB, + 0x01, 0x58, 0x31, 0xB3, 0x19, 0x12, 0x19, 0x72, + 0xB4, 0x9F, 0x42, 0xC4, 0x3C, 0xFC, 0xAA, 0x25, + 0x24, 0x16, 0x79, 0xBB, 0x3D, 0xE9, 0xBE, 0xEA, + 0xC7, 0xBB, 0xE5, 0x4E, 0x10, 0xA0, 0x60, 0xFC + }, + { + 0x56, 0xA3, 0x32, 0xFB, 0xF5, 0x6B, 0xE1, 0xCD, + 0xD3, 0x5E, 0xDE, 0x87, 0x86, 0xB9, 0xD4, 0xEF, + 0xE0, 0x03, 0x4E, 0x0B, 0x70, 0x1A, 0x99, 0x18, + 0xF2, 0xC4, 0xB1, 0xA3, 0x0B, 0x61, 0x91, 0xF5, + 0xFC, 0x63, 0xB6, 0xF6, 0xAB, 0x6B, 0xB7, 0x66, + 0x41, 0x45, 0x46, 0x03, 0x21, 0x66, 0xA4, 0x61, + 0xCB, 0x2E, 0xC8, 0x63, 0x14, 0xD3, 0x45, 0xBA, + 0xB9, 0xBA, 0xD4, 0x60, 0xD4, 0x15, 0xFF, 0x30 + }, + { + 0x82, 0x34, 0xCD, 0x13, 0xDB, 0x1B, 0xF1, 0xCF, + 0xD0, 0x8B, 0xA6, 0x03, 0x67, 0xD4, 0x0A, 0x24, + 0xD7, 0x14, 0xA7, 0x13, 0xDA, 0x9D, 0x02, 0x0F, + 0xE4, 0x6E, 0x86, 0x00, 0xC4, 0x3A, 0x2A, 0x66, + 0x9C, 0x07, 0x4F, 0xFE, 0x9A, 0x3A, 0xDE, 0x6D, + 0x3C, 0xA7, 0x29, 0x4F, 0x12, 0xBD, 0x2E, 0xB6, + 0xA6, 0xFD, 0xA1, 0x06, 0xE0, 0xEF, 0x06, 0xC9, + 0xD2, 0xAB, 0x4A, 0x2B, 0x91, 0xDC, 0x39, 0x15 + }, + { + 0x8C, 0xAD, 0x74, 0x5E, 0x05, 0xBF, 0x35, 0x1B, + 0x4E, 0xB5, 0x0A, 0x50, 0x92, 0xFF, 0xE3, 0xDD, + 0x97, 0x14, 0x6B, 0xD5, 0xE9, 0x21, 0xFE, 0x98, + 0xDF, 0x80, 0xDF, 0x32, 0x19, 0xB5, 0x12, 0x3B, + 0x93, 0x57, 0xA9, 0xBA, 0x32, 0xA5, 0x4C, 0xFA, + 0xE5, 0x23, 0x33, 0xA6, 0x3A, 0xAD, 0xB0, 0x7C, + 0x77, 0x4D, 0x8D, 0x2A, 0x12, 0x6A, 0xBE, 0x66, + 0x9F, 0x70, 0xFA, 0x0C, 0x9C, 0xCE, 0x1E, 0xD7 + }, + { + 0x35, 0x2A, 0xAA, 0x6B, 0x98, 0x27, 0x70, 0x8E, + 0xED, 0x19, 0xFA, 0xA6, 0x28, 0x70, 0xFA, 0x42, + 0x2C, 0x2D, 0xAF, 0x81, 0xE1, 0x09, 0xEC, 0x97, + 0x9C, 0xDD, 0x5C, 0x2F, 0x91, 0x98, 0x3E, 0x77, + 0x1F, 0x30, 0xDE, 0xA6, 0xB9, 0xB5, 0x4F, 0x66, + 0xB6, 0xE5, 0x5F, 0x8A, 0x21, 0xD6, 0xBD, 0xD1, + 0x19, 0xF0, 0x0A, 0xD0, 0x78, 0x6C, 0x12, 0x13, + 0xFC, 0xC6, 0xA9, 0xD9, 0x6B, 0x95, 0xA9, 0xFD + }, + { + 0xC7, 0xAA, 0xBD, 0xFA, 0x38, 0x70, 0x2B, 0x36, + 0xDC, 0xEF, 0x67, 0x96, 0x95, 0x16, 0x2D, 0xD8, + 0x57, 0x9B, 0xE9, 0xA2, 0xD4, 0x09, 0xC6, 0x2E, + 0x6B, 0xEA, 0x51, 0xC5, 0x61, 0x6E, 0xB2, 0xC9, + 0x7E, 0x68, 0x24, 0x3F, 0x9E, 0x5C, 0x0D, 0x05, + 0x51, 0x6D, 0xDD, 0x5F, 0x90, 0x1C, 0xF0, 0x95, + 0x37, 0xF3, 0x19, 0xF0, 0x5B, 0x57, 0xB1, 0x81, + 0x96, 0x0D, 0x2D, 0x58, 0x83, 0x4C, 0x12, 0x60 + }, + { + 0xF0, 0x9B, 0xC6, 0x45, 0x76, 0x7D, 0x91, 0x62, + 0x90, 0x9E, 0xD6, 0xE9, 0x1B, 0xF1, 0xF3, 0xC9, + 0x00, 0x7B, 0x24, 0x18, 0x50, 0x3F, 0x36, 0xEA, + 0x96, 0x5D, 0x3D, 0x78, 0x73, 0x96, 0x87, 0x81, + 0x54, 0x31, 0xB8, 0x61, 0x8B, 0xF7, 0xFF, 0xC5, + 0xE7, 0x0D, 0x99, 0x48, 0xCF, 0x5A, 0x10, 0xC6, + 0x0F, 0x03, 0xDE, 0xC7, 0x30, 0xE1, 0x18, 0x74, + 0xFE, 0xA3, 0xB1, 0x4C, 0xFB, 0x1F, 0x7D, 0x5C + }, + { + 0x46, 0x53, 0x71, 0x81, 0xB6, 0x44, 0x8B, 0xAE, + 0xAA, 0xBA, 0x15, 0xA2, 0xE3, 0xAA, 0xFD, 0xC7, + 0x36, 0xB7, 0x60, 0xB1, 0x86, 0xCF, 0x0C, 0x97, + 0xBD, 0xE6, 0xBA, 0xAB, 0x61, 0x53, 0xD3, 0xD1, + 0xC0, 0x6C, 0x33, 0xCB, 0x69, 0x2D, 0x07, 0x37, + 0x6D, 0x6F, 0x58, 0xCF, 0x34, 0xAF, 0xD4, 0xE1, + 0x61, 0xA7, 0x08, 0x5C, 0x20, 0xA0, 0x74, 0x06, + 0xE8, 0xE4, 0x6F, 0xFA, 0x99, 0x43, 0x86, 0x65 + }, + { + 0x58, 0x67, 0x0A, 0x1B, 0x1D, 0x95, 0x0D, 0x64, + 0xD2, 0xA5, 0x96, 0x03, 0x29, 0xD1, 0x35, 0x2C, + 0xC7, 0x9A, 0x6E, 0x13, 0x59, 0xDE, 0xC1, 0x3A, + 0x19, 0x95, 0x6E, 0x79, 0x65, 0x31, 0x60, 0x54, + 0xBB, 0x32, 0x96, 0x81, 0x54, 0xCA, 0x2E, 0xA3, + 0xCD, 0x39, 0x18, 0x85, 0x96, 0xC6, 0x14, 0x8B, + 0xAC, 0x0C, 0xBD, 0x79, 0x1B, 0x77, 0xC6, 0x73, + 0x70, 0x25, 0xFC, 0xD9, 0x0F, 0x50, 0x2E, 0xBE + }, + { + 0x6C, 0x1E, 0x30, 0xB3, 0xB0, 0x5E, 0x6A, 0xB3, + 0x95, 0x52, 0x2F, 0x11, 0xA5, 0xA8, 0x86, 0x70, + 0xB4, 0xC1, 0xF0, 0x00, 0x94, 0x5B, 0x0A, 0x77, + 0xFA, 0x13, 0x37, 0xC3, 0x7A, 0x35, 0xDD, 0xCF, + 0xB4, 0xCA, 0xBF, 0x18, 0xD6, 0x0B, 0x75, 0xD1, + 0x02, 0xFE, 0xB5, 0xC3, 0x45, 0xF3, 0x88, 0x54, + 0x66, 0xDF, 0xBE, 0x65, 0xF1, 0x30, 0x75, 0xB9, + 0x1E, 0x56, 0x2D, 0x27, 0xE4, 0x12, 0x9B, 0xA2 + }, + { + 0x16, 0xD9, 0xFB, 0x3B, 0xBB, 0xB3, 0x52, 0x7F, + 0x9C, 0x23, 0x7E, 0xD5, 0x06, 0x9E, 0xBD, 0x6D, + 0x37, 0x5F, 0x25, 0xB3, 0xC0, 0x43, 0x1B, 0x72, + 0xB6, 0x39, 0xEC, 0xDD, 0xE4, 0x4D, 0x16, 0xE0, + 0xB1, 0xE7, 0x9E, 0x5B, 0xB1, 0x8F, 0x8B, 0x68, + 0x49, 0xC7, 0x8D, 0x0E, 0xF5, 0x46, 0x3D, 0xD3, + 0xA3, 0xB4, 0x30, 0xA2, 0x17, 0x83, 0x57, 0xB6, + 0x86, 0x31, 0xDD, 0xED, 0x3F, 0x1D, 0x1B, 0xEF + }, + { + 0x12, 0xEA, 0xB9, 0x43, 0x7E, 0x58, 0xE2, 0x2B, + 0x3E, 0x33, 0x08, 0x77, 0xE3, 0xC9, 0x08, 0xC9, + 0xA2, 0xC1, 0x43, 0x28, 0x26, 0xD9, 0x16, 0x13, + 0xDF, 0x82, 0xB9, 0xEA, 0x2B, 0xA9, 0x72, 0xCE, + 0x35, 0xAF, 0x5A, 0xA8, 0xCB, 0xB0, 0x24, 0x15, + 0x10, 0xA4, 0x2D, 0x22, 0x4B, 0xD8, 0xA4, 0xCF, + 0x8D, 0x47, 0xEF, 0x8A, 0x11, 0x43, 0xAF, 0x8C, + 0xC0, 0x4F, 0x36, 0x4A, 0x0C, 0xE3, 0x63, 0x13 + }, + { + 0xD3, 0x5D, 0x61, 0xBA, 0xAB, 0x94, 0x1C, 0xBC, + 0x20, 0x75, 0x3C, 0x1F, 0xEA, 0x93, 0xB3, 0x30, + 0x92, 0xDF, 0x69, 0xF2, 0xDE, 0x02, 0xB4, 0xE9, + 0xAF, 0xEF, 0x42, 0xF5, 0x2C, 0xF3, 0x79, 0xA6, + 0xA6, 0xBF, 0x07, 0x86, 0x5D, 0x9B, 0xBA, 0x7B, + 0x84, 0x4D, 0x6A, 0x5D, 0xC2, 0xB8, 0xE7, 0x1A, + 0x50, 0xC3, 0xF5, 0xCF, 0xE6, 0xDC, 0x70, 0x3F, + 0x41, 0xEA, 0x2F, 0xEF, 0x75, 0x41, 0x46, 0x64 + }, + { + 0x20, 0xE1, 0x3B, 0xC5, 0xED, 0x17, 0xA8, 0x9F, + 0x2D, 0x11, 0x08, 0x6E, 0x23, 0x41, 0xDD, 0x8A, + 0x4B, 0xAA, 0x76, 0x21, 0xE1, 0x56, 0x59, 0x90, + 0x7C, 0x60, 0x08, 0x54, 0x6E, 0x0B, 0x9B, 0x05, + 0x71, 0x63, 0x99, 0xEA, 0x97, 0x25, 0x10, 0x77, + 0x07, 0x6C, 0xDA, 0x2D, 0x53, 0xE6, 0xF3, 0x88, + 0x62, 0x9B, 0x7F, 0x2F, 0x68, 0xF0, 0xC6, 0x19, + 0x5A, 0x1E, 0xE2, 0x0C, 0xBF, 0x0C, 0x12, 0xE9 + }, + { + 0x0A, 0xFB, 0xD4, 0x67, 0x85, 0x0F, 0x23, 0x1A, + 0x60, 0xAE, 0xC3, 0x81, 0x04, 0xA8, 0x42, 0x3F, + 0x2E, 0x44, 0xEC, 0x34, 0x36, 0xC5, 0x4E, 0xC8, + 0x18, 0x32, 0x26, 0xA0, 0x86, 0x24, 0x77, 0xF6, + 0xDA, 0x40, 0x64, 0xC1, 0xAF, 0x94, 0xF1, 0xB3, + 0xEC, 0xB5, 0xF1, 0xEA, 0xFA, 0x0B, 0xF2, 0x6C, + 0x3E, 0x6D, 0x0F, 0x4D, 0x96, 0xBE, 0xE9, 0x25, + 0x1C, 0x6E, 0xD8, 0x64, 0x59, 0x89, 0x39, 0x86 + }, + { + 0xDA, 0x94, 0x29, 0xF4, 0xFB, 0x5C, 0xC3, 0xAF, + 0xBB, 0x3D, 0x21, 0xBE, 0x44, 0xBA, 0x43, 0xF8, + 0xBA, 0x66, 0x19, 0x20, 0x0E, 0x85, 0x9B, 0x24, + 0xD9, 0xB5, 0xD3, 0x5D, 0xF5, 0x46, 0xC0, 0x00, + 0x7C, 0xB0, 0x15, 0x62, 0x0B, 0xA2, 0xA9, 0xB0, + 0xAA, 0xD7, 0x14, 0x94, 0xC7, 0x52, 0x85, 0x73, + 0x1E, 0x2E, 0x3C, 0x65, 0xD8, 0x1D, 0xE7, 0xA7, + 0xD2, 0x4D, 0xD7, 0x78, 0x9E, 0xD2, 0x61, 0x2F + }, + { + 0xEE, 0x1B, 0x3C, 0x15, 0x3E, 0xDD, 0xA8, 0xC8, + 0x5B, 0x40, 0x58, 0x8C, 0xDD, 0x18, 0x4A, 0x88, + 0xB4, 0xFB, 0xC1, 0xC5, 0x4C, 0x20, 0xB3, 0xD3, + 0x80, 0x55, 0x99, 0x94, 0x8D, 0xBB, 0x23, 0x33, + 0xCF, 0x5B, 0x95, 0xA6, 0x17, 0x90, 0x7F, 0x8C, + 0xF0, 0xAA, 0x62, 0x1B, 0x5E, 0x98, 0xC8, 0x55, + 0x98, 0x39, 0x04, 0x54, 0x17, 0xFF, 0xA5, 0x09, + 0x91, 0xC8, 0xFA, 0x18, 0x3E, 0xB1, 0x43, 0xCC + }, + { + 0xD2, 0xB2, 0xB7, 0xB5, 0x43, 0x6D, 0x00, 0xEA, + 0x60, 0xE6, 0x39, 0xB1, 0xD2, 0xE2, 0x23, 0x35, + 0xC6, 0x20, 0x26, 0xDE, 0x6B, 0x84, 0xAE, 0x10, + 0x5B, 0x78, 0x6C, 0xF3, 0x08, 0x2A, 0x98, 0x4D, + 0xEE, 0x5A, 0xE3, 0x16, 0xB4, 0xFD, 0x57, 0x2B, + 0xAD, 0xF5, 0x20, 0x10, 0xE9, 0x5E, 0x7B, 0x67, + 0x67, 0xAA, 0xDB, 0xEE, 0x75, 0x82, 0xD7, 0x0B, + 0xAD, 0xC9, 0xFB, 0xFB, 0x7E, 0xC9, 0x31, 0x19 + }, + { + 0x75, 0xE9, 0x76, 0xC5, 0xF8, 0xDB, 0x31, 0x79, + 0x86, 0xC6, 0x89, 0x4E, 0xC7, 0xCE, 0x96, 0xC2, + 0x7B, 0x29, 0x84, 0x59, 0x0B, 0xFF, 0x20, 0x5C, + 0xAF, 0xBB, 0x35, 0xDD, 0x33, 0xAB, 0x70, 0xA9, + 0xCE, 0x46, 0x69, 0x6E, 0xD4, 0x57, 0x8A, 0x85, + 0x41, 0x21, 0x70, 0xFD, 0x63, 0x77, 0xFF, 0x5D, + 0x0E, 0x43, 0xB4, 0x3C, 0xC1, 0x3E, 0xA9, 0xDB, + 0xA7, 0x7D, 0x79, 0x94, 0xBC, 0x3B, 0x1F, 0xF3 + }, + { + 0xB2, 0xD9, 0xD3, 0x77, 0xE4, 0x59, 0x5C, 0x94, + 0x85, 0xC5, 0x89, 0x97, 0x3F, 0x4E, 0x93, 0xEA, + 0xA1, 0x1A, 0x3D, 0x0A, 0x58, 0x35, 0x24, 0x4C, + 0x26, 0xDA, 0xE4, 0x4E, 0xBA, 0x2D, 0x7C, 0xBF, + 0xA1, 0xDF, 0x85, 0xF2, 0x1E, 0x11, 0x2A, 0xEE, + 0x85, 0xD6, 0x51, 0xFF, 0x4C, 0xA0, 0x6B, 0x93, + 0xDC, 0x7F, 0xF6, 0x3E, 0xE7, 0x35, 0xB4, 0x46, + 0x2E, 0xB4, 0x6A, 0x07, 0xCE, 0x5A, 0x14, 0x3A + }, + { + 0x31, 0xCF, 0xBF, 0x23, 0x6E, 0x83, 0x48, 0xD3, + 0x22, 0x04, 0x3A, 0x8C, 0x7B, 0x92, 0xA6, 0x84, + 0x27, 0x9F, 0x00, 0xD3, 0xB5, 0x1F, 0xA7, 0xAE, + 0xEA, 0x8B, 0x36, 0x7B, 0xD1, 0x12, 0x03, 0x2B, + 0xED, 0xDE, 0xE5, 0x51, 0x29, 0x30, 0xC6, 0x17, + 0x4B, 0xCD, 0xCF, 0x17, 0x99, 0x63, 0xDD, 0x7F, + 0xFC, 0x80, 0x38, 0x16, 0x52, 0x24, 0x87, 0xFD, + 0xC7, 0xB3, 0xF2, 0xD8, 0x53, 0xD2, 0x6D, 0xD6 + }, + { + 0xC6, 0xFF, 0xB1, 0x65, 0x1A, 0xFF, 0xDC, 0xDD, + 0x6D, 0x88, 0x35, 0x00, 0xED, 0x9F, 0xC5, 0xAB, + 0xEF, 0xAB, 0x8B, 0xBA, 0x07, 0x39, 0x5F, 0x21, + 0xDF, 0x4F, 0x82, 0xEE, 0xCB, 0x3F, 0x83, 0xF9, + 0xB7, 0x05, 0x2C, 0x70, 0x0C, 0xE6, 0xF3, 0xDF, + 0x84, 0xA5, 0x53, 0x65, 0xBE, 0x9A, 0x59, 0x23, + 0xB1, 0xCF, 0x3F, 0x22, 0x0A, 0x5A, 0x11, 0x51, + 0xCC, 0xFA, 0x98, 0xBD, 0xFA, 0x91, 0x83, 0x12 + }, + { + 0xF8, 0xA5, 0xAF, 0x2F, 0xD6, 0x70, 0x0F, 0xB7, + 0x15, 0x8E, 0x26, 0x87, 0x50, 0x23, 0xA4, 0x2A, + 0xD1, 0x8A, 0x56, 0x54, 0xD3, 0x89, 0xC7, 0x39, + 0xE5, 0x35, 0x20, 0xC3, 0x68, 0xEF, 0xD0, 0xC4, + 0x8D, 0xC9, 0xEE, 0x0C, 0x9D, 0xF2, 0x2A, 0x27, + 0x42, 0x1B, 0xB5, 0xB6, 0xE3, 0x8F, 0x00, 0x29, + 0xA8, 0x71, 0x38, 0xFC, 0x68, 0xC6, 0x62, 0x96, + 0xE7, 0x39, 0x05, 0xB8, 0xC7, 0x93, 0x2E, 0x7B + }, + { + 0xF8, 0xD3, 0xA5, 0x3B, 0x8D, 0x77, 0x2F, 0x54, + 0x97, 0x01, 0xD1, 0xE9, 0x53, 0x79, 0xA7, 0xF0, + 0xE4, 0x5D, 0x1D, 0x9E, 0x9C, 0x1C, 0x24, 0xBE, + 0xFE, 0x19, 0xCA, 0x8B, 0xB3, 0xAB, 0x54, 0xD5, + 0xA6, 0xB4, 0xB5, 0xB6, 0x47, 0x59, 0x1B, 0x9B, + 0x8B, 0xAC, 0xC2, 0x16, 0x5E, 0xF9, 0xC9, 0xB5, + 0x3D, 0x43, 0x2C, 0xD5, 0x6B, 0x30, 0x9E, 0x3D, + 0x2F, 0x0E, 0x09, 0x37, 0x25, 0x51, 0x73, 0x59 + }, + { + 0x20, 0xE9, 0x55, 0xA5, 0x04, 0x62, 0x07, 0xAF, + 0x68, 0x81, 0x4A, 0xE6, 0xD3, 0xAB, 0x94, 0x97, + 0x6D, 0x10, 0xB8, 0xE1, 0xED, 0x28, 0x64, 0x9D, + 0xB0, 0x47, 0xED, 0x71, 0xC6, 0xD4, 0x32, 0x92, + 0xC5, 0xE0, 0xC3, 0x2E, 0xC5, 0xC9, 0x7D, 0xD6, + 0x1C, 0xD2, 0x16, 0x05, 0xFD, 0x49, 0x9D, 0x60, + 0x85, 0x4F, 0xCA, 0x6C, 0x4D, 0x27, 0x85, 0xC3, + 0x55, 0xDC, 0xF3, 0xF8, 0xEB, 0x65, 0xB0, 0xD8 + }, + { + 0xA8, 0x17, 0x58, 0xFC, 0xFF, 0x6F, 0xC0, 0xB8, + 0x0D, 0x8E, 0x1D, 0x7A, 0xC9, 0x23, 0xD3, 0xCF, + 0x96, 0x88, 0xDF, 0x98, 0x33, 0xD7, 0x32, 0x51, + 0xB5, 0x45, 0x49, 0x34, 0x91, 0x5C, 0x72, 0x24, + 0x77, 0x3C, 0x07, 0xBA, 0x87, 0x2E, 0x8D, 0x0F, + 0x9E, 0x60, 0x20, 0x1C, 0x8C, 0xDC, 0x69, 0xD9, + 0xD7, 0x79, 0xA0, 0x25, 0xB9, 0x5B, 0x0C, 0x34, + 0xFB, 0x84, 0xBC, 0x1D, 0x90, 0x10, 0xF7, 0x95 + }, + { + 0xDA, 0x27, 0x27, 0xE3, 0xE5, 0x79, 0xCE, 0xEB, + 0x51, 0x92, 0x88, 0x94, 0x57, 0xCD, 0x17, 0xC5, + 0xC4, 0x9B, 0xE3, 0x7D, 0xF9, 0x2B, 0xD8, 0xF0, + 0x9E, 0xCD, 0x98, 0x11, 0x33, 0xF2, 0x8C, 0x7B, + 0x7B, 0x45, 0x14, 0x64, 0x0B, 0x68, 0x44, 0x21, + 0x5C, 0x52, 0x20, 0x39, 0xF9, 0x6A, 0x29, 0x7A, + 0x6E, 0xEE, 0x84, 0x33, 0xB5, 0x33, 0xF9, 0x4C, + 0x0A, 0x60, 0x05, 0x53, 0x61, 0xAD, 0xA0, 0xB0 + }, + { + 0xC6, 0x27, 0x78, 0xAC, 0x0F, 0x72, 0x27, 0x2E, + 0x8A, 0x86, 0xF0, 0x32, 0xEF, 0x83, 0xB1, 0xE0, + 0x15, 0x5A, 0x4D, 0xA6, 0x02, 0xA5, 0xC8, 0x44, + 0xDE, 0x6D, 0x57, 0x97, 0xC8, 0x7B, 0x5B, 0xAE, + 0x90, 0x18, 0x2B, 0x7F, 0xDD, 0x28, 0xFC, 0xFD, + 0x29, 0x4C, 0xA6, 0xE1, 0x8B, 0x6C, 0x12, 0xDF, + 0xEF, 0x12, 0x0D, 0x40, 0xBA, 0x5A, 0xB7, 0xA9, + 0x06, 0xD0, 0x8E, 0x37, 0xB1, 0xE2, 0xB7, 0xDA + }, + { + 0xD6, 0xF1, 0x4F, 0x60, 0x23, 0x1B, 0xCE, 0xDF, + 0x28, 0xDB, 0x30, 0x68, 0x50, 0x97, 0x7A, 0xA5, + 0x52, 0x8D, 0xC3, 0xBF, 0x4A, 0xA0, 0x9A, 0x6E, + 0xBA, 0x36, 0x35, 0x9A, 0x82, 0xF0, 0x8D, 0xA1, + 0xBE, 0xBC, 0xD8, 0x9A, 0x75, 0x13, 0x4D, 0xAB, + 0x38, 0xF7, 0x46, 0xEE, 0x05, 0xAD, 0x5E, 0x3A, + 0xD1, 0xAC, 0x97, 0xF6, 0x5A, 0x08, 0x3D, 0xE8, + 0x55, 0x23, 0x10, 0xE7, 0xE8, 0x1E, 0x36, 0x88 + }, + { + 0xAA, 0x67, 0x9E, 0xE4, 0x76, 0x98, 0x1E, 0x78, + 0xE9, 0x2C, 0xAD, 0x88, 0x84, 0xD0, 0x40, 0x0E, + 0x58, 0x84, 0x08, 0x6D, 0x76, 0xB3, 0xD7, 0x18, + 0x90, 0x7C, 0x27, 0x61, 0x19, 0xB0, 0x9F, 0x5C, + 0x59, 0xD7, 0xB1, 0x58, 0x40, 0x19, 0x65, 0x09, + 0xCC, 0x52, 0x37, 0x0A, 0x47, 0xBF, 0x36, 0x40, + 0xBA, 0x94, 0x32, 0x2C, 0x17, 0x27, 0x4C, 0x3B, + 0xA1, 0x6F, 0x85, 0x04, 0xEE, 0xC2, 0x3C, 0xC1 + }, + { + 0xF0, 0x97, 0x41, 0xA8, 0x6E, 0x51, 0x2E, 0xA4, + 0xD9, 0x77, 0x81, 0x04, 0xEF, 0x39, 0x5E, 0xA9, + 0x21, 0xCA, 0xB8, 0x6B, 0x8A, 0x9D, 0xE2, 0x70, + 0x08, 0x3C, 0xB0, 0xE5, 0x63, 0x11, 0x88, 0x2B, + 0x06, 0x76, 0x3B, 0x29, 0x9D, 0x23, 0x51, 0x02, + 0x0F, 0x37, 0x9C, 0x56, 0xBD, 0x99, 0xE0, 0xC8, + 0xF2, 0x23, 0x2B, 0xF2, 0x2D, 0xC7, 0xB2, 0x63, + 0xE5, 0x44, 0xC2, 0xDC, 0x3D, 0x5F, 0x68, 0x4C + }, + { + 0x60, 0xE8, 0xF3, 0x59, 0x20, 0xF2, 0x79, 0xAC, + 0x22, 0x4A, 0x3F, 0x6C, 0x72, 0x42, 0x6C, 0x42, + 0x16, 0x21, 0x6D, 0xF7, 0xBD, 0xB3, 0x46, 0xD8, + 0xF4, 0xFE, 0xF7, 0x44, 0xAA, 0xE9, 0xC7, 0xFD, + 0x0E, 0x5D, 0x01, 0xF2, 0xA5, 0xCF, 0xCB, 0xBF, + 0xD7, 0xBD, 0xB4, 0xE8, 0x6A, 0xCD, 0x8E, 0x10, + 0xD5, 0xAA, 0x0A, 0x67, 0x65, 0xB3, 0x21, 0x1C, + 0x4C, 0x6F, 0xC5, 0x5C, 0x1E, 0xF3, 0xDD, 0x1D + }, + { + 0xAE, 0x85, 0x2E, 0xC3, 0x7D, 0xBD, 0x8A, 0xD2, + 0xFA, 0x3E, 0x24, 0xFA, 0x33, 0xCD, 0xDB, 0x5A, + 0xEB, 0xC6, 0x9E, 0x3A, 0xDE, 0xD8, 0xAE, 0x93, + 0x8F, 0xAE, 0x03, 0xBB, 0x52, 0xA4, 0xA9, 0xCE, + 0x40, 0xDC, 0xB8, 0x8D, 0x0E, 0x3F, 0x08, 0x79, + 0x43, 0xFC, 0x96, 0x1D, 0xEA, 0xCA, 0x2E, 0x2C, + 0xCF, 0x83, 0xAC, 0xCA, 0xE7, 0xC2, 0x37, 0x87, + 0xFB, 0x71, 0x7B, 0x62, 0xAF, 0xA6, 0xA4, 0x55 + }, + { + 0x10, 0xF4, 0x69, 0x86, 0x67, 0x09, 0xFF, 0x2A, + 0x25, 0xF2, 0x41, 0x66, 0x35, 0x15, 0xF8, 0x42, + 0x5E, 0x19, 0x2E, 0x36, 0x37, 0x5C, 0xF0, 0x14, + 0xA9, 0xAC, 0x29, 0x0C, 0x72, 0x2F, 0x23, 0x57, + 0xA3, 0x5F, 0x65, 0xF0, 0x24, 0xBC, 0x97, 0xB9, + 0x2C, 0xC4, 0xE8, 0x5C, 0xAA, 0x2E, 0xE4, 0x61, + 0x73, 0xFE, 0xFC, 0x37, 0xF0, 0x93, 0xDF, 0xEE, + 0x16, 0xD7, 0xC7, 0x3A, 0xB9, 0x52, 0x4B, 0x94 + }, + { + 0xEE, 0xE0, 0x39, 0xDB, 0x0F, 0x28, 0x1A, 0x8F, + 0x89, 0x93, 0xD1, 0x05, 0xE6, 0xAE, 0x1D, 0xEC, + 0x06, 0x62, 0x70, 0xFE, 0x8A, 0x2A, 0xC7, 0x66, + 0xB8, 0xFE, 0xCB, 0x1C, 0xAB, 0x8B, 0xA4, 0xFD, + 0x04, 0xB0, 0x0E, 0xDB, 0x82, 0x61, 0x6D, 0x32, + 0x40, 0x52, 0x0F, 0xD7, 0xE8, 0xAA, 0xFE, 0x5F, + 0xE9, 0x63, 0xD0, 0xCF, 0xE9, 0xDB, 0xA8, 0xB7, + 0xB9, 0xCB, 0x7E, 0x7B, 0x31, 0x6A, 0x7C, 0xFF + }, + { + 0x03, 0xDF, 0x5F, 0x75, 0x9F, 0xF2, 0x45, 0x05, + 0xC6, 0xAE, 0xD3, 0xE6, 0x1E, 0xEA, 0xF6, 0xDE, + 0xBF, 0xB3, 0x1D, 0xB8, 0x48, 0x01, 0xAE, 0x95, + 0x5B, 0xAF, 0x6D, 0xA7, 0x3D, 0x41, 0xDD, 0xD4, + 0x11, 0xE9, 0x33, 0x1C, 0x34, 0x7A, 0x52, 0xE6, + 0x1E, 0x7E, 0x6A, 0x24, 0x85, 0xE2, 0xC3, 0xE5, + 0x1A, 0xBB, 0xFA, 0x52, 0x9E, 0x49, 0xC7, 0x50, + 0xB4, 0xA5, 0xE5, 0x59, 0x6A, 0x46, 0x00, 0x2D + }, + { + 0x18, 0xE8, 0x6F, 0xCB, 0xD0, 0xA5, 0x8F, 0xBA, + 0x21, 0x6E, 0x4E, 0x23, 0xD5, 0x39, 0x9A, 0x68, + 0x6D, 0x56, 0x8D, 0xEE, 0x3A, 0x50, 0xE9, 0x43, + 0xB1, 0xAC, 0x51, 0xF6, 0xCE, 0xC5, 0xD6, 0x29, + 0x8D, 0x17, 0xDC, 0x64, 0xC0, 0x89, 0x45, 0xDE, + 0xEC, 0x2E, 0x25, 0xAB, 0x96, 0x67, 0x3F, 0xB9, + 0xCD, 0x0D, 0x2C, 0x89, 0x99, 0xF1, 0x02, 0x55, + 0xFC, 0x54, 0x43, 0x07, 0x80, 0x4B, 0x38, 0xAB + }, + { + 0x61, 0xB0, 0x28, 0xBD, 0xFF, 0x2B, 0x77, 0x99, + 0x83, 0x8B, 0x1C, 0x9C, 0x0E, 0x32, 0xAC, 0xD2, + 0x3C, 0xF3, 0x13, 0x48, 0x7D, 0xC9, 0x8D, 0x99, + 0xDC, 0xE5, 0x13, 0xF9, 0xC1, 0x63, 0x2B, 0xFC, + 0x1F, 0x38, 0x18, 0x30, 0x4E, 0xD2, 0x70, 0x7B, + 0xA8, 0x13, 0x5D, 0xDF, 0xF9, 0x6A, 0xE5, 0x7D, + 0x84, 0x54, 0x19, 0xAA, 0x0F, 0x05, 0x5A, 0x40, + 0x2C, 0xA4, 0x1C, 0x05, 0x2D, 0x31, 0x34, 0xC4 + }, + { + 0xB3, 0x22, 0x1F, 0x35, 0x54, 0x20, 0xF0, 0x56, + 0x58, 0x14, 0x9C, 0x3F, 0xBC, 0x58, 0xD4, 0x66, + 0x6B, 0x1E, 0x2D, 0x58, 0xAF, 0xE6, 0x6B, 0x48, + 0x52, 0xBB, 0x03, 0x04, 0xD3, 0xED, 0x07, 0xB6, + 0x9D, 0xCC, 0x7C, 0xBB, 0xDD, 0x9B, 0x9A, 0xBB, + 0x85, 0x0F, 0xE4, 0x35, 0x19, 0x4D, 0xDB, 0x21, + 0xC9, 0x2A, 0xBD, 0x2D, 0x66, 0x75, 0xF0, 0xC8, + 0xD3, 0xB3, 0xA5, 0x64, 0xD7, 0xFD, 0xE8, 0xB4 + }, + { + 0xBD, 0xB6, 0x69, 0x4D, 0x9F, 0x55, 0xBB, 0xF1, + 0x23, 0xA3, 0xE8, 0x03, 0xB4, 0xEF, 0x4F, 0xC9, + 0x36, 0xED, 0xD0, 0xEF, 0x0D, 0x1C, 0x3B, 0xF0, + 0x89, 0xFB, 0x32, 0xAA, 0x22, 0xA3, 0xE7, 0xE3, + 0x92, 0x9F, 0xEE, 0x1F, 0xC9, 0x8B, 0x22, 0xE8, + 0x6B, 0xE9, 0x07, 0x10, 0x1A, 0x94, 0x69, 0xC5, + 0xD2, 0xF6, 0xCC, 0xD6, 0x32, 0xB2, 0x3C, 0x1C, + 0xA8, 0xF0, 0x57, 0x77, 0x6B, 0x28, 0x21, 0x76 + }, + { + 0xC1, 0x0F, 0x96, 0xC6, 0x9E, 0x8B, 0x53, 0x6E, + 0x9A, 0x26, 0x42, 0x56, 0x5F, 0x41, 0xBB, 0x5A, + 0x47, 0xF2, 0xB8, 0xF4, 0x76, 0x5C, 0x7D, 0x7D, + 0x02, 0xC1, 0x61, 0x19, 0xE8, 0xD5, 0x5F, 0xA6, + 0xB0, 0x3C, 0xB8, 0xA8, 0x1D, 0xFA, 0x77, 0xF2, + 0x13, 0xA5, 0x15, 0x6C, 0x64, 0x09, 0x96, 0x02, + 0xAF, 0x66, 0x0F, 0x54, 0x05, 0x5C, 0x20, 0x07, + 0x98, 0x1B, 0xC3, 0x77, 0x78, 0x83, 0xB7, 0xD8 + }, + { + 0x5B, 0xD5, 0xF0, 0x15, 0xB0, 0xBC, 0x8D, 0xF9, + 0xF6, 0xA6, 0x95, 0x08, 0x8B, 0xD9, 0x27, 0xF8, + 0xE6, 0xC6, 0x0E, 0xA5, 0x2C, 0x8A, 0x4D, 0x4A, + 0xD5, 0x4C, 0xAA, 0x9D, 0x4F, 0x33, 0x94, 0x38, + 0xF3, 0x8F, 0xF8, 0xA5, 0xC7, 0xD4, 0x98, 0x08, + 0xD8, 0xAF, 0xA4, 0x3D, 0x1D, 0xC7, 0xC0, 0x07, + 0x7A, 0x19, 0x48, 0x11, 0xA7, 0x7A, 0x74, 0x25, + 0x6B, 0xF9, 0x36, 0xAE, 0x63, 0x49, 0x68, 0xDA + }, + { + 0x95, 0x50, 0x42, 0x78, 0x2A, 0x31, 0x29, 0x8D, + 0x18, 0x34, 0xC2, 0x69, 0xDD, 0x40, 0xC6, 0x0C, + 0x69, 0xCE, 0x8F, 0xB6, 0xDF, 0x14, 0x20, 0x91, + 0xF1, 0x78, 0x74, 0x44, 0xE1, 0x5B, 0x65, 0x98, + 0xD9, 0x33, 0x96, 0xE6, 0xAC, 0x51, 0x14, 0x2A, + 0xB4, 0xC9, 0xAE, 0x9B, 0x43, 0x3E, 0xA6, 0xD1, + 0xDA, 0x65, 0x1C, 0xD5, 0x8C, 0x82, 0xE3, 0xBA, + 0x2D, 0x75, 0xD9, 0x1F, 0xDB, 0xF2, 0x3C, 0x33 + }, + { + 0x4D, 0x2C, 0x15, 0x2B, 0x6E, 0x13, 0xB1, 0xE4, + 0xE4, 0x1C, 0xD2, 0x6E, 0x1A, 0x4D, 0xF9, 0xBB, + 0xDE, 0x3E, 0x6A, 0x0B, 0x78, 0xDB, 0xAB, 0x29, + 0x26, 0x38, 0x6D, 0x2B, 0xF3, 0x00, 0x47, 0x1F, + 0x1E, 0x28, 0x1B, 0x71, 0xD3, 0x23, 0xB5, 0xF5, + 0x7B, 0x4D, 0x5A, 0x87, 0xC6, 0x36, 0xD9, 0x37, + 0x63, 0xF1, 0x96, 0x02, 0xCB, 0x19, 0x41, 0xD4, + 0x8C, 0xD1, 0x8F, 0xB7, 0xCA, 0x7E, 0x4D, 0x29 + }, + { + 0x1F, 0x21, 0x31, 0x29, 0xA9, 0xFC, 0xDB, 0x25, + 0x9C, 0xD1, 0x72, 0x28, 0x4F, 0x51, 0x89, 0xF1, + 0xE6, 0xD5, 0x0D, 0x7E, 0x01, 0x8E, 0xE5, 0x20, + 0x3F, 0xBD, 0xF0, 0x68, 0x8F, 0xC4, 0x40, 0xB8, + 0xF4, 0x35, 0x53, 0x4A, 0x9F, 0xAC, 0xB9, 0x37, + 0x5C, 0x17, 0x11, 0x3E, 0xC4, 0x3C, 0x6A, 0x29, + 0x21, 0x21, 0x35, 0x7C, 0x92, 0x69, 0xE9, 0xEA, + 0x53, 0x94, 0xC4, 0x6F, 0xAE, 0xE8, 0xD8, 0x5F + }, + { + 0x32, 0x8C, 0xDA, 0x0B, 0x3D, 0x9D, 0xF6, 0xDE, + 0xFC, 0xB2, 0xC5, 0x84, 0x80, 0x3E, 0x15, 0xA1, + 0x81, 0x7E, 0x5F, 0xEE, 0x41, 0x80, 0x63, 0xA3, + 0x41, 0x98, 0x6D, 0x5C, 0xBE, 0x97, 0xAB, 0x58, + 0x39, 0xE5, 0x95, 0xAB, 0xB0, 0xE5, 0xAB, 0xFF, + 0x3E, 0x8A, 0x28, 0x01, 0x6B, 0xA7, 0x7F, 0x84, + 0x35, 0xD0, 0x0F, 0xB8, 0x74, 0x31, 0xC9, 0x46, + 0xB9, 0x66, 0xEB, 0x2B, 0xB9, 0x3A, 0x7E, 0x3D + }, + { + 0x4B, 0xD7, 0x13, 0xAF, 0x9A, 0x55, 0xA7, 0x49, + 0xBE, 0xF7, 0x36, 0xA1, 0xED, 0xC1, 0x54, 0x7D, + 0xB2, 0xA7, 0x1F, 0x83, 0xFA, 0xC7, 0x7D, 0x30, + 0x1C, 0xC9, 0x9F, 0xD2, 0xCF, 0xA9, 0xAC, 0x56, + 0x4B, 0xB6, 0x28, 0xCD, 0xCC, 0x87, 0xF3, 0x71, + 0x13, 0x05, 0xC6, 0x5C, 0xBE, 0xB8, 0x05, 0xB3, + 0xBF, 0xD8, 0x10, 0xD7, 0xFA, 0xAD, 0x36, 0x47, + 0xE1, 0x37, 0xCC, 0x49, 0xF4, 0xC8, 0xD7, 0xFD + }, + { + 0xAB, 0xFA, 0x78, 0x3B, 0x83, 0x2F, 0xA8, 0xE6, + 0x14, 0x75, 0xA4, 0x30, 0xD5, 0x9B, 0x7E, 0xAD, + 0xA2, 0x38, 0xB0, 0x19, 0x63, 0x12, 0x77, 0xD8, + 0x7A, 0x8D, 0x8F, 0x2D, 0x49, 0xC9, 0xC6, 0xC1, + 0xE9, 0x0F, 0x44, 0x6B, 0xF0, 0xBF, 0x1A, 0x6E, + 0x94, 0x8F, 0x04, 0x80, 0x56, 0x15, 0xE2, 0xAB, + 0x94, 0x4A, 0xE5, 0x39, 0x17, 0xFE, 0x0D, 0x50, + 0xAC, 0xA0, 0xAC, 0x26, 0x27, 0x66, 0xEC, 0xA7 + }, + { + 0x93, 0x2A, 0x40, 0x5F, 0x02, 0x27, 0x40, 0xFC, + 0x59, 0x58, 0x8B, 0x45, 0x24, 0x3B, 0xB4, 0x49, + 0xF8, 0xB5, 0xE8, 0x4C, 0xE8, 0x34, 0x4F, 0x52, + 0xB6, 0x56, 0x46, 0xC3, 0xB6, 0x6B, 0x37, 0xB0, + 0xAA, 0x45, 0x70, 0x63, 0x5F, 0xB3, 0xBA, 0xE4, + 0x1E, 0x9F, 0x6F, 0x22, 0xF0, 0xEC, 0x3F, 0x8D, + 0xB9, 0x05, 0xD0, 0xAB, 0xDF, 0x1B, 0xCA, 0x3F, + 0x6B, 0xF3, 0xEB, 0x60, 0x23, 0x9C, 0x27, 0x9F + }, + { + 0x51, 0x02, 0xEE, 0xC1, 0x3A, 0x5E, 0x66, 0x1C, + 0x89, 0x63, 0xB0, 0xC0, 0x8D, 0xAC, 0xB1, 0xD7, + 0xB2, 0x55, 0x09, 0x5B, 0x7A, 0xBE, 0xE6, 0x82, + 0x65, 0x32, 0xDD, 0x44, 0x6C, 0x4D, 0xD5, 0xE1, + 0xB9, 0xFD, 0x25, 0x49, 0xC8, 0xFB, 0xBC, 0xAD, + 0xB6, 0x81, 0x43, 0x9F, 0xA8, 0x30, 0x67, 0x40, + 0xF6, 0xF7, 0x1F, 0x06, 0x33, 0xE2, 0x4C, 0x4E, + 0x0C, 0xE6, 0xA9, 0x2C, 0x45, 0x53, 0xC6, 0xEF + }, + { + 0x2E, 0xEE, 0xD3, 0x30, 0x01, 0xBF, 0x10, 0xA0, + 0x0C, 0x6F, 0x6D, 0x33, 0xBD, 0x05, 0xA8, 0x83, + 0xC0, 0x9A, 0xEE, 0x10, 0xCB, 0xAF, 0x22, 0x56, + 0xB2, 0x4A, 0x79, 0x7B, 0x07, 0xFB, 0x9D, 0xA5, + 0xCD, 0x70, 0xB6, 0x8E, 0x96, 0x17, 0xB8, 0x3E, + 0xB6, 0x41, 0xD7, 0xC9, 0x26, 0xCA, 0x93, 0x9E, + 0x13, 0x88, 0x7C, 0x2E, 0xEE, 0x9F, 0xCE, 0x7D, + 0x13, 0xAE, 0xFB, 0x57, 0xDF, 0x59, 0x5C, 0x15 + }, + { + 0x95, 0x35, 0x80, 0x34, 0x1A, 0x0F, 0x86, 0x2D, + 0x51, 0x3A, 0x64, 0x41, 0x9D, 0x2E, 0x6B, 0x74, + 0x92, 0x7E, 0xAE, 0x87, 0x6C, 0x1D, 0xFF, 0x07, + 0xF7, 0x7F, 0xB1, 0x92, 0x2C, 0x42, 0x1A, 0xEC, + 0xE0, 0xBF, 0xC0, 0x83, 0x8B, 0x99, 0x89, 0x3C, + 0x67, 0x85, 0xA0, 0xF5, 0x90, 0x88, 0x96, 0x29, + 0xFD, 0x25, 0x32, 0x17, 0x19, 0x07, 0x36, 0x55, + 0x5E, 0xE6, 0x89, 0xE7, 0x07, 0x6E, 0x44, 0x80 + }, + { + 0xEA, 0x22, 0xED, 0x77, 0x59, 0xC2, 0x15, 0xAB, + 0x94, 0xF3, 0x47, 0xE2, 0xDB, 0x1B, 0x35, 0xC4, + 0x45, 0xA2, 0xD1, 0x24, 0x6A, 0xC5, 0x50, 0xF2, + 0x32, 0x0D, 0x8A, 0x8F, 0xDA, 0xCE, 0x20, 0x17, + 0x96, 0x8E, 0xDB, 0xAE, 0x13, 0xB4, 0xB7, 0x08, + 0x16, 0x4F, 0xA2, 0x7C, 0x61, 0x36, 0xCD, 0x8F, + 0x2C, 0x90, 0x66, 0x63, 0x79, 0x6E, 0x82, 0x57, + 0x8E, 0xDC, 0xDD, 0x02, 0xF8, 0xEF, 0x83, 0xFD + }, + { + 0x9D, 0x8B, 0xC9, 0x45, 0x08, 0xCA, 0x1F, 0x4E, + 0x88, 0xB9, 0xE3, 0x28, 0xE6, 0x5B, 0xAF, 0x93, + 0xCA, 0xBC, 0xE3, 0x96, 0xF0, 0x26, 0x41, 0x69, + 0x91, 0xDA, 0x6B, 0x5F, 0xE6, 0xD4, 0x43, 0x9E, + 0x92, 0xE5, 0x6E, 0x63, 0xFB, 0x90, 0x64, 0xF4, + 0x32, 0x2A, 0x5E, 0xFF, 0x46, 0xCF, 0x0E, 0xBC, + 0x7E, 0x47, 0x26, 0xFB, 0x8B, 0x25, 0x25, 0xA4, + 0x0E, 0x93, 0x77, 0x34, 0x50, 0x74, 0xBA, 0x57 + }, + { + 0x86, 0x51, 0x65, 0x9A, 0x0F, 0x83, 0x4F, 0xF0, + 0x4F, 0x37, 0x83, 0x7D, 0x71, 0xE0, 0xAE, 0x71, + 0x38, 0x28, 0xF9, 0x6A, 0x38, 0x91, 0xF6, 0xB7, + 0x95, 0xFD, 0x13, 0x9D, 0xFF, 0x25, 0x73, 0x7E, + 0x4A, 0x1A, 0xC2, 0x13, 0x1A, 0xF6, 0x89, 0xB9, + 0x06, 0xFB, 0xDE, 0xA3, 0x2C, 0xC3, 0xA2, 0xE0, + 0x0D, 0x52, 0x01, 0x84, 0x26, 0x0C, 0x06, 0x25, + 0x33, 0x37, 0x23, 0xAD, 0xE6, 0x55, 0x04, 0x2F + }, + { + 0xB4, 0xB3, 0x5B, 0xF0, 0x88, 0x5F, 0x05, 0x0E, + 0x94, 0x6D, 0xFC, 0x0E, 0xA2, 0xD0, 0x83, 0xBF, + 0x46, 0x5C, 0x66, 0x19, 0x45, 0x25, 0xF3, 0x48, + 0x13, 0xED, 0x68, 0x1F, 0xBE, 0xCA, 0x62, 0x3E, + 0x9E, 0x01, 0x7C, 0xE4, 0xAD, 0xDE, 0xDD, 0x86, + 0x2D, 0x90, 0x9B, 0xC9, 0x1F, 0xE2, 0xC6, 0x14, + 0xC1, 0x3F, 0x74, 0xB0, 0x60, 0x64, 0xF7, 0x87, + 0x3A, 0x2E, 0xB0, 0x47, 0x34, 0x17, 0x1D, 0x38 + }, + { + 0xE9, 0x50, 0x4E, 0x51, 0x11, 0x90, 0x2F, 0x47, + 0x9D, 0x68, 0x77, 0x57, 0x18, 0x42, 0x83, 0x0A, + 0xB7, 0x16, 0x36, 0x38, 0x09, 0x27, 0x31, 0xDD, + 0x77, 0xC6, 0x58, 0x23, 0xE7, 0xEC, 0xF0, 0x3E, + 0x8E, 0xDC, 0x43, 0xD1, 0xFD, 0x58, 0x13, 0x1F, + 0x37, 0x0C, 0xDF, 0x30, 0x88, 0x2C, 0x79, 0xC0, + 0x02, 0x37, 0xC5, 0xE0, 0xC2, 0xCB, 0x49, 0xC9, + 0x29, 0xF9, 0xE7, 0xC5, 0x68, 0xB4, 0x25, 0x74 + }, + { + 0xD7, 0x3E, 0x8D, 0x05, 0xDC, 0x21, 0x75, 0xB9, + 0x68, 0x76, 0xD6, 0xA7, 0x9A, 0xA5, 0x8B, 0xFB, + 0xDE, 0xF4, 0x2F, 0x87, 0x9C, 0xF1, 0xA1, 0xC4, + 0x9D, 0xD2, 0x15, 0xD6, 0xC2, 0xC6, 0x3A, 0x92, + 0x7F, 0x7B, 0x98, 0xBD, 0x8E, 0xD3, 0x6B, 0x35, + 0xCA, 0xF4, 0x57, 0xD9, 0xF8, 0xC6, 0xDC, 0x03, + 0x19, 0xA4, 0x97, 0x4D, 0x38, 0x8D, 0x2B, 0xCC, + 0x2A, 0x70, 0xEA, 0x05, 0xF9, 0x51, 0x6C, 0x47 + }, + { + 0x25, 0xD3, 0xD0, 0x1C, 0x71, 0x94, 0x10, 0xEB, + 0xED, 0xF2, 0x12, 0xF3, 0x91, 0xA5, 0xEB, 0x1E, + 0xEA, 0x76, 0x05, 0xD6, 0x7E, 0xF7, 0x4B, 0x23, + 0x85, 0xCB, 0xB1, 0x1D, 0x80, 0x01, 0x85, 0x43, + 0x96, 0x22, 0x70, 0x78, 0x83, 0x1F, 0x63, 0xD8, + 0x67, 0x59, 0x68, 0x17, 0x15, 0x1A, 0x69, 0x3F, + 0x8E, 0x38, 0x26, 0xE2, 0x20, 0x7E, 0x8E, 0xA3, + 0x8A, 0xA3, 0x71, 0x49, 0x53, 0xBF, 0x19, 0xC0 + }, + { + 0xAC, 0xE4, 0x9E, 0x6C, 0xD3, 0x54, 0xD5, 0x63, + 0xE8, 0x00, 0xB0, 0x8D, 0xD0, 0x2E, 0x7C, 0x82, + 0x2B, 0x30, 0x42, 0x12, 0x18, 0x49, 0x77, 0xBF, + 0x90, 0x01, 0xE7, 0x04, 0xF0, 0xD0, 0x6C, 0x25, + 0x5E, 0x7E, 0xC7, 0x80, 0x98, 0x72, 0xF9, 0xF4, + 0x55, 0xCF, 0x74, 0xD6, 0x13, 0x83, 0x4C, 0x43, + 0x00, 0xF6, 0x33, 0x81, 0x07, 0xE3, 0x9E, 0x4B, + 0xD3, 0x70, 0x47, 0x39, 0x9C, 0x35, 0x58, 0x8E + }, + { + 0xDB, 0x84, 0x56, 0x41, 0x4D, 0xA8, 0xB0, 0x53, + 0xC4, 0x97, 0x5D, 0x78, 0x92, 0x3E, 0xEC, 0xC1, + 0x4F, 0x53, 0x96, 0x26, 0xED, 0xFE, 0x0A, 0x43, + 0xC1, 0xEC, 0xF7, 0x8F, 0xB1, 0x4E, 0xD9, 0xC4, + 0xAB, 0xB4, 0xB8, 0x53, 0x86, 0x3C, 0x94, 0xC7, + 0x41, 0x5F, 0x12, 0xF3, 0x3E, 0xBE, 0x64, 0xFB, + 0xF1, 0x34, 0x4E, 0xBE, 0x70, 0x8A, 0x58, 0xB0, + 0x1B, 0x0B, 0x79, 0xE4, 0xA2, 0x90, 0xD1, 0xF6 + }, + { + 0xD7, 0x39, 0x57, 0x47, 0x11, 0x71, 0x11, 0x7A, + 0x2D, 0xE3, 0x71, 0x09, 0x3A, 0x21, 0x3A, 0x89, + 0x30, 0x46, 0x7C, 0x39, 0x39, 0x8C, 0xD1, 0xFD, + 0xA3, 0xB4, 0xA3, 0x15, 0xAA, 0x00, 0xC6, 0x72, + 0x98, 0x4D, 0xBC, 0x16, 0x6C, 0xA4, 0xF7, 0x11, + 0x40, 0xFF, 0xD8, 0xAE, 0x9D, 0xD9, 0xC8, 0x9F, + 0xB3, 0xA6, 0x45, 0x34, 0xB0, 0x72, 0x69, 0x2F, + 0x43, 0x2D, 0x11, 0x2F, 0xE1, 0x4A, 0x49, 0x2D + }, + { + 0x07, 0xBF, 0x9A, 0x80, 0xB6, 0xCB, 0xB5, 0xEC, + 0x1C, 0x2F, 0x8C, 0x65, 0x54, 0x25, 0x35, 0xEC, + 0x3B, 0xD0, 0x20, 0x85, 0x5B, 0x8A, 0x5F, 0x8C, + 0x1D, 0xEF, 0x41, 0x84, 0x88, 0xDB, 0x1B, 0x4A, + 0x47, 0xD8, 0xC6, 0x3E, 0x4F, 0xCA, 0xF9, 0x63, + 0x20, 0xB4, 0x51, 0xD8, 0xB1, 0x31, 0x46, 0xF4, + 0x55, 0xBD, 0x56, 0xB2, 0x5F, 0x8F, 0xC9, 0xA7, + 0x2E, 0xBD, 0xDD, 0xB4, 0x2C, 0xB5, 0x01, 0xEB + }, + { + 0xE4, 0x16, 0x0A, 0x35, 0x31, 0x93, 0xE4, 0xAB, + 0xBA, 0x4E, 0x33, 0x71, 0x0E, 0xC8, 0x9B, 0xBF, + 0xBA, 0x72, 0x83, 0x83, 0x0D, 0xF5, 0xE2, 0x19, + 0x78, 0x1F, 0xB3, 0xFF, 0x4E, 0xEF, 0x05, 0xF4, + 0xDE, 0x6A, 0x7E, 0x87, 0xBC, 0xDB, 0x78, 0xBF, + 0x53, 0x80, 0xC4, 0x5C, 0x20, 0x93, 0x48, 0x71, + 0xFA, 0x3D, 0xE3, 0x26, 0xDB, 0xFF, 0x5A, 0xCA, + 0x34, 0xB8, 0x44, 0x11, 0xDF, 0x4C, 0xEA, 0xF6 + }, + { + 0x41, 0x66, 0x50, 0xFE, 0x48, 0xDE, 0x67, 0x32, + 0xA2, 0x6D, 0xA9, 0x0F, 0xA8, 0xE6, 0xEC, 0x00, + 0x1C, 0x3A, 0x25, 0xAC, 0xD9, 0x41, 0x39, 0xCB, + 0x71, 0x5D, 0x06, 0x3D, 0x3E, 0x79, 0x54, 0x42, + 0xDE, 0x89, 0xDE, 0xC9, 0x09, 0xD9, 0xEE, 0x27, + 0xBC, 0x33, 0x64, 0x90, 0xDE, 0xF6, 0x90, 0x4F, + 0x81, 0xFE, 0x41, 0x7F, 0xFB, 0x43, 0x0E, 0x8C, + 0xB8, 0xE2, 0x85, 0xC2, 0x30, 0x6E, 0x50, 0x40 + }, + { + 0x65, 0x34, 0x2C, 0xFA, 0xDA, 0x3A, 0xCE, 0x3A, + 0xFE, 0x31, 0x56, 0x31, 0x1D, 0x25, 0x28, 0xC7, + 0x93, 0x10, 0xAF, 0x14, 0xB8, 0xEF, 0x43, 0x28, + 0x1F, 0xE0, 0xEC, 0x05, 0xBE, 0x1E, 0x0D, 0x0C, + 0x1B, 0xEB, 0xEC, 0xD2, 0x6C, 0xAE, 0x54, 0xE4, + 0xB2, 0x74, 0xE2, 0x0B, 0x5C, 0x95, 0x65, 0x80, + 0x96, 0x93, 0xF1, 0x06, 0xE6, 0xD6, 0x52, 0x41, + 0x7F, 0xEE, 0x12, 0x3D, 0xDF, 0xA5, 0x64, 0xCE + }, + { + 0x7A, 0x4B, 0xFC, 0xDC, 0x98, 0x3E, 0x61, 0x97, + 0x02, 0xDF, 0x6D, 0xBA, 0xAC, 0x22, 0x97, 0x83, + 0xE9, 0xE5, 0xD4, 0x33, 0xF4, 0x0C, 0x85, 0xEC, + 0xF5, 0xC0, 0x87, 0xBE, 0xD5, 0x1F, 0xF6, 0x6C, + 0x28, 0x29, 0x39, 0x06, 0xFF, 0x32, 0xD9, 0xD4, + 0x23, 0x2F, 0x9C, 0xB1, 0xD8, 0x37, 0x7E, 0xC1, + 0x14, 0x39, 0x88, 0x58, 0x83, 0x8E, 0x3F, 0x8F, + 0xC0, 0x42, 0xF3, 0x31, 0x8E, 0xAB, 0xA6, 0x06 + }, + { + 0x9F, 0x12, 0xA3, 0xA4, 0xD1, 0xC1, 0xC4, 0x9A, + 0xD9, 0x57, 0x18, 0x5E, 0x89, 0x00, 0x41, 0xD4, + 0xCE, 0x79, 0x80, 0x88, 0x73, 0x09, 0x06, 0xE7, + 0x0F, 0xEE, 0x40, 0xF1, 0x04, 0xEB, 0x89, 0x20, + 0x6F, 0x7B, 0x5D, 0x00, 0xE7, 0x39, 0x37, 0xAB, + 0xF7, 0xEF, 0x6F, 0xF2, 0x84, 0x66, 0xDD, 0xCE, + 0x0A, 0x13, 0xB6, 0x3E, 0x75, 0x60, 0xF5, 0xCD, + 0xE5, 0xA1, 0xAC, 0xBD, 0x7F, 0xF6, 0x5A, 0xCC + }, + { + 0x2A, 0x39, 0xE6, 0x12, 0x23, 0xDD, 0x57, 0xAA, + 0x7D, 0xB5, 0xAB, 0x06, 0x49, 0xF2, 0xA2, 0x14, + 0x51, 0xDA, 0x9E, 0x51, 0x8E, 0xA6, 0x16, 0xFD, + 0xA0, 0x1A, 0xD3, 0x78, 0x75, 0xC4, 0x8D, 0x5E, + 0x4D, 0x7D, 0x45, 0x38, 0x9A, 0x58, 0x66, 0x98, + 0x16, 0x25, 0x15, 0x4D, 0x05, 0x18, 0x0F, 0x7C, + 0xC7, 0x83, 0xD1, 0xCD, 0x6C, 0x2A, 0xD9, 0xDE, + 0x9E, 0x87, 0x9F, 0x8D, 0xBC, 0x62, 0xC9, 0x32 + }, + { + 0x89, 0x5E, 0x5A, 0xDA, 0x86, 0x2A, 0x53, 0xE1, + 0x8E, 0xC7, 0xD7, 0xD7, 0xEC, 0x54, 0xD8, 0x10, + 0x68, 0x6F, 0x8B, 0xF4, 0xA2, 0x0D, 0x20, 0x43, + 0x44, 0xE0, 0xE8, 0x4B, 0xD3, 0x73, 0x1A, 0xD5, + 0x9B, 0x66, 0x87, 0xFD, 0x61, 0x36, 0x26, 0xDC, + 0x0F, 0x6E, 0x27, 0x3B, 0x74, 0x49, 0xD3, 0x94, + 0x0A, 0x28, 0x4E, 0xDC, 0x1F, 0xD0, 0xBE, 0x70, + 0xA9, 0x37, 0x3B, 0xD1, 0xF8, 0x46, 0x84, 0xE4 + }, + { + 0x1C, 0x05, 0xC6, 0x72, 0x7E, 0x7B, 0xFF, 0xBF, + 0x54, 0x68, 0x42, 0x3F, 0xDA, 0xC4, 0x43, 0x90, + 0x85, 0x8D, 0xD7, 0xD5, 0xAF, 0x2B, 0x99, 0xA0, + 0xA6, 0x73, 0x77, 0xD3, 0xB7, 0x78, 0x22, 0x29, + 0x57, 0x67, 0xBD, 0x53, 0xAA, 0x5C, 0xDF, 0xFF, + 0x87, 0xEA, 0xDB, 0x19, 0x23, 0xF8, 0x09, 0xC1, + 0xA6, 0xF6, 0x51, 0x07, 0x0A, 0xB8, 0xCA, 0xE7, + 0x9B, 0x7C, 0x3A, 0xE6, 0xBD, 0x23, 0xAF, 0xD3 + }, + { + 0x0F, 0xC1, 0x48, 0x37, 0x84, 0x24, 0xAA, 0x92, + 0xC0, 0x12, 0xB4, 0x7E, 0x2B, 0x79, 0xC0, 0x65, + 0x3F, 0x1D, 0x86, 0x30, 0x00, 0x1D, 0x6A, 0xE7, + 0x94, 0xA4, 0x23, 0x47, 0x2A, 0xA4, 0x09, 0x34, + 0xDF, 0x9B, 0x3C, 0x86, 0xE9, 0x85, 0x05, 0x4E, + 0xEF, 0xE7, 0x5C, 0xBD, 0xAC, 0x8B, 0x89, 0x8B, + 0x31, 0x14, 0xCA, 0x0E, 0xA2, 0xB9, 0x93, 0x25, + 0x90, 0x9A, 0x92, 0x49, 0x58, 0x07, 0x99, 0xAA + }, + { + 0x58, 0x75, 0x3B, 0x1F, 0x60, 0xEB, 0x5F, 0xC0, + 0x4F, 0x50, 0x21, 0xAC, 0x28, 0xAA, 0x13, 0x32, + 0x73, 0x1B, 0xF4, 0x60, 0xD8, 0x42, 0x3E, 0x2C, + 0x0D, 0x5F, 0x42, 0x32, 0x9C, 0x52, 0x5A, 0x0B, + 0x91, 0xEE, 0xF1, 0xDB, 0x87, 0x5F, 0x38, 0x45, + 0x11, 0xB2, 0x2B, 0x87, 0xEA, 0x0D, 0x70, 0xBE, + 0xCF, 0x50, 0x55, 0x53, 0x75, 0x19, 0x3B, 0xEE, + 0x1C, 0x12, 0xEB, 0x71, 0x42, 0x7D, 0xBB, 0xCD + }, + { + 0x82, 0x2B, 0xF2, 0xB5, 0xC1, 0xCE, 0x41, 0x01, + 0x58, 0xB6, 0x8F, 0x3C, 0x42, 0xDE, 0x7B, 0xF0, + 0x3D, 0x34, 0x94, 0xB1, 0x01, 0xBF, 0x89, 0x43, + 0x4D, 0xEE, 0x8D, 0x35, 0x75, 0xC5, 0x91, 0xEF, + 0x6F, 0x5C, 0xE9, 0x0F, 0xE5, 0xF8, 0x3C, 0x66, + 0x91, 0xDC, 0x0C, 0xC6, 0x73, 0x20, 0xA6, 0x16, + 0xB1, 0x45, 0xB3, 0x88, 0xCD, 0x4B, 0x0F, 0x59, + 0x8E, 0x53, 0x30, 0xBF, 0x73, 0x6D, 0xA0, 0xE8 + }, + { + 0xD5, 0x89, 0x37, 0xD4, 0x49, 0x89, 0x77, 0xBD, + 0xA3, 0x3F, 0x32, 0xD9, 0xCE, 0x6F, 0x9E, 0x5A, + 0x92, 0xF7, 0x2B, 0xE2, 0x9A, 0xB2, 0xD3, 0x9E, + 0x95, 0x30, 0x92, 0xBE, 0x70, 0x1C, 0x72, 0x8B, + 0x0E, 0x84, 0xC9, 0x5F, 0xE6, 0xCA, 0x0A, 0xFD, + 0x83, 0xA0, 0x5F, 0xD5, 0x7F, 0xE3, 0x65, 0xD0, + 0x06, 0x26, 0xBD, 0x88, 0x10, 0x08, 0x36, 0x5F, + 0xF6, 0xFF, 0x5E, 0x27, 0x94, 0x7B, 0xEC, 0x9C + }, + { + 0x1E, 0x70, 0x43, 0xF1, 0xCA, 0x38, 0x5E, 0x6B, + 0x4A, 0x48, 0xE7, 0xFA, 0x2A, 0x98, 0xB8, 0x15, + 0x40, 0xB1, 0xC0, 0x0A, 0xB2, 0x99, 0x76, 0xFB, + 0xCC, 0x28, 0x35, 0x07, 0xB9, 0x76, 0x23, 0x3C, + 0x35, 0xBA, 0x8E, 0x47, 0xAE, 0xD6, 0x91, 0x94, + 0x88, 0x1E, 0xC1, 0x39, 0xBA, 0x30, 0xD4, 0x03, + 0xB6, 0x65, 0x00, 0x7A, 0x82, 0xD8, 0xF9, 0x78, + 0xA3, 0x38, 0xFB, 0xA4, 0x3A, 0x25, 0xE1, 0x22 + }, + { + 0x05, 0x4F, 0x48, 0xC5, 0x41, 0xB9, 0x9E, 0x47, + 0xC8, 0xF1, 0xAF, 0x4B, 0x6F, 0x07, 0xCF, 0xBD, + 0x51, 0x42, 0x0F, 0x18, 0xF3, 0x02, 0x52, 0x95, + 0x92, 0x6E, 0x96, 0x2D, 0x5F, 0x8B, 0x1F, 0x8C, + 0xE5, 0xAC, 0x9F, 0x25, 0xEE, 0xA7, 0xD0, 0x3E, + 0x10, 0x07, 0xD3, 0xCF, 0x7F, 0x92, 0x09, 0x3E, + 0xD9, 0x57, 0xEB, 0x0B, 0x51, 0x4E, 0x7D, 0x19, + 0xE8, 0x86, 0x35, 0xE1, 0xAB, 0x31, 0xDC, 0xED + }, + { + 0x83, 0x26, 0xD9, 0x89, 0x61, 0x6A, 0x4C, 0x6A, + 0x21, 0x36, 0xDB, 0x94, 0x2D, 0x15, 0x88, 0x37, + 0xF4, 0x0A, 0xDC, 0x71, 0xF3, 0xE8, 0x15, 0x7B, + 0x5D, 0xD3, 0x39, 0x50, 0xD5, 0x2D, 0x9B, 0x17, + 0x37, 0x9C, 0xF1, 0xF7, 0xDE, 0x66, 0x4B, 0xBD, + 0x34, 0x19, 0x4D, 0x3F, 0xEA, 0x6D, 0xAF, 0x97, + 0x5F, 0x5E, 0x8B, 0xDF, 0x20, 0xDE, 0xF1, 0x49, + 0xC6, 0x60, 0x01, 0x90, 0xBC, 0x42, 0x37, 0x79 + }, + { + 0x5C, 0xC6, 0xAB, 0x95, 0x2D, 0xAF, 0xCF, 0xC8, + 0x68, 0x23, 0x6F, 0xD2, 0x21, 0x52, 0x94, 0xD6, + 0x68, 0xE1, 0x02, 0x00, 0xA8, 0xAD, 0x0C, 0xDC, + 0x1F, 0x4A, 0x38, 0x4D, 0x0A, 0x6C, 0x40, 0x94, + 0xFA, 0x4C, 0x42, 0x7E, 0x00, 0xA9, 0xC9, 0x67, + 0xE6, 0x49, 0x00, 0xC0, 0x57, 0xD4, 0xBB, 0x11, + 0x69, 0xFE, 0xB4, 0x8A, 0x34, 0x4C, 0x62, 0x22, + 0x6C, 0x23, 0x65, 0x76, 0x6B, 0xEB, 0x86, 0x21 + }, + { + 0xCD, 0xE7, 0xF8, 0x31, 0x71, 0xA6, 0x32, 0x1F, + 0xEA, 0x3E, 0xC0, 0x8B, 0x86, 0xA8, 0x49, 0xCC, + 0x5E, 0xF3, 0x55, 0x53, 0x7D, 0x7B, 0x1C, 0xE2, + 0x59, 0xAA, 0xC8, 0x0E, 0x55, 0xC0, 0xC9, 0x39, + 0xF5, 0x21, 0x24, 0xA3, 0xDE, 0xB0, 0x90, 0x48, + 0x7F, 0xFD, 0xF7, 0x09, 0xA6, 0xBD, 0x0F, 0x36, + 0x45, 0x70, 0x99, 0x81, 0x75, 0xD6, 0xF6, 0x8B, + 0x40, 0x85, 0xEA, 0xE5, 0x19, 0x0E, 0x65, 0x86 + }, + { + 0xA6, 0x8E, 0xAB, 0xA4, 0x0A, 0xF0, 0x31, 0xC0, + 0x7E, 0xFD, 0x4C, 0xE7, 0x28, 0xC9, 0xBC, 0x53, + 0x54, 0x98, 0xAB, 0x5D, 0x9D, 0x89, 0xDD, 0x06, + 0x70, 0x4C, 0x59, 0xA9, 0x03, 0xEF, 0xCA, 0x71, + 0x18, 0x24, 0x08, 0x6A, 0x60, 0x19, 0x7C, 0xB6, + 0x4A, 0x10, 0xE5, 0xFF, 0x9F, 0x7B, 0x16, 0x1F, + 0x82, 0x2A, 0xEA, 0xC6, 0x98, 0x46, 0x1E, 0x12, + 0x25, 0xCC, 0x17, 0x84, 0xAB, 0xBB, 0x52, 0xA5 + }, + { + 0x6E, 0x1A, 0xC3, 0x76, 0x5B, 0xF3, 0x32, 0xE9, + 0x7D, 0xF0, 0xE8, 0x68, 0xE8, 0x8C, 0xA8, 0x3D, + 0xEF, 0xD9, 0xB2, 0xBA, 0x0A, 0x48, 0x48, 0xE2, + 0x3F, 0x0C, 0xA0, 0x91, 0x37, 0x4C, 0xDC, 0xD4, + 0x09, 0xFF, 0xE3, 0x62, 0xA3, 0x08, 0xC0, 0xC6, + 0x3A, 0x91, 0xF3, 0xE3, 0x5D, 0xB8, 0x9E, 0x2E, + 0x1E, 0x85, 0x60, 0x21, 0xDD, 0x7F, 0xE9, 0x8B, + 0xD1, 0x8A, 0xFE, 0x93, 0xF3, 0x8E, 0x7A, 0x7A + }, + { + 0x42, 0xDA, 0x74, 0x7B, 0x37, 0x08, 0xA2, 0x8C, + 0xB2, 0xF5, 0xF4, 0xC2, 0x94, 0xE6, 0xC2, 0xDC, + 0xE9, 0xF5, 0xD5, 0x90, 0xB2, 0x85, 0x11, 0x90, + 0xA3, 0x6F, 0xD4, 0x3D, 0xF7, 0x89, 0x22, 0x9C, + 0xA0, 0xCD, 0xE2, 0xA9, 0x65, 0x3E, 0x11, 0x81, + 0x33, 0x15, 0x1A, 0x38, 0xC3, 0xD2, 0x34, 0x73, + 0x97, 0xC7, 0xBB, 0xD1, 0xEB, 0x6D, 0x3C, 0x1B, + 0x15, 0xB6, 0x13, 0x39, 0x33, 0x5D, 0x78, 0xB7 + }, + { + 0x55, 0x62, 0x58, 0x44, 0x92, 0xA3, 0x94, 0xA6, + 0x2C, 0x10, 0x30, 0x1A, 0xFD, 0xBF, 0xAA, 0x40, + 0x89, 0x41, 0x78, 0x9F, 0x9D, 0x1E, 0x3F, 0xB9, + 0x0A, 0xA0, 0xB4, 0x80, 0x91, 0xD2, 0x9E, 0x3E, + 0xF6, 0xCD, 0xA9, 0x97, 0x04, 0xCE, 0x23, 0xD7, + 0x84, 0x87, 0x07, 0xCC, 0x30, 0x50, 0xD5, 0xF3, + 0x8C, 0xEE, 0x67, 0x73, 0x7E, 0x7E, 0x8D, 0x48, + 0xB9, 0x39, 0xC8, 0x93, 0x76, 0x9E, 0xAA, 0xAF + }, + { + 0x54, 0x04, 0x28, 0x36, 0x77, 0xAA, 0x11, 0x6D, + 0x35, 0x3E, 0x73, 0x11, 0x5F, 0x37, 0xEE, 0x77, + 0x0B, 0xEF, 0xF4, 0xAC, 0xAF, 0x20, 0x80, 0x7A, + 0xC3, 0xBE, 0x11, 0x2A, 0x44, 0x64, 0xC8, 0x64, + 0x80, 0x2C, 0xFE, 0xBE, 0x81, 0x60, 0x17, 0x1D, + 0x32, 0x27, 0xEE, 0x3E, 0xD4, 0xDA, 0x4D, 0x84, + 0x5F, 0xD2, 0xF8, 0xF5, 0x03, 0x7D, 0x37, 0x10, + 0xF4, 0x3B, 0x83, 0xE1, 0xEA, 0xAF, 0xA5, 0xD2 + }, + { + 0xAB, 0x53, 0xA7, 0x09, 0x26, 0xC9, 0xD9, 0x30, + 0x9E, 0x19, 0x68, 0x80, 0xD8, 0xDD, 0x8E, 0x56, + 0x18, 0x63, 0xE7, 0x6E, 0x1B, 0xD0, 0x74, 0xE7, + 0x8F, 0x0E, 0xB5, 0xD0, 0x5E, 0x9B, 0x4E, 0xD7, + 0x90, 0xFF, 0x17, 0xD1, 0xF5, 0xB4, 0x1E, 0x9A, + 0x07, 0xB9, 0xC0, 0x3E, 0x0A, 0x6A, 0xCA, 0x9B, + 0x1C, 0x6B, 0xA8, 0xF3, 0xB2, 0xDE, 0xE8, 0x53, + 0xC6, 0x71, 0xA7, 0x74, 0xBE, 0x4B, 0xEA, 0x9D + }, + { + 0x48, 0x0E, 0xE9, 0xCE, 0xC3, 0x45, 0x6E, 0x46, + 0x43, 0x02, 0x1F, 0x7B, 0x47, 0x28, 0x8E, 0x2D, + 0x79, 0x15, 0xD3, 0x75, 0x44, 0xB3, 0x95, 0x42, + 0x84, 0xCE, 0x87, 0x69, 0xB6, 0xC8, 0xD7, 0x76, + 0x99, 0x59, 0x31, 0x06, 0xC0, 0x4D, 0xD0, 0xE2, + 0x01, 0xAD, 0x0C, 0x4E, 0xB7, 0x9C, 0x59, 0x63, + 0xA5, 0xC5, 0xE9, 0xF7, 0xA4, 0x04, 0x47, 0x66, + 0x6B, 0xA1, 0xD6, 0xA7, 0x83, 0x65, 0x13, 0x63 + }, + { + 0xBB, 0x56, 0x28, 0xE5, 0x6C, 0x2D, 0x14, 0x3B, + 0xA6, 0xBE, 0xE0, 0xE5, 0x28, 0xD4, 0x75, 0x21, + 0x21, 0xF1, 0xAE, 0xDB, 0x31, 0xF1, 0xCC, 0x17, + 0xBD, 0xA1, 0xEC, 0x01, 0x27, 0x91, 0x51, 0x6D, + 0xC9, 0xE6, 0xE9, 0xB7, 0x20, 0xFC, 0xB7, 0x41, + 0x15, 0x5D, 0xCC, 0x63, 0xFE, 0x64, 0x5E, 0x82, + 0x30, 0xF3, 0xE1, 0xE1, 0x94, 0x4C, 0x68, 0x05, + 0xA2, 0x9E, 0x90, 0x6C, 0xD3, 0xA0, 0xB9, 0xCD + }, + { + 0x32, 0x51, 0x16, 0x9F, 0x12, 0x70, 0x0F, 0x0B, + 0xDC, 0xCD, 0x3F, 0xCB, 0xB3, 0xD8, 0x75, 0x49, + 0xD9, 0xA5, 0x04, 0x22, 0x44, 0x7F, 0x08, 0xEF, + 0xB8, 0x9F, 0x7E, 0x1D, 0xD4, 0x0B, 0x03, 0x53, + 0x9D, 0xF0, 0xAE, 0xEE, 0x2B, 0x45, 0xFE, 0x87, + 0xB7, 0x04, 0xAC, 0x4A, 0x9D, 0xF7, 0xC3, 0x8A, + 0xBC, 0xFC, 0xC1, 0x84, 0xE4, 0x10, 0x1B, 0x84, + 0x86, 0x8A, 0xF2, 0xEB, 0xE6, 0x70, 0xB3, 0xC6 + }, + { + 0xA4, 0x70, 0x52, 0xD7, 0xF5, 0x43, 0x4E, 0xBB, + 0x93, 0x44, 0x34, 0x38, 0x28, 0x31, 0x30, 0xE1, + 0xCD, 0xF3, 0x6A, 0x8F, 0xCB, 0x77, 0x39, 0x12, + 0xBD, 0x05, 0x41, 0x6E, 0x44, 0x07, 0x08, 0xDC, + 0xAF, 0xDA, 0x87, 0xF6, 0x46, 0x27, 0xF3, 0x93, + 0x56, 0xDA, 0xD5, 0xD6, 0x53, 0x7F, 0x4E, 0xDB, + 0x64, 0xBE, 0xD3, 0xB6, 0x9C, 0xEB, 0x9F, 0x7F, + 0x80, 0x6E, 0xB3, 0x7B, 0xC4, 0x55, 0xA2, 0xD0 + }, + { + 0x4D, 0x01, 0x28, 0x12, 0xA7, 0xFA, 0x97, 0x9F, + 0xE1, 0x07, 0xB9, 0x34, 0x09, 0xD9, 0xAB, 0xD4, + 0x9F, 0x51, 0xCB, 0x74, 0xAF, 0x17, 0xF1, 0x49, + 0x5B, 0xBE, 0xDB, 0x9D, 0x44, 0xAC, 0xD6, 0xE3, + 0x66, 0xAA, 0x3F, 0x3A, 0x59, 0x56, 0x22, 0xE5, + 0x53, 0x4D, 0xA8, 0x52, 0x9B, 0x98, 0x8D, 0x8C, + 0x62, 0x2E, 0xF8, 0x44, 0x81, 0xE3, 0x36, 0x38, + 0x7B, 0x5E, 0xA5, 0x5D, 0x7B, 0x02, 0x58, 0x63 + }, + { + 0x72, 0xBF, 0xB8, 0xDC, 0xB1, 0x11, 0x5E, 0xE5, + 0xE6, 0x11, 0x7B, 0x86, 0xDB, 0xC6, 0x86, 0x38, + 0x94, 0x2A, 0x31, 0x13, 0x87, 0xBF, 0xDD, 0x3A, + 0xF9, 0xE1, 0x21, 0xC5, 0xD6, 0x9B, 0x89, 0x56, + 0x7E, 0xB4, 0xBB, 0x5C, 0xAD, 0x13, 0x2B, 0x80, + 0x23, 0x92, 0xF9, 0x8E, 0xBF, 0x11, 0x4A, 0xED, + 0x21, 0x2B, 0xFD, 0x7B, 0xF2, 0xD3, 0x54, 0x0C, + 0x08, 0xA7, 0x6D, 0xCA, 0xD2, 0x38, 0x51, 0xA7 + }, + { + 0x4D, 0xA0, 0x49, 0x00, 0x73, 0xF8, 0x6C, 0x2B, + 0xA9, 0x6D, 0x90, 0x58, 0x3E, 0x43, 0x65, 0xE5, + 0x16, 0x5C, 0xE2, 0x5F, 0x32, 0xAA, 0xD2, 0x92, + 0x44, 0x50, 0x7C, 0x83, 0xDE, 0x1E, 0xB9, 0xFC, + 0x99, 0xF8, 0xC3, 0xB5, 0xE2, 0x8E, 0xC5, 0x0C, + 0xC0, 0x94, 0xA9, 0x8B, 0xB9, 0x2A, 0x9A, 0xD4, + 0x78, 0x95, 0x8C, 0xD0, 0x54, 0x5E, 0x48, 0xE2, + 0xE2, 0x94, 0xE3, 0x43, 0xEA, 0xE9, 0xD6, 0x88 + }, + { + 0xC6, 0xA0, 0xCD, 0x42, 0x6C, 0x5C, 0xDF, 0x44, + 0x5A, 0x6F, 0x04, 0x4C, 0x8C, 0xD4, 0xD8, 0x51, + 0xD1, 0xD9, 0xF6, 0x76, 0x36, 0x65, 0xB8, 0x2C, + 0x3B, 0xE3, 0x79, 0x06, 0xFA, 0x63, 0x60, 0xD8, + 0xC3, 0x8F, 0xD9, 0xC3, 0x11, 0xF2, 0xC0, 0xE7, + 0xFC, 0xEE, 0xBB, 0x41, 0xD8, 0x21, 0x95, 0x24, + 0x4D, 0x71, 0xC7, 0xFD, 0xB3, 0x21, 0xBE, 0xFE, + 0xE0, 0x48, 0x1F, 0xE0, 0x64, 0xD5, 0x3B, 0x0E + }, + { + 0x8A, 0x7C, 0x40, 0x97, 0x30, 0x2C, 0x62, 0xBB, + 0x8A, 0x3F, 0x3C, 0xB5, 0xE8, 0xFA, 0x70, 0x17, + 0xFB, 0x42, 0xEA, 0xC3, 0x53, 0x4A, 0x4A, 0x88, + 0x23, 0x80, 0x71, 0xD1, 0xE3, 0x8C, 0x2E, 0x2F, + 0xBF, 0x07, 0x6A, 0x96, 0xDE, 0xAC, 0x0E, 0x1B, + 0xE6, 0x4C, 0x1D, 0x6B, 0xE5, 0x50, 0x4B, 0x22, + 0x05, 0x73, 0x13, 0xF2, 0xA1, 0x42, 0x64, 0x53, + 0xDC, 0xCF, 0x7D, 0x44, 0xD6, 0xFC, 0x33, 0xA9 + }, + { + 0x60, 0x30, 0xA8, 0x14, 0x1B, 0x45, 0xD4, 0x57, + 0xF8, 0x76, 0x99, 0xAF, 0xB8, 0x3B, 0xB6, 0x8F, + 0xF4, 0xCE, 0x53, 0x57, 0x24, 0xF1, 0x14, 0xAF, + 0x91, 0x4A, 0x98, 0x75, 0x5D, 0x42, 0x66, 0xD4, + 0xC9, 0x8A, 0x7C, 0x1E, 0x45, 0xFA, 0xE1, 0x93, + 0xDC, 0x69, 0x09, 0xB8, 0xB0, 0x50, 0xE0, 0x34, + 0x92, 0xF7, 0x19, 0x66, 0x2D, 0x90, 0xB5, 0xAE, + 0x76, 0x40, 0x47, 0x28, 0x8F, 0xAF, 0x18, 0x20 + }, + { + 0xA4, 0x7A, 0xB7, 0xCC, 0x1A, 0xAB, 0x22, 0xEC, + 0xF4, 0xB7, 0x79, 0xF7, 0x60, 0x3F, 0xDF, 0x3F, + 0xBC, 0x3F, 0xC7, 0x25, 0x67, 0x47, 0xFA, 0x54, + 0x47, 0xFA, 0xD6, 0xD2, 0x04, 0xA4, 0x29, 0x76, + 0x4C, 0x58, 0x5C, 0xCE, 0xD1, 0xD6, 0x33, 0x64, + 0x6E, 0x01, 0x60, 0x37, 0xEF, 0x4B, 0xC1, 0x52, + 0xDB, 0x4B, 0x76, 0xA1, 0x4F, 0x24, 0x05, 0x64, + 0x4A, 0x69, 0x97, 0x3A, 0xD8, 0xBD, 0x7E, 0x18 + }, + { + 0x8D, 0xED, 0x46, 0x60, 0x21, 0x8E, 0xFF, 0x21, + 0xDA, 0x35, 0x7C, 0x4B, 0x43, 0x07, 0x32, 0xBF, + 0x59, 0x88, 0xFD, 0x39, 0x7A, 0x41, 0x31, 0x2B, + 0xB5, 0x07, 0xB1, 0x65, 0x43, 0x0A, 0x7B, 0x41, + 0xC2, 0x65, 0xDF, 0xD5, 0xEF, 0xBB, 0x4E, 0xCB, + 0x2A, 0x97, 0xA9, 0x64, 0x80, 0xAE, 0x19, 0x86, + 0x0C, 0x37, 0x50, 0x37, 0x7A, 0x12, 0x68, 0xF2, + 0x12, 0x87, 0x80, 0x61, 0x3F, 0xE5, 0x20, 0xE1 + }, + { + 0x2B, 0x9B, 0x8B, 0xD9, 0x5B, 0x23, 0x62, 0x75, + 0xF3, 0xCE, 0xD7, 0x2F, 0xDF, 0xD4, 0x9A, 0x8F, + 0x51, 0x67, 0x69, 0x41, 0x76, 0x7B, 0x76, 0x0A, + 0xBE, 0xDA, 0x36, 0x1B, 0x07, 0xB4, 0xA0, 0xA0, + 0x2E, 0xA0, 0x8D, 0x3E, 0x91, 0xF1, 0xCD, 0xB4, + 0xB2, 0x74, 0xCC, 0xED, 0x21, 0x6D, 0xE9, 0x89, + 0xE5, 0x5E, 0x4C, 0x25, 0x49, 0x7B, 0x99, 0xDE, + 0x6B, 0x4C, 0x55, 0xB7, 0x85, 0xD0, 0xFC, 0x79 + }, + { + 0x42, 0x11, 0xE3, 0x42, 0xF7, 0x58, 0x8A, 0xCC, + 0xE7, 0xA7, 0xDF, 0x92, 0xB7, 0x9F, 0xDF, 0x7D, + 0xEA, 0x14, 0xFA, 0x42, 0x21, 0xDD, 0x59, 0xCD, + 0x0E, 0x81, 0x5C, 0x2A, 0xC0, 0xE5, 0xAF, 0xCF, + 0xD2, 0x25, 0x05, 0xA4, 0x3D, 0xBB, 0xA7, 0x0B, + 0x90, 0x5F, 0x31, 0xD2, 0x90, 0xB1, 0xD1, 0xDD, + 0xC8, 0xFF, 0x69, 0xF5, 0xCC, 0x65, 0x6B, 0x2C, + 0x6F, 0x74, 0x66, 0x8A, 0x38, 0x1A, 0xE8, 0xE2 + }, + { + 0x15, 0x2E, 0xCD, 0xD8, 0xB7, 0x4F, 0xC2, 0x52, + 0xA2, 0xC2, 0x7A, 0x7B, 0x5E, 0x9C, 0x2C, 0xC5, + 0xA9, 0x0E, 0x4A, 0x12, 0xA1, 0x9B, 0x4D, 0xC5, + 0x35, 0xF0, 0xF3, 0x5F, 0x9E, 0xE5, 0xD1, 0x4F, + 0x1F, 0x59, 0x5B, 0xC3, 0xC9, 0xC1, 0x3B, 0x92, + 0xA3, 0x2B, 0x4E, 0x62, 0x1D, 0x91, 0x64, 0x2E, + 0x5D, 0x70, 0x90, 0x11, 0x4F, 0x26, 0xCE, 0xE1, + 0x08, 0x4E, 0x4E, 0x1A, 0x7B, 0xB4, 0xD2, 0xA8 + }, + { + 0xDD, 0xBE, 0x61, 0xE3, 0xC6, 0x2D, 0x2D, 0xE9, + 0xC5, 0x5B, 0x7F, 0x3B, 0x34, 0x08, 0x4E, 0x8D, + 0x49, 0x6F, 0x6F, 0xBF, 0x95, 0xC1, 0x1B, 0x9A, + 0xF8, 0x0F, 0xBE, 0x00, 0xF1, 0xC0, 0x69, 0xAB, + 0xEB, 0x24, 0x6C, 0x48, 0x89, 0xD8, 0x89, 0x9F, + 0xB5, 0x7E, 0xC9, 0xBB, 0x05, 0xFB, 0x0D, 0xDD, + 0x4E, 0x3F, 0x7C, 0xB3, 0x4B, 0x83, 0x93, 0x80, + 0x2E, 0xD1, 0xE7, 0x92, 0x93, 0xB8, 0xC9, 0x8C + }, + { + 0x0B, 0x74, 0x0F, 0xC2, 0xE6, 0xA6, 0xCA, 0x90, + 0x87, 0x1F, 0xCC, 0x4B, 0xCE, 0x7B, 0xC1, 0x3D, + 0xF3, 0xF4, 0xCD, 0xDA, 0x35, 0xB1, 0x6D, 0xE5, + 0x26, 0x62, 0x8E, 0x06, 0x27, 0xFA, 0x9C, 0xD8, + 0x1C, 0xEF, 0xBE, 0x1B, 0xB2, 0xC1, 0xE5, 0x39, + 0xFE, 0x2A, 0x0F, 0x1A, 0xA3, 0x2F, 0xE3, 0x42, + 0xC1, 0x45, 0x4B, 0x93, 0x8A, 0x25, 0xE5, 0x1A, + 0xE5, 0x5A, 0x6B, 0xEE, 0x39, 0xED, 0x60, 0xF6 + }, + { + 0x89, 0xB6, 0x75, 0xAE, 0xA9, 0x70, 0xDF, 0xD4, + 0xD5, 0x68, 0x07, 0xFC, 0xDE, 0xA5, 0x42, 0x07, + 0x75, 0x8A, 0xA6, 0x0B, 0x47, 0xFB, 0x9E, 0x1A, + 0x30, 0x33, 0x2C, 0x2E, 0x3B, 0x5C, 0x13, 0x19, + 0xEC, 0x08, 0x4D, 0x67, 0x50, 0xEC, 0x34, 0xD4, + 0xE0, 0x50, 0x58, 0x75, 0xF8, 0xB1, 0x83, 0xFE, + 0xA1, 0x7F, 0x01, 0x61, 0xBD, 0x49, 0x2E, 0x5D, + 0x41, 0x4A, 0x30, 0x1C, 0x95, 0x69, 0xC7, 0x22 + }, + { + 0x94, 0xBF, 0xAB, 0x66, 0xEB, 0x87, 0xBC, 0x45, + 0x36, 0xC1, 0xB8, 0x74, 0x81, 0xCA, 0x3C, 0xB9, + 0x52, 0x0A, 0x21, 0x01, 0x8A, 0xD5, 0x20, 0xC9, + 0xDA, 0x34, 0x23, 0xDF, 0xAB, 0x0F, 0xC1, 0xD2, + 0xB7, 0xAA, 0x3C, 0x0F, 0x3D, 0xCD, 0xC1, 0xC5, + 0x89, 0x71, 0x09, 0xED, 0x0E, 0xD5, 0xBF, 0xDF, + 0xDF, 0x00, 0xAC, 0x15, 0x45, 0x7A, 0x27, 0x48, + 0x79, 0x2A, 0x98, 0x50, 0x48, 0x8D, 0x1C, 0xF8 + }, + { + 0x4A, 0x9E, 0x3F, 0x22, 0xF4, 0x6F, 0x67, 0x13, + 0x4B, 0x5A, 0x0A, 0xBE, 0x17, 0x1E, 0xD4, 0x95, + 0xC9, 0xA5, 0x49, 0x3A, 0x3A, 0xEC, 0xF8, 0xB2, + 0x28, 0xF1, 0x8F, 0x41, 0x0F, 0xE0, 0xF1, 0xD6, + 0x65, 0x5F, 0xD8, 0xAE, 0xCB, 0x8B, 0x7D, 0xD7, + 0xF4, 0x90, 0xF9, 0xCA, 0xB3, 0x8F, 0xDB, 0x09, + 0xA6, 0xFF, 0x15, 0xEE, 0xC4, 0x51, 0xDA, 0x12, + 0x28, 0x59, 0x51, 0xDF, 0xA7, 0x20, 0x70, 0xDF + }, + { + 0xC8, 0xA1, 0x7F, 0x2C, 0x04, 0x03, 0xE0, 0xAF, + 0xC6, 0x5A, 0x80, 0xB3, 0x55, 0x77, 0x6E, 0xE3, + 0xA1, 0xC8, 0x08, 0x16, 0x41, 0x79, 0xCF, 0x26, + 0xBE, 0x74, 0x53, 0xAA, 0x7A, 0x9E, 0xD7, 0x0A, + 0x51, 0xD9, 0xF0, 0x43, 0x78, 0xC4, 0xA4, 0x9A, + 0xE7, 0x03, 0x28, 0x53, 0xD0, 0x79, 0x24, 0x9A, + 0x97, 0x67, 0x4F, 0xE6, 0x2B, 0x39, 0xD4, 0x65, + 0xAE, 0x88, 0xF4, 0x46, 0x56, 0x1F, 0x2F, 0x7C + }, + { + 0xD3, 0x11, 0x9D, 0x92, 0xBD, 0x06, 0xB4, 0xA9, + 0x0D, 0x31, 0xC3, 0x7A, 0xE0, 0x01, 0x46, 0x88, + 0xBC, 0x8E, 0xA8, 0xF6, 0x40, 0x92, 0x64, 0x86, + 0xFD, 0xD7, 0xBD, 0x8F, 0x2A, 0xC4, 0x16, 0x85, + 0x0B, 0xD3, 0x70, 0x0B, 0xA4, 0x9F, 0x0E, 0x0C, + 0xE6, 0x64, 0xAD, 0xBD, 0x72, 0x4B, 0x1C, 0x45, + 0x8F, 0xE9, 0x4A, 0x31, 0x5D, 0xED, 0x62, 0xE9, + 0x63, 0x17, 0x96, 0x02, 0x0F, 0x80, 0x05, 0xA6 + }, + { + 0x2D, 0xFE, 0x01, 0x07, 0xEE, 0xA9, 0x11, 0xAF, + 0xDB, 0x63, 0x70, 0xA6, 0x03, 0x1C, 0x2E, 0x70, + 0x61, 0xCB, 0xBC, 0xDC, 0x7A, 0x87, 0xB5, 0x1A, + 0x1E, 0x67, 0x83, 0x9F, 0xAA, 0x52, 0x75, 0x96, + 0x47, 0x0C, 0x7A, 0x5F, 0x4D, 0xE2, 0x24, 0x82, + 0x57, 0x7D, 0x93, 0x5B, 0xF5, 0xAD, 0x1C, 0xCB, + 0x35, 0x3D, 0x0D, 0x9D, 0xF1, 0x35, 0x18, 0x24, + 0xB9, 0xD1, 0xE4, 0x50, 0x98, 0xEF, 0x71, 0xD6 + }, + { + 0x85, 0x62, 0xB3, 0x27, 0x7B, 0xE0, 0xB6, 0xE9, + 0x76, 0x40, 0xBD, 0xB0, 0x42, 0xE8, 0x1D, 0x12, + 0x76, 0xDC, 0x78, 0xA8, 0xE8, 0xD9, 0x3C, 0xA2, + 0x88, 0xA6, 0xDE, 0x84, 0x8E, 0x96, 0x65, 0xE8, + 0xD4, 0x81, 0x80, 0xD5, 0xE2, 0x08, 0x30, 0x5F, + 0xAB, 0x98, 0xE5, 0xE3, 0x6E, 0x2F, 0x35, 0x60, + 0x3B, 0x44, 0xB6, 0xBD, 0x36, 0x2A, 0xA3, 0x65, + 0x3A, 0x52, 0xFC, 0x04, 0x10, 0x30, 0x7C, 0x62 + }, + { + 0xBA, 0xD6, 0x0B, 0x42, 0x09, 0x9C, 0xAE, 0xC2, + 0xF5, 0xB5, 0xAB, 0xA3, 0x6D, 0x16, 0xA9, 0xE8, + 0x26, 0x9B, 0x6B, 0x04, 0x11, 0x1F, 0x3D, 0x09, + 0xE8, 0x2F, 0x82, 0x00, 0x25, 0x6C, 0x11, 0x41, + 0x8E, 0x88, 0x29, 0x7E, 0x21, 0x7C, 0xB6, 0xB6, + 0x7A, 0x7D, 0xDE, 0x6E, 0x2C, 0x9C, 0xF4, 0x76, + 0x31, 0x77, 0x32, 0x1E, 0x8B, 0xD3, 0x3A, 0xC2, + 0xA9, 0xC6, 0xF3, 0x90, 0xD1, 0x01, 0xA3, 0x3A + }, + { + 0xA7, 0xC0, 0x1B, 0x54, 0x77, 0x5E, 0x27, 0xE9, + 0x9F, 0x0B, 0xE6, 0x1B, 0xBE, 0x2D, 0xF8, 0x88, + 0x31, 0x01, 0x68, 0x94, 0x8F, 0xCF, 0xC5, 0x2C, + 0x82, 0x2E, 0x95, 0x96, 0x8C, 0x66, 0xFA, 0x01, + 0x78, 0x90, 0x6E, 0xD4, 0xA2, 0xB5, 0xA4, 0x4F, + 0xFF, 0xAE, 0x63, 0x79, 0x0B, 0x6D, 0xB8, 0x3F, + 0xE2, 0xBE, 0x9E, 0xD2, 0x3F, 0x69, 0xC1, 0x90, + 0x38, 0x6E, 0x6B, 0x6C, 0xEA, 0xFD, 0x73, 0x81 + }, + { + 0x82, 0xA0, 0xA6, 0x80, 0x83, 0xB4, 0x2D, 0xE1, + 0x25, 0x65, 0x15, 0xFB, 0x11, 0x9F, 0x21, 0x14, + 0xF3, 0xF7, 0x09, 0x0F, 0x6F, 0x7F, 0x54, 0xFB, + 0xE7, 0x04, 0xF5, 0x28, 0x9A, 0x15, 0xAA, 0x94, + 0x2D, 0x4F, 0x52, 0x8B, 0x8C, 0x82, 0xE5, 0x66, + 0xF6, 0x58, 0x88, 0xB4, 0x09, 0x94, 0xD1, 0x99, + 0x42, 0xF9, 0x80, 0x0F, 0x20, 0x47, 0x6E, 0x20, + 0x10, 0x00, 0x19, 0xCD, 0x08, 0x93, 0x8F, 0xDA + }, + { + 0xF3, 0x38, 0x85, 0x32, 0xD6, 0xD0, 0x44, 0x1D, + 0x03, 0xC2, 0xAD, 0x4B, 0x93, 0x68, 0x17, 0xDC, + 0xE2, 0xE8, 0x80, 0xA8, 0x47, 0xFB, 0xDD, 0x1E, + 0xE2, 0xC8, 0x51, 0xDD, 0x87, 0x93, 0x21, 0x25, + 0x39, 0x1D, 0x72, 0xCD, 0x88, 0xCF, 0x4A, 0x6D, + 0xD9, 0x0B, 0xB7, 0x8E, 0xC9, 0xC1, 0xAD, 0x89, + 0x94, 0x92, 0xA9, 0x0C, 0xAE, 0x5D, 0x80, 0xF9, + 0x31, 0x6E, 0x2B, 0xFC, 0xF7, 0xED, 0xCC, 0xDA + }, + { + 0x06, 0xA6, 0x60, 0xE5, 0x77, 0x6F, 0xF8, 0x3C, + 0x6F, 0xBF, 0xF7, 0x21, 0xAB, 0xD4, 0xF9, 0x24, + 0x04, 0xDD, 0x18, 0xB9, 0xA4, 0x4B, 0x78, 0x2F, + 0xCC, 0x26, 0xF2, 0x3C, 0x4B, 0x96, 0x63, 0xF9, + 0x58, 0xBA, 0x18, 0x69, 0x5D, 0x1A, 0x4E, 0x30, + 0xB8, 0x06, 0x9E, 0x65, 0xFA, 0xBE, 0xC9, 0x7D, + 0x25, 0xE0, 0xD6, 0x4F, 0xB1, 0xB9, 0x1C, 0x91, + 0x9F, 0xA8, 0x3C, 0x99, 0x90, 0x5B, 0xC6, 0xF3 + }, + { + 0x1A, 0xFF, 0x11, 0xAF, 0x7C, 0x20, 0xBB, 0x5B, + 0x9D, 0x3F, 0x46, 0x06, 0x10, 0x75, 0x80, 0xC4, + 0xBB, 0xB4, 0x13, 0xB8, 0x3A, 0x6D, 0x3D, 0xDB, + 0xE1, 0xFC, 0x2D, 0x89, 0x82, 0x46, 0x53, 0x3B, + 0x6B, 0x73, 0x2A, 0xE8, 0xA8, 0xC2, 0x85, 0x3A, + 0x75, 0x42, 0xFF, 0x70, 0x12, 0x30, 0xDB, 0x3C, + 0x45, 0x08, 0xD7, 0x4D, 0x9D, 0xD0, 0xB6, 0x45, + 0x9F, 0x3B, 0x27, 0x68, 0xB8, 0xE6, 0xCB, 0x2D + }, + { + 0xD8, 0xEB, 0xEA, 0x4D, 0xED, 0xD2, 0xDE, 0x50, + 0xAA, 0x93, 0x1D, 0x35, 0xE7, 0x20, 0x08, 0x0F, + 0xDB, 0xAD, 0x05, 0xAB, 0x47, 0x0B, 0x8C, 0xE6, + 0x4F, 0x5D, 0xDF, 0x79, 0xB0, 0x29, 0x2E, 0x75, + 0x2E, 0xB4, 0xF4, 0x94, 0xCB, 0x8E, 0xF5, 0xEE, + 0x72, 0x61, 0xFA, 0xE0, 0x8B, 0xC0, 0x20, 0x32, + 0x4D, 0xBA, 0x78, 0x54, 0x07, 0xC5, 0xE2, 0x5B, + 0x3B, 0x74, 0x00, 0x65, 0xC5, 0xF4, 0x5A, 0x16 + }, + { + 0xF3, 0x7D, 0xC0, 0x17, 0x01, 0xBE, 0xB5, 0xB5, + 0x67, 0xAB, 0x5C, 0x35, 0x0A, 0x20, 0x4B, 0x98, + 0xF1, 0x48, 0xC4, 0x97, 0xE1, 0xE8, 0x60, 0xD8, + 0x42, 0x6C, 0x9A, 0xAD, 0x39, 0x22, 0x09, 0x75, + 0xD1, 0xBB, 0xB9, 0xAB, 0xCD, 0x99, 0x06, 0x93, + 0xF6, 0x44, 0xCB, 0x0E, 0x97, 0xAB, 0xD4, 0x52, + 0x17, 0x4B, 0xAB, 0xB8, 0x1B, 0x6B, 0x52, 0x07, + 0xBC, 0x1F, 0x06, 0x87, 0x70, 0x49, 0x53, 0xC7 + }, + { + 0x29, 0xA1, 0xA3, 0xE1, 0x45, 0x23, 0x02, 0xBF, + 0xAB, 0x19, 0x01, 0x1B, 0x61, 0xB2, 0xD5, 0xA2, + 0xB5, 0xDD, 0xCB, 0x22, 0x59, 0xBC, 0x55, 0x78, + 0x4A, 0xEF, 0x60, 0x55, 0x8E, 0x7F, 0x12, 0xBC, + 0xF5, 0x52, 0xA6, 0x0F, 0xEC, 0xF5, 0x03, 0xFF, + 0xF3, 0x68, 0x82, 0x37, 0xCD, 0xB9, 0x7F, 0x46, + 0x9B, 0x14, 0x62, 0xC7, 0x50, 0xEC, 0x76, 0x9C, + 0x4E, 0x56, 0x34, 0x53, 0x4F, 0x20, 0xDB, 0x8B + }, + { + 0x30, 0x97, 0xC7, 0xE1, 0x9D, 0x4B, 0x9B, 0xDB, + 0x07, 0xAC, 0x88, 0xB5, 0x27, 0x04, 0x45, 0xE4, + 0x35, 0xFE, 0x8A, 0x0B, 0x36, 0x7A, 0x22, 0x92, + 0x9C, 0x16, 0xFE, 0x81, 0xFA, 0x97, 0x3B, 0xA8, + 0x0E, 0x89, 0x07, 0x82, 0x93, 0x14, 0xE1, 0xA5, + 0x9A, 0xC1, 0xE1, 0x69, 0xFC, 0x16, 0x0E, 0x85, + 0xDF, 0xA5, 0x72, 0xD1, 0xE7, 0xA7, 0x7F, 0xCF, + 0x0B, 0xD2, 0x33, 0x7C, 0xFE, 0xA1, 0x34, 0x82 + }, + { + 0xE1, 0x63, 0xDC, 0x24, 0x2E, 0xB2, 0xBE, 0xAA, + 0x28, 0xCA, 0xF9, 0x45, 0xBE, 0x22, 0xD2, 0x48, + 0xA9, 0x98, 0x08, 0xC8, 0xD3, 0x64, 0xB2, 0x38, + 0x2F, 0x1E, 0xD9, 0x48, 0x7D, 0x37, 0x0D, 0xBD, + 0xC7, 0xC8, 0x77, 0x81, 0x63, 0xB1, 0x8F, 0x7E, + 0xD7, 0xD9, 0xB6, 0x83, 0x08, 0x84, 0x73, 0x7C, + 0x6F, 0xE0, 0xBE, 0x26, 0x2B, 0x84, 0xA1, 0xA3, + 0xD7, 0x46, 0x4B, 0x35, 0xAD, 0xFE, 0x8A, 0xB8 + }, + { + 0xFE, 0x0D, 0xAD, 0x29, 0x8E, 0x00, 0x4F, 0x25, + 0xFE, 0xA9, 0x9F, 0xDF, 0x00, 0x30, 0x0E, 0x64, + 0x32, 0xE5, 0x81, 0xEA, 0x59, 0xC9, 0xE4, 0x19, + 0x64, 0x82, 0xA0, 0x7F, 0x45, 0xFF, 0xF9, 0x94, + 0x4F, 0xC6, 0x7E, 0xCB, 0x49, 0xAA, 0x58, 0xC7, + 0xA2, 0x0B, 0x13, 0x6B, 0x7E, 0x13, 0xA0, 0xB0, + 0xD2, 0x87, 0x4B, 0xEE, 0xF0, 0x24, 0x18, 0xE4, + 0x46, 0x5F, 0xCD, 0xED, 0xE9, 0xCD, 0x17, 0x45 + }, + { + 0x59, 0x02, 0x21, 0x6B, 0xED, 0xB9, 0xAF, 0x8A, + 0x97, 0x50, 0xE1, 0xB6, 0xC7, 0x2E, 0xC6, 0x11, + 0xCA, 0xB2, 0x44, 0x7F, 0xEC, 0x36, 0x58, 0xD0, + 0x21, 0x47, 0x9B, 0x5E, 0xAD, 0xAD, 0x5F, 0x64, + 0x0E, 0xE3, 0xFE, 0x98, 0x80, 0x8E, 0xAF, 0x01, + 0xC2, 0x51, 0xFE, 0xE8, 0x51, 0xDF, 0xFF, 0x25, + 0x16, 0xCF, 0x6C, 0x37, 0xDE, 0x39, 0xBB, 0xDC, + 0x71, 0xE8, 0x03, 0x05, 0xA4, 0x1B, 0xF2, 0xA1 + }, + { + 0x06, 0xAA, 0x18, 0x3E, 0x05, 0xE8, 0x07, 0xA8, + 0x2F, 0x0D, 0x1E, 0x64, 0xED, 0x8E, 0x80, 0xA8, + 0x6D, 0xC3, 0x58, 0xAC, 0x45, 0xC9, 0xA7, 0x7C, + 0x96, 0x11, 0x50, 0x2B, 0x3A, 0x33, 0x65, 0x96, + 0x1F, 0x89, 0x5D, 0x91, 0x4E, 0xC7, 0xD7, 0x20, + 0xDB, 0x42, 0x4F, 0xBD, 0xC7, 0xF4, 0x0B, 0x7B, + 0xD8, 0x11, 0xEF, 0xA0, 0x42, 0xA5, 0xCE, 0xCA, + 0xA3, 0x94, 0x1F, 0x5A, 0x1B, 0xB1, 0x8F, 0x7A + }, + { + 0x94, 0x03, 0x09, 0xA3, 0xD6, 0x9D, 0x30, 0xC4, + 0xA6, 0xC1, 0xF7, 0xC4, 0x19, 0xB9, 0xBA, 0x36, + 0x6F, 0x0B, 0x2E, 0xD6, 0x72, 0x4E, 0xAB, 0x19, + 0x75, 0x90, 0x14, 0x55, 0xE6, 0xFA, 0x11, 0x3F, + 0x78, 0xE1, 0xEF, 0x81, 0xB0, 0xDB, 0x2D, 0x64, + 0xD3, 0xCF, 0x0F, 0x8A, 0xAF, 0x49, 0xB2, 0xC0, + 0xF5, 0xF2, 0xA0, 0x0F, 0x17, 0xB6, 0x1D, 0xAC, + 0xD8, 0x98, 0x8E, 0x13, 0x6D, 0x7C, 0x84, 0xA3 + }, + { + 0x93, 0x52, 0x22, 0xE0, 0x93, 0x26, 0x2C, 0x64, + 0x96, 0xAC, 0x4D, 0x99, 0xE1, 0xB9, 0x85, 0x2B, + 0xE6, 0xE7, 0xFE, 0xA6, 0xA6, 0xA5, 0x61, 0x27, + 0x04, 0x7D, 0x78, 0x05, 0x99, 0x14, 0x8B, 0x14, + 0xE4, 0x65, 0x92, 0x2D, 0xB3, 0x98, 0x3B, 0xB2, + 0xEF, 0xB0, 0x0B, 0x4E, 0x6F, 0xAD, 0xC6, 0x45, + 0x53, 0x34, 0x75, 0xB9, 0x83, 0x7C, 0xF8, 0x42, + 0xE6, 0x69, 0x72, 0x1B, 0x6A, 0xD4, 0x31, 0xE2 + }, + { + 0x54, 0x00, 0xF3, 0x23, 0x42, 0xD7, 0xA1, 0xA7, + 0x70, 0x46, 0x85, 0xC8, 0x38, 0x71, 0x3C, 0x04, + 0x34, 0x90, 0x0B, 0xD4, 0x1B, 0xFE, 0x43, 0x61, + 0x3A, 0xCF, 0x21, 0x55, 0x56, 0x7C, 0xA9, 0x02, + 0x45, 0x9F, 0x2C, 0x6B, 0xBB, 0xB7, 0x18, 0x41, + 0x93, 0xEA, 0xE5, 0xE5, 0x8F, 0xEA, 0x7D, 0xF2, + 0x04, 0xB9, 0x79, 0xC2, 0x3C, 0xC4, 0xE1, 0xE2, + 0xE2, 0xB5, 0xA5, 0x48, 0xC8, 0x7A, 0x52, 0xF6 + }, + { + 0xB0, 0xE4, 0x34, 0x78, 0x97, 0x5A, 0x25, 0x53, + 0xEC, 0x00, 0xCD, 0x6E, 0x8F, 0x8B, 0xEA, 0x45, + 0xD3, 0x17, 0x61, 0xD9, 0x6E, 0x1C, 0xC8, 0x23, + 0xF0, 0xEF, 0xEE, 0x6A, 0x84, 0x9F, 0x33, 0xCC, + 0xC2, 0x16, 0x05, 0x7D, 0x84, 0x5F, 0xF6, 0x3E, + 0x2D, 0xF0, 0x51, 0x7E, 0xC3, 0xD8, 0x9C, 0xEF, + 0x8E, 0x2E, 0xB0, 0xF4, 0x7A, 0x25, 0xD5, 0x30, + 0xB3, 0xCF, 0x68, 0x50, 0xBD, 0xFE, 0xFD, 0xAD + }, + { + 0x55, 0xAD, 0x75, 0x0A, 0x1E, 0xB7, 0x34, 0x3C, + 0x6E, 0x0B, 0xAC, 0x5E, 0xFF, 0x01, 0x9C, 0xC4, + 0x83, 0x92, 0x51, 0x9C, 0x27, 0xF7, 0x38, 0x31, + 0xDA, 0xCF, 0xCC, 0x1F, 0x24, 0x75, 0x53, 0xAE, + 0x0D, 0xFA, 0xBB, 0xA3, 0x2A, 0x7D, 0x2F, 0x2E, + 0xF4, 0x5A, 0xB8, 0x99, 0x9A, 0xF9, 0xF1, 0x06, + 0xBB, 0xA3, 0xCC, 0x7C, 0x62, 0x0F, 0xF1, 0x8F, + 0x3D, 0x42, 0xA8, 0x44, 0xFB, 0xAE, 0xA6, 0x4C + }, + { + 0x6A, 0x06, 0x29, 0x1C, 0x34, 0x0E, 0x8A, 0xCE, + 0x1C, 0x51, 0x85, 0x5D, 0x65, 0x68, 0x0E, 0x70, + 0x61, 0x0B, 0x43, 0xD0, 0x0D, 0x09, 0xCC, 0x22, + 0x08, 0x0A, 0x9F, 0xE8, 0xBB, 0x9B, 0xE5, 0xED, + 0xE7, 0x83, 0xA8, 0xB4, 0x6E, 0xB3, 0x6E, 0x80, + 0xA1, 0x0D, 0xA6, 0xD8, 0x0F, 0xFD, 0xEE, 0x48, + 0x8F, 0x5E, 0x6D, 0x4F, 0xC4, 0xF3, 0x07, 0xE8, + 0xBF, 0xE4, 0x7A, 0xFA, 0x90, 0x77, 0x41, 0xB3 + }, + { + 0xAA, 0xF0, 0x9E, 0xF0, 0x98, 0x72, 0x2D, 0x68, + 0x0B, 0x47, 0xD8, 0x76, 0xD4, 0x55, 0x05, 0x47, + 0x3C, 0x67, 0x5B, 0xA8, 0x10, 0xC9, 0x8D, 0x2F, + 0x87, 0xB6, 0xF8, 0xC9, 0xD7, 0xA5, 0x7B, 0x91, + 0x75, 0xE9, 0x9B, 0xAD, 0xF2, 0x48, 0x05, 0xB7, + 0x4D, 0x3A, 0x36, 0x23, 0xF6, 0x97, 0x0B, 0x32, + 0xA3, 0xBF, 0xDC, 0x06, 0x89, 0x8B, 0xD8, 0x36, + 0x23, 0x52, 0x57, 0x2E, 0xBA, 0x4C, 0x26, 0x52 + }, + { + 0x20, 0xCE, 0x35, 0x16, 0xC2, 0x07, 0x42, 0x16, + 0x40, 0x35, 0x5C, 0xF9, 0x6B, 0xDB, 0xFB, 0xFA, + 0x87, 0x15, 0x22, 0x88, 0xAB, 0xD8, 0x3F, 0xC7, + 0x17, 0x44, 0xC3, 0x14, 0x2E, 0x5B, 0xC7, 0xA3, + 0x7D, 0x3E, 0x6E, 0x02, 0xEB, 0x75, 0x4A, 0x72, + 0x81, 0x47, 0xA6, 0xB4, 0x97, 0x81, 0x36, 0x5B, + 0xCE, 0xF0, 0xB6, 0x65, 0x7A, 0x0F, 0xE7, 0xD6, + 0x14, 0x84, 0x9E, 0x6C, 0x28, 0xE9, 0x57, 0xAE + }, + { + 0x65, 0xF2, 0x0B, 0xB7, 0x8B, 0xF4, 0xF4, 0x68, + 0x05, 0x2E, 0xB1, 0x5B, 0xCF, 0x07, 0xBE, 0x87, + 0x79, 0xB0, 0x60, 0xA8, 0x88, 0xA9, 0x1A, 0xBC, + 0x94, 0x37, 0xEC, 0x77, 0x39, 0xAE, 0x69, 0x69, + 0xD7, 0xD9, 0x99, 0x0B, 0x95, 0x8A, 0x23, 0x6A, + 0x85, 0x1E, 0x2E, 0xE1, 0xC1, 0x41, 0x0E, 0xBF, + 0xFF, 0x02, 0x3E, 0x32, 0x90, 0x58, 0x47, 0xFC, + 0x92, 0x5F, 0xBC, 0xE7, 0x97, 0x9A, 0x67, 0x47 + }, + { + 0xFC, 0x63, 0x18, 0x2D, 0xD9, 0xC3, 0x09, 0x74, + 0xE4, 0x48, 0xCA, 0x1C, 0xE6, 0xF5, 0xF3, 0xA6, + 0x5D, 0xD6, 0xC5, 0xF0, 0x7B, 0x64, 0x0C, 0xFA, + 0xEB, 0x42, 0xB5, 0xE7, 0x55, 0x58, 0x3C, 0x3B, + 0xB6, 0x95, 0xBF, 0xBE, 0xB0, 0xA8, 0xE2, 0x22, + 0xF5, 0xF7, 0x88, 0xE9, 0x95, 0x5F, 0x49, 0x13, + 0x76, 0xE2, 0x58, 0x9C, 0x40, 0x95, 0xD1, 0x27, + 0xE6, 0x0F, 0x81, 0x89, 0xFB, 0x9E, 0x1D, 0xA9 + }, + { + 0x84, 0xDF, 0x96, 0xA0, 0xAD, 0x02, 0x0D, 0x77, + 0xC2, 0x17, 0x8A, 0x0B, 0x24, 0xB4, 0xBF, 0xDB, + 0xCE, 0xD4, 0x37, 0x56, 0x4E, 0xA8, 0x87, 0x75, + 0x64, 0xF5, 0x8C, 0x4A, 0x7B, 0x05, 0x79, 0x13, + 0xCB, 0xE9, 0xFF, 0x27, 0xF0, 0xD6, 0xB0, 0xD5, + 0xD6, 0xD5, 0xC4, 0x06, 0x09, 0x4B, 0xBC, 0x15, + 0x74, 0x6B, 0x16, 0x6C, 0x4E, 0xB6, 0xB9, 0xCD, + 0x5B, 0x3E, 0xA4, 0x30, 0x6C, 0x5D, 0xB7, 0x06 + }, + { + 0xD4, 0xBE, 0x98, 0x71, 0x33, 0x08, 0xDB, 0x54, + 0x14, 0xFB, 0xED, 0x58, 0x1A, 0x50, 0x65, 0x37, + 0x88, 0x04, 0xB8, 0x15, 0x50, 0x71, 0xC8, 0x67, + 0x51, 0x26, 0x6F, 0x43, 0xF8, 0x82, 0x61, 0x38, + 0x27, 0xC3, 0x7A, 0x36, 0xE7, 0xA2, 0xEC, 0xB1, + 0x98, 0x98, 0x12, 0x8D, 0x9A, 0x57, 0x87, 0xC7, + 0x22, 0x95, 0xBB, 0x53, 0x45, 0xA0, 0x45, 0xCE, + 0x03, 0x3C, 0xE3, 0xB3, 0xF2, 0x92, 0x32, 0xE5 + }, + { + 0xBC, 0x8A, 0x5B, 0x4C, 0xD8, 0xD0, 0xA6, 0x6A, + 0xF6, 0xFC, 0x66, 0xAC, 0x95, 0x3E, 0x69, 0xA0, + 0x37, 0x73, 0xAD, 0xBF, 0xE9, 0x91, 0xC8, 0xAD, + 0x64, 0xF9, 0xFD, 0x23, 0x61, 0xE9, 0x58, 0x47, + 0xE5, 0x38, 0xFC, 0xD1, 0x8C, 0x77, 0xB7, 0x72, + 0xCC, 0x6A, 0x06, 0xC6, 0x2F, 0x82, 0xDD, 0xE9, + 0xC6, 0xE0, 0x75, 0x61, 0x5B, 0xC0, 0x21, 0x7B, + 0xE9, 0x76, 0xCD, 0x94, 0x4E, 0xD7, 0xFB, 0x6C + }, + { + 0x5D, 0x0E, 0xFE, 0xC3, 0x28, 0xDF, 0xCB, 0x15, + 0xA6, 0x7C, 0xE5, 0x42, 0x18, 0x1D, 0x3E, 0xD5, + 0xF4, 0xA9, 0xAD, 0x47, 0x46, 0xCA, 0x31, 0x7E, + 0x85, 0xD3, 0xE1, 0xFC, 0x89, 0xEC, 0x78, 0x4E, + 0x4D, 0x75, 0x78, 0xDD, 0x2C, 0x4A, 0xC0, 0xE3, + 0x5D, 0x86, 0x72, 0x4E, 0x9B, 0xF5, 0x09, 0xFC, + 0x70, 0x59, 0xEF, 0x06, 0x0C, 0x3B, 0xC4, 0x2E, + 0x43, 0x17, 0x9E, 0x4B, 0x25, 0x62, 0xAA, 0x98 + }, + { + 0x8A, 0x2A, 0x2E, 0x1D, 0x84, 0x41, 0xBE, 0xA9, + 0x28, 0x05, 0xA4, 0x99, 0x74, 0x1C, 0x6D, 0xF0, + 0x2E, 0xAC, 0xDC, 0x09, 0xFE, 0xE7, 0x01, 0x56, + 0x01, 0x83, 0xAB, 0xB6, 0x4F, 0x92, 0x9A, 0x22, + 0xA0, 0xC5, 0x26, 0xAC, 0xC6, 0x82, 0xC0, 0x6B, + 0x1B, 0x00, 0x3D, 0xBF, 0xBD, 0x7F, 0x84, 0x73, + 0x3D, 0xDA, 0x9D, 0x65, 0xF5, 0x63, 0x86, 0x2A, + 0x05, 0x56, 0x0C, 0x5B, 0x6D, 0x4D, 0x7D, 0x5A + }, + { + 0xDD, 0xE7, 0x88, 0xEA, 0xAC, 0x12, 0x74, 0x33, + 0xCA, 0xAC, 0x6C, 0x14, 0xF1, 0x78, 0xC3, 0x96, + 0x21, 0x67, 0xA8, 0x8F, 0x16, 0xA1, 0x52, 0xC7, + 0xEF, 0xC8, 0x12, 0x1D, 0xBC, 0x8B, 0x70, 0xCA, + 0x35, 0x9D, 0x73, 0xC5, 0x99, 0xFE, 0x6C, 0xEE, + 0xA0, 0xFF, 0x65, 0xD7, 0x05, 0x15, 0xDD, 0x91, + 0x1F, 0xC4, 0x0B, 0x9F, 0x52, 0x3A, 0xA3, 0x42, + 0xA0, 0x62, 0x9C, 0x4F, 0x7E, 0xBE, 0x17, 0xE8 + }, + { + 0x0A, 0xF6, 0xDD, 0x67, 0x90, 0xC7, 0xDD, 0xAE, + 0xA7, 0x51, 0xA6, 0x7C, 0x6B, 0xB6, 0xC9, 0x0C, + 0x9F, 0x13, 0x37, 0xDB, 0xD6, 0x42, 0xE3, 0x93, + 0x86, 0x8B, 0xF2, 0x59, 0x61, 0x35, 0x16, 0x63, + 0x11, 0xA5, 0xA2, 0x46, 0x9D, 0x3A, 0xED, 0x8E, + 0x2A, 0x2E, 0x5D, 0xF5, 0x51, 0x9E, 0x56, 0x17, + 0xCF, 0x57, 0xB2, 0x90, 0x7B, 0x8F, 0xC7, 0x0E, + 0x6B, 0xAB, 0xE7, 0x9A, 0x06, 0x30, 0x64, 0x13 + }, + { + 0xC6, 0x63, 0x3A, 0x98, 0x57, 0x7B, 0x3B, 0xE9, + 0xAE, 0x81, 0xC1, 0xEA, 0x6B, 0x2E, 0xC1, 0x03, + 0xB6, 0x62, 0x07, 0x22, 0x83, 0x97, 0x23, 0xEA, + 0x34, 0xFA, 0xBF, 0x55, 0x33, 0x97, 0xAA, 0x57, + 0x08, 0x81, 0x4E, 0xCA, 0x2A, 0xC5, 0x0E, 0x00, + 0x1F, 0xCD, 0x81, 0xEB, 0x7C, 0x8A, 0x5D, 0xB2, + 0xD3, 0xC4, 0xD6, 0x1A, 0xE6, 0x8D, 0x4A, 0xA2, + 0x62, 0x2D, 0x2F, 0x4C, 0x9D, 0xE8, 0x35, 0x74 + }, + { + 0x92, 0xA6, 0x9E, 0xE9, 0x83, 0x70, 0xEB, 0x95, + 0x8E, 0x21, 0x1C, 0x69, 0xE7, 0xEC, 0x72, 0x4E, + 0xEF, 0xAE, 0x49, 0x3D, 0x86, 0x8D, 0x82, 0xEE, + 0x76, 0x1E, 0x62, 0x47, 0x45, 0x82, 0x3B, 0x6C, + 0x2E, 0xE9, 0xF7, 0x3E, 0xCC, 0x30, 0xFA, 0x73, + 0x04, 0xEC, 0x84, 0xAE, 0x20, 0xA5, 0xE5, 0x89, + 0x2E, 0x6E, 0x8E, 0xF2, 0x01, 0x8B, 0x6F, 0x15, + 0xB8, 0xBD, 0xB4, 0x85, 0x3F, 0xDF, 0x26, 0x71 + }, + { + 0x74, 0x75, 0x89, 0xBD, 0xF0, 0x4B, 0xAF, 0xC4, + 0xDC, 0x08, 0x4E, 0xEC, 0x91, 0xE4, 0xFE, 0x99, + 0x4E, 0x9A, 0xBF, 0x1E, 0xC8, 0xB6, 0x18, 0x9A, + 0x33, 0x60, 0xDA, 0xCC, 0x1E, 0xDA, 0x4B, 0x16, + 0x79, 0xB0, 0x92, 0x05, 0xA2, 0x60, 0x23, 0xC4, + 0x40, 0x94, 0x32, 0xC0, 0x6A, 0x51, 0xC5, 0xF1, + 0x63, 0x8B, 0x17, 0x3F, 0x1C, 0x5E, 0x1F, 0x6D, + 0x05, 0x66, 0x74, 0x00, 0x8C, 0xF0, 0x72, 0x9A + }, + { + 0x16, 0x79, 0xB9, 0x27, 0x74, 0xBC, 0x45, 0x68, + 0x4F, 0x85, 0xD4, 0x86, 0x3B, 0x88, 0x97, 0xED, + 0x74, 0x42, 0x1A, 0xF0, 0xEA, 0xE7, 0x82, 0xBB, + 0xC4, 0x7C, 0xEB, 0xAD, 0x39, 0x3F, 0xB2, 0xD7, + 0x3F, 0x49, 0x1D, 0x25, 0x35, 0xD2, 0x48, 0x8D, + 0x30, 0x7B, 0x95, 0xA8, 0x19, 0xBA, 0xA6, 0x5B, + 0x3E, 0x8D, 0xC8, 0x8C, 0x4D, 0xCD, 0x76, 0xAA, + 0xA9, 0xF6, 0xD0, 0xDC, 0x0E, 0x34, 0x84, 0x60 + }, + { + 0x1A, 0x78, 0xF5, 0x12, 0x3E, 0x45, 0xCB, 0x28, + 0x50, 0xA5, 0x24, 0x9B, 0x7A, 0x32, 0xF5, 0xD7, + 0x61, 0xD4, 0xF6, 0x18, 0x43, 0x04, 0x34, 0x58, + 0x84, 0xA9, 0x92, 0x1A, 0x3C, 0xC4, 0x31, 0xE0, + 0xF4, 0x07, 0x3D, 0x8D, 0xA3, 0xEA, 0x18, 0x57, + 0x9C, 0x4C, 0x9F, 0xC0, 0xD8, 0x52, 0xB7, 0x6E, + 0xA4, 0x45, 0x26, 0xB4, 0x24, 0x69, 0x67, 0x86, + 0xEC, 0x06, 0x1B, 0x92, 0x7D, 0x09, 0xCE, 0x82 + }, + { + 0xF4, 0x5E, 0x96, 0x55, 0x1E, 0x28, 0xEF, 0x8A, + 0x5C, 0x85, 0xBC, 0x9D, 0x0B, 0x7C, 0xDF, 0x14, + 0x29, 0x58, 0xC8, 0x92, 0xB6, 0x73, 0x0E, 0x2A, + 0xD5, 0xF2, 0x67, 0x37, 0xC8, 0x1B, 0x20, 0x8D, + 0x0B, 0x32, 0xCB, 0x82, 0xCC, 0x79, 0xE6, 0x60, + 0xFD, 0xC8, 0x9B, 0x49, 0x6C, 0xE4, 0xE4, 0x1E, + 0x73, 0xBD, 0x96, 0x0B, 0x94, 0xE2, 0x62, 0x0F, + 0x05, 0xE4, 0x90, 0xFE, 0x4F, 0x00, 0xA9, 0x61 + }, + { + 0xEA, 0xC4, 0x6C, 0x8D, 0x8D, 0xD2, 0x08, 0xD1, + 0xCD, 0x24, 0x12, 0x1B, 0x9F, 0x19, 0xCE, 0xB9, + 0xC7, 0xFE, 0x02, 0x7C, 0xF5, 0xFD, 0x79, 0xA7, + 0x3C, 0x51, 0xB7, 0x0F, 0xC3, 0xFB, 0x30, 0xCF, + 0xAB, 0xDE, 0x29, 0x30, 0x7B, 0xDD, 0xA5, 0x77, + 0x6A, 0x99, 0xED, 0x65, 0x5D, 0xA4, 0x33, 0x52, + 0x6A, 0x49, 0xEC, 0xE0, 0x7A, 0x8C, 0x70, 0x7D, + 0x8D, 0xD1, 0x7F, 0xDA, 0xD8, 0xFF, 0xE1, 0xCC + }, + { + 0x4B, 0xB3, 0xB5, 0x8E, 0x4B, 0xC0, 0x74, 0x11, + 0xD6, 0x14, 0xF5, 0x55, 0x36, 0xB8, 0x40, 0x4C, + 0x7A, 0x3D, 0x88, 0x0A, 0xF7, 0x97, 0xB8, 0xBC, + 0x82, 0xE2, 0xCE, 0xFF, 0x50, 0x1E, 0x25, 0xC8, + 0x08, 0xB3, 0x17, 0x75, 0xF5, 0x8F, 0x3E, 0x04, + 0x64, 0xB4, 0xD1, 0xF4, 0x63, 0xAD, 0x1D, 0xC9, + 0x03, 0x12, 0x20, 0x1B, 0x66, 0x2A, 0x7E, 0x03, + 0x51, 0x3C, 0x6E, 0xF8, 0xAD, 0xD0, 0xDC, 0xF0 + }, + { + 0x84, 0xF0, 0xF4, 0x50, 0xFF, 0x51, 0x05, 0xF9, + 0xAA, 0x4E, 0xE9, 0xC8, 0xF9, 0xCA, 0x68, 0xD0, + 0xDD, 0x13, 0x76, 0x23, 0xB8, 0x43, 0xBA, 0xEC, + 0xFE, 0xCC, 0x04, 0xB1, 0xEC, 0xF5, 0x98, 0xF9, + 0xC1, 0xD9, 0xF1, 0x0A, 0xF9, 0x8B, 0x47, 0x07, + 0xC0, 0x89, 0x99, 0x74, 0x15, 0x77, 0x2E, 0x87, + 0x06, 0x5A, 0x89, 0x9A, 0x2F, 0x76, 0x92, 0x8D, + 0xA5, 0x39, 0x55, 0xEC, 0x22, 0x6A, 0x7C, 0xCC + }, + { + 0x55, 0x26, 0x58, 0x65, 0x90, 0x3F, 0x18, 0x0F, + 0x51, 0x3B, 0xBB, 0x09, 0xDD, 0x94, 0xEA, 0xDE, + 0xEA, 0xFB, 0x43, 0x8E, 0xBF, 0xBB, 0x56, 0xE2, + 0x5E, 0xAA, 0x3D, 0x11, 0xFB, 0x00, 0x25, 0x1B, + 0x5E, 0xFC, 0x45, 0xA8, 0x8D, 0x30, 0x01, 0x1A, + 0x58, 0xCE, 0xF0, 0xD1, 0xAA, 0xED, 0x45, 0x6D, + 0x01, 0x0B, 0xA4, 0xCC, 0x21, 0xBB, 0xCE, 0xF3, + 0x80, 0xC3, 0x64, 0x8E, 0x2C, 0x5B, 0xC4, 0x89 + }, + { + 0x93, 0xFA, 0xB7, 0x24, 0xF7, 0x34, 0x0F, 0xFB, + 0x67, 0x66, 0x0C, 0x26, 0x5E, 0x94, 0xE9, 0x09, + 0x0C, 0xD5, 0x71, 0x98, 0x2B, 0x9D, 0x70, 0xF9, + 0x9B, 0xDC, 0x9A, 0x0B, 0x16, 0x2C, 0x1D, 0x55, + 0x30, 0x40, 0x9B, 0xF5, 0xAB, 0x0B, 0x56, 0xCE, + 0x5F, 0x03, 0xF3, 0xE7, 0x52, 0x79, 0x99, 0x32, + 0x7F, 0x90, 0xD8, 0x86, 0xB5, 0xC3, 0x7C, 0x9A, + 0xCE, 0x25, 0x32, 0xD8, 0x68, 0x52, 0xB2, 0x66 + }, + { + 0x33, 0x0B, 0x8D, 0xAD, 0x89, 0xC8, 0xFB, 0x62, + 0x4E, 0x54, 0x99, 0x29, 0x2C, 0xBB, 0xEA, 0x46, + 0x2B, 0x83, 0xA8, 0x29, 0x02, 0x20, 0x91, 0x87, + 0x07, 0x1E, 0xCE, 0x66, 0x15, 0xB6, 0x54, 0x58, + 0xBF, 0x84, 0x15, 0xD3, 0x5A, 0xF8, 0x25, 0x40, + 0x9F, 0x2B, 0x2C, 0x10, 0x16, 0x5B, 0x76, 0xDE, + 0x0E, 0x35, 0x9C, 0x1B, 0xCC, 0x00, 0x1D, 0xC1, + 0xC6, 0x7B, 0x57, 0x3C, 0x7D, 0xBC, 0x25, 0x03 + }, + { + 0xA1, 0xDA, 0x39, 0x12, 0xC7, 0xAA, 0x64, 0x32, + 0x77, 0x42, 0x84, 0xE1, 0x71, 0xF0, 0x47, 0xB6, + 0x1E, 0x0E, 0x01, 0xCE, 0xD9, 0x62, 0x2C, 0x4D, + 0x99, 0x30, 0x5B, 0xDE, 0x9B, 0xE7, 0x00, 0x5C, + 0x3B, 0xBE, 0x12, 0x2F, 0x2A, 0x8B, 0xCE, 0x3B, + 0xFC, 0x8B, 0xFD, 0xEE, 0xEE, 0x83, 0xA6, 0x9E, + 0x47, 0x73, 0xB8, 0x25, 0xBE, 0xC6, 0x85, 0xCC, + 0x69, 0x6B, 0xD5, 0x14, 0xC3, 0x15, 0x60, 0x91 + }, + { + 0xFB, 0xC5, 0x47, 0x59, 0x89, 0xE0, 0x7E, 0x71, + 0xC4, 0xA8, 0x7B, 0xB5, 0xB8, 0xCE, 0xBD, 0x5A, + 0xF5, 0x4A, 0xE6, 0xE6, 0x51, 0x2F, 0xFA, 0xE6, + 0xBD, 0x7F, 0x97, 0x79, 0x17, 0xA6, 0x9B, 0xCC, + 0x5B, 0xB3, 0x35, 0x9B, 0x48, 0x17, 0xED, 0x3F, + 0xF8, 0xD1, 0xC6, 0x65, 0xE6, 0x00, 0x24, 0x61, + 0x97, 0x0C, 0xCC, 0xF8, 0xDB, 0x72, 0x82, 0xFF, + 0xDC, 0xDB, 0xB6, 0xE2, 0xA7, 0x63, 0x5F, 0x87 + }, + { + 0x28, 0xBD, 0x33, 0x1D, 0xAF, 0x4F, 0x4F, 0xAD, + 0x17, 0x7F, 0xFC, 0xD2, 0xA5, 0x59, 0x30, 0xF0, + 0xDF, 0xBA, 0xB4, 0x27, 0x42, 0xE9, 0x91, 0x6B, + 0xC2, 0xB5, 0xE7, 0x55, 0x7E, 0xB3, 0x66, 0xE3, + 0xCD, 0x35, 0x80, 0x60, 0xE0, 0xDD, 0x66, 0x6A, + 0x35, 0x31, 0x28, 0x0E, 0x61, 0x0E, 0xD6, 0x06, + 0x09, 0x8A, 0xDF, 0x5F, 0xE3, 0x4C, 0xEC, 0x6A, + 0x4C, 0x7C, 0x74, 0x4D, 0xBE, 0xD1, 0x04, 0xDC + }, + { + 0x6D, 0x29, 0xF7, 0x8D, 0x75, 0x15, 0x72, 0x08, + 0x5A, 0x86, 0x3F, 0x4E, 0xED, 0x98, 0xE8, 0x30, + 0xE2, 0x3C, 0xAA, 0x1F, 0xCB, 0xB8, 0x4E, 0xFA, + 0x5C, 0x39, 0xA5, 0xCE, 0xF0, 0xE5, 0xDD, 0xBA, + 0x94, 0xB1, 0x43, 0x26, 0x1D, 0x16, 0xB7, 0x9C, + 0xBB, 0x52, 0x9F, 0x6A, 0x0C, 0x99, 0x07, 0xCE, + 0xB3, 0xCB, 0xA7, 0x93, 0xA9, 0x82, 0xC8, 0x7F, + 0xEE, 0x2A, 0x9D, 0xAD, 0x06, 0xDD, 0x2B, 0xC9 + }, + { + 0x0B, 0x9E, 0x79, 0x65, 0x78, 0xA9, 0x01, 0xCF, + 0x5F, 0x8A, 0x8E, 0x18, 0x41, 0x2A, 0xDC, 0x91, + 0xA2, 0x29, 0x05, 0xF2, 0x15, 0xF6, 0x1F, 0x61, + 0x0C, 0xDD, 0x10, 0xEC, 0x87, 0x57, 0xD5, 0x3A, + 0xD2, 0xAD, 0x3A, 0x06, 0x0D, 0xCB, 0x26, 0xB3, + 0x8C, 0xC8, 0xAF, 0xFF, 0x47, 0xE4, 0x63, 0x0B, + 0x25, 0x2D, 0xE9, 0x1C, 0x17, 0xA8, 0x98, 0x03, + 0x55, 0x4A, 0x66, 0x03, 0xC7, 0xA4, 0x30, 0xF6 + }, + { + 0xA1, 0x0D, 0x28, 0xDC, 0x7B, 0x5C, 0xF9, 0xA2, + 0xF5, 0x0C, 0x61, 0x0A, 0x2F, 0xE8, 0x54, 0xA7, + 0x4E, 0x02, 0x59, 0x6C, 0xB0, 0x80, 0x90, 0xC7, + 0x17, 0x08, 0xC2, 0xE7, 0x8A, 0xD5, 0x7B, 0xCC, + 0x22, 0xBB, 0xE3, 0x22, 0x0F, 0x84, 0x42, 0xC3, + 0x32, 0xC4, 0x32, 0xB1, 0xA2, 0x3B, 0x4A, 0x33, + 0xFD, 0x13, 0x36, 0x42, 0x4F, 0x92, 0x44, 0xC6, + 0xFC, 0xEA, 0x59, 0x45, 0x58, 0x66, 0x41, 0x6C + }, + { + 0x0A, 0x61, 0x12, 0xDA, 0xE4, 0xB2, 0x55, 0x0A, + 0xE1, 0x1B, 0xD1, 0xB3, 0x24, 0x1C, 0x64, 0x61, + 0x2E, 0xB0, 0x57, 0xAE, 0x53, 0xC0, 0x7C, 0xAB, + 0x72, 0x5C, 0x40, 0x22, 0xCF, 0xAC, 0x19, 0x06, + 0x09, 0x22, 0x5C, 0xCE, 0xD7, 0x4F, 0x85, 0xFF, + 0x11, 0x23, 0x4F, 0x44, 0x64, 0xA0, 0x6C, 0x34, + 0xA5, 0xD6, 0x6A, 0x6C, 0x11, 0x50, 0xAD, 0xBE, + 0x62, 0x68, 0x65, 0x76, 0x32, 0x55, 0x09, 0x2C + }, + { + 0x40, 0x7B, 0x66, 0xCF, 0x3B, 0x44, 0x4E, 0x4A, + 0xAB, 0x68, 0x10, 0x73, 0xF3, 0x16, 0xF7, 0xB6, + 0xEB, 0xD9, 0x86, 0xEA, 0x30, 0x8B, 0x17, 0x95, + 0x4D, 0xBD, 0x42, 0x0C, 0xD2, 0x0F, 0x3C, 0x6A, + 0xBE, 0x4D, 0x81, 0x11, 0x72, 0xBB, 0xEE, 0xB2, + 0x86, 0x09, 0x08, 0x2C, 0xA6, 0xD2, 0x12, 0x17, + 0x98, 0xF5, 0x16, 0x15, 0xD5, 0x8E, 0xAB, 0x8D, + 0xFA, 0xC6, 0x65, 0x6A, 0x6B, 0xCC, 0x36, 0x75 + }, + { + 0xEB, 0x66, 0x0D, 0x06, 0xC1, 0xBF, 0xFB, 0x15, + 0x67, 0x5B, 0x60, 0x58, 0x60, 0x7D, 0x93, 0xB6, + 0xFC, 0x93, 0x63, 0x9B, 0xF3, 0x6B, 0x37, 0x61, + 0xAB, 0x29, 0x36, 0x94, 0x2C, 0x1B, 0xEA, 0xCC, + 0x9D, 0x09, 0x49, 0x80, 0xF0, 0x1D, 0xE1, 0xA3, + 0x61, 0xB6, 0x9C, 0x5A, 0xFD, 0x95, 0x4F, 0x7C, + 0x1A, 0x8E, 0xDF, 0xFE, 0xFE, 0x63, 0x35, 0x3F, + 0x3E, 0x2C, 0x23, 0x3D, 0x3E, 0x2E, 0x0E, 0xAC + }, + { + 0xA4, 0xF8, 0xC0, 0xF6, 0x44, 0x3B, 0xFD, 0x4B, + 0xC5, 0x1B, 0xC4, 0x1C, 0x1B, 0x51, 0x3F, 0x03, + 0x2D, 0x91, 0x94, 0x85, 0x05, 0x48, 0x14, 0xC5, + 0x16, 0xC2, 0xFF, 0x6A, 0x3A, 0x68, 0x28, 0x80, + 0x99, 0x1C, 0xCE, 0x6D, 0xBF, 0x37, 0xAC, 0xD5, + 0x32, 0x95, 0x48, 0x82, 0x20, 0xB0, 0x2C, 0x36, + 0x88, 0xD3, 0xA4, 0x58, 0xB7, 0x43, 0xAD, 0xB5, + 0xA1, 0xEE, 0x8D, 0x1D, 0x47, 0x45, 0xE8, 0xF9 + }, + { + 0xC1, 0x2D, 0xF6, 0x6B, 0xD6, 0x5D, 0x4D, 0x28, + 0x37, 0xD9, 0x06, 0xB6, 0x71, 0x7C, 0xD6, 0x5D, + 0xF4, 0x7C, 0xF7, 0xA2, 0xF3, 0x18, 0x6B, 0xD7, + 0x96, 0xC9, 0xAD, 0x03, 0x59, 0x65, 0x4F, 0x2E, + 0xE7, 0x68, 0x71, 0xE4, 0x7E, 0x20, 0x29, 0x3C, + 0x4C, 0x9C, 0x61, 0x6B, 0x2F, 0xFB, 0x55, 0xD2, + 0xC3, 0x33, 0xBE, 0x0F, 0x4F, 0x73, 0x11, 0xA6, + 0x67, 0x1F, 0xD3, 0x52, 0x44, 0x2B, 0xEC, 0x0F + }, + { + 0xA5, 0x60, 0x57, 0xA0, 0x11, 0xFB, 0xC7, 0xDC, + 0x5B, 0x4C, 0x6C, 0x47, 0x33, 0xFE, 0x4D, 0x54, + 0x0D, 0xCB, 0x6B, 0xFC, 0xFF, 0xF4, 0xC2, 0x88, + 0x73, 0x60, 0x49, 0xA4, 0x9B, 0x72, 0x3B, 0xAE, + 0x83, 0xAE, 0xAD, 0x0C, 0x83, 0xE9, 0x1A, 0x9B, + 0x40, 0xD6, 0x23, 0x42, 0x2A, 0x2F, 0x7F, 0xB9, + 0xD1, 0xAC, 0xB2, 0x69, 0x96, 0x09, 0x83, 0xBF, + 0xFA, 0x89, 0x4D, 0x1F, 0x76, 0x64, 0xB6, 0xFD + }, + { + 0xAD, 0x77, 0xC8, 0xA1, 0x96, 0x78, 0x25, 0x97, + 0x46, 0x9B, 0x57, 0xE0, 0x5B, 0xD3, 0x4E, 0xEE, + 0x15, 0x03, 0x38, 0x11, 0x6A, 0x44, 0xCC, 0x7A, + 0x6D, 0xBC, 0x4B, 0xBA, 0x6F, 0x3F, 0xB2, 0x43, + 0x1D, 0x79, 0x21, 0xE5, 0x0C, 0x62, 0xF6, 0x68, + 0xA8, 0xD8, 0x1C, 0xDE, 0xC3, 0x0C, 0xE5, 0xF0, + 0xA6, 0x2A, 0xEF, 0x4A, 0xE9, 0x55, 0xCF, 0x43, + 0x25, 0xB5, 0x42, 0x8A, 0x59, 0xC2, 0x96, 0xD0 + }, + { + 0x76, 0x0D, 0x15, 0xC2, 0xCF, 0xF2, 0x0B, 0x7E, + 0x26, 0x0B, 0xC3, 0xEA, 0x70, 0x47, 0xFC, 0x1A, + 0x5B, 0x81, 0x51, 0x66, 0x46, 0x69, 0x15, 0x8C, + 0xD4, 0xB3, 0xA5, 0x00, 0x66, 0x5D, 0xC9, 0xEB, + 0x5E, 0x49, 0xEF, 0x8B, 0x83, 0xE7, 0xF4, 0x9C, + 0xAD, 0xD8, 0xCB, 0x7C, 0xC3, 0xFD, 0x29, 0x46, + 0xF2, 0xCD, 0xD2, 0xDD, 0x9F, 0x7E, 0xB9, 0x30, + 0xB4, 0x06, 0x4C, 0x49, 0x23, 0xE1, 0xC2, 0xDE + }, + { + 0x9C, 0x9E, 0xAD, 0x95, 0xDF, 0xE9, 0x85, 0xAC, + 0x22, 0xCA, 0x9A, 0xC2, 0x24, 0x05, 0x6D, 0xBE, + 0x5B, 0xD6, 0x34, 0x64, 0x96, 0xA5, 0x9E, 0xA6, + 0xEF, 0x41, 0x22, 0xAE, 0x1D, 0xA3, 0xE9, 0xB3, + 0xED, 0x5C, 0x03, 0x4F, 0xCB, 0x52, 0xAD, 0x7F, + 0x0C, 0x40, 0xDC, 0x1D, 0xA6, 0x7A, 0x7D, 0x95, + 0xED, 0x61, 0xDA, 0xBE, 0xD5, 0x93, 0x92, 0xA6, + 0xE3, 0x63, 0x91, 0xA1, 0x11, 0x85, 0xE6, 0x2F + }, + { + 0x1B, 0xE4, 0x89, 0x8D, 0x32, 0xEF, 0x92, 0xF0, + 0x4A, 0x01, 0x00, 0x0D, 0x93, 0x00, 0xE4, 0x13, + 0x08, 0x92, 0xD8, 0x98, 0x14, 0x89, 0x7F, 0xC0, + 0xA4, 0x35, 0xD3, 0xFD, 0xF0, 0xC1, 0xF8, 0x51, + 0xD2, 0xCD, 0xDD, 0x19, 0x52, 0xE5, 0xF5, 0x34, + 0xE3, 0xDD, 0xE9, 0x95, 0x47, 0xF7, 0x13, 0x2E, + 0xD1, 0x0A, 0xE1, 0x9B, 0x14, 0x00, 0x70, 0x16, + 0x7A, 0x73, 0x13, 0x6D, 0x46, 0x83, 0xFD, 0x2F + }, + { + 0x8D, 0xDD, 0x24, 0xCD, 0xE3, 0x92, 0xFC, 0xD3, + 0xDF, 0x21, 0x2B, 0x4C, 0xF0, 0x34, 0x30, 0xF7, + 0x2E, 0xF7, 0xEC, 0x70, 0x08, 0xC4, 0xF3, 0x9C, + 0x4A, 0xB7, 0x90, 0x7F, 0xCC, 0xE8, 0xD4, 0xFB, + 0xCA, 0xAF, 0x40, 0xD1, 0x3C, 0xF5, 0x0C, 0x3C, + 0x11, 0x97, 0x8F, 0x3C, 0xA7, 0x6D, 0x81, 0x5A, + 0x8D, 0x1A, 0x38, 0x19, 0xF5, 0x58, 0xBB, 0x49, + 0xE3, 0x88, 0x61, 0x3D, 0x2E, 0x3A, 0xA3, 0xC5 + }, + { + 0xB2, 0x1C, 0x93, 0x44, 0xA5, 0x0E, 0xAE, 0xF5, + 0x5F, 0x68, 0x09, 0x62, 0xD2, 0xE8, 0xDA, 0xBF, + 0x45, 0xFC, 0xFA, 0x36, 0x05, 0x3A, 0x33, 0x43, + 0xF0, 0xDF, 0x5E, 0xAF, 0x6B, 0x57, 0xB4, 0x66, + 0x56, 0xFB, 0x3C, 0xDE, 0x90, 0x69, 0x67, 0xAC, + 0xAD, 0x79, 0xBA, 0x9D, 0x45, 0xD6, 0xE0, 0x78, + 0xF2, 0xDD, 0x1E, 0x1C, 0x36, 0x4B, 0xB0, 0x32, + 0x4C, 0x17, 0x8C, 0x51, 0x4F, 0xC9, 0x54, 0xB1 + }, + { + 0xF5, 0xD7, 0x1E, 0x3F, 0x73, 0xDF, 0x90, 0xF3, + 0x3C, 0xA7, 0x84, 0x1A, 0x78, 0x28, 0xDF, 0x61, + 0x53, 0xE7, 0x6B, 0x17, 0x19, 0x7E, 0xB8, 0xF9, + 0xD9, 0x90, 0xAC, 0xDE, 0xB9, 0x49, 0x02, 0x39, + 0x4A, 0xBB, 0x2E, 0x7B, 0xC4, 0xEF, 0x9A, 0x52, + 0x71, 0x81, 0x52, 0xF4, 0x03, 0x4D, 0xA3, 0xF3, + 0x82, 0x86, 0xF8, 0xDF, 0x64, 0x0D, 0x3A, 0x07, + 0xFA, 0xC1, 0x0A, 0x56, 0xA2, 0x46, 0xEF, 0x6C + }, + { + 0x47, 0x6D, 0x20, 0xAF, 0xFC, 0xCD, 0xEE, 0x06, + 0x20, 0x36, 0x72, 0xF7, 0x70, 0x40, 0x38, 0xEF, + 0x74, 0x06, 0x4E, 0x84, 0x8A, 0xBF, 0xED, 0x84, + 0x3A, 0x93, 0x32, 0x7A, 0x6A, 0x9C, 0x35, 0xDB, + 0x5D, 0x7E, 0x0D, 0x90, 0x5F, 0xF5, 0x80, 0xE0, + 0x83, 0x11, 0xD6, 0x10, 0x49, 0x20, 0x3E, 0x8D, + 0xF7, 0x0A, 0xEC, 0xE2, 0xE5, 0x59, 0x3B, 0x85, + 0x67, 0x3A, 0xCA, 0x7E, 0x35, 0x4B, 0xE5, 0xEF + }, + { + 0x81, 0x41, 0xE7, 0x2A, 0xF5, 0x23, 0x80, 0xAE, + 0x91, 0x4F, 0x73, 0xC9, 0x42, 0x6E, 0x22, 0x9C, + 0x46, 0x80, 0x5D, 0xFB, 0x29, 0xA9, 0x67, 0x47, + 0x0B, 0xCF, 0x7F, 0xA6, 0x67, 0xE8, 0x0E, 0xD0, + 0xBF, 0x96, 0xBF, 0x08, 0x5B, 0x73, 0x00, 0x33, + 0x6A, 0xB7, 0x73, 0x7E, 0x06, 0xCF, 0x1A, 0x33, + 0x5F, 0xA9, 0xBA, 0x31, 0x8D, 0xA8, 0xF4, 0xA9, + 0x21, 0x3C, 0x8F, 0x35, 0xF5, 0x0B, 0x75, 0xF1 + }, + { + 0xE2, 0xBE, 0xDA, 0x12, 0xF3, 0x8E, 0xBF, 0xD7, + 0x40, 0x93, 0xA1, 0x74, 0x3F, 0x1A, 0x9B, 0x51, + 0xBA, 0x99, 0x08, 0xC7, 0xC5, 0x5A, 0x89, 0xCA, + 0x6D, 0x2A, 0xC2, 0x6F, 0xD0, 0xBE, 0xDA, 0x50, + 0x4A, 0x50, 0xBA, 0xA4, 0x40, 0x4C, 0x17, 0x5F, + 0x26, 0x56, 0xA9, 0x2F, 0x72, 0xA3, 0x25, 0x41, + 0xA6, 0x92, 0x91, 0x9E, 0xF3, 0xF2, 0x6E, 0xE9, + 0xB3, 0x9B, 0x60, 0x3D, 0x66, 0xB6, 0x96, 0xF7 + }, + { + 0x39, 0x3E, 0x56, 0xFB, 0x9C, 0xF5, 0xD0, 0x15, + 0x28, 0x2E, 0xF5, 0x76, 0x8C, 0x2F, 0xD8, 0xB8, + 0x94, 0x8A, 0x87, 0x13, 0xF5, 0x22, 0x60, 0x5F, + 0x50, 0x4C, 0xDE, 0x12, 0x5B, 0xFD, 0x1D, 0x4C, + 0xA4, 0x9D, 0x47, 0x24, 0xCB, 0x6A, 0x1B, 0x17, + 0x12, 0xA5, 0x62, 0xA3, 0xD7, 0x6E, 0x47, 0x33, + 0xD3, 0x0D, 0x8F, 0xB1, 0xC7, 0xBB, 0xCA, 0x7D, + 0xA7, 0xED, 0xC5, 0x9B, 0xB3, 0xB8, 0xD0, 0x66 + }, + { + 0x76, 0x9D, 0x9D, 0xAD, 0x68, 0x33, 0xFC, 0xFE, + 0xD3, 0x73, 0xB5, 0x04, 0x77, 0xD7, 0x04, 0xB0, + 0x50, 0x57, 0x49, 0x33, 0x8E, 0x52, 0xCA, 0xAE, + 0x90, 0x89, 0x58, 0x6B, 0x0C, 0x68, 0xC8, 0xFC, + 0xED, 0xA9, 0xAA, 0xB5, 0x9A, 0xF4, 0x88, 0x91, + 0x60, 0x47, 0x04, 0xE4, 0x91, 0x34, 0xFC, 0x06, + 0x9C, 0x9F, 0xE4, 0x7A, 0x9A, 0x97, 0x13, 0xEE, + 0x2E, 0xD7, 0x4E, 0xD5, 0x46, 0x0D, 0x9F, 0xEF + }, + { + 0xB4, 0x56, 0xFB, 0xE2, 0xD8, 0x19, 0xFF, 0x02, + 0x48, 0x13, 0x58, 0xFA, 0xA0, 0x45, 0x8A, 0x2C, + 0xE0, 0xF6, 0xE0, 0x7E, 0x21, 0x72, 0x64, 0x8F, + 0xF2, 0x68, 0x90, 0xAC, 0x02, 0x5C, 0x98, 0xE3, + 0x2A, 0x45, 0xAB, 0x63, 0x98, 0xDA, 0x33, 0x5A, + 0x71, 0xCE, 0x88, 0xE4, 0x94, 0xF1, 0xC7, 0xEF, + 0xD8, 0x40, 0xDE, 0x95, 0xC6, 0x9A, 0x6E, 0x05, + 0xBB, 0x3C, 0x79, 0xC4, 0x67, 0xD5, 0xF5, 0x13 + }, + { + 0x64, 0x90, 0x7E, 0x90, 0xAC, 0x40, 0x21, 0xF2, + 0xAD, 0x9C, 0x67, 0xA0, 0x4B, 0x95, 0xAC, 0xB4, + 0xC9, 0x37, 0xA3, 0xFB, 0x7C, 0x05, 0x78, 0xBB, + 0x5C, 0x27, 0x4C, 0x85, 0x8D, 0x62, 0x33, 0x69, + 0x59, 0xCE, 0x5D, 0x80, 0xB7, 0x05, 0x2A, 0x42, + 0x2F, 0x91, 0x7F, 0x2E, 0xED, 0x48, 0x4F, 0xD2, + 0x22, 0xB9, 0x34, 0x5A, 0xF7, 0x9B, 0x6E, 0x72, + 0xCB, 0x80, 0x43, 0xCD, 0x5E, 0xE6, 0x69, 0x1A + }, + { + 0x9C, 0x62, 0x51, 0x77, 0xA0, 0xF1, 0x44, 0x77, + 0x9E, 0x9B, 0xC9, 0xCC, 0x45, 0x93, 0x4C, 0x24, + 0xF2, 0x07, 0x1A, 0x3B, 0x64, 0x13, 0x35, 0x7C, + 0x7D, 0xF4, 0xC9, 0x55, 0x8F, 0x63, 0xA3, 0x60, + 0x4D, 0x9F, 0xAA, 0xD9, 0x08, 0x6A, 0x69, 0x6E, + 0x00, 0x06, 0x24, 0x07, 0x4C, 0x08, 0x5A, 0x34, + 0xF9, 0xBA, 0xBB, 0x50, 0xBF, 0xE3, 0xFD, 0xFE, + 0xD4, 0xB9, 0x6B, 0xCF, 0x04, 0x8D, 0x4D, 0x5E + }, + { + 0x2A, 0x47, 0x10, 0xE6, 0xBD, 0x41, 0x18, 0xD3, + 0x76, 0x4F, 0xCD, 0x10, 0xD7, 0x63, 0xF5, 0xFA, + 0x12, 0xD6, 0x73, 0xCA, 0xAE, 0xE5, 0xB9, 0xDB, + 0x17, 0x5C, 0x7A, 0x3A, 0x94, 0xE5, 0xEF, 0x25, + 0x7E, 0xC1, 0x4D, 0xC1, 0x9B, 0xD3, 0x62, 0x17, + 0xD8, 0x9E, 0x23, 0x5A, 0xDE, 0x18, 0xDE, 0x8E, + 0x5F, 0x16, 0x3D, 0xCA, 0x4B, 0x16, 0x88, 0x18, + 0x0B, 0xA7, 0xBB, 0x0E, 0x18, 0xBE, 0x43, 0x61 + }, + { + 0x34, 0xD6, 0xDD, 0x66, 0x0F, 0x89, 0x0B, 0x45, + 0x73, 0x78, 0xA7, 0x77, 0x46, 0x8C, 0xB8, 0x9F, + 0x72, 0x5F, 0x62, 0x80, 0xB3, 0x81, 0xFE, 0x7D, + 0x8C, 0x7E, 0xFD, 0x70, 0x6A, 0x91, 0xC3, 0x9D, + 0xFD, 0x53, 0x02, 0x7D, 0x82, 0x6D, 0x6D, 0x2B, + 0x65, 0xB0, 0xD2, 0x16, 0xAE, 0xA2, 0x3B, 0x9C, + 0xC5, 0x35, 0xE2, 0xC0, 0x99, 0xBD, 0x58, 0xA5, + 0xDA, 0xB2, 0x41, 0x49, 0xB5, 0x2B, 0xA0, 0x69 + }, + { + 0xC1, 0xBD, 0xB7, 0xB6, 0x0E, 0x24, 0x0C, 0xB4, + 0x60, 0x46, 0x10, 0xE3, 0x5C, 0x17, 0xE1, 0x8B, + 0x2B, 0x0F, 0x19, 0xF4, 0xCF, 0x03, 0x0D, 0x62, + 0x14, 0xBD, 0x5F, 0x96, 0xAC, 0xCB, 0x2B, 0x9D, + 0xB8, 0x9C, 0x65, 0x32, 0xEE, 0xFF, 0x93, 0xD2, + 0x68, 0x69, 0xC4, 0xE4, 0x52, 0xC3, 0x0A, 0x0F, + 0xF2, 0xD0, 0xC3, 0x97, 0xD9, 0x2C, 0x83, 0xEC, + 0x3E, 0x7C, 0xDC, 0xC1, 0x32, 0x0D, 0x82, 0x9F + }, + { + 0x46, 0xF4, 0x89, 0xCB, 0x25, 0x26, 0x7A, 0xEC, + 0xA9, 0x1B, 0x05, 0x83, 0x3B, 0xDC, 0xC4, 0xF6, + 0x79, 0x72, 0x8C, 0xAD, 0x76, 0xD1, 0xD4, 0xD6, + 0x36, 0x58, 0xCA, 0xF6, 0xF3, 0x26, 0x94, 0xBD, + 0xD5, 0x83, 0x8D, 0xA5, 0x34, 0xC0, 0x67, 0x79, + 0x2E, 0x24, 0x9D, 0xAE, 0x2D, 0xB5, 0x2A, 0xD1, + 0x9F, 0xCF, 0xC8, 0x40, 0x02, 0x41, 0x37, 0xDB, + 0xAC, 0x84, 0x13, 0x66, 0xE0, 0xE5, 0xE9, 0xA0 + }, + { + 0x1F, 0x64, 0x5A, 0x69, 0xC8, 0x14, 0x17, 0x0A, + 0x2A, 0x0F, 0x36, 0x03, 0x1C, 0x8B, 0x65, 0x7D, + 0x3C, 0x5F, 0x71, 0x44, 0x9E, 0x61, 0x82, 0xEA, + 0x6E, 0xAC, 0xDB, 0xB5, 0xC5, 0x85, 0x32, 0x84, + 0xA5, 0x06, 0xD6, 0x92, 0xE7, 0x84, 0xC3, 0x6A, + 0x49, 0xAB, 0x91, 0x35, 0x11, 0x1D, 0x65, 0x54, + 0x6F, 0x69, 0x79, 0x42, 0x2F, 0x46, 0xCA, 0x6F, + 0x5A, 0x81, 0xD6, 0x16, 0xCC, 0xBF, 0xD5, 0xA0 + }, + { + 0x13, 0xC6, 0x32, 0x55, 0x5C, 0x3B, 0x61, 0x86, + 0x87, 0xA8, 0x6F, 0x75, 0xC6, 0xA0, 0x8B, 0x42, + 0x74, 0xE8, 0x56, 0x6A, 0xD4, 0xAC, 0xDD, 0xAF, + 0x46, 0xB9, 0xCB, 0xA2, 0xEA, 0xA2, 0x52, 0x1C, + 0xB5, 0x13, 0x86, 0xDE, 0x93, 0xF3, 0x39, 0x1E, + 0x8A, 0x53, 0x01, 0xF7, 0x1A, 0x63, 0xF4, 0xAF, + 0xDD, 0xBA, 0xAF, 0xB6, 0xC6, 0xF3, 0x90, 0x0D, + 0x47, 0xFD, 0x76, 0xD3, 0x63, 0xE6, 0x33, 0xF3 + }, + { + 0xC6, 0x5A, 0x6B, 0x58, 0xA9, 0x43, 0x4B, 0x00, + 0xBA, 0x4E, 0xFF, 0x16, 0x02, 0x6F, 0x83, 0xA5, + 0x17, 0xCB, 0xA9, 0x0E, 0x7A, 0x3C, 0x80, 0xDF, + 0x58, 0x6D, 0x22, 0x32, 0x41, 0xF1, 0x05, 0x6C, + 0xA8, 0x74, 0x4B, 0xF0, 0xE8, 0x65, 0xE4, 0xCC, + 0x45, 0x69, 0x94, 0x8D, 0xBB, 0xB7, 0x12, 0x50, + 0x35, 0xB1, 0x2C, 0x4E, 0x32, 0x32, 0x48, 0xF7, + 0xA3, 0xAE, 0xBC, 0x45, 0x48, 0x81, 0xE4, 0x4A + }, + { + 0xB0, 0x79, 0xEC, 0xD1, 0x8C, 0x1C, 0x1C, 0xE5, + 0xE3, 0x90, 0x6D, 0x3B, 0x76, 0xF8, 0x68, 0x1C, + 0x09, 0xD0, 0x22, 0x59, 0xD9, 0x2C, 0x31, 0xC1, + 0x43, 0x0C, 0x9B, 0x37, 0x39, 0xA0, 0x3E, 0x71, + 0x94, 0x17, 0x5F, 0x61, 0xC3, 0x6C, 0x7A, 0xC8, + 0x2C, 0xF7, 0x3E, 0xD7, 0xFA, 0xD1, 0xE6, 0x81, + 0xDF, 0x75, 0x94, 0xAB, 0x9F, 0x48, 0x9E, 0x95, + 0x53, 0x2F, 0x7D, 0xC4, 0x26, 0xB0, 0x6E, 0x37 + }, + { + 0xD2, 0xC6, 0x2B, 0x2E, 0x3B, 0x2E, 0x2D, 0x71, + 0x5C, 0xB3, 0xD1, 0xAE, 0x8F, 0xE4, 0x75, 0x15, + 0xE2, 0x6A, 0x16, 0xE1, 0x5A, 0xAE, 0xC7, 0x59, + 0x9B, 0x8D, 0x0F, 0x48, 0xCA, 0xD0, 0xF0, 0x68, + 0x84, 0xE4, 0x20, 0x50, 0x05, 0x3D, 0x20, 0xB1, + 0xC2, 0xF1, 0x10, 0x23, 0xF8, 0x9E, 0xFE, 0xF4, + 0x66, 0xFC, 0xA6, 0x6F, 0x6A, 0x1C, 0x15, 0x63, + 0xD4, 0x78, 0xAB, 0x29, 0xBA, 0xA3, 0xC4, 0xFA + }, + { + 0x7B, 0x56, 0x1D, 0xFF, 0xCC, 0x11, 0xCB, 0x19, + 0x6E, 0xA2, 0xA7, 0x30, 0xD3, 0x2D, 0x09, 0xCE, + 0x56, 0xBE, 0x86, 0x22, 0x53, 0x2C, 0x60, 0xA3, + 0xC0, 0x84, 0x33, 0xC4, 0x6C, 0x37, 0xE5, 0xE6, + 0xA4, 0x70, 0xA2, 0x94, 0x91, 0x53, 0x7F, 0x8B, + 0x8F, 0x7B, 0x52, 0x53, 0x13, 0x2C, 0x86, 0x9A, + 0x83, 0x76, 0x19, 0xB2, 0x25, 0xBB, 0x32, 0xDC, + 0xDB, 0x84, 0x5C, 0x39, 0x43, 0x58, 0x09, 0xBB + }, + { + 0xE6, 0x37, 0xA7, 0x15, 0x31, 0xC0, 0xCC, 0x4B, + 0x15, 0x33, 0x1F, 0xB2, 0xB1, 0x6F, 0xE5, 0xFA, + 0xC7, 0x17, 0xB4, 0x2C, 0x47, 0x7F, 0xF5, 0x8C, + 0xD2, 0xF3, 0xF1, 0x3B, 0x28, 0x97, 0x3C, 0xEF, + 0xA8, 0xF4, 0x56, 0x7B, 0xE6, 0x25, 0x37, 0x0E, + 0x03, 0xB7, 0xC7, 0x26, 0xF8, 0xD3, 0xEF, 0x16, + 0x26, 0xE9, 0xF9, 0x26, 0x54, 0x24, 0xE6, 0x0C, + 0xAB, 0xA3, 0x2E, 0x15, 0xBE, 0x41, 0xB7, 0x9F + }, + { + 0x18, 0xBB, 0x19, 0xF3, 0x9E, 0x96, 0xD2, 0x1B, + 0xA1, 0xB7, 0x3C, 0x1B, 0x38, 0xA8, 0xB9, 0x72, + 0xD0, 0x26, 0xA7, 0x68, 0xA6, 0x9B, 0x51, 0xAD, + 0x6B, 0x8E, 0x49, 0x7C, 0x4F, 0x7F, 0xA5, 0xE4, + 0x2C, 0x8C, 0xAC, 0x33, 0x73, 0xE0, 0xAD, 0xF0, + 0x12, 0xCD, 0x2C, 0x85, 0xDE, 0x1E, 0x43, 0x97, + 0xD0, 0xBF, 0x94, 0xDD, 0x74, 0x89, 0x9E, 0xCB, + 0x8A, 0x64, 0x4F, 0x89, 0xF1, 0x1D, 0xD4, 0x13 + }, + { + 0x5A, 0xCA, 0x88, 0xE1, 0xEB, 0xF5, 0x8A, 0x85, + 0xE4, 0xDF, 0x9C, 0x77, 0x2E, 0xD7, 0x39, 0xEF, + 0xBA, 0xE8, 0x17, 0xF7, 0x31, 0xDA, 0xC8, 0x23, + 0xE2, 0xA9, 0xE3, 0xB7, 0x73, 0x67, 0x1E, 0x0F, + 0x71, 0xD8, 0xE7, 0xDC, 0x19, 0x8A, 0x96, 0xAC, + 0x79, 0x5C, 0x7B, 0x9F, 0xE0, 0x8F, 0x1F, 0x3E, + 0xD1, 0x16, 0x7D, 0xFE, 0x06, 0x40, 0x24, 0xB5, + 0x3D, 0x15, 0x6A, 0x8F, 0x3C, 0x54, 0x00, 0x29 + }, + { + 0xBF, 0x5E, 0x25, 0x65, 0x96, 0xAC, 0xAF, 0x77, + 0x9E, 0xC3, 0x7F, 0x1E, 0xF7, 0xC1, 0xA7, 0x30, + 0x85, 0x50, 0x66, 0x1A, 0x0D, 0xA7, 0xC3, 0x85, + 0x5E, 0x49, 0xDB, 0x61, 0xBA, 0x20, 0x4C, 0x8C, + 0x57, 0xD1, 0x5D, 0x0F, 0x1A, 0x39, 0x6C, 0x14, + 0xF6, 0xC5, 0x7E, 0x3A, 0x90, 0x81, 0xB8, 0x8E, + 0x30, 0xAD, 0x1B, 0x72, 0xB6, 0xBF, 0x95, 0x13, + 0x9D, 0xCC, 0xDD, 0xCF, 0x24, 0x36, 0x61, 0xD8 + }, + { + 0x42, 0x71, 0xDA, 0xFC, 0xF5, 0xAF, 0xC2, 0x35, + 0x2A, 0x04, 0x29, 0xC5, 0x98, 0xC1, 0x1B, 0x0F, + 0xAA, 0xF0, 0x73, 0x3C, 0x11, 0xC8, 0x42, 0x7A, + 0x78, 0x39, 0x10, 0x16, 0x94, 0x5D, 0xAF, 0x7B, + 0x0C, 0x7E, 0x9E, 0x2C, 0x98, 0xCC, 0x33, 0x08, + 0xB7, 0xE6, 0x17, 0x19, 0x95, 0xA4, 0x2D, 0x60, + 0xC5, 0x33, 0x7C, 0xFB, 0xC6, 0x28, 0x95, 0x38, + 0xBC, 0xD3, 0xF6, 0xD8, 0xDE, 0xAB, 0x8C, 0x88 + }, + { + 0x4A, 0x70, 0xBD, 0x23, 0xBA, 0xD4, 0x72, 0x6B, + 0x10, 0x41, 0x26, 0x89, 0x01, 0x3B, 0x1D, 0x8A, + 0x4E, 0x31, 0x5B, 0x52, 0x5D, 0xFE, 0xD3, 0x29, + 0xEE, 0x9C, 0xB6, 0x6D, 0x9C, 0x32, 0x92, 0x25, + 0xED, 0x47, 0x93, 0xA1, 0x05, 0x28, 0xA7, 0x0B, + 0x57, 0xA5, 0xCA, 0x7F, 0x91, 0x40, 0x92, 0x20, + 0xD0, 0xA9, 0xC8, 0xE2, 0x80, 0x76, 0x95, 0x40, + 0x8D, 0xE1, 0xDC, 0xCC, 0x1B, 0x41, 0x43, 0x78 + }, + { + 0x7B, 0xE9, 0x5D, 0x25, 0x1F, 0x91, 0x9D, 0xEA, + 0xC9, 0x6D, 0x2B, 0xED, 0x2A, 0xB6, 0xB4, 0x99, + 0xF8, 0x06, 0x60, 0x1D, 0x31, 0x5A, 0xDD, 0x81, + 0x82, 0xA5, 0x50, 0x97, 0x7D, 0x0C, 0xE7, 0x75, + 0xD6, 0x8C, 0x0F, 0x75, 0x5E, 0xD3, 0x75, 0xE7, + 0xF5, 0x46, 0x59, 0xF8, 0xCE, 0xE8, 0xEE, 0x16, + 0x28, 0x10, 0xF9, 0xA4, 0x09, 0x67, 0x41, 0xDB, + 0x18, 0x0B, 0xEF, 0x27, 0x37, 0x79, 0xEB, 0x37 + }, + { + 0x86, 0x13, 0xC6, 0xFF, 0xF0, 0x39, 0x98, 0x73, + 0xB8, 0x5E, 0xCB, 0x68, 0x65, 0xB2, 0xC9, 0x66, + 0xBB, 0x67, 0xC0, 0x26, 0xAD, 0xFE, 0xE5, 0x48, + 0xBC, 0x86, 0x39, 0x79, 0x7C, 0x42, 0x49, 0x66, + 0xFE, 0xB3, 0x3B, 0x7B, 0x12, 0xD6, 0x69, 0xBB, + 0x72, 0x2C, 0xB9, 0x7D, 0xA9, 0xAD, 0x13, 0x57, + 0xBA, 0xBA, 0x43, 0xAE, 0xB2, 0x7A, 0xB5, 0x85, + 0xBE, 0x04, 0x26, 0x68, 0x69, 0xF8, 0x9C, 0x02 + }, + { + 0x55, 0xEF, 0x2C, 0x0A, 0x4F, 0x83, 0x39, 0x71, + 0x77, 0x89, 0xE5, 0x2A, 0x37, 0x3E, 0x2D, 0xB5, + 0x8E, 0x31, 0x1B, 0xBD, 0x20, 0x64, 0x28, 0x33, + 0xC3, 0x95, 0x35, 0xF9, 0x12, 0x96, 0x7B, 0xD2, + 0x3E, 0xF8, 0x3E, 0xE2, 0xAD, 0xFD, 0xED, 0x2E, + 0x72, 0x3A, 0xF0, 0x62, 0x4E, 0x52, 0xA2, 0x19, + 0x08, 0x12, 0x7A, 0xFB, 0x51, 0xFC, 0x9B, 0x6D, + 0x71, 0xB5, 0x62, 0x4A, 0x56, 0x3B, 0x7A, 0xCD + }, + { + 0xCB, 0x3F, 0x85, 0x16, 0xF6, 0x1A, 0x35, 0x2A, + 0x27, 0x33, 0x7A, 0x6D, 0x3C, 0x1C, 0xD0, 0x27, + 0x24, 0x64, 0xA1, 0xB2, 0x19, 0x7B, 0x60, 0x21, + 0xF6, 0x97, 0x15, 0x76, 0x56, 0x36, 0xB6, 0xE0, + 0x3F, 0x42, 0x18, 0x0D, 0xF3, 0x65, 0x6D, 0x5E, + 0xB2, 0xBB, 0xDA, 0x2D, 0x31, 0xB0, 0x0D, 0x9C, + 0x77, 0xC2, 0x5E, 0xFA, 0xB6, 0xBE, 0xA2, 0x33, + 0x44, 0x43, 0x90, 0x26, 0xC3, 0x50, 0x5E, 0xD9 + }, + { + 0xB6, 0x4A, 0xCA, 0xDD, 0x4A, 0xB1, 0x97, 0x9A, + 0xAE, 0xAB, 0xAC, 0x4A, 0x75, 0x53, 0x48, 0x1F, + 0x59, 0x13, 0xFF, 0x8F, 0xAA, 0x01, 0x45, 0x79, + 0xCD, 0xC8, 0xC3, 0x00, 0xFB, 0x8A, 0x8E, 0x92, + 0x45, 0xF8, 0xC9, 0x4C, 0xF1, 0x0F, 0xAE, 0x46, + 0x24, 0x8C, 0xC3, 0xD3, 0x41, 0x7F, 0x73, 0x07, + 0x48, 0xA9, 0xCC, 0x69, 0x5D, 0xD5, 0x5D, 0xA8, + 0x56, 0x15, 0x25, 0x3A, 0x80, 0x62, 0xC1, 0x52 + }, + { + 0x68, 0x57, 0xC5, 0x12, 0xF9, 0xCD, 0xF6, 0x46, + 0x15, 0x78, 0x92, 0x73, 0xD6, 0xA2, 0x58, 0xDF, + 0x5A, 0x60, 0xD1, 0x04, 0xEF, 0x92, 0xFE, 0xDF, + 0x3E, 0x7B, 0x04, 0xEF, 0x3C, 0x79, 0xC6, 0x88, + 0x85, 0x0A, 0xCB, 0xC7, 0xEE, 0x33, 0xC5, 0xF1, + 0x1B, 0x53, 0x76, 0x1C, 0x3E, 0x49, 0x22, 0x4B, + 0xC8, 0xB8, 0x0C, 0x7A, 0x05, 0x88, 0x22, 0x25, + 0x5A, 0x0C, 0x3B, 0x4D, 0xA4, 0x8B, 0x7F, 0x1B + }, + { + 0x66, 0xD9, 0xEF, 0x69, 0x7B, 0x9A, 0xFB, 0x65, + 0x58, 0xEA, 0xC6, 0x3C, 0xED, 0x2D, 0x7B, 0x74, + 0x31, 0x55, 0x17, 0xEF, 0x0D, 0x5F, 0xBF, 0x6E, + 0x82, 0x3E, 0x1A, 0x83, 0xB0, 0xBD, 0xF8, 0x49, + 0x2E, 0x12, 0x5E, 0xA2, 0x34, 0x56, 0xD7, 0x15, + 0x9B, 0x74, 0x37, 0x35, 0x24, 0xB1, 0x28, 0xDE, + 0x0C, 0x8B, 0xD9, 0xFB, 0x69, 0xE8, 0x82, 0xAA, + 0xAD, 0xCE, 0x02, 0xA7, 0x7B, 0x66, 0x01, 0xB1 + }, + { + 0x2B, 0x3C, 0xA9, 0xC5, 0x41, 0x97, 0x87, 0xDA, + 0x55, 0xBF, 0x49, 0x11, 0x2A, 0x36, 0x41, 0x5E, + 0x22, 0xF9, 0x60, 0xEC, 0xF4, 0xF5, 0xD3, 0x95, + 0x2B, 0xE9, 0x88, 0xEB, 0x76, 0x6C, 0xFB, 0xA9, + 0x90, 0x0F, 0x41, 0x79, 0xDA, 0xAF, 0xA4, 0xCA, + 0xF7, 0xF7, 0x6C, 0xD3, 0xD0, 0x5D, 0x59, 0x1A, + 0xC2, 0x0B, 0xB5, 0x54, 0xF1, 0x6C, 0x54, 0x7B, + 0x3D, 0x9D, 0xD8, 0xD5, 0x7E, 0x07, 0x5F, 0x1C + }, + { + 0xA8, 0x39, 0xC9, 0x13, 0x74, 0x65, 0x1D, 0x12, + 0xD9, 0x7F, 0x7B, 0x66, 0xA4, 0x91, 0x21, 0x95, + 0x7B, 0xCB, 0x3C, 0x4B, 0xBE, 0x51, 0x5B, 0x5F, + 0xE6, 0x61, 0xA4, 0xE2, 0x27, 0xC2, 0xB8, 0x4E, + 0x39, 0x07, 0xD9, 0x4D, 0xEC, 0xB8, 0xBC, 0x0D, + 0x1D, 0x7C, 0xC7, 0x79, 0x9D, 0xF2, 0x68, 0x6D, + 0x10, 0xB3, 0xB9, 0x0F, 0xD7, 0x4C, 0xEF, 0xC1, + 0xBE, 0xD3, 0xAB, 0x4F, 0xF3, 0xDF, 0x1D, 0xB8 + }, + { + 0xAE, 0x16, 0x8D, 0x84, 0xA6, 0xF0, 0xF2, 0x3E, + 0xD9, 0x34, 0xC2, 0x6A, 0xE8, 0x00, 0x0D, 0x61, + 0xEB, 0x2F, 0x8E, 0xA2, 0x7E, 0x64, 0x80, 0x45, + 0xD7, 0x13, 0x51, 0x3D, 0x84, 0x89, 0x54, 0x44, + 0x2A, 0xB1, 0x03, 0x48, 0xBE, 0xE3, 0xA6, 0x27, + 0x34, 0x16, 0x46, 0xCF, 0xB7, 0x9C, 0x57, 0xB3, + 0x68, 0x70, 0xA6, 0x1A, 0x44, 0xBD, 0x00, 0xF6, + 0xCD, 0xD0, 0xA9, 0x83, 0x9A, 0xD9, 0xCA, 0x6D + }, + { + 0xFF, 0x25, 0x45, 0xB9, 0x38, 0xA3, 0xCC, 0x5C, + 0xCE, 0x6F, 0x40, 0x0B, 0x03, 0xA6, 0x51, 0x23, + 0x1D, 0x48, 0xCE, 0xCB, 0xA4, 0x64, 0x1C, 0x8B, + 0x2D, 0x22, 0xF5, 0xED, 0xF5, 0x08, 0x8B, 0x9A, + 0xA8, 0x3C, 0xA4, 0xBD, 0xB6, 0xB2, 0xAF, 0xAF, + 0xEE, 0xAD, 0xCC, 0xDA, 0xBA, 0xD6, 0xFB, 0xBE, + 0x56, 0xDD, 0x2F, 0x31, 0x4D, 0x6B, 0xA4, 0x41, + 0xE1, 0x78, 0x11, 0xC6, 0x4A, 0x1A, 0xCD, 0x41 + }, + { + 0x0A, 0xEA, 0xB0, 0xC6, 0x3E, 0xEF, 0x4E, 0x1A, + 0xDB, 0x0D, 0x7E, 0x23, 0x97, 0xCC, 0xDF, 0x7A, + 0x80, 0xD6, 0xE6, 0x10, 0x51, 0x2E, 0xA2, 0x79, + 0x86, 0x0B, 0xC9, 0x4D, 0x71, 0x52, 0xB8, 0x5D, + 0x69, 0x59, 0xD6, 0x81, 0xE7, 0x60, 0xE9, 0x3D, + 0xEF, 0x4A, 0x25, 0xD1, 0x2E, 0xFD, 0x7C, 0x55, + 0xD1, 0x04, 0xAB, 0xC4, 0x1F, 0x1E, 0xA9, 0x67, + 0x80, 0xA6, 0xEE, 0x71, 0x89, 0x05, 0x4C, 0x78 + }, + { + 0xA7, 0x4E, 0xE6, 0x0F, 0x5D, 0x59, 0x55, 0xAC, + 0xD7, 0xE5, 0x4B, 0xD8, 0x6C, 0x3E, 0x36, 0xFB, + 0x42, 0x16, 0x7E, 0xBB, 0xD5, 0x9B, 0x3F, 0x71, + 0xEA, 0xE2, 0xF0, 0xF0, 0x59, 0x53, 0x3A, 0x06, + 0x8E, 0x82, 0xD8, 0xBF, 0x40, 0x0C, 0xD8, 0x47, + 0xE3, 0x44, 0x8A, 0xF9, 0x1B, 0x30, 0x17, 0x3E, + 0x67, 0x60, 0xF0, 0x99, 0xD9, 0x12, 0xCE, 0xAC, + 0xFC, 0x1E, 0xA5, 0x52, 0xC6, 0xD0, 0xC8, 0xD4 + }, + { + 0x4A, 0xF6, 0xA7, 0xC7, 0xFE, 0xD8, 0x23, 0xF5, + 0x45, 0x52, 0xA1, 0xDC, 0x95, 0x33, 0xFE, 0x07, + 0x5E, 0x9F, 0xEC, 0xA6, 0xCB, 0x61, 0x4A, 0x54, + 0x4F, 0x8B, 0xB5, 0x0D, 0xF2, 0xEB, 0x32, 0x68, + 0xD4, 0x73, 0x7E, 0x94, 0xA8, 0x30, 0xF5, 0x4A, + 0x89, 0x12, 0x75, 0x91, 0xE4, 0x27, 0xEF, 0x83, + 0x1D, 0x19, 0xEC, 0xE6, 0xFD, 0x63, 0x39, 0x55, + 0x1B, 0x63, 0xE0, 0x16, 0xAD, 0x9F, 0x65, 0xF4 + }, + { + 0x32, 0x5A, 0x72, 0xDD, 0x05, 0xB8, 0x69, 0xCA, + 0xF2, 0x76, 0x0D, 0x12, 0xB3, 0xEF, 0x3B, 0x4B, + 0xC3, 0x98, 0xCA, 0x57, 0x1A, 0x4A, 0x66, 0x08, + 0x84, 0x5C, 0x16, 0x02, 0x10, 0xA6, 0x56, 0x66, + 0x2B, 0x33, 0x3C, 0x6A, 0x6B, 0x82, 0x3C, 0x14, + 0x36, 0xD6, 0x22, 0xA0, 0x37, 0x7F, 0xDD, 0xA7, + 0x7A, 0xAF, 0xC7, 0xB0, 0x1C, 0x44, 0x8B, 0x83, + 0xA2, 0x73, 0xD7, 0xCE, 0x22, 0x7D, 0x44, 0x65 + }, + { + 0x2B, 0xCD, 0x85, 0x34, 0xF1, 0x24, 0x23, 0x22, + 0x74, 0x30, 0xB1, 0x7F, 0xEF, 0x5C, 0xAC, 0x6E, + 0xCE, 0x19, 0x9C, 0xAA, 0x58, 0xB0, 0xE7, 0x69, + 0x1D, 0xA0, 0xF8, 0xC6, 0x31, 0x11, 0x91, 0xAF, + 0xB2, 0x68, 0xAC, 0xBC, 0x5D, 0x5D, 0x66, 0x97, + 0xFF, 0xB6, 0xE0, 0xBD, 0x27, 0xA2, 0x3D, 0x2A, + 0xD9, 0xEB, 0xB7, 0x12, 0xC0, 0x0F, 0xC6, 0xB2, + 0x6B, 0xF0, 0x0B, 0x70, 0x27, 0xEC, 0x98, 0xA1 + }, + { + 0x76, 0xF7, 0x3B, 0x2A, 0x62, 0xF3, 0x71, 0x84, + 0x9F, 0x2B, 0x66, 0x06, 0xEA, 0xA2, 0x53, 0x28, + 0xB2, 0x55, 0xAA, 0x37, 0x58, 0x7A, 0x95, 0x5C, + 0x4C, 0x7A, 0x4E, 0x89, 0x63, 0x84, 0x78, 0xE0, + 0x10, 0x38, 0x52, 0xEE, 0x6A, 0x20, 0x21, 0x7A, + 0xF9, 0x4F, 0xCE, 0x02, 0x86, 0x1F, 0x66, 0x7F, + 0x60, 0x62, 0xC3, 0x6A, 0xB1, 0x70, 0xE8, 0x5E, + 0xD7, 0x30, 0xE3, 0x38, 0x54, 0xB1, 0x9A, 0x37 + }, + { + 0xB5, 0xDA, 0x34, 0x42, 0x1F, 0xC3, 0xF5, 0x39, + 0x63, 0x45, 0xB7, 0x69, 0xC0, 0xBA, 0x15, 0x9A, + 0x8E, 0x79, 0x2E, 0x20, 0xAC, 0xD1, 0xE6, 0xA5, + 0x0C, 0xB7, 0xA5, 0x5F, 0xB5, 0x4D, 0x16, 0x39, + 0x08, 0xFE, 0x6A, 0xEE, 0x02, 0x15, 0x39, 0xBC, + 0x20, 0x40, 0x25, 0xA2, 0x6C, 0x03, 0x23, 0x2C, + 0x42, 0xF7, 0x1F, 0xB5, 0xE5, 0x77, 0xDF, 0x3F, + 0x16, 0x64, 0x09, 0xAE, 0xE7, 0xC5, 0x3B, 0xF9 + }, + { + 0x50, 0x5D, 0x86, 0x12, 0xC4, 0x74, 0x56, 0x22, + 0x10, 0x18, 0x76, 0x55, 0x39, 0x68, 0xE6, 0x59, + 0xBB, 0xE0, 0x26, 0xE3, 0x68, 0xB1, 0x98, 0x5D, + 0x16, 0x53, 0xAC, 0xE2, 0x25, 0x80, 0x1A, 0x36, + 0x02, 0x17, 0x2C, 0x47, 0xC8, 0x55, 0xAB, 0x95, + 0xC8, 0x43, 0xA5, 0x8D, 0xE1, 0x2C, 0xD9, 0xFD, + 0xE6, 0x82, 0xBA, 0x5B, 0x2D, 0x97, 0xA7, 0x36, + 0x7D, 0x55, 0xE5, 0x86, 0x67, 0x43, 0xB1, 0x91 + }, +}; + + + + +static const uint8_t blake2b_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2B_OUTBYTES] = +{ + { + 0x10, 0xEB, 0xB6, 0x77, 0x00, 0xB1, 0x86, 0x8E, + 0xFB, 0x44, 0x17, 0x98, 0x7A, 0xCF, 0x46, 0x90, + 0xAE, 0x9D, 0x97, 0x2F, 0xB7, 0xA5, 0x90, 0xC2, + 0xF0, 0x28, 0x71, 0x79, 0x9A, 0xAA, 0x47, 0x86, + 0xB5, 0xE9, 0x96, 0xE8, 0xF0, 0xF4, 0xEB, 0x98, + 0x1F, 0xC2, 0x14, 0xB0, 0x05, 0xF4, 0x2D, 0x2F, + 0xF4, 0x23, 0x34, 0x99, 0x39, 0x16, 0x53, 0xDF, + 0x7A, 0xEF, 0xCB, 0xC1, 0x3F, 0xC5, 0x15, 0x68 + }, + { + 0x96, 0x1F, 0x6D, 0xD1, 0xE4, 0xDD, 0x30, 0xF6, + 0x39, 0x01, 0x69, 0x0C, 0x51, 0x2E, 0x78, 0xE4, + 0xB4, 0x5E, 0x47, 0x42, 0xED, 0x19, 0x7C, 0x3C, + 0x5E, 0x45, 0xC5, 0x49, 0xFD, 0x25, 0xF2, 0xE4, + 0x18, 0x7B, 0x0B, 0xC9, 0xFE, 0x30, 0x49, 0x2B, + 0x16, 0xB0, 0xD0, 0xBC, 0x4E, 0xF9, 0xB0, 0xF3, + 0x4C, 0x70, 0x03, 0xFA, 0xC0, 0x9A, 0x5E, 0xF1, + 0x53, 0x2E, 0x69, 0x43, 0x02, 0x34, 0xCE, 0xBD + }, + { + 0xDA, 0x2C, 0xFB, 0xE2, 0xD8, 0x40, 0x9A, 0x0F, + 0x38, 0x02, 0x61, 0x13, 0x88, 0x4F, 0x84, 0xB5, + 0x01, 0x56, 0x37, 0x1A, 0xE3, 0x04, 0xC4, 0x43, + 0x01, 0x73, 0xD0, 0x8A, 0x99, 0xD9, 0xFB, 0x1B, + 0x98, 0x31, 0x64, 0xA3, 0x77, 0x07, 0x06, 0xD5, + 0x37, 0xF4, 0x9E, 0x0C, 0x91, 0x6D, 0x9F, 0x32, + 0xB9, 0x5C, 0xC3, 0x7A, 0x95, 0xB9, 0x9D, 0x85, + 0x74, 0x36, 0xF0, 0x23, 0x2C, 0x88, 0xA9, 0x65 + }, + { + 0x33, 0xD0, 0x82, 0x5D, 0xDD, 0xF7, 0xAD, 0xA9, + 0x9B, 0x0E, 0x7E, 0x30, 0x71, 0x04, 0xAD, 0x07, + 0xCA, 0x9C, 0xFD, 0x96, 0x92, 0x21, 0x4F, 0x15, + 0x61, 0x35, 0x63, 0x15, 0xE7, 0x84, 0xF3, 0xE5, + 0xA1, 0x7E, 0x36, 0x4A, 0xE9, 0xDB, 0xB1, 0x4C, + 0xB2, 0x03, 0x6D, 0xF9, 0x32, 0xB7, 0x7F, 0x4B, + 0x29, 0x27, 0x61, 0x36, 0x5F, 0xB3, 0x28, 0xDE, + 0x7A, 0xFD, 0xC6, 0xD8, 0x99, 0x8F, 0x5F, 0xC1 + }, + { + 0xBE, 0xAA, 0x5A, 0x3D, 0x08, 0xF3, 0x80, 0x71, + 0x43, 0xCF, 0x62, 0x1D, 0x95, 0xCD, 0x69, 0x05, + 0x14, 0xD0, 0xB4, 0x9E, 0xFF, 0xF9, 0xC9, 0x1D, + 0x24, 0xB5, 0x92, 0x41, 0xEC, 0x0E, 0xEF, 0xA5, + 0xF6, 0x01, 0x96, 0xD4, 0x07, 0x04, 0x8B, 0xBA, + 0x8D, 0x21, 0x46, 0x82, 0x8E, 0xBC, 0xB0, 0x48, + 0x8D, 0x88, 0x42, 0xFD, 0x56, 0xBB, 0x4F, 0x6D, + 0xF8, 0xE1, 0x9C, 0x4B, 0x4D, 0xAA, 0xB8, 0xAC + }, + { + 0x09, 0x80, 0x84, 0xB5, 0x1F, 0xD1, 0x3D, 0xEA, + 0xE5, 0xF4, 0x32, 0x0D, 0xE9, 0x4A, 0x68, 0x8E, + 0xE0, 0x7B, 0xAE, 0xA2, 0x80, 0x04, 0x86, 0x68, + 0x9A, 0x86, 0x36, 0x11, 0x7B, 0x46, 0xC1, 0xF4, + 0xC1, 0xF6, 0xAF, 0x7F, 0x74, 0xAE, 0x7C, 0x85, + 0x76, 0x00, 0x45, 0x6A, 0x58, 0xA3, 0xAF, 0x25, + 0x1D, 0xC4, 0x72, 0x3A, 0x64, 0xCC, 0x7C, 0x0A, + 0x5A, 0xB6, 0xD9, 0xCA, 0xC9, 0x1C, 0x20, 0xBB + }, + { + 0x60, 0x44, 0x54, 0x0D, 0x56, 0x08, 0x53, 0xEB, + 0x1C, 0x57, 0xDF, 0x00, 0x77, 0xDD, 0x38, 0x10, + 0x94, 0x78, 0x1C, 0xDB, 0x90, 0x73, 0xE5, 0xB1, + 0xB3, 0xD3, 0xF6, 0xC7, 0x82, 0x9E, 0x12, 0x06, + 0x6B, 0xBA, 0xCA, 0x96, 0xD9, 0x89, 0xA6, 0x90, + 0xDE, 0x72, 0xCA, 0x31, 0x33, 0xA8, 0x36, 0x52, + 0xBA, 0x28, 0x4A, 0x6D, 0x62, 0x94, 0x2B, 0x27, + 0x1F, 0xFA, 0x26, 0x20, 0xC9, 0xE7, 0x5B, 0x1F + }, + { + 0x7A, 0x8C, 0xFE, 0x9B, 0x90, 0xF7, 0x5F, 0x7E, + 0xCB, 0x3A, 0xCC, 0x05, 0x3A, 0xAE, 0xD6, 0x19, + 0x31, 0x12, 0xB6, 0xF6, 0xA4, 0xAE, 0xEB, 0x3F, + 0x65, 0xD3, 0xDE, 0x54, 0x19, 0x42, 0xDE, 0xB9, + 0xE2, 0x22, 0x81, 0x52, 0xA3, 0xC4, 0xBB, 0xBE, + 0x72, 0xFC, 0x3B, 0x12, 0x62, 0x95, 0x28, 0xCF, + 0xBB, 0x09, 0xFE, 0x63, 0x0F, 0x04, 0x74, 0x33, + 0x9F, 0x54, 0xAB, 0xF4, 0x53, 0xE2, 0xED, 0x52 + }, + { + 0x38, 0x0B, 0xEA, 0xF6, 0xEA, 0x7C, 0xC9, 0x36, + 0x5E, 0x27, 0x0E, 0xF0, 0xE6, 0xF3, 0xA6, 0x4F, + 0xB9, 0x02, 0xAC, 0xAE, 0x51, 0xDD, 0x55, 0x12, + 0xF8, 0x42, 0x59, 0xAD, 0x2C, 0x91, 0xF4, 0xBC, + 0x41, 0x08, 0xDB, 0x73, 0x19, 0x2A, 0x5B, 0xBF, + 0xB0, 0xCB, 0xCF, 0x71, 0xE4, 0x6C, 0x3E, 0x21, + 0xAE, 0xE1, 0xC5, 0xE8, 0x60, 0xDC, 0x96, 0xE8, + 0xEB, 0x0B, 0x7B, 0x84, 0x26, 0xE6, 0xAB, 0xE9 + }, + { + 0x60, 0xFE, 0x3C, 0x45, 0x35, 0xE1, 0xB5, 0x9D, + 0x9A, 0x61, 0xEA, 0x85, 0x00, 0xBF, 0xAC, 0x41, + 0xA6, 0x9D, 0xFF, 0xB1, 0xCE, 0xAD, 0xD9, 0xAC, + 0xA3, 0x23, 0xE9, 0xA6, 0x25, 0xB6, 0x4D, 0xA5, + 0x76, 0x3B, 0xAD, 0x72, 0x26, 0xDA, 0x02, 0xB9, + 0xC8, 0xC4, 0xF1, 0xA5, 0xDE, 0x14, 0x0A, 0xC5, + 0xA6, 0xC1, 0x12, 0x4E, 0x4F, 0x71, 0x8C, 0xE0, + 0xB2, 0x8E, 0xA4, 0x73, 0x93, 0xAA, 0x66, 0x37 + }, + { + 0x4F, 0xE1, 0x81, 0xF5, 0x4A, 0xD6, 0x3A, 0x29, + 0x83, 0xFE, 0xAA, 0xF7, 0x7D, 0x1E, 0x72, 0x35, + 0xC2, 0xBE, 0xB1, 0x7F, 0xA3, 0x28, 0xB6, 0xD9, + 0x50, 0x5B, 0xDA, 0x32, 0x7D, 0xF1, 0x9F, 0xC3, + 0x7F, 0x02, 0xC4, 0xB6, 0xF0, 0x36, 0x8C, 0xE2, + 0x31, 0x47, 0x31, 0x3A, 0x8E, 0x57, 0x38, 0xB5, + 0xFA, 0x2A, 0x95, 0xB2, 0x9D, 0xE1, 0xC7, 0xF8, + 0x26, 0x4E, 0xB7, 0x7B, 0x69, 0xF5, 0x85, 0xCD + }, + { + 0xF2, 0x28, 0x77, 0x3C, 0xE3, 0xF3, 0xA4, 0x2B, + 0x5F, 0x14, 0x4D, 0x63, 0x23, 0x7A, 0x72, 0xD9, + 0x96, 0x93, 0xAD, 0xB8, 0x83, 0x7D, 0x0E, 0x11, + 0x2A, 0x8A, 0x0F, 0x8F, 0xFF, 0xF2, 0xC3, 0x62, + 0x85, 0x7A, 0xC4, 0x9C, 0x11, 0xEC, 0x74, 0x0D, + 0x15, 0x00, 0x74, 0x9D, 0xAC, 0x9B, 0x1F, 0x45, + 0x48, 0x10, 0x8B, 0xF3, 0x15, 0x57, 0x94, 0xDC, + 0xC9, 0xE4, 0x08, 0x28, 0x49, 0xE2, 0xB8, 0x5B + }, + { + 0x96, 0x24, 0x52, 0xA8, 0x45, 0x5C, 0xC5, 0x6C, + 0x85, 0x11, 0x31, 0x7E, 0x3B, 0x1F, 0x3B, 0x2C, + 0x37, 0xDF, 0x75, 0xF5, 0x88, 0xE9, 0x43, 0x25, + 0xFD, 0xD7, 0x70, 0x70, 0x35, 0x9C, 0xF6, 0x3A, + 0x9A, 0xE6, 0xE9, 0x30, 0x93, 0x6F, 0xDF, 0x8E, + 0x1E, 0x08, 0xFF, 0xCA, 0x44, 0x0C, 0xFB, 0x72, + 0xC2, 0x8F, 0x06, 0xD8, 0x9A, 0x21, 0x51, 0xD1, + 0xC4, 0x6C, 0xD5, 0xB2, 0x68, 0xEF, 0x85, 0x63 + }, + { + 0x43, 0xD4, 0x4B, 0xFA, 0x18, 0x76, 0x8C, 0x59, + 0x89, 0x6B, 0xF7, 0xED, 0x17, 0x65, 0xCB, 0x2D, + 0x14, 0xAF, 0x8C, 0x26, 0x02, 0x66, 0x03, 0x90, + 0x99, 0xB2, 0x5A, 0x60, 0x3E, 0x4D, 0xDC, 0x50, + 0x39, 0xD6, 0xEF, 0x3A, 0x91, 0x84, 0x7D, 0x10, + 0x88, 0xD4, 0x01, 0xC0, 0xC7, 0xE8, 0x47, 0x78, + 0x1A, 0x8A, 0x59, 0x0D, 0x33, 0xA3, 0xC6, 0xCB, + 0x4D, 0xF0, 0xFA, 0xB1, 0xC2, 0xF2, 0x23, 0x55 + }, + { + 0xDC, 0xFF, 0xA9, 0xD5, 0x8C, 0x2A, 0x4C, 0xA2, + 0xCD, 0xBB, 0x0C, 0x7A, 0xA4, 0xC4, 0xC1, 0xD4, + 0x51, 0x65, 0x19, 0x00, 0x89, 0xF4, 0xE9, 0x83, + 0xBB, 0x1C, 0x2C, 0xAB, 0x4A, 0xAE, 0xFF, 0x1F, + 0xA2, 0xB5, 0xEE, 0x51, 0x6F, 0xEC, 0xD7, 0x80, + 0x54, 0x02, 0x40, 0xBF, 0x37, 0xE5, 0x6C, 0x8B, + 0xCC, 0xA7, 0xFA, 0xB9, 0x80, 0xE1, 0xE6, 0x1C, + 0x94, 0x00, 0xD8, 0xA9, 0xA5, 0xB1, 0x4A, 0xC6 + }, + { + 0x6F, 0xBF, 0x31, 0xB4, 0x5A, 0xB0, 0xC0, 0xB8, + 0xDA, 0xD1, 0xC0, 0xF5, 0xF4, 0x06, 0x13, 0x79, + 0x91, 0x2D, 0xDE, 0x5A, 0xA9, 0x22, 0x09, 0x9A, + 0x03, 0x0B, 0x72, 0x5C, 0x73, 0x34, 0x6C, 0x52, + 0x42, 0x91, 0xAD, 0xEF, 0x89, 0xD2, 0xF6, 0xFD, + 0x8D, 0xFC, 0xDA, 0x6D, 0x07, 0xDA, 0xD8, 0x11, + 0xA9, 0x31, 0x45, 0x36, 0xC2, 0x91, 0x5E, 0xD4, + 0x5D, 0xA3, 0x49, 0x47, 0xE8, 0x3D, 0xE3, 0x4E + }, + { + 0xA0, 0xC6, 0x5B, 0xDD, 0xDE, 0x8A, 0xDE, 0xF5, + 0x72, 0x82, 0xB0, 0x4B, 0x11, 0xE7, 0xBC, 0x8A, + 0xAB, 0x10, 0x5B, 0x99, 0x23, 0x1B, 0x75, 0x0C, + 0x02, 0x1F, 0x4A, 0x73, 0x5C, 0xB1, 0xBC, 0xFA, + 0xB8, 0x75, 0x53, 0xBB, 0xA3, 0xAB, 0xB0, 0xC3, + 0xE6, 0x4A, 0x0B, 0x69, 0x55, 0x28, 0x51, 0x85, + 0xA0, 0xBD, 0x35, 0xFB, 0x8C, 0xFD, 0xE5, 0x57, + 0x32, 0x9B, 0xEB, 0xB1, 0xF6, 0x29, 0xEE, 0x93 + }, + { + 0xF9, 0x9D, 0x81, 0x55, 0x50, 0x55, 0x8E, 0x81, + 0xEC, 0xA2, 0xF9, 0x67, 0x18, 0xAE, 0xD1, 0x0D, + 0x86, 0xF3, 0xF1, 0xCF, 0xB6, 0x75, 0xCC, 0xE0, + 0x6B, 0x0E, 0xFF, 0x02, 0xF6, 0x17, 0xC5, 0xA4, + 0x2C, 0x5A, 0xA7, 0x60, 0x27, 0x0F, 0x26, 0x79, + 0xDA, 0x26, 0x77, 0xC5, 0xAE, 0xB9, 0x4F, 0x11, + 0x42, 0x27, 0x7F, 0x21, 0xC7, 0xF7, 0x9F, 0x3C, + 0x4F, 0x0C, 0xCE, 0x4E, 0xD8, 0xEE, 0x62, 0xB1 + }, + { + 0x95, 0x39, 0x1D, 0xA8, 0xFC, 0x7B, 0x91, 0x7A, + 0x20, 0x44, 0xB3, 0xD6, 0xF5, 0x37, 0x4E, 0x1C, + 0xA0, 0x72, 0xB4, 0x14, 0x54, 0xD5, 0x72, 0xC7, + 0x35, 0x6C, 0x05, 0xFD, 0x4B, 0xC1, 0xE0, 0xF4, + 0x0B, 0x8B, 0xB8, 0xB4, 0xA9, 0xF6, 0xBC, 0xE9, + 0xBE, 0x2C, 0x46, 0x23, 0xC3, 0x99, 0xB0, 0xDC, + 0xA0, 0xDA, 0xB0, 0x5C, 0xB7, 0x28, 0x1B, 0x71, + 0xA2, 0x1B, 0x0E, 0xBC, 0xD9, 0xE5, 0x56, 0x70 + }, + { + 0x04, 0xB9, 0xCD, 0x3D, 0x20, 0xD2, 0x21, 0xC0, + 0x9A, 0xC8, 0x69, 0x13, 0xD3, 0xDC, 0x63, 0x04, + 0x19, 0x89, 0xA9, 0xA1, 0xE6, 0x94, 0xF1, 0xE6, + 0x39, 0xA3, 0xBA, 0x7E, 0x45, 0x18, 0x40, 0xF7, + 0x50, 0xC2, 0xFC, 0x19, 0x1D, 0x56, 0xAD, 0x61, + 0xF2, 0xE7, 0x93, 0x6B, 0xC0, 0xAC, 0x8E, 0x09, + 0x4B, 0x60, 0xCA, 0xEE, 0xD8, 0x78, 0xC1, 0x87, + 0x99, 0x04, 0x54, 0x02, 0xD6, 0x1C, 0xEA, 0xF9 + }, + { + 0xEC, 0x0E, 0x0E, 0xF7, 0x07, 0xE4, 0xED, 0x6C, + 0x0C, 0x66, 0xF9, 0xE0, 0x89, 0xE4, 0x95, 0x4B, + 0x05, 0x80, 0x30, 0xD2, 0xDD, 0x86, 0x39, 0x8F, + 0xE8, 0x40, 0x59, 0x63, 0x1F, 0x9E, 0xE5, 0x91, + 0xD9, 0xD7, 0x73, 0x75, 0x35, 0x51, 0x49, 0x17, + 0x8C, 0x0C, 0xF8, 0xF8, 0xE7, 0xC4, 0x9E, 0xD2, + 0xA5, 0xE4, 0xF9, 0x54, 0x88, 0xA2, 0x24, 0x70, + 0x67, 0xC2, 0x08, 0x51, 0x0F, 0xAD, 0xC4, 0x4C + }, + { + 0x9A, 0x37, 0xCC, 0xE2, 0x73, 0xB7, 0x9C, 0x09, + 0x91, 0x36, 0x77, 0x51, 0x0E, 0xAF, 0x76, 0x88, + 0xE8, 0x9B, 0x33, 0x14, 0xD3, 0x53, 0x2F, 0xD2, + 0x76, 0x4C, 0x39, 0xDE, 0x02, 0x2A, 0x29, 0x45, + 0xB5, 0x71, 0x0D, 0x13, 0x51, 0x7A, 0xF8, 0xDD, + 0xC0, 0x31, 0x66, 0x24, 0xE7, 0x3B, 0xEC, 0x1C, + 0xE6, 0x7D, 0xF1, 0x52, 0x28, 0x30, 0x20, 0x36, + 0xF3, 0x30, 0xAB, 0x0C, 0xB4, 0xD2, 0x18, 0xDD + }, + { + 0x4C, 0xF9, 0xBB, 0x8F, 0xB3, 0xD4, 0xDE, 0x8B, + 0x38, 0xB2, 0xF2, 0x62, 0xD3, 0xC4, 0x0F, 0x46, + 0xDF, 0xE7, 0x47, 0xE8, 0xFC, 0x0A, 0x41, 0x4C, + 0x19, 0x3D, 0x9F, 0xCF, 0x75, 0x31, 0x06, 0xCE, + 0x47, 0xA1, 0x8F, 0x17, 0x2F, 0x12, 0xE8, 0xA2, + 0xF1, 0xC2, 0x67, 0x26, 0x54, 0x53, 0x58, 0xE5, + 0xEE, 0x28, 0xC9, 0xE2, 0x21, 0x3A, 0x87, 0x87, + 0xAA, 0xFB, 0xC5, 0x16, 0xD2, 0x34, 0x31, 0x52 + }, + { + 0x64, 0xE0, 0xC6, 0x3A, 0xF9, 0xC8, 0x08, 0xFD, + 0x89, 0x31, 0x37, 0x12, 0x98, 0x67, 0xFD, 0x91, + 0x93, 0x9D, 0x53, 0xF2, 0xAF, 0x04, 0xBE, 0x4F, + 0xA2, 0x68, 0x00, 0x61, 0x00, 0x06, 0x9B, 0x2D, + 0x69, 0xDA, 0xA5, 0xC5, 0xD8, 0xED, 0x7F, 0xDD, + 0xCB, 0x2A, 0x70, 0xEE, 0xEC, 0xDF, 0x2B, 0x10, + 0x5D, 0xD4, 0x6A, 0x1E, 0x3B, 0x73, 0x11, 0x72, + 0x8F, 0x63, 0x9A, 0xB4, 0x89, 0x32, 0x6B, 0xC9 + }, + { + 0x5E, 0x9C, 0x93, 0x15, 0x8D, 0x65, 0x9B, 0x2D, + 0xEF, 0x06, 0xB0, 0xC3, 0xC7, 0x56, 0x50, 0x45, + 0x54, 0x26, 0x62, 0xD6, 0xEE, 0xE8, 0xA9, 0x6A, + 0x89, 0xB7, 0x8A, 0xDE, 0x09, 0xFE, 0x8B, 0x3D, + 0xCC, 0x09, 0x6D, 0x4F, 0xE4, 0x88, 0x15, 0xD8, + 0x8D, 0x8F, 0x82, 0x62, 0x01, 0x56, 0x60, 0x2A, + 0xF5, 0x41, 0x95, 0x5E, 0x1F, 0x6C, 0xA3, 0x0D, + 0xCE, 0x14, 0xE2, 0x54, 0xC3, 0x26, 0xB8, 0x8F + }, + { + 0x77, 0x75, 0xDF, 0xF8, 0x89, 0x45, 0x8D, 0xD1, + 0x1A, 0xEF, 0x41, 0x72, 0x76, 0x85, 0x3E, 0x21, + 0x33, 0x5E, 0xB8, 0x8E, 0x4D, 0xEC, 0x9C, 0xFB, + 0x4E, 0x9E, 0xDB, 0x49, 0x82, 0x00, 0x88, 0x55, + 0x1A, 0x2C, 0xA6, 0x03, 0x39, 0xF1, 0x20, 0x66, + 0x10, 0x11, 0x69, 0xF0, 0xDF, 0xE8, 0x4B, 0x09, + 0x8F, 0xDD, 0xB1, 0x48, 0xD9, 0xDA, 0x6B, 0x3D, + 0x61, 0x3D, 0xF2, 0x63, 0x88, 0x9A, 0xD6, 0x4B + }, + { + 0xF0, 0xD2, 0x80, 0x5A, 0xFB, 0xB9, 0x1F, 0x74, + 0x39, 0x51, 0x35, 0x1A, 0x6D, 0x02, 0x4F, 0x93, + 0x53, 0xA2, 0x3C, 0x7C, 0xE1, 0xFC, 0x2B, 0x05, + 0x1B, 0x3A, 0x8B, 0x96, 0x8C, 0x23, 0x3F, 0x46, + 0xF5, 0x0F, 0x80, 0x6E, 0xCB, 0x15, 0x68, 0xFF, + 0xAA, 0x0B, 0x60, 0x66, 0x1E, 0x33, 0x4B, 0x21, + 0xDD, 0xE0, 0x4F, 0x8F, 0xA1, 0x55, 0xAC, 0x74, + 0x0E, 0xEB, 0x42, 0xE2, 0x0B, 0x60, 0xD7, 0x64 + }, + { + 0x86, 0xA2, 0xAF, 0x31, 0x6E, 0x7D, 0x77, 0x54, + 0x20, 0x1B, 0x94, 0x2E, 0x27, 0x53, 0x64, 0xAC, + 0x12, 0xEA, 0x89, 0x62, 0xAB, 0x5B, 0xD8, 0xD7, + 0xFB, 0x27, 0x6D, 0xC5, 0xFB, 0xFF, 0xC8, 0xF9, + 0xA2, 0x8C, 0xAE, 0x4E, 0x48, 0x67, 0xDF, 0x67, + 0x80, 0xD9, 0xB7, 0x25, 0x24, 0x16, 0x09, 0x27, + 0xC8, 0x55, 0xDA, 0x5B, 0x60, 0x78, 0xE0, 0xB5, + 0x54, 0xAA, 0x91, 0xE3, 0x1C, 0xB9, 0xCA, 0x1D + }, + { + 0x10, 0xBD, 0xF0, 0xCA, 0xA0, 0x80, 0x27, 0x05, + 0xE7, 0x06, 0x36, 0x9B, 0xAF, 0x8A, 0x3F, 0x79, + 0xD7, 0x2C, 0x0A, 0x03, 0xA8, 0x06, 0x75, 0xA7, + 0xBB, 0xB0, 0x0B, 0xE3, 0xA4, 0x5E, 0x51, 0x64, + 0x24, 0xD1, 0xEE, 0x88, 0xEF, 0xB5, 0x6F, 0x6D, + 0x57, 0x77, 0x54, 0x5A, 0xE6, 0xE2, 0x77, 0x65, + 0xC3, 0xA8, 0xF5, 0xE4, 0x93, 0xFC, 0x30, 0x89, + 0x15, 0x63, 0x89, 0x33, 0xA1, 0xDF, 0xEE, 0x55 + }, + { + 0xB0, 0x17, 0x81, 0x09, 0x2B, 0x17, 0x48, 0x45, + 0x9E, 0x2E, 0x4E, 0xC1, 0x78, 0x69, 0x66, 0x27, + 0xBF, 0x4E, 0xBA, 0xFE, 0xBB, 0xA7, 0x74, 0xEC, + 0xF0, 0x18, 0xB7, 0x9A, 0x68, 0xAE, 0xB8, 0x49, + 0x17, 0xBF, 0x0B, 0x84, 0xBB, 0x79, 0xD1, 0x7B, + 0x74, 0x31, 0x51, 0x14, 0x4C, 0xD6, 0x6B, 0x7B, + 0x33, 0xA4, 0xB9, 0xE5, 0x2C, 0x76, 0xC4, 0xE1, + 0x12, 0x05, 0x0F, 0xF5, 0x38, 0x5B, 0x7F, 0x0B + }, + { + 0xC6, 0xDB, 0xC6, 0x1D, 0xEC, 0x6E, 0xAE, 0xAC, + 0x81, 0xE3, 0xD5, 0xF7, 0x55, 0x20, 0x3C, 0x8E, + 0x22, 0x05, 0x51, 0x53, 0x4A, 0x0B, 0x2F, 0xD1, + 0x05, 0xA9, 0x18, 0x89, 0x94, 0x5A, 0x63, 0x85, + 0x50, 0x20, 0x4F, 0x44, 0x09, 0x3D, 0xD9, 0x98, + 0xC0, 0x76, 0x20, 0x5D, 0xFF, 0xAD, 0x70, 0x3A, + 0x0E, 0x5C, 0xD3, 0xC7, 0xF4, 0x38, 0xA7, 0xE6, + 0x34, 0xCD, 0x59, 0xFE, 0xDE, 0xDB, 0x53, 0x9E + }, + { + 0xEB, 0xA5, 0x1A, 0xCF, 0xFB, 0x4C, 0xEA, 0x31, + 0xDB, 0x4B, 0x8D, 0x87, 0xE9, 0xBF, 0x7D, 0xD4, + 0x8F, 0xE9, 0x7B, 0x02, 0x53, 0xAE, 0x67, 0xAA, + 0x58, 0x0F, 0x9A, 0xC4, 0xA9, 0xD9, 0x41, 0xF2, + 0xBE, 0xA5, 0x18, 0xEE, 0x28, 0x68, 0x18, 0xCC, + 0x9F, 0x63, 0x3F, 0x2A, 0x3B, 0x9F, 0xB6, 0x8E, + 0x59, 0x4B, 0x48, 0xCD, 0xD6, 0xD5, 0x15, 0xBF, + 0x1D, 0x52, 0xBA, 0x6C, 0x85, 0xA2, 0x03, 0xA7 + }, + { + 0x86, 0x22, 0x1F, 0x3A, 0xDA, 0x52, 0x03, 0x7B, + 0x72, 0x22, 0x4F, 0x10, 0x5D, 0x79, 0x99, 0x23, + 0x1C, 0x5E, 0x55, 0x34, 0xD0, 0x3D, 0xA9, 0xD9, + 0xC0, 0xA1, 0x2A, 0xCB, 0x68, 0x46, 0x0C, 0xD3, + 0x75, 0xDA, 0xF8, 0xE2, 0x43, 0x86, 0x28, 0x6F, + 0x96, 0x68, 0xF7, 0x23, 0x26, 0xDB, 0xF9, 0x9B, + 0xA0, 0x94, 0x39, 0x24, 0x37, 0xD3, 0x98, 0xE9, + 0x5B, 0xB8, 0x16, 0x1D, 0x71, 0x7F, 0x89, 0x91 + }, + { + 0x55, 0x95, 0xE0, 0x5C, 0x13, 0xA7, 0xEC, 0x4D, + 0xC8, 0xF4, 0x1F, 0xB7, 0x0C, 0xB5, 0x0A, 0x71, + 0xBC, 0xE1, 0x7C, 0x02, 0x4F, 0xF6, 0xDE, 0x7A, + 0xF6, 0x18, 0xD0, 0xCC, 0x4E, 0x9C, 0x32, 0xD9, + 0x57, 0x0D, 0x6D, 0x3E, 0xA4, 0x5B, 0x86, 0x52, + 0x54, 0x91, 0x03, 0x0C, 0x0D, 0x8F, 0x2B, 0x18, + 0x36, 0xD5, 0x77, 0x8C, 0x1C, 0xE7, 0x35, 0xC1, + 0x77, 0x07, 0xDF, 0x36, 0x4D, 0x05, 0x43, 0x47 + }, + { + 0xCE, 0x0F, 0x4F, 0x6A, 0xCA, 0x89, 0x59, 0x0A, + 0x37, 0xFE, 0x03, 0x4D, 0xD7, 0x4D, 0xD5, 0xFA, + 0x65, 0xEB, 0x1C, 0xBD, 0x0A, 0x41, 0x50, 0x8A, + 0xAD, 0xDC, 0x09, 0x35, 0x1A, 0x3C, 0xEA, 0x6D, + 0x18, 0xCB, 0x21, 0x89, 0xC5, 0x4B, 0x70, 0x0C, + 0x00, 0x9F, 0x4C, 0xBF, 0x05, 0x21, 0xC7, 0xEA, + 0x01, 0xBE, 0x61, 0xC5, 0xAE, 0x09, 0xCB, 0x54, + 0xF2, 0x7B, 0xC1, 0xB4, 0x4D, 0x65, 0x8C, 0x82 + }, + { + 0x7E, 0xE8, 0x0B, 0x06, 0xA2, 0x15, 0xA3, 0xBC, + 0xA9, 0x70, 0xC7, 0x7C, 0xDA, 0x87, 0x61, 0x82, + 0x2B, 0xC1, 0x03, 0xD4, 0x4F, 0xA4, 0xB3, 0x3F, + 0x4D, 0x07, 0xDC, 0xB9, 0x97, 0xE3, 0x6D, 0x55, + 0x29, 0x8B, 0xCE, 0xAE, 0x12, 0x24, 0x1B, 0x3F, + 0xA0, 0x7F, 0xA6, 0x3B, 0xE5, 0x57, 0x60, 0x68, + 0xDA, 0x38, 0x7B, 0x8D, 0x58, 0x59, 0xAE, 0xAB, + 0x70, 0x13, 0x69, 0x84, 0x8B, 0x17, 0x6D, 0x42 + }, + { + 0x94, 0x0A, 0x84, 0xB6, 0xA8, 0x4D, 0x10, 0x9A, + 0xAB, 0x20, 0x8C, 0x02, 0x4C, 0x6C, 0xE9, 0x64, + 0x76, 0x76, 0xBA, 0x0A, 0xAA, 0x11, 0xF8, 0x6D, + 0xBB, 0x70, 0x18, 0xF9, 0xFD, 0x22, 0x20, 0xA6, + 0xD9, 0x01, 0xA9, 0x02, 0x7F, 0x9A, 0xBC, 0xF9, + 0x35, 0x37, 0x27, 0x27, 0xCB, 0xF0, 0x9E, 0xBD, + 0x61, 0xA2, 0xA2, 0xEE, 0xB8, 0x76, 0x53, 0xE8, + 0xEC, 0xAD, 0x1B, 0xAB, 0x85, 0xDC, 0x83, 0x27 + }, + { + 0x20, 0x20, 0xB7, 0x82, 0x64, 0xA8, 0x2D, 0x9F, + 0x41, 0x51, 0x14, 0x1A, 0xDB, 0xA8, 0xD4, 0x4B, + 0xF2, 0x0C, 0x5E, 0xC0, 0x62, 0xEE, 0xE9, 0xB5, + 0x95, 0xA1, 0x1F, 0x9E, 0x84, 0x90, 0x1B, 0xF1, + 0x48, 0xF2, 0x98, 0xE0, 0xC9, 0xF8, 0x77, 0x7D, + 0xCD, 0xBC, 0x7C, 0xC4, 0x67, 0x0A, 0xAC, 0x35, + 0x6C, 0xC2, 0xAD, 0x8C, 0xCB, 0x16, 0x29, 0xF1, + 0x6F, 0x6A, 0x76, 0xBC, 0xEF, 0xBE, 0xE7, 0x60 + }, + { + 0xD1, 0xB8, 0x97, 0xB0, 0xE0, 0x75, 0xBA, 0x68, + 0xAB, 0x57, 0x2A, 0xDF, 0x9D, 0x9C, 0x43, 0x66, + 0x63, 0xE4, 0x3E, 0xB3, 0xD8, 0xE6, 0x2D, 0x92, + 0xFC, 0x49, 0xC9, 0xBE, 0x21, 0x4E, 0x6F, 0x27, + 0x87, 0x3F, 0xE2, 0x15, 0xA6, 0x51, 0x70, 0xE6, + 0xBE, 0xA9, 0x02, 0x40, 0x8A, 0x25, 0xB4, 0x95, + 0x06, 0xF4, 0x7B, 0xAB, 0xD0, 0x7C, 0xEC, 0xF7, + 0x11, 0x3E, 0xC1, 0x0C, 0x5D, 0xD3, 0x12, 0x52 + }, + { + 0xB1, 0x4D, 0x0C, 0x62, 0xAB, 0xFA, 0x46, 0x9A, + 0x35, 0x71, 0x77, 0xE5, 0x94, 0xC1, 0x0C, 0x19, + 0x42, 0x43, 0xED, 0x20, 0x25, 0xAB, 0x8A, 0xA5, + 0xAD, 0x2F, 0xA4, 0x1A, 0xD3, 0x18, 0xE0, 0xFF, + 0x48, 0xCD, 0x5E, 0x60, 0xBE, 0xC0, 0x7B, 0x13, + 0x63, 0x4A, 0x71, 0x1D, 0x23, 0x26, 0xE4, 0x88, + 0xA9, 0x85, 0xF3, 0x1E, 0x31, 0x15, 0x33, 0x99, + 0xE7, 0x30, 0x88, 0xEF, 0xC8, 0x6A, 0x5C, 0x55 + }, + { + 0x41, 0x69, 0xC5, 0xCC, 0x80, 0x8D, 0x26, 0x97, + 0xDC, 0x2A, 0x82, 0x43, 0x0D, 0xC2, 0x3E, 0x3C, + 0xD3, 0x56, 0xDC, 0x70, 0xA9, 0x45, 0x66, 0x81, + 0x05, 0x02, 0xB8, 0xD6, 0x55, 0xB3, 0x9A, 0xBF, + 0x9E, 0x7F, 0x90, 0x2F, 0xE7, 0x17, 0xE0, 0x38, + 0x92, 0x19, 0x85, 0x9E, 0x19, 0x45, 0xDF, 0x1A, + 0xF6, 0xAD, 0xA4, 0x2E, 0x4C, 0xCD, 0xA5, 0x5A, + 0x19, 0x7B, 0x71, 0x00, 0xA3, 0x0C, 0x30, 0xA1 + }, + { + 0x25, 0x8A, 0x4E, 0xDB, 0x11, 0x3D, 0x66, 0xC8, + 0x39, 0xC8, 0xB1, 0xC9, 0x1F, 0x15, 0xF3, 0x5A, + 0xDE, 0x60, 0x9F, 0x11, 0xCD, 0x7F, 0x86, 0x81, + 0xA4, 0x04, 0x5B, 0x9F, 0xEF, 0x7B, 0x0B, 0x24, + 0xC8, 0x2C, 0xDA, 0x06, 0xA5, 0xF2, 0x06, 0x7B, + 0x36, 0x88, 0x25, 0xE3, 0x91, 0x4E, 0x53, 0xD6, + 0x94, 0x8E, 0xDE, 0x92, 0xEF, 0xD6, 0xE8, 0x38, + 0x7F, 0xA2, 0xE5, 0x37, 0x23, 0x9B, 0x5B, 0xEE + }, + { + 0x79, 0xD2, 0xD8, 0x69, 0x6D, 0x30, 0xF3, 0x0F, + 0xB3, 0x46, 0x57, 0x76, 0x11, 0x71, 0xA1, 0x1E, + 0x6C, 0x3F, 0x1E, 0x64, 0xCB, 0xE7, 0xBE, 0xBE, + 0xE1, 0x59, 0xCB, 0x95, 0xBF, 0xAF, 0x81, 0x2B, + 0x4F, 0x41, 0x1E, 0x2F, 0x26, 0xD9, 0xC4, 0x21, + 0xDC, 0x2C, 0x28, 0x4A, 0x33, 0x42, 0xD8, 0x23, + 0xEC, 0x29, 0x38, 0x49, 0xE4, 0x2D, 0x1E, 0x46, + 0xB0, 0xA4, 0xAC, 0x1E, 0x3C, 0x86, 0xAB, 0xAA + }, + { + 0x8B, 0x94, 0x36, 0x01, 0x0D, 0xC5, 0xDE, 0xE9, + 0x92, 0xAE, 0x38, 0xAE, 0xA9, 0x7F, 0x2C, 0xD6, + 0x3B, 0x94, 0x6D, 0x94, 0xFE, 0xDD, 0x2E, 0xC9, + 0x67, 0x1D, 0xCD, 0xE3, 0xBD, 0x4C, 0xE9, 0x56, + 0x4D, 0x55, 0x5C, 0x66, 0xC1, 0x5B, 0xB2, 0xB9, + 0x00, 0xDF, 0x72, 0xED, 0xB6, 0xB8, 0x91, 0xEB, + 0xCA, 0xDF, 0xEF, 0xF6, 0x3C, 0x9E, 0xA4, 0x03, + 0x6A, 0x99, 0x8B, 0xE7, 0x97, 0x39, 0x81, 0xE7 + }, + { + 0xC8, 0xF6, 0x8E, 0x69, 0x6E, 0xD2, 0x82, 0x42, + 0xBF, 0x99, 0x7F, 0x5B, 0x3B, 0x34, 0x95, 0x95, + 0x08, 0xE4, 0x2D, 0x61, 0x38, 0x10, 0xF1, 0xE2, + 0xA4, 0x35, 0xC9, 0x6E, 0xD2, 0xFF, 0x56, 0x0C, + 0x70, 0x22, 0xF3, 0x61, 0xA9, 0x23, 0x4B, 0x98, + 0x37, 0xFE, 0xEE, 0x90, 0xBF, 0x47, 0x92, 0x2E, + 0xE0, 0xFD, 0x5F, 0x8D, 0xDF, 0x82, 0x37, 0x18, + 0xD8, 0x6D, 0x1E, 0x16, 0xC6, 0x09, 0x00, 0x71 + }, + { + 0xB0, 0x2D, 0x3E, 0xEE, 0x48, 0x60, 0xD5, 0x86, + 0x8B, 0x2C, 0x39, 0xCE, 0x39, 0xBF, 0xE8, 0x10, + 0x11, 0x29, 0x05, 0x64, 0xDD, 0x67, 0x8C, 0x85, + 0xE8, 0x78, 0x3F, 0x29, 0x30, 0x2D, 0xFC, 0x13, + 0x99, 0xBA, 0x95, 0xB6, 0xB5, 0x3C, 0xD9, 0xEB, + 0xBF, 0x40, 0x0C, 0xCA, 0x1D, 0xB0, 0xAB, 0x67, + 0xE1, 0x9A, 0x32, 0x5F, 0x2D, 0x11, 0x58, 0x12, + 0xD2, 0x5D, 0x00, 0x97, 0x8A, 0xD1, 0xBC, 0xA4 + }, + { + 0x76, 0x93, 0xEA, 0x73, 0xAF, 0x3A, 0xC4, 0xDA, + 0xD2, 0x1C, 0xA0, 0xD8, 0xDA, 0x85, 0xB3, 0x11, + 0x8A, 0x7D, 0x1C, 0x60, 0x24, 0xCF, 0xAF, 0x55, + 0x76, 0x99, 0x86, 0x82, 0x17, 0xBC, 0x0C, 0x2F, + 0x44, 0xA1, 0x99, 0xBC, 0x6C, 0x0E, 0xDD, 0x51, + 0x97, 0x98, 0xBA, 0x05, 0xBD, 0x5B, 0x1B, 0x44, + 0x84, 0x34, 0x6A, 0x47, 0xC2, 0xCA, 0xDF, 0x6B, + 0xF3, 0x0B, 0x78, 0x5C, 0xC8, 0x8B, 0x2B, 0xAF + }, + { + 0xA0, 0xE5, 0xC1, 0xC0, 0x03, 0x1C, 0x02, 0xE4, + 0x8B, 0x7F, 0x09, 0xA5, 0xE8, 0x96, 0xEE, 0x9A, + 0xEF, 0x2F, 0x17, 0xFC, 0x9E, 0x18, 0xE9, 0x97, + 0xD7, 0xF6, 0xCA, 0xC7, 0xAE, 0x31, 0x64, 0x22, + 0xC2, 0xB1, 0xE7, 0x79, 0x84, 0xE5, 0xF3, 0xA7, + 0x3C, 0xB4, 0x5D, 0xEE, 0xD5, 0xD3, 0xF8, 0x46, + 0x00, 0x10, 0x5E, 0x6E, 0xE3, 0x8F, 0x2D, 0x09, + 0x0C, 0x7D, 0x04, 0x42, 0xEA, 0x34, 0xC4, 0x6D + }, + { + 0x41, 0xDA, 0xA6, 0xAD, 0xCF, 0xDB, 0x69, 0xF1, + 0x44, 0x0C, 0x37, 0xB5, 0x96, 0x44, 0x01, 0x65, + 0xC1, 0x5A, 0xDA, 0x59, 0x68, 0x13, 0xE2, 0xE2, + 0x2F, 0x06, 0x0F, 0xCD, 0x55, 0x1F, 0x24, 0xDE, + 0xE8, 0xE0, 0x4B, 0xA6, 0x89, 0x03, 0x87, 0x88, + 0x6C, 0xEE, 0xC4, 0xA7, 0xA0, 0xD7, 0xFC, 0x6B, + 0x44, 0x50, 0x63, 0x92, 0xEC, 0x38, 0x22, 0xC0, + 0xD8, 0xC1, 0xAC, 0xFC, 0x7D, 0x5A, 0xEB, 0xE8 + }, + { + 0x14, 0xD4, 0xD4, 0x0D, 0x59, 0x84, 0xD8, 0x4C, + 0x5C, 0xF7, 0x52, 0x3B, 0x77, 0x98, 0xB2, 0x54, + 0xE2, 0x75, 0xA3, 0xA8, 0xCC, 0x0A, 0x1B, 0xD0, + 0x6E, 0xBC, 0x0B, 0xEE, 0x72, 0x68, 0x56, 0xAC, + 0xC3, 0xCB, 0xF5, 0x16, 0xFF, 0x66, 0x7C, 0xDA, + 0x20, 0x58, 0xAD, 0x5C, 0x34, 0x12, 0x25, 0x44, + 0x60, 0xA8, 0x2C, 0x92, 0x18, 0x70, 0x41, 0x36, + 0x3C, 0xC7, 0x7A, 0x4D, 0xC2, 0x15, 0xE4, 0x87 + }, + { + 0xD0, 0xE7, 0xA1, 0xE2, 0xB9, 0xA4, 0x47, 0xFE, + 0xE8, 0x3E, 0x22, 0x77, 0xE9, 0xFF, 0x80, 0x10, + 0xC2, 0xF3, 0x75, 0xAE, 0x12, 0xFA, 0x7A, 0xAA, + 0x8C, 0xA5, 0xA6, 0x31, 0x78, 0x68, 0xA2, 0x6A, + 0x36, 0x7A, 0x0B, 0x69, 0xFB, 0xC1, 0xCF, 0x32, + 0xA5, 0x5D, 0x34, 0xEB, 0x37, 0x06, 0x63, 0x01, + 0x6F, 0x3D, 0x21, 0x10, 0x23, 0x0E, 0xBA, 0x75, + 0x40, 0x28, 0xA5, 0x6F, 0x54, 0xAC, 0xF5, 0x7C + }, + { + 0xE7, 0x71, 0xAA, 0x8D, 0xB5, 0xA3, 0xE0, 0x43, + 0xE8, 0x17, 0x8F, 0x39, 0xA0, 0x85, 0x7B, 0xA0, + 0x4A, 0x3F, 0x18, 0xE4, 0xAA, 0x05, 0x74, 0x3C, + 0xF8, 0xD2, 0x22, 0xB0, 0xB0, 0x95, 0x82, 0x53, + 0x50, 0xBA, 0x42, 0x2F, 0x63, 0x38, 0x2A, 0x23, + 0xD9, 0x2E, 0x41, 0x49, 0x07, 0x4E, 0x81, 0x6A, + 0x36, 0xC1, 0xCD, 0x28, 0x28, 0x4D, 0x14, 0x62, + 0x67, 0x94, 0x0B, 0x31, 0xF8, 0x81, 0x8E, 0xA2 + }, + { + 0xFE, 0xB4, 0xFD, 0x6F, 0x9E, 0x87, 0xA5, 0x6B, + 0xEF, 0x39, 0x8B, 0x32, 0x84, 0xD2, 0xBD, 0xA5, + 0xB5, 0xB0, 0xE1, 0x66, 0x58, 0x3A, 0x66, 0xB6, + 0x1E, 0x53, 0x84, 0x57, 0xFF, 0x05, 0x84, 0x87, + 0x2C, 0x21, 0xA3, 0x29, 0x62, 0xB9, 0x92, 0x8F, + 0xFA, 0xB5, 0x8D, 0xE4, 0xAF, 0x2E, 0xDD, 0x4E, + 0x15, 0xD8, 0xB3, 0x55, 0x70, 0x52, 0x32, 0x07, + 0xFF, 0x4E, 0x2A, 0x5A, 0xA7, 0x75, 0x4C, 0xAA + }, + { + 0x46, 0x2F, 0x17, 0xBF, 0x00, 0x5F, 0xB1, 0xC1, + 0xB9, 0xE6, 0x71, 0x77, 0x9F, 0x66, 0x52, 0x09, + 0xEC, 0x28, 0x73, 0xE3, 0xE4, 0x11, 0xF9, 0x8D, + 0xAB, 0xF2, 0x40, 0xA1, 0xD5, 0xEC, 0x3F, 0x95, + 0xCE, 0x67, 0x96, 0xB6, 0xFC, 0x23, 0xFE, 0x17, + 0x19, 0x03, 0xB5, 0x02, 0x02, 0x34, 0x67, 0xDE, + 0xC7, 0x27, 0x3F, 0xF7, 0x48, 0x79, 0xB9, 0x29, + 0x67, 0xA2, 0xA4, 0x3A, 0x5A, 0x18, 0x3D, 0x33 + }, + { + 0xD3, 0x33, 0x81, 0x93, 0xB6, 0x45, 0x53, 0xDB, + 0xD3, 0x8D, 0x14, 0x4B, 0xEA, 0x71, 0xC5, 0x91, + 0x5B, 0xB1, 0x10, 0xE2, 0xD8, 0x81, 0x80, 0xDB, + 0xC5, 0xDB, 0x36, 0x4F, 0xD6, 0x17, 0x1D, 0xF3, + 0x17, 0xFC, 0x72, 0x68, 0x83, 0x1B, 0x5A, 0xEF, + 0x75, 0xE4, 0x34, 0x2B, 0x2F, 0xAD, 0x87, 0x97, + 0xBA, 0x39, 0xED, 0xDC, 0xEF, 0x80, 0xE6, 0xEC, + 0x08, 0x15, 0x93, 0x50, 0xB1, 0xAD, 0x69, 0x6D + }, + { + 0xE1, 0x59, 0x0D, 0x58, 0x5A, 0x3D, 0x39, 0xF7, + 0xCB, 0x59, 0x9A, 0xBD, 0x47, 0x90, 0x70, 0x96, + 0x64, 0x09, 0xA6, 0x84, 0x6D, 0x43, 0x77, 0xAC, + 0xF4, 0x47, 0x1D, 0x06, 0x5D, 0x5D, 0xB9, 0x41, + 0x29, 0xCC, 0x9B, 0xE9, 0x25, 0x73, 0xB0, 0x5E, + 0xD2, 0x26, 0xBE, 0x1E, 0x9B, 0x7C, 0xB0, 0xCA, + 0xBE, 0x87, 0x91, 0x85, 0x89, 0xF8, 0x0D, 0xAD, + 0xD4, 0xEF, 0x5E, 0xF2, 0x5A, 0x93, 0xD2, 0x8E + }, + { + 0xF8, 0xF3, 0x72, 0x6A, 0xC5, 0xA2, 0x6C, 0xC8, + 0x01, 0x32, 0x49, 0x3A, 0x6F, 0xED, 0xCB, 0x0E, + 0x60, 0x76, 0x0C, 0x09, 0xCF, 0xC8, 0x4C, 0xAD, + 0x17, 0x81, 0x75, 0x98, 0x68, 0x19, 0x66, 0x5E, + 0x76, 0x84, 0x2D, 0x7B, 0x9F, 0xED, 0xF7, 0x6D, + 0xDD, 0xEB, 0xF5, 0xD3, 0xF5, 0x6F, 0xAA, 0xAD, + 0x44, 0x77, 0x58, 0x7A, 0xF2, 0x16, 0x06, 0xD3, + 0x96, 0xAE, 0x57, 0x0D, 0x8E, 0x71, 0x9A, 0xF2 + }, + { + 0x30, 0x18, 0x60, 0x55, 0xC0, 0x79, 0x49, 0x94, + 0x81, 0x83, 0xC8, 0x50, 0xE9, 0xA7, 0x56, 0xCC, + 0x09, 0x93, 0x7E, 0x24, 0x7D, 0x9D, 0x92, 0x8E, + 0x86, 0x9E, 0x20, 0xBA, 0xFC, 0x3C, 0xD9, 0x72, + 0x17, 0x19, 0xD3, 0x4E, 0x04, 0xA0, 0x89, 0x9B, + 0x92, 0xC7, 0x36, 0x08, 0x45, 0x50, 0x18, 0x68, + 0x86, 0xEF, 0xBA, 0x2E, 0x79, 0x0D, 0x8B, 0xE6, + 0xEB, 0xF0, 0x40, 0xB2, 0x09, 0xC4, 0x39, 0xA4 + }, + { + 0xF3, 0xC4, 0x27, 0x6C, 0xB8, 0x63, 0x63, 0x77, + 0x12, 0xC2, 0x41, 0xC4, 0x44, 0xC5, 0xCC, 0x1E, + 0x35, 0x54, 0xE0, 0xFD, 0xDB, 0x17, 0x4D, 0x03, + 0x58, 0x19, 0xDD, 0x83, 0xEB, 0x70, 0x0B, 0x4C, + 0xE8, 0x8D, 0xF3, 0xAB, 0x38, 0x41, 0xBA, 0x02, + 0x08, 0x5E, 0x1A, 0x99, 0xB4, 0xE1, 0x73, 0x10, + 0xC5, 0x34, 0x10, 0x75, 0xC0, 0x45, 0x8B, 0xA3, + 0x76, 0xC9, 0x5A, 0x68, 0x18, 0xFB, 0xB3, 0xE2 + }, + { + 0x0A, 0xA0, 0x07, 0xC4, 0xDD, 0x9D, 0x58, 0x32, + 0x39, 0x30, 0x40, 0xA1, 0x58, 0x3C, 0x93, 0x0B, + 0xCA, 0x7D, 0xC5, 0xE7, 0x7E, 0xA5, 0x3A, 0xDD, + 0x7E, 0x2B, 0x3F, 0x7C, 0x8E, 0x23, 0x13, 0x68, + 0x04, 0x35, 0x20, 0xD4, 0xA3, 0xEF, 0x53, 0xC9, + 0x69, 0xB6, 0xBB, 0xFD, 0x02, 0x59, 0x46, 0xF6, + 0x32, 0xBD, 0x7F, 0x76, 0x5D, 0x53, 0xC2, 0x10, + 0x03, 0xB8, 0xF9, 0x83, 0xF7, 0x5E, 0x2A, 0x6A + }, + { + 0x08, 0xE9, 0x46, 0x47, 0x20, 0x53, 0x3B, 0x23, + 0xA0, 0x4E, 0xC2, 0x4F, 0x7A, 0xE8, 0xC1, 0x03, + 0x14, 0x5F, 0x76, 0x53, 0x87, 0xD7, 0x38, 0x77, + 0x7D, 0x3D, 0x34, 0x34, 0x77, 0xFD, 0x1C, 0x58, + 0xDB, 0x05, 0x21, 0x42, 0xCA, 0xB7, 0x54, 0xEA, + 0x67, 0x43, 0x78, 0xE1, 0x87, 0x66, 0xC5, 0x35, + 0x42, 0xF7, 0x19, 0x70, 0x17, 0x1C, 0xC4, 0xF8, + 0x16, 0x94, 0x24, 0x6B, 0x71, 0x7D, 0x75, 0x64 + }, + { + 0xD3, 0x7F, 0xF7, 0xAD, 0x29, 0x79, 0x93, 0xE7, + 0xEC, 0x21, 0xE0, 0xF1, 0xB4, 0xB5, 0xAE, 0x71, + 0x9C, 0xDC, 0x83, 0xC5, 0xDB, 0x68, 0x75, 0x27, + 0xF2, 0x75, 0x16, 0xCB, 0xFF, 0xA8, 0x22, 0x88, + 0x8A, 0x68, 0x10, 0xEE, 0x5C, 0x1C, 0xA7, 0xBF, + 0xE3, 0x32, 0x11, 0x19, 0xBE, 0x1A, 0xB7, 0xBF, + 0xA0, 0xA5, 0x02, 0x67, 0x1C, 0x83, 0x29, 0x49, + 0x4D, 0xF7, 0xAD, 0x6F, 0x52, 0x2D, 0x44, 0x0F + }, + { + 0xDD, 0x90, 0x42, 0xF6, 0xE4, 0x64, 0xDC, 0xF8, + 0x6B, 0x12, 0x62, 0xF6, 0xAC, 0xCF, 0xAF, 0xBD, + 0x8C, 0xFD, 0x90, 0x2E, 0xD3, 0xED, 0x89, 0xAB, + 0xF7, 0x8F, 0xFA, 0x48, 0x2D, 0xBD, 0xEE, 0xB6, + 0x96, 0x98, 0x42, 0x39, 0x4C, 0x9A, 0x11, 0x68, + 0xAE, 0x3D, 0x48, 0x1A, 0x01, 0x78, 0x42, 0xF6, + 0x60, 0x00, 0x2D, 0x42, 0x44, 0x7C, 0x6B, 0x22, + 0xF7, 0xB7, 0x2F, 0x21, 0xAA, 0xE0, 0x21, 0xC9 + }, + { + 0xBD, 0x96, 0x5B, 0xF3, 0x1E, 0x87, 0xD7, 0x03, + 0x27, 0x53, 0x6F, 0x2A, 0x34, 0x1C, 0xEB, 0xC4, + 0x76, 0x8E, 0xCA, 0x27, 0x5F, 0xA0, 0x5E, 0xF9, + 0x8F, 0x7F, 0x1B, 0x71, 0xA0, 0x35, 0x12, 0x98, + 0xDE, 0x00, 0x6F, 0xBA, 0x73, 0xFE, 0x67, 0x33, + 0xED, 0x01, 0xD7, 0x58, 0x01, 0xB4, 0xA9, 0x28, + 0xE5, 0x42, 0x31, 0xB3, 0x8E, 0x38, 0xC5, 0x62, + 0xB2, 0xE3, 0x3E, 0xA1, 0x28, 0x49, 0x92, 0xFA + }, + { + 0x65, 0x67, 0x6D, 0x80, 0x06, 0x17, 0x97, 0x2F, + 0xBD, 0x87, 0xE4, 0xB9, 0x51, 0x4E, 0x1C, 0x67, + 0x40, 0x2B, 0x7A, 0x33, 0x10, 0x96, 0xD3, 0xBF, + 0xAC, 0x22, 0xF1, 0xAB, 0xB9, 0x53, 0x74, 0xAB, + 0xC9, 0x42, 0xF1, 0x6E, 0x9A, 0xB0, 0xEA, 0xD3, + 0x3B, 0x87, 0xC9, 0x19, 0x68, 0xA6, 0xE5, 0x09, + 0xE1, 0x19, 0xFF, 0x07, 0x78, 0x7B, 0x3E, 0xF4, + 0x83, 0xE1, 0xDC, 0xDC, 0xCF, 0x6E, 0x30, 0x22 + }, + { + 0x93, 0x9F, 0xA1, 0x89, 0x69, 0x9C, 0x5D, 0x2C, + 0x81, 0xDD, 0xD1, 0xFF, 0xC1, 0xFA, 0x20, 0x7C, + 0x97, 0x0B, 0x6A, 0x36, 0x85, 0xBB, 0x29, 0xCE, + 0x1D, 0x3E, 0x99, 0xD4, 0x2F, 0x2F, 0x74, 0x42, + 0xDA, 0x53, 0xE9, 0x5A, 0x72, 0x90, 0x73, 0x14, + 0xF4, 0x58, 0x83, 0x99, 0xA3, 0xFF, 0x5B, 0x0A, + 0x92, 0xBE, 0xB3, 0xF6, 0xBE, 0x26, 0x94, 0xF9, + 0xF8, 0x6E, 0xCF, 0x29, 0x52, 0xD5, 0xB4, 0x1C + }, + { + 0xC5, 0x16, 0x54, 0x17, 0x01, 0x86, 0x3F, 0x91, + 0x00, 0x5F, 0x31, 0x41, 0x08, 0xCE, 0xEC, 0xE3, + 0xC6, 0x43, 0xE0, 0x4F, 0xC8, 0xC4, 0x2F, 0xD2, + 0xFF, 0x55, 0x62, 0x20, 0xE6, 0x16, 0xAA, 0xA6, + 0xA4, 0x8A, 0xEB, 0x97, 0xA8, 0x4B, 0xAD, 0x74, + 0x78, 0x2E, 0x8D, 0xFF, 0x96, 0xA1, 0xA2, 0xFA, + 0x94, 0x93, 0x39, 0xD7, 0x22, 0xED, 0xCA, 0xA3, + 0x2B, 0x57, 0x06, 0x70, 0x41, 0xDF, 0x88, 0xCC + }, + { + 0x98, 0x7F, 0xD6, 0xE0, 0xD6, 0x85, 0x7C, 0x55, + 0x3E, 0xAE, 0xBB, 0x3D, 0x34, 0x97, 0x0A, 0x2C, + 0x2F, 0x6E, 0x89, 0xA3, 0x54, 0x8F, 0x49, 0x25, + 0x21, 0x72, 0x2B, 0x80, 0xA1, 0xC2, 0x1A, 0x15, + 0x38, 0x92, 0x34, 0x6D, 0x2C, 0xBA, 0x64, 0x44, + 0x21, 0x2D, 0x56, 0xDA, 0x9A, 0x26, 0xE3, 0x24, + 0xDC, 0xCB, 0xC0, 0xDC, 0xDE, 0x85, 0xD4, 0xD2, + 0xEE, 0x43, 0x99, 0xEE, 0xC5, 0xA6, 0x4E, 0x8F + }, + { + 0xAE, 0x56, 0xDE, 0xB1, 0xC2, 0x32, 0x8D, 0x9C, + 0x40, 0x17, 0x70, 0x6B, 0xCE, 0x6E, 0x99, 0xD4, + 0x13, 0x49, 0x05, 0x3B, 0xA9, 0xD3, 0x36, 0xD6, + 0x77, 0xC4, 0xC2, 0x7D, 0x9F, 0xD5, 0x0A, 0xE6, + 0xAE, 0xE1, 0x7E, 0x85, 0x31, 0x54, 0xE1, 0xF4, + 0xFE, 0x76, 0x72, 0x34, 0x6D, 0xA2, 0xEA, 0xA3, + 0x1E, 0xEA, 0x53, 0xFC, 0xF2, 0x4A, 0x22, 0x80, + 0x4F, 0x11, 0xD0, 0x3D, 0xA6, 0xAB, 0xFC, 0x2B + }, + { + 0x49, 0xD6, 0xA6, 0x08, 0xC9, 0xBD, 0xE4, 0x49, + 0x18, 0x70, 0x49, 0x85, 0x72, 0xAC, 0x31, 0xAA, + 0xC3, 0xFA, 0x40, 0x93, 0x8B, 0x38, 0xA7, 0x81, + 0x8F, 0x72, 0x38, 0x3E, 0xB0, 0x40, 0xAD, 0x39, + 0x53, 0x2B, 0xC0, 0x65, 0x71, 0xE1, 0x3D, 0x76, + 0x7E, 0x69, 0x45, 0xAB, 0x77, 0xC0, 0xBD, 0xC3, + 0xB0, 0x28, 0x42, 0x53, 0x34, 0x3F, 0x9F, 0x6C, + 0x12, 0x44, 0xEB, 0xF2, 0xFF, 0x0D, 0xF8, 0x66 + }, + { + 0xDA, 0x58, 0x2A, 0xD8, 0xC5, 0x37, 0x0B, 0x44, + 0x69, 0xAF, 0x86, 0x2A, 0xA6, 0x46, 0x7A, 0x22, + 0x93, 0xB2, 0xB2, 0x8B, 0xD8, 0x0A, 0xE0, 0xE9, + 0x1F, 0x42, 0x5A, 0xD3, 0xD4, 0x72, 0x49, 0xFD, + 0xF9, 0x88, 0x25, 0xCC, 0x86, 0xF1, 0x40, 0x28, + 0xC3, 0x30, 0x8C, 0x98, 0x04, 0xC7, 0x8B, 0xFE, + 0xEE, 0xEE, 0x46, 0x14, 0x44, 0xCE, 0x24, 0x36, + 0x87, 0xE1, 0xA5, 0x05, 0x22, 0x45, 0x6A, 0x1D + }, + { + 0xD5, 0x26, 0x6A, 0xA3, 0x33, 0x11, 0x94, 0xAE, + 0xF8, 0x52, 0xEE, 0xD8, 0x6D, 0x7B, 0x5B, 0x26, + 0x33, 0xA0, 0xAF, 0x1C, 0x73, 0x59, 0x06, 0xF2, + 0xE1, 0x32, 0x79, 0xF1, 0x49, 0x31, 0xA9, 0xFC, + 0x3B, 0x0E, 0xAC, 0x5C, 0xE9, 0x24, 0x52, 0x73, + 0xBD, 0x1A, 0xA9, 0x29, 0x05, 0xAB, 0xE1, 0x62, + 0x78, 0xEF, 0x7E, 0xFD, 0x47, 0x69, 0x47, 0x89, + 0xA7, 0x28, 0x3B, 0x77, 0xDA, 0x3C, 0x70, 0xF8 + }, + { + 0x29, 0x62, 0x73, 0x4C, 0x28, 0x25, 0x21, 0x86, + 0xA9, 0xA1, 0x11, 0x1C, 0x73, 0x2A, 0xD4, 0xDE, + 0x45, 0x06, 0xD4, 0xB4, 0x48, 0x09, 0x16, 0x30, + 0x3E, 0xB7, 0x99, 0x1D, 0x65, 0x9C, 0xCD, 0xA0, + 0x7A, 0x99, 0x11, 0x91, 0x4B, 0xC7, 0x5C, 0x41, + 0x8A, 0xB7, 0xA4, 0x54, 0x17, 0x57, 0xAD, 0x05, + 0x47, 0x96, 0xE2, 0x67, 0x97, 0xFE, 0xAF, 0x36, + 0xE9, 0xF6, 0xAD, 0x43, 0xF1, 0x4B, 0x35, 0xA4 + }, + { + 0xE8, 0xB7, 0x9E, 0xC5, 0xD0, 0x6E, 0x11, 0x1B, + 0xDF, 0xAF, 0xD7, 0x1E, 0x9F, 0x57, 0x60, 0xF0, + 0x0A, 0xC8, 0xAC, 0x5D, 0x8B, 0xF7, 0x68, 0xF9, + 0xFF, 0x6F, 0x08, 0xB8, 0xF0, 0x26, 0x09, 0x6B, + 0x1C, 0xC3, 0xA4, 0xC9, 0x73, 0x33, 0x30, 0x19, + 0xF1, 0xE3, 0x55, 0x3E, 0x77, 0xDA, 0x3F, 0x98, + 0xCB, 0x9F, 0x54, 0x2E, 0x0A, 0x90, 0xE5, 0xF8, + 0xA9, 0x40, 0xCC, 0x58, 0xE5, 0x98, 0x44, 0xB3 + }, + { + 0xDF, 0xB3, 0x20, 0xC4, 0x4F, 0x9D, 0x41, 0xD1, + 0xEF, 0xDC, 0xC0, 0x15, 0xF0, 0x8D, 0xD5, 0x53, + 0x9E, 0x52, 0x6E, 0x39, 0xC8, 0x7D, 0x50, 0x9A, + 0xE6, 0x81, 0x2A, 0x96, 0x9E, 0x54, 0x31, 0xBF, + 0x4F, 0xA7, 0xD9, 0x1F, 0xFD, 0x03, 0xB9, 0x81, + 0xE0, 0xD5, 0x44, 0xCF, 0x72, 0xD7, 0xB1, 0xC0, + 0x37, 0x4F, 0x88, 0x01, 0x48, 0x2E, 0x6D, 0xEA, + 0x2E, 0xF9, 0x03, 0x87, 0x7E, 0xBA, 0x67, 0x5E + }, + { + 0xD8, 0x86, 0x75, 0x11, 0x8F, 0xDB, 0x55, 0xA5, + 0xFB, 0x36, 0x5A, 0xC2, 0xAF, 0x1D, 0x21, 0x7B, + 0xF5, 0x26, 0xCE, 0x1E, 0xE9, 0xC9, 0x4B, 0x2F, + 0x00, 0x90, 0xB2, 0xC5, 0x8A, 0x06, 0xCA, 0x58, + 0x18, 0x7D, 0x7F, 0xE5, 0x7C, 0x7B, 0xED, 0x9D, + 0x26, 0xFC, 0xA0, 0x67, 0xB4, 0x11, 0x0E, 0xEF, + 0xCD, 0x9A, 0x0A, 0x34, 0x5D, 0xE8, 0x72, 0xAB, + 0xE2, 0x0D, 0xE3, 0x68, 0x00, 0x1B, 0x07, 0x45 + }, + { + 0xB8, 0x93, 0xF2, 0xFC, 0x41, 0xF7, 0xB0, 0xDD, + 0x6E, 0x2F, 0x6A, 0xA2, 0xE0, 0x37, 0x0C, 0x0C, + 0xFF, 0x7D, 0xF0, 0x9E, 0x3A, 0xCF, 0xCC, 0x0E, + 0x92, 0x0B, 0x6E, 0x6F, 0xAD, 0x0E, 0xF7, 0x47, + 0xC4, 0x06, 0x68, 0x41, 0x7D, 0x34, 0x2B, 0x80, + 0xD2, 0x35, 0x1E, 0x8C, 0x17, 0x5F, 0x20, 0x89, + 0x7A, 0x06, 0x2E, 0x97, 0x65, 0xE6, 0xC6, 0x7B, + 0x53, 0x9B, 0x6B, 0xA8, 0xB9, 0x17, 0x05, 0x45 + }, + { + 0x6C, 0x67, 0xEC, 0x56, 0x97, 0xAC, 0xCD, 0x23, + 0x5C, 0x59, 0xB4, 0x86, 0xD7, 0xB7, 0x0B, 0xAE, + 0xED, 0xCB, 0xD4, 0xAA, 0x64, 0xEB, 0xD4, 0xEE, + 0xF3, 0xC7, 0xEA, 0xC1, 0x89, 0x56, 0x1A, 0x72, + 0x62, 0x50, 0xAE, 0xC4, 0xD4, 0x8C, 0xAD, 0xCA, + 0xFB, 0xBE, 0x2C, 0xE3, 0xC1, 0x6C, 0xE2, 0xD6, + 0x91, 0xA8, 0xCC, 0xE0, 0x6E, 0x88, 0x79, 0x55, + 0x6D, 0x44, 0x83, 0xED, 0x71, 0x65, 0xC0, 0x63 + }, + { + 0xF1, 0xAA, 0x2B, 0x04, 0x4F, 0x8F, 0x0C, 0x63, + 0x8A, 0x3F, 0x36, 0x2E, 0x67, 0x7B, 0x5D, 0x89, + 0x1D, 0x6F, 0xD2, 0xAB, 0x07, 0x65, 0xF6, 0xEE, + 0x1E, 0x49, 0x87, 0xDE, 0x05, 0x7E, 0xAD, 0x35, + 0x78, 0x83, 0xD9, 0xB4, 0x05, 0xB9, 0xD6, 0x09, + 0xEE, 0xA1, 0xB8, 0x69, 0xD9, 0x7F, 0xB1, 0x6D, + 0x9B, 0x51, 0x01, 0x7C, 0x55, 0x3F, 0x3B, 0x93, + 0xC0, 0xA1, 0xE0, 0xF1, 0x29, 0x6F, 0xED, 0xCD + }, + { + 0xCB, 0xAA, 0x25, 0x95, 0x72, 0xD4, 0xAE, 0xBF, + 0xC1, 0x91, 0x7A, 0xCD, 0xDC, 0x58, 0x2B, 0x9F, + 0x8D, 0xFA, 0xA9, 0x28, 0xA1, 0x98, 0xCA, 0x7A, + 0xCD, 0x0F, 0x2A, 0xA7, 0x6A, 0x13, 0x4A, 0x90, + 0x25, 0x2E, 0x62, 0x98, 0xA6, 0x5B, 0x08, 0x18, + 0x6A, 0x35, 0x0D, 0x5B, 0x76, 0x26, 0x69, 0x9F, + 0x8C, 0xB7, 0x21, 0xA3, 0xEA, 0x59, 0x21, 0xB7, + 0x53, 0xAE, 0x3A, 0x2D, 0xCE, 0x24, 0xBA, 0x3A + }, + { + 0xFA, 0x15, 0x49, 0xC9, 0x79, 0x6C, 0xD4, 0xD3, + 0x03, 0xDC, 0xF4, 0x52, 0xC1, 0xFB, 0xD5, 0x74, + 0x4F, 0xD9, 0xB9, 0xB4, 0x70, 0x03, 0xD9, 0x20, + 0xB9, 0x2D, 0xE3, 0x48, 0x39, 0xD0, 0x7E, 0xF2, + 0xA2, 0x9D, 0xED, 0x68, 0xF6, 0xFC, 0x9E, 0x6C, + 0x45, 0xE0, 0x71, 0xA2, 0xE4, 0x8B, 0xD5, 0x0C, + 0x50, 0x84, 0xE9, 0x6B, 0x65, 0x7D, 0xD0, 0x40, + 0x40, 0x45, 0xA1, 0xDD, 0xEF, 0xE2, 0x82, 0xED + }, + { + 0x5C, 0xF2, 0xAC, 0x89, 0x7A, 0xB4, 0x44, 0xDC, + 0xB5, 0xC8, 0xD8, 0x7C, 0x49, 0x5D, 0xBD, 0xB3, + 0x4E, 0x18, 0x38, 0xB6, 0xB6, 0x29, 0x42, 0x7C, + 0xAA, 0x51, 0x70, 0x2A, 0xD0, 0xF9, 0x68, 0x85, + 0x25, 0xF1, 0x3B, 0xEC, 0x50, 0x3A, 0x3C, 0x3A, + 0x2C, 0x80, 0xA6, 0x5E, 0x0B, 0x57, 0x15, 0xE8, + 0xAF, 0xAB, 0x00, 0xFF, 0xA5, 0x6E, 0xC4, 0x55, + 0xA4, 0x9A, 0x1A, 0xD3, 0x0A, 0xA2, 0x4F, 0xCD + }, + { + 0x9A, 0xAF, 0x80, 0x20, 0x7B, 0xAC, 0xE1, 0x7B, + 0xB7, 0xAB, 0x14, 0x57, 0x57, 0xD5, 0x69, 0x6B, + 0xDE, 0x32, 0x40, 0x6E, 0xF2, 0x2B, 0x44, 0x29, + 0x2E, 0xF6, 0x5D, 0x45, 0x19, 0xC3, 0xBB, 0x2A, + 0xD4, 0x1A, 0x59, 0xB6, 0x2C, 0xC3, 0xE9, 0x4B, + 0x6F, 0xA9, 0x6D, 0x32, 0xA7, 0xFA, 0xAD, 0xAE, + 0x28, 0xAF, 0x7D, 0x35, 0x09, 0x72, 0x19, 0xAA, + 0x3F, 0xD8, 0xCD, 0xA3, 0x1E, 0x40, 0xC2, 0x75 + }, + { + 0xAF, 0x88, 0xB1, 0x63, 0x40, 0x2C, 0x86, 0x74, + 0x5C, 0xB6, 0x50, 0xC2, 0x98, 0x8F, 0xB9, 0x52, + 0x11, 0xB9, 0x4B, 0x03, 0xEF, 0x29, 0x0E, 0xED, + 0x96, 0x62, 0x03, 0x42, 0x41, 0xFD, 0x51, 0xCF, + 0x39, 0x8F, 0x80, 0x73, 0xE3, 0x69, 0x35, 0x4C, + 0x43, 0xEA, 0xE1, 0x05, 0x2F, 0x9B, 0x63, 0xB0, + 0x81, 0x91, 0xCA, 0xA1, 0x38, 0xAA, 0x54, 0xFE, + 0xA8, 0x89, 0xCC, 0x70, 0x24, 0x23, 0x68, 0x97 + }, + { + 0x48, 0xFA, 0x7D, 0x64, 0xE1, 0xCE, 0xEE, 0x27, + 0xB9, 0x86, 0x4D, 0xB5, 0xAD, 0xA4, 0xB5, 0x3D, + 0x00, 0xC9, 0xBC, 0x76, 0x26, 0x55, 0x58, 0x13, + 0xD3, 0xCD, 0x67, 0x30, 0xAB, 0x3C, 0xC0, 0x6F, + 0xF3, 0x42, 0xD7, 0x27, 0x90, 0x5E, 0x33, 0x17, + 0x1B, 0xDE, 0x6E, 0x84, 0x76, 0xE7, 0x7F, 0xB1, + 0x72, 0x08, 0x61, 0xE9, 0x4B, 0x73, 0xA2, 0xC5, + 0x38, 0xD2, 0x54, 0x74, 0x62, 0x85, 0xF4, 0x30 + }, + { + 0x0E, 0x6F, 0xD9, 0x7A, 0x85, 0xE9, 0x04, 0xF8, + 0x7B, 0xFE, 0x85, 0xBB, 0xEB, 0x34, 0xF6, 0x9E, + 0x1F, 0x18, 0x10, 0x5C, 0xF4, 0xED, 0x4F, 0x87, + 0xAE, 0xC3, 0x6C, 0x6E, 0x8B, 0x5F, 0x68, 0xBD, + 0x2A, 0x6F, 0x3D, 0xC8, 0xA9, 0xEC, 0xB2, 0xB6, + 0x1D, 0xB4, 0xEE, 0xDB, 0x6B, 0x2E, 0xA1, 0x0B, + 0xF9, 0xCB, 0x02, 0x51, 0xFB, 0x0F, 0x8B, 0x34, + 0x4A, 0xBF, 0x7F, 0x36, 0x6B, 0x6D, 0xE5, 0xAB + }, + { + 0x06, 0x62, 0x2D, 0xA5, 0x78, 0x71, 0x76, 0x28, + 0x7F, 0xDC, 0x8F, 0xED, 0x44, 0x0B, 0xAD, 0x18, + 0x7D, 0x83, 0x00, 0x99, 0xC9, 0x4E, 0x6D, 0x04, + 0xC8, 0xE9, 0xC9, 0x54, 0xCD, 0xA7, 0x0C, 0x8B, + 0xB9, 0xE1, 0xFC, 0x4A, 0x6D, 0x0B, 0xAA, 0x83, + 0x1B, 0x9B, 0x78, 0xEF, 0x66, 0x48, 0x68, 0x1A, + 0x48, 0x67, 0xA1, 0x1D, 0xA9, 0x3E, 0xE3, 0x6E, + 0x5E, 0x6A, 0x37, 0xD8, 0x7F, 0xC6, 0x3F, 0x6F + }, + { + 0x1D, 0xA6, 0x77, 0x2B, 0x58, 0xFA, 0xBF, 0x9C, + 0x61, 0xF6, 0x8D, 0x41, 0x2C, 0x82, 0xF1, 0x82, + 0xC0, 0x23, 0x6D, 0x7D, 0x57, 0x5E, 0xF0, 0xB5, + 0x8D, 0xD2, 0x24, 0x58, 0xD6, 0x43, 0xCD, 0x1D, + 0xFC, 0x93, 0xB0, 0x38, 0x71, 0xC3, 0x16, 0xD8, + 0x43, 0x0D, 0x31, 0x29, 0x95, 0xD4, 0x19, 0x7F, + 0x08, 0x74, 0xC9, 0x91, 0x72, 0xBA, 0x00, 0x4A, + 0x01, 0xEE, 0x29, 0x5A, 0xBA, 0xC2, 0x4E, 0x46 + }, + { + 0x3C, 0xD2, 0xD9, 0x32, 0x0B, 0x7B, 0x1D, 0x5F, + 0xB9, 0xAA, 0xB9, 0x51, 0xA7, 0x60, 0x23, 0xFA, + 0x66, 0x7B, 0xE1, 0x4A, 0x91, 0x24, 0xE3, 0x94, + 0x51, 0x39, 0x18, 0xA3, 0xF4, 0x40, 0x96, 0xAE, + 0x49, 0x04, 0xBA, 0x0F, 0xFC, 0x15, 0x0B, 0x63, + 0xBC, 0x7A, 0xB1, 0xEE, 0xB9, 0xA6, 0xE2, 0x57, + 0xE5, 0xC8, 0xF0, 0x00, 0xA7, 0x03, 0x94, 0xA5, + 0xAF, 0xD8, 0x42, 0x71, 0x5D, 0xE1, 0x5F, 0x29 + }, + { + 0x04, 0xCD, 0xC1, 0x4F, 0x74, 0x34, 0xE0, 0xB4, + 0xBE, 0x70, 0xCB, 0x41, 0xDB, 0x4C, 0x77, 0x9A, + 0x88, 0xEA, 0xEF, 0x6A, 0xCC, 0xEB, 0xCB, 0x41, + 0xF2, 0xD4, 0x2F, 0xFF, 0xE7, 0xF3, 0x2A, 0x8E, + 0x28, 0x1B, 0x5C, 0x10, 0x3A, 0x27, 0x02, 0x1D, + 0x0D, 0x08, 0x36, 0x22, 0x50, 0x75, 0x3C, 0xDF, + 0x70, 0x29, 0x21, 0x95, 0xA5, 0x3A, 0x48, 0x72, + 0x8C, 0xEB, 0x58, 0x44, 0xC2, 0xD9, 0x8B, 0xAB + }, + { + 0x90, 0x71, 0xB7, 0xA8, 0xA0, 0x75, 0xD0, 0x09, + 0x5B, 0x8F, 0xB3, 0xAE, 0x51, 0x13, 0x78, 0x57, + 0x35, 0xAB, 0x98, 0xE2, 0xB5, 0x2F, 0xAF, 0x91, + 0xD5, 0xB8, 0x9E, 0x44, 0xAA, 0xC5, 0xB5, 0xD4, + 0xEB, 0xBF, 0x91, 0x22, 0x3B, 0x0F, 0xF4, 0xC7, + 0x19, 0x05, 0xDA, 0x55, 0x34, 0x2E, 0x64, 0x65, + 0x5D, 0x6E, 0xF8, 0xC8, 0x9A, 0x47, 0x68, 0xC3, + 0xF9, 0x3A, 0x6D, 0xC0, 0x36, 0x6B, 0x5B, 0xC8 + }, + { + 0xEB, 0xB3, 0x02, 0x40, 0xDD, 0x96, 0xC7, 0xBC, + 0x8D, 0x0A, 0xBE, 0x49, 0xAA, 0x4E, 0xDC, 0xBB, + 0x4A, 0xFD, 0xC5, 0x1F, 0xF9, 0xAA, 0xF7, 0x20, + 0xD3, 0xF9, 0xE7, 0xFB, 0xB0, 0xF9, 0xC6, 0xD6, + 0x57, 0x13, 0x50, 0x50, 0x17, 0x69, 0xFC, 0x4E, + 0xBD, 0x0B, 0x21, 0x41, 0x24, 0x7F, 0xF4, 0x00, + 0xD4, 0xFD, 0x4B, 0xE4, 0x14, 0xED, 0xF3, 0x77, + 0x57, 0xBB, 0x90, 0xA3, 0x2A, 0xC5, 0xC6, 0x5A + }, + { + 0x85, 0x32, 0xC5, 0x8B, 0xF3, 0xC8, 0x01, 0x5D, + 0x9D, 0x1C, 0xBE, 0x00, 0xEE, 0xF1, 0xF5, 0x08, + 0x2F, 0x8F, 0x36, 0x32, 0xFB, 0xE9, 0xF1, 0xED, + 0x4F, 0x9D, 0xFB, 0x1F, 0xA7, 0x9E, 0x82, 0x83, + 0x06, 0x6D, 0x77, 0xC4, 0x4C, 0x4A, 0xF9, 0x43, + 0xD7, 0x6B, 0x30, 0x03, 0x64, 0xAE, 0xCB, 0xD0, + 0x64, 0x8C, 0x8A, 0x89, 0x39, 0xBD, 0x20, 0x41, + 0x23, 0xF4, 0xB5, 0x62, 0x60, 0x42, 0x2D, 0xEC + }, + { + 0xFE, 0x98, 0x46, 0xD6, 0x4F, 0x7C, 0x77, 0x08, + 0x69, 0x6F, 0x84, 0x0E, 0x2D, 0x76, 0xCB, 0x44, + 0x08, 0xB6, 0x59, 0x5C, 0x2F, 0x81, 0xEC, 0x6A, + 0x28, 0xA7, 0xF2, 0xF2, 0x0C, 0xB8, 0x8C, 0xFE, + 0x6A, 0xC0, 0xB9, 0xE9, 0xB8, 0x24, 0x4F, 0x08, + 0xBD, 0x70, 0x95, 0xC3, 0x50, 0xC1, 0xD0, 0x84, + 0x2F, 0x64, 0xFB, 0x01, 0xBB, 0x7F, 0x53, 0x2D, + 0xFC, 0xD4, 0x73, 0x71, 0xB0, 0xAE, 0xEB, 0x79 + }, + { + 0x28, 0xF1, 0x7E, 0xA6, 0xFB, 0x6C, 0x42, 0x09, + 0x2D, 0xC2, 0x64, 0x25, 0x7E, 0x29, 0x74, 0x63, + 0x21, 0xFB, 0x5B, 0xDA, 0xEA, 0x98, 0x73, 0xC2, + 0xA7, 0xFA, 0x9D, 0x8F, 0x53, 0x81, 0x8E, 0x89, + 0x9E, 0x16, 0x1B, 0xC7, 0x7D, 0xFE, 0x80, 0x90, + 0xAF, 0xD8, 0x2B, 0xF2, 0x26, 0x6C, 0x5C, 0x1B, + 0xC9, 0x30, 0xA8, 0xD1, 0x54, 0x76, 0x24, 0x43, + 0x9E, 0x66, 0x2E, 0xF6, 0x95, 0xF2, 0x6F, 0x24 + }, + { + 0xEC, 0x6B, 0x7D, 0x7F, 0x03, 0x0D, 0x48, 0x50, + 0xAC, 0xAE, 0x3C, 0xB6, 0x15, 0xC2, 0x1D, 0xD2, + 0x52, 0x06, 0xD6, 0x3E, 0x84, 0xD1, 0xDB, 0x8D, + 0x95, 0x73, 0x70, 0x73, 0x7B, 0xA0, 0xE9, 0x84, + 0x67, 0xEA, 0x0C, 0xE2, 0x74, 0xC6, 0x61, 0x99, + 0x90, 0x1E, 0xAE, 0xC1, 0x8A, 0x08, 0x52, 0x57, + 0x15, 0xF5, 0x3B, 0xFD, 0xB0, 0xAA, 0xCB, 0x61, + 0x3D, 0x34, 0x2E, 0xBD, 0xCE, 0xED, 0xDC, 0x3B + }, + { + 0xB4, 0x03, 0xD3, 0x69, 0x1C, 0x03, 0xB0, 0xD3, + 0x41, 0x8D, 0xF3, 0x27, 0xD5, 0x86, 0x0D, 0x34, + 0xBB, 0xFC, 0xC4, 0x51, 0x9B, 0xFB, 0xCE, 0x36, + 0xBF, 0x33, 0xB2, 0x08, 0x38, 0x5F, 0xAD, 0xB9, + 0x18, 0x6B, 0xC7, 0x8A, 0x76, 0xC4, 0x89, 0xD8, + 0x9F, 0xD5, 0x7E, 0x7D, 0xC7, 0x54, 0x12, 0xD2, + 0x3B, 0xCD, 0x1D, 0xAE, 0x84, 0x70, 0xCE, 0x92, + 0x74, 0x75, 0x4B, 0xB8, 0x58, 0x5B, 0x13, 0xC5 + }, + { + 0x31, 0xFC, 0x79, 0x73, 0x8B, 0x87, 0x72, 0xB3, + 0xF5, 0x5C, 0xD8, 0x17, 0x88, 0x13, 0xB3, 0xB5, + 0x2D, 0x0D, 0xB5, 0xA4, 0x19, 0xD3, 0x0B, 0xA9, + 0x49, 0x5C, 0x4B, 0x9D, 0xA0, 0x21, 0x9F, 0xAC, + 0x6D, 0xF8, 0xE7, 0xC2, 0x3A, 0x81, 0x15, 0x51, + 0xA6, 0x2B, 0x82, 0x7F, 0x25, 0x6E, 0xCD, 0xB8, + 0x12, 0x4A, 0xC8, 0xA6, 0x79, 0x2C, 0xCF, 0xEC, + 0xC3, 0xB3, 0x01, 0x27, 0x22, 0xE9, 0x44, 0x63 + }, + { + 0xBB, 0x20, 0x39, 0xEC, 0x28, 0x70, 0x91, 0xBC, + 0xC9, 0x64, 0x2F, 0xC9, 0x00, 0x49, 0xE7, 0x37, + 0x32, 0xE0, 0x2E, 0x57, 0x7E, 0x28, 0x62, 0xB3, + 0x22, 0x16, 0xAE, 0x9B, 0xED, 0xCD, 0x73, 0x0C, + 0x4C, 0x28, 0x4E, 0xF3, 0x96, 0x8C, 0x36, 0x8B, + 0x7D, 0x37, 0x58, 0x4F, 0x97, 0xBD, 0x4B, 0x4D, + 0xC6, 0xEF, 0x61, 0x27, 0xAC, 0xFE, 0x2E, 0x6A, + 0xE2, 0x50, 0x91, 0x24, 0xE6, 0x6C, 0x8A, 0xF4 + }, + { + 0xF5, 0x3D, 0x68, 0xD1, 0x3F, 0x45, 0xED, 0xFC, + 0xB9, 0xBD, 0x41, 0x5E, 0x28, 0x31, 0xE9, 0x38, + 0x35, 0x0D, 0x53, 0x80, 0xD3, 0x43, 0x22, 0x78, + 0xFC, 0x1C, 0x0C, 0x38, 0x1F, 0xCB, 0x7C, 0x65, + 0xC8, 0x2D, 0xAF, 0xE0, 0x51, 0xD8, 0xC8, 0xB0, + 0xD4, 0x4E, 0x09, 0x74, 0xA0, 0xE5, 0x9E, 0xC7, + 0xBF, 0x7E, 0xD0, 0x45, 0x9F, 0x86, 0xE9, 0x6F, + 0x32, 0x9F, 0xC7, 0x97, 0x52, 0x51, 0x0F, 0xD3 + }, + { + 0x8D, 0x56, 0x8C, 0x79, 0x84, 0xF0, 0xEC, 0xDF, + 0x76, 0x40, 0xFB, 0xC4, 0x83, 0xB5, 0xD8, 0xC9, + 0xF8, 0x66, 0x34, 0xF6, 0xF4, 0x32, 0x91, 0x84, + 0x1B, 0x30, 0x9A, 0x35, 0x0A, 0xB9, 0xC1, 0x13, + 0x7D, 0x24, 0x06, 0x6B, 0x09, 0xDA, 0x99, 0x44, + 0xBA, 0xC5, 0x4D, 0x5B, 0xB6, 0x58, 0x0D, 0x83, + 0x60, 0x47, 0xAA, 0xC7, 0x4A, 0xB7, 0x24, 0xB8, + 0x87, 0xEB, 0xF9, 0x3D, 0x4B, 0x32, 0xEC, 0xA9 + }, + { + 0xC0, 0xB6, 0x5C, 0xE5, 0xA9, 0x6F, 0xF7, 0x74, + 0xC4, 0x56, 0xCA, 0xC3, 0xB5, 0xF2, 0xC4, 0xCD, + 0x35, 0x9B, 0x4F, 0xF5, 0x3E, 0xF9, 0x3A, 0x3D, + 0xA0, 0x77, 0x8B, 0xE4, 0x90, 0x0D, 0x1E, 0x8D, + 0xA1, 0x60, 0x1E, 0x76, 0x9E, 0x8F, 0x1B, 0x02, + 0xD2, 0xA2, 0xF8, 0xC5, 0xB9, 0xFA, 0x10, 0xB4, + 0x4F, 0x1C, 0x18, 0x69, 0x85, 0x46, 0x8F, 0xEE, + 0xB0, 0x08, 0x73, 0x02, 0x83, 0xA6, 0x65, 0x7D + }, + { + 0x49, 0x00, 0xBB, 0xA6, 0xF5, 0xFB, 0x10, 0x3E, + 0xCE, 0x8E, 0xC9, 0x6A, 0xDA, 0x13, 0xA5, 0xC3, + 0xC8, 0x54, 0x88, 0xE0, 0x55, 0x51, 0xDA, 0x6B, + 0x6B, 0x33, 0xD9, 0x88, 0xE6, 0x11, 0xEC, 0x0F, + 0xE2, 0xE3, 0xC2, 0xAA, 0x48, 0xEA, 0x6A, 0xE8, + 0x98, 0x6A, 0x3A, 0x23, 0x1B, 0x22, 0x3C, 0x5D, + 0x27, 0xCE, 0xC2, 0xEA, 0xDD, 0xE9, 0x1C, 0xE0, + 0x79, 0x81, 0xEE, 0x65, 0x28, 0x62, 0xD1, 0xE4 + }, + { + 0xC7, 0xF5, 0xC3, 0x7C, 0x72, 0x85, 0xF9, 0x27, + 0xF7, 0x64, 0x43, 0x41, 0x4D, 0x43, 0x57, 0xFF, + 0x78, 0x96, 0x47, 0xD7, 0xA0, 0x05, 0xA5, 0xA7, + 0x87, 0xE0, 0x3C, 0x34, 0x6B, 0x57, 0xF4, 0x9F, + 0x21, 0xB6, 0x4F, 0xA9, 0xCF, 0x4B, 0x7E, 0x45, + 0x57, 0x3E, 0x23, 0x04, 0x90, 0x17, 0x56, 0x71, + 0x21, 0xA9, 0xC3, 0xD4, 0xB2, 0xB7, 0x3E, 0xC5, + 0xE9, 0x41, 0x35, 0x77, 0x52, 0x5D, 0xB4, 0x5A + }, + { + 0xEC, 0x70, 0x96, 0x33, 0x07, 0x36, 0xFD, 0xB2, + 0xD6, 0x4B, 0x56, 0x53, 0xE7, 0x47, 0x5D, 0xA7, + 0x46, 0xC2, 0x3A, 0x46, 0x13, 0xA8, 0x26, 0x87, + 0xA2, 0x80, 0x62, 0xD3, 0x23, 0x63, 0x64, 0x28, + 0x4A, 0xC0, 0x17, 0x20, 0xFF, 0xB4, 0x06, 0xCF, + 0xE2, 0x65, 0xC0, 0xDF, 0x62, 0x6A, 0x18, 0x8C, + 0x9E, 0x59, 0x63, 0xAC, 0xE5, 0xD3, 0xD5, 0xBB, + 0x36, 0x3E, 0x32, 0xC3, 0x8C, 0x21, 0x90, 0xA6 + }, + { + 0x82, 0xE7, 0x44, 0xC7, 0x5F, 0x46, 0x49, 0xEC, + 0x52, 0xB8, 0x07, 0x71, 0xA7, 0x7D, 0x47, 0x5A, + 0x3B, 0xC0, 0x91, 0x98, 0x95, 0x56, 0x96, 0x0E, + 0x27, 0x6A, 0x5F, 0x9E, 0xAD, 0x92, 0xA0, 0x3F, + 0x71, 0x87, 0x42, 0xCD, 0xCF, 0xEA, 0xEE, 0x5C, + 0xB8, 0x5C, 0x44, 0xAF, 0x19, 0x8A, 0xDC, 0x43, + 0xA4, 0xA4, 0x28, 0xF5, 0xF0, 0xC2, 0xDD, 0xB0, + 0xBE, 0x36, 0x05, 0x9F, 0x06, 0xD7, 0xDF, 0x73 + }, + { + 0x28, 0x34, 0xB7, 0xA7, 0x17, 0x0F, 0x1F, 0x5B, + 0x68, 0x55, 0x9A, 0xB7, 0x8C, 0x10, 0x50, 0xEC, + 0x21, 0xC9, 0x19, 0x74, 0x0B, 0x78, 0x4A, 0x90, + 0x72, 0xF6, 0xE5, 0xD6, 0x9F, 0x82, 0x8D, 0x70, + 0xC9, 0x19, 0xC5, 0x03, 0x9F, 0xB1, 0x48, 0xE3, + 0x9E, 0x2C, 0x8A, 0x52, 0x11, 0x83, 0x78, 0xB0, + 0x64, 0xCA, 0x8D, 0x50, 0x01, 0xCD, 0x10, 0xA5, + 0x47, 0x83, 0x87, 0xB9, 0x66, 0x71, 0x5E, 0xD6 + }, + { + 0x16, 0xB4, 0xAD, 0xA8, 0x83, 0xF7, 0x2F, 0x85, + 0x3B, 0xB7, 0xEF, 0x25, 0x3E, 0xFC, 0xAB, 0x0C, + 0x3E, 0x21, 0x61, 0x68, 0x7A, 0xD6, 0x15, 0x43, + 0xA0, 0xD2, 0x82, 0x4F, 0x91, 0xC1, 0xF8, 0x13, + 0x47, 0xD8, 0x6B, 0xE7, 0x09, 0xB1, 0x69, 0x96, + 0xE1, 0x7F, 0x2D, 0xD4, 0x86, 0x92, 0x7B, 0x02, + 0x88, 0xAD, 0x38, 0xD1, 0x30, 0x63, 0xC4, 0xA9, + 0x67, 0x2C, 0x39, 0x39, 0x7D, 0x37, 0x89, 0xB6 + }, + { + 0x78, 0xD0, 0x48, 0xF3, 0xA6, 0x9D, 0x8B, 0x54, + 0xAE, 0x0E, 0xD6, 0x3A, 0x57, 0x3A, 0xE3, 0x50, + 0xD8, 0x9F, 0x7C, 0x6C, 0xF1, 0xF3, 0x68, 0x89, + 0x30, 0xDE, 0x89, 0x9A, 0xFA, 0x03, 0x76, 0x97, + 0x62, 0x9B, 0x31, 0x4E, 0x5C, 0xD3, 0x03, 0xAA, + 0x62, 0xFE, 0xEA, 0x72, 0xA2, 0x5B, 0xF4, 0x2B, + 0x30, 0x4B, 0x6C, 0x6B, 0xCB, 0x27, 0xFA, 0xE2, + 0x1C, 0x16, 0xD9, 0x25, 0xE1, 0xFB, 0xDA, 0xC3 + }, + { + 0x0F, 0x74, 0x6A, 0x48, 0x74, 0x92, 0x87, 0xAD, + 0xA7, 0x7A, 0x82, 0x96, 0x1F, 0x05, 0xA4, 0xDA, + 0x4A, 0xBD, 0xB7, 0xD7, 0x7B, 0x12, 0x20, 0xF8, + 0x36, 0xD0, 0x9E, 0xC8, 0x14, 0x35, 0x9C, 0x0E, + 0xC0, 0x23, 0x9B, 0x8C, 0x7B, 0x9F, 0xF9, 0xE0, + 0x2F, 0x56, 0x9D, 0x1B, 0x30, 0x1E, 0xF6, 0x7C, + 0x46, 0x12, 0xD1, 0xDE, 0x4F, 0x73, 0x0F, 0x81, + 0xC1, 0x2C, 0x40, 0xCC, 0x06, 0x3C, 0x5C, 0xAA + }, + { + 0xF0, 0xFC, 0x85, 0x9D, 0x3B, 0xD1, 0x95, 0xFB, + 0xDC, 0x2D, 0x59, 0x1E, 0x4C, 0xDA, 0xC1, 0x51, + 0x79, 0xEC, 0x0F, 0x1D, 0xC8, 0x21, 0xC1, 0x1D, + 0xF1, 0xF0, 0xC1, 0xD2, 0x6E, 0x62, 0x60, 0xAA, + 0xA6, 0x5B, 0x79, 0xFA, 0xFA, 0xCA, 0xFD, 0x7D, + 0x3A, 0xD6, 0x1E, 0x60, 0x0F, 0x25, 0x09, 0x05, + 0xF5, 0x87, 0x8C, 0x87, 0x45, 0x28, 0x97, 0x64, + 0x7A, 0x35, 0xB9, 0x95, 0xBC, 0xAD, 0xC3, 0xA3 + }, + { + 0x26, 0x20, 0xF6, 0x87, 0xE8, 0x62, 0x5F, 0x6A, + 0x41, 0x24, 0x60, 0xB4, 0x2E, 0x2C, 0xEF, 0x67, + 0x63, 0x42, 0x08, 0xCE, 0x10, 0xA0, 0xCB, 0xD4, + 0xDF, 0xF7, 0x04, 0x4A, 0x41, 0xB7, 0x88, 0x00, + 0x77, 0xE9, 0xF8, 0xDC, 0x3B, 0x8D, 0x12, 0x16, + 0xD3, 0x37, 0x6A, 0x21, 0xE0, 0x15, 0xB5, 0x8F, + 0xB2, 0x79, 0xB5, 0x21, 0xD8, 0x3F, 0x93, 0x88, + 0xC7, 0x38, 0x2C, 0x85, 0x05, 0x59, 0x0B, 0x9B + }, + { + 0x22, 0x7E, 0x3A, 0xED, 0x8D, 0x2C, 0xB1, 0x0B, + 0x91, 0x8F, 0xCB, 0x04, 0xF9, 0xDE, 0x3E, 0x6D, + 0x0A, 0x57, 0xE0, 0x84, 0x76, 0xD9, 0x37, 0x59, + 0xCD, 0x7B, 0x2E, 0xD5, 0x4A, 0x1C, 0xBF, 0x02, + 0x39, 0xC5, 0x28, 0xFB, 0x04, 0xBB, 0xF2, 0x88, + 0x25, 0x3E, 0x60, 0x1D, 0x3B, 0xC3, 0x8B, 0x21, + 0x79, 0x4A, 0xFE, 0xF9, 0x0B, 0x17, 0x09, 0x4A, + 0x18, 0x2C, 0xAC, 0x55, 0x77, 0x45, 0xE7, 0x5F + }, + { + 0x1A, 0x92, 0x99, 0x01, 0xB0, 0x9C, 0x25, 0xF2, + 0x7D, 0x6B, 0x35, 0xBE, 0x7B, 0x2F, 0x1C, 0x47, + 0x45, 0x13, 0x1F, 0xDE, 0xBC, 0xA7, 0xF3, 0xE2, + 0x45, 0x19, 0x26, 0x72, 0x04, 0x34, 0xE0, 0xDB, + 0x6E, 0x74, 0xFD, 0x69, 0x3A, 0xD2, 0x9B, 0x77, + 0x7D, 0xC3, 0x35, 0x5C, 0x59, 0x2A, 0x36, 0x1C, + 0x48, 0x73, 0xB0, 0x11, 0x33, 0xA5, 0x7C, 0x2E, + 0x3B, 0x70, 0x75, 0xCB, 0xDB, 0x86, 0xF4, 0xFC + }, + { + 0x5F, 0xD7, 0x96, 0x8B, 0xC2, 0xFE, 0x34, 0xF2, + 0x20, 0xB5, 0xE3, 0xDC, 0x5A, 0xF9, 0x57, 0x17, + 0x42, 0xD7, 0x3B, 0x7D, 0x60, 0x81, 0x9F, 0x28, + 0x88, 0xB6, 0x29, 0x07, 0x2B, 0x96, 0xA9, 0xD8, + 0xAB, 0x2D, 0x91, 0xB8, 0x2D, 0x0A, 0x9A, 0xAB, + 0xA6, 0x1B, 0xBD, 0x39, 0x95, 0x81, 0x32, 0xFC, + 0xC4, 0x25, 0x70, 0x23, 0xD1, 0xEC, 0xA5, 0x91, + 0xB3, 0x05, 0x4E, 0x2D, 0xC8, 0x1C, 0x82, 0x00 + }, + { + 0xDF, 0xCC, 0xE8, 0xCF, 0x32, 0x87, 0x0C, 0xC6, + 0xA5, 0x03, 0xEA, 0xDA, 0xFC, 0x87, 0xFD, 0x6F, + 0x78, 0x91, 0x8B, 0x9B, 0x4D, 0x07, 0x37, 0xDB, + 0x68, 0x10, 0xBE, 0x99, 0x6B, 0x54, 0x97, 0xE7, + 0xE5, 0xCC, 0x80, 0xE3, 0x12, 0xF6, 0x1E, 0x71, + 0xFF, 0x3E, 0x96, 0x24, 0x43, 0x60, 0x73, 0x15, + 0x64, 0x03, 0xF7, 0x35, 0xF5, 0x6B, 0x0B, 0x01, + 0x84, 0x5C, 0x18, 0xF6, 0xCA, 0xF7, 0x72, 0xE6 + }, + { + 0x02, 0xF7, 0xEF, 0x3A, 0x9C, 0xE0, 0xFF, 0xF9, + 0x60, 0xF6, 0x70, 0x32, 0xB2, 0x96, 0xEF, 0xCA, + 0x30, 0x61, 0xF4, 0x93, 0x4D, 0x69, 0x07, 0x49, + 0xF2, 0xD0, 0x1C, 0x35, 0xC8, 0x1C, 0x14, 0xF3, + 0x9A, 0x67, 0xFA, 0x35, 0x0B, 0xC8, 0xA0, 0x35, + 0x9B, 0xF1, 0x72, 0x4B, 0xFF, 0xC3, 0xBC, 0xA6, + 0xD7, 0xC7, 0xBB, 0xA4, 0x79, 0x1F, 0xD5, 0x22, + 0xA3, 0xAD, 0x35, 0x3C, 0x02, 0xEC, 0x5A, 0xA8 + }, + { + 0x64, 0xBE, 0x5C, 0x6A, 0xBA, 0x65, 0xD5, 0x94, + 0x84, 0x4A, 0xE7, 0x8B, 0xB0, 0x22, 0xE5, 0xBE, + 0xBE, 0x12, 0x7F, 0xD6, 0xB6, 0xFF, 0xA5, 0xA1, + 0x37, 0x03, 0x85, 0x5A, 0xB6, 0x3B, 0x62, 0x4D, + 0xCD, 0x1A, 0x36, 0x3F, 0x99, 0x20, 0x3F, 0x63, + 0x2E, 0xC3, 0x86, 0xF3, 0xEA, 0x76, 0x7F, 0xC9, + 0x92, 0xE8, 0xED, 0x96, 0x86, 0x58, 0x6A, 0xA2, + 0x75, 0x55, 0xA8, 0x59, 0x9D, 0x5B, 0x80, 0x8F + }, + { + 0xF7, 0x85, 0x85, 0x50, 0x5C, 0x4E, 0xAA, 0x54, + 0xA8, 0xB5, 0xBE, 0x70, 0xA6, 0x1E, 0x73, 0x5E, + 0x0F, 0xF9, 0x7A, 0xF9, 0x44, 0xDD, 0xB3, 0x00, + 0x1E, 0x35, 0xD8, 0x6C, 0x4E, 0x21, 0x99, 0xD9, + 0x76, 0x10, 0x4B, 0x6A, 0xE3, 0x17, 0x50, 0xA3, + 0x6A, 0x72, 0x6E, 0xD2, 0x85, 0x06, 0x4F, 0x59, + 0x81, 0xB5, 0x03, 0x88, 0x9F, 0xEF, 0x82, 0x2F, + 0xCD, 0xC2, 0x89, 0x8D, 0xDD, 0xB7, 0x88, 0x9A + }, + { + 0xE4, 0xB5, 0x56, 0x60, 0x33, 0x86, 0x95, 0x72, + 0xED, 0xFD, 0x87, 0x47, 0x9A, 0x5B, 0xB7, 0x3C, + 0x80, 0xE8, 0x75, 0x9B, 0x91, 0x23, 0x28, 0x79, + 0xD9, 0x6B, 0x1D, 0xDA, 0x36, 0xC0, 0x12, 0x07, + 0x6E, 0xE5, 0xA2, 0xED, 0x7A, 0xE2, 0xDE, 0x63, + 0xEF, 0x84, 0x06, 0xA0, 0x6A, 0xEA, 0x82, 0xC1, + 0x88, 0x03, 0x1B, 0x56, 0x0B, 0xEA, 0xFB, 0x58, + 0x3F, 0xB3, 0xDE, 0x9E, 0x57, 0x95, 0x2A, 0x7E + }, + { + 0xE1, 0xB3, 0xE7, 0xED, 0x86, 0x7F, 0x6C, 0x94, + 0x84, 0xA2, 0xA9, 0x7F, 0x77, 0x15, 0xF2, 0x5E, + 0x25, 0x29, 0x4E, 0x99, 0x2E, 0x41, 0xF6, 0xA7, + 0xC1, 0x61, 0xFF, 0xC2, 0xAD, 0xC6, 0xDA, 0xAE, + 0xB7, 0x11, 0x31, 0x02, 0xD5, 0xE6, 0x09, 0x02, + 0x87, 0xFE, 0x6A, 0xD9, 0x4C, 0xE5, 0xD6, 0xB7, + 0x39, 0xC6, 0xCA, 0x24, 0x0B, 0x05, 0xC7, 0x6F, + 0xB7, 0x3F, 0x25, 0xDD, 0x02, 0x4B, 0xF9, 0x35 + }, + { + 0x85, 0xFD, 0x08, 0x5F, 0xDC, 0x12, 0xA0, 0x80, + 0x98, 0x3D, 0xF0, 0x7B, 0xD7, 0x01, 0x2B, 0x0D, + 0x40, 0x2A, 0x0F, 0x40, 0x43, 0xFC, 0xB2, 0x77, + 0x5A, 0xDF, 0x0B, 0xAD, 0x17, 0x4F, 0x9B, 0x08, + 0xD1, 0x67, 0x6E, 0x47, 0x69, 0x85, 0x78, 0x5C, + 0x0A, 0x5D, 0xCC, 0x41, 0xDB, 0xFF, 0x6D, 0x95, + 0xEF, 0x4D, 0x66, 0xA3, 0xFB, 0xDC, 0x4A, 0x74, + 0xB8, 0x2B, 0xA5, 0x2D, 0xA0, 0x51, 0x2B, 0x74 + }, + { + 0xAE, 0xD8, 0xFA, 0x76, 0x4B, 0x0F, 0xBF, 0xF8, + 0x21, 0xE0, 0x52, 0x33, 0xD2, 0xF7, 0xB0, 0x90, + 0x0E, 0xC4, 0x4D, 0x82, 0x6F, 0x95, 0xE9, 0x3C, + 0x34, 0x3C, 0x1B, 0xC3, 0xBA, 0x5A, 0x24, 0x37, + 0x4B, 0x1D, 0x61, 0x6E, 0x7E, 0x7A, 0xBA, 0x45, + 0x3A, 0x0A, 0xDA, 0x5E, 0x4F, 0xAB, 0x53, 0x82, + 0x40, 0x9E, 0x0D, 0x42, 0xCE, 0x9C, 0x2B, 0xC7, + 0xFB, 0x39, 0xA9, 0x9C, 0x34, 0x0C, 0x20, 0xF0 + }, + { + 0x7B, 0xA3, 0xB2, 0xE2, 0x97, 0x23, 0x35, 0x22, + 0xEE, 0xB3, 0x43, 0xBD, 0x3E, 0xBC, 0xFD, 0x83, + 0x5A, 0x04, 0x00, 0x77, 0x35, 0xE8, 0x7F, 0x0C, + 0xA3, 0x00, 0xCB, 0xEE, 0x6D, 0x41, 0x65, 0x65, + 0x16, 0x21, 0x71, 0x58, 0x1E, 0x40, 0x20, 0xFF, + 0x4C, 0xF1, 0x76, 0x45, 0x0F, 0x12, 0x91, 0xEA, + 0x22, 0x85, 0xCB, 0x9E, 0xBF, 0xFE, 0x4C, 0x56, + 0x66, 0x06, 0x27, 0x68, 0x51, 0x45, 0x05, 0x1C + }, + { + 0xDE, 0x74, 0x8B, 0xCF, 0x89, 0xEC, 0x88, 0x08, + 0x47, 0x21, 0xE1, 0x6B, 0x85, 0xF3, 0x0A, 0xDB, + 0x1A, 0x61, 0x34, 0xD6, 0x64, 0xB5, 0x84, 0x35, + 0x69, 0xBA, 0xBC, 0x5B, 0xBD, 0x1A, 0x15, 0xCA, + 0x9B, 0x61, 0x80, 0x3C, 0x90, 0x1A, 0x4F, 0xEF, + 0x32, 0x96, 0x5A, 0x17, 0x49, 0xC9, 0xF3, 0xA4, + 0xE2, 0x43, 0xE1, 0x73, 0x93, 0x9D, 0xC5, 0xA8, + 0xDC, 0x49, 0x5C, 0x67, 0x1A, 0xB5, 0x21, 0x45 + }, + { + 0xAA, 0xF4, 0xD2, 0xBD, 0xF2, 0x00, 0xA9, 0x19, + 0x70, 0x6D, 0x98, 0x42, 0xDC, 0xE1, 0x6C, 0x98, + 0x14, 0x0D, 0x34, 0xBC, 0x43, 0x3D, 0xF3, 0x20, + 0xAB, 0xA9, 0xBD, 0x42, 0x9E, 0x54, 0x9A, 0xA7, + 0xA3, 0x39, 0x76, 0x52, 0xA4, 0xD7, 0x68, 0x27, + 0x77, 0x86, 0xCF, 0x99, 0x3C, 0xDE, 0x23, 0x38, + 0x67, 0x3E, 0xD2, 0xE6, 0xB6, 0x6C, 0x96, 0x1F, + 0xEF, 0xB8, 0x2C, 0xD2, 0x0C, 0x93, 0x33, 0x8F + }, + { + 0xC4, 0x08, 0x21, 0x89, 0x68, 0xB7, 0x88, 0xBF, + 0x86, 0x4F, 0x09, 0x97, 0xE6, 0xBC, 0x4C, 0x3D, + 0xBA, 0x68, 0xB2, 0x76, 0xE2, 0x12, 0x5A, 0x48, + 0x43, 0x29, 0x60, 0x52, 0xFF, 0x93, 0xBF, 0x57, + 0x67, 0xB8, 0xCD, 0xCE, 0x71, 0x31, 0xF0, 0x87, + 0x64, 0x30, 0xC1, 0x16, 0x5F, 0xEC, 0x6C, 0x4F, + 0x47, 0xAD, 0xAA, 0x4F, 0xD8, 0xBC, 0xFA, 0xCE, + 0xF4, 0x63, 0xB5, 0xD3, 0xD0, 0xFA, 0x61, 0xA0 + }, + { + 0x76, 0xD2, 0xD8, 0x19, 0xC9, 0x2B, 0xCE, 0x55, + 0xFA, 0x8E, 0x09, 0x2A, 0xB1, 0xBF, 0x9B, 0x9E, + 0xAB, 0x23, 0x7A, 0x25, 0x26, 0x79, 0x86, 0xCA, + 0xCF, 0x2B, 0x8E, 0xE1, 0x4D, 0x21, 0x4D, 0x73, + 0x0D, 0xC9, 0xA5, 0xAA, 0x2D, 0x7B, 0x59, 0x6E, + 0x86, 0xA1, 0xFD, 0x8F, 0xA0, 0x80, 0x4C, 0x77, + 0x40, 0x2D, 0x2F, 0xCD, 0x45, 0x08, 0x36, 0x88, + 0xB2, 0x18, 0xB1, 0xCD, 0xFA, 0x0D, 0xCB, 0xCB + }, + { + 0x72, 0x06, 0x5E, 0xE4, 0xDD, 0x91, 0xC2, 0xD8, + 0x50, 0x9F, 0xA1, 0xFC, 0x28, 0xA3, 0x7C, 0x7F, + 0xC9, 0xFA, 0x7D, 0x5B, 0x3F, 0x8A, 0xD3, 0xD0, + 0xD7, 0xA2, 0x56, 0x26, 0xB5, 0x7B, 0x1B, 0x44, + 0x78, 0x8D, 0x4C, 0xAF, 0x80, 0x62, 0x90, 0x42, + 0x5F, 0x98, 0x90, 0xA3, 0xA2, 0xA3, 0x5A, 0x90, + 0x5A, 0xB4, 0xB3, 0x7A, 0xCF, 0xD0, 0xDA, 0x6E, + 0x45, 0x17, 0xB2, 0x52, 0x5C, 0x96, 0x51, 0xE4 + }, + { + 0x64, 0x47, 0x5D, 0xFE, 0x76, 0x00, 0xD7, 0x17, + 0x1B, 0xEA, 0x0B, 0x39, 0x4E, 0x27, 0xC9, 0xB0, + 0x0D, 0x8E, 0x74, 0xDD, 0x1E, 0x41, 0x6A, 0x79, + 0x47, 0x36, 0x82, 0xAD, 0x3D, 0xFD, 0xBB, 0x70, + 0x66, 0x31, 0x55, 0x80, 0x55, 0xCF, 0xC8, 0xA4, + 0x0E, 0x07, 0xBD, 0x01, 0x5A, 0x45, 0x40, 0xDC, + 0xDE, 0xA1, 0x58, 0x83, 0xCB, 0xBF, 0x31, 0x41, + 0x2D, 0xF1, 0xDE, 0x1C, 0xD4, 0x15, 0x2B, 0x91 + }, + { + 0x12, 0xCD, 0x16, 0x74, 0xA4, 0x48, 0x8A, 0x5D, + 0x7C, 0x2B, 0x31, 0x60, 0xD2, 0xE2, 0xC4, 0xB5, + 0x83, 0x71, 0xBE, 0xDA, 0xD7, 0x93, 0x41, 0x8D, + 0x6F, 0x19, 0xC6, 0xEE, 0x38, 0x5D, 0x70, 0xB3, + 0xE0, 0x67, 0x39, 0x36, 0x9D, 0x4D, 0xF9, 0x10, + 0xED, 0xB0, 0xB0, 0xA5, 0x4C, 0xBF, 0xF4, 0x3D, + 0x54, 0x54, 0x4C, 0xD3, 0x7A, 0xB3, 0xA0, 0x6C, + 0xFA, 0x0A, 0x3D, 0xDA, 0xC8, 0xB6, 0x6C, 0x89 + }, + { + 0x60, 0x75, 0x69, 0x66, 0x47, 0x9D, 0xED, 0xC6, + 0xDD, 0x4B, 0xCF, 0xF8, 0xEA, 0x7D, 0x1D, 0x4C, + 0xE4, 0xD4, 0xAF, 0x2E, 0x7B, 0x09, 0x7E, 0x32, + 0xE3, 0x76, 0x35, 0x18, 0x44, 0x11, 0x47, 0xCC, + 0x12, 0xB3, 0xC0, 0xEE, 0x6D, 0x2E, 0xCA, 0xBF, + 0x11, 0x98, 0xCE, 0xC9, 0x2E, 0x86, 0xA3, 0x61, + 0x6F, 0xBA, 0x4F, 0x4E, 0x87, 0x2F, 0x58, 0x25, + 0x33, 0x0A, 0xDB, 0xB4, 0xC1, 0xDE, 0xE4, 0x44 + }, + { + 0xA7, 0x80, 0x3B, 0xCB, 0x71, 0xBC, 0x1D, 0x0F, + 0x43, 0x83, 0xDD, 0xE1, 0xE0, 0x61, 0x2E, 0x04, + 0xF8, 0x72, 0xB7, 0x15, 0xAD, 0x30, 0x81, 0x5C, + 0x22, 0x49, 0xCF, 0x34, 0xAB, 0xB8, 0xB0, 0x24, + 0x91, 0x5C, 0xB2, 0xFC, 0x9F, 0x4E, 0x7C, 0xC4, + 0xC8, 0xCF, 0xD4, 0x5B, 0xE2, 0xD5, 0xA9, 0x1E, + 0xAB, 0x09, 0x41, 0xC7, 0xD2, 0x70, 0xE2, 0xDA, + 0x4C, 0xA4, 0xA9, 0xF7, 0xAC, 0x68, 0x66, 0x3A + }, + { + 0xB8, 0x4E, 0xF6, 0xA7, 0x22, 0x9A, 0x34, 0xA7, + 0x50, 0xD9, 0xA9, 0x8E, 0xE2, 0x52, 0x98, 0x71, + 0x81, 0x6B, 0x87, 0xFB, 0xE3, 0xBC, 0x45, 0xB4, + 0x5F, 0xA5, 0xAE, 0x82, 0xD5, 0x14, 0x15, 0x40, + 0x21, 0x11, 0x65, 0xC3, 0xC5, 0xD7, 0xA7, 0x47, + 0x6B, 0xA5, 0xA4, 0xAA, 0x06, 0xD6, 0x64, 0x76, + 0xF0, 0xD9, 0xDC, 0x49, 0xA3, 0xF1, 0xEE, 0x72, + 0xC3, 0xAC, 0xAB, 0xD4, 0x98, 0x96, 0x74, 0x14 + }, + { + 0xFA, 0xE4, 0xB6, 0xD8, 0xEF, 0xC3, 0xF8, 0xC8, + 0xE6, 0x4D, 0x00, 0x1D, 0xAB, 0xEC, 0x3A, 0x21, + 0xF5, 0x44, 0xE8, 0x27, 0x14, 0x74, 0x52, 0x51, + 0xB2, 0xB4, 0xB3, 0x93, 0xF2, 0xF4, 0x3E, 0x0D, + 0xA3, 0xD4, 0x03, 0xC6, 0x4D, 0xB9, 0x5A, 0x2C, + 0xB6, 0xE2, 0x3E, 0xBB, 0x7B, 0x9E, 0x94, 0xCD, + 0xD5, 0xDD, 0xAC, 0x54, 0xF0, 0x7C, 0x4A, 0x61, + 0xBD, 0x3C, 0xB1, 0x0A, 0xA6, 0xF9, 0x3B, 0x49 + }, + { + 0x34, 0xF7, 0x28, 0x66, 0x05, 0xA1, 0x22, 0x36, + 0x95, 0x40, 0x14, 0x1D, 0xED, 0x79, 0xB8, 0x95, + 0x72, 0x55, 0xDA, 0x2D, 0x41, 0x55, 0xAB, 0xBF, + 0x5A, 0x8D, 0xBB, 0x89, 0xC8, 0xEB, 0x7E, 0xDE, + 0x8E, 0xEE, 0xF1, 0xDA, 0xA4, 0x6D, 0xC2, 0x9D, + 0x75, 0x1D, 0x04, 0x5D, 0xC3, 0xB1, 0xD6, 0x58, + 0xBB, 0x64, 0xB8, 0x0F, 0xF8, 0x58, 0x9E, 0xDD, + 0xB3, 0x82, 0x4B, 0x13, 0xDA, 0x23, 0x5A, 0x6B + }, + { + 0x3B, 0x3B, 0x48, 0x43, 0x4B, 0xE2, 0x7B, 0x9E, + 0xAB, 0xAB, 0xBA, 0x43, 0xBF, 0x6B, 0x35, 0xF1, + 0x4B, 0x30, 0xF6, 0xA8, 0x8D, 0xC2, 0xE7, 0x50, + 0xC3, 0x58, 0x47, 0x0D, 0x6B, 0x3A, 0xA3, 0xC1, + 0x8E, 0x47, 0xDB, 0x40, 0x17, 0xFA, 0x55, 0x10, + 0x6D, 0x82, 0x52, 0xF0, 0x16, 0x37, 0x1A, 0x00, + 0xF5, 0xF8, 0xB0, 0x70, 0xB7, 0x4B, 0xA5, 0xF2, + 0x3C, 0xFF, 0xC5, 0x51, 0x1C, 0x9F, 0x09, 0xF0 + }, + { + 0xBA, 0x28, 0x9E, 0xBD, 0x65, 0x62, 0xC4, 0x8C, + 0x3E, 0x10, 0xA8, 0xAD, 0x6C, 0xE0, 0x2E, 0x73, + 0x43, 0x3D, 0x1E, 0x93, 0xD7, 0xC9, 0x27, 0x9D, + 0x4D, 0x60, 0xA7, 0xE8, 0x79, 0xEE, 0x11, 0xF4, + 0x41, 0xA0, 0x00, 0xF4, 0x8E, 0xD9, 0xF7, 0xC4, + 0xED, 0x87, 0xA4, 0x51, 0x36, 0xD7, 0xDC, 0xCD, + 0xCA, 0x48, 0x21, 0x09, 0xC7, 0x8A, 0x51, 0x06, + 0x2B, 0x3B, 0xA4, 0x04, 0x4A, 0xDA, 0x24, 0x69 + }, + { + 0x02, 0x29, 0x39, 0xE2, 0x38, 0x6C, 0x5A, 0x37, + 0x04, 0x98, 0x56, 0xC8, 0x50, 0xA2, 0xBB, 0x10, + 0xA1, 0x3D, 0xFE, 0xA4, 0x21, 0x2B, 0x4C, 0x73, + 0x2A, 0x88, 0x40, 0xA9, 0xFF, 0xA5, 0xFA, 0xF5, + 0x48, 0x75, 0xC5, 0x44, 0x88, 0x16, 0xB2, 0x78, + 0x5A, 0x00, 0x7D, 0xA8, 0xA8, 0xD2, 0xBC, 0x7D, + 0x71, 0xA5, 0x4E, 0x4E, 0x65, 0x71, 0xF1, 0x0B, + 0x60, 0x0C, 0xBD, 0xB2, 0x5D, 0x13, 0xED, 0xE3 + }, + { + 0xE6, 0xFE, 0xC1, 0x9D, 0x89, 0xCE, 0x87, 0x17, + 0xB1, 0xA0, 0x87, 0x02, 0x46, 0x70, 0xFE, 0x02, + 0x6F, 0x6C, 0x7C, 0xBD, 0xA1, 0x1C, 0xAE, 0xF9, + 0x59, 0xBB, 0x2D, 0x35, 0x1B, 0xF8, 0x56, 0xF8, + 0x05, 0x5D, 0x1C, 0x0E, 0xBD, 0xAA, 0xA9, 0xD1, + 0xB1, 0x78, 0x86, 0xFC, 0x2C, 0x56, 0x2B, 0x5E, + 0x99, 0x64, 0x2F, 0xC0, 0x64, 0x71, 0x0C, 0x0D, + 0x34, 0x88, 0xA0, 0x2B, 0x5E, 0xD7, 0xF6, 0xFD + }, + { + 0x94, 0xC9, 0x6F, 0x02, 0xA8, 0xF5, 0x76, 0xAC, + 0xA3, 0x2B, 0xA6, 0x1C, 0x2B, 0x20, 0x6F, 0x90, + 0x72, 0x85, 0xD9, 0x29, 0x9B, 0x83, 0xAC, 0x17, + 0x5C, 0x20, 0x9A, 0x8D, 0x43, 0xD5, 0x3B, 0xFE, + 0x68, 0x3D, 0xD1, 0xD8, 0x3E, 0x75, 0x49, 0xCB, + 0x90, 0x6C, 0x28, 0xF5, 0x9A, 0xB7, 0xC4, 0x6F, + 0x87, 0x51, 0x36, 0x6A, 0x28, 0xC3, 0x9D, 0xD5, + 0xFE, 0x26, 0x93, 0xC9, 0x01, 0x96, 0x66, 0xC8 + }, + { + 0x31, 0xA0, 0xCD, 0x21, 0x5E, 0xBD, 0x2C, 0xB6, + 0x1D, 0xE5, 0xB9, 0xED, 0xC9, 0x1E, 0x61, 0x95, + 0xE3, 0x1C, 0x59, 0xA5, 0x64, 0x8D, 0x5C, 0x9F, + 0x73, 0x7E, 0x12, 0x5B, 0x26, 0x05, 0x70, 0x8F, + 0x2E, 0x32, 0x5A, 0xB3, 0x38, 0x1C, 0x8D, 0xCE, + 0x1A, 0x3E, 0x95, 0x88, 0x86, 0xF1, 0xEC, 0xDC, + 0x60, 0x31, 0x8F, 0x88, 0x2C, 0xFE, 0x20, 0xA2, + 0x41, 0x91, 0x35, 0x2E, 0x61, 0x7B, 0x0F, 0x21 + }, + { + 0x91, 0xAB, 0x50, 0x4A, 0x52, 0x2D, 0xCE, 0x78, + 0x77, 0x9F, 0x4C, 0x6C, 0x6B, 0xA2, 0xE6, 0xB6, + 0xDB, 0x55, 0x65, 0xC7, 0x6D, 0x3E, 0x7E, 0x7C, + 0x92, 0x0C, 0xAF, 0x7F, 0x75, 0x7E, 0xF9, 0xDB, + 0x7C, 0x8F, 0xCF, 0x10, 0xE5, 0x7F, 0x03, 0x37, + 0x9E, 0xA9, 0xBF, 0x75, 0xEB, 0x59, 0x89, 0x5D, + 0x96, 0xE1, 0x49, 0x80, 0x0B, 0x6A, 0xAE, 0x01, + 0xDB, 0x77, 0x8B, 0xB9, 0x0A, 0xFB, 0xC9, 0x89 + }, + { + 0xD8, 0x5C, 0xAB, 0xC6, 0xBD, 0x5B, 0x1A, 0x01, + 0xA5, 0xAF, 0xD8, 0xC6, 0x73, 0x47, 0x40, 0xDA, + 0x9F, 0xD1, 0xC1, 0xAC, 0xC6, 0xDB, 0x29, 0xBF, + 0xC8, 0xA2, 0xE5, 0xB6, 0x68, 0xB0, 0x28, 0xB6, + 0xB3, 0x15, 0x4B, 0xFB, 0x87, 0x03, 0xFA, 0x31, + 0x80, 0x25, 0x1D, 0x58, 0x9A, 0xD3, 0x80, 0x40, + 0xCE, 0xB7, 0x07, 0xC4, 0xBA, 0xD1, 0xB5, 0x34, + 0x3C, 0xB4, 0x26, 0xB6, 0x1E, 0xAA, 0x49, 0xC1 + }, + { + 0xD6, 0x2E, 0xFB, 0xEC, 0x2C, 0xA9, 0xC1, 0xF8, + 0xBD, 0x66, 0xCE, 0x8B, 0x3F, 0x6A, 0x89, 0x8C, + 0xB3, 0xF7, 0x56, 0x6B, 0xA6, 0x56, 0x8C, 0x61, + 0x8A, 0xD1, 0xFE, 0xB2, 0xB6, 0x5B, 0x76, 0xC3, + 0xCE, 0x1D, 0xD2, 0x0F, 0x73, 0x95, 0x37, 0x2F, + 0xAF, 0x28, 0x42, 0x7F, 0x61, 0xC9, 0x27, 0x80, + 0x49, 0xCF, 0x01, 0x40, 0xDF, 0x43, 0x4F, 0x56, + 0x33, 0x04, 0x8C, 0x86, 0xB8, 0x1E, 0x03, 0x99 + }, + { + 0x7C, 0x8F, 0xDC, 0x61, 0x75, 0x43, 0x9E, 0x2C, + 0x3D, 0xB1, 0x5B, 0xAF, 0xA7, 0xFB, 0x06, 0x14, + 0x3A, 0x6A, 0x23, 0xBC, 0x90, 0xF4, 0x49, 0xE7, + 0x9D, 0xEE, 0xF7, 0x3C, 0x3D, 0x49, 0x2A, 0x67, + 0x17, 0x15, 0xC1, 0x93, 0xB6, 0xFE, 0xA9, 0xF0, + 0x36, 0x05, 0x0B, 0x94, 0x60, 0x69, 0x85, 0x6B, + 0x89, 0x7E, 0x08, 0xC0, 0x07, 0x68, 0xF5, 0xEE, + 0x5D, 0xDC, 0xF7, 0x0B, 0x7C, 0xD6, 0xD0, 0xE0 + }, + { + 0x58, 0x60, 0x2E, 0xE7, 0x46, 0x8E, 0x6B, 0xC9, + 0xDF, 0x21, 0xBD, 0x51, 0xB2, 0x3C, 0x00, 0x5F, + 0x72, 0xD6, 0xCB, 0x01, 0x3F, 0x0A, 0x1B, 0x48, + 0xCB, 0xEC, 0x5E, 0xCA, 0x29, 0x92, 0x99, 0xF9, + 0x7F, 0x09, 0xF5, 0x4A, 0x9A, 0x01, 0x48, 0x3E, + 0xAE, 0xB3, 0x15, 0xA6, 0x47, 0x8B, 0xAD, 0x37, + 0xBA, 0x47, 0xCA, 0x13, 0x47, 0xC7, 0xC8, 0xFC, + 0x9E, 0x66, 0x95, 0x59, 0x2C, 0x91, 0xD7, 0x23 + }, + { + 0x27, 0xF5, 0xB7, 0x9E, 0xD2, 0x56, 0xB0, 0x50, + 0x99, 0x3D, 0x79, 0x34, 0x96, 0xED, 0xF4, 0x80, + 0x7C, 0x1D, 0x85, 0xA7, 0xB0, 0xA6, 0x7C, 0x9C, + 0x4F, 0xA9, 0x98, 0x60, 0x75, 0x0B, 0x0A, 0xE6, + 0x69, 0x89, 0x67, 0x0A, 0x8F, 0xFD, 0x78, 0x56, + 0xD7, 0xCE, 0x41, 0x15, 0x99, 0xE5, 0x8C, 0x4D, + 0x77, 0xB2, 0x32, 0xA6, 0x2B, 0xEF, 0x64, 0xD1, + 0x52, 0x75, 0xBE, 0x46, 0xA6, 0x82, 0x35, 0xFF + }, + { + 0x39, 0x57, 0xA9, 0x76, 0xB9, 0xF1, 0x88, 0x7B, + 0xF0, 0x04, 0xA8, 0xDC, 0xA9, 0x42, 0xC9, 0x2D, + 0x2B, 0x37, 0xEA, 0x52, 0x60, 0x0F, 0x25, 0xE0, + 0xC9, 0xBC, 0x57, 0x07, 0xD0, 0x27, 0x9C, 0x00, + 0xC6, 0xE8, 0x5A, 0x83, 0x9B, 0x0D, 0x2D, 0x8E, + 0xB5, 0x9C, 0x51, 0xD9, 0x47, 0x88, 0xEB, 0xE6, + 0x24, 0x74, 0xA7, 0x91, 0xCA, 0xDF, 0x52, 0xCC, + 0xCF, 0x20, 0xF5, 0x07, 0x0B, 0x65, 0x73, 0xFC + }, + { + 0xEA, 0xA2, 0x37, 0x6D, 0x55, 0x38, 0x0B, 0xF7, + 0x72, 0xEC, 0xCA, 0x9C, 0xB0, 0xAA, 0x46, 0x68, + 0xC9, 0x5C, 0x70, 0x71, 0x62, 0xFA, 0x86, 0xD5, + 0x18, 0xC8, 0xCE, 0x0C, 0xA9, 0xBF, 0x73, 0x62, + 0xB9, 0xF2, 0xA0, 0xAD, 0xC3, 0xFF, 0x59, 0x92, + 0x2D, 0xF9, 0x21, 0xB9, 0x45, 0x67, 0xE8, 0x1E, + 0x45, 0x2F, 0x6C, 0x1A, 0x07, 0xFC, 0x81, 0x7C, + 0xEB, 0xE9, 0x96, 0x04, 0xB3, 0x50, 0x5D, 0x38 + }, + { + 0xC1, 0xE2, 0xC7, 0x8B, 0x6B, 0x27, 0x34, 0xE2, + 0x48, 0x0E, 0xC5, 0x50, 0x43, 0x4C, 0xB5, 0xD6, + 0x13, 0x11, 0x1A, 0xDC, 0xC2, 0x1D, 0x47, 0x55, + 0x45, 0xC3, 0xB1, 0xB7, 0xE6, 0xFF, 0x12, 0x44, + 0x44, 0x76, 0xE5, 0xC0, 0x55, 0x13, 0x2E, 0x22, + 0x29, 0xDC, 0x0F, 0x80, 0x70, 0x44, 0xBB, 0x91, + 0x9B, 0x1A, 0x56, 0x62, 0xDD, 0x38, 0xA9, 0xEE, + 0x65, 0xE2, 0x43, 0xA3, 0x91, 0x1A, 0xED, 0x1A + }, + { + 0x8A, 0xB4, 0x87, 0x13, 0x38, 0x9D, 0xD0, 0xFC, + 0xF9, 0xF9, 0x65, 0xD3, 0xCE, 0x66, 0xB1, 0xE5, + 0x59, 0xA1, 0xF8, 0xC5, 0x87, 0x41, 0xD6, 0x76, + 0x83, 0xCD, 0x97, 0x13, 0x54, 0xF4, 0x52, 0xE6, + 0x2D, 0x02, 0x07, 0xA6, 0x5E, 0x43, 0x6C, 0x5D, + 0x5D, 0x8F, 0x8E, 0xE7, 0x1C, 0x6A, 0xBF, 0xE5, + 0x0E, 0x66, 0x90, 0x04, 0xC3, 0x02, 0xB3, 0x1A, + 0x7E, 0xA8, 0x31, 0x1D, 0x4A, 0x91, 0x60, 0x51 + }, + { + 0x24, 0xCE, 0x0A, 0xDD, 0xAA, 0x4C, 0x65, 0x03, + 0x8B, 0xD1, 0xB1, 0xC0, 0xF1, 0x45, 0x2A, 0x0B, + 0x12, 0x87, 0x77, 0xAA, 0xBC, 0x94, 0xA2, 0x9D, + 0xF2, 0xFD, 0x6C, 0x7E, 0x2F, 0x85, 0xF8, 0xAB, + 0x9A, 0xC7, 0xEF, 0xF5, 0x16, 0xB0, 0xE0, 0xA8, + 0x25, 0xC8, 0x4A, 0x24, 0xCF, 0xE4, 0x92, 0xEA, + 0xAD, 0x0A, 0x63, 0x08, 0xE4, 0x6D, 0xD4, 0x2F, + 0xE8, 0x33, 0x3A, 0xB9, 0x71, 0xBB, 0x30, 0xCA + }, + { + 0x51, 0x54, 0xF9, 0x29, 0xEE, 0x03, 0x04, 0x5B, + 0x6B, 0x0C, 0x00, 0x04, 0xFA, 0x77, 0x8E, 0xDE, + 0xE1, 0xD1, 0x39, 0x89, 0x32, 0x67, 0xCC, 0x84, + 0x82, 0x5A, 0xD7, 0xB3, 0x6C, 0x63, 0xDE, 0x32, + 0x79, 0x8E, 0x4A, 0x16, 0x6D, 0x24, 0x68, 0x65, + 0x61, 0x35, 0x4F, 0x63, 0xB0, 0x07, 0x09, 0xA1, + 0x36, 0x4B, 0x3C, 0x24, 0x1D, 0xE3, 0xFE, 0xBF, + 0x07, 0x54, 0x04, 0x58, 0x97, 0x46, 0x7C, 0xD4 + }, + { + 0xE7, 0x4E, 0x90, 0x79, 0x20, 0xFD, 0x87, 0xBD, + 0x5A, 0xD6, 0x36, 0xDD, 0x11, 0x08, 0x5E, 0x50, + 0xEE, 0x70, 0x45, 0x9C, 0x44, 0x3E, 0x1C, 0xE5, + 0x80, 0x9A, 0xF2, 0xBC, 0x2E, 0xBA, 0x39, 0xF9, + 0xE6, 0xD7, 0x12, 0x8E, 0x0E, 0x37, 0x12, 0xC3, + 0x16, 0xDA, 0x06, 0xF4, 0x70, 0x5D, 0x78, 0xA4, + 0x83, 0x8E, 0x28, 0x12, 0x1D, 0x43, 0x44, 0xA2, + 0xC7, 0x9C, 0x5E, 0x0D, 0xB3, 0x07, 0xA6, 0x77 + }, + { + 0xBF, 0x91, 0xA2, 0x23, 0x34, 0xBA, 0xC2, 0x0F, + 0x3F, 0xD8, 0x06, 0x63, 0xB3, 0xCD, 0x06, 0xC4, + 0xE8, 0x80, 0x2F, 0x30, 0xE6, 0xB5, 0x9F, 0x90, + 0xD3, 0x03, 0x5C, 0xC9, 0x79, 0x8A, 0x21, 0x7E, + 0xD5, 0xA3, 0x1A, 0xBB, 0xDA, 0x7F, 0xA6, 0x84, + 0x28, 0x27, 0xBD, 0xF2, 0xA7, 0xA1, 0xC2, 0x1F, + 0x6F, 0xCF, 0xCC, 0xBB, 0x54, 0xC6, 0xC5, 0x29, + 0x26, 0xF3, 0x2D, 0xA8, 0x16, 0x26, 0x9B, 0xE1 + }, + { + 0xD9, 0xD5, 0xC7, 0x4B, 0xE5, 0x12, 0x1B, 0x0B, + 0xD7, 0x42, 0xF2, 0x6B, 0xFF, 0xB8, 0xC8, 0x9F, + 0x89, 0x17, 0x1F, 0x3F, 0x93, 0x49, 0x13, 0x49, + 0x2B, 0x09, 0x03, 0xC2, 0x71, 0xBB, 0xE2, 0xB3, + 0x39, 0x5E, 0xF2, 0x59, 0x66, 0x9B, 0xEF, 0x43, + 0xB5, 0x7F, 0x7F, 0xCC, 0x30, 0x27, 0xDB, 0x01, + 0x82, 0x3F, 0x6B, 0xAE, 0xE6, 0x6E, 0x4F, 0x9F, + 0xEA, 0xD4, 0xD6, 0x72, 0x6C, 0x74, 0x1F, 0xCE + }, + { + 0x50, 0xC8, 0xB8, 0xCF, 0x34, 0xCD, 0x87, 0x9F, + 0x80, 0xE2, 0xFA, 0xAB, 0x32, 0x30, 0xB0, 0xC0, + 0xE1, 0xCC, 0x3E, 0x9D, 0xCA, 0xDE, 0xB1, 0xB9, + 0xD9, 0x7A, 0xB9, 0x23, 0x41, 0x5D, 0xD9, 0xA1, + 0xFE, 0x38, 0xAD, 0xDD, 0x5C, 0x11, 0x75, 0x6C, + 0x67, 0x99, 0x0B, 0x25, 0x6E, 0x95, 0xAD, 0x6D, + 0x8F, 0x9F, 0xED, 0xCE, 0x10, 0xBF, 0x1C, 0x90, + 0x67, 0x9C, 0xDE, 0x0E, 0xCF, 0x1B, 0xE3, 0x47 + }, + { + 0x0A, 0x38, 0x6E, 0x7C, 0xD5, 0xDD, 0x9B, 0x77, + 0xA0, 0x35, 0xE0, 0x9F, 0xE6, 0xFE, 0xE2, 0xC8, + 0xCE, 0x61, 0xB5, 0x38, 0x3C, 0x87, 0xEA, 0x43, + 0x20, 0x50, 0x59, 0xC5, 0xE4, 0xCD, 0x4F, 0x44, + 0x08, 0x31, 0x9B, 0xB0, 0xA8, 0x23, 0x60, 0xF6, + 0xA5, 0x8E, 0x6C, 0x9C, 0xE3, 0xF4, 0x87, 0xC4, + 0x46, 0x06, 0x3B, 0xF8, 0x13, 0xBC, 0x6B, 0xA5, + 0x35, 0xE1, 0x7F, 0xC1, 0x82, 0x6C, 0xFC, 0x91 + }, + { + 0x1F, 0x14, 0x59, 0xCB, 0x6B, 0x61, 0xCB, 0xAC, + 0x5F, 0x0E, 0xFE, 0x8F, 0xC4, 0x87, 0x53, 0x8F, + 0x42, 0x54, 0x89, 0x87, 0xFC, 0xD5, 0x62, 0x21, + 0xCF, 0xA7, 0xBE, 0xB2, 0x25, 0x04, 0x76, 0x9E, + 0x79, 0x2C, 0x45, 0xAD, 0xFB, 0x1D, 0x6B, 0x3D, + 0x60, 0xD7, 0xB7, 0x49, 0xC8, 0xA7, 0x5B, 0x0B, + 0xDF, 0x14, 0xE8, 0xEA, 0x72, 0x1B, 0x95, 0xDC, + 0xA5, 0x38, 0xCA, 0x6E, 0x25, 0x71, 0x12, 0x09 + }, + { + 0xE5, 0x8B, 0x38, 0x36, 0xB7, 0xD8, 0xFE, 0xDB, + 0xB5, 0x0C, 0xA5, 0x72, 0x5C, 0x65, 0x71, 0xE7, + 0x4C, 0x07, 0x85, 0xE9, 0x78, 0x21, 0xDA, 0xB8, + 0xB6, 0x29, 0x8C, 0x10, 0xE4, 0xC0, 0x79, 0xD4, + 0xA6, 0xCD, 0xF2, 0x2F, 0x0F, 0xED, 0xB5, 0x50, + 0x32, 0x92, 0x5C, 0x16, 0x74, 0x81, 0x15, 0xF0, + 0x1A, 0x10, 0x5E, 0x77, 0xE0, 0x0C, 0xEE, 0x3D, + 0x07, 0x92, 0x4D, 0xC0, 0xD8, 0xF9, 0x06, 0x59 + }, + { + 0xB9, 0x29, 0xCC, 0x65, 0x05, 0xF0, 0x20, 0x15, + 0x86, 0x72, 0xDE, 0xDA, 0x56, 0xD0, 0xDB, 0x08, + 0x1A, 0x2E, 0xE3, 0x4C, 0x00, 0xC1, 0x10, 0x00, + 0x29, 0xBD, 0xF8, 0xEA, 0x98, 0x03, 0x4F, 0xA4, + 0xBF, 0x3E, 0x86, 0x55, 0xEC, 0x69, 0x7F, 0xE3, + 0x6F, 0x40, 0x55, 0x3C, 0x5B, 0xB4, 0x68, 0x01, + 0x64, 0x4A, 0x62, 0x7D, 0x33, 0x42, 0xF4, 0xFC, + 0x92, 0xB6, 0x1F, 0x03, 0x29, 0x0F, 0xB3, 0x81 + }, + { + 0x72, 0xD3, 0x53, 0x99, 0x4B, 0x49, 0xD3, 0xE0, + 0x31, 0x53, 0x92, 0x9A, 0x1E, 0x4D, 0x4F, 0x18, + 0x8E, 0xE5, 0x8A, 0xB9, 0xE7, 0x2E, 0xE8, 0xE5, + 0x12, 0xF2, 0x9B, 0xC7, 0x73, 0x91, 0x38, 0x19, + 0xCE, 0x05, 0x7D, 0xDD, 0x70, 0x02, 0xC0, 0x43, + 0x3E, 0xE0, 0xA1, 0x61, 0x14, 0xE3, 0xD1, 0x56, + 0xDD, 0x2C, 0x4A, 0x7E, 0x80, 0xEE, 0x53, 0x37, + 0x8B, 0x86, 0x70, 0xF2, 0x3E, 0x33, 0xEF, 0x56 + }, + { + 0xC7, 0x0E, 0xF9, 0xBF, 0xD7, 0x75, 0xD4, 0x08, + 0x17, 0x67, 0x37, 0xA0, 0x73, 0x6D, 0x68, 0x51, + 0x7C, 0xE1, 0xAA, 0xAD, 0x7E, 0x81, 0xA9, 0x3C, + 0x8C, 0x1E, 0xD9, 0x67, 0xEA, 0x21, 0x4F, 0x56, + 0xC8, 0xA3, 0x77, 0xB1, 0x76, 0x3E, 0x67, 0x66, + 0x15, 0xB6, 0x0F, 0x39, 0x88, 0x24, 0x1E, 0xAE, + 0x6E, 0xAB, 0x96, 0x85, 0xA5, 0x12, 0x49, 0x29, + 0xD2, 0x81, 0x88, 0xF2, 0x9E, 0xAB, 0x06, 0xF7 + }, + { + 0xC2, 0x30, 0xF0, 0x80, 0x26, 0x79, 0xCB, 0x33, + 0x82, 0x2E, 0xF8, 0xB3, 0xB2, 0x1B, 0xF7, 0xA9, + 0xA2, 0x89, 0x42, 0x09, 0x29, 0x01, 0xD7, 0xDA, + 0xC3, 0x76, 0x03, 0x00, 0x83, 0x10, 0x26, 0xCF, + 0x35, 0x4C, 0x92, 0x32, 0xDF, 0x3E, 0x08, 0x4D, + 0x99, 0x03, 0x13, 0x0C, 0x60, 0x1F, 0x63, 0xC1, + 0xF4, 0xA4, 0xA4, 0xB8, 0x10, 0x6E, 0x46, 0x8C, + 0xD4, 0x43, 0xBB, 0xE5, 0xA7, 0x34, 0xF4, 0x5F + }, + { + 0x6F, 0x43, 0x09, 0x4C, 0xAF, 0xB5, 0xEB, 0xF1, + 0xF7, 0xA4, 0x93, 0x7E, 0xC5, 0x0F, 0x56, 0xA4, + 0xC9, 0xDA, 0x30, 0x3C, 0xBB, 0x55, 0xAC, 0x1F, + 0x27, 0xF1, 0xF1, 0x97, 0x6C, 0xD9, 0x6B, 0xED, + 0xA9, 0x46, 0x4F, 0x0E, 0x7B, 0x9C, 0x54, 0x62, + 0x0B, 0x8A, 0x9F, 0xBA, 0x98, 0x31, 0x64, 0xB8, + 0xBE, 0x35, 0x78, 0x42, 0x5A, 0x02, 0x4F, 0x5F, + 0xE1, 0x99, 0xC3, 0x63, 0x56, 0xB8, 0x89, 0x72 + }, + { + 0x37, 0x45, 0x27, 0x3F, 0x4C, 0x38, 0x22, 0x5D, + 0xB2, 0x33, 0x73, 0x81, 0x87, 0x1A, 0x0C, 0x6A, + 0xAF, 0xD3, 0xAF, 0x9B, 0x01, 0x8C, 0x88, 0xAA, + 0x02, 0x02, 0x58, 0x50, 0xA5, 0xDC, 0x3A, 0x42, + 0xA1, 0xA3, 0xE0, 0x3E, 0x56, 0xCB, 0xF1, 0xB0, + 0x87, 0x6D, 0x63, 0xA4, 0x41, 0xF1, 0xD2, 0x85, + 0x6A, 0x39, 0xB8, 0x80, 0x1E, 0xB5, 0xAF, 0x32, + 0x52, 0x01, 0xC4, 0x15, 0xD6, 0x5E, 0x97, 0xFE + }, + { + 0xC5, 0x0C, 0x44, 0xCC, 0xA3, 0xEC, 0x3E, 0xDA, + 0xAE, 0x77, 0x9A, 0x7E, 0x17, 0x94, 0x50, 0xEB, + 0xDD, 0xA2, 0xF9, 0x70, 0x67, 0xC6, 0x90, 0xAA, + 0x6C, 0x5A, 0x4A, 0xC7, 0xC3, 0x01, 0x39, 0xBB, + 0x27, 0xC0, 0xDF, 0x4D, 0xB3, 0x22, 0x0E, 0x63, + 0xCB, 0x11, 0x0D, 0x64, 0xF3, 0x7F, 0xFE, 0x07, + 0x8D, 0xB7, 0x26, 0x53, 0xE2, 0xDA, 0xAC, 0xF9, + 0x3A, 0xE3, 0xF0, 0xA2, 0xD1, 0xA7, 0xEB, 0x2E + }, + { + 0x8A, 0xEF, 0x26, 0x3E, 0x38, 0x5C, 0xBC, 0x61, + 0xE1, 0x9B, 0x28, 0x91, 0x42, 0x43, 0x26, 0x2A, + 0xF5, 0xAF, 0xE8, 0x72, 0x6A, 0xF3, 0xCE, 0x39, + 0xA7, 0x9C, 0x27, 0x02, 0x8C, 0xF3, 0xEC, 0xD3, + 0xF8, 0xD2, 0xDF, 0xD9, 0xCF, 0xC9, 0xAD, 0x91, + 0xB5, 0x8F, 0x6F, 0x20, 0x77, 0x8F, 0xD5, 0xF0, + 0x28, 0x94, 0xA3, 0xD9, 0x1C, 0x7D, 0x57, 0xD1, + 0xE4, 0xB8, 0x66, 0xA7, 0xF3, 0x64, 0xB6, 0xBE + }, + { + 0x28, 0x69, 0x61, 0x41, 0xDE, 0x6E, 0x2D, 0x9B, + 0xCB, 0x32, 0x35, 0x57, 0x8A, 0x66, 0x16, 0x6C, + 0x14, 0x48, 0xD3, 0xE9, 0x05, 0xA1, 0xB4, 0x82, + 0xD4, 0x23, 0xBE, 0x4B, 0xC5, 0x36, 0x9B, 0xC8, + 0xC7, 0x4D, 0xAE, 0x0A, 0xCC, 0x9C, 0xC1, 0x23, + 0xE1, 0xD8, 0xDD, 0xCE, 0x9F, 0x97, 0x91, 0x7E, + 0x8C, 0x01, 0x9C, 0x55, 0x2D, 0xA3, 0x2D, 0x39, + 0xD2, 0x21, 0x9B, 0x9A, 0xBF, 0x0F, 0xA8, 0xC8 + }, + { + 0x2F, 0xB9, 0xEB, 0x20, 0x85, 0x83, 0x01, 0x81, + 0x90, 0x3A, 0x9D, 0xAF, 0xE3, 0xDB, 0x42, 0x8E, + 0xE1, 0x5B, 0xE7, 0x66, 0x22, 0x24, 0xEF, 0xD6, + 0x43, 0x37, 0x1F, 0xB2, 0x56, 0x46, 0xAE, 0xE7, + 0x16, 0xE5, 0x31, 0xEC, 0xA6, 0x9B, 0x2B, 0xDC, + 0x82, 0x33, 0xF1, 0xA8, 0x08, 0x1F, 0xA4, 0x3D, + 0xA1, 0x50, 0x03, 0x02, 0x97, 0x5A, 0x77, 0xF4, + 0x2F, 0xA5, 0x92, 0x13, 0x67, 0x10, 0xE9, 0xDC + }, + { + 0x66, 0xF9, 0xA7, 0x14, 0x3F, 0x7A, 0x33, 0x14, + 0xA6, 0x69, 0xBF, 0x2E, 0x24, 0xBB, 0xB3, 0x50, + 0x14, 0x26, 0x1D, 0x63, 0x9F, 0x49, 0x5B, 0x6C, + 0x9C, 0x1F, 0x10, 0x4F, 0xE8, 0xE3, 0x20, 0xAC, + 0xA6, 0x0D, 0x45, 0x50, 0xD6, 0x9D, 0x52, 0xED, + 0xBD, 0x5A, 0x3C, 0xDE, 0xB4, 0x01, 0x4A, 0xE6, + 0x5B, 0x1D, 0x87, 0xAA, 0x77, 0x0B, 0x69, 0xAE, + 0x5C, 0x15, 0xF4, 0x33, 0x0B, 0x0B, 0x0A, 0xD8 + }, + { + 0xF4, 0xC4, 0xDD, 0x1D, 0x59, 0x4C, 0x35, 0x65, + 0xE3, 0xE2, 0x5C, 0xA4, 0x3D, 0xAD, 0x82, 0xF6, + 0x2A, 0xBE, 0xA4, 0x83, 0x5E, 0xD4, 0xCD, 0x81, + 0x1B, 0xCD, 0x97, 0x5E, 0x46, 0x27, 0x98, 0x28, + 0xD4, 0x4D, 0x4C, 0x62, 0xC3, 0x67, 0x9F, 0x1B, + 0x7F, 0x7B, 0x9D, 0xD4, 0x57, 0x1D, 0x7B, 0x49, + 0x55, 0x73, 0x47, 0xB8, 0xC5, 0x46, 0x0C, 0xBD, + 0xC1, 0xBE, 0xF6, 0x90, 0xFB, 0x2A, 0x08, 0xC0 + }, + { + 0x8F, 0x1D, 0xC9, 0x64, 0x9C, 0x3A, 0x84, 0x55, + 0x1F, 0x8F, 0x6E, 0x91, 0xCA, 0xC6, 0x82, 0x42, + 0xA4, 0x3B, 0x1F, 0x8F, 0x32, 0x8E, 0xE9, 0x22, + 0x80, 0x25, 0x73, 0x87, 0xFA, 0x75, 0x59, 0xAA, + 0x6D, 0xB1, 0x2E, 0x4A, 0xEA, 0xDC, 0x2D, 0x26, + 0x09, 0x91, 0x78, 0x74, 0x9C, 0x68, 0x64, 0xB3, + 0x57, 0xF3, 0xF8, 0x3B, 0x2F, 0xB3, 0xEF, 0xA8, + 0xD2, 0xA8, 0xDB, 0x05, 0x6B, 0xED, 0x6B, 0xCC + }, + { + 0x31, 0x39, 0xC1, 0xA7, 0xF9, 0x7A, 0xFD, 0x16, + 0x75, 0xD4, 0x60, 0xEB, 0xBC, 0x07, 0xF2, 0x72, + 0x8A, 0xA1, 0x50, 0xDF, 0x84, 0x96, 0x24, 0x51, + 0x1E, 0xE0, 0x4B, 0x74, 0x3B, 0xA0, 0xA8, 0x33, + 0x09, 0x2F, 0x18, 0xC1, 0x2D, 0xC9, 0x1B, 0x4D, + 0xD2, 0x43, 0xF3, 0x33, 0x40, 0x2F, 0x59, 0xFE, + 0x28, 0xAB, 0xDB, 0xBB, 0xAE, 0x30, 0x1E, 0x7B, + 0x65, 0x9C, 0x7A, 0x26, 0xD5, 0xC0, 0xF9, 0x79 + }, + { + 0x06, 0xF9, 0x4A, 0x29, 0x96, 0x15, 0x8A, 0x81, + 0x9F, 0xE3, 0x4C, 0x40, 0xDE, 0x3C, 0xF0, 0x37, + 0x9F, 0xD9, 0xFB, 0x85, 0xB3, 0xE3, 0x63, 0xBA, + 0x39, 0x26, 0xA0, 0xE7, 0xD9, 0x60, 0xE3, 0xF4, + 0xC2, 0xE0, 0xC7, 0x0C, 0x7C, 0xE0, 0xCC, 0xB2, + 0xA6, 0x4F, 0xC2, 0x98, 0x69, 0xF6, 0xE7, 0xAB, + 0x12, 0xBD, 0x4D, 0x3F, 0x14, 0xFC, 0xE9, 0x43, + 0x27, 0x90, 0x27, 0xE7, 0x85, 0xFB, 0x5C, 0x29 + }, + { + 0xC2, 0x9C, 0x39, 0x9E, 0xF3, 0xEE, 0xE8, 0x96, + 0x1E, 0x87, 0x56, 0x5C, 0x1C, 0xE2, 0x63, 0x92, + 0x5F, 0xC3, 0xD0, 0xCE, 0x26, 0x7D, 0x13, 0xE4, + 0x8D, 0xD9, 0xE7, 0x32, 0xEE, 0x67, 0xB0, 0xF6, + 0x9F, 0xAD, 0x56, 0x40, 0x1B, 0x0F, 0x10, 0xFC, + 0xAA, 0xC1, 0x19, 0x20, 0x10, 0x46, 0xCC, 0xA2, + 0x8C, 0x5B, 0x14, 0xAB, 0xDE, 0xA3, 0x21, 0x2A, + 0xE6, 0x55, 0x62, 0xF7, 0xF1, 0x38, 0xDB, 0x3D + }, + { + 0x4C, 0xEC, 0x4C, 0x9D, 0xF5, 0x2E, 0xEF, 0x05, + 0xC3, 0xF6, 0xFA, 0xAA, 0x97, 0x91, 0xBC, 0x74, + 0x45, 0x93, 0x71, 0x83, 0x22, 0x4E, 0xCC, 0x37, + 0xA1, 0xE5, 0x8D, 0x01, 0x32, 0xD3, 0x56, 0x17, + 0x53, 0x1D, 0x7E, 0x79, 0x5F, 0x52, 0xAF, 0x7B, + 0x1E, 0xB9, 0xD1, 0x47, 0xDE, 0x12, 0x92, 0xD3, + 0x45, 0xFE, 0x34, 0x18, 0x23, 0xF8, 0xE6, 0xBC, + 0x1E, 0x5B, 0xAD, 0xCA, 0x5C, 0x65, 0x61, 0x08 + }, + { + 0x89, 0x8B, 0xFB, 0xAE, 0x93, 0xB3, 0xE1, 0x8D, + 0x00, 0x69, 0x7E, 0xAB, 0x7D, 0x97, 0x04, 0xFA, + 0x36, 0xEC, 0x33, 0x9D, 0x07, 0x61, 0x31, 0xCE, + 0xFD, 0xF3, 0x0E, 0xDB, 0xE8, 0xD9, 0xCC, 0x81, + 0xC3, 0xA8, 0x0B, 0x12, 0x96, 0x59, 0xB1, 0x63, + 0xA3, 0x23, 0xBA, 0xB9, 0x79, 0x3D, 0x4F, 0xEE, + 0xD9, 0x2D, 0x54, 0xDA, 0xE9, 0x66, 0xC7, 0x75, + 0x29, 0x76, 0x4A, 0x09, 0xBE, 0x88, 0xDB, 0x45 + }, + { + 0xEE, 0x9B, 0xD0, 0x46, 0x9D, 0x3A, 0xAF, 0x4F, + 0x14, 0x03, 0x5B, 0xE4, 0x8A, 0x2C, 0x3B, 0x84, + 0xD9, 0xB4, 0xB1, 0xFF, 0xF1, 0xD9, 0x45, 0xE1, + 0xF1, 0xC1, 0xD3, 0x89, 0x80, 0xA9, 0x51, 0xBE, + 0x19, 0x7B, 0x25, 0xFE, 0x22, 0xC7, 0x31, 0xF2, + 0x0A, 0xEA, 0xCC, 0x93, 0x0B, 0xA9, 0xC4, 0xA1, + 0xF4, 0x76, 0x22, 0x27, 0x61, 0x7A, 0xD3, 0x50, + 0xFD, 0xAB, 0xB4, 0xE8, 0x02, 0x73, 0xA0, 0xF4 + }, + { + 0x3D, 0x4D, 0x31, 0x13, 0x30, 0x05, 0x81, 0xCD, + 0x96, 0xAC, 0xBF, 0x09, 0x1C, 0x3D, 0x0F, 0x3C, + 0x31, 0x01, 0x38, 0xCD, 0x69, 0x79, 0xE6, 0x02, + 0x6C, 0xDE, 0x62, 0x3E, 0x2D, 0xD1, 0xB2, 0x4D, + 0x4A, 0x86, 0x38, 0xBE, 0xD1, 0x07, 0x33, 0x44, + 0x78, 0x3A, 0xD0, 0x64, 0x9C, 0xC6, 0x30, 0x5C, + 0xCE, 0xC0, 0x4B, 0xEB, 0x49, 0xF3, 0x1C, 0x63, + 0x30, 0x88, 0xA9, 0x9B, 0x65, 0x13, 0x02, 0x67 + }, + { + 0x95, 0xC0, 0x59, 0x1A, 0xD9, 0x1F, 0x92, 0x1A, + 0xC7, 0xBE, 0x6D, 0x9C, 0xE3, 0x7E, 0x06, 0x63, + 0xED, 0x80, 0x11, 0xC1, 0xCF, 0xD6, 0xD0, 0x16, + 0x2A, 0x55, 0x72, 0xE9, 0x43, 0x68, 0xBA, 0xC0, + 0x20, 0x24, 0x48, 0x5E, 0x6A, 0x39, 0x85, 0x4A, + 0xA4, 0x6F, 0xE3, 0x8E, 0x97, 0xD6, 0xC6, 0xB1, + 0x94, 0x7C, 0xD2, 0x72, 0xD8, 0x6B, 0x06, 0xBB, + 0x5B, 0x2F, 0x78, 0xB9, 0xB6, 0x8D, 0x55, 0x9D + }, + { + 0x22, 0x7B, 0x79, 0xDE, 0xD3, 0x68, 0x15, 0x3B, + 0xF4, 0x6C, 0x0A, 0x3C, 0xA9, 0x78, 0xBF, 0xDB, + 0xEF, 0x31, 0xF3, 0x02, 0x4A, 0x56, 0x65, 0x84, + 0x24, 0x68, 0x49, 0x0B, 0x0F, 0xF7, 0x48, 0xAE, + 0x04, 0xE7, 0x83, 0x2E, 0xD4, 0xC9, 0xF4, 0x9D, + 0xE9, 0xB1, 0x70, 0x67, 0x09, 0xD6, 0x23, 0xE5, + 0xC8, 0xC1, 0x5E, 0x3C, 0xAE, 0xCA, 0xE8, 0xD5, + 0xE4, 0x33, 0x43, 0x0F, 0xF7, 0x2F, 0x20, 0xEB + }, + { + 0x5D, 0x34, 0xF3, 0x95, 0x2F, 0x01, 0x05, 0xEE, + 0xF8, 0x8A, 0xE8, 0xB6, 0x4C, 0x6C, 0xE9, 0x5E, + 0xBF, 0xAD, 0xE0, 0xE0, 0x2C, 0x69, 0xB0, 0x87, + 0x62, 0xA8, 0x71, 0x2D, 0x2E, 0x49, 0x11, 0xAD, + 0x3F, 0x94, 0x1F, 0xC4, 0x03, 0x4D, 0xC9, 0xB2, + 0xE4, 0x79, 0xFD, 0xBC, 0xD2, 0x79, 0xB9, 0x02, + 0xFA, 0xF5, 0xD8, 0x38, 0xBB, 0x2E, 0x0C, 0x64, + 0x95, 0xD3, 0x72, 0xB5, 0xB7, 0x02, 0x98, 0x13 + }, + { + 0x7F, 0x93, 0x9B, 0xF8, 0x35, 0x3A, 0xBC, 0xE4, + 0x9E, 0x77, 0xF1, 0x4F, 0x37, 0x50, 0xAF, 0x20, + 0xB7, 0xB0, 0x39, 0x02, 0xE1, 0xA1, 0xE7, 0xFB, + 0x6A, 0xAF, 0x76, 0xD0, 0x25, 0x9C, 0xD4, 0x01, + 0xA8, 0x31, 0x90, 0xF1, 0x56, 0x40, 0xE7, 0x4F, + 0x3E, 0x6C, 0x5A, 0x90, 0xE8, 0x39, 0xC7, 0x82, + 0x1F, 0x64, 0x74, 0x75, 0x7F, 0x75, 0xC7, 0xBF, + 0x90, 0x02, 0x08, 0x4D, 0xDC, 0x7A, 0x62, 0xDC + }, + { + 0x06, 0x2B, 0x61, 0xA2, 0xF9, 0xA3, 0x3A, 0x71, + 0xD7, 0xD0, 0xA0, 0x61, 0x19, 0x64, 0x4C, 0x70, + 0xB0, 0x71, 0x6A, 0x50, 0x4D, 0xE7, 0xE5, 0xE1, + 0xBE, 0x49, 0xBD, 0x7B, 0x86, 0xE7, 0xED, 0x68, + 0x17, 0x71, 0x4F, 0x9F, 0x0F, 0xC3, 0x13, 0xD0, + 0x61, 0x29, 0x59, 0x7E, 0x9A, 0x22, 0x35, 0xEC, + 0x85, 0x21, 0xDE, 0x36, 0xF7, 0x29, 0x0A, 0x90, + 0xCC, 0xFC, 0x1F, 0xFA, 0x6D, 0x0A, 0xEE, 0x29 + }, + { + 0xF2, 0x9E, 0x01, 0xEE, 0xAE, 0x64, 0x31, 0x1E, + 0xB7, 0xF1, 0xC6, 0x42, 0x2F, 0x94, 0x6B, 0xF7, + 0xBE, 0xA3, 0x63, 0x79, 0x52, 0x3E, 0x7B, 0x2B, + 0xBA, 0xBA, 0x7D, 0x1D, 0x34, 0xA2, 0x2D, 0x5E, + 0xA5, 0xF1, 0xC5, 0xA0, 0x9D, 0x5C, 0xE1, 0xFE, + 0x68, 0x2C, 0xCE, 0xD9, 0xA4, 0x79, 0x8D, 0x1A, + 0x05, 0xB4, 0x6C, 0xD7, 0x2D, 0xFF, 0x5C, 0x1B, + 0x35, 0x54, 0x40, 0xB2, 0xA2, 0xD4, 0x76, 0xBC + }, + { + 0xEC, 0x38, 0xCD, 0x3B, 0xBA, 0xB3, 0xEF, 0x35, + 0xD7, 0xCB, 0x6D, 0x5C, 0x91, 0x42, 0x98, 0x35, + 0x1D, 0x8A, 0x9D, 0xC9, 0x7F, 0xCE, 0xE0, 0x51, + 0xA8, 0xA0, 0x2F, 0x58, 0xE3, 0xED, 0x61, 0x84, + 0xD0, 0xB7, 0x81, 0x0A, 0x56, 0x15, 0x41, 0x1A, + 0xB1, 0xB9, 0x52, 0x09, 0xC3, 0xC8, 0x10, 0x11, + 0x4F, 0xDE, 0xB2, 0x24, 0x52, 0x08, 0x4E, 0x77, + 0xF3, 0xF8, 0x47, 0xC6, 0xDB, 0xAA, 0xFE, 0x16 + }, + { + 0xC2, 0xAE, 0xF5, 0xE0, 0xCA, 0x43, 0xE8, 0x26, + 0x41, 0x56, 0x5B, 0x8C, 0xB9, 0x43, 0xAA, 0x8B, + 0xA5, 0x35, 0x50, 0xCA, 0xEF, 0x79, 0x3B, 0x65, + 0x32, 0xFA, 0xFA, 0xD9, 0x4B, 0x81, 0x60, 0x82, + 0xF0, 0x11, 0x3A, 0x3E, 0xA2, 0xF6, 0x36, 0x08, + 0xAB, 0x40, 0x43, 0x7E, 0xCC, 0x0F, 0x02, 0x29, + 0xCB, 0x8F, 0xA2, 0x24, 0xDC, 0xF1, 0xC4, 0x78, + 0xA6, 0x7D, 0x9B, 0x64, 0x16, 0x2B, 0x92, 0xD1 + }, + { + 0x15, 0xF5, 0x34, 0xEF, 0xFF, 0x71, 0x05, 0xCD, + 0x1C, 0x25, 0x4D, 0x07, 0x4E, 0x27, 0xD5, 0x89, + 0x8B, 0x89, 0x31, 0x3B, 0x7D, 0x36, 0x6D, 0xC2, + 0xD7, 0xD8, 0x71, 0x13, 0xFA, 0x7D, 0x53, 0xAA, + 0xE1, 0x3F, 0x6D, 0xBA, 0x48, 0x7A, 0xD8, 0x10, + 0x3D, 0x5E, 0x85, 0x4C, 0x91, 0xFD, 0xB6, 0xE1, + 0xE7, 0x4B, 0x2E, 0xF6, 0xD1, 0x43, 0x17, 0x69, + 0xC3, 0x07, 0x67, 0xDD, 0xE0, 0x67, 0xA3, 0x5C + }, + { + 0x89, 0xAC, 0xBC, 0xA0, 0xB1, 0x69, 0x89, 0x7A, + 0x0A, 0x27, 0x14, 0xC2, 0xDF, 0x8C, 0x95, 0xB5, + 0xB7, 0x9C, 0xB6, 0x93, 0x90, 0x14, 0x2B, 0x7D, + 0x60, 0x18, 0xBB, 0x3E, 0x30, 0x76, 0xB0, 0x99, + 0xB7, 0x9A, 0x96, 0x41, 0x52, 0xA9, 0xD9, 0x12, + 0xB1, 0xB8, 0x64, 0x12, 0xB7, 0xE3, 0x72, 0xE9, + 0xCE, 0xCA, 0xD7, 0xF2, 0x5D, 0x4C, 0xBA, 0xB8, + 0xA3, 0x17, 0xBE, 0x36, 0x49, 0x2A, 0x67, 0xD7 + }, + { + 0xE3, 0xC0, 0x73, 0x91, 0x90, 0xED, 0x84, 0x9C, + 0x9C, 0x96, 0x2F, 0xD9, 0xDB, 0xB5, 0x5E, 0x20, + 0x7E, 0x62, 0x4F, 0xCA, 0xC1, 0xEB, 0x41, 0x76, + 0x91, 0x51, 0x54, 0x99, 0xEE, 0xA8, 0xD8, 0x26, + 0x7B, 0x7E, 0x8F, 0x12, 0x87, 0xA6, 0x36, 0x33, + 0xAF, 0x50, 0x11, 0xFD, 0xE8, 0xC4, 0xDD, 0xF5, + 0x5B, 0xFD, 0xF7, 0x22, 0xED, 0xF8, 0x88, 0x31, + 0x41, 0x4F, 0x2C, 0xFA, 0xED, 0x59, 0xCB, 0x9A + }, + { + 0x8D, 0x6C, 0xF8, 0x7C, 0x08, 0x38, 0x0D, 0x2D, + 0x15, 0x06, 0xEE, 0xE4, 0x6F, 0xD4, 0x22, 0x2D, + 0x21, 0xD8, 0xC0, 0x4E, 0x58, 0x5F, 0xBF, 0xD0, + 0x82, 0x69, 0xC9, 0x8F, 0x70, 0x28, 0x33, 0xA1, + 0x56, 0x32, 0x6A, 0x07, 0x24, 0x65, 0x64, 0x00, + 0xEE, 0x09, 0x35, 0x1D, 0x57, 0xB4, 0x40, 0x17, + 0x5E, 0x2A, 0x5D, 0xE9, 0x3C, 0xC5, 0xF8, 0x0D, + 0xB6, 0xDA, 0xF8, 0x35, 0x76, 0xCF, 0x75, 0xFA + }, + { + 0xDA, 0x24, 0xBE, 0xDE, 0x38, 0x36, 0x66, 0xD5, + 0x63, 0xEE, 0xED, 0x37, 0xF6, 0x31, 0x9B, 0xAF, + 0x20, 0xD5, 0xC7, 0x5D, 0x16, 0x35, 0xA6, 0xBA, + 0x5E, 0xF4, 0xCF, 0xA1, 0xAC, 0x95, 0x48, 0x7E, + 0x96, 0xF8, 0xC0, 0x8A, 0xF6, 0x00, 0xAA, 0xB8, + 0x7C, 0x98, 0x6E, 0xBA, 0xD4, 0x9F, 0xC7, 0x0A, + 0x58, 0xB4, 0x89, 0x0B, 0x9C, 0x87, 0x6E, 0x09, + 0x10, 0x16, 0xDA, 0xF4, 0x9E, 0x1D, 0x32, 0x2E + }, + { + 0xF9, 0xD1, 0xD1, 0xB1, 0xE8, 0x7E, 0xA7, 0xAE, + 0x75, 0x3A, 0x02, 0x97, 0x50, 0xCC, 0x1C, 0xF3, + 0xD0, 0x15, 0x7D, 0x41, 0x80, 0x5E, 0x24, 0x5C, + 0x56, 0x17, 0xBB, 0x93, 0x4E, 0x73, 0x2F, 0x0A, + 0xE3, 0x18, 0x0B, 0x78, 0xE0, 0x5B, 0xFE, 0x76, + 0xC7, 0xC3, 0x05, 0x1E, 0x3E, 0x3A, 0xC7, 0x8B, + 0x9B, 0x50, 0xC0, 0x51, 0x42, 0x65, 0x7E, 0x1E, + 0x03, 0x21, 0x5D, 0x6E, 0xC7, 0xBF, 0xD0, 0xFC + }, + { + 0x11, 0xB7, 0xBC, 0x16, 0x68, 0x03, 0x20, 0x48, + 0xAA, 0x43, 0x34, 0x3D, 0xE4, 0x76, 0x39, 0x5E, + 0x81, 0x4B, 0xBB, 0xC2, 0x23, 0x67, 0x8D, 0xB9, + 0x51, 0xA1, 0xB0, 0x3A, 0x02, 0x1E, 0xFA, 0xC9, + 0x48, 0xCF, 0xBE, 0x21, 0x5F, 0x97, 0xFE, 0x9A, + 0x72, 0xA2, 0xF6, 0xBC, 0x03, 0x9E, 0x39, 0x56, + 0xBF, 0xA4, 0x17, 0xC1, 0xA9, 0xF1, 0x0D, 0x6D, + 0x7B, 0xA5, 0xD3, 0xD3, 0x2F, 0xF3, 0x23, 0xE5 + }, + { + 0xB8, 0xD9, 0x00, 0x0E, 0x4F, 0xC2, 0xB0, 0x66, + 0xED, 0xB9, 0x1A, 0xFE, 0xE8, 0xE7, 0xEB, 0x0F, + 0x24, 0xE3, 0xA2, 0x01, 0xDB, 0x8B, 0x67, 0x93, + 0xC0, 0x60, 0x85, 0x81, 0xE6, 0x28, 0xED, 0x0B, + 0xCC, 0x4E, 0x5A, 0xA6, 0x78, 0x79, 0x92, 0xA4, + 0xBC, 0xC4, 0x4E, 0x28, 0x80, 0x93, 0xE6, 0x3E, + 0xE8, 0x3A, 0xBD, 0x0B, 0xC3, 0xEC, 0x6D, 0x09, + 0x34, 0xA6, 0x74, 0xA4, 0xDA, 0x13, 0x83, 0x8A + }, + { + 0xCE, 0x32, 0x5E, 0x29, 0x4F, 0x9B, 0x67, 0x19, + 0xD6, 0xB6, 0x12, 0x78, 0x27, 0x6A, 0xE0, 0x6A, + 0x25, 0x64, 0xC0, 0x3B, 0xB0, 0xB7, 0x83, 0xFA, + 0xFE, 0x78, 0x5B, 0xDF, 0x89, 0xC7, 0xD5, 0xAC, + 0xD8, 0x3E, 0x78, 0x75, 0x6D, 0x30, 0x1B, 0x44, + 0x56, 0x99, 0x02, 0x4E, 0xAE, 0xB7, 0x7B, 0x54, + 0xD4, 0x77, 0x33, 0x6E, 0xC2, 0xA4, 0xF3, 0x32, + 0xF2, 0xB3, 0xF8, 0x87, 0x65, 0xDD, 0xB0, 0xC3 + }, + { + 0x29, 0xAC, 0xC3, 0x0E, 0x96, 0x03, 0xAE, 0x2F, + 0xCC, 0xF9, 0x0B, 0xF9, 0x7E, 0x6C, 0xC4, 0x63, + 0xEB, 0xE2, 0x8C, 0x1B, 0x2F, 0x9B, 0x4B, 0x76, + 0x5E, 0x70, 0x53, 0x7C, 0x25, 0xC7, 0x02, 0xA2, + 0x9D, 0xCB, 0xFB, 0xF1, 0x4C, 0x99, 0xC5, 0x43, + 0x45, 0xBA, 0x2B, 0x51, 0xF1, 0x7B, 0x77, 0xB5, + 0xF1, 0x5D, 0xB9, 0x2B, 0xBA, 0xD8, 0xFA, 0x95, + 0xC4, 0x71, 0xF5, 0xD0, 0x70, 0xA1, 0x37, 0xCC + }, + { + 0x33, 0x79, 0xCB, 0xAA, 0xE5, 0x62, 0xA8, 0x7B, + 0x4C, 0x04, 0x25, 0x55, 0x0F, 0xFD, 0xD6, 0xBF, + 0xE1, 0x20, 0x3F, 0x0D, 0x66, 0x6C, 0xC7, 0xEA, + 0x09, 0x5B, 0xE4, 0x07, 0xA5, 0xDF, 0xE6, 0x1E, + 0xE9, 0x14, 0x41, 0xCD, 0x51, 0x54, 0xB3, 0xE5, + 0x3B, 0x4F, 0x5F, 0xB3, 0x1A, 0xD4, 0xC7, 0xA9, + 0xAD, 0x5C, 0x7A, 0xF4, 0xAE, 0x67, 0x9A, 0xA5, + 0x1A, 0x54, 0x00, 0x3A, 0x54, 0xCA, 0x6B, 0x2D + }, + { + 0x30, 0x95, 0xA3, 0x49, 0xD2, 0x45, 0x70, 0x8C, + 0x7C, 0xF5, 0x50, 0x11, 0x87, 0x03, 0xD7, 0x30, + 0x2C, 0x27, 0xB6, 0x0A, 0xF5, 0xD4, 0xE6, 0x7F, + 0xC9, 0x78, 0xF8, 0xA4, 0xE6, 0x09, 0x53, 0xC7, + 0xA0, 0x4F, 0x92, 0xFC, 0xF4, 0x1A, 0xEE, 0x64, + 0x32, 0x1C, 0xCB, 0x70, 0x7A, 0x89, 0x58, 0x51, + 0x55, 0x2B, 0x1E, 0x37, 0xB0, 0x0B, 0xC5, 0xE6, + 0xB7, 0x2F, 0xA5, 0xBC, 0xEF, 0x9E, 0x3F, 0xFF + }, + { + 0x07, 0x26, 0x2D, 0x73, 0x8B, 0x09, 0x32, 0x1F, + 0x4D, 0xBC, 0xCE, 0xC4, 0xBB, 0x26, 0xF4, 0x8C, + 0xB0, 0xF0, 0xED, 0x24, 0x6C, 0xE0, 0xB3, 0x1B, + 0x9A, 0x6E, 0x7B, 0xC6, 0x83, 0x04, 0x9F, 0x1F, + 0x3E, 0x55, 0x45, 0xF2, 0x8C, 0xE9, 0x32, 0xDD, + 0x98, 0x5C, 0x5A, 0xB0, 0xF4, 0x3B, 0xD6, 0xDE, + 0x07, 0x70, 0x56, 0x0A, 0xF3, 0x29, 0x06, 0x5E, + 0xD2, 0xE4, 0x9D, 0x34, 0x62, 0x4C, 0x2C, 0xBB + }, + { + 0xB6, 0x40, 0x5E, 0xCA, 0x8E, 0xE3, 0x31, 0x6C, + 0x87, 0x06, 0x1C, 0xC6, 0xEC, 0x18, 0xDB, 0xA5, + 0x3E, 0x6C, 0x25, 0x0C, 0x63, 0xBA, 0x1F, 0x3B, + 0xAE, 0x9E, 0x55, 0xDD, 0x34, 0x98, 0x03, 0x6A, + 0xF0, 0x8C, 0xD2, 0x72, 0xAA, 0x24, 0xD7, 0x13, + 0xC6, 0x02, 0x0D, 0x77, 0xAB, 0x2F, 0x39, 0x19, + 0xAF, 0x1A, 0x32, 0xF3, 0x07, 0x42, 0x06, 0x18, + 0xAB, 0x97, 0xE7, 0x39, 0x53, 0x99, 0x4F, 0xB4 + }, + { + 0x7E, 0xE6, 0x82, 0xF6, 0x31, 0x48, 0xEE, 0x45, + 0xF6, 0xE5, 0x31, 0x5D, 0xA8, 0x1E, 0x5C, 0x6E, + 0x55, 0x7C, 0x2C, 0x34, 0x64, 0x1F, 0xC5, 0x09, + 0xC7, 0xA5, 0x70, 0x10, 0x88, 0xC3, 0x8A, 0x74, + 0x75, 0x61, 0x68, 0xE2, 0xCD, 0x8D, 0x35, 0x1E, + 0x88, 0xFD, 0x1A, 0x45, 0x1F, 0x36, 0x0A, 0x01, + 0xF5, 0xB2, 0x58, 0x0F, 0x9B, 0x5A, 0x2E, 0x8C, + 0xFC, 0x13, 0x8F, 0x3D, 0xD5, 0x9A, 0x3F, 0xFC + }, + { + 0x1D, 0x26, 0x3C, 0x17, 0x9D, 0x6B, 0x26, 0x8F, + 0x6F, 0xA0, 0x16, 0xF3, 0xA4, 0xF2, 0x9E, 0x94, + 0x38, 0x91, 0x12, 0x5E, 0xD8, 0x59, 0x3C, 0x81, + 0x25, 0x60, 0x59, 0xF5, 0xA7, 0xB4, 0x4A, 0xF2, + 0xDC, 0xB2, 0x03, 0x0D, 0x17, 0x5C, 0x00, 0xE6, + 0x2E, 0xCA, 0xF7, 0xEE, 0x96, 0x68, 0x2A, 0xA0, + 0x7A, 0xB2, 0x0A, 0x61, 0x10, 0x24, 0xA2, 0x85, + 0x32, 0xB1, 0xC2, 0x5B, 0x86, 0x65, 0x79, 0x02 + }, + { + 0x10, 0x6D, 0x13, 0x2C, 0xBD, 0xB4, 0xCD, 0x25, + 0x97, 0x81, 0x28, 0x46, 0xE2, 0xBC, 0x1B, 0xF7, + 0x32, 0xFE, 0xC5, 0xF0, 0xA5, 0xF6, 0x5D, 0xBB, + 0x39, 0xEC, 0x4E, 0x6D, 0xC6, 0x4A, 0xB2, 0xCE, + 0x6D, 0x24, 0x63, 0x0D, 0x0F, 0x15, 0xA8, 0x05, + 0xC3, 0x54, 0x00, 0x25, 0xD8, 0x4A, 0xFA, 0x98, + 0xE3, 0x67, 0x03, 0xC3, 0xDB, 0xEE, 0x71, 0x3E, + 0x72, 0xDD, 0xE8, 0x46, 0x5B, 0xC1, 0xBE, 0x7E + }, + { + 0x0E, 0x79, 0x96, 0x82, 0x26, 0x65, 0x06, 0x67, + 0xA8, 0xD8, 0x62, 0xEA, 0x8D, 0xA4, 0x89, 0x1A, + 0xF5, 0x6A, 0x4E, 0x3A, 0x8B, 0x6D, 0x17, 0x50, + 0xE3, 0x94, 0xF0, 0xDE, 0xA7, 0x6D, 0x64, 0x0D, + 0x85, 0x07, 0x7B, 0xCE, 0xC2, 0xCC, 0x86, 0x88, + 0x6E, 0x50, 0x67, 0x51, 0xB4, 0xF6, 0xA5, 0x83, + 0x8F, 0x7F, 0x0B, 0x5F, 0xEF, 0x76, 0x5D, 0x9D, + 0xC9, 0x0D, 0xCD, 0xCB, 0xAF, 0x07, 0x9F, 0x08 + }, + { + 0x52, 0x11, 0x56, 0xA8, 0x2A, 0xB0, 0xC4, 0xE5, + 0x66, 0xE5, 0x84, 0x4D, 0x5E, 0x31, 0xAD, 0x9A, + 0xAF, 0x14, 0x4B, 0xBD, 0x5A, 0x46, 0x4F, 0xDC, + 0xA3, 0x4D, 0xBD, 0x57, 0x17, 0xE8, 0xFF, 0x71, + 0x1D, 0x3F, 0xFE, 0xBB, 0xFA, 0x08, 0x5D, 0x67, + 0xFE, 0x99, 0x6A, 0x34, 0xF6, 0xD3, 0xE4, 0xE6, + 0x0B, 0x13, 0x96, 0xBF, 0x4B, 0x16, 0x10, 0xC2, + 0x63, 0xBD, 0xBB, 0x83, 0x4D, 0x56, 0x08, 0x16 + }, + { + 0x1A, 0xBA, 0x88, 0xBE, 0xFC, 0x55, 0xBC, 0x25, + 0xEF, 0xBC, 0xE0, 0x2D, 0xB8, 0xB9, 0x93, 0x3E, + 0x46, 0xF5, 0x76, 0x61, 0xBA, 0xEA, 0xBE, 0xB2, + 0x1C, 0xC2, 0x57, 0x4D, 0x2A, 0x51, 0x8A, 0x3C, + 0xBA, 0x5D, 0xC5, 0xA3, 0x8E, 0x49, 0x71, 0x34, + 0x40, 0xB2, 0x5F, 0x9C, 0x74, 0x4E, 0x75, 0xF6, + 0xB8, 0x5C, 0x9D, 0x8F, 0x46, 0x81, 0xF6, 0x76, + 0x16, 0x0F, 0x61, 0x05, 0x35, 0x7B, 0x84, 0x06 + }, + { + 0x5A, 0x99, 0x49, 0xFC, 0xB2, 0xC4, 0x73, 0xCD, + 0xA9, 0x68, 0xAC, 0x1B, 0x5D, 0x08, 0x56, 0x6D, + 0xC2, 0xD8, 0x16, 0xD9, 0x60, 0xF5, 0x7E, 0x63, + 0xB8, 0x98, 0xFA, 0x70, 0x1C, 0xF8, 0xEB, 0xD3, + 0xF5, 0x9B, 0x12, 0x4D, 0x95, 0xBF, 0xBB, 0xED, + 0xC5, 0xF1, 0xCF, 0x0E, 0x17, 0xD5, 0xEA, 0xED, + 0x0C, 0x02, 0xC5, 0x0B, 0x69, 0xD8, 0xA4, 0x02, + 0xCA, 0xBC, 0xCA, 0x44, 0x33, 0xB5, 0x1F, 0xD4 + }, + { + 0xB0, 0xCE, 0xAD, 0x09, 0x80, 0x7C, 0x67, 0x2A, + 0xF2, 0xEB, 0x2B, 0x0F, 0x06, 0xDD, 0xE4, 0x6C, + 0xF5, 0x37, 0x0E, 0x15, 0xA4, 0x09, 0x6B, 0x1A, + 0x7D, 0x7C, 0xBB, 0x36, 0xEC, 0x31, 0xC2, 0x05, + 0xFB, 0xEF, 0xCA, 0x00, 0xB7, 0xA4, 0x16, 0x2F, + 0xA8, 0x9F, 0xB4, 0xFB, 0x3E, 0xB7, 0x8D, 0x79, + 0x77, 0x0C, 0x23, 0xF4, 0x4E, 0x72, 0x06, 0x66, + 0x4C, 0xE3, 0xCD, 0x93, 0x1C, 0x29, 0x1E, 0x5D + }, + { + 0xBB, 0x66, 0x64, 0x93, 0x1E, 0xC9, 0x70, 0x44, + 0xE4, 0x5B, 0x2A, 0xE4, 0x20, 0xAE, 0x1C, 0x55, + 0x1A, 0x88, 0x74, 0xBC, 0x93, 0x7D, 0x08, 0xE9, + 0x69, 0x39, 0x9C, 0x39, 0x64, 0xEB, 0xDB, 0xA8, + 0x34, 0x6C, 0xDD, 0x5D, 0x09, 0xCA, 0xAF, 0xE4, + 0xC2, 0x8B, 0xA7, 0xEC, 0x78, 0x81, 0x91, 0xCE, + 0xCA, 0x65, 0xDD, 0xD6, 0xF9, 0x5F, 0x18, 0x58, + 0x3E, 0x04, 0x0D, 0x0F, 0x30, 0xD0, 0x36, 0x4D + }, + { + 0x65, 0xBC, 0x77, 0x0A, 0x5F, 0xAA, 0x37, 0x92, + 0x36, 0x98, 0x03, 0x68, 0x3E, 0x84, 0x4B, 0x0B, + 0xE7, 0xEE, 0x96, 0xF2, 0x9F, 0x6D, 0x6A, 0x35, + 0x56, 0x80, 0x06, 0xBD, 0x55, 0x90, 0xF9, 0xA4, + 0xEF, 0x63, 0x9B, 0x7A, 0x80, 0x61, 0xC7, 0xB0, + 0x42, 0x4B, 0x66, 0xB6, 0x0A, 0xC3, 0x4A, 0xF3, + 0x11, 0x99, 0x05, 0xF3, 0x3A, 0x9D, 0x8C, 0x3A, + 0xE1, 0x83, 0x82, 0xCA, 0x9B, 0x68, 0x99, 0x00 + }, + { + 0xEA, 0x9B, 0x4D, 0xCA, 0x33, 0x33, 0x36, 0xAA, + 0xF8, 0x39, 0xA4, 0x5C, 0x6E, 0xAA, 0x48, 0xB8, + 0xCB, 0x4C, 0x7D, 0xDA, 0xBF, 0xFE, 0xA4, 0xF6, + 0x43, 0xD6, 0x35, 0x7E, 0xA6, 0x62, 0x8A, 0x48, + 0x0A, 0x5B, 0x45, 0xF2, 0xB0, 0x52, 0xC1, 0xB0, + 0x7D, 0x1F, 0xED, 0xCA, 0x91, 0x8B, 0x6F, 0x11, + 0x39, 0xD8, 0x0F, 0x74, 0xC2, 0x45, 0x10, 0xDC, + 0xBA, 0xA4, 0xBE, 0x70, 0xEA, 0xCC, 0x1B, 0x06 + }, + { + 0xE6, 0x34, 0x2F, 0xB4, 0xA7, 0x80, 0xAD, 0x97, + 0x5D, 0x0E, 0x24, 0xBC, 0xE1, 0x49, 0x98, 0x9B, + 0x91, 0xD3, 0x60, 0x55, 0x7E, 0x87, 0x99, 0x4F, + 0x6B, 0x45, 0x7B, 0x89, 0x55, 0x75, 0xCC, 0x02, + 0xD0, 0xC1, 0x5B, 0xAD, 0x3C, 0xE7, 0x57, 0x7F, + 0x4C, 0x63, 0x92, 0x7F, 0xF1, 0x3F, 0x3E, 0x38, + 0x1F, 0xF7, 0xE7, 0x2B, 0xDB, 0xE7, 0x45, 0x32, + 0x48, 0x44, 0xA9, 0xD2, 0x7E, 0x3F, 0x1C, 0x01 + }, + { + 0x3E, 0x20, 0x9C, 0x9B, 0x33, 0xE8, 0xE4, 0x61, + 0x17, 0x8A, 0xB4, 0x6B, 0x1C, 0x64, 0xB4, 0x9A, + 0x07, 0xFB, 0x74, 0x5F, 0x1C, 0x8B, 0xC9, 0x5F, + 0xBF, 0xB9, 0x4C, 0x6B, 0x87, 0xC6, 0x95, 0x16, + 0x65, 0x1B, 0x26, 0x4E, 0xF9, 0x80, 0x93, 0x7F, + 0xAD, 0x41, 0x23, 0x8B, 0x91, 0xDD, 0xC0, 0x11, + 0xA5, 0xDD, 0x77, 0x7C, 0x7E, 0xFD, 0x44, 0x94, + 0xB4, 0xB6, 0xEC, 0xD3, 0xA9, 0xC2, 0x2A, 0xC0 + }, + { + 0xFD, 0x6A, 0x3D, 0x5B, 0x18, 0x75, 0xD8, 0x04, + 0x86, 0xD6, 0xE6, 0x96, 0x94, 0xA5, 0x6D, 0xBB, + 0x04, 0xA9, 0x9A, 0x4D, 0x05, 0x1F, 0x15, 0xDB, + 0x26, 0x89, 0x77, 0x6B, 0xA1, 0xC4, 0x88, 0x2E, + 0x6D, 0x46, 0x2A, 0x60, 0x3B, 0x70, 0x15, 0xDC, + 0x9F, 0x4B, 0x74, 0x50, 0xF0, 0x53, 0x94, 0x30, + 0x3B, 0x86, 0x52, 0xCF, 0xB4, 0x04, 0xA2, 0x66, + 0x96, 0x2C, 0x41, 0xBA, 0xE6, 0xE1, 0x8A, 0x94 + }, + { + 0x95, 0x1E, 0x27, 0x51, 0x7E, 0x6B, 0xAD, 0x9E, + 0x41, 0x95, 0xFC, 0x86, 0x71, 0xDE, 0xE3, 0xE7, + 0xE9, 0xBE, 0x69, 0xCE, 0xE1, 0x42, 0x2C, 0xB9, + 0xFE, 0xCF, 0xCE, 0x0D, 0xBA, 0x87, 0x5F, 0x7B, + 0x31, 0x0B, 0x93, 0xEE, 0x3A, 0x3D, 0x55, 0x8F, + 0x94, 0x1F, 0x63, 0x5F, 0x66, 0x8F, 0xF8, 0x32, + 0xD2, 0xC1, 0xD0, 0x33, 0xC5, 0xE2, 0xF0, 0x99, + 0x7E, 0x4C, 0x66, 0xF1, 0x47, 0x34, 0x4E, 0x02 + }, + { + 0x8E, 0xBA, 0x2F, 0x87, 0x4F, 0x1A, 0xE8, 0x40, + 0x41, 0x90, 0x3C, 0x7C, 0x42, 0x53, 0xC8, 0x22, + 0x92, 0x53, 0x0F, 0xC8, 0x50, 0x95, 0x50, 0xBF, + 0xDC, 0x34, 0xC9, 0x5C, 0x7E, 0x28, 0x89, 0xD5, + 0x65, 0x0B, 0x0A, 0xD8, 0xCB, 0x98, 0x8E, 0x5C, + 0x48, 0x94, 0xCB, 0x87, 0xFB, 0xFB, 0xB1, 0x96, + 0x12, 0xEA, 0x93, 0xCC, 0xC4, 0xC5, 0xCA, 0xD1, + 0x71, 0x58, 0xB9, 0x76, 0x34, 0x64, 0xB4, 0x92 + }, + { + 0x16, 0xF7, 0x12, 0xEA, 0xA1, 0xB7, 0xC6, 0x35, + 0x47, 0x19, 0xA8, 0xE7, 0xDB, 0xDF, 0xAF, 0x55, + 0xE4, 0x06, 0x3A, 0x4D, 0x27, 0x7D, 0x94, 0x75, + 0x50, 0x01, 0x9B, 0x38, 0xDF, 0xB5, 0x64, 0x83, + 0x09, 0x11, 0x05, 0x7D, 0x50, 0x50, 0x61, 0x36, + 0xE2, 0x39, 0x4C, 0x3B, 0x28, 0x94, 0x5C, 0xC9, + 0x64, 0x96, 0x7D, 0x54, 0xE3, 0x00, 0x0C, 0x21, + 0x81, 0x62, 0x6C, 0xFB, 0x9B, 0x73, 0xEF, 0xD2 + }, + { + 0xC3, 0x96, 0x39, 0xE7, 0xD5, 0xC7, 0xFB, 0x8C, + 0xDD, 0x0F, 0xD3, 0xE6, 0xA5, 0x20, 0x96, 0x03, + 0x94, 0x37, 0x12, 0x2F, 0x21, 0xC7, 0x8F, 0x16, + 0x79, 0xCE, 0xA9, 0xD7, 0x8A, 0x73, 0x4C, 0x56, + 0xEC, 0xBE, 0xB2, 0x86, 0x54, 0xB4, 0xF1, 0x8E, + 0x34, 0x2C, 0x33, 0x1F, 0x6F, 0x72, 0x29, 0xEC, + 0x4B, 0x4B, 0xC2, 0x81, 0xB2, 0xD8, 0x0A, 0x6E, + 0xB5, 0x00, 0x43, 0xF3, 0x17, 0x96, 0xC8, 0x8C + }, + { + 0x72, 0xD0, 0x81, 0xAF, 0x99, 0xF8, 0xA1, 0x73, + 0xDC, 0xC9, 0xA0, 0xAC, 0x4E, 0xB3, 0x55, 0x74, + 0x05, 0x63, 0x9A, 0x29, 0x08, 0x4B, 0x54, 0xA4, + 0x01, 0x72, 0x91, 0x2A, 0x2F, 0x8A, 0x39, 0x51, + 0x29, 0xD5, 0x53, 0x6F, 0x09, 0x18, 0xE9, 0x02, + 0xF9, 0xE8, 0xFA, 0x60, 0x00, 0x99, 0x5F, 0x41, + 0x68, 0xDD, 0xC5, 0xF8, 0x93, 0x01, 0x1B, 0xE6, + 0xA0, 0xDB, 0xC9, 0xB8, 0xA1, 0xA3, 0xF5, 0xBB + }, + { + 0xC1, 0x1A, 0xA8, 0x1E, 0x5E, 0xFD, 0x24, 0xD5, + 0xFC, 0x27, 0xEE, 0x58, 0x6C, 0xFD, 0x88, 0x47, + 0xFB, 0xB0, 0xE2, 0x76, 0x01, 0xCC, 0xEC, 0xE5, + 0xEC, 0xCA, 0x01, 0x98, 0xE3, 0xC7, 0x76, 0x53, + 0x93, 0xBB, 0x74, 0x45, 0x7C, 0x7E, 0x7A, 0x27, + 0xEB, 0x91, 0x70, 0x35, 0x0E, 0x1F, 0xB5, 0x38, + 0x57, 0x17, 0x75, 0x06, 0xBE, 0x3E, 0x76, 0x2C, + 0xC0, 0xF1, 0x4D, 0x8C, 0x3A, 0xFE, 0x90, 0x77 + }, + { + 0xC2, 0x8F, 0x21, 0x50, 0xB4, 0x52, 0xE6, 0xC0, + 0xC4, 0x24, 0xBC, 0xDE, 0x6F, 0x8D, 0x72, 0x00, + 0x7F, 0x93, 0x10, 0xFE, 0xD7, 0xF2, 0xF8, 0x7D, + 0xE0, 0xDB, 0xB6, 0x4F, 0x44, 0x79, 0xD6, 0xC1, + 0x44, 0x1B, 0xA6, 0x6F, 0x44, 0xB2, 0xAC, 0xCE, + 0xE6, 0x16, 0x09, 0x17, 0x7E, 0xD3, 0x40, 0x12, + 0x8B, 0x40, 0x7E, 0xCE, 0xC7, 0xC6, 0x4B, 0xBE, + 0x50, 0xD6, 0x3D, 0x22, 0xD8, 0x62, 0x77, 0x27 + }, + { + 0xF6, 0x3D, 0x88, 0x12, 0x28, 0x77, 0xEC, 0x30, + 0xB8, 0xC8, 0xB0, 0x0D, 0x22, 0xE8, 0x90, 0x00, + 0xA9, 0x66, 0x42, 0x61, 0x12, 0xBD, 0x44, 0x16, + 0x6E, 0x2F, 0x52, 0x5B, 0x76, 0x9C, 0xCB, 0xE9, + 0xB2, 0x86, 0xD4, 0x37, 0xA0, 0x12, 0x91, 0x30, + 0xDD, 0xE1, 0xA8, 0x6C, 0x43, 0xE0, 0x4B, 0xED, + 0xB5, 0x94, 0xE6, 0x71, 0xD9, 0x82, 0x83, 0xAF, + 0xE6, 0x4C, 0xE3, 0x31, 0xDE, 0x98, 0x28, 0xFD + }, + { + 0x34, 0x8B, 0x05, 0x32, 0x88, 0x0B, 0x88, 0xA6, + 0x61, 0x4A, 0x8D, 0x74, 0x08, 0xC3, 0xF9, 0x13, + 0x35, 0x7F, 0xBB, 0x60, 0xE9, 0x95, 0xC6, 0x02, + 0x05, 0xBE, 0x91, 0x39, 0xE7, 0x49, 0x98, 0xAE, + 0xDE, 0x7F, 0x45, 0x81, 0xE4, 0x2F, 0x6B, 0x52, + 0x69, 0x8F, 0x7F, 0xA1, 0x21, 0x97, 0x08, 0xC1, + 0x44, 0x98, 0x06, 0x7F, 0xD1, 0xE0, 0x95, 0x02, + 0xDE, 0x83, 0xA7, 0x7D, 0xD2, 0x81, 0x15, 0x0C + }, + { + 0x51, 0x33, 0xDC, 0x8B, 0xEF, 0x72, 0x53, 0x59, + 0xDF, 0xF5, 0x97, 0x92, 0xD8, 0x5E, 0xAF, 0x75, + 0xB7, 0xE1, 0xDC, 0xD1, 0x97, 0x8B, 0x01, 0xC3, + 0x5B, 0x1B, 0x85, 0xFC, 0xEB, 0xC6, 0x33, 0x88, + 0xAD, 0x99, 0xA1, 0x7B, 0x63, 0x46, 0xA2, 0x17, + 0xDC, 0x1A, 0x96, 0x22, 0xEB, 0xD1, 0x22, 0xEC, + 0xF6, 0x91, 0x3C, 0x4D, 0x31, 0xA6, 0xB5, 0x2A, + 0x69, 0x5B, 0x86, 0xAF, 0x00, 0xD7, 0x41, 0xA0 + }, + { + 0x27, 0x53, 0xC4, 0xC0, 0xE9, 0x8E, 0xCA, 0xD8, + 0x06, 0xE8, 0x87, 0x80, 0xEC, 0x27, 0xFC, 0xCD, + 0x0F, 0x5C, 0x1A, 0xB5, 0x47, 0xF9, 0xE4, 0xBF, + 0x16, 0x59, 0xD1, 0x92, 0xC2, 0x3A, 0xA2, 0xCC, + 0x97, 0x1B, 0x58, 0xB6, 0x80, 0x25, 0x80, 0xBA, + 0xEF, 0x8A, 0xDC, 0x3B, 0x77, 0x6E, 0xF7, 0x08, + 0x6B, 0x25, 0x45, 0xC2, 0x98, 0x7F, 0x34, 0x8E, + 0xE3, 0x71, 0x9C, 0xDE, 0xF2, 0x58, 0xC4, 0x03 + }, + { + 0xB1, 0x66, 0x35, 0x73, 0xCE, 0x4B, 0x9D, 0x8C, + 0xAE, 0xFC, 0x86, 0x50, 0x12, 0xF3, 0xE3, 0x97, + 0x14, 0xB9, 0x89, 0x8A, 0x5D, 0xA6, 0xCE, 0x17, + 0xC2, 0x5A, 0x6A, 0x47, 0x93, 0x1A, 0x9D, 0xDB, + 0x9B, 0xBE, 0x98, 0xAD, 0xAA, 0x55, 0x3B, 0xEE, + 0xD4, 0x36, 0xE8, 0x95, 0x78, 0x45, 0x54, 0x16, + 0xC2, 0xA5, 0x2A, 0x52, 0x5C, 0xF2, 0x86, 0x2B, + 0x8D, 0x1D, 0x49, 0xA2, 0x53, 0x1B, 0x73, 0x91 + }, + { + 0x64, 0xF5, 0x8B, 0xD6, 0xBF, 0xC8, 0x56, 0xF5, + 0xE8, 0x73, 0xB2, 0xA2, 0x95, 0x6E, 0xA0, 0xED, + 0xA0, 0xD6, 0xDB, 0x0D, 0xA3, 0x9C, 0x8C, 0x7F, + 0xC6, 0x7C, 0x9F, 0x9F, 0xEE, 0xFC, 0xFF, 0x30, + 0x72, 0xCD, 0xF9, 0xE6, 0xEA, 0x37, 0xF6, 0x9A, + 0x44, 0xF0, 0xC6, 0x1A, 0xA0, 0xDA, 0x36, 0x93, + 0xC2, 0xDB, 0x5B, 0x54, 0x96, 0x0C, 0x02, 0x81, + 0xA0, 0x88, 0x15, 0x1D, 0xB4, 0x2B, 0x11, 0xE8 + }, + { + 0x07, 0x64, 0xC7, 0xBE, 0x28, 0x12, 0x5D, 0x90, + 0x65, 0xC4, 0xB9, 0x8A, 0x69, 0xD6, 0x0A, 0xED, + 0xE7, 0x03, 0x54, 0x7C, 0x66, 0xA1, 0x2E, 0x17, + 0xE1, 0xC6, 0x18, 0x99, 0x41, 0x32, 0xF5, 0xEF, + 0x82, 0x48, 0x2C, 0x1E, 0x3F, 0xE3, 0x14, 0x6C, + 0xC6, 0x53, 0x76, 0xCC, 0x10, 0x9F, 0x01, 0x38, + 0xED, 0x9A, 0x80, 0xE4, 0x9F, 0x1F, 0x3C, 0x7D, + 0x61, 0x0D, 0x2F, 0x24, 0x32, 0xF2, 0x06, 0x05 + }, + { + 0xF7, 0x48, 0x78, 0x43, 0x98, 0xA2, 0xFF, 0x03, + 0xEB, 0xEB, 0x07, 0xE1, 0x55, 0xE6, 0x61, 0x16, + 0xA8, 0x39, 0x74, 0x1A, 0x33, 0x6E, 0x32, 0xDA, + 0x71, 0xEC, 0x69, 0x60, 0x01, 0xF0, 0xAD, 0x1B, + 0x25, 0xCD, 0x48, 0xC6, 0x9C, 0xFC, 0xA7, 0x26, + 0x5E, 0xCA, 0x1D, 0xD7, 0x19, 0x04, 0xA0, 0xCE, + 0x74, 0x8A, 0xC4, 0x12, 0x4F, 0x35, 0x71, 0x07, + 0x6D, 0xFA, 0x71, 0x16, 0xA9, 0xCF, 0x00, 0xE9 + }, + { + 0x3F, 0x0D, 0xBC, 0x01, 0x86, 0xBC, 0xEB, 0x6B, + 0x78, 0x5B, 0xA7, 0x8D, 0x2A, 0x2A, 0x01, 0x3C, + 0x91, 0x0B, 0xE1, 0x57, 0xBD, 0xAF, 0xFA, 0xE8, + 0x1B, 0xB6, 0x66, 0x3B, 0x1A, 0x73, 0x72, 0x2F, + 0x7F, 0x12, 0x28, 0x79, 0x5F, 0x3E, 0xCA, 0xDA, + 0x87, 0xCF, 0x6E, 0xF0, 0x07, 0x84, 0x74, 0xAF, + 0x73, 0xF3, 0x1E, 0xCA, 0x0C, 0xC2, 0x00, 0xED, + 0x97, 0x5B, 0x68, 0x93, 0xF7, 0x61, 0xCB, 0x6D + }, + { + 0xD4, 0x76, 0x2C, 0xD4, 0x59, 0x98, 0x76, 0xCA, + 0x75, 0xB2, 0xB8, 0xFE, 0x24, 0x99, 0x44, 0xDB, + 0xD2, 0x7A, 0xCE, 0x74, 0x1F, 0xDA, 0xB9, 0x36, + 0x16, 0xCB, 0xC6, 0xE4, 0x25, 0x46, 0x0F, 0xEB, + 0x51, 0xD4, 0xE7, 0xAD, 0xCC, 0x38, 0x18, 0x0E, + 0x7F, 0xC4, 0x7C, 0x89, 0x02, 0x4A, 0x7F, 0x56, + 0x19, 0x1A, 0xDB, 0x87, 0x8D, 0xFD, 0xE4, 0xEA, + 0xD6, 0x22, 0x23, 0xF5, 0xA2, 0x61, 0x0E, 0xFE + }, + { + 0xCD, 0x36, 0xB3, 0xD5, 0xB4, 0xC9, 0x1B, 0x90, + 0xFC, 0xBB, 0xA7, 0x95, 0x13, 0xCF, 0xEE, 0x19, + 0x07, 0xD8, 0x64, 0x5A, 0x16, 0x2A, 0xFD, 0x0C, + 0xD4, 0xCF, 0x41, 0x92, 0xD4, 0xA5, 0xF4, 0xC8, + 0x92, 0x18, 0x3A, 0x8E, 0xAC, 0xDB, 0x2B, 0x6B, + 0x6A, 0x9D, 0x9A, 0xA8, 0xC1, 0x1A, 0xC1, 0xB2, + 0x61, 0xB3, 0x80, 0xDB, 0xEE, 0x24, 0xCA, 0x46, + 0x8F, 0x1B, 0xFD, 0x04, 0x3C, 0x58, 0xEE, 0xFE + }, + { + 0x98, 0x59, 0x34, 0x52, 0x28, 0x16, 0x61, 0xA5, + 0x3C, 0x48, 0xA9, 0xD8, 0xCD, 0x79, 0x08, 0x26, + 0xC1, 0xA1, 0xCE, 0x56, 0x77, 0x38, 0x05, 0x3D, + 0x0B, 0xEE, 0x4A, 0x91, 0xA3, 0xD5, 0xBD, 0x92, + 0xEE, 0xFD, 0xBA, 0xBE, 0xBE, 0x32, 0x04, 0xF2, + 0x03, 0x1C, 0xA5, 0xF7, 0x81, 0xBD, 0xA9, 0x9E, + 0xF5, 0xD8, 0xAE, 0x56, 0xE5, 0xB0, 0x4A, 0x9E, + 0x1E, 0xCD, 0x21, 0xB0, 0xEB, 0x05, 0xD3, 0xE1 + }, + { + 0x77, 0x1F, 0x57, 0xDD, 0x27, 0x75, 0xCC, 0xDA, + 0xB5, 0x59, 0x21, 0xD3, 0xE8, 0xE3, 0x0C, 0xCF, + 0x48, 0x4D, 0x61, 0xFE, 0x1C, 0x1B, 0x9C, 0x2A, + 0xE8, 0x19, 0xD0, 0xFB, 0x2A, 0x12, 0xFA, 0xB9, + 0xBE, 0x70, 0xC4, 0xA7, 0xA1, 0x38, 0xDA, 0x84, + 0xE8, 0x28, 0x04, 0x35, 0xDA, 0xAD, 0xE5, 0xBB, + 0xE6, 0x6A, 0xF0, 0x83, 0x6A, 0x15, 0x4F, 0x81, + 0x7F, 0xB1, 0x7F, 0x33, 0x97, 0xE7, 0x25, 0xA3 + }, + { + 0xC6, 0x08, 0x97, 0xC6, 0xF8, 0x28, 0xE2, 0x1F, + 0x16, 0xFB, 0xB5, 0xF1, 0x5B, 0x32, 0x3F, 0x87, + 0xB6, 0xC8, 0x95, 0x5E, 0xAB, 0xF1, 0xD3, 0x80, + 0x61, 0xF7, 0x07, 0xF6, 0x08, 0xAB, 0xDD, 0x99, + 0x3F, 0xAC, 0x30, 0x70, 0x63, 0x3E, 0x28, 0x6C, + 0xF8, 0x33, 0x9C, 0xE2, 0x95, 0xDD, 0x35, 0x2D, + 0xF4, 0xB4, 0xB4, 0x0B, 0x2F, 0x29, 0xDA, 0x1D, + 0xD5, 0x0B, 0x3A, 0x05, 0xD0, 0x79, 0xE6, 0xBB + }, + { + 0x82, 0x10, 0xCD, 0x2C, 0x2D, 0x3B, 0x13, 0x5C, + 0x2C, 0xF0, 0x7F, 0xA0, 0xD1, 0x43, 0x3C, 0xD7, + 0x71, 0xF3, 0x25, 0xD0, 0x75, 0xC6, 0x46, 0x9D, + 0x9C, 0x7F, 0x1B, 0xA0, 0x94, 0x3C, 0xD4, 0xAB, + 0x09, 0x80, 0x8C, 0xAB, 0xF4, 0xAC, 0xB9, 0xCE, + 0x5B, 0xB8, 0x8B, 0x49, 0x89, 0x29, 0xB4, 0xB8, + 0x47, 0xF6, 0x81, 0xAD, 0x2C, 0x49, 0x0D, 0x04, + 0x2D, 0xB2, 0xAE, 0xC9, 0x42, 0x14, 0xB0, 0x6B + }, + { + 0x1D, 0x4E, 0xDF, 0xFF, 0xD8, 0xFD, 0x80, 0xF7, + 0xE4, 0x10, 0x78, 0x40, 0xFA, 0x3A, 0xA3, 0x1E, + 0x32, 0x59, 0x84, 0x91, 0xE4, 0xAF, 0x70, 0x13, + 0xC1, 0x97, 0xA6, 0x5B, 0x7F, 0x36, 0xDD, 0x3A, + 0xC4, 0xB4, 0x78, 0x45, 0x61, 0x11, 0xCD, 0x43, + 0x09, 0xD9, 0x24, 0x35, 0x10, 0x78, 0x2F, 0xA3, + 0x1B, 0x7C, 0x4C, 0x95, 0xFA, 0x95, 0x15, 0x20, + 0xD0, 0x20, 0xEB, 0x7E, 0x5C, 0x36, 0xE4, 0xEF + }, + { + 0xAF, 0x8E, 0x6E, 0x91, 0xFA, 0xB4, 0x6C, 0xE4, + 0x87, 0x3E, 0x1A, 0x50, 0xA8, 0xEF, 0x44, 0x8C, + 0xC2, 0x91, 0x21, 0xF7, 0xF7, 0x4D, 0xEE, 0xF3, + 0x4A, 0x71, 0xEF, 0x89, 0xCC, 0x00, 0xD9, 0x27, + 0x4B, 0xC6, 0xC2, 0x45, 0x4B, 0xBB, 0x32, 0x30, + 0xD8, 0xB2, 0xEC, 0x94, 0xC6, 0x2B, 0x1D, 0xEC, + 0x85, 0xF3, 0x59, 0x3B, 0xFA, 0x30, 0xEA, 0x6F, + 0x7A, 0x44, 0xD7, 0xC0, 0x94, 0x65, 0xA2, 0x53 + }, + { + 0x29, 0xFD, 0x38, 0x4E, 0xD4, 0x90, 0x6F, 0x2D, + 0x13, 0xAA, 0x9F, 0xE7, 0xAF, 0x90, 0x59, 0x90, + 0x93, 0x8B, 0xED, 0x80, 0x7F, 0x18, 0x32, 0x45, + 0x4A, 0x37, 0x2A, 0xB4, 0x12, 0xEE, 0xA1, 0xF5, + 0x62, 0x5A, 0x1F, 0xCC, 0x9A, 0xC8, 0x34, 0x3B, + 0x7C, 0x67, 0xC5, 0xAB, 0xA6, 0xE0, 0xB1, 0xCC, + 0x46, 0x44, 0x65, 0x49, 0x13, 0x69, 0x2C, 0x6B, + 0x39, 0xEB, 0x91, 0x87, 0xCE, 0xAC, 0xD3, 0xEC + }, + { + 0xA2, 0x68, 0xC7, 0x88, 0x5D, 0x98, 0x74, 0xA5, + 0x1C, 0x44, 0xDF, 0xFE, 0xD8, 0xEA, 0x53, 0xE9, + 0x4F, 0x78, 0x45, 0x6E, 0x0B, 0x2E, 0xD9, 0x9F, + 0xF5, 0xA3, 0x92, 0x47, 0x60, 0x81, 0x38, 0x26, + 0xD9, 0x60, 0xA1, 0x5E, 0xDB, 0xED, 0xBB, 0x5D, + 0xE5, 0x22, 0x6B, 0xA4, 0xB0, 0x74, 0xE7, 0x1B, + 0x05, 0xC5, 0x5B, 0x97, 0x56, 0xBB, 0x79, 0xE5, + 0x5C, 0x02, 0x75, 0x4C, 0x2C, 0x7B, 0x6C, 0x8A + }, + { + 0x0C, 0xF8, 0x54, 0x54, 0x88, 0xD5, 0x6A, 0x86, + 0x81, 0x7C, 0xD7, 0xEC, 0xB1, 0x0F, 0x71, 0x16, + 0xB7, 0xEA, 0x53, 0x0A, 0x45, 0xB6, 0xEA, 0x49, + 0x7B, 0x6C, 0x72, 0xC9, 0x97, 0xE0, 0x9E, 0x3D, + 0x0D, 0xA8, 0x69, 0x8F, 0x46, 0xBB, 0x00, 0x6F, + 0xC9, 0x77, 0xC2, 0xCD, 0x3D, 0x11, 0x77, 0x46, + 0x3A, 0xC9, 0x05, 0x7F, 0xDD, 0x16, 0x62, 0xC8, + 0x5D, 0x0C, 0x12, 0x64, 0x43, 0xC1, 0x04, 0x73 + }, + { + 0xB3, 0x96, 0x14, 0x26, 0x8F, 0xDD, 0x87, 0x81, + 0x51, 0x5E, 0x2C, 0xFE, 0xBF, 0x89, 0xB4, 0xD5, + 0x40, 0x2B, 0xAB, 0x10, 0xC2, 0x26, 0xE6, 0x34, + 0x4E, 0x6B, 0x9A, 0xE0, 0x00, 0xFB, 0x0D, 0x6C, + 0x79, 0xCB, 0x2F, 0x3E, 0xC8, 0x0E, 0x80, 0xEA, + 0xEB, 0x19, 0x80, 0xD2, 0xF8, 0x69, 0x89, 0x16, + 0xBD, 0x2E, 0x9F, 0x74, 0x72, 0x36, 0x65, 0x51, + 0x16, 0x64, 0x9C, 0xD3, 0xCA, 0x23, 0xA8, 0x37 + }, + { + 0x74, 0xBE, 0xF0, 0x92, 0xFC, 0x6F, 0x1E, 0x5D, + 0xBA, 0x36, 0x63, 0xA3, 0xFB, 0x00, 0x3B, 0x2A, + 0x5B, 0xA2, 0x57, 0x49, 0x65, 0x36, 0xD9, 0x9F, + 0x62, 0xB9, 0xD7, 0x3F, 0x8F, 0x9E, 0xB3, 0xCE, + 0x9F, 0xF3, 0xEE, 0xC7, 0x09, 0xEB, 0x88, 0x36, + 0x55, 0xEC, 0x9E, 0xB8, 0x96, 0xB9, 0x12, 0x8F, + 0x2A, 0xFC, 0x89, 0xCF, 0x7D, 0x1A, 0xB5, 0x8A, + 0x72, 0xF4, 0xA3, 0xBF, 0x03, 0x4D, 0x2B, 0x4A + }, + { + 0x3A, 0x98, 0x8D, 0x38, 0xD7, 0x56, 0x11, 0xF3, + 0xEF, 0x38, 0xB8, 0x77, 0x49, 0x80, 0xB3, 0x3E, + 0x57, 0x3B, 0x6C, 0x57, 0xBE, 0xE0, 0x46, 0x9B, + 0xA5, 0xEE, 0xD9, 0xB4, 0x4F, 0x29, 0x94, 0x5E, + 0x73, 0x47, 0x96, 0x7F, 0xBA, 0x2C, 0x16, 0x2E, + 0x1C, 0x3B, 0xE7, 0xF3, 0x10, 0xF2, 0xF7, 0x5E, + 0xE2, 0x38, 0x1E, 0x7B, 0xFD, 0x6B, 0x3F, 0x0B, + 0xAE, 0xA8, 0xD9, 0x5D, 0xFB, 0x1D, 0xAF, 0xB1 + }, + { + 0x58, 0xAE, 0xDF, 0xCE, 0x6F, 0x67, 0xDD, 0xC8, + 0x5A, 0x28, 0xC9, 0x92, 0xF1, 0xC0, 0xBD, 0x09, + 0x69, 0xF0, 0x41, 0xE6, 0x6F, 0x1E, 0xE8, 0x80, + 0x20, 0xA1, 0x25, 0xCB, 0xFC, 0xFE, 0xBC, 0xD6, + 0x17, 0x09, 0xC9, 0xC4, 0xEB, 0xA1, 0x92, 0xC1, + 0x5E, 0x69, 0xF0, 0x20, 0xD4, 0x62, 0x48, 0x60, + 0x19, 0xFA, 0x8D, 0xEA, 0x0C, 0xD7, 0xA4, 0x29, + 0x21, 0xA1, 0x9D, 0x2F, 0xE5, 0x46, 0xD4, 0x3D + }, + { + 0x93, 0x47, 0xBD, 0x29, 0x14, 0x73, 0xE6, 0xB4, + 0xE3, 0x68, 0x43, 0x7B, 0x8E, 0x56, 0x1E, 0x06, + 0x5F, 0x64, 0x9A, 0x6D, 0x8A, 0xDA, 0x47, 0x9A, + 0xD0, 0x9B, 0x19, 0x99, 0xA8, 0xF2, 0x6B, 0x91, + 0xCF, 0x61, 0x20, 0xFD, 0x3B, 0xFE, 0x01, 0x4E, + 0x83, 0xF2, 0x3A, 0xCF, 0xA4, 0xC0, 0xAD, 0x7B, + 0x37, 0x12, 0xB2, 0xC3, 0xC0, 0x73, 0x32, 0x70, + 0x66, 0x31, 0x12, 0xCC, 0xD9, 0x28, 0x5C, 0xD9 + }, + { + 0xB3, 0x21, 0x63, 0xE7, 0xC5, 0xDB, 0xB5, 0xF5, + 0x1F, 0xDC, 0x11, 0xD2, 0xEA, 0xC8, 0x75, 0xEF, + 0xBB, 0xCB, 0x7E, 0x76, 0x99, 0x09, 0x0A, 0x7E, + 0x7F, 0xF8, 0xA8, 0xD5, 0x07, 0x95, 0xAF, 0x5D, + 0x74, 0xD9, 0xFF, 0x98, 0x54, 0x3E, 0xF8, 0xCD, + 0xF8, 0x9A, 0xC1, 0x3D, 0x04, 0x85, 0x27, 0x87, + 0x56, 0xE0, 0xEF, 0x00, 0xC8, 0x17, 0x74, 0x56, + 0x61, 0xE1, 0xD5, 0x9F, 0xE3, 0x8E, 0x75, 0x37 + }, + { + 0x10, 0x85, 0xD7, 0x83, 0x07, 0xB1, 0xC4, 0xB0, + 0x08, 0xC5, 0x7A, 0x2E, 0x7E, 0x5B, 0x23, 0x46, + 0x58, 0xA0, 0xA8, 0x2E, 0x4F, 0xF1, 0xE4, 0xAA, + 0xAC, 0x72, 0xB3, 0x12, 0xFD, 0xA0, 0xFE, 0x27, + 0xD2, 0x33, 0xBC, 0x5B, 0x10, 0xE9, 0xCC, 0x17, + 0xFD, 0xC7, 0x69, 0x7B, 0x54, 0x0C, 0x7D, 0x95, + 0xEB, 0x21, 0x5A, 0x19, 0xA1, 0xA0, 0xE2, 0x0E, + 0x1A, 0xBF, 0xA1, 0x26, 0xEF, 0xD5, 0x68, 0xC7 + }, + { + 0x4E, 0x5C, 0x73, 0x4C, 0x7D, 0xDE, 0x01, 0x1D, + 0x83, 0xEA, 0xC2, 0xB7, 0x34, 0x7B, 0x37, 0x35, + 0x94, 0xF9, 0x2D, 0x70, 0x91, 0xB9, 0xCA, 0x34, + 0xCB, 0x9C, 0x6F, 0x39, 0xBD, 0xF5, 0xA8, 0xD2, + 0xF1, 0x34, 0x37, 0x9E, 0x16, 0xD8, 0x22, 0xF6, + 0x52, 0x21, 0x70, 0xCC, 0xF2, 0xDD, 0xD5, 0x5C, + 0x84, 0xB9, 0xE6, 0xC6, 0x4F, 0xC9, 0x27, 0xAC, + 0x4C, 0xF8, 0xDF, 0xB2, 0xA1, 0x77, 0x01, 0xF2 + }, + { + 0x69, 0x5D, 0x83, 0xBD, 0x99, 0x0A, 0x11, 0x17, + 0xB3, 0xD0, 0xCE, 0x06, 0xCC, 0x88, 0x80, 0x27, + 0xD1, 0x2A, 0x05, 0x4C, 0x26, 0x77, 0xFD, 0x82, + 0xF0, 0xD4, 0xFB, 0xFC, 0x93, 0x57, 0x55, 0x23, + 0xE7, 0x99, 0x1A, 0x5E, 0x35, 0xA3, 0x75, 0x2E, + 0x9B, 0x70, 0xCE, 0x62, 0x99, 0x2E, 0x26, 0x8A, + 0x87, 0x77, 0x44, 0xCD, 0xD4, 0x35, 0xF5, 0xF1, + 0x30, 0x86, 0x9C, 0x9A, 0x20, 0x74, 0xB3, 0x38 + }, + { + 0xA6, 0x21, 0x37, 0x43, 0x56, 0x8E, 0x3B, 0x31, + 0x58, 0xB9, 0x18, 0x43, 0x01, 0xF3, 0x69, 0x08, + 0x47, 0x55, 0x4C, 0x68, 0x45, 0x7C, 0xB4, 0x0F, + 0xC9, 0xA4, 0xB8, 0xCF, 0xD8, 0xD4, 0xA1, 0x18, + 0xC3, 0x01, 0xA0, 0x77, 0x37, 0xAE, 0xDA, 0x0F, + 0x92, 0x9C, 0x68, 0x91, 0x3C, 0x5F, 0x51, 0xC8, + 0x03, 0x94, 0xF5, 0x3B, 0xFF, 0x1C, 0x3E, 0x83, + 0xB2, 0xE4, 0x0C, 0xA9, 0x7E, 0xBA, 0x9E, 0x15 + }, + { + 0xD4, 0x44, 0xBF, 0xA2, 0x36, 0x2A, 0x96, 0xDF, + 0x21, 0x3D, 0x07, 0x0E, 0x33, 0xFA, 0x84, 0x1F, + 0x51, 0x33, 0x4E, 0x4E, 0x76, 0x86, 0x6B, 0x81, + 0x39, 0xE8, 0xAF, 0x3B, 0xB3, 0x39, 0x8B, 0xE2, + 0xDF, 0xAD, 0xDC, 0xBC, 0x56, 0xB9, 0x14, 0x6D, + 0xE9, 0xF6, 0x81, 0x18, 0xDC, 0x58, 0x29, 0xE7, + 0x4B, 0x0C, 0x28, 0xD7, 0x71, 0x19, 0x07, 0xB1, + 0x21, 0xF9, 0x16, 0x1C, 0xB9, 0x2B, 0x69, 0xA9 + }, + { + 0x14, 0x27, 0x09, 0xD6, 0x2E, 0x28, 0xFC, 0xCC, + 0xD0, 0xAF, 0x97, 0xFA, 0xD0, 0xF8, 0x46, 0x5B, + 0x97, 0x1E, 0x82, 0x20, 0x1D, 0xC5, 0x10, 0x70, + 0xFA, 0xA0, 0x37, 0x2A, 0xA4, 0x3E, 0x92, 0x48, + 0x4B, 0xE1, 0xC1, 0xE7, 0x3B, 0xA1, 0x09, 0x06, + 0xD5, 0xD1, 0x85, 0x3D, 0xB6, 0xA4, 0x10, 0x6E, + 0x0A, 0x7B, 0xF9, 0x80, 0x0D, 0x37, 0x3D, 0x6D, + 0xEE, 0x2D, 0x46, 0xD6, 0x2E, 0xF2, 0xA4, 0x61 + }, + { + 0xB7, 0x20, 0x71, 0xE0, 0x96, 0x27, 0x7E, 0xDE, + 0xBB, 0x8E, 0xE5, 0x13, 0x4D, 0xD3, 0x71, 0x49, + 0x96, 0x30, 0x7B, 0xA3, 0xA5, 0x5A, 0xA4, 0x73, + 0x3D, 0x41, 0x2A, 0xBB, 0xE2, 0x8E, 0x90, 0x9E, + 0x10, 0xE5, 0x7E, 0x6F, 0xBF, 0xB4, 0xEF, 0x53, + 0xB3, 0xB9, 0x60, 0x51, 0x82, 0x94, 0xFF, 0x88, + 0x9A, 0x90, 0x82, 0x92, 0x54, 0x41, 0x2E, 0x2A, + 0x60, 0xB8, 0x5A, 0xDD, 0x07, 0xA3, 0x67, 0x4F + }, + { + 0x3A, 0x9E, 0x68, 0xB5, 0xA9, 0x1C, 0xCD, 0x5D, + 0xE2, 0x31, 0x64, 0x79, 0x07, 0xC4, 0x27, 0xB8, + 0x2D, 0xCB, 0xEA, 0xAC, 0xA7, 0x07, 0x7A, 0x71, + 0x47, 0x45, 0x16, 0xD4, 0x4A, 0x6C, 0x96, 0xA2, + 0x30, 0x59, 0x05, 0x34, 0xBD, 0x9F, 0x3B, 0xAF, + 0xA8, 0x14, 0x3F, 0x8B, 0xE6, 0x7B, 0x3A, 0xBC, + 0xE7, 0xB6, 0x40, 0x53, 0x29, 0x66, 0x4C, 0x47, + 0xC0, 0xC2, 0x2F, 0x5F, 0x53, 0xAC, 0x13, 0x69 + }, + { + 0x64, 0xDB, 0x26, 0xE1, 0xED, 0x48, 0x33, 0x6E, + 0x7C, 0x82, 0xB0, 0x7A, 0x4A, 0xFF, 0x17, 0xE3, + 0xA6, 0xD9, 0x8E, 0xDD, 0x33, 0xE0, 0x91, 0xF8, + 0xD7, 0x65, 0x7D, 0xE6, 0xC9, 0xE0, 0x0F, 0x79, + 0x82, 0x87, 0xEC, 0x55, 0xC4, 0x19, 0x0D, 0xDF, + 0x67, 0x53, 0xD2, 0xB1, 0xA4, 0xD8, 0x84, 0x2C, + 0x18, 0x2F, 0x62, 0x6B, 0xE4, 0xA0, 0xDA, 0x1C, + 0xA0, 0x93, 0xBB, 0x2E, 0x9E, 0x33, 0x05, 0x3E + }, + { + 0xFE, 0x2C, 0x15, 0xE2, 0xE3, 0x91, 0x44, 0x27, + 0xF7, 0x12, 0x3A, 0xB3, 0x95, 0xA5, 0x83, 0xA6, + 0xA3, 0xCB, 0xD4, 0xD2, 0x0A, 0xF7, 0x2E, 0xDE, + 0xCA, 0xBE, 0x46, 0xC8, 0x66, 0x4E, 0x6C, 0xB9, + 0xF8, 0x6D, 0xE1, 0x7E, 0x4E, 0xD5, 0x24, 0x4B, + 0xA3, 0x1C, 0xCF, 0x80, 0xA8, 0x6B, 0x1D, 0xAD, + 0x12, 0x1F, 0x52, 0x62, 0x18, 0xC1, 0x09, 0xC1, + 0x74, 0x4C, 0x19, 0xF4, 0x1F, 0xAB, 0x3F, 0x72 + }, + { + 0x96, 0xB7, 0x1D, 0x72, 0x67, 0x16, 0x26, 0xDC, + 0xFB, 0x3E, 0x4F, 0x65, 0xE5, 0xD1, 0xAD, 0xEB, + 0x55, 0x5D, 0x16, 0x97, 0xAF, 0x4D, 0xC8, 0x14, + 0x14, 0xDF, 0x27, 0x4D, 0xFE, 0x06, 0xEE, 0xCC, + 0x7B, 0x18, 0x6F, 0x2E, 0x57, 0x62, 0xD2, 0xAE, + 0xC3, 0xAA, 0xAE, 0x4D, 0xBA, 0x2F, 0xFB, 0xE4, + 0x29, 0x25, 0x6E, 0x03, 0xF7, 0x48, 0x14, 0x12, + 0x7D, 0x42, 0x49, 0x28, 0xCD, 0xF0, 0xC9, 0x84 + }, + { + 0xB9, 0x1D, 0xA3, 0xC1, 0xAA, 0x73, 0x97, 0x80, + 0x83, 0xCA, 0x1E, 0x79, 0x0C, 0xFC, 0x81, 0xBF, + 0xD7, 0x89, 0x9A, 0xF1, 0x63, 0x80, 0xB4, 0xA2, + 0x0D, 0xB2, 0xA7, 0xCE, 0x04, 0x47, 0xA7, 0xFF, + 0x0F, 0x7D, 0xCF, 0x7C, 0x80, 0x39, 0xB9, 0x65, + 0xE3, 0x77, 0x26, 0x6D, 0xB6, 0x53, 0x07, 0x8D, + 0x91, 0x92, 0x6E, 0x7A, 0x74, 0xD0, 0x62, 0xA5, + 0xF5, 0xA5, 0xED, 0xB3, 0x9F, 0xA8, 0xF2, 0x53 + }, + { + 0xB7, 0x33, 0x18, 0xE1, 0xAB, 0x4E, 0xBE, 0xDD, + 0xCF, 0xC9, 0x79, 0x7D, 0xC1, 0x39, 0x48, 0x1E, + 0x39, 0x6F, 0x7D, 0x54, 0x0E, 0x16, 0x3E, 0xE7, + 0xFE, 0xA6, 0x23, 0xE1, 0x6A, 0xC9, 0x95, 0x58, + 0xD4, 0xCE, 0xA7, 0x6F, 0x5B, 0x67, 0x6A, 0xF2, + 0xEB, 0x3C, 0x97, 0x6D, 0x35, 0x1A, 0xC4, 0x0C, + 0x07, 0x4F, 0x5F, 0x51, 0xF2, 0x1E, 0x7F, 0x0A, + 0xEE, 0xF9, 0x1B, 0x5E, 0x7C, 0xD8, 0x08, 0xE0 + }, + { + 0x57, 0x9C, 0x6B, 0x50, 0x31, 0xFD, 0xEF, 0x67, + 0x01, 0x20, 0x6D, 0xB0, 0x16, 0x5F, 0x93, 0x15, + 0xBC, 0x64, 0x44, 0x70, 0x0E, 0x59, 0x38, 0x68, + 0x2E, 0xD5, 0x04, 0x87, 0xDB, 0x65, 0x6D, 0x06, + 0xC7, 0x4B, 0x61, 0xEE, 0x0F, 0x14, 0x31, 0x5A, + 0xC8, 0x01, 0x5A, 0x39, 0x15, 0xD9, 0xB5, 0x2E, + 0x91, 0x75, 0xFE, 0x72, 0xB8, 0x29, 0xB7, 0x16, + 0xF7, 0x26, 0x24, 0xD4, 0x21, 0x92, 0xAD, 0xD0 + }, + { + 0x5C, 0x21, 0xA9, 0x78, 0xE4, 0xD8, 0xD3, 0x99, + 0xCB, 0x47, 0xCC, 0x99, 0x22, 0x40, 0xEB, 0x8B, + 0x89, 0x3C, 0xDE, 0xF0, 0xA9, 0xC4, 0x07, 0x07, + 0x9E, 0x1E, 0x9C, 0x0B, 0x07, 0x6F, 0x26, 0x44, + 0x87, 0x8F, 0x98, 0xBB, 0x92, 0x9D, 0xE3, 0x6F, + 0xC8, 0x35, 0xD9, 0x8D, 0x7A, 0x0E, 0x5E, 0x93, + 0x1B, 0xB8, 0x08, 0x92, 0xD8, 0x76, 0x81, 0x4F, + 0xD8, 0x3B, 0x66, 0x15, 0xC7, 0x62, 0x1A, 0x06 + }, + { + 0x65, 0x15, 0x0E, 0xE9, 0x2D, 0x7B, 0x10, 0x25, + 0x3C, 0x4C, 0x7E, 0x6A, 0x25, 0x58, 0x5D, 0x06, + 0x20, 0x24, 0xF8, 0xD4, 0x9C, 0x16, 0xB1, 0x38, + 0xCD, 0x1A, 0xA4, 0xA4, 0x33, 0xD2, 0xAC, 0xBC, + 0x1F, 0xC2, 0x8A, 0x84, 0x0C, 0xB7, 0xAD, 0x13, + 0xA8, 0xB8, 0xBC, 0x19, 0xFA, 0x5E, 0xEE, 0x2D, + 0xDB, 0xBD, 0x02, 0xF2, 0x7B, 0x0B, 0x09, 0xE3, + 0x6A, 0xAF, 0xBB, 0x51, 0x49, 0xBF, 0x9B, 0x37 + }, + { + 0x6C, 0x16, 0xA9, 0x54, 0x18, 0x5C, 0x54, 0x8D, + 0x02, 0xEB, 0xAC, 0xF5, 0xAA, 0x54, 0xB3, 0xB5, + 0x20, 0xC1, 0x0B, 0xF8, 0x9A, 0x21, 0x79, 0xA0, + 0xDC, 0xBD, 0x49, 0xDC, 0x4F, 0xD1, 0xB1, 0x5B, + 0x9C, 0xB1, 0x3B, 0xAB, 0x3E, 0x3E, 0x7C, 0x6B, + 0x4E, 0x45, 0x85, 0xE0, 0x99, 0x00, 0x10, 0x05, + 0x24, 0x67, 0x1B, 0xD4, 0xDC, 0xB1, 0x04, 0x9C, + 0x56, 0x67, 0xD3, 0x57, 0x70, 0x95, 0x04, 0x13 + }, + { + 0xB3, 0x02, 0x01, 0x25, 0x48, 0x73, 0x75, 0x34, + 0xCB, 0xDE, 0x09, 0x96, 0xD6, 0xB5, 0xEB, 0xC7, + 0xA8, 0xB8, 0xA9, 0x79, 0xBC, 0xC2, 0x0A, 0xB5, + 0xCC, 0xA7, 0x07, 0xC6, 0x72, 0x8D, 0xA3, 0xE9, + 0xAB, 0x94, 0x12, 0xB9, 0x0A, 0xAE, 0xB9, 0x4E, + 0xEF, 0x03, 0x25, 0x6F, 0x1C, 0x9C, 0xF5, 0x47, + 0xF1, 0x1F, 0x1A, 0x82, 0xE2, 0x04, 0x21, 0xB4, + 0xB8, 0xAD, 0x2A, 0x1A, 0x1D, 0x6E, 0x19, 0xC2 + }, + { + 0x1D, 0xB4, 0xDF, 0x09, 0xA7, 0xAD, 0x46, 0xE0, + 0x76, 0x30, 0xA5, 0x96, 0x16, 0x41, 0xBF, 0xE3, + 0xBD, 0x65, 0x41, 0x55, 0xF0, 0x4C, 0x50, 0xA9, + 0x79, 0xF0, 0xC8, 0xB7, 0xE5, 0xB0, 0x10, 0xA3, + 0xCF, 0x0B, 0x7B, 0x43, 0xE6, 0x51, 0xB7, 0x51, + 0xE2, 0x02, 0x5C, 0x59, 0x19, 0x96, 0x42, 0xCE, + 0x97, 0x7B, 0x06, 0x47, 0xDD, 0xDF, 0xDD, 0x88, + 0x3B, 0x6E, 0x37, 0xA0, 0x9E, 0xB0, 0x08, 0xD3 + }, + { + 0x23, 0xF4, 0xA5, 0x81, 0x86, 0xF5, 0x85, 0xBA, + 0x27, 0xB5, 0xC6, 0x29, 0x8E, 0x01, 0xBF, 0xC4, + 0x53, 0x20, 0xDB, 0xB0, 0xBF, 0xFF, 0x46, 0x66, + 0x42, 0x43, 0xD5, 0xFA, 0x2B, 0x2D, 0xA6, 0xCE, + 0xD4, 0x52, 0x63, 0x10, 0x9F, 0xDF, 0x24, 0xAB, + 0x3B, 0xE4, 0x3E, 0x10, 0x25, 0x0D, 0x99, 0x8F, + 0x3A, 0x39, 0x06, 0x84, 0x53, 0xB3, 0x02, 0x3A, + 0x6A, 0xF7, 0x7A, 0x26, 0x6B, 0x2B, 0xBB, 0x12 + }, + { + 0x19, 0x6C, 0xD5, 0xEC, 0x4C, 0x48, 0x92, 0x87, + 0xAD, 0x8E, 0xDC, 0xD7, 0xAE, 0xB4, 0xC6, 0xAB, + 0xDB, 0x31, 0xE3, 0xD6, 0x85, 0xA7, 0xCC, 0xE8, + 0x9C, 0xB8, 0x71, 0x9E, 0xC6, 0x3E, 0x83, 0x76, + 0xF5, 0xA2, 0x6B, 0xB0, 0x3F, 0x58, 0x08, 0x88, + 0xB5, 0x15, 0x9F, 0x12, 0xA2, 0x22, 0x4A, 0x66, + 0xEA, 0x24, 0xE8, 0xCB, 0x3C, 0xF1, 0x86, 0xBE, + 0xC0, 0x88, 0xE5, 0x62, 0xBC, 0xAF, 0xB1, 0xF6 + }, + { + 0x9E, 0x1D, 0x29, 0xCB, 0x07, 0xE5, 0x9E, 0xE6, + 0x48, 0x5A, 0x2C, 0x86, 0xC4, 0xF3, 0xE8, 0x60, + 0x43, 0x7F, 0x30, 0xBF, 0x8A, 0xCD, 0x31, 0xA9, + 0x48, 0x59, 0xF4, 0x74, 0xBC, 0x4D, 0xFE, 0xD2, + 0xD9, 0xC1, 0x05, 0x76, 0xE4, 0x36, 0x57, 0x42, + 0xF2, 0x2A, 0xE1, 0x82, 0xE0, 0x02, 0xF0, 0x81, + 0x5C, 0x8C, 0x47, 0x6C, 0x0D, 0xA6, 0x77, 0x1F, + 0xE4, 0x08, 0xBD, 0xAA, 0x12, 0x8A, 0x80, 0x87 + }, + { + 0x38, 0xC9, 0x6E, 0xBD, 0x8C, 0x53, 0x25, 0x89, + 0xEA, 0x6C, 0x70, 0x3F, 0xD7, 0xB9, 0x9C, 0x50, + 0x75, 0x83, 0x49, 0xAA, 0x98, 0x2E, 0xC2, 0x46, + 0xA6, 0x13, 0x00, 0x2F, 0xC8, 0xF8, 0x18, 0x59, + 0x84, 0xCF, 0x73, 0x01, 0x0F, 0xEF, 0x27, 0xDF, + 0x48, 0x98, 0x2E, 0x4A, 0xF2, 0x8F, 0x6A, 0x87, + 0x41, 0xB2, 0x9D, 0x49, 0xCF, 0x88, 0xA5, 0xE3, + 0x21, 0x3A, 0xA9, 0xB0, 0x81, 0x9D, 0xB7, 0x0C + }, + { + 0x3D, 0xC5, 0xA0, 0xC8, 0x4B, 0x55, 0x9D, 0x14, + 0x21, 0x08, 0xF7, 0x92, 0x7C, 0x13, 0xE6, 0x37, + 0x7A, 0x98, 0x27, 0x25, 0x4B, 0x9C, 0x7B, 0x5F, + 0x80, 0x84, 0x42, 0xF3, 0xC8, 0xF0, 0x74, 0xC7, + 0x35, 0xA3, 0xC7, 0x91, 0xCE, 0x06, 0xD6, 0xCE, + 0xCC, 0xD5, 0xC6, 0xAF, 0x72, 0x99, 0xFC, 0x7E, + 0x39, 0x5D, 0xF1, 0x1C, 0x48, 0x26, 0x1F, 0x62, + 0x07, 0xD0, 0xC7, 0x5B, 0xDB, 0x02, 0x77, 0xE3 + }, + { + 0xEE, 0xC6, 0x51, 0x27, 0xA6, 0x25, 0x7A, 0x87, + 0x60, 0x3F, 0x4B, 0xC8, 0x17, 0x88, 0x18, 0x7C, + 0xD6, 0xD1, 0xB4, 0x76, 0x81, 0x7D, 0x5D, 0x3D, + 0xF1, 0x1B, 0x34, 0xBE, 0x5D, 0x18, 0x6A, 0xF3, + 0x92, 0x7B, 0xD2, 0x4B, 0x1C, 0x75, 0x9E, 0xF5, + 0x2A, 0x28, 0xB0, 0x0A, 0x1D, 0x56, 0xEB, 0x03, + 0xF9, 0xC1, 0x5A, 0xF3, 0x1F, 0xAA, 0x90, 0xD1, + 0x62, 0x72, 0x15, 0x8A, 0xF5, 0x62, 0x5A, 0x4A + }, + { + 0x66, 0x18, 0x65, 0x1A, 0xC1, 0x43, 0x57, 0x99, + 0x90, 0x80, 0xEF, 0x5D, 0xCB, 0x8B, 0xD4, 0x21, + 0x64, 0xE3, 0x2A, 0x63, 0x5C, 0x4F, 0x48, 0x1C, + 0x1D, 0xFF, 0xBC, 0x9D, 0x85, 0x2B, 0xA4, 0xF1, + 0x4C, 0x2A, 0x96, 0xFE, 0xA5, 0x5F, 0xF9, 0xFF, + 0xD8, 0x82, 0x54, 0xE4, 0xBE, 0x8F, 0x68, 0x49, + 0x1B, 0x1C, 0xCC, 0x2E, 0x6C, 0x9A, 0xEF, 0xE3, + 0xBA, 0x5B, 0x10, 0x95, 0x51, 0x90, 0x8C, 0x85 + }, + { + 0x25, 0xD7, 0xF9, 0xF4, 0x42, 0xD4, 0x43, 0x7D, + 0xCE, 0x00, 0x42, 0x1D, 0x66, 0x42, 0xE6, 0xBD, + 0x32, 0xBA, 0x08, 0xE5, 0xF6, 0xB6, 0x86, 0xD0, + 0x9A, 0x0E, 0x4B, 0x53, 0xB0, 0x67, 0xCF, 0xB8, + 0x6F, 0xBF, 0x82, 0x98, 0x52, 0xA0, 0x70, 0xD6, + 0x43, 0xD3, 0x2D, 0xF2, 0xE2, 0x3D, 0x6B, 0xFA, + 0x5B, 0x3F, 0xDC, 0x28, 0x0F, 0xE0, 0x9F, 0x32, + 0x46, 0x08, 0x98, 0xE8, 0x2B, 0x8B, 0xA8, 0xF6 + }, + { + 0x20, 0x6C, 0x70, 0x54, 0x9C, 0xD9, 0xCF, 0xFC, + 0x15, 0xA2, 0x4E, 0x5A, 0xE4, 0x57, 0x51, 0x09, + 0xA8, 0x01, 0xDF, 0xAD, 0xD4, 0xCF, 0xD4, 0xF1, + 0x64, 0x7F, 0x15, 0x4C, 0x14, 0x9B, 0x7C, 0x7B, + 0x12, 0x67, 0x04, 0xCE, 0x9F, 0x88, 0xA1, 0xB5, + 0xAB, 0x4C, 0xC1, 0x0F, 0x9E, 0x3C, 0x32, 0x6A, + 0xEC, 0x12, 0x26, 0xB7, 0xD2, 0xE8, 0x7D, 0x42, + 0xA8, 0x86, 0xEB, 0x87, 0xD5, 0x56, 0x18, 0xE0 + }, + { + 0x0E, 0xF2, 0x73, 0x2B, 0x27, 0x3E, 0x0C, 0xCA, + 0x12, 0x95, 0x8A, 0xC6, 0x98, 0x86, 0x47, 0x42, + 0x9C, 0x67, 0xA1, 0xC9, 0x49, 0x5B, 0x1C, 0xFC, + 0x46, 0x91, 0x9F, 0x69, 0xEF, 0xCA, 0x97, 0x59, + 0x04, 0x5C, 0x2D, 0x71, 0xA8, 0x74, 0xED, 0x0C, + 0x55, 0x30, 0x1E, 0x0F, 0x8E, 0x9C, 0xAB, 0xD8, + 0xBE, 0x12, 0x62, 0x19, 0xED, 0x59, 0x10, 0x95, + 0x5E, 0xD2, 0x52, 0xE0, 0x29, 0x72, 0x1C, 0x85 + }, + { + 0xB1, 0x32, 0x2F, 0x81, 0xA0, 0x21, 0x98, 0x23, + 0xAB, 0x5C, 0x0B, 0xC6, 0x32, 0x03, 0xDD, 0x11, + 0x4E, 0x98, 0xC2, 0x57, 0xA5, 0x04, 0x0F, 0xB9, + 0xFA, 0x1C, 0x2F, 0xDC, 0x62, 0x72, 0x30, 0xCB, + 0x6A, 0xDB, 0x94, 0xAF, 0x05, 0xB8, 0xEE, 0x31, + 0x9B, 0x58, 0x9D, 0x69, 0x7E, 0xFE, 0x13, 0xBC, + 0x42, 0x69, 0x15, 0xB0, 0x17, 0xAF, 0x55, 0xFC, + 0xAF, 0x3E, 0x40, 0x88, 0x9F, 0x9D, 0xB8, 0x07 + }, + { + 0xE2, 0xE3, 0x72, 0x2B, 0xC1, 0x75, 0xD8, 0xF7, + 0x72, 0x1F, 0x81, 0x39, 0x78, 0x75, 0xD6, 0x99, + 0xA8, 0xAE, 0x80, 0x25, 0x29, 0x7C, 0x0E, 0x33, + 0x15, 0xB5, 0x76, 0x6C, 0x95, 0x89, 0x64, 0xA0, + 0x0D, 0xB3, 0x4E, 0x3E, 0x89, 0xDD, 0xDA, 0x1B, + 0xF9, 0x93, 0x62, 0xF7, 0x31, 0x15, 0x94, 0x0D, + 0xFF, 0xF2, 0x70, 0x57, 0x71, 0xAC, 0xFF, 0xD0, + 0xD7, 0x8F, 0x60, 0xC8, 0xBE, 0x2A, 0x76, 0xCD + }, + { + 0xC8, 0x67, 0xB2, 0x4F, 0x3F, 0x14, 0x58, 0x23, + 0x3F, 0x2E, 0x6B, 0x2E, 0xBC, 0xEF, 0x95, 0xDD, + 0x45, 0x34, 0xAF, 0x3D, 0x2B, 0x7B, 0x98, 0x2F, + 0x62, 0x24, 0xF6, 0x81, 0xCD, 0x31, 0xB1, 0xF0, + 0x54, 0xCC, 0x51, 0x64, 0x8D, 0x65, 0x65, 0x3E, + 0xAA, 0x66, 0x29, 0xB2, 0xE4, 0xF3, 0x49, 0xD6, + 0xF2, 0x07, 0xA3, 0xA5, 0x6E, 0xEA, 0xFE, 0xF9, + 0x71, 0x36, 0x68, 0x24, 0x98, 0x99, 0x47, 0x6F + }, + { + 0x5E, 0x3B, 0x08, 0xA3, 0x12, 0x03, 0x85, 0x19, + 0x49, 0xE0, 0xB4, 0xFB, 0x06, 0xC3, 0xDC, 0x2A, + 0xD8, 0x8B, 0x7D, 0x76, 0x73, 0x5D, 0xF3, 0xE8, + 0x50, 0x2D, 0xF1, 0x38, 0xAA, 0xB5, 0xC7, 0xD5, + 0x95, 0x85, 0xD8, 0x15, 0x05, 0x1E, 0x72, 0x9D, + 0x85, 0xF6, 0xC5, 0x1C, 0x46, 0x14, 0xBA, 0x83, + 0x39, 0x48, 0x29, 0x4F, 0x31, 0xFA, 0xF2, 0xE4, + 0x08, 0xF4, 0x76, 0xA0, 0xE0, 0x20, 0x61, 0x34 + }, + { + 0x8D, 0xA3, 0x58, 0x29, 0x6A, 0xE4, 0x69, 0x71, + 0x0D, 0xE3, 0xBE, 0xF2, 0x74, 0xDC, 0x22, 0x91, + 0xCF, 0x43, 0xA5, 0x1C, 0xE6, 0x10, 0xD2, 0x44, + 0x2D, 0x7A, 0xD5, 0xBC, 0x02, 0xF7, 0x26, 0xC6, + 0x08, 0xBA, 0xE5, 0x42, 0x69, 0x3B, 0xC5, 0x17, + 0xAF, 0xC8, 0x94, 0x67, 0xCE, 0x25, 0x6A, 0x40, + 0xA0, 0x59, 0xAA, 0x3D, 0x15, 0x3A, 0xF6, 0xD1, + 0x15, 0x7A, 0x18, 0xF0, 0xF4, 0xD3, 0x2A, 0xB2 + }, + { + 0xBC, 0xC4, 0x92, 0x2A, 0xF8, 0x35, 0xFF, 0xF1, + 0x7D, 0xEA, 0xF7, 0x75, 0xF0, 0x9D, 0x11, 0xAC, + 0xFE, 0x26, 0x18, 0xFA, 0x64, 0x9B, 0x80, 0x95, + 0x62, 0xB9, 0x8B, 0xA9, 0xAA, 0x50, 0x4E, 0x58, + 0x41, 0xBB, 0xD6, 0x5D, 0x27, 0x9C, 0x1E, 0x6C, + 0xA0, 0x3E, 0xCF, 0x11, 0xC8, 0xAC, 0x4B, 0x94, + 0xC2, 0xC5, 0xB8, 0x6D, 0x02, 0x2C, 0x48, 0xF7, + 0xDE, 0x53, 0x51, 0x9A, 0xCB, 0x1E, 0x94, 0xB8 + }, + { + 0x01, 0xDB, 0x1E, 0x5D, 0x76, 0xF9, 0xF9, 0x9D, + 0x8D, 0x58, 0xC4, 0xEE, 0x1D, 0xA5, 0x68, 0x97, + 0x53, 0xED, 0x47, 0x05, 0x83, 0xEB, 0x1F, 0x3E, + 0x02, 0xE2, 0xDA, 0xE6, 0x7F, 0xCA, 0xC1, 0x8B, + 0x61, 0x74, 0xC7, 0x4A, 0xF7, 0xD7, 0xDD, 0x39, + 0x23, 0xD1, 0xC9, 0x73, 0x3D, 0x5A, 0x4C, 0x8D, + 0xFF, 0x8E, 0xDA, 0xB0, 0x1F, 0x33, 0x5A, 0x72, + 0xE0, 0x5A, 0x35, 0xBE, 0x07, 0x38, 0x13, 0xC0 + }, + { + 0xEB, 0xC2, 0x58, 0xBD, 0x37, 0x14, 0x0B, 0x76, + 0x1E, 0x24, 0x6F, 0x2D, 0x34, 0x75, 0xF7, 0x97, + 0x18, 0x01, 0x01, 0xCA, 0x95, 0x32, 0x9D, 0x41, + 0x60, 0x68, 0xB8, 0xDB, 0x02, 0xBD, 0x3E, 0x6E, + 0x2B, 0x85, 0x6F, 0x23, 0x1E, 0x1E, 0x9D, 0xC0, + 0x87, 0x67, 0x3D, 0x1E, 0x69, 0xD3, 0x0C, 0xAA, + 0x57, 0x1F, 0xB7, 0x1A, 0x16, 0x77, 0x70, 0x57, + 0x90, 0x78, 0x61, 0xC5, 0x6B, 0xEA, 0x1D, 0x41 + }, + { + 0x1B, 0x88, 0x59, 0x0D, 0x8C, 0x0D, 0x6C, 0x72, + 0x92, 0x3B, 0xBE, 0xBC, 0x36, 0xC8, 0x73, 0xCC, + 0x28, 0x42, 0xB6, 0x33, 0x43, 0xA5, 0x2E, 0xAD, + 0xD8, 0xB9, 0x52, 0xA7, 0x1F, 0x49, 0xBE, 0x20, + 0xF3, 0xE8, 0x32, 0x15, 0xC7, 0xD8, 0x24, 0x71, + 0x6B, 0x6A, 0x91, 0x02, 0x49, 0x92, 0xB4, 0x88, + 0x0D, 0x70, 0x9F, 0x41, 0xEA, 0x03, 0x84, 0x9D, + 0x10, 0xDF, 0xD2, 0x0E, 0xF3, 0xDF, 0x3C, 0xF8 + }, + { + 0x83, 0xE0, 0x50, 0xC2, 0x0A, 0x81, 0x0B, 0xD2, + 0xF5, 0x77, 0x02, 0x45, 0x10, 0xD3, 0x6A, 0x20, + 0xF3, 0x16, 0xC4, 0x49, 0x29, 0x83, 0x68, 0x91, + 0xDD, 0xB8, 0x01, 0x93, 0xDA, 0xC0, 0x67, 0xDB, + 0x1C, 0x01, 0x8A, 0xE4, 0x48, 0x9F, 0xA6, 0x23, + 0x5E, 0x16, 0xC0, 0x81, 0x5E, 0xB8, 0x3C, 0xB2, + 0x85, 0x94, 0x1F, 0x03, 0x07, 0x82, 0x42, 0x1D, + 0xA5, 0xCD, 0xAB, 0x55, 0x89, 0x4A, 0xE4, 0x20 + }, + { + 0x72, 0xFB, 0xB7, 0xDB, 0x93, 0x52, 0xB3, 0xF9, + 0x30, 0x38, 0xC6, 0x7A, 0x37, 0xC3, 0x0B, 0x1F, + 0x1A, 0x73, 0x76, 0x3E, 0x35, 0xDD, 0x11, 0x7F, + 0x18, 0xFF, 0x6A, 0x5B, 0xDD, 0xC7, 0x58, 0x28, + 0x9D, 0xFD, 0xF7, 0xF1, 0xB1, 0x11, 0x07, 0x85, + 0xC6, 0x8A, 0xE0, 0x5B, 0x14, 0x50, 0x1A, 0xBF, + 0xCC, 0x05, 0xA7, 0xD1, 0x8A, 0x03, 0x78, 0x3E, + 0xE9, 0x33, 0x08, 0x87, 0x14, 0x20, 0x24, 0x71 + }, + { + 0x61, 0x77, 0xEC, 0x13, 0x6C, 0x12, 0xDE, 0xCA, + 0x9B, 0x49, 0x56, 0xD5, 0x66, 0x6C, 0xA2, 0x3C, + 0x76, 0x32, 0xE0, 0xB6, 0x3E, 0xBE, 0x01, 0x22, + 0x9A, 0x87, 0x25, 0x3D, 0x39, 0x92, 0xA0, 0xAE, + 0x46, 0xF9, 0x84, 0x4E, 0x53, 0xE6, 0x80, 0xA6, + 0x57, 0xA1, 0xB6, 0xFD, 0xC4, 0x0D, 0xDE, 0xBF, + 0xD7, 0x5C, 0xB5, 0x1A, 0x32, 0xF3, 0x90, 0xBE, + 0x27, 0x57, 0xB2, 0x2E, 0xF4, 0x2D, 0xCE, 0xB2 + }, + { + 0xCB, 0x49, 0x94, 0x56, 0x85, 0x9A, 0x99, 0x93, + 0xC2, 0x76, 0x1B, 0x66, 0x53, 0xA0, 0x35, 0x5D, + 0x0C, 0x07, 0xDE, 0xFA, 0x04, 0x1D, 0xEA, 0xB9, + 0xE4, 0x21, 0x2A, 0x7C, 0x6C, 0x73, 0xB5, 0x68, + 0x74, 0x3C, 0x55, 0xD6, 0x1F, 0xE2, 0x6D, 0x19, + 0xF7, 0xD4, 0xA0, 0x9C, 0xDE, 0xF0, 0xE9, 0xF3, + 0x1F, 0x23, 0x53, 0xAA, 0x5F, 0x16, 0x9D, 0xAF, + 0x75, 0x94, 0x50, 0x67, 0xFA, 0xBB, 0x02, 0xC4 + }, + { + 0x1B, 0xBE, 0x41, 0x15, 0x1F, 0xE1, 0x34, 0x5E, + 0x90, 0x93, 0x15, 0x58, 0x64, 0xFF, 0xA4, 0x42, + 0xC6, 0x1C, 0xB4, 0xD2, 0x75, 0x9F, 0xA0, 0x8B, + 0xB3, 0x92, 0x43, 0x05, 0x2E, 0xF0, 0xDB, 0x95, + 0xE8, 0xF9, 0xF9, 0x77, 0xC4, 0xB1, 0xE0, 0x24, + 0x8F, 0xF1, 0x0C, 0xE8, 0x3D, 0xE0, 0x26, 0x2E, + 0x55, 0x38, 0x29, 0x80, 0x0F, 0x20, 0x7B, 0xC4, + 0xDA, 0xBB, 0x50, 0xCD, 0xC7, 0x47, 0x7F, 0xF0 + }, + { + 0x44, 0x19, 0x39, 0x4B, 0x3F, 0xF6, 0xF3, 0xF7, + 0x8D, 0x16, 0xDD, 0x5B, 0xFA, 0x32, 0x06, 0xC3, + 0xC9, 0x7C, 0x56, 0xB4, 0xAD, 0x19, 0x37, 0x7C, + 0x14, 0x5F, 0xA9, 0x78, 0x7D, 0x02, 0x65, 0x64, + 0x87, 0xF4, 0x6A, 0x07, 0x37, 0xBE, 0xC2, 0x2A, + 0x49, 0x7B, 0x58, 0xCE, 0x33, 0x3F, 0x8B, 0x1E, + 0xF2, 0x7E, 0xB4, 0x16, 0xB9, 0x81, 0x9C, 0x29, + 0xD6, 0x35, 0x3F, 0x24, 0xDE, 0xF9, 0xE0, 0xF1 + }, + { + 0x40, 0x4A, 0x34, 0x56, 0xA2, 0xA1, 0x62, 0x64, + 0x5D, 0xF4, 0x1D, 0x70, 0x3B, 0x9B, 0x35, 0x52, + 0xC3, 0x19, 0xFD, 0x4E, 0x07, 0xA0, 0x18, 0x13, + 0xE9, 0xBF, 0x60, 0x9F, 0x2A, 0x2B, 0x5D, 0xAD, + 0xD5, 0x4C, 0x38, 0x93, 0x11, 0x6F, 0x87, 0xD8, + 0xD2, 0xE2, 0xC7, 0xD7, 0xC1, 0x58, 0x9B, 0xA4, + 0xC7, 0x1C, 0x70, 0x66, 0xFB, 0x19, 0x44, 0x8F, + 0x6E, 0x23, 0x80, 0x3D, 0xD4, 0xA1, 0x42, 0x31 + }, + { + 0x6C, 0xF3, 0x63, 0xA6, 0xCE, 0x78, 0xF4, 0x58, + 0xA3, 0xC0, 0x6F, 0xA6, 0x9A, 0xEE, 0x4F, 0x51, + 0x84, 0x4A, 0xF3, 0x7D, 0xE3, 0xD9, 0xAA, 0xF5, + 0x7B, 0x3D, 0x80, 0x1D, 0x0C, 0x23, 0xE7, 0x54, + 0xAB, 0xBA, 0x99, 0xF6, 0xFE, 0xBF, 0x5B, 0x4D, + 0xD4, 0x95, 0x66, 0x5A, 0xEF, 0x33, 0xA9, 0xA8, + 0xE4, 0x1A, 0x35, 0x8B, 0x81, 0xB7, 0x37, 0x31, + 0xA3, 0x9B, 0xCC, 0xAC, 0xAD, 0xDD, 0x20, 0x94 + }, + { + 0x15, 0xBF, 0x57, 0xAE, 0x36, 0xD1, 0x27, 0xF5, + 0x98, 0xE3, 0x87, 0xB1, 0xF9, 0x95, 0xCD, 0xED, + 0x4E, 0x6B, 0x46, 0x4B, 0xDF, 0x00, 0x3A, 0x6D, + 0x25, 0x20, 0xBC, 0x81, 0x72, 0xC2, 0xC4, 0x95, + 0x42, 0xB2, 0x5B, 0xD7, 0x75, 0x72, 0x74, 0xE5, + 0x2F, 0x68, 0xA6, 0xAF, 0x7E, 0x66, 0xC0, 0x4D, + 0xB2, 0x6F, 0x51, 0xBD, 0xBB, 0x44, 0x6A, 0x85, + 0x97, 0xC9, 0x66, 0x82, 0xCF, 0x55, 0x31, 0x9F + }, + { + 0xA3, 0x70, 0x7D, 0x67, 0xC8, 0x3D, 0x3C, 0x58, + 0x73, 0xC4, 0x87, 0xDD, 0x19, 0x02, 0x69, 0x44, + 0xEA, 0xF4, 0x6E, 0xD0, 0x91, 0xA3, 0x46, 0xAE, + 0x19, 0x46, 0x54, 0xDE, 0x04, 0x2C, 0x35, 0xAD, + 0xAD, 0x27, 0xC3, 0xA3, 0x53, 0x67, 0x2A, 0x94, + 0x7F, 0xAF, 0x36, 0x69, 0x7A, 0x4C, 0xF1, 0x59, + 0xA0, 0xFE, 0xD3, 0xEB, 0xDB, 0x92, 0x0E, 0x74, + 0x5C, 0x29, 0x76, 0x92, 0x16, 0xAC, 0x31, 0xD9 + }, + { + 0x9B, 0xCF, 0xD7, 0xB1, 0xCF, 0xB3, 0xCC, 0x51, + 0x9A, 0xFE, 0xE2, 0x2F, 0x15, 0x28, 0xAB, 0xDB, + 0xDD, 0xEC, 0x57, 0x75, 0xCF, 0x00, 0x4C, 0x12, + 0x67, 0x57, 0x65, 0xFE, 0xD9, 0x93, 0x0E, 0xDA, + 0xF6, 0x73, 0x84, 0xFC, 0xA7, 0x30, 0xF3, 0x1E, + 0xAA, 0x91, 0xF2, 0x94, 0x51, 0xFB, 0x64, 0x93, + 0x90, 0xD3, 0x64, 0x76, 0x9F, 0xB3, 0x33, 0x49, + 0x1D, 0xBD, 0xEA, 0x25, 0xEC, 0x43, 0x38, 0x1D + }, + { + 0x9F, 0x00, 0x8F, 0xD8, 0x3B, 0xFF, 0xC4, 0xC5, + 0xE5, 0xAE, 0xB0, 0xBA, 0xB6, 0x51, 0xB5, 0xEB, + 0x05, 0x01, 0xA7, 0x2A, 0x03, 0x17, 0xD2, 0x15, + 0x7C, 0x53, 0x34, 0x7D, 0x12, 0xC4, 0x35, 0x37, + 0xFD, 0xBA, 0xA7, 0x61, 0xFD, 0x64, 0xD1, 0x46, + 0x25, 0x33, 0x38, 0xFD, 0x3A, 0xE7, 0xD6, 0xE7, + 0xBD, 0x21, 0xF7, 0xD8, 0x22, 0x3C, 0xD6, 0x08, + 0x14, 0x81, 0x6A, 0xBC, 0x17, 0xF0, 0xC3, 0x7E + }, + { + 0x8B, 0xCC, 0xF7, 0xDB, 0x5F, 0x47, 0xAE, 0xBF, + 0xAA, 0x04, 0xCB, 0x64, 0xB2, 0x17, 0xA9, 0x1B, + 0x2C, 0xA9, 0x43, 0x75, 0x61, 0xAB, 0xFB, 0x1C, + 0x88, 0x3F, 0x59, 0x10, 0x48, 0xF1, 0xD5, 0x41, + 0x2D, 0x4B, 0xD9, 0x06, 0x2A, 0x61, 0x08, 0x56, + 0x61, 0x24, 0xD7, 0xC2, 0xF7, 0xD4, 0x8D, 0x57, + 0x1C, 0x97, 0xB4, 0x30, 0x0A, 0x85, 0xE6, 0x46, + 0xF4, 0x00, 0x28, 0xC2, 0x62, 0xFA, 0xB0, 0xFB + }, + { + 0x10, 0xF4, 0xDD, 0x45, 0xB9, 0xDC, 0xCF, 0x28, + 0x63, 0x7F, 0xE8, 0xBF, 0xBE, 0x23, 0xFB, 0x03, + 0x38, 0x62, 0x20, 0xA4, 0x83, 0x97, 0xFC, 0xBA, + 0x72, 0x45, 0xC2, 0x63, 0x92, 0xA7, 0x92, 0x61, + 0xB3, 0x3A, 0x6C, 0x00, 0xF1, 0x1B, 0x41, 0x60, + 0x0A, 0xA5, 0x58, 0x1A, 0x4E, 0x88, 0x5C, 0xF9, + 0xBD, 0xAC, 0x2F, 0x2E, 0xCA, 0x48, 0x0C, 0x4B, + 0x14, 0x76, 0xCD, 0xAF, 0x06, 0xD4, 0x11, 0x90 + }, + { + 0xA5, 0xA9, 0xF2, 0xF6, 0x0A, 0x6A, 0xA9, 0xB5, + 0x75, 0x76, 0x72, 0x14, 0x17, 0xB6, 0xD8, 0x6F, + 0x8F, 0xA0, 0x62, 0x7A, 0x31, 0x06, 0x7D, 0xB2, + 0x85, 0xC9, 0x54, 0x48, 0x5B, 0xBD, 0x77, 0x48, + 0xA6, 0xC5, 0x1E, 0x6B, 0xE2, 0x13, 0x89, 0x62, + 0x44, 0xBF, 0xFD, 0x07, 0x68, 0x64, 0xCE, 0x2D, + 0xDF, 0x4B, 0xC6, 0x6C, 0x4F, 0xF4, 0x1E, 0x05, + 0x5D, 0xF3, 0x70, 0x6A, 0x81, 0xB1, 0x71, 0x13 + }, + { + 0x1F, 0x43, 0xDA, 0xD3, 0x00, 0x4A, 0x0F, 0xE1, + 0x9C, 0xAF, 0x2F, 0xA2, 0x5A, 0xE5, 0x3E, 0xB2, + 0xD0, 0xB9, 0x44, 0x7E, 0x92, 0x63, 0x76, 0xA4, + 0x80, 0xDE, 0x79, 0xAE, 0xE7, 0x3A, 0x63, 0x31, + 0xDE, 0x5F, 0x2E, 0xD9, 0xF7, 0x62, 0x48, 0x70, + 0xF3, 0x90, 0x98, 0x13, 0x62, 0x29, 0xC6, 0x1B, + 0xC4, 0xB4, 0x02, 0xE2, 0xEB, 0xDD, 0xA6, 0x7F, + 0x1A, 0x83, 0x94, 0x84, 0x21, 0x32, 0x64, 0x3D + }, + { + 0xE2, 0x32, 0x04, 0x42, 0xB9, 0x1D, 0x32, 0xA1, + 0x7C, 0xB9, 0x10, 0xA7, 0x2B, 0x28, 0x2F, 0x89, + 0x85, 0xF5, 0xB9, 0x53, 0xDE, 0x91, 0x17, 0x1B, + 0x48, 0x24, 0xA0, 0xE6, 0x1E, 0xDA, 0x59, 0x86, + 0xFB, 0xBB, 0xB5, 0x4B, 0xF1, 0xBF, 0xD8, 0x04, + 0x57, 0xA1, 0x2C, 0x39, 0xA3, 0x4E, 0x4A, 0x4F, + 0xA6, 0xC2, 0x9D, 0x8B, 0x76, 0x5C, 0xEE, 0xEB, + 0xE1, 0xB2, 0x30, 0x00, 0x52, 0x90, 0x37, 0xD1 + }, + { + 0x62, 0x33, 0xCC, 0x9E, 0xC3, 0xE2, 0xFE, 0x8B, + 0xEA, 0x33, 0x6E, 0x03, 0x3A, 0xFA, 0x9A, 0x81, + 0x59, 0xB0, 0xF9, 0x1F, 0x7C, 0x5C, 0x84, 0xF1, + 0xD3, 0x65, 0x58, 0xDC, 0x7F, 0xB0, 0x17, 0x2C, + 0x00, 0x24, 0xB9, 0xDC, 0x00, 0xA1, 0xD9, 0x92, + 0x7B, 0x20, 0x59, 0x86, 0x93, 0xA1, 0x0A, 0x86, + 0xC5, 0x7F, 0xF1, 0xD0, 0xFC, 0xC2, 0x05, 0x61, + 0xAD, 0x0C, 0x46, 0x5E, 0xCB, 0xE0, 0x77, 0x0F + }, + { + 0xFF, 0x6E, 0x35, 0x9A, 0x4A, 0xDE, 0x95, 0xBD, + 0x1F, 0xD5, 0xD1, 0x52, 0xBB, 0x40, 0xE7, 0x3D, + 0xEF, 0x73, 0x6E, 0xC1, 0x1E, 0x7D, 0x49, 0x54, + 0xFF, 0xBB, 0x73, 0x8A, 0xC8, 0x3D, 0x1A, 0xBB, + 0x7F, 0xD7, 0xC7, 0xB3, 0x8E, 0x75, 0x71, 0xA1, + 0x64, 0x1F, 0x2D, 0x12, 0x30, 0xFF, 0x91, 0xCA, + 0xB0, 0x87, 0xCE, 0xF2, 0x19, 0xCD, 0x7E, 0x9E, + 0x40, 0x33, 0x57, 0x87, 0xA6, 0x51, 0x50, 0x1E + }, + { + 0xE7, 0x63, 0x26, 0x6E, 0xA7, 0xB6, 0xA3, 0x87, + 0xBE, 0x83, 0x56, 0xE8, 0xF1, 0xF8, 0x96, 0x8C, + 0x10, 0x2A, 0x05, 0xCE, 0x32, 0x9D, 0x32, 0x9E, + 0xFD, 0x33, 0xF1, 0x66, 0xDE, 0xBA, 0x01, 0x34, + 0x51, 0xD3, 0x29, 0x44, 0x8A, 0x08, 0xB6, 0xDA, + 0xD1, 0x57, 0x91, 0x8E, 0x67, 0x51, 0x3D, 0x28, + 0xA5, 0x71, 0x30, 0x68, 0x9A, 0xB9, 0x8B, 0x15, + 0x92, 0xAE, 0xD4, 0xAA, 0x95, 0xD5, 0x9E, 0xE3 + }, + { + 0x95, 0x0F, 0xAE, 0x04, 0xE5, 0xF6, 0xDE, 0x22, + 0x8E, 0xE6, 0x51, 0x86, 0xDD, 0x36, 0xCF, 0x1A, + 0x20, 0xF0, 0x8A, 0xBA, 0xDD, 0xA4, 0x9A, 0xCF, + 0x8D, 0x21, 0x75, 0xC7, 0x54, 0xA6, 0xFF, 0xB4, + 0x1E, 0x07, 0x4C, 0x34, 0x61, 0xF5, 0xC9, 0x7E, + 0x38, 0x01, 0xC1, 0x1B, 0x5C, 0x7C, 0x00, 0x8E, + 0x26, 0x80, 0xD3, 0xAE, 0x02, 0xCE, 0x34, 0xE3, + 0x3F, 0xEF, 0xA2, 0xB6, 0xB0, 0x2A, 0xE6, 0x75 + }, + { + 0xBA, 0x3F, 0x43, 0xCE, 0x66, 0x40, 0xF4, 0xA1, + 0x5E, 0xB2, 0x9B, 0x0B, 0xBF, 0x4D, 0xB5, 0xCC, + 0x0E, 0x7B, 0x8C, 0xD3, 0x57, 0xDC, 0xBD, 0x6D, + 0x28, 0x02, 0x04, 0x92, 0xED, 0x30, 0x95, 0x0A, + 0x7C, 0xBA, 0xF0, 0x74, 0x53, 0x9B, 0xA2, 0x27, + 0x56, 0xDB, 0xF4, 0x48, 0x46, 0x0E, 0x2A, 0xC5, + 0x48, 0xAD, 0xEE, 0x31, 0xFE, 0xE8, 0x7C, 0xAB, + 0xBF, 0x21, 0x1F, 0xC4, 0x1B, 0x17, 0x07, 0x0A + }, + { + 0x3C, 0xBE, 0x59, 0x74, 0xC6, 0x1F, 0x8B, 0x63, + 0xDE, 0x69, 0xB9, 0xBB, 0xB5, 0xE3, 0x9D, 0x16, + 0x13, 0x67, 0x7F, 0x0D, 0x9B, 0x51, 0xFD, 0xB7, + 0x94, 0x78, 0x68, 0x1F, 0x15, 0xCE, 0x69, 0x81, + 0xFD, 0x6C, 0x43, 0x46, 0x56, 0x8D, 0xF1, 0xE8, + 0x6A, 0xFD, 0x01, 0x85, 0xC4, 0x06, 0xD5, 0xC9, + 0x1A, 0x10, 0x1B, 0xAE, 0x65, 0xFA, 0x59, 0xAC, + 0x28, 0xB7, 0x34, 0x75, 0xB6, 0xB2, 0x84, 0x53 + }, + { + 0x28, 0xE6, 0x6C, 0xCC, 0x7B, 0xE9, 0x6B, 0x78, + 0x32, 0xC7, 0x3A, 0x79, 0xB4, 0xF7, 0x1F, 0x50, + 0x48, 0x38, 0x03, 0x7A, 0x40, 0x33, 0x17, 0xBB, + 0xDF, 0x2F, 0x69, 0x13, 0xA3, 0xD0, 0x4B, 0x8F, + 0xC1, 0xDB, 0x2A, 0xEA, 0xCA, 0xCE, 0x56, 0x33, + 0x28, 0xFC, 0xD6, 0xB5, 0x04, 0xF1, 0xFD, 0x77, + 0x6A, 0x41, 0xE9, 0x47, 0xC9, 0x47, 0x5F, 0x9C, + 0x82, 0x0D, 0xEC, 0xF3, 0x05, 0xAF, 0xAA, 0xB6 + }, + { + 0xF7, 0xFC, 0x95, 0x7A, 0xB3, 0xD6, 0x25, 0xB2, + 0x7D, 0x5D, 0x92, 0xC2, 0x89, 0x9C, 0xBA, 0x44, + 0x1D, 0x0C, 0x83, 0xB6, 0x63, 0xF1, 0x72, 0x4D, + 0xAB, 0x4D, 0x07, 0xF1, 0x1A, 0x77, 0xCA, 0x6E, + 0xC2, 0x68, 0xA5, 0x5C, 0x33, 0x37, 0xB0, 0x84, + 0x3C, 0xD8, 0xF2, 0x45, 0xC0, 0x34, 0x46, 0x24, + 0x6B, 0xEC, 0xE9, 0x0D, 0x69, 0xFB, 0x2F, 0x1F, + 0xB5, 0xA1, 0x59, 0xED, 0xCB, 0x59, 0xCA, 0xFA + }, + { + 0xD8, 0xBA, 0x41, 0x47, 0xBE, 0xB8, 0x9A, 0x78, + 0x50, 0xF5, 0x34, 0xA5, 0x88, 0xAC, 0x18, 0xFE, + 0x3E, 0x75, 0xD5, 0xEB, 0xA9, 0xAB, 0xB2, 0x16, + 0x7F, 0x70, 0xA9, 0x66, 0xEC, 0xA0, 0x10, 0x97, + 0x12, 0x34, 0x68, 0x53, 0x2A, 0xEC, 0xEE, 0x7C, + 0xE4, 0x94, 0x4C, 0x3A, 0x22, 0xD9, 0x4E, 0x0A, + 0xF0, 0x4E, 0x32, 0xEC, 0x25, 0x2C, 0x2E, 0x13, + 0xFF, 0x91, 0x13, 0xB4, 0xE4, 0x6D, 0x35, 0x91 + }, + { + 0x58, 0x4C, 0x2A, 0x5F, 0xB4, 0x9A, 0xF1, 0x5C, + 0x85, 0xBF, 0x09, 0xD9, 0xC3, 0xF9, 0x50, 0x01, + 0x67, 0xEE, 0x9A, 0xD7, 0x7B, 0x53, 0xE4, 0x61, + 0x68, 0x29, 0x14, 0x62, 0x9A, 0x79, 0xAF, 0x01, + 0x30, 0xBA, 0x26, 0x3F, 0xE8, 0x25, 0xAA, 0x2C, + 0xBF, 0xBE, 0x42, 0xE9, 0xB6, 0x47, 0x71, 0xF7, + 0xAA, 0xDF, 0xF0, 0x30, 0xCC, 0x9B, 0x6D, 0xA8, + 0xCF, 0xF5, 0xE0, 0x6F, 0xBD, 0xCB, 0xC1, 0x24 + }, + { + 0xBF, 0x7D, 0x03, 0xFE, 0x52, 0x1E, 0xBC, 0x06, + 0x98, 0xD6, 0xAB, 0x89, 0xDC, 0x30, 0xCD, 0x6E, + 0x72, 0x04, 0xCA, 0xCB, 0x48, 0x91, 0xE8, 0x3C, + 0xB8, 0xE8, 0x16, 0xF7, 0x8B, 0x88, 0x66, 0xE0, + 0xFC, 0xF4, 0xD5, 0x78, 0x54, 0x83, 0x26, 0x59, + 0x65, 0xB7, 0x08, 0x3C, 0x3C, 0x24, 0x51, 0x2C, + 0xC4, 0xD5, 0x4C, 0x9E, 0xAF, 0x2D, 0x80, 0x29, + 0x76, 0x4C, 0x89, 0xEA, 0xBB, 0xE9, 0xAA, 0xDA + }, + { + 0x73, 0x18, 0xB8, 0x39, 0x6A, 0xE0, 0xD4, 0xAC, + 0x0F, 0x5E, 0x3C, 0xCE, 0xB0, 0x33, 0xD8, 0x99, + 0x75, 0xD3, 0x8E, 0x1C, 0x60, 0x23, 0xDC, 0x6B, + 0x0C, 0xEF, 0x3B, 0xDC, 0x9F, 0x81, 0xBD, 0x7D, + 0xEB, 0xAC, 0x5F, 0x89, 0x96, 0xB9, 0x71, 0x15, + 0x05, 0x15, 0x35, 0x10, 0x48, 0x40, 0x71, 0xC5, + 0xEE, 0x46, 0x8F, 0x0B, 0x18, 0x6F, 0x0D, 0x74, + 0xCF, 0xD5, 0x1B, 0x07, 0x59, 0x42, 0xA9, 0x8D + }, + { + 0x58, 0x1D, 0x42, 0x53, 0xD9, 0x7C, 0xCA, 0xED, + 0xB0, 0x38, 0x5B, 0x52, 0xC0, 0x80, 0x7F, 0x5D, + 0xED, 0xD5, 0x89, 0x61, 0x92, 0xDB, 0xBB, 0xC9, + 0x89, 0x4B, 0x7C, 0xC6, 0xE1, 0x4C, 0x48, 0x03, + 0xF1, 0xC2, 0x0A, 0xC4, 0x42, 0xC8, 0xF1, 0x50, + 0xDD, 0x74, 0x96, 0xBA, 0x12, 0xB7, 0x12, 0x20, + 0x00, 0x90, 0xBB, 0x5A, 0xA0, 0x9E, 0x08, 0xF0, + 0x9C, 0xA9, 0xE0, 0xB9, 0x66, 0x27, 0x0A, 0xCA + }, + { + 0x6D, 0x6C, 0xF6, 0xD9, 0xE2, 0xF4, 0xA3, 0x02, + 0x86, 0x6F, 0x83, 0x01, 0x99, 0xCD, 0x57, 0x6A, + 0xF2, 0xCE, 0xB6, 0x8D, 0xE5, 0x8F, 0xBE, 0xF6, + 0xD9, 0x77, 0xF2, 0xD9, 0xA9, 0x68, 0x47, 0x83, + 0x99, 0x79, 0xF9, 0x71, 0x46, 0x6F, 0x8F, 0x20, + 0xA6, 0xF5, 0x1C, 0xC6, 0xB7, 0x90, 0xA7, 0xBE, + 0x27, 0x7C, 0xE7, 0x54, 0xF6, 0x57, 0x63, 0x92, + 0xEA, 0x4B, 0x5C, 0x86, 0x28, 0xC1, 0x09, 0xE0 + }, + { + 0xCA, 0x60, 0xC4, 0x8F, 0x4D, 0x6A, 0xD7, 0x49, + 0x53, 0xCC, 0x94, 0x61, 0x30, 0x7A, 0x1A, 0x7B, + 0x31, 0x7B, 0x77, 0xAD, 0xF3, 0xAB, 0x6D, 0xAC, + 0xD0, 0xF0, 0xFD, 0x26, 0xCD, 0x2A, 0x58, 0x1D, + 0x9B, 0x15, 0x20, 0x8E, 0x63, 0xCA, 0x4A, 0x44, + 0xC0, 0xFD, 0xD9, 0x9C, 0x36, 0x65, 0xAE, 0x56, + 0x2B, 0xAF, 0xAC, 0x44, 0x7D, 0x46, 0x5F, 0x70, + 0x40, 0xF2, 0xD7, 0x5F, 0x62, 0x42, 0x31, 0x15 + }, + { + 0xCA, 0x96, 0x9D, 0x63, 0x92, 0x29, 0xDF, 0x4D, + 0xF9, 0x32, 0xE0, 0xAF, 0x08, 0xD7, 0x49, 0x29, + 0x95, 0xB7, 0x0B, 0xB2, 0x3B, 0x27, 0x3E, 0x22, + 0xFB, 0x1F, 0xFB, 0x8D, 0xB7, 0x33, 0x55, 0xCF, + 0x17, 0x66, 0x28, 0xEE, 0x87, 0x87, 0x3D, 0x78, + 0xAA, 0x8A, 0x18, 0x29, 0xBB, 0x4D, 0xB7, 0x4F, + 0xB7, 0xFF, 0xEE, 0x90, 0x2E, 0x2B, 0x52, 0xF9, + 0x77, 0xE1, 0x8B, 0xE4, 0x9E, 0x05, 0xBB, 0x6F + }, + { + 0x5A, 0x65, 0x06, 0x60, 0xCD, 0xF9, 0x7E, 0xB8, + 0x8D, 0x25, 0xF9, 0xC3, 0x36, 0x6E, 0x5B, 0x74, + 0xC8, 0x36, 0x56, 0x41, 0x26, 0x7B, 0x21, 0x62, + 0x62, 0xE0, 0x73, 0xF1, 0x55, 0xF6, 0xDC, 0xC2, + 0x3C, 0xB6, 0xCF, 0xCC, 0x3E, 0x47, 0x84, 0x80, + 0x2D, 0x35, 0xD7, 0x79, 0xB3, 0x2B, 0x20, 0xE1, + 0x01, 0x5E, 0x3D, 0x5D, 0x5E, 0x6E, 0xC7, 0x18, + 0xCA, 0xD3, 0x31, 0x55, 0x13, 0x6B, 0x84, 0xF2 + }, + { + 0xC7, 0xCC, 0x4E, 0xC6, 0x52, 0x65, 0x36, 0x8F, + 0x6F, 0xEC, 0xEE, 0xB6, 0x5D, 0xE3, 0xF1, 0x99, + 0x3E, 0x85, 0x30, 0xBA, 0x25, 0x73, 0xB2, 0x92, + 0xD8, 0xE9, 0xD8, 0xE7, 0x0A, 0x3C, 0xB7, 0x73, + 0xB0, 0xAE, 0xB3, 0x31, 0x0A, 0xE5, 0xB9, 0x6E, + 0x85, 0xE4, 0x58, 0x28, 0x73, 0xF3, 0x72, 0x63, + 0x57, 0x4D, 0xE8, 0xC5, 0xDE, 0x60, 0xB8, 0xA7, + 0xD1, 0xDD, 0x01, 0xB9, 0x93, 0xD9, 0x5B, 0x46 + }, + { + 0x36, 0x66, 0x9C, 0x5F, 0x13, 0x15, 0x55, 0x03, + 0x51, 0x2F, 0xFD, 0xC9, 0xB2, 0x52, 0x77, 0x08, + 0x4F, 0x97, 0x7B, 0x7E, 0x43, 0xC8, 0xF3, 0xE2, + 0x9F, 0x13, 0xB1, 0xE6, 0x86, 0x93, 0x88, 0xDF, + 0x5E, 0x58, 0xB6, 0xB9, 0xD0, 0xEC, 0xCE, 0x3D, + 0x5D, 0xF5, 0xB4, 0xEB, 0x6E, 0x63, 0xDB, 0x70, + 0x5E, 0xA5, 0xAA, 0x9F, 0x3E, 0x9E, 0xDF, 0xD7, + 0x38, 0x69, 0x36, 0xC1, 0xF6, 0x01, 0xA3, 0x4F + }, + { + 0x40, 0xF9, 0x05, 0xB9, 0xCE, 0x1C, 0x73, 0x5D, + 0xF9, 0x2C, 0x89, 0x3E, 0x85, 0x2E, 0xC0, 0x1C, + 0xC8, 0x41, 0xD6, 0xDA, 0x42, 0xF3, 0x16, 0x67, + 0xB6, 0x6F, 0x7B, 0x29, 0xD6, 0xC0, 0xB7, 0x4A, + 0x0B, 0x3F, 0xB8, 0x5C, 0xAA, 0xB8, 0x30, 0x6C, + 0x08, 0x21, 0x5C, 0x83, 0x49, 0xA1, 0x90, 0x93, + 0x36, 0x98, 0xCC, 0x2E, 0xC9, 0x16, 0x91, 0xC9, + 0x0B, 0x75, 0xAB, 0xDC, 0x24, 0x60, 0x23, 0xBF + }, + { + 0xA0, 0x60, 0x6C, 0x97, 0xC1, 0x0F, 0x66, 0xDC, + 0x4F, 0x09, 0x79, 0x10, 0x94, 0x09, 0x2A, 0x9F, + 0xF3, 0xB3, 0x23, 0x4D, 0x5B, 0x35, 0x65, 0xA8, + 0x66, 0xF2, 0x55, 0x0E, 0x4B, 0xF6, 0x45, 0xE7, + 0xFC, 0x69, 0xBE, 0xB7, 0x3B, 0xC6, 0xF3, 0x85, + 0xBD, 0xD3, 0x4D, 0xFC, 0x36, 0x3C, 0x3E, 0x6C, + 0xC1, 0x8B, 0xCB, 0x90, 0xF1, 0xDD, 0xEF, 0x58, + 0x1D, 0x8E, 0xF2, 0x1B, 0xE5, 0x67, 0x4A, 0xC9 + }, + { + 0xB7, 0xA3, 0x45, 0x71, 0x72, 0xEF, 0x57, 0x0C, + 0xF0, 0xA7, 0xE9, 0x66, 0x10, 0x11, 0x22, 0x89, + 0xA5, 0xAC, 0x53, 0xA8, 0x9B, 0xD7, 0xB5, 0xDB, + 0xCA, 0x16, 0x6F, 0x80, 0x84, 0xBF, 0x33, 0xA1, + 0xDC, 0xAC, 0x93, 0xF9, 0x2B, 0x91, 0x6A, 0x52, + 0xC8, 0xEC, 0xDC, 0x09, 0x6E, 0xC4, 0x45, 0x9C, + 0x53, 0x62, 0xCD, 0x2D, 0xCF, 0x4C, 0x95, 0x65, + 0xED, 0x52, 0x0D, 0x38, 0x97, 0x97, 0x4C, 0x5A + }, + { + 0xB4, 0x0B, 0xEC, 0xDD, 0xB0, 0xC8, 0x41, 0x0A, + 0x49, 0x07, 0xB6, 0xF7, 0x61, 0x9B, 0x32, 0xF7, + 0x81, 0x91, 0x69, 0xE3, 0x1E, 0xAD, 0xE8, 0x3D, + 0xF7, 0xD5, 0xFC, 0xFA, 0x19, 0xDA, 0x3B, 0xB0, + 0x70, 0x7D, 0xCC, 0x2A, 0x56, 0x77, 0x80, 0xCF, + 0x9E, 0x94, 0x8D, 0x5A, 0x7F, 0x0D, 0x50, 0xA8, + 0xEB, 0x90, 0xDB, 0xD7, 0x2B, 0x2E, 0x0E, 0xE6, + 0xA0, 0x6B, 0x94, 0xA5, 0x40, 0x32, 0x50, 0x8D + }, + { + 0x84, 0xB1, 0x4B, 0x2E, 0xF4, 0xC1, 0x8F, 0xFB, + 0x12, 0x99, 0xBE, 0xC0, 0xAF, 0x3C, 0x8D, 0x17, + 0x80, 0xEA, 0xE9, 0xC3, 0xEB, 0xE4, 0xAF, 0xD5, + 0x46, 0x02, 0xFB, 0x33, 0x75, 0x15, 0x2A, 0x21, + 0xC9, 0x72, 0xE0, 0x47, 0x65, 0x3F, 0xC4, 0x68, + 0xB1, 0x90, 0xCF, 0x40, 0xB1, 0x5D, 0xAA, 0xCE, + 0x21, 0x48, 0xEB, 0xBD, 0x01, 0xA6, 0xE0, 0xA5, + 0x13, 0x32, 0x7A, 0x10, 0x10, 0x45, 0xB2, 0xB7 + }, + { + 0x9F, 0x24, 0x8F, 0x7C, 0x92, 0x8F, 0x91, 0xDB, + 0xD9, 0x38, 0xD4, 0x0D, 0x9D, 0x70, 0x88, 0xA4, + 0x4E, 0x37, 0x2C, 0x7B, 0x57, 0x43, 0xD3, 0x07, + 0xCF, 0xF6, 0xDA, 0xF1, 0x11, 0xBD, 0x67, 0x7A, + 0xAC, 0x05, 0x28, 0x7B, 0xEA, 0x47, 0xBE, 0x55, + 0x38, 0x1C, 0x65, 0xDA, 0x39, 0x29, 0x67, 0x3D, + 0x6B, 0x8E, 0x0D, 0x66, 0x05, 0x9C, 0x94, 0x88, + 0x3A, 0x42, 0x1C, 0x99, 0x8C, 0xBF, 0x9B, 0xA9 + }, + { + 0x24, 0xC7, 0x9D, 0x72, 0x07, 0x00, 0x8A, 0x30, + 0xC6, 0x34, 0x6F, 0x41, 0x14, 0x2F, 0x35, 0x31, + 0x9F, 0x22, 0x64, 0x27, 0x16, 0x89, 0x52, 0x56, + 0x34, 0xA1, 0xFB, 0xAD, 0xC6, 0x4A, 0x07, 0xDA, + 0x0C, 0xBB, 0x13, 0x0B, 0x33, 0x47, 0xB5, 0xE9, + 0x6E, 0x68, 0xEB, 0xFC, 0x4B, 0xFA, 0x09, 0xD2, + 0x56, 0x10, 0xD0, 0xE9, 0x3C, 0xB8, 0xAD, 0x77, + 0xB9, 0x42, 0xFF, 0x99, 0xCA, 0x08, 0xEF, 0xF2 + }, + { + 0x4C, 0xE8, 0xCE, 0x25, 0xF4, 0x51, 0xC0, 0xDC, + 0xB7, 0x85, 0x15, 0xA7, 0xB1, 0x4D, 0xAB, 0xA6, + 0xB8, 0x53, 0xE5, 0x16, 0xE2, 0x91, 0x14, 0x69, + 0x24, 0x9D, 0xCA, 0xA6, 0x29, 0xF6, 0xCC, 0xEA, + 0x1C, 0xC1, 0xF1, 0xA3, 0xAF, 0x8F, 0x01, 0x72, + 0x33, 0x2F, 0x8E, 0xE3, 0x5B, 0xCB, 0x53, 0xFC, + 0xE4, 0x01, 0x89, 0xAF, 0x24, 0x79, 0x90, 0xC1, + 0x5D, 0x2A, 0xC9, 0x5C, 0x6B, 0xF5, 0x91, 0x03 + }, + { + 0x5D, 0x03, 0xF9, 0x14, 0x29, 0x25, 0x37, 0xC2, + 0xB9, 0x65, 0xE7, 0x0D, 0x07, 0xCF, 0x87, 0x11, + 0xC9, 0xC3, 0xC4, 0xE1, 0x5B, 0x11, 0x35, 0xBE, + 0x7D, 0x35, 0xE4, 0x40, 0xAE, 0x2B, 0x23, 0x15, + 0xD5, 0x59, 0x32, 0x9C, 0x0C, 0x3C, 0x89, 0x05, + 0xBA, 0x9D, 0x14, 0xAD, 0x4E, 0xEE, 0x5D, 0x03, + 0x30, 0x5D, 0xFC, 0xDD, 0x8B, 0x0A, 0x25, 0x5E, + 0xDD, 0x87, 0xB9, 0xEC, 0x3C, 0x92, 0x2B, 0xE9 + }, + { + 0xB3, 0x16, 0xB9, 0x32, 0xBB, 0xBD, 0x39, 0x2F, + 0xA1, 0x31, 0xFD, 0xC8, 0x9D, 0x12, 0x57, 0x73, + 0x18, 0x73, 0x0E, 0x34, 0x38, 0xA9, 0x6E, 0x87, + 0x4E, 0x1B, 0x1B, 0x1E, 0x82, 0xCA, 0x3D, 0x15, + 0x2A, 0x33, 0x11, 0x50, 0x9E, 0x04, 0x76, 0x64, + 0x7F, 0x30, 0xD0, 0x54, 0x7A, 0x09, 0x1E, 0xB3, + 0xDA, 0x0D, 0x63, 0x8B, 0x1B, 0x35, 0x67, 0xDC, + 0xA5, 0x65, 0xAC, 0x1A, 0x90, 0x81, 0x4B, 0xFD + }, + { + 0x2D, 0x9F, 0xA1, 0x3B, 0x3B, 0xB2, 0xAA, 0x81, + 0xB0, 0x0E, 0x89, 0x7B, 0x96, 0x7D, 0x3E, 0x0C, + 0x3A, 0x70, 0x2B, 0xF8, 0xA3, 0x03, 0xBC, 0xE6, + 0x5C, 0x86, 0x7A, 0x04, 0xB9, 0xE9, 0xD4, 0x0D, + 0x2C, 0xAB, 0x3B, 0x64, 0x4E, 0x30, 0x99, 0x6C, + 0x4A, 0x71, 0x83, 0xCC, 0x59, 0x1A, 0x36, 0x6E, + 0x2D, 0x65, 0x17, 0x7F, 0x4D, 0x01, 0x8D, 0x59, + 0xF8, 0x51, 0x3D, 0x33, 0xFD, 0x82, 0x6A, 0xCD + }, + { + 0xE7, 0x75, 0x59, 0x88, 0x3B, 0x3F, 0xDF, 0x9E, + 0x73, 0x34, 0xE8, 0xE8, 0x2B, 0x05, 0xD3, 0x8C, + 0xE9, 0xAE, 0x93, 0x0A, 0xB0, 0xAD, 0xAF, 0x7C, + 0xCE, 0x59, 0xD6, 0x25, 0x4D, 0xF4, 0x5D, 0x08, + 0x63, 0x43, 0x9B, 0xF5, 0xF0, 0xA5, 0xD0, 0x70, + 0xC1, 0xD7, 0x0F, 0xE3, 0x6B, 0x25, 0x41, 0xF7, + 0xB7, 0x66, 0x18, 0xD4, 0x65, 0x10, 0xC2, 0x7E, + 0xA3, 0x20, 0x08, 0xC0, 0x92, 0xF6, 0x11, 0xB6 + }, + { + 0x5C, 0x20, 0xF4, 0xF9, 0x9E, 0xD7, 0x31, 0x85, + 0xEA, 0xD0, 0xF0, 0x40, 0xC9, 0x7A, 0x6D, 0x99, + 0x68, 0xBA, 0xAB, 0xC2, 0x9C, 0xBB, 0x0A, 0xEB, + 0x15, 0x4C, 0x3C, 0xEA, 0xFF, 0x4E, 0x5E, 0x34, + 0x21, 0xAF, 0x51, 0xB3, 0xB7, 0xE3, 0xEA, 0x52, + 0xFD, 0x9F, 0x04, 0xB1, 0x73, 0x93, 0x38, 0xC3, + 0x6A, 0x10, 0x41, 0x3C, 0x64, 0xDF, 0x8B, 0xA2, + 0x55, 0xAF, 0x52, 0x87, 0x99, 0x1C, 0x06, 0x74 + }, + { + 0x61, 0xE7, 0xEA, 0x07, 0x09, 0x38, 0x20, 0xE7, + 0xDB, 0x70, 0x04, 0x5D, 0xEB, 0xB1, 0x42, 0xC8, + 0xCC, 0x9C, 0x07, 0xEC, 0x6B, 0x40, 0x1B, 0xD7, + 0x3D, 0xDB, 0x9F, 0xF9, 0xE8, 0xDC, 0x9F, 0x2C, + 0x58, 0xF6, 0x9B, 0x9F, 0x0C, 0x44, 0x48, 0xC8, + 0x09, 0xFC, 0x16, 0x2E, 0xB9, 0xC9, 0x44, 0x43, + 0xE0, 0xFC, 0x74, 0x67, 0x6B, 0xE0, 0x68, 0x44, + 0x0B, 0x0F, 0x53, 0x98, 0x9F, 0xF8, 0x78, 0x6E + }, + { + 0x8A, 0xC8, 0xD3, 0xA5, 0xE6, 0x69, 0x58, 0x0A, + 0x39, 0x69, 0xF8, 0x54, 0xE9, 0xFC, 0xD3, 0xD6, + 0xCE, 0xB4, 0x19, 0x70, 0x1E, 0x13, 0x79, 0xCB, + 0xA0, 0xAD, 0xFB, 0xF2, 0xD2, 0x7C, 0x75, 0x4E, + 0xF3, 0x21, 0x1E, 0xF4, 0xD8, 0xC7, 0x2F, 0x63, + 0x53, 0xA4, 0x1A, 0xBE, 0xEF, 0xC9, 0x55, 0x90, + 0xEA, 0xDE, 0xB8, 0x10, 0xC0, 0xC5, 0x0C, 0xC9, + 0x95, 0x27, 0x25, 0x21, 0x7A, 0x2B, 0xB4, 0x5D + }, + { + 0x4A, 0x15, 0x4D, 0xF6, 0x4D, 0x13, 0xEA, 0xEB, + 0x16, 0xFF, 0x3B, 0x86, 0xFE, 0x12, 0xF5, 0xE1, + 0x80, 0xDD, 0x88, 0x3B, 0x58, 0xD4, 0xEF, 0xF2, + 0xE0, 0x10, 0x9B, 0xEA, 0x4C, 0xE1, 0xE5, 0xDC, + 0x5F, 0xC7, 0xE8, 0xF6, 0x75, 0xD1, 0xAA, 0x97, + 0x2C, 0x29, 0xC0, 0xAA, 0x97, 0x65, 0x8C, 0x5A, + 0xFB, 0xC4, 0x95, 0xB4, 0xBA, 0x28, 0x2D, 0x43, + 0xB0, 0x82, 0xF2, 0x02, 0x7E, 0xE3, 0xBF, 0x19 + }, + { + 0xE1, 0xCC, 0x4F, 0xD1, 0x58, 0x6C, 0x5B, 0x96, + 0x80, 0xDF, 0xCF, 0x2E, 0x7B, 0x6A, 0x3C, 0x86, + 0x9F, 0x5D, 0xEF, 0xB1, 0xFD, 0xA9, 0x88, 0xBC, + 0x5C, 0x5D, 0xA5, 0x11, 0x3A, 0xA2, 0xD0, 0xD3, + 0x91, 0x4F, 0xCC, 0x2D, 0xBF, 0xCE, 0x7C, 0x28, + 0xDD, 0x7D, 0xE1, 0x35, 0xBB, 0xDC, 0x45, 0x49, + 0xA3, 0x8D, 0x95, 0x05, 0x50, 0xED, 0x83, 0x73, + 0xCE, 0x9D, 0xF4, 0x84, 0xF1, 0x0F, 0xAF, 0x24 + }, + { + 0xB0, 0x37, 0xB7, 0x32, 0xE3, 0x4D, 0x5E, 0xCC, + 0x45, 0x6E, 0x80, 0xC5, 0x97, 0xA4, 0x01, 0x2B, + 0x56, 0xCB, 0xEF, 0xCB, 0x3C, 0x99, 0x73, 0x55, + 0x36, 0x26, 0x44, 0x09, 0x04, 0x87, 0xAE, 0xA6, + 0x5D, 0x6C, 0xC1, 0x13, 0x1E, 0x58, 0x2F, 0xA7, + 0x9D, 0x66, 0x34, 0x33, 0x11, 0xDC, 0x37, 0x7F, + 0xE6, 0x44, 0xBA, 0xA3, 0xE5, 0x0B, 0xA1, 0x16, + 0x22, 0xC1, 0x0B, 0x96, 0x7C, 0x63, 0xA0, 0xF7 + }, + { + 0xF2, 0x2D, 0x13, 0xEA, 0x2E, 0x16, 0x06, 0xC4, + 0xA4, 0x31, 0x21, 0x0F, 0x68, 0xA6, 0x40, 0x6C, + 0xAB, 0xBA, 0x65, 0x0A, 0xCB, 0x06, 0xD3, 0xB4, + 0x5A, 0xA4, 0x79, 0x2D, 0x26, 0xF3, 0x71, 0x9C, + 0x47, 0xA3, 0x19, 0xFE, 0x63, 0xBD, 0x46, 0x1F, + 0xA9, 0xD7, 0x15, 0x50, 0xFB, 0x29, 0x67, 0xFA, + 0xD7, 0x91, 0xCB, 0x72, 0x08, 0x46, 0x07, 0x7F, + 0xEA, 0x40, 0x6B, 0x5F, 0x9E, 0x05, 0xDB, 0xF2 + }, + { + 0xA6, 0xC8, 0xEB, 0x62, 0x50, 0x42, 0xC0, 0x96, + 0xEE, 0xE4, 0x7C, 0xBB, 0xD3, 0x5C, 0xE7, 0x33, + 0x55, 0x3D, 0xD0, 0x98, 0x8B, 0xA6, 0xA7, 0x35, + 0x6E, 0xFB, 0xC4, 0x6C, 0xFD, 0xAD, 0x82, 0x9C, + 0x0E, 0xE4, 0x10, 0xFB, 0xE2, 0xA9, 0x2E, 0x90, + 0xAF, 0x6D, 0x58, 0x4C, 0x5E, 0x91, 0x83, 0x71, + 0x05, 0x09, 0x4A, 0xFA, 0xF3, 0x89, 0xD1, 0x72, + 0x04, 0xC5, 0x73, 0x21, 0x11, 0x30, 0x50, 0xD8 + }, + { + 0x86, 0x38, 0xBD, 0xA8, 0xF3, 0x85, 0xFB, 0xC1, + 0x43, 0x95, 0x31, 0x58, 0x8F, 0xC2, 0x0D, 0x96, + 0xA6, 0x9D, 0xE4, 0x1E, 0x53, 0x17, 0xCE, 0xA2, + 0xB9, 0x9C, 0x70, 0x53, 0xAF, 0x09, 0xB8, 0xB6, + 0xBA, 0x94, 0x88, 0xF5, 0x82, 0xDE, 0x8B, 0x59, + 0x05, 0xF2, 0xF0, 0x0E, 0xAC, 0x29, 0x43, 0x79, + 0x86, 0xA8, 0xE1, 0x6B, 0xE4, 0x0F, 0x34, 0x11, + 0x6C, 0x68, 0xC6, 0x67, 0xB5, 0x71, 0xF6, 0x8F + }, + { + 0x4B, 0x64, 0x65, 0x07, 0x9A, 0x86, 0xE8, 0x1B, + 0xA4, 0x6B, 0x13, 0xFD, 0x7B, 0xA7, 0xDF, 0x06, + 0x64, 0x4B, 0xE8, 0xB0, 0xFC, 0x7E, 0xA6, 0x4E, + 0xF4, 0x31, 0xEB, 0x1B, 0xA6, 0x4E, 0x76, 0x79, + 0x12, 0xD8, 0x2E, 0xC0, 0x6D, 0xEB, 0x33, 0xCA, + 0xFB, 0xEE, 0xDE, 0x7E, 0x33, 0x31, 0xDE, 0xB1, + 0x04, 0x63, 0x5C, 0x16, 0xA4, 0x1F, 0x4C, 0x35, + 0x8F, 0xB7, 0xB9, 0x10, 0xF6, 0x02, 0xD9, 0x2D + }, + { + 0x67, 0x2F, 0xE0, 0xB7, 0x8F, 0x1D, 0xD8, 0x3A, + 0xED, 0x57, 0xB0, 0xFD, 0x43, 0xF6, 0xD8, 0x5D, + 0xBB, 0x9D, 0xE3, 0xDE, 0x0A, 0x2F, 0xF6, 0x82, + 0xE7, 0x87, 0x15, 0x6C, 0xEA, 0x71, 0x90, 0x70, + 0x34, 0x0B, 0x51, 0x1E, 0x9E, 0xB9, 0xEB, 0xFE, + 0xDE, 0xEF, 0x46, 0x3D, 0x52, 0xEE, 0x39, 0x42, + 0x65, 0x4C, 0x1F, 0xB9, 0xBE, 0x39, 0xB9, 0x6E, + 0x61, 0x84, 0x23, 0x35, 0x87, 0x66, 0x48, 0xAA + }, + { + 0xC6, 0xB7, 0xC8, 0x5B, 0x6D, 0x7C, 0xE4, 0x40, + 0x98, 0x54, 0x75, 0x83, 0x28, 0x18, 0x9C, 0x85, + 0x6C, 0xA2, 0xAF, 0x44, 0x10, 0xFE, 0x67, 0x2B, + 0x9E, 0xEA, 0xD0, 0xA2, 0x3B, 0x93, 0xDF, 0xDF, + 0x43, 0xD3, 0x58, 0x53, 0xC5, 0x62, 0xEA, 0x72, + 0xF3, 0x6E, 0x20, 0x9A, 0x25, 0xBF, 0x1F, 0x86, + 0x41, 0x64, 0x88, 0x67, 0x20, 0xA2, 0xC9, 0xD9, + 0x2B, 0x91, 0x3A, 0xC7, 0xAF, 0xBE, 0xE2, 0x87 + }, + { + 0xE4, 0x25, 0x13, 0x83, 0xDC, 0x07, 0x2D, 0xFC, + 0xE8, 0x32, 0x14, 0x43, 0x9B, 0x99, 0x93, 0x91, + 0xC5, 0x8B, 0x96, 0x57, 0xDD, 0x43, 0x7C, 0xC5, + 0xC1, 0x34, 0xF2, 0x1B, 0x45, 0xBB, 0xDC, 0x3D, + 0x0F, 0xFC, 0x13, 0xF8, 0xBF, 0xDD, 0x67, 0xEC, + 0xA2, 0x4C, 0xB6, 0xC8, 0xC8, 0x3C, 0x8D, 0x4B, + 0xD1, 0x2A, 0x1D, 0x03, 0xDA, 0x33, 0x79, 0x04, + 0x7C, 0xB4, 0x52, 0xFC, 0x52, 0x2A, 0xD1, 0x1E + }, + { + 0xFF, 0xAC, 0x7B, 0x74, 0x4B, 0x92, 0xCB, 0x66, + 0xEE, 0x86, 0x3F, 0x78, 0xAD, 0x00, 0xA2, 0xF5, + 0x61, 0x09, 0x80, 0x9C, 0x10, 0x6F, 0x5A, 0x24, + 0x02, 0x42, 0xC7, 0x10, 0x10, 0x73, 0x22, 0xB0, + 0x7D, 0x04, 0xAC, 0x5F, 0x8D, 0xA3, 0x16, 0xD3, + 0x93, 0x61, 0x45, 0x92, 0x1B, 0x39, 0x61, 0xE9, + 0x63, 0x9B, 0x02, 0xC3, 0x84, 0xEE, 0xCE, 0xFE, + 0x12, 0xB0, 0xB6, 0x7C, 0xC1, 0x5A, 0x7B, 0x71 + }, + { + 0x40, 0x2C, 0x76, 0x37, 0x14, 0xA8, 0x43, 0x66, + 0x94, 0x9E, 0x50, 0x46, 0xA1, 0xC3, 0x01, 0xA5, + 0x45, 0x7A, 0x18, 0xE5, 0x0B, 0x67, 0x67, 0x5F, + 0x65, 0x01, 0x4A, 0x62, 0x9F, 0xE0, 0x02, 0x77, + 0xBE, 0x6D, 0xBD, 0x33, 0xF0, 0xF2, 0x92, 0x64, + 0xBB, 0x5B, 0xA3, 0x57, 0x58, 0x00, 0xF5, 0x29, + 0x34, 0x91, 0x39, 0x03, 0x4F, 0xA3, 0xD0, 0x5D, + 0xC0, 0x97, 0x1C, 0x8D, 0x20, 0x29, 0xD5, 0xB4 + }, + { + 0x7A, 0x84, 0x1A, 0xBE, 0x2F, 0xCE, 0x9A, 0x94, + 0xBE, 0x72, 0x40, 0xE8, 0x9C, 0x90, 0x30, 0xAA, + 0x8A, 0x80, 0x45, 0xA1, 0x25, 0x01, 0x34, 0x01, + 0xD4, 0x62, 0xFB, 0x6F, 0x38, 0x77, 0xAA, 0x6F, + 0xEF, 0x5A, 0xCF, 0xBC, 0x79, 0xF3, 0x0A, 0x53, + 0xD8, 0x05, 0x50, 0xD7, 0x47, 0xB0, 0xB8, 0xD1, + 0xFE, 0xDD, 0x43, 0x24, 0x57, 0xB0, 0x85, 0x54, + 0x81, 0xC2, 0xF1, 0xF6, 0x2C, 0xCE, 0xC1, 0xAD + }, + { + 0xD7, 0x8E, 0x04, 0x58, 0x1A, 0xB2, 0x63, 0x8A, + 0x5A, 0xA4, 0x49, 0xBD, 0xF1, 0x6D, 0x3F, 0xBA, + 0xDE, 0xA2, 0xC3, 0x5F, 0x6E, 0x44, 0xFC, 0x08, + 0xCD, 0x3B, 0x67, 0xD0, 0xFD, 0xE3, 0x24, 0xFA, + 0x08, 0x1D, 0x35, 0xA7, 0xE2, 0x87, 0xC8, 0x02, + 0x63, 0x4D, 0xE5, 0xD3, 0xA0, 0xC3, 0x94, 0x7D, + 0x58, 0xC3, 0xCD, 0x55, 0xB9, 0xD6, 0xB7, 0xDE, + 0x55, 0x29, 0x05, 0x0F, 0xF5, 0x5C, 0x89, 0x90 + }, + { + 0x25, 0x13, 0xFD, 0xDF, 0x92, 0x64, 0xE9, 0x88, + 0x03, 0x31, 0x40, 0xE7, 0x52, 0x95, 0xF2, 0x73, + 0x43, 0x56, 0x54, 0xFC, 0xAB, 0x8F, 0x3B, 0xCC, + 0x7A, 0x45, 0x57, 0xBD, 0x4C, 0xA9, 0xAA, 0xD1, + 0xFA, 0xBC, 0xE3, 0xD3, 0x23, 0x94, 0xE6, 0xE7, + 0xA6, 0xC4, 0x8C, 0xE3, 0xCC, 0xD8, 0xE8, 0xD8, + 0xFC, 0x20, 0x2F, 0xA2, 0x8E, 0x20, 0x05, 0x7C, + 0x15, 0x4E, 0x8F, 0xE4, 0x80, 0xCD, 0x6C, 0x5E + }, + { + 0xBE, 0xEF, 0xB5, 0xB4, 0xBF, 0x7A, 0x83, 0x8A, + 0x87, 0x31, 0xFC, 0xA6, 0x54, 0xF6, 0x40, 0x8C, + 0xE4, 0x93, 0xEF, 0x79, 0x35, 0x46, 0xD0, 0x57, + 0xB0, 0xA5, 0x7D, 0x69, 0xE7, 0xAE, 0xA4, 0xA8, + 0x9E, 0x8B, 0xAD, 0xA5, 0x8B, 0x6E, 0x25, 0x7C, + 0xA4, 0x9F, 0x71, 0x8A, 0xA9, 0xC7, 0x12, 0x68, + 0xC1, 0x1D, 0x02, 0x09, 0x77, 0xCA, 0x14, 0x8E, + 0xD1, 0xF4, 0x55, 0xE9, 0x70, 0x8E, 0x01, 0xFF + }, + { + 0x32, 0x5E, 0x14, 0xFA, 0x10, 0x65, 0x1B, 0x9A, + 0xA9, 0xAA, 0xE5, 0x08, 0x3D, 0xE6, 0x2C, 0x48, + 0x43, 0x9E, 0xAD, 0x2C, 0xA2, 0x95, 0xDC, 0x5B, + 0x37, 0x71, 0x8C, 0xF2, 0x90, 0x6B, 0x4B, 0x9E, + 0x54, 0x4F, 0xBD, 0xF4, 0x38, 0xF8, 0x8A, 0x0C, + 0x69, 0x66, 0x92, 0x0E, 0x18, 0x78, 0x53, 0x5F, + 0xA0, 0x85, 0xB8, 0x18, 0xA5, 0x82, 0xB0, 0xEF, + 0xB5, 0x77, 0x7D, 0xA9, 0x6E, 0x2C, 0x53, 0xB9 + }, + { + 0x05, 0x13, 0xF0, 0x68, 0x04, 0x9D, 0x11, 0x62, + 0xBB, 0x70, 0x88, 0x9A, 0x5A, 0xB5, 0x86, 0x6D, + 0x1B, 0xD0, 0x85, 0x6C, 0xD5, 0x77, 0x75, 0xE0, + 0x06, 0xA4, 0x03, 0x4F, 0x1A, 0x6E, 0x74, 0xBA, + 0x02, 0x7D, 0x2F, 0xD8, 0x56, 0x0D, 0x72, 0xFB, + 0x48, 0xD2, 0x30, 0x4F, 0x0F, 0x54, 0xD7, 0xBF, + 0x7C, 0x27, 0xE0, 0x70, 0xF5, 0xA4, 0x48, 0x57, + 0xD6, 0x0E, 0x48, 0x25, 0xE9, 0x99, 0xCB, 0x62 + }, + { + 0xBE, 0xB6, 0x46, 0x3E, 0x34, 0x12, 0x0C, 0xD8, + 0xFE, 0x1B, 0xBE, 0x25, 0x3A, 0xE5, 0xA2, 0x6E, + 0x2F, 0x1D, 0xD5, 0x64, 0x56, 0xDA, 0x33, 0x87, + 0xCA, 0xD8, 0xDC, 0xD6, 0xD0, 0x25, 0x8F, 0x04, + 0xE4, 0x63, 0x94, 0x59, 0x16, 0x36, 0x69, 0x0F, + 0xBE, 0x56, 0xB8, 0xCF, 0xDF, 0xF9, 0xAB, 0xF4, + 0x7A, 0xBE, 0x3D, 0x7F, 0x42, 0xE8, 0xE9, 0xAB, + 0x32, 0x41, 0xCF, 0xD6, 0xD9, 0xD5, 0xCF, 0xF3 + }, + { + 0x93, 0xEF, 0x62, 0xDB, 0x5B, 0x75, 0x84, 0x44, + 0x5A, 0x19, 0x01, 0x3C, 0x6D, 0x9D, 0x4B, 0x1D, + 0x3B, 0x0D, 0x17, 0x07, 0xB8, 0xC5, 0x09, 0x30, + 0x13, 0x35, 0x41, 0x3D, 0x84, 0xD8, 0x49, 0x7D, + 0xBD, 0xAB, 0xCD, 0x01, 0x4B, 0x0F, 0xC4, 0x75, + 0x43, 0xA6, 0x4F, 0x11, 0x63, 0x26, 0xD4, 0x94, + 0x2E, 0xBF, 0x26, 0xEB, 0x34, 0x04, 0x7E, 0x3C, + 0x9E, 0xE2, 0x18, 0xDD, 0x4C, 0x95, 0x6C, 0xDA + }, + { + 0x33, 0xA3, 0x5F, 0xCC, 0x49, 0xE7, 0x0C, 0x0E, + 0x53, 0xFD, 0x98, 0xF9, 0x44, 0x10, 0x83, 0x6C, + 0x03, 0x3C, 0x2C, 0x7B, 0x5E, 0x7C, 0x82, 0xC4, + 0x1E, 0x48, 0xF2, 0x73, 0x42, 0xC0, 0xF5, 0x21, + 0x4D, 0x91, 0x31, 0x52, 0xB9, 0xE5, 0xFF, 0xB0, + 0xE0, 0x63, 0xDF, 0x54, 0xFE, 0xB4, 0x5B, 0x47, + 0x30, 0x8D, 0xBC, 0x9C, 0x21, 0xC8, 0x7B, 0x4B, + 0xD2, 0x2A, 0x72, 0xCA, 0x00, 0x2D, 0xA6, 0xD2 + }, + { + 0xE5, 0xB2, 0xB0, 0x0C, 0x26, 0xBC, 0x03, 0x63, + 0x55, 0x79, 0x61, 0xDC, 0x6A, 0x4C, 0xC4, 0xFF, + 0xBC, 0xE0, 0x48, 0x78, 0x1E, 0x01, 0xC3, 0xCD, + 0x9C, 0x7C, 0x6B, 0xB7, 0x54, 0xCD, 0x44, 0xA4, + 0xEB, 0x01, 0x18, 0x31, 0xC6, 0x01, 0xB4, 0xB8, + 0x0C, 0x0F, 0x91, 0xC8, 0xA1, 0x52, 0xF3, 0xFB, + 0xC2, 0x10, 0x32, 0x0A, 0x9D, 0x14, 0xD0, 0x42, + 0x15, 0xD7, 0x53, 0xFE, 0x45, 0x51, 0x3A, 0x4D + }, + { + 0x9F, 0xAB, 0xEA, 0xD7, 0x7F, 0x76, 0x68, 0xC4, + 0x3E, 0x02, 0x62, 0x7A, 0x52, 0xCB, 0x5F, 0xE3, + 0x22, 0x0C, 0x73, 0xD9, 0xFB, 0x6F, 0x49, 0x08, + 0xC4, 0xD5, 0xB9, 0x9D, 0x10, 0x2C, 0x74, 0x8C, + 0x7D, 0xB8, 0xCC, 0x2C, 0x65, 0xB6, 0x90, 0x9D, + 0x8F, 0x98, 0x0B, 0x90, 0xEB, 0x45, 0xFB, 0x76, + 0x15, 0xB2, 0xAC, 0x9B, 0xCE, 0xDD, 0x52, 0x76, + 0x4A, 0xA8, 0x8C, 0x32, 0xD8, 0x6B, 0x72, 0x1C + }, + { + 0xB8, 0xA0, 0x7F, 0xD2, 0xF3, 0x62, 0x60, 0x65, + 0xB9, 0xA6, 0x88, 0x7B, 0xA7, 0xE0, 0xB3, 0x9D, + 0x81, 0xB5, 0x47, 0xD1, 0x52, 0xDA, 0xAD, 0x06, + 0xE6, 0xF1, 0xD7, 0xA7, 0xF5, 0x97, 0xA0, 0xFC, + 0x09, 0x6F, 0x5A, 0x30, 0x19, 0x77, 0x80, 0x22, + 0xDD, 0x53, 0xFB, 0xFC, 0x28, 0x20, 0xDE, 0x41, + 0x8F, 0x54, 0x16, 0x60, 0x22, 0x5E, 0x2B, 0xFC, + 0xEC, 0xB8, 0x4D, 0x8F, 0xFD, 0x6D, 0x81, 0x0E + }, + { + 0xBF, 0xBB, 0x4F, 0x9B, 0x16, 0xDD, 0x53, 0xCD, + 0x06, 0x42, 0x48, 0x08, 0x04, 0xD3, 0x16, 0x42, + 0x5D, 0xF7, 0xCF, 0x51, 0xFF, 0x05, 0xC4, 0x26, + 0x30, 0x1E, 0xA1, 0x7E, 0x0C, 0xB0, 0x44, 0x71, + 0xA0, 0xCD, 0x78, 0x40, 0x15, 0xC2, 0xA8, 0x03, + 0x97, 0x31, 0x1A, 0x1A, 0xA6, 0x55, 0xB5, 0x55, + 0x0E, 0x8C, 0xA2, 0x4C, 0xD0, 0xF9, 0xB2, 0xEB, + 0xAD, 0x3C, 0x20, 0x0A, 0x60, 0x4B, 0x22, 0x82 + }, + { + 0x52, 0x0E, 0x7F, 0xE0, 0x7B, 0x40, 0x7D, 0x19, + 0x39, 0x75, 0xBA, 0xC7, 0x7A, 0x52, 0xA2, 0x7F, + 0x9E, 0x35, 0x0A, 0x85, 0x3D, 0xAE, 0x2E, 0x35, + 0x0D, 0x66, 0xF5, 0x63, 0x2F, 0xCC, 0x37, 0x57, + 0xF1, 0x20, 0x4D, 0x79, 0x3F, 0xA8, 0xAC, 0x13, + 0x81, 0x44, 0x3F, 0x27, 0x00, 0x36, 0x3E, 0x82, + 0x23, 0x9D, 0xD9, 0x2E, 0xC8, 0xA3, 0x32, 0x6F, + 0x49, 0x85, 0xAF, 0xD4, 0x5A, 0xDD, 0x1A, 0x45 + }, + { + 0xBF, 0xB0, 0x81, 0xE6, 0x2D, 0x58, 0xB8, 0xCF, + 0xD3, 0xA3, 0xDF, 0xFB, 0xBC, 0xDC, 0x68, 0x16, + 0xDF, 0xCC, 0x8F, 0x91, 0xE3, 0x90, 0x2A, 0x15, + 0x08, 0xC2, 0xB6, 0xA7, 0xE0, 0xEE, 0x9C, 0xA1, + 0xA5, 0xBA, 0xA1, 0x59, 0xF1, 0x05, 0x4D, 0x4A, + 0x58, 0xFB, 0x98, 0x61, 0x53, 0x53, 0x26, 0x07, + 0x82, 0xC1, 0x6A, 0xBE, 0x29, 0xAB, 0x9C, 0x19, + 0x40, 0x38, 0x1E, 0x4C, 0xFF, 0x6F, 0x29, 0xD7 + }, + { + 0xFD, 0xD8, 0x74, 0x4D, 0x31, 0xDA, 0xBE, 0x77, + 0xDD, 0xD3, 0x87, 0x69, 0x60, 0x8A, 0xA7, 0xCA, + 0xB1, 0xB5, 0xFC, 0x8F, 0x9C, 0xB9, 0x84, 0xE0, + 0x89, 0x2E, 0x32, 0xFE, 0x4F, 0xDA, 0xB4, 0x88, + 0x22, 0x9F, 0x1F, 0xE0, 0x6F, 0xC6, 0x37, 0xB3, + 0x03, 0x07, 0xD1, 0xB4, 0xDE, 0xAC, 0x7E, 0xB3, + 0xCB, 0x4E, 0x72, 0x1E, 0xAF, 0xFF, 0xCA, 0x8B, + 0x80, 0xA0, 0x15, 0x2F, 0x15, 0xF9, 0x29, 0x02 + }, + { + 0xD5, 0xDD, 0x48, 0x8C, 0x0B, 0x08, 0x96, 0x90, + 0x67, 0x81, 0x6E, 0xD6, 0xB6, 0x4A, 0xFD, 0xD1, + 0xC3, 0x77, 0xC3, 0x60, 0xC4, 0xDD, 0xE8, 0xBA, + 0xDD, 0xCB, 0xFE, 0xC1, 0x95, 0x14, 0x44, 0xAA, + 0x5B, 0x57, 0x7B, 0x23, 0xB3, 0x0B, 0x83, 0x3A, + 0xFB, 0x45, 0x89, 0x78, 0xC4, 0x58, 0x9F, 0x06, + 0x73, 0xE8, 0xD6, 0x34, 0x64, 0x76, 0x0E, 0xC2, + 0x48, 0x0B, 0xFE, 0x50, 0xA4, 0x5F, 0x52, 0x61 + }, + { + 0x42, 0x46, 0x65, 0xF4, 0x95, 0xC3, 0xF9, 0x23, + 0xB7, 0x5C, 0x7E, 0x71, 0x3B, 0x71, 0xE9, 0x53, + 0xAF, 0xEB, 0xF5, 0x9D, 0x29, 0x6A, 0x7E, 0xB3, + 0x41, 0xAF, 0x28, 0x39, 0x1D, 0x94, 0x4E, 0xB5, + 0x09, 0x97, 0xE5, 0x3E, 0x30, 0xC9, 0xF3, 0xD2, + 0x9E, 0x7C, 0xF4, 0x66, 0x99, 0xA5, 0x54, 0x5F, + 0x9D, 0xE4, 0xB3, 0x69, 0xA5, 0xD7, 0xBB, 0x57, + 0x30, 0xEC, 0x8D, 0x3C, 0x19, 0x01, 0xAC, 0x45 + }, + { + 0x90, 0x1B, 0x39, 0x0A, 0xE3, 0x50, 0x54, 0x29, + 0xDD, 0xDE, 0x34, 0x25, 0x5D, 0xFB, 0x32, 0x83, + 0x68, 0x3C, 0x68, 0x57, 0x72, 0x96, 0xD6, 0x0E, + 0x99, 0x4A, 0x63, 0xC8, 0x1B, 0x47, 0x0C, 0xA6, + 0xFC, 0x8E, 0x1C, 0x3B, 0x5A, 0xDD, 0x8D, 0xB3, + 0x77, 0xB4, 0xFE, 0x2F, 0xA1, 0x07, 0xE9, 0x38, + 0xB1, 0x36, 0x46, 0x8B, 0xE5, 0x59, 0x87, 0x5A, + 0xB4, 0xA3, 0x45, 0xFF, 0xF1, 0x4E, 0xA8, 0x62 + }, + { + 0x31, 0x71, 0x69, 0x2F, 0x52, 0xBD, 0xBE, 0x63, + 0x3D, 0xB4, 0xEF, 0xE3, 0x36, 0x07, 0x3A, 0x19, + 0x4A, 0x8E, 0x8E, 0xD4, 0x60, 0xD5, 0x09, 0xAC, + 0xBC, 0x32, 0x6B, 0x1F, 0x2C, 0xBF, 0x60, 0x5A, + 0x01, 0x5A, 0xC4, 0xA9, 0x69, 0x2A, 0x71, 0xE9, + 0xED, 0x0C, 0x83, 0x99, 0xB8, 0xE8, 0xF3, 0x32, + 0x8A, 0xC7, 0x7F, 0xBF, 0x37, 0x9E, 0x89, 0x61, + 0xD3, 0xA1, 0xD8, 0x4C, 0xCD, 0x43, 0xA7, 0xBC + }, + { + 0x6C, 0x0D, 0xE9, 0x96, 0xD1, 0x8F, 0x8F, 0x18, + 0x15, 0x6E, 0x5E, 0x2E, 0x93, 0xD8, 0xE4, 0x4F, + 0xC0, 0x56, 0x4A, 0xA8, 0x5E, 0x7F, 0x6B, 0x52, + 0xA6, 0x9C, 0x48, 0xE5, 0xB7, 0x42, 0x8B, 0x93, + 0x23, 0xB9, 0x3B, 0xE0, 0xF2, 0xDC, 0xC9, 0x8C, + 0x0D, 0x0C, 0xFD, 0xC7, 0x95, 0x1C, 0xEA, 0x8E, + 0xCC, 0x2D, 0x27, 0xBC, 0x49, 0x98, 0x25, 0xF5, + 0x13, 0x02, 0xE2, 0xFE, 0x2B, 0xF2, 0x18, 0x60 + }, + { + 0x8A, 0xD0, 0x3E, 0xBD, 0x78, 0x25, 0x2F, 0xBD, + 0xC6, 0xF4, 0x8A, 0xF6, 0x13, 0x3A, 0xED, 0x0A, + 0xF1, 0x58, 0xC5, 0x04, 0x7C, 0x3C, 0x84, 0x3D, + 0x78, 0xFF, 0x4E, 0x17, 0x05, 0x4F, 0xDD, 0xA0, + 0x9A, 0x80, 0x97, 0x8E, 0xCC, 0xD1, 0xA8, 0x87, + 0xB7, 0x4E, 0x21, 0x1B, 0xDA, 0xC0, 0xA8, 0x2C, + 0x22, 0x33, 0x55, 0x74, 0xCC, 0x35, 0xF3, 0x75, + 0xCA, 0x27, 0x03, 0x12, 0xF6, 0xFC, 0x06, 0xE5 + }, + { + 0xD8, 0x2A, 0x71, 0x19, 0xDC, 0x23, 0xF0, 0xAD, + 0xCF, 0xBF, 0x67, 0xF9, 0x70, 0x9E, 0x29, 0x24, + 0xC5, 0x0A, 0xEF, 0x6D, 0x4D, 0xA2, 0x5A, 0x96, + 0x35, 0xB2, 0x00, 0x1B, 0x5D, 0xBC, 0x43, 0x07, + 0x4D, 0xA9, 0xD2, 0x75, 0xA4, 0x3B, 0x87, 0x65, + 0xFD, 0x64, 0x19, 0xC0, 0x1F, 0x2F, 0x6F, 0xDD, + 0x59, 0x7B, 0x39, 0x4E, 0x3D, 0x95, 0x33, 0x13, + 0x51, 0x5C, 0x50, 0x07, 0xB7, 0x5B, 0x58, 0xE8 + }, + { + 0x1D, 0x9F, 0xC0, 0xE8, 0x84, 0x71, 0x4F, 0x14, + 0x00, 0x32, 0xC2, 0xAE, 0x1F, 0x59, 0xDB, 0xEE, + 0xB5, 0x43, 0x86, 0x12, 0x26, 0x7C, 0x93, 0x34, + 0x0F, 0x5D, 0xE5, 0x67, 0x0D, 0x6A, 0x93, 0x98, + 0xA4, 0x71, 0x23, 0xB4, 0xF9, 0x6C, 0x8A, 0x0B, + 0x06, 0xBB, 0x12, 0x33, 0x3A, 0x98, 0x3E, 0xD9, + 0x1C, 0xF6, 0xBE, 0x8C, 0x14, 0x2E, 0x9B, 0xCF, + 0x7D, 0x5B, 0x14, 0xF6, 0x3D, 0x84, 0x20, 0x4D + }, + { + 0xEC, 0x8E, 0x2E, 0x16, 0x63, 0x51, 0xB4, 0xAC, + 0x5B, 0x32, 0xFE, 0x37, 0x03, 0xC3, 0x3D, 0x02, + 0x0E, 0xC5, 0x85, 0x39, 0x81, 0x0B, 0x97, 0x90, + 0x15, 0x42, 0x98, 0x4F, 0x2A, 0xF4, 0x9C, 0x71, + 0x2D, 0x3E, 0xAD, 0x94, 0x5D, 0x86, 0x46, 0xDD, + 0x50, 0xE2, 0x4E, 0xCC, 0x96, 0x17, 0x12, 0x04, + 0xC2, 0xB6, 0xC7, 0xF3, 0x50, 0xBD, 0x44, 0x9E, + 0x41, 0x69, 0x83, 0x4F, 0xFE, 0xC4, 0x14, 0x3C + }, + { + 0x02, 0x71, 0xDA, 0x80, 0xA8, 0x28, 0x76, 0xE0, + 0x44, 0x46, 0xD4, 0x80, 0x54, 0x35, 0x38, 0x1A, + 0xD1, 0xB6, 0x86, 0xD9, 0x4F, 0xAB, 0xE0, 0x6B, + 0x87, 0x2D, 0x24, 0xEC, 0x57, 0x52, 0x40, 0x61, + 0x52, 0x23, 0x7E, 0x93, 0x71, 0x2A, 0x47, 0x26, + 0x15, 0x99, 0x20, 0x21, 0x1C, 0x95, 0x58, 0xF8, + 0x1A, 0xCA, 0xCF, 0x49, 0x8D, 0x76, 0xA6, 0xD0, + 0xB3, 0x13, 0x9F, 0xF9, 0xFD, 0x6B, 0xF8, 0x48 + }, + { + 0x3F, 0x63, 0x97, 0xBA, 0x9C, 0x0B, 0x5B, 0xB8, + 0x63, 0xF6, 0xE7, 0xB7, 0xDB, 0x80, 0xEA, 0x39, + 0x0D, 0xE0, 0x8B, 0x55, 0x93, 0xBD, 0xB4, 0xC2, + 0x05, 0x9A, 0x3D, 0xF4, 0x50, 0xF9, 0xCB, 0x28, + 0x54, 0xD6, 0x56, 0x51, 0x87, 0x9D, 0x01, 0xC0, + 0xB1, 0x1C, 0x53, 0x30, 0x2A, 0x99, 0xD8, 0xA9, + 0x0C, 0xD4, 0xB6, 0x0F, 0x02, 0xE5, 0x34, 0x6A, + 0xAD, 0x52, 0x8E, 0x15, 0x3D, 0xDB, 0x40, 0xD9 + }, + { + 0x1E, 0x86, 0xAF, 0x05, 0x40, 0xF9, 0xAD, 0x40, + 0xF9, 0xB8, 0x43, 0x14, 0x38, 0xA3, 0xAB, 0xA1, + 0x04, 0xE4, 0xF2, 0xC9, 0xA0, 0xC6, 0x26, 0x97, + 0x42, 0xF1, 0xE7, 0x8F, 0xC0, 0x90, 0x55, 0xF9, + 0x41, 0x03, 0x59, 0xCB, 0x9D, 0x74, 0xF0, 0xF3, + 0xB2, 0x26, 0x6F, 0xCC, 0x3E, 0xE3, 0x7C, 0x4D, + 0xDF, 0xCA, 0x79, 0xD8, 0x30, 0xC6, 0x02, 0xA8, + 0xE2, 0x68, 0x99, 0xE3, 0x6E, 0x22, 0xA3, 0x6E + }, + { + 0x63, 0xC1, 0xBE, 0xA1, 0x7A, 0xCC, 0x53, 0xD6, + 0xC4, 0x66, 0xD9, 0xB9, 0xDF, 0xB7, 0x38, 0x98, + 0x96, 0x03, 0x3D, 0xBF, 0xB4, 0xA9, 0xB8, 0x6B, + 0x96, 0x96, 0xCC, 0x9A, 0x2A, 0x59, 0xAD, 0xC3, + 0x05, 0xEB, 0x7B, 0xC0, 0x28, 0x40, 0x80, 0xB1, + 0xCC, 0x60, 0x6C, 0xE9, 0x3B, 0xDB, 0x50, 0x4B, + 0x19, 0x5B, 0x4B, 0xAA, 0x07, 0x78, 0x6C, 0x2C, + 0x51, 0xAF, 0xAF, 0x7F, 0x0A, 0xC9, 0xFA, 0x25 + }, + { + 0x1A, 0x4B, 0x27, 0xEC, 0xE7, 0x97, 0xEF, 0xFC, + 0xB5, 0xE7, 0xF4, 0x0F, 0x8E, 0xCA, 0xB7, 0x86, + 0x8F, 0xC1, 0xFC, 0x25, 0xC3, 0xFD, 0x91, 0xB8, + 0xF8, 0xA4, 0x83, 0x62, 0x0D, 0x99, 0xD7, 0x98, + 0x6F, 0x26, 0x70, 0x76, 0x24, 0x0C, 0x58, 0xDB, + 0x0C, 0x33, 0xF9, 0x64, 0xB4, 0x15, 0x83, 0xB8, + 0xF8, 0x4A, 0x4F, 0x2F, 0x2D, 0x82, 0xC0, 0x52, + 0x76, 0x40, 0xF8, 0x9B, 0x63, 0xFA, 0x74, 0x4D + }, + { + 0x77, 0x89, 0xAE, 0xDC, 0x59, 0xE7, 0x9D, 0x33, + 0x3A, 0x53, 0x61, 0xCD, 0x8C, 0xB3, 0xDF, 0xEF, + 0xD8, 0x23, 0x64, 0x64, 0xAB, 0x84, 0xEE, 0xB2, + 0x11, 0xF7, 0xC4, 0x81, 0x7F, 0x56, 0x62, 0x17, + 0x17, 0x71, 0x72, 0x55, 0x62, 0x60, 0xB7, 0x40, + 0xAF, 0x74, 0xF1, 0xC8, 0x63, 0xAF, 0x6A, 0x0C, + 0xBC, 0x41, 0x80, 0x29, 0x90, 0xC7, 0x3C, 0xB8, + 0x4D, 0x5E, 0x90, 0xC2, 0x20, 0x94, 0x38, 0x35 + }, + { + 0xD6, 0x39, 0x64, 0x2F, 0xA1, 0x42, 0xB1, 0x00, + 0xB5, 0x57, 0x8C, 0x73, 0x6C, 0xBE, 0x6E, 0x59, + 0x1B, 0xD5, 0xFA, 0xD1, 0xBE, 0xE0, 0x5A, 0x4B, + 0xAC, 0x41, 0xFE, 0x71, 0x43, 0xF5, 0xDF, 0xB8, + 0xAB, 0xC2, 0xE0, 0x30, 0x83, 0x75, 0xCD, 0x45, + 0x39, 0x27, 0x92, 0xF6, 0x39, 0x22, 0xDD, 0x61, + 0x93, 0x86, 0x2A, 0x55, 0x8D, 0x15, 0x4C, 0x00, + 0xBB, 0x66, 0xF5, 0x38, 0xA6, 0x4F, 0xCE, 0x4F + }, + { + 0x26, 0x48, 0x5D, 0x50, 0x44, 0x95, 0x1F, 0x7D, + 0x96, 0x80, 0xFC, 0xF1, 0xF0, 0xFC, 0x2F, 0x60, + 0xE9, 0xDF, 0x0E, 0x91, 0xAE, 0x6C, 0xEE, 0xA3, + 0x1C, 0x61, 0xE0, 0x99, 0xAB, 0x7B, 0xAC, 0x59, + 0xC9, 0x52, 0xC0, 0x25, 0xBD, 0x2E, 0xCF, 0xEC, + 0x5C, 0x79, 0xF2, 0xB9, 0xDE, 0x62, 0x31, 0x77, + 0x8E, 0x64, 0x9A, 0x6D, 0x90, 0x7E, 0xEE, 0x1B, + 0x15, 0xB1, 0x03, 0x81, 0x79, 0xFD, 0x07, 0xE1 + }, + { + 0x88, 0x52, 0xE7, 0xA9, 0xB0, 0xD3, 0x57, 0x87, + 0x08, 0xEE, 0xE9, 0xEA, 0xBC, 0x3F, 0xF3, 0x8E, + 0x42, 0x3D, 0x94, 0x16, 0xCA, 0xBF, 0x3D, 0xAA, + 0x8D, 0x5E, 0x14, 0x1A, 0x8B, 0xBA, 0xD9, 0x45, + 0xEA, 0xF3, 0xE5, 0x39, 0xA2, 0x23, 0x48, 0xE3, + 0x89, 0xCD, 0x72, 0x40, 0xFB, 0x27, 0x4D, 0xE5, + 0xBA, 0xAF, 0xBF, 0xE1, 0x91, 0xDD, 0x77, 0xCB, + 0x13, 0x07, 0x3A, 0xF6, 0xB3, 0xC1, 0x4D, 0x1E + }, + { + 0x2C, 0x36, 0xE4, 0xBD, 0x6F, 0xC1, 0x74, 0x50, + 0xE9, 0xFB, 0x39, 0x96, 0xDD, 0x9F, 0xD7, 0x9F, + 0x30, 0x96, 0x93, 0x5B, 0xDD, 0xF1, 0xA5, 0x45, + 0xF4, 0x7F, 0xDF, 0x84, 0x19, 0xD9, 0xD6, 0xE4, + 0xCF, 0x21, 0x48, 0xDB, 0xB4, 0xBD, 0xF4, 0x8C, + 0x1F, 0xFD, 0xA1, 0xE9, 0xD7, 0xAD, 0x9D, 0x7A, + 0xDA, 0x67, 0x1D, 0xF8, 0xB1, 0xCA, 0x73, 0x2F, + 0x07, 0xBD, 0xE7, 0x6A, 0x9C, 0xEE, 0x43, 0x1C + }, + { + 0xD1, 0x0B, 0x64, 0x1E, 0x71, 0xFF, 0x32, 0xE7, + 0xC3, 0xEA, 0x33, 0x7C, 0xCF, 0x7A, 0xBA, 0x24, + 0xCF, 0xEE, 0x01, 0x29, 0x96, 0x47, 0xBC, 0x77, + 0x36, 0x7B, 0x89, 0xEB, 0x40, 0x53, 0x9A, 0x40, + 0x91, 0x35, 0xDB, 0xA7, 0xE2, 0x50, 0x77, 0x22, + 0xD4, 0xDF, 0xB6, 0xAC, 0xBB, 0x61, 0xCF, 0x3A, + 0x8F, 0x20, 0x3A, 0x90, 0xC9, 0x08, 0xD9, 0xF9, + 0x20, 0x6C, 0x77, 0x5F, 0x95, 0x92, 0xE2, 0x25 + }, + { + 0x1C, 0x33, 0x13, 0x72, 0x71, 0x25, 0x3B, 0xD8, + 0x1A, 0x83, 0xA2, 0xC8, 0x57, 0x0F, 0xE3, 0x85, + 0xDC, 0x87, 0xC4, 0x1F, 0x06, 0x7C, 0x91, 0x9A, + 0x90, 0x07, 0xEB, 0xBF, 0x12, 0x86, 0xB5, 0x33, + 0x64, 0x9C, 0xDD, 0xCE, 0x37, 0x01, 0x8F, 0xEC, + 0x66, 0xAF, 0x39, 0x5A, 0x00, 0xF2, 0xCD, 0x6C, + 0xE2, 0x1D, 0x2A, 0x5A, 0x37, 0x2B, 0x22, 0x42, + 0xE5, 0x9E, 0xB1, 0x14, 0x37, 0xF3, 0xA4, 0x0B + }, + { + 0x0F, 0xC7, 0xB5, 0x66, 0x30, 0xBC, 0x13, 0xD5, + 0x4F, 0x86, 0x36, 0xFE, 0xC6, 0x4E, 0xA1, 0x5E, + 0xFA, 0xEE, 0x10, 0x0F, 0xCE, 0xE8, 0xA6, 0x52, + 0xB0, 0x02, 0x0A, 0xC0, 0x82, 0xBB, 0xCB, 0xEA, + 0x23, 0x1D, 0x75, 0x59, 0xD0, 0x30, 0xD5, 0xDD, + 0x99, 0x26, 0xCE, 0xF6, 0x54, 0xA6, 0x95, 0x3E, + 0xD2, 0xDC, 0x57, 0xB5, 0xD7, 0x07, 0x46, 0x3E, + 0x26, 0xB7, 0x32, 0xCB, 0xEC, 0x93, 0xE4, 0xC2 + }, + { + 0x1E, 0x7D, 0xEE, 0x71, 0x7F, 0x1F, 0x83, 0x03, + 0xF8, 0x49, 0x4C, 0x49, 0xDF, 0x37, 0x4E, 0xBA, + 0x82, 0x17, 0x0E, 0x9F, 0x6C, 0x76, 0xFB, 0x0E, + 0xCC, 0x5B, 0xB0, 0xDE, 0x88, 0xCD, 0x4B, 0x00, + 0x49, 0xB9, 0x64, 0x12, 0x3F, 0x8D, 0x6C, 0x96, + 0x0F, 0x5A, 0x8F, 0xF4, 0xE9, 0x41, 0x97, 0xA2, + 0x26, 0x14, 0xAA, 0x95, 0xF0, 0xB2, 0x3C, 0x7E, + 0xF5, 0xCE, 0xB8, 0xDA, 0x44, 0x30, 0xFA, 0xE9 + }, + { + 0x5B, 0x47, 0xD4, 0x20, 0x90, 0xAE, 0x94, 0x45, + 0xBC, 0x1F, 0x90, 0x00, 0x7A, 0x05, 0xB2, 0xF2, + 0x16, 0xBB, 0xE9, 0x0C, 0x0E, 0xF9, 0xEC, 0x90, + 0x87, 0x0A, 0x14, 0x32, 0x8C, 0x8A, 0xBE, 0xEE, + 0x89, 0xF7, 0x52, 0x0E, 0xA3, 0x18, 0x18, 0xA4, + 0x97, 0xA0, 0xDA, 0x92, 0x74, 0xAE, 0x70, 0x3A, + 0x0F, 0xC2, 0xB1, 0xCD, 0x16, 0xB9, 0x19, 0xF6, + 0x59, 0x40, 0x11, 0x7F, 0x4A, 0xA6, 0xC5, 0x96 + }, + { + 0xD3, 0xBD, 0xD9, 0x6F, 0x48, 0x74, 0xAA, 0x5C, + 0x17, 0x01, 0xF2, 0xBD, 0x5E, 0xA7, 0x00, 0x8A, + 0x66, 0x88, 0xE4, 0xE7, 0x7A, 0xC5, 0xBA, 0x0A, + 0xEF, 0xAA, 0x52, 0xC7, 0xC8, 0x4D, 0xF4, 0xE3, + 0xA9, 0xD0, 0x76, 0xD9, 0x30, 0x46, 0x7C, 0xB5, + 0x1E, 0x20, 0x2B, 0xC9, 0x39, 0x11, 0xD4, 0x98, + 0x2C, 0x88, 0x25, 0xE0, 0xBE, 0x72, 0x7A, 0x2F, + 0x35, 0x9D, 0x15, 0x16, 0xA4, 0xD7, 0x09, 0xB6 + }, + { + 0x82, 0x2D, 0xDF, 0xCF, 0x76, 0xD5, 0x29, 0x64, + 0xA7, 0x95, 0xDD, 0x87, 0x0D, 0x9E, 0x2A, 0x2D, + 0xE8, 0xB2, 0xAF, 0xF6, 0x00, 0x58, 0xF9, 0xE8, + 0x5F, 0x44, 0x0F, 0x94, 0xBA, 0xFA, 0x01, 0x5F, + 0x1B, 0x36, 0xDD, 0xD9, 0x7B, 0x26, 0x83, 0xEE, + 0x3D, 0xCD, 0x61, 0x3D, 0x09, 0x17, 0xEF, 0x05, + 0xC2, 0xFC, 0xE7, 0x55, 0x4E, 0x46, 0xD3, 0x19, + 0xB6, 0xC0, 0x64, 0xBE, 0x10, 0x4C, 0x60, 0x9A + }, + { + 0x8E, 0x2E, 0x95, 0x2D, 0x4F, 0x90, 0x6D, 0x8D, + 0xA7, 0x13, 0x9C, 0x9F, 0x79, 0xF4, 0xB2, 0x91, + 0xA8, 0x2C, 0x88, 0xAC, 0x64, 0x79, 0xA5, 0xC2, + 0x6D, 0xDC, 0xEA, 0x2E, 0x5B, 0xCB, 0x26, 0x8A, + 0x67, 0x40, 0x4A, 0xD7, 0x31, 0x94, 0xC4, 0x72, + 0xA6, 0xF9, 0x7D, 0x6E, 0xFD, 0x74, 0x95, 0xB0, + 0xD2, 0x10, 0xEE, 0x08, 0xAE, 0x07, 0x3A, 0x5C, + 0x12, 0x9E, 0xA0, 0x11, 0xB4, 0x50, 0x9B, 0x55 + }, + { + 0xBF, 0xEF, 0x8D, 0xC5, 0x64, 0x5A, 0xF1, 0x82, + 0x0F, 0xB0, 0xAD, 0xC5, 0xCF, 0xA1, 0x91, 0xA1, + 0xB6, 0xB4, 0x32, 0xF3, 0xB9, 0x36, 0x2F, 0x91, + 0x29, 0xC0, 0xAD, 0x6C, 0xC8, 0x1B, 0x06, 0xF4, + 0x2A, 0x30, 0xA2, 0x20, 0x68, 0x6F, 0x61, 0xDF, + 0x44, 0xC1, 0x0D, 0xC3, 0x22, 0x09, 0xBC, 0x1B, + 0xDE, 0xAA, 0x97, 0x9C, 0xCB, 0xC5, 0x25, 0xEB, + 0x9B, 0x6A, 0xD7, 0x3F, 0x28, 0x67, 0x53, 0xAE + }, + { + 0xE2, 0x28, 0x4C, 0x49, 0x9E, 0x15, 0x2F, 0x0E, + 0x70, 0xE7, 0x0B, 0x09, 0x63, 0x7F, 0x54, 0x2B, + 0x28, 0x82, 0x7D, 0x77, 0xFB, 0x44, 0x30, 0xB4, + 0xA4, 0x2E, 0x25, 0x58, 0x34, 0x3B, 0x82, 0xC3, + 0xE1, 0x8B, 0xEA, 0xF2, 0x69, 0x52, 0x49, 0xFC, + 0xD0, 0xDD, 0xB5, 0xD0, 0xD3, 0xE3, 0x24, 0x2D, + 0xA9, 0x6C, 0xBB, 0xDE, 0xD9, 0x1B, 0x30, 0x23, + 0x9C, 0xCD, 0x58, 0xCC, 0x16, 0xC4, 0x49, 0xFE + }, + { + 0x49, 0x80, 0x88, 0x9D, 0x49, 0xC8, 0xC1, 0x56, + 0x22, 0x1D, 0x7E, 0x5F, 0xF5, 0x67, 0x48, 0xB5, + 0x01, 0xCD, 0x73, 0xD4, 0x8A, 0x75, 0x2B, 0x6C, + 0x43, 0xAB, 0xBA, 0xF5, 0x83, 0x15, 0xC1, 0x51, + 0x32, 0xF8, 0xDF, 0x98, 0x47, 0x9F, 0x19, 0x7A, + 0x63, 0xB0, 0xA0, 0xCA, 0x73, 0x62, 0x44, 0x79, + 0xB9, 0x74, 0xD0, 0x64, 0xBE, 0x61, 0x75, 0x98, + 0x69, 0xFE, 0x27, 0xCC, 0x71, 0x56, 0x92, 0xDD + }, + { + 0x0C, 0x51, 0x4F, 0xB2, 0x2B, 0x88, 0x2B, 0xD8, + 0xF2, 0x14, 0xFF, 0x2B, 0x4F, 0x87, 0xDD, 0x0C, + 0x1F, 0xB3, 0x64, 0x46, 0xB4, 0x5E, 0x06, 0xA8, + 0x62, 0x6C, 0x21, 0xE5, 0xE1, 0x46, 0xBD, 0xB0, + 0x06, 0x6C, 0x4B, 0x15, 0xA0, 0x88, 0x65, 0x63, + 0x35, 0xAD, 0x9A, 0xE4, 0x7B, 0x2A, 0x14, 0xFF, + 0x1B, 0xBA, 0x22, 0x21, 0x28, 0xF7, 0x3D, 0x89, + 0x16, 0x1F, 0xEB, 0x69, 0xDE, 0x61, 0x89, 0xE9 + }, + { + 0x09, 0x65, 0x88, 0xF2, 0xB4, 0x4B, 0xD4, 0x70, + 0xEA, 0xAA, 0x6D, 0xA6, 0xDD, 0xBF, 0xEB, 0xBB, + 0x74, 0x29, 0xD1, 0xC5, 0x68, 0x28, 0xE2, 0x38, + 0x0C, 0x54, 0x9B, 0x15, 0x7E, 0xD6, 0x58, 0x0F, + 0x9E, 0xB6, 0x10, 0x27, 0x84, 0xF3, 0x4F, 0x40, + 0xB5, 0x73, 0x5F, 0xA5, 0xA5, 0x61, 0x7C, 0x58, + 0x5D, 0xAB, 0x64, 0x3D, 0x98, 0xA4, 0x0C, 0x05, + 0x49, 0x94, 0x5D, 0x78, 0xCE, 0x10, 0xBD, 0x84 + }, + { + 0xDE, 0x90, 0x0E, 0x52, 0x97, 0xF5, 0x35, 0x21, + 0x9B, 0x35, 0x23, 0x87, 0x6F, 0x72, 0xCE, 0x6B, + 0xC1, 0xAE, 0x14, 0x2E, 0x45, 0x5D, 0xED, 0xFB, + 0xEA, 0x91, 0xED, 0xEE, 0xDC, 0xD4, 0x0C, 0x76, + 0x36, 0x0E, 0xE6, 0x94, 0x61, 0x1D, 0x5C, 0x32, + 0xCA, 0x2C, 0x1C, 0x00, 0x76, 0xBC, 0xA0, 0xE0, + 0x97, 0x6B, 0xE4, 0xE9, 0xEF, 0xCD, 0x16, 0x23, + 0x5E, 0x9F, 0xEC, 0x58, 0x10, 0x32, 0x44, 0x21 + }, + { + 0xE8, 0x0A, 0xB0, 0x3C, 0x6A, 0x9C, 0x13, 0x5C, + 0xBC, 0x3A, 0x6C, 0x0C, 0x4A, 0x35, 0x90, 0x18, + 0x71, 0xC7, 0x3D, 0x4A, 0x5D, 0xE4, 0xFB, 0x1F, + 0xC1, 0xF5, 0x7B, 0x04, 0xD0, 0xC0, 0x4D, 0x57, + 0xA7, 0xC7, 0x44, 0x85, 0xEC, 0xDA, 0xDA, 0xDF, + 0xE6, 0xF2, 0xD0, 0xE7, 0xF9, 0xCF, 0x72, 0x90, + 0x86, 0xBF, 0x47, 0x21, 0x9F, 0xE7, 0xA6, 0x4E, + 0x08, 0xC6, 0x55, 0x3C, 0x05, 0x95, 0x5D, 0xBC + }, + { + 0x64, 0x63, 0xB3, 0x35, 0x53, 0xD7, 0xBD, 0x23, + 0x28, 0x7F, 0x1E, 0xB0, 0xA7, 0x87, 0xE5, 0xFC, + 0xB1, 0x6E, 0xBB, 0xBF, 0x54, 0xC5, 0x1C, 0x30, + 0x6E, 0xFC, 0xEC, 0x52, 0xF2, 0xAB, 0x0B, 0x11, + 0xEE, 0x3C, 0x9A, 0x0F, 0x56, 0x45, 0x60, 0x34, + 0xD2, 0x90, 0xD1, 0xDF, 0x9C, 0x7C, 0x86, 0x7B, + 0xA7, 0xB8, 0x4E, 0x16, 0x6A, 0xF0, 0x1C, 0xBF, + 0x4E, 0x58, 0xDA, 0xB2, 0x5A, 0xA4, 0x0E, 0x5C + }, + { + 0x5F, 0x98, 0x60, 0xF4, 0x83, 0x12, 0xAA, 0xD2, + 0xC7, 0x66, 0x92, 0xE4, 0x2E, 0xE3, 0x31, 0xD9, + 0x9F, 0x48, 0xFE, 0x1A, 0x5E, 0xA3, 0xF6, 0x14, + 0x48, 0x44, 0x4F, 0x96, 0xFA, 0xE0, 0x3A, 0x5D, + 0x18, 0xE9, 0xEF, 0x76, 0xF1, 0x10, 0x01, 0x4E, + 0x3B, 0x5A, 0xD5, 0xF3, 0x5E, 0x67, 0x23, 0x81, + 0xF1, 0x76, 0xB1, 0x6A, 0x01, 0x2E, 0x01, 0x4F, + 0x64, 0x44, 0x8A, 0x04, 0x74, 0x09, 0x8E, 0xC1 + }, + { + 0x97, 0xBE, 0xF1, 0xA2, 0xE5, 0xFA, 0x75, 0x94, + 0xD3, 0xF3, 0x2F, 0x30, 0x2E, 0x07, 0x75, 0x3B, + 0x18, 0x24, 0x07, 0xC0, 0xCD, 0x9A, 0xC5, 0x35, + 0x06, 0x42, 0x41, 0xBE, 0xB8, 0xEE, 0xEC, 0xEF, + 0x42, 0xA0, 0x2C, 0xBB, 0xE1, 0xA9, 0xFF, 0xE4, + 0x7A, 0xDD, 0x4F, 0x5E, 0x56, 0x45, 0x45, 0x99, + 0x5E, 0x45, 0x1E, 0xDC, 0x97, 0x56, 0x77, 0x92, + 0xD6, 0x87, 0xD8, 0xD7, 0xB3, 0x9D, 0x3E, 0x17 + }, + { + 0x5B, 0x81, 0x22, 0x88, 0x87, 0x4F, 0x37, 0x7E, + 0x5F, 0xAD, 0x6F, 0xB7, 0x0F, 0x05, 0x06, 0x21, + 0x25, 0xF1, 0x0C, 0x8A, 0x2E, 0xBB, 0x19, 0x3C, + 0x7B, 0x8E, 0x17, 0x46, 0x7C, 0xC7, 0x1A, 0x9D, + 0x9A, 0x2D, 0x48, 0x30, 0xD5, 0x48, 0x47, 0xC4, + 0x26, 0x1F, 0x35, 0xE9, 0x4E, 0x6B, 0x97, 0xF7, + 0xE0, 0x56, 0x8D, 0x29, 0x8F, 0x4C, 0xA1, 0xC1, + 0xDD, 0x9E, 0x17, 0x1A, 0x2A, 0xEC, 0x8D, 0x5A + }, + { + 0x45, 0xAA, 0xD7, 0x13, 0xEC, 0x26, 0x3D, 0x09, + 0xCD, 0x39, 0x4B, 0x07, 0x9B, 0xF2, 0x0C, 0x54, + 0x20, 0x66, 0xE8, 0xCE, 0xB7, 0x9A, 0x4A, 0xC5, + 0xF0, 0xC0, 0x40, 0x35, 0x2B, 0x3F, 0xF0, 0xFC, + 0x39, 0x92, 0x34, 0xB8, 0x62, 0x69, 0x26, 0x33, + 0x99, 0x7B, 0xE2, 0xB4, 0x73, 0xBB, 0x8F, 0x4E, + 0x2C, 0x99, 0xAE, 0x00, 0xF6, 0xFC, 0x5D, 0x5F, + 0xDC, 0xF1, 0xC7, 0x92, 0xB3, 0xC6, 0x51, 0x34 + }, + { + 0x29, 0xF0, 0x13, 0x39, 0x42, 0x59, 0x4B, 0x28, + 0xEA, 0x19, 0x82, 0xD4, 0xC4, 0x18, 0x1B, 0x5A, + 0xB8, 0x51, 0x56, 0x89, 0xEB, 0x04, 0xD3, 0xEA, + 0x3C, 0xC2, 0xDC, 0x16, 0x4F, 0x0A, 0x77, 0x7C, + 0x37, 0x3D, 0x0B, 0x25, 0x2D, 0x82, 0x7C, 0x7C, + 0x4A, 0xBE, 0x12, 0x69, 0xB3, 0x7A, 0x1B, 0x14, + 0x9D, 0x1C, 0x1C, 0x19, 0x24, 0x97, 0x74, 0x84, + 0x3F, 0x4C, 0x53, 0x3D, 0xF6, 0x5C, 0xC2, 0x8B + }, + { + 0xE0, 0x5B, 0x00, 0xDD, 0xC3, 0x23, 0x69, 0x9E, + 0x50, 0xBA, 0xE7, 0xE1, 0x69, 0xCD, 0xBC, 0x9E, + 0x09, 0x82, 0x0B, 0x4D, 0x01, 0x1D, 0x4B, 0xC5, + 0x7C, 0x15, 0x34, 0xF1, 0x53, 0x82, 0x13, 0x96, + 0x1B, 0x77, 0x4E, 0x43, 0xD6, 0x28, 0x84, 0xA9, + 0xCE, 0x94, 0xCE, 0xCD, 0xB4, 0xF8, 0x26, 0x4D, + 0x75, 0x96, 0xD6, 0xEF, 0xCD, 0xB8, 0x57, 0x0B, + 0x0D, 0x3D, 0xB6, 0x91, 0x2D, 0x5D, 0x9F, 0x24 + }, + { + 0xEC, 0xBB, 0x0F, 0x66, 0xED, 0xC5, 0xAE, 0x8D, + 0x08, 0xBD, 0x69, 0xD1, 0x00, 0x85, 0xD8, 0xDC, + 0x70, 0x8C, 0x9F, 0x89, 0x55, 0x95, 0x60, 0xF2, + 0xBE, 0x39, 0x2E, 0xFE, 0x37, 0xDE, 0xF0, 0x28, + 0xD4, 0x97, 0xE8, 0x53, 0x06, 0x3B, 0x47, 0x39, + 0xAD, 0x7C, 0x90, 0x93, 0xD1, 0x88, 0xC7, 0x57, + 0x43, 0xE0, 0xEF, 0x23, 0xDC, 0xAC, 0xB9, 0xA4, + 0xA0, 0x29, 0xD3, 0x25, 0xE4, 0x80, 0x25, 0xCE + }, + { + 0xDD, 0xB0, 0x85, 0x10, 0x05, 0x2A, 0x74, 0x5E, + 0x8E, 0x49, 0xA6, 0xA4, 0x1F, 0xBC, 0xF2, 0x15, + 0xCF, 0xD7, 0x5A, 0xFD, 0xE6, 0x02, 0x28, 0x2E, + 0x8F, 0xC1, 0xAF, 0xB6, 0x91, 0xFB, 0x0F, 0xE1, + 0xC0, 0x52, 0x34, 0x98, 0x4D, 0xEA, 0xF7, 0x4C, + 0x92, 0x06, 0xE6, 0x47, 0x10, 0xCB, 0x2E, 0x82, + 0x8B, 0xAD, 0x9B, 0x90, 0xD3, 0x90, 0x6B, 0xB9, + 0x42, 0x12, 0x57, 0xFC, 0x54, 0x3B, 0x76, 0x75 + }, + { + 0xC5, 0x55, 0x66, 0x2A, 0x6C, 0xD8, 0x33, 0xCC, + 0x87, 0x9A, 0xAA, 0x54, 0xF2, 0x0F, 0xFE, 0xDE, + 0x0D, 0x1E, 0x03, 0xC6, 0xE0, 0x1D, 0x8D, 0xE5, + 0xB7, 0x23, 0x22, 0xB0, 0x5C, 0x20, 0x2C, 0x4E, + 0xC6, 0xD6, 0x3F, 0x7F, 0x9E, 0xC9, 0x07, 0xA7, + 0x4C, 0x16, 0x20, 0x0A, 0xAA, 0x36, 0x72, 0x4E, + 0xA5, 0x45, 0x4D, 0xE7, 0x4B, 0x06, 0x0B, 0x7A, + 0x33, 0xC4, 0x4A, 0xAE, 0xA2, 0x0C, 0x79, 0x98 + }, + { + 0x96, 0x7F, 0x12, 0x31, 0xFA, 0x53, 0x5F, 0x34, + 0x74, 0xB6, 0xB1, 0x7F, 0xD8, 0xF2, 0xE5, 0x63, + 0x25, 0xD2, 0x71, 0x0D, 0x49, 0x3A, 0x7F, 0x7C, + 0x12, 0x2F, 0x90, 0x54, 0xE1, 0x38, 0xD7, 0x06, + 0xF2, 0xCF, 0xD1, 0x46, 0x7A, 0x7F, 0x2F, 0x71, + 0xC8, 0x53, 0x55, 0x6A, 0xD6, 0xFE, 0x7B, 0xD0, + 0x6C, 0x44, 0xC0, 0x8B, 0x3C, 0x74, 0x17, 0x59, + 0x52, 0x39, 0xE4, 0x5C, 0x78, 0xBD, 0x06, 0xBB + }, + { + 0x4A, 0x16, 0xD8, 0x33, 0xEE, 0x7A, 0x4F, 0x75, + 0xC3, 0x25, 0x13, 0xCC, 0x55, 0x06, 0x42, 0x6F, + 0x56, 0xEC, 0xF6, 0xE1, 0x95, 0xA9, 0x99, 0xAC, + 0xF9, 0x68, 0x13, 0xEA, 0xB2, 0xDE, 0xFF, 0x41, + 0x34, 0x76, 0xB7, 0xE1, 0x43, 0x29, 0xBC, 0x2C, + 0x8B, 0xFD, 0xC5, 0x69, 0x61, 0xCB, 0xB4, 0xB1, + 0x02, 0xAA, 0x3A, 0x18, 0xEA, 0xFF, 0x75, 0x9C, + 0xE7, 0xC9, 0x81, 0x34, 0x5B, 0x64, 0x2A, 0xC5 + }, + { + 0xC8, 0xBA, 0xCD, 0x6B, 0x5D, 0xE0, 0xC1, 0x6A, + 0xA4, 0xBE, 0x39, 0x76, 0xF5, 0x46, 0xE9, 0xD8, + 0xA2, 0x97, 0xDB, 0x3A, 0xFF, 0xF6, 0xB6, 0x00, + 0xBD, 0x5D, 0x89, 0x0F, 0x6C, 0xE1, 0xDA, 0xBA, + 0x4C, 0x6F, 0x39, 0xD2, 0xD4, 0xE3, 0x54, 0xBB, + 0xA3, 0x56, 0x1E, 0xDA, 0x94, 0x8C, 0xB8, 0x82, + 0x20, 0xB3, 0x1F, 0x48, 0x2F, 0xA9, 0xA1, 0x11, + 0xFD, 0x64, 0x34, 0x83, 0xF0, 0xBE, 0xD6, 0x30 + }, + { + 0x6C, 0xAC, 0x99, 0x4A, 0x45, 0x22, 0xA9, 0xFB, + 0x6D, 0x0D, 0xA9, 0xEF, 0x69, 0x42, 0x29, 0x77, + 0xB5, 0xC8, 0x7E, 0x30, 0xA6, 0xA9, 0x25, 0x29, + 0x03, 0xAE, 0xBB, 0x5D, 0x76, 0x29, 0xAE, 0x7E, + 0x15, 0xD0, 0xFC, 0x0B, 0x55, 0x85, 0x97, 0x43, + 0x19, 0xA0, 0x9F, 0x33, 0x4D, 0x61, 0x0D, 0xB9, + 0x4D, 0xFC, 0xFD, 0xEB, 0x90, 0x74, 0x9E, 0x44, + 0x6F, 0xEA, 0x68, 0x24, 0xBF, 0xCC, 0x78, 0x5F + }, + { + 0x9A, 0xA9, 0x4C, 0xD4, 0x7C, 0xBC, 0xD5, 0x9E, + 0x4E, 0xE4, 0x14, 0x4B, 0xD5, 0x77, 0xC7, 0xAD, + 0xF6, 0x74, 0xE4, 0x6F, 0xE2, 0xDE, 0xC5, 0x1F, + 0x1B, 0x98, 0x85, 0x26, 0x89, 0xFE, 0x64, 0xAB, + 0xFB, 0xA2, 0x18, 0x6D, 0xB8, 0x8C, 0x95, 0xAD, + 0x11, 0xBD, 0xEA, 0x75, 0xD9, 0xBA, 0x60, 0xE2, + 0x4C, 0xE4, 0x76, 0x2E, 0x8B, 0x73, 0x84, 0xEF, + 0xF0, 0xBA, 0x3B, 0xD7, 0x37, 0x53, 0x1C, 0x30 + }, + { + 0xED, 0x3F, 0xF6, 0x14, 0xB6, 0x8D, 0x4D, 0x05, + 0x9C, 0x28, 0x5B, 0x7D, 0x3A, 0x13, 0x80, 0xE9, + 0x54, 0x64, 0x74, 0x06, 0xC3, 0x2C, 0x28, 0x97, + 0xB7, 0x6D, 0x0F, 0x11, 0x8A, 0xEB, 0xCC, 0x2C, + 0x56, 0xBD, 0x66, 0xB7, 0x15, 0xAB, 0x47, 0x46, + 0x18, 0xEA, 0x24, 0x6B, 0x01, 0x31, 0x5F, 0xCB, + 0xCB, 0x7B, 0x32, 0x80, 0x60, 0x23, 0x53, 0xA8, + 0x71, 0xC1, 0xA2, 0xBF, 0x10, 0x1F, 0x5B, 0xBC + }, + { + 0xD9, 0x42, 0x5E, 0xB9, 0xA4, 0x27, 0xE1, 0xF0, + 0xD6, 0xB5, 0xF0, 0xAC, 0xCB, 0xFF, 0x3F, 0x71, + 0xD8, 0x72, 0x46, 0x74, 0x20, 0x2F, 0x7B, 0xE9, + 0x95, 0x1F, 0x06, 0xDF, 0x15, 0xAA, 0x5F, 0x86, + 0xEA, 0x3F, 0x8C, 0xBE, 0xFF, 0x36, 0x14, 0x51, + 0x80, 0xEE, 0x60, 0x14, 0x20, 0x05, 0xFE, 0x79, + 0x25, 0xE0, 0xDC, 0x89, 0x64, 0xB7, 0x99, 0x35, + 0xE3, 0x2E, 0x20, 0xF2, 0x68, 0x5F, 0xC7, 0x27 + }, + { + 0x0E, 0x77, 0x0D, 0x45, 0x78, 0x72, 0xE7, 0xF6, + 0xCA, 0x93, 0xD9, 0x17, 0x75, 0x29, 0xD0, 0x72, + 0x35, 0xDD, 0x6A, 0xFB, 0x82, 0xAC, 0x6E, 0x29, + 0x74, 0xBD, 0x13, 0x11, 0x42, 0x37, 0x64, 0x39, + 0xD6, 0xCE, 0xFB, 0x2D, 0x23, 0xA7, 0xDE, 0x3E, + 0x23, 0xA4, 0x1E, 0x3D, 0x2C, 0xF7, 0x6D, 0xCA, + 0xEC, 0x02, 0xE2, 0xB0, 0xF3, 0x00, 0x17, 0xFB, + 0x25, 0x6C, 0xA3, 0x68, 0xAE, 0xF8, 0xDD, 0x3E + }, + { + 0xB1, 0xDF, 0xB3, 0x38, 0x96, 0xE3, 0xFE, 0x38, + 0x00, 0x44, 0xB9, 0x13, 0x22, 0x6F, 0x68, 0xCE, + 0x28, 0x97, 0x59, 0x7A, 0x51, 0x71, 0x91, 0x61, + 0x4C, 0xF9, 0x88, 0xC9, 0x10, 0x7A, 0xFE, 0x42, + 0xD7, 0x27, 0x4E, 0xC1, 0xBF, 0x87, 0x23, 0xEB, + 0xEB, 0x50, 0x83, 0x5D, 0x4F, 0x67, 0x85, 0xDD, + 0xA3, 0xA0, 0xA0, 0x36, 0xB3, 0x55, 0x0C, 0x36, + 0x24, 0x45, 0x82, 0xE6, 0xE5, 0xE9, 0xDF, 0xFE + }, + { + 0x79, 0x6A, 0x15, 0x63, 0x29, 0xAC, 0x6B, 0x5A, + 0x02, 0xD6, 0x55, 0x71, 0x0E, 0x05, 0x3D, 0xB1, + 0xAC, 0x77, 0xA7, 0xCE, 0x43, 0xF8, 0x47, 0x31, + 0x62, 0x19, 0x26, 0xB0, 0x7A, 0x93, 0xCB, 0xF8, + 0x8F, 0xB2, 0x60, 0xB3, 0x68, 0x80, 0x8B, 0xA8, + 0x79, 0x15, 0x40, 0x4D, 0x7B, 0x2D, 0x4D, 0x1C, + 0xD7, 0x2A, 0xAC, 0x03, 0x05, 0x4B, 0xD0, 0xB7, + 0x3F, 0xE7, 0x81, 0x08, 0xB7, 0xAA, 0x3D, 0x2D + }, + { + 0x35, 0x2B, 0xA1, 0xE0, 0xD8, 0xD8, 0x75, 0x68, + 0x4F, 0xA9, 0x5E, 0xD7, 0x33, 0x04, 0x69, 0xA8, + 0x31, 0x71, 0xB1, 0x9B, 0xBD, 0x97, 0xAF, 0xB7, + 0x32, 0x1B, 0xFE, 0xAA, 0x50, 0x7F, 0x8C, 0x0A, + 0xAF, 0xE4, 0x1C, 0xCE, 0xEC, 0xF9, 0xD8, 0xD3, + 0xD9, 0xE3, 0xAC, 0x1F, 0x6A, 0xC1, 0x7B, 0x78, + 0x38, 0x83, 0xBB, 0x4D, 0xE8, 0x33, 0xC3, 0x06, + 0xD9, 0x26, 0xC3, 0xD4, 0x34, 0x5C, 0x4C, 0x9E + }, + { + 0x57, 0x9C, 0x5E, 0x59, 0x34, 0x5D, 0x2B, 0x56, + 0xEF, 0x17, 0x85, 0x46, 0x2D, 0x3F, 0x79, 0x11, + 0x56, 0x6D, 0xA1, 0x32, 0xDF, 0xDF, 0xC2, 0x0F, + 0x3C, 0xEF, 0x55, 0x83, 0xFE, 0xB2, 0x11, 0x91, + 0xA3, 0xB3, 0x4C, 0xBB, 0xEC, 0x64, 0x6F, 0x8C, + 0x15, 0x52, 0xF2, 0x5F, 0x76, 0x80, 0xCB, 0x50, + 0x81, 0xA1, 0xA1, 0xE4, 0xFD, 0xC2, 0xC9, 0xCD, + 0x5A, 0x69, 0xA2, 0x12, 0xB9, 0xFD, 0x41, 0x87 + }, + { + 0x06, 0xA3, 0x9E, 0x37, 0xF0, 0xC8, 0x83, 0x9B, + 0xA7, 0x5D, 0xD9, 0xC8, 0xEB, 0x80, 0x9E, 0x3D, + 0x48, 0x5A, 0xED, 0x7A, 0x3E, 0x21, 0xD8, 0x01, + 0x01, 0xC2, 0xBA, 0x6C, 0xB0, 0x63, 0x68, 0xD0, + 0xE5, 0x3A, 0x04, 0x3D, 0x90, 0x0C, 0x9E, 0x8C, + 0x0A, 0x85, 0xB1, 0xEC, 0x09, 0xB9, 0xAA, 0xC5, + 0x8C, 0xC1, 0x51, 0x93, 0x33, 0xE8, 0xF3, 0x35, + 0x66, 0x8B, 0xA7, 0xB4, 0x72, 0xB5, 0x24, 0xF7 + }, + { + 0x9E, 0xC8, 0xF8, 0x02, 0x15, 0xD5, 0xB9, 0x1C, + 0x0D, 0x04, 0xA7, 0xEF, 0x91, 0x25, 0x6C, 0x87, + 0x48, 0x2A, 0xCD, 0x5B, 0xC4, 0xE3, 0x6D, 0x81, + 0xC9, 0x93, 0xDC, 0x44, 0x2E, 0xE6, 0x8D, 0x47, + 0x5A, 0x58, 0x98, 0xFC, 0xEC, 0xA8, 0x28, 0xFC, + 0x08, 0xD3, 0x7A, 0x8A, 0x3D, 0xE7, 0x4D, 0x9E, + 0x45, 0x0E, 0xC1, 0xD8, 0x22, 0x16, 0xCC, 0xA4, + 0xC4, 0x6B, 0xF3, 0xB1, 0x0D, 0x68, 0x61, 0xDD + }, + { + 0x1C, 0x22, 0xDF, 0xE0, 0x6C, 0xD7, 0xD9, 0xAB, + 0x10, 0x45, 0xD4, 0xF8, 0x14, 0xB6, 0xEF, 0x37, + 0x39, 0xBF, 0xF9, 0x22, 0xFE, 0x5F, 0x18, 0x7B, + 0xD3, 0x5F, 0xD0, 0x23, 0x08, 0x14, 0xFA, 0x3B, + 0x80, 0x02, 0x71, 0x7E, 0x89, 0x1A, 0x37, 0x72, + 0xD3, 0x59, 0x74, 0xEA, 0xC0, 0xE5, 0xCF, 0x35, + 0xE0, 0xC3, 0xF7, 0xD5, 0xB2, 0x1A, 0xA9, 0x9B, + 0x9D, 0x4C, 0xF3, 0xE1, 0x73, 0xC1, 0x87, 0xF2 + }, + { + 0x2A, 0x1B, 0x2C, 0xA4, 0xEC, 0x59, 0x35, 0xAC, + 0x3A, 0xB0, 0xFE, 0x3C, 0x15, 0xEF, 0xBC, 0xF3, + 0x41, 0xAA, 0x19, 0xA4, 0x21, 0xAB, 0x0B, 0x30, + 0x04, 0xDA, 0x14, 0x4F, 0x4D, 0x9B, 0xB0, 0xC3, + 0x93, 0x1E, 0xB4, 0xE0, 0x18, 0xB6, 0x66, 0x2D, + 0xCA, 0xB5, 0xDB, 0xDC, 0xC0, 0x04, 0xE7, 0xB2, + 0x02, 0xF7, 0x35, 0x24, 0xD5, 0x55, 0xE0, 0x01, + 0x09, 0x91, 0x06, 0x85, 0xBA, 0x6F, 0x72, 0x16 + }, + { + 0xBC, 0xBC, 0x51, 0xD7, 0x68, 0xD2, 0x71, 0xC1, + 0x17, 0xFB, 0xBD, 0x0A, 0xB1, 0xC4, 0x9A, 0xA9, + 0xDA, 0xD0, 0x1D, 0x46, 0x1C, 0xD6, 0x4B, 0x49, + 0xE4, 0x2D, 0x54, 0x0C, 0xE3, 0x3E, 0x31, 0x57, + 0xE2, 0x2F, 0x10, 0x91, 0x06, 0x2B, 0xD3, 0x47, + 0x07, 0x26, 0x8E, 0xA7, 0xB5, 0x9B, 0xC8, 0x85, + 0x86, 0x2F, 0x2D, 0xA1, 0x7F, 0x3F, 0x71, 0xA2, + 0x51, 0x58, 0xAC, 0x57, 0x76, 0xEC, 0x87, 0x49 + }, + { + 0x5A, 0xC7, 0x40, 0xF2, 0xC6, 0xC1, 0xD3, 0x01, + 0x50, 0xB9, 0x89, 0xDB, 0x1A, 0xD0, 0xF0, 0xD3, + 0x64, 0xCD, 0x6E, 0x9C, 0x9A, 0x4C, 0xE4, 0x49, + 0x2A, 0x39, 0x71, 0x06, 0x1C, 0x00, 0xB2, 0x18, + 0x6E, 0xBE, 0x87, 0xD8, 0x53, 0x25, 0xB1, 0x16, + 0x9F, 0xBD, 0x80, 0x86, 0x62, 0xC3, 0xED, 0x39, + 0xB5, 0x1C, 0x49, 0x57, 0xA4, 0xB1, 0x0F, 0xD9, + 0xC9, 0xE7, 0x1C, 0x55, 0xD3, 0x7E, 0xEC, 0xCB + }, + { + 0xD6, 0x15, 0x59, 0x7D, 0x2C, 0xC6, 0x8E, 0x46, + 0x17, 0x0B, 0x49, 0x57, 0xA5, 0x6A, 0x8D, 0xB6, + 0x4D, 0xC7, 0x97, 0x67, 0xC9, 0x7C, 0x93, 0xD2, + 0x9F, 0x82, 0x08, 0x52, 0xE1, 0xD6, 0x07, 0x0D, + 0x6A, 0x4A, 0x01, 0xCE, 0xBB, 0x67, 0x68, 0x97, + 0x34, 0x0B, 0xAF, 0xFB, 0x6D, 0x2C, 0x85, 0x3B, + 0xA6, 0x16, 0xA2, 0x51, 0xFB, 0x20, 0x08, 0x79, + 0x23, 0x21, 0x54, 0x32, 0x28, 0x0C, 0x29, 0xEA + }, + { + 0xB9, 0x8C, 0x90, 0xD4, 0x06, 0xA6, 0xFB, 0xBB, + 0x15, 0x11, 0xF2, 0xEA, 0x7A, 0x65, 0xA0, 0x3E, + 0x61, 0xEB, 0x09, 0x20, 0x21, 0xE0, 0x02, 0xE2, + 0x79, 0xFD, 0x4C, 0x94, 0x69, 0x5C, 0x3C, 0xE8, + 0xF1, 0xB2, 0x12, 0xA3, 0x3F, 0x48, 0x70, 0x41, + 0x51, 0xE5, 0x68, 0xB8, 0x8D, 0x2D, 0x95, 0x3F, + 0x35, 0x27, 0x6E, 0xC8, 0x3D, 0x8E, 0x4F, 0x78, + 0xE1, 0x64, 0x77, 0x23, 0xEC, 0xBF, 0x5C, 0x61 + }, + { + 0x52, 0x4B, 0x12, 0x5C, 0x7F, 0x9E, 0x8F, 0x13, + 0x04, 0x9B, 0xCD, 0xE7, 0x11, 0x1C, 0xB5, 0xFA, + 0x6A, 0x4E, 0x1D, 0xE0, 0xD6, 0xB1, 0xC3, 0x1B, + 0x16, 0xBC, 0xF3, 0xAE, 0x32, 0x43, 0x59, 0x9D, + 0x0D, 0x78, 0xFC, 0x15, 0x10, 0x98, 0xCA, 0x2E, + 0x73, 0x4A, 0x47, 0xAA, 0x98, 0x15, 0x7C, 0x61, + 0xB6, 0xCF, 0xD0, 0x2E, 0xDE, 0x62, 0x11, 0xE8, + 0x99, 0x2D, 0x6F, 0x6A, 0xDC, 0x60, 0x01, 0xD8 + }, + { + 0x7D, 0xC0, 0xF1, 0x40, 0x7E, 0x34, 0xA2, 0xC7, + 0x04, 0x85, 0x21, 0x56, 0x2B, 0x33, 0x65, 0x37, + 0x15, 0xA2, 0x39, 0xFD, 0x91, 0x8C, 0xB1, 0xBF, + 0xBF, 0xD6, 0x99, 0x84, 0xFE, 0x7A, 0x29, 0xF4, + 0xBC, 0xD3, 0x19, 0xDB, 0x89, 0xE8, 0x26, 0xEC, + 0xDB, 0x05, 0x7B, 0x2F, 0xEA, 0x4C, 0x6E, 0x8D, + 0xEA, 0x91, 0x51, 0x6E, 0x16, 0x00, 0x77, 0xDB, + 0xC0, 0x83, 0x43, 0xFD, 0x53, 0xDD, 0x31, 0x07 + }, + { + 0x70, 0xF9, 0x76, 0x74, 0xF3, 0x84, 0x90, 0x82, + 0x51, 0x50, 0xC2, 0x23, 0x25, 0x0D, 0x8A, 0x6C, + 0x5F, 0x2A, 0x54, 0x4D, 0x2C, 0xD4, 0x3A, 0x5D, + 0xCE, 0x92, 0xB4, 0xB5, 0x8A, 0xB2, 0x66, 0x12, + 0xAB, 0xC6, 0x4C, 0x3C, 0x17, 0xC8, 0x47, 0xF6, + 0x54, 0x9B, 0x17, 0x9D, 0xAF, 0x2E, 0x46, 0x2A, + 0x59, 0x43, 0xEE, 0x44, 0x22, 0x40, 0x56, 0x89, + 0x55, 0x45, 0x4A, 0x94, 0x44, 0x11, 0xEB, 0x7F + }, + { + 0x06, 0xC5, 0x54, 0xEE, 0xC3, 0x61, 0x08, 0x29, + 0x03, 0x2F, 0x9F, 0x0C, 0x3E, 0xF2, 0x6D, 0x5D, + 0x66, 0xC9, 0x70, 0xC9, 0x69, 0xDC, 0xFD, 0xC7, + 0x99, 0x66, 0x76, 0x11, 0x4B, 0x99, 0x7C, 0x62, + 0x80, 0xE0, 0xB5, 0x8F, 0x99, 0x7C, 0x12, 0xDF, + 0x57, 0x84, 0x7B, 0xF4, 0x89, 0xC1, 0x37, 0xB1, + 0x97, 0xDC, 0xB6, 0x46, 0xF0, 0xD4, 0x34, 0x4B, + 0x2A, 0x20, 0xB4, 0x6D, 0xFA, 0xE5, 0xFE, 0x60 + }, + { + 0x0C, 0x67, 0x4B, 0x3A, 0x20, 0x83, 0x6D, 0x82, + 0x07, 0x58, 0x5A, 0xFC, 0x92, 0x31, 0x0B, 0xDD, + 0x99, 0xCD, 0x4A, 0xE1, 0x03, 0xE0, 0xA2, 0x2C, + 0x85, 0x0B, 0x68, 0x94, 0x22, 0xDB, 0xF3, 0xB6, + 0xEC, 0xCF, 0xA4, 0x19, 0xF8, 0x7D, 0x4C, 0x2B, + 0x20, 0x69, 0xD6, 0x90, 0x0D, 0xEE, 0x54, 0xE7, + 0x16, 0x57, 0xD8, 0xFC, 0xF2, 0xDD, 0x73, 0x25, + 0xA3, 0xF6, 0xFB, 0x4E, 0x04, 0x9E, 0x7A, 0x2A + }, + { + 0xA7, 0x4A, 0xB0, 0x6A, 0x75, 0xB8, 0x49, 0xB1, + 0x19, 0xB6, 0x42, 0x65, 0xD0, 0x9B, 0xB8, 0x1E, + 0xEB, 0x99, 0xF8, 0xF6, 0x3D, 0x34, 0x25, 0xD2, + 0x79, 0x6F, 0xA4, 0xE4, 0xA1, 0x0A, 0x0E, 0x29, + 0x33, 0xD2, 0x60, 0xCD, 0xF2, 0x4F, 0xFF, 0x36, + 0x03, 0x99, 0x41, 0x22, 0xCF, 0xBE, 0x24, 0x62, + 0xAA, 0x54, 0x13, 0x7A, 0xB5, 0x9F, 0xD3, 0x92, + 0x6A, 0x0E, 0x86, 0x96, 0xD0, 0x6E, 0xBE, 0xEB + }, + { + 0xB6, 0x0B, 0x79, 0x48, 0xB2, 0xFB, 0x3D, 0xCF, + 0x55, 0x52, 0x04, 0xDD, 0x1C, 0x2E, 0xA4, 0x6D, + 0xA4, 0x82, 0x19, 0xB2, 0xED, 0xC6, 0x77, 0x6B, + 0xA0, 0x3B, 0xB6, 0xD3, 0xCB, 0xFC, 0x44, 0xC5, + 0x6B, 0x75, 0xF4, 0x21, 0x27, 0x9A, 0xAF, 0x1C, + 0xE7, 0x99, 0x87, 0xF0, 0xF0, 0x1A, 0xB8, 0x8E, + 0xF3, 0x21, 0x72, 0x58, 0xB5, 0xD3, 0x63, 0xA0, + 0x9F, 0x5B, 0xD2, 0xAB, 0x93, 0x29, 0xBB, 0x75 + }, + { + 0xB1, 0x1F, 0x71, 0xCE, 0x44, 0xAD, 0x51, 0x1D, + 0x24, 0x99, 0x4D, 0x82, 0x06, 0x7F, 0x81, 0x66, + 0x28, 0x19, 0x4F, 0xDF, 0xDB, 0x78, 0xEB, 0xAB, + 0x1E, 0x04, 0x7A, 0xC6, 0x66, 0x19, 0x5B, 0xC5, + 0xAA, 0xC2, 0xF7, 0x96, 0xF3, 0x22, 0x54, 0x75, + 0x93, 0x73, 0x0F, 0xF3, 0x08, 0x2B, 0xE2, 0x26, + 0x57, 0xAE, 0xB5, 0x8F, 0xB0, 0x46, 0xA7, 0x7E, + 0xD3, 0xCC, 0x21, 0xEE, 0xC6, 0xB9, 0xB3, 0xD6 + }, + { + 0xC2, 0x02, 0xA6, 0x18, 0x63, 0x58, 0x52, 0xFD, + 0x4C, 0x24, 0x51, 0x48, 0x6D, 0x6B, 0x8D, 0x81, + 0x70, 0x04, 0xE8, 0x0C, 0xEE, 0x0F, 0x55, 0x3B, + 0x1C, 0xD6, 0x42, 0x65, 0x06, 0x3A, 0x1A, 0x22, + 0x26, 0xB1, 0x3C, 0x02, 0x2E, 0x43, 0x7F, 0x31, + 0x54, 0x03, 0x87, 0xB0, 0x92, 0x32, 0xAE, 0x52, + 0x9E, 0xD6, 0x05, 0x2D, 0x3A, 0xF7, 0x79, 0x71, + 0x21, 0x1F, 0x74, 0xD9, 0xB8, 0xD6, 0x40, 0xFB + }, + { + 0x02, 0xDC, 0x77, 0xBB, 0x43, 0xCD, 0x98, 0x22, + 0xA2, 0xF9, 0xE2, 0x9F, 0x9B, 0x46, 0x89, 0x29, + 0x7A, 0x52, 0x5E, 0x19, 0xC7, 0x1B, 0xB7, 0x59, + 0xAF, 0x5A, 0x1A, 0x07, 0x99, 0xF7, 0x58, 0xE8, + 0xFF, 0xC8, 0x03, 0xA1, 0xAA, 0xAB, 0xFD, 0xD9, + 0xF6, 0x5C, 0x33, 0x8A, 0xC5, 0x81, 0xD2, 0x71, + 0x1E, 0x06, 0xDD, 0x3C, 0x2B, 0xF7, 0xE9, 0x55, + 0x34, 0xC1, 0x8E, 0xCD, 0xA7, 0x3E, 0xAA, 0x35 + }, + { + 0x56, 0x55, 0x63, 0x2E, 0xBA, 0x55, 0xCB, 0xE1, + 0x2D, 0xC9, 0xAD, 0xA4, 0xFE, 0x8C, 0xB0, 0xAD, + 0x1A, 0x20, 0x65, 0x05, 0x0E, 0x81, 0x7A, 0xF5, + 0xC6, 0x9C, 0xB7, 0xCF, 0x42, 0x82, 0xD4, 0x6F, + 0x85, 0x2F, 0x62, 0xE4, 0xF8, 0x6B, 0xCA, 0xEA, + 0xFF, 0x25, 0x40, 0x91, 0x94, 0xFE, 0x2C, 0xB8, + 0x0B, 0x1E, 0xDD, 0x10, 0xCA, 0x2C, 0x96, 0xE2, + 0x15, 0x3F, 0x3D, 0xF0, 0x21, 0x38, 0x4E, 0x2D + }, + { + 0x29, 0x40, 0x63, 0xCB, 0xC4, 0x49, 0x41, 0xDA, + 0x33, 0x39, 0x2E, 0x36, 0x1E, 0xA8, 0x39, 0x6D, + 0x0C, 0x25, 0xE9, 0xC8, 0xDD, 0xB3, 0x22, 0xF7, + 0x12, 0x01, 0x31, 0x21, 0xF9, 0xF6, 0x41, 0xAC, + 0x9E, 0x96, 0xC2, 0x91, 0xA8, 0x13, 0x13, 0x63, + 0x58, 0x37, 0xCC, 0x27, 0x53, 0x1C, 0xE2, 0xE9, + 0x72, 0xA4, 0x59, 0x0C, 0x43, 0x82, 0xBC, 0x40, + 0xF2, 0x64, 0xEC, 0xD5, 0x8D, 0x89, 0xE8, 0xB1 + }, + { + 0xEF, 0xE3, 0x49, 0xD2, 0x72, 0x1B, 0x08, 0x44, + 0x59, 0xFA, 0xE1, 0xEA, 0x6A, 0x72, 0x0A, 0xE7, + 0x25, 0xE6, 0xED, 0x03, 0xDA, 0xEF, 0xED, 0xA0, + 0x63, 0xDF, 0xCD, 0x6A, 0xF4, 0x07, 0x3C, 0x7C, + 0xD0, 0x3B, 0x94, 0x60, 0x3F, 0x5B, 0x01, 0xFA, + 0xE8, 0x92, 0xAB, 0xBB, 0xF6, 0x2D, 0xA9, 0x2F, + 0x36, 0xD9, 0xA3, 0x4C, 0x71, 0xD6, 0x23, 0x10, + 0xC3, 0xFF, 0xAB, 0xBE, 0xDE, 0xCD, 0xD5, 0xEE + }, + { + 0x52, 0x71, 0x0D, 0xDC, 0xE0, 0x47, 0xC7, 0x8C, + 0x01, 0x99, 0x42, 0xD6, 0x78, 0x63, 0xD9, 0x37, + 0x19, 0xED, 0xA9, 0xB8, 0xD3, 0xAA, 0xA3, 0xFB, + 0xAC, 0x1C, 0xD3, 0x56, 0x81, 0x06, 0x6A, 0x09, + 0x26, 0x11, 0x4F, 0xDF, 0xF7, 0x2C, 0x3E, 0x8C, + 0x08, 0x57, 0x43, 0x96, 0x33, 0x9E, 0x57, 0x25, + 0xE2, 0x82, 0x12, 0xF9, 0x29, 0xEE, 0xDC, 0x54, + 0x08, 0x4A, 0xA8, 0x20, 0xD2, 0x56, 0x63, 0x7F + }, + { + 0x54, 0xBB, 0x00, 0x52, 0x85, 0x2F, 0xA1, 0x15, + 0xC9, 0x7F, 0x71, 0x92, 0x6B, 0x43, 0x87, 0xF4, + 0xEB, 0xA4, 0xB5, 0x53, 0xC5, 0x52, 0x7D, 0x24, + 0xB9, 0x90, 0xEE, 0x4A, 0xA1, 0xD2, 0x44, 0x68, + 0xC5, 0x20, 0x0F, 0x5F, 0xA2, 0x88, 0x07, 0x5E, + 0x32, 0x08, 0x88, 0xC4, 0x73, 0xB7, 0xB6, 0xBB, + 0x10, 0x7D, 0x19, 0x14, 0x47, 0x6E, 0x90, 0xA5, + 0x20, 0x46, 0x41, 0x84, 0x9B, 0x5E, 0xAA, 0x64 + }, + { + 0x22, 0xBD, 0x46, 0x1B, 0xD9, 0x73, 0xEC, 0xAD, + 0x4D, 0x2F, 0x44, 0xCE, 0x1E, 0xB9, 0x15, 0xAC, + 0x41, 0x90, 0x7A, 0xAC, 0x42, 0xFB, 0xEE, 0xD8, + 0x0E, 0xA4, 0xF5, 0xF4, 0xF6, 0xED, 0x2E, 0x26, + 0x53, 0x07, 0xDD, 0x3A, 0xF6, 0x48, 0x14, 0x5C, + 0xA1, 0xF8, 0x43, 0xCD, 0x09, 0x49, 0x1D, 0x96, + 0x1F, 0x18, 0x5E, 0x97, 0xF5, 0xA7, 0x68, 0x2B, + 0x7C, 0x14, 0xB5, 0xB5, 0x18, 0x9A, 0x0F, 0xE2 + }, + { + 0x7D, 0x8B, 0x08, 0xF8, 0xB3, 0x04, 0x45, 0xBB, + 0xA9, 0x35, 0x61, 0x55, 0x17, 0xEE, 0x7A, 0x9B, + 0xD1, 0xA3, 0x7D, 0x55, 0x3B, 0x00, 0x01, 0x2D, + 0xC9, 0x5A, 0xD3, 0xF7, 0xFB, 0x32, 0x9A, 0x9A, + 0xC8, 0xDC, 0x83, 0x54, 0xD2, 0xEB, 0x27, 0x42, + 0xD1, 0xA1, 0xF4, 0xEC, 0xDD, 0xEE, 0xA3, 0xF9, + 0xCF, 0x21, 0x54, 0xDD, 0xDB, 0xC9, 0xDC, 0x38, + 0xA3, 0x70, 0x64, 0x92, 0x70, 0x95, 0x87, 0xA5 + }, + { + 0xC2, 0x46, 0xAB, 0xFF, 0xAD, 0xF7, 0xEA, 0xE7, + 0xBE, 0xAA, 0x9D, 0x07, 0x3C, 0x80, 0x02, 0x50, + 0x20, 0xEB, 0xCC, 0x6C, 0x3D, 0x15, 0x69, 0x00, + 0xD5, 0x9C, 0x93, 0x8B, 0x2E, 0xA4, 0x49, 0xF4, + 0x6D, 0x41, 0xD7, 0xED, 0xC3, 0x99, 0xCA, 0x07, + 0x36, 0x2E, 0xC5, 0xE1, 0x08, 0x8C, 0x66, 0x81, + 0x64, 0x96, 0xD2, 0x25, 0x87, 0xDE, 0x79, 0x90, + 0x25, 0xC2, 0xCD, 0xDB, 0xBF, 0x88, 0xD7, 0x82 + }, + { + 0xBF, 0xF8, 0xBA, 0x64, 0x12, 0x60, 0xF7, 0x86, + 0xE9, 0x0E, 0xFB, 0x47, 0x22, 0xDB, 0xB3, 0x65, + 0xEB, 0x21, 0x77, 0x02, 0x31, 0x4C, 0x42, 0xC8, + 0x4F, 0xDD, 0x5C, 0x0F, 0x86, 0xB1, 0xF1, 0x97, + 0x77, 0x5F, 0xEF, 0xD8, 0x8C, 0x56, 0x9F, 0xA5, + 0x16, 0x56, 0x92, 0x91, 0x2A, 0x42, 0xAC, 0x41, + 0xBB, 0xFE, 0xB4, 0xC4, 0xF5, 0x23, 0xA3, 0x45, + 0x9A, 0xF2, 0xAA, 0xDC, 0x41, 0x2B, 0x6C, 0xAC + }, + { + 0x36, 0x17, 0x52, 0xCE, 0x90, 0xBF, 0x91, 0xDF, + 0xD3, 0xC3, 0x38, 0x1A, 0xEA, 0x0C, 0x77, 0x5F, + 0xA3, 0xDB, 0xB4, 0x09, 0x1B, 0x28, 0xBF, 0x48, + 0x52, 0x5E, 0xCA, 0xC7, 0xBC, 0xFD, 0xE6, 0xF2, + 0x98, 0x45, 0x67, 0x04, 0x11, 0x6E, 0x47, 0x83, + 0xF2, 0x88, 0xDC, 0x23, 0x9A, 0x89, 0xB7, 0x0F, + 0xAE, 0x52, 0x0F, 0xF4, 0x50, 0x59, 0x75, 0x7A, + 0x57, 0xE0, 0xD4, 0xA0, 0xDC, 0x73, 0xA7, 0x90 + }, + { + 0xA9, 0xDA, 0x90, 0x65, 0xBA, 0x73, 0x11, 0x0C, + 0xD0, 0xFD, 0xE1, 0xD2, 0xF5, 0x3B, 0xE8, 0xD6, + 0xDE, 0x2B, 0x20, 0x42, 0x54, 0x67, 0x19, 0xBE, + 0xC6, 0x21, 0xA8, 0x66, 0xCA, 0x62, 0x13, 0x10, + 0x34, 0x4A, 0x75, 0x94, 0x5B, 0x17, 0x82, 0x92, + 0xCC, 0x8C, 0xF1, 0x5F, 0xD2, 0x42, 0xC8, 0x08, + 0xEB, 0xDB, 0x2A, 0x2C, 0x07, 0x46, 0x9B, 0xCC, + 0xD7, 0xD1, 0x3F, 0x6B, 0x08, 0xFD, 0x1A, 0xB4 + }, + { + 0xC0, 0xE4, 0x2D, 0x2C, 0x34, 0xE8, 0xDA, 0x97, + 0x72, 0x35, 0x11, 0xE6, 0x78, 0xA6, 0x3E, 0x3F, + 0xFE, 0x35, 0x17, 0x26, 0x16, 0x0F, 0xCF, 0x07, + 0xEC, 0x97, 0x17, 0x75, 0x11, 0x09, 0x71, 0x97, + 0xAC, 0x06, 0xAF, 0xE7, 0xC0, 0x95, 0x2E, 0x23, + 0xA2, 0x92, 0xB5, 0xFD, 0x7F, 0xC0, 0x90, 0xEE, + 0xC5, 0x6D, 0x3F, 0x5A, 0xAC, 0x3B, 0xCA, 0xFF, + 0xCD, 0xE6, 0xAC, 0x6B, 0x94, 0xE8, 0xD4, 0xE9 + }, + { + 0xEB, 0x46, 0x2C, 0xEA, 0x7A, 0x06, 0x2E, 0xF3, + 0xD6, 0x87, 0x16, 0x96, 0x0C, 0x1F, 0xD5, 0xA3, + 0xF0, 0x39, 0xDF, 0x44, 0xB9, 0x66, 0xC6, 0xEC, + 0x3D, 0xC6, 0xC3, 0x24, 0xCD, 0xC5, 0x77, 0x20, + 0xDE, 0xB2, 0xFD, 0xBC, 0x7E, 0x47, 0x84, 0xB9, + 0x65, 0xB9, 0x71, 0x34, 0x30, 0x4C, 0xFC, 0x63, + 0x52, 0x5A, 0xD0, 0x07, 0x37, 0x09, 0x1F, 0x37, + 0xA1, 0x84, 0x11, 0xC7, 0xC8, 0x59, 0xC2, 0x5E + }, + { + 0xA6, 0x40, 0xC6, 0x90, 0xE8, 0x0A, 0x3A, 0x26, + 0x1E, 0x5B, 0xC7, 0xA8, 0xF1, 0xE9, 0xB7, 0x30, + 0x9A, 0x64, 0x09, 0xA3, 0x33, 0x00, 0x9A, 0x2E, + 0x87, 0xE1, 0x81, 0x1F, 0xAC, 0xE9, 0x7D, 0x85, + 0xFB, 0x52, 0xFD, 0x0E, 0x08, 0x5F, 0xD8, 0xD0, + 0xCA, 0xD4, 0x40, 0x8D, 0xC3, 0x6A, 0x31, 0xAE, + 0xD4, 0x18, 0x5F, 0x44, 0xD0, 0xD6, 0xEE, 0x02, + 0xF6, 0x72, 0xEA, 0xA8, 0x5B, 0xBD, 0x8C, 0x9A + }, + { + 0xBA, 0x77, 0xBF, 0x28, 0xC8, 0xC5, 0x54, 0xF1, + 0x10, 0x14, 0x2A, 0xE1, 0x27, 0xE5, 0x4F, 0x47, + 0x0E, 0x96, 0x67, 0xD2, 0x22, 0x2C, 0x2E, 0x59, + 0x33, 0x0B, 0x2A, 0xAF, 0x1B, 0xEC, 0x24, 0x57, + 0x29, 0x0D, 0x95, 0x59, 0xC5, 0x9A, 0x25, 0xEA, + 0x77, 0x0F, 0x7A, 0x93, 0x30, 0xFC, 0xEC, 0x63, + 0xC5, 0x73, 0x1D, 0xAC, 0x59, 0x67, 0xE1, 0xF3, + 0x80, 0x1B, 0xF3, 0x66, 0x03, 0x3B, 0xCC, 0x97 + }, + { + 0xB2, 0x59, 0xA9, 0x54, 0x68, 0x22, 0x92, 0xE4, + 0x4C, 0x7F, 0x3D, 0x21, 0xC6, 0x5C, 0xA1, 0x78, + 0xA8, 0x65, 0xC7, 0xC6, 0xF8, 0xE9, 0xBD, 0x90, + 0xE3, 0x07, 0x49, 0xB0, 0x5C, 0x88, 0x1A, 0x1F, + 0x29, 0x04, 0xE7, 0xBD, 0x88, 0x73, 0x3A, 0x86, + 0xF9, 0xD6, 0x01, 0xC8, 0x0E, 0xB8, 0xA8, 0x2A, + 0xEB, 0xC6, 0xE2, 0xF7, 0x78, 0xCF, 0xD5, 0xE4, + 0xEA, 0xE7, 0x99, 0x8F, 0xD6, 0x9F, 0x98, 0x48 + }, + { + 0x79, 0x59, 0x23, 0xA6, 0xEB, 0x83, 0x50, 0x68, + 0x75, 0xDC, 0x12, 0x3C, 0x0C, 0x0C, 0x78, 0xE8, + 0x1E, 0x40, 0x47, 0x36, 0xA9, 0xAA, 0x6B, 0xBB, + 0x98, 0x50, 0xA2, 0x2B, 0xDC, 0x14, 0x9B, 0x7C, + 0x15, 0xD7, 0x36, 0x59, 0xC2, 0xE3, 0x8F, 0x1E, + 0x65, 0x44, 0x48, 0x08, 0xD7, 0x8E, 0x6A, 0x6E, + 0xEC, 0x5C, 0x09, 0x0D, 0xF0, 0x8B, 0xD1, 0x0C, + 0xC3, 0xEF, 0x96, 0x99, 0x0F, 0x04, 0xBE, 0x09 + }, + { + 0xF3, 0xDF, 0x93, 0x20, 0xF7, 0x7F, 0xEA, 0xC3, + 0xC7, 0xCA, 0x4E, 0x4D, 0xA7, 0xAB, 0xD7, 0x28, + 0x1B, 0xEB, 0x8D, 0xBD, 0xFE, 0x7B, 0xFD, 0xEB, + 0x77, 0x34, 0x24, 0x42, 0xCC, 0x03, 0x2C, 0x85, + 0x61, 0xE2, 0x00, 0x47, 0x7B, 0x83, 0xEA, 0x30, + 0x17, 0x95, 0x17, 0x42, 0x11, 0x90, 0x47, 0x0F, + 0x6E, 0x7A, 0xF3, 0x99, 0xB5, 0x7A, 0x7A, 0x8D, + 0x5F, 0xD5, 0xD5, 0xEF, 0x3E, 0x1F, 0x3E, 0x13 + }, + { + 0xD0, 0xE0, 0x20, 0x3E, 0xDF, 0x4C, 0x6E, 0xB3, + 0xB1, 0x42, 0xFC, 0xA0, 0xDD, 0x2D, 0x09, 0xF1, + 0x6D, 0x27, 0xE6, 0x4B, 0xCD, 0x9C, 0x6E, 0xB8, + 0x3C, 0x32, 0xEA, 0x4A, 0xC9, 0xC7, 0x88, 0x01, + 0x89, 0xCF, 0x0A, 0xA8, 0xE6, 0x5D, 0x78, 0x2A, + 0x55, 0x64, 0xF0, 0xD0, 0x76, 0x52, 0x86, 0xBE, + 0x99, 0x20, 0xE8, 0x75, 0x1D, 0xD7, 0xED, 0x78, + 0x7C, 0x53, 0x78, 0xD2, 0x16, 0x85, 0x2D, 0x29 + }, + { + 0x4F, 0xF7, 0xBE, 0x53, 0xC3, 0xE8, 0x63, 0xD8, + 0x76, 0x60, 0x40, 0xE9, 0x4B, 0xFC, 0xDE, 0x10, + 0xE0, 0x29, 0xA7, 0x9C, 0x0E, 0x21, 0x7F, 0xEC, + 0x74, 0xAA, 0x74, 0xF9, 0x76, 0xF9, 0x6B, 0xD2, + 0x4A, 0x10, 0xB2, 0x94, 0x0C, 0xC2, 0xA7, 0xD3, + 0x73, 0xA2, 0xA6, 0xE3, 0xA0, 0xFE, 0x5F, 0xA8, + 0x93, 0x04, 0x49, 0x5A, 0xC4, 0x47, 0x20, 0xB8, + 0x60, 0xC4, 0xE9, 0xF7, 0xC2, 0x0F, 0x32, 0x3B + }, + { + 0xF5, 0x93, 0xBB, 0x54, 0xF0, 0xAF, 0x57, 0xD3, + 0x98, 0xCC, 0xDD, 0x00, 0xC7, 0x62, 0xBC, 0xFE, + 0xE3, 0x8E, 0x5A, 0x4E, 0xF0, 0x44, 0x2C, 0x62, + 0x02, 0xED, 0x90, 0x94, 0x63, 0x87, 0xC6, 0x14, + 0x65, 0x19, 0xEB, 0x69, 0x05, 0x1F, 0xB3, 0x89, + 0x3A, 0xCC, 0x14, 0x6C, 0xE6, 0xFE, 0xE0, 0x2E, + 0x8A, 0x72, 0x59, 0x8B, 0x56, 0x19, 0xA0, 0x63, + 0x29, 0x5D, 0x72, 0xC2, 0x93, 0x1F, 0xF5, 0x88 + }, + { + 0x39, 0x84, 0xD9, 0x15, 0x67, 0x8D, 0x4B, 0x87, + 0xDF, 0x74, 0x88, 0x0F, 0x9E, 0xE1, 0x2F, 0x86, + 0xA9, 0xAD, 0x10, 0xAB, 0x26, 0x49, 0xDE, 0xB6, + 0x45, 0x34, 0x18, 0x99, 0x46, 0xAE, 0x51, 0x26, + 0x3F, 0x9C, 0x4A, 0x2A, 0xD9, 0xC4, 0x1D, 0xEC, + 0x6F, 0x5A, 0x28, 0x55, 0x79, 0x6E, 0x83, 0xE8, + 0x3B, 0x73, 0xD4, 0x96, 0x85, 0x4F, 0xB5, 0xC7, + 0x7F, 0x4C, 0x26, 0x8F, 0x32, 0xF7, 0xFC, 0xBD + }, + { + 0x8D, 0x34, 0xAA, 0x22, 0x2D, 0x3D, 0x5A, 0x5B, + 0x0F, 0xC4, 0x49, 0xC3, 0x22, 0x22, 0xC8, 0x24, + 0x1D, 0x83, 0xDE, 0x84, 0xA5, 0xDC, 0xA5, 0x8B, + 0xB4, 0xD3, 0xCC, 0x37, 0x06, 0xB9, 0x97, 0x39, + 0xB8, 0x95, 0x17, 0x4D, 0x7E, 0xEE, 0xAE, 0x08, + 0x57, 0xBC, 0x4D, 0x77, 0xA4, 0xE4, 0x1D, 0x21, + 0xFF, 0x09, 0x12, 0xF8, 0x1E, 0xBC, 0xA0, 0x2C, + 0xBD, 0xFE, 0xDE, 0x7C, 0x6C, 0x4C, 0x14, 0x57 + }, + { + 0xBE, 0x7E, 0x82, 0xAB, 0x86, 0x2C, 0x72, 0xFC, + 0x4E, 0xB7, 0x02, 0x91, 0x22, 0xAA, 0x0B, 0x44, + 0x87, 0xAC, 0x59, 0x41, 0x38, 0x5A, 0x44, 0xB9, + 0xD4, 0x23, 0x0A, 0xF7, 0xBB, 0xA7, 0x55, 0xCC, + 0xED, 0x52, 0xE5, 0x66, 0xA8, 0x62, 0x31, 0xBC, + 0x8C, 0x44, 0x10, 0xAB, 0x09, 0xBE, 0x5E, 0x23, + 0x89, 0xBB, 0x4E, 0x2E, 0x13, 0x1E, 0x7F, 0xD5, + 0xED, 0xE3, 0x93, 0x24, 0x30, 0x11, 0xFC, 0xC3 + }, + { + 0x62, 0xCA, 0xDA, 0x51, 0x70, 0xA0, 0xB2, 0xC9, + 0x97, 0x72, 0x60, 0x80, 0x44, 0xB1, 0x7A, 0x4F, + 0x6F, 0x30, 0xA4, 0xED, 0x5A, 0x2C, 0xB9, 0xC3, + 0x94, 0xD4, 0x0C, 0x7C, 0xE2, 0xAE, 0x42, 0x99, + 0xFB, 0x6E, 0x7A, 0xCA, 0xE2, 0x27, 0x5E, 0x4B, + 0x73, 0xA5, 0xF3, 0x84, 0xC7, 0x5F, 0xAC, 0xC7, + 0x75, 0xB7, 0xA8, 0xC8, 0xF1, 0x40, 0xCB, 0x81, + 0x7A, 0x04, 0x60, 0xA3, 0x5B, 0xC4, 0x72, 0x46 + }, + { + 0x75, 0x20, 0x3F, 0xEF, 0xFC, 0x83, 0x10, 0x8C, + 0x71, 0x21, 0x07, 0xED, 0x78, 0x07, 0xA7, 0x95, + 0x49, 0x78, 0x47, 0x40, 0xA6, 0x63, 0x08, 0x00, + 0x1B, 0xA4, 0xB9, 0xDB, 0xB6, 0xE5, 0x1A, 0xC5, + 0xA1, 0x7A, 0x3D, 0x94, 0x9A, 0x97, 0xD8, 0x17, + 0xEA, 0x7C, 0x48, 0x78, 0x6D, 0x7D, 0x96, 0xBC, + 0x1D, 0x86, 0x27, 0x32, 0xFF, 0xFE, 0xB1, 0x90, + 0xAC, 0xB2, 0x0C, 0x9F, 0xF4, 0x9A, 0x90, 0x80 + }, + { + 0x9E, 0x66, 0x75, 0x79, 0x37, 0xAB, 0x63, 0xEE, + 0x44, 0x31, 0x27, 0x69, 0xAE, 0x4A, 0xB3, 0x26, + 0x1F, 0xA0, 0xAE, 0xB1, 0x46, 0x67, 0x63, 0x66, + 0x25, 0x45, 0x5D, 0xC4, 0x92, 0x66, 0x6F, 0x63, + 0x08, 0x1E, 0x47, 0x28, 0x69, 0x21, 0xC2, 0x46, + 0xFF, 0x37, 0x39, 0x6F, 0xC0, 0x8F, 0xB5, 0xAE, + 0xE4, 0x9B, 0xC9, 0x30, 0x03, 0xB0, 0x0F, 0x94, + 0xC2, 0x62, 0x15, 0xF6, 0x0B, 0x1F, 0x63, 0x7A + }, + { + 0x69, 0xA2, 0x0B, 0x53, 0xA0, 0xF8, 0xC8, 0x05, + 0x31, 0xB5, 0x52, 0x7C, 0x07, 0x6A, 0x81, 0x21, + 0xD2, 0x29, 0xCD, 0xEC, 0xCC, 0x0C, 0xA2, 0x51, + 0x4C, 0x25, 0x6A, 0x0F, 0xDA, 0xCA, 0xC6, 0xCA, + 0xAB, 0xCC, 0xBE, 0xB1, 0xA0, 0x3D, 0xDA, 0x12, + 0x10, 0x27, 0xA9, 0x11, 0x3B, 0xA0, 0x57, 0xF7, + 0xF9, 0xBC, 0x6F, 0x6C, 0x49, 0x85, 0x4E, 0x69, + 0xBD, 0x86, 0xF5, 0x60, 0x2D, 0x60, 0xEE, 0x75 + }, + { + 0xC6, 0xEB, 0x68, 0x57, 0x84, 0x27, 0x52, 0xB8, + 0xCB, 0xE4, 0x8D, 0xD3, 0x4C, 0xCB, 0xD6, 0xFA, + 0xB4, 0x33, 0x89, 0x64, 0x11, 0x54, 0x0C, 0x87, + 0xF2, 0x7A, 0xEA, 0x51, 0xE8, 0xC1, 0x82, 0xB3, + 0x8C, 0xC5, 0x7B, 0x96, 0x35, 0x24, 0x51, 0x38, + 0xDF, 0x58, 0xA5, 0x1B, 0x06, 0x07, 0x4E, 0xA8, + 0xD2, 0x92, 0x66, 0x8D, 0xC9, 0x6E, 0xA7, 0xA7, + 0x65, 0x88, 0x62, 0x21, 0x59, 0xD0, 0x38, 0x36 + }, + { + 0x28, 0x68, 0xCD, 0x6A, 0x0B, 0x45, 0xD6, 0x03, + 0x66, 0x6E, 0x2F, 0xB7, 0x1F, 0x9A, 0xFD, 0xA0, + 0x14, 0xC3, 0xEE, 0x42, 0x47, 0x5D, 0xF8, 0x89, + 0x9F, 0x5B, 0x54, 0xEC, 0xFC, 0x02, 0xCD, 0x4B, + 0xF3, 0x74, 0x07, 0xAF, 0x49, 0x1D, 0x1F, 0x32, + 0x82, 0xD7, 0x6A, 0x11, 0x4C, 0x73, 0x0C, 0xDC, + 0xF0, 0xFC, 0x70, 0xC9, 0xC0, 0x81, 0x1D, 0x26, + 0x03, 0x54, 0xAA, 0xBE, 0x5B, 0xFF, 0xD4, 0x5A + }, + { + 0xC2, 0x99, 0x85, 0x59, 0xF4, 0xD2, 0xD3, 0xBF, + 0xB8, 0x79, 0x4F, 0x05, 0xB0, 0x42, 0x04, 0xB3, + 0xB7, 0x8D, 0x91, 0x1B, 0x93, 0x70, 0x4E, 0x07, + 0xAE, 0x44, 0x9E, 0x6B, 0x5B, 0xB5, 0x72, 0xE2, + 0x33, 0x0B, 0x09, 0x24, 0xDD, 0x2D, 0x6A, 0xB5, + 0xB5, 0xD3, 0x37, 0x05, 0x0F, 0xE4, 0x61, 0x24, + 0xA5, 0x24, 0x5F, 0x3F, 0x6F, 0x2A, 0xCF, 0x22, + 0x8F, 0x54, 0xFB, 0x3A, 0xB6, 0x95, 0x5F, 0xF6 + }, + { + 0x77, 0x26, 0xAF, 0xF6, 0x6C, 0x22, 0x94, 0x84, + 0xE4, 0xC2, 0x31, 0xCB, 0xC9, 0x5C, 0x2F, 0xF5, + 0xE9, 0x75, 0x76, 0x29, 0x05, 0xAA, 0xFC, 0x32, + 0x92, 0xCD, 0x0F, 0x8E, 0xE3, 0x89, 0x37, 0xB0, + 0x14, 0xA3, 0xD8, 0x7E, 0xFB, 0x2A, 0x50, 0xDA, + 0x2A, 0x6E, 0xC7, 0x6F, 0x56, 0x05, 0xB7, 0x00, + 0x84, 0x80, 0x28, 0xD3, 0x0A, 0x53, 0x8A, 0xFC, + 0xCF, 0x6A, 0x4F, 0x3E, 0xC8, 0xE7, 0xEA, 0x43 + }, + { + 0x97, 0xD3, 0x9D, 0x1B, 0x9F, 0x8D, 0x69, 0x21, + 0x8A, 0x05, 0xB5, 0xB0, 0x07, 0x60, 0x60, 0x43, + 0xDC, 0xB2, 0x95, 0x6D, 0xA5, 0xB9, 0xF7, 0xB5, + 0xA7, 0x3E, 0x6E, 0xA8, 0x72, 0x80, 0xCD, 0x4A, + 0xB2, 0x33, 0xE3, 0x14, 0x3D, 0x67, 0x13, 0x88, + 0x2D, 0x63, 0xD3, 0xE6, 0x58, 0x6A, 0x3A, 0xED, + 0xC7, 0x28, 0x04, 0x9E, 0xDB, 0x38, 0x4D, 0xBC, + 0x0F, 0x78, 0x43, 0xB5, 0x41, 0x83, 0xEF, 0x23 + }, + { + 0xF6, 0xC9, 0x18, 0x91, 0x13, 0xF5, 0xAC, 0x89, + 0x63, 0x86, 0x39, 0xF4, 0xC0, 0xF1, 0x81, 0xFE, + 0x0E, 0xC6, 0xF4, 0xF6, 0xEE, 0x34, 0x61, 0x12, + 0x81, 0xC5, 0xFD, 0x06, 0xF6, 0xF5, 0xEC, 0xBF, + 0xB7, 0x9F, 0xB9, 0x2A, 0xE3, 0xD5, 0x3A, 0xA3, + 0xF2, 0xD1, 0xE8, 0xA9, 0x73, 0x5A, 0x02, 0xC7, + 0x58, 0xEB, 0x74, 0x1E, 0x6E, 0x7F, 0x07, 0x99, + 0xDD, 0x05, 0x7A, 0xF5, 0x89, 0xDB, 0x23, 0xC9 + }, + { + 0x3A, 0xA4, 0xFF, 0xBA, 0xF3, 0x16, 0x3A, 0x0E, + 0x0F, 0x0D, 0x76, 0x70, 0x2B, 0xEB, 0x49, 0xE8, + 0x18, 0x26, 0xB9, 0x5D, 0xDB, 0x8C, 0x01, 0x76, + 0x45, 0xF8, 0x6C, 0x6F, 0xA6, 0x8E, 0x0D, 0x73, + 0xB1, 0x66, 0xE2, 0x7F, 0x07, 0xE6, 0xB5, 0xFC, + 0xB4, 0x0B, 0x63, 0x69, 0xE5, 0xEB, 0x51, 0x71, + 0xDD, 0x82, 0x5C, 0x71, 0x63, 0xE2, 0x95, 0x77, + 0xD0, 0xC0, 0xF6, 0xDF, 0x7B, 0x54, 0x29, 0x3E + }, + { + 0x09, 0x55, 0x43, 0x28, 0x25, 0xF0, 0x62, 0xD6, + 0x79, 0x48, 0x26, 0x70, 0x68, 0xCD, 0xB4, 0x54, + 0xF9, 0x08, 0xB3, 0x2D, 0xBE, 0xD2, 0x30, 0x9A, + 0x13, 0x0C, 0x79, 0xF2, 0x40, 0xAB, 0x0C, 0x85, + 0xF6, 0x5E, 0xCB, 0x6B, 0x35, 0x97, 0x64, 0xEC, + 0xDA, 0x3C, 0xA9, 0xE5, 0xB6, 0x19, 0x6B, 0x9C, + 0xE5, 0x6F, 0x78, 0xA7, 0xC7, 0xE8, 0x62, 0x41, + 0x5A, 0x09, 0x8D, 0xCD, 0x4A, 0xB6, 0x82, 0xE7 + }, + { + 0x3D, 0xF9, 0x1E, 0x11, 0x15, 0xCF, 0x15, 0x0B, + 0xE9, 0x96, 0x27, 0x19, 0x90, 0x2B, 0xD4, 0xE6, + 0x25, 0xD7, 0xF0, 0xD5, 0x72, 0xB6, 0x22, 0xCC, + 0x89, 0xD1, 0x40, 0x8E, 0xB1, 0x22, 0x7B, 0xED, + 0x22, 0xC2, 0xBA, 0x59, 0xDF, 0x13, 0x7A, 0x12, + 0x46, 0x98, 0x01, 0x99, 0x7F, 0x37, 0x30, 0x3B, + 0xAD, 0x54, 0x89, 0x1C, 0x6D, 0xBE, 0x86, 0xC7, + 0x0F, 0xB8, 0x46, 0x95, 0xA7, 0x72, 0x86, 0x7B + }, + { + 0x71, 0x96, 0x16, 0xCE, 0xBC, 0x97, 0x57, 0xD2, + 0x42, 0xB6, 0x21, 0x78, 0x91, 0xE3, 0x5C, 0xF7, + 0x28, 0x56, 0x69, 0x8F, 0x58, 0xAA, 0x88, 0xF4, + 0xFC, 0xE9, 0xB2, 0xF6, 0x8F, 0xF6, 0x47, 0x4D, + 0x8F, 0xB0, 0x5C, 0x4C, 0x2A, 0xF1, 0x35, 0x24, + 0x71, 0x0D, 0x0F, 0xD9, 0xE2, 0xAB, 0xB6, 0xEC, + 0x80, 0x8E, 0xF8, 0xD2, 0xFC, 0x4D, 0x3F, 0xD6, + 0xA7, 0xF7, 0xAD, 0x53, 0x5F, 0x51, 0x53, 0xA7 + }, + { + 0x49, 0xA7, 0x22, 0x58, 0xBB, 0x9C, 0x39, 0xF5, + 0x57, 0x4C, 0x55, 0x3A, 0x11, 0xA4, 0xD6, 0x0F, + 0x60, 0x98, 0x39, 0x8A, 0xD9, 0xDB, 0x73, 0x87, + 0xC9, 0x08, 0x02, 0xEF, 0x91, 0xA9, 0xA4, 0xA1, + 0x69, 0xE6, 0xBB, 0xBF, 0x0D, 0xFF, 0x67, 0xBE, + 0xB0, 0x39, 0xEC, 0xC3, 0x64, 0x78, 0x0A, 0x75, + 0xD8, 0x01, 0xE7, 0x90, 0xA9, 0xE5, 0xDC, 0x58, + 0x88, 0x2A, 0xFB, 0x2E, 0xDD, 0x33, 0x0A, 0x4F + }, + { + 0xE2, 0xD2, 0xA2, 0x2D, 0xBF, 0xD4, 0x2C, 0x34, + 0xE6, 0x5F, 0x26, 0x01, 0xA3, 0x78, 0x56, 0x05, + 0xD0, 0x24, 0xC2, 0x8C, 0xD8, 0x39, 0xE9, 0x6E, + 0x43, 0x51, 0x7E, 0xF4, 0xBA, 0x32, 0x1C, 0xA4, + 0x56, 0xB4, 0x51, 0x37, 0xC4, 0xD7, 0x79, 0xD1, + 0x23, 0x1F, 0x7A, 0x44, 0x8A, 0x90, 0xB1, 0x50, + 0x12, 0x33, 0xF0, 0xAB, 0x49, 0xE7, 0x1E, 0xD1, + 0xC2, 0xC5, 0x4B, 0x16, 0x86, 0xED, 0x8D, 0xEE + }, + { + 0x29, 0x26, 0xDC, 0xA8, 0x5E, 0xC0, 0xC3, 0x9A, + 0xA9, 0x22, 0x51, 0xA5, 0x99, 0x0E, 0x99, 0x66, + 0xA5, 0xAA, 0xFA, 0x59, 0xEB, 0x24, 0xE8, 0xDB, + 0x77, 0x7A, 0x58, 0x0E, 0xB5, 0x3B, 0x81, 0xB9, + 0x50, 0x40, 0xFD, 0x49, 0xC6, 0x7C, 0x31, 0xCA, + 0xE1, 0xFC, 0x77, 0x0F, 0x33, 0xC0, 0x98, 0x7B, + 0xDB, 0xEE, 0x4D, 0x59, 0x23, 0x9E, 0xF4, 0xA4, + 0x57, 0xAF, 0xF7, 0x7D, 0xD4, 0x3E, 0x19, 0xF4 + }, + { + 0xF2, 0x1F, 0x90, 0x15, 0x2E, 0x0B, 0x2F, 0xAE, + 0x6B, 0x65, 0xAA, 0x2C, 0x49, 0x64, 0x94, 0x1F, + 0x04, 0x7E, 0xB1, 0xFA, 0x46, 0xB8, 0xED, 0xC7, + 0xD7, 0xDB, 0xD9, 0xF2, 0x83, 0xF2, 0x25, 0x07, + 0x00, 0x7E, 0xD0, 0xB8, 0xA7, 0xD3, 0xD7, 0xAC, + 0x54, 0xFD, 0xFF, 0xA5, 0xD6, 0x8C, 0x47, 0xD4, + 0x30, 0x6B, 0xA6, 0xE2, 0xAE, 0x50, 0xF6, 0xBE, + 0x3C, 0x2F, 0xD4, 0x3E, 0xD1, 0x32, 0x34, 0x24 + }, + { + 0xE5, 0xE6, 0x5B, 0x52, 0x9A, 0xF5, 0xC8, 0x12, + 0xC9, 0x43, 0xF8, 0x34, 0xBF, 0xE6, 0x16, 0xB3, + 0xDC, 0x0E, 0xD6, 0x38, 0x94, 0x6E, 0xFD, 0x35, + 0x44, 0x3E, 0x71, 0xD8, 0x3D, 0x5D, 0x08, 0xB5, + 0x0F, 0xFC, 0x29, 0x81, 0x5A, 0x16, 0x11, 0xC7, + 0xE5, 0x03, 0x9A, 0x47, 0x53, 0x3C, 0x7D, 0xAF, + 0x65, 0xD3, 0xA2, 0x23, 0x14, 0x03, 0x9C, 0xD9, + 0x21, 0xAE, 0x18, 0x42, 0x36, 0x0E, 0x88, 0x8C + }, + { + 0xA6, 0xCE, 0xB4, 0x0A, 0x42, 0x96, 0x12, 0x00, + 0x5F, 0x04, 0x42, 0x3E, 0xD5, 0x15, 0x2B, 0x20, + 0x99, 0x59, 0xFE, 0x30, 0xEA, 0x5B, 0x52, 0x4B, + 0x46, 0x54, 0x1F, 0xE4, 0x10, 0xA6, 0x0D, 0xEA, + 0x48, 0x11, 0xCB, 0xFA, 0x95, 0xCE, 0xC5, 0xAC, + 0x2F, 0x50, 0x9A, 0xE0, 0x5C, 0xCE, 0xDB, 0x2B, + 0x3F, 0xBF, 0xF4, 0x38, 0x0F, 0x4C, 0x75, 0xF5, + 0xBD, 0x5C, 0x41, 0x2A, 0xAA, 0x2F, 0x6F, 0x74 + }, + { + 0x02, 0x89, 0x79, 0x6E, 0x63, 0xF1, 0x00, 0x3C, + 0xFE, 0xA3, 0xDA, 0x9C, 0xAF, 0x20, 0x39, 0x43, + 0x82, 0xD0, 0x4E, 0x3A, 0xF3, 0x5A, 0xE0, 0xD1, + 0xAA, 0x2E, 0x02, 0x57, 0x59, 0x23, 0x7E, 0x25, + 0xDE, 0x42, 0xF5, 0x89, 0x39, 0x26, 0x47, 0xD5, + 0x46, 0xEA, 0x9A, 0x06, 0x9F, 0xBB, 0x95, 0x34, + 0x76, 0xD0, 0x87, 0xFD, 0x9C, 0xD5, 0xA3, 0x66, + 0xE5, 0xCF, 0x72, 0x37, 0x5C, 0x7D, 0xA3, 0x24 + }, + { + 0x40, 0x76, 0x9E, 0x0D, 0x8F, 0x02, 0xB5, 0xA1, + 0xDF, 0x95, 0xA7, 0x34, 0xCA, 0xE4, 0x0E, 0xA5, + 0x85, 0xB6, 0xD6, 0xF7, 0x47, 0xC9, 0x86, 0x05, + 0xFA, 0x9A, 0x36, 0xF9, 0x42, 0x3F, 0x7E, 0x34, + 0xEA, 0x70, 0x16, 0xF4, 0x6B, 0x4F, 0xB3, 0xE2, + 0x40, 0x6D, 0xCF, 0xA6, 0x31, 0x3C, 0x38, 0xF0, + 0x49, 0xAF, 0x90, 0xFB, 0x96, 0xCE, 0x20, 0xC7, + 0xCE, 0x40, 0xDA, 0x58, 0x0B, 0x12, 0xFC, 0x86 + }, + { + 0x30, 0x40, 0x56, 0x69, 0xA3, 0xD3, 0x28, 0x8D, + 0xC1, 0x3E, 0x87, 0x6A, 0x27, 0xF6, 0xFD, 0x7E, + 0x98, 0x96, 0xDE, 0xCA, 0xE3, 0x2F, 0x72, 0xF4, + 0xB9, 0x80, 0x16, 0x5A, 0x0B, 0x54, 0x00, 0x8B, + 0x6B, 0x37, 0x1D, 0x4C, 0x45, 0x39, 0x4C, 0x50, + 0x13, 0x4A, 0x0E, 0xB4, 0x31, 0x24, 0xBE, 0xA3, + 0xC3, 0x16, 0x4D, 0x76, 0x16, 0xAD, 0x6C, 0xAD, + 0xFA, 0x17, 0x39, 0x8A, 0x47, 0x38, 0x27, 0xA0 + }, + { + 0x0E, 0x9D, 0xB6, 0xB0, 0xCA, 0x64, 0xCC, 0xCE, + 0x15, 0x34, 0x5C, 0x60, 0x9C, 0x77, 0xB2, 0xB0, + 0x55, 0xEF, 0xFF, 0xF9, 0xFC, 0x60, 0x45, 0x83, + 0x4D, 0x7A, 0x7E, 0xC6, 0x14, 0x5C, 0x1E, 0xD0, + 0x1D, 0xCF, 0xA9, 0x0F, 0x25, 0x8A, 0x86, 0x7C, + 0xC9, 0xDE, 0x47, 0xFA, 0x26, 0x73, 0x2A, 0x29, + 0x2D, 0x45, 0x1A, 0xC0, 0x83, 0xF3, 0xA0, 0xB2, + 0xBD, 0xD0, 0xE4, 0x48, 0x53, 0xBD, 0xA2, 0xFA + }, + { + 0x20, 0xB5, 0x6F, 0xE2, 0xA0, 0xF3, 0x8B, 0x51, + 0x0C, 0xB2, 0x5D, 0xB8, 0xB6, 0xCB, 0x4A, 0x73, + 0x2D, 0xA1, 0x8C, 0x24, 0xD0, 0x79, 0xAB, 0x59, + 0xA5, 0x85, 0x3E, 0xA4, 0x68, 0x42, 0x37, 0xA1, + 0x93, 0x24, 0x4A, 0x58, 0xC8, 0x5D, 0xB2, 0xA9, + 0xA1, 0x6D, 0xF2, 0x41, 0x87, 0x33, 0xCC, 0x8B, + 0x73, 0x2C, 0x9E, 0x46, 0x76, 0x3B, 0xEB, 0x31, + 0xA5, 0xBA, 0xDA, 0xEA, 0x77, 0x0C, 0x4B, 0x1B + }, + { + 0x95, 0x57, 0xD3, 0xEB, 0x2B, 0x06, 0xE4, 0x0E, + 0xD3, 0x9C, 0xA7, 0x56, 0xB2, 0x1C, 0xAC, 0x10, + 0x41, 0x62, 0x59, 0xAB, 0x85, 0x47, 0x70, 0x59, + 0xF9, 0xED, 0x23, 0xB7, 0x67, 0x38, 0x31, 0x0F, + 0x09, 0x0D, 0x63, 0x78, 0x98, 0x6E, 0x22, 0xAC, + 0xD6, 0xC2, 0x02, 0xE1, 0x86, 0x30, 0xF3, 0x51, + 0x50, 0x4D, 0xFB, 0x44, 0x2F, 0xC8, 0x11, 0x2F, + 0xE7, 0x99, 0x48, 0xAF, 0x98, 0xBA, 0xA4, 0xA5 + }, + { + 0x5E, 0x9D, 0x4F, 0x92, 0xA1, 0x33, 0xB0, 0x66, + 0x5D, 0x7A, 0x37, 0x1A, 0x2A, 0x47, 0xBD, 0xDF, + 0xDD, 0xA6, 0x60, 0xCA, 0x6C, 0x9E, 0x2A, 0xF4, + 0x79, 0x8B, 0x0A, 0xA8, 0x19, 0x56, 0x0B, 0x71, + 0xA2, 0x18, 0x1D, 0x63, 0x6C, 0x8B, 0x26, 0x5B, + 0xFD, 0xD6, 0x8F, 0xA0, 0x5F, 0x5F, 0x3E, 0x37, + 0xF4, 0x34, 0x63, 0x6E, 0xD4, 0xDF, 0x16, 0x68, + 0x46, 0x3B, 0x45, 0x5F, 0x60, 0xC1, 0x8F, 0x2E + }, + { + 0x7D, 0x2E, 0x33, 0xBB, 0xA4, 0xEC, 0x80, 0x5A, + 0x2B, 0x68, 0x26, 0xF9, 0xAD, 0xEF, 0x30, 0xFD, + 0x19, 0xFA, 0x3E, 0x03, 0x31, 0xB2, 0xCE, 0xA8, + 0x4B, 0x14, 0x05, 0x75, 0x18, 0xC5, 0x16, 0x7D, + 0xEF, 0x4F, 0x5F, 0xEB, 0x92, 0x9C, 0xBE, 0xDA, + 0xE4, 0xA8, 0x2E, 0xD7, 0xC2, 0xE1, 0xFC, 0x08, + 0x14, 0x80, 0xE5, 0x45, 0xE8, 0x60, 0x63, 0x1A, + 0x58, 0x2C, 0x16, 0x93, 0x06, 0xBC, 0x07, 0x23 + }, + { + 0xE2, 0x59, 0x1B, 0x0E, 0xFC, 0xF6, 0x05, 0xF3, + 0x88, 0x12, 0x10, 0xAC, 0x50, 0x59, 0x22, 0x70, + 0x61, 0x8E, 0x4C, 0x55, 0x0A, 0x65, 0x3B, 0xA8, + 0xAA, 0x14, 0xA6, 0x8C, 0xA0, 0xC7, 0x8F, 0x0C, + 0xB6, 0xDB, 0xE3, 0x91, 0xDF, 0xFE, 0x66, 0x37, + 0xAA, 0xBC, 0x50, 0x86, 0x48, 0xED, 0xFE, 0x5F, + 0x29, 0x91, 0x22, 0xA0, 0x0C, 0xA0, 0x66, 0x92, + 0x81, 0xB1, 0x81, 0xF7, 0x60, 0xB0, 0x75, 0xC8 + }, + { + 0xEE, 0x5D, 0x26, 0xF8, 0x50, 0x8A, 0x83, 0xB7, + 0xF0, 0x03, 0x34, 0x9A, 0x90, 0x3D, 0x07, 0xC4, + 0xBF, 0xE7, 0x56, 0xF5, 0x2F, 0x24, 0x05, 0x38, + 0xF3, 0x4B, 0x5D, 0xEF, 0x25, 0x7F, 0x44, 0xAE, + 0x34, 0x23, 0x29, 0x3A, 0xA3, 0xE9, 0x9E, 0x97, + 0x96, 0x45, 0x47, 0xF3, 0x0D, 0x3E, 0xD4, 0x0D, + 0x4B, 0xF6, 0x18, 0x29, 0xF5, 0x2A, 0xF7, 0x25, + 0xA2, 0x7B, 0xAF, 0x8B, 0x02, 0x5E, 0x92, 0x97 + }, + { + 0xA3, 0x23, 0xC1, 0xD6, 0x0B, 0x57, 0x0F, 0x20, + 0x9A, 0x72, 0xA6, 0x06, 0xC5, 0xBB, 0x10, 0x42, + 0x4F, 0x2C, 0xA7, 0xD4, 0x3F, 0x23, 0xCA, 0x30, + 0x7D, 0x44, 0xCB, 0xB1, 0xE9, 0x67, 0x82, 0x00, + 0x2F, 0x40, 0x05, 0xD5, 0xA7, 0x0F, 0x9A, 0x3D, + 0x25, 0x4D, 0xA0, 0x64, 0x56, 0x9B, 0x34, 0xA2, + 0x9E, 0xF5, 0x31, 0xFE, 0x29, 0x3E, 0xAF, 0x45, + 0xC7, 0x2B, 0xDB, 0x56, 0xAB, 0x29, 0x52, 0x44 + }, + { + 0xCB, 0x33, 0xAA, 0xE8, 0x32, 0x68, 0x38, 0xF4, + 0x40, 0x7C, 0xDE, 0xC1, 0x54, 0x10, 0xE3, 0xAF, + 0x75, 0xF6, 0x76, 0x72, 0xE1, 0xE5, 0xA9, 0xC0, + 0xB4, 0x97, 0xCB, 0x4B, 0xA2, 0x74, 0xDC, 0x2D, + 0x7F, 0xBC, 0x66, 0xB3, 0xEE, 0xFA, 0x49, 0x2E, + 0x59, 0x93, 0x91, 0x34, 0x48, 0x12, 0xC0, 0xE0, + 0x8A, 0x7A, 0x28, 0x1C, 0x5A, 0x0E, 0xE1, 0xA9, + 0x1D, 0x03, 0x9F, 0xFC, 0x09, 0xE3, 0x2A, 0xA3 + }, + { + 0x58, 0x79, 0x05, 0x38, 0x96, 0xB8, 0x30, 0x80, + 0xA3, 0xC5, 0x17, 0x5B, 0xC6, 0x96, 0x17, 0x8E, + 0x4E, 0xE2, 0x17, 0x86, 0x4E, 0x09, 0xD7, 0x8D, + 0x1C, 0x65, 0xCE, 0x9D, 0xAE, 0x3E, 0xDA, 0x02, + 0xAC, 0x3D, 0x3F, 0xAD, 0x0F, 0x12, 0x91, 0x01, + 0xAD, 0xF6, 0x46, 0x8C, 0x7B, 0x3A, 0x1B, 0xC4, + 0xB3, 0x17, 0x26, 0x68, 0xB6, 0xDF, 0x4C, 0x3F, + 0x64, 0x47, 0x45, 0x13, 0x33, 0xF5, 0x9D, 0xC7 + }, + { + 0x2A, 0xB2, 0xEB, 0x9D, 0x6C, 0x96, 0x57, 0x1C, + 0x68, 0xB7, 0xDC, 0x47, 0xA6, 0xEF, 0x07, 0xE3, + 0x60, 0x06, 0x7C, 0xA1, 0x10, 0x27, 0x81, 0xDA, + 0x85, 0xD1, 0x00, 0xC8, 0x9C, 0x9A, 0x63, 0x5F, + 0xFC, 0xD1, 0xD8, 0x49, 0xA9, 0x12, 0x03, 0x1D, + 0xB3, 0x33, 0x96, 0x88, 0xB3, 0xE1, 0x46, 0x89, + 0xA9, 0xE3, 0x99, 0xC7, 0x0C, 0x15, 0xEB, 0xCE, + 0xD4, 0xF1, 0x05, 0xEA, 0xDE, 0x4E, 0x38, 0x11 + }, + { + 0xD5, 0x40, 0x51, 0x6A, 0x8D, 0x71, 0x64, 0x1B, + 0xFF, 0x73, 0xF8, 0x38, 0xEE, 0xE1, 0xFC, 0xB1, + 0x01, 0x05, 0x1C, 0x9C, 0x86, 0x30, 0x66, 0xC2, + 0x66, 0x18, 0x2C, 0xF7, 0x23, 0xBC, 0x9A, 0x40, + 0x4D, 0x36, 0x2F, 0x8C, 0x2E, 0x72, 0x80, 0x47, + 0x8F, 0x81, 0x85, 0xC3, 0x3F, 0xAF, 0x91, 0x72, + 0xE7, 0x45, 0x50, 0xB2, 0xEC, 0x57, 0x82, 0xED, + 0x9C, 0x2D, 0x62, 0x4E, 0x74, 0x1C, 0x26, 0x7F + }, + { + 0x5E, 0xC3, 0x13, 0xF6, 0xE1, 0x18, 0xBF, 0xF2, + 0x87, 0x7C, 0xC0, 0x71, 0x5F, 0xA5, 0x58, 0xE2, + 0x54, 0x68, 0xBD, 0xEF, 0x00, 0x91, 0x3A, 0x29, + 0xEA, 0x29, 0x0D, 0x06, 0x28, 0xC5, 0x7F, 0x3A, + 0x40, 0x9D, 0x0B, 0x8A, 0x73, 0x1E, 0x2A, 0xA8, + 0x99, 0x7B, 0xE9, 0x1A, 0x13, 0x8D, 0xCB, 0x23, + 0x24, 0x6C, 0xA1, 0x22, 0x79, 0x71, 0x38, 0x07, + 0x3B, 0x26, 0x54, 0xC4, 0xEB, 0x12, 0x9E, 0xED + }, + { + 0xDB, 0xBB, 0x12, 0x05, 0x91, 0x3F, 0xBB, 0x20, + 0x5A, 0x7D, 0xC3, 0x7E, 0x8A, 0xDA, 0xDB, 0x0B, + 0xE5, 0x46, 0xF0, 0xEC, 0x99, 0x45, 0xC1, 0xE2, + 0x70, 0x20, 0x51, 0x3C, 0x08, 0x53, 0x42, 0xA3, + 0xF4, 0xC4, 0x96, 0x5B, 0xA4, 0x39, 0xE4, 0x4D, + 0x87, 0x22, 0x03, 0x9B, 0x92, 0x96, 0x48, 0x00, + 0x60, 0x41, 0x45, 0xF1, 0x18, 0x0A, 0x96, 0x1E, + 0x8D, 0xBB, 0x38, 0x46, 0xE2, 0x74, 0x6A, 0x37 + }, + { + 0xAF, 0xF3, 0xBD, 0x5D, 0x41, 0x5E, 0x54, 0x75, + 0x90, 0x1A, 0xF0, 0x93, 0xE6, 0xF6, 0xC7, 0x87, + 0xFC, 0x20, 0x6B, 0x59, 0xE1, 0x99, 0x21, 0xEF, + 0x96, 0x1E, 0xFB, 0x81, 0x43, 0xBF, 0xA7, 0x96, + 0x1C, 0xCE, 0xA3, 0xC7, 0xF7, 0xC6, 0x08, 0xBE, + 0x08, 0xBC, 0x95, 0x95, 0x93, 0x7A, 0xBD, 0x8A, + 0x03, 0x0D, 0x47, 0xBA, 0x0A, 0x23, 0xAB, 0x08, + 0x77, 0x32, 0xA3, 0xC0, 0xA3, 0xD4, 0x09, 0xB4 + }, + { + 0xB0, 0x57, 0x09, 0x46, 0x6C, 0x1A, 0x54, 0xA8, + 0xE9, 0x71, 0x57, 0x50, 0x32, 0xAB, 0x71, 0xE5, + 0x93, 0x51, 0x5D, 0x81, 0x98, 0x8C, 0x0A, 0xB6, + 0x9D, 0xC8, 0xED, 0x47, 0xDB, 0x3D, 0x42, 0x56, + 0x8C, 0x23, 0x91, 0x8F, 0x9D, 0x53, 0xF3, 0x6B, + 0xE0, 0xF6, 0x05, 0x60, 0x68, 0x56, 0xC4, 0x8C, + 0x71, 0xF2, 0xC0, 0x26, 0x74, 0xB8, 0x7F, 0xD5, + 0x51, 0x46, 0x9B, 0xAF, 0x4E, 0xE3, 0x02, 0x80 + }, + { + 0x01, 0x7A, 0xFD, 0xC9, 0x50, 0xB8, 0x20, 0xDC, + 0x8C, 0xB2, 0x69, 0x57, 0x1F, 0xD8, 0x16, 0xD1, + 0x55, 0x8E, 0xA3, 0x4F, 0x39, 0x4B, 0x4E, 0x9F, + 0xA3, 0x41, 0x07, 0x63, 0xB1, 0xBF, 0x85, 0x18, + 0x47, 0xCA, 0x20, 0x9C, 0x35, 0xDB, 0x19, 0x6A, + 0x42, 0x3C, 0xCA, 0x88, 0x06, 0xA1, 0x83, 0x19, + 0x82, 0xE6, 0xBA, 0x13, 0x96, 0xB9, 0x3C, 0xB1, + 0x44, 0x25, 0xAC, 0x60, 0x72, 0x3E, 0x5B, 0x4F + }, + { + 0x98, 0x55, 0xEC, 0xD0, 0x75, 0x52, 0x94, 0x03, + 0xC1, 0x4B, 0x00, 0x49, 0xCC, 0x78, 0xFA, 0x51, + 0xFA, 0xA3, 0x2D, 0xB4, 0x31, 0x5C, 0xD4, 0x9B, + 0x33, 0x48, 0x4E, 0xB6, 0x43, 0x9E, 0xEF, 0xBD, + 0x96, 0xF1, 0x2D, 0x10, 0x63, 0xCD, 0xE1, 0xA5, + 0x0B, 0xB2, 0xFD, 0x75, 0x0C, 0x82, 0xD6, 0x01, + 0x36, 0x27, 0xF8, 0x16, 0x4E, 0x32, 0xBA, 0xFC, + 0x2F, 0x69, 0x0D, 0xA1, 0x73, 0x09, 0x03, 0x82 + }, + { + 0x30, 0x82, 0xEE, 0xFA, 0x12, 0x63, 0x97, 0x32, + 0x04, 0x30, 0x5A, 0xCA, 0xA3, 0x41, 0xD9, 0x21, + 0x04, 0x56, 0x81, 0x4F, 0xDC, 0xE2, 0x29, 0x12, + 0xAB, 0x1D, 0xF1, 0x8E, 0xE7, 0x55, 0xCB, 0xCE, + 0xF1, 0x7B, 0x3F, 0x24, 0x43, 0x4A, 0x8D, 0xEC, + 0x04, 0xBF, 0xD9, 0x4E, 0x43, 0xA8, 0xC6, 0x22, + 0xEC, 0xBD, 0x53, 0x7E, 0x7D, 0x6C, 0x21, 0x17, + 0xF0, 0x77, 0x4F, 0x8F, 0xFE, 0xBE, 0xF2, 0x1C + }, + { + 0x96, 0xE2, 0x4A, 0xAD, 0x53, 0xB0, 0xA1, 0xEC, + 0xEE, 0x55, 0x3C, 0x69, 0x5C, 0x9D, 0xBE, 0x79, + 0x41, 0x64, 0xFE, 0x9D, 0xA4, 0x1F, 0x34, 0x00, + 0xC2, 0xC5, 0xC5, 0x56, 0x97, 0x1D, 0xE1, 0xCD, + 0xA6, 0x30, 0xA6, 0xD2, 0x3E, 0xC0, 0x3E, 0xD0, + 0x6C, 0x3A, 0x0D, 0x7E, 0xB9, 0x5F, 0x37, 0x57, + 0x30, 0x8A, 0xAD, 0x1A, 0xE0, 0x11, 0xCF, 0x20, + 0xBE, 0xE4, 0xDA, 0xCE, 0x5F, 0x4D, 0x96, 0x92 + }, + { + 0x61, 0x76, 0xAB, 0x2C, 0x3B, 0x1D, 0x04, 0x34, + 0x7A, 0x53, 0xC5, 0x88, 0x50, 0x0A, 0xAB, 0x7B, + 0x1E, 0xC7, 0xAD, 0x25, 0xDC, 0xD0, 0xCD, 0x68, + 0xFE, 0x61, 0xE5, 0x91, 0xAC, 0x19, 0x90, 0x8C, + 0x48, 0x0C, 0x99, 0xAD, 0x1B, 0xCF, 0x1B, 0x67, + 0x04, 0x10, 0x6A, 0x04, 0x83, 0xF6, 0x0F, 0x57, + 0xF3, 0xAD, 0x87, 0x12, 0x65, 0x9A, 0xBF, 0xC8, + 0x4F, 0x2E, 0x02, 0x08, 0x4F, 0xC5, 0x81, 0x65 + }, + { + 0x01, 0xEF, 0xF4, 0xEB, 0x13, 0xFA, 0x9D, 0x7E, + 0xA6, 0x59, 0x54, 0x72, 0x0B, 0xE5, 0x6F, 0x0E, + 0x37, 0x8A, 0xE7, 0x7B, 0xD5, 0x34, 0xC7, 0x44, + 0xAF, 0x6E, 0xC0, 0x1E, 0xFC, 0x03, 0x76, 0xE8, + 0x1D, 0x98, 0x86, 0x6B, 0x5E, 0x6F, 0xA8, 0xC1, + 0x3A, 0x5F, 0xC7, 0xCB, 0xA5, 0x9A, 0x1A, 0xC5, + 0xD4, 0x74, 0x1E, 0xC0, 0x07, 0x22, 0x67, 0x8D, + 0xB0, 0x6A, 0x0A, 0x7D, 0x28, 0x91, 0xEF, 0x56 + }, + { + 0x83, 0xA2, 0xBC, 0xB3, 0x35, 0x7E, 0x28, 0xE1, + 0x9C, 0xE9, 0xEC, 0xB2, 0xB0, 0xD1, 0x20, 0xF4, + 0x24, 0x7C, 0xA8, 0xD4, 0xB4, 0x59, 0xC7, 0x72, + 0x3D, 0x54, 0x1C, 0x0F, 0xCB, 0x90, 0x0C, 0x05, + 0x19, 0x56, 0xAD, 0x41, 0x10, 0x1D, 0xED, 0x19, + 0x3D, 0xD3, 0xAD, 0x7E, 0xE9, 0xFA, 0xCA, 0x47, + 0xAC, 0x47, 0x40, 0xF0, 0x87, 0x96, 0x62, 0xA9, + 0xA4, 0x98, 0x0C, 0x70, 0x49, 0x58, 0x3F, 0xFC + }, + { + 0x5F, 0x3A, 0xFE, 0x9B, 0x46, 0x9D, 0x82, 0x09, + 0x61, 0x53, 0x29, 0xF9, 0xB0, 0xCD, 0x99, 0x7D, + 0x8A, 0x46, 0xAF, 0x5F, 0x5D, 0x88, 0x39, 0x48, + 0xE4, 0x72, 0xAA, 0x72, 0x0B, 0x06, 0x3D, 0x15, + 0xFE, 0x41, 0x3F, 0xA2, 0xAF, 0x8D, 0x12, 0x0E, + 0x48, 0xA3, 0x77, 0xBB, 0x66, 0x1C, 0x83, 0x66, + 0x61, 0xC2, 0xA3, 0x4E, 0x5E, 0x1D, 0x5A, 0x26, + 0xA9, 0x61, 0xBC, 0xDB, 0x63, 0x28, 0x78, 0xAB + }, + { + 0x31, 0x95, 0x24, 0x78, 0xE1, 0xB6, 0x22, 0x9B, + 0x6B, 0xCA, 0x29, 0x6C, 0x64, 0x3A, 0x3F, 0xDB, + 0xE4, 0xAA, 0x2C, 0x2F, 0x7F, 0xEA, 0x46, 0x66, + 0x75, 0x45, 0x3D, 0x5F, 0x7F, 0x09, 0x42, 0x70, + 0x21, 0xA7, 0x7B, 0x86, 0x25, 0xC7, 0x80, 0x70, + 0xC0, 0xF7, 0xCE, 0x56, 0x4D, 0x8D, 0x25, 0x7D, + 0x7E, 0xB3, 0x64, 0x95, 0xBE, 0x76, 0x95, 0x0C, + 0x31, 0xA1, 0xA7, 0xD8, 0x0F, 0xF8, 0xB1, 0xB4 + }, + { + 0x69, 0xBB, 0x57, 0xDD, 0x43, 0xA6, 0x05, 0x11, + 0x76, 0x7C, 0xD6, 0x02, 0x00, 0x84, 0x24, 0xBE, + 0x71, 0x26, 0x59, 0x50, 0xEF, 0x59, 0x21, 0x88, + 0x4D, 0x77, 0x06, 0xF3, 0x68, 0x3E, 0x75, 0x13, + 0x78, 0x61, 0xAA, 0x5E, 0x12, 0xCD, 0x39, 0xFB, + 0x3F, 0x72, 0xB8, 0xB8, 0x1D, 0x3B, 0xA7, 0x21, + 0x72, 0x42, 0xEE, 0x59, 0x29, 0x62, 0x93, 0x8C, + 0x1F, 0x88, 0x6B, 0x9B, 0x9D, 0x48, 0x46, 0x85 + }, + { + 0x06, 0xFB, 0x96, 0xC5, 0x9C, 0xC3, 0x36, 0x47, + 0x36, 0x4D, 0x6A, 0xA0, 0x3F, 0xFD, 0x6B, 0x27, + 0xB1, 0xE0, 0x8D, 0x51, 0xCF, 0x11, 0x9D, 0xAC, + 0x6F, 0x3B, 0x20, 0x42, 0x23, 0x1A, 0x5C, 0x21, + 0xA9, 0x2A, 0x12, 0xB2, 0xCD, 0x12, 0xA1, 0xBF, + 0x10, 0xB3, 0xB5, 0xC4, 0xDF, 0x12, 0x60, 0x01, + 0x7E, 0x76, 0xB2, 0x96, 0xAF, 0x56, 0x02, 0xDB, + 0x90, 0xC9, 0x2B, 0xA7, 0x26, 0x92, 0xE3, 0x67 + }, + { + 0xEB, 0xFD, 0x4B, 0xFB, 0x0A, 0x60, 0x5C, 0x32, + 0x6F, 0x3C, 0x30, 0x63, 0x0B, 0x07, 0x8C, 0x2D, + 0x78, 0x73, 0xC8, 0x18, 0x91, 0x02, 0x33, 0xAC, + 0xC7, 0x5D, 0x27, 0xD1, 0xF3, 0xC9, 0x8F, 0xE6, + 0x2A, 0x44, 0xB9, 0x5F, 0xFF, 0x8D, 0xBD, 0xF9, + 0x12, 0x0F, 0xD9, 0xB9, 0xBC, 0xAA, 0x6C, 0xD1, + 0xFB, 0xDC, 0x8A, 0x21, 0x26, 0x82, 0x04, 0xDA, + 0xB4, 0xF0, 0x1E, 0x74, 0x40, 0x88, 0xDE, 0xB0 + }, + { + 0xDB, 0x72, 0x46, 0x86, 0xC5, 0x34, 0x03, 0x4B, + 0x03, 0x4E, 0xA3, 0xA1, 0x28, 0xFC, 0x32, 0x4C, + 0x7F, 0xBA, 0x62, 0x7C, 0xE8, 0xAB, 0x88, 0x0F, + 0x15, 0xD6, 0x05, 0x1F, 0x95, 0xAC, 0x3E, 0x99, + 0xC3, 0x9E, 0x59, 0x4F, 0x29, 0x37, 0x2A, 0xFF, + 0xFD, 0xAB, 0xB0, 0x85, 0x40, 0x87, 0x5A, 0xE7, + 0x65, 0xCA, 0x38, 0x9C, 0x2C, 0xAE, 0xBA, 0x2C, + 0xFA, 0xD8, 0x39, 0xFF, 0x07, 0xAC, 0x64, 0xC6 + }, + { + 0xC5, 0xC0, 0x81, 0xF9, 0x44, 0xF9, 0x3F, 0x92, + 0x4B, 0x59, 0x35, 0x86, 0xB7, 0xE1, 0x59, 0x4B, + 0xF0, 0x41, 0xE5, 0x3C, 0x2C, 0x9A, 0x5F, 0x1B, + 0xD5, 0x63, 0x51, 0xA6, 0x13, 0xF2, 0x6D, 0x55, + 0x15, 0xA1, 0x16, 0xE7, 0xCF, 0x16, 0xF6, 0x52, + 0xF3, 0xCB, 0x5E, 0x8B, 0xCB, 0x32, 0xCC, 0x25, + 0x48, 0x8B, 0x8A, 0x14, 0xC8, 0x68, 0xA7, 0xDD, + 0xA9, 0x01, 0xD2, 0x66, 0x63, 0xE0, 0x45, 0x42 + }, + { + 0xC0, 0xA0, 0x54, 0x11, 0xED, 0xA4, 0xFB, 0x2E, + 0x99, 0xA2, 0x1D, 0xE3, 0x1A, 0xDD, 0x98, 0x81, + 0x3E, 0x7C, 0x40, 0xFD, 0x0D, 0xC7, 0xF2, 0x70, + 0xFA, 0x63, 0xF4, 0xD5, 0xCF, 0x06, 0x26, 0x1E, + 0xB6, 0xFB, 0xD1, 0x95, 0x9B, 0xB4, 0x9F, 0xB9, + 0xE2, 0xA5, 0xAC, 0xC7, 0xB3, 0x1B, 0x32, 0x40, + 0x6D, 0xBA, 0x87, 0xCF, 0x3C, 0x5C, 0x01, 0x84, + 0x18, 0xC3, 0xFC, 0xD9, 0xCB, 0x81, 0xED, 0x6D + }, + { + 0x09, 0x3D, 0xF8, 0x61, 0x32, 0x80, 0xCD, 0x6E, + 0xF3, 0x80, 0x3F, 0xF9, 0x42, 0xEF, 0x52, 0x43, + 0x7C, 0xD1, 0xFE, 0xD3, 0x1D, 0xF8, 0x08, 0x61, + 0xE1, 0x9E, 0xDB, 0xC1, 0xA9, 0xDB, 0x28, 0xF6, + 0x01, 0xB6, 0xFE, 0xFB, 0xEC, 0x86, 0xA6, 0x15, + 0xA2, 0x57, 0x07, 0x43, 0x2F, 0xD1, 0xDB, 0x50, + 0x93, 0x68, 0x51, 0x6D, 0x41, 0x6A, 0x6F, 0x53, + 0xD7, 0x5D, 0x50, 0x2A, 0xEE, 0x07, 0x22, 0x6B + }, + { + 0x11, 0xAC, 0x2D, 0x6A, 0x6A, 0xF4, 0xAB, 0x88, + 0x7B, 0x71, 0x5F, 0x1A, 0x19, 0x95, 0xD5, 0xCB, + 0x5A, 0xE9, 0x9B, 0xDC, 0xCE, 0xA1, 0xF2, 0xF8, + 0x29, 0xC7, 0x0E, 0x74, 0x4A, 0x76, 0x3F, 0x46, + 0x40, 0x8C, 0x23, 0x26, 0x95, 0xC6, 0xA4, 0x94, + 0x9A, 0x5E, 0x43, 0xD1, 0xA5, 0xB9, 0xFA, 0xDF, + 0xB1, 0x06, 0x7B, 0xE4, 0x16, 0x4E, 0x04, 0x2F, + 0x91, 0xBD, 0xD2, 0x6D, 0x91, 0xD5, 0x95, 0x62 + }, + { + 0x18, 0xB4, 0x84, 0x27, 0x85, 0xD6, 0x1E, 0xC1, + 0x0E, 0x56, 0x19, 0xBF, 0xC3, 0x6D, 0xAD, 0x7A, + 0x77, 0x47, 0xB2, 0x2C, 0x6F, 0x48, 0xAD, 0xCE, + 0x43, 0x3B, 0xB0, 0x66, 0x2C, 0xBD, 0xDA, 0x77, + 0xDB, 0x52, 0x24, 0x97, 0x0B, 0xBD, 0x07, 0x45, + 0x34, 0x4B, 0xFE, 0x78, 0x5B, 0xBB, 0x29, 0x8C, + 0x21, 0xE7, 0x41, 0x09, 0xEB, 0x41, 0xCB, 0xFB, + 0x70, 0xE0, 0x74, 0xA7, 0xE0, 0xA6, 0xF6, 0xBD + }, + { + 0xBC, 0xB4, 0xA5, 0x43, 0x51, 0xFA, 0x94, 0xF0, + 0xF6, 0x26, 0x49, 0x02, 0x54, 0x74, 0xCC, 0xA0, + 0x76, 0xB9, 0x43, 0x4D, 0x35, 0xF4, 0xCE, 0x9A, + 0x56, 0x17, 0x9A, 0x2C, 0x0B, 0x9C, 0xAF, 0x76, + 0x64, 0x52, 0xB4, 0x48, 0x8A, 0x13, 0x4A, 0x83, + 0xCA, 0x27, 0x2F, 0xC4, 0x02, 0xE8, 0x8C, 0xF6, + 0xBF, 0xEB, 0xB1, 0xFA, 0x00, 0x63, 0xF3, 0xE2, + 0x4F, 0xDD, 0x11, 0xD3, 0x5C, 0x55, 0xEB, 0x50 + }, + { + 0x34, 0x9D, 0xF0, 0x7F, 0x42, 0x97, 0x63, 0x19, + 0x69, 0xC3, 0x8D, 0x87, 0x03, 0x13, 0x62, 0x90, + 0x77, 0xAF, 0x0F, 0x00, 0xEB, 0x01, 0x71, 0x41, + 0x24, 0xF2, 0xCF, 0x2B, 0x13, 0x15, 0x51, 0xDE, + 0xAF, 0x2E, 0xF3, 0xE1, 0x9A, 0xDE, 0x51, 0x37, + 0x08, 0x30, 0xB1, 0xA0, 0x6D, 0x33, 0xAB, 0xBA, + 0xF7, 0xEF, 0x69, 0xDB, 0xE5, 0x90, 0x04, 0x20, + 0x97, 0x40, 0x0C, 0x89, 0xFF, 0x3F, 0xB8, 0xBC + }, + { + 0xE7, 0xE7, 0x3B, 0x49, 0x5B, 0xE2, 0xC0, 0xCA, + 0x5F, 0x05, 0xF7, 0x34, 0x84, 0xFE, 0x1D, 0x64, + 0x63, 0x48, 0x66, 0xD3, 0x01, 0xF1, 0xE8, 0x41, + 0xB5, 0x8C, 0x26, 0x80, 0x96, 0x2E, 0xA8, 0x33, + 0xD5, 0xFF, 0x26, 0x9F, 0x8D, 0xB7, 0xE7, 0x20, + 0x14, 0x70, 0xAA, 0x77, 0xD8, 0x81, 0xA8, 0xE0, + 0x89, 0x41, 0xCD, 0xED, 0x52, 0xAB, 0xF2, 0xB5, + 0x59, 0x75, 0x60, 0xA1, 0x98, 0xCF, 0xBF, 0x05 + }, + { + 0x6C, 0xA8, 0x19, 0x02, 0x18, 0x75, 0x91, 0x07, + 0x12, 0xB2, 0xD8, 0xB7, 0x54, 0x19, 0x84, 0xA6, + 0xEC, 0x13, 0xFC, 0x58, 0x24, 0xEA, 0xA8, 0xD0, + 0xC9, 0x44, 0xCA, 0x07, 0xD0, 0x94, 0xB1, 0x95, + 0x6F, 0xFB, 0x42, 0x03, 0x4F, 0x5D, 0xA8, 0x12, + 0xD0, 0xEC, 0x1A, 0x4C, 0xC1, 0x74, 0x40, 0xB8, + 0xD2, 0x31, 0x5C, 0x56, 0xF3, 0xDA, 0x0D, 0xF5, + 0xB1, 0x6F, 0xD1, 0xD2, 0xD0, 0xFE, 0xE5, 0xAF + }, + { + 0x9A, 0x04, 0xA6, 0x90, 0x18, 0x6D, 0xA8, 0x3D, + 0xD3, 0xA5, 0x99, 0x43, 0x80, 0x65, 0xCF, 0x07, + 0xD0, 0xD8, 0x4C, 0x84, 0xD0, 0x36, 0x0D, 0x7D, + 0x13, 0xAD, 0x2E, 0x01, 0x2D, 0x05, 0x63, 0x7A, + 0x45, 0x4B, 0x86, 0xC5, 0xDF, 0x84, 0x62, 0x70, + 0x4B, 0x28, 0xB5, 0xE2, 0x38, 0xFA, 0x33, 0xC1, + 0x3D, 0x19, 0x6D, 0x81, 0xC6, 0x14, 0xBA, 0x99, + 0x4F, 0xE6, 0xD9, 0xBE, 0xCA, 0xE3, 0x87, 0x1E + }, + { + 0xE3, 0x29, 0xE1, 0x49, 0x9C, 0x77, 0x84, 0xC0, + 0xCA, 0x87, 0xBF, 0xF5, 0x62, 0x8D, 0x74, 0x96, + 0x1E, 0x27, 0xE5, 0xFA, 0x48, 0x94, 0x6B, 0xCF, + 0x68, 0x58, 0xA4, 0xD3, 0x35, 0x83, 0xA9, 0x75, + 0x05, 0x51, 0x1C, 0xB2, 0x97, 0x6D, 0x30, 0xED, + 0x12, 0xBD, 0x1D, 0x27, 0x35, 0x35, 0x5F, 0x57, + 0xE1, 0xB1, 0x97, 0x00, 0xA3, 0xCB, 0xBD, 0x55, + 0x1E, 0x83, 0x0A, 0xF3, 0x60, 0x9E, 0x37, 0x25 + }, + { + 0xB2, 0xFE, 0xFF, 0xBF, 0x5C, 0x7E, 0x48, 0x04, + 0x2F, 0xAB, 0xAA, 0xA0, 0x2E, 0x70, 0xCD, 0x08, + 0x83, 0xBD, 0x3D, 0xA0, 0x7A, 0x77, 0x6A, 0xAC, + 0x3A, 0x1D, 0x23, 0x5A, 0xAB, 0xD5, 0x2E, 0x00, + 0x07, 0xDD, 0x85, 0x63, 0xF2, 0x4D, 0x65, 0xCB, + 0x1B, 0x37, 0x28, 0x5F, 0x22, 0x80, 0x6E, 0x4E, + 0x68, 0x69, 0x3F, 0x4C, 0xF7, 0xD3, 0xE2, 0x2C, + 0xFC, 0x32, 0xE5, 0x26, 0x38, 0x89, 0x94, 0x7B + }, + { + 0xE2, 0xA7, 0x99, 0x85, 0x12, 0x6D, 0x40, 0x4A, + 0x4B, 0x63, 0x0F, 0xA8, 0xC2, 0x5A, 0x24, 0x89, + 0x99, 0x08, 0xA1, 0x1E, 0xE0, 0x69, 0x32, 0xAA, + 0xF0, 0x77, 0xED, 0x99, 0x08, 0x3C, 0x22, 0x83, + 0xA4, 0x0C, 0xBB, 0x45, 0xE5, 0xEE, 0x2A, 0xE9, + 0x17, 0x18, 0x81, 0x46, 0xC5, 0x77, 0x60, 0x3C, + 0xCE, 0xD6, 0x15, 0x93, 0xF8, 0x8A, 0xB1, 0xCA, + 0xF9, 0x71, 0x13, 0xAF, 0x7F, 0xF9, 0x9A, 0x36 + }, + { + 0x2A, 0x78, 0x15, 0x37, 0x55, 0xEA, 0x2A, 0x54, + 0xB8, 0xA6, 0x35, 0x32, 0x19, 0x49, 0x1D, 0xAB, + 0xEE, 0x7C, 0x31, 0x44, 0x6E, 0xD3, 0x01, 0x0A, + 0x55, 0x7C, 0xA8, 0x2C, 0x0E, 0xE4, 0xD3, 0xE7, + 0x51, 0x39, 0x84, 0xD3, 0xD0, 0x05, 0x5B, 0xB7, + 0x28, 0xF3, 0xB6, 0x24, 0x3B, 0x48, 0xC3, 0xD7, + 0x15, 0x1B, 0xB4, 0xF8, 0xAA, 0x10, 0x8A, 0x0F, + 0xF6, 0x47, 0x0D, 0xDC, 0x51, 0xE6, 0x7D, 0x36 + }, + { + 0x16, 0x48, 0x15, 0x1D, 0xF3, 0xDA, 0x98, 0xFC, + 0xD0, 0x4C, 0xE2, 0x9D, 0x16, 0xD0, 0xFE, 0xC6, + 0x4C, 0x87, 0xE8, 0x0A, 0x45, 0x32, 0x21, 0xB0, + 0x6F, 0x35, 0xA7, 0x76, 0xB4, 0xA9, 0xD3, 0xE6, + 0x38, 0x94, 0x6B, 0xDD, 0x50, 0xEE, 0x6A, 0xAB, + 0x0F, 0x1F, 0x09, 0x81, 0xBE, 0xA8, 0x63, 0x00, + 0x79, 0x1C, 0x39, 0xD1, 0xA1, 0x35, 0x61, 0x4A, + 0xBF, 0x22, 0xA5, 0x7B, 0x36, 0xBA, 0xC3, 0x66 + }, + { + 0x7D, 0x62, 0x3C, 0x8F, 0x2A, 0x06, 0x45, 0xBB, + 0x48, 0x25, 0x75, 0x68, 0xD1, 0xA7, 0xB7, 0xC9, + 0xFB, 0x80, 0x1A, 0x15, 0x10, 0x56, 0x3C, 0x1F, + 0x1A, 0xBD, 0x23, 0x52, 0xB5, 0x78, 0xF6, 0xFF, + 0x2F, 0x82, 0x08, 0x91, 0xF3, 0x8B, 0x5F, 0x56, + 0xBA, 0xF0, 0x89, 0x72, 0x92, 0xE0, 0x5E, 0x02, + 0xBF, 0xBB, 0xA8, 0xA3, 0x36, 0xAB, 0x95, 0x5D, + 0x85, 0x7F, 0xAB, 0xFF, 0xD8, 0x9F, 0x58, 0xB9 + }, + { + 0xEE, 0x7B, 0x3D, 0x8C, 0x71, 0x6E, 0xE5, 0xFF, + 0x10, 0x27, 0x46, 0x0B, 0xBF, 0x0D, 0x71, 0xB3, + 0x88, 0xAA, 0x31, 0x57, 0x05, 0x90, 0xA2, 0x11, + 0x98, 0x85, 0x46, 0x7F, 0x93, 0x3D, 0x28, 0x92, + 0x50, 0x05, 0x65, 0x4A, 0x1B, 0x29, 0x9D, 0xFB, + 0x57, 0xAA, 0xB4, 0x61, 0xD7, 0xE1, 0xC0, 0x3E, + 0xD5, 0x49, 0xE3, 0x19, 0xB1, 0xF7, 0x87, 0x4C, + 0x49, 0x59, 0xB7, 0x22, 0x2E, 0xBA, 0x7E, 0x65 + }, + { + 0x4E, 0xA4, 0x45, 0x12, 0x89, 0xD3, 0x54, 0x44, + 0x90, 0x15, 0x30, 0xDB, 0x4A, 0x22, 0xA2, 0xF4, + 0x52, 0x3B, 0x0D, 0x65, 0xDF, 0x1D, 0x34, 0x8C, + 0x33, 0x8F, 0xD9, 0xFD, 0xF6, 0x88, 0xB7, 0x38, + 0x00, 0xF9, 0x14, 0x0D, 0x10, 0x44, 0xBB, 0x76, + 0x3E, 0xA4, 0xD0, 0x48, 0xC6, 0xC9, 0x02, 0xC4, + 0xF0, 0x56, 0x40, 0x73, 0x88, 0x9C, 0x1E, 0xEC, + 0xF2, 0x2F, 0x39, 0x74, 0x83, 0xC7, 0x4C, 0xD4 + }, + { + 0xE9, 0x73, 0x03, 0x9E, 0x6D, 0x93, 0x51, 0x5C, + 0xC6, 0x2C, 0x84, 0x29, 0x56, 0x5F, 0xFA, 0x8C, + 0xB1, 0xEE, 0x31, 0x23, 0xD3, 0xE5, 0xBD, 0x8F, + 0xE6, 0x7F, 0xE7, 0x82, 0xB1, 0x00, 0xD6, 0xFE, + 0xE6, 0x61, 0x29, 0x9E, 0xE2, 0x1C, 0x9A, 0x99, + 0x39, 0x29, 0xD4, 0x68, 0x94, 0x1B, 0xFA, 0x95, + 0x26, 0x0F, 0x89, 0x37, 0xE7, 0x6F, 0xF7, 0x96, + 0x40, 0xDA, 0x7A, 0xA9, 0x7E, 0xD6, 0xE2, 0x65 + }, + { + 0x10, 0x7E, 0x9F, 0xA8, 0xA7, 0x36, 0xB6, 0xDD, + 0xB5, 0x0D, 0xD2, 0xE8, 0x0A, 0x88, 0xC3, 0xD4, + 0xE3, 0xE8, 0x1E, 0x0D, 0x3A, 0xFE, 0xFD, 0xA0, + 0x1D, 0x1B, 0x99, 0x07, 0x7D, 0xEB, 0xA3, 0xB2, + 0xC9, 0x3C, 0x85, 0xA9, 0xD4, 0xAF, 0xF8, 0xD3, + 0xFD, 0xC8, 0xC3, 0xB6, 0xDA, 0x14, 0xF2, 0x5A, + 0x97, 0x45, 0x6F, 0x2B, 0xA6, 0x65, 0x60, 0x34, + 0x9C, 0x28, 0x48, 0xEB, 0x7C, 0xDE, 0x60, 0x18 + }, + { + 0xD7, 0x75, 0x8E, 0xD0, 0xD6, 0x6B, 0xD1, 0x83, + 0x21, 0xD9, 0x90, 0xD2, 0x68, 0x49, 0x9C, 0xEF, + 0xB4, 0xD9, 0x27, 0x88, 0x85, 0x6B, 0xE1, 0x65, + 0x00, 0xCF, 0x6E, 0xF3, 0x18, 0xA2, 0xF6, 0xC3, + 0xA2, 0x1A, 0x07, 0x15, 0x11, 0xDD, 0x66, 0x2A, + 0x68, 0x92, 0xE1, 0x35, 0x3F, 0x6C, 0x65, 0xBB, + 0xCE, 0x40, 0xCA, 0x32, 0x1E, 0x75, 0x9A, 0xCB, + 0xCF, 0xE9, 0x02, 0xC8, 0x00, 0x2B, 0x25, 0x70 + }, + { + 0xF2, 0x9C, 0xC1, 0xB5, 0xF8, 0x88, 0x88, 0x0C, + 0x09, 0x4F, 0x84, 0x43, 0xF3, 0x73, 0xA1, 0xAC, + 0xCB, 0x26, 0x11, 0x36, 0xA5, 0x59, 0x05, 0xCB, + 0x43, 0x11, 0x0E, 0xE7, 0xBA, 0xAE, 0xBF, 0x89, + 0x7C, 0x83, 0x44, 0xBA, 0x26, 0x6C, 0x8F, 0x6C, + 0x95, 0x15, 0x64, 0x07, 0x41, 0x1F, 0xF4, 0x53, + 0x89, 0x45, 0x2A, 0x87, 0xCE, 0x75, 0x29, 0xFF, + 0xE8, 0x34, 0x96, 0xC5, 0x27, 0x04, 0x65, 0xB6 + }, + { + 0xA8, 0x79, 0xF3, 0x52, 0x41, 0xEB, 0xC0, 0xAE, + 0xA9, 0x7A, 0x41, 0x84, 0x1E, 0x85, 0x2B, 0x98, + 0x4A, 0x85, 0xAA, 0x11, 0xE0, 0x35, 0xE1, 0x71, + 0xA3, 0x2A, 0x10, 0x5D, 0xFC, 0xB4, 0x12, 0xA8, + 0x06, 0xEE, 0x69, 0x6A, 0x9B, 0x96, 0x73, 0x7D, + 0x07, 0x2D, 0xF5, 0x12, 0x6B, 0xEF, 0x8C, 0x05, + 0x38, 0x2B, 0x90, 0x3E, 0x57, 0x8B, 0x1B, 0xC5, + 0x47, 0xC3, 0x5F, 0x20, 0xF7, 0x10, 0x7E, 0x59 + }, + { + 0x49, 0xBF, 0x07, 0x9E, 0x39, 0xC2, 0x19, 0xC8, + 0x02, 0x8D, 0x6E, 0x6E, 0x8B, 0x9B, 0x22, 0xB4, + 0xA3, 0xF4, 0x2F, 0x9E, 0x78, 0xE9, 0x2C, 0xD5, + 0x51, 0xFA, 0x29, 0xD2, 0x28, 0xBF, 0xBE, 0xB7, + 0x27, 0x88, 0x70, 0x98, 0xD1, 0x8C, 0x62, 0x35, + 0x10, 0x52, 0xA9, 0xF6, 0x64, 0x25, 0xFA, 0x6F, + 0xD8, 0xD5, 0x86, 0x2D, 0xE2, 0x52, 0xFB, 0x3A, + 0x8C, 0x31, 0xEE, 0xFA, 0xEC, 0xAF, 0xCD, 0x43 + }, + { + 0xC4, 0x50, 0x37, 0x39, 0xC2, 0x9D, 0x09, 0x8B, + 0x75, 0xFE, 0x8C, 0xDF, 0xEB, 0x9A, 0xBA, 0x06, + 0xDB, 0xB8, 0x43, 0xCD, 0xDF, 0x8D, 0x37, 0x75, + 0xA2, 0x77, 0xB3, 0xB0, 0x1A, 0x40, 0x15, 0xBA, + 0xD5, 0xEA, 0x7E, 0xDB, 0xB0, 0x45, 0xFD, 0x98, + 0x72, 0xDD, 0x1D, 0x30, 0x27, 0xED, 0x9C, 0x0E, + 0xF9, 0xE5, 0x82, 0xBF, 0xA9, 0x7F, 0x8B, 0x55, + 0x0A, 0xE4, 0x9F, 0x5A, 0xA5, 0x2D, 0xB3, 0xD4 + }, + { + 0x54, 0x3B, 0x37, 0x4E, 0x55, 0xAA, 0xF4, 0xE3, + 0x36, 0xBE, 0x1C, 0x6D, 0xD8, 0x86, 0xF8, 0xC8, + 0x36, 0xAE, 0x29, 0x93, 0xFA, 0xE5, 0x29, 0x3E, + 0x6F, 0xFD, 0xBA, 0x7C, 0x1A, 0x5F, 0xA7, 0x02, + 0x5E, 0x20, 0x5F, 0x3C, 0x43, 0x39, 0x3B, 0x89, + 0xC7, 0x5E, 0x28, 0xDD, 0x42, 0x2B, 0xAD, 0x05, + 0x8B, 0xAA, 0xCB, 0xC3, 0x18, 0x10, 0x59, 0x50, + 0x13, 0x5B, 0x18, 0xAF, 0xFC, 0xD3, 0x36, 0x75 + }, + { + 0x0E, 0x3F, 0xD2, 0x0F, 0x0B, 0xCD, 0x9D, 0x27, + 0xA0, 0xB1, 0x3D, 0xBA, 0x16, 0x80, 0xCD, 0x6D, + 0x3D, 0x69, 0x85, 0xC5, 0x1B, 0x97, 0xC9, 0x7B, + 0xD6, 0x0E, 0xF0, 0xEE, 0xF5, 0xC2, 0xDB, 0x71, + 0xAD, 0xFD, 0x44, 0x88, 0x9F, 0xBD, 0x57, 0x78, + 0x78, 0x88, 0xC3, 0x83, 0xA7, 0xD5, 0xFB, 0xF1, + 0x49, 0x25, 0x3A, 0x74, 0x93, 0x81, 0xF0, 0x10, + 0x33, 0xA1, 0x3B, 0x77, 0x9C, 0xBD, 0xEF, 0xCF + }, + { + 0x51, 0x38, 0x00, 0xD9, 0x40, 0x64, 0xB5, 0x9A, + 0xA4, 0xB5, 0x90, 0x7D, 0x74, 0x1B, 0xBF, 0x5D, + 0x33, 0xBF, 0x0E, 0x6C, 0xBC, 0x0A, 0x39, 0xF0, + 0x5C, 0xCC, 0x9C, 0x1F, 0x01, 0x51, 0x33, 0x7C, + 0x6A, 0xA6, 0xF8, 0x01, 0xB3, 0xC5, 0xC4, 0x28, + 0x85, 0x5C, 0x5B, 0x93, 0xAD, 0x76, 0x8E, 0xD2, + 0x6A, 0x29, 0xCD, 0x9C, 0xEB, 0x52, 0x14, 0x3A, + 0xE9, 0x53, 0xE1, 0x8D, 0x00, 0x2F, 0x1E, 0xCF + }, + { + 0x83, 0x20, 0xAB, 0x5E, 0xA6, 0x8D, 0xB7, 0x07, + 0xB9, 0x32, 0xDF, 0x60, 0xF6, 0x9F, 0xB6, 0x43, + 0xCE, 0xE7, 0x93, 0x7C, 0x5C, 0x7A, 0xE2, 0x0B, + 0x44, 0x28, 0x2A, 0x12, 0x7E, 0xF0, 0x30, 0xA3, + 0xD5, 0x79, 0xAC, 0x30, 0x2B, 0x1C, 0x6C, 0xE2, + 0x20, 0xBC, 0x7A, 0xCC, 0xD6, 0x41, 0x2E, 0xD7, + 0x48, 0x97, 0x11, 0x75, 0xA8, 0x3F, 0xFC, 0x9B, + 0xE4, 0xB7, 0x0C, 0x3A, 0x3F, 0x2F, 0xA5, 0xA8 + }, + { + 0x16, 0x55, 0x93, 0x7F, 0x02, 0xB7, 0x4B, 0xFE, + 0xE9, 0x2C, 0x58, 0xE6, 0xE0, 0xCB, 0xE6, 0xF9, + 0x8F, 0xD1, 0x7B, 0x58, 0x83, 0x55, 0x95, 0xFC, + 0xA0, 0xD4, 0x00, 0xEF, 0x46, 0x4D, 0x73, 0x39, + 0xC0, 0xC4, 0x35, 0x5E, 0xD9, 0x72, 0xBE, 0xAE, + 0xD9, 0x5E, 0x78, 0xFC, 0x9F, 0x7E, 0xEA, 0x5F, + 0x68, 0xA6, 0x2A, 0xA3, 0xC2, 0x29, 0xA8, 0xF1, + 0x94, 0x45, 0xF9, 0x0E, 0x45, 0x97, 0xCB, 0x8D + }, + { + 0x2B, 0x43, 0x95, 0x5A, 0xFE, 0xC8, 0x13, 0x8A, + 0x0F, 0x06, 0x29, 0xD3, 0x95, 0xB2, 0x02, 0x0E, + 0x2C, 0xD5, 0x50, 0xF5, 0x92, 0x51, 0x48, 0xE4, + 0x05, 0x4F, 0xA6, 0x0C, 0x52, 0x50, 0x27, 0x1D, + 0xBA, 0x35, 0x33, 0x0B, 0xCF, 0x24, 0x4D, 0x10, + 0x55, 0xC2, 0xA4, 0x36, 0x09, 0xA1, 0xCE, 0xFF, + 0xCF, 0x02, 0x7B, 0xAA, 0x5F, 0xC2, 0x1F, 0xFA, + 0xD8, 0x52, 0xA5, 0xC6, 0xD6, 0x5F, 0x5F, 0x8E + }, + { + 0x28, 0x2A, 0x2A, 0x43, 0x2D, 0x7F, 0x6A, 0x1D, + 0x96, 0xA3, 0xF7, 0xDB, 0x92, 0xD6, 0xC5, 0xF5, + 0xBD, 0x57, 0x52, 0xD7, 0xCB, 0xB4, 0x94, 0x91, + 0x05, 0x5B, 0x30, 0xE0, 0x9A, 0x6D, 0x6D, 0xF1, + 0x9F, 0x66, 0x81, 0xB8, 0xDA, 0x61, 0x82, 0x9C, + 0xBA, 0x8D, 0xEF, 0xA9, 0x5F, 0xAF, 0x21, 0x63, + 0x5B, 0x32, 0x9E, 0x6C, 0x31, 0x78, 0x4E, 0xC2, + 0xF6, 0x4E, 0x7F, 0xED, 0x79, 0xB1, 0x55, 0x16 + }, + { + 0xDD, 0x46, 0x62, 0x36, 0x93, 0x7E, 0xB9, 0xD7, + 0xCF, 0x01, 0x4F, 0x3E, 0xDE, 0x78, 0x02, 0x90, + 0x7D, 0xAE, 0xF3, 0x65, 0xAE, 0x7B, 0x4B, 0x00, + 0xD8, 0xB4, 0x74, 0x0B, 0x16, 0xA9, 0x96, 0x27, + 0x7E, 0xB9, 0x2F, 0x9B, 0x77, 0xA9, 0xFE, 0xC5, + 0xFE, 0x54, 0x70, 0xEE, 0x9A, 0xC0, 0xEB, 0x17, + 0xE2, 0xD2, 0x74, 0x21, 0x2B, 0xA3, 0x85, 0x5D, + 0x58, 0x03, 0x3C, 0x4A, 0x94, 0x85, 0x03, 0x35 + }, + { + 0xC6, 0xD8, 0x45, 0x70, 0x00, 0x50, 0x5B, 0x3E, + 0xEF, 0xCB, 0xAA, 0x88, 0x2E, 0x33, 0x7C, 0xB3, + 0xD2, 0x7B, 0x35, 0xE5, 0x44, 0x54, 0x3F, 0xAA, + 0xA6, 0xD1, 0x7D, 0x3C, 0x75, 0x6A, 0x2C, 0x6B, + 0x1F, 0x52, 0x04, 0xD1, 0x9C, 0xC4, 0x9A, 0xEA, + 0x47, 0xFA, 0x73, 0xB1, 0x62, 0x9E, 0x04, 0x0F, + 0x4A, 0x90, 0x39, 0xB2, 0x70, 0x24, 0x26, 0x73, + 0xE7, 0x22, 0x24, 0x88, 0x3F, 0xC4, 0xB6, 0xFD + }, + { + 0xB6, 0x13, 0x67, 0xE7, 0xE8, 0x79, 0x9C, 0xA1, + 0xAF, 0x2E, 0xEF, 0x8D, 0x99, 0xC2, 0xE1, 0x6E, + 0x6B, 0x57, 0x51, 0x48, 0x45, 0xAA, 0x2E, 0x5C, + 0xFD, 0xB3, 0x23, 0x83, 0xDE, 0x31, 0xDA, 0x38, + 0xBF, 0xF3, 0x2C, 0x1F, 0x5A, 0xF8, 0x64, 0x65, + 0x5E, 0xEC, 0x51, 0xB5, 0x4B, 0x1C, 0xA7, 0x15, + 0x2D, 0x95, 0xB7, 0x12, 0x7C, 0x15, 0xDE, 0x4F, + 0xB9, 0x0F, 0x1D, 0x22, 0x95, 0x50, 0x18, 0x13 + }, + { + 0xD4, 0x75, 0x4B, 0xB5, 0x5A, 0xE3, 0x93, 0xF9, + 0x71, 0xF1, 0xF0, 0xC6, 0xA0, 0x75, 0xD9, 0x29, + 0x5F, 0xDF, 0x1E, 0xDF, 0x14, 0xDE, 0x37, 0x4C, + 0xC1, 0xDA, 0x6F, 0x72, 0x24, 0x3C, 0x17, 0xDD, + 0xA4, 0x44, 0xC2, 0x77, 0x65, 0xF0, 0x97, 0x40, + 0x44, 0xDB, 0xA9, 0x02, 0x3F, 0x02, 0xD1, 0x6D, + 0x8A, 0xC7, 0x8D, 0xCE, 0x0B, 0x7A, 0x9F, 0x03, + 0x7E, 0xCA, 0x14, 0xD3, 0x4A, 0xF9, 0x7C, 0x36 + }, + { + 0x70, 0x26, 0x40, 0x1F, 0x0B, 0x36, 0x60, 0x48, + 0xCD, 0x8B, 0x13, 0x69, 0xEC, 0x5D, 0xFF, 0x24, + 0xD4, 0x50, 0xAD, 0x26, 0x58, 0x30, 0xE8, 0x11, + 0x6D, 0x0B, 0x49, 0x27, 0x9A, 0x97, 0x4C, 0x8B, + 0xA8, 0xD6, 0xE5, 0x18, 0xBF, 0xCA, 0xD0, 0xCD, + 0x9E, 0xBA, 0x5C, 0x50, 0x04, 0xC4, 0x46, 0xD9, + 0xFC, 0x91, 0x98, 0xBD, 0xF0, 0xF9, 0x30, 0xC5, + 0x1D, 0xD5, 0x84, 0x18, 0x12, 0xA8, 0x5D, 0x9C + }, + { + 0x63, 0x66, 0xE4, 0x20, 0x2D, 0x2A, 0x0A, 0x0A, + 0x0E, 0x49, 0x2C, 0x6C, 0xAF, 0x33, 0x69, 0x11, + 0xF7, 0x5D, 0x0E, 0x1F, 0x5F, 0x77, 0x31, 0xF4, + 0x3E, 0x3D, 0x9B, 0x2C, 0x6F, 0xE1, 0xF7, 0x23, + 0x3E, 0x11, 0x70, 0x99, 0x57, 0x05, 0x33, 0x85, + 0xAD, 0xC5, 0x08, 0xA6, 0x2C, 0x4B, 0x16, 0x63, + 0x61, 0x47, 0xDC, 0xEE, 0x33, 0xE2, 0xF8, 0xD8, + 0x3D, 0x2D, 0xB7, 0xEC, 0x3B, 0xED, 0xB6, 0x97 + }, + { + 0xF4, 0x53, 0xFE, 0xB1, 0xDE, 0xD5, 0x4F, 0x59, + 0x91, 0x3B, 0xDE, 0x70, 0xB5, 0x63, 0x2C, 0x51, + 0x0C, 0x5B, 0x4C, 0x67, 0xA6, 0xC9, 0xAA, 0x3A, + 0xD9, 0xB8, 0x97, 0xEF, 0x86, 0x8E, 0xB7, 0x87, + 0x66, 0x11, 0x75, 0x13, 0x54, 0x23, 0xC3, 0x82, + 0xD3, 0x9A, 0x5B, 0x2D, 0x33, 0x65, 0x22, 0xCE, + 0x3B, 0x58, 0x83, 0x06, 0xBD, 0x98, 0xD0, 0x13, + 0x1E, 0xB2, 0xC9, 0xB8, 0x33, 0xAA, 0x8D, 0xB2 + }, + { + 0xA2, 0x9C, 0xBC, 0x7B, 0xFB, 0x56, 0x66, 0xE2, + 0xCC, 0xDE, 0x0F, 0x35, 0xA6, 0xD8, 0x48, 0x90, + 0x92, 0xED, 0x39, 0xB1, 0xF6, 0xF5, 0x76, 0x27, + 0x43, 0x8B, 0xFD, 0xFD, 0xB7, 0x6E, 0x43, 0x8F, + 0xE4, 0x1A, 0xAA, 0xE5, 0xE5, 0x35, 0x12, 0x94, + 0x0F, 0x5E, 0x7E, 0x1F, 0xCA, 0xBA, 0x6E, 0x57, + 0x25, 0xD9, 0x86, 0x99, 0x7C, 0xEE, 0x98, 0x2A, + 0x33, 0x7A, 0x34, 0x7D, 0x39, 0x1F, 0xB0, 0x8C + }, + { + 0x2A, 0xAE, 0xB4, 0xB7, 0xCF, 0x69, 0x49, 0x57, + 0x06, 0x86, 0xA9, 0x8E, 0x0D, 0x00, 0x97, 0xB8, + 0x55, 0x5A, 0x0A, 0xF2, 0xC8, 0x52, 0x6E, 0xE9, + 0xD3, 0xED, 0x60, 0x56, 0x73, 0x39, 0x32, 0xA1, + 0x22, 0x9F, 0x76, 0xBE, 0xDF, 0x60, 0x23, 0x40, + 0x4D, 0xAC, 0x65, 0xDE, 0xC7, 0x7C, 0x42, 0x0A, + 0xB6, 0x50, 0x6A, 0xF5, 0x93, 0x1A, 0xE4, 0x31, + 0x6B, 0x08, 0xA4, 0x18, 0x81, 0x65, 0x16, 0xAB + }, + { + 0x8F, 0xD7, 0xE0, 0xB9, 0xBE, 0x81, 0x57, 0xC9, + 0x98, 0x64, 0x75, 0x41, 0x2C, 0x2D, 0x73, 0xA9, + 0xDA, 0x32, 0x0F, 0xB0, 0x6B, 0x9E, 0xAB, 0x0A, + 0x1E, 0xD4, 0x99, 0xE2, 0xCF, 0xB9, 0xC9, 0x46, + 0x98, 0x50, 0xC4, 0x49, 0x1E, 0xBB, 0x07, 0x2C, + 0xE4, 0xEE, 0xEE, 0xDC, 0x37, 0xAA, 0xB8, 0x0E, + 0xA2, 0xD6, 0x9A, 0xDE, 0x0B, 0xB7, 0x35, 0x99, + 0x42, 0x8E, 0xB6, 0x84, 0xFB, 0x8C, 0xDD, 0x07 + }, + { + 0xA5, 0xD7, 0x45, 0x18, 0xFF, 0x65, 0xEB, 0x5C, + 0x6D, 0x12, 0x78, 0x1E, 0xAC, 0x61, 0x12, 0xA0, + 0x9A, 0x85, 0xF2, 0xDE, 0x23, 0x56, 0x0C, 0x00, + 0x81, 0xC2, 0x31, 0x65, 0xB7, 0x3A, 0x1A, 0xB2, + 0x90, 0xF3, 0x02, 0x08, 0x36, 0x26, 0xA1, 0x05, + 0xF9, 0x4B, 0x6E, 0xAF, 0x4B, 0x97, 0x6D, 0x52, + 0xBC, 0x16, 0xEB, 0x5E, 0x2A, 0x63, 0x25, 0x94, + 0xC2, 0x73, 0x6D, 0x04, 0xE6, 0x05, 0x4C, 0x35 + }, + { + 0xF8, 0x2A, 0x59, 0x50, 0x9A, 0xF9, 0x76, 0x7C, + 0xFB, 0x22, 0xD7, 0x27, 0xD7, 0x2B, 0xEC, 0x85, + 0x3E, 0x13, 0xCF, 0x9C, 0xBD, 0x71, 0xAB, 0x2E, + 0xD5, 0x2A, 0x9D, 0x17, 0xEC, 0xEA, 0xE0, 0xFC, + 0x90, 0x10, 0xDF, 0xDA, 0xB3, 0xC4, 0x88, 0xA2, + 0x58, 0x8C, 0xB5, 0x3D, 0xDA, 0x08, 0xF7, 0xA5, + 0xA8, 0x9D, 0x5C, 0x66, 0x50, 0x6E, 0x13, 0xED, + 0x96, 0xA5, 0x85, 0x7A, 0xCE, 0xED, 0xA7, 0x6F + }, + { + 0x54, 0x21, 0x2C, 0x04, 0xDC, 0xD3, 0xCD, 0x0A, + 0x10, 0x53, 0x8C, 0x3D, 0xD6, 0xF0, 0x32, 0x82, + 0x90, 0x2C, 0x42, 0x09, 0xF0, 0xD3, 0x26, 0x1E, + 0x4E, 0xD3, 0x6E, 0xFC, 0xDD, 0x17, 0xC9, 0xCB, + 0x9E, 0x9C, 0xB1, 0x58, 0x7C, 0x1C, 0xF5, 0xE6, + 0xDB, 0x70, 0x31, 0xCF, 0xB9, 0x82, 0xE8, 0x82, + 0xA9, 0xE3, 0xB1, 0xCB, 0x5E, 0xAE, 0x23, 0xED, + 0x04, 0x11, 0xF4, 0x01, 0x6A, 0x3E, 0xB5, 0x75 + }, + { + 0x28, 0x9F, 0x6E, 0x9E, 0x87, 0x6E, 0x96, 0x44, + 0x62, 0x57, 0xB6, 0x04, 0x36, 0x67, 0x15, 0x2B, + 0x35, 0x0D, 0x28, 0xC3, 0x9D, 0x8C, 0x9B, 0x53, + 0x62, 0x52, 0x73, 0x8E, 0x9C, 0x7A, 0x02, 0x95, + 0x68, 0xE0, 0x83, 0x21, 0xAF, 0x91, 0xA5, 0x8A, + 0x91, 0xC4, 0xCE, 0xF9, 0x13, 0x4C, 0xEF, 0xCC, + 0x5F, 0x36, 0x15, 0x3A, 0xC0, 0xC2, 0xAB, 0x33, + 0xAD, 0x35, 0xDC, 0x41, 0x32, 0x11, 0xA5, 0x3D + }, + { + 0xEB, 0xC0, 0xCF, 0xE4, 0x0F, 0x71, 0xA6, 0x26, + 0x7D, 0x69, 0x92, 0xB6, 0xBF, 0x3B, 0x21, 0x77, + 0xE2, 0xCA, 0x54, 0x58, 0x79, 0xAC, 0x61, 0x1D, + 0x82, 0xB8, 0x20, 0xCA, 0xFB, 0x77, 0x9A, 0x76, + 0x5F, 0x0F, 0xE3, 0xFD, 0x31, 0x5F, 0xD0, 0x93, + 0xFA, 0x0A, 0x96, 0x09, 0x3C, 0x83, 0x2E, 0xA6, + 0x79, 0x21, 0x36, 0xA4, 0x19, 0xA3, 0x4C, 0xCA, + 0x61, 0xEB, 0xB8, 0xE9, 0xDF, 0xE1, 0xC7, 0x98 + }, + { + 0x4F, 0x1A, 0xD2, 0x8C, 0xAF, 0x73, 0xEA, 0xE9, + 0x92, 0x29, 0xF0, 0xDA, 0xD0, 0x34, 0x52, 0x9B, + 0x65, 0xFF, 0x68, 0x61, 0xBC, 0x14, 0x4C, 0xD2, + 0xA4, 0x67, 0x50, 0x4D, 0x5A, 0xD8, 0x32, 0xBD, + 0x43, 0x72, 0xA3, 0x63, 0x5F, 0xD9, 0x02, 0x93, + 0x4F, 0xC8, 0x20, 0x62, 0x66, 0x42, 0xB4, 0xC8, + 0xD6, 0x20, 0xFC, 0x86, 0x30, 0x60, 0x38, 0x00, + 0xBC, 0xFC, 0x4C, 0xDF, 0xC7, 0xED, 0x2C, 0x7A + }, + { + 0xC5, 0x2D, 0x8D, 0xC3, 0xD7, 0x31, 0x34, 0x38, + 0x5B, 0x4B, 0xC9, 0x1F, 0x85, 0xE8, 0xCD, 0xCF, + 0x78, 0x52, 0x38, 0xFB, 0x35, 0xB0, 0x5F, 0x37, + 0xE5, 0x8C, 0x9F, 0x2C, 0x23, 0xB9, 0xC1, 0x25, + 0xFA, 0x92, 0x42, 0x59, 0xEF, 0x5F, 0xB5, 0x85, + 0x83, 0xE2, 0xE3, 0x4B, 0x73, 0xEB, 0x85, 0x7E, + 0xEE, 0x24, 0x2F, 0xD6, 0x94, 0x94, 0xBD, 0xEF, + 0x3B, 0xCF, 0x2B, 0xDD, 0x3B, 0x62, 0xD9, 0xD0 + }, + { + 0x7A, 0x5B, 0x2D, 0x5B, 0x2B, 0xA5, 0x69, 0x7A, + 0xC2, 0x4F, 0xFD, 0x17, 0xEC, 0xEF, 0x47, 0xB3, + 0x5E, 0xC0, 0x97, 0xB4, 0xC5, 0x48, 0xE5, 0x19, + 0x85, 0x78, 0xFE, 0x98, 0x9D, 0xFF, 0x28, 0x75, + 0x44, 0xF0, 0xF3, 0x01, 0x48, 0x5C, 0x4D, 0xCC, + 0xF7, 0xAB, 0x25, 0x95, 0xAD, 0xAC, 0xFC, 0x2C, + 0xBA, 0x58, 0x90, 0x68, 0x48, 0x51, 0x28, 0xE1, + 0x73, 0x01, 0x2F, 0x61, 0x75, 0x43, 0xE2, 0xD6 + }, + { + 0x1B, 0x1F, 0x93, 0xEE, 0xF1, 0xB3, 0x6A, 0x80, + 0x0A, 0x65, 0xEE, 0x4E, 0x8A, 0x4B, 0xA1, 0x19, + 0x6F, 0x9A, 0x99, 0x1B, 0x1C, 0x87, 0xF3, 0x30, + 0x67, 0x13, 0xA8, 0x5D, 0xC6, 0xC5, 0x82, 0x40, + 0x0A, 0x65, 0x15, 0x3F, 0x23, 0x9F, 0xC1, 0x45, + 0x76, 0xB9, 0x84, 0x28, 0x29, 0x6D, 0xE4, 0xC1, + 0x49, 0xD2, 0xFB, 0x2B, 0x1D, 0xF7, 0xB1, 0x56, + 0x73, 0xF7, 0x30, 0x43, 0x5C, 0x6B, 0xA3, 0x20 + }, + { + 0xF2, 0xB7, 0xFA, 0x6E, 0x53, 0x4A, 0x85, 0x28, + 0x37, 0xED, 0xAC, 0xFB, 0xF5, 0xC6, 0xDD, 0xC9, + 0xA9, 0x73, 0x72, 0x9A, 0x3B, 0x59, 0x26, 0xCD, + 0x04, 0x69, 0xB7, 0x97, 0x49, 0x51, 0xD1, 0xDD, + 0x00, 0xA6, 0x29, 0x62, 0xB1, 0xA6, 0x70, 0x77, + 0xE4, 0x08, 0xCE, 0xC0, 0x9B, 0xEC, 0x12, 0xCC, + 0x58, 0xA7, 0x18, 0x62, 0x4B, 0xD1, 0x7B, 0x3E, + 0x60, 0xFF, 0x59, 0xF1, 0x18, 0x81, 0x03, 0xDE + }, + { + 0x39, 0x49, 0x38, 0x45, 0x78, 0xBB, 0x92, 0x94, + 0x26, 0xEC, 0x51, 0xA3, 0x65, 0x2A, 0xC3, 0x68, + 0x4F, 0x00, 0x63, 0x6C, 0xD2, 0x2D, 0x03, 0x81, + 0xC1, 0xEA, 0x07, 0x60, 0x47, 0xD0, 0x77, 0x28, + 0x3E, 0xB4, 0x8E, 0x07, 0xEC, 0x7D, 0x73, 0x7D, + 0xD4, 0xDC, 0x18, 0x23, 0x72, 0x06, 0x9E, 0x8F, + 0xB2, 0x8A, 0x1D, 0x53, 0x7E, 0xED, 0x24, 0x99, + 0x18, 0xBC, 0x24, 0x76, 0x6E, 0x2C, 0x26, 0x3A + }, + { + 0xB2, 0x70, 0x5B, 0x02, 0xC2, 0x82, 0x4D, 0xB7, + 0x24, 0xB0, 0x7B, 0xCB, 0x36, 0xCB, 0x3C, 0x9D, + 0xAF, 0x5A, 0xD0, 0x0E, 0xA1, 0x04, 0x2C, 0x4A, + 0xE3, 0x53, 0xFB, 0x37, 0x4B, 0x3D, 0xE9, 0x86, + 0x7E, 0x1D, 0x2E, 0xE0, 0x7A, 0x5A, 0x25, 0x33, + 0xDD, 0x7F, 0xA3, 0x73, 0xF7, 0x4D, 0xC5, 0x55, + 0xE8, 0x7E, 0x38, 0xFF, 0x3D, 0xEF, 0x75, 0x85, + 0x82, 0xAF, 0xAF, 0x67, 0x20, 0xA3, 0xFD, 0xDC + }, + { + 0x76, 0x7C, 0xF4, 0x59, 0xD7, 0xF5, 0x70, 0xE6, + 0x8D, 0xFA, 0x28, 0xE6, 0xF6, 0x98, 0xB8, 0x07, + 0x46, 0xFB, 0x33, 0x3B, 0x84, 0x29, 0xF4, 0x3A, + 0x7A, 0xAA, 0x44, 0x30, 0x63, 0xC8, 0xB6, 0x6B, + 0x4B, 0x66, 0x21, 0x56, 0x86, 0xC9, 0x9A, 0xEE, + 0x85, 0xF7, 0x4D, 0x30, 0x38, 0xCA, 0xFA, 0x15, + 0x9D, 0xDD, 0xD1, 0xA4, 0x19, 0x6D, 0x76, 0xA5, + 0x2F, 0x71, 0x81, 0x9F, 0xFA, 0x66, 0x10, 0x15 + }, + { + 0xF2, 0x84, 0x53, 0x2D, 0x57, 0xCD, 0x4F, 0x15, + 0xFE, 0x7D, 0xE9, 0xDF, 0x0A, 0xC2, 0x8C, 0x9A, + 0x4B, 0xF6, 0xC2, 0x89, 0x3E, 0x21, 0x9F, 0xB5, + 0xA2, 0xD4, 0x2C, 0x88, 0x0A, 0xE0, 0x60, 0x88, + 0x3E, 0xB0, 0xE9, 0x67, 0xCE, 0xEB, 0xF2, 0x68, + 0xC6, 0x0A, 0x44, 0xA3, 0xBE, 0x04, 0xD7, 0xC0, + 0xD8, 0xA7, 0x6E, 0xA2, 0xAA, 0x61, 0x09, 0xBF, + 0xE5, 0xB0, 0x62, 0x15, 0x16, 0x84, 0x8D, 0xF0 + }, + { + 0x56, 0x8C, 0xF3, 0x3E, 0xF3, 0xBB, 0xB1, 0xB0, + 0x02, 0x83, 0x3C, 0xCE, 0x66, 0x4A, 0x5B, 0x34, + 0x31, 0x6D, 0x05, 0xF9, 0xC5, 0x83, 0x78, 0x83, + 0x5F, 0xF6, 0xB0, 0x36, 0xB9, 0xBB, 0x69, 0x64, + 0x5F, 0x65, 0x92, 0x83, 0xD6, 0x35, 0x9E, 0x83, + 0x7F, 0x64, 0x5E, 0xF0, 0xE2, 0xA3, 0x94, 0x63, + 0x82, 0x7E, 0x99, 0x0A, 0xE1, 0x1D, 0x8D, 0xBC, + 0x3E, 0x09, 0x87, 0x34, 0xBB, 0xC8, 0x40, 0x3B + }, + { + 0xC0, 0x76, 0xCE, 0x1B, 0xC5, 0x05, 0xA9, 0xEB, + 0x88, 0xEF, 0x74, 0x5A, 0x5D, 0x09, 0x54, 0xEA, + 0x30, 0x32, 0x76, 0xE8, 0x03, 0x79, 0x1B, 0xF7, + 0x39, 0x81, 0x7D, 0x6E, 0x16, 0x79, 0xE9, 0x53, + 0xF7, 0xDA, 0x9D, 0x26, 0xF4, 0x67, 0xCF, 0x4A, + 0x80, 0xBC, 0x8D, 0x90, 0x2F, 0x48, 0xA5, 0xD9, + 0x72, 0x4F, 0x27, 0x12, 0x88, 0x25, 0x28, 0x14, + 0xD0, 0x0A, 0x84, 0x9B, 0xF0, 0x12, 0xB0, 0x8D + }, + { + 0xF4, 0x57, 0xDF, 0x0F, 0x2A, 0xE3, 0x93, 0x30, + 0x76, 0x35, 0xF0, 0x96, 0x97, 0xD8, 0x37, 0xFA, + 0xC7, 0x79, 0x56, 0x60, 0x60, 0x30, 0x75, 0x37, + 0x33, 0xCA, 0xA9, 0x15, 0x9C, 0x60, 0x1E, 0x31, + 0xA4, 0x48, 0xE6, 0x0B, 0x1A, 0xB2, 0x71, 0xE0, + 0x09, 0x9D, 0x19, 0x19, 0xA9, 0x39, 0xE1, 0x03, + 0x6B, 0x3F, 0xC8, 0x0B, 0x77, 0x2D, 0x42, 0x16, + 0x64, 0xA0, 0x11, 0x03, 0xC8, 0x1C, 0xE5, 0x78 + }, + { + 0xB7, 0xC0, 0xC0, 0xD2, 0x3E, 0xF7, 0x74, 0x6A, + 0xB7, 0x0E, 0xA3, 0xB1, 0x59, 0x34, 0xCB, 0xB0, + 0x9F, 0x34, 0x9F, 0x7A, 0x07, 0x16, 0x64, 0xAF, + 0x48, 0xA1, 0xF7, 0xAE, 0xCF, 0x46, 0xC1, 0xEE, + 0xE4, 0x41, 0x4B, 0x59, 0xE2, 0xBC, 0x8F, 0x27, + 0x04, 0xB0, 0x1B, 0x89, 0x11, 0x78, 0xAD, 0x3D, + 0xB0, 0xB5, 0x89, 0x8E, 0x7B, 0x4C, 0x0E, 0x36, + 0xAD, 0x22, 0x2D, 0xA5, 0x29, 0x84, 0x78, 0xF7 + }, + { + 0x0D, 0x58, 0xB8, 0x24, 0xBD, 0x80, 0x38, 0x89, + 0x90, 0x2C, 0x38, 0xED, 0xBD, 0xAF, 0x3A, 0xF8, + 0x18, 0xDF, 0x69, 0x6F, 0xD9, 0x77, 0x0E, 0xC1, + 0x53, 0x9B, 0x91, 0x0C, 0x5C, 0xD3, 0xEC, 0x4A, + 0x1A, 0xD6, 0x22, 0x56, 0x73, 0x50, 0xC6, 0xC0, + 0x9F, 0x33, 0x6F, 0xE3, 0xA0, 0x3C, 0x32, 0xE3, + 0x0C, 0xD9, 0xA5, 0x46, 0x95, 0xEC, 0xD7, 0x96, + 0xC4, 0xD8, 0x24, 0x19, 0x80, 0xBD, 0x7D, 0x81 + }, + { + 0xAA, 0x34, 0x39, 0xDB, 0x82, 0x67, 0x65, 0xC8, + 0x5C, 0x42, 0x6E, 0xD6, 0xB9, 0xC8, 0x12, 0x20, + 0xE1, 0x22, 0xC0, 0xE7, 0x89, 0x42, 0x31, 0x96, + 0x5B, 0xD9, 0x05, 0xB2, 0x9A, 0x39, 0x01, 0xAD, + 0x97, 0xC5, 0xD4, 0xDF, 0x76, 0xD7, 0x48, 0x68, + 0xCA, 0x32, 0xDC, 0xD6, 0xA0, 0x4A, 0xDB, 0x23, + 0xB2, 0x84, 0x66, 0xAA, 0xC4, 0xFA, 0x68, 0xF9, + 0x19, 0x8B, 0x41, 0xF7, 0x9A, 0xCF, 0xEC, 0x71 + }, + { + 0xDE, 0x9E, 0x72, 0x7A, 0x22, 0xD1, 0xBB, 0x4C, + 0xC0, 0x52, 0x2D, 0x51, 0xB6, 0xA9, 0x22, 0x7F, + 0xD6, 0xBE, 0x3C, 0xA4, 0xC4, 0x39, 0xAF, 0xF3, + 0xB7, 0xD9, 0x20, 0xEE, 0x54, 0xFE, 0x8B, 0x58, + 0xBB, 0xA2, 0x5D, 0x1F, 0x79, 0x39, 0x1B, 0x94, + 0x25, 0x78, 0x1E, 0xDB, 0x17, 0x37, 0xE9, 0x26, + 0x9A, 0x8C, 0xF6, 0x27, 0x7B, 0x3A, 0x22, 0xC3, + 0xBA, 0xB9, 0x55, 0xA7, 0x9C, 0xA0, 0x18, 0x2A + }, + { + 0xB6, 0x81, 0x8D, 0x13, 0x9F, 0xA0, 0x83, 0xF6, + 0xD2, 0x42, 0xA1, 0x5E, 0x71, 0xD6, 0x2E, 0x20, + 0x8D, 0x53, 0x7D, 0x9A, 0x1B, 0xFE, 0xC4, 0x51, + 0x15, 0x6E, 0xFD, 0xD8, 0xC1, 0xB7, 0x09, 0xA1, + 0x41, 0x87, 0x24, 0xA7, 0x57, 0x61, 0xC4, 0xB2, + 0x91, 0xD1, 0x2B, 0x62, 0x9A, 0x75, 0xA9, 0x7B, + 0x96, 0x38, 0x4D, 0x09, 0x3E, 0x36, 0x14, 0x8F, + 0x90, 0x5D, 0x7E, 0x69, 0x7D, 0xF4, 0xD3, 0xDB + }, + { + 0x6E, 0x2E, 0xD7, 0xB1, 0xAB, 0xF4, 0xD0, 0xFF, + 0x0F, 0x1F, 0x3B, 0x9A, 0x65, 0x30, 0xC0, 0x18, + 0x64, 0x9F, 0xEC, 0xF3, 0x00, 0x1B, 0xBB, 0xBF, + 0x87, 0xD3, 0x69, 0x3C, 0x0A, 0xBC, 0x99, 0x62, + 0xAF, 0xF4, 0xDD, 0x2B, 0x36, 0x50, 0x29, 0xC2, + 0xDC, 0x40, 0xC3, 0xB8, 0xDF, 0x0A, 0x68, 0x66, + 0x9C, 0xC2, 0x7C, 0x6A, 0x34, 0xEB, 0x73, 0xE1, + 0x2D, 0x3F, 0xEC, 0x7F, 0x98, 0x8D, 0xC2, 0x8D + }, + { + 0xE9, 0xA9, 0x97, 0x10, 0x50, 0x63, 0xF4, 0xD2, + 0xD2, 0x28, 0x15, 0x9F, 0x6F, 0x8D, 0xFE, 0xF5, + 0xB3, 0x16, 0xCC, 0x20, 0x4F, 0x16, 0xA4, 0x2A, + 0xA6, 0xFC, 0x3C, 0xAA, 0xFB, 0x76, 0x51, 0xC2, + 0xA2, 0xEE, 0xB9, 0x25, 0x22, 0xBF, 0x03, 0xF5, + 0xA4, 0x67, 0x49, 0xC2, 0x78, 0x30, 0x1D, 0xB2, + 0xDE, 0xE2, 0xB5, 0xB7, 0xFE, 0x1B, 0xE4, 0x4C, + 0xE5, 0x8B, 0x97, 0x45, 0xD7, 0x3D, 0x1E, 0x80 + }, + { + 0x57, 0x39, 0x0E, 0x15, 0xDA, 0x37, 0xE0, 0x2C, + 0xC4, 0x13, 0xDF, 0x62, 0xAA, 0xDE, 0x21, 0x91, + 0xF5, 0x5E, 0xE4, 0xD6, 0xB3, 0x33, 0x22, 0x8F, + 0x0E, 0xD7, 0x09, 0xD6, 0xD2, 0x06, 0xE9, 0x83, + 0x68, 0xAD, 0xA6, 0x13, 0x10, 0xA8, 0xB3, 0x92, + 0x36, 0x2D, 0x04, 0x39, 0xAE, 0x3A, 0x55, 0x92, + 0xE2, 0xF1, 0x6F, 0x97, 0xA9, 0x7B, 0x85, 0x84, + 0x79, 0x04, 0x6D, 0x44, 0x13, 0x7C, 0xE3, 0xAD + }, + { + 0xBD, 0xD9, 0x0F, 0xBA, 0x48, 0x9C, 0xB2, 0x05, + 0x72, 0xE3, 0x00, 0x37, 0xAC, 0xC6, 0x31, 0x0D, + 0x54, 0xEE, 0x1D, 0xF5, 0x83, 0x9F, 0xCC, 0xC4, + 0x42, 0x56, 0x55, 0xF6, 0x66, 0x55, 0xEB, 0x7F, + 0x53, 0x60, 0xE0, 0xC2, 0x94, 0x3D, 0x1A, 0x86, + 0x6B, 0xCA, 0x15, 0x1E, 0xEE, 0xE7, 0xBA, 0x8D, + 0x9F, 0xCB, 0x87, 0x33, 0x81, 0xB9, 0xF0, 0x82, + 0x01, 0xA6, 0xAE, 0xB6, 0xED, 0x9E, 0x0A, 0xAC + }, + { + 0xD5, 0xCD, 0xA3, 0x28, 0x4D, 0x1B, 0x55, 0x64, + 0xF6, 0x37, 0x23, 0x63, 0xB6, 0x24, 0xCE, 0xDD, + 0x3E, 0x70, 0xD8, 0xBA, 0x4F, 0xB9, 0x1E, 0x07, + 0x3B, 0x36, 0x1D, 0x09, 0x3B, 0xC1, 0x47, 0xE8, + 0x11, 0xE4, 0x05, 0xA9, 0xBF, 0x33, 0x95, 0x6D, + 0xFF, 0x92, 0x02, 0x50, 0xE8, 0xBC, 0xA2, 0xE8, + 0x0E, 0xBB, 0x1D, 0xE1, 0x15, 0x64, 0xDB, 0x9D, + 0xAB, 0x3E, 0x63, 0x7D, 0xAB, 0xB9, 0x51, 0xE5 + }, + { + 0xF7, 0x1C, 0xD6, 0xA3, 0x0F, 0x37, 0x35, 0x31, + 0xB3, 0x6F, 0x6A, 0x76, 0xC4, 0xB8, 0x4F, 0x46, + 0xC2, 0xDD, 0xCA, 0x8C, 0x7D, 0x5F, 0x11, 0x9F, + 0xDF, 0x08, 0x52, 0xC6, 0xFC, 0xFD, 0xD3, 0xDE, + 0x07, 0x5B, 0xB5, 0x49, 0xEE, 0x91, 0x06, 0x08, + 0x48, 0xCC, 0xDA, 0x29, 0xCC, 0x08, 0x4E, 0x1A, + 0x7A, 0x6B, 0xF0, 0xD7, 0xF0, 0x1B, 0x29, 0xD8, + 0x4D, 0x44, 0xFE, 0xD9, 0x08, 0x09, 0xF4, 0x8D + }, + { + 0x39, 0x89, 0xA6, 0x7E, 0xC5, 0x76, 0xA2, 0x92, + 0xBC, 0x49, 0x25, 0xD6, 0xFF, 0x2D, 0xE4, 0x7F, + 0x92, 0x0E, 0xBD, 0x56, 0x7A, 0xA5, 0xDA, 0x74, + 0xC4, 0x03, 0x0E, 0x62, 0xE9, 0x9F, 0xF1, 0xC7, + 0xEE, 0xD8, 0xA2, 0x51, 0x46, 0x1D, 0x50, 0x9E, + 0xD2, 0xBF, 0x32, 0xCA, 0xAB, 0xA7, 0x59, 0x93, + 0x50, 0xF0, 0xFB, 0x35, 0x04, 0x45, 0x3D, 0xC6, + 0xAA, 0x29, 0x20, 0x93, 0xA7, 0xCB, 0x89, 0x9F + }, + { + 0x1A, 0xCD, 0xBF, 0xA3, 0x2C, 0x11, 0xDA, 0x37, + 0x2A, 0xE9, 0x62, 0x64, 0x5D, 0xBD, 0xB4, 0xD3, + 0x48, 0xF2, 0x44, 0xEB, 0x72, 0xF8, 0xE9, 0x6A, + 0x2A, 0xA8, 0x25, 0xF0, 0x99, 0x60, 0x16, 0x4C, + 0x53, 0xC7, 0xC7, 0xBD, 0x94, 0xDF, 0x15, 0xFD, + 0x05, 0x83, 0x79, 0xC7, 0xA5, 0xEE, 0x55, 0xDE, + 0xE3, 0xD2, 0x86, 0x49, 0x09, 0x2E, 0x93, 0x47, + 0x90, 0xDB, 0x9E, 0xC2, 0x03, 0xE1, 0x09, 0xF8 + }, + { + 0xBC, 0xBD, 0x6A, 0x31, 0xCA, 0x36, 0x42, 0xDE, + 0x51, 0x29, 0x01, 0x23, 0xC1, 0xF7, 0x2E, 0x2A, + 0x1E, 0xB2, 0x49, 0xFE, 0xED, 0x0C, 0x7D, 0x97, + 0xF2, 0x22, 0x93, 0x6A, 0xB3, 0xF8, 0x38, 0x03, + 0xFD, 0x6E, 0x6F, 0xA3, 0x3C, 0xF7, 0x91, 0xB9, + 0x8C, 0x7F, 0x27, 0xEC, 0x2B, 0xDA, 0x4E, 0x41, + 0x4C, 0xE7, 0x01, 0x2F, 0xE0, 0x6F, 0x47, 0x91, + 0x2B, 0xDA, 0xFC, 0xF2, 0xFE, 0x83, 0x26, 0x20 + }, + { + 0x1F, 0xFE, 0x0B, 0x7F, 0xDE, 0xD3, 0x7B, 0x3E, + 0xDC, 0x0B, 0x99, 0xDF, 0x66, 0xE2, 0x22, 0xD5, + 0x36, 0x15, 0x12, 0x05, 0x48, 0x87, 0xD0, 0xAB, + 0x1A, 0xAE, 0x6C, 0x4F, 0x5B, 0xC3, 0xE8, 0xB2, + 0xD9, 0xAB, 0x2A, 0x7E, 0x26, 0x45, 0x0A, 0x6F, + 0xE0, 0x80, 0x3D, 0xEA, 0x75, 0xB1, 0xE3, 0xA5, + 0xBB, 0x7E, 0x7C, 0xF0, 0x16, 0xA2, 0x3F, 0xF0, + 0x03, 0xF5, 0xA6, 0xC5, 0x5D, 0x54, 0xD3, 0x3F + }, + { + 0x68, 0xEB, 0xEF, 0x82, 0xA6, 0x2E, 0x2C, 0xF8, + 0xF0, 0x02, 0xB7, 0x67, 0x3C, 0x21, 0x23, 0x75, + 0x53, 0xF1, 0x8B, 0x7D, 0x14, 0x5F, 0xE9, 0x4B, + 0xB4, 0x6D, 0xCB, 0x86, 0x73, 0x6E, 0x94, 0xA2, + 0xA2, 0x0E, 0x0F, 0xDE, 0xE8, 0x18, 0xBD, 0x01, + 0x88, 0xE9, 0xA0, 0x2B, 0x60, 0x47, 0x0E, 0x1B, + 0x16, 0x82, 0x0F, 0xD9, 0xDC, 0xE7, 0x1B, 0xB4, + 0xA2, 0x07, 0xCA, 0xA5, 0xC0, 0x5A, 0x7B, 0xD2 + }, + { + 0xEB, 0x57, 0xE3, 0x9B, 0x38, 0x8C, 0x01, 0x85, + 0x38, 0x7B, 0xEE, 0x17, 0xB8, 0x0D, 0x60, 0xA7, + 0xD1, 0x09, 0xD5, 0x56, 0x65, 0x2E, 0x7C, 0x7C, + 0xAC, 0x63, 0xCF, 0xE5, 0xFD, 0x10, 0x2F, 0x24, + 0x61, 0xA3, 0xC5, 0xE9, 0x3F, 0x92, 0xE9, 0x36, + 0x70, 0x2F, 0x5E, 0xEC, 0xBC, 0x26, 0x13, 0x5E, + 0x86, 0x5E, 0xCF, 0x17, 0xAD, 0x26, 0x4F, 0x00, + 0x39, 0x58, 0x0B, 0x7A, 0xCF, 0x3A, 0x31, 0x39 + }, + { + 0xE9, 0x53, 0xB8, 0x63, 0x9C, 0x16, 0xA9, 0x61, + 0xEC, 0xEA, 0xDC, 0xD5, 0xDC, 0x06, 0x13, 0x96, + 0xCF, 0x6A, 0xD8, 0x2A, 0x4A, 0x5F, 0x50, 0xEA, + 0x34, 0x58, 0x30, 0x27, 0x6A, 0x03, 0xE5, 0x70, + 0x89, 0xEE, 0x30, 0x82, 0x09, 0x4D, 0x77, 0x06, + 0x06, 0xBE, 0xC1, 0x00, 0xBC, 0xD7, 0xB9, 0x6E, + 0x1D, 0x5F, 0x68, 0x61, 0xB2, 0xCB, 0x18, 0xA0, + 0xCB, 0x21, 0x2A, 0xC4, 0xAB, 0xEF, 0x84, 0x11 + }, + { + 0x4C, 0xB2, 0x46, 0xBF, 0x6F, 0x2A, 0x7D, 0x31, + 0xF6, 0xFC, 0x2D, 0xBB, 0x35, 0x00, 0xFA, 0x1D, + 0x92, 0xED, 0xB2, 0x9B, 0x38, 0x7C, 0xAF, 0x17, + 0x1F, 0x1F, 0xE0, 0x25, 0x36, 0x80, 0xD8, 0xE6, + 0xF9, 0x2C, 0x21, 0x8C, 0xED, 0x48, 0x0A, 0x79, + 0xD1, 0x2F, 0xA4, 0x1A, 0x40, 0x05, 0xD6, 0xC2, + 0x09, 0x54, 0xDF, 0x95, 0xF6, 0x70, 0xD7, 0x24, + 0x65, 0x5A, 0xDB, 0x96, 0x32, 0x2B, 0x76, 0x63 + }, + { + 0xDE, 0x48, 0x2B, 0x0D, 0x6E, 0xB1, 0x52, 0xA5, + 0xA6, 0xE5, 0x38, 0x64, 0x64, 0xBF, 0x5A, 0x28, + 0x18, 0x27, 0x90, 0x81, 0xCF, 0x66, 0x47, 0x16, + 0xD9, 0x45, 0x00, 0x99, 0x90, 0x78, 0x43, 0xA1, + 0x81, 0xF1, 0xA7, 0xBF, 0xE9, 0x3C, 0x72, 0x01, + 0x75, 0x76, 0xF8, 0x70, 0x8D, 0xE1, 0x0D, 0xA4, + 0x11, 0x88, 0x2A, 0xA6, 0xBA, 0x82, 0xBB, 0x12, + 0xB5, 0xDF, 0xD8, 0x59, 0x2B, 0xFD, 0xDB, 0xD2 + }, + { + 0xEC, 0xAC, 0xD2, 0x62, 0xDB, 0x43, 0x14, 0xDB, + 0x41, 0x89, 0xEE, 0x2E, 0xEA, 0x5F, 0x6E, 0xAC, + 0x13, 0xAA, 0xAA, 0xB8, 0x4A, 0x55, 0xAA, 0x9A, + 0xFC, 0xF7, 0x44, 0x9F, 0x09, 0x8D, 0x91, 0x0D, + 0xE6, 0xE2, 0x4A, 0xCF, 0x59, 0xBD, 0x71, 0x2C, + 0x56, 0x49, 0x63, 0x06, 0x0D, 0xE0, 0x0F, 0x34, + 0x0C, 0xBF, 0xBC, 0xD5, 0x31, 0xAC, 0xA0, 0x34, + 0x3B, 0xBA, 0x33, 0x99, 0x28, 0xFD, 0xED, 0xFC + }, + { + 0xA0, 0xD5, 0x65, 0x74, 0x7A, 0x67, 0x47, 0x56, + 0xA7, 0x30, 0xA1, 0x32, 0x79, 0x32, 0xE6, 0xF2, + 0xFA, 0x0A, 0xBA, 0xAB, 0xBC, 0xA8, 0x2C, 0x3D, + 0x09, 0x51, 0x50, 0x5E, 0xD9, 0xEA, 0x9F, 0x6A, + 0x90, 0x22, 0xCB, 0xF2, 0x9F, 0x67, 0x63, 0x9A, + 0xAC, 0x74, 0xA9, 0x73, 0x5A, 0x53, 0x63, 0xA8, + 0x8F, 0x01, 0x28, 0xEA, 0x91, 0xEB, 0x4F, 0x63, + 0x92, 0x21, 0xBB, 0xF9, 0x90, 0x95, 0x4E, 0xEE + }, + { + 0x27, 0x8D, 0xFD, 0x6C, 0x0D, 0x05, 0xB2, 0x51, + 0x40, 0xCE, 0x87, 0xF9, 0x99, 0xC2, 0x50, 0xFF, + 0xEB, 0x1E, 0x0C, 0x8F, 0x6C, 0xA2, 0x0A, 0x6C, + 0x1A, 0xDD, 0xB4, 0x6F, 0xBD, 0xF9, 0x15, 0x35, + 0x7F, 0xF3, 0x34, 0x2E, 0xCA, 0xAE, 0xD9, 0x71, + 0x5E, 0x94, 0xA6, 0xAA, 0xCD, 0x3B, 0xF4, 0x5D, + 0xE1, 0x84, 0x56, 0xF5, 0x45, 0x3F, 0x29, 0x12, + 0xBC, 0xA5, 0x65, 0xF6, 0xEB, 0x56, 0x91, 0xA9 + }, + { + 0xE2, 0xEE, 0x13, 0xB4, 0xB0, 0x49, 0x7A, 0x33, + 0x0F, 0xCC, 0xE6, 0x77, 0xC0, 0x66, 0x90, 0x9F, + 0x2D, 0x13, 0xB4, 0x18, 0xEB, 0x4C, 0x56, 0x64, + 0xB5, 0xDE, 0x18, 0x09, 0x92, 0xBF, 0x4E, 0xD5, + 0x0A, 0x2B, 0x79, 0xDC, 0xE8, 0x00, 0x77, 0x30, + 0x1B, 0x0F, 0x2F, 0x1D, 0xDA, 0x8C, 0xBC, 0xDA, + 0x04, 0xE1, 0x3F, 0x4F, 0xF8, 0xF8, 0xFF, 0x95, + 0x73, 0x54, 0x6C, 0x1C, 0x68, 0x42, 0x8E, 0xDE + }, + { + 0x6A, 0x15, 0xB8, 0x04, 0xC3, 0x48, 0x1C, 0xE1, + 0x69, 0x15, 0x7F, 0x68, 0x64, 0xDC, 0x4A, 0x21, + 0x9F, 0xCD, 0xDC, 0x25, 0x6B, 0x54, 0xB5, 0x2E, + 0xA0, 0x7B, 0x0D, 0x13, 0x13, 0xD6, 0xE7, 0x13, + 0xDF, 0xAD, 0x26, 0x37, 0xF5, 0x16, 0xE5, 0x6A, + 0x70, 0x8A, 0x73, 0x56, 0x9C, 0xEE, 0x3F, 0xD9, + 0x66, 0x6A, 0xBD, 0x57, 0x16, 0x96, 0xEA, 0xC7, + 0x16, 0x85, 0x99, 0xBB, 0x88, 0x3D, 0xFB, 0x18 + }, + { + 0x61, 0xD2, 0xF6, 0xDE, 0xDE, 0x68, 0x6C, 0xD2, + 0xD7, 0xF2, 0x2C, 0x13, 0x7B, 0x23, 0x9D, 0x10, + 0xD2, 0x6B, 0xF1, 0x24, 0x28, 0x08, 0x92, 0xB2, + 0x4B, 0x5E, 0x20, 0x85, 0xAE, 0x88, 0x23, 0x74, + 0xFC, 0x47, 0xC3, 0x6B, 0x05, 0x66, 0x35, 0x28, + 0xF6, 0x36, 0x8A, 0x91, 0x87, 0xD8, 0xAC, 0x0D, + 0x19, 0xDD, 0x60, 0xEF, 0xFF, 0x58, 0x51, 0x12, + 0xB7, 0x91, 0x46, 0x59, 0x32, 0xC6, 0x94, 0x26 + }, + { + 0xE8, 0x8F, 0x96, 0xEB, 0x77, 0x84, 0xFD, 0xBD, + 0xAD, 0xE4, 0x5B, 0xCD, 0xDB, 0xDE, 0x7F, 0xB7, + 0xD2, 0x3A, 0x0E, 0x23, 0xF9, 0xA0, 0x8B, 0x62, + 0x9C, 0x8C, 0x3E, 0x28, 0xA4, 0xDD, 0xA5, 0x78, + 0x54, 0xC3, 0x73, 0x1B, 0x36, 0xAC, 0xD4, 0x46, + 0xC3, 0xB6, 0x3F, 0x38, 0xC8, 0x1B, 0x9C, 0xD6, + 0x8F, 0x3F, 0x84, 0xF6, 0x9A, 0x31, 0x11, 0xC5, + 0x69, 0x22, 0xB6, 0x8B, 0xDF, 0x76, 0x3B, 0x45 + }, + { + 0x05, 0xE1, 0x76, 0x49, 0xCC, 0x46, 0x3B, 0x24, + 0x3A, 0xA6, 0xCF, 0x04, 0x52, 0x2D, 0xD0, 0x4A, + 0xE5, 0xCA, 0x2D, 0x95, 0x53, 0xEE, 0x2F, 0x40, + 0xC5, 0xB6, 0x5C, 0xBA, 0xEE, 0x98, 0x14, 0x31, + 0xD0, 0x3A, 0x8E, 0xF8, 0x7A, 0xFC, 0x7A, 0xE1, + 0x8D, 0x09, 0x7A, 0xC6, 0x50, 0xBF, 0x8A, 0x15, + 0xEA, 0xC7, 0xBE, 0x4F, 0xFC, 0x2F, 0x70, 0xA5, + 0x82, 0x5D, 0x75, 0x30, 0x27, 0xA6, 0xC1, 0x58 + }, + { + 0x66, 0xB5, 0x11, 0x63, 0x1E, 0x0E, 0xB0, 0x15, + 0xA0, 0x45, 0x1F, 0x2F, 0x9D, 0x6E, 0xFA, 0x5D, + 0xBD, 0x8A, 0x9E, 0xA4, 0x36, 0x59, 0xAB, 0x2B, + 0x4C, 0x83, 0x61, 0x51, 0xE6, 0x4F, 0x1E, 0x72, + 0x5C, 0x2C, 0x33, 0xFF, 0x36, 0xBC, 0x79, 0xC7, + 0x33, 0xC9, 0xB5, 0xE4, 0x78, 0x7F, 0x85, 0xA5, + 0xD4, 0x35, 0x68, 0xF6, 0x9B, 0x1C, 0xB8, 0x2F, + 0xC1, 0x16, 0x6F, 0x55, 0x0D, 0xB4, 0xF4, 0x42 + }, + { + 0xD7, 0x9F, 0x9A, 0x0B, 0x09, 0x2F, 0x4D, 0x37, + 0x98, 0xB8, 0x1E, 0xD9, 0x8B, 0x65, 0x41, 0x0F, + 0x50, 0x29, 0xD1, 0x21, 0xEB, 0x39, 0x12, 0x1E, + 0xF9, 0x35, 0x17, 0x3D, 0x17, 0xD4, 0x7F, 0xE6, + 0xBC, 0x97, 0x80, 0xD6, 0x74, 0xD8, 0xEE, 0x97, + 0x1B, 0xB3, 0xA9, 0xCA, 0xA5, 0xCF, 0xB0, 0xB9, + 0x06, 0x27, 0xC6, 0x97, 0x73, 0xDF, 0xA2, 0x6E, + 0x4F, 0xE5, 0xAA, 0xF3, 0xE9, 0x48, 0xDE, 0x8D + }, + { + 0x47, 0x40, 0x23, 0x5B, 0xA3, 0xED, 0x8F, 0x21, + 0xFB, 0x88, 0x77, 0x80, 0x33, 0x7A, 0xC6, 0x9E, + 0xB3, 0xF5, 0xB9, 0x67, 0x90, 0x52, 0x5D, 0xD2, + 0x2F, 0xA2, 0x56, 0xD4, 0x94, 0xD1, 0x79, 0x79, + 0xDA, 0xC7, 0x0F, 0xEF, 0x38, 0x18, 0xCA, 0xD9, + 0x70, 0xD6, 0x57, 0xB1, 0x62, 0x44, 0x11, 0x9B, + 0xCA, 0x29, 0x42, 0xEB, 0x2C, 0xDC, 0xAA, 0x3C, + 0xB5, 0x3D, 0x0E, 0x79, 0x5E, 0xAC, 0xCF, 0x98 + }, + { + 0x5A, 0x92, 0x73, 0xD6, 0x8B, 0x69, 0x30, 0x8C, + 0x36, 0x53, 0xDC, 0x1C, 0xFF, 0x83, 0x09, 0x32, + 0x7A, 0x9E, 0x7B, 0x59, 0x3B, 0xA3, 0x7B, 0x21, + 0x6E, 0x56, 0xB2, 0x35, 0x99, 0x1B, 0xFB, 0x1E, + 0x23, 0x32, 0xD0, 0xC0, 0x9B, 0x42, 0x2F, 0x68, + 0x39, 0x17, 0x0A, 0xDF, 0x74, 0xA0, 0x82, 0xA8, + 0xF8, 0x48, 0xCC, 0x07, 0x78, 0xCE, 0x38, 0x71, + 0x58, 0x6F, 0x20, 0xA1, 0x9C, 0xD7, 0x05, 0xD5 + }, + { + 0x6D, 0x16, 0x4D, 0xE3, 0x26, 0x04, 0x88, 0xC9, + 0xBE, 0x3A, 0xFF, 0x78, 0x4F, 0x2B, 0xDB, 0xF2, + 0xBE, 0x7D, 0xB0, 0x99, 0xBD, 0x12, 0x3B, 0xB1, + 0xD4, 0x9B, 0x1E, 0x81, 0xFD, 0x04, 0xFA, 0xFC, + 0x46, 0x56, 0xD3, 0xD6, 0x3C, 0xBB, 0xB1, 0x37, + 0x46, 0x9F, 0xA1, 0x75, 0x50, 0xDA, 0xF5, 0xA1, + 0xE0, 0xD2, 0x24, 0xA8, 0x7E, 0x31, 0x33, 0xA5, + 0xB5, 0x21, 0xA0, 0xEA, 0x57, 0x95, 0xC8, 0x3F + }, + { + 0xD0, 0x79, 0xE0, 0x3A, 0xC7, 0x2C, 0x5A, 0xA7, + 0x4F, 0x87, 0x4F, 0x38, 0x90, 0xD8, 0x53, 0xFD, + 0x93, 0xE6, 0xDA, 0x77, 0x2F, 0x15, 0xFF, 0x8C, + 0x7F, 0x55, 0xA8, 0x2A, 0x33, 0x8B, 0x66, 0xE3, + 0xF7, 0xF7, 0x25, 0x4B, 0x91, 0xA2, 0x65, 0x8D, + 0x53, 0xEB, 0xE1, 0x37, 0x18, 0x83, 0x87, 0x1B, + 0x0A, 0x7B, 0xA8, 0xBA, 0xA2, 0x8C, 0x3A, 0xC1, + 0x39, 0xE7, 0x12, 0xF2, 0xA2, 0x7E, 0xD9, 0xAB + }, + { + 0xCB, 0x71, 0xBD, 0x77, 0x8D, 0x07, 0x3C, 0xDD, + 0xFA, 0x01, 0x78, 0x63, 0x3E, 0x86, 0x95, 0xAB, + 0xE4, 0xC2, 0x38, 0xFA, 0xAF, 0x44, 0x88, 0xC2, + 0x79, 0x63, 0x23, 0x2A, 0x09, 0x7A, 0xA6, 0x6E, + 0x89, 0x0C, 0x25, 0xD9, 0x28, 0xFB, 0xEA, 0xF7, + 0xF0, 0x87, 0x75, 0xCD, 0xAD, 0x01, 0x3B, 0x9F, + 0x45, 0x9A, 0x17, 0x9F, 0x81, 0x3C, 0xE0, 0x85, + 0x3D, 0x5F, 0x54, 0x70, 0xFD, 0xED, 0x9D, 0x69 + }, + { + 0x43, 0xD6, 0x17, 0x7F, 0x0C, 0xFA, 0xB1, 0x0C, + 0x60, 0x19, 0x32, 0x44, 0xDD, 0x44, 0x1B, 0x50, + 0xC0, 0x60, 0xBB, 0xB9, 0x77, 0xCA, 0x2C, 0x77, + 0x50, 0xA4, 0xCF, 0x45, 0x31, 0x10, 0xA3, 0x02, + 0x9B, 0x9B, 0xD5, 0x6B, 0x33, 0xD1, 0x73, 0x69, + 0x27, 0x8F, 0xF6, 0x0A, 0xAF, 0x79, 0x6A, 0x06, + 0x0A, 0xE4, 0x64, 0x2B, 0x35, 0x05, 0x0C, 0x70, + 0xA6, 0xB1, 0x22, 0x30, 0xEE, 0x5B, 0xAB, 0x2E + }, + { + 0x67, 0x3C, 0x71, 0x38, 0xAC, 0xE2, 0x94, 0xBB, + 0x41, 0x93, 0xF1, 0x26, 0xF3, 0x06, 0x36, 0x15, + 0x8B, 0xDE, 0x52, 0xDA, 0x12, 0xAC, 0xC2, 0xFA, + 0xE9, 0xA3, 0x45, 0x44, 0xEB, 0x4E, 0xF5, 0xBA, + 0xD1, 0xE0, 0x18, 0xB5, 0x15, 0x65, 0x57, 0x12, + 0xAC, 0x23, 0x02, 0xD6, 0xD3, 0x40, 0x65, 0x83, + 0x28, 0x7C, 0x47, 0x9F, 0x55, 0xA6, 0xF3, 0x04, + 0x31, 0x5A, 0x37, 0xC0, 0x6D, 0xD7, 0x6A, 0x33 + }, + { + 0x3D, 0xE7, 0xD1, 0xFA, 0xA5, 0xD5, 0x85, 0x91, + 0xE1, 0x76, 0xE9, 0xA3, 0xEB, 0xC0, 0x9E, 0x1D, + 0x43, 0x44, 0x5D, 0x2A, 0x43, 0x49, 0x0F, 0x73, + 0x4B, 0x5C, 0xEB, 0xC9, 0x01, 0xC6, 0x62, 0x13, + 0x73, 0x9E, 0x31, 0xBD, 0xE2, 0xA2, 0xA2, 0xBE, + 0xA5, 0x4D, 0xD5, 0xC6, 0x06, 0xA5, 0xB6, 0xA4, + 0x11, 0xD5, 0xEF, 0x62, 0xF2, 0xF6, 0xD8, 0xF6, + 0x98, 0x88, 0x98, 0xBA, 0xB0, 0x0A, 0xAA, 0x62 + }, + { + 0xAD, 0xAC, 0x73, 0x8D, 0x48, 0x2C, 0xDD, 0xB5, + 0x89, 0x55, 0x04, 0x90, 0x17, 0xAE, 0x20, 0xEC, + 0xCA, 0x18, 0xDD, 0x68, 0x33, 0x63, 0x74, 0x6D, + 0x5E, 0x14, 0x46, 0x83, 0x74, 0xEC, 0x88, 0xFD, + 0x4F, 0x14, 0x9C, 0xDB, 0xAE, 0x30, 0xE9, 0x5E, + 0x9B, 0x47, 0x63, 0xD9, 0xD6, 0x43, 0x8C, 0x2D, + 0x44, 0x53, 0x7C, 0xE4, 0x57, 0x99, 0x90, 0xF4, + 0xED, 0x6C, 0x07, 0x5A, 0xFD, 0x9C, 0x54, 0x25 + }, + { + 0xDA, 0xBC, 0xBB, 0xCB, 0x55, 0xAB, 0x11, 0x70, + 0xA6, 0x63, 0x58, 0x31, 0xB5, 0x38, 0x68, 0x87, + 0xE9, 0x59, 0x9D, 0xBB, 0xED, 0x28, 0x3B, 0x50, + 0xEF, 0xBE, 0x3E, 0x23, 0x87, 0x40, 0x06, 0x1B, + 0xC2, 0xEF, 0x4A, 0xF2, 0x6A, 0x4D, 0x96, 0x26, + 0xBA, 0x60, 0xC3, 0x0F, 0xC4, 0xA2, 0x24, 0x79, + 0xC6, 0xEE, 0xF6, 0x26, 0xA2, 0xE9, 0x91, 0xAB, + 0x7C, 0xBB, 0xBE, 0xD1, 0x83, 0x74, 0x37, 0x71 + }, + { + 0x23, 0xEA, 0xF1, 0x3A, 0x1B, 0xE9, 0x2A, 0x8C, + 0x96, 0x49, 0x2F, 0x5B, 0xE7, 0xE2, 0x65, 0x11, + 0x4F, 0x3E, 0xFE, 0x8E, 0x6E, 0x58, 0x4D, 0x97, + 0x7A, 0x83, 0xC8, 0xE6, 0x17, 0x55, 0x55, 0x12, + 0xA4, 0x56, 0xF8, 0x98, 0x3C, 0x12, 0x87, 0xCE, + 0x20, 0x82, 0x03, 0x27, 0x8E, 0xEB, 0xE5, 0xAB, + 0x1E, 0xDA, 0xE3, 0x71, 0x74, 0x02, 0xAC, 0x7B, + 0xAC, 0xE9, 0x2A, 0xD8, 0x57, 0x32, 0xA1, 0xAD + }, + { + 0xE5, 0x5F, 0xBE, 0x2D, 0x92, 0x21, 0x24, 0x7A, + 0xD4, 0xBF, 0xEC, 0x5E, 0x98, 0x58, 0xDF, 0xFA, + 0x73, 0x64, 0xCF, 0xDB, 0x8F, 0xF0, 0x32, 0xAA, + 0xCB, 0x23, 0xC4, 0xEF, 0xEE, 0xC7, 0x29, 0xF8, + 0xB1, 0xEC, 0xDE, 0x19, 0x1D, 0x00, 0x3B, 0xEE, + 0x9B, 0x38, 0x4A, 0xE4, 0xA0, 0xAE, 0xCB, 0xB5, + 0x67, 0x70, 0x19, 0x7B, 0x53, 0x84, 0x5E, 0x5E, + 0x60, 0xD5, 0x4F, 0xF9, 0x07, 0x16, 0xCA, 0x71 + }, + { + 0x3D, 0x7D, 0xAD, 0x73, 0xC1, 0xA9, 0x1B, 0x86, + 0x77, 0x10, 0x09, 0xA6, 0xFD, 0x33, 0x05, 0x4B, + 0x48, 0x15, 0xDB, 0xB8, 0xEE, 0x3B, 0x0F, 0xAE, + 0xBE, 0xF9, 0x8C, 0x7D, 0x42, 0x91, 0x48, 0x5C, + 0x53, 0x42, 0xA5, 0x36, 0xC9, 0x38, 0xCF, 0x1B, + 0x06, 0x98, 0x06, 0x84, 0x98, 0x53, 0x55, 0x43, + 0x43, 0x39, 0x9D, 0x21, 0xB1, 0xF6, 0x40, 0xBF, + 0xF9, 0xFA, 0x2D, 0x7B, 0xCC, 0xB3, 0x4D, 0x10 + }, + { + 0x99, 0xFF, 0x48, 0x81, 0xCC, 0x0C, 0x51, 0xF7, + 0x18, 0x69, 0x5D, 0x97, 0xF3, 0x7C, 0xAC, 0xDF, + 0x96, 0xC6, 0x6F, 0x2E, 0x68, 0xDE, 0xD6, 0x59, + 0xC6, 0xF7, 0x21, 0x21, 0x33, 0x0F, 0x61, 0xFD, + 0xD1, 0x4F, 0xE5, 0x53, 0x08, 0x25, 0x2C, 0x3F, + 0x70, 0x03, 0xEF, 0x29, 0xC0, 0x4C, 0xDE, 0xB5, + 0x76, 0x4C, 0x03, 0x8C, 0x70, 0xFA, 0x11, 0xD4, + 0xD1, 0xB2, 0xDA, 0x96, 0x34, 0x2D, 0xCC, 0x10 + }, + { + 0x99, 0x6A, 0xC3, 0xCD, 0xAA, 0x6C, 0x04, 0x7B, + 0x7E, 0x32, 0xA0, 0x8B, 0xEC, 0xC1, 0x5A, 0xC4, + 0xDC, 0xAA, 0x44, 0xDE, 0x49, 0xBB, 0x06, 0xA5, + 0x44, 0x16, 0xF1, 0x42, 0x88, 0xF3, 0xEE, 0x5D, + 0x5C, 0x0A, 0xC6, 0xD5, 0x61, 0x3D, 0xA2, 0x3E, + 0x5F, 0x5C, 0xB7, 0xDF, 0x60, 0x56, 0x40, 0x21, + 0x2C, 0x22, 0x1C, 0x43, 0x29, 0x5A, 0xC5, 0xB5, + 0xF9, 0x4D, 0x02, 0xA4, 0xD9, 0x08, 0xDB, 0xB0 + }, + { + 0xBD, 0xFB, 0x8B, 0xF5, 0xE9, 0x91, 0xD7, 0x15, + 0x61, 0xBD, 0xB6, 0xE4, 0x53, 0x16, 0xDA, 0x34, + 0x6D, 0x8F, 0x94, 0x89, 0x7A, 0x34, 0x4D, 0xAC, + 0xA9, 0x6C, 0x3F, 0xFE, 0xE3, 0x4C, 0xFE, 0x30, + 0xDB, 0x34, 0x09, 0x16, 0x4E, 0xED, 0x93, 0x7F, + 0xCF, 0xE6, 0x22, 0xAE, 0x4D, 0xCB, 0xFF, 0xC4, + 0x7E, 0xC6, 0x87, 0x51, 0x7C, 0x22, 0x70, 0x50, + 0x7E, 0x96, 0x3C, 0x1E, 0x05, 0x8E, 0x69, 0xFA + }, + { + 0x4A, 0xA4, 0xB6, 0xAA, 0x60, 0xBB, 0x19, 0x46, + 0x0E, 0x74, 0x3F, 0xCD, 0x52, 0xFE, 0xD1, 0xF7, + 0x39, 0xF4, 0x62, 0xB6, 0xCF, 0x93, 0x6B, 0x30, + 0x40, 0x24, 0xB7, 0xF5, 0x32, 0x21, 0x04, 0x2F, + 0x40, 0xA9, 0xFB, 0x9A, 0x87, 0x67, 0x2A, 0x7D, + 0xD2, 0x22, 0xC1, 0xC7, 0xB7, 0xBA, 0x01, 0xA9, + 0x24, 0x01, 0x0C, 0x52, 0x22, 0xFF, 0x86, 0xC7, + 0xC7, 0x8D, 0x31, 0xA1, 0x54, 0x3E, 0x53, 0x90 + }, + { + 0x5E, 0xB7, 0xA8, 0xBC, 0x57, 0xA1, 0x90, 0x26, + 0x07, 0xA9, 0x28, 0x85, 0x8B, 0x3D, 0x15, 0xFD, + 0x5F, 0xA3, 0xFF, 0xCD, 0x23, 0xA4, 0x48, 0xC3, + 0x46, 0x3A, 0x41, 0x0E, 0x73, 0xFE, 0xBB, 0x4D, + 0x40, 0xC7, 0x07, 0x08, 0xA6, 0x15, 0x09, 0x6D, + 0x8C, 0xB5, 0x56, 0x89, 0x3E, 0xE8, 0x2F, 0xB1, + 0xD9, 0xBB, 0x88, 0x9D, 0x27, 0x53, 0x0B, 0xDC, + 0x30, 0x2D, 0xCD, 0x89, 0xD1, 0xCE, 0x23, 0xDF + }, + { + 0x2D, 0x7D, 0x6D, 0xAF, 0x93, 0x5E, 0xF1, 0xE7, + 0xF5, 0xBA, 0x49, 0xD2, 0x2E, 0xBB, 0xAC, 0xC5, + 0x46, 0xC3, 0x80, 0x74, 0xA4, 0x48, 0xEA, 0xEC, + 0x8A, 0x2C, 0xA5, 0xB2, 0x4E, 0xA9, 0x0A, 0x0C, + 0x4F, 0x7A, 0x25, 0xBD, 0x91, 0xB8, 0x7E, 0x9B, + 0x96, 0x84, 0x69, 0x16, 0x86, 0x3E, 0xBD, 0xE8, + 0x39, 0x77, 0x2D, 0x7A, 0xC3, 0x69, 0x78, 0x3E, + 0x75, 0x4D, 0x14, 0x06, 0xE7, 0xAC, 0xB9, 0x6B + }, + { + 0xAA, 0x99, 0x52, 0x35, 0x19, 0xA0, 0x86, 0x85, + 0x34, 0x1B, 0xE4, 0x18, 0x7D, 0x78, 0x74, 0x23, + 0x78, 0x58, 0x86, 0x70, 0xFA, 0xE0, 0x55, 0xAB, + 0xE6, 0xAB, 0x7B, 0x13, 0xBF, 0xC1, 0x2D, 0x67, + 0x03, 0x77, 0x2A, 0x88, 0x7A, 0x9D, 0xD0, 0xE8, + 0x7B, 0x05, 0x90, 0x26, 0xB1, 0x81, 0x20, 0x55, + 0x09, 0x8C, 0x96, 0xDF, 0x09, 0x29, 0x29, 0x01, + 0x7E, 0x37, 0x07, 0x51, 0x8B, 0x99, 0x9C, 0x16 + }, + { + 0x2F, 0xB3, 0x9A, 0xA5, 0xBB, 0x5D, 0x82, 0xD0, + 0xCE, 0x1B, 0xE9, 0x2E, 0xEA, 0x68, 0x20, 0x73, + 0x7A, 0x5E, 0x1C, 0xD1, 0x25, 0xD5, 0x2A, 0xB9, + 0xBE, 0x54, 0x82, 0x12, 0x61, 0xF4, 0xE4, 0x22, + 0x4C, 0xB2, 0xCE, 0x4B, 0x34, 0x42, 0x95, 0xB4, + 0x89, 0x1A, 0x60, 0x71, 0x3B, 0x92, 0x91, 0x76, + 0x13, 0x41, 0x72, 0xA6, 0x54, 0x8F, 0xF5, 0x72, + 0xB5, 0x33, 0xA3, 0x45, 0x7E, 0xED, 0x91, 0x40 + }, + { + 0x2B, 0xCF, 0x1E, 0x01, 0x1D, 0x8A, 0xDA, 0x79, + 0x4F, 0xD4, 0xF1, 0x32, 0x9D, 0x77, 0x74, 0x24, + 0xE9, 0x76, 0xE3, 0xFE, 0x09, 0x81, 0xD7, 0x57, + 0x8E, 0x56, 0xC2, 0x96, 0x95, 0xB5, 0x16, 0x46, + 0xEE, 0x1C, 0x80, 0x8E, 0x40, 0xEF, 0x29, 0xAD, + 0xA7, 0x3E, 0x1F, 0x93, 0x2B, 0xF7, 0x0C, 0xB1, + 0x75, 0x95, 0x34, 0x75, 0xB9, 0x9E, 0x51, 0x73, + 0x87, 0x11, 0xE6, 0x1A, 0xE3, 0x6D, 0x56, 0x5D + }, + { + 0x2B, 0xAD, 0x70, 0x18, 0x33, 0x3F, 0xBA, 0x4B, + 0x70, 0xD0, 0x95, 0xF7, 0xF8, 0x00, 0xA6, 0x5C, + 0xE2, 0xCE, 0x67, 0xC4, 0x1E, 0x7C, 0xDD, 0xBD, + 0x3A, 0x3F, 0x64, 0x40, 0xD3, 0x4E, 0xA0, 0xCE, + 0x09, 0x4D, 0x99, 0xDC, 0xA2, 0x20, 0x4D, 0x68, + 0x06, 0xE1, 0x7B, 0x52, 0x69, 0x1B, 0x24, 0x79, + 0x55, 0x7C, 0xCD, 0x69, 0xE7, 0xCA, 0x16, 0x4A, + 0x66, 0x13, 0xE6, 0x4C, 0x6F, 0x00, 0xF0, 0x31 + }, + { + 0x02, 0xA6, 0x15, 0x2E, 0xAD, 0x77, 0xCB, 0x1B, + 0x9A, 0x75, 0x8A, 0xAB, 0x97, 0x13, 0xB8, 0x36, + 0x5B, 0x38, 0x48, 0x8A, 0x02, 0xAF, 0x5E, 0x4A, + 0x53, 0x5C, 0xB9, 0x21, 0xF6, 0x45, 0x7B, 0x26, + 0x7C, 0x99, 0xE7, 0x90, 0x55, 0x26, 0x00, 0x53, + 0x6F, 0xB1, 0x48, 0xD2, 0x18, 0xC8, 0xDF, 0x18, + 0x8D, 0x3D, 0xAF, 0x0E, 0xBA, 0xB0, 0x15, 0x01, + 0x7A, 0xCC, 0x57, 0x9C, 0xE3, 0x6E, 0x20, 0x9A + }, + { + 0xFB, 0x23, 0x60, 0x0A, 0x84, 0xF1, 0x49, 0xB6, + 0x4F, 0x1D, 0x7C, 0xCA, 0xDC, 0x47, 0x12, 0x88, + 0xB1, 0x21, 0x2D, 0xA2, 0x10, 0xAD, 0x44, 0x2D, + 0x13, 0xFE, 0x99, 0xC3, 0x70, 0x2E, 0x17, 0x71, + 0x34, 0x11, 0xB0, 0x1E, 0xAE, 0x77, 0xC9, 0x1A, + 0x49, 0x60, 0x71, 0xDC, 0xCB, 0x9A, 0x49, 0xE5, + 0x23, 0x7B, 0xC6, 0xC2, 0x6B, 0xFA, 0x79, 0xB3, + 0x7D, 0xDD, 0x69, 0x88, 0xBB, 0xA4, 0x5F, 0xEA + }, + { + 0xC5, 0x6A, 0xC9, 0x0E, 0x66, 0x5E, 0x48, 0xC6, + 0x27, 0x39, 0x7D, 0x1A, 0xB5, 0xD6, 0xF4, 0xE6, + 0x2F, 0x99, 0x77, 0x4F, 0x4F, 0x53, 0xA2, 0x0F, + 0x54, 0x54, 0xDB, 0xC2, 0xA7, 0x12, 0xB8, 0x90, + 0x9F, 0xB4, 0x56, 0xFB, 0xA5, 0x87, 0x5B, 0x98, + 0x5A, 0x4B, 0xE7, 0xA0, 0x9D, 0xCB, 0x7A, 0x74, + 0x4A, 0x9E, 0x55, 0x70, 0xDF, 0x5C, 0xC8, 0xB9, + 0xC2, 0x82, 0xE3, 0x6F, 0x7A, 0xE4, 0x7D, 0x3B + }, + { + 0x50, 0x70, 0x31, 0xDA, 0xFB, 0xA0, 0x47, 0xAF, + 0x2D, 0xCB, 0x2A, 0x08, 0x4F, 0x94, 0x38, 0xA1, + 0x47, 0x30, 0x96, 0xA9, 0x3C, 0xAC, 0x3A, 0xE0, + 0xF7, 0x5E, 0x6D, 0x1F, 0x60, 0xB2, 0x28, 0x79, + 0xA6, 0x69, 0x1A, 0x96, 0x49, 0xEC, 0x75, 0x80, + 0x90, 0x6F, 0x03, 0x13, 0x92, 0x11, 0xBE, 0xDF, + 0x9C, 0x40, 0x2B, 0x82, 0xC0, 0x62, 0x4A, 0x17, + 0x0A, 0xB6, 0x90, 0xDC, 0x9A, 0x57, 0x71, 0xD9 + }, + { + 0x2B, 0x45, 0x7B, 0xD5, 0xD8, 0x06, 0x7D, 0xD0, + 0xCE, 0x08, 0x3B, 0x1A, 0xF3, 0x29, 0xC4, 0x29, + 0x4C, 0x0B, 0xBF, 0x07, 0x20, 0x89, 0x6C, 0xE5, + 0xFC, 0xF0, 0xDB, 0xA0, 0x4D, 0xA9, 0x1A, 0x70, + 0xB4, 0x26, 0x6D, 0x26, 0xD3, 0x63, 0xC1, 0xDD, + 0xC9, 0x65, 0x63, 0xFE, 0x50, 0xFA, 0xDA, 0x97, + 0xAF, 0xDA, 0x36, 0xFE, 0xD5, 0x70, 0xC2, 0xA4, + 0x91, 0x11, 0x63, 0x0D, 0xE6, 0x6C, 0xB0, 0x0F + }, + { + 0x2F, 0x30, 0x5C, 0x49, 0xBD, 0xD5, 0xDA, 0xF6, + 0x5A, 0x03, 0xBA, 0xEF, 0x72, 0x2C, 0x69, 0xF6, + 0x72, 0x7B, 0x22, 0x0D, 0xC0, 0x3F, 0xDB, 0x66, + 0x92, 0x9B, 0xCD, 0x22, 0xBA, 0xDE, 0x81, 0x43, + 0x25, 0x90, 0x7B, 0xEB, 0x01, 0xC8, 0xDE, 0x4C, + 0x82, 0xA5, 0x66, 0xD9, 0x75, 0x60, 0x20, 0x0C, + 0xE1, 0xBD, 0x18, 0x20, 0xA7, 0x8E, 0x04, 0x2C, + 0x55, 0x2B, 0xE0, 0xAF, 0x97, 0x59, 0x39, 0x87 + }, + { + 0x78, 0x9B, 0xC9, 0xB5, 0x5F, 0x4B, 0x1D, 0xA6, + 0xC8, 0x48, 0x5F, 0xC2, 0xEF, 0xDF, 0xB5, 0x50, + 0x2D, 0x8F, 0xFC, 0x38, 0x41, 0x22, 0x6C, 0x61, + 0x1D, 0xCD, 0x35, 0x96, 0x8E, 0x56, 0x06, 0xEA, + 0x51, 0xD9, 0xB2, 0xE1, 0x4A, 0x26, 0x13, 0x23, + 0xD0, 0x3D, 0xAB, 0x61, 0x65, 0x2D, 0x68, 0x64, + 0x16, 0xBF, 0xC3, 0x88, 0x35, 0x69, 0x85, 0x43, + 0xAE, 0x58, 0x52, 0xCC, 0xD4, 0x21, 0xB3, 0x2C + }, + { + 0xDF, 0xBD, 0xC3, 0xAF, 0x3B, 0xC0, 0xC5, 0xDC, + 0x39, 0xDF, 0x05, 0x60, 0x59, 0x13, 0x52, 0x81, + 0xD6, 0xA6, 0x5F, 0x7E, 0xFD, 0xF0, 0x28, 0xCD, + 0x83, 0xBD, 0x7E, 0x7D, 0x0A, 0x73, 0x48, 0x0F, + 0x50, 0x17, 0xB3, 0x61, 0xF6, 0xA7, 0x35, 0x54, + 0x90, 0x4E, 0x69, 0x7C, 0xB1, 0x0E, 0xA8, 0x84, + 0x48, 0x86, 0xBE, 0xEA, 0x58, 0xB4, 0x29, 0x0B, + 0xF9, 0x37, 0x78, 0x01, 0x47, 0xAB, 0x88, 0x73 + }, + { + 0x01, 0x19, 0xEA, 0xD2, 0x8E, 0x34, 0x70, 0x6A, + 0x24, 0xE1, 0xF9, 0x68, 0x25, 0x07, 0xD3, 0x24, + 0x33, 0xDD, 0x74, 0xCE, 0xAF, 0x5B, 0xC2, 0x6D, + 0x76, 0x05, 0x2D, 0xF3, 0x67, 0x15, 0x66, 0x0D, + 0x7B, 0x22, 0x7B, 0xB1, 0xAA, 0x1E, 0x28, 0x2D, + 0xCA, 0x67, 0x5C, 0xA4, 0xEC, 0x37, 0xF0, 0xAD, + 0x7F, 0xA8, 0x75, 0x7C, 0x5D, 0xC4, 0x09, 0xF9, + 0x84, 0x2C, 0x90, 0xED, 0xCF, 0xCF, 0x7C, 0x46 + }, + { + 0xFF, 0xA6, 0x13, 0xC4, 0x58, 0xD2, 0x85, 0xF3, + 0x9D, 0xED, 0x67, 0xBB, 0x21, 0x64, 0x7B, 0x48, + 0xF9, 0xC1, 0xB3, 0x28, 0x4A, 0x37, 0x90, 0xA4, + 0x0B, 0xFF, 0xF7, 0xE0, 0xC0, 0xB8, 0xE8, 0x46, + 0xF5, 0x57, 0xB2, 0x47, 0x9E, 0xDD, 0x8A, 0x19, + 0x8D, 0x37, 0x66, 0x53, 0x22, 0xA2, 0x67, 0xB7, + 0xB4, 0x5E, 0xDB, 0xD8, 0xDC, 0x61, 0x3B, 0xDD, + 0x54, 0x59, 0x56, 0xE5, 0x96, 0x86, 0x50, 0x56 + }, + { + 0x0E, 0x21, 0xF0, 0x47, 0x96, 0xCB, 0xF1, 0x72, + 0x70, 0x81, 0xCF, 0x9F, 0xA5, 0xEF, 0x9A, 0x0B, + 0xDE, 0x92, 0x7D, 0x8F, 0x72, 0x2B, 0x2D, 0xF1, + 0xBB, 0x65, 0x15, 0x0F, 0xD2, 0x18, 0x5F, 0xBF, + 0x49, 0x2D, 0x39, 0x1F, 0x70, 0xF1, 0xBE, 0xFC, + 0xFB, 0x7C, 0x20, 0x9D, 0xB0, 0x6E, 0x78, 0xB5, + 0x5B, 0xF8, 0xE5, 0x98, 0x94, 0x81, 0xBB, 0xB3, + 0x53, 0x3D, 0x4C, 0x06, 0xB1, 0x90, 0x16, 0x5F + }, + { + 0x41, 0x4C, 0xA9, 0x0F, 0x8D, 0x52, 0x06, 0xB8, + 0xD7, 0x53, 0x46, 0x4C, 0x4F, 0xAD, 0xFC, 0x92, + 0xF0, 0xF1, 0xFC, 0x02, 0xCD, 0xAD, 0x1C, 0x93, + 0xD5, 0x43, 0x56, 0x4B, 0xC3, 0x5E, 0x18, 0x11, + 0xA0, 0xC7, 0x55, 0x3A, 0xD8, 0x98, 0x2F, 0x96, + 0xF9, 0xCE, 0x69, 0x1A, 0xF8, 0xA2, 0x73, 0x9B, + 0x4E, 0xBA, 0x90, 0x51, 0x26, 0xA5, 0x9F, 0xAA, + 0x12, 0xA6, 0x71, 0x52, 0xE8, 0xB1, 0xE2, 0x26 + }, + { + 0xB6, 0x2F, 0x68, 0x2F, 0xFF, 0x1C, 0xA8, 0xDC, + 0x7A, 0x45, 0x8D, 0x4F, 0x17, 0x7F, 0x96, 0xA0, + 0x85, 0x7B, 0x9E, 0x91, 0x25, 0x8C, 0x06, 0xE6, + 0xB7, 0xC0, 0x91, 0x19, 0x00, 0xDA, 0x19, 0x4E, + 0x3B, 0x08, 0x2C, 0x91, 0xAA, 0x4E, 0xD7, 0x88, + 0x5B, 0x62, 0xC9, 0xA4, 0x09, 0x64, 0xB9, 0x86, + 0x98, 0x62, 0x58, 0x4E, 0xB1, 0x57, 0x2F, 0x8B, + 0x54, 0x38, 0xC5, 0x26, 0xEF, 0x67, 0xFC, 0xEC + }, + { + 0xB8, 0xAA, 0xA1, 0xEB, 0x63, 0x1B, 0x91, 0x59, + 0x0D, 0x66, 0x3E, 0x70, 0xEB, 0x06, 0x88, 0x1E, + 0xBC, 0x5E, 0xE1, 0x3B, 0x21, 0xDC, 0x36, 0x04, + 0x21, 0x48, 0x79, 0x80, 0x6B, 0x44, 0x6F, 0xA5, + 0x46, 0x02, 0xF6, 0x95, 0xF2, 0xEB, 0xC8, 0xCE, + 0x10, 0x49, 0xCF, 0xD5, 0x2C, 0x11, 0x04, 0x8C, + 0x5C, 0xF1, 0xF7, 0x12, 0x99, 0xBA, 0x8D, 0xEB, + 0x98, 0xE1, 0x01, 0x19, 0x1B, 0x6E, 0x79, 0xAA + }, + { + 0x1B, 0x30, 0xC9, 0x45, 0x5E, 0x1F, 0x37, 0x67, + 0x17, 0x71, 0x08, 0x29, 0x63, 0xA8, 0x70, 0x17, + 0x9F, 0x39, 0x55, 0x77, 0x68, 0xD8, 0xDB, 0x11, + 0x2B, 0x22, 0xF2, 0x42, 0x72, 0x5E, 0x3C, 0xB7, + 0x5A, 0xE8, 0x12, 0x5F, 0x81, 0x62, 0x6C, 0x33, + 0x29, 0x34, 0x13, 0x40, 0x7D, 0x3B, 0x0E, 0xF8, + 0x9E, 0xB6, 0x58, 0x97, 0x34, 0x40, 0x1E, 0x28, + 0x6F, 0x8B, 0xFE, 0xB4, 0xD3, 0x06, 0xFD, 0xB8 + }, + { + 0xC0, 0xD1, 0x7F, 0xE0, 0x52, 0xB4, 0xAA, 0x94, + 0x22, 0x30, 0x36, 0x71, 0x6A, 0x8D, 0xA3, 0xDF, + 0x05, 0xAC, 0x4A, 0x8F, 0x60, 0xFC, 0x6C, 0x93, + 0x1D, 0xE8, 0xBF, 0x57, 0x94, 0xBF, 0xDA, 0x44, + 0xDC, 0x09, 0x56, 0xDF, 0x59, 0x2D, 0x5F, 0x4E, + 0xA8, 0x8D, 0xDC, 0xC5, 0xB7, 0xC3, 0x6A, 0x89, + 0xA0, 0xC2, 0xA0, 0x44, 0x85, 0xFA, 0xCC, 0x5A, + 0x51, 0xE2, 0x35, 0x70, 0x3E, 0x2B, 0x81, 0x13 + }, + { + 0xA2, 0xAB, 0x5F, 0xAB, 0x43, 0x11, 0x82, 0x19, + 0xF5, 0xF0, 0x43, 0xF0, 0x60, 0xB0, 0x52, 0x54, + 0x06, 0x14, 0xE1, 0x0C, 0xF6, 0x29, 0xCF, 0xB1, + 0x62, 0xD5, 0xD6, 0xD1, 0x06, 0xF0, 0x0A, 0xA3, + 0x8A, 0x3F, 0xAE, 0xA8, 0xF0, 0x55, 0x5D, 0xD9, + 0x14, 0xFE, 0x5D, 0x57, 0x29, 0x31, 0xEB, 0xE1, + 0x21, 0x1B, 0x4A, 0xA4, 0x78, 0x4B, 0x54, 0x03, + 0x43, 0x34, 0xB8, 0x79, 0xCA, 0xFA, 0x0F, 0x64 + }, + { + 0xE7, 0xEF, 0x84, 0xF1, 0x97, 0x87, 0xD4, 0xCD, + 0xDE, 0x94, 0x9E, 0xF7, 0x17, 0x33, 0xEC, 0xB6, + 0x66, 0x46, 0x82, 0x5E, 0x17, 0x9A, 0xE7, 0x7F, + 0xDA, 0x2D, 0x80, 0xAD, 0x69, 0x24, 0xC6, 0x09, + 0x1D, 0x21, 0x5D, 0xAC, 0x6C, 0x63, 0xEA, 0x05, + 0x3D, 0x6A, 0xEF, 0xD6, 0x5D, 0x4F, 0x76, 0x06, + 0x1C, 0xA4, 0xDC, 0x59, 0x8C, 0xB9, 0x9F, 0xBF, + 0x55, 0x5F, 0x12, 0xF2, 0x2F, 0x95, 0x14, 0x5D + }, + { + 0xD6, 0x2C, 0x64, 0xEB, 0x38, 0x4A, 0x77, 0x87, + 0x6E, 0x99, 0xE2, 0x74, 0xF5, 0x2B, 0xC3, 0xD1, + 0x27, 0x32, 0xBE, 0x04, 0xA3, 0x36, 0x0C, 0x1F, + 0x3E, 0x3A, 0xEC, 0x2B, 0x8F, 0x81, 0xEE, 0x1F, + 0xD9, 0xD4, 0x0A, 0x0B, 0x40, 0xF1, 0xF5, 0x38, + 0xD6, 0x24, 0xA7, 0x94, 0x1D, 0x7E, 0xA1, 0x17, + 0x75, 0xCC, 0x5C, 0xF0, 0x9B, 0x05, 0x08, 0xF4, + 0x7B, 0x3F, 0x4B, 0xA4, 0x5F, 0x53, 0xF3, 0xB0 + }, + { + 0x78, 0x1B, 0xFE, 0xD0, 0xD9, 0x54, 0xC6, 0x2C, + 0x63, 0x7C, 0xBF, 0x8C, 0xE0, 0x7E, 0x0D, 0xAE, + 0xB6, 0x21, 0x18, 0x0F, 0xF2, 0x18, 0x86, 0x5D, + 0x93, 0xA9, 0x6D, 0x66, 0x7E, 0x28, 0x9E, 0xE4, + 0x1D, 0x27, 0x13, 0x0D, 0x5A, 0x17, 0x40, 0xE3, + 0x1C, 0x89, 0x60, 0x39, 0x72, 0x52, 0x96, 0x11, + 0x21, 0x1F, 0xE9, 0xAA, 0xC1, 0xDE, 0xA9, 0xD2, + 0x47, 0x5B, 0x64, 0x55, 0xB5, 0x1D, 0x14, 0x22 + }, + { + 0xBC, 0x6E, 0x59, 0x40, 0x0C, 0x82, 0xCE, 0x8D, + 0x7A, 0x00, 0x73, 0x0E, 0xB1, 0x40, 0x88, 0xFF, + 0x0E, 0x1F, 0x5D, 0x62, 0xBD, 0xA3, 0x81, 0xFF, + 0xAC, 0xF4, 0x76, 0x0C, 0xEF, 0xEE, 0xC5, 0x65, + 0x39, 0xC3, 0xDF, 0x29, 0xD7, 0x01, 0x14, 0x58, + 0x7B, 0xF6, 0x1E, 0x8B, 0xE6, 0xC3, 0x10, 0x9D, + 0x46, 0x04, 0xFE, 0x24, 0xFA, 0x23, 0xFF, 0x32, + 0xE6, 0xE3, 0x1D, 0x43, 0xA9, 0x11, 0xED, 0x3B + }, + { + 0x70, 0x47, 0x9F, 0xD1, 0x9F, 0xC5, 0xBE, 0xAC, + 0x91, 0x67, 0x61, 0x29, 0x9D, 0x55, 0xCA, 0x33, + 0x6C, 0xE3, 0xFF, 0x48, 0x4D, 0xE8, 0x60, 0x37, + 0x91, 0xEA, 0xCF, 0xFC, 0x16, 0x9C, 0x36, 0xDC, + 0x44, 0xC4, 0x38, 0x36, 0x10, 0x9F, 0xA0, 0x61, + 0xCD, 0xD8, 0x4F, 0x80, 0xBC, 0xC7, 0xAB, 0x61, + 0x2D, 0x00, 0x09, 0x12, 0x03, 0xC7, 0xEF, 0x21, + 0xFC, 0x37, 0xDD, 0xB6, 0xCF, 0x65, 0x67, 0xBF + }, + { + 0x21, 0x38, 0x8D, 0xF9, 0xEF, 0xF4, 0x40, 0x59, + 0xCB, 0x68, 0x1F, 0xBF, 0x27, 0x35, 0x26, 0xF7, + 0x68, 0xD6, 0x36, 0x36, 0xEC, 0x9C, 0x63, 0x1C, + 0x9F, 0xE1, 0xED, 0xC6, 0x19, 0xBE, 0xCD, 0x46, + 0x7C, 0x38, 0x4B, 0x31, 0x0A, 0x96, 0x33, 0xFC, + 0xA7, 0x90, 0xFA, 0x91, 0xA9, 0xD5, 0x70, 0x78, + 0x8A, 0xF0, 0x45, 0x56, 0xD6, 0xC2, 0x08, 0xE0, + 0x4E, 0x9C, 0xFB, 0x54, 0x5A, 0xBD, 0x00, 0xF2 + }, + { + 0x3C, 0xD9, 0x22, 0x9C, 0x83, 0xC9, 0xEB, 0x63, + 0x79, 0x1F, 0x41, 0xA6, 0x15, 0x6C, 0xD7, 0x77, + 0x5A, 0x9B, 0x6C, 0x5F, 0x3B, 0x33, 0x54, 0xF6, + 0xBC, 0x98, 0x33, 0x95, 0xA9, 0xBF, 0x8B, 0xBB, + 0x1D, 0x8C, 0xEA, 0x4F, 0x2E, 0x41, 0x15, 0x50, + 0xB4, 0x21, 0x9D, 0x92, 0x7C, 0x9A, 0x67, 0xE9, + 0x7B, 0xAC, 0x73, 0x3E, 0xC5, 0xFE, 0xD3, 0x9B, + 0x5A, 0x24, 0x9B, 0x76, 0xCF, 0x92, 0xF3, 0xC7 + }, + { + 0x0F, 0x6C, 0xD0, 0xC1, 0x82, 0x58, 0xDA, 0xE9, + 0xB3, 0x1F, 0x5D, 0x43, 0x98, 0x1E, 0x34, 0xB0, + 0x24, 0xD6, 0x1B, 0x53, 0x48, 0xB5, 0x6E, 0x93, + 0x2B, 0x55, 0x06, 0x8B, 0x4C, 0xF1, 0x89, 0x2B, + 0x58, 0x03, 0xC7, 0x46, 0x7B, 0xFA, 0x34, 0x7F, + 0xF5, 0x1E, 0xE5, 0xEF, 0xEB, 0x7B, 0xB9, 0x12, + 0x59, 0x38, 0xBB, 0xB8, 0x4D, 0xAC, 0x9B, 0x7B, + 0x91, 0x11, 0xE9, 0x99, 0x99, 0xAA, 0x4B, 0xD2 + }, + { + 0xEC, 0x68, 0x36, 0x17, 0x53, 0xDF, 0x1B, 0xD0, + 0x04, 0x53, 0xB8, 0x86, 0x44, 0x34, 0x26, 0xB1, + 0x89, 0x67, 0xEB, 0x69, 0x4F, 0xC6, 0x39, 0x6C, + 0x96, 0xCC, 0xEA, 0xE2, 0x48, 0x86, 0x88, 0x09, + 0x73, 0x12, 0x08, 0xFD, 0x26, 0x06, 0xE5, 0x35, + 0x68, 0xE4, 0xFB, 0xBD, 0xD9, 0x93, 0x10, 0xDD, + 0x33, 0x47, 0x5E, 0xC6, 0x7B, 0xF0, 0xFD, 0x2F, + 0xA7, 0xF6, 0xC0, 0x6F, 0x22, 0xCA, 0xBA, 0xF5 + }, + { + 0xC4, 0xC9, 0x91, 0x40, 0xB0, 0xAE, 0x83, 0x7F, + 0x61, 0xD2, 0xA1, 0x7F, 0xED, 0x4C, 0xE2, 0x3B, + 0xDE, 0x7D, 0x89, 0xF6, 0xCF, 0xCE, 0x64, 0x63, + 0xB9, 0x19, 0xEC, 0xA1, 0x01, 0x1A, 0xEF, 0xD7, + 0x25, 0xD8, 0x07, 0x8C, 0xEF, 0xD9, 0x9B, 0xFE, + 0x08, 0x08, 0xFA, 0x68, 0xFB, 0x84, 0x2A, 0x58, + 0xA0, 0x3A, 0x00, 0x27, 0x9D, 0xB4, 0x48, 0x36, + 0xB7, 0x24, 0xFD, 0x5C, 0x91, 0x2F, 0xFD, 0xF3 + }, + { + 0x8D, 0xC6, 0x36, 0x4B, 0xEE, 0xD5, 0x5B, 0x41, + 0x20, 0xFD, 0xA2, 0xAC, 0x57, 0x4A, 0xB1, 0x90, + 0xF4, 0x14, 0x69, 0x24, 0xF3, 0xED, 0xA9, 0x46, + 0xB7, 0xED, 0xCC, 0xAC, 0x70, 0xC0, 0x98, 0xDC, + 0xC2, 0x24, 0x34, 0x56, 0x89, 0x44, 0xBC, 0x3A, + 0xB2, 0x8A, 0x3E, 0x03, 0xE4, 0x03, 0xF9, 0xCD, + 0xEF, 0x0E, 0x5E, 0x38, 0x98, 0xA0, 0xDC, 0x2A, + 0x0E, 0x04, 0x52, 0x4C, 0x9B, 0x8C, 0xA4, 0x34 + }, + { + 0xF3, 0x86, 0xFC, 0x11, 0x30, 0x90, 0xAD, 0x7F, + 0xA8, 0xE7, 0x1A, 0xBA, 0x41, 0x7B, 0x85, 0xEE, + 0x28, 0x39, 0x5F, 0x87, 0x35, 0xFF, 0xDF, 0x4C, + 0x3B, 0x5E, 0xF8, 0xA0, 0x50, 0xD0, 0xD2, 0x7D, + 0xB4, 0xE6, 0x85, 0xC9, 0x6D, 0x92, 0x55, 0xAC, + 0x98, 0xE9, 0x0D, 0xFD, 0x98, 0x94, 0x9C, 0x23, + 0xFB, 0xD6, 0xCD, 0x5E, 0xB8, 0x7A, 0xF9, 0x97, + 0x6E, 0xE3, 0x89, 0x35, 0x50, 0xCB, 0x29, 0x88 + }, + { + 0xA3, 0x1B, 0xAA, 0x9B, 0x86, 0x2A, 0x5C, 0x70, + 0xE8, 0x85, 0x7D, 0xBB, 0xD9, 0xF4, 0x50, 0xD9, + 0x00, 0xC7, 0x56, 0xE6, 0x98, 0xD5, 0x37, 0x73, + 0xEB, 0xF7, 0xB2, 0x25, 0x36, 0xCB, 0x28, 0x25, + 0x28, 0xC5, 0x7B, 0xD8, 0x00, 0x4F, 0xA3, 0x78, + 0xDF, 0xA9, 0x48, 0xB4, 0x9F, 0x48, 0x45, 0xA5, + 0x62, 0xF7, 0xC0, 0x43, 0xDC, 0x68, 0xDF, 0x5F, + 0xDD, 0x33, 0x56, 0xFC, 0xAA, 0x1B, 0x35, 0x33 + }, + { + 0x28, 0xE7, 0x5A, 0xDC, 0x35, 0xCA, 0xF9, 0x5D, + 0x27, 0xF0, 0x0B, 0xBA, 0xF4, 0x3A, 0x77, 0x47, + 0x10, 0xF4, 0x55, 0x6A, 0x62, 0x70, 0x87, 0xAC, + 0x11, 0xB3, 0x74, 0xE5, 0x0F, 0x0F, 0x8E, 0x0B, + 0x8B, 0xF9, 0xE5, 0x60, 0x64, 0x2A, 0x95, 0x87, + 0x10, 0xB7, 0xDA, 0x0F, 0x90, 0x90, 0xD6, 0xC7, + 0x4E, 0xDE, 0x84, 0x04, 0x3D, 0xB4, 0xBC, 0x6E, + 0x51, 0x9D, 0x16, 0x84, 0xF5, 0xD5, 0x32, 0x60 + }, + { + 0x17, 0xC8, 0x35, 0x01, 0xF8, 0xA9, 0x0D, 0x3C, + 0x88, 0x50, 0xD9, 0xFD, 0xCC, 0x1D, 0xE4, 0x28, + 0x01, 0x61, 0xEE, 0x2F, 0xD5, 0xC1, 0x7B, 0x70, + 0x72, 0xA3, 0x31, 0xED, 0x4A, 0x81, 0xC2, 0x2A, + 0x63, 0x8A, 0xBD, 0xE8, 0x33, 0xDE, 0x77, 0xC6, + 0x54, 0xC1, 0x3F, 0xF8, 0xBD, 0x51, 0xF1, 0x74, + 0xEF, 0x66, 0x74, 0x7E, 0x0C, 0x86, 0x8F, 0x0E, + 0x47, 0x28, 0xA8, 0x2C, 0x5C, 0x98, 0x07, 0xAB + }, + { + 0xAE, 0xFC, 0xAD, 0xB2, 0x73, 0x14, 0x34, 0x58, + 0xEE, 0xF0, 0x3E, 0x9D, 0x5C, 0x92, 0x3D, 0x84, + 0x93, 0x56, 0xD6, 0x75, 0x99, 0xEF, 0xA3, 0x52, + 0x63, 0x52, 0x82, 0xA4, 0x5D, 0xDA, 0xAC, 0x5E, + 0x88, 0x00, 0x45, 0xF7, 0xF6, 0x9E, 0x76, 0xCE, + 0x88, 0x41, 0xDB, 0xD1, 0x67, 0xB1, 0x3F, 0x66, + 0xE9, 0xFA, 0xDB, 0xFE, 0x6F, 0x54, 0xF6, 0xD4, + 0xC0, 0x92, 0xD4, 0x7A, 0x0C, 0x0A, 0xBF, 0x2E + }, + { + 0x38, 0x17, 0x92, 0x25, 0x50, 0xCF, 0xE0, 0x53, + 0x3A, 0xB0, 0xDD, 0xC8, 0xF8, 0x90, 0xE7, 0xE3, + 0x55, 0x02, 0x46, 0xAA, 0xB2, 0x0A, 0xD0, 0xA1, + 0x5C, 0x21, 0x6C, 0xA1, 0xCA, 0x13, 0x80, 0x48, + 0xDF, 0x96, 0x90, 0x04, 0xF5, 0x0A, 0x22, 0x56, + 0x48, 0x11, 0x91, 0xBF, 0xB5, 0x41, 0x80, 0x54, + 0x5A, 0x9C, 0xE8, 0xD4, 0x01, 0xED, 0xAA, 0xE0, + 0x31, 0x86, 0xB9, 0xE1, 0x63, 0x33, 0x14, 0xB6 + }, + { + 0xD1, 0x83, 0xDA, 0xF3, 0x2C, 0x1E, 0x05, 0x2D, + 0x80, 0x00, 0x3F, 0xB6, 0xFA, 0xB6, 0x97, 0xCF, + 0xD9, 0x05, 0xB7, 0x34, 0xDC, 0x37, 0xF1, 0x2F, + 0x27, 0x81, 0x83, 0x4B, 0xC8, 0xE7, 0x37, 0x22, + 0x48, 0xDE, 0xC1, 0x93, 0xB5, 0xDA, 0x56, 0x5D, + 0x85, 0x29, 0xB3, 0x36, 0xFE, 0x19, 0x4B, 0xF4, + 0x57, 0x01, 0x83, 0xD6, 0x98, 0x7A, 0xC5, 0x47, + 0x0F, 0x7A, 0x73, 0xA0, 0x81, 0xBC, 0x70, 0x76 + }, + { + 0x74, 0x93, 0x3D, 0xAB, 0xD3, 0xBC, 0xBA, 0xDE, + 0x2B, 0x93, 0x97, 0x46, 0x30, 0xAF, 0x6A, 0x18, + 0x35, 0x2A, 0x8C, 0xC9, 0xC7, 0x41, 0x2C, 0x29, + 0xC9, 0x40, 0xEF, 0x87, 0x81, 0xE4, 0x73, 0xD1, + 0x34, 0x7F, 0x90, 0x26, 0xC2, 0x6B, 0xF9, 0x99, + 0x1C, 0xCD, 0xA4, 0x35, 0x8F, 0x03, 0xFF, 0x2A, + 0x79, 0xDD, 0x2E, 0xE1, 0x44, 0xBB, 0x3C, 0x7B, + 0x49, 0xD9, 0x66, 0x39, 0x25, 0xFB, 0x45, 0x2E + }, + { + 0x74, 0x38, 0x0E, 0x27, 0x78, 0x3C, 0xB6, 0x06, + 0x67, 0xCD, 0xFD, 0x4B, 0xD2, 0xB0, 0xD5, 0x5D, + 0x29, 0xBD, 0x37, 0x83, 0x7C, 0x6C, 0x95, 0x42, + 0x38, 0xAF, 0x3B, 0xC0, 0x76, 0xEA, 0xAF, 0x18, + 0xDF, 0x73, 0x3A, 0x41, 0x0E, 0x73, 0x87, 0xFD, + 0x05, 0x21, 0xCD, 0x85, 0xC0, 0xFC, 0x09, 0x85, + 0xA3, 0xDB, 0xB5, 0x1E, 0x80, 0x6C, 0xE6, 0x5D, + 0x89, 0x44, 0xCF, 0xB2, 0x35, 0xB9, 0xEB, 0x78 + }, + { + 0xB5, 0x2E, 0x9D, 0xE1, 0x98, 0xDE, 0x9E, 0xAF, + 0x8B, 0xEF, 0x12, 0x08, 0x37, 0xD5, 0xD2, 0x85, + 0x67, 0xD7, 0x97, 0xA0, 0xD3, 0xAD, 0xF0, 0x82, + 0x60, 0x0D, 0xE7, 0xD3, 0x1A, 0x7D, 0xF1, 0xDD, + 0x00, 0xC4, 0xF8, 0x65, 0x56, 0xFF, 0x79, 0xF4, + 0xB3, 0x4A, 0x3D, 0xDA, 0xC3, 0x31, 0x73, 0x9E, + 0xC2, 0xBF, 0x66, 0xC4, 0x49, 0x7D, 0x06, 0xD3, + 0x9E, 0x98, 0x49, 0x9E, 0x9E, 0xFA, 0xD3, 0x62 + }, + { + 0x22, 0x57, 0x7E, 0xF8, 0x49, 0x7A, 0x97, 0x75, + 0xCD, 0xE2, 0xF0, 0x5C, 0xBC, 0xCE, 0xF6, 0xC4, + 0xCA, 0xA0, 0xAD, 0x46, 0xC6, 0x95, 0x76, 0x27, + 0xBD, 0x02, 0x78, 0x46, 0x8C, 0xE4, 0x74, 0xB9, + 0x69, 0x17, 0x4A, 0x9A, 0x7B, 0xDB, 0xAB, 0xAB, + 0x39, 0x5C, 0x54, 0x1F, 0x4D, 0x73, 0x39, 0xD0, + 0xE4, 0x83, 0x01, 0x2F, 0xA2, 0xD9, 0x3E, 0x58, + 0x76, 0x29, 0xC0, 0x64, 0x3E, 0x2A, 0x6C, 0x64 + }, + { + 0xCC, 0x75, 0x6E, 0x15, 0x86, 0x9D, 0xEF, 0x1A, + 0x24, 0x23, 0x43, 0x7A, 0xFF, 0x3D, 0x95, 0xEA, + 0x4E, 0xF5, 0x63, 0xF7, 0x23, 0xD1, 0xFB, 0x46, + 0x49, 0xF1, 0xE0, 0xFE, 0x61, 0x27, 0xA7, 0x56, + 0xAE, 0xD0, 0x25, 0x34, 0xA0, 0x2C, 0xCD, 0x8B, + 0x06, 0x37, 0x3F, 0xBF, 0xCA, 0x60, 0x11, 0x8B, + 0xD5, 0x56, 0xB7, 0x37, 0x66, 0xF3, 0xCE, 0x78, + 0xF0, 0xDD, 0x2A, 0x75, 0xC6, 0x7D, 0xA3, 0x31 + }, + { + 0x06, 0x4F, 0x9B, 0x5E, 0x95, 0x34, 0x03, 0x49, + 0x32, 0x63, 0x80, 0xF1, 0xA9, 0x8B, 0xC2, 0x4B, + 0x84, 0x53, 0x1C, 0x52, 0x23, 0x71, 0xC8, 0x93, + 0xA6, 0x1B, 0x18, 0xE5, 0x01, 0xB4, 0xD0, 0x9A, + 0x7C, 0x0D, 0x2B, 0x38, 0x9F, 0x70, 0x2B, 0xC6, + 0xF2, 0x6D, 0xD9, 0x0F, 0x5E, 0x85, 0x63, 0xAD, + 0xFD, 0x9E, 0x11, 0xFE, 0xA8, 0xEA, 0x14, 0xEB, + 0xC3, 0x2B, 0x70, 0x5A, 0x9C, 0xF5, 0xFE, 0x74 + }, + { + 0x81, 0x1D, 0x84, 0x03, 0xB4, 0xF7, 0x3C, 0x2B, + 0xFD, 0x16, 0x40, 0xC7, 0xE7, 0xFF, 0x7D, 0x1A, + 0xAB, 0xDB, 0x13, 0x11, 0xC2, 0x78, 0xA3, 0xC0, + 0x89, 0x7C, 0x1E, 0x2A, 0x55, 0x2D, 0x95, 0xE9, + 0xE1, 0xF4, 0xC1, 0xE5, 0xE3, 0x6D, 0x57, 0x23, + 0xC8, 0x52, 0xBD, 0xA8, 0x7E, 0xD5, 0x54, 0x27, + 0x4E, 0x53, 0x75, 0xD5, 0x3F, 0x7F, 0xC4, 0x9A, + 0xD7, 0xE5, 0x2D, 0xBB, 0xC7, 0x6E, 0x59, 0x9A + }, + { + 0xA3, 0x0E, 0xD3, 0x24, 0xAD, 0xC3, 0xFC, 0x8F, + 0x97, 0x6D, 0xE5, 0x8A, 0xD8, 0x0F, 0x4F, 0x6E, + 0xF8, 0xE7, 0xC4, 0xFD, 0xB3, 0x27, 0x80, 0xC5, + 0xA5, 0xEB, 0xB2, 0xAF, 0x93, 0x8A, 0x39, 0xCD, + 0x10, 0xA7, 0xD8, 0x50, 0x8E, 0x18, 0x56, 0x5F, + 0xA3, 0xF4, 0xE4, 0x80, 0x1A, 0xC2, 0xEE, 0xDA, + 0x5A, 0x6D, 0xFD, 0x40, 0xEC, 0x9C, 0x44, 0xB0, + 0x92, 0xE3, 0x27, 0x24, 0xEC, 0x72, 0x97, 0x42 + }, + { + 0xB5, 0xC4, 0xEC, 0x0F, 0xB2, 0x27, 0xB1, 0x7F, + 0x3E, 0x7D, 0x8B, 0x9D, 0x90, 0x60, 0xDB, 0xA4, + 0xCC, 0xA5, 0xF0, 0x0D, 0x97, 0x56, 0x1C, 0x7F, + 0x6B, 0x48, 0x56, 0x00, 0xDE, 0xE6, 0x4A, 0xE1, + 0xA3, 0x33, 0x31, 0xC1, 0x89, 0xB4, 0xC1, 0x50, + 0xDC, 0x62, 0xFA, 0x14, 0xE1, 0x7F, 0x15, 0x33, + 0xB0, 0x1E, 0x37, 0xE4, 0xFC, 0x37, 0xB7, 0xBC, + 0x8A, 0x05, 0xA4, 0xC9, 0x34, 0x8E, 0x65, 0x10 + }, + { + 0xCE, 0x0B, 0x06, 0xC0, 0x19, 0xCA, 0x67, 0xA1, + 0x65, 0x81, 0xF0, 0xEF, 0x35, 0xA6, 0x85, 0x70, + 0xE7, 0xBD, 0x60, 0x4C, 0xAC, 0xF4, 0x68, 0xCA, + 0xE4, 0xA2, 0x45, 0xEA, 0xF6, 0x59, 0x09, 0x9F, + 0x67, 0xAF, 0x1F, 0xE7, 0x82, 0x96, 0x05, 0xC7, + 0xD6, 0x92, 0x2D, 0x34, 0x28, 0x81, 0x56, 0xD5, + 0x90, 0xBE, 0x80, 0x73, 0x81, 0x86, 0xCB, 0xB3, + 0xFB, 0x64, 0x70, 0xE0, 0x9E, 0x8B, 0xD5, 0xC3 + }, + { + 0x9C, 0x1F, 0x02, 0xC3, 0x8F, 0x8C, 0xC2, 0xFB, + 0x84, 0x34, 0xEA, 0x7C, 0x32, 0xA4, 0xF2, 0x1F, + 0xB6, 0xFE, 0x6E, 0x56, 0xF1, 0x15, 0x1D, 0x45, + 0xE1, 0x18, 0x66, 0xDF, 0xFE, 0x72, 0x55, 0x00, + 0x4F, 0xE2, 0xA2, 0x15, 0xB3, 0x8B, 0x3D, 0x04, + 0x49, 0x39, 0x2C, 0xD5, 0x58, 0x1E, 0x19, 0xFE, + 0x54, 0x44, 0x5D, 0x56, 0x8A, 0xAD, 0x76, 0x25, + 0x58, 0x21, 0x01, 0xDB, 0xD0, 0x4F, 0xD0, 0x03 + }, + { + 0xC6, 0xAD, 0x98, 0xDA, 0x09, 0xB4, 0x05, 0x46, + 0x12, 0x76, 0xBD, 0x93, 0xFB, 0x58, 0x78, 0x1F, + 0x84, 0x90, 0xF1, 0x76, 0x46, 0x00, 0x6D, 0xA3, + 0x4C, 0x3B, 0xF0, 0xB7, 0x57, 0xAB, 0xA2, 0x56, + 0x01, 0x28, 0xEE, 0xA8, 0xDF, 0x9F, 0xD1, 0xAE, + 0xC9, 0x3E, 0x37, 0xA6, 0x68, 0x7F, 0xD3, 0x26, + 0x2E, 0x6D, 0x71, 0xB8, 0x40, 0xD9, 0x09, 0x08, + 0xFA, 0x95, 0x46, 0x02, 0xE5, 0xD8, 0xC5, 0xA7 + }, + { + 0x79, 0x79, 0xC1, 0x33, 0xC0, 0x4B, 0xB8, 0x1C, + 0x32, 0x75, 0x61, 0x0C, 0xFF, 0xBE, 0x3D, 0x30, + 0xF9, 0x45, 0xEF, 0x00, 0x87, 0xFE, 0x43, 0x6D, + 0x95, 0xA2, 0x98, 0xDF, 0x6A, 0xD8, 0x24, 0x72, + 0xB0, 0x18, 0x40, 0xC2, 0x14, 0x33, 0xB1, 0xFE, + 0x44, 0x3D, 0x91, 0x23, 0xD6, 0xF3, 0xA9, 0xB1, + 0x6C, 0x75, 0x7E, 0x71, 0xFC, 0xFB, 0x16, 0xD0, + 0xEF, 0x1F, 0x09, 0xF0, 0xB1, 0xB7, 0x6A, 0xA4 + }, + { + 0xC0, 0x85, 0x89, 0xF5, 0xEB, 0xE0, 0x10, 0x24, + 0x52, 0xCC, 0x46, 0x4B, 0x6F, 0x66, 0x49, 0x3F, + 0xB9, 0x96, 0x1C, 0x9C, 0xA0, 0x1C, 0xD1, 0xD0, + 0x80, 0x37, 0x99, 0x21, 0x44, 0x13, 0x0A, 0x9F, + 0xC1, 0xD5, 0xC4, 0x9D, 0xCD, 0x27, 0xD0, 0x9D, + 0xF3, 0x4E, 0x29, 0x73, 0xD7, 0x59, 0x37, 0xF9, + 0x5E, 0x0E, 0x6F, 0x6D, 0x42, 0xF0, 0xA7, 0x76, + 0x65, 0xB8, 0x95, 0xA4, 0xA9, 0x7C, 0x41, 0x57 + }, + { + 0x90, 0x11, 0xC4, 0xA5, 0x31, 0x70, 0x7E, 0x94, + 0x17, 0x68, 0x9E, 0x20, 0xD8, 0xD3, 0xF3, 0x41, + 0x18, 0x1B, 0x1C, 0x82, 0x7B, 0xA0, 0xEB, 0x47, + 0xC4, 0xFF, 0x7F, 0xD6, 0x32, 0xEA, 0x13, 0x60, + 0x8B, 0xB6, 0x73, 0x1A, 0x68, 0x3B, 0x51, 0xB0, + 0x08, 0x68, 0xE7, 0xE1, 0xBD, 0x2E, 0x98, 0xF1, + 0x7F, 0x53, 0xA1, 0xE9, 0x9C, 0xF9, 0x81, 0x6F, + 0x3A, 0xA5, 0x35, 0x43, 0xA6, 0xB9, 0x37, 0x01 + }, + { + 0x9D, 0x20, 0x16, 0x1F, 0x21, 0x76, 0xFC, 0xDE, + 0xD5, 0xE4, 0xB0, 0xB8, 0x14, 0xD8, 0x24, 0x7B, + 0xB4, 0x85, 0xB2, 0x5E, 0xF0, 0x35, 0xC5, 0xC7, + 0x65, 0x97, 0x97, 0x72, 0xF2, 0x71, 0xDF, 0xED, + 0xCE, 0xFD, 0xA3, 0xBE, 0xED, 0xCF, 0x0B, 0xC8, + 0x92, 0xFF, 0x4D, 0xBA, 0xF3, 0xE7, 0xFA, 0xC0, + 0x57, 0x61, 0x0D, 0xB7, 0xB0, 0x87, 0x5F, 0x37, + 0xB4, 0xEF, 0xE0, 0x54, 0x0C, 0x99, 0x19, 0xDA + }, + { + 0xCA, 0x55, 0x94, 0xAF, 0xAD, 0xD5, 0xBD, 0xB5, + 0x3E, 0x43, 0x71, 0xE2, 0x4D, 0xEE, 0x64, 0x46, + 0xE4, 0x49, 0xFB, 0x30, 0x83, 0x5F, 0x5F, 0xC4, + 0x0E, 0xCB, 0x34, 0xB8, 0xA3, 0xF7, 0x22, 0x27, + 0x20, 0xFE, 0x83, 0x2B, 0xE4, 0x89, 0x22, 0x0C, + 0x1A, 0x02, 0x3A, 0x87, 0x78, 0x02, 0x77, 0x69, + 0x6A, 0x77, 0x1E, 0x2B, 0xFC, 0x90, 0x3E, 0x2E, + 0x84, 0x87, 0x4F, 0x10, 0x9B, 0x07, 0x2D, 0xAF + }, + { + 0xC3, 0xE4, 0xE3, 0x56, 0x34, 0x56, 0xF4, 0x1D, + 0xAF, 0xC2, 0xE6, 0xB7, 0xF2, 0xF9, 0x09, 0xE2, + 0xD9, 0xA0, 0xA8, 0x09, 0x31, 0x71, 0x56, 0x3D, + 0x77, 0xC7, 0x1C, 0xCD, 0x92, 0x93, 0xF6, 0x6F, + 0x39, 0x02, 0x4B, 0x67, 0xB6, 0x93, 0x80, 0x50, + 0xF7, 0x71, 0x0F, 0xE7, 0xAF, 0xF2, 0xB0, 0xC4, + 0xEB, 0x09, 0x13, 0x88, 0x21, 0x40, 0x1A, 0x8D, + 0x22, 0xB5, 0xD2, 0x19, 0xB5, 0x0D, 0x34, 0xC0 + }, + { + 0x18, 0x1D, 0x17, 0xF1, 0xFF, 0x5C, 0x24, 0x3F, + 0x97, 0x8C, 0x8F, 0x21, 0x24, 0x87, 0x23, 0x29, + 0x6A, 0x48, 0xA6, 0xA0, 0x7A, 0x08, 0xF7, 0x7A, + 0xC4, 0xEC, 0x46, 0xA7, 0x21, 0xA6, 0x14, 0x0E, + 0xA3, 0x30, 0x93, 0x00, 0x77, 0x42, 0x85, 0x2E, + 0x83, 0x9F, 0xD7, 0x7F, 0x8F, 0x88, 0x54, 0xFC, + 0xE5, 0xBE, 0x26, 0x16, 0xDC, 0x23, 0x84, 0x51, + 0xCC, 0x2D, 0x2F, 0x10, 0xD1, 0x34, 0x09, 0xEB + }, + { + 0x0B, 0x4C, 0x0E, 0x4D, 0xF2, 0x71, 0xA7, 0x36, + 0xBB, 0x9B, 0xB5, 0x16, 0x83, 0x13, 0x29, 0x10, + 0x4C, 0xB9, 0xD6, 0xC9, 0x12, 0xE9, 0xE5, 0xA5, + 0x22, 0x6A, 0x56, 0x90, 0x02, 0x21, 0xDE, 0x91, + 0xD6, 0x3C, 0x87, 0x7F, 0x50, 0xBF, 0xE6, 0x50, + 0x69, 0xA6, 0xC2, 0x67, 0xE7, 0xCA, 0x77, 0x58, + 0x5A, 0x86, 0x04, 0x9D, 0xF5, 0xB2, 0x3F, 0x0E, + 0xED, 0x23, 0x1B, 0x9D, 0xAC, 0xE5, 0x38, 0x97 + }, + { + 0x95, 0x51, 0x9C, 0x9E, 0xAD, 0xA2, 0x24, 0xCE, + 0xB7, 0x86, 0x16, 0x3F, 0x61, 0x25, 0x9F, 0xD3, + 0x7B, 0x48, 0xE9, 0x1C, 0xA8, 0xC2, 0x66, 0x11, + 0xC2, 0x34, 0xD9, 0xDB, 0x33, 0x27, 0xBE, 0x88, + 0xA6, 0xBF, 0x8C, 0x82, 0x53, 0xF3, 0xD0, 0xF9, + 0x00, 0x1F, 0x68, 0x84, 0x7E, 0x4F, 0x91, 0x96, + 0x22, 0x89, 0x0F, 0x09, 0xCD, 0x37, 0xD8, 0x0A, + 0x09, 0x66, 0x2F, 0x4B, 0xEA, 0x2D, 0x12, 0xF4 + }, + { + 0xF9, 0x01, 0x23, 0x30, 0x64, 0x1E, 0x1B, 0x15, + 0x3D, 0x10, 0x7F, 0x50, 0xFA, 0xDB, 0x8E, 0x7A, + 0xE1, 0xB3, 0xB7, 0x8B, 0x01, 0x2A, 0xF9, 0x6B, + 0x4B, 0x84, 0xC5, 0x81, 0x44, 0x28, 0x89, 0xCE, + 0xDA, 0x63, 0xFD, 0xC2, 0xA2, 0x90, 0x27, 0xFB, + 0x7B, 0xC4, 0xFD, 0xE6, 0xC2, 0x2C, 0x23, 0x29, + 0xC7, 0xD0, 0x68, 0x9B, 0x8A, 0x6D, 0xB1, 0x37, + 0x3F, 0x13, 0x26, 0x23, 0xFA, 0xA0, 0x0C, 0xF9 + }, + { + 0xDA, 0x76, 0xA8, 0xD1, 0xA4, 0xA4, 0x6E, 0x94, + 0x5D, 0x4D, 0x6A, 0xB2, 0x08, 0x63, 0x78, 0x82, + 0x3F, 0x91, 0x1E, 0x84, 0xDE, 0xFB, 0xBE, 0xF5, + 0x52, 0x95, 0xD5, 0x06, 0xB2, 0x14, 0x48, 0x5B, + 0x71, 0xDC, 0x23, 0x27, 0x39, 0x34, 0x78, 0x13, + 0x40, 0x86, 0xCE, 0xD1, 0x03, 0x1A, 0xD5, 0x36, + 0x0D, 0x99, 0x4E, 0x25, 0x43, 0xC5, 0xEF, 0xF2, + 0x33, 0xAA, 0x6A, 0x80, 0x8E, 0x39, 0xAC, 0x9F + }, + { + 0xD1, 0x2C, 0x96, 0x60, 0x6E, 0xAB, 0xDC, 0x11, + 0xF0, 0xE0, 0xCC, 0x8D, 0x0E, 0x28, 0xAE, 0xF5, + 0x99, 0xFB, 0x4C, 0xA4, 0x04, 0xBE, 0x0C, 0x66, + 0x4C, 0x0F, 0x3E, 0xEB, 0x37, 0xC3, 0x85, 0x88, + 0xAE, 0x44, 0x58, 0xEA, 0x28, 0xFA, 0x77, 0xD9, + 0xBF, 0x09, 0x63, 0xB9, 0x91, 0xED, 0x75, 0xF2, + 0xE0, 0x84, 0xD8, 0x2F, 0xAE, 0x9F, 0x57, 0x4E, + 0xF9, 0xF1, 0x24, 0xBE, 0xAD, 0x0B, 0xEB, 0xED + }, + { + 0xFB, 0xBF, 0xFC, 0x89, 0x0E, 0x6F, 0xC4, 0x7F, + 0x8B, 0xA1, 0xD5, 0xAE, 0x6B, 0x57, 0x46, 0x34, + 0xE2, 0x19, 0x15, 0x8F, 0x09, 0x4B, 0x21, 0xDE, + 0xAA, 0x60, 0xA3, 0x77, 0x17, 0x41, 0x0F, 0x88, + 0x51, 0xBC, 0xA4, 0xE3, 0x83, 0xE1, 0x03, 0x52, + 0x3E, 0x39, 0x9E, 0xBC, 0xC3, 0xA2, 0xB5, 0x51, + 0xBC, 0x13, 0xDA, 0x8F, 0xBB, 0xDB, 0x21, 0x08, + 0x19, 0x4D, 0x8F, 0x57, 0x79, 0x79, 0x09, 0xFF + }, + { + 0x04, 0xB2, 0x17, 0x0F, 0xD0, 0xDE, 0xE9, 0xBA, + 0xB8, 0x97, 0x3F, 0xCE, 0x5C, 0x91, 0x83, 0x14, + 0xCC, 0x1E, 0x8E, 0x0C, 0xBE, 0x92, 0xE6, 0xD3, + 0xA7, 0x1B, 0x8D, 0x1E, 0x26, 0xB0, 0xC4, 0x86, + 0xD7, 0xDE, 0x42, 0x1A, 0xDE, 0xC2, 0x71, 0x78, + 0xBC, 0x6C, 0xAB, 0xD9, 0x26, 0xF7, 0xE8, 0xD9, + 0xB1, 0x01, 0xAE, 0x58, 0x34, 0xFD, 0x44, 0x60, + 0xBE, 0x54, 0xC3, 0xB8, 0xCB, 0x1B, 0xBF, 0xCA + }, + { + 0x54, 0xEF, 0x02, 0xD8, 0xD7, 0xBA, 0x3C, 0x79, + 0x02, 0x60, 0xC2, 0xFE, 0x2F, 0x27, 0x27, 0x15, + 0x4B, 0x9E, 0x7D, 0x46, 0xE1, 0x70, 0x77, 0x57, + 0x06, 0xE7, 0xC2, 0x31, 0x4B, 0x60, 0x94, 0xE8, + 0x91, 0x5C, 0xCA, 0x4A, 0x61, 0xEB, 0x75, 0xF5, + 0x77, 0x05, 0x86, 0x29, 0x85, 0x79, 0x35, 0x75, + 0xFA, 0x7E, 0x22, 0x92, 0x27, 0x16, 0x6A, 0x3C, + 0x68, 0x71, 0x7F, 0xC2, 0xD6, 0x6C, 0x50, 0xCD + }, + { + 0x40, 0xA7, 0xE7, 0x0A, 0xDF, 0x3E, 0xB4, 0xE6, + 0x20, 0xE2, 0x6B, 0xB3, 0x70, 0x99, 0x75, 0x10, + 0xB5, 0x52, 0xDB, 0x39, 0xDA, 0x80, 0xC1, 0x46, + 0x06, 0xEF, 0x8F, 0x88, 0x30, 0xD6, 0xDC, 0xF8, + 0x70, 0x11, 0x6F, 0x19, 0x8F, 0x44, 0x78, 0x5C, + 0xA1, 0xFE, 0x89, 0x04, 0x37, 0x55, 0x71, 0x08, + 0x00, 0x76, 0xDD, 0x79, 0x7E, 0xE9, 0xD0, 0xE2, + 0x06, 0xD1, 0x79, 0xB3, 0x07, 0x14, 0xD2, 0xBF + }, + { + 0x3C, 0x9F, 0x11, 0x31, 0x41, 0x51, 0x29, 0xAA, + 0x18, 0x06, 0xF9, 0x80, 0x91, 0x84, 0x58, 0xAE, + 0x81, 0xDD, 0x70, 0x2B, 0xFF, 0xE0, 0xB9, 0x41, + 0xA6, 0x0E, 0xDD, 0x4A, 0x89, 0x07, 0x5F, 0xFB, + 0xFF, 0xBD, 0x08, 0x6C, 0xC6, 0xE4, 0x52, 0x06, + 0x04, 0x70, 0xD9, 0x6B, 0x4F, 0x54, 0xE0, 0x65, + 0x7D, 0x9F, 0xE6, 0xD4, 0x9A, 0x7A, 0x6D, 0x36, + 0xE2, 0x94, 0x7F, 0xC6, 0x65, 0x37, 0x85, 0x93 + }, + { + 0xF8, 0x8F, 0xCB, 0xE8, 0x36, 0x93, 0x30, 0x95, + 0xD7, 0x78, 0x2B, 0x95, 0x67, 0x98, 0xA4, 0x8D, + 0x1C, 0x50, 0xAE, 0x68, 0xF0, 0x67, 0x5A, 0x54, + 0x2B, 0xAB, 0xDC, 0x7A, 0xB8, 0xBE, 0xE1, 0x08, + 0x3B, 0xD9, 0x40, 0xA6, 0x12, 0x9A, 0xD5, 0x76, + 0x54, 0xE1, 0x01, 0x6C, 0x5D, 0xA4, 0x9B, 0xD7, + 0x18, 0x72, 0xD9, 0x16, 0x09, 0x1C, 0xD5, 0x71, + 0x50, 0xE2, 0x01, 0xF5, 0x69, 0x6B, 0x13, 0x2A + }, + { + 0x23, 0x27, 0x14, 0x5E, 0x00, 0xFF, 0x50, 0x1F, + 0x27, 0xDF, 0x2C, 0xB1, 0x2B, 0x57, 0xF0, 0x26, + 0xD7, 0xDB, 0x89, 0xB8, 0xC9, 0x2F, 0xFB, 0xCD, + 0x86, 0x92, 0x00, 0xFB, 0x0E, 0x42, 0x86, 0x06, + 0x37, 0xC3, 0x58, 0x7E, 0x1B, 0xF9, 0xB2, 0xEA, + 0xBC, 0xE5, 0x73, 0x47, 0x37, 0x1A, 0xE0, 0x53, + 0x1E, 0xFB, 0x1D, 0x87, 0x37, 0xA3, 0x0A, 0x11, + 0xC3, 0x60, 0x0E, 0xC2, 0xDB, 0xDA, 0xF1, 0x54 + }, + { + 0x14, 0x8C, 0x90, 0xA8, 0x6F, 0x8A, 0xF6, 0x5C, + 0x0D, 0xB4, 0xB3, 0xD0, 0x49, 0x26, 0x4C, 0x19, + 0xC7, 0x6A, 0x94, 0xF2, 0xC4, 0x59, 0x9B, 0x5D, + 0x18, 0xC1, 0xA7, 0x01, 0xFD, 0xBC, 0x77, 0x02, + 0x81, 0xB4, 0x9F, 0xC7, 0xDF, 0xD4, 0x12, 0xC2, + 0x4E, 0x02, 0xFB, 0xE6, 0xD2, 0xB1, 0x2D, 0x66, + 0xA5, 0xA3, 0x78, 0x14, 0x72, 0x16, 0x3B, 0x93, + 0xD1, 0xF5, 0x79, 0x39, 0x29, 0x0F, 0x40, 0x20 + }, + { + 0xF9, 0x02, 0xE1, 0xC5, 0x93, 0x21, 0xE8, 0xFA, + 0x99, 0x2F, 0x97, 0x26, 0x6B, 0xCF, 0x83, 0xB3, + 0x6E, 0xA6, 0x83, 0xAF, 0x6C, 0xEB, 0xFD, 0xAF, + 0xED, 0xFB, 0x6E, 0xE9, 0xB5, 0x5C, 0xF8, 0x15, + 0x92, 0xFC, 0xFF, 0x71, 0x5E, 0xD3, 0xAA, 0x6D, + 0x99, 0x24, 0xE2, 0x8B, 0x1A, 0x40, 0x33, 0xFA, + 0x60, 0x42, 0xAF, 0x2D, 0xC1, 0x18, 0x92, 0x32, + 0x0C, 0xB1, 0x5C, 0x9F, 0xF8, 0x96, 0x50, 0x6D + }, + { + 0x70, 0x25, 0xE4, 0x97, 0xD8, 0x3F, 0x16, 0x04, + 0x10, 0xC9, 0xCB, 0x94, 0x97, 0x55, 0x27, 0xB6, + 0xF4, 0xCD, 0x8F, 0x4B, 0x9C, 0x09, 0xA5, 0x8E, + 0x50, 0x8F, 0xE8, 0xF8, 0x75, 0xA2, 0xC5, 0x4F, + 0xB4, 0xF9, 0xDA, 0x88, 0x8A, 0x06, 0x45, 0xC4, + 0x7C, 0x37, 0xED, 0x88, 0x6C, 0x0F, 0x05, 0xE4, + 0xAA, 0x46, 0x1D, 0xA0, 0xAF, 0x27, 0x7F, 0x84, + 0x18, 0xAA, 0xE0, 0xD1, 0xC8, 0xF6, 0x2A, 0x9C + }, + { + 0x98, 0xF3, 0x95, 0x31, 0x7C, 0xA7, 0x57, 0x63, + 0x73, 0xA1, 0x0E, 0x82, 0x79, 0xBD, 0x85, 0x8A, + 0x11, 0x73, 0x42, 0xCD, 0x41, 0xA9, 0xC3, 0xE8, + 0x0D, 0xD6, 0x73, 0x68, 0x1E, 0x16, 0x07, 0x42, + 0x8D, 0x00, 0xAD, 0x92, 0x4B, 0x90, 0x54, 0x55, + 0x6B, 0x88, 0xD0, 0x7F, 0x40, 0xE9, 0xEC, 0x93, + 0x90, 0x90, 0xB5, 0x2D, 0x09, 0x53, 0x2D, 0xEA, + 0x6E, 0xAE, 0xA6, 0x67, 0xD1, 0x3A, 0xB2, 0xC8 + }, + { + 0x38, 0xCC, 0x4C, 0x5D, 0x10, 0xD9, 0x6A, 0x73, + 0x32, 0x9C, 0xC6, 0x1C, 0x51, 0x1B, 0x6F, 0x67, + 0x77, 0xA7, 0xE0, 0x01, 0xB1, 0x78, 0xE8, 0x1B, + 0x0E, 0x57, 0xCC, 0x4A, 0xC9, 0x89, 0xE3, 0xE9, + 0xB1, 0x9C, 0x3F, 0xC6, 0xDF, 0x70, 0xA3, 0x07, + 0x22, 0xB9, 0xA2, 0x13, 0x38, 0x36, 0xBA, 0x58, + 0x1F, 0xE1, 0x08, 0xE5, 0x3E, 0xBD, 0x8F, 0xFE, + 0xFB, 0x5E, 0xE5, 0x17, 0x17, 0xA9, 0xA7, 0x8E + }, + { + 0x38, 0x2C, 0xB2, 0xAF, 0x17, 0x11, 0x3C, 0xCC, + 0xD6, 0xD8, 0x20, 0xF8, 0x63, 0xBB, 0xE8, 0x32, + 0x02, 0xD1, 0x81, 0x3B, 0xC4, 0xB5, 0x39, 0xE6, + 0x53, 0x72, 0xF6, 0x76, 0x92, 0xBA, 0xFF, 0x91, + 0xA7, 0xF6, 0xF4, 0xA8, 0x0C, 0x2D, 0x74, 0xD0, + 0x92, 0x7A, 0xCF, 0x7B, 0xDC, 0x65, 0x01, 0x22, + 0x61, 0x29, 0xA4, 0xDD, 0x05, 0x6E, 0x6B, 0x34, + 0xB9, 0xCF, 0xEE, 0x0A, 0xCD, 0x04, 0xD5, 0x25 + }, + { + 0xBD, 0xF9, 0xED, 0xC5, 0x4B, 0x48, 0xDE, 0xB7, + 0xE8, 0xDF, 0x69, 0x3E, 0xD2, 0xE5, 0xC2, 0xF5, + 0x45, 0x1B, 0x03, 0x00, 0x81, 0x57, 0x58, 0x17, + 0x9C, 0xD4, 0x9B, 0x4E, 0x76, 0xB6, 0xA9, 0x55, + 0x6A, 0xC8, 0x22, 0x81, 0x3A, 0x3E, 0x30, 0x1C, + 0x36, 0x40, 0x50, 0x0C, 0xAB, 0x83, 0xAC, 0x69, + 0x31, 0x63, 0x56, 0x92, 0xF1, 0x71, 0x4F, 0x8B, + 0x2D, 0xA1, 0xB6, 0x05, 0xE0, 0x6E, 0x49, 0xDA + }, + { + 0x15, 0x87, 0x8A, 0x1D, 0xE3, 0x2B, 0xD5, 0xA2, + 0x23, 0xE1, 0xC0, 0x31, 0xBE, 0xB4, 0xF2, 0x7E, + 0x86, 0x62, 0x92, 0x8A, 0x00, 0x3E, 0x67, 0xAF, + 0x58, 0x50, 0xDB, 0x80, 0x20, 0x14, 0x8D, 0x5C, + 0xDC, 0x4E, 0x12, 0x01, 0x24, 0x31, 0x00, 0xD1, + 0xF7, 0x71, 0xE2, 0xCA, 0x00, 0x73, 0x20, 0x9F, + 0xE5, 0xE9, 0xC5, 0x76, 0x22, 0xD1, 0xEB, 0xF6, + 0xC7, 0xA3, 0x87, 0x9A, 0xF3, 0x51, 0x86, 0x7F + }, + { + 0x0E, 0x36, 0xA4, 0x93, 0xB4, 0x48, 0xE8, 0xD1, + 0x4E, 0x48, 0xD5, 0xCA, 0x25, 0xBC, 0xCE, 0x48, + 0xFB, 0x7A, 0x69, 0x62, 0x80, 0xD5, 0x34, 0x72, + 0x43, 0x02, 0x4C, 0xC5, 0x10, 0xB6, 0x42, 0x64, + 0x4B, 0xE6, 0xFC, 0xAD, 0x33, 0xDF, 0x32, 0x37, + 0xF7, 0xD6, 0xCC, 0xE0, 0xAE, 0x04, 0xED, 0xE4, + 0x90, 0x27, 0xD5, 0x50, 0xF4, 0xB2, 0x98, 0xB4, + 0x1D, 0x1B, 0xEC, 0xE8, 0xFB, 0x08, 0x72, 0x67 + }, + { + 0x86, 0x41, 0x33, 0x9E, 0x2F, 0x56, 0x4E, 0xCB, + 0x01, 0x2C, 0xD1, 0x47, 0x48, 0x7E, 0x98, 0xDA, + 0x5A, 0xE0, 0x4E, 0x5D, 0xD0, 0x56, 0xA5, 0x5A, + 0x1B, 0x5F, 0x7C, 0xAA, 0x1B, 0x16, 0x52, 0xC1, + 0x74, 0xCF, 0x0F, 0xC3, 0xC3, 0xF7, 0x90, 0x75, + 0xD4, 0xCD, 0xE4, 0x9C, 0x44, 0xB2, 0x31, 0x00, + 0x4A, 0x95, 0x3F, 0xD7, 0x06, 0x23, 0xB8, 0xF2, + 0x7C, 0xBE, 0x2A, 0x24, 0x2B, 0xD7, 0x19, 0x17 + }, + { + 0xA2, 0x3E, 0x2F, 0x31, 0x93, 0x2B, 0x03, 0x92, + 0xA0, 0x01, 0xE0, 0x52, 0xF4, 0x61, 0x71, 0xBE, + 0xC3, 0x9A, 0x4C, 0xA5, 0xBF, 0x26, 0x98, 0x68, + 0xF7, 0x9C, 0xA9, 0xAB, 0xAC, 0xF8, 0x02, 0x68, + 0xDC, 0x1C, 0x8B, 0xAF, 0xF0, 0x67, 0xC1, 0x0B, + 0x5E, 0x1D, 0x7E, 0xFC, 0x72, 0x7C, 0x07, 0xF9, + 0x66, 0x34, 0x79, 0x77, 0x35, 0x33, 0xB4, 0xC1, + 0x90, 0xC6, 0x67, 0x1F, 0x10, 0x38, 0x68, 0x3D + }, + { + 0xC9, 0x3B, 0x3C, 0x72, 0xE5, 0x1D, 0x4B, 0xDE, + 0xBF, 0x7A, 0xDF, 0x92, 0x04, 0x8C, 0xFE, 0xA6, + 0xE9, 0x4B, 0xA8, 0x94, 0xD8, 0x08, 0x65, 0x73, + 0xBA, 0x63, 0xD1, 0x6E, 0x7E, 0x53, 0x0A, 0x79, + 0x28, 0xF0, 0xB6, 0x73, 0xB6, 0xE8, 0xB5, 0x41, + 0x27, 0xE6, 0xC8, 0xBB, 0x27, 0xE5, 0xE1, 0x9B, + 0xFF, 0x3E, 0xE0, 0x40, 0xD7, 0x9E, 0x5D, 0xA9, + 0xA5, 0xFE, 0x50, 0x48, 0x8A, 0x0C, 0xDD, 0xF5 + }, + { + 0x0C, 0x7E, 0x94, 0x36, 0x83, 0x9A, 0xFE, 0xAD, + 0x6F, 0x2B, 0x3A, 0x22, 0x32, 0xB9, 0xC2, 0x9A, + 0xD2, 0xEE, 0x8E, 0x6C, 0xFC, 0x67, 0xB8, 0x24, + 0x13, 0x41, 0x89, 0x4F, 0x38, 0x34, 0x3E, 0x72, + 0x97, 0x7B, 0x4D, 0x37, 0xC5, 0x11, 0x1F, 0x73, + 0x07, 0xC6, 0xB6, 0x16, 0x5A, 0xC7, 0x3D, 0xC5, + 0xCB, 0x85, 0x43, 0x8B, 0xFE, 0xF0, 0x85, 0x60, + 0x7E, 0x19, 0x8B, 0xA9, 0x99, 0x6A, 0x11, 0xAF + }, + { + 0xB4, 0x47, 0xEB, 0x18, 0x29, 0xBF, 0x4D, 0xCE, + 0x24, 0xBF, 0x2F, 0xBB, 0x8C, 0x86, 0xA6, 0xD4, + 0x27, 0x59, 0x10, 0xF2, 0xF5, 0xB9, 0xA4, 0x2A, + 0x82, 0x17, 0x44, 0xC3, 0xFE, 0x0C, 0xCA, 0xF8, + 0xD7, 0x25, 0xC8, 0x0A, 0x42, 0xF9, 0xAD, 0x4E, + 0x68, 0xED, 0xBD, 0x03, 0x1D, 0xAB, 0x12, 0x31, + 0xB4, 0xE3, 0x42, 0x7C, 0x33, 0xEC, 0x2E, 0xEE, + 0x2F, 0x6B, 0xA7, 0x69, 0x34, 0x23, 0x34, 0x97 + }, + { + 0xF1, 0x02, 0xF0, 0xFD, 0xBC, 0x78, 0x5F, 0xFC, + 0x96, 0x9C, 0x4B, 0x07, 0x30, 0x59, 0x57, 0xD5, + 0x32, 0x82, 0x54, 0x11, 0xD7, 0xF1, 0xCC, 0x19, + 0x3E, 0x3C, 0xEE, 0x1A, 0x30, 0x1A, 0x6C, 0x7D, + 0x31, 0x84, 0x07, 0xD7, 0x1F, 0xD6, 0xA8, 0xE4, + 0xDC, 0x57, 0x16, 0x07, 0x46, 0xBB, 0xBE, 0xB2, + 0x76, 0xC0, 0xCD, 0xDA, 0x36, 0x67, 0xDB, 0x49, + 0x04, 0xE7, 0xA9, 0x14, 0x7C, 0x13, 0x19, 0xAF + }, + { + 0x61, 0xEC, 0xAA, 0x7C, 0xFE, 0xA4, 0x63, 0xEE, + 0x5E, 0xDA, 0x78, 0x86, 0xA7, 0x1C, 0xC1, 0x77, + 0x3E, 0x26, 0x70, 0x28, 0xF8, 0x36, 0xF6, 0x3A, + 0xFD, 0x62, 0x20, 0xD8, 0xBD, 0x69, 0x31, 0xC3, + 0xB5, 0x89, 0x3F, 0x83, 0x2D, 0x24, 0x74, 0xBB, + 0x87, 0x92, 0x2B, 0x4D, 0x92, 0xCF, 0x7E, 0xF4, + 0xB3, 0x0A, 0x72, 0x0A, 0xC1, 0xAD, 0x41, 0x07, + 0xB5, 0xB2, 0x94, 0xEC, 0x02, 0x3C, 0x4B, 0xED + }, + { + 0x1D, 0x6D, 0x37, 0x3D, 0x32, 0x5E, 0x2A, 0x6E, + 0x6C, 0xB1, 0x3F, 0x6F, 0x50, 0x8C, 0x03, 0xD4, + 0x9D, 0x76, 0x5C, 0x01, 0x80, 0x68, 0x39, 0xE9, + 0xAF, 0x48, 0x98, 0x09, 0xA6, 0xC9, 0x9B, 0x2F, + 0x9D, 0x58, 0xD9, 0x90, 0xE5, 0xBD, 0x6A, 0x97, + 0x55, 0xF3, 0x43, 0x6E, 0xF4, 0xD4, 0xBA, 0x81, + 0xCD, 0xA7, 0x0D, 0xBD, 0xA5, 0xB6, 0xF0, 0x95, + 0xA4, 0x6B, 0xE1, 0xFA, 0x91, 0xAF, 0x7E, 0x97 + }, + { + 0xD6, 0x54, 0xB9, 0xF0, 0x96, 0xE9, 0xB8, 0xA6, + 0x59, 0xFB, 0x8B, 0x45, 0xA7, 0x1F, 0xDF, 0xFC, + 0xE2, 0x14, 0x38, 0x18, 0xA6, 0xF0, 0xDB, 0x0A, + 0x17, 0x4A, 0x0D, 0x86, 0x13, 0xA6, 0xE5, 0x4D, + 0xB7, 0x85, 0xFD, 0xDE, 0x9C, 0xCE, 0x99, 0x70, + 0x63, 0x80, 0xE6, 0x62, 0x86, 0x0B, 0x62, 0xF9, + 0xE3, 0x29, 0x5B, 0x89, 0x16, 0xCC, 0x3C, 0x5F, + 0xAB, 0xB7, 0xCF, 0x7D, 0x8C, 0x7C, 0xD8, 0xC1 + }, + { + 0xCA, 0xFC, 0x07, 0x76, 0x6A, 0xBA, 0x10, 0xA8, + 0xB7, 0xC7, 0xCE, 0x25, 0x76, 0x61, 0xEE, 0x56, + 0x09, 0xD1, 0x74, 0x25, 0x66, 0x1E, 0x38, 0x36, + 0x50, 0x1C, 0x24, 0x46, 0x03, 0x23, 0xAB, 0xCF, + 0xAE, 0xA1, 0xE7, 0xC9, 0x39, 0xB2, 0x43, 0xC1, + 0x78, 0xBB, 0xB0, 0xAB, 0x23, 0x04, 0x12, 0x4B, + 0x70, 0x13, 0x3A, 0x2E, 0x2A, 0x45, 0x1E, 0xE1, + 0x96, 0x23, 0x61, 0x58, 0xA1, 0xF0, 0x73, 0xEF + }, + { + 0x47, 0xB8, 0x32, 0x6E, 0x06, 0x23, 0xAB, 0x18, + 0x63, 0xA2, 0x8C, 0x4A, 0xD6, 0xE1, 0x15, 0xCA, + 0xD0, 0x25, 0x97, 0x99, 0x46, 0xF6, 0x47, 0x7D, + 0x64, 0xC2, 0xE9, 0xAE, 0x3B, 0x1D, 0x59, 0xC3, + 0x29, 0x17, 0xE4, 0xDF, 0x51, 0x20, 0x83, 0xE8, + 0x79, 0x96, 0x47, 0x66, 0x71, 0x5F, 0x8B, 0x56, + 0x64, 0x11, 0x56, 0xEF, 0xE7, 0xE0, 0x43, 0x31, + 0xB3, 0xF4, 0x8D, 0x6B, 0xCF, 0x3E, 0x84, 0xB6 + }, + { + 0x67, 0x92, 0xC4, 0xC7, 0xA0, 0x88, 0xDA, 0x3F, + 0xBB, 0x5D, 0x70, 0x5C, 0xA4, 0xD1, 0x9F, 0xF6, + 0x2E, 0x6F, 0xE9, 0x0F, 0x53, 0x8B, 0xA5, 0x92, + 0xA2, 0x0F, 0x99, 0x18, 0xB3, 0x9A, 0x9D, 0x23, + 0xF3, 0x9E, 0x2E, 0x1A, 0xA1, 0x04, 0x6D, 0xEF, + 0x49, 0x07, 0xB8, 0x49, 0x68, 0x70, 0x0C, 0x64, + 0xD8, 0x27, 0xEE, 0x69, 0xFE, 0xDF, 0xAD, 0x36, + 0xDD, 0x48, 0x90, 0x86, 0x96, 0x07, 0xE5, 0x24 + }, + { + 0xAE, 0xAA, 0x9C, 0xC1, 0x54, 0x35, 0x7E, 0xE4, + 0xF6, 0xF7, 0xA2, 0xD5, 0x2A, 0x38, 0x52, 0xDB, + 0x68, 0xF1, 0x1A, 0x54, 0x3E, 0xB1, 0xB6, 0x19, + 0x71, 0x4B, 0x48, 0xC0, 0xAB, 0xB3, 0x2C, 0x16, + 0x22, 0x51, 0x54, 0x32, 0x3C, 0xD9, 0x22, 0xFF, + 0x3B, 0x0D, 0xFA, 0xA8, 0x89, 0xB2, 0xD7, 0x6B, + 0xF8, 0x5A, 0xAE, 0x37, 0x37, 0xB8, 0x87, 0x28, + 0x25, 0xDB, 0xDB, 0xA1, 0xB5, 0xA5, 0x21, 0xC9 + }, + { + 0xDC, 0x28, 0xB7, 0xD1, 0x9A, 0x83, 0xE3, 0xFE, + 0x3B, 0x5D, 0x3E, 0x28, 0xEF, 0xF0, 0x3F, 0x00, + 0x12, 0x2A, 0x4F, 0x46, 0xFB, 0x9D, 0x70, 0x8C, + 0xF0, 0xA9, 0x76, 0x43, 0x99, 0x30, 0x3F, 0x54, + 0x10, 0x20, 0xD9, 0x0A, 0xE0, 0xBB, 0x07, 0xDD, + 0x8A, 0xD1, 0x26, 0x4B, 0xCD, 0x6E, 0x49, 0x63, + 0xA8, 0xA6, 0x40, 0x42, 0x7C, 0x19, 0xBA, 0xAB, + 0xDC, 0x21, 0xB5, 0xC2, 0x0F, 0x33, 0xEB, 0xA4 + }, + { + 0xD5, 0x43, 0xD5, 0x00, 0x89, 0x75, 0x2B, 0xA1, + 0xB6, 0xFE, 0xAF, 0x11, 0x5E, 0x4F, 0xE3, 0x77, + 0xF0, 0x4E, 0xDA, 0xE4, 0x02, 0x51, 0xE0, 0x1A, + 0x0B, 0x90, 0xC3, 0xDF, 0x0E, 0x6E, 0xAB, 0xDB, + 0x06, 0x9D, 0x6D, 0x43, 0x5B, 0x53, 0xF6, 0x54, + 0xDC, 0x73, 0x28, 0x49, 0xE9, 0x10, 0x6B, 0x06, + 0xBF, 0x5C, 0x02, 0xA9, 0xD1, 0xAC, 0xF7, 0x36, + 0x9B, 0xC2, 0x02, 0xF3, 0x7A, 0x66, 0xEF, 0x98 + }, + { + 0x8C, 0x11, 0x2D, 0xA0, 0x90, 0xAF, 0x8B, 0x4D, + 0x80, 0x6A, 0x42, 0x4A, 0x17, 0x8B, 0x2F, 0x90, + 0x11, 0xA2, 0x07, 0xBC, 0x2A, 0x1A, 0xFE, 0x6C, + 0x15, 0x03, 0x0D, 0xA3, 0x8B, 0x0C, 0xDF, 0x1F, + 0x28, 0x27, 0xE2, 0xFD, 0xA2, 0x0D, 0xA5, 0xCD, + 0xA9, 0xB2, 0xA6, 0x30, 0xD0, 0x3D, 0xB3, 0x03, + 0x03, 0x56, 0x24, 0xE7, 0x4D, 0x98, 0xCF, 0x63, + 0x5F, 0xA2, 0x7F, 0xCA, 0x0E, 0x05, 0x4B, 0x03 + }, + { + 0xEC, 0xDF, 0xA7, 0xF1, 0xA7, 0xC0, 0x1B, 0xDD, + 0x42, 0x53, 0xCE, 0x55, 0x89, 0xC1, 0x5D, 0x01, + 0x35, 0xA2, 0x98, 0xA4, 0xBC, 0x83, 0x33, 0x39, + 0x73, 0xFD, 0xC7, 0x78, 0xA6, 0x89, 0xAE, 0x2B, + 0x9D, 0x1E, 0x0B, 0x38, 0xB1, 0x54, 0x1E, 0x6E, + 0xB0, 0x80, 0x55, 0x55, 0x7A, 0xFB, 0xFC, 0x14, + 0x04, 0x9C, 0x57, 0x85, 0x7A, 0xA1, 0x79, 0xE6, + 0x62, 0xC6, 0xFE, 0xB2, 0xF3, 0x1E, 0xAE, 0xF4 + }, + { + 0xD1, 0x8C, 0xCF, 0x41, 0xB9, 0x70, 0xA1, 0xD1, + 0x2B, 0x1C, 0xA2, 0x10, 0x24, 0x07, 0x20, 0xEE, + 0x2A, 0xDD, 0x5C, 0x4B, 0x0D, 0xC8, 0xF3, 0x76, + 0x6D, 0x05, 0xCA, 0x36, 0x0F, 0x9B, 0x32, 0x90, + 0xC9, 0x90, 0xB3, 0x9E, 0x97, 0x03, 0x08, 0x1F, + 0xC4, 0x51, 0x34, 0xC3, 0x8A, 0x57, 0x7A, 0x4D, + 0x12, 0x9C, 0x8C, 0xF2, 0x71, 0x52, 0x58, 0x3C, + 0x50, 0x9F, 0x3C, 0x10, 0x39, 0x55, 0x36, 0x4D + }, + { + 0x2B, 0x8B, 0x19, 0x01, 0xB8, 0x27, 0xE5, 0x9C, + 0x10, 0x67, 0x31, 0xE8, 0x8D, 0xE0, 0x9F, 0x68, + 0xFA, 0x85, 0xE8, 0xB4, 0x52, 0x59, 0xD4, 0x86, + 0x38, 0x6E, 0x67, 0x49, 0x31, 0x85, 0x43, 0x1E, + 0x84, 0x31, 0xCA, 0x7E, 0x0B, 0x2A, 0xEE, 0xA4, + 0x01, 0x21, 0x50, 0x24, 0x3B, 0xD0, 0xCB, 0xC2, + 0x13, 0xC9, 0x89, 0x61, 0x36, 0xA6, 0x50, 0x37, + 0x7D, 0x0D, 0x21, 0x77, 0x6B, 0xE1, 0xAF, 0xF6 + }, + { + 0x91, 0x08, 0xC5, 0x67, 0x13, 0xB1, 0xE1, 0xB5, + 0x6B, 0x63, 0x29, 0x15, 0xB4, 0x20, 0x86, 0xB5, + 0xE4, 0x3E, 0x21, 0xA7, 0x08, 0x9A, 0x2A, 0x6C, + 0x53, 0xBB, 0x22, 0x1A, 0x06, 0xCD, 0xC8, 0xF8, + 0x74, 0x19, 0x37, 0x42, 0x23, 0x4B, 0xE8, 0x82, + 0x82, 0xFB, 0x65, 0x95, 0x75, 0x5A, 0xE9, 0x4D, + 0xDA, 0x2C, 0x6F, 0x91, 0x86, 0x9B, 0x71, 0x3A, + 0xFE, 0x02, 0x06, 0xC7, 0xCA, 0xCC, 0x91, 0xD4 + }, + { + 0x59, 0x91, 0x38, 0x73, 0x6F, 0xB3, 0xD4, 0xDF, + 0xF9, 0x6C, 0x95, 0xD5, 0x45, 0xE2, 0xBD, 0xD0, + 0x61, 0xC4, 0x79, 0x47, 0xC0, 0x8F, 0xAE, 0xA4, + 0x9E, 0x20, 0xA6, 0x7C, 0x5A, 0xC9, 0x69, 0xDC, + 0x4A, 0x37, 0x6B, 0xE2, 0x94, 0x91, 0xB6, 0x8A, + 0x96, 0x0C, 0xA2, 0xE1, 0xB5, 0x14, 0xBD, 0x07, + 0xE7, 0x08, 0xCD, 0x69, 0x5B, 0x95, 0x21, 0x88, + 0x6C, 0x1F, 0x81, 0xFF, 0xAF, 0x4D, 0xD5, 0x0D + }, + { + 0x9D, 0xC7, 0xC0, 0x6C, 0x8B, 0x3E, 0xB4, 0x20, + 0xA6, 0xBC, 0x30, 0x0B, 0xB8, 0x13, 0xCD, 0x70, + 0x4D, 0x0B, 0x45, 0x50, 0x43, 0xAC, 0x7A, 0x3C, + 0xA4, 0x7B, 0xFA, 0x5D, 0x32, 0x13, 0x6D, 0x30, + 0xD2, 0x72, 0x5C, 0x41, 0x7D, 0xF6, 0x81, 0x1D, + 0x1F, 0x3E, 0x6E, 0x05, 0x99, 0x03, 0x02, 0x3F, + 0xFE, 0x04, 0xBE, 0xE7, 0xA0, 0x23, 0xED, 0xD1, + 0x07, 0xE6, 0xB4, 0xA5, 0x63, 0x76, 0x3A, 0xB4 + }, + { + 0xB9, 0x75, 0xB6, 0x5F, 0x3B, 0x5C, 0x8F, 0x95, + 0xAC, 0xA2, 0x01, 0xA6, 0x3A, 0xE2, 0x80, 0xD8, + 0xEF, 0xDD, 0xC7, 0x62, 0x44, 0xA3, 0xBF, 0x71, + 0xD3, 0xF4, 0xDB, 0x06, 0x37, 0x35, 0xD6, 0x0F, + 0x0D, 0x03, 0xE9, 0xB0, 0x7E, 0x37, 0x16, 0x1F, + 0xCA, 0x5F, 0x31, 0x98, 0x70, 0x4C, 0x7C, 0x6F, + 0xAF, 0x93, 0xB9, 0xAE, 0x52, 0x28, 0x90, 0x95, + 0x1D, 0xC0, 0xBA, 0x17, 0xC6, 0xAA, 0xF8, 0xE1 + }, + { + 0x83, 0x95, 0x2C, 0x5B, 0x17, 0x42, 0xC5, 0x70, + 0x21, 0x90, 0x25, 0x8E, 0xA1, 0x09, 0xB9, 0xC2, + 0x0C, 0x4E, 0xBF, 0x31, 0x4F, 0xBD, 0xBE, 0x4C, + 0xD1, 0x69, 0xA4, 0xDA, 0xD7, 0x1C, 0x66, 0xDD, + 0x9F, 0x8F, 0xED, 0xD4, 0x1D, 0x9C, 0xF8, 0x48, + 0x1C, 0xF0, 0x46, 0x64, 0x2B, 0xCC, 0xCA, 0x2F, + 0x2C, 0x2B, 0x5F, 0xA6, 0xE0, 0x2D, 0x2A, 0x2B, + 0xB0, 0x13, 0x15, 0x1A, 0xF8, 0xEA, 0xA5, 0x44 + }, + { + 0xD0, 0x93, 0x9D, 0x14, 0xC6, 0x21, 0xBD, 0x09, + 0xB8, 0x1A, 0x6B, 0x22, 0x4D, 0x8B, 0xF1, 0x49, + 0x2D, 0x37, 0xA2, 0xEB, 0x9E, 0x78, 0xF7, 0xC1, + 0x7A, 0xDE, 0xFC, 0x75, 0x53, 0xA3, 0x41, 0xB9, + 0xEF, 0xC7, 0x62, 0xF8, 0x78, 0xF3, 0xAE, 0x28, + 0xFF, 0x81, 0x6B, 0x26, 0x8A, 0x8D, 0x8D, 0x33, + 0xD5, 0x09, 0xCA, 0xF2, 0x00, 0x22, 0xE4, 0xDA, + 0xEE, 0x68, 0xB8, 0x4C, 0x9A, 0x81, 0xC2, 0x0F + }, + { + 0x56, 0x8F, 0x83, 0xE2, 0xE5, 0xC8, 0xF6, 0xDC, + 0x5B, 0xDA, 0xA5, 0x6F, 0xD2, 0x2F, 0xAC, 0x41, + 0x44, 0xED, 0xE6, 0xFB, 0x98, 0x3D, 0xEE, 0x2D, + 0x0E, 0x91, 0x14, 0x6C, 0x79, 0xBC, 0x20, 0x51, + 0x03, 0xCC, 0x88, 0xF1, 0x8B, 0x3F, 0xDA, 0x84, + 0xCD, 0xC8, 0x8F, 0xE5, 0x04, 0xAA, 0xF0, 0xD3, + 0x7F, 0xB7, 0xF6, 0x23, 0x9B, 0xBD, 0xBE, 0x34, + 0x26, 0x71, 0xBA, 0x35, 0x04, 0x8B, 0x66, 0xE2 + }, + { + 0xCA, 0x98, 0xAF, 0x0C, 0x0B, 0x1C, 0x7A, 0xEB, + 0x20, 0x39, 0x0A, 0x4B, 0x12, 0x04, 0xAF, 0x92, + 0xAD, 0x82, 0x54, 0x51, 0x17, 0xD9, 0xE0, 0x1D, + 0x0C, 0x7E, 0xC7, 0x02, 0x5E, 0x11, 0x3C, 0xC0, + 0x66, 0x8B, 0xB3, 0xA7, 0x07, 0xAD, 0x61, 0x40, + 0x71, 0xDE, 0x46, 0xF4, 0x5E, 0x21, 0xA0, 0xD7, + 0xBA, 0x7E, 0xEE, 0xF4, 0x29, 0xBE, 0x2C, 0x4F, + 0x83, 0x69, 0x9F, 0xC6, 0x63, 0x01, 0x94, 0x75 + }, + { + 0x20, 0x37, 0xF6, 0xD5, 0x84, 0x55, 0x67, 0x36, + 0x64, 0x77, 0xA1, 0x55, 0x83, 0x24, 0x95, 0x5C, + 0xC6, 0xCD, 0x0D, 0x91, 0xCD, 0x0D, 0xD0, 0x15, + 0xAD, 0xAF, 0xF7, 0x38, 0xF8, 0xB1, 0x52, 0xE4, + 0x87, 0xA9, 0x7F, 0xA0, 0x7D, 0xFB, 0xEE, 0x07, + 0x1D, 0xCC, 0x78, 0xF1, 0xA7, 0x4D, 0x47, 0xED, + 0x5F, 0x12, 0xDE, 0x2C, 0xEF, 0xF2, 0xBE, 0xF2, + 0x4D, 0x55, 0x2C, 0x13, 0x5D, 0x0F, 0xC5, 0x16 + }, + { + 0x45, 0x3F, 0xE3, 0xC2, 0x0D, 0x2A, 0x6E, 0x19, + 0xD3, 0x8F, 0xA6, 0xBE, 0x69, 0xD2, 0x37, 0xAB, + 0x1B, 0xC2, 0x5A, 0xD8, 0x94, 0x7C, 0xA4, 0x8C, + 0x68, 0xBA, 0x88, 0x8A, 0x8F, 0x33, 0xA3, 0x77, + 0x7D, 0x4C, 0x70, 0xA6, 0x01, 0xDA, 0x09, 0xBF, + 0x7C, 0xB1, 0x4A, 0x05, 0x9D, 0x3B, 0xDE, 0x47, + 0xC1, 0xB2, 0xB0, 0x8D, 0x7A, 0x01, 0x44, 0xDF, + 0x05, 0x51, 0xA7, 0x18, 0x76, 0x19, 0xD3, 0x9F + }, + { + 0xC9, 0x95, 0xD5, 0x0B, 0x97, 0xC2, 0x6C, 0xD0, + 0x6C, 0x75, 0x2E, 0xE7, 0x28, 0xEC, 0x65, 0xF1, + 0x5A, 0xDD, 0x11, 0x11, 0xB4, 0x88, 0x91, 0xF4, + 0xAC, 0xA5, 0xEB, 0xEB, 0x80, 0x5F, 0xCE, 0xEB, + 0xD3, 0xCC, 0x94, 0x9C, 0x44, 0xD2, 0x8C, 0x8E, + 0xE6, 0x53, 0x52, 0x76, 0x01, 0x78, 0xD6, 0xD8, + 0x0E, 0xC2, 0x0C, 0x3A, 0xF1, 0x76, 0xF1, 0x2C, + 0x4E, 0x4D, 0x74, 0x35, 0x5E, 0x53, 0x07, 0xBB + }, + { + 0xC9, 0xF0, 0xB4, 0x4D, 0xBD, 0x2D, 0x29, 0x7B, + 0xAC, 0xA3, 0x69, 0x2D, 0xEA, 0x87, 0x11, 0x18, + 0x67, 0xC7, 0xFA, 0x81, 0x1F, 0x88, 0x5F, 0x08, + 0x10, 0x49, 0xE0, 0xE1, 0xAB, 0xAB, 0x07, 0xBE, + 0x64, 0x5A, 0x9E, 0xF3, 0xF2, 0xD3, 0x0C, 0xFC, + 0xDA, 0x7B, 0x04, 0xC4, 0x10, 0xCE, 0x72, 0xBB, + 0x4D, 0xF8, 0xC9, 0x55, 0xE3, 0xA1, 0xA4, 0x8E, + 0x9C, 0xF3, 0xD5, 0xF7, 0xD6, 0x87, 0x3A, 0xAC + }, + { + 0x4F, 0x58, 0xFA, 0x07, 0x49, 0xF1, 0xA4, 0x2F, + 0x73, 0x56, 0x13, 0x00, 0x15, 0xC5, 0xD0, 0xF6, + 0x2D, 0xDF, 0xC5, 0x9D, 0x1B, 0x31, 0x0F, 0x88, + 0xCD, 0x4A, 0xF4, 0x00, 0x92, 0x64, 0x77, 0x2A, + 0x4A, 0xA2, 0x56, 0xE4, 0x44, 0x26, 0x2B, 0xE9, + 0xF9, 0x60, 0xE4, 0xD7, 0xE6, 0x6E, 0x65, 0x51, + 0xF4, 0x40, 0x41, 0x3F, 0xD3, 0xEA, 0x39, 0x9C, + 0xB2, 0x85, 0xC6, 0x28, 0xD0, 0x45, 0x6E, 0x2C + }, + { + 0x0E, 0x94, 0x87, 0xC2, 0x04, 0xD8, 0x9F, 0x30, + 0x33, 0xAF, 0x4E, 0x8B, 0xA0, 0xD7, 0x40, 0x57, + 0x29, 0x1E, 0x1C, 0x38, 0x46, 0x19, 0x28, 0x3C, + 0x1B, 0xBE, 0x6A, 0x59, 0xE0, 0x15, 0xC7, 0x9A, + 0xB6, 0xBE, 0x16, 0xF0, 0x81, 0x7D, 0x40, 0x92, + 0x83, 0x20, 0x63, 0xC0, 0xE4, 0xA5, 0x91, 0xA9, + 0x00, 0x38, 0x69, 0x5C, 0xDD, 0x20, 0x07, 0x44, + 0x7E, 0x6A, 0xEC, 0xF2, 0x83, 0x03, 0x8C, 0x8E + }, + { + 0xF9, 0x11, 0x8B, 0xB9, 0x41, 0x68, 0x03, 0xA7, + 0x8C, 0x67, 0x0C, 0xE3, 0x0B, 0xB7, 0x38, 0x83, + 0x14, 0xB3, 0xD2, 0x13, 0x3C, 0xA5, 0x0C, 0xF8, + 0xE0, 0x3D, 0x3B, 0x10, 0xDD, 0x26, 0xA9, 0x42, + 0x90, 0xA3, 0xCA, 0x86, 0x68, 0xCF, 0x99, 0x47, + 0x28, 0x57, 0x66, 0x96, 0x0C, 0xE0, 0xF4, 0x51, + 0x37, 0xCC, 0xA4, 0x2B, 0x00, 0xD5, 0xD2, 0xEA, + 0xBB, 0x13, 0xF9, 0x5F, 0x5F, 0x5E, 0x89, 0x04 + }, + { + 0xFC, 0xF5, 0x1B, 0xC1, 0xFF, 0x4B, 0xAB, 0xD6, + 0xA4, 0x22, 0x37, 0x5F, 0x09, 0xB8, 0xE3, 0x33, + 0xA3, 0x73, 0x14, 0xEA, 0x14, 0x9C, 0xCB, 0x94, + 0x57, 0x86, 0xF0, 0xA4, 0xA3, 0x96, 0xA1, 0x10, + 0xBE, 0x6A, 0x0D, 0x37, 0x92, 0xC6, 0xEB, 0x5A, + 0x23, 0x80, 0x14, 0x28, 0xC6, 0xB4, 0xEE, 0x6D, + 0xC7, 0x79, 0xAD, 0x5C, 0x57, 0x46, 0x65, 0x1F, + 0x0C, 0x97, 0xE4, 0x88, 0x0E, 0xCC, 0x89, 0x07 + }, + { + 0xD4, 0x3E, 0x0E, 0x75, 0x41, 0x13, 0xE1, 0xD8, + 0xCD, 0x88, 0x03, 0xF1, 0x6F, 0x9E, 0x7F, 0xC9, + 0x5B, 0xC2, 0x49, 0x57, 0x51, 0x17, 0x1A, 0x56, + 0x71, 0x4D, 0xBF, 0x72, 0xB1, 0x6A, 0x2A, 0xA9, + 0x13, 0xE8, 0x77, 0xEF, 0x42, 0x9F, 0xDA, 0x8F, + 0x06, 0x9D, 0xC6, 0xE0, 0xEE, 0x35, 0x4A, 0x05, + 0xE8, 0xE0, 0x84, 0xFF, 0x81, 0x14, 0x3E, 0x17, + 0x7D, 0xCD, 0x05, 0x03, 0x6E, 0xF5, 0xBE, 0xAC + }, + { + 0x01, 0xB8, 0x2A, 0x56, 0x90, 0x6D, 0x2D, 0x9B, + 0x39, 0x58, 0xFC, 0xAE, 0xF5, 0x4B, 0x1C, 0x98, + 0x0F, 0x2B, 0x72, 0xD1, 0x97, 0x86, 0xDB, 0xFF, + 0xC3, 0x9A, 0x9E, 0x3D, 0x89, 0xF2, 0x44, 0xB8, + 0x87, 0x40, 0x46, 0x45, 0xC9, 0xAB, 0xC3, 0x07, + 0xBA, 0xD3, 0xA5, 0x10, 0xCF, 0xCB, 0x5D, 0xB3, + 0x2E, 0xD9, 0x9A, 0x07, 0x1B, 0x46, 0x9C, 0x2E, + 0x71, 0x4E, 0xDF, 0xE5, 0x6F, 0x5D, 0x9A, 0x55 + }, + { + 0x79, 0xA0, 0x37, 0xD0, 0x91, 0xC1, 0x07, 0x76, + 0x86, 0xB9, 0xCD, 0x8D, 0x11, 0x45, 0x28, 0xC8, + 0xAE, 0xAD, 0x4F, 0x3E, 0x39, 0x62, 0x24, 0x7D, + 0x1B, 0xBA, 0x72, 0xD5, 0x50, 0x6E, 0x8B, 0xB0, + 0xE6, 0x4D, 0x36, 0x14, 0x58, 0xE5, 0xCF, 0xAD, + 0xF1, 0x9A, 0x08, 0x53, 0xCB, 0x0B, 0x4B, 0xA5, + 0x9E, 0xDB, 0x66, 0xED, 0x11, 0x63, 0x89, 0xCC, + 0x71, 0x9B, 0xEA, 0x49, 0x72, 0xF2, 0x21, 0xEC + }, + { + 0x70, 0xB3, 0x96, 0x16, 0x72, 0xA8, 0xC5, 0x4F, + 0x17, 0xFB, 0x5C, 0xEA, 0x7B, 0x96, 0xEC, 0x73, + 0xCE, 0x9E, 0x12, 0x39, 0x08, 0xA7, 0x06, 0x92, + 0x41, 0xEA, 0x5E, 0x4C, 0xC3, 0x7A, 0xA3, 0x05, + 0x6A, 0x9D, 0xD4, 0xF8, 0xE6, 0xF9, 0x67, 0xE3, + 0xFD, 0x56, 0xB6, 0x4F, 0xFA, 0x1D, 0x38, 0xEF, + 0xEA, 0xDC, 0x78, 0x50, 0x62, 0x86, 0x98, 0x98, + 0x65, 0xB6, 0x67, 0xF1, 0x0D, 0x27, 0xF3, 0x92 + }, + { + 0x52, 0xFA, 0xED, 0xEF, 0x37, 0x65, 0x75, 0x77, + 0x7A, 0xFC, 0x18, 0xD5, 0xD6, 0x14, 0x37, 0x00, + 0xC3, 0x87, 0x47, 0xE2, 0x99, 0x2B, 0x2B, 0xAC, + 0xB5, 0xFA, 0x83, 0x17, 0xCD, 0xB0, 0xB5, 0xC8, + 0x42, 0x55, 0xBD, 0x4B, 0xD4, 0xC2, 0x2D, 0x0A, + 0x2B, 0xDD, 0x26, 0x7E, 0xB7, 0x14, 0x18, 0x24, + 0x37, 0x5A, 0xE2, 0x88, 0x68, 0x97, 0x75, 0xB6, + 0x17, 0xA4, 0x7B, 0x23, 0x66, 0x80, 0xFA, 0x9D + }, + { + 0x87, 0x4B, 0xBE, 0xC7, 0x0C, 0xBC, 0xF1, 0xAB, + 0x9C, 0x17, 0x0E, 0x0B, 0x3F, 0xC3, 0xAA, 0x7B, + 0x19, 0x1D, 0xEE, 0x3F, 0x5B, 0x91, 0xBE, 0x6B, + 0xA5, 0x9C, 0xED, 0xF3, 0xDF, 0x01, 0x1C, 0xBB, + 0xB9, 0xC8, 0xBE, 0x5E, 0x68, 0xC3, 0x68, 0x19, + 0xFD, 0x4F, 0xAA, 0x4D, 0xE9, 0xCE, 0x7E, 0xB9, + 0x02, 0x2C, 0x18, 0x50, 0xD5, 0xF5, 0x4F, 0xD1, + 0xED, 0x9E, 0x6E, 0x52, 0xEA, 0xDF, 0x04, 0x16 + }, + { + 0x28, 0xD1, 0xDD, 0xC1, 0x19, 0xFB, 0xB1, 0x32, + 0xB8, 0x0A, 0x9C, 0x2D, 0x6A, 0x98, 0xF2, 0xC8, + 0x0D, 0x84, 0x74, 0xF1, 0x31, 0x76, 0x8D, 0x63, + 0xE1, 0x2C, 0x27, 0x8C, 0x3B, 0x73, 0xA5, 0x86, + 0xC4, 0x07, 0x81, 0x86, 0x83, 0x61, 0x7A, 0x10, + 0x72, 0xF2, 0xEE, 0xDA, 0xC5, 0x4E, 0x0B, 0xFE, + 0x4C, 0xD9, 0xCA, 0x7C, 0xBB, 0xB2, 0xCB, 0xC7, + 0x0B, 0xA8, 0x12, 0xA0, 0x53, 0x98, 0xC6, 0x3B + }, + { + 0xC1, 0x83, 0x94, 0x1D, 0x10, 0x84, 0x7A, 0xAF, + 0x1A, 0x8E, 0x2D, 0xD5, 0x74, 0x99, 0xD1, 0x52, + 0x93, 0xF8, 0x7C, 0x9F, 0xA8, 0xD5, 0xC3, 0x04, + 0x78, 0xFD, 0xAE, 0x79, 0x37, 0x3E, 0xF5, 0x08, + 0x77, 0xCE, 0xC4, 0x5C, 0x9E, 0xEF, 0x09, 0x85, + 0x58, 0xD9, 0xDC, 0x80, 0x84, 0x38, 0x83, 0xAC, + 0x12, 0xCF, 0x0C, 0xC3, 0xE5, 0x84, 0x79, 0x38, + 0x38, 0x56, 0xBE, 0x76, 0xD0, 0x7A, 0x66, 0xD1 + }, + { + 0xF7, 0x03, 0x14, 0xCA, 0x65, 0x92, 0x18, 0xFD, + 0xAC, 0x19, 0x36, 0xC3, 0xD5, 0x50, 0xDE, 0x92, + 0x92, 0xF1, 0xD1, 0xE8, 0x79, 0x9C, 0x8D, 0x10, + 0xBD, 0xB8, 0xF7, 0x15, 0x14, 0x15, 0xCC, 0xED, + 0x30, 0xE2, 0xBD, 0x68, 0x21, 0x21, 0xB1, 0x54, + 0x4A, 0xD9, 0xC1, 0xD8, 0xDF, 0x1D, 0x1B, 0x1E, + 0x94, 0xD7, 0xD0, 0x23, 0xA6, 0x88, 0xE5, 0xD8, + 0x9A, 0xB4, 0xE6, 0x33, 0xD1, 0xEE, 0xB3, 0x23 + }, + { + 0x2F, 0x5D, 0x8F, 0x21, 0xC6, 0x84, 0x89, 0x9D, + 0x5C, 0xF1, 0x60, 0x3A, 0xA2, 0xEB, 0x3B, 0x04, + 0xFB, 0x15, 0xE9, 0xEF, 0x17, 0x68, 0x1A, 0xFF, + 0x1C, 0xF1, 0x7C, 0xBD, 0x4D, 0x83, 0x41, 0x71, + 0xD5, 0xBA, 0x09, 0x11, 0x70, 0xFD, 0xFB, 0xB2, + 0x89, 0xFB, 0x9B, 0xC2, 0x94, 0x3F, 0x52, 0xF1, + 0x7D, 0xDE, 0xF1, 0x29, 0x85, 0x6E, 0x7A, 0xDA, + 0x7C, 0xF2, 0xFF, 0xEA, 0xC5, 0x29, 0x64, 0x87 + }, + { + 0xD1, 0x10, 0xD6, 0x5A, 0x9C, 0xB5, 0x07, 0xCC, + 0x91, 0xB6, 0x7C, 0x6D, 0x00, 0x3F, 0x74, 0x8E, + 0xCF, 0x30, 0x6F, 0x4F, 0x19, 0x1A, 0x97, 0x2D, + 0x6A, 0x3D, 0xB8, 0x06, 0x48, 0x04, 0x82, 0x09, + 0x5B, 0x6F, 0x66, 0xC7, 0xAC, 0x49, 0x28, 0xFB, + 0x17, 0x28, 0xAE, 0x7B, 0x76, 0xCE, 0x18, 0x15, + 0xCC, 0xE7, 0x62, 0x5E, 0x17, 0xE4, 0x67, 0x7D, + 0x43, 0x26, 0x4A, 0x6C, 0x80, 0x5D, 0xAC, 0x50 + }, + { + 0x34, 0xD6, 0xEE, 0x85, 0x27, 0xD0, 0x72, 0xC8, + 0x78, 0x22, 0x4F, 0xC4, 0xDC, 0x50, 0x78, 0x4C, + 0x82, 0xF9, 0x33, 0x07, 0xFF, 0x43, 0x87, 0xC2, + 0x3F, 0xE4, 0xF8, 0x07, 0x78, 0xDC, 0x98, 0x8D, + 0x3A, 0xC7, 0xBE, 0x10, 0x19, 0x58, 0x8C, 0x02, + 0x57, 0x75, 0x24, 0xBB, 0xD2, 0x2A, 0x8A, 0xAA, + 0xA4, 0xDF, 0x18, 0xD5, 0xD5, 0x81, 0x6D, 0x5F, + 0x11, 0x19, 0xA4, 0xA1, 0x57, 0xAF, 0x28, 0x0A + }, + { + 0x24, 0xC4, 0xC8, 0xC2, 0x20, 0xAD, 0xAB, 0xC2, + 0xE5, 0x43, 0x44, 0xF0, 0xDD, 0x8C, 0x81, 0xC3, + 0x7C, 0x1A, 0xA0, 0x6D, 0xB8, 0x4C, 0xE0, 0xF2, + 0xDF, 0x77, 0x94, 0x04, 0x0D, 0x39, 0x81, 0xA8, + 0xAD, 0x6D, 0x3B, 0xCC, 0x18, 0xBA, 0xA1, 0x90, + 0x4C, 0x09, 0xC6, 0x01, 0x0E, 0xC9, 0x5A, 0xB9, + 0xC3, 0x66, 0xD7, 0x0F, 0xFE, 0x66, 0xB7, 0x49, + 0x96, 0x4D, 0x66, 0x98, 0x3B, 0x2E, 0x1E, 0x96 + }, + { + 0xB5, 0x3B, 0x58, 0x45, 0x34, 0x2C, 0x55, 0xE6, + 0xC0, 0xEB, 0x6B, 0x7E, 0x04, 0xB6, 0xF1, 0xD2, + 0xA1, 0xDB, 0x92, 0x0B, 0x91, 0x18, 0xBE, 0xBB, + 0xEA, 0x54, 0xED, 0x8C, 0xDA, 0x12, 0xA3, 0x09, + 0x28, 0x1C, 0xDF, 0xD1, 0x54, 0xC3, 0x5F, 0xFB, + 0x88, 0x0B, 0x41, 0xC7, 0x79, 0x71, 0xE0, 0x8B, + 0xA9, 0x40, 0x72, 0x06, 0x0D, 0x76, 0x8E, 0xD4, + 0x89, 0x02, 0xF9, 0x2D, 0xCB, 0xFD, 0x49, 0x1C + }, + { + 0x49, 0xB3, 0xD9, 0xE1, 0xFD, 0xDB, 0x46, 0x25, + 0x4C, 0xE2, 0x2B, 0x50, 0x07, 0xEC, 0x2E, 0xBA, + 0xCE, 0x27, 0xF8, 0xFB, 0xEC, 0xBF, 0x40, 0xDE, + 0xF5, 0x10, 0x23, 0x30, 0x28, 0x92, 0xB5, 0x43, + 0xEB, 0x0D, 0x3F, 0xD1, 0x6B, 0xB0, 0x90, 0xF1, + 0xF3, 0xCC, 0x8A, 0xBC, 0x1C, 0x5C, 0x5C, 0x68, + 0x8B, 0xE7, 0xFB, 0xEB, 0x04, 0xC2, 0x1E, 0x9F, + 0xF9, 0xDE, 0x53, 0x36, 0xD7, 0x0A, 0xF4, 0x28 + }, + { + 0xB6, 0x32, 0x65, 0xE9, 0xE9, 0x0D, 0x9D, 0x44, + 0xFF, 0xD7, 0x64, 0xF3, 0x2C, 0xA1, 0x14, 0x84, + 0xF3, 0x1A, 0xC0, 0x85, 0xFD, 0x6A, 0x96, 0x34, + 0x35, 0x84, 0x4A, 0xD9, 0x2E, 0x5F, 0x06, 0xE2, + 0xCB, 0xF9, 0x2B, 0x4E, 0xEC, 0x29, 0xC0, 0x3C, + 0x6F, 0x2D, 0xFA, 0xD4, 0x9C, 0xE9, 0x16, 0x4D, + 0x79, 0x27, 0x00, 0xB3, 0xE4, 0x7A, 0x8A, 0x88, + 0x6A, 0xFC, 0x69, 0xCD, 0x40, 0xB4, 0x0A, 0x80 + }, + { + 0xE1, 0xD7, 0xCD, 0x91, 0x8E, 0xF7, 0x27, 0xCF, + 0x0B, 0xBD, 0x48, 0xE5, 0x76, 0x75, 0x1C, 0xDB, + 0x87, 0xB6, 0xD2, 0xCE, 0xAE, 0x4B, 0xC3, 0xE3, + 0x72, 0x1E, 0x6C, 0x35, 0xF2, 0x63, 0x47, 0x63, + 0x87, 0xEF, 0x19, 0x1B, 0x3E, 0xAF, 0xCC, 0x13, + 0x47, 0x69, 0xEB, 0x7F, 0x4D, 0x4C, 0xD4, 0xA2, + 0x94, 0x66, 0x69, 0xF8, 0xBB, 0x6E, 0xC0, 0x60, + 0x02, 0xB2, 0x6C, 0x2F, 0x52, 0xBD, 0x58, 0xA6 + }, + { + 0x85, 0x50, 0xC9, 0x40, 0xE4, 0xD3, 0xA1, 0x3B, + 0xB7, 0x49, 0x98, 0x40, 0x10, 0x61, 0xFB, 0x8E, + 0x8A, 0xCA, 0xEC, 0xEB, 0x95, 0x02, 0xF3, 0x88, + 0x18, 0xE1, 0x86, 0x26, 0x13, 0xBA, 0xF7, 0x6F, + 0xA8, 0x02, 0x69, 0xBD, 0xA4, 0x3C, 0x8C, 0x27, + 0x42, 0x09, 0x94, 0x1F, 0x8F, 0x92, 0x84, 0xDF, + 0xAB, 0x28, 0x9D, 0x6B, 0xD6, 0x58, 0x53, 0x80, + 0xF1, 0xA0, 0x5A, 0xFB, 0xE4, 0xD2, 0x37, 0xE6 + }, + { + 0x49, 0x78, 0x90, 0xBF, 0x97, 0x7E, 0xD6, 0x28, + 0x78, 0x27, 0x8A, 0x05, 0xC9, 0xE7, 0x28, 0x7E, + 0xC2, 0x42, 0x26, 0x35, 0x66, 0x81, 0x36, 0x41, + 0xC7, 0xE1, 0x6F, 0x9B, 0xA4, 0x1F, 0x1C, 0x93, + 0xE1, 0xCA, 0xCF, 0x4B, 0xA0, 0xD7, 0xA8, 0xA9, + 0x47, 0x20, 0xBE, 0x94, 0x1D, 0x32, 0x0A, 0x45, + 0xE5, 0x88, 0x12, 0xF6, 0x40, 0x7E, 0x1B, 0x18, + 0x78, 0xB5, 0x7D, 0x14, 0xD3, 0xE3, 0x4F, 0x20 + }, + { + 0xD5, 0x03, 0xC6, 0x81, 0xA4, 0x7D, 0xF9, 0x5E, + 0x1F, 0x11, 0x3A, 0x17, 0xCA, 0xF3, 0xFF, 0xB7, + 0xCA, 0x38, 0xE2, 0x29, 0xBA, 0x08, 0xD4, 0x79, + 0x8E, 0x7C, 0x67, 0x8E, 0xE2, 0xD4, 0xEB, 0x61, + 0xB8, 0x9B, 0x36, 0x16, 0x77, 0xBF, 0xA6, 0x39, + 0xDA, 0xB3, 0x99, 0xB6, 0xA3, 0x76, 0xDD, 0xA4, + 0x2E, 0xF3, 0xAF, 0x34, 0xDE, 0x63, 0x7E, 0xD7, + 0x6E, 0xDB, 0x74, 0xF1, 0xBF, 0x5E, 0x83, 0x18 + }, + { + 0x5E, 0x70, 0x78, 0x19, 0x91, 0xDE, 0x75, 0xBB, + 0x47, 0x06, 0x1E, 0x9E, 0xC5, 0xE0, 0xA2, 0xF6, + 0x59, 0x6D, 0xAB, 0xED, 0x57, 0x77, 0x03, 0xF7, + 0xD2, 0x08, 0x6C, 0x5D, 0x3C, 0xFE, 0xD6, 0x59, + 0x35, 0x2D, 0xF0, 0xB7, 0x4A, 0x0A, 0xD7, 0xF5, + 0xD5, 0x1F, 0x7B, 0xAE, 0x10, 0x70, 0xCD, 0x9D, + 0x79, 0x31, 0x06, 0x1C, 0xE7, 0x0D, 0x62, 0x8A, + 0x45, 0x49, 0xEC, 0x5A, 0x7C, 0xB8, 0x20, 0xA4 + }, + { + 0x3E, 0x6D, 0x1E, 0x21, 0xBB, 0xED, 0xEE, 0x7D, + 0xF0, 0x18, 0x01, 0xAE, 0x95, 0x18, 0x57, 0x6A, + 0x2B, 0x09, 0x96, 0x7B, 0x8C, 0xEC, 0x7B, 0x64, + 0x75, 0x66, 0xD3, 0x5B, 0x00, 0xE6, 0x48, 0x98, + 0xFC, 0x14, 0x27, 0xE9, 0x1C, 0x41, 0xA6, 0xA2, + 0x8E, 0xE9, 0xDC, 0xD5, 0x4A, 0xF4, 0xC8, 0x38, + 0x60, 0x06, 0xF0, 0xB0, 0x82, 0xA6, 0x7E, 0x0A, + 0x30, 0x8C, 0x6F, 0xB3, 0x2C, 0x9E, 0x56, 0x91 + }, + { + 0x9C, 0x10, 0xAF, 0x55, 0xAF, 0xA5, 0x1F, 0xC5, + 0x59, 0x0B, 0x97, 0x51, 0xBB, 0x24, 0xD1, 0xE5, + 0xC7, 0x34, 0xF6, 0x43, 0xA8, 0xC9, 0x3F, 0xD3, + 0x57, 0x51, 0x9B, 0x1B, 0x37, 0x8F, 0xB5, 0x00, + 0xF7, 0x3C, 0x47, 0x44, 0x3F, 0x2F, 0x5F, 0x44, + 0x02, 0x75, 0x46, 0x65, 0x86, 0xF6, 0x62, 0x15, + 0xA2, 0x62, 0x5D, 0x31, 0x08, 0x7B, 0x46, 0x53, + 0x5D, 0x1B, 0xA1, 0x09, 0xD5, 0xCA, 0xC5, 0x33 + }, + { + 0x68, 0xB5, 0x9F, 0x8B, 0xD4, 0xCD, 0x6B, 0x6D, + 0xFF, 0x04, 0x02, 0xD9, 0xDF, 0xBF, 0xA1, 0x7D, + 0x8B, 0x0E, 0xDD, 0x6C, 0x5E, 0x13, 0xF3, 0x22, + 0x25, 0x1F, 0x92, 0x5F, 0x36, 0x84, 0xB0, 0x90, + 0x7C, 0x45, 0x0C, 0x9A, 0x1A, 0xBB, 0x7A, 0x97, + 0x38, 0x20, 0x9A, 0x63, 0xD2, 0x6B, 0xD8, 0x85, + 0x60, 0x0D, 0xB4, 0x05, 0x92, 0x62, 0x2B, 0x99, + 0x23, 0xAA, 0xDD, 0x1E, 0x1E, 0xD8, 0x50, 0x66 + }, + { + 0xD5, 0x70, 0xB8, 0xFC, 0x7A, 0xAE, 0x53, 0x23, + 0xA9, 0xD7, 0xCC, 0x6C, 0x27, 0x02, 0xD4, 0xCD, + 0x6A, 0x74, 0x69, 0xC3, 0xAA, 0xF1, 0x9C, 0xB4, + 0xD8, 0xAC, 0x1A, 0xD1, 0x73, 0xDF, 0xB4, 0x7D, + 0x0E, 0x13, 0x93, 0x0A, 0x57, 0xB1, 0x11, 0x81, + 0x5F, 0x68, 0xAD, 0x36, 0x00, 0x3F, 0x73, 0x5D, + 0x8C, 0x1B, 0x8B, 0xFA, 0xA9, 0x70, 0x74, 0xCA, + 0xB3, 0x5D, 0x44, 0xAF, 0x99, 0xE2, 0xDA, 0x06 + }, + { + 0xCC, 0xF9, 0x35, 0x20, 0x88, 0x65, 0xBD, 0x6F, + 0xA6, 0x74, 0xB6, 0x18, 0x83, 0x22, 0xAA, 0x03, + 0x27, 0xBD, 0xC2, 0x2B, 0xA7, 0x98, 0x60, 0x14, + 0x1F, 0x83, 0x42, 0x7F, 0x76, 0xE3, 0x04, 0x69, + 0x68, 0x53, 0x3A, 0x78, 0x64, 0x32, 0x40, 0xFA, + 0xE6, 0x6C, 0xD8, 0x3C, 0x97, 0x27, 0x38, 0x73, + 0x08, 0xEE, 0x15, 0x6B, 0x57, 0x2A, 0xD4, 0x8C, + 0x2D, 0x4F, 0x5A, 0xB3, 0xE5, 0x5F, 0x52, 0xF7 + }, + { + 0x93, 0x57, 0x31, 0x8F, 0xC8, 0x33, 0xB9, 0x4D, + 0x6A, 0xB2, 0x43, 0x3B, 0xC1, 0xB9, 0x5A, 0xA2, + 0x7A, 0xA0, 0x0C, 0xF7, 0xE5, 0x51, 0xA1, 0x0B, + 0x49, 0xA4, 0xC6, 0x48, 0xD6, 0xD1, 0x8C, 0xB7, + 0x3B, 0x21, 0xD4, 0x2B, 0x56, 0xD5, 0xC6, 0xC3, + 0x6B, 0xE8, 0x4E, 0x32, 0x36, 0x7C, 0xAF, 0xD9, + 0xC9, 0x2C, 0xEE, 0x6B, 0x53, 0x6C, 0xE9, 0xD1, + 0x8A, 0x2D, 0x83, 0x82, 0xB0, 0xBB, 0xB1, 0x5C + }, + { + 0xBC, 0x52, 0xAE, 0x7C, 0x6E, 0x49, 0xE4, 0x48, + 0x6E, 0x8E, 0x09, 0x88, 0x6B, 0x0F, 0x3D, 0x35, + 0x65, 0xDE, 0xC0, 0x91, 0x65, 0x14, 0x1A, 0xE5, + 0x16, 0x67, 0x0E, 0x7A, 0x48, 0xBC, 0x19, 0x30, + 0xB4, 0xFF, 0x1E, 0x2A, 0x10, 0x7D, 0x0B, 0x51, + 0xBC, 0x45, 0xAD, 0xA4, 0x8A, 0xCD, 0xFB, 0x5B, + 0x6C, 0x1B, 0xD5, 0xDD, 0xC7, 0x0E, 0xD0, 0xE4, + 0x60, 0xA5, 0xCF, 0x2C, 0x07, 0x7A, 0x31, 0x6F + }, + { + 0x68, 0x30, 0xC5, 0x64, 0x75, 0x32, 0x1E, 0xAF, + 0xEE, 0x2F, 0xB0, 0x08, 0xCB, 0x96, 0x7A, 0x62, + 0x25, 0xE1, 0xA3, 0x43, 0x4A, 0x1F, 0xDB, 0x1B, + 0x45, 0xB6, 0xF5, 0x44, 0xD2, 0xBD, 0xC4, 0xE3, + 0xFD, 0xF9, 0x78, 0x05, 0xA1, 0xF8, 0x9D, 0x0A, + 0x67, 0x76, 0x30, 0x70, 0xA9, 0x71, 0xD0, 0x36, + 0x58, 0x3A, 0xBE, 0xBF, 0x77, 0xEA, 0x11, 0x45, + 0xC2, 0x13, 0x3C, 0xB4, 0x40, 0x72, 0x2A, 0xB8 + }, + { + 0x81, 0x38, 0x0D, 0x61, 0xD4, 0x38, 0xC4, 0x2E, + 0xB3, 0x96, 0x29, 0xBF, 0x67, 0x0F, 0x5E, 0x5E, + 0xDA, 0x12, 0x8D, 0x8C, 0x62, 0xEB, 0x28, 0x66, + 0x88, 0x99, 0x49, 0x6F, 0xEF, 0xE8, 0x44, 0xA0, + 0x63, 0x1A, 0x10, 0xCD, 0x97, 0x65, 0x4A, 0xDB, + 0xE9, 0x32, 0x2B, 0xC7, 0x58, 0x24, 0x45, 0xB5, + 0x57, 0xDD, 0x14, 0xA6, 0xAA, 0x79, 0x4B, 0x91, + 0xA7, 0x4C, 0x6C, 0xA6, 0x64, 0xE0, 0xF8, 0x77 + }, + { + 0xA1, 0x2A, 0x1E, 0x4C, 0x69, 0x40, 0x33, 0x1A, + 0xF0, 0xBB, 0xC2, 0xE5, 0x12, 0x0E, 0xD5, 0xDD, + 0x05, 0x93, 0x67, 0x57, 0xF0, 0x05, 0xA1, 0x06, + 0xD9, 0x2E, 0x3A, 0xDB, 0xCA, 0x88, 0x65, 0xD8, + 0xA1, 0x6C, 0x21, 0x1A, 0x08, 0x1D, 0x9C, 0x2E, + 0x1B, 0xE4, 0xFA, 0x81, 0x69, 0x76, 0x97, 0x06, + 0xA9, 0xDD, 0xCA, 0x96, 0x35, 0x06, 0x6C, 0xBD, + 0x58, 0xC6, 0xC4, 0x93, 0xBF, 0x44, 0x90, 0x04 + }, + { + 0xEC, 0x52, 0x1C, 0xBB, 0x37, 0xF0, 0x44, 0x67, + 0xCC, 0x06, 0xE2, 0x42, 0x6C, 0xC0, 0x37, 0xDC, + 0x43, 0x56, 0x80, 0xCA, 0x54, 0xFC, 0x7E, 0x6C, + 0xC1, 0xF7, 0xA1, 0x3D, 0x4F, 0x96, 0xFD, 0xD6, + 0x5E, 0xE3, 0xD9, 0xED, 0xDB, 0xA7, 0x18, 0x77, + 0x8A, 0x15, 0x55, 0xF5, 0x3B, 0x14, 0xAA, 0x22, + 0x01, 0xD1, 0xC4, 0x94, 0xEE, 0xD5, 0xC7, 0x73, + 0x27, 0x58, 0x7B, 0xC7, 0x62, 0xE3, 0x98, 0x2F + }, + { + 0x18, 0xB7, 0x20, 0xAA, 0xF5, 0x4D, 0xED, 0x97, + 0x42, 0xDF, 0x7F, 0xAF, 0xA7, 0xB1, 0xC7, 0x99, + 0x01, 0xEC, 0x99, 0xFE, 0xBF, 0xD9, 0x0A, 0xCC, + 0x61, 0xC1, 0x70, 0x34, 0xAB, 0xF1, 0xE1, 0xBE, + 0x6A, 0x34, 0xB0, 0x98, 0xDB, 0x4C, 0xF2, 0xC4, + 0xA6, 0xC6, 0x1A, 0xCC, 0xCA, 0x2B, 0xAB, 0xDA, + 0xA5, 0xE9, 0x26, 0x3A, 0xAA, 0xD8, 0x5B, 0xD9, + 0x90, 0xCA, 0x66, 0xE4, 0x81, 0xA1, 0xA2, 0x00 + }, + { + 0x90, 0x8E, 0x85, 0x6C, 0xD0, 0xC7, 0x7E, 0xFC, + 0x19, 0xE7, 0xF8, 0x0E, 0x9F, 0x27, 0xAA, 0xD2, + 0x23, 0xDF, 0x09, 0xB2, 0x57, 0xFF, 0xA0, 0x6A, + 0x5B, 0x17, 0x1F, 0xC7, 0x36, 0xC3, 0xED, 0x92, + 0x66, 0x92, 0x7D, 0xA2, 0x03, 0x68, 0xAE, 0xA2, + 0xE4, 0x35, 0x07, 0xA2, 0x30, 0x82, 0xF1, 0xBA, + 0x13, 0x82, 0x38, 0x1E, 0x73, 0x17, 0x41, 0xA0, + 0x37, 0xE3, 0x26, 0x9F, 0xBB, 0x3B, 0x9D, 0x53 + }, + { + 0xD6, 0x55, 0xF7, 0x25, 0x06, 0x76, 0x40, 0x17, + 0x8C, 0x5D, 0x4B, 0x46, 0x8D, 0x5F, 0x48, 0xC6, + 0x4A, 0xEC, 0x30, 0x0B, 0xAF, 0x94, 0x1F, 0x21, + 0x68, 0xD5, 0x70, 0x97, 0x87, 0x0C, 0x72, 0x8C, + 0x33, 0xBD, 0xB2, 0x1B, 0x32, 0xEF, 0xB4, 0x09, + 0x08, 0x52, 0xC6, 0x9B, 0xBF, 0xDD, 0xFB, 0xDC, + 0xC9, 0xDF, 0xD2, 0xDF, 0xBC, 0x03, 0xC7, 0x4B, + 0x17, 0xC6, 0x87, 0xAF, 0xDE, 0xC5, 0x77, 0xE9 + }, + { + 0x10, 0x13, 0x95, 0xC5, 0xBA, 0x2B, 0x49, 0x23, + 0x1B, 0x2E, 0x9F, 0xF8, 0xB4, 0xA6, 0x09, 0x86, + 0xDE, 0x21, 0xDC, 0x42, 0x9D, 0x11, 0xEE, 0xAF, + 0x2A, 0xB6, 0xA6, 0x8D, 0xFA, 0x10, 0xED, 0xD5, + 0xC0, 0x92, 0x98, 0xC9, 0xE4, 0xA7, 0x9C, 0x89, + 0x9D, 0x89, 0x17, 0x56, 0x8C, 0x51, 0x79, 0x13, + 0xB0, 0x09, 0xE5, 0x9E, 0x8E, 0xA8, 0x11, 0xFF, + 0x3F, 0x99, 0xCF, 0x9A, 0xDA, 0x11, 0x6C, 0x87 + }, + { + 0x37, 0x0C, 0xEB, 0x18, 0xCC, 0x8B, 0x6F, 0xA3, + 0xB6, 0x22, 0xA3, 0xC8, 0xDA, 0x63, 0x7B, 0x8F, + 0x0A, 0x87, 0x8B, 0xA0, 0x50, 0x46, 0x94, 0x83, + 0xB7, 0x94, 0x6B, 0xB9, 0xD7, 0x08, 0xEB, 0x27, + 0x85, 0x63, 0x25, 0xBB, 0x5E, 0x0F, 0x12, 0xF1, + 0x70, 0xB0, 0xBF, 0x72, 0x56, 0x46, 0xE2, 0xFB, + 0xD9, 0xBB, 0x4F, 0x0A, 0xBA, 0xBB, 0x3B, 0x39, + 0x49, 0xCA, 0x6D, 0x32, 0x24, 0xB6, 0x4E, 0xCE + }, + { + 0xDE, 0x49, 0x47, 0x57, 0xCB, 0xAA, 0xD9, 0x23, + 0x20, 0x8F, 0xF7, 0xCA, 0x0D, 0xE9, 0x0E, 0x09, + 0x68, 0x03, 0x08, 0xF4, 0x16, 0xBE, 0xE3, 0xBD, + 0xA7, 0xC6, 0x21, 0xBF, 0x94, 0xA3, 0x01, 0x65, + 0x60, 0x93, 0xFC, 0xD5, 0x86, 0x72, 0xE8, 0x63, + 0x75, 0x8B, 0x64, 0x26, 0xB0, 0x5A, 0xB5, 0x32, + 0x8A, 0x60, 0x25, 0x76, 0x40, 0xA9, 0x4B, 0xA0, + 0xBC, 0x21, 0x33, 0x73, 0xB7, 0x3E, 0xD9, 0x29 + }, + { + 0xA8, 0x54, 0x3C, 0xB6, 0xBE, 0x25, 0x12, 0xB0, + 0x4C, 0x5E, 0x83, 0x02, 0x79, 0x22, 0xEE, 0x31, + 0xF7, 0x28, 0xA3, 0x6D, 0xBB, 0x13, 0x75, 0xE8, + 0xEB, 0x57, 0x1E, 0xF7, 0x4F, 0xDA, 0x22, 0x65, + 0x65, 0x8C, 0x57, 0x95, 0xBE, 0xB5, 0x1C, 0xE1, + 0xB4, 0x9B, 0x58, 0x9A, 0x6E, 0x32, 0x9C, 0xBF, + 0x82, 0xA0, 0x83, 0x5E, 0x44, 0x84, 0xCC, 0xEE, + 0xFE, 0x86, 0x8E, 0xBB, 0x18, 0x9D, 0xE3, 0x97 + }, + { + 0xC5, 0x5A, 0xED, 0x55, 0xD9, 0x23, 0xA1, 0x7E, + 0x37, 0x38, 0xEE, 0x61, 0x64, 0x42, 0x60, 0x35, + 0x1B, 0xDE, 0x51, 0x5C, 0xB2, 0xE7, 0x52, 0x91, + 0x1C, 0x15, 0xFA, 0xBD, 0x7C, 0xF6, 0x68, 0x15, + 0x82, 0x42, 0x80, 0x13, 0xED, 0x56, 0xDA, 0xFA, + 0x3F, 0x48, 0x5D, 0x20, 0xD4, 0xCD, 0x9E, 0x73, + 0x98, 0xE5, 0x8E, 0x9C, 0x52, 0x9F, 0x5C, 0xB9, + 0x53, 0x12, 0xE5, 0x7D, 0x5B, 0x49, 0x04, 0xB8 + }, + { + 0x20, 0xFE, 0xC6, 0x21, 0x16, 0x29, 0x54, 0xB2, + 0x5E, 0xB6, 0x44, 0xF4, 0x02, 0x55, 0x52, 0x3D, + 0x3A, 0xBA, 0xC8, 0x64, 0x1A, 0x6F, 0xC9, 0x9E, + 0x5F, 0x24, 0xDA, 0xBA, 0xD9, 0xF2, 0x00, 0x9B, + 0x0F, 0xA8, 0xFB, 0xCA, 0x1A, 0xA9, 0xD8, 0x37, + 0x79, 0xC7, 0x77, 0x6A, 0xD8, 0x1B, 0x8A, 0xCC, + 0x31, 0xD1, 0x9E, 0x2E, 0xE5, 0x66, 0x5B, 0x88, + 0x71, 0x95, 0x23, 0x3D, 0x22, 0x45, 0xB1, 0x7E + }, + { + 0x90, 0x57, 0x40, 0x47, 0xBD, 0x43, 0xBA, 0xA7, + 0x65, 0x77, 0x5F, 0x4F, 0x2E, 0x5A, 0x37, 0x91, + 0xCA, 0xEC, 0xE7, 0x5F, 0x72, 0x6A, 0x00, 0x7B, + 0xC6, 0x98, 0x30, 0xD9, 0xB1, 0x6C, 0xE1, 0x41, + 0xED, 0x24, 0x61, 0x89, 0xAF, 0xC4, 0x78, 0xD6, + 0x2A, 0xEA, 0x35, 0x8E, 0x0D, 0x62, 0xF1, 0x53, + 0xCD, 0x0A, 0xD4, 0xEC, 0x12, 0x04, 0x70, 0x1F, + 0x75, 0x74, 0xE9, 0x07, 0x55, 0x45, 0xB5, 0x7E + }, + { + 0x48, 0x5F, 0x34, 0x7E, 0xFB, 0x32, 0x4B, 0x64, + 0x7F, 0xE2, 0xB3, 0x42, 0x1A, 0x45, 0xF7, 0xBE, + 0x49, 0xAB, 0x22, 0xED, 0xFC, 0xDF, 0x66, 0x15, + 0xAA, 0xD2, 0x1E, 0xC2, 0x6C, 0x19, 0x58, 0x07, + 0x42, 0xAD, 0x12, 0x85, 0xF5, 0x0E, 0x13, 0x87, + 0xB8, 0xBD, 0xDD, 0x49, 0x33, 0x2E, 0x4D, 0x1F, + 0x4D, 0xE0, 0x91, 0x47, 0x68, 0xA0, 0x69, 0x7E, + 0xDF, 0x38, 0xEA, 0x03, 0x88, 0x83, 0xB1, 0x85 + }, + { + 0x9D, 0x35, 0x2D, 0x9A, 0x98, 0x5F, 0x13, 0xA0, + 0xD6, 0xD0, 0xF2, 0x04, 0x64, 0x8E, 0x59, 0x18, + 0xFC, 0x46, 0x1F, 0xB5, 0x09, 0xDC, 0x47, 0x11, + 0x8B, 0x46, 0x48, 0x98, 0xA9, 0x53, 0x05, 0x47, + 0x1B, 0xCD, 0xEB, 0xF6, 0x63, 0x43, 0xAC, 0x87, + 0x12, 0xF5, 0x77, 0x01, 0xCA, 0xDD, 0xD5, 0x5A, + 0xBA, 0xD7, 0x36, 0xD1, 0x7B, 0x69, 0xD6, 0x83, + 0xFA, 0x8E, 0x40, 0x5A, 0xC2, 0x7F, 0x45, 0xEF + }, + { + 0x03, 0x2A, 0x16, 0x1E, 0x42, 0x13, 0x58, 0xE9, + 0x59, 0xA2, 0x53, 0xEE, 0x6F, 0x69, 0xD5, 0x48, + 0x25, 0x98, 0x01, 0x46, 0x37, 0xF5, 0xAC, 0x2C, + 0x03, 0xD4, 0x73, 0xA9, 0x32, 0x35, 0x3B, 0xD7, + 0xBF, 0x3B, 0x44, 0x4F, 0xB9, 0x07, 0x4E, 0xA3, + 0x93, 0x42, 0x11, 0xF6, 0x48, 0x11, 0xA4, 0x78, + 0x7D, 0x1B, 0x0F, 0x4C, 0x26, 0xC2, 0xCE, 0xC5, + 0xD2, 0xF0, 0xC3, 0xA6, 0x54, 0xD8, 0x8A, 0xCD + }, + { + 0x86, 0x42, 0x44, 0x3F, 0xB9, 0x73, 0xF8, 0x1F, + 0xFB, 0xDB, 0x36, 0xCF, 0xAB, 0x6B, 0x44, 0x21, + 0x8D, 0x2F, 0x37, 0xA4, 0xEE, 0x2D, 0xAB, 0x88, + 0x3D, 0xFF, 0x71, 0x05, 0x45, 0x4D, 0x1A, 0x28, + 0xB2, 0x39, 0xF9, 0x4F, 0xC4, 0x84, 0x4C, 0x79, + 0x1F, 0x4D, 0x50, 0xB3, 0xD8, 0x89, 0xFF, 0x97, + 0x39, 0xE8, 0x75, 0x78, 0xFF, 0x64, 0x53, 0xB1, + 0x49, 0xC4, 0x07, 0xD4, 0xA7, 0x1B, 0x66, 0xB6 + }, + { + 0x07, 0xFF, 0x86, 0x28, 0xB5, 0x87, 0x44, 0x41, + 0x60, 0x04, 0x42, 0x54, 0x0F, 0x45, 0x07, 0xFF, + 0x2B, 0x56, 0x54, 0x49, 0x32, 0x16, 0xA1, 0xCA, + 0xA8, 0xD5, 0x6B, 0xFD, 0x06, 0x8E, 0x8C, 0x92, + 0x33, 0xC3, 0x65, 0x74, 0x83, 0x87, 0x44, 0xC4, + 0x8F, 0xC9, 0xBE, 0x80, 0x64, 0x06, 0xA1, 0xBF, + 0x1B, 0xD0, 0xE0, 0xCE, 0x96, 0xAD, 0x0F, 0xCA, + 0xD4, 0xF4, 0xC7, 0x21, 0xE6, 0x47, 0xA1, 0x62 + }, + { + 0x81, 0x23, 0xD4, 0x5B, 0x92, 0x04, 0xEA, 0xAC, + 0x28, 0x88, 0xC7, 0x58, 0x4B, 0xA1, 0x0A, 0x4C, + 0x59, 0x0F, 0xD1, 0x54, 0xD5, 0x1E, 0x24, 0x40, + 0x33, 0x65, 0x46, 0x6C, 0xFE, 0xEE, 0xFD, 0x6E, + 0x4F, 0x37, 0xC6, 0xB7, 0x15, 0xE8, 0xD2, 0xAB, + 0x52, 0xEC, 0xBC, 0xA9, 0x2D, 0x4A, 0x89, 0x43, + 0xEF, 0x4F, 0x10, 0xE4, 0xF5, 0x06, 0x30, 0xD0, + 0x45, 0x91, 0xA3, 0x35, 0xF4, 0x16, 0x43, 0x5D + }, + { + 0xB0, 0xEF, 0x54, 0xFB, 0x9B, 0x68, 0x89, 0x72, + 0xB2, 0x40, 0x9F, 0xBE, 0x9B, 0x95, 0xBD, 0xC2, + 0x59, 0xA4, 0x47, 0x93, 0x90, 0x5C, 0x29, 0xA1, + 0x24, 0x59, 0xD9, 0x75, 0xDF, 0x6A, 0x44, 0x6C, + 0x9F, 0x17, 0x5E, 0x08, 0x97, 0x6C, 0x8B, 0x6E, + 0xCA, 0x1F, 0x75, 0x65, 0xA7, 0xB6, 0x10, 0x42, + 0xF3, 0xDC, 0x03, 0x20, 0xC3, 0x09, 0x1D, 0xC5, + 0x1F, 0xD0, 0xE4, 0x1F, 0x8E, 0x56, 0x1B, 0x8D + }, + { + 0x58, 0xF9, 0x85, 0x51, 0x8A, 0x2B, 0x90, 0x82, + 0x99, 0x83, 0xCD, 0x48, 0xB9, 0x62, 0x3D, 0x71, + 0x2C, 0x23, 0x61, 0xA3, 0x67, 0xAC, 0xA5, 0x1A, + 0x5E, 0x08, 0x66, 0x39, 0xD8, 0x79, 0x75, 0xD3, + 0xD4, 0x5A, 0x1F, 0x1E, 0xF1, 0x7E, 0x51, 0xE8, + 0xD9, 0x9C, 0x99, 0x95, 0xD8, 0x7F, 0xF1, 0xA8, + 0xE4, 0x77, 0xD7, 0xC2, 0x31, 0xCA, 0x47, 0x51, + 0x14, 0x10, 0xBD, 0xDE, 0xA9, 0x38, 0x53, 0xA7 + }, + { + 0x90, 0x94, 0x97, 0x11, 0x55, 0x82, 0x0A, 0x10, + 0xD4, 0xF5, 0xFE, 0x7C, 0xDA, 0x82, 0x72, 0xCE, + 0x41, 0xC2, 0xC8, 0x63, 0xBE, 0xF2, 0x44, 0x41, + 0xCB, 0x6A, 0x60, 0x94, 0x95, 0xA9, 0xD2, 0x01, + 0x72, 0x70, 0x30, 0x9B, 0x96, 0xB4, 0x38, 0x97, + 0x56, 0x4F, 0xD9, 0x07, 0xEA, 0x75, 0xF9, 0x9E, + 0x2D, 0xD2, 0x82, 0xEA, 0x4E, 0x5E, 0xC5, 0x50, + 0xEA, 0x78, 0x52, 0xCE, 0x3B, 0x69, 0xF3, 0x8D + }, + { + 0x34, 0xCA, 0xF7, 0x54, 0x82, 0x13, 0xCB, 0x73, + 0x36, 0xF1, 0x79, 0x10, 0x29, 0x31, 0xBC, 0x39, + 0xB7, 0x91, 0x8E, 0x87, 0x53, 0xC5, 0x6F, 0x8F, + 0x7E, 0x10, 0x2F, 0xBA, 0x6F, 0x1A, 0x29, 0x11, + 0x5D, 0xEB, 0xA2, 0xBE, 0x9B, 0x02, 0x3E, 0x15, + 0xD3, 0xE6, 0xC3, 0x49, 0x87, 0xEB, 0xC4, 0x70, + 0xD9, 0xE9, 0x4D, 0x68, 0x42, 0x86, 0x13, 0x57, + 0x41, 0xDF, 0xF3, 0xBD, 0x59, 0xEC, 0x98, 0x2D + }, + { + 0xA6, 0xDB, 0xFE, 0xDB, 0xAE, 0x19, 0x9E, 0xF6, + 0x7C, 0x93, 0x71, 0x0D, 0xEC, 0xC4, 0x18, 0x34, + 0x89, 0x1C, 0xC6, 0xDC, 0xE4, 0xA0, 0x81, 0xC2, + 0xD4, 0x2F, 0x5C, 0x99, 0x68, 0x62, 0xFD, 0xBB, + 0xF1, 0x72, 0xBD, 0xBB, 0x9D, 0x3A, 0x3C, 0xBB, + 0x4D, 0x6D, 0xC6, 0x9F, 0xE8, 0x71, 0x1B, 0x43, + 0x3C, 0xF2, 0x8E, 0x8C, 0x97, 0x88, 0x36, 0x9B, + 0x33, 0xA9, 0x36, 0xE5, 0xBE, 0x54, 0x6B, 0x8C + }, + { + 0x3E, 0x77, 0x73, 0x95, 0x61, 0xE3, 0x65, 0x63, + 0xD1, 0xEF, 0xCD, 0x01, 0xF8, 0x2F, 0xAF, 0x5A, + 0xB8, 0xB0, 0xFF, 0xBF, 0x3A, 0x9E, 0x63, 0xF1, + 0xE1, 0x49, 0x62, 0x50, 0xB9, 0x7E, 0x12, 0x88, + 0xCD, 0xC9, 0xF8, 0xD4, 0x2F, 0xEA, 0xEB, 0x28, + 0x87, 0x89, 0x78, 0x7D, 0x5E, 0xC4, 0xB3, 0xD9, + 0x1B, 0x40, 0x5A, 0x58, 0x6F, 0x6D, 0x34, 0xF7, + 0x44, 0xC1, 0xD3, 0x8F, 0xE9, 0x82, 0xEA, 0x48 + }, + { + 0xE0, 0xC5, 0x0A, 0xF4, 0xEB, 0xCB, 0x2A, 0x64, + 0xD1, 0x2D, 0x79, 0x14, 0x60, 0x75, 0x1A, 0x13, + 0xA6, 0x41, 0xB6, 0x4D, 0x94, 0x83, 0x01, 0x66, + 0xF2, 0xD8, 0x15, 0x7A, 0x2E, 0x23, 0xC5, 0xBC, + 0x1D, 0x74, 0xE9, 0xAB, 0x7F, 0xC4, 0xE2, 0x9D, + 0x88, 0xA5, 0x52, 0x4A, 0x97, 0xC4, 0x75, 0xE8, + 0x57, 0x54, 0x79, 0xAB, 0x5F, 0xF9, 0x3B, 0x05, + 0x44, 0x92, 0xEA, 0x4B, 0x62, 0xDB, 0x24, 0x89 + }, + { + 0xBB, 0x46, 0x8F, 0x06, 0x83, 0xA1, 0x82, 0x62, + 0x85, 0x23, 0x27, 0xA5, 0x7B, 0xE4, 0x95, 0xBF, + 0xE9, 0x15, 0x65, 0x7B, 0x36, 0x42, 0x23, 0x1F, + 0xE9, 0x5C, 0x3D, 0x30, 0x0A, 0x53, 0x81, 0x30, + 0xC4, 0x9C, 0x56, 0x87, 0xC4, 0x4F, 0x11, 0x4E, + 0x0F, 0x44, 0x15, 0x18, 0xFE, 0x9C, 0xFB, 0xC1, + 0x3E, 0x6F, 0x51, 0x6D, 0xBE, 0x5B, 0xFC, 0xD3, + 0x85, 0x9A, 0xE4, 0xF3, 0x1B, 0xA3, 0xAB, 0xC3 + }, + { + 0x85, 0x29, 0x20, 0x3E, 0x28, 0x59, 0x64, 0xE4, + 0x08, 0x7F, 0xA6, 0x81, 0xBC, 0x34, 0xF8, 0xC9, + 0x90, 0x04, 0xB0, 0x0E, 0x9C, 0x72, 0xA0, 0x3C, + 0xDF, 0x9F, 0x2E, 0xFC, 0x5A, 0x2C, 0xD7, 0x78, + 0xC9, 0x2C, 0x47, 0xF3, 0xC3, 0x03, 0x5C, 0x99, + 0x57, 0x82, 0xBF, 0x95, 0xE6, 0x9D, 0xA4, 0x9B, + 0x07, 0xDE, 0xCC, 0xD8, 0x34, 0xA0, 0x77, 0x90, + 0xC2, 0x00, 0x50, 0x1F, 0x96, 0x4E, 0x05, 0xF1 + }, + { + 0xE2, 0xF6, 0x69, 0x88, 0xB1, 0xD1, 0x05, 0x69, + 0x61, 0xBA, 0x3A, 0x28, 0xCC, 0x71, 0xF0, 0xA8, + 0x1E, 0xBB, 0x72, 0x2D, 0xBC, 0xC9, 0xC4, 0xC8, + 0xAD, 0x32, 0xB2, 0x58, 0xFC, 0xC5, 0xD9, 0x6B, + 0xDD, 0x44, 0x6A, 0xF3, 0xF8, 0x3B, 0xB0, 0xEF, + 0x14, 0x50, 0x28, 0x93, 0xC4, 0x98, 0xEA, 0x61, + 0x4D, 0xF7, 0x09, 0xFC, 0x85, 0x1E, 0xBD, 0xF5, + 0xB9, 0xFD, 0xAE, 0x82, 0x70, 0xBC, 0x5D, 0xF3 + }, + { + 0xE4, 0xF1, 0xAF, 0x01, 0x4D, 0x72, 0x75, 0xA8, + 0x0B, 0x7D, 0x6C, 0x04, 0x62, 0x2C, 0xF5, 0x7A, + 0x0B, 0x74, 0x38, 0xF0, 0xBC, 0x3F, 0x13, 0xDC, + 0x3D, 0x16, 0x51, 0x31, 0x2E, 0xAB, 0x59, 0x37, + 0x14, 0xA0, 0x20, 0x87, 0xE2, 0xD2, 0x73, 0x00, + 0xF3, 0x81, 0xB4, 0x26, 0xF6, 0x47, 0x60, 0x3C, + 0xA6, 0x9B, 0xFE, 0x09, 0x71, 0x16, 0x05, 0x3F, + 0x7E, 0xF2, 0xDC, 0x00, 0x84, 0x61, 0x34, 0x30 + }, + { + 0x97, 0xA8, 0x74, 0x88, 0xB4, 0x38, 0x31, 0x9A, + 0x95, 0x48, 0xD5, 0x79, 0xEA, 0x93, 0x91, 0x8A, + 0xDC, 0xA1, 0x5C, 0x7A, 0x1F, 0x7F, 0x98, 0xE9, + 0x27, 0xDA, 0x4C, 0xBF, 0x19, 0xB9, 0x4A, 0x29, + 0x57, 0x48, 0x4A, 0xCF, 0xEE, 0xD0, 0x89, 0x27, + 0xF6, 0xF9, 0xD3, 0x53, 0x89, 0xC0, 0xBE, 0xBE, + 0xED, 0xA8, 0x4F, 0x40, 0x87, 0x50, 0xA2, 0x80, + 0xF9, 0xB3, 0xD9, 0xA7, 0x64, 0xDF, 0xE7, 0xCF + }, + { + 0xDC, 0x24, 0xAC, 0x8A, 0xB5, 0xCC, 0x93, 0x06, + 0xE7, 0xF5, 0xB2, 0x8C, 0xBF, 0x02, 0xB2, 0x2F, + 0xE6, 0xDB, 0xFC, 0xA5, 0x41, 0xAB, 0x56, 0xF1, + 0x39, 0xDB, 0x04, 0x72, 0x6F, 0xE4, 0xB2, 0xBE, + 0xDC, 0x4B, 0x94, 0xE0, 0xA7, 0x7D, 0xEE, 0x10, + 0x89, 0x12, 0x06, 0x6F, 0x1F, 0xC1, 0xF9, 0x10, + 0xBE, 0xE1, 0x14, 0xC0, 0x34, 0xD7, 0xC0, 0x37, + 0x84, 0xA8, 0x18, 0x70, 0x63, 0xBA, 0x63, 0x4D + }, + { + 0x3E, 0xF3, 0xD9, 0x96, 0x57, 0x4A, 0x4A, 0x55, + 0x98, 0xD1, 0x92, 0x21, 0x8B, 0x89, 0xAC, 0x89, + 0xE6, 0x14, 0x2B, 0xB5, 0x4C, 0xAE, 0x49, 0xFC, + 0x62, 0xC8, 0x4D, 0x70, 0x5E, 0x0F, 0xBA, 0xEB, + 0x1F, 0x09, 0x96, 0xD0, 0xB6, 0x5E, 0x1A, 0x5B, + 0xB9, 0x6E, 0xC3, 0x6A, 0x5E, 0x57, 0xDE, 0x14, + 0x52, 0x86, 0x10, 0x2D, 0x87, 0x2C, 0xC5, 0xD9, + 0xD5, 0x88, 0x74, 0xA0, 0x6B, 0x1F, 0xE0, 0x68 + }, + { + 0x9D, 0x5E, 0x02, 0x66, 0x98, 0xF5, 0xB9, 0xAF, + 0x81, 0xA0, 0x44, 0x99, 0x08, 0xCC, 0xF8, 0x64, + 0xBD, 0x02, 0xC5, 0xA3, 0x16, 0xCD, 0x33, 0xD3, + 0x31, 0xE3, 0x3E, 0xEB, 0x14, 0xE4, 0x09, 0x31, + 0xE5, 0xEF, 0x72, 0x98, 0xB3, 0xA3, 0x3E, 0x39, + 0x75, 0x01, 0x6E, 0xD9, 0x8F, 0x5D, 0x90, 0x7E, + 0xF4, 0x14, 0xA8, 0x65, 0x75, 0x54, 0xCF, 0x08, + 0x0F, 0x76, 0x1B, 0xFA, 0x65, 0x1B, 0x31, 0xAF + }, + { + 0xC4, 0xBB, 0xBC, 0x5A, 0x1C, 0xB5, 0x85, 0xF2, + 0x9B, 0xBB, 0x10, 0xA3, 0x51, 0x16, 0xCA, 0xC3, + 0x44, 0xA3, 0x4B, 0x1B, 0x44, 0x3C, 0x13, 0x34, + 0x67, 0x53, 0x50, 0x4F, 0x9A, 0xDD, 0x71, 0x26, + 0xA6, 0xBA, 0xFE, 0xC9, 0x36, 0x36, 0xD7, 0x19, + 0x1E, 0x91, 0xE0, 0x94, 0x7A, 0xA6, 0x9A, 0x98, + 0xA3, 0xFB, 0x11, 0xD3, 0x4F, 0xE7, 0x6C, 0x40, + 0xCB, 0xD6, 0x18, 0x62, 0x38, 0xAD, 0xBD, 0x29 + }, + { + 0x47, 0x0B, 0xC3, 0x13, 0x38, 0x16, 0xE1, 0xE6, + 0xCC, 0x7D, 0x5A, 0x04, 0xD2, 0xC2, 0x9D, 0x4E, + 0x66, 0xC6, 0x65, 0xE2, 0x95, 0xFE, 0x88, 0x96, + 0x01, 0x88, 0xE0, 0x5C, 0xE8, 0x08, 0x07, 0x55, + 0xBA, 0x79, 0x48, 0x1B, 0x27, 0x38, 0x98, 0xD6, + 0x40, 0x4E, 0x5F, 0x03, 0xF7, 0xD5, 0x91, 0x34, + 0x08, 0x43, 0x42, 0x73, 0x77, 0x85, 0x2E, 0xE1, + 0x6C, 0xAB, 0xB1, 0x6A, 0x35, 0xBB, 0x1A, 0x56 + }, + { + 0x01, 0xB5, 0xDD, 0x24, 0x61, 0xC2, 0xC0, 0x4B, + 0x3B, 0xD1, 0x0A, 0x70, 0x4F, 0x3B, 0xE0, 0x63, + 0xD5, 0x6E, 0x7C, 0xF1, 0x21, 0x06, 0x7D, 0x96, + 0x13, 0x11, 0x04, 0xF0, 0x2D, 0x49, 0x5F, 0xE0, + 0x9D, 0x9B, 0xF2, 0xC4, 0x55, 0x7A, 0xC5, 0xA9, + 0xDA, 0xFA, 0xCA, 0x02, 0x4F, 0x77, 0x2D, 0x4D, + 0xDE, 0xB7, 0xFE, 0x88, 0x54, 0x73, 0x86, 0x76, + 0x6E, 0xB0, 0xA8, 0x92, 0xCB, 0xE5, 0x80, 0xE7 + }, + { + 0x41, 0x04, 0x1A, 0xF8, 0xF6, 0x27, 0x6A, 0xB4, + 0x7C, 0xD2, 0xBE, 0x03, 0x1E, 0xDA, 0x32, 0x7A, + 0x2D, 0x1A, 0x83, 0x97, 0x45, 0x28, 0x49, 0x25, + 0x16, 0x9A, 0xF4, 0x4C, 0x1F, 0x2F, 0xB6, 0x33, + 0x1F, 0x43, 0xF5, 0x99, 0xBD, 0x4D, 0x9B, 0x49, + 0x27, 0x58, 0x6D, 0x19, 0x11, 0x75, 0xE3, 0x0D, + 0x98, 0x2C, 0x26, 0x19, 0x64, 0x11, 0x08, 0x05, + 0x23, 0x17, 0xBB, 0x19, 0x56, 0x6F, 0x77, 0xBC + }, + { + 0x17, 0x6B, 0x35, 0xC0, 0x66, 0x8D, 0x9C, 0x6F, + 0xB3, 0xE1, 0x0E, 0xF2, 0x7D, 0xBA, 0xF0, 0xF1, + 0x5D, 0x11, 0xB5, 0x02, 0x78, 0x06, 0x3E, 0x3E, + 0xE9, 0xBF, 0x0F, 0xC9, 0x30, 0xDE, 0xDF, 0x24, + 0x9C, 0xD0, 0x5D, 0x11, 0x28, 0xED, 0x38, 0xB2, + 0x39, 0xF2, 0xAB, 0xED, 0x8F, 0x03, 0xCF, 0xFC, + 0x43, 0xDC, 0xFA, 0x7B, 0x54, 0x5A, 0xA4, 0x8C, + 0x59, 0x3C, 0xCA, 0x7D, 0x9A, 0x94, 0xD7, 0x3B + }, + { + 0xD1, 0x85, 0xF6, 0xF9, 0x36, 0x15, 0xCC, 0xCC, + 0x68, 0xA6, 0x5A, 0x99, 0xED, 0x73, 0x78, 0xD1, + 0x55, 0x44, 0x37, 0x2B, 0x91, 0xC6, 0xC7, 0x52, + 0x74, 0xFD, 0x0C, 0xD9, 0x31, 0x0C, 0xE4, 0x38, + 0x96, 0xEA, 0xD5, 0x57, 0x5E, 0x28, 0x0A, 0x77, + 0xF2, 0xE8, 0xCC, 0x70, 0xCB, 0xF6, 0x93, 0xD6, + 0xA8, 0x87, 0x51, 0xFD, 0xAB, 0x0B, 0xBD, 0x30, + 0x99, 0x6D, 0x46, 0x00, 0xBF, 0x1B, 0x56, 0x87 + }, + { + 0xAF, 0x51, 0x2C, 0x58, 0xAA, 0x44, 0x78, 0x2E, + 0x89, 0x48, 0xC2, 0x81, 0x6C, 0x98, 0xDD, 0xE7, + 0xC8, 0x60, 0x26, 0x78, 0xA3, 0x4F, 0x10, 0x55, + 0x1A, 0x54, 0xF2, 0x5D, 0x41, 0x4B, 0xA6, 0x62, + 0x72, 0xF4, 0xA2, 0xD7, 0x30, 0x84, 0xFF, 0x0F, + 0xC7, 0xDC, 0x90, 0x55, 0xA7, 0xD6, 0x23, 0xDE, + 0x63, 0x0A, 0x5D, 0x4D, 0x58, 0xB0, 0x41, 0xA9, + 0x4B, 0x29, 0xBF, 0x4C, 0x96, 0x7B, 0x44, 0x67 + }, + { + 0x7B, 0x54, 0x1E, 0x30, 0xDC, 0x15, 0x32, 0x52, + 0xE9, 0x49, 0xBB, 0xC5, 0xA8, 0xD3, 0xBD, 0xB5, + 0x98, 0xB1, 0xE2, 0x43, 0x11, 0xDB, 0x1A, 0x4D, + 0x00, 0x43, 0x11, 0x87, 0x2B, 0x98, 0x6D, 0x2A, + 0x73, 0xF4, 0xA6, 0x5D, 0x19, 0xFA, 0xF1, 0xD2, + 0x13, 0x66, 0x5C, 0xFA, 0x84, 0x3D, 0xDE, 0x72, + 0x28, 0xA5, 0x84, 0x9D, 0x16, 0x1B, 0xA2, 0x03, + 0x9C, 0xB8, 0x88, 0xDF, 0x88, 0x23, 0x73, 0x73 + }, + { + 0xC6, 0x97, 0xDE, 0xE5, 0x87, 0xC0, 0x0B, 0x31, + 0xD5, 0x62, 0x45, 0x86, 0x28, 0x8E, 0x17, 0xBC, + 0x11, 0xA5, 0x08, 0xF4, 0xA3, 0x7C, 0x9D, 0xF3, + 0x08, 0x92, 0x33, 0x83, 0x66, 0xEA, 0x27, 0xC2, + 0x84, 0x8E, 0x12, 0x35, 0xFB, 0xBB, 0x65, 0x61, + 0x0F, 0x3D, 0xB2, 0xDB, 0xFB, 0x14, 0x38, 0x25, + 0x65, 0x75, 0xD0, 0x16, 0xFB, 0xC8, 0x84, 0x07, + 0xCA, 0xBB, 0x88, 0xF7, 0xC3, 0x79, 0xE4, 0x82 + }, + { + 0xDB, 0xC9, 0xD1, 0x63, 0x89, 0x78, 0x68, 0x8A, + 0x50, 0x1C, 0x15, 0x34, 0x04, 0x68, 0x35, 0xF7, + 0x44, 0x8C, 0xB7, 0x51, 0x28, 0x03, 0xA1, 0x2F, + 0xB1, 0xCC, 0xDF, 0xB1, 0xAC, 0x10, 0x14, 0xF0, + 0x9A, 0x60, 0x09, 0x9D, 0x05, 0x12, 0x83, 0xAB, + 0xDA, 0x5A, 0x37, 0xA3, 0x10, 0x91, 0x0D, 0xC7, + 0x6C, 0x0E, 0x34, 0xDA, 0x74, 0xE9, 0xD5, 0x46, + 0xCB, 0xE5, 0x84, 0x3A, 0x9F, 0x75, 0x82, 0x67 + }, + { + 0xD7, 0xFB, 0x0A, 0x53, 0x99, 0x78, 0x86, 0xEC, + 0xCE, 0x8C, 0xD4, 0x55, 0x28, 0xB5, 0x79, 0x8C, + 0x54, 0xD6, 0x36, 0x31, 0xFC, 0x6F, 0xED, 0x83, + 0x77, 0x5F, 0xC2, 0x54, 0x5C, 0xF0, 0xA5, 0x33, + 0x20, 0x9B, 0x71, 0xA9, 0x9D, 0x91, 0x08, 0x59, + 0xFB, 0xC6, 0xE3, 0xD2, 0xD1, 0x8B, 0x25, 0xEB, + 0x6B, 0xF1, 0xC1, 0x8C, 0x2B, 0x70, 0x75, 0xE0, + 0xB9, 0x86, 0xDF, 0xD7, 0x9A, 0xE3, 0xEE, 0xB0 + }, + { + 0x55, 0x40, 0x80, 0x75, 0x9E, 0x72, 0xBD, 0xBF, + 0x67, 0x5B, 0xA4, 0xB9, 0x0E, 0xF1, 0xB7, 0xB7, + 0x96, 0x97, 0x5C, 0x94, 0xB4, 0xA1, 0x33, 0x5F, + 0x2F, 0x19, 0x54, 0xDD, 0x60, 0xBB, 0xDB, 0x94, + 0xB3, 0x60, 0x9A, 0xC7, 0xD9, 0x39, 0xE1, 0x8D, + 0x11, 0x43, 0x90, 0x78, 0x20, 0x6B, 0x2C, 0x16, + 0x32, 0xDA, 0x6F, 0x71, 0xCA, 0x45, 0x81, 0x35, + 0x99, 0x07, 0xA4, 0x93, 0x21, 0x63, 0x12, 0xA8 + }, + { + 0xA1, 0x03, 0x78, 0x3C, 0x5B, 0x0C, 0x35, 0x1A, + 0x8F, 0x83, 0x29, 0x48, 0x13, 0x9F, 0x64, 0x99, + 0x78, 0x74, 0x6D, 0x62, 0xFF, 0xA7, 0xD4, 0xD5, + 0x71, 0x72, 0x69, 0x71, 0x54, 0x8A, 0xCA, 0x73, + 0xE0, 0x83, 0xEF, 0xE2, 0x3B, 0x85, 0xF2, 0x09, + 0x2B, 0x95, 0xDC, 0x5F, 0xE6, 0xF5, 0xF0, 0x2B, + 0x63, 0x09, 0x1C, 0xEA, 0xC7, 0x6D, 0x12, 0xC2, + 0xB3, 0x5D, 0xBE, 0x11, 0x28, 0xFA, 0xC9, 0x70 + }, + { + 0xD0, 0x96, 0x3E, 0x2A, 0xB6, 0x3A, 0x4E, 0x0A, + 0x00, 0x96, 0xA5, 0xE8, 0x4A, 0x43, 0xB0, 0x6A, + 0xCA, 0xC4, 0x40, 0x5A, 0xB1, 0x97, 0xD8, 0xAD, + 0x39, 0x82, 0xE7, 0xA8, 0x1C, 0xB2, 0xE8, 0x7C, + 0xED, 0x6E, 0x84, 0xB6, 0xEA, 0xBC, 0xAF, 0x87, + 0x66, 0x8D, 0xB5, 0x5A, 0xC7, 0x40, 0x3E, 0x6B, + 0xB7, 0xFA, 0xD3, 0x0E, 0x81, 0x10, 0x58, 0xF1, + 0x4F, 0xDF, 0x6A, 0x1B, 0xD3, 0x1D, 0xB4, 0xA8 + }, + { + 0xFC, 0xC4, 0x59, 0x75, 0x21, 0x2D, 0x3E, 0xFF, + 0xDA, 0x94, 0x59, 0x37, 0x57, 0x45, 0x0C, 0x31, + 0x1D, 0xBF, 0xBD, 0x28, 0xD2, 0xAC, 0x2B, 0x83, + 0x35, 0xA2, 0xB8, 0x47, 0x24, 0x5C, 0x7D, 0xD9, + 0x3C, 0x0D, 0xD8, 0x7F, 0xE5, 0x34, 0x93, 0xB5, + 0xCA, 0x7E, 0x3A, 0x48, 0x8E, 0x69, 0x30, 0x50, + 0xBC, 0x30, 0xFC, 0x3C, 0x29, 0x66, 0x3C, 0x98, + 0x55, 0x09, 0x69, 0x4C, 0x98, 0x80, 0x52, 0x61 + }, + { + 0x3E, 0x1E, 0x69, 0x8E, 0xB2, 0x8F, 0x63, 0x02, + 0xF3, 0x23, 0xE5, 0x37, 0x7F, 0xC7, 0x5F, 0x42, + 0x89, 0x39, 0x52, 0x96, 0xD1, 0x8B, 0x7E, 0x6F, + 0x67, 0x8B, 0x97, 0x02, 0xDF, 0x07, 0x43, 0x69, + 0xC7, 0x26, 0x56, 0xA1, 0x82, 0x37, 0x65, 0x88, + 0x19, 0xDE, 0x49, 0x44, 0x75, 0xCF, 0xC8, 0xE8, + 0x5A, 0x20, 0x1D, 0x68, 0xA6, 0x4A, 0x9A, 0x64, + 0x9C, 0x3A, 0x45, 0x75, 0xEA, 0x37, 0xF7, 0x0D + }, + { + 0xB6, 0x62, 0x10, 0x4B, 0x95, 0xB2, 0xD9, 0xA4, + 0x4B, 0x9D, 0x15, 0x17, 0xE9, 0x7E, 0x92, 0xB2, + 0xDD, 0xF0, 0x6E, 0x1F, 0x30, 0xE8, 0xC8, 0x3F, + 0x11, 0xAC, 0x97, 0xC1, 0x52, 0xE2, 0x1A, 0x07, + 0x0B, 0x77, 0x22, 0x93, 0x00, 0x4C, 0xDC, 0x0D, + 0x7C, 0x72, 0x9B, 0xF6, 0xA4, 0xE6, 0xD7, 0x4A, + 0x39, 0x11, 0x5E, 0x40, 0x08, 0x0E, 0x45, 0x12, + 0xC1, 0x69, 0x23, 0xCC, 0x23, 0x88, 0xFD, 0x74 + }, + { + 0x2F, 0xDC, 0x47, 0x5D, 0x8E, 0xDE, 0xA5, 0x56, + 0x93, 0xBF, 0x98, 0xAA, 0xC6, 0xE4, 0xB9, 0xEC, + 0xF6, 0x31, 0xD0, 0x1A, 0x54, 0xD5, 0xD7, 0x9F, + 0xD0, 0x59, 0xC6, 0x54, 0xBB, 0x68, 0xE9, 0x36, + 0x12, 0x02, 0xB8, 0x9E, 0x56, 0x7A, 0x04, 0xF7, + 0xC7, 0x19, 0xE6, 0x13, 0xE1, 0x2F, 0xFA, 0x20, + 0x78, 0x41, 0xC4, 0xA0, 0x7E, 0xF2, 0x37, 0xE6, + 0xC5, 0x38, 0xFB, 0x90, 0x5D, 0x45, 0xBF, 0xC4 + }, + { + 0xEC, 0x2A, 0x18, 0x22, 0x1C, 0x70, 0x07, 0x0E, + 0xC5, 0x07, 0x40, 0x19, 0x3A, 0x5D, 0x2B, 0xB7, + 0x87, 0x7C, 0x45, 0x21, 0x60, 0xDD, 0x24, 0x0E, + 0x2B, 0x1E, 0xB5, 0xEB, 0xF5, 0xB7, 0xA7, 0xE4, + 0x6B, 0xA0, 0x2A, 0x31, 0xEB, 0xF1, 0x65, 0xD7, + 0xEC, 0x8B, 0x9D, 0x10, 0xD7, 0xD0, 0x5F, 0x59, + 0x34, 0x19, 0xBF, 0x92, 0x04, 0x87, 0x6E, 0x56, + 0x5A, 0xCB, 0x76, 0x20, 0x23, 0x2E, 0x55, 0x38 + }, + { + 0xF4, 0xC3, 0xA7, 0x34, 0x1B, 0xB1, 0xA9, 0x70, + 0xC3, 0xCD, 0x26, 0x39, 0xCD, 0x3D, 0x44, 0x87, + 0xBB, 0x26, 0x00, 0xC5, 0xAB, 0xF5, 0x3E, 0x5F, + 0x0E, 0x13, 0x31, 0x34, 0x2C, 0x43, 0x6F, 0x71, + 0x3B, 0x5E, 0x4E, 0x55, 0xB9, 0xCA, 0xC2, 0x95, + 0x46, 0xA1, 0x0C, 0xF4, 0x4E, 0xFD, 0x6A, 0x91, + 0xF3, 0x45, 0x6B, 0xB8, 0x5C, 0x1C, 0x8E, 0x80, + 0xDA, 0x8B, 0x71, 0x95, 0x7C, 0x85, 0x7E, 0x04 + }, + { + 0xF6, 0x48, 0x45, 0xD9, 0x79, 0xDE, 0x18, 0x53, + 0x99, 0x8A, 0x1F, 0xA0, 0xFC, 0xCA, 0xB7, 0x95, + 0x27, 0xCE, 0x89, 0x58, 0x7C, 0xDD, 0x18, 0x2E, + 0xBF, 0x45, 0x99, 0x89, 0xC7, 0xA7, 0xF8, 0xC8, + 0x76, 0x10, 0xAD, 0xDD, 0xDA, 0x86, 0xCB, 0x24, + 0x31, 0x9F, 0xEB, 0xA0, 0xC4, 0xCE, 0xA2, 0x95, + 0xF6, 0x3D, 0x66, 0x4D, 0x28, 0xA5, 0x64, 0xB6, + 0xF2, 0xED, 0xF9, 0x0C, 0x86, 0x96, 0xA8, 0x44 + }, + { + 0x73, 0xDA, 0x18, 0xEC, 0x21, 0xC1, 0x89, 0xBB, + 0xBB, 0x59, 0xCE, 0x07, 0x3B, 0x91, 0xA9, 0x89, + 0x19, 0x20, 0xDE, 0x83, 0x10, 0x24, 0xE0, 0x76, + 0xE3, 0x98, 0xC9, 0x22, 0x4E, 0xD8, 0x66, 0xFD, + 0xE0, 0xCD, 0x3B, 0xE8, 0xDF, 0xDA, 0x09, 0x77, + 0x48, 0xD9, 0x49, 0x87, 0x83, 0x9D, 0x5B, 0xDD, + 0x54, 0x34, 0xCE, 0x49, 0x6D, 0x9E, 0xBE, 0xEA, + 0xE7, 0xA3, 0x4F, 0x1F, 0xDB, 0xC5, 0xE4, 0xAB + }, + { + 0xB3, 0x15, 0x0D, 0xDF, 0x2A, 0x7B, 0x2A, 0xFE, + 0x4F, 0x66, 0x1D, 0xF5, 0xAE, 0xB0, 0xF1, 0xE0, + 0xE4, 0x3D, 0x8F, 0xFB, 0x47, 0x2A, 0x25, 0xC0, + 0xD2, 0xE3, 0x45, 0xB6, 0x9D, 0x01, 0xD9, 0x33, + 0xC6, 0x0B, 0x5F, 0xA6, 0x74, 0x3E, 0x32, 0x4A, + 0x16, 0x6A, 0xAC, 0x1D, 0x38, 0xCC, 0xA1, 0x73, + 0xAE, 0x4A, 0xE3, 0x75, 0xE1, 0x32, 0xE1, 0x4C, + 0x8D, 0x51, 0xE7, 0x05, 0x12, 0x13, 0xAA, 0x84 + }, + { + 0x68, 0x3F, 0xBA, 0xC5, 0xFB, 0x0E, 0xA0, 0xB8, + 0x0B, 0x2E, 0x36, 0xB8, 0xDF, 0x9A, 0x65, 0x19, + 0xF2, 0x90, 0x8E, 0x5C, 0x6B, 0x69, 0xCA, 0xEA, + 0x9A, 0xE5, 0x01, 0x3A, 0xEF, 0xCB, 0x0D, 0xF6, + 0x41, 0xD4, 0x12, 0x18, 0xA4, 0xE8, 0xC6, 0x88, + 0x44, 0x90, 0x8C, 0xCF, 0x11, 0x8B, 0xFF, 0x89, + 0x0A, 0x87, 0x1F, 0x38, 0x61, 0x7C, 0x3B, 0xFB, + 0x91, 0x27, 0x9C, 0xF8, 0x8B, 0x4D, 0x51, 0x0A + }, + { + 0x39, 0x10, 0x9C, 0x59, 0x20, 0x87, 0x07, 0x4B, + 0xB9, 0x12, 0x2C, 0x25, 0x66, 0xDA, 0x59, 0x1F, + 0x2D, 0x8E, 0x65, 0x2A, 0xC2, 0xD8, 0x8F, 0x19, + 0xFF, 0xEC, 0x52, 0x9D, 0x86, 0x41, 0x6F, 0x3C, + 0xDF, 0x55, 0xF0, 0xC8, 0x07, 0xCB, 0x0F, 0xC4, + 0x39, 0x34, 0x10, 0x6D, 0x7A, 0x61, 0x48, 0x02, + 0x21, 0x0B, 0x2C, 0x7B, 0xB5, 0xCA, 0xC3, 0x93, + 0x51, 0x86, 0x34, 0x26, 0x74, 0x96, 0x12, 0xCC + }, + { + 0xDF, 0xD5, 0xB9, 0x43, 0x6D, 0x8E, 0x29, 0xA8, + 0xA8, 0x45, 0x78, 0xDF, 0xF6, 0x66, 0x66, 0xF2, + 0xD1, 0x80, 0xE5, 0x67, 0x83, 0xBB, 0x1E, 0x31, + 0xF2, 0x28, 0x63, 0x69, 0x54, 0x2F, 0xAF, 0xE4, + 0xDE, 0xEC, 0x27, 0xA2, 0x98, 0xF2, 0x9C, 0x2D, + 0xB7, 0x49, 0x08, 0x93, 0x70, 0x3D, 0x23, 0xF4, + 0xE0, 0xFD, 0x9C, 0x75, 0x24, 0x4A, 0xFA, 0x5E, + 0x8B, 0x87, 0x04, 0xB0, 0x6D, 0xC9, 0xDF, 0x98 + }, + { + 0xB5, 0x07, 0x6D, 0x05, 0x0A, 0x6C, 0x79, 0xA5, + 0xD3, 0x5D, 0x8B, 0x6B, 0xDB, 0x70, 0x58, 0xE6, + 0xB6, 0xF0, 0xA1, 0xAD, 0x5C, 0xF7, 0x1E, 0x9A, + 0xEA, 0xE9, 0x3C, 0x59, 0xD5, 0xE9, 0x0C, 0xEC, + 0x71, 0xB0, 0xC9, 0x91, 0xAA, 0x34, 0x13, 0x9A, + 0xA3, 0xC6, 0xAD, 0x81, 0x45, 0x9C, 0x1A, 0xC4, + 0x4D, 0x4F, 0xA1, 0x72, 0xC0, 0xCE, 0x2C, 0x7D, + 0x30, 0x61, 0x31, 0xEF, 0xF9, 0x57, 0x87, 0x30 + }, + { + 0x00, 0x03, 0x0B, 0xD6, 0xCF, 0x57, 0xF4, 0x90, + 0xD1, 0x09, 0xF8, 0xA2, 0xA5, 0xA7, 0x0A, 0xA3, + 0xC2, 0x6A, 0xF9, 0x6B, 0xC3, 0x80, 0x9C, 0xFB, + 0x69, 0x08, 0xDE, 0x5F, 0x1C, 0xE8, 0xB0, 0xD0, + 0xB9, 0x27, 0x54, 0x23, 0x38, 0x50, 0x95, 0xCD, + 0x84, 0xAE, 0xF0, 0x5C, 0xF7, 0x02, 0xE7, 0xB1, + 0x87, 0x74, 0x1B, 0x9C, 0x8F, 0xC9, 0x0B, 0xDE, + 0xBB, 0xE4, 0x57, 0x7B, 0x47, 0x7C, 0x82, 0x86 + }, + { + 0xC6, 0x81, 0x7F, 0x76, 0xEC, 0x04, 0x29, 0x43, + 0xA4, 0x85, 0xBD, 0xAB, 0xE1, 0x91, 0x96, 0xF4, + 0x9F, 0x08, 0x25, 0x33, 0xD9, 0xA7, 0x57, 0x64, + 0x3F, 0xAC, 0x82, 0xFD, 0xD1, 0xB8, 0xBD, 0x4A, + 0x58, 0xC5, 0x1D, 0x95, 0x57, 0x12, 0x7B, 0xB8, + 0x7B, 0x86, 0xF8, 0x0D, 0x16, 0x5B, 0x87, 0x79, + 0x95, 0xBE, 0x11, 0xB3, 0x45, 0x56, 0x7C, 0xC5, + 0x5A, 0x64, 0xFC, 0x29, 0x96, 0x95, 0x1A, 0x10 + }, + { + 0x6F, 0x39, 0xFE, 0x1C, 0x18, 0x61, 0xF4, 0x4F, + 0xB1, 0x89, 0x78, 0x3F, 0x1D, 0xDF, 0xDB, 0x22, + 0xDA, 0xAD, 0x6E, 0x24, 0xA3, 0x18, 0xE3, 0xB4, + 0x4D, 0x0C, 0x25, 0xA4, 0x1F, 0x1E, 0xCF, 0x7B, + 0x45, 0x10, 0x64, 0x22, 0xF2, 0x8F, 0x37, 0x40, + 0x72, 0x85, 0x81, 0xA1, 0x4F, 0xB7, 0x66, 0x7B, + 0x7B, 0x7E, 0xCF, 0x6B, 0x93, 0xDD, 0x1E, 0x67, + 0xFA, 0x12, 0x60, 0x8D, 0x51, 0xB5, 0x5E, 0xF1 + }, + { + 0xC1, 0xEC, 0x61, 0x1C, 0xBD, 0xB8, 0x28, 0x8B, + 0x57, 0x95, 0x4F, 0x3F, 0x56, 0xA1, 0xCC, 0x65, + 0xF3, 0x4C, 0xAC, 0xC9, 0xA1, 0x83, 0x74, 0x5C, + 0xC7, 0x32, 0x5A, 0x13, 0xCB, 0x4D, 0x42, 0x7E, + 0xC0, 0xFF, 0x0E, 0x45, 0xB5, 0xC7, 0x7E, 0x6A, + 0xB7, 0x39, 0x1E, 0xA1, 0x07, 0x4F, 0x7C, 0xD6, + 0x05, 0x09, 0x27, 0x2E, 0x51, 0x12, 0x7E, 0xBB, + 0xC1, 0xF2, 0x0E, 0x24, 0x20, 0x7E, 0x1C, 0x3D + }, + { + 0xE8, 0xB5, 0x7D, 0x0F, 0x72, 0x5D, 0x63, 0xD4, + 0x76, 0x4F, 0x0C, 0xCF, 0x88, 0x2C, 0x7D, 0xBF, + 0x54, 0x96, 0xCD, 0xC9, 0x8F, 0xB2, 0xC9, 0x19, + 0xF0, 0x01, 0x0C, 0xC2, 0x3A, 0x5E, 0x9B, 0xA4, + 0xA6, 0x4C, 0xB8, 0xE7, 0x21, 0x9E, 0x34, 0x54, + 0xB7, 0xED, 0xEC, 0x56, 0xA8, 0xA0, 0xE4, 0x6E, + 0xC9, 0x19, 0xD6, 0x1A, 0xEC, 0x5B, 0x30, 0xC7, + 0xB1, 0x4B, 0x1E, 0x93, 0x3E, 0x37, 0xA4, 0xD1 + }, + { + 0x98, 0x7B, 0xE2, 0x73, 0x11, 0x61, 0x94, 0xA3, + 0xE5, 0x48, 0xC9, 0x28, 0x11, 0xA6, 0xA9, 0xCA, + 0xF7, 0xD1, 0xAE, 0x66, 0x69, 0xEC, 0x5E, 0xA6, + 0x44, 0x69, 0x02, 0xE0, 0xDB, 0xA2, 0x2D, 0xBD, + 0xB3, 0xC7, 0xC1, 0x3F, 0x58, 0xDE, 0xBE, 0xEC, + 0xCD, 0x78, 0x73, 0xD8, 0xA4, 0xB9, 0x96, 0x67, + 0x03, 0xCF, 0x5A, 0xDE, 0x78, 0xB6, 0xF2, 0xEF, + 0xC3, 0x62, 0x7A, 0xD8, 0xAB, 0xEA, 0x76, 0xC2 + }, + { + 0x48, 0x19, 0xD2, 0x1E, 0x80, 0x0E, 0x05, 0xA6, + 0xE1, 0x3A, 0x3D, 0x5D, 0xEB, 0xC9, 0x7A, 0xF9, + 0x17, 0xB1, 0x57, 0x87, 0x3E, 0xFB, 0x7B, 0x2E, + 0x24, 0xB2, 0x2B, 0x30, 0x15, 0xF6, 0x14, 0x0C, + 0x61, 0x18, 0x18, 0x10, 0x8F, 0xF3, 0xBE, 0x6E, + 0xE0, 0x0A, 0x5A, 0x3B, 0xC7, 0xBD, 0x12, 0xD6, + 0x79, 0xA1, 0x1D, 0x06, 0x10, 0xA1, 0xE4, 0x30, + 0x4B, 0x93, 0x1E, 0x8C, 0xE9, 0xEB, 0x93, 0x20 + }, + { + 0x07, 0xA2, 0x16, 0x3F, 0xD8, 0x73, 0x05, 0x00, + 0x6F, 0x3A, 0xDF, 0xAC, 0x8F, 0x37, 0xF2, 0xE3, + 0xAF, 0x8D, 0x23, 0xEF, 0xD0, 0x13, 0x1B, 0xA7, + 0x20, 0x3A, 0xB9, 0x6C, 0x93, 0xA9, 0x0C, 0x1A, + 0x68, 0x69, 0x52, 0xDC, 0xAD, 0x2C, 0xF6, 0xF4, + 0x8F, 0x36, 0x99, 0xF4, 0xF4, 0x57, 0xD9, 0x66, + 0x37, 0xF4, 0xCE, 0x0D, 0xF9, 0x9C, 0x31, 0x30, + 0x15, 0x26, 0xD8, 0xB2, 0xED, 0x02, 0x39, 0x19 + }, + { + 0xC7, 0x83, 0x47, 0x0A, 0xBC, 0xF4, 0x7F, 0x7E, + 0x64, 0xE5, 0x91, 0x86, 0x10, 0x6A, 0xA1, 0xD3, + 0xEA, 0xEC, 0x1E, 0x0B, 0x34, 0xD8, 0x2B, 0x2E, + 0x5C, 0x23, 0xDD, 0xCD, 0xB3, 0xCE, 0xC5, 0x41, + 0xB9, 0xC4, 0xD1, 0x77, 0xD1, 0xBD, 0x36, 0xFB, + 0x40, 0x04, 0xFD, 0x8F, 0x75, 0x4E, 0xEB, 0xA7, + 0x97, 0x28, 0x50, 0x1F, 0x28, 0xB4, 0x92, 0x8E, + 0x26, 0xD7, 0xA3, 0x2D, 0x29, 0xCD, 0xF8, 0x1D + }, + { + 0x07, 0xE6, 0x2C, 0x1C, 0xD5, 0xF1, 0x47, 0x19, + 0x60, 0x58, 0xBF, 0x65, 0x5C, 0xD7, 0xF1, 0xD6, + 0x7A, 0x1C, 0xEC, 0x37, 0xD2, 0x64, 0x3D, 0x68, + 0x42, 0x7F, 0x20, 0xFF, 0xAF, 0x87, 0x8F, 0x5B, + 0xA4, 0x3E, 0x6D, 0xA1, 0x6D, 0x42, 0x13, 0x05, + 0x4E, 0x2D, 0x6C, 0x2C, 0xE6, 0x75, 0x46, 0x4F, + 0x0E, 0x8F, 0x3B, 0x2E, 0xEE, 0x33, 0xD4, 0xB5, + 0x0E, 0x96, 0x53, 0xF6, 0x6E, 0xB1, 0x0B, 0xF6 + }, + { + 0x0F, 0xA2, 0x02, 0xBB, 0x07, 0xD3, 0x94, 0xB7, + 0xE9, 0xCE, 0x2E, 0x5A, 0xD0, 0x21, 0x21, 0x26, + 0xC1, 0xBD, 0xF1, 0x0B, 0x84, 0xA5, 0xD1, 0x0B, + 0x41, 0xD3, 0x93, 0x14, 0x04, 0xDB, 0xB9, 0xD0, + 0xC8, 0xC3, 0x2C, 0xAE, 0xED, 0x40, 0xCB, 0x2A, + 0xA0, 0x51, 0x89, 0xD0, 0x2C, 0x7A, 0xE7, 0x8C, + 0xF7, 0x9C, 0xC0, 0x3A, 0xA9, 0x86, 0x26, 0x0F, + 0xF8, 0x74, 0x76, 0x71, 0x50, 0x3A, 0x5A, 0x96 + }, + { + 0x5A, 0x90, 0xD0, 0xDF, 0x75, 0x7E, 0xFE, 0x17, + 0x2B, 0xC7, 0x84, 0xCB, 0xEE, 0xA9, 0x4C, 0xFA, + 0x28, 0xE4, 0xA9, 0xCA, 0x55, 0x31, 0xFB, 0x29, + 0xEA, 0xD2, 0x38, 0xB3, 0xCD, 0x7E, 0x00, 0xBC, + 0x4A, 0x56, 0xA7, 0x96, 0x46, 0x3F, 0x8C, 0x9B, + 0x7D, 0x95, 0x81, 0x0E, 0x33, 0x33, 0x51, 0x3D, + 0x3E, 0xA1, 0x10, 0xB2, 0xD2, 0x7D, 0x5B, 0xF4, + 0x31, 0xCE, 0x85, 0x68, 0x21, 0x94, 0x8E, 0x69 + }, + { + 0x76, 0x3F, 0xD2, 0xD0, 0x1F, 0x16, 0x5A, 0xD0, + 0xAD, 0x20, 0xC3, 0x83, 0x90, 0xBE, 0x04, 0x12, + 0x37, 0xE6, 0xFA, 0x89, 0x78, 0x6D, 0x21, 0x4A, + 0x2E, 0xAD, 0x73, 0x3A, 0x9F, 0xBC, 0x5D, 0x8A, + 0x2A, 0xA4, 0x44, 0x48, 0x4E, 0x92, 0x0E, 0x50, + 0x45, 0x21, 0x68, 0xC1, 0x65, 0x48, 0xE6, 0x9E, + 0xAC, 0xF9, 0xCF, 0x28, 0x01, 0x81, 0x69, 0x3E, + 0xAA, 0x71, 0xEE, 0xBE, 0x5E, 0x1F, 0x69, 0xFD + }, + { + 0xC2, 0xE2, 0x5C, 0x6C, 0xAA, 0x92, 0xA2, 0xC3, + 0x49, 0xF7, 0xBF, 0x59, 0xF1, 0x92, 0x73, 0x9C, + 0x2A, 0x2E, 0x6C, 0xFD, 0x2F, 0x85, 0x4A, 0xDA, + 0xB3, 0x98, 0xF0, 0x1D, 0x0D, 0xD8, 0x69, 0x3E, + 0x99, 0x93, 0xEA, 0x08, 0x00, 0xEC, 0x40, 0x8F, + 0x2D, 0xE7, 0x8D, 0x5B, 0x07, 0xF4, 0x4C, 0x41, + 0x4A, 0x19, 0xA5, 0xC9, 0xC4, 0xE5, 0xCB, 0x8B, + 0x27, 0x6B, 0xBD, 0xAE, 0x07, 0xC2, 0x1E, 0x8F + }, + { + 0x2A, 0x20, 0x7F, 0x7C, 0x6D, 0x04, 0x3C, 0x15, + 0x4B, 0xA9, 0x8F, 0x1E, 0x0D, 0xAC, 0xCB, 0x79, + 0xF4, 0xC2, 0x8F, 0x34, 0x59, 0xAD, 0x1B, 0x14, + 0xA5, 0xDE, 0x74, 0xAC, 0x42, 0x21, 0x25, 0xE8, + 0x8A, 0xB0, 0xF0, 0xAA, 0x1F, 0xD7, 0x2F, 0xA5, + 0xF7, 0x2D, 0xBC, 0x7F, 0x64, 0xA9, 0xDB, 0x61, + 0x1E, 0xB3, 0x02, 0xC5, 0xCA, 0x9A, 0x32, 0xE3, + 0x32, 0x49, 0x0A, 0x97, 0x3D, 0x36, 0x07, 0x9C + }, + { + 0x27, 0x10, 0xD4, 0x77, 0x0A, 0xB7, 0x94, 0x79, + 0xEC, 0x6F, 0xB9, 0x7A, 0x18, 0x53, 0xC6, 0x2A, + 0xAD, 0x22, 0xAA, 0xD6, 0xE0, 0x4B, 0x89, 0xBB, + 0x55, 0xED, 0xB0, 0x3F, 0x55, 0x62, 0x74, 0xD5, + 0xBA, 0x24, 0x56, 0x9B, 0x59, 0x71, 0x7D, 0x63, + 0x2B, 0x35, 0x35, 0x7F, 0x30, 0x6C, 0x60, 0x27, + 0x26, 0xD0, 0x6B, 0x8F, 0xC7, 0x2E, 0x87, 0xC4, + 0xCD, 0xCD, 0xF2, 0xF2, 0x3D, 0x5F, 0x75, 0x3F + }, + { + 0x5A, 0xBF, 0xE8, 0xC2, 0x5C, 0x0E, 0x57, 0x4F, + 0xC1, 0xC4, 0x9A, 0xD2, 0x78, 0xCB, 0x4C, 0x56, + 0xEA, 0xD5, 0x6E, 0x79, 0xD8, 0xFE, 0x18, 0xD4, + 0x24, 0xC8, 0x0D, 0x99, 0x16, 0xFF, 0x7D, 0xDB, + 0x21, 0x2B, 0xC8, 0xC9, 0x81, 0xBF, 0x97, 0x6A, + 0xEC, 0x6B, 0x6A, 0xCE, 0x61, 0x47, 0xA6, 0xBC, + 0xBB, 0x1A, 0x63, 0xA7, 0xAA, 0x4E, 0xE5, 0xE0, + 0x7C, 0x5E, 0xE1, 0xAC, 0xE9, 0xAF, 0xF2, 0xF7 + }, + { + 0xD5, 0x20, 0x52, 0x82, 0x3C, 0x9B, 0xB4, 0x42, + 0x51, 0xCF, 0x4B, 0x29, 0xBE, 0x82, 0x98, 0x09, + 0xB5, 0x31, 0xC3, 0xA0, 0x9A, 0xE7, 0x2A, 0x5C, + 0x08, 0xE9, 0x4B, 0x09, 0xB5, 0xEC, 0x04, 0x57, + 0x8A, 0x82, 0xB9, 0x6A, 0xBA, 0x99, 0xC9, 0xD6, + 0xA6, 0x05, 0x89, 0x6B, 0x75, 0x01, 0x26, 0x84, + 0x2E, 0x11, 0xAD, 0x7D, 0x4E, 0x55, 0x3A, 0x59, + 0x64, 0x98, 0xCC, 0x1E, 0x62, 0x91, 0x95, 0xB0 + }, + { + 0xC4, 0x3D, 0x25, 0xAA, 0x47, 0xB6, 0x98, 0x65, + 0x9E, 0x13, 0x73, 0xF9, 0xF3, 0xC7, 0xF9, 0xC2, + 0xF7, 0x2C, 0x83, 0xD2, 0x98, 0x58, 0xBE, 0xF5, + 0x21, 0xEA, 0x24, 0x71, 0x68, 0x0E, 0x99, 0xC7, + 0x05, 0x17, 0xA3, 0xDF, 0x7E, 0xBA, 0xE2, 0xAF, + 0xDD, 0x0B, 0x74, 0x76, 0x93, 0x4E, 0xF5, 0x73, + 0xEF, 0x04, 0x1F, 0x8C, 0x04, 0x21, 0x0E, 0xC9, + 0x93, 0x3C, 0x4B, 0x18, 0xEF, 0x81, 0x1A, 0x99 + }, + { + 0x61, 0xE8, 0x6E, 0x85, 0x01, 0xDE, 0x33, 0xEB, + 0x6D, 0x0B, 0x39, 0x44, 0x47, 0x27, 0xDA, 0xEE, + 0x29, 0x7D, 0x8D, 0x26, 0x8A, 0xEB, 0x2B, 0x15, + 0x64, 0x81, 0x8D, 0xEB, 0x43, 0x34, 0xD8, 0xFA, + 0x84, 0xA3, 0x4A, 0xD3, 0x47, 0xA5, 0xBD, 0x7B, + 0xBA, 0xD2, 0x1F, 0x71, 0x18, 0xDE, 0x22, 0xB2, + 0x67, 0xF3, 0xB1, 0x47, 0xB6, 0x33, 0x53, 0xBE, + 0xA5, 0xCA, 0xCF, 0x1D, 0x32, 0x15, 0xF3, 0xFB + }, + { + 0x7A, 0x0D, 0x2E, 0x7E, 0xFE, 0xF8, 0xFC, 0x21, + 0x9F, 0xDC, 0xD1, 0x8E, 0xBD, 0xDC, 0x94, 0xE2, + 0x3D, 0x6B, 0xB2, 0x3A, 0x71, 0xBD, 0x54, 0x67, + 0x35, 0x67, 0x61, 0x75, 0xEA, 0x48, 0x23, 0x17, + 0x3E, 0xCD, 0x82, 0x32, 0x1F, 0xD9, 0x0C, 0x60, + 0x8F, 0x57, 0xC7, 0xE5, 0xB4, 0xBA, 0x59, 0x75, + 0xFB, 0x71, 0xA1, 0x14, 0xEF, 0x39, 0xC4, 0xC5, + 0x2C, 0xCC, 0x0C, 0x5A, 0x3D, 0xBF, 0x44, 0x99 + }, + { + 0xAE, 0xB2, 0x53, 0x8D, 0x70, 0x2E, 0x22, 0xF4, + 0xDE, 0x44, 0x2B, 0x61, 0x3C, 0xDC, 0x19, 0x3C, + 0x42, 0x43, 0x9F, 0x91, 0xB1, 0xF4, 0xB0, 0xE0, + 0xEA, 0xFA, 0x95, 0xD4, 0x2D, 0x6F, 0xBC, 0x79, + 0x00, 0xB4, 0x46, 0x96, 0xD3, 0xAA, 0xE6, 0x7D, + 0x21, 0x26, 0x3F, 0x83, 0xE2, 0x00, 0x9B, 0x3D, + 0xE7, 0x4C, 0xF7, 0x14, 0x93, 0x19, 0x65, 0xE8, + 0x37, 0x5C, 0xE4, 0xC9, 0x1D, 0xBA, 0xBA, 0x05 + }, + { + 0xA7, 0x9C, 0xA2, 0x27, 0x37, 0xD2, 0x48, 0x4A, + 0x5D, 0x63, 0xDC, 0x00, 0xD8, 0x9F, 0x6B, 0xBE, + 0x9C, 0x45, 0x19, 0x6F, 0xD1, 0x6C, 0x5E, 0xF2, + 0x6F, 0x26, 0x40, 0xC7, 0xAD, 0x97, 0x01, 0x80, + 0x63, 0x13, 0x20, 0xDB, 0xD9, 0x8A, 0xFC, 0x5C, + 0x45, 0x12, 0x53, 0x1A, 0x2D, 0xBA, 0xB8, 0x1C, + 0xA2, 0xAF, 0xC8, 0x67, 0xCF, 0xE1, 0x05, 0x72, + 0xDB, 0x0B, 0x90, 0xCA, 0xF3, 0xC6, 0x31, 0x0C + }, + { + 0x87, 0x18, 0xAB, 0x2D, 0x95, 0x00, 0xBA, 0x38, + 0xCA, 0xEF, 0xA9, 0x9E, 0xCC, 0xE7, 0xD3, 0x98, + 0x4B, 0xB3, 0xAC, 0x86, 0x91, 0xAC, 0xF6, 0xFD, + 0x7B, 0x1C, 0x4C, 0x0B, 0xC1, 0x02, 0x4C, 0x54, + 0xB6, 0x14, 0x85, 0xF6, 0x4C, 0x9C, 0x9E, 0x36, + 0x9B, 0x0D, 0x62, 0xED, 0xE2, 0x98, 0x47, 0xC2, + 0xC2, 0x74, 0xF5, 0x38, 0x0D, 0x32, 0x43, 0xD1, + 0xF4, 0x01, 0x10, 0x27, 0x6A, 0xF5, 0x4A, 0x65 + }, + { + 0xC9, 0x47, 0x83, 0xE5, 0x15, 0x11, 0x54, 0x84, + 0x04, 0xD6, 0xD7, 0x33, 0x72, 0x01, 0xF8, 0xB2, + 0xBD, 0x40, 0x61, 0x3C, 0x2B, 0x97, 0xCF, 0xE0, + 0x0D, 0x74, 0x21, 0x85, 0x8E, 0x9B, 0x27, 0x4B, + 0x08, 0x04, 0xE2, 0xFD, 0x54, 0x30, 0x81, 0x51, + 0x47, 0x4A, 0xB0, 0xF6, 0x79, 0xAE, 0x1A, 0xF7, + 0x50, 0x3A, 0x42, 0x9A, 0xE3, 0x6C, 0xF0, 0xDA, + 0x57, 0x77, 0x70, 0x3F, 0xCB, 0x8B, 0xF7, 0x3B + }, + { + 0xC1, 0x40, 0x31, 0x27, 0x23, 0x48, 0x12, 0x9A, + 0x32, 0x68, 0x79, 0x96, 0xE2, 0x49, 0x3B, 0x46, + 0xFF, 0x49, 0x1B, 0xEC, 0xE8, 0xC9, 0x31, 0x7B, + 0x7C, 0x41, 0xB1, 0xD2, 0xD7, 0xC7, 0xDB, 0xD9, + 0xDD, 0x40, 0xF0, 0x24, 0x30, 0x37, 0x39, 0x30, + 0x75, 0x28, 0xC6, 0x05, 0x9B, 0xC2, 0x35, 0x90, + 0x9B, 0x5D, 0x29, 0xB8, 0x8E, 0xD5, 0x69, 0x72, + 0xB1, 0xA3, 0xDE, 0x9B, 0x51, 0x1A, 0xEB, 0x17 + }, + { + 0x00, 0x03, 0xA1, 0xF8, 0x5E, 0x02, 0x5B, 0x42, + 0x47, 0x47, 0xA6, 0x85, 0xAB, 0xFA, 0xF0, 0x5D, + 0xF7, 0x95, 0xDD, 0xF4, 0xBE, 0xAE, 0x77, 0xE6, + 0xB1, 0xE5, 0xFF, 0xB6, 0xCF, 0x5C, 0x4D, 0x87, + 0x32, 0xAD, 0x54, 0x66, 0x6E, 0xE3, 0x8E, 0x9F, + 0xE8, 0x54, 0xC8, 0x5A, 0xFC, 0xC7, 0xFD, 0x59, + 0x7A, 0x09, 0x26, 0xCC, 0xB6, 0x74, 0xB5, 0x29, + 0x11, 0x2F, 0x95, 0xBF, 0x7B, 0xDC, 0xB3, 0xFD + }, + { + 0xBE, 0x62, 0xB1, 0x06, 0x24, 0x2D, 0x3B, 0x8A, + 0xC8, 0x54, 0x2A, 0xD8, 0xC9, 0xE9, 0x7D, 0x7D, + 0x58, 0xA4, 0x68, 0xBB, 0xEE, 0xBB, 0x3B, 0xE7, + 0xFF, 0x05, 0x99, 0x34, 0x4B, 0x07, 0x17, 0x2A, + 0xAC, 0xFE, 0xA9, 0x7C, 0xF6, 0x88, 0x2E, 0x14, + 0x06, 0xF7, 0xCD, 0xFF, 0x36, 0x72, 0x92, 0x89, + 0x9F, 0x05, 0x9E, 0xF4, 0xB1, 0x14, 0xC1, 0x6B, + 0xE3, 0x2B, 0x2D, 0xF5, 0xB5, 0x4D, 0x99, 0xE3 + }, + { + 0x3B, 0xCB, 0x01, 0xCC, 0xCB, 0xAB, 0xED, 0xF5, + 0x17, 0x0E, 0x01, 0xE4, 0xE0, 0xD7, 0x2F, 0x23, + 0xF0, 0x10, 0xD9, 0x0B, 0xC0, 0x76, 0x54, 0xDB, + 0x2E, 0x68, 0x00, 0xC2, 0xB4, 0xB5, 0x53, 0xDC, + 0xF4, 0x20, 0xCB, 0x0D, 0x20, 0xE0, 0x62, 0xFC, + 0x53, 0xC7, 0x17, 0xD9, 0x69, 0x1F, 0x6F, 0xF7, + 0xA3, 0x8A, 0xDC, 0x48, 0x29, 0xC9, 0xEE, 0x89, + 0xF5, 0x61, 0xE6, 0x96, 0x5B, 0x17, 0x18, 0x26 + }, + { + 0xC2, 0x6F, 0x40, 0xAE, 0x0D, 0x28, 0x59, 0x93, + 0x94, 0x90, 0xE7, 0xC0, 0xC2, 0xFC, 0xD8, 0xC3, + 0x0E, 0xAD, 0x13, 0xD2, 0x07, 0x1B, 0x29, 0x84, + 0x56, 0x99, 0x44, 0xA5, 0xEF, 0xEB, 0xBE, 0xA3, + 0xAF, 0x9A, 0xB5, 0xDB, 0xE5, 0xF4, 0x4D, 0x88, + 0x04, 0x5B, 0x9A, 0x54, 0x1F, 0x2C, 0x26, 0x06, + 0x98, 0x76, 0x04, 0xFA, 0xCA, 0x3A, 0x0E, 0x55, + 0xD6, 0x86, 0xD4, 0x17, 0x63, 0x9F, 0x99, 0x3D + }, + { + 0x6F, 0xAF, 0xCF, 0x4E, 0x62, 0x77, 0xC6, 0x8B, + 0xAB, 0x28, 0xD4, 0x55, 0x8C, 0x3B, 0xD6, 0x8C, + 0x97, 0xF0, 0x8C, 0x6F, 0x8D, 0xC4, 0x6C, 0xFC, + 0x02, 0xEA, 0xB6, 0x7B, 0x09, 0x96, 0x2E, 0x4B, + 0x08, 0x51, 0xB3, 0x24, 0x97, 0x1B, 0x26, 0x77, + 0xBA, 0xCB, 0x33, 0x18, 0xC3, 0x69, 0x9D, 0x9A, + 0xDA, 0x11, 0xD7, 0xF3, 0x0B, 0xB7, 0x6F, 0x63, + 0x23, 0xA0, 0x95, 0xEA, 0x2C, 0xE5, 0xBF, 0x52 + }, + { + 0xB0, 0x2B, 0x3D, 0x58, 0x4B, 0xA1, 0xA3, 0x5F, + 0x1C, 0x57, 0xA2, 0xDD, 0xCE, 0x1C, 0x8A, 0xF4, + 0xDA, 0x43, 0x15, 0xCF, 0x47, 0x11, 0x30, 0x94, + 0xC7, 0xFE, 0x97, 0x0C, 0x15, 0xCE, 0xCA, 0x31, + 0x53, 0xCA, 0x1B, 0x05, 0x17, 0x2B, 0x7D, 0xD7, + 0xDF, 0x92, 0x48, 0x53, 0x97, 0xB4, 0xD8, 0xA0, + 0x31, 0xBD, 0x97, 0xF2, 0x35, 0x7F, 0x4D, 0x75, + 0xC1, 0x4F, 0x55, 0x03, 0xAD, 0x71, 0x00, 0xBD + }, + { + 0x99, 0x59, 0x09, 0x45, 0x1A, 0x5B, 0xD1, 0x31, + 0xFC, 0x83, 0xFF, 0x29, 0x70, 0x00, 0xDF, 0x76, + 0x1E, 0x3F, 0x7C, 0xAD, 0x42, 0xAA, 0x9E, 0xDD, + 0x88, 0x22, 0x73, 0x56, 0xF1, 0x36, 0x7F, 0xE6, + 0xC4, 0x8B, 0xE0, 0x22, 0xB8, 0x87, 0x35, 0x8C, + 0x29, 0xB9, 0x99, 0x5F, 0x73, 0x76, 0xD6, 0x35, + 0xE6, 0x96, 0xD4, 0x90, 0x19, 0xAE, 0x8A, 0xB1, + 0xDB, 0xE8, 0x2E, 0x72, 0xAA, 0x72, 0x64, 0x77 + }, + { + 0x64, 0x3E, 0xF5, 0x1E, 0xE5, 0xC8, 0xDE, 0x98, + 0x26, 0xD6, 0x50, 0x42, 0xF5, 0xCF, 0x09, 0x4E, + 0x2F, 0x72, 0x98, 0x5B, 0x22, 0xEA, 0x7D, 0x3B, + 0x2E, 0x21, 0x90, 0x99, 0x9B, 0x68, 0x3D, 0x61, + 0x22, 0xB2, 0xA9, 0x7B, 0xD1, 0x62, 0x38, 0xE1, + 0x4A, 0x3D, 0xBE, 0xE0, 0x76, 0xBD, 0x57, 0x61, + 0xF6, 0xBA, 0x44, 0x85, 0x0B, 0x8D, 0x89, 0x97, + 0x3D, 0xB7, 0x56, 0x6D, 0x34, 0xBC, 0x90, 0xAD + }, + { + 0xEC, 0x79, 0xD1, 0xE9, 0xD6, 0x9F, 0x47, 0xA9, + 0xF4, 0x1F, 0xD3, 0x9A, 0x2E, 0xD3, 0x77, 0xB0, + 0x71, 0xBF, 0x7A, 0x1D, 0x2D, 0x7D, 0xA7, 0xB7, + 0xE8, 0x56, 0x89, 0x62, 0xB8, 0x81, 0x45, 0x6E, + 0xDE, 0x3F, 0xB9, 0x36, 0x1A, 0xA5, 0x43, 0x26, + 0x19, 0x8D, 0x8E, 0xE1, 0x5F, 0x72, 0x03, 0xE0, + 0x62, 0x54, 0x1C, 0xDE, 0x55, 0x2C, 0x07, 0x1A, + 0x9C, 0x61, 0xF7, 0xA2, 0x0D, 0x0B, 0xB2, 0xB4 + }, + { + 0x64, 0xFC, 0x02, 0x28, 0x61, 0xA9, 0x7D, 0xA3, + 0x42, 0xB9, 0xD7, 0x3A, 0xF0, 0x2B, 0x8A, 0xA0, + 0xF0, 0x02, 0xD8, 0x0E, 0x24, 0x65, 0x96, 0xA0, + 0xFD, 0x48, 0x0E, 0x03, 0x84, 0x84, 0x35, 0xF3, + 0xC9, 0x46, 0xEE, 0x7F, 0xB6, 0xD3, 0x2F, 0x7E, + 0x72, 0xE2, 0x72, 0xC1, 0xF4, 0xC3, 0x61, 0xA3, + 0x87, 0x8C, 0x38, 0x95, 0xDC, 0x21, 0xD5, 0x6F, + 0x35, 0x53, 0x17, 0x41, 0x80, 0x22, 0xF8, 0x2E + }, + { + 0x23, 0x37, 0xF5, 0x95, 0x3C, 0xBA, 0x46, 0x53, + 0x24, 0x93, 0x66, 0x8D, 0x34, 0x99, 0x8A, 0x06, + 0xDC, 0x8F, 0x1A, 0xF3, 0x9E, 0xCC, 0xB2, 0x30, + 0x52, 0x0E, 0x51, 0x20, 0x48, 0xDF, 0x34, 0x02, + 0x98, 0x69, 0xFB, 0xCB, 0x02, 0x08, 0x79, 0xAF, + 0x5A, 0xCA, 0xFC, 0xC7, 0x93, 0x1C, 0xAA, 0xE6, + 0x94, 0x1A, 0x76, 0xF9, 0xA1, 0xA9, 0xFD, 0x14, + 0x93, 0x38, 0x41, 0x51, 0xD5, 0xAE, 0x4A, 0x18 + }, + { + 0xC5, 0x87, 0x87, 0x0C, 0xFD, 0x32, 0xC3, 0x00, + 0x38, 0x9D, 0x0A, 0x52, 0xEF, 0x79, 0xE8, 0xA5, + 0x49, 0x43, 0x3B, 0xC4, 0x9A, 0xA9, 0x91, 0xE7, + 0x34, 0xB2, 0x58, 0xA6, 0xF8, 0xAB, 0xEB, 0x47, + 0xD8, 0xAA, 0x0C, 0xF7, 0x20, 0x6B, 0x34, 0xB5, + 0x15, 0x08, 0x00, 0x58, 0x73, 0x08, 0xD3, 0x56, + 0x73, 0xD2, 0x2A, 0x5E, 0x94, 0x00, 0x91, 0xED, + 0x37, 0x4E, 0x53, 0x6E, 0x16, 0x0D, 0x3A, 0x4E + }, + { + 0x0E, 0xC4, 0x40, 0x5F, 0x59, 0xA8, 0x6F, 0xB4, + 0x20, 0x2A, 0xC2, 0xAF, 0x73, 0x6B, 0x39, 0xD2, + 0x71, 0xD8, 0xEF, 0x6F, 0xE2, 0x22, 0xA0, 0x35, + 0x30, 0x7A, 0x4A, 0x59, 0xA3, 0x58, 0x2F, 0xBD, + 0x70, 0xEB, 0x92, 0x60, 0xB7, 0xA5, 0x08, 0xD5, + 0x73, 0xFB, 0xAA, 0x26, 0x60, 0x05, 0x86, 0x99, + 0x5E, 0xAF, 0xDF, 0xB7, 0x36, 0x75, 0xF4, 0x89, + 0xDC, 0xE4, 0xAD, 0x05, 0x00, 0x1E, 0xFE, 0xBC + }, + { + 0xC8, 0xA1, 0x29, 0x58, 0xEA, 0x50, 0x0D, 0xE2, + 0x26, 0x98, 0x15, 0xC0, 0x65, 0xEE, 0xC0, 0x51, + 0xF2, 0x34, 0x6D, 0xB3, 0x5C, 0x35, 0xF4, 0xD1, + 0x42, 0x29, 0x64, 0x5F, 0xFC, 0xC7, 0x9F, 0x57, + 0x4C, 0xB8, 0x00, 0x35, 0x35, 0x5E, 0xB5, 0xC1, + 0xF3, 0x87, 0xF1, 0xF0, 0xB6, 0xA7, 0x09, 0x71, + 0x93, 0xE9, 0x7C, 0x61, 0xC3, 0xAA, 0xD6, 0x32, + 0xA0, 0xB1, 0x63, 0x05, 0x5D, 0x9C, 0xBD, 0x4C + }, + { + 0x99, 0x38, 0x67, 0x28, 0xA0, 0x43, 0xDF, 0xA6, + 0x96, 0x89, 0x59, 0x20, 0x8C, 0x0D, 0x14, 0x23, + 0xBE, 0x16, 0x0B, 0x11, 0x17, 0xFD, 0x76, 0x9F, + 0x54, 0x73, 0xAB, 0x99, 0xBA, 0x29, 0x0A, 0x04, + 0x09, 0xF2, 0x03, 0x7F, 0x10, 0xF2, 0xCF, 0x1B, + 0x77, 0x22, 0x94, 0xF9, 0x37, 0x36, 0xDE, 0xA0, + 0xDB, 0xA6, 0x05, 0xC6, 0xF0, 0xC8, 0xD9, 0x3D, + 0x49, 0xF7, 0x17, 0x37, 0xDD, 0x18, 0x5B, 0x86 + }, + { + 0x68, 0x48, 0xA1, 0x66, 0x3C, 0x05, 0xB0, 0xFC, + 0x62, 0xBE, 0x17, 0x95, 0x32, 0xAC, 0x1E, 0x87, + 0xFA, 0x34, 0xBC, 0xD0, 0xA9, 0x53, 0xBA, 0xA6, + 0x99, 0xA0, 0x6E, 0x09, 0x8C, 0x99, 0x99, 0x09, + 0x1D, 0x31, 0x02, 0x92, 0x95, 0x62, 0x8C, 0x75, + 0xCB, 0x7A, 0x9F, 0xCD, 0x0F, 0x1B, 0x79, 0xEF, + 0x78, 0x29, 0xE7, 0x0E, 0xC5, 0xFD, 0x75, 0xDF, + 0x80, 0x22, 0xF3, 0x7B, 0x91, 0x80, 0x73, 0x86 + }, + { + 0x87, 0xEB, 0x1B, 0x86, 0x35, 0x31, 0xCE, 0xC8, + 0xDC, 0x16, 0x99, 0xE4, 0xDA, 0xD1, 0x7C, 0xCF, + 0x8A, 0x15, 0xA4, 0x67, 0xA6, 0x01, 0x74, 0x91, + 0x46, 0x85, 0x4F, 0xF1, 0x21, 0xF7, 0x05, 0xFF, + 0xBC, 0x2C, 0x61, 0x8B, 0x32, 0x0A, 0xAF, 0x59, + 0xD8, 0xF6, 0xF5, 0x40, 0x18, 0x09, 0x64, 0x85, + 0x92, 0x46, 0x80, 0x29, 0xA1, 0x63, 0x64, 0x0F, + 0x0F, 0x2C, 0x39, 0xB5, 0xC9, 0x11, 0x19, 0xFD + }, + { + 0x8A, 0x3A, 0xEA, 0x4C, 0xCB, 0xCE, 0x0B, 0xC0, + 0xDF, 0x66, 0xBA, 0x44, 0xAB, 0xE7, 0x45, 0x4E, + 0xDB, 0x48, 0xBC, 0x3F, 0x40, 0x7D, 0x87, 0x51, + 0x77, 0xDB, 0x76, 0x4A, 0x0C, 0xFB, 0x08, 0x23, + 0x47, 0x53, 0xD3, 0x40, 0x30, 0x76, 0xC1, 0x9D, + 0x4A, 0x64, 0x0F, 0x57, 0x68, 0x61, 0x9C, 0x37, + 0x06, 0x1B, 0x93, 0x76, 0x51, 0x65, 0xEC, 0x7B, + 0x56, 0x5C, 0x34, 0xDF, 0x5C, 0x19, 0xA2, 0xA5 + }, + { + 0x91, 0x71, 0x66, 0x90, 0x11, 0x4F, 0x45, 0xA7, + 0x78, 0x8C, 0xBA, 0xFA, 0x7F, 0x57, 0xD3, 0x88, + 0x58, 0x99, 0x82, 0xB0, 0x13, 0xB4, 0x02, 0xBC, + 0x0D, 0xF6, 0x67, 0x27, 0x97, 0x6F, 0x2A, 0x68, + 0xE1, 0x15, 0x17, 0x4F, 0x3D, 0x1D, 0x08, 0x7F, + 0x48, 0x6D, 0x95, 0x15, 0x91, 0xF4, 0xE0, 0x3E, + 0x93, 0xE9, 0x17, 0x09, 0x26, 0xEC, 0x94, 0x42, + 0x2F, 0x84, 0x35, 0xFC, 0x2F, 0xDF, 0xA7, 0x9D + }, + { + 0x41, 0x77, 0x29, 0xB9, 0xC1, 0x2A, 0xE1, 0xBB, + 0xDB, 0x53, 0xAD, 0xD6, 0x93, 0x1A, 0xFA, 0x2A, + 0x02, 0x9E, 0x49, 0xAF, 0xCE, 0x76, 0xAA, 0x8B, + 0xB3, 0x19, 0x80, 0xB8, 0xB3, 0x0A, 0xB7, 0x45, + 0x80, 0x05, 0xCA, 0xC6, 0x0B, 0x63, 0xCC, 0xA1, + 0x7D, 0x27, 0x66, 0xF9, 0x9D, 0xDC, 0xC7, 0x37, + 0xA2, 0xC4, 0xBA, 0x88, 0xA8, 0xED, 0x32, 0x08, + 0x0C, 0x67, 0x6A, 0x20, 0xDF, 0xAC, 0xF6, 0x78 + }, + { + 0x82, 0x9D, 0x59, 0x3D, 0x71, 0x12, 0x97, 0x80, + 0x1D, 0x48, 0xEB, 0x09, 0x2E, 0x68, 0x98, 0x1F, + 0x71, 0x01, 0x60, 0xB4, 0x12, 0x34, 0xD9, 0x47, + 0xBC, 0x4E, 0x7B, 0xCA, 0x91, 0xB0, 0xB3, 0x59, + 0x12, 0xA4, 0xA4, 0x4E, 0x06, 0xD4, 0xCD, 0x86, + 0x72, 0x3D, 0x34, 0x2F, 0x35, 0x41, 0x45, 0x17, + 0x24, 0xEC, 0xD0, 0xC3, 0xAC, 0x20, 0x6A, 0x0A, + 0x90, 0xAC, 0x2F, 0xA8, 0xC7, 0x26, 0xDD, 0x77 + }, + { + 0xF8, 0x88, 0x60, 0x0D, 0x6E, 0x82, 0xD2, 0x07, + 0xB8, 0xB9, 0x4B, 0x6B, 0x3B, 0x14, 0x26, 0x22, + 0xCB, 0x00, 0x79, 0xA0, 0xCA, 0xDB, 0x8A, 0x07, + 0x97, 0x9B, 0x1C, 0xE1, 0xA1, 0x0D, 0x3E, 0xC3, + 0x1E, 0x18, 0xF9, 0x81, 0x2C, 0x14, 0x38, 0xAF, + 0x0D, 0xEE, 0x2D, 0x5D, 0x6E, 0x97, 0x6E, 0x7F, + 0x13, 0x97, 0x9E, 0x42, 0x89, 0x3D, 0xB0, 0x65, + 0x41, 0x39, 0x53, 0xD3, 0x1F, 0x31, 0x0F, 0x5F + }, + { + 0x7C, 0x24, 0x12, 0x47, 0xE9, 0x42, 0x87, 0x84, + 0xFE, 0x17, 0x1E, 0x85, 0xF4, 0x6B, 0x5F, 0x1B, + 0xC6, 0xDF, 0x2E, 0x42, 0x99, 0x53, 0x2B, 0xC3, + 0xCE, 0xFF, 0xD8, 0x22, 0xA3, 0xAE, 0x5C, 0x0D, + 0x96, 0xD4, 0x8D, 0x49, 0x1F, 0x3C, 0x83, 0x79, + 0xE9, 0x07, 0x0F, 0xD2, 0x89, 0x2D, 0xBD, 0x27, + 0xD1, 0x56, 0x46, 0xF0, 0xD2, 0xDF, 0x09, 0x4A, + 0xFD, 0x50, 0xB5, 0xA2, 0xEE, 0xA0, 0x24, 0xEA + }, + { + 0x42, 0x1D, 0x7D, 0xBF, 0x7A, 0x9F, 0x2F, 0x5B, + 0x1D, 0x03, 0xA4, 0x21, 0x93, 0xAD, 0x41, 0xED, + 0x87, 0x09, 0xE1, 0x14, 0x10, 0x5C, 0x58, 0x35, + 0xC1, 0xF5, 0x82, 0xBA, 0xF2, 0x43, 0xA0, 0xD7, + 0x78, 0xC6, 0x11, 0x7E, 0x5E, 0xE5, 0x94, 0x3E, + 0x01, 0xAD, 0xDC, 0x9B, 0xC7, 0x85, 0x7A, 0xFB, + 0x7C, 0xA0, 0xA6, 0x04, 0x20, 0x61, 0xEA, 0xD8, + 0x7F, 0xC6, 0x17, 0xD7, 0x9D, 0x18, 0xE6, 0x36 + }, + { + 0xBC, 0x35, 0x9F, 0x17, 0x6F, 0x8C, 0x2A, 0x89, + 0xD2, 0xD4, 0x7E, 0x7B, 0x84, 0x62, 0x78, 0x82, + 0x96, 0x66, 0x67, 0xF3, 0xB3, 0x15, 0xDE, 0x0B, + 0xCF, 0xEF, 0xEA, 0xEA, 0x74, 0xAC, 0xBA, 0xDD, + 0x64, 0x01, 0x0C, 0xA4, 0x59, 0x6C, 0x7C, 0x74, + 0xAF, 0x61, 0x89, 0x0D, 0x51, 0x38, 0x31, 0x8C, + 0x2B, 0x32, 0x5F, 0x75, 0x22, 0xDD, 0x5D, 0x70, + 0x2B, 0x32, 0xD3, 0x94, 0xE5, 0x15, 0xF8, 0x05 + }, + { + 0x36, 0x74, 0x2B, 0xF8, 0xF6, 0x88, 0x30, 0x57, + 0x34, 0x97, 0xF7, 0xAC, 0x1B, 0xF9, 0x3B, 0xD1, + 0x4D, 0x75, 0xC5, 0x17, 0x38, 0xD7, 0x87, 0x96, + 0x61, 0xA4, 0x7F, 0x7F, 0x27, 0xF1, 0x7E, 0x7F, + 0x06, 0xE7, 0x8C, 0x0B, 0xFA, 0x3C, 0x25, 0x79, + 0xF6, 0x5E, 0x28, 0xBD, 0xCD, 0x0B, 0x45, 0x9B, + 0x53, 0x72, 0x2D, 0xA0, 0x11, 0x20, 0x7D, 0x23, + 0xBF, 0xB9, 0x56, 0xF9, 0x68, 0xDA, 0x28, 0x7F + }, + { + 0x23, 0x00, 0x05, 0x65, 0xF5, 0x08, 0x8D, 0x41, + 0x2E, 0x2C, 0x59, 0xA7, 0xBC, 0x3C, 0xC6, 0x40, + 0x2E, 0xBD, 0xBF, 0xE7, 0x6C, 0x3C, 0xCE, 0x89, + 0xA0, 0xB2, 0xC6, 0x45, 0x3A, 0xB2, 0x85, 0x6D, + 0xDC, 0x19, 0x21, 0x7D, 0x21, 0x13, 0x69, 0x47, + 0x79, 0x42, 0xDA, 0xD3, 0xF5, 0x5B, 0xE7, 0x3D, + 0x56, 0xA8, 0x83, 0xBB, 0x79, 0xEA, 0x14, 0x7D, + 0xED, 0xCC, 0x4C, 0xB6, 0x75, 0xB3, 0x40, 0xBC + }, + { + 0xD9, 0x50, 0x41, 0x0F, 0x38, 0x6B, 0x80, 0x1A, + 0xE6, 0x1B, 0x73, 0x1A, 0xE9, 0xA6, 0x2A, 0xB9, + 0x7E, 0x82, 0x4C, 0x8E, 0x55, 0xD4, 0x84, 0xD8, + 0x9B, 0xD4, 0x27, 0x4E, 0xAE, 0x3A, 0x2F, 0x57, + 0x13, 0xE7, 0x7C, 0xEC, 0x4F, 0x6C, 0xDA, 0xCB, + 0x65, 0x38, 0xB0, 0x39, 0xE7, 0xE3, 0x30, 0xA5, + 0x4B, 0x89, 0x19, 0xEC, 0x9E, 0x08, 0xF6, 0x27, + 0x5B, 0x69, 0xE0, 0x7C, 0x24, 0xE2, 0x39, 0xD9 + }, + { + 0xCE, 0x58, 0xBE, 0x41, 0x00, 0x37, 0xC4, 0xB3, + 0xF8, 0x9A, 0x42, 0xFE, 0x50, 0x23, 0xF6, 0x6D, + 0x55, 0x43, 0x31, 0xEF, 0xFF, 0x44, 0x9B, 0x28, + 0x78, 0x31, 0xA3, 0xCC, 0xF8, 0x7B, 0x23, 0xB4, + 0xEA, 0xB7, 0xAC, 0xB2, 0xFE, 0x99, 0x8F, 0x60, + 0x44, 0x36, 0x2C, 0x72, 0xDD, 0xC9, 0x04, 0x7A, + 0x40, 0x50, 0x3E, 0x43, 0x46, 0x57, 0x53, 0xA6, + 0xEA, 0x39, 0x4D, 0x2F, 0xF1, 0x54, 0x03, 0xC9 + }, + { + 0xD5, 0x06, 0x05, 0xF0, 0xE2, 0x1A, 0x0B, 0x12, + 0x9D, 0xA0, 0xA2, 0x9B, 0x93, 0x06, 0x2B, 0xD2, + 0x13, 0xA3, 0x52, 0x41, 0xCE, 0x89, 0xB6, 0xEC, + 0xEA, 0xB3, 0x3B, 0x72, 0x27, 0x6E, 0x3D, 0x45, + 0xFB, 0x3E, 0x78, 0xD5, 0xDE, 0x72, 0xBD, 0x4C, + 0x8C, 0x0D, 0xF7, 0xCD, 0xB9, 0x8A, 0xC1, 0x43, + 0x2D, 0x87, 0xA7, 0xA5, 0x4D, 0xF0, 0x98, 0xC6, + 0xB1, 0xF0, 0x89, 0x9A, 0x75, 0xA3, 0x6F, 0x25 + }, + { + 0x33, 0xEC, 0xBA, 0x84, 0x3F, 0xDC, 0x90, 0x4F, + 0x1D, 0xF9, 0x56, 0xC5, 0x18, 0x61, 0x9A, 0x5F, + 0xBB, 0x42, 0x0B, 0xA2, 0xAE, 0x5F, 0x44, 0xF3, + 0xDA, 0x77, 0xA9, 0x3E, 0x34, 0x32, 0x74, 0x59, + 0x8F, 0x4D, 0x96, 0x4B, 0x8C, 0xBD, 0x03, 0x9C, + 0x28, 0xD4, 0x4A, 0x76, 0x11, 0x4E, 0x83, 0x5A, + 0x39, 0x65, 0xB7, 0x96, 0x27, 0xF1, 0xBF, 0x68, + 0xE0, 0x8C, 0x68, 0x70, 0xDE, 0x3C, 0xD3, 0x92 + }, + { + 0x6F, 0xD0, 0xEF, 0xC5, 0x31, 0xDB, 0x87, 0x65, + 0x37, 0x31, 0x36, 0xF0, 0x8C, 0x4E, 0xE5, 0x03, + 0x25, 0x7E, 0x52, 0x9E, 0xAC, 0xCA, 0xF9, 0x80, + 0xE3, 0x3F, 0x83, 0xBE, 0xFF, 0x8B, 0x02, 0xC9, + 0x84, 0x01, 0x5B, 0x85, 0x49, 0x7A, 0xA4, 0x3A, + 0x5A, 0x8D, 0xBB, 0x71, 0xB9, 0x76, 0x75, 0x74, + 0xB8, 0xFB, 0xDC, 0xF4, 0xB5, 0xC5, 0xDF, 0xFB, + 0x74, 0x54, 0xD8, 0xCC, 0xE8, 0xE7, 0x9D, 0xF0 + }, + { + 0x9B, 0xC4, 0x6E, 0xCF, 0x2E, 0xF1, 0x51, 0xCA, + 0x90, 0xEC, 0x3C, 0xDB, 0xCE, 0xDF, 0x4A, 0xD3, + 0x81, 0xA1, 0x81, 0x23, 0xAE, 0x23, 0xC4, 0x8A, + 0xA7, 0x8E, 0x46, 0x75, 0x4C, 0xAE, 0xFB, 0x10, + 0x5D, 0xE8, 0x08, 0x32, 0x6C, 0x88, 0x6D, 0x80, + 0x57, 0x7F, 0xFE, 0xDA, 0x6E, 0x68, 0x20, 0x9F, + 0x4C, 0x50, 0x76, 0x01, 0xC5, 0xC4, 0x9C, 0x34, + 0xAE, 0x35, 0x75, 0x41, 0x0C, 0xBC, 0x9D, 0x3E + }, + { + 0x53, 0xBC, 0xE4, 0x67, 0xFC, 0x31, 0xEE, 0x55, + 0x17, 0xD8, 0xB4, 0x4F, 0x1C, 0x95, 0xA1, 0xA5, + 0x95, 0x17, 0xD4, 0xE9, 0x6B, 0x7F, 0xB3, 0xE1, + 0x55, 0x2C, 0x1B, 0x7C, 0x5F, 0x3F, 0x61, 0x45, + 0xEF, 0x85, 0xEF, 0x29, 0xE9, 0x1B, 0x98, 0xEB, + 0x61, 0x8B, 0xDE, 0xFE, 0xFA, 0x77, 0x4D, 0xD7, + 0x59, 0x98, 0x68, 0xBA, 0xE5, 0x0D, 0x72, 0x80, + 0xE3, 0x3E, 0x7C, 0xFE, 0x83, 0x29, 0xFE, 0xFD + }, + { + 0x48, 0x4F, 0xC6, 0xB4, 0xAC, 0xB1, 0xCF, 0x78, + 0xA2, 0xBF, 0xE9, 0x84, 0x3B, 0x93, 0x2D, 0xC5, + 0xA9, 0x22, 0xF3, 0x7C, 0xB0, 0x70, 0x56, 0xE0, + 0x6C, 0x5F, 0x78, 0x19, 0x3B, 0xE6, 0x4F, 0x0D, + 0xFD, 0xFE, 0x7B, 0xB0, 0xEB, 0x31, 0xF0, 0x9A, + 0x0B, 0x7F, 0xCC, 0xFD, 0x42, 0x69, 0x91, 0xB7, + 0x04, 0x46, 0xA7, 0x75, 0xB3, 0xC7, 0xE6, 0x3C, + 0xD9, 0x9B, 0xC8, 0x9D, 0xB5, 0x85, 0x59, 0xFE + }, + { + 0x5D, 0x00, 0x7B, 0x2E, 0xB2, 0xFD, 0xF3, 0x77, + 0x78, 0x15, 0x0C, 0x90, 0x67, 0x24, 0xF5, 0x40, + 0x35, 0xA6, 0xF0, 0xD5, 0x78, 0x73, 0x2C, 0x19, + 0xA6, 0xC0, 0xCC, 0x17, 0xF7, 0x9E, 0x4B, 0x1C, + 0x49, 0xA4, 0x31, 0x77, 0x75, 0x57, 0xF3, 0xFB, + 0x84, 0x64, 0x91, 0xC1, 0x0E, 0x22, 0x83, 0x3F, + 0x48, 0xFB, 0xA8, 0x0B, 0xDD, 0x81, 0x7F, 0x80, + 0xE6, 0x6B, 0xCD, 0x51, 0x25, 0xA5, 0xB1, 0x88 + }, + { + 0x06, 0x0B, 0xF3, 0x15, 0xA8, 0xE9, 0x5E, 0x42, + 0xEA, 0x8E, 0xF0, 0xD3, 0x02, 0xF1, 0x74, 0xCE, + 0x17, 0x0E, 0xC6, 0x10, 0x39, 0x8A, 0x8D, 0x87, + 0x00, 0x4A, 0xB1, 0x82, 0xBF, 0x8E, 0xC3, 0xA2, + 0xD7, 0x07, 0x11, 0x88, 0xED, 0x63, 0xDD, 0xC8, + 0x51, 0x31, 0x65, 0x08, 0x58, 0xB9, 0x54, 0xAF, + 0x4E, 0xF0, 0x78, 0xC9, 0xAD, 0x94, 0xB4, 0x87, + 0x1C, 0x4A, 0x42, 0xEE, 0x30, 0x58, 0x09, 0xAC + }, + { + 0x75, 0xC7, 0x87, 0xC5, 0xC1, 0x20, 0x72, 0xFD, + 0x2A, 0x68, 0x26, 0x76, 0x1E, 0xBA, 0x5A, 0x39, + 0xCE, 0x74, 0x61, 0xC6, 0x62, 0x42, 0x99, 0x66, + 0xBF, 0x47, 0x3E, 0xCB, 0xEE, 0xAD, 0x66, 0x6A, + 0xF1, 0xE0, 0xC9, 0xF5, 0x33, 0x30, 0x94, 0xD4, + 0xB7, 0xE9, 0x80, 0x58, 0x4D, 0x52, 0x16, 0x43, + 0xB9, 0xAC, 0x87, 0x00, 0x7E, 0x9F, 0x2A, 0xCD, + 0x3D, 0x3B, 0x26, 0x6C, 0x37, 0xDA, 0x89, 0x68 + }, + { + 0x26, 0x95, 0xAD, 0x32, 0x3F, 0x27, 0x80, 0x72, + 0x37, 0x5E, 0xAF, 0x86, 0xE4, 0xBA, 0x9F, 0x94, + 0x5E, 0xA7, 0x8D, 0x18, 0x71, 0x59, 0x6F, 0x26, + 0xE9, 0x9C, 0x76, 0x16, 0x32, 0xD4, 0x0A, 0x8F, + 0x8A, 0x3E, 0xCF, 0xD5, 0xED, 0xFA, 0x07, 0x79, + 0xC1, 0x83, 0xFE, 0xD5, 0x65, 0x03, 0x58, 0x2A, + 0x91, 0x91, 0x57, 0xDC, 0x75, 0xF7, 0x56, 0x91, + 0x33, 0x33, 0xBC, 0xBA, 0xE6, 0x61, 0xEB, 0xA6 + }, + { + 0x78, 0xA9, 0xB2, 0x7B, 0xFC, 0x6E, 0x7F, 0x85, + 0x30, 0x15, 0x39, 0x4A, 0xB6, 0x62, 0xF3, 0x1D, + 0xF9, 0xF3, 0x23, 0xF2, 0xEB, 0xD0, 0x0C, 0x62, + 0x7A, 0x60, 0xD4, 0x87, 0x24, 0xF9, 0xAB, 0xA1, + 0x46, 0xF0, 0x42, 0x2D, 0x8E, 0x5D, 0x4F, 0xDA, + 0xFC, 0xF2, 0x11, 0x1E, 0x30, 0x59, 0x13, 0x7C, + 0x9E, 0xF1, 0x16, 0x9A, 0x70, 0x85, 0xC9, 0xC2, + 0xDF, 0xA3, 0xE3, 0xAF, 0xA2, 0x77, 0x38, 0x7E + }, + { + 0x5A, 0x45, 0x97, 0xD8, 0xFC, 0xBC, 0x87, 0xB3, + 0x1E, 0x93, 0xA8, 0x71, 0xE2, 0xDE, 0xB0, 0xC1, + 0x31, 0x8D, 0x96, 0x91, 0x8D, 0xC1, 0x0B, 0xAA, + 0x88, 0xD5, 0xD2, 0x6F, 0xF2, 0xCE, 0x2E, 0xBB, + 0x45, 0xF8, 0xD3, 0xC9, 0xE7, 0x88, 0x77, 0xE2, + 0xA6, 0x92, 0x86, 0x4D, 0x8A, 0x25, 0x3F, 0x9C, + 0x47, 0x6E, 0x4F, 0x10, 0x77, 0xCE, 0x71, 0x81, + 0x31, 0xB0, 0xDD, 0x63, 0x9F, 0x07, 0xF2, 0x89 + }, + { + 0x7B, 0x8C, 0xC5, 0x79, 0x71, 0xFD, 0x0A, 0x4A, + 0xD3, 0xE6, 0x44, 0xAD, 0x17, 0xBB, 0x8A, 0xCF, + 0xC2, 0x18, 0xD4, 0xAB, 0xB0, 0xA4, 0xEE, 0xF1, + 0xB7, 0x70, 0x40, 0x63, 0xC2, 0x9F, 0x2A, 0x74, + 0x19, 0x6D, 0x0C, 0x96, 0x5B, 0xFA, 0xFC, 0x68, + 0x39, 0x02, 0xDF, 0x1F, 0x30, 0x68, 0x48, 0xDF, + 0xD3, 0x88, 0x36, 0x6E, 0xE0, 0xD6, 0x05, 0x34, + 0x6E, 0xEA, 0x2A, 0x21, 0x6D, 0xC2, 0x2E, 0x30 + }, + { + 0x5E, 0xE8, 0x07, 0x77, 0xC9, 0x88, 0xEC, 0x4A, + 0x1A, 0x90, 0xEC, 0x73, 0x4C, 0xDE, 0x1E, 0x53, + 0x06, 0xE8, 0x70, 0x36, 0xAA, 0x8C, 0x6D, 0x5A, + 0xDB, 0xCC, 0x76, 0x0D, 0x0A, 0xBB, 0x78, 0xAB, + 0xD8, 0x6E, 0xBD, 0x13, 0xAC, 0x11, 0x21, 0xDE, + 0x4C, 0x51, 0x44, 0x7D, 0xEE, 0x45, 0x79, 0x39, + 0x13, 0x2E, 0xD9, 0xD5, 0xF3, 0xEC, 0xBB, 0x89, + 0xA5, 0x75, 0x53, 0xD2, 0x5E, 0xC9, 0x3C, 0xF1 + }, + { + 0xAA, 0x12, 0x37, 0x49, 0x5C, 0x16, 0x11, 0x3E, + 0x30, 0xB5, 0x3B, 0x54, 0x46, 0x0B, 0xC6, 0x6E, + 0x32, 0x8C, 0xDA, 0x5D, 0xB1, 0x27, 0x03, 0xDB, + 0x8E, 0x3B, 0x1A, 0xEE, 0x0D, 0x94, 0xFD, 0x50, + 0x89, 0x63, 0x48, 0xB3, 0xA5, 0x93, 0x11, 0xC8, + 0xEF, 0x62, 0xC5, 0x96, 0xCD, 0xB2, 0x6E, 0x28, + 0x4B, 0xE9, 0x47, 0xA1, 0x81, 0xF2, 0xFA, 0x2D, + 0xC2, 0xEF, 0xAA, 0x8D, 0xDD, 0xE1, 0x3E, 0x24 + }, + { + 0x6A, 0x5E, 0x71, 0x23, 0xFD, 0xA9, 0x67, 0x75, + 0x12, 0xD8, 0xCA, 0xD1, 0x9B, 0xAC, 0x2B, 0xB4, + 0x3A, 0x66, 0x01, 0x07, 0xD8, 0x37, 0x1C, 0xA4, + 0x57, 0xB4, 0xA0, 0x2B, 0xB8, 0x06, 0x21, 0xC7, + 0x07, 0x40, 0x51, 0x62, 0x9B, 0x4C, 0x03, 0x88, + 0x24, 0x19, 0x3B, 0x6F, 0x60, 0x54, 0xBD, 0xB6, + 0x2D, 0xCC, 0xD7, 0x4E, 0x69, 0x67, 0x22, 0x9F, + 0x17, 0x18, 0xB0, 0x1E, 0xEF, 0x50, 0xE4, 0xD4 + }, + { + 0x7E, 0xD4, 0x51, 0x37, 0xE7, 0xB4, 0xC9, 0x39, + 0x25, 0x16, 0x9B, 0x6D, 0x58, 0x86, 0xD7, 0x48, + 0x5B, 0xF5, 0x05, 0xCC, 0xDF, 0xAA, 0x55, 0x68, + 0xCF, 0xD0, 0xCC, 0x74, 0xB7, 0x50, 0xB3, 0x21, + 0xB9, 0x45, 0xF9, 0x31, 0xCC, 0x33, 0xE8, 0xF0, + 0xA0, 0x0B, 0xF5, 0x22, 0xC6, 0xB3, 0x7C, 0x1D, + 0xEC, 0xD7, 0xE3, 0x3C, 0xD4, 0x0C, 0xD3, 0x5C, + 0x2D, 0xBA, 0x69, 0x53, 0x15, 0x6B, 0x96, 0x64 + }, + { + 0x42, 0xF0, 0xD3, 0x81, 0xD9, 0xBF, 0xD9, 0x2C, + 0xEA, 0xA8, 0x66, 0x78, 0x5E, 0xCE, 0x1B, 0x92, + 0x4A, 0xB2, 0x9A, 0x91, 0x78, 0xD5, 0xE3, 0x97, + 0x20, 0x40, 0x36, 0xB9, 0x4A, 0x13, 0x4D, 0x26, + 0x25, 0xCC, 0x2D, 0x47, 0x0F, 0x4F, 0x30, 0x13, + 0xB5, 0xCF, 0x7F, 0xE2, 0x78, 0xAA, 0x09, 0x7F, + 0xC0, 0x80, 0x09, 0xCC, 0x3F, 0xCD, 0x7E, 0x18, + 0x09, 0x67, 0xC6, 0xC9, 0x11, 0xDE, 0xC3, 0x6B + }, + { + 0x9A, 0x61, 0x14, 0x39, 0x2A, 0x41, 0x90, 0x59, + 0x84, 0x8F, 0x35, 0xEA, 0x84, 0xD2, 0x6E, 0x51, + 0xF6, 0xAC, 0x09, 0xA1, 0xEB, 0xF5, 0xDC, 0xB5, + 0x80, 0xD6, 0x56, 0x38, 0x6F, 0x1E, 0x19, 0x57, + 0xED, 0x0B, 0xA4, 0x76, 0xF7, 0xA4, 0xE5, 0x11, + 0xA9, 0xFA, 0x35, 0xF0, 0xD4, 0x67, 0xC3, 0xEB, + 0x84, 0x0E, 0x3B, 0x99, 0xAA, 0xB4, 0xFC, 0x37, + 0x93, 0xDA, 0x90, 0x09, 0xA4, 0x6C, 0x83, 0x3F + }, + { + 0xAF, 0xF3, 0x74, 0xD9, 0xEC, 0x02, 0xEB, 0xFE, + 0xD9, 0x19, 0x52, 0x19, 0x47, 0x0C, 0x2B, 0x5F, + 0xFC, 0xAD, 0xFE, 0x18, 0x2C, 0xBF, 0x87, 0x3F, + 0x50, 0x5F, 0x66, 0x64, 0xFD, 0x25, 0x6F, 0x68, + 0x52, 0xE7, 0xDF, 0x1C, 0x0E, 0x09, 0xCD, 0x9F, + 0x25, 0x6E, 0x8C, 0x0D, 0x86, 0xC3, 0xC6, 0xDC, + 0x6C, 0x46, 0xD8, 0x46, 0x36, 0x94, 0x7C, 0x0C, + 0xE6, 0xF2, 0x00, 0x35, 0x7E, 0x82, 0x6E, 0xF4 + }, + { + 0xED, 0x2F, 0x34, 0x75, 0x5B, 0x75, 0xEB, 0xDF, + 0x46, 0x87, 0xDB, 0xBB, 0x63, 0xF7, 0x11, 0x64, + 0x49, 0x56, 0x28, 0x22, 0xD1, 0xEA, 0xF0, 0xC7, + 0xBA, 0xA6, 0x14, 0x29, 0xDD, 0x80, 0x43, 0x64, + 0x01, 0x1F, 0x34, 0xE6, 0xF1, 0x32, 0xBF, 0xDA, + 0x7A, 0x7D, 0x92, 0xF7, 0xC7, 0x68, 0x98, 0xDB, + 0x3C, 0x62, 0x4C, 0xDA, 0xA7, 0x4B, 0x9C, 0x5F, + 0xB2, 0x84, 0xF6, 0x38, 0x9A, 0xE3, 0xBD, 0xB4 + }, + { + 0x37, 0xF6, 0xFA, 0xEC, 0x53, 0x03, 0x24, 0x2B, + 0x84, 0x56, 0xAF, 0x35, 0x8C, 0x70, 0xFA, 0xDC, + 0xCA, 0x52, 0xCC, 0xF1, 0x68, 0x67, 0x77, 0xA1, + 0xAF, 0xB0, 0x03, 0x99, 0x5A, 0x66, 0xAF, 0xA4, + 0x25, 0xCE, 0x2E, 0xD4, 0x66, 0xEA, 0x11, 0x7C, + 0xAB, 0x4C, 0xAD, 0x40, 0x1A, 0x25, 0xEA, 0x23, + 0xFB, 0xFE, 0x29, 0x36, 0x02, 0xEA, 0x35, 0x68, + 0x60, 0xF9, 0x69, 0xCF, 0xCC, 0x28, 0xE1, 0x3B + }, + { + 0xB3, 0x2C, 0x90, 0x8E, 0x7A, 0xCD, 0x1F, 0x27, + 0xFA, 0x42, 0x07, 0xF7, 0x35, 0x04, 0xFB, 0xA3, + 0xEF, 0xAC, 0xCD, 0xB1, 0x0C, 0x87, 0x21, 0x98, + 0x2F, 0x01, 0xFC, 0xD9, 0x78, 0x5F, 0x70, 0x61, + 0x3E, 0x0F, 0x2B, 0x00, 0x35, 0xB9, 0xCF, 0x3F, + 0x42, 0xF9, 0x1F, 0x41, 0x0B, 0xED, 0x06, 0x5C, + 0x31, 0xA4, 0xC8, 0x19, 0xAC, 0x18, 0x4B, 0xC4, + 0x71, 0x0B, 0xD8, 0x75, 0xC7, 0xFA, 0xEC, 0x7B + }, + { + 0xF2, 0x12, 0x70, 0xCD, 0x54, 0xA3, 0xA1, 0x9C, + 0x3A, 0x31, 0x61, 0xF2, 0x75, 0x39, 0x6B, 0xA4, + 0xCF, 0x3A, 0x28, 0x74, 0x7D, 0x50, 0xF6, 0x81, + 0x0D, 0x47, 0x19, 0x36, 0x0B, 0x80, 0x68, 0xE1, + 0x30, 0x64, 0xE5, 0x35, 0x55, 0xF9, 0xDA, 0x1C, + 0x27, 0x35, 0xB9, 0x73, 0x41, 0xBB, 0x8D, 0xB8, + 0xE1, 0x18, 0xCC, 0xF7, 0xB6, 0x79, 0xE2, 0x79, + 0x11, 0xED, 0x10, 0x00, 0x5D, 0xBE, 0x91, 0x33 + }, + { + 0x66, 0x9B, 0xF4, 0xA8, 0x0A, 0x2D, 0x8E, 0xD7, + 0x2E, 0x2E, 0x53, 0xE9, 0x3F, 0xCE, 0x54, 0xF2, + 0xA2, 0xA2, 0xC2, 0x34, 0x1D, 0x3E, 0xF6, 0x66, + 0x3C, 0x32, 0x91, 0x8B, 0xDF, 0x0D, 0x54, 0xE4, + 0x54, 0xA5, 0xE8, 0x79, 0x04, 0x20, 0x90, 0x9F, + 0x7B, 0x1E, 0x9D, 0x66, 0x65, 0x09, 0x4F, 0x4C, + 0xF9, 0x68, 0xBC, 0x8A, 0xDE, 0x33, 0x09, 0xEE, + 0x6D, 0x0F, 0xD7, 0xEC, 0x22, 0x60, 0x72, 0x3B + }, + { + 0x0E, 0xE5, 0x38, 0x66, 0xE0, 0x5E, 0xDC, 0xF2, + 0xD2, 0x10, 0x8C, 0xEE, 0x9B, 0xF3, 0x00, 0xBE, + 0xEA, 0x60, 0xC7, 0xD6, 0xF8, 0x1F, 0x65, 0xA2, + 0x01, 0x5E, 0x7B, 0x8C, 0xE6, 0x4D, 0xDF, 0x7C, + 0x52, 0x3A, 0x39, 0x21, 0x62, 0x65, 0x60, 0xC3, + 0xBC, 0x32, 0x56, 0x58, 0x20, 0xBD, 0xFC, 0xF9, + 0xC1, 0x1B, 0x22, 0x26, 0x74, 0x4C, 0x3F, 0x79, + 0xD5, 0xD6, 0xA8, 0xD1, 0x38, 0xC2, 0x7E, 0x38 + }, + { + 0x06, 0x19, 0xD4, 0xC0, 0xB8, 0xEF, 0xD1, 0xA9, + 0x0D, 0x2A, 0x0B, 0x5A, 0xB0, 0x9C, 0x51, 0x54, + 0x0F, 0x0F, 0x58, 0x1D, 0xB9, 0x20, 0x61, 0x70, + 0x31, 0x92, 0x45, 0x6C, 0xBA, 0x8B, 0xAB, 0xE8, + 0x7B, 0xAA, 0xF2, 0x3E, 0x26, 0xBA, 0x0B, 0xCA, + 0x70, 0x66, 0xA4, 0x5B, 0x77, 0x6F, 0x9D, 0x0C, + 0xD0, 0x8F, 0x9C, 0xD8, 0x89, 0x60, 0xD9, 0x19, + 0xB8, 0x2F, 0x8A, 0x08, 0x27, 0x26, 0x65, 0xEC + }, + { + 0xA5, 0x00, 0xD5, 0x83, 0x9E, 0xB0, 0x9D, 0x6E, + 0x28, 0x73, 0xC8, 0xC0, 0x16, 0xC5, 0x3A, 0x35, + 0x9A, 0xAD, 0xB5, 0x88, 0x10, 0xD5, 0xE4, 0x1C, + 0x8B, 0x47, 0x2D, 0x46, 0x02, 0xFF, 0xE1, 0x4F, + 0xAC, 0xE6, 0xA8, 0x75, 0x58, 0x4A, 0x24, 0x26, + 0xAE, 0xE4, 0xF7, 0xBC, 0xB7, 0xE5, 0x10, 0xB5, + 0x4F, 0xDA, 0xB5, 0xB0, 0xEF, 0x37, 0x18, 0xF0, + 0x91, 0xFF, 0xDA, 0x08, 0x3C, 0x01, 0x82, 0x3B + }, + { + 0x66, 0x68, 0x3D, 0x44, 0x02, 0x12, 0x2A, 0x64, + 0xAB, 0x9A, 0xC3, 0xB6, 0xEF, 0x13, 0x89, 0x44, + 0x57, 0x50, 0xA3, 0xF0, 0xD8, 0x49, 0x77, 0x9F, + 0xA0, 0x88, 0x3B, 0x6E, 0xD7, 0x55, 0x07, 0x9A, + 0x4E, 0x56, 0x5E, 0xCF, 0x08, 0xFF, 0x00, 0x2A, + 0xD5, 0xCB, 0xF5, 0x74, 0x7F, 0x44, 0x90, 0x67, + 0x90, 0x6C, 0x90, 0xC1, 0xC6, 0xCB, 0x93, 0x4B, + 0x3F, 0x77, 0x65, 0x16, 0xDF, 0x3D, 0xBF, 0x96 + }, + { + 0x15, 0xFB, 0x1D, 0x78, 0xD8, 0xB8, 0xE2, 0x16, + 0xF7, 0xC4, 0x44, 0xCC, 0xC6, 0x5D, 0x22, 0xDD, + 0xE6, 0x8D, 0x95, 0x8D, 0x2E, 0xDA, 0x55, 0xC5, + 0x65, 0x2F, 0x30, 0xB2, 0xC1, 0xB9, 0xD1, 0x90, + 0x7F, 0xF0, 0xE1, 0x0D, 0xCD, 0xD5, 0xA7, 0xCA, + 0x65, 0xC5, 0xF3, 0xA9, 0x43, 0x87, 0x23, 0xFC, + 0xAE, 0x21, 0x77, 0xDD, 0xDD, 0x01, 0x7F, 0xD3, + 0xFE, 0xE4, 0xEB, 0xBD, 0xAE, 0x97, 0x1C, 0x4D + }, + { + 0x7B, 0x77, 0x02, 0x26, 0xD1, 0xA1, 0x0B, 0xB7, + 0xD9, 0x87, 0x9E, 0xB6, 0x31, 0x65, 0xE2, 0x03, + 0x11, 0x48, 0xD7, 0xD3, 0xBB, 0xBC, 0xCC, 0x15, + 0x37, 0x23, 0x87, 0x04, 0x19, 0x2A, 0xCD, 0x0B, + 0xF0, 0x56, 0x20, 0x49, 0x35, 0xC9, 0xE5, 0x2F, + 0x86, 0x97, 0xF0, 0xB4, 0x60, 0x49, 0xCB, 0x9F, + 0x3F, 0x32, 0x17, 0x79, 0xB1, 0x07, 0xC3, 0x46, + 0x0D, 0xA3, 0x44, 0x3E, 0x65, 0x94, 0x5F, 0xC9 + }, + { + 0x38, 0x61, 0x52, 0x5E, 0x15, 0x3F, 0x50, 0xDF, + 0x7E, 0x6F, 0x2A, 0xE8, 0x44, 0xFC, 0x1C, 0xA0, + 0x1D, 0x83, 0x9F, 0x64, 0x55, 0x2B, 0x56, 0x29, + 0x9F, 0x68, 0xDB, 0xC5, 0x3C, 0xC7, 0x8A, 0xE8, + 0xD5, 0x81, 0x79, 0x68, 0x78, 0x3B, 0x1E, 0x2B, + 0x29, 0x96, 0x35, 0x5A, 0x79, 0x3E, 0x80, 0x21, + 0x09, 0xED, 0xFF, 0x7D, 0x96, 0xEA, 0x1E, 0x05, + 0xEC, 0x7B, 0x71, 0xC8, 0xDE, 0x60, 0xF3, 0x8E + }, + { + 0xBF, 0xC6, 0x5D, 0xCF, 0x9E, 0x32, 0x8A, 0x66, + 0x03, 0x32, 0xBE, 0xB0, 0x06, 0x21, 0x6E, 0x25, + 0x04, 0xC7, 0x54, 0xCB, 0xB9, 0xB0, 0x01, 0xB3, + 0x95, 0x86, 0xDD, 0x94, 0x1E, 0x59, 0x88, 0x6F, + 0xE2, 0x68, 0x9A, 0x80, 0x25, 0xCD, 0x83, 0x60, + 0x36, 0xEA, 0x9B, 0xBB, 0xDF, 0xD3, 0xAC, 0xEC, + 0xB9, 0x4A, 0x7A, 0xAB, 0x65, 0x9D, 0x73, 0xA7, + 0x0F, 0xDE, 0xAF, 0x69, 0xAA, 0xD8, 0x5C, 0xDA + }, + { + 0xA5, 0xB9, 0x83, 0x5E, 0x69, 0xB5, 0x1D, 0x7A, + 0x15, 0x18, 0x49, 0xE6, 0xB3, 0xEA, 0xA4, 0xB9, + 0xD6, 0x5A, 0xDC, 0x09, 0x7A, 0xE3, 0xA2, 0x40, + 0x03, 0x3C, 0x4A, 0x16, 0xB3, 0xEA, 0xBF, 0x9A, + 0xE0, 0x28, 0xBD, 0x66, 0x87, 0xFA, 0xE0, 0xBF, + 0x43, 0xEA, 0xA5, 0xC9, 0x0F, 0xA5, 0x0C, 0x28, + 0x2F, 0xE2, 0xFE, 0x86, 0x25, 0x84, 0xB8, 0x94, + 0x7E, 0x01, 0x26, 0x49, 0xB4, 0x80, 0xBD, 0x5E + }, + { + 0xA3, 0x73, 0x94, 0x8C, 0x7F, 0x66, 0x3C, 0xED, + 0xD8, 0x83, 0x91, 0x1E, 0xBC, 0xD7, 0x50, 0x44, + 0xF4, 0xD6, 0x00, 0x99, 0x7D, 0x32, 0x01, 0x62, + 0x7F, 0x85, 0xC5, 0x5E, 0x2F, 0x8B, 0xF1, 0x76, + 0x3D, 0x8E, 0xEB, 0xD6, 0x29, 0x07, 0xE4, 0xE1, + 0xAB, 0x04, 0x0B, 0x94, 0x39, 0x6A, 0xA0, 0x6B, + 0x35, 0xA9, 0x4B, 0x03, 0x6B, 0x13, 0x50, 0x71, + 0x57, 0x08, 0x7B, 0x23, 0xFA, 0x91, 0xD5, 0x6B + }, + { + 0x99, 0x0A, 0xD4, 0xDE, 0x4B, 0x17, 0x2A, 0x37, + 0x3E, 0x49, 0x38, 0xAF, 0x36, 0x47, 0xFD, 0xDA, + 0xEE, 0xFE, 0xFA, 0x95, 0xDE, 0x2F, 0x3D, 0x9C, + 0xC7, 0x7C, 0x75, 0xC1, 0x54, 0xCE, 0xFF, 0x2E, + 0xAE, 0x2F, 0x22, 0xB1, 0xA7, 0xEA, 0x62, 0x75, + 0xC7, 0x8B, 0x89, 0xF3, 0x62, 0xAD, 0x41, 0x20, + 0x85, 0x2C, 0x98, 0xA9, 0xBE, 0xB6, 0x6D, 0xEA, + 0x7E, 0xBC, 0x56, 0x26, 0xD0, 0xA8, 0xA2, 0x85 + }, + { + 0x52, 0x79, 0x7A, 0xC3, 0x1B, 0xE2, 0x0D, 0xB9, + 0xC8, 0x7C, 0x8D, 0x9A, 0xB5, 0xF4, 0x5F, 0x02, + 0x27, 0xE5, 0xB9, 0xA2, 0x2A, 0x59, 0x6C, 0xF0, + 0xDF, 0x2E, 0x4C, 0xE4, 0xDB, 0x39, 0x2B, 0x96, + 0x73, 0xF5, 0x5B, 0x41, 0x02, 0x23, 0xAE, 0xEA, + 0x7F, 0xDA, 0x93, 0xCE, 0x18, 0x50, 0x5F, 0x79, + 0x02, 0x5B, 0x17, 0x33, 0xD6, 0xD0, 0x2F, 0x43, + 0xF9, 0xD6, 0x7C, 0xA0, 0x2C, 0x60, 0xF8, 0x54 + }, + { + 0xD5, 0xE6, 0x80, 0x1D, 0x71, 0xB8, 0x69, 0xEA, + 0x34, 0x4F, 0x76, 0x64, 0x6B, 0x77, 0xF9, 0x67, + 0xCC, 0xB8, 0x2E, 0x60, 0x84, 0x85, 0xF6, 0x31, + 0x66, 0xF4, 0x70, 0x4F, 0x36, 0x19, 0xC6, 0xCC, + 0xE4, 0xC3, 0xA9, 0xAA, 0x7A, 0x6B, 0xE7, 0xB7, + 0x7A, 0x99, 0x16, 0xE0, 0x75, 0x3D, 0x4A, 0x89, + 0x62, 0x39, 0xFE, 0x8E, 0x50, 0x8B, 0x65, 0x0D, + 0x9F, 0x07, 0xD6, 0x20, 0xD9, 0xBD, 0x97, 0xE7 + }, + { + 0xBC, 0x6D, 0x94, 0xBC, 0x7E, 0x86, 0xD9, 0x7C, + 0xCF, 0x46, 0xD0, 0xA6, 0xC5, 0x97, 0x8B, 0x43, + 0xFE, 0x97, 0x77, 0x71, 0xE7, 0xD6, 0xFE, 0x0C, + 0xD2, 0xE5, 0x0E, 0x5C, 0x4A, 0x5B, 0x30, 0x5F, + 0x34, 0x66, 0xAE, 0x8E, 0xB1, 0x23, 0xD1, 0x01, + 0x43, 0x6D, 0xC0, 0xDC, 0xD3, 0xF2, 0xE0, 0x80, + 0xE6, 0xDF, 0x0B, 0x75, 0x57, 0x73, 0x6F, 0xC7, + 0xE3, 0xAB, 0x8C, 0x8A, 0xA5, 0x9B, 0xD7, 0xB5 + }, + { + 0x5F, 0x02, 0x52, 0xFA, 0x56, 0x6E, 0x69, 0x7E, + 0xD7, 0xDA, 0xC4, 0x03, 0x01, 0x09, 0x25, 0xA9, + 0x2C, 0xCE, 0x08, 0xAB, 0xCB, 0x8D, 0xBC, 0x0F, + 0xFF, 0xE7, 0xA8, 0xA7, 0x2C, 0xA4, 0x62, 0x9A, + 0x6A, 0xAF, 0x0C, 0x78, 0xEE, 0x44, 0x34, 0x1C, + 0x99, 0x95, 0xBE, 0xA9, 0x4A, 0x49, 0xD3, 0xEE, + 0x04, 0xB9, 0x5F, 0x14, 0x89, 0xD4, 0xEA, 0x72, + 0x4D, 0xC0, 0xFC, 0x2B, 0x4B, 0x7B, 0xA3, 0x7B + }, + { + 0xD5, 0x04, 0x9D, 0x4B, 0x10, 0xBF, 0x74, 0x0B, + 0xC4, 0xB7, 0x7E, 0xC1, 0x13, 0x70, 0xFB, 0xCE, + 0xF6, 0x03, 0xBD, 0xEA, 0xB4, 0x7E, 0x68, 0xC1, + 0xF6, 0x5C, 0x26, 0x80, 0x53, 0xB1, 0x18, 0xE9, + 0x71, 0x69, 0x59, 0xE9, 0x1B, 0xCC, 0x44, 0x14, + 0x14, 0x17, 0xCE, 0xBD, 0x58, 0xC1, 0xFE, 0x3D, + 0xA9, 0x6F, 0x48, 0x44, 0x51, 0xF5, 0xB8, 0x5C, + 0x0C, 0x2E, 0x6F, 0x1B, 0xC7, 0x19, 0x16, 0x76 + }, + { + 0x5F, 0xCD, 0x4B, 0x2F, 0x65, 0xEA, 0xB2, 0x6B, + 0x9B, 0x30, 0x5E, 0x1C, 0x97, 0x29, 0xA8, 0x27, + 0xA2, 0x80, 0xC0, 0xD0, 0xC9, 0xD1, 0x10, 0xDB, + 0x70, 0xC8, 0x94, 0x7C, 0x0B, 0x9F, 0x5B, 0x54, + 0x28, 0x4C, 0x3D, 0x7B, 0x54, 0x76, 0x64, 0xE7, + 0xC5, 0x4E, 0x83, 0xE3, 0x57, 0x6A, 0xA2, 0x58, + 0xAE, 0x11, 0x3E, 0x8B, 0xBA, 0xE2, 0xCF, 0xE4, + 0xF5, 0xB2, 0x3F, 0xCE, 0x88, 0xE7, 0x39, 0x3C + }, + { + 0x95, 0x4A, 0x7E, 0xC8, 0x60, 0xD0, 0xE8, 0xFD, + 0xFC, 0x2E, 0x64, 0x48, 0x97, 0xFD, 0x36, 0xA9, + 0xD5, 0x69, 0x86, 0xC3, 0x7E, 0x48, 0x44, 0x87, + 0x97, 0xCD, 0xC7, 0xD7, 0x64, 0x0E, 0xFF, 0xB2, + 0x65, 0x26, 0xFC, 0x3C, 0xEF, 0xE4, 0xD0, 0x3E, + 0x31, 0x0C, 0x0B, 0xFD, 0x97, 0xD9, 0x77, 0x89, + 0x68, 0xCD, 0xFF, 0x05, 0xA7, 0x8B, 0x7F, 0x4F, + 0xA4, 0xC9, 0x09, 0x8E, 0x74, 0xC7, 0xD6, 0x17 + }, + { + 0xE5, 0x9D, 0x1D, 0xCD, 0x40, 0x42, 0x74, 0x9F, + 0xC8, 0x5B, 0x04, 0x28, 0x0B, 0x8E, 0x3A, 0x4B, + 0x1A, 0x08, 0xF6, 0x93, 0xF5, 0xB9, 0x05, 0xAC, + 0xC0, 0xBD, 0x89, 0x04, 0x0E, 0x82, 0x04, 0xF1, + 0x0C, 0x29, 0x1A, 0x78, 0xFC, 0x8C, 0x7D, 0x24, + 0x2D, 0xBC, 0x9A, 0x2F, 0x2A, 0xCE, 0x5B, 0x18, + 0x7C, 0xA8, 0x6D, 0xBE, 0x73, 0xD4, 0xEF, 0x8B, + 0x61, 0xD8, 0x22, 0xD0, 0xCF, 0x7F, 0xE7, 0x0C + }, + { + 0xF0, 0x75, 0xB9, 0xE8, 0x30, 0x4A, 0x2B, 0x4C, + 0x32, 0x65, 0x8B, 0x62, 0xF5, 0x6E, 0x2F, 0xBB, + 0x60, 0x63, 0x37, 0x34, 0x80, 0xA3, 0xC5, 0x64, + 0x2F, 0x50, 0x24, 0x6E, 0x56, 0x43, 0xC1, 0x61, + 0x55, 0xF6, 0x71, 0xE8, 0x1D, 0xA1, 0x8B, 0xB2, + 0xB8, 0x1B, 0xF9, 0x5B, 0x99, 0xA9, 0xDE, 0x7B, + 0x82, 0x71, 0x17, 0xFF, 0x60, 0x2C, 0x1E, 0x3E, + 0xF8, 0x92, 0x46, 0x39, 0x51, 0xA6, 0x3C, 0x16 + }, + { + 0xB1, 0xF2, 0x9C, 0x64, 0xF4, 0x9B, 0x6C, 0xD5, + 0x5F, 0x44, 0x06, 0x6F, 0x12, 0x7D, 0x6C, 0xA0, + 0x10, 0xC9, 0xE9, 0xE9, 0x29, 0x9A, 0xD5, 0x6D, + 0xD1, 0xEE, 0xE8, 0x23, 0xAF, 0xF1, 0x5F, 0x9F, + 0xE2, 0xB9, 0x24, 0xBD, 0xE2, 0xE3, 0x49, 0xC7, + 0xFF, 0xB5, 0x46, 0x45, 0x41, 0xA6, 0x90, 0x70, + 0x38, 0x2E, 0x95, 0x5A, 0x58, 0x39, 0x2E, 0x8C, + 0x56, 0x03, 0xAF, 0x4D, 0x09, 0x54, 0xA6, 0x20 + }, + { + 0x6B, 0xA1, 0x46, 0xF2, 0x83, 0x8D, 0x3E, 0x79, + 0x4D, 0xA7, 0x84, 0x89, 0xBA, 0x2E, 0xA9, 0x6E, + 0xFF, 0x88, 0x89, 0xD3, 0xB1, 0xEE, 0x69, 0x66, + 0x29, 0x02, 0xB0, 0x81, 0x3C, 0x7F, 0xD3, 0xD3, + 0xEE, 0xDC, 0xC6, 0xE2, 0x08, 0xB6, 0x6D, 0x4C, + 0xAF, 0xC6, 0x67, 0xF5, 0x0D, 0xBE, 0x32, 0x83, + 0x00, 0x45, 0x0D, 0x7A, 0x01, 0xC4, 0x8B, 0x74, + 0x51, 0x53, 0x3D, 0x12, 0x43, 0x19, 0xD4, 0xAD + }, + { + 0xA0, 0x18, 0x5A, 0x3A, 0xA6, 0x70, 0xD3, 0x8B, + 0xE6, 0xA5, 0xEC, 0x0A, 0x02, 0x0C, 0x94, 0x4F, + 0xBB, 0x71, 0x4A, 0x0B, 0x43, 0x5B, 0x7D, 0x3C, + 0x45, 0x45, 0x1F, 0x33, 0xD5, 0xF9, 0x8B, 0x3E, + 0x23, 0x3E, 0x0D, 0x6D, 0x65, 0xF4, 0x90, 0x1A, + 0x52, 0xF2, 0xFC, 0xB2, 0x5D, 0x3D, 0xAD, 0xDC, + 0x98, 0x2D, 0xB6, 0x15, 0x4E, 0x5E, 0x76, 0x45, + 0x19, 0xFC, 0x2B, 0xA7, 0x12, 0xFD, 0xC8, 0x0B + }, + { + 0x38, 0xC6, 0x5D, 0xBF, 0x77, 0x08, 0x4B, 0x7F, + 0x48, 0xF7, 0xFD, 0x32, 0x40, 0xE2, 0x0D, 0xA6, + 0x1D, 0x77, 0x6F, 0xDF, 0x1D, 0x97, 0x50, 0x0B, + 0xEA, 0xB1, 0x61, 0x1C, 0x00, 0xA4, 0x26, 0xFA, + 0x6E, 0x7F, 0xF4, 0x74, 0x8F, 0xBB, 0xA3, 0xC5, + 0x49, 0x40, 0xF0, 0x5C, 0x59, 0xBF, 0xC7, 0x17, + 0x71, 0x28, 0x25, 0xEE, 0xFA, 0xDF, 0x69, 0x1E, + 0x59, 0x3B, 0x68, 0xD6, 0x68, 0x44, 0x9F, 0xC5 + }, + { + 0x06, 0x8A, 0x60, 0x8F, 0xE2, 0x08, 0x68, 0xB7, + 0x65, 0x57, 0xE5, 0xBD, 0xF8, 0x8F, 0xD7, 0x5E, + 0x40, 0x0D, 0xA2, 0x72, 0x30, 0xA5, 0xF5, 0xF1, + 0x21, 0x5E, 0x14, 0x88, 0x6D, 0x0A, 0x1F, 0x41, + 0x2F, 0x7B, 0xB2, 0xA1, 0xE9, 0x23, 0xA5, 0xC3, + 0x4E, 0x63, 0x4C, 0x32, 0x2E, 0x2A, 0xE7, 0xE9, + 0x15, 0x80, 0xDE, 0x73, 0x24, 0xE9, 0x78, 0x5F, + 0xB4, 0x76, 0xD9, 0xDF, 0x55, 0xA2, 0x89, 0x72 + }, + { + 0x1A, 0x34, 0x97, 0x63, 0xDF, 0x7C, 0xED, 0x00, + 0x72, 0x23, 0x56, 0x66, 0x87, 0x2B, 0xF6, 0xD1, + 0x08, 0xB2, 0x01, 0x9B, 0x3A, 0x84, 0x0B, 0x1C, + 0x5F, 0x8A, 0x8E, 0xD2, 0x2B, 0x0A, 0x61, 0xD4, + 0xAF, 0xEF, 0x4A, 0x17, 0x33, 0xDA, 0xE9, 0x9F, + 0x28, 0x1C, 0x60, 0x99, 0x6B, 0xE3, 0x8F, 0xF9, + 0x37, 0x97, 0x7C, 0xA4, 0xEA, 0x9B, 0xFC, 0x8B, + 0xFF, 0xFB, 0x68, 0x9A, 0x67, 0xC1, 0x15, 0xBE + }, + { + 0x38, 0xF3, 0x65, 0xD6, 0x0A, 0x87, 0x59, 0x27, + 0x4F, 0x35, 0x67, 0x9E, 0x00, 0xEC, 0xD0, 0x0D, + 0x29, 0xCF, 0xE3, 0x75, 0x72, 0x19, 0x08, 0x73, + 0xDA, 0xDC, 0xB4, 0xF3, 0xE3, 0x10, 0x7D, 0x79, + 0x1A, 0x4A, 0x74, 0xBB, 0x3C, 0x48, 0x5B, 0x4E, + 0xB5, 0x47, 0xF3, 0x18, 0x04, 0xBD, 0x22, 0xB0, + 0x84, 0x8F, 0x2E, 0x87, 0x00, 0x14, 0x9D, 0xA2, + 0x7A, 0x0C, 0x8C, 0xA7, 0x07, 0xC6, 0xB5, 0x6D + }, + { + 0xC1, 0x66, 0x0A, 0xA5, 0x71, 0xBE, 0x85, 0xBE, + 0xEC, 0xE0, 0x9E, 0x50, 0xB7, 0xCE, 0x1B, 0xEF, + 0xFA, 0x64, 0x9F, 0x41, 0x09, 0x42, 0x39, 0xAA, + 0x16, 0x76, 0x48, 0xBF, 0x15, 0x56, 0xC9, 0xE6, + 0xA2, 0x53, 0x57, 0x3B, 0xD5, 0xD0, 0xB8, 0x15, + 0x5E, 0x40, 0x4D, 0x19, 0x14, 0x74, 0x3F, 0x7D, + 0xC2, 0x5D, 0x8F, 0x95, 0x11, 0x83, 0x30, 0x92, + 0x05, 0x63, 0x2C, 0xA1, 0xE9, 0x2F, 0xE0, 0x35 + }, + { + 0x17, 0xC8, 0xD2, 0x7C, 0x78, 0x12, 0xBC, 0x0E, + 0x15, 0x20, 0x71, 0x30, 0x83, 0xDB, 0xD8, 0xF6, + 0x09, 0x0B, 0x01, 0xDA, 0x54, 0x53, 0xE3, 0x36, + 0xDD, 0x51, 0xD9, 0x41, 0x54, 0x37, 0x2D, 0x82, + 0xF0, 0xFA, 0x2C, 0x61, 0xBC, 0xE7, 0x91, 0xB4, + 0xC1, 0xD8, 0x32, 0xEF, 0xF6, 0x0A, 0x5B, 0x0A, + 0x31, 0x96, 0x17, 0x29, 0xC6, 0x7D, 0x34, 0xD3, + 0x67, 0xCB, 0x4D, 0x23, 0x35, 0x7B, 0x58, 0xDE + }, + { + 0x9B, 0xB6, 0x0A, 0x06, 0xA3, 0x91, 0x49, 0x72, + 0xDF, 0x5E, 0x03, 0xAE, 0xC4, 0xF9, 0xB7, 0x9B, + 0xD7, 0x9A, 0xE2, 0x0D, 0x9A, 0xA6, 0x1E, 0xFE, + 0x42, 0x62, 0x63, 0x21, 0x89, 0x2C, 0xE3, 0x93, + 0x5A, 0x59, 0xA9, 0x1C, 0xED, 0x7D, 0x60, 0x17, + 0x8B, 0xF4, 0xE5, 0x7B, 0x21, 0xF8, 0xE0, 0x09, + 0x33, 0x2F, 0x72, 0x10, 0xA7, 0x4B, 0x4E, 0x11, + 0x90, 0xC2, 0xC0, 0x78, 0x3C, 0x8E, 0x62, 0x9B + }, + { + 0x4D, 0xE4, 0x5B, 0x60, 0x06, 0x79, 0xE0, 0xEC, + 0x25, 0x30, 0x5F, 0x75, 0x5D, 0xAD, 0x36, 0xD9, + 0x2A, 0xDA, 0xA3, 0x41, 0x5F, 0xFE, 0x8C, 0xA2, + 0xBD, 0x41, 0xCC, 0x40, 0xCF, 0xED, 0xBB, 0x31, + 0x66, 0xBC, 0x9A, 0x86, 0xC2, 0x6A, 0xCA, 0xCF, + 0x31, 0x6D, 0x73, 0x79, 0xD8, 0xB3, 0x8D, 0xD8, + 0x70, 0xFD, 0x50, 0x3E, 0x47, 0x5B, 0x65, 0x54, + 0xA1, 0x57, 0xE1, 0xD5, 0x2A, 0x5B, 0x46, 0x60 + }, + { + 0xC3, 0x01, 0x27, 0x07, 0x86, 0x39, 0x7E, 0xC0, + 0xF7, 0xD3, 0x1A, 0xF4, 0xC1, 0x66, 0xC0, 0xF9, + 0x75, 0xDF, 0xAA, 0xD2, 0x73, 0x34, 0xE5, 0x89, + 0x05, 0xAD, 0x07, 0x5E, 0xDC, 0xAF, 0x26, 0x13, + 0x44, 0x2C, 0x4A, 0xDB, 0x70, 0x01, 0x4E, 0x37, + 0x4C, 0xF2, 0xF4, 0x3A, 0xBC, 0x6E, 0x38, 0x62, + 0xCB, 0xFA, 0x55, 0xDC, 0x25, 0xED, 0x4C, 0xE3, + 0x31, 0xEB, 0x07, 0x82, 0xCF, 0x05, 0x21, 0x76 + }, + { + 0xD7, 0xC5, 0xE4, 0x1E, 0xBA, 0x46, 0x10, 0x75, + 0xE5, 0x6B, 0xB9, 0x2F, 0x6C, 0x45, 0x3C, 0x39, + 0xCB, 0x6E, 0xF4, 0x48, 0x16, 0x1D, 0xA3, 0xCA, + 0xE0, 0x2C, 0xE3, 0x22, 0xCD, 0xFE, 0x8C, 0x9C, + 0xB5, 0x87, 0x30, 0x4B, 0x32, 0x0F, 0x23, 0x7A, + 0x59, 0x5D, 0x29, 0x41, 0x8A, 0x07, 0xE3, 0xCF, + 0x64, 0x3F, 0x5B, 0x95, 0x24, 0xC5, 0xE4, 0x6B, + 0x21, 0xDE, 0xDA, 0x16, 0x5B, 0x80, 0xDC, 0x30 + }, + { + 0xB7, 0x80, 0x48, 0xD8, 0xE0, 0xF4, 0xF3, 0x12, + 0x69, 0x99, 0x9E, 0x94, 0x07, 0x3A, 0x7D, 0x33, + 0xE3, 0x24, 0x0F, 0xC2, 0x3A, 0x96, 0x9F, 0xDC, + 0xC9, 0x87, 0x5C, 0xBD, 0x19, 0x2F, 0x51, 0x52, + 0x16, 0x99, 0x1F, 0x22, 0x70, 0x0F, 0x98, 0xA5, + 0xDC, 0xE3, 0xF4, 0x48, 0xFD, 0x2A, 0x49, 0x75, + 0xBE, 0xF4, 0x25, 0x27, 0xD3, 0x0E, 0x38, 0xD0, + 0xC5, 0x1A, 0x13, 0xB2, 0xE4, 0x3A, 0x99, 0xD8 + }, + { + 0x7D, 0xFE, 0x50, 0xA0, 0x52, 0x2D, 0xF7, 0x16, + 0x42, 0xF4, 0x88, 0xC5, 0x0C, 0x95, 0x07, 0x1B, + 0x15, 0x3D, 0xC9, 0xDC, 0xAD, 0xAA, 0xBF, 0x26, + 0xF1, 0x21, 0x6E, 0xE1, 0x89, 0xBF, 0xDA, 0x53, + 0x56, 0x9B, 0x1F, 0x70, 0xA1, 0xAF, 0x2A, 0x1F, + 0x2C, 0x6F, 0xCB, 0xBB, 0xF9, 0x83, 0x3C, 0xA2, + 0xC1, 0xC7, 0x4F, 0x93, 0x17, 0xE4, 0x40, 0x6E, + 0xC4, 0xE2, 0x38, 0xC5, 0x52, 0x1A, 0xAC, 0x3A + }, + { + 0x53, 0x82, 0x1D, 0x44, 0xB5, 0xE1, 0xD1, 0xB4, + 0x11, 0xB3, 0xBA, 0x3A, 0x81, 0xB1, 0x8D, 0xC3, + 0x91, 0xAD, 0xF7, 0x7A, 0x78, 0x9C, 0xF2, 0x48, + 0x2C, 0x43, 0xB6, 0xD8, 0xBB, 0x26, 0x8D, 0x7F, + 0x03, 0x26, 0x44, 0xD0, 0xE5, 0xDF, 0x2C, 0x80, + 0xAD, 0x92, 0x34, 0x9F, 0xE0, 0xD6, 0x0F, 0xBC, + 0xB0, 0xFD, 0x86, 0x20, 0xC5, 0xEE, 0xE7, 0xCF, + 0x9E, 0x85, 0xC8, 0x7B, 0xAA, 0x5E, 0x44, 0x9D + }, + { + 0x20, 0xDD, 0xBF, 0x61, 0x52, 0x75, 0x1E, 0xA0, + 0x85, 0xCE, 0xBA, 0xAB, 0x96, 0xE1, 0x68, 0x7E, + 0xF0, 0xC9, 0x0E, 0x33, 0x34, 0xDD, 0xEF, 0x03, + 0x84, 0xD2, 0x5C, 0x4B, 0xEB, 0xF3, 0xAA, 0x40, + 0x0B, 0xBF, 0xAB, 0xD0, 0xDE, 0x54, 0x11, 0xF4, + 0x17, 0x9E, 0x65, 0xE7, 0x8C, 0x11, 0x21, 0x09, + 0x8C, 0x5A, 0x22, 0xBF, 0x85, 0x0A, 0x8B, 0xB0, + 0xE3, 0x54, 0x1E, 0x4A, 0xCA, 0x53, 0x77, 0x45 + }, + { + 0x08, 0x35, 0xC4, 0x3C, 0x8D, 0xFF, 0x36, 0xD1, + 0x47, 0x4E, 0xC2, 0x4D, 0x6E, 0x97, 0xA2, 0x74, + 0x78, 0xAB, 0x0F, 0x47, 0xA0, 0xD2, 0x9C, 0x67, + 0x36, 0xFF, 0xF6, 0x00, 0x17, 0x63, 0x6F, 0x1C, + 0x4A, 0x4B, 0x56, 0x9A, 0x8A, 0x71, 0x29, 0xA3, + 0x44, 0x40, 0xE0, 0x6A, 0x4B, 0xEF, 0xA4, 0x5E, + 0x61, 0xE7, 0x95, 0x46, 0xB2, 0x7B, 0x7B, 0x49, + 0x9E, 0xFF, 0x53, 0x37, 0x48, 0x3A, 0xF5, 0x65 + }, + { + 0xB1, 0xF3, 0x90, 0x3B, 0x3F, 0x95, 0x2E, 0x99, + 0x85, 0x27, 0x1A, 0x54, 0x06, 0x26, 0xF8, 0x62, + 0xA3, 0xF0, 0x61, 0x00, 0x78, 0x48, 0xA4, 0xBF, + 0x93, 0x75, 0x0C, 0x93, 0xE8, 0xA6, 0x54, 0x53, + 0x76, 0x92, 0x38, 0xB5, 0x64, 0x0C, 0xA1, 0x42, + 0x28, 0xAB, 0x3F, 0x2A, 0x3F, 0xF4, 0x8D, 0x13, + 0xC3, 0xA2, 0x97, 0x4F, 0xA1, 0x5E, 0x14, 0x29, + 0x28, 0xFC, 0x6D, 0x0C, 0xD8, 0x3E, 0xCC, 0x18 + }, + { + 0x4E, 0xF9, 0x1B, 0x4C, 0x81, 0x98, 0x4E, 0xFE, + 0x3F, 0x67, 0xE3, 0x31, 0x98, 0x7B, 0x5F, 0x20, + 0xC3, 0x70, 0x4A, 0x93, 0xF1, 0x75, 0xB6, 0x42, + 0x73, 0xE5, 0x66, 0x80, 0xE3, 0xE7, 0x55, 0x83, + 0xD5, 0x2D, 0x0A, 0xD2, 0xE6, 0xBB, 0x2C, 0xAB, + 0xE1, 0xB5, 0xB5, 0xF3, 0x66, 0x2A, 0xFB, 0xB0, + 0x87, 0x26, 0x2B, 0x18, 0x0B, 0x1C, 0x67, 0xE9, + 0x6F, 0x51, 0xDE, 0xA2, 0x2C, 0xB9, 0xE6, 0xE0 + }, + { + 0x5D, 0x8E, 0xB3, 0xEE, 0xC7, 0xB1, 0xC4, 0x79, + 0xFA, 0xF1, 0x4B, 0xDD, 0x82, 0x83, 0x01, 0x67, + 0xF3, 0x5F, 0xA6, 0xA8, 0x73, 0x1E, 0x6C, 0xFC, + 0x50, 0xFA, 0x93, 0xED, 0x72, 0xAF, 0x4A, 0xB9, + 0x4F, 0xC0, 0xDD, 0xC5, 0xC7, 0xB3, 0x4F, 0x14, + 0x82, 0x62, 0x55, 0xA2, 0x8F, 0xCC, 0x45, 0x81, + 0xFF, 0xC6, 0x7F, 0x06, 0xAE, 0x17, 0xFA, 0x3D, + 0xF1, 0x44, 0xC8, 0xC9, 0xD1, 0x8B, 0x05, 0xB7 + }, + { + 0xBB, 0xB2, 0x30, 0xE5, 0x3A, 0x7C, 0xA3, 0xA9, + 0x23, 0x3F, 0x52, 0xE1, 0xE5, 0x6E, 0xCF, 0xBC, + 0x08, 0xFE, 0xBD, 0xCC, 0x7A, 0x55, 0x2A, 0xB4, + 0x76, 0x60, 0xAA, 0x8F, 0x20, 0xD7, 0x65, 0xEE, + 0x2F, 0x96, 0xEC, 0x34, 0x61, 0xC2, 0x3C, 0x8B, + 0xB7, 0xAD, 0xFF, 0x39, 0xF3, 0x82, 0xD1, 0x15, + 0xB3, 0xAB, 0x24, 0x3F, 0xA8, 0x3B, 0xDA, 0xAF, + 0x82, 0x71, 0x98, 0x0D, 0xE1, 0x90, 0xAC, 0x4B + }, + { + 0xCB, 0x0A, 0x5D, 0x5E, 0x38, 0x8F, 0xC2, 0xA0, + 0xCB, 0xC2, 0x07, 0x3C, 0x4D, 0x1B, 0xBF, 0x18, + 0x3B, 0x68, 0x86, 0x98, 0xFB, 0x78, 0x04, 0x10, + 0x50, 0xB4, 0xE9, 0x93, 0x30, 0x79, 0x1F, 0x95, + 0x1E, 0x99, 0x74, 0x1A, 0x12, 0x2A, 0x35, 0xFB, + 0x97, 0x39, 0xC1, 0xBB, 0x35, 0xC7, 0x57, 0x08, + 0x9F, 0xBA, 0xEC, 0x9F, 0x61, 0x7D, 0xB1, 0x5E, + 0x65, 0xBD, 0x5D, 0x14, 0x4B, 0x06, 0x2C, 0x7A + }, + { + 0x0A, 0x43, 0x31, 0xDA, 0x87, 0xEE, 0x4A, 0x89, + 0x8C, 0x78, 0x64, 0x4E, 0x0C, 0xB4, 0x73, 0xCE, + 0x9F, 0xDC, 0xF3, 0x71, 0x6E, 0x94, 0xBD, 0x98, + 0x8B, 0x1F, 0xCD, 0xAB, 0xDB, 0xA0, 0x0B, 0x10, + 0xE1, 0x93, 0xDF, 0x76, 0x81, 0x28, 0xEC, 0xBE, + 0x4D, 0x71, 0x1C, 0x4C, 0xA6, 0x6D, 0x0F, 0xD0, + 0x4E, 0x7F, 0x3C, 0xEF, 0xD3, 0xD1, 0x8B, 0xC3, + 0xF4, 0xD6, 0xD9, 0x95, 0x07, 0xA4, 0x5A, 0x3E + }, + { + 0x7E, 0xF1, 0xBF, 0xD7, 0x02, 0xE0, 0x95, 0xB9, + 0x3D, 0x2E, 0x9F, 0x34, 0xD6, 0x44, 0x41, 0xEB, + 0x68, 0x80, 0x5B, 0x79, 0x1F, 0x58, 0x96, 0x41, + 0x2A, 0x55, 0xCD, 0xCB, 0x13, 0xCE, 0x27, 0x12, + 0xDA, 0x2B, 0xCC, 0x72, 0x9F, 0xA6, 0x06, 0xCD, + 0x0A, 0x66, 0x10, 0x5F, 0x25, 0xA7, 0x99, 0x07, + 0x10, 0x27, 0x35, 0x5E, 0x22, 0xFC, 0x49, 0x95, + 0x8C, 0x0C, 0x3E, 0x47, 0x5E, 0x21, 0x1B, 0x65 + }, + { + 0x41, 0x2B, 0x3A, 0xD4, 0x57, 0x98, 0x0B, 0x6B, + 0xA1, 0x6D, 0x16, 0xD7, 0xAE, 0xBD, 0xB2, 0x2C, + 0xDC, 0x95, 0x80, 0xAC, 0x45, 0x9F, 0xF2, 0xDF, + 0xF6, 0x28, 0x58, 0xA1, 0x9E, 0xE5, 0x41, 0xB2, + 0x3B, 0x07, 0xF3, 0xA8, 0xC1, 0xB9, 0x81, 0x8D, + 0x58, 0x52, 0xA0, 0x0B, 0xE9, 0x7D, 0x9E, 0x53, + 0x13, 0x17, 0xEA, 0xCA, 0x02, 0xF1, 0xFD, 0x98, + 0xBB, 0xC6, 0xF9, 0x42, 0xA5, 0xCA, 0x48, 0xDC + }, + { + 0x3B, 0x88, 0xB7, 0xCD, 0x34, 0x49, 0x0B, 0xBB, + 0x06, 0xF7, 0xEC, 0x10, 0xA4, 0x18, 0x19, 0xAD, + 0xD0, 0xF7, 0x23, 0xA6, 0x8F, 0xF4, 0x45, 0x5F, + 0x2D, 0xC4, 0x85, 0x75, 0xD2, 0xF0, 0xC3, 0xAC, + 0x9A, 0xE5, 0xE7, 0x38, 0xB4, 0x85, 0xC6, 0xBF, + 0x72, 0xC8, 0x74, 0x25, 0x02, 0xD2, 0x21, 0xBB, + 0x8A, 0xEE, 0xC0, 0xEF, 0x23, 0xD4, 0x83, 0x33, + 0xAD, 0xF1, 0x27, 0x7E, 0xC7, 0x6D, 0xE8, 0xDA + }, + { + 0x62, 0x7E, 0x20, 0x88, 0x80, 0x57, 0x7E, 0x35, + 0x6E, 0x35, 0xBA, 0x78, 0x84, 0x46, 0x6C, 0xCE, + 0x2C, 0x31, 0x60, 0xF2, 0xF1, 0x61, 0x71, 0xF3, + 0x26, 0x11, 0xB9, 0x5A, 0xA4, 0xEE, 0x82, 0xAD, + 0x00, 0xD8, 0xD5, 0xE8, 0x56, 0x01, 0xAB, 0x48, + 0x2F, 0xB8, 0xEF, 0xF2, 0xC8, 0x60, 0x18, 0x86, + 0x9E, 0x5C, 0x4F, 0xC6, 0x68, 0x3B, 0xFF, 0x7E, + 0xC6, 0xD7, 0x21, 0x66, 0x79, 0xB6, 0x8C, 0x08 + }, + { + 0x73, 0xE1, 0xCC, 0x23, 0x3E, 0x4D, 0x89, 0xED, + 0x30, 0x04, 0x4D, 0xF6, 0xAD, 0x81, 0x6E, 0xC4, + 0x60, 0xA0, 0x8C, 0xF9, 0x5C, 0x85, 0x97, 0x78, + 0x2C, 0xB9, 0x1D, 0x4D, 0xA1, 0xAA, 0x9D, 0xA2, + 0xB1, 0x49, 0xA4, 0x4A, 0x20, 0xDE, 0x92, 0xE9, + 0xFF, 0x64, 0x03, 0xC0, 0x33, 0x99, 0x85, 0x4F, + 0x20, 0x71, 0x0D, 0x30, 0xCE, 0x7D, 0x1E, 0x8A, + 0xE7, 0xD9, 0x0D, 0xAB, 0xF9, 0x64, 0xF4, 0xCF + }, + { + 0x6F, 0x1C, 0xAD, 0x42, 0xD3, 0xA7, 0x3A, 0x61, + 0x06, 0x92, 0x4F, 0x28, 0xBC, 0xE9, 0xF6, 0x22, + 0x37, 0xD3, 0xD1, 0xA1, 0xB9, 0xFB, 0x4A, 0xC9, + 0x12, 0x96, 0x23, 0x0D, 0x73, 0x48, 0xF7, 0x0A, + 0x4C, 0x11, 0xE1, 0xB3, 0x4D, 0x47, 0xB0, 0xA8, + 0xD2, 0xED, 0xDC, 0x79, 0x40, 0x9F, 0x80, 0x5E, + 0xA0, 0xCA, 0x24, 0x36, 0x70, 0x8D, 0x58, 0x87, + 0xC9, 0xD2, 0x83, 0x22, 0x35, 0x0A, 0x6E, 0x9E + }, + { + 0x06, 0xA9, 0x27, 0x40, 0x15, 0x48, 0x57, 0x2D, + 0x4D, 0xF4, 0x56, 0xDC, 0x0F, 0xAF, 0x32, 0xF7, + 0xDC, 0x35, 0x0B, 0xD7, 0x4D, 0x2B, 0xE0, 0x99, + 0x4E, 0xFF, 0xC0, 0x06, 0x34, 0x9A, 0x06, 0xC3, + 0xD5, 0xB2, 0x70, 0xC0, 0x7E, 0x87, 0x88, 0x2C, + 0x43, 0x6B, 0xC8, 0xD5, 0xA3, 0x7F, 0x72, 0xE5, + 0x46, 0xE8, 0xD4, 0x86, 0xC3, 0x5E, 0x33, 0xD3, + 0x9F, 0x99, 0xD2, 0x64, 0x28, 0xFF, 0x0F, 0xF9 + }, + { + 0x38, 0x40, 0x15, 0x62, 0x84, 0xAD, 0x5F, 0x9C, + 0xA1, 0x3A, 0x1D, 0xC6, 0x21, 0x03, 0xC9, 0xBD, + 0x51, 0xA5, 0x82, 0x92, 0x14, 0xB9, 0xA1, 0xA0, + 0xA7, 0x61, 0x4E, 0xCD, 0xDC, 0x03, 0x81, 0x35, + 0x74, 0xD1, 0x6E, 0x41, 0x9F, 0x79, 0x73, 0x93, + 0x68, 0xD1, 0xE7, 0x3E, 0xBB, 0xDE, 0xE5, 0x6B, + 0x24, 0xC0, 0xF0, 0xCF, 0x8D, 0x02, 0x41, 0xA7, + 0xDF, 0xD6, 0x42, 0x41, 0x43, 0x9C, 0x12, 0x12 + }, + { + 0x22, 0x3F, 0x07, 0x0B, 0x0D, 0x14, 0xDA, 0xF3, + 0xB7, 0x8C, 0xDD, 0xAB, 0x5D, 0xC6, 0xAF, 0xE6, + 0x64, 0x6B, 0xA8, 0x7D, 0x15, 0xE0, 0x5C, 0xDB, + 0x19, 0x99, 0x22, 0x92, 0xB5, 0xC2, 0xB2, 0x06, + 0xC6, 0x16, 0x06, 0xBA, 0xA2, 0x3F, 0xBA, 0x15, + 0x5B, 0x88, 0x6D, 0x79, 0xB3, 0x81, 0xC6, 0x3B, + 0xD5, 0x24, 0x5F, 0x60, 0xFE, 0x38, 0x78, 0x86, + 0xE5, 0x4D, 0x5E, 0x8C, 0x2B, 0xCF, 0x74, 0x88 + }, + { + 0x3D, 0xB1, 0x04, 0x5E, 0xA5, 0x95, 0xF4, 0x5A, + 0x7E, 0x51, 0x79, 0xA0, 0x7E, 0xE6, 0x49, 0x5B, + 0x02, 0x43, 0xE0, 0x0C, 0x00, 0x99, 0xF9, 0x1C, + 0xC5, 0x6C, 0x3B, 0xD8, 0x7F, 0x4A, 0xD2, 0x73, + 0x09, 0x40, 0xFE, 0x0B, 0xC6, 0x3B, 0x32, 0x1C, + 0xA7, 0x5B, 0x22, 0xE3, 0x30, 0x36, 0x17, 0x9C, + 0xD7, 0x94, 0x25, 0x27, 0xB6, 0x99, 0xFE, 0xC3, + 0xDA, 0x2C, 0x6E, 0xAB, 0x8B, 0xBC, 0xD4, 0x8B + }, + { + 0x79, 0x21, 0x1D, 0xA2, 0x78, 0xCD, 0x05, 0xA5, + 0xC1, 0x6F, 0x8E, 0xC1, 0x3B, 0x4B, 0x78, 0x60, + 0xE7, 0xF5, 0xA4, 0xC5, 0x79, 0x6C, 0x3F, 0x5C, + 0x6E, 0x1F, 0x15, 0xE8, 0x86, 0xEA, 0x8A, 0x5F, + 0x2B, 0x2D, 0x7D, 0x75, 0x62, 0x3A, 0x04, 0x2F, + 0xA3, 0xCC, 0x37, 0xEC, 0x4F, 0xC6, 0xC7, 0x04, + 0x16, 0x16, 0xB2, 0xD9, 0x48, 0x80, 0x4D, 0xDB, + 0x94, 0xBA, 0x1C, 0x81, 0x20, 0xBA, 0xFD, 0x9B + }, + { + 0xE7, 0x3B, 0x5E, 0x5C, 0x7B, 0x8A, 0xF1, 0x7D, + 0xDC, 0xAB, 0x68, 0x9C, 0x90, 0x48, 0x53, 0x26, + 0xF6, 0xA8, 0x49, 0xBD, 0x8C, 0xCA, 0x41, 0xFE, + 0xC7, 0x1E, 0x62, 0xA6, 0x32, 0x2D, 0x00, 0x4A, + 0xCD, 0xBF, 0x6A, 0x63, 0x8A, 0x57, 0x98, 0xF9, + 0xAD, 0xBA, 0x60, 0xBC, 0x3C, 0xF1, 0xFB, 0xA9, + 0x6B, 0xCD, 0x83, 0xEB, 0x08, 0x60, 0x78, 0xA9, + 0x5E, 0x1D, 0x87, 0x38, 0x0D, 0xA2, 0xB0, 0x04 + }, + { + 0x5D, 0x7F, 0xD1, 0x0C, 0x55, 0xAC, 0x62, 0x61, + 0x47, 0x41, 0xFB, 0x5B, 0x98, 0x28, 0x40, 0xDC, + 0x4B, 0xC3, 0x1D, 0xA0, 0x79, 0x57, 0x68, 0xCA, + 0x37, 0x5D, 0x43, 0x6A, 0x38, 0x2F, 0x08, 0x24, + 0xF3, 0x50, 0x6F, 0x13, 0xF3, 0xE1, 0x3B, 0xBE, + 0x02, 0xC4, 0x98, 0x5A, 0xAE, 0x65, 0x0C, 0x2C, + 0x24, 0x4B, 0xA4, 0x4A, 0xE0, 0x64, 0xBA, 0x3D, + 0xF9, 0x4B, 0xFB, 0x17, 0x2F, 0xFD, 0x06, 0xED + }, + { + 0xF7, 0xD4, 0x52, 0xF3, 0x81, 0xFC, 0x3D, 0x9D, + 0x18, 0x7E, 0xBD, 0x93, 0x93, 0xA2, 0xC4, 0x71, + 0x7E, 0xC8, 0xEA, 0x04, 0x53, 0x59, 0xD8, 0x31, + 0x81, 0xAC, 0x40, 0x52, 0x6F, 0x86, 0xD1, 0xEF, + 0xD2, 0x7A, 0x78, 0x54, 0x08, 0xC5, 0x26, 0xB3, + 0x3F, 0x0A, 0x12, 0x7A, 0x4C, 0x44, 0x45, 0x8E, + 0x90, 0x80, 0x17, 0x5A, 0xBA, 0x21, 0xBA, 0xC1, + 0x06, 0xA2, 0xDA, 0x08, 0x57, 0x29, 0xA4, 0xF3 + }, + { + 0x53, 0x8B, 0xF2, 0x34, 0xD8, 0xF0, 0x30, 0x7C, + 0x42, 0xAF, 0x9A, 0x7B, 0x7F, 0xA8, 0x45, 0x56, + 0xD7, 0xC1, 0xAD, 0x6F, 0x3A, 0xE4, 0x55, 0x84, + 0x6F, 0x7A, 0x60, 0x57, 0xC5, 0x2C, 0x76, 0x28, + 0xA8, 0x9D, 0x69, 0x5A, 0x88, 0xA7, 0x5E, 0x33, + 0x22, 0x5C, 0x97, 0xA3, 0x72, 0xC6, 0xF5, 0xFF, + 0x6D, 0x72, 0x4C, 0x06, 0x31, 0x53, 0xB1, 0xCE, + 0x7B, 0x60, 0x08, 0xBF, 0x42, 0x73, 0x70, 0x13 + }, + { + 0xCD, 0x93, 0x3E, 0xAB, 0x58, 0x6A, 0xDC, 0x0F, + 0x83, 0x59, 0x5F, 0x31, 0xFC, 0xA6, 0x8D, 0x9A, + 0x22, 0x37, 0x54, 0x53, 0xE6, 0xCB, 0xC7, 0x8C, + 0xE7, 0x43, 0x57, 0x91, 0x14, 0xCF, 0xEB, 0xB2, + 0xCB, 0xE2, 0x6D, 0xDA, 0xE8, 0xBA, 0x48, 0x1C, + 0x9B, 0x67, 0x22, 0x93, 0x3C, 0x58, 0x01, 0x38, + 0x0F, 0xCC, 0xC8, 0x1E, 0xB9, 0xF7, 0xEE, 0xCB, + 0xCD, 0xCC, 0x12, 0xD4, 0x76, 0x69, 0x7F, 0x24 + }, + { + 0x9E, 0x8D, 0x94, 0x1D, 0x35, 0xF8, 0x3B, 0x8A, + 0x0B, 0xCF, 0x4C, 0xAF, 0x31, 0xC5, 0xF6, 0xD9, + 0x04, 0x69, 0x74, 0x56, 0xF3, 0xAE, 0x64, 0x58, + 0xE6, 0x2A, 0x69, 0x5C, 0x1D, 0x58, 0x67, 0xA7, + 0x36, 0x76, 0xEB, 0xE4, 0x4D, 0x2A, 0xF1, 0xD2, + 0x70, 0x4D, 0x8C, 0xD5, 0x48, 0x6E, 0x25, 0x80, + 0xB4, 0xE6, 0x59, 0xE6, 0xBC, 0xAD, 0xF4, 0x10, + 0x63, 0x56, 0x47, 0xF5, 0xE4, 0x08, 0x94, 0xE1 + }, + { + 0x9B, 0x8A, 0x47, 0x3B, 0x94, 0xEE, 0xCF, 0xE7, + 0xE2, 0xA2, 0xB2, 0x24, 0xEC, 0xFA, 0x37, 0x4F, + 0xB3, 0x7B, 0x1A, 0x9B, 0xF4, 0x2B, 0x45, 0x61, + 0x7A, 0x8C, 0x76, 0x31, 0x50, 0xC4, 0xCA, 0xC3, + 0xDD, 0x52, 0xC6, 0x41, 0x58, 0x6E, 0xE7, 0x73, + 0xC9, 0x5B, 0x9F, 0x41, 0xFB, 0xA9, 0xD5, 0x89, + 0xFE, 0x8B, 0x5A, 0x21, 0x98, 0xAD, 0x32, 0x4C, + 0x4C, 0x93, 0x94, 0x44, 0xD8, 0xB9, 0xB1, 0x31 + }, + { + 0x58, 0x98, 0x6C, 0xB1, 0x60, 0x4B, 0x7E, 0x92, + 0x8A, 0x91, 0x37, 0xC0, 0x49, 0xB4, 0x4D, 0xDB, + 0xB4, 0x9B, 0x94, 0xE6, 0x76, 0x64, 0x06, 0x02, + 0x9F, 0xFE, 0x03, 0xCD, 0x83, 0x06, 0x9C, 0x3D, + 0xF4, 0x3F, 0xD5, 0x37, 0x32, 0xE9, 0x1D, 0x5B, + 0x12, 0xDB, 0x10, 0x05, 0x67, 0xE9, 0x2F, 0x8F, + 0xE1, 0xC2, 0x3F, 0xD3, 0x99, 0x10, 0x53, 0x40, + 0x63, 0x80, 0x64, 0xBE, 0xC6, 0xC9, 0x3E, 0xB4 + }, + { + 0xC4, 0x67, 0x9F, 0x31, 0x2C, 0xB9, 0x2F, 0x42, + 0xEF, 0x9A, 0xDF, 0xBF, 0xBF, 0x0D, 0x0A, 0x00, + 0xF6, 0x7D, 0x0F, 0x21, 0xC4, 0xAD, 0xFA, 0x3E, + 0x32, 0x3B, 0xCE, 0xFA, 0xE4, 0x95, 0xD1, 0xBA, + 0xD5, 0x82, 0xAE, 0x94, 0xB9, 0x24, 0x57, 0x7B, + 0x0C, 0x5E, 0x39, 0xF5, 0xBE, 0xA1, 0x46, 0x15, + 0xFD, 0x5F, 0xB9, 0x33, 0x08, 0x0B, 0xA9, 0x77, + 0x28, 0x93, 0xBE, 0x38, 0xC3, 0x01, 0xFC, 0xF3 + }, + { + 0xDF, 0x29, 0x38, 0xF0, 0xDC, 0xC8, 0x74, 0x57, + 0x5A, 0xFD, 0xE1, 0x35, 0x4F, 0x7E, 0x79, 0xEE, + 0xD3, 0x5F, 0xCB, 0x44, 0x67, 0xFA, 0xC3, 0xF6, + 0x09, 0xB6, 0x62, 0x36, 0xCE, 0x11, 0xE4, 0x0C, + 0x6F, 0x8F, 0xDF, 0xCE, 0xD3, 0xBE, 0x64, 0xC4, + 0x29, 0x5F, 0xED, 0x0D, 0x95, 0xC2, 0x71, 0xDD, + 0xDB, 0x1D, 0xA0, 0x68, 0x80, 0x7C, 0xC2, 0x78, + 0xF9, 0xBD, 0x5C, 0x06, 0x9D, 0x79, 0x6E, 0x8E + }, + { + 0x5A, 0x57, 0x78, 0xEE, 0x41, 0x41, 0xF9, 0x01, + 0xE3, 0x31, 0x1B, 0x5B, 0x68, 0xA6, 0x64, 0xC7, + 0xCB, 0x47, 0x03, 0x91, 0x48, 0x15, 0x6D, 0x07, + 0xDB, 0x73, 0xCC, 0xF5, 0xA1, 0xC9, 0x30, 0x10, + 0x4B, 0x83, 0x4C, 0x52, 0xB3, 0x72, 0x2A, 0x23, + 0x80, 0x2A, 0xC9, 0x8A, 0x8D, 0x70, 0x40, 0xF2, + 0xA0, 0x5A, 0x2C, 0x6E, 0x51, 0xFD, 0xBE, 0xB8, + 0x5D, 0x90, 0xA2, 0xB4, 0x02, 0x62, 0x7C, 0xE5 + }, + { + 0x66, 0x83, 0xC8, 0xCE, 0xE5, 0x8F, 0xEA, 0x85, + 0x5D, 0x17, 0x39, 0x49, 0x63, 0xEA, 0xE5, 0xE4, + 0xB8, 0xA5, 0x03, 0x57, 0xB5, 0xE0, 0x7F, 0x64, + 0x63, 0x69, 0x9A, 0xDA, 0x99, 0x6B, 0x7E, 0x35, + 0x3D, 0xF0, 0xA2, 0xEE, 0x21, 0xAF, 0xEE, 0x50, + 0xF3, 0xE9, 0xAF, 0x27, 0x99, 0x75, 0x28, 0xAA, + 0xDF, 0x0F, 0x1F, 0x88, 0x2F, 0x80, 0xE3, 0x88, + 0x85, 0xC4, 0x66, 0xD8, 0x82, 0x81, 0x9B, 0xAF + }, + { + 0x33, 0xA0, 0x9D, 0xAA, 0xC8, 0x8D, 0x69, 0x42, + 0x6E, 0xAB, 0x24, 0xDE, 0x8C, 0xC3, 0x47, 0x3C, + 0x2B, 0x69, 0xC3, 0x5E, 0x16, 0x57, 0x94, 0x84, + 0xC7, 0xD7, 0xD8, 0xD9, 0xFF, 0x0D, 0xA8, 0xD0, + 0xE1, 0x8C, 0x1D, 0xBF, 0x3B, 0x26, 0x2C, 0xBB, + 0x00, 0xF1, 0x3A, 0xC3, 0x78, 0x78, 0xBE, 0x4A, + 0xA4, 0x3A, 0x49, 0xB3, 0x7E, 0x76, 0xB7, 0x87, + 0x49, 0xD8, 0xFC, 0xA7, 0x64, 0x3D, 0x2D, 0x96 + }, + { + 0x14, 0x33, 0x09, 0x22, 0xCA, 0x25, 0x50, 0xDE, + 0x72, 0x30, 0x49, 0x14, 0xD8, 0xCE, 0x19, 0x03, + 0xC0, 0xC8, 0x7B, 0xDE, 0x66, 0x90, 0xF0, 0xEF, + 0x87, 0xAD, 0xE6, 0x6B, 0x04, 0xCC, 0xF5, 0xE5, + 0xF7, 0x9A, 0xEA, 0x0A, 0x0B, 0x0D, 0x5B, 0xEB, + 0x82, 0x70, 0xA7, 0xBF, 0xF0, 0xD5, 0xE1, 0xB8, + 0x9F, 0x43, 0x43, 0xDE, 0xA2, 0xDF, 0x6A, 0x52, + 0x53, 0x23, 0x53, 0x59, 0xCF, 0xB1, 0xFF, 0x44 + }, + { + 0x1E, 0xC1, 0xFD, 0xFD, 0x35, 0xED, 0xE0, 0x3C, + 0x6F, 0x90, 0x49, 0xCE, 0x9A, 0x11, 0xE5, 0x8B, + 0x61, 0xB2, 0x7B, 0x71, 0x7A, 0xF4, 0x4C, 0x10, + 0x22, 0x35, 0x7C, 0x83, 0x72, 0xCF, 0x29, 0x0D, + 0x5D, 0xA3, 0x83, 0x79, 0x7C, 0x33, 0x65, 0x28, + 0xB5, 0x16, 0xC2, 0x0D, 0xAE, 0xD0, 0xB2, 0xC7, + 0x41, 0x23, 0xD5, 0x02, 0xA5, 0xCB, 0xA5, 0xAE, + 0xFF, 0xDE, 0xAB, 0x0B, 0x0E, 0x3F, 0x63, 0x53 + }, + { + 0x8F, 0x8E, 0xF5, 0x2B, 0x1B, 0x43, 0x1A, 0x72, + 0x2D, 0x6D, 0xA4, 0x1D, 0x97, 0x1D, 0x53, 0x5F, + 0x5A, 0xBB, 0x9D, 0xA7, 0xAE, 0x2C, 0xD1, 0x8C, + 0xC3, 0xC0, 0xDF, 0x67, 0x18, 0x8E, 0x80, 0x12, + 0xF0, 0xDC, 0xCB, 0x3A, 0xB9, 0x66, 0x88, 0xFD, + 0xB7, 0xB0, 0xD8, 0xAE, 0x31, 0x43, 0xFF, 0x9B, + 0xD5, 0x76, 0x36, 0xB4, 0x45, 0xCF, 0x4F, 0x25, + 0xED, 0xE9, 0x52, 0xDA, 0x2E, 0x7D, 0xD7, 0x87 + }, + { + 0xC4, 0x7D, 0x34, 0x82, 0x5F, 0x60, 0x74, 0x46, + 0x8E, 0x1D, 0xCB, 0xB4, 0x36, 0x72, 0xB2, 0x58, + 0x44, 0x3B, 0x43, 0x1F, 0xDC, 0x75, 0x83, 0x59, + 0x6C, 0x37, 0x5B, 0xAC, 0x76, 0xD9, 0xB1, 0x8F, + 0x9A, 0x32, 0x36, 0x17, 0x13, 0x36, 0xB8, 0x32, + 0x6B, 0x6C, 0x29, 0x56, 0xB8, 0xFA, 0xBF, 0xCA, + 0x9B, 0x2C, 0xBA, 0xBA, 0x7C, 0xFB, 0x1D, 0x34, + 0x60, 0xD9, 0xA8, 0x6D, 0xB4, 0xD3, 0xA6, 0x09 + }, + { + 0xC0, 0x65, 0xF6, 0x36, 0xBF, 0xC9, 0xF1, 0x4A, + 0x19, 0xD4, 0x91, 0xE1, 0x5C, 0x0A, 0x33, 0x1A, + 0x98, 0x72, 0x7D, 0x6F, 0xE1, 0x4D, 0x8C, 0x8E, + 0x9B, 0x27, 0x4E, 0x58, 0xB9, 0xE2, 0x27, 0x9D, + 0xCC, 0x65, 0x1F, 0x00, 0x82, 0xA0, 0xF6, 0x78, + 0x2F, 0xD9, 0x77, 0x7B, 0x28, 0xF9, 0x00, 0x8D, + 0xD6, 0x42, 0xE3, 0x71, 0x25, 0x53, 0xCE, 0x3C, + 0x3A, 0xEF, 0x9B, 0x39, 0x79, 0x5A, 0x77, 0x46 + }, + { + 0x12, 0xE2, 0xE8, 0x9B, 0x5E, 0x3F, 0x0F, 0x36, + 0x8A, 0x45, 0xA0, 0x4C, 0xD9, 0xCA, 0xDD, 0x02, + 0x3C, 0x93, 0x33, 0x27, 0x58, 0x13, 0x6F, 0x82, + 0x7C, 0x63, 0x81, 0x19, 0x4B, 0x66, 0x4A, 0x65, + 0x4F, 0x24, 0x3B, 0xF0, 0x7D, 0xD9, 0xC7, 0x73, + 0x95, 0x24, 0xC1, 0x6F, 0x39, 0x16, 0xA4, 0xFE, + 0xBD, 0x17, 0x89, 0x39, 0x7F, 0x1D, 0x1A, 0x0C, + 0x94, 0x5B, 0x26, 0xF1, 0xBF, 0xD1, 0x2D, 0x0B + }, + { + 0x9F, 0x14, 0x9B, 0x80, 0x50, 0xF5, 0x0A, 0x78, + 0xC4, 0x22, 0x9D, 0xCA, 0xA3, 0x4A, 0x85, 0xE7, + 0x18, 0x9E, 0xC2, 0xE1, 0x1D, 0xBF, 0xA1, 0x1D, + 0x7C, 0x16, 0xB4, 0x19, 0x4F, 0x61, 0x91, 0xD6, + 0x0E, 0x65, 0x15, 0xC7, 0x13, 0x0B, 0xBD, 0x2B, + 0x8D, 0x50, 0x48, 0xFD, 0x3F, 0xC0, 0x3A, 0xA8, + 0xE0, 0x2D, 0xB9, 0x7F, 0x9F, 0x64, 0xEA, 0x8B, + 0x9F, 0x69, 0xAB, 0x94, 0xD3, 0x3B, 0x21, 0x5B + }, + { + 0x6B, 0x89, 0x8F, 0x01, 0x69, 0x0F, 0x7A, 0xFE, + 0xC7, 0x76, 0xAF, 0xB4, 0x9A, 0xDE, 0x58, 0x7B, + 0xA3, 0x01, 0xF7, 0xC3, 0x05, 0x69, 0xEE, 0xA1, + 0xEB, 0x1E, 0x4E, 0x92, 0xFE, 0x78, 0x8D, 0xD4, + 0x84, 0xE4, 0x8B, 0xBA, 0x4D, 0x36, 0x25, 0xE0, + 0x4C, 0x8B, 0x84, 0xB5, 0xE3, 0x3C, 0xA8, 0x87, + 0x72, 0xEE, 0x2D, 0x50, 0x9B, 0xC2, 0x8B, 0xAC, + 0x5C, 0x60, 0xA4, 0xE7, 0xDC, 0x99, 0x32, 0xC9 + }, + { + 0x94, 0x5A, 0xE6, 0x1D, 0xCE, 0x64, 0x4D, 0xD5, + 0x61, 0x15, 0x5C, 0x37, 0x94, 0x1B, 0x92, 0xFA, + 0x8A, 0xAE, 0x6C, 0x22, 0x08, 0x74, 0x2A, 0xCF, + 0x01, 0x11, 0xBB, 0x66, 0x7A, 0x1B, 0x7A, 0xC5, + 0x8F, 0x66, 0x98, 0xAA, 0x8A, 0x46, 0xB9, 0x77, + 0x5C, 0xC1, 0xD0, 0x31, 0x88, 0x77, 0x5D, 0xF8, + 0x6B, 0x85, 0x06, 0x98, 0x70, 0x8F, 0xF6, 0x73, + 0x44, 0x1B, 0xD8, 0x58, 0x99, 0xE4, 0xD5, 0xF3 + }, + { + 0xF5, 0xFA, 0x2B, 0x6E, 0xC1, 0x9F, 0xF6, 0x82, + 0x25, 0xE9, 0x96, 0x92, 0x2F, 0x7F, 0xFB, 0x2F, + 0xAD, 0x76, 0xAB, 0xF1, 0x29, 0x8A, 0x77, 0xBE, + 0xB0, 0xC6, 0x6D, 0xEC, 0xF2, 0x8F, 0x9B, 0x4D, + 0x75, 0xDB, 0xA0, 0x92, 0x5B, 0x63, 0x35, 0x43, + 0xB9, 0xD8, 0xD0, 0x27, 0x12, 0x17, 0xFE, 0x3A, + 0x8B, 0xB3, 0x14, 0xC3, 0xA7, 0x45, 0x96, 0xC4, + 0xDB, 0xDA, 0x30, 0x55, 0x26, 0x5B, 0x33, 0x8F + }, + { + 0x6C, 0xA2, 0x2A, 0xB8, 0x5A, 0xCB, 0xEB, 0x84, + 0xE5, 0xB4, 0x5C, 0x5F, 0x1C, 0xC8, 0xC8, 0x99, + 0xB0, 0x20, 0xFB, 0xED, 0x98, 0xA0, 0x77, 0x19, + 0xC1, 0x42, 0xAE, 0x80, 0x5D, 0xCF, 0xB0, 0x94, + 0xB4, 0x30, 0x4E, 0x9C, 0xFA, 0x9A, 0x96, 0x21, + 0xEA, 0x05, 0x96, 0xF5, 0x0F, 0xAC, 0xE0, 0xE3, + 0xDE, 0x62, 0x4F, 0x2C, 0x06, 0x28, 0x76, 0xB5, + 0x9F, 0x30, 0xC2, 0x70, 0x97, 0xB2, 0x56, 0x75 + }, + { + 0xFF, 0x67, 0x74, 0x07, 0x30, 0xEC, 0xC4, 0xA9, + 0x60, 0xB0, 0x73, 0xEA, 0x89, 0xEF, 0x9C, 0xF1, + 0xF0, 0xC5, 0xBB, 0x5B, 0x9F, 0x9E, 0xA0, 0x50, + 0x60, 0x54, 0x58, 0xE8, 0x9D, 0x21, 0x3D, 0xDF, + 0xD7, 0x52, 0x22, 0xB3, 0xF2, 0xF6, 0x99, 0x9B, + 0x6C, 0x22, 0x94, 0xBB, 0x0E, 0xC1, 0x28, 0x98, + 0xE5, 0x55, 0x5E, 0xB1, 0x3B, 0xBB, 0x69, 0x67, + 0xFE, 0x63, 0x80, 0x1E, 0xC3, 0xAB, 0xBF, 0x26 + }, + { + 0xCA, 0x8F, 0xDB, 0xE9, 0x1C, 0xBD, 0xF4, 0xF2, + 0x1A, 0xE3, 0x0A, 0x27, 0x94, 0xC3, 0x5C, 0x51, + 0xF1, 0xF2, 0xD7, 0xCD, 0x96, 0x7B, 0xDC, 0xF5, + 0x53, 0xCC, 0x15, 0x98, 0x1A, 0xFA, 0xE3, 0xB7, + 0x93, 0x02, 0x08, 0x83, 0xF2, 0x01, 0x66, 0x44, + 0xA8, 0xBA, 0xF3, 0xCA, 0xDF, 0x49, 0x68, 0xCE, + 0xCD, 0xB9, 0x3E, 0x4B, 0xDE, 0x7D, 0xB5, 0x0F, + 0xB7, 0x3B, 0x66, 0xC9, 0x7A, 0xDC, 0x16, 0xB1 + }, + { + 0x80, 0xF5, 0x04, 0xAE, 0x71, 0xA5, 0x6D, 0x74, + 0x36, 0xED, 0x07, 0x9A, 0x65, 0x4C, 0x17, 0x6E, + 0xDE, 0xD9, 0xD3, 0x8B, 0x71, 0xA8, 0xB6, 0xCE, + 0xBD, 0x7A, 0x1C, 0x3E, 0x3D, 0xCE, 0x4E, 0x23, + 0xCE, 0x0D, 0xB8, 0x49, 0xCA, 0x12, 0xBD, 0x41, + 0x84, 0x21, 0x7D, 0x48, 0x94, 0x26, 0xC9, 0xE6, + 0x1B, 0x46, 0x58, 0xB3, 0x88, 0xCE, 0x8E, 0x71, + 0x5D, 0x21, 0xCD, 0x38, 0x31, 0x75, 0x5A, 0x66 + }, + { + 0x7E, 0x3A, 0xC4, 0x07, 0x4F, 0xE7, 0xBE, 0xD4, + 0x03, 0x7F, 0x8B, 0xA4, 0xF3, 0xE8, 0x85, 0xAC, + 0xDB, 0xB0, 0x02, 0x88, 0x9C, 0x26, 0x8F, 0x80, + 0xBD, 0x4C, 0x10, 0x4E, 0xD4, 0x79, 0xCA, 0xF4, + 0x6A, 0x6A, 0xED, 0x6A, 0xE7, 0x18, 0xD4, 0xA9, + 0x8B, 0xE7, 0x36, 0x0A, 0xD6, 0x62, 0x2D, 0x26, + 0xBA, 0x1B, 0xFF, 0xEF, 0x14, 0xAB, 0xC8, 0x27, + 0x2F, 0x79, 0x60, 0x7B, 0x05, 0x33, 0x8C, 0x91 + }, + { + 0x87, 0x2C, 0x7F, 0x28, 0x9D, 0x41, 0x20, 0x65, + 0x90, 0xFE, 0xD3, 0x70, 0xCC, 0xA0, 0x69, 0x5F, + 0xF7, 0xDB, 0x39, 0x02, 0xBE, 0x2A, 0xEB, 0x40, + 0xD4, 0xEE, 0xCC, 0xFF, 0x47, 0xBA, 0x91, 0x07, + 0xB4, 0xFC, 0xAF, 0xCB, 0x65, 0x49, 0xFF, 0xCD, + 0x42, 0xEA, 0xEA, 0x1F, 0xE7, 0x3A, 0x2A, 0xA2, + 0x93, 0x66, 0xC8, 0x95, 0xA9, 0x78, 0x59, 0x79, + 0x09, 0x15, 0xE4, 0xD1, 0x6E, 0x09, 0x12, 0x49 + }, + { + 0x02, 0x59, 0x69, 0x69, 0xA4, 0x81, 0xA1, 0xDB, + 0xCA, 0x1F, 0x0C, 0x90, 0x67, 0x77, 0xAA, 0x76, + 0x23, 0xB1, 0x99, 0x6E, 0x1A, 0xBD, 0xC7, 0xE6, + 0xAD, 0xAA, 0xD8, 0x3E, 0x6A, 0x46, 0x58, 0xEA, + 0x55, 0xB5, 0x32, 0xD2, 0xDF, 0x72, 0x1C, 0x95, + 0x3E, 0x80, 0x70, 0x31, 0x6E, 0x7E, 0x4A, 0x30, + 0x0C, 0xC5, 0xC9, 0x14, 0xB4, 0x3C, 0xCC, 0xCD, + 0x61, 0x7C, 0xD4, 0x5F, 0x27, 0x34, 0x53, 0x96 + }, + { + 0xBB, 0xF6, 0xEB, 0x01, 0x10, 0x76, 0x96, 0x28, + 0x35, 0x5F, 0xF4, 0xA0, 0x4C, 0xE6, 0x68, 0x9E, + 0xDC, 0x0E, 0x44, 0x9F, 0xE2, 0x90, 0x13, 0x97, + 0xF8, 0x91, 0x84, 0x4D, 0xE9, 0x5B, 0x18, 0x6B, + 0xC8, 0x64, 0xC3, 0x4C, 0x3D, 0x5C, 0x2A, 0xE6, + 0xFB, 0x96, 0xD9, 0x06, 0xEC, 0x19, 0x9D, 0x9F, + 0x5F, 0x1F, 0x3D, 0x73, 0x28, 0xF9, 0xDE, 0xF1, + 0x0D, 0x3C, 0x93, 0x1F, 0xAC, 0x13, 0x17, 0x97 + }, + { + 0xD1, 0x61, 0x68, 0x19, 0xCD, 0xCD, 0x75, 0x3F, + 0x43, 0x3B, 0xAC, 0x06, 0xD6, 0x4A, 0xA6, 0x8D, + 0x8A, 0x4B, 0xEB, 0xB0, 0xEC, 0x66, 0x96, 0xAC, + 0xD5, 0xFA, 0x75, 0x42, 0x9F, 0xBD, 0x01, 0x12, + 0x9D, 0x22, 0x35, 0x93, 0x58, 0x67, 0x84, 0x1D, + 0xDD, 0x19, 0xF1, 0xAD, 0xFD, 0xB4, 0x50, 0xAF, + 0xF2, 0xF4, 0xD9, 0xC1, 0x2A, 0xAF, 0x0B, 0x07, + 0x15, 0xA5, 0xA0, 0x66, 0x64, 0x48, 0x13, 0xF0 + }, + { + 0x59, 0x1A, 0xAA, 0x79, 0xFC, 0x54, 0x63, 0x70, + 0x08, 0xF7, 0x25, 0x4A, 0xEB, 0x21, 0xEB, 0x0D, + 0x1D, 0xAE, 0x62, 0xE3, 0xE8, 0xCA, 0x37, 0xDD, + 0xB4, 0xDA, 0xE9, 0x09, 0x36, 0x70, 0xB9, 0x8B, + 0x93, 0x0C, 0x04, 0xBE, 0xDC, 0x41, 0xF4, 0x89, + 0x3B, 0xFB, 0xE7, 0x09, 0x9F, 0x39, 0x7D, 0xA9, + 0xAD, 0x07, 0x98, 0x01, 0x65, 0x4E, 0x74, 0x85, + 0x3D, 0x31, 0xDE, 0x41, 0x1C, 0xB4, 0x04, 0xBD + }, + { + 0x06, 0x52, 0x16, 0x66, 0x9E, 0xFA, 0x1A, 0xD6, + 0x15, 0x08, 0x8E, 0x49, 0x4C, 0x78, 0x8D, 0xDA, + 0xD0, 0xD2, 0xF2, 0xC1, 0x3D, 0xF9, 0x9D, 0x79, + 0xEB, 0xA4, 0x30, 0xDE, 0x91, 0xDA, 0x5B, 0x2E, + 0x8F, 0x57, 0x72, 0x64, 0xC4, 0x52, 0xA1, 0xB3, + 0x98, 0x5D, 0xDD, 0xEB, 0x49, 0x7A, 0x70, 0x23, + 0xE5, 0x88, 0xE1, 0xE1, 0xAB, 0xC7, 0x42, 0x3E, + 0x12, 0x7E, 0x65, 0x06, 0xD4, 0x40, 0x6F, 0xFE + }, + { + 0x69, 0x1F, 0xB3, 0x17, 0x45, 0x2F, 0x85, 0xAF, + 0x0C, 0x02, 0xF4, 0x04, 0xEB, 0x35, 0x61, 0xFB, + 0xCC, 0x3B, 0xD9, 0xC6, 0xC2, 0x5B, 0x9A, 0x21, + 0x8D, 0x68, 0x80, 0x05, 0x40, 0x9E, 0xCD, 0xDD, + 0x7D, 0xAB, 0x28, 0x1C, 0x91, 0xB1, 0xBE, 0xC6, + 0xF6, 0xA5, 0x90, 0x4F, 0xBC, 0xDF, 0x0A, 0x2B, + 0xFA, 0x30, 0x7A, 0xD7, 0xB0, 0x82, 0xC3, 0x72, + 0xDC, 0x84, 0x0D, 0x8E, 0x8A, 0xC7, 0x59, 0xBF + }, + { + 0xE0, 0xAF, 0xAD, 0x63, 0x83, 0x75, 0x82, 0x50, + 0x52, 0x5E, 0xD0, 0xBB, 0xE5, 0x1E, 0x4F, 0x48, + 0x4B, 0xE4, 0xE6, 0x16, 0x32, 0x1F, 0x26, 0x60, + 0x16, 0x88, 0xAD, 0x51, 0x51, 0x82, 0xE3, 0x1F, + 0x40, 0x1A, 0xA8, 0x31, 0xEE, 0x43, 0xFB, 0xB4, + 0xB8, 0x0E, 0x76, 0x9D, 0xEE, 0x41, 0x78, 0x3A, + 0x11, 0xC5, 0x7D, 0x9F, 0xE0, 0x76, 0xFB, 0x06, + 0xC3, 0xF9, 0xE5, 0x0F, 0xD3, 0xB9, 0xCB, 0xC5 + }, + { + 0x3A, 0x88, 0x30, 0x9D, 0xDB, 0xB4, 0x90, 0x79, + 0x9A, 0x0A, 0xC4, 0xF3, 0xFB, 0x74, 0x38, 0xF7, + 0xDC, 0x86, 0x90, 0xBA, 0xEC, 0xB4, 0x4E, 0x80, + 0x74, 0x8D, 0xEE, 0xE7, 0x39, 0xE7, 0x75, 0x7C, + 0x48, 0xFE, 0xAD, 0x34, 0x1F, 0x9D, 0x8A, 0x8F, + 0x50, 0xA8, 0x49, 0xEC, 0x1A, 0x4C, 0x3E, 0x11, + 0x70, 0xC1, 0x6D, 0x79, 0xB4, 0xC1, 0x82, 0x73, + 0x2B, 0x44, 0xF0, 0x1A, 0xF2, 0x8B, 0xBE, 0xF6 + }, + { + 0x9B, 0x3E, 0xFC, 0xB1, 0xEF, 0xC3, 0x4D, 0xC8, + 0xC0, 0xAC, 0x44, 0x1F, 0xFA, 0x34, 0x50, 0xF3, + 0x35, 0x96, 0x8A, 0xF5, 0x3A, 0xD3, 0x20, 0x91, + 0xED, 0x54, 0xD1, 0x7F, 0x28, 0x0A, 0x09, 0x47, + 0xEC, 0xC1, 0x62, 0x22, 0xA0, 0xC4, 0xAA, 0x1B, + 0xFB, 0x30, 0x12, 0xFF, 0xBA, 0xA6, 0x35, 0x67, + 0x40, 0x32, 0x7E, 0xDD, 0xF2, 0xA5, 0x2B, 0x86, + 0xD4, 0xDD, 0x2F, 0x4C, 0xB3, 0x2E, 0x56, 0x4C + }, + { + 0x2A, 0xAE, 0x30, 0x8F, 0x61, 0xC7, 0x2B, 0xDF, + 0x09, 0x11, 0xD1, 0x08, 0x61, 0xA3, 0xDB, 0x46, + 0xE9, 0x01, 0x01, 0xDC, 0x7B, 0xA9, 0x9F, 0x5A, + 0x0B, 0xD2, 0x49, 0x0B, 0xD5, 0x68, 0x02, 0x61, + 0x4C, 0x94, 0xCB, 0x74, 0x23, 0xF0, 0x53, 0x6B, + 0x0F, 0x5B, 0x1C, 0xAD, 0x26, 0x9D, 0x6B, 0x8D, + 0x0F, 0x55, 0x8B, 0xE1, 0x2F, 0x0E, 0xF0, 0x20, + 0x51, 0x5E, 0x9C, 0x43, 0xEC, 0x62, 0x63, 0x8F + }, + { + 0x75, 0xE6, 0xFC, 0x84, 0x35, 0x8A, 0xE6, 0x32, + 0xA6, 0x51, 0x4F, 0xFB, 0xD3, 0x9B, 0x37, 0xA3, + 0x6C, 0x88, 0xF1, 0xE5, 0xD5, 0x12, 0xF1, 0xD1, + 0x66, 0xF6, 0xDE, 0xD5, 0x74, 0x73, 0xF6, 0x12, + 0x22, 0x2C, 0x2A, 0x72, 0x30, 0x75, 0x7F, 0x5F, + 0x2A, 0x06, 0x18, 0xE1, 0xF9, 0x26, 0x8E, 0xDE, + 0xD8, 0x84, 0x79, 0xFF, 0x12, 0x00, 0x0A, 0x80, + 0x04, 0x76, 0x30, 0xF3, 0xA2, 0x82, 0xA2, 0xC9 + }, + { + 0x65, 0x86, 0x57, 0x21, 0x88, 0xC7, 0xE7, 0x52, + 0x91, 0xD3, 0x32, 0xD7, 0x14, 0x5B, 0x69, 0x3F, + 0xED, 0x34, 0xD3, 0xE0, 0x73, 0x11, 0x2A, 0x4A, + 0x30, 0xAD, 0x17, 0x48, 0xC7, 0x0B, 0x2D, 0xB4, + 0xB1, 0x2C, 0x3F, 0x5E, 0x5F, 0xA4, 0xC5, 0xCD, + 0xC2, 0x90, 0xA1, 0xF9, 0x72, 0x6B, 0xCD, 0x9C, + 0xE5, 0x1C, 0xE0, 0x24, 0x68, 0xA9, 0x54, 0x8F, + 0xC5, 0xA2, 0x84, 0x53, 0x11, 0x0E, 0x3B, 0x33 + }, + { + 0xE2, 0x34, 0x4A, 0xD4, 0x0D, 0xF1, 0x4B, 0x2B, + 0xC2, 0x31, 0x1B, 0xFE, 0x0D, 0xF8, 0x9C, 0x58, + 0xCE, 0x60, 0xFA, 0xEB, 0x0E, 0x6C, 0x56, 0xDB, + 0x96, 0xD6, 0x91, 0x7B, 0x3D, 0x96, 0x7A, 0xE1, + 0x33, 0x2B, 0xC3, 0x75, 0x4C, 0x2D, 0xAE, 0xEA, + 0x35, 0x76, 0xDB, 0xF7, 0xD5, 0xE6, 0x5C, 0xDE, + 0xFD, 0x26, 0xEE, 0x05, 0x37, 0x52, 0x26, 0xB3, + 0xB4, 0x80, 0xD0, 0x41, 0x39, 0xD1, 0x11, 0x59 + }, + { + 0x20, 0x25, 0xBA, 0xA6, 0x2C, 0x78, 0x0C, 0xA2, + 0x49, 0x0C, 0xD7, 0x63, 0x0E, 0xBC, 0x83, 0x58, + 0xC2, 0x0B, 0x37, 0xFE, 0xEB, 0x48, 0x2D, 0xD1, + 0xEE, 0x50, 0xC6, 0x68, 0xA6, 0xEE, 0xE6, 0xBC, + 0xAD, 0x18, 0xB4, 0xC3, 0xCC, 0xA2, 0x13, 0x9C, + 0x99, 0xEE, 0x18, 0xD6, 0xBD, 0x83, 0xB0, 0x38, + 0x9E, 0xBE, 0xE8, 0xFE, 0x42, 0xB3, 0xFC, 0xC9, + 0x26, 0x44, 0xF3, 0x34, 0xA1, 0x5A, 0x7F, 0x44 + }, + { + 0x76, 0x0E, 0x97, 0x7F, 0xA2, 0x94, 0x17, 0xAF, + 0x93, 0x73, 0x41, 0x30, 0x1F, 0x8B, 0x77, 0xB4, + 0x45, 0x2C, 0x31, 0x0D, 0xE6, 0xD9, 0x09, 0x2E, + 0x08, 0x65, 0x32, 0x53, 0xC3, 0x73, 0xE1, 0x74, + 0x26, 0x01, 0x00, 0x0A, 0x2C, 0xB6, 0x7A, 0x6C, + 0xDC, 0x39, 0x80, 0x6D, 0x4D, 0xD1, 0xDB, 0x51, + 0x67, 0x48, 0xC5, 0x9D, 0xA9, 0x16, 0x6B, 0x0A, + 0x95, 0xC9, 0xF8, 0x85, 0xD3, 0xB3, 0x90, 0xEB + }, + { + 0xF0, 0x2B, 0xE3, 0xED, 0x8D, 0x5F, 0xF1, 0x0B, + 0xF4, 0x61, 0x46, 0x65, 0xD3, 0x78, 0xEE, 0x07, + 0x93, 0x80, 0x35, 0x12, 0x17, 0x06, 0x2A, 0xF8, + 0x8C, 0x99, 0x1C, 0x72, 0x76, 0x3A, 0xB4, 0xD7, + 0x41, 0x47, 0x0A, 0x32, 0xA9, 0x43, 0x14, 0x75, + 0xD0, 0x02, 0x6C, 0xB9, 0xFA, 0xE7, 0xD9, 0x45, + 0xBE, 0xBC, 0x11, 0x49, 0x37, 0x51, 0xDB, 0x96, + 0x4D, 0xC9, 0xC2, 0xBD, 0x2F, 0x69, 0xB5, 0xEE + }, + { + 0x97, 0x2E, 0x10, 0x76, 0x92, 0xC1, 0xBC, 0x5E, + 0x60, 0x4D, 0x35, 0x69, 0x1D, 0x22, 0x0A, 0xF6, + 0xF5, 0x87, 0xCD, 0xA2, 0xCD, 0x23, 0x3A, 0x10, + 0x2A, 0x92, 0x91, 0xEB, 0x85, 0x16, 0x97, 0x76, + 0x30, 0x37, 0x16, 0xF2, 0xA8, 0x40, 0xB3, 0x9B, + 0x68, 0x27, 0xA0, 0xAF, 0x3B, 0x66, 0xB3, 0xD7, + 0xF9, 0x5B, 0x88, 0x3E, 0x18, 0x38, 0xC4, 0xF2, + 0x00, 0xE5, 0x9C, 0x4B, 0x9E, 0x1B, 0xEB, 0x60 + }, + { + 0x59, 0x0B, 0xDC, 0x15, 0x68, 0xDF, 0x6D, 0xE0, + 0xC1, 0x94, 0x21, 0x9E, 0x5B, 0x64, 0xF6, 0x37, + 0x5E, 0x46, 0xC3, 0x4F, 0x30, 0x6E, 0x9D, 0x62, + 0xBC, 0x64, 0xCD, 0xC8, 0xB7, 0x22, 0x94, 0x78, + 0xB9, 0xED, 0xCE, 0x6D, 0xCB, 0xB1, 0x15, 0x42, + 0x6B, 0x74, 0x8D, 0x60, 0x75, 0x73, 0x33, 0xF5, + 0x5B, 0x11, 0x2B, 0x46, 0x23, 0xED, 0xDD, 0xAF, + 0x40, 0x01, 0x4F, 0xF1, 0xEE, 0x93, 0x65, 0x51 + }, + { + 0xEB, 0x44, 0xBE, 0x01, 0x9D, 0x07, 0xA7, 0x64, + 0x62, 0xD4, 0xF2, 0x10, 0x65, 0x0B, 0x38, 0x36, + 0xC9, 0x01, 0xBC, 0xD7, 0x99, 0xF6, 0x17, 0xF8, + 0xD7, 0xA7, 0x64, 0x51, 0xC1, 0x60, 0x0F, 0xE8, + 0xCB, 0x22, 0x29, 0xB4, 0x94, 0xDB, 0x30, 0x66, + 0xAC, 0x43, 0x57, 0x38, 0x3B, 0xFD, 0x12, 0x37, + 0xE3, 0xD7, 0x9B, 0x89, 0xC6, 0x7B, 0x7C, 0xD9, + 0xAF, 0xBF, 0xCF, 0x2E, 0xB6, 0xA7, 0xE3, 0xB2 + }, + { + 0x92, 0xC5, 0xE9, 0x15, 0x04, 0x54, 0x7A, 0x09, + 0x9B, 0x5A, 0x50, 0xA3, 0x48, 0x40, 0x95, 0xFB, + 0x80, 0x29, 0xE4, 0x6F, 0xEA, 0x48, 0x22, 0xE9, + 0x57, 0xE5, 0x2F, 0xAE, 0x08, 0x4C, 0xFF, 0xE7, + 0x71, 0x9A, 0xC1, 0x5E, 0xA3, 0xB7, 0x7B, 0x2D, + 0xB1, 0x2A, 0x34, 0x6F, 0x91, 0xA4, 0x84, 0x9B, + 0x9D, 0x05, 0x00, 0x4F, 0x97, 0x79, 0x4E, 0xD3, + 0x72, 0x59, 0x11, 0x2D, 0x73, 0x1C, 0x05, 0x37 + }, + { + 0x7E, 0x4C, 0x55, 0x42, 0xD5, 0x27, 0xAA, 0x4A, + 0x70, 0xDA, 0x4D, 0xD5, 0x70, 0xFF, 0x0A, 0xAC, + 0xBC, 0x01, 0xB0, 0x30, 0xCA, 0xB0, 0xE3, 0x6A, + 0x4A, 0xEB, 0x3C, 0x3D, 0x7D, 0x37, 0xC6, 0x52, + 0xB2, 0xDB, 0x93, 0x53, 0xC9, 0x28, 0x1A, 0x59, + 0xB1, 0x10, 0xE2, 0x99, 0xF5, 0xDD, 0xBD, 0x0C, + 0x5E, 0xA9, 0x94, 0xF9, 0x02, 0xF3, 0xDF, 0x50, + 0x29, 0x34, 0xC3, 0x80, 0x2A, 0xA5, 0xC7, 0xE5 + }, + { + 0xF1, 0x51, 0xA6, 0xA8, 0x7E, 0x15, 0xA6, 0xF0, + 0xD1, 0x52, 0xFA, 0xBC, 0xB1, 0x06, 0x25, 0xCB, + 0xCA, 0x72, 0x67, 0xA7, 0x21, 0x31, 0xBD, 0xFC, + 0x9A, 0x15, 0xE8, 0xC9, 0x17, 0x8A, 0x6C, 0xA1, + 0x1F, 0x58, 0xA3, 0x9D, 0xF4, 0xA6, 0x43, 0x37, + 0x3F, 0xDD, 0x4F, 0x36, 0x14, 0x72, 0x27, 0x30, + 0xEB, 0xF9, 0x12, 0x62, 0xD4, 0xCC, 0x2C, 0x6D, + 0xDF, 0x20, 0x37, 0x54, 0x58, 0x00, 0x38, 0x10 + }, + { + 0xDC, 0x9D, 0x9F, 0x02, 0xFB, 0x8F, 0xC9, 0x54, + 0x42, 0x2B, 0x8E, 0x6A, 0x1A, 0x85, 0x99, 0x5A, + 0x8B, 0x03, 0x5C, 0x1B, 0x04, 0xD3, 0x95, 0xA5, + 0x29, 0x5D, 0x4C, 0x44, 0xAF, 0xE4, 0x3B, 0x7E, + 0xE7, 0x69, 0x3D, 0x94, 0x6F, 0x63, 0x80, 0x5B, + 0x45, 0x05, 0xA4, 0xB2, 0x45, 0xC5, 0x57, 0x6C, + 0x63, 0x3C, 0x62, 0xBE, 0x44, 0x96, 0xAD, 0x35, + 0x48, 0xB6, 0xEA, 0x59, 0x2A, 0x5B, 0x2D, 0x81 + }, + { + 0xCF, 0x48, 0x6B, 0xC2, 0x8C, 0xD3, 0xF9, 0xD3, + 0x95, 0xBD, 0x7C, 0x34, 0xAB, 0x39, 0xFF, 0x6F, + 0x40, 0xB6, 0x94, 0x49, 0x1A, 0x3F, 0xE6, 0xC9, + 0xB1, 0xE8, 0x23, 0x8D, 0x9D, 0x65, 0xB1, 0x0A, + 0x5E, 0x3B, 0xA8, 0xDF, 0x28, 0x27, 0x1C, 0x1B, + 0xED, 0x0A, 0x4C, 0x8E, 0x8E, 0x20, 0x57, 0x7E, + 0xEF, 0x69, 0x64, 0x10, 0xAA, 0x25, 0xEB, 0x55, + 0x5D, 0x5F, 0x40, 0x08, 0x84, 0x41, 0xC1, 0x2B + }, + { + 0x0A, 0x3C, 0xB5, 0xCD, 0x6C, 0x1E, 0x87, 0x91, + 0xEB, 0x90, 0xE5, 0x07, 0xBA, 0xD2, 0x54, 0xAF, + 0x7A, 0x69, 0x28, 0xCA, 0x2C, 0xBE, 0xFE, 0xB7, + 0xBC, 0xF2, 0xF5, 0xA2, 0xD3, 0xF3, 0xC3, 0x8F, + 0xA8, 0x93, 0x91, 0xB2, 0xBA, 0xBC, 0x38, 0x30, + 0xCD, 0x1D, 0x90, 0x22, 0xA0, 0x8D, 0x6D, 0xD6, + 0xA5, 0xA8, 0x45, 0x0D, 0xC0, 0x99, 0x2E, 0xBA, + 0x8D, 0xD3, 0x9C, 0x51, 0x76, 0x36, 0xF2, 0x65 + }, + { + 0x00, 0x99, 0x4F, 0x8B, 0x52, 0xBA, 0xFF, 0x1B, + 0x42, 0x09, 0x09, 0x7D, 0x2D, 0xD3, 0x7F, 0xE1, + 0x53, 0xB9, 0xA6, 0xFA, 0x29, 0x44, 0x93, 0x6F, + 0x2F, 0x7F, 0x47, 0x0C, 0x9E, 0x9D, 0x7A, 0x8F, + 0x07, 0xBD, 0xCC, 0xF9, 0xCA, 0xBE, 0x0D, 0x1C, + 0x5F, 0xEC, 0xF0, 0x67, 0x9F, 0x27, 0x19, 0x13, + 0x9B, 0xA6, 0x8A, 0x95, 0x18, 0xDE, 0x59, 0x1E, + 0x82, 0xE3, 0xBD, 0xDD, 0xE2, 0x1C, 0xFA, 0x16 + }, + { + 0x53, 0xFF, 0x45, 0xDB, 0xF6, 0xE9, 0x5F, 0xA1, + 0x60, 0x96, 0x1D, 0xA4, 0x43, 0x9B, 0x9B, 0xAC, + 0xD4, 0x45, 0xBD, 0x0E, 0x7D, 0x2E, 0x80, 0x6E, + 0x2D, 0x1B, 0x15, 0xBB, 0x07, 0xD4, 0x82, 0x89, + 0x7D, 0x81, 0x0A, 0x0E, 0x71, 0x4F, 0x03, 0x3C, + 0x3A, 0x34, 0xE8, 0xF7, 0x66, 0x5C, 0x2C, 0x2A, + 0x56, 0xC0, 0xFA, 0x1E, 0x7A, 0x18, 0x42, 0xD4, + 0x88, 0xC3, 0xEC, 0x6E, 0x43, 0x8C, 0xC4, 0x4E + }, + { + 0xB5, 0xD7, 0x5F, 0x7E, 0x1F, 0xF5, 0xF9, 0x2A, + 0x14, 0x41, 0x58, 0x3C, 0x0E, 0x4D, 0x77, 0x53, + 0x5A, 0x44, 0x9F, 0x2E, 0x9C, 0x83, 0x67, 0x4F, + 0xD3, 0x4B, 0xDC, 0xEB, 0x43, 0x5D, 0xB1, 0x84, + 0x14, 0x4D, 0x4C, 0x25, 0x9C, 0xFB, 0x93, 0xE7, + 0x6B, 0x59, 0xBC, 0xAD, 0x44, 0x21, 0xC0, 0xC5, + 0x5D, 0x4D, 0xFA, 0xCF, 0xC7, 0xB8, 0xCB, 0x96, + 0xC5, 0x32, 0x09, 0x08, 0x0C, 0xB0, 0x66, 0xF4 + }, + { + 0xAB, 0x12, 0x18, 0xFF, 0x5D, 0x73, 0x1C, 0xA1, + 0xC9, 0x61, 0x31, 0x32, 0xC1, 0x1D, 0xB6, 0xCC, + 0x89, 0x32, 0xCB, 0x14, 0xE6, 0x44, 0x97, 0x00, + 0xBD, 0x62, 0x2B, 0x51, 0x46, 0x18, 0x3E, 0xF1, + 0x64, 0x98, 0x86, 0x75, 0xDE, 0xA4, 0x36, 0xB2, + 0x68, 0xB0, 0xD0, 0x98, 0x04, 0x30, 0x8D, 0x8F, + 0xD2, 0xF0, 0x54, 0x38, 0x98, 0x01, 0x06, 0x7C, + 0xBA, 0x1F, 0xB1, 0xBA, 0x02, 0xB6, 0x95, 0x82 + }, + { + 0xFC, 0xFE, 0x80, 0x4C, 0x1B, 0x7C, 0x27, 0xF8, + 0x02, 0xE1, 0x15, 0x40, 0x03, 0xEE, 0x4F, 0x3D, + 0x24, 0x77, 0x3B, 0xA2, 0x05, 0x5F, 0x9C, 0x4C, + 0x57, 0xB3, 0xC3, 0xBB, 0x45, 0x98, 0xAD, 0xF6, + 0x62, 0x56, 0xD1, 0xAD, 0x69, 0x19, 0x02, 0xF4, + 0xB8, 0x5E, 0xBB, 0xF2, 0x44, 0xA0, 0xA7, 0x3D, + 0xA0, 0x6C, 0xC4, 0x3E, 0x13, 0xC6, 0xB8, 0x18, + 0xCB, 0x35, 0x48, 0xB8, 0x74, 0xF7, 0x71, 0x34 + }, + { + 0x16, 0x82, 0x0E, 0x52, 0x04, 0xA7, 0xAC, 0xF1, + 0x1A, 0xB1, 0xFA, 0x85, 0x7B, 0x8A, 0x58, 0x30, + 0x38, 0x43, 0xDD, 0x87, 0xF2, 0x79, 0xAE, 0xEA, + 0xE6, 0xB7, 0x9F, 0x45, 0x18, 0xF0, 0x2E, 0xFC, + 0xD3, 0x6D, 0x7B, 0x5A, 0x08, 0xA7, 0x0F, 0x1F, + 0x0D, 0x29, 0x19, 0x1F, 0x25, 0x3B, 0xD6, 0x20, + 0xF2, 0x1C, 0xF9, 0x62, 0x9F, 0x3C, 0x32, 0xF8, + 0x2F, 0x27, 0xCE, 0xE7, 0x45, 0xC9, 0x5D, 0xC0 + }, + { + 0x19, 0x9C, 0x1D, 0x5B, 0x4F, 0x38, 0xA9, 0x54, + 0xAD, 0xCA, 0xF5, 0xF2, 0x9E, 0x2A, 0x47, 0x92, + 0xEE, 0x31, 0x07, 0xB8, 0x13, 0xF9, 0xA1, 0x98, + 0xAE, 0x37, 0x34, 0x98, 0x69, 0x0B, 0xC9, 0x3B, + 0x57, 0xAE, 0x16, 0xC8, 0x6C, 0x03, 0x9C, 0xB4, + 0x29, 0xFB, 0x6D, 0xD0, 0x2D, 0x05, 0xE1, 0x2A, + 0x85, 0x39, 0x2C, 0x90, 0xD4, 0x6D, 0xD9, 0x32, + 0x0D, 0x14, 0x38, 0x28, 0xD3, 0xDF, 0x32, 0x66 + }, + { + 0x51, 0x3D, 0xF7, 0x24, 0x1E, 0x29, 0x59, 0x8F, + 0xE2, 0xCC, 0x07, 0x06, 0xD4, 0x0A, 0x55, 0x1F, + 0x21, 0xE7, 0xBA, 0x7A, 0xFC, 0xDB, 0x66, 0xBA, + 0x9D, 0x5E, 0xBC, 0xE3, 0x5B, 0xA1, 0x47, 0xF9, + 0x41, 0xCF, 0x4B, 0x2D, 0xA5, 0x58, 0xB1, 0x01, + 0x2B, 0xC3, 0x74, 0x0F, 0xF5, 0xA2, 0x76, 0xD6, + 0x3F, 0xBE, 0x1D, 0x21, 0x85, 0xAE, 0x8C, 0x92, + 0x18, 0xF7, 0xA7, 0x48, 0x83, 0x59, 0x26, 0x79 + }, + { + 0x43, 0xFB, 0xA2, 0x25, 0x79, 0xE6, 0xDB, 0xD0, + 0x1E, 0x13, 0xDB, 0x08, 0xA0, 0x7A, 0xF6, 0xD7, + 0x38, 0x52, 0x3E, 0x15, 0x7E, 0xC3, 0x0F, 0x63, + 0x38, 0x5F, 0x3C, 0x4F, 0x69, 0x9D, 0xF8, 0xB8, + 0x98, 0x2F, 0xB8, 0x25, 0x3A, 0x3C, 0x9F, 0xD8, + 0xA6, 0x9A, 0x6E, 0x05, 0x75, 0xA7, 0xBF, 0xCD, + 0x0E, 0x9D, 0xAA, 0xD4, 0xC0, 0x66, 0x9E, 0xCB, + 0x92, 0x47, 0xB4, 0xEC, 0xF8, 0xB1, 0xF6, 0x1E + }, + { + 0x89, 0x54, 0xC4, 0x0B, 0x8B, 0xD2, 0x12, 0x59, + 0xB8, 0xD4, 0xD7, 0x4C, 0x42, 0x82, 0x26, 0xA6, + 0x8F, 0xA1, 0x45, 0xA2, 0x9A, 0x73, 0x4A, 0x76, + 0x9A, 0x3A, 0x51, 0x23, 0xCF, 0x40, 0x7D, 0xC3, + 0xBB, 0xC1, 0xFD, 0xF5, 0x52, 0x84, 0x64, 0x34, + 0x15, 0x20, 0x17, 0x2E, 0xF3, 0x28, 0x5A, 0x63, + 0xE9, 0xB1, 0x46, 0x8E, 0x21, 0x38, 0xB1, 0x23, + 0x64, 0xEF, 0x28, 0xE5, 0xB8, 0x0E, 0xCC, 0x17 + }, + { + 0x58, 0x2C, 0x7B, 0x6F, 0xFC, 0x77, 0xC7, 0x9D, + 0xE8, 0x1F, 0x8B, 0x9B, 0xFC, 0xA7, 0x36, 0x04, + 0xC8, 0x26, 0x90, 0x56, 0xD1, 0xFF, 0xA0, 0x1A, + 0x0F, 0x25, 0xBE, 0x1D, 0x28, 0x21, 0xF4, 0x4B, + 0xA8, 0x5C, 0x11, 0x09, 0xBD, 0xEC, 0xE8, 0x14, + 0x73, 0xF8, 0x21, 0xD8, 0x57, 0xDF, 0x0F, 0x78, + 0x1B, 0x20, 0x26, 0x79, 0xFC, 0xB8, 0x47, 0xE2, + 0x46, 0x1F, 0xF5, 0x9D, 0x36, 0xE3, 0x49, 0x9B + }, + { + 0xD6, 0xBA, 0x01, 0x67, 0xA7, 0xB1, 0x72, 0x1E, + 0x52, 0x9B, 0xBF, 0xBC, 0xAC, 0x02, 0x20, 0x6F, + 0xFA, 0xC0, 0xD0, 0xDC, 0x55, 0xA6, 0x87, 0xC5, + 0x49, 0xC5, 0x43, 0x3C, 0x5F, 0xFB, 0x69, 0x21, + 0xD2, 0xE2, 0xF3, 0x65, 0x98, 0x81, 0x29, 0xD9, + 0xA7, 0x66, 0xD4, 0x34, 0x50, 0x58, 0x41, 0x3B, + 0xBC, 0x83, 0xB6, 0x9C, 0x2F, 0xF6, 0xBC, 0x54, + 0x01, 0xC8, 0x67, 0x83, 0x09, 0x6D, 0x54, 0xC6 + }, + { + 0x16, 0x6B, 0x91, 0x71, 0x47, 0x11, 0xAF, 0x24, + 0x2E, 0x59, 0xA7, 0x17, 0xB8, 0x37, 0xC7, 0x0C, + 0xDA, 0xA2, 0x26, 0xDE, 0xB0, 0x94, 0x79, 0xBD, + 0xFA, 0xC4, 0x83, 0x0B, 0xB7, 0x6E, 0x87, 0x83, + 0xA7, 0x12, 0x28, 0xE5, 0x09, 0x18, 0xCB, 0xEF, + 0xB8, 0xBE, 0x04, 0x20, 0x60, 0x21, 0xE1, 0x56, + 0xFC, 0xD1, 0xD5, 0x31, 0x2F, 0x06, 0x8D, 0xEA, + 0x6C, 0xA2, 0x3C, 0x2E, 0xA1, 0x51, 0x8C, 0x27 + }, + { + 0xA3, 0x02, 0x9F, 0xEE, 0x92, 0xEC, 0x04, 0xE7, + 0xFB, 0x54, 0x7B, 0x2E, 0xE2, 0xE4, 0xA6, 0x7C, + 0x88, 0x91, 0x01, 0x0D, 0x86, 0x13, 0x42, 0x58, + 0x1E, 0x43, 0x3D, 0x4E, 0x5E, 0xBB, 0x6E, 0xAB, + 0xC6, 0xAE, 0xAF, 0xC1, 0x14, 0x7E, 0xDC, 0x58, + 0xBA, 0x47, 0xD5, 0x63, 0x15, 0x18, 0xC0, 0x99, + 0xE5, 0xD5, 0x4F, 0x31, 0xF1, 0x9A, 0x3F, 0x51, + 0x5B, 0xCE, 0x31, 0x68, 0x42, 0x02, 0x27, 0x82 + }, + { + 0xAC, 0x1C, 0x32, 0x72, 0xBB, 0x48, 0x77, 0x55, + 0x19, 0x96, 0x55, 0xFC, 0xA7, 0x73, 0x88, 0x6D, + 0x51, 0xE5, 0x75, 0x0C, 0xB7, 0xF5, 0x48, 0x09, + 0x4B, 0x99, 0x3F, 0x3B, 0x97, 0xA1, 0x8E, 0xAA, + 0x7D, 0xBB, 0x3C, 0x0A, 0x86, 0x9B, 0x35, 0x19, + 0xF3, 0xC5, 0x70, 0x77, 0x04, 0x51, 0x87, 0xB7, + 0xC5, 0xB5, 0xCD, 0x98, 0x74, 0xBE, 0xB9, 0x34, + 0x32, 0x29, 0x92, 0xCB, 0x86, 0x4C, 0xB6, 0x0C + }, + { + 0x17, 0xA8, 0xB0, 0x2B, 0x4E, 0x6D, 0x6C, 0x65, + 0x24, 0x6D, 0x7E, 0x8B, 0xBF, 0x6F, 0xB8, 0x9D, + 0xAF, 0xAB, 0x42, 0x06, 0xC6, 0x7C, 0xC4, 0x7C, + 0x81, 0xA8, 0xE1, 0xD8, 0xD4, 0x2C, 0xD3, 0xCD, + 0xC6, 0xCD, 0x38, 0x4E, 0xED, 0xF5, 0x3C, 0x85, + 0x55, 0x6D, 0xDC, 0x30, 0x8F, 0xC2, 0x15, 0x3A, + 0x1F, 0x4C, 0x1F, 0xBF, 0xC4, 0x89, 0xB4, 0x53, + 0x18, 0x8B, 0x4C, 0x6D, 0xD7, 0xF9, 0x48, 0x83 + }, + { + 0xB0, 0x09, 0x16, 0xFA, 0x4B, 0x7A, 0x04, 0x51, + 0xCE, 0x58, 0xD9, 0xF3, 0x98, 0xC6, 0x23, 0xF7, + 0x51, 0x1B, 0x70, 0x09, 0x4F, 0xD2, 0x9F, 0x11, + 0xC9, 0x59, 0xD8, 0xFF, 0xA8, 0x83, 0xDF, 0x04, + 0x6A, 0x51, 0xCB, 0x48, 0x89, 0xAE, 0x30, 0x4E, + 0x07, 0x44, 0x02, 0xDD, 0xD7, 0x2B, 0xF7, 0xBE, + 0xB5, 0xF8, 0x68, 0x4D, 0x82, 0xCD, 0x40, 0xF0, + 0x9D, 0x06, 0xAC, 0x2C, 0x15, 0xB6, 0x28, 0x48 + }, + { + 0x12, 0x46, 0x4C, 0x45, 0xEE, 0x33, 0xA6, 0x2B, + 0x79, 0x2F, 0x16, 0x21, 0x0F, 0x44, 0x66, 0x22, + 0xCE, 0xFA, 0x40, 0x7E, 0x5B, 0xBB, 0x57, 0xE5, + 0xE7, 0x3E, 0xC7, 0x92, 0x01, 0x0F, 0xB7, 0x60, + 0x3B, 0xD3, 0x24, 0x67, 0x2D, 0x58, 0x4A, 0x2B, + 0x21, 0xAE, 0x7B, 0x7B, 0x11, 0x1D, 0x41, 0x59, + 0x83, 0x20, 0x68, 0xC5, 0x92, 0xF0, 0x79, 0x7F, + 0xF5, 0x7E, 0x2B, 0x1F, 0xC1, 0x44, 0x72, 0xE8 + }, + { + 0xA5, 0x78, 0x7C, 0x3E, 0x8E, 0xCF, 0xD3, 0x3D, + 0xAE, 0x20, 0x67, 0xB5, 0x6E, 0x9C, 0x9D, 0x04, + 0x0D, 0xA8, 0xC5, 0x01, 0x4B, 0xCC, 0xCA, 0xB4, + 0x85, 0x22, 0xFB, 0xEE, 0xFB, 0x71, 0xC2, 0x33, + 0x13, 0xBE, 0x0E, 0xC5, 0x93, 0x5D, 0x0E, 0x03, + 0x69, 0x67, 0xEB, 0xE2, 0x4D, 0xD2, 0xC6, 0x76, + 0xCD, 0xE3, 0x79, 0x4D, 0x4E, 0xDC, 0x82, 0x81, + 0x19, 0xD4, 0x10, 0xCC, 0x11, 0x5A, 0xE2, 0xD7 + }, + { + 0x66, 0x57, 0xAF, 0x7F, 0xF1, 0xDD, 0xC7, 0xDB, + 0x05, 0xAD, 0x70, 0x98, 0x2A, 0x42, 0x5D, 0xB4, + 0x22, 0xAA, 0x3A, 0x66, 0xD9, 0x39, 0xF4, 0xF9, + 0xCE, 0xE6, 0x92, 0xD6, 0x49, 0xB9, 0x30, 0x72, + 0x8C, 0x39, 0xC4, 0x5A, 0x86, 0xC1, 0xEE, 0x8B, + 0xC6, 0x3C, 0xE1, 0x64, 0x2E, 0xCC, 0xF5, 0x67, + 0xDA, 0xC1, 0xC6, 0x38, 0x0D, 0x7F, 0x4C, 0xFD, + 0x02, 0x7E, 0xBE, 0x55, 0x4E, 0xDF, 0x0D, 0x91 + }, + { + 0x20, 0xBC, 0x6D, 0x24, 0x1A, 0x4B, 0x98, 0xA9, + 0xC8, 0x15, 0xF2, 0xAA, 0x09, 0x3E, 0x28, 0xA8, + 0xC5, 0xC5, 0x2E, 0x7E, 0x19, 0x86, 0x5C, 0xD9, + 0x34, 0xC3, 0xD9, 0xA9, 0x11, 0xD1, 0xA9, 0xCB, + 0xE9, 0x44, 0xF8, 0x86, 0x6B, 0xA2, 0xCC, 0x3E, + 0xF7, 0x0B, 0xD4, 0xF9, 0xA7, 0x84, 0x8F, 0x8F, + 0xE0, 0x13, 0xB9, 0xEC, 0x14, 0xFB, 0xC3, 0xFF, + 0x1D, 0x4C, 0x8B, 0xC9, 0x33, 0xB3, 0x2B, 0xB6 + }, + { + 0x98, 0xB3, 0x6F, 0x22, 0x72, 0x2F, 0xF4, 0x38, + 0x80, 0x8E, 0x10, 0x74, 0xCA, 0x67, 0x1D, 0x26, + 0x7B, 0xB8, 0xB3, 0x29, 0x26, 0x2D, 0xE7, 0x81, + 0x31, 0x03, 0x7A, 0x53, 0x1F, 0xE4, 0xEE, 0xAC, + 0xC0, 0xCD, 0x52, 0xC0, 0xD3, 0x67, 0xB9, 0xCB, + 0xD9, 0x96, 0x97, 0x11, 0x19, 0x5C, 0x2E, 0xFC, + 0xFC, 0xB1, 0xDC, 0x75, 0x44, 0xE9, 0x6D, 0xCD, + 0x24, 0x99, 0xD4, 0x10, 0x25, 0xFE, 0x5B, 0x7D + }, + { + 0x10, 0x74, 0xB3, 0x6A, 0xA4, 0x08, 0x38, 0x9E, + 0x5E, 0x97, 0xC5, 0x75, 0xCF, 0xA5, 0x4A, 0xAD, + 0xBA, 0xDA, 0xC7, 0x27, 0x40, 0x46, 0x0A, 0xE3, + 0x74, 0x12, 0x17, 0x5F, 0x7D, 0x74, 0x73, 0x78, + 0x18, 0x4F, 0x49, 0xBD, 0xFE, 0x62, 0xEF, 0xA0, + 0xE7, 0x92, 0xD3, 0x17, 0x4F, 0x7C, 0x6B, 0x9A, + 0x55, 0x27, 0x60, 0xBF, 0x56, 0x6E, 0x1C, 0x48, + 0xB1, 0x69, 0x13, 0xDD, 0x3A, 0x0F, 0xD6, 0x80 + }, + { + 0x5A, 0x79, 0xE2, 0xEC, 0x85, 0x8C, 0x69, 0x65, + 0x67, 0x3B, 0xD8, 0x98, 0xB1, 0xF4, 0x46, 0x8E, + 0xD4, 0xE6, 0xDF, 0x5C, 0x04, 0x5F, 0xE3, 0x00, + 0x91, 0x0A, 0x51, 0x4A, 0x2A, 0x98, 0x29, 0xA5, + 0x67, 0xE0, 0xF0, 0x1B, 0x2E, 0xCD, 0xA3, 0x00, + 0x69, 0xC5, 0x53, 0xF3, 0x20, 0x7F, 0x52, 0x3F, + 0x72, 0x59, 0x06, 0x96, 0x3B, 0x2A, 0xC2, 0xB8, + 0xA9, 0xD7, 0x0E, 0xC1, 0x72, 0x54, 0x6A, 0xC9 + }, + { + 0x3C, 0x8D, 0x5E, 0x92, 0x78, 0xBA, 0xCF, 0x16, + 0xA7, 0x9D, 0x0C, 0x0F, 0xE8, 0x69, 0x88, 0x95, + 0x0A, 0xB7, 0x29, 0x2F, 0x9D, 0x06, 0xCD, 0x45, + 0x77, 0x5D, 0xCC, 0x50, 0x42, 0xAC, 0xA6, 0xC9, + 0xA8, 0xAD, 0x25, 0x41, 0x39, 0xFD, 0xED, 0x98, + 0xBB, 0xDC, 0x1A, 0x77, 0x6F, 0x59, 0x9D, 0x87, + 0xD5, 0x32, 0x0A, 0x82, 0xD3, 0xD7, 0xD4, 0x23, + 0xA1, 0x35, 0x31, 0x06, 0xC5, 0xF4, 0x3C, 0xA1 + }, + { + 0x7C, 0x96, 0xD2, 0xD4, 0x7B, 0x2D, 0x14, 0x11, + 0x05, 0xD7, 0xB0, 0x23, 0x74, 0x18, 0x99, 0x63, + 0x77, 0x27, 0x77, 0xD3, 0xB5, 0x25, 0x54, 0x67, + 0x70, 0xCF, 0xF7, 0x7F, 0xFD, 0x4B, 0x24, 0x86, + 0x28, 0x34, 0x0B, 0x04, 0x64, 0x40, 0xA9, 0x1E, + 0x7A, 0x51, 0xD4, 0xB6, 0x5D, 0xD9, 0x71, 0x82, + 0x7C, 0x7C, 0x6E, 0xB5, 0x5C, 0xB8, 0x8E, 0xF6, + 0xE5, 0x4D, 0xFF, 0x3C, 0xFD, 0x2E, 0x05, 0x36 + }, + { + 0x77, 0x77, 0x19, 0xD1, 0xC6, 0xBA, 0xE3, 0xB7, + 0xD9, 0x4B, 0xCA, 0xBC, 0x15, 0xB0, 0xE8, 0x58, + 0x8E, 0xD7, 0xBC, 0x71, 0xEF, 0xA9, 0xA1, 0x00, + 0xB0, 0x31, 0xBF, 0x72, 0x4E, 0x11, 0x3A, 0xF3, + 0x2C, 0xB4, 0xA4, 0x10, 0x3F, 0xE1, 0x07, 0xE9, + 0x43, 0x9D, 0x69, 0x15, 0xC6, 0x8C, 0xA3, 0x26, + 0x2F, 0xA6, 0x52, 0xD1, 0x67, 0x81, 0xAF, 0xBC, + 0xA2, 0xE9, 0xCF, 0x47, 0xD4, 0x49, 0x4C, 0x69 + }, + { + 0x2F, 0x97, 0x6D, 0x6F, 0xF2, 0xD0, 0x5F, 0x46, + 0x2B, 0x65, 0xE9, 0x7D, 0x40, 0xC9, 0x3B, 0xFB, + 0x5F, 0x74, 0xEB, 0xFF, 0x1E, 0x94, 0x94, 0x0F, + 0x78, 0xC5, 0xF6, 0x60, 0x97, 0x7B, 0xDA, 0x46, + 0x01, 0x01, 0x66, 0xF0, 0x70, 0xB4, 0x4B, 0x07, + 0x1C, 0x72, 0x36, 0x51, 0xF8, 0xA2, 0x85, 0x4A, + 0xC6, 0xCF, 0x03, 0x83, 0xFD, 0xDF, 0x7B, 0xAB, + 0xF2, 0x6E, 0x24, 0x38, 0x41, 0x43, 0x3A, 0x26 + }, + { + 0xA4, 0x65, 0x55, 0x93, 0x7B, 0x78, 0x61, 0xB9, + 0x6D, 0x33, 0x0B, 0xBC, 0x86, 0x03, 0x8C, 0x39, + 0xA7, 0x8D, 0x37, 0x8E, 0xEF, 0x05, 0x71, 0x10, + 0x76, 0xCE, 0x34, 0xDE, 0xD4, 0x64, 0x78, 0x55, + 0xF1, 0x94, 0x6F, 0x04, 0xEF, 0xD1, 0x02, 0x53, + 0x2A, 0x42, 0xFD, 0xA0, 0x81, 0x48, 0x6D, 0xFF, + 0x41, 0x4A, 0xEE, 0x72, 0xA9, 0xEE, 0xD5, 0x17, + 0x88, 0x67, 0x7F, 0xB8, 0x69, 0x7D, 0x1E, 0x48 + }, + { + 0x90, 0xDA, 0x17, 0x65, 0x23, 0xF7, 0x5C, 0xC4, + 0xF7, 0x55, 0xEF, 0x43, 0xD0, 0xF9, 0x64, 0xB6, + 0xBA, 0x63, 0x50, 0x99, 0xD2, 0x8B, 0x45, 0x1F, + 0x8D, 0xE6, 0xB8, 0xB3, 0x99, 0x51, 0xA4, 0x05, + 0x8F, 0xAC, 0x8B, 0x2A, 0x68, 0xE8, 0xB8, 0x59, + 0x56, 0xA2, 0xEC, 0x52, 0xE6, 0xBF, 0xFE, 0xDE, + 0xFC, 0x6D, 0x46, 0x3B, 0xC0, 0x6B, 0xFB, 0x2E, + 0x5E, 0x64, 0x9F, 0x14, 0x44, 0xFD, 0x93, 0xAA + }, + { + 0xB6, 0xD1, 0x8D, 0x7E, 0x97, 0x39, 0x19, 0x9C, + 0x68, 0xAF, 0x15, 0xB1, 0x72, 0xBE, 0xF6, 0xEB, + 0x21, 0x51, 0x8A, 0x09, 0xA2, 0x8F, 0x40, 0x78, + 0x99, 0x69, 0x04, 0xFF, 0xD6, 0x26, 0x91, 0xE4, + 0x60, 0x57, 0x4A, 0xB8, 0xBB, 0x3C, 0x0C, 0x80, + 0x7D, 0x12, 0xAA, 0xBD, 0x2B, 0x48, 0x4D, 0xE2, + 0x54, 0x18, 0xAE, 0xDC, 0x35, 0x52, 0xEB, 0x41, + 0xFA, 0xC2, 0x22, 0x09, 0xEF, 0x71, 0xBE, 0x79 + }, + { + 0x6F, 0xC2, 0x92, 0xE5, 0x85, 0x67, 0x02, 0x33, + 0xE8, 0x07, 0x4C, 0x83, 0xC8, 0x8C, 0x39, 0x62, + 0xB2, 0x4D, 0x0D, 0xDD, 0x59, 0xFD, 0x9C, 0x6E, + 0x44, 0x53, 0x0E, 0x71, 0xA4, 0x57, 0x40, 0xD8, + 0x91, 0xAC, 0xB4, 0x09, 0x0C, 0x25, 0xF2, 0x4F, + 0x0B, 0x3A, 0xD2, 0x9A, 0x36, 0xCF, 0x08, 0x82, + 0x26, 0xCB, 0x0C, 0x81, 0x81, 0x5A, 0x37, 0x51, + 0x47, 0x41, 0xE9, 0x64, 0x43, 0x61, 0xA8, 0x35 + }, + { + 0x7F, 0x92, 0x36, 0x4A, 0xA9, 0x97, 0x35, 0x6F, + 0xCB, 0xFB, 0x59, 0xBA, 0x1D, 0xF3, 0x38, 0x32, + 0xB6, 0x45, 0x0B, 0x37, 0x68, 0x8B, 0x99, 0xAC, + 0x7F, 0xA9, 0x1B, 0x9B, 0x0F, 0x7D, 0xA6, 0x13, + 0xA3, 0xDA, 0x07, 0x41, 0xF6, 0x9B, 0x12, 0x3D, + 0x17, 0xE9, 0xC2, 0xC2, 0xDA, 0xA5, 0xE7, 0x57, + 0x2C, 0x08, 0x62, 0xA4, 0xE0, 0x1C, 0xBB, 0x3E, + 0x7D, 0xE3, 0xD3, 0x59, 0x26, 0xD0, 0x72, 0x58 + }, + { + 0x9B, 0x3E, 0x3F, 0x1F, 0xA8, 0xD6, 0xED, 0x6D, + 0x29, 0xA1, 0xE3, 0x5B, 0x79, 0xBD, 0x5E, 0x47, + 0x3F, 0xB3, 0x4B, 0xA1, 0xB9, 0xE8, 0x5D, 0x3A, + 0x1D, 0x69, 0x77, 0x46, 0x7D, 0xB0, 0x73, 0x46, + 0x77, 0xD1, 0x24, 0x20, 0x36, 0xDA, 0x60, 0xC1, + 0x5F, 0x9F, 0x95, 0xCC, 0xFE, 0xAA, 0x8D, 0xE2, + 0xFB, 0x93, 0xF8, 0x1A, 0x39, 0x9A, 0xCF, 0xA6, + 0x2E, 0xA3, 0xE1, 0x7C, 0xAF, 0xAE, 0xC4, 0x85 + }, + { + 0x8E, 0x99, 0x7D, 0x28, 0x51, 0xB8, 0x27, 0xE6, + 0xDD, 0x00, 0xD4, 0x3E, 0x63, 0xFB, 0x3F, 0x19, + 0x11, 0xAE, 0x3D, 0x15, 0xA1, 0xED, 0x4C, 0xF5, + 0xA4, 0x4D, 0x16, 0x52, 0x36, 0x3B, 0x53, 0xCB, + 0x35, 0x69, 0xCF, 0x97, 0x7D, 0x60, 0xF4, 0x9A, + 0x5C, 0x34, 0xB9, 0x11, 0x33, 0xE4, 0xD6, 0xC8, + 0xF7, 0x3C, 0x03, 0xCA, 0x05, 0xED, 0xD2, 0x52, + 0xCA, 0x81, 0x71, 0x08, 0x16, 0x52, 0x36, 0xC8 + }, + { + 0x63, 0x1B, 0xA0, 0xDF, 0xBF, 0x9B, 0x09, 0xEF, + 0xC4, 0xCD, 0x25, 0x90, 0x59, 0x85, 0x6D, 0x08, + 0x08, 0x80, 0x43, 0x10, 0x77, 0x36, 0xFB, 0x5A, + 0x42, 0x9D, 0x4A, 0xAC, 0xF4, 0x0F, 0xDA, 0x44, + 0x66, 0x50, 0x65, 0xF1, 0x4C, 0xFF, 0xA9, 0xC1, + 0x85, 0x03, 0x4C, 0x22, 0xB7, 0x63, 0xA7, 0xE4, + 0x0F, 0x09, 0x78, 0xE7, 0xBC, 0xEE, 0xAC, 0xA5, + 0x35, 0x56, 0x7A, 0x3C, 0xA5, 0x5E, 0xC9, 0x86 + }, + { + 0x84, 0x34, 0x0F, 0x62, 0xC1, 0xDF, 0xCA, 0x3E, + 0xCD, 0x0A, 0xBC, 0x72, 0xA9, 0xC5, 0xAE, 0x9B, + 0x47, 0x6B, 0x2E, 0x43, 0xD6, 0xFD, 0x85, 0x03, + 0x35, 0x82, 0x83, 0x3B, 0x09, 0xA8, 0xE2, 0xC8, + 0x03, 0xD9, 0x8C, 0xAF, 0x36, 0xA1, 0x7F, 0x60, + 0x3A, 0xF6, 0xFD, 0xB2, 0x90, 0x5D, 0xC7, 0x4B, + 0x3A, 0xEE, 0x88, 0xD5, 0x70, 0x60, 0x17, 0x4C, + 0xF5, 0x2E, 0x87, 0xF6, 0xDD, 0x3E, 0x51, 0x71 + }, + { + 0x9B, 0xD6, 0x30, 0x6B, 0x7F, 0x02, 0x2A, 0x38, + 0x83, 0x9B, 0xCF, 0xEC, 0xE0, 0x0D, 0x6F, 0x6E, + 0xE5, 0xB5, 0x13, 0x41, 0xFA, 0x6A, 0xC6, 0xB9, + 0xB8, 0x02, 0x84, 0x5E, 0xA8, 0x0E, 0x3F, 0x63, + 0x27, 0xA9, 0x32, 0xA5, 0xF4, 0x8D, 0xC2, 0x2A, + 0xE0, 0x14, 0x04, 0xB5, 0xB8, 0x6B, 0x68, 0xC5, + 0x1B, 0x66, 0x4B, 0xF8, 0x2E, 0x35, 0xE0, 0x46, + 0x78, 0xD3, 0xE2, 0x23, 0x3A, 0xF2, 0xA3, 0xEC + }, + { + 0xF5, 0x01, 0x30, 0x43, 0xFE, 0xC3, 0xAA, 0xAC, + 0x95, 0x72, 0x3A, 0xBF, 0x69, 0x25, 0xDA, 0x58, + 0xA1, 0x58, 0xDA, 0x7C, 0xAF, 0x6F, 0x09, 0xDF, + 0xC8, 0x67, 0x7C, 0x33, 0x64, 0x4E, 0xE9, 0xD8, + 0x89, 0x44, 0x99, 0x1D, 0x34, 0x06, 0x84, 0xD9, + 0x37, 0x1A, 0x24, 0x22, 0x2D, 0x1F, 0xBA, 0x0F, + 0x8F, 0x0D, 0x2E, 0xE3, 0xE6, 0x47, 0x61, 0x41, + 0x36, 0xCB, 0xA9, 0xE0, 0xD2, 0x21, 0x88, 0xBE + }, + { + 0x26, 0xBF, 0xB2, 0x4D, 0xEF, 0xB2, 0x1C, 0xDD, + 0x7A, 0xD0, 0x7E, 0x83, 0x0B, 0x95, 0xB9, 0x07, + 0xB1, 0x64, 0x9C, 0x4B, 0xC6, 0x49, 0x50, 0xDA, + 0x04, 0xCB, 0x39, 0xE8, 0x00, 0x44, 0x52, 0x10, + 0xAD, 0x55, 0x03, 0xC6, 0xDF, 0x8E, 0x6B, 0x47, + 0xF2, 0x7C, 0x00, 0x04, 0x41, 0x77, 0x6E, 0xFA, + 0x4D, 0x7B, 0x56, 0x82, 0x2C, 0x4D, 0x38, 0xBF, + 0x3D, 0x34, 0x30, 0xBF, 0x89, 0x28, 0x4C, 0xA2 + }, + { + 0xF2, 0x40, 0xFF, 0x67, 0xE5, 0x30, 0xF6, 0x8C, + 0xF8, 0xF1, 0x33, 0xE9, 0xCB, 0xE7, 0x63, 0xA7, + 0xB3, 0xC5, 0xEB, 0xB3, 0x07, 0x92, 0x75, 0x43, + 0x76, 0x9C, 0x06, 0xB0, 0x8E, 0x18, 0x91, 0x64, + 0xF3, 0xA5, 0xFB, 0x9D, 0x4D, 0xA4, 0x10, 0x1F, + 0x08, 0x46, 0x83, 0x50, 0xF8, 0x7F, 0xB4, 0x10, + 0x97, 0x1A, 0x59, 0x3A, 0x2F, 0x4D, 0x6E, 0x81, + 0x65, 0xC7, 0xD3, 0xC1, 0x53, 0xA2, 0x90, 0x48 + }, + { + 0x04, 0xB9, 0x20, 0x16, 0xD0, 0x3F, 0xA7, 0x2E, + 0x3B, 0xE6, 0x8C, 0x83, 0xF5, 0xBB, 0xEB, 0x18, + 0x37, 0x52, 0x02, 0x5D, 0x48, 0x83, 0xAB, 0x47, + 0xB1, 0xE9, 0xB6, 0x03, 0xDA, 0x65, 0xD4, 0x07, + 0x15, 0x25, 0x1F, 0x67, 0x5E, 0xA1, 0x90, 0xD8, + 0x4D, 0xB3, 0xB1, 0x16, 0xFD, 0x56, 0x9F, 0x8F, + 0xE6, 0xCA, 0x0B, 0x48, 0x5E, 0x8F, 0xFB, 0xE6, + 0xF6, 0xD3, 0x42, 0x0E, 0x85, 0x37, 0x78, 0x79 + }, + { + 0x33, 0xDE, 0xA8, 0x38, 0xE7, 0x22, 0xEC, 0x26, + 0xD6, 0x25, 0x1C, 0x50, 0x80, 0x1D, 0xD7, 0xB3, + 0x94, 0xD3, 0x8B, 0xF9, 0xD3, 0xE3, 0x48, 0x95, + 0x7B, 0x62, 0x3E, 0x3C, 0x93, 0xDB, 0x5A, 0x9E, + 0x75, 0x7B, 0xCA, 0x2A, 0x21, 0xD0, 0x9C, 0xF2, + 0x97, 0x56, 0xEB, 0xCA, 0x1C, 0xA2, 0x31, 0x13, + 0x75, 0xE2, 0xAD, 0xD3, 0x6D, 0x7F, 0xDB, 0x9F, + 0x8D, 0x0E, 0x6F, 0xB5, 0xF8, 0xD6, 0x96, 0x8A + }, + { + 0x78, 0x87, 0x48, 0xBA, 0x59, 0x2F, 0x25, 0xFE, + 0x09, 0x7B, 0x34, 0x00, 0xA1, 0x19, 0x93, 0x8D, + 0x5D, 0xEB, 0xD6, 0x0A, 0xCF, 0x02, 0x67, 0x70, + 0xA9, 0x3E, 0xF6, 0x62, 0xF8, 0xCB, 0x56, 0xEC, + 0x88, 0x9B, 0xD5, 0xBE, 0x9D, 0x6D, 0x3F, 0x94, + 0xF8, 0x27, 0x05, 0x1D, 0x53, 0xD2, 0x09, 0xBD, + 0x27, 0xF2, 0xA0, 0xC0, 0xA0, 0xE8, 0xFB, 0xC1, + 0xC0, 0xF1, 0x70, 0x9D, 0x98, 0xD5, 0x70, 0xC8 + }, + { + 0x0B, 0x9B, 0x47, 0x9C, 0x0B, 0x36, 0x2D, 0x64, + 0x13, 0x3D, 0x79, 0x3D, 0xFC, 0x1B, 0xF3, 0xB6, + 0x9E, 0xEB, 0x18, 0x5F, 0xBE, 0x3B, 0xEB, 0x37, + 0x90, 0x13, 0x1A, 0x04, 0x51, 0x27, 0x7E, 0x3E, + 0x74, 0x75, 0x8E, 0x60, 0x46, 0xA5, 0x09, 0x7A, + 0xDB, 0x92, 0x70, 0x34, 0x1E, 0x56, 0x2C, 0xB9, + 0x85, 0x3E, 0x15, 0xB5, 0x1D, 0x00, 0xA5, 0xE0, + 0xA4, 0xE1, 0x93, 0xAB, 0xBF, 0x86, 0xF9, 0x1C + }, + { + 0x70, 0xE2, 0xA2, 0xF1, 0x87, 0x0E, 0xC5, 0x05, + 0x0B, 0x90, 0xA3, 0xC2, 0x0C, 0xB9, 0x25, 0x72, + 0x73, 0x31, 0xEE, 0xA5, 0x2A, 0x9B, 0x49, 0xCE, + 0x59, 0xE8, 0x54, 0x9E, 0x5E, 0x99, 0x44, 0x7E, + 0xD1, 0x49, 0x5E, 0x33, 0x08, 0x04, 0x26, 0x10, + 0x01, 0xA2, 0xCE, 0x51, 0x9A, 0xF8, 0x96, 0x0B, + 0x47, 0x56, 0x09, 0xD9, 0xE9, 0x55, 0x68, 0xE0, + 0x2B, 0x53, 0x0A, 0x09, 0x12, 0xF9, 0x73, 0x0E + }, + { + 0x20, 0x9E, 0x07, 0xFA, 0x43, 0x1E, 0x30, 0xD6, + 0x36, 0x9B, 0xBF, 0x37, 0x69, 0x77, 0x94, 0xC4, + 0xDD, 0x1C, 0x94, 0xB4, 0x17, 0x36, 0x62, 0x23, + 0xD2, 0xD8, 0x08, 0xE5, 0x2B, 0x03, 0xEC, 0xF9, + 0xC4, 0x0C, 0xB1, 0x42, 0xD8, 0xF0, 0x86, 0xF3, + 0x6D, 0x6F, 0x6B, 0x38, 0xBE, 0x11, 0xF6, 0x4E, + 0x5D, 0x0F, 0x4D, 0x5C, 0x72, 0xA1, 0x80, 0xFF, + 0x98, 0xC9, 0x0A, 0xC3, 0xA9, 0x6C, 0xFC, 0x9F + }, + { + 0xA6, 0x84, 0x5B, 0x25, 0x43, 0x84, 0xD3, 0x10, + 0x56, 0x85, 0x9A, 0x0B, 0x97, 0x07, 0x39, 0x33, + 0x4D, 0x0B, 0x90, 0xD7, 0x0C, 0x1F, 0x6E, 0xF7, + 0x1E, 0x57, 0x81, 0x07, 0xD1, 0x77, 0x79, 0xCA, + 0x45, 0x5D, 0xF0, 0x35, 0xDD, 0x72, 0x9D, 0xEC, + 0x37, 0x35, 0xEE, 0xC6, 0x15, 0x7B, 0x48, 0x49, + 0x18, 0xAA, 0x99, 0xEB, 0xD3, 0xFF, 0xFF, 0xC6, + 0x17, 0x56, 0x90, 0x80, 0xC2, 0x6E, 0x05, 0x9A + }, + { + 0x95, 0x6F, 0x4D, 0x2F, 0xE7, 0xFE, 0x86, 0xEF, + 0x8A, 0xCD, 0xB2, 0x91, 0x08, 0xE6, 0x7C, 0x27, + 0xC4, 0xD6, 0xBA, 0x83, 0x1C, 0x1D, 0x30, 0xD3, + 0x00, 0x6F, 0xDB, 0x89, 0xC2, 0xAD, 0x21, 0x02, + 0xF1, 0xD0, 0x79, 0xAD, 0xD6, 0x64, 0x7A, 0xCC, + 0xF7, 0xD9, 0xF5, 0xB4, 0xBA, 0x07, 0x79, 0x81, + 0x59, 0x6A, 0x9B, 0x74, 0xBF, 0xAB, 0x1A, 0xD0, + 0x06, 0x42, 0xC4, 0x7B, 0xDB, 0x1E, 0x4A, 0xE0 + }, + { + 0xD2, 0x75, 0x21, 0x5A, 0x41, 0xB4, 0x10, 0x23, + 0xBC, 0xD1, 0x51, 0x3E, 0x9F, 0xFE, 0xA5, 0x7A, + 0xB0, 0xB3, 0xFC, 0xDC, 0xAD, 0x1B, 0x63, 0x57, + 0xCC, 0x2D, 0xE1, 0x27, 0x6F, 0x26, 0x7A, 0x12, + 0x8F, 0x12, 0x2F, 0xB2, 0x30, 0xB7, 0xBC, 0x25, + 0x4E, 0x95, 0xFD, 0x3B, 0xC2, 0xED, 0x4E, 0xB6, + 0x4F, 0x4E, 0xDE, 0x87, 0xE7, 0xDB, 0x9B, 0xDE, + 0xD7, 0xCC, 0x39, 0xFA, 0x41, 0xFE, 0xCC, 0x8D + }, + { + 0x7C, 0x94, 0xBF, 0x81, 0xEC, 0xB0, 0xD1, 0x9A, + 0x49, 0x40, 0x44, 0xD5, 0x1A, 0x4F, 0xC9, 0x4A, + 0xC2, 0x49, 0x11, 0xA9, 0x29, 0x94, 0x07, 0xA3, + 0x54, 0xC3, 0x71, 0x53, 0x01, 0xC4, 0xE7, 0x15, + 0x81, 0x78, 0x0E, 0x17, 0x56, 0xF6, 0x25, 0xA4, + 0x43, 0xD7, 0x84, 0x34, 0x79, 0x09, 0x82, 0x04, + 0xF3, 0x58, 0x44, 0xEE, 0xF1, 0x95, 0x0C, 0xFD, + 0x96, 0xC9, 0x89, 0x98, 0x89, 0x4E, 0x9B, 0x51 + }, + { + 0x9A, 0xCB, 0x87, 0x6C, 0x3A, 0xE6, 0x56, 0x11, + 0xCC, 0x87, 0xA2, 0x70, 0x98, 0xC7, 0xC9, 0x77, + 0x6B, 0xAC, 0xFE, 0xCB, 0x45, 0xE2, 0x18, 0x48, + 0x3B, 0x83, 0xB6, 0x67, 0x85, 0xE8, 0x50, 0x10, + 0xF8, 0x05, 0xB6, 0x54, 0xB7, 0x97, 0x44, 0xFA, + 0x69, 0x1D, 0x1D, 0x62, 0x64, 0x5A, 0x5F, 0x6F, + 0x81, 0xA0, 0x39, 0x39, 0x2A, 0x76, 0x7E, 0xBB, + 0xF8, 0xB7, 0x47, 0x82, 0xAD, 0xA8, 0x2C, 0xAA + }, + { + 0x0C, 0xAF, 0x9B, 0x5E, 0xC2, 0x08, 0x11, 0xC9, + 0x08, 0x3A, 0xE9, 0x0F, 0x8E, 0x63, 0x03, 0x71, + 0xB4, 0xE9, 0x6B, 0x99, 0xED, 0x46, 0x84, 0x97, + 0x9E, 0xBD, 0x13, 0xDB, 0x2C, 0xC6, 0x48, 0x34, + 0x85, 0x6A, 0x71, 0x53, 0x91, 0x1B, 0x66, 0x00, + 0x20, 0xCC, 0xC5, 0x8D, 0x18, 0x36, 0xC4, 0xD5, + 0x3D, 0xEE, 0x61, 0x70, 0x5F, 0xFC, 0xB7, 0x82, + 0xFC, 0xB8, 0x37, 0x68, 0x6F, 0x92, 0xFB, 0x4A + }, + { + 0x82, 0xB4, 0xE2, 0xF8, 0xCC, 0x90, 0x26, 0xE3, + 0x0E, 0xFF, 0xF9, 0x6A, 0x53, 0x36, 0x4E, 0xFC, + 0x3B, 0x01, 0xA5, 0x77, 0x17, 0xF4, 0x43, 0xA3, + 0x4D, 0xCF, 0xE6, 0xBC, 0xBF, 0x13, 0xD5, 0xDB, + 0xDD, 0x5B, 0x40, 0x59, 0x27, 0xAC, 0x48, 0xF7, + 0x3D, 0x91, 0xF4, 0xC4, 0xF8, 0xF4, 0x68, 0x33, + 0x50, 0x1B, 0x3A, 0x88, 0x9B, 0x9B, 0xB7, 0x70, + 0x63, 0x30, 0x0A, 0x38, 0x85, 0x29, 0xE0, 0x12 + }, + { + 0xF0, 0x63, 0x04, 0x2F, 0x9C, 0x49, 0x44, 0xFE, + 0x4D, 0xD8, 0xC5, 0x5B, 0x14, 0x4A, 0xA4, 0xA2, + 0x88, 0x73, 0x2F, 0xF0, 0x18, 0xFA, 0x50, 0x72, + 0x0E, 0x46, 0xD5, 0x9A, 0x3F, 0x64, 0x66, 0x9A, + 0xEB, 0x05, 0x33, 0x77, 0xD6, 0x34, 0x45, 0xB7, + 0xA2, 0x85, 0xBB, 0x22, 0x2A, 0xB7, 0x2B, 0x4A, + 0xA2, 0xCD, 0x55, 0xD1, 0x35, 0xDB, 0x30, 0xC8, + 0x33, 0xB1, 0x6E, 0x7C, 0x43, 0xFB, 0x5B, 0xD7 + }, + { + 0xFE, 0x48, 0xA2, 0x01, 0xD2, 0x96, 0xB4, 0x72, + 0x0A, 0x85, 0xBD, 0xD9, 0x9A, 0x15, 0x41, 0xBC, + 0x99, 0xA1, 0x8C, 0x78, 0xE6, 0x3B, 0x0F, 0x5C, + 0xE9, 0x66, 0x9D, 0x04, 0xDB, 0x35, 0x02, 0xEB, + 0x76, 0x35, 0xD6, 0xC5, 0xB5, 0xC2, 0xE4, 0x00, + 0x42, 0xB8, 0xC1, 0xC0, 0xB0, 0x8E, 0x5C, 0xD5, + 0xC8, 0xBC, 0xC5, 0x94, 0xD2, 0x31, 0xD7, 0x49, + 0x26, 0x72, 0xFE, 0x67, 0x18, 0x72, 0x36, 0x2F + }, + { + 0x29, 0xBF, 0xE1, 0xC1, 0x31, 0xA8, 0x99, 0x2A, + 0x9A, 0xF2, 0xBC, 0xA5, 0x8F, 0x83, 0xEA, 0xB4, + 0x84, 0x54, 0xD0, 0x09, 0xFB, 0x2B, 0x8D, 0xCB, + 0xB0, 0xA9, 0x02, 0xBC, 0xDA, 0x83, 0xDB, 0x7D, + 0xB8, 0x98, 0x76, 0x46, 0x3F, 0xDC, 0xD2, 0x0A, + 0xC4, 0xDF, 0xD3, 0x65, 0xE4, 0x17, 0x40, 0x14, + 0xE7, 0xEB, 0xB6, 0xE4, 0x88, 0xD4, 0x6F, 0x8A, + 0x62, 0x83, 0xBF, 0x09, 0x5E, 0xD1, 0x24, 0xFF + }, + { + 0x44, 0x42, 0x9C, 0x9D, 0x36, 0x53, 0x84, 0x9E, + 0xEC, 0x2C, 0xAC, 0x58, 0x7D, 0x8A, 0x28, 0x65, + 0x1D, 0x2F, 0xE4, 0xA7, 0xAA, 0x50, 0x8A, 0xD8, + 0x22, 0xCA, 0x22, 0x7C, 0x3D, 0xAE, 0xF1, 0x85, + 0xCF, 0xBB, 0xF6, 0x77, 0x0D, 0x0E, 0x03, 0xF5, + 0x4E, 0xD9, 0xE1, 0xA7, 0xDE, 0x9F, 0x2E, 0xB4, + 0x56, 0xA9, 0x66, 0x51, 0x83, 0xCE, 0xB7, 0xB3, + 0xBC, 0x3D, 0x61, 0x53, 0xE1, 0x5C, 0x39, 0xE7 + }, + { + 0xDB, 0x23, 0x1A, 0xA4, 0xCF, 0xD8, 0x2E, 0x34, + 0x0C, 0x93, 0x98, 0xA1, 0x22, 0x4D, 0xDA, 0x5A, + 0x72, 0xD6, 0x58, 0x32, 0xDB, 0xED, 0x12, 0x79, + 0x2A, 0x1C, 0xE4, 0x38, 0xE2, 0x50, 0x48, 0xE5, + 0xCD, 0x82, 0x11, 0xD5, 0x6B, 0x29, 0xB9, 0x0F, + 0xF3, 0x6A, 0x31, 0x05, 0x3E, 0x5F, 0x88, 0x7D, + 0x7D, 0x83, 0xB9, 0x5E, 0xA8, 0x61, 0x7C, 0x4C, + 0xB5, 0xA4, 0x98, 0x9E, 0x08, 0x24, 0x82, 0x7D + }, + { + 0xC4, 0x30, 0xC3, 0x7C, 0xD6, 0xB4, 0x69, 0x26, + 0xC6, 0x95, 0xB1, 0x7B, 0x3D, 0xE5, 0xC5, 0x22, + 0x76, 0x06, 0x64, 0x97, 0x4C, 0xC7, 0x8F, 0xB2, + 0x3B, 0x11, 0xC7, 0x80, 0x4A, 0xC8, 0x5E, 0xDB, + 0xAA, 0xE7, 0xCA, 0xE0, 0x73, 0xA5, 0x50, 0xDA, + 0x32, 0xD1, 0x8D, 0x26, 0x27, 0x19, 0x50, 0x90, + 0xE1, 0xE1, 0x70, 0x7C, 0x5E, 0x2A, 0xFD, 0x8C, + 0xD1, 0x1F, 0xAA, 0x80, 0x2B, 0x72, 0xA5, 0x43 + }, + { + 0x9A, 0x0A, 0x8E, 0xB7, 0x56, 0x18, 0xEC, 0x90, + 0xA5, 0x23, 0x92, 0x35, 0xB0, 0x55, 0xFC, 0x3A, + 0x0F, 0x46, 0x17, 0x4C, 0xC3, 0xC7, 0x9D, 0xC9, + 0x6B, 0xEA, 0xDF, 0x6E, 0x6C, 0x71, 0xA2, 0xBE, + 0x39, 0xF8, 0x63, 0x10, 0x8B, 0x6E, 0xEC, 0x19, + 0xE0, 0xEE, 0xA8, 0xD0, 0x20, 0xD8, 0x6B, 0xB6, + 0x59, 0xC0, 0xEF, 0x91, 0x10, 0x49, 0x82, 0x6C, + 0xDB, 0xE9, 0x3B, 0x9F, 0x21, 0x24, 0x90, 0x58 + }, + { + 0x84, 0xC5, 0x6A, 0xFB, 0x03, 0x8D, 0x52, 0x5B, + 0xD9, 0xCD, 0x47, 0xC1, 0xAF, 0xAD, 0x8C, 0xEB, + 0x40, 0x59, 0x97, 0x82, 0xA5, 0xBD, 0x5C, 0x1A, + 0xF2, 0xF6, 0x92, 0x52, 0xF2, 0x57, 0x4A, 0xE0, + 0x0A, 0x44, 0x68, 0xDD, 0x22, 0xAC, 0x59, 0x44, + 0x8D, 0x5A, 0xC1, 0x44, 0xA6, 0x82, 0x41, 0xBA, + 0xE0, 0x67, 0xAA, 0x2B, 0x65, 0xE4, 0x5B, 0x99, + 0x1F, 0x21, 0x79, 0x10, 0x24, 0xD1, 0xB0, 0xD1 + }, + { + 0x3B, 0x98, 0x3C, 0x93, 0x7A, 0x45, 0xAA, 0xC2, + 0x47, 0xD9, 0xB9, 0x9E, 0xEB, 0x6C, 0x86, 0x4C, + 0x64, 0x4C, 0x9F, 0x02, 0x4C, 0x26, 0xE6, 0xD2, + 0x83, 0x43, 0x4B, 0x0D, 0xBF, 0x2C, 0xC0, 0xF7, + 0xB6, 0x87, 0x6C, 0x64, 0xD2, 0xA1, 0x37, 0x18, + 0x57, 0x09, 0x43, 0x60, 0x5C, 0xB2, 0x5A, 0x05, + 0xA7, 0xAF, 0x42, 0xA0, 0x4A, 0xF8, 0x98, 0xE1, + 0xEF, 0x91, 0x85, 0x27, 0xAE, 0xAE, 0x55, 0xF6 + }, + { + 0xF2, 0x70, 0x0C, 0xDE, 0xD9, 0xF8, 0x48, 0x68, + 0x6C, 0xB4, 0x03, 0x0E, 0xB0, 0x4C, 0xD5, 0x0A, + 0x8F, 0x0C, 0x1E, 0xEE, 0xD8, 0x02, 0x44, 0xC8, + 0x80, 0x2B, 0x83, 0xCF, 0x39, 0xE0, 0x7A, 0x31, + 0xAB, 0x1D, 0xF4, 0x37, 0xC9, 0x88, 0x68, 0x77, + 0x31, 0xE1, 0xBE, 0x67, 0xC5, 0x33, 0x01, 0xF0, + 0x9B, 0xA8, 0xBB, 0x14, 0x3B, 0x2A, 0xDE, 0xBD, + 0x7A, 0xB1, 0xC4, 0xC7, 0x85, 0xB6, 0x8F, 0x54 + }, + { + 0x35, 0x65, 0x65, 0x66, 0xF0, 0x7E, 0x78, 0x28, + 0x5E, 0x1D, 0x44, 0x79, 0xA9, 0xF5, 0xC8, 0x51, + 0x5D, 0x3B, 0x5B, 0x83, 0x4A, 0x56, 0x53, 0x59, + 0xB0, 0x92, 0xD9, 0x0F, 0x3A, 0x0C, 0xDC, 0xB5, + 0xA9, 0x36, 0x1F, 0x49, 0x38, 0xCF, 0x43, 0xFE, + 0x44, 0x3E, 0x0A, 0x0A, 0x59, 0x4E, 0x93, 0x97, + 0xF3, 0xD9, 0xE8, 0xFB, 0xC5, 0xB1, 0xF7, 0x6C, + 0x26, 0x8C, 0x61, 0x1E, 0xB8, 0xE7, 0xD0, 0xDA + }, + { + 0x6C, 0xA3, 0x9A, 0x4C, 0xB5, 0x23, 0x46, 0xE6, + 0x37, 0x49, 0x55, 0x0A, 0x0B, 0x74, 0xA8, 0x1B, + 0x14, 0x6F, 0x14, 0x29, 0x1F, 0xF2, 0x70, 0xEE, + 0xEA, 0x8F, 0x84, 0x66, 0x78, 0xDE, 0xD7, 0x4C, + 0x12, 0x21, 0x97, 0x63, 0x4D, 0x73, 0xD5, 0x95, + 0xD9, 0x7A, 0xBE, 0xBB, 0x92, 0x17, 0xE9, 0x36, + 0x7A, 0x86, 0xDA, 0x0D, 0xFE, 0xAF, 0x92, 0x3A, + 0xC0, 0x2F, 0x55, 0x1F, 0x9B, 0x95, 0xD3, 0x57 + }, + { + 0x42, 0xCC, 0xFF, 0x81, 0x39, 0x79, 0xC7, 0x93, + 0xEF, 0x60, 0x5F, 0xAF, 0xF8, 0xD5, 0x41, 0xD2, + 0xC4, 0x24, 0x6E, 0x2E, 0xD3, 0xA5, 0x4A, 0x4F, + 0x56, 0xE0, 0x95, 0x7B, 0xFD, 0x70, 0x4E, 0x17, + 0xFB, 0x77, 0x9F, 0xE0, 0x12, 0x20, 0x3A, 0xA5, + 0x2A, 0xF5, 0x63, 0x22, 0x07, 0x7E, 0x6E, 0x30, + 0x8E, 0x49, 0x2E, 0x55, 0x92, 0x04, 0x21, 0x10, + 0x96, 0xF2, 0xBD, 0xE0, 0x65, 0x0E, 0x89, 0xE8 + }, + { + 0x54, 0xE6, 0x04, 0x52, 0x7E, 0x4F, 0xEB, 0x70, + 0xA6, 0xF5, 0x46, 0x48, 0x70, 0x73, 0x71, 0x78, + 0x5E, 0xA4, 0x74, 0xD6, 0xF0, 0x87, 0x08, 0xD2, + 0x78, 0x3A, 0x27, 0xC8, 0xCF, 0x77, 0x62, 0x02, + 0x2E, 0x52, 0x51, 0xE9, 0xEA, 0x80, 0x7C, 0x43, + 0xCF, 0xCC, 0xA0, 0xC1, 0x73, 0xF8, 0x7B, 0xB3, + 0x53, 0x25, 0xAA, 0xAA, 0x39, 0x39, 0xB8, 0xD1, + 0x3B, 0x89, 0xD7, 0x18, 0xE0, 0x81, 0xEE, 0xDB + }, + { + 0x4B, 0xD7, 0xCB, 0x7E, 0x9E, 0x0E, 0x43, 0xD2, + 0xBF, 0xF8, 0x32, 0xD2, 0x25, 0xF3, 0xD9, 0xC8, + 0xCE, 0x2C, 0x89, 0x3D, 0x58, 0xBB, 0x51, 0x69, + 0x6F, 0x43, 0xD9, 0x86, 0x50, 0x3A, 0x19, 0xC5, + 0x62, 0x4B, 0x67, 0x66, 0xBB, 0x1C, 0x9A, 0x81, + 0x91, 0xC6, 0x02, 0xDF, 0x21, 0x31, 0xE7, 0xE5, + 0xE2, 0x64, 0xA1, 0x96, 0x07, 0x6A, 0xB5, 0x76, + 0x48, 0x1B, 0xBD, 0xBC, 0xF3, 0x54, 0x66, 0x94 + }, + { + 0x30, 0x73, 0x1C, 0x81, 0xC0, 0xA4, 0x3B, 0x3D, + 0xBF, 0xC8, 0xF1, 0x66, 0x77, 0x9D, 0xC7, 0xA9, + 0x18, 0x72, 0x23, 0x6E, 0x54, 0x5F, 0x84, 0xF2, + 0x11, 0x82, 0x17, 0xD1, 0xDE, 0xDE, 0xAD, 0x7D, + 0x7F, 0xDC, 0xB9, 0x96, 0xF2, 0x3E, 0x28, 0x59, + 0x1F, 0xFA, 0x58, 0x21, 0x1B, 0x25, 0x8E, 0x15, + 0x2E, 0xE3, 0x01, 0x42, 0x53, 0x9E, 0x55, 0x42, + 0x46, 0x1E, 0x85, 0xFC, 0xAD, 0xE8, 0x53, 0xE0 + }, + { + 0xB4, 0x18, 0x2C, 0xD8, 0x72, 0x1B, 0xCD, 0x01, + 0xF4, 0x4C, 0xE6, 0x4C, 0xB5, 0xE4, 0x08, 0xF7, + 0xC2, 0x79, 0x7B, 0xA8, 0x67, 0x2F, 0xE1, 0x5F, + 0x50, 0x64, 0xEC, 0x3F, 0xF0, 0x9E, 0x80, 0xE3, + 0x81, 0x9F, 0x2B, 0xDB, 0xF4, 0xBA, 0xBD, 0xCB, + 0xB2, 0x44, 0xCE, 0x77, 0xF8, 0x26, 0xE3, 0xC4, + 0xED, 0x89, 0xE0, 0xE3, 0xC1, 0x7D, 0xD9, 0x4F, + 0xB7, 0xE3, 0x1A, 0x00, 0x05, 0x2B, 0x85, 0x80 + }, + { + 0x6E, 0xDB, 0xF7, 0x15, 0x84, 0x63, 0x60, 0x8F, + 0xF6, 0xFE, 0x95, 0x51, 0x45, 0x47, 0x14, 0xD5, + 0xA1, 0x36, 0x49, 0x8C, 0xDA, 0xE5, 0xF5, 0xE8, + 0x09, 0x30, 0x95, 0x50, 0xEB, 0xE6, 0x61, 0xBD, + 0xC6, 0x08, 0xAE, 0xDB, 0x2D, 0x8D, 0x5D, 0x8B, + 0x3B, 0x89, 0xA2, 0x4E, 0x14, 0x42, 0xF7, 0xB6, + 0xE2, 0xEE, 0x1E, 0xAD, 0x4A, 0xA4, 0x11, 0xF9, + 0x6E, 0x3D, 0x53, 0x23, 0x97, 0x27, 0xCC, 0xB4 + }, + { + 0x11, 0xD9, 0x35, 0xD2, 0x64, 0x52, 0x3A, 0xCC, + 0xF4, 0x7D, 0xFB, 0x06, 0xC2, 0x4F, 0x52, 0x08, + 0x7E, 0x7D, 0xF1, 0x2A, 0x0C, 0x61, 0x72, 0xFC, + 0x80, 0xAD, 0xA2, 0x0F, 0x66, 0x90, 0x8D, 0x40, + 0x8B, 0x45, 0x72, 0x75, 0x2C, 0x68, 0x4F, 0xD0, + 0x8C, 0x00, 0xAF, 0x71, 0x09, 0x4F, 0xCF, 0x03, + 0x9C, 0x04, 0x05, 0x37, 0x50, 0xA5, 0x29, 0x69, + 0x7E, 0xB7, 0x7D, 0x94, 0xCB, 0x0F, 0xA1, 0x9F + }, + { + 0x84, 0xAB, 0xC0, 0xE6, 0xE0, 0x77, 0x1B, 0x30, + 0xE2, 0x90, 0x36, 0x67, 0xD4, 0xEE, 0x96, 0x03, + 0x45, 0x20, 0x95, 0x4F, 0x24, 0x54, 0xB9, 0x9B, + 0x98, 0x1B, 0xA7, 0x17, 0xB8, 0x4A, 0x96, 0xDD, + 0xBA, 0xB7, 0xB1, 0x84, 0x27, 0xE1, 0x2A, 0xEF, + 0x64, 0x19, 0x12, 0xEE, 0x0D, 0xA7, 0xF6, 0x09, + 0x7F, 0xD5, 0x83, 0x6D, 0x70, 0x2F, 0xED, 0x1B, + 0xCB, 0x38, 0x45, 0x61, 0xCA, 0x3D, 0x6C, 0x76 + }, + { + 0x75, 0x78, 0xBE, 0xE5, 0x01, 0xE2, 0xC1, 0x27, + 0x34, 0x7C, 0x93, 0xAC, 0xCC, 0xA3, 0xE1, 0x7C, + 0xA2, 0x50, 0x4B, 0x5D, 0x7B, 0xE9, 0x32, 0xFC, + 0x64, 0x5D, 0x14, 0xB3, 0x77, 0x67, 0xB4, 0xE2, + 0x2F, 0x06, 0xA0, 0xEB, 0x0B, 0xCE, 0xC9, 0xF0, + 0xB8, 0xA3, 0xCC, 0x46, 0xD2, 0x57, 0x51, 0x8D, + 0x8D, 0x5B, 0xDA, 0xA9, 0xBF, 0x76, 0xD3, 0x11, + 0x2D, 0x41, 0xAB, 0x28, 0x74, 0xEB, 0xE9, 0xDB + }, + { + 0x3D, 0xD7, 0x40, 0xF2, 0x51, 0xB5, 0x46, 0x77, + 0xF9, 0x13, 0xA5, 0x46, 0x23, 0x70, 0x44, 0x31, + 0xD0, 0x65, 0xFE, 0xA2, 0xC8, 0xD7, 0x3E, 0x9E, + 0x96, 0xCB, 0x89, 0x55, 0x46, 0x2B, 0x03, 0x03, + 0x51, 0xF3, 0xF0, 0x9D, 0x15, 0x5C, 0xB1, 0xEA, + 0x0C, 0xC8, 0x6E, 0x3A, 0x89, 0x03, 0xD0, 0xFA, + 0x85, 0x0D, 0x7D, 0x06, 0x4C, 0x49, 0x82, 0x6E, + 0x58, 0x88, 0x33, 0x5C, 0x56, 0xB9, 0x7B, 0xCD + }, + { + 0x54, 0x9A, 0x73, 0xE1, 0x6B, 0x09, 0x30, 0x04, + 0x22, 0xE1, 0xDA, 0xFF, 0xE2, 0xD6, 0x57, 0x0C, + 0x58, 0x92, 0x5D, 0x76, 0xE7, 0xE4, 0x43, 0x11, + 0xAF, 0x11, 0x0C, 0x5E, 0x24, 0x3E, 0xC0, 0x52, + 0xE4, 0xE4, 0xB1, 0x3F, 0xF6, 0xCA, 0x5B, 0x6E, + 0xA0, 0x3A, 0x2F, 0x0B, 0xF0, 0x39, 0xB8, 0x61, + 0x16, 0xAD, 0xE6, 0xAC, 0xF8, 0x10, 0xF7, 0xB7, + 0x2D, 0x75, 0x90, 0xF8, 0x54, 0xC2, 0xA6, 0x2F + }, + { + 0x6B, 0xA5, 0x74, 0x66, 0xA7, 0x80, 0xC9, 0x88, + 0xE3, 0x66, 0x55, 0xD6, 0x09, 0xBE, 0xEB, 0x4A, + 0x56, 0x8E, 0xDF, 0xE4, 0xF9, 0x05, 0x1B, 0xA8, + 0xF8, 0x5A, 0x34, 0x23, 0x5D, 0x12, 0x73, 0x8C, + 0x31, 0x6A, 0x45, 0x5B, 0x1B, 0x10, 0x5C, 0xCD, + 0x55, 0x43, 0xE8, 0x8B, 0x40, 0x3E, 0xA6, 0x5C, + 0x84, 0x8A, 0x2F, 0xEC, 0xD7, 0x9E, 0xAD, 0x11, + 0xEB, 0xEF, 0x4C, 0xE6, 0x4D, 0x69, 0x0E, 0x65 + }, + { + 0xEA, 0x4D, 0x21, 0xB3, 0x36, 0xF2, 0x1A, 0xE8, + 0x44, 0x8A, 0x14, 0x90, 0x7D, 0x5A, 0x8F, 0xCB, + 0x63, 0xC7, 0xF3, 0x26, 0xA2, 0xA0, 0xD5, 0x61, + 0x4E, 0xDF, 0x76, 0x4B, 0xAB, 0x9F, 0x29, 0x3B, + 0xA6, 0x2A, 0xE0, 0xE2, 0x00, 0x3B, 0x04, 0x47, + 0x14, 0x6C, 0x1E, 0xD9, 0x2A, 0x55, 0xDE, 0xA8, + 0x56, 0xC7, 0xB8, 0xCF, 0x16, 0x95, 0x88, 0xA1, + 0xDA, 0x7D, 0xAB, 0x1D, 0xF7, 0xF2, 0xB8, 0x08 + }, + { + 0xB2, 0x9A, 0xE7, 0xED, 0x5D, 0x05, 0xF8, 0xB6, + 0xD8, 0x3D, 0xD0, 0x74, 0x52, 0x8F, 0x13, 0xE6, + 0xDF, 0xF8, 0x4A, 0x24, 0x37, 0x86, 0x05, 0x65, + 0xE2, 0x33, 0x6E, 0x34, 0xAC, 0xE0, 0x45, 0x2E, + 0x81, 0x38, 0xDD, 0x41, 0x5E, 0x64, 0xE2, 0xCF, + 0x99, 0xDD, 0x62, 0xB8, 0x29, 0xB5, 0x21, 0x22, + 0xEF, 0xD8, 0xA0, 0x95, 0xF7, 0xCB, 0x1A, 0x23, + 0xF2, 0xB7, 0x61, 0x5A, 0xAB, 0xC7, 0x81, 0x69 + }, + { + 0xCC, 0x45, 0xF6, 0x84, 0x05, 0x87, 0xAB, 0x35, + 0x0A, 0x96, 0xD2, 0x9E, 0x59, 0xB4, 0x65, 0xFB, + 0x1D, 0xB9, 0x66, 0x89, 0xEB, 0x80, 0x3D, 0x38, + 0xA9, 0xFA, 0x23, 0x7C, 0xF9, 0x93, 0x39, 0x1C, + 0xA0, 0x64, 0xC0, 0x44, 0xEF, 0xAA, 0x0B, 0x12, + 0x05, 0x1D, 0x72, 0xBA, 0x81, 0x4D, 0xD0, 0x9B, + 0xAF, 0x0F, 0xFE, 0x73, 0x40, 0x64, 0x97, 0xD7, + 0xBE, 0xC3, 0xC2, 0x84, 0xDD, 0xA3, 0xCF, 0xE1 + }, + { + 0xD0, 0x11, 0x57, 0xB0, 0xE2, 0x01, 0xC5, 0x62, + 0x1B, 0x24, 0x9D, 0x0C, 0x1E, 0x65, 0xD5, 0x93, + 0x35, 0xE0, 0x21, 0x87, 0x86, 0xA7, 0x43, 0xAC, + 0x72, 0xB0, 0x1A, 0x85, 0xC7, 0x55, 0x0D, 0x80, + 0x1E, 0xE5, 0xF5, 0xF8, 0x88, 0xB1, 0xB1, 0x23, + 0x3F, 0x41, 0x0B, 0xAA, 0x4C, 0x06, 0x58, 0x03, + 0x3E, 0x72, 0xF9, 0x57, 0x77, 0x2C, 0x54, 0xF1, + 0x06, 0xA2, 0x68, 0x09, 0x1C, 0xEF, 0x53, 0xA2 + }, + { + 0x37, 0x1F, 0x9F, 0x69, 0x52, 0xBE, 0x2A, 0xC9, + 0xED, 0xF2, 0xA7, 0xF2, 0xA0, 0xB7, 0x65, 0xFB, + 0x52, 0x62, 0x89, 0x30, 0x0F, 0x78, 0x7C, 0x3E, + 0xAB, 0xDD, 0x3C, 0x47, 0xB2, 0x20, 0x24, 0xF2, + 0x46, 0xEA, 0x6D, 0x21, 0xC9, 0xBB, 0x65, 0x7E, + 0x0B, 0xB2, 0xCA, 0x62, 0x86, 0xA2, 0xBB, 0x1B, + 0x22, 0xF4, 0x07, 0x77, 0x17, 0x51, 0x08, 0x29, + 0xA8, 0xD2, 0x12, 0x3E, 0xFE, 0x64, 0x6A, 0x60 + }, + { + 0xBF, 0x0C, 0xA7, 0xF4, 0x86, 0x1E, 0xDD, 0x66, + 0x40, 0x57, 0x15, 0x8D, 0xF7, 0x35, 0x48, 0xAA, + 0xED, 0xF7, 0xBC, 0x59, 0x44, 0xA6, 0x5C, 0x79, + 0x8C, 0x8B, 0x88, 0xDE, 0x31, 0x82, 0xD9, 0xDE, + 0xA3, 0x24, 0x6B, 0xDD, 0x2E, 0x41, 0x9E, 0x9C, + 0x9D, 0x92, 0xC2, 0x7B, 0x0A, 0x61, 0xAD, 0x56, + 0x0B, 0xE1, 0x3F, 0x9F, 0x90, 0xB7, 0x93, 0x3D, + 0xEE, 0xFF, 0x96, 0x85, 0xCC, 0xAB, 0xA2, 0x21 + }, + { + 0xE1, 0xE1, 0xA7, 0x13, 0x41, 0x16, 0x75, 0x77, + 0x84, 0xE8, 0x64, 0xC9, 0xD4, 0x4A, 0x1D, 0x5A, + 0xC0, 0x9F, 0xC6, 0x02, 0x8B, 0xB8, 0x35, 0x9E, + 0x80, 0xB9, 0xD2, 0xC1, 0x24, 0x8E, 0x64, 0xCD, + 0xA4, 0xB5, 0x1C, 0x2F, 0x08, 0x41, 0x0F, 0x3B, + 0xCB, 0x5A, 0xF4, 0x88, 0x6B, 0x4B, 0x87, 0x8F, + 0x3C, 0x2A, 0x2E, 0x39, 0xC0, 0x30, 0x17, 0xAD, + 0x7B, 0xE5, 0x0A, 0xB6, 0xF3, 0xFA, 0x60, 0x45 + }, + { + 0x4F, 0x48, 0x29, 0x66, 0xD2, 0x21, 0x05, 0x71, + 0xB2, 0x3C, 0x77, 0x3B, 0xED, 0x8B, 0xB4, 0x54, + 0x7C, 0x0B, 0x01, 0x47, 0x29, 0x9E, 0x28, 0xF7, + 0x5F, 0xE5, 0x6C, 0xCF, 0x93, 0xC9, 0xC5, 0xDB, + 0x15, 0xC0, 0xD7, 0x64, 0xDB, 0x1D, 0x81, 0x8A, + 0x39, 0x02, 0x3D, 0x61, 0x99, 0x75, 0x2B, 0xCA, + 0x9B, 0xB1, 0x4C, 0x9C, 0x2A, 0x86, 0x37, 0xF2, + 0x97, 0x7F, 0x66, 0xC1, 0xCC, 0xCB, 0x83, 0xC1 + }, + { + 0xF2, 0x76, 0xB0, 0xC9, 0x58, 0x4C, 0x8B, 0xE4, + 0x9E, 0x7C, 0x10, 0x20, 0x59, 0xC7, 0x69, 0xFB, + 0x99, 0xC4, 0x7B, 0x95, 0x5F, 0xE7, 0x61, 0xA6, + 0x03, 0x1A, 0x55, 0x79, 0xA9, 0x4C, 0x5E, 0x73, + 0x48, 0xFC, 0x1A, 0x73, 0x51, 0x3D, 0x31, 0xDB, + 0xE7, 0xF5, 0xB9, 0xB8, 0x1E, 0xE3, 0x7D, 0x28, + 0x30, 0x89, 0x95, 0xEE, 0xBC, 0x10, 0xE3, 0x98, + 0x32, 0xF5, 0x59, 0x33, 0x0C, 0x0C, 0x9C, 0x91 + }, + { + 0xBE, 0x95, 0xE5, 0x6A, 0x83, 0xBC, 0x67, 0xEA, + 0x0A, 0x5C, 0xE4, 0x96, 0xEE, 0x22, 0x99, 0x5A, + 0xB3, 0xD7, 0xBA, 0xAD, 0x03, 0xEA, 0xD3, 0xD8, + 0xB1, 0x53, 0xE3, 0x9C, 0x9B, 0xD5, 0x68, 0x72, + 0x32, 0xCF, 0x2D, 0xFA, 0x04, 0x31, 0x43, 0xB7, + 0xBE, 0x4D, 0xF4, 0x3E, 0x9D, 0xB8, 0x82, 0x1D, + 0xFF, 0xE5, 0xC3, 0xC4, 0x74, 0x4D, 0x81, 0x08, + 0xC9, 0xB6, 0x36, 0xC7, 0x9D, 0x52, 0x6A, 0x88 + }, + { + 0x9E, 0xAA, 0xCA, 0x66, 0x1E, 0xFC, 0x29, 0xDD, + 0xB9, 0x15, 0x59, 0x47, 0x39, 0x00, 0x86, 0x42, + 0x7B, 0x9A, 0x73, 0x08, 0x1C, 0x1D, 0x4B, 0x8F, + 0x84, 0x8B, 0xC3, 0x5A, 0x38, 0x0A, 0x3A, 0x96, + 0xD0, 0x46, 0x41, 0x62, 0x38, 0x12, 0x39, 0xB4, + 0xDE, 0x58, 0x3B, 0xEF, 0x20, 0x2F, 0x11, 0xEB, + 0xF2, 0x6A, 0x87, 0xF3, 0xEC, 0xA7, 0x69, 0xF0, + 0xD6, 0x2A, 0x3E, 0x91, 0x54, 0xDA, 0x0E, 0xC3 + }, + { + 0x98, 0x91, 0x7F, 0xC4, 0x0C, 0xCB, 0x06, 0x58, + 0x65, 0xEA, 0x31, 0x93, 0xC6, 0xF9, 0xB3, 0xC4, + 0x1C, 0x5C, 0xDE, 0xAD, 0x33, 0x25, 0x21, 0x66, + 0x29, 0x42, 0x86, 0x59, 0xFA, 0x4D, 0x9E, 0x8F, + 0x09, 0x96, 0x7D, 0xFE, 0x5A, 0xDD, 0x96, 0x51, + 0xED, 0xA5, 0xA2, 0x51, 0x73, 0x0C, 0xE6, 0x6B, + 0xBB, 0x7C, 0x87, 0x23, 0x5D, 0xC9, 0x06, 0xA5, + 0xC3, 0xE4, 0x7A, 0x96, 0x4B, 0xCA, 0xEE, 0x13 + }, + { + 0x85, 0xEA, 0x6C, 0x56, 0x16, 0x18, 0xBF, 0x21, + 0x69, 0xC5, 0xCC, 0x2D, 0xBB, 0x3C, 0x7F, 0x50, + 0xEF, 0xD1, 0xBB, 0x3B, 0x3F, 0xFB, 0xE2, 0x24, + 0x6C, 0x8A, 0xDD, 0xE4, 0xBE, 0xDA, 0x67, 0x0F, + 0x1F, 0x97, 0xBA, 0xB1, 0x05, 0xD1, 0x67, 0xD7, + 0x97, 0x0C, 0xCA, 0x91, 0x24, 0x78, 0xF2, 0x9C, + 0x42, 0xFE, 0x56, 0x25, 0x49, 0xF4, 0x0F, 0x77, + 0x4A, 0xB2, 0x4D, 0x81, 0x9F, 0x4C, 0x3F, 0xFF + }, + { + 0xE6, 0x3B, 0x5E, 0x76, 0x12, 0xE9, 0xC1, 0x1B, + 0xEF, 0x3B, 0x4D, 0x5E, 0xA3, 0xA6, 0x81, 0x38, + 0x64, 0x2E, 0x94, 0x8F, 0xB2, 0x6A, 0xD1, 0xC5, + 0xC0, 0xB2, 0xC4, 0x0D, 0xD2, 0x6D, 0xFE, 0x24, + 0xA8, 0xFF, 0xED, 0xCD, 0xE0, 0x04, 0x1A, 0x20, + 0xE7, 0x16, 0x9D, 0x06, 0x51, 0x4F, 0x82, 0x34, + 0xC0, 0xAC, 0xA6, 0x59, 0xCD, 0x77, 0x81, 0x6A, + 0x2A, 0x7F, 0x84, 0x6E, 0xE6, 0x47, 0x5C, 0x02 + }, + { + 0x07, 0x63, 0x70, 0x5B, 0x00, 0x6D, 0x8A, 0x79, + 0x96, 0xA4, 0x5C, 0x15, 0x1E, 0xAE, 0x52, 0xC0, + 0xD0, 0x6E, 0xC8, 0x1E, 0x76, 0x8E, 0x2B, 0x56, + 0x25, 0x5D, 0xC6, 0xD3, 0x9E, 0x4F, 0xCA, 0xF5, + 0xA2, 0xD0, 0x7F, 0xF0, 0xE5, 0x04, 0x0D, 0x6A, + 0xAF, 0xB1, 0x76, 0xA4, 0x02, 0xB7, 0x49, 0x9F, + 0x8B, 0x3E, 0x58, 0x7E, 0x92, 0xAE, 0x83, 0x4E, + 0x40, 0x4E, 0x47, 0x87, 0x35, 0x08, 0xCB, 0x50 + }, + { + 0xA0, 0x0F, 0x81, 0x3F, 0x5B, 0xA0, 0x66, 0xFB, + 0xC7, 0x29, 0x0B, 0x35, 0x86, 0x1A, 0x7A, 0x51, + 0x03, 0x74, 0x11, 0xBD, 0xCD, 0x08, 0x71, 0x90, + 0x6A, 0x1C, 0x07, 0x15, 0x58, 0x54, 0x21, 0x30, + 0x71, 0x9C, 0x67, 0xC2, 0x01, 0x02, 0x00, 0x01, + 0x59, 0x8A, 0x63, 0x07, 0xB9, 0x1D, 0xAF, 0x4D, + 0xC5, 0xEF, 0x91, 0xC4, 0x4F, 0x3E, 0xEF, 0x59, + 0x01, 0x3E, 0x6D, 0xB0, 0xF5, 0x18, 0x82, 0x66 + }, + { + 0xD3, 0xB9, 0xA1, 0x31, 0x6F, 0x67, 0x34, 0x53, + 0x49, 0xBC, 0x81, 0x1E, 0xF7, 0x58, 0x39, 0x7A, + 0xA0, 0x22, 0x3D, 0xA9, 0x75, 0xCE, 0x8D, 0xF5, + 0x38, 0xDD, 0x5E, 0xED, 0xE8, 0xB7, 0x08, 0x9A, + 0x46, 0x50, 0xC4, 0x09, 0xD2, 0x81, 0x8E, 0xA3, + 0xE9, 0xA7, 0x9A, 0x1F, 0x26, 0x7B, 0x47, 0xA9, + 0x08, 0xCA, 0x0D, 0x71, 0xA9, 0x63, 0xA6, 0x36, + 0xC8, 0xA1, 0x7C, 0xA5, 0x7D, 0x87, 0xF4, 0x5B + }, + { + 0xBB, 0xD3, 0x8D, 0x4A, 0x09, 0x01, 0xF0, 0xD6, + 0xF7, 0x71, 0xF1, 0xD7, 0x14, 0x46, 0x8B, 0x48, + 0x87, 0x2D, 0x65, 0xAF, 0x0C, 0x9F, 0xE7, 0xEA, + 0x70, 0x46, 0xA3, 0x2D, 0xC7, 0x03, 0xB6, 0x82, + 0xD5, 0x68, 0x1E, 0x84, 0x47, 0xC0, 0x26, 0x3F, + 0x18, 0x55, 0xD9, 0xDF, 0x71, 0x75, 0x3F, 0x1C, + 0xC0, 0xD7, 0xAE, 0xBC, 0xD5, 0x6D, 0x55, 0x63, + 0x45, 0x56, 0xC3, 0x56, 0x88, 0xEF, 0x85, 0x45 + }, + { + 0x39, 0xBA, 0x9F, 0x11, 0x70, 0x48, 0xB9, 0xA4, + 0xAB, 0xED, 0xA5, 0xAC, 0x97, 0xEF, 0xB2, 0xC5, + 0x13, 0x3B, 0xB6, 0x4D, 0xE2, 0x34, 0x17, 0x29, + 0x93, 0xA5, 0x04, 0x41, 0x85, 0x32, 0xC8, 0xEF, + 0xA9, 0xB5, 0xFB, 0xC6, 0xB7, 0xF1, 0xB9, 0xA9, + 0x8E, 0xCE, 0x6B, 0xC9, 0x8D, 0x62, 0x26, 0x07, + 0xA3, 0xC6, 0xE6, 0xAE, 0x62, 0x5A, 0x40, 0xE7, + 0xB0, 0x59, 0xAD, 0x6E, 0x81, 0x0B, 0x43, 0x8F + }, + { + 0xFC, 0x4B, 0x1A, 0x1B, 0x41, 0x24, 0x69, 0xC5, + 0xB4, 0x23, 0xF0, 0xB9, 0xA8, 0xE5, 0x75, 0xC9, + 0xA7, 0x3E, 0xF7, 0x3A, 0x45, 0xA6, 0x45, 0xA3, + 0xE2, 0xAF, 0x91, 0x97, 0xF6, 0xB0, 0xF2, 0xE5, + 0x15, 0xC7, 0xEE, 0x21, 0xC7, 0xE9, 0xB2, 0xBE, + 0x8A, 0xC9, 0xE6, 0x8B, 0xDC, 0x2B, 0x2A, 0x83, + 0x59, 0x33, 0x86, 0xF4, 0xE4, 0x42, 0xD8, 0x61, + 0xC3, 0x87, 0xE7, 0x97, 0x87, 0x77, 0xCF, 0xBE + }, + { + 0xE2, 0xCD, 0x57, 0x90, 0x34, 0x2C, 0x4F, 0x22, + 0xDC, 0x8D, 0x39, 0x93, 0xB1, 0xA7, 0x27, 0x3E, + 0x8C, 0x29, 0xF4, 0x84, 0x09, 0xBF, 0x56, 0x87, + 0xA7, 0x79, 0xAA, 0x4F, 0x43, 0x06, 0x45, 0x5C, + 0x45, 0x59, 0x88, 0x59, 0xB4, 0x53, 0xB9, 0xC6, + 0x85, 0x30, 0x9E, 0x92, 0x31, 0x96, 0x62, 0x5D, + 0x73, 0x1B, 0x94, 0x2B, 0x24, 0x36, 0x00, 0x30, + 0x4E, 0xA4, 0xF7, 0x6E, 0xE2, 0x56, 0xAC, 0x05 + }, + { + 0x27, 0x78, 0x57, 0x4C, 0x1E, 0x9B, 0x06, 0x56, + 0x97, 0x9F, 0x27, 0x36, 0xAA, 0xA2, 0x5C, 0x90, + 0xFA, 0x37, 0x7B, 0x91, 0x6E, 0xEE, 0xBA, 0x32, + 0x39, 0x8C, 0x2D, 0x0E, 0x65, 0x98, 0xA0, 0x73, + 0x47, 0x4C, 0x36, 0x7B, 0x7D, 0x14, 0xC7, 0xA3, + 0x12, 0xB5, 0x77, 0xBC, 0xFD, 0xDE, 0x50, 0x72, + 0x38, 0xCF, 0x56, 0x25, 0x6A, 0xA2, 0x73, 0xAF, + 0xE2, 0x51, 0xCB, 0xC0, 0x8B, 0x7D, 0x05, 0x7F + }, + { + 0x22, 0xC4, 0x74, 0xB8, 0xDA, 0x8E, 0x1B, 0xBC, + 0xB6, 0xCB, 0x5A, 0x2D, 0x38, 0x89, 0x94, 0xEC, + 0x2A, 0x25, 0x44, 0x6C, 0x79, 0xE4, 0x9C, 0x97, + 0x60, 0x55, 0xBA, 0xD2, 0x48, 0x22, 0xDE, 0x5C, + 0xE7, 0xD5, 0x83, 0x37, 0x86, 0x3E, 0x14, 0x3C, + 0xC6, 0x53, 0x9F, 0xB4, 0x5B, 0x3C, 0xF6, 0x41, + 0xB3, 0xD4, 0xD5, 0x51, 0xDA, 0x9C, 0x0C, 0x9C, + 0x05, 0x0F, 0x31, 0x52, 0x7B, 0xD2, 0x6D, 0xF4 + }, + { + 0x3C, 0xC9, 0xD7, 0x23, 0x10, 0xE3, 0x2B, 0x6E, + 0xBC, 0xBE, 0x1E, 0x2B, 0x49, 0x82, 0x89, 0x0D, + 0x87, 0xF1, 0x4A, 0xC5, 0xE9, 0x31, 0xC3, 0x76, + 0x8F, 0x5A, 0x61, 0x49, 0x90, 0xF3, 0xA9, 0xEE, + 0x77, 0x9F, 0x7C, 0xBF, 0x0D, 0x2E, 0x92, 0xF6, + 0x7B, 0xE6, 0x0D, 0x8E, 0x28, 0x39, 0x7A, 0xDD, + 0x35, 0x1C, 0x46, 0x27, 0x7C, 0x36, 0x3A, 0xB6, + 0x48, 0x0C, 0xE0, 0x89, 0x53, 0x20, 0xA6, 0x0C + }, + { + 0x81, 0xB9, 0xEF, 0x7D, 0xA8, 0xD2, 0xA3, 0x3D, + 0x91, 0xF8, 0xC5, 0xB4, 0xE4, 0x61, 0xBA, 0x55, + 0xFD, 0x7D, 0xDA, 0xD9, 0x20, 0xF5, 0xE8, 0x5C, + 0x26, 0x16, 0x6E, 0x83, 0x62, 0x30, 0x54, 0xD3, + 0x7F, 0x08, 0x0E, 0x18, 0xBC, 0x07, 0x6A, 0xF3, + 0x1D, 0x31, 0xEC, 0x4A, 0x8A, 0x83, 0x9B, 0xE0, + 0x37, 0xA5, 0x78, 0x57, 0x08, 0x84, 0x71, 0xBD, + 0x01, 0x86, 0x6E, 0xE4, 0x6B, 0x23, 0x11, 0xAF + }, + { + 0x11, 0x9D, 0xEC, 0xD6, 0x1C, 0xC9, 0x26, 0xF4, + 0x48, 0x5A, 0x3B, 0x8D, 0x08, 0x9F, 0x1C, 0x49, + 0x4B, 0xFD, 0x63, 0xCE, 0xBD, 0x7F, 0x24, 0xF0, + 0xCC, 0x8B, 0x8F, 0x77, 0x91, 0x86, 0x1A, 0x17, + 0x78, 0xE0, 0x23, 0xE7, 0x37, 0x4E, 0xF9, 0x76, + 0x24, 0xB4, 0x9D, 0x86, 0xFF, 0x79, 0x54, 0xBE, + 0x35, 0x15, 0x63, 0x5F, 0x9A, 0xE3, 0xCF, 0x0E, + 0x4B, 0x9D, 0x02, 0xA7, 0xDC, 0x93, 0xE8, 0xC8 + }, + { + 0xCD, 0xEE, 0xC4, 0x3D, 0xEE, 0xB9, 0x79, 0x87, + 0x65, 0x2A, 0x5A, 0xED, 0xDA, 0xD4, 0x5D, 0x93, + 0xA0, 0x8E, 0xDE, 0x0B, 0x4B, 0x93, 0xC2, 0x02, + 0x7C, 0xE6, 0x34, 0xF7, 0x46, 0x68, 0xC4, 0xF4, + 0x63, 0xC7, 0x65, 0x07, 0x42, 0x72, 0x15, 0xFF, + 0x61, 0x12, 0x66, 0x88, 0xF2, 0x7F, 0x0E, 0x59, + 0x84, 0x1B, 0xD8, 0x42, 0xA7, 0x90, 0x2D, 0xC7, + 0x98, 0x89, 0x66, 0x18, 0x5E, 0xEC, 0x45, 0x48 + }, + { + 0x02, 0xCB, 0x80, 0xB2, 0xD4, 0xE5, 0x11, 0x9C, + 0xE8, 0xCD, 0xAB, 0x63, 0x74, 0xA3, 0x75, 0x34, + 0x1F, 0x52, 0x96, 0x3F, 0xD4, 0x76, 0xA5, 0x84, + 0xE9, 0xD5, 0x05, 0x15, 0x5B, 0x29, 0x37, 0x95, + 0x95, 0xEB, 0x87, 0xCD, 0xAE, 0x3A, 0xD1, 0x76, + 0x63, 0xE6, 0xF3, 0xBF, 0xB9, 0x40, 0xFC, 0xC0, + 0x3C, 0x02, 0xE7, 0xFE, 0xC3, 0x37, 0x02, 0x00, + 0xF8, 0x96, 0x2E, 0x31, 0xAF, 0x3D, 0x4F, 0xA7 + }, + { + 0xFA, 0x0C, 0x5B, 0x47, 0x11, 0x24, 0x38, 0xA3, + 0xC5, 0xB4, 0xAC, 0x71, 0x4E, 0x91, 0x15, 0xB5, + 0x54, 0x88, 0xA4, 0x24, 0x76, 0x78, 0x7A, 0xFF, + 0x26, 0x23, 0x0F, 0x3D, 0x6D, 0x7E, 0x2C, 0x17, + 0x10, 0x46, 0x6F, 0x0B, 0x5D, 0x20, 0x5B, 0x83, + 0x80, 0x12, 0x41, 0x6C, 0x1C, 0xEC, 0x51, 0xF0, + 0xC8, 0x48, 0x62, 0x01, 0xC9, 0x65, 0x4D, 0xD5, + 0x18, 0x54, 0x2B, 0x5F, 0x88, 0x97, 0x25, 0xC6 + }, + { + 0xE1, 0xDF, 0x73, 0xCE, 0x41, 0x0B, 0x9A, 0x9A, + 0xFD, 0x3C, 0xFD, 0x9E, 0xCF, 0x10, 0x89, 0x12, + 0x11, 0x08, 0xB5, 0x25, 0x79, 0x78, 0x33, 0x7F, + 0xB3, 0xAE, 0xF9, 0x6C, 0xBB, 0x65, 0xF7, 0xCC, + 0x19, 0x67, 0x7B, 0x63, 0xC9, 0x9D, 0x69, 0xAB, + 0x93, 0xBA, 0x63, 0x06, 0xAB, 0x23, 0x96, 0xF8, + 0x85, 0xBF, 0x3C, 0x99, 0x55, 0x83, 0x8F, 0xBD, + 0x08, 0x7F, 0xAC, 0xE4, 0xE6, 0xCA, 0xF4, 0x32 + }, + { + 0xE9, 0x1E, 0x03, 0x44, 0x44, 0x21, 0x84, 0x94, + 0x38, 0x13, 0x41, 0xA4, 0x75, 0x76, 0x34, 0x5B, + 0x4A, 0x89, 0xAF, 0x22, 0x45, 0x41, 0x76, 0xB2, + 0xC5, 0xAF, 0xAF, 0x41, 0x2F, 0xFA, 0xCB, 0x56, + 0x45, 0x34, 0xB6, 0x0B, 0x4B, 0xDF, 0x59, 0xCA, + 0x7D, 0x40, 0x04, 0x8C, 0xB1, 0x6A, 0xBE, 0x1C, + 0xC9, 0x7C, 0xE3, 0x9F, 0x52, 0xC2, 0x02, 0x70, + 0xFF, 0x7E, 0xF8, 0x3F, 0xE5, 0x76, 0xDF, 0x38 + }, + { + 0x7B, 0x24, 0xDA, 0xFA, 0x05, 0x74, 0x77, 0xC0, + 0x85, 0x30, 0xBD, 0xA6, 0xC6, 0xB3, 0xDB, 0x91, + 0x81, 0x2C, 0xEC, 0x18, 0x06, 0xEB, 0x16, 0x88, + 0x72, 0x28, 0xDE, 0x57, 0x5A, 0x4C, 0xDF, 0x16, + 0x4B, 0xA0, 0x2C, 0xE9, 0xBD, 0xCE, 0x91, 0xB8, + 0x9A, 0x04, 0xBD, 0xDA, 0x21, 0x0A, 0xB5, 0x40, + 0x7D, 0x14, 0x6C, 0x66, 0x25, 0x06, 0x15, 0xCC, + 0x9B, 0x64, 0x9F, 0xF5, 0xB3, 0x83, 0x82, 0x4A + }, + { + 0xA7, 0x50, 0xD2, 0x29, 0xF6, 0x82, 0x16, 0x2C, + 0x48, 0x38, 0xEF, 0x2D, 0x95, 0x13, 0x9F, 0xC0, + 0x4C, 0x6E, 0xD6, 0x90, 0x23, 0x5F, 0x07, 0x4E, + 0x4E, 0xEF, 0xBE, 0x03, 0xCB, 0xC3, 0xA8, 0x55, + 0x9C, 0x97, 0x95, 0x17, 0xA3, 0x60, 0xB8, 0x1A, + 0x7F, 0x43, 0x56, 0x03, 0xA4, 0x00, 0x36, 0x91, + 0xEA, 0x14, 0x3C, 0x48, 0x32, 0xD2, 0x71, 0xF9, + 0xE6, 0xAE, 0x9E, 0xA9, 0x63, 0x9C, 0x21, 0xCF + }, + { + 0xB2, 0xA4, 0x09, 0x0D, 0x8B, 0xA9, 0x6A, 0xCC, + 0x85, 0x35, 0x4E, 0x8A, 0xEB, 0xFA, 0xEC, 0x49, + 0x44, 0xF8, 0xE4, 0x50, 0x59, 0xAF, 0x7A, 0x4D, + 0x36, 0x11, 0x90, 0x71, 0x37, 0xFA, 0x2B, 0xA2, + 0xA8, 0xEF, 0xBA, 0x5C, 0xB5, 0x06, 0x38, 0x36, + 0x36, 0xBE, 0x9C, 0x22, 0xCE, 0x9E, 0x69, 0xED, + 0xAF, 0x52, 0xC9, 0x4F, 0x90, 0x41, 0xF1, 0x57, + 0x53, 0xC0, 0xC9, 0x2E, 0x7B, 0xCA, 0xC1, 0x56 + }, + { + 0xC0, 0x07, 0x20, 0x60, 0x5E, 0x0F, 0x85, 0xC7, + 0x6F, 0x7F, 0xF1, 0xEC, 0x49, 0x72, 0x2D, 0x64, + 0x67, 0x73, 0xE5, 0xDD, 0x88, 0xF5, 0xD6, 0x4E, + 0xAD, 0x7C, 0x8C, 0x88, 0xD0, 0x40, 0xCF, 0x52, + 0x29, 0xCB, 0x75, 0x57, 0x75, 0x85, 0x98, 0x69, + 0x27, 0x7B, 0x5F, 0x0E, 0x48, 0x61, 0xE2, 0x7B, + 0xF8, 0xA9, 0xA2, 0xE9, 0x37, 0xB4, 0x3E, 0xED, + 0xD9, 0xD1, 0x05, 0x24, 0xAE, 0x58, 0x34, 0x89 + }, + { + 0x28, 0x75, 0xF0, 0xF6, 0xE9, 0xC8, 0xC9, 0xC6, + 0x48, 0xEA, 0x92, 0xF3, 0x94, 0x87, 0x44, 0x89, + 0x70, 0x1C, 0x05, 0xAF, 0x4E, 0xE7, 0x8B, 0x69, + 0xCB, 0xAF, 0xAF, 0xFA, 0x85, 0x2F, 0xC2, 0xC6, + 0x9E, 0xE7, 0x72, 0x66, 0x3D, 0x7E, 0x52, 0x52, + 0x65, 0x31, 0x2C, 0xDE, 0xC8, 0x7F, 0x5C, 0xD7, + 0x21, 0xE7, 0x25, 0x50, 0x23, 0x55, 0x89, 0xB9, + 0x16, 0x9C, 0x73, 0x1B, 0x98, 0x77, 0x41, 0x42 + }, + { + 0x7B, 0xEF, 0xDF, 0xFB, 0x27, 0x85, 0x0F, 0x82, + 0x34, 0x1C, 0xDA, 0x48, 0x28, 0xCC, 0x13, 0xE6, + 0xFF, 0x0D, 0xFA, 0xF6, 0xA7, 0xC2, 0x99, 0xFA, + 0xF1, 0xBB, 0xF4, 0xFE, 0xCA, 0x59, 0x5F, 0xA8, + 0xFB, 0x4B, 0x09, 0x70, 0x87, 0xAB, 0x0A, 0x34, + 0x71, 0x21, 0xDC, 0xA0, 0x31, 0x8F, 0x8F, 0x68, + 0x05, 0xE1, 0x5D, 0x03, 0xD8, 0x76, 0x74, 0x49, + 0xD3, 0x57, 0x68, 0xE2, 0xA1, 0x25, 0xED, 0x5D + }, + { + 0xFF, 0xDF, 0xA8, 0x3F, 0xF8, 0xC3, 0x1B, 0xF9, + 0x28, 0xEF, 0xAD, 0xD3, 0xB6, 0xB1, 0x7C, 0xDA, + 0xD7, 0x21, 0x1D, 0x95, 0x35, 0x59, 0x66, 0xE8, + 0xB9, 0x95, 0xDE, 0x3E, 0xC0, 0xF3, 0xCA, 0xD6, + 0x19, 0xD9, 0xA9, 0x37, 0xB1, 0x0C, 0x2C, 0x6A, + 0xE3, 0xA7, 0x70, 0x8F, 0x19, 0x77, 0x98, 0x13, + 0x80, 0xEF, 0xE4, 0xBF, 0xA6, 0x20, 0xB3, 0x43, + 0x26, 0x37, 0xC6, 0x70, 0x91, 0x36, 0x1F, 0x69 + }, + { + 0x11, 0xA1, 0xB8, 0x13, 0x23, 0x7B, 0x41, 0xEB, + 0x0D, 0x44, 0x15, 0x31, 0x0A, 0x18, 0xFD, 0xE4, + 0xB5, 0x14, 0x62, 0xF9, 0x4B, 0x34, 0xAD, 0xE3, + 0xDB, 0xEC, 0xD1, 0xE3, 0x95, 0x8B, 0xF2, 0x37, + 0x6E, 0xFC, 0x64, 0xB6, 0x9B, 0xFE, 0x6D, 0x8C, + 0xD3, 0x64, 0xC3, 0xF1, 0x15, 0x8F, 0xA8, 0xF2, + 0x91, 0x4D, 0xEA, 0xA4, 0x61, 0x26, 0x04, 0xE2, + 0xA7, 0x71, 0x27, 0x80, 0x88, 0x0B, 0x3F, 0xE8 + }, + { + 0xFA, 0xD9, 0x7F, 0x15, 0x87, 0x86, 0x23, 0xBC, + 0x35, 0x77, 0xEE, 0x2C, 0xBA, 0xC9, 0xFF, 0xD4, + 0x8B, 0xE6, 0x2B, 0x02, 0x2B, 0x48, 0xE4, 0x94, + 0xDB, 0xD5, 0xB9, 0x95, 0x78, 0xC7, 0x1A, 0x52, + 0x09, 0x3D, 0x96, 0x46, 0x6F, 0x02, 0x5C, 0x78, + 0xFF, 0x73, 0x9D, 0x6B, 0x9E, 0x49, 0x76, 0xD7, + 0x73, 0x09, 0x34, 0x2E, 0x90, 0x99, 0xA2, 0xC0, + 0x9B, 0xA7, 0xF5, 0x73, 0x60, 0x2A, 0xCB, 0xE0 + }, + { + 0xD6, 0x91, 0x78, 0xDC, 0xE8, 0xA0, 0xFA, 0xC1, + 0x01, 0xC3, 0xA1, 0xA5, 0xD3, 0xDD, 0x0F, 0x98, + 0x82, 0xC8, 0x11, 0x30, 0x87, 0x74, 0xEC, 0xD2, + 0x15, 0x30, 0xC7, 0x92, 0x72, 0x02, 0xFE, 0xD1, + 0xD1, 0x0F, 0x11, 0xE4, 0xB0, 0x6A, 0x60, 0x51, + 0xB4, 0xB4, 0x94, 0xC5, 0xB4, 0x16, 0xCD, 0x04, + 0xC6, 0x20, 0x35, 0x72, 0x42, 0xC1, 0x2C, 0x75, + 0xD3, 0xAF, 0xDD, 0xE3, 0xC8, 0x0D, 0xB5, 0xD5 + }, + { + 0xD8, 0xEE, 0x03, 0x74, 0xC2, 0xDE, 0x36, 0x76, + 0x84, 0x37, 0xAF, 0x76, 0x25, 0x68, 0xA4, 0x7E, + 0x48, 0xA9, 0xA9, 0x9F, 0xAF, 0x94, 0x20, 0x72, + 0x10, 0x03, 0xC6, 0xA3, 0x9F, 0x54, 0xB4, 0x28, + 0xE4, 0x90, 0x4F, 0xE1, 0x2F, 0xC4, 0x95, 0xE0, + 0xDD, 0xA5, 0xCA, 0x11, 0x1F, 0x8A, 0x18, 0xD6, + 0xDD, 0x0D, 0x41, 0x41, 0x2C, 0x33, 0xF4, 0x66, + 0x4D, 0xB7, 0x26, 0x01, 0xCF, 0xCA, 0x4E, 0xE6 + }, + { + 0xE2, 0x73, 0xAF, 0xDC, 0xD8, 0x34, 0xEA, 0xB5, + 0x20, 0x8D, 0x46, 0x0D, 0x60, 0x9B, 0x77, 0xEA, + 0xA0, 0x1C, 0xB5, 0x29, 0xD7, 0xE5, 0xB0, 0x9E, + 0x56, 0xD3, 0x33, 0x0A, 0x4B, 0xB1, 0xDC, 0x9F, + 0x15, 0x8B, 0xF5, 0x1A, 0xBC, 0x04, 0x2C, 0x87, + 0x1D, 0x92, 0x47, 0xCF, 0xF2, 0x97, 0xEF, 0xCE, + 0xD1, 0xCC, 0x47, 0xB4, 0x5A, 0x2F, 0xF2, 0x8E, + 0x84, 0x5A, 0x2A, 0x9D, 0x27, 0x6D, 0xC3, 0x2F + }, + { + 0x18, 0x9A, 0x9D, 0xDF, 0x0D, 0xEC, 0xE2, 0xFA, + 0x77, 0x23, 0x49, 0x7E, 0x08, 0x6F, 0xDE, 0x3D, + 0x6C, 0xBF, 0xAC, 0x5B, 0xAE, 0x69, 0x31, 0x5A, + 0x7B, 0x50, 0xAD, 0xF5, 0xC8, 0x9B, 0xBB, 0xB1, + 0x84, 0xAD, 0x1D, 0x68, 0xA1, 0x53, 0xF0, 0xFB, + 0x34, 0x90, 0x39, 0x0B, 0x1F, 0x44, 0xA9, 0x19, + 0x3E, 0x26, 0x6C, 0xF6, 0x2A, 0x08, 0x18, 0x5A, + 0x40, 0x7C, 0x26, 0x7A, 0xDE, 0xA5, 0x6F, 0xF0 + }, + { + 0xA0, 0x7C, 0x27, 0xDB, 0xBC, 0xBE, 0x3F, 0x1D, + 0xB5, 0xEC, 0x45, 0x60, 0xE1, 0x52, 0xB7, 0x1B, + 0x53, 0x44, 0xB1, 0xFB, 0x82, 0x5E, 0x12, 0xDB, + 0x12, 0xA6, 0xD4, 0xB9, 0x7F, 0x50, 0xAC, 0xD7, + 0xB9, 0xAF, 0x0B, 0xE4, 0xC4, 0x77, 0xAF, 0x60, + 0xE0, 0x02, 0xC4, 0x9A, 0xD2, 0x7E, 0xC6, 0xB2, + 0x6F, 0x1C, 0xED, 0xF1, 0x42, 0xAF, 0x38, 0x3C, + 0xE9, 0x88, 0xDB, 0x26, 0xDC, 0xE3, 0x89, 0x55 + }, + { + 0x22, 0xBB, 0x7E, 0x8B, 0xC1, 0x1E, 0x98, 0x8C, + 0x61, 0x03, 0x07, 0x4D, 0x0F, 0x3F, 0x48, 0x57, + 0xDD, 0xC7, 0xA7, 0xB1, 0xBA, 0xF6, 0xAD, 0x66, + 0xE2, 0x14, 0xEB, 0x4F, 0x36, 0x4A, 0x8B, 0xB3, + 0x22, 0x30, 0x2B, 0x01, 0x3F, 0x19, 0xEB, 0x45, + 0x12, 0xB9, 0x21, 0x9C, 0x2B, 0xC0, 0x56, 0xE3, + 0xC1, 0xA9, 0x9A, 0x54, 0x34, 0x0F, 0x99, 0x42, + 0x08, 0x22, 0xC3, 0xBA, 0xFF, 0x02, 0x58, 0xC6 + }, + { + 0x45, 0xC2, 0x18, 0x01, 0xAF, 0x2C, 0x78, 0x2C, + 0xC3, 0xBE, 0xB4, 0x1F, 0x97, 0x4B, 0x80, 0x28, + 0xDC, 0x4D, 0x45, 0x1A, 0x81, 0x23, 0x76, 0xD6, + 0x04, 0x92, 0x29, 0x23, 0x01, 0xC1, 0x89, 0x91, + 0x82, 0x4D, 0x72, 0xB8, 0x05, 0xD6, 0xAF, 0xF4, + 0x99, 0xBF, 0xFC, 0x38, 0xDA, 0xD2, 0xA5, 0x97, + 0x50, 0x9F, 0x2B, 0x24, 0x17, 0xF6, 0x6A, 0x44, + 0xD8, 0x6A, 0x2C, 0x42, 0x89, 0xB1, 0xA1, 0xA9 + }, + { + 0x2A, 0x7A, 0x13, 0xD3, 0x1F, 0x5A, 0x50, 0xC7, + 0x11, 0x5A, 0x27, 0xA2, 0xF8, 0x01, 0xAC, 0x1A, + 0x14, 0xB0, 0xCC, 0x65, 0xEF, 0x24, 0x10, 0xCD, + 0x77, 0xE2, 0x8E, 0x5F, 0x57, 0xF4, 0x2D, 0x03, + 0x90, 0x50, 0x9C, 0xD7, 0x87, 0xD0, 0x71, 0x92, + 0x16, 0x17, 0x48, 0x3D, 0x15, 0x31, 0xF8, 0x59, + 0xF5, 0xDE, 0x29, 0x20, 0xDD, 0x9B, 0x85, 0x62, + 0x17, 0x6F, 0x31, 0x0A, 0xB9, 0x2E, 0xE6, 0x02 + }, + { + 0x88, 0xDC, 0x1D, 0x5E, 0x24, 0x56, 0x59, 0x3E, + 0xC2, 0x8B, 0xE7, 0x1A, 0x6D, 0x97, 0xAA, 0xD0, + 0x22, 0xA3, 0xCA, 0x41, 0x13, 0x0F, 0x2C, 0x65, + 0x9B, 0xDD, 0x9C, 0x25, 0x9F, 0x73, 0x39, 0x01, + 0x99, 0x9E, 0x17, 0xFD, 0x69, 0x1D, 0x12, 0x9D, + 0x81, 0xA1, 0xEA, 0xF0, 0x71, 0xDA, 0x7E, 0x15, + 0x8D, 0x96, 0x15, 0x78, 0xC7, 0xE2, 0xD5, 0x7C, + 0x4C, 0x11, 0xDD, 0xFB, 0x20, 0xAA, 0x1C, 0xC2 + }, + { + 0xF7, 0x35, 0x33, 0x98, 0xDB, 0xC6, 0x8F, 0x15, + 0x74, 0x81, 0xA4, 0xE4, 0xCB, 0xF5, 0x3D, 0x0A, + 0xC5, 0x16, 0x9F, 0x0C, 0x25, 0xF6, 0x3B, 0x1F, + 0x46, 0x07, 0x34, 0x35, 0x41, 0x7A, 0x6A, 0xCB, + 0x60, 0x8C, 0x36, 0x6A, 0xBB, 0x2A, 0x5D, 0x19, + 0x78, 0x6A, 0x10, 0x72, 0x90, 0x5C, 0xE3, 0x69, + 0xA6, 0x91, 0x0E, 0xDA, 0x5C, 0x3B, 0x91, 0x41, + 0x8F, 0x33, 0xE6, 0xBF, 0x87, 0x33, 0xED, 0x7D + }, + { + 0x68, 0x88, 0x36, 0x93, 0x73, 0x9A, 0x04, 0xD3, + 0x0D, 0x2C, 0x56, 0x41, 0xC4, 0xBF, 0xF6, 0xF7, + 0x50, 0x0E, 0x5F, 0x5D, 0x3D, 0xFD, 0xCF, 0x63, + 0xE4, 0x47, 0xD3, 0xC8, 0x41, 0x14, 0xDB, 0xE6, + 0x83, 0x3C, 0xC6, 0x11, 0x73, 0x76, 0xD5, 0x1F, + 0xDE, 0x70, 0x96, 0x31, 0x76, 0xFD, 0x07, 0xB5, + 0x58, 0xD3, 0x8B, 0x8E, 0x96, 0xF3, 0x9E, 0x1C, + 0xDC, 0x27, 0xA4, 0x1A, 0x43, 0x15, 0xB3, 0xC4 + }, + { + 0xB0, 0xD6, 0x75, 0xD0, 0x4B, 0x92, 0xB1, 0x15, + 0x21, 0xCF, 0xA5, 0xCB, 0xFD, 0xA6, 0x45, 0x8D, + 0x63, 0xD6, 0xC9, 0xE3, 0xA7, 0xDC, 0xB6, 0x27, + 0x11, 0x60, 0x20, 0xD9, 0x73, 0x5C, 0x73, 0xA4, + 0x88, 0x28, 0xE9, 0xAB, 0xD2, 0x1B, 0xD5, 0x92, + 0xB4, 0xDB, 0x7F, 0x01, 0xC3, 0xE0, 0xFC, 0x26, + 0x1F, 0x47, 0xB7, 0x39, 0x32, 0x33, 0xE8, 0xD7, + 0x03, 0x32, 0xC2, 0x73, 0x0E, 0x67, 0xCE, 0xB2 + }, + { + 0xF4, 0xEA, 0xFF, 0x87, 0x1A, 0xCE, 0x80, 0x79, + 0x83, 0x6F, 0x9F, 0x9C, 0x24, 0x56, 0x75, 0x54, + 0x41, 0x87, 0x90, 0xEC, 0x72, 0x8D, 0x7D, 0x31, + 0xC3, 0x89, 0xAC, 0x8F, 0xE2, 0x88, 0x7D, 0xDB, + 0x07, 0x9E, 0xE4, 0x27, 0x33, 0x2B, 0x6A, 0xE3, + 0x3B, 0x04, 0xB5, 0xC1, 0x8C, 0x36, 0xF3, 0x9C, + 0xEE, 0x04, 0x38, 0xA2, 0x36, 0xE9, 0x92, 0xD2, + 0xFD, 0xFC, 0x27, 0x33, 0x7F, 0x6D, 0x27, 0x9F + }, + { + 0xAC, 0x6B, 0x84, 0xD3, 0x0E, 0x9E, 0x2C, 0x0B, + 0x0D, 0xDE, 0xD7, 0xAE, 0xB5, 0x50, 0x21, 0xD8, + 0x23, 0xC8, 0x74, 0xDF, 0x5A, 0xE7, 0x83, 0x20, + 0x1B, 0x96, 0xEC, 0x71, 0x6C, 0xAC, 0x20, 0x2A, + 0x28, 0xF7, 0xD1, 0xD6, 0x1D, 0x27, 0xDD, 0x21, + 0x79, 0x22, 0x0F, 0x27, 0x7B, 0x53, 0xF8, 0xE2, + 0x25, 0x45, 0x58, 0x26, 0xDD, 0x8E, 0xEA, 0x30, + 0x8B, 0x77, 0x1E, 0xE2, 0xFB, 0xE6, 0x81, 0xE7 + }, + { + 0x3C, 0x13, 0x4B, 0x0B, 0x32, 0x80, 0xB7, 0x52, + 0xA9, 0xAF, 0x04, 0xDA, 0xE3, 0x59, 0x00, 0xAA, + 0x80, 0x5C, 0x02, 0xB1, 0x7C, 0xEA, 0x00, 0xF3, + 0x3D, 0x4A, 0x82, 0x0F, 0x1C, 0x09, 0xF6, 0x53, + 0x69, 0x02, 0xFE, 0xFE, 0x0C, 0xF2, 0x01, 0xF3, + 0x6B, 0xEC, 0x9E, 0x4E, 0xF3, 0x85, 0xF4, 0xE5, + 0x6C, 0x8C, 0xD6, 0xC1, 0x9F, 0xED, 0x62, 0xFA, + 0x90, 0x76, 0x05, 0x8F, 0x65, 0xB7, 0x51, 0x53 + }, + { + 0x38, 0x6A, 0x0B, 0x65, 0xD2, 0x11, 0xC5, 0x14, + 0xDA, 0x54, 0xA9, 0x1E, 0x05, 0x5F, 0xEF, 0x7F, + 0x45, 0xC5, 0xE5, 0xA3, 0x7D, 0x96, 0x1B, 0xEC, + 0x22, 0x6C, 0xA3, 0xFF, 0x8F, 0x31, 0x57, 0xFC, + 0x12, 0x76, 0x4E, 0xB5, 0xE1, 0x9A, 0xB2, 0x9C, + 0xA2, 0xC4, 0xD7, 0xE2, 0xF1, 0x80, 0x07, 0xD6, + 0x31, 0x3E, 0xB6, 0x76, 0xAB, 0x17, 0x5A, 0x43, + 0x1D, 0xF2, 0xDA, 0x19, 0x2C, 0xA0, 0x9C, 0xAA + }, + { + 0x4E, 0xB6, 0xF4, 0x8B, 0x15, 0xB8, 0x79, 0xCF, + 0x42, 0xD9, 0x81, 0x82, 0xFB, 0xDC, 0xBD, 0x50, + 0xA3, 0x75, 0x18, 0xF9, 0x04, 0x5C, 0x96, 0x82, + 0x00, 0x94, 0xFB, 0x3E, 0xEA, 0x2F, 0x1E, 0x19, + 0xB9, 0x30, 0xDC, 0xD2, 0x81, 0x33, 0x2F, 0xB0, + 0xC9, 0x1B, 0x11, 0xD0, 0x3B, 0xF3, 0xA8, 0x4A, + 0x87, 0x1E, 0x9B, 0xF0, 0x7A, 0x87, 0x91, 0x32, + 0xDE, 0x9D, 0x66, 0x72, 0x38, 0x83, 0x46, 0x1D + }, + { + 0x79, 0x9E, 0x31, 0x88, 0xB1, 0x31, 0xE3, 0xBF, + 0xC1, 0x53, 0x04, 0x36, 0x51, 0x77, 0x63, 0xAC, + 0x36, 0x7E, 0x3F, 0x14, 0xF4, 0xCD, 0x6B, 0xA6, + 0x49, 0x2D, 0x99, 0xF4, 0xD9, 0x4C, 0x02, 0x48, + 0x54, 0x64, 0xF9, 0x0F, 0xBB, 0xEF, 0xD8, 0xAE, + 0x00, 0xB4, 0x54, 0xDD, 0x2E, 0x87, 0xB0, 0x33, + 0x2E, 0x86, 0x7F, 0xC3, 0x5A, 0x4C, 0x69, 0xF1, + 0x32, 0xBB, 0x0C, 0x86, 0x5B, 0x8C, 0x64, 0xF2 + }, + { + 0x32, 0x48, 0xE2, 0xBE, 0xAB, 0x33, 0xC1, 0xD7, + 0x62, 0x85, 0x03, 0x3A, 0xC6, 0x45, 0x16, 0x44, + 0xBA, 0xBB, 0x7A, 0xFE, 0x57, 0x40, 0x27, 0x82, + 0xCC, 0xD0, 0xEC, 0x2F, 0x0F, 0xF3, 0x88, 0xD8, + 0xDC, 0x22, 0x56, 0x1F, 0x2D, 0x79, 0x26, 0x1A, + 0x02, 0x5F, 0xE7, 0x71, 0xD3, 0xAF, 0x8D, 0x35, + 0x0D, 0x36, 0xF8, 0xC1, 0x4E, 0x6D, 0x98, 0xCC, + 0xE9, 0x17, 0x86, 0x29, 0x85, 0xE1, 0x43, 0xDB + }, + { + 0xD6, 0x1E, 0x73, 0x55, 0xD5, 0x24, 0x41, 0x27, + 0xFD, 0x46, 0xA4, 0x3D, 0xCB, 0x8A, 0x8F, 0xF2, + 0x8C, 0x1D, 0x5D, 0x8D, 0x55, 0xE1, 0x63, 0x4B, + 0xCC, 0x3F, 0x0B, 0xD4, 0x28, 0x0F, 0xD4, 0x36, + 0xDE, 0x38, 0x69, 0x89, 0x11, 0x4B, 0x4C, 0xDD, + 0xA3, 0x6D, 0x48, 0xFA, 0xEB, 0xE5, 0x67, 0xB4, + 0xFF, 0x1A, 0x41, 0x6E, 0x53, 0x63, 0x37, 0x5B, + 0xAF, 0x36, 0x4C, 0x5A, 0xE9, 0xFA, 0xF5, 0xC5 + }, + { + 0x6F, 0xBF, 0x39, 0xCB, 0x06, 0x1B, 0xC9, 0x27, + 0xDB, 0xBE, 0xBE, 0x05, 0xC1, 0x1E, 0x47, 0x77, + 0x82, 0x53, 0x50, 0x77, 0xED, 0xAC, 0x7B, 0x37, + 0xFB, 0x57, 0x0B, 0x10, 0x67, 0x0F, 0x09, 0x8B, + 0x16, 0xBB, 0x6D, 0xEC, 0x01, 0x9D, 0xD6, 0xFA, + 0xF1, 0x11, 0x4F, 0xB2, 0x5E, 0x58, 0x01, 0xE3, + 0x85, 0xF6, 0x67, 0xFC, 0x12, 0x82, 0x1F, 0x1F, + 0xBE, 0xDF, 0x41, 0xEB, 0x0D, 0x9D, 0x9D, 0x7A + }, + { + 0x48, 0x32, 0xB6, 0x83, 0x4A, 0x5D, 0x75, 0x33, + 0x15, 0x6C, 0x5F, 0xB9, 0xB6, 0xFB, 0x88, 0x95, + 0xE2, 0x39, 0x76, 0x63, 0x4E, 0x44, 0xDE, 0xCA, + 0x46, 0x88, 0x4E, 0x8D, 0x67, 0x17, 0x12, 0xD9, + 0x97, 0x95, 0x96, 0xF3, 0x6E, 0x2D, 0x71, 0x67, + 0xB9, 0x65, 0xB3, 0xF8, 0x29, 0x25, 0xB2, 0x2B, + 0xBA, 0x8A, 0x8C, 0x04, 0x76, 0xCA, 0x8A, 0x7A, + 0xBF, 0x4C, 0xA6, 0xC8, 0x01, 0xE7, 0x26, 0x9A + }, + { + 0xB5, 0x46, 0x55, 0x7F, 0x32, 0x6D, 0x30, 0x98, + 0xEE, 0x44, 0xEA, 0x13, 0xF6, 0x1C, 0x84, 0xAD, + 0xE6, 0x4C, 0xE5, 0xAD, 0x80, 0x75, 0x35, 0x76, + 0xAF, 0xF4, 0xF1, 0x5B, 0x62, 0x92, 0x68, 0x4D, + 0x0C, 0x1A, 0x99, 0x7A, 0xB7, 0xD4, 0x14, 0x46, + 0xF1, 0x8F, 0x8F, 0x6B, 0x00, 0x0A, 0x0E, 0xA5, + 0xB7, 0x2B, 0xA2, 0x4D, 0x45, 0x82, 0x91, 0x43, + 0xA0, 0x4F, 0x27, 0x4F, 0xEB, 0x2C, 0x8F, 0x21 + }, + { + 0x18, 0xD4, 0x19, 0xFE, 0x75, 0xEF, 0x0F, 0x4D, + 0x5A, 0x72, 0x3E, 0xD6, 0x91, 0x1B, 0xEA, 0xF7, + 0x18, 0x94, 0x69, 0x4C, 0x9A, 0x60, 0xEF, 0x86, + 0xE3, 0x90, 0x73, 0xB5, 0x32, 0x90, 0x10, 0x7D, + 0x4E, 0xFA, 0x52, 0xBA, 0x2E, 0xA3, 0x72, 0x93, + 0xFB, 0x62, 0x38, 0x6F, 0xBC, 0x5A, 0xA5, 0xA8, + 0xB6, 0xCF, 0xC4, 0x30, 0xBC, 0xEF, 0x73, 0xAF, + 0xAD, 0x48, 0x15, 0x5E, 0xE5, 0x1C, 0x26, 0x50 + }, + { + 0x77, 0x93, 0x07, 0xF7, 0x09, 0x1F, 0xE4, 0x61, + 0x51, 0xA2, 0x08, 0x11, 0x8C, 0xDF, 0x48, 0xA0, + 0xB6, 0xFD, 0x92, 0x9C, 0xAD, 0x93, 0x5E, 0x6A, + 0xC9, 0xA8, 0x6A, 0x46, 0xE9, 0xA3, 0xFB, 0x14, + 0xB0, 0x2A, 0xB0, 0x82, 0x82, 0x75, 0x48, 0x59, + 0x32, 0x90, 0xCF, 0x35, 0xD3, 0xBC, 0xB3, 0x09, + 0x94, 0x0E, 0xC1, 0x96, 0x31, 0x17, 0x79, 0xE1, + 0x51, 0x4E, 0x46, 0x08, 0x78, 0x3F, 0x25, 0xD9 + }, + { + 0x11, 0x3D, 0x82, 0xE3, 0x63, 0x64, 0xA8, 0x8B, + 0x4C, 0x80, 0x49, 0xBC, 0xA3, 0x81, 0xB7, 0x74, + 0x04, 0x38, 0xB8, 0x42, 0x4F, 0xA3, 0x5B, 0x83, + 0x96, 0x2C, 0xDB, 0xF1, 0xCC, 0x27, 0x70, 0x11, + 0x4D, 0xB4, 0xB9, 0xF2, 0xF8, 0x57, 0x9E, 0xA1, + 0xF1, 0xD7, 0x4F, 0x9F, 0x18, 0xF5, 0xB9, 0xE2, + 0x17, 0xB5, 0x2B, 0xE0, 0xD1, 0x90, 0xD3, 0xE7, + 0x83, 0x9C, 0x37, 0x49, 0x37, 0xCC, 0xB5, 0xD4 + }, + { + 0xA1, 0x82, 0xFA, 0x05, 0x83, 0xB1, 0x6B, 0x27, + 0xAC, 0x6C, 0x3D, 0x43, 0xA9, 0x19, 0x3E, 0x92, + 0xB4, 0x16, 0x4F, 0x7C, 0xCD, 0x20, 0x09, 0xC0, + 0x92, 0xE9, 0xF5, 0x65, 0x9D, 0x44, 0xAF, 0xAC, + 0x29, 0xCF, 0x77, 0xCF, 0xBE, 0xB1, 0xEF, 0x35, + 0x65, 0x2F, 0x01, 0x34, 0xFE, 0xF5, 0xB8, 0x70, + 0xE0, 0xCF, 0xB9, 0xA7, 0x98, 0x0A, 0xF2, 0x17, + 0xFD, 0xD1, 0x54, 0xB5, 0x87, 0x27, 0x6C, 0x3D + }, + { + 0xB1, 0xD2, 0x9E, 0x33, 0x85, 0xA8, 0xE8, 0xD7, + 0x1A, 0xE9, 0x72, 0x8F, 0xB1, 0x73, 0xCC, 0xE4, + 0x2B, 0x2E, 0x48, 0x4A, 0x08, 0x64, 0x59, 0xC0, + 0x59, 0x52, 0x3C, 0x42, 0xC6, 0x5E, 0x31, 0xB7, + 0xC5, 0x0A, 0x20, 0x3C, 0x1E, 0x45, 0x72, 0x8E, + 0x82, 0x52, 0xA5, 0xF6, 0x4A, 0x1F, 0x54, 0x63, + 0x0E, 0x85, 0x97, 0x2B, 0x68, 0xDC, 0x69, 0x5E, + 0x56, 0x72, 0x71, 0xDC, 0x67, 0x0C, 0xF9, 0xE7 + }, + { + 0x86, 0x4B, 0xB5, 0x80, 0xD8, 0x8F, 0x0E, 0x32, + 0x50, 0x8C, 0x1E, 0x36, 0xF1, 0xA0, 0xA7, 0x56, + 0x45, 0xDF, 0xCE, 0x7A, 0x1C, 0x08, 0x71, 0x51, + 0xDC, 0x16, 0x89, 0x1F, 0xB1, 0x73, 0xE0, 0xE8, + 0x4C, 0x50, 0x5B, 0xDC, 0xCA, 0x33, 0x3B, 0x6F, + 0x81, 0x67, 0x54, 0x7D, 0x1E, 0x94, 0xDD, 0xB9, + 0x4E, 0xAA, 0x92, 0x4E, 0x11, 0xCE, 0xBC, 0x45, + 0x0D, 0x5D, 0x4F, 0x02, 0x4D, 0xF1, 0xE4, 0x7E + }, + { + 0xB1, 0xE2, 0x1F, 0x11, 0xAE, 0x79, 0x2B, 0x42, + 0x43, 0x34, 0x09, 0x9E, 0x91, 0x75, 0xE8, 0xBF, + 0xCE, 0xE0, 0x9B, 0x78, 0xF9, 0x6C, 0xA0, 0x6C, + 0x79, 0x67, 0x99, 0xF1, 0xBD, 0xE8, 0x0A, 0x5A, + 0x64, 0xF9, 0xFD, 0x8F, 0xC6, 0xCA, 0xFB, 0x3D, + 0xD0, 0xB6, 0x60, 0x57, 0x16, 0xE7, 0x13, 0x5C, + 0x53, 0x91, 0x92, 0xE4, 0xF4, 0x63, 0x6B, 0xBC, + 0x97, 0xBA, 0x8C, 0x43, 0x67, 0x12, 0x5C, 0x2E + }, + { + 0xB2, 0x5D, 0xE9, 0x81, 0x1A, 0x48, 0x98, 0x62, + 0x29, 0xE8, 0x1D, 0x4F, 0xD6, 0xCB, 0x7E, 0x01, + 0x46, 0x54, 0xB7, 0xB4, 0x6A, 0x72, 0xA1, 0x2B, + 0x7D, 0xEC, 0xF2, 0xBE, 0xF3, 0x45, 0x81, 0x22, + 0xEA, 0xB6, 0xAB, 0xD8, 0x8A, 0x20, 0x69, 0x50, + 0x42, 0x5C, 0x3B, 0x8A, 0x2F, 0x75, 0x20, 0x37, + 0xAC, 0x3F, 0x50, 0x4B, 0x52, 0xB8, 0x3E, 0xEB, + 0x74, 0xD6, 0x36, 0x34, 0xE9, 0xBD, 0x7D, 0x78 + }, + { + 0x81, 0x49, 0x53, 0x31, 0x3A, 0x50, 0x65, 0xE8, + 0x04, 0x96, 0xAC, 0xCD, 0x3A, 0x7E, 0x07, 0xE2, + 0x37, 0xE9, 0x4E, 0x2C, 0x88, 0x5F, 0x0F, 0x94, + 0xF3, 0x23, 0x36, 0xD1, 0x91, 0xF9, 0x21, 0x60, + 0xEB, 0x2D, 0xE0, 0x0A, 0xDE, 0x6B, 0xD7, 0x3E, + 0xBB, 0xCF, 0x85, 0x27, 0x2A, 0x84, 0xDB, 0x36, + 0x7A, 0xFE, 0x2F, 0xD0, 0xAA, 0xD9, 0x88, 0x61, + 0xA7, 0x71, 0x4C, 0x85, 0xAE, 0x03, 0xC4, 0xB3 + }, + { + 0xAF, 0xA1, 0x1C, 0xCA, 0xD1, 0xD5, 0x05, 0x9E, + 0x72, 0x98, 0x89, 0x08, 0x00, 0x5D, 0xF1, 0xBC, + 0xB3, 0xE5, 0x08, 0xD0, 0xF9, 0xD1, 0xC3, 0x71, + 0xB5, 0x72, 0xF5, 0xAE, 0xC6, 0xEE, 0xB7, 0x79, + 0x02, 0x7E, 0xAD, 0x0A, 0xF4, 0x4E, 0x72, 0x85, + 0x45, 0x3D, 0x49, 0x35, 0xF1, 0x1D, 0xE7, 0x3D, + 0xD4, 0x9F, 0xC1, 0xAA, 0xEA, 0x64, 0xFD, 0x78, + 0x1C, 0xFD, 0x85, 0x26, 0xEF, 0x46, 0xFD, 0xF6 + }, + { + 0xDB, 0x85, 0x6F, 0x13, 0x8A, 0xCA, 0x31, 0x81, + 0xAB, 0x03, 0x81, 0x36, 0xAF, 0x90, 0xE9, 0x9D, + 0x18, 0xB8, 0xE3, 0xBA, 0x78, 0x1B, 0xD2, 0x24, + 0xBA, 0x50, 0x34, 0x69, 0x2E, 0xF6, 0x5E, 0x7A, + 0x92, 0x6D, 0x5C, 0xF9, 0x52, 0x04, 0xCB, 0xAE, + 0xD1, 0x27, 0x8C, 0x9F, 0xEA, 0xA8, 0xC4, 0xCB, + 0xF4, 0x62, 0x94, 0x3C, 0x28, 0x09, 0x0C, 0x96, + 0x81, 0xB3, 0xD0, 0x4D, 0xCE, 0x6D, 0x40, 0x60 + }, + { + 0x93, 0x9C, 0xE9, 0xAB, 0x0E, 0xF1, 0xC6, 0xAC, + 0xB5, 0xEA, 0x01, 0xF5, 0x80, 0xE9, 0xD0, 0x62, + 0x81, 0xBD, 0x03, 0xD9, 0x16, 0x49, 0x04, 0x50, + 0xF5, 0xF0, 0x93, 0x4B, 0xC1, 0x68, 0xAF, 0x57, + 0x7F, 0xC5, 0xED, 0x4B, 0x01, 0x02, 0x98, 0x5F, + 0x0D, 0xC9, 0x19, 0x40, 0x2D, 0x98, 0x5D, 0x45, + 0xD4, 0xD6, 0xC7, 0x6D, 0x31, 0x35, 0x98, 0x58, + 0x8F, 0x48, 0xF4, 0x09, 0x0B, 0x96, 0x0A, 0xFF + }, + { + 0x97, 0xA6, 0x61, 0xC0, 0x57, 0x9D, 0x3F, 0xB7, + 0xBD, 0x6B, 0x36, 0x36, 0xFC, 0x22, 0x4C, 0x68, + 0x56, 0x53, 0xB5, 0x30, 0xFF, 0x32, 0x52, 0xFE, + 0xBB, 0x50, 0x2C, 0xDC, 0x8B, 0x80, 0xF9, 0x41, + 0x08, 0x3B, 0x79, 0x8A, 0xF6, 0x2B, 0x80, 0x57, + 0x18, 0x16, 0xB5, 0xFE, 0xB7, 0x39, 0x4C, 0x6E, + 0x18, 0x1D, 0x1E, 0xD3, 0x80, 0x7D, 0x9F, 0xBF, + 0xA0, 0x81, 0x2C, 0x09, 0x9A, 0xDE, 0x2C, 0xF7 + }, + { + 0x5C, 0x7B, 0xF1, 0xDF, 0xFE, 0x5D, 0x70, 0x44, + 0x43, 0x7A, 0xE4, 0xB1, 0xA0, 0xF9, 0x1D, 0x67, + 0xF4, 0xA5, 0x5D, 0x18, 0xD6, 0x84, 0x23, 0x2D, + 0x99, 0xDE, 0x2F, 0x94, 0xBB, 0x91, 0xDA, 0x7C, + 0xC2, 0x24, 0xD6, 0xE5, 0xB1, 0xB8, 0x9A, 0x45, + 0x03, 0x17, 0x5E, 0x4D, 0xA3, 0xBA, 0xEE, 0x3B, + 0xF3, 0xE9, 0x8D, 0x6F, 0x8C, 0x36, 0xFD, 0xE2, + 0xFC, 0xAE, 0x89, 0xDC, 0x5E, 0xA4, 0xE2, 0x6C + }, + { + 0xA1, 0x22, 0xBD, 0x56, 0xC1, 0xF4, 0xFC, 0x67, + 0xBB, 0x70, 0x92, 0xBF, 0xED, 0x4F, 0x42, 0x37, + 0x7F, 0x21, 0xAE, 0x78, 0x62, 0x38, 0xDA, 0xA3, + 0x73, 0xB2, 0xFF, 0x66, 0xA3, 0x19, 0xD6, 0x6C, + 0xE1, 0x42, 0x48, 0x0C, 0x1C, 0xFF, 0x03, 0xA6, + 0xB6, 0x2B, 0xA8, 0x77, 0x64, 0x5D, 0xE2, 0xB9, + 0x37, 0x1F, 0x6C, 0xA5, 0x5D, 0xFC, 0x34, 0xFC, + 0xD8, 0x77, 0xB6, 0x59, 0x14, 0x5E, 0x9D, 0x9A + }, + { + 0xB9, 0x94, 0xA9, 0x44, 0x65, 0x0E, 0x2A, 0xF1, + 0x22, 0x4C, 0x9F, 0xAF, 0x15, 0x74, 0x12, 0x00, + 0xF3, 0x50, 0x31, 0x2A, 0x32, 0x22, 0x24, 0xEF, + 0x2B, 0xF5, 0x06, 0xB5, 0xA4, 0x1B, 0x6D, 0x7F, + 0xB2, 0x7E, 0x08, 0xEC, 0x3B, 0xAB, 0xFD, 0xAD, + 0x8A, 0xC4, 0x9B, 0xB1, 0xDC, 0x56, 0x69, 0xDE, + 0xB2, 0xCF, 0xE9, 0x66, 0x12, 0x47, 0x8C, 0x4C, + 0x27, 0x6B, 0x88, 0x6E, 0xA0, 0xC7, 0x9D, 0xE8 + }, + { + 0x99, 0xB5, 0x7A, 0x9F, 0x86, 0x89, 0x20, 0xC1, + 0xB4, 0xFB, 0xC8, 0xD6, 0xA3, 0x3C, 0x44, 0xE9, + 0xB2, 0x72, 0xFE, 0xF4, 0x5A, 0x16, 0xCA, 0xEF, + 0x95, 0x61, 0xBB, 0x48, 0x5A, 0x43, 0xE8, 0xA1, + 0xC3, 0x22, 0x8A, 0x72, 0x5A, 0xC0, 0xFB, 0xF3, + 0xA3, 0x27, 0xCF, 0x23, 0xF6, 0x36, 0x05, 0xBA, + 0xAE, 0x14, 0xBD, 0x30, 0x8D, 0x1F, 0xC4, 0x1E, + 0xC7, 0x86, 0xD3, 0x90, 0x60, 0x67, 0x88, 0xFA + }, + { + 0x7E, 0x37, 0x07, 0x59, 0x07, 0x33, 0xF4, 0xD5, + 0x6D, 0xE8, 0x26, 0xCE, 0xB9, 0x93, 0x59, 0xB2, + 0x76, 0xBC, 0xA1, 0xB6, 0x94, 0x8A, 0xC1, 0xBE, + 0xED, 0xDE, 0x32, 0x75, 0x4F, 0xE8, 0x60, 0x15, + 0x39, 0x7B, 0x66, 0xD0, 0xD2, 0xDB, 0x89, 0x15, + 0xB9, 0x22, 0x16, 0x04, 0xD1, 0x74, 0xD3, 0x00, + 0x12, 0x8E, 0xD6, 0xB0, 0x03, 0xEE, 0x83, 0x1A, + 0x21, 0x0C, 0xCB, 0xA2, 0x04, 0xB7, 0x27, 0x1A + }, + { + 0xE5, 0xC2, 0x41, 0xE9, 0x77, 0x08, 0xA5, 0x1B, + 0xA9, 0x23, 0xB6, 0xE2, 0x5C, 0xAB, 0xAF, 0x4C, + 0xB5, 0x97, 0xBC, 0xB4, 0x9D, 0x95, 0x47, 0x67, + 0x2E, 0x1C, 0x95, 0xD8, 0xB0, 0xCF, 0xA0, 0x58, + 0x13, 0x79, 0xFC, 0x4F, 0xE6, 0xBA, 0x84, 0xAD, + 0x45, 0xE8, 0x66, 0x50, 0xBA, 0x39, 0x8A, 0xDE, + 0x14, 0x66, 0x63, 0x11, 0x2A, 0x74, 0x2C, 0xF7, + 0xE6, 0x50, 0x97, 0xB4, 0x50, 0x82, 0x75, 0xB0 + }, + { + 0xF5, 0xC3, 0x34, 0xE1, 0xF6, 0xB4, 0xCB, 0x87, + 0xCC, 0x99, 0x0D, 0xC0, 0x48, 0xC9, 0x25, 0x1D, + 0x04, 0x96, 0xEB, 0x03, 0xC0, 0x60, 0xAC, 0xDE, + 0xF3, 0x2F, 0x64, 0xEC, 0x1A, 0x1B, 0xD9, 0xA1, + 0xAA, 0xF0, 0xCE, 0xBE, 0x08, 0xAE, 0xFA, 0xE7, + 0x2B, 0x85, 0xAA, 0xCD, 0xCD, 0x82, 0x35, 0x03, + 0x0B, 0xC1, 0x92, 0xD6, 0x09, 0xF7, 0x53, 0xCB, + 0x96, 0x93, 0x77, 0x50, 0x4C, 0x22, 0xED, 0x69 + }, + { + 0x5E, 0x8F, 0xBE, 0xAE, 0x36, 0x56, 0xAE, 0xD8, + 0xD8, 0x73, 0x24, 0x98, 0xEA, 0x1E, 0x43, 0x44, + 0xC6, 0x53, 0x16, 0x00, 0x8E, 0xFD, 0x4E, 0xFA, + 0x97, 0x79, 0x4E, 0x92, 0x95, 0x96, 0x81, 0xA5, + 0xD7, 0xC2, 0xD9, 0xBF, 0x6C, 0xCF, 0x8B, 0x4E, + 0x03, 0x8B, 0x89, 0xB7, 0x76, 0xC6, 0x73, 0x22, + 0x2E, 0x03, 0xBA, 0x53, 0x65, 0xB3, 0xAE, 0x01, + 0x00, 0x21, 0x89, 0x2E, 0x00, 0x59, 0xDF, 0xFE + }, + { + 0x06, 0xAB, 0x01, 0x29, 0x2A, 0x08, 0xCC, 0x81, + 0xA5, 0xAF, 0xE2, 0x2B, 0xCC, 0x5A, 0x5C, 0xC3, + 0x98, 0x6D, 0x23, 0x10, 0xA0, 0x1E, 0x9B, 0x50, + 0xCC, 0x7E, 0x6F, 0x3D, 0xAB, 0xA6, 0x4A, 0x11, + 0xD0, 0x3E, 0xCA, 0x01, 0xDD, 0x3A, 0x83, 0xB0, + 0xF6, 0x9F, 0xAA, 0x95, 0x06, 0xC2, 0xB5, 0x25, + 0xFB, 0x11, 0x7F, 0xFF, 0x78, 0x59, 0x78, 0x14, + 0xB2, 0x28, 0x91, 0xD8, 0x60, 0xDF, 0xCD, 0x91 + }, + { + 0x4B, 0xF3, 0xC5, 0xCC, 0x84, 0x4D, 0x55, 0x52, + 0xEA, 0x60, 0xC0, 0xFE, 0x4C, 0xDE, 0x6D, 0xDD, + 0xE1, 0xAE, 0xDB, 0xB5, 0x96, 0x43, 0x60, 0x19, + 0xC0, 0x89, 0xF8, 0x99, 0x5E, 0x2B, 0xD7, 0xF1, + 0x74, 0xBB, 0x85, 0x6B, 0xCB, 0x50, 0x2C, 0x29, + 0xA1, 0x7D, 0x7C, 0xB2, 0x2E, 0xC8, 0xC1, 0x89, + 0x8A, 0x76, 0x1B, 0xCD, 0xD7, 0x93, 0xE3, 0x5E, + 0x84, 0xF3, 0xC2, 0x24, 0x66, 0xAA, 0x6C, 0x39 + }, + { + 0xA3, 0x21, 0xB8, 0xC9, 0x1E, 0xCE, 0x2A, 0xD5, + 0xF6, 0x61, 0x25, 0x10, 0x8D, 0x26, 0x11, 0x9B, + 0xE7, 0x5F, 0x92, 0xE4, 0x11, 0x4C, 0xFF, 0x1F, + 0xB7, 0x32, 0x6A, 0x29, 0x67, 0xCA, 0xB0, 0x94, + 0xD0, 0x7F, 0x81, 0xE4, 0x8C, 0xDB, 0x01, 0xFF, + 0x2D, 0xEA, 0x33, 0x5C, 0x27, 0x49, 0x7F, 0x65, + 0xC9, 0xFF, 0xFC, 0x90, 0x52, 0x52, 0xBD, 0x3D, + 0xDC, 0xB6, 0x10, 0x62, 0xE7, 0x50, 0x25, 0x06 + }, + { + 0x97, 0xFE, 0xEA, 0x76, 0xB3, 0x87, 0x46, 0x84, + 0x73, 0x38, 0x79, 0x12, 0x97, 0xD8, 0x6B, 0xC9, + 0x4E, 0x41, 0x7E, 0xAA, 0xF2, 0x66, 0x9A, 0xE2, + 0x4D, 0xD8, 0xD6, 0xDB, 0x68, 0x31, 0xFC, 0x26, + 0x3D, 0xB0, 0xA7, 0xA0, 0x90, 0x30, 0x4A, 0x8A, + 0x17, 0x33, 0xC8, 0x84, 0x3A, 0xB9, 0xF0, 0x1E, + 0x23, 0x6E, 0xC9, 0xFF, 0xC0, 0x84, 0x11, 0xAB, + 0x38, 0x24, 0xD0, 0xDE, 0x04, 0xA5, 0x98, 0xF5 + }, + { + 0xC0, 0x09, 0xD1, 0xC4, 0x1C, 0x0D, 0xEC, 0x74, + 0xDF, 0xC9, 0xC7, 0xE3, 0x80, 0x3D, 0x00, 0x88, + 0xB4, 0xFC, 0xA0, 0x1C, 0x73, 0xD9, 0x88, 0x4F, + 0xBF, 0xE6, 0x52, 0x23, 0x48, 0x7A, 0x19, 0x63, + 0x5F, 0x75, 0x3D, 0xFC, 0xCB, 0x7B, 0xB7, 0x4B, + 0xF0, 0xEB, 0xA7, 0x61, 0xCE, 0x65, 0x97, 0x1B, + 0xFB, 0x80, 0x47, 0xFC, 0xBE, 0x25, 0xCA, 0x13, + 0x61, 0x26, 0xFA, 0xF7, 0xF9, 0x3E, 0x04, 0x1A + }, + { + 0x76, 0xF4, 0x50, 0x29, 0xD7, 0x09, 0xE8, 0xFE, + 0x8B, 0x05, 0xE4, 0x0B, 0x73, 0xB6, 0xEB, 0xF6, + 0xC5, 0xE9, 0xE1, 0x21, 0x0B, 0x9E, 0x2E, 0xCB, + 0x7C, 0x8B, 0xAE, 0x0D, 0x12, 0x97, 0xF5, 0x3C, + 0x3D, 0xDE, 0xB0, 0x95, 0x04, 0xEE, 0x08, 0x1F, + 0xA5, 0xFD, 0xA7, 0xEB, 0xBA, 0x33, 0xD1, 0x19, + 0x77, 0x0F, 0xBB, 0x57, 0xCA, 0x4E, 0x0B, 0x62, + 0x99, 0xE7, 0xE2, 0x80, 0xD7, 0x4A, 0xA8, 0x37 + }, + { + 0x53, 0xF4, 0x7A, 0x3D, 0x38, 0xB9, 0xAC, 0x6D, + 0xA3, 0x34, 0xB9, 0x57, 0xE2, 0xD9, 0x50, 0x62, + 0xD0, 0xCC, 0xC2, 0xA4, 0x6D, 0x2E, 0x89, 0x69, + 0xB0, 0x57, 0xD0, 0x45, 0x54, 0x08, 0x27, 0xF9, + 0x5F, 0x03, 0x9D, 0xB4, 0xDE, 0x8D, 0xC2, 0x0D, + 0x90, 0x11, 0xCB, 0x6C, 0x4F, 0x6E, 0x70, 0x7A, + 0xE5, 0x21, 0xA1, 0x10, 0xC5, 0xB2, 0x04, 0xFC, + 0xDB, 0x7B, 0xC6, 0x8B, 0xE2, 0xCC, 0x16, 0xB2 + }, + { + 0xEE, 0x45, 0x75, 0xB1, 0x4D, 0x7E, 0x33, 0xD2, + 0x46, 0x3B, 0xAD, 0x75, 0xA4, 0xA1, 0x5E, 0xF9, + 0x35, 0x5F, 0x5A, 0xEB, 0xA3, 0x3B, 0x58, 0x82, + 0x1E, 0xC8, 0xF5, 0x4D, 0x2C, 0xA8, 0x57, 0x14, + 0x23, 0x50, 0x51, 0x43, 0xD0, 0x56, 0xF5, 0x28, + 0x07, 0xD1, 0x5F, 0x35, 0xC5, 0x99, 0xCE, 0x71, + 0xFA, 0xF9, 0xEC, 0x13, 0xCE, 0x34, 0x24, 0x6F, + 0xAA, 0x52, 0x89, 0xE1, 0x33, 0x5A, 0xD3, 0x80 + }, + { + 0x7D, 0xCD, 0x6A, 0x62, 0xB6, 0xBB, 0xF0, 0xD2, + 0xB4, 0x80, 0x4A, 0x29, 0x48, 0xAB, 0x9A, 0xBA, + 0x04, 0xA9, 0xAD, 0x7E, 0x41, 0x40, 0x40, 0x77, + 0x2B, 0x5B, 0x47, 0x53, 0x5C, 0x2A, 0xEF, 0x63, + 0x68, 0x6A, 0x9F, 0x56, 0x76, 0x55, 0x80, 0x17, + 0xD3, 0xE7, 0x4F, 0x57, 0x90, 0xE9, 0xFB, 0xD0, + 0x94, 0x2D, 0x44, 0xEF, 0x61, 0x81, 0xFC, 0x08, + 0x83, 0x6F, 0xF1, 0xA3, 0x87, 0xE0, 0x2D, 0xA4 + }, + { + 0x42, 0xFA, 0x5A, 0x46, 0x70, 0x4B, 0xB9, 0xAE, + 0xAF, 0xB2, 0x99, 0xAF, 0xCF, 0x62, 0x86, 0x67, + 0xAF, 0xFC, 0x9F, 0xF0, 0xA9, 0x65, 0x2B, 0xD2, + 0x6D, 0x1C, 0x7A, 0x5D, 0x2B, 0x07, 0x4C, 0xBF, + 0x1E, 0x82, 0x26, 0xEF, 0xF6, 0x6C, 0xDD, 0x65, + 0x71, 0x18, 0x2B, 0xD7, 0x2A, 0x6C, 0x66, 0x57, + 0xEB, 0x59, 0x7F, 0xE3, 0xA8, 0xF4, 0xBC, 0x55, + 0x55, 0xF1, 0xA3, 0xE9, 0xAD, 0xAC, 0x74, 0xC2 + }, + { + 0xDD, 0x53, 0x4E, 0x30, 0x41, 0xA4, 0x35, 0x48, + 0xEF, 0xF0, 0x99, 0x44, 0xCF, 0x02, 0x50, 0x40, + 0x31, 0x82, 0x83, 0xAB, 0x24, 0x04, 0x0B, 0xD1, + 0xB0, 0x40, 0x4D, 0x0E, 0xCD, 0x7B, 0x3A, 0xF7, + 0xB9, 0x78, 0xEA, 0x69, 0xC4, 0xAC, 0xC1, 0xCB, + 0xFE, 0xAF, 0x09, 0xFE, 0x7A, 0x33, 0x0B, 0xB1, + 0x4B, 0xAD, 0x58, 0x26, 0x3F, 0x9D, 0x88, 0x2A, + 0x16, 0xEF, 0x87, 0x87, 0x13, 0x83, 0x50, 0x28 + }, + { + 0xD0, 0x8A, 0x2C, 0x23, 0x5D, 0x49, 0x09, 0xA0, + 0xAD, 0x09, 0x09, 0xAF, 0x57, 0x87, 0x13, 0xFA, + 0x42, 0x51, 0x68, 0x33, 0x07, 0x3D, 0xD1, 0x1C, + 0x6E, 0x28, 0xD1, 0x53, 0xB6, 0x1A, 0x5B, 0x0D, + 0x35, 0x61, 0x4B, 0xF4, 0xAE, 0x7E, 0x24, 0x27, + 0xF8, 0x3A, 0xD4, 0x8A, 0xDF, 0xF0, 0x9B, 0xDF, + 0x79, 0x82, 0x82, 0x0C, 0xAC, 0xD0, 0xC3, 0x9D, + 0xF7, 0x74, 0x21, 0xBE, 0xA9, 0xC9, 0xC2, 0xE3 + }, + { + 0x00, 0xEA, 0xBE, 0xA8, 0xEF, 0xA0, 0x88, 0x36, + 0xFC, 0x02, 0xCB, 0xF4, 0x67, 0x9E, 0x6F, 0x46, + 0x10, 0x6D, 0xE2, 0x72, 0x52, 0xA9, 0x51, 0x85, + 0x0F, 0x1E, 0xE9, 0xA0, 0x9E, 0x24, 0xE1, 0x5A, + 0xAB, 0xCC, 0x3F, 0xDD, 0xDE, 0x6E, 0x31, 0xD8, + 0x1B, 0x5F, 0x44, 0xF4, 0x54, 0x29, 0x75, 0xF2, + 0xC0, 0xEC, 0xD4, 0x54, 0xC5, 0x33, 0x3F, 0xF6, + 0x36, 0x4A, 0xD7, 0xBD, 0x0E, 0xE7, 0xED, 0xC5 + }, + { + 0x37, 0x8C, 0x81, 0x63, 0x16, 0x34, 0x20, 0x38, + 0xA8, 0xAC, 0x17, 0x03, 0xC3, 0x1F, 0xF7, 0xB2, + 0x59, 0x35, 0x09, 0x72, 0xFB, 0xA2, 0x18, 0x55, + 0xE8, 0x7C, 0xF3, 0x32, 0x6A, 0x43, 0xEF, 0x49, + 0xCB, 0xA8, 0xC1, 0x92, 0xEE, 0x8A, 0x2F, 0x9D, + 0xE1, 0x88, 0xC1, 0xAB, 0x6F, 0x8D, 0x22, 0xA7, + 0x65, 0x38, 0xFE, 0x75, 0xD5, 0x54, 0xE3, 0xC0, + 0x39, 0x75, 0xEF, 0x30, 0xD1, 0xA5, 0x81, 0x19 + }, + { + 0x85, 0x92, 0x73, 0xE9, 0x0C, 0xD1, 0x6D, 0xAD, + 0x7A, 0x68, 0x41, 0x1C, 0xCB, 0x70, 0xA2, 0x75, + 0xB7, 0xE3, 0xF4, 0xAD, 0x35, 0x45, 0x01, 0x65, + 0x1A, 0xF2, 0x0E, 0x73, 0x07, 0x30, 0xEC, 0xC1, + 0x8A, 0x57, 0x9A, 0x54, 0x06, 0x49, 0xDE, 0x46, + 0xFB, 0xCB, 0xC1, 0xDF, 0xDA, 0x86, 0x8F, 0x5E, + 0x0C, 0x10, 0x8D, 0xA3, 0xE7, 0xBD, 0x38, 0x80, + 0x16, 0x4A, 0xF2, 0x35, 0x90, 0xAE, 0xE0, 0x41 + }, + { + 0x3B, 0x3B, 0x3B, 0xF1, 0x26, 0x93, 0xB2, 0xAD, + 0xE2, 0x09, 0xFF, 0xAF, 0x8A, 0x8C, 0x1A, 0xA9, + 0xFA, 0xCC, 0x8D, 0xED, 0xF9, 0x29, 0xEA, 0x55, + 0x24, 0x00, 0xB2, 0x86, 0x00, 0x56, 0xAF, 0xB8, + 0x6E, 0xDE, 0x97, 0xA9, 0x6F, 0x08, 0xF2, 0x0B, + 0x0B, 0xE7, 0x0D, 0x51, 0xB8, 0x55, 0x4E, 0x2C, + 0x60, 0xDA, 0xDB, 0xDE, 0x71, 0xED, 0xC7, 0x50, + 0xE3, 0x0D, 0x2D, 0x71, 0x4E, 0x96, 0x59, 0x00 + }, + { + 0x93, 0x2D, 0xE9, 0x0E, 0xA6, 0x00, 0x33, 0x82, + 0x95, 0x13, 0x94, 0xA7, 0xAC, 0xD0, 0x84, 0x97, + 0xA8, 0x09, 0xD6, 0x71, 0x96, 0x80, 0xE9, 0x6A, + 0x10, 0x54, 0xDB, 0xCC, 0x72, 0x6B, 0x77, 0xF2, + 0x27, 0x35, 0xF8, 0x18, 0x16, 0x21, 0x3A, 0x2E, + 0x36, 0x75, 0xAB, 0x76, 0x10, 0x77, 0xB0, 0x16, + 0xAC, 0xB0, 0xA8, 0x76, 0x17, 0xFD, 0x9C, 0x2F, + 0x1F, 0xD1, 0x71, 0x59, 0x4D, 0xA3, 0xBC, 0xEF + }, + { + 0xC0, 0x9E, 0xCB, 0xEB, 0xF0, 0x3B, 0x36, 0x8D, + 0x29, 0xA7, 0xBD, 0x95, 0xED, 0xDA, 0xBA, 0xC9, + 0x15, 0x04, 0x87, 0xDA, 0x36, 0x5A, 0x98, 0xEB, + 0x4B, 0x9F, 0x6D, 0x25, 0xAA, 0xEB, 0x3A, 0x87, + 0xE7, 0x21, 0x07, 0xB5, 0x9F, 0x84, 0xA1, 0x46, + 0x7A, 0xB6, 0x03, 0xFE, 0x9D, 0x50, 0x20, 0x19, + 0x5D, 0xCD, 0xFF, 0xF6, 0x44, 0xCC, 0x6A, 0x27, + 0xA0, 0x72, 0x6D, 0xDF, 0x78, 0xBF, 0x6D, 0xF5 + }, + { + 0xB5, 0xCA, 0x66, 0x48, 0x3C, 0x80, 0x06, 0x83, + 0xBF, 0x3B, 0xD9, 0x19, 0x59, 0x99, 0x07, 0x9F, + 0xFE, 0x90, 0x17, 0xD6, 0x8E, 0x38, 0x90, 0xDD, + 0xBC, 0xCE, 0x5E, 0xD1, 0x26, 0xE1, 0xFC, 0xE3, + 0x31, 0x65, 0x94, 0x21, 0x42, 0x91, 0x7E, 0xC7, + 0x6B, 0x50, 0x68, 0xA4, 0x6A, 0xCA, 0x27, 0x12, + 0xA1, 0xF9, 0x0B, 0xB6, 0x76, 0x22, 0x12, 0xAF, + 0x39, 0xB7, 0xF6, 0x71, 0x05, 0xB5, 0x5B, 0x05 + }, + { + 0xFD, 0xBB, 0xD9, 0x6A, 0x37, 0x3A, 0xFE, 0x1C, + 0x5D, 0x9A, 0xDC, 0x34, 0x65, 0x09, 0x64, 0x69, + 0xDF, 0x47, 0xAD, 0xEA, 0xD1, 0x12, 0x90, 0x0D, + 0xC8, 0x3A, 0xD5, 0x86, 0xDF, 0x46, 0x3E, 0x60, + 0xB6, 0x99, 0x69, 0xAC, 0x42, 0xCD, 0x32, 0x56, + 0x8E, 0x91, 0x69, 0xC2, 0xB9, 0xF8, 0xEF, 0x1A, + 0x52, 0x9C, 0xF3, 0xB3, 0x7D, 0x70, 0x31, 0x21, + 0x57, 0xFC, 0xC9, 0x07, 0xA5, 0xE1, 0x58, 0xF0 + }, + { + 0xD7, 0x6D, 0xA2, 0xB7, 0x52, 0xD2, 0xE4, 0x7C, + 0x1E, 0xE7, 0x99, 0x79, 0x64, 0xE9, 0xDC, 0x76, + 0xB7, 0xC9, 0x3C, 0xBD, 0x66, 0x9E, 0x6E, 0x9F, + 0x9D, 0x66, 0xF8, 0x31, 0xFF, 0xE2, 0x8A, 0x99, + 0xF1, 0xCA, 0x69, 0x43, 0x48, 0x45, 0x5A, 0x3F, + 0xE2, 0xAA, 0xC6, 0xA2, 0x14, 0x4D, 0x3C, 0x2A, + 0xBE, 0x9F, 0x7C, 0x58, 0x1C, 0x20, 0x72, 0x95, + 0x5C, 0xA5, 0xC2, 0xE3, 0x96, 0x27, 0xFD, 0x51 + }, + { + 0xB7, 0x86, 0xE7, 0x5E, 0x5F, 0x94, 0x6A, 0x67, + 0x82, 0x6A, 0x33, 0xBD, 0x8E, 0x76, 0xC1, 0xA9, + 0x75, 0xED, 0x42, 0xE5, 0xA9, 0xBE, 0x4C, 0x9A, + 0xE9, 0x13, 0x42, 0x0F, 0xC5, 0x56, 0x22, 0x06, + 0x8E, 0x91, 0x00, 0xA7, 0xBB, 0x1B, 0x7F, 0xDA, + 0x35, 0x67, 0x78, 0x56, 0x11, 0xB0, 0x16, 0xE9, + 0x9A, 0x25, 0x6D, 0xE6, 0xFB, 0xAC, 0x2B, 0x79, + 0xA3, 0xDA, 0x23, 0x28, 0x8B, 0x80, 0x14, 0x99 + }, + { + 0xD5, 0xF4, 0x72, 0x4A, 0x08, 0xCD, 0x05, 0xEF, + 0xAF, 0x2B, 0xFA, 0x9A, 0xCF, 0x9E, 0xCD, 0xDE, + 0x60, 0x40, 0x4B, 0x09, 0xCF, 0x13, 0x11, 0xC5, + 0xE5, 0xAF, 0x15, 0x26, 0x0D, 0x29, 0x60, 0xD4, + 0xDE, 0x4C, 0x77, 0x49, 0xBF, 0x30, 0xFA, 0xAD, + 0xBE, 0x78, 0x05, 0x9E, 0x66, 0xED, 0x9C, 0x04, + 0x5A, 0xF9, 0xDC, 0x79, 0x00, 0x5A, 0x1D, 0x4D, + 0xF1, 0xFE, 0x2E, 0xA9, 0xA3, 0xCD, 0x6A, 0x46 + }, + { + 0xFC, 0x16, 0xF9, 0xC6, 0xDE, 0xF0, 0x5E, 0x6E, + 0x8F, 0x78, 0x09, 0x9B, 0x8E, 0x6C, 0x86, 0x0E, + 0x08, 0x97, 0x72, 0x3E, 0x1C, 0x0E, 0x3D, 0x27, + 0x72, 0xB9, 0xBC, 0x2B, 0x3A, 0xD9, 0x18, 0x25, + 0x5C, 0xE7, 0x5D, 0xB9, 0x4E, 0xE0, 0xE1, 0xF0, + 0x6A, 0x04, 0x4B, 0x31, 0x9B, 0xF6, 0x91, 0x39, + 0xE4, 0x85, 0x95, 0x4A, 0x4B, 0x1B, 0x99, 0xD2, + 0xBE, 0xAE, 0xCE, 0x47, 0x67, 0xE7, 0x92, 0xA5 + }, + { + 0x90, 0x7D, 0xE4, 0xD3, 0x14, 0x0A, 0xFF, 0xB4, + 0x14, 0x55, 0x47, 0xD0, 0xC3, 0xD3, 0xCF, 0xC9, + 0x02, 0x72, 0x2C, 0x04, 0x13, 0x8C, 0x57, 0x96, + 0xFC, 0xF6, 0x5D, 0xFA, 0x47, 0x37, 0x23, 0x96, + 0x5A, 0xF7, 0x12, 0x63, 0x3B, 0x67, 0x48, 0x10, + 0x0C, 0x32, 0x93, 0x69, 0xFC, 0x01, 0xA1, 0xDD, + 0x56, 0x40, 0xFC, 0x8A, 0x18, 0x97, 0x04, 0x4B, + 0xF2, 0x1F, 0x81, 0x8B, 0x92, 0xDC, 0x32, 0x0C + }, + { + 0x9E, 0x9F, 0x6D, 0xFF, 0x91, 0x40, 0x6B, 0x91, + 0x82, 0x95, 0x26, 0x3D, 0x21, 0x6B, 0xC9, 0x03, + 0xFA, 0x51, 0x6C, 0x42, 0x93, 0x7E, 0xC4, 0x10, + 0x19, 0xF6, 0x75, 0x15, 0xFC, 0xDB, 0x1D, 0x91, + 0xB5, 0x3F, 0x62, 0x17, 0x6C, 0x1C, 0x22, 0xF2, + 0x99, 0xD8, 0x0F, 0xC9, 0xDD, 0x8D, 0x76, 0xE9, + 0xB0, 0x82, 0xF2, 0x9A, 0x02, 0x7C, 0x37, 0xAB, + 0xEE, 0x89, 0xBE, 0x71, 0x59, 0xB0, 0x3D, 0xFB + }, + { + 0x96, 0x51, 0x3A, 0x80, 0x2D, 0x48, 0x70, 0xF6, + 0x4C, 0xD0, 0x15, 0x2A, 0xCC, 0xC5, 0xED, 0x8B, + 0x24, 0xC6, 0x44, 0xFC, 0x65, 0xF0, 0xCF, 0xAE, + 0xC0, 0xA1, 0x1F, 0x26, 0x88, 0x8E, 0x80, 0xE1, + 0x4E, 0x5B, 0xA8, 0x64, 0xED, 0xA8, 0x8E, 0x7C, + 0x05, 0x64, 0x2D, 0x15, 0xF0, 0x67, 0x83, 0x00, + 0xDE, 0xC3, 0x79, 0x97, 0x0F, 0xBF, 0x2E, 0xEA, + 0x0C, 0x12, 0x08, 0xC0, 0x17, 0xE6, 0x9A, 0x1B + }, + { + 0x89, 0x0D, 0x39, 0xDA, 0x13, 0xF3, 0x02, 0x95, + 0xBC, 0xDF, 0xC2, 0x0E, 0x63, 0xF0, 0x13, 0x79, + 0xC9, 0x1B, 0x84, 0xBD, 0x01, 0xEE, 0x06, 0x43, + 0x57, 0x1D, 0x94, 0x05, 0x5A, 0x7A, 0x11, 0x49, + 0xF1, 0xE3, 0x0B, 0xBB, 0x82, 0x1C, 0x4B, 0xC7, + 0xEA, 0x99, 0xA0, 0xDB, 0xF3, 0xE7, 0x92, 0xDF, + 0x33, 0xD4, 0xFA, 0x2E, 0x4A, 0x39, 0xE9, 0x32, + 0xE8, 0xCE, 0xB9, 0xE7, 0xF9, 0x57, 0x8E, 0x28 + }, + { + 0x11, 0x44, 0x70, 0x2B, 0x39, 0xEC, 0x0B, 0x6B, + 0x0E, 0x5B, 0xE8, 0x07, 0x9F, 0x60, 0xB7, 0xD9, + 0x0F, 0x6C, 0x57, 0x94, 0x57, 0x3E, 0xFF, 0x3E, + 0x33, 0xE6, 0xD4, 0x4A, 0x96, 0x53, 0x6B, 0x4D, + 0x95, 0xBE, 0xBA, 0x09, 0x3C, 0x95, 0xFF, 0xF2, + 0x41, 0xFA, 0x6D, 0x4F, 0xDA, 0xD3, 0xFE, 0xE6, + 0x70, 0xC3, 0xBA, 0x13, 0xFE, 0x1E, 0x80, 0xA7, + 0xDB, 0x3E, 0xB6, 0x8B, 0x81, 0x00, 0x19, 0xD1 + }, + { + 0x7C, 0xB6, 0x19, 0xC0, 0x86, 0x6E, 0xB3, 0x7A, + 0x80, 0x61, 0xD1, 0xE6, 0x55, 0xF1, 0x95, 0xFA, + 0x40, 0xE0, 0x03, 0xD3, 0xD1, 0x4C, 0x74, 0x08, + 0xDD, 0x22, 0xAA, 0xE4, 0x92, 0x94, 0xE5, 0x6E, + 0xCC, 0x58, 0xC1, 0x5F, 0x9D, 0x69, 0xA7, 0x6B, + 0xA2, 0x14, 0x77, 0x43, 0x92, 0xFA, 0x5A, 0xF0, + 0xDA, 0x16, 0x37, 0x4A, 0xCA, 0xB2, 0x81, 0x1B, + 0x1E, 0x64, 0xB2, 0x7E, 0xF3, 0x9A, 0x5A, 0x77 + }, + { + 0x78, 0x9F, 0x11, 0xEB, 0xB5, 0x41, 0x79, 0x1A, + 0xAB, 0xE5, 0x33, 0xE1, 0x52, 0x91, 0x5E, 0x46, + 0x1B, 0x09, 0xC2, 0x03, 0x77, 0x5C, 0x64, 0xCA, + 0x7A, 0xE1, 0x3D, 0xB1, 0x8B, 0x3D, 0x7D, 0x53, + 0x39, 0xC4, 0x18, 0x9D, 0x7C, 0x4F, 0x11, 0xA8, + 0xB3, 0xDE, 0x57, 0xD8, 0x20, 0x45, 0x72, 0xA4, + 0xC6, 0xBB, 0x11, 0xC6, 0x03, 0x95, 0x38, 0x41, + 0x1B, 0xCA, 0xCF, 0x06, 0x54, 0xD5, 0x8F, 0xCA + }, + { + 0x87, 0x8B, 0xF7, 0xB5, 0x02, 0xAC, 0x63, 0xEA, + 0x10, 0xCA, 0x28, 0x16, 0x10, 0x4A, 0x7C, 0xD5, + 0x69, 0x49, 0xD9, 0xF9, 0x51, 0x12, 0x49, 0xAD, + 0x34, 0x24, 0xFB, 0x87, 0x6A, 0x53, 0x07, 0x83, + 0x43, 0x0D, 0x21, 0xC5, 0xD8, 0x65, 0x1F, 0xD6, + 0x4E, 0xCA, 0x99, 0x7E, 0xD5, 0x7D, 0x59, 0x5C, + 0x9B, 0x19, 0x42, 0xA3, 0x5C, 0xDE, 0xFE, 0x64, + 0x6F, 0x32, 0x23, 0xA6, 0x92, 0xE7, 0x24, 0x6D + }, + { + 0x11, 0x4E, 0x6C, 0x71, 0x8A, 0xC6, 0x83, 0x06, + 0xA6, 0x2C, 0x2D, 0x44, 0xF5, 0x7B, 0x1A, 0x8F, + 0xEA, 0x7B, 0xB5, 0x29, 0x13, 0x1F, 0xF0, 0xB3, + 0x08, 0x9B, 0xB6, 0xC2, 0xBF, 0x08, 0x29, 0x60, + 0x06, 0x94, 0x8F, 0xE5, 0x9F, 0x1D, 0x07, 0x4D, + 0x10, 0x5B, 0xCF, 0xBE, 0x5B, 0x8A, 0x97, 0x19, + 0x43, 0x6C, 0x31, 0x18, 0x61, 0x99, 0xE3, 0xC9, + 0x9F, 0xD5, 0x66, 0x7A, 0x50, 0x92, 0x4F, 0x5F + }, + { + 0xE9, 0x4D, 0x5A, 0xDE, 0x41, 0x61, 0xB6, 0x35, + 0xF6, 0x4A, 0x04, 0x7A, 0x6A, 0x33, 0xF8, 0x72, + 0xEB, 0x03, 0x9F, 0x3B, 0x49, 0xA3, 0x5B, 0x2A, + 0x9F, 0xD5, 0x83, 0xD4, 0x06, 0x4F, 0x01, 0x48, + 0xB2, 0x94, 0xBE, 0xB5, 0xBF, 0x97, 0xAF, 0x42, + 0x05, 0x8E, 0x61, 0x7D, 0xCD, 0x60, 0x24, 0x86, + 0xD8, 0xB0, 0x37, 0x93, 0x81, 0x48, 0xF3, 0xA7, + 0x79, 0x0B, 0xA8, 0xA0, 0xF2, 0x31, 0x96, 0xEB + }, + { + 0x9B, 0x19, 0xCC, 0x00, 0xDF, 0x74, 0x2B, 0x6A, + 0x53, 0x4F, 0x1F, 0xC1, 0x0C, 0x90, 0x26, 0x94, + 0x5B, 0xF3, 0x49, 0x1A, 0x7B, 0xFB, 0x6A, 0x3F, + 0xC0, 0x8C, 0x7E, 0xC2, 0x1C, 0x6B, 0x35, 0x78, + 0x9D, 0xBC, 0xA4, 0x3A, 0x67, 0x15, 0x49, 0x60, + 0xBB, 0xAA, 0x79, 0xD8, 0xA4, 0x08, 0xBF, 0x5E, + 0xAD, 0x87, 0x10, 0x57, 0xEC, 0x09, 0x06, 0xBA, + 0x47, 0x24, 0xBA, 0x40, 0xDF, 0xE3, 0x19, 0x3B + }, + { + 0xC6, 0x9D, 0x6A, 0x00, 0x97, 0xE3, 0x9F, 0xF3, + 0x95, 0xC2, 0x08, 0x4F, 0x52, 0x51, 0xA6, 0x2E, + 0x78, 0x5B, 0x34, 0xD4, 0x7F, 0xD2, 0xEE, 0xF2, + 0x4C, 0x35, 0x6A, 0xF5, 0x26, 0x32, 0x73, 0x06, + 0xFC, 0x2B, 0x74, 0x4F, 0xD0, 0xB6, 0x15, 0xB3, + 0x93, 0xD9, 0x6B, 0xF6, 0xB0, 0x74, 0x6F, 0x2F, + 0x1C, 0x41, 0xD0, 0x7C, 0x5C, 0x43, 0xF6, 0xED, + 0xE8, 0xF1, 0xF9, 0x07, 0xC8, 0x4E, 0x02, 0xB3 + }, + { + 0xA9, 0xC7, 0xCA, 0x55, 0x21, 0x1F, 0xE1, 0x84, + 0x76, 0x41, 0x29, 0x53, 0x49, 0x64, 0x0A, 0x66, + 0x9D, 0xA3, 0x42, 0x07, 0x3A, 0xA5, 0xBD, 0xD8, + 0x25, 0x87, 0xB7, 0xA5, 0x3B, 0x41, 0x1F, 0xDB, + 0x52, 0xA5, 0x2C, 0x78, 0x0B, 0xC3, 0x64, 0x3F, + 0xC0, 0x3C, 0x3B, 0x06, 0xA7, 0x6D, 0x71, 0x87, + 0x7E, 0x7D, 0x1F, 0x18, 0x44, 0x66, 0x24, 0x7D, + 0x0E, 0x85, 0xD2, 0xB3, 0xCD, 0x19, 0x10, 0x9C + }, + { + 0x2C, 0x3E, 0xA8, 0x3F, 0x28, 0x4F, 0x06, 0x90, + 0x66, 0x8B, 0x95, 0x56, 0xA3, 0xA8, 0x14, 0x36, + 0xA7, 0xF2, 0xEF, 0xE0, 0x38, 0xAA, 0x6A, 0x79, + 0x54, 0xF2, 0x02, 0x4F, 0x30, 0x1F, 0xB1, 0x16, + 0x8F, 0xC4, 0x89, 0x81, 0x82, 0xD7, 0xC6, 0x15, + 0xFE, 0x15, 0x38, 0xF4, 0x52, 0xC2, 0x12, 0x04, + 0xE5, 0x48, 0x4B, 0x98, 0xDE, 0x93, 0x3D, 0x6D, + 0x64, 0xEB, 0xDC, 0x5C, 0x0A, 0xA1, 0x26, 0x97 + }, + { + 0x39, 0x44, 0x43, 0x91, 0x0B, 0x8C, 0xAE, 0x9C, + 0x53, 0xDE, 0xF3, 0x00, 0xCF, 0x9C, 0xFD, 0x66, + 0x8D, 0xD0, 0xC8, 0xB4, 0x05, 0xD6, 0xA3, 0xEA, + 0xCA, 0xC8, 0x91, 0xED, 0x5D, 0xAF, 0xF9, 0xE2, + 0x23, 0xDB, 0x80, 0x13, 0x34, 0x7D, 0x2A, 0x8C, + 0x15, 0xE9, 0x4C, 0x36, 0x27, 0xB4, 0xCF, 0x84, + 0x94, 0x90, 0x43, 0x84, 0x65, 0x10, 0xF4, 0x06, + 0x19, 0xB2, 0xD0, 0xA3, 0x0E, 0xF5, 0xA9, 0xD6 + }, + { + 0x6F, 0xAF, 0x7E, 0x2A, 0xA1, 0xF9, 0xEA, 0x63, + 0x18, 0x84, 0x32, 0xE2, 0x5F, 0xED, 0x05, 0x5C, + 0x64, 0x63, 0xCD, 0x84, 0xA8, 0xA6, 0x09, 0xF8, + 0x98, 0x99, 0x73, 0x96, 0x30, 0x35, 0x46, 0x18, + 0xA7, 0x9E, 0xDE, 0xA3, 0xD6, 0xCC, 0xFD, 0xFC, + 0x89, 0xD8, 0x3E, 0x5E, 0x84, 0x53, 0x35, 0x43, + 0xEF, 0x0A, 0x42, 0x5D, 0x70, 0x0C, 0x11, 0xB1, + 0xC8, 0x0F, 0x06, 0x34, 0xAA, 0x88, 0x4D, 0x7F + }, + { + 0x03, 0xCB, 0xAD, 0xD1, 0xE8, 0xD4, 0x3A, 0x01, + 0xAC, 0x4A, 0xE4, 0x6E, 0x62, 0x91, 0x0B, 0xB3, + 0xE5, 0x79, 0xCA, 0x3E, 0xA5, 0x27, 0x35, 0x54, + 0x78, 0x2E, 0xFE, 0xDF, 0x34, 0xB9, 0xE5, 0x5C, + 0xD2, 0xB3, 0xE6, 0x16, 0x1A, 0x37, 0xB2, 0xAC, + 0xB2, 0xFB, 0xC6, 0xC7, 0x8E, 0x57, 0xC8, 0x3F, + 0xCC, 0x09, 0x54, 0xAF, 0x30, 0xFF, 0x5D, 0x8D, + 0x19, 0x2A, 0xDE, 0x15, 0x34, 0x04, 0xBF, 0x04 + }, + { + 0xB4, 0x1A, 0x55, 0x4E, 0x13, 0xA3, 0x3B, 0x4E, + 0xC8, 0xCE, 0xFC, 0x59, 0x1E, 0xE7, 0xFB, 0x26, + 0xE6, 0x93, 0xE3, 0x3A, 0xAB, 0xD3, 0x51, 0x98, + 0x7B, 0x05, 0xE8, 0x34, 0x80, 0xF4, 0xBB, 0x8D, + 0x1C, 0x9C, 0x48, 0x61, 0x4D, 0xD0, 0xE4, 0x30, + 0x4F, 0x51, 0x6D, 0x6A, 0x83, 0xCE, 0x68, 0x16, + 0x47, 0xEA, 0x55, 0x80, 0x50, 0xB7, 0x11, 0xA4, + 0xA1, 0x4D, 0x50, 0x37, 0x93, 0x69, 0x50, 0x64 + }, + { + 0xD5, 0xEC, 0xFD, 0xC9, 0xF0, 0x5B, 0x6C, 0xBF, + 0x18, 0xC6, 0x53, 0x5F, 0xA4, 0x1B, 0x96, 0x81, + 0x08, 0x14, 0x60, 0x24, 0x41, 0x96, 0x45, 0x98, + 0x11, 0x1C, 0xAC, 0xBA, 0x9D, 0x51, 0x84, 0xEC, + 0x00, 0x6B, 0x94, 0x63, 0x13, 0x45, 0x80, 0x4B, + 0xC3, 0xB1, 0x82, 0xA9, 0xE1, 0x2D, 0x25, 0x7F, + 0xF6, 0x01, 0xA4, 0x54, 0x62, 0x97, 0x72, 0xB3, + 0x34, 0x75, 0x6F, 0x5E, 0x03, 0x7F, 0x23, 0x06 + }, + { + 0xBB, 0xE9, 0xA1, 0x8E, 0x69, 0x83, 0x23, 0x42, + 0x29, 0xD3, 0x62, 0x67, 0x76, 0xEB, 0xAD, 0xE6, + 0xE6, 0x3C, 0xEE, 0x51, 0xDD, 0x2B, 0xAF, 0x4E, + 0x3E, 0x85, 0x03, 0xEF, 0x39, 0x07, 0xD7, 0x54, + 0x86, 0xF9, 0x21, 0xEC, 0x47, 0x6E, 0x7C, 0x82, + 0x66, 0x45, 0x93, 0xAC, 0x2A, 0xBD, 0x20, 0x21, + 0xCA, 0x6F, 0x74, 0xEC, 0xDF, 0x95, 0x14, 0xC3, + 0x08, 0xF7, 0x1A, 0x2C, 0xAA, 0x89, 0x30, 0xF0 + }, + { + 0x85, 0xCC, 0x3E, 0x11, 0x4D, 0xF0, 0x55, 0xBD, + 0xA7, 0xDF, 0x42, 0x4B, 0xC5, 0x97, 0xA1, 0xDF, + 0x8D, 0x21, 0x79, 0xD6, 0x73, 0x19, 0xFB, 0x5A, + 0x72, 0x16, 0x32, 0x95, 0x06, 0x37, 0x6F, 0x38, + 0xDE, 0x2C, 0x05, 0x0B, 0x7C, 0x3C, 0x63, 0x61, + 0x53, 0x21, 0x8D, 0x5A, 0x8C, 0x7A, 0x1F, 0x0C, + 0x5D, 0x70, 0xAB, 0xE9, 0x26, 0x87, 0x65, 0x4A, + 0xD5, 0xF1, 0x46, 0x97, 0x81, 0xDE, 0x2E, 0xD9 + }, + { + 0xF9, 0x8D, 0x21, 0x93, 0xEA, 0xA3, 0xDD, 0xC0, + 0xCA, 0xD9, 0x93, 0x0D, 0x34, 0xE2, 0x7E, 0xCB, + 0xCD, 0xC9, 0xF5, 0x3A, 0x37, 0x34, 0xBF, 0x53, + 0xEF, 0x0B, 0x0E, 0x58, 0x23, 0x49, 0x68, 0xA1, + 0xB3, 0x95, 0xA2, 0x56, 0x8B, 0xEA, 0xF3, 0x6A, + 0x37, 0xDD, 0x6F, 0x28, 0x96, 0x89, 0xC7, 0x29, + 0x51, 0xDB, 0x79, 0x91, 0xE1, 0x64, 0xBE, 0x6F, + 0x33, 0xC8, 0x27, 0x22, 0x11, 0x8E, 0xF2, 0xE6 + }, + { + 0x0C, 0x07, 0x93, 0x48, 0xC6, 0x9F, 0x3A, 0x0A, + 0xA6, 0x23, 0x14, 0x98, 0xD2, 0x0D, 0x37, 0x81, + 0x72, 0x92, 0x9C, 0x4E, 0x84, 0x9C, 0x33, 0xAE, + 0xF7, 0x20, 0xFB, 0xF3, 0x95, 0x57, 0xC5, 0x55, + 0x33, 0xB2, 0x7D, 0xD0, 0x2B, 0xFC, 0x95, 0x91, + 0x7D, 0x7D, 0xD3, 0x63, 0xB7, 0xF5, 0xD3, 0x8A, + 0x38, 0x69, 0x12, 0x80, 0xB7, 0x3E, 0x19, 0x65, + 0xCE, 0x8C, 0xD9, 0x75, 0x64, 0xC8, 0x12, 0xF3 + }, + { + 0xB0, 0xD7, 0xD4, 0x96, 0x46, 0xD0, 0x0B, 0x4B, + 0x9D, 0xB8, 0xFA, 0xBE, 0xBA, 0x07, 0x6C, 0xF8, + 0xA2, 0x0D, 0x3F, 0xA2, 0x1A, 0x50, 0xBE, 0xBD, + 0xEF, 0x42, 0xC8, 0xE0, 0xE9, 0xBB, 0xDC, 0x16, + 0x66, 0xD1, 0x86, 0x88, 0x86, 0x0B, 0x37, 0x4D, + 0xD0, 0x6C, 0xE3, 0x73, 0x52, 0xC7, 0x82, 0xDC, + 0x60, 0x72, 0xC8, 0x0E, 0x70, 0xE3, 0x3F, 0x4C, + 0x5B, 0xC4, 0xA7, 0x2D, 0x8B, 0xDB, 0x7E, 0xD7 + }, + { + 0x56, 0x7F, 0x29, 0xE8, 0xE2, 0x60, 0x90, 0xAC, + 0xB9, 0x46, 0xE1, 0x9D, 0x57, 0x3F, 0xA9, 0x93, + 0x82, 0x78, 0x43, 0xDC, 0xC1, 0x1A, 0x40, 0x43, + 0xB7, 0x13, 0x6F, 0x75, 0xCE, 0xFE, 0x08, 0xF2, + 0x6A, 0xB9, 0xC2, 0x6D, 0xC7, 0x6B, 0xBC, 0x7F, + 0x4E, 0xA0, 0x58, 0xD5, 0x79, 0xE1, 0xD3, 0x75, + 0xF0, 0x7A, 0xAD, 0xE8, 0xFD, 0x61, 0xFA, 0x14, + 0x43, 0x03, 0x64, 0x94, 0x7A, 0x44, 0x67, 0xDA + }, + { + 0xBA, 0x37, 0x1A, 0x57, 0x46, 0x6D, 0xF6, 0xE6, + 0xB6, 0xA8, 0x7B, 0x9F, 0xA4, 0x13, 0x4E, 0x65, + 0x6B, 0xAF, 0x76, 0xCF, 0x96, 0xF2, 0xE1, 0x86, + 0xCB, 0x47, 0x2A, 0xC9, 0x61, 0xB3, 0x50, 0x9B, + 0xFA, 0xC8, 0xBF, 0xED, 0x83, 0x44, 0xC6, 0x69, + 0xF7, 0x9F, 0x2C, 0x0B, 0x3E, 0xA7, 0xD2, 0x19, + 0x61, 0x73, 0xCA, 0x4A, 0x0E, 0x66, 0xE8, 0x86, + 0x85, 0xCF, 0xFF, 0x96, 0xB7, 0x16, 0xEF, 0xB4 + }, + { + 0x2F, 0xFF, 0xDB, 0x3D, 0xFF, 0x04, 0x93, 0x4F, + 0x8C, 0xAD, 0x4C, 0x53, 0x84, 0x34, 0xA2, 0x2F, + 0x50, 0xC2, 0x9A, 0x3E, 0x89, 0xC6, 0x76, 0xB5, + 0xCD, 0x39, 0x0F, 0xFC, 0xFC, 0x41, 0xDE, 0xF5, + 0xF8, 0x18, 0x66, 0xD8, 0xED, 0x58, 0xB7, 0xAD, + 0x7E, 0x39, 0x8B, 0x8E, 0x6A, 0x64, 0xC1, 0xED, + 0x39, 0x42, 0xBE, 0x8F, 0x67, 0xB1, 0x63, 0xC0, + 0xA3, 0xE9, 0x0B, 0xEE, 0x98, 0xF6, 0xF2, 0x0C + }, + { + 0x87, 0x79, 0x06, 0x0D, 0xA4, 0x61, 0x87, 0xDC, + 0x9B, 0x66, 0x19, 0xCD, 0x09, 0xB5, 0xE9, 0x7E, + 0xF8, 0x43, 0x2F, 0x10, 0x94, 0xA2, 0x58, 0xA4, + 0xBE, 0x17, 0xC4, 0x88, 0xC1, 0xB8, 0x62, 0xA5, + 0x99, 0xE5, 0xB6, 0x7C, 0x68, 0x83, 0x4B, 0x70, + 0x77, 0x5D, 0xB5, 0x29, 0x99, 0x1C, 0xF0, 0x2E, + 0xD9, 0xCF, 0xA6, 0xC0, 0x7D, 0x94, 0x33, 0x58, + 0xFA, 0x10, 0x15, 0xA3, 0xF0, 0x14, 0x6B, 0x94 + }, + { + 0x71, 0x5B, 0x81, 0x36, 0x55, 0xED, 0xE2, 0xAE, + 0x95, 0x0D, 0xD0, 0x04, 0xC2, 0x82, 0xC4, 0x5B, + 0xE3, 0x1D, 0x3E, 0xAB, 0x30, 0x89, 0x3C, 0x35, + 0x91, 0x0D, 0x94, 0x96, 0xFE, 0x01, 0xC3, 0x03, + 0x81, 0x35, 0xAE, 0xF6, 0xC8, 0x13, 0x38, 0xAE, + 0x4A, 0x41, 0x78, 0x6D, 0xEA, 0xDB, 0x9A, 0x77, + 0x1B, 0xA4, 0x08, 0x53, 0xD7, 0x11, 0xF7, 0xFA, + 0xD9, 0xC9, 0x0F, 0xF7, 0x70, 0xA7, 0xFC, 0x58 + }, + { + 0x08, 0x85, 0x7E, 0xF8, 0x09, 0x48, 0x67, 0x82, + 0x29, 0x04, 0x20, 0xC1, 0x2E, 0x1D, 0xFF, 0xA8, + 0x3E, 0xF1, 0x52, 0xAD, 0x40, 0x59, 0x69, 0x44, + 0x7B, 0x97, 0xD4, 0xE5, 0x39, 0x30, 0xEB, 0x3D, + 0x2B, 0xB6, 0x22, 0x07, 0x42, 0x50, 0x74, 0xCE, + 0xFC, 0x75, 0xD4, 0x9A, 0xBA, 0x66, 0x10, 0x7A, + 0x50, 0xA7, 0xE3, 0xFF, 0x54, 0x20, 0x72, 0xA9, + 0x71, 0xCD, 0x9C, 0x90, 0x49, 0xB9, 0x39, 0xD6 + }, + { + 0x03, 0x74, 0x33, 0x03, 0x9B, 0x9C, 0x88, 0x42, + 0x2E, 0x9C, 0xB5, 0xA9, 0x8D, 0x06, 0x50, 0x42, + 0xE5, 0xBB, 0xD2, 0x9B, 0xCA, 0x09, 0x81, 0x8B, + 0xBF, 0x24, 0xB1, 0x93, 0x7E, 0xA6, 0xC5, 0xCB, + 0x90, 0xBC, 0xDE, 0xE9, 0xB6, 0x1F, 0x9C, 0xC2, + 0x45, 0x3F, 0xB6, 0x78, 0x92, 0x9B, 0xFD, 0xEB, + 0x57, 0x09, 0x9C, 0x6E, 0xCF, 0xB9, 0xDF, 0x45, + 0x81, 0x12, 0x46, 0xE5, 0xCD, 0x98, 0xBD, 0x5B + }, + { + 0xB0, 0xAB, 0xD2, 0x5A, 0x8A, 0x44, 0x30, 0xA0, + 0xB2, 0x39, 0x36, 0xE0, 0x55, 0xC3, 0xBB, 0xDA, + 0xDF, 0xFA, 0xFD, 0x74, 0xCC, 0x1E, 0xB4, 0x96, + 0x36, 0xE6, 0xAB, 0x16, 0x2F, 0xB9, 0x1B, 0xC7, + 0x75, 0x03, 0x5F, 0xFF, 0x96, 0x19, 0xC2, 0x8E, + 0x08, 0xC5, 0xE1, 0x57, 0x94, 0xDE, 0x84, 0x30, + 0x56, 0x61, 0x5A, 0x1C, 0xE5, 0xA5, 0xD4, 0xFC, + 0xF2, 0x9A, 0xD0, 0x65, 0x2C, 0x88, 0xBD, 0x1C + }, + { + 0xFB, 0x5B, 0x21, 0x4B, 0x4B, 0xE0, 0x02, 0x45, + 0x88, 0x46, 0xF7, 0xC0, 0xD7, 0x7B, 0xEE, 0x08, + 0xF2, 0x5A, 0xDF, 0x91, 0x7A, 0xF3, 0x7A, 0xD1, + 0x74, 0x90, 0x5C, 0x47, 0x41, 0x10, 0xCD, 0x8C, + 0x73, 0x8E, 0xA5, 0xC5, 0xCF, 0x99, 0x91, 0xBE, + 0x23, 0xC4, 0xDB, 0x34, 0xC9, 0xE1, 0xC1, 0x6D, + 0x7D, 0xD1, 0xFE, 0xA6, 0xE6, 0x1A, 0xFF, 0xAD, + 0x90, 0xC1, 0x09, 0xB6, 0x71, 0x17, 0xC3, 0xF1 + }, + { + 0x0F, 0x23, 0xF2, 0x1C, 0x59, 0xFA, 0xD7, 0x7C, + 0x7B, 0xE6, 0x27, 0x5A, 0xF8, 0x51, 0x65, 0x7B, + 0x11, 0x0D, 0x45, 0xA6, 0x37, 0xD5, 0x2D, 0xA4, + 0x1A, 0x05, 0xAA, 0xBB, 0x14, 0x1A, 0x8E, 0x19, + 0x74, 0xC3, 0x7B, 0xB7, 0x61, 0x1D, 0x2C, 0xE6, + 0xE5, 0x2D, 0xE4, 0x38, 0xBF, 0xBA, 0xF8, 0x44, + 0xFD, 0x78, 0xE8, 0x23, 0x02, 0x3F, 0xD6, 0x07, + 0xF2, 0x51, 0x2E, 0x5B, 0xD8, 0xD7, 0xA7, 0x26 + }, + { + 0x58, 0xC9, 0x9F, 0xC3, 0x48, 0xE6, 0xD6, 0xB3, + 0xAE, 0x1A, 0x64, 0xC8, 0xBC, 0xF9, 0xE0, 0xFE, + 0x0F, 0x6C, 0xFD, 0x14, 0x21, 0xC7, 0x6B, 0xEE, + 0x94, 0x2E, 0xC8, 0xD9, 0x19, 0xCD, 0x5B, 0x4C, + 0x9E, 0x22, 0x0F, 0xFC, 0x3C, 0x2A, 0xD6, 0x3E, + 0x11, 0xE1, 0xFB, 0xAE, 0x68, 0xC8, 0xF4, 0xC2, + 0x5A, 0x53, 0x71, 0xE9, 0x8B, 0x72, 0xF2, 0xC0, + 0x0F, 0x28, 0xF8, 0xC2, 0x2E, 0x0E, 0x2D, 0xF5 + }, + { + 0xFB, 0x9F, 0x85, 0xED, 0x0E, 0xD6, 0x52, 0x3B, + 0xCD, 0xDA, 0x15, 0x3E, 0x99, 0x74, 0xC2, 0xA4, + 0x1A, 0x0F, 0x9B, 0x19, 0x04, 0x4F, 0x00, 0xE7, + 0x27, 0x5D, 0x2F, 0x70, 0xED, 0x6E, 0x15, 0xCC, + 0xE5, 0x85, 0x75, 0xF1, 0xE7, 0xE1, 0x78, 0xF5, + 0xCD, 0xD7, 0xCE, 0xAF, 0xFD, 0x28, 0x51, 0x08, + 0xC8, 0xA5, 0x2A, 0x56, 0x93, 0xA5, 0x46, 0x90, + 0x53, 0x17, 0xD6, 0x99, 0x1E, 0xC5, 0x74, 0x87 + }, + { + 0x43, 0x63, 0x00, 0xD4, 0x9E, 0xC7, 0x9D, 0xED, + 0xEF, 0x59, 0xAF, 0xFB, 0xC5, 0x6F, 0xD3, 0x10, + 0xB7, 0xB8, 0x1D, 0x83, 0x08, 0x61, 0x7B, 0xFB, + 0x91, 0x32, 0xFA, 0x2A, 0x29, 0x13, 0x94, 0x1E, + 0x3B, 0xEF, 0xAC, 0xD0, 0x34, 0xCB, 0x14, 0x13, + 0xB5, 0x13, 0xDA, 0x9A, 0xCB, 0x88, 0xAF, 0xF1, + 0x27, 0xB2, 0x7F, 0xC0, 0x54, 0xB3, 0xCF, 0x4D, + 0x34, 0xBC, 0xFB, 0xD2, 0x97, 0x09, 0x47, 0xCA + }, + { + 0x50, 0x29, 0x7F, 0x2D, 0x3D, 0xE0, 0x5A, 0xCD, + 0x42, 0x0D, 0x9F, 0xC1, 0xA6, 0x31, 0x08, 0x14, + 0x4A, 0x7A, 0xEF, 0xC2, 0x66, 0x6E, 0x89, 0x5D, + 0x75, 0xE5, 0x7B, 0x7A, 0xC3, 0xF1, 0x3C, 0xB5, + 0x60, 0x0D, 0x8B, 0x41, 0x18, 0x04, 0x3C, 0x5A, + 0x0C, 0xD2, 0x01, 0xAC, 0xE4, 0x89, 0x2C, 0x88, + 0xFC, 0xF6, 0x90, 0x0E, 0xF5, 0xCE, 0xE1, 0x9E, + 0x72, 0x08, 0x32, 0xC1, 0x5D, 0x20, 0x86, 0x21 + }, + { + 0xCF, 0xA1, 0x03, 0x0E, 0xDC, 0x29, 0x5A, 0xE1, + 0x30, 0x37, 0x08, 0x91, 0x78, 0x19, 0xC4, 0x1A, + 0x0A, 0x37, 0xFA, 0xBE, 0xDB, 0x3B, 0x3F, 0x9B, + 0x3C, 0xFE, 0x95, 0x19, 0x1C, 0x60, 0x60, 0x26, + 0xD3, 0x1C, 0xEB, 0xAE, 0xA9, 0x9A, 0xCB, 0xD0, + 0xB8, 0x0B, 0x16, 0xFC, 0xB3, 0xA4, 0x09, 0x4F, + 0xE6, 0x2E, 0x49, 0x58, 0x1B, 0x1D, 0x11, 0x28, + 0xF3, 0xA8, 0x58, 0xD1, 0xCA, 0x8F, 0xE3, 0x31 + }, + { + 0x6D, 0x96, 0x3A, 0x75, 0xF1, 0xB7, 0xFE, 0xA9, + 0x5C, 0x11, 0x51, 0x1B, 0x5B, 0xE6, 0xC0, 0x9D, + 0xC0, 0x5D, 0x97, 0x10, 0xE0, 0x6E, 0x8E, 0x18, + 0xE0, 0xC5, 0xD6, 0xBD, 0xE9, 0x68, 0xBA, 0x42, + 0xCC, 0xDB, 0x01, 0xB2, 0x78, 0x24, 0x11, 0x42, + 0x68, 0x17, 0xEC, 0x99, 0xA2, 0xC2, 0xE6, 0x0B, + 0xE0, 0x56, 0x70, 0x57, 0x8B, 0x69, 0x52, 0x27, + 0x1B, 0x41, 0x2C, 0xFD, 0xBC, 0x2F, 0x30, 0x9F + }, + { + 0x38, 0xB8, 0xEB, 0xF2, 0x24, 0xC7, 0x47, 0x63, + 0x19, 0x28, 0x37, 0x04, 0xAD, 0x1C, 0xBE, 0x28, + 0xAA, 0xDE, 0x2B, 0xAE, 0x10, 0x02, 0xFF, 0xB4, + 0xCC, 0xA2, 0x78, 0x5A, 0x85, 0xB6, 0xE0, 0x57, + 0x32, 0x0E, 0x24, 0x61, 0xC1, 0xFA, 0x7B, 0xBB, + 0x1B, 0xCC, 0x95, 0x5F, 0x1F, 0xE4, 0x4F, 0xE5, + 0x9D, 0xB2, 0x91, 0x1C, 0x0F, 0x87, 0x68, 0x55, + 0x28, 0xD6, 0x59, 0x51, 0xB4, 0x8C, 0xF8, 0x7D + }, + { + 0x42, 0x78, 0xFC, 0xF3, 0x03, 0x20, 0x04, 0x82, + 0xE9, 0xF3, 0xA7, 0x92, 0xFF, 0xB1, 0x63, 0x1A, + 0xE5, 0xC4, 0xBA, 0xE2, 0x5A, 0xE9, 0xF4, 0x56, + 0x5B, 0x60, 0xE0, 0x03, 0xAF, 0x4F, 0x75, 0x27, + 0x0D, 0x5B, 0xDB, 0xC5, 0xDF, 0xDD, 0xF7, 0xDD, + 0x09, 0x90, 0x1B, 0x6C, 0x6F, 0xE1, 0x21, 0x71, + 0xB8, 0xE7, 0x41, 0xF0, 0xBC, 0x38, 0x29, 0x3F, + 0xEB, 0x12, 0x19, 0xDD, 0xA6, 0x84, 0x6D, 0xA6 + }, + { + 0xAF, 0x6E, 0x49, 0xE4, 0x5C, 0x09, 0xF8, 0xD5, + 0xB7, 0x00, 0x87, 0x6B, 0xC3, 0xF6, 0x76, 0x6C, + 0x02, 0xA5, 0x5B, 0x5F, 0x15, 0x42, 0xC8, 0x95, + 0x50, 0x37, 0xD3, 0x27, 0xC3, 0x8A, 0x05, 0x45, + 0x86, 0x85, 0x37, 0xAE, 0x0D, 0x57, 0x7A, 0xB6, + 0xA6, 0xBD, 0xF4, 0x4B, 0x7B, 0xF6, 0xBE, 0x87, + 0x45, 0xE9, 0x3E, 0x95, 0x7F, 0xB9, 0x06, 0x61, + 0x0D, 0x5D, 0xE0, 0x21, 0x75, 0xF3, 0x39, 0xC1 + }, + { + 0x1D, 0x09, 0x64, 0x44, 0x3F, 0xDC, 0x03, 0x0B, + 0x32, 0x30, 0xAB, 0xFE, 0xE7, 0xA7, 0x5C, 0x00, + 0xBF, 0xC7, 0x0D, 0x59, 0x03, 0x48, 0xEE, 0xAF, + 0xC5, 0x9D, 0x68, 0x36, 0x9D, 0xB4, 0x2C, 0x36, + 0xE7, 0xF2, 0x0E, 0xE9, 0x64, 0x4A, 0x87, 0x12, + 0x08, 0xF2, 0x06, 0x18, 0xC3, 0x5D, 0xAE, 0xF6, + 0x12, 0xE8, 0xB3, 0x33, 0x80, 0xD4, 0xE0, 0x00, + 0xC3, 0xF4, 0xB2, 0x1A, 0x39, 0x6F, 0x56, 0x9F + }, + { + 0xD0, 0x72, 0xEF, 0xA5, 0x0F, 0x56, 0x5E, 0x9E, + 0x5E, 0x59, 0xF4, 0x63, 0x4D, 0x99, 0x6E, 0x92, + 0x8A, 0x11, 0x04, 0xA4, 0x5F, 0x37, 0xBF, 0xA5, + 0x36, 0x11, 0xB9, 0xB7, 0x7A, 0x53, 0x97, 0x9D, + 0x85, 0x40, 0xAB, 0xAF, 0xF0, 0xFD, 0xCD, 0x47, + 0x3D, 0x5F, 0x33, 0x9B, 0x33, 0x19, 0xD8, 0xE6, + 0x5D, 0x54, 0xB3, 0x5A, 0xBC, 0x9F, 0xE6, 0xC2, + 0xA4, 0xAA, 0x04, 0xE8, 0x48, 0xE9, 0x5F, 0xCA + }, + { + 0x55, 0x18, 0x6C, 0x49, 0xD1, 0x2B, 0x1F, 0x20, + 0x9A, 0xA9, 0x7C, 0x57, 0x45, 0x6D, 0xB1, 0x03, + 0x40, 0x2D, 0x69, 0xC2, 0xA3, 0x1D, 0x2C, 0xBF, + 0x53, 0xF0, 0xD0, 0x1F, 0xBF, 0xC4, 0x3E, 0x02, + 0xB0, 0x5A, 0xEF, 0x4F, 0x2E, 0x62, 0x66, 0x80, + 0x64, 0x53, 0x9E, 0xA4, 0x95, 0xA4, 0x68, 0x9B, + 0x5D, 0x91, 0xC7, 0xFE, 0x32, 0x23, 0x75, 0xFA, + 0xB9, 0x2E, 0xA7, 0xFE, 0x24, 0xD0, 0xB7, 0x59 + }, + { + 0x30, 0x05, 0x9C, 0xE5, 0xE7, 0x34, 0x89, 0xAB, + 0xEB, 0xE7, 0xF2, 0xC5, 0x0D, 0xAB, 0x59, 0x93, + 0xA6, 0x8E, 0x74, 0xB1, 0x24, 0x9C, 0x10, 0xFD, + 0x6A, 0x8F, 0x17, 0xBA, 0x0E, 0x0B, 0x2B, 0x3B, + 0xAB, 0xA2, 0xCC, 0x6D, 0xCF, 0x8C, 0xDA, 0xC7, + 0x82, 0x06, 0xD1, 0x97, 0x3A, 0xBD, 0x19, 0xD1, + 0x70, 0x16, 0x50, 0x7B, 0x7B, 0x05, 0x5B, 0x91, + 0xDF, 0x75, 0xC7, 0x20, 0xE2, 0xD2, 0x23, 0xB0 + }, + { + 0x5A, 0xAE, 0x32, 0x78, 0x7A, 0xAF, 0x27, 0xBB, + 0x20, 0x24, 0x64, 0x21, 0x40, 0x2E, 0x90, 0xB7, + 0x04, 0x63, 0xF8, 0x20, 0x87, 0x18, 0x53, 0x72, + 0xCB, 0xFD, 0x36, 0xDB, 0x44, 0x84, 0x50, 0xB0, + 0x81, 0x4A, 0x64, 0x88, 0xB0, 0xB0, 0x2C, 0x28, + 0xC1, 0xFA, 0xF7, 0xAA, 0xF0, 0x3B, 0x1D, 0x7A, + 0xBF, 0x5D, 0x66, 0x02, 0x3A, 0x41, 0x26, 0x5A, + 0x21, 0x8D, 0x40, 0x5D, 0xA6, 0xE7, 0x2D, 0x04 + }, + { + 0x25, 0x40, 0xB2, 0x23, 0x15, 0xFD, 0x11, 0x4C, + 0xA7, 0xE9, 0x65, 0x39, 0x4A, 0xB6, 0xDF, 0x27, + 0xA2, 0xFE, 0x31, 0xD4, 0x7E, 0x44, 0xBC, 0x8D, + 0xEE, 0x04, 0x09, 0x95, 0x3E, 0xF9, 0x2D, 0xC5, + 0x63, 0xFC, 0xBE, 0x1C, 0x5B, 0x48, 0x6B, 0x84, + 0x2B, 0x35, 0x77, 0x7F, 0xD2, 0x49, 0x03, 0xB8, + 0xED, 0xE4, 0xBB, 0xF7, 0x75, 0x80, 0x0C, 0x70, + 0x06, 0x19, 0x28, 0x2C, 0x1A, 0x06, 0xF5, 0xD4 + }, + { + 0x18, 0x2D, 0x13, 0xD3, 0x2E, 0x61, 0x7C, 0x21, + 0x06, 0x07, 0x12, 0x5E, 0x0B, 0x62, 0xE4, 0x15, + 0xE5, 0x88, 0x84, 0xA7, 0xE2, 0x19, 0xC0, 0x9B, + 0x34, 0x4D, 0x17, 0xC9, 0xF0, 0x70, 0x89, 0x38, + 0x5E, 0xE5, 0xE8, 0x4C, 0x08, 0x78, 0x17, 0xA8, + 0x07, 0x8A, 0x44, 0xB8, 0x98, 0x47, 0xBC, 0x75, + 0x38, 0x8F, 0x11, 0x34, 0x7F, 0xB4, 0x61, 0xBD, + 0xAE, 0xE5, 0x0C, 0xCA, 0x88, 0xD8, 0x1E, 0x3A + }, + { + 0x00, 0x66, 0xCB, 0xEC, 0x15, 0x5B, 0xA2, 0xFE, + 0x1F, 0x29, 0x89, 0x07, 0x2F, 0x47, 0xA6, 0x4F, + 0x6A, 0x3B, 0x83, 0x56, 0x49, 0xFA, 0xA0, 0x0D, + 0xE8, 0x6B, 0xBA, 0x88, 0xA7, 0xBD, 0xC8, 0xF8, + 0x23, 0x2D, 0xA9, 0xBB, 0x33, 0xBA, 0x9D, 0xA9, + 0x7A, 0x83, 0xF7, 0xAD, 0x08, 0xA4, 0xC8, 0xBD, + 0xC1, 0x78, 0xCC, 0x07, 0xFD, 0x5C, 0xCA, 0x42, + 0x07, 0xFA, 0x0C, 0xA6, 0xB9, 0xC0, 0xE7, 0xB2 + }, + { + 0x55, 0x9C, 0x00, 0x66, 0x1F, 0x41, 0x06, 0x86, + 0xC8, 0x52, 0x01, 0x19, 0x25, 0x3B, 0x9F, 0x08, + 0xAD, 0xA3, 0x2D, 0x2A, 0x89, 0x07, 0x1A, 0x0D, + 0x45, 0xAE, 0x00, 0xAC, 0xAE, 0x2B, 0xB6, 0x42, + 0x0A, 0xF2, 0xBC, 0x02, 0x26, 0x25, 0x05, 0xA3, + 0xC8, 0x92, 0x75, 0x96, 0x2B, 0xAC, 0xD9, 0x21, + 0x6F, 0xEF, 0x18, 0x87, 0x8D, 0x86, 0x24, 0x0A, + 0x7A, 0xB1, 0xFB, 0x00, 0x64, 0x7C, 0x33, 0xFA + }, + { + 0x3B, 0x8D, 0xD9, 0xC7, 0x9B, 0x44, 0xE1, 0x88, + 0x4E, 0xBB, 0x1D, 0x95, 0x80, 0x2B, 0x83, 0x4A, + 0xEE, 0x81, 0x7A, 0xEF, 0x1F, 0xF4, 0x62, 0xEE, + 0xA5, 0x5B, 0x38, 0x1F, 0xE2, 0x4A, 0xB1, 0xF6, + 0xB8, 0x48, 0x64, 0x86, 0xDE, 0x01, 0xF7, 0x24, + 0xF3, 0x26, 0x9C, 0x10, 0x2B, 0x0A, 0x8A, 0x1E, + 0x35, 0xDA, 0xD0, 0x9A, 0x54, 0x72, 0x2E, 0x7D, + 0x62, 0x33, 0xA0, 0xA9, 0x0C, 0x93, 0x74, 0x5D + }, + { + 0x49, 0x9F, 0x7C, 0x57, 0xB4, 0xEE, 0x73, 0x33, + 0xAF, 0x90, 0x43, 0x52, 0xE1, 0x67, 0x7B, 0x54, + 0xB6, 0xD8, 0xE6, 0x0B, 0xEB, 0xCB, 0x2F, 0x9C, + 0xCE, 0x09, 0x3D, 0xD0, 0x23, 0x4B, 0x1A, 0x84, + 0x9C, 0x67, 0x2B, 0x4A, 0xD2, 0xCD, 0xAB, 0x3E, + 0x67, 0xA2, 0x61, 0xD2, 0x15, 0xB7, 0x80, 0x6C, + 0xF8, 0xF4, 0x11, 0x26, 0x82, 0xCC, 0xC5, 0x6A, + 0x95, 0xC7, 0x11, 0x9F, 0xFE, 0x20, 0x1A, 0x78 + }, + { + 0xFF, 0xC5, 0x9D, 0x80, 0xE2, 0xC0, 0x77, 0xFD, + 0xD7, 0x9C, 0xD2, 0x45, 0xD0, 0x93, 0x00, 0x1B, + 0x1E, 0x9A, 0x75, 0xB5, 0x35, 0x8A, 0xEE, 0x1F, + 0xA4, 0x56, 0xAC, 0x39, 0x04, 0xD0, 0x9D, 0xA8, + 0x11, 0x96, 0x1B, 0xE2, 0x8B, 0x6F, 0x44, 0xFD, + 0xEE, 0xA2, 0x49, 0x9A, 0xE5, 0xBB, 0x12, 0x9E, + 0x57, 0x90, 0xC5, 0xF5, 0xBB, 0xCB, 0xB8, 0x5D, + 0x96, 0xBF, 0x56, 0xF6, 0x22, 0x62, 0x66, 0x21 + }, + { + 0x87, 0x3D, 0xD0, 0xEC, 0xE0, 0xFE, 0x61, 0xC2, + 0x14, 0xA5, 0x4D, 0x3C, 0x61, 0x04, 0x28, 0x0A, + 0x6D, 0xD7, 0xC1, 0xB8, 0xEB, 0x4D, 0xB6, 0x94, + 0x8F, 0x81, 0x53, 0x23, 0xF3, 0x46, 0xBA, 0x93, + 0x2F, 0xD1, 0x10, 0x98, 0x74, 0x61, 0xE2, 0xBC, + 0x3A, 0xA4, 0x11, 0x11, 0x08, 0xD9, 0x48, 0x83, + 0x24, 0xD5, 0x20, 0x7A, 0x56, 0xFA, 0x34, 0x5C, + 0x70, 0x7C, 0x38, 0x67, 0xF1, 0x32, 0xF9, 0x84 + }, + { + 0xE7, 0xDD, 0x2F, 0x68, 0x86, 0xB4, 0xC2, 0xFA, + 0x1B, 0xCD, 0x8A, 0x0F, 0xD8, 0x2F, 0x56, 0x94, + 0x74, 0xC4, 0xB1, 0xDA, 0x50, 0x3C, 0x5E, 0x10, + 0xBB, 0x33, 0x8F, 0x6E, 0x69, 0x4B, 0x68, 0x3A, + 0xFB, 0xCB, 0x3E, 0x49, 0x10, 0xF1, 0xFF, 0x5C, + 0xC0, 0xCF, 0x71, 0x1C, 0x34, 0x60, 0xC8, 0x4D, + 0xAA, 0x68, 0x8F, 0xEA, 0x8B, 0x86, 0x5C, 0xE9, + 0x47, 0x91, 0x09, 0x21, 0x5E, 0xE6, 0xF3, 0xF2 + }, + { + 0xBE, 0x22, 0x04, 0xB3, 0x2C, 0xB9, 0x12, 0xC6, + 0x80, 0x1A, 0x1B, 0x1D, 0x91, 0x2B, 0x3B, 0x58, + 0xB1, 0x99, 0x95, 0xAA, 0x8C, 0x43, 0xB9, 0x66, + 0xE1, 0x52, 0xB7, 0xDD, 0x57, 0xE8, 0xC0, 0x7F, + 0x6A, 0x3B, 0xE8, 0x74, 0x5C, 0x5D, 0x83, 0x04, + 0xD4, 0x2F, 0x97, 0x5F, 0x84, 0x2D, 0x64, 0x6A, + 0xBE, 0x98, 0x13, 0x89, 0x7D, 0x79, 0xF5, 0xD5, + 0xDC, 0x63, 0x67, 0xCA, 0x6D, 0x23, 0x34, 0x42 + }, + { + 0x61, 0xBE, 0xB2, 0xB5, 0xC8, 0xA3, 0x8A, 0x0A, + 0xB3, 0x91, 0xC6, 0x0B, 0x63, 0xE7, 0xAD, 0xD6, + 0xF5, 0x8A, 0xDD, 0xAB, 0x9B, 0x77, 0xC9, 0x94, + 0x7D, 0x9C, 0x50, 0x7E, 0xC0, 0x90, 0xC6, 0x38, + 0xA4, 0x5A, 0x68, 0x4D, 0xA2, 0x38, 0x38, 0x12, + 0x23, 0xE1, 0x38, 0xEA, 0x31, 0xE3, 0x73, 0x19, + 0x6E, 0x58, 0x48, 0x8F, 0x81, 0x88, 0xCD, 0xD1, + 0xA6, 0xB4, 0xF2, 0xC1, 0x08, 0x0B, 0xCB, 0x87 + }, + { + 0xE4, 0x34, 0xA3, 0x0B, 0xAD, 0x94, 0xAC, 0xF0, + 0x7E, 0x10, 0x49, 0x4A, 0x78, 0xAE, 0x97, 0x75, + 0x0B, 0x1A, 0x1F, 0x15, 0xAA, 0xEC, 0x3F, 0x78, + 0xC8, 0xF9, 0x99, 0xF0, 0x1F, 0x1B, 0x50, 0xA4, + 0x6C, 0xFC, 0xE7, 0xEB, 0x2C, 0x87, 0x11, 0x65, + 0x0D, 0xF9, 0x0C, 0x13, 0x7E, 0xA3, 0x72, 0xC2, + 0x05, 0x72, 0x85, 0x28, 0x63, 0x2B, 0xA9, 0xD8, + 0x7D, 0xC9, 0xD6, 0xED, 0x38, 0x70, 0xB2, 0xF9 + }, + { + 0x2E, 0xD0, 0xB3, 0x44, 0x1A, 0x5D, 0xF9, 0xBC, + 0x57, 0x1B, 0x92, 0x47, 0xFE, 0x80, 0x18, 0x58, + 0xDD, 0x59, 0x61, 0xDE, 0x10, 0x72, 0xD6, 0x3B, + 0x68, 0x09, 0x09, 0x07, 0xE4, 0x3E, 0xD0, 0x0B, + 0x2D, 0x9F, 0xFF, 0xE3, 0x72, 0xF9, 0x35, 0xDD, + 0x91, 0xD9, 0x51, 0x39, 0xAF, 0x2F, 0x54, 0xD9, + 0xC2, 0x7D, 0xEF, 0x3C, 0x95, 0x1A, 0xB7, 0xA7, + 0x98, 0xE9, 0x78, 0x96, 0xBB, 0x9B, 0x9D, 0xE8 + }, + { + 0x16, 0x4D, 0xB4, 0x62, 0x5D, 0xAA, 0xB6, 0x66, + 0x74, 0x91, 0xB0, 0x66, 0x60, 0xE4, 0xB4, 0xF1, + 0x24, 0x8B, 0x14, 0x64, 0xCE, 0x50, 0xAA, 0xB8, + 0x3A, 0x17, 0x01, 0xD6, 0x3D, 0xC3, 0x92, 0xDB, + 0x7D, 0x1F, 0xCA, 0x14, 0xA9, 0x13, 0xE6, 0x5C, + 0xC7, 0x04, 0xB8, 0x16, 0x92, 0x56, 0xB0, 0xDE, + 0x3F, 0x40, 0x49, 0xC1, 0x3B, 0xEB, 0x63, 0xFC, + 0x1E, 0x14, 0xDA, 0x75, 0xB7, 0xDF, 0x76, 0xA4 + }, + { + 0x72, 0x03, 0x6E, 0x06, 0x70, 0x04, 0x1A, 0x93, + 0xC4, 0xCD, 0x57, 0xC8, 0xFB, 0x62, 0x50, 0x45, + 0xF5, 0x5C, 0x3D, 0xB7, 0x34, 0x70, 0x17, 0x07, + 0x49, 0xEB, 0x69, 0x07, 0x6B, 0x91, 0x97, 0xD5, + 0xC8, 0xBE, 0xC7, 0x65, 0x50, 0x4B, 0xAC, 0xA9, + 0x69, 0x5E, 0xA3, 0xD6, 0x70, 0xA5, 0xD2, 0x31, + 0x99, 0x88, 0x5B, 0x45, 0x02, 0xED, 0xC6, 0x2E, + 0xC4, 0xFF, 0x58, 0x9A, 0xCD, 0xAF, 0xB2, 0x7E + }, + { + 0xFD, 0x44, 0x9B, 0xB9, 0xD9, 0x32, 0x12, 0x12, + 0x30, 0x97, 0x7A, 0x6C, 0x54, 0x3B, 0xDE, 0x19, + 0x3B, 0xDA, 0x99, 0x4F, 0x4E, 0x9D, 0xA7, 0x3A, + 0xA6, 0xF9, 0x8D, 0xF6, 0x61, 0x1D, 0x19, 0x56, + 0xA9, 0xC1, 0xBF, 0x64, 0x74, 0xA7, 0x87, 0x08, + 0xC0, 0x1D, 0xAC, 0xFE, 0xDA, 0x94, 0x9D, 0x9B, + 0xAB, 0x3E, 0x2D, 0xCD, 0x56, 0x74, 0x5B, 0x24, + 0xE0, 0x2E, 0xCD, 0xDF, 0x66, 0x58, 0xCE, 0x5E + }, + { + 0x47, 0x27, 0xD5, 0x9E, 0x31, 0xE2, 0x70, 0xA0, + 0xFE, 0xEC, 0x76, 0x93, 0xA0, 0xAA, 0x31, 0x0B, + 0x45, 0x88, 0xF1, 0x67, 0xA6, 0x73, 0x71, 0x45, + 0x70, 0x5C, 0x07, 0x10, 0xA1, 0x7B, 0x65, 0x72, + 0xC0, 0x99, 0x13, 0xEF, 0x2D, 0x2A, 0x45, 0x2F, + 0x62, 0x9B, 0x89, 0x63, 0x38, 0x33, 0x8B, 0x78, + 0xEA, 0x04, 0x6A, 0x55, 0x62, 0xA8, 0xA6, 0xD5, + 0x4E, 0x54, 0x4D, 0xF2, 0x6F, 0x33, 0x68, 0x79 + }, + { + 0xB4, 0x5C, 0xCA, 0xB3, 0x21, 0xF5, 0x51, 0x6A, + 0x5B, 0x82, 0x10, 0xEE, 0x58, 0x0D, 0x77, 0xDE, + 0x85, 0xAA, 0xE4, 0x32, 0x6B, 0x8A, 0xD4, 0xCA, + 0xBC, 0x27, 0xAE, 0xDD, 0xB1, 0x36, 0xA0, 0x08, + 0x81, 0x61, 0x40, 0x49, 0xA2, 0x47, 0xE8, 0x28, + 0x97, 0xC8, 0x5E, 0x4F, 0xBD, 0x6B, 0x30, 0x8D, + 0x39, 0xC4, 0x40, 0x38, 0x8F, 0x1F, 0xB0, 0x24, + 0x7D, 0x66, 0x26, 0x56, 0xAB, 0xFE, 0x69, 0x5A + }, + { + 0x34, 0xF0, 0xED, 0x36, 0x66, 0x58, 0x48, 0x42, + 0x37, 0xAA, 0x03, 0xD1, 0x65, 0x92, 0xA3, 0x0F, + 0xEB, 0x13, 0x1A, 0x40, 0x65, 0x09, 0xE2, 0xAB, + 0x9A, 0x21, 0x94, 0x5C, 0x28, 0xB3, 0x2F, 0x06, + 0x08, 0x02, 0x56, 0xC4, 0xC2, 0xF1, 0x82, 0xC7, + 0xE9, 0xE3, 0x5D, 0x6D, 0x4B, 0xAA, 0x5F, 0x8C, + 0x6D, 0xD1, 0xC3, 0xF4, 0x91, 0x9F, 0x18, 0x96, + 0xAD, 0x59, 0x12, 0xEC, 0xC2, 0x27, 0xB6, 0xA7 + }, + { + 0x27, 0x09, 0x41, 0x4F, 0x8A, 0xA0, 0x9B, 0xA7, + 0x13, 0xA3, 0x2C, 0x97, 0xEB, 0x29, 0xD4, 0xDF, + 0x11, 0x28, 0xDC, 0x3D, 0x50, 0x57, 0x5C, 0xA6, + 0x82, 0x7F, 0x3E, 0x18, 0x4A, 0xE0, 0x8B, 0xB1, + 0x9C, 0x2C, 0x14, 0x54, 0xCF, 0xFB, 0xB9, 0x15, + 0xC3, 0x57, 0x37, 0x2E, 0x14, 0xC2, 0x52, 0xF5, + 0x7A, 0x24, 0xF4, 0x5D, 0x94, 0xF4, 0x21, 0x76, + 0x9A, 0x02, 0x1F, 0xE5, 0xDF, 0xD5, 0x9B, 0xAF + }, + { + 0x60, 0xC8, 0x9A, 0xF7, 0x74, 0x97, 0xC5, 0xB7, + 0x6A, 0x21, 0xBA, 0xC4, 0xA4, 0x81, 0xF6, 0x37, + 0x08, 0x73, 0x73, 0x48, 0xFE, 0x38, 0x7A, 0xA4, + 0x85, 0x96, 0x92, 0x94, 0x74, 0x61, 0xFE, 0x2E, + 0x75, 0x2B, 0x94, 0xED, 0x1F, 0x5E, 0xD3, 0x6B, + 0x29, 0xC4, 0x53, 0x97, 0x43, 0xE5, 0x62, 0xCF, + 0x2C, 0xFA, 0xF4, 0xD7, 0x03, 0xA6, 0x34, 0x51, + 0x13, 0xF0, 0xEE, 0x76, 0x78, 0xD2, 0x6B, 0x89 + }, + { + 0xCE, 0x31, 0x9F, 0x8C, 0x5A, 0x3C, 0x77, 0xE1, + 0xC2, 0xB0, 0x2A, 0x45, 0x18, 0x45, 0xAA, 0x2B, + 0x9D, 0x7C, 0xB0, 0x1F, 0x57, 0x43, 0x1E, 0x10, + 0x13, 0x98, 0xC7, 0x4A, 0x45, 0xA9, 0xC6, 0xD3, + 0x95, 0xF6, 0xE4, 0x34, 0x09, 0xD7, 0x1F, 0x16, + 0x28, 0xCC, 0x22, 0xD3, 0xCE, 0xD2, 0x7C, 0x30, + 0x7B, 0x46, 0x7E, 0x1E, 0x01, 0x36, 0x3A, 0x43, + 0x8E, 0xD3, 0x8E, 0x5E, 0xA8, 0x0B, 0x07, 0x11 + }, + { + 0x98, 0x6D, 0x46, 0xE0, 0x87, 0x42, 0xE4, 0xC6, + 0xAC, 0x19, 0x3C, 0x1D, 0x06, 0x1A, 0x3C, 0xCF, + 0xA2, 0xB8, 0x39, 0x63, 0x59, 0xF1, 0x62, 0x99, + 0x7D, 0xD8, 0x5E, 0x34, 0x96, 0x56, 0xD1, 0xDE, + 0x39, 0x4D, 0x4A, 0x2B, 0x9E, 0x5B, 0x43, 0xF3, + 0x56, 0x72, 0x77, 0x85, 0x35, 0xAE, 0xCE, 0xBE, + 0xD1, 0x02, 0xA4, 0x83, 0x48, 0xBB, 0xF7, 0xC5, + 0x3C, 0xED, 0xBE, 0x95, 0x94, 0x17, 0x05, 0xC3 + }, + { + 0xB5, 0x51, 0x13, 0xA5, 0xF0, 0x87, 0xCA, 0xAD, + 0x4E, 0x13, 0xB8, 0xC0, 0xFF, 0xE9, 0x30, 0xA0, + 0x30, 0x7F, 0x13, 0x41, 0xD8, 0x6A, 0x62, 0x7E, + 0xBB, 0x99, 0xD2, 0xDC, 0x60, 0x5B, 0xE6, 0x6D, + 0x2F, 0x9A, 0xC9, 0x6D, 0x96, 0xF7, 0xC0, 0x31, + 0xEF, 0x5B, 0x37, 0xFE, 0xFA, 0x4A, 0xAA, 0xE4, + 0x5F, 0x83, 0xD1, 0x3F, 0xB2, 0x8C, 0xA5, 0xF0, + 0x07, 0x3E, 0xDB, 0x5B, 0xC8, 0xCE, 0x9C, 0x00 + }, + { + 0xA5, 0xA9, 0xDF, 0xC9, 0x0B, 0xBE, 0x44, 0xF4, + 0xB4, 0x3C, 0xA1, 0xE0, 0x92, 0x76, 0x14, 0x56, + 0xCE, 0x50, 0xBA, 0xEC, 0x16, 0x51, 0xAF, 0xB2, + 0xBA, 0x5A, 0xC9, 0x0D, 0xB1, 0x8D, 0x09, 0x3F, + 0x53, 0xEA, 0x3D, 0x57, 0x1F, 0x7A, 0x6E, 0x18, + 0xBF, 0xB8, 0xA3, 0x3F, 0xBF, 0x67, 0x84, 0xD9, + 0xDA, 0x53, 0x5D, 0xD4, 0x82, 0xDF, 0xD1, 0xE4, + 0x4E, 0xE4, 0xFC, 0x61, 0xCE, 0x9A, 0xD1, 0x74 + }, + { + 0x66, 0xFF, 0x05, 0x35, 0xC0, 0xF5, 0x6D, 0x01, + 0xFC, 0xD1, 0xE0, 0x9C, 0x00, 0x3D, 0x6D, 0x25, + 0xD8, 0xDA, 0xA4, 0x26, 0x0E, 0xC8, 0x01, 0xEF, + 0x00, 0xD1, 0x42, 0xCE, 0x84, 0x48, 0x10, 0x29, + 0x51, 0x6B, 0x76, 0x9F, 0x19, 0xFB, 0xAB, 0x68, + 0xFB, 0xC5, 0x9F, 0x30, 0x9D, 0x6C, 0x50, 0x75, + 0xFD, 0x6E, 0xEA, 0x08, 0x14, 0x65, 0x31, 0xC1, + 0x58, 0x43, 0x7C, 0x78, 0x6B, 0x48, 0xA6, 0xDA + }, + { + 0x3E, 0xC6, 0x23, 0x09, 0xA9, 0xE5, 0x08, 0x8F, + 0xD9, 0xE0, 0xC3, 0x98, 0x47, 0xED, 0x8E, 0x15, + 0x8A, 0xC6, 0xE6, 0x01, 0x2E, 0xA5, 0x57, 0xE8, + 0xC0, 0x8B, 0x6D, 0xEC, 0x75, 0x5C, 0x68, 0xCD, + 0x9C, 0x79, 0xFA, 0x02, 0x7F, 0xD2, 0x67, 0xF1, + 0x9A, 0x24, 0xF2, 0x7A, 0xBA, 0x6E, 0xB6, 0xA2, + 0xF3, 0x96, 0x92, 0x51, 0xC0, 0x9D, 0x10, 0x91, + 0xEF, 0x6D, 0x79, 0xF7, 0xDC, 0x20, 0x92, 0x2C + }, + { + 0x0D, 0xEA, 0xE1, 0x60, 0x12, 0xB3, 0x1B, 0xA0, + 0x4B, 0x0B, 0x24, 0x61, 0x6B, 0xCF, 0x83, 0xA8, + 0xF6, 0x5C, 0x30, 0x97, 0x87, 0x5B, 0x51, 0x52, + 0x89, 0x11, 0x99, 0x47, 0x87, 0xF2, 0x4F, 0xF1, + 0xC1, 0x30, 0xBE, 0x2B, 0x5E, 0x7D, 0x18, 0x65, + 0x90, 0xE9, 0xCD, 0x58, 0x0E, 0xA5, 0x42, 0x73, + 0x00, 0xDC, 0x4A, 0x8D, 0xE8, 0x08, 0xB4, 0xE5, + 0x54, 0xC6, 0x5E, 0xBA, 0x89, 0x7F, 0x78, 0x98 + }, + { + 0x9A, 0xFD, 0x24, 0x12, 0x00, 0x73, 0xB6, 0x11, + 0xAF, 0x61, 0xE6, 0xF6, 0x9B, 0xCB, 0xBF, 0x41, + 0x34, 0xCD, 0x1F, 0x79, 0x4A, 0x28, 0xF1, 0xC9, + 0x93, 0x89, 0xFF, 0x86, 0xD8, 0x91, 0x5E, 0x63, + 0x23, 0x3D, 0xCE, 0x1C, 0xA4, 0xAB, 0x8B, 0x2B, + 0xA0, 0xD7, 0x77, 0x76, 0xC8, 0xCA, 0x4A, 0x90, + 0x4D, 0x6B, 0x3D, 0x9E, 0x1F, 0x1E, 0x3B, 0x45, + 0xB8, 0x6D, 0x98, 0x2A, 0xD4, 0xB6, 0x8D, 0xD0 + }, + { + 0xEC, 0x19, 0xD2, 0x86, 0x6F, 0x24, 0x84, 0xA2, + 0x00, 0x0F, 0xA1, 0xDA, 0xFC, 0x8F, 0x0A, 0xE4, + 0x86, 0xDC, 0x4E, 0x69, 0xD7, 0x83, 0x4A, 0x9B, + 0xF0, 0xF2, 0xAD, 0x5B, 0x35, 0x36, 0x42, 0x4A, + 0xFA, 0x8F, 0xC5, 0x0A, 0xCE, 0xC9, 0x98, 0x8E, + 0x8B, 0x06, 0xCA, 0x38, 0x08, 0x34, 0xEF, 0xF0, + 0x7C, 0xDA, 0xC6, 0xD4, 0x70, 0x68, 0x97, 0xE6, + 0xC4, 0x09, 0x65, 0xA1, 0xA2, 0x07, 0xAC, 0x0D + }, + { + 0x76, 0xE6, 0x9B, 0x5F, 0x42, 0xB8, 0x69, 0x37, + 0x46, 0xC8, 0x52, 0xA9, 0x0B, 0x0C, 0xBB, 0xD7, + 0x69, 0xD4, 0x2D, 0xA2, 0x39, 0x60, 0x31, 0xF1, + 0x37, 0x4A, 0x78, 0x6D, 0xE4, 0xE9, 0x4A, 0x84, + 0x75, 0x09, 0x0D, 0xD2, 0x68, 0xC2, 0xAB, 0x00, + 0x71, 0x32, 0x16, 0x20, 0x9A, 0x64, 0xDB, 0x2B, + 0xA9, 0xB2, 0xC7, 0xAF, 0x9B, 0x6C, 0x6C, 0x62, + 0x6A, 0x2A, 0xAD, 0xA9, 0x92, 0x85, 0x1D, 0xD8 + }, + { + 0x3A, 0xAC, 0x43, 0xCC, 0xEA, 0xE4, 0xCF, 0x6A, + 0x86, 0xF6, 0x3F, 0x23, 0x6D, 0x73, 0x8E, 0x84, + 0xC5, 0x9F, 0xAC, 0x0F, 0xB7, 0x66, 0x5F, 0xFB, + 0x0A, 0xCD, 0xE3, 0x26, 0xF9, 0x5F, 0x88, 0x17, + 0x33, 0xE6, 0xB4, 0x6D, 0x68, 0x53, 0x1C, 0x1F, + 0xB0, 0x67, 0xA0, 0x56, 0x1E, 0xFC, 0x0E, 0x82, + 0xBC, 0xBD, 0xB1, 0x54, 0xCB, 0x57, 0xF1, 0xE8, + 0xF1, 0x26, 0xA9, 0xBD, 0x4F, 0x12, 0x4E, 0xB7 + }, + { + 0x99, 0x7A, 0xC9, 0x8B, 0xCF, 0x82, 0x6A, 0xC9, + 0x45, 0x2A, 0x89, 0x1C, 0x15, 0xFD, 0x7C, 0xC6, + 0x12, 0x74, 0x08, 0x01, 0x01, 0xDD, 0xB6, 0x33, + 0x98, 0x13, 0xBA, 0xD3, 0x08, 0xDD, 0xA4, 0x58, + 0x87, 0x1F, 0xF1, 0x3E, 0xB5, 0x10, 0x03, 0xA9, + 0x38, 0xAB, 0x39, 0x65, 0x91, 0xA6, 0x6A, 0x69, + 0x7B, 0x7C, 0xBE, 0xD3, 0x08, 0x8D, 0xC4, 0x86, + 0xDF, 0x1D, 0x70, 0x27, 0x14, 0xC5, 0x1B, 0xEE + }, + { + 0x9B, 0xED, 0x42, 0xF6, 0x71, 0xF1, 0xC3, 0xF3, + 0x05, 0x64, 0x14, 0x52, 0xF7, 0xCC, 0x81, 0x73, + 0xEE, 0x7C, 0xED, 0x66, 0xDA, 0xE9, 0xDA, 0x80, + 0x9B, 0x0D, 0xFC, 0x59, 0x93, 0xBE, 0x47, 0x79, + 0xE5, 0x95, 0x1A, 0xA0, 0xD3, 0xAB, 0xB8, 0x1E, + 0x9E, 0xC7, 0xD3, 0xFB, 0x01, 0x10, 0xC4, 0xFE, + 0x36, 0xE4, 0xB7, 0x30, 0x76, 0x83, 0x7F, 0x4C, + 0x6F, 0xDA, 0x22, 0x51, 0x07, 0x64, 0x02, 0x67 + }, + { + 0xFF, 0x02, 0xD1, 0x6D, 0xA4, 0xF2, 0x15, 0x1B, + 0x4C, 0x77, 0x43, 0x82, 0xC8, 0x2B, 0x97, 0xC7, + 0x9D, 0x41, 0xDE, 0x36, 0x3D, 0x45, 0x31, 0x0C, + 0xBD, 0xE8, 0xAF, 0x36, 0xB5, 0xAA, 0xF7, 0x4D, + 0x85, 0xA6, 0xFC, 0x5D, 0xF8, 0x41, 0xCE, 0xC3, + 0xFF, 0xD9, 0x86, 0x37, 0x03, 0x1E, 0x55, 0x9F, + 0x70, 0x27, 0x69, 0x49, 0xB9, 0xD8, 0x2B, 0x43, + 0xAC, 0x03, 0x0A, 0x5A, 0x26, 0xE5, 0xFB, 0x4A + }, + { + 0x69, 0x75, 0xF9, 0x67, 0x4D, 0xF5, 0xC5, 0xE1, + 0x5C, 0x86, 0x7D, 0x59, 0x36, 0xE3, 0x38, 0x5A, + 0xF8, 0x75, 0x79, 0xA0, 0x98, 0x76, 0x57, 0x9E, + 0x66, 0xB5, 0x0B, 0x98, 0xB2, 0x2C, 0x8D, 0xED, + 0x4E, 0xD6, 0x3F, 0xAF, 0x59, 0x70, 0x0C, 0xE7, + 0x36, 0x9F, 0xEC, 0x97, 0xA6, 0xC2, 0xC8, 0xBE, + 0xD7, 0x38, 0x65, 0x34, 0x93, 0xDE, 0xFB, 0xA4, + 0x64, 0x98, 0x89, 0xF4, 0x6F, 0x54, 0xE3, 0x7C + }, + { + 0x7B, 0xB8, 0xC6, 0x3A, 0x11, 0x20, 0xC6, 0xF6, + 0x89, 0x08, 0xF0, 0x4A, 0x8E, 0xB3, 0xF7, 0x7F, + 0x82, 0x5C, 0x44, 0x1B, 0xA1, 0xE0, 0x3A, 0x5C, + 0xD9, 0x46, 0xF4, 0xEC, 0x97, 0x5D, 0x99, 0xB1, + 0xC9, 0x35, 0x6D, 0x73, 0xF1, 0xE7, 0x9C, 0x1D, + 0x9C, 0x48, 0x81, 0xCF, 0x15, 0xC5, 0x45, 0x7E, + 0x41, 0x1E, 0xD3, 0x2B, 0x05, 0x90, 0x14, 0x41, + 0x99, 0x80, 0xB5, 0x1F, 0x7F, 0x0C, 0xE5, 0x52 + }, + { + 0x43, 0x3E, 0xA0, 0xE2, 0x16, 0x41, 0x9D, 0xCD, + 0x88, 0x7A, 0xE1, 0x1D, 0x8E, 0x6A, 0xE3, 0x03, + 0xEE, 0x02, 0xAF, 0xBF, 0xF4, 0x3F, 0x65, 0x96, + 0xFF, 0x3A, 0xD1, 0x2C, 0xF0, 0xE3, 0x40, 0x44, + 0x06, 0x88, 0x84, 0xB9, 0x11, 0x73, 0x32, 0xA1, + 0x39, 0xEE, 0x6D, 0xEA, 0xF4, 0x1A, 0x19, 0x02, + 0xFB, 0x3F, 0x3A, 0xD3, 0xFB, 0xD5, 0x6F, 0x66, + 0x17, 0x6C, 0xD4, 0x33, 0x1D, 0x91, 0xB3, 0xD1 + }, + { + 0x81, 0x40, 0x57, 0xD9, 0x7E, 0x10, 0xBA, 0xCC, + 0xDD, 0xDE, 0x36, 0x68, 0xFC, 0xF5, 0xF0, 0x4F, + 0x44, 0x70, 0xED, 0x99, 0xCA, 0x81, 0xF3, 0x08, + 0xC7, 0xF2, 0x79, 0x58, 0xF5, 0x6A, 0x19, 0xFC, + 0xDB, 0x5B, 0xBB, 0x91, 0xFE, 0x64, 0x58, 0x23, + 0xFF, 0x43, 0x9C, 0xBE, 0xD0, 0x47, 0xFD, 0x49, + 0x7E, 0x55, 0x3D, 0x87, 0xF5, 0x36, 0x82, 0x17, + 0xA5, 0x42, 0xC2, 0xB7, 0xD2, 0xC8, 0x94, 0xF1 + }, + { + 0xBD, 0x8C, 0x47, 0x2B, 0x53, 0x8B, 0xF7, 0x0D, + 0x1B, 0x67, 0x67, 0x51, 0xCF, 0xB1, 0x21, 0x52, + 0x88, 0x89, 0x8D, 0xD4, 0x6B, 0x59, 0xAC, 0x31, + 0x23, 0x20, 0xD3, 0xD6, 0x59, 0x10, 0x8C, 0x50, + 0x75, 0xC4, 0x10, 0x47, 0xCE, 0xB3, 0x9A, 0x06, + 0x3F, 0xFB, 0xDA, 0xB6, 0x77, 0x37, 0x4F, 0x01, + 0x8E, 0xE9, 0x3E, 0x92, 0x84, 0x9B, 0x6C, 0x60, + 0x4A, 0x5D, 0xBA, 0x13, 0x25, 0x90, 0x93, 0xAE + }, + { + 0xB4, 0x24, 0x16, 0x39, 0x3E, 0x95, 0x33, 0x79, + 0x13, 0xE9, 0x06, 0xF3, 0x43, 0x78, 0x0F, 0xF7, + 0x73, 0xAE, 0xAB, 0xB7, 0x14, 0xBB, 0xC9, 0x46, + 0x28, 0x91, 0x6F, 0xB8, 0xB7, 0xD0, 0x78, 0x7B, + 0x16, 0x54, 0x6B, 0xC7, 0xA2, 0x77, 0x56, 0x17, + 0xD1, 0x16, 0xEE, 0x7C, 0x01, 0x00, 0x67, 0x50, + 0xFB, 0xFA, 0x27, 0x57, 0x76, 0xDC, 0x3E, 0xA5, + 0x32, 0xFE, 0xC9, 0x63, 0x20, 0x58, 0x38, 0xD7 + }, + { + 0x53, 0x6E, 0x6F, 0xAE, 0x3E, 0xC3, 0x77, 0x43, + 0xC6, 0x46, 0x04, 0x89, 0x3A, 0xE2, 0x22, 0xB3, + 0x95, 0xB9, 0x66, 0x30, 0xD4, 0xB8, 0x49, 0x4D, + 0x4D, 0x1F, 0x46, 0x09, 0x68, 0xB2, 0x6E, 0x26, + 0x88, 0x96, 0x64, 0xDB, 0xBB, 0x96, 0xD1, 0x58, + 0xE0, 0xB6, 0x39, 0x0D, 0xE2, 0x9C, 0xCB, 0x49, + 0x62, 0xF4, 0x27, 0xBC, 0x45, 0x58, 0x60, 0x47, + 0xDE, 0xEF, 0x77, 0x92, 0xC7, 0xAF, 0x9E, 0x56 + }, + { + 0x85, 0x25, 0x77, 0x49, 0x89, 0x4E, 0x44, 0x97, + 0xD3, 0x11, 0xC9, 0x2E, 0x8D, 0x23, 0xED, 0x60, + 0x2F, 0xC7, 0x93, 0x9F, 0x76, 0x5D, 0x37, 0x17, + 0xC3, 0x8F, 0xCA, 0x3A, 0x29, 0x60, 0x6C, 0xB1, + 0x46, 0x4B, 0x89, 0x2F, 0x4F, 0x0F, 0x90, 0xDB, + 0x39, 0x0D, 0x0F, 0x0C, 0xA8, 0xE4, 0x9B, 0xCC, + 0x5D, 0x08, 0x18, 0xA5, 0x7A, 0x8A, 0xAD, 0x22, + 0x65, 0x38, 0xBB, 0xDD, 0x79, 0xCA, 0x23, 0xB5 + }, + { + 0xF8, 0x73, 0x4F, 0xD4, 0x4D, 0x7F, 0xB3, 0x02, + 0x16, 0x3A, 0xEA, 0xEE, 0x35, 0x33, 0x0D, 0xBA, + 0x6C, 0x95, 0xC1, 0x23, 0xBF, 0x3D, 0x33, 0xA1, + 0xE3, 0x90, 0x96, 0xD7, 0xB8, 0x9A, 0x62, 0x50, + 0x8E, 0x61, 0xFD, 0x0A, 0x3E, 0xB8, 0x31, 0x1E, + 0xF3, 0x6B, 0xF0, 0x16, 0x8D, 0xD5, 0x3C, 0x3C, + 0x71, 0x79, 0x7B, 0x1E, 0xF8, 0x10, 0x27, 0xD9, + 0x23, 0x41, 0xF1, 0xC4, 0x29, 0x6A, 0xDE, 0x5E + }, + { + 0x99, 0x62, 0x8A, 0xB6, 0xA9, 0xE8, 0x8C, 0xD6, + 0x9D, 0xC2, 0x0A, 0x34, 0x21, 0x15, 0x0A, 0xCA, + 0xB8, 0x10, 0xF1, 0x09, 0x75, 0x61, 0x58, 0xBA, + 0x7A, 0xB6, 0x24, 0x8D, 0x79, 0xCE, 0xEC, 0xB8, + 0x86, 0xA7, 0x39, 0x9C, 0x4E, 0x7D, 0x47, 0x08, + 0x4B, 0x36, 0xF9, 0xD7, 0xD2, 0x6F, 0xC0, 0x94, + 0x07, 0xDF, 0x52, 0x3D, 0x03, 0xDF, 0x51, 0x68, + 0x0D, 0x25, 0xA2, 0x38, 0xD2, 0xE5, 0x1E, 0xF6 + }, + { + 0x32, 0x99, 0x70, 0x5C, 0xF4, 0x1F, 0xE8, 0x17, + 0x8E, 0x22, 0xF5, 0x57, 0xF8, 0xF3, 0x73, 0x52, + 0x9E, 0x1D, 0xB8, 0xB4, 0xC3, 0x36, 0x01, 0x45, + 0xBD, 0xD6, 0x1A, 0xF0, 0xC2, 0x1A, 0x2B, 0x5D, + 0xF9, 0xB4, 0x14, 0x2D, 0xB6, 0x40, 0x48, 0xFF, + 0xB4, 0xAC, 0x41, 0xBA, 0x8F, 0x84, 0xF2, 0x80, + 0x64, 0xC0, 0x10, 0x65, 0x4A, 0x82, 0x48, 0x20, + 0x97, 0xDA, 0x95, 0xD7, 0x91, 0xFF, 0x57, 0x21 + }, + { + 0x25, 0x21, 0xEA, 0x4D, 0xC4, 0xC4, 0xEF, 0x94, + 0x40, 0xF2, 0x08, 0xF2, 0xD6, 0xF0, 0x57, 0x56, + 0x7A, 0x85, 0xBD, 0x6B, 0xB5, 0x30, 0xF6, 0x3D, + 0x17, 0x9C, 0x79, 0xF5, 0x95, 0x84, 0xD1, 0x57, + 0xFF, 0xA9, 0x91, 0x98, 0x07, 0x6C, 0xF1, 0x66, + 0xF4, 0x29, 0x94, 0x0B, 0x0B, 0x86, 0x1B, 0xA4, + 0x88, 0x97, 0x8A, 0x7A, 0xCB, 0xAF, 0xE7, 0xBD, + 0x8C, 0xDF, 0x07, 0x97, 0xFB, 0xDD, 0xB8, 0x31 + }, + { + 0x8A, 0x0C, 0x00, 0x35, 0xD8, 0xF8, 0x65, 0x72, + 0xA7, 0x34, 0xDB, 0xC8, 0x9C, 0xF4, 0x1B, 0xFB, + 0xD1, 0x35, 0x33, 0x85, 0x3E, 0x2B, 0xB5, 0x51, + 0x6D, 0x3A, 0x77, 0x17, 0x70, 0x2A, 0xA8, 0xBB, + 0x19, 0x3B, 0x55, 0x88, 0xF4, 0x50, 0x72, 0x33, + 0x30, 0x05, 0xDB, 0xF6, 0x39, 0x4C, 0x22, 0x22, + 0x1F, 0x4F, 0xF6, 0xF8, 0xCD, 0x82, 0x42, 0xAC, + 0xAE, 0x82, 0x6F, 0x65, 0x6F, 0x7D, 0x13, 0x60 + }, + { + 0xF8, 0x3C, 0x11, 0x54, 0xA3, 0xEC, 0x22, 0x16, + 0xB5, 0x25, 0x3E, 0x46, 0x6F, 0xFA, 0xEC, 0x3D, + 0xE6, 0xD5, 0x83, 0x77, 0x1A, 0x02, 0xF8, 0x47, + 0xC3, 0xA8, 0xE9, 0xAE, 0xF9, 0xE4, 0x7E, 0x74, + 0xDC, 0x7F, 0x52, 0x27, 0x3E, 0x57, 0x3E, 0xEB, + 0x7C, 0x38, 0xA7, 0xCA, 0x1A, 0xF7, 0x25, 0xA4, + 0x16, 0x80, 0x7D, 0xB2, 0x56, 0xF7, 0x70, 0x36, + 0x81, 0xED, 0xC1, 0x17, 0x3B, 0x62, 0xA0, 0x3B + }, + { + 0x5A, 0xE0, 0x03, 0x87, 0xDA, 0x11, 0x2C, 0x08, + 0x94, 0xF9, 0x65, 0x15, 0xA5, 0x7B, 0xB1, 0x11, + 0x9A, 0xD1, 0x27, 0xA2, 0x41, 0x8E, 0xFD, 0xD3, + 0x82, 0x61, 0x07, 0xF2, 0x29, 0xAB, 0x4B, 0xFB, + 0xA7, 0xA5, 0x24, 0x92, 0xDE, 0x6A, 0x53, 0x69, + 0xF8, 0xE7, 0xF6, 0x07, 0x11, 0x6A, 0x2E, 0x70, + 0x42, 0x47, 0x65, 0x02, 0xD0, 0x21, 0xDB, 0x27, + 0x02, 0x81, 0xA5, 0x1C, 0xE7, 0x7B, 0x8F, 0xF1 + }, + { + 0x59, 0x8E, 0xCC, 0xEF, 0xE4, 0xCA, 0x72, 0x93, + 0x81, 0xBA, 0x77, 0xB9, 0x58, 0x7E, 0x0E, 0x3F, + 0xBB, 0x2E, 0xC2, 0xDD, 0x70, 0xF4, 0x18, 0x45, + 0xF3, 0x91, 0xA2, 0x9A, 0xA9, 0xDC, 0xA1, 0x04, + 0xDB, 0x29, 0xC2, 0xB5, 0x84, 0xCE, 0xA4, 0x59, + 0xDB, 0xC6, 0x93, 0x78, 0xBF, 0x88, 0xDC, 0x03, + 0xB8, 0x4E, 0xC0, 0x5A, 0x1E, 0x84, 0x4D, 0x7C, + 0xA7, 0x85, 0x46, 0x72, 0xCC, 0x50, 0xC6, 0x99 + }, + { + 0xBF, 0xCF, 0x4B, 0x96, 0xF4, 0xFF, 0x25, 0xD9, + 0x96, 0x0C, 0x17, 0xA4, 0x84, 0x4C, 0x60, 0xDE, + 0x57, 0x20, 0x7D, 0xB7, 0xF0, 0x89, 0x53, 0x13, + 0xDE, 0xE2, 0xF5, 0xCF, 0xFB, 0x6A, 0x8D, 0xEC, + 0x45, 0xC0, 0x20, 0x96, 0x8D, 0x9A, 0x33, 0xF9, + 0x64, 0xE9, 0x3F, 0xCC, 0x79, 0xE0, 0xFC, 0x82, + 0x3A, 0x4B, 0xEF, 0x81, 0x19, 0x77, 0xAA, 0x03, + 0x2C, 0x18, 0xED, 0xC8, 0xEC, 0xB2, 0xF6, 0x17 + }, + { + 0x72, 0xE5, 0x2A, 0x71, 0x13, 0x97, 0xE6, 0xD5, + 0x29, 0xCA, 0xCF, 0xF0, 0xCB, 0x42, 0xB9, 0x11, + 0x14, 0x1C, 0x24, 0x11, 0x2C, 0x8F, 0xF1, 0x4D, + 0x99, 0xF5, 0x1F, 0x5F, 0xE9, 0x4F, 0x4B, 0x05, + 0xA3, 0x15, 0x10, 0x21, 0x46, 0xF6, 0xE0, 0xD5, + 0x43, 0xB5, 0x84, 0xD0, 0x7D, 0x33, 0x28, 0xBB, + 0xFF, 0xEC, 0x8F, 0xD6, 0x38, 0x5E, 0x7C, 0xE7, + 0x22, 0xF6, 0x78, 0x2F, 0xAC, 0xDA, 0xFE, 0x3E + }, + { + 0x9C, 0xA0, 0x31, 0x7D, 0x71, 0x44, 0x9A, 0x61, + 0x44, 0x9F, 0x16, 0x7F, 0x71, 0x5F, 0xE4, 0x08, + 0x64, 0xAF, 0x52, 0x54, 0xA9, 0x2F, 0x65, 0xEA, + 0x75, 0x37, 0xE1, 0xB4, 0x9B, 0x7F, 0x15, 0xD5, + 0x8B, 0x6B, 0x78, 0x76, 0x74, 0xF7, 0x0B, 0x85, + 0x06, 0xBD, 0x42, 0x33, 0xB8, 0x6D, 0x47, 0x7E, + 0xDD, 0x58, 0x31, 0x85, 0x0E, 0x43, 0x4A, 0xB0, + 0x54, 0x44, 0x8C, 0xA2, 0x01, 0x05, 0x69, 0x21 + }, + { + 0x02, 0xF4, 0x66, 0x7B, 0x36, 0xDE, 0x08, 0xB5, + 0x68, 0xB8, 0xA7, 0x93, 0x31, 0x17, 0x42, 0x0E, + 0x8E, 0x2D, 0x71, 0xAC, 0x6E, 0x43, 0x9A, 0xEF, + 0x25, 0xBE, 0x27, 0x85, 0x9B, 0xB0, 0x92, 0x3D, + 0xCA, 0x3A, 0xC4, 0x8A, 0x01, 0xDD, 0x99, 0xDD, + 0xC2, 0xF1, 0xDF, 0x04, 0x50, 0x4B, 0xBE, 0x69, + 0x5D, 0xCD, 0x1F, 0x82, 0x11, 0x67, 0xED, 0x53, + 0x7F, 0x57, 0x06, 0x83, 0xB1, 0x41, 0x8D, 0x63 + }, + { + 0xE1, 0x66, 0xA7, 0x8A, 0xFF, 0x51, 0x18, 0xD1, + 0xD6, 0xBA, 0xD8, 0x62, 0xD1, 0x78, 0x04, 0xD2, + 0x32, 0x52, 0xC3, 0x5A, 0x48, 0x8B, 0xEC, 0xE1, + 0x36, 0x61, 0x53, 0x58, 0x91, 0xB0, 0xCB, 0x31, + 0xF7, 0x3D, 0xC7, 0xD6, 0x9F, 0x0F, 0x60, 0xDB, + 0x6D, 0x22, 0x2F, 0x0F, 0x1F, 0x8B, 0x76, 0x74, + 0x4E, 0x49, 0x9C, 0x38, 0xE3, 0x46, 0xA0, 0xAC, + 0x97, 0xF2, 0x42, 0x58, 0xC9, 0x2B, 0x02, 0xF2 + }, + { + 0x13, 0xD3, 0xAC, 0xB9, 0x83, 0x4B, 0x6A, 0x46, + 0x73, 0xA6, 0x1E, 0x60, 0xDB, 0xFE, 0x49, 0x86, + 0x78, 0x24, 0xB1, 0x9A, 0x17, 0xE4, 0xBA, 0x0A, + 0x33, 0xE7, 0x4B, 0x23, 0xDF, 0xB5, 0x89, 0xA5, + 0x9E, 0x76, 0x8D, 0x7B, 0x60, 0x1E, 0x4E, 0x6E, + 0x4A, 0x4F, 0x83, 0x3B, 0x0A, 0x90, 0xF2, 0x5C, + 0x74, 0xD8, 0x27, 0x24, 0xE2, 0x5D, 0xA8, 0xBC, + 0xC7, 0x73, 0x3B, 0x52, 0xC6, 0x4F, 0xAF, 0xB3 + }, + { + 0x78, 0x55, 0x0D, 0xDC, 0x3F, 0xF2, 0x8E, 0x40, + 0x79, 0x4D, 0xAE, 0x50, 0xEA, 0xAA, 0xED, 0x6E, + 0xCE, 0x40, 0x78, 0x2F, 0x55, 0x01, 0x8D, 0x55, + 0xDA, 0x26, 0xBD, 0x51, 0x51, 0x67, 0x9B, 0x09, + 0x80, 0xA9, 0x4B, 0xFF, 0xC5, 0xE8, 0xE5, 0x5F, + 0x82, 0x02, 0x60, 0x32, 0x14, 0xE9, 0x21, 0x42, + 0x88, 0xF9, 0x57, 0x0F, 0x72, 0x0E, 0x20, 0x17, + 0x9E, 0x22, 0x62, 0xF7, 0x7D, 0xEF, 0xB3, 0x73 + }, + { + 0x7B, 0x53, 0x4D, 0xA5, 0xD3, 0xB4, 0x25, 0x0E, + 0xEB, 0xED, 0xA1, 0x35, 0x6F, 0x6D, 0xC5, 0xBB, + 0x44, 0x1B, 0x2F, 0xF0, 0x79, 0xE2, 0x12, 0x83, + 0x97, 0x76, 0x3C, 0xC0, 0x71, 0xB2, 0x73, 0x89, + 0xC0, 0xD8, 0xF6, 0xAE, 0x56, 0xC7, 0xCF, 0x90, + 0x1A, 0x21, 0xC9, 0x57, 0xE3, 0x2E, 0x72, 0xFE, + 0x4B, 0x16, 0xC7, 0x6B, 0x69, 0x0F, 0x06, 0x1A, + 0xBD, 0xB4, 0x5D, 0x31, 0x10, 0x3D, 0x31, 0xC3 + }, + { + 0x44, 0x9C, 0xE3, 0x9D, 0x3C, 0xB7, 0xC7, 0x0B, + 0x06, 0x77, 0x0C, 0xC2, 0x83, 0xD1, 0xB6, 0x64, + 0xCA, 0x1F, 0x14, 0x62, 0x78, 0x9B, 0x46, 0x58, + 0xBC, 0x66, 0xDD, 0x7A, 0xDE, 0x1F, 0xBD, 0xB3, + 0xE6, 0x87, 0x8A, 0xD4, 0xCA, 0xCD, 0x90, 0x31, + 0x94, 0x68, 0xC8, 0xF0, 0xA3, 0xB0, 0x49, 0x12, + 0x86, 0x9A, 0x56, 0xD5, 0x73, 0x1F, 0x9C, 0x37, + 0x3F, 0xED, 0x02, 0x93, 0x7B, 0x1F, 0x2D, 0x45 + }, + { + 0x7F, 0xFB, 0xF9, 0x42, 0x94, 0x14, 0x08, 0xB6, + 0xC7, 0x58, 0x08, 0xA1, 0xCB, 0xAB, 0x0D, 0x19, + 0xD4, 0xF4, 0x73, 0x99, 0x02, 0xBA, 0xB4, 0xBE, + 0x2A, 0xDB, 0x6B, 0x3C, 0x5E, 0x85, 0x7D, 0xC0, + 0x6D, 0x79, 0xB9, 0x0B, 0xF2, 0xA4, 0xAE, 0xEC, + 0xA4, 0x73, 0xE5, 0x82, 0x74, 0x6F, 0x42, 0x64, + 0xF7, 0x38, 0xCB, 0x31, 0xDA, 0xF1, 0xD4, 0xB4, + 0x2E, 0x92, 0x9D, 0xAC, 0x46, 0xE6, 0xB2, 0x60 + }, + { + 0x02, 0xDD, 0xC2, 0x04, 0x4B, 0xF1, 0xBF, 0x42, + 0xEB, 0x15, 0x1B, 0x22, 0x43, 0x52, 0x86, 0xC9, + 0xEB, 0x3F, 0x9B, 0x67, 0x2E, 0x4B, 0xA8, 0xB7, + 0x39, 0x8D, 0x76, 0x6D, 0x8B, 0xBF, 0xAD, 0x4C, + 0x4B, 0xEE, 0x27, 0x5B, 0x82, 0xFB, 0xB5, 0x23, + 0xEF, 0x4B, 0xD2, 0xDC, 0xEA, 0x72, 0xC5, 0xA8, + 0x6E, 0x41, 0x8C, 0x20, 0xDB, 0x08, 0xEE, 0xD0, + 0x95, 0xDA, 0x7E, 0x6D, 0x4E, 0x68, 0x1A, 0x27 + }, + { + 0xB9, 0xE5, 0xD7, 0x93, 0x9F, 0xAA, 0xBD, 0x48, + 0xBF, 0xB2, 0xEA, 0x97, 0x76, 0x67, 0xFA, 0x40, + 0x3B, 0xF1, 0x87, 0x75, 0x22, 0x09, 0x54, 0x1D, + 0xA0, 0x49, 0xD3, 0xAE, 0xF9, 0x4D, 0xC7, 0xED, + 0xEA, 0x48, 0x01, 0x41, 0x76, 0xAF, 0x7B, 0x6A, + 0x11, 0x0F, 0x97, 0xDC, 0xC3, 0x3A, 0xB1, 0x88, + 0x89, 0xE6, 0x20, 0x50, 0xD4, 0xA9, 0x91, 0x20, + 0x06, 0x82, 0x51, 0x81, 0xA4, 0x7C, 0x39, 0x9F + }, + { + 0xA3, 0xDA, 0x8B, 0x41, 0xD3, 0x7A, 0x7F, 0x37, + 0xE9, 0x6A, 0x4A, 0x2D, 0x01, 0x41, 0x35, 0x6A, + 0xCE, 0xD3, 0x29, 0x0B, 0x09, 0x90, 0x9D, 0x43, + 0x03, 0x43, 0x57, 0x5D, 0x23, 0xDF, 0xB8, 0xFE, + 0xC2, 0x0B, 0x18, 0x59, 0xF2, 0x90, 0x94, 0xA1, + 0xBB, 0x40, 0x76, 0xCD, 0xA9, 0x92, 0xD5, 0x88, + 0x30, 0xFF, 0xD6, 0xC5, 0x21, 0x76, 0xFA, 0x29, + 0xDE, 0x8A, 0xDF, 0x02, 0x5B, 0x1F, 0x2F, 0xEE + }, + { + 0x26, 0xC9, 0x71, 0xF0, 0xA8, 0xAD, 0x8B, 0xA5, + 0xCB, 0x32, 0x70, 0x60, 0x8A, 0x46, 0x33, 0x09, + 0x36, 0x87, 0xC3, 0xEA, 0xAB, 0x6A, 0xEC, 0xE9, + 0x25, 0xBC, 0xAF, 0x3D, 0x80, 0xB5, 0x03, 0xF8, + 0x84, 0xA3, 0xDD, 0x03, 0xE5, 0x03, 0xF0, 0xC1, + 0x89, 0x1F, 0x41, 0x56, 0x00, 0xBA, 0xA4, 0x7A, + 0xCD, 0xEB, 0xF9, 0x80, 0xB2, 0xFF, 0x7D, 0xEC, + 0xAF, 0x14, 0x7B, 0x95, 0xD2, 0x13, 0x45, 0xB0 + }, + { + 0x17, 0x6F, 0xE3, 0xE5, 0x3B, 0x7C, 0xA9, 0xEF, + 0x1D, 0x68, 0xB3, 0xED, 0x1A, 0xD3, 0xA6, 0xC9, + 0x06, 0x63, 0x7C, 0x26, 0xA9, 0x9C, 0xBB, 0xF4, + 0x19, 0x53, 0x8A, 0xFE, 0x4E, 0xFC, 0x6E, 0xD0, + 0xAB, 0xBF, 0xDF, 0x11, 0xEB, 0x35, 0x0A, 0x15, + 0x11, 0xE9, 0x03, 0x3C, 0x00, 0x72, 0x8B, 0x79, + 0x39, 0xD1, 0xF8, 0x3F, 0x6C, 0x9E, 0x8D, 0x32, + 0x52, 0xBD, 0xDC, 0x60, 0xCB, 0x93, 0xD0, 0x6A + }, + { + 0x53, 0x9C, 0x12, 0x37, 0xB0, 0x81, 0x5A, 0x96, + 0xD1, 0x30, 0x6A, 0xED, 0x3C, 0xEE, 0x66, 0x12, + 0x25, 0x86, 0x91, 0x9F, 0x82, 0x8F, 0x44, 0x8E, + 0xB4, 0xA1, 0x15, 0xC9, 0x51, 0x23, 0x33, 0xB1, + 0x8B, 0x75, 0x44, 0xFC, 0x86, 0x91, 0xC3, 0x7A, + 0x09, 0xDC, 0x91, 0xA8, 0x95, 0x9E, 0x8C, 0xDC, + 0xC3, 0xCD, 0x13, 0x03, 0x3A, 0xAD, 0x18, 0x64, + 0x92, 0xD6, 0xFC, 0x8A, 0x9F, 0x0B, 0xEB, 0x92 + }, + { + 0x83, 0xDB, 0x43, 0xB8, 0x8D, 0x79, 0xCD, 0x6B, + 0x63, 0xE0, 0x3C, 0xAF, 0x73, 0x2F, 0xC5, 0xB3, + 0x69, 0x61, 0x8D, 0x0E, 0x6B, 0xA3, 0xFB, 0xEC, + 0x4A, 0x37, 0xAC, 0xB5, 0xFE, 0xE5, 0xFE, 0x8C, + 0x41, 0x8F, 0x58, 0xD1, 0x60, 0xBD, 0xFB, 0x9B, + 0xEB, 0x91, 0x9D, 0xC9, 0xE8, 0xF6, 0xF2, 0x31, + 0x6F, 0x82, 0xA1, 0x00, 0xA1, 0xC0, 0x35, 0x42, + 0x4A, 0x99, 0x7C, 0x56, 0x26, 0x6C, 0x79, 0x22 + }, + { + 0x2C, 0xA6, 0xC1, 0x63, 0xB1, 0x1D, 0x53, 0xCB, + 0xFB, 0x84, 0x48, 0x06, 0xF8, 0xB1, 0xA9, 0x95, + 0x3B, 0x30, 0x28, 0x31, 0x7F, 0x23, 0x5E, 0xA0, + 0x2C, 0xE5, 0x85, 0x04, 0xB0, 0xA2, 0x7A, 0x61, + 0x56, 0xFA, 0xE5, 0x65, 0x3B, 0xA6, 0x2C, 0x11, + 0xD9, 0x67, 0x00, 0x0F, 0xB9, 0x7C, 0xA8, 0x3A, + 0xD5, 0x4E, 0xF2, 0x58, 0xD2, 0x65, 0xB3, 0xCE, + 0x52, 0x21, 0xB6, 0xD8, 0x79, 0x86, 0xAD, 0xE8 + }, + { + 0xF0, 0x45, 0x6D, 0x9C, 0xA4, 0x40, 0xE8, 0xC1, + 0x22, 0x55, 0x91, 0x36, 0x0F, 0x27, 0x81, 0xA7, + 0x70, 0x6B, 0x24, 0xCE, 0xA8, 0xAD, 0x25, 0xF8, + 0x8B, 0x70, 0xC4, 0xBA, 0x6C, 0x8D, 0xF9, 0x81, + 0xBF, 0x55, 0xB7, 0x93, 0xCB, 0x88, 0x33, 0x3D, + 0xB2, 0x94, 0xAB, 0x3F, 0xD1, 0xDA, 0x7B, 0xCF, + 0x25, 0x45, 0x41, 0xEF, 0xC4, 0x73, 0x07, 0xB3, + 0x17, 0x4B, 0x26, 0x22, 0xBB, 0x23, 0xDC, 0xFF + }, + { + 0xA9, 0xFD, 0xBF, 0xFB, 0x57, 0x00, 0x67, 0xE9, + 0x64, 0xF0, 0xCB, 0x37, 0x72, 0xD8, 0xD5, 0x3C, + 0xA8, 0x80, 0xC7, 0xD0, 0x20, 0xE0, 0x3E, 0xB5, + 0x49, 0x2D, 0x8C, 0x83, 0x6C, 0x8C, 0x30, 0xD1, + 0x38, 0x00, 0x0F, 0x90, 0xEA, 0x48, 0x5E, 0x0F, + 0x10, 0x97, 0xF1, 0x14, 0x6E, 0x8F, 0x99, 0x09, + 0xF3, 0x8C, 0x72, 0xE6, 0xAA, 0xE9, 0x18, 0xC5, + 0x4C, 0xB9, 0xC3, 0x6C, 0xCB, 0xBF, 0xE1, 0x1C + }, + { + 0x18, 0xFF, 0xC6, 0xBF, 0xC6, 0xDE, 0x12, 0x39, + 0x55, 0x0A, 0x7C, 0x76, 0xDC, 0x87, 0xD1, 0x0C, + 0x7A, 0xB0, 0x3A, 0x2A, 0xF6, 0x59, 0x02, 0x7A, + 0xDB, 0x0B, 0x41, 0xFF, 0x65, 0xAC, 0x88, 0xB2, + 0xB1, 0xFF, 0x1D, 0xAE, 0xFE, 0x62, 0x59, 0x4E, + 0x74, 0x39, 0x2C, 0x1A, 0xAD, 0xC7, 0x99, 0x8B, + 0x55, 0x99, 0x74, 0x7E, 0xDB, 0x60, 0x03, 0x14, + 0x53, 0x2A, 0xF9, 0xE5, 0xE3, 0xB4, 0xB7, 0xD2 + }, + { + 0x0A, 0xFB, 0xF4, 0xDA, 0xA6, 0xE6, 0x10, 0x02, + 0x48, 0xDC, 0xCB, 0x24, 0xB4, 0x31, 0x1F, 0xA1, + 0x3F, 0xD7, 0x12, 0x46, 0x66, 0x93, 0x62, 0xDB, + 0xB5, 0x96, 0x29, 0x1F, 0x76, 0xA1, 0x4D, 0x30, + 0xFF, 0x99, 0xEC, 0x00, 0x25, 0xC0, 0x8B, 0x7C, + 0x16, 0xCC, 0xF8, 0x62, 0x0A, 0x70, 0xEF, 0xB8, + 0xF8, 0x8B, 0xA9, 0x63, 0xE7, 0x66, 0xD9, 0xBE, + 0x19, 0x75, 0x99, 0x27, 0x6D, 0xD6, 0xDB, 0x62 + }, + { + 0x73, 0x8B, 0x19, 0x18, 0x4D, 0x13, 0x0D, 0x7F, + 0x3A, 0x60, 0xDF, 0x82, 0xCD, 0xF5, 0x77, 0x88, + 0xC5, 0x8E, 0xA8, 0xBE, 0x56, 0x62, 0xA3, 0xB0, + 0xB6, 0x48, 0x77, 0x2A, 0x55, 0x55, 0x54, 0xCD, + 0x36, 0x1C, 0xE8, 0x26, 0xCE, 0xB2, 0x08, 0x57, + 0x4C, 0xAB, 0xBC, 0x39, 0x77, 0xBC, 0x50, 0x41, + 0xD0, 0x5F, 0x73, 0xB5, 0xF2, 0x98, 0x87, 0x67, + 0x00, 0x9E, 0xD7, 0xEF, 0x7E, 0x2A, 0xE3, 0x27 + }, + { + 0xF5, 0x0E, 0x89, 0x18, 0xD5, 0x5F, 0x5B, 0x0E, + 0x9D, 0x15, 0x24, 0xE5, 0x87, 0xA2, 0x4A, 0xBE, + 0x6A, 0xBB, 0x16, 0x26, 0xFC, 0x09, 0x94, 0x7D, + 0x2C, 0x3C, 0xA0, 0xCC, 0xE2, 0x0B, 0x65, 0xA8, + 0x91, 0x37, 0xA9, 0xBC, 0x4C, 0x07, 0x99, 0xF6, + 0xBE, 0x4A, 0x3D, 0x2A, 0x3B, 0x08, 0x4E, 0xBD, + 0x8A, 0xAB, 0x0F, 0x18, 0xCA, 0x7D, 0x1C, 0x95, + 0x94, 0xC5, 0x24, 0xA8, 0x40, 0x04, 0x32, 0x93 + }, + { + 0x80, 0x9E, 0x1E, 0xAC, 0xC5, 0x42, 0x75, 0xE2, + 0x51, 0x2D, 0x4B, 0x7E, 0x40, 0xF7, 0x16, 0x9A, + 0xEA, 0x4A, 0xDE, 0xF5, 0xE9, 0x46, 0xA7, 0xBB, + 0x06, 0x64, 0xA0, 0x40, 0xAE, 0xF6, 0x34, 0x8C, + 0x10, 0x00, 0xC2, 0x56, 0x24, 0x40, 0x9D, 0x42, + 0x3A, 0xD1, 0xAF, 0x20, 0x24, 0x14, 0x25, 0x42, + 0x6E, 0xD2, 0xAA, 0x3D, 0xEF, 0xD4, 0x99, 0x80, + 0x23, 0x76, 0xB5, 0xA3, 0x03, 0xE5, 0x43, 0xB9 + }, + { + 0x98, 0x34, 0x28, 0xF8, 0x39, 0x3A, 0x36, 0x34, + 0xB8, 0x0D, 0xEE, 0x2C, 0xB9, 0x9B, 0x50, 0xDC, + 0x5B, 0x93, 0xA3, 0xB9, 0x4C, 0xB4, 0xC9, 0x7C, + 0x2F, 0x80, 0xE4, 0x10, 0x16, 0x00, 0x08, 0x0D, + 0x98, 0x55, 0xFE, 0xC4, 0x08, 0xAB, 0xF2, 0x35, + 0x1E, 0x47, 0x6A, 0x19, 0xFC, 0x0E, 0x68, 0x4E, + 0x2A, 0x93, 0x84, 0xED, 0x69, 0xBB, 0x1A, 0x21, + 0x1A, 0xE4, 0x20, 0xB0, 0x97, 0x6F, 0xE4, 0xF8 + }, + { + 0x09, 0x61, 0x2C, 0x56, 0xAD, 0x01, 0x8D, 0x39, + 0xE0, 0x26, 0x33, 0xA1, 0x2D, 0x34, 0xAA, 0x80, + 0xB7, 0x1C, 0x5F, 0xFD, 0xA9, 0x1C, 0x61, 0xD4, + 0x4C, 0xCD, 0xAA, 0xEF, 0x17, 0xC8, 0xAA, 0xA1, + 0x94, 0x93, 0x81, 0x9E, 0x31, 0xDA, 0x27, 0x85, + 0x9B, 0x54, 0x8D, 0x2B, 0x47, 0xD3, 0x12, 0xB9, + 0xF6, 0x61, 0x43, 0x2F, 0x3D, 0x38, 0xBF, 0xDF, + 0x7C, 0x51, 0x89, 0x6C, 0x0A, 0x02, 0x1E, 0x03 + }, + { + 0xC6, 0xB4, 0x82, 0xFD, 0xE5, 0xDE, 0xD2, 0x08, + 0x1A, 0xE7, 0xAE, 0xB2, 0x1E, 0x65, 0x44, 0x48, + 0x4E, 0xA9, 0x11, 0x6D, 0x2D, 0x68, 0xBA, 0x11, + 0xB5, 0x50, 0xA5, 0x6B, 0xDA, 0x5D, 0x36, 0x8E, + 0x82, 0xFB, 0xEF, 0x7D, 0x04, 0xC3, 0x73, 0x9D, + 0x1C, 0x9F, 0x46, 0x63, 0x66, 0x57, 0x31, 0x5F, + 0x6C, 0x95, 0x02, 0x34, 0xFF, 0x77, 0xCD, 0xD2, + 0xA3, 0x3C, 0x8B, 0x7D, 0xFB, 0x36, 0xAE, 0x92 + }, + { + 0x1E, 0x13, 0xD5, 0x69, 0x2B, 0x4F, 0x1B, 0x38, + 0xE6, 0x46, 0x04, 0x26, 0x22, 0xA9, 0x43, 0x93, + 0xB4, 0xFC, 0xC9, 0xDC, 0x32, 0xED, 0x2D, 0xBA, + 0x13, 0xB6, 0x5C, 0x3B, 0x09, 0xEA, 0x45, 0x3C, + 0xEA, 0x11, 0xAE, 0x7C, 0x48, 0x0E, 0xEB, 0x16, + 0xEB, 0x57, 0x13, 0x43, 0xB9, 0xC7, 0x9A, 0xC3, + 0x4F, 0xDD, 0xA7, 0xED, 0x20, 0xF5, 0x44, 0x4F, + 0x72, 0xE7, 0x57, 0xC9, 0x6C, 0xD7, 0xA4, 0x55 + }, + { + 0x5A, 0xFC, 0xC9, 0xCE, 0x27, 0x59, 0xA0, 0xB1, + 0x33, 0x84, 0xDE, 0xEB, 0xE1, 0x4F, 0xC2, 0xFD, + 0x89, 0x19, 0xA9, 0xE8, 0x8A, 0x97, 0xED, 0xD5, + 0x35, 0x35, 0x1E, 0xFE, 0xCD, 0x44, 0x6B, 0x12, + 0xFB, 0x8B, 0xD7, 0x2A, 0x46, 0xEF, 0x5D, 0xF1, + 0x1A, 0x0A, 0x87, 0xA0, 0xA7, 0x4D, 0xB4, 0x57, + 0x9E, 0x13, 0xF8, 0x10, 0xE0, 0x07, 0x58, 0xEC, + 0x34, 0xB0, 0xCE, 0x7B, 0x72, 0x56, 0x87, 0x4E + }, + { + 0x04, 0xBB, 0x01, 0x88, 0x2C, 0x6B, 0xC1, 0xCD, + 0xA1, 0xF7, 0x00, 0x96, 0xF2, 0x25, 0xE8, 0x65, + 0x99, 0x00, 0x14, 0x33, 0x3C, 0xB0, 0x4D, 0x0C, + 0x44, 0xC5, 0x0E, 0xC3, 0x8E, 0xA6, 0xDF, 0xF3, + 0x0E, 0x98, 0xAA, 0x67, 0x8E, 0x5F, 0x85, 0x2F, + 0x90, 0x10, 0xC1, 0xB6, 0x26, 0xF9, 0x99, 0x1A, + 0x5C, 0xB5, 0x95, 0x79, 0xD8, 0xFC, 0x55, 0xA4, + 0x77, 0x41, 0x18, 0xAE, 0xF9, 0xD0, 0xF1, 0x71 + }, + { + 0xF8, 0xD0, 0xF2, 0xD9, 0x6D, 0x30, 0xA7, 0xF2, + 0x37, 0x42, 0x90, 0x82, 0x8F, 0x83, 0x54, 0x66, + 0xC3, 0x40, 0x34, 0x5A, 0x73, 0x9A, 0xC6, 0xE0, + 0x45, 0x07, 0xD3, 0x59, 0x57, 0x2F, 0x8F, 0x6E, + 0xB1, 0x76, 0x0C, 0xD7, 0x5C, 0x22, 0xBA, 0x3C, + 0xDB, 0xD8, 0x61, 0x62, 0xF7, 0xB8, 0xD9, 0xD1, + 0x77, 0x18, 0x93, 0x27, 0x88, 0xEA, 0xA8, 0x71, + 0x18, 0x57, 0xCD, 0x32, 0x44, 0x89, 0x85, 0x82 + }, + { + 0xBC, 0xA8, 0x5D, 0xDC, 0xF3, 0x92, 0x1E, 0x56, + 0xA9, 0xAD, 0xF2, 0xCC, 0xD6, 0x84, 0x09, 0x48, + 0x9F, 0x13, 0x31, 0x05, 0xC3, 0x2B, 0x2F, 0xF3, + 0x5A, 0x32, 0x7B, 0x61, 0xC3, 0x27, 0x22, 0xC5, + 0x78, 0x98, 0x70, 0x7D, 0x22, 0xD0, 0x36, 0xD3, + 0xDF, 0xD5, 0x31, 0x95, 0xFA, 0x8A, 0xB1, 0xC4, + 0x52, 0x7E, 0x12, 0xEA, 0x1B, 0x64, 0x6F, 0xF0, + 0xB5, 0x78, 0x35, 0xC6, 0xF6, 0x55, 0x0D, 0x3F + }, + { + 0x65, 0xEB, 0x44, 0x4F, 0x29, 0xD3, 0x4E, 0x6A, + 0x89, 0x79, 0xF7, 0xF4, 0xAC, 0xD2, 0xD7, 0xE1, + 0xB5, 0x63, 0xE8, 0x96, 0x4C, 0x25, 0x83, 0x89, + 0x0C, 0x03, 0xDD, 0xA6, 0x6A, 0x6E, 0xD6, 0x63, + 0x1F, 0xE8, 0xF2, 0xC4, 0x69, 0x20, 0x3C, 0xA9, + 0x36, 0xE8, 0x30, 0xDA, 0xB8, 0xFE, 0xB8, 0x6F, + 0xBD, 0xB7, 0xAB, 0x89, 0x61, 0x69, 0x61, 0x65, + 0x2D, 0xA1, 0x59, 0xBA, 0x7D, 0x6D, 0x32, 0x1D + }, + { + 0x60, 0xE4, 0xB2, 0xC8, 0x6D, 0x26, 0x5A, 0xD4, + 0xFF, 0x83, 0x0D, 0x07, 0x0B, 0xD7, 0x37, 0x34, + 0x9B, 0x40, 0x97, 0x23, 0xB9, 0x25, 0x3A, 0x73, + 0xD7, 0xC8, 0x0B, 0x7E, 0x40, 0xDA, 0x49, 0xD5, + 0x40, 0x0A, 0x3F, 0xE7, 0xB1, 0xDD, 0x99, 0x28, + 0xA3, 0xF7, 0x3B, 0x2E, 0xC8, 0x12, 0x9F, 0xAA, + 0xE9, 0xBE, 0x98, 0x88, 0x31, 0x15, 0xA3, 0xF9, + 0x84, 0xBC, 0xC1, 0x29, 0xDA, 0x56, 0xF8, 0x9C + }, + { + 0x07, 0x32, 0x3B, 0x5F, 0xBC, 0xF7, 0x7A, 0x99, + 0xC3, 0x18, 0xE9, 0xFD, 0x74, 0x79, 0xED, 0x9C, + 0x3D, 0x7D, 0x74, 0x9A, 0x9D, 0x70, 0x8A, 0x04, + 0x69, 0xC5, 0xBC, 0x8E, 0x0B, 0x5D, 0x77, 0x75, + 0x16, 0x38, 0xA0, 0xD6, 0x60, 0x09, 0xCA, 0xA8, + 0x96, 0xDE, 0xAA, 0xA9, 0x4A, 0x30, 0x69, 0x31, + 0x98, 0x11, 0x88, 0xA2, 0xB0, 0xA1, 0x2A, 0xEF, + 0xD8, 0xF0, 0xD3, 0xD3, 0x77, 0xCE, 0x6E, 0xED + }, + { + 0x3D, 0x6B, 0x2C, 0xEF, 0x77, 0xEA, 0x4B, 0xE8, + 0xA3, 0x00, 0x19, 0x98, 0xF5, 0x2B, 0xD0, 0x00, + 0x0C, 0xE2, 0x69, 0xDA, 0x37, 0x3D, 0x93, 0xD0, + 0x1C, 0x3C, 0x76, 0x98, 0x7B, 0x8A, 0x77, 0x6D, + 0xE6, 0x1E, 0xE4, 0xF4, 0x29, 0xA5, 0x81, 0xCF, + 0x0A, 0x9D, 0x1E, 0x70, 0xE5, 0x8F, 0x0F, 0xD4, + 0x4A, 0x0F, 0xB5, 0x4A, 0xC4, 0x8D, 0xFA, 0x39, + 0xB8, 0xEC, 0xF5, 0x2A, 0x7B, 0x6F, 0x06, 0xB7 + }, + { + 0x3E, 0x68, 0xB7, 0xD9, 0xB5, 0xB9, 0x91, 0x5C, + 0x92, 0x4E, 0xAB, 0x2B, 0x22, 0xDA, 0xBF, 0x09, + 0x50, 0xC0, 0x3F, 0xA5, 0x92, 0x2D, 0x87, 0x56, + 0xFA, 0x1E, 0x0A, 0x0A, 0xCE, 0xA8, 0xEF, 0x13, + 0x33, 0x4B, 0x8A, 0xD2, 0xA5, 0x95, 0x82, 0x08, + 0x7B, 0xC8, 0x5F, 0xD1, 0x1B, 0xC7, 0xF6, 0x3E, + 0x6B, 0xFC, 0xE5, 0x01, 0x26, 0x8F, 0xB1, 0x09, + 0xF6, 0xF2, 0x7F, 0xB9, 0x20, 0x12, 0xFA, 0xE4 + }, + { + 0xDE, 0x11, 0x9A, 0xF6, 0xD3, 0x8E, 0xFD, 0xE7, + 0xF7, 0x41, 0xF7, 0xDA, 0x1E, 0x18, 0xF2, 0x16, + 0x29, 0xB1, 0x06, 0x7F, 0x99, 0xA0, 0x16, 0x21, + 0xE5, 0x92, 0x72, 0x74, 0xC9, 0x27, 0x68, 0x2F, + 0x6B, 0xDF, 0x9D, 0x1A, 0xE7, 0x65, 0xA4, 0xB1, + 0x62, 0xD6, 0x10, 0xE5, 0x60, 0x53, 0x4D, 0x4A, + 0x7A, 0xA1, 0x83, 0xF8, 0xBE, 0x68, 0xA6, 0xCE, + 0x6A, 0xFF, 0xFF, 0x35, 0x88, 0xF2, 0x89, 0x59 + }, + { + 0x2C, 0x15, 0x93, 0x94, 0x87, 0xE7, 0xA4, 0xC0, + 0x1B, 0x40, 0xAD, 0x09, 0xB6, 0x03, 0xFA, 0xDB, + 0x6D, 0x83, 0x38, 0xE7, 0xDC, 0x40, 0xFB, 0xD3, + 0x33, 0xA0, 0x29, 0xA7, 0x2A, 0x77, 0x5C, 0x7B, + 0xA6, 0x54, 0xDD, 0x9E, 0x17, 0xA8, 0x2B, 0x17, + 0x11, 0xB9, 0x87, 0x83, 0x19, 0xB8, 0xDD, 0x03, + 0xAA, 0x39, 0xEA, 0xBF, 0xF5, 0x5A, 0x0D, 0x85, + 0xB6, 0x57, 0x2A, 0x93, 0x1F, 0xA8, 0x8A, 0x17 + }, + { + 0x12, 0x19, 0x18, 0x39, 0x98, 0x0A, 0xCC, 0x68, + 0x09, 0x2F, 0xA0, 0x6A, 0xE6, 0xC9, 0xC3, 0x5C, + 0xDE, 0x6F, 0x01, 0xB2, 0xFE, 0x5B, 0x3B, 0x7F, + 0x98, 0x98, 0x5D, 0xD5, 0x0D, 0x7A, 0xA0, 0x2A, + 0xC8, 0x72, 0x7C, 0xFF, 0x2D, 0x16, 0x99, 0xF5, + 0xF2, 0xF3, 0x46, 0x18, 0x2C, 0x80, 0xEE, 0x77, + 0xEE, 0x72, 0x02, 0xDC, 0x6E, 0xDC, 0x59, 0x29, + 0x22, 0x5E, 0x36, 0xE5, 0xAD, 0x01, 0xB1, 0x31 + }, + { + 0xB2, 0x2A, 0x42, 0xFA, 0xC1, 0x76, 0x36, 0x04, + 0x60, 0x0F, 0x65, 0x42, 0x24, 0x1B, 0x33, 0xB4, + 0xFE, 0xE9, 0x33, 0x1B, 0xDD, 0xC2, 0x3D, 0xC8, + 0x6A, 0xF2, 0xF2, 0x92, 0x54, 0x0A, 0xF9, 0x78, + 0xBC, 0x40, 0x86, 0x1A, 0x9B, 0x12, 0xF9, 0x8F, + 0xEB, 0x27, 0x99, 0x6E, 0x0D, 0x9F, 0xE1, 0x73, + 0x9D, 0x29, 0x85, 0x93, 0x8B, 0xBA, 0xAC, 0x49, + 0x93, 0x2D, 0x2B, 0x84, 0xF5, 0xDC, 0xA8, 0xB9 + }, + { + 0x09, 0xC9, 0xA4, 0x12, 0xB0, 0xFB, 0xBA, 0x20, + 0xAB, 0x1C, 0x78, 0xDB, 0x0F, 0x79, 0x5F, 0x06, + 0xB8, 0x64, 0x87, 0x50, 0x81, 0x77, 0x78, 0x40, + 0x31, 0xC2, 0x25, 0xEF, 0x82, 0x0A, 0xF2, 0x7E, + 0xE5, 0x22, 0x09, 0xB4, 0x9A, 0x7C, 0xB8, 0xF5, + 0x93, 0x51, 0xDA, 0x63, 0xE0, 0xCF, 0xDB, 0xCC, + 0x09, 0xFF, 0x28, 0x3B, 0xAB, 0x87, 0xEA, 0x20, + 0xB0, 0x4B, 0x08, 0xBD, 0x98, 0x0E, 0x1E, 0xEA + }, + { + 0xB8, 0x25, 0x6D, 0x7C, 0xEC, 0x8A, 0xF7, 0xAA, + 0x0D, 0xEB, 0xBF, 0x0E, 0x06, 0x52, 0xFC, 0x04, + 0xDB, 0x99, 0x9D, 0x1E, 0x8C, 0x9B, 0x4F, 0x95, + 0x89, 0x0C, 0x25, 0xE0, 0x60, 0x09, 0x5B, 0xA2, + 0x21, 0xE7, 0x65, 0x34, 0x9F, 0x14, 0x52, 0xAF, + 0x67, 0xFC, 0x58, 0xE0, 0xD2, 0x46, 0xAB, 0xE9, + 0xF7, 0x95, 0xF0, 0xBB, 0x1C, 0x7B, 0x9F, 0x29, + 0x52, 0x85, 0x7A, 0xF4, 0xE2, 0xFA, 0x71, 0xF8 + }, + { + 0xCC, 0xB6, 0x42, 0x38, 0xE4, 0xC8, 0x28, 0x9C, + 0xFF, 0xE5, 0xC2, 0x99, 0x66, 0x88, 0x1A, 0x52, + 0x43, 0x37, 0x87, 0x54, 0x15, 0x5F, 0x0C, 0xA0, + 0xE2, 0xDC, 0xFE, 0xD8, 0xAF, 0xDF, 0xCF, 0x14, + 0x5F, 0x19, 0xF1, 0xAC, 0x00, 0xD7, 0x0E, 0x2F, + 0xCD, 0x0D, 0x0B, 0xAC, 0x93, 0x6C, 0xB2, 0x52, + 0x45, 0xE9, 0x8F, 0x43, 0xA5, 0x7F, 0xEC, 0x76, + 0x66, 0x78, 0xB0, 0x87, 0x16, 0xC3, 0xC2, 0xE1 + }, + { + 0x94, 0xC9, 0x1E, 0xC1, 0x5E, 0xB7, 0x6A, 0xAC, + 0x5A, 0x9A, 0x04, 0x29, 0xD7, 0x3E, 0x43, 0xE5, + 0xE5, 0x67, 0x15, 0x9F, 0xAB, 0xE2, 0xE8, 0xC7, + 0xE5, 0x30, 0x9B, 0xFB, 0x25, 0xD4, 0xF8, 0x0E, + 0x1F, 0x48, 0x41, 0xC3, 0x84, 0x01, 0xA3, 0x52, + 0xF3, 0x07, 0x5C, 0x4A, 0x55, 0x1C, 0x54, 0xB4, + 0x5F, 0xC0, 0xAA, 0x17, 0x19, 0xF7, 0xF5, 0xEF, + 0x13, 0x66, 0x19, 0xD6, 0x76, 0xEA, 0x71, 0x5D + }, + { + 0xF0, 0x5F, 0x59, 0xD0, 0x87, 0x18, 0x58, 0x84, + 0xAB, 0x8C, 0x26, 0xA5, 0xB9, 0xDB, 0xFA, 0x07, + 0x7E, 0xC7, 0x91, 0xA4, 0x75, 0x97, 0xF1, 0xD9, + 0x38, 0x1A, 0x9F, 0x38, 0x27, 0xD9, 0xFD, 0x63, + 0x26, 0x5A, 0x0A, 0x27, 0xEF, 0x1F, 0x28, 0x3E, + 0x15, 0xAC, 0x55, 0x5C, 0x79, 0xCA, 0x94, 0xFE, + 0x8D, 0x6B, 0xD0, 0xCE, 0x66, 0x70, 0xB9, 0xA8, + 0x0B, 0x9A, 0x3A, 0xC6, 0x06, 0xD7, 0x36, 0x8B + }, + { + 0x28, 0xD7, 0xF2, 0xFE, 0x27, 0x4F, 0xE4, 0x08, + 0x33, 0x51, 0x16, 0xB9, 0xA9, 0xB3, 0xB4, 0xAC, + 0xFC, 0xB9, 0x07, 0x04, 0x6A, 0x3C, 0x5F, 0xB2, + 0xE1, 0x2F, 0xCC, 0x1A, 0xD2, 0x8B, 0x35, 0x38, + 0x4A, 0x84, 0x0F, 0x2D, 0xDE, 0x37, 0xB2, 0x60, + 0x75, 0x6F, 0x5E, 0x2E, 0x1A, 0xAB, 0xDB, 0xAC, + 0xBB, 0x27, 0x55, 0xB9, 0x7A, 0xAB, 0x86, 0x5B, + 0x6F, 0x29, 0x73, 0xA5, 0xD2, 0x88, 0x5A, 0x41 + }, + { + 0x51, 0xA9, 0x20, 0x99, 0x59, 0xB7, 0x6F, 0x82, + 0x3B, 0xE6, 0xFE, 0x4C, 0xD5, 0xBE, 0xD9, 0x24, + 0xBB, 0x24, 0xE7, 0x07, 0x37, 0x69, 0x6B, 0xE5, + 0x98, 0xEC, 0xE8, 0xA3, 0xDB, 0x71, 0x5E, 0x23, + 0x54, 0x02, 0xE0, 0x89, 0xA3, 0x4A, 0x07, 0x1B, + 0xBB, 0x8A, 0xD1, 0x0E, 0x9B, 0x4C, 0xD6, 0xE9, + 0xCB, 0x86, 0x0B, 0xE6, 0xEC, 0x23, 0x3C, 0xF4, + 0x56, 0x87, 0x84, 0xA5, 0x4D, 0x7F, 0x75, 0xF0 + }, + { + 0x7D, 0x31, 0x45, 0x86, 0x43, 0xCC, 0x74, 0x88, + 0x52, 0xF2, 0x72, 0x8C, 0xC2, 0xE9, 0x14, 0x3F, + 0xBA, 0xF7, 0xD4, 0x39, 0xB7, 0xEF, 0x6F, 0x39, + 0xFA, 0xE2, 0xEC, 0x92, 0x22, 0x03, 0xC8, 0xD7, + 0xE5, 0x53, 0xD0, 0xC9, 0x28, 0xFA, 0x79, 0xF1, + 0x85, 0x07, 0x5F, 0x72, 0xEF, 0x57, 0x8D, 0x00, + 0x86, 0xA9, 0x77, 0xE0, 0xF5, 0xEE, 0x87, 0x33, + 0xB4, 0xCA, 0x3C, 0x86, 0x8E, 0xEC, 0x66, 0x29 + }, + { + 0xD1, 0x38, 0x02, 0x7A, 0xD0, 0xCA, 0x9E, 0x49, + 0x5B, 0x28, 0xCA, 0x56, 0x25, 0x08, 0x79, 0x2A, + 0xDB, 0xC8, 0x6C, 0x08, 0x54, 0xE5, 0x26, 0xBB, + 0x36, 0x73, 0x69, 0x8F, 0xE4, 0xB5, 0x53, 0xAB, + 0x8A, 0x30, 0x73, 0x06, 0x87, 0x53, 0x76, 0xCE, + 0xE4, 0xCA, 0x61, 0x02, 0xCA, 0xA8, 0xFC, 0x54, + 0xC4, 0x48, 0x06, 0xF0, 0x24, 0x9A, 0x2E, 0xCE, + 0x8B, 0x85, 0xB1, 0x81, 0xF3, 0x35, 0x8C, 0x8F + }, + { + 0xCF, 0x0D, 0xBB, 0x54, 0x37, 0xA3, 0xCC, 0xE2, + 0x4B, 0x45, 0x6F, 0x6E, 0x9D, 0x63, 0x2E, 0xFF, + 0xA3, 0x04, 0xA3, 0xC5, 0xC6, 0x0B, 0xDE, 0x76, + 0x7E, 0xCD, 0xF4, 0x77, 0xE5, 0x7F, 0xFE, 0x5F, + 0x3D, 0x59, 0x8F, 0xE2, 0x8D, 0x80, 0xC0, 0x71, + 0x7D, 0xA9, 0xA6, 0x00, 0xA4, 0x58, 0x41, 0x2E, + 0xC6, 0x91, 0x08, 0xBB, 0xF1, 0x59, 0x70, 0x95, + 0x91, 0x50, 0xA2, 0x0A, 0x71, 0xF1, 0xFA, 0x6B + }, + { + 0x8B, 0x30, 0x8E, 0xEC, 0x06, 0xF1, 0xE6, 0x2B, + 0x63, 0x3E, 0xAE, 0x5A, 0x80, 0x0D, 0xE2, 0x94, + 0x1D, 0x7F, 0x59, 0xF6, 0x1B, 0x47, 0x6B, 0xEB, + 0xB1, 0x2C, 0x64, 0x4E, 0xA8, 0xD6, 0x85, 0x51, + 0xA0, 0xD5, 0xC2, 0x89, 0x55, 0x48, 0x87, 0x8E, + 0x1F, 0x1A, 0xF1, 0xF0, 0xB6, 0x1B, 0x58, 0x48, + 0xA3, 0x3F, 0x31, 0x8D, 0x47, 0x5F, 0xE5, 0x32, + 0xBD, 0xB7, 0x40, 0x26, 0xB1, 0xE4, 0xDC, 0xAF + }, + { + 0x56, 0x9C, 0x30, 0x10, 0x80, 0xDA, 0x76, 0x7A, + 0x73, 0xF1, 0x95, 0x7A, 0xE5, 0x6A, 0xEF, 0xC9, + 0x0B, 0x10, 0x9D, 0x58, 0x81, 0x5A, 0x68, 0x98, + 0x94, 0x74, 0x74, 0xC5, 0xCC, 0x27, 0x6F, 0x49, + 0xDE, 0xD3, 0x2E, 0xF5, 0x17, 0xFE, 0x4D, 0xF6, + 0xE3, 0x55, 0x75, 0x51, 0x41, 0xE7, 0x09, 0xA4, + 0x9B, 0x36, 0x25, 0x3D, 0x6D, 0xE9, 0x60, 0xB6, + 0x38, 0xF8, 0x90, 0x45, 0x1F, 0xAD, 0x96, 0xF6 + }, + { + 0x1C, 0x1F, 0x85, 0x36, 0x78, 0xC8, 0x44, 0x4E, + 0xA4, 0x92, 0x50, 0x94, 0x06, 0x12, 0x4B, 0x86, + 0x7C, 0x1C, 0x23, 0x91, 0x2A, 0x17, 0x99, 0xED, + 0x89, 0x99, 0x7B, 0x88, 0xF2, 0xB9, 0x92, 0x15, + 0x17, 0xAD, 0xC0, 0x9A, 0x12, 0xC2, 0x37, 0x4C, + 0xE6, 0x9D, 0x33, 0x67, 0x5F, 0x74, 0x58, 0xE4, + 0xAC, 0xCD, 0xCF, 0x70, 0xEB, 0x20, 0xF1, 0x67, + 0xAC, 0xD0, 0xD9, 0x73, 0x0D, 0x51, 0x31, 0x65 + }, + { + 0x15, 0x1E, 0x9F, 0x1C, 0x73, 0x6C, 0x77, 0x58, + 0x9E, 0x14, 0xDB, 0x76, 0x62, 0x5B, 0xE6, 0x37, + 0xDC, 0x71, 0x7C, 0x44, 0x94, 0xBA, 0x99, 0x5A, + 0x7C, 0xC9, 0xC0, 0x11, 0xE9, 0x95, 0xCD, 0x50, + 0x32, 0x04, 0x19, 0x5A, 0x64, 0x4B, 0x88, 0x5F, + 0x1E, 0xEE, 0x6D, 0xAF, 0xE2, 0x7C, 0xFF, 0x1E, + 0x6C, 0x8F, 0xAA, 0x17, 0x96, 0x8A, 0xDA, 0xCD, + 0x4A, 0xA2, 0x24, 0x2C, 0xA8, 0xB4, 0x36, 0xAF + }, + { + 0x04, 0x69, 0xC2, 0x31, 0xDE, 0xDE, 0x9D, 0x0C, + 0x60, 0x71, 0x38, 0x59, 0xF5, 0x5B, 0x77, 0x4E, + 0x59, 0x59, 0x02, 0x45, 0xD1, 0xA7, 0x66, 0xE4, + 0xEA, 0x58, 0x70, 0x24, 0x1A, 0xD1, 0x37, 0xAD, + 0xA1, 0xC9, 0x93, 0xC7, 0xA6, 0xF2, 0xBA, 0x6C, + 0xBB, 0xBF, 0x50, 0x78, 0xF5, 0xB6, 0xEF, 0x05, + 0xE6, 0x37, 0xD6, 0xDA, 0x18, 0x81, 0xCA, 0xA3, + 0x87, 0x7C, 0x7C, 0x5F, 0x10, 0x22, 0x94, 0x22 + }, + { + 0xD5, 0xD1, 0xB2, 0x55, 0x99, 0x38, 0xBD, 0x2E, + 0xE7, 0x38, 0x6E, 0x6F, 0xBC, 0x9B, 0xBA, 0xFA, + 0xB9, 0xC0, 0x8C, 0x46, 0x57, 0x6B, 0x35, 0x5C, + 0x82, 0xE0, 0xF8, 0x20, 0x8D, 0x04, 0x46, 0xB8, + 0x6C, 0x34, 0x97, 0x21, 0xC1, 0x3B, 0x38, 0xBD, + 0x93, 0x09, 0xB7, 0x62, 0xE2, 0xB1, 0x7C, 0xC1, + 0x0A, 0x4E, 0xCD, 0xA3, 0x01, 0x3F, 0xDF, 0x1E, + 0x5B, 0x09, 0x8F, 0xAD, 0xB5, 0xE0, 0xD5, 0x28 + }, + { + 0xDB, 0x16, 0xAC, 0x70, 0x3D, 0x01, 0x48, 0xB8, + 0xD3, 0xE2, 0xF4, 0x59, 0x45, 0x85, 0xAB, 0xE8, + 0xA6, 0x28, 0xC8, 0xEC, 0xB3, 0xD3, 0x2F, 0x24, + 0xA8, 0xA8, 0x78, 0x6C, 0x6A, 0x97, 0x93, 0xB8, + 0x8E, 0xD8, 0x56, 0x66, 0xE3, 0xAA, 0xF9, 0x4D, + 0x08, 0xA3, 0x07, 0x04, 0xF5, 0x42, 0x67, 0xD8, + 0xAD, 0x8D, 0x24, 0xEB, 0x4E, 0x08, 0xA5, 0x89, + 0xC1, 0xBB, 0x6A, 0xD2, 0x91, 0x1A, 0xAD, 0xFC + }, + { + 0x57, 0xB7, 0x5A, 0x1B, 0x38, 0xDD, 0xF8, 0x38, + 0x56, 0xB8, 0x75, 0xBE, 0x80, 0xE8, 0x9C, 0xBC, + 0x23, 0x4A, 0xB6, 0xD1, 0x5F, 0xEE, 0xEE, 0xC3, + 0x06, 0x09, 0x19, 0x91, 0x25, 0x83, 0x91, 0x5B, + 0x52, 0x92, 0x88, 0x45, 0x8B, 0x65, 0x96, 0xA4, + 0x51, 0xE8, 0xC8, 0x6D, 0x7C, 0xE1, 0x89, 0x7F, + 0x66, 0x56, 0x03, 0x05, 0x24, 0x55, 0xB1, 0x6C, + 0xAD, 0xB5, 0x5B, 0xDA, 0xB5, 0x67, 0x54, 0x83 + }, + { + 0xFE, 0x44, 0x2B, 0x8B, 0x2A, 0xA4, 0x33, 0x24, + 0x9A, 0xB4, 0x1B, 0x35, 0x79, 0x84, 0xE0, 0x48, + 0x2D, 0xED, 0x06, 0x6E, 0xB9, 0xD0, 0x6E, 0x05, + 0x63, 0x25, 0xB5, 0xBA, 0x3F, 0xE9, 0xD8, 0xF4, + 0x2F, 0x4C, 0xFA, 0x60, 0x90, 0x33, 0x75, 0xAD, + 0x78, 0x78, 0x10, 0x11, 0x7D, 0xA0, 0x38, 0xBD, + 0xB4, 0x8D, 0x11, 0x27, 0x3A, 0x5A, 0xC9, 0x5B, + 0xBB, 0x05, 0xEC, 0xB1, 0xF5, 0x49, 0x0F, 0x09 + }, + { + 0x02, 0x0A, 0x28, 0xAC, 0xCA, 0xA0, 0x8E, 0x0C, + 0x51, 0x01, 0xB9, 0x3D, 0x35, 0xF7, 0x94, 0x8D, + 0x36, 0x3D, 0x0A, 0x0D, 0xDE, 0xFA, 0x5E, 0x5F, + 0xDF, 0xEB, 0x1B, 0x22, 0x22, 0xF7, 0xA3, 0xDB, + 0x7F, 0x98, 0x03, 0x90, 0x06, 0xD6, 0x58, 0x91, + 0xD9, 0x99, 0x68, 0x91, 0x6E, 0x92, 0x3A, 0x65, + 0xFB, 0xA1, 0xD3, 0xF2, 0xF0, 0x6E, 0xA8, 0x22, + 0x48, 0xE4, 0x7E, 0xF4, 0x56, 0x4A, 0xC6, 0x84 + }, + { + 0xAA, 0x94, 0xFB, 0x68, 0x5D, 0x54, 0xF4, 0xEA, + 0x06, 0x44, 0xBC, 0xAF, 0x90, 0xDF, 0xCA, 0x05, + 0x1A, 0xD4, 0xC6, 0x2C, 0x3A, 0xB2, 0x37, 0xBB, + 0x7E, 0x44, 0xC6, 0x09, 0x3F, 0xAA, 0x4B, 0x2F, + 0xA8, 0x9D, 0xF7, 0xC3, 0xE2, 0x4A, 0x1A, 0xC4, + 0xA0, 0x55, 0xD8, 0x8B, 0xDD, 0x42, 0x77, 0x6C, + 0x1A, 0xC1, 0xC6, 0x56, 0x29, 0x94, 0x26, 0x67, + 0x6C, 0x72, 0xD9, 0xFF, 0x6C, 0x97, 0x51, 0x50 + }, + { + 0x1A, 0x10, 0x00, 0x87, 0xA5, 0x3F, 0x3A, 0xDB, + 0x21, 0x4D, 0xE0, 0x75, 0x5F, 0x00, 0x91, 0x54, + 0x81, 0xE5, 0x1F, 0x45, 0x8A, 0x74, 0x55, 0xD6, + 0x73, 0x93, 0x56, 0xB3, 0x5C, 0x3B, 0xA7, 0x41, + 0x34, 0x51, 0x07, 0xC8, 0x90, 0x29, 0x19, 0x8E, + 0x4E, 0x9A, 0x44, 0xCF, 0x18, 0xE4, 0xFD, 0xC9, + 0x10, 0xCF, 0xCF, 0xA4, 0x28, 0x1F, 0xD8, 0x63, + 0x89, 0xB4, 0x4B, 0x48, 0xE0, 0x29, 0x72, 0x0B + }, + { + 0x1A, 0x32, 0x8C, 0x93, 0x72, 0xDD, 0x86, 0x75, + 0xE1, 0x7D, 0x1C, 0x87, 0x8F, 0x86, 0x01, 0xFF, + 0xE3, 0xA8, 0xF8, 0x46, 0xFE, 0x8E, 0x76, 0x42, + 0xEB, 0xB6, 0xB9, 0x78, 0x93, 0x58, 0x0B, 0x94, + 0xC6, 0xBC, 0xFD, 0xF8, 0x40, 0x25, 0x53, 0x06, + 0xEF, 0x35, 0xD9, 0xC5, 0x3B, 0xD5, 0xC8, 0x3F, + 0x1E, 0x9E, 0x6A, 0x30, 0x90, 0xCD, 0x66, 0x29, + 0x5A, 0x02, 0x39, 0xA5, 0xA4, 0x47, 0xDC, 0x32 + }, + { + 0xF9, 0x48, 0x75, 0x88, 0x7B, 0x05, 0xDC, 0xC8, + 0xEF, 0x44, 0x8D, 0xF1, 0x80, 0xF0, 0x42, 0xF5, + 0x2D, 0x8C, 0x3C, 0x30, 0xCB, 0xDB, 0x6D, 0x38, + 0xE8, 0x66, 0xEB, 0x69, 0x19, 0xD1, 0x41, 0x6B, + 0x8D, 0x28, 0x60, 0x2C, 0x3D, 0xE4, 0xE6, 0x82, + 0x2E, 0x01, 0x9B, 0xB0, 0xCB, 0xB3, 0xB2, 0x00, + 0xCE, 0xED, 0xCF, 0x3C, 0x63, 0x9A, 0x6D, 0x65, + 0x9F, 0xE9, 0xDE, 0xBC, 0x7F, 0x30, 0xEB, 0xB8 + }, + { + 0x48, 0x85, 0x9B, 0xFA, 0x23, 0x98, 0xA1, 0xAC, + 0x91, 0x41, 0x6D, 0x9A, 0x86, 0x0E, 0xCE, 0x0C, + 0xD7, 0xB8, 0xF1, 0xED, 0x1A, 0x91, 0x00, 0x27, + 0x89, 0xA7, 0x7E, 0x38, 0xB7, 0x85, 0x84, 0xB8, + 0x51, 0xA9, 0x1F, 0x60, 0x1C, 0x84, 0x3A, 0xA1, + 0x02, 0xDF, 0xC1, 0xAD, 0x46, 0x8A, 0xFB, 0xD7, + 0x3F, 0xBF, 0x91, 0x05, 0xF1, 0x65, 0xCC, 0xE9, + 0x68, 0x1E, 0x24, 0x6F, 0x7E, 0xA8, 0x0E, 0x5E + }, + { + 0x2E, 0xC0, 0x62, 0x50, 0xFB, 0x46, 0xD7, 0xAC, + 0x34, 0x96, 0x20, 0x29, 0xF3, 0x7E, 0xBD, 0x33, + 0x03, 0x3C, 0x74, 0x2E, 0x1B, 0x2C, 0xC5, 0x4B, + 0xDC, 0x4C, 0x97, 0x13, 0xA4, 0x1C, 0x5D, 0xD2, + 0x33, 0x9F, 0x8C, 0xEF, 0xC0, 0x87, 0xEE, 0x22, + 0x33, 0xD6, 0xC1, 0x97, 0x83, 0x2D, 0x28, 0xDA, + 0xC6, 0x6A, 0xEC, 0x73, 0x5F, 0x37, 0x7F, 0xAA, + 0x9F, 0x4B, 0xD3, 0x0E, 0x92, 0xC7, 0x51, 0x63 + }, + { + 0x37, 0xB9, 0x0C, 0xEC, 0xCF, 0x00, 0x3A, 0x88, + 0x6B, 0x04, 0xDD, 0x1F, 0xA7, 0x68, 0x85, 0x82, + 0xF2, 0x62, 0x92, 0xA0, 0x6D, 0xD3, 0x1C, 0x8A, + 0xEC, 0xF6, 0x4F, 0xBB, 0xB3, 0x07, 0x23, 0xFB, + 0x68, 0x66, 0x50, 0x81, 0x74, 0x3A, 0x5F, 0x79, + 0x3D, 0x56, 0x17, 0xBE, 0x14, 0x28, 0x69, 0xA0, + 0xB5, 0x1C, 0x51, 0xC8, 0x84, 0xD6, 0x37, 0x6B, + 0x10, 0xF9, 0x19, 0x7B, 0x3D, 0xAB, 0xEA, 0xCC + }, + { + 0x9A, 0xE4, 0x5E, 0x39, 0x36, 0x85, 0x7E, 0xFD, + 0x26, 0xB7, 0x5A, 0x8C, 0x54, 0x84, 0x34, 0x12, + 0xAC, 0x15, 0x1B, 0x30, 0x3B, 0xDC, 0x24, 0x4D, + 0x2B, 0x0D, 0x2C, 0xA3, 0x70, 0x54, 0xB6, 0x87, + 0x31, 0x7E, 0x52, 0x14, 0x6F, 0x05, 0xB2, 0x0E, + 0x71, 0xFD, 0x62, 0x9B, 0x4E, 0x19, 0x66, 0xBD, + 0xC1, 0xEE, 0xA3, 0x9F, 0xF9, 0x64, 0x9B, 0x8E, + 0xFA, 0x40, 0x88, 0xD5, 0xDD, 0x25, 0xF0, 0x43 + }, + { + 0xFA, 0x14, 0x5D, 0xAE, 0xB2, 0x0F, 0x39, 0x4E, + 0x8D, 0xB8, 0x85, 0x01, 0xC0, 0x67, 0xB4, 0xD7, + 0xD2, 0xEE, 0x12, 0x29, 0x85, 0x45, 0xEA, 0xBB, + 0xF0, 0x63, 0x20, 0x21, 0x44, 0x39, 0x0E, 0x35, + 0x76, 0xC7, 0xC1, 0xC1, 0x7D, 0x78, 0x05, 0x3C, + 0xAE, 0xBC, 0x81, 0xCE, 0x49, 0xE6, 0x3A, 0x00, + 0x50, 0xDD, 0xA9, 0xC6, 0x23, 0x15, 0xA4, 0x7B, + 0xD1, 0xEF, 0x15, 0x69, 0xCD, 0xA4, 0x07, 0xC5 + }, + { + 0x1F, 0xDD, 0xC4, 0xA6, 0x8B, 0xFB, 0x61, 0xBD, + 0xAD, 0xC5, 0x5C, 0x23, 0xF9, 0xA1, 0x85, 0x8E, + 0xA0, 0x4D, 0xD3, 0x07, 0x75, 0xD3, 0x5F, 0xDB, + 0x9F, 0x8C, 0x7A, 0x5D, 0x1A, 0x06, 0x08, 0xB9, + 0xAE, 0x57, 0x75, 0xD1, 0xAF, 0x2D, 0xCC, 0x23, + 0xD5, 0xAB, 0x55, 0xA0, 0x99, 0x41, 0x1F, 0xDA, + 0xBA, 0x20, 0x2E, 0xD4, 0xBE, 0x74, 0x74, 0x34, + 0x1D, 0x92, 0x35, 0xE7, 0xA9, 0x43, 0x21, 0xD6 + }, + { + 0x4D, 0xF7, 0xA0, 0x1F, 0x3C, 0x04, 0xDE, 0x5B, + 0x92, 0xFF, 0x30, 0x77, 0x6F, 0xC9, 0x10, 0x29, + 0x12, 0xD3, 0x8F, 0x31, 0xD2, 0xC8, 0x72, 0x2A, + 0x65, 0xAB, 0xF7, 0x6B, 0x4F, 0x35, 0x0E, 0x8E, + 0xA5, 0x24, 0x57, 0x08, 0xF7, 0xC3, 0x68, 0xDF, + 0x8A, 0x3E, 0xFB, 0x6E, 0xFB, 0xAD, 0x77, 0xCD, + 0x82, 0x57, 0x6F, 0x9B, 0x19, 0x48, 0x74, 0x85, + 0xD9, 0x90, 0x48, 0x99, 0x4E, 0xE9, 0xB5, 0x90 + }, + { + 0x43, 0x02, 0xE5, 0x48, 0x00, 0x35, 0x09, 0xC1, + 0x2C, 0xBF, 0x00, 0x34, 0xB6, 0xD0, 0x50, 0x59, + 0xF0, 0x41, 0x5A, 0xA6, 0xF6, 0x58, 0x16, 0x8A, + 0xAD, 0xD2, 0x5E, 0xC8, 0xF2, 0x3A, 0xCE, 0xD2, + 0xC4, 0x47, 0x52, 0xDE, 0x11, 0x5F, 0xA4, 0x4B, + 0x16, 0x9F, 0xE2, 0x77, 0x12, 0x80, 0x52, 0x3E, + 0x4F, 0x99, 0x56, 0x82, 0x96, 0x48, 0x2B, 0xEC, + 0xFA, 0x69, 0x39, 0x1B, 0xFD, 0x5E, 0xB1, 0x54 + }, + { + 0xCE, 0xA0, 0xB8, 0x1F, 0xDC, 0x55, 0xF7, 0x1C, + 0xA6, 0x33, 0x20, 0x90, 0x71, 0x87, 0xCC, 0xAA, + 0xCE, 0xB0, 0xAD, 0x38, 0xC5, 0x3E, 0x5F, 0x30, + 0x1B, 0xD1, 0x7E, 0x01, 0xFF, 0x5A, 0xB2, 0xD0, + 0xBD, 0x58, 0xFB, 0xAD, 0x7D, 0x22, 0x8F, 0xD3, + 0x3D, 0xC2, 0x18, 0x80, 0xA6, 0x7A, 0xC2, 0xEE, + 0x68, 0x35, 0xFC, 0x48, 0xB3, 0x8A, 0xC3, 0x08, + 0x92, 0x14, 0xDE, 0xFF, 0xBE, 0x97, 0x2D, 0x23 + }, + { + 0xF7, 0xEC, 0x43, 0xE6, 0xA4, 0xB2, 0x59, 0x2D, + 0x87, 0xB9, 0x17, 0x9F, 0x6D, 0x22, 0x31, 0x5B, + 0xBC, 0x52, 0x37, 0x33, 0xFB, 0x38, 0x18, 0x80, + 0x32, 0xB5, 0xB9, 0x26, 0x75, 0x4D, 0x61, 0xF2, + 0x5D, 0x6B, 0x21, 0x3A, 0xC3, 0x85, 0x8A, 0xE3, + 0xC7, 0x04, 0x21, 0x1D, 0x62, 0xEF, 0xAE, 0x86, + 0xAE, 0xCD, 0x70, 0xAF, 0x0C, 0xBA, 0x74, 0xAA, + 0xD3, 0xA9, 0xE6, 0x2F, 0xC9, 0x83, 0x97, 0x47 + }, + { + 0x6A, 0x10, 0x0B, 0x4E, 0xD4, 0x52, 0x24, 0xA7, + 0x14, 0xD5, 0x79, 0xA8, 0xD8, 0xD6, 0x5B, 0x75, + 0xDC, 0x71, 0xF7, 0x55, 0x75, 0x6A, 0x8C, 0xCB, + 0xF0, 0x09, 0x0D, 0xEC, 0xD6, 0x4E, 0x9B, 0x9F, + 0xDC, 0xBC, 0xF1, 0x0B, 0x7F, 0x75, 0x47, 0xD6, + 0x1D, 0xDC, 0xFA, 0x6D, 0x42, 0xE8, 0x4A, 0xE8, + 0x05, 0x55, 0xF4, 0xFB, 0x37, 0xC7, 0x25, 0xBE, + 0xD5, 0xE5, 0x3A, 0x7F, 0x6A, 0x7F, 0x06, 0x85 + }, + { + 0xB9, 0x2C, 0xFB, 0x2A, 0xA5, 0xE6, 0xFD, 0x13, + 0x2D, 0x1C, 0x8F, 0xF1, 0xC1, 0x3B, 0xA2, 0xD8, + 0xCE, 0xB9, 0x69, 0x49, 0x3C, 0xD3, 0x40, 0x2A, + 0xA4, 0x99, 0x9D, 0x67, 0x9F, 0x25, 0x52, 0xD1, + 0x3F, 0xA4, 0x66, 0x90, 0x90, 0xE7, 0x45, 0x26, + 0xA6, 0x45, 0x69, 0xB2, 0x19, 0x23, 0x43, 0xD5, + 0x91, 0xA5, 0x69, 0x03, 0x55, 0xB3, 0x49, 0xDB, + 0x4B, 0x8F, 0x8E, 0x47, 0x62, 0xB6, 0xE0, 0x4B + }, + { + 0x4F, 0x18, 0x0D, 0xC1, 0x25, 0x03, 0xFA, 0x46, + 0x31, 0xAE, 0xD7, 0xEC, 0xE7, 0xD9, 0x82, 0xB4, + 0x7B, 0x06, 0x44, 0x98, 0x6D, 0xF0, 0xCF, 0x6E, + 0xA0, 0x98, 0xEB, 0xDE, 0xF0, 0xBD, 0x67, 0x53, + 0x78, 0xF0, 0x15, 0xA1, 0x46, 0x95, 0x33, 0xB3, + 0x40, 0x2A, 0x4A, 0xB5, 0x93, 0x44, 0x08, 0xCB, + 0x7C, 0xF5, 0x9B, 0x19, 0x77, 0xCB, 0xDE, 0xF5, + 0xD3, 0xB2, 0xEA, 0x1E, 0xD9, 0x8E, 0x15, 0x0E + }, + { + 0x72, 0x56, 0xBC, 0x0D, 0x63, 0x9E, 0xB2, 0x7E, + 0x03, 0x9E, 0xBF, 0xA4, 0x81, 0x00, 0xF3, 0x75, + 0x2B, 0x56, 0x39, 0x0A, 0xA3, 0x8F, 0x2F, 0x48, + 0xB3, 0x1D, 0x1C, 0x67, 0xE9, 0x3B, 0x89, 0xA3, + 0x36, 0x9E, 0xA9, 0x98, 0x73, 0x1E, 0x51, 0x61, + 0xF4, 0x47, 0xF1, 0x96, 0x11, 0x98, 0xD6, 0xC3, + 0xF6, 0xA9, 0x6E, 0x33, 0xFC, 0xA9, 0x28, 0xF4, + 0x58, 0x4D, 0xF1, 0xCA, 0xB1, 0xBC, 0xA4, 0x32 + }, + { + 0x9C, 0x3A, 0x1E, 0x6D, 0xD4, 0x06, 0x2D, 0x7D, + 0x79, 0x13, 0x5B, 0x6F, 0x51, 0x13, 0x88, 0x28, + 0x24, 0x30, 0x1F, 0xA8, 0xB6, 0xFA, 0x37, 0x09, + 0x71, 0x79, 0x94, 0x47, 0x83, 0x48, 0xA7, 0x59, + 0x9E, 0xDB, 0x1A, 0x30, 0xF8, 0x01, 0xE8, 0xE4, + 0xA0, 0x9D, 0x7A, 0xC8, 0x6E, 0xCB, 0x29, 0xF9, + 0xC7, 0x44, 0xE0, 0x18, 0xC8, 0x8E, 0x51, 0xBB, + 0xAA, 0xB5, 0x1A, 0x6A, 0xC2, 0x9E, 0xF3, 0xAA + }, + { + 0x46, 0x68, 0x09, 0x4E, 0xA2, 0x58, 0xCF, 0xD1, + 0xDE, 0x88, 0x1C, 0x92, 0x25, 0x1B, 0xF4, 0x99, + 0xC3, 0x88, 0x2F, 0xF6, 0x39, 0x8B, 0xFC, 0x9E, + 0x8E, 0xFC, 0xFA, 0x0B, 0x37, 0xE4, 0x71, 0xAA, + 0xCB, 0xA4, 0xFE, 0xBF, 0x93, 0x44, 0xD5, 0x12, + 0x8D, 0xBF, 0xB1, 0xC5, 0x6D, 0x14, 0x70, 0xEF, + 0x92, 0x71, 0x3E, 0x14, 0x4A, 0xE2, 0x17, 0x75, + 0x95, 0x2B, 0xCA, 0x21, 0x15, 0x4F, 0x5A, 0xC1 + }, + { + 0x96, 0xD4, 0x80, 0x0B, 0xA0, 0xFC, 0x9D, 0x03, + 0x9F, 0x1D, 0x91, 0x79, 0x51, 0x99, 0xFD, 0x14, + 0x4F, 0x81, 0x84, 0x1D, 0x0C, 0xEB, 0x0E, 0x39, + 0x99, 0x85, 0xD0, 0xDF, 0x76, 0xFC, 0x49, 0x9D, + 0xC8, 0xA5, 0xCB, 0x21, 0xE0, 0x52, 0x5B, 0xCC, + 0x6E, 0x72, 0x54, 0xFD, 0x8F, 0x28, 0x50, 0x67, + 0x71, 0x6D, 0xA5, 0x29, 0x36, 0x06, 0x1E, 0xEF, + 0x69, 0xCD, 0x12, 0xF4, 0xA9, 0xD6, 0xF6, 0x08 + }, + { + 0x2B, 0xB0, 0x39, 0xAE, 0x98, 0xEB, 0xD4, 0x33, + 0x00, 0xC6, 0x35, 0x61, 0x4E, 0xC1, 0xE6, 0x4F, + 0xDB, 0x8A, 0x81, 0xC4, 0x9F, 0xBA, 0xC6, 0xD5, + 0x56, 0x1C, 0x17, 0xA1, 0x0F, 0x6B, 0xBF, 0x27, + 0xBB, 0x72, 0x5B, 0x3E, 0x54, 0x80, 0xD0, 0xD4, + 0xA0, 0x7D, 0x2F, 0xD0, 0xA5, 0x59, 0xBD, 0xE8, + 0xA4, 0xCB, 0xF8, 0xCB, 0x31, 0x87, 0x50, 0x79, + 0xC2, 0x90, 0xE8, 0x1B, 0x60, 0xA4, 0xD2, 0x0E + }, + { + 0xBE, 0xB4, 0xB9, 0x24, 0x1E, 0xC0, 0x74, 0xDF, + 0xA4, 0x8A, 0x35, 0x2F, 0xF6, 0xC8, 0xCE, 0x23, + 0x2A, 0xB6, 0x82, 0xC3, 0xB1, 0xCB, 0x81, 0x0D, + 0xE4, 0xCB, 0x20, 0x8F, 0x78, 0x42, 0x76, 0x29, + 0xF9, 0x83, 0x79, 0x56, 0x45, 0xDE, 0xCE, 0x2D, + 0x82, 0x13, 0x7A, 0x1B, 0x15, 0xB2, 0x02, 0x93, + 0x59, 0x3A, 0xC1, 0x3C, 0x76, 0x83, 0x4A, 0xCF, + 0x83, 0x60, 0xB9, 0xB7, 0x4F, 0x52, 0x1A, 0x02 + }, + { + 0x2A, 0x5E, 0x19, 0x60, 0xC2, 0xFB, 0x38, 0x1E, + 0x7D, 0x27, 0x99, 0xF3, 0x43, 0x4C, 0xAE, 0x86, + 0x74, 0xDA, 0xE7, 0x6B, 0x3E, 0x8F, 0x73, 0x69, + 0xF9, 0xE1, 0xFB, 0xA1, 0xAE, 0xF9, 0x3C, 0x72, + 0x7B, 0x3D, 0x6A, 0x2B, 0x6C, 0x90, 0x71, 0x54, + 0x39, 0x69, 0xE2, 0x07, 0xD0, 0xD8, 0xF4, 0x69, + 0x5D, 0xFF, 0xDF, 0xDF, 0xF9, 0x04, 0x54, 0xF1, + 0x44, 0x93, 0x2E, 0x1C, 0x86, 0xE0, 0x8B, 0x43 + }, + { + 0xE1, 0x84, 0x8A, 0x41, 0x4B, 0x8D, 0x08, 0x5F, + 0x22, 0x2D, 0xE7, 0x43, 0xAE, 0x65, 0x65, 0x40, + 0x7A, 0x65, 0x7F, 0xD1, 0x23, 0x7C, 0x06, 0x24, + 0x24, 0xE6, 0x26, 0xA3, 0x89, 0x78, 0xFC, 0x08, + 0x84, 0xB7, 0xFB, 0x64, 0x62, 0xA6, 0x6E, 0xBA, + 0xD4, 0x3E, 0x22, 0x97, 0x34, 0x82, 0xCB, 0x09, + 0xDA, 0x37, 0x75, 0x7C, 0x81, 0x32, 0x10, 0xD4, + 0xAC, 0x61, 0xBA, 0xC3, 0x8C, 0xB1, 0x16, 0x16 + }, + { + 0xFD, 0xD2, 0xD1, 0xDE, 0xA8, 0x3C, 0x4B, 0xF3, + 0x2B, 0x95, 0x53, 0xEC, 0x84, 0xAB, 0x0E, 0xD1, + 0xEC, 0x77, 0xF0, 0x5E, 0x03, 0xC2, 0x49, 0x86, + 0xAE, 0x1F, 0xE5, 0xAD, 0x21, 0x37, 0xB2, 0x49, + 0x69, 0xDC, 0xE4, 0xFC, 0x40, 0x29, 0x1D, 0x4D, + 0x3A, 0x67, 0x11, 0xFE, 0x5D, 0xFB, 0xA0, 0xFC, + 0xA0, 0x87, 0x11, 0x1B, 0xC8, 0x0A, 0xDD, 0x2B, + 0x9A, 0x78, 0x4E, 0x0E, 0x96, 0xAB, 0xE5, 0xF1 + }, + { + 0x4B, 0x58, 0x94, 0x8D, 0xDA, 0x6A, 0xF7, 0x8B, + 0xF9, 0x65, 0x84, 0xA1, 0xE1, 0x1E, 0x7A, 0x6A, + 0xD5, 0x4F, 0x39, 0x51, 0x51, 0xF2, 0x7A, 0x32, + 0xC2, 0xA9, 0xE9, 0x96, 0xBC, 0x18, 0x29, 0x32, + 0x6D, 0xB9, 0x77, 0x61, 0x61, 0xC2, 0xE4, 0x67, + 0xAF, 0x84, 0xB5, 0x78, 0xCC, 0xE1, 0xE1, 0xBE, + 0x0B, 0xCE, 0x8B, 0x33, 0x0D, 0x80, 0x2D, 0x5C, + 0xD4, 0x1B, 0x64, 0xFB, 0xE6, 0x90, 0x5C, 0xCE + }, + { + 0xD3, 0xB5, 0xD2, 0x92, 0x3B, 0xE4, 0x7C, 0x8F, + 0xB7, 0x62, 0x93, 0xFB, 0x9F, 0xA2, 0x1A, 0x0E, + 0x6A, 0xFD, 0xA6, 0xB3, 0x4E, 0x95, 0x2B, 0x1D, + 0xB6, 0x23, 0xF9, 0x6E, 0x7F, 0x0F, 0x4F, 0xEA, + 0x01, 0x01, 0xD3, 0xC8, 0x18, 0x2D, 0x80, 0x1F, + 0x31, 0xDD, 0x17, 0x06, 0x88, 0x50, 0xB2, 0x16, + 0x91, 0x84, 0x22, 0x6A, 0xEA, 0x46, 0x4B, 0x0D, + 0x1E, 0xD7, 0x00, 0xA2, 0x60, 0x84, 0x9D, 0xB5 + }, + { + 0x70, 0x2E, 0x67, 0x11, 0xA3, 0xA4, 0xC1, 0x76, + 0xCE, 0xA9, 0x8E, 0x63, 0x3C, 0xD4, 0x0B, 0xCD, + 0xFD, 0xF8, 0x13, 0x53, 0x63, 0xCE, 0x06, 0x56, + 0xA3, 0xE5, 0x8A, 0xB1, 0xEE, 0x03, 0x1F, 0xDE, + 0xBF, 0x6C, 0x2C, 0xFE, 0xEA, 0x0D, 0xD4, 0xA2, + 0x09, 0x0D, 0x66, 0x2F, 0x8C, 0x2D, 0xA1, 0x15, + 0xB9, 0x70, 0xDF, 0xC3, 0x36, 0xCF, 0x05, 0x9A, + 0x79, 0xBD, 0x31, 0xEB, 0xC9, 0x1A, 0x14, 0x5A + }, + { + 0xF1, 0xF6, 0x36, 0xBC, 0x44, 0x92, 0x2A, 0x5D, + 0xC8, 0x92, 0xB2, 0x83, 0xEC, 0x96, 0xF9, 0x60, + 0x60, 0x3D, 0xB8, 0x29, 0xB9, 0x81, 0x3F, 0xE9, + 0xE0, 0xA6, 0x40, 0x33, 0x77, 0x1B, 0xF0, 0x58, + 0x05, 0x41, 0x91, 0x00, 0xCB, 0xFB, 0xAB, 0x19, + 0x0A, 0xDF, 0x2A, 0x79, 0x72, 0xB0, 0x14, 0x5D, + 0x61, 0x38, 0x1B, 0xD6, 0x51, 0x99, 0x97, 0xD5, + 0x0A, 0x76, 0x37, 0xA1, 0xEA, 0x4C, 0xBB, 0xD7 + }, + { + 0xA0, 0xB4, 0x32, 0xBC, 0x55, 0x89, 0x67, 0x2C, + 0x49, 0x44, 0xE1, 0xE1, 0x3B, 0x8A, 0x7B, 0x6B, + 0x6D, 0xEB, 0x5C, 0x8D, 0xDE, 0x4D, 0x1E, 0xC8, + 0xE0, 0xDD, 0x69, 0x8A, 0xE4, 0xAE, 0x5C, 0x94, + 0xE0, 0xE8, 0xBA, 0x17, 0xCD, 0xD7, 0x79, 0x8D, + 0x8D, 0xE5, 0xFC, 0x02, 0x7D, 0x5F, 0xE0, 0xE0, + 0xAE, 0xA6, 0xB5, 0xD4, 0x1D, 0x25, 0x37, 0xFE, + 0x80, 0xBC, 0x27, 0x27, 0x7B, 0x11, 0x55, 0x2D + }, + { + 0x6B, 0xF8, 0x13, 0x85, 0x0F, 0xBD, 0xBA, 0xD0, + 0xFA, 0xF5, 0x46, 0xC4, 0xC9, 0x8D, 0xFE, 0xEE, + 0x94, 0x97, 0xB7, 0xEF, 0x67, 0x0B, 0x75, 0x52, + 0xEA, 0x29, 0xDE, 0x75, 0xEE, 0xAA, 0x0F, 0x6E, + 0x3E, 0x6F, 0x7C, 0xAD, 0x18, 0x61, 0xF6, 0x4B, + 0x8E, 0x2C, 0xE5, 0x21, 0x8F, 0xF1, 0x87, 0xAE, + 0x06, 0x13, 0x02, 0xE7, 0xDB, 0x86, 0x98, 0xE2, + 0x72, 0x41, 0x8F, 0x98, 0x44, 0x16, 0xC3, 0xD0 + }, + { + 0x78, 0x3B, 0x05, 0x5C, 0x13, 0x68, 0xC5, 0x17, + 0xB4, 0x7E, 0x60, 0xAA, 0x64, 0x7E, 0xD3, 0x42, + 0x31, 0xE2, 0xF2, 0xED, 0x92, 0x92, 0xA8, 0x28, + 0x15, 0x11, 0x6A, 0x84, 0x83, 0xB1, 0xBD, 0x39, + 0x4A, 0x3C, 0xBE, 0x51, 0x32, 0x59, 0x73, 0x8F, + 0xA5, 0xDA, 0x8E, 0x82, 0x3B, 0xEF, 0xB5, 0xC9, + 0xCD, 0xFD, 0x26, 0x20, 0x33, 0x6F, 0x20, 0x2E, + 0x8A, 0x80, 0x74, 0xD1, 0xE3, 0xF7, 0xFB, 0x9C + }, + { + 0x12, 0x43, 0x8D, 0x49, 0xD6, 0x8E, 0x6A, 0xDC, + 0xD4, 0x1C, 0xDC, 0x3B, 0x99, 0x43, 0x69, 0xF2, + 0x43, 0x96, 0xB2, 0x95, 0xC8, 0x11, 0xA5, 0x13, + 0x3C, 0xEB, 0xCB, 0x5D, 0x29, 0x75, 0x47, 0x53, + 0xBA, 0x7D, 0x79, 0x20, 0x78, 0x8C, 0xD9, 0x31, + 0x4B, 0xB4, 0x96, 0xBC, 0x0B, 0xE2, 0xB2, 0xB6, + 0x22, 0x45, 0x73, 0xCE, 0x1F, 0x0D, 0x6F, 0x0F, + 0xE9, 0xE0, 0xF8, 0xCA, 0xBB, 0x4F, 0xD2, 0x7B + }, + { + 0x50, 0x7A, 0x82, 0x1B, 0xA5, 0x72, 0x0A, 0x9F, + 0x21, 0x5F, 0xDA, 0x7E, 0x54, 0x0A, 0x39, 0x72, + 0x77, 0xC9, 0x8F, 0xE8, 0x88, 0x36, 0x78, 0x84, + 0xA5, 0xEF, 0xD0, 0x64, 0x1F, 0xDB, 0x35, 0x9A, + 0xB4, 0x64, 0x6D, 0xF7, 0xCB, 0xA1, 0x6A, 0xE4, + 0x54, 0xCD, 0x16, 0xF5, 0x21, 0xE3, 0xDA, 0x97, + 0x36, 0x6B, 0x9A, 0x5A, 0x7A, 0xE2, 0x0C, 0xA4, + 0x96, 0x54, 0x42, 0x82, 0x44, 0x53, 0xED, 0xBB + }, + { + 0x7C, 0x69, 0x46, 0x26, 0x61, 0xCB, 0xFE, 0x7A, + 0xA4, 0xDB, 0x17, 0x19, 0xC5, 0x12, 0xE7, 0x41, + 0xA4, 0xB2, 0x20, 0x33, 0x5B, 0xC3, 0x01, 0xCF, + 0x98, 0x07, 0x14, 0x6A, 0x3E, 0x4C, 0x7C, 0xF3, + 0xFD, 0xE3, 0x1D, 0xFD, 0x6F, 0x8D, 0x62, 0xF7, + 0x65, 0x8B, 0xB6, 0xF5, 0x93, 0xE1, 0x41, 0xB0, + 0xFE, 0x12, 0x41, 0xE5, 0xD6, 0xC1, 0xB1, 0xC8, + 0x82, 0xD4, 0xD2, 0xA4, 0xCD, 0xC6, 0xD6, 0x50 + }, + { + 0x01, 0x31, 0x2A, 0x92, 0xAD, 0xF6, 0x8B, 0x84, + 0xE0, 0x14, 0x11, 0x8A, 0x37, 0x4D, 0x7B, 0x33, + 0x66, 0x89, 0xFA, 0x19, 0x65, 0xFB, 0x0E, 0xAE, + 0x2A, 0x69, 0x35, 0xE8, 0x57, 0xB0, 0xA9, 0x34, + 0xFA, 0x75, 0x00, 0x43, 0x68, 0x7C, 0x9F, 0xB7, + 0x35, 0x60, 0x7F, 0xBD, 0xA4, 0x30, 0x1B, 0x5C, + 0xC3, 0xDB, 0x02, 0x8D, 0x6B, 0x14, 0x1E, 0xB7, + 0x9F, 0xC0, 0x0C, 0xF5, 0x9E, 0x24, 0xBA, 0x72 + }, + { + 0x06, 0xDA, 0xFB, 0x0B, 0xD8, 0xBB, 0x95, 0x8C, + 0x66, 0x71, 0x17, 0x6B, 0x9D, 0xA9, 0xB3, 0x39, + 0xB9, 0xDA, 0x1F, 0x09, 0xF3, 0x8A, 0x2D, 0xE0, + 0xE2, 0x43, 0x61, 0xF9, 0x4B, 0x4A, 0xAD, 0xF1, + 0xA0, 0x18, 0x55, 0x65, 0x25, 0x44, 0xFD, 0x6E, + 0x23, 0xB2, 0x74, 0xDD, 0x1E, 0x1E, 0x07, 0x82, + 0xEC, 0x4D, 0x45, 0xAA, 0x3B, 0x7E, 0xFF, 0xE7, + 0x0F, 0xC2, 0xD2, 0x7F, 0x6A, 0xEF, 0x78, 0x4B + }, + { + 0x14, 0x4C, 0xCC, 0x96, 0x0E, 0x7F, 0x35, 0x4F, + 0x93, 0x03, 0x9A, 0x49, 0xBE, 0x12, 0xBF, 0x36, + 0xC2, 0x9C, 0x06, 0x5D, 0xBD, 0x2F, 0x91, 0x27, + 0x33, 0xE6, 0x29, 0x8B, 0x58, 0x37, 0x6D, 0x6C, + 0x80, 0xB9, 0x34, 0xF0, 0x36, 0x29, 0x0A, 0xE0, + 0xA3, 0xCB, 0xEF, 0xA8, 0x37, 0x37, 0x29, 0xDB, + 0xD7, 0xBA, 0xB6, 0x47, 0xC7, 0xA7, 0x05, 0x9B, + 0xBE, 0x64, 0x80, 0x31, 0x67, 0x87, 0x18, 0x14 + }, + { + 0x8C, 0xF6, 0x73, 0x23, 0x6B, 0x98, 0x59, 0x36, + 0xEF, 0xA8, 0x74, 0xB9, 0x11, 0xB8, 0xBB, 0xAF, + 0xCD, 0xF9, 0x56, 0x44, 0x2F, 0xA5, 0x13, 0x3E, + 0x2F, 0x59, 0x1D, 0x7D, 0xA3, 0x41, 0xAB, 0xC0, + 0xA4, 0x80, 0xC8, 0x56, 0x68, 0x39, 0xEB, 0xA9, + 0xE9, 0xCF, 0x71, 0x31, 0x21, 0x6D, 0x03, 0x93, + 0x16, 0x47, 0x9F, 0x48, 0x1C, 0x43, 0x6C, 0x0D, + 0x6C, 0x92, 0x29, 0x40, 0x28, 0x38, 0xCE, 0xD7 + }, + { + 0x7B, 0xA7, 0x25, 0xC8, 0x57, 0x10, 0x7E, 0x54, + 0xD1, 0x62, 0x8C, 0xF5, 0x08, 0x85, 0x1E, 0x69, + 0x71, 0x47, 0x0C, 0x2B, 0x37, 0xD1, 0xE1, 0x01, + 0x11, 0x02, 0x3D, 0xA5, 0x20, 0x61, 0x67, 0x76, + 0x0B, 0x8B, 0x3B, 0x54, 0x02, 0xAA, 0x4D, 0x0D, + 0xCF, 0x0B, 0xB5, 0x77, 0x98, 0xF5, 0x74, 0xE1, + 0x7D, 0x8C, 0x29, 0x00, 0x3E, 0xF6, 0x08, 0x35, + 0xA8, 0xF7, 0x37, 0x60, 0xA9, 0x18, 0x40, 0x3A + }, + { + 0xEA, 0x50, 0x30, 0x01, 0x80, 0x61, 0x39, 0xBD, + 0xDB, 0x76, 0x02, 0x0F, 0x88, 0xB7, 0xD1, 0xBA, + 0x36, 0xD1, 0xC5, 0xAD, 0x82, 0x5B, 0x51, 0xBD, + 0xB9, 0xA8, 0xEF, 0x2F, 0xFE, 0xAD, 0xAB, 0x45, + 0x76, 0xDA, 0x35, 0x20, 0x63, 0x8C, 0x5E, 0xD4, + 0xF4, 0xEF, 0x7B, 0x44, 0xAA, 0x50, 0xC5, 0xEB, + 0x6E, 0x06, 0x48, 0xB8, 0x12, 0x7E, 0xE8, 0xC9, + 0x97, 0xD7, 0x24, 0xCB, 0x67, 0x47, 0xF4, 0x99 + }, + { + 0xF0, 0x2C, 0x37, 0x67, 0x6C, 0x0E, 0xCA, 0xD4, + 0xFE, 0x7F, 0x97, 0x71, 0xEE, 0x0B, 0x0C, 0x06, + 0x99, 0x17, 0x74, 0xFF, 0xDE, 0x1E, 0xD1, 0xA2, + 0x7D, 0x02, 0xAD, 0x12, 0xD8, 0x5B, 0x93, 0xE6, + 0xC4, 0x49, 0xB2, 0x1A, 0xC1, 0x9F, 0x80, 0x07, + 0x0C, 0xF8, 0x58, 0x22, 0x70, 0x58, 0xD3, 0xD7, + 0x27, 0x2C, 0x6D, 0x47, 0x98, 0xAE, 0xA9, 0x34, + 0x72, 0x2F, 0xE3, 0x0D, 0xDD, 0xA4, 0xD7, 0xE9 + }, + { + 0x1C, 0x1E, 0xBE, 0xC9, 0x86, 0x4D, 0x50, 0x84, + 0xFB, 0x18, 0x0D, 0x33, 0x04, 0x35, 0x96, 0x34, + 0xE8, 0x98, 0xD9, 0x7C, 0x11, 0xC1, 0x6B, 0x7E, + 0x4C, 0xF9, 0x6E, 0x72, 0xBD, 0x2E, 0x37, 0xB7, + 0x2B, 0x61, 0xE7, 0x0B, 0x78, 0x39, 0x67, 0x31, + 0x51, 0x4D, 0xDA, 0xFD, 0xE9, 0x06, 0xAA, 0xB2, + 0xEE, 0x26, 0xDD, 0xF9, 0xC1, 0xC8, 0xB3, 0xA1, + 0x4A, 0x19, 0x5E, 0xD0, 0xBB, 0x99, 0xBD, 0xFF + }, + { + 0x52, 0xBC, 0x02, 0x4D, 0x36, 0xB0, 0x46, 0x43, + 0x5B, 0x2D, 0x76, 0x75, 0x0A, 0x39, 0xB6, 0x82, + 0xD0, 0x1F, 0x51, 0xE6, 0x94, 0x1C, 0x84, 0xAC, + 0x3B, 0x35, 0xAB, 0x63, 0x10, 0xEF, 0xCF, 0xA9, + 0x49, 0x7B, 0x02, 0xF6, 0x67, 0xD1, 0x59, 0x26, + 0x6C, 0x43, 0xB4, 0x68, 0xD8, 0x2A, 0x45, 0xF4, + 0xC5, 0xAF, 0x35, 0x7E, 0x1D, 0xF6, 0x13, 0xB3, + 0x2D, 0x3F, 0xD4, 0x00, 0x82, 0x8C, 0xC9, 0x5C + }, + { + 0xB8, 0x6C, 0xDD, 0xEA, 0xAD, 0x01, 0x1A, 0xB2, + 0x6C, 0x4B, 0xB3, 0x65, 0xC4, 0x42, 0x51, 0x7A, + 0xBB, 0x99, 0x13, 0x2D, 0xEA, 0xE8, 0x3D, 0xBB, + 0xDD, 0xD8, 0x63, 0x47, 0x3A, 0xEC, 0x2D, 0x5E, + 0xD5, 0x55, 0x9F, 0x2D, 0xAA, 0xA9, 0x02, 0x0E, + 0x08, 0xAA, 0x9B, 0xA6, 0x1F, 0x46, 0x96, 0xF3, + 0xEA, 0x26, 0xD4, 0xBB, 0xCE, 0x12, 0x22, 0x5C, + 0xF6, 0x89, 0x6C, 0xA4, 0x87, 0xBA, 0xB0, 0xE3 + }, + { + 0x20, 0x59, 0x2B, 0xAC, 0xB3, 0x7F, 0xC5, 0xFA, + 0x02, 0xCC, 0xA2, 0x18, 0xA8, 0x76, 0x0E, 0x70, + 0x6A, 0x5E, 0x38, 0xD4, 0x65, 0x89, 0x4C, 0x6E, + 0x2E, 0xE5, 0x5F, 0x4B, 0x8F, 0x08, 0x32, 0x48, + 0x03, 0xA2, 0xA6, 0xF2, 0xEB, 0x60, 0xB2, 0x28, + 0xB0, 0x50, 0xFA, 0x2B, 0x38, 0xF2, 0xB4, 0x77, + 0xE9, 0xDE, 0x07, 0x7A, 0x20, 0x95, 0xCF, 0x66, + 0xCF, 0x0E, 0xB0, 0x6D, 0x87, 0x61, 0xEF, 0xB2 + }, + { + 0x74, 0x43, 0x88, 0x1F, 0x6E, 0xCA, 0xE6, 0xD1, + 0x33, 0x4A, 0xF8, 0x8C, 0x91, 0xD4, 0x95, 0xEC, + 0xFA, 0x4F, 0x18, 0xCA, 0x59, 0x14, 0x00, 0x44, + 0xB0, 0x51, 0x0C, 0x1D, 0x9E, 0x35, 0x96, 0xA7, + 0x1E, 0x0E, 0x0F, 0x5C, 0x38, 0xB9, 0x8F, 0xCD, + 0x1C, 0xDE, 0xFC, 0x36, 0x95, 0x0E, 0x8D, 0xC2, + 0xCB, 0xFB, 0x42, 0xDD, 0x67, 0x88, 0x46, 0xEE, + 0xEF, 0x99, 0xE6, 0x9D, 0x87, 0x5E, 0x5B, 0xDA + }, + { + 0x67, 0x30, 0xD9, 0x46, 0xAC, 0x03, 0x76, 0x80, + 0x2E, 0x39, 0xEE, 0xAD, 0x5B, 0xA9, 0xA2, 0x4D, + 0xB5, 0x6B, 0x45, 0x89, 0x59, 0x1B, 0xFA, 0x99, + 0x00, 0xE6, 0x42, 0xDE, 0x37, 0x1C, 0xCE, 0x2D, + 0x6B, 0x5D, 0xD5, 0x21, 0xFD, 0x6C, 0x3B, 0xD2, + 0x57, 0x49, 0xAD, 0xB6, 0x41, 0x4B, 0x66, 0x5D, + 0x7C, 0x9F, 0x4A, 0xAF, 0x35, 0x8A, 0x75, 0x11, + 0xAE, 0xF8, 0x6A, 0x78, 0x33, 0x69, 0x22, 0x4B + }, + { + 0x9A, 0xC0, 0x69, 0x50, 0x8B, 0xD0, 0xB4, 0x85, + 0xA8, 0xAE, 0x2F, 0x9C, 0x43, 0xD2, 0x16, 0xA7, + 0x53, 0x0F, 0xAB, 0x2E, 0xE7, 0xEE, 0xF4, 0x07, + 0x5C, 0x53, 0xBA, 0x98, 0x53, 0x32, 0x1B, 0xD4, + 0xB8, 0x59, 0x0A, 0x44, 0x50, 0x24, 0x84, 0x3D, + 0xD7, 0xE2, 0xD1, 0xE9, 0x89, 0x84, 0x92, 0xFA, + 0x23, 0x0E, 0xA9, 0x3C, 0x78, 0xD8, 0x02, 0x94, + 0x96, 0x1F, 0x38, 0xCE, 0x5A, 0xED, 0xEE, 0x20 + }, + { + 0xE0, 0x5A, 0x58, 0xA8, 0xDB, 0xE5, 0x16, 0x09, + 0xA3, 0xDE, 0xFC, 0x73, 0xEC, 0x92, 0x7B, 0x54, + 0x4A, 0x29, 0x46, 0x19, 0x23, 0x1E, 0x3C, 0x2E, + 0xA2, 0xCF, 0xD0, 0x07, 0x18, 0xC0, 0xF8, 0x8E, + 0x1F, 0x25, 0x9B, 0xB2, 0xD2, 0x2B, 0x1C, 0x3B, + 0x75, 0x44, 0x3E, 0x32, 0x41, 0xDD, 0x89, 0x1B, + 0xE3, 0xA2, 0x69, 0x27, 0x1F, 0x92, 0x23, 0x4B, + 0x20, 0x81, 0xC5, 0x7D, 0xF0, 0xB2, 0xF6, 0x79 + }, + { + 0x66, 0xD7, 0x7F, 0x27, 0x2D, 0x74, 0xF9, 0x02, + 0xB0, 0xCD, 0xBA, 0x2A, 0x6F, 0x55, 0xAC, 0xC4, + 0xFC, 0xD9, 0x95, 0x5E, 0x63, 0x84, 0xEC, 0x79, + 0xFD, 0x24, 0x00, 0xDE, 0x6E, 0x03, 0x84, 0x09, + 0x7A, 0xBD, 0xF2, 0x5C, 0x70, 0x07, 0x31, 0x7D, + 0x4F, 0x12, 0xCC, 0x8E, 0x84, 0x18, 0x3C, 0xD8, + 0x11, 0x4F, 0xD6, 0xB3, 0xAB, 0xBC, 0x62, 0x1C, + 0x82, 0x95, 0x9C, 0xFE, 0x6D, 0x15, 0x3D, 0x16 + }, + { + 0x8B, 0xC0, 0x5A, 0x9B, 0xCD, 0x22, 0xF6, 0xD4, + 0x7F, 0x35, 0xF9, 0x07, 0x92, 0xE5, 0xA3, 0xE4, + 0x4F, 0x45, 0xFC, 0x3D, 0xA8, 0x31, 0x71, 0xE7, + 0x22, 0x93, 0x65, 0xA3, 0x70, 0x74, 0x17, 0x9B, + 0xF4, 0x24, 0x5B, 0xE6, 0xE5, 0x1D, 0xC6, 0x2D, + 0x2C, 0xB4, 0x02, 0x50, 0x32, 0x47, 0x27, 0x32, + 0x48, 0x02, 0x42, 0x97, 0xF3, 0x79, 0xAC, 0xC8, + 0x91, 0xB8, 0x9D, 0xAD, 0x9B, 0x50, 0xCB, 0x22 + }, + { + 0xD2, 0xD8, 0x80, 0x28, 0x56, 0xFD, 0x26, 0xE8, + 0xD0, 0x19, 0x9D, 0x6B, 0xEA, 0x77, 0x72, 0x0F, + 0x3A, 0x4E, 0xF6, 0x8F, 0xD0, 0xB3, 0x2F, 0xA4, + 0xB4, 0xB1, 0x9A, 0x70, 0x05, 0xC3, 0x50, 0xAD, + 0x56, 0xC4, 0xF8, 0x05, 0x5F, 0x17, 0xFF, 0xF1, + 0xB4, 0x15, 0x78, 0x30, 0x4C, 0x17, 0xFD, 0xCD, + 0x1A, 0x7D, 0x6C, 0xC3, 0x67, 0x04, 0x7B, 0x0C, + 0xE2, 0xD3, 0x8D, 0x81, 0x13, 0xCE, 0x52, 0x01 + }, + { + 0xAF, 0x6E, 0xEB, 0x2C, 0xE6, 0xB3, 0x4A, 0x45, + 0xB0, 0x6A, 0x95, 0xA7, 0x83, 0x5D, 0x32, 0x25, + 0x31, 0x31, 0xF7, 0x6C, 0xB7, 0x9F, 0xDA, 0xE7, + 0xD8, 0xA2, 0x4E, 0xAD, 0x16, 0x89, 0x96, 0x40, + 0xFC, 0x8C, 0xB0, 0xFE, 0xE1, 0xEA, 0x82, 0xD6, + 0x16, 0xD5, 0x9C, 0x97, 0xD9, 0x81, 0x14, 0x1A, + 0x48, 0xFF, 0x98, 0xE3, 0x16, 0xD1, 0x9A, 0xD0, + 0x87, 0x44, 0x27, 0xC4, 0xAC, 0xBE, 0x76, 0x00 + }, + { + 0x49, 0x9B, 0x3F, 0x10, 0xE2, 0xAA, 0xD7, 0x5E, + 0x16, 0xAB, 0x1A, 0x37, 0x0D, 0x5A, 0x81, 0xB1, + 0xF1, 0x88, 0x55, 0x56, 0x13, 0x6B, 0xE2, 0x1C, + 0xF9, 0xB2, 0x09, 0x13, 0x3F, 0x04, 0x7A, 0x83, + 0x50, 0x63, 0xB6, 0x9D, 0xF6, 0x43, 0xFF, 0xC2, + 0x45, 0xDE, 0x78, 0x3D, 0x60, 0xD5, 0xE7, 0x12, + 0x79, 0x48, 0x1E, 0x8F, 0x42, 0xD0, 0x05, 0xC2, + 0xDD, 0xA7, 0x35, 0xC2, 0x74, 0x24, 0x66, 0x85 + }, + { + 0x8E, 0xC1, 0x95, 0x19, 0x50, 0x5B, 0x14, 0x52, + 0xF5, 0x76, 0x75, 0x0B, 0x27, 0x23, 0x3E, 0x6F, + 0x05, 0x09, 0x88, 0x06, 0xDC, 0x82, 0xD7, 0xC9, + 0xED, 0x35, 0x05, 0x86, 0x2C, 0x38, 0x57, 0x38, + 0x5A, 0x1B, 0x2A, 0x66, 0xEA, 0xE6, 0x03, 0x5B, + 0xFE, 0xEB, 0x37, 0xC4, 0xB7, 0x9D, 0x2B, 0x7F, + 0xEE, 0x14, 0x96, 0xFB, 0x4B, 0x60, 0xCD, 0x8E, + 0x00, 0x85, 0xE1, 0x78, 0x18, 0x57, 0x10, 0x85 + }, + { + 0x77, 0xB4, 0x88, 0x00, 0x55, 0x14, 0x19, 0x27, + 0xF6, 0x2F, 0xBD, 0x46, 0x45, 0x8E, 0x37, 0xC3, + 0x6D, 0xCA, 0x80, 0x36, 0xB6, 0xD8, 0x4D, 0x07, + 0xF4, 0x37, 0x45, 0x3B, 0xD2, 0x0A, 0x47, 0xB0, + 0x20, 0xEF, 0xFE, 0x86, 0xD8, 0xAB, 0x38, 0x24, + 0x29, 0xC7, 0x57, 0x2D, 0x85, 0x3C, 0x43, 0x77, + 0x1B, 0xEE, 0x80, 0x0B, 0xE2, 0xBE, 0x31, 0x6A, + 0x6F, 0x47, 0x24, 0x22, 0xDA, 0x9E, 0x68, 0x7E + }, + { + 0x19, 0xF7, 0x5F, 0x4B, 0xEA, 0xB9, 0x31, 0xCB, + 0x5C, 0x0E, 0xCB, 0x5B, 0x4A, 0xA8, 0xCD, 0x53, + 0x64, 0x2A, 0x2A, 0xAC, 0x11, 0xCC, 0x78, 0x24, + 0xEB, 0x2B, 0xF9, 0x65, 0x19, 0xB4, 0x29, 0x53, + 0xDC, 0x38, 0x47, 0x91, 0xE6, 0xFB, 0x4B, 0x53, + 0xA9, 0xD6, 0x8F, 0xBB, 0xC0, 0x38, 0x81, 0xEB, + 0x96, 0x1E, 0xED, 0xBF, 0x7B, 0x9B, 0xB5, 0x8F, + 0xBE, 0x45, 0xC4, 0x85, 0xBA, 0x74, 0x13, 0x7D + }, + { + 0xB8, 0xBA, 0xD2, 0xD5, 0x6D, 0xC7, 0x5E, 0x44, + 0x1C, 0xBA, 0xF0, 0xFF, 0x9E, 0x83, 0x50, 0x0E, + 0x9D, 0xE6, 0x0E, 0x88, 0x68, 0xD8, 0xD4, 0x5E, + 0x8F, 0x00, 0x3B, 0x12, 0x4E, 0xE4, 0xB5, 0x28, + 0x2C, 0x76, 0x00, 0x8F, 0xD4, 0xF1, 0x6A, 0x77, + 0x31, 0x37, 0xCD, 0xCD, 0xC3, 0x94, 0xB2, 0x68, + 0x8A, 0xCB, 0xF5, 0xBD, 0xCE, 0xC9, 0xFB, 0x44, + 0xDE, 0x53, 0xAA, 0xCC, 0x5A, 0x88, 0xCE, 0xD0 + }, + { + 0xCF, 0xFB, 0x31, 0x9A, 0xAC, 0xB9, 0x5D, 0x8E, + 0x95, 0x99, 0xE4, 0x2D, 0xF3, 0x9E, 0xF8, 0x4B, + 0x66, 0x5A, 0xDE, 0xE1, 0xF9, 0xA9, 0x41, 0x4E, + 0x2E, 0x79, 0x28, 0x5A, 0x4C, 0xBB, 0xD7, 0xF7, + 0x5A, 0xBD, 0x89, 0x66, 0x76, 0xA9, 0x4A, 0x46, + 0x1D, 0x2B, 0xD1, 0x97, 0x70, 0x7E, 0xDE, 0xF6, + 0x0C, 0x14, 0x43, 0x3A, 0x53, 0xE8, 0xEF, 0x2E, + 0x87, 0x38, 0x73, 0x04, 0xBB, 0x61, 0x26, 0x62 + }, + { + 0x39, 0xBD, 0x39, 0x55, 0x8A, 0x88, 0x1B, 0x91, + 0x3B, 0xC0, 0xD8, 0xA6, 0xD3, 0xA0, 0x82, 0x43, + 0xA7, 0x6B, 0xFC, 0xF4, 0x75, 0x7F, 0x5E, 0x56, + 0xBB, 0x6B, 0xC7, 0x07, 0xF4, 0x50, 0xD1, 0x6E, + 0xD2, 0x9F, 0x57, 0x26, 0xF7, 0xBF, 0x69, 0x79, + 0x82, 0xB9, 0x8E, 0x1F, 0x68, 0xB9, 0x63, 0x2A, + 0xEF, 0x68, 0x54, 0x7E, 0x2E, 0xF0, 0xFF, 0x02, + 0x41, 0xAD, 0x73, 0x81, 0xFF, 0xB6, 0x52, 0xE6 + }, + { + 0x46, 0x29, 0x5F, 0x68, 0xB9, 0x67, 0x6B, 0x1D, + 0x69, 0xEF, 0x04, 0x42, 0xB7, 0x94, 0x0D, 0x12, + 0x6D, 0x73, 0xDA, 0x93, 0xC1, 0xD2, 0x79, 0xD2, + 0xF9, 0x2E, 0xF9, 0x20, 0x04, 0x21, 0x3D, 0xA9, + 0x7A, 0x52, 0xAB, 0x04, 0xFA, 0x54, 0x37, 0xE7, + 0x78, 0x47, 0x57, 0x0F, 0x81, 0xAB, 0xD5, 0x45, + 0xF8, 0x53, 0xEB, 0xE6, 0x9B, 0x4C, 0x16, 0x72, + 0x15, 0x7E, 0x66, 0x05, 0xD5, 0x70, 0x08, 0x76 + }, + { + 0x8F, 0xE5, 0x20, 0x6D, 0x60, 0x50, 0x68, 0x53, + 0x6E, 0xA9, 0x63, 0x65, 0x2C, 0xBE, 0x80, 0x45, + 0x3A, 0x89, 0xFB, 0xFB, 0x8B, 0x95, 0xC4, 0x06, + 0xF0, 0x4F, 0x46, 0x42, 0x7D, 0x5E, 0x64, 0xA2, + 0xF8, 0x86, 0x98, 0x1F, 0xD4, 0xB8, 0xF4, 0xBE, + 0x48, 0xD4, 0xEF, 0x39, 0x0E, 0x4D, 0x9C, 0xBB, + 0xAF, 0x35, 0x02, 0x28, 0x43, 0xCE, 0x94, 0xD8, + 0xA7, 0xF2, 0x46, 0x04, 0xDD, 0xAD, 0x23, 0xEE + }, + { + 0xAD, 0xF7, 0x06, 0xBD, 0xA8, 0x47, 0x94, 0x29, + 0x37, 0x54, 0xB3, 0x40, 0x6F, 0xA5, 0x13, 0xF6, + 0x34, 0x02, 0xF7, 0xDA, 0xD6, 0x3E, 0xD4, 0x29, + 0xE1, 0x3D, 0x49, 0x89, 0x29, 0xC7, 0xCD, 0xC1, + 0xC0, 0x0D, 0xEF, 0x06, 0x8A, 0x76, 0x86, 0xC0, + 0x86, 0x30, 0xB4, 0x5F, 0x11, 0x2B, 0xCC, 0xE4, + 0x0A, 0x97, 0x31, 0xD9, 0xC4, 0xA7, 0x93, 0xE4, + 0x86, 0x6C, 0x94, 0x57, 0xB9, 0x37, 0xFA, 0x24 + }, + { + 0x16, 0xAA, 0xAA, 0x21, 0x5D, 0x2F, 0x1B, 0x59, + 0x74, 0x59, 0xA0, 0x2A, 0xC5, 0x5E, 0xB1, 0x6F, + 0x80, 0x6C, 0xAD, 0xE8, 0xB5, 0x2F, 0x5C, 0xE0, + 0xEE, 0x7C, 0xDB, 0x7A, 0x00, 0x3A, 0x70, 0xDF, + 0x36, 0xC8, 0xEC, 0x12, 0x62, 0x6E, 0xD2, 0x6D, + 0xB5, 0xDA, 0xEB, 0xFA, 0xAE, 0xFB, 0xAA, 0xA9, + 0xD0, 0xDC, 0x84, 0xDB, 0x52, 0x47, 0x3F, 0xDC, + 0xFF, 0xD2, 0x96, 0xC5, 0x5A, 0xB7, 0xB8, 0x19 + }, + { + 0x8D, 0xEA, 0xA4, 0xEE, 0x85, 0xFA, 0x35, 0x99, + 0xE9, 0x18, 0xBD, 0xB0, 0xD0, 0x25, 0xB5, 0xC3, + 0xF0, 0x65, 0x51, 0xEE, 0xA4, 0xC6, 0xB6, 0xF9, + 0xC9, 0x96, 0xBE, 0x1C, 0x14, 0xB6, 0x7C, 0x27, + 0xA5, 0xD4, 0x10, 0x86, 0x5E, 0x01, 0xF9, 0x35, + 0x71, 0x7A, 0xEF, 0xC4, 0x8D, 0x84, 0xB6, 0x96, + 0x24, 0xFE, 0x7B, 0x39, 0xA6, 0xA3, 0xF8, 0x1C, + 0x31, 0x31, 0xC2, 0x5A, 0xCC, 0xB3, 0x3F, 0x51 + }, + { + 0xA0, 0x2C, 0x1D, 0x86, 0x4B, 0x34, 0x4A, 0xD5, + 0x64, 0xD1, 0xF4, 0xE8, 0x1E, 0xDB, 0xA9, 0x2B, + 0xBC, 0xE1, 0x21, 0xE0, 0x65, 0x1B, 0xBE, 0xF5, + 0xCE, 0x0A, 0x70, 0xCC, 0x34, 0x35, 0xE7, 0x8A, + 0xAF, 0x92, 0xF0, 0x6E, 0x66, 0x0A, 0xCA, 0x15, + 0x2D, 0x5B, 0xFA, 0x02, 0x4A, 0xF4, 0x8B, 0x5D, + 0x78, 0xAB, 0xDC, 0xB4, 0xDB, 0x22, 0x05, 0x2F, + 0x09, 0x82, 0xD5, 0x83, 0x98, 0xB2, 0xF5, 0x91 + }, + { + 0xF2, 0xFE, 0x21, 0x0D, 0xA7, 0xB2, 0x03, 0x87, + 0x4C, 0x8E, 0xC4, 0x29, 0xCE, 0xBC, 0xE8, 0x81, + 0x45, 0x08, 0x98, 0x2D, 0x01, 0x29, 0xBE, 0x7F, + 0x94, 0x45, 0x5C, 0x51, 0xD4, 0x79, 0x18, 0xCC, + 0x83, 0x82, 0x84, 0x71, 0x0A, 0x7D, 0x15, 0xB4, + 0x84, 0x42, 0x34, 0xD3, 0xBE, 0x19, 0x40, 0xE4, + 0x70, 0x6A, 0xB8, 0x30, 0x18, 0xFC, 0x10, 0xA6, + 0x8E, 0x95, 0x4D, 0x11, 0xC5, 0x09, 0xE3, 0x07 + }, + { + 0x5B, 0x97, 0xF0, 0x33, 0x9C, 0xC6, 0x6A, 0xE7, + 0x99, 0xCA, 0x84, 0xCA, 0xF3, 0x80, 0x16, 0x36, + 0x6F, 0x83, 0x18, 0x72, 0x42, 0xE5, 0x9C, 0xF4, + 0x32, 0x0D, 0xCD, 0x6F, 0x39, 0x2A, 0x0E, 0x9D, + 0x6D, 0xEB, 0x35, 0x26, 0x64, 0x3F, 0xA7, 0xE5, + 0xA3, 0x88, 0xCF, 0xE5, 0x61, 0x9A, 0x79, 0xC6, + 0xF0, 0x61, 0xD4, 0x38, 0xC4, 0x92, 0x6E, 0x6A, + 0xD4, 0x58, 0xB8, 0x74, 0x74, 0xBA, 0x6A, 0x86 + }, + { + 0x56, 0x90, 0x08, 0x77, 0xF7, 0x6E, 0x90, 0x82, + 0xB8, 0x70, 0x0E, 0x42, 0x58, 0xE1, 0x11, 0xE6, + 0x50, 0xDA, 0xDD, 0x7E, 0x02, 0x44, 0x0C, 0x49, + 0xA1, 0xC0, 0x5A, 0xC1, 0x81, 0xC1, 0xDA, 0x46, + 0x46, 0x3B, 0x96, 0xD8, 0xE3, 0x51, 0xFB, 0x35, + 0x95, 0x66, 0x9B, 0x69, 0x15, 0x0B, 0x28, 0xD2, + 0x10, 0x38, 0x18, 0xF9, 0x04, 0x18, 0xC0, 0x5E, + 0xCF, 0x20, 0x02, 0x81, 0x64, 0x26, 0x99, 0x91 + }, + { + 0x59, 0xA3, 0x00, 0x0D, 0xCD, 0x8C, 0x99, 0xAB, + 0xBD, 0x64, 0x12, 0x90, 0xDE, 0x8A, 0xAD, 0x78, + 0xDC, 0x0C, 0x2D, 0x97, 0x54, 0x06, 0x41, 0xFA, + 0xAF, 0xEE, 0xC8, 0x82, 0x2E, 0xD4, 0x56, 0xAD, + 0x54, 0xD0, 0x99, 0xA6, 0x3E, 0x17, 0x9B, 0x3D, + 0x7B, 0x76, 0xD8, 0x45, 0x63, 0xF5, 0x80, 0xC7, + 0x15, 0xA1, 0xB1, 0xA7, 0x19, 0x57, 0x63, 0xF4, + 0x75, 0xB1, 0xD8, 0xBC, 0x7B, 0x32, 0xBF, 0x48 + }, + { + 0xE7, 0x68, 0xFC, 0x47, 0x24, 0x42, 0x24, 0x43, + 0xE4, 0xB3, 0x74, 0x41, 0x0A, 0x07, 0x84, 0x19, + 0xB5, 0x16, 0xD5, 0x81, 0xC0, 0xC5, 0xF7, 0x4E, + 0xEC, 0x56, 0xAE, 0xCD, 0x80, 0xDB, 0x0E, 0x1F, + 0x04, 0xD8, 0x89, 0xB2, 0x8C, 0xC1, 0xD4, 0x9B, + 0x04, 0x75, 0xDD, 0xD6, 0x74, 0x07, 0x6A, 0xAF, + 0xDA, 0xE0, 0x83, 0xFD, 0x26, 0xC9, 0x39, 0x74, + 0x9D, 0xB4, 0x8D, 0x7F, 0xDB, 0x8F, 0x02, 0xD8 + }, + { + 0x81, 0x7F, 0x79, 0x6C, 0xED, 0x45, 0x18, 0x51, + 0x94, 0xB1, 0x15, 0xDF, 0xC1, 0x6A, 0x05, 0x1F, + 0xF3, 0x43, 0xB5, 0x87, 0xE1, 0x29, 0x15, 0x4A, + 0xAE, 0x81, 0xE5, 0x8F, 0x37, 0x76, 0xC6, 0x67, + 0x26, 0x0D, 0xCC, 0x81, 0x23, 0x7A, 0x1A, 0x36, + 0x20, 0xD2, 0x0B, 0x10, 0xE1, 0x40, 0x31, 0xE4, + 0x68, 0xE4, 0xE2, 0xAD, 0x5C, 0x8D, 0x1B, 0xD7, + 0x0C, 0x23, 0x2B, 0x10, 0x94, 0x80, 0x52, 0x4C + }, + { + 0x75, 0x74, 0x96, 0xB7, 0x9C, 0x90, 0x3D, 0x53, + 0x8E, 0x97, 0x18, 0x82, 0x9C, 0xA2, 0x8D, 0x2C, + 0x3B, 0xAE, 0xAC, 0xCE, 0x5C, 0x93, 0xE4, 0xEF, + 0x42, 0x11, 0xF5, 0x85, 0x3B, 0xB0, 0xAF, 0xC9, + 0x55, 0xC7, 0x84, 0xAE, 0x8E, 0x80, 0xFC, 0x2B, + 0xBA, 0x61, 0x25, 0x90, 0x63, 0x07, 0x17, 0x90, + 0xB8, 0x7B, 0xCE, 0x8E, 0xF3, 0xF9, 0x8C, 0x47, + 0xD5, 0x09, 0xB0, 0x31, 0x3F, 0xC9, 0x74, 0xC5 + }, + { + 0xFE, 0xAC, 0x6A, 0xF2, 0xD4, 0x32, 0x72, 0xD0, + 0xC1, 0xB2, 0xEB, 0x70, 0xBA, 0xD6, 0xFF, 0xF7, + 0xD2, 0xA2, 0xB2, 0x9C, 0xE0, 0xFE, 0x97, 0x55, + 0xAB, 0xE4, 0x83, 0x83, 0x88, 0x48, 0xB8, 0x5E, + 0x18, 0x11, 0x28, 0x0A, 0x59, 0xA1, 0x53, 0xCE, + 0x68, 0xDF, 0x99, 0xEE, 0x0F, 0x25, 0xA0, 0x62, + 0x1B, 0x58, 0x4C, 0x36, 0x86, 0x51, 0xDA, 0x97, + 0xDE, 0x99, 0x48, 0x06, 0x8E, 0xF1, 0xAF, 0x3A + }, + { + 0x4C, 0x1E, 0xE9, 0xA0, 0x57, 0xA7, 0x93, 0xFD, + 0xBE, 0x7C, 0x12, 0x5E, 0xBF, 0xEF, 0x76, 0xB6, + 0x59, 0x9B, 0x7D, 0xF0, 0xB7, 0xA6, 0xBD, 0x17, + 0x3A, 0xD7, 0xB4, 0x8C, 0x79, 0xE5, 0x02, 0xCA, + 0x54, 0x5F, 0x87, 0xC5, 0xC5, 0x06, 0xB1, 0x0F, + 0x1A, 0xB2, 0xB2, 0x7D, 0x05, 0x5C, 0xEF, 0xB9, + 0x1C, 0x00, 0xCA, 0x4D, 0xD0, 0x2B, 0x52, 0x3F, + 0x97, 0x4D, 0x2E, 0x15, 0x4A, 0xAD, 0x4A, 0xD8 + }, + { + 0x5A, 0x3F, 0x11, 0x5B, 0xDB, 0x6D, 0xA5, 0x9C, + 0x65, 0xAD, 0x82, 0x56, 0x11, 0xAD, 0x0B, 0xA4, + 0x1C, 0xC4, 0xF2, 0x78, 0x52, 0xD8, 0x2D, 0x20, + 0xA5, 0x25, 0x22, 0xD7, 0x3F, 0xB4, 0xC9, 0xA1, + 0x8B, 0x34, 0xD4, 0x0C, 0xFF, 0xBE, 0x46, 0x89, + 0x92, 0x5E, 0xE7, 0xC7, 0x74, 0x55, 0xF4, 0x5A, + 0x55, 0xB6, 0x29, 0x73, 0x13, 0x16, 0x6E, 0x7A, + 0x28, 0x86, 0x0F, 0xCF, 0xA6, 0x6E, 0xE1, 0x22 + }, + { + 0xFA, 0x60, 0x4C, 0xB7, 0x93, 0x3C, 0xDE, 0x6A, + 0x08, 0xA2, 0x25, 0xA9, 0x3E, 0x2C, 0x7C, 0xEF, + 0xE5, 0x33, 0x4A, 0xF6, 0x93, 0x0A, 0x51, 0x25, + 0x09, 0x51, 0xA6, 0xAD, 0x51, 0x72, 0x0A, 0x07, + 0x83, 0x1A, 0x50, 0x3D, 0xC5, 0x8C, 0x40, 0x5E, + 0xDF, 0x81, 0xE9, 0x76, 0xFA, 0x5A, 0xA0, 0x11, + 0x96, 0xB6, 0xAD, 0x69, 0x19, 0x05, 0xB1, 0x46, + 0x5E, 0x78, 0x13, 0xD7, 0xCC, 0xF4, 0xEA, 0x49 + }, + { + 0x97, 0x87, 0xB2, 0x7E, 0x19, 0x70, 0x50, 0x31, + 0x94, 0x0A, 0xCF, 0x74, 0x7C, 0xD8, 0x3F, 0x57, + 0x75, 0xFF, 0xCB, 0xEB, 0xE6, 0xE9, 0x8B, 0x35, + 0xE7, 0x4E, 0xBC, 0xCA, 0x0F, 0x4F, 0xEF, 0x99, + 0x23, 0xF0, 0x89, 0xD5, 0x60, 0xAD, 0x70, 0xDB, + 0xE3, 0x8F, 0x8F, 0x04, 0x13, 0xCD, 0x60, 0xEC, + 0x4F, 0x0F, 0xA0, 0xE6, 0xE7, 0x91, 0xFE, 0x1E, + 0x0C, 0x8D, 0xA3, 0x2A, 0x2C, 0x9F, 0x07, 0x65 + }, + { + 0x00, 0xA4, 0x7E, 0xD5, 0x67, 0x71, 0x9D, 0x26, + 0xDD, 0xD8, 0xBA, 0x04, 0xE3, 0x57, 0xDC, 0x5D, + 0x43, 0x6F, 0x81, 0x80, 0xCB, 0xDD, 0x0E, 0x07, + 0xEA, 0x54, 0xF6, 0xAF, 0x7C, 0x72, 0xD6, 0xF1, + 0x14, 0x46, 0x82, 0x15, 0xAD, 0x03, 0x16, 0x90, + 0xCF, 0x7E, 0x90, 0x48, 0xBA, 0xDF, 0xF2, 0xBA, + 0x5A, 0x17, 0xE2, 0xCF, 0x25, 0x9F, 0x31, 0x49, + 0xCD, 0x85, 0xDB, 0x3C, 0x56, 0x76, 0x59, 0xC3 + }, + { + 0x26, 0x0B, 0x07, 0xCE, 0x3F, 0x48, 0x66, 0x4C, + 0xCA, 0xD9, 0x36, 0xAB, 0x52, 0x73, 0x73, 0x64, + 0x42, 0x29, 0x06, 0x5C, 0x6A, 0x0E, 0xB2, 0x3E, + 0xFB, 0x39, 0xBE, 0xE2, 0x3C, 0xDD, 0x1B, 0x9C, + 0x60, 0x90, 0x01, 0xB0, 0xBC, 0x0F, 0x78, 0xEE, + 0xA3, 0x59, 0x61, 0x24, 0x98, 0xB7, 0xA1, 0x3C, + 0xAD, 0xAA, 0x50, 0x6B, 0x30, 0x45, 0x99, 0x40, + 0x3E, 0x30, 0xA7, 0x7D, 0x35, 0xC7, 0x59, 0x3B + }, + { + 0x67, 0x20, 0x2B, 0xF6, 0x24, 0x67, 0x13, 0x54, + 0x0D, 0x8A, 0xA4, 0x31, 0x75, 0x81, 0xC0, 0xBC, + 0xF9, 0xC2, 0x35, 0x37, 0x23, 0xF3, 0x13, 0xBB, + 0xD9, 0x7A, 0xF6, 0x4F, 0xEF, 0x90, 0x90, 0xDF, + 0x35, 0x3F, 0x30, 0xFB, 0x38, 0x4F, 0x45, 0xFB, + 0x0E, 0x18, 0x28, 0x4A, 0xBB, 0x48, 0x20, 0x40, + 0xE2, 0x6F, 0x25, 0x43, 0x88, 0x05, 0xC8, 0x89, + 0x5A, 0x4B, 0xE9, 0xBA, 0xA0, 0x26, 0xEB, 0x6B + }, + { + 0xBC, 0xAF, 0x1E, 0x23, 0x17, 0x93, 0x39, 0x42, + 0xB8, 0xF8, 0x99, 0x31, 0x02, 0x75, 0x03, 0xD7, + 0x47, 0x7A, 0x52, 0x7E, 0x56, 0xDF, 0xA6, 0xEA, + 0xED, 0x81, 0xBB, 0x90, 0x77, 0x54, 0x22, 0x48, + 0x40, 0x03, 0x7A, 0xB2, 0x12, 0x02, 0xAB, 0xBE, + 0xF0, 0x5A, 0x87, 0xD6, 0xD6, 0x3A, 0x5F, 0x7B, + 0x0F, 0xB8, 0x8D, 0xFE, 0xFE, 0x19, 0x1E, 0x95, + 0x42, 0x4F, 0xDD, 0xCB, 0xDE, 0xDC, 0x53, 0xA8 + }, + { + 0xDB, 0xBC, 0xD0, 0x5B, 0x7D, 0xDA, 0x8C, 0x1F, + 0xDA, 0x31, 0xAA, 0x27, 0x62, 0x73, 0x2B, 0x96, + 0x11, 0xA8, 0xAE, 0x0F, 0xDD, 0x51, 0x5D, 0xAB, + 0x34, 0xB5, 0x10, 0xA6, 0x93, 0xA1, 0x90, 0x2B, + 0x62, 0x26, 0xE1, 0x83, 0x34, 0xF9, 0xAE, 0xCD, + 0x18, 0xB1, 0xDA, 0xB1, 0x6A, 0x53, 0x2A, 0xD5, + 0xA8, 0xA4, 0x2E, 0x7E, 0x14, 0x98, 0x71, 0x6B, + 0x08, 0x70, 0x9D, 0x99, 0xD3, 0x2A, 0xAA, 0xF7 + }, + { + 0xAC, 0x79, 0xF6, 0x7F, 0xC2, 0x32, 0xB4, 0x2D, + 0x5F, 0xB3, 0x9E, 0xF8, 0x9E, 0xBB, 0xE5, 0x78, + 0x52, 0x86, 0xA5, 0x22, 0x3E, 0x19, 0xB3, 0x1B, + 0xD1, 0x76, 0xD0, 0x82, 0x37, 0x5B, 0xEB, 0xB2, + 0x77, 0x36, 0x3B, 0x7D, 0x00, 0x8F, 0x4F, 0x4A, + 0x0D, 0xC9, 0xF7, 0x9F, 0xE0, 0x34, 0x4E, 0x31, + 0x98, 0x2C, 0xF4, 0xE5, 0x72, 0x48, 0x9F, 0x71, + 0x0E, 0x3D, 0x4D, 0x4A, 0x67, 0x91, 0xC3, 0x31 + }, + { + 0xBB, 0x5F, 0x31, 0x59, 0x2A, 0xA9, 0xA8, 0x26, + 0xA3, 0x9A, 0x35, 0x2F, 0x3A, 0x4C, 0xF7, 0xFC, + 0xE4, 0x3C, 0x34, 0xD4, 0x54, 0x1C, 0xB4, 0x66, + 0xF7, 0xD1, 0xC7, 0x0B, 0x04, 0xC6, 0xDD, 0x78, + 0x1B, 0x9B, 0x81, 0xFD, 0xE9, 0x63, 0xD0, 0xE4, + 0x20, 0x03, 0x70, 0x91, 0x64, 0x6E, 0xEF, 0xB3, + 0x8C, 0x6E, 0x22, 0xAA, 0x87, 0xBF, 0x97, 0xD0, + 0x5E, 0x79, 0xEF, 0x09, 0x03, 0xF7, 0x05, 0x91 + }, + { + 0x2F, 0x0D, 0xB1, 0x3C, 0x00, 0x1E, 0x4C, 0xD6, + 0xDF, 0xDB, 0x07, 0xE6, 0xEC, 0xD4, 0xD7, 0x26, + 0x53, 0x9B, 0x15, 0x15, 0x37, 0x09, 0x16, 0x40, + 0xB2, 0xF0, 0xE2, 0x63, 0xDB, 0xC9, 0xFF, 0xD3, + 0x2F, 0x6B, 0xAC, 0xD9, 0xC9, 0x8A, 0xD5, 0xF5, + 0x97, 0x2D, 0x87, 0x5D, 0x0A, 0x9D, 0x28, 0x9A, + 0xB5, 0x15, 0x4B, 0xC7, 0x90, 0xB0, 0xCD, 0xE5, + 0xD6, 0xD3, 0xB8, 0xBF, 0xCC, 0x54, 0xD4, 0xEA + }, + { + 0x6C, 0x9C, 0x5B, 0x3C, 0x03, 0x8F, 0x04, 0x03, + 0x07, 0x5B, 0xD6, 0x50, 0x50, 0xA0, 0x3C, 0x31, + 0xDE, 0xA1, 0x74, 0x31, 0xB9, 0xD4, 0x4E, 0x7F, + 0x39, 0xC3, 0xB6, 0xD0, 0xA3, 0x1C, 0x87, 0x56, + 0xFA, 0xE4, 0xAA, 0x40, 0xDB, 0xF3, 0x85, 0x8F, + 0x21, 0xEF, 0x82, 0x50, 0x90, 0x54, 0xBF, 0x98, + 0xE1, 0xAE, 0xF3, 0xB9, 0x8D, 0xAC, 0xC1, 0x7D, + 0x1B, 0xE8, 0xE0, 0xEB, 0x46, 0x83, 0x1A, 0xAE + }, + { + 0x1D, 0x68, 0x1E, 0x1F, 0xFA, 0x63, 0x06, 0x10, + 0xC8, 0xBB, 0x19, 0x26, 0x21, 0x93, 0xD9, 0xEE, + 0xC4, 0x33, 0x5C, 0x6D, 0x9F, 0x3E, 0x8C, 0xE7, + 0xE8, 0xF2, 0x03, 0x5A, 0xD6, 0xAC, 0xAC, 0xB1, + 0x2D, 0x2A, 0x10, 0x87, 0x32, 0x20, 0x87, 0x72, + 0xCE, 0x6D, 0xC7, 0x90, 0xBA, 0x86, 0x41, 0xED, + 0x7B, 0x48, 0x43, 0x1F, 0xD4, 0x54, 0x40, 0x9E, + 0xF7, 0xC2, 0xEB, 0x81, 0x61, 0xA3, 0x27, 0x2F + }, + { + 0x68, 0xE1, 0xB8, 0xDD, 0x01, 0xD1, 0xFA, 0x24, + 0x0B, 0x05, 0xCF, 0x06, 0xAB, 0x89, 0x36, 0x24, + 0xC5, 0x43, 0x25, 0xDE, 0x47, 0xB1, 0xA9, 0xFA, + 0xBB, 0x42, 0x12, 0x92, 0xD7, 0x30, 0x45, 0x7B, + 0x74, 0x45, 0xFA, 0x68, 0xEA, 0x06, 0x0C, 0x8E, + 0xF5, 0x1B, 0xAE, 0xD3, 0x62, 0x5C, 0x83, 0xE8, + 0x7E, 0x73, 0x15, 0x53, 0xEE, 0x72, 0xAD, 0x4E, + 0x09, 0x5D, 0x66, 0xEC, 0xD5, 0x10, 0xEF, 0x6C + }, + { + 0xCB, 0xCE, 0xBC, 0x03, 0x77, 0xA7, 0xEE, 0xC4, + 0x57, 0x4B, 0x74, 0xA5, 0x0B, 0x1D, 0x51, 0xB5, + 0x2B, 0xA4, 0x14, 0x20, 0x0B, 0x0B, 0x92, 0xE1, + 0x8E, 0xDE, 0x72, 0x06, 0x55, 0x81, 0x0E, 0xD6, + 0xFF, 0x87, 0x48, 0xAC, 0x78, 0x24, 0x54, 0x71, + 0x83, 0x1E, 0xE6, 0xBA, 0x38, 0x57, 0x4C, 0x95, + 0x54, 0x14, 0x2B, 0x5D, 0xD8, 0xE3, 0x67, 0x16, + 0xEF, 0xE9, 0x4B, 0x28, 0x57, 0x14, 0xC8, 0x51 + }, + { + 0x95, 0x4A, 0x54, 0x06, 0x43, 0x9E, 0x31, 0x2F, + 0xB4, 0x45, 0x86, 0xF5, 0xBE, 0x28, 0x4A, 0xC8, + 0x10, 0x4E, 0x6B, 0xD2, 0x6D, 0x4D, 0x26, 0xAF, + 0x3D, 0x00, 0x23, 0xB4, 0x90, 0xFC, 0x98, 0xF3, + 0x00, 0x26, 0x2D, 0xE2, 0xDB, 0x5C, 0xE1, 0xC1, + 0x24, 0xB8, 0xEA, 0x07, 0xB1, 0xDC, 0x12, 0xF1, + 0xA0, 0xA9, 0x13, 0xA9, 0x16, 0x8C, 0x01, 0xCB, + 0x96, 0xA0, 0x56, 0x24, 0xA7, 0x55, 0xC3, 0x77 + }, + { + 0x08, 0xE6, 0xF5, 0x28, 0x28, 0x1D, 0x8E, 0xFE, + 0xDA, 0x06, 0x66, 0xEB, 0x7D, 0xD3, 0xF0, 0x27, + 0x02, 0x8C, 0x9F, 0x40, 0xDE, 0x4B, 0x10, 0x15, + 0x2D, 0xEF, 0x39, 0x1B, 0x4A, 0x68, 0xEC, 0xC9, + 0xE4, 0x95, 0xD8, 0x27, 0x99, 0x33, 0x5A, 0x5D, + 0x0E, 0x4E, 0xAB, 0x64, 0x23, 0x4D, 0x0B, 0x4B, + 0x29, 0xAF, 0xAD, 0xD0, 0x1E, 0x2C, 0x38, 0xBA, + 0xBF, 0x84, 0x1E, 0xE2, 0xFE, 0x62, 0x07, 0xF6 + }, + { + 0x19, 0x89, 0x29, 0x5D, 0x3D, 0xB4, 0x05, 0xE5, + 0x34, 0xFE, 0x75, 0x6E, 0x0D, 0xFF, 0x54, 0x85, + 0x7D, 0x28, 0x15, 0x4E, 0xDA, 0x6C, 0x6E, 0x2F, + 0xE0, 0xFA, 0x26, 0x0D, 0x6D, 0x48, 0xA7, 0x27, + 0x66, 0xC7, 0x0A, 0x56, 0xA4, 0xA9, 0xE7, 0x10, + 0xD5, 0xF4, 0xC3, 0x6D, 0xC1, 0xAD, 0x81, 0x84, + 0x79, 0x94, 0xED, 0x1E, 0x0E, 0x2E, 0xCD, 0xD3, + 0x56, 0xB1, 0x9B, 0xD2, 0x87, 0x7B, 0x9C, 0x81 + }, + { + 0xDB, 0x95, 0xD8, 0x00, 0x98, 0x5E, 0x44, 0x47, + 0xEE, 0x51, 0x50, 0x06, 0x09, 0x70, 0xDF, 0xFD, + 0x64, 0x16, 0x50, 0x36, 0x1A, 0xCB, 0x2E, 0xB3, + 0x5D, 0xB7, 0x12, 0x01, 0xA9, 0x97, 0x2A, 0xF2, + 0x39, 0x72, 0xB8, 0x5B, 0x5E, 0x77, 0x24, 0x30, + 0xF6, 0xEF, 0xC9, 0x49, 0x33, 0xEB, 0xDC, 0xD5, + 0x19, 0x97, 0xC8, 0x8B, 0x7B, 0xF1, 0xBF, 0xBC, + 0x9E, 0xA0, 0x8D, 0x9C, 0xF0, 0xF9, 0xA9, 0x75 + }, + { + 0x9D, 0x85, 0xFF, 0x49, 0x25, 0xD0, 0xDF, 0xDD, + 0x73, 0x2A, 0xCA, 0xE5, 0x36, 0xC7, 0x09, 0x6C, + 0x34, 0xFC, 0xB9, 0xA7, 0x8E, 0xA0, 0x8B, 0x89, + 0xD7, 0x12, 0x1F, 0x14, 0x5F, 0x9D, 0x64, 0xD5, + 0x9A, 0xBA, 0xC3, 0x5D, 0xB7, 0xD5, 0x3B, 0x20, + 0x5A, 0xDB, 0x81, 0x69, 0xDB, 0xCB, 0xF3, 0xE7, + 0xAD, 0xFE, 0x3E, 0xF2, 0xC8, 0xA1, 0xF8, 0x57, + 0x90, 0xCA, 0xFD, 0xF8, 0xBE, 0xC1, 0x79, 0xA6 + }, + { + 0x09, 0x57, 0x40, 0xD0, 0xD9, 0xDF, 0xF1, 0x3E, + 0xA6, 0xE2, 0x16, 0x21, 0x64, 0x2C, 0xD2, 0x6E, + 0x9D, 0xF8, 0x77, 0xB6, 0xFD, 0xE2, 0x01, 0xCF, + 0xE2, 0xD0, 0x1D, 0x05, 0x99, 0x3F, 0xA5, 0x24, + 0x73, 0x62, 0x57, 0x04, 0xC1, 0x63, 0xE8, 0x95, + 0x7B, 0x98, 0xB6, 0xEE, 0x1C, 0x0C, 0x8C, 0xCB, + 0xFC, 0xAE, 0x65, 0x30, 0x49, 0x6C, 0x30, 0x62, + 0x04, 0xB9, 0x0C, 0xBB, 0xC6, 0x4A, 0xBA, 0x03 + }, + { + 0x26, 0xC6, 0x2B, 0x5E, 0x7D, 0x42, 0x27, 0x6A, + 0x82, 0x2F, 0x78, 0x71, 0x67, 0x31, 0x0D, 0x46, + 0x16, 0x0B, 0x9E, 0xA4, 0x5A, 0x46, 0x13, 0x95, + 0x58, 0x67, 0xEB, 0xDF, 0x51, 0xB1, 0x7C, 0x14, + 0x30, 0x4D, 0x51, 0x2E, 0x10, 0xB1, 0x29, 0x9F, + 0x97, 0xFC, 0x2D, 0x3B, 0xC7, 0xB6, 0x0B, 0xBE, + 0x37, 0x22, 0xBC, 0x9A, 0x4B, 0xD1, 0xB2, 0x3B, + 0x4F, 0xC4, 0xD6, 0xA2, 0x3E, 0xED, 0x83, 0xA7 + }, + { + 0x64, 0x4D, 0xC6, 0xC3, 0xC5, 0xE8, 0xA5, 0xC4, + 0x00, 0x03, 0x49, 0x2F, 0xCA, 0xDC, 0xDD, 0x19, + 0xC6, 0x97, 0xF2, 0x04, 0x81, 0xC9, 0xF4, 0x16, + 0x1C, 0x21, 0xBD, 0xA4, 0xA6, 0xA2, 0x67, 0x1A, + 0x1B, 0x65, 0x0D, 0x90, 0x93, 0xF4, 0xAC, 0x0B, + 0xCB, 0x3F, 0xEB, 0xA2, 0x3B, 0x37, 0x8F, 0x3B, + 0xBA, 0x5A, 0x9D, 0xB0, 0xD7, 0xD4, 0x05, 0xDD, + 0x36, 0xE3, 0x1E, 0xC1, 0x97, 0x51, 0x6C, 0x8F + }, + { + 0x0D, 0x88, 0x96, 0x1E, 0xCC, 0x35, 0x0B, 0x83, + 0xD4, 0xED, 0xE8, 0x31, 0xB7, 0xC7, 0x12, 0x4C, + 0x4D, 0x11, 0xB4, 0x06, 0xA5, 0x4B, 0xF3, 0x1D, + 0xBD, 0xED, 0xB6, 0x2C, 0x96, 0xC2, 0x1A, 0xD9, + 0x98, 0x22, 0x7D, 0x3F, 0x37, 0xF2, 0x58, 0x98, + 0x11, 0x01, 0xA9, 0x0E, 0xD5, 0x17, 0x3A, 0x00, + 0x89, 0xA6, 0x18, 0xAA, 0x4D, 0xEC, 0x2A, 0xD7, + 0xDC, 0x71, 0xFE, 0xB0, 0xD0, 0x2B, 0x3E, 0x60 + }, + { + 0x01, 0xF5, 0xB5, 0x50, 0xFB, 0x8D, 0x27, 0xAD, + 0x0B, 0x47, 0x34, 0x5B, 0x4E, 0x01, 0x76, 0xC5, + 0xE9, 0xEA, 0xD2, 0xFE, 0xE3, 0x1B, 0xF5, 0x9A, + 0x76, 0x1A, 0xF9, 0x4B, 0x63, 0x1E, 0x9F, 0x90, + 0xA4, 0x8F, 0xD4, 0xCD, 0x3D, 0x59, 0xFD, 0x07, + 0x7A, 0x52, 0x8D, 0x05, 0x9C, 0xAA, 0xE5, 0x19, + 0xE0, 0x15, 0x45, 0x17, 0x1F, 0x2A, 0xC1, 0x36, + 0x76, 0x3C, 0xD1, 0x26, 0x8F, 0x41, 0x02, 0x1E + }, + { + 0xEC, 0x96, 0xF8, 0xE1, 0xF0, 0x6D, 0xF5, 0xB6, + 0xD9, 0x65, 0xD1, 0x82, 0x2F, 0x56, 0xE8, 0x7E, + 0x86, 0x6E, 0xB6, 0x81, 0x57, 0x1C, 0xD5, 0x2B, + 0xE0, 0xCB, 0xCC, 0xC3, 0xEE, 0x54, 0xBD, 0xEA, + 0x56, 0x06, 0x6F, 0x98, 0x36, 0xA5, 0xA3, 0x88, + 0xA4, 0xDC, 0xD9, 0x2C, 0xE1, 0x5D, 0xE8, 0xE0, + 0x73, 0x7F, 0x1F, 0x03, 0x94, 0x27, 0x98, 0x37, + 0xAF, 0xCC, 0x6E, 0x28, 0x14, 0x5B, 0x0F, 0xF3 + }, + { + 0x73, 0x22, 0xDA, 0xDE, 0xE1, 0x73, 0x35, 0xB7, + 0x47, 0xA6, 0xA2, 0xAD, 0xD4, 0xD6, 0x4D, 0x68, + 0xB0, 0xEA, 0x4C, 0xDD, 0x84, 0xB6, 0xE0, 0xDA, + 0x53, 0xA5, 0xFE, 0x9B, 0xB6, 0x52, 0xE1, 0x80, + 0x20, 0x3D, 0x87, 0xB8, 0xD9, 0x3E, 0x57, 0x73, + 0x4D, 0x68, 0xEA, 0x78, 0xEF, 0xD3, 0xA9, 0xF0, + 0xFB, 0xC0, 0x12, 0xC5, 0x2A, 0xF9, 0x04, 0xD0, + 0x44, 0x7C, 0xBF, 0x2A, 0x6E, 0x4F, 0xFC, 0xD9 + }, + { + 0x9F, 0x0A, 0x1D, 0xB7, 0xFA, 0xF4, 0xC2, 0xF5, + 0xA4, 0x06, 0x40, 0x6B, 0x97, 0xBA, 0x11, 0x8B, + 0xF6, 0x37, 0xC6, 0xCD, 0x1E, 0x93, 0xC9, 0x4D, + 0x44, 0x41, 0x3A, 0xDF, 0xE9, 0xBB, 0x78, 0x12, + 0x1E, 0x56, 0x1A, 0xFF, 0xB5, 0xA0, 0x54, 0xF6, + 0x5F, 0x37, 0xBC, 0xE0, 0xF7, 0x77, 0xE6, 0x54, + 0xB2, 0x82, 0xC9, 0x40, 0xB0, 0x34, 0x1C, 0x3E, + 0x83, 0x2E, 0x0D, 0x3F, 0xAC, 0x1F, 0xB4, 0x56 + }, + { + 0x73, 0xD9, 0x85, 0x13, 0xF7, 0x4F, 0x5B, 0xF7, + 0x68, 0xB4, 0x22, 0xCD, 0x9F, 0xCA, 0x24, 0x54, + 0x2B, 0x6E, 0x9A, 0x59, 0x7B, 0xCE, 0x2F, 0x62, + 0x90, 0x77, 0xBA, 0x41, 0x3F, 0x43, 0x0E, 0xC3, + 0x57, 0xCB, 0x09, 0x3E, 0x42, 0x17, 0xA6, 0x35, + 0x59, 0x05, 0xE2, 0x3B, 0x12, 0xCF, 0x1B, 0xA7, + 0x0B, 0x27, 0xD1, 0x66, 0x21, 0xF4, 0xF3, 0xB8, + 0xC0, 0xE1, 0x4C, 0x1A, 0x5C, 0xAC, 0xBF, 0x64 + }, + { + 0x59, 0xCA, 0xDE, 0xA2, 0xE1, 0x54, 0xE9, 0x18, + 0xB0, 0xAB, 0xDB, 0xFD, 0x2A, 0xA1, 0x72, 0x8A, + 0xC2, 0x71, 0xF5, 0xD5, 0x60, 0x15, 0xEC, 0x4B, + 0x5D, 0x18, 0x1B, 0xB9, 0x89, 0xBF, 0x60, 0x02, + 0xF6, 0x3E, 0x41, 0xAE, 0x4C, 0x3E, 0x38, 0x70, + 0xB7, 0x47, 0x20, 0xF0, 0x2A, 0xA8, 0x88, 0x04, + 0xA3, 0x6D, 0xC8, 0x3A, 0x46, 0xFF, 0x91, 0xB6, + 0x2E, 0xB2, 0x3A, 0x21, 0x3B, 0x3B, 0x8F, 0xD5 + }, + { + 0xA1, 0x7E, 0xD8, 0x86, 0xFA, 0xEC, 0x45, 0x51, + 0x89, 0xBA, 0xC7, 0x58, 0x48, 0xB3, 0x67, 0xC5, + 0x63, 0x35, 0xE1, 0xDE, 0xA7, 0xD7, 0xC4, 0x52, + 0x03, 0xA9, 0x2A, 0x1D, 0x51, 0x89, 0x12, 0xCC, + 0x9D, 0xC1, 0x33, 0x19, 0xA4, 0x36, 0x6B, 0x81, + 0x93, 0x16, 0xFC, 0x5A, 0x67, 0x45, 0xE8, 0xD2, + 0x36, 0x8D, 0xED, 0xF7, 0x8B, 0x51, 0xD8, 0x14, + 0x63, 0x4C, 0x87, 0x1F, 0x80, 0xA3, 0x79, 0xDB + }, + { + 0x77, 0xBD, 0x0D, 0x0C, 0xC6, 0x8A, 0x2C, 0xD8, + 0x1D, 0xC0, 0xEC, 0x72, 0x56, 0x10, 0xEB, 0x7E, + 0x21, 0xA0, 0x37, 0xFA, 0x67, 0x99, 0x9E, 0xD1, + 0x5A, 0xAD, 0xA8, 0x45, 0xEC, 0x24, 0x5C, 0xF2, + 0x46, 0x02, 0x6F, 0xCE, 0x2D, 0xD3, 0xEC, 0xD5, + 0x29, 0x51, 0xB8, 0x1F, 0xF2, 0x44, 0x96, 0x9E, + 0x37, 0xE7, 0xA2, 0xA6, 0x22, 0x99, 0x33, 0x4A, + 0xF8, 0xF3, 0xAE, 0x88, 0x27, 0x7C, 0x6B, 0xD1 + }, + { + 0x37, 0x15, 0xF6, 0x81, 0x62, 0x35, 0xB0, 0x1B, + 0x6B, 0x16, 0x38, 0xB5, 0x6A, 0xB3, 0x65, 0xAC, + 0x82, 0x6D, 0xE3, 0xCE, 0x8D, 0x95, 0x2F, 0x17, + 0x04, 0xEC, 0xA5, 0x43, 0x1A, 0x17, 0x54, 0x35, + 0x27, 0x08, 0x89, 0x85, 0xC3, 0xD5, 0xE3, 0x95, + 0x8B, 0xFC, 0xC0, 0x61, 0x69, 0x9F, 0xDE, 0x63, + 0xB4, 0x0A, 0x5C, 0x41, 0x4E, 0xCD, 0x21, 0xC5, + 0x85, 0x65, 0xAB, 0x86, 0x87, 0x76, 0xFF, 0x4C + }, + { + 0x83, 0x40, 0xD4, 0x9F, 0xC0, 0x57, 0x8F, 0xFE, + 0xBA, 0x6C, 0xEA, 0x6C, 0x37, 0x6C, 0x5B, 0x42, + 0xB8, 0x90, 0x32, 0x87, 0x11, 0x03, 0x77, 0x12, + 0x16, 0x72, 0xAD, 0x5C, 0xC2, 0x54, 0x1B, 0xBD, + 0x99, 0x5C, 0xA3, 0xAE, 0x17, 0xA2, 0xBB, 0xC3, + 0x0F, 0x6E, 0x55, 0x65, 0x51, 0x1F, 0xC0, 0xAB, + 0xFE, 0x34, 0x30, 0x49, 0x54, 0xA6, 0xEB, 0xA9, + 0x72, 0xCE, 0xC3, 0x3A, 0xF9, 0x19, 0xDF, 0x34 + }, + { + 0x97, 0xB7, 0x21, 0x4C, 0xCE, 0xA9, 0x15, 0x66, + 0xB0, 0xD8, 0x18, 0x75, 0xAA, 0xB0, 0x1B, 0x0F, + 0x0A, 0x74, 0x7A, 0x8E, 0x2C, 0xBF, 0x29, 0x28, + 0xBC, 0x1C, 0x57, 0x2E, 0xCF, 0xB7, 0xDE, 0xED, + 0xB8, 0x1E, 0xEF, 0x53, 0xD8, 0x81, 0x82, 0xE3, + 0x15, 0x58, 0xF4, 0x8C, 0x56, 0x19, 0x50, 0x09, + 0xC7, 0x11, 0x1F, 0x69, 0xF3, 0x18, 0xB6, 0x3C, + 0x29, 0xAD, 0xB7, 0xC7, 0x8C, 0x37, 0x1E, 0x0B + }, + { + 0x08, 0x42, 0xC5, 0xFB, 0xE5, 0x48, 0xB5, 0xD0, + 0x82, 0x5C, 0xBB, 0x19, 0x28, 0xE0, 0x14, 0x0C, + 0x60, 0xA7, 0xAB, 0x98, 0x12, 0x9C, 0xDA, 0xFC, + 0xDD, 0x9F, 0xB6, 0xFF, 0xBC, 0x69, 0x86, 0x65, + 0x3F, 0xC2, 0x8A, 0x65, 0xED, 0x14, 0x77, 0x5D, + 0xCC, 0x01, 0x6E, 0xDA, 0x41, 0xB5, 0x3E, 0x62, + 0x1D, 0x07, 0x0A, 0x10, 0x90, 0x10, 0x37, 0x31, + 0x47, 0x42, 0x23, 0x31, 0x1C, 0xC5, 0x9D, 0x8C + }, + { + 0xA9, 0xEE, 0x2A, 0x52, 0x05, 0x30, 0xC6, 0x48, + 0x8F, 0xDC, 0xC4, 0xFF, 0xC2, 0xD5, 0x22, 0x5C, + 0x24, 0x6F, 0x0C, 0xEF, 0x8A, 0x2A, 0x10, 0x9B, + 0x9A, 0xE1, 0x26, 0x3F, 0x8E, 0x48, 0x78, 0xAA, + 0xD6, 0xA7, 0x2E, 0xB7, 0x93, 0x07, 0x7C, 0x42, + 0xBC, 0xEF, 0x13, 0xD8, 0x98, 0xEB, 0xB4, 0x6D, + 0xC7, 0x64, 0x8D, 0x02, 0x1E, 0x86, 0xB5, 0x72, + 0xD2, 0x18, 0xD3, 0x26, 0xA9, 0xAE, 0x85, 0x2B + }, + { + 0xCE, 0x1A, 0x3E, 0xA3, 0x95, 0x90, 0x7C, 0x3E, + 0x34, 0x8C, 0x5D, 0x98, 0xF6, 0x94, 0xAD, 0x71, + 0xA9, 0x0F, 0xC0, 0x72, 0xB0, 0xC0, 0x82, 0xCF, + 0xB9, 0x8B, 0x4B, 0xDA, 0xEE, 0xA4, 0xCB, 0xE3, + 0x52, 0x7E, 0x10, 0x9E, 0xB0, 0x28, 0x13, 0xEA, + 0x1B, 0x66, 0x2D, 0x01, 0xFB, 0x8D, 0x9F, 0x6C, + 0xCE, 0x45, 0x7C, 0xA2, 0xE3, 0xB7, 0x00, 0x52, + 0xC8, 0x47, 0x4F, 0x5F, 0x4C, 0x96, 0x4C, 0x2F + }, + { + 0x9A, 0x73, 0x51, 0x02, 0x38, 0x27, 0x9C, 0xE6, + 0xCD, 0x68, 0xD3, 0x69, 0x2C, 0xC9, 0x85, 0xA3, + 0x95, 0x2C, 0x10, 0x31, 0x15, 0x65, 0x9E, 0xEF, + 0x14, 0x25, 0x13, 0x39, 0x1C, 0x7F, 0x02, 0x26, + 0x18, 0xCC, 0x54, 0x81, 0xFE, 0xDD, 0x69, 0x24, + 0xF0, 0x57, 0xB8, 0xE5, 0x50, 0x4E, 0x4D, 0xEC, + 0x10, 0x94, 0x41, 0xE5, 0x7A, 0xEE, 0x09, 0x84, + 0x71, 0x02, 0x4C, 0x0A, 0xB9, 0xA3, 0xC3, 0x24 + }, + { + 0x70, 0x3E, 0xE6, 0x8C, 0xC0, 0xD3, 0x85, 0x21, + 0xDA, 0xE0, 0x2C, 0xD2, 0xB9, 0x73, 0x5D, 0x96, + 0x89, 0xF3, 0x17, 0xA5, 0x9F, 0xE2, 0xD3, 0x9B, + 0xF0, 0x17, 0x75, 0x32, 0x0C, 0xE8, 0x84, 0xA0, + 0x1B, 0x7F, 0x89, 0xBA, 0xD2, 0xB9, 0x7B, 0x13, + 0xF7, 0x06, 0xCF, 0xE9, 0x0F, 0x39, 0x2B, 0xAC, + 0x19, 0xCC, 0xE4, 0xEF, 0x6D, 0xA9, 0x07, 0x12, + 0x19, 0x6F, 0x00, 0xED, 0xFC, 0x38, 0x53, 0x1B + }, + { + 0xCC, 0xBD, 0x3F, 0xA7, 0x07, 0x53, 0x70, 0xC7, + 0x36, 0x9D, 0xE3, 0x94, 0x04, 0xAA, 0x1D, 0x63, + 0x97, 0xF9, 0x47, 0xCC, 0x1E, 0x53, 0x36, 0x1C, + 0x27, 0x68, 0xF4, 0x70, 0xA9, 0xF6, 0x1D, 0xAB, + 0x22, 0xF4, 0x84, 0xAC, 0xC4, 0xF3, 0x2B, 0x15, + 0x7E, 0xED, 0x08, 0x15, 0x92, 0xC8, 0x1F, 0x69, + 0x59, 0x98, 0x2C, 0x7E, 0xDB, 0x16, 0x5C, 0x05, + 0x8D, 0x8F, 0xFC, 0x80, 0xB6, 0xC2, 0x8A, 0xC2 + }, + { + 0xD3, 0x60, 0xC6, 0xDC, 0x33, 0x7C, 0x58, 0xB7, + 0xF6, 0xB9, 0xE2, 0x6A, 0xC3, 0x3F, 0x08, 0x41, + 0x07, 0xDF, 0x06, 0x8B, 0x41, 0x24, 0xA3, 0x44, + 0x06, 0xBA, 0x25, 0x57, 0xAD, 0x54, 0x2A, 0x2F, + 0x91, 0xB8, 0x1D, 0x57, 0x9C, 0x33, 0x02, 0xF0, + 0xE4, 0x65, 0x6F, 0x58, 0x96, 0x6D, 0xA2, 0x5E, + 0xA3, 0xCE, 0x53, 0xE6, 0x60, 0xCC, 0xD0, 0x8B, + 0x05, 0x11, 0x8C, 0x0C, 0x03, 0xAD, 0xA4, 0x1B + }, + { + 0xF0, 0xDA, 0xE7, 0x8E, 0x4A, 0x4A, 0xCE, 0xA3, + 0x83, 0x41, 0xBE, 0xEF, 0xE3, 0xD2, 0xDD, 0x44, + 0x6F, 0xC1, 0x5F, 0x86, 0xA0, 0xD1, 0x9C, 0x7E, + 0x02, 0x3A, 0x0A, 0x3B, 0x7F, 0x6F, 0x2A, 0x60, + 0x0E, 0xC4, 0x39, 0xC3, 0x4D, 0xAE, 0x9E, 0x1D, + 0x0D, 0xDB, 0x4E, 0xFA, 0x63, 0x9E, 0x04, 0xC2, + 0x5B, 0x89, 0x44, 0xC3, 0x38, 0xC9, 0xC3, 0x04, + 0xC7, 0x5C, 0xE8, 0x0F, 0x2D, 0xB1, 0xEF, 0xBF + }, + { + 0xCB, 0x22, 0xC2, 0xE1, 0x61, 0xF4, 0x78, 0x4C, + 0x15, 0xAE, 0xB8, 0x8C, 0x73, 0x5A, 0x1B, 0xDC, + 0x09, 0x90, 0xA2, 0x30, 0x73, 0x15, 0x68, 0x2C, + 0x54, 0x15, 0x73, 0x1A, 0x8F, 0x8E, 0x8C, 0x38, + 0x91, 0xEB, 0xBA, 0x7E, 0xD1, 0xC5, 0x7E, 0xB3, + 0xC9, 0x09, 0x7D, 0xDF, 0x87, 0xE1, 0x87, 0x71, + 0x48, 0xF3, 0x2A, 0x9C, 0x21, 0x8F, 0x03, 0x95, + 0x62, 0x70, 0x48, 0x47, 0x26, 0x22, 0x68, 0x5C + }, + { + 0x8A, 0x34, 0x53, 0x4E, 0x5C, 0xC8, 0x85, 0x6E, + 0xB2, 0xE6, 0xFA, 0x16, 0x85, 0x5E, 0x74, 0xF3, + 0xE8, 0x45, 0xE0, 0x1A, 0x22, 0x7D, 0x1B, 0x09, + 0x18, 0xDF, 0x1F, 0x46, 0x0D, 0x54, 0xA5, 0xF8, + 0x76, 0xB6, 0x28, 0x95, 0xE5, 0x47, 0xF3, 0x57, + 0xE2, 0x39, 0xEE, 0x3E, 0x28, 0x12, 0x6C, 0x5F, + 0x23, 0x15, 0xA1, 0xE5, 0x8F, 0x59, 0xB5, 0x52, + 0xEC, 0x2D, 0x6D, 0x2A, 0x22, 0x79, 0x44, 0x85 + }, + { + 0xB0, 0x62, 0xB3, 0xED, 0x86, 0x40, 0xCD, 0xF3, + 0x5D, 0xB9, 0xA4, 0x2C, 0x38, 0xC2, 0x3C, 0x60, + 0x8D, 0x72, 0x84, 0x5D, 0xEE, 0x89, 0xB9, 0x11, + 0xF2, 0xBB, 0x69, 0xFF, 0x31, 0x90, 0xF1, 0x8B, + 0xA4, 0x18, 0x2F, 0xA3, 0x4A, 0x55, 0x56, 0x9E, + 0x74, 0x76, 0x66, 0x7B, 0xB8, 0x24, 0x2F, 0xFC, + 0x3D, 0xBF, 0xCA, 0x5A, 0xED, 0xEF, 0x70, 0x38, + 0xB3, 0x81, 0x4D, 0xB3, 0xE9, 0x3B, 0x3D, 0xC8 + }, + { + 0x3D, 0x4B, 0x56, 0x80, 0x41, 0xA7, 0x96, 0xE3, + 0x6C, 0x29, 0x17, 0x15, 0x05, 0x6D, 0x10, 0x7F, + 0xBB, 0x91, 0xB5, 0x83, 0x82, 0x22, 0x5F, 0x2D, + 0xEA, 0x55, 0x17, 0x62, 0x21, 0xAE, 0xF1, 0xDD, + 0x53, 0xB3, 0x71, 0xBA, 0x35, 0xCA, 0xFB, 0x5E, + 0x24, 0x31, 0x28, 0xC4, 0x99, 0x6B, 0x0A, 0x01, + 0x64, 0x46, 0x85, 0xFD, 0x0F, 0x35, 0x25, 0xEA, + 0xB9, 0x38, 0x5C, 0xE8, 0x46, 0x19, 0x2D, 0xA5 + }, + { + 0x6D, 0x2F, 0xC9, 0x8C, 0x92, 0x70, 0x02, 0x60, + 0xC5, 0xF7, 0xDB, 0x06, 0x0E, 0x73, 0x8F, 0xEB, + 0x91, 0xF1, 0xBC, 0x99, 0x76, 0xEB, 0xEC, 0x52, + 0x69, 0xA2, 0x51, 0xCF, 0xC8, 0xC2, 0x85, 0xF8, + 0xC8, 0x56, 0xEA, 0xBC, 0x10, 0xA9, 0xB5, 0x5D, + 0x6F, 0xF0, 0x33, 0x20, 0x8D, 0xB7, 0xBF, 0xC4, + 0xDB, 0x4E, 0xD3, 0xB0, 0x90, 0xDF, 0x87, 0xDF, + 0xEF, 0x67, 0xC2, 0x96, 0x26, 0xE4, 0xF8, 0xF0 + }, + { + 0x5F, 0xF9, 0x82, 0xF0, 0xE4, 0xFE, 0x07, 0xFF, + 0x80, 0x5A, 0x1C, 0xB4, 0x90, 0x9C, 0xD9, 0xDA, + 0x57, 0x45, 0xCA, 0xD8, 0xAE, 0x15, 0x3A, 0x79, + 0x3F, 0x7D, 0x34, 0xF8, 0xE3, 0x71, 0xD8, 0xCC, + 0x4C, 0x40, 0xF7, 0x14, 0xA3, 0xDF, 0xA0, 0x1B, + 0x05, 0x02, 0x00, 0x9D, 0x21, 0xA0, 0xFE, 0x25, + 0x06, 0xBE, 0x23, 0x66, 0x31, 0x59, 0xCA, 0x4A, + 0x67, 0x79, 0xC3, 0x88, 0x9A, 0x2F, 0x8F, 0x1F + }, + { + 0x18, 0x41, 0x36, 0x63, 0x23, 0x14, 0xC4, 0x55, + 0xF8, 0xB5, 0xB9, 0x41, 0x41, 0x97, 0xA2, 0x3C, + 0x26, 0xEC, 0x81, 0x2B, 0x4B, 0xC4, 0x6D, 0x9B, + 0x63, 0x15, 0xD4, 0xD1, 0x85, 0x3E, 0xD7, 0xF8, + 0xA6, 0xCF, 0x11, 0xF5, 0xB1, 0xDA, 0xE1, 0x3C, + 0x53, 0xE8, 0x9D, 0x24, 0x12, 0xCC, 0x75, 0x2D, + 0x25, 0xF0, 0x57, 0xA8, 0x8C, 0x2F, 0xF8, 0xAD, + 0xAD, 0x30, 0x04, 0x10, 0x1B, 0x26, 0xD6, 0x6E + }, + { + 0xF6, 0x62, 0xEC, 0x73, 0x5C, 0xA7, 0xF8, 0xF4, + 0xC7, 0x55, 0x3F, 0x53, 0x6E, 0x63, 0x8A, 0xED, + 0xBB, 0x74, 0x35, 0x94, 0x49, 0x4A, 0x67, 0x80, + 0xF1, 0xCD, 0xBA, 0x58, 0x14, 0x54, 0xA8, 0xC1, + 0xFD, 0x6F, 0xD7, 0x58, 0x5C, 0xA4, 0xB7, 0x0F, + 0x1A, 0xEC, 0xAF, 0xFE, 0x98, 0x31, 0xB9, 0x48, + 0x70, 0x76, 0x41, 0xE4, 0x32, 0xA4, 0xFA, 0x93, + 0x26, 0x58, 0x61, 0x8F, 0x4F, 0xD1, 0xD3, 0xB5 + }, + { + 0x94, 0xF5, 0xAF, 0x00, 0x2A, 0x01, 0x26, 0x04, + 0x7C, 0x6F, 0x73, 0xDF, 0x80, 0xFB, 0x73, 0xF0, + 0x66, 0x95, 0xF0, 0x4F, 0xD0, 0xFB, 0xE0, 0x7C, + 0x6D, 0x30, 0xEB, 0x43, 0xED, 0xB0, 0x21, 0x83, + 0x16, 0xF5, 0x95, 0x45, 0x2E, 0x44, 0x2E, 0xFA, + 0xE8, 0x22, 0x58, 0x2A, 0x93, 0x17, 0xA9, 0x70, + 0xBC, 0x7F, 0x91, 0x2E, 0x25, 0x7D, 0xB8, 0xA7, + 0xC7, 0xDA, 0x9F, 0xD3, 0x29, 0x6F, 0xE7, 0x24 + }, + { + 0xFC, 0xA5, 0x13, 0x35, 0xFA, 0xD8, 0xB2, 0x26, + 0xC4, 0x58, 0xCA, 0x9A, 0x48, 0x99, 0x30, 0x65, + 0xE0, 0x91, 0x25, 0x7C, 0x09, 0xCE, 0x2C, 0xCE, + 0xEB, 0x8D, 0x5A, 0xA9, 0xDA, 0x75, 0x37, 0x77, + 0x34, 0xD2, 0xB0, 0xE0, 0x74, 0xA9, 0xFE, 0x57, + 0xE4, 0x0E, 0x69, 0x1E, 0x99, 0xAA, 0x7B, 0x47, + 0x11, 0x0A, 0x9E, 0xCE, 0x79, 0x51, 0xC8, 0x42, + 0xB2, 0x2B, 0xF4, 0x10, 0x62, 0xB6, 0xDB, 0xB6 + }, + { + 0x3E, 0x4C, 0x9F, 0xA8, 0xA2, 0x7C, 0x06, 0x72, + 0x55, 0xAE, 0x73, 0x34, 0x4E, 0x85, 0xA1, 0xBC, + 0x50, 0x81, 0xB7, 0x7C, 0xEA, 0x06, 0x09, 0x47, + 0xC5, 0x3A, 0x7F, 0x46, 0xFC, 0x8A, 0xAB, 0xC3, + 0xDF, 0x33, 0xAE, 0xDA, 0x4C, 0x91, 0xA2, 0xC0, + 0x4B, 0x81, 0xB7, 0x7E, 0xB2, 0x24, 0x3C, 0xD5, + 0xA2, 0xD4, 0xA6, 0x04, 0x3E, 0x5B, 0xC6, 0xD9, + 0x16, 0x0F, 0x48, 0x1A, 0x74, 0x5F, 0xF9, 0x09 + }, + { + 0x49, 0x43, 0xF8, 0xF4, 0xBF, 0x82, 0x12, 0x22, + 0x5C, 0xA9, 0xFA, 0xA9, 0xFE, 0x3A, 0x32, 0xDD, + 0xE2, 0xF3, 0xEE, 0xA4, 0x37, 0x2B, 0xAB, 0x26, + 0x03, 0xA9, 0xE7, 0xBC, 0xFE, 0x8A, 0x74, 0xE1, + 0x42, 0x08, 0x64, 0xA4, 0xCA, 0x9E, 0xE9, 0xD5, + 0x9A, 0x09, 0xEC, 0xCC, 0x13, 0xE3, 0xDF, 0x95, + 0x89, 0x36, 0xC3, 0x99, 0xD4, 0xE0, 0x65, 0xA4, + 0x50, 0xD8, 0x40, 0x8D, 0x62, 0xA2, 0x7F, 0x36 + }, + { + 0xD4, 0x92, 0x28, 0x88, 0x64, 0xAF, 0xDE, 0xCE, + 0x45, 0x9A, 0xD2, 0x02, 0x8E, 0x34, 0x72, 0xE0, + 0x15, 0xD1, 0xF0, 0xC5, 0x5D, 0xE8, 0x4A, 0x5C, + 0x66, 0x49, 0x97, 0xE6, 0xCE, 0x1A, 0x25, 0xD2, + 0x1F, 0xD6, 0x03, 0x1F, 0xAB, 0x41, 0x78, 0x8E, + 0x10, 0xED, 0x94, 0x7B, 0xC1, 0x2D, 0x0C, 0x65, + 0x23, 0x26, 0x0D, 0x46, 0xAE, 0x20, 0x0F, 0x85, + 0xDA, 0x1D, 0xCE, 0x55, 0xD8, 0xE7, 0xBA, 0x29 + }, + { + 0x37, 0x13, 0x81, 0x75, 0x93, 0x07, 0x27, 0x46, + 0x3B, 0xA5, 0xD3, 0xC2, 0xA2, 0xCD, 0x27, 0x9B, + 0x9B, 0x73, 0xE9, 0x0A, 0x7B, 0xA9, 0xAB, 0x89, + 0x2C, 0x57, 0x9B, 0xB6, 0x50, 0x7C, 0x01, 0x3C, + 0xC5, 0xB1, 0xB4, 0x72, 0x41, 0x9B, 0xEF, 0x8C, + 0x5B, 0xEA, 0xC8, 0x8E, 0x0D, 0x0A, 0x51, 0x2E, + 0x83, 0x55, 0xAB, 0x19, 0x7D, 0x16, 0x53, 0x47, + 0x5E, 0xCB, 0x02, 0xEF, 0x0B, 0x18, 0x21, 0x88 + }, + { + 0xCF, 0x73, 0x45, 0x6C, 0x39, 0xA5, 0x65, 0xB3, + 0x96, 0xAF, 0xD8, 0x68, 0xE0, 0x8D, 0xCE, 0x37, + 0x51, 0xCD, 0x76, 0x60, 0xA5, 0x8A, 0xB2, 0xFE, + 0x5B, 0x2E, 0x37, 0xD1, 0xF2, 0xA1, 0xB7, 0xD3, + 0x1D, 0xA1, 0x71, 0x9D, 0xE6, 0xDA, 0x7D, 0xFE, + 0xD9, 0x30, 0x3C, 0x40, 0xD5, 0x1C, 0x37, 0x1F, + 0x3E, 0xBF, 0x99, 0xFD, 0x4D, 0xA6, 0xFF, 0xB8, + 0x2F, 0xBF, 0x8A, 0x8A, 0xFF, 0xDF, 0x91, 0xC3 + }, + { + 0x9C, 0xA8, 0x68, 0x07, 0x6D, 0x67, 0xCF, 0x26, + 0xD7, 0xE1, 0x3D, 0x94, 0xAF, 0xB3, 0x04, 0x17, + 0x42, 0x1C, 0x04, 0x68, 0x02, 0xEE, 0x7D, 0x8B, + 0x73, 0x89, 0x15, 0xE4, 0x62, 0x47, 0xEC, 0x27, + 0xFC, 0x2F, 0xFD, 0x89, 0x08, 0xBC, 0x5B, 0x80, + 0x42, 0xB0, 0x37, 0x94, 0x6D, 0x9F, 0x76, 0x4F, + 0x31, 0x4B, 0x81, 0xC7, 0x95, 0xFC, 0x06, 0x8C, + 0x98, 0x23, 0x2D, 0xC9, 0x61, 0x37, 0x3C, 0x9A + }, + { + 0xA0, 0x71, 0x23, 0x7F, 0x2C, 0x3C, 0x14, 0xB6, + 0x69, 0xFF, 0x72, 0x1B, 0xB4, 0xF5, 0xC5, 0xBB, + 0x1A, 0xAD, 0xEC, 0x40, 0xF7, 0xEB, 0x99, 0x05, + 0x7F, 0x5D, 0x3D, 0xB3, 0x40, 0x4F, 0xC3, 0x18, + 0x8C, 0x19, 0x1D, 0x86, 0x69, 0xE3, 0x40, 0x07, + 0x7A, 0xAC, 0xAB, 0x2D, 0x5D, 0xB5, 0x05, 0xF1, + 0x63, 0xA5, 0x6C, 0x7D, 0xED, 0x5E, 0xF8, 0x49, + 0xB8, 0x7C, 0x1E, 0xF5, 0x7A, 0x62, 0xD8, 0xA3 + }, + { + 0xF4, 0x2B, 0x89, 0xE6, 0x3D, 0x86, 0x46, 0x99, + 0xD2, 0xC2, 0xD0, 0xAA, 0xF5, 0x89, 0x99, 0x3F, + 0x6F, 0x3F, 0x2A, 0x6B, 0x47, 0x73, 0x89, 0x57, + 0xA8, 0xF2, 0x04, 0xA9, 0x55, 0x13, 0x7E, 0xEE, + 0x0E, 0x5C, 0xE8, 0xA3, 0x80, 0x11, 0x3B, 0xC3, + 0xA9, 0x05, 0x1A, 0x16, 0x3A, 0x07, 0x3C, 0x61, + 0x31, 0x19, 0x87, 0x43, 0x78, 0x32, 0xE1, 0xAA, + 0x87, 0xFF, 0x9A, 0x9B, 0xC8, 0x0B, 0x26, 0xB7 + }, + { + 0x75, 0xE4, 0x2E, 0x0F, 0x51, 0x03, 0xCA, 0x3F, + 0x8A, 0xF2, 0x4A, 0x16, 0xB1, 0x51, 0x82, 0x89, + 0x8E, 0x6A, 0xCC, 0xB7, 0xDE, 0x08, 0x45, 0x82, + 0x59, 0xE9, 0x52, 0x7E, 0x29, 0xFB, 0xD2, 0xBD, + 0x0B, 0xE7, 0x26, 0x80, 0x44, 0xE0, 0x60, 0xFC, + 0x00, 0x85, 0x94, 0x57, 0x99, 0x6C, 0x30, 0xD3, + 0x2A, 0x5D, 0x94, 0x98, 0x05, 0xF5, 0x89, 0x7F, + 0x7E, 0x75, 0x29, 0x1D, 0xF2, 0xA5, 0x9A, 0xE5 + }, + { + 0x13, 0xE0, 0x8A, 0xA2, 0xD8, 0x76, 0xAE, 0xD0, + 0x98, 0x7F, 0x3F, 0xF6, 0xF7, 0xA5, 0x28, 0x41, + 0xAF, 0x62, 0xAA, 0xCC, 0x1E, 0x45, 0x96, 0x24, + 0x10, 0x96, 0xE5, 0xEC, 0xD5, 0x63, 0xA0, 0xB3, + 0x41, 0xE1, 0x10, 0x46, 0x82, 0xA7, 0xDE, 0xE7, + 0xF7, 0x20, 0x8F, 0xC2, 0xF7, 0xC7, 0x80, 0x19, + 0xB4, 0x79, 0xFE, 0x7F, 0xE9, 0x6B, 0x8B, 0x86, + 0x21, 0x04, 0x57, 0xE9, 0xA8, 0x4F, 0x49, 0xE9 + }, + { + 0xDA, 0xCE, 0x22, 0xE5, 0x28, 0x7C, 0x44, 0xB6, + 0xF5, 0x72, 0x52, 0xC0, 0x09, 0x00, 0x9B, 0x1C, + 0xA5, 0x4F, 0xA0, 0xD3, 0x75, 0xA6, 0x9A, 0x2A, + 0x03, 0x79, 0x87, 0x09, 0x66, 0xD0, 0x6A, 0x97, + 0x41, 0xD9, 0x3D, 0xFC, 0x67, 0xBF, 0x19, 0x74, + 0x45, 0x00, 0xA2, 0xA9, 0x1B, 0x02, 0xCA, 0x0B, + 0x66, 0xB3, 0xE7, 0xAB, 0x72, 0xC8, 0x73, 0x44, + 0x18, 0xA0, 0xBA, 0xF0, 0x7B, 0x4A, 0x7F, 0x9F + }, + { + 0xD1, 0xE1, 0x2B, 0x9E, 0x30, 0x20, 0x0C, 0xF6, + 0x18, 0x16, 0x1E, 0xB4, 0x56, 0x37, 0xDC, 0x2F, + 0x71, 0xE6, 0x57, 0x49, 0x69, 0x47, 0xDA, 0x90, + 0x66, 0xD0, 0xF1, 0xE5, 0xC9, 0x01, 0xCA, 0x59, + 0x12, 0xFC, 0x95, 0x7F, 0x07, 0x96, 0x4A, 0xC2, + 0x0C, 0xE6, 0x8D, 0x90, 0x2D, 0x41, 0x65, 0x58, + 0x5D, 0x80, 0x1C, 0x4D, 0xB0, 0x33, 0x31, 0x81, + 0x67, 0x99, 0x56, 0x96, 0xB3, 0x53, 0xFE, 0xAE + }, + { + 0x4A, 0xEB, 0xE4, 0x3E, 0xCF, 0xDA, 0x66, 0x6B, + 0x8E, 0x67, 0xCE, 0x20, 0x4C, 0x84, 0x82, 0x74, + 0x39, 0x36, 0xF2, 0xA7, 0xA4, 0xE4, 0x6A, 0x9F, + 0x56, 0xE6, 0x11, 0x24, 0xB5, 0x1E, 0xF3, 0x81, + 0x70, 0x3E, 0xE7, 0x8F, 0x1D, 0xA0, 0xD5, 0xE7, + 0x88, 0x12, 0xC9, 0xB4, 0xE1, 0x89, 0x0A, 0x74, + 0x3A, 0x89, 0x60, 0x9B, 0x6A, 0xF2, 0xE1, 0xD4, + 0x8A, 0x06, 0x7C, 0xF9, 0x53, 0x41, 0x27, 0x3B + }, + { + 0xBA, 0x3F, 0xEF, 0xAE, 0xE2, 0x27, 0x77, 0x17, + 0x35, 0x1A, 0x34, 0x77, 0xB8, 0x9D, 0x6B, 0x2C, + 0x56, 0xAF, 0x5D, 0x2E, 0xB9, 0x81, 0x70, 0x6D, + 0xCE, 0x58, 0x92, 0xEB, 0x4A, 0x57, 0xC4, 0x8F, + 0x63, 0x0F, 0x8D, 0xE9, 0x7F, 0xF8, 0x39, 0xA1, + 0x21, 0xE1, 0x04, 0xAB, 0xD4, 0xFF, 0x72, 0xF9, + 0x8A, 0x84, 0x3F, 0x61, 0x06, 0xA6, 0x82, 0xB6, + 0xCE, 0x67, 0xE2, 0x0C, 0x07, 0xA6, 0x25, 0x2C + }, + { + 0x36, 0x20, 0xA6, 0x97, 0x7A, 0x37, 0x95, 0x7B, + 0xA6, 0x58, 0x58, 0xC4, 0x06, 0x59, 0x08, 0x55, + 0x9D, 0xA7, 0x1D, 0xF9, 0x30, 0x90, 0xA0, 0xAA, + 0x06, 0x7D, 0x20, 0x93, 0x9F, 0x44, 0x8B, 0x39, + 0xB1, 0xBB, 0x2B, 0x81, 0xB7, 0xD2, 0x29, 0xD8, + 0xFD, 0x9C, 0xE0, 0x90, 0x17, 0x96, 0x13, 0x21, + 0x75, 0x85, 0x88, 0xAF, 0xF9, 0xD2, 0xB2, 0x3C, + 0x56, 0x7A, 0xEC, 0x21, 0xB0, 0xD7, 0x2A, 0xEC + }, + { + 0xA4, 0xAD, 0x4D, 0xF0, 0x81, 0x53, 0x2D, 0x1F, + 0x2F, 0xA0, 0x61, 0xD9, 0x86, 0x62, 0x75, 0xEC, + 0x44, 0x4B, 0x8B, 0x54, 0x78, 0x43, 0x49, 0xB7, + 0x4C, 0x15, 0x20, 0xEB, 0x36, 0x22, 0x6C, 0x4F, + 0xC6, 0x30, 0xAA, 0xD2, 0x91, 0x86, 0xEE, 0x9D, + 0x43, 0xBD, 0x6B, 0xEF, 0xE0, 0x46, 0xBA, 0x46, + 0x3F, 0xC6, 0x27, 0x79, 0x49, 0xFB, 0x27, 0xD4, + 0xDD, 0x8E, 0x86, 0x6C, 0x5D, 0x5B, 0x5E, 0x87 + }, + { + 0x17, 0xD1, 0x71, 0x50, 0x72, 0x56, 0x14, 0xA9, + 0x3C, 0x7B, 0xA4, 0xDE, 0x53, 0xA1, 0xC1, 0x97, + 0xEF, 0x59, 0xCC, 0x08, 0xD2, 0x67, 0x9F, 0xB5, + 0x7E, 0xFE, 0x38, 0x9D, 0xA6, 0xC6, 0xD1, 0x8E, + 0xA6, 0x82, 0x29, 0xFB, 0x53, 0x36, 0xFB, 0xBA, + 0x94, 0xEB, 0x61, 0xAA, 0x91, 0x49, 0x35, 0x1E, + 0x06, 0xA4, 0xE5, 0xA4, 0x67, 0x99, 0x1C, 0x35, + 0xB3, 0xBC, 0xED, 0xA4, 0x13, 0x8D, 0x0C, 0x85 + }, + { + 0x53, 0x36, 0x5B, 0x0D, 0x84, 0x54, 0x50, 0xD3, + 0x4E, 0x89, 0xA9, 0x75, 0x60, 0x60, 0xD3, 0x1C, + 0x5E, 0xD4, 0x08, 0xBF, 0x31, 0x87, 0xBC, 0x80, + 0x0B, 0xE2, 0x05, 0x37, 0x1D, 0x9F, 0xA9, 0xA8, + 0xE1, 0x6D, 0x19, 0x45, 0xD0, 0x39, 0xCA, 0x4D, + 0x6C, 0xA6, 0xD7, 0xEA, 0x06, 0x8E, 0xDD, 0x12, + 0xA6, 0x75, 0x4A, 0x0E, 0x74, 0x47, 0x70, 0x1C, + 0x92, 0x85, 0x2C, 0x3E, 0x9B, 0x78, 0xF9, 0x24 + }, + { + 0x2D, 0xAA, 0x7A, 0x27, 0xCF, 0xB3, 0x1F, 0x9A, + 0x04, 0x08, 0xD4, 0x46, 0x77, 0x83, 0x72, 0x91, + 0x8A, 0x6B, 0x06, 0x45, 0x5D, 0x67, 0xB6, 0x84, + 0x72, 0x79, 0x72, 0x47, 0x25, 0xE0, 0x87, 0xF0, + 0x86, 0x4B, 0x43, 0x0E, 0x4F, 0x6F, 0x1A, 0x64, + 0x48, 0xD5, 0x36, 0xB1, 0x0D, 0x54, 0x2D, 0xE7, + 0x4B, 0xBC, 0xCA, 0xC9, 0x74, 0xA9, 0xC0, 0x98, + 0x2D, 0xEF, 0xF6, 0xB9, 0xFB, 0x33, 0x14, 0x3E + }, + { + 0x43, 0x32, 0x59, 0x90, 0xC4, 0x56, 0x90, 0x20, + 0x8E, 0xB8, 0x21, 0x00, 0x68, 0x75, 0x61, 0x3F, + 0x83, 0xE6, 0x07, 0xD8, 0xDC, 0x0E, 0xC5, 0x51, + 0xAB, 0xA0, 0x0A, 0x66, 0x9E, 0x02, 0x18, 0x7E, + 0xE0, 0x9D, 0x0C, 0xC8, 0x92, 0x20, 0x7B, 0x09, + 0xF0, 0x31, 0x93, 0x79, 0x28, 0x1C, 0xA9, 0x4D, + 0x11, 0x52, 0x41, 0x75, 0xCE, 0x29, 0x8A, 0xD4, + 0x3B, 0xB8, 0x8C, 0x48, 0xC1, 0x3C, 0x69, 0xBB + }, + { + 0x36, 0x92, 0x97, 0x20, 0x53, 0x50, 0x10, 0x50, + 0x56, 0xB3, 0xFD, 0x02, 0x0F, 0xDC, 0x73, 0xF5, + 0x87, 0x91, 0xFD, 0x79, 0xDF, 0xE7, 0x0B, 0x7B, + 0xB9, 0x86, 0x4B, 0xC7, 0x80, 0x59, 0x91, 0x99, + 0x57, 0x95, 0x9C, 0x11, 0x09, 0x7B, 0x60, 0xAB, + 0x2D, 0x89, 0x41, 0x0C, 0x8F, 0x1F, 0x3C, 0xE7, + 0x9B, 0xA6, 0xAB, 0xBF, 0xD5, 0xB9, 0xAD, 0xC9, + 0x11, 0xCB, 0x09, 0x80, 0xF7, 0xA8, 0xDD, 0x5D + }, + { + 0xAD, 0x5F, 0xB8, 0xE7, 0xCB, 0x08, 0x58, 0x77, + 0xD5, 0x86, 0x2A, 0x91, 0xC5, 0xED, 0x01, 0x87, + 0x94, 0x9D, 0x19, 0xF6, 0x3C, 0xB0, 0x61, 0x76, + 0x6C, 0xAB, 0x41, 0x2A, 0x6B, 0x5D, 0x04, 0x40, + 0x7D, 0xF5, 0xEF, 0x1B, 0x2B, 0x63, 0x99, 0x0C, + 0x11, 0xB0, 0x06, 0x65, 0x96, 0xBD, 0x9B, 0xEC, + 0xB5, 0xF5, 0x8A, 0x02, 0x2C, 0xF6, 0xF7, 0x64, + 0xCB, 0x17, 0xA8, 0x55, 0xAB, 0xC5, 0xB1, 0x69 + }, + { + 0x0D, 0x13, 0x43, 0x46, 0xE7, 0x33, 0x56, 0xAF, + 0xD2, 0x5F, 0xA0, 0x1F, 0xAD, 0x05, 0x90, 0x9F, + 0xF3, 0xA3, 0x9B, 0x2C, 0xC0, 0xB3, 0x69, 0x57, + 0xFF, 0x69, 0x23, 0xE1, 0x90, 0xC9, 0x45, 0xE8, + 0x41, 0x26, 0xF3, 0x3C, 0x09, 0xDE, 0x32, 0xF7, + 0x0B, 0x52, 0x96, 0xB7, 0xE2, 0x26, 0xB0, 0xCF, + 0xF3, 0x30, 0x1D, 0x53, 0x9D, 0xC0, 0xBA, 0x20, + 0xB6, 0x8C, 0xC8, 0x01, 0x48, 0x43, 0x47, 0xF4 + }, + { + 0xD8, 0x59, 0x76, 0x6E, 0x05, 0xBD, 0x14, 0xBA, + 0xD6, 0x68, 0x23, 0x43, 0x2F, 0x9F, 0xFA, 0xC1, + 0xF6, 0xC9, 0x01, 0x67, 0x6D, 0x52, 0x59, 0xA1, + 0xED, 0x10, 0xD3, 0xF7, 0x50, 0x7A, 0xF8, 0x7A, + 0x11, 0x91, 0x7F, 0x5A, 0x18, 0x92, 0x9F, 0x07, + 0xE6, 0x0A, 0x3B, 0xED, 0xC5, 0x07, 0x46, 0xD0, + 0x00, 0x71, 0x1A, 0xE8, 0x7C, 0xF4, 0x33, 0xE2, + 0x52, 0x68, 0x71, 0x3B, 0xAB, 0x23, 0x66, 0xE1 + }, + { + 0x13, 0x69, 0x56, 0xA8, 0xF8, 0xFA, 0xE6, 0x3A, + 0x4E, 0x24, 0xE6, 0x7E, 0x61, 0x38, 0xCE, 0x0C, + 0x34, 0x27, 0x42, 0x87, 0xB5, 0xFD, 0x7A, 0x32, + 0xBD, 0x1A, 0xEE, 0x0D, 0x01, 0x65, 0x9C, 0xDA, + 0x2B, 0x46, 0x8D, 0xD9, 0xBC, 0x95, 0xDF, 0x4C, + 0x92, 0x09, 0x2C, 0xF4, 0x30, 0xB5, 0x07, 0x24, + 0x04, 0xB6, 0x15, 0x35, 0xD4, 0x64, 0x90, 0x41, + 0x47, 0x04, 0x84, 0x05, 0xCA, 0x01, 0x7F, 0x4C + }, + { + 0xE0, 0x0D, 0x19, 0x47, 0xCF, 0xE3, 0x1A, 0x4E, + 0xC1, 0x25, 0xE4, 0xA0, 0x6B, 0xF3, 0x44, 0xCA, + 0x97, 0xB9, 0x38, 0x40, 0xFB, 0x5A, 0xE0, 0xF9, + 0xEC, 0xE1, 0x73, 0x4D, 0x3A, 0x32, 0xFE, 0x01, + 0x5E, 0x59, 0xCE, 0x60, 0x83, 0xF8, 0xC1, 0xCD, + 0x53, 0x9A, 0xDD, 0x8A, 0x89, 0xEA, 0x7C, 0xBA, + 0xA7, 0x0C, 0x4E, 0x94, 0x4E, 0x70, 0x90, 0x7F, + 0x19, 0x8D, 0x78, 0x85, 0xDB, 0x58, 0x71, 0x3C + }, + { + 0x50, 0x5B, 0x88, 0xE5, 0xC4, 0x29, 0xDE, 0x2A, + 0x42, 0x7C, 0x72, 0x07, 0x7B, 0xF4, 0xF8, 0x8F, + 0x38, 0xAA, 0x3A, 0xBC, 0x03, 0xB7, 0x39, 0x3A, + 0x91, 0xF2, 0x0B, 0x69, 0xD7, 0x89, 0x85, 0x3C, + 0x99, 0xB9, 0xAA, 0x59, 0x10, 0x19, 0x3C, 0x25, + 0xAE, 0x44, 0xC3, 0x27, 0xCE, 0xA5, 0x85, 0xBD, + 0x20, 0xD4, 0x24, 0x7D, 0x28, 0x77, 0x66, 0x54, + 0xB7, 0x69, 0x10, 0x1E, 0xA5, 0x59, 0x5F, 0xC1 + }, + { + 0x50, 0xAD, 0x2F, 0xA9, 0xF4, 0x32, 0xFC, 0xEE, + 0x5A, 0x8F, 0x46, 0xEB, 0xEA, 0x99, 0x71, 0xE1, + 0x98, 0xC4, 0x3A, 0xD6, 0x55, 0x90, 0x1E, 0xF9, + 0x0D, 0x74, 0xF3, 0x34, 0xA3, 0xA1, 0x7A, 0x44, + 0x90, 0xF8, 0x0E, 0x0F, 0xBD, 0x5E, 0x80, 0xBE, + 0xC3, 0x79, 0x21, 0x52, 0xF3, 0x95, 0xEF, 0x49, + 0x88, 0xBE, 0xF4, 0x01, 0x37, 0xDC, 0x0B, 0x89, + 0x8C, 0x5B, 0xA7, 0xA5, 0xEC, 0xA7, 0xE2, 0x99 + }, + { + 0x13, 0x20, 0x2C, 0xA6, 0xBE, 0xB1, 0xAF, 0xEC, + 0x99, 0x45, 0x9A, 0xC3, 0xB2, 0x42, 0x2A, 0x51, + 0x77, 0x99, 0x98, 0xD6, 0x6D, 0x40, 0x9A, 0x80, + 0x5A, 0x1A, 0xFF, 0x54, 0xE5, 0xA4, 0x70, 0xE1, + 0xAB, 0x77, 0x77, 0xFC, 0x37, 0xEB, 0xD1, 0x7F, + 0x77, 0xB1, 0x41, 0x8F, 0x4F, 0x10, 0xED, 0xD7, + 0xF3, 0xDD, 0x29, 0x0F, 0x66, 0xE6, 0x1F, 0x5D, + 0x37, 0xB2, 0x66, 0xA5, 0x64, 0xC0, 0xEA, 0xA4 + }, + { + 0x30, 0xCF, 0x7D, 0xE4, 0x39, 0x05, 0xC2, 0x73, + 0xD9, 0x68, 0xD9, 0x4D, 0x3B, 0xD4, 0xEC, 0x6A, + 0x73, 0x4E, 0x1C, 0x1C, 0xA9, 0xBA, 0xD7, 0x10, + 0xEA, 0xC5, 0xFD, 0x73, 0x86, 0xDF, 0x7D, 0xAF, + 0x46, 0xF1, 0x9C, 0x6A, 0x5F, 0x20, 0xC2, 0xD3, + 0xBF, 0xF1, 0x23, 0xAF, 0x46, 0x83, 0x37, 0xE7, + 0x3B, 0xE6, 0x61, 0x2C, 0x5C, 0x87, 0x20, 0x85, + 0x5E, 0x58, 0x08, 0xCF, 0x89, 0x43, 0xD3, 0x47 + }, + { + 0xB2, 0x5F, 0x79, 0xDF, 0x78, 0x9B, 0xF6, 0x9B, + 0x32, 0x9E, 0x6E, 0x5C, 0xE7, 0x3A, 0x7C, 0xAC, + 0x81, 0xAA, 0xB1, 0x1B, 0x9E, 0x02, 0x44, 0x9D, + 0x32, 0x14, 0xCE, 0xAE, 0x28, 0xBF, 0x98, 0xD6, + 0x3D, 0xD0, 0x06, 0xE4, 0x2B, 0xEA, 0x4A, 0x2B, + 0x78, 0x16, 0x29, 0x72, 0xB7, 0x4B, 0x02, 0xB7, + 0x14, 0xF9, 0x66, 0xDA, 0x85, 0x22, 0x5F, 0x2B, + 0x02, 0x7B, 0xDF, 0x89, 0xD4, 0xA4, 0xF7, 0xF4 + }, + { + 0x00, 0xC9, 0x28, 0x13, 0xF3, 0x25, 0x32, 0x69, + 0x41, 0x3F, 0x92, 0xA6, 0x98, 0x3F, 0x45, 0xB5, + 0xB1, 0x13, 0xAD, 0x43, 0x6D, 0x05, 0x0C, 0x17, + 0x05, 0x7A, 0x69, 0xF0, 0xBE, 0xCD, 0x6E, 0x55, + 0x62, 0xD6, 0x44, 0x50, 0xFD, 0x0E, 0x51, 0xF7, + 0x84, 0xDD, 0xB9, 0x4D, 0xA4, 0xE1, 0x78, 0xC4, + 0xB6, 0x0A, 0xF3, 0xF2, 0x71, 0x95, 0xCC, 0xAA, + 0x39, 0xDE, 0x8A, 0xEA, 0xA6, 0xD8, 0xFB, 0xAB + }, + { + 0x4A, 0x95, 0x70, 0xE1, 0x7C, 0xB0, 0x2D, 0xC8, + 0x38, 0x4A, 0x37, 0x3C, 0x61, 0xC8, 0xA0, 0x76, + 0x09, 0xA4, 0x85, 0x67, 0x4D, 0x1E, 0x24, 0x84, + 0xAA, 0x86, 0x20, 0x57, 0x9B, 0x32, 0x51, 0x55, + 0x4F, 0x15, 0x0E, 0xAF, 0x5E, 0xEA, 0x2C, 0xE4, + 0xA1, 0xBF, 0xDF, 0x4F, 0xA5, 0x5E, 0x32, 0xC0, + 0xE1, 0xED, 0x6B, 0x79, 0xA8, 0xFC, 0xCF, 0x19, + 0xA0, 0x13, 0xE2, 0x83, 0xC3, 0x3B, 0x10, 0x69 + }, + { + 0x24, 0xBA, 0x98, 0xAC, 0x81, 0xD8, 0xBA, 0x2A, + 0xEB, 0x60, 0x05, 0x97, 0xD8, 0x3D, 0x8B, 0x64, + 0x08, 0x3B, 0x82, 0x35, 0x47, 0xAE, 0x64, 0xF9, + 0xAB, 0xAE, 0x37, 0x04, 0x8A, 0xD4, 0x95, 0x78, + 0xBF, 0x18, 0x8E, 0x78, 0x70, 0xE1, 0xBA, 0x0F, + 0xC1, 0x4D, 0x6A, 0xE3, 0x32, 0xC5, 0xD6, 0xAC, + 0xA2, 0xEC, 0x32, 0xC0, 0xB6, 0x02, 0x51, 0x1A, + 0x97, 0xC4, 0x2C, 0xC8, 0xA8, 0x0D, 0x74, 0x50 + }, + { + 0x94, 0xB7, 0xDE, 0x03, 0x72, 0x2F, 0x68, 0xA6, + 0xE8, 0xFB, 0x85, 0x0B, 0xCB, 0x54, 0xAB, 0xAD, + 0x2A, 0x24, 0x6F, 0x48, 0x3A, 0x8E, 0x08, 0xEF, + 0xF0, 0x5E, 0x37, 0x24, 0xC9, 0x46, 0xA9, 0x0F, + 0xAC, 0xF4, 0x6F, 0x49, 0x1E, 0xDA, 0xDD, 0x1D, + 0x56, 0x1F, 0x67, 0xEB, 0xD4, 0x6C, 0x62, 0x11, + 0x43, 0x69, 0xCF, 0xE2, 0x3A, 0x9D, 0x64, 0xC9, + 0x8F, 0x98, 0x46, 0x6E, 0xA9, 0x3E, 0x00, 0x1B + }, + { + 0x50, 0x29, 0xA0, 0x31, 0x37, 0xA1, 0x89, 0xC0, + 0x00, 0x78, 0xC8, 0xCC, 0x0B, 0x37, 0x6D, 0xB0, + 0x87, 0x3C, 0xC0, 0x2D, 0x63, 0x9E, 0x1C, 0x3E, + 0x22, 0xAF, 0x46, 0x0B, 0xC3, 0xD5, 0x9C, 0x48, + 0xFE, 0x1D, 0x39, 0xEF, 0xED, 0x8D, 0x7A, 0xBF, + 0x80, 0x5B, 0x91, 0xC0, 0xA2, 0xFD, 0xF4, 0xB1, + 0x5F, 0x22, 0x62, 0xE5, 0x1A, 0x10, 0xF0, 0xE6, + 0x41, 0xBE, 0x5E, 0x61, 0x6E, 0xD5, 0x65, 0xBC + }, + { + 0x7E, 0x0B, 0x0A, 0xC8, 0xA4, 0x6D, 0x42, 0x12, + 0x27, 0xB8, 0x41, 0x75, 0x5E, 0xA9, 0x68, 0xF0, + 0x10, 0x81, 0x9A, 0xB1, 0xE5, 0x17, 0x20, 0xA2, + 0x4F, 0xED, 0x20, 0x4E, 0x3C, 0x9B, 0x6F, 0x8B, + 0x8C, 0x64, 0xAB, 0xE6, 0xD5, 0xF2, 0x6C, 0x44, + 0xAF, 0xFB, 0x45, 0x70, 0x2A, 0xF1, 0x99, 0xC4, + 0xB2, 0x0A, 0x98, 0x11, 0x33, 0x53, 0x61, 0xA3, + 0xEE, 0x8C, 0x4A, 0x76, 0x79, 0x97, 0xD3, 0x35 + }, + { + 0x01, 0xC1, 0xF0, 0xAC, 0xC6, 0x02, 0x56, 0x39, + 0x66, 0x84, 0x6C, 0x37, 0x63, 0xC3, 0x3A, 0xFB, + 0x10, 0x55, 0xCD, 0x87, 0x4C, 0x66, 0x06, 0x66, + 0xA3, 0x74, 0x83, 0x64, 0x12, 0x1F, 0xA1, 0xE5, + 0xCC, 0x78, 0x4B, 0x1A, 0x14, 0x3F, 0x43, 0x97, + 0xB1, 0x4F, 0x79, 0x78, 0xAF, 0xEC, 0xFE, 0xCF, + 0x77, 0x00, 0xD4, 0x16, 0xEA, 0x0D, 0x61, 0xEC, + 0xB8, 0x49, 0x2A, 0x0B, 0xCF, 0x5A, 0x10, 0xE6 + }, + { + 0x68, 0x3F, 0x2E, 0x0F, 0xBD, 0xF2, 0xA7, 0x22, + 0xEB, 0x4F, 0xB4, 0x11, 0x55, 0xD7, 0x22, 0x4D, + 0x46, 0x0E, 0xCC, 0x3F, 0x16, 0x98, 0xB9, 0x01, + 0xC9, 0x05, 0xB5, 0x2C, 0xDC, 0x9F, 0xCC, 0x72, + 0x97, 0x62, 0x49, 0x3E, 0x26, 0x37, 0xF8, 0x62, + 0x78, 0xF6, 0x26, 0x27, 0xDC, 0x24, 0xF6, 0xEE, + 0x36, 0x41, 0xAB, 0xC7, 0xB5, 0x4E, 0xFF, 0x58, + 0x9E, 0x2C, 0x32, 0x6E, 0x16, 0x25, 0xEE, 0x57 + }, + { + 0xD8, 0x87, 0xF5, 0x32, 0xF2, 0x32, 0x94, 0x90, + 0x4E, 0x33, 0x1B, 0x3A, 0x87, 0x27, 0xF4, 0xDC, + 0x65, 0xCA, 0xA7, 0x44, 0x9C, 0x31, 0x12, 0x91, + 0xCF, 0x9C, 0xC7, 0xFB, 0xF8, 0xAC, 0xC4, 0x82, + 0x69, 0x4F, 0x1F, 0xD3, 0xE1, 0xD7, 0x4C, 0x14, + 0x2D, 0x0C, 0x37, 0x62, 0x5A, 0x92, 0xA5, 0xC2, + 0xB5, 0x14, 0x11, 0xB2, 0xCD, 0xF3, 0x93, 0xBD, + 0x48, 0xE3, 0xEE, 0x27, 0x19, 0xFB, 0x70, 0xD6 + }, + { + 0x01, 0xC9, 0xDF, 0x94, 0x1A, 0x64, 0xF7, 0x62, + 0x4B, 0xF6, 0x0F, 0xE2, 0x90, 0xD0, 0x3C, 0xA0, + 0x99, 0x7E, 0x07, 0x11, 0xBA, 0x62, 0x86, 0x21, + 0x4E, 0x48, 0xCA, 0x25, 0xB7, 0xF3, 0xE9, 0x95, + 0xB9, 0x8A, 0x24, 0x5A, 0xE4, 0x45, 0xC8, 0xF6, + 0x93, 0xCC, 0xE6, 0x5C, 0x50, 0x78, 0xBB, 0x8F, + 0x82, 0x73, 0xDE, 0xD5, 0x79, 0xF7, 0x51, 0x01, + 0xB5, 0x3E, 0x90, 0x1E, 0x7F, 0x87, 0xA8, 0x1C + }, + { + 0xA8, 0x04, 0xFE, 0xD1, 0xAD, 0x6A, 0xAE, 0x67, + 0xA0, 0x98, 0xC9, 0xE6, 0x6D, 0x52, 0x95, 0x49, + 0x50, 0x7F, 0xF5, 0xF1, 0xA4, 0xF1, 0xA8, 0x16, + 0xEA, 0xA5, 0xA8, 0x6F, 0xDA, 0xCC, 0x62, 0xB6, + 0x69, 0xD3, 0x87, 0x69, 0x9F, 0x88, 0x9B, 0xF7, + 0x7B, 0x4F, 0xB5, 0x28, 0x3D, 0xAA, 0xE5, 0x87, + 0x48, 0x21, 0x0C, 0xFA, 0xEA, 0xEB, 0x8A, 0xD5, + 0x3E, 0x26, 0x46, 0x80, 0x3D, 0xF8, 0xBF, 0x13 + }, + { + 0x4B, 0xCE, 0x7D, 0xAC, 0x13, 0x1A, 0x2A, 0xA5, + 0x8D, 0xD8, 0xFA, 0x39, 0xC6, 0x9A, 0xB9, 0x20, + 0x19, 0xCE, 0x49, 0x6C, 0x61, 0x90, 0xE6, 0xF3, + 0xB0, 0x4A, 0xB0, 0x4C, 0x84, 0x7F, 0x35, 0x52, + 0xEF, 0x1B, 0x93, 0x70, 0x43, 0xA9, 0xBC, 0x95, + 0x2E, 0xF2, 0x68, 0x87, 0x2E, 0x7E, 0xC1, 0x28, + 0x39, 0xC9, 0x16, 0xE8, 0xC2, 0x29, 0xC5, 0x4F, + 0x40, 0x67, 0x66, 0x06, 0x12, 0xFD, 0x0D, 0x78 + }, + { + 0xD3, 0x2B, 0x1C, 0x69, 0x53, 0x74, 0xA5, 0xA7, + 0x57, 0x4F, 0x09, 0xD8, 0xEA, 0x56, 0x3F, 0xF2, + 0x7E, 0xE8, 0x31, 0xA9, 0xB3, 0xCE, 0x95, 0x05, + 0x69, 0x96, 0xD1, 0xB2, 0xB6, 0x4F, 0x0A, 0x18, + 0xAB, 0x82, 0x41, 0xEE, 0x28, 0x83, 0xAB, 0x55, + 0x08, 0xE7, 0x4A, 0x81, 0x42, 0xAC, 0x2E, 0x11, + 0x60, 0xE9, 0xB9, 0x04, 0xF4, 0x69, 0xBE, 0x94, + 0x50, 0x54, 0x91, 0x46, 0xA8, 0xBF, 0xAC, 0xB6 + }, + { + 0xD1, 0x48, 0xD1, 0xF9, 0xFC, 0x97, 0x27, 0xAB, + 0xF9, 0x6C, 0x8E, 0x2D, 0x20, 0xBC, 0x76, 0x76, + 0xAD, 0xB0, 0x0D, 0xA6, 0x23, 0x06, 0xF9, 0xCD, + 0xEA, 0xAA, 0x6B, 0x82, 0x89, 0xC4, 0xB0, 0x5F, + 0x01, 0xE6, 0xC0, 0xC4, 0xD8, 0x45, 0xC7, 0xDB, + 0x34, 0xE7, 0x53, 0x80, 0x54, 0x3E, 0x5B, 0xB6, + 0x45, 0x0C, 0x2F, 0xBA, 0x40, 0x33, 0xC4, 0xF7, + 0xCC, 0x05, 0xF4, 0x23, 0x6B, 0xFA, 0x82, 0x8C + }, + { + 0xA7, 0xE6, 0x95, 0x27, 0xE0, 0x15, 0xF9, 0x73, + 0x58, 0x72, 0x88, 0x9E, 0xFA, 0x4E, 0x57, 0x18, + 0x81, 0x81, 0x09, 0x02, 0x5C, 0x4F, 0xB3, 0x19, + 0x7D, 0x12, 0x91, 0xCC, 0x52, 0x37, 0xEA, 0x92, + 0x93, 0x42, 0xCA, 0x06, 0x1C, 0x43, 0x44, 0xAD, + 0xB9, 0x8F, 0xA3, 0x15, 0x2B, 0xE3, 0xE7, 0x67, + 0xF9, 0xC6, 0x50, 0x7E, 0xB2, 0x6D, 0xC3, 0x6A, + 0x5C, 0x4E, 0x89, 0xAA, 0x84, 0xC7, 0x47, 0x39 + }, + { + 0x88, 0x5E, 0x3D, 0x9B, 0xB7, 0xA4, 0xA4, 0x31, + 0x78, 0x09, 0xAB, 0x42, 0x7D, 0x8E, 0x29, 0x23, + 0x77, 0x89, 0xDA, 0xD9, 0x4D, 0x53, 0x15, 0xE2, + 0x93, 0x15, 0xC3, 0x97, 0x6D, 0x59, 0x09, 0x78, + 0xF9, 0x0A, 0x56, 0x4A, 0x31, 0xF0, 0xB9, 0xE5, + 0xA7, 0x34, 0xB0, 0x27, 0x62, 0x21, 0xDF, 0xEE, + 0x34, 0x34, 0x32, 0x65, 0x8C, 0x9D, 0x39, 0x22, + 0xCB, 0x89, 0x5D, 0x61, 0xE6, 0x8B, 0x3A, 0xD3 + }, + { + 0x5C, 0x58, 0x8C, 0xCB, 0x3C, 0x6C, 0x6B, 0xB0, + 0x1B, 0x60, 0xEA, 0x14, 0x8A, 0xAB, 0x29, 0x2B, + 0x02, 0xDE, 0x57, 0xC9, 0x19, 0x25, 0x14, 0x58, + 0xCF, 0x1D, 0x17, 0x03, 0x6D, 0xE2, 0x5B, 0x02, + 0xEF, 0x40, 0x64, 0x2A, 0x13, 0xDF, 0x7D, 0xCC, + 0x42, 0x50, 0xE9, 0xC1, 0x84, 0x1F, 0x75, 0x43, + 0x1A, 0xC0, 0x6D, 0x10, 0xFB, 0xB7, 0x3A, 0x0A, + 0x00, 0xBD, 0x60, 0x3F, 0xE9, 0xAE, 0xC3, 0xD2 + }, + { + 0xB1, 0x27, 0x66, 0xA3, 0xDD, 0x39, 0xC3, 0x74, + 0x6E, 0xF6, 0xF6, 0xC0, 0xC9, 0xA7, 0xC9, 0x24, + 0x85, 0x5D, 0xB2, 0xE5, 0x6F, 0x65, 0xB2, 0x43, + 0x6A, 0x47, 0x21, 0xDF, 0x94, 0x9A, 0xC5, 0xE9, + 0x45, 0x8A, 0x36, 0xA4, 0xC3, 0x80, 0xD8, 0xE8, + 0x55, 0x90, 0x2B, 0x9D, 0xB6, 0x84, 0xD7, 0xB7, + 0x79, 0x74, 0xD1, 0x85, 0x53, 0xBA, 0xD0, 0x35, + 0x68, 0x3B, 0x5F, 0xBC, 0x06, 0x78, 0xE5, 0x16 + }, + { + 0x1D, 0x83, 0xE7, 0xB7, 0x1E, 0x1F, 0xA3, 0x99, + 0xE7, 0xBD, 0x86, 0x52, 0xE8, 0xB5, 0x62, 0x98, + 0x80, 0x4A, 0x5E, 0x41, 0xBB, 0x84, 0x87, 0xE0, + 0xE5, 0xED, 0xB4, 0xBD, 0x58, 0x5D, 0x1C, 0xE0, + 0x26, 0xB6, 0xE9, 0xCD, 0xD8, 0x31, 0x52, 0xE7, + 0x1F, 0xB9, 0x5E, 0xB5, 0x23, 0xFB, 0xEE, 0xCD, + 0xCC, 0xFD, 0xB8, 0xD7, 0x93, 0x93, 0x10, 0x5C, + 0xEF, 0xB5, 0xC1, 0x34, 0xB9, 0x72, 0x6B, 0xEF + }, + { + 0xEA, 0x21, 0x4F, 0xCF, 0x15, 0xDE, 0x1C, 0x45, + 0xF8, 0x21, 0xCF, 0xD0, 0x64, 0x80, 0x75, 0x68, + 0x86, 0xC9, 0x2B, 0x29, 0xCF, 0x1E, 0xDC, 0x21, + 0x7F, 0xB5, 0xC7, 0xB8, 0x7B, 0xCE, 0xF7, 0xEA, + 0x79, 0x90, 0x53, 0x78, 0xC8, 0x22, 0x0B, 0x25, + 0xD3, 0x8E, 0xC0, 0x7D, 0xF4, 0x66, 0x0C, 0xFB, + 0x9E, 0xC4, 0x48, 0x15, 0xCC, 0x56, 0x3E, 0x0F, + 0x78, 0x16, 0xA1, 0x5C, 0xF0, 0xEA, 0x7F, 0x0F + }, + { + 0x2C, 0x5D, 0x41, 0xE5, 0x6A, 0x03, 0xB4, 0x41, + 0x42, 0x49, 0xF0, 0xDB, 0xC4, 0xDE, 0x88, 0xD9, + 0xBB, 0x88, 0xF5, 0x7B, 0x18, 0x39, 0x9F, 0x53, + 0xF2, 0xEE, 0xE2, 0x12, 0x4A, 0x9E, 0xC0, 0xD6, + 0x30, 0xAF, 0x79, 0xE4, 0xB9, 0x02, 0x03, 0x8C, + 0xBB, 0xC9, 0x6D, 0xFE, 0xCF, 0xCB, 0x82, 0x79, + 0x17, 0xA5, 0x78, 0x21, 0xE9, 0x56, 0xC3, 0x64, + 0x40, 0xCE, 0x8A, 0x7E, 0xD8, 0xBC, 0x14, 0x33 + }, + { + 0x0F, 0xD2, 0xD2, 0x24, 0x9A, 0xF5, 0xFC, 0xB4, + 0x40, 0x63, 0xE2, 0x1F, 0x7B, 0x9D, 0xF1, 0xEA, + 0x43, 0x0E, 0xEC, 0x02, 0xE4, 0x93, 0x20, 0x69, + 0x88, 0xCC, 0x71, 0xBB, 0x4C, 0x73, 0xBF, 0x94, + 0xDF, 0x92, 0x2D, 0xF4, 0x64, 0x3E, 0x24, 0xF5, + 0x2C, 0xAB, 0x75, 0xA1, 0x36, 0x02, 0x00, 0x22, + 0x17, 0x18, 0xA7, 0x3C, 0x0A, 0x33, 0x7A, 0x62, + 0x78, 0x77, 0x28, 0x13, 0xE8, 0x6D, 0x3A, 0x83 + }, + { + 0x90, 0x5B, 0x67, 0x7A, 0xD9, 0x6B, 0x2B, 0xA5, + 0x27, 0x44, 0x87, 0x6B, 0xFC, 0x0B, 0x5F, 0xB9, + 0xC3, 0x7E, 0x2F, 0x46, 0x35, 0x24, 0xDE, 0x91, + 0xDA, 0x89, 0x68, 0xD6, 0x99, 0x79, 0xDB, 0x45, + 0x35, 0x23, 0x3F, 0x07, 0x06, 0x05, 0x4C, 0x2E, + 0x17, 0x5F, 0xD5, 0xB8, 0x66, 0xA8, 0x60, 0xF2, + 0x47, 0x10, 0xF5, 0xA6, 0x67, 0x27, 0x3B, 0xD2, + 0x6E, 0x9D, 0x38, 0x1C, 0x25, 0xC0, 0xA2, 0x8B + }, + { + 0xE5, 0xD3, 0xBC, 0x0C, 0xA0, 0x15, 0x59, 0x10, + 0xF0, 0x24, 0xAE, 0xA1, 0x4D, 0xB0, 0x7F, 0x20, + 0x96, 0xDE, 0xD2, 0x7C, 0x74, 0xCD, 0x38, 0x08, + 0x46, 0xD3, 0x82, 0xF6, 0xA2, 0xF9, 0x52, 0xF3, + 0x1D, 0x41, 0x67, 0xC8, 0x24, 0xCF, 0x7A, 0x55, + 0x8D, 0x8B, 0xA3, 0xEE, 0x56, 0x6E, 0x05, 0x90, + 0x98, 0xA5, 0x3F, 0x40, 0x0E, 0x96, 0x0F, 0xFF, + 0x67, 0xEE, 0x1E, 0x7D, 0x07, 0xC8, 0xBA, 0xD0 + }, + { + 0xFA, 0xDE, 0x2C, 0x25, 0x61, 0xE1, 0x55, 0x40, + 0x36, 0xA5, 0x70, 0x31, 0x06, 0x3F, 0x41, 0xEB, + 0xA6, 0xAE, 0x13, 0x01, 0xCD, 0x7D, 0x97, 0x0E, + 0x5B, 0xA8, 0x68, 0x9B, 0x47, 0x37, 0xA9, 0x72, + 0x1F, 0xC8, 0xFF, 0xE2, 0x08, 0x3A, 0x8C, 0x28, + 0xC9, 0xA8, 0x14, 0x20, 0xA7, 0xEF, 0xA2, 0xE8, + 0xF0, 0x50, 0x1A, 0xD8, 0x68, 0xDA, 0x6D, 0x87, + 0xCE, 0xC0, 0x29, 0x09, 0xF0, 0xBA, 0xAA, 0xE8 + }, + { + 0x47, 0xAF, 0xD0, 0x7E, 0xEF, 0x86, 0xBD, 0xCE, + 0x5C, 0xB3, 0xA4, 0xA5, 0xB6, 0xF8, 0xC9, 0x55, + 0x4A, 0xF4, 0x61, 0xAF, 0x71, 0x34, 0xC4, 0xC1, + 0x06, 0x9B, 0x65, 0xB2, 0xD2, 0xB3, 0xF7, 0x38, + 0xA8, 0x5D, 0x75, 0x10, 0x11, 0xFE, 0xCF, 0xF3, + 0xF2, 0xBA, 0x5B, 0x2D, 0x68, 0x6D, 0xC0, 0x6E, + 0xDC, 0xB9, 0x4B, 0xA9, 0x5F, 0x15, 0xCE, 0xB2, + 0xBE, 0xB8, 0x21, 0x9F, 0x7E, 0x9C, 0xF2, 0x11 + }, + { + 0x82, 0xE6, 0x0D, 0x6A, 0xF2, 0x0D, 0xE9, 0x8F, + 0x4B, 0x3D, 0xBE, 0xF5, 0x74, 0x00, 0x83, 0x82, + 0x99, 0x59, 0x7D, 0x1F, 0xA8, 0x50, 0x37, 0xA2, + 0x87, 0x39, 0x44, 0xA2, 0xB1, 0x7A, 0xDD, 0x61, + 0x49, 0x5F, 0x1A, 0x81, 0x15, 0xD6, 0xF2, 0xD7, + 0x55, 0x1E, 0x47, 0x68, 0xE4, 0x35, 0x2B, 0xD1, + 0x8A, 0xF0, 0x88, 0x44, 0x29, 0x9C, 0x23, 0x7E, + 0x78, 0x72, 0x98, 0x66, 0xD7, 0xDC, 0x07, 0x80 + }, + { + 0x76, 0x91, 0xE7, 0x13, 0xAE, 0x67, 0xB4, 0xD0, + 0x28, 0x4F, 0x55, 0x23, 0x83, 0xA6, 0xE6, 0x81, + 0x66, 0x3B, 0xCF, 0x83, 0xDC, 0x44, 0x6A, 0xEB, + 0x28, 0xE4, 0x5A, 0x7A, 0xC9, 0x31, 0x95, 0x0E, + 0xC1, 0xD7, 0x68, 0x6E, 0xAB, 0xC3, 0x7B, 0x97, + 0xC2, 0xA8, 0x3F, 0x89, 0xEF, 0x16, 0x04, 0xDE, + 0x29, 0xEC, 0x7B, 0x03, 0x2D, 0x63, 0xBE, 0x72, + 0xB3, 0xAA, 0x77, 0xD7, 0xEB, 0x51, 0x72, 0x93 + }, + { + 0xC4, 0xB2, 0x77, 0x54, 0xFC, 0xB4, 0xDF, 0x87, + 0x6D, 0x0A, 0x14, 0xF0, 0xC6, 0x0B, 0x6B, 0x98, + 0x52, 0x27, 0x82, 0x2C, 0xF4, 0x41, 0xED, 0x66, + 0x2E, 0x46, 0x3D, 0x13, 0x50, 0x6C, 0xC3, 0xAB, + 0x24, 0x58, 0x35, 0xBB, 0x4E, 0x5A, 0x89, 0x22, + 0xAD, 0x8E, 0x3E, 0x74, 0xD1, 0x82, 0x5B, 0x94, + 0x67, 0xE1, 0xD4, 0xAC, 0xFD, 0x20, 0xC8, 0x06, + 0xA0, 0xD4, 0xD3, 0x33, 0xC4, 0x9F, 0x97, 0x1A + }, + { + 0xD1, 0xA5, 0x49, 0x68, 0x51, 0xD6, 0xDD, 0x4C, + 0xC1, 0x9C, 0x46, 0x6D, 0x78, 0xB4, 0x39, 0x3F, + 0xF5, 0x57, 0x08, 0x82, 0x4D, 0x1E, 0x77, 0x4E, + 0x57, 0x23, 0x83, 0x8E, 0x1A, 0x54, 0x6E, 0x0F, + 0xBC, 0x06, 0xB1, 0x6E, 0x82, 0x17, 0x59, 0xA6, + 0x6D, 0xBD, 0xD0, 0xFF, 0xF2, 0xC3, 0x18, 0xC3, + 0xB0, 0x9B, 0xCB, 0xCD, 0x88, 0x90, 0x89, 0xBC, + 0x00, 0xBE, 0xD4, 0x8D, 0x21, 0xDD, 0x42, 0xAE + }, + { + 0x13, 0x58, 0xAF, 0x4A, 0x0C, 0x6E, 0x29, 0x47, + 0xB0, 0x66, 0x1D, 0x1F, 0xF7, 0x98, 0x59, 0x8F, + 0x72, 0xE2, 0x75, 0x97, 0x54, 0x37, 0xF5, 0xD0, + 0xDD, 0xBE, 0xD9, 0x7C, 0x75, 0xE7, 0xB9, 0xFA, + 0x4C, 0xB5, 0x6E, 0x0A, 0x02, 0x12, 0x97, 0x51, + 0x2A, 0x5A, 0xAE, 0x0C, 0xD3, 0x79, 0xE3, 0xDE, + 0xF2, 0xDD, 0xB3, 0xC4, 0xCE, 0x92, 0xB1, 0x8B, + 0x93, 0x57, 0x56, 0x3C, 0x36, 0xA0, 0x26, 0x31 + }, + { + 0x98, 0x5C, 0x3D, 0x70, 0xAC, 0x8E, 0x31, 0xEE, + 0xB5, 0x4D, 0xE3, 0x7D, 0xDA, 0x1E, 0x18, 0x1D, + 0x32, 0x4F, 0xC2, 0xC6, 0x2B, 0x63, 0x39, 0x54, + 0xE2, 0x2A, 0xEF, 0x7E, 0x79, 0xC2, 0x28, 0x54, + 0xFB, 0x0A, 0x83, 0x6D, 0x24, 0x53, 0x1F, 0xF6, + 0xEF, 0xAF, 0x77, 0x3F, 0x57, 0xA8, 0x25, 0x1D, + 0x78, 0x6F, 0x15, 0xE9, 0xEF, 0x51, 0x93, 0xD3, + 0x67, 0xAB, 0x34, 0x20, 0xE4, 0x3F, 0x8B, 0x9C + }, + { + 0x92, 0x2F, 0x2D, 0x6A, 0x32, 0x85, 0x0A, 0x94, + 0x96, 0x17, 0xC0, 0x37, 0xA4, 0xA7, 0x6A, 0x31, + 0x60, 0xD2, 0x52, 0x14, 0x3F, 0x2E, 0x4A, 0x14, + 0x2D, 0xDC, 0x31, 0x42, 0x32, 0x55, 0x63, 0x99, + 0xB7, 0xC2, 0x97, 0x72, 0x2F, 0x1E, 0xEC, 0x33, + 0x9A, 0x79, 0x31, 0x7D, 0x8C, 0xC4, 0x57, 0xC4, + 0x82, 0xCE, 0xFB, 0x22, 0xB3, 0xDC, 0x13, 0x81, + 0x2C, 0x99, 0xDB, 0x51, 0xB5, 0xD6, 0xDC, 0x93 + }, + { + 0xFB, 0x5C, 0xD0, 0x0F, 0xF9, 0x81, 0xE8, 0xEA, + 0x76, 0xAC, 0xD1, 0xCE, 0x03, 0xD1, 0x06, 0x8E, + 0xA1, 0x23, 0x94, 0xEF, 0x83, 0x84, 0x7F, 0x46, + 0xD7, 0xED, 0x3C, 0xE3, 0x4E, 0x01, 0x34, 0x3C, + 0x36, 0x38, 0x4F, 0xDA, 0xB6, 0xFB, 0x3F, 0x86, + 0x5B, 0xFA, 0x2A, 0x95, 0x32, 0x95, 0x59, 0xD0, + 0xA2, 0xD0, 0x9A, 0xBF, 0xD3, 0x27, 0x97, 0x42, + 0x2C, 0xC3, 0x04, 0xCF, 0xCC, 0x55, 0x7F, 0x04 + }, + { + 0x45, 0xD9, 0x96, 0xF5, 0xD4, 0x9A, 0x1A, 0x37, + 0x7D, 0xC5, 0xCA, 0x41, 0xA4, 0x80, 0xA7, 0xE7, + 0x86, 0x8A, 0xEF, 0x20, 0x4A, 0xE3, 0x5F, 0xEB, + 0x8D, 0x92, 0x71, 0x99, 0x9A, 0xE3, 0xB4, 0x2A, + 0x9D, 0xEF, 0xB6, 0x53, 0x97, 0xD7, 0x27, 0x2A, + 0x3E, 0x44, 0xC3, 0xED, 0x04, 0x5C, 0xF9, 0x2F, + 0x87, 0x4F, 0x11, 0xEE, 0x8D, 0x4F, 0x52, 0x3E, + 0x00, 0x81, 0x78, 0x27, 0x52, 0x7E, 0xD9, 0xAC + }, + { + 0x4C, 0xB8, 0xEB, 0x27, 0x31, 0x81, 0xF5, 0xBA, + 0x0F, 0x5A, 0xEF, 0x35, 0xD8, 0x14, 0x3F, 0x32, + 0xFF, 0x67, 0x5A, 0x3D, 0x0C, 0x8D, 0x26, 0xF1, + 0x25, 0xCD, 0x96, 0x2A, 0x26, 0x1E, 0x9D, 0x9F, + 0x11, 0x4A, 0x28, 0xAA, 0x9C, 0x0F, 0x40, 0x84, + 0xFA, 0x31, 0xD6, 0xC4, 0x29, 0xCF, 0x10, 0xED, + 0x44, 0x91, 0x98, 0x67, 0x49, 0xF9, 0xB7, 0x7F, + 0x0D, 0x99, 0x0A, 0xC9, 0xB9, 0x73, 0x89, 0x78 + }, + { + 0x94, 0x73, 0xED, 0x31, 0x72, 0xF8, 0x8C, 0x59, + 0xF4, 0xD3, 0x25, 0x8C, 0x77, 0xF9, 0x4D, 0x53, + 0xFA, 0x76, 0x4F, 0x0A, 0x67, 0x41, 0x63, 0x5E, + 0x23, 0x7C, 0x6E, 0xD4, 0x3F, 0xB0, 0xCA, 0x4B, + 0xC8, 0x95, 0xD0, 0xF4, 0x05, 0x99, 0xD4, 0xF7, + 0x0D, 0x1A, 0x9A, 0x0E, 0x6A, 0x04, 0x6C, 0x9C, + 0xB8, 0x5C, 0x43, 0x88, 0xA6, 0x44, 0xC7, 0xB4, + 0xF5, 0xE2, 0x24, 0xE1, 0x07, 0x0D, 0xF1, 0xBA + }, + { + 0xCF, 0xF5, 0x28, 0xDA, 0x92, 0x5F, 0xC0, 0xB3, + 0x2E, 0x9D, 0x55, 0xA4, 0x98, 0x81, 0xE2, 0x49, + 0xB7, 0xCA, 0x94, 0x43, 0x3E, 0x63, 0x2A, 0x60, + 0x77, 0xEF, 0x27, 0x76, 0x77, 0x5B, 0x08, 0x8C, + 0xFD, 0x3F, 0xD6, 0x74, 0x8C, 0x74, 0xB9, 0x1D, + 0x27, 0x20, 0x48, 0xF7, 0x4F, 0x64, 0x82, 0xAD, + 0xAE, 0xBC, 0x57, 0xE1, 0x20, 0xD0, 0x45, 0x08, + 0x57, 0x47, 0x34, 0x36, 0x3B, 0xCB, 0xC4, 0xD8 + }, + { + 0x1B, 0xB3, 0x99, 0x27, 0xC2, 0xC2, 0x36, 0x9C, + 0xD5, 0x84, 0xFA, 0x1E, 0x41, 0xE3, 0xDB, 0x53, + 0x13, 0x7A, 0xBB, 0xCE, 0x53, 0xB3, 0x17, 0xB1, + 0xFA, 0xD4, 0xE3, 0xFC, 0xAD, 0x2B, 0x45, 0xE6, + 0x44, 0xA1, 0xA2, 0x11, 0xA0, 0x29, 0xFF, 0xAA, + 0xCF, 0xBD, 0xEC, 0x94, 0x71, 0x61, 0xE5, 0x18, + 0x22, 0x9A, 0xE5, 0xE0, 0xA3, 0xD8, 0x0A, 0x02, + 0x6C, 0xB4, 0x37, 0x88, 0x50, 0x37, 0x22, 0x23 + }, + { + 0x9B, 0x99, 0xC0, 0xCB, 0x05, 0xD8, 0xAB, 0x41, + 0x1D, 0xBE, 0xE0, 0x9E, 0xB5, 0x84, 0x02, 0xBF, + 0x0B, 0x70, 0xD3, 0x89, 0x40, 0xC8, 0xD3, 0xAD, + 0xAF, 0x20, 0x87, 0xB7, 0xBD, 0x1D, 0x9F, 0xD0, + 0x44, 0x9E, 0x27, 0xD8, 0x2F, 0x88, 0x82, 0x22, + 0xCB, 0x2A, 0x85, 0xC7, 0x3A, 0x21, 0xE4, 0xFF, + 0x6E, 0x69, 0x45, 0x65, 0x51, 0x6B, 0x0D, 0xFB, + 0xAA, 0xF5, 0xBA, 0xF4, 0x7A, 0x49, 0xD9, 0x1E + }, + { + 0xEC, 0xCB, 0xCB, 0xF1, 0xC6, 0xA0, 0x74, 0xF1, + 0x96, 0xEB, 0x60, 0x3B, 0xDB, 0x38, 0x5B, 0x0B, + 0x7D, 0x9C, 0xAD, 0xBA, 0xF5, 0xBA, 0x22, 0xD6, + 0x2D, 0xBA, 0x17, 0x82, 0xA5, 0xDB, 0x74, 0x19, + 0x29, 0xD8, 0x73, 0x81, 0x3A, 0x53, 0xBB, 0xE6, + 0xF8, 0x01, 0x8E, 0x18, 0x04, 0xFD, 0x8B, 0x69, + 0xFF, 0xBE, 0xBC, 0x3E, 0xB6, 0x0C, 0x77, 0xEB, + 0xC0, 0x7D, 0xEF, 0xF5, 0x81, 0xF1, 0xC0, 0xEE + }, + { + 0x9B, 0x33, 0x98, 0x23, 0x98, 0x35, 0xB2, 0x17, + 0x48, 0x8A, 0xD7, 0xCB, 0x39, 0xB3, 0xE3, 0x63, + 0xEC, 0xFF, 0xF9, 0xB3, 0x5D, 0x73, 0x6B, 0x2D, + 0x33, 0x3F, 0x59, 0x30, 0x22, 0x08, 0x1A, 0xA9, + 0x82, 0x2F, 0xFA, 0x4E, 0x45, 0x52, 0xD4, 0x0B, + 0xAF, 0xD5, 0x83, 0x17, 0xF4, 0x76, 0x87, 0xA7, + 0x36, 0x4D, 0x1E, 0xB2, 0xDC, 0x52, 0x91, 0x3A, + 0xC2, 0x89, 0xA7, 0x03, 0x50, 0xD7, 0x6D, 0xF3 + }, + { + 0x9E, 0x14, 0xAB, 0x16, 0x3F, 0xE5, 0x78, 0xE6, + 0x49, 0x46, 0xC8, 0xDD, 0x7A, 0x42, 0x8C, 0xFD, + 0x5F, 0x0C, 0xB5, 0x0D, 0x58, 0x0D, 0x82, 0xF4, + 0x0B, 0x25, 0x5A, 0x80, 0x17, 0x5C, 0xF5, 0xC3, + 0x66, 0xBC, 0x50, 0x09, 0x43, 0x9D, 0x23, 0x47, + 0x02, 0x9E, 0x1C, 0x5E, 0x82, 0x83, 0x49, 0x2C, + 0xEF, 0x3C, 0xC4, 0x29, 0xD6, 0x64, 0xE4, 0x72, + 0x87, 0x1F, 0xBF, 0xA6, 0x55, 0x67, 0xF0, 0x21 + }, + { + 0x3A, 0x19, 0xBF, 0x91, 0xFE, 0xF2, 0xF1, 0x3C, + 0x4E, 0x03, 0x6D, 0x9D, 0xF8, 0xF3, 0x04, 0xF8, + 0xBE, 0xCA, 0xC0, 0xA9, 0x4F, 0x0F, 0xA6, 0x9A, + 0x67, 0xA7, 0x04, 0x84, 0x0B, 0xDE, 0x7E, 0xA7, + 0xD6, 0xC3, 0xF2, 0x99, 0x89, 0x4A, 0x6F, 0xB0, + 0x70, 0x8E, 0x3D, 0x92, 0xEC, 0x70, 0x1E, 0x13, + 0xC0, 0x19, 0x2F, 0x3E, 0x0F, 0x1D, 0x18, 0xBB, + 0x18, 0xE8, 0xA2, 0x9A, 0x56, 0xC3, 0xE7, 0xD8 + }, + { + 0xBE, 0x69, 0x60, 0x17, 0x74, 0xC3, 0xB4, 0x23, + 0x69, 0x9E, 0x75, 0x2F, 0x37, 0xD9, 0x4F, 0x3D, + 0x43, 0x10, 0xDD, 0xCB, 0xB6, 0x0B, 0xD4, 0xE7, + 0x41, 0x58, 0x89, 0x6A, 0x34, 0xB3, 0x60, 0x14, + 0x43, 0x78, 0x28, 0x3E, 0x71, 0xFA, 0xE3, 0xE6, + 0x61, 0xBA, 0xBC, 0x3D, 0x2D, 0x9A, 0x1D, 0xC9, + 0x41, 0x73, 0x56, 0x6A, 0xFF, 0xA7, 0xF5, 0xE5, + 0x8D, 0xA2, 0xFB, 0xA5, 0x3E, 0x4D, 0xC3, 0x54 + }, + { + 0xB7, 0x53, 0x2D, 0x47, 0xC8, 0x95, 0x8C, 0x9F, + 0xC3, 0xB8, 0x94, 0x77, 0x33, 0x95, 0x6B, 0x9A, + 0x65, 0x99, 0x6C, 0x14, 0x51, 0xC9, 0xB3, 0x6B, + 0x85, 0x43, 0x38, 0x0A, 0x58, 0x16, 0x74, 0xAF, + 0x2C, 0x31, 0xAB, 0xF3, 0x40, 0x67, 0x97, 0x10, + 0x08, 0xB7, 0x06, 0xC3, 0x67, 0x8C, 0x61, 0x61, + 0x04, 0x86, 0x0F, 0xF8, 0x5D, 0x61, 0x24, 0xF5, + 0xAA, 0x20, 0x07, 0xD5, 0x54, 0x57, 0x50, 0xCA + }, + { + 0x0E, 0xAF, 0x9B, 0x72, 0x76, 0xE4, 0x90, 0xFA, + 0x5E, 0xB3, 0x0A, 0xCE, 0x90, 0x8D, 0x6B, 0xC6, + 0x23, 0x39, 0xB6, 0x9E, 0xCC, 0x48, 0x5C, 0x9F, + 0xD2, 0x5F, 0x43, 0x7E, 0xB1, 0x1C, 0x43, 0x62, + 0xF9, 0x90, 0xCC, 0x65, 0x93, 0x87, 0x3E, 0xA3, + 0xBD, 0x45, 0xA0, 0x61, 0x6E, 0xE3, 0x31, 0x6C, + 0xE8, 0x3D, 0x8B, 0x3F, 0x3C, 0xFF, 0x3A, 0x79, + 0x47, 0xD6, 0x88, 0xA3, 0x57, 0x5D, 0x79, 0x9F + }, + { + 0x07, 0xF5, 0x0B, 0x95, 0xAD, 0x45, 0x7D, 0xC3, + 0x8E, 0x17, 0x4E, 0xFD, 0x37, 0x77, 0x76, 0xDE, + 0x21, 0x9D, 0x81, 0xE1, 0x85, 0xCB, 0x23, 0x79, + 0xAA, 0x90, 0xBD, 0x9D, 0xF7, 0x42, 0x04, 0xAB, + 0x84, 0x9E, 0xAD, 0x6C, 0xFD, 0x17, 0x15, 0xCA, + 0x07, 0xF4, 0x4B, 0xB6, 0x58, 0x6B, 0x1E, 0x40, + 0xB2, 0x35, 0x1E, 0x97, 0x29, 0x35, 0x4E, 0xB5, + 0x42, 0x23, 0xCF, 0xD8, 0xD2, 0xCE, 0x10, 0xB8 + }, + { + 0x4C, 0x63, 0x36, 0x2B, 0x93, 0x0E, 0xA9, 0x8D, + 0x26, 0x63, 0xBE, 0xD8, 0x72, 0x8A, 0xD1, 0x39, + 0xAE, 0xEC, 0x7D, 0xAA, 0x7B, 0x68, 0x03, 0x1C, + 0x9D, 0x53, 0x04, 0x84, 0x60, 0x54, 0xD3, 0x5E, + 0xE6, 0x2E, 0x2B, 0xBC, 0xD2, 0x24, 0x13, 0xDB, + 0x88, 0x75, 0x7E, 0x01, 0xE5, 0x12, 0x10, 0xE3, + 0x18, 0xE7, 0x97, 0x46, 0x2D, 0x7D, 0x2D, 0xE9, + 0x21, 0x97, 0x21, 0x02, 0x67, 0xDA, 0x6B, 0xCD + }, + { + 0x81, 0x9C, 0x11, 0x19, 0xBA, 0x19, 0x87, 0x93, + 0x69, 0xFD, 0xA3, 0x6E, 0x9F, 0xE9, 0xC8, 0x1F, + 0x82, 0xDA, 0x87, 0xAC, 0x6D, 0xFB, 0x3B, 0x8D, + 0x15, 0x9D, 0x0C, 0xE5, 0xA8, 0xF2, 0xFB, 0xDC, + 0x3A, 0x27, 0xA9, 0xA8, 0x2A, 0xCE, 0x54, 0x08, + 0x33, 0xF6, 0x0E, 0xD8, 0x8F, 0x19, 0x70, 0x62, + 0x24, 0xDA, 0x5A, 0xFB, 0x47, 0x98, 0xD6, 0x2A, + 0xEA, 0xCC, 0x62, 0xB8, 0x78, 0x1F, 0x67, 0xC5 + }, + { + 0xD0, 0x6E, 0x74, 0xB4, 0x76, 0xA0, 0x25, 0x05, + 0x24, 0x4D, 0x3C, 0xC4, 0x12, 0xFD, 0x21, 0x74, + 0xCE, 0x37, 0x62, 0x33, 0x02, 0x03, 0xFF, 0xA9, + 0x50, 0x1B, 0xE5, 0x68, 0x93, 0xC1, 0x64, 0x1B, + 0xD9, 0xC7, 0x3B, 0x0D, 0x6E, 0x80, 0xC8, 0x39, + 0x38, 0x93, 0x1C, 0xD1, 0x3F, 0x6B, 0x32, 0x29, + 0xDA, 0x58, 0x8B, 0xFF, 0xE9, 0xCC, 0xD4, 0x96, + 0x0A, 0xBD, 0x48, 0xBF, 0x03, 0x9A, 0x94, 0x7E + }, + { + 0x7A, 0x08, 0xC2, 0xEB, 0xCF, 0x08, 0xA2, 0x8C, + 0xB1, 0x2C, 0x64, 0x20, 0xCC, 0xC0, 0xE4, 0x85, + 0x58, 0xC0, 0x01, 0xAE, 0x6A, 0xF1, 0xF7, 0xA7, + 0x7B, 0xD9, 0x83, 0xBB, 0x2A, 0xBB, 0x5D, 0x40, + 0x09, 0x3F, 0x3C, 0x80, 0x61, 0x3B, 0x4C, 0xA6, + 0xC0, 0x60, 0x81, 0xC0, 0x59, 0x4B, 0x49, 0xC8, + 0x7C, 0x41, 0xB8, 0xC9, 0x02, 0x3A, 0xA6, 0x25, + 0xA5, 0xD0, 0x05, 0x70, 0x2C, 0x61, 0xE2, 0x67 + }, + { + 0x2D, 0x22, 0x70, 0xAB, 0xD2, 0x1B, 0xB3, 0x56, + 0x51, 0x7C, 0x57, 0x7A, 0x0C, 0x45, 0x91, 0xB8, + 0x50, 0x76, 0xCB, 0xD8, 0x37, 0x4B, 0xE3, 0x22, + 0xCB, 0xE8, 0xAA, 0x59, 0x96, 0x20, 0xF9, 0xA1, + 0xF7, 0x39, 0x03, 0xF5, 0x2B, 0x01, 0x41, 0x41, + 0x41, 0x30, 0x66, 0x2F, 0x05, 0x4F, 0x1D, 0x69, + 0xFB, 0xF1, 0xAF, 0x9D, 0xB0, 0xDA, 0xD5, 0xF6, + 0x8B, 0x2D, 0x3C, 0x8E, 0x56, 0x92, 0x6A, 0x36 + }, + { + 0x3E, 0x28, 0xD2, 0xAE, 0xA2, 0x38, 0x4A, 0x15, + 0x4A, 0xB2, 0x0D, 0x54, 0x44, 0x8D, 0x00, 0x18, + 0x86, 0x71, 0x80, 0xE3, 0x32, 0x63, 0xE8, 0xFC, + 0x9C, 0xD4, 0x12, 0x0F, 0xF5, 0x8A, 0x7E, 0xB9, + 0x82, 0xF8, 0x21, 0x82, 0x5D, 0x0E, 0x8C, 0x5E, + 0x33, 0x99, 0x46, 0xC2, 0x3C, 0x84, 0xEF, 0xC2, + 0x8F, 0x83, 0x6B, 0xCF, 0xF4, 0xFD, 0xA9, 0xFB, + 0x39, 0x65, 0x43, 0xCB, 0x61, 0xBB, 0x03, 0xFF + }, + { + 0x34, 0x09, 0x87, 0x07, 0xBA, 0x33, 0x4B, 0x69, + 0xA1, 0xF4, 0xE8, 0x2E, 0xF9, 0x4F, 0x1B, 0xC1, + 0x26, 0x67, 0xBB, 0xD9, 0xE5, 0xC4, 0xE7, 0x81, + 0x21, 0xA3, 0x66, 0x46, 0xC2, 0x0D, 0xE6, 0xE0, + 0x93, 0xC1, 0x31, 0x9D, 0x25, 0x89, 0x13, 0xE3, + 0x5C, 0xEB, 0x5B, 0xF1, 0xB2, 0x40, 0x50, 0x52, + 0x99, 0xC5, 0x1B, 0x65, 0x54, 0xF6, 0xA5, 0x25, + 0xC5, 0xA8, 0xCE, 0xE0, 0x36, 0xDD, 0x5A, 0x03 + }, + { + 0x17, 0x6F, 0xCD, 0x9A, 0x2A, 0x09, 0x39, 0x73, + 0xC2, 0x1D, 0x17, 0x70, 0x9E, 0x1A, 0x8A, 0x91, + 0x14, 0x66, 0xE2, 0x8B, 0xFB, 0x0D, 0xAC, 0x8B, + 0xE6, 0x2F, 0xB8, 0x0E, 0x4B, 0x3A, 0xA9, 0x91, + 0x5F, 0x2C, 0x88, 0x66, 0xCD, 0x09, 0x1C, 0x3A, + 0x9F, 0x15, 0x14, 0x45, 0x4B, 0x7B, 0x28, 0x54, + 0xBB, 0x65, 0xB4, 0x76, 0x1F, 0x95, 0xE8, 0x09, + 0xDF, 0x0D, 0xDE, 0x10, 0x7E, 0xB4, 0x5F, 0x1B + }, + { + 0x47, 0xA1, 0xD2, 0x59, 0x66, 0x14, 0xCC, 0x71, + 0x83, 0x78, 0x87, 0xCC, 0xE1, 0x1D, 0xD3, 0x37, + 0x6B, 0x1C, 0x6C, 0x8C, 0x3D, 0xAC, 0xA2, 0x4D, + 0x48, 0x9C, 0x62, 0x73, 0x2E, 0xE5, 0xA6, 0x20, + 0xAC, 0xF2, 0x2D, 0x51, 0x05, 0xA9, 0xBC, 0xD0, + 0xE6, 0x82, 0x56, 0x8B, 0x94, 0xCD, 0x1C, 0x57, + 0x04, 0xED, 0x60, 0x58, 0xBD, 0x47, 0x84, 0xE6, + 0x2E, 0x38, 0x48, 0x3B, 0x7C, 0x91, 0xEE, 0x95 + }, + { + 0x6B, 0xA2, 0xC5, 0x99, 0xF2, 0x32, 0xA2, 0xD6, + 0x2B, 0x8B, 0xFC, 0x1D, 0xAC, 0x71, 0xFF, 0x27, + 0xD9, 0x97, 0x58, 0xA3, 0xBD, 0xD6, 0x1D, 0xF1, + 0x28, 0x3D, 0x82, 0xD0, 0xBA, 0x96, 0x8B, 0x22, + 0xCA, 0x4A, 0x29, 0xBD, 0x10, 0xC2, 0x53, 0x5A, + 0xAD, 0xC8, 0x9A, 0x62, 0x03, 0xC8, 0x8C, 0x04, + 0x15, 0x19, 0x5C, 0x50, 0xD9, 0x72, 0x69, 0xA6, + 0xE3, 0xD3, 0x4B, 0x5F, 0x33, 0xD8, 0xB1, 0x71 + }, + { + 0x5B, 0x22, 0x6C, 0xA1, 0xC4, 0xAB, 0xEC, 0x79, + 0x9C, 0xE9, 0x2E, 0xF9, 0x49, 0xF8, 0xB2, 0x1E, + 0x8E, 0x72, 0x2C, 0xAE, 0x49, 0x04, 0xE7, 0x67, + 0x1C, 0xDB, 0xC2, 0xBF, 0x71, 0x73, 0x2E, 0x17, + 0x82, 0xA3, 0x8A, 0x72, 0xC1, 0x2F, 0x6C, 0xBD, + 0xB7, 0xE4, 0x4F, 0x6F, 0x14, 0xAC, 0x99, 0x4C, + 0x07, 0xAF, 0x83, 0xF1, 0x55, 0x3A, 0xA5, 0x4F, + 0x0C, 0x4C, 0xF6, 0x72, 0xB1, 0xF1, 0xDE, 0xB9 + }, + { + 0xF2, 0x15, 0x7A, 0xC2, 0x76, 0x95, 0xE2, 0xEC, + 0xF4, 0x20, 0xD9, 0xF1, 0x86, 0x79, 0x0C, 0x60, + 0xCD, 0xBC, 0x61, 0x0C, 0x4F, 0xA1, 0x83, 0x13, + 0x6D, 0x2B, 0xFF, 0xE9, 0xC1, 0x8D, 0x70, 0x2C, + 0xCF, 0xC1, 0xBD, 0x6E, 0xCF, 0x18, 0x78, 0x92, + 0x05, 0xBC, 0xA9, 0x02, 0xE9, 0xA2, 0x75, 0xB7, + 0x43, 0x71, 0xE4, 0x7A, 0xE2, 0xBF, 0x10, 0x35, + 0x0A, 0x38, 0xF5, 0xA0, 0x71, 0x67, 0x0A, 0xFB + }, + { + 0xBE, 0x8F, 0xED, 0xE0, 0xDF, 0xB6, 0xCD, 0xBE, + 0x3C, 0x7F, 0x01, 0x15, 0x16, 0x88, 0xAD, 0xB9, + 0x62, 0x8B, 0x8A, 0xD0, 0x30, 0xEB, 0xBC, 0x0B, + 0x3B, 0x7C, 0x22, 0x2F, 0xE6, 0x3A, 0x50, 0x8F, + 0x01, 0xD0, 0xF5, 0x40, 0xBF, 0x87, 0x5F, 0x6B, + 0x72, 0xF6, 0x24, 0x2F, 0x6C, 0xC9, 0xDE, 0xD9, + 0xF0, 0xAA, 0x2B, 0xD0, 0x0F, 0x9B, 0x00, 0x51, + 0x4D, 0x90, 0xDD, 0x4E, 0xE5, 0x81, 0x5A, 0xF9 + }, + { + 0x87, 0xA4, 0xD1, 0x1F, 0xB1, 0x10, 0x06, 0x80, + 0x3F, 0x91, 0x2A, 0x30, 0x64, 0x85, 0xDB, 0xBB, + 0xC5, 0x36, 0xEE, 0x4E, 0x99, 0xA4, 0x5D, 0x89, + 0x12, 0x91, 0x5E, 0xE6, 0xDC, 0xAA, 0xA9, 0x34, + 0xC6, 0x8F, 0x66, 0x81, 0x2F, 0x8C, 0xD4, 0x89, + 0x9F, 0x5C, 0x10, 0x84, 0x51, 0xB6, 0x6D, 0x72, + 0x1C, 0xDC, 0xDD, 0x81, 0x9F, 0xA2, 0x37, 0x14, + 0x6A, 0x5C, 0x14, 0x7B, 0xE2, 0x7A, 0x51, 0x98 + }, + { + 0xF5, 0x11, 0xE1, 0xA3, 0x14, 0xAE, 0x0E, 0x7C, + 0x72, 0x3B, 0x08, 0xD5, 0xA3, 0x0E, 0x52, 0x78, + 0x0D, 0x17, 0x9D, 0xE1, 0xE7, 0x8F, 0x52, 0xE0, + 0x95, 0xCD, 0xE7, 0x91, 0xDD, 0x37, 0x3E, 0x6D, + 0x11, 0x4B, 0x5B, 0x63, 0xE7, 0x91, 0xE1, 0x56, + 0xED, 0x00, 0xA4, 0x33, 0x7B, 0x8D, 0x89, 0x5F, + 0x8F, 0x59, 0x73, 0x6E, 0x85, 0x8D, 0xA8, 0x32, + 0xC3, 0xC1, 0x2F, 0x73, 0x5C, 0x0D, 0xBA, 0xD7 + }, + { + 0xBB, 0xAB, 0xD6, 0x07, 0xA5, 0x41, 0xA9, 0x72, + 0xAF, 0x00, 0x1E, 0x7B, 0xDB, 0xF9, 0x8A, 0x30, + 0x40, 0xE8, 0xA3, 0x72, 0xD5, 0x35, 0x68, 0xE2, + 0xFA, 0xA5, 0xCB, 0x65, 0x5A, 0x8B, 0x3E, 0x14, + 0x63, 0x23, 0x16, 0x12, 0x26, 0xB3, 0xA0, 0xF9, + 0x70, 0x47, 0x83, 0x13, 0xCE, 0x82, 0xA6, 0xAC, + 0xF2, 0xB4, 0xAA, 0x4F, 0x7A, 0x20, 0xA3, 0xF6, + 0x41, 0xA0, 0x97, 0x2F, 0xC2, 0x04, 0xD3, 0x71 + }, + { + 0x2B, 0x80, 0xC8, 0xF8, 0x51, 0x96, 0x4F, 0x26, + 0x2D, 0x4C, 0x61, 0x8F, 0x93, 0xED, 0x0D, 0x76, + 0xF2, 0x44, 0xA9, 0xF6, 0xD7, 0xAF, 0x9C, 0xDE, + 0x74, 0x61, 0x22, 0x4A, 0x06, 0x54, 0xBD, 0x11, + 0x4E, 0xED, 0xEA, 0x09, 0xAA, 0x58, 0xA3, 0x71, + 0x40, 0x3B, 0xBE, 0x32, 0xAB, 0xEA, 0x9A, 0x78, + 0xD1, 0xA5, 0x7E, 0x15, 0x81, 0x39, 0xCD, 0xF9, + 0xC3, 0x32, 0x91, 0xE5, 0xCC, 0x8E, 0x1A, 0x16 + }, + { + 0x83, 0x0C, 0x2A, 0xC6, 0x20, 0xEC, 0xCA, 0xB2, + 0x7D, 0xF7, 0xAF, 0xF5, 0xCB, 0x66, 0x8C, 0x92, + 0xE6, 0xFC, 0x1A, 0xDA, 0xA3, 0x8B, 0xC1, 0x56, + 0xA6, 0x2B, 0x22, 0x5B, 0x7E, 0x00, 0x73, 0x5E, + 0xC1, 0xD9, 0xA8, 0xFD, 0x0B, 0x49, 0x44, 0x62, + 0x8F, 0xAE, 0x02, 0x67, 0xC6, 0x47, 0xB9, 0x46, + 0x88, 0x02, 0x5D, 0x10, 0xEE, 0x73, 0x61, 0xBF, + 0xE9, 0xFB, 0x97, 0x85, 0x61, 0x37, 0xAC, 0x5A + }, + { + 0x4C, 0x93, 0xD6, 0x05, 0x16, 0x87, 0x1E, 0x2E, + 0xF5, 0xEC, 0xC4, 0x67, 0x85, 0x0C, 0x3F, 0x2A, + 0x12, 0x35, 0x65, 0xD9, 0x06, 0xDB, 0x20, 0x62, + 0x51, 0x8F, 0x42, 0x72, 0x7B, 0xAA, 0xC4, 0x3B, + 0x52, 0x31, 0xC3, 0xAB, 0xAE, 0x64, 0xFF, 0x44, + 0xD2, 0xE9, 0x19, 0xDD, 0x8D, 0x1E, 0xC4, 0x01, + 0xA6, 0x72, 0x88, 0x7A, 0x00, 0x09, 0x04, 0xD1, + 0xB1, 0x27, 0x36, 0x82, 0xCE, 0x73, 0x1D, 0x11 + }, + { + 0xE1, 0x1F, 0xC8, 0x4B, 0x02, 0x6F, 0x43, 0xE0, + 0x5C, 0xF0, 0x87, 0x70, 0xD4, 0x09, 0x86, 0x11, + 0x78, 0xA6, 0xE6, 0x8F, 0xC9, 0x72, 0xB2, 0x0D, + 0xA6, 0x50, 0x8F, 0x62, 0xFF, 0xFE, 0x5F, 0xED, + 0xC7, 0x09, 0xAF, 0x64, 0x5C, 0xA6, 0xC2, 0x06, + 0xCD, 0xC5, 0x37, 0xFA, 0xBA, 0x62, 0xB7, 0x0C, + 0xA8, 0xFD, 0xB9, 0xFC, 0x97, 0x55, 0x83, 0x69, + 0x4F, 0x0B, 0x3D, 0xDB, 0x8A, 0x53, 0x9D, 0xA2 + }, + { + 0x06, 0x0C, 0xCD, 0x82, 0xAC, 0x3E, 0x9F, 0x3C, + 0x57, 0x22, 0xFF, 0xF6, 0x9E, 0x1F, 0x52, 0x17, + 0x97, 0xF7, 0x53, 0xF5, 0x31, 0xE6, 0x3A, 0x2D, + 0x44, 0x63, 0x4D, 0xF8, 0x18, 0xBD, 0x04, 0xE8, + 0xE0, 0x5D, 0xC6, 0xEE, 0x85, 0x11, 0xC5, 0x8E, + 0xAB, 0x05, 0xC8, 0x10, 0xB1, 0x5F, 0x7F, 0x69, + 0x7E, 0x27, 0x40, 0x71, 0x86, 0x4D, 0x41, 0xB6, + 0x63, 0x86, 0xB3, 0xA0, 0xE1, 0xA3, 0xD5, 0x95 + }, + { + 0x41, 0x60, 0x54, 0xF0, 0x4E, 0x81, 0xF4, 0x4F, + 0x52, 0xD5, 0xA0, 0xFA, 0xD5, 0xB1, 0x2C, 0x7F, + 0x59, 0xE9, 0x98, 0x44, 0xC2, 0xA5, 0x92, 0xE8, + 0x81, 0x6F, 0x14, 0xAE, 0x72, 0x36, 0x49, 0x60, + 0x38, 0x29, 0x31, 0x16, 0x11, 0x32, 0x7B, 0xA9, + 0x6E, 0x57, 0x27, 0x57, 0xA5, 0xD5, 0xF6, 0xB8, + 0xEC, 0x9F, 0x48, 0x48, 0x3C, 0xDD, 0x07, 0x9D, + 0x63, 0xD1, 0x28, 0xD2, 0x80, 0x33, 0x39, 0x5C + }, + { + 0x69, 0x45, 0x15, 0x4A, 0x0B, 0xA7, 0x37, 0xC6, + 0x34, 0x93, 0x9A, 0x39, 0xA7, 0x79, 0xB9, 0x47, + 0xE0, 0x96, 0xFF, 0x70, 0x8B, 0x9E, 0x80, 0xCA, + 0x63, 0x07, 0x84, 0x96, 0x20, 0xCD, 0x9C, 0x1F, + 0xC0, 0x88, 0x2C, 0xCE, 0x55, 0x08, 0x8A, 0x31, + 0xEB, 0x2F, 0xB9, 0xEA, 0x85, 0x32, 0x6A, 0xCE, + 0x54, 0xCA, 0xC4, 0x1E, 0xF7, 0x9D, 0xBB, 0x02, + 0xC9, 0xAE, 0xB9, 0x5C, 0x49, 0x50, 0x1B, 0x7D + }, + { + 0xE1, 0x93, 0x1A, 0xE0, 0xF8, 0x07, 0x12, 0xCC, + 0xB2, 0x91, 0xBC, 0x04, 0x17, 0xA9, 0x72, 0xD2, + 0xD2, 0xD6, 0x3B, 0x03, 0xE2, 0x4C, 0x8F, 0x2E, + 0xA9, 0xE8, 0xE8, 0x96, 0xC4, 0x01, 0x11, 0x0D, + 0xB6, 0x33, 0xD3, 0x18, 0x24, 0xFD, 0xD9, 0x0E, + 0x34, 0x31, 0xE1, 0x43, 0xFE, 0x13, 0x58, 0x26, + 0x11, 0xB6, 0x02, 0xF5, 0x29, 0x39, 0x7B, 0xB4, + 0x23, 0x62, 0x62, 0xF9, 0xB2, 0xFE, 0xD0, 0x03 + }, + { + 0xDD, 0xE6, 0xE6, 0x9F, 0x1F, 0x0A, 0x0F, 0x91, + 0x90, 0x6A, 0xED, 0x50, 0xF6, 0xDF, 0x07, 0x51, + 0xFF, 0xA2, 0x49, 0x6F, 0x08, 0x1D, 0x4A, 0x7D, + 0x57, 0x08, 0x4D, 0xF0, 0xFD, 0xEA, 0x00, 0xCD, + 0x32, 0x94, 0x97, 0xA4, 0x49, 0x3D, 0x35, 0x95, + 0x9F, 0x0C, 0xAD, 0x54, 0xF3, 0x96, 0xED, 0xDF, + 0x9C, 0xF3, 0x46, 0x35, 0x55, 0xD2, 0xD7, 0x09, + 0x10, 0xAE, 0x11, 0x40, 0x20, 0xC3, 0xB4, 0x83 + }, + { + 0xBD, 0xE2, 0xA7, 0x1B, 0xC6, 0x6E, 0x68, 0x26, + 0xEB, 0xAB, 0x1D, 0x2C, 0x17, 0x11, 0x30, 0xCD, + 0x2F, 0xCB, 0xD8, 0xB0, 0xCE, 0xF6, 0xB5, 0x3F, + 0xC3, 0xF6, 0x38, 0xDB, 0x54, 0x41, 0x31, 0xA5, + 0x13, 0x6B, 0x1B, 0x51, 0xC0, 0x47, 0x94, 0xDA, + 0x92, 0x05, 0x53, 0xD6, 0x34, 0xF9, 0x79, 0x9F, + 0x5A, 0x29, 0xC2, 0x66, 0x5B, 0x27, 0x63, 0xF3, + 0x9F, 0x6E, 0x10, 0xA0, 0x25, 0x1F, 0x55, 0x0C + }, + { + 0x6D, 0x56, 0xF8, 0x71, 0xB0, 0x6F, 0x56, 0xF1, + 0xE8, 0xC4, 0x7E, 0x1A, 0xAF, 0xC9, 0x81, 0xAD, + 0xC3, 0xF8, 0xA1, 0x25, 0xC3, 0xE6, 0xDA, 0xFF, + 0x82, 0x39, 0x3F, 0xAC, 0x50, 0xF6, 0x3B, 0x3A, + 0x6A, 0x4C, 0x8C, 0x90, 0x3F, 0x3D, 0xD8, 0x74, + 0xCB, 0x91, 0x41, 0xE8, 0xCA, 0x16, 0xFF, 0x11, + 0x97, 0xFC, 0xBA, 0x27, 0x79, 0x16, 0xE2, 0xA8, + 0xDF, 0xC7, 0x01, 0x5C, 0x48, 0xB4, 0x13, 0xEC + }, + { + 0x99, 0x67, 0x4E, 0x23, 0x3D, 0xD0, 0x81, 0x9E, + 0x0F, 0x3F, 0x88, 0xE7, 0x64, 0xBC, 0x6D, 0x95, + 0xAA, 0x22, 0x77, 0x3A, 0xDD, 0x44, 0xFE, 0x24, + 0x05, 0x3E, 0x62, 0x93, 0x9C, 0xDA, 0x22, 0xB6, + 0xBE, 0xBA, 0x33, 0x0D, 0x8E, 0x51, 0x9A, 0x72, + 0x21, 0xCE, 0xD6, 0x79, 0x07, 0x37, 0xCE, 0x99, + 0x39, 0x2A, 0x67, 0x06, 0xDC, 0x54, 0xAA, 0xC3, + 0x2E, 0x90, 0x05, 0x60, 0xB1, 0xAF, 0x18, 0x22 + }, + { + 0x0D, 0x3D, 0xDF, 0xE4, 0x29, 0xCD, 0x65, 0xCE, + 0xDE, 0xF8, 0xDA, 0xAB, 0x10, 0x85, 0x09, 0xD6, + 0x04, 0x78, 0x2B, 0xDB, 0xBB, 0xF4, 0x0C, 0x55, + 0xC5, 0x4A, 0xB6, 0x89, 0x11, 0xA8, 0x44, 0x6F, + 0xBA, 0x56, 0x60, 0x16, 0xCF, 0xB0, 0x9D, 0x9F, + 0x45, 0x70, 0xE3, 0x58, 0x43, 0x3B, 0xDC, 0xF2, + 0x68, 0x5B, 0x15, 0xD2, 0xC1, 0xBD, 0x59, 0xDE, + 0xBE, 0xC2, 0x95, 0xDB, 0xA7, 0x56, 0x55, 0x1A + }, + { + 0x0C, 0x9F, 0xC6, 0x18, 0xEC, 0x5E, 0xF8, 0xE0, + 0xD4, 0xA1, 0x91, 0x7A, 0x13, 0x94, 0x1A, 0x21, + 0xE7, 0x11, 0xCC, 0x5C, 0x17, 0x5E, 0x91, 0x83, + 0x19, 0xB8, 0xB7, 0xFC, 0x7D, 0xFE, 0x7C, 0xA0, + 0xE4, 0xD3, 0x25, 0x44, 0x42, 0x1C, 0x7B, 0x34, + 0xF9, 0xE0, 0x5E, 0x84, 0x5B, 0x45, 0xBC, 0xD6, + 0x2C, 0x66, 0x22, 0xD0, 0xAF, 0x65, 0x86, 0xEF, + 0x6C, 0xF8, 0x75, 0xCB, 0xB7, 0xD3, 0x2B, 0xF6 + }, + { + 0x5F, 0x73, 0x18, 0x71, 0x70, 0xDF, 0xF5, 0x8A, + 0xB6, 0xD6, 0x9E, 0x99, 0x7D, 0x1B, 0x22, 0x0A, + 0xAC, 0x4C, 0xC5, 0x8F, 0x40, 0x27, 0x22, 0x9E, + 0x93, 0x63, 0xB6, 0x9A, 0x77, 0x92, 0xEE, 0x1C, + 0xF5, 0x50, 0x51, 0x06, 0xF7, 0xC1, 0xCF, 0x1D, + 0x9A, 0xA4, 0x40, 0xBD, 0xF2, 0x8B, 0x59, 0x05, + 0xD6, 0xB9, 0xDC, 0x92, 0x72, 0xB2, 0xA3, 0x23, + 0xB0, 0x6D, 0xE4, 0xC6, 0x13, 0xEC, 0xA8, 0xFC + }, + { + 0x7F, 0x03, 0x8D, 0x0A, 0x57, 0xD8, 0x9A, 0x1F, + 0x4C, 0x24, 0x4C, 0xE7, 0x85, 0xC7, 0x60, 0xBB, + 0xA2, 0x8A, 0xD0, 0x15, 0xF2, 0xD7, 0x43, 0x53, + 0x88, 0x4A, 0xD4, 0xC0, 0x9F, 0xD8, 0x75, 0x11, + 0xD5, 0x64, 0x7E, 0x12, 0xBD, 0x8F, 0x8B, 0xEC, + 0x88, 0x9E, 0x36, 0x50, 0x4F, 0xCF, 0x38, 0xDE, + 0x43, 0x77, 0xF7, 0xB9, 0x15, 0xCF, 0x8A, 0x7E, + 0x71, 0xCC, 0x65, 0x9E, 0x85, 0x43, 0xF2, 0x3A + }, + { + 0x16, 0x6D, 0xF0, 0x02, 0xC5, 0x78, 0xD1, 0x40, + 0xE7, 0x0E, 0x38, 0x45, 0xCD, 0x7D, 0xE3, 0x24, + 0x78, 0xEB, 0xB4, 0xA8, 0x78, 0x3E, 0x0A, 0x39, + 0xEE, 0xF3, 0x5C, 0xEF, 0x13, 0x40, 0xF5, 0x45, + 0xED, 0xF1, 0xAD, 0xFA, 0x38, 0xD9, 0x96, 0x57, + 0xFC, 0xA0, 0x65, 0xE6, 0x28, 0x1C, 0x5C, 0xE9, + 0xE1, 0x5A, 0x07, 0x57, 0xEA, 0x3B, 0x38, 0x37, + 0x36, 0xBB, 0x3C, 0x8B, 0xBA, 0x67, 0x64, 0xA0 + }, + { + 0xD2, 0x80, 0xC1, 0xA6, 0xD1, 0xC7, 0x0B, 0xBC, + 0x5A, 0x51, 0x80, 0x25, 0xDB, 0xE3, 0x68, 0x32, + 0x81, 0xCD, 0x8F, 0x89, 0x21, 0x85, 0x5A, 0xEB, + 0x43, 0x58, 0xD3, 0x9C, 0x3D, 0x5B, 0xF6, 0xD5, + 0x43, 0xF4, 0x06, 0x78, 0x45, 0x80, 0x8D, 0xE8, + 0x37, 0x18, 0x76, 0xDB, 0x89, 0x0D, 0x3D, 0xD9, + 0xEB, 0x85, 0x94, 0xD2, 0x63, 0x7A, 0xB1, 0xA2, + 0x6E, 0xE2, 0x6D, 0x02, 0xAE, 0x0B, 0xBD, 0x68 + }, + { + 0x1D, 0x4E, 0x6A, 0x46, 0xA2, 0x35, 0x7E, 0x5E, + 0x8B, 0xDE, 0xDF, 0x20, 0x3E, 0x8D, 0x55, 0xBE, + 0x80, 0xA0, 0x48, 0x9F, 0x7B, 0x47, 0xCD, 0xE3, + 0x47, 0x20, 0x85, 0x43, 0xFD, 0x0E, 0x25, 0xDE, + 0x34, 0xB9, 0x92, 0x47, 0xA0, 0xDD, 0x1F, 0x27, + 0xD5, 0x1C, 0x16, 0xCD, 0x91, 0x8C, 0xC2, 0xF5, + 0x26, 0x8C, 0xBE, 0x77, 0xE6, 0x38, 0x55, 0x0D, + 0x63, 0x44, 0x58, 0xE2, 0x05, 0x2F, 0x4D, 0x4A + }, + { + 0x24, 0xE0, 0xA5, 0x63, 0x48, 0x80, 0xE5, 0xB7, + 0xBD, 0x36, 0xBD, 0xBF, 0xF8, 0xE0, 0x30, 0x21, + 0xA9, 0xC9, 0xE1, 0x11, 0x1F, 0x03, 0xE6, 0x58, + 0xB1, 0x9B, 0x7D, 0x05, 0x87, 0xB8, 0x2D, 0x06, + 0xBA, 0xBB, 0xAD, 0x4C, 0x01, 0xEA, 0x4B, 0xD5, + 0xA8, 0x2A, 0x55, 0x07, 0x4C, 0x54, 0x32, 0xE7, + 0xB3, 0x58, 0x23, 0xF7, 0x05, 0xC5, 0xF1, 0x5D, + 0x5F, 0x9E, 0xDA, 0x8A, 0xB6, 0xC8, 0x14, 0x07 + }, + { + 0x9B, 0xD7, 0xFB, 0xCF, 0x8B, 0x48, 0x8C, 0xA9, + 0x40, 0x1A, 0x4C, 0x81, 0xBE, 0x94, 0xDF, 0x6B, + 0x59, 0xC8, 0x3C, 0x46, 0x05, 0xE9, 0x9E, 0xE3, + 0x3A, 0xA7, 0x73, 0xAB, 0xC8, 0x18, 0xAB, 0xE8, + 0xF4, 0x0F, 0xBF, 0x27, 0x1C, 0xB0, 0xDF, 0xA3, + 0x91, 0xBC, 0x9B, 0x2C, 0x6F, 0x81, 0x66, 0xE1, + 0xA3, 0xF2, 0x93, 0x45, 0x9B, 0xCE, 0x4C, 0x4F, + 0x97, 0xCA, 0x38, 0x77, 0xFC, 0xDB, 0x3E, 0xDA + }, + { + 0x0A, 0xB6, 0x0F, 0x69, 0x80, 0xC2, 0x77, 0xA5, + 0x37, 0x39, 0xD7, 0x77, 0x5A, 0x30, 0x67, 0x48, + 0xE1, 0x8B, 0x08, 0x0F, 0xC6, 0x40, 0x23, 0x18, + 0xD6, 0x4B, 0xFB, 0x31, 0xA9, 0x3C, 0xBA, 0x09, + 0xA3, 0xB0, 0x5A, 0x61, 0x12, 0x3F, 0x8E, 0xE5, + 0x97, 0xB3, 0x12, 0x20, 0x45, 0xF4, 0xC6, 0x3F, + 0x46, 0x0D, 0x44, 0xDB, 0xDD, 0xF2, 0x55, 0x0A, + 0x1E, 0xC5, 0x1E, 0xB6, 0x64, 0x4E, 0x41, 0x0C + }, + { + 0x33, 0x39, 0xBE, 0xE4, 0x06, 0x18, 0x6E, 0x28, + 0x7A, 0x75, 0x38, 0x4F, 0x80, 0xB8, 0x19, 0x91, + 0x7C, 0xD2, 0xC5, 0xF1, 0xD7, 0x13, 0xD9, 0xF6, + 0x3F, 0x18, 0x3C, 0x28, 0x61, 0x2D, 0xE4, 0xD7, + 0x21, 0x1C, 0x66, 0x16, 0x61, 0x18, 0xC0, 0x49, + 0xA5, 0x3F, 0xDA, 0x3C, 0xF2, 0xA9, 0x94, 0xF7, + 0x17, 0x74, 0x13, 0x94, 0xE9, 0x71, 0xAD, 0x9B, + 0xA2, 0x57, 0xCE, 0x01, 0x5C, 0xCC, 0x55, 0xD6 + }, + { + 0x67, 0x84, 0x84, 0x02, 0xE6, 0x6A, 0xBD, 0xB1, + 0x33, 0x80, 0x52, 0x5D, 0xA2, 0x7A, 0x79, 0x5F, + 0xFE, 0xD2, 0xEC, 0xFF, 0x81, 0x6B, 0x2F, 0xD7, + 0xFA, 0x15, 0xAC, 0xF8, 0x45, 0x9C, 0x78, 0x9D, + 0x9E, 0x91, 0x86, 0xF8, 0x72, 0x04, 0xDB, 0x4A, + 0xE0, 0x92, 0x00, 0x03, 0x12, 0xA8, 0x09, 0x25, + 0xBB, 0xC3, 0xD2, 0x28, 0x70, 0xCC, 0xFE, 0x2A, + 0x30, 0xC2, 0xB4, 0x03, 0x9D, 0x43, 0x77, 0xC1 + }, + { + 0xD4, 0xAD, 0x9A, 0x4D, 0x32, 0x70, 0xD5, 0xF8, + 0xF8, 0xF2, 0xA9, 0x29, 0xB0, 0x6F, 0x0D, 0xE9, + 0xF4, 0x68, 0xC1, 0x7D, 0xCF, 0x17, 0x70, 0x12, + 0x2E, 0x24, 0x3C, 0x58, 0x10, 0xA8, 0xCD, 0x20, + 0xBF, 0x26, 0x2B, 0x32, 0x58, 0xD4, 0x61, 0xFA, + 0x10, 0x54, 0x1B, 0xA9, 0x46, 0xCC, 0x39, 0x86, + 0x52, 0xAD, 0x6D, 0x92, 0xEB, 0xFC, 0x14, 0x03, + 0xF3, 0x13, 0x4E, 0x58, 0xA4, 0x9F, 0x52, 0x33 + }, + { + 0xBF, 0x74, 0x8E, 0xD0, 0x59, 0x8A, 0xF6, 0x11, + 0x0F, 0x10, 0x53, 0x6C, 0xE5, 0x93, 0xE2, 0xD8, + 0xFF, 0x12, 0x5A, 0x7B, 0x12, 0xBC, 0x62, 0x9F, + 0xCF, 0x73, 0xD9, 0xFD, 0xB5, 0x46, 0x63, 0x5A, + 0xD7, 0xD4, 0xCF, 0x33, 0x83, 0x2D, 0x1E, 0x17, + 0xE8, 0xAD, 0x5D, 0x5E, 0x00, 0x01, 0x35, 0x0C, + 0x97, 0xCB, 0xF4, 0xAC, 0x39, 0xD9, 0x11, 0xDE, + 0xCA, 0xA0, 0xE7, 0xB8, 0x6D, 0xBE, 0xF3, 0xA6 + }, + { + 0xAC, 0x6A, 0x4B, 0xD8, 0xCF, 0x39, 0xBF, 0x6E, + 0x96, 0x1B, 0xAA, 0x00, 0x37, 0xD8, 0xDB, 0x71, + 0xBF, 0x50, 0x69, 0x8D, 0xA9, 0x09, 0x3E, 0x12, + 0x15, 0x1D, 0x85, 0x94, 0xB2, 0xD9, 0x05, 0x51, + 0xB2, 0xA0, 0x79, 0x75, 0x14, 0x8A, 0x78, 0xB1, + 0xC9, 0x91, 0xE0, 0x4C, 0xC3, 0xC4, 0xD3, 0x87, + 0xFB, 0x41, 0xC9, 0x60, 0x81, 0x06, 0xDD, 0x4E, + 0x7C, 0x71, 0x30, 0xE7, 0xD2, 0xD2, 0x5C, 0x9F + }, + { + 0x8F, 0x66, 0x91, 0x63, 0xC6, 0xED, 0x66, 0x97, + 0xA1, 0x5B, 0x89, 0x2B, 0xAD, 0x95, 0xA8, 0x88, + 0x58, 0x29, 0xD1, 0xD7, 0xA2, 0x69, 0x36, 0xFD, + 0x30, 0x00, 0x83, 0x87, 0xB3, 0xCC, 0x58, 0x49, + 0xF7, 0x5A, 0xB3, 0xF0, 0xF6, 0x83, 0x30, 0x5A, + 0x63, 0x82, 0x2A, 0x59, 0x2F, 0x4F, 0xFD, 0x11, + 0x91, 0x92, 0x5F, 0x96, 0x7D, 0x9C, 0x95, 0x7C, + 0xFE, 0x6A, 0x11, 0x5A, 0x56, 0x5D, 0x47, 0xB5 + }, + { + 0xF0, 0x4B, 0x4B, 0x7F, 0xD3, 0x41, 0xB9, 0x1C, + 0x6D, 0x56, 0xD6, 0x61, 0x85, 0xDC, 0xF3, 0x37, + 0x26, 0x14, 0x99, 0xDC, 0x9D, 0x15, 0x02, 0xC9, + 0xDE, 0xC6, 0x73, 0xFF, 0x44, 0x9F, 0x6A, 0x22, + 0xA4, 0xDE, 0xFC, 0x4E, 0x45, 0x7E, 0x5B, 0x5A, + 0x87, 0x65, 0x6B, 0xBD, 0x3F, 0x74, 0xD1, 0xC5, + 0x71, 0x4B, 0x9B, 0x41, 0x21, 0x44, 0xE2, 0xC0, + 0x3A, 0x6A, 0x5D, 0x02, 0xC9, 0x68, 0x80, 0x83 + }, + { + 0xD6, 0x9A, 0xFA, 0xDE, 0x59, 0x41, 0x02, 0xDD, + 0xE9, 0x98, 0x5D, 0xAE, 0x81, 0xE4, 0xDA, 0xA3, + 0x88, 0xBC, 0xE1, 0x09, 0xAF, 0x53, 0x0C, 0xEA, + 0x7D, 0xA6, 0x7D, 0x78, 0xE2, 0x62, 0xC2, 0x3E, + 0xBA, 0x91, 0x68, 0xD1, 0x70, 0x16, 0x04, 0x69, + 0xC0, 0xA2, 0x25, 0x9D, 0x1A, 0x38, 0x69, 0xCA, + 0xE6, 0xA9, 0xFF, 0x6F, 0x6C, 0x56, 0xDA, 0xC0, + 0x56, 0xF5, 0x7F, 0x08, 0x98, 0xD8, 0xB8, 0x7C + }, + { + 0xA0, 0x51, 0x8C, 0x80, 0xA4, 0x9B, 0x5D, 0x35, + 0xCF, 0xBF, 0x84, 0x57, 0xD0, 0x8C, 0xFD, 0xB3, + 0x27, 0x02, 0x5B, 0x3C, 0x9F, 0xDE, 0x8C, 0xE7, + 0xB2, 0xF3, 0x1D, 0xC4, 0xFA, 0xA1, 0x9F, 0x91, + 0x3B, 0xD6, 0x83, 0x40, 0xDD, 0x3C, 0x23, 0x8A, + 0xD2, 0x4A, 0x01, 0x8A, 0x67, 0xDF, 0x01, 0x89, + 0xA8, 0xA8, 0x44, 0x18, 0x88, 0x18, 0xE1, 0xAE, + 0xF2, 0x22, 0x98, 0x72, 0x98, 0xEB, 0x77, 0x63 + }, + { + 0x6E, 0x5F, 0xEB, 0x22, 0x57, 0x6F, 0x41, 0xB2, + 0x3B, 0xFB, 0x96, 0x80, 0xFC, 0xD1, 0xD8, 0x76, + 0x08, 0x4A, 0x7B, 0x61, 0x7F, 0xCE, 0x01, 0xB5, + 0xE3, 0x47, 0x74, 0xE1, 0x6C, 0xCB, 0x65, 0xBF, + 0x0A, 0xC8, 0x37, 0x8A, 0x71, 0x67, 0xC9, 0xD3, + 0x27, 0x9D, 0xBD, 0x54, 0x36, 0x71, 0x5C, 0x50, + 0xB0, 0x4A, 0x23, 0x3C, 0x89, 0xB8, 0x0B, 0x3F, + 0xCC, 0x3E, 0xF4, 0x0C, 0xA3, 0x6D, 0x34, 0xAE + }, + { + 0x04, 0x2D, 0x57, 0x56, 0xCC, 0x02, 0xFE, 0x99, + 0x2B, 0x83, 0xE6, 0xC8, 0xFA, 0xF2, 0xB6, 0x42, + 0xAF, 0xD4, 0x28, 0xBC, 0x96, 0xF4, 0x30, 0x35, + 0x9A, 0x4F, 0xBC, 0x66, 0x1C, 0x8C, 0x8F, 0x3E, + 0x1A, 0x5B, 0xD3, 0x30, 0x96, 0xD3, 0xA6, 0xD9, + 0xCA, 0x2A, 0xD8, 0x76, 0x8A, 0xB2, 0x3B, 0xB2, + 0x2A, 0x7B, 0xEA, 0x83, 0xD4, 0x8C, 0xF5, 0x85, + 0xC5, 0x09, 0x90, 0x68, 0xE8, 0x59, 0x11, 0x91 + }, + { + 0x4C, 0xF5, 0x26, 0xA4, 0xE8, 0x27, 0x26, 0xD8, + 0xDB, 0xFE, 0x92, 0x0C, 0xA7, 0x85, 0x10, 0x5F, + 0x18, 0x0E, 0xBD, 0xAF, 0x77, 0xC5, 0xF3, 0x0E, + 0x86, 0xBE, 0x11, 0xD5, 0x14, 0x5B, 0xE9, 0x3D, + 0xA5, 0xD1, 0xA7, 0xD3, 0x54, 0x64, 0xA6, 0xD9, + 0x4B, 0x43, 0x9E, 0x6B, 0x70, 0x9A, 0x1F, 0x80, + 0xCA, 0xD2, 0x4C, 0x02, 0xCA, 0xCD, 0xE7, 0x7E, + 0xF2, 0xC1, 0x17, 0xFE, 0x73, 0xE3, 0x77, 0xD9 + }, + { + 0x28, 0x6E, 0xEC, 0x56, 0x18, 0xF4, 0x0A, 0x2B, + 0x36, 0x2D, 0xFD, 0x85, 0x8E, 0x20, 0x26, 0xF7, + 0xC4, 0xF1, 0x4A, 0x28, 0x10, 0x1A, 0x5D, 0xE6, + 0xDB, 0x7F, 0xDF, 0xB4, 0x3E, 0x6B, 0x00, 0xE6, + 0x2F, 0xC0, 0xDA, 0x95, 0x54, 0x49, 0xF7, 0x20, + 0x4D, 0x6C, 0x5A, 0xDD, 0x19, 0x0B, 0xF0, 0x7C, + 0xF2, 0x75, 0x7C, 0xE9, 0x96, 0x9A, 0xAD, 0xAC, + 0x93, 0x5F, 0xCF, 0xAF, 0x6C, 0xF7, 0x3B, 0x89 + }, + { + 0x59, 0xC6, 0xA3, 0xA1, 0xA0, 0x3E, 0x93, 0x52, + 0x86, 0x68, 0xF9, 0xF2, 0x20, 0xCD, 0x59, 0xF2, + 0x46, 0x87, 0x84, 0x96, 0xBC, 0x93, 0x80, 0x3B, + 0xAA, 0x1A, 0xC2, 0x99, 0x47, 0x47, 0x70, 0x75, + 0x37, 0xEE, 0x28, 0x49, 0xAE, 0x76, 0x0F, 0x67, + 0xB0, 0x39, 0x1B, 0x5E, 0xE0, 0xF1, 0x32, 0x41, + 0x26, 0x5B, 0x66, 0x65, 0x36, 0x17, 0xEB, 0x13, + 0xAD, 0x03, 0x21, 0x6C, 0x00, 0x24, 0x9F, 0xD0 + }, + { + 0xFE, 0x76, 0x54, 0x74, 0xCD, 0x06, 0x68, 0x13, + 0xA9, 0x92, 0x92, 0x9B, 0x36, 0xB2, 0xB0, 0xAE, + 0x0A, 0xBF, 0x6C, 0xEF, 0xDE, 0x63, 0x27, 0x78, + 0x81, 0xFF, 0x85, 0x43, 0x7A, 0x2C, 0xD6, 0xC6, + 0x1B, 0xF6, 0x78, 0x9B, 0xAD, 0x3D, 0x58, 0xE9, + 0x37, 0xEF, 0x73, 0xED, 0x26, 0xF6, 0xEC, 0x80, + 0x2D, 0x50, 0x46, 0x29, 0x30, 0x01, 0x23, 0x75, + 0xBC, 0xA9, 0x13, 0x8F, 0x3D, 0x00, 0xB3, 0xBB + }, + { + 0xAB, 0x12, 0x3A, 0xFA, 0x01, 0xF4, 0x0A, 0x55, + 0xCB, 0x91, 0x28, 0x77, 0x9A, 0xD0, 0x19, 0x6A, + 0xF9, 0x9E, 0x9C, 0xE6, 0x5C, 0x83, 0x13, 0x1E, + 0x0A, 0x2A, 0xD2, 0x21, 0x94, 0xC7, 0x94, 0x12, + 0xD9, 0xFA, 0xBC, 0x1E, 0x7B, 0xE4, 0xDA, 0x7F, + 0x1B, 0x84, 0xE5, 0x66, 0xFF, 0x53, 0xBB, 0x29, + 0xCB, 0x4B, 0x3D, 0x6D, 0x41, 0x29, 0x9B, 0xFF, + 0x80, 0x6E, 0x79, 0x70, 0x98, 0x89, 0x5A, 0xE6 + }, + { + 0x57, 0x11, 0x5D, 0x5D, 0xB3, 0x22, 0x90, 0xAE, + 0x8B, 0x1D, 0xB1, 0x12, 0x49, 0xD8, 0x98, 0x8C, + 0x74, 0x56, 0xC3, 0xA1, 0x30, 0xDE, 0xE3, 0x23, + 0xF2, 0x3F, 0x2D, 0xD4, 0x51, 0xA2, 0xDC, 0xDB, + 0x70, 0x83, 0xBE, 0x77, 0x1D, 0x08, 0x24, 0x10, + 0x16, 0xE0, 0x8F, 0xBC, 0x95, 0x18, 0x35, 0x33, + 0xF1, 0x3C, 0x94, 0xFE, 0x92, 0x7C, 0x00, 0xA2, + 0xB0, 0x6A, 0x0A, 0x29, 0xF5, 0xDF, 0x94, 0x4C + }, + { + 0x62, 0x9A, 0x3C, 0xB1, 0xEF, 0x7A, 0xFD, 0xF8, + 0xD0, 0xEB, 0xC0, 0x55, 0x0A, 0xD0, 0x08, 0x7F, + 0x23, 0x1A, 0x5C, 0xBD, 0x00, 0x12, 0x36, 0x2E, + 0xDF, 0xE6, 0x13, 0xFA, 0xAB, 0x60, 0xDC, 0x79, + 0xA4, 0x73, 0x98, 0xBB, 0x1B, 0xD8, 0x0F, 0x42, + 0x9A, 0xC1, 0xAB, 0x7F, 0xAE, 0x02, 0x1A, 0x94, + 0x98, 0xFC, 0x2E, 0x47, 0x12, 0xD6, 0x8F, 0x43, + 0xF9, 0x12, 0xFE, 0x7D, 0xE4, 0x89, 0x35, 0xB1 + }, + { + 0x61, 0x3A, 0x53, 0x13, 0x11, 0x34, 0xA6, 0xC7, + 0x56, 0x7E, 0xD6, 0x2B, 0x96, 0x61, 0x48, 0x00, + 0xB0, 0xA7, 0x3C, 0xEF, 0xE9, 0xDC, 0x5E, 0x7A, + 0xF9, 0xC4, 0xD0, 0x8B, 0xEF, 0x4E, 0x00, 0xD7, + 0xB8, 0x6E, 0xE3, 0xF2, 0x00, 0xCA, 0x54, 0x44, + 0xF8, 0x48, 0xE1, 0x92, 0xC7, 0x43, 0xFC, 0xE7, + 0xF6, 0xA5, 0x69, 0x37, 0x7A, 0x6F, 0xBC, 0x6E, + 0x6A, 0xA8, 0xD6, 0x4F, 0x60, 0xF8, 0xA0, 0xE3 + }, + { + 0xCF, 0x3D, 0x7D, 0x39, 0x78, 0x75, 0x0E, 0x07, + 0x10, 0x6A, 0x5D, 0xA1, 0xAF, 0x4E, 0xC6, 0xD7, + 0xF0, 0x04, 0xC8, 0xE1, 0x01, 0x02, 0xE0, 0x06, + 0x6C, 0x6B, 0x87, 0x50, 0x9D, 0xE3, 0xB0, 0x0A, + 0x87, 0x0E, 0xA1, 0x5E, 0x37, 0xC8, 0x8D, 0x81, + 0xAC, 0xA3, 0x75, 0xCE, 0x1C, 0x48, 0x02, 0x0B, + 0xF5, 0x2F, 0x30, 0x50, 0x44, 0x68, 0x10, 0x7C, + 0x00, 0x4F, 0xCC, 0x41, 0xFC, 0x66, 0x32, 0xFB + }, + { + 0x6A, 0x40, 0x5D, 0xD2, 0x9E, 0x58, 0xAD, 0xC0, + 0x36, 0x43, 0xB1, 0x98, 0xF3, 0xBD, 0x98, 0x3B, + 0x43, 0xDE, 0x8E, 0x37, 0xEE, 0xA6, 0x2A, 0xE8, + 0x75, 0xE6, 0xE2, 0x37, 0x50, 0x98, 0x82, 0x76, + 0x71, 0x47, 0xC0, 0xEF, 0x57, 0xF7, 0x3D, 0x1B, + 0x0E, 0x9D, 0x97, 0x94, 0x5E, 0x7C, 0xE9, 0x28, + 0xE8, 0x85, 0x30, 0xE0, 0xD8, 0xCB, 0x80, 0xD9, + 0x60, 0xB4, 0xBC, 0x70, 0xCB, 0xFF, 0x12, 0x2D + }, + { + 0xB1, 0x28, 0xF2, 0x41, 0x63, 0x20, 0x11, 0xE8, + 0x4D, 0x32, 0x16, 0xDA, 0x72, 0x89, 0x70, 0x4A, + 0x80, 0x3C, 0x38, 0x3B, 0x43, 0x99, 0x79, 0x87, + 0xE0, 0x17, 0x74, 0x33, 0xB6, 0xB1, 0x4F, 0x8A, + 0xD6, 0x1C, 0x08, 0xD5, 0xCD, 0x29, 0x75, 0x1F, + 0x29, 0xA8, 0x64, 0xD0, 0xCE, 0x90, 0x45, 0xDF, + 0x7F, 0x78, 0x1F, 0xAC, 0x9B, 0x00, 0x39, 0xF8, + 0x7A, 0xD0, 0x1E, 0xE2, 0x3C, 0xC1, 0x9B, 0x0F + }, + { + 0xDB, 0xA9, 0x6B, 0x30, 0xA2, 0xBD, 0xC5, 0x0D, + 0xFE, 0x5F, 0x4A, 0xFB, 0x70, 0xC5, 0xD1, 0x53, + 0xE2, 0xB7, 0xC6, 0x38, 0xFE, 0xAA, 0x0B, 0x97, + 0xB1, 0x59, 0xA6, 0x5B, 0x87, 0x17, 0x1D, 0x72, + 0x07, 0xD5, 0x9B, 0xBE, 0xA8, 0xE6, 0x77, 0x89, + 0x53, 0x3C, 0xDB, 0x22, 0x32, 0xB3, 0xE7, 0x24, + 0xF8, 0x45, 0x7C, 0x7F, 0xB0, 0xB6, 0x95, 0x1D, + 0x6F, 0x94, 0xFB, 0x6F, 0x60, 0x9B, 0xE8, 0xCA + }, + { + 0xC3, 0xE2, 0x5A, 0x44, 0xDA, 0x99, 0xED, 0x0E, + 0x03, 0xCE, 0xDA, 0xB3, 0xB7, 0x68, 0xFA, 0x4E, + 0x84, 0xAA, 0xA8, 0xC4, 0xB5, 0xA1, 0x62, 0xFC, + 0x30, 0xA7, 0x48, 0xF1, 0x34, 0xFA, 0x05, 0xA1, + 0x09, 0xFD, 0x24, 0x11, 0xCC, 0x21, 0xEB, 0x1E, + 0x43, 0x05, 0xF0, 0x82, 0x53, 0x38, 0xB3, 0xB6, + 0x55, 0x0B, 0x26, 0x7A, 0x7C, 0x12, 0xF0, 0x03, + 0x98, 0xA2, 0xEA, 0xA0, 0xF6, 0xCE, 0xCC, 0xF1 + }, + { + 0x68, 0xC5, 0x16, 0xDE, 0x74, 0xBD, 0x62, 0x5C, + 0x5F, 0xC9, 0xA5, 0xE4, 0x09, 0x3B, 0x9A, 0x8B, + 0x1B, 0xC0, 0x88, 0xFF, 0xC2, 0x1D, 0x1D, 0x6A, + 0x09, 0xCA, 0x44, 0x48, 0xAD, 0xCE, 0x70, 0x39, + 0x43, 0xAC, 0x90, 0xC7, 0xB5, 0xA7, 0xFF, 0x10, + 0x84, 0x57, 0xF9, 0xB9, 0xAA, 0x0F, 0xB5, 0x42, + 0xD7, 0xA3, 0xB3, 0x74, 0x9D, 0x29, 0xFB, 0xE2, + 0x0C, 0x6B, 0x61, 0xDE, 0xC2, 0x68, 0x44, 0x10 + }, + { + 0x54, 0x96, 0x57, 0x00, 0x91, 0x04, 0xFF, 0x99, + 0x9B, 0x40, 0x1D, 0x69, 0xD0, 0xF1, 0xCA, 0x81, + 0x2D, 0xEB, 0xFF, 0x80, 0x78, 0x36, 0x7D, 0x6D, + 0x60, 0x09, 0x84, 0x95, 0x90, 0xA0, 0x07, 0x19, + 0xF7, 0x62, 0xCE, 0x15, 0x68, 0x44, 0x91, 0x6A, + 0xA0, 0x1E, 0x81, 0xB1, 0x79, 0x8B, 0xD2, 0x2D, + 0x3E, 0xA2, 0x10, 0x8D, 0x21, 0x52, 0xF0, 0x97, + 0x7B, 0x10, 0xB2, 0xE6, 0x6C, 0x9F, 0x14, 0xC2 + }, + { + 0xDC, 0x9B, 0xF9, 0x9C, 0x15, 0x58, 0x88, 0x84, + 0x1E, 0xD0, 0xC0, 0xCA, 0xDB, 0xD3, 0x49, 0x11, + 0x5A, 0x34, 0x17, 0xB7, 0x4E, 0x07, 0x01, 0x92, + 0x4C, 0x6B, 0x8B, 0x95, 0x79, 0x3E, 0x51, 0xF6, + 0x5B, 0x86, 0x7C, 0x4C, 0xC3, 0x7E, 0xE3, 0xB9, + 0x38, 0xBC, 0x5B, 0xC5, 0x3D, 0xA1, 0x1F, 0x67, + 0x4A, 0xCE, 0x99, 0xF5, 0xE4, 0x63, 0xC7, 0x7A, + 0x95, 0xC5, 0x6A, 0x96, 0x4E, 0xC0, 0x5B, 0x4A + }, + { + 0x32, 0xEF, 0x2E, 0x86, 0x19, 0x90, 0xB4, 0xA5, + 0xC7, 0xBA, 0xF2, 0xAB, 0x84, 0x28, 0xA3, 0xA3, + 0x82, 0x7D, 0x20, 0xCF, 0xA4, 0x69, 0x6F, 0x80, + 0x02, 0xA1, 0x3A, 0xD6, 0xA3, 0x87, 0xC2, 0x61, + 0xE1, 0xA2, 0xE1, 0x20, 0xF0, 0x06, 0xD1, 0x2C, + 0x56, 0x78, 0xEF, 0xFA, 0x8A, 0xD8, 0xB5, 0x40, + 0xFE, 0x88, 0x2A, 0xFF, 0xD9, 0x20, 0xED, 0xFB, + 0x34, 0x70, 0x7D, 0x95, 0x48, 0xD2, 0xE4, 0xED + }, + { + 0x63, 0xD0, 0xF0, 0x7E, 0xBE, 0xDD, 0x0E, 0xAD, + 0x1F, 0xA2, 0x92, 0x03, 0x6B, 0x89, 0x1D, 0x15, + 0x0C, 0x07, 0x29, 0x64, 0x70, 0x43, 0x15, 0xCF, + 0x9A, 0xEB, 0x5C, 0xAD, 0x59, 0xB7, 0xE5, 0xCB, + 0xC1, 0x1E, 0xEA, 0x43, 0xC6, 0xCA, 0x86, 0xDF, + 0xB7, 0xF0, 0x2A, 0x56, 0xE2, 0x01, 0x51, 0x29, + 0x3A, 0xF3, 0xFC, 0xE3, 0xF5, 0x35, 0x1F, 0xDD, + 0xDC, 0xC7, 0x9D, 0xB0, 0xD1, 0x72, 0xF3, 0x49 + }, + { + 0xF8, 0xDB, 0x39, 0x2F, 0x25, 0xDB, 0xBC, 0xA9, + 0x62, 0x22, 0xA7, 0xB3, 0x2D, 0x8C, 0x3C, 0xF9, + 0x24, 0x94, 0x89, 0x9B, 0x50, 0x4D, 0x4F, 0xAC, + 0x43, 0x1F, 0x1D, 0x12, 0x84, 0xEF, 0x46, 0x23, + 0x04, 0x19, 0x74, 0x28, 0x37, 0x98, 0xA1, 0x45, + 0x55, 0x27, 0xAE, 0x33, 0xFC, 0x47, 0xD4, 0x1A, + 0x3D, 0x4F, 0xDE, 0x22, 0xBE, 0x66, 0x6D, 0xF2, + 0x55, 0xA6, 0x10, 0xF2, 0x45, 0xEF, 0x47, 0xDB + }, + { + 0x62, 0xD6, 0xA0, 0x38, 0xC5, 0xC2, 0x90, 0x78, + 0x47, 0xA3, 0xF6, 0x8B, 0x9B, 0xBB, 0x0D, 0x2A, + 0xC7, 0x48, 0xA1, 0x05, 0x0C, 0xBC, 0x38, 0x57, + 0xAB, 0x27, 0xDC, 0xB8, 0xBD, 0x0F, 0xE9, 0x0C, + 0xD2, 0xE5, 0x33, 0xFD, 0x98, 0x1D, 0x95, 0xC9, + 0x33, 0x6A, 0xE3, 0xA7, 0x95, 0xF9, 0x3B, 0x53, + 0xE5, 0x3A, 0xD1, 0xC9, 0x2D, 0xEA, 0x8C, 0x73, + 0x5B, 0xB8, 0x4E, 0x93, 0xB1, 0x45, 0xA7, 0xA5 + }, + { + 0xAE, 0x69, 0xF3, 0x6D, 0x85, 0x04, 0x92, 0x86, + 0x43, 0x56, 0x6D, 0x6F, 0x2B, 0xF2, 0x1F, 0x2B, + 0x02, 0x52, 0xC7, 0xE3, 0x55, 0xD1, 0x83, 0x0B, + 0x63, 0xEC, 0x74, 0xD0, 0x42, 0x63, 0xD3, 0xB7, + 0x45, 0x0A, 0xEE, 0xB6, 0x53, 0x78, 0xC1, 0x61, + 0xA2, 0xE5, 0xB5, 0xC0, 0x8F, 0x8E, 0x15, 0xE1, + 0x7E, 0xA9, 0x11, 0x1C, 0x77, 0x71, 0x10, 0x85, + 0x77, 0x86, 0x9B, 0xD6, 0x0B, 0xC2, 0x47, 0x40 + }, + { + 0x3C, 0xE3, 0xBD, 0x95, 0xC6, 0x3B, 0x19, 0x31, + 0xD5, 0x99, 0x97, 0xCB, 0x35, 0xEC, 0x3F, 0xC2, + 0x22, 0x66, 0x56, 0x2D, 0x55, 0x08, 0xB0, 0x49, + 0x1F, 0x20, 0xC5, 0xE4, 0xB4, 0xE6, 0x33, 0x29, + 0xF6, 0xD0, 0x3F, 0x0A, 0x63, 0x55, 0x57, 0x89, + 0x38, 0x7B, 0x5F, 0xD9, 0xA5, 0xB1, 0xAC, 0xDF, + 0x7E, 0x85, 0xE4, 0x8C, 0x67, 0x3E, 0x6D, 0x8F, + 0xC5, 0xFF, 0x33, 0x03, 0x7B, 0x2F, 0x2F, 0x4F + }, + { + 0xE4, 0xC0, 0x67, 0x27, 0xF4, 0x3A, 0x61, 0x08, + 0x82, 0x24, 0x0C, 0xFC, 0x10, 0x0A, 0xD9, 0xE7, + 0x8D, 0x32, 0x57, 0x51, 0x61, 0x1C, 0xCE, 0x51, + 0x73, 0x8F, 0x83, 0x47, 0x50, 0x5B, 0x5D, 0xB6, + 0x5F, 0xFE, 0x72, 0x1F, 0x38, 0x60, 0x8A, 0xE2, + 0x9B, 0x1D, 0x05, 0x16, 0x06, 0x8C, 0x37, 0x95, + 0x6A, 0xFC, 0x76, 0x5C, 0x35, 0x5B, 0x53, 0xA5, + 0x63, 0x5F, 0x68, 0xAD, 0xD4, 0xA3, 0xFD, 0xC2 + }, + { + 0xFB, 0x29, 0x00, 0x3A, 0xC6, 0xAE, 0xD6, 0x62, + 0xEA, 0x61, 0xCB, 0x0A, 0x3C, 0xD8, 0x1A, 0x73, + 0xEF, 0x9F, 0xB5, 0xC6, 0xB4, 0xEE, 0xE7, 0x16, + 0x81, 0xBF, 0xF2, 0x55, 0x07, 0xE4, 0xC0, 0xA4, + 0x75, 0xA6, 0x2E, 0x87, 0x6D, 0x2D, 0x11, 0x6E, + 0x1D, 0xD1, 0xD1, 0x87, 0xEE, 0x59, 0x94, 0xA6, + 0x05, 0xAA, 0x24, 0xB7, 0xB4, 0x5B, 0x63, 0x61, + 0x6E, 0x6C, 0xE5, 0xFB, 0xFE, 0x97, 0x63, 0x9D + }, + { + 0xAE, 0x6F, 0xAD, 0x2C, 0x01, 0xF2, 0xC2, 0xDA, + 0xCB, 0x13, 0xA2, 0x88, 0xC5, 0x02, 0xBC, 0x82, + 0x3A, 0x43, 0xA4, 0xB4, 0x52, 0xFA, 0x2C, 0xFA, + 0x9E, 0xEA, 0xDF, 0x6F, 0x17, 0x3E, 0x57, 0x65, + 0x21, 0xDB, 0xA3, 0x49, 0xD3, 0xD6, 0xC3, 0x9B, + 0x3A, 0x18, 0x79, 0x25, 0x24, 0x74, 0x9B, 0x6B, + 0xD5, 0x34, 0xE0, 0xB5, 0x23, 0xD5, 0xC9, 0x7D, + 0x49, 0x69, 0xA3, 0x98, 0x3E, 0x5B, 0xB9, 0x10 + }, + { + 0xA0, 0x60, 0x68, 0x83, 0xFA, 0x08, 0xF4, 0x61, + 0x3B, 0x5B, 0xED, 0xE1, 0xAA, 0x67, 0xB3, 0xF1, + 0x87, 0x7A, 0xF0, 0x16, 0xE5, 0xC8, 0xB9, 0x14, + 0xAD, 0x5F, 0x8A, 0x76, 0x43, 0x33, 0xC1, 0xD6, + 0x02, 0xA1, 0x16, 0xA1, 0xA2, 0x25, 0x49, 0xE1, + 0x8C, 0xE0, 0xCD, 0x82, 0x54, 0x68, 0x96, 0xA9, + 0xF5, 0xB2, 0xCE, 0x22, 0x63, 0x76, 0x78, 0x10, + 0xAA, 0x4C, 0x2D, 0x7E, 0x87, 0x0B, 0x4A, 0x0C + }, + { + 0x9D, 0xF4, 0x2E, 0x4E, 0x63, 0xAC, 0xEF, 0x48, + 0x0F, 0x67, 0x5F, 0x39, 0x01, 0xA7, 0x83, 0xB2, + 0x2C, 0xE3, 0x14, 0xC4, 0x84, 0x9E, 0x82, 0x7F, + 0x79, 0x38, 0xE9, 0x89, 0x9B, 0x00, 0xC5, 0x4F, + 0x8C, 0x50, 0x07, 0x10, 0x81, 0xE1, 0x0B, 0x02, + 0x26, 0x22, 0x13, 0xBB, 0xAE, 0x7C, 0x98, 0x93, + 0x50, 0xF3, 0xDE, 0x66, 0x75, 0x45, 0xDF, 0x94, + 0xFE, 0xCC, 0x4A, 0x94, 0x92, 0xB4, 0x35, 0x9C + }, + { + 0x89, 0xCF, 0x7A, 0xDD, 0x87, 0x9F, 0x00, 0x6D, + 0xF3, 0xB6, 0x7C, 0x2F, 0x72, 0x69, 0x48, 0x2E, + 0x12, 0x9A, 0x7D, 0xFD, 0x73, 0x76, 0x9E, 0x0A, + 0x8E, 0x6D, 0x51, 0xDB, 0x57, 0x25, 0x4F, 0x72, + 0x7F, 0x2E, 0x3C, 0x84, 0xD8, 0xE7, 0x2F, 0x91, + 0x24, 0x12, 0x56, 0xC5, 0xC4, 0xF0, 0x15, 0x0F, + 0xA1, 0xD5, 0x1A, 0x89, 0x04, 0xD8, 0xBD, 0xE1, + 0x03, 0xF0, 0xF7, 0x53, 0x19, 0xA4, 0x64, 0x66 + }, + { + 0xDF, 0xD1, 0x7C, 0xC6, 0x26, 0xD0, 0xD4, 0xA5, + 0x03, 0xCF, 0xE7, 0x91, 0x3E, 0x50, 0x64, 0x5E, + 0x62, 0xC5, 0x0F, 0xEB, 0xB8, 0x44, 0x34, 0x05, + 0xB1, 0x64, 0x25, 0xF8, 0x7D, 0x0E, 0xC4, 0xF7, + 0xB0, 0xE2, 0xC3, 0x3B, 0x7B, 0xF8, 0x94, 0x27, + 0xF4, 0x7D, 0x23, 0x48, 0x39, 0x00, 0x42, 0xD9, + 0xB1, 0x76, 0x98, 0xD9, 0x21, 0x7E, 0x09, 0x92, + 0x4E, 0xD2, 0x2D, 0x8D, 0xB4, 0x97, 0x6E, 0x16 + }, + { + 0xDC, 0x9F, 0xF4, 0xC2, 0x5E, 0x36, 0x71, 0x11, + 0x2A, 0x54, 0x35, 0xCA, 0x8D, 0x16, 0x94, 0x9B, + 0x4E, 0x80, 0x78, 0xCF, 0x09, 0x8C, 0x80, 0xD3, + 0xCB, 0x03, 0xE7, 0x38, 0x0E, 0xB3, 0xAE, 0x10, + 0x7C, 0x11, 0x45, 0x3D, 0x00, 0x07, 0x50, 0xA2, + 0xBA, 0x8E, 0x00, 0x96, 0x20, 0xBA, 0x04, 0xE6, + 0x44, 0xBF, 0xBB, 0x6F, 0x6E, 0xE4, 0x5A, 0x43, + 0x9C, 0x8F, 0xEF, 0xAB, 0x32, 0x67, 0x53, 0xE9 + }, + { + 0x11, 0x3A, 0x15, 0x0B, 0x5A, 0x25, 0xB9, 0x60, + 0xF7, 0xB9, 0x0D, 0x36, 0xF3, 0xBC, 0xD1, 0x4C, + 0x5B, 0xF8, 0xC6, 0xA8, 0xA0, 0x37, 0xF6, 0x71, + 0x97, 0xDF, 0xF1, 0x24, 0xFC, 0x71, 0x1C, 0xBB, + 0xF8, 0xB0, 0x87, 0x6C, 0x5B, 0x73, 0x82, 0xF9, + 0xB2, 0xDA, 0x11, 0xC8, 0xC4, 0x2F, 0x7D, 0xCC, + 0x84, 0x0F, 0xB8, 0x4F, 0x54, 0x9C, 0x4E, 0x1A, + 0x3D, 0xF9, 0xEC, 0x58, 0xAE, 0x3A, 0xCA, 0x12 + }, + { + 0xCE, 0x17, 0xA2, 0x16, 0x93, 0xF7, 0x8B, 0xC2, + 0x81, 0x97, 0x43, 0x89, 0x1D, 0xBE, 0x8A, 0x09, + 0xA6, 0xF4, 0xAF, 0x2C, 0x4F, 0xF4, 0x05, 0xC3, + 0x43, 0xFC, 0x91, 0x49, 0x71, 0x7D, 0xD1, 0x0D, + 0x8C, 0xBF, 0x52, 0x04, 0x44, 0x44, 0x21, 0x60, + 0xFA, 0xB4, 0xE9, 0x36, 0x00, 0x9A, 0xF0, 0x6A, + 0x3C, 0xE4, 0xD7, 0xE2, 0x4D, 0x92, 0x79, 0x65, + 0xEA, 0x29, 0x67, 0x65, 0x84, 0x5F, 0x35, 0x19 + }, + { + 0xB1, 0xCA, 0x36, 0x6F, 0xB1, 0x3D, 0x7E, 0x0F, + 0x6E, 0x92, 0x67, 0xCD, 0x39, 0xFA, 0x0B, 0xE1, + 0x91, 0x1B, 0x58, 0x83, 0xA1, 0xDB, 0x2D, 0xC2, + 0x76, 0x90, 0x1C, 0xBE, 0xD7, 0xFD, 0x00, 0x5A, + 0xA9, 0x08, 0xE6, 0xFC, 0xE8, 0x2D, 0xE8, 0x2C, + 0x08, 0xFA, 0xDA, 0x91, 0x72, 0xAD, 0x6D, 0x7D, + 0x10, 0x37, 0x07, 0x97, 0xE9, 0x32, 0xFC, 0x96, + 0x4F, 0x00, 0xA8, 0x1A, 0xA5, 0x1F, 0xCE, 0xBE + }, + { + 0x06, 0x22, 0xE4, 0x5C, 0x42, 0x01, 0x5C, 0x39, + 0x74, 0x49, 0x8D, 0xCD, 0x20, 0x7C, 0x8B, 0x35, + 0xF5, 0x85, 0xCA, 0x7C, 0x05, 0xBE, 0x9B, 0xB1, + 0x06, 0x78, 0x59, 0x21, 0xD8, 0x20, 0x7C, 0x80, + 0xB9, 0xAB, 0x0C, 0xA4, 0x70, 0x2A, 0xFB, 0x39, + 0xF2, 0xD1, 0x18, 0x9D, 0x99, 0xDD, 0x62, 0x51, + 0x91, 0xFF, 0xF3, 0x9C, 0x75, 0x03, 0x39, 0xFD, + 0xCA, 0xB7, 0xBB, 0x2F, 0xEF, 0x4A, 0x8D, 0x81 + }, + { + 0x02, 0x15, 0x45, 0x6A, 0x3B, 0x31, 0x3B, 0x3B, + 0xC6, 0x92, 0x18, 0xE8, 0x95, 0xFA, 0x64, 0xCC, + 0xBD, 0x8F, 0x15, 0xEE, 0xAB, 0x52, 0x7A, 0xAD, + 0xF4, 0x0D, 0x7E, 0x69, 0x0A, 0xBD, 0x94, 0x74, + 0xC3, 0x03, 0xD5, 0x57, 0xB1, 0x61, 0x93, 0x66, + 0xC0, 0x99, 0x32, 0x1B, 0x52, 0xCD, 0xFA, 0x91, + 0x26, 0x35, 0x37, 0x9C, 0x79, 0x27, 0xB5, 0x14, + 0xA2, 0x14, 0x6D, 0x7F, 0x49, 0x1F, 0xE0, 0x64 + }, + { + 0x72, 0x0E, 0x85, 0x2A, 0x92, 0x04, 0xBC, 0x16, + 0x88, 0x8E, 0x2B, 0x21, 0x25, 0x08, 0xFD, 0xFF, + 0x9C, 0xFA, 0x55, 0xBB, 0x84, 0x48, 0x81, 0x3F, + 0x89, 0x58, 0x12, 0xCE, 0x57, 0xE3, 0x90, 0x94, + 0x63, 0xB2, 0x9B, 0x9D, 0x38, 0x99, 0x29, 0x5D, + 0x32, 0x38, 0xF4, 0x03, 0x2C, 0x4F, 0x76, 0xB8, + 0x80, 0x4D, 0x28, 0xBB, 0x34, 0xA1, 0x9B, 0x6D, + 0xB1, 0xD8, 0x9A, 0x95, 0xB3, 0xFA, 0x4E, 0x40 + }, + { + 0x28, 0xEE, 0x8F, 0x72, 0xC6, 0x06, 0xFF, 0x83, + 0x71, 0xB2, 0x04, 0xAB, 0x4E, 0x07, 0x1F, 0x31, + 0x03, 0xCB, 0x2C, 0x81, 0x3D, 0x27, 0x4C, 0xE3, + 0xA5, 0x7F, 0xB1, 0x27, 0x6E, 0x5F, 0xE7, 0xA9, + 0xF0, 0x96, 0x7F, 0x20, 0x65, 0x89, 0x48, 0x96, + 0x78, 0x9A, 0xBF, 0x4D, 0xFC, 0x12, 0x4B, 0x13, + 0x34, 0x2F, 0xBC, 0xDC, 0x65, 0x17, 0xE2, 0x33, + 0x1C, 0x99, 0x70, 0x9E, 0xB0, 0x60, 0x0B, 0x03 + }, + { + 0xD0, 0xD8, 0x51, 0xB6, 0x7E, 0xD7, 0x07, 0x9A, + 0xDC, 0x5E, 0x41, 0xB9, 0x15, 0x3D, 0xE7, 0xD8, + 0xCC, 0x8B, 0x4E, 0x71, 0x0B, 0x56, 0x77, 0xC5, + 0xCF, 0x63, 0xFA, 0xA1, 0x97, 0x64, 0xE6, 0x70, + 0xA5, 0x37, 0x47, 0xFB, 0x54, 0xC8, 0x71, 0x59, + 0xF4, 0x7C, 0xEE, 0xF9, 0x91, 0xD3, 0xBB, 0x57, + 0xE4, 0xF0, 0x00, 0xC7, 0x09, 0xC8, 0x9C, 0xF3, + 0x0F, 0x5F, 0x1D, 0x72, 0x8F, 0x7F, 0xB0, 0x05 + }, + { + 0x9D, 0x68, 0x6D, 0x11, 0x97, 0x04, 0x66, 0xF1, + 0x14, 0xF4, 0x90, 0xB0, 0x06, 0xF7, 0xBF, 0x57, + 0xB0, 0x8B, 0x9E, 0x39, 0xD9, 0xC6, 0x28, 0x28, + 0xA3, 0xAC, 0x69, 0x77, 0xC2, 0xAA, 0x25, 0x11, + 0xD2, 0x31, 0xEA, 0x5D, 0xFC, 0x4A, 0x25, 0x5B, + 0xD3, 0x8A, 0x10, 0xEC, 0xEE, 0x74, 0xCF, 0xF7, + 0xB1, 0x55, 0xCE, 0xB3, 0x6C, 0x36, 0xF3, 0x47, + 0xDC, 0xFB, 0x22, 0x1A, 0xC2, 0xF1, 0xCF, 0x48 + }, + { + 0x85, 0x74, 0x63, 0x98, 0x9A, 0x2B, 0xEF, 0x5E, + 0x77, 0xE9, 0xF9, 0x84, 0x7D, 0x45, 0x26, 0xF1, + 0x07, 0x56, 0xF1, 0xF2, 0x18, 0x9E, 0x56, 0x25, + 0xF0, 0xA4, 0x6B, 0x47, 0xF6, 0xC8, 0xDB, 0x43, + 0xCD, 0xA0, 0x6D, 0x95, 0x5A, 0x3C, 0xDE, 0xED, + 0x1C, 0x7B, 0xA8, 0x54, 0x6C, 0x17, 0xBB, 0x66, + 0x72, 0xCB, 0xDF, 0xF3, 0x90, 0x0C, 0x5B, 0x82, + 0x02, 0x4A, 0xB8, 0xD1, 0xE7, 0x09, 0xCB, 0xAC + }, + { + 0x15, 0xB2, 0xC6, 0xD3, 0x90, 0x02, 0xC5, 0xDA, + 0x2A, 0x41, 0x61, 0xC2, 0x29, 0xC0, 0x40, 0x19, + 0x32, 0xAD, 0x3C, 0xE2, 0x83, 0x73, 0x2B, 0x50, + 0xCF, 0x55, 0xAB, 0x9C, 0xEE, 0x49, 0xDC, 0xA3, + 0x91, 0xB3, 0x6F, 0x98, 0x4F, 0x57, 0xE2, 0x72, + 0x98, 0x3B, 0x2B, 0xFB, 0x56, 0xC7, 0x53, 0xED, + 0xBA, 0xCE, 0x77, 0x39, 0x7C, 0xCE, 0x80, 0x56, + 0xE6, 0xB5, 0xFF, 0xC1, 0x06, 0x21, 0xA9, 0x19 + }, + { + 0xE3, 0xE8, 0xAE, 0x9A, 0xF3, 0xFA, 0xD2, 0xE5, + 0x91, 0x9B, 0xB5, 0xEB, 0x67, 0x81, 0x38, 0x2F, + 0xF6, 0x4A, 0x99, 0x2B, 0x9C, 0x80, 0x97, 0x88, + 0xF0, 0xD8, 0x06, 0x6D, 0x63, 0x8A, 0x26, 0x63, + 0xC3, 0x0E, 0xC8, 0x70, 0xB0, 0x0F, 0x36, 0x9E, + 0x6A, 0x7C, 0x83, 0x6A, 0x25, 0xB7, 0xED, 0xEC, + 0xEE, 0xD2, 0x9C, 0xE1, 0x88, 0x2A, 0xE3, 0x52, + 0xF6, 0xB4, 0x77, 0xC2, 0x67, 0x39, 0x62, 0x0D + }, + { + 0x3F, 0x28, 0x0B, 0x4E, 0x31, 0xB6, 0x94, 0x40, + 0x41, 0xA5, 0x05, 0xDB, 0xD8, 0x55, 0x5B, 0xC6, + 0x82, 0x64, 0xAD, 0x01, 0x82, 0xD3, 0x5C, 0x8F, + 0x49, 0x24, 0x9C, 0xD3, 0xFC, 0xBE, 0xD7, 0xE7, + 0x6F, 0x58, 0x5B, 0xBE, 0x88, 0x62, 0x41, 0x4C, + 0x5A, 0xB4, 0xC3, 0x6C, 0xF4, 0xE4, 0x40, 0x92, + 0x3E, 0xB4, 0x61, 0xEF, 0x34, 0x89, 0x95, 0xE5, + 0xF7, 0x25, 0x31, 0xEB, 0x3C, 0x4D, 0xB3, 0x82 + }, + { + 0x88, 0x0C, 0xF9, 0xA4, 0x80, 0x6C, 0xA5, 0x6F, + 0x28, 0x74, 0xA6, 0x33, 0xFB, 0x6C, 0x9A, 0x65, + 0xBB, 0xF0, 0xB1, 0xDA, 0xCE, 0xF8, 0x2D, 0xAA, + 0x29, 0xEA, 0x0C, 0x4F, 0x62, 0xC8, 0x3F, 0x78, + 0x66, 0x55, 0x5A, 0x12, 0x72, 0xE8, 0x44, 0x07, + 0x79, 0x57, 0x06, 0x86, 0xB0, 0xBF, 0x74, 0x10, + 0x64, 0xCD, 0x38, 0x01, 0x62, 0xAE, 0x7E, 0xB1, + 0x44, 0xDF, 0x94, 0xA4, 0x33, 0xA5, 0x0A, 0xDB + }, + { + 0x04, 0x89, 0x96, 0x22, 0x2D, 0xB3, 0x4E, 0x85, + 0xC2, 0x1E, 0x71, 0xE2, 0x03, 0xE8, 0xEB, 0x6E, + 0x3F, 0x41, 0xAD, 0x41, 0xF2, 0x43, 0x6E, 0xCA, + 0x3D, 0xFD, 0xD7, 0x25, 0x03, 0xAB, 0xD0, 0x07, + 0xBC, 0x59, 0x4C, 0x15, 0x16, 0xAD, 0x53, 0x62, + 0x38, 0xF5, 0x20, 0xF9, 0xE3, 0xA8, 0xF6, 0x8C, + 0x8C, 0x43, 0x6F, 0x41, 0x9D, 0xF2, 0x73, 0x5E, + 0xE4, 0x25, 0xC8, 0xB5, 0x21, 0xEF, 0x25, 0x33 + }, + { + 0x5A, 0x00, 0x93, 0xCD, 0x6C, 0xF0, 0x0B, 0x5B, + 0x30, 0xA4, 0xC0, 0x3F, 0x1F, 0x27, 0xE5, 0x30, + 0xA6, 0x8A, 0x8A, 0xED, 0x26, 0x24, 0x2C, 0x59, + 0xC8, 0x96, 0x7F, 0xCC, 0x83, 0x62, 0xF0, 0xB4, + 0xFE, 0xAD, 0x5F, 0xE5, 0xF4, 0xB6, 0xD0, 0x83, + 0x53, 0x9B, 0xF7, 0x9B, 0xC3, 0x38, 0x32, 0x3F, + 0xE1, 0x75, 0x25, 0xA0, 0xA1, 0xC8, 0xCB, 0x22, + 0xB8, 0x5E, 0x8D, 0x53, 0x7F, 0xAD, 0x3F, 0xFD + }, + { + 0xCF, 0x66, 0xD4, 0xD9, 0x0A, 0x58, 0x26, 0x7A, + 0xC5, 0xF8, 0x8F, 0x9E, 0x88, 0x62, 0x40, 0x24, + 0x63, 0x22, 0x9E, 0x03, 0xA1, 0xEC, 0xB5, 0x09, + 0x4B, 0x93, 0xC9, 0x9F, 0x78, 0x3C, 0x4E, 0x04, + 0xF5, 0xC3, 0x82, 0xE6, 0x01, 0x65, 0x01, 0xBC, + 0x71, 0xAB, 0x3D, 0x80, 0xE0, 0x0A, 0xE8, 0x49, + 0x98, 0x91, 0x04, 0x45, 0xFA, 0x70, 0xD3, 0x55, + 0x88, 0xEC, 0xC4, 0x14, 0xA8, 0x8F, 0xCB, 0xDA + }, + { + 0xE3, 0x07, 0x7E, 0xC8, 0xB2, 0x94, 0x4A, 0xEA, + 0x6A, 0xCC, 0xDE, 0x8C, 0x48, 0xB5, 0xCB, 0x4C, + 0x83, 0x07, 0x46, 0xC3, 0x72, 0xE8, 0x34, 0x50, + 0xE0, 0xDC, 0xEC, 0x24, 0xC0, 0x05, 0xED, 0x0A, + 0x3B, 0x50, 0xBC, 0xF5, 0xC2, 0x34, 0x07, 0x8C, + 0x6D, 0x39, 0xDD, 0x0B, 0x29, 0xFD, 0x1D, 0x02, + 0xC2, 0x49, 0xD5, 0xAE, 0xB6, 0x71, 0x82, 0x15, + 0x47, 0x6C, 0xED, 0xAB, 0x33, 0x0B, 0xFE, 0x2D + }, + { + 0x73, 0x32, 0x1B, 0xE3, 0xB3, 0x93, 0xA2, 0x5B, + 0x9A, 0x5B, 0xD2, 0x15, 0xC1, 0x75, 0xB6, 0x52, + 0x6A, 0x77, 0x3D, 0xF8, 0x6D, 0x58, 0x07, 0x58, + 0x00, 0xF9, 0xA4, 0x03, 0x61, 0xA2, 0xF2, 0x12, + 0xEC, 0x80, 0xDC, 0x91, 0x48, 0xAA, 0x23, 0xE5, + 0xF7, 0xD3, 0x28, 0x0D, 0x98, 0xDE, 0xB1, 0xB6, + 0x68, 0x65, 0xB7, 0xFB, 0x9D, 0x1A, 0x50, 0x10, + 0x7C, 0xDB, 0xFE, 0x1A, 0xA9, 0x71, 0x10, 0xB5 + }, + { + 0xDC, 0xF4, 0x73, 0x7B, 0xE7, 0x3B, 0x25, 0xAC, + 0xA6, 0xE8, 0x15, 0x89, 0x33, 0xD5, 0x42, 0x70, + 0xB4, 0x51, 0xE5, 0xAD, 0x4F, 0x53, 0x25, 0xDA, + 0x03, 0xC9, 0xD5, 0xC4, 0xC2, 0xC9, 0x21, 0x48, + 0x23, 0x7D, 0xA1, 0xCC, 0xAD, 0x09, 0xF5, 0x89, + 0x95, 0x46, 0x29, 0x0B, 0xBF, 0x7D, 0x7A, 0xAA, + 0xEC, 0x5B, 0x32, 0x9E, 0x49, 0x16, 0xDF, 0xA9, + 0x17, 0xB1, 0x35, 0xC8, 0x6D, 0x8C, 0xEC, 0x92 + }, + { + 0xC6, 0xA0, 0xA1, 0xBB, 0x55, 0x7D, 0x72, 0x38, + 0x24, 0xC2, 0x5E, 0x33, 0x56, 0xAC, 0x94, 0x3E, + 0xCD, 0x9C, 0x8A, 0x5B, 0x1C, 0x92, 0x7A, 0xE4, + 0x8C, 0x37, 0x62, 0x56, 0x26, 0x2E, 0x07, 0xEB, + 0xD9, 0xB2, 0x59, 0x69, 0x9F, 0x62, 0x79, 0xC4, + 0xAF, 0xC5, 0x47, 0xD9, 0xB8, 0xC7, 0xFE, 0x4E, + 0x5E, 0x05, 0xFB, 0x02, 0x44, 0x27, 0x65, 0xAD, + 0x6A, 0xDC, 0x8C, 0xD2, 0x0B, 0x49, 0x03, 0x72 + }, + { + 0xAE, 0x12, 0x07, 0x75, 0xB2, 0x74, 0x19, 0xCE, + 0x27, 0x79, 0x78, 0x87, 0x4E, 0x11, 0xB1, 0x6F, + 0xAC, 0x29, 0x02, 0x5A, 0x12, 0xC6, 0xED, 0x0E, + 0x9B, 0x34, 0x21, 0x5E, 0xE7, 0x9D, 0x40, 0x22, + 0xC4, 0x25, 0xC5, 0x89, 0x8A, 0x25, 0x96, 0xFD, + 0xCD, 0x16, 0x8D, 0x32, 0x0D, 0x9E, 0x9B, 0xA8, + 0xA0, 0x62, 0x6E, 0x45, 0x29, 0x99, 0x3E, 0x99, + 0x2B, 0x8A, 0x7C, 0x2B, 0x71, 0xF1, 0x75, 0x41 + }, + { + 0x0A, 0x97, 0xCF, 0x27, 0x63, 0x58, 0x37, 0xA6, + 0xFF, 0xA0, 0xD1, 0x40, 0x43, 0x89, 0x0A, 0xED, + 0xDE, 0xE6, 0x10, 0xEF, 0xED, 0xB7, 0x0A, 0xF6, + 0x45, 0xDE, 0x06, 0xA3, 0xB9, 0x4E, 0x8D, 0xBF, + 0xA7, 0x37, 0xD6, 0x0C, 0xB3, 0x0E, 0x6F, 0x95, + 0xE6, 0xDF, 0x95, 0x56, 0x23, 0xEA, 0xD5, 0x37, + 0xE4, 0x5F, 0xC5, 0x71, 0x19, 0x9B, 0x0D, 0x66, + 0x15, 0x56, 0xB7, 0x2E, 0x41, 0x78, 0x80, 0xD5 + }, + { + 0x4C, 0x66, 0xFE, 0xF5, 0x2D, 0xB7, 0xE0, 0xBE, + 0x03, 0xCD, 0x5F, 0x45, 0x55, 0xE9, 0xBC, 0xC6, + 0x97, 0xDB, 0x36, 0xC3, 0x2F, 0xCB, 0xF6, 0xA2, + 0x42, 0x73, 0xFE, 0x50, 0xD2, 0x0E, 0xA4, 0xAB, + 0xFD, 0x00, 0xF0, 0x1B, 0x4D, 0x23, 0xB0, 0xF9, + 0xFB, 0xB9, 0x13, 0x17, 0x6D, 0x10, 0xFA, 0xD7, + 0xE9, 0x44, 0x62, 0x8F, 0xA4, 0xDE, 0x03, 0xFC, + 0x50, 0x43, 0xC6, 0x2B, 0x9F, 0xEC, 0x80, 0xD6 + }, + { + 0xB1, 0xC6, 0x1D, 0x9B, 0xEB, 0x1C, 0x76, 0x86, + 0x68, 0x93, 0xA2, 0x39, 0x9A, 0x40, 0xCD, 0xD4, + 0x40, 0x65, 0x2A, 0xDF, 0xDB, 0x47, 0x8A, 0x5D, + 0x82, 0x86, 0xED, 0x48, 0xE4, 0xEA, 0xBF, 0xF9, + 0x38, 0x6C, 0x88, 0xE3, 0x32, 0x01, 0xC6, 0x40, + 0x0D, 0x66, 0x15, 0x49, 0x33, 0x77, 0xF7, 0x6B, + 0x16, 0x3A, 0x73, 0x8D, 0xA0, 0xE7, 0xB9, 0x1F, + 0x87, 0x41, 0x5F, 0x70, 0x43, 0xE5, 0x12, 0x1C + }, + { + 0x87, 0xED, 0x5B, 0xFA, 0x9B, 0x3D, 0xC7, 0x5F, + 0xF8, 0x81, 0xEC, 0xD5, 0x09, 0xEA, 0x86, 0x73, + 0x24, 0xED, 0x98, 0x42, 0xDF, 0x94, 0xFD, 0x9A, + 0xB8, 0x42, 0x88, 0x46, 0xB8, 0x41, 0x18, 0x2D, + 0x6D, 0x9C, 0x72, 0x7A, 0xCC, 0x03, 0xF9, 0x1E, + 0xD1, 0x02, 0x0F, 0xE5, 0x30, 0x36, 0x33, 0xBE, + 0xF7, 0xC7, 0x45, 0xA6, 0xDF, 0x7B, 0x6F, 0xCC, + 0x2C, 0xAE, 0xBE, 0xA8, 0x54, 0x77, 0x5C, 0xD8 + }, + { + 0x81, 0x98, 0x7F, 0x77, 0x12, 0xDF, 0x90, 0x71, + 0x2D, 0x5A, 0xFC, 0x36, 0xFC, 0x42, 0x08, 0x5E, + 0x51, 0xDA, 0x96, 0x5B, 0xCA, 0x78, 0xF7, 0x9A, + 0x5B, 0x24, 0x38, 0x27, 0xE9, 0x20, 0x79, 0xB8, + 0xF0, 0x1C, 0xE2, 0xCC, 0x7C, 0xA6, 0xE7, 0x88, + 0xE5, 0xA8, 0x9F, 0x54, 0x6D, 0x8E, 0xA1, 0x69, + 0xB7, 0x0C, 0x90, 0xB5, 0x6C, 0xBA, 0xA3, 0x5A, + 0xBE, 0xB7, 0x9D, 0xBE, 0x54, 0xCE, 0x1E, 0x32 + }, + { + 0x38, 0xD2, 0xE8, 0xF6, 0x54, 0x38, 0xDD, 0x97, + 0x9A, 0x19, 0x89, 0x00, 0xF3, 0xA3, 0x1A, 0xB3, + 0x75, 0xA4, 0x7A, 0x77, 0xCA, 0x7D, 0x2B, 0x0A, + 0xF7, 0x52, 0xA8, 0x2A, 0x65, 0x41, 0x29, 0xE2, + 0x25, 0x5F, 0x11, 0xD6, 0xD3, 0xEF, 0xC5, 0xB6, + 0xBA, 0x8E, 0xCF, 0x8B, 0xF5, 0xA6, 0xFC, 0xA1, + 0xA8, 0x37, 0xFE, 0xFC, 0x78, 0xAC, 0x90, 0x62, + 0x03, 0x1A, 0xC8, 0xA9, 0x15, 0x58, 0xB0, 0xBA + }, + { + 0x47, 0x10, 0x35, 0x9F, 0xB2, 0xEE, 0x25, 0x11, + 0x8E, 0x81, 0x35, 0xAB, 0xA7, 0xDE, 0x8E, 0xDC, + 0x96, 0x1C, 0xF2, 0x7E, 0x3D, 0xC1, 0x99, 0x75, + 0x4D, 0xF3, 0x52, 0xBA, 0xA0, 0xE9, 0x7F, 0x5A, + 0xBD, 0x22, 0xD7, 0x69, 0xF9, 0x23, 0x9C, 0x68, + 0x74, 0xC2, 0xC3, 0x67, 0xBB, 0xC4, 0xD9, 0x14, + 0x02, 0xF3, 0x8B, 0xE2, 0x4C, 0x33, 0x52, 0x17, + 0xB0, 0x97, 0x8A, 0x2D, 0x09, 0xEC, 0xB3, 0xAD + }, + { + 0x03, 0xCF, 0x22, 0x20, 0x99, 0x34, 0x6E, 0x51, + 0xD1, 0xD9, 0xFD, 0x6C, 0xA4, 0xE1, 0xC7, 0xF7, + 0xBE, 0x2C, 0x74, 0x01, 0xC6, 0x0B, 0xAE, 0x02, + 0x25, 0xC6, 0xE8, 0x5A, 0xC0, 0x07, 0xF4, 0xCF, + 0xFE, 0x47, 0xF4, 0xEA, 0xED, 0x9E, 0x43, 0x41, + 0x34, 0x0F, 0x76, 0x6F, 0x2B, 0x6A, 0xB3, 0xC6, + 0x8D, 0x1F, 0xF3, 0x97, 0x39, 0x7D, 0xBD, 0x3B, + 0x1E, 0x15, 0x92, 0x88, 0x6B, 0x79, 0x17, 0xF7 + }, + { + 0xC4, 0x51, 0xFD, 0x80, 0xE5, 0xA8, 0xD8, 0xA5, + 0xFB, 0x67, 0x4C, 0xC2, 0x32, 0x89, 0x05, 0x54, + 0x0E, 0x24, 0xD2, 0x98, 0xC9, 0x3A, 0x65, 0xE9, + 0xAA, 0xFA, 0x0B, 0x69, 0xD7, 0xE5, 0x80, 0x68, + 0xD1, 0x78, 0x4A, 0xCF, 0xA3, 0x21, 0xD3, 0xDA, + 0xB9, 0xE1, 0xE6, 0x13, 0x34, 0x85, 0xC7, 0x37, + 0x03, 0x60, 0x34, 0x9D, 0xC2, 0xB7, 0x1A, 0xFD, + 0xCB, 0xEC, 0x87, 0x00, 0x8C, 0xD5, 0xF9, 0xBF + }, + { + 0x86, 0x95, 0x8E, 0xE4, 0x70, 0xF5, 0x52, 0xF9, + 0x12, 0xAC, 0xB1, 0xCD, 0xC5, 0x71, 0x92, 0x40, + 0xCE, 0x39, 0x51, 0xB1, 0x34, 0x3A, 0x96, 0x28, + 0x92, 0xCA, 0xC7, 0xE4, 0x14, 0x8B, 0xFC, 0xC7, + 0x3C, 0xF2, 0xAC, 0xAD, 0xB0, 0xAA, 0xB9, 0xAE, + 0x8A, 0x63, 0x95, 0xF6, 0x1A, 0x1A, 0x96, 0x29, + 0x33, 0x59, 0x4A, 0x79, 0x6C, 0xF5, 0xDF, 0x2C, + 0x40, 0xEA, 0xCE, 0x00, 0x4F, 0xC8, 0x98, 0x8C + }, + { + 0x67, 0xB2, 0x3E, 0xF3, 0xE7, 0xB5, 0xE9, 0x24, + 0x79, 0x0A, 0xD5, 0xE8, 0x57, 0x00, 0xB6, 0xFA, + 0x61, 0xDA, 0xA6, 0x10, 0x18, 0x6F, 0x86, 0x45, + 0x53, 0xD6, 0x65, 0xCE, 0xFA, 0x48, 0x32, 0xD1, + 0xC4, 0xEF, 0x62, 0x3E, 0x3E, 0x06, 0x4E, 0xDC, + 0x6C, 0x42, 0x9B, 0xBB, 0xDD, 0x07, 0x66, 0x65, + 0x46, 0xFD, 0x7C, 0x94, 0x5D, 0x4E, 0xD5, 0xFD, + 0x2A, 0xEB, 0xF5, 0x0E, 0xDB, 0x63, 0xA2, 0xF5 + }, + { + 0xEE, 0x24, 0xC9, 0xA1, 0x5D, 0xBF, 0xF7, 0x8F, + 0x6A, 0x04, 0xD3, 0x15, 0x20, 0xBB, 0x42, 0x92, + 0x13, 0xB7, 0x85, 0xDD, 0x3E, 0x94, 0x47, 0x06, + 0xD1, 0x6A, 0x86, 0x46, 0x16, 0xC8, 0x3A, 0x04, + 0xCA, 0xDA, 0xBD, 0xBC, 0x91, 0x8F, 0x5F, 0x16, + 0xA5, 0xAA, 0x1C, 0xA1, 0xA1, 0x77, 0xDB, 0x33, + 0xA3, 0xF0, 0xCA, 0x35, 0xD5, 0x2F, 0x35, 0xBC, + 0xE7, 0x18, 0x9B, 0xEC, 0x7A, 0xF0, 0x16, 0x39 + }, + { + 0xAC, 0x54, 0x57, 0x6A, 0xDB, 0x84, 0x0F, 0x17, + 0x6D, 0x3A, 0x37, 0xBC, 0x44, 0x26, 0x71, 0xA7, + 0x15, 0xB3, 0xF3, 0x12, 0x50, 0x21, 0x7E, 0x52, + 0xF0, 0x0D, 0xB1, 0x6E, 0xE6, 0x22, 0x8A, 0xC6, + 0xB0, 0x55, 0x76, 0x62, 0x51, 0x82, 0x89, 0x90, + 0x07, 0x11, 0x5B, 0x96, 0x37, 0xB6, 0xD9, 0xD6, + 0x5B, 0xDD, 0x63, 0x99, 0x2E, 0x10, 0x51, 0x77, + 0xE5, 0x12, 0x8A, 0x0E, 0x1B, 0x73, 0xC6, 0x47 + }, + { + 0xE4, 0x19, 0x43, 0x0F, 0x4C, 0x77, 0xC5, 0x5E, + 0xAE, 0x09, 0x79, 0x5D, 0x1C, 0x2A, 0x1B, 0x04, + 0xA9, 0x52, 0x58, 0xCB, 0x52, 0xAB, 0x78, 0x50, + 0x22, 0xE0, 0x90, 0x00, 0x9F, 0x20, 0x12, 0xB7, + 0x73, 0x45, 0xBB, 0x29, 0xAE, 0xB7, 0xB7, 0xBE, + 0x08, 0x89, 0x9B, 0x3E, 0x0A, 0x28, 0x47, 0x0C, + 0xD0, 0xCF, 0x8D, 0x87, 0x38, 0xB1, 0x15, 0x53, + 0xFE, 0x8A, 0x31, 0x26, 0xD8, 0x4B, 0x34, 0xF1 + }, + { + 0x80, 0x5A, 0xF0, 0x3B, 0xCF, 0x53, 0x67, 0x78, + 0xC7, 0xDB, 0x8E, 0xB1, 0x04, 0xCC, 0xCF, 0x79, + 0x95, 0x8F, 0xA3, 0xCD, 0xFC, 0x4C, 0x1B, 0x3F, + 0xA8, 0x42, 0xE7, 0x26, 0x8A, 0xB4, 0x98, 0xA0, + 0xDE, 0xF1, 0xB0, 0x35, 0xC5, 0xE3, 0xAE, 0x78, + 0x66, 0x4F, 0x3A, 0x22, 0x3A, 0xA4, 0xC6, 0x7B, + 0x89, 0xBB, 0x1E, 0xB6, 0xA7, 0xC2, 0xF2, 0x20, + 0xD7, 0x08, 0xD1, 0xFC, 0x6D, 0x50, 0x10, 0xFE + }, + { + 0x07, 0x3B, 0x96, 0x7B, 0xBC, 0xE2, 0xF2, 0x73, + 0xC4, 0x76, 0xB4, 0xEB, 0x48, 0x88, 0x33, 0xCD, + 0x78, 0x98, 0xBF, 0x65, 0x6A, 0x94, 0x05, 0x8E, + 0xB5, 0x81, 0x68, 0x71, 0xAD, 0x12, 0xEF, 0x11, + 0x75, 0x17, 0x08, 0xD5, 0xA8, 0xDC, 0x1F, 0x23, + 0x55, 0xB8, 0xA1, 0xF1, 0x29, 0x42, 0x23, 0x66, + 0xDC, 0x30, 0x6D, 0xFD, 0x79, 0x77, 0x11, 0xB7, + 0xB6, 0x19, 0x25, 0x8E, 0xF1, 0x84, 0xBE, 0x69 + }, + { + 0x2A, 0x7E, 0xA4, 0x56, 0xF8, 0x5B, 0xEC, 0x9A, + 0xF8, 0xCC, 0xAE, 0x55, 0x55, 0xD7, 0x0D, 0x7B, + 0x5B, 0xFF, 0x9F, 0xB3, 0x63, 0x5E, 0x1F, 0xA9, + 0xFD, 0x48, 0x3A, 0xCD, 0xD3, 0x4D, 0x20, 0xEC, + 0xDA, 0x5B, 0xC4, 0x31, 0xC4, 0x9C, 0x37, 0xBD, + 0x52, 0xC8, 0x83, 0x04, 0x10, 0x83, 0xCC, 0xD5, + 0xB6, 0xA0, 0x95, 0xBC, 0x42, 0xDB, 0xA3, 0xF1, + 0xE2, 0x99, 0xC5, 0x2E, 0xE8, 0x89, 0x3C, 0xCA + }, + { + 0x37, 0xB4, 0x35, 0x62, 0x35, 0x0A, 0xD8, 0x2F, + 0x96, 0x64, 0xC2, 0x00, 0x7F, 0x66, 0x17, 0xC1, + 0x49, 0xA0, 0xCB, 0x4E, 0xE5, 0xDB, 0x94, 0x7C, + 0x53, 0xBF, 0xB0, 0xE8, 0x4A, 0xC0, 0xB1, 0xD4, + 0xE8, 0x0E, 0x29, 0xF0, 0xFF, 0xD3, 0x37, 0x01, + 0x5C, 0xCC, 0x93, 0x24, 0xC3, 0xB8, 0x0B, 0x32, + 0x21, 0x60, 0x54, 0xDA, 0xB3, 0x8B, 0xCB, 0xA7, + 0x73, 0xAA, 0x1D, 0x70, 0x47, 0xE6, 0xEA, 0xEF + }, + { + 0x76, 0x34, 0x08, 0x4F, 0xA4, 0x9A, 0x66, 0x21, + 0x4F, 0xFF, 0xFC, 0xD1, 0x98, 0x15, 0xA5, 0xA9, + 0x56, 0xB5, 0x58, 0xA1, 0xC3, 0x17, 0x62, 0x9C, + 0x29, 0x61, 0x20, 0xF3, 0x7C, 0x88, 0x28, 0x28, + 0xC0, 0x50, 0xFE, 0xB6, 0xC0, 0xFA, 0xCB, 0x7B, + 0x8B, 0xC4, 0x88, 0xB7, 0x2A, 0x16, 0xFC, 0xED, + 0x3A, 0x65, 0x32, 0x84, 0x09, 0x9B, 0x88, 0xAA, + 0x4C, 0x11, 0xC5, 0x62, 0x66, 0xC0, 0x85, 0x49 + }, + { + 0x89, 0x17, 0x84, 0x15, 0x55, 0x44, 0xE3, 0xE6, + 0xD8, 0xC2, 0x5C, 0x29, 0xAE, 0xCE, 0x62, 0x2A, + 0xDD, 0x55, 0x61, 0xFA, 0x36, 0x04, 0x33, 0x70, + 0x02, 0xF2, 0x7D, 0x0E, 0x21, 0x4D, 0xDC, 0x66, + 0x8E, 0xB9, 0xD4, 0xBE, 0x54, 0xD7, 0x99, 0x03, + 0xCA, 0xD2, 0xB6, 0x20, 0x8A, 0x29, 0xB8, 0x20, + 0x78, 0xF6, 0xED, 0xFF, 0xE4, 0x5E, 0x07, 0x4D, + 0x02, 0xAD, 0x22, 0x45, 0xEA, 0xFC, 0x25, 0x5B + }, + { + 0x38, 0x00, 0x9A, 0x55, 0x78, 0x6B, 0xCB, 0xCB, + 0x4B, 0xE4, 0x88, 0x46, 0x08, 0x3C, 0xE4, 0x71, + 0x90, 0xBE, 0x08, 0x1E, 0xFE, 0xE7, 0x65, 0x71, + 0x9E, 0x79, 0xA9, 0xDE, 0xF9, 0x94, 0x28, 0xA5, + 0x71, 0x73, 0x6F, 0x7B, 0x71, 0x17, 0x81, 0x32, + 0x41, 0xAD, 0x27, 0x67, 0xE2, 0xC2, 0xF9, 0x85, + 0xD0, 0xEC, 0xC8, 0x93, 0x00, 0xC9, 0xB2, 0x17, + 0x54, 0xDC, 0x04, 0xA3, 0x22, 0xCF, 0x77, 0x47 + }, + { + 0x2C, 0x39, 0xB7, 0x85, 0x66, 0xB2, 0x95, 0x8A, + 0x72, 0x9E, 0x59, 0xA8, 0xEC, 0xE4, 0xDA, 0x67, + 0x5B, 0xD1, 0x25, 0x59, 0xAC, 0x47, 0x68, 0x4C, + 0xB1, 0x42, 0x97, 0x74, 0x49, 0xE4, 0x40, 0x0B, + 0x0F, 0x2C, 0xE9, 0x9F, 0xFE, 0x0B, 0x21, 0x7D, + 0xFE, 0xAE, 0xE5, 0xE2, 0x0C, 0xC1, 0x73, 0xDB, + 0x3C, 0x82, 0x73, 0x83, 0xB5, 0x3C, 0xEE, 0x6D, + 0x07, 0x5B, 0x6C, 0xE0, 0xF3, 0x83, 0x57, 0x88 + }, + { + 0x8C, 0x98, 0x2A, 0xBF, 0x5E, 0x54, 0xA3, 0xAA, + 0x02, 0xE8, 0x98, 0xE9, 0x6E, 0xD3, 0xEF, 0x65, + 0x03, 0x04, 0xAB, 0x8E, 0x4D, 0xB3, 0x85, 0xD7, + 0xF0, 0x5C, 0xE1, 0x05, 0x8B, 0x97, 0xE6, 0xE5, + 0xA7, 0xF3, 0x34, 0x20, 0x05, 0x95, 0x93, 0x10, + 0xA6, 0xDE, 0xB5, 0x60, 0xF0, 0x1B, 0x9B, 0x6D, + 0x05, 0x7C, 0xEC, 0x2E, 0x1C, 0x7C, 0x6F, 0xD6, + 0x16, 0x3F, 0x6F, 0xA0, 0x71, 0x36, 0xB1, 0x49 + }, + { + 0xCB, 0xDD, 0x78, 0xDC, 0x94, 0x48, 0x40, 0x42, + 0x55, 0x38, 0xBA, 0xE8, 0x52, 0x62, 0x87, 0x78, + 0x7A, 0x81, 0x57, 0x02, 0x90, 0x6D, 0x4C, 0x5A, + 0x67, 0x50, 0x92, 0xD4, 0xAB, 0xD7, 0x8C, 0xA9, + 0xAD, 0x0F, 0xA0, 0x2E, 0x17, 0xBC, 0x82, 0x6B, + 0x03, 0x71, 0xFD, 0xAC, 0xE3, 0xD0, 0xBF, 0x51, + 0xA9, 0x2D, 0xE0, 0x1A, 0x41, 0x6B, 0xA6, 0x6B, + 0x95, 0x79, 0x13, 0xA1, 0xC8, 0x92, 0xC7, 0x78 + }, + { + 0x52, 0x6A, 0x15, 0x28, 0xB5, 0xF7, 0xED, 0x47, + 0x8C, 0xC1, 0xCD, 0x7F, 0x0D, 0x4B, 0x61, 0x98, + 0xB8, 0xA7, 0xF6, 0x65, 0x08, 0x18, 0xE8, 0x72, + 0x14, 0xD3, 0xF3, 0x2D, 0xEA, 0xEB, 0x34, 0x15, + 0x4C, 0x77, 0x04, 0x46, 0xE0, 0xD2, 0xB0, 0xD6, + 0x5B, 0xB1, 0x8F, 0x25, 0xAD, 0x9B, 0x4E, 0xFE, + 0xB1, 0x37, 0xCC, 0xA4, 0xF1, 0x7D, 0xBF, 0x33, + 0x2B, 0x1E, 0x35, 0xDF, 0xB1, 0x92, 0x23, 0x6D + }, + { + 0x47, 0x9E, 0xB1, 0x5B, 0x98, 0xDC, 0xA7, 0x3E, + 0xFA, 0x7D, 0xF9, 0xBE, 0xCF, 0x6A, 0x6D, 0x47, + 0xD4, 0xBE, 0x9F, 0xC4, 0x75, 0x72, 0xD2, 0x48, + 0xD2, 0x17, 0xD8, 0x89, 0x9D, 0x5F, 0xDB, 0x31, + 0x58, 0xD6, 0xAE, 0x8C, 0x75, 0x00, 0x9C, 0xC0, + 0x78, 0xF7, 0x7D, 0x41, 0x53, 0x61, 0xAD, 0x16, + 0xD1, 0x42, 0x6C, 0x34, 0x76, 0xCE, 0x6F, 0xC7, + 0x55, 0x29, 0x2E, 0x20, 0x9A, 0x17, 0x46, 0xF3 + }, + { + 0x31, 0xA7, 0xE6, 0x41, 0x2F, 0x40, 0xA4, 0x03, + 0xB7, 0xDE, 0xFA, 0x5D, 0x34, 0xCB, 0xD0, 0xDC, + 0xAB, 0xB7, 0x33, 0x98, 0x22, 0x3A, 0xD2, 0x95, + 0x2A, 0xB1, 0x6F, 0xD5, 0xA8, 0x42, 0x4B, 0xED, + 0xD4, 0x91, 0x6E, 0xE6, 0xD0, 0x2F, 0xAB, 0x5A, + 0x61, 0x9D, 0xA7, 0xEE, 0xF6, 0x2A, 0xAF, 0x69, + 0xFA, 0x80, 0xBF, 0x01, 0x87, 0x51, 0x93, 0x16, + 0x78, 0x40, 0xBC, 0x46, 0xB7, 0x33, 0x1B, 0x9E + }, + { + 0x3F, 0x27, 0xDF, 0xF0, 0x57, 0xC8, 0xD7, 0xB6, + 0x04, 0x91, 0x6B, 0x12, 0xC9, 0xB3, 0xEB, 0xD6, + 0x30, 0x12, 0x3A, 0x35, 0x60, 0x65, 0xB3, 0x52, + 0x8D, 0x81, 0x80, 0x98, 0x25, 0xE0, 0x11, 0x14, + 0x87, 0x72, 0x37, 0xFB, 0xE2, 0xE7, 0x20, 0x8F, + 0x34, 0xB2, 0x5D, 0xC1, 0xD7, 0xEE, 0x0A, 0xCE, + 0xA3, 0x76, 0xE7, 0xE4, 0xE4, 0xE5, 0x38, 0x65, + 0x65, 0x62, 0x2B, 0x3A, 0x3F, 0xEF, 0xA0, 0x47 + }, + { + 0x37, 0x02, 0x14, 0x02, 0x9A, 0x72, 0xD5, 0x2F, + 0x97, 0x2C, 0x77, 0x98, 0x0C, 0xFE, 0x9D, 0x02, + 0x25, 0x64, 0x9B, 0xA2, 0x23, 0xBB, 0x7D, 0x12, + 0x91, 0x8A, 0xFC, 0x67, 0x5F, 0xB2, 0xFD, 0x98, + 0x5A, 0xFF, 0x8C, 0x26, 0x84, 0xE9, 0x33, 0x51, + 0x4B, 0x75, 0x17, 0xAE, 0x40, 0x18, 0x5E, 0xF4, + 0x52, 0x95, 0xDE, 0x97, 0x52, 0x94, 0x80, 0x7B, + 0xAD, 0xB8, 0x64, 0xD7, 0xF8, 0x8D, 0x2E, 0x0D + }, + { + 0xA5, 0x0E, 0x2A, 0xAF, 0x9B, 0x6A, 0xAF, 0x6F, + 0xFA, 0xE2, 0x1D, 0xE0, 0xE4, 0x7D, 0xC7, 0xA1, + 0x84, 0x0E, 0xEF, 0x4F, 0xAB, 0xDA, 0x2E, 0xEE, + 0xDB, 0x29, 0x72, 0xC7, 0xCE, 0xE6, 0xC2, 0x65, + 0x4D, 0x2D, 0xF2, 0xFD, 0x04, 0xEB, 0x37, 0x38, + 0x67, 0x75, 0x42, 0x55, 0x01, 0x8D, 0xD0, 0xD2, + 0x01, 0x97, 0x08, 0x56, 0x82, 0x26, 0x1B, 0xB7, + 0x9A, 0xF5, 0x69, 0x8E, 0x20, 0x9D, 0x50, 0x3E + }, + { + 0xCA, 0x7E, 0x85, 0x2C, 0x63, 0xF9, 0x6C, 0x2D, + 0xE8, 0xCE, 0xEC, 0x75, 0x56, 0xFD, 0x3A, 0x5A, + 0xBE, 0xE7, 0xCC, 0xEC, 0x28, 0x04, 0xFF, 0x7C, + 0xDA, 0x5A, 0xBE, 0x92, 0x5E, 0x95, 0xCC, 0x8A, + 0x15, 0x17, 0xD5, 0xB7, 0xD7, 0x02, 0x27, 0xB2, + 0x55, 0xAA, 0xD8, 0xA1, 0xCC, 0xD0, 0x01, 0x28, + 0x7A, 0xCD, 0xCF, 0xFE, 0xE6, 0x6C, 0xA9, 0x19, + 0xE3, 0xC9, 0x9E, 0x08, 0x08, 0xBF, 0xB7, 0x1E + }, + { + 0xCB, 0x8E, 0xBC, 0xBE, 0x16, 0x44, 0x59, 0xFA, + 0x52, 0x0A, 0x76, 0x0B, 0xE2, 0xA8, 0x79, 0x80, + 0x59, 0xB9, 0xDC, 0xA4, 0x9C, 0x69, 0x8D, 0x01, + 0x29, 0x12, 0xC2, 0x6A, 0x35, 0x1A, 0xE1, 0xCB, + 0xDD, 0x2F, 0x94, 0xEC, 0xFC, 0x9B, 0xAC, 0x79, + 0x3F, 0xF2, 0xE4, 0xDC, 0x79, 0x23, 0xF4, 0xE4, + 0x12, 0x2B, 0x72, 0x79, 0xAE, 0xB5, 0x48, 0x3E, + 0xE9, 0x48, 0xB1, 0xE4, 0x57, 0x67, 0x5D, 0x6D + }, + { + 0xE8, 0xFC, 0xF4, 0xFA, 0xD2, 0x6D, 0x74, 0x14, + 0xDB, 0xB1, 0xE8, 0xC3, 0xD6, 0xAC, 0x49, 0x26, + 0x4E, 0xAB, 0x5D, 0xC8, 0xDE, 0x37, 0x8A, 0x46, + 0x47, 0x65, 0x83, 0xF2, 0x89, 0xAE, 0x23, 0x13, + 0x92, 0x2E, 0xBA, 0xDE, 0xD7, 0x28, 0xC2, 0x0A, + 0xF9, 0x95, 0xAE, 0x18, 0x83, 0x23, 0x41, 0x0D, + 0x73, 0x41, 0xE7, 0x90, 0x61, 0x63, 0x11, 0x12, + 0xCA, 0xF0, 0x02, 0x2E, 0x2D, 0xBF, 0x45, 0xD8 + }, + { + 0xF5, 0x33, 0x76, 0x05, 0xDD, 0x30, 0x36, 0x39, + 0xCB, 0xC8, 0x3B, 0x1A, 0xF9, 0x85, 0xF1, 0x59, + 0xE0, 0x04, 0xA3, 0xCB, 0x5A, 0x9C, 0xE6, 0x6C, + 0xBA, 0x4F, 0x2B, 0xE3, 0x0B, 0x8B, 0x02, 0x87, + 0x03, 0x93, 0x40, 0xCF, 0x38, 0x1A, 0x1A, 0x99, + 0x06, 0xE1, 0xAD, 0xEF, 0x5A, 0x38, 0xAA, 0x98, + 0x51, 0x1F, 0x19, 0x18, 0xD3, 0x4B, 0x8C, 0x75, + 0x2D, 0xA5, 0x8F, 0xD8, 0x79, 0xD6, 0xD5, 0xB0 + }, + { + 0x13, 0x71, 0xA9, 0xD7, 0x75, 0x81, 0x14, 0x39, + 0x1A, 0xC6, 0x7A, 0xA8, 0x48, 0x46, 0xB1, 0xF8, + 0x38, 0x5D, 0x19, 0xA9, 0x83, 0x8E, 0xDF, 0x45, + 0x48, 0xC5, 0x99, 0x13, 0x00, 0x7B, 0x6D, 0x5A, + 0x80, 0xDB, 0xEA, 0x63, 0x72, 0xC1, 0xD2, 0xC4, + 0x8E, 0x2F, 0xD2, 0x7D, 0xD4, 0x60, 0xEE, 0x22, + 0x29, 0x2C, 0xD7, 0xF0, 0x14, 0x2F, 0x6E, 0xE8, + 0xAE, 0xDB, 0xA2, 0x40, 0xCA, 0x2F, 0xD6, 0x4A + }, + { + 0x7B, 0x61, 0xE4, 0xB8, 0xD3, 0xE3, 0x5A, 0x91, + 0x87, 0x9F, 0x64, 0xD7, 0xB5, 0xB1, 0x5A, 0x39, + 0xDD, 0xBA, 0x8F, 0xFC, 0x97, 0xF0, 0xBB, 0x1F, + 0xC0, 0xD2, 0x0E, 0xD5, 0x96, 0x1B, 0xCC, 0x9F, + 0xF6, 0xB0, 0xD4, 0xE6, 0x4D, 0xE9, 0xCA, 0x0C, + 0xD8, 0x6A, 0x8E, 0x50, 0x35, 0xB3, 0x45, 0xEC, + 0x40, 0x46, 0x40, 0x33, 0x67, 0x7A, 0x3C, 0x89, + 0x76, 0xBB, 0x0A, 0x04, 0xCA, 0xCB, 0xBC, 0x5A + }, + { + 0xF2, 0x21, 0x64, 0x32, 0x25, 0xEE, 0xD3, 0xBB, + 0xEE, 0x9D, 0x6A, 0xBA, 0xFF, 0x26, 0x8D, 0xD9, + 0x0F, 0xD2, 0x0F, 0x46, 0xFF, 0xA5, 0xB3, 0x24, + 0x36, 0x65, 0xFE, 0xCF, 0x13, 0x8F, 0x92, 0xA6, + 0xA6, 0x55, 0x89, 0xD7, 0x7D, 0x22, 0x23, 0x9C, + 0xDC, 0xBD, 0x55, 0x8B, 0xDB, 0xB4, 0xAD, 0x19, + 0xDC, 0xB6, 0x83, 0x95, 0xC6, 0x5F, 0xAD, 0xF3, + 0x18, 0x8A, 0x4B, 0x0D, 0x95, 0x13, 0x5D, 0xBB + }, + { + 0x65, 0xD7, 0x28, 0x30, 0x26, 0x61, 0x93, 0xC9, + 0x01, 0xFF, 0xF9, 0x2C, 0x25, 0xE7, 0x02, 0xB1, + 0x5D, 0x2A, 0x96, 0xE7, 0xFF, 0xD2, 0x20, 0x33, + 0x5A, 0x69, 0x69, 0x34, 0x5D, 0x8F, 0x09, 0x8A, + 0x6D, 0xBA, 0xFF, 0x82, 0x72, 0x31, 0x11, 0xA7, + 0x7B, 0x51, 0xB8, 0xE0, 0x46, 0xB9, 0xC6, 0x5D, + 0x87, 0x99, 0x8C, 0xBF, 0xD2, 0x49, 0x8E, 0xE9, + 0x5F, 0x3E, 0x9E, 0x4B, 0x1D, 0x27, 0xC2, 0x15 + }, + { + 0xCE, 0x77, 0x0F, 0xD5, 0xFE, 0xA3, 0xB0, 0x1D, + 0x7E, 0x6E, 0x2C, 0xB4, 0x73, 0x7D, 0x93, 0x83, + 0xD9, 0xBD, 0x00, 0x7A, 0x2D, 0x85, 0x9D, 0x1C, + 0x31, 0x51, 0x2B, 0x27, 0xAD, 0x58, 0x04, 0x29, + 0x60, 0xEB, 0xE0, 0x73, 0x6A, 0xA8, 0x52, 0x35, + 0xF0, 0x9A, 0xB9, 0x1A, 0x61, 0x63, 0xF0, 0xE2, + 0x29, 0x0F, 0xC8, 0xE1, 0xD1, 0xB1, 0xA1, 0x33, + 0x3E, 0xA4, 0x9C, 0x8A, 0x01, 0x2F, 0x6D, 0x02 + }, + { + 0xB7, 0x54, 0xC3, 0xD9, 0xC5, 0xD3, 0x22, 0x72, + 0xBC, 0x31, 0x33, 0x0C, 0xDC, 0xC2, 0x13, 0x83, + 0x17, 0x4A, 0xEB, 0x70, 0x4F, 0xFE, 0xA2, 0x80, + 0x69, 0x18, 0xBD, 0xEE, 0xE0, 0x80, 0xF6, 0x5E, + 0x18, 0x59, 0x71, 0xCF, 0x3B, 0x46, 0xE6, 0x50, + 0xE1, 0x8D, 0xF8, 0x13, 0x17, 0xBC, 0x22, 0x30, + 0xD2, 0xFE, 0xF0, 0xED, 0x08, 0xA7, 0x34, 0x38, + 0x09, 0x77, 0x20, 0xB6, 0x5C, 0xB1, 0x72, 0xA2 + }, + { + 0xB7, 0x8E, 0x81, 0xA7, 0x9D, 0x54, 0x83, 0xC6, + 0xF6, 0x78, 0x61, 0x33, 0x6F, 0xC5, 0x71, 0x30, + 0xCD, 0x1A, 0x9E, 0xD2, 0xED, 0x9E, 0xED, 0xA8, + 0x03, 0xBC, 0x5C, 0x4D, 0xFC, 0x9F, 0xA0, 0x19, + 0x42, 0xF6, 0xA4, 0xD2, 0x88, 0x80, 0x76, 0xAC, + 0x80, 0x4F, 0xE7, 0xF7, 0x0F, 0xD7, 0xD8, 0xCD, + 0xC3, 0xD9, 0x2C, 0xCD, 0x81, 0xFD, 0xFD, 0xED, + 0x09, 0x83, 0xA0, 0xE5, 0x3D, 0x7F, 0xD6, 0xC4 + }, + { + 0x72, 0x05, 0x9B, 0x1C, 0x65, 0x3A, 0xFE, 0x86, + 0x00, 0x18, 0xDF, 0x29, 0x1E, 0x5F, 0x98, 0x58, + 0x0D, 0x50, 0x47, 0x18, 0xE4, 0x8A, 0x5C, 0x33, + 0x5E, 0x41, 0x6E, 0xF8, 0xB8, 0x60, 0x48, 0x4C, + 0x0E, 0x08, 0x42, 0x53, 0x75, 0x24, 0xF8, 0xD9, + 0x25, 0x34, 0x63, 0x26, 0x5D, 0xE0, 0xE7, 0xC3, + 0x8E, 0xD9, 0x3A, 0xB4, 0x7F, 0xCC, 0x07, 0x29, + 0x9A, 0x8C, 0x86, 0x21, 0x4A, 0xE6, 0x43, 0xC8 + }, + { + 0xD8, 0x08, 0x25, 0x1D, 0xD2, 0x0C, 0x8A, 0xA3, + 0x0D, 0x0C, 0xC3, 0x08, 0x1C, 0xCF, 0x1A, 0xB0, + 0xA5, 0xA6, 0xF7, 0xD3, 0x75, 0xBD, 0x9B, 0x13, + 0x17, 0x1C, 0x10, 0x00, 0x71, 0x87, 0x28, 0x2D, + 0x78, 0x56, 0x63, 0x48, 0x68, 0x4B, 0xA3, 0xB2, + 0xF6, 0x68, 0x91, 0x74, 0x3E, 0xEB, 0x17, 0x5C, + 0x37, 0x58, 0xB1, 0xE0, 0xFC, 0xB5, 0xD1, 0x13, + 0xB0, 0x64, 0xAD, 0x6D, 0x48, 0x98, 0x74, 0xB8 + }, + { + 0x95, 0xB2, 0xCD, 0x60, 0xE2, 0x6E, 0xFB, 0xFC, + 0xBB, 0x80, 0x4C, 0xF7, 0xE0, 0x7A, 0xD1, 0x2F, + 0xF5, 0x61, 0x03, 0x2A, 0x06, 0xCF, 0xF2, 0xD9, + 0xFC, 0x6A, 0x19, 0xC2, 0x42, 0xFD, 0x2B, 0x9F, + 0x53, 0x2F, 0x0F, 0x19, 0x07, 0xBF, 0x0B, 0x3C, + 0x03, 0x20, 0xE1, 0xF4, 0x07, 0x22, 0xDF, 0x5E, + 0x9C, 0x81, 0xF2, 0xEF, 0x5A, 0x1B, 0x57, 0xB3, + 0x9D, 0x2F, 0x0C, 0x5A, 0xD4, 0xDF, 0x0F, 0xEF + }, + { + 0x4E, 0x29, 0xC0, 0x6B, 0x3A, 0x25, 0x5C, 0xC8, + 0x04, 0x57, 0xB7, 0x0F, 0x7F, 0x6F, 0xD2, 0x40, + 0x80, 0x27, 0x82, 0x56, 0x3E, 0x68, 0x30, 0xD1, + 0x47, 0xA6, 0xCC, 0x48, 0xC8, 0x7D, 0x10, 0x1B, + 0x32, 0x92, 0x5D, 0xE0, 0xF2, 0x2E, 0x04, 0xDE, + 0x83, 0x49, 0xF6, 0x2C, 0xB0, 0x6E, 0x94, 0x73, + 0x0E, 0x04, 0x0A, 0x5C, 0xF8, 0x9F, 0x1F, 0x14, + 0xA7, 0x61, 0x6E, 0x80, 0x23, 0xD9, 0xF5, 0xB6 + }, + { + 0x7F, 0xF4, 0x2D, 0xD4, 0x56, 0xD4, 0x5C, 0x9B, + 0x23, 0xE2, 0xB5, 0xC8, 0xDD, 0x84, 0xCF, 0x83, + 0x17, 0xC0, 0x10, 0xCE, 0x59, 0x9A, 0xD6, 0x34, + 0x67, 0xEE, 0x5F, 0x3B, 0xB9, 0x2A, 0x8A, 0x64, + 0xA1, 0x42, 0xD5, 0xEA, 0xE6, 0x8E, 0xFC, 0x7A, + 0x64, 0xB1, 0xE2, 0xB1, 0x70, 0x29, 0x05, 0x89, + 0x19, 0x06, 0x71, 0x40, 0xD2, 0x3B, 0xD6, 0x6C, + 0x03, 0x26, 0x7C, 0x8C, 0xA7, 0xB2, 0x2B, 0x73 + }, + { + 0x00, 0x11, 0x1C, 0x1C, 0x1C, 0x88, 0x7F, 0xB7, + 0x8B, 0x82, 0x63, 0x72, 0x27, 0x33, 0x55, 0xB1, + 0x49, 0xD5, 0x9F, 0xF1, 0xA0, 0x69, 0xDF, 0xCA, + 0x36, 0x39, 0xC9, 0x17, 0x42, 0x72, 0xE5, 0x68, + 0xB3, 0xF8, 0x5C, 0xF2, 0xB7, 0x34, 0x10, 0xB8, + 0x3C, 0x6D, 0xEB, 0xAD, 0x7F, 0x53, 0x68, 0xB0, + 0x82, 0xAF, 0xAA, 0x9A, 0x5A, 0xA6, 0xED, 0x8D, + 0xBA, 0x9B, 0x1B, 0xF9, 0x21, 0xD9, 0xC0, 0xF1 + }, + { + 0x97, 0x11, 0x18, 0x96, 0x5E, 0x9A, 0xEE, 0x09, + 0x5C, 0x92, 0xC4, 0xF4, 0x15, 0x05, 0x6B, 0xB2, + 0xBA, 0xA8, 0x4F, 0xB5, 0xE6, 0xA1, 0xBD, 0x49, + 0xB8, 0x0C, 0x97, 0x54, 0x87, 0x83, 0x88, 0xCD, + 0x9D, 0xE4, 0x62, 0xC0, 0x7D, 0x17, 0x6C, 0x95, + 0xFD, 0x7D, 0xF0, 0x85, 0x34, 0x81, 0x07, 0x78, + 0xE2, 0x69, 0x5E, 0x0D, 0x90, 0x4F, 0x1C, 0x91, + 0x71, 0x5D, 0x59, 0x5E, 0x2E, 0xCC, 0x90, 0xEC + }, + { + 0xBF, 0x12, 0x21, 0xCE, 0xFD, 0xC2, 0x73, 0x5A, + 0xEF, 0xCD, 0x77, 0xA2, 0x67, 0x6A, 0x05, 0x29, + 0x90, 0x50, 0xE5, 0xBA, 0x04, 0xCF, 0xCD, 0x7D, + 0xA5, 0xDF, 0xD2, 0x0D, 0x89, 0xEC, 0x7A, 0xEE, + 0xCE, 0x6A, 0x34, 0x6E, 0x06, 0x7B, 0xF4, 0x17, + 0xF8, 0x16, 0xDA, 0xCF, 0xB2, 0xF2, 0x7B, 0xE7, + 0x94, 0x01, 0xC5, 0xFF, 0x0F, 0x4A, 0xB4, 0x9A, + 0x50, 0x3C, 0xA3, 0xEE, 0xA8, 0x9A, 0x26, 0x46 + }, + { + 0x7C, 0xCB, 0x57, 0xC1, 0xF0, 0xB6, 0x30, 0xAC, + 0x6A, 0x67, 0x79, 0xF2, 0xBD, 0x95, 0x96, 0x6D, + 0x42, 0x43, 0x0F, 0xB6, 0xC1, 0x21, 0xEF, 0x99, + 0x0B, 0xEE, 0x5A, 0x48, 0xFB, 0x51, 0x7E, 0x3E, + 0x19, 0x9B, 0x46, 0xA3, 0x77, 0xAC, 0x74, 0xE4, + 0xD9, 0x83, 0x34, 0xAD, 0x07, 0xA6, 0x7A, 0x6E, + 0xAD, 0x33, 0x53, 0x7B, 0xE7, 0x59, 0x35, 0x39, + 0x1F, 0xE5, 0xE1, 0x69, 0x67, 0x13, 0xBD, 0x90 + }, + { + 0x5E, 0xF3, 0xDA, 0x7B, 0x12, 0xF2, 0x4F, 0x0A, + 0x79, 0x25, 0x97, 0x10, 0x26, 0xA8, 0x3E, 0x1C, + 0x1D, 0x0A, 0x59, 0xC9, 0x5C, 0x94, 0xBB, 0xD4, + 0x4E, 0xEE, 0x9E, 0xF1, 0x2D, 0xCD, 0x75, 0x25, + 0x45, 0xFA, 0x79, 0x33, 0xDF, 0x9E, 0x06, 0x6C, + 0xBC, 0x94, 0x3C, 0xCA, 0xB9, 0x97, 0xEC, 0x1C, + 0x33, 0x44, 0x94, 0xC8, 0x9D, 0xC0, 0x74, 0x1B, + 0x1F, 0x1B, 0xB1, 0x9A, 0x5A, 0x35, 0xA0, 0xFC + }, + { + 0x86, 0x16, 0x7A, 0xB6, 0x1E, 0x3A, 0xA7, 0x22, + 0xBD, 0x47, 0x0A, 0x38, 0x1E, 0x3D, 0x87, 0x13, + 0xC8, 0x82, 0xD0, 0xCA, 0xFB, 0x56, 0x2E, 0x71, + 0x59, 0xB5, 0x09, 0xD3, 0xE3, 0xD3, 0x80, 0x6B, + 0xE8, 0xD3, 0x9A, 0x42, 0xF4, 0xA4, 0x9E, 0xF0, + 0xCE, 0x43, 0x64, 0x0B, 0xD7, 0x8C, 0x89, 0xCF, + 0x43, 0xB3, 0x7A, 0x6B, 0xCC, 0xF3, 0x6B, 0x5A, + 0xE2, 0xAE, 0xFC, 0x32, 0xB0, 0x4A, 0xDB, 0xCE + }, + { + 0x5E, 0xA5, 0xBA, 0x8D, 0xDB, 0x5F, 0xC7, 0xA7, + 0x81, 0x12, 0xA0, 0x7F, 0x7B, 0x97, 0x4E, 0x70, + 0xB7, 0x87, 0x21, 0x33, 0xD7, 0x5C, 0x6D, 0x26, + 0x64, 0xDF, 0x9D, 0x3F, 0x36, 0x74, 0x24, 0x48, + 0x44, 0x9C, 0x29, 0xA4, 0xC7, 0xF3, 0x00, 0x26, + 0xB1, 0x5C, 0xEA, 0x8D, 0xBD, 0x93, 0x1F, 0x30, + 0xA7, 0x62, 0xF4, 0x69, 0x21, 0x0F, 0xF5, 0x67, + 0xDF, 0x16, 0x7F, 0xA5, 0x2F, 0xDE, 0x8B, 0x20 + }, + { + 0x7A, 0x59, 0x23, 0x81, 0xCE, 0x75, 0x47, 0xE5, + 0xE1, 0x7C, 0x87, 0xF0, 0x45, 0x55, 0x32, 0x2D, + 0x73, 0x43, 0xB7, 0xDD, 0x1F, 0x9C, 0xCA, 0x90, + 0xAD, 0x8F, 0x71, 0x38, 0xA0, 0x9E, 0x1E, 0x2E, + 0xA6, 0xF4, 0xB6, 0x33, 0x66, 0x3C, 0x0F, 0x66, + 0x64, 0xC2, 0x29, 0x9F, 0xAC, 0x42, 0x01, 0x66, + 0xD3, 0x40, 0xC9, 0xDD, 0xCF, 0x95, 0xF7, 0xB3, + 0x15, 0x28, 0xE4, 0x25, 0x34, 0xD5, 0x5D, 0xCB + }, + { + 0xB7, 0x92, 0x3D, 0x14, 0xF6, 0x73, 0x84, 0x0F, + 0xF5, 0x7C, 0x04, 0x25, 0xB1, 0x77, 0x83, 0x55, + 0xFC, 0x95, 0xDD, 0x6A, 0x1A, 0xC7, 0xAB, 0xF2, + 0xFF, 0x82, 0x6F, 0x4C, 0xB8, 0x56, 0x67, 0xB0, + 0x25, 0x4D, 0x4A, 0x51, 0xAD, 0x70, 0xDE, 0x2A, + 0x97, 0x19, 0x68, 0x89, 0xF8, 0x0A, 0x77, 0xB5, + 0x9C, 0xF2, 0x4E, 0x7C, 0x23, 0x6C, 0x53, 0x53, + 0x96, 0xFD, 0xF3, 0x1F, 0xB9, 0x41, 0xA1, 0xDD + }, + { + 0x9A, 0x92, 0xB2, 0x4C, 0x26, 0xD5, 0x2B, 0x81, + 0x7E, 0x2B, 0x69, 0x82, 0xEF, 0x9F, 0x2A, 0x3A, + 0x57, 0xED, 0x3F, 0xD2, 0xC0, 0x6A, 0x0A, 0xFF, + 0xC8, 0x66, 0x7B, 0x54, 0x48, 0x75, 0x5B, 0x39, + 0xCE, 0x7D, 0xC3, 0x68, 0xF4, 0x5F, 0x30, 0x9C, + 0x08, 0xB6, 0x6C, 0xF8, 0xE1, 0x27, 0x37, 0x94, + 0x11, 0x8C, 0xFC, 0xF7, 0x83, 0x33, 0x7B, 0x58, + 0xF6, 0x1C, 0x73, 0x19, 0x59, 0x8D, 0x61, 0xF1 + }, + { + 0xE4, 0x6F, 0x92, 0x46, 0xD4, 0x78, 0x91, 0x43, + 0xAE, 0x7D, 0xE6, 0x95, 0x5D, 0xC4, 0x03, 0xF6, + 0x6B, 0x52, 0xF3, 0x11, 0xE9, 0xE9, 0xBA, 0xE3, + 0xC1, 0x8E, 0x10, 0x88, 0xFF, 0x08, 0xB9, 0x43, + 0x8D, 0x4C, 0xDA, 0x2B, 0xA8, 0x70, 0xDB, 0x8B, + 0xA6, 0x2C, 0x02, 0xF9, 0x78, 0x63, 0x9F, 0x36, + 0xEE, 0x7C, 0x60, 0x5C, 0xF2, 0xB1, 0x07, 0xAF, + 0xCC, 0xC3, 0x22, 0x8E, 0x45, 0x32, 0xFC, 0x11 + }, + { + 0xDC, 0x7B, 0x1D, 0x4F, 0xCC, 0x95, 0x9B, 0x79, + 0xB7, 0xDB, 0x77, 0xA6, 0x66, 0xDF, 0xC5, 0x44, + 0x91, 0xAC, 0xA0, 0x9D, 0x70, 0xBE, 0x0E, 0x26, + 0xE1, 0xE4, 0xCD, 0x3A, 0xFE, 0xBE, 0x87, 0x25, + 0x48, 0xBA, 0x22, 0x8E, 0x54, 0x2D, 0x8F, 0x67, + 0xFB, 0x85, 0x52, 0x70, 0xC3, 0x4F, 0xF2, 0xEA, + 0x44, 0xCC, 0x98, 0xBF, 0x3B, 0x68, 0x35, 0xC7, + 0xDC, 0x60, 0xA5, 0x2B, 0x06, 0x13, 0x2B, 0x09 + }, + { + 0x1A, 0x5E, 0xA7, 0xC4, 0x69, 0x62, 0x83, 0x47, + 0xB7, 0x95, 0x60, 0x03, 0x98, 0x29, 0x29, 0x72, + 0x86, 0xEB, 0x24, 0x58, 0xFC, 0xBF, 0x1F, 0x25, + 0xCC, 0xC4, 0x67, 0xFE, 0xFB, 0x27, 0x4D, 0xCB, + 0xE9, 0xAB, 0xC3, 0x88, 0xF1, 0x6C, 0x80, 0xF6, + 0xDB, 0x4A, 0x87, 0xB2, 0x65, 0xF3, 0xC8, 0xF3, + 0xF2, 0x6C, 0x30, 0xB4, 0xD5, 0xE2, 0x72, 0xAF, + 0x0F, 0x55, 0x6D, 0x54, 0x8A, 0xDD, 0xF5, 0x1F + }, + { + 0xE8, 0x89, 0x90, 0xFE, 0x9E, 0x39, 0x9B, 0xEA, + 0xF2, 0xE5, 0xFB, 0xA1, 0xD3, 0x27, 0x48, 0x36, + 0x83, 0x04, 0x26, 0x35, 0xF2, 0x27, 0xDB, 0x73, + 0x93, 0x06, 0xEF, 0x5E, 0x7A, 0x9C, 0x49, 0x07, + 0x0B, 0xE3, 0xD2, 0xF5, 0xDF, 0xE2, 0x38, 0x39, + 0xB9, 0x40, 0x5C, 0xED, 0xB3, 0x7F, 0x4B, 0xAB, + 0x06, 0x73, 0x71, 0x1F, 0x24, 0x3C, 0x66, 0x21, + 0x14, 0x1B, 0x9E, 0x16, 0xED, 0x64, 0xD2, 0x1A + }, + { + 0x84, 0xC6, 0x46, 0xC4, 0x6A, 0x61, 0x71, 0x37, + 0x37, 0x75, 0x48, 0x6F, 0x79, 0x5E, 0xD6, 0x23, + 0x73, 0x3F, 0xCD, 0x6E, 0xC6, 0x16, 0xAB, 0x5D, + 0xFC, 0x68, 0x32, 0x83, 0x2A, 0x7B, 0x9C, 0x3E, + 0xB0, 0x8B, 0x80, 0xCD, 0x54, 0x4A, 0xDB, 0x49, + 0x6F, 0x7C, 0x35, 0xA9, 0x08, 0x6C, 0x01, 0x99, + 0x75, 0x77, 0x14, 0x25, 0xA9, 0xB3, 0x84, 0x36, + 0xF4, 0xE1, 0xD5, 0xEF, 0xCF, 0x11, 0x49, 0xB1 + }, + { + 0x9A, 0xE2, 0xBE, 0x74, 0xFB, 0x73, 0x78, 0x82, + 0x07, 0x67, 0x91, 0xF9, 0x4E, 0xFA, 0x73, 0x17, + 0x33, 0x7F, 0xEC, 0x14, 0xDE, 0xE9, 0xE1, 0x4D, + 0x32, 0x90, 0x3D, 0x2D, 0xEA, 0x3A, 0x9C, 0xA2, + 0x85, 0x9E, 0x4B, 0xB1, 0x1B, 0x38, 0x9D, 0x5A, + 0x57, 0x64, 0x47, 0x1C, 0xD7, 0x74, 0xA2, 0xB7, + 0xCD, 0x1D, 0x01, 0xAE, 0x5B, 0x4A, 0xC8, 0xCD, + 0xDE, 0x4B, 0x59, 0x85, 0xC7, 0xA4, 0x81, 0xB8 + }, + { + 0x94, 0x42, 0x70, 0x7A, 0x7B, 0xE7, 0x19, 0x4A, + 0x6A, 0x65, 0x98, 0xFD, 0x6F, 0x2E, 0xFE, 0x72, + 0x38, 0xCE, 0xE1, 0x70, 0xCB, 0xC2, 0x20, 0xCB, + 0xA0, 0x1E, 0xD2, 0x43, 0xAF, 0x84, 0xC4, 0x9B, + 0xCC, 0x37, 0x33, 0xC2, 0xF3, 0xA7, 0xDC, 0x15, + 0x98, 0x6B, 0xF0, 0x26, 0x84, 0xD1, 0xB5, 0x55, + 0x06, 0xF5, 0x99, 0x10, 0x08, 0x70, 0xCF, 0x9C, + 0x83, 0xEA, 0xC5, 0x88, 0x3E, 0x27, 0x7D, 0xCE + }, + { + 0x77, 0xB9, 0x01, 0xDC, 0x69, 0x06, 0xE9, 0x5E, + 0x1A, 0xC9, 0x61, 0xC3, 0xCC, 0x92, 0x18, 0x42, + 0x9A, 0xA3, 0xB6, 0xFC, 0x6D, 0xB7, 0x8D, 0x30, + 0x29, 0x38, 0xB6, 0xE6, 0x31, 0xE6, 0x6C, 0xD3, + 0xD9, 0xEE, 0xB6, 0x66, 0xA0, 0x77, 0x33, 0x2E, + 0x19, 0x0A, 0xF4, 0x2B, 0x4C, 0x80, 0x9F, 0xA1, + 0x09, 0x5E, 0x02, 0x13, 0x6D, 0x49, 0x39, 0x86, + 0xC0, 0x51, 0xD6, 0x73, 0x2C, 0x6F, 0x2A, 0x75 + }, + { + 0x14, 0x5B, 0xA9, 0x4C, 0xA3, 0x66, 0x87, 0xC1, + 0x5E, 0xE4, 0x30, 0xB5, 0xCC, 0x78, 0xB7, 0xBA, + 0x9B, 0x8F, 0x8D, 0x76, 0x83, 0x8C, 0xB7, 0xCD, + 0xCB, 0x3A, 0xCE, 0x0A, 0x54, 0xBB, 0xA6, 0xEF, + 0xBE, 0xD8, 0x92, 0x95, 0xA0, 0xDF, 0xC8, 0xC1, + 0x58, 0x04, 0xB2, 0xB2, 0xFE, 0x8B, 0xF8, 0x66, + 0xEF, 0x29, 0x9C, 0x91, 0x70, 0x71, 0xF3, 0x01, + 0x30, 0x6C, 0x37, 0xB8, 0x14, 0xCD, 0x79, 0x26 + }, + { + 0xFA, 0x0D, 0x97, 0xBD, 0xCF, 0x10, 0x43, 0x75, + 0x7F, 0xC4, 0xB7, 0x26, 0x55, 0x9B, 0x0C, 0x33, + 0x47, 0x4B, 0xFE, 0xA6, 0x08, 0x60, 0x1D, 0x45, + 0x39, 0x6F, 0x68, 0xDB, 0x0E, 0xEF, 0x16, 0x19, + 0x2B, 0xDB, 0x9A, 0x3C, 0x5D, 0xAB, 0x74, 0x60, + 0xAB, 0xC3, 0xBF, 0xAF, 0xFA, 0x39, 0xA4, 0x35, + 0xD2, 0xA5, 0xD0, 0xC1, 0xC8, 0x5C, 0xFF, 0xA7, + 0x11, 0x5C, 0xC8, 0x2E, 0x59, 0xB8, 0x3D, 0xFA + }, + { + 0x38, 0x1A, 0x02, 0xCB, 0x70, 0xD3, 0x9F, 0x12, + 0xC8, 0x26, 0xBB, 0x9D, 0x91, 0xF8, 0x58, 0x3A, + 0x0F, 0x75, 0xD8, 0x63, 0x44, 0x82, 0xDE, 0x5A, + 0xD2, 0x52, 0x64, 0x22, 0x03, 0xFB, 0x73, 0x8B, + 0xA1, 0x0F, 0x49, 0xEF, 0x9B, 0xFA, 0xCF, 0xB8, + 0xF6, 0xFD, 0xAA, 0x95, 0x8E, 0x12, 0xD7, 0x33, + 0xB6, 0x40, 0x24, 0xFD, 0xDA, 0x32, 0xC1, 0xEC, + 0x38, 0x5C, 0x1F, 0x9F, 0xAC, 0x42, 0x5B, 0xEB + }, + { + 0x12, 0x54, 0x2D, 0x46, 0x67, 0x73, 0xE7, 0x02, + 0xAD, 0xD9, 0x3A, 0xF5, 0xB7, 0x81, 0x0E, 0xF5, + 0x30, 0xE5, 0x0A, 0xE4, 0xC4, 0x71, 0xDF, 0xE4, + 0xE1, 0xA1, 0x2F, 0xD7, 0xA7, 0x91, 0x0B, 0xBB, + 0xB6, 0xCE, 0xA4, 0xAE, 0x2E, 0xF9, 0x6F, 0xA2, + 0x09, 0xC7, 0x45, 0xB1, 0x7E, 0x94, 0x45, 0x9A, + 0xDA, 0xAF, 0xDB, 0xFC, 0xD3, 0xD8, 0x4D, 0xE9, + 0xB8, 0xAF, 0x71, 0x1E, 0xFB, 0x0D, 0xB3, 0xEF + }, + { + 0xD5, 0xD4, 0xEA, 0xDB, 0xC5, 0x40, 0xC8, 0x48, + 0x41, 0xB7, 0x04, 0xB9, 0x4C, 0x21, 0x4B, 0x31, + 0x8B, 0x69, 0xDD, 0x39, 0x91, 0x17, 0x10, 0xF7, + 0x57, 0x19, 0x9F, 0x3E, 0x1F, 0x29, 0x8A, 0x96, + 0x1A, 0xB7, 0x23, 0x63, 0x27, 0x85, 0x4C, 0x4C, + 0xA6, 0xE9, 0x2A, 0x58, 0xDD, 0xEA, 0xB1, 0x49, + 0xF7, 0x33, 0x68, 0xEA, 0x00, 0xC4, 0xEB, 0x6B, + 0xBD, 0x14, 0xAE, 0x11, 0x48, 0x34, 0xB7, 0xD7 + }, + { + 0xEE, 0xB3, 0x08, 0x6D, 0x78, 0xBF, 0xEF, 0x0A, + 0xA3, 0x91, 0x4B, 0x85, 0x3F, 0x4F, 0xB7, 0x51, + 0x63, 0xA0, 0xA4, 0x80, 0x8F, 0xC6, 0xC4, 0xDA, + 0x01, 0xA7, 0x28, 0x87, 0xF8, 0xDB, 0x00, 0x51, + 0xCF, 0xB1, 0xDB, 0x51, 0xB3, 0xCF, 0x70, 0x1B, + 0xFB, 0xA0, 0x44, 0x79, 0x0B, 0x9F, 0xE1, 0xDC, + 0x5D, 0x15, 0x43, 0xD5, 0x8A, 0x29, 0xFE, 0x11, + 0x72, 0xE9, 0xE0, 0x4B, 0x95, 0x7B, 0x23, 0xED + }, + { + 0x52, 0x04, 0xDA, 0xA2, 0x50, 0x35, 0x66, 0xC2, + 0xA0, 0x92, 0xC2, 0x56, 0x01, 0x70, 0xBB, 0xC9, + 0x2D, 0x82, 0x3B, 0x06, 0xDD, 0x0E, 0x5D, 0xAE, + 0x6F, 0xDD, 0x66, 0xBB, 0x00, 0x46, 0x81, 0xC7, + 0x1D, 0x15, 0x89, 0x68, 0xFB, 0x1A, 0x8E, 0x8D, + 0x09, 0x93, 0xD4, 0xBB, 0x24, 0xBD, 0xD7, 0xC7, + 0x71, 0xE1, 0xF2, 0x8E, 0x1B, 0x6D, 0xAF, 0x6D, + 0x4B, 0x8C, 0xC7, 0x51, 0x8C, 0xDB, 0x4D, 0xB9 + }, + { + 0xB2, 0xFC, 0xFA, 0x50, 0xA2, 0xF9, 0x45, 0xEA, + 0xDA, 0xEA, 0x9E, 0x16, 0x88, 0xD4, 0xE3, 0xFF, + 0xEF, 0xC2, 0x5B, 0xB8, 0x1E, 0x84, 0xE5, 0xF0, + 0x34, 0x34, 0xCD, 0x3B, 0x77, 0x18, 0x37, 0x41, + 0x36, 0xCE, 0x73, 0x99, 0xA3, 0x5A, 0x53, 0x9C, + 0xE6, 0xA5, 0x23, 0xC5, 0xDD, 0xA6, 0x15, 0x09, + 0xE0, 0xBA, 0x5A, 0xBF, 0x81, 0xD0, 0x8A, 0xE5, + 0x0F, 0xDE, 0xB5, 0x6D, 0x93, 0xED, 0x12, 0x6E + }, + { + 0x71, 0xA6, 0x7A, 0x26, 0x25, 0x8A, 0xA5, 0xBD, + 0x1D, 0x40, 0x8B, 0x5B, 0x61, 0xCA, 0x4A, 0x2D, + 0x5D, 0x09, 0x48, 0x69, 0xAE, 0x6A, 0x3B, 0xDF, + 0xFF, 0xD1, 0x74, 0xB0, 0x98, 0xD3, 0x0B, 0xDA, + 0xCE, 0x03, 0xAD, 0x1E, 0x73, 0x30, 0xB3, 0x1A, + 0x9A, 0xEB, 0x50, 0x5F, 0xB2, 0x6A, 0xE0, 0x85, + 0xE5, 0x74, 0x5A, 0x63, 0x69, 0x3E, 0x73, 0xF0, + 0xD0, 0x04, 0x3C, 0xD0, 0x76, 0x8D, 0x99, 0x32 + }, + { + 0xB3, 0xA6, 0x21, 0x78, 0x3B, 0x47, 0x08, 0x9B, + 0xCA, 0x35, 0x13, 0xF5, 0x94, 0x31, 0x95, 0x95, + 0xC4, 0xAD, 0xBD, 0x2B, 0x3B, 0xB9, 0xD9, 0x79, + 0x79, 0x11, 0x32, 0x65, 0x83, 0xA8, 0x62, 0x4D, + 0xC1, 0x4B, 0x89, 0x87, 0x60, 0x4E, 0xE2, 0x2C, + 0xCC, 0xCB, 0x4D, 0x3C, 0x6A, 0x10, 0x57, 0xC0, + 0x76, 0x97, 0x43, 0xD1, 0x25, 0x3F, 0xF0, 0xE5, + 0x1A, 0x91, 0x93, 0x67, 0xD6, 0x87, 0x83, 0x09 + }, + { + 0x99, 0xBF, 0x57, 0xF2, 0xF1, 0x55, 0x53, 0xB4, + 0x21, 0x26, 0x8A, 0x1F, 0x02, 0x29, 0x26, 0x22, + 0xA7, 0x01, 0x5C, 0xEA, 0x09, 0x3A, 0x9F, 0xEC, + 0x5B, 0x2F, 0xC9, 0x73, 0xCD, 0xCF, 0x06, 0xFB, + 0x75, 0xC7, 0x4A, 0xFA, 0x9A, 0x7F, 0xB9, 0x5B, + 0xED, 0x1E, 0x41, 0xE8, 0x88, 0x71, 0x1A, 0x54, + 0x1A, 0xB1, 0xED, 0x7A, 0xCB, 0xD6, 0x7E, 0x96, + 0xB2, 0x8B, 0x40, 0xEB, 0xD0, 0x5C, 0x7C, 0xCF + }, + { + 0xF5, 0xAA, 0x3D, 0xDF, 0x8A, 0xD4, 0xE6, 0x40, + 0xF9, 0x93, 0xC8, 0x6C, 0x8F, 0x3E, 0x82, 0x58, + 0xCF, 0x0C, 0xD9, 0x0D, 0xC9, 0xEB, 0x70, 0x2C, + 0xD2, 0xBC, 0x22, 0xF7, 0xCC, 0x06, 0x9D, 0x4C, + 0xB5, 0x8A, 0x84, 0x5F, 0x31, 0x44, 0xB3, 0x78, + 0x95, 0xCA, 0x0B, 0xF8, 0x88, 0x4D, 0x90, 0xD4, + 0xEC, 0x09, 0x34, 0x07, 0x63, 0x50, 0xA0, 0x6A, + 0x4B, 0x1F, 0x8B, 0x7C, 0x73, 0xFD, 0x2A, 0xE2 + }, + { + 0x5D, 0x5E, 0xBF, 0x2F, 0xB2, 0x0B, 0x38, 0xEB, + 0x07, 0xD3, 0x6F, 0x08, 0x52, 0xC5, 0xED, 0x41, + 0x1F, 0xF2, 0x80, 0xF1, 0x6D, 0x9F, 0x9E, 0xB4, + 0x57, 0x4B, 0x81, 0xFF, 0xD6, 0x5D, 0xAC, 0xAF, + 0x43, 0xCD, 0xC5, 0x80, 0x64, 0x94, 0x64, 0xD1, + 0x88, 0x27, 0x11, 0x73, 0x77, 0x52, 0x09, 0xF7, + 0xD9, 0xD1, 0xB7, 0x9D, 0xC8, 0xF7, 0x90, 0xD5, + 0x32, 0x55, 0x9D, 0x45, 0xEE, 0x2B, 0x5A, 0xAF + }, + { + 0x17, 0x3D, 0x8A, 0xCE, 0xB5, 0x09, 0x36, 0xC1, + 0x2F, 0xBB, 0x45, 0xE0, 0x4D, 0xFB, 0x60, 0x33, + 0x8D, 0xA7, 0x3C, 0x55, 0xF2, 0xD0, 0x5D, 0x8B, + 0xB4, 0x7A, 0x3A, 0x45, 0xDC, 0xEB, 0xDF, 0xEA, + 0xD4, 0x77, 0x38, 0x23, 0xF3, 0x86, 0x92, 0xD6, + 0x44, 0x33, 0xEB, 0xD1, 0x91, 0xEF, 0x9B, 0x40, + 0xDD, 0x5A, 0x2C, 0x55, 0x79, 0x39, 0xB4, 0x6C, + 0x1A, 0x52, 0xDA, 0xB8, 0x2F, 0x5B, 0x2E, 0x29 + }, + { + 0x67, 0x0B, 0x69, 0x6A, 0x53, 0xE2, 0x2D, 0x9D, + 0xDC, 0x78, 0x8A, 0xC4, 0x68, 0x00, 0x44, 0x69, + 0xBF, 0xD3, 0xF1, 0x4A, 0x2B, 0xFB, 0xEB, 0xCF, + 0xCB, 0xF4, 0x34, 0xA5, 0x67, 0x4D, 0x8E, 0x46, + 0x92, 0x1F, 0x17, 0x87, 0xFA, 0x07, 0x20, 0xB8, + 0x05, 0xD0, 0x29, 0xD2, 0xFA, 0x47, 0xCE, 0xF6, + 0x48, 0xF9, 0x2C, 0x23, 0xDC, 0xC9, 0x17, 0x75, + 0x16, 0xDF, 0x01, 0xCC, 0xBD, 0x94, 0x48, 0x06 + }, + { + 0x56, 0x87, 0xBE, 0x2C, 0x9F, 0x79, 0xD0, 0x42, + 0xA9, 0xDD, 0xC1, 0xF3, 0xC6, 0x55, 0xF2, 0xEA, + 0x56, 0x76, 0x9B, 0x62, 0x22, 0xA4, 0x42, 0x9B, + 0x84, 0x59, 0xEC, 0xC0, 0x95, 0xC5, 0xA2, 0xED, + 0xFD, 0xC2, 0x7E, 0x7C, 0xC8, 0x92, 0xEB, 0x65, + 0x70, 0x33, 0x90, 0x0D, 0xE7, 0x44, 0xF1, 0xCD, + 0x5D, 0x09, 0x4D, 0x75, 0xDE, 0x6F, 0x66, 0x5A, + 0x37, 0xC6, 0x4F, 0x34, 0x7F, 0xD0, 0xEC, 0xB9 + }, + { + 0x21, 0x1C, 0xDB, 0xF2, 0xD0, 0x32, 0xDD, 0x49, + 0xBA, 0x56, 0x63, 0x81, 0xF2, 0xDA, 0xFC, 0x6E, + 0x76, 0xA4, 0x4F, 0xE1, 0x29, 0x32, 0xF4, 0x1E, + 0x87, 0xFE, 0xBB, 0x6D, 0xA8, 0xA5, 0x8E, 0x08, + 0xFA, 0xAB, 0xD9, 0xD3, 0xE4, 0x01, 0x16, 0x8F, + 0xB1, 0x5F, 0x43, 0xB7, 0x34, 0x13, 0x3F, 0x34, + 0x4C, 0xAD, 0x0F, 0x6B, 0x6A, 0x94, 0x5E, 0x1A, + 0xC6, 0x06, 0xC3, 0x3D, 0x0B, 0x92, 0xFF, 0x7E + }, + { + 0x8B, 0x6F, 0x8B, 0x86, 0x0C, 0xEB, 0x0F, 0xCE, + 0xE8, 0x52, 0xEC, 0xCA, 0x39, 0xA5, 0xDC, 0x45, + 0xE7, 0x8A, 0x41, 0x31, 0x53, 0x61, 0xA9, 0xA4, + 0x07, 0xA6, 0x27, 0x37, 0x90, 0x31, 0xE1, 0x25, + 0xD3, 0xD0, 0x02, 0x32, 0x25, 0x99, 0x2B, 0x8A, + 0xF2, 0x69, 0xE4, 0x06, 0x53, 0xB8, 0xBD, 0x81, + 0x9C, 0xF7, 0x9F, 0xDE, 0x67, 0x4E, 0x59, 0x73, + 0x93, 0x02, 0x45, 0xC7, 0xA7, 0x3E, 0x9D, 0xEE + }, + { + 0xB1, 0x3D, 0x18, 0x34, 0x1F, 0xC1, 0x91, 0x18, + 0xA6, 0x26, 0x0D, 0x29, 0x26, 0x3E, 0x9D, 0xCF, + 0xFB, 0x12, 0xEB, 0xF3, 0x97, 0xB6, 0x4E, 0x62, + 0x8E, 0x5A, 0x71, 0x30, 0xB5, 0x64, 0x22, 0xE8, + 0x26, 0x81, 0x8B, 0x22, 0xCE, 0x91, 0x33, 0x83, + 0x7A, 0xAB, 0x38, 0x8C, 0xAD, 0x88, 0x30, 0xE1, + 0x62, 0xDF, 0x16, 0x25, 0xC8, 0x23, 0xCF, 0x32, + 0xD8, 0x53, 0xBF, 0x86, 0xF9, 0xE6, 0x48, 0x4C + }, + { + 0xF3, 0xEE, 0x3B, 0xCE, 0xFF, 0x5F, 0x80, 0x95, + 0x70, 0xA5, 0x6E, 0xFA, 0x97, 0x9A, 0xD1, 0x6D, + 0x33, 0xDF, 0xCD, 0xFD, 0x2A, 0xFC, 0x79, 0x6D, + 0xE4, 0x2A, 0xA3, 0xB1, 0x5E, 0xD5, 0xFE, 0x7C, + 0xC3, 0xD2, 0x07, 0xF0, 0x05, 0xE8, 0x21, 0x9D, + 0x3F, 0x0B, 0xC1, 0xE7, 0x89, 0x39, 0xF8, 0xCD, + 0x55, 0x67, 0x35, 0xBF, 0x12, 0xFF, 0x56, 0x59, + 0xD7, 0xA5, 0x30, 0xD5, 0x69, 0x68, 0x24, 0xBF + }, + { + 0x0B, 0xEE, 0x10, 0xD0, 0x0F, 0x91, 0x96, 0x14, + 0x3F, 0xA2, 0x00, 0xBD, 0x8D, 0xD2, 0xB0, 0xF7, + 0xA9, 0xF7, 0x3E, 0xEF, 0x88, 0x63, 0xBE, 0xBB, + 0x44, 0x6C, 0xD1, 0x70, 0x30, 0x35, 0x55, 0x8E, + 0x27, 0xD5, 0xA3, 0xF3, 0x9D, 0x2E, 0xC1, 0x10, + 0x12, 0x97, 0x36, 0xE3, 0xA8, 0xDF, 0x69, 0x65, + 0x57, 0x41, 0xEB, 0xD2, 0x81, 0x76, 0x3A, 0x3C, + 0xAD, 0xC5, 0x0D, 0x1D, 0x02, 0xDC, 0x54, 0x6B + }, + { + 0x85, 0x2D, 0xCC, 0x69, 0x82, 0x17, 0x3F, 0x80, + 0xFB, 0x36, 0xD8, 0xD4, 0x05, 0x93, 0x3F, 0xB6, + 0x95, 0x47, 0x6E, 0x99, 0x59, 0x20, 0x95, 0x2E, + 0xB9, 0x1E, 0x60, 0xD0, 0xB1, 0x80, 0x3A, 0x43, + 0x4A, 0xCA, 0x77, 0x16, 0xFC, 0x9A, 0x7C, 0xA3, + 0x6B, 0x42, 0x8D, 0xD0, 0x31, 0xEA, 0xF2, 0x47, + 0x61, 0x2F, 0x53, 0x62, 0x7C, 0x82, 0x5D, 0xC2, + 0xE1, 0x2C, 0xE8, 0x4E, 0xB6, 0x93, 0xD2, 0xCC + }, + { + 0xCE, 0x23, 0x5F, 0xDB, 0x03, 0x72, 0x6C, 0xAD, + 0xD2, 0xEF, 0x39, 0xA5, 0xAD, 0x6E, 0x6F, 0xEB, + 0xB5, 0x35, 0x8A, 0x2A, 0x38, 0x0A, 0x34, 0x9A, + 0x5E, 0x3B, 0x69, 0xDB, 0x58, 0xFA, 0xB6, 0x12, + 0xC0, 0x5D, 0x8F, 0x5D, 0x61, 0xF0, 0x8E, 0x92, + 0xCC, 0x70, 0x4D, 0x48, 0xA6, 0x2D, 0x8F, 0xAF, + 0xE8, 0x5E, 0x04, 0x15, 0x99, 0xB8, 0x8B, 0x1F, + 0x0C, 0xA9, 0x2C, 0xBA, 0x43, 0x40, 0x09, 0xA4 + }, + { + 0x78, 0x95, 0x52, 0xCD, 0x98, 0x05, 0x1E, 0x67, + 0xA5, 0x16, 0xAE, 0x20, 0xA4, 0xD5, 0x16, 0xB7, + 0x16, 0x4F, 0xCF, 0xBA, 0x43, 0x41, 0x0F, 0x75, + 0xFA, 0x9A, 0x23, 0xF0, 0x7A, 0xE0, 0xEA, 0xE7, + 0x64, 0xAB, 0x52, 0x8A, 0x97, 0x43, 0xB6, 0x9B, + 0xB8, 0xFB, 0xA3, 0x45, 0x73, 0x5B, 0x4B, 0x18, + 0x37, 0x6F, 0xB9, 0xFE, 0xBC, 0x6B, 0x36, 0xDC, + 0x8A, 0x9C, 0x66, 0xEC, 0x1E, 0x53, 0x7C, 0x8F + }, + { + 0x24, 0x25, 0xCD, 0xF6, 0xB1, 0x9E, 0x66, 0xDE, + 0x1E, 0xE8, 0x80, 0x42, 0x55, 0xB0, 0x59, 0x2D, + 0x9B, 0x29, 0x14, 0xC2, 0x39, 0xCC, 0x38, 0x8C, + 0x49, 0x3D, 0x95, 0x6D, 0x24, 0x84, 0x6B, 0x5D, + 0x9F, 0xCC, 0x99, 0xD0, 0x18, 0xBF, 0x7B, 0x18, + 0x17, 0x6F, 0x76, 0x4F, 0x7E, 0x32, 0x12, 0x34, + 0xF2, 0x94, 0x42, 0x67, 0x54, 0xE6, 0x07, 0xAA, + 0x15, 0xC4, 0xE9, 0x0F, 0xE3, 0xE7, 0x36, 0x6F + }, + { + 0xBE, 0xDA, 0x13, 0x10, 0x9D, 0x70, 0xDA, 0x6D, + 0x13, 0x6B, 0xEA, 0x0D, 0x0C, 0x8E, 0x9A, 0x34, + 0x94, 0x7C, 0x0F, 0xE1, 0xC7, 0x51, 0xC9, 0x48, + 0x11, 0x4A, 0x93, 0x65, 0x83, 0xE7, 0xE7, 0x10, + 0x47, 0x80, 0x14, 0x38, 0x91, 0x05, 0xE0, 0x52, + 0x61, 0x4F, 0xEA, 0x85, 0x7D, 0xC4, 0xCD, 0xCE, + 0x7A, 0x91, 0xA4, 0x66, 0xFC, 0xFB, 0x27, 0x3F, + 0xB3, 0x3F, 0x78, 0x5E, 0x38, 0xCF, 0xAB, 0xD7 + }, + { + 0xBA, 0xF3, 0x2D, 0xDA, 0x90, 0xAE, 0xEB, 0xE7, + 0xCD, 0xEE, 0x24, 0x0D, 0xBD, 0xC1, 0xDD, 0xCA, + 0xD6, 0xDF, 0x9D, 0xB7, 0x19, 0x1A, 0xF3, 0xB8, + 0x3C, 0x5D, 0x1E, 0xFB, 0xD2, 0xF0, 0xCE, 0x10, + 0xCE, 0xAE, 0xA8, 0x70, 0x4D, 0x94, 0x27, 0xED, + 0x61, 0xA0, 0x99, 0x89, 0x11, 0xD3, 0x3C, 0x85, + 0xE6, 0x49, 0xB7, 0x35, 0xDC, 0xA1, 0x05, 0xBF, + 0xAE, 0xDF, 0x17, 0x02, 0x24, 0x10, 0x31, 0x7B + }, + { + 0x78, 0xB9, 0x20, 0xFC, 0x2A, 0xC4, 0x02, 0x56, + 0x1D, 0x9D, 0x0C, 0x90, 0xD9, 0x49, 0xF3, 0xAE, + 0x9D, 0x28, 0xC6, 0x33, 0x9A, 0x2D, 0x3D, 0x57, + 0x22, 0x98, 0x2B, 0xC1, 0x84, 0x72, 0xF7, 0xB5, + 0xBB, 0xF3, 0x96, 0x4D, 0xA5, 0xA9, 0xA7, 0x40, + 0x7B, 0x9D, 0x0B, 0x04, 0xA0, 0x3A, 0x5E, 0xE1, + 0x98, 0xDB, 0xE1, 0xEB, 0x74, 0x6B, 0x89, 0xD3, + 0xC5, 0xD4, 0xE0, 0x17, 0xB6, 0xDD, 0xA9, 0x98 + }, + { + 0x62, 0x12, 0xE8, 0xFE, 0x1C, 0x48, 0xB5, 0x98, + 0x00, 0x56, 0x59, 0x39, 0xB8, 0xB2, 0x48, 0xE9, + 0x7C, 0x83, 0x73, 0x98, 0x70, 0x9D, 0x41, 0x4C, + 0x4E, 0x49, 0x69, 0xD8, 0xEA, 0x66, 0xB9, 0xC5, + 0x80, 0x55, 0x43, 0x6A, 0xF3, 0x34, 0x09, 0xC9, + 0x7B, 0x89, 0x90, 0x67, 0x56, 0x3D, 0x73, 0xB1, + 0xE6, 0xD3, 0xAE, 0xC6, 0x39, 0xC6, 0x02, 0x7D, + 0x6A, 0x3B, 0xC5, 0x46, 0xF6, 0x86, 0xB5, 0xFC + }, + { + 0x1B, 0x31, 0x58, 0xC8, 0x76, 0x59, 0x1A, 0xE8, + 0x26, 0xD6, 0x51, 0x62, 0xAB, 0xC0, 0x76, 0xDE, + 0xF9, 0x93, 0xE4, 0x80, 0xF9, 0x04, 0xC2, 0x86, + 0x1E, 0x34, 0x54, 0x6A, 0xB2, 0xEF, 0x11, 0xFA, + 0xE8, 0xBF, 0xC3, 0x1B, 0x45, 0x51, 0x34, 0x84, + 0x8A, 0xDE, 0x52, 0x30, 0x11, 0xA1, 0xD6, 0xA2, + 0xC3, 0x30, 0xF9, 0x19, 0x2E, 0x78, 0xAE, 0x4C, + 0xCE, 0xF4, 0x92, 0x05, 0xFD, 0x66, 0x5D, 0xD7 + }, + { + 0xFC, 0x1D, 0x4A, 0x70, 0x32, 0x8A, 0xB6, 0x19, + 0x48, 0x36, 0x9F, 0x33, 0x23, 0xC9, 0xDA, 0x28, + 0xC6, 0xA7, 0x92, 0x59, 0x55, 0x00, 0x7D, 0x5A, + 0x0C, 0xA6, 0xFE, 0x77, 0x2C, 0xE7, 0xFD, 0xC7, + 0x64, 0xA7, 0x2C, 0xBE, 0xD0, 0x9E, 0x42, 0x19, + 0xE7, 0x59, 0x43, 0xB9, 0x6D, 0x40, 0xF7, 0xD7, + 0x9C, 0x3A, 0xC2, 0xC2, 0xAA, 0x7F, 0xBB, 0xAB, + 0x0B, 0x6D, 0x70, 0x59, 0x76, 0x22, 0xEA, 0x2F + }, + { + 0x87, 0x4D, 0xD0, 0x28, 0x27, 0x24, 0xB4, 0x19, + 0x1E, 0xBD, 0x2D, 0x8F, 0x6A, 0x1E, 0x51, 0x60, + 0x0C, 0xCE, 0x90, 0x75, 0x70, 0x2C, 0xFD, 0xED, + 0xFC, 0x1E, 0x08, 0x5A, 0xFC, 0xDF, 0x6C, 0x76, + 0x67, 0xF9, 0x9E, 0x9C, 0x34, 0x53, 0x22, 0x08, + 0x5B, 0xDA, 0x1D, 0xD2, 0x8D, 0x3A, 0x4E, 0x05, + 0xBB, 0x44, 0xDB, 0x86, 0xD2, 0xF2, 0xFE, 0xDA, + 0x2D, 0xC8, 0xFE, 0x6D, 0x92, 0xD8, 0x2D, 0x6A + }, + { + 0x8C, 0x90, 0xD8, 0x1D, 0xFA, 0x91, 0x2C, 0x66, + 0x7E, 0x1C, 0x22, 0x56, 0x0E, 0x02, 0x46, 0x8E, + 0x63, 0x22, 0xA0, 0x52, 0xF5, 0xD8, 0x7B, 0x0C, + 0x46, 0xF2, 0x5C, 0x01, 0x34, 0x73, 0xB0, 0x48, + 0xAC, 0x0F, 0x98, 0x53, 0x59, 0xC1, 0xF6, 0xDA, + 0x1D, 0x8E, 0x09, 0xED, 0x74, 0xE1, 0x07, 0x9E, + 0x4D, 0x7B, 0x44, 0x50, 0x7B, 0x86, 0xC1, 0x6E, + 0x76, 0x5C, 0xD4, 0x94, 0xB5, 0xEA, 0xF8, 0x5E + }, + { + 0xD1, 0xB4, 0x54, 0xEF, 0x9F, 0x64, 0x50, 0xE4, + 0xD4, 0x57, 0x07, 0xFB, 0xE7, 0x9B, 0x13, 0x62, + 0x65, 0x2D, 0x0B, 0x4D, 0xE7, 0x72, 0x2D, 0x63, + 0x19, 0x35, 0xA5, 0xC0, 0x87, 0x5A, 0xB7, 0xCE, + 0x60, 0x72, 0xE4, 0xB6, 0x2B, 0xC9, 0xD7, 0x8E, + 0x74, 0x97, 0xC2, 0x0D, 0x71, 0x38, 0xF3, 0x01, + 0x2B, 0xB2, 0x77, 0x58, 0x0D, 0x95, 0x5B, 0xEF, + 0x33, 0xBD, 0x40, 0x21, 0xE5, 0x3E, 0x4B, 0xE9 + }, + { + 0xC5, 0xD8, 0x4D, 0x7B, 0x48, 0x02, 0xE4, 0x9F, + 0xDC, 0x95, 0x70, 0xDA, 0x42, 0x1A, 0x23, 0x25, + 0xEB, 0xC0, 0x05, 0x63, 0x61, 0x4F, 0xC6, 0x76, + 0x1E, 0xAE, 0x71, 0xDE, 0xE7, 0x82, 0x65, 0x5F, + 0x95, 0x27, 0xF3, 0x45, 0x94, 0xC1, 0xB1, 0x73, + 0xDE, 0xAE, 0x3B, 0x1D, 0x1B, 0xC1, 0xAF, 0x4A, + 0x47, 0xBC, 0xAE, 0xBC, 0xF1, 0xF6, 0x3C, 0x2E, + 0x7F, 0x5A, 0x56, 0x5B, 0xAA, 0xE5, 0xC6, 0x25 + }, + { + 0xD9, 0x54, 0x78, 0x02, 0xB7, 0xAB, 0x29, 0x23, + 0x60, 0x7D, 0x99, 0x23, 0xB0, 0xC8, 0x8F, 0x2C, + 0x33, 0xC2, 0x03, 0xE7, 0x6E, 0x6A, 0x60, 0xB9, + 0x0D, 0x9A, 0x67, 0xA2, 0x01, 0x83, 0x69, 0xBE, + 0xA9, 0x2B, 0xD5, 0x65, 0xFC, 0x19, 0x97, 0x66, + 0x63, 0xE4, 0xB6, 0x52, 0x0C, 0xEF, 0x61, 0xD2, + 0x7A, 0x08, 0x7C, 0x04, 0x95, 0x9B, 0xA8, 0x36, + 0x41, 0xE9, 0x34, 0xB5, 0xFC, 0x8D, 0xDB, 0xC7 + }, + { + 0xC2, 0xB0, 0x08, 0x8D, 0xCD, 0x20, 0x83, 0xFF, + 0x11, 0x91, 0xB6, 0x01, 0x05, 0x62, 0xD9, 0x77, + 0xF4, 0xCE, 0xB5, 0x48, 0x98, 0xE4, 0xDD, 0x65, + 0xB1, 0xDB, 0x23, 0x6E, 0x97, 0x56, 0xE6, 0xF6, + 0x34, 0xB6, 0x8B, 0x3E, 0x1A, 0x82, 0xA3, 0xC4, + 0xA4, 0xEC, 0x4C, 0x6C, 0x09, 0x2A, 0x53, 0xC1, + 0xA5, 0x5E, 0xCE, 0x3E, 0x47, 0x90, 0xE0, 0x03, + 0xC6, 0x1C, 0x49, 0x29, 0xE4, 0x6F, 0x32, 0x8E + }, + { + 0x79, 0xD7, 0x1F, 0xAD, 0x15, 0xCB, 0xF5, 0x79, + 0x2C, 0xF6, 0xCB, 0x8D, 0x30, 0x5B, 0x4C, 0x22, + 0x28, 0x2B, 0x34, 0xDE, 0x2E, 0x21, 0x4F, 0x47, + 0x05, 0x96, 0xC8, 0xD0, 0x0A, 0x04, 0x9E, 0xA5, + 0x14, 0x6B, 0x62, 0x84, 0xD6, 0x0D, 0xD9, 0x7E, + 0x05, 0x08, 0x27, 0x89, 0x03, 0xD9, 0x8C, 0x0A, + 0x21, 0x4A, 0xAA, 0x00, 0x4E, 0xFC, 0xD4, 0xA6, + 0x0C, 0x51, 0x33, 0xC8, 0x1E, 0x39, 0xB6, 0xCD + }, + { + 0x0E, 0x50, 0xB5, 0x9A, 0x06, 0x4D, 0xBA, 0x84, + 0x9E, 0xDF, 0x6F, 0x5F, 0x96, 0x3C, 0xC5, 0xAB, + 0x86, 0xEB, 0x38, 0x70, 0x0E, 0x4E, 0x07, 0x18, + 0x5F, 0x9D, 0xE4, 0x4E, 0x9E, 0x84, 0x18, 0x87, + 0xDD, 0x29, 0x00, 0xAB, 0x00, 0x0C, 0x54, 0x38, + 0x11, 0x3B, 0xD2, 0xC3, 0x87, 0xCA, 0x44, 0xE5, + 0x7C, 0x0A, 0x70, 0x98, 0x70, 0xEB, 0x08, 0x83, + 0x7B, 0x12, 0x4E, 0x40, 0xD2, 0xA1, 0xAE, 0x23 + }, + { + 0x5F, 0x97, 0xDA, 0x67, 0x05, 0xBA, 0x3D, 0x05, + 0x50, 0x9A, 0x77, 0x04, 0x5D, 0x89, 0x88, 0xF1, + 0x4D, 0x0D, 0x66, 0x2F, 0x0A, 0xB8, 0x18, 0xC3, + 0x63, 0x33, 0x20, 0x65, 0xE7, 0x55, 0x49, 0xCE, + 0x47, 0xAA, 0xB5, 0x6E, 0x81, 0x28, 0x63, 0x53, + 0x0D, 0x12, 0x71, 0x31, 0x10, 0x67, 0xA8, 0x72, + 0xA2, 0x8D, 0x2C, 0xF2, 0xAF, 0x7A, 0x71, 0xD9, + 0x05, 0x4A, 0xA8, 0x57, 0x5A, 0x37, 0xE6, 0x94 + }, + { + 0x14, 0xBA, 0x11, 0x96, 0xF3, 0x75, 0xC5, 0xBB, + 0xB8, 0xA7, 0x87, 0xB9, 0xFC, 0x19, 0x7D, 0x38, + 0x32, 0x52, 0x55, 0x34, 0xB2, 0xBB, 0xFB, 0x21, + 0x69, 0xEE, 0x28, 0x6A, 0x76, 0x3B, 0x99, 0xDF, + 0x6E, 0x00, 0xB7, 0x0D, 0x31, 0xFF, 0x18, 0xF5, + 0xCA, 0x22, 0xC5, 0x5C, 0x13, 0xCB, 0x71, 0xCB, + 0xE0, 0xB5, 0x09, 0x91, 0x31, 0xBB, 0xC1, 0x2C, + 0x39, 0xEB, 0x54, 0xC8, 0xE0, 0xE6, 0xFE, 0x5C + }, + { + 0x1D, 0x39, 0xED, 0x4A, 0xB8, 0xB0, 0x9B, 0xFB, + 0x1D, 0x5E, 0x80, 0x2F, 0x09, 0x53, 0x97, 0x10, + 0x65, 0x5C, 0xE2, 0x32, 0xD7, 0xA2, 0xDF, 0x57, + 0x11, 0xA2, 0x6F, 0x0B, 0x6F, 0x55, 0x96, 0xBF, + 0x98, 0x38, 0x85, 0x51, 0xC4, 0x43, 0x8C, 0x83, + 0x86, 0xA8, 0x16, 0x67, 0xF4, 0x2C, 0xD4, 0xF1, + 0xFB, 0x7F, 0x05, 0xC2, 0x45, 0xAF, 0x86, 0xA6, + 0x6F, 0x9B, 0x63, 0x1F, 0x72, 0x73, 0x99, 0xF9 + }, + { + 0x7E, 0x87, 0x84, 0x95, 0x7F, 0xF3, 0x7D, 0x4B, + 0x7B, 0xD0, 0x32, 0xC4, 0xCF, 0xA2, 0xB5, 0xEA, + 0x69, 0xB5, 0x9E, 0x21, 0x6E, 0x04, 0xE5, 0xF5, + 0x42, 0x6A, 0xC5, 0x35, 0xBA, 0xE0, 0x86, 0x71, + 0xCE, 0xCC, 0xED, 0x88, 0xBC, 0x32, 0x35, 0xE4, + 0x24, 0x11, 0xC0, 0x34, 0xD4, 0xA7, 0x4C, 0xF4, + 0xA6, 0x74, 0x7E, 0x9D, 0x07, 0xA8, 0xEF, 0xE7, + 0x81, 0x8B, 0x90, 0xDA, 0x0F, 0x1C, 0xE2, 0xC2 + }, + { + 0x48, 0x90, 0x0C, 0xA4, 0xE8, 0x75, 0xDD, 0xF4, + 0xCB, 0x6A, 0xA8, 0x44, 0x18, 0x3C, 0xBB, 0x9D, + 0x84, 0xEA, 0x3C, 0x63, 0xC5, 0xF9, 0x8A, 0x8C, + 0xEA, 0x00, 0xCF, 0xA3, 0x55, 0xB9, 0xF4, 0x9D, + 0xB1, 0x96, 0x70, 0x66, 0x60, 0x3A, 0x16, 0xA9, + 0xA5, 0x08, 0x7D, 0xA8, 0xC5, 0x00, 0x98, 0xE3, + 0x76, 0x36, 0x57, 0xB6, 0x79, 0x9E, 0x98, 0x00, + 0x2C, 0x59, 0x19, 0xE4, 0xB9, 0xFC, 0x32, 0xD6 + }, + { + 0x40, 0xF3, 0x9E, 0x7B, 0x88, 0x07, 0xBA, 0xD7, + 0x1B, 0xE8, 0xF0, 0x96, 0xDC, 0xEF, 0x0D, 0x1B, + 0xBA, 0x32, 0x00, 0xCB, 0xA1, 0x02, 0x11, 0x18, + 0xC2, 0x93, 0xDB, 0xBB, 0xBB, 0xBF, 0xFA, 0x86, + 0xB5, 0x57, 0x3D, 0xC6, 0x76, 0x79, 0xAC, 0xAA, + 0x0D, 0x14, 0x57, 0x43, 0xBB, 0xA7, 0x70, 0xE0, + 0x32, 0x1D, 0x5E, 0x5B, 0x82, 0x98, 0x5E, 0x25, + 0x78, 0x19, 0x7C, 0x17, 0xD9, 0xD1, 0xCA, 0xD6 + }, + { + 0x11, 0xB7, 0x14, 0xD2, 0xA5, 0x13, 0xE0, 0x71, + 0xD4, 0x5E, 0x0E, 0x8B, 0x23, 0x16, 0x35, 0x59, + 0x4E, 0x22, 0x02, 0x11, 0xAE, 0x8E, 0xEF, 0x08, + 0x65, 0xEA, 0xF3, 0xD7, 0x5B, 0xAC, 0x4D, 0xF6, + 0xA2, 0x30, 0xF3, 0x85, 0xEC, 0x9F, 0x1E, 0xAF, + 0x05, 0x93, 0x10, 0x16, 0x6B, 0x9D, 0x7E, 0xB7, + 0xBE, 0x04, 0xA8, 0x8B, 0x27, 0xA4, 0xAB, 0xA2, + 0x2F, 0x8B, 0x79, 0x3D, 0x13, 0xE1, 0xF2, 0xAC + }, + { + 0x30, 0x1F, 0x0C, 0xFC, 0x42, 0xB2, 0xFB, 0xB6, + 0xA3, 0x85, 0x9B, 0x91, 0xFE, 0x2D, 0x66, 0x5A, + 0xFA, 0x66, 0xA8, 0x5E, 0xEE, 0x01, 0x7B, 0x7D, + 0xC6, 0x2D, 0x51, 0xE6, 0x29, 0x07, 0xB6, 0x49, + 0x53, 0x70, 0x8E, 0x05, 0xEC, 0xF0, 0x84, 0x5A, + 0xD5, 0xF6, 0x41, 0xFE, 0xE5, 0xD6, 0x09, 0x5D, + 0x7F, 0x1F, 0x5C, 0x53, 0xAF, 0x8D, 0x16, 0x0B, + 0xFF, 0x5B, 0xE2, 0xAB, 0xBD, 0xF7, 0xA4, 0x68 + }, + { + 0x28, 0x7B, 0x1F, 0x72, 0xBE, 0xBD, 0xB5, 0x95, + 0x5F, 0xD6, 0x96, 0xA4, 0x3A, 0xBB, 0x38, 0x7A, + 0x4A, 0x47, 0x4C, 0xA4, 0x05, 0xF5, 0x98, 0xAC, + 0xBC, 0xEE, 0x8D, 0x2E, 0x14, 0x70, 0x1E, 0xD3, + 0x03, 0xAB, 0x93, 0x6A, 0x6D, 0x13, 0xB9, 0x89, + 0x76, 0x0A, 0xBA, 0x03, 0xD1, 0xDF, 0x25, 0x1D, + 0x3F, 0xAF, 0xBB, 0xBA, 0x89, 0x25, 0xF9, 0x97, + 0x78, 0xD1, 0x59, 0xDA, 0xB3, 0x03, 0x31, 0x3C + }, + { + 0x0C, 0x24, 0xBE, 0x44, 0xA9, 0x7D, 0xF5, 0x7E, + 0xD3, 0x97, 0x18, 0x6E, 0x10, 0x8E, 0xC4, 0xF3, + 0xE8, 0x8A, 0x7C, 0xA2, 0x7E, 0x59, 0xB3, 0xE8, + 0x2F, 0x61, 0xDF, 0xF8, 0xF9, 0x09, 0xA0, 0x2E, + 0xAD, 0x1B, 0x67, 0xA6, 0x8A, 0xEE, 0x2F, 0x93, + 0xC0, 0xC3, 0x23, 0x44, 0x0E, 0xFB, 0x90, 0x8A, + 0xF5, 0xCA, 0x2C, 0x8B, 0xEC, 0x3D, 0x2B, 0x34, + 0xE2, 0x0B, 0xA6, 0x7B, 0x16, 0xEA, 0x06, 0xCA + }, + { + 0x59, 0x3C, 0x35, 0xF5, 0xF1, 0x64, 0x9D, 0xBA, + 0xAB, 0x79, 0xF3, 0xD0, 0xF0, 0x6A, 0xF3, 0xE5, + 0xE7, 0xE5, 0x94, 0x2F, 0x57, 0x95, 0x51, 0x97, + 0x39, 0x96, 0xC3, 0xC1, 0xC5, 0xB8, 0xFD, 0x06, + 0xCC, 0x44, 0x46, 0x3F, 0x1C, 0xA2, 0xFE, 0xA7, + 0x88, 0xB5, 0xFF, 0xA3, 0x4C, 0xCA, 0x78, 0x88, + 0xCF, 0xEA, 0x94, 0xD6, 0x00, 0xF4, 0x85, 0xFA, + 0x32, 0x7D, 0xB7, 0xC8, 0x5A, 0x5E, 0x2F, 0x20 + }, + { + 0x38, 0xC3, 0x9C, 0x36, 0x1A, 0x91, 0xD9, 0x23, + 0x79, 0xF2, 0x5F, 0xD4, 0xF9, 0xC6, 0x2F, 0x2B, + 0xB2, 0x6B, 0xCD, 0x8F, 0x3F, 0x45, 0x5D, 0xFD, + 0x6C, 0xDC, 0x13, 0x5F, 0xD7, 0xBA, 0x50, 0x78, + 0xC7, 0xC7, 0xA0, 0x47, 0x43, 0xB6, 0xFF, 0xD0, + 0x8D, 0x09, 0xED, 0x75, 0x2C, 0x53, 0xB5, 0x89, + 0x1C, 0x7C, 0xCF, 0x19, 0x59, 0x7E, 0x0C, 0xE4, + 0x2A, 0xAA, 0x22, 0xD5, 0x42, 0x42, 0xFF, 0x80 + }, + { + 0x5B, 0x63, 0x33, 0x88, 0xBB, 0xE1, 0x0A, 0xFA, + 0x0C, 0x69, 0x5C, 0x5A, 0x34, 0xE8, 0x52, 0xE4, + 0x70, 0x4A, 0x13, 0x59, 0x6E, 0x97, 0x0A, 0x72, + 0xDC, 0x12, 0x03, 0x70, 0x59, 0xC0, 0x29, 0x2F, + 0x16, 0x81, 0x49, 0xDA, 0xC0, 0x97, 0xA5, 0x84, + 0xD1, 0xD9, 0x57, 0x27, 0x41, 0xF4, 0x62, 0xE0, + 0xDA, 0xBE, 0x3F, 0x5A, 0x84, 0xB5, 0xE9, 0x4A, + 0xB7, 0x10, 0xA0, 0x48, 0xCF, 0xAB, 0xF2, 0x36 + }, + { + 0x5F, 0x3E, 0x1A, 0x63, 0xA9, 0x49, 0x58, 0x0A, + 0x1A, 0xFB, 0xF3, 0x9E, 0x2A, 0x40, 0x06, 0xC9, + 0xE2, 0xAD, 0xFB, 0x23, 0x31, 0x4C, 0xAC, 0x33, + 0x89, 0x8A, 0x59, 0xF3, 0x1A, 0xDB, 0xF9, 0xAF, + 0x87, 0x7E, 0x70, 0x75, 0x63, 0xE0, 0x46, 0x38, + 0xB1, 0x79, 0x5D, 0xC4, 0xC1, 0x8F, 0xE4, 0x0B, + 0xDB, 0x14, 0x00, 0x79, 0x10, 0xCA, 0xD7, 0x9D, + 0x23, 0x5A, 0x4A, 0xA7, 0xE9, 0x2C, 0xB2, 0xDD + }, + { + 0xCD, 0x33, 0xDD, 0xC9, 0x9F, 0xF0, 0x57, 0x1E, + 0x4C, 0x2F, 0xEB, 0x03, 0xC3, 0xEF, 0x56, 0x59, + 0x75, 0xA4, 0x41, 0x87, 0xB2, 0x29, 0xAB, 0xB4, + 0xDE, 0x71, 0x66, 0xD7, 0xE3, 0x0A, 0xBC, 0x8B, + 0x9E, 0xF1, 0x3C, 0x64, 0xEB, 0x90, 0x86, 0x1F, + 0xD0, 0xC1, 0x99, 0x29, 0x77, 0xA9, 0x3D, 0x8B, + 0x55, 0x26, 0x2A, 0xE6, 0x40, 0x29, 0x59, 0x09, + 0x1F, 0x24, 0xC1, 0xE3, 0x5B, 0x64, 0xA2, 0x51 + }, + { + 0xB0, 0x88, 0xF2, 0x7F, 0xBE, 0x0E, 0x85, 0x21, + 0xCD, 0x59, 0x22, 0x38, 0x58, 0x20, 0xF0, 0x65, + 0xEF, 0xAF, 0xFA, 0x26, 0x02, 0xCD, 0xB4, 0xE4, + 0xB3, 0xFE, 0x44, 0x2D, 0x8A, 0xF0, 0xEC, 0x75, + 0x76, 0xA4, 0x02, 0xE8, 0x88, 0xD1, 0xE0, 0xFC, + 0x19, 0xB9, 0xD7, 0xE1, 0x30, 0xC0, 0x42, 0xE7, + 0x01, 0x8B, 0x73, 0x70, 0x8D, 0x4D, 0x65, 0x7C, + 0x54, 0xAB, 0x15, 0xBB, 0x63, 0xC6, 0x79, 0xD7 + }, + { + 0xA7, 0x4D, 0x86, 0xFB, 0x23, 0x62, 0x56, 0x68, + 0x53, 0x9C, 0x16, 0x25, 0x82, 0xE0, 0x3D, 0x99, + 0x82, 0xA1, 0x65, 0x3F, 0x07, 0x0C, 0xAC, 0x72, + 0x6D, 0xE6, 0xC5, 0xCE, 0x56, 0x45, 0x76, 0x87, + 0x4F, 0xC9, 0x59, 0x50, 0x0B, 0x03, 0x70, 0x0A, + 0xEE, 0xFA, 0x7E, 0x08, 0x98, 0x32, 0xB6, 0x64, + 0xAF, 0xA0, 0xC7, 0x5C, 0x79, 0x6E, 0x8B, 0x58, + 0x08, 0xB7, 0x09, 0x74, 0xD3, 0x4D, 0x58, 0x9F + }, + { + 0x64, 0x8E, 0x74, 0x71, 0x72, 0x36, 0x0A, 0x17, + 0x15, 0x84, 0xCC, 0xC6, 0x19, 0x77, 0x55, 0xA0, + 0x7C, 0xF7, 0xB9, 0x53, 0xE3, 0xB9, 0x18, 0x75, + 0x67, 0x03, 0x51, 0x73, 0x1F, 0x6E, 0x33, 0x1E, + 0x38, 0xDF, 0xB1, 0xE7, 0x84, 0x49, 0xA4, 0x71, + 0x82, 0x03, 0x11, 0x45, 0x18, 0x01, 0x37, 0xE2, + 0x41, 0x6D, 0x11, 0xA6, 0x4C, 0xBA, 0x7E, 0x9B, + 0x55, 0xFC, 0xB7, 0x03, 0xD0, 0xAC, 0xA2, 0x98 + }, + { + 0xCF, 0xB0, 0x5E, 0x40, 0x61, 0x70, 0x9F, 0xC3, + 0xF6, 0x9C, 0x19, 0x65, 0x62, 0xD4, 0xC4, 0x51, + 0x6C, 0x0C, 0xD5, 0x70, 0x03, 0x6C, 0xED, 0xC5, + 0xEF, 0xEB, 0x4F, 0xE3, 0x11, 0x46, 0x4E, 0x39, + 0xF3, 0x59, 0x51, 0x38, 0x4D, 0x2C, 0x30, 0x90, + 0xD0, 0x4B, 0xA1, 0xD5, 0x70, 0x28, 0x0F, 0x08, + 0xAD, 0xAF, 0xEF, 0xCD, 0x82, 0x5A, 0xE9, 0x96, + 0x24, 0x79, 0xC6, 0x05, 0x3D, 0x7D, 0xEF, 0x04 + }, + { + 0x2C, 0x1A, 0x89, 0xA6, 0xA1, 0xA3, 0xEA, 0x7E, + 0x94, 0x5F, 0xD0, 0x19, 0x6F, 0x01, 0xA9, 0x22, + 0x17, 0xC6, 0xBE, 0xE3, 0x8B, 0xB0, 0x63, 0x21, + 0xD7, 0xBE, 0x19, 0xEF, 0xBC, 0x0A, 0x8C, 0x01, + 0xD5, 0x66, 0xCF, 0x4F, 0x3F, 0xB8, 0xA6, 0xA7, + 0xA4, 0xA0, 0x3B, 0xC9, 0x02, 0xB5, 0xB0, 0xFB, + 0x65, 0x22, 0xB2, 0xF4, 0x7A, 0xCE, 0x2F, 0x50, + 0xE2, 0x8A, 0x99, 0x02, 0x26, 0x04, 0x6E, 0x20 + }, + { + 0xA8, 0xE6, 0x66, 0x07, 0x84, 0x0D, 0x84, 0xE4, + 0x42, 0x7F, 0x3E, 0xB1, 0x85, 0xC1, 0x9F, 0x74, + 0xFB, 0x10, 0x76, 0x5D, 0x1C, 0x23, 0x13, 0x13, + 0x3B, 0x8F, 0x1A, 0xF0, 0xA7, 0x0B, 0xEC, 0x56, + 0x60, 0x74, 0x5D, 0xA7, 0x5A, 0x03, 0x5A, 0xF3, + 0x63, 0x8B, 0x11, 0x26, 0x96, 0x13, 0xF1, 0x80, + 0x60, 0xA3, 0xBB, 0x54, 0x68, 0x1A, 0xE9, 0x7B, + 0x4C, 0x06, 0x89, 0x61, 0x71, 0xB6, 0x4B, 0x43 + }, + { + 0xD6, 0x30, 0xA0, 0xED, 0x4C, 0xAB, 0x3A, 0x41, + 0x23, 0x6E, 0x15, 0x9B, 0x10, 0xCC, 0x7D, 0x5E, + 0x01, 0xA5, 0x1A, 0x08, 0x55, 0xB2, 0xF5, 0xD6, + 0xEF, 0x15, 0xC2, 0xEE, 0xEB, 0x0B, 0xDF, 0x2F, + 0x12, 0x26, 0xD3, 0x91, 0x81, 0xE9, 0x53, 0xA0, + 0x46, 0x77, 0xC2, 0x47, 0x7C, 0xF8, 0xFE, 0xDA, + 0x69, 0x88, 0xD7, 0x59, 0x0A, 0xA3, 0x55, 0x1B, + 0x00, 0x9A, 0x92, 0xB2, 0xB3, 0xAA, 0xBF, 0x39 + }, + { + 0xBE, 0x7F, 0x67, 0x1E, 0x25, 0xDE, 0x08, 0xC2, + 0x20, 0x14, 0xC0, 0xDC, 0xF0, 0xAD, 0x78, 0xF9, + 0x12, 0x2F, 0xF3, 0xBE, 0xBC, 0x52, 0x13, 0x79, + 0x23, 0x86, 0x43, 0x58, 0x8A, 0x44, 0x74, 0xFD, + 0xBE, 0xC2, 0xEC, 0x50, 0xDE, 0xD6, 0xBB, 0x7F, + 0x72, 0x6C, 0x00, 0x27, 0x15, 0x96, 0x11, 0x22, + 0x06, 0x6E, 0x09, 0xCA, 0x8A, 0xFB, 0x90, 0x82, + 0xED, 0xD6, 0xE7, 0x7A, 0x76, 0x2C, 0xC6, 0xC8 + }, + { + 0x77, 0x09, 0x6B, 0x7D, 0x3F, 0x12, 0xE5, 0x77, + 0xD3, 0xA4, 0x91, 0x6A, 0x8C, 0xA7, 0x3F, 0x2C, + 0x6F, 0x44, 0x92, 0xD7, 0xA7, 0xAD, 0x4C, 0xE6, + 0xDF, 0x46, 0xC1, 0xC4, 0x79, 0xF7, 0x5C, 0x47, + 0x9F, 0x7D, 0xFF, 0x4D, 0x93, 0x1F, 0x11, 0x7F, + 0x9F, 0x74, 0x7E, 0xAC, 0x73, 0x5B, 0xD6, 0x59, + 0x46, 0xA2, 0x4B, 0x47, 0xE1, 0xF3, 0xF3, 0x15, + 0x38, 0x73, 0x08, 0xDF, 0x4E, 0x7D, 0x71, 0xEE + }, + { + 0x62, 0x76, 0xB7, 0x54, 0x2F, 0x45, 0xE7, 0x84, + 0xBE, 0x1B, 0xF6, 0x94, 0x5F, 0xBE, 0xD6, 0xD7, + 0x21, 0x87, 0x7B, 0x10, 0x94, 0xFB, 0x29, 0xFB, + 0x64, 0x84, 0xC7, 0x0F, 0x62, 0x43, 0xDC, 0x58, + 0x3E, 0xF2, 0xE8, 0x17, 0xDD, 0xB5, 0x8E, 0xA3, + 0xB2, 0x1B, 0x09, 0x4E, 0x7E, 0x68, 0xA1, 0xD9, + 0xF7, 0xFC, 0xF8, 0xE7, 0xDF, 0xE7, 0x93, 0x58, + 0x9D, 0x18, 0x53, 0x5C, 0xF9, 0x8D, 0xA9, 0x45 + }, + { + 0x0E, 0xB1, 0x66, 0xE3, 0x10, 0x02, 0xEA, 0xB4, + 0x62, 0x6E, 0x9E, 0x0A, 0xB5, 0x1A, 0x1F, 0x44, + 0x6A, 0xE6, 0x0C, 0x9F, 0xC7, 0xF9, 0xEE, 0xDE, + 0x7B, 0xB5, 0xD8, 0xBD, 0x62, 0x4D, 0xEC, 0x6F, + 0x70, 0xD1, 0xC4, 0x68, 0xA4, 0x7F, 0xDB, 0xBC, + 0x61, 0x92, 0x06, 0x48, 0x5B, 0x2F, 0x44, 0x94, + 0xE0, 0xD5, 0xD4, 0x3A, 0x73, 0x7A, 0xA9, 0x3C, + 0x5B, 0xFC, 0x0F, 0x7D, 0x66, 0x3B, 0x8F, 0x7C + }, + { + 0x8D, 0x67, 0x66, 0x65, 0xB9, 0xE1, 0x9F, 0xF1, + 0x99, 0x12, 0x72, 0xEA, 0xE2, 0x06, 0xAB, 0xD4, + 0x03, 0x06, 0x12, 0xB5, 0x9A, 0x3A, 0xE1, 0x1A, + 0x2D, 0x49, 0xAC, 0x83, 0x13, 0xBD, 0x20, 0xC8, + 0xE2, 0xF2, 0x45, 0x08, 0x74, 0xB1, 0xD4, 0x3C, + 0xE8, 0xCA, 0x29, 0x45, 0xD2, 0x2C, 0x87, 0x24, + 0xD9, 0x12, 0x7F, 0x1A, 0xE5, 0x83, 0xB9, 0xE1, + 0xD0, 0xF8, 0xDD, 0x49, 0x92, 0xEA, 0x67, 0x50 + }, + { + 0xB6, 0x94, 0x58, 0xE7, 0x6D, 0x39, 0x18, 0xAB, + 0x80, 0x9E, 0x07, 0x73, 0xBA, 0xF2, 0x32, 0x71, + 0xFD, 0x84, 0x23, 0x20, 0x2D, 0x13, 0x8A, 0x6F, + 0x4F, 0x81, 0xCF, 0x51, 0x1D, 0x8B, 0x0C, 0x1F, + 0xEE, 0x31, 0xA1, 0x0B, 0xFA, 0x20, 0x5A, 0x24, + 0xFE, 0x99, 0xA0, 0x50, 0x1A, 0x8C, 0x78, 0x97, + 0x04, 0x8F, 0xD4, 0xD8, 0xB4, 0xB1, 0xD8, 0xF5, + 0xF8, 0x89, 0x35, 0x08, 0xA9, 0x37, 0xED, 0x65 + }, + { + 0x41, 0x1D, 0x7A, 0x42, 0x61, 0x02, 0x5E, 0x6E, + 0xF7, 0x87, 0x01, 0xE7, 0xBD, 0x3E, 0x71, 0xBD, + 0x58, 0xA4, 0x1A, 0x2B, 0x1A, 0xAD, 0xEB, 0x20, + 0x09, 0x62, 0x6C, 0x60, 0x95, 0x47, 0x96, 0xAD, + 0x4D, 0x07, 0x43, 0xB6, 0x98, 0xD5, 0x02, 0xAC, + 0x70, 0xBE, 0x4F, 0x44, 0xDD, 0x7C, 0xAD, 0x00, + 0x6E, 0x8A, 0x88, 0x0E, 0xCD, 0x51, 0x3A, 0xE0, + 0xE2, 0x14, 0x8C, 0xE8, 0x06, 0x65, 0xAA, 0xB5 + }, + { + 0xBB, 0x12, 0x95, 0xD7, 0xC8, 0xDD, 0x79, 0x1C, + 0xCA, 0x21, 0x64, 0xC2, 0xD7, 0xDB, 0x8F, 0xBE, + 0x70, 0x70, 0xCE, 0x5C, 0xAB, 0xA6, 0xF7, 0x8D, + 0x21, 0x0D, 0x6A, 0x20, 0x35, 0xF7, 0x68, 0x12, + 0xFC, 0x22, 0xE6, 0x21, 0x7D, 0xB5, 0x90, 0xA1, + 0xBD, 0xA3, 0xF0, 0xFE, 0x77, 0x13, 0x83, 0x44, + 0x43, 0xB7, 0x7B, 0x65, 0x47, 0x92, 0xA9, 0xB8, + 0x99, 0x6B, 0x6A, 0x0B, 0x04, 0xCF, 0xE4, 0x5C + }, + { + 0x6B, 0xAA, 0x3A, 0x80, 0xAA, 0xA7, 0xF7, 0x2E, + 0xCD, 0x2D, 0xB9, 0xDF, 0x0F, 0x72, 0x9F, 0x7A, + 0xC2, 0x49, 0x0E, 0xEF, 0xB2, 0xB0, 0xE9, 0xDB, + 0x60, 0xCB, 0x19, 0x51, 0xCC, 0x4A, 0x99, 0x07, + 0x43, 0x1D, 0x4A, 0x96, 0x34, 0xB3, 0x42, 0x52, + 0xA6, 0xEE, 0x22, 0x85, 0xEC, 0x05, 0x8D, 0xCC, + 0x34, 0xF0, 0xB2, 0x36, 0x31, 0x22, 0x56, 0xD7, + 0xB2, 0xA5, 0x8B, 0x77, 0xE9, 0x67, 0x79, 0x2A + }, + { + 0xAE, 0x50, 0x9F, 0xF3, 0xD3, 0xE9, 0xD1, 0x6B, + 0x80, 0x81, 0xB9, 0xDE, 0xDE, 0x2E, 0x4A, 0xE3, + 0xA5, 0x3A, 0xCF, 0x67, 0xF9, 0x02, 0xE7, 0x76, + 0xC8, 0x61, 0xA0, 0x84, 0xFB, 0x73, 0xE4, 0x03, + 0xC2, 0xDF, 0x27, 0x9A, 0x1E, 0x58, 0x9F, 0x75, + 0xE1, 0x18, 0xBC, 0x99, 0xB0, 0x3E, 0x35, 0x5C, + 0x25, 0x00, 0x3F, 0x30, 0x61, 0x1B, 0x66, 0x03, + 0xE5, 0xBD, 0xA3, 0xEB, 0x68, 0x80, 0xB2, 0x04 + }, + { + 0x7D, 0x97, 0x7E, 0x7D, 0x4F, 0x29, 0xA3, 0xB5, + 0x95, 0xC0, 0xA8, 0x4F, 0x33, 0xF8, 0xFF, 0xFD, + 0x2E, 0x9E, 0x4E, 0x71, 0xE1, 0xB4, 0xC1, 0x4D, + 0xC4, 0xD9, 0x86, 0xA2, 0xCA, 0x86, 0xD7, 0x7A, + 0xD8, 0x5D, 0x23, 0x5B, 0xD1, 0x78, 0x1C, 0x2D, + 0x57, 0x59, 0x6A, 0x71, 0xFC, 0xE0, 0x30, 0xAE, + 0x83, 0x1E, 0x94, 0xC9, 0xB3, 0x69, 0x80, 0xA2, + 0x0D, 0xD8, 0x6E, 0xDD, 0xDD, 0xDD, 0xC9, 0xD4 + }, + { + 0x89, 0x6F, 0x2C, 0x1F, 0x1B, 0xF8, 0x8E, 0x9C, + 0xC0, 0x20, 0xFF, 0xB9, 0x2C, 0x04, 0xDA, 0xBC, + 0xC2, 0x80, 0x06, 0xC8, 0xDA, 0x3D, 0x35, 0x1C, + 0x8E, 0x36, 0xE7, 0x21, 0xB6, 0x4F, 0x9F, 0x79, + 0xD8, 0x31, 0x87, 0xAC, 0xCC, 0xC2, 0x7E, 0xA4, + 0x9C, 0x8B, 0xBC, 0xE1, 0xB5, 0x02, 0xCF, 0x78, + 0x35, 0xC7, 0xC8, 0x67, 0x03, 0x21, 0x02, 0xB8, + 0x37, 0xAA, 0xA4, 0xC9, 0x5E, 0x88, 0x28, 0xE4 + }, + { + 0x31, 0x38, 0x0C, 0xF3, 0x91, 0xD0, 0x63, 0xEB, + 0x0A, 0x23, 0x5D, 0x8B, 0xFC, 0x2D, 0x20, 0x15, + 0x6B, 0xD3, 0x5E, 0xDC, 0x36, 0x4D, 0x0D, 0x28, + 0xA5, 0xBE, 0xE0, 0x0D, 0x21, 0x9C, 0x85, 0x41, + 0x5C, 0x6C, 0xEC, 0x91, 0x31, 0x4D, 0xB0, 0x57, + 0x53, 0x8F, 0xE1, 0x1C, 0x6D, 0x7F, 0xF7, 0x0C, + 0x6C, 0xF2, 0x34, 0xB1, 0xC6, 0xE6, 0xD3, 0x73, + 0x83, 0xD8, 0x4B, 0xF3, 0x9F, 0x87, 0xD1, 0x28 + }, + { + 0x3F, 0xEE, 0xA8, 0x74, 0x21, 0xEB, 0xC4, 0x76, + 0x99, 0x5A, 0xE6, 0x2B, 0x8C, 0x96, 0x50, 0x33, + 0x68, 0xF8, 0xF6, 0x4C, 0x9E, 0x84, 0xAB, 0x62, + 0xF4, 0xC9, 0xF1, 0x86, 0xF9, 0xC5, 0xF2, 0xA2, + 0xF7, 0xED, 0x82, 0x87, 0xD2, 0x2E, 0x97, 0x9C, + 0xAD, 0xFB, 0x2F, 0x47, 0x00, 0x87, 0xE2, 0x6F, + 0xCA, 0xD3, 0xF0, 0xA0, 0x38, 0x84, 0x51, 0xCC, + 0x08, 0x01, 0x8E, 0x0F, 0x56, 0x4E, 0xB0, 0x8A + }, + { + 0x7A, 0xE6, 0xE2, 0xC8, 0x53, 0x61, 0x54, 0x38, + 0xF6, 0xB9, 0x73, 0xB4, 0xF6, 0x9C, 0xE6, 0x97, + 0x7D, 0x7B, 0x8C, 0xF7, 0x1C, 0x48, 0x56, 0x40, + 0x09, 0x84, 0x91, 0xDF, 0x24, 0xC3, 0xEE, 0xF0, + 0xAA, 0x5C, 0xF6, 0x68, 0x27, 0xDA, 0xDC, 0x02, + 0x3C, 0xCC, 0xAE, 0x18, 0xC6, 0x6E, 0x6E, 0xE1, + 0x95, 0xFD, 0x69, 0x59, 0x6D, 0x1A, 0xCA, 0x5E, + 0x38, 0x86, 0x20, 0xAB, 0x1E, 0xD7, 0x42, 0x55 + }, + { + 0xEA, 0x53, 0x98, 0xE1, 0xFA, 0xEC, 0x41, 0xD1, + 0x1E, 0xED, 0x2E, 0x33, 0x81, 0x85, 0xEF, 0x26, + 0xD6, 0xD7, 0xE5, 0x29, 0xE8, 0x82, 0x92, 0x00, + 0xC3, 0x00, 0x20, 0x4F, 0x94, 0x62, 0x97, 0x3A, + 0xE1, 0xD5, 0x78, 0xB7, 0x0E, 0x24, 0xAA, 0x15, + 0x98, 0x57, 0xF4, 0xB0, 0x32, 0x84, 0xF2, 0xCD, + 0x56, 0x43, 0x91, 0xA5, 0x6C, 0x1F, 0x4D, 0xC6, + 0x6C, 0x93, 0x85, 0xF1, 0x1E, 0x01, 0xC1, 0xD6 + }, + { + 0x3A, 0x4E, 0x0B, 0x78, 0x83, 0x44, 0x2B, 0x91, + 0x65, 0x32, 0x92, 0x25, 0xFC, 0x5A, 0x34, 0x6A, + 0xCE, 0x62, 0xBE, 0xD3, 0x3B, 0x05, 0xC8, 0x21, + 0xFE, 0xA3, 0x01, 0xC6, 0xFD, 0x1A, 0x84, 0x4B, + 0x77, 0x48, 0x9B, 0xE3, 0xAF, 0x95, 0xB5, 0x7B, + 0x65, 0xE0, 0x0E, 0x63, 0x1F, 0x66, 0x0A, 0xAC, + 0x99, 0x6D, 0xAF, 0xB3, 0xB4, 0x61, 0x39, 0x0E, + 0xCA, 0xF0, 0x4F, 0xB6, 0x00, 0x92, 0x2F, 0x94 + }, + { + 0x99, 0x28, 0xA9, 0xAB, 0x60, 0x8F, 0x53, 0x22, + 0xBC, 0x83, 0x81, 0x96, 0xAA, 0x87, 0xC3, 0x49, + 0x39, 0xAC, 0xD7, 0xDF, 0xF2, 0x58, 0x02, 0xE7, + 0x51, 0xE2, 0x6F, 0xAB, 0x1D, 0xC7, 0xC7, 0xA6, + 0xE7, 0x65, 0x5D, 0xDF, 0x30, 0x25, 0x7C, 0x0B, + 0x25, 0x73, 0xBE, 0x7F, 0x36, 0x02, 0xEB, 0x02, + 0x2B, 0xCC, 0xE9, 0x55, 0x7D, 0xEE, 0x8D, 0x34, + 0xB6, 0x15, 0xCC, 0x57, 0x72, 0x12, 0xCD, 0xA0 + }, + { + 0x35, 0xE0, 0x95, 0xD8, 0xBC, 0x4F, 0xA2, 0x8F, + 0x42, 0x50, 0x84, 0x9D, 0xCA, 0xBB, 0x41, 0x63, + 0x71, 0x55, 0x18, 0x65, 0x72, 0x0A, 0x60, 0xF9, + 0x3B, 0x0F, 0x89, 0x9C, 0xA0, 0xD9, 0x28, 0x1F, + 0x7F, 0xAF, 0xCA, 0x25, 0x14, 0x34, 0x0E, 0x64, + 0x2F, 0x14, 0x5E, 0x17, 0xBA, 0xD7, 0x00, 0x5C, + 0xE4, 0x9F, 0xC7, 0xED, 0x5D, 0x02, 0x50, 0xB2, + 0x63, 0xDC, 0xF7, 0xD2, 0x6E, 0x9A, 0xE4, 0x62 + }, + { + 0xB7, 0xFA, 0x05, 0x78, 0x2B, 0x19, 0x46, 0x14, + 0x23, 0x60, 0xF5, 0x63, 0x02, 0x34, 0xFD, 0xBD, + 0x65, 0x17, 0x3A, 0xF5, 0x4D, 0x33, 0x26, 0x67, + 0x7C, 0x24, 0xB8, 0x0E, 0x3D, 0x96, 0xE5, 0xAF, + 0x72, 0x88, 0xA9, 0x2D, 0xD5, 0x19, 0x4A, 0x77, + 0xE9, 0x3C, 0x72, 0x81, 0x44, 0xCD, 0x75, 0x73, + 0xAB, 0x30, 0x5D, 0x86, 0x49, 0x4A, 0x60, 0x5E, + 0xF1, 0x23, 0x7A, 0xCF, 0x5F, 0xEB, 0x5C, 0xA5 + }, + { + 0x5A, 0xCF, 0xFC, 0x9A, 0xD8, 0x9E, 0x5A, 0x7F, + 0x5D, 0x3D, 0xC9, 0x82, 0x22, 0xD2, 0x9C, 0x79, + 0x24, 0x0A, 0x22, 0x05, 0x8B, 0x1E, 0x6F, 0x3C, + 0x72, 0x15, 0x62, 0x4A, 0x16, 0x97, 0x7C, 0x9B, + 0x34, 0xEA, 0xC2, 0x97, 0x90, 0xFA, 0xBD, 0x62, + 0x70, 0x4D, 0xD3, 0xF7, 0xD3, 0xAA, 0x6A, 0x42, + 0x98, 0xDF, 0xE8, 0xC1, 0xF7, 0x75, 0x9E, 0xA1, + 0x42, 0xBC, 0x9F, 0x3B, 0x04, 0x7A, 0x48, 0x8E + }, + { + 0x77, 0xEE, 0xB5, 0x74, 0xB0, 0x0F, 0xA5, 0x1B, + 0xB8, 0xC4, 0xC8, 0x04, 0x33, 0x85, 0x14, 0xDF, + 0x1E, 0x9C, 0xBA, 0x26, 0x7D, 0xA2, 0x67, 0x26, + 0x24, 0x1A, 0xAE, 0xDB, 0x52, 0x5E, 0x2B, 0x18, + 0x06, 0xF6, 0x0A, 0x9A, 0x39, 0xE1, 0x3B, 0xA7, + 0xAF, 0x8E, 0x5E, 0xE3, 0xF3, 0x13, 0xAE, 0x50, + 0x89, 0x2B, 0xBB, 0xED, 0x3D, 0x8E, 0x27, 0xE3, + 0x64, 0x17, 0xC4, 0xA7, 0xD4, 0xE0, 0x34, 0xE3 + }, + { + 0x89, 0xA9, 0xC6, 0xF1, 0xE3, 0xFC, 0xA0, 0x21, + 0x75, 0x44, 0x7E, 0x48, 0x38, 0xC0, 0xE1, 0xB2, + 0xC2, 0xD5, 0xDF, 0x17, 0x24, 0x21, 0x8B, 0x57, + 0xE7, 0x89, 0x42, 0x8B, 0xA0, 0x10, 0x4B, 0xE2, + 0xE5, 0x30, 0x03, 0xD3, 0x0E, 0x91, 0x7D, 0x13, + 0xFA, 0x84, 0x35, 0x5E, 0x47, 0x7D, 0x70, 0x04, + 0x10, 0xD5, 0x55, 0x77, 0x2A, 0x82, 0x51, 0x21, + 0xEB, 0xC7, 0x1F, 0x1C, 0xD8, 0x1D, 0x25, 0x6B + }, + { + 0x38, 0xCA, 0xBC, 0xB4, 0xF7, 0xF3, 0xC0, 0xDA, + 0x53, 0x31, 0x25, 0x35, 0x05, 0xD2, 0xEB, 0x9F, + 0x7A, 0x9B, 0x81, 0xAC, 0x4C, 0xE9, 0x99, 0xDF, + 0x34, 0x35, 0x4F, 0xDA, 0x0C, 0x99, 0xC3, 0xEF, + 0xB0, 0x57, 0x54, 0x43, 0x94, 0x00, 0xD9, 0x67, + 0xE7, 0xF7, 0xDF, 0x5F, 0x52, 0x46, 0x9E, 0x93, + 0xD4, 0xE3, 0x4E, 0x40, 0x57, 0x90, 0x6E, 0x07, + 0xED, 0x5D, 0x00, 0xBD, 0x8B, 0x04, 0x16, 0xB1 + }, + { + 0xDD, 0x0D, 0x2D, 0xFC, 0xD9, 0xFA, 0xAA, 0xD4, + 0x96, 0xBA, 0x73, 0xC2, 0xB8, 0x6C, 0x67, 0x7B, + 0xC0, 0xCA, 0x08, 0xCF, 0x93, 0x7A, 0x5C, 0xAB, + 0x01, 0xA5, 0xEB, 0xC2, 0xAA, 0xA8, 0xBB, 0xCD, + 0x6E, 0xE4, 0x19, 0x50, 0xDF, 0xEA, 0x63, 0x00, + 0xF7, 0x54, 0xE1, 0xA2, 0xCB, 0xC6, 0x94, 0xD1, + 0xE4, 0xAE, 0x3C, 0x08, 0x37, 0x03, 0x52, 0xAD, + 0xDC, 0x6B, 0xF7, 0xA5, 0x75, 0x63, 0x88, 0x8A + }, + { + 0xC4, 0x98, 0x33, 0xC9, 0x7A, 0xE6, 0x28, 0xAD, + 0xE7, 0x35, 0xC5, 0xC9, 0xD4, 0x64, 0x1A, 0x00, + 0x00, 0x6E, 0x92, 0x3A, 0xFB, 0x20, 0x51, 0x7D, + 0xFE, 0xF6, 0xD1, 0x37, 0x3D, 0x60, 0x03, 0xE7, + 0xCF, 0x7D, 0x40, 0x48, 0x6F, 0xA7, 0x9D, 0xC6, + 0xF3, 0x28, 0x4E, 0x84, 0x34, 0x34, 0x38, 0x7A, + 0xE1, 0xE1, 0x61, 0x43, 0x72, 0xA1, 0x82, 0xDC, + 0x59, 0xE8, 0x80, 0x39, 0xFD, 0x12, 0x57, 0xCA + }, + { + 0x01, 0x4A, 0x0A, 0x04, 0xF8, 0x49, 0x7D, 0x69, + 0xEA, 0xBC, 0x85, 0x83, 0xD6, 0x83, 0x35, 0x00, + 0xA1, 0x7D, 0xE9, 0x0A, 0xBD, 0xBA, 0x0B, 0xD3, + 0x09, 0x42, 0xF1, 0x33, 0x84, 0xEE, 0x27, 0xF6, + 0xAA, 0x15, 0xEC, 0xB1, 0x22, 0x74, 0xED, 0x76, + 0xEC, 0x16, 0xAD, 0x2F, 0xFE, 0xBC, 0xD9, 0x00, + 0x50, 0x5E, 0xC3, 0x6C, 0x17, 0xDB, 0x4E, 0x3C, + 0x9A, 0x54, 0x35, 0x4E, 0xDD, 0xA0, 0xD4, 0x33 + }, + { + 0xA6, 0x55, 0x41, 0xFB, 0x9A, 0xE5, 0x49, 0x9B, + 0x7D, 0x96, 0xE8, 0xBB, 0xBB, 0xC3, 0x5D, 0x15, + 0xCE, 0x68, 0x11, 0xB3, 0x1B, 0xFD, 0xB0, 0xD8, + 0x8A, 0x70, 0x6F, 0x2C, 0x8C, 0x65, 0x62, 0xB8, + 0xDD, 0x38, 0xAE, 0x68, 0x0F, 0xC6, 0x6F, 0x89, + 0xD5, 0x5C, 0xE2, 0xE9, 0x2F, 0x95, 0x3E, 0x11, + 0x61, 0xB6, 0x78, 0x9F, 0x6F, 0x27, 0x22, 0xF0, + 0x09, 0x7B, 0x2B, 0x6A, 0xEB, 0xEA, 0x92, 0x2D + }, + { + 0x99, 0xF1, 0x3B, 0x3A, 0xA3, 0x20, 0x03, 0xF3, + 0xF6, 0x47, 0x40, 0xCC, 0x74, 0x85, 0x38, 0x7C, + 0x8E, 0xE3, 0x47, 0x1A, 0x71, 0x8E, 0x10, 0x45, + 0x53, 0x15, 0x4B, 0xE7, 0x72, 0xFF, 0x80, 0xF2, + 0x25, 0x31, 0xF5, 0x28, 0x04, 0xCD, 0x53, 0x3E, + 0x56, 0xCD, 0x83, 0x94, 0x46, 0xF8, 0x59, 0xBE, + 0xFC, 0xD5, 0x87, 0x26, 0xA1, 0x35, 0x3D, 0x50, + 0x4F, 0xC1, 0x3A, 0x2D, 0x52, 0x71, 0xFE, 0x7F + }, + { + 0xE6, 0xA2, 0x22, 0x03, 0x47, 0x31, 0xE1, 0x8C, + 0xB8, 0x73, 0xB9, 0x75, 0x45, 0x47, 0xB0, 0x6A, + 0xD4, 0xCB, 0x72, 0xD6, 0xF8, 0xFB, 0x0F, 0xD1, + 0xEF, 0xEE, 0xC8, 0x21, 0x99, 0x1D, 0xF8, 0x7D, + 0x52, 0x09, 0x70, 0x77, 0xD9, 0xAF, 0x37, 0xB6, + 0xAF, 0xE4, 0x85, 0x0C, 0x16, 0x36, 0xC6, 0x3E, + 0xCF, 0x66, 0xF4, 0x9C, 0xDA, 0x08, 0x9A, 0xDC, + 0x54, 0x16, 0x2C, 0xBD, 0x72, 0x50, 0x96, 0x2E + }, + { + 0xE6, 0x0A, 0xB7, 0xB5, 0xF7, 0x0A, 0x78, 0x7B, + 0x67, 0x12, 0xF0, 0x7B, 0x15, 0xEC, 0xD6, 0xF1, + 0xA9, 0x19, 0x9C, 0x70, 0x50, 0xBC, 0xDC, 0xAB, + 0x34, 0x30, 0xB5, 0xCE, 0x16, 0xBC, 0x84, 0xF3, + 0x99, 0xAC, 0x8F, 0x14, 0x8E, 0x43, 0xA9, 0x5C, + 0x43, 0xBB, 0xDB, 0x42, 0x0E, 0x19, 0x45, 0xAF, + 0xAD, 0x69, 0xFB, 0x57, 0xA7, 0xD2, 0x75, 0xB3, + 0xA4, 0x1E, 0xBD, 0x0B, 0xA2, 0x45, 0xC3, 0xC8 + }, + { + 0x41, 0x96, 0xD1, 0x61, 0x54, 0xC8, 0xC3, 0xC8, + 0x3E, 0xF8, 0x0C, 0x6A, 0x2B, 0x96, 0x00, 0xA0, + 0x95, 0x84, 0x58, 0x97, 0x4C, 0x8B, 0x6E, 0x52, + 0xF1, 0x55, 0xBD, 0x37, 0x62, 0xF2, 0x5A, 0x36, + 0xED, 0x12, 0x19, 0x2E, 0x62, 0xA8, 0x37, 0xCF, + 0x70, 0x5D, 0x08, 0x7D, 0x13, 0x12, 0x86, 0xD3, + 0xBB, 0x55, 0x69, 0x9C, 0x18, 0x1A, 0xCF, 0x0C, + 0xF4, 0x11, 0x11, 0x09, 0x5B, 0x81, 0x94, 0x9A + }, + { + 0x82, 0x90, 0x8C, 0x10, 0x7C, 0x5B, 0x34, 0xBF, + 0xF2, 0xAE, 0xF3, 0x76, 0xD3, 0x4B, 0x12, 0x99, + 0xDC, 0xB4, 0x3C, 0x28, 0x03, 0x0E, 0xB1, 0x2C, + 0x0E, 0xB3, 0x08, 0x00, 0xF7, 0x40, 0xD7, 0xF5, + 0x7C, 0x27, 0x10, 0x1C, 0x12, 0x8A, 0x8B, 0x59, + 0xEC, 0xF9, 0x3D, 0x28, 0xA4, 0x48, 0xE1, 0x71, + 0xA0, 0xA9, 0x43, 0x66, 0xC7, 0xDD, 0xFC, 0x53, + 0xA4, 0x3C, 0xE4, 0x5E, 0xD1, 0x9B, 0x17, 0x83 + }, + { + 0xDB, 0x3C, 0xDF, 0xA1, 0x07, 0x84, 0xB6, 0xE5, + 0x4F, 0xBE, 0x08, 0x66, 0x8A, 0x91, 0x31, 0xB3, + 0xF5, 0x64, 0xB8, 0xAC, 0xC5, 0x0D, 0x02, 0x48, + 0x3A, 0x14, 0x81, 0x41, 0xBE, 0x00, 0x7B, 0xF4, + 0x05, 0x47, 0xA9, 0x2F, 0x2C, 0x83, 0x3D, 0xE9, + 0x44, 0xB9, 0x28, 0x03, 0x3F, 0x1B, 0x8D, 0x81, + 0xF1, 0x2B, 0xE9, 0x82, 0x4F, 0x74, 0x88, 0xEE, + 0x60, 0xD4, 0xA0, 0x14, 0x3C, 0x05, 0xD2, 0x83 + }, + { + 0xA7, 0x64, 0x52, 0x2A, 0x42, 0x06, 0x24, 0xBE, + 0x99, 0x2A, 0x4D, 0xDD, 0xCB, 0xC6, 0x32, 0x09, + 0x10, 0xC8, 0xA3, 0xE2, 0x1B, 0xC6, 0xD9, 0x5B, + 0x95, 0x93, 0x8F, 0x44, 0x11, 0xA7, 0xCC, 0x2F, + 0x6D, 0x46, 0x99, 0x69, 0x57, 0xB8, 0x90, 0x3E, + 0xC4, 0x1C, 0x43, 0x33, 0xE5, 0x63, 0x6C, 0xE6, + 0x30, 0xD1, 0x1B, 0x44, 0xF2, 0xDC, 0x4B, 0xB6, + 0x85, 0x28, 0x5A, 0xBB, 0x6A, 0x5C, 0x4D, 0xDC + }, + { + 0x67, 0xFB, 0x31, 0x56, 0x45, 0xA5, 0xC0, 0x72, + 0x69, 0x5A, 0xCC, 0xE3, 0x00, 0x0F, 0x26, 0xFE, + 0x65, 0x6F, 0x9D, 0x8A, 0x2A, 0x16, 0x15, 0xA7, + 0x60, 0xFA, 0x5D, 0xB1, 0xA8, 0xE2, 0x19, 0xD9, + 0xDD, 0x33, 0xA9, 0x6B, 0xD6, 0xEE, 0x92, 0x61, + 0x86, 0x38, 0xED, 0x21, 0xA3, 0x5A, 0xF2, 0x98, + 0xD0, 0x37, 0xEE, 0x37, 0xD0, 0x94, 0x11, 0x07, + 0x78, 0x84, 0xE1, 0xBC, 0x72, 0x17, 0x2C, 0x90 + }, + { + 0xDA, 0x2A, 0x16, 0x10, 0xCE, 0x80, 0x40, 0x91, + 0x56, 0x26, 0x4D, 0x81, 0x6F, 0x55, 0xE0, 0xA7, + 0x73, 0xD6, 0xC5, 0xF9, 0xF6, 0x71, 0x27, 0xF5, + 0x43, 0xB4, 0x30, 0x88, 0x72, 0x9A, 0x43, 0x8B, + 0xAB, 0xD8, 0x98, 0x32, 0xA3, 0x50, 0xA0, 0x59, + 0xB2, 0xC5, 0xAD, 0xDD, 0xF8, 0x35, 0x01, 0xA7, + 0xF7, 0x79, 0x2E, 0x07, 0xBD, 0x48, 0x6F, 0xD9, + 0x46, 0xDC, 0x3A, 0x04, 0xEF, 0x01, 0x2E, 0x2C + }, + { + 0x83, 0x58, 0x69, 0xEB, 0xB4, 0x95, 0x40, 0x3A, + 0xFF, 0xD7, 0xC5, 0xBF, 0xD7, 0x40, 0xD5, 0x0E, + 0x35, 0x44, 0x6C, 0xCB, 0xA5, 0xAF, 0x92, 0x0E, + 0xB4, 0x68, 0x49, 0xD1, 0x42, 0x96, 0x7C, 0xFA, + 0xB9, 0x5C, 0x80, 0x06, 0x23, 0xA9, 0xA0, 0xA6, + 0x96, 0x1B, 0x96, 0x38, 0x06, 0xFC, 0xA2, 0x27, + 0x30, 0x17, 0x5B, 0xE7, 0xDF, 0x36, 0x03, 0x70, + 0x2E, 0x52, 0x60, 0x37, 0x11, 0xC5, 0xC1, 0xC1 + }, + { + 0x3B, 0x47, 0x23, 0xE2, 0xBF, 0xD4, 0x32, 0x56, + 0xAC, 0x2A, 0x2B, 0x80, 0x8F, 0x2E, 0x79, 0x9A, + 0xE7, 0x62, 0x41, 0x6F, 0xB5, 0x5E, 0x06, 0x5A, + 0xFC, 0x85, 0xAD, 0x09, 0x9A, 0xFE, 0x61, 0x0D, + 0xF1, 0x0E, 0xC0, 0x7A, 0x59, 0x00, 0x41, 0x98, + 0xA6, 0x9F, 0x08, 0xF9, 0x9C, 0x6B, 0x05, 0x50, + 0xF5, 0x07, 0xE7, 0xD5, 0x9E, 0xA6, 0x4F, 0xA2, + 0x88, 0x93, 0x63, 0xD0, 0xDA, 0x70, 0x6E, 0x8F + }, + { + 0xB9, 0x45, 0x4B, 0x8A, 0x95, 0xCA, 0xCC, 0x23, + 0xC3, 0xBD, 0xFA, 0x4B, 0x0C, 0xFA, 0x5B, 0x92, + 0xE9, 0x07, 0x50, 0x04, 0x00, 0x14, 0x2C, 0x06, + 0xA9, 0x94, 0x75, 0x80, 0x18, 0xA4, 0x60, 0xF5, + 0x8C, 0x6A, 0x59, 0x62, 0x1B, 0xFF, 0x0C, 0x73, + 0xBC, 0xC4, 0x5F, 0x05, 0x60, 0x1F, 0x41, 0xBB, + 0x81, 0x6F, 0x32, 0xC2, 0xE3, 0xA5, 0x3C, 0xBE, + 0x7D, 0x08, 0x9C, 0xC8, 0xC7, 0xD0, 0x1F, 0xA5 + }, + { + 0x44, 0x73, 0x68, 0x80, 0x34, 0x30, 0xBD, 0x3A, + 0xB0, 0x50, 0x5C, 0x90, 0x48, 0xC0, 0x8F, 0xD3, + 0xC5, 0xDD, 0xD1, 0x3D, 0x2A, 0x01, 0x7C, 0xA0, + 0x56, 0xEB, 0x4E, 0x76, 0xAB, 0x45, 0xE9, 0x3B, + 0x6D, 0x18, 0xC5, 0x7C, 0x05, 0xCD, 0x97, 0xA4, + 0xD4, 0x4D, 0x35, 0x7C, 0x69, 0x2A, 0xA0, 0x47, + 0x62, 0xE2, 0x31, 0x6E, 0x3A, 0x6C, 0xF5, 0x0C, + 0xE4, 0x63, 0x56, 0x49, 0x7D, 0xB6, 0x91, 0xB0 + }, + { + 0x5B, 0x04, 0x7A, 0x49, 0xDC, 0x12, 0x7F, 0x64, + 0x7A, 0x65, 0x18, 0x22, 0xB3, 0xCB, 0x8C, 0xE4, + 0x55, 0x4D, 0xDC, 0x58, 0x25, 0x2D, 0xBC, 0xEE, + 0x63, 0x85, 0x80, 0x8F, 0xB5, 0x44, 0x01, 0x97, + 0xF4, 0x95, 0xE5, 0xC5, 0x19, 0x5F, 0x90, 0x7F, + 0x5A, 0x37, 0x7F, 0x89, 0x5B, 0x19, 0xD7, 0x9B, + 0x7E, 0xBE, 0x26, 0xBA, 0x42, 0xB3, 0x62, 0xA9, + 0xAC, 0x7F, 0xB7, 0x5F, 0xAC, 0xA6, 0xBB, 0xC0 + }, + { + 0x9A, 0x1C, 0xD3, 0xC5, 0x93, 0x68, 0x84, 0xC8, + 0x8C, 0x5A, 0x39, 0x8C, 0x73, 0x61, 0xC1, 0x5B, + 0xE5, 0xCC, 0x90, 0x96, 0x68, 0x39, 0x70, 0x6B, + 0xA8, 0x2F, 0x3B, 0x93, 0x75, 0x19, 0x0F, 0x5B, + 0x15, 0xAF, 0x53, 0x64, 0x2D, 0x4B, 0xE5, 0x54, + 0xE9, 0xAA, 0x61, 0x45, 0x0C, 0x23, 0x7E, 0xF7, + 0x3E, 0x29, 0xFC, 0x07, 0xFF, 0xE7, 0xB6, 0x62, + 0x4D, 0x3C, 0xF1, 0x71, 0xCE, 0xCE, 0x25, 0x7F + }, + { + 0xB4, 0x7F, 0x75, 0xC0, 0xE2, 0x9C, 0xD5, 0x27, + 0x93, 0x45, 0xBB, 0xFF, 0xED, 0x08, 0x73, 0x75, + 0x1C, 0xEC, 0xEC, 0xDB, 0xC3, 0xCC, 0xB9, 0xF6, + 0xAC, 0x3D, 0xCC, 0xB6, 0xB5, 0x1E, 0x72, 0xB9, + 0x8D, 0x6D, 0x4A, 0xDD, 0x54, 0x08, 0x70, 0x9F, + 0x27, 0xB2, 0x95, 0x2D, 0xEA, 0x9C, 0x41, 0x49, + 0xDB, 0xDB, 0x42, 0x25, 0x6B, 0x7B, 0xC0, 0xF1, + 0xA0, 0xB0, 0xB0, 0x9F, 0x76, 0x34, 0x7F, 0xC8 + }, + { + 0x63, 0xDA, 0x5A, 0x88, 0x54, 0x6A, 0xCC, 0xA4, + 0xCE, 0x68, 0xAE, 0x39, 0xC3, 0x02, 0x5D, 0x83, + 0x5B, 0x18, 0xDE, 0x5F, 0x30, 0xCC, 0x46, 0x2B, + 0x6D, 0x1A, 0x7C, 0xC8, 0x83, 0x26, 0x9D, 0xF7, + 0x26, 0xCD, 0x41, 0x9D, 0x8F, 0xF6, 0xC9, 0xD1, + 0xC2, 0x37, 0x66, 0x34, 0x1E, 0xD5, 0xB6, 0xCC, + 0xD5, 0x41, 0x57, 0x9A, 0xC4, 0x01, 0x3E, 0x18, + 0x38, 0x35, 0xC2, 0x05, 0xCC, 0xFE, 0xED, 0xBD + }, + { + 0x38, 0x2F, 0x31, 0x0E, 0x1C, 0x5E, 0xA9, 0x03, + 0x4B, 0x0B, 0xB1, 0xF1, 0xC6, 0x00, 0x07, 0xE8, + 0x77, 0x89, 0x9C, 0x3D, 0xE1, 0x7E, 0x80, 0xC0, + 0x69, 0xC1, 0x62, 0x0B, 0x5F, 0x28, 0xE4, 0x40, + 0x26, 0x5A, 0x81, 0x8E, 0x47, 0x7C, 0x6F, 0x45, + 0xF7, 0x6F, 0xBE, 0x7B, 0x04, 0x1F, 0xC1, 0x02, + 0x29, 0x1D, 0x85, 0x38, 0x8B, 0x6B, 0xFC, 0x8E, + 0x06, 0x59, 0x68, 0x06, 0x2E, 0x86, 0x76, 0x2C + }, + { + 0x9F, 0x81, 0x7A, 0x38, 0xE3, 0x8A, 0x3B, 0x69, + 0x19, 0x4A, 0x81, 0x5D, 0x01, 0x28, 0x22, 0x4F, + 0x66, 0xE7, 0xCA, 0x8A, 0xB5, 0xE7, 0x6A, 0xBF, + 0xF5, 0x02, 0x48, 0x66, 0x97, 0xCA, 0x7C, 0xBF, + 0x4D, 0x1F, 0xCE, 0xDE, 0x71, 0xFA, 0x5C, 0x52, + 0x2E, 0xF2, 0xE5, 0x35, 0xE6, 0x8D, 0x32, 0x2F, + 0xF9, 0x3E, 0x59, 0x4E, 0xA9, 0x4D, 0xBE, 0x0A, + 0x8A, 0x87, 0xDB, 0x0D, 0xF5, 0x69, 0x9C, 0x14 + }, + { + 0xFD, 0x5C, 0x6F, 0x02, 0xE0, 0x9F, 0x4E, 0x4F, + 0xA3, 0x64, 0x66, 0x37, 0x8D, 0x96, 0x2D, 0x8B, + 0x4B, 0x85, 0x7C, 0xF3, 0xA7, 0x7C, 0x93, 0xC3, + 0x1D, 0xEE, 0x1C, 0xD5, 0xFF, 0x34, 0x9C, 0xF0, + 0x53, 0x84, 0x35, 0x51, 0x6B, 0x3A, 0x58, 0x72, + 0x96, 0xA5, 0xCA, 0x08, 0xD7, 0x4C, 0xE8, 0x3B, + 0x4A, 0x65, 0x51, 0xBD, 0xC5, 0xC8, 0xE5, 0xE3, + 0xBA, 0x79, 0x0C, 0xCF, 0xAB, 0x11, 0x8E, 0x03 + }, + { + 0x2E, 0xEA, 0x11, 0x15, 0x6A, 0xB8, 0xFC, 0x9B, + 0x08, 0x2D, 0x90, 0xA4, 0xB5, 0x59, 0x53, 0x20, + 0xEF, 0xAE, 0x35, 0x3A, 0x34, 0x8A, 0x65, 0x2F, + 0xE8, 0x60, 0xB6, 0x7E, 0xDC, 0x42, 0xE3, 0x8B, + 0xD0, 0xD2, 0x00, 0xA5, 0xAC, 0x69, 0x22, 0xCB, + 0xC3, 0x26, 0xB0, 0x0D, 0x78, 0x2C, 0x89, 0x35, + 0x9C, 0x97, 0x74, 0xC1, 0x5E, 0x35, 0x67, 0x77, + 0xC8, 0x55, 0x01, 0xFF, 0x13, 0x58, 0xB5, 0x77 + }, + { + 0xCD, 0xB4, 0x27, 0x7A, 0xE0, 0x1B, 0xF5, 0x92, + 0xB3, 0x58, 0x3B, 0xB2, 0x35, 0x8A, 0xC5, 0xFB, + 0x6E, 0xC3, 0x34, 0x50, 0x8E, 0x64, 0xEC, 0x6E, + 0xCA, 0xC5, 0xCC, 0x0E, 0xE4, 0xB5, 0xC1, 0x60, + 0x14, 0x12, 0x0E, 0xD8, 0x1E, 0x88, 0x5B, 0x69, + 0xE3, 0x56, 0x83, 0x3F, 0x68, 0xD7, 0xB0, 0x0B, + 0xE6, 0xF3, 0xEB, 0x42, 0xE9, 0x42, 0x5F, 0x38, + 0x07, 0x77, 0xB9, 0xB1, 0x1A, 0x7F, 0x0C, 0x35 + }, + { + 0x94, 0x56, 0x2D, 0x4A, 0xE3, 0x70, 0x86, 0xA3, + 0x82, 0x06, 0x1E, 0x68, 0xD9, 0x1D, 0x7E, 0x31, + 0x26, 0xBD, 0x72, 0x50, 0x30, 0x73, 0x19, 0x95, + 0xC0, 0x97, 0x8A, 0x8D, 0xE4, 0x46, 0xCA, 0x3F, + 0x29, 0x7E, 0x61, 0x39, 0x76, 0x65, 0xDD, 0xD7, + 0x30, 0xC6, 0x10, 0xAB, 0x96, 0x45, 0x7B, 0x4E, + 0x7D, 0xBA, 0x2F, 0x7C, 0x5F, 0x65, 0x60, 0xB6, + 0x2C, 0xD1, 0x13, 0x0F, 0xFA, 0x8C, 0xDD, 0x43 + }, + { + 0x5D, 0x55, 0xF5, 0xE4, 0xDD, 0xFD, 0xC6, 0x3B, + 0x3A, 0x93, 0xAD, 0x76, 0x6E, 0xAE, 0xB2, 0x52, + 0x10, 0xBA, 0xDE, 0xA5, 0x2C, 0x0D, 0xDA, 0xDA, + 0xF8, 0x71, 0x90, 0xD7, 0x39, 0xBB, 0xFC, 0xFB, + 0x1C, 0x08, 0x4C, 0x5F, 0x7C, 0xB0, 0xDD, 0x6B, + 0xC0, 0xCB, 0x40, 0x22, 0x0A, 0x8C, 0x97, 0x30, + 0xCC, 0x16, 0xC1, 0x74, 0x36, 0x5B, 0x88, 0x23, + 0x97, 0xAD, 0x7C, 0x96, 0x50, 0x5F, 0x69, 0x91 + }, + { + 0x17, 0xB4, 0x82, 0x9B, 0x39, 0x7E, 0x18, 0x37, + 0x09, 0xE6, 0x80, 0x1C, 0xE5, 0xAB, 0x5A, 0x14, + 0xAA, 0xC0, 0x1E, 0x82, 0x0D, 0xF7, 0x9B, 0xFA, + 0xCD, 0xEA, 0xB8, 0x19, 0x8E, 0xE7, 0xDF, 0xC7, + 0x05, 0x0D, 0xA1, 0xB4, 0xD5, 0x8F, 0x1B, 0xEA, + 0x0F, 0x8E, 0x4A, 0x17, 0x54, 0xFB, 0x7C, 0x47, + 0x1F, 0x68, 0x32, 0xC8, 0xBC, 0xD6, 0x78, 0xBD, + 0xC9, 0xBF, 0x19, 0x33, 0xCE, 0x12, 0x29, 0xA5 + }, + { + 0xDE, 0x3F, 0x0A, 0xDD, 0x75, 0x99, 0x43, 0xD9, + 0x27, 0xEE, 0x28, 0xA4, 0x91, 0xC0, 0x80, 0x08, + 0x64, 0xD6, 0x89, 0x92, 0x4E, 0x6C, 0x10, 0xF9, + 0x94, 0x63, 0x9B, 0x6D, 0xAF, 0x82, 0x75, 0x9A, + 0xA8, 0x2E, 0xB8, 0x27, 0x44, 0xE6, 0x6D, 0xE2, + 0xB0, 0xB6, 0xD6, 0xC5, 0xBC, 0x25, 0x40, 0x6B, + 0x85, 0xB0, 0x0D, 0x38, 0x8B, 0x65, 0x1C, 0xCD, + 0x81, 0xFC, 0x03, 0xB9, 0x18, 0xCC, 0x3D, 0x64 + }, + { + 0xF9, 0x5B, 0x99, 0x89, 0x60, 0xFF, 0xFD, 0x58, + 0x2C, 0x47, 0xC2, 0x0F, 0xFB, 0x6F, 0xD9, 0x47, + 0x18, 0x1C, 0xCF, 0x74, 0xC5, 0xB1, 0x80, 0x5D, + 0xA0, 0xB8, 0xA3, 0x7E, 0xDB, 0xE4, 0x9E, 0x91, + 0xE6, 0x1D, 0xCB, 0x79, 0xC6, 0xC4, 0x3D, 0x3E, + 0x60, 0xF3, 0x97, 0x9D, 0x91, 0xCF, 0xB2, 0x2E, + 0xFE, 0x97, 0x8E, 0xD9, 0x6E, 0x4C, 0x71, 0x42, + 0xA8, 0xDA, 0x79, 0x47, 0x41, 0xF3, 0x04, 0xD6 + }, + { + 0x0C, 0x6B, 0x45, 0xAD, 0x00, 0x42, 0xB0, 0x72, + 0xE3, 0x97, 0xC4, 0x45, 0x21, 0xB5, 0xB5, 0xC8, + 0x04, 0xAE, 0x7E, 0xF4, 0x54, 0x6D, 0x0D, 0xCB, + 0x79, 0x30, 0x50, 0x13, 0xA2, 0x59, 0x9C, 0x98, + 0x69, 0x2A, 0xF4, 0x35, 0x64, 0x44, 0x61, 0x69, + 0xEB, 0x80, 0xF8, 0x7C, 0xDF, 0x16, 0xE4, 0xA6, + 0x4A, 0x97, 0x12, 0xB6, 0x1D, 0xF9, 0xA8, 0xFA, + 0x0D, 0x73, 0x36, 0x68, 0x9E, 0xED, 0x32, 0x26 + }, + { + 0xE8, 0x34, 0x96, 0x55, 0x51, 0x48, 0x56, 0x38, + 0xAA, 0x8F, 0x57, 0xED, 0x79, 0x05, 0x4F, 0x1A, + 0xAB, 0xAA, 0xA4, 0x4D, 0x2B, 0xA0, 0x9C, 0x7C, + 0xCC, 0x31, 0x4D, 0xA8, 0x3E, 0x01, 0x08, 0xFD, + 0xB5, 0x89, 0x20, 0x10, 0xE8, 0x61, 0x25, 0xBF, + 0x0B, 0x08, 0xA9, 0x25, 0xAE, 0x7D, 0x83, 0x59, + 0x01, 0x67, 0xE0, 0xC6, 0xAE, 0x1D, 0x99, 0x22, + 0x92, 0x5F, 0xDB, 0x50, 0x10, 0xBB, 0x82, 0x77 + }, + { + 0xCB, 0xCA, 0xBF, 0xB5, 0x3E, 0x5F, 0xB6, 0x89, + 0x18, 0x77, 0x20, 0xAB, 0xF4, 0x09, 0xBB, 0xC2, + 0xDC, 0x90, 0x66, 0x7F, 0x5F, 0x7B, 0xF8, 0x75, + 0xFE, 0x58, 0xF7, 0xD5, 0x6E, 0x68, 0xB3, 0x8F, + 0x33, 0xE6, 0xE5, 0x38, 0xEE, 0xF6, 0xB7, 0x90, + 0xCA, 0x1E, 0xD8, 0x32, 0xF7, 0xF9, 0xB9, 0x6A, + 0x9D, 0x57, 0xCE, 0x1D, 0x56, 0xD3, 0xB0, 0xAE, + 0x7B, 0xDD, 0x85, 0x6F, 0xE2, 0x8A, 0xE3, 0xCB + }, + { + 0x6D, 0xC0, 0x06, 0x5A, 0x49, 0x12, 0x21, 0xEB, + 0x21, 0x16, 0x73, 0x5C, 0xB3, 0x3F, 0x1E, 0x04, + 0x04, 0x21, 0xA7, 0xBD, 0xB9, 0x8C, 0x2E, 0x7C, + 0x8D, 0xBD, 0xC2, 0x0B, 0x48, 0x0D, 0x77, 0x9B, + 0x66, 0x74, 0xE7, 0xCB, 0x35, 0x50, 0x31, 0x87, + 0x4B, 0x6C, 0x97, 0xB8, 0x95, 0xDB, 0xCB, 0xB8, + 0x9F, 0x44, 0x99, 0x37, 0x03, 0xE6, 0xB3, 0x2B, + 0xA2, 0x58, 0xE8, 0x29, 0x00, 0x94, 0x7C, 0x6C + }, + { + 0xA9, 0x8F, 0x0D, 0xDA, 0x49, 0x59, 0xFF, 0xD0, + 0xD6, 0x90, 0x15, 0x99, 0xA9, 0xE7, 0x63, 0xD1, + 0xEA, 0x88, 0xFC, 0x00, 0x6E, 0x25, 0xB7, 0xD4, + 0xE1, 0x13, 0x2B, 0xF2, 0xBD, 0x14, 0x68, 0x6D, + 0xDC, 0x89, 0x15, 0xA8, 0x90, 0x1A, 0xA6, 0x19, + 0x13, 0xDE, 0xAE, 0x6E, 0x4D, 0xEC, 0xD5, 0x6E, + 0x08, 0xC3, 0x0D, 0x23, 0x8E, 0x6A, 0xF8, 0x99, + 0xA5, 0x34, 0x31, 0x7D, 0x20, 0x9E, 0xDE, 0xD4 + }, + { + 0x5A, 0x44, 0xD3, 0x7D, 0xF7, 0x8B, 0xFD, 0x24, + 0xED, 0x5B, 0xFC, 0x54, 0xD3, 0x63, 0x41, 0xBC, + 0x8F, 0xB0, 0x26, 0x09, 0x5E, 0xE7, 0xF8, 0x3A, + 0x66, 0x08, 0xE1, 0x04, 0xE0, 0xDF, 0xE9, 0x2D, + 0x24, 0x7A, 0x7F, 0x79, 0x43, 0x20, 0x70, 0xEB, + 0x11, 0x3F, 0xD5, 0xE5, 0xDF, 0x32, 0xD1, 0x3B, + 0x7F, 0x0E, 0xAD, 0xD3, 0xC0, 0x54, 0x84, 0x85, + 0x82, 0x83, 0xC3, 0x65, 0x24, 0x71, 0x43, 0x0F + }, + { + 0x4A, 0x92, 0xE9, 0x59, 0xC7, 0xE9, 0x1C, 0x89, + 0xEF, 0x6C, 0xB0, 0x5D, 0xFF, 0x4A, 0x29, 0xCB, + 0x4A, 0xE7, 0x4A, 0xD4, 0x5C, 0x08, 0x81, 0xEC, + 0x3E, 0x16, 0xDE, 0x78, 0x37, 0x90, 0x64, 0x5D, + 0xA2, 0xBF, 0x1D, 0x99, 0x8C, 0x7A, 0x24, 0xF5, + 0x71, 0xF1, 0x58, 0x5B, 0xB8, 0x27, 0x31, 0xBA, + 0xB9, 0xAD, 0x10, 0x1C, 0xAA, 0x08, 0x89, 0x80, + 0xC3, 0x54, 0x20, 0x6A, 0xEB, 0xB2, 0x80, 0xA5 + }, + { + 0x95, 0x53, 0xA5, 0x25, 0x40, 0x71, 0x38, 0xE1, + 0x9D, 0x82, 0xE9, 0x6C, 0xD9, 0xDD, 0x5B, 0x1D, + 0x3B, 0x52, 0xFB, 0x35, 0x9D, 0xFA, 0x1F, 0x9D, + 0x34, 0x2F, 0xE0, 0xF6, 0x3F, 0x48, 0xA5, 0x2A, + 0x00, 0x07, 0x5F, 0xA6, 0x79, 0x29, 0x5D, 0x27, + 0x54, 0xB2, 0xF6, 0x12, 0x87, 0x22, 0xEC, 0xFE, + 0xF6, 0x4E, 0x89, 0xA8, 0x77, 0x5C, 0xE0, 0x55, + 0xB4, 0xD3, 0x9A, 0xF3, 0x57, 0x49, 0x59, 0xD4 + }, + { + 0x32, 0x64, 0xCA, 0x63, 0xC2, 0x50, 0xE4, 0xED, + 0xE3, 0xC0, 0x58, 0x8B, 0xD2, 0x2C, 0x30, 0xE1, + 0xA2, 0x00, 0xB3, 0xE9, 0xE4, 0xA7, 0xBD, 0x32, + 0xB6, 0xF7, 0x39, 0x20, 0x7E, 0x01, 0x37, 0x16, + 0x56, 0xCB, 0xC9, 0x6E, 0xDB, 0xFA, 0xF6, 0x29, + 0xB0, 0xD0, 0x49, 0x24, 0xD2, 0x7B, 0x4A, 0x1F, + 0x44, 0xA7, 0xC6, 0xA9, 0xCE, 0xFB, 0x35, 0x6E, + 0xC6, 0x28, 0xAB, 0x89, 0xEA, 0x93, 0x86, 0x1C + }, + { + 0x4F, 0x78, 0x42, 0x05, 0x7A, 0x8C, 0xF5, 0xA9, + 0xA9, 0x10, 0xF2, 0x6F, 0xE4, 0xE8, 0x86, 0x5F, + 0xF4, 0x4C, 0xA1, 0x94, 0x7C, 0xE7, 0xE2, 0xA4, + 0xFB, 0x3E, 0x06, 0x63, 0xD0, 0x22, 0x88, 0xF2, + 0xAD, 0x27, 0xAE, 0x36, 0x0F, 0xFA, 0xDA, 0x04, + 0x15, 0x76, 0x53, 0xED, 0x2F, 0xDE, 0x7B, 0x73, + 0x39, 0xA3, 0xC7, 0x00, 0xB4, 0x11, 0x38, 0x86, + 0x8B, 0xCC, 0x67, 0xB9, 0xAD, 0x17, 0xF5, 0xB5 + }, + { + 0xF4, 0x59, 0xA2, 0xEA, 0xE5, 0x86, 0xAC, 0xC5, + 0x9B, 0x72, 0xD1, 0x17, 0xCE, 0xF8, 0xB6, 0x5C, + 0xFE, 0x37, 0x2D, 0x40, 0x7D, 0x39, 0x46, 0xB8, + 0xD6, 0xD8, 0xF4, 0xF8, 0xE8, 0x7C, 0xFF, 0x13, + 0xBD, 0xF9, 0xDA, 0x46, 0x32, 0x3F, 0x4E, 0x58, + 0x68, 0x93, 0xBF, 0x6C, 0xFE, 0xCE, 0x66, 0xB6, + 0x5B, 0x6D, 0x6D, 0x99, 0xED, 0x87, 0x93, 0x13, + 0x8E, 0xEA, 0x1E, 0x85, 0xEC, 0x16, 0x9F, 0x17 + }, + { + 0xE3, 0xF3, 0x60, 0xDC, 0xCE, 0xC3, 0x82, 0x25, + 0x1F, 0x8A, 0x2B, 0x3C, 0x8D, 0x31, 0xD3, 0xF8, + 0xBB, 0x92, 0x41, 0x71, 0xC4, 0xE9, 0x0B, 0xF2, + 0xD3, 0x05, 0x07, 0xB3, 0xDF, 0xDB, 0xD4, 0x4A, + 0x9A, 0xAF, 0xD2, 0x57, 0x71, 0x04, 0x70, 0xE2, + 0x78, 0x2D, 0x7A, 0xEF, 0x07, 0xF5, 0x15, 0xAD, + 0x84, 0xDC, 0x73, 0x2C, 0xE8, 0x5B, 0x31, 0x35, + 0xA4, 0xEA, 0x5B, 0xE2, 0xBB, 0x47, 0x59, 0x8F + }, + { + 0xF6, 0x3C, 0x1A, 0x10, 0xA3, 0x4C, 0xDC, 0x92, + 0x8A, 0xF1, 0x8A, 0x0A, 0xA0, 0xDD, 0xF7, 0x80, + 0xFA, 0xFD, 0x12, 0xA9, 0x67, 0xA8, 0x41, 0x75, + 0xAF, 0x93, 0x1C, 0x4B, 0xC1, 0x35, 0x70, 0x54, + 0xA6, 0x1A, 0x33, 0x43, 0xD0, 0x34, 0x65, 0xFA, + 0xC3, 0x14, 0x91, 0x78, 0x6B, 0xB0, 0x03, 0x67, + 0x72, 0x50, 0x02, 0x9F, 0x17, 0xF4, 0x2E, 0xD0, + 0xCE, 0x67, 0x90, 0xB9, 0xC0, 0x9F, 0x00, 0x31 + }, + { + 0x18, 0x1B, 0x78, 0x3B, 0xE2, 0xA6, 0x83, 0xD7, + 0xE8, 0x01, 0x0A, 0xCA, 0x35, 0x4C, 0x03, 0xB4, + 0xD6, 0x5A, 0xD6, 0xCC, 0xA6, 0xA8, 0xEC, 0xC0, + 0xF2, 0x84, 0x91, 0x9E, 0x5E, 0x29, 0xBE, 0xC1, + 0x13, 0x84, 0x34, 0xAF, 0xF2, 0xB7, 0x01, 0xDC, + 0x4D, 0x44, 0x57, 0x3C, 0xA4, 0xD9, 0x34, 0xC6, + 0x57, 0x49, 0x3C, 0x2A, 0x7A, 0x52, 0xC9, 0x70, + 0x86, 0x6C, 0x29, 0x98, 0xF0, 0xC4, 0x0E, 0xA0 + }, + { + 0x3E, 0xCF, 0xEA, 0x02, 0x8E, 0x13, 0xA1, 0x6A, + 0x7F, 0x2D, 0x11, 0x88, 0xA7, 0xDD, 0xD7, 0xDA, + 0x38, 0xA2, 0x6C, 0x7C, 0x07, 0x8C, 0x1F, 0x1D, + 0xD0, 0xC5, 0x75, 0x9D, 0xE2, 0x7F, 0xAC, 0xA2, + 0x35, 0x95, 0xFB, 0xD5, 0x13, 0xC3, 0x69, 0x50, + 0x9B, 0x88, 0x51, 0x13, 0xEB, 0x68, 0x89, 0xCB, + 0x0A, 0x17, 0x22, 0x8B, 0xDD, 0xF1, 0xB5, 0xFD, + 0x6B, 0x25, 0x57, 0xF6, 0x5E, 0xAB, 0xCF, 0xCF + }, + { + 0x85, 0x7D, 0x3E, 0x21, 0x4E, 0x92, 0x32, 0x51, + 0xEF, 0x98, 0x8B, 0xE5, 0x48, 0xBF, 0xED, 0xE8, + 0x7D, 0x44, 0x88, 0x8D, 0x31, 0xD3, 0x05, 0x23, + 0xA9, 0xFC, 0x5D, 0x85, 0x41, 0x39, 0xCF, 0xC9, + 0x28, 0x0B, 0x4E, 0x32, 0x72, 0x60, 0x53, 0x4B, + 0x67, 0x19, 0xA9, 0x33, 0x99, 0x8D, 0x26, 0x67, + 0x00, 0x2C, 0x84, 0x17, 0x14, 0xF3, 0x91, 0x46, + 0xAE, 0xFB, 0xC7, 0x47, 0x51, 0x86, 0x67, 0xCC + }, + { + 0x15, 0xC5, 0x5C, 0xDD, 0xF8, 0xF5, 0xE5, 0x70, + 0xCC, 0xA0, 0x31, 0x1E, 0xC2, 0x00, 0x6A, 0xDB, + 0xC7, 0xB8, 0x78, 0x2D, 0xEC, 0xA4, 0x93, 0x10, + 0x90, 0x94, 0xC7, 0x12, 0x4F, 0xC8, 0xB0, 0x91, + 0xA2, 0x50, 0x5F, 0x63, 0x83, 0x54, 0xE2, 0xF7, + 0xAA, 0xFF, 0x51, 0x28, 0x40, 0xD8, 0x9C, 0x28, + 0x31, 0x1B, 0x15, 0x13, 0xFA, 0x16, 0xBD, 0x37, + 0x48, 0x95, 0xCE, 0x52, 0x20, 0xDF, 0x20, 0xDE + }, + { + 0x4B, 0x32, 0xA1, 0x91, 0xB2, 0x70, 0x27, 0xE2, + 0x3F, 0x93, 0xB1, 0x7D, 0xC5, 0xE8, 0xE9, 0x3D, + 0x96, 0x53, 0xF8, 0xFE, 0x48, 0xBF, 0xA9, 0x13, + 0xDE, 0xB8, 0xBF, 0x4C, 0x52, 0x20, 0x1A, 0x00, + 0x78, 0x22, 0xE3, 0xEF, 0x40, 0xA1, 0xBE, 0x3B, + 0xFE, 0x91, 0xE1, 0x53, 0x6C, 0x0C, 0x6D, 0x8E, + 0x5C, 0x64, 0x01, 0x58, 0xB2, 0x85, 0xDA, 0x60, + 0x2E, 0x88, 0x6C, 0xFA, 0x5C, 0x60, 0xCB, 0x99 + }, + { + 0x86, 0x7B, 0x10, 0xB6, 0x46, 0xCA, 0x75, 0x33, + 0x31, 0x7B, 0x53, 0xAB, 0xCB, 0x81, 0x85, 0xF2, + 0xAD, 0x0D, 0x3C, 0xF9, 0x75, 0x08, 0x33, 0x7E, + 0x7A, 0x58, 0x3A, 0x51, 0xC3, 0x8D, 0x71, 0x09, + 0x94, 0x4F, 0x4B, 0xB0, 0x22, 0x40, 0x70, 0x9B, + 0x84, 0x3E, 0x70, 0xDF, 0x69, 0xD5, 0x66, 0x4A, + 0x4A, 0x07, 0x45, 0x9B, 0xD7, 0x3B, 0x27, 0x5F, + 0x11, 0x83, 0x58, 0x1F, 0x84, 0x97, 0xC0, 0xE8 + }, + { + 0x92, 0xE1, 0xEB, 0x5A, 0xD5, 0xD4, 0x00, 0x3E, + 0x57, 0xF5, 0x36, 0xE0, 0xE4, 0x95, 0x3F, 0x91, + 0xDB, 0xD4, 0xA6, 0x57, 0x3A, 0xAB, 0x4B, 0x32, + 0x9B, 0xC8, 0xFB, 0x1F, 0x7D, 0xC1, 0xDB, 0xD8, + 0xC7, 0x13, 0x19, 0x9C, 0x15, 0xFE, 0x8C, 0x4F, + 0xE2, 0x33, 0x6D, 0x0C, 0x73, 0x0B, 0x6B, 0xC7, + 0x7D, 0x8F, 0x66, 0xEB, 0xB5, 0xFC, 0x4B, 0xF0, + 0xDC, 0xB1, 0x6A, 0xC5, 0xEB, 0x57, 0x6F, 0xB2 + }, + { + 0x39, 0x93, 0xCE, 0xDD, 0x33, 0x33, 0x60, 0x45, + 0xE8, 0xE6, 0x40, 0xB3, 0x68, 0x4B, 0x43, 0x65, + 0x56, 0xBA, 0x72, 0xC0, 0x53, 0x91, 0xA7, 0x31, + 0x52, 0x04, 0xA1, 0x7F, 0x2F, 0x3D, 0x13, 0x0A, + 0xCE, 0xEF, 0x1D, 0x77, 0x19, 0xC3, 0x03, 0x01, + 0x3F, 0xEF, 0x41, 0x2F, 0x83, 0x9F, 0x40, 0x70, + 0xD7, 0xDF, 0x67, 0xAB, 0xAB, 0x62, 0xF3, 0xF3, + 0xF8, 0x9A, 0x79, 0x8D, 0xBC, 0x41, 0x13, 0x62 + }, + { + 0x9B, 0x59, 0xA4, 0x91, 0x10, 0xDC, 0x46, 0xB7, + 0x8C, 0x5B, 0x7E, 0x2D, 0x28, 0x2E, 0x85, 0xEE, + 0x76, 0xD2, 0xEB, 0x59, 0xCD, 0xB6, 0x92, 0xE8, + 0x57, 0xF9, 0xDF, 0x46, 0xF8, 0x76, 0x3C, 0x2B, + 0x4D, 0x9D, 0x38, 0x12, 0xFB, 0x94, 0x25, 0x5E, + 0x9E, 0xFF, 0x10, 0x43, 0x6D, 0xF9, 0x46, 0x9A, + 0x46, 0x1D, 0x1B, 0x5B, 0x98, 0xAB, 0xDD, 0xBF, + 0x6F, 0x71, 0x81, 0xF3, 0x2C, 0xF8, 0xBE, 0x13 + }, + { + 0x74, 0xF6, 0x70, 0xE8, 0x67, 0xD0, 0x1D, 0x52, + 0xA3, 0x14, 0xB0, 0x36, 0x53, 0xBE, 0xCC, 0xF3, + 0xA7, 0xED, 0xCF, 0xE9, 0xB8, 0x09, 0xCD, 0x80, + 0x62, 0x26, 0x33, 0x33, 0x71, 0xFB, 0xFE, 0x63, + 0x6F, 0xEC, 0x05, 0xFE, 0xDA, 0xF4, 0x91, 0xA3, + 0x59, 0x6B, 0x01, 0xC6, 0xF3, 0xF4, 0xA2, 0x37, + 0x00, 0x26, 0xAF, 0xB1, 0x8B, 0xB4, 0x75, 0xBF, + 0x32, 0xE0, 0x4D, 0xE7, 0x90, 0x33, 0x1E, 0xB3 + }, + { + 0x49, 0x80, 0x68, 0xB1, 0xC4, 0x00, 0x5E, 0x31, + 0x7B, 0xFB, 0x9B, 0x4A, 0x01, 0x78, 0x07, 0x29, + 0x28, 0xFA, 0xF8, 0xDF, 0xB8, 0x7D, 0x72, 0xB3, + 0xFD, 0x27, 0x2A, 0x14, 0x2C, 0x6E, 0x33, 0x7B, + 0x79, 0x38, 0x27, 0x19, 0x2F, 0x37, 0x52, 0xDB, + 0x8B, 0xF9, 0xB4, 0x60, 0x55, 0x63, 0xCF, 0xF1, + 0xE8, 0xF8, 0x74, 0x3D, 0x95, 0x4C, 0x89, 0x4B, + 0x94, 0x0D, 0x23, 0xAE, 0x7C, 0xD4, 0xDC, 0x1A + }, + { + 0x56, 0x1C, 0xC2, 0x3E, 0xE2, 0x5E, 0x14, 0x64, + 0xB6, 0x05, 0xA9, 0x46, 0x3E, 0x94, 0xF8, 0xE1, + 0xD5, 0x2A, 0x63, 0x00, 0xFE, 0x29, 0x73, 0x43, + 0x20, 0x75, 0xA5, 0x76, 0x6E, 0xE4, 0x24, 0xA0, + 0x21, 0x41, 0x4F, 0x67, 0xB3, 0x4B, 0x9E, 0x61, + 0xBF, 0x3D, 0xDB, 0x96, 0x13, 0x18, 0xDB, 0x8E, + 0x65, 0x68, 0xF0, 0xB5, 0xDA, 0xFF, 0xA5, 0x0B, + 0x7E, 0xD2, 0x39, 0x7F, 0x13, 0xF9, 0x6C, 0x95 + }, + { + 0xF0, 0x80, 0x8D, 0xFD, 0x5C, 0x3E, 0x78, 0x90, + 0x54, 0xD1, 0x6F, 0x40, 0x99, 0xC6, 0x38, 0x6A, + 0xB9, 0x9F, 0xDF, 0x88, 0x45, 0x49, 0x0B, 0x14, + 0x62, 0x84, 0x42, 0xB8, 0x29, 0x0A, 0x37, 0xA4, + 0x5A, 0xD5, 0x91, 0xD2, 0xCC, 0x89, 0x80, 0x96, + 0xC1, 0xBD, 0x2A, 0x43, 0x90, 0x7A, 0xB0, 0xDE, + 0xD5, 0xA7, 0x73, 0xCA, 0xA7, 0xDF, 0x83, 0x05, + 0x8E, 0xC8, 0x50, 0xAA, 0x20, 0x4E, 0x22, 0xE2 + }, + { + 0x81, 0xB9, 0xFA, 0xCB, 0x52, 0xA8, 0x45, 0x18, + 0x83, 0x37, 0x27, 0xFA, 0xA4, 0x03, 0x51, 0xCC, + 0xAC, 0x1E, 0x79, 0xF5, 0xCA, 0xCF, 0xEE, 0x9E, + 0x6A, 0x46, 0xFD, 0x05, 0xC5, 0x72, 0x6C, 0x6F, + 0xAD, 0x5B, 0x8F, 0xA4, 0xF0, 0x9F, 0x02, 0x3D, + 0xDD, 0x1C, 0xA1, 0xB9, 0xF2, 0x94, 0x8F, 0x52, + 0x6B, 0x9C, 0x34, 0x85, 0x3D, 0x53, 0x2E, 0xAC, + 0xC7, 0x65, 0xC1, 0xD0, 0x81, 0xEB, 0x30, 0xA7 + }, + { + 0x3D, 0x11, 0x1C, 0xC3, 0xA5, 0x57, 0x1B, 0xAF, + 0xB8, 0xBC, 0x09, 0xFB, 0xE6, 0xED, 0x66, 0xD9, + 0x7B, 0x8F, 0xCE, 0xE9, 0xA4, 0x9C, 0xD3, 0x15, + 0xD6, 0x26, 0x9A, 0xEF, 0x9A, 0xED, 0x1F, 0x7F, + 0x96, 0x86, 0xEA, 0xEC, 0x48, 0xEE, 0x0A, 0xBA, + 0xAA, 0x34, 0xE4, 0xD5, 0x08, 0x62, 0xC9, 0x8F, + 0x90, 0x8E, 0x60, 0xCC, 0x03, 0x6C, 0x87, 0x8E, + 0x0E, 0x5F, 0xE9, 0x81, 0x0B, 0x97, 0x4A, 0x5D + }, + { + 0xF2, 0xCC, 0xE4, 0xC1, 0xB9, 0x9C, 0x90, 0x57, + 0x88, 0x97, 0xEB, 0x0E, 0xE7, 0x39, 0x67, 0xDD, + 0x80, 0x71, 0xA8, 0xA1, 0xFD, 0xF0, 0xCD, 0xCC, + 0x55, 0x47, 0x1D, 0x99, 0x4E, 0xEF, 0xB3, 0x68, + 0x9E, 0xFD, 0xB8, 0x78, 0x7F, 0xEB, 0x66, 0xA9, + 0x1E, 0xC8, 0x16, 0xDB, 0x35, 0xA8, 0x09, 0x00, + 0xB0, 0x4F, 0xF1, 0x74, 0x94, 0x6E, 0x28, 0x52, + 0x59, 0x18, 0x8B, 0xBF, 0x97, 0x0F, 0x0B, 0x92 + }, + { + 0xBC, 0xED, 0x61, 0xF8, 0xC8, 0x5A, 0x28, 0x84, + 0xC7, 0xB7, 0x08, 0xA2, 0x72, 0xD2, 0xB9, 0xDA, + 0x9B, 0x01, 0xBA, 0x6F, 0xE0, 0x7B, 0xAD, 0xB7, + 0xAA, 0xCA, 0xB1, 0x76, 0x6A, 0xBF, 0xC5, 0x8E, + 0xB1, 0x08, 0xB1, 0x65, 0x78, 0x5A, 0xB0, 0xCF, + 0x23, 0x27, 0x97, 0xF0, 0xA5, 0x01, 0x2F, 0x78, + 0xD5, 0xA8, 0x58, 0xD8, 0x51, 0x79, 0x84, 0xED, + 0xE8, 0x1A, 0x43, 0x01, 0x1D, 0xB7, 0xFD, 0x3C + }, + { + 0x4D, 0x35, 0x3B, 0xA2, 0xA2, 0xB4, 0x23, 0x56, + 0xD7, 0x3F, 0x3D, 0x87, 0x6C, 0x97, 0x90, 0x3F, + 0xF4, 0xD4, 0x4A, 0x87, 0xAC, 0xE1, 0x64, 0x6E, + 0x89, 0x8B, 0x76, 0x00, 0xD1, 0x04, 0x8F, 0x41, + 0x58, 0xE0, 0xF9, 0x74, 0xC5, 0x3A, 0xAB, 0x3F, + 0x30, 0x56, 0xC8, 0x42, 0x47, 0xF9, 0x91, 0x3D, + 0x7B, 0x7D, 0x73, 0x7A, 0xE9, 0x6F, 0x3B, 0x21, + 0x0F, 0x9D, 0x5F, 0x09, 0xDD, 0x1D, 0x18, 0x40 + }, + { + 0xAE, 0xC3, 0x77, 0x07, 0x77, 0x2D, 0xAF, 0x3E, + 0xDE, 0xF7, 0x95, 0x71, 0x3A, 0x84, 0xC4, 0x0C, + 0xCA, 0x86, 0xEF, 0xBD, 0x8A, 0x50, 0x4D, 0x5B, + 0xA3, 0xAF, 0x02, 0xEF, 0x73, 0x87, 0x00, 0x1D, + 0x3B, 0x96, 0x19, 0xA5, 0x5B, 0x91, 0x79, 0x0E, + 0xD0, 0xDC, 0xA5, 0xE4, 0x14, 0x62, 0xDE, 0x85, + 0x93, 0x77, 0xE7, 0xCC, 0x59, 0x00, 0x9F, 0x78, + 0xE8, 0x71, 0xED, 0x24, 0xA2, 0xCE, 0x4A, 0xF1 + }, + { + 0x28, 0xE5, 0x74, 0xF2, 0x83, 0x5C, 0xDE, 0x8E, + 0x28, 0xD3, 0xB0, 0x9D, 0xC7, 0x2B, 0xEC, 0x34, + 0x9B, 0x34, 0xD2, 0xA3, 0xA8, 0x8B, 0xB5, 0xBB, + 0x57, 0x07, 0x14, 0x2B, 0x26, 0x79, 0x41, 0x66, + 0xA5, 0x47, 0x7B, 0x13, 0xB4, 0x0D, 0x47, 0x5A, + 0xC7, 0x0C, 0xB1, 0xD3, 0xB9, 0xA9, 0xCA, 0x6C, + 0x29, 0x9B, 0x61, 0x2C, 0x0E, 0xA5, 0x18, 0xB1, + 0xDE, 0x5C, 0xC6, 0x6A, 0x58, 0x0E, 0xC5, 0xD5 + }, + { + 0x3B, 0x76, 0x8A, 0x24, 0xBF, 0x30, 0xDA, 0xEA, + 0x4E, 0xA9, 0xBF, 0x95, 0xDA, 0xD5, 0x03, 0x68, + 0x0E, 0x89, 0x59, 0xA9, 0xCB, 0x58, 0x99, 0x03, + 0x6F, 0x60, 0x5D, 0x62, 0x1A, 0x3A, 0xEC, 0xC3, + 0xBC, 0x3E, 0x12, 0x9E, 0x47, 0x92, 0x74, 0x8A, + 0x58, 0x37, 0x5D, 0x55, 0xEC, 0x23, 0x3F, 0x11, + 0x70, 0xD9, 0x6E, 0x4D, 0x13, 0x3A, 0xC4, 0xDF, + 0xB9, 0xC9, 0x9C, 0x53, 0x25, 0x1C, 0x47, 0xD6 + }, + { + 0x78, 0x70, 0xB2, 0xE0, 0x2E, 0x55, 0x60, 0x8A, + 0x9C, 0xE4, 0xD2, 0x52, 0xCE, 0x6B, 0x39, 0x3A, + 0x95, 0xCB, 0x89, 0xAC, 0xFA, 0x6C, 0xFE, 0x23, + 0xFB, 0x8C, 0xFA, 0xF4, 0x18, 0xF6, 0x22, 0xA7, + 0x0B, 0x42, 0xCF, 0x0B, 0xFE, 0x44, 0x44, 0x82, + 0x45, 0xC2, 0xEC, 0x71, 0x6D, 0x79, 0xD9, 0x4C, + 0xC3, 0x42, 0x53, 0xEA, 0x64, 0xB4, 0x44, 0x26, + 0xD4, 0xC9, 0xD6, 0x35, 0xF2, 0x99, 0x11, 0x19 + }, + { + 0x77, 0x88, 0x19, 0x6C, 0x61, 0xE7, 0x65, 0xD3, + 0x96, 0x8A, 0x13, 0xB6, 0x91, 0x24, 0xD3, 0x61, + 0xB0, 0x40, 0x9E, 0xDC, 0x8D, 0x3B, 0x3A, 0x02, + 0x0C, 0x97, 0x29, 0x0B, 0x40, 0x96, 0x7F, 0xB4, + 0x44, 0x9B, 0x43, 0xE3, 0x89, 0xE7, 0xD3, 0x21, + 0x21, 0xF7, 0x83, 0x56, 0xB5, 0x84, 0x16, 0x16, + 0x56, 0xA6, 0x0B, 0x7F, 0x56, 0x5D, 0x6F, 0x1F, + 0x4A, 0xEC, 0x52, 0x33, 0x7D, 0x21, 0x27, 0x27 + }, + { + 0x26, 0xC6, 0x7A, 0x34, 0xD5, 0x1A, 0x95, 0x45, + 0x57, 0x2F, 0xA1, 0x12, 0x09, 0x69, 0x1E, 0x5C, + 0x80, 0x88, 0xF0, 0x2D, 0xDD, 0x1D, 0x6A, 0xF4, + 0xC2, 0xEC, 0xCB, 0xFF, 0xA2, 0x34, 0xE6, 0x8A, + 0xFB, 0x7F, 0x5B, 0xA7, 0x2E, 0x36, 0x53, 0xE8, + 0x34, 0x0F, 0xD4, 0x48, 0xE5, 0x8A, 0xB7, 0x5E, + 0x7C, 0x25, 0xD6, 0x1F, 0x03, 0x06, 0x3F, 0xA1, + 0xA7, 0x67, 0x07, 0x99, 0x60, 0x5B, 0x60, 0x1D + }, + { + 0xDC, 0x25, 0xCC, 0xCB, 0x86, 0x5B, 0x67, 0x96, + 0x28, 0x64, 0x68, 0x9B, 0x89, 0x26, 0xDF, 0xB0, + 0x30, 0xFF, 0x35, 0x58, 0xE0, 0x97, 0xCF, 0xEF, + 0xEC, 0x33, 0x64, 0x84, 0xE9, 0x5D, 0x63, 0x1B, + 0x35, 0xBF, 0x09, 0x58, 0xC0, 0xA3, 0x1E, 0x0B, + 0xF4, 0x5B, 0x90, 0xB3, 0x2E, 0xA3, 0x06, 0x6F, + 0xD3, 0x11, 0x5F, 0x50, 0x48, 0x4A, 0x8E, 0xED, + 0xCC, 0x99, 0xB5, 0x97, 0xAB, 0x26, 0xAF, 0x97 + }, + { + 0xFE, 0x78, 0x73, 0x81, 0xCE, 0x0E, 0x36, 0xA7, + 0x8C, 0x32, 0x8F, 0x55, 0x3B, 0xC8, 0xC8, 0x98, + 0x04, 0x87, 0x16, 0x15, 0x61, 0x8F, 0x97, 0x8A, + 0xA3, 0x3B, 0xD8, 0x8E, 0x83, 0xFE, 0x79, 0x4E, + 0xA7, 0x69, 0x23, 0x9D, 0xC3, 0x67, 0xE7, 0x2E, + 0x99, 0xC8, 0xEC, 0x48, 0xF3, 0x32, 0x7A, 0xC6, + 0x14, 0xA8, 0x2C, 0xA5, 0x09, 0x1F, 0x73, 0xAC, + 0x30, 0x08, 0xB5, 0x98, 0x69, 0xF3, 0x2E, 0xA3 + }, + { + 0xB5, 0x58, 0xD9, 0xFD, 0xAF, 0xC3, 0x07, 0xB3, + 0x8F, 0x93, 0x62, 0x1E, 0xFD, 0x10, 0x30, 0x33, + 0x99, 0xAF, 0x1E, 0x6D, 0x09, 0x08, 0x1F, 0x5E, + 0xFC, 0x96, 0x28, 0x70, 0x8C, 0x05, 0x17, 0x3D, + 0xEA, 0x45, 0x19, 0xBF, 0xAF, 0x48, 0x3F, 0x9F, + 0x41, 0xD6, 0x49, 0xF2, 0x96, 0xC7, 0xC3, 0x79, + 0xB3, 0xFE, 0x1E, 0xFE, 0x54, 0x7F, 0x23, 0xE6, + 0xB5, 0xC7, 0xA1, 0xBD, 0xE7, 0x8D, 0xC5, 0x58 + }, + { + 0x3F, 0xE7, 0xCB, 0x10, 0x8F, 0x4B, 0x8F, 0x7E, + 0x95, 0x59, 0x93, 0x2A, 0x8B, 0xC0, 0x50, 0x4E, + 0xE4, 0xC8, 0x86, 0xBB, 0x7F, 0xDF, 0xEE, 0xE3, + 0xAE, 0x55, 0x6A, 0xB0, 0x65, 0x0A, 0xFA, 0x89, + 0x54, 0x6F, 0x65, 0xFB, 0xA9, 0x1E, 0xF8, 0xC7, + 0xAB, 0xCC, 0xA5, 0xD0, 0x41, 0x07, 0x39, 0x41, + 0x20, 0x26, 0xFF, 0x0C, 0x08, 0xFA, 0xB4, 0xDA, + 0x52, 0x49, 0x42, 0xB6, 0xC7, 0x24, 0xE9, 0x4C + }, + { + 0x2E, 0xDA, 0xAA, 0x47, 0x1F, 0x07, 0xFE, 0x03, + 0x62, 0x76, 0x89, 0x48, 0xE5, 0xB0, 0x71, 0x0E, + 0xD1, 0xA6, 0xEA, 0x75, 0x7D, 0xEA, 0x5D, 0x9B, + 0x90, 0xFF, 0xD6, 0x7C, 0x95, 0x13, 0x22, 0x23, + 0xF0, 0x94, 0xBC, 0x69, 0xBF, 0xC9, 0xC4, 0xA7, + 0x73, 0x60, 0x74, 0x43, 0xB6, 0x19, 0x94, 0x10, + 0x48, 0x32, 0x46, 0x04, 0x16, 0x6E, 0x35, 0x7C, + 0x27, 0xDC, 0x50, 0xB1, 0x1B, 0x84, 0xE0, 0x12 + }, + { + 0x8F, 0xEC, 0x7F, 0x45, 0x30, 0x0E, 0x8E, 0xE8, + 0x30, 0x0C, 0xAB, 0xA0, 0x51, 0x76, 0x66, 0x23, + 0xB9, 0x5F, 0x52, 0xE8, 0x89, 0xF8, 0x8C, 0x2A, + 0xD0, 0x1B, 0x7B, 0x3A, 0x62, 0x05, 0x94, 0x71, + 0x9A, 0x1C, 0xDB, 0x23, 0xD5, 0x63, 0x22, 0x3E, + 0x19, 0xEC, 0x08, 0xE8, 0xFC, 0xAB, 0xAB, 0x5A, + 0xCF, 0x2C, 0x1B, 0x7F, 0x6F, 0xE5, 0x19, 0xD5, + 0x05, 0x59, 0xCF, 0x3D, 0x03, 0x51, 0x34, 0xF6 + }, + { + 0x47, 0xC3, 0x84, 0x10, 0x1A, 0x6B, 0xDB, 0x24, + 0xC5, 0xD0, 0xF4, 0xC9, 0x7B, 0x31, 0x6C, 0x3B, + 0x91, 0x55, 0x8D, 0xF1, 0x38, 0x4D, 0x91, 0x09, + 0xAB, 0xFF, 0xB9, 0x31, 0x78, 0x83, 0x8A, 0x97, + 0xFC, 0x7D, 0x85, 0x39, 0x8A, 0xA4, 0xB4, 0x69, + 0xB9, 0x01, 0x94, 0x34, 0xAF, 0x40, 0x8F, 0xB9, + 0x5A, 0x10, 0xFF, 0x65, 0xF7, 0xBB, 0x0B, 0xC8, + 0x9E, 0x7C, 0x8B, 0xDB, 0x85, 0xB3, 0x40, 0xD3 + }, + { + 0x5A, 0x96, 0x79, 0x6E, 0xA6, 0xC1, 0xB7, 0x5B, + 0xE2, 0x52, 0xE1, 0xB4, 0x3C, 0xAE, 0xE3, 0x20, + 0xBE, 0xD4, 0x76, 0x85, 0x7F, 0x2A, 0xDB, 0x32, + 0x3B, 0x4E, 0x67, 0x79, 0xB5, 0x8D, 0xFB, 0x0D, + 0xF6, 0xFA, 0xC9, 0xD0, 0x59, 0x4A, 0xF7, 0x0F, + 0xDA, 0x50, 0x64, 0x58, 0xC7, 0x1A, 0x9F, 0xE3, + 0xA2, 0xCF, 0x99, 0xFA, 0x06, 0xFF, 0x95, 0xBC, + 0xC7, 0x14, 0xAC, 0xCE, 0x39, 0x09, 0xCD, 0x2B + }, + { + 0x6C, 0xC0, 0xD9, 0xBC, 0x6D, 0x2C, 0x32, 0x1B, + 0x81, 0x46, 0x13, 0x2E, 0xD2, 0x63, 0xAF, 0x91, + 0xEC, 0x64, 0x23, 0x64, 0x21, 0x74, 0x39, 0x44, + 0x78, 0x97, 0x61, 0x2A, 0x2F, 0xAB, 0x61, 0x20, + 0xF0, 0x0E, 0x0A, 0xAF, 0x0C, 0x8E, 0x2C, 0x4C, + 0x72, 0xFF, 0x11, 0x4F, 0x14, 0x78, 0xB3, 0xD6, + 0x80, 0x52, 0xE5, 0xE0, 0xEA, 0xFE, 0xD9, 0x2B, + 0x54, 0x82, 0x65, 0xCA, 0x9B, 0x87, 0xB6, 0xB7 + }, + { + 0x0E, 0x27, 0xEA, 0xBA, 0x4E, 0xDF, 0xF7, 0xB7, + 0x76, 0xCD, 0xAC, 0xCA, 0xC4, 0xCC, 0xA2, 0x82, + 0x1B, 0x3E, 0xC0, 0x96, 0xC6, 0x59, 0xEA, 0xC5, + 0xD5, 0x22, 0xE5, 0xDA, 0x21, 0x50, 0xFE, 0x27, + 0x33, 0xC3, 0x5C, 0xBA, 0xC2, 0x75, 0xDE, 0xA6, + 0x1A, 0x09, 0x2D, 0xE9, 0x2F, 0x0D, 0xE0, 0x3D, + 0x57, 0x79, 0x16, 0xF2, 0x17, 0x97, 0xBE, 0x77, + 0xB0, 0x78, 0x66, 0x92, 0xEF, 0xD8, 0x03, 0x7E + }, + { + 0x08, 0x5E, 0xBF, 0x55, 0x07, 0xEB, 0x90, 0x83, + 0xC2, 0xBD, 0x01, 0xEF, 0x76, 0xA7, 0xC2, 0xF8, + 0xE3, 0x05, 0x57, 0x71, 0x04, 0xE5, 0xCD, 0xA0, + 0x29, 0x10, 0x9F, 0x3A, 0x20, 0x1B, 0xE3, 0xC3, + 0x22, 0x3F, 0x54, 0xF0, 0x60, 0xEC, 0x3D, 0x9E, + 0xC1, 0xAC, 0xF6, 0x4F, 0x4F, 0xE9, 0x87, 0xBF, + 0x00, 0x24, 0xD2, 0x75, 0x87, 0xE9, 0xEE, 0x56, + 0xDC, 0xC5, 0xD3, 0x38, 0x73, 0xB9, 0x18, 0xAC + }, + { + 0xCE, 0x4E, 0x7C, 0xED, 0xB2, 0xDF, 0x07, 0x29, + 0x35, 0x21, 0xD9, 0x91, 0x3C, 0x37, 0xD1, 0x35, + 0x07, 0x47, 0x01, 0x9D, 0x36, 0xE2, 0x97, 0x69, + 0xF0, 0xF8, 0x54, 0xA2, 0xF5, 0xA5, 0x81, 0x5B, + 0xC3, 0x2C, 0x9A, 0x40, 0xAA, 0xD4, 0xD1, 0x8B, + 0xF5, 0xF9, 0x71, 0x94, 0x07, 0x71, 0x9D, 0xAB, + 0x23, 0x00, 0x75, 0xC5, 0x0A, 0x70, 0xBC, 0xE6, + 0xE7, 0x4E, 0xA6, 0x7F, 0x7A, 0x2C, 0x17, 0x2E + }, + { + 0x32, 0x5C, 0x2D, 0x76, 0x62, 0x7B, 0x22, 0x20, + 0x72, 0x79, 0x62, 0x32, 0x6C, 0xFA, 0x1C, 0xF8, + 0x9F, 0x25, 0x72, 0x89, 0x99, 0x45, 0x1B, 0x46, + 0x69, 0xAE, 0xCB, 0x9B, 0x44, 0xFD, 0x89, 0x6B, + 0x8E, 0x6F, 0x51, 0xA6, 0x10, 0x5E, 0xD3, 0xB4, + 0x5F, 0x15, 0x5B, 0x5B, 0x90, 0x9A, 0x01, 0xC1, + 0xA0, 0x11, 0x41, 0x4B, 0x58, 0xE8, 0x87, 0x88, + 0xD7, 0xE9, 0xC6, 0x90, 0x0D, 0x99, 0xD9, 0x7A + }, + { + 0x95, 0xE1, 0x07, 0x80, 0x9D, 0x8F, 0x6C, 0xF3, + 0xF9, 0x1C, 0xA6, 0xBE, 0xCB, 0x10, 0x75, 0x16, + 0x19, 0x0C, 0xD6, 0xF1, 0x22, 0x30, 0xCE, 0xB9, + 0xA1, 0x74, 0x61, 0xA1, 0xFF, 0x7C, 0xE5, 0x72, + 0xE3, 0x85, 0xEB, 0x87, 0x3A, 0x6F, 0x47, 0x03, + 0x4B, 0x42, 0x84, 0xD3, 0x2D, 0xD3, 0xDB, 0x10, + 0x7E, 0xAC, 0x04, 0xDE, 0xF8, 0xF6, 0x92, 0x93, + 0xEA, 0xFF, 0x51, 0x96, 0x09, 0xC6, 0xD3, 0x32 + }, + { + 0x96, 0xF6, 0xFA, 0x7F, 0x30, 0xDE, 0x9B, 0xC8, + 0xEE, 0x52, 0x3F, 0xC6, 0x2F, 0xE8, 0xE3, 0x44, + 0xEA, 0x65, 0x60, 0x11, 0xD1, 0xA2, 0x8E, 0x71, + 0xEF, 0xB6, 0xBA, 0xDD, 0x59, 0x87, 0x41, 0x29, + 0x75, 0x60, 0x68, 0x44, 0x15, 0xDC, 0x59, 0x94, + 0xC8, 0x05, 0x96, 0x47, 0x91, 0x0B, 0xF3, 0x02, + 0x51, 0xAB, 0xEF, 0x90, 0xAA, 0x23, 0xDA, 0xA7, + 0x22, 0xB6, 0xB4, 0x8B, 0x5E, 0x9C, 0xF0, 0xB2 + }, + { + 0x03, 0xFC, 0xB5, 0x1B, 0x8A, 0x83, 0x6E, 0x12, + 0x9D, 0x19, 0xE3, 0xE2, 0x27, 0x02, 0x70, 0xE7, + 0x8D, 0x2B, 0x55, 0x4F, 0x8E, 0x1C, 0x48, 0x85, + 0xE9, 0x35, 0xB9, 0x23, 0xA5, 0x1F, 0xCF, 0x6F, + 0x0A, 0xEB, 0x8F, 0x9F, 0x6C, 0xEE, 0xE6, 0x5C, + 0x43, 0x74, 0x2E, 0x16, 0x2B, 0x12, 0x75, 0x5A, + 0x2E, 0x02, 0xA1, 0xBD, 0x67, 0x41, 0x58, 0x31, + 0x86, 0x63, 0x04, 0x48, 0x56, 0xC1, 0xBF, 0x1F + }, + { + 0x19, 0x60, 0x6A, 0x34, 0x3B, 0x1F, 0x47, 0xE8, + 0x58, 0x46, 0x27, 0x4B, 0x56, 0x61, 0x91, 0x28, + 0x95, 0xCE, 0x43, 0xFB, 0x48, 0x16, 0x38, 0x3D, + 0x63, 0x20, 0x4A, 0x41, 0xD3, 0x3D, 0x98, 0xAA, + 0x44, 0x6E, 0xDB, 0x2D, 0x64, 0x98, 0xCB, 0xA4, + 0x04, 0xA5, 0x06, 0x74, 0x0A, 0x84, 0xD1, 0x3D, + 0xBF, 0x4D, 0xF0, 0xE0, 0xD9, 0x22, 0x8A, 0x7F, + 0x6D, 0x85, 0x70, 0xAF, 0x50, 0x1F, 0xED, 0x6B + }, + { + 0x39, 0x66, 0x6B, 0x65, 0x74, 0x86, 0x3F, 0x96, + 0x3A, 0x34, 0xC3, 0x6F, 0x51, 0x3E, 0xED, 0x64, + 0x42, 0x35, 0x60, 0xA7, 0x97, 0xE7, 0x4A, 0xCE, + 0xA3, 0x0E, 0xD5, 0x41, 0xCA, 0x9D, 0x54, 0x9E, + 0x50, 0x11, 0x76, 0x14, 0xB9, 0x42, 0x01, 0xBD, + 0x14, 0x4B, 0x1F, 0x3E, 0x5B, 0x46, 0x04, 0x46, + 0xA6, 0xAA, 0xFF, 0x82, 0xA7, 0x13, 0x97, 0xB0, + 0xE8, 0xC8, 0x36, 0x32, 0x3C, 0x78, 0xDE, 0xB1 + }, + { + 0x2D, 0xFE, 0x1D, 0x45, 0xC1, 0x2A, 0x1F, 0x55, + 0x7F, 0x13, 0xB7, 0x53, 0x29, 0xF2, 0x26, 0x2D, + 0xC3, 0xAF, 0xFF, 0x86, 0xA5, 0x1B, 0x0F, 0x67, + 0xCA, 0x59, 0xE9, 0x6B, 0x97, 0xCC, 0xEF, 0x05, + 0x52, 0x69, 0x07, 0x68, 0x08, 0x92, 0x90, 0x22, + 0xE9, 0xBC, 0x96, 0x58, 0xBD, 0x2D, 0xF6, 0x90, + 0x9C, 0xAF, 0x53, 0x0A, 0xA4, 0x62, 0x74, 0xEA, + 0x4D, 0x7B, 0x7E, 0xA8, 0x60, 0xA1, 0xDB, 0x4D + }, + { + 0x30, 0xE5, 0xEA, 0xDB, 0xFE, 0x12, 0x10, 0xD3, + 0x22, 0x0C, 0xC3, 0x8F, 0x77, 0x03, 0x2A, 0x34, + 0xA0, 0xC6, 0x98, 0x8F, 0x3E, 0xCB, 0x4E, 0x3A, + 0xDB, 0x69, 0xE7, 0x75, 0xDA, 0xF8, 0xD9, 0x85, + 0x21, 0x01, 0x6F, 0x84, 0x84, 0x97, 0x33, 0xD6, + 0x9E, 0x22, 0xBA, 0x7B, 0x5C, 0x48, 0x97, 0xFC, + 0x20, 0x8C, 0xBB, 0xB0, 0xC7, 0x12, 0x15, 0xFA, + 0x31, 0x33, 0xA2, 0x70, 0xE8, 0x8C, 0xCF, 0x45 + }, + { + 0xE5, 0x1C, 0xDE, 0x28, 0x2F, 0xBA, 0x0A, 0x83, + 0xA3, 0x90, 0x93, 0xF8, 0xA7, 0x06, 0xF0, 0xFB, + 0x7F, 0x13, 0x97, 0xE4, 0xB4, 0x3A, 0x37, 0x9C, + 0x3C, 0xE0, 0x73, 0xC4, 0xCB, 0xE8, 0x64, 0x00, + 0x86, 0x46, 0x59, 0xFC, 0x11, 0x58, 0xE9, 0xA6, + 0xA2, 0x5D, 0x5A, 0xE8, 0x89, 0xAB, 0xE2, 0x06, + 0x34, 0x99, 0x8B, 0xF7, 0xC1, 0xD9, 0x5E, 0x45, + 0x22, 0x1D, 0xE0, 0xB4, 0x43, 0x67, 0x8F, 0xBB + }, + { + 0x74, 0xCE, 0x42, 0xC3, 0xD7, 0x62, 0xBC, 0xF7, + 0xF5, 0x31, 0x30, 0x67, 0x34, 0x00, 0xA7, 0x1C, + 0x9A, 0xCF, 0x03, 0x35, 0x29, 0xC8, 0x18, 0x7D, + 0x6B, 0x6F, 0xE1, 0xFD, 0x5A, 0xDA, 0x71, 0x64, + 0x57, 0x10, 0xA8, 0x90, 0xFA, 0x80, 0xB2, 0x15, + 0x58, 0x21, 0x1F, 0x55, 0x5A, 0x47, 0x23, 0x66, + 0x23, 0x86, 0xB7, 0xF8, 0x1C, 0xC1, 0x74, 0x31, + 0xFD, 0xB4, 0x4A, 0x82, 0xF0, 0xB4, 0x5C, 0x27 + }, + { + 0xF6, 0xA5, 0x60, 0x20, 0x95, 0x6B, 0x2E, 0xA2, + 0xD2, 0xF0, 0x96, 0x38, 0xB3, 0x1A, 0x10, 0x72, + 0x9E, 0x8E, 0x1B, 0x9C, 0x92, 0x1E, 0x36, 0x1B, + 0x9A, 0x96, 0xF5, 0x09, 0x90, 0xF0, 0x3C, 0xEE, + 0x64, 0x79, 0x88, 0xBD, 0x9E, 0xA9, 0x59, 0x9E, + 0x4D, 0x30, 0xA4, 0xBD, 0x80, 0x0A, 0x2D, 0x41, + 0x95, 0x17, 0x65, 0x1F, 0x8A, 0xC5, 0x7C, 0x71, + 0xDA, 0xD1, 0xC2, 0xDD, 0xD9, 0x84, 0x8B, 0xA4 + }, + { + 0x72, 0x27, 0x0B, 0x3A, 0xC3, 0xEF, 0x34, 0x16, + 0x56, 0xA1, 0xE1, 0x6E, 0xC2, 0x66, 0xCC, 0x0F, + 0x12, 0x01, 0x85, 0x92, 0x43, 0x44, 0x57, 0x2E, + 0xDF, 0x22, 0x06, 0xA0, 0x03, 0x3D, 0x5C, 0xDF, + 0xDA, 0x01, 0xB1, 0x52, 0x69, 0x62, 0x1D, 0xC8, + 0xB0, 0x70, 0x55, 0x4C, 0x6A, 0xE6, 0xA3, 0xB3, + 0xDE, 0x4B, 0x92, 0xE8, 0x7C, 0xE2, 0xA2, 0xEC, + 0x5D, 0xB6, 0xC8, 0x98, 0x27, 0x18, 0x19, 0x64 + }, + { + 0x2A, 0xCC, 0x34, 0xD7, 0xEC, 0x34, 0x35, 0x3F, + 0xEB, 0x2F, 0x2E, 0x3F, 0x58, 0x4C, 0x3C, 0x7A, + 0xB6, 0x7B, 0x14, 0x4F, 0xDA, 0x7C, 0x10, 0x17, + 0x16, 0x3A, 0xCD, 0x41, 0x53, 0x0B, 0x78, 0x22, + 0x67, 0xE4, 0x4D, 0x25, 0xF9, 0x7A, 0x2B, 0x4B, + 0xEF, 0x26, 0xD5, 0x12, 0x77, 0x27, 0xC2, 0xC4, + 0x53, 0x5E, 0x19, 0x5C, 0x74, 0xAD, 0xB8, 0xAE, + 0x86, 0x92, 0x2F, 0x91, 0xB8, 0x68, 0x82, 0xC3 + }, + { + 0x07, 0x21, 0x01, 0x5D, 0x3A, 0x8C, 0xF8, 0x00, + 0xD4, 0x6D, 0xCE, 0x18, 0xF1, 0x1C, 0x4E, 0xFE, + 0x54, 0xBC, 0xA3, 0x08, 0x5D, 0xB0, 0x2D, 0x0B, + 0xBC, 0x24, 0xD8, 0xAD, 0x43, 0x83, 0xC3, 0xB9, + 0x96, 0x7D, 0x34, 0x81, 0x9D, 0x45, 0x6C, 0x04, + 0x23, 0x01, 0x34, 0x8D, 0xD1, 0x4A, 0x91, 0x9D, + 0x5A, 0x76, 0x06, 0xA1, 0xFE, 0x5F, 0x5A, 0x45, + 0xF3, 0x0E, 0x20, 0x5E, 0xC6, 0x84, 0x77, 0xB6 + }, + { + 0x31, 0xDC, 0x72, 0xB1, 0x08, 0x24, 0x70, 0xC5, + 0xD5, 0x58, 0x28, 0x6A, 0xCB, 0x7B, 0x26, 0x80, + 0x97, 0x6D, 0x3A, 0x45, 0xBE, 0xA8, 0x78, 0xD2, + 0x2B, 0x50, 0x94, 0xBF, 0xE8, 0x9A, 0x83, 0x73, + 0x49, 0x5F, 0xEC, 0xAB, 0x8B, 0xCF, 0x42, 0x59, + 0x5B, 0x90, 0x81, 0x9B, 0x1E, 0x87, 0x3D, 0xC0, + 0xAA, 0x3F, 0x50, 0xBF, 0xF0, 0x27, 0x25, 0x98, + 0xA3, 0x55, 0x2F, 0x73, 0xFB, 0xA7, 0xA5, 0x3D + }, + { + 0x05, 0x92, 0xA1, 0xB4, 0x27, 0xF1, 0x39, 0x81, + 0x64, 0x1F, 0x82, 0x07, 0x1D, 0x2D, 0xC5, 0x89, + 0xDA, 0x13, 0xEE, 0xEE, 0xBE, 0x4A, 0xF6, 0x17, + 0x77, 0xC3, 0x0D, 0xB5, 0x1F, 0xDD, 0x85, 0x9F, + 0x99, 0x46, 0xEC, 0xBD, 0x80, 0xEF, 0x3E, 0x67, + 0x05, 0x2E, 0xF4, 0x60, 0xD1, 0x4D, 0x77, 0xD9, + 0x1E, 0xF2, 0x3D, 0x3C, 0x30, 0x11, 0x84, 0xE9, + 0xA0, 0x56, 0x84, 0xA6, 0x9E, 0xC4, 0x05, 0x0A + }, + { + 0xE1, 0xA0, 0x10, 0xAC, 0x89, 0x11, 0x33, 0x12, + 0x58, 0xB7, 0x9F, 0xA5, 0xA5, 0x4F, 0xCE, 0xA4, + 0x1F, 0xFD, 0x03, 0x00, 0x4A, 0xB4, 0x20, 0x22, + 0x13, 0xDC, 0x8F, 0xCE, 0x42, 0x44, 0x88, 0x2B, + 0x92, 0xFA, 0x6C, 0x0F, 0x99, 0x09, 0x44, 0xA2, + 0x17, 0x9A, 0x25, 0xE6, 0x7C, 0xB9, 0xA2, 0xCC, + 0x5C, 0x13, 0x46, 0xD8, 0xDB, 0x1B, 0x99, 0xAF, + 0x85, 0x25, 0xC3, 0x21, 0x64, 0x47, 0xF4, 0xE3 + }, + { + 0x36, 0x18, 0x11, 0xB6, 0x8B, 0xE7, 0x68, 0x87, + 0x18, 0xA2, 0x24, 0x2B, 0x40, 0x98, 0x91, 0x76, + 0x9F, 0x85, 0x22, 0x38, 0x57, 0xBC, 0x30, 0xAF, + 0xE1, 0x07, 0xF6, 0xBA, 0xA4, 0xCE, 0x42, 0x3A, + 0xE7, 0x9A, 0x58, 0xCB, 0x57, 0xCF, 0xA1, 0x4D, + 0x9C, 0x41, 0x87, 0x33, 0x1C, 0x3C, 0xDC, 0xE3, + 0x02, 0x20, 0x68, 0x2C, 0xE5, 0xED, 0x31, 0xD5, + 0xB2, 0xB3, 0xF8, 0x04, 0x30, 0xBD, 0x39, 0x77 + }, + { + 0x74, 0xD0, 0x40, 0x0D, 0xE4, 0x62, 0xF5, 0x35, + 0x67, 0xA5, 0xC4, 0x45, 0xE0, 0x8B, 0xAE, 0x2A, + 0x12, 0x50, 0x1B, 0xA4, 0x45, 0x8C, 0x56, 0x4F, + 0x55, 0x2E, 0x88, 0xAD, 0x48, 0x71, 0xA2, 0x67, + 0x7D, 0x77, 0x26, 0x66, 0x7F, 0xB9, 0xAC, 0xD9, + 0x14, 0x74, 0xA6, 0xCF, 0xB4, 0xA8, 0xA2, 0x14, + 0x8D, 0xFD, 0x39, 0x79, 0xB2, 0xDF, 0x13, 0xD4, + 0x15, 0xEA, 0x31, 0xFB, 0x35, 0xBF, 0x37, 0x43 + }, + { + 0xA7, 0x83, 0xFD, 0x0D, 0x85, 0xA0, 0x36, 0xE7, + 0x2A, 0x08, 0x00, 0x66, 0xE5, 0x44, 0x9F, 0xC3, + 0x2D, 0x25, 0x77, 0xC5, 0xC4, 0x42, 0x2F, 0x6F, + 0xA1, 0xED, 0x50, 0x12, 0x6B, 0x30, 0x29, 0x6B, + 0xE0, 0xBF, 0x40, 0x39, 0x31, 0x31, 0x47, 0x36, + 0xDA, 0x44, 0xDD, 0x11, 0xC1, 0x37, 0xAC, 0x1C, + 0x2B, 0xD3, 0xC0, 0x3C, 0x7C, 0x39, 0x8F, 0xE5, + 0x21, 0xD3, 0x9F, 0xE2, 0x97, 0xA8, 0xF1, 0x81 + }, + { + 0xE4, 0xAC, 0x01, 0xFA, 0xB8, 0x00, 0xDA, 0x4E, + 0xCA, 0x52, 0x77, 0xAF, 0x40, 0x3F, 0xD3, 0x5F, + 0x69, 0x64, 0x17, 0x75, 0x0C, 0x33, 0x75, 0xD5, + 0x19, 0xC9, 0xCD, 0xDA, 0x4C, 0x4D, 0x50, 0x21, + 0x84, 0x31, 0x93, 0x6C, 0x47, 0x16, 0x8E, 0x65, + 0x90, 0x5D, 0x88, 0xB4, 0xBA, 0x77, 0x24, 0x61, + 0x22, 0xD9, 0xF8, 0x5C, 0x17, 0xF7, 0x11, 0xA7, + 0x0B, 0xCF, 0xB7, 0xAE, 0x5C, 0x32, 0xDE, 0xCD + }, + { + 0xE5, 0xD6, 0x72, 0x67, 0x4F, 0x03, 0xAF, 0x40, + 0x72, 0xB4, 0xEA, 0x34, 0xAE, 0xC0, 0x56, 0x82, + 0xDE, 0xB8, 0xD2, 0x08, 0x7E, 0x8C, 0x09, 0xCB, + 0xE5, 0x72, 0x53, 0x64, 0x61, 0xA4, 0xB1, 0x0F, + 0x18, 0xF9, 0x5E, 0xD9, 0x0D, 0xCF, 0x30, 0x3B, + 0xF8, 0x07, 0x09, 0xB5, 0x82, 0x09, 0xFE, 0xF7, + 0xAE, 0x06, 0xCE, 0x9D, 0x30, 0x16, 0x5C, 0x3F, + 0xB7, 0xDD, 0x2B, 0xBA, 0xB2, 0x6F, 0xD3, 0x91 + }, + { + 0x15, 0x9C, 0x2E, 0x23, 0xC0, 0x68, 0x80, 0xD7, + 0x81, 0x21, 0x28, 0x83, 0x93, 0xFC, 0x5A, 0xE8, + 0xFA, 0x8A, 0xF4, 0x5C, 0x87, 0x65, 0x8B, 0x3E, + 0x94, 0xE8, 0x83, 0x3E, 0xF5, 0x55, 0x67, 0xA2, + 0x90, 0x3B, 0x87, 0x48, 0xB1, 0x26, 0x7F, 0x97, + 0x3B, 0xD6, 0x50, 0x41, 0x60, 0x1C, 0x75, 0x02, + 0x04, 0xA2, 0x32, 0xC8, 0xFA, 0x90, 0x51, 0xB0, + 0x0E, 0xFF, 0x44, 0x0B, 0x40, 0x54, 0x7A, 0x0C + }, + { + 0x11, 0x73, 0x47, 0x92, 0x59, 0x00, 0xD3, 0x8F, + 0xA9, 0xD1, 0x71, 0xB9, 0x3E, 0x10, 0xA0, 0x38, + 0xBE, 0xAE, 0xC7, 0x4B, 0xF2, 0x8F, 0xE7, 0xB5, + 0x8C, 0x26, 0x7C, 0x5C, 0x48, 0x25, 0x96, 0x25, + 0x60, 0x03, 0x31, 0xE4, 0x5A, 0xBC, 0xCB, 0x1D, + 0xA2, 0x86, 0xD6, 0x2B, 0x62, 0xBA, 0xB5, 0x4E, + 0x81, 0x92, 0x33, 0x48, 0xAB, 0xDA, 0xD0, 0xF3, + 0xE6, 0x56, 0x6C, 0x9E, 0x45, 0xCA, 0x93, 0xCD + }, + { + 0x13, 0x08, 0xC4, 0x28, 0x64, 0x4C, 0xB9, 0xB8, + 0xEE, 0x66, 0x21, 0x9B, 0x5F, 0xCA, 0x0C, 0x18, + 0xFC, 0xBE, 0xB8, 0x76, 0xE3, 0x12, 0xBF, 0x16, + 0xD2, 0xCE, 0xFC, 0x11, 0x5A, 0x30, 0xCB, 0xA6, + 0x15, 0xDB, 0x96, 0x4C, 0xD3, 0x08, 0xBD, 0x44, + 0x52, 0xCD, 0xBE, 0x7B, 0x47, 0x86, 0x1A, 0x9B, + 0x8B, 0xDF, 0x2B, 0x02, 0xF8, 0x4E, 0x4F, 0x1F, + 0xA0, 0x53, 0xCC, 0x17, 0x0E, 0xA8, 0x4D, 0x23 + }, + { + 0x10, 0xA5, 0x77, 0x08, 0x2A, 0xBF, 0xA9, 0x56, + 0x51, 0xF3, 0xBB, 0x73, 0x79, 0x22, 0xF4, 0x11, + 0x13, 0xD0, 0x76, 0x70, 0x41, 0x11, 0x1D, 0x0C, + 0xD8, 0x29, 0x86, 0x02, 0x96, 0x1D, 0xD2, 0x51, + 0x49, 0x92, 0x14, 0x51, 0x95, 0xEF, 0x28, 0xBF, + 0x39, 0x65, 0xE9, 0x59, 0x3A, 0x59, 0x14, 0xA8, + 0x01, 0x4C, 0x44, 0x54, 0x26, 0x08, 0x85, 0x01, + 0x64, 0x00, 0x39, 0x4D, 0x05, 0x0C, 0x9E, 0x9F + }, + { + 0xED, 0x58, 0xCD, 0x50, 0x71, 0x58, 0xFE, 0x5A, + 0x7B, 0x7D, 0x47, 0xF6, 0x8C, 0xA8, 0x4C, 0x1B, + 0xF3, 0x44, 0x25, 0xAA, 0x0F, 0xD7, 0x44, 0xD2, + 0x62, 0x8B, 0x38, 0x09, 0x09, 0x94, 0x86, 0x36, + 0x5B, 0xB6, 0x3A, 0x9C, 0x42, 0xF1, 0x1B, 0x8C, + 0x6E, 0x07, 0xA7, 0xF9, 0x8C, 0xA6, 0xF4, 0xFE, + 0xD9, 0xE1, 0x5B, 0x45, 0xF9, 0xEC, 0xDA, 0x58, + 0x79, 0xE8, 0x4D, 0x44, 0x9C, 0x2D, 0x5C, 0xC8 + }, + { + 0x34, 0x53, 0x67, 0x94, 0xB6, 0x2C, 0xB8, 0x03, + 0xFE, 0x80, 0x4F, 0xD6, 0x4F, 0x8D, 0x81, 0xC6, + 0x8B, 0xD3, 0x73, 0xD0, 0xE9, 0xD2, 0xCB, 0x68, + 0x0E, 0x31, 0x62, 0x27, 0xD9, 0x9F, 0x93, 0xFF, + 0xAB, 0x95, 0x6A, 0x3F, 0x81, 0xEA, 0x31, 0xE8, + 0x63, 0xF2, 0xDB, 0x02, 0x89, 0x95, 0xDE, 0x13, + 0xEB, 0x06, 0xB8, 0xA4, 0x43, 0xD8, 0xC3, 0x2F, + 0xEB, 0xBF, 0xEB, 0x33, 0xD8, 0xAC, 0x27, 0x50 + }, + { + 0x2D, 0xB7, 0x4B, 0x43, 0xEB, 0x34, 0xD5, 0xB5, + 0x1B, 0xB2, 0xB1, 0x38, 0x38, 0x07, 0x73, 0x97, + 0x20, 0x7D, 0xCE, 0xB9, 0xE7, 0xB5, 0x5D, 0x13, + 0xAC, 0x58, 0x71, 0x5C, 0x99, 0xBB, 0xE5, 0x9F, + 0x77, 0xD3, 0x2A, 0xBA, 0x7A, 0x5A, 0xDD, 0xA2, + 0x30, 0x7C, 0xDA, 0x28, 0x8F, 0xFA, 0xB6, 0x70, + 0x9E, 0x0E, 0xAB, 0x22, 0x89, 0x3A, 0xD6, 0xDE, + 0x3B, 0x86, 0x0D, 0x9D, 0xA2, 0xEA, 0x2B, 0x73 + }, + { + 0x8B, 0x1E, 0xDB, 0x7E, 0x42, 0x97, 0xC8, 0x6A, + 0x27, 0x57, 0x3A, 0xFC, 0x9E, 0x16, 0x58, 0x0F, + 0x85, 0x06, 0x70, 0xE5, 0x8F, 0x7C, 0xE2, 0xE4, + 0x7B, 0xE4, 0x83, 0x04, 0xE7, 0x0B, 0xE1, 0x0A, + 0x49, 0x94, 0xC8, 0x12, 0xE1, 0x29, 0x3E, 0x99, + 0x1A, 0xD8, 0x7E, 0x11, 0x22, 0x53, 0xA1, 0xD9, + 0xE1, 0x30, 0x14, 0x7D, 0x75, 0xDF, 0xB9, 0x6F, + 0x78, 0x99, 0xE2, 0xC4, 0x01, 0xB9, 0xF9, 0xEF + }, + { + 0x56, 0x74, 0x93, 0x3B, 0x00, 0x8F, 0x39, 0xBB, + 0xAD, 0x8C, 0x4A, 0x77, 0xDD, 0x57, 0x2F, 0xCD, + 0xE2, 0x64, 0x97, 0xD2, 0xC7, 0x86, 0xD6, 0x96, + 0xBB, 0xE1, 0x9E, 0x92, 0x66, 0x9D, 0x94, 0x5A, + 0xE3, 0x23, 0x9A, 0x01, 0x23, 0x38, 0xD7, 0x3D, + 0x8F, 0x58, 0x46, 0x40, 0x32, 0x7C, 0x08, 0xED, + 0x4A, 0x94, 0x54, 0x24, 0xDC, 0xE8, 0x04, 0x14, + 0x11, 0x0F, 0x08, 0xEB, 0xAE, 0x55, 0x2C, 0x96 + }, + { + 0x9E, 0x7A, 0x2C, 0x2F, 0x48, 0x4A, 0x87, 0x4C, + 0x5A, 0xC1, 0x8F, 0x22, 0xFF, 0x52, 0x50, 0x0F, + 0x42, 0xFF, 0xE8, 0x3D, 0x73, 0xA4, 0x41, 0x66, + 0x05, 0x34, 0xFC, 0x6B, 0x8A, 0xA7, 0x76, 0x1F, + 0x64, 0x19, 0xBB, 0x69, 0xE4, 0xF1, 0xB2, 0xE9, + 0xD7, 0xFA, 0xDE, 0xE9, 0xD7, 0xB5, 0x9D, 0x34, + 0x68, 0xED, 0x12, 0xFD, 0xDA, 0x9A, 0x98, 0x88, + 0xFC, 0x05, 0x98, 0xCD, 0xEC, 0x29, 0x6A, 0x9C + }, + { + 0xBC, 0x90, 0x74, 0xD4, 0xD1, 0xC5, 0xCC, 0xE4, + 0x9C, 0x28, 0x4B, 0x41, 0xA0, 0xB4, 0xCC, 0xA5, + 0x88, 0x1D, 0x69, 0x25, 0xFB, 0x68, 0x49, 0x62, + 0x51, 0x79, 0xF7, 0x8D, 0x55, 0xDC, 0x1C, 0x40, + 0x46, 0x09, 0x56, 0xDA, 0xF2, 0x33, 0xB7, 0x8D, + 0xE6, 0x62, 0x4A, 0x80, 0xAF, 0x8A, 0xD9, 0xE2, + 0x7C, 0xF2, 0xAB, 0x29, 0x9D, 0xDA, 0x79, 0xDE, + 0xAF, 0x82, 0x5B, 0xD2, 0x2D, 0x67, 0xD7, 0xFE + }, + { + 0xA2, 0x25, 0x3F, 0x2E, 0x75, 0xD8, 0x06, 0x88, + 0x5F, 0xD2, 0x3E, 0x54, 0x8E, 0xBB, 0x11, 0x39, + 0x35, 0x2D, 0x44, 0xBD, 0xCB, 0x68, 0x2F, 0xD5, + 0x2F, 0xCD, 0xA9, 0x61, 0x17, 0xD2, 0x06, 0x8D, + 0x96, 0x6E, 0x4E, 0xE4, 0x9C, 0xB2, 0x80, 0xE6, + 0x1D, 0x08, 0x33, 0x50, 0x51, 0x0C, 0xED, 0xF3, + 0xA1, 0xFE, 0x73, 0x33, 0x15, 0x17, 0x0D, 0x6E, + 0xE3, 0x5A, 0xBD, 0xB5, 0xE9, 0xD7, 0x4B, 0x87 + }, + { + 0xBB, 0xB5, 0x72, 0x03, 0xC0, 0x8F, 0xCC, 0x61, + 0x8D, 0xC0, 0xAB, 0x01, 0x9A, 0x41, 0x68, 0x62, + 0x05, 0x9F, 0xBA, 0x74, 0xF8, 0x8B, 0x81, 0x60, + 0xED, 0xE4, 0xED, 0x69, 0x26, 0x9E, 0x44, 0x9E, + 0xC5, 0x7D, 0x00, 0xA5, 0xF4, 0xCB, 0xD0, 0x78, + 0x16, 0x6B, 0xBB, 0x70, 0xD2, 0xCE, 0xD4, 0xE0, + 0x06, 0x57, 0xD9, 0x7B, 0x13, 0xA6, 0x4C, 0xC1, + 0xE4, 0xBD, 0x04, 0x57, 0xD1, 0x54, 0xAF, 0xCE + }, + { + 0xFD, 0x05, 0xFD, 0x81, 0x32, 0x5F, 0x79, 0x1E, + 0x52, 0x95, 0x7A, 0x18, 0xF9, 0x3C, 0x64, 0x3A, + 0xD4, 0xEF, 0x1D, 0xF6, 0xE8, 0x5B, 0x28, 0xFE, + 0x8D, 0x33, 0xCC, 0x06, 0xDC, 0xEA, 0xB9, 0x35, + 0x44, 0x88, 0x44, 0x6A, 0xCA, 0x7A, 0xEB, 0x06, + 0x95, 0x84, 0xAC, 0xAD, 0x3F, 0x99, 0xC3, 0x25, + 0x91, 0x47, 0x0C, 0x71, 0x20, 0x07, 0xCF, 0x0D, + 0x74, 0x94, 0xA4, 0x73, 0xC7, 0x5B, 0x09, 0x95 + }, + { + 0x34, 0x3C, 0xCE, 0x93, 0x5F, 0xC3, 0x9E, 0xF2, + 0x4D, 0xC9, 0x54, 0x23, 0xC5, 0x66, 0x95, 0x15, + 0x3C, 0x86, 0x8E, 0x8F, 0xCA, 0x7E, 0xDE, 0x5D, + 0x6B, 0x7B, 0x73, 0xFF, 0xD5, 0x32, 0x84, 0xAD, + 0x08, 0x87, 0x1A, 0x97, 0xD0, 0x04, 0x34, 0xB8, + 0x91, 0x40, 0xA1, 0x7B, 0x99, 0x99, 0xDA, 0xA0, + 0x08, 0x28, 0xE4, 0x3E, 0x3A, 0x7A, 0x92, 0xA6, + 0x17, 0x86, 0xF1, 0x2E, 0xA1, 0x32, 0x78, 0x49 + }, + { + 0xE4, 0x44, 0x80, 0x92, 0x28, 0xF3, 0x7B, 0xB1, + 0x95, 0x77, 0x26, 0xDA, 0x3C, 0xA8, 0xAF, 0xFA, + 0x0C, 0xA4, 0xE1, 0x90, 0xD0, 0x5A, 0x5C, 0xAC, + 0xFD, 0xC4, 0x97, 0xD2, 0x3C, 0x37, 0xDF, 0x3A, + 0x47, 0xEA, 0x27, 0x30, 0x6F, 0xBD, 0x5E, 0x1D, + 0x4B, 0x1A, 0x88, 0xE6, 0x32, 0xE6, 0x5D, 0x3E, + 0x21, 0xD3, 0x08, 0xA7, 0x3A, 0x00, 0xA7, 0x14, + 0xA1, 0x95, 0xE1, 0x6A, 0xE8, 0x89, 0x34, 0xB6 + }, + { + 0x16, 0xCD, 0xA7, 0x91, 0x78, 0x74, 0x5F, 0x76, + 0x81, 0x0C, 0x54, 0xC3, 0x89, 0xD1, 0x16, 0x3B, + 0x8C, 0x34, 0x71, 0xF8, 0x76, 0xAA, 0x59, 0x82, + 0x36, 0xDE, 0x54, 0x3D, 0x38, 0x41, 0x98, 0xB9, + 0x5F, 0xC5, 0x1B, 0x49, 0xFE, 0xD1, 0xE9, 0xC3, + 0x6F, 0x46, 0x5E, 0x88, 0xA0, 0xB4, 0x4C, 0x60, + 0x2F, 0x1C, 0x45, 0x61, 0x5B, 0xFD, 0x95, 0xC2, + 0xB6, 0x8A, 0xF5, 0xFF, 0x00, 0xBC, 0x1F, 0xD2 + }, + { + 0xB9, 0x6A, 0x02, 0x36, 0xAD, 0xEF, 0x9F, 0x5F, + 0x65, 0x34, 0x05, 0x10, 0x0D, 0x5E, 0x5F, 0x95, + 0xA8, 0xBC, 0x6F, 0xE8, 0x2B, 0x11, 0xEC, 0xB3, + 0x65, 0x0D, 0xFF, 0x8A, 0xEA, 0xAB, 0x6C, 0x3C, + 0x67, 0x5C, 0x39, 0x43, 0x92, 0x0F, 0x5B, 0x2F, + 0x17, 0xAB, 0x59, 0x4A, 0xF4, 0x06, 0x3F, 0xD3, + 0x70, 0x58, 0xA5, 0x1A, 0x7B, 0x78, 0x49, 0xB1, + 0x23, 0xF4, 0x56, 0x33, 0x6F, 0xB1, 0x79, 0x5D + }, + { + 0x52, 0xED, 0x8D, 0xA3, 0xFF, 0xA1, 0xFB, 0xD7, + 0xDF, 0xDD, 0xFD, 0x81, 0x40, 0xE3, 0xEF, 0x43, + 0xD6, 0x4F, 0xB7, 0xAB, 0xE5, 0x28, 0x5D, 0xE3, + 0x92, 0x36, 0x6C, 0xCE, 0x83, 0xE0, 0xDC, 0x6E, + 0x1F, 0xE2, 0x2B, 0x9B, 0x09, 0x9A, 0xE6, 0x6C, + 0xA9, 0x5A, 0xE0, 0x7C, 0x54, 0xCC, 0x5A, 0xB2, + 0x0D, 0x7F, 0x08, 0x22, 0x28, 0x28, 0x26, 0x24, + 0xEC, 0x98, 0xEA, 0xA8, 0xD8, 0xED, 0x15, 0x94 + }, + { + 0x5A, 0x68, 0x5E, 0xF6, 0x47, 0xDA, 0x30, 0xDB, + 0x3B, 0x9E, 0x26, 0x68, 0xFF, 0x89, 0xF7, 0xA9, + 0x25, 0x49, 0x67, 0xB3, 0x14, 0x81, 0x14, 0x97, + 0xE6, 0xCD, 0x00, 0x70, 0x5A, 0x6F, 0x3E, 0x76, + 0xEC, 0xEF, 0x16, 0xA8, 0xCB, 0xB8, 0x17, 0x7E, + 0xA5, 0xBF, 0xDA, 0xC8, 0x53, 0x77, 0xD3, 0xCE, + 0x72, 0x1D, 0xBD, 0x82, 0x7B, 0xBF, 0x7F, 0xA6, + 0x85, 0x13, 0x28, 0x0D, 0xA8, 0x30, 0x9B, 0x8E + }, + { + 0xAF, 0xE9, 0x28, 0x1B, 0xB3, 0x6A, 0x04, 0x06, + 0xFE, 0x6D, 0x50, 0x63, 0x7B, 0xF7, 0x2C, 0x88, + 0xBF, 0x08, 0x27, 0xB3, 0xEC, 0x72, 0xB2, 0xE8, + 0x29, 0x36, 0xBD, 0x06, 0xCC, 0x71, 0x65, 0xF7, + 0x44, 0x0B, 0x4F, 0x87, 0xEA, 0x00, 0xC2, 0x20, + 0xA8, 0x84, 0x5C, 0x47, 0x28, 0x01, 0xF0, 0xB5, + 0x8D, 0xD4, 0x63, 0x69, 0x2C, 0x23, 0xF0, 0xC9, + 0x3E, 0x12, 0x07, 0x22, 0x0B, 0x80, 0x82, 0x0A + }, + { + 0x32, 0x6E, 0xB2, 0xBA, 0x71, 0x06, 0x57, 0xE5, + 0xE4, 0x6F, 0xFE, 0x53, 0xC6, 0xE9, 0xC1, 0xAB, + 0x5C, 0x36, 0x07, 0x28, 0x44, 0x5D, 0x21, 0xF8, + 0xA9, 0xF9, 0xFD, 0x8B, 0x41, 0x8D, 0xB1, 0x0D, + 0xFA, 0x23, 0x9E, 0x23, 0x5A, 0xA6, 0x50, 0x7D, + 0x73, 0x51, 0xB2, 0x96, 0x5D, 0x31, 0x7B, 0x1E, + 0x66, 0xB2, 0x99, 0x43, 0x7F, 0x62, 0xB0, 0x2B, + 0xA6, 0xAC, 0x23, 0xE2, 0xFE, 0x41, 0x5F, 0xE0 + }, + { + 0x07, 0xA0, 0x42, 0x17, 0x07, 0xB6, 0x64, 0x0E, + 0xC0, 0x01, 0x7A, 0xFA, 0x91, 0xBB, 0xC3, 0x08, + 0x3C, 0x13, 0xC3, 0x70, 0xDC, 0x47, 0x12, 0xBE, + 0xB0, 0x8E, 0x4E, 0xC3, 0xB1, 0x43, 0x9F, 0x8A, + 0x8D, 0xEC, 0x35, 0x56, 0xF4, 0xD8, 0xC3, 0x23, + 0x79, 0xD5, 0x64, 0x29, 0xBC, 0x84, 0x8E, 0x61, + 0x64, 0x48, 0xE5, 0x84, 0x3E, 0x99, 0x37, 0x1E, + 0x77, 0x40, 0x1D, 0x89, 0x22, 0xDE, 0xFB, 0x17 + }, + { + 0xC6, 0xB7, 0xCE, 0xE2, 0xEB, 0x3C, 0xB0, 0x2C, + 0x8F, 0x30, 0x44, 0x7B, 0xE0, 0xA6, 0x6E, 0xEF, + 0x61, 0x37, 0x16, 0xAB, 0x71, 0x5B, 0xCF, 0x02, + 0xBC, 0xDD, 0x29, 0x3D, 0x8E, 0x1B, 0x5F, 0x75, + 0x33, 0xBE, 0x0D, 0x3E, 0xD2, 0x4B, 0x81, 0xB8, + 0xFE, 0x3B, 0x1A, 0x07, 0x34, 0x50, 0x15, 0x21, + 0x4E, 0x97, 0xF1, 0xB8, 0x59, 0x96, 0x81, 0x23, + 0x22, 0x0E, 0x57, 0xC5, 0x1D, 0x16, 0xB0, 0x7D + }, + { + 0xC8, 0x56, 0x4B, 0xF3, 0x69, 0xC7, 0xF8, 0x79, + 0x1D, 0xCB, 0xE4, 0x2C, 0x33, 0x81, 0x25, 0xAB, + 0x14, 0xF3, 0x98, 0xDF, 0x1E, 0xF5, 0x9D, 0xE7, + 0x17, 0xA9, 0x52, 0x1E, 0x26, 0x9A, 0x1B, 0xCB, + 0xC0, 0x13, 0x51, 0x97, 0x5F, 0xA4, 0x95, 0x2B, + 0x75, 0xBD, 0xDF, 0x6B, 0x2F, 0x0E, 0x9C, 0x2E, + 0xDF, 0x72, 0x0A, 0x72, 0x3F, 0xD6, 0xFD, 0x46, + 0x9E, 0x07, 0x42, 0xDD, 0xC7, 0x58, 0xFD, 0x73 + }, + { + 0x56, 0x5D, 0x6E, 0x5A, 0x40, 0xE1, 0x5E, 0x57, + 0x80, 0x64, 0xE2, 0xF7, 0x4C, 0xDF, 0xC3, 0x65, + 0x53, 0x22, 0xB1, 0x4C, 0xD7, 0xC6, 0x74, 0x01, + 0xA2, 0x37, 0x84, 0xE1, 0xEF, 0xCD, 0xD2, 0x32, + 0x2D, 0x93, 0x25, 0x94, 0xA7, 0x15, 0xB8, 0xB0, + 0xAB, 0x34, 0xDC, 0x3E, 0xB2, 0x2C, 0x36, 0xB2, + 0xDE, 0xBF, 0x90, 0x19, 0x5E, 0x9E, 0x15, 0xFF, + 0x4C, 0x08, 0xED, 0x1A, 0xB2, 0x04, 0x4C, 0x62 + }, + { + 0xD4, 0xFB, 0x4B, 0x67, 0x18, 0xCC, 0x2D, 0x43, + 0x80, 0x01, 0x05, 0x8F, 0x40, 0x77, 0xAA, 0xCF, + 0xF6, 0x6A, 0x57, 0x3A, 0x03, 0x9E, 0xD0, 0x54, + 0x84, 0x16, 0xF3, 0x6A, 0xAE, 0x6B, 0x26, 0x9F, + 0xFD, 0x83, 0xCE, 0x66, 0x14, 0x90, 0x6A, 0x75, + 0xB2, 0x6B, 0xDE, 0xF2, 0xA3, 0x76, 0x37, 0xC9, + 0xC6, 0xE7, 0xFA, 0x12, 0x2A, 0xAF, 0xE1, 0x79, + 0xA4, 0x31, 0x25, 0xD4, 0xB6, 0x20, 0xDA, 0x24 + }, + { + 0xDF, 0x62, 0x88, 0x35, 0x6E, 0xD8, 0xAD, 0x76, + 0x83, 0x80, 0x71, 0xB3, 0x31, 0x20, 0xD3, 0xCA, + 0x00, 0x8D, 0xD1, 0x96, 0x37, 0xD1, 0x98, 0xF9, + 0x1C, 0xFB, 0x9D, 0x0A, 0xF2, 0xE1, 0x2F, 0x2F, + 0xCB, 0xBD, 0x6F, 0xEA, 0x18, 0x30, 0xE5, 0xAB, + 0xBB, 0x10, 0xA5, 0x1F, 0xEC, 0xA4, 0xAE, 0xBE, + 0x15, 0xCF, 0xD2, 0x2E, 0xCD, 0x2C, 0x82, 0x50, + 0xCE, 0x57, 0x38, 0x75, 0x1A, 0xA6, 0x49, 0x12 + }, + { + 0x6A, 0x5F, 0x6D, 0xB6, 0x29, 0x7F, 0x9E, 0x7E, + 0xB8, 0x1F, 0xEC, 0x00, 0x4C, 0x37, 0x3C, 0xAC, + 0x13, 0x5A, 0x71, 0x36, 0xDE, 0x04, 0x0E, 0xD7, + 0xDC, 0x36, 0x98, 0x84, 0x32, 0x26, 0xF6, 0x96, + 0xF7, 0x97, 0xDE, 0xF1, 0x6E, 0x64, 0xE9, 0xF6, + 0xD9, 0x7C, 0xAA, 0xF0, 0x26, 0x98, 0xBA, 0xE3, + 0xCD, 0xE4, 0xD6, 0x3C, 0xB4, 0x1A, 0x50, 0x00, + 0x9D, 0xAA, 0x13, 0x92, 0x41, 0x2F, 0xFC, 0x6F + }, + { + 0x1D, 0x49, 0x77, 0xA2, 0xBB, 0xC2, 0xE5, 0x93, + 0xF6, 0xB0, 0x62, 0x0C, 0x84, 0x73, 0xDB, 0x5C, + 0xF1, 0x29, 0xBD, 0xBD, 0x83, 0x86, 0x23, 0xD6, + 0xA6, 0xB3, 0xDE, 0x38, 0x4F, 0x41, 0x1D, 0x0D, + 0x51, 0x8D, 0x3A, 0x19, 0xC0, 0xE0, 0x0F, 0x81, + 0x28, 0xD2, 0x21, 0x13, 0xF6, 0x9E, 0x4C, 0xCC, + 0xD7, 0x61, 0x92, 0x3A, 0xDE, 0xE1, 0xF7, 0xB8, + 0x58, 0x69, 0xF1, 0x6C, 0xE4, 0x97, 0xDE, 0x32 + }, + { + 0x4C, 0xD6, 0xFC, 0xC1, 0xA9, 0xA7, 0x28, 0x7B, + 0xCD, 0xD8, 0x19, 0x05, 0x99, 0xFE, 0x92, 0xAE, + 0x91, 0x34, 0x4B, 0x9D, 0xD8, 0x30, 0x9A, 0x5D, + 0xD4, 0xEE, 0x66, 0x51, 0xDB, 0xFB, 0x61, 0xC1, + 0x95, 0x47, 0xBA, 0x79, 0x89, 0xCE, 0x7A, 0xBB, + 0x47, 0xA4, 0x0C, 0x89, 0xEC, 0x1F, 0x14, 0x46, + 0x9C, 0x1F, 0x82, 0x18, 0x67, 0x41, 0xBB, 0x21, + 0x78, 0xF4, 0x37, 0x7F, 0xBF, 0x5E, 0x1D, 0x19 + }, + { + 0x43, 0xF3, 0xB6, 0xEB, 0x5D, 0xAF, 0x33, 0x24, + 0xE2, 0xD8, 0xE6, 0x0C, 0x32, 0x25, 0x55, 0x4B, + 0x85, 0xD6, 0xAE, 0xEA, 0x75, 0x9B, 0x16, 0x7D, + 0x7B, 0x00, 0xD6, 0x6D, 0xA7, 0x2B, 0x51, 0x6E, + 0xD4, 0xDD, 0x63, 0xA5, 0xF1, 0xA5, 0x93, 0x63, + 0x7F, 0xE2, 0xD7, 0x1E, 0xCC, 0x47, 0x4C, 0x28, + 0xAD, 0x44, 0x4B, 0x80, 0x58, 0x98, 0x9E, 0xA2, + 0xEC, 0xD6, 0x0B, 0x96, 0x2B, 0xEB, 0x73, 0xB6 + }, + { + 0xF2, 0x41, 0x7B, 0x07, 0x3C, 0x9A, 0x57, 0x61, + 0xEA, 0x9D, 0xDB, 0xDB, 0x70, 0xED, 0xBB, 0x9A, + 0x7A, 0xF9, 0x4B, 0x52, 0x73, 0x17, 0x19, 0x08, + 0xD5, 0x08, 0x71, 0x0B, 0x2F, 0x51, 0x31, 0xD4, + 0x11, 0x24, 0xE1, 0x60, 0xE2, 0x7C, 0x0F, 0xF8, + 0x7F, 0x72, 0x9E, 0xA1, 0x8F, 0xE3, 0xF4, 0x6A, + 0xCF, 0x53, 0xAC, 0xD8, 0x96, 0x72, 0xC8, 0xF1, + 0x84, 0x01, 0xE6, 0xEB, 0xAE, 0xBA, 0x21, 0x3E + }, + { + 0xBF, 0x0A, 0xE6, 0x3D, 0xB1, 0xF7, 0x99, 0x15, + 0x3B, 0xEA, 0x0B, 0xF6, 0xD5, 0xBC, 0x13, 0xCF, + 0x3E, 0x0D, 0x93, 0x10, 0xDE, 0xAA, 0x12, 0x69, + 0x33, 0x89, 0x00, 0xE0, 0xE1, 0x53, 0xBA, 0xCF, + 0xBD, 0x89, 0xD5, 0xCD, 0xE0, 0x14, 0x38, 0x9A, + 0x42, 0x8C, 0x81, 0x84, 0x97, 0x0D, 0xA2, 0x52, + 0x05, 0xB7, 0x23, 0xD1, 0x99, 0x65, 0xB9, 0xD0, + 0xDE, 0x20, 0xB7, 0xD9, 0x80, 0x6A, 0x7F, 0x67 + }, + { + 0x93, 0x4D, 0xB8, 0x5B, 0x82, 0x78, 0xE8, 0x3A, + 0x8F, 0xC8, 0x30, 0x0A, 0x81, 0xE2, 0xA3, 0x47, + 0xDB, 0x80, 0xDC, 0x8C, 0x55, 0x77, 0xC3, 0x33, + 0x7F, 0x60, 0xAF, 0xBA, 0xC8, 0x48, 0xED, 0x6E, + 0x67, 0x51, 0x50, 0x94, 0xA9, 0xA9, 0x85, 0x3B, + 0x04, 0xD7, 0xA2, 0x30, 0x5C, 0x43, 0x45, 0xC8, + 0x2F, 0x04, 0xD5, 0x10, 0xA3, 0x37, 0x38, 0x42, + 0xB3, 0xE5, 0xB9, 0x02, 0x23, 0xA4, 0x32, 0x95 + }, + { + 0x9C, 0xBF, 0x7E, 0xC2, 0xCF, 0x20, 0x44, 0xE5, + 0x4D, 0xB1, 0x83, 0xA3, 0x70, 0x9E, 0x2F, 0xD3, + 0xC9, 0x0B, 0xEE, 0x8C, 0xD5, 0xC8, 0x65, 0x05, + 0x0D, 0x9C, 0x6B, 0xF3, 0x3F, 0x0D, 0xE9, 0xAF, + 0xEE, 0xCB, 0x0F, 0x5E, 0xA5, 0x5E, 0xE5, 0x39, + 0x46, 0xDF, 0xDE, 0xAD, 0xA3, 0x59, 0xAB, 0x7B, + 0x8C, 0x06, 0x05, 0x10, 0x9B, 0x41, 0xD4, 0x28, + 0xE7, 0x78, 0x5B, 0xDB, 0x21, 0x38, 0x71, 0x1C + }, + { + 0xC1, 0x8F, 0xD1, 0xE5, 0xEE, 0x6C, 0x77, 0x64, + 0x34, 0x6C, 0x34, 0x1C, 0x59, 0x83, 0x7E, 0x91, + 0xDA, 0x42, 0xD3, 0x4F, 0x6C, 0xD8, 0xB4, 0xBD, + 0x10, 0xD0, 0x32, 0x6B, 0x1D, 0x01, 0x5D, 0x1D, + 0x53, 0x28, 0x03, 0xAB, 0xDE, 0xBD, 0x32, 0xAE, + 0x0B, 0xD2, 0x40, 0x89, 0x80, 0x83, 0x88, 0x35, + 0x01, 0xAD, 0xF1, 0x0D, 0xB7, 0x38, 0x61, 0xFD, + 0x1D, 0xB0, 0x4D, 0x87, 0x9D, 0xB5, 0xB7, 0x6C + }, + { + 0x91, 0x91, 0xD2, 0xDE, 0xE6, 0x05, 0x71, 0x27, + 0x0B, 0xD3, 0x30, 0x0D, 0x83, 0xD3, 0xC1, 0xCF, + 0x19, 0x0D, 0xEA, 0xAD, 0x0E, 0x87, 0x48, 0x48, + 0x96, 0x96, 0xF1, 0x31, 0xD4, 0x46, 0x05, 0x10, + 0x86, 0x0C, 0x8E, 0x02, 0xAA, 0x4B, 0x24, 0x7B, + 0x68, 0x47, 0xC4, 0x4C, 0x13, 0xE7, 0xB6, 0x0A, + 0xD3, 0x8C, 0xC3, 0x54, 0x39, 0x5C, 0x7A, 0x95, + 0x39, 0xF5, 0x8E, 0x3C, 0xD0, 0x30, 0x0C, 0xF9 + }, + { + 0xC8, 0x3E, 0xC3, 0xB1, 0xB6, 0xF9, 0x82, 0x1F, + 0xAA, 0xA9, 0x54, 0x34, 0xDE, 0x74, 0x16, 0x69, + 0x47, 0xD8, 0xF7, 0x87, 0xA9, 0x25, 0x9D, 0x49, + 0xC2, 0x49, 0xFA, 0xFA, 0xF0, 0xCD, 0xCE, 0xC9, + 0x83, 0x07, 0x78, 0x36, 0xB2, 0x71, 0xA5, 0xFB, + 0xAD, 0x75, 0x66, 0x99, 0x2B, 0x5F, 0x7C, 0x9C, + 0x5E, 0xC4, 0xBE, 0x94, 0xF2, 0xB5, 0x73, 0x8D, + 0x50, 0x22, 0xB3, 0xF4, 0xAA, 0x9F, 0xEA, 0x4A + }, + { + 0x11, 0x45, 0xF9, 0xC3, 0x95, 0xC3, 0x2A, 0xD0, + 0x81, 0xC6, 0x75, 0x86, 0xF9, 0xE5, 0xE4, 0x5E, + 0x27, 0x04, 0xE6, 0x26, 0x6C, 0x21, 0x30, 0xFC, + 0x70, 0x2A, 0x3E, 0x3B, 0x2D, 0x81, 0x13, 0xB3, + 0xA7, 0x9D, 0x7A, 0x72, 0x23, 0x67, 0x3E, 0x06, + 0xB5, 0x55, 0xCC, 0xC4, 0xCB, 0x75, 0x91, 0x59, + 0x5E, 0x39, 0x7B, 0xCD, 0xED, 0x0F, 0xAE, 0x2C, + 0x72, 0x2E, 0xF0, 0x82, 0x9A, 0xD8, 0x36, 0x07 + }, + { + 0x86, 0x46, 0x07, 0x55, 0xF0, 0x09, 0x6B, 0x30, + 0x71, 0xE8, 0x20, 0x3A, 0xC0, 0xB8, 0x1A, 0xFE, + 0x40, 0x26, 0xF8, 0x89, 0x7E, 0x68, 0x98, 0x9A, + 0xDD, 0xD6, 0x6A, 0xB3, 0xC8, 0xAC, 0xB8, 0xA9, + 0x30, 0x15, 0xE0, 0x8F, 0x0F, 0xA8, 0x78, 0x20, + 0xCE, 0x22, 0xD7, 0x67, 0xA5, 0xDD, 0x91, 0x26, + 0x5C, 0xB5, 0xB2, 0xD4, 0xCB, 0xF1, 0x4E, 0x15, + 0xE5, 0x72, 0x3C, 0xDB, 0x63, 0x72, 0x51, 0x65 + }, + { + 0x0F, 0xC6, 0x0B, 0x16, 0x0D, 0x8F, 0x58, 0x98, + 0xF2, 0x4B, 0x4E, 0x1D, 0x48, 0x6B, 0xC1, 0xC6, + 0x6B, 0x93, 0x2C, 0x22, 0xE5, 0x62, 0x3D, 0xB4, + 0xD5, 0x9D, 0x25, 0xDC, 0xDE, 0xFB, 0x00, 0xC7, + 0xE5, 0x66, 0xAE, 0x32, 0x1D, 0x7B, 0x63, 0xB2, + 0xA3, 0x13, 0x04, 0x42, 0x52, 0xE1, 0x45, 0x1A, + 0xDD, 0x01, 0x59, 0x22, 0x37, 0x86, 0x9D, 0x7F, + 0x74, 0xAB, 0x5E, 0xC8, 0xCB, 0x11, 0x04, 0xC3 + }, + { + 0x02, 0xE9, 0x5B, 0x7C, 0x89, 0x62, 0x89, 0x53, + 0xF8, 0x7F, 0x23, 0x08, 0xE5, 0x04, 0x77, 0x8B, + 0x7D, 0xE0, 0xE5, 0xF1, 0xC5, 0x71, 0x3C, 0xD7, + 0x3C, 0x7C, 0x26, 0x3A, 0x88, 0x72, 0x59, 0x81, + 0x7A, 0x43, 0x28, 0x46, 0x53, 0xAD, 0xF7, 0x1D, + 0x19, 0xC8, 0x05, 0xBE, 0x6E, 0x9E, 0x1F, 0x61, + 0xC4, 0x24, 0x0C, 0xDE, 0xE6, 0xE1, 0xEB, 0x57, + 0xDE, 0x12, 0x89, 0x2E, 0x4B, 0x3F, 0x9E, 0xB5 + }, + { + 0x38, 0x83, 0x2E, 0x7D, 0x4E, 0x54, 0x1D, 0x65, + 0x66, 0x77, 0x5E, 0x54, 0x04, 0xD4, 0x62, 0xC7, + 0x5A, 0x15, 0xBE, 0xD3, 0x1B, 0xDE, 0xC4, 0x8F, + 0xEA, 0xA5, 0x8A, 0x0B, 0x5E, 0x3F, 0x4E, 0x33, + 0x73, 0x5A, 0x95, 0x8C, 0x3B, 0x22, 0xD2, 0x38, + 0x62, 0xD8, 0xFE, 0x60, 0xA9, 0xB2, 0xEC, 0xDD, + 0x64, 0x68, 0x72, 0x24, 0xF3, 0x24, 0x47, 0x81, + 0x92, 0x98, 0xCA, 0x88, 0xEE, 0x6A, 0xCB, 0xE8 + }, + { + 0x3D, 0x62, 0xEF, 0x6B, 0x50, 0xB5, 0x4F, 0xA3, + 0x58, 0x96, 0x13, 0x76, 0x8C, 0x8B, 0x01, 0xA3, + 0x9D, 0x61, 0xB1, 0x31, 0x22, 0xA8, 0x95, 0x4E, + 0x27, 0xCF, 0x5E, 0xF9, 0x0C, 0x4B, 0x45, 0xB9, + 0xB0, 0x09, 0xF8, 0x73, 0xA5, 0x8C, 0x43, 0x93, + 0xB6, 0x1C, 0xF8, 0x9A, 0x16, 0xDA, 0x9B, 0x2C, + 0xAB, 0x33, 0x46, 0x68, 0x2C, 0x09, 0xFB, 0xED, + 0x72, 0x01, 0x24, 0x35, 0xF0, 0x4B, 0x6F, 0x59 + }, + { + 0xFD, 0x7A, 0xC4, 0x6C, 0x6F, 0x2D, 0x7F, 0x11, + 0x7D, 0xE2, 0x1C, 0x3A, 0xA7, 0xDD, 0x1F, 0xBF, + 0xAC, 0x78, 0x0F, 0xFE, 0x4B, 0x5C, 0x0C, 0xDB, + 0xF0, 0x9A, 0xBF, 0x19, 0x75, 0xA0, 0xC9, 0xFB, + 0xFE, 0x2D, 0x07, 0x54, 0x00, 0x9C, 0xFE, 0x0C, + 0xF3, 0xD0, 0xC8, 0x19, 0x0E, 0x63, 0x85, 0xE3, + 0x4E, 0x16, 0xBF, 0x52, 0xD1, 0x66, 0xAB, 0x0C, + 0x0C, 0x25, 0x5C, 0x2A, 0x57, 0xE1, 0xD5, 0xB1 + }, + { + 0x16, 0x8A, 0xD8, 0xCB, 0x74, 0x56, 0xF6, 0xE4, + 0x0C, 0x52, 0x74, 0xDD, 0xEA, 0x89, 0xC4, 0x49, + 0xFC, 0xF1, 0x17, 0xFB, 0x4F, 0x2D, 0xA9, 0xE9, + 0xB5, 0x78, 0xCA, 0xBA, 0x33, 0xCA, 0xB8, 0x98, + 0xF8, 0xF2, 0x40, 0x28, 0x1A, 0x3E, 0x51, 0xFE, + 0x45, 0x33, 0xA9, 0x8B, 0xBA, 0xA3, 0xC6, 0xA7, + 0xE5, 0x32, 0x0B, 0xD2, 0xE6, 0x65, 0x66, 0x3B, + 0x8A, 0xBD, 0x54, 0x68, 0x0F, 0x5D, 0x6E, 0xD4 + }, + { + 0x0A, 0xEA, 0x3A, 0x26, 0xAE, 0x42, 0xFB, 0x00, + 0x3F, 0xCF, 0x10, 0xA8, 0x25, 0x31, 0xFC, 0x76, + 0x77, 0xA7, 0x8B, 0x2F, 0xBD, 0x63, 0x21, 0xAD, + 0x83, 0x1C, 0xC5, 0x6A, 0xF4, 0x54, 0xC2, 0xAA, + 0x25, 0xED, 0x1A, 0xE6, 0x10, 0xF5, 0xCE, 0xD4, + 0x4E, 0xA9, 0x6C, 0xC2, 0xA2, 0x9F, 0x3C, 0x3C, + 0xB4, 0x1E, 0x23, 0x25, 0x20, 0xDF, 0x8B, 0xCF, + 0x72, 0xFF, 0xAC, 0xF3, 0xD5, 0x4D, 0x7B, 0xF9 + }, + { + 0x1C, 0x50, 0x8E, 0x58, 0xBD, 0xA9, 0x0E, 0x5D, + 0x2D, 0x4C, 0x54, 0x13, 0xF8, 0x50, 0x3B, 0xC4, + 0x12, 0xB5, 0x28, 0x78, 0x55, 0x23, 0x0E, 0x5D, + 0x06, 0x91, 0xFC, 0xDF, 0xB2, 0xDB, 0xCB, 0x07, + 0xF1, 0x76, 0x8F, 0xC0, 0x43, 0xF9, 0x13, 0x7C, + 0x67, 0x82, 0x94, 0xEE, 0x8C, 0x34, 0xE6, 0xFD, + 0x1F, 0x0A, 0x2D, 0x81, 0x46, 0xF3, 0xCF, 0x14, + 0xB5, 0x0D, 0x78, 0x70, 0x5C, 0xB2, 0xA9, 0x40 + }, + { + 0x44, 0xFE, 0x2E, 0x23, 0x40, 0xD9, 0x92, 0xC9, + 0x70, 0xDE, 0x46, 0x41, 0x37, 0x4F, 0x47, 0x02, + 0xAD, 0x84, 0xA4, 0x94, 0x5A, 0x98, 0x7E, 0x9E, + 0xA8, 0xDB, 0x9A, 0xFC, 0x9C, 0x8F, 0x61, 0xFD, + 0xD7, 0x1D, 0x9D, 0x59, 0x31, 0x45, 0x8F, 0xA2, + 0xEA, 0x74, 0x50, 0xC1, 0xB3, 0x72, 0xC1, 0x6C, + 0x97, 0xBF, 0xCF, 0x57, 0x0D, 0xEB, 0x4C, 0xA9, + 0x34, 0xFD, 0xEB, 0x95, 0x93, 0xA7, 0xA7, 0xD1 + }, + { + 0x58, 0x30, 0x5F, 0xBB, 0xDC, 0x12, 0x78, 0x29, + 0x69, 0x2F, 0x1C, 0x28, 0x3D, 0x4B, 0x40, 0x6F, + 0x17, 0xEA, 0x44, 0xF4, 0x3B, 0x81, 0xE3, 0x45, + 0x8C, 0x8C, 0x4A, 0xA8, 0xDA, 0xDB, 0xA2, 0x69, + 0x95, 0x15, 0x04, 0x14, 0x48, 0x54, 0x5A, 0x70, + 0xB4, 0xBD, 0xE5, 0x5D, 0xB9, 0x43, 0x72, 0x91, + 0xD1, 0x57, 0x1B, 0xA0, 0x87, 0xFC, 0xB4, 0xDE, + 0x98, 0x6A, 0x99, 0xB8, 0x04, 0x39, 0x64, 0x4B + }, + { + 0x5F, 0x5F, 0x00, 0x1F, 0x7B, 0x72, 0xAC, 0x92, + 0xB5, 0xA5, 0xDB, 0x83, 0x5D, 0xC4, 0xE7, 0x45, + 0x0A, 0x90, 0x9D, 0x2D, 0x54, 0xA0, 0x7A, 0x7A, + 0xD3, 0x8E, 0xE3, 0x42, 0x00, 0xCB, 0x64, 0x5F, + 0x4E, 0x95, 0x54, 0xBA, 0x4E, 0x80, 0xF3, 0x2C, + 0xDB, 0xA4, 0x44, 0x54, 0x9B, 0xC4, 0xF8, 0x6E, + 0x96, 0x25, 0x7E, 0x88, 0xFB, 0x16, 0x77, 0x82, + 0xB2, 0xDC, 0xE7, 0xF1, 0x71, 0x9E, 0x37, 0x83 + }, + { + 0x55, 0x98, 0x02, 0xC5, 0x3C, 0x9B, 0x5C, 0xA2, + 0xB7, 0x25, 0xC8, 0x6E, 0xF4, 0x91, 0x78, 0x94, + 0x53, 0x8F, 0xC4, 0x4C, 0xAB, 0x49, 0xD6, 0x4B, + 0x3C, 0xFB, 0x2A, 0x35, 0xB6, 0x0B, 0x97, 0xA9, + 0xE9, 0xDC, 0x2F, 0x1B, 0xF3, 0xAF, 0xA6, 0xA4, + 0x01, 0xCD, 0xE9, 0xF8, 0xDD, 0xDE, 0x8C, 0x36, + 0x6B, 0x2E, 0x4E, 0x1F, 0xE3, 0x74, 0x39, 0x81, + 0x89, 0xCE, 0x8D, 0x56, 0x6E, 0x2C, 0x65, 0xF7 + }, + { + 0x2A, 0xF8, 0x2B, 0x9F, 0x16, 0xBA, 0xFA, 0x2B, + 0xA2, 0x68, 0x5A, 0xEE, 0xB2, 0xF7, 0x2D, 0x6A, + 0x6B, 0x1E, 0x1F, 0x39, 0xAD, 0x4F, 0x36, 0x69, + 0x37, 0x8F, 0x6F, 0xBD, 0xD5, 0xBD, 0xF0, 0xE1, + 0x35, 0x7E, 0x80, 0xD5, 0x3B, 0x6B, 0x6E, 0x3E, + 0x09, 0xA7, 0xFA, 0xFC, 0x1A, 0x40, 0xC3, 0x70, + 0xB6, 0x5D, 0x1D, 0xE1, 0x8F, 0xA5, 0xDB, 0xAA, + 0x5D, 0xA5, 0x9F, 0x8A, 0xAA, 0x91, 0x0B, 0xB8 + }, + { + 0x6A, 0x48, 0x91, 0x8A, 0x07, 0x74, 0x68, 0x76, + 0x19, 0x0B, 0x7C, 0x29, 0xD1, 0x56, 0x4E, 0x36, + 0xA9, 0x05, 0xCE, 0x56, 0xF5, 0x10, 0xFE, 0xE0, + 0xF4, 0xCE, 0x4F, 0xD4, 0x3E, 0xA2, 0xCF, 0x1A, + 0xB1, 0x2C, 0x4A, 0x14, 0x80, 0x82, 0xDF, 0x9A, + 0xBC, 0x96, 0x31, 0x01, 0x72, 0x2A, 0x0B, 0xBF, + 0x47, 0x6A, 0xE0, 0x50, 0x47, 0xCE, 0xAD, 0x46, + 0x3D, 0x0B, 0xE4, 0x39, 0x14, 0xC9, 0x82, 0x9A + }, + { + 0x4F, 0xCB, 0xF6, 0xAB, 0x48, 0x05, 0xCB, 0x38, + 0x0C, 0xBA, 0x9C, 0xDD, 0xC7, 0x8E, 0x00, 0x1A, + 0x67, 0x36, 0xFD, 0xC0, 0xF2, 0x24, 0x90, 0xB7, + 0x6D, 0xE3, 0xDD, 0xBF, 0xFE, 0x73, 0x65, 0xD4, + 0xD8, 0x77, 0x46, 0x91, 0x2A, 0xDA, 0xE1, 0xA3, + 0x11, 0x72, 0x9B, 0x13, 0x5A, 0xEA, 0xBD, 0xC6, + 0x81, 0xAE, 0x93, 0x04, 0xC2, 0x67, 0x84, 0x69, + 0x2E, 0x29, 0xDF, 0x4B, 0xCD, 0x88, 0xE4, 0x91 + }, + { + 0x45, 0xD5, 0xD1, 0x2E, 0xB0, 0x69, 0xE8, 0xCC, + 0x5B, 0x06, 0x1F, 0x6B, 0x14, 0x46, 0x9F, 0x1F, + 0x8D, 0xB9, 0x96, 0x0E, 0xB3, 0x80, 0x00, 0xE6, + 0xE3, 0xF3, 0x2E, 0xFD, 0x2C, 0x8A, 0xE1, 0x3A, + 0x26, 0x5E, 0x0D, 0x8F, 0x53, 0xC0, 0xB3, 0x23, + 0x69, 0x75, 0x04, 0x77, 0x8F, 0x60, 0x6C, 0x41, + 0xFA, 0x87, 0x21, 0xD3, 0x52, 0xC0, 0xAA, 0xFB, + 0x9A, 0x67, 0x5B, 0x72, 0x91, 0x5B, 0x5F, 0xCC + }, + { + 0x39, 0x07, 0xE3, 0xE8, 0xFB, 0x80, 0x2D, 0xAD, + 0xF9, 0xC5, 0x8A, 0x0E, 0x5C, 0x60, 0xFF, 0x00, + 0xE4, 0x7A, 0x5A, 0xD3, 0x3A, 0x85, 0xB0, 0xF6, + 0x30, 0x0D, 0x13, 0x19, 0x5B, 0x3D, 0xC2, 0x73, + 0x9F, 0x59, 0xAB, 0x27, 0x17, 0x4F, 0x6E, 0xA7, + 0x03, 0xE1, 0x0B, 0xBA, 0xA5, 0x49, 0x69, 0x3A, + 0x82, 0x02, 0x0B, 0xFC, 0xEB, 0x28, 0x85, 0xD8, + 0x3A, 0x09, 0xD9, 0xAC, 0xD9, 0xEA, 0x70, 0x1F + }, + { + 0x2E, 0x15, 0x32, 0xED, 0x72, 0x6A, 0x5E, 0x0D, + 0xB7, 0x21, 0x12, 0xD6, 0xFB, 0x22, 0x3A, 0xD1, + 0x49, 0x16, 0x64, 0x58, 0x70, 0x33, 0x89, 0x3E, + 0x59, 0x66, 0x9A, 0xDE, 0xE3, 0x23, 0x17, 0x53, + 0x5E, 0xDB, 0xC8, 0x91, 0x51, 0x41, 0xB3, 0x53, + 0xAE, 0xB5, 0xF1, 0x38, 0xA6, 0x3B, 0xCD, 0x78, + 0xDA, 0x15, 0xA1, 0x86, 0xDD, 0x76, 0xAF, 0x6C, + 0xFA, 0x29, 0x1E, 0x07, 0x70, 0xAB, 0x6C, 0xCA + }, + { + 0x6C, 0xF9, 0x4D, 0xE2, 0x91, 0x53, 0x9F, 0x43, + 0x88, 0x94, 0x66, 0xF0, 0xBB, 0xF5, 0x1F, 0x64, + 0xA8, 0x8E, 0x12, 0xA2, 0xD4, 0x01, 0xDD, 0xE8, + 0x2F, 0x54, 0x1F, 0x24, 0xBA, 0x28, 0x70, 0x94, + 0xD0, 0xF8, 0xF6, 0x60, 0xCA, 0x9E, 0xE2, 0xB8, + 0x17, 0x7A, 0xA3, 0x2D, 0x6C, 0xD1, 0x83, 0x89, + 0x78, 0xB6, 0xB3, 0xE2, 0xD2, 0x3A, 0x1D, 0x9D, + 0xC2, 0xD0, 0x4F, 0xEA, 0x2B, 0x78, 0xF8, 0x5E + }, + { + 0xFE, 0xDB, 0x84, 0xC6, 0x1E, 0x7E, 0x41, 0x31, + 0x66, 0x0C, 0x94, 0x02, 0x3D, 0x1C, 0x3E, 0xB2, + 0x39, 0xBF, 0x80, 0xCC, 0xCF, 0xC5, 0x2F, 0x36, + 0x49, 0x62, 0x4C, 0x5F, 0x89, 0x76, 0x40, 0x19, + 0xCF, 0x5A, 0x8D, 0xAD, 0xF5, 0x7A, 0xF1, 0xB5, + 0x0D, 0x19, 0xDB, 0xBD, 0x7D, 0x23, 0xA2, 0xF2, + 0x68, 0xCE, 0x72, 0x95, 0x80, 0x68, 0x5C, 0x7F, + 0xE2, 0xF9, 0x5D, 0x1A, 0x53, 0x9A, 0x1F, 0xF1 + }, + { + 0x72, 0x03, 0x5E, 0x62, 0xE8, 0x04, 0x69, 0x4E, + 0x36, 0x6C, 0x18, 0xC9, 0xE5, 0xBC, 0x6D, 0xF2, + 0x92, 0xAC, 0xD7, 0xC9, 0xE2, 0xD0, 0x70, 0x20, + 0x35, 0x95, 0x9E, 0x0F, 0xC2, 0x49, 0xF1, 0x1D, + 0xC1, 0x68, 0x84, 0x87, 0x7F, 0xFD, 0xB9, 0x4A, + 0x76, 0x1D, 0x04, 0x50, 0x36, 0x65, 0xDC, 0xA2, + 0xFB, 0x31, 0x18, 0xA7, 0x00, 0x4C, 0xAA, 0x2F, + 0xBD, 0x2B, 0xA9, 0x8A, 0x6B, 0x63, 0x86, 0xE3 + }, + { + 0x7C, 0x55, 0xA8, 0xD9, 0x5D, 0x7F, 0xD2, 0x04, + 0xBF, 0xEA, 0xC7, 0x1B, 0x8B, 0xE8, 0x86, 0xD2, + 0x93, 0x5F, 0x61, 0x9E, 0x6C, 0xCD, 0xDB, 0xD2, + 0x56, 0x10, 0xA8, 0x22, 0x45, 0x80, 0xC5, 0x28, + 0xFC, 0x2E, 0x17, 0xA4, 0x7E, 0x5E, 0xEE, 0xD7, + 0x4E, 0x0D, 0xF9, 0xFF, 0xE7, 0xDE, 0xEC, 0xC8, + 0x81, 0x59, 0xCE, 0xC8, 0xEA, 0xC3, 0xBE, 0xB9, + 0xC1, 0x48, 0x6C, 0x0D, 0x43, 0x88, 0xD2, 0x75 + }, + { + 0x55, 0x43, 0xD6, 0x7F, 0x80, 0x04, 0x9D, 0xC8, + 0x6D, 0x81, 0x39, 0x03, 0xF5, 0xEA, 0x45, 0xFC, + 0xC7, 0x61, 0xCB, 0x83, 0xDB, 0xBE, 0xB0, 0xB9, + 0x2C, 0x98, 0x86, 0x1D, 0x05, 0x1F, 0x29, 0xBD, + 0x6A, 0xD0, 0x3D, 0xBC, 0x94, 0x7B, 0x4E, 0x66, + 0x85, 0x92, 0x9A, 0x22, 0x8F, 0x77, 0xC4, 0xFB, + 0xE9, 0x6D, 0x5F, 0x81, 0x03, 0x35, 0x8D, 0xA9, + 0xE4, 0xA5, 0x55, 0x74, 0x89, 0x0E, 0xEE, 0xD0 + }, + { + 0x3D, 0x50, 0xAC, 0x28, 0x3E, 0xE6, 0xEF, 0x84, + 0xA1, 0x33, 0xE8, 0x2F, 0xE0, 0xCD, 0xBD, 0x54, + 0xC3, 0xE5, 0xD6, 0xA9, 0x06, 0xC6, 0x98, 0x95, + 0x76, 0xDF, 0x91, 0xCE, 0x19, 0x73, 0x32, 0x73, + 0x34, 0x6F, 0x8C, 0x16, 0x92, 0x7B, 0xE6, 0xAD, + 0xA8, 0xFF, 0x14, 0xAF, 0xD2, 0x46, 0x93, 0x23, + 0x8B, 0xF3, 0x11, 0x41, 0x08, 0xEF, 0x6F, 0xF7, + 0x05, 0x5D, 0xA4, 0x28, 0xC7, 0x3E, 0x30, 0xFE + }, + { + 0x3C, 0x11, 0x8B, 0xF2, 0x6C, 0x3E, 0x74, 0x3E, + 0x17, 0x40, 0xF2, 0x02, 0x5C, 0x67, 0xBD, 0xCF, + 0xD4, 0xB9, 0x71, 0x45, 0x67, 0x82, 0xA1, 0x54, + 0xB9, 0x42, 0xCE, 0x8F, 0xC7, 0x6D, 0x65, 0xC7, + 0x68, 0xB5, 0x22, 0xB9, 0x2A, 0x95, 0xF6, 0xC6, + 0xF8, 0xDA, 0x3D, 0x4E, 0xA9, 0x67, 0x0C, 0x54, + 0xF7, 0x07, 0xF4, 0x6C, 0xAD, 0x66, 0xC1, 0x3C, + 0x0B, 0x37, 0x44, 0x0B, 0x89, 0x96, 0x21, 0x0F + }, + { + 0xDC, 0xAA, 0xAF, 0x16, 0x0D, 0x02, 0x0A, 0xEE, + 0xAF, 0x3D, 0xB0, 0x80, 0xD2, 0xC7, 0xFF, 0xF7, + 0x8E, 0x84, 0x81, 0x83, 0x93, 0x13, 0xCD, 0x94, + 0x52, 0x29, 0x33, 0xAE, 0xD5, 0x70, 0xD6, 0x82, + 0xB6, 0x24, 0x01, 0x64, 0xD3, 0xA2, 0xB5, 0x63, + 0x6A, 0xEC, 0x0B, 0x53, 0x32, 0x9B, 0xDA, 0xC9, + 0x33, 0xC4, 0x76, 0xB4, 0x50, 0xC6, 0x69, 0x0A, + 0x2C, 0x18, 0xBE, 0x61, 0x5A, 0x94, 0xAC, 0xF9 + }, + { + 0x7B, 0xDD, 0xD8, 0x0E, 0x4A, 0x95, 0x2E, 0xBF, + 0xB3, 0x22, 0xB4, 0x9F, 0x23, 0x12, 0x22, 0x91, + 0x2F, 0xB7, 0x6D, 0xAD, 0xDF, 0x04, 0xE8, 0xBB, + 0xAA, 0x90, 0xF1, 0x84, 0xAB, 0x9F, 0xEE, 0x26, + 0xCA, 0x00, 0xD3, 0xEB, 0x76, 0x15, 0x94, 0x36, + 0xF2, 0x4F, 0x06, 0xC6, 0xCF, 0xCE, 0x8B, 0xDD, + 0xE7, 0x94, 0xD6, 0x64, 0x46, 0x7B, 0x44, 0xFC, + 0x10, 0x79, 0x26, 0x0D, 0x28, 0xBB, 0x78, 0x06 + }, + { + 0x29, 0xCB, 0x78, 0x5D, 0x10, 0x00, 0x26, 0x43, + 0x7C, 0x56, 0xB8, 0xFE, 0xFD, 0x32, 0x12, 0x73, + 0x7D, 0x8A, 0x11, 0xAD, 0x16, 0x74, 0xBA, 0xC1, + 0x89, 0xA0, 0x90, 0x24, 0x71, 0x7E, 0x3D, 0x97, + 0x84, 0xFF, 0x56, 0x6D, 0x8F, 0xB8, 0x3D, 0x70, + 0xFB, 0x84, 0xED, 0x05, 0x2D, 0xFD, 0x15, 0x7B, + 0x31, 0x34, 0x01, 0x48, 0x15, 0xE8, 0x30, 0x60, + 0x4F, 0x41, 0x68, 0x5B, 0x2C, 0xA4, 0x23, 0x60 + }, + { + 0xD6, 0xED, 0xB3, 0x30, 0xF9, 0x21, 0xD5, 0x37, + 0xAE, 0xFF, 0xC5, 0x92, 0x17, 0xA3, 0xEF, 0x9F, + 0xA2, 0xF4, 0x0C, 0x47, 0x82, 0x5A, 0x1A, 0x71, + 0xB5, 0xF2, 0xA1, 0x9F, 0x18, 0xA1, 0x9C, 0x1A, + 0x18, 0x75, 0xC1, 0x34, 0x08, 0xF2, 0x14, 0x4C, + 0xA0, 0x07, 0x47, 0x13, 0xA2, 0x9E, 0x2C, 0x2B, + 0xCB, 0x86, 0xC5, 0xE3, 0x11, 0x7E, 0x07, 0xDB, + 0x8F, 0xBC, 0xE4, 0xE5, 0xE5, 0xFE, 0xAD, 0x9A + }, + { + 0xFD, 0x7F, 0xAD, 0xFA, 0x2A, 0x96, 0xC5, 0x97, + 0xCA, 0xBF, 0x4A, 0x7F, 0x15, 0x62, 0x49, 0x2A, + 0x71, 0x15, 0x25, 0x0A, 0x0D, 0x9F, 0x5F, 0xDC, + 0xC7, 0xA0, 0xE2, 0x13, 0xBE, 0x4E, 0x8C, 0xA9, + 0xAA, 0x34, 0x8E, 0x5A, 0x9F, 0xA8, 0x21, 0x66, + 0x9C, 0x88, 0x35, 0x58, 0x71, 0x7A, 0xB1, 0x7C, + 0x62, 0x12, 0xA6, 0x41, 0xBE, 0x89, 0x4E, 0x72, + 0xD2, 0x02, 0xE6, 0x89, 0x13, 0x52, 0x20, 0xC0 + }, + { + 0x9E, 0x09, 0xD0, 0x3D, 0x11, 0xBC, 0xD7, 0x37, + 0x26, 0x00, 0xAD, 0x5D, 0x72, 0x01, 0xF4, 0x2F, + 0xAB, 0x28, 0x79, 0x83, 0xEF, 0xED, 0xFD, 0x25, + 0x6A, 0xC9, 0xE1, 0x61, 0xDE, 0xF9, 0x04, 0xDF, + 0x04, 0x11, 0x30, 0xDB, 0x0D, 0x70, 0xEA, 0x1B, + 0x04, 0xC7, 0xF5, 0xE4, 0x50, 0xBD, 0x9D, 0xB2, + 0xF9, 0x48, 0x4E, 0x1C, 0xFC, 0xEF, 0xE4, 0x5A, + 0xF7, 0xD0, 0x5B, 0x23, 0xDF, 0x41, 0x04, 0x13 + }, + { + 0x1D, 0x73, 0x0B, 0xDB, 0x73, 0x0C, 0xAB, 0x73, + 0xF1, 0x48, 0xD3, 0x80, 0x04, 0x50, 0x11, 0x75, + 0x73, 0xD4, 0x7B, 0xE9, 0xEE, 0x8B, 0x39, 0x62, + 0xC4, 0xD8, 0x26, 0x06, 0xE7, 0x02, 0x6D, 0x00, + 0xEC, 0x14, 0xEA, 0x1B, 0x80, 0x1E, 0x5D, 0xD6, + 0x18, 0xE2, 0x17, 0x5C, 0x51, 0x14, 0x46, 0x06, + 0x49, 0xCF, 0xD3, 0x94, 0x33, 0x9C, 0x03, 0x2E, + 0xF4, 0x98, 0xA4, 0x29, 0x60, 0xC8, 0x5E, 0x5F + }, + { + 0xD0, 0x85, 0xE4, 0xDD, 0xFF, 0x0C, 0x9E, 0xD2, + 0x37, 0x05, 0xD9, 0xCF, 0x99, 0xD7, 0xFA, 0x90, + 0xAA, 0xCA, 0xCE, 0x9E, 0xB5, 0xD5, 0x09, 0x7D, + 0x23, 0x10, 0x53, 0x30, 0x8A, 0xF8, 0x9C, 0xA3, + 0xFA, 0x16, 0x93, 0x35, 0x25, 0xBF, 0x89, 0xCA, + 0xDF, 0x9E, 0x26, 0xDE, 0xB4, 0xA1, 0xFA, 0xEF, + 0xDD, 0x64, 0x9E, 0x81, 0xCC, 0xE1, 0x9B, 0x04, + 0xCE, 0xA1, 0x76, 0x54, 0xA9, 0x41, 0x0C, 0x80 + }, + { + 0x9C, 0xAA, 0x34, 0xEB, 0xA1, 0x1F, 0xF9, 0x61, + 0x01, 0x20, 0x23, 0x00, 0xAC, 0x82, 0xCA, 0x85, + 0xA7, 0xFA, 0xC2, 0xA6, 0x93, 0xC8, 0x78, 0x17, + 0x44, 0xFA, 0x0A, 0x27, 0xCF, 0x78, 0x44, 0x85, + 0x4C, 0x00, 0x59, 0x61, 0x83, 0x61, 0xF3, 0x03, + 0x7C, 0x2C, 0x1A, 0x4C, 0x7A, 0x72, 0x85, 0x15, + 0xA7, 0x3E, 0x40, 0x61, 0x5D, 0x20, 0x29, 0xAA, + 0x37, 0xBB, 0xCB, 0xD9, 0x82, 0x44, 0xFB, 0x17 + }, + { + 0x10, 0xC8, 0x0A, 0xE9, 0xDF, 0x09, 0xCE, 0x0E, + 0x80, 0x6C, 0x1B, 0x0B, 0xD0, 0x16, 0x2F, 0xC8, + 0x48, 0xC6, 0x10, 0x37, 0xB1, 0x6E, 0x4D, 0x46, + 0x03, 0x5E, 0x6F, 0x93, 0x66, 0x7E, 0x90, 0x5C, + 0xA1, 0xB7, 0xBA, 0x2D, 0xF0, 0x0C, 0x28, 0xD4, + 0x92, 0x20, 0x0F, 0x81, 0xA8, 0x71, 0xB0, 0xB6, + 0xD1, 0x93, 0x3D, 0x5D, 0x05, 0x1F, 0xED, 0xB2, + 0x7B, 0x53, 0x20, 0xD1, 0x65, 0x05, 0xD1, 0x48 + }, + { + 0xCF, 0x4F, 0x1A, 0x6D, 0x20, 0x2F, 0x8C, 0x9C, + 0x67, 0xAD, 0x54, 0xDB, 0x20, 0x5B, 0xF3, 0xD3, + 0x4D, 0x0E, 0x93, 0x28, 0x36, 0xC7, 0xF7, 0xCF, + 0xBD, 0x06, 0x5C, 0x77, 0x14, 0x61, 0x48, 0xD5, + 0xE2, 0x62, 0x3F, 0xE3, 0x75, 0x91, 0xF4, 0xD1, + 0xC6, 0xF3, 0xBA, 0xCC, 0x94, 0xFD, 0x8E, 0x4A, + 0xE9, 0x9A, 0xC1, 0x11, 0xA1, 0x1A, 0x88, 0x7A, + 0xF1, 0xA0, 0xFF, 0x6F, 0xA3, 0x80, 0x62, 0xA8 + }, + { + 0xBE, 0x71, 0xD4, 0x71, 0x4A, 0xEB, 0xC5, 0xB8, + 0xA0, 0x6D, 0xAE, 0x40, 0x6A, 0x09, 0x77, 0x0B, + 0x82, 0x38, 0xA4, 0xFE, 0xEE, 0x34, 0x59, 0x16, + 0xB7, 0xCA, 0xA3, 0x2A, 0xF9, 0x4E, 0x7D, 0xF3, + 0xAD, 0xA6, 0x1D, 0x00, 0xCC, 0xC3, 0xAF, 0x40, + 0x70, 0xA1, 0x48, 0xAF, 0x74, 0x0D, 0xA0, 0x79, + 0x44, 0xFF, 0xCB, 0x16, 0x8A, 0x64, 0xC4, 0xD2, + 0x3A, 0x6B, 0x71, 0x2F, 0x58, 0x45, 0xA9, 0xCF + }, + { + 0x28, 0xC1, 0x39, 0x9F, 0xB9, 0xFD, 0x95, 0x0C, + 0xA8, 0x40, 0xD8, 0xFE, 0x01, 0x3C, 0x71, 0xDB, + 0x3A, 0x26, 0xD9, 0x98, 0x35, 0xEC, 0x0F, 0xAF, + 0x05, 0xC0, 0x14, 0x71, 0x33, 0x9E, 0x40, 0x09, + 0xCA, 0x6E, 0xBC, 0xAF, 0x9E, 0x08, 0x36, 0x35, + 0x9A, 0x2D, 0x68, 0x64, 0x08, 0xD2, 0x14, 0x2E, + 0x71, 0x9E, 0x0E, 0x80, 0xDF, 0x23, 0x46, 0xBA, + 0xF0, 0x7F, 0x76, 0x78, 0x7C, 0x61, 0xBB, 0x33 + }, + { + 0x4E, 0x3E, 0x50, 0xE9, 0xE0, 0xF4, 0x1C, 0x1C, + 0xFE, 0x7D, 0x63, 0x60, 0xFA, 0xD8, 0x67, 0x39, + 0x7E, 0xB8, 0x86, 0x15, 0xD2, 0xFB, 0x89, 0x87, + 0x01, 0xED, 0x08, 0x82, 0x44, 0x22, 0xC0, 0xF7, + 0x11, 0x3F, 0x03, 0xA6, 0x0E, 0x57, 0x2A, 0xDB, + 0x4C, 0xE1, 0x63, 0xFA, 0xAE, 0x30, 0xE6, 0x51, + 0x6B, 0xD8, 0x15, 0xE3, 0x40, 0x7A, 0x97, 0x65, + 0x37, 0x83, 0x7D, 0x9D, 0xC8, 0x86, 0x0B, 0xB0 + }, + { + 0xC0, 0xB1, 0x25, 0x25, 0xF8, 0x1D, 0x0F, 0x9B, + 0x7D, 0xDB, 0x56, 0x8C, 0xB5, 0x6A, 0xB4, 0x30, + 0xA4, 0x75, 0xC6, 0xAC, 0x9B, 0x79, 0xEC, 0xFD, + 0x0E, 0xFE, 0xDD, 0x54, 0xC4, 0x0A, 0xC4, 0xAD, + 0x8C, 0x5F, 0xF9, 0x8E, 0x2D, 0x7F, 0x40, 0x0E, + 0x17, 0x72, 0xD0, 0xAD, 0xD7, 0x2B, 0xA8, 0x1B, + 0xEE, 0x7E, 0xB1, 0x9F, 0x96, 0xA1, 0x13, 0xCC, + 0x05, 0x46, 0x5D, 0x68, 0x0A, 0x72, 0x55, 0xCD + }, + { + 0xE7, 0x01, 0xE9, 0x61, 0x8F, 0x92, 0xCF, 0xB8, + 0x3B, 0xC5, 0x11, 0x4C, 0x9D, 0xE9, 0x27, 0x2E, + 0x01, 0x79, 0x40, 0x14, 0x59, 0x25, 0x30, 0xCA, + 0x44, 0x76, 0x48, 0x10, 0xD4, 0x20, 0x80, 0x20, + 0x42, 0xBF, 0xD7, 0x8A, 0x79, 0x15, 0x1A, 0xAC, + 0x92, 0x67, 0xDF, 0xE0, 0x08, 0xBC, 0x7D, 0xFB, + 0xC9, 0xFC, 0x16, 0x9C, 0x9C, 0x3C, 0x68, 0x39, + 0x89, 0x6F, 0xEC, 0xF1, 0x2E, 0x7B, 0x21, 0x67 + }, + { + 0x30, 0xAA, 0x15, 0x50, 0x8A, 0x30, 0x00, 0x21, + 0xDC, 0xBB, 0xB9, 0x11, 0x9D, 0x00, 0x30, 0x4E, + 0x07, 0xD3, 0x58, 0x26, 0x33, 0x5A, 0x8C, 0x4F, + 0xB7, 0xBC, 0xC6, 0xD1, 0x9B, 0xA2, 0xC5, 0xC0, + 0x3D, 0x40, 0xDB, 0x3F, 0x57, 0x52, 0xF2, 0x45, + 0x59, 0x89, 0x27, 0xEE, 0x32, 0xBF, 0x84, 0x96, + 0xF5, 0x42, 0x9B, 0x97, 0xBD, 0x84, 0x05, 0x76, + 0x6D, 0x0D, 0xE1, 0xA3, 0xC9, 0xA0, 0xA5, 0xB5 + }, + { + 0xEE, 0xA4, 0x60, 0x1E, 0xA5, 0x28, 0xCA, 0x08, + 0x08, 0x5B, 0x3A, 0xF1, 0xE9, 0xD1, 0xE8, 0xDB, + 0xA1, 0x4F, 0x6E, 0xEB, 0x91, 0xE7, 0xBE, 0x6D, + 0x24, 0x08, 0xC0, 0x46, 0x8E, 0x3F, 0x69, 0x7E, + 0x1E, 0x8D, 0x9B, 0xBD, 0x6C, 0x06, 0x6F, 0xAA, + 0x3C, 0xD5, 0x06, 0x5D, 0x81, 0x3F, 0xAD, 0xC9, + 0x48, 0xCD, 0x74, 0x1D, 0x47, 0x36, 0x35, 0x1E, + 0x02, 0x89, 0x28, 0x2F, 0xF8, 0x2E, 0x96, 0x99 + }, + { + 0x56, 0xE7, 0xD3, 0x43, 0x8F, 0x88, 0x5E, 0x8B, + 0x17, 0x11, 0xCB, 0x64, 0x5E, 0xCD, 0x0F, 0x0E, + 0xD0, 0xD0, 0x1D, 0xD9, 0xD4, 0xC7, 0x65, 0xEF, + 0x23, 0xE6, 0xB3, 0xFA, 0x93, 0xE0, 0x8B, 0x31, + 0xB9, 0x42, 0xDF, 0x34, 0xD2, 0x33, 0xDE, 0xA6, + 0x82, 0xFF, 0x5F, 0xDC, 0x08, 0x52, 0x21, 0xF1, + 0x5E, 0x5A, 0x73, 0x1B, 0xB3, 0xFE, 0xA9, 0xC8, + 0x0E, 0x48, 0xEB, 0x5D, 0x9C, 0xEE, 0xCE, 0xBB + }, + { + 0x12, 0xD0, 0x2D, 0x83, 0x5A, 0x27, 0xAA, 0x5C, + 0xB7, 0x8D, 0x68, 0xE1, 0xC5, 0x86, 0x36, 0x0C, + 0x23, 0x8C, 0xE0, 0x97, 0xC4, 0xFB, 0x7E, 0xBB, + 0x44, 0x78, 0xE2, 0x74, 0xB4, 0xD9, 0xB2, 0x8F, + 0xDF, 0xD8, 0xF6, 0xF9, 0x5D, 0xFD, 0xCF, 0xE1, + 0xDE, 0x83, 0x1B, 0xCF, 0x21, 0x1F, 0xB4, 0x57, + 0x34, 0xE0, 0x18, 0x76, 0x08, 0x0E, 0xA8, 0x3F, + 0x63, 0xD8, 0xDA, 0xA2, 0x06, 0xC8, 0xE7, 0x4B + }, + { + 0xD0, 0x57, 0x82, 0xA6, 0x6A, 0x29, 0xF1, 0x94, + 0x16, 0x8E, 0xF1, 0x17, 0x7E, 0x7D, 0x83, 0x39, + 0xFF, 0x38, 0x40, 0xB8, 0xC1, 0x75, 0xD4, 0xC0, + 0x41, 0x3E, 0x1D, 0x3C, 0xDD, 0xE0, 0x05, 0x47, + 0x83, 0x11, 0x5E, 0x3E, 0x69, 0xCD, 0xAA, 0x99, + 0x78, 0xF5, 0x66, 0xB3, 0x84, 0x62, 0x78, 0xB0, + 0x90, 0x35, 0x45, 0x41, 0xA6, 0x7A, 0x48, 0x6E, + 0xDE, 0xB6, 0xEE, 0x88, 0x05, 0xD3, 0xC3, 0x2C + }, + { + 0x7B, 0x60, 0xC0, 0xC5, 0xAA, 0x76, 0x3B, 0xAB, + 0x90, 0xB6, 0xE9, 0x78, 0x02, 0x34, 0x51, 0x62, + 0xB7, 0x7B, 0x65, 0xFE, 0x57, 0xA1, 0x2F, 0xB5, + 0x91, 0x9F, 0xE0, 0xC7, 0xFF, 0x76, 0x46, 0x98, + 0x31, 0x91, 0xC9, 0x92, 0xFE, 0xE2, 0xD7, 0x68, + 0x7E, 0xE0, 0xDB, 0x83, 0x14, 0xB9, 0xFE, 0x9F, + 0x2C, 0x3F, 0x3A, 0xF9, 0xE5, 0xDC, 0x0C, 0xE6, + 0xD9, 0x28, 0xC9, 0xFF, 0x17, 0x6C, 0x63, 0xC5 + }, + { + 0xA1, 0x58, 0xB7, 0x6B, 0x95, 0xB5, 0x6D, 0xB2, + 0x53, 0xA7, 0x63, 0x3A, 0x6C, 0x93, 0xDF, 0x16, + 0x8E, 0x25, 0x60, 0x33, 0x97, 0xBB, 0xFA, 0xD8, + 0xF4, 0xB9, 0x9E, 0x25, 0x43, 0x54, 0xC3, 0x84, + 0x97, 0xB9, 0x10, 0xF2, 0xC8, 0x54, 0x66, 0x9A, + 0xB5, 0xF7, 0xE5, 0x25, 0xA7, 0x76, 0x46, 0xAE, + 0xB7, 0x45, 0x8C, 0xB7, 0x41, 0x0D, 0x2E, 0xE3, + 0x69, 0xC0, 0x6D, 0xB3, 0xCB, 0x2F, 0xF2, 0x57 + }, + { + 0x63, 0x30, 0xD1, 0xC3, 0x91, 0xD6, 0xE4, 0x1B, + 0x88, 0x11, 0xF7, 0xF7, 0x1A, 0xCC, 0x98, 0xDD, + 0x7A, 0xE4, 0x00, 0x5D, 0x39, 0x03, 0xF5, 0x53, + 0xEF, 0xB8, 0x3D, 0x8F, 0xB6, 0x67, 0x79, 0xE4, + 0x7A, 0x2E, 0x43, 0x63, 0x94, 0x20, 0xB9, 0xAF, + 0x7D, 0xB5, 0xD0, 0x0A, 0x32, 0xEE, 0xB6, 0x98, + 0xC5, 0x58, 0x8F, 0x4A, 0x10, 0xCE, 0xFF, 0x53, + 0xFA, 0x42, 0xCA, 0x14, 0x1C, 0xBF, 0x63, 0x72 + }, + { + 0x51, 0x81, 0x4B, 0x14, 0xD5, 0xDF, 0x9A, 0x56, + 0x66, 0x2E, 0x27, 0x23, 0xBE, 0xAA, 0x3B, 0xC2, + 0x81, 0x5C, 0xBD, 0xCC, 0x4B, 0x9B, 0x7F, 0x8B, + 0x69, 0x13, 0xE4, 0x92, 0xDA, 0x4F, 0xCE, 0x39, + 0x3B, 0x13, 0xA3, 0x61, 0x7A, 0xD7, 0x62, 0xAB, + 0x07, 0x12, 0x5D, 0x9D, 0x0A, 0xE8, 0x11, 0x32, + 0xBE, 0x3D, 0x53, 0x5A, 0x1C, 0x77, 0x1C, 0x1A, + 0xC7, 0xD2, 0x90, 0x23, 0x87, 0x2C, 0xA4, 0xB8 + }, + { + 0xA2, 0xC7, 0x57, 0xAB, 0x63, 0xF4, 0x37, 0x40, + 0x41, 0x23, 0xF1, 0x20, 0xFC, 0x71, 0x7E, 0xF3, + 0xD9, 0xEE, 0x5A, 0xE9, 0x00, 0x35, 0x6B, 0x6E, + 0x54, 0xA8, 0x8F, 0x12, 0x55, 0x4E, 0x23, 0x37, + 0xAD, 0x0E, 0xC0, 0xEA, 0x2C, 0xF9, 0x39, 0x89, + 0x50, 0x6E, 0xE8, 0xBB, 0x91, 0x26, 0xA5, 0xC8, + 0x59, 0x88, 0xBD, 0x56, 0x41, 0x87, 0x09, 0xCE, + 0xA6, 0x5A, 0x38, 0x2A, 0x12, 0x4F, 0xE2, 0xA4 + }, + { + 0xB2, 0xC8, 0x70, 0x5C, 0xCD, 0xC8, 0xC8, 0xA4, + 0x97, 0xC9, 0x9D, 0x72, 0x47, 0x24, 0xEB, 0x6A, + 0x66, 0xEE, 0x3B, 0x82, 0x4D, 0x29, 0x3F, 0x08, + 0xC5, 0x10, 0x05, 0x57, 0x3C, 0x23, 0x6F, 0x8D, + 0x3F, 0x49, 0xFA, 0x54, 0x0A, 0x88, 0x72, 0xDC, + 0x11, 0xE7, 0x7B, 0x3D, 0xAF, 0xD2, 0xBD, 0x0D, + 0x89, 0x86, 0x21, 0x2F, 0x68, 0x7C, 0x37, 0x45, + 0x16, 0xDD, 0xB0, 0xAC, 0xCA, 0xD4, 0xFB, 0x61 + }, + { + 0x65, 0x71, 0x34, 0x00, 0xAD, 0x14, 0xD6, 0x2B, + 0x5D, 0xA9, 0x43, 0xFE, 0x05, 0x4B, 0x14, 0x9E, + 0x08, 0x14, 0x79, 0x04, 0x73, 0x1F, 0x57, 0x99, + 0x91, 0xE0, 0x9C, 0x33, 0x00, 0xA1, 0x15, 0x5C, + 0x45, 0x0F, 0x2D, 0xF3, 0xF6, 0xA0, 0xBF, 0x2C, + 0x5A, 0x32, 0x34, 0x4B, 0xE5, 0x99, 0x57, 0x65, + 0xDC, 0x42, 0xBE, 0x1B, 0x08, 0x00, 0x45, 0xBA, + 0x66, 0x1E, 0x98, 0x63, 0x3F, 0x5D, 0xAD, 0xE0 + }, + { + 0xDF, 0xA5, 0xF4, 0xEC, 0xAD, 0x26, 0xBB, 0x41, + 0xD7, 0x94, 0x61, 0x02, 0x9E, 0x60, 0xCA, 0x86, + 0x44, 0xFB, 0x10, 0x59, 0x7B, 0xCB, 0x98, 0x3C, + 0x59, 0xE1, 0xB3, 0xD0, 0x3B, 0x22, 0x6C, 0xEC, + 0x74, 0x26, 0x3A, 0xE3, 0x11, 0xE2, 0xBC, 0x2B, + 0xA3, 0xCF, 0xE3, 0x13, 0x5E, 0xB2, 0x52, 0x1D, + 0x54, 0xC0, 0x8E, 0x44, 0x5E, 0xEA, 0xB6, 0xAB, + 0xCB, 0xFC, 0x23, 0xC8, 0x77, 0x50, 0xF0, 0xFB + }, + { + 0xAD, 0x9C, 0xDD, 0x9E, 0xCF, 0x02, 0xC7, 0x47, + 0x4B, 0xA3, 0x86, 0xDE, 0x19, 0xEC, 0x59, 0xE6, + 0xD3, 0xB4, 0x17, 0x8E, 0x9D, 0x6E, 0x4F, 0x81, + 0xF8, 0xC5, 0x75, 0xD2, 0x17, 0xA7, 0x77, 0xF9, + 0x20, 0xB8, 0xD5, 0x18, 0x72, 0x1E, 0xD3, 0xA2, + 0x2E, 0x34, 0x62, 0xA1, 0xB4, 0xC3, 0x7A, 0x39, + 0xD9, 0x26, 0xCD, 0x58, 0xFD, 0x6E, 0x90, 0xBB, + 0xDF, 0x13, 0x50, 0x56, 0xDF, 0x25, 0xA3, 0xC1 + }, + { + 0x8E, 0xF8, 0xDE, 0xDE, 0x0D, 0x58, 0xCE, 0x33, + 0x32, 0x0E, 0x8E, 0xB7, 0xB7, 0xCB, 0xB0, 0x1F, + 0x06, 0x2C, 0x45, 0xDA, 0x89, 0x8B, 0x98, 0xB6, + 0xD5, 0x1B, 0x8C, 0xE0, 0xE9, 0xF5, 0xB0, 0x9D, + 0x0C, 0x6E, 0xDA, 0x78, 0x2A, 0x95, 0x5E, 0x77, + 0xF9, 0x1F, 0xB6, 0x38, 0xCB, 0x6E, 0xA8, 0x40, + 0x20, 0xA7, 0xB7, 0xA1, 0x44, 0x43, 0x9F, 0xCF, + 0xF2, 0xB9, 0xE0, 0xCE, 0xCE, 0x3A, 0x08, 0x24 + }, + { + 0x24, 0xFD, 0x25, 0x47, 0x21, 0xE6, 0x3F, 0x49, + 0xBF, 0x71, 0x8B, 0xFF, 0x77, 0xC1, 0xAA, 0xB5, + 0xE4, 0x9A, 0xBF, 0x86, 0x7F, 0x2B, 0xA5, 0x52, + 0x22, 0xE7, 0xCB, 0xE1, 0xBC, 0x2B, 0x23, 0x2F, + 0xF8, 0x1C, 0x90, 0x89, 0xC8, 0x20, 0xFB, 0x1D, + 0xBF, 0x0F, 0xA2, 0x94, 0x5A, 0x1A, 0x65, 0xFE, + 0x53, 0x18, 0x6B, 0x9E, 0x09, 0x70, 0x70, 0xB5, + 0xB3, 0xAA, 0x20, 0xC0, 0xF6, 0x81, 0x07, 0xF3 + }, + { + 0x36, 0xF1, 0x87, 0xEF, 0xA6, 0x70, 0x2E, 0xEB, + 0x23, 0x34, 0xD4, 0x09, 0x31, 0xAC, 0xC9, 0x7C, + 0x61, 0x25, 0x7E, 0xF8, 0xF4, 0x57, 0x1A, 0x0F, + 0x45, 0x07, 0x96, 0x46, 0x5D, 0x1C, 0xD2, 0xED, + 0x37, 0x90, 0x4C, 0x26, 0x20, 0xEC, 0x40, 0x86, + 0x66, 0xD7, 0x3F, 0xB8, 0x7B, 0xA6, 0x66, 0x14, + 0x5A, 0xDC, 0x99, 0x13, 0x7B, 0xDC, 0xBD, 0x7B, + 0xF2, 0x2E, 0x1C, 0x1F, 0x7B, 0x6A, 0x69, 0xAB + }, + { + 0xD1, 0x95, 0x58, 0xB6, 0x07, 0x5A, 0x56, 0x6B, + 0x5D, 0xBF, 0xD6, 0xFE, 0xDF, 0x10, 0xEC, 0xFB, + 0x4B, 0xC9, 0x83, 0x0D, 0x81, 0xB4, 0x29, 0x76, + 0xF3, 0xD9, 0x4C, 0x0D, 0xE5, 0x66, 0x6F, 0xE7, + 0x20, 0x73, 0xEA, 0xF2, 0x74, 0x8B, 0xF7, 0x26, + 0xCA, 0x18, 0xFE, 0x5C, 0x21, 0x1C, 0x77, 0xD7, + 0x86, 0x7C, 0xB7, 0xB7, 0xD8, 0x7B, 0x28, 0xC2, + 0x91, 0x20, 0xC7, 0x97, 0x4A, 0x1D, 0x08, 0x49 + }, + { + 0x4E, 0x59, 0x3C, 0x8B, 0x5F, 0xF4, 0x4D, 0xD2, + 0xCA, 0xA7, 0x75, 0x7F, 0xBF, 0xB1, 0x89, 0xA6, + 0x3C, 0xE0, 0xDE, 0x5B, 0x72, 0xB7, 0x19, 0x5A, + 0x86, 0x7A, 0xF0, 0x5E, 0xCA, 0x34, 0x89, 0x0D, + 0x40, 0xB6, 0x72, 0x2B, 0xD8, 0xA5, 0x7F, 0x34, + 0xF9, 0xCE, 0x33, 0x2E, 0xAA, 0x95, 0x34, 0x3D, + 0x83, 0x2E, 0x15, 0xB3, 0x03, 0x9E, 0xBD, 0x90, + 0xDE, 0x27, 0x0E, 0x5D, 0xFA, 0x02, 0xE2, 0xF1 + }, + { + 0xEB, 0x16, 0x91, 0xD7, 0x6E, 0xD9, 0xB5, 0x1E, + 0x49, 0x2A, 0xF9, 0x70, 0x2D, 0xD6, 0xAF, 0xB7, + 0x2F, 0x81, 0xE0, 0xCC, 0x16, 0x5F, 0xCA, 0xCB, + 0xB4, 0x58, 0x25, 0x92, 0x26, 0xDD, 0x31, 0xC6, + 0xAA, 0x2D, 0x0A, 0x04, 0x19, 0x76, 0xDC, 0xD2, + 0x3E, 0xBF, 0x90, 0x51, 0xD4, 0x19, 0xE8, 0x7D, + 0x7A, 0xE5, 0xEF, 0xE6, 0xA9, 0xA0, 0xD9, 0x47, + 0x72, 0xEE, 0xD3, 0x2C, 0x6E, 0xAF, 0x5B, 0xF3 + }, + { + 0x30, 0x70, 0x9A, 0x28, 0x32, 0xDC, 0x6C, 0xB5, + 0xFE, 0xAB, 0x36, 0xDC, 0x79, 0x8A, 0x71, 0xCB, + 0xCE, 0xAF, 0xFF, 0xAB, 0x79, 0x97, 0x00, 0x5A, + 0x6C, 0x47, 0xFA, 0x7F, 0x79, 0x46, 0x44, 0x06, + 0x60, 0xC9, 0x9C, 0xB7, 0xA7, 0xD9, 0xCB, 0xC9, + 0x68, 0x84, 0x9D, 0x79, 0x29, 0xA5, 0xBA, 0x0C, + 0xF5, 0x1B, 0x62, 0xB5, 0xB8, 0x98, 0x87, 0xE6, + 0x29, 0x9E, 0x18, 0xA2, 0xDB, 0x14, 0xC3, 0x60 + }, + { + 0xFE, 0x81, 0x77, 0x82, 0x35, 0x04, 0xF4, 0x25, + 0xDE, 0xAE, 0x54, 0x02, 0x80, 0xCA, 0x7C, 0x16, + 0xD6, 0x56, 0x10, 0xE3, 0xD0, 0x55, 0x4B, 0x86, + 0x3E, 0xD3, 0xCB, 0xD0, 0xCE, 0x51, 0x6B, 0x3F, + 0x1D, 0xBE, 0x0F, 0x52, 0x7B, 0xB3, 0xF9, 0x7E, + 0xAD, 0x08, 0x85, 0xDF, 0xAE, 0x7E, 0x39, 0xEF, + 0xDE, 0x9C, 0xB3, 0x08, 0x53, 0xCB, 0x4F, 0xE5, + 0x14, 0xEC, 0xDA, 0x74, 0xE4, 0x48, 0xD4, 0x6D + }, + { + 0x1B, 0x09, 0x4F, 0xED, 0x5E, 0xCC, 0x75, 0x18, + 0xCC, 0xAA, 0xDC, 0xE4, 0xBC, 0x5D, 0xC2, 0xFE, + 0xC0, 0x11, 0x4E, 0x3C, 0xE5, 0x08, 0x98, 0x8B, + 0x2A, 0x28, 0x25, 0xEA, 0xE7, 0xDE, 0x4D, 0x3B, + 0xC4, 0xCA, 0x68, 0x45, 0x63, 0xFF, 0x66, 0x16, + 0x02, 0xDB, 0xC3, 0x7E, 0xD5, 0xD0, 0x94, 0x4E, + 0xEE, 0x75, 0x6D, 0xD3, 0xD5, 0x1B, 0x12, 0xFD, + 0xE7, 0xA4, 0x6B, 0xCF, 0x35, 0x54, 0x5D, 0x6D + }, + { + 0x19, 0xCD, 0x56, 0x49, 0x2B, 0xC0, 0xC2, 0xD3, + 0xFB, 0x1F, 0x39, 0x55, 0x4F, 0xC6, 0xF8, 0x4E, + 0x66, 0x32, 0x8E, 0x5F, 0x19, 0x2C, 0xB4, 0xA6, + 0x36, 0x40, 0xB4, 0xB9, 0x17, 0xFA, 0x74, 0x63, + 0xB8, 0x5E, 0x50, 0xA9, 0x10, 0xEB, 0xF8, 0x6D, + 0xD2, 0x74, 0x57, 0xB1, 0xF1, 0x00, 0x29, 0x97, + 0xC0, 0x6E, 0xB1, 0x7F, 0x04, 0x3D, 0x04, 0xE2, + 0xCF, 0x9F, 0xB6, 0xF5, 0x2D, 0x6F, 0x2C, 0x61 + }, + { + 0x35, 0xE8, 0x9F, 0x8D, 0x0A, 0x03, 0x46, 0xFE, + 0x3F, 0xAA, 0x52, 0x5C, 0x63, 0xD6, 0xF5, 0x14, + 0x04, 0xCA, 0xF9, 0x19, 0x5E, 0x91, 0x7D, 0x1E, + 0x3A, 0x8D, 0x92, 0xD5, 0x5E, 0xE8, 0xCF, 0xEB, + 0xE1, 0xE1, 0xA6, 0x6F, 0x7B, 0xF7, 0xC8, 0x79, + 0xE8, 0x46, 0x46, 0xD0, 0x50, 0xAA, 0xE3, 0xA9, + 0x0B, 0x23, 0x6A, 0x32, 0xF9, 0x2F, 0x75, 0x19, + 0x59, 0x15, 0x2F, 0xAC, 0x73, 0xEB, 0x4C, 0xBE + }, + { + 0xD2, 0xC5, 0x1E, 0xC0, 0x63, 0x71, 0xD4, 0xBD, + 0x25, 0x9D, 0x2E, 0x5B, 0xEF, 0x3F, 0x25, 0xFF, + 0xE1, 0x7B, 0xDF, 0x73, 0xA7, 0x7E, 0xA4, 0x17, + 0xA7, 0x5D, 0xF5, 0x92, 0xF4, 0xD3, 0x5E, 0x9C, + 0x54, 0xC1, 0x8E, 0x1D, 0xA4, 0xAA, 0x0C, 0x0D, + 0xC9, 0x9B, 0x58, 0xAC, 0x7C, 0x33, 0x47, 0x28, + 0x90, 0x28, 0x5D, 0x26, 0x48, 0x2E, 0xD4, 0x0A, + 0x84, 0x32, 0xB8, 0x64, 0x5A, 0x10, 0x69, 0x84 + }, + { + 0x10, 0xF3, 0xA6, 0xEC, 0x5D, 0x32, 0xAE, 0x6B, + 0x69, 0xA9, 0x85, 0xB8, 0x81, 0xA2, 0xF6, 0x7C, + 0x7F, 0x7F, 0x51, 0x57, 0xEE, 0x04, 0xE5, 0x2D, + 0x39, 0x1C, 0xD9, 0xB6, 0x80, 0xFF, 0xE8, 0x13, + 0x99, 0xED, 0x76, 0xF7, 0xC8, 0x77, 0xE5, 0xC8, + 0x0D, 0x99, 0x31, 0x2B, 0x0C, 0x34, 0x28, 0x96, + 0x21, 0x18, 0x54, 0x93, 0x3E, 0x83, 0x4E, 0x9F, + 0xA6, 0x3A, 0x96, 0x22, 0x76, 0x0F, 0xCA, 0x9E + }, + { + 0x92, 0xE0, 0x25, 0x35, 0xF9, 0xC0, 0x43, 0xC1, + 0x0D, 0x2D, 0x4F, 0x7A, 0xAB, 0x7A, 0x2A, 0xD7, + 0x1D, 0xE1, 0x3F, 0x35, 0x55, 0x22, 0xA1, 0xFE, + 0xBE, 0x22, 0xD6, 0x25, 0xB6, 0x59, 0xC3, 0xA7, + 0x64, 0x44, 0x3D, 0xB4, 0x10, 0x9E, 0x1D, 0x41, + 0xF9, 0x4B, 0x7D, 0x66, 0xE0, 0x7F, 0xA9, 0x1A, + 0x02, 0x81, 0x28, 0x51, 0x74, 0xAC, 0x5F, 0x53, + 0x9F, 0x29, 0x73, 0xB3, 0x41, 0x44, 0xC6, 0x77 + }, + { + 0x7C, 0x0F, 0x79, 0xC6, 0x55, 0x5C, 0x26, 0x77, + 0x8D, 0x6D, 0xD2, 0x49, 0x48, 0x0E, 0x09, 0xC3, + 0x35, 0xF6, 0x80, 0x66, 0x98, 0x41, 0x11, 0x53, + 0x04, 0x7B, 0xFE, 0xCF, 0xE3, 0x74, 0x23, 0xED, + 0x42, 0x91, 0xE2, 0xF1, 0xE4, 0xC0, 0xF6, 0xDF, + 0x80, 0x08, 0x68, 0x5F, 0xD7, 0xA2, 0x7F, 0x13, + 0x4A, 0x5C, 0x22, 0x07, 0x6B, 0xFD, 0x9C, 0x97, + 0x53, 0x7F, 0x03, 0xC6, 0xAD, 0x5F, 0xC1, 0xC6 + }, + { + 0x9F, 0x1D, 0x1A, 0xAA, 0x84, 0xF4, 0xA0, 0x64, + 0x18, 0x57, 0x8A, 0x33, 0xA7, 0x50, 0xB1, 0x42, + 0x1F, 0x1F, 0xE8, 0xCE, 0x7B, 0x70, 0x3C, 0x60, + 0x24, 0x83, 0x29, 0x9C, 0x3A, 0x1C, 0x00, 0x63, + 0x85, 0xA4, 0x42, 0x2B, 0xEA, 0x65, 0x86, 0xD3, + 0x3D, 0xDB, 0xF6, 0x4D, 0x1A, 0x4A, 0x38, 0x7D, + 0xC2, 0x71, 0xD1, 0x22, 0x6F, 0xBE, 0xCF, 0x09, + 0x5A, 0x87, 0xF2, 0x16, 0x96, 0x6B, 0xB8, 0x75 + }, + { + 0xC7, 0x68, 0xC2, 0xB7, 0x2A, 0xC5, 0xC7, 0xE7, + 0x19, 0xBA, 0xB3, 0x34, 0x9C, 0x51, 0xB1, 0xE1, + 0xB2, 0x66, 0xC2, 0xA8, 0xE2, 0xC7, 0xF7, 0xF9, + 0x30, 0x47, 0x10, 0x15, 0x2D, 0x75, 0x89, 0x5B, + 0xB9, 0x4E, 0x6D, 0x2F, 0x22, 0x05, 0xE4, 0x04, + 0x2A, 0x79, 0xDB, 0xE5, 0x1B, 0x78, 0xFE, 0x74, + 0x06, 0x41, 0x1A, 0x4D, 0x1A, 0x48, 0x29, 0xF6, + 0x13, 0x14, 0x77, 0xED, 0x55, 0x88, 0x2E, 0x8A + }, + { + 0xE8, 0x3F, 0xAE, 0x6B, 0x59, 0xBA, 0xED, 0x2A, + 0x47, 0x07, 0xFB, 0xF5, 0x4A, 0x64, 0xB3, 0x61, + 0x02, 0x63, 0xA9, 0xF2, 0x3B, 0xFE, 0x7E, 0xEA, + 0x66, 0x82, 0x84, 0xEB, 0x0D, 0x01, 0x91, 0x5F, + 0x16, 0x2C, 0xC4, 0x2D, 0x2A, 0xCD, 0xA4, 0x9E, + 0x29, 0xA6, 0x48, 0x77, 0xBB, 0x84, 0x41, 0x2A, + 0xC0, 0x80, 0xDC, 0x52, 0x11, 0x57, 0x51, 0xC6, + 0xEF, 0x02, 0xA4, 0x78, 0xF0, 0xC7, 0x00, 0x6D + }, + { + 0xB2, 0x6D, 0x32, 0x56, 0x94, 0x2A, 0xF0, 0x2B, + 0xAE, 0x33, 0x1E, 0xF2, 0xE1, 0xF6, 0x1C, 0x60, + 0x8D, 0xD7, 0xA0, 0x94, 0x9F, 0xD7, 0xD2, 0x74, + 0x80, 0x09, 0x5B, 0x19, 0xE1, 0x72, 0xB7, 0x41, + 0xE5, 0xC7, 0xCB, 0xA1, 0xE1, 0x4D, 0xE7, 0xA4, + 0x0B, 0xB0, 0x99, 0xDC, 0x1A, 0x73, 0xA9, 0x4B, + 0xFB, 0xA1, 0x58, 0x06, 0x65, 0xA4, 0x2E, 0x5C, + 0x51, 0xF0, 0x3B, 0xC1, 0x0D, 0x3A, 0x65, 0xE2 + }, + { + 0xAB, 0xB4, 0x49, 0xA5, 0x90, 0x8F, 0xF3, 0xA7, + 0x0A, 0x53, 0x45, 0x9B, 0x24, 0xF4, 0xC6, 0x9F, + 0x6E, 0xFC, 0xC9, 0x02, 0xDC, 0x77, 0xD4, 0xC7, + 0xEE, 0xC5, 0xD8, 0x6E, 0x51, 0xC1, 0xBA, 0x1E, + 0x21, 0x97, 0x6A, 0x6F, 0x7E, 0x62, 0x37, 0x93, + 0x0E, 0x2A, 0xE1, 0x58, 0xBC, 0x19, 0xBC, 0x40, + 0x86, 0x7E, 0xEB, 0x15, 0x52, 0xD8, 0xCA, 0x04, + 0x14, 0xD0, 0xB0, 0xA9, 0x15, 0xC6, 0xDF, 0x0D + }, + { + 0xB3, 0xBA, 0xF5, 0xC5, 0x2C, 0xB6, 0xC7, 0x9D, + 0x66, 0x1D, 0x25, 0x07, 0xEA, 0x38, 0xBB, 0xDE, + 0xE3, 0xBC, 0xC6, 0x6D, 0xC6, 0x3E, 0x4B, 0x68, + 0x86, 0x72, 0x45, 0xB6, 0x31, 0x01, 0x26, 0x63, + 0xF3, 0x51, 0xA7, 0x72, 0xBD, 0xD9, 0x92, 0x1B, + 0xC9, 0xA5, 0xFF, 0x18, 0x25, 0xFD, 0x65, 0x7D, + 0x5C, 0x6F, 0x59, 0xA4, 0xC9, 0x37, 0xFD, 0x43, + 0xAC, 0x8F, 0xE9, 0xB6, 0x84, 0xFF, 0x00, 0x10 + }, + { + 0x9E, 0xDD, 0x9A, 0x83, 0x6F, 0xC1, 0x82, 0xD4, + 0xB3, 0x64, 0xF5, 0x6E, 0xEA, 0xA8, 0x46, 0xB7, + 0x94, 0x77, 0xB6, 0xD8, 0xAC, 0x07, 0xD7, 0x73, + 0x01, 0xDF, 0x00, 0x78, 0xA0, 0x39, 0xD2, 0x75, + 0x99, 0xED, 0xC4, 0x61, 0x57, 0xC1, 0x4E, 0x99, + 0xCC, 0x10, 0x81, 0x45, 0xA4, 0xFB, 0xEA, 0x09, + 0xE6, 0x44, 0xDC, 0x76, 0x4B, 0x99, 0x41, 0x40, + 0x90, 0x0B, 0xBA, 0xB7, 0xE7, 0x03, 0x72, 0x40 + }, + { + 0x3D, 0x66, 0xF6, 0x75, 0x64, 0x90, 0x7B, 0xE1, + 0x26, 0x4D, 0x53, 0x06, 0x42, 0xF6, 0x2D, 0x91, + 0x93, 0x6C, 0x47, 0xF8, 0x72, 0x63, 0xF8, 0x4B, + 0x18, 0x4F, 0x89, 0xC5, 0xC4, 0xD4, 0x7E, 0x41, + 0x80, 0x80, 0xEE, 0x3D, 0x1E, 0x3A, 0x2D, 0xF4, + 0xB5, 0x1F, 0xBB, 0x1C, 0xA3, 0xBC, 0x74, 0xAE, + 0x53, 0x93, 0x57, 0x24, 0x26, 0x10, 0x52, 0x3A, + 0xBF, 0xED, 0x3D, 0xFC, 0x90, 0x03, 0x72, 0xF8 + }, + { + 0xDC, 0x6A, 0xF3, 0x8D, 0xFA, 0xD9, 0x8A, 0x30, + 0xFF, 0x64, 0x66, 0x97, 0x93, 0x87, 0x8C, 0xF5, + 0x36, 0x07, 0x3C, 0xCE, 0xA4, 0xF2, 0xD6, 0x0E, + 0x17, 0xB5, 0xBF, 0xED, 0xB4, 0xC3, 0x22, 0xD3, + 0x97, 0x8D, 0xA4, 0x80, 0x70, 0x0A, 0x24, 0x3D, + 0x9F, 0x20, 0xCE, 0x19, 0x81, 0xF3, 0xC5, 0x79, + 0x22, 0xF0, 0x1D, 0x1C, 0xD0, 0x19, 0x5B, 0x0C, + 0x4F, 0x8C, 0x5A, 0x50, 0xC9, 0x04, 0xAB, 0x48 + }, + { + 0xE4, 0xF0, 0x63, 0xD4, 0xDC, 0x32, 0x28, 0x16, + 0xD2, 0xBD, 0xBB, 0x2D, 0x24, 0x4B, 0xD0, 0x10, + 0x6D, 0x51, 0x45, 0x59, 0x6A, 0x96, 0x58, 0xD7, + 0x02, 0x39, 0x50, 0x05, 0x65, 0xD8, 0x52, 0xE1, + 0x17, 0x23, 0xEF, 0xF6, 0x72, 0xBE, 0x7B, 0x58, + 0x2C, 0xB8, 0x8F, 0xE4, 0x9B, 0x95, 0x07, 0x55, + 0x4A, 0x54, 0xBE, 0x2B, 0xE7, 0x90, 0xC1, 0x46, + 0x55, 0x49, 0xF5, 0xDD, 0xEC, 0x9F, 0xB5, 0x27 + }, + { + 0x0A, 0xD6, 0xAF, 0xA3, 0xE6, 0x69, 0xE1, 0xBD, + 0x1C, 0xC1, 0xF0, 0x4E, 0x95, 0x56, 0xC0, 0x22, + 0x37, 0xBB, 0x27, 0x41, 0xB0, 0x9D, 0x20, 0x7A, + 0xBF, 0xBA, 0x20, 0x0A, 0xD2, 0x34, 0x7D, 0x49, + 0xC9, 0x48, 0x41, 0x58, 0x3B, 0x31, 0x8D, 0x9B, + 0xF8, 0x89, 0x4B, 0x43, 0x99, 0xA6, 0x49, 0x72, + 0x46, 0x0D, 0x90, 0xDC, 0x19, 0x32, 0x90, 0xD7, + 0x12, 0xE3, 0x82, 0x93, 0x58, 0xB3, 0xB6, 0x26 + }, +}; + + + + +static const uint8_t blake2sp_kat[BLAKE2_KAT_LENGTH][BLAKE2S_OUTBYTES] = +{ + { + 0xDD, 0x0E, 0x89, 0x17, 0x76, 0x93, 0x3F, 0x43, + 0xC7, 0xD0, 0x32, 0xB0, 0x8A, 0x91, 0x7E, 0x25, + 0x74, 0x1F, 0x8A, 0xA9, 0xA1, 0x2C, 0x12, 0xE1, + 0xCA, 0xC8, 0x80, 0x15, 0x00, 0xF2, 0xCA, 0x4F + }, + { + 0xA6, 0xB9, 0xEE, 0xCC, 0x25, 0x22, 0x7A, 0xD7, + 0x88, 0xC9, 0x9D, 0x3F, 0x23, 0x6D, 0xEB, 0xC8, + 0xDA, 0x40, 0x88, 0x49, 0xE9, 0xA5, 0x17, 0x89, + 0x78, 0x72, 0x7A, 0x81, 0x45, 0x7F, 0x72, 0x39 + }, + { + 0xDA, 0xCA, 0xDE, 0xCE, 0x7A, 0x8E, 0x6B, 0xF3, + 0xAB, 0xFE, 0x32, 0x4C, 0xA6, 0x95, 0x43, 0x69, + 0x84, 0xB8, 0x19, 0x5D, 0x29, 0xF6, 0xBB, 0xD8, + 0x96, 0xE4, 0x1E, 0x18, 0xE2, 0x1C, 0x91, 0x45 + }, + { + 0xED, 0x14, 0x41, 0x3B, 0x40, 0xDA, 0x68, 0x9F, + 0x1F, 0x7F, 0xED, 0x2B, 0x08, 0xDF, 0xF4, 0x5B, + 0x80, 0x92, 0xDB, 0x5E, 0xC2, 0xC3, 0x61, 0x0E, + 0x02, 0x72, 0x4D, 0x20, 0x2F, 0x42, 0x3C, 0x46 + }, + { + 0x9B, 0x8A, 0x52, 0x7B, 0x52, 0x72, 0x25, 0x0A, + 0x1E, 0xC3, 0x97, 0x38, 0x8F, 0x04, 0x09, 0x14, + 0x95, 0x48, 0x06, 0xE7, 0x94, 0xDB, 0x04, 0xB7, + 0x0A, 0x46, 0x11, 0xBC, 0x59, 0x58, 0x6A, 0x83 + }, + { + 0x2B, 0xB6, 0x33, 0x37, 0x29, 0x00, 0x0B, 0xE3, + 0xD5, 0xA2, 0x1B, 0x98, 0xF8, 0xE7, 0xEA, 0xD0, + 0x77, 0xF1, 0x51, 0xA5, 0x39, 0x39, 0x19, 0xEB, + 0x67, 0xC8, 0x76, 0xEE, 0x00, 0xBB, 0xBB, 0x04 + }, + { + 0x63, 0xC0, 0x14, 0x08, 0x15, 0x4A, 0xD1, 0x9D, + 0x7F, 0xB7, 0x39, 0xF3, 0x11, 0x78, 0x17, 0x80, + 0x46, 0x2C, 0xF2, 0xEE, 0xCC, 0xE6, 0x0F, 0x06, + 0x4E, 0x85, 0x34, 0x87, 0xC2, 0x72, 0xE3, 0xEB + }, + { + 0x3D, 0x05, 0x1A, 0x11, 0x76, 0x01, 0x9C, 0xA3, + 0x7B, 0xF3, 0x3D, 0x60, 0x42, 0x7F, 0x8D, 0x9D, + 0x1C, 0x3A, 0xBD, 0x59, 0x82, 0x97, 0xCF, 0xB4, + 0x23, 0x5F, 0x74, 0x7D, 0x7C, 0x7C, 0x7F, 0xEC + }, + { + 0x39, 0x1E, 0xA9, 0x12, 0xDF, 0x4D, 0x4D, 0x79, + 0xA4, 0x64, 0x6D, 0x9D, 0xA2, 0x54, 0x9A, 0x44, + 0x6D, 0x22, 0x40, 0xF6, 0x24, 0x15, 0xD0, 0x70, + 0xA2, 0xE0, 0x93, 0x99, 0x2B, 0x47, 0x1F, 0xBA + }, + { + 0x32, 0x46, 0x40, 0x44, 0x0E, 0xA5, 0xC3, 0x08, + 0x2D, 0xDC, 0x30, 0x9E, 0x78, 0x09, 0xD7, 0x41, + 0xD6, 0xCC, 0x1B, 0x2D, 0x49, 0x0F, 0xF8, 0xC0, + 0x52, 0x12, 0x8A, 0x6E, 0xEB, 0x40, 0x9D, 0x62 + }, + { + 0xAB, 0x85, 0x5E, 0x6F, 0xA3, 0x9A, 0x5E, 0x8F, + 0xC9, 0x0E, 0xAC, 0xB9, 0x99, 0xC7, 0xF7, 0x8A, + 0xE7, 0x1E, 0x59, 0xC3, 0xD9, 0x7D, 0x60, 0xAF, + 0xE5, 0x17, 0xD5, 0x87, 0x92, 0x3B, 0x77, 0x11 + }, + { + 0x2A, 0x39, 0xDA, 0x45, 0x86, 0xEF, 0xC4, 0x77, + 0x85, 0xA7, 0xA8, 0xDA, 0x85, 0x68, 0x3A, 0x51, + 0x72, 0x4C, 0xDE, 0xF5, 0x41, 0x3B, 0x35, 0x6D, + 0xC4, 0xFB, 0x50, 0x05, 0x13, 0xF8, 0xFA, 0x2E + }, + { + 0x8A, 0x00, 0x57, 0xC1, 0xF7, 0x8A, 0xD6, 0x21, + 0x45, 0x55, 0xC0, 0x67, 0x07, 0x33, 0xE2, 0x9A, + 0x4C, 0x7E, 0x95, 0x62, 0x27, 0x66, 0x0E, 0xFE, + 0xB1, 0xD7, 0xFC, 0x79, 0xF5, 0x8E, 0xC6, 0xF2 + }, + { + 0x07, 0x64, 0xB0, 0x01, 0x7F, 0x5B, 0xD9, 0x51, + 0xF0, 0x1D, 0x9F, 0xDF, 0x95, 0xC0, 0xCB, 0x41, + 0x38, 0x98, 0x5D, 0x84, 0x79, 0x9C, 0xD4, 0x29, + 0x84, 0xE2, 0x5B, 0x51, 0x28, 0x00, 0xE7, 0x3C + }, + { + 0xCC, 0x02, 0x49, 0x56, 0x93, 0xC8, 0xE1, 0x84, + 0xAD, 0x2E, 0xD0, 0x9D, 0x53, 0x3D, 0xC3, 0x3B, + 0x76, 0xA7, 0x78, 0x3D, 0x62, 0x07, 0xFC, 0xAC, + 0xCB, 0x64, 0xF3, 0xED, 0x2C, 0x6D, 0x66, 0xE0 + }, + { + 0xC0, 0xDF, 0x49, 0xC2, 0x06, 0xA3, 0x42, 0x88, + 0x14, 0x32, 0x16, 0x84, 0x7D, 0xF3, 0x34, 0xD4, + 0x56, 0x9D, 0xAD, 0x73, 0xC2, 0xB1, 0xFF, 0x62, + 0x84, 0x88, 0x4F, 0xD3, 0x89, 0x41, 0xFB, 0x95 + }, + { + 0xB9, 0x19, 0x45, 0x19, 0xE4, 0x97, 0x8A, 0x9D, + 0xC8, 0x93, 0xB2, 0x8B, 0xD8, 0x08, 0xCD, 0xFA, + 0xBB, 0x1B, 0xD5, 0x10, 0xD8, 0x62, 0xB3, 0x17, + 0x1F, 0xF6, 0xE0, 0x17, 0xA4, 0x1B, 0x80, 0x4C + }, + { + 0xBB, 0xA9, 0x27, 0xAC, 0xF1, 0x1B, 0xEB, 0xD3, + 0x62, 0xA3, 0xA3, 0xEB, 0x78, 0xC4, 0xBB, 0x65, + 0xE6, 0x02, 0xA8, 0x70, 0x9F, 0xCE, 0xF3, 0x8D, + 0xC6, 0xC8, 0xB7, 0xBD, 0xA6, 0x64, 0xC3, 0x2C + }, + { + 0xEC, 0xB4, 0x90, 0x0A, 0x63, 0x92, 0x4E, 0x72, + 0x0D, 0x40, 0xF2, 0xD2, 0xB1, 0x4D, 0x1B, 0xB3, + 0x9C, 0x37, 0x01, 0xAD, 0x73, 0x46, 0xBD, 0x0B, + 0x67, 0x23, 0x42, 0x70, 0xBF, 0xBE, 0x7E, 0x70 + }, + { + 0xF8, 0x31, 0x5A, 0x21, 0xB2, 0x5E, 0x6B, 0xA8, + 0xBF, 0x59, 0xB1, 0x7B, 0x05, 0x91, 0x3B, 0x8C, + 0xA4, 0x65, 0x9F, 0x1C, 0xD8, 0x38, 0xFC, 0xC7, + 0x73, 0xC9, 0xEB, 0x12, 0xE7, 0x00, 0x4E, 0x09 + }, + { + 0x4B, 0x77, 0xAF, 0x67, 0xA9, 0x23, 0x2B, 0xF1, + 0x18, 0x4E, 0x57, 0x81, 0x82, 0x94, 0x03, 0x1E, + 0x55, 0xF1, 0xF8, 0x53, 0xC9, 0x4D, 0xBA, 0xB5, + 0x57, 0x75, 0x47, 0x33, 0x0D, 0x65, 0xAA, 0x61 + }, + { + 0x76, 0x85, 0x68, 0x39, 0x0F, 0xD2, 0xB8, 0x70, + 0x94, 0x11, 0x4E, 0xD4, 0xCF, 0x72, 0x3E, 0xA3, + 0x20, 0xFE, 0x97, 0x7B, 0x53, 0x18, 0x03, 0x05, + 0xC3, 0x84, 0x33, 0x54, 0x79, 0xF0, 0xB5, 0x9B + }, + { + 0xA4, 0x31, 0xCB, 0x27, 0x0F, 0x3E, 0x2C, 0x9B, + 0x7A, 0x95, 0x93, 0xB1, 0x55, 0xCC, 0xEC, 0xFF, + 0x5B, 0x5C, 0x4A, 0x2D, 0xCD, 0x5D, 0x6B, 0xB1, + 0xC4, 0x85, 0xAA, 0x28, 0x69, 0x97, 0xF9, 0x15 + }, + { + 0xD6, 0x91, 0xFA, 0x6A, 0x79, 0x0B, 0x1A, 0x51, + 0x79, 0x80, 0x08, 0x7F, 0x50, 0xB0, 0x3D, 0xED, + 0x8C, 0x6E, 0xD4, 0x86, 0xD0, 0x84, 0x22, 0x1C, + 0x82, 0x7D, 0x9B, 0xD9, 0x22, 0xBE, 0xB8, 0xC0 + }, + { + 0x8F, 0x97, 0x8A, 0x49, 0x32, 0xF4, 0x45, 0x98, + 0x13, 0xE8, 0xFE, 0x15, 0x68, 0x6E, 0x4E, 0xFA, + 0x25, 0xC2, 0xC5, 0xFF, 0x5A, 0x3A, 0x4F, 0x8C, + 0x9B, 0x14, 0x96, 0x5D, 0x2F, 0x0B, 0xE4, 0x61 + }, + { + 0x1E, 0xFB, 0xD0, 0xC1, 0x31, 0x44, 0x91, 0x42, + 0xF2, 0x29, 0x5F, 0x2D, 0x42, 0x41, 0x1D, 0xFE, + 0x0F, 0x48, 0xD4, 0xAC, 0xAE, 0x76, 0x2D, 0x8D, + 0xF6, 0x7A, 0x57, 0x0B, 0xF7, 0xB1, 0xDC, 0xD5 + }, + { + 0xD5, 0x3B, 0xA9, 0x33, 0x46, 0x14, 0x3A, 0xB8, + 0xE0, 0xD3, 0xD1, 0xBF, 0x27, 0x27, 0x06, 0xD1, + 0x69, 0xE6, 0x6C, 0x69, 0xC7, 0xB8, 0xF4, 0xA5, + 0xE8, 0x2F, 0xEF, 0x44, 0x07, 0x02, 0xBC, 0xF2 + }, + { + 0xF7, 0x1A, 0x3E, 0xC0, 0x1A, 0xA3, 0x82, 0xEA, + 0x76, 0x99, 0x2B, 0x43, 0x0A, 0x7F, 0x42, 0xC7, + 0xAD, 0x2A, 0x86, 0xAE, 0xA9, 0xC1, 0x9E, 0x76, + 0xCD, 0x17, 0x32, 0xEC, 0x68, 0x30, 0xDE, 0x6F + }, + { + 0x80, 0xA6, 0xAB, 0x7B, 0x71, 0x04, 0x64, 0xF9, + 0x3E, 0x6C, 0xBA, 0x96, 0x86, 0x4A, 0xA6, 0x40, + 0x9B, 0xCA, 0xFC, 0x1B, 0xF4, 0xB3, 0x2A, 0x30, + 0x93, 0x72, 0xE8, 0x57, 0xE8, 0x04, 0x06, 0x8C + }, + { + 0xDB, 0xDE, 0x81, 0xE5, 0x1A, 0x52, 0x17, 0x4B, + 0x10, 0x14, 0x90, 0x1B, 0x53, 0xBE, 0xF8, 0x8D, + 0xE9, 0x3B, 0x29, 0xE2, 0x74, 0x34, 0x7E, 0x8E, + 0x9A, 0x7B, 0x03, 0x74, 0x56, 0x62, 0x9F, 0x35 + }, + { + 0x75, 0xF2, 0x74, 0x46, 0x6B, 0x1A, 0x2D, 0x0F, + 0xD8, 0x45, 0xBB, 0xB5, 0x7C, 0x38, 0xC9, 0x89, + 0x51, 0x6E, 0x15, 0x68, 0x32, 0x0A, 0xB5, 0x17, + 0xB1, 0x63, 0xEA, 0xF7, 0x09, 0x23, 0x4C, 0xC7 + }, + { + 0xAF, 0xE1, 0xA0, 0x59, 0x1C, 0x49, 0x1D, 0x41, + 0x6E, 0xB6, 0x4F, 0x62, 0x86, 0xF3, 0xBA, 0x29, + 0xD4, 0xC9, 0x99, 0x82, 0x14, 0xA3, 0x83, 0x1C, + 0x39, 0x01, 0x4A, 0xC0, 0x30, 0x55, 0x79, 0x45 + }, + { + 0x67, 0xFF, 0x6A, 0xCD, 0xBE, 0x8A, 0x99, 0xA1, + 0x66, 0xA5, 0xD9, 0xCF, 0x32, 0x13, 0x65, 0x06, + 0xB5, 0x48, 0xD6, 0xC9, 0x47, 0xC2, 0x4C, 0x69, + 0x9C, 0xEA, 0x3A, 0xFD, 0x92, 0xAD, 0xFA, 0xCA + }, + { + 0xBF, 0xB4, 0xD0, 0xC7, 0x11, 0x20, 0x75, 0x26, + 0x2C, 0x2D, 0xD2, 0x48, 0xF3, 0x34, 0xB2, 0xEF, + 0x15, 0x40, 0x08, 0x7E, 0xCC, 0x73, 0x82, 0xBC, + 0x2A, 0x27, 0x25, 0x75, 0xC5, 0x00, 0x9F, 0x70 + }, + { + 0x17, 0xC9, 0x4B, 0x9C, 0x53, 0x72, 0x43, 0xF2, + 0x33, 0x5B, 0x86, 0x39, 0x49, 0xB2, 0xB9, 0x1C, + 0x98, 0xA6, 0x95, 0x6D, 0x7C, 0x10, 0xAA, 0x98, + 0x99, 0x59, 0xA8, 0x0F, 0x91, 0x0C, 0x25, 0x22 + }, + { + 0xF6, 0x33, 0x8F, 0x43, 0x4D, 0x31, 0x94, 0x10, + 0x19, 0x6D, 0x95, 0x19, 0xAB, 0xCA, 0xEF, 0xF7, + 0xD5, 0x54, 0x39, 0xFD, 0x2A, 0xA5, 0xBA, 0xBF, + 0x7A, 0x7E, 0x79, 0x13, 0xB2, 0x94, 0xED, 0x4D + }, + { + 0x08, 0xEF, 0x7D, 0x65, 0xF9, 0xBB, 0xF3, 0xDA, + 0x1F, 0x78, 0x84, 0xAE, 0x9B, 0x75, 0x90, 0x1F, + 0xD8, 0x52, 0x95, 0x66, 0x2A, 0x6E, 0xA7, 0x1D, + 0xE0, 0x8B, 0xEE, 0x38, 0x34, 0x57, 0x62, 0x78 + }, + { + 0x16, 0x47, 0xEC, 0xC2, 0xBA, 0x13, 0xF8, 0xB9, + 0x3B, 0x2F, 0xBC, 0xDC, 0x4E, 0x8F, 0x1D, 0xFA, + 0x47, 0xFE, 0x3B, 0xE1, 0x2A, 0xAA, 0x0E, 0x45, + 0x9B, 0x0E, 0x5A, 0x87, 0xF3, 0xA6, 0x9B, 0xB0 + }, + { + 0xFF, 0x92, 0x7A, 0x71, 0x78, 0x81, 0xF6, 0xFD, + 0x8E, 0xD8, 0xBF, 0x5D, 0x5E, 0x35, 0xBD, 0x80, + 0x16, 0x15, 0x73, 0xE5, 0x82, 0x94, 0x04, 0xC3, + 0x2D, 0x2A, 0x27, 0x6A, 0x01, 0xF4, 0xB9, 0x06 + }, + { + 0xC8, 0xCA, 0xF1, 0x36, 0xFF, 0x20, 0x9C, 0x82, + 0xE0, 0x24, 0x0C, 0x1E, 0x62, 0xA3, 0xBC, 0x7E, + 0x9C, 0xAC, 0x87, 0x3B, 0x01, 0x1C, 0xF7, 0xC5, + 0xE6, 0x7E, 0xC1, 0x87, 0xA5, 0xFB, 0xCD, 0x96 + }, + { + 0xD9, 0xAC, 0xC7, 0x3E, 0x3F, 0x42, 0x1E, 0x18, + 0x83, 0xB5, 0xED, 0x53, 0xD8, 0x2A, 0x9A, 0xEC, + 0x8F, 0x5D, 0xC9, 0x80, 0xC4, 0x2B, 0xCA, 0xEB, + 0x0E, 0x7D, 0x89, 0x76, 0xA3, 0x38, 0xEF, 0x51 + }, + { + 0x9F, 0x17, 0x3F, 0xCF, 0x08, 0xA5, 0x36, 0x21, + 0x93, 0xF3, 0x52, 0xC8, 0x25, 0x6A, 0xE5, 0x34, + 0xAE, 0x9C, 0xE7, 0xBF, 0xA4, 0xBC, 0x09, 0xFA, + 0xC9, 0x00, 0x98, 0xF9, 0x8A, 0x71, 0x62, 0x94 + }, + { + 0x0A, 0x72, 0x45, 0x79, 0xDC, 0x80, 0xBC, 0x0C, + 0x90, 0x04, 0xE5, 0x1B, 0xE7, 0xEF, 0xF3, 0xAF, + 0xA5, 0x30, 0x75, 0xAB, 0x4A, 0x32, 0x55, 0x77, + 0x33, 0x58, 0x6E, 0x82, 0x0F, 0xD3, 0x64, 0x23 + }, + { + 0x38, 0xF7, 0xC3, 0x40, 0xF4, 0xB1, 0x59, 0xB1, + 0xE5, 0x94, 0xF6, 0xEB, 0x83, 0x28, 0x49, 0x17, + 0xB7, 0xAA, 0x19, 0xC7, 0x4F, 0x57, 0x11, 0x7A, + 0x4E, 0x08, 0xCF, 0x7C, 0x4E, 0x32, 0xA2, 0x3C + }, + { + 0x1C, 0x67, 0x4B, 0xE2, 0x57, 0xE9, 0xB3, 0x31, + 0x34, 0xD4, 0x16, 0x8F, 0x15, 0x2F, 0x8B, 0x63, + 0xDF, 0xD7, 0x80, 0xC9, 0x7D, 0xC4, 0xDC, 0x37, + 0xAC, 0x26, 0xCC, 0x0A, 0xEF, 0xB7, 0x9C, 0x1A + }, + { + 0x2F, 0x0C, 0x59, 0x76, 0x16, 0xD5, 0x75, 0x17, + 0x14, 0xA5, 0xFB, 0x4E, 0xBF, 0x3C, 0x48, 0x1A, + 0x96, 0xC3, 0xAD, 0x14, 0x5E, 0xBD, 0xE0, 0x65, + 0x09, 0xF3, 0xA2, 0xE5, 0xF2, 0xC1, 0x3F, 0xC8 + }, + { + 0xFD, 0xDC, 0x69, 0xE0, 0xC9, 0x83, 0xCD, 0x82, + 0x83, 0xED, 0x81, 0x88, 0xBE, 0xC4, 0xE5, 0xF4, + 0x1D, 0xEA, 0x3D, 0x01, 0xB9, 0xE7, 0x4C, 0x4B, + 0xAF, 0x73, 0x41, 0xD8, 0xB4, 0xBF, 0x55, 0x3D + }, + { + 0x24, 0xD0, 0x83, 0xCB, 0xA0, 0x38, 0xC8, 0x7E, + 0x9A, 0xCB, 0x86, 0x81, 0x82, 0x02, 0x08, 0xB7, + 0x5C, 0xB3, 0x29, 0x3A, 0x96, 0xC9, 0xEF, 0xA7, + 0x5D, 0x2C, 0x63, 0xF1, 0x6B, 0x85, 0xFE, 0x1E + }, + { + 0x7F, 0x6A, 0x64, 0x9C, 0xCA, 0x89, 0xB2, 0x53, + 0xFF, 0xBD, 0x20, 0xC0, 0x16, 0x98, 0x01, 0x00, + 0xA8, 0x7C, 0x16, 0x81, 0x09, 0x62, 0x8F, 0xCC, + 0x66, 0x52, 0x5D, 0x8B, 0xAA, 0xFE, 0x50, 0x5F + }, + { + 0x6D, 0xA3, 0x73, 0xB4, 0xC1, 0x87, 0x92, 0xB3, + 0x20, 0x9A, 0xDD, 0x15, 0xA5, 0x07, 0x4A, 0x1D, + 0x70, 0xC1, 0x0B, 0xB3, 0x94, 0x80, 0xCA, 0x3F, + 0xE5, 0xC4, 0x39, 0xD9, 0x5F, 0xC2, 0x86, 0xCA + }, + { + 0x27, 0x0A, 0xFF, 0xA6, 0x42, 0x6F, 0x1A, 0x51, + 0x5C, 0x9B, 0x76, 0xDF, 0xC2, 0x7D, 0x18, 0x1F, + 0xC2, 0xFD, 0x57, 0xD0, 0x82, 0xA3, 0xBA, 0x2C, + 0x1E, 0xEF, 0x07, 0x15, 0x33, 0xA6, 0xDF, 0xB7 + }, + { + 0xC2, 0x2E, 0x15, 0xCF, 0xC5, 0xA3, 0xD1, 0x4B, + 0x64, 0xD1, 0x31, 0xF3, 0x5F, 0xB3, 0x5D, 0xD5, + 0xE6, 0xC5, 0x7D, 0xC4, 0xAF, 0xC5, 0x52, 0x27, + 0x75, 0x01, 0xEC, 0xA7, 0x64, 0xDA, 0x74, 0xBF + }, + { + 0xAD, 0x68, 0x3E, 0x96, 0xB8, 0xAC, 0x65, 0x8C, + 0x4F, 0x3F, 0x10, 0xAD, 0x22, 0xD9, 0x9B, 0x07, + 0xCB, 0x5E, 0xF9, 0xE3, 0x1C, 0xBE, 0x11, 0xE7, + 0xF7, 0xDC, 0x29, 0xF2, 0xAE, 0xE5, 0x02, 0x4C + }, + { + 0x78, 0xD3, 0xCE, 0xDA, 0x1C, 0xE0, 0x52, 0x93, + 0xF4, 0x30, 0xF6, 0x16, 0x7B, 0x33, 0xC9, 0x9F, + 0x0B, 0x1D, 0x6D, 0xAD, 0xE5, 0x21, 0x43, 0xC2, + 0x92, 0x55, 0x77, 0xC0, 0xBA, 0x82, 0x53, 0xEB + }, + { + 0xE0, 0x06, 0x45, 0x63, 0x44, 0xF9, 0x0F, 0x50, + 0x1C, 0x25, 0x81, 0x3F, 0x9B, 0xE2, 0xA3, 0xF4, + 0x0B, 0x98, 0x74, 0xFA, 0x05, 0x63, 0x98, 0x1C, + 0xD4, 0x56, 0xEE, 0x8D, 0x44, 0x80, 0x7C, 0x93 + }, + { + 0x39, 0x08, 0xE8, 0xD5, 0x47, 0xC0, 0xAF, 0xB1, + 0x13, 0x49, 0x49, 0x46, 0x63, 0x04, 0xA1, 0x45, + 0x02, 0x7E, 0x6B, 0xB7, 0xA7, 0x4D, 0xD1, 0xC1, + 0x62, 0xCD, 0xF0, 0xBC, 0xF7, 0x72, 0x37, 0xE8 + }, + { + 0x1B, 0x6C, 0x87, 0xA3, 0x48, 0x38, 0xC7, 0xCD, + 0x5F, 0xD0, 0x89, 0x14, 0x22, 0x4E, 0x90, 0xC2, + 0x2A, 0xBF, 0x5A, 0x97, 0xB1, 0x06, 0x46, 0xD9, + 0x8C, 0x49, 0x16, 0xD3, 0xA8, 0x93, 0x9E, 0x62 + }, + { + 0xB0, 0xD3, 0x8F, 0x82, 0xF2, 0x48, 0x91, 0x69, + 0x52, 0xB3, 0x16, 0xB6, 0xD3, 0x6D, 0x9E, 0x02, + 0x2D, 0xF6, 0xEE, 0xCC, 0x26, 0xC7, 0x62, 0xA6, + 0x55, 0xCF, 0x5F, 0x0A, 0xE6, 0x49, 0xE2, 0xBD + }, + { + 0x8D, 0x66, 0xFC, 0x9C, 0xED, 0xA5, 0xED, 0xDF, + 0xB1, 0xE0, 0x4D, 0x09, 0x6C, 0xA7, 0x0E, 0xF5, + 0x06, 0x50, 0xFB, 0x87, 0xCC, 0x6A, 0x9F, 0xFB, + 0xB3, 0xD2, 0x0B, 0xCE, 0x7B, 0x5A, 0x60, 0x74 + }, + { + 0x06, 0x43, 0x54, 0xE8, 0xE1, 0x1C, 0xF7, 0x13, + 0xB2, 0xC7, 0x2B, 0xA6, 0x7A, 0xC7, 0xD7, 0x6E, + 0x41, 0xBA, 0x61, 0xDB, 0x9C, 0x2D, 0xEA, 0x52, + 0x2E, 0x0B, 0xDA, 0x17, 0xCB, 0xA5, 0xE3, 0x92 + }, + { + 0xC8, 0xEF, 0x5F, 0x49, 0x8B, 0xD1, 0xBC, 0x70, + 0x7F, 0xBC, 0x7B, 0x5C, 0xBC, 0x2D, 0xFF, 0x04, + 0x93, 0x14, 0x4A, 0xC5, 0x27, 0x86, 0xDB, 0x3C, + 0x79, 0x3E, 0xF4, 0xAE, 0x8A, 0x83, 0x88, 0x47 + }, + { + 0x8A, 0x23, 0x97, 0xDF, 0x31, 0xE7, 0xF0, 0xCC, + 0x29, 0x0D, 0xA9, 0xA8, 0xBB, 0xE4, 0xF5, 0xF7, + 0xA3, 0xA1, 0x37, 0x50, 0x73, 0x0D, 0xB6, 0x2D, + 0xC2, 0x54, 0x0F, 0xDB, 0xD6, 0x18, 0x85, 0x89 + }, + { + 0xF1, 0x2D, 0x0B, 0x13, 0xC6, 0xAD, 0xFB, 0x3B, + 0xE5, 0x0A, 0x51, 0xEB, 0x6B, 0xAF, 0x65, 0xAB, + 0xFB, 0x17, 0x00, 0xBA, 0xA8, 0x7E, 0x52, 0x7D, + 0xBE, 0x3E, 0x67, 0x5A, 0x7A, 0x99, 0x46, 0x61 + }, + { + 0x10, 0x24, 0xC9, 0x40, 0xBE, 0x73, 0x41, 0x44, + 0x9B, 0x50, 0x10, 0x52, 0x2B, 0x50, 0x9F, 0x65, + 0xBB, 0xDC, 0x12, 0x87, 0xB4, 0x55, 0xC2, 0xBB, + 0x7F, 0x72, 0xB2, 0xC9, 0x2F, 0xD0, 0xD1, 0x89 + }, + { + 0x52, 0x60, 0x3B, 0x6C, 0xBF, 0xAD, 0x49, 0x66, + 0xCB, 0x04, 0x4C, 0xB2, 0x67, 0x56, 0x83, 0x85, + 0xCF, 0x35, 0xF2, 0x1E, 0x6C, 0x45, 0xCF, 0x30, + 0xAE, 0xD1, 0x98, 0x32, 0xCB, 0x51, 0xE9, 0xF5 + }, + { + 0xFF, 0xF2, 0x4D, 0x3C, 0xC7, 0x29, 0xD3, 0x95, + 0xDA, 0xF9, 0x78, 0xB0, 0x15, 0x73, 0x06, 0xCB, + 0x49, 0x57, 0x97, 0xE6, 0xC8, 0xDC, 0xA1, 0x73, + 0x1D, 0x2F, 0x6F, 0x81, 0xB8, 0x49, 0xBA, 0xAE + }, + { + 0x41, 0xEE, 0xE9, 0x0D, 0x47, 0xEC, 0x27, 0x72, + 0xCD, 0x35, 0x2D, 0xFD, 0x67, 0xE0, 0x60, 0x5F, + 0xBD, 0xFC, 0x5F, 0xD6, 0xD8, 0x26, 0x45, 0x1E, + 0x3D, 0x06, 0x4D, 0x38, 0x28, 0xBD, 0x3B, 0xAE + }, + { + 0x30, 0x0B, 0x6B, 0x36, 0xE5, 0x9F, 0x85, 0x1D, + 0xDD, 0xC2, 0x9B, 0xFA, 0x93, 0x08, 0x25, 0x20, + 0xCD, 0x77, 0xC5, 0x1E, 0x00, 0x7E, 0x00, 0xD2, + 0xD7, 0x8B, 0x26, 0xF4, 0xAF, 0x96, 0x15, 0x32 + }, + { + 0x9E, 0xF3, 0x03, 0x14, 0x83, 0x4E, 0x40, 0x1C, + 0x87, 0x1A, 0x20, 0x04, 0xE3, 0x8D, 0x5C, 0xE3, + 0x2E, 0xD2, 0x8E, 0x11, 0x37, 0xF1, 0x97, 0x0F, + 0x4F, 0x43, 0x78, 0xC7, 0x37, 0x06, 0x76, 0x3D + }, + { + 0x3F, 0xBD, 0xCD, 0xE7, 0xB6, 0x43, 0x04, 0x02, + 0x5E, 0xC0, 0x58, 0x26, 0x09, 0x03, 0x1E, 0xC2, + 0x66, 0xD5, 0x0F, 0x56, 0x83, 0x5A, 0xE0, 0xCB, + 0x72, 0xD8, 0xCD, 0xB4, 0xCF, 0xAF, 0x44, 0x19 + }, + { + 0xE9, 0x0E, 0xAD, 0x3B, 0x98, 0x2B, 0x43, 0x5B, + 0x66, 0x36, 0x6A, 0x49, 0x6C, 0x3F, 0x8A, 0xE6, + 0x5B, 0x17, 0x61, 0x37, 0x00, 0xF5, 0x47, 0x67, + 0x3F, 0x62, 0x15, 0x35, 0x41, 0x91, 0x28, 0x64 + }, + { + 0xAB, 0xE3, 0x54, 0x7B, 0x33, 0x6D, 0x6E, 0x24, + 0x0D, 0x7F, 0xE6, 0x82, 0xD7, 0x4B, 0x9C, 0xC7, + 0xE8, 0xD7, 0xF9, 0xB5, 0x66, 0x48, 0x58, 0xB9, + 0x4D, 0xF5, 0x9E, 0x9F, 0xC3, 0x30, 0xD9, 0xE5 + }, + { + 0xB2, 0x99, 0x64, 0x20, 0x95, 0xB8, 0x28, 0x6C, + 0x52, 0x1C, 0xDB, 0x21, 0xED, 0x0F, 0xE0, 0x57, + 0x27, 0x80, 0x21, 0xBB, 0x40, 0x38, 0xEB, 0x5A, + 0x3D, 0x79, 0x54, 0x2F, 0x5D, 0x75, 0x1F, 0x54 + }, + { + 0xE4, 0xD7, 0x58, 0x35, 0x9F, 0x08, 0x67, 0x93, + 0xA8, 0x37, 0x54, 0xAC, 0xA6, 0x96, 0x8C, 0x3E, + 0x9F, 0xD9, 0x4B, 0x40, 0x49, 0x7F, 0x2E, 0xC2, + 0x24, 0xA2, 0x91, 0x60, 0x63, 0xA2, 0x14, 0xA3 + }, + { + 0x59, 0xA3, 0x04, 0xFC, 0x03, 0xAB, 0x75, 0xD5, + 0x57, 0xDB, 0x04, 0xEB, 0xD0, 0x2D, 0xD4, 0xC6, + 0xB8, 0x10, 0xA1, 0x38, 0xBB, 0xFE, 0xEA, 0x5D, + 0xFC, 0xEE, 0xAA, 0x2B, 0x75, 0xB0, 0x64, 0x91 + }, + { + 0x39, 0x95, 0x10, 0x22, 0x15, 0xF5, 0xFE, 0x92, + 0x10, 0xEB, 0x30, 0xD9, 0x52, 0xD8, 0xC9, 0x19, + 0x58, 0x9E, 0x71, 0x45, 0xFC, 0xD4, 0x95, 0xEA, + 0x78, 0xD0, 0x2B, 0x9C, 0x14, 0x8F, 0xAF, 0x09 + }, + { + 0x47, 0x2E, 0xE7, 0x11, 0x56, 0x35, 0x06, 0xA5, + 0xF0, 0x08, 0x3F, 0xE8, 0x2B, 0x08, 0xB9, 0x92, + 0x3C, 0xF6, 0xC8, 0x40, 0x4D, 0x0C, 0xBA, 0xCB, + 0xF8, 0x48, 0x64, 0xF6, 0x48, 0x54, 0x2A, 0xC0 + }, + { + 0x68, 0xFD, 0xB8, 0x2A, 0xDA, 0xE7, 0x9B, 0xEF, + 0x59, 0x0A, 0xBA, 0x62, 0xD7, 0xAC, 0x55, 0x32, + 0x12, 0x06, 0x1C, 0x36, 0xE3, 0x6F, 0x12, 0xC0, + 0xEF, 0xA2, 0x9A, 0x17, 0x62, 0xDE, 0x3B, 0x6A + }, + { + 0x75, 0x85, 0xC0, 0x77, 0x33, 0x83, 0xF1, 0x74, + 0xFD, 0x66, 0x65, 0x49, 0xA8, 0x35, 0x2B, 0x30, + 0x5B, 0xF6, 0x85, 0x5B, 0xC9, 0x8B, 0xEA, 0x28, + 0xC3, 0x91, 0xB3, 0xC0, 0x34, 0xDA, 0x5A, 0x5A + }, + { + 0xAC, 0xC5, 0x75, 0xFE, 0x2C, 0xD7, 0xBA, 0x2A, + 0x31, 0xFC, 0x7D, 0x67, 0x0A, 0x92, 0x34, 0xAF, + 0x68, 0x50, 0x33, 0x86, 0xE9, 0x59, 0x07, 0x3D, + 0x16, 0xA8, 0x1B, 0x33, 0xB9, 0x22, 0xB5, 0x0E + }, + { + 0x9E, 0xC7, 0xD2, 0x99, 0x59, 0x43, 0xD3, 0x9D, + 0x6B, 0x97, 0x14, 0x93, 0xB8, 0x97, 0xA0, 0xEE, + 0x2D, 0x33, 0x92, 0xA7, 0x2D, 0xB8, 0x75, 0xC2, + 0x40, 0x5D, 0x35, 0x71, 0x78, 0xFB, 0x69, 0x11 + }, + { + 0x2D, 0x7E, 0xF1, 0x94, 0x01, 0x42, 0x5A, 0xBA, + 0x45, 0x0E, 0x82, 0xD3, 0x6D, 0x0F, 0xE7, 0xB2, + 0x08, 0x5E, 0xA0, 0xAF, 0x60, 0x45, 0xA5, 0x99, + 0x4C, 0xF4, 0x31, 0xEA, 0x59, 0x93, 0x9C, 0xC9 + }, + { + 0xF3, 0x2F, 0xD8, 0x55, 0xF0, 0x11, 0xC7, 0x18, + 0x02, 0x7F, 0x2E, 0xBE, 0x37, 0x7D, 0x69, 0x39, + 0xF1, 0x23, 0x70, 0xCA, 0xFF, 0x15, 0x1C, 0x1E, + 0x5A, 0xCE, 0x43, 0x8D, 0x70, 0x3C, 0x6D, 0x9F + }, + { + 0xB2, 0xBD, 0x83, 0xD2, 0x31, 0x0D, 0x3D, 0x7B, + 0x1D, 0x2D, 0x5A, 0xAF, 0x43, 0x59, 0xFA, 0xE2, + 0x86, 0x12, 0x96, 0x27, 0x19, 0xFD, 0xDE, 0x4D, + 0xDA, 0xF6, 0x9E, 0x78, 0x20, 0xF3, 0x3F, 0x61 + }, + { + 0x1A, 0x7A, 0x9D, 0x0F, 0x44, 0xDD, 0xFA, 0x7F, + 0xC2, 0xF4, 0x77, 0x0C, 0xAD, 0x74, 0x22, 0xFA, + 0x6C, 0x4E, 0x37, 0xE6, 0xCB, 0x03, 0x6D, 0x89, + 0x9E, 0x10, 0x27, 0x50, 0xE5, 0x94, 0xFF, 0xCD + }, + { + 0xDC, 0x69, 0xF6, 0x14, 0x1C, 0x8E, 0x10, 0x3F, + 0xF6, 0x1F, 0x62, 0x98, 0xA2, 0xC4, 0x4F, 0x52, + 0xD1, 0x47, 0x36, 0x6D, 0xDB, 0xD9, 0xC7, 0x9C, + 0xC3, 0x08, 0xFE, 0x84, 0x33, 0x6A, 0x95, 0x64 + }, + { + 0xE3, 0x4E, 0xD4, 0x17, 0xB0, 0x79, 0x1D, 0x9A, + 0x77, 0xEE, 0x1E, 0x50, 0xCC, 0x2C, 0x20, 0x7E, + 0x54, 0x0C, 0x77, 0x14, 0x04, 0x21, 0xC4, 0x6C, + 0xE0, 0x86, 0x28, 0x78, 0xAA, 0xEB, 0x27, 0x09 + }, + { + 0x21, 0x74, 0x42, 0x5C, 0x8C, 0xCA, 0xE3, 0x98, + 0xC4, 0xFF, 0x06, 0xF8, 0x48, 0x99, 0x1C, 0x5E, + 0x9B, 0xC0, 0xF3, 0x46, 0x11, 0x11, 0x70, 0x6F, + 0xB9, 0x5D, 0x0B, 0xE1, 0xC6, 0x8E, 0x47, 0x60 + }, + { + 0x18, 0x94, 0x58, 0x2A, 0x8A, 0x25, 0xFE, 0x8F, + 0x84, 0x7A, 0x4A, 0x03, 0x25, 0x74, 0xB7, 0x7B, + 0x8B, 0x36, 0xBF, 0x19, 0x99, 0x75, 0x26, 0xBB, + 0x4B, 0xC8, 0x5F, 0x38, 0x24, 0x53, 0x7F, 0xEB + }, + { + 0x17, 0xED, 0x18, 0x8A, 0xE3, 0xC9, 0x53, 0xD6, + 0x55, 0x44, 0x59, 0x83, 0xB8, 0x32, 0x5B, 0xAF, + 0xFF, 0x32, 0xE2, 0x22, 0xB2, 0xDF, 0xEB, 0x16, + 0xE8, 0x61, 0x7A, 0xBF, 0x86, 0xEE, 0x7C, 0xC5 + }, + { + 0xF1, 0x48, 0x9A, 0xD1, 0xC3, 0x54, 0xCD, 0xE9, + 0x78, 0x92, 0x37, 0xEA, 0x6D, 0xBF, 0x67, 0xFC, + 0x1E, 0x44, 0xD1, 0xAC, 0xC8, 0xDC, 0x66, 0xAD, + 0x83, 0x87, 0x27, 0xF4, 0x7D, 0x9A, 0x91, 0xFE + }, + { + 0x36, 0x7F, 0x22, 0x16, 0x5B, 0x8B, 0x66, 0xE9, + 0x7F, 0x66, 0x70, 0xF3, 0x4E, 0xBA, 0x27, 0x49, + 0xD2, 0x64, 0x3B, 0x21, 0xBE, 0xAD, 0xAD, 0xFE, + 0xFE, 0xA2, 0x57, 0x4B, 0x7C, 0x9B, 0x21, 0x96 + }, + { + 0x3D, 0x8D, 0xFE, 0xA1, 0x7E, 0xEA, 0x5D, 0x64, + 0x5A, 0xC1, 0xD4, 0x1A, 0x5B, 0x59, 0x22, 0x6C, + 0x48, 0x6C, 0x36, 0xBD, 0x77, 0xED, 0x44, 0xBB, + 0x34, 0x91, 0x70, 0xD0, 0x80, 0xE3, 0x0E, 0x68 + }, + { + 0x41, 0x15, 0xF8, 0x9E, 0x0B, 0x3B, 0x5C, 0x8F, + 0x61, 0x22, 0xC0, 0x25, 0x00, 0x17, 0x1D, 0xCF, + 0xFB, 0xCE, 0xA4, 0x66, 0x2A, 0x8C, 0x5F, 0x8C, + 0x1C, 0x01, 0xA9, 0xCA, 0x7B, 0x10, 0x27, 0xBB + }, + { + 0xED, 0x6E, 0x91, 0x0B, 0x96, 0x02, 0x55, 0xD7, + 0xD7, 0x92, 0xEB, 0xE6, 0x7F, 0x26, 0x0A, 0x14, + 0x3C, 0xFA, 0xC1, 0x05, 0x1D, 0xFC, 0x05, 0x90, + 0x25, 0xEE, 0x0C, 0x1B, 0xFC, 0xBC, 0x56, 0x81 + }, + { + 0x55, 0x8F, 0xA8, 0xAF, 0xA1, 0x2B, 0xBE, 0xE5, + 0x4A, 0xF7, 0x8F, 0x6B, 0x74, 0x45, 0xF9, 0x96, + 0x65, 0xD4, 0xE3, 0x56, 0xBC, 0x07, 0xD3, 0xEF, + 0xFD, 0x8F, 0xD6, 0x5A, 0xB9, 0xC7, 0x47, 0x16 + }, + { + 0x5B, 0x60, 0x12, 0x76, 0x20, 0x53, 0xB8, 0x73, + 0x4A, 0xF0, 0xE5, 0x55, 0xE6, 0xA2, 0xBB, 0x4F, + 0xD4, 0x84, 0x0A, 0xF3, 0xB0, 0x4F, 0xCF, 0x63, + 0x50, 0xA2, 0xB8, 0xA5, 0x1B, 0x67, 0x96, 0xAD + }, + { + 0xAB, 0x7A, 0xCC, 0xA5, 0xD7, 0x77, 0x10, 0xBA, + 0xD3, 0x7B, 0xA0, 0xFF, 0x4C, 0xEA, 0xE2, 0x7E, + 0x84, 0x71, 0x79, 0xF7, 0xFD, 0x7A, 0xEC, 0x88, + 0x69, 0xC6, 0x49, 0xB3, 0x3F, 0x8D, 0x25, 0x77 + }, + { + 0xFF, 0x77, 0x30, 0xB4, 0x74, 0xEC, 0x21, 0x45, + 0xA9, 0x2D, 0xD1, 0xCF, 0xFE, 0x45, 0xC3, 0x42, + 0xC6, 0xFD, 0x6B, 0xAC, 0x58, 0x0F, 0xF9, 0x5A, + 0x75, 0xED, 0xA3, 0xBF, 0x90, 0xEB, 0x4F, 0x01 + }, + { + 0xD1, 0x0F, 0x06, 0x1D, 0x5B, 0x9C, 0xB4, 0x4E, + 0xE0, 0x78, 0xA9, 0x6B, 0x33, 0x18, 0x57, 0x9E, + 0x5E, 0xF5, 0x0A, 0xEF, 0x3E, 0xD9, 0x6E, 0x4F, + 0x62, 0x14, 0x9B, 0x2E, 0x9F, 0x7C, 0x66, 0x0C + }, + { + 0x67, 0xD2, 0x2B, 0x8E, 0xDF, 0x20, 0x01, 0xD8, + 0x64, 0x22, 0x13, 0x6A, 0xC6, 0x51, 0x6C, 0xF3, + 0x9F, 0x7F, 0xC6, 0xA7, 0x02, 0x98, 0x92, 0xFD, + 0x75, 0xC9, 0x87, 0x90, 0x96, 0x4A, 0x72, 0x0B + }, + { + 0x7A, 0x5E, 0xC5, 0xBA, 0x76, 0x25, 0x9B, 0x07, + 0xB4, 0xDA, 0x03, 0xF3, 0x81, 0xFE, 0x7B, 0xEA, + 0x48, 0x65, 0xC8, 0x6C, 0x42, 0x4A, 0xBA, 0xA0, + 0xDD, 0x1E, 0xCF, 0x74, 0xF8, 0x7D, 0x2A, 0xC0 + }, + { + 0xE0, 0xFF, 0x60, 0xD6, 0x90, 0x29, 0xE6, 0xBD, + 0x1C, 0x15, 0x95, 0x3E, 0x91, 0x50, 0x9C, 0x0C, + 0x59, 0xED, 0x5D, 0xA5, 0x00, 0x01, 0x99, 0xF2, + 0x16, 0xD2, 0x9F, 0x96, 0x07, 0x9C, 0x2F, 0xEF + }, + { + 0xFC, 0x13, 0xEA, 0xD8, 0x41, 0x01, 0x8F, 0x59, + 0x90, 0x3B, 0x40, 0xF2, 0x02, 0x0C, 0x66, 0x38, + 0xA6, 0x6A, 0x54, 0xC3, 0xA3, 0x38, 0x41, 0x4D, + 0x97, 0xA5, 0xC3, 0x94, 0xF3, 0x26, 0x6F, 0x33 + }, + { + 0x0C, 0x2F, 0x62, 0xB8, 0x98, 0xFB, 0x2F, 0x63, + 0x61, 0x7E, 0x78, 0x73, 0x45, 0x26, 0x3C, 0xB9, + 0xCF, 0x60, 0x65, 0x4B, 0x55, 0x3B, 0x20, 0x3E, + 0xE4, 0x9D, 0xCB, 0xB8, 0xF2, 0xA6, 0xAF, 0xAC + }, + { + 0xD7, 0xD6, 0xCB, 0x55, 0x2A, 0xEB, 0x36, 0xEB, + 0x96, 0xB1, 0xD5, 0xE0, 0x52, 0xF8, 0xD9, 0x21, + 0xC3, 0x24, 0x5A, 0x97, 0x0D, 0x0B, 0xC8, 0x41, + 0x0C, 0xD6, 0x5E, 0xA1, 0x04, 0xC8, 0xE7, 0x79 + }, + { + 0xB7, 0x14, 0x1F, 0x30, 0x5E, 0xFD, 0xFE, 0xE5, + 0x56, 0xBD, 0x13, 0xE0, 0x40, 0x0D, 0x1E, 0x8C, + 0xFD, 0x65, 0x48, 0xBF, 0x81, 0xEE, 0x5D, 0x15, + 0x32, 0x7E, 0x49, 0x95, 0xCA, 0x8A, 0xD6, 0xFD + }, + { + 0xB6, 0xB6, 0x38, 0xD2, 0x2B, 0x7A, 0x12, 0x82, + 0x53, 0x74, 0xF7, 0x03, 0x48, 0xD7, 0x44, 0x8D, + 0x4E, 0x7D, 0x90, 0x8C, 0xF6, 0xE7, 0xBB, 0xEF, + 0x8C, 0x93, 0xEF, 0x67, 0x9B, 0x2A, 0x54, 0x78 + }, + { + 0x0D, 0xF4, 0x58, 0x56, 0x41, 0xFA, 0x09, 0xF6, + 0xCB, 0xA4, 0xCC, 0x16, 0x5A, 0x10, 0xAD, 0xDE, + 0x34, 0xF8, 0x0D, 0x42, 0x5A, 0x70, 0xDB, 0x67, + 0xE2, 0xFD, 0x23, 0x7B, 0x62, 0x7F, 0x43, 0x8A + }, + { + 0x10, 0x6B, 0x2B, 0x35, 0x4D, 0x95, 0xAC, 0xEC, + 0xD0, 0xD9, 0x58, 0x8F, 0xBC, 0x23, 0x1F, 0x8B, + 0xEA, 0x2E, 0x94, 0xEA, 0x66, 0x2D, 0xDD, 0x3F, + 0x13, 0x9E, 0x1B, 0x67, 0x87, 0x46, 0x1E, 0xED + }, + { + 0xAE, 0x5C, 0x69, 0xEE, 0xFE, 0x90, 0x89, 0xB2, + 0x9C, 0x6C, 0x1A, 0x23, 0x70, 0xD2, 0x05, 0x52, + 0xBA, 0x40, 0xC3, 0xD5, 0xE3, 0x71, 0x3C, 0x12, + 0xDE, 0xFC, 0xAE, 0x99, 0x7F, 0x43, 0x3E, 0xCD + }, + { + 0x1A, 0xAE, 0xF5, 0x5D, 0x4F, 0xA8, 0x92, 0xB6, + 0x35, 0xFB, 0x2A, 0x7A, 0x25, 0xF9, 0xA8, 0xE0, + 0x3B, 0x9F, 0xFB, 0x08, 0x2A, 0xE9, 0xC0, 0x7C, + 0x20, 0x42, 0xA0, 0x49, 0xC6, 0x51, 0x5E, 0x45 + }, + { + 0x29, 0x7D, 0xAA, 0xC4, 0xD5, 0x4D, 0xC4, 0x1C, + 0x83, 0xE3, 0x23, 0x94, 0x59, 0x9F, 0x17, 0x1C, + 0xDA, 0xA9, 0xDD, 0xB7, 0x17, 0x26, 0xDA, 0x4E, + 0xCE, 0x3C, 0xCF, 0x95, 0xC1, 0x1F, 0x56, 0xDF + }, + { + 0x2C, 0x45, 0xAC, 0xF4, 0x91, 0xEC, 0x2F, 0x4B, + 0x7E, 0x30, 0x9E, 0x7E, 0xDD, 0x81, 0x5B, 0xE5, + 0xA5, 0x4C, 0x44, 0x58, 0xD1, 0xA5, 0x7C, 0x4F, + 0x9B, 0x76, 0x3B, 0x0C, 0x67, 0x18, 0xD4, 0x3E + }, + { + 0x2F, 0x92, 0xF9, 0x01, 0x70, 0xD3, 0xAE, 0x95, + 0xAB, 0xFA, 0xC3, 0xA6, 0x98, 0x9A, 0x2A, 0x60, + 0xCB, 0x28, 0xB8, 0x58, 0x78, 0x2B, 0xE7, 0xEA, + 0x17, 0x9B, 0x48, 0xA7, 0x27, 0x6D, 0xD8, 0x60 + }, + { + 0xB4, 0x01, 0xE8, 0x4B, 0x15, 0xAC, 0xC4, 0x70, + 0x93, 0x6D, 0x6E, 0x37, 0xF7, 0x88, 0x83, 0x33, + 0x09, 0x27, 0x31, 0x13, 0x3B, 0x25, 0x1B, 0xEA, + 0x22, 0x16, 0x58, 0xCA, 0x19, 0xA7, 0x56, 0x69 + }, + { + 0xF8, 0xB3, 0x40, 0xD2, 0xB9, 0xB3, 0x3D, 0x43, + 0xA0, 0xA6, 0x6F, 0x34, 0x97, 0x82, 0x0A, 0xFA, + 0xAE, 0xE4, 0x34, 0xC4, 0xE3, 0xC0, 0xC1, 0x7E, + 0x89, 0x8B, 0x83, 0x01, 0xC5, 0x7A, 0x26, 0xBD + }, + { + 0x56, 0x6D, 0xA2, 0x83, 0x99, 0x03, 0x89, 0x13, + 0x8A, 0xA6, 0xF2, 0xAA, 0xA3, 0xB9, 0xE4, 0x0C, + 0xBF, 0x90, 0x84, 0x0E, 0xC7, 0x62, 0xBD, 0x96, + 0xB7, 0xE3, 0x3A, 0x31, 0x13, 0xB1, 0x01, 0x08 + }, + { + 0x34, 0x06, 0x72, 0xB7, 0x04, 0x67, 0x60, 0x42, + 0xC9, 0xBF, 0x3F, 0x33, 0x7B, 0xA7, 0x9F, 0x11, + 0x33, 0x6A, 0xEB, 0xB5, 0xEC, 0x5D, 0x31, 0xDF, + 0x54, 0xEB, 0x6A, 0xD3, 0xB0, 0x43, 0x04, 0x42 + }, + { + 0x50, 0x50, 0xB7, 0x3B, 0x93, 0x16, 0xEE, 0xA2, + 0xF1, 0x49, 0xBF, 0xFD, 0x22, 0xAE, 0xE3, 0x84, + 0xDC, 0x54, 0x03, 0xB1, 0x8E, 0x16, 0xFA, 0x88, + 0x82, 0x5E, 0x18, 0x16, 0x09, 0x49, 0x6F, 0xD2 + }, + { + 0x13, 0x65, 0xCC, 0x6F, 0xB9, 0x26, 0x0E, 0x86, + 0x88, 0x9B, 0x3A, 0xFB, 0xD1, 0xC8, 0xBC, 0x12, + 0x92, 0x31, 0x97, 0x71, 0x5D, 0xB2, 0x66, 0xCC, + 0x7A, 0x01, 0xCA, 0x57, 0x15, 0x9F, 0x75, 0x96 + }, + { + 0x29, 0x46, 0x6F, 0x51, 0xC0, 0x11, 0xFD, 0x10, + 0x18, 0x14, 0x94, 0xA9, 0x37, 0x9B, 0x61, 0x59, + 0xB8, 0x08, 0xAE, 0x0F, 0xCB, 0x01, 0x61, 0xF8, + 0xF0, 0x79, 0x09, 0xFF, 0x04, 0x1B, 0x19, 0x65 + }, + { + 0x65, 0x91, 0xA3, 0xC3, 0xC7, 0x67, 0xB3, 0x8D, + 0x80, 0x5E, 0xD3, 0xF7, 0xEB, 0x67, 0x63, 0xE8, + 0xB3, 0xD2, 0xD6, 0x42, 0xE7, 0x30, 0x77, 0x45, + 0xCD, 0x34, 0x18, 0xEF, 0xF6, 0x9A, 0x19, 0xED + }, + { + 0x1D, 0x84, 0xB0, 0x4B, 0x13, 0x38, 0xB0, 0xD2, + 0xE3, 0xC9, 0x8F, 0x7A, 0xEA, 0x3E, 0x98, 0xEF, + 0xFC, 0x53, 0x0A, 0x50, 0x44, 0xB9, 0x3B, 0x96, + 0xC6, 0x7E, 0xE3, 0x79, 0xD6, 0x2E, 0x81, 0x5F + }, + { + 0x6F, 0xA2, 0x95, 0x27, 0x25, 0x32, 0xE9, 0x83, + 0xE1, 0x66, 0xB1, 0x2E, 0x49, 0x99, 0xC0, 0x52, + 0xF8, 0x9D, 0x9F, 0x30, 0xAE, 0x14, 0x81, 0xF3, + 0xD6, 0x0E, 0xAE, 0x85, 0xF8, 0xEE, 0x17, 0x8A + }, + { + 0x4E, 0xD8, 0xCA, 0xA9, 0x8E, 0xC3, 0x9F, 0x6A, + 0x62, 0x9F, 0x9A, 0x65, 0x4A, 0x44, 0x7E, 0x7E, + 0x3E, 0x4F, 0xAE, 0xEC, 0xF3, 0x4D, 0xCF, 0x65, + 0x8D, 0x2D, 0x4B, 0x98, 0xB7, 0xA2, 0xEC, 0x1A + }, + { + 0xCF, 0xAB, 0x82, 0x99, 0xA0, 0xDA, 0x0C, 0x2A, + 0x7E, 0x8F, 0xF5, 0x4D, 0x0A, 0x67, 0x6D, 0x14, + 0x1A, 0xB2, 0x6B, 0xC0, 0x01, 0x2E, 0x5F, 0x66, + 0x8E, 0x85, 0xD8, 0x14, 0xBC, 0x98, 0x88, 0xB0 + }, + { + 0xA6, 0x26, 0x54, 0x3C, 0x27, 0x1F, 0xCC, 0xC3, + 0xE4, 0x45, 0x0B, 0x48, 0xD6, 0x6B, 0xC9, 0xCB, + 0xDE, 0xB2, 0x5E, 0x5D, 0x07, 0x7A, 0x62, 0x13, + 0xCD, 0x90, 0xCB, 0xBD, 0x0F, 0xD2, 0x20, 0x76 + }, + { + 0x05, 0xCF, 0x3A, 0x90, 0x04, 0x91, 0x16, 0xDC, + 0x60, 0xEF, 0xC3, 0x15, 0x36, 0xAA, 0xA3, 0xD1, + 0x67, 0x76, 0x29, 0x94, 0x89, 0x28, 0x76, 0xDC, + 0xB7, 0xEF, 0x3F, 0xBE, 0xCD, 0x74, 0x49, 0xC0 + }, + { + 0xCC, 0xD6, 0x1C, 0x92, 0x6C, 0xC1, 0xE5, 0xE9, + 0x12, 0x8C, 0x02, 0x1C, 0x0C, 0x6E, 0x92, 0xAE, + 0xFC, 0x4F, 0xFB, 0xDE, 0x39, 0x4D, 0xD6, 0xF3, + 0xB7, 0xD8, 0x7A, 0x8C, 0xED, 0x89, 0x60, 0x14 + }, + { + 0x3F, 0xFA, 0x4F, 0x6D, 0xAF, 0xA5, 0x7F, 0x1C, + 0x50, 0xF1, 0xAF, 0xA4, 0xF8, 0x12, 0x92, 0xAE, + 0x71, 0xA0, 0x6F, 0xE4, 0xF8, 0xFF, 0x46, 0xC5, + 0x1D, 0x32, 0xFF, 0x26, 0x13, 0x48, 0x9F, 0x2B + }, + { + 0x19, 0xD3, 0x92, 0x1C, 0xFC, 0x0F, 0x1A, 0x2B, + 0xB8, 0x13, 0xB3, 0xDF, 0xA9, 0x6D, 0xF9, 0x0E, + 0x2C, 0x6B, 0x87, 0xD7, 0x8E, 0x92, 0x38, 0xF8, + 0x5B, 0xBC, 0x77, 0xAE, 0x9A, 0x73, 0xF9, 0x8F + }, + { + 0xF5, 0xC9, 0x16, 0xFF, 0x2B, 0xAD, 0xDE, 0x3E, + 0x29, 0xA5, 0xF9, 0x40, 0x23, 0x3E, 0xA3, 0x40, + 0x07, 0xD8, 0xF1, 0x82, 0xA4, 0x8A, 0x80, 0x8B, + 0x46, 0xBB, 0x80, 0x58, 0x00, 0x3F, 0x19, 0x03 + }, + { + 0x6B, 0xA0, 0x7A, 0x1A, 0xF7, 0x58, 0xE6, 0x82, + 0xD3, 0xE0, 0x9A, 0xDD, 0x2D, 0x3D, 0xCD, 0xF3, + 0x5D, 0x95, 0x53, 0xF6, 0x79, 0x98, 0x54, 0xA2, + 0x7E, 0x53, 0x60, 0x63, 0xC5, 0x7F, 0x81, 0xA5 + }, + { + 0xB7, 0x83, 0x78, 0xFB, 0x44, 0x6C, 0x54, 0x4B, + 0x04, 0xD4, 0xA1, 0x52, 0xAC, 0x49, 0x57, 0x31, + 0x61, 0xB3, 0xDD, 0xEB, 0xF6, 0x93, 0x86, 0x77, + 0x0A, 0x55, 0xA7, 0xD4, 0x7B, 0x88, 0x0E, 0x5D + }, + { + 0xB5, 0x19, 0x53, 0x8F, 0xE1, 0x62, 0x6F, 0x0C, + 0x59, 0x59, 0x45, 0xAD, 0xA5, 0x8A, 0x34, 0x4F, + 0xAA, 0xC0, 0x06, 0x17, 0x61, 0xCC, 0x9D, 0x4A, + 0x84, 0x14, 0x19, 0xBD, 0x32, 0xEE, 0xC0, 0xD9 + }, + { + 0x96, 0xE4, 0x88, 0xB0, 0x27, 0x89, 0x64, 0x13, + 0xF4, 0x03, 0x4B, 0x03, 0x54, 0xF4, 0x84, 0x84, + 0xF6, 0xCF, 0xC1, 0x0F, 0x8E, 0xC5, 0x7B, 0x02, + 0x6F, 0xD2, 0x1A, 0x3B, 0x88, 0x36, 0x1A, 0x74 + }, + { + 0x77, 0x0C, 0x8A, 0x5F, 0x47, 0xBF, 0xD7, 0x69, + 0xCE, 0xD3, 0x5A, 0x71, 0xAF, 0xC3, 0xCA, 0x1F, + 0xF4, 0xC1, 0xF1, 0xE7, 0xCC, 0x3D, 0x23, 0x56, + 0xDE, 0x94, 0x50, 0x04, 0x36, 0x8D, 0x81, 0x45 + }, + { + 0x6D, 0xF9, 0xD8, 0xD0, 0xD3, 0xA8, 0xD9, 0x8C, + 0x83, 0x50, 0xD7, 0x16, 0x2B, 0xD1, 0x55, 0x79, + 0xD5, 0x70, 0x7A, 0xDD, 0x76, 0x11, 0xA0, 0x0E, + 0xEB, 0x6C, 0xA5, 0x74, 0x3E, 0xD7, 0x8C, 0xB7 + }, + { + 0x4F, 0x0F, 0xE8, 0xFC, 0x17, 0x90, 0x15, 0x91, + 0xCF, 0x34, 0x87, 0x30, 0xE1, 0x87, 0xDE, 0x52, + 0x3D, 0x6D, 0x75, 0x68, 0xC1, 0xFB, 0xD8, 0x24, + 0x85, 0x91, 0x39, 0x85, 0xEB, 0x67, 0x97, 0x1C + }, + { + 0x0E, 0xF3, 0xBB, 0x35, 0xCF, 0x37, 0x2B, 0xD9, + 0x4E, 0x3F, 0x80, 0xEE, 0xCE, 0xBD, 0x50, 0xEF, + 0x0D, 0x03, 0x08, 0xE0, 0x1E, 0x0E, 0xD6, 0xDE, + 0x0F, 0x5A, 0x8A, 0x8C, 0x81, 0x8A, 0x00, 0x74 + }, + { + 0xC0, 0x38, 0xD3, 0xE8, 0x09, 0xA5, 0xE3, 0xA5, + 0x8D, 0xB2, 0xF9, 0x1C, 0x15, 0xAE, 0x12, 0x43, + 0x95, 0x78, 0xF7, 0x54, 0x85, 0xCD, 0x84, 0xF5, + 0x56, 0xC6, 0x97, 0x1E, 0x8E, 0x25, 0x06, 0x20 + }, + { + 0xCE, 0x39, 0x9A, 0x0F, 0x08, 0x27, 0x7D, 0x8D, + 0x48, 0x16, 0x09, 0x50, 0x60, 0xEB, 0xBF, 0x33, + 0xDA, 0x01, 0x6F, 0xB4, 0x3A, 0x6C, 0x35, 0x6D, + 0x5A, 0x3F, 0xE4, 0xBB, 0x57, 0x4C, 0x5E, 0x7B + }, + { + 0x86, 0x9F, 0x7E, 0x31, 0x6B, 0x19, 0x4F, 0x95, + 0x31, 0xBC, 0xAF, 0x33, 0xF7, 0x91, 0x3F, 0x1B, + 0x9C, 0xFC, 0x6B, 0xB5, 0xDC, 0xF8, 0x6B, 0x69, + 0x2B, 0xF8, 0xCA, 0xB2, 0x9B, 0x8A, 0xA9, 0x6F + }, + { + 0x32, 0x7D, 0xFA, 0x46, 0x44, 0x59, 0xD9, 0xE4, + 0x8F, 0x5E, 0x55, 0xC7, 0xF5, 0xBA, 0xA6, 0x8F, + 0xC4, 0xA2, 0x5A, 0xD6, 0x22, 0xBC, 0x7B, 0xF0, + 0x1A, 0xCA, 0x82, 0xFD, 0x5E, 0x72, 0x31, 0x4C + }, + { + 0xE0, 0x0D, 0xAD, 0x31, 0x51, 0xB9, 0x08, 0x5E, + 0xAE, 0x78, 0x69, 0x84, 0xFE, 0x20, 0x73, 0x52, + 0x32, 0xB7, 0xFF, 0x7F, 0x1B, 0x1D, 0xB7, 0x96, + 0x1F, 0xD0, 0xD0, 0xE0, 0xF6, 0x05, 0xDB, 0x9A + }, + { + 0x07, 0x6F, 0x64, 0x45, 0x20, 0xD0, 0xB4, 0x73, + 0x2D, 0x6C, 0x53, 0x1C, 0x93, 0x49, 0x08, 0x90, + 0x26, 0x93, 0x6D, 0x99, 0x82, 0x04, 0x61, 0xDA, + 0x87, 0x74, 0x9A, 0x52, 0x0F, 0xBE, 0x90, 0xCE + }, + { + 0xB4, 0x41, 0x4C, 0xA1, 0x37, 0x3B, 0xE4, 0x6F, + 0x15, 0xCE, 0xA6, 0xB1, 0x25, 0x5A, 0x7D, 0x18, + 0x86, 0xC6, 0xFD, 0xB0, 0x8E, 0xD5, 0xAF, 0x96, + 0x57, 0xD5, 0xAA, 0xC3, 0x17, 0xDE, 0x3A, 0x29 + }, + { + 0x8D, 0x1A, 0xB0, 0x26, 0x3D, 0xAB, 0x7B, 0x86, + 0xEC, 0xEE, 0x21, 0x91, 0x62, 0xD9, 0x99, 0xA0, + 0x12, 0x45, 0x57, 0x22, 0x69, 0xDE, 0x31, 0x10, + 0x0E, 0x5D, 0x88, 0xFC, 0x1B, 0x1E, 0xAA, 0x69 + }, + { + 0xB4, 0x8D, 0x1C, 0x1F, 0x83, 0x92, 0x4A, 0x02, + 0xA2, 0x3E, 0x5E, 0x0F, 0x97, 0x1E, 0x16, 0xE8, + 0x7F, 0xC4, 0x88, 0x48, 0x53, 0x83, 0x34, 0x85, + 0x19, 0x1A, 0x2B, 0x60, 0x72, 0x2F, 0xE2, 0x69 + }, + { + 0xF2, 0xED, 0xD5, 0xF7, 0x50, 0xA2, 0x0A, 0x54, + 0x1D, 0x3F, 0x6B, 0xD5, 0xDF, 0x80, 0x83, 0x8F, + 0x11, 0x82, 0x5B, 0x25, 0xA9, 0x8F, 0x3D, 0xA5, + 0xE1, 0x52, 0x3B, 0xFF, 0x81, 0x3B, 0xB5, 0x60 + }, + { + 0x07, 0x16, 0x60, 0x04, 0xEF, 0x88, 0xE1, 0x61, + 0x4E, 0xBD, 0xC8, 0x87, 0xDF, 0xC7, 0xDA, 0x42, + 0xEB, 0xCD, 0xA0, 0x2D, 0x92, 0xC1, 0x2F, 0x18, + 0xD1, 0x18, 0x6C, 0xE3, 0xC9, 0x87, 0x10, 0xE4 + }, + { + 0x69, 0xF8, 0x3A, 0xA1, 0x01, 0xD6, 0x9B, 0x8F, + 0x12, 0x20, 0xDC, 0x1C, 0x53, 0x8D, 0x89, 0x34, + 0x45, 0x84, 0x20, 0xBE, 0x33, 0x5F, 0xEB, 0x46, + 0xFF, 0xC4, 0x7A, 0x2C, 0x8E, 0x2E, 0x6A, 0x8A + }, + { + 0xE1, 0x46, 0x9F, 0x16, 0xC6, 0xFC, 0xA1, 0x51, + 0x19, 0xA2, 0x72, 0xE5, 0x85, 0xC7, 0xF5, 0x04, + 0x21, 0xBC, 0x8A, 0x41, 0x4C, 0x86, 0x4F, 0xC7, + 0x6B, 0x01, 0x04, 0x8D, 0x4C, 0x6F, 0xC5, 0xD2 + }, + { + 0x67, 0x63, 0x34, 0x3A, 0x1C, 0x80, 0xF1, 0x92, + 0x83, 0xA8, 0x0A, 0xF8, 0x54, 0xE7, 0xE9, 0x06, + 0x5C, 0x2A, 0x83, 0x49, 0xEF, 0x11, 0xF1, 0x1B, + 0xFB, 0x76, 0xBA, 0x9F, 0x97, 0x04, 0x85, 0x39 + }, + { + 0x1A, 0xE3, 0xA0, 0xB8, 0xB2, 0xC7, 0x88, 0x5B, + 0xA3, 0x18, 0xAD, 0x6F, 0xD4, 0x49, 0xFC, 0x4D, + 0x7F, 0x84, 0x04, 0xB5, 0x9C, 0xF3, 0x27, 0x5F, + 0xCD, 0xEA, 0x13, 0x56, 0x34, 0x25, 0x77, 0x2D + }, + { + 0x3A, 0x71, 0x18, 0x4C, 0xBE, 0x8E, 0xB5, 0x8E, + 0x68, 0x12, 0xBA, 0x7A, 0x7A, 0x1D, 0xCA, 0x0C, + 0xA2, 0x8E, 0xEC, 0x63, 0x78, 0x2F, 0x2E, 0x6E, + 0x3C, 0x0B, 0x87, 0x07, 0x3F, 0x53, 0x3F, 0xFD + }, + { + 0x18, 0x4C, 0xCF, 0x2A, 0x52, 0xF3, 0x88, 0xC9, + 0xF8, 0x97, 0xA8, 0x57, 0xFE, 0x7C, 0xCE, 0xC2, + 0x95, 0x99, 0x11, 0xA8, 0xD1, 0xE0, 0x9E, 0xE8, + 0x80, 0x4D, 0x8D, 0x5D, 0x50, 0x8D, 0xD9, 0x18 + }, + { + 0xA6, 0x6D, 0x40, 0x9A, 0xF7, 0xAF, 0xD7, 0x5B, + 0xE8, 0x31, 0xDD, 0x49, 0x8C, 0x19, 0x6E, 0xF1, + 0x2C, 0x73, 0xC3, 0x11, 0x29, 0xEC, 0x02, 0xD5, + 0xF1, 0x2A, 0xB0, 0x2A, 0x2C, 0x63, 0xA2, 0x5E + }, + { + 0x58, 0xB3, 0x74, 0x97, 0xFC, 0xF0, 0xBE, 0x0E, + 0x0C, 0xF1, 0x73, 0x40, 0x45, 0xC2, 0x95, 0xB2, + 0x86, 0xC7, 0x6A, 0x7C, 0x04, 0x8E, 0x87, 0xC5, + 0x40, 0x28, 0xED, 0x36, 0x91, 0x5B, 0x5D, 0xF3 + }, + { + 0x2C, 0x73, 0x33, 0x54, 0x0A, 0x83, 0x2D, 0x64, + 0x45, 0x6E, 0x43, 0x05, 0x8C, 0x50, 0xD9, 0x3C, + 0x93, 0x2A, 0xD9, 0xB1, 0x8B, 0x3F, 0xC3, 0xA0, + 0x59, 0x92, 0x07, 0xCD, 0xA3, 0xB3, 0xC7, 0xA6 + }, + { + 0x3D, 0xC0, 0x62, 0xFF, 0xB5, 0x7D, 0x83, 0x5F, + 0xE3, 0xAA, 0x40, 0x94, 0x66, 0x82, 0x2F, 0x91, + 0x86, 0x91, 0x84, 0x23, 0x94, 0x75, 0x05, 0x16, + 0x5F, 0xDC, 0xDF, 0xB7, 0x30, 0x6F, 0x72, 0x59 + }, + { + 0x89, 0x20, 0x48, 0x44, 0xAC, 0xB9, 0x2F, 0x35, + 0x3B, 0xFC, 0x89, 0xA3, 0xCE, 0x8A, 0x98, 0x17, + 0x21, 0x9C, 0x10, 0x13, 0x85, 0xC5, 0x93, 0xCF, + 0x60, 0xE0, 0xBE, 0xFA, 0x96, 0x38, 0xE1, 0x4E + }, + { + 0x78, 0x2B, 0xA9, 0x02, 0xE9, 0x12, 0x32, 0x94, + 0x1C, 0x78, 0xC4, 0x9C, 0xD9, 0x77, 0x1A, 0x5D, + 0x99, 0x92, 0xF9, 0xB0, 0x7D, 0x9C, 0x0A, 0x2D, + 0xF8, 0x2D, 0x38, 0x5D, 0x15, 0xC4, 0x2B, 0xB3 + }, + { + 0x0D, 0xC3, 0xFF, 0x7D, 0xF0, 0xDF, 0xC0, 0x23, + 0x76, 0x3D, 0x76, 0x34, 0xE1, 0x8D, 0xA2, 0x73, + 0x93, 0xFC, 0x9F, 0xDB, 0x1C, 0x15, 0x46, 0x46, + 0x86, 0x10, 0x75, 0xF0, 0xA8, 0x7D, 0x0E, 0x90 + }, + { + 0xB9, 0x5C, 0x65, 0xFB, 0x6F, 0x25, 0x4E, 0xDB, + 0xDE, 0x8C, 0x03, 0x7D, 0x5C, 0x8B, 0x20, 0x39, + 0x34, 0x0F, 0x4A, 0xC2, 0xB0, 0x23, 0xA6, 0xAA, + 0x28, 0xA8, 0xFC, 0xD2, 0xD2, 0x68, 0x9C, 0xF4 + }, + { + 0x87, 0xE8, 0xF5, 0x15, 0x72, 0xA5, 0xD6, 0xA2, + 0x39, 0xF8, 0x5B, 0xC5, 0x3E, 0x11, 0x74, 0xE1, + 0x5B, 0xE1, 0x2F, 0xCD, 0xF1, 0x51, 0xA0, 0xB9, + 0xA2, 0xB4, 0x36, 0x40, 0xCA, 0xF7, 0x4C, 0x1D + }, + { + 0x2A, 0x6F, 0x3E, 0x46, 0x2C, 0x40, 0x5C, 0x35, + 0x4F, 0xE8, 0x0F, 0xCC, 0xCE, 0xD1, 0xC9, 0xBE, + 0x44, 0x32, 0x5D, 0x29, 0xE0, 0x7D, 0xA3, 0x09, + 0x60, 0xB6, 0x25, 0xA7, 0x6E, 0xA4, 0x2F, 0x83 + }, + { + 0x20, 0xB4, 0x6C, 0x8F, 0xBF, 0xCA, 0x97, 0x45, + 0x32, 0x62, 0x46, 0x0F, 0x84, 0x98, 0xA7, 0xE2, + 0xAF, 0x15, 0xAC, 0x79, 0xB5, 0x9D, 0xDF, 0xB0, + 0x27, 0xBB, 0x52, 0xF2, 0xD6, 0x8E, 0x8F, 0x51 + }, + { + 0x31, 0xB0, 0x76, 0x3C, 0xB9, 0xBA, 0x92, 0x40, + 0x3D, 0xCA, 0x1A, 0xBD, 0xD7, 0x34, 0x2D, 0x7D, + 0xE9, 0x4C, 0x58, 0x1E, 0x76, 0xF7, 0xC9, 0xA6, + 0x1E, 0x51, 0x59, 0x28, 0xE1, 0x0B, 0x4E, 0x77 + }, + { + 0xE1, 0x91, 0xE1, 0x17, 0x06, 0x3C, 0xFA, 0xC9, + 0x64, 0x2C, 0xD9, 0x3C, 0xB4, 0x2B, 0x39, 0xED, + 0xDD, 0x9E, 0x4A, 0xB6, 0x5F, 0x1D, 0x03, 0x97, + 0xE3, 0xE1, 0x7D, 0xD0, 0x4C, 0xAB, 0x11, 0x80 + }, + { + 0x22, 0x5A, 0x20, 0x21, 0x07, 0xA7, 0x47, 0x03, + 0xE0, 0x41, 0xC6, 0xCC, 0xA4, 0xEA, 0xCF, 0x4F, + 0x21, 0xEE, 0xA6, 0xF2, 0x2A, 0x14, 0x6D, 0x8D, + 0xA2, 0xAB, 0x8C, 0xF6, 0x19, 0x72, 0x29, 0xA5 + }, + { + 0xEF, 0xC4, 0x83, 0x6B, 0xE4, 0xAC, 0x3E, 0x97, + 0x91, 0xD2, 0xEC, 0x62, 0x22, 0x6E, 0x7D, 0xF6, + 0x41, 0x18, 0xF4, 0x56, 0x5C, 0x19, 0xE6, 0xC9, + 0xE8, 0x40, 0x63, 0xF5, 0x66, 0x1C, 0x7B, 0x2F + }, + { + 0x3A, 0x76, 0xB0, 0x15, 0x2C, 0x0E, 0x1D, 0x1F, + 0xD7, 0xAC, 0x9D, 0x91, 0xA2, 0x8A, 0x18, 0xE1, + 0xA4, 0xC0, 0x60, 0x80, 0xF2, 0xB7, 0xEC, 0xEF, + 0xB6, 0xEF, 0xFE, 0x28, 0xB8, 0xCF, 0xC7, 0x65 + }, + { + 0x0D, 0x46, 0xAD, 0x03, 0x90, 0x70, 0x11, 0x58, + 0x28, 0xF9, 0x4E, 0xB6, 0xB7, 0x29, 0x63, 0xE6, + 0x0A, 0x7D, 0x2D, 0xB7, 0xCA, 0x89, 0x91, 0xD2, + 0x25, 0xC3, 0x87, 0x7B, 0x14, 0x9B, 0x0A, 0x8A + }, + { + 0xE4, 0x4C, 0xFC, 0x42, 0x11, 0x8F, 0x09, 0x6B, + 0xFC, 0x51, 0x52, 0x1C, 0xB1, 0x8D, 0x5D, 0x65, + 0x25, 0x58, 0x6B, 0x98, 0x9F, 0x4E, 0xE2, 0xB8, + 0x28, 0xC5, 0x19, 0x9F, 0xEA, 0xB9, 0x4B, 0x82 + }, + { + 0x6D, 0x4B, 0xD2, 0xE0, 0x73, 0xEC, 0x49, 0x66, + 0x84, 0x7F, 0x5C, 0xBE, 0x88, 0xDD, 0xFA, 0xBA, + 0x2B, 0xE4, 0xCA, 0xF2, 0xF3, 0x33, 0x55, 0x2B, + 0x85, 0x53, 0xDA, 0x53, 0x34, 0x87, 0xC2, 0x5B + }, + { + 0xBB, 0xC4, 0x6D, 0xB4, 0x37, 0xD1, 0x07, 0xC9, + 0x67, 0xCA, 0x6D, 0x91, 0x45, 0x5B, 0xBD, 0xFE, + 0x05, 0x21, 0x18, 0xAB, 0xD1, 0xD0, 0x69, 0xF0, + 0x43, 0x59, 0x48, 0x7E, 0x13, 0xAE, 0xA0, 0xE1 + }, + { + 0xB9, 0x74, 0xC1, 0x4D, 0xB7, 0xD3, 0x17, 0x4D, + 0xD0, 0x60, 0x84, 0xBB, 0x30, 0x31, 0x08, 0xB2, + 0xF0, 0xDA, 0xF5, 0x0E, 0xCC, 0xC3, 0x29, 0x35, + 0x43, 0x79, 0x5C, 0x96, 0x36, 0xC6, 0x24, 0x82 + }, + { + 0x0E, 0xEE, 0x23, 0x5B, 0x06, 0x93, 0x6A, 0xED, + 0x71, 0x73, 0xC8, 0xC1, 0x9A, 0xA7, 0xC2, 0x17, + 0xB9, 0xEE, 0xDA, 0xEB, 0x1A, 0x88, 0xF3, 0x05, + 0x52, 0xE9, 0x22, 0x51, 0x45, 0x14, 0x9E, 0x82 + }, + { + 0x36, 0xD0, 0x89, 0xE0, 0x25, 0xB5, 0x68, 0x69, + 0x37, 0x74, 0x28, 0x25, 0xE6, 0xEE, 0x3D, 0x83, + 0xE7, 0xD7, 0xA5, 0x0C, 0x82, 0x3C, 0x82, 0x88, + 0x34, 0x60, 0xF3, 0x85, 0x14, 0x7D, 0xC1, 0x7B + }, + { + 0x77, 0xEE, 0x4F, 0xFC, 0x9F, 0x5D, 0xD6, 0x05, + 0x47, 0x0D, 0xC0, 0xE7, 0x4D, 0x6B, 0x17, 0xC5, + 0x13, 0x0D, 0x8B, 0x73, 0x91, 0x3F, 0x36, 0xD5, + 0xF8, 0x78, 0x7E, 0x61, 0x9A, 0x94, 0x7C, 0xA0 + }, + { + 0x0F, 0xE6, 0xC2, 0xAB, 0x75, 0x42, 0x33, 0x36, + 0x0D, 0x68, 0xB9, 0xAC, 0x80, 0xCD, 0x61, 0x18, + 0x4B, 0xFA, 0xA7, 0xD3, 0x56, 0x29, 0x41, 0x80, + 0x02, 0x5F, 0xE4, 0x06, 0x39, 0xC7, 0x6C, 0x36 + }, + { + 0x99, 0x60, 0x88, 0xC7, 0x94, 0x56, 0xEC, 0xDD, + 0xA1, 0xFB, 0xC0, 0x2E, 0xE1, 0xBA, 0x42, 0xD9, + 0x1D, 0x85, 0x8C, 0x31, 0x0A, 0x5A, 0x8B, 0x46, + 0x74, 0xFE, 0x6A, 0x7C, 0x14, 0x44, 0x14, 0xA1 + }, + { + 0x9E, 0x33, 0x8A, 0xED, 0x0B, 0xC7, 0x1C, 0x0C, + 0x97, 0xF1, 0x98, 0x55, 0xBF, 0x49, 0x17, 0x4F, + 0x70, 0xA9, 0xD7, 0x70, 0x14, 0x87, 0x36, 0x63, + 0x21, 0x34, 0x27, 0x50, 0x2B, 0xD8, 0x5D, 0x9F + }, + { + 0x4A, 0x84, 0x3D, 0x26, 0xAD, 0xEC, 0x52, 0x0E, + 0x4B, 0x5D, 0xBF, 0x01, 0x45, 0xCC, 0x4F, 0x50, + 0x24, 0xFA, 0xFC, 0xDC, 0x20, 0x25, 0x82, 0x4A, + 0x8C, 0x64, 0x65, 0x06, 0x17, 0x68, 0x7E, 0xE7 + }, + { + 0xC9, 0x16, 0x78, 0xC4, 0xA6, 0x4E, 0x2F, 0xA4, + 0xB7, 0x4D, 0xE6, 0x1A, 0xD0, 0xC0, 0x6F, 0xF0, + 0x6B, 0x5D, 0x67, 0x2F, 0xA7, 0xC6, 0x87, 0x7A, + 0x40, 0x14, 0xCE, 0x9E, 0x91, 0xBE, 0x38, 0xD7 + }, + { + 0xFF, 0x77, 0x77, 0x40, 0x5D, 0x32, 0x7A, 0xDB, + 0x58, 0x30, 0x1C, 0x71, 0x1E, 0xCD, 0xC2, 0xBC, + 0xE1, 0xBF, 0xA8, 0x29, 0xFF, 0xC9, 0xB1, 0x17, + 0xF2, 0x1A, 0x2B, 0x19, 0x8D, 0x0D, 0x68, 0x84 + }, + { + 0x0A, 0x8D, 0xDA, 0xF1, 0x72, 0x8C, 0x5C, 0xD9, + 0x3A, 0x25, 0x5D, 0x56, 0x23, 0xC3, 0xDA, 0xDA, + 0x2D, 0x3D, 0x05, 0x71, 0xBF, 0x14, 0x38, 0xAD, + 0xC8, 0xC9, 0x64, 0xA9, 0xAA, 0xD1, 0x18, 0xCB + }, + { + 0xC1, 0x33, 0xAB, 0xBD, 0x0D, 0x2D, 0x80, 0x8A, + 0x67, 0xB6, 0x74, 0x5B, 0x4B, 0x36, 0x50, 0xB4, + 0xA6, 0x4D, 0xC2, 0x76, 0xCF, 0x98, 0xE3, 0x03, + 0x57, 0xB6, 0xAB, 0xD5, 0xC1, 0xD2, 0x2A, 0x9B + }, + { + 0xC5, 0x9E, 0xE5, 0xC1, 0x96, 0xBA, 0x3C, 0xFE, + 0xF9, 0x40, 0x87, 0x79, 0x82, 0x07, 0xBD, 0xCE, + 0xF1, 0x39, 0xCE, 0x2C, 0xF7, 0x8D, 0xCE, 0xD6, + 0x19, 0x8F, 0x0F, 0xA3, 0xA4, 0x09, 0x13, 0x1C + }, + { + 0xC7, 0xFD, 0xAD, 0xE5, 0x9C, 0x46, 0x99, 0x38, + 0x5E, 0xBA, 0x59, 0xE7, 0x56, 0xC2, 0xB1, 0x71, + 0xB0, 0x23, 0xDE, 0xAE, 0x08, 0x2E, 0x5A, 0x6E, + 0x3B, 0xFB, 0xDC, 0x10, 0x73, 0xA3, 0x20, 0x03 + }, + { + 0x97, 0x53, 0x27, 0xC5, 0xF4, 0xDE, 0xC6, 0x41, + 0x4B, 0x6E, 0x00, 0xCB, 0x04, 0x23, 0x37, 0xB8, + 0xD2, 0xA6, 0x56, 0x46, 0x37, 0xA7, 0x44, 0x2A, + 0xEC, 0x7B, 0xE8, 0xF8, 0xC8, 0x9A, 0x2F, 0x1C + }, + { + 0xA2, 0xF7, 0x24, 0x6D, 0xF4, 0xA2, 0x4E, 0xFB, + 0xAC, 0xD3, 0xFD, 0x60, 0x68, 0x3A, 0xBC, 0x86, + 0x8B, 0xEF, 0x25, 0x32, 0x70, 0x52, 0xCF, 0x2F, + 0x1D, 0x93, 0xEC, 0xE4, 0xFF, 0xCD, 0x73, 0xC6 + }, + { + 0x49, 0x7F, 0xB2, 0xAC, 0xAC, 0xF1, 0x23, 0xF3, + 0x59, 0x5E, 0x40, 0xFC, 0x51, 0xA7, 0xBD, 0x24, + 0x45, 0x8B, 0xBC, 0xBA, 0x4A, 0x29, 0x40, 0xA5, + 0xCB, 0x03, 0xD6, 0x08, 0xFB, 0xDF, 0x28, 0x25 + }, + { + 0x0E, 0x97, 0xD2, 0x27, 0x93, 0xCE, 0x6F, 0x28, + 0x3D, 0x5C, 0x74, 0x0D, 0x30, 0x8A, 0x27, 0xAD, + 0x7C, 0x3B, 0x0D, 0x9A, 0xFC, 0xD3, 0xD9, 0xE9, + 0xB9, 0xCA, 0xC5, 0x6B, 0x10, 0x29, 0x0C, 0x8F + }, + { + 0x66, 0x30, 0xB3, 0x56, 0x18, 0xE7, 0x00, 0xD9, + 0x10, 0x68, 0x38, 0x93, 0x79, 0x5E, 0xF7, 0x0B, + 0xF0, 0x7E, 0xB1, 0x56, 0xF5, 0x5F, 0xFE, 0x3B, + 0x69, 0xAD, 0x88, 0xA4, 0xB8, 0xB0, 0xBF, 0xA1 + }, + { + 0x02, 0xF7, 0x42, 0xC6, 0xE9, 0x52, 0x78, 0x12, + 0x1A, 0x05, 0xE4, 0x42, 0x05, 0x44, 0x4F, 0xC5, + 0xEA, 0x6A, 0xF5, 0xE7, 0x41, 0xC5, 0x35, 0xBC, + 0x2C, 0xBC, 0x3B, 0x23, 0x5A, 0x2E, 0xA2, 0xB0 + }, + { + 0x46, 0x22, 0xF3, 0x6E, 0xB8, 0x98, 0x38, 0x3F, + 0x60, 0xD5, 0xBE, 0xD8, 0x09, 0xAC, 0x5C, 0x47, + 0x45, 0xC5, 0xD6, 0xAB, 0x84, 0xBC, 0xAD, 0xF7, + 0x9C, 0xF2, 0xA9, 0x6D, 0x4E, 0xC8, 0x88, 0x18 + }, + { + 0xCC, 0xD1, 0x1F, 0xAA, 0xA0, 0x58, 0x1E, 0xC3, + 0x2C, 0x3A, 0x40, 0x3F, 0x92, 0xEF, 0x43, 0xD5, + 0xDC, 0xF1, 0x95, 0xC1, 0xA1, 0x01, 0xDB, 0xFD, + 0x49, 0x5D, 0xBB, 0x4D, 0xCE, 0x80, 0x69, 0xE0 + }, + { + 0x06, 0x02, 0x4D, 0x6B, 0x07, 0xE0, 0x00, 0xBC, + 0xE6, 0x13, 0x47, 0x0A, 0x28, 0x80, 0x51, 0x9B, + 0x8B, 0xE4, 0xA3, 0x6B, 0xF3, 0x3C, 0x99, 0xC9, + 0x17, 0x89, 0x3E, 0xC7, 0x5D, 0xD9, 0x0F, 0xE3 + }, + { + 0xD9, 0x3A, 0xF9, 0x47, 0xB1, 0x46, 0x3A, 0x81, + 0x7D, 0xB4, 0x41, 0xA4, 0x74, 0x58, 0x8D, 0x6F, + 0x99, 0x6D, 0x24, 0x39, 0x83, 0xE8, 0x3C, 0x7E, + 0xEE, 0x90, 0xE1, 0xEF, 0xA4, 0x40, 0xD9, 0xBA + }, + { + 0x94, 0x89, 0x89, 0x45, 0xA7, 0xDB, 0x25, 0x9E, + 0x1B, 0x2E, 0x7C, 0xBE, 0xA4, 0x8A, 0xA0, 0xC6, + 0xD6, 0x57, 0x0D, 0x18, 0x17, 0x9F, 0x06, 0x18, + 0x47, 0x1C, 0x88, 0xF3, 0xEC, 0x3B, 0x0F, 0xC3 + }, + { + 0x4C, 0x2D, 0x93, 0x52, 0x56, 0x39, 0x2A, 0xA2, + 0xBE, 0x6E, 0x10, 0x78, 0xC0, 0x59, 0x38, 0x15, + 0xAB, 0xEF, 0x46, 0x9D, 0xE9, 0x69, 0xB5, 0x7B, + 0x88, 0x1B, 0x93, 0xAF, 0x55, 0x84, 0x65, 0xFA + }, + { + 0xAA, 0xC7, 0xBE, 0x16, 0xE5, 0x2F, 0x79, 0x0E, + 0x4F, 0xF7, 0x0B, 0x24, 0x01, 0x5C, 0xB1, 0x1B, + 0x40, 0x61, 0x6E, 0x94, 0xDB, 0x13, 0x88, 0x2B, + 0x41, 0xD3, 0xDD, 0x8C, 0x8C, 0x19, 0x52, 0xB7 + }, + { + 0x04, 0x34, 0xB4, 0x7C, 0x0E, 0xE7, 0xE6, 0xF5, + 0x39, 0x06, 0x79, 0x9A, 0x43, 0x20, 0x9D, 0x3F, + 0xC3, 0x7D, 0x3F, 0xD1, 0xF7, 0x45, 0x55, 0xDE, + 0x67, 0xAB, 0xAC, 0xB9, 0x51, 0xB0, 0x06, 0xF4 + }, + { + 0x04, 0x42, 0xFB, 0xDD, 0x5B, 0x58, 0x49, 0x6E, + 0xC7, 0x81, 0x59, 0xCC, 0xAA, 0x88, 0x7C, 0x88, + 0xA8, 0x61, 0xFC, 0xCA, 0x70, 0xE7, 0xAB, 0xC9, + 0x76, 0xF2, 0x4C, 0x11, 0x58, 0x8B, 0xE6, 0xEE + }, + { + 0xA7, 0x3E, 0x68, 0xBB, 0x18, 0xB0, 0x07, 0x64, + 0x8E, 0x76, 0xB5, 0x52, 0x8D, 0x1E, 0x50, 0xE7, + 0xFA, 0x65, 0x4D, 0xA3, 0x97, 0x0E, 0xC3, 0x49, + 0xBF, 0x59, 0x1A, 0x30, 0xD9, 0x32, 0xC8, 0xF6 + }, + { + 0x84, 0x9C, 0xF8, 0x73, 0x16, 0x2B, 0xA7, 0x2C, + 0x4B, 0x80, 0x08, 0xE6, 0x8F, 0x93, 0x2F, 0xB3, + 0xA0, 0x15, 0xA7, 0x4F, 0xCF, 0x95, 0x71, 0x98, + 0xD5, 0x6A, 0x0D, 0xC4, 0x62, 0x5A, 0x74, 0xF5 + }, + { + 0xA6, 0xDE, 0xC6, 0xFC, 0x89, 0x49, 0x34, 0x9C, + 0x4E, 0x9A, 0x9C, 0x62, 0x36, 0x87, 0xFB, 0xA4, + 0xC9, 0xB2, 0x75, 0xBD, 0xB2, 0x30, 0x50, 0x9B, + 0x72, 0xE3, 0xD6, 0x71, 0x19, 0x14, 0xE2, 0xD8 + }, + { + 0x58, 0xAF, 0xC2, 0xB2, 0x4A, 0x19, 0xFD, 0xBF, + 0x76, 0xA0, 0x9B, 0x70, 0xB1, 0xE3, 0xB7, 0x7F, + 0xCB, 0xD4, 0x06, 0x50, 0x01, 0xD9, 0x63, 0x66, + 0x40, 0xEB, 0x5A, 0x26, 0x28, 0xF4, 0x42, 0xCC + }, + { + 0x47, 0x3A, 0x43, 0xAA, 0x1D, 0x6A, 0x02, 0x87, + 0x67, 0x43, 0x2A, 0x83, 0x0A, 0xD1, 0x22, 0x1E, + 0x02, 0x9C, 0x58, 0x9A, 0xF9, 0xFD, 0x4D, 0x68, + 0xD5, 0x6C, 0x4F, 0xB8, 0x20, 0x25, 0x93, 0x52 + }, + { + 0xA0, 0xAE, 0xB4, 0xA5, 0xAD, 0x89, 0x9A, 0xF2, + 0xE2, 0x91, 0xB2, 0xE7, 0x9D, 0xBB, 0x6B, 0x0B, + 0xF5, 0x6B, 0x58, 0x44, 0x67, 0x6B, 0x95, 0x5D, + 0x94, 0x5B, 0x6C, 0x4A, 0xE1, 0xC0, 0x1E, 0xED + }, + { + 0xCF, 0xC3, 0x02, 0x9A, 0x9E, 0xEB, 0x15, 0x22, + 0x22, 0xD9, 0x66, 0x53, 0x49, 0x2E, 0x46, 0xCA, + 0x64, 0xCA, 0x4F, 0x0D, 0x64, 0x68, 0x30, 0x28, + 0xD3, 0xAE, 0xE5, 0xA4, 0x9C, 0xB4, 0x71, 0x63 + }, + { + 0x74, 0x67, 0xCF, 0x77, 0x61, 0xCD, 0x9F, 0x55, + 0x61, 0x8D, 0x30, 0xC9, 0xD8, 0xC5, 0xB4, 0x1E, + 0x47, 0x01, 0x51, 0x0C, 0x7D, 0x16, 0xAB, 0x4E, + 0x5D, 0x89, 0xA5, 0xD7, 0x71, 0x46, 0xB0, 0x92 + }, + { + 0xC0, 0x16, 0xD8, 0x42, 0x4E, 0x53, 0x1E, 0xFC, + 0x57, 0x37, 0xC0, 0x3F, 0xC9, 0x0A, 0x5E, 0xFC, + 0x9F, 0x90, 0x22, 0xE4, 0xD5, 0xBA, 0x3B, 0x06, + 0x95, 0xF7, 0xAE, 0x53, 0x82, 0x60, 0xC2, 0xEE + }, + { + 0x5D, 0x38, 0x11, 0x89, 0xE6, 0x00, 0x0F, 0xC1, + 0x17, 0xC7, 0x1F, 0x59, 0xF7, 0x86, 0xFB, 0x4B, + 0x79, 0xFD, 0xD4, 0xEC, 0x5D, 0x4C, 0xD3, 0x0A, + 0xAC, 0x21, 0x57, 0xF7, 0x5D, 0xEA, 0xD7, 0x78 + }, + { + 0x7C, 0x9C, 0xDD, 0x15, 0xC4, 0xC9, 0xAB, 0xCA, + 0xCB, 0xFE, 0x6F, 0x66, 0x4A, 0x7F, 0x5F, 0x8B, + 0x2E, 0x25, 0x91, 0x83, 0x29, 0x1A, 0xE5, 0xCC, + 0x91, 0x30, 0xA0, 0xB2, 0x41, 0xE5, 0x73, 0x7F + }, + { + 0xB8, 0x81, 0x31, 0x72, 0xF5, 0x21, 0x8A, 0xC3, + 0xEB, 0x68, 0x7B, 0xC4, 0xAF, 0xAF, 0xF8, 0x3F, + 0xBC, 0xA4, 0xE9, 0xC1, 0xA4, 0x62, 0x96, 0x33, + 0x01, 0xDD, 0x44, 0x59, 0x85, 0x01, 0x50, 0xA2 + }, + { + 0xE3, 0xD1, 0x30, 0xE3, 0x6A, 0x02, 0x8E, 0xA8, + 0x0C, 0x57, 0xA2, 0xAA, 0x48, 0x19, 0xFD, 0x34, + 0xE4, 0xDB, 0xBE, 0xB1, 0x4A, 0x49, 0x58, 0x94, + 0xB1, 0x5A, 0x87, 0x87, 0xDB, 0x1A, 0x9F, 0x9C + }, + { + 0xFF, 0xF1, 0xB4, 0x40, 0x0F, 0x48, 0x9E, 0x07, + 0xD2, 0x23, 0x51, 0xC1, 0xF0, 0x95, 0x65, 0xE2, + 0x65, 0xB6, 0x8A, 0xD2, 0x9F, 0x63, 0x29, 0x87, + 0x9E, 0x6B, 0x5F, 0x7F, 0x6B, 0x41, 0x93, 0x50 + }, + { + 0x55, 0x9E, 0xD5, 0xBB, 0x3E, 0x5F, 0x39, 0x85, + 0xFB, 0x57, 0x82, 0x28, 0xBF, 0x8C, 0x0F, 0x0B, + 0x17, 0x3F, 0x8D, 0x11, 0x53, 0xFA, 0xEB, 0x9F, + 0xEC, 0x75, 0x6F, 0xFD, 0x18, 0xA8, 0x72, 0x38 + }, + { + 0x88, 0x13, 0x12, 0x53, 0x01, 0x4D, 0x23, 0xC5, + 0xE3, 0x8E, 0x78, 0xBD, 0xA1, 0x94, 0x55, 0xD8, + 0xA0, 0x23, 0xBD, 0x7A, 0x7E, 0x72, 0x74, 0x57, + 0xA1, 0x52, 0xA8, 0x1D, 0x0B, 0x17, 0x18, 0xA7 + }, + { + 0xF4, 0xD3, 0xFA, 0xE7, 0xCD, 0xE6, 0xBB, 0x66, + 0x71, 0x5A, 0x19, 0x8F, 0xA4, 0x8D, 0x21, 0x0C, + 0x10, 0xF8, 0xDF, 0x32, 0x04, 0xAE, 0x5E, 0x33, + 0xA6, 0x02, 0x46, 0x7F, 0x1B, 0x62, 0x26, 0x85 + }, + { + 0xE6, 0x2B, 0x62, 0x2A, 0xC8, 0xA2, 0x13, 0x66, + 0xBF, 0x2D, 0xED, 0x30, 0xF4, 0x08, 0x2A, 0x53, + 0xE7, 0x7A, 0x9A, 0xA6, 0x96, 0xB1, 0xF3, 0xEE, + 0x8C, 0xFE, 0x99, 0xC5, 0x93, 0x12, 0xD9, 0xC7 + }, + { + 0x3D, 0x39, 0xFF, 0xA8, 0x55, 0x12, 0xC3, 0xC8, + 0x89, 0x0D, 0x4B, 0xDF, 0x31, 0x88, 0x9C, 0xA6, + 0x6E, 0x5C, 0xEC, 0xB6, 0x3C, 0xFE, 0xED, 0x57, + 0xB9, 0x26, 0x37, 0x08, 0xE7, 0x4C, 0x55, 0x0B + }, + { + 0xB1, 0x70, 0x3B, 0x8A, 0x00, 0xE2, 0x61, 0x24, + 0x97, 0xD1, 0x1C, 0x64, 0x9D, 0x15, 0x0A, 0x6C, + 0x96, 0x3B, 0xF4, 0xFD, 0x38, 0xFE, 0xB1, 0xC3, + 0x81, 0xFE, 0x0D, 0x9B, 0x04, 0xC0, 0x2B, 0x22 + }, + { + 0x12, 0xFB, 0xAD, 0x9D, 0x37, 0x82, 0x81, 0x2D, + 0x71, 0x17, 0x9A, 0x50, 0xFB, 0xD9, 0xB4, 0x56, + 0x6C, 0x7B, 0x06, 0xF5, 0xD7, 0x7C, 0x6F, 0x32, + 0x97, 0x17, 0xFB, 0x4A, 0xE2, 0xC5, 0xB4, 0xEC + }, + { + 0x76, 0x8B, 0x65, 0x9A, 0x82, 0x4B, 0x43, 0xF9, + 0xCA, 0x56, 0x60, 0xB9, 0xDD, 0xF0, 0x5F, 0x8B, + 0xA2, 0xBC, 0x49, 0x93, 0x86, 0x6B, 0x7C, 0x9B, + 0xE6, 0x87, 0x91, 0xF5, 0xB2, 0x46, 0x44, 0xB3 + }, + { + 0xC0, 0x20, 0x4E, 0x23, 0xCA, 0x86, 0xBE, 0x20, + 0x5E, 0xED, 0x0C, 0xC3, 0xDD, 0x72, 0x25, 0xCE, + 0x5F, 0xFE, 0x1E, 0xE1, 0x2D, 0xAC, 0xB9, 0x3C, + 0x5D, 0x06, 0x29, 0xB7, 0x69, 0x9C, 0xD7, 0x33 + }, + { + 0xF4, 0x32, 0x96, 0x96, 0x1F, 0x8E, 0xAE, 0xCC, + 0xD8, 0x54, 0x41, 0x3D, 0xC5, 0xAD, 0xDA, 0x62, + 0x39, 0x3A, 0x34, 0x46, 0x27, 0xE8, 0x6C, 0x06, + 0x6E, 0x79, 0x07, 0x55, 0x00, 0x40, 0x74, 0x4F + }, + { + 0x82, 0xF4, 0x46, 0x9E, 0x80, 0x78, 0x90, 0x21, + 0xC6, 0x1D, 0xB7, 0xE3, 0x2F, 0x36, 0xAC, 0xBE, + 0x59, 0x1A, 0x64, 0xF2, 0x60, 0x59, 0x26, 0x57, + 0x70, 0xAE, 0x65, 0x8D, 0x62, 0xBD, 0xE7, 0xEF + }, + { + 0x2A, 0x85, 0x67, 0x1A, 0x55, 0xC8, 0x9F, 0xA1, + 0x56, 0xE2, 0x96, 0xF7, 0x5D, 0xF1, 0xC7, 0xDB, + 0xAB, 0x17, 0x8E, 0xBB, 0xA6, 0x52, 0x04, 0xA7, + 0xE8, 0x17, 0x8C, 0x91, 0x6A, 0xD0, 0x87, 0xF8 + }, + { + 0x33, 0xE2, 0x45, 0x00, 0x28, 0x08, 0xF6, 0x93, + 0x4B, 0x9B, 0xE3, 0xA6, 0xFA, 0x8E, 0x86, 0x70, + 0xC9, 0x0B, 0xAA, 0x62, 0x57, 0x17, 0xB9, 0x20, + 0x1E, 0xB9, 0xB9, 0xDD, 0x91, 0x2F, 0x5C, 0xE2 + }, + { + 0x58, 0xEE, 0x5E, 0x79, 0x91, 0x84, 0xAD, 0x9D, + 0xA9, 0xA1, 0x7C, 0x5B, 0x46, 0xA4, 0x81, 0x0E, + 0x28, 0xBD, 0xD0, 0x8C, 0x35, 0x81, 0x63, 0x4C, + 0x83, 0x50, 0x30, 0x53, 0x9B, 0x79, 0x54, 0x4D + }, + { + 0x26, 0xD8, 0xFA, 0x08, 0xDB, 0x30, 0x8E, 0xDF, + 0x2F, 0x96, 0xF8, 0x2A, 0xF6, 0xB6, 0x0C, 0x17, + 0xD8, 0xF1, 0xFF, 0x85, 0x8C, 0x52, 0xF2, 0xD0, + 0xF3, 0x83, 0x10, 0x78, 0x12, 0x75, 0x26, 0xA3 + }, + { + 0x25, 0xA5, 0x8D, 0xF4, 0x03, 0x92, 0x47, 0xA2, + 0x2F, 0x68, 0xFF, 0x2B, 0x71, 0x76, 0x6B, 0x7B, + 0x56, 0x00, 0xDD, 0xF4, 0x01, 0xD9, 0x9F, 0xF2, + 0xC1, 0x95, 0x5A, 0xE7, 0xBB, 0x43, 0xE5, 0x6A + }, + { + 0xBE, 0x43, 0xE8, 0x68, 0x61, 0x60, 0xE9, 0x07, + 0xBA, 0x54, 0x7D, 0x5A, 0x87, 0x9D, 0x10, 0xF7, + 0x88, 0xAF, 0xC8, 0x42, 0xB8, 0xEB, 0xB9, 0xF3, + 0xF7, 0x88, 0x53, 0x25, 0x15, 0x91, 0x2A, 0xE4 + }, + { + 0xAA, 0x4A, 0xCB, 0x95, 0xD8, 0x79, 0x19, 0x2A, + 0x69, 0x08, 0xE8, 0x8A, 0xE3, 0xD6, 0x58, 0x9F, + 0x4E, 0x3E, 0xB3, 0xD4, 0xE0, 0x3A, 0x80, 0x6C, + 0xCD, 0xB9, 0xB5, 0xD6, 0xA9, 0x58, 0x6F, 0xDF + }, + { + 0x84, 0x66, 0xD5, 0xE4, 0x4C, 0xE9, 0x5B, 0x4F, + 0xA1, 0x79, 0x99, 0x24, 0x44, 0xB8, 0xC2, 0x48, + 0x5B, 0x88, 0x64, 0x48, 0xA6, 0xDC, 0xCF, 0xCF, + 0x0B, 0xC3, 0x0B, 0xC5, 0xF0, 0xF5, 0x6B, 0x01 + }, + { + 0x00, 0x56, 0xD7, 0xE0, 0xAC, 0x33, 0x35, 0x57, + 0x83, 0x65, 0x9B, 0x38, 0xEC, 0x8B, 0xEC, 0xCB, + 0xF7, 0x83, 0x93, 0x99, 0x67, 0xFE, 0x37, 0xAE, + 0xAC, 0xF3, 0x69, 0xDD, 0xB6, 0x70, 0xAD, 0xA0 + }, + { + 0x90, 0x4F, 0x42, 0xF3, 0x45, 0x53, 0x0A, 0xC8, + 0xA3, 0x52, 0xD0, 0x9B, 0x68, 0x72, 0xC5, 0xBC, + 0xA3, 0x66, 0x1A, 0xBC, 0xA6, 0xCA, 0x64, 0xC8, + 0x09, 0x9F, 0x2F, 0xB6, 0x86, 0x7C, 0x30, 0xFE + }, + { + 0xA8, 0xC3, 0xBF, 0x46, 0xF0, 0xB8, 0x8B, 0xBD, + 0x16, 0xFD, 0xA4, 0xA8, 0xB5, 0xCA, 0x81, 0xF5, + 0x24, 0x35, 0x20, 0xC3, 0x85, 0xD3, 0x8C, 0x0B, + 0x4D, 0x23, 0x52, 0xAB, 0x34, 0xEA, 0x35, 0xE6 + }, + { + 0x8D, 0x33, 0x17, 0xFC, 0x60, 0x6E, 0x56, 0x6D, + 0x30, 0x2E, 0xDA, 0xB5, 0x5E, 0x80, 0x16, 0x11, + 0xD8, 0xC1, 0x3F, 0x4A, 0x9A, 0x19, 0xD1, 0x85, + 0x97, 0x8D, 0xEF, 0x72, 0x83, 0x9C, 0xDA, 0xA3 + }, + { + 0x97, 0x38, 0x80, 0x11, 0xF5, 0x7A, 0x49, 0x86, + 0x90, 0xEC, 0x79, 0x88, 0xEF, 0xF9, 0x03, 0xFF, + 0x9B, 0x23, 0x58, 0xF5, 0xB6, 0x1B, 0xAA, 0x20, + 0xF7, 0x32, 0x90, 0xD6, 0x29, 0x6C, 0x1C, 0x0B + }, + { + 0xCF, 0xB8, 0x0C, 0xAB, 0x89, 0x90, 0x95, 0x08, + 0x09, 0x12, 0x3F, 0xBF, 0x85, 0xE9, 0x76, 0x45, + 0x47, 0x08, 0xE0, 0xAF, 0xED, 0x69, 0x8E, 0x33, + 0x52, 0xA3, 0x16, 0x35, 0x90, 0x9D, 0xB3, 0xE5 + }, + { + 0x0D, 0xAA, 0xCA, 0x55, 0x13, 0x2A, 0x23, 0x5B, + 0x83, 0x1A, 0x5E, 0xFF, 0x4E, 0xA4, 0x67, 0xCD, + 0x10, 0xAF, 0x44, 0x20, 0x08, 0x47, 0x73, 0x5A, + 0x1F, 0xFD, 0x51, 0xFA, 0x37, 0xEA, 0xA2, 0xA2 + }, + { + 0x69, 0xB2, 0x14, 0x97, 0xEB, 0xB8, 0x24, 0xBA, + 0x66, 0x53, 0x68, 0x18, 0x88, 0x25, 0xE6, 0xF6, + 0xF1, 0x4C, 0xF2, 0xC3, 0xF7, 0xB5, 0x53, 0x0B, + 0xB3, 0x4F, 0xA6, 0x58, 0xEE, 0xD9, 0xA7, 0x39 + }, + { + 0xB9, 0xA1, 0x9F, 0x50, 0x9B, 0xE0, 0x3F, 0xBC, + 0x40, 0xE2, 0x43, 0xA5, 0x8A, 0x3D, 0xED, 0x11, + 0xF0, 0xD5, 0x1F, 0x80, 0xE3, 0xE2, 0x9A, 0x50, + 0x56, 0x44, 0xCC, 0x05, 0x74, 0x38, 0x14, 0xEC + }, + { + 0xC4, 0xBC, 0xB2, 0x00, 0x25, 0x55, 0xD5, 0x44, + 0xFD, 0x0B, 0x02, 0x77, 0x06, 0x23, 0x89, 0x1E, + 0x70, 0xEE, 0xEC, 0x77, 0x44, 0x86, 0x5D, 0xD6, + 0x45, 0x5A, 0xD6, 0x65, 0xCC, 0x82, 0xE8, 0x61 + }, + { + 0x91, 0x2D, 0x24, 0xDC, 0x3D, 0x69, 0x23, 0xA4, + 0x83, 0xC2, 0x63, 0xEB, 0xA8, 0x1B, 0x7A, 0x87, + 0x97, 0xF2, 0x3C, 0xBF, 0x2F, 0x78, 0xB5, 0x1E, + 0x22, 0x26, 0x63, 0x9F, 0x84, 0xA5, 0x90, 0x47 + }, + { + 0x56, 0x82, 0x7A, 0x18, 0x88, 0x3A, 0xFD, 0xF9, + 0xCE, 0xEC, 0x56, 0x2B, 0x20, 0x66, 0xD8, 0xAC, + 0xB2, 0xC1, 0x95, 0x05, 0xEC, 0xE6, 0xF7, 0xA8, + 0x3E, 0x9F, 0x33, 0x46, 0xCB, 0xB8, 0x28, 0xC9 + }, + { + 0x25, 0x1D, 0x8D, 0x09, 0xFC, 0x48, 0xDD, 0x1D, + 0x6A, 0xF8, 0xFF, 0xDF, 0x39, 0x50, 0x91, 0xA4, + 0x6E, 0x05, 0xB8, 0xB7, 0xC5, 0xEC, 0x0C, 0x79, + 0xB6, 0x8A, 0x89, 0x04, 0xC8, 0x27, 0xBD, 0xEA + }, + { + 0xC2, 0xD1, 0x4D, 0x69, 0xFD, 0x0B, 0xBD, 0x1C, + 0x0F, 0xE8, 0xC8, 0x45, 0xD5, 0xFD, 0x6A, 0x8F, + 0x74, 0x01, 0x51, 0xB1, 0xD8, 0xEB, 0x4D, 0x26, + 0x36, 0x4B, 0xB0, 0x2D, 0xAE, 0x0C, 0x13, 0xBC + }, + { + 0x2E, 0x5F, 0xE2, 0x1F, 0x8F, 0x1B, 0x63, 0x97, + 0xA3, 0x8A, 0x60, 0x3D, 0x60, 0xB6, 0xF5, 0x3C, + 0x3B, 0x5D, 0xB2, 0x0A, 0xA5, 0x6C, 0x6D, 0x44, + 0xBE, 0xBD, 0x48, 0x28, 0xCE, 0x28, 0xF9, 0x0F + }, + { + 0x25, 0x05, 0x9F, 0x10, 0x60, 0x5E, 0x67, 0xAD, + 0xFE, 0x68, 0x13, 0x50, 0x66, 0x6E, 0x15, 0xAE, + 0x97, 0x6A, 0x5A, 0x57, 0x1C, 0x13, 0xCF, 0x5B, + 0xC8, 0x05, 0x3F, 0x43, 0x0E, 0x12, 0x0A, 0x52 + }, + { + 0x51, 0x40, 0xCF, 0xBE, 0x0C, 0x4E, 0xC0, 0x95, + 0xDD, 0x01, 0x71, 0x3D, 0xC4, 0x70, 0xE0, 0xCA, + 0x04, 0x9E, 0x5B, 0xA8, 0x67, 0x19, 0x84, 0xCD, + 0x28, 0xAB, 0x51, 0x0D, 0xFF, 0xEE, 0x97, 0xCD + }, + { + 0x15, 0xDA, 0x7B, 0x3A, 0xDB, 0xB3, 0x00, 0x57, + 0xA0, 0x29, 0x44, 0x8A, 0xAF, 0x7C, 0x63, 0x3E, + 0x7A, 0x1F, 0x7D, 0x5C, 0xE1, 0xD2, 0x49, 0xC2, + 0x62, 0x0A, 0xD3, 0x69, 0xD1, 0xD6, 0x2D, 0x9E + }, + { + 0xF1, 0xB4, 0xAB, 0x71, 0xF0, 0x58, 0x6F, 0x30, + 0x10, 0x1C, 0x93, 0x52, 0x25, 0x71, 0x0E, 0x2A, + 0x73, 0x6E, 0x8F, 0xC9, 0xA9, 0xB9, 0xF6, 0x7C, + 0x4F, 0x76, 0x20, 0x7E, 0x3F, 0x33, 0xC0, 0x19 + }, + { + 0xC6, 0x7B, 0x34, 0x56, 0xFA, 0xF7, 0x52, 0xAC, + 0x24, 0x5A, 0x2D, 0x0F, 0x09, 0x77, 0xC5, 0x4F, + 0xB4, 0xAC, 0x7A, 0x37, 0x4C, 0x46, 0x08, 0x12, + 0xBC, 0x55, 0x12, 0x32, 0x40, 0xC0, 0x9B, 0xEE + }, + { + 0xCC, 0xD5, 0xCA, 0x6A, 0xBC, 0xBE, 0x2B, 0x9F, + 0x99, 0xCE, 0x95, 0x55, 0x1A, 0x5D, 0xAD, 0x56, + 0x67, 0xEC, 0x59, 0x38, 0x82, 0x86, 0x1E, 0x70, + 0xAD, 0x8F, 0x49, 0x6C, 0x1D, 0xBE, 0xA8, 0xD9 + }, + { + 0x72, 0x9D, 0x01, 0x83, 0x60, 0xD6, 0x09, 0x5E, + 0x90, 0x8D, 0x6E, 0xA8, 0x93, 0xE2, 0x8D, 0xF3, + 0x3D, 0x7C, 0xEB, 0x72, 0xF4, 0x59, 0x79, 0x00, + 0x4F, 0xBA, 0x38, 0xE9, 0xA2, 0x64, 0xD8, 0xF1 + }, + { + 0xED, 0x4A, 0xD4, 0xC8, 0x33, 0x8E, 0x81, 0x6A, + 0xCC, 0xFC, 0x4B, 0x1A, 0xA3, 0x68, 0x2C, 0x73, + 0xC7, 0x3E, 0xDB, 0x7F, 0x2F, 0xCD, 0x72, 0xEC, + 0x87, 0x31, 0xEC, 0x98, 0x5F, 0xE8, 0xAA, 0x82 + }, + { + 0x0C, 0x77, 0x8A, 0xAC, 0x95, 0xF3, 0xB9, 0xA6, + 0xD4, 0xA0, 0x1E, 0x1C, 0x1E, 0xA2, 0x0D, 0xD8, + 0xEE, 0x62, 0xAA, 0x67, 0x16, 0xBA, 0xA9, 0xAF, + 0x0E, 0xD3, 0x5B, 0x4F, 0x40, 0xD8, 0x8F, 0xE2 + }, + { + 0x1B, 0x1E, 0x12, 0xB2, 0xD5, 0x97, 0xBA, 0x31, + 0x72, 0x22, 0x1E, 0x0D, 0xD2, 0x6C, 0xD4, 0x29, + 0x82, 0xDA, 0x64, 0xAC, 0x09, 0xAC, 0xF9, 0xD2, + 0x3E, 0xA7, 0x8C, 0xD0, 0x04, 0xE6, 0x84, 0x83 + }, + { + 0xB6, 0xBB, 0x94, 0x4A, 0x20, 0xFA, 0x3E, 0x57, + 0x5A, 0x23, 0xF2, 0xA9, 0x68, 0x08, 0xB1, 0x5A, + 0x2D, 0x6F, 0x41, 0xD6, 0xED, 0x3C, 0x65, 0xF6, + 0x88, 0x58, 0x54, 0xF1, 0x77, 0x4A, 0xEE, 0xF9 + }, + { + 0xE9, 0xDA, 0x7A, 0x00, 0xE0, 0xBB, 0x43, 0xCE, + 0xEE, 0xA1, 0x5B, 0xD3, 0x78, 0xED, 0x5D, 0x4F, + 0xFC, 0x00, 0x19, 0x6A, 0x5F, 0x2D, 0x68, 0xB2, + 0x3F, 0x2C, 0x79, 0x90, 0x0B, 0xFD, 0x3C, 0x8F + }, + { + 0x21, 0x09, 0x9A, 0x71, 0xFB, 0xB6, 0x0F, 0x88, + 0xE5, 0x91, 0x58, 0xA4, 0xF4, 0x7F, 0x95, 0xF2, + 0x9F, 0x58, 0x8E, 0xFD, 0x04, 0x16, 0x3A, 0x83, + 0x81, 0x64, 0x8A, 0x5E, 0x34, 0x0A, 0x2B, 0x7D + }, + { + 0x67, 0xB8, 0x52, 0x6C, 0xA4, 0x32, 0x3A, 0xBE, + 0x47, 0x97, 0x96, 0x9C, 0x9E, 0xEE, 0x05, 0x44, + 0x34, 0xD4, 0xCB, 0xCA, 0xB7, 0x07, 0xC6, 0xDE, + 0xB4, 0x28, 0x0B, 0xB3, 0xB8, 0x5B, 0x24, 0x79 + }, + { + 0x8C, 0x60, 0x11, 0xAD, 0x82, 0x1F, 0x40, 0xA0, + 0xBA, 0xBD, 0xA4, 0x8A, 0x7A, 0xCB, 0x4A, 0xC1, + 0xCA, 0xC1, 0x1E, 0xE8, 0x03, 0x66, 0x81, 0x40, + 0x7E, 0x17, 0x91, 0x66, 0x16, 0x89, 0x06, 0xBD + }, + { + 0xAF, 0xAD, 0x9C, 0x37, 0x0F, 0x66, 0x40, 0x87, + 0xC1, 0x66, 0x00, 0xEA, 0xA8, 0xDF, 0xEF, 0xD0, + 0x67, 0x5A, 0x91, 0x10, 0x6D, 0x59, 0xF1, 0x1A, + 0xE9, 0x1F, 0x9B, 0x40, 0x4E, 0xA1, 0xE0, 0x28 + }, + { + 0x49, 0x0A, 0xAD, 0x40, 0xDB, 0xAE, 0x7F, 0x52, + 0x0C, 0xE2, 0xD0, 0xB6, 0xC0, 0xA0, 0x04, 0x6F, + 0x0E, 0xE3, 0xDF, 0x98, 0x5A, 0xEC, 0x30, 0x52, + 0xEA, 0x62, 0x91, 0x7C, 0x8F, 0xFD, 0x7D, 0x65 + }, + { + 0xD2, 0x2F, 0xE4, 0xCD, 0x03, 0x53, 0xA1, 0x1B, + 0xC6, 0xED, 0x16, 0xB3, 0x4F, 0x12, 0x0B, 0xB5, + 0x1F, 0x6B, 0xFC, 0x4B, 0x76, 0x4D, 0x50, 0xE7, + 0xED, 0x85, 0xD2, 0x87, 0x4E, 0xE7, 0x4E, 0xF3 + }, + { + 0xB6, 0x45, 0xB6, 0xCD, 0xBB, 0x9E, 0x73, 0xC8, + 0x7F, 0xD1, 0x4C, 0x19, 0x60, 0x46, 0x9D, 0x88, + 0xD8, 0xCD, 0x9A, 0x15, 0xC4, 0x23, 0xA4, 0x85, + 0xC8, 0x97, 0x02, 0x0E, 0x09, 0x3D, 0x38, 0x30 + }, + { + 0x98, 0xD5, 0x99, 0x6E, 0x3F, 0xD0, 0x2E, 0xFC, + 0x19, 0xB3, 0xE7, 0x65, 0xB3, 0x02, 0x81, 0x73, + 0x63, 0x32, 0x25, 0x95, 0x97, 0xD5, 0xEC, 0xE1, + 0xD4, 0x9E, 0xB1, 0x42, 0x3F, 0x9C, 0xEC, 0x90 + }, + { + 0x30, 0xD9, 0x2C, 0xD5, 0x87, 0xCB, 0xF9, 0xFE, + 0x13, 0xFF, 0xEB, 0x6D, 0xCB, 0x50, 0xBD, 0x72, + 0x86, 0x15, 0x61, 0x1E, 0xA3, 0xFC, 0x59, 0xA0, + 0x08, 0x7B, 0xD1, 0x17, 0x04, 0x2A, 0x50, 0x28 + }, + { + 0x9B, 0x54, 0x71, 0x97, 0x4D, 0x6D, 0xCB, 0x93, + 0x02, 0x7F, 0xBE, 0xA9, 0x84, 0x28, 0x58, 0x3A, + 0x8F, 0x4E, 0xA8, 0x47, 0x6F, 0x64, 0xFF, 0x50, + 0x38, 0x52, 0x93, 0xA5, 0x99, 0x96, 0x89, 0x46 + }, + { + 0xDF, 0xAB, 0x17, 0xB7, 0xF0, 0x4D, 0xAF, 0xBF, + 0xFD, 0xD1, 0x01, 0x95, 0xE5, 0xFA, 0x07, 0xB9, + 0xB0, 0x38, 0xF3, 0xC7, 0xDA, 0x83, 0x37, 0x16, + 0x36, 0x33, 0xA4, 0xC6, 0x53, 0x5C, 0xF4, 0xA7 + }, + { + 0xA8, 0x23, 0x60, 0x8B, 0x4B, 0xDE, 0x2D, 0x74, + 0x59, 0x77, 0xDB, 0x22, 0xAE, 0x4C, 0x71, 0x12, + 0xDA, 0x35, 0x4E, 0x98, 0x83, 0x59, 0x42, 0xB2, + 0x74, 0xE6, 0xE6, 0xF1, 0x07, 0x73, 0x7B, 0x3F + }, + { + 0x3D, 0xD7, 0xC5, 0xFC, 0x94, 0x78, 0xEC, 0x07, + 0x51, 0xF7, 0x08, 0x76, 0x3D, 0x42, 0xD4, 0x48, + 0x9C, 0x0A, 0x86, 0xF5, 0xE0, 0x2D, 0x68, 0x61, + 0x1A, 0x20, 0x28, 0xD0, 0x0E, 0xFD, 0x69, 0xCC + }, + { + 0xE6, 0xA5, 0x16, 0x97, 0x40, 0x0F, 0xC3, 0xE9, + 0xFF, 0x09, 0xCB, 0x92, 0x98, 0xBF, 0xDF, 0x14, + 0xA1, 0x70, 0x2C, 0xA9, 0xB6, 0x88, 0xFC, 0x0F, + 0xD5, 0x36, 0xEA, 0xDD, 0x6F, 0x9B, 0x07, 0xD2 + }, + { + 0xBD, 0x8C, 0x5E, 0x03, 0x74, 0x6E, 0xFF, 0x1D, + 0xD3, 0x7C, 0xF4, 0xEA, 0x3D, 0xC5, 0xD9, 0x35, + 0xBF, 0x5B, 0x5B, 0x36, 0xA1, 0x32, 0x0E, 0x9E, + 0xE2, 0x64, 0xBF, 0x06, 0x0B, 0x2D, 0x90, 0xA0 + }, + { + 0x07, 0xCC, 0xBB, 0x36, 0x65, 0x97, 0x3F, 0xC3, + 0x67, 0xD5, 0x66, 0x3D, 0x1D, 0x31, 0x63, 0x5E, + 0xD5, 0x1B, 0xC9, 0x2C, 0x18, 0x58, 0xD7, 0x43, + 0xED, 0x79, 0x7E, 0x7B, 0x7B, 0xE6, 0xB0, 0x3B + }, + { + 0x2E, 0xF0, 0x71, 0xFC, 0x2E, 0x89, 0xC4, 0x35, + 0xFF, 0xC8, 0x7A, 0x86, 0x0A, 0x35, 0x5A, 0xF6, + 0x00, 0x14, 0x27, 0x1C, 0x2A, 0x92, 0xF0, 0xA4, + 0x0A, 0x2A, 0x26, 0x78, 0x7C, 0xBB, 0x02, 0x1D + }, + { + 0x68, 0xC5, 0x92, 0xE4, 0xBD, 0x56, 0xD3, 0xB6, + 0x1D, 0x5E, 0x99, 0x93, 0x59, 0x3B, 0x79, 0xC6, + 0xCB, 0xB3, 0x90, 0xC5, 0x66, 0xDB, 0x89, 0x4A, + 0xBE, 0xDA, 0xB5, 0xB4, 0x19, 0xC5, 0x0C, 0xF1 + }, + { + 0xDC, 0x50, 0xA9, 0xE9, 0x5F, 0xB5, 0x78, 0xAE, + 0x82, 0x76, 0x7C, 0x6A, 0x0E, 0x30, 0x54, 0xB6, + 0xE4, 0x0E, 0x1C, 0x48, 0x04, 0xCC, 0xAE, 0x74, + 0x32, 0xFF, 0x5A, 0x03, 0x6A, 0x4E, 0x03, 0x80 + }, + { + 0x8B, 0x9D, 0x17, 0xA0, 0x4C, 0x64, 0xD8, 0x54, + 0xB0, 0x86, 0x26, 0x8F, 0x4A, 0x86, 0xF1, 0x2B, + 0x3A, 0x99, 0x00, 0x7E, 0x55, 0x0E, 0xE6, 0xF2, + 0xCB, 0x24, 0xDC, 0x9E, 0xD9, 0xF1, 0x39, 0xC8 + }, + { + 0x08, 0x13, 0x56, 0xB7, 0x1B, 0x39, 0xFD, 0xFC, + 0x0D, 0xC5, 0xCD, 0xB4, 0xB8, 0x0C, 0x52, 0xA2, + 0x6C, 0xEA, 0x34, 0x62, 0x1D, 0x93, 0x2B, 0xB1, + 0x11, 0xB4, 0x4C, 0x09, 0x5A, 0x5B, 0x2A, 0x5E + }, + { + 0x4C, 0xCC, 0x43, 0xE6, 0x6C, 0x67, 0x42, 0xF1, + 0x80, 0x1B, 0x16, 0xDB, 0x50, 0x93, 0x60, 0x52, + 0x82, 0xA3, 0x37, 0xB5, 0x2F, 0x87, 0xCA, 0xB0, + 0x67, 0xB9, 0x62, 0x6E, 0x0A, 0x77, 0x32, 0xEF + }, + { + 0xC0, 0xDF, 0x42, 0xCE, 0x61, 0x2B, 0x28, 0xC0, + 0x2A, 0x47, 0x54, 0x36, 0xF8, 0x9D, 0xBE, 0xBD, + 0x8B, 0x5D, 0x74, 0xFB, 0xED, 0xC3, 0x11, 0xB3, + 0x2F, 0x2C, 0xED, 0x0D, 0x7F, 0xD5, 0x59, 0xD8 + }, + { + 0xE6, 0x18, 0xE1, 0x29, 0xC3, 0x01, 0xBC, 0xCD, + 0xA2, 0x07, 0x7E, 0xEE, 0xA4, 0xBE, 0xB2, 0x7E, + 0x20, 0x0B, 0x11, 0x46, 0xA9, 0x72, 0x28, 0x66, + 0x1A, 0x79, 0xE6, 0x9D, 0xAC, 0x26, 0x59, 0x38 + }, + { + 0x49, 0xD9, 0x57, 0x8C, 0x08, 0x0A, 0x0D, 0xE3, + 0x78, 0x79, 0x1E, 0x23, 0x0F, 0xD4, 0x4C, 0xB8, + 0x78, 0xBB, 0xE8, 0xE2, 0xB4, 0x4F, 0x4D, 0x64, + 0xB8, 0x5B, 0x59, 0x6F, 0x45, 0x4C, 0xD6, 0xDF + }, + { + 0xDF, 0xF4, 0x93, 0xAF, 0xDF, 0x4F, 0x57, 0x50, + 0x47, 0x92, 0x5A, 0x16, 0xB4, 0xE6, 0xB3, 0x77, + 0x84, 0xE9, 0xCF, 0xFF, 0x0B, 0x37, 0x92, 0x53, + 0x2E, 0xA0, 0x1D, 0x10, 0x86, 0x06, 0x7B, 0xCC + }, + { + 0xA5, 0x77, 0x88, 0x1E, 0x41, 0x0A, 0x52, 0xED, + 0x7E, 0xE1, 0x76, 0x35, 0x17, 0x0D, 0xF3, 0x79, + 0x44, 0xBF, 0xF4, 0xDD, 0x16, 0x95, 0x63, 0x14, + 0x35, 0x89, 0x31, 0x0B, 0x72, 0xED, 0x4C, 0x24 + }, + { + 0xE7, 0x09, 0xEA, 0x15, 0x81, 0x4A, 0xF6, 0x2F, + 0x6F, 0x9D, 0xA0, 0xE2, 0x29, 0xF9, 0xD1, 0x55, + 0xC2, 0x36, 0xCE, 0xB8, 0xE1, 0x49, 0x69, 0xE3, + 0x9D, 0x28, 0xF9, 0xC0, 0x50, 0x1D, 0xCF, 0x1D + }, + { + 0x67, 0x2E, 0x2A, 0x85, 0x77, 0xC7, 0xAD, 0x79, + 0x14, 0xB0, 0x24, 0x42, 0x13, 0x8B, 0x4B, 0x74, + 0x44, 0x2F, 0xA6, 0x72, 0xDA, 0x81, 0x32, 0x4B, + 0x2C, 0x1F, 0x8C, 0x84, 0x0F, 0xC4, 0x9C, 0x80 + }, + { + 0x93, 0xD9, 0xE8, 0xA8, 0x47, 0xDA, 0x25, 0x1D, + 0xEE, 0x2E, 0x14, 0xF3, 0x1B, 0x84, 0xCB, 0x7F, + 0xBE, 0x62, 0xBD, 0x03, 0xA7, 0x1C, 0x86, 0x3E, + 0xDD, 0x51, 0xDF, 0xAF, 0xB6, 0xDE, 0x64, 0x89 + }, + { + 0x87, 0xA7, 0x3E, 0x90, 0x45, 0x62, 0x99, 0xF9, + 0xB1, 0xC5, 0xC9, 0x82, 0x60, 0x1F, 0xBF, 0x4F, + 0x59, 0x22, 0xA5, 0x45, 0x7C, 0x49, 0x0C, 0xE1, + 0xDC, 0x0E, 0x54, 0x3A, 0x55, 0xF1, 0x4C, 0x52 + }, + { + 0x82, 0x42, 0x96, 0xE2, 0x1B, 0x81, 0x5F, 0xB6, + 0x4A, 0xF6, 0x7F, 0x65, 0xE0, 0xA2, 0x88, 0x98, + 0xFB, 0x3A, 0x45, 0xEB, 0x28, 0x88, 0x1E, 0xD8, + 0x37, 0x7C, 0xAD, 0x78, 0x74, 0x86, 0xC4, 0xA1 + }, + { + 0x41, 0x62, 0xA9, 0xBD, 0xDA, 0xA1, 0x8A, 0xAE, + 0x80, 0x1C, 0x18, 0xCC, 0x30, 0xF3, 0x62, 0x7F, + 0xAC, 0xF8, 0x3B, 0x87, 0xC7, 0xC2, 0xAB, 0x0E, + 0xD2, 0x2B, 0x77, 0x4F, 0x28, 0xA1, 0x8E, 0x36 + }, + { + 0x25, 0x03, 0x13, 0xFE, 0x7D, 0x5F, 0x1E, 0x1E, + 0x76, 0xA8, 0x6A, 0x9D, 0x05, 0x59, 0x5A, 0xAA, + 0xA5, 0x5B, 0xEE, 0xFF, 0x6B, 0x67, 0x09, 0xBE, + 0x0E, 0xBF, 0xCC, 0x59, 0xF5, 0xF2, 0xDD, 0xD0 + }, + { + 0x5E, 0x2C, 0xC2, 0x2D, 0x14, 0x5F, 0x5E, 0x75, + 0x8A, 0x6E, 0x52, 0x7A, 0xC3, 0xB9, 0x3A, 0xD1, + 0x5B, 0x53, 0x6F, 0xC0, 0xEE, 0xA3, 0x10, 0x46, + 0x08, 0xFE, 0x56, 0x64, 0x79, 0xDA, 0x0D, 0x3F + }, + { + 0x9B, 0x55, 0x21, 0x9E, 0xD2, 0x5D, 0xDC, 0xA9, + 0x6A, 0xC3, 0x26, 0x92, 0xAC, 0x2B, 0x37, 0x77, + 0x5E, 0x86, 0x7C, 0x3A, 0x31, 0x30, 0xCE, 0x4F, + 0xCE, 0xE3, 0x8F, 0x8B, 0xCB, 0xC2, 0xD5, 0xC4 + }, + { + 0xA8, 0x61, 0x80, 0xCB, 0x58, 0x54, 0x34, 0x8D, + 0x76, 0x73, 0xD4, 0x23, 0x5E, 0xBB, 0xD9, 0x36, + 0x3B, 0xE9, 0x8A, 0xED, 0xD0, 0x19, 0xF9, 0x99, + 0x5B, 0x58, 0x3E, 0xB5, 0x4F, 0xD8, 0x2A, 0x49 + }, + { + 0x95, 0x81, 0x0C, 0x46, 0x6B, 0x82, 0x83, 0x5F, + 0x71, 0x5B, 0xEC, 0xD1, 0x79, 0x7E, 0xFC, 0x2C, + 0x33, 0x91, 0xCF, 0x6E, 0xAC, 0x09, 0x93, 0x45, + 0x36, 0xD6, 0x47, 0x65, 0x98, 0x66, 0x65, 0x03 + }, + { + 0x76, 0xDC, 0x15, 0x1A, 0x9F, 0x1A, 0x2F, 0x51, + 0x46, 0xC7, 0x3C, 0x39, 0xAE, 0x96, 0x4B, 0x3A, + 0xBE, 0x93, 0xD1, 0x30, 0x95, 0x01, 0x17, 0x9E, + 0x3B, 0xA4, 0xF5, 0x12, 0x9C, 0xD6, 0xAA, 0xEC + }, + { + 0x06, 0x3F, 0x2F, 0x27, 0xC9, 0xCE, 0xEB, 0x67, + 0x20, 0x64, 0x4F, 0x34, 0xDB, 0xB9, 0x19, 0x1B, + 0x71, 0x52, 0x74, 0x9C, 0x9F, 0xB3, 0x01, 0x23, + 0x84, 0x91, 0xE9, 0x7E, 0x93, 0x0A, 0x11, 0x3A + }, + { + 0x7E, 0x49, 0x6D, 0x8A, 0xC3, 0xF5, 0x90, 0xE2, + 0x1B, 0x87, 0xDE, 0xF5, 0x2A, 0x14, 0xCA, 0x6A, + 0xE7, 0x53, 0x07, 0x97, 0x32, 0x62, 0xD8, 0xE1, + 0xF0, 0x4E, 0xF9, 0xF6, 0x21, 0xB7, 0xE3, 0xB0 + }, + { + 0x37, 0xC4, 0xBA, 0xB3, 0x05, 0x87, 0x19, 0xFF, + 0xC2, 0xF6, 0xF3, 0x2A, 0x22, 0x31, 0xF7, 0x01, + 0x4E, 0xF5, 0xAB, 0x9D, 0xCE, 0x27, 0xDA, 0x52, + 0x15, 0xE4, 0x0D, 0x71, 0x2F, 0x1F, 0x0C, 0x87 + }, + { + 0x69, 0x74, 0x6E, 0x20, 0xF3, 0xD2, 0x56, 0x1C, + 0x22, 0x6C, 0x64, 0xB9, 0x35, 0x2D, 0xCE, 0x24, + 0xC5, 0xA9, 0x5E, 0x96, 0xE5, 0xBB, 0xE8, 0xA3, + 0x2A, 0xE8, 0xB3, 0x62, 0x8D, 0x99, 0x93, 0x22 + }, + { + 0xEF, 0x0D, 0x84, 0x67, 0x05, 0x8D, 0xDF, 0x79, + 0x86, 0x1B, 0x27, 0xBC, 0xDD, 0xE6, 0x88, 0xC7, + 0x06, 0xE4, 0xEF, 0x65, 0xE0, 0xB5, 0xF5, 0xE4, + 0xB7, 0x06, 0x80, 0x4F, 0x7C, 0xFC, 0x9B, 0xA2 + }, + { + 0xB4, 0x31, 0x4C, 0x5B, 0xBF, 0xBA, 0xF6, 0xFE, + 0x47, 0x19, 0x55, 0x99, 0x89, 0x8E, 0xE1, 0xAB, + 0xB9, 0x27, 0xD9, 0x02, 0x5E, 0xBA, 0x57, 0xE3, + 0x2C, 0x4E, 0x2F, 0xA1, 0x40, 0x96, 0x27, 0x5E + }, + { + 0xD3, 0x12, 0x7E, 0xA0, 0x3A, 0x91, 0x7E, 0x5A, + 0x38, 0x6C, 0x58, 0x5D, 0x7C, 0x87, 0xC8, 0x93, + 0x5C, 0xE0, 0x2F, 0xAA, 0xA9, 0x9A, 0x4E, 0x91, + 0xB8, 0x7D, 0xD9, 0x37, 0x63, 0x70, 0x06, 0x16 + }, + { + 0xE8, 0x2C, 0x2E, 0x01, 0xD2, 0x5F, 0xD0, 0xAB, + 0x6C, 0xA4, 0x69, 0x78, 0xF0, 0x07, 0x42, 0x6D, + 0xE3, 0x3D, 0xC8, 0x80, 0x7C, 0x83, 0xEF, 0x68, + 0xC0, 0x08, 0xB5, 0xC6, 0x78, 0x61, 0x9A, 0xFB + }, + { + 0xA2, 0x31, 0x7B, 0x9A, 0x18, 0xCC, 0x5A, 0x27, + 0x76, 0xB7, 0x00, 0x82, 0x09, 0x15, 0x4A, 0x4A, + 0x34, 0x1F, 0x24, 0x3F, 0x9C, 0x19, 0x26, 0x63, + 0x05, 0xD5, 0xF6, 0x32, 0xAA, 0x63, 0x76, 0xBC + }, + { + 0x88, 0xA2, 0x3E, 0xD8, 0x93, 0x40, 0x20, 0x98, + 0x53, 0xF7, 0x09, 0x2E, 0xF8, 0xC8, 0xB4, 0x4D, + 0x66, 0xD3, 0xAF, 0xEC, 0x6F, 0xB9, 0x3A, 0x4F, + 0x0C, 0xE9, 0x81, 0x8A, 0xAE, 0x19, 0xC6, 0x50 + }, + { + 0x5A, 0xCC, 0x13, 0x49, 0x41, 0xCD, 0xBA, 0x1E, + 0xE9, 0xD1, 0x03, 0x0A, 0xEF, 0x6D, 0x48, 0x2B, + 0xB9, 0xBF, 0xC1, 0x72, 0x5B, 0x3E, 0x9D, 0xA8, + 0x2E, 0xB9, 0xBA, 0xCB, 0x3C, 0xFF, 0x93, 0x57 + }, + { + 0x7C, 0xD2, 0x54, 0x9B, 0x86, 0x6C, 0x5F, 0xD9, + 0x2B, 0x3D, 0xC8, 0x32, 0x4D, 0x92, 0xDC, 0x8B, + 0x3A, 0x0B, 0x14, 0x75, 0x5C, 0x40, 0xF0, 0xB0, + 0x4A, 0x55, 0xC3, 0xE0, 0xE5, 0xC0, 0x98, 0x07 + }, + { + 0x73, 0x04, 0xEB, 0x90, 0x4D, 0x69, 0x3F, 0xFF, + 0x69, 0x96, 0x66, 0x5B, 0x50, 0x99, 0xFC, 0x28, + 0xF3, 0x2C, 0xAC, 0x63, 0x8E, 0x01, 0x7F, 0x9B, + 0x6E, 0xA9, 0x15, 0x48, 0xD0, 0xF1, 0xEC, 0x25 + }, + { + 0xAB, 0x8A, 0x09, 0xC4, 0x8D, 0x85, 0xF3, 0x15, + 0xBA, 0xE5, 0xA9, 0x9E, 0x80, 0xA0, 0xDD, 0x15, + 0x94, 0x07, 0x6F, 0xE7, 0x97, 0xBA, 0x22, 0x18, + 0x06, 0xF5, 0x11, 0x05, 0x72, 0xD0, 0x7E, 0xB5 + }, + { + 0x60, 0xA2, 0x92, 0x0D, 0xB9, 0xAF, 0x60, 0x80, + 0xD4, 0x93, 0xDE, 0x58, 0xDB, 0xC6, 0xB8, 0x12, + 0x19, 0x14, 0x86, 0x06, 0x43, 0xE9, 0x3F, 0x3D, + 0x8A, 0x7F, 0x52, 0xA4, 0xC0, 0x85, 0x2B, 0xDE + }, + { + 0xD4, 0x6F, 0xCC, 0xB8, 0x7F, 0xBF, 0x56, 0xA7, + 0x4A, 0xED, 0xF9, 0x7A, 0x98, 0x51, 0xEE, 0x41, + 0xB8, 0x0E, 0x55, 0xB8, 0xAC, 0x4C, 0x2C, 0x7D, + 0x2C, 0xA4, 0xEA, 0x7E, 0xCF, 0x6F, 0x4C, 0x06 + }, + { + 0x8B, 0x55, 0xAA, 0x2A, 0xF2, 0x16, 0xE7, 0xBB, + 0x65, 0x64, 0xB1, 0xB7, 0x16, 0x30, 0xAB, 0x24, + 0x15, 0x35, 0xC0, 0x6C, 0x65, 0xF4, 0x7C, 0x06, + 0xDA, 0x1F, 0x2E, 0x83, 0x03, 0x9B, 0x38, 0x4A + }, + { + 0xBC, 0xD9, 0x1B, 0xB5, 0x49, 0xF2, 0xE2, 0xDB, + 0xBE, 0x9A, 0xC5, 0xE3, 0x8F, 0x51, 0x0C, 0xA4, + 0xCB, 0x5A, 0x09, 0xD8, 0xA5, 0xBB, 0xA7, 0x43, + 0x8B, 0xE4, 0x58, 0xF0, 0x47, 0xFE, 0x53, 0x1C + }, + { + 0xFC, 0xCF, 0xA5, 0xF1, 0x21, 0xEA, 0xAE, 0xDC, + 0xDE, 0x8C, 0x9B, 0xDA, 0x85, 0xEC, 0x0B, 0x23, + 0x78, 0xC9, 0x2B, 0x82, 0x17, 0xEE, 0x2F, 0x68, + 0x21, 0x14, 0xBA, 0x1F, 0xDB, 0x51, 0x91, 0xA5 + }, + { + 0x14, 0xE2, 0x20, 0x10, 0x69, 0xD7, 0xEC, 0x4C, + 0x6C, 0x85, 0xDC, 0xA0, 0x78, 0x9C, 0x44, 0x74, + 0xF4, 0xBB, 0x17, 0x07, 0x42, 0xED, 0xE3, 0x6B, + 0x7B, 0x21, 0x9E, 0x00, 0x4F, 0x11, 0x5B, 0x69 + }, + { + 0xB2, 0x4D, 0x76, 0x86, 0x00, 0xAF, 0x73, 0xB0, + 0x54, 0x03, 0xB4, 0xD8, 0x13, 0x21, 0x72, 0x1F, + 0xEC, 0xEC, 0x07, 0x7B, 0x30, 0x1E, 0x62, 0x72, + 0x3F, 0x94, 0x9A, 0x20, 0xBA, 0xAD, 0xE2, 0x25 + }, + { + 0xBA, 0x70, 0xB6, 0x2B, 0xDA, 0x17, 0x83, 0x8F, + 0x7C, 0x65, 0xD2, 0x67, 0x6F, 0x90, 0x08, 0x5A, + 0xB5, 0x55, 0x81, 0xB3, 0x8E, 0xAE, 0xC7, 0x2D, + 0x98, 0xBA, 0x80, 0x7B, 0x85, 0xFB, 0x2D, 0xAD + }, + { + 0x95, 0xF2, 0xE5, 0x67, 0xB6, 0x37, 0x53, 0x6E, + 0xC9, 0x1B, 0xC5, 0xDF, 0x06, 0x5E, 0x2A, 0xEB, + 0xD2, 0x5A, 0xC0, 0x25, 0x09, 0x19, 0xF7, 0x46, + 0x1F, 0x46, 0x81, 0xDC, 0x91, 0xD3, 0x94, 0xFE + }, + { + 0x9A, 0x16, 0x46, 0x6B, 0x2D, 0x1F, 0x27, 0x1D, + 0x51, 0xE0, 0x9E, 0x1E, 0xE7, 0x8B, 0xFD, 0x82, + 0x6D, 0x17, 0xE4, 0x3D, 0xBC, 0x9B, 0xFF, 0xC6, + 0x41, 0xB5, 0x67, 0xA7, 0xB7, 0x6A, 0x12, 0x0D + }, + { + 0xAD, 0x72, 0x06, 0x1C, 0x22, 0x00, 0xEB, 0xA5, + 0x87, 0x62, 0xFA, 0x7F, 0xE9, 0xDE, 0xA9, 0x42, + 0xCE, 0x96, 0x9D, 0xCF, 0x1A, 0x86, 0xE1, 0xC6, + 0x9A, 0x03, 0x91, 0x54, 0x47, 0x5E, 0x4C, 0x74 + }, + { + 0x87, 0x89, 0x9B, 0xCF, 0xC4, 0x09, 0xD2, 0x6B, + 0x43, 0xD3, 0x50, 0x2F, 0xC4, 0x07, 0x50, 0xFD, + 0x3D, 0xB6, 0x8B, 0x95, 0x55, 0xA9, 0x0B, 0xFC, + 0x88, 0xA7, 0x01, 0x19, 0xB5, 0x6B, 0xD5, 0x17 + }, + { + 0xC3, 0x76, 0xEE, 0x01, 0x2F, 0x8B, 0x19, 0x98, + 0x9C, 0x14, 0x1A, 0xD5, 0x26, 0xBD, 0xB3, 0x46, + 0x57, 0xE1, 0x93, 0x75, 0x6A, 0x79, 0x24, 0xD8, + 0x40, 0x86, 0x05, 0x6E, 0xF1, 0xA7, 0xC6, 0xEE + }, + { + 0x8F, 0xF6, 0x27, 0xD8, 0xC2, 0x10, 0x15, 0x40, + 0xF1, 0x25, 0x20, 0x78, 0x70, 0x3A, 0x5E, 0x16, + 0x09, 0x13, 0x1B, 0xF8, 0x10, 0x36, 0x46, 0x91, + 0x06, 0xD0, 0x14, 0x26, 0x17, 0x33, 0x20, 0x60 + }, + { + 0x89, 0x2B, 0xB9, 0x24, 0x82, 0x31, 0xC7, 0x6F, + 0x0B, 0x7E, 0x60, 0xDC, 0x09, 0x3B, 0x92, 0x64, + 0xCE, 0xF1, 0x5A, 0xBB, 0xD3, 0x5A, 0x4C, 0x8A, + 0x68, 0x05, 0x51, 0x5F, 0x78, 0x54, 0xE3, 0x2A + }, + { + 0x7F, 0x48, 0xE2, 0xD7, 0x21, 0xAC, 0x13, 0x8E, + 0x99, 0x0E, 0xC2, 0x92, 0x96, 0x7A, 0xFE, 0xB9, + 0x25, 0xD0, 0x5C, 0x44, 0x01, 0x84, 0x28, 0x10, + 0xD2, 0xAC, 0x93, 0xC4, 0x85, 0xAC, 0x54, 0xA9 + }, + { + 0x4F, 0x65, 0x95, 0xB0, 0x41, 0xBD, 0x30, 0x39, + 0xF7, 0x69, 0x83, 0x16, 0xF9, 0xCE, 0xC8, 0x49, + 0xD2, 0x15, 0xA6, 0x51, 0xD2, 0xFD, 0x12, 0xD6, + 0xDA, 0x05, 0x45, 0xF6, 0xBB, 0xBF, 0x33, 0x7F + }, + { + 0x1E, 0x48, 0x53, 0xCB, 0x0B, 0x20, 0x09, 0xCB, + 0x01, 0xC1, 0x0C, 0x72, 0x02, 0xEA, 0x6D, 0x1E, + 0x07, 0xA7, 0xB9, 0x6F, 0x89, 0xF8, 0xBC, 0xD3, + 0x1F, 0x8B, 0x25, 0xC3, 0x0D, 0x17, 0xAB, 0x05 + }, + { + 0x30, 0x12, 0xCA, 0x4B, 0x32, 0xFF, 0x3B, 0x47, + 0xD7, 0x1F, 0x77, 0xD2, 0x3B, 0x3B, 0x9E, 0xF9, + 0xA1, 0x53, 0x26, 0x38, 0x8B, 0xBF, 0xD6, 0xDE, + 0xFF, 0xAF, 0xDC, 0x53, 0x6C, 0xE7, 0xAB, 0xCC + }, + { + 0xDD, 0xAF, 0x6B, 0x6F, 0x6E, 0x76, 0x45, 0x95, + 0xE6, 0xFB, 0xE6, 0x0C, 0xD8, 0xE1, 0xCD, 0xB5, + 0xA2, 0x6D, 0x67, 0xB2, 0x54, 0xD1, 0x47, 0xD6, + 0x76, 0xD2, 0x56, 0x72, 0x50, 0xA7, 0x14, 0x49 + }, + { + 0xC5, 0x79, 0x78, 0x93, 0x60, 0x54, 0xC6, 0xAD, + 0xB1, 0xA7, 0xBC, 0x29, 0x45, 0x44, 0x65, 0x69, + 0xEE, 0xD3, 0x51, 0x74, 0x13, 0x15, 0xC0, 0x50, + 0x5B, 0x12, 0x5F, 0x03, 0x7A, 0x4D, 0xFA, 0x19 + }, + { + 0x86, 0xFF, 0x47, 0xEF, 0x70, 0xD3, 0x26, 0xC9, + 0xDA, 0x39, 0x06, 0x62, 0x12, 0x4E, 0xA4, 0x8A, + 0x05, 0xE2, 0x11, 0x84, 0xBB, 0x1B, 0xA7, 0x47, + 0x83, 0xF8, 0x2A, 0x16, 0xCE, 0x00, 0x92, 0x53 + }, + { + 0xD1, 0x39, 0x26, 0x08, 0x63, 0xDA, 0x10, 0xD1, + 0x15, 0xE2, 0xF6, 0x66, 0x35, 0xB5, 0x30, 0x10, + 0x46, 0xA6, 0x71, 0x9B, 0xDD, 0x1B, 0x48, 0xCE, + 0xA8, 0xEB, 0x4D, 0x98, 0x34, 0x29, 0x4F, 0xB3 + }, + { + 0x94, 0x55, 0xF4, 0xB6, 0x64, 0x43, 0x66, 0x03, + 0x39, 0x10, 0xC6, 0x3B, 0x84, 0x62, 0x08, 0x6A, + 0x36, 0xFC, 0x01, 0x62, 0x0F, 0x3B, 0xD6, 0xA2, + 0xAC, 0xBD, 0x8E, 0x08, 0x25, 0x80, 0x5D, 0xC1 + }, + { + 0x78, 0xB9, 0x43, 0x43, 0xB3, 0xD7, 0xA7, 0x86, + 0xA5, 0x30, 0x38, 0x2C, 0x47, 0x2A, 0x6B, 0x75, + 0x98, 0x93, 0x7E, 0x25, 0xEF, 0x2C, 0x16, 0xAB, + 0xCA, 0xA1, 0xC2, 0x58, 0xE4, 0x07, 0x0A, 0x98 + }, + { + 0x21, 0x7D, 0x87, 0x88, 0x47, 0x52, 0x0F, 0x65, + 0xD0, 0xC6, 0x1E, 0xEC, 0x67, 0x6E, 0x1A, 0x7D, + 0x47, 0x32, 0xAA, 0x8B, 0x97, 0xB8, 0x0B, 0xF5, + 0x11, 0x0E, 0x49, 0x54, 0xD8, 0xBA, 0x9A, 0x03 + }, + { + 0x33, 0xE3, 0x0F, 0x50, 0xA5, 0xA2, 0x0B, 0x11, + 0xF1, 0x3E, 0xCF, 0xBC, 0xA9, 0xBF, 0x33, 0xF3, + 0xD4, 0x37, 0x80, 0xB1, 0x8F, 0xB8, 0x13, 0xCF, + 0x47, 0xCF, 0x32, 0x14, 0xEE, 0xD3, 0x68, 0xE3 + }, + { + 0x7F, 0xCE, 0x78, 0x61, 0x14, 0x27, 0x30, 0xBB, + 0x62, 0xF6, 0xED, 0x4E, 0xD1, 0x39, 0x5B, 0x70, + 0x6B, 0xB4, 0xFE, 0x56, 0xEF, 0xAC, 0xC1, 0x97, + 0xD5, 0xC9, 0xCB, 0xB8, 0xF6, 0xE4, 0xF0, 0x7C + }, + { + 0x92, 0xE6, 0x95, 0x2C, 0x80, 0x54, 0x31, 0x43, + 0x8F, 0x20, 0x22, 0xFF, 0xB9, 0x53, 0x27, 0x97, + 0x43, 0x96, 0x07, 0x35, 0x1A, 0xCF, 0xBE, 0x2F, + 0xE2, 0xE2, 0x6E, 0xF7, 0xF0, 0x45, 0x06, 0x8E + }, + { + 0x2E, 0xBA, 0x7A, 0xA5, 0x89, 0x02, 0x9D, 0x72, + 0x5F, 0x3E, 0x73, 0x32, 0x99, 0xCA, 0x09, 0x17, + 0xA0, 0x26, 0x58, 0xF7, 0x39, 0xD0, 0xD4, 0x43, + 0x51, 0x1B, 0xED, 0x60, 0x1A, 0x30, 0xD6, 0x60 + }, + { + 0xFE, 0x63, 0x23, 0xF4, 0xA9, 0xA2, 0x63, 0x89, + 0x89, 0x68, 0x88, 0x44, 0xFB, 0x0F, 0x38, 0x7D, + 0x98, 0x14, 0xEC, 0x28, 0x05, 0xCB, 0xD5, 0x80, + 0x9F, 0xF0, 0x30, 0x58, 0xDD, 0x7A, 0xBF, 0x4F + }, + { + 0x47, 0xEF, 0x06, 0x04, 0x01, 0x47, 0x8F, 0x6F, + 0x27, 0x68, 0xDB, 0xCB, 0x58, 0x24, 0x2D, 0xB5, + 0x1B, 0xF2, 0x80, 0xA3, 0x95, 0x87, 0x33, 0x8A, + 0x19, 0x03, 0x8D, 0x5F, 0x6D, 0x5F, 0x9A, 0x40 + }, + { + 0xA1, 0x1E, 0xB9, 0xDC, 0x03, 0x7C, 0x3C, 0x27, + 0x78, 0xE7, 0xF0, 0x62, 0xCB, 0x28, 0x46, 0xCC, + 0x39, 0x2B, 0x16, 0x60, 0xD3, 0xFF, 0x96, 0xA2, + 0xF7, 0x58, 0x4A, 0x2D, 0x89, 0xB5, 0x49, 0xA9 + }, + { + 0x3B, 0x82, 0x25, 0x95, 0xAD, 0x57, 0x2F, 0x13, + 0x57, 0x91, 0x7A, 0x5B, 0xCC, 0x43, 0xC9, 0x2F, + 0x1C, 0x34, 0x3F, 0x46, 0x67, 0x31, 0x03, 0xBD, + 0x50, 0x71, 0x11, 0x9C, 0xC3, 0xF6, 0x49, 0xB8 + }, + { + 0x8A, 0x98, 0x14, 0x81, 0xEF, 0xC1, 0x23, 0xAA, + 0x47, 0x69, 0x27, 0x87, 0x89, 0x97, 0xC4, 0x28, + 0x23, 0xFC, 0x9A, 0x10, 0x78, 0xDA, 0x26, 0x74, + 0x1C, 0x32, 0x11, 0x16, 0x6E, 0x2B, 0x37, 0xD8 + }, + { + 0xAB, 0xB8, 0xA2, 0x0F, 0xAE, 0xB3, 0x13, 0xB3, + 0xA0, 0xBF, 0xD9, 0x00, 0x4B, 0x06, 0x42, 0x49, + 0x79, 0xC5, 0x82, 0x2A, 0x94, 0x59, 0xAD, 0x33, + 0x5C, 0xF8, 0xE9, 0x2A, 0xCF, 0x38, 0x2D, 0x88 + }, + { + 0xBD, 0x2E, 0xED, 0xF4, 0x0B, 0xC1, 0x42, 0xD3, + 0xC3, 0x94, 0x51, 0x6D, 0xF7, 0xBA, 0x17, 0x6F, + 0x68, 0x67, 0xD4, 0x15, 0x05, 0x50, 0x58, 0x32, + 0x85, 0x9A, 0xBE, 0x90, 0x54, 0x95, 0xAC, 0x7F + }, + { + 0x71, 0xEF, 0xFD, 0x48, 0x93, 0xD3, 0x4F, 0xAF, + 0x60, 0xA8, 0xF6, 0xFE, 0xBE, 0x71, 0x99, 0x53, + 0x30, 0xEA, 0x92, 0x46, 0x7D, 0x55, 0x0D, 0x85, + 0xDA, 0x4D, 0x70, 0x5F, 0x7D, 0x1F, 0x90, 0xA3 + }, + { + 0xA9, 0x6A, 0x92, 0x59, 0x95, 0x91, 0xBD, 0x97, + 0x6E, 0xD0, 0xAF, 0x62, 0x8F, 0x34, 0xA9, 0x10, + 0x1A, 0x6F, 0x40, 0xA1, 0x4B, 0x25, 0x1D, 0x86, + 0xF4, 0x90, 0xC1, 0x89, 0xE2, 0xC0, 0x48, 0x6E + }, + { + 0x99, 0xEE, 0x97, 0x58, 0x2E, 0x3B, 0x05, 0xB5, + 0x26, 0x6F, 0xC5, 0x60, 0x55, 0x7A, 0x17, 0x66, + 0x19, 0xAD, 0xC7, 0xE7, 0x9D, 0x9E, 0xF7, 0xFB, + 0x30, 0x72, 0xA2, 0xB5, 0x21, 0x9F, 0x2F, 0x0C + }, + { + 0xBB, 0x94, 0xC3, 0xC9, 0x59, 0x12, 0xF4, 0xD3, + 0xF2, 0xEC, 0x4F, 0x11, 0xEC, 0xBA, 0xF0, 0x51, + 0x7A, 0x3B, 0x67, 0xDF, 0xDD, 0xD5, 0x19, 0x6C, + 0xA7, 0xC5, 0xB6, 0xD1, 0x31, 0xEC, 0x15, 0x8D + }, + { + 0xB0, 0x10, 0xA3, 0xED, 0x30, 0x58, 0x95, 0x13, + 0xCE, 0xF9, 0x30, 0x1B, 0xDC, 0x2A, 0x0C, 0x84, + 0x14, 0xFC, 0xAF, 0x53, 0x19, 0x5D, 0xA4, 0x6C, + 0x94, 0x8A, 0x40, 0xE0, 0xBD, 0x27, 0x35, 0xEF + }, + { + 0xDF, 0xCA, 0x9B, 0xEA, 0x77, 0x9D, 0x8C, 0x1C, + 0x04, 0x98, 0x32, 0x1E, 0x14, 0x48, 0xCF, 0x66, + 0x3C, 0x9B, 0x94, 0x89, 0xF8, 0xB1, 0x06, 0x48, + 0x02, 0x12, 0x1C, 0xA5, 0x75, 0xFE, 0x29, 0x5B + }, + { + 0xEC, 0x45, 0xF6, 0x22, 0xE0, 0x96, 0x46, 0x4C, + 0x1F, 0xFF, 0x73, 0x19, 0x5B, 0xB4, 0x15, 0x23, + 0x93, 0xF6, 0xFB, 0xDE, 0x36, 0x95, 0xF4, 0xC3, + 0x9C, 0xFF, 0x8D, 0xEF, 0xEA, 0x80, 0x78, 0x6F + }, + { + 0x23, 0xE8, 0xD0, 0x66, 0x67, 0x13, 0x03, 0xE9, + 0x9E, 0x5C, 0x43, 0xD2, 0x9D, 0x2A, 0xF6, 0x70, + 0x7E, 0x11, 0xFF, 0xAC, 0x70, 0x89, 0xB7, 0x4A, + 0x64, 0xE2, 0x78, 0xB2, 0xB0, 0xEE, 0x73, 0xDD + }, + { + 0x15, 0x66, 0x14, 0x39, 0xA3, 0xB2, 0x97, 0xD6, + 0x78, 0xC3, 0xDD, 0xF9, 0xD8, 0x25, 0xAE, 0xE9, + 0x97, 0xCB, 0xE7, 0x6F, 0xED, 0xD8, 0x6C, 0xA1, + 0x66, 0x4E, 0x97, 0x2D, 0x40, 0x47, 0x9B, 0xA5 + }, + { + 0x5C, 0x76, 0xF0, 0x98, 0xF2, 0x06, 0xE5, 0x39, + 0x88, 0x85, 0xB2, 0x0C, 0x42, 0xFF, 0x19, 0x03, + 0xFC, 0xEF, 0xFA, 0xFA, 0x7F, 0x76, 0x39, 0xDB, + 0xF2, 0x02, 0x30, 0xDB, 0xA4, 0xF9, 0xDF, 0x82 + }, + { + 0xF7, 0x78, 0x84, 0xED, 0xBC, 0xE9, 0x39, 0xF4, + 0x80, 0x72, 0x56, 0xC2, 0xA3, 0x79, 0x45, 0x02, + 0x1D, 0xA5, 0x49, 0x6B, 0x5B, 0x43, 0xC5, 0xAA, + 0x3B, 0xB9, 0x89, 0x6F, 0x57, 0x88, 0x51, 0x14 + }, + { + 0x8F, 0xBE, 0x42, 0xF9, 0xD0, 0xB4, 0xCF, 0x23, + 0x8C, 0xBC, 0xAA, 0x93, 0x63, 0xFD, 0x8C, 0x17, + 0xB7, 0xCD, 0xF9, 0x56, 0x7D, 0xDA, 0xC7, 0x49, + 0x39, 0x1F, 0x02, 0xC7, 0xB1, 0xE9, 0x75, 0xD8 + }, + { + 0x28, 0xE8, 0xDC, 0x38, 0x41, 0x36, 0x5F, 0x7A, + 0x67, 0x1D, 0xBC, 0x7B, 0x52, 0xF1, 0x38, 0xAF, + 0x54, 0x6B, 0xA7, 0x4D, 0x24, 0x00, 0x94, 0xB9, + 0xE1, 0x50, 0x65, 0x78, 0x9A, 0xD2, 0x08, 0xB5 + }, + { + 0x0E, 0x2B, 0xE1, 0x0C, 0x4D, 0x1C, 0x92, 0xA2, + 0xA5, 0xFE, 0x79, 0xE8, 0x8C, 0x67, 0x87, 0xED, + 0x2F, 0xBA, 0x2D, 0xAA, 0x65, 0x84, 0xB6, 0x99, + 0xDB, 0xA1, 0xD4, 0x16, 0xFA, 0x07, 0x15, 0x16 + }, + { + 0x4A, 0xE4, 0xCB, 0xFD, 0x24, 0x9A, 0xD3, 0x0C, + 0xD8, 0x72, 0xEA, 0x76, 0xC0, 0xF6, 0xC5, 0xB5, + 0xE4, 0x8D, 0x2B, 0x1B, 0x64, 0x23, 0xAF, 0xE6, + 0x77, 0x02, 0xA3, 0x04, 0x3E, 0x15, 0x63, 0x4A + }, + { + 0x91, 0x9E, 0x75, 0xCE, 0x42, 0xBC, 0x3D, 0xB6, + 0x2F, 0x72, 0x65, 0x3C, 0x62, 0x2D, 0xC3, 0xC9, + 0x54, 0x9E, 0x79, 0x8B, 0xF7, 0xC9, 0x85, 0x2E, + 0xC5, 0x9F, 0xE7, 0xFD, 0x42, 0x3B, 0x9D, 0x97 + }, + { + 0x67, 0x14, 0x01, 0x68, 0xD1, 0xEA, 0xCB, 0x76, + 0x8B, 0xB1, 0x36, 0x8D, 0xF2, 0xDB, 0x58, 0x4B, + 0xD4, 0x4F, 0x22, 0xB2, 0x48, 0x79, 0x2D, 0x02, + 0xEF, 0x48, 0xD8, 0x76, 0xD8, 0xDA, 0x1C, 0xB6 + }, + { + 0xE6, 0xF5, 0x87, 0xE7, 0x5F, 0x47, 0x24, 0xD2, + 0x3D, 0x95, 0x49, 0x8A, 0x2E, 0x1A, 0xB7, 0xB5, + 0xCC, 0xF5, 0xF9, 0x79, 0x1C, 0x28, 0x35, 0xDC, + 0x5B, 0xFB, 0x3D, 0x45, 0x33, 0xB1, 0x73, 0xFE + }, + { + 0xAB, 0xBB, 0xB2, 0x84, 0x5E, 0x19, 0x36, 0x47, + 0xD2, 0xFB, 0x77, 0xFD, 0x0C, 0x49, 0x88, 0xEB, + 0xDC, 0xD6, 0x78, 0x7E, 0xDE, 0x12, 0xB0, 0xB5, + 0x41, 0xCF, 0x85, 0xDA, 0x7F, 0xC5, 0xB1, 0xBD + }, + { + 0x9A, 0xFF, 0x02, 0x9F, 0x95, 0x83, 0xDF, 0xD2, + 0x16, 0x92, 0x69, 0xD2, 0xEA, 0x82, 0x58, 0x61, + 0xC1, 0xF3, 0x50, 0x58, 0xED, 0x05, 0x47, 0xCC, + 0x45, 0xB7, 0xFD, 0x66, 0x99, 0x2D, 0x67, 0xEC + }, + { + 0x6E, 0xBC, 0xFC, 0x8E, 0x05, 0xC7, 0xF2, 0x0D, + 0x5C, 0x4D, 0x11, 0x63, 0x8F, 0x09, 0x85, 0x5B, + 0x3D, 0x3A, 0x27, 0xA4, 0x88, 0x36, 0x0C, 0xBE, + 0x1E, 0x65, 0x3D, 0x98, 0xFF, 0xFB, 0x80, 0x77 + }, + { + 0x73, 0xC2, 0x69, 0x74, 0xD9, 0x82, 0xC6, 0x59, + 0x0B, 0xDC, 0xBE, 0x1B, 0xE6, 0x7E, 0x0C, 0x9F, + 0x3B, 0x98, 0x63, 0x94, 0x3C, 0x4D, 0xC9, 0xCB, + 0xC4, 0x12, 0xAF, 0x78, 0xBB, 0x48, 0x58, 0x0E + }, + { + 0x6B, 0x84, 0xE9, 0x91, 0xA3, 0x5F, 0xC8, 0x33, + 0x84, 0x92, 0x2D, 0x87, 0xC6, 0x00, 0xE3, 0xE2, + 0x83, 0x97, 0xF2, 0xD4, 0x04, 0x97, 0x53, 0xD3, + 0xB2, 0xB3, 0xCF, 0xA7, 0x64, 0x58, 0x86, 0xF9 + }, + { + 0x35, 0xBB, 0xB0, 0xA2, 0xE9, 0x59, 0xC7, 0xA3, + 0xF9, 0xB5, 0x93, 0xD9, 0x79, 0x66, 0xC4, 0x1C, + 0x38, 0x12, 0x67, 0x08, 0x1C, 0xC2, 0xDD, 0x2C, + 0xC8, 0xD1, 0x27, 0x97, 0xE2, 0x21, 0xB1, 0x3F + }, + { + 0xC0, 0xC2, 0x4A, 0x17, 0x34, 0x10, 0x04, 0xAB, + 0x8C, 0x88, 0x22, 0x28, 0xF0, 0x2D, 0x62, 0x57, + 0x9B, 0x38, 0xED, 0x3B, 0xFF, 0x78, 0x6E, 0x14, + 0x4F, 0x28, 0xCB, 0x25, 0x68, 0x75, 0xBE, 0x9B + }, + { + 0xB7, 0x24, 0x81, 0xA3, 0xF3, 0x83, 0xCB, 0x94, + 0xD6, 0x6C, 0x2B, 0x1D, 0xCA, 0xCB, 0x2F, 0x68, + 0x84, 0x9C, 0x49, 0xD0, 0xAC, 0xCC, 0xCB, 0xD2, + 0x6C, 0x41, 0x0A, 0x55, 0x0B, 0xE8, 0x77, 0x7A + }, + { + 0xE0, 0x15, 0xC2, 0x66, 0x26, 0x02, 0x4E, 0x74, + 0xAF, 0x87, 0x0E, 0xEC, 0xA1, 0x96, 0xD1, 0xF7, + 0x6C, 0x14, 0x05, 0xE6, 0xC9, 0xFC, 0x7C, 0xEA, + 0x67, 0x90, 0x52, 0x60, 0x1E, 0xC9, 0x07, 0xD4 + }, + { + 0xFD, 0x11, 0x1B, 0xF0, 0x6E, 0x3A, 0x0E, 0xBE, + 0x01, 0x05, 0xA0, 0xC9, 0xA8, 0x02, 0x82, 0xCD, + 0x38, 0xE7, 0x37, 0x09, 0x2F, 0xCD, 0x06, 0x22, + 0x4B, 0xF8, 0xB1, 0x7A, 0x25, 0x2B, 0x5A, 0x9A + }, + { + 0xBA, 0x52, 0x96, 0x6F, 0xA1, 0xE1, 0xD5, 0xB2, + 0x8C, 0xBF, 0x7A, 0x9E, 0x35, 0x98, 0x4F, 0xA3, + 0x0C, 0xC1, 0xE3, 0xF9, 0x0E, 0x23, 0xC7, 0xC6, + 0x11, 0x33, 0xF8, 0x94, 0x43, 0xB8, 0xD1, 0xA2 + }, + { + 0xA6, 0x21, 0x1F, 0xEB, 0xBA, 0x6B, 0x51, 0x34, + 0x91, 0x70, 0xE6, 0x24, 0xC4, 0x2C, 0x9E, 0x12, + 0x6A, 0x23, 0x67, 0xA8, 0x2E, 0xC7, 0x58, 0x60, + 0x82, 0xDA, 0x04, 0xD5, 0xFE, 0x71, 0xB1, 0xA5 + }, + { + 0x0A, 0xB4, 0x15, 0x8F, 0xAC, 0x8F, 0x36, 0x32, + 0x8E, 0x08, 0xB1, 0xE0, 0x1F, 0x9F, 0x4A, 0x30, + 0x72, 0xCF, 0xBC, 0x2D, 0x31, 0x7B, 0x58, 0x0A, + 0x68, 0x3D, 0xDB, 0x98, 0x8F, 0x47, 0xAB, 0x48 + }, + { + 0xF7, 0xCC, 0xF3, 0xED, 0xCA, 0xCE, 0xD0, 0xA6, + 0xDD, 0x2D, 0xAB, 0xF3, 0x49, 0x7C, 0x7E, 0x8A, + 0xCA, 0x0B, 0x31, 0xE9, 0xD5, 0xBB, 0x3B, 0x2E, + 0x8B, 0xF0, 0x6C, 0x7A, 0x32, 0x05, 0xDB, 0x0B + }, + { + 0xA7, 0x73, 0xF9, 0xE5, 0xB9, 0xA6, 0x65, 0x97, + 0x9E, 0x90, 0x58, 0x2E, 0x1D, 0xBA, 0xFA, 0x67, + 0x1A, 0xCF, 0x97, 0xD3, 0x91, 0x55, 0x1F, 0x64, + 0x82, 0xB6, 0x22, 0x4C, 0x61, 0x3A, 0x1C, 0xC3 + }, + { + 0x35, 0xBE, 0x12, 0x59, 0x5C, 0x76, 0xAB, 0x7B, + 0x03, 0x95, 0x13, 0xBE, 0x35, 0x8E, 0x55, 0xEF, + 0xA0, 0x8E, 0xBC, 0x20, 0xED, 0xA6, 0x06, 0xCC, + 0x25, 0xB3, 0x63, 0xB7, 0x07, 0xDD, 0x44, 0x12 + }, + { + 0xB4, 0xB0, 0xAB, 0x1D, 0xBF, 0xE7, 0x74, 0x90, + 0x9D, 0x8E, 0x7E, 0x93, 0xC2, 0xFA, 0xF7, 0x2F, + 0xA1, 0x35, 0x02, 0x9D, 0x82, 0xD3, 0xD5, 0xCE, + 0x35, 0x8F, 0xEC, 0xB0, 0x1E, 0x47, 0xA2, 0x82 + }, + { + 0x48, 0x7C, 0x3C, 0x0D, 0x8A, 0x3E, 0x29, 0xF5, + 0xE9, 0xAA, 0x4F, 0xDC, 0x73, 0x6C, 0x6C, 0x74, + 0x30, 0x05, 0x01, 0x5C, 0xC6, 0x01, 0xFA, 0xA9, + 0xAE, 0x69, 0x47, 0x58, 0x52, 0x5E, 0xB8, 0x42 + }, + { + 0x16, 0x83, 0x02, 0x32, 0x69, 0x85, 0x47, 0x84, + 0x92, 0x26, 0x59, 0xE1, 0x53, 0x92, 0x12, 0xAD, + 0x7C, 0xF4, 0x96, 0x50, 0x85, 0x90, 0x87, 0x08, + 0xBC, 0x9B, 0x08, 0xB5, 0xB1, 0x25, 0x89, 0x17 + }, + { + 0xA2, 0x69, 0xDB, 0xA9, 0xC6, 0x00, 0x57, 0xA9, + 0x85, 0x5E, 0x21, 0x4E, 0x8B, 0x1A, 0x04, 0x57, + 0x37, 0x94, 0x9A, 0xB2, 0x4C, 0xFA, 0x76, 0xD8, + 0xFB, 0x8E, 0xA2, 0x19, 0x1C, 0x48, 0x4C, 0x75 + }, + { + 0x52, 0xE2, 0x09, 0xF0, 0x9B, 0x49, 0x34, 0x0F, + 0xA1, 0xD0, 0x9E, 0x75, 0xF0, 0x2F, 0xF9, 0x05, + 0x96, 0xB6, 0x2A, 0x76, 0xDB, 0x2B, 0xCC, 0x46, + 0x27, 0xA2, 0x55, 0x55, 0x26, 0xD3, 0x52, 0xD9 + }, + { + 0xD2, 0x80, 0xBA, 0xA8, 0x95, 0xE2, 0x68, 0x82, + 0xC2, 0xD6, 0x1F, 0xBA, 0xE3, 0x1C, 0xE6, 0x85, + 0x3E, 0xF7, 0x8A, 0xD1, 0xB8, 0xDE, 0x51, 0x7C, + 0x03, 0x07, 0xA9, 0xA9, 0x25, 0x29, 0xE9, 0xBA + }, + { + 0x7B, 0x39, 0x60, 0xBC, 0x02, 0x56, 0xF4, 0xF6, + 0x81, 0x3F, 0x1C, 0xEC, 0xA3, 0xCA, 0x60, 0xFD, + 0xE8, 0x60, 0x3B, 0xDA, 0x33, 0x71, 0xED, 0x8D, + 0xBB, 0x3E, 0x56, 0x2D, 0x62, 0x69, 0x89, 0x99 + }, + { + 0x13, 0x21, 0xB2, 0x5F, 0xD5, 0xD9, 0x98, 0x59, + 0xED, 0x96, 0xF3, 0xA8, 0x3A, 0xBD, 0x86, 0x03, + 0xE6, 0xAC, 0x93, 0x91, 0x7E, 0x82, 0xEB, 0xF3, + 0x4D, 0xA4, 0xED, 0xC1, 0x68, 0x45, 0x8A, 0xAD + }, + { + 0x3E, 0x1F, 0x35, 0x12, 0xA1, 0xAF, 0x6D, 0xC2, + 0xB8, 0x9C, 0xAC, 0x5C, 0xB0, 0xAD, 0x9E, 0xEB, + 0x14, 0xB1, 0x90, 0x80, 0x08, 0x18, 0x91, 0xF4, + 0x23, 0xD6, 0x85, 0x3E, 0xF7, 0x41, 0x9B, 0x87 + }, + { + 0xEE, 0x3A, 0x70, 0xBF, 0x29, 0x9C, 0x98, 0xA2, + 0x00, 0x30, 0x8F, 0x3D, 0x88, 0x53, 0xED, 0xEB, + 0x25, 0xDC, 0x98, 0xB1, 0xE6, 0x45, 0xFE, 0xBD, + 0x03, 0x9E, 0xC1, 0xC2, 0x43, 0x57, 0x22, 0x03 + }, + { + 0xD4, 0x96, 0x1F, 0x4E, 0x69, 0x36, 0x08, 0xAA, + 0x77, 0x5C, 0xB1, 0x9F, 0x65, 0xA0, 0xA1, 0x77, + 0x51, 0x68, 0x9B, 0xDE, 0x60, 0x50, 0x02, 0x1E, + 0x29, 0x55, 0xC9, 0x7B, 0xCA, 0xC2, 0x6E, 0x9E + }, + { + 0x13, 0x54, 0x00, 0x41, 0x1A, 0x46, 0xFB, 0x72, + 0x01, 0x11, 0x73, 0xD2, 0x79, 0xE7, 0x84, 0x7C, + 0x49, 0x95, 0x72, 0x61, 0x26, 0x09, 0xAA, 0xDB, + 0x2E, 0x0F, 0xE0, 0xF4, 0x78, 0x9C, 0x53, 0x2A + }, + { + 0x16, 0xDA, 0xB4, 0xC4, 0xD7, 0x0B, 0xF8, 0xFC, + 0x1B, 0x5F, 0x15, 0x8B, 0xBF, 0xE9, 0x13, 0x04, + 0x31, 0xDF, 0x71, 0x00, 0x96, 0xBF, 0x3A, 0x4B, + 0xA0, 0x52, 0xA1, 0xB7, 0x35, 0xEB, 0x09, 0xE7 + }, + { + 0x08, 0xD4, 0x52, 0x5A, 0xB2, 0x70, 0x5F, 0x3F, + 0x44, 0xB0, 0x09, 0x94, 0xB1, 0xBB, 0xEB, 0x9E, + 0x87, 0x75, 0x07, 0x8A, 0x36, 0x9E, 0xB3, 0x1C, + 0xA3, 0xD9, 0xA1, 0x38, 0x6E, 0xD9, 0x21, 0x1E + }, + { + 0xE9, 0x62, 0x3B, 0x9A, 0x84, 0x68, 0x9E, 0x05, + 0x7A, 0xA1, 0xB5, 0xB4, 0x51, 0x1D, 0x52, 0x8A, + 0xF8, 0x58, 0x30, 0x9D, 0xF1, 0xBD, 0x01, 0x14, + 0x43, 0x4A, 0x8B, 0x3F, 0xDC, 0xDA, 0x01, 0xBC + }, + { + 0x35, 0xD3, 0x25, 0x08, 0xD3, 0xFC, 0xCB, 0xA8, + 0xB1, 0x01, 0x8C, 0xED, 0x48, 0x74, 0xD7, 0xE4, + 0x79, 0xE8, 0xB5, 0xB6, 0x89, 0x43, 0x4E, 0xD5, + 0x6C, 0xE4, 0xA4, 0xC7, 0x4E, 0x0B, 0xAF, 0x6D + }, + { + 0xA4, 0xF0, 0x8D, 0x65, 0x84, 0xF8, 0x6D, 0xC1, + 0x68, 0x61, 0x3D, 0x73, 0xA0, 0xD1, 0x00, 0xD4, + 0x42, 0x65, 0x34, 0x11, 0x65, 0x34, 0xC6, 0xF5, + 0xCD, 0x38, 0xFA, 0x60, 0xB9, 0x4C, 0x54, 0xD6 + }, + { + 0x0C, 0x9A, 0xE5, 0xB3, 0xAE, 0x95, 0x39, 0x73, + 0x07, 0xC6, 0x85, 0xDC, 0xD2, 0xDB, 0x40, 0x3B, + 0xBD, 0x80, 0xE3, 0x06, 0x5D, 0x7D, 0xF0, 0xAD, + 0x96, 0xF9, 0xC7, 0x8F, 0x5B, 0x39, 0xAC, 0xFF + }, + { + 0x8A, 0xDB, 0xC2, 0x5F, 0x9B, 0x14, 0xBF, 0x86, + 0xE4, 0x0B, 0xAC, 0x9E, 0x08, 0xC4, 0xA2, 0x6D, + 0x67, 0xF6, 0x60, 0x94, 0x0B, 0xD6, 0xFF, 0x0A, + 0xE1, 0x53, 0x09, 0x26, 0x8C, 0x3B, 0x1E, 0xD1 + }, + { + 0xDF, 0xD5, 0xCF, 0xBE, 0xB1, 0x3D, 0x99, 0xBD, + 0x13, 0x63, 0xF5, 0x2B, 0x56, 0x38, 0xF2, 0xA7, + 0xE3, 0x00, 0x5E, 0xD2, 0xBE, 0xE1, 0x3E, 0x23, + 0xDA, 0x37, 0xEA, 0xDC, 0xCC, 0xA3, 0xEC, 0x13 + }, + { + 0xAC, 0x45, 0xB8, 0x1B, 0xBA, 0xEE, 0xA9, 0xE6, + 0x37, 0x82, 0xC7, 0x90, 0x93, 0x4C, 0x94, 0xCF, + 0xBF, 0x65, 0xC0, 0x80, 0x4D, 0xDE, 0x82, 0x01, + 0x96, 0x96, 0xD3, 0x7D, 0x6B, 0xBF, 0x53, 0x44 + }, + { + 0xBC, 0x75, 0x6E, 0xC7, 0xC9, 0x5B, 0x07, 0x70, + 0xA2, 0x12, 0x94, 0xCE, 0x4C, 0x20, 0x4F, 0xD4, + 0x78, 0xB2, 0x01, 0x50, 0x59, 0x6D, 0x40, 0x9F, + 0xE8, 0x7D, 0x45, 0xB8, 0x3B, 0x25, 0x9C, 0x8C + }, + { + 0xBD, 0x99, 0x1E, 0xD6, 0xB0, 0xDE, 0xC3, 0xFB, + 0x44, 0x3A, 0x16, 0xE2, 0x2D, 0xDD, 0x2D, 0xD1, + 0xF4, 0x1A, 0x21, 0x83, 0x7C, 0x95, 0x45, 0x87, + 0x83, 0xF4, 0xC7, 0x6E, 0x70, 0x7D, 0x5A, 0x4D + }, + { + 0x67, 0x42, 0x13, 0x93, 0x8B, 0x26, 0xC4, 0x56, + 0x44, 0x54, 0x68, 0x1D, 0x00, 0xFA, 0xD8, 0x49, + 0x08, 0x58, 0x29, 0x25, 0x8E, 0xC9, 0x88, 0xF1, + 0xC5, 0xEB, 0xB6, 0xDC, 0x5A, 0x43, 0xA6, 0x63 + }, + { + 0x12, 0xB8, 0xE5, 0x17, 0x8F, 0x47, 0x1F, 0xA5, + 0x5E, 0x79, 0x03, 0x88, 0x96, 0x54, 0x68, 0x22, + 0x2F, 0xF6, 0x70, 0xBE, 0x77, 0x8A, 0x8A, 0x20, + 0x61, 0xD4, 0xC1, 0x25, 0xAF, 0x53, 0xA1, 0x6B + }, + { + 0x37, 0xAA, 0x77, 0xD7, 0x44, 0x40, 0x00, 0x41, + 0x05, 0x3B, 0x7C, 0x96, 0xA0, 0x36, 0x47, 0x35, + 0xB9, 0xAA, 0x90, 0xDD, 0x57, 0xDA, 0xFE, 0x5E, + 0xC8, 0x71, 0xC4, 0x8D, 0xDC, 0xE7, 0x18, 0x86 + }, + { + 0xD8, 0x40, 0x17, 0x68, 0x3B, 0x4C, 0x39, 0x7D, + 0xC1, 0x53, 0x95, 0xB2, 0xF5, 0xBB, 0x73, 0x87, + 0xC1, 0x2A, 0xD5, 0xFC, 0x1E, 0xC1, 0x02, 0x43, + 0x95, 0xB6, 0x40, 0xD8, 0x3E, 0x83, 0x00, 0x61 + }, + { + 0x1B, 0x0F, 0x5A, 0x5E, 0xAA, 0x9A, 0x69, 0x4D, + 0xF4, 0xA3, 0xC9, 0x68, 0x2F, 0x9B, 0x2C, 0xB6, + 0x4D, 0x14, 0xA6, 0xEB, 0x4B, 0x7E, 0xAC, 0xCB, + 0x23, 0x91, 0xC0, 0x9D, 0x08, 0x2F, 0xDC, 0xA8 + }, + { + 0xAC, 0xF2, 0x6A, 0xF6, 0xFE, 0xFC, 0x03, 0x2F, + 0x8B, 0xF1, 0x67, 0xC7, 0xFF, 0x7D, 0x5B, 0x82, + 0xF8, 0x68, 0x42, 0xF1, 0x0A, 0x69, 0x1D, 0xD0, + 0x60, 0x82, 0x97, 0xC9, 0xE2, 0xCA, 0x0F, 0xE0 + }, + { + 0x6B, 0x2A, 0x49, 0x88, 0x86, 0xC8, 0x1B, 0xEE, + 0x02, 0x5D, 0xCE, 0xEE, 0x3F, 0x82, 0xCF, 0x65, + 0x4F, 0xA4, 0x5C, 0x01, 0x02, 0x70, 0xB8, 0xC3, + 0x2E, 0x98, 0x2E, 0x9B, 0x26, 0xA0, 0xEB, 0x7C + }, + { + 0xDD, 0xE0, 0x94, 0xF8, 0xC0, 0x45, 0x4F, 0x65, + 0xED, 0x0A, 0x69, 0x7C, 0x20, 0xB5, 0x52, 0x66, + 0xE8, 0xDE, 0xA4, 0x1C, 0x02, 0x44, 0x2B, 0x91, + 0x64, 0x44, 0x43, 0xB3, 0x1B, 0x32, 0x9B, 0x1C + }, + { + 0x90, 0x6F, 0x85, 0x5A, 0xAB, 0xA2, 0x4A, 0x6F, + 0x67, 0x5D, 0xB9, 0x31, 0x8A, 0x54, 0xC6, 0x20, + 0x8C, 0x91, 0x95, 0xE7, 0x90, 0x30, 0x85, 0x11, + 0x87, 0x69, 0x10, 0xE1, 0xB7, 0x41, 0x10, 0xD4 + }, + { + 0xB4, 0x92, 0xD8, 0x97, 0x96, 0x22, 0xA6, 0x09, + 0x73, 0x50, 0xEE, 0xB9, 0xC9, 0xF3, 0xE3, 0xF1, + 0x67, 0x71, 0xC4, 0x8B, 0x74, 0xF4, 0x0A, 0x9B, + 0x81, 0x95, 0x56, 0xFD, 0xFD, 0x1A, 0x3B, 0x7D + }, + { + 0xB8, 0xC1, 0x3C, 0xFE, 0x4A, 0x52, 0xFB, 0x6E, + 0x2B, 0x55, 0x5A, 0x17, 0xE7, 0x0D, 0x79, 0x6A, + 0x1C, 0xB2, 0xF4, 0xC6, 0x4F, 0x0B, 0x3F, 0x05, + 0x18, 0xAB, 0xDD, 0x09, 0x39, 0xC9, 0x8A, 0x38 + }, + { + 0xBF, 0x52, 0x32, 0x06, 0x9A, 0x40, 0xCA, 0x68, + 0xA4, 0xC1, 0xEE, 0x39, 0x67, 0x43, 0x79, 0xAE, + 0xAB, 0x55, 0xAF, 0xDF, 0x53, 0x8C, 0x7B, 0x7F, + 0xA3, 0x2E, 0xB8, 0x7D, 0x4B, 0x55, 0xA7, 0xC8 + }, + { + 0x4A, 0x31, 0x24, 0x18, 0x6D, 0x85, 0xC5, 0x8A, + 0x99, 0x81, 0x77, 0x15, 0xD1, 0xB7, 0xAF, 0x67, + 0x83, 0x84, 0x58, 0x08, 0xC6, 0x51, 0xB7, 0xDD, + 0xC6, 0x97, 0xC2, 0x00, 0xE8, 0xDE, 0x6A, 0x5B + }, + { + 0xB4, 0x86, 0xE8, 0x03, 0x3C, 0x87, 0x7E, 0x6E, + 0xCA, 0xC8, 0x8A, 0xD2, 0x75, 0xFA, 0x25, 0x49, + 0xF7, 0x43, 0x4C, 0x0E, 0xF5, 0xF9, 0xDA, 0x07, + 0x6A, 0xBB, 0x56, 0x85, 0x7F, 0xD1, 0x14, 0x83 + }, + { + 0x9B, 0x1A, 0xA7, 0xDC, 0x51, 0x6E, 0x97, 0x45, + 0xF3, 0x9E, 0xC4, 0x0E, 0x5C, 0xAB, 0x25, 0x38, + 0x19, 0x0A, 0x66, 0x77, 0x92, 0x25, 0xBE, 0x46, + 0x61, 0x85, 0xB5, 0x20, 0x98, 0xD2, 0x50, 0x0F + }, + { + 0x84, 0x64, 0x57, 0x03, 0xD5, 0x5E, 0x48, 0x05, + 0x33, 0x7B, 0xF3, 0xB0, 0xB7, 0x22, 0xEA, 0x85, + 0xB1, 0xF9, 0xE8, 0x2A, 0x00, 0x71, 0xC2, 0x42, + 0xFB, 0x7A, 0xA9, 0x71, 0x6D, 0x1D, 0xEB, 0x0E + }, + { + 0xB5, 0x34, 0x4C, 0x4C, 0x62, 0x25, 0x39, 0x01, + 0xBE, 0x62, 0x47, 0x25, 0x64, 0x6A, 0x57, 0x9A, + 0x52, 0x92, 0xDC, 0x36, 0x61, 0x44, 0x69, 0x35, + 0x37, 0xCE, 0xC0, 0x69, 0x7F, 0x01, 0xF1, 0x9C + }, + { + 0x01, 0xFB, 0x51, 0x48, 0xE6, 0xFB, 0x89, 0x61, + 0x3A, 0xCD, 0x94, 0x61, 0xDC, 0x2E, 0x91, 0x7F, + 0x6D, 0xE6, 0xAE, 0xAD, 0x19, 0x73, 0x90, 0xC8, + 0x91, 0x32, 0x0D, 0x4F, 0x90, 0xF8, 0x85, 0x1C + }, + { + 0x43, 0x5E, 0x49, 0xA4, 0xC1, 0x54, 0xDE, 0xAC, + 0x37, 0x09, 0x0F, 0xB4, 0x4F, 0x05, 0x23, 0x87, + 0x21, 0x7D, 0xA0, 0x12, 0xFF, 0x17, 0xE7, 0x15, + 0x4D, 0x3D, 0x54, 0x74, 0x0B, 0x7D, 0xC2, 0xBB + }, + { + 0x7F, 0x49, 0x0B, 0xD0, 0xA7, 0x3A, 0x09, 0x7D, + 0x8F, 0xDB, 0x43, 0x5C, 0xE1, 0xEC, 0x89, 0x42, + 0xFA, 0x03, 0xBF, 0xB1, 0x55, 0x61, 0x8C, 0xE6, + 0xB0, 0x3B, 0x62, 0x1A, 0xA2, 0x4B, 0xAB, 0xAD + }, + { + 0x7A, 0x14, 0xCB, 0x50, 0x64, 0xD7, 0xFF, 0x4C, + 0xA5, 0x59, 0x60, 0x00, 0x89, 0x4E, 0xFB, 0xEF, + 0x29, 0x99, 0xD0, 0x05, 0x1C, 0x0F, 0x64, 0x5C, + 0xC3, 0xFC, 0x46, 0xD7, 0x17, 0x81, 0x05, 0x95 + }, + { + 0x71, 0xD4, 0x1C, 0x77, 0x7E, 0x58, 0xE7, 0x43, + 0x7A, 0x19, 0xEC, 0x1D, 0x79, 0xAA, 0xE1, 0xB8, + 0x0B, 0x8A, 0x3F, 0xE8, 0x09, 0xF4, 0xBB, 0x41, + 0xD3, 0xE5, 0xB8, 0xA0, 0x6C, 0x36, 0x12, 0x80 + }, + { + 0x01, 0xF2, 0x8B, 0xD6, 0xEB, 0x90, 0x83, 0xF3, + 0x99, 0x4B, 0x45, 0xD4, 0xA8, 0x13, 0x6B, 0x89, + 0xDE, 0x3B, 0x88, 0x10, 0x71, 0xDE, 0x75, 0xD9, + 0x0C, 0xBB, 0x4A, 0x03, 0x0E, 0x86, 0xC8, 0xE2 + }, + { + 0x60, 0x52, 0xD2, 0x65, 0x36, 0xFA, 0xDC, 0xD8, + 0x0A, 0xA7, 0xA3, 0xA6, 0x47, 0x1A, 0xBE, 0xF0, + 0x0F, 0x5E, 0x3B, 0xC4, 0x5A, 0x75, 0xBA, 0xC5, + 0x16, 0x0D, 0xA5, 0x08, 0x19, 0x16, 0xD0, 0x24 + }, + { + 0xB8, 0xAE, 0xB7, 0x5B, 0x2D, 0x7F, 0xD4, 0x0F, + 0x26, 0x83, 0x55, 0x8A, 0x0F, 0x8A, 0x8A, 0xF8, + 0x99, 0x2C, 0xC6, 0x97, 0x73, 0xB7, 0xE4, 0x40, + 0x5E, 0x85, 0x90, 0xAF, 0xAF, 0x81, 0xE8, 0xE7 + }, + { + 0x8C, 0x2E, 0xDB, 0x68, 0x5C, 0xAB, 0xEA, 0x2E, + 0xF0, 0xA3, 0xA1, 0xDD, 0x06, 0xA9, 0xE4, 0xD0, + 0x5F, 0x7C, 0x3B, 0xAA, 0xEF, 0x18, 0x43, 0x39, + 0xD1, 0xE6, 0x6E, 0xA3, 0x90, 0x59, 0x99, 0x0D + }, + { + 0xBD, 0xA8, 0x59, 0x4F, 0xAD, 0xF9, 0x3A, 0x04, + 0x26, 0x81, 0x85, 0x46, 0xF5, 0x96, 0x91, 0xDE, + 0xA0, 0xE5, 0xCC, 0xC7, 0xAE, 0x19, 0x0F, 0xC4, + 0xBD, 0x5F, 0x59, 0x24, 0x8A, 0xEF, 0x3E, 0x26 + }, + { + 0x99, 0xDE, 0x3A, 0xFB, 0xD8, 0x4A, 0x50, 0x9C, + 0xB6, 0xDA, 0x6F, 0x3A, 0x93, 0xDE, 0x93, 0x7D, + 0x44, 0x0C, 0x5D, 0x92, 0xC7, 0x61, 0x44, 0x73, + 0x6D, 0x9A, 0x4D, 0x67, 0x2A, 0x48, 0xAF, 0x24 + }, + { + 0x45, 0x12, 0xCE, 0xD4, 0xAB, 0x93, 0x4B, 0x3A, + 0x07, 0x45, 0x4B, 0xE0, 0x1E, 0x21, 0x40, 0xB5, + 0x7D, 0x29, 0xE0, 0xD9, 0x35, 0x37, 0x22, 0xD9, + 0xCB, 0x79, 0x20, 0x2C, 0x82, 0xD1, 0x43, 0x02 + }, + { + 0x49, 0x74, 0x96, 0x12, 0x6E, 0x2C, 0xC1, 0x49, + 0x5F, 0xB2, 0x64, 0x37, 0x30, 0x99, 0xD0, 0x65, + 0x6D, 0x9D, 0x03, 0xC9, 0xC0, 0x1A, 0x5B, 0x99, + 0xA3, 0x98, 0x27, 0xED, 0x88, 0x50, 0xAF, 0x22 + }, + { + 0xEE, 0x3B, 0x46, 0xE3, 0x5D, 0x60, 0xD4, 0xFA, + 0x2F, 0x35, 0x18, 0xFC, 0x45, 0x83, 0x43, 0xF0, + 0x0E, 0x0E, 0xB1, 0xEE, 0x73, 0xF8, 0xD0, 0xD7, + 0xE4, 0xFE, 0xCB, 0x0C, 0x61, 0xA3, 0x86, 0x8F + }, + { + 0x85, 0x43, 0xE5, 0xC8, 0x67, 0xC6, 0xBB, 0xBF, + 0x14, 0x52, 0x0B, 0x0B, 0x6C, 0x7D, 0xB9, 0x07, + 0xAD, 0x22, 0xE2, 0x6B, 0x0A, 0x4F, 0x8D, 0x49, + 0xEE, 0x8B, 0x1F, 0xF4, 0x7A, 0x71, 0x48, 0x08 + }, + { + 0x38, 0x33, 0x78, 0x9E, 0xC4, 0x04, 0x52, 0xE8, + 0xE1, 0x8C, 0xA3, 0x1C, 0x6F, 0xDF, 0x55, 0x05, + 0x17, 0xD4, 0x77, 0x17, 0x42, 0x26, 0xFE, 0xD5, + 0x52, 0x62, 0x62, 0xF7, 0x24, 0x97, 0xE6, 0xEF + }, + { + 0xFE, 0x8E, 0xFC, 0x3E, 0xF3, 0x0A, 0x15, 0x9D, + 0xE4, 0x90, 0xD1, 0x4F, 0xDA, 0x89, 0xA8, 0xDB, + 0x50, 0xB7, 0x67, 0x90, 0x8C, 0xC9, 0x7B, 0xB9, + 0x91, 0x5E, 0x3B, 0x11, 0x3E, 0xCC, 0x40, 0xEA + }, + { + 0xB4, 0x34, 0xE4, 0xAA, 0x6F, 0xC5, 0x5C, 0x59, + 0x8A, 0xD3, 0xA5, 0xA2, 0x28, 0x37, 0x30, 0xD4, + 0x7B, 0x5D, 0x2B, 0x4F, 0x14, 0x9F, 0x1E, 0x54, + 0xE4, 0x62, 0x3D, 0x72, 0x65, 0x49, 0x56, 0xEC + }, + { + 0xFE, 0x90, 0x70, 0xFC, 0xFA, 0x5E, 0xE4, 0xDC, + 0x2E, 0xCB, 0x41, 0x1A, 0x3D, 0x79, 0xAC, 0xD7, + 0x09, 0x3F, 0x45, 0xD3, 0xC9, 0x34, 0x51, 0x28, + 0x41, 0x7F, 0x48, 0xF6, 0xAD, 0x47, 0x73, 0xBF + }, + { + 0x5B, 0xAE, 0x3F, 0xAC, 0x6E, 0xDC, 0x6E, 0x7F, + 0xA3, 0x48, 0xE4, 0x45, 0x8A, 0x92, 0xF7, 0xD0, + 0x6A, 0x75, 0xAA, 0x66, 0xF4, 0x1E, 0x07, 0x57, + 0xCD, 0x3B, 0x77, 0x6E, 0xC1, 0x82, 0xF2, 0x54 + }, + { + 0x56, 0xB1, 0x15, 0x0B, 0x32, 0x96, 0xBB, 0x42, + 0xC1, 0x74, 0xE4, 0xC4, 0xBD, 0x6E, 0xB8, 0x55, + 0x2B, 0x98, 0xA5, 0xCE, 0xE9, 0x31, 0xD3, 0x6F, + 0x71, 0xAE, 0x7D, 0x65, 0x48, 0x0B, 0x23, 0xF2 + }, + { + 0x33, 0x4A, 0x95, 0xA0, 0x5A, 0x95, 0x1B, 0x77, + 0xFF, 0x9B, 0x92, 0xEA, 0x84, 0x5E, 0xDB, 0xF1, + 0x86, 0x21, 0x2F, 0x73, 0xFE, 0x21, 0x68, 0xC5, + 0xF1, 0x98, 0xF0, 0x28, 0x70, 0x89, 0xD7, 0x72 + }, + { + 0xC6, 0xC3, 0xE8, 0xDE, 0x50, 0x24, 0x78, 0x88, + 0x34, 0x4A, 0xA0, 0xDE, 0x1F, 0x01, 0xE4, 0x7A, + 0x2A, 0xFD, 0xD5, 0xFC, 0x72, 0xD6, 0x63, 0x53, + 0x24, 0xA7, 0x3F, 0x6C, 0x45, 0xDF, 0xB0, 0x69 + }, + { + 0xB5, 0x39, 0x97, 0x44, 0xAA, 0xA6, 0xAF, 0xFD, + 0x85, 0x95, 0x40, 0x10, 0x16, 0x43, 0xB1, 0xD9, + 0xDF, 0xC0, 0xB8, 0xA8, 0xEE, 0xB4, 0xDE, 0xB3, + 0x02, 0x32, 0xF5, 0xD1, 0x0A, 0xB1, 0xFF, 0x0F + }, + { + 0x26, 0xE6, 0xA1, 0x6F, 0x83, 0x43, 0xAB, 0x12, + 0x3D, 0x4C, 0x27, 0x6A, 0x61, 0xC3, 0xD4, 0xDF, + 0x71, 0x33, 0x89, 0xFA, 0xA6, 0x10, 0x95, 0x97, + 0xBF, 0x68, 0xA3, 0x3C, 0xF5, 0x0B, 0x04, 0x78 + }, + { + 0xF4, 0xAF, 0x8D, 0x98, 0x80, 0x6E, 0x22, 0x38, + 0x5D, 0x4C, 0xFC, 0x66, 0xA1, 0x26, 0x71, 0xB3, + 0xE6, 0xA4, 0xF2, 0x51, 0x49, 0xA5, 0x97, 0xE0, + 0x8C, 0x27, 0xDB, 0x59, 0x3B, 0x5A, 0x74, 0xBB + }, + { + 0x92, 0x4E, 0x41, 0xA0, 0x97, 0x9F, 0xC8, 0xEA, + 0xFA, 0x51, 0x04, 0x5D, 0x1F, 0xAA, 0x58, 0x6F, + 0xCE, 0x46, 0x54, 0x8C, 0x59, 0x0C, 0xFF, 0xBA, + 0x36, 0x2E, 0x31, 0xF9, 0x19, 0xE4, 0x02, 0x8B + }, + { + 0x00, 0x50, 0x67, 0x39, 0x86, 0x46, 0xD9, 0x49, + 0x12, 0xCD, 0xCB, 0xD9, 0xC6, 0x05, 0x4B, 0xF6, + 0xBA, 0x2B, 0xC8, 0x47, 0x3D, 0xB3, 0x9C, 0x67, + 0x8F, 0x10, 0x78, 0xAF, 0x4E, 0x79, 0x31, 0x42 + }, + { + 0xB7, 0xEB, 0x02, 0xF0, 0xAD, 0x6F, 0xB7, 0x23, + 0x29, 0xC5, 0x52, 0x63, 0x00, 0xF3, 0x58, 0xF4, + 0xC8, 0xDB, 0x99, 0x9A, 0x2A, 0x3F, 0x4D, 0x28, + 0xB3, 0x51, 0x61, 0xAA, 0x46, 0x4D, 0x99, 0x6F + }, + { + 0xF9, 0x02, 0xC6, 0x7C, 0x20, 0x2B, 0x45, 0x9D, + 0x33, 0x3B, 0x19, 0xCE, 0x80, 0xE7, 0xA4, 0xDA, + 0xC3, 0x59, 0xCE, 0xFD, 0x4B, 0x3B, 0x89, 0x14, + 0x8A, 0xF7, 0x3F, 0xF0, 0xBB, 0xF0, 0x28, 0x7D + }, + { + 0x10, 0x0A, 0x8F, 0xE6, 0x10, 0xD8, 0x8D, 0x9D, + 0x27, 0xFE, 0x70, 0x06, 0xDF, 0xDD, 0xD0, 0xEB, + 0x8D, 0x6F, 0x4C, 0xEC, 0x60, 0x1D, 0x3B, 0x64, + 0x1A, 0x8E, 0x3F, 0x5F, 0x86, 0xF4, 0xEC, 0x82 + }, + { + 0x3C, 0x36, 0xA1, 0xE8, 0xD7, 0xD6, 0x8E, 0x33, + 0xDD, 0x8C, 0xF5, 0xC3, 0x06, 0xE1, 0x58, 0x11, + 0x13, 0xFE, 0x66, 0xBB, 0x83, 0xA5, 0xD4, 0x66, + 0x08, 0xB2, 0xBA, 0x00, 0x1E, 0x7E, 0x5A, 0x04 + }, + { + 0x30, 0x56, 0x05, 0x62, 0xCA, 0xD9, 0x99, 0x4D, + 0x9A, 0x8F, 0x58, 0x9E, 0x1A, 0x05, 0x82, 0xA2, + 0xA2, 0x34, 0xA3, 0x09, 0x51, 0x10, 0x01, 0x82, + 0xAD, 0xE2, 0xEF, 0x66, 0x7D, 0x70, 0x98, 0x93 + }, + { + 0xAD, 0xBD, 0xCF, 0x5D, 0x87, 0xCD, 0x11, 0x1F, + 0x0B, 0x4B, 0x8A, 0x15, 0x64, 0xB4, 0x15, 0x86, + 0xE5, 0x2F, 0x8A, 0xB1, 0x07, 0x38, 0x27, 0x6F, + 0x8A, 0x23, 0x9C, 0x03, 0x1F, 0x89, 0xC4, 0xBA + }, + { + 0x32, 0x65, 0xBA, 0x98, 0xDD, 0xAC, 0x91, 0x8E, + 0x34, 0x30, 0x0D, 0xD9, 0xC5, 0xB8, 0x9D, 0xA9, + 0xC6, 0x3B, 0x38, 0x5A, 0x2D, 0xC8, 0xBC, 0xB4, + 0xDE, 0x9A, 0x67, 0x56, 0x35, 0xC9, 0x5A, 0xAE + }, + { + 0x69, 0x8D, 0xFB, 0x00, 0xF7, 0x56, 0x2E, 0xC4, + 0x55, 0x6C, 0x1E, 0x4E, 0x83, 0x93, 0xF8, 0x18, + 0x27, 0x52, 0x94, 0x3F, 0x94, 0x6A, 0xAC, 0x91, + 0xA0, 0xCD, 0x19, 0xEA, 0x87, 0x8C, 0x7C, 0x89 + }, + { + 0x3D, 0x00, 0xBD, 0x79, 0x22, 0x28, 0xF2, 0xC2, + 0x39, 0xDB, 0xF0, 0x03, 0xFC, 0x43, 0x47, 0xCF, + 0xDB, 0xF6, 0xDB, 0xA4, 0xEF, 0xA8, 0x7F, 0x4A, + 0xE2, 0x07, 0x99, 0x60, 0x1D, 0x7E, 0x64, 0x0B + }, + { + 0xD9, 0xAB, 0xCB, 0x50, 0x79, 0x32, 0x87, 0x2A, + 0x27, 0x61, 0x8E, 0x22, 0x99, 0xFE, 0x0B, 0x69, + 0xA9, 0x0A, 0x3C, 0x6A, 0xF1, 0x09, 0x14, 0xC6, + 0x02, 0x46, 0x26, 0x6A, 0xA5, 0x36, 0x35, 0x6A + }, + { + 0x0C, 0xD3, 0x88, 0xA9, 0x3E, 0x01, 0x08, 0x7C, + 0x55, 0xB1, 0x81, 0xCA, 0xA2, 0x5B, 0x6A, 0xEA, + 0x58, 0xD6, 0x25, 0x90, 0xAA, 0x51, 0x3D, 0x0E, + 0xC5, 0xBF, 0x5E, 0x35, 0x47, 0xD0, 0xD5, 0x59 + }, + { + 0x49, 0x43, 0x97, 0x87, 0x55, 0xA2, 0x01, 0x3E, + 0xE2, 0xEC, 0x65, 0xC1, 0xBE, 0x7B, 0xFD, 0x1D, + 0x51, 0x9E, 0x89, 0x04, 0x0F, 0x63, 0x9C, 0x29, + 0x25, 0x03, 0x7A, 0xB6, 0x11, 0x84, 0xCE, 0xB5 + }, + { + 0x16, 0x1C, 0x2E, 0xDD, 0x6A, 0x6D, 0x14, 0xB6, + 0x38, 0x91, 0x81, 0x25, 0x80, 0x5A, 0x6C, 0xAF, + 0xCC, 0x4B, 0x40, 0x44, 0xDC, 0x07, 0x24, 0x0E, + 0x7E, 0x76, 0xE6, 0x90, 0x25, 0x2B, 0xC1, 0x27 + }, + { + 0x7A, 0x22, 0xB8, 0x27, 0x9F, 0x8B, 0x49, 0xA5, + 0x94, 0x79, 0x3C, 0xC2, 0x8F, 0x89, 0x3F, 0xE2, + 0x2F, 0x5E, 0xD1, 0xAF, 0xB7, 0xC7, 0xA7, 0xC8, + 0xEB, 0x4D, 0xA1, 0x05, 0xE2, 0x01, 0x0F, 0x3A + }, + { + 0x3C, 0x39, 0xDD, 0xA4, 0xDE, 0xC1, 0x1E, 0xDF, + 0x2E, 0x90, 0x2D, 0xC8, 0xB0, 0x62, 0x6B, 0x38, + 0x9D, 0xFB, 0xEF, 0x27, 0x98, 0x7D, 0x3C, 0x65, + 0x4E, 0x5A, 0x5B, 0xF3, 0xEB, 0xBF, 0x20, 0x13 + }, + { + 0x2A, 0xEF, 0x2E, 0x3D, 0xD6, 0x70, 0xB9, 0x2A, + 0xF8, 0x35, 0xEB, 0x8E, 0xE0, 0x31, 0x9C, 0xED, + 0x46, 0x8A, 0x25, 0xC8, 0x19, 0x55, 0x12, 0xF0, + 0x71, 0x03, 0x7E, 0x40, 0x34, 0x1F, 0xDA, 0x95 + }, + { + 0x77, 0x53, 0xAA, 0x3B, 0xCA, 0x71, 0x54, 0x6C, + 0x5B, 0x6A, 0xC2, 0xCB, 0x54, 0x31, 0xE5, 0x93, + 0x04, 0x4A, 0x81, 0x46, 0x20, 0x6D, 0x25, 0x20, + 0xD5, 0x9A, 0xEB, 0xA0, 0x1C, 0x08, 0xD1, 0xAD + }, + { + 0x70, 0x26, 0x47, 0x09, 0xE4, 0xA6, 0xF5, 0xB7, + 0xEE, 0x45, 0xE4, 0xCA, 0x1D, 0x60, 0x72, 0x35, + 0x5D, 0xAA, 0xE6, 0x8A, 0xE0, 0x4D, 0x36, 0x30, + 0x7F, 0x8F, 0xC9, 0x40, 0xD2, 0x1B, 0x10, 0x0C + }, + { + 0x9E, 0xD9, 0x16, 0xFD, 0xEA, 0xE5, 0xB1, 0x20, + 0xFE, 0x06, 0xE8, 0x7E, 0x6D, 0xD6, 0x19, 0x1A, + 0x1E, 0xA5, 0xFA, 0x0B, 0x57, 0x2B, 0x0B, 0x19, + 0xBC, 0x30, 0xD7, 0xB9, 0xFD, 0x2E, 0x36, 0x38 + }, + { + 0x98, 0xED, 0x94, 0x8C, 0x8B, 0xBC, 0x54, 0x69, + 0xC7, 0x73, 0xEA, 0x3D, 0x18, 0x32, 0x63, 0x4A, + 0xCD, 0x89, 0xDB, 0x48, 0x22, 0xEA, 0x1D, 0x00, + 0x56, 0xF6, 0x0B, 0xB6, 0x09, 0x7B, 0x89, 0x41 + }, + { + 0x5A, 0xF7, 0xAC, 0xBE, 0x4C, 0xCA, 0x14, 0xB0, + 0xEE, 0x7F, 0x17, 0x8F, 0x1F, 0x00, 0x17, 0xE7, + 0xE5, 0x11, 0xAC, 0xA4, 0xB9, 0x33, 0x47, 0x9F, + 0x56, 0x97, 0x5B, 0x96, 0xB9, 0x68, 0xB4, 0xEC + }, + { + 0xD0, 0x25, 0xBD, 0xE5, 0xA4, 0xC7, 0xE5, 0xE8, + 0x35, 0xE9, 0xB1, 0x6E, 0x36, 0xA5, 0x26, 0x4C, + 0x56, 0xD1, 0xBA, 0xCE, 0xBD, 0x17, 0x2B, 0x58, + 0x31, 0x3F, 0xA7, 0xFD, 0x9B, 0x6F, 0x0E, 0x72 + }, + { + 0xE1, 0x3B, 0xAC, 0x79, 0x16, 0x4F, 0x19, 0x20, + 0x2A, 0x84, 0xCF, 0xD6, 0x93, 0x92, 0x49, 0x46, + 0xA1, 0x24, 0xD5, 0xDE, 0xBD, 0x22, 0xE1, 0xAB, + 0x23, 0x0F, 0xC3, 0xA4, 0xB1, 0x30, 0x52, 0x26 + }, + { + 0xB3, 0x67, 0x2D, 0x43, 0xC8, 0xFF, 0x69, 0x8D, + 0x34, 0x92, 0x5F, 0x45, 0x2B, 0xAA, 0xAD, 0xD8, + 0x86, 0x58, 0xF2, 0xD3, 0x55, 0xD9, 0x1C, 0x85, + 0x72, 0xC0, 0xCE, 0x3A, 0x84, 0xF4, 0xD2, 0x01 + }, + { + 0x5A, 0xA2, 0xCF, 0xAD, 0x82, 0xAB, 0xFE, 0xE1, + 0x55, 0x71, 0x1A, 0xB3, 0xE3, 0x1F, 0x86, 0x29, + 0xC2, 0x1E, 0x9C, 0x30, 0xBD, 0x6C, 0x2C, 0xAB, + 0xD3, 0xAC, 0x87, 0x35, 0xBA, 0xFE, 0x74, 0xC9 + }, + { + 0x5F, 0x9B, 0x85, 0x38, 0xC6, 0x53, 0x16, 0xA7, + 0xC1, 0x85, 0x60, 0xEF, 0x3D, 0x30, 0x57, 0x2E, + 0xA2, 0x44, 0x12, 0x08, 0x48, 0xD5, 0xE1, 0x96, + 0xD5, 0xDE, 0x2E, 0x70, 0x58, 0x62, 0x71, 0x8F + }, + { + 0x60, 0xA3, 0xD3, 0x30, 0x0E, 0xA7, 0x59, 0x10, + 0x74, 0x33, 0x18, 0x5B, 0x06, 0x7E, 0xCE, 0xF6, + 0x4B, 0x22, 0xCE, 0x00, 0x11, 0xCE, 0xFF, 0x55, + 0xB6, 0x97, 0x6F, 0xFD, 0x63, 0x14, 0xAF, 0xA6 + }, + { + 0x56, 0xD9, 0x2F, 0x8B, 0xA9, 0xFB, 0x40, 0x6F, + 0xF1, 0xCD, 0xBE, 0x0F, 0x16, 0x09, 0xD4, 0x9E, + 0x81, 0x72, 0xBF, 0x5B, 0xC1, 0x35, 0xF6, 0x87, + 0xD0, 0x21, 0x23, 0x6A, 0x3C, 0x6D, 0xB0, 0x3A + }, + { + 0x60, 0xFB, 0x92, 0xB3, 0xE9, 0xE4, 0x49, 0xA3, + 0x1E, 0x24, 0xFB, 0x5F, 0x09, 0xE7, 0x0D, 0x4D, + 0xED, 0xD8, 0xED, 0x4E, 0xF7, 0x80, 0xD1, 0x32, + 0xD3, 0x51, 0xE1, 0x7B, 0x30, 0x78, 0x6B, 0x04 + }, + { + 0x1F, 0x2B, 0xD2, 0x7D, 0x11, 0xBD, 0x7A, 0x2A, + 0xEF, 0xCD, 0xDE, 0x72, 0xD4, 0xA5, 0xA1, 0x5F, + 0x73, 0xE5, 0x62, 0x9C, 0x0E, 0x95, 0xB8, 0xD2, + 0x0F, 0x7E, 0x05, 0xD5, 0x35, 0x0D, 0x40, 0x33 + }, + { + 0x86, 0x48, 0x07, 0x8F, 0x9B, 0x8D, 0xA4, 0x84, + 0x7E, 0xA0, 0xCB, 0x0C, 0x7E, 0xB4, 0x1F, 0x67, + 0x32, 0x81, 0x17, 0x07, 0xD0, 0x9B, 0x4C, 0x80, + 0x97, 0xE7, 0x46, 0x6E, 0x39, 0x36, 0xD0, 0xA7 + }, + { + 0xD6, 0xB9, 0xA3, 0xC0, 0xCF, 0x8A, 0xF4, 0x29, + 0x0A, 0xDC, 0x98, 0x69, 0x5A, 0x7E, 0xC0, 0xCF, + 0xAB, 0x3C, 0xA2, 0xE9, 0x19, 0x9D, 0x63, 0x8E, + 0x18, 0x6A, 0xE0, 0x6E, 0x67, 0x79, 0xD6, 0xA5 + }, + { + 0x37, 0xB4, 0x84, 0x0B, 0x9B, 0xFF, 0xC8, 0x90, + 0x3F, 0x41, 0x94, 0xEB, 0x01, 0x69, 0x06, 0x50, + 0xE6, 0xB0, 0x67, 0x45, 0x96, 0xB6, 0xB5, 0x60, + 0x40, 0x19, 0x94, 0x25, 0x62, 0xD3, 0x44, 0x6C + }, + { + 0x20, 0x09, 0x31, 0xC5, 0x54, 0xB5, 0x9D, 0x03, + 0xB2, 0xEA, 0x5A, 0xFE, 0xFB, 0xE0, 0x42, 0xE8, + 0x12, 0x44, 0x76, 0xD1, 0x91, 0x1A, 0x8F, 0x77, + 0xD4, 0x25, 0x73, 0x85, 0x6E, 0xC2, 0x48, 0x7B + }, + { + 0xEC, 0x86, 0x41, 0x7D, 0x08, 0xCA, 0x61, 0x44, + 0x44, 0x4E, 0x4E, 0xC4, 0x41, 0xA0, 0x62, 0xB1, + 0xC6, 0x90, 0x06, 0xEC, 0x3D, 0xD2, 0x94, 0xD9, + 0x55, 0xF6, 0x76, 0x12, 0x91, 0x5E, 0x33, 0x27 + }, + { + 0x20, 0xCD, 0x1C, 0xED, 0x99, 0xDA, 0x9B, 0x07, + 0xF2, 0x57, 0x2D, 0x67, 0xCA, 0xF3, 0x35, 0xA2, + 0x97, 0xA0, 0xC7, 0x63, 0x3E, 0x11, 0x28, 0x56, + 0xD1, 0x41, 0x4D, 0x54, 0x2B, 0x8E, 0x9C, 0xA8 + }, + { + 0xBB, 0x0C, 0xCA, 0xFF, 0xB8, 0x79, 0xF0, 0x23, + 0xFB, 0xB5, 0x0F, 0xBA, 0xF1, 0x6F, 0x2B, 0xAD, + 0x8C, 0xFF, 0xC6, 0x3F, 0x01, 0xF7, 0x48, 0x67, + 0xE3, 0xC2, 0xF3, 0x04, 0xC9, 0xAA, 0x20, 0x30 + }, + { + 0x3A, 0x5D, 0xDB, 0xA2, 0xD7, 0x68, 0x47, 0xF8, + 0x6F, 0xA2, 0x9F, 0x5E, 0xF4, 0x8A, 0x56, 0xE7, + 0x44, 0x13, 0x0F, 0x3D, 0xB4, 0x6D, 0xE0, 0x16, + 0x1F, 0x2E, 0x6B, 0x5D, 0x86, 0x47, 0xC1, 0xBB + }, + { + 0x65, 0xAA, 0x48, 0x08, 0xA9, 0x93, 0x91, 0x68, + 0xCB, 0x1B, 0x6E, 0x44, 0xC0, 0x63, 0x4B, 0x71, + 0xF1, 0xDF, 0xD7, 0xF5, 0xAB, 0x6D, 0x60, 0xE5, + 0x32, 0x52, 0x8B, 0x52, 0x0A, 0x36, 0x82, 0xD7 + }, + { + 0x54, 0xE1, 0x53, 0x05, 0x18, 0xE4, 0xC8, 0x5A, + 0x45, 0xE6, 0xD7, 0xD1, 0x4C, 0x54, 0x54, 0x33, + 0xA5, 0xF5, 0x01, 0xBA, 0xDA, 0x31, 0x3D, 0x46, + 0xC8, 0x12, 0x17, 0xBA, 0xD9, 0xFD, 0xFE, 0xDA + }, + { + 0x05, 0x8D, 0xCC, 0xDC, 0xD9, 0xCC, 0x86, 0x2E, + 0xF1, 0xB8, 0xCD, 0x50, 0xCC, 0xBD, 0x5B, 0x8D, + 0x69, 0xF3, 0x31, 0x0F, 0x04, 0x41, 0x0D, 0x91, + 0x42, 0xDB, 0xAF, 0x80, 0xF5, 0x0E, 0xB3, 0x33 + }, + { + 0xF4, 0x0C, 0x48, 0x27, 0x58, 0xCD, 0xB3, 0xC2, + 0x67, 0x0A, 0x90, 0x3F, 0x02, 0xD0, 0x2C, 0xEB, + 0x69, 0x96, 0x73, 0x1F, 0xA1, 0x8D, 0x67, 0xB7, + 0xFA, 0x65, 0xBE, 0x41, 0x1B, 0x68, 0xC4, 0x73 + }, + { + 0x5F, 0xAE, 0x12, 0xFE, 0x22, 0xFF, 0x4A, 0xB0, + 0x5F, 0x35, 0x7E, 0xFE, 0xE8, 0xAA, 0x06, 0x63, + 0xF6, 0x31, 0x3E, 0xAC, 0x25, 0x9A, 0x88, 0xD5, + 0xEB, 0x68, 0xFB, 0x4D, 0x6F, 0x7F, 0x2E, 0xB8 + }, + { + 0xD2, 0x3A, 0x96, 0xF0, 0x68, 0xD1, 0x69, 0xE9, + 0x97, 0xA5, 0x60, 0x99, 0xAA, 0x29, 0x10, 0x5F, + 0x43, 0x22, 0x62, 0x8B, 0x5B, 0x95, 0x25, 0xF7, + 0x1B, 0x7C, 0x6E, 0x7A, 0x23, 0x08, 0x59, 0xA7 + }, + { + 0x50, 0x7C, 0x82, 0x5A, 0x28, 0x53, 0x52, 0x45, + 0x55, 0x7C, 0x61, 0x9D, 0x70, 0xDB, 0x74, 0xBA, + 0x39, 0x61, 0x21, 0xAC, 0x29, 0x00, 0x72, 0x1B, + 0x28, 0x46, 0xFA, 0x8E, 0xA9, 0x48, 0x07, 0xA3 + }, + { + 0x4F, 0x2B, 0x77, 0x63, 0x48, 0x49, 0x10, 0x38, + 0x5A, 0x23, 0x0C, 0x77, 0xB8, 0xF7, 0x40, 0x70, + 0x51, 0x04, 0x2A, 0x3A, 0x50, 0x40, 0x01, 0x30, + 0x52, 0x23, 0x5F, 0x33, 0x48, 0x45, 0x16, 0x54 + }, + { + 0xC9, 0x3F, 0x68, 0x61, 0x8A, 0xC1, 0x6D, 0xC2, + 0xBE, 0x4D, 0xBC, 0x48, 0xF3, 0xBF, 0xC7, 0xED, + 0x87, 0x07, 0xEC, 0x81, 0x15, 0xB0, 0xF8, 0x37, + 0x8C, 0x15, 0xD1, 0xCF, 0x0D, 0x20, 0x02, 0x5C + }, + { + 0x2F, 0x54, 0x23, 0xC1, 0x9A, 0xDD, 0x7D, 0xC9, + 0x83, 0xE0, 0x45, 0x18, 0x6E, 0x0F, 0x16, 0xD6, + 0xB2, 0x5A, 0xF5, 0x44, 0x5C, 0xD7, 0x73, 0xA9, + 0x50, 0x58, 0x26, 0x73, 0x17, 0xE2, 0x6A, 0xCF + }, + { + 0xA1, 0xC7, 0xFB, 0xAB, 0x43, 0xF1, 0xD2, 0x07, + 0xC7, 0xFF, 0xB6, 0x58, 0x74, 0xCC, 0x69, 0x2F, + 0x9D, 0xA4, 0x5E, 0x13, 0xA2, 0x29, 0x85, 0x5E, + 0x99, 0x18, 0x7F, 0xDF, 0xCD, 0x6C, 0xC2, 0x21 + }, + { + 0xAC, 0x64, 0x45, 0x5F, 0x38, 0x53, 0xFA, 0x62, + 0x1F, 0x5F, 0x6E, 0xB8, 0x22, 0x5D, 0xC5, 0x88, + 0x76, 0xB3, 0xC8, 0xBB, 0xD9, 0x32, 0x63, 0xE5, + 0x5E, 0xFC, 0x78, 0xBE, 0x53, 0x8F, 0xDC, 0x54 + }, + { + 0x9F, 0x43, 0xBD, 0x71, 0x8E, 0x48, 0xA2, 0x39, + 0xD5, 0xD7, 0x9C, 0xA6, 0xE9, 0x88, 0xB5, 0xEA, + 0x7A, 0xA7, 0x4E, 0x80, 0xD6, 0x4A, 0xF8, 0xF9, + 0xD0, 0x28, 0x41, 0xA8, 0x16, 0x56, 0xA0, 0x22 + }, + { + 0x0F, 0xF2, 0x7D, 0xAC, 0x03, 0x5C, 0x89, 0x07, + 0xED, 0xCD, 0xEA, 0xBC, 0xB5, 0x40, 0x1D, 0xC4, + 0xD2, 0x3C, 0x40, 0x13, 0x4E, 0xCB, 0x44, 0x27, + 0xA2, 0x03, 0x20, 0x87, 0xE7, 0xC8, 0xAD, 0xF3 + }, + { + 0x50, 0x28, 0x52, 0x71, 0x95, 0x69, 0x32, 0xD3, + 0x9B, 0x09, 0x67, 0x20, 0x2B, 0x56, 0x00, 0x6C, + 0xBB, 0x6D, 0x73, 0x8E, 0xE2, 0x9E, 0x5A, 0x86, + 0x7E, 0xDF, 0x72, 0xC8, 0xC4, 0x38, 0x6F, 0x1B + }, + { + 0x32, 0x2C, 0xE0, 0x6C, 0xC1, 0x41, 0xA0, 0xB3, + 0xD8, 0x9B, 0xCD, 0xCF, 0xCB, 0x38, 0x59, 0x75, + 0xDB, 0xCA, 0x56, 0xE5, 0x71, 0x9A, 0x78, 0xC3, + 0x40, 0x00, 0xFC, 0xEC, 0x2E, 0x15, 0xB5, 0x5D + }, + { + 0x13, 0x36, 0x62, 0x8C, 0x7F, 0x15, 0x41, 0xC7, + 0x81, 0x5F, 0xC0, 0xFF, 0x1F, 0xB5, 0xDF, 0xB0, + 0x7A, 0x85, 0xCF, 0x5A, 0x17, 0xA2, 0x87, 0x2A, + 0x3C, 0xE4, 0xB3, 0x22, 0xD4, 0xA0, 0x3D, 0x0B + }, + { + 0x20, 0xCA, 0xFA, 0xF5, 0x87, 0xEB, 0x9F, 0x6D, + 0x31, 0xA7, 0xD0, 0xF1, 0x58, 0x85, 0xCB, 0x78, + 0x46, 0x75, 0x43, 0x36, 0x3D, 0xEE, 0x66, 0x25, + 0x98, 0x1C, 0x76, 0x98, 0xED, 0xB2, 0x77, 0x1F + }, + { + 0x38, 0xC7, 0x24, 0x64, 0x0B, 0xCB, 0x67, 0xE1, + 0xF8, 0x41, 0x4C, 0x41, 0xDB, 0x25, 0xD8, 0x97, + 0xDA, 0x5C, 0x26, 0x9B, 0x84, 0xF8, 0x8B, 0xD1, + 0x1F, 0x21, 0x85, 0x9A, 0xC3, 0xFA, 0xC3, 0x3F + }, + { + 0x5A, 0x9A, 0x94, 0x4F, 0x8E, 0xE1, 0xFB, 0xA7, + 0x22, 0x19, 0xDE, 0x72, 0x22, 0xD8, 0x68, 0x99, + 0x3D, 0x10, 0x66, 0x82, 0x3F, 0x20, 0x45, 0xB2, + 0xCB, 0xC0, 0x0E, 0x4D, 0x44, 0x01, 0xA8, 0x9D + }, + { + 0x8B, 0xF5, 0x17, 0x95, 0xF3, 0x90, 0x34, 0x30, + 0xFB, 0x39, 0x10, 0x4D, 0x7F, 0x0A, 0x00, 0xC3, + 0xC9, 0xC9, 0x30, 0x7B, 0x1B, 0x42, 0xE4, 0x79, + 0x97, 0xCB, 0x99, 0x8E, 0xCF, 0x70, 0x29, 0x79 + }, + { + 0xDA, 0xBC, 0xA0, 0x8E, 0x50, 0x2C, 0x9A, 0x79, + 0x53, 0x18, 0x45, 0xD1, 0x65, 0x10, 0xB8, 0x19, + 0x3C, 0xC7, 0x90, 0x28, 0x47, 0xA3, 0xCD, 0x8E, + 0xAC, 0x94, 0xD2, 0xC7, 0x55, 0x9F, 0x8E, 0xB2 + }, + { + 0xE7, 0x63, 0xDF, 0x1C, 0x5A, 0xC4, 0x34, 0xBE, + 0x55, 0xE3, 0x8C, 0x10, 0xB7, 0x53, 0x9B, 0x4C, + 0x59, 0x52, 0xC8, 0x5D, 0xCE, 0x80, 0x20, 0x88, + 0x96, 0xDA, 0xA4, 0xE7, 0x66, 0x23, 0x88, 0x9A + }, + { + 0x90, 0xF1, 0x6F, 0xF7, 0x33, 0x13, 0x02, 0xED, + 0xC1, 0xB9, 0xBB, 0xB5, 0x09, 0x5C, 0x84, 0xD0, + 0x14, 0xBB, 0xFD, 0xC0, 0xAA, 0x87, 0xD5, 0xBF, + 0x51, 0x88, 0x08, 0xD4, 0x26, 0x5E, 0x04, 0xD6 + }, + { + 0x16, 0x9D, 0xF7, 0x67, 0xD0, 0x8C, 0x12, 0x81, + 0x89, 0xE4, 0x26, 0x81, 0xC1, 0x0E, 0x50, 0xA8, + 0xBD, 0x48, 0x35, 0xC1, 0x7D, 0xC0, 0x3A, 0x6A, + 0xE8, 0x0C, 0x51, 0x16, 0xBB, 0x0B, 0x9C, 0x58 + }, + { + 0xB6, 0x1B, 0x99, 0x8D, 0x5A, 0x54, 0xBE, 0xA4, + 0x54, 0x28, 0x89, 0xB5, 0x8D, 0x6E, 0xC0, 0x99, + 0x5A, 0x7F, 0x0D, 0x26, 0x21, 0xC8, 0x94, 0x66, + 0xEF, 0xD5, 0x6F, 0xBC, 0x79, 0x85, 0x2E, 0x77 + }, + { + 0x20, 0xE1, 0xE9, 0x5E, 0x36, 0xEF, 0x6B, 0x89, + 0xD9, 0xF4, 0xC0, 0x46, 0x45, 0x2B, 0x2D, 0x20, + 0x0A, 0xEC, 0xA6, 0x35, 0x5B, 0x94, 0xF1, 0xB1, + 0x1B, 0x75, 0x9F, 0x9B, 0xFF, 0x07, 0x09, 0x57 + }, + { + 0x78, 0x86, 0x74, 0xDC, 0x22, 0xE7, 0x72, 0x63, + 0xE0, 0xA3, 0x26, 0xED, 0x97, 0x85, 0x03, 0x0D, + 0xD2, 0x92, 0xF6, 0x01, 0x47, 0xF5, 0x90, 0x8C, + 0xC7, 0x1F, 0xB1, 0xBE, 0x17, 0xB1, 0xC9, 0xA5 + }, + { + 0x43, 0x65, 0x42, 0x86, 0x3D, 0x7F, 0xEB, 0x21, + 0x34, 0x2F, 0x7D, 0xF8, 0xAA, 0x93, 0xC3, 0x5F, + 0x12, 0x91, 0x09, 0x8D, 0x28, 0x8A, 0xC9, 0xA3, + 0xB0, 0xF7, 0x2B, 0x22, 0xB0, 0xA3, 0xC8, 0xE5 + }, + { + 0x1F, 0x6E, 0x5B, 0x41, 0x1C, 0xD5, 0xDB, 0x74, + 0xDE, 0xEC, 0x31, 0xD2, 0x5A, 0xF2, 0xCA, 0x21, + 0xFA, 0x16, 0x81, 0x54, 0x15, 0xDB, 0xE5, 0x6D, + 0xF9, 0x1A, 0x45, 0xD7, 0x05, 0x01, 0xED, 0x3F + }, + { + 0x06, 0x95, 0xE4, 0x19, 0x0C, 0x3D, 0x42, 0x2B, + 0x92, 0xC8, 0x43, 0xB1, 0xFA, 0xB3, 0x6F, 0x48, + 0x69, 0xA0, 0x78, 0xA5, 0xD9, 0x71, 0x81, 0x68, + 0xD2, 0x6B, 0x56, 0xFE, 0xBF, 0x15, 0xF4, 0xAD + }, + { + 0xBB, 0xF8, 0x13, 0xE6, 0xC7, 0x52, 0x4B, 0x96, + 0xA2, 0x9E, 0x8A, 0x9D, 0x21, 0x4C, 0x48, 0x5A, + 0xE1, 0x71, 0xE0, 0xF1, 0x8A, 0xAB, 0x09, 0xC7, + 0x66, 0xDC, 0xC9, 0xB5, 0xA1, 0x7E, 0x16, 0xD9 + }, + { + 0x0F, 0x97, 0xCD, 0xEB, 0xBC, 0x45, 0x4E, 0x8F, + 0x9C, 0xE6, 0x4B, 0x8F, 0xB8, 0x5D, 0x57, 0xAE, + 0x36, 0xE2, 0x76, 0xAC, 0xBB, 0xAA, 0xBC, 0x5D, + 0x62, 0xFD, 0x90, 0x1D, 0x86, 0xE7, 0x3E, 0x08 + }, + { + 0x90, 0x0B, 0x21, 0x1D, 0xD7, 0x80, 0xD8, 0xDC, + 0xF9, 0x41, 0x34, 0x4C, 0x0C, 0xE5, 0x70, 0xCF, + 0x48, 0xBB, 0x27, 0x9B, 0x7B, 0x05, 0x9E, 0x69, + 0x8F, 0x1C, 0xE7, 0x67, 0xFD, 0xBD, 0xFA, 0xF0 + }, + { + 0x60, 0x60, 0xA5, 0x0C, 0x2E, 0x84, 0x9B, 0x1C, + 0x7E, 0xEE, 0xCE, 0x33, 0xDC, 0xF7, 0xFF, 0x37, + 0xC7, 0x55, 0x60, 0x14, 0x05, 0x2A, 0x54, 0x23, + 0xE6, 0x00, 0xE7, 0xE6, 0x48, 0x6F, 0xCD, 0x82 + }, + { + 0xEA, 0xCC, 0x92, 0x93, 0xEA, 0x5D, 0xE3, 0x65, + 0xD3, 0x01, 0x79, 0x0A, 0x65, 0xD4, 0xB8, 0x08, + 0x2D, 0x93, 0xBB, 0xA1, 0x1D, 0x90, 0xA9, 0xE5, + 0x03, 0x8F, 0x3A, 0xD7, 0x43, 0x42, 0x23, 0x26 + }, + { + 0x3B, 0xF7, 0x4E, 0x1B, 0x4E, 0xE5, 0x35, 0xE6, + 0x3F, 0xC1, 0x89, 0x00, 0x16, 0xE9, 0xE1, 0xDB, + 0x0A, 0x91, 0xCD, 0xC9, 0x14, 0x12, 0x39, 0x22, + 0xF2, 0x33, 0xA4, 0xE1, 0xF1, 0x1C, 0xCA, 0x21 + }, + { + 0xE3, 0x28, 0x64, 0x48, 0xCD, 0x54, 0xA1, 0xB2, + 0xEB, 0xBF, 0xAA, 0xF3, 0xD8, 0xF2, 0x3D, 0xF7, + 0xAE, 0xDD, 0x37, 0xDB, 0x90, 0x82, 0x60, 0x1E, + 0xFB, 0xF7, 0xEB, 0x9B, 0xE1, 0x70, 0xAA, 0xAF + }, + { + 0xB1, 0xD1, 0xF6, 0x52, 0x6A, 0x8A, 0xD2, 0x97, + 0x2C, 0x8C, 0x72, 0x47, 0x70, 0xB5, 0xCA, 0x9E, + 0x27, 0xF3, 0xC8, 0x94, 0x9F, 0x99, 0xFA, 0x27, + 0xFB, 0x8F, 0x82, 0x78, 0xC4, 0xEE, 0xF5, 0x0A + }, + { + 0x75, 0x97, 0xE3, 0xDB, 0x98, 0x4B, 0x14, 0xDF, + 0x46, 0xA9, 0x74, 0x98, 0xE7, 0xB6, 0xCF, 0x90, + 0xF6, 0xA8, 0x2F, 0xA1, 0x77, 0x40, 0xDB, 0xFE, + 0x72, 0x43, 0xE4, 0x82, 0xBC, 0xED, 0x2C, 0xB0 + }, + { + 0xEB, 0xB9, 0x3E, 0xC0, 0xCD, 0xE6, 0xFD, 0x2A, + 0x5C, 0xCF, 0xA2, 0x86, 0xC6, 0x6C, 0xEE, 0xD5, + 0x8B, 0x81, 0x7C, 0x65, 0x87, 0x8F, 0x65, 0x66, + 0xDF, 0xDF, 0xEE, 0x1F, 0x1D, 0xAE, 0x90, 0x12 + }, + { + 0xAE, 0x87, 0xEB, 0x31, 0xF1, 0x09, 0x54, 0x2E, + 0x06, 0x1B, 0xD4, 0xBB, 0xF0, 0x2D, 0x54, 0xD6, + 0x1D, 0x1C, 0x63, 0x2B, 0x3B, 0x27, 0x93, 0x7C, + 0xEA, 0xA5, 0x88, 0xED, 0x79, 0x61, 0xD2, 0xEB + }, + { + 0x35, 0xB2, 0xDC, 0xA2, 0x53, 0x24, 0xD0, 0x5F, + 0xAB, 0xF6, 0x49, 0xA3, 0x62, 0xB7, 0xAC, 0x3D, + 0xE0, 0x2A, 0x3E, 0xA8, 0x90, 0xB1, 0xA3, 0x71, + 0x21, 0x46, 0xA6, 0x43, 0xCF, 0xA9, 0x4D, 0xBD + }, + { + 0x1C, 0xCE, 0x97, 0x7F, 0x29, 0x71, 0xD4, 0xE4, + 0x80, 0x73, 0x8B, 0x82, 0x1E, 0x8C, 0xC4, 0x59, + 0x73, 0x21, 0xBD, 0x3B, 0x60, 0x2D, 0xDD, 0xFB, + 0x88, 0xFB, 0x22, 0xD4, 0x23, 0xD0, 0x45, 0xF1 + }, + { + 0xAD, 0xFC, 0x3A, 0xBB, 0x96, 0xE8, 0xBB, 0x86, + 0xDA, 0xF8, 0x2B, 0xF7, 0x0B, 0x56, 0x2D, 0xAD, + 0xFE, 0x7F, 0xDD, 0x82, 0x0C, 0xB5, 0x6F, 0x75, + 0x59, 0xC2, 0x88, 0xC2, 0xB8, 0x8A, 0x30, 0x97 + }, + { + 0xB2, 0xA5, 0xAF, 0x80, 0x38, 0xEC, 0xC0, 0x10, + 0x8A, 0x3D, 0x07, 0x7F, 0x73, 0x4F, 0x79, 0x37, + 0x80, 0x00, 0x03, 0x54, 0x3B, 0x8F, 0xB4, 0x97, + 0x06, 0xDE, 0x06, 0x7C, 0xFE, 0x62, 0xF6, 0x76 + }, + { + 0xD7, 0x9E, 0x1A, 0xC9, 0x7E, 0x61, 0x7D, 0xE4, + 0x46, 0x4E, 0xD6, 0xB6, 0x42, 0x84, 0xF4, 0xC8, + 0x9A, 0x16, 0x69, 0x5E, 0x7E, 0x1E, 0x9F, 0xFE, + 0x56, 0xC5, 0xD2, 0x53, 0x94, 0x5A, 0xFA, 0x2B + }, + { + 0x83, 0x5A, 0xD2, 0x2C, 0x3B, 0x3C, 0x1F, 0xD7, + 0x91, 0xE6, 0xF0, 0xCE, 0xCE, 0x60, 0x82, 0xB3, + 0xB5, 0xF5, 0x78, 0xFE, 0x62, 0x77, 0x71, 0x03, + 0x28, 0x5E, 0xB9, 0xA8, 0xD5, 0xCF, 0x50, 0xB4 + }, + { + 0xE6, 0xFB, 0x34, 0x30, 0x2A, 0x3C, 0xBD, 0x3C, + 0x7F, 0x15, 0x73, 0x4A, 0x6A, 0x9A, 0x19, 0x1A, + 0x2F, 0x98, 0xD9, 0x82, 0x61, 0xB5, 0xA5, 0x2D, + 0x00, 0xD8, 0x1F, 0x6A, 0x5B, 0x46, 0xE7, 0xAB + }, + { + 0x58, 0x8A, 0xDD, 0x5E, 0x35, 0x77, 0x7F, 0xB6, + 0x98, 0x7F, 0xAB, 0xCD, 0xD4, 0x6A, 0xC1, 0x53, + 0x04, 0x7C, 0xC8, 0x34, 0xF9, 0xE1, 0xC7, 0x3D, + 0x13, 0xC3, 0x00, 0x76, 0xCC, 0x2C, 0xF1, 0xB3 + }, + { + 0x5B, 0x14, 0x1C, 0x65, 0x0C, 0x4B, 0xE0, 0x63, + 0x31, 0x64, 0xB0, 0xD1, 0xE8, 0x45, 0xD2, 0x15, + 0x84, 0x2A, 0xB8, 0xEC, 0xCA, 0x81, 0x7E, 0xCE, + 0xB5, 0x51, 0x0C, 0xC2, 0x65, 0x7B, 0x61, 0xEF + }, + { + 0x86, 0xF3, 0x69, 0xA8, 0x60, 0x9C, 0x01, 0x96, + 0x51, 0xAA, 0x33, 0x48, 0x73, 0x07, 0xBE, 0x72, + 0x35, 0xC1, 0x66, 0xED, 0xAF, 0xC8, 0x84, 0x30, + 0xA5, 0x1F, 0xA9, 0x46, 0x40, 0x54, 0x90, 0x6C + }, + { + 0x0C, 0x3A, 0xC4, 0x57, 0xE4, 0x96, 0xF2, 0xFC, + 0xEE, 0x08, 0x91, 0x64, 0x8B, 0x93, 0xC4, 0x88, + 0xCA, 0xDE, 0x94, 0x11, 0x4B, 0x69, 0x5E, 0x7F, + 0x5E, 0x9A, 0x47, 0x9F, 0x46, 0x5C, 0x32, 0xA6 + }, + { + 0xB4, 0xEC, 0x36, 0x47, 0xF5, 0xC3, 0x80, 0x11, + 0x81, 0x3B, 0xDD, 0xBE, 0x54, 0xBE, 0x6F, 0xF0, + 0x6C, 0xC4, 0xC4, 0xC7, 0xF5, 0x93, 0x9B, 0x0F, + 0xFE, 0xE8, 0x70, 0x87, 0x24, 0xB1, 0x73, 0xDA + }, + { + 0xEA, 0x37, 0xA1, 0xD8, 0x6E, 0x09, 0xFB, 0x75, + 0x67, 0xAE, 0x48, 0x59, 0xC6, 0xC6, 0x5F, 0xFC, + 0x70, 0x5D, 0xD4, 0x85, 0xD6, 0x0B, 0xAF, 0xDE, + 0xD5, 0x26, 0xD2, 0xAF, 0xC2, 0x57, 0x3E, 0x30 + }, + { + 0x15, 0x52, 0x73, 0xC4, 0x95, 0xC4, 0x76, 0xAE, + 0x08, 0xFD, 0x48, 0x60, 0x8A, 0x5C, 0x3D, 0x9B, + 0xE1, 0x90, 0x41, 0x58, 0x9F, 0x48, 0x0F, 0xCC, + 0x58, 0x72, 0x06, 0x2B, 0x0C, 0x5B, 0x0B, 0x45 + }, + { + 0x6C, 0x70, 0x81, 0xCD, 0x4A, 0xF8, 0xAA, 0x45, + 0x72, 0xD9, 0xC2, 0x80, 0x1D, 0x49, 0x2F, 0xC8, + 0x77, 0xAF, 0x4A, 0x78, 0xF8, 0x47, 0x17, 0xDB, + 0xA1, 0x01, 0x49, 0x13, 0xAF, 0xF5, 0x1C, 0xC7 + }, + { + 0xC7, 0x9F, 0x19, 0xD0, 0x02, 0x67, 0xD1, 0x3D, + 0xC4, 0x30, 0x19, 0x5F, 0x1F, 0x2E, 0xB2, 0xB1, + 0x62, 0xD0, 0x75, 0xB9, 0x86, 0x76, 0x72, 0x90, + 0x31, 0xC8, 0x05, 0x0C, 0x1B, 0xA0, 0x39, 0x13 + }, + { + 0xE6, 0x1F, 0x04, 0x33, 0x20, 0x8B, 0x39, 0xD3, + 0x1E, 0xB4, 0xA1, 0x88, 0x55, 0x83, 0x2B, 0x14, + 0x02, 0x00, 0x8A, 0xCB, 0x99, 0x77, 0xE3, 0x49, + 0xF5, 0x9C, 0xC3, 0x89, 0xBF, 0xB9, 0x99, 0xD3 + }, + { + 0x6D, 0x7B, 0x55, 0xDA, 0xE0, 0x20, 0x42, 0x45, + 0xC7, 0x7D, 0xD3, 0x7F, 0x6C, 0x73, 0x74, 0x47, + 0x3F, 0x79, 0x35, 0xA0, 0xFF, 0x57, 0x02, 0xED, + 0x62, 0xC3, 0xF9, 0x82, 0xC4, 0x64, 0xF2, 0x03 + }, + { + 0x54, 0x32, 0x32, 0xA7, 0xC2, 0xE9, 0xB8, 0x60, + 0x41, 0x13, 0xBC, 0x55, 0xE7, 0x17, 0x46, 0xF5, + 0xB8, 0xBB, 0xF1, 0x2F, 0x81, 0xCB, 0x76, 0x53, + 0x3F, 0x1E, 0x27, 0x99, 0x3F, 0x8D, 0x2C, 0xBA + }, + { + 0xC0, 0x72, 0x18, 0x86, 0x69, 0xB1, 0xE1, 0x3D, + 0x6F, 0xEA, 0xB4, 0x24, 0x26, 0xA9, 0x5E, 0x5A, + 0x6D, 0x47, 0x89, 0x6A, 0x5B, 0x52, 0x6B, 0x49, + 0xD2, 0xD0, 0x56, 0x4B, 0xBB, 0x8C, 0x46, 0xF3 + }, + { + 0xE2, 0x9A, 0xF0, 0xBE, 0xA1, 0xF5, 0xB0, 0xA9, + 0x48, 0xA0, 0x5A, 0x09, 0xA5, 0xDD, 0xFB, 0xF8, + 0x4D, 0x1F, 0x05, 0x79, 0x1C, 0x8A, 0x31, 0xB6, + 0xB8, 0xCC, 0x29, 0x20, 0xD1, 0xFE, 0x56, 0x88 + }, + { + 0xFE, 0x81, 0x76, 0xD3, 0xBF, 0x2B, 0x4F, 0x32, + 0x18, 0x5A, 0x85, 0xE2, 0x17, 0xDA, 0x60, 0xE7, + 0x5A, 0xA7, 0xEF, 0xDC, 0x6E, 0xCF, 0x9A, 0x3B, + 0x6F, 0x54, 0x83, 0x53, 0x6C, 0xCD, 0xB7, 0xD6 + }, + { + 0x3C, 0xAF, 0x01, 0x9A, 0x53, 0x73, 0x37, 0xC7, + 0xEA, 0x03, 0x4D, 0x29, 0xB4, 0x03, 0x7F, 0x30, + 0x25, 0x71, 0x73, 0x6E, 0xEA, 0xF6, 0x28, 0x69, + 0x22, 0x94, 0x25, 0x6B, 0xF2, 0x39, 0x47, 0xC6 + }, + { + 0xEF, 0xA9, 0x89, 0x36, 0xEA, 0xD0, 0xCE, 0x71, + 0x6B, 0xED, 0xDD, 0x70, 0x1D, 0x9C, 0xDD, 0x86, + 0xA5, 0x41, 0xD5, 0xB2, 0x8A, 0x5D, 0xC0, 0xD7, + 0x71, 0xC5, 0x79, 0xFC, 0x26, 0x71, 0x3F, 0xF3 + }, + { + 0xFF, 0x58, 0x4D, 0xFD, 0xD3, 0x5B, 0x82, 0xE8, + 0x22, 0xF3, 0x57, 0x7C, 0x78, 0x7D, 0xA4, 0x37, + 0x81, 0xCB, 0x9C, 0xB3, 0x26, 0xA6, 0xDA, 0x3B, + 0x68, 0x32, 0x80, 0x8E, 0xAD, 0x4C, 0xA4, 0x24 + }, + { + 0xF6, 0x91, 0xCA, 0xA2, 0x49, 0x79, 0x4B, 0x7D, + 0xD6, 0x7C, 0xC7, 0x3D, 0x54, 0x35, 0x3D, 0xBE, + 0xB9, 0x5C, 0x2D, 0x90, 0x9C, 0x5B, 0x38, 0x52, + 0xF3, 0xC3, 0x84, 0xCB, 0x7D, 0x29, 0x82, 0xCB + }, + { + 0x3B, 0xCA, 0x89, 0x52, 0x7A, 0x01, 0x5C, 0xBA, + 0x9B, 0x4C, 0x9E, 0x90, 0x8D, 0x7B, 0x78, 0x87, + 0x74, 0x4E, 0xF8, 0x7A, 0x41, 0x21, 0x9A, 0x08, + 0xB5, 0x54, 0x61, 0x7D, 0x95, 0x3A, 0xD8, 0x39 + }, + { + 0x59, 0x66, 0x77, 0xA0, 0x15, 0xB5, 0x55, 0x68, + 0x66, 0x91, 0x0A, 0x0F, 0x13, 0xB0, 0x7C, 0xE6, + 0x01, 0x90, 0x47, 0x85, 0x17, 0x34, 0x58, 0x10, + 0xBE, 0xE3, 0xF1, 0x5E, 0x58, 0x4D, 0x3F, 0xB5 + }, + { + 0xA3, 0xDD, 0xC2, 0x39, 0x0F, 0x99, 0x7A, 0xFA, + 0x07, 0x7B, 0xA5, 0x5B, 0x95, 0xFA, 0x73, 0xCC, + 0x12, 0x16, 0xD9, 0x28, 0x9B, 0x33, 0x35, 0xAE, + 0xAF, 0x2F, 0x3B, 0x17, 0x9A, 0x25, 0x1C, 0x3C + }, + { + 0x71, 0xD5, 0xC1, 0xCE, 0x0F, 0x67, 0xE9, 0xC2, + 0x46, 0xD1, 0x5F, 0x13, 0xC1, 0x10, 0x81, 0x06, + 0xB3, 0x40, 0x7C, 0x45, 0x77, 0x2F, 0xB2, 0xC3, + 0xDA, 0xE5, 0x0D, 0x7A, 0x50, 0x31, 0x78, 0x87 + }, + { + 0xDC, 0x6C, 0xE3, 0xFF, 0x60, 0xED, 0x4A, 0x1B, + 0x68, 0x0D, 0x98, 0x91, 0x1D, 0x22, 0x98, 0xAE, + 0x47, 0x27, 0x16, 0x9D, 0x28, 0x6E, 0xB0, 0xD2, + 0xBB, 0xA7, 0x0C, 0x83, 0x74, 0xB0, 0x9B, 0xE9 + }, + { + 0x50, 0xB6, 0xEF, 0xA9, 0x3A, 0x21, 0x1A, 0x8E, + 0xCE, 0xBA, 0x06, 0x03, 0x40, 0xEC, 0x5F, 0xD5, + 0xD1, 0xEF, 0x57, 0xAE, 0xEE, 0x1E, 0x39, 0x72, + 0xC0, 0x04, 0x73, 0xFE, 0x13, 0x1D, 0x44, 0xF6 + }, + { + 0x80, 0xA9, 0x1F, 0x16, 0xBE, 0x4E, 0x29, 0xB4, + 0x5E, 0x01, 0xA8, 0x26, 0x14, 0x3C, 0x00, 0xBB, + 0xBF, 0x95, 0x32, 0xE9, 0x9C, 0x98, 0x1E, 0x5C, + 0x36, 0xE6, 0xE8, 0x38, 0x71, 0xC9, 0xD6, 0xC5 + }, + { + 0x52, 0x22, 0x7C, 0x70, 0x35, 0x51, 0x43, 0x0F, + 0xB6, 0xE7, 0x5A, 0x12, 0x92, 0xDC, 0xE6, 0x96, + 0xB1, 0x73, 0x5F, 0xB1, 0xEB, 0x7F, 0x84, 0x4B, + 0x58, 0x0F, 0x64, 0x9E, 0x69, 0xBD, 0xDA, 0x3D + }, + { + 0xB0, 0x00, 0xFE, 0x4B, 0xA1, 0x97, 0x9F, 0xD9, + 0xC7, 0x5C, 0x69, 0xDE, 0xB0, 0x92, 0xA0, 0x04, + 0x8D, 0xB8, 0x05, 0x00, 0x40, 0x69, 0xBA, 0x33, + 0xC8, 0x0A, 0xDB, 0x87, 0x3A, 0x0B, 0xE2, 0x53 + }, + { + 0x34, 0x73, 0xB9, 0x64, 0x98, 0x6B, 0x33, 0xC3, + 0x43, 0x2C, 0x70, 0xD5, 0x3F, 0x8A, 0xF3, 0x19, + 0xAD, 0xFB, 0x8C, 0x5D, 0x82, 0xAE, 0xF1, 0xB5, + 0x30, 0x99, 0x91, 0x41, 0xC4, 0x0D, 0x1C, 0x96 + }, + { + 0xB4, 0xDA, 0x28, 0x25, 0x9B, 0x47, 0x0C, 0x18, + 0xB2, 0x72, 0xEB, 0x26, 0x5A, 0x85, 0x50, 0x93, + 0x7C, 0x3F, 0xD3, 0xB6, 0x0A, 0x79, 0xE7, 0x26, + 0x30, 0x61, 0x91, 0xE0, 0x29, 0x1B, 0xE8, 0xBF + }, + { + 0xBE, 0x12, 0x8F, 0x2F, 0x8F, 0x02, 0xA7, 0x92, + 0xBF, 0x82, 0xAA, 0x95, 0xE9, 0x04, 0x33, 0xCE, + 0xD5, 0x79, 0xC1, 0x0B, 0xC4, 0xA3, 0xCC, 0xDD, + 0x57, 0xD0, 0x94, 0xDF, 0x98, 0x91, 0x9E, 0x80 + }, + { + 0xEE, 0x83, 0x32, 0x75, 0x47, 0x61, 0x98, 0x98, + 0xC1, 0xA6, 0x95, 0xAC, 0xBD, 0x02, 0x84, 0x31, + 0x34, 0x06, 0x6F, 0x43, 0x29, 0xC7, 0x8C, 0xFC, + 0x67, 0x2A, 0x41, 0x65, 0x20, 0xEA, 0x48, 0x5D + }, + { + 0xBA, 0x7A, 0xFB, 0xBF, 0x30, 0x43, 0x77, 0xD8, + 0x07, 0xC3, 0x21, 0x47, 0xAB, 0x45, 0x84, 0xF1, + 0xD0, 0xA7, 0x74, 0xB4, 0x71, 0x5D, 0x7B, 0x90, + 0xFA, 0x61, 0x55, 0x82, 0x9E, 0x03, 0x36, 0xFA + }, + { + 0xD7, 0x81, 0x45, 0xFE, 0x28, 0x04, 0xE2, 0x37, + 0x15, 0xB7, 0x3A, 0x5A, 0x95, 0x79, 0xC7, 0x6E, + 0xEE, 0xAC, 0x93, 0x27, 0x39, 0xA2, 0x93, 0x26, + 0x33, 0x66, 0x63, 0x11, 0x53, 0x49, 0x76, 0x56 + }, + { + 0x49, 0x94, 0xFB, 0xD7, 0xB2, 0x8B, 0xE7, 0x73, + 0xB3, 0x17, 0xB9, 0x5A, 0x04, 0xF6, 0x0F, 0xDE, + 0xD3, 0x32, 0x35, 0xED, 0x24, 0x1A, 0x2C, 0x02, + 0x0D, 0xE8, 0x91, 0xD7, 0x59, 0x39, 0xF0, 0x55 + }, + { + 0x5F, 0x72, 0xF0, 0xF9, 0x40, 0x6E, 0xCE, 0x8A, + 0x2D, 0x20, 0x84, 0x9A, 0x80, 0x58, 0xB3, 0x4A, + 0x92, 0xA5, 0x94, 0xB5, 0x2C, 0x23, 0xB9, 0xC7, + 0x4F, 0x5C, 0x22, 0x59, 0x1F, 0x7C, 0xF2, 0xAA + }, + { + 0xAE, 0x8B, 0x88, 0x17, 0x5D, 0x75, 0xBE, 0xC2, + 0x52, 0x6E, 0x08, 0x9D, 0xF8, 0x8A, 0x10, 0x3B, + 0xE0, 0x96, 0xDA, 0x5E, 0xDB, 0x48, 0x26, 0x91, + 0x2A, 0xEE, 0xFA, 0x6F, 0x0B, 0x66, 0xCC, 0xEE + }, + { + 0x1E, 0xB0, 0xF4, 0xAC, 0x20, 0xFB, 0x5D, 0x81, + 0xFD, 0x6F, 0xD1, 0xE0, 0xCF, 0xE0, 0xC5, 0xAB, + 0x14, 0xC0, 0xED, 0x1E, 0xF5, 0x3A, 0x39, 0x26, + 0xD7, 0xCC, 0x51, 0xD0, 0x5F, 0xCA, 0x05, 0x15 + }, + { + 0x84, 0xE5, 0xE4, 0x9B, 0x8D, 0x6D, 0xAC, 0xF2, + 0x3A, 0x19, 0xC7, 0x30, 0xE4, 0x94, 0x87, 0x3E, + 0x14, 0xF2, 0x0B, 0xD2, 0x81, 0xF1, 0x1C, 0xFA, + 0x59, 0x0F, 0xE5, 0x01, 0xE1, 0xAE, 0x55, 0xAE + }, + { + 0xE9, 0xD0, 0xF8, 0x00, 0x7C, 0xE5, 0x79, 0x76, + 0x9F, 0xC5, 0xCA, 0x7C, 0x03, 0x33, 0x31, 0x5C, + 0xA0, 0xEB, 0xF9, 0x9A, 0x3D, 0x5D, 0xB2, 0xF8, + 0x4A, 0xDB, 0x38, 0x7C, 0x77, 0xB3, 0x03, 0x29 + }, + { + 0x25, 0x9B, 0x13, 0x93, 0xC5, 0xB4, 0x93, 0x2E, + 0x87, 0x0A, 0x3A, 0x1C, 0x46, 0x9E, 0x6F, 0x99, + 0x50, 0x9D, 0x2E, 0x28, 0xB4, 0x0A, 0x84, 0x12, + 0xCA, 0xA2, 0xC9, 0x0B, 0x4D, 0x2C, 0xFB, 0xF6 + }, + { + 0x47, 0x38, 0xB8, 0x85, 0x38, 0x5E, 0x7E, 0x03, + 0x9F, 0x62, 0x12, 0x35, 0xFE, 0x94, 0x5E, 0xFD, + 0xDC, 0x9B, 0x89, 0xCD, 0x2B, 0xCF, 0xD9, 0xE2, + 0xFC, 0x48, 0x4E, 0x84, 0x86, 0x7C, 0x91, 0x16 + }, + { + 0x07, 0x94, 0x83, 0xF9, 0x7F, 0x1D, 0xEF, 0x0D, + 0x9B, 0xEA, 0x4E, 0xC4, 0xDD, 0x5B, 0xE2, 0xF7, + 0x46, 0x86, 0x64, 0x6D, 0x7C, 0x5D, 0x1C, 0x52, + 0xF3, 0xE4, 0x27, 0x4D, 0xFF, 0x5E, 0x81, 0x94 + }, + { + 0xF5, 0x01, 0x15, 0x9B, 0x99, 0x40, 0xBC, 0x24, + 0x96, 0x7D, 0x6D, 0xC6, 0xE5, 0x2A, 0x65, 0xE9, + 0x64, 0x2F, 0x50, 0x95, 0x16, 0xDC, 0xA3, 0x21, + 0x44, 0xCD, 0x8F, 0x69, 0xD0, 0xED, 0x24, 0xFB + }, + { + 0xB7, 0x5F, 0xD4, 0x7C, 0xDD, 0x85, 0xB1, 0xB5, + 0x32, 0xE6, 0xCC, 0x6D, 0x04, 0x29, 0x2A, 0x9A, + 0xBF, 0x74, 0x17, 0xCE, 0xBC, 0x5D, 0x97, 0x0E, + 0xE2, 0xC9, 0x5A, 0xBB, 0x80, 0xD4, 0x4A, 0x8D + }, + { + 0x7C, 0xB3, 0x6F, 0x88, 0x9E, 0x95, 0xAB, 0x25, + 0xDB, 0xB1, 0xF5, 0xF6, 0xBD, 0x6C, 0x13, 0xF7, + 0xAB, 0xCA, 0x7C, 0xC4, 0x62, 0xDC, 0x6F, 0xEE, + 0x6C, 0x6A, 0xE1, 0xAE, 0x77, 0x3A, 0x35, 0xD4 + }, + { + 0xC6, 0xE2, 0x7F, 0x3E, 0x6E, 0x67, 0xCA, 0x48, + 0xA0, 0xDC, 0xDD, 0x0F, 0x69, 0xE2, 0x2D, 0xD4, + 0x6B, 0xCC, 0xCD, 0xFF, 0x7F, 0x30, 0x01, 0x8F, + 0xC2, 0x2E, 0x41, 0xD2, 0x37, 0xA1, 0xA3, 0x73 + }, + { + 0x70, 0x0F, 0x32, 0x03, 0xAB, 0x8C, 0x41, 0x66, + 0xFE, 0x8F, 0x81, 0xC4, 0xCB, 0xC2, 0xE3, 0xE0, + 0x04, 0x3B, 0xA6, 0x5B, 0x3B, 0x0A, 0xB5, 0x6F, + 0xA9, 0xC0, 0xAC, 0x8C, 0xA4, 0xF2, 0xE6, 0x42 + }, + { + 0x9C, 0x96, 0x32, 0xEA, 0xE6, 0x8F, 0x79, 0x3B, + 0x9B, 0xD5, 0xB2, 0x42, 0xBE, 0xBE, 0xAA, 0x72, + 0xAA, 0x3F, 0x4C, 0xA8, 0xC3, 0xCE, 0x6B, 0x51, + 0x70, 0xB0, 0xAB, 0x93, 0x2B, 0xD3, 0xFA, 0x00 + }, + { + 0x25, 0x77, 0xC8, 0xB2, 0xC5, 0x80, 0x95, 0x17, + 0x07, 0x39, 0x6A, 0x9C, 0x3F, 0xD3, 0x20, 0x2C, + 0x7C, 0x89, 0x36, 0x7E, 0x82, 0xEE, 0x34, 0xF3, + 0xF9, 0xFB, 0xB7, 0xB5, 0x38, 0xE8, 0x61, 0xD5 + }, + { + 0x0A, 0x8E, 0x4E, 0x73, 0x8C, 0x99, 0xBA, 0xBA, + 0x1E, 0xCC, 0x32, 0xB2, 0x6F, 0x9D, 0x8D, 0xFA, + 0xA6, 0x18, 0x78, 0x5D, 0x08, 0x71, 0x5B, 0xD9, + 0xE5, 0x39, 0xFC, 0x43, 0xE2, 0x92, 0xBE, 0x11 + }, + { + 0x47, 0x91, 0xBF, 0x70, 0xE3, 0x7E, 0x29, 0xFF, + 0xA8, 0x21, 0x0E, 0x02, 0xD3, 0xC1, 0x53, 0x56, + 0xFA, 0x98, 0x23, 0x3D, 0xCE, 0xA6, 0x4A, 0x93, + 0xA1, 0xB3, 0x54, 0x9E, 0x76, 0x9C, 0x34, 0xC0 + }, + { + 0x41, 0x7D, 0xC9, 0x1A, 0x54, 0xBC, 0x7B, 0x59, + 0xC4, 0xA6, 0x6C, 0x25, 0x31, 0xD3, 0x25, 0xAE, + 0x48, 0x3C, 0x6E, 0x5D, 0x79, 0x08, 0x22, 0xA3, + 0x9C, 0xC5, 0xCE, 0xB9, 0x2D, 0x87, 0x20, 0x8F + }, + { + 0x91, 0x53, 0xC5, 0x49, 0x6A, 0xEA, 0xA9, 0x13, + 0x57, 0x10, 0xA5, 0x75, 0xD9, 0x68, 0x58, 0x04, + 0xE3, 0xB4, 0x40, 0xF1, 0xA7, 0x85, 0x12, 0x87, + 0xF4, 0x57, 0x3E, 0x24, 0x4C, 0x29, 0xAE, 0x80 + }, + { + 0x3C, 0x59, 0xBE, 0xB7, 0x8C, 0xA1, 0x2E, 0xD5, + 0x70, 0xC5, 0x43, 0x36, 0x0A, 0x4C, 0x13, 0xCC, + 0x74, 0xE7, 0x4F, 0x9F, 0x58, 0xE6, 0xEA, 0x26, + 0x77, 0x6F, 0x40, 0x82, 0xAB, 0x1C, 0xAE, 0xE6 + }, + { + 0xE4, 0x10, 0x4B, 0x55, 0x3E, 0x83, 0xF7, 0xE5, + 0xE2, 0x5D, 0x64, 0x5B, 0x78, 0xE1, 0x7E, 0x71, + 0xF5, 0x05, 0xC6, 0xE5, 0x54, 0x89, 0x3D, 0x41, + 0x36, 0xAC, 0xB9, 0xFB, 0xC9, 0xDC, 0x9B, 0x7C + }, + { + 0x36, 0x94, 0xBE, 0x2F, 0x1E, 0xA5, 0x99, 0x2A, + 0x98, 0x26, 0xB9, 0x2B, 0x54, 0x93, 0xD1, 0x26, + 0xF4, 0x3C, 0x94, 0x14, 0xD0, 0x12, 0x3C, 0x61, + 0x96, 0x67, 0xEA, 0xF2, 0xF3, 0x7F, 0x97, 0x0F + }, + { + 0xBA, 0x75, 0xB9, 0x9B, 0xC0, 0x4B, 0x47, 0xE6, + 0xE6, 0x4C, 0x14, 0x40, 0xD8, 0x20, 0x7A, 0x44, + 0x6E, 0xCE, 0x9F, 0x70, 0x41, 0xCC, 0x7F, 0xCF, + 0x7B, 0x82, 0x89, 0xC9, 0xE9, 0xD3, 0xBE, 0xF4 + }, + { + 0x05, 0xFF, 0x87, 0x00, 0x31, 0x12, 0x57, 0x53, + 0x75, 0x5F, 0xDA, 0xD3, 0xB5, 0xF8, 0x0C, 0x14, + 0x1D, 0xCC, 0x7D, 0x47, 0x54, 0x2B, 0x5D, 0x58, + 0x29, 0xB8, 0x9B, 0x03, 0x30, 0xBB, 0x07, 0x88 + }, + { + 0xBC, 0xBF, 0x4F, 0x96, 0x02, 0x41, 0xB5, 0xAD, + 0x90, 0x05, 0x6C, 0x09, 0xF4, 0xF8, 0xB5, 0xE8, + 0x2D, 0xE6, 0x96, 0x4A, 0xF1, 0xDF, 0x6F, 0xB4, + 0x2A, 0x06, 0x28, 0xB8, 0xE9, 0xBC, 0x56, 0x6D + }, + { + 0xEF, 0x05, 0xB4, 0x22, 0xB8, 0x0D, 0x91, 0xB0, + 0x64, 0x93, 0xC5, 0xDE, 0x54, 0xB3, 0xEF, 0x05, + 0x1B, 0x2D, 0xCD, 0x8C, 0x8F, 0xF5, 0xA8, 0x9B, + 0xBE, 0x33, 0xC2, 0x2B, 0x62, 0xDF, 0xE6, 0x31 + }, + { + 0x1E, 0x05, 0xDB, 0x5A, 0x54, 0xA9, 0x53, 0x99, + 0xAC, 0x54, 0x71, 0x1E, 0xA3, 0x3F, 0x78, 0x9F, + 0x53, 0x85, 0xEC, 0x19, 0x86, 0xF3, 0x1F, 0x42, + 0xC3, 0x35, 0x45, 0x0D, 0x8B, 0xC3, 0x02, 0x03 + }, + { + 0x01, 0x05, 0x64, 0xD7, 0x5B, 0x86, 0x3C, 0x6F, + 0x69, 0x8B, 0xA5, 0xB7, 0x8C, 0x96, 0x86, 0x41, + 0x64, 0x86, 0x06, 0x9F, 0x69, 0x8C, 0xE0, 0x53, + 0x2A, 0x70, 0xEE, 0x7D, 0x0E, 0x11, 0x47, 0x25 + }, + { + 0x50, 0x7A, 0x73, 0x4F, 0x14, 0x48, 0x8A, 0x78, + 0x88, 0x47, 0x0B, 0xB4, 0x34, 0xC1, 0xD4, 0xCA, + 0x6A, 0x13, 0x2E, 0xAD, 0x53, 0xC6, 0x7C, 0x15, + 0x46, 0x10, 0x5D, 0xBD, 0x4F, 0x34, 0x0F, 0x45 + }, + { + 0xB2, 0xED, 0xE9, 0x72, 0x28, 0x58, 0x72, 0x05, + 0x08, 0xAC, 0x56, 0xD8, 0xFC, 0x59, 0xCD, 0xB5, + 0x44, 0x0D, 0xBF, 0xE0, 0x17, 0x37, 0x39, 0x85, + 0x24, 0xEF, 0xFF, 0xB6, 0x93, 0xF6, 0x45, 0xE5 + }, + { + 0x95, 0x19, 0x26, 0xBD, 0x32, 0x2E, 0x5F, 0x51, + 0x49, 0xD8, 0x65, 0x44, 0xDE, 0xEF, 0x88, 0x51, + 0xD7, 0x85, 0x48, 0x15, 0x44, 0x65, 0x52, 0x3E, + 0xC8, 0x1D, 0x04, 0x2F, 0xE7, 0x11, 0x79, 0x33 + }, + { + 0xE2, 0x60, 0xD1, 0x5A, 0xD2, 0x4D, 0xAA, 0x04, + 0xE2, 0x4B, 0x6E, 0x33, 0x69, 0xE4, 0x92, 0xC3, + 0x26, 0xBD, 0xC8, 0xAD, 0x0F, 0x89, 0x32, 0x8D, + 0x72, 0x8C, 0x95, 0xF4, 0xBF, 0xBC, 0x4D, 0x96 + }, + { + 0x7A, 0x42, 0xC5, 0x32, 0xC8, 0x37, 0x3C, 0x2A, + 0x50, 0x93, 0x09, 0xE5, 0x1F, 0x11, 0x96, 0x5D, + 0xCC, 0xBB, 0x33, 0xB4, 0x8D, 0x95, 0xA3, 0x85, + 0x60, 0x79, 0x65, 0x50, 0xE7, 0x81, 0x0F, 0xC3 + }, + { + 0xE5, 0x97, 0x89, 0x5C, 0x4E, 0xAE, 0xB9, 0xCA, + 0x47, 0xAA, 0xAE, 0x7D, 0xBE, 0x70, 0x1D, 0xAA, + 0x0E, 0x0D, 0x8F, 0xAA, 0x34, 0xB1, 0x2A, 0x1B, + 0x64, 0xCE, 0xB2, 0xCD, 0x6E, 0x0D, 0xCE, 0x61 + }, + { + 0x18, 0xDA, 0x81, 0x7F, 0xDE, 0x72, 0x98, 0xD0, + 0x6E, 0x0A, 0x01, 0x29, 0x82, 0x35, 0x7A, 0xD1, + 0xF3, 0x6D, 0x69, 0xAD, 0x25, 0x6F, 0x0B, 0x3D, + 0xDC, 0x7C, 0xFA, 0x44, 0x0D, 0xE7, 0x7F, 0xFD + }, + { + 0x38, 0x0D, 0xB1, 0xF5, 0x7E, 0xEF, 0x73, 0x5E, + 0x4B, 0x4C, 0x4D, 0xAF, 0x3A, 0x41, 0x15, 0xF6, + 0x49, 0x3F, 0x36, 0xF5, 0x80, 0xC1, 0xF8, 0xFC, + 0xD4, 0x1B, 0xA7, 0x95, 0x50, 0x34, 0x98, 0x11 + }, + { + 0x8B, 0x78, 0xE6, 0x13, 0x71, 0xBC, 0x58, 0x61, + 0xDC, 0x53, 0xA9, 0xCD, 0x11, 0x57, 0x55, 0x6C, + 0x18, 0xFD, 0xD9, 0x9E, 0xDF, 0x34, 0x82, 0xC6, + 0x93, 0x38, 0x9A, 0x0F, 0xC7, 0x4D, 0xA4, 0xB1 + }, + { + 0xDE, 0x2F, 0xAE, 0xA6, 0xCE, 0xB0, 0x07, 0xC5, + 0x91, 0xED, 0x5B, 0xDC, 0xDF, 0xD0, 0x81, 0xFC, + 0xC0, 0x2B, 0xFE, 0x63, 0x81, 0xAA, 0xB0, 0x4F, + 0xAD, 0xCC, 0x69, 0xA7, 0xC0, 0xAF, 0x96, 0x57 + }, + { + 0x70, 0x2E, 0x9F, 0x29, 0xFE, 0x5E, 0x9D, 0xE7, + 0x72, 0x34, 0x65, 0x7E, 0x64, 0xBF, 0x0B, 0xC3, + 0x76, 0x22, 0x4E, 0x60, 0x7E, 0xA7, 0xB8, 0xF7, + 0xB5, 0xF9, 0x98, 0xE0, 0xE6, 0xBA, 0x68, 0x9B + }, + { + 0xC9, 0xCD, 0x34, 0x69, 0x3C, 0x06, 0x13, 0xE8, + 0xDF, 0x44, 0xC4, 0x76, 0xE9, 0x94, 0xE4, 0x6E, + 0x5D, 0x4D, 0xD0, 0x58, 0xF8, 0x9A, 0xB9, 0xF4, + 0x89, 0xC7, 0x7D, 0xCD, 0xE0, 0xFD, 0x3B, 0xB6 + }, + { + 0xA5, 0x6B, 0xF9, 0x45, 0xA7, 0x6E, 0xE3, 0xE3, + 0x5D, 0xC6, 0x45, 0x55, 0xD0, 0x71, 0x80, 0x7C, + 0xE8, 0xCA, 0x74, 0xB2, 0x40, 0xCC, 0x45, 0xC8, + 0xD2, 0xD5, 0xC2, 0x4E, 0x44, 0x16, 0x24, 0x2A + }, + { + 0x17, 0x1F, 0x75, 0xE5, 0xEE, 0xAD, 0x4C, 0x6A, + 0x04, 0xF7, 0x55, 0x29, 0x98, 0x43, 0x2D, 0x36, + 0xCD, 0xF6, 0xFD, 0x95, 0xC0, 0xF6, 0xBA, 0x73, + 0xF4, 0x73, 0x90, 0xB2, 0x26, 0x9B, 0xC1, 0x21 + }, + { + 0x5E, 0x96, 0x96, 0xA2, 0xA9, 0x6A, 0x12, 0x2D, + 0xC8, 0xFC, 0x0C, 0x85, 0x02, 0xA2, 0x88, 0x58, + 0x25, 0xE1, 0x5F, 0xDB, 0x66, 0xCA, 0xEC, 0x57, + 0x7B, 0x4A, 0x0D, 0xE1, 0x61, 0x08, 0x0E, 0x75 + }, + { + 0x1B, 0x88, 0x17, 0x16, 0xAC, 0x7A, 0xF0, 0x10, + 0x81, 0x7C, 0x9D, 0xB2, 0x03, 0x0A, 0x89, 0xD5, + 0x5B, 0x1C, 0x4B, 0xF2, 0x3B, 0xE6, 0x19, 0x7E, + 0xA0, 0x96, 0x42, 0x0E, 0x9F, 0xBC, 0xF2, 0x5A + }, + { + 0x6D, 0x2A, 0x7B, 0x3D, 0x8F, 0xB8, 0x1A, 0x22, + 0x50, 0x7E, 0x3B, 0xCE, 0xED, 0xBA, 0x33, 0x8B, + 0x36, 0x92, 0x21, 0x3A, 0x5E, 0x4F, 0xBA, 0xD5, + 0x81, 0xBE, 0xE5, 0x61, 0xE3, 0x76, 0xE1, 0xE3 + }, + { + 0x37, 0x89, 0xA2, 0x92, 0x91, 0x70, 0x5F, 0xF0, + 0x80, 0x3D, 0x5A, 0x79, 0x23, 0xAD, 0x4A, 0x4B, + 0x50, 0xEB, 0x84, 0x50, 0x63, 0x66, 0xA9, 0xEF, + 0xDB, 0xB0, 0x25, 0xF8, 0x4B, 0xE5, 0x7A, 0x60 + }, + { + 0x52, 0xCE, 0xA2, 0x8A, 0x42, 0x7C, 0x15, 0x11, + 0x4E, 0xB3, 0x4C, 0x32, 0x17, 0xA1, 0x0C, 0x0E, + 0x67, 0xE8, 0x4D, 0x9D, 0x3F, 0xC4, 0x39, 0x4D, + 0x39, 0x30, 0x73, 0x9F, 0x81, 0x4F, 0x09, 0x43 + }, + { + 0xDB, 0x55, 0x04, 0x98, 0xAD, 0x97, 0xF8, 0x93, + 0x04, 0x6D, 0x39, 0x1E, 0xC0, 0x01, 0xD7, 0x36, + 0x92, 0xFB, 0x54, 0x4C, 0x27, 0x52, 0xF9, 0x58, + 0x46, 0xDF, 0xC9, 0x93, 0x8D, 0xF9, 0xD2, 0xAC + }, + { + 0xDC, 0x1B, 0x60, 0xAD, 0xF1, 0x9C, 0xBB, 0x10, + 0x84, 0xCA, 0xF1, 0x99, 0xD5, 0xEE, 0xC7, 0x80, + 0x3E, 0xE4, 0x92, 0x13, 0x3C, 0x4B, 0xD4, 0x4D, + 0x77, 0xBE, 0xEC, 0xD3, 0xB0, 0x5A, 0x90, 0x30 + }, + { + 0xB9, 0xB3, 0xD4, 0x7E, 0x02, 0x61, 0x20, 0x9B, + 0x8D, 0x44, 0x27, 0xA4, 0x8A, 0xFD, 0x4E, 0xCE, + 0xC9, 0xF4, 0x41, 0xC2, 0xC8, 0x2B, 0x27, 0x73, + 0x6A, 0x1D, 0x07, 0x91, 0xB7, 0xA4, 0x7C, 0xCF + }, + { + 0x41, 0xAE, 0x7C, 0x24, 0x07, 0xC5, 0x69, 0xD7, + 0x72, 0x80, 0xF6, 0xDE, 0x3F, 0x68, 0x4F, 0xDB, + 0x73, 0x86, 0xFB, 0x03, 0x19, 0x33, 0x5F, 0x5F, + 0x79, 0x17, 0x08, 0x8C, 0xCA, 0xCE, 0x47, 0x8D + }, + { + 0x4F, 0x0A, 0x79, 0xD7, 0xAC, 0xF8, 0xC7, 0xBC, + 0xD8, 0x49, 0x92, 0x78, 0x88, 0xD2, 0x83, 0xB9, + 0x4D, 0x98, 0xA1, 0xA1, 0xF1, 0xD7, 0xC6, 0x8C, + 0x09, 0x72, 0x31, 0x0C, 0xA2, 0x44, 0x5E, 0xF2 + }, + { + 0xA0, 0x24, 0x74, 0x53, 0x50, 0x07, 0x32, 0x44, + 0x35, 0x6A, 0xCA, 0x52, 0xC5, 0x84, 0x84, 0x7E, + 0xCE, 0x7A, 0x83, 0x99, 0x56, 0x4A, 0xB4, 0xAD, + 0xD0, 0x86, 0xF7, 0xC9, 0xAF, 0xF9, 0x64, 0x44 + }, + { + 0x36, 0x6E, 0x3E, 0x59, 0x6F, 0x05, 0x9C, 0x55, + 0x4E, 0x6F, 0xF0, 0x04, 0xB2, 0x88, 0x27, 0xB2, + 0x15, 0xBF, 0x36, 0xC6, 0x5E, 0x50, 0xD5, 0x0C, + 0x3E, 0xA7, 0xE4, 0xA6, 0x8B, 0x8B, 0x30, 0x1D + }, + { + 0xB4, 0xC5, 0x95, 0x95, 0x1D, 0xB9, 0x67, 0x23, + 0x24, 0x37, 0x47, 0x57, 0xE2, 0x76, 0x8B, 0xAA, + 0x1D, 0xFF, 0x10, 0x3D, 0xE7, 0x92, 0x10, 0x5E, + 0x60, 0x87, 0x95, 0x38, 0xEE, 0x89, 0x9B, 0x46 + }, + { + 0x8F, 0x6B, 0x0A, 0xCE, 0x7E, 0x41, 0x5D, 0x88, + 0xF4, 0xFF, 0xD4, 0x70, 0xC5, 0x61, 0x9A, 0x7D, + 0xA0, 0x6E, 0xB8, 0x80, 0x8C, 0x5D, 0xD5, 0xA7, + 0x74, 0x36, 0x97, 0xB7, 0x7A, 0xF6, 0x9D, 0xE5 + }, + { + 0x06, 0xD5, 0xA2, 0xB9, 0x40, 0xD2, 0x63, 0x8F, + 0xF9, 0x40, 0xAB, 0x8E, 0x68, 0xD9, 0x50, 0x8A, + 0x7C, 0x8E, 0xD7, 0xEF, 0xCE, 0x55, 0xD6, 0x3F, + 0x5F, 0xD6, 0xFE, 0xA3, 0x5A, 0x21, 0xC1, 0x07 + }, + { + 0x76, 0xD1, 0x25, 0x5E, 0xAC, 0x30, 0xC2, 0x57, + 0xDE, 0x67, 0xA9, 0x24, 0xC8, 0x09, 0x36, 0x51, + 0x27, 0xBB, 0x0C, 0x73, 0x42, 0x0E, 0xFA, 0xFE, + 0x60, 0x6D, 0x93, 0x2C, 0xB1, 0x82, 0x70, 0x46 + }, + { + 0x4C, 0x2C, 0xEE, 0x1E, 0x73, 0x26, 0x29, 0x22, + 0x43, 0x92, 0x7E, 0xB5, 0x3E, 0xB7, 0x31, 0x2E, + 0x27, 0x3B, 0x16, 0x62, 0x46, 0x3E, 0x88, 0x25, + 0xEE, 0xBC, 0x7F, 0xF4, 0x87, 0xDF, 0xD8, 0xD6 + }, + { + 0x0B, 0x81, 0xFF, 0xF2, 0xC2, 0x25, 0x5C, 0xF4, + 0xD6, 0xFB, 0x67, 0xE4, 0xD6, 0x23, 0x2B, 0x7A, + 0x39, 0x09, 0x86, 0x08, 0x86, 0xA9, 0x7D, 0xE3, + 0x7C, 0x8E, 0xAE, 0xD3, 0x3A, 0xE7, 0xE5, 0xCD + }, + { + 0x4A, 0xC1, 0xF7, 0x16, 0xF7, 0xE5, 0x71, 0x70, + 0xD0, 0xDF, 0x3E, 0x17, 0x4A, 0xCE, 0xFA, 0x39, + 0x0A, 0xAF, 0xB0, 0xEF, 0x0C, 0x24, 0xE4, 0x3B, + 0x24, 0x17, 0x6C, 0xEF, 0xB2, 0x2E, 0xA7, 0xFF + }, + { + 0xD1, 0x99, 0x88, 0x8F, 0xA8, 0xF9, 0x62, 0xA5, + 0xD5, 0x80, 0x12, 0x40, 0x02, 0x57, 0x4B, 0x06, + 0x61, 0xAA, 0xDC, 0xCF, 0x81, 0x68, 0xF6, 0xD0, + 0x88, 0x2F, 0x5C, 0xC2, 0xFE, 0x51, 0xAB, 0x7E + }, + { + 0xCF, 0x28, 0x80, 0xDB, 0x9E, 0x01, 0xFB, 0xB2, + 0x47, 0x22, 0x19, 0x3B, 0xD6, 0x9B, 0x4F, 0x20, + 0x95, 0x5A, 0x67, 0xE3, 0x79, 0xA1, 0x50, 0x14, + 0x40, 0x45, 0xA0, 0xE6, 0x6F, 0xE1, 0x0B, 0x54 + }, + { + 0x39, 0x0D, 0x89, 0xC4, 0xE6, 0x84, 0xF2, 0xA2, + 0xC4, 0x23, 0x74, 0x0C, 0x98, 0xA9, 0xA2, 0xF0, + 0x97, 0x67, 0x22, 0x31, 0x1F, 0xAE, 0xD9, 0xB9, + 0x9B, 0x4F, 0x68, 0x9D, 0x7E, 0x5F, 0xA6, 0xF9 + }, + { + 0xA7, 0x36, 0x6E, 0xCB, 0xE4, 0x93, 0xF6, 0xD1, + 0xAF, 0x44, 0x17, 0x6C, 0xC5, 0x97, 0x43, 0x9B, + 0x9A, 0x1C, 0x71, 0xBB, 0x69, 0x6E, 0xF0, 0xA2, + 0x8C, 0x87, 0x79, 0x2A, 0xC9, 0x6C, 0x15, 0xFB + }, + { + 0xF6, 0x6B, 0x37, 0x1A, 0x09, 0xE9, 0x3A, 0x34, + 0x5D, 0x06, 0x23, 0x0B, 0xD3, 0x0A, 0x07, 0x6F, + 0x8B, 0x61, 0x66, 0xEA, 0x64, 0x58, 0x5E, 0x1E, + 0x2C, 0x49, 0xDE, 0xED, 0xAE, 0x3A, 0xA6, 0xDC + }, + { + 0xD0, 0x2E, 0x40, 0xA2, 0x02, 0x00, 0xE1, 0x33, + 0xF8, 0x0E, 0x0E, 0xA1, 0x45, 0x57, 0x09, 0xDF, + 0xAE, 0x80, 0x19, 0xB8, 0x59, 0xF5, 0xDA, 0xA7, + 0xDF, 0x4F, 0xB0, 0x12, 0x53, 0x10, 0x6D, 0x06 + }, + { + 0xAC, 0x93, 0x46, 0x58, 0x07, 0xFE, 0x29, 0xFD, + 0x71, 0x06, 0xE0, 0x91, 0xF7, 0x44, 0x87, 0x1F, + 0x50, 0xAB, 0x17, 0xCA, 0x11, 0xC0, 0xDE, 0x27, + 0xE4, 0x1B, 0x02, 0xF2, 0x65, 0x36, 0x17, 0x90 + }, + { + 0x76, 0xF5, 0xC9, 0x66, 0x92, 0x74, 0xA8, 0x70, + 0x6B, 0x32, 0x41, 0x07, 0x7A, 0xB9, 0x1D, 0x8B, + 0x92, 0x38, 0x7E, 0xEC, 0xC4, 0x48, 0xDE, 0x3A, + 0xA9, 0x40, 0xD3, 0xC6, 0xB5, 0xFC, 0x86, 0x9E + }, + { + 0xBB, 0xDB, 0x70, 0x8A, 0xA1, 0x0B, 0xEC, 0x92, + 0x7A, 0x4F, 0xF7, 0x4C, 0xA2, 0x3C, 0x13, 0xA2, + 0x78, 0xBE, 0xF3, 0xE6, 0x44, 0x47, 0xA4, 0x0F, + 0x1E, 0xE2, 0xB5, 0x93, 0x52, 0x3F, 0x91, 0x3A + }, + { + 0x69, 0x6D, 0xBC, 0x6E, 0xF1, 0xE4, 0x56, 0x36, + 0x97, 0x87, 0x3E, 0xF0, 0x34, 0xA2, 0x31, 0x34, + 0xD9, 0xED, 0x49, 0x5E, 0x21, 0x3C, 0xC2, 0xB9, + 0x29, 0xB0, 0x0B, 0x68, 0x3F, 0x75, 0x13, 0x9B + }, + { + 0x26, 0x40, 0x28, 0x37, 0x03, 0xB4, 0x67, 0x8F, + 0x3D, 0x10, 0x5A, 0x66, 0x5B, 0xD7, 0x80, 0xEE, + 0x00, 0x21, 0x5F, 0x2F, 0x89, 0x7C, 0xE0, 0x34, + 0x91, 0x35, 0x87, 0x47, 0xE4, 0xBD, 0xD4, 0x8F + }, + { + 0x16, 0xFC, 0x52, 0x73, 0x21, 0x27, 0xAB, 0xBE, + 0x34, 0xD9, 0xAC, 0xBE, 0x53, 0x52, 0x6F, 0x15, + 0xD0, 0x8A, 0x68, 0xB3, 0x50, 0x65, 0x22, 0x45, + 0xE3, 0x84, 0xB6, 0xF7, 0x93, 0x70, 0x6D, 0x4E + }, + { + 0x43, 0x65, 0xBB, 0xCC, 0xAC, 0x2D, 0xA9, 0x66, + 0xE9, 0xAF, 0xE3, 0xA4, 0xAA, 0x30, 0x13, 0x66, + 0xCB, 0x43, 0xE3, 0x16, 0x58, 0xC9, 0x4B, 0x0A, + 0x88, 0x4B, 0xE8, 0x81, 0x2F, 0xA1, 0x8A, 0x21 + }, + { + 0x38, 0xAE, 0xC7, 0x68, 0xF5, 0x98, 0xEA, 0xE8, + 0x22, 0x8A, 0x47, 0x38, 0xDF, 0x67, 0x82, 0xAA, + 0xEF, 0x19, 0xCB, 0x0B, 0x78, 0x85, 0xE9, 0xA5, + 0xA5, 0x90, 0xA9, 0x3A, 0x81, 0x97, 0xA4, 0x3C + }, + { + 0x58, 0xB4, 0xB5, 0xB6, 0x21, 0xD4, 0x1D, 0x4E, + 0x6B, 0x43, 0xDF, 0xBE, 0xA1, 0xDC, 0xBE, 0xB5, + 0x2C, 0x7D, 0x58, 0x84, 0x34, 0x08, 0x59, 0x33, + 0x86, 0x77, 0x76, 0x1E, 0xF3, 0x65, 0xCD, 0x5B + }, + { + 0x35, 0x5F, 0xEE, 0x99, 0xAC, 0xAA, 0x6C, 0x72, + 0xB7, 0xC8, 0x4E, 0x25, 0x85, 0xA4, 0x26, 0xAC, + 0x18, 0x2D, 0x2A, 0x79, 0x88, 0x14, 0x2C, 0xD7, + 0x1C, 0xDE, 0x2A, 0x12, 0x0E, 0x83, 0xAA, 0xA6 + }, + { + 0x6A, 0x79, 0x52, 0x13, 0x8D, 0xAA, 0xF1, 0x84, + 0x2B, 0x17, 0x3B, 0x90, 0x0A, 0xA9, 0xC2, 0x2F, + 0xA6, 0x4F, 0x7E, 0x34, 0xA0, 0xFA, 0x00, 0x64, + 0x85, 0xB6, 0x75, 0x97, 0x48, 0x8F, 0x65, 0x37 + }, + { + 0xAC, 0x09, 0xE3, 0x84, 0xA7, 0x96, 0xE8, 0x68, + 0xB1, 0xE5, 0x74, 0x2A, 0x1E, 0x57, 0xA1, 0xFB, + 0x04, 0xCC, 0x0A, 0x48, 0x99, 0x59, 0x54, 0xF9, + 0x6E, 0xE7, 0xEB, 0x99, 0xA8, 0x1D, 0x9F, 0x75 + }, + { + 0x5E, 0x13, 0x8B, 0x80, 0x18, 0x7F, 0xE1, 0x9B, + 0x82, 0x2A, 0xC8, 0x72, 0x49, 0xFA, 0xB0, 0x3C, + 0x72, 0xDD, 0xF4, 0x36, 0x34, 0xC4, 0x6E, 0x98, + 0xB3, 0x98, 0x89, 0x08, 0x8E, 0xD5, 0x8C, 0x36 + }, + { + 0x69, 0x6D, 0xC1, 0x08, 0x44, 0x8B, 0xA4, 0xDA, + 0x32, 0xE7, 0xF4, 0x07, 0x1C, 0x34, 0x66, 0x4E, + 0xFE, 0xE9, 0xE8, 0x5D, 0xA5, 0xF7, 0xAA, 0xD1, + 0x79, 0xCF, 0xA7, 0x92, 0x26, 0xC0, 0x03, 0x23 + }, + { + 0x1F, 0x03, 0xE7, 0xD7, 0x60, 0xC9, 0x38, 0x90, + 0xA8, 0x4C, 0x4B, 0xED, 0x7D, 0x19, 0x35, 0x39, + 0xC8, 0xC7, 0x39, 0xF5, 0x4A, 0x1D, 0x2E, 0x04, + 0x69, 0x33, 0x71, 0xBC, 0xFD, 0x2D, 0x83, 0x6C + }, + { + 0xFB, 0x80, 0x75, 0x53, 0x97, 0x7F, 0x95, 0x1E, + 0xF0, 0x0B, 0xAC, 0x50, 0x2C, 0x70, 0x49, 0x1F, + 0x41, 0xDD, 0x7E, 0x46, 0x50, 0x2D, 0x77, 0x25, + 0xA8, 0x5C, 0x15, 0xCB, 0x2A, 0xAE, 0x5D, 0x8E + }, + { + 0x0D, 0xA0, 0x96, 0x02, 0xE2, 0x1F, 0x8F, 0x87, + 0xF5, 0x58, 0x97, 0xCD, 0xF1, 0x53, 0xEE, 0xC2, + 0x0A, 0x51, 0x89, 0xB6, 0x51, 0x7A, 0x04, 0xD3, + 0xFF, 0x0D, 0x3C, 0x66, 0x5C, 0xAC, 0xAB, 0xB5 + }, + { + 0x71, 0xFD, 0x10, 0xF2, 0xD1, 0x89, 0x79, 0x28, + 0x19, 0x79, 0x78, 0x66, 0x27, 0xF5, 0x86, 0xC3, + 0x74, 0xB1, 0x86, 0x19, 0x9A, 0x49, 0xAB, 0x0B, + 0xA4, 0x42, 0x6F, 0x7B, 0x3D, 0x33, 0xD5, 0x52 + }, + { + 0x79, 0x32, 0xAC, 0x70, 0x26, 0xAC, 0x90, 0x5B, + 0x3D, 0xAB, 0xD3, 0x33, 0x5C, 0x92, 0x2C, 0x3C, + 0x86, 0x65, 0xC3, 0xE1, 0x81, 0xBD, 0xF6, 0x6D, + 0xD6, 0x90, 0xE4, 0xDF, 0xA9, 0x59, 0xB7, 0xA1 + }, + { + 0x07, 0xAA, 0xFC, 0x7B, 0x58, 0x7E, 0x51, 0x77, + 0xBA, 0xAF, 0x56, 0x46, 0xFF, 0xF4, 0x75, 0x1F, + 0x62, 0x72, 0x5F, 0xC2, 0xF2, 0xD5, 0xB6, 0x22, + 0xBB, 0x6A, 0xBD, 0xE5, 0xB5, 0x5A, 0xA8, 0x8F + }, + { + 0xC0, 0xC7, 0xAA, 0xF9, 0x27, 0x71, 0x78, 0xF9, + 0x3C, 0x01, 0x9C, 0x64, 0x70, 0x0D, 0xBA, 0xDF, + 0x5E, 0x9D, 0x0D, 0x91, 0xCC, 0x7B, 0xCB, 0xD6, + 0x06, 0x8C, 0x95, 0xB4, 0xE2, 0xE9, 0xB8, 0x47 + }, + { + 0xD9, 0xBB, 0x44, 0xE6, 0x0C, 0x5D, 0x66, 0x21, + 0x2A, 0x8A, 0xA8, 0x4B, 0x3E, 0x64, 0xCE, 0x65, + 0x3A, 0xD0, 0x62, 0x9F, 0x59, 0x09, 0x69, 0xAD, + 0x40, 0x7F, 0x2F, 0x47, 0x2C, 0xB9, 0x60, 0x9D + }, + { + 0x92, 0x4A, 0xB6, 0x2E, 0xD3, 0x42, 0x7A, 0x55, + 0x5D, 0x99, 0xFF, 0x25, 0x93, 0x8F, 0x8A, 0xC3, + 0x74, 0x26, 0x2E, 0xAA, 0xD8, 0x13, 0xD9, 0x62, + 0x83, 0xEB, 0xD0, 0xD7, 0xB1, 0x6E, 0xAD, 0x69 + }, + { + 0xDC, 0x39, 0x38, 0x87, 0x7E, 0x54, 0xE6, 0x12, + 0x78, 0x25, 0xD1, 0xA6, 0x33, 0xEA, 0xDF, 0x8C, + 0x40, 0xD2, 0xE9, 0xB9, 0x1F, 0xD5, 0x1D, 0x0E, + 0x95, 0x13, 0x5A, 0x77, 0x95, 0x83, 0x8E, 0x64 + }, + { + 0xA9, 0x57, 0xD7, 0x68, 0x40, 0x22, 0x10, 0xF9, + 0xE1, 0xF5, 0x19, 0x86, 0x8A, 0x28, 0xDF, 0xF0, + 0x6B, 0xCB, 0x67, 0x33, 0xED, 0x3D, 0x36, 0xB6, + 0x8E, 0xB5, 0xB6, 0x8C, 0xF5, 0xE7, 0xF7, 0x32 + }, + { + 0xB1, 0x13, 0x46, 0xA5, 0x9F, 0xAA, 0xE1, 0x6C, + 0xDC, 0x78, 0x97, 0x42, 0x4A, 0x95, 0xD2, 0x0F, + 0x91, 0xC7, 0x55, 0xFA, 0xFB, 0xFD, 0x75, 0x06, + 0x11, 0xD5, 0x15, 0x2B, 0xD7, 0xCE, 0x74, 0xF4 + }, + { + 0x4F, 0xB4, 0xB0, 0x25, 0x7C, 0xFB, 0x52, 0x66, + 0xBA, 0x99, 0xDF, 0xC9, 0x9C, 0x46, 0xDA, 0x59, + 0x2C, 0xCA, 0x90, 0xDC, 0xCA, 0x9C, 0xE1, 0xE7, + 0xCB, 0xA6, 0x61, 0xAC, 0x3E, 0xFD, 0x56, 0x37 + }, + { + 0xC4, 0x85, 0x10, 0x6B, 0x2D, 0xC5, 0x91, 0xE8, + 0x83, 0x6D, 0xED, 0xB7, 0x5C, 0x77, 0xB0, 0x95, + 0x9D, 0xA9, 0x5D, 0xFF, 0x5A, 0x5C, 0x12, 0x3E, + 0x7B, 0x7B, 0x1A, 0x01, 0x12, 0xCB, 0xF8, 0x92 + }, + { + 0x2D, 0xAC, 0x81, 0x21, 0x19, 0xB5, 0x22, 0xCF, + 0x77, 0xFE, 0xA5, 0xE4, 0x7A, 0x45, 0x64, 0x19, + 0x8F, 0x2D, 0xB5, 0x2E, 0x89, 0xC0, 0x31, 0xB3, + 0x73, 0xC8, 0x6A, 0x98, 0xCF, 0x95, 0x20, 0xA6 + }, + { + 0x91, 0x3E, 0x59, 0x38, 0xFA, 0x57, 0xCB, 0xD8, + 0x2A, 0x61, 0xF1, 0x18, 0x2A, 0x65, 0xF0, 0x06, + 0x01, 0x50, 0x81, 0x8F, 0x17, 0x1C, 0x72, 0x71, + 0x8C, 0xA0, 0xAF, 0x19, 0x75, 0xFD, 0x91, 0xE0 + }, + { + 0x1B, 0x93, 0xA7, 0x6C, 0x2A, 0x8D, 0x12, 0xBC, + 0xE2, 0x43, 0xF7, 0x02, 0x31, 0x4B, 0x42, 0x95, + 0x6B, 0x4F, 0x53, 0xA0, 0x5D, 0x28, 0x29, 0xDF, + 0xEC, 0x48, 0xAF, 0x04, 0x6D, 0x73, 0xA8, 0x08 + }, + { + 0x46, 0x68, 0x15, 0x9A, 0x16, 0x21, 0xE1, 0xEA, + 0xA8, 0xAA, 0x63, 0xD8, 0xBF, 0xC6, 0x2E, 0xA0, + 0x23, 0xEE, 0x4E, 0x1D, 0x26, 0x07, 0x14, 0x08, + 0x84, 0x5D, 0xA4, 0x91, 0x27, 0x46, 0x53, 0x96 + }, + { + 0x69, 0x6B, 0xE0, 0x0F, 0xE1, 0x9A, 0x85, 0x08, + 0xAA, 0xE5, 0x82, 0xBB, 0xFF, 0x7E, 0x2B, 0x15, + 0x12, 0x02, 0x7F, 0x24, 0x2F, 0x96, 0x7E, 0x39, + 0x13, 0x12, 0x3D, 0x3A, 0xB6, 0xCE, 0xA7, 0x9B + }, + { + 0xEB, 0x31, 0x36, 0x84, 0x07, 0x88, 0x55, 0xA5, + 0x48, 0xAE, 0x61, 0x4D, 0xCE, 0x58, 0x26, 0x7C, + 0xCB, 0xAA, 0x58, 0x91, 0x02, 0x37, 0x87, 0x53, + 0x91, 0xF8, 0x5F, 0xA5, 0x64, 0x9A, 0x0D, 0xF8 + }, + { + 0xE3, 0xF9, 0x4B, 0xC8, 0x0E, 0x4F, 0x30, 0x77, + 0x93, 0xC2, 0xB4, 0x62, 0x46, 0x41, 0x9E, 0xB9, + 0x71, 0xE5, 0x76, 0x7F, 0x4A, 0xAB, 0xAA, 0x68, + 0x1A, 0x13, 0xE3, 0xC2, 0x81, 0xDD, 0x0B, 0xB4 + }, + { + 0xE2, 0x26, 0x1C, 0xD7, 0x0A, 0xA8, 0xC6, 0x44, + 0x60, 0x54, 0x21, 0x96, 0x8B, 0x1A, 0x41, 0xC3, + 0xD3, 0x85, 0xE7, 0x9F, 0xA5, 0x95, 0xFB, 0x04, + 0xAA, 0x02, 0x0E, 0x00, 0x82, 0x5F, 0x0C, 0x40 + }, + { + 0xBE, 0x75, 0xA4, 0x0A, 0xDA, 0x64, 0x5C, 0x0A, + 0x5B, 0x96, 0x93, 0x72, 0xBB, 0x00, 0x88, 0x83, + 0x2B, 0x2E, 0x2F, 0x3D, 0xC8, 0x4C, 0x58, 0xDA, + 0x78, 0xA8, 0xA3, 0xEC, 0xBD, 0x05, 0xDE, 0xC6 + }, + { + 0x90, 0x8D, 0x43, 0x84, 0x8E, 0x9E, 0x9E, 0x70, + 0xD2, 0x78, 0x1E, 0xC6, 0xF6, 0x15, 0x65, 0xE2, + 0x89, 0xEB, 0xDE, 0xFA, 0x1A, 0x9D, 0x06, 0xB1, + 0xD0, 0x77, 0xEA, 0x75, 0x62, 0xB5, 0x24, 0x9B + }, + { + 0xBF, 0xE6, 0xFE, 0xCC, 0xD5, 0x61, 0xCB, 0x2B, + 0x79, 0x59, 0x37, 0x8E, 0xF0, 0xEC, 0xBC, 0xB7, + 0xC8, 0xF5, 0xF5, 0xA3, 0xF8, 0xC7, 0x50, 0xCE, + 0x8D, 0xFF, 0xC7, 0x17, 0xAC, 0x01, 0xE9, 0x65 + }, + { + 0x13, 0x33, 0x34, 0x24, 0x40, 0xF0, 0x0E, 0xAF, + 0x9F, 0xB8, 0xE6, 0x16, 0x7C, 0x68, 0x73, 0x9F, + 0x15, 0x3A, 0x13, 0x8E, 0x4E, 0x97, 0x25, 0xBC, + 0xF1, 0xDC, 0x57, 0x22, 0x34, 0xA1, 0x13, 0xF5 + }, + { + 0x9B, 0xC5, 0x7A, 0xF6, 0x39, 0x59, 0xAD, 0x94, + 0xFF, 0x94, 0x79, 0x08, 0xAA, 0x15, 0xB6, 0x50, + 0xEB, 0xB9, 0x99, 0xC6, 0xE6, 0x6F, 0xE6, 0x2A, + 0xF9, 0x93, 0xA3, 0x96, 0x1E, 0x67, 0xB2, 0xA6 + }, + { + 0x08, 0x2B, 0x0A, 0x4D, 0x5A, 0x40, 0xB4, 0x0F, + 0xFD, 0x88, 0xAD, 0xC4, 0xD8, 0xC0, 0x1A, 0x77, + 0x47, 0x21, 0x3B, 0x5A, 0xA1, 0x3F, 0x6E, 0x2F, + 0x32, 0xDC, 0x37, 0x9E, 0x7A, 0x05, 0x16, 0x9D + }, + { + 0x53, 0x1C, 0xD0, 0xA2, 0xDF, 0x4A, 0x19, 0xDB, + 0x27, 0x0F, 0xE5, 0xBF, 0x92, 0xB7, 0x60, 0x3B, + 0x86, 0x56, 0x7D, 0xB8, 0xA5, 0xC6, 0xFB, 0xFE, + 0xBC, 0xB2, 0x1B, 0xF6, 0xAE, 0x1B, 0x14, 0xB3 + }, + { + 0x9D, 0x1E, 0x66, 0x48, 0x47, 0x8A, 0x0A, 0x33, + 0x10, 0xB9, 0x01, 0x6A, 0x69, 0x56, 0xDD, 0xFF, + 0xE2, 0xC9, 0x7C, 0xBD, 0x99, 0xEC, 0xE9, 0x88, + 0x32, 0x92, 0x9D, 0x72, 0xF1, 0x48, 0x1C, 0xC8 + }, + { + 0x32, 0x47, 0x90, 0xDB, 0x11, 0xDA, 0x33, 0xB3, + 0x97, 0xFF, 0xA2, 0xE9, 0x22, 0x14, 0xCF, 0xF8, + 0x2C, 0x22, 0x6A, 0xDF, 0xDC, 0x94, 0xD1, 0x07, + 0x9C, 0x79, 0xBF, 0xE6, 0x48, 0xFC, 0x25, 0xFB + }, + { + 0xE1, 0xD6, 0x4E, 0xE8, 0x3F, 0x67, 0x1E, 0x63, + 0xB1, 0x4D, 0xE8, 0xA5, 0xF8, 0x6F, 0x6C, 0xB0, + 0xD2, 0xCC, 0xAF, 0xAB, 0x0B, 0xF6, 0xAF, 0xA8, + 0xD3, 0x93, 0x3C, 0x43, 0xA9, 0x50, 0xD6, 0x08 + }, + { + 0x61, 0xE8, 0x83, 0xF8, 0xCB, 0xA7, 0x71, 0x70, + 0x7D, 0x06, 0xCF, 0x24, 0x66, 0xC3, 0x72, 0x0F, + 0x55, 0x74, 0x8D, 0x4F, 0x05, 0xEC, 0x98, 0xA2, + 0x66, 0x31, 0xCA, 0x63, 0xB1, 0x6D, 0x40, 0x8D + }, + { + 0xC4, 0xFD, 0x31, 0xE8, 0x4E, 0x37, 0x81, 0x27, + 0x3B, 0x5A, 0x55, 0x04, 0xCB, 0x1F, 0xF6, 0xD8, + 0xA9, 0x68, 0xCE, 0x58, 0x01, 0xC8, 0xCB, 0x36, + 0xF4, 0x0C, 0x34, 0x61, 0xFD, 0x2E, 0x15, 0x94 + }, + { + 0x79, 0xAC, 0x4B, 0x43, 0xF4, 0xC3, 0x47, 0x99, + 0x72, 0xDF, 0xD9, 0x40, 0xA9, 0xF6, 0xF6, 0xEE, + 0xEC, 0xCB, 0xAA, 0x0D, 0x5C, 0xC4, 0xD4, 0x58, + 0xFD, 0x58, 0x89, 0x04, 0x82, 0xFC, 0x64, 0x0B + }, + { + 0xF8, 0x76, 0x1D, 0xB2, 0xE5, 0x4C, 0xC7, 0x46, + 0xA8, 0x67, 0x30, 0xA0, 0x13, 0x9D, 0x01, 0xE5, + 0x80, 0x0D, 0xD4, 0x62, 0xAB, 0x45, 0xDA, 0x14, + 0x39, 0xDD, 0xE1, 0x11, 0x0F, 0xB8, 0xE9, 0x06 + }, + { + 0xD7, 0xDF, 0x1E, 0xF2, 0x1B, 0xCF, 0x14, 0xFF, + 0x14, 0x83, 0x4C, 0x65, 0xD2, 0x5A, 0xFC, 0x9B, + 0xD5, 0xB3, 0x3A, 0x0B, 0x69, 0x9F, 0x92, 0x78, + 0xD3, 0xA5, 0xC4, 0x70, 0x80, 0x4C, 0x67, 0xAA + }, + { + 0x1B, 0xA5, 0x16, 0x5B, 0x4D, 0xBD, 0x45, 0xF1, + 0x2C, 0xE2, 0x91, 0xF2, 0x5C, 0xC3, 0x3D, 0x83, + 0xCF, 0xD7, 0x8D, 0x1A, 0xC9, 0x40, 0x89, 0x20, + 0x60, 0xB8, 0x5B, 0x5B, 0x86, 0xAD, 0x55, 0x01 + }, + { + 0xBF, 0xF0, 0x3C, 0x17, 0x2F, 0x68, 0x6B, 0x08, + 0xC1, 0x2E, 0xFB, 0x6A, 0xC7, 0x77, 0x87, 0x1E, + 0x3A, 0x92, 0xA6, 0x0F, 0xEC, 0x9D, 0x6F, 0x17, + 0x1B, 0xE6, 0x23, 0x19, 0xFA, 0xAC, 0x99, 0x6C + }, + { + 0x18, 0xC5, 0x70, 0x88, 0xB2, 0xDA, 0xB2, 0xE7, + 0xF1, 0x09, 0x3D, 0x90, 0x1F, 0x3B, 0xEF, 0x91, + 0x77, 0x32, 0xB8, 0x39, 0xDF, 0x6D, 0x2E, 0x93, + 0xB7, 0xF7, 0xF2, 0x47, 0x39, 0x5C, 0x71, 0x3B + }, + { + 0x3F, 0x7D, 0x7B, 0xBB, 0x25, 0x15, 0x43, 0x82, + 0x96, 0xF8, 0xD6, 0xE4, 0x09, 0x70, 0x53, 0xD6, + 0xF7, 0xA2, 0x87, 0x23, 0x30, 0xF2, 0x2B, 0x2F, + 0x36, 0xF5, 0xF3, 0x6D, 0x83, 0xB5, 0x41, 0x18 + }, + { + 0x6C, 0xA0, 0x97, 0x33, 0xB6, 0xF0, 0x88, 0x1F, + 0x30, 0xF4, 0xDE, 0xCE, 0xA1, 0x72, 0xF4, 0xD0, + 0x72, 0x9D, 0x5B, 0xC9, 0x61, 0x66, 0x97, 0x52, + 0xCF, 0x79, 0xDF, 0x27, 0xBD, 0xB0, 0xA6, 0xC4 + }, + { + 0xEC, 0x6C, 0xE2, 0x97, 0x38, 0x41, 0x63, 0x15, + 0xD9, 0x32, 0x4D, 0xCA, 0x11, 0xFF, 0x53, 0xBA, + 0xEC, 0x62, 0xF5, 0xE0, 0xFC, 0x9F, 0x25, 0xA4, + 0x56, 0x42, 0x0C, 0x20, 0xD2, 0xEE, 0x82, 0xEA + }, + { + 0x0C, 0x81, 0xDF, 0x70, 0x73, 0xAD, 0x06, 0xF0, + 0xAC, 0xA9, 0x5F, 0xEB, 0x98, 0x7E, 0x36, 0xDB, + 0x0C, 0xBC, 0x70, 0x20, 0xDA, 0xCE, 0x0D, 0x94, + 0xE7, 0xBE, 0xCF, 0x0C, 0x11, 0x3D, 0x7D, 0xBC + }, + { + 0x71, 0x65, 0xC2, 0x92, 0x2F, 0x3C, 0x28, 0x53, + 0x65, 0xD3, 0x63, 0xF3, 0x1A, 0xCF, 0x0B, 0xC1, + 0x6C, 0xCB, 0x70, 0x13, 0x94, 0x1F, 0xE8, 0xE1, + 0x90, 0x74, 0x02, 0x7E, 0x6C, 0xD6, 0xB3, 0xB5 + }, + { + 0x3C, 0xA9, 0x96, 0x42, 0x69, 0x17, 0x19, 0xDA, + 0x37, 0x39, 0xE6, 0x82, 0x8E, 0xDE, 0x4D, 0x2A, + 0x15, 0x48, 0x34, 0xDD, 0x25, 0x17, 0x06, 0xD6, + 0x8D, 0xAA, 0x8A, 0x35, 0xE4, 0x90, 0xD4, 0x80 + }, + { + 0xFA, 0x93, 0x38, 0x5C, 0x95, 0xCE, 0xD4, 0x14, + 0x0A, 0x73, 0xE1, 0x9B, 0x92, 0xDC, 0x4A, 0x97, + 0xC7, 0x77, 0xB1, 0x16, 0x19, 0xE3, 0x1E, 0xBE, + 0x55, 0x44, 0x40, 0xCB, 0x64, 0x18, 0x4F, 0x3D + }, + { + 0x3C, 0xB4, 0xF2, 0xD1, 0xB1, 0x96, 0x94, 0x66, + 0x73, 0x37, 0xC8, 0xF6, 0xF7, 0x2E, 0xCE, 0x12, + 0x52, 0x17, 0x44, 0x22, 0xDE, 0xA1, 0x5C, 0xE4, + 0xCF, 0xFE, 0xD7, 0x93, 0x43, 0x01, 0x12, 0x3A + }, + { + 0x27, 0x5A, 0x19, 0x45, 0x78, 0x8B, 0x4B, 0x37, + 0x7C, 0x09, 0x58, 0x48, 0x09, 0xD2, 0x70, 0xD4, + 0xDC, 0xC3, 0x8E, 0xA8, 0x82, 0xEB, 0xEE, 0xB6, + 0x11, 0x7C, 0xB2, 0x03, 0xC9, 0xC8, 0xB5, 0x64 + }, + { + 0xC7, 0xB1, 0xC1, 0xDD, 0x25, 0x96, 0x82, 0x17, + 0x8F, 0x25, 0x3B, 0xBF, 0xBD, 0x07, 0xFC, 0x50, + 0x2E, 0xEB, 0x91, 0x90, 0x8D, 0xD6, 0xB2, 0xB3, + 0x27, 0xCB, 0x62, 0x59, 0xCB, 0xCB, 0xAB, 0xBF + }, + { + 0xFB, 0x69, 0x48, 0xCC, 0x1F, 0xB0, 0xB8, 0x95, + 0xEA, 0x8B, 0x91, 0xA5, 0x9C, 0x26, 0x19, 0x82, + 0xA3, 0xB2, 0xE6, 0x53, 0x36, 0xD3, 0x39, 0x04, + 0xD5, 0x16, 0xEF, 0x29, 0x3E, 0x60, 0x10, 0x1C + }, + { + 0x44, 0x00, 0x5F, 0xE5, 0x52, 0x65, 0x75, 0x7C, + 0x8F, 0x13, 0xF0, 0x0E, 0xD0, 0xA5, 0x7D, 0xC7, + 0x8D, 0x83, 0xFC, 0xFE, 0x2F, 0x0E, 0xFE, 0x38, + 0x76, 0x7F, 0xCB, 0x91, 0xB6, 0x2B, 0xFB, 0x1D + }, + { + 0x90, 0x59, 0x4E, 0x75, 0x46, 0x37, 0x0F, 0x03, + 0xB2, 0xDD, 0xBB, 0x8A, 0xDC, 0x6A, 0x40, 0x6B, + 0x2E, 0x4B, 0xBF, 0x81, 0xDC, 0x1C, 0x14, 0x47, + 0x68, 0xEE, 0xCD, 0x7C, 0x3D, 0x8E, 0xCB, 0x32 + }, + { + 0x12, 0x59, 0x20, 0x0C, 0x9B, 0x65, 0x6F, 0x57, + 0xA7, 0x64, 0xFC, 0x85, 0x14, 0x13, 0x90, 0x75, + 0xC9, 0x10, 0x2D, 0x00, 0x87, 0xBA, 0xB1, 0x19, + 0x0B, 0x9D, 0xBC, 0x57, 0xC0, 0xAF, 0x15, 0x93 + }, + { + 0x1B, 0x81, 0x26, 0x85, 0x8E, 0xA7, 0x4C, 0x16, + 0xB2, 0xEC, 0xF3, 0xD2, 0xF6, 0xA8, 0x2A, 0x44, + 0x48, 0x91, 0x63, 0x6F, 0xA9, 0x23, 0xAE, 0x80, + 0xF4, 0x58, 0xC1, 0x2B, 0xEC, 0x1D, 0x4E, 0x54 + }, + { + 0x0E, 0xC3, 0x83, 0x76, 0x6F, 0x59, 0x72, 0xEF, + 0x46, 0x7D, 0xF3, 0x6A, 0xEA, 0x1A, 0xCB, 0xA5, + 0x10, 0x73, 0x71, 0x54, 0x8E, 0x5B, 0xD4, 0x3B, + 0x57, 0xBB, 0xFA, 0x59, 0x23, 0x40, 0x27, 0x77 + }, + { + 0xD1, 0x4F, 0x6C, 0xD3, 0xF0, 0xCD, 0x6B, 0x8B, + 0xAB, 0x3D, 0xEB, 0x3C, 0x73, 0x24, 0x16, 0x47, + 0xB7, 0x3B, 0x42, 0xFF, 0x30, 0xAC, 0x60, 0x2F, + 0xBB, 0xDD, 0x57, 0x17, 0x93, 0x9D, 0xEE, 0xFC + }, + { + 0x72, 0x9F, 0x44, 0xCA, 0x65, 0xD3, 0xDA, 0xF7, + 0x9A, 0x4E, 0x6D, 0xFA, 0xBB, 0x1C, 0x4C, 0xBF, + 0x70, 0x55, 0xD3, 0x03, 0xBB, 0x48, 0x36, 0xB3, + 0xED, 0xA9, 0xDE, 0xBB, 0x38, 0x05, 0xE8, 0x0D + }, + { + 0x21, 0xF9, 0xA7, 0x84, 0xAF, 0x69, 0x3E, 0xFE, + 0x42, 0xF6, 0x3F, 0xF2, 0x40, 0x25, 0xA7, 0x3D, + 0x4F, 0xB2, 0x1D, 0x5C, 0x94, 0x6A, 0xFD, 0x77, + 0x4A, 0xE0, 0x84, 0x00, 0x4F, 0x37, 0xD4, 0xA3 + }, + { + 0x53, 0xB8, 0x43, 0x29, 0xB4, 0x27, 0xA0, 0xA9, + 0xE2, 0xBF, 0xAB, 0x10, 0xA4, 0xAD, 0x18, 0xDD, + 0xE5, 0x77, 0x2E, 0xFA, 0x7C, 0xAE, 0x0E, 0x6A, + 0xE1, 0x23, 0xD8, 0xDC, 0x0E, 0x44, 0x4A, 0x12 + }, + { + 0x29, 0xBD, 0x3D, 0xFB, 0x43, 0xF3, 0x68, 0x5F, + 0xE5, 0x85, 0x27, 0xFD, 0x64, 0xC8, 0x63, 0x84, + 0x8A, 0xDE, 0xF5, 0x92, 0x41, 0xD1, 0xFB, 0xE2, + 0xB5, 0x6F, 0x2C, 0xE2, 0xF0, 0x8B, 0x63, 0xBA + }, + { + 0x68, 0x59, 0x50, 0x62, 0xE1, 0x9A, 0x66, 0xEE, + 0x6F, 0x1A, 0x05, 0xF0, 0x9B, 0x86, 0x18, 0x0F, + 0xB5, 0x85, 0xBA, 0x0F, 0xC9, 0x27, 0x75, 0x72, + 0x9C, 0xCD, 0xB6, 0xA2, 0x2D, 0x67, 0x26, 0xC7 + }, + { + 0xDC, 0xE8, 0xB4, 0x8E, 0xEB, 0x7B, 0x5E, 0xDF, + 0xB5, 0x4D, 0xF7, 0xAB, 0x0F, 0xE7, 0x93, 0xAA, + 0xB7, 0xAB, 0x3D, 0x06, 0x87, 0xB1, 0xD3, 0xEB, + 0xFF, 0x48, 0x69, 0xE6, 0xB0, 0xAB, 0x85, 0xF0 + }, + { + 0x65, 0x8F, 0x4D, 0x16, 0xD0, 0x5B, 0x00, 0x2F, + 0x18, 0x29, 0x91, 0x56, 0x75, 0x76, 0x9D, 0x49, + 0x32, 0xFB, 0x42, 0x93, 0x06, 0x9C, 0xC1, 0x56, + 0x0A, 0x60, 0x4A, 0x47, 0xC8, 0xD6, 0x45, 0x83 + }, + { + 0xD5, 0x01, 0x13, 0x3F, 0xAD, 0xF6, 0x98, 0x64, + 0x38, 0xDD, 0x19, 0x86, 0x16, 0x8E, 0x97, 0xB5, + 0xE1, 0x49, 0x4E, 0x5A, 0xFF, 0x6A, 0x21, 0x8B, + 0xBB, 0xD9, 0x90, 0xC7, 0x42, 0x1E, 0xB6, 0x61 + }, + { + 0xE4, 0xF8, 0x76, 0xB3, 0x24, 0xEB, 0x2A, 0xF5, + 0xF9, 0x8A, 0x66, 0xBB, 0x69, 0x1B, 0x79, 0xFD, + 0x90, 0x7A, 0x93, 0x83, 0x0A, 0x8C, 0x7C, 0x6D, + 0x43, 0x7E, 0x39, 0xFC, 0x31, 0x63, 0x5B, 0xE9 + }, + { + 0x1D, 0x3F, 0x13, 0xFD, 0x96, 0x58, 0x66, 0x0C, + 0x3E, 0x03, 0xEC, 0x0A, 0xC7, 0xDA, 0x25, 0xBD, + 0x54, 0x5E, 0xA5, 0x59, 0x50, 0x93, 0x89, 0xDF, + 0xD3, 0xCF, 0x20, 0xF8, 0x59, 0xCA, 0x83, 0x27 + }, + { + 0x4E, 0x62, 0xCA, 0x9C, 0xDD, 0x35, 0x80, 0x33, + 0xED, 0xEB, 0x7F, 0x02, 0xAF, 0x58, 0x8E, 0x72, + 0x00, 0xE0, 0x6A, 0x45, 0xDF, 0x37, 0x1E, 0x99, + 0x65, 0x7B, 0x71, 0x88, 0xB0, 0x01, 0x36, 0x93 + }, + { + 0x36, 0xF6, 0x5E, 0x8F, 0xCA, 0xA7, 0xA5, 0x46, + 0x25, 0xD7, 0x99, 0x9F, 0x52, 0xF5, 0x27, 0x61, + 0x69, 0x37, 0x7F, 0x96, 0x30, 0x32, 0x07, 0x4B, + 0x75, 0xB0, 0xBE, 0x86, 0x53, 0x9D, 0x29, 0xC3 + }, + { + 0xA9, 0x2F, 0x61, 0x85, 0xEB, 0x68, 0x79, 0x2D, + 0x15, 0x13, 0xA4, 0xEB, 0xFE, 0xB2, 0x9B, 0xE2, + 0x77, 0x67, 0x33, 0x7C, 0xF4, 0x76, 0x9B, 0x42, + 0x0D, 0xA5, 0xE2, 0xF8, 0x63, 0x88, 0x44, 0xBB + }, + { + 0xEC, 0xC1, 0x6D, 0xC4, 0x3F, 0x9B, 0x0A, 0x5A, + 0xA9, 0x97, 0x6E, 0x95, 0x5D, 0x90, 0xB9, 0x4E, + 0x20, 0x7C, 0xEA, 0xA9, 0xC5, 0x3E, 0x2B, 0x35, + 0x36, 0x05, 0xBB, 0xD8, 0xAD, 0x60, 0xEC, 0xC0 + }, + { + 0xE0, 0x8C, 0xD8, 0x14, 0x94, 0x36, 0x0A, 0x3E, + 0xDF, 0x86, 0x1C, 0x7E, 0xEB, 0x7D, 0x6D, 0xBF, + 0xE0, 0x02, 0xA2, 0x7B, 0x2B, 0xCD, 0x0D, 0x87, + 0xC0, 0x4F, 0x71, 0x5D, 0x3C, 0x8F, 0xB7, 0x91 + }, + { + 0xEC, 0x74, 0xC5, 0xCE, 0x17, 0x88, 0x31, 0xB3, + 0x27, 0x78, 0xA5, 0xC8, 0x8C, 0xD0, 0x4B, 0xCD, + 0x77, 0xB5, 0x0F, 0x3E, 0xAC, 0xD9, 0xD1, 0x7C, + 0x18, 0x7B, 0xB4, 0x20, 0x9E, 0x38, 0x0B, 0x44 + }, + { + 0xB5, 0x1A, 0x1A, 0xF2, 0x6D, 0xAB, 0x47, 0xE3, + 0xF7, 0xFB, 0xA6, 0xA7, 0x5E, 0x51, 0x40, 0x4B, + 0x01, 0xC5, 0xC5, 0x54, 0xB2, 0x0B, 0x2D, 0x53, + 0x36, 0x8A, 0x1B, 0xB0, 0x1A, 0x5F, 0x66, 0x79 + }, + { + 0x55, 0xD5, 0x57, 0x8D, 0x05, 0x71, 0x49, 0xE7, + 0xFE, 0x07, 0x9C, 0x88, 0xCB, 0x66, 0x52, 0x81, + 0x30, 0x95, 0x5A, 0x74, 0x7B, 0xDA, 0xA1, 0x96, + 0x61, 0xC4, 0xB6, 0x20, 0xC2, 0x0A, 0x0F, 0x20 + }, + { + 0x0E, 0x2B, 0xF6, 0x04, 0x23, 0x7F, 0xB5, 0x55, + 0x41, 0xF2, 0xBD, 0x90, 0xE6, 0x1D, 0x61, 0x9C, + 0x30, 0xD9, 0x3B, 0xF7, 0xC2, 0x7C, 0xE0, 0xDC, + 0xE0, 0x42, 0xCB, 0x0B, 0x62, 0x2A, 0x2D, 0x7C + }, + { + 0x1F, 0x6B, 0x8E, 0x05, 0xBA, 0x48, 0xC1, 0xCA, + 0x88, 0x56, 0xE1, 0x1E, 0x56, 0x0C, 0x2F, 0xB1, + 0x82, 0x49, 0x24, 0xAD, 0x1E, 0xDD, 0xA5, 0x6A, + 0x43, 0x7F, 0xDA, 0x7D, 0x8F, 0x12, 0x5B, 0x65 + }, + { + 0x13, 0xAF, 0x79, 0x11, 0xED, 0xD9, 0x7B, 0x8B, + 0x06, 0x60, 0x81, 0x1D, 0x07, 0x25, 0xAE, 0xD7, + 0xB4, 0x66, 0x26, 0xAE, 0x83, 0x25, 0xFA, 0xEE, + 0xF6, 0xED, 0x64, 0x71, 0x3D, 0xEC, 0x7E, 0x2E + }, + { + 0xAF, 0x8C, 0x99, 0xFE, 0x38, 0xCF, 0x62, 0xEA, + 0x70, 0x34, 0xBC, 0x8C, 0xBF, 0x57, 0x07, 0xA4, + 0x29, 0x7B, 0x68, 0xC6, 0xA2, 0xFF, 0x63, 0x45, + 0x16, 0x1F, 0xC1, 0x31, 0xFC, 0xD6, 0x1B, 0x96 + }, + { + 0xAD, 0xB1, 0x7B, 0x0D, 0x8D, 0x23, 0xF0, 0x2C, + 0xCA, 0x31, 0x55, 0x39, 0x88, 0xE2, 0x44, 0x2A, + 0xAB, 0x3C, 0xB7, 0xF2, 0xF8, 0x3A, 0x6C, 0x2C, + 0x29, 0x02, 0xC4, 0x21, 0x52, 0x32, 0xFC, 0x51 + }, + { + 0xD5, 0x8D, 0x30, 0x97, 0x1F, 0x8F, 0xC2, 0x30, + 0xB9, 0x7E, 0x87, 0x48, 0x00, 0xCC, 0xA5, 0xBD, + 0x50, 0x39, 0xA8, 0xD0, 0x98, 0xCD, 0x6F, 0x7A, + 0xF0, 0xC4, 0xCD, 0xA6, 0x87, 0x22, 0xB2, 0x52 + }, + { + 0xE6, 0xA8, 0x22, 0x43, 0x51, 0xA5, 0xDF, 0xC2, + 0x6B, 0xC6, 0x50, 0xE3, 0x30, 0xC5, 0x1D, 0x4B, + 0x70, 0x1C, 0xCA, 0xED, 0x54, 0xB2, 0x4C, 0xE0, + 0xD9, 0x18, 0x47, 0xE7, 0x28, 0x37, 0x25, 0x54 + }, + { + 0x5F, 0x56, 0xB3, 0x6F, 0x5C, 0x37, 0xB9, 0x9A, + 0x9F, 0x61, 0xB4, 0xE3, 0xA4, 0x5C, 0x55, 0x03, + 0x96, 0x01, 0xDB, 0x76, 0x2E, 0x5E, 0x32, 0xFA, + 0xBE, 0x22, 0xC6, 0xFF, 0xF3, 0x0A, 0xBB, 0x75 + }, + { + 0xA1, 0x7F, 0xD2, 0xA1, 0x33, 0xC6, 0x07, 0xB5, + 0xE1, 0x22, 0x15, 0x3A, 0xAB, 0x4D, 0xBA, 0x0B, + 0x0B, 0x19, 0xDE, 0x1A, 0x55, 0x98, 0x67, 0x57, + 0xE0, 0xD7, 0xA5, 0xB8, 0x3B, 0x41, 0x3F, 0x83 + }, + { + 0x5F, 0x00, 0x8F, 0xC2, 0x52, 0xD7, 0x31, 0x12, + 0x58, 0x34, 0x20, 0x14, 0x19, 0xF9, 0x23, 0x06, + 0xBF, 0x85, 0x65, 0xB3, 0x2F, 0xB7, 0x1F, 0x21, + 0x33, 0x80, 0x7C, 0xA0, 0x1A, 0xA2, 0x53, 0x28 + }, + { + 0x71, 0xBD, 0x99, 0x98, 0x04, 0x5E, 0xE0, 0x47, + 0x76, 0xC5, 0x87, 0x9A, 0x89, 0x3F, 0x89, 0x8B, + 0x53, 0x9D, 0xC1, 0xA7, 0x3B, 0x04, 0xE7, 0x24, + 0x35, 0x5D, 0x10, 0xCE, 0xEE, 0x6B, 0x6C, 0xA3 + }, + { + 0x7D, 0x30, 0xFC, 0x76, 0x85, 0xCF, 0x57, 0x62, + 0x2F, 0x52, 0x78, 0x24, 0x7C, 0x4A, 0x72, 0xB6, + 0xF4, 0x9E, 0xE0, 0xFC, 0xBE, 0xB5, 0xE8, 0x95, + 0x74, 0xF7, 0xD2, 0x9A, 0x9E, 0x3D, 0x08, 0x5C + }, + { + 0x58, 0xE6, 0x94, 0xD0, 0x4B, 0xBA, 0x77, 0xA2, + 0x3A, 0x81, 0xD9, 0x3A, 0x32, 0xA4, 0x92, 0x37, + 0x6C, 0xFC, 0x5D, 0x2D, 0x69, 0xA0, 0x69, 0xD8, + 0x3C, 0xE0, 0xD3, 0x47, 0xCE, 0x87, 0x75, 0x60 + }, + { + 0xDD, 0xC1, 0xC0, 0xBB, 0x16, 0xF3, 0x88, 0x90, + 0x4B, 0x67, 0x75, 0xCC, 0x5D, 0xE6, 0xCB, 0xAA, + 0xC0, 0x1F, 0x7A, 0xFD, 0x3A, 0x97, 0xD3, 0xB8, + 0xB2, 0xC7, 0xB2, 0x93, 0xBC, 0x7A, 0x15, 0x52 + }, + { + 0xA6, 0x7E, 0x45, 0x13, 0x32, 0xFA, 0x72, 0x8F, + 0xDF, 0x16, 0xCE, 0xB4, 0x4B, 0x11, 0x62, 0x98, + 0xE4, 0xF8, 0x4D, 0x45, 0x47, 0x51, 0x09, 0x2E, + 0x7E, 0xA9, 0x29, 0xC6, 0x4F, 0x0A, 0x20, 0x8F + }, + { + 0xD3, 0xAE, 0xF8, 0x39, 0xCF, 0x1F, 0x17, 0x1C, + 0xAA, 0xF6, 0x23, 0x4C, 0x45, 0x71, 0x6D, 0x65, + 0x3A, 0xDE, 0x7E, 0x45, 0xFE, 0xF0, 0x13, 0x90, + 0xD6, 0x4F, 0xEF, 0xFB, 0x8C, 0xF9, 0xB2, 0x92 + }, + { + 0xA9, 0x18, 0x4C, 0xB7, 0xAB, 0x2D, 0x41, 0x15, + 0x7F, 0xE4, 0xC5, 0x4D, 0xDA, 0xC7, 0xC4, 0x46, + 0x80, 0x90, 0x39, 0x6C, 0xBF, 0x7E, 0x53, 0x56, + 0x86, 0x38, 0x1F, 0xDF, 0xFF, 0xB0, 0x20, 0xFF + }, + { + 0x8D, 0xE3, 0x88, 0x3A, 0xE8, 0x09, 0x62, 0xD6, + 0x18, 0xF6, 0x30, 0xD8, 0x46, 0xB8, 0x4F, 0x21, + 0x4F, 0x4C, 0x96, 0xAC, 0x03, 0x24, 0x39, 0xAB, + 0xD1, 0xD7, 0x74, 0x53, 0xE5, 0x87, 0x58, 0x92 + }, + { + 0x08, 0xF8, 0x53, 0x3E, 0xB6, 0xF2, 0x01, 0xCB, + 0x87, 0xFD, 0x89, 0xF4, 0xF9, 0x1D, 0xE4, 0xC9, + 0xC0, 0xEF, 0x94, 0x13, 0xE8, 0x2C, 0xD5, 0x2B, + 0xC1, 0x8A, 0x1C, 0xA5, 0x92, 0xC6, 0x4E, 0xCA + }, + { + 0xCB, 0xDF, 0x5A, 0x2D, 0xF4, 0xA6, 0xFA, 0x2C, + 0xA4, 0x06, 0x98, 0x3E, 0x86, 0xEF, 0xE6, 0x15, + 0x09, 0xC5, 0xF9, 0x26, 0x41, 0x2F, 0xDC, 0xF0, + 0x6E, 0x58, 0xD8, 0xD0, 0xBC, 0xBE, 0xCD, 0x53 + }, + { + 0x6B, 0xAE, 0x18, 0x90, 0x2E, 0x8B, 0xBE, 0xEA, + 0xBD, 0xE4, 0xC9, 0x59, 0xA0, 0xAB, 0xC8, 0xE8, + 0x9B, 0x5C, 0x79, 0xE2, 0x4A, 0xF1, 0xD3, 0xB4, + 0x67, 0x9B, 0x2F, 0x6E, 0x0A, 0x61, 0xAA, 0x41 + }, + { + 0x94, 0x4A, 0xFF, 0x9D, 0x26, 0x24, 0x4A, 0x4F, + 0x13, 0x71, 0x6B, 0xAE, 0x20, 0xE7, 0xC1, 0x40, + 0x32, 0xDA, 0x54, 0x5D, 0x27, 0x05, 0x92, 0x47, + 0x8A, 0xA0, 0xF8, 0x8C, 0x2E, 0xDD, 0xDF, 0xB0 + }, + { + 0xB2, 0x36, 0x07, 0x91, 0x4B, 0xCE, 0xFC, 0x7B, + 0x3A, 0x2E, 0x5C, 0xA2, 0x08, 0x6A, 0xF5, 0xD8, + 0xA8, 0x3F, 0x20, 0x5B, 0x83, 0x36, 0xBF, 0xAD, + 0xD2, 0x70, 0xE6, 0xA4, 0x39, 0x7E, 0x9E, 0x3F + }, + { + 0x50, 0x3D, 0x1A, 0xF6, 0xB5, 0xC1, 0x1C, 0x50, + 0x16, 0x97, 0xE1, 0x6D, 0xDF, 0x1B, 0xEE, 0x23, + 0xD8, 0x7A, 0x8D, 0x6F, 0xB4, 0xD8, 0x15, 0x69, + 0xDE, 0x15, 0x87, 0x81, 0xA4, 0x95, 0xF2, 0x68 + }, + { + 0xBB, 0xF7, 0x5F, 0x39, 0x46, 0xB7, 0x27, 0xFA, + 0x32, 0xE9, 0x2C, 0xCE, 0x87, 0x40, 0x4F, 0xB6, + 0xE2, 0x70, 0xC2, 0x80, 0x42, 0x5F, 0x9B, 0xD6, + 0x4E, 0xE6, 0x0D, 0x1F, 0xA6, 0xDB, 0xDE, 0x83 + }, + { + 0x23, 0x6B, 0x6E, 0x72, 0xBC, 0xC0, 0x13, 0x4C, + 0x95, 0xE5, 0xA9, 0x15, 0x9B, 0x34, 0x2B, 0xF4, + 0xAD, 0x92, 0x8E, 0x00, 0x51, 0x73, 0xD6, 0xBF, + 0xE6, 0x02, 0xD8, 0xA4, 0xF2, 0x92, 0x34, 0xC6 + }, + { + 0xC3, 0xD7, 0x34, 0x82, 0x70, 0x65, 0x25, 0x91, + 0x9E, 0xE2, 0x11, 0x52, 0xAB, 0x71, 0x1A, 0xF1, + 0xBA, 0xD8, 0xE2, 0x5B, 0x32, 0x0D, 0x8F, 0xE4, + 0x5A, 0x01, 0xCF, 0x48, 0x13, 0xA2, 0x49, 0xC4 + }, + { + 0x20, 0x80, 0x54, 0x9F, 0xDC, 0xA2, 0xFB, 0xD9, + 0xC1, 0x67, 0xAB, 0x46, 0x7D, 0x77, 0x86, 0x76, + 0x01, 0x2D, 0xFD, 0x7A, 0x87, 0x29, 0x0C, 0x5D, + 0x15, 0x54, 0xCE, 0x1C, 0x94, 0x87, 0x8C, 0x20 + }, + { + 0x42, 0x2F, 0x87, 0x2F, 0x15, 0x90, 0xBF, 0x7F, + 0x47, 0x99, 0x04, 0x6A, 0x46, 0xB0, 0xB9, 0x39, + 0xDB, 0x06, 0xB4, 0x21, 0x62, 0x93, 0x57, 0xE5, + 0x7E, 0xE8, 0x23, 0x49, 0xB2, 0xCF, 0x21, 0x3A + }, + { + 0x22, 0xD8, 0x80, 0xB7, 0x14, 0xD6, 0xC6, 0xF2, + 0x83, 0x36, 0x94, 0x10, 0x11, 0xB6, 0x14, 0xAB, + 0xE5, 0x97, 0xB0, 0x6C, 0x71, 0xD0, 0xB9, 0x6B, + 0xFD, 0xC5, 0xB5, 0xC1, 0x3C, 0x5D, 0xC0, 0x96 + }, + { + 0xDE, 0xF6, 0xAA, 0xB3, 0x1F, 0xF3, 0x11, 0x8B, + 0x88, 0x2C, 0x71, 0x0B, 0x15, 0x97, 0xE9, 0x3A, + 0xE5, 0x97, 0xDE, 0xAC, 0xD5, 0xF0, 0xE7, 0xDF, + 0xF3, 0x0A, 0x8A, 0x24, 0x25, 0xD1, 0xFB, 0x93 + }, + { + 0x3B, 0x5B, 0x5C, 0xB5, 0xC5, 0x8C, 0x1B, 0xAF, + 0x57, 0x05, 0xAF, 0xDB, 0xFF, 0x35, 0xD6, 0x6B, + 0x1C, 0xFB, 0xEA, 0x9D, 0xC9, 0x2F, 0x1B, 0xAB, + 0xE8, 0x11, 0x49, 0x32, 0xB6, 0xE9, 0x48, 0xAB + }, + { + 0x0E, 0x6D, 0x09, 0x9F, 0x7B, 0xF4, 0x6C, 0x7B, + 0x24, 0x90, 0xAF, 0x00, 0xCA, 0x94, 0xEF, 0x1D, + 0x78, 0x99, 0x60, 0x11, 0xA1, 0x13, 0xAE, 0xD4, + 0x2C, 0x64, 0x14, 0x32, 0xEA, 0x81, 0x2B, 0xE9 + }, + { + 0xE6, 0xBE, 0xD2, 0x79, 0xBB, 0x45, 0xAF, 0x8D, + 0xEC, 0xCB, 0x5F, 0xE2, 0x68, 0xC8, 0xF6, 0x71, + 0x00, 0xB3, 0xB3, 0x08, 0x12, 0xB7, 0x99, 0xA6, + 0x37, 0xBD, 0x76, 0xC8, 0x49, 0x75, 0x53, 0xC2 + }, + { + 0x75, 0x07, 0x23, 0xC1, 0xB3, 0xF6, 0xE9, 0x03, + 0xDC, 0xF8, 0xD4, 0x37, 0x33, 0x04, 0xA4, 0xC1, + 0x42, 0x2A, 0xDF, 0x2D, 0xD9, 0x5A, 0x2D, 0xBC, + 0x77, 0xF8, 0x0B, 0x99, 0xA6, 0x6A, 0x89, 0x1F + }, + { + 0xFB, 0x15, 0x72, 0x27, 0xE6, 0x10, 0x13, 0xAB, + 0x49, 0xCE, 0x9F, 0x5E, 0x37, 0xCD, 0xD5, 0x40, + 0x68, 0x08, 0x1C, 0x31, 0x54, 0x63, 0xB5, 0xDB, + 0x89, 0x4A, 0x4E, 0xE6, 0xBC, 0x94, 0xE9, 0x50 + }, + { + 0xA4, 0xE4, 0x9F, 0x0F, 0xFA, 0x74, 0x02, 0xE0, + 0x9E, 0xB4, 0xA6, 0xFD, 0x03, 0x38, 0x1A, 0x49, + 0x94, 0x5C, 0xB6, 0x25, 0x12, 0xCB, 0x60, 0xC2, + 0xB3, 0xAA, 0x27, 0x44, 0x08, 0x83, 0x8A, 0xEA + }, + { + 0x9B, 0xAD, 0x96, 0x33, 0x39, 0x63, 0xE9, 0x99, + 0x71, 0xF1, 0x35, 0xBD, 0xA6, 0xDB, 0x42, 0xCB, + 0x51, 0x86, 0xD4, 0x47, 0x98, 0xED, 0xB6, 0xA1, + 0x12, 0x06, 0x33, 0x4B, 0xBA, 0xB8, 0x09, 0xB5 + }, + { + 0x8E, 0xD9, 0x8B, 0xF2, 0x7A, 0x8A, 0x4A, 0xDB, + 0x90, 0x82, 0xFC, 0x18, 0x6E, 0x24, 0x2C, 0xB5, + 0x16, 0x47, 0xBF, 0x06, 0xCB, 0xDF, 0x04, 0xF6, + 0xB0, 0x01, 0xC1, 0x91, 0x9F, 0xDB, 0x74, 0x55 + }, + { + 0x94, 0xF5, 0xDE, 0x41, 0x2B, 0x62, 0xF3, 0x84, + 0x29, 0x20, 0x66, 0x2F, 0x45, 0x76, 0x45, 0xFA, + 0xB2, 0x05, 0x81, 0x3C, 0xFD, 0x57, 0x1D, 0x8C, + 0xD1, 0x9E, 0x4A, 0xA8, 0x04, 0x4E, 0xC4, 0x54 + }, + { + 0x8C, 0x6C, 0x6F, 0x0D, 0xAD, 0x1F, 0x64, 0x21, + 0x72, 0x6B, 0x6D, 0x05, 0xE0, 0xE1, 0xFB, 0x38, + 0xDD, 0x83, 0x2A, 0x03, 0xAE, 0x25, 0x83, 0xDE, + 0x3E, 0x89, 0x6A, 0xE5, 0x9D, 0xB4, 0x09, 0x8A + }, + { + 0x5E, 0x1A, 0x0A, 0x0B, 0x13, 0xDF, 0xB3, 0xB1, + 0xF0, 0xFB, 0x38, 0x69, 0xA3, 0x9B, 0x8F, 0x4D, + 0xC3, 0xE8, 0x7B, 0x50, 0xF1, 0xB1, 0xED, 0xD8, + 0xAF, 0x43, 0x5D, 0x54, 0xEC, 0xD1, 0xAE, 0xD0 + }, + { + 0xEC, 0x86, 0x87, 0x54, 0x2A, 0xA0, 0x0B, 0xAA, + 0xC8, 0x50, 0x17, 0xD7, 0xF3, 0x31, 0x9D, 0x23, + 0xCC, 0xBF, 0xE1, 0x2C, 0x43, 0x7E, 0x61, 0xCA, + 0x74, 0x8F, 0x7A, 0xF8, 0xDA, 0xC6, 0x58, 0x7D + }, + { + 0x36, 0xF0, 0x88, 0x17, 0xBB, 0xF9, 0x0D, 0xBC, + 0xC7, 0xF5, 0xAF, 0x67, 0x9C, 0x8A, 0xAB, 0xD1, + 0xE0, 0xFE, 0x68, 0x59, 0x8E, 0xAD, 0x41, 0x66, + 0x96, 0x46, 0x8F, 0x3B, 0x62, 0x01, 0x77, 0xD7 + }, + { + 0x56, 0x37, 0x73, 0xF4, 0x7E, 0x52, 0x37, 0x61, + 0x95, 0x18, 0x82, 0xCE, 0x3C, 0x7E, 0x8A, 0x16, + 0x2E, 0x07, 0xA5, 0x32, 0x04, 0x5E, 0x15, 0x2E, + 0x13, 0x9D, 0x8E, 0xBF, 0xA2, 0x20, 0x34, 0xA7 + }, + { + 0x8C, 0x66, 0x3A, 0x0E, 0xB9, 0x84, 0xB7, 0x83, + 0xBB, 0x44, 0x07, 0xA6, 0x3A, 0x10, 0x9B, 0x33, + 0x4D, 0x4F, 0x5C, 0x22, 0xEF, 0x11, 0x24, 0x76, + 0xBC, 0x27, 0xD8, 0xD2, 0x82, 0x00, 0x22, 0xE7 + }, + { + 0x61, 0x9B, 0x7B, 0x1D, 0xBA, 0x4C, 0xA2, 0x31, + 0x46, 0xAA, 0x98, 0xC3, 0x00, 0x99, 0x45, 0x84, + 0x19, 0x90, 0xC8, 0xDC, 0xC9, 0xB4, 0x4E, 0x30, + 0x84, 0x4B, 0x49, 0xC6, 0x6E, 0x95, 0x96, 0xA0 + }, + { + 0x0A, 0x8E, 0x27, 0x70, 0x33, 0x64, 0x68, 0x0A, + 0x68, 0xD7, 0xB7, 0x0F, 0x2A, 0xB6, 0xF3, 0x58, + 0x0A, 0xC2, 0xE2, 0x51, 0x40, 0xC5, 0xC8, 0x80, + 0xDF, 0x63, 0x00, 0xCB, 0x15, 0xBC, 0x97, 0xD9 + }, + { + 0xEB, 0xFC, 0x44, 0xA3, 0x09, 0xDF, 0x57, 0xB9, + 0x64, 0xB5, 0x9A, 0x76, 0x28, 0x78, 0x4F, 0x30, + 0x30, 0x93, 0xF0, 0x68, 0x95, 0x09, 0xD9, 0x6C, + 0x7A, 0xA0, 0xB2, 0xF8, 0x52, 0x6E, 0x98, 0x4A + }, + { + 0x10, 0x10, 0xB3, 0x3E, 0x05, 0xA3, 0x57, 0x17, + 0x5E, 0x2A, 0x90, 0xD6, 0x4D, 0xE3, 0x06, 0xE9, + 0x6B, 0x85, 0xCE, 0x13, 0x42, 0xCC, 0xF5, 0xE3, + 0x25, 0xD2, 0xAC, 0xB2, 0x7A, 0x26, 0x80, 0xC6 + }, + { + 0x5D, 0x87, 0x3D, 0x09, 0x28, 0x35, 0x5A, 0x96, + 0xAB, 0xF8, 0xF5, 0xD3, 0x03, 0x7E, 0x2E, 0xD3, + 0xF6, 0xF7, 0x83, 0x27, 0x80, 0xE1, 0x61, 0x45, + 0xE4, 0xF7, 0xE2, 0xE7, 0xCF, 0xF7, 0xBA, 0x81 + }, + { + 0xF2, 0x7D, 0xA3, 0x5B, 0x9F, 0xED, 0xD5, 0x19, + 0xD6, 0xF8, 0x19, 0x58, 0x1B, 0x61, 0xB0, 0x28, + 0x51, 0x8F, 0xE0, 0xD9, 0xDD, 0x9E, 0x7F, 0xFC, + 0x03, 0x96, 0x3E, 0x61, 0xFB, 0x1F, 0x78, 0x13 + }, + { + 0xCD, 0xB8, 0xF1, 0x06, 0x70, 0x58, 0x2B, 0x71, + 0x67, 0xDA, 0x9C, 0xC0, 0xF2, 0x40, 0x74, 0x92, + 0xBC, 0xDB, 0x7A, 0x10, 0xE4, 0x48, 0x7B, 0xE3, + 0xC9, 0x60, 0xC6, 0x61, 0xE7, 0x56, 0xF8, 0x05 + }, + { + 0x38, 0x32, 0xAA, 0xA1, 0x55, 0xB9, 0x7D, 0xE7, + 0xA1, 0xCA, 0x47, 0x37, 0xD9, 0x2E, 0x66, 0xFB, + 0x66, 0x98, 0xDD, 0xE9, 0x7C, 0x52, 0xF4, 0x1B, + 0x97, 0xF0, 0x69, 0xF5, 0x06, 0xE2, 0x7E, 0x63 + }, + { + 0xFD, 0xCA, 0x38, 0x3A, 0x83, 0x9C, 0x8E, 0xC7, + 0x52, 0x9F, 0xA9, 0xE5, 0x65, 0xC2, 0x82, 0xBF, + 0x10, 0x9F, 0x9B, 0xF4, 0xA2, 0x2C, 0xE4, 0x71, + 0xA1, 0x2C, 0x2F, 0x6C, 0xFA, 0x35, 0x16, 0x66 + }, + { + 0x8B, 0xAC, 0xC0, 0x66, 0x8B, 0x86, 0x95, 0xC0, + 0x9F, 0xE4, 0xD9, 0xED, 0x52, 0x86, 0x52, 0xF2, + 0xCE, 0x28, 0x99, 0x44, 0x2B, 0x87, 0x6B, 0x45, + 0x80, 0x80, 0xBF, 0x07, 0x32, 0x72, 0x54, 0xCF + }, + { + 0xB2, 0x57, 0x82, 0x8B, 0xD2, 0xD0, 0xEC, 0x8D, + 0x89, 0x08, 0x05, 0x1D, 0xD1, 0x83, 0x2F, 0x2F, + 0xFD, 0xD3, 0x86, 0x10, 0x83, 0x68, 0x2E, 0x80, + 0x35, 0xA5, 0x59, 0x7F, 0x49, 0xA2, 0x0B, 0xCF + }, + { + 0xA6, 0x8D, 0x23, 0x05, 0x6B, 0x48, 0xF1, 0x71, + 0x42, 0xAB, 0x2C, 0x66, 0x61, 0xB8, 0x9E, 0xCF, + 0xD4, 0x27, 0xC2, 0x18, 0x6A, 0x48, 0x36, 0xC1, + 0x3F, 0x6B, 0x74, 0xAE, 0x9C, 0xF6, 0x15, 0x0E + }, + { + 0x3F, 0x7C, 0xD0, 0x34, 0xEA, 0x3C, 0x55, 0x3B, + 0x1F, 0x6B, 0x74, 0x7E, 0xC5, 0x4F, 0x0F, 0x05, + 0x59, 0xA0, 0xC1, 0x55, 0x20, 0x0B, 0x31, 0x44, + 0xAF, 0x5C, 0x47, 0x16, 0x94, 0x49, 0xD2, 0x2C + }, + { + 0x99, 0xFE, 0x9C, 0x95, 0xA2, 0xEA, 0x3E, 0x6A, + 0x61, 0x2C, 0x0C, 0xE8, 0x15, 0x60, 0xC2, 0x83, + 0x1F, 0x05, 0xA7, 0x08, 0x8D, 0x47, 0x73, 0x85, + 0xCE, 0xD7, 0x40, 0x83, 0x9B, 0x4E, 0x42, 0xD1 + }, + { + 0x3A, 0x21, 0xB0, 0xCF, 0xDB, 0x31, 0x46, 0x2C, + 0xD9, 0x52, 0x67, 0x73, 0xB0, 0xF7, 0x90, 0x6D, + 0xC2, 0x82, 0xE1, 0x07, 0xAC, 0x9C, 0x93, 0x8B, + 0x4A, 0x92, 0x0D, 0x5E, 0xE9, 0xD4, 0x8B, 0x0F + }, + { + 0x69, 0xE4, 0x44, 0xA9, 0x62, 0x23, 0x53, 0x7C, + 0x6D, 0x38, 0x87, 0x77, 0x8D, 0x46, 0x11, 0x5E, + 0x41, 0x2C, 0x5A, 0xE8, 0x88, 0x89, 0x89, 0x37, + 0xFA, 0x49, 0x29, 0x50, 0x96, 0x6B, 0x11, 0x01 + }, + { + 0x83, 0xA2, 0xD3, 0xB1, 0x22, 0x04, 0x34, 0x33, + 0x5C, 0x6F, 0x65, 0x79, 0x6C, 0x3A, 0x61, 0x1C, + 0x7E, 0x0D, 0x52, 0xB8, 0xE1, 0x37, 0x04, 0xE4, + 0x36, 0x40, 0x40, 0x5F, 0x0E, 0xAB, 0x82, 0x14 + }, + { + 0x9E, 0xDB, 0xE0, 0xAA, 0x15, 0x5E, 0x67, 0x49, + 0xB9, 0x27, 0x1A, 0x26, 0x0A, 0x7A, 0xA8, 0x83, + 0x16, 0x1B, 0xF8, 0x86, 0x3E, 0x47, 0x75, 0xF1, + 0x51, 0x35, 0xE3, 0x00, 0xC0, 0x35, 0xBB, 0x74 + }, + { + 0xAD, 0x70, 0xA0, 0xCC, 0xBC, 0x1B, 0xB1, 0xA1, + 0x17, 0x72, 0x07, 0x4F, 0x11, 0x05, 0x1E, 0xFF, + 0x3B, 0x18, 0xBA, 0x45, 0x0F, 0x6D, 0x90, 0x48, + 0x2C, 0xCC, 0x00, 0x0C, 0xD2, 0x81, 0x8A, 0x32 + }, + { + 0xF3, 0xD8, 0x54, 0x13, 0x9F, 0x23, 0xF5, 0xE7, + 0xD1, 0x94, 0xB2, 0x92, 0x04, 0x39, 0x58, 0xB7, + 0x7D, 0xB0, 0x7D, 0xF1, 0xD7, 0x74, 0xE3, 0x1A, + 0xB4, 0x55, 0x40, 0x3E, 0x61, 0xD0, 0x40, 0x2F + }, + { + 0xDC, 0xCD, 0xB1, 0xB8, 0x79, 0xA6, 0x43, 0x80, + 0x08, 0x37, 0xD7, 0x41, 0xC6, 0x37, 0x2C, 0xF6, + 0x23, 0x36, 0x53, 0xDB, 0x0D, 0xEC, 0x87, 0xB3, + 0x7E, 0x9F, 0x5B, 0xBD, 0xC8, 0x10, 0xE9, 0xBE + }, + { + 0x7D, 0xBC, 0xBD, 0xA3, 0xD9, 0x84, 0x51, 0x4A, + 0x0E, 0xC8, 0x34, 0xE3, 0xA9, 0x2B, 0x1A, 0xE4, + 0x27, 0x11, 0x60, 0x7C, 0xE0, 0x97, 0xAE, 0xD3, + 0x46, 0x57, 0x05, 0x4A, 0x01, 0xD3, 0xE6, 0x06 + }, + { + 0x4E, 0x39, 0x22, 0x3A, 0x77, 0x26, 0x57, 0x9E, + 0xD8, 0x05, 0x1A, 0x11, 0x28, 0x91, 0xB5, 0x2C, + 0xE4, 0x57, 0xE8, 0x50, 0x08, 0x26, 0x9E, 0xCA, + 0x56, 0xF1, 0x96, 0x0F, 0x6F, 0xF2, 0x76, 0x79 + }, + { + 0xCA, 0xE8, 0x89, 0xEA, 0xDF, 0x4F, 0x79, 0xC3, + 0xF5, 0x7C, 0xCB, 0x66, 0x1A, 0x42, 0x08, 0x9B, + 0xAB, 0x2A, 0xCB, 0x89, 0x1D, 0xAA, 0x57, 0x3B, + 0xEA, 0x92, 0x03, 0x20, 0x89, 0xAD, 0xA9, 0x11 + }, + { + 0xDC, 0x0B, 0x17, 0xD6, 0xB7, 0x04, 0xE2, 0xBF, + 0x51, 0x66, 0x9A, 0x59, 0xB4, 0xF3, 0xDA, 0x87, + 0x03, 0xBF, 0x59, 0xB0, 0x0F, 0x15, 0x00, 0x35, + 0x18, 0x8D, 0xFF, 0xE7, 0x9B, 0x4A, 0xF8, 0xD2 + }, + { + 0x79, 0x30, 0x63, 0xE9, 0x18, 0x1D, 0x27, 0x3E, + 0x26, 0x9A, 0x41, 0x2D, 0x61, 0xCA, 0xB9, 0xAF, + 0x4E, 0x86, 0x96, 0xF3, 0x89, 0x2F, 0xA8, 0x01, + 0x6F, 0x77, 0xD7, 0xBB, 0x0E, 0x61, 0x93, 0x8C + }, + { + 0x6E, 0xDC, 0x77, 0x3F, 0xF4, 0x16, 0xD5, 0xD3, + 0xD0, 0xBE, 0x04, 0x55, 0xD7, 0x75, 0x0D, 0xD7, + 0xDE, 0x49, 0x83, 0x2F, 0x5B, 0x3A, 0xB1, 0x59, + 0xB8, 0xCE, 0x39, 0x2B, 0x89, 0xF3, 0x20, 0xD0 + }, + { + 0x7F, 0x46, 0x15, 0xD3, 0x25, 0x10, 0xA8, 0x41, + 0xA8, 0x58, 0x7B, 0xCF, 0x32, 0xA2, 0x3C, 0xF4, + 0xB3, 0x74, 0x17, 0xB4, 0x88, 0x51, 0x90, 0x58, + 0xC4, 0x79, 0x84, 0x72, 0x56, 0x2F, 0x47, 0x18 + }, + { + 0xFA, 0xE6, 0xE2, 0xCA, 0xCF, 0x7E, 0x47, 0xF8, + 0x07, 0x81, 0x81, 0x60, 0x19, 0x59, 0x68, 0x96, + 0xC1, 0x08, 0x37, 0x91, 0x1F, 0xDB, 0x3C, 0x5F, + 0x1E, 0x97, 0x11, 0x29, 0x12, 0xE5, 0x37, 0xCD + }, + { + 0x22, 0x88, 0xC3, 0x01, 0x1B, 0x3A, 0x17, 0xFE, + 0x6F, 0x77, 0x54, 0x68, 0x0B, 0xCF, 0x45, 0xCB, + 0x9F, 0x58, 0x4E, 0x39, 0x34, 0xBE, 0xB1, 0xC7, + 0x1B, 0xEF, 0x91, 0xC0, 0x57, 0x0D, 0x14, 0xBD + }, + { + 0xBF, 0xB3, 0xA2, 0x26, 0xC0, 0x64, 0x82, 0x87, + 0xB2, 0xDE, 0xCF, 0x83, 0xC1, 0x67, 0x4E, 0x5A, + 0xE1, 0x6A, 0xBC, 0xCE, 0x2C, 0xAC, 0x8D, 0x45, + 0x6F, 0x11, 0x84, 0xD0, 0xC3, 0x34, 0x37, 0xBE + }, + { + 0xE3, 0x23, 0xE0, 0x94, 0x31, 0xBD, 0x9B, 0x52, + 0x34, 0xC9, 0xA1, 0x68, 0xA2, 0x15, 0xB4, 0x74, + 0x04, 0xE9, 0xC3, 0x77, 0x60, 0x56, 0xA2, 0x5E, + 0xCC, 0x85, 0xBB, 0x71, 0x18, 0x6A, 0x23, 0xA3 + }, + { + 0xA3, 0x9A, 0x20, 0x25, 0x6F, 0xCA, 0x28, 0x8D, + 0xE2, 0x78, 0xEC, 0xF9, 0x50, 0x71, 0x4D, 0x3B, + 0x78, 0x7A, 0xEF, 0x83, 0x97, 0x58, 0x0F, 0x21, + 0xE4, 0x24, 0x54, 0xEA, 0xB6, 0xFB, 0xB1, 0x1E + }, + { + 0x21, 0xD1, 0x15, 0x54, 0xD9, 0x9E, 0x42, 0x2B, + 0x9D, 0x96, 0xD4, 0x28, 0x3B, 0x57, 0x78, 0x0C, + 0xE3, 0xD4, 0x99, 0x28, 0x19, 0x62, 0x90, 0x0B, + 0x20, 0x08, 0x8B, 0x76, 0xAE, 0x7E, 0x0B, 0x02 + }, + { + 0x9E, 0xC3, 0x99, 0x86, 0x68, 0x13, 0x7B, 0xD5, + 0x16, 0x1E, 0x42, 0x17, 0x38, 0x54, 0x92, 0xE1, + 0x79, 0xFB, 0xD9, 0x9E, 0x6F, 0x32, 0x2B, 0x87, + 0xC5, 0xD0, 0xF8, 0x7B, 0x82, 0x78, 0x19, 0x52 + }, + { + 0xA7, 0x61, 0x18, 0xA6, 0x6C, 0x55, 0x4F, 0x84, + 0x86, 0x92, 0xCD, 0x80, 0xF0, 0x89, 0x21, 0x8C, + 0x21, 0x48, 0xEC, 0x89, 0x3C, 0x65, 0x90, 0xF5, + 0x4F, 0x01, 0xDB, 0x4C, 0xFF, 0xC7, 0xA1, 0xAD + }, + { + 0x17, 0x6D, 0x64, 0x6A, 0xC6, 0xBF, 0x9A, 0x79, + 0x6B, 0x33, 0x8D, 0xE3, 0x49, 0x9E, 0xAF, 0x0C, + 0xCE, 0x6F, 0x4F, 0xE3, 0xDD, 0xC9, 0x93, 0x0C, + 0xEE, 0x43, 0xBB, 0x6F, 0x80, 0xD3, 0xEC, 0x80 + }, + { + 0x02, 0x23, 0x1D, 0x35, 0x50, 0xB5, 0x00, 0x69, + 0x76, 0x1D, 0x19, 0x9E, 0x4A, 0xA8, 0x85, 0x45, + 0x7E, 0xF5, 0x16, 0x1D, 0x04, 0xE1, 0x6F, 0x09, + 0x09, 0x56, 0x51, 0x9E, 0x05, 0x38, 0x87, 0x13 + }, + { + 0xAC, 0x8C, 0x3F, 0x2B, 0x74, 0xFC, 0x30, 0x59, + 0x90, 0x3D, 0x0C, 0x85, 0xC8, 0x9D, 0xA1, 0xF9, + 0xF6, 0xA7, 0x3A, 0x69, 0xCD, 0x59, 0xCB, 0x7A, + 0x8A, 0x65, 0xD9, 0xB4, 0x5B, 0x13, 0x6B, 0x91 + }, + { + 0xE7, 0x2B, 0x7A, 0xEB, 0x39, 0x36, 0x2D, 0x9E, + 0xDE, 0x7E, 0x45, 0x93, 0xB0, 0x2D, 0x87, 0x18, + 0x18, 0x62, 0xD0, 0xF4, 0x81, 0xB1, 0x9A, 0xEB, + 0xCF, 0xBD, 0x1F, 0xDC, 0x39, 0x88, 0x5D, 0xB1 + }, + { + 0x86, 0x2A, 0xF4, 0xE7, 0xBC, 0x4B, 0xFE, 0xF5, + 0xAB, 0x30, 0x51, 0xE2, 0xA4, 0xEA, 0x1D, 0x5E, + 0x22, 0xEE, 0x30, 0x57, 0xCB, 0xBB, 0xE0, 0x98, + 0xE9, 0x41, 0xD0, 0xE3, 0xFC, 0xE0, 0x38, 0xB2 + }, + { + 0x6E, 0xCC, 0x69, 0x9E, 0xD6, 0xDF, 0xCD, 0x0B, + 0xF7, 0xDB, 0xD9, 0xE8, 0x48, 0xFE, 0x20, 0x5E, + 0x37, 0xDC, 0x0F, 0x98, 0xB5, 0xBC, 0x56, 0x09, + 0x78, 0xB4, 0xBF, 0xAA, 0x68, 0x98, 0xFD, 0x52 + }, + { + 0x53, 0xCA, 0xCC, 0x8F, 0xDD, 0x53, 0xC0, 0x1D, + 0x49, 0xC5, 0x56, 0x94, 0x77, 0xA8, 0xD8, 0xC5, + 0xFD, 0x98, 0x47, 0x4E, 0x8D, 0xDD, 0xED, 0x8F, + 0x54, 0x5C, 0x86, 0xD6, 0x97, 0x8E, 0x2E, 0x96 + }, + { + 0xC9, 0xCE, 0xFF, 0x51, 0x69, 0x74, 0xE5, 0xF5, + 0x52, 0x55, 0x61, 0x79, 0x35, 0xFB, 0x1F, 0x89, + 0xC1, 0xD5, 0x13, 0xE3, 0xE0, 0xE2, 0x69, 0x85, + 0x74, 0x55, 0xB1, 0x8B, 0x7F, 0xD3, 0x6D, 0x89 + }, + { + 0xDA, 0x8E, 0xC3, 0x1E, 0x72, 0x83, 0xA7, 0xC1, + 0xEF, 0x5A, 0xBD, 0xFA, 0x21, 0x5F, 0xB5, 0x4C, + 0xF1, 0x75, 0x6A, 0x42, 0xA2, 0x3F, 0x56, 0x0C, + 0x49, 0xBE, 0x8F, 0xF4, 0xDA, 0x34, 0x8A, 0xCA + }, + { + 0x51, 0x1B, 0x78, 0x8F, 0xF5, 0x4E, 0xEB, 0x4F, + 0x61, 0xE9, 0xE3, 0x85, 0xE0, 0xA6, 0xEA, 0x75, + 0x02, 0x17, 0x6E, 0x3F, 0xD2, 0x22, 0xD7, 0x10, + 0xD6, 0xF1, 0x71, 0x8E, 0x72, 0x70, 0xB9, 0x69 + }, + { + 0xBF, 0x52, 0xDF, 0xA1, 0x11, 0x52, 0xBA, 0xA9, + 0xA3, 0x87, 0xD2, 0xF2, 0x6A, 0x9E, 0x68, 0xFE, + 0x58, 0xB3, 0x29, 0x78, 0x3F, 0xFC, 0x71, 0x05, + 0x74, 0x6B, 0x3E, 0xA6, 0x5A, 0xE1, 0x68, 0x22 + }, + { + 0x9D, 0x75, 0x24, 0xEE, 0xD2, 0xCD, 0x6A, 0x1E, + 0x3B, 0xB6, 0x8D, 0x5E, 0xF0, 0x80, 0xAF, 0xF7, + 0x25, 0xBC, 0xC7, 0xD0, 0xD6, 0x30, 0xF7, 0xC9, + 0x77, 0x74, 0x48, 0xB9, 0xA7, 0xCC, 0x67, 0x39 + }, + { + 0xB5, 0x80, 0xF5, 0x55, 0x33, 0x82, 0xA3, 0xD1, + 0x47, 0x0D, 0xC9, 0x2B, 0x01, 0x17, 0xD6, 0xA8, + 0x4D, 0x94, 0x7B, 0xA7, 0x77, 0x38, 0xEE, 0x87, + 0x6B, 0x63, 0x3B, 0x74, 0xAC, 0x2E, 0x50, 0x16 + }, + { + 0x74, 0x2F, 0xF2, 0xB3, 0x8E, 0xF3, 0x83, 0xA8, + 0x27, 0x43, 0xF2, 0x50, 0xB7, 0x8D, 0xCC, 0x6A, + 0x98, 0x7A, 0x66, 0xFD, 0xC5, 0x1A, 0x39, 0x48, + 0x27, 0x74, 0xBB, 0x2B, 0x23, 0x1A, 0xD9, 0x6A + }, + { + 0x2E, 0x16, 0x37, 0xA2, 0x34, 0xA7, 0x48, 0xBB, + 0x0B, 0x30, 0x6B, 0xCB, 0x37, 0xC5, 0x0F, 0x20, + 0x24, 0x85, 0xC7, 0x52, 0x54, 0xF7, 0x4D, 0x36, + 0x86, 0x35, 0x92, 0xF0, 0x06, 0xFB, 0xB7, 0x9B + }, + { + 0x1F, 0xB8, 0x17, 0xE7, 0xFD, 0x5D, 0x32, 0xAA, + 0x3D, 0xCC, 0x27, 0x00, 0xAB, 0xA0, 0xE3, 0xAB, + 0x2C, 0x32, 0x30, 0x9C, 0xC3, 0xF0, 0xE1, 0x3D, + 0x96, 0x05, 0x98, 0x8E, 0x63, 0x41, 0x01, 0x67 + }, + { + 0x6D, 0x65, 0xD6, 0xE4, 0xE3, 0x56, 0x89, 0xB2, + 0x1E, 0x92, 0xBF, 0xDE, 0x62, 0xE8, 0x5D, 0x55, + 0xB5, 0x37, 0x75, 0x5F, 0xAC, 0xE1, 0xD6, 0x72, + 0x1E, 0x7F, 0x42, 0x7C, 0x3B, 0x80, 0xC0, 0x7E + }, + { + 0xD8, 0x7D, 0xAB, 0x56, 0x9C, 0x68, 0x99, 0xFC, + 0x07, 0xB8, 0x9B, 0xE5, 0x44, 0xE7, 0x85, 0xB7, + 0xA2, 0x5C, 0x8E, 0xFC, 0x8B, 0xE6, 0x9A, 0x2C, + 0xA5, 0x72, 0x2E, 0xF1, 0xFA, 0xD5, 0x2B, 0xD2 + }, + { + 0x24, 0x51, 0xEC, 0x1B, 0x02, 0x2D, 0x5B, 0xEB, + 0xD0, 0x85, 0x4A, 0xE1, 0xD8, 0xE8, 0x5B, 0x4E, + 0x60, 0x1B, 0x21, 0xCE, 0x96, 0x5A, 0xE6, 0x19, + 0xF6, 0x40, 0x68, 0xEA, 0x4F, 0x47, 0x66, 0xB4 + }, + { + 0x54, 0xCE, 0x52, 0x31, 0xDA, 0x40, 0x66, 0x84, + 0xCF, 0x02, 0x8A, 0x57, 0x92, 0x09, 0xCA, 0xA3, + 0x3E, 0x81, 0x97, 0x0A, 0xE4, 0x47, 0x9C, 0x30, + 0x53, 0x0A, 0xEE, 0x86, 0x5E, 0x90, 0x19, 0x61 + }, + { + 0x33, 0x97, 0x1A, 0x90, 0xA6, 0xD3, 0xF2, 0x19, + 0x69, 0xD9, 0x32, 0xD8, 0xD9, 0x25, 0xAB, 0x41, + 0x99, 0xD6, 0xF3, 0x4B, 0xCE, 0x06, 0x7C, 0x8A, + 0xA3, 0x31, 0x92, 0x07, 0x1D, 0xCC, 0x91, 0x31 + }, + { + 0x82, 0xC4, 0x14, 0xA6, 0xF9, 0xCE, 0x4D, 0xEF, + 0x8D, 0x2D, 0x13, 0xF8, 0xAF, 0x44, 0xAF, 0x51, + 0xFB, 0xA2, 0x4F, 0xD7, 0x7A, 0xF4, 0x91, 0x26, + 0x6F, 0x2F, 0x54, 0xCD, 0x78, 0xF6, 0xDF, 0x14 + }, + { + 0x6F, 0xEE, 0x57, 0x4E, 0x48, 0x6A, 0xCA, 0x1A, + 0x50, 0xE0, 0xB5, 0x88, 0x4D, 0x42, 0x69, 0x1A, + 0x8A, 0xEE, 0x37, 0x46, 0x6F, 0xAB, 0x07, 0x12, + 0x38, 0x86, 0xF9, 0xF3, 0x5D, 0xA8, 0x10, 0x3E + }, + { + 0x07, 0x02, 0x95, 0x69, 0xE0, 0xFA, 0x62, 0x84, + 0x2A, 0xC1, 0x9A, 0xCE, 0xD3, 0xC3, 0xB6, 0x5B, + 0xA8, 0xA4, 0xED, 0x8D, 0x8D, 0xB6, 0x61, 0x08, + 0x6C, 0xC5, 0xA2, 0x61, 0x7B, 0xE2, 0xFB, 0x1D + }, + { + 0x06, 0xE9, 0xFC, 0x1A, 0x70, 0x85, 0x51, 0x33, + 0x1D, 0x5A, 0xEB, 0x29, 0x76, 0x51, 0x5C, 0xDB, + 0xA8, 0x3A, 0x24, 0x78, 0xCF, 0x15, 0xDB, 0x60, + 0x9A, 0xE4, 0x28, 0x38, 0xB6, 0x0C, 0xAA, 0xE4 + }, + { + 0xE2, 0x65, 0xA6, 0x18, 0xE6, 0x80, 0x01, 0x73, + 0x3E, 0x3F, 0xAE, 0x30, 0xCE, 0x93, 0x3E, 0x10, + 0x4A, 0xCC, 0x1F, 0x2F, 0x61, 0x6C, 0x88, 0x1A, + 0x11, 0x57, 0x4F, 0x45, 0x6C, 0x8B, 0x67, 0xF8 + }, + { + 0xEF, 0xE3, 0x0A, 0x54, 0x7A, 0x0D, 0x3A, 0xE6, + 0x87, 0xD5, 0x0F, 0x2A, 0x2A, 0xDB, 0xF1, 0x9E, + 0xFC, 0xC4, 0x02, 0x70, 0x64, 0x20, 0x1F, 0x4B, + 0x32, 0x26, 0xC1, 0x95, 0x36, 0x05, 0x12, 0xC8 + }, + { + 0x17, 0xA0, 0x2D, 0x70, 0x64, 0xBE, 0x0C, 0xA1, + 0x4B, 0xFE, 0x0D, 0x1A, 0x28, 0xF1, 0x42, 0x92, + 0xE0, 0xE0, 0xFA, 0x6A, 0x98, 0x6A, 0x5F, 0x67, + 0xB8, 0x2A, 0xBC, 0xFA, 0xFA, 0x56, 0x6D, 0x6D + }, + { + 0x2C, 0x24, 0xE8, 0x0F, 0x92, 0x16, 0x79, 0x8C, + 0xC4, 0x65, 0xCC, 0x92, 0x23, 0x0C, 0xD7, 0x44, + 0x6D, 0x91, 0xF1, 0x96, 0xC7, 0xC6, 0x2B, 0x4B, + 0xDA, 0xB5, 0x9E, 0xF8, 0x07, 0x55, 0xE6, 0xD0 + }, + { + 0x98, 0x53, 0x2B, 0x89, 0x70, 0x35, 0x22, 0x82, + 0x54, 0x6B, 0x57, 0x0C, 0xA7, 0xCD, 0x29, 0x7D, + 0xFF, 0x9B, 0x9F, 0x35, 0x4D, 0x1A, 0x00, 0x3F, + 0x43, 0xD9, 0x24, 0x27, 0x7F, 0x51, 0x76, 0x35 + }, + { + 0x58, 0xF8, 0xBD, 0xDB, 0x4D, 0x00, 0xCE, 0xC2, + 0x23, 0x43, 0xD1, 0xE6, 0x2B, 0xDE, 0xD2, 0x2A, + 0xD8, 0x25, 0x15, 0x49, 0xE2, 0xDA, 0x7E, 0x35, + 0x4B, 0x62, 0x6A, 0xF6, 0x96, 0x3B, 0x12, 0x6D + }, + { + 0x32, 0xC7, 0x31, 0x5A, 0xE1, 0x6A, 0x26, 0xE3, + 0x4D, 0xCA, 0x38, 0x52, 0xB6, 0x70, 0xDF, 0xBA, + 0xB0, 0x52, 0x54, 0x51, 0xD8, 0xD1, 0x00, 0x19, + 0x04, 0x1E, 0x53, 0x5A, 0x33, 0xB6, 0x68, 0x87 + }, + { + 0x77, 0x69, 0xBA, 0xB4, 0x16, 0xFE, 0x29, 0x54, + 0xF3, 0xCD, 0xF8, 0x66, 0x00, 0xCC, 0x77, 0x1D, + 0x44, 0x46, 0xB6, 0x67, 0xB2, 0x5E, 0x66, 0xF4, + 0x43, 0xAB, 0xF8, 0xB7, 0xC9, 0x58, 0x75, 0x9B + }, + { + 0xD6, 0x2D, 0xDE, 0xFC, 0x8B, 0xB2, 0x34, 0x56, + 0xB7, 0x63, 0xC7, 0xFC, 0xF7, 0x7E, 0xB7, 0x2C, + 0x2B, 0x87, 0x5F, 0xF7, 0x94, 0x82, 0x3C, 0xD8, + 0x0C, 0x01, 0xAA, 0xF5, 0x07, 0xB1, 0xBC, 0x7F + }, + { + 0x9A, 0x42, 0xB3, 0xF6, 0x93, 0xC6, 0x08, 0x4A, + 0xA8, 0xA5, 0x28, 0xA4, 0x7B, 0xC9, 0xB8, 0x8F, + 0x71, 0x22, 0x42, 0x0F, 0xD3, 0x1F, 0xB0, 0x49, + 0xB6, 0xE6, 0x37, 0xF0, 0x5A, 0x06, 0x85, 0xEE + }, + { + 0xDE, 0xB6, 0x6D, 0x78, 0x55, 0xD3, 0xD3, 0x27, + 0x0C, 0x60, 0x2C, 0xFC, 0x09, 0xF8, 0xA5, 0x0D, + 0x81, 0xF8, 0xAB, 0x53, 0xFD, 0x41, 0x1E, 0x46, + 0x63, 0xF3, 0x6A, 0xF6, 0xFB, 0x00, 0xDE, 0xF7 + }, + { + 0x07, 0xAD, 0x36, 0x21, 0x20, 0x0B, 0xC5, 0xC1, + 0x33, 0xC9, 0x28, 0xBB, 0x9B, 0x42, 0x76, 0x41, + 0xB9, 0x90, 0x1E, 0xFF, 0xB1, 0xD1, 0x83, 0xF8, + 0x52, 0xDE, 0xDF, 0x74, 0xE4, 0x4A, 0xEB, 0xCE + }, + { + 0x61, 0xB3, 0x2E, 0xEF, 0xCA, 0x3C, 0xE8, 0xA9, + 0x6D, 0xA6, 0xA4, 0x6A, 0xBF, 0x6B, 0x79, 0x8A, + 0x69, 0xF4, 0xCA, 0x9D, 0x8B, 0xB5, 0xCC, 0x7D, + 0xC0, 0x33, 0xBB, 0x5D, 0x58, 0x2C, 0x42, 0xFA + }, + { + 0xA9, 0x39, 0xC4, 0x35, 0x83, 0xBC, 0xC5, 0x8F, + 0x0D, 0x8B, 0xBA, 0xF6, 0x8F, 0x24, 0x5A, 0x29, + 0x45, 0x12, 0xCB, 0x26, 0x6E, 0x7E, 0x29, 0x11, + 0x39, 0x7C, 0xBC, 0xB5, 0xE0, 0x7E, 0x9E, 0x51 + }, + { + 0xD4, 0x2D, 0x01, 0x19, 0xF5, 0xCE, 0x72, 0x78, + 0xE3, 0xF2, 0x63, 0x63, 0x5F, 0x54, 0x7D, 0x16, + 0x22, 0x62, 0x52, 0x82, 0x62, 0x82, 0x47, 0xCA, + 0x6C, 0xFE, 0x31, 0xE6, 0xB4, 0xCA, 0x73, 0xCF + }, + { + 0x65, 0x9E, 0x89, 0x9D, 0x4D, 0x48, 0x60, 0x44, + 0x99, 0x48, 0x2B, 0x2A, 0xDE, 0x64, 0x10, 0x63, + 0x79, 0xB5, 0x42, 0x30, 0x5D, 0x55, 0x6F, 0x1F, + 0x37, 0x26, 0x73, 0x7D, 0x7A, 0xB9, 0x45, 0xDE + }, + { + 0x06, 0xFC, 0x9A, 0x83, 0x52, 0x00, 0xFA, 0xFB, + 0x28, 0xEA, 0x6A, 0x87, 0x21, 0x8D, 0xA7, 0xD0, + 0xED, 0xB8, 0x3E, 0x2A, 0x0F, 0xE9, 0x14, 0x53, + 0x6D, 0xAA, 0x2F, 0xEF, 0x63, 0x00, 0xAD, 0x0E + }, + { + 0x4C, 0xBA, 0x8D, 0x45, 0x9A, 0xC9, 0xDD, 0x89, + 0x39, 0xDE, 0x83, 0xD4, 0xD9, 0x28, 0x74, 0x41, + 0xA4, 0x03, 0x6D, 0xDE, 0x1B, 0x94, 0x66, 0xA7, + 0x6A, 0x56, 0x21, 0xE9, 0x46, 0xD3, 0x99, 0xDF + }, + { + 0x58, 0x33, 0x12, 0x21, 0x46, 0xD8, 0x14, 0x58, + 0xCD, 0x1B, 0x66, 0x8C, 0x65, 0x75, 0xBB, 0xB3, + 0x73, 0x58, 0x76, 0x83, 0x7A, 0x02, 0x37, 0xDA, + 0xBB, 0xF3, 0x26, 0x3F, 0xC4, 0xD9, 0x4C, 0x68 + }, + { + 0x28, 0x51, 0x1F, 0xCC, 0x44, 0x6B, 0x6B, 0xA4, + 0x1C, 0x6F, 0x4E, 0x93, 0x2A, 0x0C, 0x12, 0x9E, + 0x07, 0x13, 0x8B, 0x69, 0xAE, 0x47, 0xD5, 0x51, + 0x96, 0xC5, 0xA0, 0xA1, 0xA0, 0x33, 0xBA, 0x36 + }, + { + 0x4E, 0x1B, 0x3B, 0x01, 0x63, 0xF8, 0x3E, 0x65, + 0xE8, 0x62, 0x2A, 0xE6, 0xCB, 0x54, 0x2D, 0x59, + 0xF7, 0xF8, 0xDE, 0x0D, 0xD3, 0xAB, 0x2C, 0x4E, + 0x30, 0x20, 0x47, 0x51, 0x65, 0x9E, 0x95, 0x15 + }, + { + 0xAE, 0x38, 0x64, 0xDB, 0x79, 0xFF, 0x29, 0x4B, + 0xE6, 0xD4, 0x24, 0x8E, 0x54, 0x19, 0x8D, 0x82, + 0x46, 0x5C, 0x8D, 0xB6, 0x41, 0x0F, 0x03, 0x23, + 0xE1, 0x34, 0xFF, 0x2E, 0x12, 0xC6, 0x96, 0x89 + }, + { + 0x14, 0xF7, 0x03, 0x16, 0xAF, 0x6C, 0x5C, 0x78, + 0x6C, 0x37, 0x01, 0xEC, 0xC9, 0x32, 0xE6, 0x0B, + 0x37, 0x10, 0xD2, 0x48, 0x3D, 0x38, 0x62, 0xDD, + 0x8E, 0x43, 0xCB, 0xFF, 0x70, 0x59, 0xE3, 0x1C + }, + { + 0xFA, 0x6F, 0x29, 0x2E, 0x3F, 0x23, 0x32, 0x57, + 0x89, 0x54, 0x5E, 0xEF, 0x90, 0xF2, 0x2F, 0xCC, + 0x5C, 0x1B, 0x5B, 0x3A, 0xF5, 0x91, 0x8E, 0x6F, + 0x48, 0x00, 0x5F, 0x94, 0x41, 0x67, 0x11, 0x52 + }, + { + 0x61, 0x8F, 0x40, 0x20, 0x45, 0xF6, 0xCF, 0x5C, + 0x9B, 0x12, 0x38, 0x90, 0xC1, 0x1F, 0x30, 0x9A, + 0x33, 0x74, 0x90, 0x18, 0x5B, 0x35, 0xDD, 0x20, + 0xAB, 0x3B, 0x3A, 0xD2, 0x7C, 0xE4, 0xB3, 0x53 + }, + { + 0x54, 0x26, 0xFC, 0xCE, 0xC4, 0x47, 0x8B, 0xAD, + 0xF9, 0xE0, 0xA2, 0x43, 0x79, 0xBA, 0xB8, 0x7C, + 0xBA, 0x8D, 0x3A, 0xF0, 0x5D, 0xEA, 0xFD, 0x18, + 0x71, 0xF7, 0xC0, 0xCF, 0x5F, 0x44, 0xD8, 0x70 + }, + { + 0x8D, 0xAC, 0xEB, 0x7D, 0x1D, 0x85, 0x83, 0x9A, + 0x6B, 0xE9, 0x3B, 0xDA, 0xA2, 0xBE, 0x33, 0x8C, + 0xDB, 0x0D, 0xEE, 0xA8, 0x8D, 0xC7, 0x78, 0x0C, + 0xBD, 0x12, 0x8B, 0xC9, 0x59, 0xAE, 0x1F, 0x76 + }, + { + 0x6F, 0x4D, 0x6C, 0x31, 0xDC, 0x51, 0x59, 0x41, + 0x15, 0xC2, 0xD7, 0x16, 0x3D, 0xD0, 0x89, 0xBF, + 0x85, 0x1C, 0xF7, 0x71, 0x40, 0x69, 0xE1, 0x71, + 0x16, 0x0C, 0xEA, 0xB2, 0x1E, 0xE9, 0x7C, 0xC3 + }, + { + 0xB3, 0x67, 0xE6, 0x0F, 0xB8, 0xA0, 0x83, 0x3D, + 0x7D, 0xAD, 0xDD, 0xC6, 0x6C, 0xC9, 0xB5, 0x4A, + 0xC8, 0x26, 0xC5, 0xFE, 0x71, 0x5B, 0x4C, 0x9F, + 0xA5, 0xA5, 0x51, 0xC2, 0xBE, 0x0C, 0xC8, 0x78 + }, + { + 0x83, 0xEE, 0x2D, 0x4D, 0x99, 0xD4, 0x84, 0x68, + 0x76, 0x07, 0xD1, 0x43, 0xBD, 0x09, 0x94, 0xC6, + 0xC7, 0x75, 0x2D, 0xA2, 0x55, 0x06, 0x4A, 0xA7, + 0x60, 0x62, 0x89, 0xBC, 0x49, 0x6E, 0x37, 0x0D + }, + { + 0x65, 0xDB, 0x6D, 0xBE, 0xC0, 0x4F, 0xFC, 0xFE, + 0x79, 0xDF, 0xB2, 0x41, 0xE5, 0xCB, 0x83, 0xBF, + 0xAE, 0xDA, 0x64, 0xCC, 0xD3, 0x47, 0x01, 0x81, + 0xFA, 0x6E, 0x52, 0x69, 0x27, 0x9F, 0xA3, 0xDB + }, + { + 0x2E, 0xD3, 0x4D, 0xED, 0xD8, 0xDA, 0x03, 0xEF, + 0x72, 0x18, 0x36, 0x63, 0xA1, 0x43, 0x8E, 0xDE, + 0xE8, 0xDF, 0xE9, 0xBF, 0xF6, 0xBD, 0x9F, 0xC4, + 0x7B, 0x8C, 0xE6, 0x65, 0xCC, 0xEA, 0x1D, 0x02 + }, + { + 0xE3, 0x24, 0xD6, 0xD2, 0xCF, 0xEF, 0x91, 0x67, + 0x83, 0x2B, 0x12, 0x94, 0x7F, 0xF1, 0xA3, 0x16, + 0x2F, 0x5D, 0xD2, 0xA8, 0xB1, 0xC5, 0x6D, 0xE2, + 0x54, 0x4D, 0xFC, 0x60, 0xF3, 0x73, 0x49, 0xC4 + }, + { + 0x5C, 0x4F, 0x21, 0x16, 0xA9, 0xF6, 0x40, 0xA5, + 0x3B, 0x0C, 0xD2, 0x07, 0x0F, 0x5E, 0x68, 0x13, + 0x4E, 0x82, 0xC9, 0x31, 0x36, 0x0F, 0x74, 0xC1, + 0xB2, 0x5A, 0x79, 0x6C, 0x18, 0xCD, 0xFC, 0xD4 + }, + { + 0x71, 0x04, 0x7A, 0x17, 0x00, 0xFE, 0xAE, 0x94, + 0x6E, 0x4D, 0xD4, 0xF2, 0xE2, 0x94, 0x8E, 0x86, + 0xED, 0x33, 0x20, 0xF0, 0x03, 0x6D, 0x23, 0x00, + 0xD4, 0x15, 0x4B, 0xE6, 0x31, 0xE4, 0x49, 0xAA + }, + { + 0x70, 0x53, 0xCD, 0x6B, 0x7C, 0x0F, 0x45, 0x84, + 0x0F, 0x0B, 0x36, 0x00, 0x74, 0xAA, 0x53, 0xF9, + 0xE7, 0x8F, 0xDB, 0x9A, 0xCA, 0x7B, 0x0F, 0xDC, + 0x32, 0x15, 0xE5, 0xE5, 0x86, 0x52, 0x34, 0x84 + }, + { + 0xB7, 0x0A, 0xAC, 0x5A, 0x24, 0x9F, 0xE9, 0x81, + 0x9D, 0x04, 0xCE, 0x7A, 0xAF, 0x2E, 0x13, 0xB3, + 0xD2, 0xF4, 0xCC, 0xCE, 0xFB, 0xFA, 0x6D, 0x3F, + 0xD4, 0x82, 0x42, 0xA1, 0xF4, 0x1B, 0x11, 0x3C + }, + { + 0x47, 0x1D, 0x0F, 0xCC, 0x4A, 0xF2, 0x93, 0x54, + 0xCA, 0xDC, 0xA4, 0x72, 0x6C, 0x20, 0xA4, 0x49, + 0xF7, 0xFB, 0xE4, 0x3A, 0x9B, 0xE7, 0x90, 0x1E, + 0x8A, 0xEC, 0x38, 0x97, 0x1F, 0xEC, 0xC9, 0x96 + }, + { + 0x96, 0x3E, 0xBE, 0x34, 0xE6, 0x37, 0x8A, 0x76, + 0xD2, 0x39, 0x51, 0xC4, 0x6F, 0xB7, 0xE5, 0xC6, + 0xC4, 0xA7, 0xC7, 0x81, 0x03, 0x74, 0x66, 0xD6, + 0x1B, 0xAE, 0x3B, 0xFE, 0x87, 0x7D, 0x21, 0x3D + }, + { + 0xB2, 0x66, 0xA4, 0x10, 0xCA, 0xBD, 0x2D, 0xC5, + 0x18, 0x2F, 0x53, 0x02, 0x75, 0x7F, 0xBC, 0xF9, + 0x72, 0x5C, 0x4B, 0xD9, 0x13, 0x00, 0x7E, 0xAC, + 0x39, 0xA2, 0x98, 0xAD, 0x1E, 0x57, 0xAE, 0x4E + }, + { + 0x37, 0x26, 0x91, 0x76, 0x02, 0xB4, 0x44, 0xB7, + 0x8A, 0x93, 0xD8, 0xF9, 0x96, 0x87, 0xEB, 0xE6, + 0x8A, 0xFD, 0x36, 0x16, 0x99, 0x95, 0xA5, 0x52, + 0xEF, 0xA0, 0xE2, 0x95, 0x5D, 0xC6, 0xB2, 0x25 + }, + { + 0x59, 0x9F, 0x16, 0x02, 0x71, 0x66, 0x6D, 0xEC, + 0x21, 0x99, 0x1A, 0x4B, 0xA8, 0x5C, 0x3F, 0x55, + 0xAB, 0x73, 0xA7, 0x91, 0x5C, 0xB1, 0x94, 0x8E, + 0xA7, 0x8B, 0xDA, 0x0D, 0x51, 0x04, 0xE6, 0x81 + }, + { + 0x78, 0xDE, 0x4F, 0x3C, 0x8D, 0xE0, 0x18, 0xE4, + 0x59, 0xB7, 0xDE, 0xB3, 0x1F, 0x88, 0xC8, 0xAE, + 0xFB, 0x82, 0x3D, 0xBA, 0x14, 0x85, 0x88, 0x09, + 0x11, 0x94, 0x45, 0xF1, 0xF7, 0xC5, 0x9E, 0x3C + }, + { + 0x99, 0x51, 0x9C, 0x74, 0xB8, 0x80, 0xA0, 0x37, + 0xAF, 0xD3, 0x1E, 0xE0, 0xC2, 0x45, 0x91, 0x5E, + 0x74, 0x2E, 0xA0, 0xAD, 0x50, 0x44, 0xA8, 0xBB, + 0x1C, 0x28, 0xE7, 0xE8, 0x47, 0xDA, 0x94, 0x72 + }, + { + 0x00, 0xBF, 0x14, 0x2E, 0x16, 0xAD, 0xBB, 0x5E, + 0x3D, 0xA9, 0x2F, 0x5F, 0x5F, 0x2E, 0x6E, 0x21, + 0x40, 0x60, 0x2A, 0xA7, 0x37, 0xF0, 0x36, 0x36, + 0x31, 0xAE, 0x9A, 0x2D, 0x31, 0x38, 0xDA, 0x0B + }, + { + 0xB9, 0x93, 0xDE, 0x38, 0xB4, 0xC5, 0x78, 0x94, + 0x54, 0x0F, 0xB8, 0x58, 0xF2, 0xEF, 0xD5, 0x8E, + 0x6B, 0xFE, 0xB1, 0x27, 0xC7, 0x50, 0x85, 0x54, + 0x8B, 0x7C, 0xF1, 0x81, 0xD8, 0x25, 0x92, 0x99 + }, + { + 0x40, 0x3C, 0xB0, 0x66, 0xB5, 0xF9, 0xF9, 0x3E, + 0x52, 0xE0, 0x74, 0x6E, 0xE9, 0xD0, 0x23, 0x81, + 0xEE, 0xC7, 0xD4, 0xCA, 0xFA, 0xE2, 0xF5, 0xBA, + 0x0D, 0xBD, 0x71, 0x5E, 0x7F, 0x03, 0x9E, 0x04 + }, + { + 0x39, 0x8E, 0x56, 0x83, 0x18, 0x20, 0x91, 0xD5, + 0xFF, 0x16, 0xF8, 0xBF, 0x8D, 0xA8, 0xEC, 0x1C, + 0xF6, 0x8C, 0xEA, 0x16, 0x68, 0x08, 0xC9, 0xD5, + 0xBC, 0xFB, 0xD7, 0xC0, 0x2C, 0xC4, 0x33, 0xF9 + }, + { + 0x95, 0x30, 0x84, 0x76, 0xB5, 0x69, 0xB0, 0xFF, + 0x15, 0x49, 0xF6, 0x9D, 0xDA, 0x9F, 0x30, 0x27, + 0x90, 0xE8, 0xA3, 0x0C, 0xAD, 0xC9, 0xC3, 0xB1, + 0xCA, 0x7F, 0x81, 0xFD, 0xA8, 0x5C, 0x1D, 0x2C + }, + { + 0x96, 0x38, 0x86, 0x5E, 0xEE, 0x85, 0x6A, 0xFE, + 0xD5, 0xF9, 0xAB, 0x00, 0xFD, 0x74, 0xBF, 0xDC, + 0xEA, 0xC3, 0x59, 0x1F, 0x42, 0x3F, 0xDA, 0xFA, + 0x82, 0x85, 0x1D, 0xEA, 0xB5, 0xBB, 0xA3, 0x21 + }, + { + 0x6A, 0xDD, 0x7C, 0x82, 0x5B, 0x57, 0xF0, 0x00, + 0x31, 0xF5, 0x44, 0xD1, 0xC8, 0x06, 0xC3, 0x6A, + 0x22, 0x3D, 0x83, 0x1E, 0x59, 0x30, 0x27, 0xC5, + 0x8B, 0x13, 0x44, 0x58, 0xBC, 0xC9, 0xF9, 0x9E + }, + { + 0x5D, 0xA8, 0xA0, 0x5D, 0xBF, 0x04, 0x57, 0x1C, + 0xFB, 0xF8, 0x1E, 0xC3, 0xCE, 0xED, 0x28, 0x92, + 0xC0, 0x1C, 0x8D, 0x4D, 0xBF, 0x35, 0x72, 0x4C, + 0x9C, 0x33, 0xD0, 0x1F, 0xD4, 0xA9, 0x14, 0x0A + }, + { + 0x62, 0xC9, 0x80, 0xAF, 0xAF, 0x79, 0xF0, 0xAC, + 0xB1, 0x7B, 0xF9, 0x9B, 0x08, 0x99, 0xE4, 0x25, + 0x67, 0x2A, 0xAE, 0x33, 0x8A, 0x38, 0xC3, 0x5E, + 0xF4, 0xD7, 0xBB, 0x2D, 0xAA, 0xC4, 0x2F, 0x4F + }, + { + 0x96, 0x20, 0x00, 0xD0, 0x41, 0x62, 0xB9, 0x69, + 0xCD, 0x5A, 0x09, 0x95, 0x98, 0x4B, 0x44, 0x48, + 0x41, 0xD7, 0x07, 0x89, 0x50, 0x3C, 0xA2, 0xD0, + 0xBB, 0x1A, 0x57, 0x60, 0x64, 0x34, 0xE7, 0xE3 + }, + { + 0xA6, 0xE5, 0x89, 0x76, 0xEA, 0x2C, 0xE7, 0x18, + 0x4E, 0x9C, 0x21, 0x0D, 0xC5, 0x9C, 0x34, 0x16, + 0x50, 0x98, 0x5A, 0x21, 0xF4, 0x04, 0x82, 0x72, + 0xEA, 0x22, 0x91, 0x12, 0x48, 0xCE, 0xAB, 0xEA + }, + { + 0xC7, 0x29, 0x1E, 0x4F, 0xBD, 0xB1, 0xC5, 0xFA, + 0xD1, 0x48, 0x98, 0xA3, 0x60, 0xD3, 0x63, 0x01, + 0xB5, 0x7B, 0xEB, 0x35, 0x7B, 0xE3, 0x66, 0x69, + 0x9A, 0x5A, 0x26, 0x02, 0xDF, 0xD5, 0x6B, 0xE3 + }, + { + 0xA6, 0x45, 0x4B, 0x58, 0x04, 0x76, 0x42, 0x78, + 0xD9, 0x8A, 0xCD, 0x08, 0x8B, 0x5B, 0xFC, 0x95, + 0xBA, 0xAC, 0x72, 0x96, 0x00, 0x3A, 0x86, 0x53, + 0x08, 0xBB, 0xEA, 0xC7, 0x3A, 0xCD, 0x91, 0x28 + }, + { + 0x7E, 0xAB, 0xA4, 0x3B, 0x80, 0x72, 0x64, 0x01, + 0xCF, 0x24, 0x30, 0x66, 0xEF, 0xD1, 0x29, 0xEB, + 0x84, 0x2C, 0xA4, 0x87, 0x84, 0x09, 0x72, 0x19, + 0x8F, 0xC0, 0x91, 0x3B, 0x70, 0x07, 0xF1, 0xD8 + }, + { + 0xBE, 0x73, 0x0F, 0x17, 0x50, 0xFD, 0xC5, 0x30, + 0x02, 0xC7, 0x8C, 0x5A, 0x4E, 0x39, 0xDA, 0xCA, + 0x43, 0x6A, 0xF9, 0x00, 0x19, 0x34, 0x58, 0x6B, + 0xE5, 0x08, 0x14, 0xD2, 0xE1, 0x7B, 0x44, 0x64 + }, + { + 0xE8, 0x83, 0x11, 0xC3, 0xD5, 0x81, 0xB4, 0xA9, + 0x1F, 0x9D, 0x3E, 0x6D, 0x8C, 0x0A, 0x35, 0xD3, + 0x30, 0x73, 0xCF, 0x10, 0xFE, 0x2D, 0xA3, 0xFB, + 0x16, 0xB8, 0xF0, 0x18, 0x6F, 0xAC, 0xE6, 0xBF + }, + { + 0x42, 0x57, 0x50, 0x58, 0xCB, 0xA8, 0x81, 0xEA, + 0xF3, 0x0A, 0x6A, 0x50, 0x50, 0x7F, 0x05, 0x27, + 0xB6, 0x0D, 0x55, 0x0F, 0x17, 0x4A, 0x66, 0x7E, + 0xE6, 0x95, 0x84, 0x2A, 0x45, 0x08, 0x55, 0x9F + }, + { + 0x45, 0xAC, 0xD6, 0x37, 0xF3, 0xD0, 0x99, 0x15, + 0x3E, 0xE7, 0x50, 0x35, 0x8B, 0x48, 0x8B, 0x47, + 0xF0, 0x37, 0x3D, 0x94, 0xAB, 0x01, 0xE8, 0x27, + 0x8E, 0xAF, 0x3D, 0xDC, 0x91, 0x03, 0x8B, 0x90 + }, + { + 0x13, 0x49, 0x64, 0x80, 0xE3, 0x86, 0x40, 0x24, + 0x87, 0xDE, 0xD4, 0x0A, 0x38, 0xA0, 0x0A, 0x98, + 0x1E, 0xCB, 0x00, 0x8D, 0x4B, 0xFC, 0x9B, 0x6B, + 0xE2, 0x41, 0xAC, 0x95, 0x0F, 0xBE, 0x9A, 0x79 + }, + { + 0x4B, 0xCD, 0x8E, 0x2B, 0xB6, 0xCA, 0x47, 0x88, + 0x05, 0x4B, 0x1D, 0xF4, 0x12, 0x4C, 0x34, 0x8C, + 0xF0, 0xE2, 0x1A, 0x9E, 0x59, 0x4E, 0xEE, 0x77, + 0x61, 0xCD, 0x50, 0xFE, 0x4E, 0x6A, 0x76, 0x16 + }, + { + 0xC8, 0xF8, 0xB0, 0x6E, 0xBA, 0x12, 0xA7, 0x3B, + 0x0B, 0x1E, 0x3C, 0x56, 0x8E, 0x24, 0x4A, 0xA7, + 0x41, 0x3F, 0xD2, 0xE7, 0x1E, 0x3D, 0x03, 0x7B, + 0xC0, 0x0E, 0xD6, 0x1E, 0xAC, 0xAF, 0xBF, 0xE3 + }, + { + 0x81, 0x82, 0x7C, 0x8C, 0x8B, 0x47, 0x64, 0x39, + 0xBC, 0x80, 0xE6, 0x0B, 0x1C, 0x6E, 0xFB, 0x80, + 0x6B, 0x60, 0x10, 0xF5, 0x71, 0x1E, 0xB4, 0x92, + 0xE1, 0x80, 0x2F, 0xAD, 0x7D, 0xE7, 0x7C, 0x0D + }, + { + 0xDF, 0x5D, 0xC8, 0x7D, 0x3A, 0x3F, 0x9D, 0xB1, + 0xB0, 0xAC, 0xFC, 0xA3, 0x80, 0xC2, 0x4D, 0xFF, + 0xBD, 0x7D, 0x3A, 0x66, 0x70, 0x9F, 0xA5, 0x14, + 0x90, 0x88, 0x79, 0x48, 0x1C, 0xC3, 0x53, 0x49 + }, + { + 0x6D, 0x81, 0xE8, 0xB9, 0x2D, 0x7E, 0xA8, 0x40, + 0x83, 0x84, 0xAA, 0x17, 0x8B, 0x30, 0x3A, 0x64, + 0x61, 0x1F, 0x32, 0xDB, 0x10, 0x4E, 0x9C, 0xB8, + 0x47, 0x53, 0x90, 0x03, 0x03, 0x81, 0x6C, 0x19 + }, + { + 0x40, 0xF0, 0x66, 0xA4, 0x99, 0x85, 0xD3, 0x24, + 0x6E, 0x0B, 0xB4, 0xF5, 0xD4, 0x8B, 0x9C, 0x66, + 0xFB, 0x81, 0x8C, 0x98, 0xFA, 0xE0, 0x35, 0x61, + 0xE5, 0x04, 0x50, 0x74, 0x38, 0xD3, 0x32, 0x59 + }, + { + 0xFC, 0xFE, 0xDB, 0x78, 0xCF, 0x38, 0x0F, 0x51, + 0x15, 0xFA, 0x45, 0x5D, 0x9B, 0x5D, 0xD7, 0x72, + 0xCD, 0x12, 0x12, 0x6D, 0xC4, 0x0B, 0x32, 0xCF, + 0xD7, 0x1E, 0x82, 0x84, 0x2E, 0x40, 0x87, 0x1C + }, + { + 0x8D, 0xB6, 0x02, 0x86, 0xF4, 0x9A, 0xDE, 0xA2, + 0xFF, 0xF5, 0x0F, 0x2C, 0x11, 0x70, 0x1B, 0x76, + 0x28, 0xBA, 0x95, 0x1C, 0x74, 0x99, 0x81, 0x88, + 0xB5, 0x59, 0xD4, 0xD0, 0x72, 0x23, 0xA5, 0x2E + }, + { + 0xA7, 0x7C, 0x0B, 0x3F, 0xC0, 0xF9, 0x09, 0x97, + 0xFF, 0xF3, 0xB3, 0x89, 0x86, 0x63, 0x18, 0xED, + 0xD7, 0xF1, 0x42, 0x1B, 0x85, 0x0C, 0x99, 0x5B, + 0x5B, 0x85, 0x80, 0x4B, 0x38, 0xBB, 0x7E, 0x76 + }, + { + 0x8F, 0xA5, 0xC8, 0xE6, 0x7C, 0x6A, 0xBC, 0xFD, + 0xB5, 0x1A, 0xC0, 0xE5, 0x02, 0xD2, 0x12, 0x31, + 0xE8, 0xF6, 0xCC, 0x1F, 0xE3, 0x67, 0x77, 0x94, + 0x34, 0x36, 0x3D, 0x07, 0xF7, 0x42, 0x95, 0x63 + }, + { + 0x4A, 0xE6, 0xCA, 0x5F, 0xCA, 0x0F, 0xC5, 0xF8, + 0xB2, 0x0A, 0xC9, 0x87, 0xB6, 0x39, 0xC5, 0x51, + 0x4A, 0xBC, 0xF2, 0x6E, 0xC8, 0x5E, 0xCC, 0x28, + 0x01, 0x0C, 0x17, 0x39, 0x98, 0xB1, 0xB2, 0x9B + }, + { + 0x88, 0xB7, 0x66, 0xC0, 0xE9, 0x5E, 0x40, 0x56, + 0xE1, 0xCF, 0x2B, 0x6B, 0x6E, 0x8B, 0x56, 0xA3, + 0x53, 0x6A, 0x31, 0x0D, 0xEE, 0xBC, 0x14, 0x53, + 0x12, 0x46, 0x5D, 0xD4, 0xB5, 0xE6, 0x0A, 0x7B + }, + { + 0xB0, 0x05, 0x42, 0xA4, 0xBC, 0xDE, 0xD9, 0x51, + 0x12, 0xDC, 0xB3, 0xC6, 0xC9, 0x6F, 0x1A, 0xA1, + 0xFD, 0x0E, 0x24, 0x3A, 0xEE, 0x37, 0x9D, 0x0A, + 0x53, 0x61, 0x0F, 0xEC, 0xA0, 0x66, 0xA8, 0xB7 + }, + { + 0x73, 0x59, 0x5D, 0x6C, 0xB5, 0xBB, 0x9A, 0x00, + 0x93, 0x65, 0x7B, 0xDE, 0x0B, 0xE5, 0x39, 0x1C, + 0x9E, 0x27, 0xC1, 0x35, 0xF9, 0xD4, 0x7D, 0x6C, + 0x0D, 0x11, 0x2F, 0x61, 0x17, 0xF4, 0x65, 0xDF + }, + { + 0xBF, 0x6E, 0xC9, 0x47, 0x92, 0x1B, 0x19, 0x80, + 0x26, 0x20, 0xFA, 0x86, 0xBC, 0xE5, 0x46, 0x92, + 0x5F, 0x00, 0xDD, 0xA7, 0xC2, 0x9F, 0x7D, 0x51, + 0x5E, 0x31, 0xB6, 0xD4, 0xB5, 0xE7, 0xE7, 0x4C + }, + { + 0x4D, 0x15, 0x08, 0xE0, 0xF9, 0xDC, 0xB8, 0x8C, + 0xAC, 0x14, 0x91, 0x03, 0xCA, 0x15, 0xA2, 0xB3, + 0xB7, 0x4E, 0x1B, 0x2D, 0x4C, 0x7C, 0xD8, 0xA3, + 0xE1, 0x58, 0x41, 0x79, 0x92, 0xDE, 0x2E, 0x8F + }, + { + 0xD4, 0x46, 0x82, 0x36, 0xE4, 0xC1, 0xE5, 0x35, + 0xDA, 0xD1, 0x79, 0x38, 0x4E, 0xDF, 0xF4, 0x60, + 0x76, 0x52, 0xCA, 0xBE, 0xB0, 0xC2, 0x42, 0xC9, + 0x31, 0x27, 0xB4, 0xEC, 0x3A, 0xE4, 0xD8, 0xE1 + }, + { + 0x12, 0xC1, 0x35, 0x8A, 0x96, 0xDA, 0x5F, 0x60, + 0x0E, 0x89, 0xEF, 0x25, 0xEB, 0x32, 0xD4, 0x59, + 0xC4, 0x74, 0x31, 0xC8, 0x66, 0x96, 0x7A, 0x86, + 0x2F, 0x1A, 0xBF, 0x49, 0x68, 0x55, 0xFB, 0x29 + }, + { + 0xDF, 0x78, 0x64, 0x77, 0xAA, 0xBF, 0x4C, 0x95, + 0xEE, 0xEE, 0x90, 0x73, 0xCE, 0xE2, 0x01, 0x65, + 0x37, 0xC8, 0x98, 0xF6, 0xCD, 0x71, 0xFB, 0x00, + 0xCA, 0x27, 0xB8, 0xF0, 0x2E, 0x1B, 0x3C, 0x9F + }, + { + 0xA3, 0x1D, 0x92, 0x91, 0x9D, 0x94, 0xE4, 0x21, + 0x06, 0x9E, 0x66, 0x9B, 0x01, 0x17, 0x06, 0x69, + 0x7D, 0xD4, 0x01, 0x00, 0x35, 0x0D, 0x48, 0xEC, + 0x55, 0xCC, 0xF8, 0x19, 0x5B, 0x8D, 0x1A, 0x16 + }, + { + 0x51, 0x97, 0x19, 0x20, 0x68, 0x55, 0x89, 0x3F, + 0xEB, 0x86, 0x34, 0xE1, 0xD2, 0xFB, 0x80, 0x81, + 0xBA, 0xF1, 0x59, 0xD0, 0x39, 0x0C, 0x87, 0x86, + 0xE0, 0x3C, 0x34, 0xFB, 0x10, 0x4E, 0x99, 0xE6 + }, + { + 0xE5, 0x3A, 0x99, 0x60, 0xEC, 0xDF, 0x31, 0xD6, + 0x69, 0x1D, 0x15, 0x24, 0xA0, 0xEC, 0x29, 0xA4, + 0xAB, 0x9E, 0x9C, 0x5E, 0x01, 0xC3, 0xA2, 0xA9, + 0xD5, 0x46, 0xF5, 0x1C, 0x41, 0xF3, 0x4D, 0x66 + }, + { + 0x33, 0x4A, 0x3A, 0x48, 0xA3, 0x1A, 0x3B, 0xDD, + 0xDB, 0xD1, 0x4D, 0x6E, 0x2F, 0xF4, 0x95, 0x61, + 0x85, 0x32, 0xAD, 0x47, 0x43, 0xEC, 0x78, 0x86, + 0xC7, 0x97, 0xE7, 0xA1, 0x25, 0x5A, 0x60, 0x64 + }, + { + 0x5B, 0x83, 0x2F, 0x99, 0x39, 0xF2, 0xB0, 0x92, + 0x34, 0x7E, 0x17, 0xDA, 0xB9, 0x90, 0x73, 0xAC, + 0xE2, 0x02, 0x3B, 0x4B, 0x37, 0xBC, 0xC8, 0xE8, + 0x16, 0x8A, 0x5B, 0x0E, 0x23, 0x53, 0xB4, 0xA6 + }, + { + 0x73, 0x9B, 0xDC, 0x3F, 0x60, 0x71, 0xB1, 0x6C, + 0x3E, 0x8B, 0xB4, 0x1E, 0xD7, 0x15, 0x7A, 0xE9, + 0x34, 0x41, 0x74, 0x80, 0x4F, 0xB3, 0xDE, 0xE7, + 0xB8, 0xF4, 0xBD, 0x54, 0x41, 0x53, 0x72, 0x05 + }, + { + 0x43, 0x38, 0x9D, 0x64, 0xC1, 0x27, 0x6D, 0xC8, + 0x17, 0xA2, 0x81, 0x39, 0xA7, 0xD4, 0xA3, 0x10, + 0xBF, 0x56, 0x87, 0xCA, 0x89, 0xF1, 0x6E, 0xD6, + 0xD6, 0xFC, 0x65, 0xF9, 0x8E, 0x32, 0x63, 0x05 + }, + { + 0x24, 0x1A, 0xC1, 0x0C, 0x82, 0x4A, 0x5A, 0xF2, + 0xD7, 0x91, 0x70, 0x8A, 0x8C, 0xD6, 0x1B, 0x27, + 0xC0, 0xEC, 0x69, 0x3B, 0xF6, 0x91, 0x54, 0xAB, + 0x4B, 0xA9, 0x6D, 0x4E, 0xF0, 0xBA, 0x90, 0x43 + }, + { + 0x9F, 0xD3, 0x70, 0x7C, 0xA2, 0x51, 0xCE, 0xE4, + 0x5F, 0x5B, 0xA6, 0x50, 0x1B, 0x08, 0x27, 0xD5, + 0x95, 0x07, 0x57, 0x9B, 0x15, 0x80, 0x71, 0x3D, + 0x94, 0xAE, 0x66, 0x97, 0x3A, 0x49, 0xEB, 0x23 + }, + { + 0xBA, 0x99, 0x9A, 0x73, 0x68, 0x25, 0x68, 0xDD, + 0x75, 0x9F, 0xC0, 0x40, 0x97, 0x34, 0xCA, 0xB4, + 0xC5, 0x42, 0xC6, 0x13, 0x2F, 0x34, 0xF9, 0xD8, + 0xFA, 0x72, 0x18, 0x28, 0xBC, 0x15, 0x1A, 0x08 + }, + { + 0x97, 0x08, 0x01, 0x3B, 0xCA, 0xD9, 0x6A, 0x28, + 0x40, 0x37, 0x94, 0x45, 0xDB, 0x40, 0xBF, 0xB0, + 0x07, 0x50, 0x48, 0xA5, 0xEF, 0x65, 0x84, 0xDC, + 0xDD, 0x6B, 0x7B, 0xFF, 0x0A, 0x76, 0x73, 0xF4 + }, + { + 0xE9, 0xAA, 0x89, 0xC5, 0x19, 0x56, 0x47, 0x49, + 0xE7, 0x78, 0xDF, 0x55, 0xE9, 0x7B, 0xB5, 0x82, + 0x8C, 0x4E, 0x6F, 0x4E, 0x45, 0x7D, 0x72, 0xAF, + 0x42, 0x36, 0xB5, 0xD6, 0x50, 0x3C, 0x01, 0x05 + }, + { + 0x40, 0xB8, 0xE0, 0xAE, 0xC7, 0x3D, 0x37, 0xDA, + 0x3B, 0xB3, 0xD2, 0x6D, 0x02, 0xAF, 0xC1, 0x8D, + 0xDB, 0x34, 0xFA, 0xAF, 0x70, 0x34, 0xCE, 0xFD, + 0x4F, 0x44, 0x41, 0xB7, 0x62, 0x0D, 0x76, 0xD5 + }, + { + 0xB9, 0x0A, 0x38, 0x62, 0x0E, 0x03, 0xCA, 0xC7, + 0xD9, 0x78, 0x45, 0x29, 0x30, 0x3B, 0x20, 0x36, + 0xD5, 0x66, 0x15, 0xBC, 0x46, 0xD2, 0x4F, 0x58, + 0x07, 0x84, 0x13, 0xEC, 0x96, 0xEA, 0xAE, 0x88 + }, + { + 0x04, 0x17, 0x84, 0x9C, 0x13, 0x6D, 0xFC, 0x6E, + 0xE4, 0x3D, 0x9B, 0x40, 0x62, 0x46, 0x93, 0xE2, + 0xB8, 0x10, 0x96, 0x74, 0x6E, 0x2A, 0xD4, 0x84, + 0xF6, 0xC0, 0x9A, 0xA5, 0x19, 0xC5, 0x44, 0x2D + }, + { + 0x92, 0x90, 0x0A, 0xD8, 0x8C, 0x37, 0xDE, 0xCB, + 0x88, 0x50, 0x7E, 0x61, 0x64, 0x09, 0xD3, 0x5F, + 0x9A, 0x1F, 0xA4, 0xAF, 0x3C, 0xF3, 0x1A, 0x0E, + 0x4D, 0xFD, 0x5B, 0xD6, 0xB1, 0x65, 0x16, 0xE6 + }, + { + 0xF8, 0x98, 0x88, 0x0A, 0x5B, 0x1B, 0x45, 0x39, + 0x99, 0xB1, 0x87, 0x73, 0x8D, 0xD0, 0x9C, 0xEB, + 0xA7, 0xEB, 0x23, 0x24, 0xD4, 0xC3, 0x67, 0x82, + 0x38, 0xF6, 0xD1, 0x1C, 0x1A, 0xAD, 0x54, 0x20 + }, + { + 0x0A, 0xDA, 0xD4, 0xAF, 0x26, 0x03, 0x44, 0x46, + 0x26, 0x73, 0x81, 0xB7, 0xE8, 0x9E, 0x65, 0xF5, + 0x27, 0x66, 0x2E, 0x58, 0x1B, 0x96, 0x55, 0x3D, + 0x49, 0x2D, 0x83, 0xBE, 0x42, 0x82, 0x8D, 0x30 + }, + { + 0xAA, 0xEB, 0x7F, 0xC1, 0x9C, 0x59, 0x95, 0xA0, + 0xF2, 0xDC, 0x22, 0x0E, 0x85, 0x70, 0x90, 0x7D, + 0x25, 0x03, 0x44, 0x9C, 0x94, 0x74, 0x01, 0x49, + 0x06, 0xFC, 0x5E, 0x4C, 0x2A, 0xAB, 0x75, 0xDE + }, + { + 0x38, 0xCA, 0x21, 0x71, 0xF7, 0x94, 0x6E, 0x37, + 0xC8, 0xAB, 0xA8, 0xCB, 0xD9, 0x6E, 0x9E, 0xB1, + 0x97, 0xE1, 0x5F, 0xC1, 0xBA, 0x17, 0x4E, 0x22, + 0x1A, 0x24, 0x7D, 0x27, 0x74, 0x4A, 0x35, 0x3A + }, + { + 0x8E, 0x01, 0x9F, 0xE9, 0xB4, 0xCF, 0xC4, 0x1E, + 0xEA, 0x17, 0x49, 0x09, 0xFD, 0xD5, 0xAF, 0xE8, + 0x93, 0x50, 0x54, 0x52, 0x5E, 0xA3, 0x04, 0x6E, + 0x72, 0x98, 0x91, 0xF1, 0x7D, 0x1E, 0xC7, 0x16 + }, + { + 0xA0, 0xEF, 0xA7, 0xD2, 0x42, 0x0D, 0xFF, 0x0C, + 0x14, 0x76, 0x8F, 0x91, 0x87, 0x0E, 0xC7, 0xFD, + 0x32, 0xAE, 0xB4, 0xC6, 0x9F, 0x62, 0xBF, 0xB2, + 0x96, 0x07, 0x11, 0x17, 0x98, 0x35, 0x61, 0x1E + }, + { + 0xAD, 0x18, 0x74, 0x56, 0x67, 0x37, 0xD7, 0xDE, + 0xC2, 0x9C, 0x75, 0x0F, 0xED, 0x79, 0xEA, 0x38, + 0xC4, 0x90, 0x50, 0x28, 0x59, 0xD0, 0xA8, 0x2F, + 0xB2, 0x9D, 0x8B, 0xE5, 0x1C, 0xEE, 0xA4, 0xA0 + }, + { + 0x21, 0x33, 0xDD, 0x20, 0x7A, 0xAA, 0xD1, 0x54, + 0x82, 0x6D, 0xC0, 0x51, 0xB1, 0xFD, 0x55, 0xF7, + 0x17, 0xEE, 0xC7, 0xD7, 0xEB, 0xA0, 0x32, 0x14, + 0x70, 0x05, 0x0B, 0x6D, 0x8B, 0x24, 0xCB, 0x60 + }, + { + 0xEA, 0x7E, 0xF9, 0x31, 0x07, 0xF8, 0xEB, 0xE6, + 0x0D, 0x40, 0x51, 0x19, 0xAE, 0x2D, 0xB1, 0x97, + 0xFE, 0x8B, 0x36, 0x1E, 0xFE, 0x2F, 0xEB, 0xA2, + 0xB5, 0x4F, 0x03, 0x61, 0x3F, 0xF8, 0x10, 0xCC + }, + { + 0xA7, 0x5F, 0xF1, 0x34, 0x12, 0x59, 0xE7, 0x93, + 0x45, 0x36, 0x27, 0x60, 0x4E, 0x93, 0xE5, 0x25, + 0xFD, 0xF5, 0x52, 0xE2, 0x4C, 0xBD, 0x61, 0xC1, + 0x55, 0x47, 0xA2, 0x22, 0xEE, 0x9A, 0x29, 0x83 + }, + { + 0x71, 0xFB, 0xA1, 0x00, 0xBA, 0x84, 0xE2, 0xED, + 0x39, 0x8D, 0xE4, 0xDA, 0x5B, 0xF6, 0x15, 0x84, + 0xB0, 0x55, 0x32, 0x59, 0x8F, 0xA2, 0x03, 0xE7, + 0xAA, 0x8C, 0x0D, 0x89, 0x74, 0xD6, 0xD3, 0x63 + }, + { + 0xE5, 0x35, 0xAF, 0xAC, 0x52, 0x94, 0x4A, 0xAA, + 0xC2, 0x5E, 0xB6, 0x20, 0x39, 0xAB, 0x04, 0x21, + 0xAD, 0x6D, 0xE7, 0xF6, 0x28, 0x16, 0x5D, 0x44, + 0x1F, 0xF3, 0xC3, 0x75, 0x16, 0x9C, 0x59, 0xA3 + }, + { + 0x51, 0xE2, 0x4D, 0x44, 0x6A, 0x5A, 0x4C, 0xF6, + 0x39, 0x3A, 0xA0, 0xF3, 0xAD, 0xCE, 0xAC, 0x76, + 0x6D, 0x62, 0x5F, 0xAC, 0xBE, 0xFD, 0xB1, 0x10, + 0x38, 0xDF, 0x5F, 0xEC, 0x4C, 0xFA, 0x63, 0x70 + }, + { + 0x49, 0x14, 0x3F, 0x37, 0x6F, 0x6C, 0x35, 0x53, + 0x86, 0xFB, 0xCB, 0xC7, 0xD8, 0x95, 0xEF, 0x48, + 0x6C, 0x77, 0x64, 0x99, 0x08, 0x0E, 0x3B, 0xCB, + 0x97, 0x21, 0x07, 0xEF, 0x80, 0x18, 0x0E, 0x6A + }, + { + 0x88, 0xAE, 0x9B, 0x89, 0xA5, 0x55, 0xD2, 0xE8, + 0x10, 0x78, 0x32, 0x18, 0xE1, 0xA1, 0x10, 0x8D, + 0x9B, 0xA4, 0xA5, 0xD0, 0x9A, 0xF8, 0x4F, 0xA7, + 0x20, 0xB5, 0x11, 0xD8, 0xA4, 0xD8, 0x2D, 0x37 + }, + { + 0x2E, 0xC0, 0x79, 0x7A, 0xDB, 0x2D, 0xA4, 0xDC, + 0xAA, 0x2B, 0x99, 0x4C, 0xA0, 0x69, 0x30, 0x73, + 0xDA, 0x0E, 0x0B, 0x26, 0xDF, 0xDE, 0x12, 0xC9, + 0x75, 0x78, 0x24, 0x6B, 0xD2, 0xA6, 0xF5, 0x5D + }, + { + 0x4F, 0x6F, 0x19, 0x40, 0xE0, 0x8C, 0x45, 0xDD, + 0x94, 0xB3, 0x24, 0x80, 0xE1, 0x6F, 0xDB, 0x72, + 0x4E, 0x22, 0x20, 0x0D, 0x74, 0x6A, 0xD1, 0x7C, + 0xBA, 0x5D, 0x40, 0x73, 0xD3, 0x30, 0x47, 0xDA + }, + { + 0xAB, 0x47, 0x68, 0xB2, 0x34, 0x7E, 0xC1, 0x33, + 0xBA, 0x90, 0xE6, 0x67, 0xE6, 0x91, 0x27, 0xCE, + 0xE9, 0x0C, 0x68, 0xCE, 0x80, 0x72, 0xCA, 0x0A, + 0x3E, 0x66, 0x2B, 0xD2, 0x3D, 0xFA, 0xD2, 0x58 + }, + { + 0xFB, 0x52, 0x95, 0x9E, 0x19, 0x19, 0x45, 0xA3, + 0x0E, 0x16, 0xB6, 0xD5, 0x98, 0x17, 0xAD, 0x44, + 0xA9, 0xBB, 0xD8, 0x2C, 0xE5, 0xAA, 0x42, 0xCB, + 0x0A, 0x06, 0x6D, 0xD3, 0x31, 0x71, 0x4E, 0xCF + }, + { + 0x38, 0xCB, 0xD9, 0xB7, 0x74, 0x04, 0x32, 0xB3, + 0x5B, 0x87, 0x26, 0xDA, 0xF6, 0xA6, 0xF2, 0xCE, + 0xBC, 0x1D, 0xEA, 0x20, 0x33, 0x68, 0x4F, 0x4A, + 0x4A, 0xF2, 0xC8, 0xE2, 0xD5, 0x12, 0x7B, 0xC7 + }, + { + 0xBB, 0xE5, 0x7E, 0x36, 0x2B, 0x61, 0x33, 0x0B, + 0xD3, 0x1F, 0x5A, 0x19, 0x27, 0x30, 0xAA, 0x3A, + 0xE0, 0x78, 0x12, 0x0B, 0xB4, 0x8A, 0x7C, 0xA4, + 0xFB, 0xCC, 0xB4, 0x86, 0x0A, 0x09, 0x2D, 0xF2 + }, + { + 0x48, 0xCD, 0x9E, 0x87, 0x5E, 0x94, 0x7A, 0x09, + 0xA0, 0xFA, 0x25, 0x11, 0x2B, 0x6D, 0xE3, 0xCA, + 0xF0, 0x62, 0xFE, 0x54, 0x73, 0xB7, 0xC7, 0x43, + 0xC6, 0x11, 0xB0, 0x9B, 0xA7, 0x6A, 0x5D, 0xF9 + }, + { + 0x8C, 0x25, 0x83, 0x1B, 0xE7, 0xF7, 0x17, 0xF6, + 0xBC, 0x1E, 0xA2, 0x76, 0xAE, 0xD5, 0x05, 0x17, + 0x11, 0x84, 0xA2, 0xAE, 0x88, 0xBC, 0x58, 0xB2, + 0xED, 0x31, 0x6E, 0x46, 0xA6, 0xF2, 0xEC, 0xC5 + }, + { + 0x9B, 0x34, 0x67, 0x59, 0x5F, 0x9C, 0x03, 0x32, + 0xDD, 0x26, 0x19, 0x88, 0xF7, 0xFA, 0xEF, 0x4B, + 0xE7, 0x7D, 0x4D, 0x9B, 0xBC, 0x47, 0xDE, 0x40, + 0x50, 0xF4, 0x2D, 0xBD, 0x5D, 0x3F, 0x1C, 0xE7 + }, + { + 0x5F, 0xF0, 0xCB, 0x6C, 0x98, 0x7A, 0xD2, 0x7B, + 0xB2, 0x99, 0x01, 0x71, 0x52, 0xB1, 0xCF, 0xBF, + 0x6F, 0x1D, 0x80, 0x2C, 0xA7, 0xA7, 0x31, 0xDC, + 0xED, 0xD4, 0x24, 0x1E, 0x7A, 0x64, 0xED, 0x49 + }, + { + 0x5E, 0x47, 0xBC, 0x19, 0xE5, 0x1E, 0xF5, 0xD7, + 0xDC, 0x5F, 0xBF, 0x3C, 0x85, 0x8E, 0xD0, 0x4E, + 0x4D, 0x7A, 0x17, 0xFD, 0x6E, 0x6F, 0xEF, 0xE9, + 0x45, 0xDB, 0xFA, 0x44, 0xBE, 0xC9, 0xDB, 0x6E + }, + { + 0xBF, 0xFD, 0x02, 0x20, 0x90, 0x02, 0x4D, 0xE3, + 0x40, 0xBD, 0x88, 0xC6, 0xA2, 0xD3, 0x38, 0x3B, + 0xA5, 0xFD, 0xC1, 0x84, 0x5A, 0xF3, 0xB7, 0x88, + 0x4F, 0xDA, 0x45, 0x39, 0x77, 0x58, 0x3E, 0xA4 + }, + { + 0x34, 0x22, 0x1C, 0x14, 0xCE, 0x67, 0xDE, 0x7E, + 0xE4, 0xA8, 0x57, 0xA7, 0x9D, 0x70, 0x46, 0x63, + 0x44, 0x00, 0x3F, 0x11, 0x2B, 0x0C, 0x3C, 0xF8, + 0x45, 0xD7, 0x55, 0x24, 0x10, 0x26, 0x73, 0xA0 + }, + { + 0xBC, 0x49, 0x58, 0xA8, 0x1A, 0x76, 0x24, 0x17, + 0xC7, 0x58, 0x89, 0x1C, 0xBD, 0x65, 0x39, 0x2F, + 0x13, 0xD0, 0x73, 0x8D, 0x9A, 0xD2, 0x40, 0x87, + 0x6C, 0x61, 0x8A, 0x5A, 0xBF, 0x8E, 0x75, 0xF7 + }, + { + 0x8B, 0xD8, 0x87, 0xB1, 0x14, 0x45, 0x05, 0xC2, + 0xC7, 0x4F, 0xF6, 0x49, 0x0A, 0xC5, 0xDB, 0x26, + 0x2D, 0x49, 0xD8, 0x40, 0x47, 0xE9, 0xB8, 0x53, + 0xEB, 0x86, 0x0E, 0x5A, 0x7E, 0xDD, 0xA3, 0x67 + }, + { + 0xF2, 0x07, 0xBD, 0x45, 0x57, 0xA9, 0xE5, 0x26, + 0xB7, 0xC5, 0xC5, 0x59, 0x89, 0x6B, 0x81, 0xF1, + 0x09, 0xA7, 0x02, 0x77, 0xEB, 0xBB, 0xCC, 0xBF, + 0x4D, 0xBD, 0xBB, 0x53, 0x55, 0x72, 0xB7, 0x96 + }, + { + 0xCE, 0xD1, 0xB8, 0x84, 0x4B, 0x84, 0xB5, 0x64, + 0xE8, 0xDD, 0x7C, 0x99, 0x22, 0x55, 0x28, 0x4A, + 0xA9, 0xC9, 0xD3, 0x2C, 0xB2, 0x09, 0xFE, 0x1A, + 0x51, 0x8C, 0x60, 0x2D, 0x8F, 0x4B, 0x62, 0xFF + }, + { + 0xEB, 0x23, 0xB2, 0x03, 0x01, 0xF2, 0xA5, 0x91, + 0xAC, 0xBA, 0x5B, 0x5A, 0xFD, 0xFD, 0x2E, 0x3A, + 0x92, 0xDD, 0xE2, 0x26, 0x3E, 0xD9, 0x9E, 0x3E, + 0x23, 0x71, 0x26, 0x13, 0xE7, 0x65, 0x68, 0x19 + }, + { + 0x17, 0x7C, 0x6C, 0xE3, 0x61, 0x36, 0x9F, 0x2A, + 0xB1, 0x99, 0x83, 0xBE, 0xAE, 0x46, 0x52, 0xB6, + 0x36, 0xBD, 0x89, 0xA8, 0x9F, 0x98, 0xA7, 0xE4, + 0xCE, 0x2C, 0xFC, 0xC7, 0x17, 0xB8, 0x77, 0x96 + }, + { + 0x99, 0x67, 0x5B, 0x79, 0xBE, 0x32, 0xD9, 0xC1, + 0x5A, 0x7B, 0x04, 0x66, 0xEA, 0x5F, 0xDC, 0xE4, + 0x0E, 0x77, 0xE0, 0xBB, 0x52, 0x4D, 0x83, 0x83, + 0xF5, 0x5D, 0xAF, 0x10, 0xC3, 0x9D, 0xA2, 0x01 + }, + { + 0x3D, 0xDB, 0xA3, 0x59, 0x77, 0xF1, 0x9F, 0x87, + 0xC5, 0x13, 0x89, 0xF7, 0x7E, 0xF3, 0x78, 0xB6, + 0x51, 0x75, 0x4D, 0xBD, 0xB1, 0xEB, 0x37, 0x58, + 0x3E, 0xA3, 0x56, 0xE4, 0x7A, 0x45, 0x50, 0xBE + }, + { + 0x6E, 0xC7, 0xC5, 0xF5, 0xA3, 0x73, 0x18, 0xA9, + 0x11, 0x18, 0x7A, 0xF1, 0xB5, 0x6C, 0xA9, 0x44, + 0x19, 0x3C, 0x9F, 0xC3, 0xD7, 0x55, 0x1F, 0x2E, + 0xCD, 0x07, 0x51, 0x96, 0x31, 0x6B, 0x72, 0xA7 + }, + { + 0xFA, 0xAE, 0x5E, 0x63, 0x23, 0x4E, 0x6F, 0x7E, + 0x78, 0xD0, 0x35, 0xB7, 0x0C, 0x28, 0xD9, 0x90, + 0x9F, 0x79, 0xA5, 0xAF, 0xE1, 0x65, 0xEE, 0x6E, + 0xE3, 0xE4, 0xAD, 0x1E, 0x4B, 0xD4, 0x8F, 0x81 + }, + { + 0x2B, 0x25, 0x3B, 0xF9, 0x03, 0xC8, 0x29, 0xC9, + 0xB4, 0x98, 0x83, 0x70, 0x14, 0xCE, 0x02, 0x03, + 0x10, 0x2E, 0x54, 0x1D, 0xE6, 0xDD, 0xF2, 0x6F, + 0xFA, 0x1B, 0x58, 0x42, 0xA6, 0x64, 0x8C, 0x02 + }, + { + 0x4F, 0x66, 0xE0, 0xA8, 0xBC, 0x7E, 0xB2, 0x33, + 0x59, 0x00, 0xA5, 0xB8, 0xCF, 0x23, 0x1A, 0x92, + 0xB4, 0xFC, 0x0A, 0xBC, 0x37, 0x9E, 0x22, 0xBE, + 0x96, 0x96, 0xBC, 0xBE, 0x18, 0x84, 0xFD, 0x5E + }, + { + 0x2F, 0x7A, 0x2C, 0xCD, 0x1E, 0x3E, 0x9D, 0xA9, + 0xBD, 0xF2, 0xDD, 0xB5, 0x1F, 0xAD, 0x99, 0xAD, + 0x8C, 0x0D, 0xC8, 0xB8, 0xAA, 0xB3, 0xF4, 0xB1, + 0x05, 0x0E, 0x13, 0x29, 0x98, 0x6A, 0x8B, 0x93 + }, + { + 0x73, 0x45, 0xEA, 0x03, 0x86, 0x96, 0xE7, 0x39, + 0x5E, 0x15, 0x18, 0xBF, 0x5E, 0x51, 0x51, 0x82, + 0x3E, 0x16, 0xA7, 0xE2, 0x13, 0x82, 0x71, 0x50, + 0x5B, 0xC1, 0x78, 0x87, 0xC4, 0xF5, 0xE8, 0x41 + }, + { + 0x26, 0xA1, 0x4F, 0xF9, 0xC1, 0x32, 0xCD, 0xA3, + 0xA3, 0xC6, 0x54, 0xB6, 0xEC, 0x0A, 0x62, 0x63, + 0xD7, 0x26, 0xA3, 0xF2, 0xD0, 0x8A, 0x47, 0xDE, + 0xAC, 0xB1, 0x26, 0xCF, 0x22, 0x09, 0x47, 0x08 + }, + { + 0xE6, 0x41, 0x72, 0x46, 0x9B, 0x01, 0x30, 0xAB, + 0xB6, 0xCC, 0xAA, 0x46, 0xE2, 0x85, 0x31, 0x06, + 0xC4, 0x97, 0x76, 0x70, 0xB2, 0x4E, 0xD9, 0x6B, + 0xFB, 0x46, 0x21, 0xF1, 0xF6, 0xFC, 0x26, 0xA0 + }, + { + 0x39, 0x62, 0x58, 0xE3, 0x9F, 0xC7, 0xFD, 0xF7, + 0x36, 0xD0, 0x07, 0x81, 0x27, 0xA5, 0xC4, 0x15, + 0x83, 0x0E, 0xC0, 0x42, 0x5C, 0x32, 0x79, 0x35, + 0x18, 0xEC, 0x83, 0x09, 0xAF, 0x99, 0x12, 0xB1 + }, + { + 0x62, 0x5C, 0x48, 0x7A, 0x8E, 0x42, 0xCF, 0x9B, + 0xAE, 0x0C, 0x76, 0x61, 0x26, 0xCC, 0x78, 0x14, + 0x76, 0xEB, 0x13, 0xA8, 0xDF, 0x66, 0x2C, 0xCE, + 0xD8, 0xDD, 0x08, 0x7C, 0x8F, 0x9D, 0x98, 0xE8 + }, + { + 0x4D, 0x88, 0xF5, 0xF8, 0xE8, 0x50, 0x06, 0x20, + 0xEE, 0x52, 0x6B, 0x09, 0xBF, 0x6B, 0xAF, 0x34, + 0x22, 0x29, 0x3F, 0x76, 0x6D, 0xB7, 0xDA, 0xF4, + 0xE6, 0xA0, 0x72, 0xE2, 0x11, 0x53, 0x53, 0xFD + }, + { + 0x98, 0x50, 0x52, 0xB2, 0x21, 0x7A, 0x56, 0xEC, + 0xCE, 0x92, 0xE0, 0xA5, 0x2B, 0xC0, 0x0C, 0x52, + 0xE3, 0x19, 0x8A, 0x0A, 0xD4, 0xF0, 0x78, 0x4B, + 0x9C, 0xE0, 0xCD, 0x5B, 0xA9, 0xCD, 0x7B, 0x55 + }, + { + 0x5D, 0xB7, 0x27, 0x07, 0x01, 0x2D, 0xE2, 0xAE, + 0x6F, 0x11, 0xC6, 0xF9, 0x03, 0xA8, 0xB4, 0x4B, + 0x91, 0x0D, 0xB4, 0xD6, 0x17, 0x92, 0xF3, 0x88, + 0x6E, 0x2C, 0xE7, 0x8C, 0x79, 0x1C, 0xC6, 0xCA + }, + { + 0xA2, 0x08, 0x8B, 0xBA, 0xA0, 0x42, 0x16, 0xD2, + 0x2D, 0x02, 0xBA, 0xE3, 0x5D, 0xC7, 0x9B, 0x40, + 0x82, 0xC4, 0x59, 0xA0, 0xFC, 0x31, 0x37, 0x73, + 0xEA, 0x24, 0x79, 0xD4, 0x51, 0x8F, 0x50, 0xB3 + }, + { + 0xA2, 0x78, 0xE9, 0xC7, 0xA5, 0x3A, 0x74, 0xCD, + 0x49, 0x72, 0x6E, 0x77, 0x64, 0xB8, 0x09, 0x28, + 0xE3, 0x6D, 0xCA, 0xEF, 0x2E, 0x1C, 0x37, 0x69, + 0xA0, 0xFA, 0x39, 0xDC, 0xBB, 0x35, 0x2A, 0x2A + }, + { + 0x84, 0x62, 0x40, 0x85, 0x60, 0x87, 0x25, 0x68, + 0xAD, 0x75, 0x53, 0x1D, 0x5C, 0x30, 0x38, 0x90, + 0x6E, 0xEE, 0x09, 0xBC, 0xEA, 0xC8, 0x0C, 0xB8, + 0x6E, 0xF5, 0x1A, 0x9C, 0xC7, 0xD3, 0x86, 0xD9 + }, + { + 0x31, 0xEF, 0xAB, 0x17, 0xCF, 0xE0, 0x07, 0x22, + 0xF0, 0x15, 0xC6, 0x9F, 0x56, 0x68, 0x6D, 0x47, + 0xFB, 0xFB, 0xB3, 0xA8, 0x2C, 0x2D, 0x6D, 0x23, + 0xE5, 0x0E, 0x5F, 0x6C, 0xC8, 0x46, 0x9D, 0x4A + }, + { + 0xEC, 0x02, 0x12, 0xE4, 0x56, 0x08, 0x87, 0xB7, + 0x8E, 0x2D, 0x83, 0x5F, 0x2C, 0x7C, 0x9D, 0x63, + 0x57, 0xEF, 0x90, 0x65, 0x1F, 0x7E, 0x46, 0x8B, + 0x34, 0xFD, 0xC0, 0xAC, 0x7B, 0x33, 0x48, 0xF9 + }, + { + 0x70, 0x1D, 0x57, 0xC8, 0x6C, 0x00, 0x61, 0xE9, + 0xDF, 0x4F, 0xAC, 0x3B, 0x59, 0x7E, 0xEB, 0x30, + 0x38, 0x51, 0xFC, 0x3D, 0xC2, 0xBC, 0x8A, 0xC8, + 0x22, 0x09, 0xD6, 0xBC, 0x84, 0x07, 0xD5, 0x2A + }, + { + 0xAC, 0x7B, 0x5B, 0x44, 0x16, 0xB4, 0xCA, 0xE9, + 0x1E, 0xB3, 0xC0, 0xAD, 0x68, 0x41, 0xF2, 0x9D, + 0xFB, 0xDA, 0xD6, 0x17, 0xFF, 0x01, 0x5B, 0xC7, + 0xF6, 0x4E, 0x39, 0xE0, 0x09, 0xBC, 0x6B, 0x92 + }, + { + 0x19, 0xB3, 0x62, 0xA2, 0x99, 0xDD, 0xCC, 0xD3, + 0xB0, 0x64, 0xF3, 0x3C, 0xAC, 0xD3, 0xCC, 0x7D, + 0x21, 0x56, 0x0C, 0xB7, 0x65, 0x5A, 0xFE, 0xCD, + 0xD0, 0x8C, 0x69, 0xE4, 0x91, 0xE8, 0xCF, 0x07 + }, + { + 0xC1, 0x54, 0xB3, 0x20, 0x94, 0xB5, 0x19, 0x66, + 0x3B, 0x9B, 0x7A, 0x47, 0x38, 0xF1, 0x00, 0x4D, + 0x6E, 0x84, 0x46, 0x3D, 0x9F, 0x4E, 0x0C, 0xE8, + 0x3D, 0xDE, 0x21, 0x6A, 0x70, 0x9C, 0xB6, 0x15 + }, + { + 0x7E, 0x28, 0x30, 0xF7, 0x4F, 0xC7, 0xC4, 0xD2, + 0x24, 0xA2, 0x01, 0xB4, 0x6F, 0x95, 0xE3, 0x7E, + 0xBB, 0xFB, 0x56, 0xDD, 0xDC, 0x49, 0x2F, 0x82, + 0x27, 0xE4, 0xD9, 0x05, 0x20, 0x17, 0x34, 0xB8 + }, + { + 0x0D, 0x85, 0x92, 0xA5, 0xC3, 0xBB, 0x1F, 0xD2, + 0xF1, 0x51, 0xED, 0xA7, 0xD1, 0x2A, 0x4C, 0xC7, + 0x0E, 0xE6, 0x8A, 0x18, 0xE0, 0x00, 0xEA, 0x4A, + 0x5F, 0x55, 0x88, 0xAC, 0x3B, 0xF8, 0x8F, 0xD4 + }, + { + 0xF7, 0xEE, 0x45, 0xDC, 0x9F, 0x37, 0xCE, 0xDD, + 0x16, 0x5C, 0xDF, 0x4A, 0xDB, 0xC4, 0xE4, 0x0C, + 0xB9, 0xC7, 0xAE, 0x50, 0x36, 0xE7, 0xB9, 0xBA, + 0x13, 0xCE, 0x72, 0x78, 0xD4, 0xDA, 0x5F, 0x8C + }, + { + 0x93, 0x00, 0x41, 0xEB, 0x2D, 0x7B, 0x9F, 0x8E, + 0x51, 0x40, 0xF6, 0x60, 0xEC, 0x2E, 0x60, 0x37, + 0x15, 0xB9, 0xDC, 0xDB, 0xD5, 0xA3, 0x02, 0x71, + 0x84, 0xF5, 0x28, 0xEC, 0x92, 0xF8, 0x3F, 0xCD + }, + { + 0x1F, 0xA1, 0xAC, 0x8E, 0x84, 0xAC, 0x17, 0x12, + 0x6B, 0x14, 0xB2, 0x2C, 0xB5, 0x18, 0x42, 0x85, + 0x86, 0xCA, 0x27, 0x66, 0xE4, 0x77, 0xC8, 0x81, + 0xEB, 0x47, 0x61, 0x8C, 0x37, 0xD4, 0xD2, 0xE1 + }, + { + 0xED, 0x2A, 0x5D, 0x22, 0xAF, 0x3B, 0x7D, 0x87, + 0x2F, 0x06, 0xAB, 0x74, 0xB7, 0xD6, 0x2D, 0xA5, + 0x96, 0x8E, 0x65, 0x10, 0xA5, 0x06, 0x7A, 0xDF, + 0x82, 0xC4, 0xE9, 0x46, 0xAC, 0xA2, 0x1C, 0x79 + }, + { + 0xE5, 0xD4, 0xC1, 0xD0, 0xCA, 0x77, 0x16, 0x21, + 0xEC, 0x56, 0x2B, 0xB0, 0x95, 0xC4, 0x23, 0xD8, + 0x11, 0xC0, 0x40, 0x3C, 0xB9, 0xDA, 0x77, 0xBB, + 0x0B, 0xC8, 0xD8, 0x41, 0x71, 0xD1, 0xA8, 0x1A + }, + { + 0x0B, 0x93, 0x7F, 0xFD, 0xBB, 0x3E, 0xCF, 0x1C, + 0xCF, 0xF9, 0xB3, 0x2A, 0xE7, 0xCD, 0x17, 0x71, + 0x3A, 0x94, 0x58, 0x89, 0x93, 0x79, 0x03, 0x4D, + 0x8B, 0xA7, 0xE6, 0x6B, 0xF4, 0x2A, 0x92, 0x3A + }, + { + 0x2D, 0x61, 0xDB, 0xE2, 0xFA, 0xCA, 0xF4, 0x1D, + 0xD9, 0x69, 0x9C, 0x88, 0xD4, 0xCF, 0xC7, 0xA0, + 0xCD, 0x60, 0xAF, 0xDB, 0x1F, 0xB9, 0x0F, 0xBE, + 0x60, 0xC2, 0xB6, 0x10, 0xCF, 0xB0, 0x1F, 0xDE + }, + { + 0xFD, 0xE7, 0xB2, 0x6D, 0x80, 0x82, 0x74, 0x2C, + 0x7C, 0x41, 0xBC, 0xCF, 0xEB, 0x9E, 0x3C, 0x57, + 0x28, 0x93, 0xDF, 0x3B, 0xC2, 0xC4, 0x9D, 0x0F, + 0xBD, 0x62, 0xB5, 0xEC, 0xE0, 0x9D, 0x61, 0x05 + }, + { + 0x3B, 0x44, 0xB4, 0xB8, 0xAE, 0xA8, 0x0B, 0xBD, + 0x83, 0x59, 0x98, 0xDA, 0x5F, 0xB2, 0x4A, 0xD8, + 0x06, 0x49, 0x83, 0x64, 0xE9, 0xE5, 0x8F, 0xEC, + 0x24, 0xB4, 0xE0, 0x93, 0x4F, 0xFF, 0xAD, 0x74 + }, + { + 0xE5, 0x4B, 0xDE, 0x2B, 0xF2, 0x9F, 0x48, 0x6D, + 0x90, 0x1D, 0x7B, 0x9F, 0x58, 0x8B, 0x9E, 0x1A, + 0xCC, 0x9A, 0xDC, 0x20, 0x6A, 0xE5, 0xA7, 0x6D, + 0xCC, 0x4B, 0x84, 0xA6, 0x69, 0x91, 0x38, 0x09 + }, + { + 0xDD, 0xD7, 0x37, 0x6B, 0xD9, 0x04, 0xEE, 0xD0, + 0x3E, 0xDB, 0xEC, 0x98, 0x8C, 0x57, 0xC2, 0x13, + 0x60, 0x62, 0x2F, 0xA2, 0xE2, 0xA1, 0xB9, 0xBA, + 0x1C, 0xE9, 0x25, 0x19, 0xD8, 0x98, 0xC3, 0xEE + }, + { + 0xCE, 0x8E, 0x2C, 0x86, 0xF1, 0xC4, 0xB7, 0xF7, + 0x6C, 0x77, 0xCF, 0x37, 0x82, 0x08, 0xFA, 0x64, + 0x25, 0x7B, 0x9A, 0xCA, 0xA1, 0x6A, 0x55, 0x6B, + 0x6A, 0x05, 0x0D, 0xDD, 0x9B, 0x5D, 0xC8, 0x79 + }, + { + 0x50, 0x09, 0x0A, 0x7F, 0xD0, 0x4C, 0x61, 0xD9, + 0xFC, 0x4A, 0x9F, 0x13, 0x53, 0xD4, 0xA3, 0x56, + 0xA9, 0x06, 0x2A, 0x1D, 0x85, 0x9A, 0x3D, 0xA4, + 0x57, 0x05, 0xD3, 0xFE, 0x17, 0x15, 0x95, 0x47 + }, + { + 0x94, 0x39, 0x51, 0x79, 0xC2, 0x8F, 0x9A, 0x5C, + 0x5C, 0x7C, 0x07, 0x83, 0x97, 0xEB, 0x47, 0xA9, + 0xB0, 0x05, 0xFB, 0x74, 0xC5, 0xC9, 0x19, 0xB8, + 0xD4, 0xD5, 0xF0, 0xB7, 0xA8, 0xC2, 0x2B, 0xAB + }, + { + 0x2A, 0xBF, 0xB3, 0x6C, 0xAE, 0x39, 0x0C, 0x5C, + 0xE5, 0xFD, 0x8A, 0xC9, 0x59, 0xED, 0x8B, 0x5D, + 0x41, 0x57, 0xA9, 0xA0, 0xE5, 0xD2, 0xD0, 0x53, + 0x14, 0xB4, 0x8D, 0x5C, 0x35, 0xF3, 0xCC, 0x18 + }, + { + 0x53, 0x33, 0xE3, 0x08, 0xB6, 0x26, 0xB5, 0x02, + 0xBA, 0xE8, 0xE3, 0xFD, 0x60, 0xE5, 0x1F, 0x94, + 0x39, 0x75, 0x4E, 0x8C, 0x05, 0x27, 0x17, 0x7D, + 0xAA, 0x75, 0xD6, 0x90, 0x32, 0x40, 0x63, 0x7F + }, + { + 0x20, 0xCB, 0x7A, 0x19, 0x9E, 0xF5, 0x77, 0x3C, + 0x39, 0x91, 0x33, 0xD2, 0xAE, 0x9F, 0x99, 0xC5, + 0x0C, 0xF8, 0xE1, 0xB8, 0x26, 0x37, 0x69, 0xB0, + 0x8C, 0x5B, 0x4D, 0xD3, 0xA7, 0x3D, 0xB8, 0x06 + }, + { + 0xDE, 0x1D, 0x5D, 0x1A, 0x03, 0xBA, 0xEA, 0x68, + 0xD7, 0xD9, 0xAE, 0x36, 0x8F, 0x41, 0xDC, 0x36, + 0xB6, 0x6C, 0x14, 0xD7, 0x9A, 0xAF, 0xC7, 0x9E, + 0x81, 0xD9, 0x72, 0x54, 0xB4, 0x81, 0x50, 0xB2 + }, + { + 0xB7, 0x2E, 0x7B, 0xA9, 0x8E, 0x0F, 0x8D, 0x6E, + 0xAF, 0x01, 0xCB, 0x6B, 0xB3, 0x0F, 0x78, 0xA4, + 0x06, 0x85, 0x9F, 0x2B, 0x9A, 0xB0, 0x82, 0x99, + 0x1C, 0xB1, 0x04, 0xC4, 0x9D, 0x11, 0xC4, 0x0B + }, + { + 0xCD, 0x66, 0xC0, 0xF1, 0x11, 0x79, 0xE9, 0xA0, + 0xA6, 0x1D, 0x38, 0xB9, 0x43, 0x9D, 0xBC, 0x4A, + 0x42, 0x23, 0x0A, 0xE4, 0x56, 0xD9, 0x80, 0x62, + 0x4F, 0xF6, 0x0E, 0x1C, 0x05, 0x16, 0x7C, 0x69 + }, + { + 0x33, 0xBF, 0xA8, 0xA6, 0x8E, 0x4D, 0xC6, 0x56, + 0x7D, 0x5E, 0xAE, 0x85, 0x25, 0xA2, 0xF1, 0x99, + 0xE9, 0xF5, 0x0A, 0x56, 0xAE, 0xAF, 0xFA, 0xB0, + 0x45, 0x26, 0x46, 0x41, 0x22, 0xA2, 0x69, 0x2B + }, + { + 0x13, 0xBC, 0x57, 0x20, 0xDE, 0x24, 0x7E, 0xDD, + 0x4D, 0xC0, 0x87, 0xA0, 0x8A, 0x1E, 0x44, 0x38, + 0x8B, 0xF2, 0x04, 0x7B, 0x10, 0x2C, 0x5D, 0x87, + 0x8A, 0x86, 0xC8, 0xAA, 0x10, 0xE5, 0x00, 0x19 + }, + { + 0xC9, 0xF7, 0x91, 0x71, 0xD1, 0x9C, 0x37, 0x03, + 0xB7, 0xEB, 0xF9, 0xF7, 0x62, 0xCE, 0x3F, 0xD2, + 0x4B, 0x30, 0x2E, 0x22, 0x81, 0xF7, 0x2D, 0xA3, + 0x1A, 0x65, 0x01, 0x4F, 0xF9, 0x23, 0xC8, 0x59 + }, + { + 0x1C, 0xF6, 0x55, 0x60, 0xDE, 0xEF, 0x7D, 0xAD, + 0x52, 0x82, 0xFA, 0x8B, 0x42, 0xE2, 0x89, 0xD7, + 0x1A, 0x43, 0xB9, 0x72, 0xB2, 0x4E, 0xB3, 0xC8, + 0xED, 0x4D, 0x6E, 0x72, 0x5E, 0x5F, 0x14, 0xAD + }, + { + 0x64, 0xB4, 0x19, 0x02, 0x4F, 0x7F, 0x56, 0x57, + 0xE2, 0xDC, 0x29, 0xB0, 0x49, 0x65, 0xB6, 0xC4, + 0x6B, 0x10, 0xE3, 0x25, 0x8F, 0xB8, 0x87, 0xB7, + 0xA4, 0x5D, 0x97, 0x6A, 0x32, 0x13, 0x3F, 0x09 + }, + { + 0x36, 0x9F, 0x9F, 0x93, 0xA8, 0xD2, 0xAB, 0x84, + 0x05, 0x8F, 0x3F, 0x00, 0xC3, 0x98, 0xE3, 0x77, + 0x43, 0xD9, 0x3C, 0xB6, 0x65, 0x99, 0x29, 0x80, + 0x34, 0x88, 0xA8, 0x3E, 0x66, 0xBB, 0x28, 0x6A + }, + { + 0x4A, 0x84, 0x84, 0xD8, 0x1A, 0xD3, 0x6F, 0x14, + 0x7D, 0x78, 0x32, 0xCC, 0x90, 0x93, 0xCB, 0xEA, + 0xE6, 0xA3, 0xC3, 0x4F, 0xE4, 0xD4, 0x41, 0x7D, + 0xDB, 0xC6, 0xA5, 0x39, 0xB2, 0x78, 0xB1, 0xF3 + }, + { + 0x3A, 0x19, 0xE8, 0x3D, 0xD1, 0xE6, 0xFC, 0x8F, + 0xF7, 0x65, 0x34, 0x86, 0xD4, 0xAD, 0xC9, 0x8E, + 0x51, 0x5D, 0x24, 0x08, 0xB4, 0xE1, 0x0C, 0x17, + 0xEA, 0xEB, 0xA4, 0x9E, 0x17, 0xBB, 0xC8, 0xEF + }, + { + 0xA3, 0x23, 0x5D, 0x70, 0x0C, 0x3F, 0x1E, 0x66, + 0xBA, 0x6E, 0xE0, 0xA4, 0x28, 0x39, 0xA2, 0x4C, + 0x32, 0x57, 0x8C, 0x19, 0x7B, 0xBC, 0x03, 0xFB, + 0x39, 0x9F, 0x5C, 0xE1, 0xEA, 0x08, 0x59, 0xCA + }, + { + 0xB5, 0x54, 0x9C, 0x20, 0x7D, 0x6E, 0x04, 0xC4, + 0x35, 0x1D, 0x96, 0xA2, 0xD6, 0xC8, 0x5A, 0x75, + 0x12, 0x18, 0x4F, 0xEB, 0xDF, 0xB7, 0x03, 0x8C, + 0xD2, 0x9D, 0xF6, 0xB0, 0xC9, 0xF1, 0xB8, 0x1E + }, + { + 0x31, 0x45, 0x98, 0x13, 0x45, 0x21, 0xCB, 0x4F, + 0x70, 0xB9, 0xA8, 0x7D, 0xFB, 0x73, 0xB9, 0x7C, + 0xCB, 0xFF, 0xE8, 0x6B, 0x12, 0x21, 0xAF, 0x0C, + 0x40, 0xA5, 0x20, 0xE4, 0xD9, 0x23, 0xFB, 0x60 + }, + { + 0x07, 0x7E, 0x22, 0x7E, 0xD2, 0x44, 0xC1, 0xD6, + 0x71, 0x6F, 0xC4, 0xD8, 0x46, 0xF5, 0xA9, 0xCB, + 0xE8, 0x30, 0x52, 0x4B, 0x7B, 0x6C, 0x9A, 0x47, + 0x0C, 0x4D, 0xE1, 0x0B, 0xF3, 0x65, 0x4B, 0x02 + }, + { + 0x9A, 0x64, 0x2C, 0x05, 0x8D, 0xE7, 0x9A, 0x85, + 0xB3, 0xA3, 0x24, 0x38, 0x71, 0xCE, 0xF8, 0xF5, + 0x02, 0x87, 0xBD, 0x98, 0xA5, 0xC9, 0x6C, 0x31, + 0x6E, 0x61, 0x4D, 0x1B, 0x6D, 0xBE, 0x5E, 0xA2 + }, + { + 0x66, 0x70, 0xB7, 0x88, 0x94, 0x2C, 0x68, 0x47, + 0xD0, 0x3C, 0xA1, 0xF9, 0x41, 0x6D, 0x84, 0xC2, + 0x3B, 0x25, 0x2D, 0x25, 0x07, 0x84, 0x8C, 0xDA, + 0x66, 0x0F, 0x6A, 0x14, 0x83, 0xE0, 0x33, 0xBD + }, + { + 0xE7, 0x08, 0x82, 0x26, 0xF9, 0xEB, 0x3D, 0x82, + 0x47, 0x1F, 0x07, 0xBD, 0xB2, 0x16, 0x43, 0x30, + 0x7B, 0x5D, 0xDE, 0x07, 0x96, 0xA4, 0x8A, 0xFF, + 0x53, 0x64, 0x2E, 0xB9, 0x3A, 0x29, 0xBF, 0xB0 + }, + { + 0xE7, 0x2A, 0x0F, 0x8C, 0x01, 0x5C, 0x7D, 0x40, + 0x44, 0xA2, 0xBA, 0x1D, 0xFC, 0x75, 0x0F, 0xF7, + 0xE3, 0xC4, 0x54, 0x25, 0x38, 0xE2, 0x75, 0xB9, + 0x17, 0xCF, 0x0E, 0x73, 0x06, 0x6D, 0x78, 0xFE + }, + { + 0xF2, 0xDA, 0xFA, 0xA9, 0x96, 0xC3, 0x7E, 0xE6, + 0x04, 0xFC, 0xC5, 0xB1, 0xBE, 0x43, 0x62, 0xDF, + 0x56, 0x62, 0x26, 0xFF, 0xC6, 0x05, 0x20, 0x3C, + 0x54, 0x6E, 0xC7, 0x31, 0xBF, 0x35, 0x6D, 0xF4 + }, + { + 0xBA, 0x8B, 0xBB, 0xA3, 0x68, 0xB1, 0x09, 0xB0, + 0xA9, 0x83, 0x5A, 0x7A, 0xC5, 0x7A, 0xE2, 0x42, + 0x2A, 0x19, 0xA1, 0xA4, 0xC5, 0x5F, 0xC9, 0xD5, + 0x43, 0xDF, 0x25, 0xB7, 0xF8, 0x66, 0x4B, 0xEC + }, + { + 0x28, 0x95, 0xC9, 0x85, 0x04, 0xB2, 0x1F, 0x62, + 0x74, 0xFA, 0x00, 0x56, 0x64, 0xCC, 0x2D, 0x2F, + 0x97, 0x21, 0xFD, 0x26, 0xA3, 0x67, 0xFD, 0x90, + 0x5C, 0xD7, 0x77, 0xFF, 0xA6, 0x7E, 0x09, 0xAB + }, + { + 0x6B, 0x68, 0xC1, 0xC6, 0x9C, 0x7F, 0x65, 0x06, + 0xFC, 0x23, 0xCD, 0xAD, 0x98, 0x16, 0xF5, 0x56, + 0xC6, 0xAE, 0xB7, 0x17, 0xD2, 0xE9, 0x83, 0xEC, + 0x32, 0xA4, 0xA4, 0x16, 0x06, 0xF8, 0x5A, 0x60 + }, + { + 0x28, 0x71, 0xC4, 0xDF, 0xD0, 0x6D, 0x08, 0xD8, + 0x28, 0x48, 0x46, 0x77, 0x89, 0xB0, 0xB9, 0xFF, + 0x50, 0x86, 0x77, 0x53, 0x7C, 0x1C, 0x00, 0xD5, + 0x40, 0x3D, 0xA6, 0x53, 0xF2, 0xCB, 0x19, 0x3E + }, + { + 0x87, 0x43, 0x37, 0xEC, 0x05, 0xFC, 0xE5, 0x6C, + 0xCC, 0xA1, 0xE1, 0x44, 0xA8, 0xD5, 0xD9, 0x05, + 0x2A, 0xD1, 0x41, 0x11, 0x6A, 0x5A, 0x6B, 0x17, + 0x2F, 0xB2, 0x9C, 0x89, 0xA8, 0x0C, 0xFF, 0xD9 + }, + { + 0x60, 0x7D, 0x99, 0x97, 0xD7, 0x1E, 0xFF, 0x5F, + 0xBD, 0x4D, 0x81, 0x44, 0xF4, 0x7C, 0xAA, 0xD3, + 0xC4, 0x0E, 0x92, 0x09, 0xB4, 0x95, 0xA8, 0x90, + 0x42, 0x92, 0xF6, 0x90, 0x41, 0xC0, 0x98, 0xC6 + }, + { + 0xC5, 0x45, 0xDC, 0xAA, 0x50, 0x96, 0x10, 0x66, + 0x88, 0x15, 0x9E, 0xCC, 0x60, 0x5B, 0x22, 0x4D, + 0xE4, 0xCE, 0x40, 0x07, 0xF5, 0x08, 0x2B, 0xD8, + 0xFD, 0x21, 0x6F, 0x06, 0xC6, 0xD7, 0x50, 0xF1 + }, + { + 0x5F, 0x45, 0xF0, 0x0D, 0x55, 0x1E, 0xFB, 0x54, + 0xCB, 0x92, 0x3A, 0xB7, 0xC8, 0x50, 0xD5, 0x0A, + 0x8B, 0x5B, 0x24, 0x0F, 0x5F, 0xC3, 0x93, 0x24, + 0x6A, 0x59, 0xDB, 0x66, 0x01, 0xB2, 0x97, 0x37 + }, + { + 0xAA, 0xD8, 0xD4, 0xB9, 0x12, 0xD0, 0x6E, 0x58, + 0x27, 0x6A, 0xBA, 0x31, 0x00, 0xF6, 0x3D, 0xAF, + 0xBE, 0xB4, 0x34, 0x3A, 0x9D, 0x65, 0x7D, 0x28, + 0x77, 0xD8, 0x94, 0xF7, 0x72, 0x13, 0x2A, 0xF2 + }, + { + 0xF5, 0xA8, 0x0C, 0x7A, 0x14, 0x4B, 0xD4, 0xA7, + 0x65, 0xD4, 0x07, 0xEA, 0x2C, 0xF8, 0x28, 0x38, + 0x72, 0x8A, 0x3D, 0xC9, 0xEF, 0x13, 0x6B, 0x77, + 0x17, 0x79, 0x9B, 0x0A, 0x77, 0x98, 0xCB, 0x61 + }, + { + 0x1F, 0x17, 0x16, 0x10, 0xCA, 0xC7, 0xD5, 0x0D, + 0x4D, 0x3C, 0x9E, 0x19, 0xB1, 0xF6, 0x7F, 0x85, + 0x26, 0xCC, 0xB0, 0xDD, 0xE2, 0xFD, 0xBC, 0xD5, + 0x26, 0x37, 0xE1, 0x65, 0x1D, 0x56, 0x4A, 0x98 + }, + { + 0x8E, 0x8D, 0xB0, 0xDD, 0x78, 0xD9, 0x97, 0xF7, + 0xB4, 0xA5, 0xE1, 0x5C, 0xF1, 0xBB, 0x0F, 0xF2, + 0x15, 0x6A, 0xCA, 0x71, 0xC8, 0x9A, 0x3D, 0x1B, + 0x27, 0xAD, 0x99, 0xAB, 0x97, 0x77, 0x72, 0x69 + }, + { + 0xFB, 0xD9, 0xA5, 0x10, 0x7A, 0xEA, 0x4E, 0x8A, + 0x54, 0x95, 0x1E, 0x64, 0x2D, 0x6F, 0x3F, 0x44, + 0x8D, 0x82, 0x05, 0x19, 0x1B, 0xD6, 0xDB, 0x80, + 0xA3, 0x24, 0xBA, 0xAC, 0xE3, 0x52, 0x1B, 0xA8 + }, + { + 0x37, 0xBB, 0x77, 0x15, 0x46, 0x8F, 0x7E, 0xA2, + 0x80, 0xC9, 0x04, 0x88, 0x59, 0x1B, 0x06, 0x2C, + 0x7D, 0x9C, 0x91, 0x87, 0x50, 0xE5, 0x2C, 0x9F, + 0xB1, 0x1B, 0xDC, 0x86, 0x4A, 0xDC, 0x74, 0x50 + }, + { + 0x1A, 0xB0, 0xF0, 0x3C, 0x77, 0x45, 0xDB, 0x03, + 0x33, 0x34, 0x74, 0x00, 0xBB, 0xD5, 0xAC, 0x3D, + 0x5E, 0x0D, 0x13, 0x49, 0x68, 0x2C, 0x39, 0x39, + 0x78, 0xB6, 0xA5, 0xD3, 0x5F, 0xF5, 0x3D, 0x1E + }, + { + 0x89, 0x7E, 0x29, 0xD5, 0x49, 0x4B, 0xC1, 0xFD, + 0xA2, 0x21, 0xC9, 0x49, 0x7D, 0xE1, 0xA2, 0x0F, + 0x98, 0xF6, 0x5F, 0x47, 0xA4, 0x15, 0x81, 0xC1, + 0x9C, 0xF6, 0xAC, 0xF7, 0xD0, 0xB5, 0xA0, 0xE5 + }, + { + 0x0C, 0x97, 0x82, 0x15, 0x68, 0x20, 0x76, 0x57, + 0x5F, 0xF5, 0xB1, 0x02, 0x17, 0xAF, 0x43, 0xEB, + 0xDD, 0x2E, 0xD8, 0x71, 0xEA, 0x2C, 0x84, 0x40, + 0xCE, 0x15, 0x3B, 0x23, 0x27, 0xF2, 0x19, 0x65 + }, + { + 0xD3, 0x67, 0x52, 0xFC, 0xA0, 0x28, 0x08, 0x7C, + 0x97, 0x9B, 0xAE, 0xBB, 0x93, 0xC7, 0xA9, 0xFC, + 0xFE, 0xDB, 0xB7, 0x63, 0x03, 0x00, 0xB2, 0x03, + 0xC8, 0x7F, 0x19, 0x82, 0x10, 0x40, 0xAA, 0x3E + }, + { + 0x23, 0xFF, 0xC4, 0x7B, 0x3C, 0xA7, 0x4A, 0x7C, + 0x8D, 0x32, 0x71, 0xA6, 0xC3, 0xA0, 0x60, 0xA4, + 0xEE, 0xF4, 0x6D, 0xFD, 0x8F, 0xD5, 0x41, 0x55, + 0x7B, 0xB2, 0xC8, 0xB6, 0xEE, 0xD2, 0x16, 0xEE + }, + { + 0xCE, 0xC1, 0xEE, 0xA6, 0x82, 0x18, 0x59, 0x06, + 0xA5, 0xE3, 0xAC, 0xB1, 0x52, 0xEC, 0x3B, 0xD0, + 0x5C, 0x44, 0x4C, 0x02, 0x4B, 0x77, 0x0F, 0x79, + 0x03, 0x4F, 0x9F, 0xC8, 0xC5, 0xFE, 0x92, 0x95 + }, + { + 0xD4, 0x87, 0xDE, 0xE1, 0xE2, 0xEA, 0xE1, 0x65, + 0x36, 0x1F, 0x42, 0xE3, 0x8B, 0x1B, 0x12, 0xAB, + 0xA7, 0xEA, 0x36, 0x66, 0xD4, 0x72, 0x85, 0x05, + 0xE0, 0xFD, 0x03, 0xE1, 0x7C, 0x96, 0xC1, 0xFC + }, + { + 0xC0, 0x74, 0x61, 0xC1, 0x35, 0x37, 0x8D, 0xA3, + 0xE0, 0xDF, 0x84, 0x04, 0x0C, 0x6A, 0x90, 0xE7, + 0xCF, 0xF6, 0x4E, 0x0D, 0xBC, 0x7F, 0x59, 0x1B, + 0x34, 0x16, 0x6D, 0xC7, 0xEE, 0xB5, 0x43, 0xE7 + }, + { + 0x46, 0xAB, 0x0A, 0x69, 0xB9, 0x54, 0xEC, 0xF6, + 0xF2, 0x07, 0xC9, 0xD0, 0x4D, 0x5C, 0x52, 0xB9, + 0xED, 0xB3, 0xA1, 0x07, 0x10, 0xB0, 0x94, 0x09, + 0x05, 0x4C, 0x26, 0xED, 0xC3, 0x06, 0x5E, 0x8B + }, + { + 0x40, 0xC2, 0x83, 0xD9, 0xDC, 0x8A, 0x42, 0x99, + 0xCA, 0x5D, 0x36, 0xDE, 0x87, 0xAB, 0x3C, 0x15, + 0xD5, 0x1B, 0x5D, 0xB9, 0x12, 0x5E, 0x81, 0xBA, + 0x35, 0xA5, 0x7B, 0xD7, 0xB4, 0x27, 0x8C, 0x4F + }, + { + 0xC1, 0x73, 0xFC, 0x81, 0x9B, 0xFA, 0x61, 0xFB, + 0xBF, 0x02, 0xD7, 0xAC, 0xA7, 0x7E, 0x55, 0x85, + 0x53, 0x5B, 0x56, 0x17, 0x9E, 0xBE, 0xD5, 0x1B, + 0xDE, 0x6C, 0x23, 0xE7, 0x4D, 0x32, 0x8B, 0x12 + }, + { + 0x38, 0x22, 0xF0, 0xAC, 0x37, 0xC2, 0x7C, 0xFB, + 0x14, 0xB8, 0xAC, 0x46, 0xAA, 0xB1, 0x13, 0x0D, + 0xB3, 0x92, 0x0F, 0xB4, 0xF2, 0x0F, 0xE8, 0xD3, + 0x50, 0x4E, 0xBF, 0xF9, 0x13, 0xDF, 0xE2, 0xAE + }, + { + 0x39, 0x45, 0x75, 0x68, 0x23, 0x3E, 0xC3, 0x0F, + 0x35, 0x31, 0x71, 0xE2, 0x4F, 0xC6, 0x32, 0x85, + 0xFE, 0x67, 0xF8, 0x23, 0x67, 0x42, 0x2F, 0x8E, + 0xDD, 0x8F, 0x54, 0x9A, 0xA5, 0x13, 0x56, 0x2C + }, + { + 0xE2, 0x26, 0x40, 0xB2, 0x2A, 0xE3, 0x47, 0xBE, + 0x4C, 0xF5, 0xD7, 0x84, 0x6C, 0xD1, 0x52, 0x8A, + 0xE5, 0x05, 0xB3, 0x62, 0xE7, 0xD8, 0xBC, 0xCD, + 0xF1, 0xCF, 0x87, 0x38, 0xD3, 0xC3, 0x32, 0x53 + }, + { + 0xA9, 0x90, 0x95, 0x68, 0x00, 0x3D, 0x39, 0xB2, + 0x86, 0x21, 0xD0, 0x58, 0x16, 0xC7, 0x5D, 0x31, + 0x05, 0x38, 0xBC, 0x71, 0x9D, 0x11, 0x10, 0x76, + 0x53, 0x11, 0xDF, 0x74, 0x8A, 0x23, 0xA1, 0xFC + }, + { + 0xC3, 0xA9, 0xBC, 0x34, 0x0B, 0x07, 0xDC, 0x91, + 0x3C, 0x37, 0x00, 0x24, 0x2E, 0xFD, 0x89, 0x2C, + 0xD7, 0x82, 0xA0, 0x3C, 0x23, 0x52, 0x99, 0x64, + 0x6E, 0x32, 0xA8, 0xA9, 0xC2, 0x8E, 0x6E, 0x4C + }, + { + 0xAD, 0xC6, 0xFB, 0x4F, 0x6D, 0xCD, 0xD4, 0x47, + 0x9C, 0xCB, 0x5C, 0x1E, 0xFD, 0x30, 0x10, 0xEF, + 0x53, 0x80, 0x19, 0x06, 0x44, 0x29, 0x46, 0x28, + 0xDE, 0xB5, 0x94, 0x32, 0x15, 0x0E, 0xEE, 0x81 + }, + { + 0xE6, 0x3A, 0x52, 0xD0, 0xB3, 0x84, 0x4A, 0x3D, + 0xF8, 0xB3, 0x70, 0x1F, 0x93, 0x3A, 0x0A, 0x3A, + 0x84, 0xC3, 0x99, 0x41, 0x9B, 0x05, 0xFD, 0x68, + 0x55, 0x10, 0x26, 0xDE, 0x42, 0xA3, 0x98, 0x7E + }, + { + 0xC3, 0x23, 0x9D, 0x6C, 0x4F, 0x30, 0x3F, 0x85, + 0x05, 0x52, 0x89, 0xFA, 0x99, 0xC7, 0x21, 0x3D, + 0x5E, 0x60, 0x40, 0x9E, 0x19, 0x18, 0x95, 0x48, + 0x0B, 0x20, 0x57, 0x52, 0x9E, 0x31, 0x96, 0xF9 + }, + { + 0x83, 0xDE, 0xE5, 0x8B, 0x7E, 0x90, 0x00, 0xA0, + 0x9F, 0x2C, 0xE3, 0xDE, 0xD7, 0xC2, 0x1F, 0x00, + 0xE0, 0xBE, 0x50, 0xA6, 0x5B, 0x7D, 0x29, 0x85, + 0x30, 0xE3, 0x1A, 0xD2, 0xEC, 0x68, 0x4A, 0xEC + }, + { + 0x75, 0x78, 0x8D, 0x0B, 0x53, 0x18, 0x95, 0x10, + 0x59, 0xA4, 0x46, 0xB3, 0x79, 0x27, 0xBE, 0x47, + 0xFC, 0xA6, 0x32, 0x36, 0xF7, 0xF9, 0x0F, 0xE4, + 0x01, 0x04, 0xBB, 0xBA, 0x6B, 0x6D, 0x58, 0x8B + }, + { + 0x1A, 0xAE, 0xEE, 0x7B, 0xE6, 0x27, 0x80, 0x61, + 0xD0, 0xD5, 0xB5, 0x78, 0x7A, 0x22, 0xFA, 0xD3, + 0xBD, 0x6E, 0x10, 0x7C, 0xF3, 0x3F, 0xD5, 0x7B, + 0xD2, 0x8C, 0x00, 0x7C, 0x85, 0x21, 0x01, 0x54 + }, + { + 0xBA, 0x3B, 0x87, 0x1F, 0xD0, 0x0C, 0xDC, 0xCE, + 0xE4, 0xC8, 0x4D, 0xE7, 0x4D, 0x36, 0x10, 0xC5, + 0xC2, 0x62, 0x08, 0xDA, 0x86, 0x5C, 0xC7, 0x80, + 0xC8, 0x8F, 0xCF, 0xAB, 0x6A, 0x43, 0xD6, 0xF9 + }, + { + 0x46, 0xBB, 0x13, 0x3F, 0x8E, 0x64, 0xC1, 0x08, + 0x09, 0x4E, 0x22, 0xC9, 0xF3, 0x76, 0x33, 0x5C, + 0x26, 0xAF, 0x30, 0xA1, 0x73, 0xC8, 0x5F, 0x8B, + 0xC7, 0x17, 0xFE, 0x0F, 0x54, 0x80, 0x1A, 0xE5 + }, + { + 0x6A, 0xA9, 0x09, 0x7A, 0x8C, 0xF4, 0x52, 0xD6, + 0x6C, 0x89, 0x6B, 0xBF, 0x39, 0xC4, 0xD0, 0x05, + 0xB3, 0x2B, 0xDD, 0xB1, 0xD8, 0xDD, 0x51, 0x67, + 0x85, 0xBF, 0xDB, 0x31, 0x96, 0x72, 0x1F, 0xD4 + }, + { + 0xDA, 0xCE, 0x6B, 0x36, 0xDF, 0xA5, 0xF5, 0x5E, + 0x26, 0x17, 0x4A, 0x63, 0xC2, 0xFA, 0x45, 0x15, + 0x0C, 0x77, 0x6C, 0x24, 0xB1, 0x74, 0x56, 0xC7, + 0x79, 0x8E, 0xCF, 0x91, 0x9D, 0xFA, 0x3D, 0xE2 + }, + { + 0x2E, 0xF0, 0x35, 0x47, 0xF9, 0xDF, 0x2E, 0x8D, + 0xF1, 0xD9, 0x5D, 0xF3, 0x64, 0x17, 0x45, 0x53, + 0x5F, 0xB0, 0x85, 0xA4, 0xA2, 0xC4, 0xAF, 0x6F, + 0x8A, 0xDE, 0xF6, 0x59, 0x05, 0xA5, 0x2F, 0xCD + }, + { + 0xC6, 0xD5, 0x41, 0x68, 0x18, 0x56, 0x33, 0xCC, + 0xF4, 0x13, 0x22, 0x4A, 0x0B, 0x89, 0xD1, 0xC0, + 0x99, 0xAC, 0xF5, 0xF6, 0x4F, 0x80, 0xA9, 0x35, + 0x33, 0x3C, 0xC1, 0x7F, 0x28, 0x17, 0xCF, 0x0A + }, + { + 0xC8, 0x8B, 0xDB, 0x89, 0x9E, 0x64, 0x1F, 0x6D, + 0xF0, 0xBB, 0xC2, 0x9B, 0x2B, 0xB9, 0x90, 0x8A, + 0xF2, 0x68, 0xCB, 0xB3, 0xE9, 0xDF, 0x6E, 0xA4, + 0xCF, 0x7A, 0xA0, 0x3C, 0xCA, 0xF0, 0xF1, 0xFD + }, + { + 0x54, 0x7D, 0x86, 0xEF, 0x6B, 0xA3, 0x57, 0x5C, + 0x0C, 0x82, 0x68, 0x7F, 0x51, 0x83, 0xC1, 0xD3, + 0x1E, 0x10, 0x4C, 0xFF, 0xE6, 0x3D, 0x28, 0xB2, + 0xE3, 0xF7, 0x5D, 0xF3, 0x47, 0x52, 0xE3, 0xB7 + }, + { + 0x3C, 0x18, 0x51, 0x33, 0x7B, 0x11, 0x1E, 0x58, + 0x59, 0x86, 0xCA, 0x25, 0x13, 0x2A, 0xD2, 0x83, + 0x85, 0x59, 0x5B, 0x2F, 0x1A, 0x40, 0x57, 0x34, + 0x0A, 0xB7, 0xA7, 0xBD, 0x0B, 0x90, 0xBF, 0xF5 + }, + { + 0x15, 0xCA, 0xE7, 0xF7, 0x5B, 0xF2, 0xC7, 0x3C, + 0x1F, 0xE6, 0xBA, 0xE0, 0xF2, 0xCE, 0x46, 0x3C, + 0x5A, 0x72, 0x28, 0xED, 0x3A, 0x3D, 0x34, 0x13, + 0xDA, 0x80, 0x9E, 0x52, 0x35, 0x9F, 0x21, 0xB1 + }, + { + 0xDE, 0x38, 0xE5, 0xA7, 0x4E, 0xB5, 0x4E, 0x48, + 0x4E, 0x34, 0x79, 0xBD, 0xF9, 0x60, 0xDF, 0x98, + 0x39, 0x7F, 0x4C, 0xF4, 0x9B, 0x6C, 0x38, 0x22, + 0x95, 0x80, 0x24, 0x0B, 0xF9, 0xFF, 0xD5, 0x53 + }, + { + 0xCE, 0x8B, 0x0C, 0x1C, 0x43, 0x00, 0x43, 0xFA, + 0x33, 0x38, 0x5C, 0xE3, 0xEC, 0xD0, 0x3C, 0xCD, + 0x48, 0x86, 0x18, 0xFB, 0x74, 0x7E, 0xCF, 0xF8, + 0x5E, 0x9F, 0xD6, 0x8C, 0x2E, 0x89, 0x0A, 0x4F + }, + { + 0x18, 0x31, 0xC8, 0x17, 0x79, 0xB6, 0x66, 0x0D, + 0xC6, 0xAE, 0x98, 0x59, 0x2D, 0x47, 0x28, 0x9C, + 0xA5, 0x07, 0x8E, 0x03, 0xFB, 0xC5, 0x58, 0x77, + 0xE0, 0x37, 0x6F, 0xA7, 0x4D, 0xE7, 0x42, 0xDA + }, + { + 0x1B, 0x7A, 0xA2, 0xEC, 0x11, 0x2D, 0xFC, 0x5E, + 0xAD, 0x81, 0xD4, 0x46, 0x4A, 0x90, 0x94, 0xC9, + 0x13, 0xC2, 0x57, 0xD4, 0x74, 0x9A, 0x5E, 0x18, + 0xDC, 0xFB, 0x5E, 0x8D, 0xB5, 0x80, 0x2E, 0x0D + }, + { + 0xFB, 0x6C, 0x24, 0x29, 0x35, 0xA4, 0xB7, 0xCF, + 0x2A, 0x37, 0x4F, 0xD2, 0x61, 0xB6, 0xF7, 0x63, + 0xAC, 0xF5, 0x2A, 0x40, 0xC0, 0x12, 0xD9, 0xA1, + 0xC2, 0xB2, 0xE2, 0xF4, 0xC3, 0x79, 0x7E, 0xEA + }, + { + 0xFB, 0xE2, 0x9E, 0xEE, 0x1A, 0x04, 0xE8, 0x61, + 0xC0, 0x38, 0x61, 0xC4, 0x06, 0x3B, 0xE4, 0xCE, + 0x41, 0xDA, 0x16, 0xF1, 0x02, 0x59, 0x05, 0xCF, + 0xD8, 0x54, 0xDA, 0x31, 0x8E, 0x6D, 0xC8, 0x6A + }, + { + 0x0D, 0xE3, 0x70, 0x83, 0x4E, 0x3C, 0xCB, 0x46, + 0xB9, 0x95, 0xB4, 0x0B, 0xA9, 0x7D, 0x76, 0x59, + 0xEB, 0x3D, 0x1D, 0x6C, 0x55, 0xA5, 0x58, 0x03, + 0xEB, 0x30, 0xA6, 0x41, 0xBB, 0x57, 0xD4, 0x70 + }, + { + 0x1D, 0x90, 0xAB, 0xB5, 0x09, 0xC9, 0xEE, 0x33, + 0x67, 0xFA, 0x48, 0xD4, 0xDD, 0x4B, 0x72, 0x5C, + 0x29, 0x6B, 0x16, 0x81, 0x25, 0x4D, 0xAD, 0x65, + 0x85, 0xA8, 0x0A, 0xD5, 0x60, 0x3A, 0xE9, 0xBD + }, + { + 0x2C, 0x7E, 0xFF, 0x23, 0x57, 0xA6, 0xD0, 0x17, + 0x3C, 0x30, 0xC6, 0x6C, 0x34, 0x18, 0x2D, 0x53, + 0x6A, 0x50, 0xBC, 0x09, 0x51, 0xF9, 0x79, 0x01, + 0x7A, 0x96, 0x66, 0xB5, 0xF3, 0x16, 0x89, 0x72 + }, + { + 0xF2, 0x83, 0xD4, 0x2A, 0x53, 0x88, 0xF3, 0x8E, + 0x01, 0x9B, 0xAC, 0xCB, 0x95, 0xB4, 0xD9, 0x65, + 0xE8, 0xB7, 0x62, 0x0B, 0x39, 0x5E, 0x76, 0xA1, + 0xDD, 0xA2, 0x4F, 0x3F, 0x77, 0xAA, 0xF1, 0xCE + }, + { + 0xF3, 0x90, 0xA3, 0x56, 0x02, 0x36, 0xED, 0x20, + 0x3F, 0x08, 0x90, 0x28, 0x1C, 0x4F, 0xD2, 0x47, + 0x36, 0xF8, 0x1E, 0xED, 0x38, 0x02, 0x5E, 0x90, + 0x7F, 0x22, 0x37, 0x84, 0xF7, 0x55, 0xD0, 0x4B + }, + { + 0x00, 0xF3, 0xFD, 0x22, 0x6B, 0x22, 0x19, 0x15, + 0x65, 0x17, 0xEB, 0x59, 0xEE, 0x3E, 0x76, 0x03, + 0xC8, 0x9C, 0x5F, 0xD2, 0x61, 0xF7, 0x4C, 0x05, + 0x3C, 0x78, 0x87, 0x87, 0x78, 0xB9, 0xB8, 0x56 + }, + { + 0xDC, 0xCE, 0x73, 0xFC, 0x5E, 0x1F, 0xF4, 0x48, + 0x48, 0x66, 0x89, 0x0D, 0x2A, 0x26, 0x7B, 0x8C, + 0xA4, 0xF2, 0x6B, 0xD5, 0xB8, 0xE0, 0x1A, 0x27, + 0x87, 0x14, 0x94, 0x7D, 0xD0, 0xB8, 0x1F, 0x7C + }, + { + 0xD1, 0x51, 0x13, 0x96, 0xE2, 0xB9, 0x10, 0x38, + 0x02, 0xD0, 0x57, 0xD5, 0xCD, 0x45, 0x36, 0x56, + 0x3D, 0x52, 0x78, 0xAA, 0x29, 0x9F, 0x75, 0xF0, + 0x5A, 0xCA, 0x0A, 0x16, 0xCE, 0x1B, 0x67, 0xAA + }, + { + 0x96, 0xCC, 0xD3, 0xA3, 0xBB, 0xD1, 0x1E, 0xE3, + 0x25, 0x96, 0xEE, 0x28, 0xE6, 0x1B, 0x1E, 0x93, + 0x54, 0xB1, 0x5A, 0x69, 0xB2, 0xEA, 0xA2, 0x4A, + 0xE4, 0x38, 0x76, 0x72, 0x18, 0x33, 0x12, 0x86 + }, + { + 0x86, 0x26, 0x9F, 0x9A, 0x50, 0xF5, 0x69, 0x24, + 0x4F, 0x32, 0x36, 0x21, 0x5C, 0x9E, 0xB4, 0xC3, + 0x03, 0x6D, 0x7F, 0x7F, 0x00, 0x44, 0xD4, 0x34, + 0x81, 0x28, 0x8C, 0x27, 0xAF, 0xB4, 0x23, 0x2B + }, + { + 0x1C, 0xA1, 0xF1, 0xB8, 0x4B, 0x79, 0xFB, 0x0F, + 0x49, 0xA0, 0xD9, 0xFA, 0xF1, 0xFF, 0x1C, 0xE1, + 0x40, 0x2B, 0x0C, 0x66, 0xBD, 0x86, 0x93, 0xBF, + 0xD3, 0xCC, 0x85, 0xCC, 0x20, 0xC5, 0x81, 0xE2 + }, + { + 0xF7, 0x27, 0xC1, 0x1E, 0x9E, 0x56, 0xF5, 0xED, + 0xFA, 0x6E, 0x05, 0x6E, 0x67, 0xB9, 0x6F, 0x98, + 0x9F, 0xC2, 0xCA, 0x9F, 0x5B, 0xED, 0x08, 0x6A, + 0x21, 0x09, 0x8D, 0x37, 0xC7, 0xF2, 0xF7, 0xF0 + }, + { + 0x5F, 0xCB, 0x61, 0x13, 0x02, 0x3E, 0x0E, 0xA5, + 0xAE, 0x4E, 0x5A, 0xDA, 0x69, 0xA9, 0x0B, 0xAD, + 0x68, 0x10, 0x33, 0x0A, 0xC8, 0x2C, 0x21, 0x0B, + 0x0E, 0xF3, 0xF1, 0x00, 0x20, 0xB4, 0x5B, 0x39 + }, + { + 0x2A, 0x1C, 0x2D, 0x5D, 0xEB, 0x0E, 0x09, 0x10, + 0x2D, 0xEA, 0xA3, 0x7B, 0xDE, 0x82, 0x9F, 0xA8, + 0x44, 0x8B, 0xA2, 0xB4, 0xA6, 0x61, 0x39, 0x0D, + 0xF9, 0xB0, 0x24, 0x4C, 0xD4, 0xCD, 0xFB, 0x75 + }, + { + 0xFC, 0x1E, 0xB2, 0x4E, 0xD0, 0xB8, 0x66, 0xBE, + 0x3C, 0x7A, 0x8D, 0xC4, 0xA9, 0x95, 0x82, 0x31, + 0xE8, 0x8B, 0xB0, 0x66, 0xB0, 0x97, 0x97, 0x8D, + 0xC5, 0xFE, 0xFB, 0x9B, 0x9B, 0xED, 0x01, 0xEF + }, + { + 0xC6, 0xD1, 0x4C, 0xAD, 0xAC, 0x38, 0xA3, 0x91, + 0xF5, 0x27, 0x29, 0x8A, 0xB1, 0x7D, 0x57, 0x56, + 0x69, 0xEF, 0x44, 0x96, 0x7A, 0xC0, 0xD9, 0x03, + 0x6B, 0x41, 0x60, 0x77, 0x60, 0x78, 0x68, 0xCD + }, + { + 0xBA, 0x86, 0x1B, 0xBC, 0x17, 0xFB, 0xE8, 0x7A, + 0x6B, 0x05, 0x3A, 0x7B, 0x94, 0xE8, 0x7F, 0x80, + 0x6A, 0x6E, 0xBA, 0x03, 0xFE, 0xA4, 0xAE, 0x29, + 0x5A, 0x96, 0x1F, 0xA0, 0x64, 0x7E, 0xDA, 0xD5 + }, + { + 0x95, 0xF9, 0x5F, 0x9E, 0xA6, 0x72, 0x7C, 0xB2, + 0x15, 0xC4, 0x3B, 0x4E, 0xEC, 0x20, 0xCB, 0x50, + 0x68, 0x04, 0x5C, 0x06, 0x7E, 0xFC, 0xDA, 0x38, + 0xCC, 0xF0, 0x4E, 0x29, 0x83, 0x28, 0x94, 0xB3 + }, + { + 0xDA, 0xC2, 0xAF, 0xC5, 0xE5, 0x25, 0x7F, 0x26, + 0x12, 0x85, 0x55, 0x21, 0xF3, 0x99, 0x70, 0x8B, + 0x00, 0xA6, 0x77, 0xB5, 0xCB, 0xC7, 0x47, 0x7C, + 0xE8, 0x44, 0x4B, 0xD0, 0xEB, 0xD9, 0xCB, 0x34 + }, + { + 0x68, 0xE5, 0x99, 0xFC, 0x54, 0x44, 0x1D, 0x32, + 0x0C, 0xD2, 0x7B, 0x29, 0x89, 0x1A, 0x0D, 0x99, + 0xE9, 0x1E, 0x5F, 0xFA, 0xD2, 0x79, 0x3A, 0xA2, + 0x0F, 0x73, 0x42, 0xB2, 0x54, 0x93, 0xB5, 0x8D + }, + { + 0x19, 0x80, 0x2A, 0xF7, 0x6C, 0x19, 0x0B, 0x98, + 0x06, 0x2D, 0x3E, 0xC5, 0xA5, 0x66, 0xAC, 0x86, + 0xC8, 0x18, 0x38, 0x69, 0x48, 0xED, 0xEA, 0x99, + 0xA6, 0x7B, 0x3A, 0x80, 0xD6, 0x3D, 0x6E, 0x30 + }, + { + 0xC8, 0xEF, 0xCE, 0x9D, 0xEE, 0x72, 0x9E, 0x7A, + 0xFA, 0x40, 0xBF, 0xB6, 0x3C, 0x1F, 0xEB, 0xA7, + 0x2A, 0x77, 0xF0, 0xF9, 0x62, 0xC2, 0x7D, 0x12, + 0xA6, 0x8C, 0x53, 0x79, 0x4F, 0xA9, 0xB2, 0x74 + }, + { + 0xDD, 0x57, 0xCA, 0x69, 0xCB, 0x49, 0x7E, 0xF2, + 0xB3, 0x8B, 0x4A, 0x4B, 0x8C, 0x0B, 0x01, 0x9F, + 0xF2, 0x93, 0xC8, 0x22, 0xE3, 0x4E, 0xA4, 0xCA, + 0xA5, 0x81, 0x3F, 0xFE, 0xA9, 0x7E, 0x94, 0x6D + }, + { + 0x14, 0x8F, 0xF9, 0x75, 0x4D, 0x8C, 0xC9, 0x12, + 0x3B, 0xCE, 0x7F, 0xFB, 0xC1, 0x27, 0xAA, 0xEB, + 0xB7, 0x63, 0xCC, 0x7D, 0x86, 0x8D, 0xC6, 0xEC, + 0x0C, 0x4E, 0xD1, 0xC1, 0xFD, 0x24, 0x4D, 0x7E + }, + { + 0x20, 0xE7, 0x6B, 0xDD, 0x92, 0x88, 0x33, 0xAE, + 0xA0, 0xE3, 0x18, 0x47, 0xF6, 0xAC, 0x9A, 0xAB, + 0xE9, 0xD8, 0xC6, 0x35, 0x59, 0x0D, 0x7B, 0x5F, + 0x31, 0xB8, 0x3B, 0x39, 0xA5, 0x1D, 0xC4, 0xBC + }, + { + 0x2B, 0xF2, 0x12, 0xA9, 0xCD, 0x83, 0x3E, 0xED, + 0x96, 0xD0, 0x6C, 0x7B, 0xBB, 0x80, 0x97, 0x16, + 0xA2, 0x24, 0x53, 0x23, 0x30, 0x5A, 0x57, 0x32, + 0x03, 0x52, 0x27, 0xAF, 0x09, 0x15, 0xE1, 0x5E + }, + { + 0x53, 0x67, 0x0E, 0xDF, 0xA8, 0x18, 0x73, 0x9A, + 0xDE, 0x2D, 0xDB, 0xA4, 0x99, 0xEC, 0xF0, 0x64, + 0xD4, 0xDF, 0xB3, 0xEA, 0x65, 0x29, 0x6D, 0xDE, + 0x94, 0x3D, 0xA7, 0x29, 0x2A, 0x5B, 0x17, 0x19 + }, + { + 0x8C, 0x11, 0xB4, 0xDA, 0xC9, 0x5C, 0x9D, 0xFB, + 0x89, 0xD6, 0x4E, 0x89, 0x43, 0x4C, 0xEB, 0x7F, + 0x52, 0x91, 0xDF, 0xF7, 0x73, 0x1D, 0xB2, 0x82, + 0x79, 0x1F, 0x69, 0x94, 0xDD, 0xB7, 0x12, 0x12 + }, + { + 0x03, 0x77, 0x3D, 0xCC, 0x46, 0x8E, 0xB6, 0x28, + 0xB2, 0x23, 0x16, 0x7A, 0x55, 0x9E, 0xD8, 0x09, + 0x4C, 0xFE, 0x94, 0xB1, 0xF9, 0x08, 0x94, 0xD1, + 0x2C, 0x0E, 0x61, 0xD0, 0x6C, 0x75, 0x21, 0x92 + }, + { + 0x64, 0xBC, 0xF1, 0x68, 0x68, 0x08, 0xF2, 0x5F, + 0xB6, 0x39, 0x9A, 0x87, 0xDE, 0xEA, 0xB9, 0x74, + 0x3C, 0x23, 0x4A, 0x18, 0x3B, 0x0F, 0x94, 0xB9, + 0x90, 0x08, 0xE1, 0x21, 0xE2, 0xC1, 0x29, 0x7C + }, + { + 0x81, 0x4D, 0x92, 0xD9, 0xEA, 0x04, 0xA9, 0xCC, + 0x88, 0xD4, 0x36, 0x86, 0xB2, 0x5D, 0x4E, 0xE0, + 0x66, 0x04, 0xE9, 0xD1, 0x75, 0x1B, 0x6E, 0x4C, + 0xCF, 0x7D, 0x7A, 0xD9, 0x22, 0xA6, 0x67, 0x34 + }, + { + 0x76, 0x69, 0xDB, 0x05, 0xF1, 0xD7, 0x5A, 0xA1, + 0x6A, 0xEE, 0x6F, 0xE8, 0xF3, 0xC9, 0x1F, 0x8E, + 0x43, 0x98, 0xBF, 0x08, 0xDE, 0x8E, 0x39, 0x96, + 0x98, 0xDF, 0x09, 0xE2, 0x79, 0x6E, 0xCD, 0x14 + }, + { + 0xA8, 0x1B, 0xFC, 0x39, 0xDE, 0x9A, 0x63, 0xCA, + 0xD8, 0xE9, 0xCE, 0x26, 0x44, 0x70, 0xF8, 0x4E, + 0x81, 0xFD, 0x91, 0x26, 0x38, 0xB4, 0xA4, 0x0A, + 0x9A, 0x42, 0xB2, 0x25, 0xFF, 0x06, 0x65, 0xDB + }, + { + 0x6A, 0xB3, 0x7A, 0xEB, 0x76, 0x8C, 0xB1, 0x7D, + 0x31, 0x2B, 0xE9, 0x77, 0x77, 0x34, 0x13, 0x4A, + 0x28, 0x27, 0x9D, 0xC8, 0x47, 0x94, 0xFF, 0x78, + 0xD8, 0x6C, 0xEA, 0xB1, 0x46, 0xC0, 0xD8, 0xAF + }, + { + 0x14, 0x7C, 0x4F, 0x61, 0xDA, 0x80, 0x5C, 0xF3, + 0xCD, 0xE3, 0xD0, 0x39, 0x7B, 0xF3, 0x8A, 0xA6, + 0x1D, 0xF1, 0xEE, 0xEB, 0x66, 0x9A, 0x61, 0x5E, + 0x41, 0x3F, 0x15, 0x11, 0xAE, 0x52, 0x67, 0x6C + }, + { + 0x16, 0xE1, 0xF6, 0x34, 0x90, 0x50, 0xDD, 0xA8, + 0xA9, 0x8C, 0x22, 0x36, 0x62, 0x5E, 0x88, 0xED, + 0x9B, 0xEF, 0x47, 0xA0, 0x7D, 0x61, 0xD5, 0x38, + 0x9F, 0x2B, 0x0B, 0x5B, 0x47, 0x5F, 0x7B, 0x26 + }, + { + 0x2D, 0x0D, 0x0A, 0xA3, 0x28, 0x5D, 0x78, 0xB8, + 0x9B, 0x5B, 0xA3, 0xE5, 0x81, 0x2C, 0x02, 0x63, + 0x61, 0xBC, 0x82, 0x06, 0x45, 0x64, 0xE0, 0x12, + 0x51, 0xB5, 0x95, 0xA4, 0x98, 0x07, 0xBE, 0x8B + }, + { + 0x7D, 0x07, 0xD6, 0x9E, 0x32, 0xF8, 0xFB, 0xEE, + 0xF1, 0xA9, 0xA5, 0x70, 0x28, 0x5D, 0xC2, 0x3B, + 0x48, 0x39, 0xB7, 0x58, 0x86, 0xAC, 0xED, 0x91, + 0xA7, 0xB3, 0x88, 0xCE, 0xA5, 0x92, 0x99, 0x3D + }, + { + 0x3E, 0xE9, 0x82, 0x6D, 0x9D, 0x78, 0x95, 0x86, + 0xF9, 0x54, 0xEE, 0x56, 0xC9, 0xD9, 0x32, 0x32, + 0x4C, 0x3C, 0x43, 0xA0, 0xD3, 0x37, 0x57, 0xF8, + 0x77, 0x96, 0x8D, 0xD6, 0xD3, 0x07, 0x0F, 0xA8 + }, + { + 0x87, 0x25, 0xBB, 0x31, 0x82, 0x38, 0x7D, 0x54, + 0x4C, 0xF7, 0x1C, 0x6E, 0xDD, 0x86, 0x49, 0xA3, + 0x88, 0xAD, 0xF7, 0xCC, 0x34, 0x05, 0x7C, 0x81, + 0x6D, 0x0F, 0x5E, 0x46, 0xCC, 0x9A, 0xD5, 0xC5 + }, + { + 0x73, 0x5E, 0xAD, 0x72, 0xA7, 0x36, 0xAB, 0x0D, + 0x30, 0x1B, 0xEB, 0x06, 0x32, 0x96, 0xB9, 0xA4, + 0x0C, 0xDF, 0xD0, 0x09, 0x04, 0x04, 0x15, 0xEF, + 0xF1, 0x61, 0xEA, 0x4E, 0x9C, 0xEA, 0x7C, 0x0C + }, + { + 0x85, 0x8A, 0x4F, 0xEE, 0x3B, 0x6B, 0x14, 0x7B, + 0x77, 0xF2, 0xA9, 0x53, 0x1E, 0x2F, 0x9D, 0x5B, + 0x43, 0x9A, 0x10, 0xDF, 0x8A, 0x4C, 0x83, 0xC0, + 0x7D, 0xB0, 0xEE, 0x14, 0x80, 0x2D, 0x57, 0x74 + }, + { + 0xAF, 0xA7, 0x0D, 0x26, 0x13, 0xA6, 0x0C, 0xF7, + 0x0D, 0x89, 0x90, 0xA1, 0xF2, 0x15, 0x05, 0x49, + 0x90, 0x6E, 0x9E, 0x5E, 0xD7, 0x98, 0x97, 0x82, + 0x7A, 0xF4, 0xAC, 0x74, 0xC2, 0xD3, 0x9A, 0xA9 + }, + { + 0x02, 0x6C, 0x57, 0xE3, 0x5E, 0x17, 0x4A, 0x58, + 0x72, 0x2C, 0x43, 0xE6, 0x28, 0x17, 0x7A, 0xF8, + 0x5B, 0xBE, 0x21, 0x6E, 0xC9, 0xCF, 0xDB, 0x1E, + 0xC4, 0xE0, 0x74, 0x51, 0x92, 0x11, 0x7A, 0x17 + }, + { + 0x2D, 0x68, 0xE4, 0x4D, 0xE9, 0x34, 0x63, 0x2A, + 0xDC, 0xBF, 0xF8, 0xE0, 0xA4, 0x35, 0xB2, 0x00, + 0x54, 0x09, 0x10, 0xF3, 0x1E, 0xDE, 0x7E, 0xF7, + 0x99, 0x8F, 0x00, 0x22, 0x00, 0x87, 0xF6, 0xB6 + }, + { + 0x40, 0xCE, 0x6E, 0x6C, 0x29, 0x10, 0x96, 0x91, + 0xFB, 0xE8, 0xA4, 0x1B, 0xA7, 0x45, 0xD0, 0x3A, + 0x7E, 0xCD, 0xD0, 0x80, 0xA4, 0xA8, 0x8F, 0x45, + 0x85, 0x97, 0x34, 0x51, 0xA2, 0xDC, 0x9C, 0xF7 + }, + { + 0x9F, 0xA0, 0xF0, 0x5D, 0x41, 0x84, 0x5B, 0x17, + 0xC3, 0x6F, 0x49, 0x9C, 0xE8, 0xE9, 0xB6, 0x72, + 0x5A, 0xA3, 0x9B, 0xC8, 0xB7, 0xD1, 0xBF, 0x1C, + 0xAA, 0x2A, 0x9B, 0x4C, 0xB8, 0x7F, 0xAB, 0xDA + }, + { + 0x71, 0x6C, 0x7D, 0xBD, 0x5E, 0x70, 0x9C, 0x3F, + 0x84, 0x31, 0x49, 0x64, 0x02, 0xD1, 0xB3, 0x9B, + 0xCB, 0xC1, 0x91, 0x35, 0xDB, 0xE4, 0xC3, 0x1D, + 0xC2, 0xDE, 0xFF, 0x27, 0x66, 0x0A, 0x61, 0x8E + }, + { + 0x73, 0xEA, 0x85, 0x8F, 0xA2, 0x4D, 0x5C, 0x6B, + 0x63, 0xB2, 0x51, 0x12, 0x1B, 0xDB, 0x84, 0x70, + 0xD1, 0x65, 0xDD, 0x65, 0xC1, 0xA6, 0xAD, 0x8B, + 0x84, 0xED, 0x40, 0x09, 0xF1, 0xA4, 0x09, 0xBE + }, + { + 0xC3, 0xFF, 0xAA, 0xA8, 0x11, 0x75, 0xE3, 0x1E, + 0xF3, 0x53, 0xAD, 0xFF, 0x34, 0x39, 0xC9, 0x07, + 0xAF, 0xA4, 0xCF, 0x6B, 0xC0, 0x83, 0xA6, 0x30, + 0xDC, 0xD2, 0x70, 0x85, 0xFF, 0x90, 0xD8, 0x98 + }, + { + 0x50, 0x3E, 0x06, 0x46, 0xEB, 0x60, 0x5B, 0x92, + 0x5B, 0xB0, 0xE8, 0x2F, 0xDE, 0x93, 0xE0, 0xE5, + 0x59, 0x53, 0x13, 0x33, 0x73, 0x89, 0x74, 0x11, + 0x4D, 0x72, 0x56, 0x1C, 0x33, 0x0F, 0x0B, 0x8B + }, + { + 0x88, 0x86, 0xFD, 0x3F, 0xB6, 0x28, 0xB7, 0x18, + 0xFD, 0x9F, 0x8F, 0x3A, 0x89, 0xE4, 0x7E, 0x6C, + 0x79, 0x1B, 0xAF, 0x52, 0x64, 0x0E, 0x3A, 0xDA, + 0x1F, 0x61, 0x7D, 0xA9, 0x6F, 0x5B, 0x90, 0x50 + }, + { + 0xD8, 0x3D, 0x7E, 0xD3, 0x7E, 0x8F, 0xB7, 0x82, + 0x2C, 0xFA, 0x58, 0xA8, 0xA3, 0x0F, 0xFE, 0xF1, + 0x4D, 0xB0, 0xDA, 0xA1, 0xBD, 0x2E, 0x59, 0x66, + 0x25, 0xA0, 0x6E, 0x15, 0xF1, 0x9C, 0x17, 0xBD + }, + { + 0x2C, 0xF9, 0x67, 0xB1, 0xF0, 0xE0, 0x70, 0x17, + 0x68, 0xFC, 0x71, 0x9F, 0x56, 0x62, 0x78, 0x24, + 0xD7, 0xAB, 0xEB, 0x68, 0x51, 0x17, 0x52, 0xCE, + 0x48, 0x89, 0x51, 0xCB, 0xD1, 0x9C, 0x7F, 0x44 + }, + { + 0x91, 0x06, 0xDA, 0xA4, 0xDD, 0x76, 0xB0, 0x3D, + 0x21, 0xDB, 0x44, 0x9B, 0xA0, 0xEA, 0xC5, 0xE8, + 0x93, 0x96, 0x03, 0xC5, 0xBA, 0xFD, 0xF1, 0xFD, + 0x80, 0xC5, 0xE6, 0xE8, 0x00, 0xA7, 0x19, 0x56 + }, + { + 0x95, 0xD3, 0x71, 0x8A, 0x41, 0x14, 0xB0, 0x37, + 0xEE, 0x5E, 0x17, 0xE3, 0x70, 0x76, 0xF6, 0x4D, + 0x10, 0xD1, 0x30, 0xFE, 0x3F, 0x68, 0x8E, 0x8A, + 0x9F, 0xC2, 0x83, 0x7C, 0x16, 0x64, 0x0B, 0x7B + }, + { + 0xA6, 0xEE, 0x07, 0xB1, 0x1B, 0xD8, 0x9A, 0xAF, + 0x51, 0x17, 0x7B, 0x72, 0x2B, 0x24, 0x5A, 0xD7, + 0x79, 0xA7, 0x04, 0x9D, 0x1F, 0x68, 0x13, 0x03, + 0xAE, 0xEB, 0xC6, 0xB0, 0x4F, 0x88, 0x05, 0x98 + }, + { + 0x07, 0x68, 0x37, 0xB1, 0x80, 0x5A, 0xB0, 0xBC, + 0xF7, 0x7D, 0x02, 0x66, 0x4D, 0xEE, 0x45, 0xF4, + 0xED, 0xB1, 0x39, 0xE3, 0xF0, 0xB2, 0xB6, 0x4F, + 0x3B, 0x22, 0x47, 0x85, 0x98, 0xD5, 0x70, 0xE3 + }, + { + 0x83, 0xD6, 0x7E, 0xE9, 0x7A, 0xEC, 0x23, 0x88, + 0x80, 0x30, 0x4A, 0xC0, 0x83, 0x5C, 0x28, 0xB2, + 0x1A, 0x9D, 0xA4, 0x4B, 0x36, 0x4D, 0xF1, 0xD9, + 0x0C, 0x30, 0x4A, 0x5F, 0x71, 0x35, 0x6A, 0x68 + }, + { + 0x5F, 0x10, 0xD0, 0xDB, 0xB0, 0x02, 0xDD, 0x32, + 0xE6, 0x64, 0xBD, 0xAA, 0x14, 0x32, 0x2E, 0xFB, + 0x53, 0x7F, 0x3C, 0xA6, 0x0E, 0xE1, 0xF0, 0x66, + 0x3B, 0x3F, 0x5E, 0xD7, 0xB6, 0xF9, 0x74, 0x07 + }, + { + 0x38, 0x79, 0x33, 0x0A, 0x9C, 0xEF, 0x6C, 0xA5, + 0x86, 0x08, 0x5A, 0x9E, 0xD5, 0x09, 0xE6, 0x0F, + 0x17, 0x6B, 0x80, 0x69, 0xC6, 0xF9, 0x60, 0x60, + 0x11, 0x8D, 0x5A, 0x2D, 0x4E, 0x1C, 0x39, 0xDF + }, + { + 0xC2, 0xE4, 0xF5, 0x00, 0xAE, 0x20, 0x04, 0xC5, + 0xDB, 0xBF, 0xBF, 0x22, 0xB6, 0x84, 0x70, 0x27, + 0x7E, 0x5C, 0x47, 0xE2, 0xED, 0x90, 0xEF, 0x95, + 0xCC, 0x8A, 0xEF, 0x75, 0x69, 0xB1, 0x3E, 0xFC + }, + { + 0x54, 0x7B, 0xC8, 0x27, 0x3F, 0x32, 0x4E, 0xAC, + 0xC8, 0xD0, 0x75, 0x43, 0x60, 0x4B, 0xC3, 0xF4, + 0x06, 0x80, 0xDA, 0x91, 0x64, 0xD8, 0x49, 0x67, + 0x1A, 0x74, 0x41, 0xD9, 0x8B, 0xD0, 0x2E, 0xA1 + }, + { + 0x53, 0x63, 0xFC, 0x77, 0x13, 0x41, 0x06, 0xCB, + 0xE3, 0x46, 0x94, 0xDC, 0xF5, 0x76, 0x7A, 0x14, + 0xE0, 0x03, 0x42, 0xBD, 0x39, 0x93, 0xDC, 0x1E, + 0x9E, 0xE5, 0xEC, 0x4C, 0x67, 0x2B, 0xA6, 0xA6 + }, + { + 0x10, 0x0F, 0x8F, 0xA0, 0xBC, 0xAC, 0x83, 0xDB, + 0x3B, 0x34, 0xFD, 0xCD, 0x66, 0x58, 0xD2, 0x1A, + 0x2D, 0xA7, 0xC4, 0x8B, 0x24, 0x3F, 0x79, 0x4F, + 0xAB, 0xBF, 0x46, 0xDE, 0x1A, 0xBB, 0x3E, 0xA7 + }, + { + 0x17, 0xA3, 0x68, 0x0D, 0xC1, 0xF5, 0xE6, 0x3F, + 0x1B, 0x85, 0x50, 0xD9, 0xA2, 0x2D, 0x91, 0xD2, + 0xDB, 0xB1, 0x5B, 0x61, 0xE5, 0xA7, 0x8F, 0x74, + 0x2A, 0xB5, 0xA0, 0x47, 0x14, 0x7C, 0x26, 0x8C + }, + { + 0x45, 0x07, 0x70, 0x42, 0xE2, 0xDD, 0x20, 0x57, + 0x0F, 0x13, 0x26, 0x0E, 0x14, 0xE0, 0x7F, 0xD1, + 0xD1, 0x62, 0x04, 0xD5, 0xEC, 0x3B, 0x0F, 0x4A, + 0xE0, 0xC3, 0xF9, 0x5C, 0xBD, 0xD4, 0xDD, 0x8A + }, + { + 0x4B, 0xCA, 0xD7, 0x11, 0x58, 0x68, 0xEB, 0x58, + 0xBA, 0x54, 0x55, 0xC4, 0x4D, 0x98, 0x48, 0xF5, + 0xB1, 0x9E, 0x9F, 0x22, 0x2C, 0x22, 0x87, 0xC0, + 0x53, 0x94, 0xC5, 0x2B, 0x98, 0xE7, 0xFA, 0x74 + }, + { + 0xE4, 0x1E, 0xF0, 0x8F, 0x63, 0x05, 0xE2, 0x85, + 0x09, 0x10, 0x84, 0x9E, 0x2B, 0xB6, 0x87, 0x2B, + 0x12, 0x6C, 0x1E, 0x24, 0x64, 0x01, 0x68, 0x77, + 0x3A, 0x14, 0xF6, 0xDA, 0x7E, 0x59, 0xB4, 0x83 + }, + { + 0x77, 0x60, 0xC0, 0x65, 0x97, 0x36, 0x8F, 0x98, + 0x18, 0x92, 0xA2, 0x93, 0x7D, 0xB5, 0xBF, 0xB7, + 0x91, 0xEF, 0xD8, 0x89, 0xA3, 0x35, 0xAE, 0x78, + 0xB7, 0x31, 0x23, 0xF3, 0x1A, 0x4F, 0xE4, 0xA5 + }, + { + 0x9E, 0x36, 0xBF, 0x7B, 0xA8, 0xF2, 0x70, 0x52, + 0x9B, 0x23, 0x52, 0xA8, 0x9F, 0xEC, 0xBA, 0x01, + 0x7D, 0x5F, 0x54, 0xD1, 0x08, 0x64, 0x8A, 0xAC, + 0xDA, 0xAC, 0x03, 0x2B, 0x73, 0xFF, 0x4D, 0x09 + }, + { + 0xE7, 0xFA, 0x5D, 0x9D, 0x4E, 0x6F, 0xF2, 0xEF, + 0x44, 0x54, 0x7D, 0x66, 0x93, 0xA3, 0x04, 0xC0, + 0xDA, 0x54, 0x7D, 0x04, 0xFE, 0x18, 0x1B, 0xA3, + 0xC4, 0xA1, 0x6E, 0x68, 0xBF, 0x3C, 0x58, 0x8D + }, + { + 0x94, 0xCF, 0x4E, 0x9E, 0xD1, 0xFC, 0x2B, 0x69, + 0x19, 0xA0, 0xC3, 0xF8, 0xC6, 0x9A, 0xDA, 0x7E, + 0x70, 0x6C, 0x05, 0xEC, 0xC7, 0xB0, 0x68, 0xEA, + 0xBA, 0xCB, 0xC2, 0xBB, 0x94, 0x1F, 0xB5, 0x28 + }, + { + 0x1A, 0xF3, 0x2C, 0xC2, 0x06, 0x54, 0xD5, 0x81, + 0xD0, 0xD3, 0x4F, 0x68, 0x16, 0x19, 0x44, 0x21, + 0x0A, 0x46, 0x25, 0x42, 0xC5, 0xC3, 0xDF, 0xF3, + 0xD8, 0xF7, 0xD0, 0x91, 0x20, 0x1B, 0x64, 0x8D + }, + { + 0xBF, 0x05, 0x1C, 0xA9, 0x56, 0x05, 0xF1, 0xEA, + 0xDC, 0x9F, 0x28, 0x7F, 0x35, 0x00, 0x4F, 0xEF, + 0xDE, 0x69, 0xEB, 0xCB, 0x46, 0x72, 0x6F, 0x19, + 0x68, 0x9E, 0x31, 0x0C, 0xCB, 0xE5, 0xC0, 0xF4 + }, + { + 0xFB, 0xCA, 0x5B, 0xB2, 0x7E, 0xAF, 0x3C, 0x6E, + 0x30, 0x41, 0x49, 0xDF, 0x2B, 0x3D, 0x25, 0x65, + 0x15, 0xF2, 0x31, 0x45, 0x80, 0xC4, 0x37, 0xED, + 0xBF, 0xDF, 0x64, 0xBA, 0x26, 0x0E, 0xAC, 0x57 + }, + { + 0x3B, 0xE3, 0xA7, 0xD9, 0x72, 0xB1, 0x63, 0x2D, + 0x31, 0x6F, 0xA9, 0x4D, 0x4C, 0xB4, 0x5D, 0xDD, + 0xCB, 0x6D, 0x56, 0x78, 0x3E, 0x2D, 0xF8, 0x9E, + 0x2B, 0x35, 0x0E, 0x66, 0xE1, 0x5A, 0xD9, 0x7D + }, + { + 0x04, 0x7E, 0x75, 0x05, 0xC3, 0x08, 0x2E, 0x6D, + 0xEF, 0xBB, 0x55, 0x10, 0xC2, 0x89, 0xFF, 0x25, + 0x5D, 0x94, 0xF5, 0xD3, 0x47, 0xC7, 0xBD, 0x5E, + 0x3F, 0x36, 0x9F, 0x4F, 0x9B, 0x04, 0xD4, 0x73 + }, + { + 0x6F, 0x89, 0x8B, 0x3B, 0xEE, 0x49, 0xC3, 0x36, + 0x75, 0x9F, 0xD5, 0xD7, 0xA9, 0x01, 0xFE, 0x01, + 0xE1, 0x1E, 0xAD, 0x8B, 0x19, 0xD8, 0x2D, 0x8F, + 0xC2, 0x6E, 0xD6, 0x8E, 0x2C, 0xAF, 0xC4, 0x67 + }, + { + 0x09, 0x44, 0x51, 0x0A, 0xDC, 0x53, 0xEA, 0xDE, + 0xB4, 0x78, 0x14, 0x2E, 0x6B, 0x4F, 0x61, 0x6C, + 0xA8, 0x0C, 0x96, 0x5D, 0x34, 0x28, 0xEF, 0x81, + 0xC2, 0xF1, 0xFE, 0x26, 0xD1, 0xCE, 0xA5, 0xC0 + }, + { + 0xB9, 0x69, 0xBB, 0xB3, 0x3B, 0x16, 0x79, 0x14, + 0x01, 0xCB, 0x05, 0x36, 0x15, 0x49, 0x29, 0x46, + 0x40, 0xC5, 0x1A, 0x5D, 0xF7, 0x5B, 0x7C, 0x1D, + 0x97, 0x87, 0x39, 0x78, 0x39, 0x46, 0xF9, 0xB1 + }, + { + 0x42, 0x30, 0x90, 0x93, 0x23, 0x0B, 0xA4, 0x22, + 0x97, 0xEA, 0xB2, 0x99, 0x0E, 0x1C, 0x00, 0x13, + 0x6D, 0x44, 0xB2, 0xC1, 0x54, 0xC9, 0x04, 0xE8, + 0xA3, 0xDD, 0x8A, 0x2D, 0xB5, 0x2F, 0x38, 0x94 + }, + { + 0x16, 0xF2, 0x0D, 0xBF, 0xB8, 0x7A, 0x3B, 0xD3, + 0xE5, 0x93, 0xFF, 0xA6, 0xEB, 0xC5, 0xE6, 0x9D, + 0xA3, 0xD6, 0x51, 0x2D, 0x45, 0x10, 0xBA, 0x1F, + 0x78, 0x7E, 0x8B, 0x26, 0x60, 0x87, 0xB4, 0x57 + }, + { + 0x57, 0xD2, 0xF0, 0xD9, 0x17, 0xEF, 0x22, 0xC0, + 0xB6, 0xF5, 0xD0, 0xBE, 0xEF, 0xC8, 0x7F, 0xDC, + 0x83, 0x97, 0x0C, 0xBF, 0x86, 0x58, 0x0E, 0xAA, + 0x16, 0x6E, 0x1F, 0x1D, 0x8C, 0xB0, 0x76, 0xFE + }, + { + 0x7C, 0xD2, 0x2B, 0x59, 0x43, 0x5F, 0x32, 0x60, + 0xC2, 0x18, 0x14, 0x36, 0x4B, 0xCC, 0xE6, 0x27, + 0x69, 0x9D, 0x35, 0x66, 0x1E, 0x69, 0x3F, 0xEA, + 0x43, 0x41, 0xC8, 0x53, 0xA2, 0xC6, 0xB1, 0x23 + }, + { + 0xCD, 0xD0, 0x5C, 0x3D, 0xFB, 0x49, 0x68, 0xD7, + 0x67, 0x31, 0xAF, 0x09, 0xB1, 0xB9, 0x77, 0xB3, + 0x3F, 0xE0, 0x91, 0x0B, 0x0E, 0xD8, 0x86, 0x7C, + 0x1F, 0x7F, 0xB0, 0xC3, 0xC5, 0xF6, 0x4F, 0x63 + }, + { + 0x56, 0x58, 0xAA, 0x1C, 0xA1, 0x13, 0xE8, 0xEE, + 0x47, 0x74, 0xAD, 0x73, 0x92, 0x29, 0xDF, 0x0F, + 0x0C, 0xBC, 0xA3, 0xD9, 0x48, 0xB5, 0xB4, 0x1B, + 0x55, 0x48, 0x8B, 0xC9, 0xAF, 0x3C, 0x5B, 0x6B + }, + { + 0xA3, 0x2E, 0x73, 0x23, 0xAF, 0xDD, 0x21, 0x1B, + 0x7E, 0x6B, 0xEE, 0x6B, 0x64, 0xA1, 0xB2, 0x84, + 0xFF, 0x8C, 0x89, 0x27, 0xE2, 0xA2, 0xEB, 0x9F, + 0xB0, 0x7F, 0xBF, 0x53, 0xBC, 0xC2, 0xAA, 0x23 + }, + { + 0xC8, 0xF9, 0x56, 0x24, 0xA3, 0x4B, 0x48, 0xBF, + 0x48, 0x9F, 0x9B, 0x56, 0x3E, 0x40, 0x1E, 0x26, + 0xF9, 0x93, 0x4F, 0xEE, 0xEC, 0x47, 0x4B, 0x62, + 0xFE, 0x42, 0x7B, 0x87, 0x46, 0x26, 0xB7, 0x4B + }, + { + 0x74, 0x63, 0xE9, 0x74, 0xBD, 0x09, 0xF6, 0x6C, + 0xEE, 0xD2, 0x34, 0x11, 0x3B, 0x09, 0x8F, 0x92, + 0x9F, 0xCD, 0xED, 0xBF, 0xBF, 0x00, 0xE4, 0x3A, + 0xB8, 0x58, 0x8A, 0xDF, 0x59, 0x17, 0x1F, 0x8A + }, + { + 0x34, 0x33, 0x6E, 0x2C, 0xBA, 0xB9, 0x15, 0x94, + 0x20, 0x0A, 0x8A, 0xE5, 0x27, 0x3A, 0x07, 0xA9, + 0x95, 0x44, 0x70, 0x12, 0x46, 0x4D, 0x78, 0x5D, + 0x3A, 0x20, 0xEC, 0x61, 0xE7, 0xD3, 0xD8, 0x6C + }, + { + 0x9A, 0x69, 0xA6, 0xE5, 0x3D, 0x07, 0x75, 0x40, + 0x52, 0x64, 0x2A, 0xAD, 0xA2, 0x00, 0x76, 0x51, + 0xD7, 0x00, 0xD0, 0x43, 0x0C, 0x88, 0x8F, 0xD6, + 0x97, 0x1E, 0x65, 0x9A, 0x6D, 0x9C, 0xEF, 0x94 + }, + { + 0x47, 0xEE, 0x2E, 0xDD, 0xCC, 0xD5, 0x83, 0x33, + 0xD8, 0x93, 0x79, 0xC6, 0xAD, 0x35, 0x6F, 0xD3, + 0x58, 0xB0, 0x77, 0xFA, 0xCA, 0xA0, 0xF9, 0xBD, + 0x63, 0xA9, 0x08, 0x68, 0x81, 0x3B, 0x82, 0xE7 + }, + { + 0xE6, 0x2F, 0x28, 0xD0, 0x32, 0x43, 0x15, 0x1C, + 0xC4, 0x8F, 0x0D, 0xC6, 0x39, 0xDF, 0xEF, 0x75, + 0x87, 0x6A, 0xC7, 0x2A, 0xB5, 0x09, 0x5B, 0x99, + 0xA3, 0x35, 0xB6, 0x78, 0x0E, 0xF7, 0x63, 0x02 + }, + { + 0xAD, 0x30, 0x1C, 0x16, 0x9C, 0x5C, 0x80, 0xBE, + 0x3F, 0xCE, 0xBE, 0x1A, 0x9E, 0xA7, 0x67, 0xC8, + 0xA1, 0x68, 0xA7, 0x82, 0xC1, 0x9A, 0x95, 0xD2, + 0x40, 0x60, 0xE5, 0x16, 0x21, 0x51, 0x73, 0x18 + }, + { + 0xD2, 0x75, 0x16, 0x51, 0x62, 0xAA, 0x1D, 0x7F, + 0xB6, 0x11, 0x7F, 0x0C, 0xEE, 0x0F, 0x1F, 0xE0, + 0xA1, 0x40, 0x08, 0xDC, 0xD3, 0xE3, 0xDE, 0x39, + 0x24, 0xB5, 0xFB, 0xBB, 0xCA, 0xA6, 0x32, 0xEE + }, + { + 0xAF, 0x2A, 0xDC, 0x3F, 0xAB, 0x3D, 0xCD, 0x6C, + 0x15, 0xBF, 0xB5, 0x57, 0x2B, 0x8A, 0xF6, 0x84, + 0xBF, 0xE4, 0x0B, 0xF4, 0x06, 0xB3, 0xD6, 0x4F, + 0xB0, 0xE7, 0x3A, 0x71, 0x64, 0x5F, 0x39, 0x61 + }, + { + 0x89, 0x12, 0x74, 0x32, 0x14, 0xF6, 0x1C, 0xF9, + 0x50, 0xAF, 0x31, 0xD2, 0x9E, 0x43, 0x3D, 0x9B, + 0x7E, 0x45, 0x1D, 0x00, 0x0C, 0xE2, 0x2B, 0xA7, + 0x57, 0x44, 0xD0, 0x56, 0x4F, 0xB9, 0x5C, 0xAC + }, + { + 0xA5, 0x5E, 0x30, 0x15, 0xCE, 0xF7, 0x2F, 0xBA, + 0x56, 0xF9, 0x29, 0x61, 0xD1, 0x78, 0x16, 0xAE, + 0xB5, 0x65, 0xFE, 0x22, 0x2F, 0xB2, 0x11, 0x86, + 0x43, 0x46, 0x52, 0x99, 0x4F, 0xF6, 0x23, 0x24 + }, + { + 0x71, 0x18, 0x0F, 0x96, 0x2F, 0xBA, 0x33, 0x72, + 0x54, 0x01, 0x11, 0xF2, 0x0E, 0x7A, 0x05, 0x0B, + 0x36, 0x71, 0xDF, 0xA5, 0x36, 0xE8, 0xC6, 0x7C, + 0xA3, 0x7B, 0x71, 0x33, 0x08, 0xEA, 0x77, 0x5B + }, + { + 0x4B, 0x38, 0x12, 0xE7, 0x18, 0xEA, 0xA9, 0xA9, + 0x90, 0x79, 0x45, 0x28, 0x5C, 0xFF, 0x84, 0xF2, + 0x37, 0x28, 0x5F, 0x25, 0xDC, 0x3D, 0xD2, 0xCB, + 0xA8, 0xE0, 0x14, 0x9A, 0xC1, 0x27, 0xEE, 0x04 + }, + { + 0x21, 0xA5, 0x0E, 0x26, 0x74, 0xEC, 0x4F, 0x88, + 0xCD, 0x2C, 0xD0, 0x1E, 0xD3, 0x3D, 0x34, 0xA4, + 0xD9, 0x8A, 0x7A, 0x9C, 0x87, 0x79, 0x32, 0xC1, + 0xEF, 0x2E, 0xD2, 0x3E, 0x25, 0x0E, 0xF4, 0xEE + }, + { + 0x01, 0xF2, 0x8B, 0x3E, 0xBB, 0xBA, 0x40, 0x5E, + 0xB5, 0xB3, 0xD2, 0x01, 0x23, 0x9F, 0xDF, 0xE3, + 0x54, 0xEA, 0xCF, 0xDE, 0x06, 0xB2, 0xB0, 0xA1, + 0x3A, 0xC0, 0xEB, 0x17, 0x2C, 0x98, 0x8F, 0x15 + }, + { + 0xC6, 0x6B, 0xF8, 0x1E, 0xC5, 0x13, 0x0B, 0x69, + 0x31, 0x1E, 0x2E, 0x8B, 0xBF, 0xB7, 0x68, 0x3F, + 0x05, 0xF5, 0x86, 0x55, 0xD3, 0x9F, 0xD0, 0x5B, + 0xEC, 0x76, 0x79, 0x4D, 0x04, 0xFD, 0x44, 0xBC + }, + { + 0x7E, 0x4D, 0xFA, 0xDD, 0x77, 0x8F, 0x59, 0x0B, + 0x04, 0xDE, 0xA9, 0xB4, 0xCA, 0x0C, 0x00, 0x70, + 0x9D, 0x79, 0xFF, 0x1E, 0x1A, 0xF0, 0xB2, 0xA3, + 0x65, 0xB3, 0x91, 0x7B, 0x96, 0x14, 0x01, 0xA3 + }, + { + 0x29, 0x71, 0xBA, 0xE7, 0x68, 0x32, 0xAA, 0xF6, + 0xFB, 0x64, 0xEB, 0xA7, 0x4D, 0x8E, 0xB9, 0x19, + 0x3B, 0xCD, 0xDF, 0xF0, 0xCF, 0x70, 0x65, 0x80, + 0x68, 0xA6, 0x75, 0x04, 0x07, 0xA0, 0xC8, 0x8E + }, + { + 0x3C, 0x27, 0x69, 0xAD, 0xF4, 0x5D, 0x89, 0x5A, + 0x03, 0x48, 0x1F, 0x99, 0x90, 0xEB, 0xEB, 0x5B, + 0x48, 0x83, 0x36, 0x99, 0xED, 0x1C, 0x55, 0xBB, + 0x10, 0xEC, 0x3C, 0x39, 0x67, 0x5A, 0x66, 0x1D + }, + { + 0x44, 0x4A, 0x6A, 0xF4, 0x77, 0xFB, 0x4E, 0x18, + 0xD1, 0x28, 0x8B, 0xC0, 0x7A, 0xC7, 0x34, 0x7D, + 0xB9, 0xA7, 0x50, 0xDA, 0x8F, 0x5B, 0x66, 0x5A, + 0xF3, 0x7E, 0xDD, 0x9D, 0x7B, 0x8C, 0xD7, 0x67 + }, + { + 0x09, 0xAD, 0x34, 0x09, 0x09, 0x34, 0x60, 0x5F, + 0xBF, 0xA2, 0xD0, 0x77, 0xA9, 0x4A, 0x80, 0x49, + 0x0D, 0xA3, 0x2F, 0x43, 0x03, 0x4B, 0x9C, 0x88, + 0x3E, 0xC3, 0xC9, 0x46, 0xFB, 0x82, 0x14, 0xC3 + }, + { + 0x94, 0xA8, 0xC5, 0x9D, 0x96, 0x42, 0x7D, 0xB1, + 0x5E, 0xAC, 0x9C, 0xE7, 0x86, 0x5F, 0x07, 0x62, + 0x6C, 0x7D, 0x10, 0xD6, 0x47, 0xD3, 0xA4, 0xF7, + 0x7D, 0xD4, 0x31, 0x6E, 0x73, 0xCC, 0x88, 0x29 + }, + { + 0xC3, 0xF2, 0x36, 0xCD, 0x15, 0xD6, 0x18, 0x43, + 0x24, 0xE4, 0xB3, 0x38, 0xDC, 0xC3, 0xEC, 0x7F, + 0x51, 0x9E, 0x2B, 0xC4, 0x64, 0xAE, 0x89, 0x61, + 0xB3, 0x64, 0x3B, 0x5A, 0xBC, 0x7C, 0x72, 0x68 + }, + { + 0x5E, 0xBA, 0xDD, 0x96, 0x95, 0x1A, 0x28, 0x70, + 0xF0, 0x82, 0x1C, 0x29, 0x22, 0xEA, 0xC5, 0x18, + 0x30, 0x90, 0x40, 0x07, 0x2E, 0xF3, 0xB3, 0x45, + 0x7F, 0x8D, 0xEF, 0x84, 0x21, 0xB9, 0x10, 0xD6 + }, + { + 0xD2, 0x73, 0x37, 0xC2, 0xBC, 0x9D, 0x32, 0x0F, + 0x84, 0x35, 0xE6, 0xBE, 0x6C, 0x2C, 0xE2, 0x50, + 0x61, 0xEC, 0x62, 0xE7, 0x9D, 0x2A, 0x65, 0x5C, + 0x56, 0x4E, 0xFA, 0xFF, 0x24, 0x98, 0x0B, 0x90 + }, + { + 0x42, 0x9A, 0x79, 0xE6, 0x98, 0x96, 0x7C, 0x70, + 0x9A, 0x6B, 0xC6, 0xB9, 0xB4, 0x82, 0xB5, 0xBC, + 0x9F, 0xB9, 0x04, 0x29, 0x0A, 0x5E, 0xBD, 0xA0, + 0x9E, 0x4F, 0x41, 0x15, 0xD6, 0x0D, 0xF1, 0x04 + }, + { + 0x8E, 0xD3, 0xBC, 0x87, 0x3D, 0xFD, 0x09, 0xE8, + 0xB0, 0x3F, 0x31, 0x44, 0x33, 0x38, 0x66, 0x0B, + 0x95, 0x95, 0xB9, 0xB4, 0xC6, 0x8B, 0x7C, 0x95, + 0xE0, 0x75, 0xD6, 0xC9, 0x20, 0x77, 0xE5, 0x4F + }, + { + 0xAC, 0x70, 0x90, 0xDB, 0x89, 0x84, 0xC3, 0x64, + 0x87, 0x90, 0x78, 0xD0, 0x99, 0x34, 0x4F, 0xBA, + 0x73, 0x04, 0xFD, 0x4F, 0x4F, 0x66, 0x15, 0x5A, + 0x1D, 0x5D, 0x59, 0x39, 0x7A, 0xEC, 0x2E, 0x5B + }, + { + 0xC7, 0x20, 0xDD, 0x42, 0xB5, 0x12, 0xF6, 0x7F, + 0x9A, 0x47, 0x66, 0x54, 0x4F, 0xB1, 0x40, 0x9D, + 0xD0, 0x1F, 0x7A, 0x69, 0x5E, 0xF8, 0xD0, 0x33, + 0x60, 0xA4, 0x04, 0xB1, 0xCD, 0x12, 0xE7, 0xDF + }, + { + 0x89, 0xFB, 0xDE, 0x70, 0x57, 0xE9, 0x13, 0xEA, + 0xC2, 0xFF, 0x1B, 0x70, 0x21, 0xDD, 0x17, 0x42, + 0x1A, 0x8F, 0x07, 0xD0, 0x06, 0xE3, 0x89, 0x6E, + 0xC1, 0xEA, 0xEB, 0xBF, 0x88, 0xCE, 0xEB, 0xE7 + }, + { + 0xB9, 0x9F, 0x47, 0x1D, 0xC0, 0x62, 0xBF, 0xB6, + 0x13, 0x82, 0xB5, 0xFF, 0x3E, 0xFD, 0xD1, 0x21, + 0x2E, 0x02, 0xF6, 0xC5, 0xAF, 0x0C, 0xCB, 0xA3, + 0x28, 0xEB, 0xE0, 0xBA, 0x29, 0x21, 0x27, 0xE4 + }, + { + 0xE9, 0x98, 0xC7, 0x29, 0x34, 0xFE, 0x6F, 0x55, + 0x41, 0xF2, 0x28, 0x37, 0x9B, 0xA3, 0x73, 0x1B, + 0x6D, 0xEA, 0x2D, 0xC5, 0xD1, 0x43, 0x8F, 0x36, + 0x7D, 0x05, 0x40, 0xE3, 0x26, 0x02, 0x78, 0x7A + }, + { + 0xBD, 0x59, 0xAE, 0x72, 0x6D, 0x14, 0x89, 0xAF, + 0x83, 0x6D, 0xA2, 0xAD, 0xD0, 0x36, 0x0E, 0x07, + 0x71, 0x59, 0x8C, 0x2F, 0xA7, 0x86, 0xC4, 0xF6, + 0x5A, 0xE4, 0x87, 0x75, 0x64, 0x43, 0x3A, 0x7F + }, + { + 0xBC, 0xBD, 0x87, 0xA0, 0x50, 0x95, 0xC9, 0xB0, + 0x70, 0xF5, 0x6F, 0xCB, 0x6D, 0xE6, 0xDB, 0x04, + 0x00, 0x93, 0xF6, 0x58, 0xE1, 0xFD, 0x90, 0xDC, + 0x5B, 0xC8, 0x6B, 0x4A, 0x2E, 0xE4, 0xA2, 0xFC + }, + { + 0x48, 0x1D, 0x2D, 0xFE, 0x5A, 0x56, 0x50, 0xF6, + 0x26, 0x53, 0xF9, 0x03, 0x90, 0xD5, 0x4C, 0xEC, + 0x83, 0x7E, 0x1C, 0x41, 0x6C, 0x03, 0xC7, 0x65, + 0x03, 0x5E, 0x4D, 0x9F, 0x5C, 0xAF, 0xF2, 0xB7 + }, + { + 0xE3, 0x90, 0xBB, 0xED, 0x91, 0x28, 0xEA, 0x79, + 0x76, 0xBF, 0x98, 0x6F, 0xC0, 0x81, 0x82, 0xE6, + 0xCB, 0xAA, 0x2B, 0xC0, 0x81, 0x92, 0x6C, 0x43, + 0x46, 0x53, 0x4D, 0x6E, 0x26, 0xFB, 0x89, 0xED + }, + { + 0x04, 0x37, 0x51, 0x08, 0x58, 0xE5, 0x5C, 0x54, + 0xD6, 0x5D, 0x88, 0xCC, 0x16, 0x6F, 0xDE, 0x13, + 0x7A, 0xB4, 0xB5, 0x93, 0x55, 0xC2, 0xF9, 0x7D, + 0x34, 0xB8, 0x63, 0x3E, 0x2A, 0xD2, 0x83, 0x45 + }, + { + 0x69, 0x2B, 0xE8, 0xF2, 0xD8, 0x8B, 0x3B, 0x01, + 0xFF, 0x8E, 0xA9, 0x59, 0x12, 0x42, 0x41, 0x31, + 0x98, 0x33, 0x60, 0x33, 0x2D, 0x76, 0xE0, 0xD4, + 0x5A, 0xF4, 0x5F, 0x58, 0xCD, 0xDC, 0x90, 0xE9 + }, + { + 0x52, 0xB4, 0xDD, 0x7B, 0x0D, 0x08, 0x15, 0x15, + 0xB2, 0x82, 0x6B, 0xF3, 0xA0, 0xB3, 0x45, 0x40, + 0x39, 0xFD, 0x4D, 0xC3, 0x22, 0xDD, 0xB6, 0xC1, + 0x07, 0x47, 0x0A, 0xCA, 0x47, 0x8A, 0x60, 0xAA + }, + { + 0x1E, 0xA3, 0xA4, 0x9B, 0xBF, 0x3C, 0x35, 0x95, + 0x1C, 0x6F, 0x09, 0x1C, 0xC6, 0xC6, 0x7C, 0x52, + 0x6F, 0xB8, 0x68, 0x39, 0xF8, 0x3B, 0xB1, 0x1C, + 0xBE, 0x0F, 0x3A, 0xE4, 0xFC, 0x80, 0x9F, 0xDD + }, + { + 0xF7, 0xB8, 0x18, 0xD6, 0xE0, 0x8D, 0x48, 0x84, + 0x81, 0x4F, 0xC9, 0xF8, 0x2F, 0x5E, 0xC8, 0xBD, + 0xFB, 0x41, 0x28, 0xE3, 0x9B, 0x74, 0x08, 0xB2, + 0x88, 0x3F, 0xC8, 0xB7, 0x1C, 0x39, 0xE4, 0x2E + }, + { + 0xB4, 0xCB, 0x4D, 0xD5, 0xE9, 0x06, 0xC2, 0xB2, + 0x5E, 0x57, 0x8F, 0x6F, 0xD5, 0x05, 0xB3, 0xE7, + 0xF2, 0xDB, 0xDE, 0x6F, 0xA0, 0x8E, 0x75, 0xCB, + 0xD0, 0x70, 0x34, 0x60, 0xDE, 0x1D, 0x8A, 0xC2 + }, + { + 0x5F, 0x5F, 0xD4, 0x2A, 0x30, 0xFA, 0x82, 0x0F, + 0x6B, 0xC2, 0x17, 0x54, 0x99, 0x26, 0x1A, 0xC1, + 0xB5, 0x1D, 0x24, 0x90, 0xCB, 0xAA, 0x5F, 0xFC, + 0xB6, 0xCC, 0x53, 0xE3, 0x37, 0x67, 0xFC, 0x14 + }, + { + 0xD2, 0x76, 0xB4, 0x1A, 0x39, 0x60, 0xEB, 0x4B, + 0x70, 0x37, 0xA3, 0x86, 0xB4, 0xFC, 0xFD, 0x12, + 0xBD, 0x6D, 0x29, 0xC0, 0x43, 0x7E, 0x10, 0xE6, + 0x80, 0x8C, 0xB9, 0xE8, 0x2A, 0x1F, 0x4D, 0xDF + }, + { + 0x6A, 0xEC, 0xD1, 0xF6, 0x22, 0xA6, 0xFC, 0x75, + 0xA9, 0xAA, 0x66, 0x04, 0x79, 0xC4, 0xFA, 0x5E, + 0x13, 0x3E, 0x00, 0x2C, 0xA5, 0x0E, 0x4D, 0x2E, + 0x94, 0x41, 0xF4, 0xB8, 0xC9, 0x71, 0x3B, 0x77 + }, + { + 0x6C, 0xB2, 0x4E, 0x1E, 0x40, 0xDD, 0xFB, 0x8F, + 0x62, 0x22, 0x2D, 0x73, 0x03, 0xD6, 0xD5, 0x71, + 0x11, 0x37, 0xF8, 0x63, 0xF4, 0x8C, 0xCF, 0x56, + 0xBF, 0x7A, 0xD0, 0x11, 0x4A, 0xCD, 0xE7, 0x0F + }, + { + 0xAB, 0x64, 0xA3, 0x95, 0xFD, 0x25, 0x03, 0xF5, + 0xD4, 0x7B, 0x75, 0x52, 0x4C, 0x45, 0x8D, 0xA1, + 0x70, 0x4E, 0xEB, 0x9E, 0x79, 0x59, 0x5F, 0x08, + 0x7A, 0x35, 0xF2, 0xD7, 0xAC, 0xB9, 0x64, 0x57 + }, + { + 0xE0, 0x86, 0xDF, 0x44, 0xB0, 0x7E, 0xF2, 0xD3, + 0x1A, 0x72, 0xB7, 0x84, 0x46, 0x08, 0xC3, 0x41, + 0xC6, 0xBE, 0xCE, 0xAC, 0x50, 0xF2, 0x05, 0x1D, + 0x1C, 0x60, 0x4F, 0xD9, 0x6D, 0xB3, 0x9F, 0xC4 + }, + { + 0xB0, 0x11, 0x4E, 0x4F, 0x45, 0x57, 0xEB, 0x93, + 0xEE, 0xF0, 0xDE, 0xC4, 0x9A, 0x0C, 0x67, 0x42, + 0x34, 0x46, 0x29, 0x2B, 0x86, 0xFE, 0x1E, 0x69, + 0xC9, 0x5C, 0xD1, 0x4C, 0x72, 0x92, 0x8E, 0x03 + }, + { + 0x3B, 0x01, 0xBE, 0x1E, 0xA0, 0x02, 0x9B, 0xC9, + 0x1D, 0x08, 0x54, 0xAB, 0x1E, 0xBB, 0x87, 0x4D, + 0xA4, 0xA4, 0xD7, 0x29, 0x08, 0xC1, 0x32, 0xBA, + 0x3F, 0xBE, 0xEF, 0x3A, 0xE3, 0x3B, 0x9A, 0x6E + }, + { + 0x92, 0x7B, 0x65, 0xDF, 0x8F, 0xE4, 0xFC, 0xBD, + 0xDF, 0xAF, 0x6E, 0xCF, 0x74, 0x6A, 0x1B, 0x68, + 0x05, 0xFE, 0x05, 0x78, 0x02, 0x12, 0x5D, 0xC5, + 0x27, 0x13, 0xE6, 0x99, 0xD1, 0x6B, 0xF8, 0x6A + }, + { + 0x49, 0x30, 0x6C, 0x30, 0xC5, 0xEC, 0x9A, 0x02, + 0xD1, 0xA9, 0x51, 0x37, 0x9C, 0x89, 0xC6, 0x73, + 0xB3, 0x56, 0x00, 0x8C, 0x95, 0x09, 0x4D, 0xBB, + 0x3F, 0xAB, 0x47, 0x55, 0x2F, 0x84, 0x76, 0xDF + }, + { + 0x65, 0xA2, 0xC5, 0x9F, 0xC6, 0x69, 0x11, 0xB7, + 0x09, 0x86, 0x55, 0xDA, 0x10, 0xE7, 0xB6, 0x63, + 0xBE, 0x32, 0xD1, 0x42, 0x8D, 0x05, 0xA1, 0xC1, + 0x5B, 0x0D, 0x80, 0x5A, 0x45, 0x23, 0xC6, 0x17 + }, + { + 0x61, 0x70, 0xE6, 0x08, 0x3C, 0x7C, 0x48, 0x18, + 0x7D, 0x0A, 0x9B, 0x63, 0x97, 0x88, 0xA4, 0x97, + 0x4B, 0x7D, 0xAA, 0xA6, 0xBD, 0xD3, 0x5E, 0x86, + 0x53, 0x77, 0xF0, 0xE4, 0xCD, 0xC0, 0xE9, 0x06 + }, + { + 0xFF, 0x40, 0xAA, 0xA0, 0xD4, 0x7D, 0x94, 0xDE, + 0xCB, 0xD8, 0x72, 0x3E, 0x79, 0xA9, 0xC2, 0x45, + 0xFC, 0xF1, 0x89, 0xD9, 0x9B, 0x84, 0x0F, 0x7E, + 0xC0, 0x19, 0x6C, 0x61, 0x88, 0x85, 0x1F, 0x15 + }, + { + 0x68, 0x69, 0x25, 0xFF, 0xA0, 0x8F, 0x86, 0x5A, + 0x47, 0x25, 0x55, 0xF4, 0xA8, 0xEB, 0x0C, 0x64, + 0x9A, 0x11, 0x28, 0xC2, 0x20, 0x0A, 0x93, 0x73, + 0x5A, 0x45, 0x08, 0x26, 0xCA, 0x8D, 0x5D, 0x4C + }, + { + 0xDB, 0x05, 0x84, 0x6C, 0xB5, 0xA3, 0xEC, 0x49, + 0x2A, 0xD1, 0xED, 0x17, 0x62, 0x8C, 0x78, 0x1D, + 0xE7, 0xD4, 0x48, 0x2E, 0x73, 0x0B, 0xA5, 0x15, + 0xCD, 0x51, 0xC9, 0xD9, 0x85, 0x15, 0x1B, 0x5A + }, + { + 0x96, 0x81, 0xFC, 0x29, 0x74, 0x8D, 0x92, 0x80, + 0xBE, 0x14, 0x62, 0x4C, 0xC7, 0xA6, 0xF6, 0x26, + 0x8A, 0x2B, 0xBF, 0x83, 0x6C, 0x76, 0xA2, 0x83, + 0x67, 0xE8, 0x8A, 0xC1, 0x96, 0x17, 0xEB, 0xC5 + }, + { + 0x98, 0x9A, 0xFE, 0x47, 0x6A, 0x7F, 0xDB, 0x31, + 0x58, 0xEA, 0xE6, 0x60, 0xD8, 0x1E, 0x4F, 0xAE, + 0xF2, 0x3D, 0xBC, 0x68, 0xA7, 0x71, 0x1B, 0x15, + 0xF1, 0x44, 0x9D, 0xCA, 0x66, 0x22, 0x64, 0xBF + }, + { + 0x11, 0x54, 0x28, 0x85, 0xFA, 0xC2, 0x1D, 0x29, + 0xBD, 0x53, 0x52, 0x72, 0x71, 0x82, 0x73, 0x05, + 0x17, 0xAD, 0x5C, 0x49, 0x26, 0xBF, 0xED, 0x24, + 0x7F, 0xDB, 0x18, 0xA0, 0xE1, 0xE4, 0xA0, 0x75 + }, + { + 0x61, 0x14, 0x36, 0x6C, 0xC5, 0x05, 0x3B, 0x35, + 0xAA, 0x2A, 0xC2, 0xEF, 0xEC, 0x6D, 0x8A, 0xE4, + 0x23, 0x58, 0x4B, 0x23, 0xFB, 0xA1, 0x76, 0x92, + 0x56, 0x48, 0xCD, 0xBC, 0xF8, 0x8C, 0x64, 0xB6 + }, + { + 0x25, 0x92, 0x6C, 0x9F, 0x27, 0xE2, 0x2B, 0x59, + 0x62, 0xBE, 0x56, 0x1B, 0x31, 0x18, 0xA4, 0xA4, + 0x03, 0x4D, 0x22, 0xEC, 0x6A, 0x90, 0xD7, 0xC5, + 0x58, 0xBD, 0xC9, 0x39, 0xE0, 0xD0, 0x7E, 0xE6 + }, + { + 0x06, 0xA7, 0xB5, 0xEF, 0xB9, 0x5F, 0x80, 0xDE, + 0x20, 0x44, 0xAB, 0x71, 0xB1, 0xF9, 0x96, 0x6A, + 0xB7, 0x3F, 0xD3, 0x7A, 0xA0, 0x36, 0x54, 0x79, + 0xD1, 0xD4, 0xE4, 0xE3, 0xDC, 0x2D, 0xC9, 0x7B + }, + { + 0x40, 0xE0, 0xC6, 0x67, 0x2D, 0xE2, 0x10, 0x38, + 0x0E, 0x6E, 0x68, 0xF4, 0x87, 0x8D, 0xED, 0x02, + 0xA5, 0x1C, 0xCB, 0xD9, 0xEB, 0x7A, 0x14, 0x21, + 0x57, 0xCF, 0x61, 0x80, 0xD4, 0x82, 0x21, 0xCC + }, + { + 0x03, 0x7E, 0x0C, 0x64, 0x87, 0x0F, 0x93, 0x2B, + 0xFA, 0x17, 0x7E, 0x08, 0xBE, 0x52, 0xA2, 0xA6, + 0x27, 0xE7, 0x49, 0x40, 0xE9, 0x00, 0xEC, 0xF6, + 0x26, 0xED, 0x63, 0x68, 0x0B, 0xA7, 0x90, 0xF6 + }, + { + 0xE7, 0xB5, 0x74, 0x14, 0xCF, 0x66, 0x7D, 0x76, + 0x80, 0x8C, 0x1E, 0x9B, 0xF1, 0xFF, 0xDF, 0x54, + 0x1B, 0xEC, 0x5E, 0xFD, 0xE1, 0xF6, 0x31, 0x46, + 0xF6, 0x30, 0xE2, 0x8D, 0xE9, 0xF1, 0x5F, 0x0C + }, + { + 0xC0, 0xA6, 0xAF, 0x35, 0xFD, 0x5E, 0x4D, 0x54, + 0x3B, 0xFB, 0x83, 0x34, 0x4D, 0x4C, 0x80, 0xC2, + 0x47, 0x7E, 0x0B, 0xFC, 0x86, 0xD1, 0x0B, 0xAD, + 0xB9, 0x0D, 0x20, 0xD7, 0x58, 0x3B, 0x32, 0xB7 + }, + { + 0x88, 0x9E, 0xD3, 0xE0, 0x09, 0xA8, 0x79, 0x1D, + 0x0F, 0xAE, 0x87, 0x86, 0xFA, 0x79, 0xFD, 0xC0, + 0xB3, 0xEF, 0x4C, 0x81, 0x65, 0x01, 0xCC, 0x2D, + 0x77, 0x78, 0x2A, 0xEE, 0xC7, 0xA6, 0xB9, 0xEF + }, + { + 0xCC, 0xD7, 0x8E, 0x2F, 0x6C, 0x98, 0xB7, 0xF8, + 0x1D, 0xE5, 0x3A, 0xAB, 0xD9, 0x9A, 0x83, 0xAF, + 0xA5, 0x64, 0xC8, 0xE8, 0x6E, 0x22, 0x17, 0xDB, + 0xCF, 0xF4, 0x3F, 0xE9, 0x09, 0xCE, 0xAC, 0xB0 + }, + { + 0x40, 0x39, 0xB6, 0x84, 0xA5, 0x73, 0x24, 0x52, + 0x8D, 0x80, 0x06, 0x20, 0x30, 0xAC, 0xAF, 0x6E, + 0xAB, 0x7D, 0xDF, 0xA8, 0x98, 0xF9, 0xC8, 0x46, + 0x3C, 0xD3, 0xD2, 0x3D, 0x23, 0xC5, 0x70, 0x5C + }, + { + 0x99, 0xCD, 0x27, 0xBC, 0x3E, 0xA8, 0x60, 0x05, + 0xC9, 0xA5, 0x75, 0xD1, 0xE7, 0x90, 0x98, 0x21, + 0x63, 0x53, 0x3D, 0xFF, 0x7D, 0x45, 0x5E, 0x5E, + 0x56, 0xE5, 0x2F, 0x99, 0xAE, 0x12, 0xA6, 0xD5 + }, + { + 0xC7, 0x78, 0x6C, 0x0B, 0x69, 0x3F, 0xA3, 0x56, + 0x08, 0x40, 0x4F, 0x46, 0xD6, 0x98, 0xCC, 0x6D, + 0x41, 0x4C, 0x75, 0x6A, 0x14, 0x16, 0xB4, 0xC4, + 0xC6, 0x37, 0x9C, 0x55, 0x09, 0x18, 0x67, 0x75 + }, + { + 0x76, 0x18, 0x42, 0x91, 0x1F, 0x00, 0x48, 0x2D, + 0x72, 0x05, 0x25, 0x92, 0xDA, 0x17, 0x12, 0x33, + 0x69, 0x7C, 0xBD, 0x77, 0x04, 0x64, 0x58, 0x35, + 0xBE, 0xF7, 0x53, 0x64, 0x65, 0x50, 0x4D, 0x30 + }, + { + 0x2D, 0x38, 0x7E, 0xD6, 0xE9, 0x45, 0x77, 0xB7, + 0xAF, 0x80, 0x72, 0x34, 0xD5, 0xA0, 0x14, 0xFC, + 0x4C, 0xFB, 0x0E, 0x42, 0x09, 0xB3, 0x43, 0x96, + 0x71, 0xC0, 0x9E, 0x75, 0xFA, 0x8B, 0x27, 0x7C + }, + { + 0xCB, 0xCE, 0x16, 0xB2, 0x9B, 0x00, 0xAB, 0xE5, + 0x07, 0x23, 0x02, 0x5D, 0x19, 0x55, 0x64, 0x7C, + 0x75, 0xA7, 0xB9, 0x61, 0xA0, 0x52, 0x65, 0xDD, + 0xE0, 0xE3, 0x0B, 0x2C, 0xA5, 0xF4, 0xF3, 0x91 + }, + { + 0x2C, 0xFC, 0x21, 0xA8, 0xA5, 0xCA, 0x97, 0xC4, + 0xD2, 0x57, 0x16, 0x58, 0xDD, 0xED, 0x21, 0x28, + 0x89, 0x38, 0xB3, 0x7F, 0x79, 0x26, 0x64, 0xE6, + 0x3E, 0xD5, 0x07, 0xA2, 0x42, 0xA2, 0xDE, 0xB9 + }, + { + 0x4D, 0x25, 0xD7, 0x00, 0x5C, 0x2D, 0x24, 0x03, + 0x14, 0xDE, 0x26, 0xE5, 0x50, 0x28, 0xBA, 0x92, + 0x07, 0x48, 0x87, 0x49, 0x84, 0xAA, 0x81, 0x1F, + 0x7F, 0x61, 0x1D, 0xB5, 0x2C, 0x6C, 0x34, 0xA9 + }, + { + 0x6B, 0x01, 0x17, 0x03, 0x08, 0xE0, 0x86, 0x5D, + 0xAB, 0x36, 0x32, 0xBB, 0x0D, 0x57, 0xAF, 0x93, + 0x95, 0x91, 0xD4, 0x02, 0x70, 0xF1, 0x83, 0x50, + 0xF7, 0x95, 0x73, 0x7A, 0x17, 0xF1, 0xE6, 0x8E + }, + { + 0x3F, 0xBA, 0x77, 0x7D, 0x90, 0xE1, 0x4F, 0x23, + 0xCB, 0x18, 0x97, 0xBC, 0xC8, 0x13, 0x9E, 0x62, + 0x4F, 0x76, 0x59, 0x51, 0xBF, 0x29, 0xB1, 0xAE, + 0x3E, 0xFC, 0xC5, 0xD1, 0x6A, 0x32, 0x97, 0x46 + }, + { + 0x28, 0x2B, 0x66, 0xF8, 0xB8, 0x66, 0xD4, 0x18, + 0x4D, 0x81, 0x6D, 0x9F, 0xE0, 0x3E, 0x90, 0x14, + 0x59, 0x0E, 0xDD, 0xD9, 0xC6, 0xAD, 0x91, 0x6F, + 0xD1, 0x07, 0x62, 0x6A, 0xCB, 0xE0, 0x05, 0x4A + }, + { + 0xEA, 0x6D, 0x1B, 0x1B, 0x27, 0x31, 0x69, 0xE3, + 0x03, 0x95, 0x48, 0x9E, 0xA6, 0x50, 0x44, 0x27, + 0xDC, 0x61, 0x7B, 0x72, 0x30, 0xFE, 0x1D, 0xF3, + 0xA7, 0x58, 0x7A, 0x7B, 0x38, 0x43, 0xD6, 0x8E + }, + { + 0x43, 0x0F, 0x0A, 0xE0, 0x1D, 0xF9, 0xAF, 0x9E, + 0xC1, 0xA3, 0xEF, 0xC8, 0x5B, 0xA5, 0x5D, 0x8F, + 0x8A, 0x73, 0x3B, 0x7E, 0x48, 0x3C, 0xF1, 0x88, + 0xAB, 0xFF, 0x68, 0xD9, 0x58, 0xD9, 0xCD, 0xFE + }, + { + 0xF4, 0xD6, 0xA0, 0x09, 0xEB, 0x12, 0x4C, 0x70, + 0x02, 0xE5, 0x2E, 0x87, 0xEA, 0x79, 0xAB, 0xC9, + 0xDE, 0x04, 0x6F, 0xD6, 0x44, 0x1F, 0x26, 0x3F, + 0x23, 0x02, 0x9F, 0x68, 0xC9, 0xCD, 0x65, 0xDC + }, + { + 0x89, 0x31, 0xC8, 0xFC, 0xC2, 0xB1, 0xB5, 0x7D, + 0xAA, 0x3B, 0x46, 0xF5, 0xD6, 0xA9, 0x70, 0x4E, + 0x4F, 0x08, 0x4C, 0x58, 0x2B, 0xF6, 0x46, 0xFC, + 0x28, 0x97, 0x2D, 0x0B, 0x9C, 0x91, 0x2F, 0x3C + }, + { + 0x38, 0x59, 0x10, 0x8E, 0x9E, 0xBC, 0x40, 0x64, + 0x5A, 0x44, 0xD7, 0xEA, 0x51, 0xAC, 0x3C, 0x79, + 0x3C, 0x34, 0x17, 0x5B, 0xD6, 0x01, 0x84, 0x8F, + 0x13, 0x7F, 0x66, 0x3D, 0xC6, 0x8B, 0xD8, 0x4C + }, + { + 0x9B, 0x47, 0xA1, 0x77, 0xAC, 0x5E, 0x04, 0x04, + 0x6C, 0x45, 0xB6, 0xFE, 0xE7, 0x95, 0x2A, 0xBA, + 0x99, 0x90, 0xB5, 0xAA, 0x2E, 0x67, 0xF5, 0xD1, + 0x80, 0x98, 0xC8, 0x4E, 0x33, 0x52, 0x1B, 0x12 + }, + { + 0x4D, 0x5E, 0x69, 0x52, 0x77, 0xA4, 0xCA, 0x52, + 0x43, 0xA6, 0x31, 0x5B, 0x58, 0x5D, 0xAD, 0x82, + 0xBC, 0x7E, 0x11, 0x69, 0x1B, 0xA3, 0x15, 0x64, + 0x35, 0xE5, 0xED, 0x97, 0x0B, 0x0B, 0xE2, 0x46 + }, + { + 0xF2, 0x05, 0x8C, 0x47, 0xE3, 0xF0, 0x01, 0xC9, + 0x61, 0x02, 0xFD, 0x40, 0x96, 0x84, 0xE9, 0x0E, + 0x35, 0x77, 0x9E, 0x21, 0xC2, 0x00, 0x10, 0x59, + 0x98, 0xAA, 0xD5, 0x00, 0x2B, 0xC1, 0x40, 0xB4 + }, + { + 0x42, 0xB3, 0xB5, 0x52, 0x62, 0xB6, 0xE4, 0xD9, + 0x3E, 0x28, 0xB8, 0x56, 0x32, 0xEF, 0xC1, 0x29, + 0xCC, 0x63, 0x6C, 0xBF, 0xB6, 0x5E, 0x53, 0x2A, + 0xF8, 0x3B, 0xB2, 0x5A, 0x9A, 0x24, 0x7C, 0xE3 + }, + { + 0x51, 0x2D, 0x06, 0x19, 0x67, 0x25, 0x4C, 0xBC, + 0xC4, 0x93, 0xF6, 0xC7, 0xDE, 0x1C, 0x35, 0x6A, + 0x79, 0xCE, 0x33, 0x2E, 0x55, 0x8B, 0x8D, 0x95, + 0x5F, 0x16, 0x81, 0xFE, 0x17, 0xED, 0x3B, 0x92 + }, + { + 0xD2, 0x33, 0x1C, 0x6C, 0x6C, 0x27, 0xBE, 0xC9, + 0x6A, 0x16, 0x8D, 0xDA, 0x89, 0x3E, 0x07, 0xD2, + 0x1B, 0xF5, 0x74, 0x9B, 0xDA, 0xEC, 0xE3, 0x8E, + 0xE3, 0xB4, 0xC3, 0xB5, 0xCA, 0x28, 0x7B, 0x3C + }, + { + 0xBB, 0xDC, 0x93, 0xC2, 0xA0, 0x64, 0x55, 0xE6, + 0xC7, 0x09, 0x84, 0x6E, 0x7D, 0x62, 0x95, 0x05, + 0x62, 0xBA, 0x9C, 0x53, 0x91, 0x02, 0xEB, 0x34, + 0xB6, 0x89, 0xE1, 0x80, 0x67, 0x58, 0xDB, 0x36 + }, + { + 0x6C, 0x58, 0x05, 0x9A, 0xA4, 0xD4, 0x6C, 0x8C, + 0x73, 0x50, 0x18, 0x25, 0x85, 0x76, 0x91, 0x7B, + 0xCD, 0x4A, 0xE6, 0x92, 0x71, 0xCC, 0xD1, 0xF7, + 0x77, 0x74, 0x85, 0x22, 0xBD, 0x32, 0x5E, 0x90 + }, + { + 0x73, 0x49, 0xBB, 0x86, 0x83, 0x10, 0xE1, 0x7A, + 0x3F, 0x52, 0x98, 0xEA, 0x84, 0xF7, 0xE9, 0xC7, + 0xF7, 0xEC, 0x63, 0x5E, 0x22, 0xD5, 0x71, 0x01, + 0xF4, 0x5B, 0x20, 0xF2, 0x8B, 0xB4, 0x8A, 0x61 + }, + { + 0x19, 0xCA, 0x73, 0x0D, 0xD2, 0xA1, 0xD6, 0xFD, + 0x09, 0x38, 0xFE, 0x6C, 0x24, 0xA2, 0xC2, 0xD1, + 0xFF, 0xA6, 0xC8, 0x21, 0xF8, 0xF2, 0x81, 0x1B, + 0xF5, 0x7F, 0x92, 0x31, 0xEB, 0x30, 0x8B, 0x05 + }, + { + 0x3A, 0x0E, 0xEF, 0xF0, 0xAE, 0xDA, 0x17, 0xE4, + 0xFC, 0x72, 0xE9, 0x46, 0xF9, 0x4B, 0x75, 0x53, + 0xDA, 0xA3, 0x5F, 0x0C, 0x43, 0xCD, 0xEE, 0x65, + 0xE2, 0xF6, 0xF1, 0xE3, 0x8C, 0x93, 0xB7, 0x8A + }, + { + 0xC1, 0x14, 0x70, 0xD5, 0xDD, 0x72, 0xC3, 0xE3, + 0xC6, 0xE3, 0x40, 0x2E, 0xE0, 0x5C, 0x95, 0x21, + 0x9A, 0xC0, 0x55, 0x37, 0x10, 0x37, 0xC3, 0xC0, + 0xA6, 0xF9, 0xC0, 0x39, 0x4F, 0x18, 0x7B, 0xD2 + }, + { + 0x95, 0x08, 0xCB, 0xFA, 0x84, 0xA2, 0x70, 0x73, + 0xEE, 0x52, 0x8F, 0x81, 0xAD, 0xBC, 0x07, 0x83, + 0x2F, 0xD1, 0x2D, 0xBC, 0xB5, 0xBF, 0xF8, 0x12, + 0x3C, 0xEA, 0xCD, 0x9B, 0x05, 0xEF, 0xE8, 0xD8 + }, + { + 0xF2, 0x88, 0x0D, 0x2E, 0x13, 0x6F, 0x18, 0xD2, + 0xEC, 0x39, 0x93, 0xC3, 0x1F, 0x83, 0x75, 0xCB, + 0x04, 0x11, 0x82, 0x97, 0x3A, 0x1F, 0xB8, 0x5F, + 0x64, 0x29, 0x97, 0xE6, 0x86, 0xD9, 0xF8, 0x11 + }, + { + 0x71, 0xA6, 0x93, 0xDE, 0x07, 0x09, 0x4A, 0x13, + 0x54, 0x3A, 0xCA, 0xCD, 0xD1, 0xCD, 0x7F, 0xDF, + 0xAA, 0xEE, 0x6B, 0x5D, 0xC9, 0x76, 0x46, 0xF9, + 0x7F, 0x00, 0x2D, 0x6E, 0xD8, 0xA4, 0x24, 0xDB + }, + { + 0x9D, 0x1E, 0x88, 0xC8, 0x64, 0x1F, 0xE9, 0x2F, + 0x5F, 0x9D, 0x2E, 0xC6, 0x09, 0x78, 0x69, 0xDB, + 0x61, 0xD2, 0xF6, 0x1B, 0xEC, 0xEF, 0x24, 0x08, + 0x3B, 0x14, 0x44, 0x74, 0xDC, 0xE3, 0xEE, 0xDD + }, + { + 0xF8, 0x64, 0x3D, 0xBE, 0xAC, 0xFC, 0xC9, 0x8C, + 0x1D, 0xE6, 0x62, 0xE3, 0x5A, 0x80, 0x0F, 0xD8, + 0xDF, 0xC8, 0xA3, 0x69, 0xCE, 0x62, 0xED, 0x51, + 0x4E, 0x81, 0x3E, 0x65, 0x72, 0x8E, 0xD3, 0x79 + }, + { + 0xE8, 0x01, 0xCC, 0x52, 0xB6, 0x8B, 0x77, 0x8D, + 0xD0, 0x6D, 0x05, 0xA1, 0x7D, 0xD7, 0xBC, 0x5A, + 0x95, 0xBB, 0xB1, 0xE7, 0x7E, 0xE9, 0xA7, 0xC7, + 0x10, 0x26, 0x60, 0x3D, 0xF2, 0x48, 0xCE, 0xE1 + }, + { + 0x1C, 0xD5, 0x2A, 0xBE, 0xBC, 0x37, 0x55, 0xC5, + 0x5B, 0xCC, 0x06, 0x0E, 0xC0, 0x4F, 0x46, 0xBF, + 0xF5, 0x29, 0x6E, 0xBA, 0x0A, 0xFE, 0x62, 0x62, + 0xC4, 0x2E, 0xF5, 0x69, 0x0D, 0x86, 0x92, 0xC0 + }, + { + 0xB8, 0x55, 0x75, 0x60, 0xDE, 0xF9, 0x68, 0x0F, + 0x1E, 0x18, 0x9B, 0xE8, 0xA0, 0x77, 0x30, 0x4E, + 0x78, 0x6A, 0x7F, 0x16, 0x84, 0xC7, 0x27, 0x7F, + 0x7E, 0x86, 0x59, 0xD5, 0xCD, 0xC9, 0xDD, 0x47 + }, + { + 0x74, 0xED, 0x24, 0x02, 0x61, 0x51, 0xC5, 0x25, + 0x67, 0x5F, 0x5A, 0x63, 0x70, 0x61, 0x02, 0x10, + 0x88, 0x58, 0x4B, 0x4F, 0xAC, 0xC5, 0x32, 0x56, + 0xC0, 0x05, 0x03, 0xEE, 0x39, 0xBE, 0x76, 0xCB + }, + { + 0x56, 0xA8, 0x47, 0x67, 0x0F, 0x76, 0x6B, 0x3A, + 0x5C, 0xF2, 0x14, 0x2C, 0xEC, 0xAA, 0xA3, 0xCD, + 0x09, 0x14, 0x65, 0xF6, 0x06, 0xE3, 0xA8, 0x47, + 0x77, 0x7C, 0x08, 0x64, 0xD1, 0x7C, 0x55, 0x75 + }, + { + 0xB4, 0x65, 0xED, 0xB5, 0x44, 0x50, 0x2D, 0x9F, + 0x80, 0xD1, 0x2A, 0xD3, 0x97, 0xA6, 0xCE, 0x82, + 0x0E, 0x74, 0x4E, 0x8B, 0x16, 0xD4, 0x27, 0x33, + 0xCA, 0x6F, 0x3E, 0x97, 0x37, 0x2E, 0xB7, 0x2E + }, + { + 0x52, 0xDC, 0x3B, 0xD4, 0x56, 0x21, 0x73, 0x22, + 0x3D, 0xCF, 0x2E, 0xE2, 0x98, 0xB9, 0x44, 0x61, + 0x8D, 0x4B, 0x5E, 0x39, 0x5B, 0x86, 0xB1, 0xDD, + 0x1F, 0xD5, 0x11, 0x79, 0x02, 0x85, 0x44, 0xFA + }, + { + 0x54, 0xFE, 0x66, 0x16, 0x57, 0x7F, 0xEF, 0xEC, + 0x66, 0x9F, 0x34, 0x36, 0x33, 0x18, 0x80, 0x2A, + 0xE5, 0x3D, 0x0C, 0x83, 0x7F, 0x0E, 0xDD, 0xCA, + 0x2A, 0xE1, 0x07, 0x75, 0x39, 0x1E, 0x6D, 0xC9 + }, + { + 0xE8, 0x38, 0x9F, 0x6E, 0x59, 0x7E, 0xBE, 0xE5, + 0x81, 0x9C, 0xB1, 0x34, 0x65, 0xD6, 0xBA, 0x26, + 0x45, 0xAC, 0x97, 0xCD, 0x67, 0xC5, 0xB5, 0xB2, + 0x2E, 0x7E, 0xFF, 0xFA, 0xF6, 0x78, 0xBA, 0x77 + }, + { + 0x75, 0x53, 0x01, 0x78, 0x09, 0x29, 0xA4, 0x3D, + 0xDA, 0xF6, 0x89, 0x1B, 0x1B, 0xCD, 0xCA, 0x13, + 0x57, 0x33, 0x66, 0x1E, 0xEB, 0xD7, 0x12, 0xC6, + 0x3B, 0x3C, 0xFC, 0x83, 0xFC, 0x3B, 0xF8, 0x97 + }, + { + 0x97, 0x6F, 0x9D, 0xB7, 0x50, 0xB7, 0xC6, 0x7A, + 0xB7, 0x9A, 0xA1, 0xBB, 0xB9, 0x45, 0x98, 0xF1, + 0x47, 0xCA, 0xC5, 0xDD, 0xE6, 0xD3, 0x81, 0xC9, + 0xC0, 0x1E, 0xD8, 0x59, 0xA5, 0xDC, 0x52, 0xA7 + }, + { + 0x24, 0x44, 0x9B, 0x56, 0x79, 0xBB, 0x25, 0x06, + 0x8B, 0xF4, 0xFE, 0xC0, 0xAF, 0xFE, 0x05, 0xF6, + 0xC3, 0xC1, 0x22, 0x47, 0xBB, 0xB2, 0xD0, 0xC2, + 0x50, 0x25, 0x45, 0xD4, 0xBF, 0x42, 0x33, 0x7F + }, + { + 0x9C, 0xE3, 0x80, 0x9C, 0xF2, 0xC5, 0xBE, 0xD8, + 0xFB, 0x65, 0x11, 0x75, 0x9D, 0x3D, 0xE1, 0x82, + 0x8C, 0x6A, 0x0C, 0x4C, 0x04, 0x31, 0x11, 0xC4, + 0xD0, 0xC7, 0x1F, 0x37, 0x81, 0x8B, 0xFE, 0x08 + }, + { + 0xE6, 0xA9, 0xE6, 0x61, 0x1D, 0x6B, 0x13, 0x66, + 0xDC, 0xE3, 0x35, 0xEB, 0x77, 0x26, 0xF9, 0xF3, + 0x61, 0x34, 0xC2, 0x71, 0xF9, 0xDB, 0xE9, 0x13, + 0x2C, 0x0D, 0xFC, 0xA1, 0xA4, 0x31, 0xEC, 0xDD + }, + { + 0x45, 0x63, 0x93, 0xF1, 0xCF, 0x33, 0x53, 0x0E, + 0x4E, 0x66, 0x35, 0xBA, 0x73, 0x42, 0xF5, 0x73, + 0x17, 0xBD, 0x2E, 0x85, 0x55, 0x4B, 0xB6, 0xF6, + 0xA3, 0x12, 0xCB, 0x3A, 0x11, 0xE9, 0x0C, 0x46 + }, + { + 0xFA, 0x87, 0x09, 0x54, 0x33, 0x91, 0x6A, 0x77, + 0xF9, 0xBF, 0x91, 0xE1, 0x3A, 0x32, 0x82, 0x97, + 0x65, 0xE7, 0xC0, 0x26, 0xED, 0x56, 0xC7, 0x79, + 0x48, 0xC7, 0xE8, 0xE9, 0x86, 0x39, 0xB5, 0xC4 + }, + { + 0x17, 0xF8, 0x97, 0xE7, 0x06, 0x20, 0x0D, 0x49, + 0xD1, 0xBC, 0xC5, 0xFD, 0x95, 0x4C, 0x41, 0xAD, + 0xC6, 0x67, 0x2C, 0xC9, 0x58, 0x01, 0xF1, 0xAD, + 0xF7, 0xD4, 0xEE, 0x65, 0xEE, 0x03, 0x49, 0x80 + }, + { + 0x66, 0xFD, 0x20, 0xC3, 0x26, 0x3B, 0x43, 0x39, + 0x2A, 0x3D, 0xF3, 0x8C, 0xB8, 0xF2, 0xC8, 0x59, + 0x04, 0x39, 0xFC, 0x7C, 0xDE, 0x30, 0xF6, 0x4B, + 0x23, 0x91, 0x32, 0x40, 0x6D, 0x90, 0xE7, 0xBE + }, + { + 0x19, 0xDE, 0x7C, 0xAE, 0xB5, 0xB1, 0x64, 0xD4, + 0xEE, 0x7C, 0x1D, 0xFA, 0x1B, 0x25, 0x21, 0x63, + 0x1F, 0x4A, 0xE9, 0xBA, 0xAD, 0x40, 0xC2, 0xAE, + 0x00, 0xF5, 0x99, 0xC7, 0xB2, 0x31, 0xAC, 0xD8 + }, + { + 0x2D, 0x26, 0x09, 0x7A, 0x90, 0x6E, 0x42, 0xCF, + 0xB2, 0xC8, 0x09, 0x67, 0x3C, 0xF9, 0xAF, 0x50, + 0x25, 0xE5, 0xB4, 0x78, 0x8F, 0x26, 0xF0, 0x44, + 0x34, 0xAA, 0x8E, 0x2A, 0x4B, 0x1C, 0x87, 0x20 + }, + { + 0x48, 0xD5, 0xCA, 0x33, 0xE4, 0x28, 0x91, 0x15, + 0xC5, 0xE1, 0x59, 0x40, 0x35, 0xD2, 0x39, 0x9B, + 0x49, 0x8C, 0xBF, 0x1F, 0x8A, 0x76, 0xFB, 0x55, + 0x70, 0x48, 0x5E, 0x53, 0x9F, 0xAD, 0x6A, 0xAF + }, + { + 0x12, 0x83, 0xAD, 0xA1, 0x0F, 0x85, 0x69, 0xBF, + 0x75, 0x67, 0xD5, 0xD6, 0x8E, 0x3C, 0xB8, 0x31, + 0x1B, 0x06, 0xAA, 0xEF, 0x88, 0x0B, 0x0A, 0x5A, + 0x40, 0xF8, 0x91, 0xAC, 0xBA, 0x96, 0x8A, 0x54 + }, + { + 0x49, 0x21, 0x61, 0x76, 0xEF, 0x21, 0x7B, 0x37, + 0x6B, 0xDB, 0x2C, 0xAF, 0x17, 0xC4, 0xEF, 0x43, + 0x2F, 0xFA, 0x3A, 0x59, 0x41, 0xC6, 0xFC, 0x34, + 0x2B, 0xC3, 0x62, 0xC2, 0x85, 0x50, 0x2F, 0x5B + }, + { + 0x88, 0x3A, 0xF1, 0xB7, 0x01, 0x91, 0x41, 0x23, + 0x8A, 0x79, 0xE9, 0x1E, 0x40, 0x7B, 0xF5, 0x76, + 0xE6, 0x55, 0x1F, 0x43, 0x22, 0x6F, 0x32, 0x45, + 0x86, 0x92, 0x7C, 0x3B, 0x6E, 0x70, 0x72, 0x91 + }, + { + 0x41, 0x02, 0x5F, 0x12, 0xFC, 0x3E, 0x7B, 0x6F, + 0xF2, 0xC8, 0x98, 0xFD, 0x60, 0xF4, 0xF4, 0x46, + 0xEB, 0x4A, 0x84, 0x13, 0xF7, 0xDD, 0xBB, 0x34, + 0xE2, 0x28, 0x89, 0x66, 0xF1, 0x4A, 0xDD, 0x29 + }, + { + 0xAE, 0xCD, 0xD5, 0x23, 0xAA, 0x0C, 0x40, 0x8B, + 0xA1, 0xDF, 0x7E, 0x3C, 0xE6, 0x23, 0x66, 0x56, + 0xE6, 0x4A, 0x2B, 0x54, 0xA0, 0x31, 0x91, 0x98, + 0xBE, 0x07, 0xBF, 0x59, 0x4F, 0xA5, 0xBE, 0xBC + }, + { + 0xD8, 0xFE, 0x38, 0xFA, 0x15, 0xEC, 0x31, 0xA8, + 0x26, 0xB0, 0x41, 0x2E, 0xCC, 0x95, 0x61, 0x03, + 0x9B, 0x91, 0xD3, 0xD1, 0x40, 0x83, 0x8F, 0x4C, + 0x48, 0x74, 0x46, 0xDA, 0xAB, 0x4C, 0x36, 0x9C + }, + { + 0xC8, 0x4B, 0x14, 0xA7, 0x0B, 0x6D, 0xEF, 0x01, + 0x94, 0xD7, 0x30, 0x35, 0x41, 0x36, 0xF9, 0x60, + 0xE6, 0xD1, 0xD5, 0xB4, 0x72, 0x26, 0x9D, 0xDA, + 0x41, 0x4E, 0xD1, 0xA2, 0x3C, 0xBE, 0x73, 0xE7 + }, + { + 0x0C, 0x4F, 0x9B, 0x3E, 0xBA, 0xB7, 0x43, 0xD1, + 0x20, 0x52, 0x53, 0x56, 0xB2, 0xA7, 0x76, 0xE6, + 0xF0, 0x1E, 0x6C, 0xD5, 0xED, 0x51, 0x3B, 0x70, + 0x49, 0xE7, 0x2E, 0xD6, 0xD3, 0x37, 0x97, 0xC7 + }, + { + 0x6F, 0xF5, 0x79, 0xE8, 0x91, 0x10, 0x6A, 0xF2, + 0x6A, 0x11, 0x78, 0x53, 0x06, 0x2A, 0x20, 0xFF, + 0x4E, 0xC8, 0xB3, 0x76, 0x95, 0x7A, 0xE6, 0xEB, + 0xC2, 0x84, 0x7F, 0x81, 0x56, 0x56, 0x4E, 0x48 + }, + { + 0xAA, 0x46, 0x33, 0x62, 0x8B, 0x24, 0x3A, 0xD6, + 0xFA, 0x9C, 0x65, 0x5C, 0xB9, 0x34, 0x69, 0x21, + 0xAE, 0x6A, 0x14, 0x55, 0x04, 0x03, 0x49, 0xB4, + 0x2A, 0xDD, 0x2D, 0xD4, 0x54, 0x17, 0xC4, 0x6B + }, + { + 0x52, 0x79, 0xCE, 0xAB, 0xF6, 0xA8, 0xD4, 0xC4, + 0xCA, 0x60, 0x41, 0xDA, 0xD1, 0xC9, 0x69, 0x35, + 0xCF, 0xC7, 0x85, 0x09, 0xF7, 0x24, 0xCE, 0x5F, + 0xA1, 0x90, 0x26, 0x36, 0x00, 0xCE, 0xFF, 0x0B + }, + { + 0xF0, 0xFC, 0xA3, 0x0A, 0xCF, 0x2A, 0xE3, 0x6A, + 0xD1, 0x85, 0xAC, 0xAB, 0x0C, 0x7B, 0x08, 0xD2, + 0x3E, 0xDD, 0x99, 0xD1, 0x84, 0x9B, 0x06, 0x6B, + 0xCA, 0x6F, 0xEE, 0x03, 0x05, 0x88, 0x60, 0x4F + }, + { + 0x4D, 0xF2, 0x94, 0x58, 0x04, 0x80, 0x0A, 0x01, + 0x53, 0xF5, 0x8F, 0xF5, 0xEC, 0x2B, 0x18, 0x11, + 0x73, 0xC0, 0x77, 0x34, 0x13, 0x7A, 0x61, 0x25, + 0x40, 0x1D, 0x83, 0x56, 0x36, 0xED, 0xA8, 0x12 + }, + { + 0x69, 0x03, 0x22, 0x10, 0x09, 0x23, 0x66, 0x12, + 0xED, 0xC2, 0x1C, 0x5B, 0x04, 0x30, 0x12, 0x42, + 0x8A, 0x03, 0x60, 0x48, 0x21, 0xDD, 0xB2, 0xB6, + 0x5E, 0xF8, 0x6D, 0xF0, 0x52, 0x43, 0xD5, 0x15 + }, + { + 0x48, 0xFB, 0xAB, 0xE7, 0xA8, 0x9B, 0xA6, 0x8B, + 0x6F, 0x5C, 0x69, 0x41, 0x05, 0x4F, 0xA8, 0x47, + 0x92, 0xDD, 0x2A, 0x93, 0x97, 0x6A, 0xA5, 0xF2, + 0x58, 0x78, 0x7A, 0xD8, 0xF8, 0x95, 0x90, 0x91 + }, + { + 0xE5, 0xA3, 0x50, 0x68, 0xFA, 0x61, 0xB1, 0xD0, + 0x0E, 0xB6, 0xDC, 0x6E, 0x9F, 0x6E, 0x19, 0x82, + 0x3A, 0xFB, 0xF6, 0x17, 0x61, 0xEE, 0xFE, 0xD3, + 0x19, 0xD3, 0x0F, 0xAD, 0xFD, 0xFB, 0x7D, 0x5C + }, + { + 0xD0, 0x7D, 0x84, 0xBC, 0xAB, 0x34, 0xB7, 0x74, + 0x9B, 0xC4, 0x4C, 0x77, 0x90, 0x11, 0x77, 0xD8, + 0x14, 0x19, 0x4C, 0x40, 0x84, 0x49, 0xB2, 0x50, + 0x50, 0xEF, 0x4B, 0x15, 0x93, 0x78, 0xCC, 0x52 + }, + { + 0x4C, 0xA9, 0xE1, 0x5C, 0x2A, 0x23, 0x07, 0xC3, + 0x77, 0x9C, 0x8E, 0xC9, 0xE6, 0x67, 0x33, 0xBE, + 0x15, 0x71, 0xD9, 0xEA, 0x7C, 0x7C, 0x95, 0x57, + 0x15, 0x51, 0x8F, 0x60, 0x64, 0x58, 0xE9, 0xA6 + }, + { + 0x6E, 0x6A, 0x7C, 0x6F, 0xB1, 0x13, 0xC0, 0xA1, + 0xE2, 0x5C, 0x32, 0x31, 0x09, 0x37, 0xAF, 0xE9, + 0xCE, 0x3B, 0x36, 0x93, 0xC0, 0x5E, 0x9D, 0x7C, + 0xA6, 0xE5, 0x51, 0x2E, 0xCA, 0x73, 0xB8, 0x8A + }, + { + 0xEA, 0x90, 0x37, 0x63, 0x0F, 0x13, 0xE5, 0xB6, + 0x38, 0xBD, 0xD7, 0x47, 0x2C, 0xFE, 0x1E, 0xEC, + 0xA7, 0x75, 0x1E, 0x38, 0xDB, 0x51, 0x77, 0x3C, + 0x66, 0x7E, 0x93, 0x30, 0x0C, 0xE2, 0xE2, 0x35 + }, + { + 0x1A, 0x41, 0xFE, 0xBD, 0xA5, 0xDD, 0x29, 0x3C, + 0x89, 0xF8, 0x59, 0x77, 0x77, 0xE0, 0xB4, 0x0E, + 0xCD, 0x8B, 0x91, 0xAA, 0x23, 0xA5, 0xA2, 0xD1, + 0x0B, 0xE8, 0x04, 0xEA, 0x4E, 0xD1, 0xAC, 0x1D + }, + { + 0xA0, 0x8A, 0xAF, 0x19, 0x48, 0x96, 0xA2, 0x11, + 0x76, 0x41, 0x0E, 0x20, 0x2B, 0x43, 0xB4, 0x32, + 0x22, 0x9C, 0x02, 0x9B, 0xA5, 0x7B, 0xA2, 0xC8, + 0xA6, 0x41, 0x0F, 0x22, 0xF9, 0x9C, 0xFE, 0x51 + }, + { + 0x9D, 0xBC, 0x75, 0x4E, 0xB0, 0x4B, 0x02, 0x36, + 0x06, 0x49, 0xCE, 0xA2, 0xA9, 0x38, 0x10, 0xAF, + 0x22, 0x0E, 0xF4, 0x60, 0x4C, 0x93, 0xE1, 0xDB, + 0x9C, 0xB1, 0x07, 0xA3, 0x1B, 0x30, 0xFD, 0xF4 + }, + { + 0x88, 0xB9, 0xB6, 0x72, 0x8B, 0xB1, 0xEC, 0xE0, + 0x8A, 0x2D, 0x46, 0x85, 0xBC, 0x2B, 0x2C, 0xB1, + 0x21, 0x2E, 0x95, 0xFD, 0xC8, 0x35, 0x68, 0x3C, + 0xBA, 0xE3, 0xFE, 0x5D, 0x15, 0xC4, 0xB5, 0xD8 + }, + { + 0x26, 0xA7, 0x2A, 0xFD, 0x2C, 0xA9, 0x4A, 0xDA, + 0xB8, 0x29, 0x7A, 0xF1, 0xDD, 0xA4, 0x75, 0x50, + 0xF9, 0xE7, 0xCE, 0x7A, 0x00, 0x3E, 0x85, 0xEE, + 0x5E, 0xD4, 0x23, 0x75, 0x73, 0x33, 0xF3, 0xB5 + }, + { + 0xC3, 0x71, 0x7F, 0xAD, 0x38, 0x7D, 0x09, 0x8D, + 0xDF, 0x8E, 0xFC, 0x35, 0xD2, 0xEB, 0x58, 0xE5, + 0xF5, 0xA6, 0x52, 0x12, 0xC6, 0xCE, 0xD2, 0x3B, + 0x15, 0x0E, 0x5D, 0x37, 0x68, 0x7B, 0xCA, 0xD9 + }, + { + 0xBE, 0x36, 0x02, 0x2B, 0xCB, 0xED, 0xB0, 0x14, + 0x0E, 0x44, 0x34, 0x64, 0x30, 0xF7, 0x3F, 0xA5, + 0x91, 0x99, 0xC2, 0xE2, 0xC2, 0x3E, 0x88, 0x7D, + 0x60, 0x05, 0x05, 0xBB, 0x09, 0x78, 0x1B, 0x5B + }, + { + 0x1A, 0x3C, 0x65, 0x91, 0xAC, 0x73, 0xDF, 0x2A, + 0x3E, 0x7D, 0xC6, 0x51, 0x0D, 0x1D, 0x77, 0x37, + 0x0D, 0xEF, 0x19, 0xC0, 0xDC, 0x32, 0x94, 0x53, + 0x83, 0xD3, 0x93, 0x5B, 0x86, 0xB5, 0x00, 0xFD + }, + { + 0x51, 0xC5, 0xD3, 0xD3, 0x7B, 0x9F, 0x2C, 0xDF, + 0x25, 0x83, 0x0F, 0x5B, 0x87, 0x3A, 0xA1, 0x07, + 0xA2, 0x3F, 0xBB, 0xAB, 0x7A, 0x11, 0x3D, 0x25, + 0xDA, 0xFF, 0x28, 0x49, 0xB8, 0x96, 0x08, 0x68 + }, + { + 0x0F, 0xEE, 0x74, 0x7E, 0x40, 0xCD, 0xE3, 0xC8, + 0x44, 0x00, 0x37, 0x06, 0x32, 0x9B, 0xAD, 0x48, + 0x80, 0xBD, 0x57, 0xF4, 0x71, 0x13, 0x92, 0x18, + 0xDB, 0xD2, 0x9B, 0x26, 0xFD, 0x59, 0x89, 0x63 + }, + { + 0x33, 0x40, 0xA0, 0x81, 0xC5, 0x9B, 0xBA, 0x1F, + 0xBD, 0x26, 0x63, 0x75, 0xD0, 0x10, 0x2C, 0x89, + 0xF0, 0x79, 0x13, 0xE5, 0xFF, 0xCC, 0xDE, 0xAF, + 0x39, 0x69, 0xBF, 0x2D, 0x71, 0xEC, 0x40, 0x48 + }, + { + 0x7E, 0x70, 0x64, 0x85, 0x0F, 0x48, 0xF0, 0x84, + 0x03, 0xA6, 0x1A, 0x37, 0x86, 0xBD, 0x5A, 0x3B, + 0x7C, 0x62, 0x15, 0xBA, 0x31, 0xF3, 0x76, 0x73, + 0x10, 0xFC, 0x73, 0xF6, 0x20, 0x08, 0xCC, 0x0E + }, + { + 0x42, 0xD8, 0xA6, 0x95, 0xA9, 0x3C, 0x04, 0xA7, + 0x68, 0xF0, 0x3A, 0x04, 0xD0, 0x4F, 0xA8, 0xE4, + 0x12, 0x16, 0x60, 0x9E, 0x94, 0xF1, 0x4C, 0x55, + 0xAD, 0x72, 0xA9, 0x0D, 0xA4, 0xB8, 0xDD, 0x3E + }, + { + 0x25, 0xDF, 0x61, 0x2D, 0x3B, 0x9D, 0xF6, 0xEC, + 0x83, 0x82, 0x26, 0x5A, 0xAB, 0x6C, 0xB9, 0x93, + 0x5C, 0xCE, 0x2D, 0x96, 0x2D, 0x21, 0x17, 0x54, + 0xAF, 0x07, 0xF3, 0xFE, 0xA1, 0xD2, 0x71, 0xE1 + }, + { + 0x1B, 0x36, 0x58, 0xE6, 0x78, 0x5F, 0x8A, 0xCB, + 0x40, 0x73, 0x8D, 0x2A, 0x88, 0xEC, 0x6F, 0x0B, + 0xB4, 0xF9, 0xB3, 0x96, 0x27, 0x8D, 0xA8, 0xA6, + 0x58, 0x79, 0xEC, 0x79, 0x35, 0xE7, 0x21, 0x2C + }, + { + 0x35, 0xAC, 0x98, 0xE2, 0x90, 0x9F, 0x73, 0xB3, + 0x9F, 0x4A, 0x2C, 0xDB, 0x8F, 0x0F, 0x13, 0xF8, + 0xB2, 0xAC, 0xF4, 0xAF, 0x05, 0x27, 0xB0, 0x3F, + 0xF2, 0x8A, 0xAE, 0xBC, 0x14, 0x32, 0x9E, 0x18 + }, + { + 0x9E, 0xB1, 0x3A, 0x45, 0xAF, 0xB2, 0xCB, 0xED, + 0x3F, 0xAA, 0x9B, 0xB6, 0x38, 0xF0, 0x3C, 0xFA, + 0xF1, 0xD0, 0xDE, 0xFC, 0x11, 0xCF, 0xF2, 0xEF, + 0x40, 0x99, 0xBC, 0x0C, 0x6E, 0x60, 0x99, 0x2B + }, + { + 0x51, 0x14, 0x67, 0xDF, 0xF6, 0x24, 0x1B, 0x28, + 0x85, 0x9E, 0xF4, 0x18, 0xA3, 0xE2, 0xCE, 0x30, + 0xA2, 0xD3, 0xED, 0x3B, 0xAA, 0x05, 0xDB, 0xA7, + 0xFF, 0xB1, 0xC6, 0xD7, 0xDD, 0x0E, 0x4C, 0xDE + }, + { + 0x48, 0x87, 0x14, 0x17, 0x3E, 0xF1, 0x0A, 0xFB, + 0xF6, 0x0B, 0x1E, 0xC0, 0xD9, 0x2C, 0xB1, 0x3F, + 0x2F, 0x08, 0xE7, 0x27, 0xC8, 0xC7, 0xD3, 0xF3, + 0x5D, 0x43, 0x9F, 0xEE, 0xCA, 0x1F, 0xFC, 0x8B + }, + { + 0x20, 0x2F, 0x2E, 0x61, 0x21, 0x08, 0x74, 0x7E, + 0x34, 0x34, 0x70, 0xF9, 0x46, 0xC1, 0x0C, 0x7A, + 0x63, 0xC4, 0x96, 0x72, 0xCA, 0xFC, 0x42, 0x94, + 0x19, 0xC7, 0x2C, 0x3E, 0x8D, 0xA9, 0xF7, 0x87 + }, + { + 0xE8, 0x4C, 0x68, 0xD3, 0x68, 0xF6, 0x5B, 0x81, + 0xC0, 0x64, 0x2E, 0x0E, 0xAE, 0x41, 0xD5, 0x08, + 0xD3, 0x39, 0x6A, 0x1F, 0xA0, 0x5B, 0xB7, 0x98, + 0x64, 0x46, 0x6A, 0xF7, 0xD1, 0x1B, 0x8C, 0x6C + }, + { + 0x26, 0x52, 0x6F, 0xF2, 0xB9, 0xBA, 0xCE, 0x7C, + 0x54, 0xC1, 0xCE, 0x75, 0x0C, 0xC4, 0x0E, 0x6A, + 0xFF, 0x7D, 0x4C, 0xA5, 0x3A, 0xBF, 0xB0, 0xA9, + 0x10, 0x1D, 0x04, 0x2F, 0xA6, 0xA0, 0x7E, 0x13 + }, + { + 0x02, 0x37, 0x95, 0xE3, 0xF9, 0xC4, 0xB0, 0xDB, + 0x47, 0x58, 0x87, 0x23, 0x21, 0x1E, 0x60, 0x8F, + 0x2C, 0x0A, 0x65, 0xF1, 0x69, 0xD5, 0x88, 0x30, + 0x4D, 0xD1, 0xE3, 0x8F, 0xD9, 0xF8, 0xD8, 0xE9 + }, + { + 0x89, 0x6D, 0xE9, 0xC3, 0x3A, 0x5E, 0xFA, 0xF1, + 0xD5, 0x01, 0x76, 0x4D, 0x30, 0xFD, 0x6C, 0xE9, + 0xF6, 0x5A, 0xA8, 0x72, 0x37, 0x79, 0xF0, 0x8C, + 0xE0, 0x86, 0x96, 0x8E, 0xAB, 0x20, 0xE9, 0xAE + }, + { + 0x76, 0x08, 0x97, 0xD4, 0x26, 0xC5, 0x77, 0xE9, + 0x0B, 0x46, 0x02, 0x22, 0x32, 0x49, 0xBA, 0x55, + 0x14, 0x10, 0xF5, 0x35, 0x8E, 0x77, 0xDD, 0x50, + 0x08, 0x70, 0xE5, 0xD8, 0xAC, 0x83, 0x77, 0x94 + }, + { + 0x14, 0x3A, 0xDE, 0x2C, 0x8A, 0x41, 0xB0, 0xDD, + 0xFB, 0x63, 0xBC, 0x79, 0x3B, 0xE0, 0x4B, 0xA9, + 0x41, 0x0A, 0xC0, 0xA9, 0x0F, 0x59, 0x34, 0x96, + 0x2D, 0x92, 0xAB, 0x82, 0x24, 0xCD, 0xC7, 0x5E + }, + { + 0x27, 0xC7, 0x9E, 0x96, 0xED, 0x96, 0x14, 0x12, + 0x02, 0xEE, 0x59, 0xEF, 0x0D, 0x12, 0x2C, 0xAA, + 0xED, 0x3E, 0x96, 0x6C, 0xEB, 0x4B, 0x3D, 0x4A, + 0xDF, 0xA1, 0xCE, 0x91, 0x52, 0xDC, 0x8C, 0xA2 + }, + { + 0x40, 0x84, 0xEC, 0x78, 0x09, 0x4A, 0x95, 0x1C, + 0xBD, 0xAB, 0xD3, 0x48, 0xCB, 0x86, 0x0E, 0x69, + 0x52, 0xCA, 0xDC, 0x6E, 0x57, 0x0C, 0xB3, 0x45, + 0xC2, 0xD3, 0x58, 0x12, 0xBE, 0x78, 0x08, 0xF3 + }, + { + 0xA1, 0x76, 0xBF, 0x3D, 0xCC, 0x42, 0xAB, 0xAA, + 0xAC, 0xE0, 0x77, 0xBB, 0x0A, 0xDD, 0x93, 0x33, + 0x26, 0x23, 0x91, 0xD8, 0xEC, 0x1E, 0x3F, 0xEE, + 0x16, 0x13, 0x2E, 0x34, 0x43, 0x9B, 0x08, 0x1C + }, + { + 0x43, 0x7A, 0x56, 0x48, 0x5B, 0xC3, 0x0F, 0xE2, + 0x34, 0x8D, 0xFB, 0xE5, 0x89, 0x6A, 0x5D, 0xC1, + 0xDC, 0xF5, 0x0C, 0xCC, 0xCD, 0x09, 0xCC, 0x84, + 0x2D, 0x0B, 0x18, 0xEA, 0xEC, 0x9F, 0xD9, 0x4E + }, + { + 0x31, 0xC3, 0xF1, 0xCA, 0x99, 0x96, 0x8F, 0x23, + 0xAA, 0x09, 0x07, 0x06, 0x30, 0xBD, 0xD1, 0x9D, + 0xF3, 0x66, 0x07, 0xD5, 0xC6, 0xAE, 0x49, 0x03, + 0x77, 0x1D, 0xDA, 0xDE, 0x71, 0x37, 0xF5, 0xC9 + }, + { + 0x32, 0x6E, 0x32, 0x7C, 0x72, 0x4E, 0x37, 0x8E, + 0x13, 0xB8, 0xBC, 0x7E, 0xB8, 0xD7, 0x89, 0xD5, + 0x9D, 0x25, 0x31, 0xE0, 0x4A, 0xC2, 0x27, 0x0F, + 0x4C, 0x07, 0x0F, 0x79, 0x21, 0x60, 0x2C, 0xDA + }, + { + 0x0A, 0xCC, 0x38, 0x3F, 0x69, 0xCA, 0xBE, 0x5A, + 0x93, 0x22, 0xDC, 0xF6, 0x83, 0xA5, 0x04, 0x00, + 0x9B, 0xD0, 0x49, 0x88, 0xA9, 0xF9, 0xC6, 0x12, + 0x96, 0xAB, 0xD9, 0x66, 0x98, 0xAB, 0x40, 0x3B + }, + { + 0xDB, 0x09, 0x2D, 0x38, 0x8F, 0xD3, 0xAB, 0xE9, + 0x14, 0x59, 0xEA, 0xB4, 0x5A, 0x1C, 0x21, 0x23, + 0x9B, 0x66, 0x03, 0x6C, 0x5D, 0x02, 0x9C, 0x8F, + 0x51, 0xFE, 0xB1, 0x1E, 0xBA, 0xF8, 0x05, 0xB5 + }, + { + 0xCE, 0x73, 0xBB, 0xFD, 0xC1, 0xC9, 0x69, 0xFB, + 0x9E, 0x2D, 0x44, 0x41, 0xDC, 0x7E, 0x85, 0xB1, + 0x23, 0x71, 0x24, 0xD6, 0xD9, 0x8A, 0x22, 0xB3, + 0x70, 0x56, 0x2E, 0xBB, 0x0A, 0xDA, 0x2B, 0xCB + }, + { + 0x95, 0xDF, 0xDA, 0x58, 0x1D, 0xD3, 0xD3, 0xF0, + 0xF9, 0x09, 0x73, 0x4A, 0x87, 0x17, 0xE5, 0x59, + 0x84, 0x80, 0xED, 0xC6, 0xEC, 0xCF, 0x6A, 0xF8, + 0xDC, 0x69, 0x03, 0xFD, 0x5A, 0x1D, 0x2A, 0xBF + }, + { + 0x4B, 0xA2, 0x25, 0xE8, 0xAA, 0x57, 0x3B, 0x26, + 0xC7, 0xC8, 0x5B, 0xF0, 0x9A, 0x19, 0xE6, 0x7D, + 0xB3, 0x11, 0x53, 0x83, 0xA8, 0x40, 0xF8, 0xA6, + 0x97, 0xBF, 0x18, 0xB4, 0x9B, 0xE1, 0x0B, 0x0C + }, + { + 0x5A, 0x57, 0x49, 0xD6, 0x8C, 0x19, 0xEB, 0x2D, + 0x13, 0x5A, 0x07, 0xF2, 0xC1, 0x4F, 0x29, 0xE3, + 0x66, 0x6B, 0x09, 0x2A, 0x6B, 0x06, 0x7C, 0x1D, + 0xEE, 0x70, 0x67, 0xAB, 0xEE, 0x03, 0x4C, 0x3D + }, + { + 0x2A, 0x89, 0x6F, 0xB1, 0xE2, 0x54, 0x2E, 0x1C, + 0xBE, 0x10, 0xAD, 0x1C, 0x1F, 0x2D, 0xA6, 0x4A, + 0x10, 0x37, 0x27, 0x57, 0xDC, 0x61, 0x32, 0x86, + 0x85, 0x70, 0x47, 0xF3, 0x9B, 0x50, 0x09, 0xA1 + }, + { + 0x5E, 0xAE, 0xD8, 0x04, 0x3D, 0x37, 0xD1, 0xC8, + 0xB4, 0x6A, 0xBA, 0x97, 0x68, 0x68, 0x53, 0xB7, + 0x11, 0x74, 0x1B, 0x54, 0x02, 0x77, 0xAD, 0xBA, + 0xF4, 0xB3, 0xB9, 0x8F, 0xF1, 0x23, 0x07, 0xDD + }, + { + 0xDD, 0xE5, 0x9C, 0x38, 0x4D, 0xD9, 0x9B, 0xEF, + 0x6B, 0x06, 0x49, 0xC0, 0xC7, 0x2E, 0x8E, 0xD0, + 0xAE, 0x26, 0x01, 0xED, 0x78, 0x8E, 0x1D, 0x10, + 0x4B, 0x71, 0x78, 0xCB, 0x4B, 0x62, 0x30, 0x56 + }, + { + 0xD6, 0x84, 0x54, 0xDF, 0x94, 0xE5, 0xD7, 0x73, + 0xC0, 0x98, 0x79, 0x35, 0xE2, 0xCA, 0x8D, 0xFE, + 0x40, 0x2E, 0x30, 0x31, 0x1A, 0xEC, 0x0A, 0x7E, + 0x1C, 0x27, 0x83, 0x15, 0xDE, 0x15, 0x82, 0xF6 + }, + { + 0x3F, 0x84, 0xC1, 0x95, 0xEB, 0xB2, 0x92, 0x8A, + 0xD6, 0xD6, 0x61, 0x1B, 0xCB, 0x5C, 0x54, 0xBC, + 0x74, 0x0A, 0x72, 0x65, 0x2E, 0x9A, 0x74, 0x40, + 0xB1, 0xF3, 0xBD, 0xF5, 0x33, 0x12, 0xBE, 0x97 + }, + { + 0x2F, 0x77, 0xAC, 0xBC, 0x5C, 0x0B, 0xD2, 0x51, + 0x0C, 0x68, 0x0D, 0x63, 0xFA, 0x7B, 0x5C, 0x0B, + 0x97, 0x93, 0x06, 0xB0, 0x5C, 0xD2, 0xC9, 0x35, + 0x89, 0x1B, 0x41, 0xAF, 0x1D, 0x9C, 0xA9, 0x32 + }, + { + 0x2A, 0x85, 0xB7, 0x70, 0x6A, 0xB9, 0x2B, 0xAB, + 0x43, 0x2D, 0x84, 0x3D, 0x58, 0x7D, 0x84, 0x12, + 0x29, 0x18, 0xAC, 0xE8, 0x88, 0x64, 0x21, 0xE1, + 0xE3, 0xD7, 0x82, 0x76, 0x22, 0xBC, 0x5D, 0x6C + }, + { + 0xA7, 0xAC, 0xD6, 0xB0, 0xA7, 0xA7, 0x37, 0xD9, + 0x7B, 0x88, 0x64, 0x75, 0xFB, 0xB4, 0x77, 0x07, + 0x11, 0xF1, 0x5B, 0xC8, 0x8A, 0xBD, 0x2C, 0x4F, + 0x45, 0xEE, 0xE6, 0x48, 0x0F, 0x70, 0x53, 0x65 + }, + { + 0xD8, 0x1A, 0xE0, 0xDF, 0x53, 0xCB, 0xCA, 0x53, + 0x50, 0x32, 0xAC, 0x3D, 0x99, 0xFA, 0x42, 0xEC, + 0x95, 0x24, 0xF1, 0x15, 0x80, 0x5A, 0x36, 0xBF, + 0xB8, 0x60, 0xE5, 0x09, 0x52, 0xEC, 0xAC, 0x60 + }, + { + 0x15, 0x3C, 0x05, 0x42, 0xD9, 0x60, 0xC4, 0xDC, + 0x6E, 0xD8, 0x03, 0x08, 0xB3, 0x8A, 0x40, 0x46, + 0xAF, 0x00, 0x6C, 0xF9, 0xBF, 0x83, 0x48, 0x10, + 0xF5, 0x33, 0x84, 0xA8, 0x3B, 0xAC, 0x2C, 0xA8 + }, + { + 0x9B, 0xE9, 0xB7, 0xD2, 0xA5, 0xA4, 0x7F, 0x80, + 0x88, 0x94, 0x8D, 0x56, 0x5E, 0x8C, 0x25, 0x55, + 0x03, 0x3C, 0xF8, 0xE6, 0x1B, 0x90, 0x94, 0x59, + 0x95, 0xA6, 0x18, 0xAA, 0xF7, 0x85, 0xC8, 0x08 + }, + { + 0xFD, 0x4E, 0x60, 0xBB, 0x62, 0x88, 0x4A, 0xF9, + 0xB7, 0x48, 0x98, 0x73, 0xED, 0xCB, 0x9F, 0xFA, + 0x63, 0x3A, 0x1B, 0xB4, 0x1A, 0x2E, 0xC8, 0x4C, + 0xEE, 0x63, 0x38, 0x72, 0xDF, 0xC1, 0x94, 0x7E + }, + { + 0x48, 0xA6, 0xE3, 0xF4, 0x71, 0x1B, 0x87, 0x47, + 0x72, 0xFB, 0x37, 0xB6, 0x9B, 0x7F, 0x6F, 0xB3, + 0x89, 0xA1, 0x3E, 0x62, 0x23, 0x69, 0x79, 0xBC, + 0xC6, 0xB9, 0x22, 0xF3, 0xB8, 0xED, 0xDD, 0x97 + }, + { + 0xE7, 0x91, 0x9B, 0xA8, 0xA3, 0x45, 0x0E, 0x3E, + 0x67, 0xF2, 0x2C, 0x34, 0xC1, 0x98, 0x71, 0xEB, + 0xB6, 0xDF, 0xF8, 0x0E, 0xF8, 0xDB, 0xA1, 0x5A, + 0xCE, 0x28, 0xF9, 0xE8, 0x1F, 0xEC, 0xEC, 0xED + }, + { + 0x54, 0xE6, 0x50, 0xB2, 0x08, 0x73, 0x20, 0x70, + 0xBC, 0xC9, 0x5F, 0xA8, 0xAC, 0xDC, 0x42, 0x85, + 0xE1, 0x9A, 0x50, 0x56, 0x69, 0xEE, 0x4D, 0x5F, + 0xFB, 0x82, 0x20, 0xAB, 0x69, 0x5D, 0x26, 0x08 + }, + { + 0xD7, 0xF1, 0x42, 0x27, 0x89, 0xDE, 0xCC, 0xEE, + 0xDD, 0xD0, 0x76, 0xB9, 0x98, 0xE7, 0x58, 0x66, + 0x00, 0x70, 0xD8, 0x3D, 0x24, 0x8A, 0x32, 0x25, + 0xF3, 0x37, 0x98, 0x7F, 0x56, 0xAF, 0xB3, 0x1D + }, + { + 0xC5, 0xCA, 0xCE, 0x9C, 0x29, 0xC3, 0xB6, 0x5B, + 0x66, 0x1F, 0x9D, 0xFD, 0x3D, 0x5D, 0xEE, 0x67, + 0x44, 0x8D, 0x98, 0xE1, 0x33, 0x06, 0x06, 0x1D, + 0x23, 0x81, 0x32, 0xF3, 0x86, 0x6F, 0xE9, 0x58 + }, + { + 0x6A, 0x46, 0x43, 0x75, 0x71, 0x70, 0x85, 0x0A, + 0x5E, 0x99, 0xEB, 0x92, 0xC4, 0xE3, 0x55, 0xA3, + 0x35, 0x4C, 0x3A, 0xD0, 0xF6, 0x9C, 0x1C, 0x61, + 0x14, 0x45, 0x70, 0xDA, 0xFE, 0xCB, 0xF7, 0x5E + }, + { + 0xA3, 0xE7, 0x41, 0xB9, 0x4A, 0x3B, 0xCA, 0x1F, + 0x06, 0x26, 0x6D, 0x79, 0xD1, 0x51, 0xE7, 0xAA, + 0x03, 0x81, 0x1E, 0x47, 0x59, 0x15, 0xF9, 0x57, + 0xBC, 0xC0, 0xE6, 0xC0, 0xC0, 0xCC, 0x41, 0x74 + }, + { + 0xDA, 0x13, 0x32, 0x20, 0xC4, 0x2B, 0x0C, 0x7C, + 0x0C, 0x42, 0x09, 0x67, 0x74, 0xF6, 0x7E, 0x17, + 0xAA, 0x4F, 0xD3, 0x76, 0xFB, 0x86, 0x66, 0xF8, + 0xE5, 0xA3, 0x50, 0x63, 0x39, 0xAC, 0x93, 0x2E + }, + { + 0x0E, 0xC6, 0x6E, 0x62, 0x6E, 0xB6, 0xCF, 0xED, + 0xE0, 0x1C, 0x4B, 0x0B, 0xAC, 0x04, 0xB0, 0xD3, + 0xE0, 0x58, 0x5A, 0x90, 0x78, 0x10, 0x97, 0x0B, + 0x6C, 0xA4, 0xC0, 0xE3, 0xDC, 0x30, 0x48, 0x41 + }, + { + 0x66, 0x26, 0x7A, 0x35, 0x9B, 0x3E, 0x84, 0xA3, + 0x54, 0x1B, 0x5C, 0xC8, 0xC6, 0x7A, 0xA5, 0x22, + 0xC9, 0x59, 0xF1, 0xF3, 0x27, 0x52, 0xD0, 0xB7, + 0x14, 0x3D, 0xA9, 0xA3, 0x86, 0xC5, 0xC1, 0x7C + }, + { + 0x20, 0x71, 0x86, 0x48, 0xE2, 0x38, 0x53, 0x3C, + 0xE6, 0x39, 0x0A, 0x38, 0xC5, 0xD3, 0xFB, 0x7A, + 0x51, 0x4E, 0x95, 0x93, 0xC2, 0xDC, 0x9F, 0xBB, + 0xFF, 0x10, 0x0A, 0x46, 0xFD, 0xA7, 0xC7, 0x1C + }, + { + 0x84, 0xF5, 0x75, 0xE0, 0xED, 0xF1, 0xEE, 0xDF, + 0xAF, 0x6D, 0x45, 0xF1, 0x7A, 0xAC, 0xD5, 0xB5, + 0x7E, 0x86, 0x9B, 0x58, 0xD9, 0x59, 0xD8, 0xDD, + 0x31, 0x80, 0xBA, 0x65, 0x13, 0xA1, 0x1D, 0xA8 + }, + { + 0x3D, 0xB3, 0x65, 0x37, 0x86, 0xCE, 0x35, 0x1D, + 0x66, 0x32, 0x5D, 0xB6, 0xCE, 0x15, 0x35, 0xEA, + 0xF6, 0xB2, 0x13, 0xE6, 0x9A, 0xEF, 0x18, 0xBC, + 0x76, 0xDC, 0x51, 0x30, 0xE3, 0x4B, 0x9B, 0xA3 + }, + { + 0x2E, 0x1D, 0xBB, 0x7D, 0x16, 0xD9, 0x2A, 0x35, + 0x50, 0x6F, 0xB4, 0x9E, 0x60, 0xA9, 0xE8, 0xC3, + 0x86, 0x9E, 0xB0, 0x33, 0x83, 0x53, 0x24, 0x83, + 0x4E, 0xE7, 0x50, 0xFA, 0xB1, 0x35, 0xBC, 0xE5 + }, + { + 0x3C, 0x5F, 0xF7, 0x14, 0x7F, 0x89, 0x5A, 0x5A, + 0xFA, 0x7E, 0x89, 0x6B, 0x48, 0x70, 0x7C, 0x14, + 0x12, 0x43, 0xD5, 0x01, 0xCD, 0x74, 0x06, 0xB5, + 0x37, 0x0C, 0x37, 0xCE, 0x5D, 0xF5, 0x2E, 0x9E + }, + { + 0x2D, 0xE1, 0x02, 0x7F, 0x98, 0xD1, 0x58, 0x50, + 0xD1, 0xA8, 0x00, 0xD3, 0xC4, 0x98, 0x18, 0xDC, + 0xE1, 0xE1, 0xF2, 0x59, 0x20, 0x91, 0xBD, 0xE8, + 0x7B, 0xCF, 0x63, 0xA9, 0x90, 0x59, 0xE6, 0x4B + }, + { + 0xD5, 0x56, 0x85, 0x3E, 0x59, 0x5D, 0xE2, 0x78, + 0xBF, 0xD9, 0xD6, 0x88, 0x89, 0x69, 0xF3, 0x96, + 0x6D, 0x79, 0x52, 0x05, 0xCD, 0x88, 0x87, 0x87, + 0xBA, 0x23, 0xB1, 0xA0, 0x16, 0x81, 0xBE, 0x4F + }, + { + 0xF5, 0xD1, 0x05, 0xBD, 0xE5, 0xB4, 0x85, 0x9D, + 0x77, 0x39, 0xD1, 0xA1, 0x2C, 0x6F, 0x32, 0xA3, + 0xC7, 0xEA, 0x4C, 0x82, 0x44, 0xFE, 0xAC, 0x7D, + 0xA2, 0xA2, 0x08, 0x9D, 0xE4, 0xC9, 0x02, 0x66 + }, + { + 0xA2, 0x1A, 0xA6, 0x69, 0xAB, 0xE7, 0x55, 0x5E, + 0x06, 0x1F, 0x26, 0x3A, 0x6B, 0x78, 0xD9, 0x7E, + 0xA4, 0x71, 0x55, 0x6E, 0xC2, 0xF2, 0xA3, 0x54, + 0x1F, 0x84, 0xAB, 0x7C, 0x0E, 0x58, 0x8C, 0xBD + }, + { + 0xA9, 0x9A, 0x39, 0xC7, 0xB9, 0x39, 0x97, 0x95, + 0xDC, 0x4A, 0xB7, 0xAC, 0xF6, 0x8E, 0x33, 0xE9, + 0x92, 0x1B, 0x7E, 0x2A, 0xD3, 0x55, 0xA4, 0x8C, + 0x8C, 0x71, 0xAA, 0xCE, 0x17, 0x18, 0x5A, 0x11 + }, + { + 0x9A, 0x36, 0xFA, 0x66, 0x43, 0x48, 0x04, 0x6D, + 0x09, 0x6B, 0xF7, 0x55, 0xCF, 0x98, 0xD7, 0x9C, + 0x6C, 0x2B, 0x28, 0x47, 0x3C, 0x25, 0xE8, 0x0D, + 0x4F, 0xEF, 0x9F, 0x92, 0xB9, 0xB4, 0x32, 0xE3 + }, + { + 0x0F, 0xDF, 0x09, 0xAB, 0x02, 0x4F, 0x6B, 0xA8, + 0xA6, 0x55, 0x35, 0x7A, 0x15, 0xBF, 0xD3, 0x8D, + 0x90, 0xEA, 0x9D, 0xD9, 0x7C, 0xA4, 0xB7, 0x3A, + 0xA4, 0x66, 0xC6, 0xFB, 0xAB, 0x45, 0x36, 0xD0 + }, + { + 0xAB, 0xB9, 0x0A, 0xFE, 0xD1, 0xA8, 0x95, 0x40, + 0x8B, 0x4F, 0x74, 0xE1, 0x28, 0xBD, 0x06, 0x7A, + 0xC2, 0x91, 0x20, 0x77, 0x21, 0xEA, 0xFC, 0xBD, + 0xDD, 0x14, 0xD8, 0x6B, 0x5D, 0x74, 0xD3, 0xB7 + }, + { + 0xFA, 0xCD, 0x2B, 0x8F, 0x15, 0xB1, 0x04, 0xB2, + 0x23, 0x0D, 0xBE, 0x06, 0xE1, 0x26, 0x8B, 0x0E, + 0x55, 0x2E, 0xC3, 0xD8, 0x26, 0xAE, 0xDB, 0x8C, + 0xB8, 0x48, 0x46, 0xE6, 0xDD, 0x8A, 0xC5, 0xEF + }, + { + 0x84, 0xDF, 0xC1, 0x0A, 0xF4, 0x0D, 0xD3, 0xB1, + 0xFA, 0x13, 0xB7, 0x64, 0x34, 0xD0, 0x6C, 0x1B, + 0xF7, 0x66, 0x4A, 0xB8, 0x70, 0x47, 0x3A, 0x2B, + 0xD0, 0x93, 0x85, 0xD1, 0x2D, 0x74, 0xB2, 0x87 + }, + { + 0x03, 0x6A, 0xAC, 0xBD, 0x62, 0x4B, 0x01, 0xA3, + 0x2D, 0x13, 0x1A, 0x0A, 0x34, 0x3A, 0x9C, 0x75, + 0xB1, 0x2A, 0x2D, 0x14, 0xDA, 0xBA, 0x21, 0x0F, + 0x90, 0xCF, 0x99, 0xFB, 0x55, 0x0C, 0x36, 0x64 + }, + { + 0x1B, 0xEA, 0xF3, 0xAC, 0xB0, 0x94, 0xC6, 0xF7, + 0x5C, 0x13, 0xB3, 0x73, 0x7E, 0x21, 0x8C, 0xB9, + 0xEE, 0x0C, 0xBC, 0xA9, 0x9E, 0x52, 0x5D, 0x70, + 0xFB, 0x38, 0x8C, 0x9D, 0xC0, 0xD2, 0x65, 0x25 + }, + { + 0x54, 0xD7, 0xF9, 0x95, 0x1D, 0x01, 0x14, 0xE0, + 0x56, 0xB5, 0xF5, 0xAD, 0x1F, 0x38, 0x02, 0x6A, + 0x07, 0xF2, 0x40, 0x11, 0x83, 0x30, 0xDC, 0x81, + 0x04, 0x9E, 0x35, 0x2D, 0x93, 0xF3, 0xCE, 0x6D + }, + { + 0x94, 0x48, 0x42, 0x70, 0x3A, 0xFD, 0x55, 0x51, + 0xAD, 0x71, 0x96, 0xBB, 0xD3, 0x08, 0x05, 0xAB, + 0x95, 0x10, 0x18, 0xA5, 0x50, 0x7B, 0x74, 0x47, + 0x25, 0x82, 0x15, 0xEE, 0xA3, 0x43, 0xC0, 0x8F + }, + { + 0xFE, 0x7A, 0x0C, 0x4D, 0x05, 0xB0, 0xAB, 0x44, + 0x26, 0x3C, 0x66, 0x29, 0xE5, 0xC1, 0x13, 0x4B, + 0xA4, 0x57, 0xDD, 0x8D, 0x3A, 0xA2, 0xA5, 0x0C, + 0xA3, 0x15, 0x5E, 0x64, 0x36, 0xBC, 0xDC, 0x74 + }, + { + 0xE0, 0x9C, 0x8F, 0xA6, 0xAA, 0x87, 0xF0, 0xD8, + 0xA2, 0xA5, 0x1E, 0x26, 0x56, 0xAC, 0x12, 0xC4, + 0x2C, 0xAD, 0x0D, 0xDC, 0xB7, 0x21, 0x0E, 0x86, + 0xB1, 0x30, 0xD7, 0x32, 0xEE, 0xDB, 0x34, 0x71 + }, + { + 0x9A, 0x7E, 0xEC, 0x3E, 0xBA, 0xB1, 0x60, 0x24, + 0xA2, 0x40, 0x98, 0x78, 0x79, 0x5C, 0x37, 0xC1, + 0xDD, 0x12, 0x56, 0x84, 0xC0, 0x80, 0xDE, 0x68, + 0x61, 0xB0, 0xA4, 0x08, 0x49, 0xA1, 0x66, 0x0A + }, + { + 0x3D, 0x57, 0x93, 0xB3, 0x0A, 0x25, 0xFD, 0x6D, + 0x50, 0xE1, 0x76, 0xDB, 0x73, 0xC1, 0xD1, 0xD0, + 0x94, 0xE8, 0x70, 0x41, 0x06, 0x11, 0x98, 0x2C, + 0x2E, 0xBB, 0x42, 0x4E, 0x28, 0x3A, 0x2E, 0xD7 + }, + { + 0xC7, 0xA5, 0xCA, 0x41, 0xB8, 0x08, 0xB7, 0xF0, + 0x96, 0x03, 0x2D, 0x1F, 0xC1, 0x01, 0xAD, 0xF3, + 0x6C, 0xD3, 0xD6, 0x65, 0x44, 0x4A, 0xB3, 0xCB, + 0xBC, 0x23, 0xC6, 0x27, 0xF2, 0x5C, 0xCD, 0x02 + }, + { + 0x4D, 0x9D, 0x4B, 0xAD, 0x06, 0x7C, 0x0A, 0xAB, + 0x9B, 0xC4, 0x27, 0x22, 0x8F, 0x7F, 0x06, 0x52, + 0x61, 0x43, 0x32, 0x6C, 0xAD, 0x00, 0x6F, 0xB9, + 0x0D, 0x61, 0xC7, 0xD2, 0x26, 0xC3, 0x39, 0xF5 + }, + { + 0x01, 0x29, 0xDA, 0x8C, 0xC0, 0xB0, 0xDF, 0xF9, + 0x5C, 0x84, 0xB4, 0xB1, 0x41, 0x0E, 0xEF, 0x29, + 0x84, 0x30, 0x15, 0x9F, 0x40, 0xD1, 0xCA, 0xE3, + 0xE7, 0x50, 0x49, 0x73, 0x29, 0xB8, 0x3E, 0x9D + }, + { + 0xD9, 0xD8, 0xDE, 0x73, 0xED, 0x36, 0x53, 0x3D, + 0xAB, 0x5A, 0xDD, 0x8D, 0x73, 0xF7, 0x69, 0x9D, + 0x14, 0x6F, 0x92, 0xCF, 0xDE, 0xB7, 0x13, 0xDD, + 0xF6, 0x57, 0x60, 0xF8, 0xC5, 0x85, 0x47, 0x94 + }, + { + 0x85, 0x6B, 0x7F, 0x4C, 0x68, 0xDC, 0x50, 0x07, + 0xBE, 0xAC, 0xF4, 0xDF, 0x39, 0xC5, 0xA6, 0xC3, + 0xA3, 0x36, 0x52, 0x19, 0x57, 0x21, 0xDF, 0x94, + 0x89, 0xF4, 0x58, 0x07, 0xAA, 0x24, 0x2E, 0x2A + }, + { + 0xEB, 0xB8, 0x4D, 0x59, 0x2E, 0x90, 0x23, 0xF6, + 0xE0, 0x33, 0x17, 0x6D, 0x42, 0x40, 0xC0, 0x43, + 0x21, 0xDC, 0x0B, 0x6E, 0xC0, 0x14, 0xBC, 0x69, + 0xAD, 0x33, 0x24, 0x99, 0x08, 0x5C, 0xA5, 0x91 + }, + { + 0x4B, 0x8A, 0x05, 0x69, 0xB7, 0x02, 0x35, 0x87, + 0x4D, 0x75, 0x1C, 0x04, 0x60, 0xD1, 0x4E, 0xD2, + 0xFF, 0x9F, 0xA9, 0x98, 0xCB, 0x40, 0x35, 0x79, + 0xF9, 0xDA, 0xDF, 0x3B, 0xC9, 0x8F, 0x0C, 0xD9 + }, + { + 0x60, 0xF5, 0xDB, 0x3E, 0xFB, 0xDD, 0x2E, 0x06, + 0x54, 0xED, 0x82, 0x18, 0xCE, 0x1B, 0x37, 0xB5, + 0xB7, 0x1F, 0x68, 0xF4, 0x20, 0xD2, 0x61, 0xDC, + 0x46, 0x25, 0x9C, 0xED, 0x40, 0x5E, 0x03, 0x7E + }, + { + 0xC1, 0xF9, 0xF9, 0x94, 0x54, 0x6A, 0x6D, 0xD4, + 0x5E, 0x79, 0xAA, 0x04, 0x76, 0x02, 0x67, 0x7E, + 0xF6, 0xAB, 0x82, 0xAA, 0x6B, 0x09, 0x6E, 0x23, + 0xE2, 0x51, 0xA9, 0xAD, 0xDD, 0xA2, 0x16, 0xF9 + }, + { + 0xA1, 0x86, 0x7C, 0xBA, 0x5B, 0x3C, 0x76, 0x26, + 0x07, 0x63, 0x0B, 0xC5, 0xCF, 0xDF, 0x9D, 0xEA, + 0x58, 0x7A, 0x71, 0x6D, 0x44, 0xF4, 0xEE, 0x62, + 0x18, 0x93, 0x38, 0x7B, 0x11, 0x10, 0xC1, 0xA8 + }, + { + 0x51, 0x97, 0xC9, 0xB9, 0xE5, 0x6F, 0xB0, 0x42, + 0x71, 0x37, 0x5C, 0x1E, 0x55, 0x0A, 0x3C, 0xD4, + 0xC4, 0x17, 0x61, 0x11, 0x86, 0x2C, 0x9F, 0x5C, + 0x4D, 0x79, 0x8F, 0x70, 0x66, 0x8A, 0xEC, 0x21 + }, + { + 0xD7, 0x92, 0x48, 0x91, 0x67, 0xAC, 0x6E, 0xD7, + 0x65, 0x31, 0x86, 0x2F, 0x2B, 0xBD, 0xBC, 0x03, + 0x4D, 0xC3, 0xD2, 0x0B, 0xAE, 0x72, 0x9C, 0xEB, + 0x41, 0x29, 0x95, 0x12, 0xC1, 0x89, 0x25, 0x82 + }, + { + 0x93, 0x88, 0x1B, 0x4C, 0x4D, 0xFF, 0x3B, 0x1B, + 0x8D, 0x8F, 0x8F, 0xD4, 0x6C, 0xA0, 0xBC, 0xC8, + 0x8D, 0xFE, 0xB3, 0x51, 0x2B, 0x22, 0xFE, 0xA7, + 0xF2, 0xD4, 0xCD, 0xFA, 0x0F, 0xD2, 0xCD, 0xDD + }, + { + 0xFE, 0x67, 0xCC, 0x13, 0x36, 0x68, 0xCB, 0xD3, + 0x1D, 0x89, 0xEC, 0x12, 0x40, 0x75, 0x78, 0x42, + 0xB9, 0x73, 0xA8, 0xE2, 0x6E, 0xF2, 0xAD, 0x59, + 0x47, 0xE1, 0xBA, 0xFE, 0x9A, 0x0D, 0x0B, 0xE3 + }, + { + 0x53, 0xB3, 0xC2, 0x4E, 0xF7, 0xF7, 0x2D, 0x6C, + 0x0E, 0x90, 0x26, 0x6B, 0x55, 0xB7, 0x61, 0x39, + 0x38, 0xDC, 0x87, 0xD8, 0xEB, 0x82, 0x4E, 0x4E, + 0x4A, 0x9E, 0xFE, 0x06, 0x62, 0xFB, 0x0B, 0xAC + }, + { + 0x18, 0x47, 0xAF, 0xDC, 0xED, 0x5C, 0xA7, 0x5C, + 0xFB, 0x3B, 0x3A, 0x8A, 0x0B, 0xA7, 0x81, 0x4B, + 0xEE, 0xC5, 0x3F, 0xC9, 0x4E, 0xA5, 0xE1, 0xF8, + 0x6A, 0x73, 0x3C, 0x11, 0x78, 0x59, 0xA9, 0x54 + }, + { + 0x0E, 0xDB, 0x3D, 0x47, 0x40, 0x32, 0x83, 0xD4, + 0x39, 0x90, 0xE2, 0xE4, 0xBB, 0x70, 0xC3, 0x73, + 0xC6, 0x9F, 0x69, 0x17, 0x1A, 0xB2, 0x36, 0x3B, + 0x12, 0x23, 0x7B, 0x75, 0x25, 0x96, 0x52, 0x7E + }, + { + 0x07, 0x17, 0xF5, 0xDD, 0xB0, 0x9F, 0x78, 0xA3, + 0x27, 0xA2, 0x55, 0x97, 0x1F, 0xFE, 0x55, 0x92, + 0x3E, 0xD1, 0xAB, 0x4A, 0x4B, 0xB8, 0xC5, 0xF4, + 0x5B, 0xC5, 0x31, 0x1B, 0x85, 0xB4, 0x1A, 0x3F + }, + { + 0xD0, 0x53, 0x36, 0xD4, 0x17, 0xF1, 0xBF, 0x25, + 0xCC, 0xDA, 0x45, 0x73, 0x6F, 0x65, 0x16, 0xA7, + 0x98, 0x16, 0x2D, 0x76, 0xA0, 0xA4, 0xCE, 0xA4, + 0xCF, 0xBE, 0xB9, 0xD2, 0xF4, 0x3D, 0xC1, 0xBE + }, + { + 0x32, 0xA9, 0x45, 0x92, 0xE3, 0xB2, 0x81, 0xEA, + 0x3F, 0xD9, 0x2E, 0x05, 0x5C, 0xF8, 0x7D, 0x6B, + 0x98, 0x6F, 0xCB, 0x03, 0xBB, 0x1C, 0xFA, 0x4D, + 0x19, 0xEE, 0xD4, 0xC8, 0x19, 0xD8, 0xFF, 0xF3 + }, + { + 0x52, 0xF9, 0x27, 0x25, 0xDD, 0xE7, 0x0E, 0xF0, + 0x70, 0xF7, 0x66, 0xE4, 0x66, 0xC5, 0x6E, 0x21, + 0x57, 0xFC, 0x0A, 0xC3, 0xAC, 0x55, 0x36, 0xC0, + 0x8D, 0xC5, 0xC6, 0x74, 0x5E, 0xEA, 0xA4, 0x48 + }, + { + 0xC7, 0xEC, 0x42, 0x2B, 0x79, 0xAD, 0x70, 0xB7, + 0xF9, 0x05, 0x39, 0xB4, 0x45, 0x2D, 0xDE, 0x6E, + 0x33, 0x7D, 0xDB, 0xEC, 0x4D, 0x33, 0xFF, 0x00, + 0x4E, 0x49, 0xCA, 0x41, 0x6D, 0xDB, 0x4A, 0x36 + }, + { + 0xD8, 0x1A, 0xB0, 0x18, 0x30, 0xF4, 0x39, 0x43, + 0x8D, 0x02, 0x06, 0x7F, 0xC8, 0xCF, 0x41, 0xF2, + 0x1E, 0x12, 0x1B, 0x41, 0x4E, 0xBC, 0xAE, 0xDF, + 0xFA, 0x43, 0xF1, 0xFA, 0x04, 0xC2, 0x93, 0xEA + }, + { + 0x3E, 0x51, 0xDE, 0xDA, 0xFB, 0x7C, 0xCE, 0x34, + 0xC1, 0x21, 0xA9, 0xE3, 0x1F, 0x0D, 0x97, 0x6B, + 0x57, 0x58, 0x72, 0x2A, 0xAA, 0x48, 0x23, 0xB5, + 0xBE, 0x68, 0xA7, 0x19, 0x18, 0xCA, 0x0D, 0xEB + }, + { + 0x11, 0x0E, 0x05, 0xFE, 0x11, 0x20, 0xB8, 0xCD, + 0x3A, 0xCB, 0x95, 0x9C, 0x6F, 0x82, 0x0E, 0x02, + 0xDE, 0x85, 0x57, 0x0F, 0x8A, 0x1B, 0xD4, 0xCC, + 0xE4, 0x77, 0xB4, 0x0D, 0xA4, 0x1B, 0xC9, 0x2A + }, + { + 0x9F, 0x45, 0x9C, 0x12, 0x40, 0x9E, 0x5C, 0x4A, + 0x1C, 0xBE, 0x63, 0x07, 0xD5, 0x8A, 0xC0, 0xA5, + 0xD9, 0x16, 0x3A, 0x2A, 0xFA, 0xB1, 0x35, 0x90, + 0x67, 0xED, 0xCC, 0x48, 0xF3, 0xD7, 0xF8, 0x5C + }, + { + 0x64, 0xB0, 0xA5, 0x6B, 0xF1, 0x3A, 0xD6, 0xD7, + 0xCF, 0x3D, 0x29, 0xE9, 0x8F, 0x99, 0xB2, 0xC7, + 0x8A, 0x1F, 0x0A, 0x23, 0x21, 0x56, 0x09, 0xC4, + 0x03, 0xAB, 0xD6, 0x63, 0x54, 0x7B, 0xCD, 0x21 + }, + { + 0x19, 0x28, 0x62, 0x1D, 0xA7, 0x2C, 0x05, 0x45, + 0xB6, 0xD3, 0xEB, 0x5C, 0x66, 0x50, 0x15, 0x8B, + 0x83, 0x9A, 0x9D, 0x44, 0x23, 0x09, 0x22, 0xAB, + 0xAE, 0x91, 0x6B, 0x2D, 0x45, 0x32, 0x6F, 0x4F + }, + { + 0x93, 0x35, 0x2F, 0x01, 0x7F, 0x8D, 0x92, 0xFA, + 0x86, 0xCC, 0xE0, 0x58, 0x45, 0x0E, 0xF4, 0x57, + 0x87, 0x31, 0x61, 0x2E, 0x29, 0xA4, 0x03, 0x63, + 0xFA, 0xEC, 0x5A, 0xC5, 0x7D, 0x80, 0x76, 0xFF + }, + { + 0xC2, 0xF0, 0x87, 0xE4, 0x62, 0xA2, 0xFC, 0x93, + 0xB5, 0xBE, 0x0E, 0xD5, 0x59, 0x03, 0x85, 0xD2, + 0xE7, 0xAF, 0x1F, 0x91, 0xE6, 0xC6, 0xF0, 0x00, + 0x0D, 0x15, 0x5F, 0x6F, 0xB6, 0xD1, 0x27, 0x54 + }, + { + 0x43, 0x6E, 0xA5, 0x3C, 0x8B, 0xC1, 0xDF, 0xE0, + 0x24, 0x91, 0x2F, 0x12, 0xA4, 0x79, 0x1B, 0x88, + 0x7C, 0x6A, 0xB4, 0x71, 0xF7, 0x64, 0x56, 0x9C, + 0xB5, 0xAB, 0x0A, 0x13, 0x7A, 0x57, 0xDC, 0x48 + }, + { + 0x25, 0xDE, 0x52, 0x01, 0x55, 0xF0, 0x52, 0x69, + 0xC7, 0xBE, 0x83, 0xB1, 0xF4, 0x53, 0x25, 0x56, + 0x94, 0x07, 0x6B, 0xF6, 0xB6, 0xD8, 0x89, 0xC5, + 0x54, 0xEE, 0x05, 0x66, 0x70, 0xAD, 0xB3, 0x90 + }, + { + 0x97, 0x19, 0x7B, 0x9C, 0x3D, 0x19, 0xBB, 0x0F, + 0xE4, 0x56, 0x03, 0xB7, 0x61, 0x26, 0x0E, 0xFA, + 0x4E, 0x2A, 0x0C, 0x67, 0xA2, 0x97, 0xB6, 0xF6, + 0xA8, 0xB3, 0x86, 0xDE, 0xF0, 0x86, 0xA0, 0x58 + }, + { + 0xBE, 0x70, 0x7F, 0x09, 0x3E, 0xAD, 0x84, 0x13, + 0xCD, 0x24, 0x45, 0x0C, 0x74, 0xB7, 0x4C, 0x95, + 0x0F, 0xFB, 0x52, 0x84, 0x6E, 0x6E, 0xBC, 0xAA, + 0x6F, 0xFD, 0x55, 0xCD, 0x63, 0x45, 0x88, 0x6A + }, + { + 0x90, 0x80, 0x6F, 0xD1, 0xC0, 0x81, 0x10, 0x96, + 0xB0, 0x12, 0x8E, 0xEB, 0x11, 0x41, 0xDB, 0x04, + 0x46, 0xBA, 0x2C, 0xC4, 0x94, 0xDD, 0x91, 0x5C, + 0xA2, 0xB9, 0xED, 0xD8, 0x24, 0xA1, 0x08, 0x69 + }, + { + 0xD8, 0x3F, 0x60, 0xF4, 0xBB, 0x6C, 0x31, 0xCC, + 0xAF, 0x40, 0x6D, 0x4A, 0x53, 0x7F, 0xA0, 0xDA, + 0x12, 0xBD, 0xDA, 0x64, 0x7A, 0x2B, 0x1A, 0xA1, + 0xE8, 0xEF, 0x8E, 0x0B, 0xCD, 0x1A, 0x56, 0xFE + }, + { + 0x80, 0x8B, 0xEB, 0xC1, 0x4B, 0x6D, 0x9E, 0xF6, + 0x0B, 0x34, 0x21, 0xE4, 0xBE, 0x7D, 0x28, 0x75, + 0xB3, 0xA6, 0x79, 0x35, 0xD9, 0x8A, 0xDD, 0x9D, + 0xD8, 0x29, 0x08, 0x2C, 0x63, 0x3C, 0x33, 0x14 + }, + { + 0x65, 0x44, 0x9F, 0xC6, 0x72, 0x5B, 0x1A, 0x1A, + 0x94, 0x62, 0x49, 0xB4, 0x30, 0x16, 0x50, 0xB1, + 0xB0, 0x30, 0x40, 0x7E, 0x6B, 0xE6, 0xC4, 0x8C, + 0xF7, 0xE6, 0xC9, 0x8B, 0xD1, 0xE0, 0x08, 0x4D + }, + { + 0x73, 0x63, 0x76, 0xE4, 0x90, 0x9A, 0x99, 0xE5, + 0xCB, 0xCC, 0xAE, 0x8F, 0xDE, 0x9A, 0x25, 0x3B, + 0x50, 0x5C, 0x1D, 0x09, 0x20, 0x61, 0xFD, 0x70, + 0x05, 0x00, 0x3E, 0xF5, 0xC5, 0xCC, 0x7F, 0x60 + }, + { + 0x23, 0x0A, 0x60, 0xCF, 0x7E, 0x6D, 0x54, 0x56, + 0x82, 0x37, 0xCF, 0x29, 0x44, 0xEE, 0x32, 0xCB, + 0xF5, 0xE1, 0x4C, 0x4C, 0xAA, 0x31, 0xBA, 0x2C, + 0x48, 0x03, 0x44, 0xCD, 0x6A, 0x24, 0xDC, 0x5A + }, + { + 0xF4, 0x40, 0xFD, 0x7B, 0xB5, 0xFA, 0x84, 0x7D, + 0xD4, 0x33, 0xD5, 0x6C, 0xAD, 0x06, 0xF4, 0x59, + 0x87, 0x89, 0xF6, 0x75, 0x8C, 0x34, 0xA6, 0xE1, + 0x37, 0x35, 0x21, 0xCD, 0x3B, 0x2C, 0xCC, 0xAD + }, + { + 0xAE, 0x04, 0x74, 0x87, 0x80, 0xA8, 0xC7, 0x42, + 0x4C, 0x21, 0xC0, 0x06, 0x0B, 0x58, 0xBA, 0xBB, + 0xBB, 0xBE, 0x3C, 0xF3, 0xF1, 0xB3, 0xE4, 0xA1, + 0x06, 0xD0, 0xA6, 0xC1, 0xD8, 0x65, 0x11, 0xC9 + }, + { + 0xBC, 0x21, 0x7A, 0xEA, 0x32, 0x48, 0x7F, 0x6F, + 0x08, 0x93, 0xAB, 0xB1, 0x57, 0x04, 0xE5, 0x01, + 0xEA, 0x7B, 0x6E, 0x1B, 0x3D, 0xA4, 0xC1, 0x0D, + 0x5B, 0x4C, 0xC8, 0xA9, 0x11, 0xD6, 0x36, 0x58 + }, + { + 0xCF, 0x38, 0x5A, 0xF1, 0x60, 0xFC, 0xDA, 0x12, + 0xA0, 0xC1, 0x7C, 0x04, 0x7D, 0x19, 0x6B, 0x6F, + 0xB2, 0x40, 0xCB, 0xE2, 0x12, 0x3D, 0x54, 0x36, + 0x7B, 0x13, 0x71, 0x10, 0x4D, 0x68, 0xFC, 0xDB + }, + { + 0x2D, 0x1B, 0x52, 0x93, 0x6F, 0x2D, 0xAD, 0x68, + 0xEB, 0x75, 0x07, 0xE8, 0x3F, 0xB6, 0xC6, 0x80, + 0x43, 0x26, 0x96, 0x11, 0x78, 0x2A, 0xD1, 0x3A, + 0x2A, 0x7A, 0x4B, 0xBC, 0xAC, 0x45, 0xE3, 0x96 + }, + { + 0xF5, 0xA1, 0xDF, 0x11, 0xC6, 0xF0, 0xF9, 0x2D, + 0x79, 0x9B, 0x1D, 0x20, 0x61, 0x9A, 0xC2, 0x14, + 0x73, 0x85, 0xBA, 0xED, 0xBF, 0xE0, 0x7C, 0x07, + 0x6F, 0xAE, 0x60, 0x7D, 0xAE, 0x4C, 0xF6, 0x36 + }, + { + 0x9D, 0x91, 0x48, 0x66, 0xAE, 0xA5, 0x92, 0x5D, + 0x54, 0x96, 0xE2, 0x74, 0x9A, 0xD4, 0x3C, 0xA4, + 0xE3, 0xD0, 0x3E, 0xA6, 0x06, 0xA5, 0x67, 0xC9, + 0x0E, 0xE8, 0x12, 0x1D, 0x56, 0x7A, 0x8F, 0x3B + }, + { + 0xB7, 0x72, 0x39, 0xEB, 0xD9, 0xB5, 0x66, 0xF5, + 0x11, 0xEE, 0xC5, 0x85, 0xC0, 0x93, 0xDA, 0xEA, + 0xC5, 0x41, 0xBD, 0xC4, 0xA9, 0xEC, 0xB0, 0xC8, + 0x08, 0xB7, 0xE5, 0xF5, 0x2F, 0x11, 0x91, 0x2B + }, + { + 0x2B, 0x4F, 0x92, 0x6F, 0x0D, 0x63, 0x53, 0x24, + 0x15, 0xCB, 0x7C, 0xFE, 0xE5, 0x79, 0x52, 0xDC, + 0x4B, 0xC6, 0x4F, 0xD0, 0x1F, 0x72, 0xE1, 0xF9, + 0x25, 0xA9, 0xD8, 0xC0, 0x06, 0x2B, 0x5F, 0xE3 + }, + { + 0x3E, 0x11, 0x34, 0xBD, 0x9F, 0x19, 0xCA, 0xF8, + 0x87, 0xAF, 0x28, 0x49, 0xDE, 0x21, 0xB5, 0x0B, + 0x1B, 0x96, 0x23, 0x8E, 0x52, 0x10, 0x2A, 0xE0, + 0x84, 0x83, 0x20, 0x1F, 0x79, 0x9E, 0xE0, 0xEE + }, + { + 0x3D, 0x18, 0x17, 0xD8, 0x9F, 0x6D, 0x2B, 0x8D, + 0xBF, 0x33, 0x0C, 0xEA, 0x84, 0x16, 0x87, 0x96, + 0xF2, 0x33, 0xCF, 0x53, 0x46, 0xAE, 0x24, 0xB7, + 0x71, 0x93, 0x28, 0x64, 0x96, 0x56, 0x6F, 0x5C + }, + { + 0x37, 0x83, 0x54, 0x07, 0x11, 0x60, 0x11, 0xA5, + 0xB5, 0x09, 0xD0, 0x65, 0xB9, 0x2F, 0x9A, 0x88, + 0xD8, 0x03, 0x1A, 0x81, 0x64, 0x2C, 0x40, 0xFB, + 0xAC, 0x2C, 0x2E, 0xDE, 0x83, 0x88, 0xAB, 0x94 + }, + { + 0x8C, 0x1B, 0x91, 0x08, 0x5B, 0x07, 0x27, 0xD8, + 0xC9, 0x70, 0x72, 0x87, 0xCF, 0x4A, 0xF2, 0x21, + 0xF1, 0x1F, 0xE4, 0xCD, 0x7E, 0x0D, 0xD8, 0x62, + 0xAE, 0x73, 0x09, 0xBB, 0x8A, 0x08, 0xF7, 0x29 + }, + { + 0xAD, 0x9B, 0x38, 0xDE, 0x53, 0x41, 0xAB, 0x98, + 0xB7, 0xB9, 0x2E, 0x40, 0x26, 0xE6, 0x33, 0x18, + 0xCA, 0x4B, 0xA4, 0xC7, 0x15, 0xE5, 0xCB, 0x5A, + 0x95, 0xFC, 0x94, 0x12, 0xCF, 0x39, 0xED, 0x10 + }, + { + 0x49, 0xF0, 0xB0, 0xCC, 0x7B, 0x29, 0xEB, 0x07, + 0xB3, 0x73, 0x69, 0xC7, 0x96, 0x00, 0x4A, 0x31, + 0x4B, 0x7A, 0x1F, 0xEB, 0xF5, 0x85, 0x2A, 0xE5, + 0x95, 0xCC, 0xE0, 0xBA, 0x25, 0xF7, 0x77, 0x17 + }, + { + 0x36, 0x7C, 0x01, 0x1B, 0x95, 0x2D, 0xF1, 0x4F, + 0xCE, 0xD0, 0x22, 0xB9, 0x39, 0x1C, 0xC2, 0x8C, + 0x3A, 0x9D, 0xD5, 0x5B, 0xC5, 0x06, 0xD4, 0x01, + 0x65, 0xC7, 0x26, 0x67, 0x15, 0xB3, 0xD3, 0x85 + }, + { + 0xCF, 0xFA, 0x0C, 0x9D, 0xDF, 0xE2, 0x33, 0x77, + 0xE3, 0x68, 0xF7, 0x9B, 0x18, 0x89, 0x02, 0xD8, + 0xAD, 0x43, 0x67, 0x53, 0x03, 0x9E, 0x29, 0x39, + 0xB5, 0x83, 0xCD, 0xC1, 0x1A, 0x6F, 0xC2, 0x80 + }, + { + 0x21, 0x2D, 0x55, 0x20, 0x7D, 0x23, 0xE8, 0xCE, + 0x1E, 0x6E, 0x02, 0xD7, 0x65, 0xFB, 0x50, 0xD9, + 0x51, 0x35, 0xD6, 0xCE, 0xFD, 0x54, 0x05, 0x9E, + 0x8F, 0xCF, 0x7A, 0x1A, 0x42, 0x55, 0xEB, 0x00 + }, + { + 0x1E, 0x2C, 0x90, 0x91, 0xA1, 0xC8, 0x98, 0x69, + 0x80, 0xC9, 0x6B, 0xF2, 0x46, 0x4A, 0x7B, 0x40, + 0x9B, 0x50, 0x45, 0x20, 0xA3, 0xDA, 0x15, 0x38, + 0x48, 0xC6, 0x8B, 0xD1, 0x47, 0x98, 0xF7, 0x80 + }, + { + 0x28, 0x8F, 0x3D, 0x3F, 0x2D, 0xC6, 0x1C, 0x49, + 0xD4, 0x4A, 0x31, 0xDE, 0xBD, 0x03, 0x50, 0xD9, + 0x8B, 0x7C, 0xAD, 0x95, 0x56, 0xCC, 0x0D, 0x77, + 0xA3, 0x74, 0x7D, 0x2F, 0x03, 0x82, 0xB7, 0xC6 + }, + { + 0x91, 0xFD, 0x06, 0xBF, 0x38, 0x66, 0x06, 0x35, + 0x70, 0x57, 0xE8, 0x63, 0x3F, 0xB1, 0xC6, 0x29, + 0x55, 0x6C, 0x43, 0xD0, 0x00, 0x5C, 0x1E, 0x51, + 0xB8, 0xA0, 0x93, 0xC4, 0x03, 0x37, 0x75, 0xBD + }, + { + 0x40, 0x2E, 0x75, 0x3B, 0x07, 0x0C, 0x2C, 0xCF, + 0xC3, 0x4D, 0x4C, 0xDE, 0xE5, 0xDF, 0xB2, 0xC0, + 0xB3, 0x9E, 0x53, 0x6B, 0x30, 0xFC, 0xE8, 0xF7, + 0xA5, 0x59, 0xA0, 0x93, 0xC1, 0x68, 0x6F, 0x9C + }, + { + 0x9C, 0xB0, 0x4B, 0xE2, 0x30, 0xA3, 0xE7, 0xD1, + 0xC0, 0xAF, 0xEF, 0xD9, 0x70, 0xB2, 0xC0, 0xD3, + 0xE9, 0xE6, 0x09, 0x31, 0x5E, 0x7A, 0x5E, 0xB2, + 0xA0, 0x26, 0x81, 0xFD, 0x78, 0x3D, 0x2E, 0x73 + }, + { + 0xEC, 0xD5, 0x02, 0xEA, 0x11, 0x40, 0x8B, 0x87, + 0x64, 0x49, 0x44, 0x09, 0x45, 0x0F, 0x03, 0x77, + 0xBB, 0x24, 0xCC, 0x70, 0x02, 0xAE, 0xC4, 0xC1, + 0xA4, 0xEA, 0xD6, 0x5A, 0x50, 0x90, 0x09, 0x23 + }, + { + 0x58, 0x5C, 0xFC, 0xE8, 0x0C, 0x27, 0x6B, 0x1A, + 0x0E, 0x8A, 0x1E, 0xD0, 0x3C, 0x0A, 0x9C, 0xA1, + 0x95, 0xA5, 0x2C, 0x7B, 0xD7, 0x9A, 0xC4, 0xC6, + 0xE7, 0x36, 0x76, 0x9A, 0x9F, 0xB5, 0xBD, 0x65 + }, + { + 0x64, 0x59, 0xB8, 0x8E, 0xF9, 0x8C, 0xD0, 0xF7, + 0x2B, 0x45, 0x6A, 0x1A, 0xCB, 0xAD, 0xB3, 0x3B, + 0xC3, 0xF8, 0x10, 0xD5, 0x1A, 0x17, 0xC6, 0x82, + 0xE0, 0x4D, 0x7C, 0x00, 0x5D, 0xBE, 0xA5, 0x23 + }, + { + 0x68, 0xD3, 0xB9, 0xF4, 0x62, 0x8C, 0x1E, 0x0C, + 0x50, 0xAB, 0x1D, 0x18, 0x29, 0xCF, 0x37, 0x94, + 0x15, 0x94, 0x83, 0xDB, 0xDD, 0x66, 0xFB, 0x6D, + 0xEA, 0xD9, 0x48, 0xBE, 0x0A, 0xCF, 0x06, 0xC6 + }, + { + 0x0C, 0xCE, 0x25, 0x3D, 0x89, 0x14, 0xAE, 0x29, + 0x34, 0x63, 0x14, 0x13, 0xE4, 0xD9, 0xC7, 0xC7, + 0x86, 0xA5, 0xFE, 0xA8, 0x1D, 0x81, 0xAA, 0xE9, + 0x68, 0x12, 0x4D, 0x75, 0x55, 0x7B, 0xAE, 0x10 + }, + { + 0x7E, 0x5E, 0x77, 0x6A, 0x68, 0xEB, 0xD1, 0x85, + 0xBB, 0xA9, 0xF4, 0x71, 0x4D, 0xFE, 0x3C, 0xD1, + 0xBD, 0x00, 0x48, 0x8E, 0xC5, 0xAE, 0xAA, 0xF3, + 0xF4, 0x15, 0x55, 0x16, 0x1A, 0xFC, 0x6A, 0xF8 + }, + { + 0x9C, 0x80, 0x42, 0xC8, 0xC9, 0x99, 0xFD, 0x26, + 0xCD, 0x29, 0x25, 0x60, 0x1B, 0x2B, 0x67, 0x51, + 0x51, 0xCE, 0x50, 0x69, 0x9D, 0xE7, 0x13, 0x03, + 0x2F, 0xB3, 0x7A, 0xDE, 0x7C, 0x17, 0x81, 0x06 + }, + { + 0x31, 0x72, 0xE0, 0x59, 0xA7, 0xA2, 0x43, 0x27, + 0xCF, 0xDD, 0xC1, 0xD2, 0xEC, 0x52, 0x91, 0xCE, + 0x9B, 0x6A, 0x60, 0xF2, 0xFB, 0x5D, 0x5A, 0x4B, + 0x6F, 0xCD, 0xF1, 0xAC, 0x59, 0x76, 0x92, 0x43 + }, + { + 0xFA, 0x69, 0x9D, 0x0C, 0xCC, 0xFE, 0xC9, 0xD2, + 0xB7, 0xD0, 0x74, 0xE4, 0x96, 0xD5, 0x64, 0xE4, + 0x31, 0xCE, 0x55, 0x54, 0xC6, 0x00, 0x50, 0x70, + 0xB9, 0x40, 0x9F, 0xB3, 0xA9, 0xC8, 0x16, 0x95 + }, + { + 0x3F, 0xAA, 0xBB, 0x11, 0xA9, 0x30, 0xFB, 0x4B, + 0xD9, 0x14, 0x80, 0xBE, 0x1F, 0x16, 0xBC, 0x57, + 0x88, 0x71, 0x97, 0xF6, 0x23, 0x99, 0x31, 0x0F, + 0x2B, 0xAA, 0xBB, 0x0D, 0xBA, 0xFB, 0x0A, 0x02 + }, + { + 0x16, 0xF2, 0x48, 0x12, 0xDA, 0xE0, 0x25, 0x48, + 0x5A, 0xD5, 0xF2, 0x46, 0x0F, 0xDE, 0x7E, 0xB5, + 0x57, 0x01, 0xF6, 0xF5, 0xF5, 0x07, 0x8E, 0x65, + 0x8E, 0x27, 0x79, 0x64, 0x50, 0xA1, 0xD8, 0x83 + }, + { + 0x0E, 0x74, 0xC7, 0x33, 0x88, 0x98, 0x41, 0x7F, + 0xE3, 0x3B, 0xCF, 0x8E, 0xCD, 0xB4, 0x43, 0x10, + 0xAE, 0x50, 0x69, 0xC7, 0xA3, 0x48, 0xF4, 0xB9, + 0x84, 0x6C, 0x2E, 0xC8, 0xF5, 0x49, 0x57, 0x9E + }, + { + 0x32, 0x32, 0x4E, 0x82, 0x5F, 0x1F, 0x73, 0x09, + 0xD5, 0x51, 0xEE, 0x77, 0x6D, 0xC2, 0x94, 0x10, + 0xDB, 0xBA, 0x59, 0x22, 0x8A, 0x77, 0x04, 0x79, + 0x47, 0x57, 0x94, 0xB4, 0x92, 0x98, 0x1B, 0x59 + }, + { + 0x57, 0x12, 0x6B, 0x26, 0xEB, 0x43, 0x3F, 0x59, + 0x6D, 0x04, 0x97, 0x63, 0x1C, 0x2B, 0x2E, 0x26, + 0x24, 0x6C, 0x64, 0xE7, 0xB8, 0x15, 0x5C, 0x0E, + 0x79, 0xA9, 0xB1, 0xF8, 0x50, 0xA2, 0xC1, 0x51 + }, + { + 0x5A, 0x25, 0x76, 0xB8, 0xC4, 0x8D, 0xB9, 0xDD, + 0x72, 0x69, 0xB6, 0x7C, 0x54, 0x7D, 0x6A, 0x5E, + 0xA5, 0x99, 0xBD, 0x0A, 0x89, 0x34, 0xA1, 0x60, + 0x9E, 0xB4, 0xA8, 0x44, 0xF4, 0x81, 0x08, 0xCC + }, + { + 0x48, 0x2C, 0x14, 0x1C, 0x86, 0x92, 0xA1, 0x7E, + 0x89, 0xEC, 0xA3, 0xE5, 0x6E, 0xAF, 0x84, 0x6A, + 0x5E, 0x57, 0x64, 0x8E, 0xF8, 0x0F, 0x79, 0x3C, + 0x04, 0x48, 0x7B, 0xFE, 0x63, 0xC3, 0xC0, 0x9B + }, + { + 0x08, 0x7C, 0x93, 0x5C, 0xE8, 0xEB, 0xC3, 0xB6, + 0x23, 0x49, 0x6D, 0x62, 0xA9, 0x50, 0x08, 0x29, + 0x64, 0xF1, 0xE1, 0xD7, 0xD5, 0x70, 0xB8, 0xCF, + 0xAE, 0x58, 0x67, 0x3D, 0xE7, 0xA7, 0x2F, 0x42 + }, + { + 0xCA, 0x0A, 0x31, 0x90, 0x79, 0x0E, 0x0A, 0x65, + 0xB3, 0xBC, 0xCF, 0x36, 0xBF, 0xFE, 0x4B, 0xF3, + 0xBE, 0xB6, 0x2E, 0x56, 0x14, 0x57, 0x67, 0x47, + 0xC2, 0xB2, 0xBF, 0x0E, 0x79, 0x93, 0xE7, 0xC2 + }, + { + 0xAA, 0xC1, 0xF3, 0x6A, 0xF5, 0x87, 0x7E, 0xBE, + 0x0A, 0xD9, 0xD9, 0x4B, 0x0E, 0xEA, 0x5D, 0x21, + 0x8D, 0x09, 0x34, 0xC7, 0x22, 0x60, 0xAC, 0x74, + 0x77, 0x8F, 0x03, 0x2A, 0x02, 0xF2, 0x63, 0x72 + }, + { + 0xB1, 0xBF, 0x9F, 0xC2, 0x96, 0x9A, 0xFE, 0xD3, + 0x13, 0xA9, 0xEF, 0x7F, 0x71, 0xC5, 0xDE, 0x75, + 0x4B, 0x8C, 0xF7, 0xE9, 0x09, 0x6A, 0xF9, 0x60, + 0x54, 0x87, 0xAD, 0x22, 0xD9, 0xF0, 0x0E, 0x5A + }, + { + 0x2A, 0x9F, 0xB3, 0xC5, 0x52, 0x33, 0x65, 0xCF, + 0x77, 0xD0, 0xA7, 0x82, 0x73, 0xD4, 0xED, 0x5D, + 0xB1, 0x13, 0xDE, 0xBA, 0x6C, 0x70, 0xBF, 0x8F, + 0x8D, 0xA7, 0x05, 0xA3, 0x82, 0x3C, 0xEE, 0xEB + }, + { + 0xB9, 0x28, 0xCB, 0x2B, 0x61, 0x15, 0xDA, 0xA6, + 0xAA, 0xB0, 0x2A, 0x0F, 0x3A, 0x9C, 0x2A, 0x21, + 0x08, 0x03, 0x0D, 0x58, 0xBB, 0x7F, 0x65, 0x19, + 0xB3, 0x21, 0x1E, 0x1B, 0x1B, 0x49, 0x32, 0x8D + }, + { + 0x2D, 0xE9, 0x69, 0xB5, 0xB9, 0xDC, 0x15, 0xCF, + 0x41, 0xDE, 0x62, 0x9A, 0x60, 0xF7, 0x75, 0x80, + 0x66, 0x30, 0xAD, 0xFF, 0xDE, 0x74, 0xAB, 0x50, + 0xBD, 0xB1, 0x90, 0x7F, 0xEB, 0x0F, 0x07, 0x59 + }, + { + 0xA0, 0x52, 0x26, 0x72, 0x90, 0x2B, 0x84, 0x30, + 0x0B, 0xC6, 0x2F, 0x83, 0x50, 0xB1, 0x23, 0xDA, + 0xF8, 0xE6, 0x8F, 0xFB, 0xF2, 0xB8, 0x81, 0xFA, + 0x6E, 0xE9, 0x33, 0xE2, 0x7E, 0x66, 0x7F, 0x30 + }, + { + 0x3B, 0x0F, 0xF6, 0x06, 0xFC, 0x28, 0xC9, 0x2A, + 0x42, 0xD2, 0x1A, 0x7A, 0xE0, 0xCC, 0x32, 0x93, + 0x5F, 0xF5, 0x5F, 0x2C, 0xC7, 0x29, 0x25, 0x33, + 0x67, 0x02, 0x60, 0x78, 0xF3, 0x12, 0xAA, 0xDD + }, + { + 0xE0, 0x3D, 0x50, 0xFC, 0x43, 0x0B, 0x15, 0x60, + 0xFA, 0x13, 0x62, 0xD9, 0x89, 0x2C, 0xAE, 0x93, + 0xF4, 0x65, 0x5B, 0x7E, 0xB4, 0x1F, 0xDB, 0xD1, + 0x97, 0x14, 0xC9, 0xFE, 0x11, 0xE0, 0x46, 0xB6 + }, + { + 0xDB, 0x7B, 0x74, 0xFF, 0xFC, 0xF0, 0xD3, 0x2A, + 0xB8, 0x6A, 0xC4, 0x3F, 0xF6, 0x8F, 0x25, 0x66, + 0xF9, 0x87, 0x9F, 0x97, 0xF2, 0x47, 0x94, 0x85, + 0xE9, 0x81, 0x68, 0xCC, 0xFF, 0x4A, 0x18, 0x25 + }, + { + 0xF5, 0x21, 0x5A, 0xD3, 0x6C, 0xD5, 0xC8, 0xFA, + 0x40, 0x05, 0x4B, 0x93, 0xF1, 0x4A, 0x30, 0x1A, + 0xC5, 0x3D, 0xE8, 0xC4, 0xA3, 0x2A, 0xD9, 0xE7, + 0x3D, 0x50, 0x8C, 0x9D, 0x44, 0x82, 0x5F, 0x31 + }, + { + 0x5A, 0xD8, 0x2D, 0x64, 0x54, 0xF5, 0x73, 0xDB, + 0x80, 0xEF, 0x5A, 0xED, 0xFE, 0xB6, 0xC1, 0xD3, + 0x1B, 0x23, 0x48, 0x58, 0xAB, 0x97, 0xFF, 0xC2, + 0x7E, 0x42, 0x3F, 0x81, 0xC3, 0xF9, 0x82, 0xF4 + }, + { + 0xDA, 0x38, 0x2C, 0x87, 0xA0, 0x45, 0x43, 0xA2, + 0x11, 0x8A, 0x05, 0xAB, 0x30, 0x14, 0x1A, 0x0B, + 0xB1, 0x91, 0xEC, 0x17, 0x49, 0x3B, 0xA6, 0xB9, + 0xCB, 0xF6, 0x73, 0x53, 0x2F, 0x2D, 0xB3, 0x53 + }, + { + 0xCA, 0x88, 0x34, 0x5C, 0x1C, 0xE4, 0xA4, 0x7A, + 0xCB, 0xD1, 0xB8, 0x3B, 0x59, 0x0C, 0xDC, 0x17, + 0x85, 0x74, 0xE1, 0x52, 0xA9, 0x5C, 0xF4, 0xAE, + 0xC2, 0xD4, 0x82, 0xB3, 0xFE, 0x7D, 0x79, 0x46 + }, + { + 0xBE, 0xFC, 0xE1, 0x81, 0x33, 0x7F, 0xB1, 0x29, + 0x00, 0x46, 0x82, 0xCC, 0xD3, 0x74, 0xA5, 0x33, + 0x61, 0xD6, 0xB9, 0x5C, 0xB8, 0x7C, 0x3D, 0x3E, + 0xF5, 0xFE, 0x16, 0xC0, 0x2C, 0xEA, 0x59, 0x78 + }, + { + 0x28, 0xA8, 0xFC, 0xFD, 0x73, 0x52, 0xE2, 0x81, + 0x8B, 0x17, 0xF9, 0x86, 0x9B, 0x9A, 0xCA, 0x26, + 0x9C, 0x23, 0x9B, 0x11, 0xAB, 0x8D, 0x4F, 0x91, + 0x47, 0x4A, 0xD4, 0x32, 0x26, 0x78, 0xBA, 0x0E + }, + { + 0x92, 0x0A, 0x32, 0x37, 0x99, 0x63, 0x08, 0x7E, + 0xCF, 0x14, 0x79, 0xF8, 0x2B, 0x4A, 0x84, 0x60, + 0xA7, 0xA0, 0x8B, 0x91, 0x9D, 0xCC, 0xF3, 0xFD, + 0x6D, 0xC9, 0xAA, 0x28, 0x84, 0x8B, 0x79, 0x74 + }, + { + 0xFC, 0xAD, 0x10, 0x0E, 0x39, 0x8D, 0xF7, 0x7C, + 0x50, 0x5F, 0x60, 0x2D, 0x31, 0xB0, 0x22, 0x8F, + 0x60, 0x8F, 0x44, 0x6F, 0x6B, 0x7C, 0x48, 0x1E, + 0x13, 0x0A, 0x0F, 0xC8, 0x72, 0xCC, 0x7D, 0x1F + }, + { + 0xD5, 0x86, 0xF5, 0x95, 0x41, 0x3D, 0xAF, 0x50, + 0x30, 0x57, 0x0C, 0xB2, 0x16, 0x6A, 0xBC, 0xBA, + 0xB7, 0x43, 0x7F, 0x51, 0x65, 0x60, 0x5F, 0x55, + 0x69, 0x27, 0xB3, 0xDA, 0x89, 0x40, 0x5C, 0xC3 + }, + { + 0x7D, 0xA4, 0xAC, 0x22, 0x57, 0xD7, 0x2E, 0x04, + 0x34, 0x7F, 0x0F, 0x6E, 0xE6, 0x86, 0xE9, 0x14, + 0x9C, 0xF5, 0x77, 0x9F, 0x80, 0x54, 0x79, 0x19, + 0x7C, 0x19, 0x86, 0x52, 0x96, 0x1C, 0xF9, 0x35 + }, + { + 0x9D, 0xE4, 0xEC, 0x19, 0x8B, 0xAE, 0x89, 0x62, + 0x04, 0x2E, 0x36, 0x09, 0xCA, 0x6F, 0x5D, 0x9E, + 0x62, 0x32, 0xD9, 0x66, 0xD9, 0x9D, 0xCA, 0xC6, + 0x19, 0xCE, 0xD6, 0x61, 0xBD, 0xDB, 0x82, 0x72 + }, + { + 0x91, 0x6C, 0x24, 0x1F, 0xE8, 0x76, 0xF0, 0x65, + 0xDF, 0x32, 0xE8, 0x5E, 0x7F, 0x3B, 0x95, 0x94, + 0x0F, 0x32, 0x9F, 0x9F, 0xC7, 0x65, 0x35, 0x00, + 0xA8, 0xA7, 0x24, 0x72, 0xAA, 0xDA, 0xA4, 0x34 + }, + { + 0x67, 0xDB, 0x6B, 0x8C, 0xC3, 0x0C, 0xF7, 0xBF, + 0x45, 0x4E, 0x50, 0xAC, 0xDF, 0x55, 0x25, 0xAE, + 0x82, 0x01, 0x57, 0x37, 0xA2, 0xC6, 0x9E, 0xEE, + 0xF3, 0xF9, 0xB5, 0x52, 0x40, 0x35, 0xF0, 0xB5 + }, + { + 0x10, 0xA3, 0xC3, 0x19, 0xBC, 0x13, 0xB0, 0x6F, + 0x5F, 0x1B, 0x3E, 0x48, 0x23, 0xD4, 0x80, 0x84, + 0x71, 0x9E, 0x01, 0x84, 0xDE, 0x35, 0x7D, 0x34, + 0xBC, 0xA8, 0x0F, 0xA2, 0x60, 0x17, 0x13, 0x36 + }, + { + 0xA3, 0x67, 0x0A, 0x15, 0x7C, 0x46, 0x0C, 0x51, + 0x87, 0xB8, 0x16, 0x45, 0xEE, 0x46, 0xC2, 0xAA, + 0x13, 0x84, 0x6C, 0xBC, 0xC1, 0xC5, 0x07, 0xF3, + 0xD2, 0x45, 0xAD, 0x86, 0x99, 0xEE, 0xB5, 0x57 + }, + { + 0x6B, 0x6E, 0x46, 0x66, 0xE2, 0x67, 0x58, 0xD3, + 0x6C, 0xE2, 0x8E, 0x70, 0x95, 0x01, 0x15, 0x5A, + 0xB1, 0x42, 0xF4, 0xF8, 0xEB, 0xFE, 0x27, 0x77, + 0xCC, 0x6C, 0x97, 0x77, 0xCE, 0x0C, 0xB1, 0x1E + }, + { + 0x0F, 0xAB, 0x73, 0xE6, 0x85, 0xD9, 0xF8, 0xA6, + 0x7B, 0x00, 0xB9, 0xB1, 0x39, 0x5C, 0xD4, 0x57, + 0x08, 0x18, 0x37, 0x9F, 0x71, 0x5D, 0x4D, 0xEE, + 0xC8, 0x3C, 0x92, 0x72, 0xE1, 0xF9, 0x78, 0x6A + }, + { + 0xAC, 0x04, 0xA6, 0xE2, 0x6F, 0x85, 0x8B, 0x12, + 0x6F, 0x0B, 0x42, 0xD6, 0x91, 0x7C, 0xAB, 0xFD, + 0x5D, 0xD4, 0x6D, 0x21, 0xFB, 0xA0, 0x79, 0x32, + 0xEC, 0xC9, 0x43, 0xB4, 0xCB, 0x13, 0xA9, 0xD1 + }, + { + 0xAD, 0x2F, 0x22, 0x8C, 0x8B, 0x8A, 0x5E, 0x61, + 0x7B, 0xF1, 0x41, 0x42, 0xEB, 0x17, 0x1B, 0x85, + 0xEF, 0x88, 0x66, 0x12, 0x2B, 0xED, 0x02, 0xB3, + 0x9A, 0x36, 0x81, 0x34, 0xDE, 0x77, 0x1A, 0x9E + }, + { + 0x90, 0x86, 0x72, 0x36, 0x3B, 0xF6, 0x0F, 0x38, + 0x08, 0x18, 0x1B, 0x9B, 0x19, 0x78, 0xC8, 0xFD, + 0x06, 0x0F, 0x4C, 0x34, 0x25, 0xD6, 0x6E, 0x20, + 0xE7, 0xEF, 0xA6, 0x0F, 0x02, 0x75, 0xF0, 0x59 + }, + { + 0x4D, 0x0B, 0x52, 0x3A, 0xB4, 0xC0, 0x7A, 0xB5, + 0x85, 0xF9, 0xB5, 0x47, 0xB9, 0xD0, 0xCB, 0xDF, + 0x21, 0x8E, 0xB8, 0x46, 0xBF, 0x6D, 0x9F, 0xDB, + 0xD5, 0xDD, 0x1D, 0xE2, 0x06, 0x0C, 0x4A, 0x79 + }, + { + 0x49, 0x89, 0x4E, 0xF6, 0xE6, 0x58, 0x61, 0x1F, + 0xF1, 0xE3, 0xB8, 0x51, 0x81, 0x97, 0x0E, 0xD8, + 0xC6, 0xFB, 0x5C, 0x2E, 0xC2, 0x8D, 0xB8, 0x86, + 0xFF, 0xB5, 0x46, 0x6E, 0x56, 0x4D, 0x9E, 0x67 + }, + { + 0x3D, 0x2A, 0x66, 0x95, 0xA5, 0x62, 0x28, 0xB7, + 0xD8, 0x19, 0x13, 0xAE, 0x2E, 0x90, 0x51, 0x16, + 0xF7, 0x94, 0x7B, 0x62, 0x84, 0xA7, 0xA8, 0x29, + 0xBB, 0x1E, 0xA4, 0xAF, 0x32, 0x30, 0x60, 0xED + }, + { + 0xAC, 0xD1, 0xA5, 0xEF, 0x5A, 0x87, 0x3A, 0x49, + 0xDF, 0x5E, 0x21, 0xCC, 0x17, 0x0B, 0xAF, 0xE6, + 0x17, 0x95, 0x37, 0x55, 0x80, 0xE6, 0x6B, 0x90, + 0x8B, 0x2A, 0x35, 0x75, 0x9D, 0xDA, 0x28, 0x76 + }, + { + 0x42, 0x5E, 0xE2, 0x5E, 0x79, 0x51, 0x4E, 0xFD, + 0x8E, 0x66, 0xE1, 0xFA, 0x42, 0xE1, 0x01, 0x8A, + 0xCA, 0xFC, 0xAB, 0x5D, 0x3B, 0x75, 0xFF, 0x68, + 0xC2, 0x63, 0x5D, 0x69, 0x10, 0xDE, 0xE5, 0xD0 + }, + { + 0xBE, 0x0A, 0x06, 0x63, 0x7E, 0xE6, 0x22, 0x61, + 0xC1, 0x05, 0x9F, 0x1C, 0xE9, 0x01, 0x5E, 0x09, + 0x07, 0xC7, 0x4C, 0xE8, 0x5F, 0xE2, 0xE2, 0x98, + 0x56, 0xE9, 0x59, 0x9E, 0x5D, 0x49, 0xE5, 0xAE + }, + { + 0x75, 0x0B, 0x0A, 0xBA, 0x81, 0xE3, 0xF6, 0xA7, + 0x0F, 0xD1, 0x00, 0x94, 0x1F, 0x96, 0x57, 0xCD, + 0xB3, 0x04, 0xB6, 0x3A, 0xF7, 0x8A, 0xB0, 0x45, + 0x3D, 0xF6, 0xA0, 0xCE, 0xD2, 0xBF, 0xA6, 0xB0 + }, + { + 0x97, 0x99, 0xDF, 0xA5, 0x58, 0xC9, 0xFA, 0xEC, + 0xB5, 0xC9, 0x41, 0xA4, 0x1C, 0x68, 0xC9, 0xA2, + 0xE3, 0x23, 0x66, 0x01, 0xCC, 0xA9, 0xDE, 0x92, + 0x01, 0x57, 0x0F, 0x12, 0x8B, 0x6D, 0xD9, 0xC5 + }, + { + 0x0C, 0xA9, 0xE2, 0x3D, 0x1F, 0xDD, 0xAD, 0xD5, + 0x91, 0x14, 0xEA, 0xAC, 0x96, 0x5E, 0x31, 0xC3, + 0xC1, 0x25, 0xE2, 0xE2, 0xEB, 0x0D, 0x7C, 0x58, + 0x17, 0x11, 0xA1, 0xBE, 0x8B, 0xA1, 0x44, 0x14 + }, + { + 0xE5, 0x55, 0xE8, 0x18, 0x1B, 0x31, 0x12, 0x44, + 0xA4, 0x5A, 0x32, 0x3B, 0x31, 0xE2, 0x53, 0x04, + 0xE0, 0x21, 0xFE, 0x4A, 0x47, 0xFD, 0xA3, 0xBC, + 0xB0, 0xB1, 0x22, 0x48, 0x79, 0xF6, 0xDC, 0xC0 + }, + { + 0x77, 0xE9, 0x25, 0x1A, 0xD8, 0xDC, 0xB0, 0x82, + 0x80, 0x1C, 0x98, 0xCE, 0x1C, 0xA0, 0xAC, 0x84, + 0xEA, 0x63, 0x5D, 0x01, 0xA6, 0x7E, 0x44, 0x46, + 0xC3, 0xA3, 0xB0, 0x58, 0xB6, 0xEB, 0x5F, 0x04 + }, + { + 0x04, 0xC3, 0x85, 0xC8, 0xC0, 0x49, 0xD4, 0x9C, + 0x1B, 0x27, 0x3C, 0x87, 0xDC, 0xF6, 0xF2, 0x89, + 0xBC, 0xCC, 0x9A, 0x72, 0x94, 0xC6, 0x66, 0xAF, + 0xC1, 0x98, 0x16, 0xD0, 0x90, 0x88, 0x67, 0x08 + }, + { + 0x69, 0xDD, 0xD3, 0x18, 0xDD, 0xEF, 0x7A, 0xB3, + 0x5C, 0x30, 0x94, 0xE8, 0xB9, 0x2A, 0xF1, 0x84, + 0xF5, 0x4B, 0x1B, 0x9F, 0x6F, 0xBF, 0x34, 0xC9, + 0x47, 0x09, 0xF4, 0x29, 0x5A, 0x5A, 0xCE, 0xBA + }, + { + 0xFC, 0x24, 0xE3, 0xC8, 0xA2, 0xA0, 0xFE, 0x5E, + 0xC8, 0x0C, 0x71, 0xE3, 0xE3, 0xE7, 0x04, 0xF6, + 0xCE, 0xB9, 0xB9, 0xE8, 0x13, 0xE5, 0x96, 0xA0, + 0x4B, 0xFE, 0xC6, 0x52, 0x89, 0x6B, 0xB7, 0xCA + }, + { + 0xB5, 0x2C, 0x98, 0xA8, 0x69, 0xD6, 0x5A, 0x54, + 0x4D, 0x60, 0x6D, 0xBF, 0xCC, 0x20, 0xF4, 0x3F, + 0xE5, 0x71, 0xE0, 0x51, 0xEF, 0x48, 0xA2, 0xDD, + 0xAC, 0xF8, 0xA6, 0xD9, 0x53, 0xE7, 0xE7, 0x98 + }, + { + 0x2B, 0x10, 0x11, 0x9A, 0x0A, 0x1A, 0x5A, 0xBF, + 0x03, 0x3F, 0xB2, 0x36, 0x88, 0xB3, 0x21, 0x9F, + 0xDF, 0xED, 0x39, 0x40, 0xEA, 0x01, 0x08, 0xAB, + 0xF5, 0x2B, 0x79, 0x96, 0x55, 0xAA, 0xD7, 0xC8 + }, + { + 0xE7, 0xF6, 0x12, 0x97, 0xA8, 0x3B, 0xD2, 0x96, + 0x7D, 0x32, 0x32, 0x7C, 0xCE, 0xD0, 0xB1, 0x19, + 0xB0, 0x6A, 0x6A, 0x98, 0x12, 0x5D, 0xDF, 0x93, + 0x59, 0x89, 0xE5, 0x18, 0xBB, 0x4B, 0x90, 0x9D + }, + { + 0xD1, 0x4B, 0x2E, 0x4D, 0xC1, 0xCA, 0xE3, 0x71, + 0x68, 0x27, 0x76, 0x9D, 0x43, 0xB4, 0x33, 0x69, + 0x7C, 0x96, 0x06, 0x75, 0x37, 0x77, 0x0C, 0x88, + 0x90, 0xD9, 0x7C, 0x7F, 0xFA, 0x87, 0xBD, 0x42 + }, + { + 0x3F, 0x95, 0x01, 0x50, 0x35, 0xCD, 0x3A, 0xAD, + 0xA1, 0x06, 0xCD, 0xA0, 0x2F, 0xEF, 0xF0, 0x28, + 0x82, 0x2B, 0xE3, 0xB7, 0x94, 0xF7, 0x87, 0xAC, + 0x22, 0x7D, 0x70, 0x90, 0x46, 0x32, 0x0D, 0xE9 + }, + { + 0x6E, 0x53, 0x0F, 0x99, 0x36, 0x93, 0xBC, 0x71, + 0xC6, 0xCF, 0xCD, 0x0E, 0xD2, 0x02, 0xFD, 0xB5, + 0xA6, 0x99, 0xA0, 0xE3, 0xAD, 0x18, 0xC9, 0x7E, + 0x72, 0x71, 0x4A, 0xA2, 0xBB, 0xE5, 0xC9, 0x29 + }, + { + 0x05, 0x77, 0x28, 0x9B, 0xCE, 0x6A, 0x28, 0xCA, + 0xB6, 0xEE, 0x25, 0xE2, 0x03, 0x55, 0x4B, 0xF2, + 0x0E, 0xED, 0xFF, 0xAA, 0x8D, 0xCB, 0xDA, 0xF1, + 0xF9, 0x80, 0x1B, 0xA8, 0x44, 0xF2, 0x98, 0x8E + }, + { + 0x39, 0x9B, 0xF7, 0x42, 0xB4, 0x9A, 0x59, 0x78, + 0x58, 0xA1, 0xB0, 0xC2, 0xB5, 0x99, 0xF9, 0xFD, + 0x4D, 0x6D, 0x66, 0x20, 0x49, 0x41, 0xA8, 0x93, + 0xBC, 0x79, 0xFC, 0xF0, 0x97, 0xE9, 0xD9, 0x92 + }, + { + 0x8F, 0xD0, 0x89, 0x1E, 0x55, 0x28, 0x27, 0xF0, + 0x66, 0x52, 0xC5, 0xED, 0x9A, 0x5C, 0x81, 0xAB, + 0x3F, 0xD6, 0x8E, 0x78, 0x93, 0xB3, 0xBE, 0x89, + 0x01, 0x1F, 0xB4, 0x7E, 0xD9, 0xCD, 0x26, 0xE8 + }, + { + 0x2B, 0xDB, 0x60, 0xED, 0x00, 0x03, 0xAA, 0x17, + 0x8E, 0xEA, 0xBE, 0x9D, 0x81, 0xAE, 0xF8, 0x55, + 0x5E, 0x83, 0x9E, 0x23, 0x74, 0x1E, 0x33, 0x53, + 0x58, 0xD1, 0x6D, 0x21, 0x36, 0xFD, 0xAC, 0x8D + }, + { + 0xA3, 0x2C, 0x2C, 0x92, 0x7A, 0x29, 0x23, 0x07, + 0x85, 0x03, 0x7C, 0x9F, 0x22, 0xF9, 0xC6, 0x67, + 0xB9, 0x62, 0xD9, 0xA9, 0x73, 0xFD, 0x7F, 0x30, + 0x08, 0x34, 0x1A, 0xA4, 0x46, 0x28, 0x91, 0xFB + }, + { + 0xD0, 0x44, 0x05, 0xF0, 0xA2, 0xBF, 0x45, 0x84, + 0xE6, 0xB2, 0x50, 0x3A, 0xCD, 0x8F, 0xB9, 0xD5, + 0x77, 0xD3, 0x8F, 0xA0, 0xE3, 0x13, 0x23, 0x0D, + 0xCD, 0x5B, 0x21, 0x49, 0x26, 0x0D, 0xB7, 0x13 + }, + { + 0x8B, 0xD8, 0x64, 0xA0, 0xA1, 0xB5, 0xA5, 0x47, + 0x36, 0xD6, 0xD0, 0x66, 0xE3, 0x9F, 0x8B, 0x01, + 0x59, 0x17, 0xE5, 0xE2, 0xDB, 0x78, 0x40, 0x97, + 0x9D, 0x80, 0x62, 0xDD, 0xEF, 0xC4, 0x02, 0x1F + }, + { + 0x50, 0xF2, 0x3E, 0xCB, 0xDE, 0x5B, 0x91, 0xA3, + 0x14, 0xA2, 0x26, 0xDD, 0xB4, 0x93, 0xCD, 0x86, + 0xD3, 0x6B, 0xF7, 0x71, 0x19, 0x8D, 0xAA, 0x66, + 0x56, 0x5B, 0xDA, 0x6E, 0x1C, 0x44, 0x58, 0x02 + }, + { + 0xCE, 0x33, 0xD0, 0x8C, 0x09, 0x8A, 0xD4, 0x33, + 0xA5, 0x79, 0x79, 0x35, 0xDA, 0x14, 0xE2, 0x2F, + 0x18, 0xA0, 0x8E, 0x8A, 0x37, 0xF1, 0x66, 0xA6, + 0xD2, 0x39, 0x33, 0x8D, 0x8F, 0x6D, 0x2B, 0x29 + }, + { + 0x14, 0x45, 0x0E, 0x68, 0x60, 0xBE, 0x99, 0xCF, + 0xC5, 0xE8, 0x02, 0x36, 0x41, 0xF1, 0x5F, 0x19, + 0x02, 0x7A, 0x69, 0xEC, 0xEC, 0x9C, 0x2F, 0x70, + 0x56, 0x7E, 0x65, 0xD0, 0xF5, 0xEB, 0xE8, 0xDF + }, + { + 0x85, 0x18, 0xA4, 0xBC, 0xB2, 0x5C, 0xA0, 0x36, + 0xDF, 0x43, 0xC8, 0x47, 0x95, 0x24, 0xA8, 0xD5, + 0x87, 0xF8, 0xBA, 0xC1, 0xD8, 0x1F, 0xB6, 0x3A, + 0xBA, 0xDA, 0x42, 0x72, 0x01, 0xC5, 0x3A, 0x77 + }, + { + 0xE5, 0xE4, 0xA4, 0xBB, 0xC7, 0xBE, 0x55, 0xC7, + 0xEF, 0x66, 0x00, 0xC9, 0xF9, 0x74, 0xDB, 0x4D, + 0x1B, 0x41, 0x41, 0x47, 0x3E, 0x6B, 0x16, 0x8D, + 0x57, 0x1C, 0x35, 0xAE, 0xB9, 0x77, 0xB2, 0x68 + }, + { + 0xE8, 0x10, 0x1D, 0x59, 0x6E, 0x0E, 0x19, 0x50, + 0x01, 0xB1, 0x84, 0x81, 0x97, 0xE2, 0x19, 0xBF, + 0x70, 0x4E, 0x70, 0x7A, 0xBA, 0x05, 0xB7, 0xF1, + 0xD9, 0xFA, 0xF5, 0xFA, 0xC4, 0x06, 0x38, 0xFD + }, + { + 0xBE, 0x49, 0x78, 0x11, 0xE2, 0xA9, 0x4A, 0x79, + 0x26, 0x0D, 0x63, 0x44, 0x05, 0x5A, 0x81, 0xD1, + 0xFE, 0x0F, 0x56, 0x47, 0x05, 0x2B, 0xE5, 0x77, + 0x46, 0xE6, 0xCA, 0xA5, 0xD9, 0xC7, 0x1C, 0x4B + }, + { + 0xE7, 0xBF, 0x11, 0xBC, 0x26, 0x90, 0xF7, 0x14, + 0xCC, 0x06, 0xF1, 0xA4, 0x7E, 0xCD, 0x24, 0x94, + 0x6E, 0x99, 0x2F, 0x5D, 0xFD, 0xEB, 0x49, 0x3D, + 0x72, 0xF6, 0xEA, 0xE0, 0x6A, 0xA6, 0x1B, 0xE5 + }, + { + 0x3A, 0x08, 0x0F, 0xD9, 0xFB, 0xF5, 0x87, 0x0B, + 0x45, 0xCA, 0x2B, 0xC6, 0xF1, 0x17, 0xC5, 0x76, + 0x94, 0xA8, 0x50, 0xB6, 0x08, 0x40, 0x83, 0x64, + 0x82, 0x6B, 0x8E, 0x11, 0x54, 0x2C, 0x28, 0xD6 + }, + { + 0x9B, 0xB7, 0x5D, 0x43, 0x08, 0xE0, 0x4E, 0x31, + 0x29, 0x23, 0x10, 0x6D, 0xA2, 0x71, 0xA2, 0x36, + 0x8F, 0xF4, 0xA7, 0xFD, 0x80, 0x71, 0x33, 0xA8, + 0x0A, 0x94, 0x84, 0xF3, 0x16, 0xF0, 0x6F, 0xBF + }, + { + 0xFE, 0x1C, 0xE7, 0xFA, 0x05, 0xEE, 0x3F, 0x2C, + 0xDC, 0xC6, 0xE4, 0x8C, 0xDF, 0x58, 0x9A, 0x81, + 0x9A, 0xC0, 0xD1, 0x67, 0x84, 0x9D, 0x70, 0xED, + 0xD0, 0x2D, 0x8B, 0x7A, 0x13, 0xCA, 0xDE, 0x60 + }, + { + 0x77, 0x3A, 0xEB, 0xA1, 0x6B, 0x66, 0x6A, 0x5F, + 0xB7, 0xFD, 0xD3, 0xAA, 0x53, 0x42, 0x1E, 0xD6, + 0xF3, 0x65, 0x3F, 0x5A, 0x6C, 0x3A, 0x05, 0x68, + 0xF7, 0x8C, 0x37, 0xE2, 0x7B, 0xF0, 0xB7, 0x59 + }, + { + 0x07, 0xB8, 0x27, 0x2E, 0x95, 0x3E, 0x2B, 0x8E, + 0xA7, 0xB5, 0x0C, 0x5D, 0xBC, 0x0C, 0x88, 0x43, + 0x96, 0x0C, 0x2F, 0x48, 0xC9, 0xF4, 0x93, 0x31, + 0x10, 0xAD, 0x6C, 0x81, 0xA2, 0x4D, 0x6B, 0xA0 + }, + { + 0x2F, 0x90, 0x9B, 0x9B, 0x08, 0xDC, 0x8C, 0xB7, + 0x15, 0xC9, 0x56, 0x0D, 0x5C, 0x51, 0x52, 0x8E, + 0x28, 0xBB, 0x76, 0x77, 0x02, 0x10, 0x8B, 0x52, + 0x06, 0xF2, 0xA4, 0x49, 0xA3, 0xD9, 0x9C, 0x4E + }, + { + 0x79, 0x15, 0xB7, 0x6B, 0x78, 0x5A, 0x61, 0xCE, + 0x39, 0xC7, 0x9A, 0x5C, 0x12, 0x2E, 0x51, 0xAE, + 0xEB, 0x35, 0x54, 0xB5, 0xEA, 0xD0, 0x6E, 0x54, + 0x6F, 0x76, 0x91, 0x31, 0x6E, 0x84, 0x40, 0x62 + }, + { + 0xA5, 0x6E, 0xC4, 0x4E, 0x9D, 0xC8, 0x90, 0x9E, + 0x8F, 0x16, 0x14, 0x98, 0x25, 0x74, 0x38, 0x93, + 0xA3, 0x63, 0x23, 0x9C, 0x83, 0x70, 0x16, 0xAA, + 0x37, 0x17, 0x7F, 0x94, 0xFB, 0x34, 0x0C, 0xE9 + }, + { + 0x98, 0xD6, 0x65, 0x38, 0x87, 0xD1, 0x85, 0xF1, + 0x24, 0x76, 0x0C, 0xF3, 0x37, 0x90, 0x9A, 0x3F, + 0xB4, 0xCC, 0x7E, 0xBD, 0x49, 0xFF, 0x85, 0xE4, + 0x67, 0x4F, 0x81, 0x52, 0x93, 0x13, 0xB0, 0xD7 + }, + { + 0x2E, 0x1C, 0x50, 0x81, 0xDB, 0xEA, 0x5F, 0x9A, + 0x79, 0xC7, 0xE0, 0xFD, 0xD0, 0x7F, 0x8C, 0x67, + 0x19, 0x6C, 0x73, 0x75, 0x8F, 0xBA, 0xC4, 0x3B, + 0xF6, 0xB8, 0x53, 0x68, 0x55, 0xF8, 0xA9, 0x57 + }, + { + 0xC2, 0x82, 0xB4, 0x32, 0x8F, 0xFF, 0x45, 0xE5, + 0xD5, 0xAF, 0x38, 0x0C, 0x49, 0x03, 0x8A, 0xF1, + 0xAE, 0x00, 0x56, 0xF6, 0x94, 0x72, 0xD3, 0x85, + 0x4E, 0xC2, 0x16, 0xA9, 0xAE, 0xAE, 0xCE, 0x33 + }, + { + 0x3D, 0x98, 0x98, 0xEF, 0xA8, 0xF4, 0xEA, 0xD3, + 0x92, 0xB4, 0x3B, 0x53, 0x92, 0xF8, 0x5D, 0x98, + 0x7C, 0xA4, 0x21, 0x3C, 0x71, 0x85, 0xDE, 0x6F, + 0x7B, 0x4B, 0xC3, 0x7E, 0x50, 0x59, 0x4A, 0x03 + }, + { + 0xFE, 0xB2, 0x7E, 0x71, 0xC0, 0xD5, 0x40, 0xD4, + 0xD6, 0x0A, 0x0B, 0xA9, 0xC0, 0x56, 0xEE, 0x53, + 0xBE, 0xC3, 0x4A, 0xDC, 0x89, 0xD5, 0xD9, 0xA3, + 0xFE, 0x3A, 0x06, 0xF2, 0xD9, 0xA4, 0xA1, 0x05 + }, + { + 0x8E, 0x27, 0xBB, 0xEA, 0xE4, 0xE0, 0xC8, 0xC7, + 0x0B, 0xA5, 0x9C, 0xE9, 0x5E, 0x2D, 0xC1, 0x6E, + 0xDA, 0x40, 0xA5, 0xF8, 0x70, 0x97, 0xF2, 0xD3, + 0x93, 0xDF, 0x84, 0xE6, 0xDD, 0xBC, 0x33, 0x1F + }, + { + 0xE9, 0xB6, 0x57, 0xCB, 0x66, 0x52, 0x7D, 0x5F, + 0xA4, 0x59, 0x7B, 0xDE, 0x26, 0x8E, 0x5D, 0xA6, + 0x19, 0x8C, 0x52, 0x0D, 0xAD, 0xC1, 0x8B, 0x9A, + 0x71, 0x59, 0xFF, 0x79, 0x82, 0x8F, 0x43, 0x94 + }, + { + 0xDF, 0x73, 0xCA, 0x3C, 0x6A, 0x14, 0xFC, 0x77, + 0xF5, 0xAC, 0x0F, 0x41, 0xE0, 0xF2, 0x1D, 0x73, + 0x59, 0x25, 0xF8, 0xA0, 0x11, 0xBB, 0xDB, 0x99, + 0xEA, 0xB1, 0x1B, 0x84, 0xBF, 0xC8, 0xE6, 0x80 + }, + { + 0x7B, 0xAF, 0x14, 0x39, 0x51, 0x7D, 0x42, 0x30, + 0xE4, 0xC2, 0xF1, 0x39, 0x98, 0xC0, 0x91, 0x81, + 0x12, 0xC6, 0x1B, 0x20, 0xF9, 0x7C, 0x1D, 0xC9, + 0x1A, 0x9C, 0x6C, 0xB2, 0x67, 0xA5, 0x2F, 0x2A + }, + { + 0x55, 0x7F, 0xCE, 0x04, 0xC1, 0x5C, 0x7C, 0x4F, + 0xFA, 0xA2, 0x1E, 0xCA, 0xFF, 0x19, 0x95, 0x0A, + 0x87, 0x3B, 0x7B, 0xCB, 0x4C, 0xC4, 0xC6, 0xDB, + 0x17, 0xA0, 0x99, 0x01, 0x40, 0xB3, 0x90, 0x42 + }, + { + 0xF7, 0xC3, 0xCB, 0xA5, 0x33, 0x79, 0xF5, 0xD3, + 0x77, 0x07, 0xCF, 0x8D, 0xA5, 0xF4, 0xDF, 0x85, + 0xF9, 0x0A, 0x90, 0xCC, 0x03, 0xFE, 0xA1, 0xE5, + 0x06, 0x2B, 0xF0, 0x0C, 0x18, 0xC1, 0x51, 0x04 + }, + { + 0x56, 0xE8, 0x33, 0x0D, 0x46, 0xEF, 0x40, 0xD9, + 0x6C, 0x12, 0xD6, 0x2A, 0xF7, 0xAB, 0x99, 0xDE, + 0xD0, 0x5B, 0x7C, 0x4F, 0x68, 0x01, 0x2D, 0x22, + 0x29, 0x48, 0xDC, 0xC3, 0x79, 0x86, 0x96, 0xA8 + }, + { + 0xDF, 0x96, 0x6B, 0x34, 0x3B, 0x62, 0x2F, 0x1A, + 0x72, 0x26, 0xD3, 0x3B, 0x5D, 0xCE, 0x3B, 0xC9, + 0xA1, 0x28, 0xFE, 0xBD, 0x5E, 0x70, 0xC7, 0xB9, + 0x97, 0x65, 0xB8, 0xD3, 0x60, 0x03, 0x68, 0x54 + }, + { + 0x0E, 0x76, 0x28, 0xC6, 0xBC, 0x01, 0x98, 0x9E, + 0x2E, 0x50, 0x47, 0x4C, 0xC9, 0x4C, 0xE6, 0x69, + 0x17, 0xCC, 0x66, 0x35, 0x00, 0xA6, 0x16, 0xF6, + 0x69, 0x4D, 0x4E, 0x97, 0x01, 0xA7, 0x2F, 0x65 + }, + { + 0xDA, 0xDA, 0x23, 0x79, 0xA6, 0xE9, 0x50, 0xF2, + 0xA8, 0x25, 0x92, 0x9D, 0x08, 0x09, 0xFE, 0xDA, + 0xBA, 0x86, 0xBF, 0xDE, 0xFD, 0x67, 0xB0, 0xDC, + 0x35, 0x47, 0x97, 0x9E, 0xBC, 0x4B, 0xC1, 0x5B + }, + { + 0xAD, 0x29, 0xEE, 0x09, 0xEC, 0xB3, 0xA2, 0x6C, + 0xB8, 0x6C, 0xD4, 0xC9, 0xE6, 0xE9, 0x7B, 0x7D, + 0xEA, 0x4A, 0x42, 0xF5, 0x63, 0x92, 0xAE, 0xB6, + 0x9E, 0xAB, 0x2F, 0xF0, 0x04, 0xFE, 0x31, 0x87 + }, + { + 0x32, 0x84, 0x2A, 0x19, 0x3E, 0x15, 0x1D, 0x95, + 0x23, 0x2F, 0x77, 0xF6, 0x51, 0x91, 0x29, 0x55, + 0x46, 0xF2, 0x49, 0x80, 0xA2, 0xEE, 0xBD, 0xAE, + 0x97, 0x50, 0xC8, 0x18, 0xDD, 0x2D, 0x66, 0x47 + }, + { + 0x9A, 0x99, 0x43, 0x9F, 0x6E, 0x92, 0x93, 0xD2, + 0xB5, 0x4C, 0x89, 0xDD, 0x38, 0xD2, 0xA0, 0xFE, + 0x49, 0xBB, 0x32, 0x03, 0x94, 0x58, 0xEA, 0x32, + 0xF5, 0x6E, 0xCB, 0x4E, 0x7F, 0x6E, 0x0D, 0x28 + }, + { + 0x0C, 0xDB, 0x14, 0x92, 0xAA, 0x58, 0x77, 0x1E, + 0xD2, 0x77, 0x27, 0x4C, 0xC0, 0x2D, 0x3B, 0x93, + 0xFE, 0x06, 0x3B, 0x13, 0x22, 0x02, 0xDD, 0xAA, + 0xF1, 0x48, 0xE8, 0xC9, 0x57, 0xD8, 0x70, 0x90 + }, + { + 0xAE, 0x1F, 0x95, 0x26, 0xCB, 0x87, 0x28, 0x40, + 0x42, 0x81, 0x65, 0xCC, 0x37, 0xCC, 0xD2, 0x6D, + 0xBD, 0x07, 0x24, 0x9E, 0xCA, 0xFA, 0x1D, 0x1C, + 0x2B, 0x9C, 0x0E, 0x42, 0xF3, 0x3A, 0x15, 0x0A + }, + { + 0x1E, 0x30, 0x15, 0xD7, 0x2D, 0x27, 0x27, 0x58, + 0x36, 0x7C, 0x24, 0x81, 0x6E, 0xBC, 0x7B, 0xB0, + 0x15, 0x7E, 0xA6, 0x96, 0x17, 0x7B, 0x8E, 0x41, + 0x5A, 0x11, 0xB2, 0xFA, 0x0F, 0x6B, 0x99, 0xDF + }, + { + 0xA4, 0x0B, 0x70, 0x6E, 0x18, 0xEE, 0x6A, 0x0A, + 0x77, 0xD8, 0x7F, 0x8C, 0x79, 0x0B, 0xA1, 0x2B, + 0x90, 0xD6, 0x33, 0xD5, 0x5F, 0x65, 0x8E, 0x45, + 0xC6, 0x91, 0x3B, 0xA6, 0x56, 0x13, 0x54, 0x32 + }, + { + 0xB7, 0xD9, 0x60, 0x8C, 0x69, 0xA7, 0xD1, 0xBB, + 0xB2, 0x1B, 0x58, 0x3A, 0x96, 0xAC, 0x78, 0xB2, + 0xC1, 0xA6, 0x43, 0x20, 0x1A, 0x2E, 0xB0, 0x41, + 0x4B, 0xC8, 0x70, 0x02, 0x26, 0x20, 0x0B, 0xA3 + }, + { + 0x29, 0xCA, 0x50, 0x1D, 0x90, 0xBE, 0x15, 0x3A, + 0x9D, 0xCD, 0xBD, 0x2D, 0xDA, 0xED, 0xD1, 0xF4, + 0x45, 0x94, 0x4C, 0x0A, 0xDA, 0x96, 0x62, 0x60, + 0xA6, 0x1E, 0x02, 0x3B, 0xBA, 0x06, 0x31, 0xA4 + }, + { + 0x67, 0xDA, 0xCB, 0x77, 0xE4, 0x0C, 0x21, 0x51, + 0x30, 0x51, 0xD5, 0xC1, 0xE2, 0xDD, 0x80, 0x4D, + 0x08, 0x3D, 0x54, 0xA7, 0xD4, 0x77, 0x0B, 0x32, + 0xB6, 0xB1, 0x7B, 0xCE, 0x7C, 0x9C, 0x3F, 0xE4 + }, + { + 0x98, 0x3E, 0x91, 0x6E, 0x27, 0xBD, 0x89, 0x8D, + 0x0B, 0x21, 0xB3, 0x53, 0x46, 0x15, 0xAA, 0xBE, + 0x24, 0x03, 0x2B, 0x71, 0x1A, 0xD5, 0x6E, 0xCF, + 0x52, 0x82, 0xAA, 0x9C, 0xCE, 0xFE, 0x79, 0xE6 + }, + { + 0xFB, 0xEF, 0x0C, 0x2E, 0x63, 0x24, 0x70, 0xF7, + 0x60, 0x71, 0x4F, 0x2A, 0x5C, 0xD6, 0xDD, 0xE2, + 0x52, 0x84, 0x91, 0xCF, 0x6D, 0x44, 0xCD, 0xE2, + 0x9F, 0xAF, 0x5E, 0xAA, 0x62, 0x96, 0x68, 0x00 + }, + { + 0x5E, 0x87, 0x75, 0xD0, 0x19, 0x28, 0x7A, 0xF6, + 0x1E, 0x3D, 0x7B, 0xDC, 0x9E, 0x62, 0x9E, 0x77, + 0x80, 0xB9, 0x8F, 0x3A, 0x9D, 0x67, 0xB3, 0x17, + 0xD8, 0xA5, 0x45, 0x87, 0x2E, 0x24, 0x5D, 0x94 + }, + { + 0xFF, 0x26, 0x8A, 0x86, 0xFD, 0x55, 0x8F, 0x41, + 0x57, 0xE2, 0x95, 0x76, 0xA8, 0x35, 0xA3, 0x93, + 0xA2, 0x85, 0xEF, 0x06, 0x51, 0xE0, 0x96, 0xD6, + 0x43, 0xDC, 0x59, 0xB5, 0x9E, 0x9C, 0x05, 0xBB + }, + { + 0xA3, 0xFD, 0x3B, 0x9B, 0xA2, 0xAE, 0xFA, 0xAA, + 0x79, 0xFB, 0xDF, 0x4C, 0xC7, 0x83, 0x17, 0x6F, + 0x9C, 0x13, 0x3E, 0xBF, 0xF6, 0x92, 0xF1, 0x80, + 0xA7, 0x82, 0xFB, 0x6F, 0x95, 0x5D, 0x26, 0xED + }, + { + 0xF6, 0xE5, 0x9D, 0xC2, 0xD0, 0x39, 0x15, 0x3F, + 0x23, 0x63, 0x22, 0x6C, 0x09, 0x09, 0xF5, 0x17, + 0x02, 0x31, 0xAA, 0xF6, 0xEF, 0xC0, 0x81, 0xEF, + 0xBC, 0xBE, 0x39, 0x1D, 0x2F, 0x5F, 0x4C, 0x68 + }, + { + 0xB5, 0x4E, 0xB5, 0x14, 0x39, 0x0C, 0x19, 0xF7, + 0x39, 0x67, 0x02, 0x72, 0x83, 0x6F, 0xE5, 0x99, + 0x8A, 0xC4, 0xB3, 0xC8, 0x55, 0x6B, 0x8C, 0x20, + 0x4C, 0xB2, 0xD4, 0xB1, 0x23, 0x52, 0x3A, 0x45 + }, + { + 0xC5, 0x8D, 0x5D, 0x9C, 0x0D, 0x59, 0x10, 0x2A, + 0x4D, 0x5F, 0xDB, 0x70, 0xA0, 0x97, 0xDD, 0x64, + 0xB5, 0x89, 0x6D, 0x09, 0xDE, 0x86, 0x2A, 0x93, + 0xB8, 0x96, 0x1D, 0xC0, 0x63, 0x48, 0x2E, 0x35 + }, + { + 0xDE, 0x72, 0x81, 0x02, 0xE8, 0x06, 0xB3, 0x3A, + 0x8D, 0xCB, 0xB9, 0x9F, 0x6D, 0x14, 0x32, 0xC3, + 0x0D, 0x33, 0xB3, 0xD8, 0x78, 0xFC, 0xB2, 0x61, + 0xE4, 0x29, 0x9D, 0xE7, 0x34, 0x1A, 0xCA, 0x30 + }, + { + 0x03, 0xFC, 0x37, 0xD7, 0xBA, 0x03, 0x3B, 0x05, + 0x77, 0x30, 0x57, 0x2E, 0x06, 0x2E, 0x26, 0xA4, + 0x52, 0x17, 0x21, 0x56, 0x71, 0x6E, 0xF1, 0x22, + 0x5C, 0x0F, 0xE4, 0x26, 0xF0, 0x07, 0xE2, 0x2B + }, + { + 0x15, 0xED, 0x77, 0x43, 0xC2, 0xCD, 0xDC, 0x18, + 0x5A, 0x44, 0xAE, 0xBE, 0xC8, 0x88, 0xED, 0xE4, + 0xB5, 0xF2, 0x16, 0x04, 0x1F, 0x2D, 0x24, 0x9F, + 0xFE, 0xB7, 0x63, 0x77, 0xA4, 0xEA, 0xCD, 0x1A + }, + { + 0x1F, 0x5C, 0x17, 0xBD, 0x06, 0xE4, 0xF6, 0xD6, + 0xC0, 0x66, 0x0F, 0x9D, 0xEC, 0x2A, 0x15, 0x11, + 0xA0, 0x09, 0x21, 0xFD, 0xF1, 0x65, 0x7D, 0x35, + 0x75, 0x12, 0x1D, 0x22, 0x02, 0x9A, 0x35, 0x8B + }, + { + 0x81, 0x20, 0x01, 0x9E, 0xA2, 0xE9, 0x20, 0xE8, + 0xE3, 0x52, 0x63, 0x3B, 0xD9, 0x74, 0xC6, 0x16, + 0xBD, 0x5E, 0xFF, 0xCB, 0xE2, 0x58, 0x9A, 0xCF, + 0xAA, 0x90, 0xA2, 0xEF, 0x81, 0x5E, 0xF3, 0xFB + }, + { + 0x22, 0x0C, 0xB6, 0x40, 0x68, 0x02, 0x9B, 0x53, + 0x91, 0xB5, 0x96, 0x10, 0xC7, 0x57, 0x9B, 0xD6, + 0x10, 0x71, 0x00, 0x55, 0x1E, 0xB9, 0x42, 0xED, + 0xDD, 0xDB, 0x7D, 0x38, 0x2C, 0x28, 0xAF, 0x0A + }, + { + 0x8E, 0x8C, 0xE7, 0xCD, 0x0B, 0xE0, 0xCC, 0xBA, + 0xD7, 0x8F, 0x04, 0x50, 0x50, 0x1C, 0x08, 0x50, + 0xB6, 0xD5, 0x78, 0x68, 0x18, 0xE5, 0xA1, 0x2B, + 0x1C, 0x1C, 0x6C, 0x3A, 0x17, 0xDE, 0xFE, 0x4F + }, + { + 0x80, 0xEA, 0xAE, 0x58, 0x14, 0x01, 0xFA, 0x28, + 0xCB, 0xAA, 0xF4, 0xF5, 0x14, 0xA3, 0xB6, 0x2F, + 0x0B, 0xE0, 0xFD, 0xBB, 0xEC, 0x14, 0x8C, 0x5A, + 0x06, 0xB5, 0xCF, 0x7C, 0xEE, 0x15, 0x62, 0x18 + }, + { + 0x6A, 0xF1, 0xE0, 0x86, 0xE3, 0xE2, 0x86, 0xFE, + 0xF6, 0xC3, 0x2B, 0xD6, 0x17, 0xF7, 0xE0, 0xA6, + 0x99, 0x7B, 0xA5, 0x4D, 0xD8, 0x1D, 0x70, 0xE6, + 0x97, 0x5F, 0x5C, 0x29, 0x71, 0x27, 0x30, 0x2C + }, + { + 0x8C, 0xB4, 0xBA, 0x40, 0xB9, 0x8A, 0x56, 0xBC, + 0x1D, 0x9A, 0xC5, 0xFC, 0xB2, 0x50, 0x56, 0xA6, + 0x99, 0xB1, 0x9C, 0x8A, 0xA0, 0xD5, 0x7D, 0x8C, + 0x39, 0x9D, 0xE7, 0x2B, 0xCF, 0xBA, 0xC2, 0x36 + }, + { + 0xEC, 0x85, 0x58, 0x97, 0x45, 0x02, 0x2E, 0x81, + 0xE3, 0x6E, 0x9A, 0x18, 0xD7, 0x91, 0x75, 0x5E, + 0xDE, 0x7A, 0x7C, 0xAF, 0x45, 0x67, 0xE0, 0xAB, + 0xCD, 0x61, 0x29, 0xA4, 0xE8, 0x66, 0x4C, 0x45 + }, + { + 0xB5, 0x4C, 0x6C, 0x00, 0x35, 0x4F, 0xA7, 0x64, + 0x85, 0x20, 0x67, 0x20, 0xD0, 0xCE, 0x61, 0xD6, + 0x4D, 0x68, 0xFF, 0x74, 0xB8, 0xCC, 0xB6, 0xC2, + 0x61, 0xD1, 0x77, 0x7C, 0x71, 0x40, 0x83, 0x6B + }, + { + 0x6D, 0x92, 0xA1, 0xEA, 0xE3, 0x0B, 0x6B, 0x4B, + 0x24, 0x91, 0x09, 0xF3, 0x85, 0xE5, 0x9A, 0x49, + 0x06, 0x53, 0x68, 0xF1, 0xA7, 0x04, 0xEB, 0xD4, + 0x4B, 0x2B, 0x4B, 0x67, 0x29, 0x5B, 0x30, 0x16 + }, + { + 0x84, 0x56, 0x43, 0x1B, 0xB4, 0x09, 0x1B, 0xDD, + 0x96, 0x47, 0x28, 0x7A, 0x7E, 0x04, 0x68, 0x4C, + 0x33, 0x28, 0x61, 0x62, 0xAC, 0x69, 0x96, 0x11, + 0x43, 0xFF, 0xD6, 0x00, 0x03, 0xF4, 0x97, 0x49 + }, + { + 0xD3, 0x18, 0x20, 0x05, 0xAD, 0x7E, 0x38, 0x76, + 0xBD, 0x7E, 0xD7, 0x07, 0x5C, 0x62, 0x4C, 0x21, + 0xF6, 0x40, 0xE7, 0x1E, 0x8F, 0x25, 0x59, 0x79, + 0xB4, 0x33, 0xF5, 0x71, 0x14, 0x8F, 0xFB, 0x4F + }, + { + 0x0F, 0xDA, 0x13, 0x03, 0x46, 0xB4, 0x1F, 0x83, + 0x89, 0x1D, 0x80, 0x82, 0x0D, 0x5E, 0x15, 0x66, + 0x25, 0x9E, 0x2C, 0xE9, 0xD2, 0xBC, 0xC0, 0x79, + 0xE1, 0x65, 0x20, 0xC3, 0x19, 0xDC, 0x85, 0x58 + }, + { + 0x7F, 0x29, 0xE0, 0xDB, 0x23, 0x6D, 0x44, 0xF3, + 0xC9, 0x07, 0xA2, 0x65, 0x58, 0xE6, 0xD6, 0x65, + 0xC9, 0x5E, 0xD0, 0xAB, 0x62, 0x63, 0xF4, 0xAE, + 0xDD, 0x25, 0x9D, 0xE9, 0x1D, 0x9C, 0x2D, 0x60 + }, + { + 0xEB, 0xFF, 0xDC, 0x8F, 0x32, 0x99, 0xF1, 0xA2, + 0xCE, 0x79, 0xD9, 0x36, 0x56, 0x3C, 0x8B, 0x52, + 0xD0, 0xC5, 0xA8, 0x32, 0x8B, 0x0C, 0x64, 0x2B, + 0x3C, 0x13, 0x3A, 0xA9, 0x45, 0x0B, 0x0B, 0xDD + }, + { + 0x66, 0x63, 0xFC, 0xC7, 0x54, 0x8A, 0xD1, 0x45, + 0xF3, 0x5D, 0x92, 0x7E, 0x60, 0xA4, 0xB7, 0xD0, + 0xDD, 0x1D, 0x31, 0xFB, 0xCC, 0x40, 0x07, 0xB1, + 0x20, 0x31, 0x70, 0x9F, 0x1A, 0xFA, 0x30, 0x66 + }, + { + 0x3C, 0xF8, 0xAB, 0xF5, 0xB8, 0x22, 0xA6, 0xE4, + 0x75, 0x29, 0x18, 0xFF, 0x81, 0x6C, 0x3A, 0xCD, + 0xE2, 0x35, 0xA9, 0xAE, 0x60, 0x78, 0x49, 0xB6, + 0xC0, 0xC1, 0xA6, 0x82, 0x00, 0x6E, 0x73, 0xC4 + }, + { + 0x9C, 0x26, 0xCB, 0xF9, 0xCE, 0xEF, 0x36, 0x66, + 0x79, 0x59, 0xBE, 0x37, 0x24, 0xD3, 0x67, 0x0E, + 0x4E, 0xFE, 0x06, 0x24, 0x51, 0x37, 0x9B, 0x49, + 0x8D, 0xE1, 0x2B, 0x3B, 0xFA, 0x2F, 0x63, 0x03 + }, + { + 0x99, 0x76, 0x71, 0x5A, 0xF1, 0x1C, 0x41, 0x0C, + 0x22, 0x11, 0x61, 0xC7, 0x1C, 0x1F, 0xAC, 0xA4, + 0x79, 0x2C, 0xCD, 0xA2, 0x1E, 0xFB, 0xE1, 0x00, + 0x76, 0x3E, 0x21, 0xF1, 0x3E, 0xB5, 0x61, 0x7B + }, + { + 0x74, 0x73, 0x69, 0x09, 0x77, 0x0F, 0xEF, 0xA0, + 0x3E, 0xB3, 0xD9, 0x1F, 0x92, 0xE1, 0xF1, 0xC4, + 0xEC, 0x6C, 0x29, 0x04, 0x19, 0x4F, 0x46, 0x2E, + 0xB4, 0x70, 0x3D, 0xCE, 0x88, 0xBF, 0xC1, 0x77 + }, + { + 0xD8, 0x04, 0x05, 0x2A, 0xA4, 0x82, 0xD3, 0x91, + 0x9B, 0x91, 0xF6, 0x30, 0x6A, 0x61, 0x75, 0x05, + 0x60, 0x30, 0xC2, 0xD7, 0xB7, 0x1E, 0xAB, 0x05, + 0xE2, 0x6F, 0x04, 0xE7, 0xA0, 0xE1, 0xDC, 0xFC + }, + { + 0x6E, 0x0F, 0x4D, 0x35, 0xA1, 0x94, 0x5D, 0x39, + 0x80, 0x74, 0x8A, 0x73, 0x79, 0xC1, 0x9F, 0x36, + 0xF9, 0x66, 0x67, 0xA2, 0xA4, 0x01, 0xB1, 0x9F, + 0x35, 0x88, 0x16, 0xED, 0x62, 0xB9, 0x4D, 0x9A + }, + { + 0x0E, 0x6F, 0x5A, 0xDC, 0x08, 0xEB, 0x4D, 0xA5, + 0xD4, 0xDE, 0xDA, 0x63, 0x61, 0x40, 0x26, 0x81, + 0xE1, 0xFE, 0x5A, 0xEC, 0x45, 0xA9, 0xB0, 0x92, + 0x4A, 0xEB, 0xB2, 0x72, 0x17, 0x5D, 0xB1, 0xB8 + }, + { + 0x9F, 0xDD, 0x89, 0xCE, 0x8D, 0xD6, 0xF2, 0x32, + 0xE4, 0x8B, 0x4F, 0xBA, 0x2F, 0xC8, 0xE6, 0xC0, + 0x53, 0x11, 0x18, 0x68, 0xAD, 0xB7, 0xEC, 0x35, + 0x33, 0xE5, 0x97, 0xC3, 0x3B, 0x64, 0x0C, 0x34 + }, + { + 0x16, 0x5F, 0xA5, 0xC4, 0x48, 0x3E, 0xDF, 0x34, + 0x15, 0xED, 0x23, 0xA7, 0x41, 0xDA, 0xF6, 0x5B, + 0xF0, 0x87, 0x68, 0x89, 0x28, 0xE5, 0x1B, 0x1E, + 0xBE, 0x09, 0x03, 0xAB, 0xD3, 0x75, 0x9B, 0x83 + }, + { + 0x6C, 0xD8, 0xDC, 0x0A, 0x1D, 0xA4, 0xD7, 0x6D, + 0xBC, 0x97, 0x3D, 0x08, 0xDA, 0x9F, 0xBF, 0x8A, + 0x38, 0x3E, 0x53, 0x67, 0x9C, 0x09, 0xDF, 0x7F, + 0x90, 0xF4, 0x68, 0x03, 0x6C, 0x9D, 0xFD, 0x20 + }, + { + 0xEA, 0x2F, 0xB2, 0xA5, 0x1C, 0x10, 0x5E, 0xD8, + 0x59, 0xCC, 0x3C, 0xE7, 0xF7, 0x60, 0x40, 0xA4, + 0x96, 0xE8, 0x63, 0xC3, 0x67, 0x6F, 0x83, 0x60, + 0x97, 0x86, 0x1C, 0x81, 0x32, 0x44, 0xD9, 0xAA + }, + { + 0xB9, 0x5A, 0xE5, 0x1C, 0xA1, 0x89, 0x50, 0xA4, + 0xD9, 0xDF, 0x43, 0xCF, 0xDC, 0xDC, 0x46, 0xC7, + 0x7F, 0x9A, 0x21, 0xAF, 0x19, 0x95, 0x6F, 0x82, + 0x28, 0xD4, 0xC0, 0x77, 0x2E, 0x2B, 0xA3, 0xF1 + }, + { + 0x41, 0x7A, 0xE9, 0x93, 0x6F, 0x2F, 0xA2, 0x86, + 0xAE, 0xCC, 0xE1, 0x3E, 0x92, 0xE4, 0x12, 0x6B, + 0x00, 0x34, 0xD0, 0x0F, 0x21, 0x1C, 0x79, 0x97, + 0x64, 0x1C, 0xB8, 0x1B, 0xF4, 0x9E, 0x1B, 0x7C + }, + { + 0x99, 0x37, 0xB0, 0x07, 0x28, 0xBF, 0x31, 0xB1, + 0x42, 0x9B, 0x21, 0x9C, 0xC7, 0xB6, 0xC5, 0xA6, + 0x3E, 0x55, 0x99, 0x9C, 0x0E, 0x3F, 0x6E, 0xD0, + 0x1C, 0x67, 0x23, 0xC0, 0xD4, 0x80, 0x47, 0x92 + }, + { + 0x79, 0x78, 0x09, 0xA4, 0x7D, 0x79, 0x14, 0xFF, + 0x2B, 0xB0, 0x4D, 0x31, 0xB8, 0xFA, 0xCF, 0x40, + 0x47, 0x28, 0x1E, 0x43, 0x95, 0xDB, 0xA5, 0x0A, + 0xC2, 0x23, 0x07, 0x85, 0x63, 0x74, 0xD7, 0xF9 + }, + { + 0xBC, 0x5C, 0x2C, 0x6A, 0x49, 0x93, 0x6C, 0xAC, + 0xCD, 0xD7, 0x97, 0x02, 0x5B, 0x61, 0x0F, 0x32, + 0xDE, 0x94, 0xB1, 0x13, 0xB8, 0xF6, 0x98, 0x3E, + 0xF5, 0x22, 0xFF, 0x0E, 0x2E, 0x7A, 0x02, 0x98 + }, + { + 0x8A, 0x67, 0xB5, 0xEE, 0xEE, 0x50, 0x34, 0x17, + 0x7F, 0x50, 0xF0, 0x1A, 0x60, 0xB9, 0xF4, 0x3B, + 0x6C, 0x17, 0xBA, 0xAD, 0x91, 0x7F, 0x98, 0x94, + 0x62, 0xA7, 0xFD, 0x67, 0x62, 0x4A, 0x9B, 0x2B + }, + { + 0x5C, 0x55, 0xC7, 0x1A, 0x21, 0xEB, 0xCD, 0x63, + 0x35, 0x27, 0xD4, 0xBC, 0x70, 0xFD, 0x7F, 0xEC, + 0x86, 0x53, 0xF8, 0x3A, 0xF3, 0x3B, 0x06, 0x27, + 0xAD, 0x37, 0x23, 0xC0, 0x2D, 0x91, 0xA8, 0x58 + }, + { + 0x7E, 0x1E, 0x55, 0xAF, 0xE6, 0x6D, 0x29, 0xFB, + 0x29, 0xC6, 0x8A, 0xB2, 0x87, 0x74, 0x11, 0x9E, + 0xCA, 0x4C, 0xD9, 0x85, 0x43, 0x4B, 0xF0, 0xD7, + 0xF0, 0x2F, 0xE8, 0xC6, 0xAC, 0xB6, 0x9F, 0x5A + }, + { + 0x2F, 0x39, 0xF0, 0x5B, 0x91, 0xC4, 0x57, 0x6B, + 0x3C, 0x37, 0xF0, 0x0A, 0x00, 0xCA, 0x4B, 0xBF, + 0x79, 0xC5, 0xD5, 0xAA, 0xFE, 0xF8, 0x73, 0x18, + 0x77, 0xC6, 0x01, 0xA1, 0x4B, 0x84, 0xFA, 0xEF + }, + { + 0xEF, 0xA3, 0x79, 0x8C, 0x8B, 0xD6, 0x47, 0x83, + 0x25, 0x05, 0x04, 0xAD, 0x85, 0x89, 0xDA, 0x17, + 0x79, 0x52, 0x32, 0x0A, 0xF7, 0xB4, 0xFB, 0xDA, + 0xEE, 0x65, 0xC7, 0x48, 0x93, 0x6C, 0xC4, 0x1B + }, + { + 0xE8, 0x50, 0x0F, 0x52, 0xE7, 0x12, 0xB8, 0x79, + 0xAA, 0x2A, 0x2E, 0x5F, 0x18, 0x07, 0xDF, 0x21, + 0xE0, 0xEA, 0x51, 0x8E, 0x48, 0xDB, 0xCD, 0x34, + 0x27, 0xF1, 0x5D, 0x71, 0x02, 0x1D, 0x79, 0x64 + }, + { + 0x2C, 0x5C, 0x44, 0xAD, 0x09, 0xB5, 0xDA, 0xCE, + 0xE8, 0xFA, 0x51, 0xC1, 0x9E, 0x6C, 0x37, 0x80, + 0xA8, 0x05, 0xFA, 0x16, 0x18, 0xA3, 0xAD, 0x6A, + 0xA7, 0x53, 0xB5, 0x47, 0x4E, 0x23, 0xB8, 0x79 + }, + { + 0x7F, 0x05, 0x99, 0x39, 0x54, 0x83, 0xBD, 0xB7, + 0x08, 0x19, 0xCE, 0xD1, 0x64, 0x3E, 0xA9, 0x52, + 0xFF, 0x7A, 0x68, 0x07, 0x86, 0x96, 0x81, 0xF2, + 0x42, 0x04, 0x5B, 0xB1, 0xC8, 0xA7, 0xCE, 0x26 + }, + { + 0x1B, 0xD6, 0xD9, 0x21, 0x3D, 0xC6, 0xF6, 0x3D, + 0x38, 0xA3, 0x45, 0x76, 0xD0, 0x33, 0x32, 0xDC, + 0x10, 0x1A, 0x9B, 0x63, 0x22, 0x42, 0x2D, 0xC6, + 0x04, 0x89, 0x97, 0x01, 0x7F, 0x2E, 0x0B, 0xC7 + }, + { + 0x34, 0x10, 0x1C, 0xBD, 0xD5, 0x3A, 0xCA, 0xB7, + 0x17, 0x10, 0xA5, 0xE0, 0x81, 0x66, 0x06, 0xC5, + 0x26, 0x46, 0x80, 0x71, 0xFD, 0xD8, 0xC7, 0x94, + 0xD5, 0x30, 0x78, 0x55, 0x0B, 0x31, 0x25, 0x14 + }, + { + 0xFB, 0x93, 0x49, 0x01, 0xBE, 0xB3, 0x6F, 0xBF, + 0xB1, 0x36, 0x2D, 0x7D, 0xA5, 0x6B, 0x0C, 0xBA, + 0x76, 0x1A, 0xF7, 0xC1, 0x58, 0xB4, 0x56, 0xD8, + 0x8A, 0xF6, 0x00, 0xAA, 0xE3, 0x48, 0x42, 0x7D + }, + { + 0x55, 0x8B, 0x08, 0x4E, 0x5A, 0xD4, 0x20, 0xED, + 0x16, 0xE2, 0x44, 0x6C, 0x5A, 0x9C, 0x2D, 0xB5, + 0x4B, 0xC1, 0x1F, 0x4E, 0x0F, 0x05, 0x73, 0x4E, + 0x3F, 0x82, 0x89, 0xEF, 0x47, 0xB3, 0xA8, 0x8B + }, + { + 0xF5, 0x34, 0x39, 0xCA, 0x0D, 0x5A, 0x20, 0xCD, + 0xB1, 0xFA, 0x7E, 0x4D, 0x13, 0x17, 0x36, 0x1C, + 0x76, 0x6A, 0x86, 0x56, 0x65, 0x11, 0x3C, 0x97, + 0x85, 0xF7, 0x5E, 0x64, 0x24, 0x09, 0xC2, 0x23 + }, + { + 0xF7, 0xA2, 0xE5, 0xCE, 0x70, 0x66, 0x3B, 0xE9, + 0xE7, 0x56, 0xFC, 0xAA, 0xA6, 0x62, 0xC5, 0xA9, + 0x90, 0xAD, 0x6A, 0x55, 0xBF, 0xDC, 0x12, 0x41, + 0x45, 0x29, 0xDC, 0xA2, 0xCA, 0x42, 0xE7, 0x68 + }, + { + 0x45, 0xD7, 0x65, 0x2F, 0x0C, 0xF2, 0xC7, 0xE3, + 0x40, 0x06, 0xD2, 0x58, 0x4A, 0x22, 0xCB, 0x52, + 0x6C, 0x4A, 0x18, 0x33, 0x78, 0x93, 0xAE, 0xAC, + 0x43, 0xB2, 0xD8, 0xD9, 0x9C, 0x6E, 0x3C, 0x37 + }, + { + 0x5C, 0x1A, 0x25, 0x9A, 0xB3, 0x71, 0x43, 0x14, + 0xA2, 0x89, 0x50, 0xEA, 0x78, 0x74, 0x18, 0x24, + 0x19, 0x65, 0xDB, 0x64, 0xCB, 0x87, 0x5D, 0x8C, + 0x46, 0x7A, 0x2F, 0x16, 0xB7, 0x03, 0x3F, 0x6A + }, + { + 0xCE, 0x4F, 0x1E, 0x5A, 0x7F, 0xF5, 0x83, 0xD9, + 0x3D, 0xEC, 0x45, 0x3B, 0xAC, 0xD4, 0x5A, 0x14, + 0x90, 0xD6, 0x9B, 0xF9, 0x42, 0x64, 0x5A, 0x3F, + 0x5A, 0xE6, 0xB6, 0xD8, 0xB1, 0xA0, 0x35, 0xC5 + }, + { + 0x7E, 0x58, 0x1D, 0x36, 0x3A, 0xF8, 0x94, 0xB8, + 0x22, 0x4B, 0xCB, 0x08, 0x4C, 0xB4, 0xD4, 0x69, + 0xFE, 0x08, 0x28, 0x23, 0x45, 0x08, 0x79, 0xC8, + 0xA5, 0xF8, 0x67, 0x47, 0x8C, 0x75, 0xB7, 0xAC + }, + { + 0xCC, 0x6E, 0x98, 0x46, 0xF5, 0x8A, 0x96, 0x12, + 0x78, 0x0C, 0x69, 0x0B, 0x51, 0xBA, 0x4F, 0xFD, + 0xAD, 0x8C, 0x79, 0xE8, 0xE9, 0xE9, 0xB0, 0x6A, + 0x9A, 0x79, 0x4B, 0x81, 0xA0, 0xFE, 0x12, 0x3C + }, + { + 0xBA, 0x83, 0x30, 0xE4, 0x17, 0x0F, 0x8E, 0x8E, + 0xEC, 0xE0, 0x18, 0xC2, 0x87, 0x42, 0x5D, 0x0F, + 0x22, 0x02, 0x8D, 0xBF, 0x67, 0x4C, 0xED, 0xEB, + 0x8E, 0x53, 0xDF, 0xD7, 0x85, 0x66, 0x7B, 0xE6 + }, + { + 0x42, 0xCF, 0x4A, 0x31, 0x9C, 0x4A, 0xFC, 0x61, + 0x1D, 0xF1, 0xF2, 0x60, 0x44, 0x03, 0x20, 0x95, + 0x32, 0x09, 0xB1, 0x83, 0x99, 0x56, 0x0A, 0xB0, + 0xC2, 0xE2, 0x9C, 0xB1, 0x10, 0xB3, 0x42, 0x80 + }, + { + 0xFA, 0x7E, 0x15, 0x2F, 0x61, 0xAD, 0xD1, 0xD2, + 0xC1, 0xC6, 0x16, 0xF2, 0xF7, 0x51, 0xB2, 0x3F, + 0x6C, 0x46, 0x21, 0xAA, 0x99, 0xFB, 0x56, 0x55, + 0x41, 0xDF, 0xDC, 0x54, 0x4A, 0xBF, 0x65, 0x87 + }, + { + 0x5F, 0x83, 0xCE, 0x3F, 0xE0, 0x53, 0xE8, 0xE3, + 0x73, 0x6B, 0x97, 0x44, 0xF7, 0xA3, 0x90, 0x9A, + 0x8E, 0xDD, 0xF2, 0x7A, 0x55, 0xFC, 0x48, 0x57, + 0x26, 0x68, 0xB6, 0x0B, 0x10, 0x69, 0x04, 0xED + }, + { + 0x48, 0x80, 0xDA, 0x43, 0x41, 0xAB, 0x12, 0x06, + 0x5E, 0x23, 0x63, 0x30, 0x9C, 0xF9, 0x21, 0xD7, + 0xEB, 0x5D, 0xE3, 0x0A, 0x64, 0x69, 0xE7, 0x3E, + 0x88, 0x3E, 0x7C, 0x28, 0xC1, 0x44, 0xA3, 0x42 + }, + { + 0x45, 0xB6, 0x2C, 0x0F, 0xE5, 0x03, 0x47, 0x6C, + 0x64, 0x2A, 0x5A, 0x13, 0xA8, 0x20, 0x5E, 0x32, + 0x91, 0x8B, 0x38, 0x68, 0x42, 0xC5, 0x0D, 0x3E, + 0x1C, 0x57, 0xBF, 0xF5, 0xEB, 0x5F, 0x88, 0xDE + }, + { + 0x65, 0xEE, 0xCA, 0x37, 0xF3, 0xB3, 0xF6, 0x4A, + 0x76, 0x55, 0x78, 0xD5, 0x0D, 0x80, 0x71, 0x07, + 0x2A, 0x1B, 0x2A, 0xE4, 0x27, 0x04, 0x0A, 0x8E, + 0xAC, 0xCC, 0x39, 0xAD, 0x8E, 0x6B, 0x8C, 0x77 + }, + { + 0x7B, 0x3F, 0x6C, 0xF5, 0x3B, 0x09, 0x37, 0x13, + 0xB2, 0x06, 0x9B, 0xE6, 0x92, 0xA7, 0x93, 0x40, + 0x8E, 0x88, 0x42, 0xA9, 0xCC, 0xD4, 0xD4, 0xD5, + 0x7C, 0x8F, 0x89, 0xF0, 0x93, 0xEB, 0x52, 0x8D + }, + { + 0x3B, 0xAC, 0xDD, 0xC7, 0x4F, 0x7B, 0xDB, 0x70, + 0x59, 0x00, 0x49, 0x93, 0x77, 0x35, 0xD6, 0x37, + 0x00, 0xC5, 0x8F, 0xE0, 0x52, 0xA7, 0xD1, 0x43, + 0x77, 0x0E, 0x9B, 0x1E, 0x6E, 0x64, 0xCD, 0xD6 + }, + { + 0xBE, 0x7A, 0xF9, 0x15, 0xF2, 0xCA, 0xF1, 0x04, + 0xF2, 0x6B, 0xCE, 0x10, 0x4C, 0x5E, 0x20, 0xB9, + 0xE3, 0x30, 0x39, 0x20, 0x84, 0x91, 0x77, 0xE9, + 0xCC, 0xCF, 0x52, 0x93, 0x66, 0xCD, 0xE8, 0x38 + }, + { + 0x5B, 0x5F, 0x0A, 0xBA, 0x91, 0x2C, 0x6F, 0x14, + 0x98, 0x87, 0x13, 0xE0, 0x68, 0x70, 0x3B, 0xB4, + 0x27, 0xC0, 0xC4, 0xB5, 0xF7, 0xD1, 0x5F, 0x41, + 0x61, 0x22, 0x5C, 0xF9, 0x48, 0x4B, 0x87, 0x84 + }, + { + 0xAD, 0x87, 0xDF, 0x06, 0x25, 0xE1, 0xA9, 0xC6, + 0x46, 0xED, 0xD5, 0xBB, 0xB1, 0x2E, 0x3E, 0x84, + 0x33, 0x06, 0xCD, 0xDC, 0xD1, 0x2D, 0xE3, 0x49, + 0x90, 0xE4, 0xFC, 0x19, 0x6D, 0x58, 0xA2, 0xA2 + }, + { + 0x43, 0x27, 0x36, 0x37, 0x37, 0x49, 0x6B, 0x45, + 0x2D, 0xCB, 0xF3, 0x41, 0xA6, 0xFF, 0x99, 0xB9, + 0x1B, 0xAB, 0x0A, 0x77, 0x4A, 0xC6, 0x26, 0x38, + 0xA3, 0xF8, 0xD0, 0x61, 0xA4, 0x26, 0x7C, 0xCC + }, + { + 0xF8, 0x44, 0x1C, 0x64, 0xAE, 0xB1, 0x04, 0x99, + 0x76, 0x64, 0x25, 0xE4, 0x3D, 0xDF, 0x7D, 0xC6, + 0x04, 0x9E, 0xFD, 0x68, 0xBC, 0xA1, 0xF7, 0xFB, + 0xF3, 0xB1, 0xB2, 0x0A, 0xE2, 0xF8, 0xFA, 0xF9 + }, + { + 0x09, 0x15, 0xC7, 0xF8, 0xC2, 0x6A, 0x38, 0xFA, + 0x62, 0xBF, 0xDD, 0xEC, 0x0F, 0x01, 0xF7, 0x2A, + 0xC5, 0x7E, 0xDA, 0xAC, 0xCC, 0x5E, 0xEE, 0xB3, + 0xFC, 0xB1, 0x52, 0x7C, 0x69, 0xAA, 0x8D, 0xFD + }, + { + 0xD6, 0x20, 0xB2, 0xDB, 0xFB, 0xD3, 0x68, 0x6E, + 0xC2, 0x89, 0xD2, 0xA3, 0x96, 0x70, 0xAB, 0x4D, + 0x95, 0x9F, 0xE3, 0xDF, 0x30, 0x5C, 0xAF, 0x13, + 0x70, 0xB7, 0x9D, 0x39, 0x6E, 0x60, 0x8D, 0xEA + }, + { + 0x57, 0x7B, 0x1D, 0xF5, 0x1E, 0x00, 0xBB, 0x40, + 0x78, 0x0C, 0xE7, 0x5F, 0x2F, 0x9F, 0x64, 0xCC, + 0x6F, 0x8D, 0xC3, 0xE0, 0x07, 0xEA, 0xC7, 0x95, + 0xCA, 0x1D, 0x39, 0x4B, 0xA9, 0xCF, 0xF5, 0x9F + }, + { + 0x34, 0xE7, 0xAF, 0x51, 0xFB, 0xC1, 0x16, 0x5C, + 0xD5, 0x54, 0x68, 0x52, 0x75, 0xF9, 0x98, 0x18, + 0x8E, 0xE5, 0xCB, 0x62, 0xCC, 0x4D, 0x04, 0x18, + 0x8E, 0xC7, 0xDD, 0x0C, 0xF3, 0x30, 0xB5, 0x1A + }, + { + 0xCB, 0xEB, 0xB2, 0x64, 0x04, 0xE1, 0xFD, 0x0E, + 0x46, 0xF7, 0x4A, 0x4A, 0x2D, 0xCE, 0x73, 0xA8, + 0x12, 0x30, 0xBC, 0x6B, 0x50, 0xA3, 0x4B, 0x15, + 0xBB, 0x70, 0x71, 0xFD, 0x25, 0x7D, 0x02, 0x9D + }, + { + 0x0B, 0x21, 0x50, 0xB2, 0x22, 0xE2, 0x11, 0x77, + 0xFB, 0x61, 0x11, 0xB9, 0x33, 0xC9, 0xF7, 0x86, + 0xED, 0x9B, 0x77, 0xE1, 0xA6, 0x4B, 0x34, 0xBD, + 0xD0, 0xE1, 0x9C, 0x0C, 0x08, 0xB3, 0xC2, 0xB6 + }, + { + 0x6E, 0x11, 0x80, 0x18, 0x38, 0x67, 0x16, 0xD2, + 0x94, 0x72, 0x00, 0xED, 0x11, 0x2F, 0x4B, 0x9D, + 0x52, 0xFD, 0xCD, 0x3C, 0x31, 0x20, 0xD7, 0xD1, + 0xD5, 0xB2, 0x10, 0x13, 0x54, 0x44, 0x17, 0x52 + }, + { + 0x07, 0x4F, 0xA3, 0xF0, 0x8A, 0x02, 0xCD, 0x9E, + 0x47, 0x50, 0x51, 0x43, 0xBB, 0xD0, 0xA3, 0x4B, + 0x1B, 0x28, 0xCF, 0xD4, 0xE5, 0x01, 0xE2, 0x7E, + 0x6E, 0xE3, 0xE1, 0x3F, 0xC3, 0xBB, 0xAA, 0x90 + }, + { + 0x5B, 0xC8, 0xF6, 0x8B, 0x46, 0xEF, 0x68, 0x6E, + 0x9C, 0x30, 0xC3, 0xF7, 0x63, 0xC8, 0x48, 0xDC, + 0x96, 0xA5, 0x2E, 0x82, 0xEA, 0xBB, 0x4B, 0xA3, + 0xC3, 0x0D, 0xAE, 0x0C, 0x63, 0x3A, 0x95, 0xBC + }, + { + 0xE4, 0xC4, 0x27, 0xE7, 0xA4, 0x61, 0xCD, 0xD2, + 0x5B, 0xD8, 0x99, 0x5A, 0xF8, 0x7A, 0xEF, 0xAE, + 0xE1, 0x7A, 0xCC, 0x4A, 0x53, 0x16, 0x8F, 0xF6, + 0x85, 0x21, 0x64, 0x95, 0x3B, 0x18, 0x7A, 0x4D + }, + { + 0x44, 0xC6, 0xA4, 0x4D, 0xAA, 0xD2, 0x35, 0xAB, + 0x41, 0xF6, 0x09, 0x45, 0x17, 0x7C, 0x25, 0x3D, + 0x53, 0xAE, 0x49, 0xC3, 0x7F, 0x5C, 0xEA, 0x7B, + 0xF4, 0xDD, 0x82, 0x21, 0x60, 0xC5, 0xC6, 0x7D + }, + { + 0x3F, 0x70, 0x82, 0x4C, 0x91, 0xA6, 0x3C, 0xDD, + 0x35, 0xE9, 0x2D, 0xAA, 0x73, 0xAC, 0x40, 0x8C, + 0xBD, 0x90, 0x83, 0x59, 0x77, 0xF0, 0x69, 0x8C, + 0x1E, 0xC4, 0xD1, 0xA1, 0x6C, 0x44, 0x9B, 0xAB + }, + { + 0xA3, 0x26, 0x03, 0xD9, 0x40, 0x80, 0x7A, 0xFB, + 0x13, 0x27, 0x26, 0x66, 0x0C, 0x16, 0x73, 0x9E, + 0x69, 0x15, 0xD5, 0xBD, 0x42, 0xBF, 0x0F, 0x37, + 0x4B, 0x3D, 0x4B, 0x7D, 0xBB, 0x2C, 0x0D, 0x05 + }, + { + 0x41, 0xFC, 0x22, 0xD7, 0x56, 0x58, 0x07, 0x70, + 0xA4, 0x88, 0xE2, 0xDE, 0xD6, 0xBB, 0xB9, 0x9E, + 0xD4, 0xF4, 0xF7, 0x95, 0x33, 0x34, 0xCD, 0x56, + 0xEF, 0x86, 0x12, 0xCD, 0xB9, 0x26, 0x5E, 0x9A + }, + { + 0xB0, 0xBD, 0x00, 0x79, 0x28, 0xBF, 0x07, 0x6D, + 0xE6, 0xB7, 0x5C, 0x12, 0x71, 0x10, 0x92, 0xFC, + 0x24, 0x75, 0x41, 0x42, 0x93, 0xE2, 0x9B, 0x5C, + 0xAC, 0x5E, 0x51, 0x74, 0x7B, 0xA1, 0x25, 0xBE + }, + { + 0x4A, 0x4F, 0xBC, 0x45, 0x09, 0x24, 0x09, 0x52, + 0x92, 0xB1, 0xF4, 0x3C, 0xF1, 0x2F, 0x20, 0x73, + 0xBB, 0x02, 0x25, 0x84, 0x6F, 0x53, 0x91, 0xF9, + 0x10, 0x47, 0x5A, 0xFD, 0xD7, 0xCC, 0x9C, 0x80 + }, + { + 0xC5, 0x7C, 0x71, 0xD4, 0x76, 0x41, 0x8D, 0xD6, + 0x91, 0x9B, 0x11, 0x79, 0x52, 0x04, 0xB1, 0xFB, + 0x5A, 0x49, 0x20, 0x3D, 0x01, 0x6F, 0x17, 0xDE, + 0x5C, 0xBB, 0xFF, 0x27, 0x2D, 0x97, 0xEC, 0x8D + }, + { + 0x3F, 0xFE, 0x7B, 0x2A, 0x93, 0x02, 0xFE, 0x41, + 0xD2, 0xBD, 0xEE, 0xE4, 0xC3, 0xFF, 0x88, 0x24, + 0x49, 0xF3, 0x98, 0xED, 0x37, 0x0C, 0xA8, 0xA4, + 0xF7, 0x39, 0x49, 0x45, 0xBD, 0x99, 0xA2, 0xDF + }, + { + 0x83, 0x30, 0x67, 0x54, 0x54, 0x94, 0xFD, 0x33, + 0x62, 0xCA, 0xA3, 0x13, 0x10, 0x76, 0x9E, 0x1D, + 0xF8, 0x41, 0xD0, 0xFC, 0x1A, 0x08, 0xE9, 0x93, + 0x2D, 0x52, 0x30, 0xB1, 0x61, 0x94, 0xFD, 0x1F + }, + { + 0xA8, 0x8A, 0xC0, 0x55, 0x81, 0x71, 0x72, 0x98, + 0xB7, 0x54, 0x0E, 0x80, 0x36, 0x9F, 0x0E, 0x86, + 0xB3, 0xE3, 0x25, 0x41, 0x5E, 0xC7, 0x0E, 0xC5, + 0xF8, 0x06, 0x7F, 0x66, 0x6B, 0x12, 0x87, 0x39 + }, + { + 0xA5, 0x09, 0x68, 0xD5, 0x0F, 0xC8, 0x8C, 0x26, + 0x88, 0x78, 0xA4, 0x7D, 0xBA, 0x28, 0x78, 0x92, + 0xFF, 0x7C, 0x78, 0x82, 0xEA, 0x99, 0x49, 0x94, + 0x2F, 0xFE, 0xB9, 0x08, 0x29, 0xF4, 0x07, 0x29 + }, + { + 0xDE, 0xA6, 0x6F, 0x7D, 0x55, 0xEC, 0x00, 0xB2, + 0x84, 0xA2, 0xB4, 0x06, 0x81, 0x11, 0xC7, 0xD9, + 0x69, 0xBC, 0xAE, 0x2E, 0x13, 0x1E, 0x92, 0xC6, + 0x02, 0xEE, 0xF0, 0x52, 0x07, 0xE0, 0x91, 0x95 + }, + { + 0xE5, 0xCB, 0xFF, 0xF6, 0x22, 0x0C, 0xE4, 0x6A, + 0xD5, 0x3B, 0xF8, 0x7F, 0xE4, 0x25, 0x05, 0x59, + 0x5A, 0xFF, 0x3A, 0x8C, 0xE1, 0x1C, 0x29, 0x14, + 0xAE, 0xFC, 0xE5, 0x30, 0xB1, 0xD3, 0xC6, 0x4B + }, + { + 0x41, 0x00, 0x1F, 0x1E, 0x51, 0x30, 0x72, 0xAA, + 0x5D, 0x56, 0xDD, 0x29, 0x5C, 0x6E, 0xD6, 0x28, + 0x51, 0x3A, 0xEA, 0x6D, 0x4B, 0x4B, 0x9F, 0xC5, + 0xBE, 0xEB, 0x47, 0x43, 0x6D, 0xAF, 0x91, 0x73 + }, + { + 0x5B, 0x7F, 0x47, 0x03, 0x40, 0xE9, 0x8C, 0xF9, + 0xF0, 0x59, 0x8B, 0xB4, 0x3E, 0xDE, 0x14, 0x90, + 0x3C, 0xEE, 0x50, 0x5D, 0xC3, 0xDD, 0x41, 0xBD, + 0x1D, 0x05, 0x91, 0x3F, 0xE5, 0x34, 0xDB, 0x30 + }, + { + 0x0A, 0xC6, 0x64, 0x37, 0x42, 0xD4, 0x53, 0xFD, + 0x65, 0xD7, 0xFC, 0x8B, 0x35, 0xC9, 0x5B, 0x16, + 0x9B, 0x42, 0x99, 0x81, 0x7C, 0xA0, 0xBD, 0xCE, + 0x50, 0x1E, 0xE1, 0xED, 0x7C, 0x95, 0xA6, 0x9A + }, + { + 0xF7, 0x97, 0x0C, 0xC9, 0xE4, 0xE6, 0x9B, 0x24, + 0x10, 0x78, 0x8B, 0xE8, 0x1E, 0xA6, 0x25, 0xB5, + 0x1E, 0xDD, 0x09, 0x01, 0xD3, 0xC7, 0x51, 0xFC, + 0x50, 0x37, 0x11, 0x70, 0x79, 0x91, 0xC1, 0x13 + }, + { + 0x2B, 0xD4, 0xC3, 0x2C, 0xB8, 0x56, 0xDD, 0xAF, + 0xA0, 0x21, 0x51, 0x4D, 0xB7, 0xC4, 0x46, 0x1B, + 0xA4, 0xFA, 0xF0, 0x53, 0x03, 0xB6, 0xB6, 0x58, + 0x07, 0xE5, 0xA9, 0xD3, 0xF1, 0x92, 0x9F, 0x90 + }, + { + 0x04, 0xAC, 0x0E, 0x98, 0x66, 0x37, 0xEA, 0x1D, + 0xA4, 0x8D, 0x13, 0x89, 0xEE, 0x68, 0xBC, 0x35, + 0x9B, 0xD3, 0x0A, 0x77, 0xD0, 0x2F, 0x8C, 0xA5, + 0x7A, 0xFA, 0x57, 0xEC, 0x35, 0xFD, 0x1B, 0xEA + }, + { + 0x91, 0x12, 0x86, 0xA4, 0x37, 0x05, 0x25, 0xAE, + 0x8A, 0x91, 0x75, 0x0F, 0x96, 0xEF, 0x82, 0x63, + 0x5A, 0x02, 0xFA, 0x1D, 0xFB, 0xA5, 0x8E, 0xD2, + 0xC4, 0x4B, 0x86, 0x49, 0xE3, 0x91, 0x34, 0xB3 + }, + { + 0x96, 0xEC, 0xFA, 0x1B, 0xF2, 0xA1, 0x13, 0xB0, + 0x1D, 0x09, 0x60, 0x5E, 0xDA, 0x42, 0xC3, 0x31, + 0xF7, 0xA7, 0xDF, 0xEF, 0x48, 0xA9, 0x5B, 0xC5, + 0x89, 0xEE, 0x5E, 0x45, 0x5A, 0x7D, 0x80, 0xB5 + }, + { + 0xF5, 0x47, 0xBE, 0x2D, 0xB2, 0xFD, 0xBF, 0x22, + 0x33, 0x30, 0x16, 0x2D, 0xDC, 0xCF, 0xD4, 0xAE, + 0x7E, 0x00, 0xBA, 0x26, 0x01, 0x24, 0x91, 0x7D, + 0xF8, 0x09, 0xC9, 0x10, 0xC0, 0xA2, 0x95, 0xCF + }, + { + 0x95, 0xD4, 0x8B, 0x30, 0xC5, 0x66, 0x06, 0x1C, + 0xAA, 0x31, 0x99, 0x16, 0x24, 0x60, 0x80, 0xA9, + 0x0B, 0x0B, 0xA2, 0xC1, 0x25, 0xA9, 0x62, 0xD9, + 0xE4, 0x9F, 0x62, 0xA0, 0xBA, 0xFE, 0x09, 0xAD + }, + { + 0xA9, 0x39, 0xD3, 0xDC, 0x91, 0x1D, 0xA8, 0x0A, + 0xAB, 0x17, 0xE1, 0xA6, 0x04, 0x0D, 0xF8, 0x22, + 0x84, 0x75, 0x26, 0x1E, 0x88, 0xF0, 0x79, 0x8D, + 0x5D, 0xE9, 0x2B, 0x20, 0x14, 0xAC, 0x2F, 0x86 + }, + { + 0x3E, 0xAE, 0xBE, 0x14, 0x03, 0xC1, 0x38, 0xAF, + 0xA5, 0x37, 0x62, 0xEF, 0xEF, 0xD1, 0x19, 0x08, + 0xFD, 0x15, 0x95, 0x31, 0xE0, 0xF6, 0x1F, 0xE1, + 0x8E, 0x11, 0x59, 0x8F, 0x22, 0x07, 0xF9, 0xB7 + }, + { + 0xF8, 0x3E, 0x4A, 0x56, 0x1A, 0x34, 0xC1, 0x5C, + 0xBD, 0x4A, 0xCB, 0x9E, 0xF7, 0xFC, 0xDC, 0x8C, + 0xBD, 0xC8, 0x4A, 0xD5, 0x3B, 0xA5, 0x4B, 0x2A, + 0xFE, 0x50, 0x17, 0x6A, 0x30, 0x9E, 0x43, 0xA4 + }, + { + 0x1F, 0x4B, 0xE5, 0x06, 0x71, 0x85, 0xE8, 0xEB, + 0xBF, 0x83, 0xF8, 0xF7, 0x1F, 0x74, 0x84, 0x67, + 0x0E, 0x10, 0xFA, 0x59, 0x9A, 0x93, 0xED, 0x6E, + 0xFB, 0x3E, 0x8A, 0x93, 0xF3, 0xDD, 0x8A, 0x20 + }, + { + 0xD9, 0xB8, 0xA1, 0x8F, 0xE0, 0xD2, 0x5D, 0x80, + 0x25, 0x50, 0x69, 0xBA, 0x91, 0xF4, 0x83, 0xA5, + 0x2A, 0x4E, 0x8C, 0x28, 0x0B, 0x0A, 0x22, 0x48, + 0xE2, 0xB8, 0x3D, 0x11, 0xF1, 0xEC, 0x16, 0x52 + }, + { + 0x62, 0xFF, 0xA5, 0xCE, 0xAB, 0x7B, 0x44, 0xDD, + 0x9E, 0xD5, 0x52, 0x0F, 0x2D, 0x10, 0xDE, 0xE2, + 0x0C, 0x2C, 0x8F, 0xA8, 0xDB, 0x29, 0xB9, 0xAB, + 0x11, 0x68, 0x69, 0x6F, 0xCB, 0xEE, 0x14, 0x07 + }, + { + 0x7C, 0xA2, 0x70, 0xD1, 0x85, 0x2A, 0x27, 0x04, + 0x16, 0xE4, 0xBB, 0x01, 0x34, 0xA4, 0x96, 0x17, + 0x15, 0xE7, 0x26, 0x36, 0xB2, 0x38, 0x2C, 0xE0, + 0xC1, 0xBC, 0xE6, 0x6A, 0x4A, 0xDF, 0x15, 0xE0 + }, + { + 0xB0, 0x96, 0x3D, 0x4A, 0x39, 0xE4, 0x1B, 0x04, + 0x9A, 0x68, 0xAB, 0xBB, 0x0A, 0x79, 0xF6, 0x73, + 0x08, 0xC0, 0x88, 0x9E, 0xB6, 0x3E, 0xDE, 0xC1, + 0x46, 0x19, 0xD5, 0xAF, 0xFC, 0x07, 0x88, 0xA6 + }, + { + 0xA8, 0x97, 0xC9, 0x9C, 0xE1, 0xBA, 0xC9, 0xDC, + 0x18, 0xFC, 0x2C, 0x26, 0x8D, 0xF4, 0x71, 0xCB, + 0xF3, 0x4F, 0xC7, 0x84, 0x0A, 0x10, 0x3D, 0x0C, + 0x4C, 0xE8, 0x78, 0x8D, 0x32, 0xD7, 0xEF, 0xE2 + }, + { + 0x85, 0x9C, 0xA4, 0xA5, 0x59, 0x9E, 0xCD, 0x12, + 0x89, 0xCD, 0x73, 0x2D, 0x1F, 0xAA, 0x18, 0x1D, + 0xB8, 0xFC, 0x34, 0x84, 0x80, 0xA7, 0x2C, 0x3D, + 0xFA, 0x0D, 0x2A, 0x03, 0xCE, 0x36, 0xBD, 0x52 + }, + { + 0xF0, 0x2F, 0xE1, 0xF3, 0xEE, 0xD0, 0x0C, 0x1B, + 0x01, 0x12, 0xDD, 0xD0, 0xCD, 0x24, 0xCB, 0xB5, + 0xA9, 0xEE, 0xCE, 0x5A, 0xC4, 0xBD, 0x20, 0x2C, + 0xD4, 0x7E, 0xAA, 0xC2, 0x5E, 0xE6, 0x3A, 0xFD + }, + { + 0xD0, 0x60, 0xEA, 0x05, 0xA5, 0x00, 0x84, 0x29, + 0xA8, 0xA8, 0x63, 0x89, 0xDD, 0xCD, 0x52, 0x98, + 0x1D, 0x45, 0x72, 0xA4, 0xF6, 0x28, 0x2D, 0xA1, + 0x20, 0x62, 0xF3, 0xFD, 0x5D, 0x09, 0x46, 0x73 + }, + { + 0x9D, 0x50, 0x99, 0x0C, 0x92, 0x62, 0x32, 0x04, + 0x8A, 0x9C, 0x17, 0x64, 0xDA, 0xD2, 0x61, 0x43, + 0x23, 0x9D, 0x95, 0xED, 0x28, 0xEF, 0x82, 0x05, + 0x12, 0x27, 0xE0, 0x2B, 0x67, 0x2D, 0x23, 0xC3 + }, + { + 0x81, 0x9A, 0xEC, 0xC4, 0x17, 0x75, 0xC9, 0x0E, + 0x87, 0xAE, 0x9B, 0xA4, 0x08, 0xC8, 0x05, 0x60, + 0x3A, 0x8A, 0x29, 0x8B, 0x76, 0x7A, 0x13, 0x01, + 0x9A, 0xD5, 0x13, 0x78, 0x9D, 0xEF, 0x7F, 0xA9 + }, + { + 0x5A, 0xA9, 0x23, 0x07, 0x33, 0x22, 0xCE, 0x11, + 0x87, 0xEE, 0x31, 0xD7, 0x13, 0x5D, 0x53, 0xA0, + 0x1B, 0x4A, 0x1B, 0xF8, 0x82, 0x17, 0xAE, 0x3C, + 0xA3, 0x05, 0xA2, 0x24, 0xEE, 0x81, 0xC1, 0x18 + }, + { + 0x32, 0xFC, 0xB9, 0xA3, 0xE8, 0xF7, 0x55, 0x14, + 0x48, 0xDE, 0x10, 0x0F, 0x42, 0x38, 0xF0, 0x3A, + 0xA9, 0xE8, 0x06, 0x85, 0xC1, 0x3E, 0xA5, 0x6B, + 0x0E, 0x53, 0xD0, 0x33, 0x79, 0x22, 0x14, 0x1F + }, + { + 0x77, 0x0C, 0x8C, 0x7E, 0xE3, 0xBD, 0xAC, 0xEC, + 0x9B, 0x1D, 0x45, 0x4C, 0x9F, 0x05, 0x85, 0xEE, + 0x94, 0xB4, 0xE6, 0xC3, 0xCC, 0x9B, 0xBD, 0x80, + 0x29, 0x78, 0xA8, 0x10, 0xB7, 0x40, 0x75, 0x8B + }, + { + 0x5C, 0x6F, 0xA3, 0x5B, 0x6D, 0xE7, 0x9F, 0x99, + 0x50, 0x49, 0x56, 0x41, 0xD9, 0x51, 0xBD, 0xEB, + 0xF9, 0x58, 0x5A, 0xE8, 0x9F, 0xF9, 0x9E, 0x26, + 0x48, 0x67, 0xCF, 0xCA, 0x5D, 0x2E, 0xF9, 0x62 + }, + { + 0xE6, 0x93, 0x9E, 0xB7, 0xAE, 0x85, 0xF8, 0x77, + 0x1F, 0xCA, 0xEB, 0x59, 0x7E, 0x49, 0x32, 0xB9, + 0x61, 0x9D, 0x2C, 0x87, 0x87, 0xBB, 0x8E, 0xE3, + 0x0B, 0x09, 0x53, 0xB6, 0x98, 0xEA, 0x11, 0x5D + }, + { + 0x16, 0xCB, 0x57, 0x61, 0x36, 0xC0, 0x19, 0x8B, + 0x7D, 0x42, 0x65, 0x19, 0xCB, 0xB5, 0x88, 0x63, + 0x45, 0x0E, 0xC3, 0xF8, 0x23, 0x84, 0x3F, 0x00, + 0xCC, 0x27, 0x52, 0x29, 0xE6, 0xDB, 0x72, 0x63 + }, + { + 0x3E, 0xA6, 0xCA, 0x46, 0xEA, 0x93, 0xD0, 0x02, + 0x57, 0xA2, 0x0E, 0xDE, 0x62, 0x66, 0xF4, 0x68, + 0xFF, 0xB4, 0xF0, 0x6E, 0x6A, 0x9E, 0x51, 0x9D, + 0xCE, 0xDA, 0xBE, 0x9B, 0xC8, 0xA2, 0xE4, 0x45 + }, + { + 0xB7, 0xA3, 0xBE, 0xD7, 0x44, 0xB9, 0xE3, 0xD0, + 0x34, 0x9D, 0x7B, 0x1F, 0x65, 0x52, 0x51, 0xB6, + 0x92, 0xAD, 0x45, 0xD0, 0xB1, 0x4B, 0x15, 0xDB, + 0x07, 0x40, 0xBD, 0x72, 0x64, 0xCF, 0x3C, 0x2C + }, + { + 0xF9, 0x0D, 0x1F, 0x3A, 0xED, 0x9C, 0x40, 0xC1, + 0x52, 0xC5, 0xDD, 0xDF, 0xB0, 0xCA, 0x21, 0xB7, + 0x01, 0xC8, 0xBC, 0x10, 0x36, 0x0F, 0x62, 0x59, + 0xF0, 0x8E, 0xC6, 0x3D, 0x05, 0x64, 0x9C, 0x52 + }, + { + 0x35, 0x2F, 0xB2, 0xE3, 0x1D, 0x3C, 0x6D, 0x59, + 0xE0, 0xBF, 0x8F, 0xEF, 0xF6, 0xB2, 0x5C, 0x8F, + 0x57, 0xC7, 0x1A, 0x9C, 0x2D, 0xBD, 0x36, 0xBD, + 0x14, 0x19, 0x97, 0xAE, 0xB1, 0x09, 0xE0, 0xDC + }, + { + 0x1D, 0xB9, 0x96, 0xC3, 0x7D, 0xF5, 0x40, 0x5F, + 0x57, 0xB6, 0xBE, 0x0B, 0xE4, 0xEE, 0xDF, 0xAF, + 0xC4, 0x67, 0x26, 0xF0, 0x4E, 0x33, 0x62, 0x6E, + 0xBA, 0x35, 0x1B, 0xFD, 0x3A, 0x70, 0x44, 0xF4 + }, + { + 0xA6, 0xF0, 0xD8, 0x47, 0xF1, 0x1D, 0xF5, 0x3B, + 0xDA, 0x6D, 0xC7, 0xAC, 0xE2, 0x74, 0xBA, 0xC7, + 0xB2, 0x8D, 0xEC, 0xBE, 0xD5, 0x34, 0x7C, 0xFB, + 0xEB, 0x03, 0x59, 0x80, 0x78, 0xE2, 0x8A, 0x7D + }, + { + 0x59, 0xDE, 0x4D, 0x8D, 0xFF, 0x76, 0xCC, 0x31, + 0xC3, 0x50, 0x62, 0x4C, 0x88, 0x4C, 0x4D, 0x57, + 0xDE, 0x79, 0xA9, 0x03, 0x94, 0xE4, 0x89, 0x28, + 0xE9, 0x4B, 0xA0, 0x84, 0xE4, 0xF1, 0x72, 0x60 + }, + { + 0x2E, 0x3B, 0xC3, 0x54, 0x70, 0x7C, 0x84, 0x3E, + 0x34, 0x88, 0x5F, 0x0A, 0xA5, 0x40, 0x7D, 0x07, + 0x6E, 0x80, 0x2F, 0x99, 0x1F, 0x92, 0x1A, 0x79, + 0x06, 0xC3, 0xCB, 0x31, 0xF4, 0x73, 0x6B, 0x3F + }, + { + 0x72, 0x80, 0x92, 0x55, 0x90, 0x3B, 0xC4, 0x68, + 0xF0, 0xA9, 0x09, 0x83, 0x90, 0x6A, 0x30, 0x5B, + 0x74, 0x28, 0x7B, 0x51, 0xD7, 0xDA, 0xE2, 0x50, + 0x30, 0x7B, 0xCE, 0xD5, 0xF2, 0xF4, 0x29, 0x20 + }, + { + 0x74, 0x0C, 0x33, 0xD2, 0x2D, 0x1C, 0xF9, 0x0A, + 0x36, 0xCC, 0xB4, 0x1F, 0xA3, 0xE7, 0xC1, 0x18, + 0xA4, 0xCB, 0x1C, 0xE3, 0x5F, 0x72, 0x8B, 0xA6, + 0xC0, 0xEE, 0xD3, 0x8D, 0x15, 0xEB, 0x42, 0xE3 + }, + { + 0xDF, 0x9D, 0x34, 0x85, 0x15, 0xE0, 0x7F, 0x8A, + 0xBF, 0x11, 0xD3, 0xEA, 0xE5, 0x9A, 0xCA, 0xCF, + 0x93, 0x09, 0x95, 0xD8, 0x6B, 0xCB, 0x41, 0x55, + 0xB3, 0x1F, 0xAC, 0x10, 0xCC, 0x6D, 0x8B, 0xEA + }, + { + 0xCF, 0x57, 0xEF, 0x8E, 0xE9, 0xD6, 0xCD, 0xBE, + 0x43, 0x70, 0xFE, 0xC8, 0x41, 0x3B, 0x1B, 0x0D, + 0x08, 0xE7, 0xDE, 0x17, 0xAD, 0xF2, 0x90, 0xA6, + 0xB3, 0x00, 0x92, 0x81, 0x95, 0x92, 0x94, 0x1F + }, + { + 0xA1, 0xEE, 0x42, 0xCF, 0xEE, 0x66, 0xC1, 0xF7, + 0xBC, 0x7A, 0x93, 0x97, 0xA2, 0xC9, 0xE5, 0xA5, + 0xD0, 0xB0, 0x7D, 0x94, 0xF5, 0xBF, 0x55, 0x06, + 0x92, 0x97, 0x6D, 0x96, 0xB7, 0xA4, 0x35, 0x45 + }, + { + 0x92, 0x51, 0x98, 0x58, 0x6D, 0xB0, 0xBC, 0x59, + 0xDD, 0xE1, 0xAB, 0x4C, 0x7E, 0xEE, 0xCD, 0x10, + 0x8E, 0x43, 0xA2, 0xB5, 0x10, 0x98, 0x00, 0x8B, + 0x09, 0x3D, 0x99, 0x2F, 0xF7, 0xFB, 0xCB, 0x81 + }, + { + 0x8D, 0x76, 0xAA, 0xDC, 0xB1, 0x01, 0xCD, 0x66, + 0xE0, 0xB4, 0xE5, 0xF1, 0x7C, 0xCE, 0xEE, 0x0F, + 0x75, 0xAD, 0xCF, 0x59, 0xB0, 0xA2, 0x28, 0x27, + 0x46, 0x9C, 0x72, 0xBE, 0xCB, 0x5F, 0x7A, 0x23 + }, + { + 0xBE, 0x52, 0x4D, 0xCE, 0xBE, 0xA1, 0xF2, 0x4A, + 0xF3, 0x98, 0x9F, 0x39, 0xF5, 0xB0, 0xE6, 0x39, + 0x12, 0x31, 0x01, 0xC4, 0xF8, 0xE5, 0x28, 0x3F, + 0x96, 0xDF, 0x47, 0x38, 0x0D, 0x5C, 0x7C, 0xB2 + }, + { + 0x46, 0xF9, 0x7F, 0x00, 0xC7, 0x2E, 0x1B, 0x1F, + 0xE6, 0x89, 0xD7, 0x7A, 0xD2, 0xF1, 0x0F, 0x78, + 0x4A, 0xB8, 0xAA, 0x3C, 0x1B, 0x8D, 0xC1, 0x91, + 0x07, 0x90, 0xAC, 0x7A, 0x78, 0xF0, 0x01, 0xB3 + }, + { + 0x00, 0x38, 0x79, 0xFB, 0xB4, 0x21, 0x36, 0x2C, + 0x4C, 0xB8, 0x4C, 0xC6, 0x2E, 0x5E, 0xDC, 0xFE, + 0x25, 0xC3, 0x4D, 0xEE, 0x8D, 0x84, 0x4E, 0x96, + 0x2A, 0x0E, 0xEB, 0x5A, 0xCA, 0x95, 0x95, 0xD1 + }, + { + 0x29, 0x7E, 0x05, 0xBE, 0x82, 0x0D, 0x6C, 0xEC, + 0x6A, 0x86, 0xB2, 0xAA, 0x7C, 0xA9, 0xF9, 0xA0, + 0x28, 0xDE, 0x3D, 0xF3, 0x6A, 0x2A, 0x29, 0xAE, + 0x98, 0xFA, 0xE1, 0x42, 0xA5, 0x75, 0xC1, 0x89 + }, + { + 0x9A, 0x5C, 0x13, 0x06, 0x7D, 0x86, 0xD6, 0xAC, + 0x5F, 0x95, 0x71, 0x8C, 0x38, 0x73, 0x7B, 0x05, + 0x78, 0xCA, 0xE5, 0xC4, 0x4E, 0xFF, 0x2F, 0x53, + 0xF3, 0xCB, 0xA1, 0xA9, 0xAB, 0x4A, 0x22, 0xC5 + }, + { + 0x06, 0x69, 0xAD, 0x72, 0x67, 0x27, 0x07, 0x23, + 0xE9, 0x4F, 0xED, 0xB4, 0xA7, 0x45, 0xE7, 0x3C, + 0xCB, 0x45, 0x02, 0x52, 0x17, 0x8E, 0x50, 0xA9, + 0xDB, 0xFE, 0x34, 0x93, 0xE5, 0xAD, 0xC8, 0xB8 + }, + { + 0xF0, 0xA5, 0x05, 0xEB, 0xAB, 0xBB, 0x43, 0x18, + 0x56, 0xCA, 0x86, 0xFB, 0xC0, 0xBC, 0x13, 0xF8, + 0x5F, 0x8F, 0xF5, 0xD9, 0x6B, 0x61, 0xC3, 0x85, + 0x47, 0x92, 0x5F, 0x6B, 0x17, 0x97, 0x5B, 0x71 + }, + { + 0xC2, 0xE0, 0x0C, 0x4C, 0x1A, 0x51, 0xBA, 0xB9, + 0x79, 0x18, 0x1B, 0xD0, 0x24, 0x49, 0x3D, 0x2C, + 0x56, 0xBE, 0xBF, 0xE8, 0x09, 0x10, 0x22, 0xFE, + 0x0F, 0xA8, 0x72, 0x46, 0xDD, 0x96, 0x56, 0x56 + }, + { + 0x1A, 0x70, 0x57, 0x26, 0x8C, 0x4E, 0x6A, 0xBB, + 0x12, 0x27, 0x68, 0x25, 0x21, 0x97, 0x48, 0xA9, + 0x47, 0x3E, 0xAF, 0x1D, 0xEB, 0x95, 0x28, 0x98, + 0x5F, 0x89, 0xB6, 0x78, 0x91, 0x2B, 0x9C, 0xA9 + }, + { + 0xD2, 0x9D, 0xEB, 0x0F, 0x58, 0x0E, 0x58, 0x95, + 0xF1, 0xE9, 0x62, 0x0A, 0xE8, 0x18, 0x03, 0x73, + 0x0A, 0x25, 0xE3, 0x88, 0x29, 0x4A, 0x7D, 0xAA, + 0x28, 0x85, 0xCB, 0x48, 0x13, 0x23, 0xA9, 0xCF + }, + { + 0x3C, 0xF2, 0x17, 0xFD, 0xD3, 0xA1, 0xFB, 0xC6, + 0xE5, 0x62, 0xD0, 0xDE, 0xCB, 0x5E, 0x24, 0xC8, + 0x1A, 0x22, 0xF0, 0x9E, 0xEC, 0xAA, 0x52, 0x2B, + 0x74, 0x95, 0x6F, 0x28, 0x76, 0x5A, 0x57, 0x10 + }, + { + 0xA5, 0x29, 0xAE, 0x41, 0x20, 0xC4, 0x05, 0xF5, + 0x7F, 0x3D, 0xD3, 0x23, 0x38, 0xF4, 0xC6, 0x3E, + 0xF1, 0x34, 0x97, 0xC7, 0x57, 0xA8, 0x9C, 0xC0, + 0x63, 0xF6, 0xBB, 0xEB, 0xF3, 0x96, 0x83, 0x0E + }, + { + 0x1A, 0x58, 0xC2, 0x42, 0x81, 0x4B, 0xD5, 0x82, + 0x7A, 0x79, 0x10, 0x1A, 0xFE, 0x89, 0x87, 0x5D, + 0x1A, 0x31, 0xFE, 0x39, 0x2B, 0x98, 0x2F, 0x69, + 0x31, 0x3C, 0x0E, 0x70, 0xC1, 0x38, 0x29, 0x9A + }, + { + 0xD7, 0x4C, 0xED, 0xE0, 0x43, 0xB3, 0x94, 0x19, + 0x25, 0x81, 0xBE, 0xA7, 0xAF, 0xCE, 0xC3, 0x6A, + 0x4B, 0x3C, 0x3C, 0xFB, 0xE5, 0xD6, 0xC5, 0xFE, + 0xC8, 0x27, 0x62, 0x27, 0xED, 0xD1, 0x0C, 0xCA + }, + { + 0x87, 0x51, 0xFD, 0x6A, 0x87, 0x25, 0xC8, 0x71, + 0x94, 0x8E, 0xD7, 0x11, 0xF7, 0xB0, 0xD0, 0xEF, + 0x09, 0x7B, 0xB6, 0x21, 0x98, 0x1E, 0xB1, 0x78, + 0x4A, 0xFE, 0xE6, 0xD6, 0x7F, 0x3C, 0xDE, 0x37 + }, + { + 0x88, 0x74, 0x67, 0xCE, 0xAC, 0x7B, 0x97, 0x73, + 0xB0, 0x48, 0xEA, 0xB8, 0x34, 0xB9, 0xD5, 0x97, + 0x93, 0x64, 0xFB, 0x26, 0x1D, 0xA4, 0xCA, 0xBD, + 0x54, 0x23, 0x0B, 0xE9, 0x93, 0xEA, 0xE6, 0x1C + }, + { + 0xFE, 0xE5, 0x9C, 0x69, 0x72, 0x25, 0xE2, 0xDC, + 0x31, 0x2E, 0xE5, 0x65, 0x92, 0x2E, 0x04, 0x2E, + 0x56, 0x79, 0x7C, 0x34, 0x20, 0x1B, 0xB8, 0x69, + 0x09, 0x4F, 0x8B, 0x5B, 0x9E, 0xF6, 0x25, 0x45 + }, + { + 0x1E, 0x64, 0x3C, 0xEE, 0x93, 0x5F, 0x10, 0xD5, + 0x61, 0xDB, 0x3B, 0xCB, 0x6B, 0x37, 0x61, 0xBF, + 0xC7, 0x8C, 0x58, 0x5A, 0x15, 0x8D, 0x97, 0x63, + 0x9F, 0xE9, 0x64, 0x94, 0x9C, 0x1A, 0xF9, 0x18 + }, + { + 0x82, 0x84, 0x9E, 0x07, 0xA3, 0xD3, 0x62, 0x7E, + 0xFD, 0xB2, 0x08, 0x51, 0xA9, 0xCC, 0xE4, 0x7F, + 0x46, 0x84, 0x6D, 0xE0, 0xCF, 0x43, 0xFE, 0x71, + 0xCE, 0xC9, 0x13, 0x85, 0x9F, 0x0A, 0x72, 0x11 + }, + { + 0xE6, 0x36, 0xA9, 0xA5, 0xB6, 0x05, 0x25, 0x54, + 0x17, 0x78, 0x65, 0x37, 0x3F, 0x5F, 0x23, 0xEC, + 0x6A, 0x46, 0xF6, 0xE0, 0x63, 0x54, 0x6F, 0x59, + 0xAA, 0x9D, 0xE5, 0x85, 0xC7, 0x0B, 0xAB, 0xDB + }, + { + 0x8D, 0x9B, 0xBD, 0x4D, 0x5D, 0x7D, 0x99, 0x4D, + 0x18, 0x50, 0xEA, 0x30, 0xB4, 0x68, 0x28, 0xBB, + 0xC5, 0x2B, 0xA5, 0xD2, 0xA7, 0x4E, 0xEF, 0xB9, + 0x55, 0xCC, 0xAC, 0xB9, 0x39, 0x7A, 0x2C, 0x19 + }, + { + 0xEC, 0x67, 0xE0, 0x3A, 0xEB, 0xCD, 0xD7, 0xCB, + 0x0A, 0x31, 0xE1, 0xF5, 0x0B, 0xCA, 0xF7, 0xDF, + 0x5F, 0x91, 0xFF, 0xF0, 0x9E, 0xC9, 0x5E, 0x90, + 0x76, 0xD2, 0x6D, 0x6F, 0x2E, 0x64, 0x42, 0xA2 + }, + { + 0x19, 0x2A, 0xB4, 0xBA, 0x08, 0xF8, 0xEB, 0x0F, + 0x83, 0xF0, 0x55, 0x2E, 0xCA, 0xF6, 0xFB, 0x51, + 0x84, 0xEC, 0x53, 0x4F, 0xAA, 0xBC, 0x8D, 0x06, + 0x47, 0x44, 0x8D, 0x6F, 0x4A, 0x19, 0xF8, 0xFF + }, + { + 0xA5, 0x12, 0xAF, 0x54, 0x88, 0xE5, 0x57, 0xFA, + 0xA8, 0x32, 0xD7, 0xA3, 0x5A, 0xAB, 0xD1, 0x96, + 0x3B, 0x9A, 0xD6, 0xDB, 0x5A, 0xDE, 0xFF, 0x70, + 0xB2, 0x61, 0x40, 0xC1, 0x05, 0xBB, 0x2F, 0x0F + }, + { + 0x80, 0x9E, 0xA9, 0x43, 0xAE, 0x56, 0x75, 0x0F, + 0xEA, 0xC6, 0xED, 0x9A, 0x61, 0x47, 0x09, 0x56, + 0xDE, 0xC9, 0xBE, 0xDC, 0xE3, 0x1E, 0xD7, 0x4D, + 0x51, 0x0B, 0xD6, 0x71, 0x27, 0x43, 0x29, 0x99 + }, + { + 0xD8, 0xD0, 0x68, 0x53, 0xFD, 0x19, 0x80, 0xEF, + 0xF5, 0x98, 0x01, 0x1A, 0xCD, 0xC8, 0x64, 0x12, + 0x6B, 0x72, 0x5D, 0x6A, 0x18, 0xF5, 0xDD, 0x64, + 0xA4, 0xC1, 0x7B, 0x28, 0x22, 0x23, 0x9A, 0x8C + }, + { + 0xB1, 0x06, 0x83, 0xAA, 0x61, 0xC4, 0x59, 0x0F, + 0xF9, 0x1E, 0xA2, 0x84, 0xDE, 0x6C, 0x28, 0xFD, + 0xC1, 0x3E, 0xAF, 0xD3, 0x4C, 0x46, 0x46, 0x09, + 0xEA, 0xCD, 0x41, 0xB7, 0xD3, 0x2D, 0xA7, 0x1C + }, + { + 0x4C, 0x32, 0x1E, 0xE0, 0xAF, 0x3F, 0x3D, 0x7F, + 0xD8, 0x7F, 0x21, 0xA5, 0xAA, 0x26, 0xDE, 0x5D, + 0xCD, 0x7E, 0x47, 0xB2, 0xB5, 0xB0, 0x45, 0x1D, + 0xBF, 0xBE, 0x91, 0xA5, 0x81, 0x54, 0xA6, 0x35 + }, + { + 0x7B, 0x0F, 0x56, 0x7D, 0xA1, 0x28, 0x7B, 0x37, + 0xD6, 0xD4, 0xA4, 0xCE, 0x12, 0x72, 0x5B, 0xC8, + 0x81, 0x81, 0x68, 0x16, 0xB8, 0x9C, 0x5D, 0x52, + 0xD1, 0xCD, 0x9A, 0xA3, 0x0C, 0x86, 0x35, 0xDB + }, + { + 0xA5, 0xD5, 0xFA, 0x65, 0x78, 0x11, 0x46, 0xC8, + 0x68, 0x93, 0xEC, 0xDA, 0xB1, 0x28, 0x03, 0x3D, + 0x16, 0xFC, 0x87, 0xFA, 0xA4, 0x94, 0xD5, 0x6D, + 0x07, 0x17, 0x44, 0xE2, 0x3D, 0xB8, 0x89, 0x79 + }, + { + 0x8E, 0x85, 0xCC, 0xDD, 0x70, 0x6E, 0x42, 0x35, + 0x03, 0xA1, 0x03, 0x7F, 0x4C, 0xAC, 0x4B, 0xD2, + 0x8F, 0xB2, 0x05, 0x57, 0x18, 0x39, 0x57, 0x6C, + 0x6F, 0x23, 0x80, 0xBF, 0xC1, 0xE0, 0xA5, 0xCD + }, + { + 0x1A, 0x1F, 0x08, 0x40, 0x86, 0x79, 0x7D, 0x90, + 0x5E, 0x0A, 0xE0, 0x56, 0x15, 0x05, 0xCA, 0x04, + 0x75, 0x7C, 0xE6, 0x62, 0x7B, 0xFD, 0x4C, 0x24, + 0xFA, 0x8C, 0x52, 0xE6, 0x8A, 0x09, 0x78, 0x4A + }, + { + 0x93, 0x6C, 0x8B, 0x32, 0x33, 0xC4, 0x7C, 0xF3, + 0x2E, 0xDD, 0xB9, 0x63, 0x6C, 0xA4, 0x1F, 0x86, + 0x0B, 0xA4, 0x0C, 0x4C, 0x70, 0x80, 0x00, 0x1E, + 0x47, 0x97, 0x4B, 0x5B, 0x55, 0x3E, 0x93, 0x7F + }, + { + 0xB3, 0x18, 0xFC, 0xD2, 0x76, 0x59, 0x87, 0x33, + 0x5A, 0x6B, 0xF0, 0x92, 0x2E, 0x2D, 0x0F, 0xA3, + 0xA4, 0x5F, 0xD2, 0xEF, 0xE3, 0xF8, 0x64, 0xA2, + 0x8E, 0xB9, 0xEA, 0x82, 0x52, 0x6B, 0x80, 0xC7 + }, + { + 0x0D, 0xA6, 0x5F, 0xDE, 0xE0, 0xB1, 0x57, 0x0A, + 0x27, 0xBB, 0x9A, 0xC5, 0x41, 0x0F, 0x41, 0xD2, + 0xB9, 0xAC, 0xD6, 0x96, 0x1D, 0xAC, 0x58, 0x0E, + 0xFD, 0xF4, 0x6B, 0xF9, 0x06, 0x00, 0xFB, 0xAD + }, + { + 0xA8, 0xE7, 0x84, 0x82, 0xE4, 0x35, 0x0E, 0x99, + 0x47, 0xB8, 0x76, 0xEF, 0xB6, 0x4D, 0x27, 0xD7, + 0xC4, 0x2D, 0x19, 0xFB, 0xC8, 0x73, 0xC6, 0xC2, + 0xD0, 0x06, 0xEC, 0xE7, 0xAE, 0x68, 0xA1, 0x6A + }, + { + 0x6D, 0x10, 0x34, 0x6B, 0xA5, 0xA6, 0x3E, 0x2A, + 0x10, 0xFD, 0x99, 0x74, 0xBD, 0x92, 0x35, 0x68, + 0xFB, 0x02, 0x77, 0xDF, 0x18, 0x56, 0xFE, 0x7A, + 0x2A, 0x39, 0xE9, 0xBA, 0x0F, 0x4E, 0x46, 0x8F + }, + { + 0x5F, 0x41, 0x84, 0x67, 0xF6, 0x2E, 0x3D, 0x48, + 0x4E, 0xFC, 0x4B, 0x8A, 0x87, 0xE9, 0x93, 0xBC, + 0xCC, 0x21, 0x91, 0x66, 0xDF, 0xD1, 0x97, 0xF9, + 0x3A, 0x17, 0xAC, 0x00, 0x90, 0x96, 0x48, 0xBE + }, + { + 0xF2, 0x02, 0x73, 0xD3, 0x5E, 0x2E, 0x9F, 0xC4, + 0x4E, 0x95, 0xB5, 0x62, 0xBA, 0x8B, 0x87, 0x27, + 0xE9, 0xC8, 0xAC, 0x75, 0x70, 0x7F, 0xCF, 0x6A, + 0xC8, 0xA7, 0xBE, 0xAC, 0x19, 0xB6, 0xF9, 0x8C + }, + { + 0x47, 0x1F, 0xD7, 0x86, 0x91, 0xF2, 0x8D, 0x6C, + 0x76, 0x89, 0x15, 0xB0, 0x20, 0x1A, 0xFD, 0x69, + 0x42, 0xAD, 0x16, 0xEB, 0x10, 0x26, 0x81, 0x4E, + 0xC4, 0x26, 0x59, 0xC9, 0x77, 0xC6, 0x8D, 0xE1 + }, + { + 0x7A, 0xAF, 0x34, 0xF7, 0x11, 0xF7, 0xDA, 0x9C, + 0xF5, 0x79, 0x3F, 0x8B, 0x4C, 0x0D, 0xD4, 0x39, + 0xCC, 0x7A, 0x29, 0x83, 0xCC, 0xE8, 0x0C, 0xEE, + 0xF8, 0x39, 0x51, 0x69, 0xBD, 0xF5, 0x45, 0xFA + }, + { + 0xFF, 0x4E, 0x5B, 0x1E, 0xFA, 0x6A, 0xDE, 0x6A, + 0xFD, 0x4B, 0x9A, 0xAB, 0x1A, 0x57, 0x4F, 0x60, + 0x57, 0xD0, 0xB5, 0xFD, 0x66, 0x9A, 0xC7, 0xFE, + 0x08, 0x74, 0x84, 0x09, 0xE8, 0x58, 0xC5, 0xC2 + }, + { + 0x50, 0xF3, 0x45, 0xC4, 0x48, 0x93, 0x2F, 0xAC, + 0x66, 0x75, 0x4C, 0x72, 0xDE, 0xFD, 0x85, 0xBF, + 0x46, 0x4D, 0x15, 0x00, 0xEE, 0x58, 0x1D, 0x87, + 0xE3, 0xF3, 0x1E, 0x52, 0xF7, 0x95, 0x2D, 0x5F + }, + { + 0x2A, 0x42, 0xB9, 0xC5, 0x3E, 0xA7, 0xAC, 0xD5, + 0x4B, 0x4A, 0x73, 0x7E, 0xD1, 0x83, 0xAC, 0xA9, + 0x3F, 0x74, 0x67, 0x31, 0x85, 0xD3, 0x52, 0x13, + 0x36, 0x9A, 0x40, 0xA7, 0x88, 0x1F, 0x58, 0x49 + }, + { + 0xF8, 0xE5, 0xA2, 0x62, 0x8D, 0xDC, 0xAA, 0x10, + 0x7B, 0xA4, 0xC6, 0x10, 0x11, 0x1F, 0x6A, 0x35, + 0x28, 0xF9, 0x8E, 0x61, 0xB2, 0x8C, 0x20, 0xF1, + 0x00, 0x5C, 0x8A, 0x65, 0xBB, 0xC6, 0x33, 0x09 + }, + { + 0x2A, 0x61, 0xFA, 0xAE, 0xBC, 0x9D, 0x7E, 0x12, + 0x01, 0x04, 0x53, 0x91, 0xDF, 0x72, 0xE1, 0x24, + 0xAE, 0x0E, 0x42, 0xC2, 0x35, 0xD6, 0x48, 0xE2, + 0xA1, 0x74, 0x8C, 0x23, 0x1B, 0xA2, 0x76, 0x88 + }, + { + 0x56, 0x8D, 0xEA, 0x26, 0xA1, 0x2B, 0x80, 0x6C, + 0xCF, 0x65, 0xD9, 0xC5, 0x52, 0x9B, 0xD8, 0x2B, + 0x30, 0xDC, 0x5D, 0xC8, 0xBF, 0xB8, 0x3D, 0x3A, + 0x22, 0xF5, 0xB7, 0x7F, 0x36, 0xC3, 0x87, 0xA6 + }, + { + 0x25, 0xDD, 0xF6, 0x29, 0xE9, 0x59, 0x13, 0xA9, + 0x92, 0x7F, 0x57, 0xF0, 0xC5, 0x0F, 0xF7, 0x73, + 0x4A, 0xBF, 0xEB, 0x8E, 0x8D, 0xFA, 0x65, 0x78, + 0x90, 0xF4, 0x58, 0xC2, 0x37, 0x6A, 0x17, 0x81 + }, + { + 0x9E, 0x53, 0xAE, 0xC3, 0x20, 0x6B, 0x18, 0xC3, + 0xE7, 0x10, 0xCF, 0x26, 0x4E, 0xF6, 0x8B, 0x0A, + 0x8A, 0x62, 0x89, 0xFD, 0x6B, 0x43, 0xB5, 0x80, + 0xA1, 0x7A, 0x91, 0xC1, 0x28, 0x9E, 0x0D, 0x95 + }, + { + 0x1A, 0x46, 0x48, 0xC4, 0xC7, 0x80, 0x48, 0xA4, + 0xE4, 0x97, 0x4E, 0xA2, 0xFD, 0xB5, 0x07, 0xEC, + 0xB4, 0x77, 0x94, 0xBE, 0x0B, 0x57, 0x8A, 0x92, + 0x0F, 0x54, 0x5D, 0xBE, 0xAB, 0x1C, 0x1E, 0xCD + }, + { + 0x54, 0x7A, 0xEA, 0x69, 0x70, 0x96, 0x02, 0xA0, + 0x21, 0x3F, 0xBB, 0x3E, 0x02, 0x9B, 0xE5, 0xDD, + 0xBF, 0xC0, 0x86, 0xCE, 0x9E, 0x82, 0xDB, 0x03, + 0xB9, 0x03, 0xAF, 0x29, 0xE6, 0xCD, 0x48, 0x50 + }, + { + 0x2C, 0x8E, 0xDA, 0x93, 0x52, 0x64, 0xE8, 0x0D, + 0x1A, 0x83, 0x2A, 0x03, 0xB1, 0x39, 0x7F, 0x19, + 0xD9, 0x97, 0x67, 0xE2, 0xE8, 0x23, 0x75, 0xE9, + 0x4A, 0x7D, 0x37, 0xBA, 0x73, 0xD5, 0xE2, 0x60 + }, + { + 0x4C, 0x8F, 0x14, 0x82, 0xAE, 0xC4, 0x9B, 0xA1, + 0x5C, 0xDC, 0xDE, 0x78, 0x95, 0xB4, 0x9E, 0x15, + 0x92, 0x71, 0x7C, 0x00, 0x42, 0x12, 0xC0, 0x12, + 0x9B, 0xB9, 0x09, 0xC7, 0xB0, 0x82, 0x2C, 0x17 + }, + { + 0x1A, 0xE5, 0x17, 0x02, 0xAF, 0xD2, 0x1F, 0x6C, + 0x41, 0x53, 0x7F, 0x83, 0x3A, 0xD2, 0x6B, 0xBC, + 0x99, 0x3C, 0xDD, 0x2A, 0xF5, 0x9D, 0xF1, 0x69, + 0xCB, 0x9B, 0x3F, 0x57, 0x2B, 0x90, 0xFD, 0xFA + }, + { + 0xF2, 0x3F, 0x8F, 0x81, 0x83, 0x9D, 0xF7, 0x09, + 0x35, 0x52, 0xB9, 0xC0, 0xF5, 0xFD, 0xA7, 0xA1, + 0x72, 0xEF, 0x36, 0xBF, 0xAF, 0x06, 0x13, 0xD3, + 0x4B, 0xEA, 0xE1, 0x8B, 0x7C, 0x3F, 0xF9, 0x5A + }, + { + 0x94, 0x4E, 0xCF, 0x71, 0x1A, 0xDD, 0x6E, 0xF8, + 0x6F, 0xB0, 0x85, 0x04, 0xD9, 0xBE, 0x0A, 0xF2, + 0xAF, 0xE9, 0xB6, 0x8D, 0xE2, 0xF7, 0xFF, 0x65, + 0x8A, 0xD6, 0x03, 0xDB, 0xDD, 0x49, 0x31, 0x4D + }, + { + 0xB1, 0x12, 0x1B, 0x64, 0xAF, 0x27, 0x01, 0x58, + 0xB7, 0x79, 0x7B, 0x1B, 0x37, 0xCB, 0xCD, 0x9B, + 0xB2, 0x0F, 0x7C, 0xF0, 0x49, 0x8F, 0x64, 0xF7, + 0x34, 0xCA, 0x54, 0xDF, 0x9C, 0x2E, 0x87, 0x51 + }, + { + 0xBB, 0xEF, 0xE0, 0xA3, 0x86, 0xE4, 0x30, 0x57, + 0x5E, 0xFC, 0xFD, 0xD2, 0xF7, 0x44, 0xEB, 0xBF, + 0x09, 0xA6, 0xA2, 0x9B, 0xB8, 0xB3, 0xFB, 0x15, + 0xB2, 0xF5, 0x77, 0xB1, 0xC7, 0x10, 0x56, 0xC4 + }, + { + 0x97, 0xBB, 0xD8, 0xF7, 0x40, 0xFC, 0xAD, 0x4B, + 0x5D, 0x0C, 0x1A, 0xF7, 0xEE, 0xD5, 0x74, 0x04, + 0x6D, 0xA9, 0xD6, 0x53, 0xB4, 0x3F, 0x80, 0xDB, + 0xB2, 0x32, 0x0D, 0x42, 0x57, 0x9E, 0xEF, 0xF1 + }, + { + 0x94, 0x75, 0xD9, 0x8E, 0xA6, 0xCA, 0x9F, 0xCE, + 0x6D, 0x70, 0xC9, 0x68, 0x53, 0x07, 0xF7, 0x73, + 0xBD, 0x5F, 0x6D, 0xF2, 0xE9, 0x27, 0x97, 0x99, + 0x20, 0x59, 0x89, 0x96, 0x96, 0x1F, 0x4B, 0x9C + }, + { + 0xED, 0x43, 0x73, 0xD3, 0x95, 0x81, 0x7B, 0xEA, + 0xF3, 0x90, 0x83, 0x33, 0xB8, 0xA5, 0xA6, 0x70, + 0x24, 0x9A, 0xDB, 0xCC, 0xBC, 0x24, 0x65, 0x62, + 0x0B, 0x69, 0xDF, 0x59, 0xC3, 0xCE, 0x89, 0x7F + }, + { + 0xB0, 0x13, 0xE6, 0x13, 0x5F, 0x7B, 0x28, 0x20, + 0x63, 0xBB, 0xFB, 0x28, 0x41, 0x7D, 0x3F, 0x59, + 0x71, 0x3A, 0x31, 0x55, 0x02, 0xAD, 0xDC, 0x87, + 0xEA, 0x4E, 0x70, 0xCD, 0x55, 0xF6, 0x97, 0x1D + }, + { + 0xE2, 0x62, 0xA4, 0xB7, 0x5B, 0x09, 0xD0, 0x9E, + 0xC1, 0x29, 0x5F, 0xFF, 0xEB, 0x3B, 0xFE, 0xF7, + 0x60, 0xCB, 0x81, 0xDA, 0x9B, 0x3F, 0x43, 0x51, + 0xC8, 0xA4, 0xB4, 0x17, 0xF1, 0x74, 0xEE, 0xE3 + }, + { + 0x70, 0x3C, 0x6F, 0x2E, 0xBE, 0x04, 0xD6, 0xE9, + 0xE8, 0x2A, 0xAD, 0xED, 0x4E, 0xF7, 0x06, 0x07, + 0x67, 0x9B, 0xA9, 0xFB, 0x70, 0xA8, 0x88, 0xF1, + 0xC3, 0x62, 0xEB, 0x16, 0x90, 0x96, 0xD3, 0xB5 + }, + { + 0x11, 0xD9, 0x9D, 0x41, 0xAC, 0x7D, 0xB6, 0xA9, + 0x8A, 0x8C, 0x12, 0x5C, 0x36, 0x1C, 0x69, 0xBB, + 0x97, 0x54, 0x8A, 0xEC, 0xEF, 0x47, 0x45, 0x99, + 0xE6, 0x6C, 0xE1, 0xB0, 0x6A, 0xAC, 0xF6, 0xEE + }, + { + 0xD1, 0x8D, 0xEB, 0x51, 0x34, 0x6D, 0x67, 0x18, + 0xDD, 0x22, 0x99, 0x3F, 0xBE, 0x7E, 0x58, 0xEE, + 0x65, 0x34, 0x43, 0x29, 0xA9, 0xF6, 0xC6, 0xC0, + 0x53, 0xAB, 0xBE, 0x01, 0x31, 0x8E, 0x49, 0x63 + }, + { + 0x02, 0x0C, 0x89, 0xC3, 0x4E, 0xC6, 0x8A, 0x63, + 0x7E, 0x14, 0x89, 0xE1, 0x89, 0x8A, 0x24, 0xAA, + 0x3A, 0x81, 0x41, 0x3B, 0xE4, 0x36, 0x5F, 0xB4, + 0xEF, 0x31, 0xAC, 0xE9, 0xC1, 0xDE, 0x4E, 0x96 + }, + { + 0x13, 0xE6, 0x81, 0x8D, 0x12, 0x56, 0x66, 0xC7, + 0x9B, 0x4E, 0x38, 0x8B, 0x26, 0x94, 0x55, 0x80, + 0xAE, 0x4A, 0x3D, 0x46, 0xBB, 0x81, 0x94, 0xE8, + 0x44, 0xBE, 0x7E, 0xA0, 0xA6, 0x7A, 0xA8, 0x8D + }, + { + 0xEA, 0x23, 0x26, 0xDC, 0xBC, 0x5B, 0xD0, 0x5D, + 0x97, 0x6D, 0x97, 0x01, 0xDC, 0xEE, 0xE2, 0x37, + 0x19, 0x27, 0x96, 0x31, 0xAA, 0x57, 0x75, 0x26, + 0xC9, 0x0E, 0x0F, 0xBE, 0x59, 0xF1, 0x04, 0x0A + }, + { + 0x94, 0xC1, 0xBC, 0xAF, 0x8D, 0x03, 0x64, 0x4A, + 0xEB, 0xE9, 0xD7, 0x13, 0x13, 0x7D, 0x48, 0x01, + 0xEF, 0x7E, 0x10, 0x89, 0x64, 0xC8, 0x0C, 0xFF, + 0x09, 0x71, 0x12, 0x2E, 0xA4, 0x25, 0x12, 0x01 + }, + { + 0x8A, 0x03, 0x20, 0xBC, 0x9B, 0xB1, 0xCB, 0x83, + 0xA8, 0x06, 0x19, 0x7A, 0x92, 0x72, 0xEE, 0x39, + 0x66, 0x0B, 0x76, 0x1D, 0x36, 0x52, 0x9B, 0xC4, + 0x89, 0x25, 0xD1, 0x04, 0xFE, 0xAA, 0xB2, 0x5B + }, + { + 0x05, 0x9D, 0x1F, 0xC8, 0xA8, 0x8B, 0x1C, 0xD5, + 0xE7, 0x7E, 0x72, 0x15, 0xC7, 0x74, 0x2D, 0x81, + 0x0E, 0x3A, 0xBA, 0xD1, 0xB6, 0x99, 0xE1, 0xA5, + 0xA5, 0xFF, 0x2E, 0xD8, 0x21, 0xF2, 0xAA, 0xB7 + }, + { + 0xF1, 0x8B, 0x4F, 0xEA, 0x70, 0xFC, 0x7B, 0xAC, + 0xA7, 0x0A, 0x3A, 0xD1, 0x4A, 0xC8, 0x5E, 0xEB, + 0x8F, 0x62, 0xA5, 0xED, 0x19, 0xDB, 0xAE, 0x17, + 0x5F, 0xD8, 0x25, 0x9F, 0x86, 0xEB, 0xF7, 0xF1 + }, + { + 0xD5, 0xAB, 0xF8, 0xEC, 0x6B, 0x6C, 0xC6, 0xF9, + 0x14, 0x31, 0x75, 0x47, 0xD8, 0x50, 0x9F, 0xB6, + 0xD6, 0x80, 0x30, 0x68, 0xA5, 0x7D, 0xAF, 0x4D, + 0xFE, 0xAE, 0x11, 0x5B, 0x46, 0x2A, 0x67, 0x15 + }, + { + 0x47, 0x88, 0x21, 0x5D, 0xFE, 0x2F, 0x40, 0x34, + 0x02, 0xF2, 0xCB, 0x5D, 0xA3, 0x84, 0x2F, 0x02, + 0x5C, 0x8C, 0xF4, 0x62, 0xAD, 0xEE, 0x98, 0xC4, + 0xB2, 0x86, 0x78, 0xF5, 0x00, 0x30, 0x11, 0x1B + }, + { + 0x07, 0x04, 0x08, 0x50, 0xBD, 0x78, 0xF8, 0xA5, + 0xF2, 0xF7, 0x4C, 0xA6, 0x7B, 0xBB, 0x62, 0x30, + 0xF2, 0x72, 0x40, 0x92, 0xBB, 0x65, 0xE9, 0x62, + 0xA0, 0x5B, 0xA4, 0xDC, 0x7C, 0xB9, 0x30, 0xA2 + }, + { + 0xD8, 0xC8, 0xBC, 0x68, 0x11, 0x45, 0xED, 0x9C, + 0xE3, 0x3F, 0xB0, 0xB3, 0x7F, 0x7A, 0x38, 0xB3, + 0x6C, 0x93, 0xC9, 0x45, 0xC8, 0xDC, 0x11, 0x18, + 0xD6, 0x0A, 0x0A, 0xED, 0x95, 0xED, 0x32, 0x5D + }, + { + 0xF2, 0xA7, 0x0C, 0x69, 0xDE, 0xE1, 0x20, 0xA4, + 0xC9, 0xCC, 0x23, 0xC9, 0xC9, 0x21, 0xFC, 0xC8, + 0x0F, 0x24, 0x91, 0xAB, 0x42, 0x8A, 0x84, 0x96, + 0x93, 0xAA, 0xD1, 0xAA, 0xAC, 0xC9, 0xD2, 0x69 + }, + { + 0x41, 0xAA, 0x1B, 0xD2, 0xA6, 0x34, 0x82, 0x14, + 0xDF, 0x56, 0x53, 0xC6, 0x9E, 0x87, 0x06, 0x2B, + 0x5B, 0xF7, 0x88, 0x09, 0xC4, 0x25, 0x01, 0x40, + 0x6A, 0x2C, 0x7B, 0x51, 0x5B, 0x0A, 0x80, 0x22 + }, + { + 0xA1, 0x50, 0x7C, 0x76, 0x44, 0x9E, 0x3C, 0x7E, + 0x32, 0xC9, 0xA8, 0x10, 0x99, 0xC2, 0xBD, 0x48, + 0x52, 0xB0, 0xCC, 0xCB, 0x51, 0x07, 0x71, 0x15, + 0xF5, 0xE4, 0x9E, 0xF2, 0x71, 0xFC, 0x48, 0xAA + }, + { + 0x45, 0x9A, 0xD9, 0xE5, 0x37, 0x02, 0xAB, 0x40, + 0x4D, 0xFF, 0x0D, 0x24, 0x04, 0x60, 0x74, 0x55, + 0x20, 0x00, 0x13, 0xFB, 0x57, 0xC5, 0xEC, 0xBA, + 0xF3, 0xD4, 0x31, 0x85, 0x00, 0x10, 0x5A, 0xFF + }, + { + 0x4F, 0xD2, 0xF6, 0x7A, 0x55, 0xE0, 0x20, 0x97, + 0xF2, 0x76, 0x22, 0x55, 0x73, 0xE7, 0x48, 0x86, + 0x76, 0xE1, 0x14, 0xF5, 0x97, 0x74, 0x97, 0xBB, + 0x4C, 0xC0, 0xC0, 0xF0, 0x01, 0x95, 0x42, 0x2B + }, + { + 0xE0, 0xEA, 0x35, 0x08, 0xBA, 0xBF, 0x71, 0x66, + 0x30, 0x19, 0xA9, 0xCA, 0xC2, 0x52, 0x70, 0xE0, + 0xBA, 0x03, 0xF7, 0xE8, 0x27, 0x71, 0xF7, 0x4D, + 0xDB, 0x56, 0x50, 0x80, 0x31, 0x16, 0x48, 0x20 + }, + { + 0xF8, 0xCC, 0xE4, 0xC9, 0x67, 0xF8, 0x11, 0x8D, + 0x75, 0x40, 0xA8, 0xDB, 0x1E, 0x91, 0x0B, 0x50, + 0xE3, 0x97, 0xD6, 0x10, 0x11, 0xA7, 0x2E, 0x5A, + 0xFC, 0x8B, 0x8D, 0x14, 0xEE, 0xFB, 0x4B, 0xF9 + }, + { + 0x03, 0xEB, 0x98, 0x17, 0x29, 0x7B, 0x36, 0x9D, + 0xF3, 0x7E, 0xE0, 0x37, 0x39, 0x1F, 0xF4, 0x8F, + 0x5F, 0x12, 0xA8, 0x0B, 0x59, 0xD8, 0xE6, 0x22, + 0xA7, 0xBE, 0x77, 0x37, 0x1D, 0x46, 0xA8, 0x4E + }, + { + 0xCC, 0xE3, 0x9B, 0xCB, 0x50, 0xCF, 0x5E, 0x56, + 0xC1, 0x91, 0xDF, 0x51, 0x08, 0x3B, 0xAA, 0x6E, + 0x65, 0xEA, 0x98, 0x87, 0x5D, 0x15, 0x1B, 0xEF, + 0x80, 0x36, 0x02, 0xC9, 0xEF, 0xB0, 0x27, 0x97 + }, + { + 0xA3, 0x49, 0x9E, 0x97, 0x93, 0x43, 0xB2, 0x75, + 0x60, 0xC2, 0xE3, 0x10, 0x8C, 0x42, 0x2C, 0x4E, + 0xB7, 0x60, 0x84, 0x69, 0x7B, 0xFD, 0xFF, 0xBA, + 0x25, 0x57, 0xFB, 0x82, 0xD5, 0x05, 0xAB, 0x6D + }, + { + 0xB2, 0xD1, 0x35, 0x3C, 0x5B, 0x8F, 0x68, 0xC8, + 0x39, 0xD2, 0x9F, 0x3C, 0x03, 0x2B, 0x4B, 0x3E, + 0x5E, 0x9A, 0x6B, 0xB4, 0x90, 0xCA, 0xA9, 0x1A, + 0xEF, 0x76, 0xC8, 0xAE, 0x2B, 0xEB, 0x95, 0x7B + }, + { + 0xAD, 0x14, 0x0F, 0x7F, 0xD5, 0xAF, 0x88, 0xC1, + 0xCF, 0x12, 0xAF, 0x25, 0x2C, 0xDC, 0x00, 0x9B, + 0xB7, 0xDB, 0x51, 0x2C, 0xB2, 0x59, 0x9A, 0x37, + 0x37, 0x0C, 0x00, 0x52, 0x8E, 0x39, 0xAE, 0x75 + }, + { + 0xD8, 0x0D, 0x22, 0xF3, 0x9D, 0xF8, 0x9C, 0x48, + 0x42, 0x25, 0x9B, 0x87, 0x8B, 0xE1, 0x24, 0x8E, + 0xB9, 0xE6, 0xE1, 0x52, 0xBA, 0x28, 0x6C, 0x04, + 0x1D, 0x84, 0x46, 0x7C, 0x26, 0x88, 0x21, 0xAB + }, + { + 0xF6, 0x80, 0xEE, 0x1E, 0x18, 0x29, 0x64, 0xAE, + 0x52, 0xBE, 0x4D, 0xCB, 0xD7, 0xCA, 0x57, 0x01, + 0xCA, 0x73, 0x39, 0x0D, 0xBF, 0x83, 0x53, 0x71, + 0x91, 0x43, 0xFA, 0x79, 0x49, 0xD2, 0x26, 0x5B + }, + { + 0x2B, 0x23, 0xCF, 0x7B, 0xEC, 0x99, 0xEC, 0x6D, + 0x5F, 0xEF, 0xA6, 0x50, 0x0E, 0xCA, 0xBD, 0x8B, + 0xE3, 0x3B, 0xA8, 0x6A, 0x13, 0x1D, 0xF3, 0xFC, + 0xA5, 0x00, 0x5B, 0xF9, 0x1B, 0x8D, 0x32, 0x3D + }, + { + 0xA1, 0x22, 0xC8, 0x3F, 0x1B, 0xDF, 0x32, 0x1D, + 0x8F, 0xDD, 0x7A, 0x7A, 0x34, 0x0B, 0xE8, 0x80, + 0xEA, 0x86, 0x67, 0xD2, 0xD1, 0x08, 0xA0, 0xC2, + 0xF2, 0x29, 0x0F, 0x95, 0x2A, 0xB8, 0x9A, 0x2D + }, + { + 0xDD, 0x22, 0x08, 0x5D, 0x33, 0x2F, 0x29, 0x7C, + 0x06, 0x75, 0xE5, 0x29, 0x61, 0x28, 0x0E, 0x83, + 0xC5, 0x07, 0x50, 0x81, 0x8D, 0xA3, 0xA4, 0xDB, + 0x9E, 0x65, 0x6B, 0xE3, 0x00, 0xF7, 0xC5, 0xCC + }, + { + 0x93, 0x92, 0xA1, 0x79, 0x44, 0xA7, 0xD7, 0x4A, + 0x63, 0x2E, 0x5B, 0x0C, 0xE0, 0x5A, 0x54, 0x27, + 0x54, 0x68, 0x05, 0x24, 0xC9, 0x15, 0x8B, 0x0F, + 0x81, 0x70, 0xB3, 0xC4, 0xFB, 0x71, 0x1B, 0x7F + }, + { + 0xB4, 0xF9, 0xCC, 0xD8, 0x76, 0xBA, 0x1E, 0x0A, + 0x6F, 0xBC, 0xF9, 0x30, 0xB1, 0x49, 0x2B, 0xC5, + 0x37, 0x67, 0xFA, 0xA0, 0x81, 0xF2, 0x70, 0xBF, + 0x82, 0x30, 0x9D, 0xDF, 0x97, 0xDB, 0xC0, 0x1B + }, + { + 0x8F, 0x73, 0xFC, 0x61, 0x7B, 0xA7, 0xE1, 0xC9, + 0x06, 0x51, 0xEE, 0xF7, 0xE2, 0xE3, 0x8C, 0x4E, + 0x26, 0x80, 0x94, 0x5A, 0x6A, 0xAC, 0x11, 0xBB, + 0xD2, 0x28, 0x95, 0xE0, 0x35, 0x9F, 0xF2, 0x2D + }, + { + 0xFB, 0x1B, 0xF4, 0x7C, 0x5A, 0x2C, 0xC5, 0xEF, + 0xF6, 0x4B, 0xA9, 0xC5, 0x9B, 0xE7, 0x4F, 0xCD, + 0x4D, 0xB1, 0x58, 0x55, 0x0C, 0x66, 0x72, 0x0E, + 0xF2, 0x8D, 0xBD, 0xF0, 0x58, 0xC3, 0x32, 0xB5 + }, + { + 0xE9, 0xD1, 0x6B, 0x7B, 0xA2, 0xC5, 0x9D, 0xE2, + 0x47, 0xB1, 0x16, 0xBD, 0xF8, 0x63, 0x51, 0x95, + 0xA6, 0x3D, 0x05, 0x2B, 0x0D, 0x68, 0x99, 0x94, + 0x7F, 0x4F, 0x99, 0xC3, 0x95, 0x8B, 0x3E, 0x29 + }, + { + 0x52, 0x8E, 0x03, 0x37, 0x7F, 0x46, 0x9E, 0xB1, + 0x67, 0x22, 0xE5, 0x12, 0x0D, 0xE7, 0x2C, 0x85, + 0x1C, 0x96, 0xD2, 0x31, 0x98, 0x9B, 0xDF, 0x32, + 0xD2, 0xA7, 0xBA, 0xCD, 0xA3, 0x41, 0xCE, 0x02 + }, + { + 0x12, 0x8E, 0xCE, 0xA1, 0xBC, 0x13, 0x5C, 0xA5, + 0xCD, 0x5C, 0x43, 0x77, 0x7C, 0x80, 0xE0, 0xAF, + 0x3B, 0xBD, 0x01, 0x34, 0x74, 0x4F, 0x8F, 0x70, + 0x5A, 0x0A, 0xAF, 0xD5, 0xD9, 0x7D, 0xBD, 0x01 + }, + { + 0x6F, 0x55, 0x5C, 0x9C, 0xA8, 0x9B, 0x8D, 0xEB, + 0x72, 0x09, 0x2F, 0xC6, 0x88, 0xBC, 0x88, 0xFE, + 0xAF, 0xBC, 0x58, 0xF1, 0x87, 0x2D, 0x1C, 0x63, + 0x92, 0xA5, 0xDF, 0x51, 0x2B, 0x5E, 0x57, 0x17 + }, + { + 0x22, 0x41, 0x14, 0xFB, 0x6D, 0x4F, 0xC2, 0x38, + 0x41, 0x9D, 0x0F, 0x00, 0x89, 0xDD, 0xD1, 0x24, + 0xE9, 0x6F, 0x82, 0xF2, 0x66, 0xAB, 0x88, 0x53, + 0xCD, 0x9D, 0xA8, 0x95, 0x72, 0xF6, 0x87, 0xE6 + }, + { + 0xC6, 0x3B, 0xE9, 0xD1, 0x46, 0x00, 0x24, 0x76, + 0x2F, 0xB3, 0xB1, 0x6A, 0x2C, 0x95, 0x86, 0x45, + 0x42, 0x1F, 0xCC, 0x35, 0xD5, 0xAB, 0xED, 0x96, + 0x3D, 0xEE, 0xEA, 0xD5, 0x3C, 0x0D, 0x89, 0x82 + }, + { + 0x20, 0x82, 0x40, 0xEF, 0xC9, 0x21, 0x7A, 0x91, + 0x7B, 0xF1, 0xBE, 0x36, 0x21, 0xFE, 0x9D, 0x8E, + 0x1C, 0xC0, 0xA1, 0xCA, 0xD9, 0x44, 0xFC, 0x68, + 0x7A, 0x26, 0xE4, 0xBD, 0x63, 0x03, 0x04, 0xA4 + }, + { + 0x82, 0x23, 0xC9, 0x3F, 0xCA, 0x41, 0x28, 0xF3, + 0x7A, 0x35, 0x0D, 0x2E, 0x85, 0x63, 0xBC, 0x1B, + 0xDB, 0xB6, 0xC2, 0x87, 0xCD, 0x5C, 0x7B, 0x10, + 0x44, 0x0B, 0x58, 0xD2, 0xFD, 0x9C, 0xDE, 0x1C + }, + { + 0xFC, 0xA5, 0x82, 0x74, 0x1A, 0xEE, 0x36, 0xDA, + 0xA9, 0x49, 0x8A, 0x05, 0xCE, 0x24, 0xA1, 0xBD, + 0xC8, 0x2B, 0xE4, 0x08, 0x06, 0xC4, 0x06, 0xD1, + 0xB8, 0x3B, 0xBE, 0x99, 0xDB, 0x43, 0x2C, 0x51 + }, + { + 0x09, 0x5C, 0xE8, 0x41, 0xBB, 0xDE, 0xC0, 0x5E, + 0x80, 0xEB, 0xC6, 0x24, 0x3D, 0x2F, 0x51, 0xD2, + 0xE5, 0x02, 0xE4, 0xFC, 0xF1, 0x16, 0xF2, 0x96, + 0x72, 0xA4, 0x56, 0x95, 0x24, 0x8D, 0x1E, 0x0B + }, + { + 0x48, 0x17, 0xD7, 0xE4, 0x65, 0x56, 0xE1, 0xC8, + 0x9D, 0x3B, 0xC2, 0x9E, 0xD6, 0x14, 0x40, 0x6B, + 0x38, 0xF0, 0x39, 0xF0, 0x00, 0x1C, 0x30, 0xE1, + 0x95, 0xD1, 0xB7, 0x98, 0x3E, 0x7D, 0x7D, 0xC3 + }, + { + 0xDC, 0x73, 0xFE, 0xED, 0x7D, 0x40, 0x61, 0xAB, + 0x28, 0x71, 0x78, 0x10, 0xA9, 0xF0, 0x61, 0x03, + 0x1B, 0xE8, 0x8D, 0xD4, 0x17, 0xF8, 0x9E, 0x4D, + 0x67, 0x9E, 0xAA, 0xF1, 0xB9, 0x0A, 0x2D, 0xE7 + }, + { + 0xFC, 0x55, 0x00, 0x19, 0x45, 0x95, 0xDE, 0x70, + 0xF5, 0xB7, 0x4E, 0xA5, 0x70, 0x27, 0x6C, 0x9F, + 0xFF, 0x78, 0xC5, 0x30, 0xBE, 0xF5, 0x7A, 0xEF, + 0x3B, 0x74, 0x4F, 0x13, 0x7D, 0x45, 0xC5, 0x67 + }, + { + 0xDF, 0x56, 0xA5, 0x1E, 0xD2, 0x86, 0xF8, 0xCA, + 0x8F, 0x1D, 0x4F, 0x96, 0xCE, 0x4A, 0x70, 0x66, + 0x3D, 0xF3, 0x01, 0x4F, 0x0E, 0x5F, 0x9F, 0xB9, + 0x43, 0x83, 0x85, 0xFB, 0x35, 0x01, 0xD8, 0x9A + }, + { + 0x0E, 0x2C, 0x64, 0xF7, 0x31, 0xB1, 0x3F, 0x40, + 0xF6, 0xEB, 0x07, 0x9F, 0x56, 0x4B, 0x9C, 0xF8, + 0xED, 0x2E, 0x2B, 0x83, 0x22, 0xCA, 0x83, 0x05, + 0xE4, 0x7A, 0xD3, 0x53, 0xB1, 0x9A, 0xC5, 0x52 + }, + { + 0x8F, 0xE9, 0xE5, 0x11, 0x2E, 0x1C, 0x76, 0xEC, + 0x06, 0x4A, 0x55, 0x6B, 0x25, 0xB7, 0x48, 0x0E, + 0x28, 0xF9, 0xD8, 0xBF, 0xB1, 0x31, 0x49, 0xF3, + 0x0E, 0xCB, 0x13, 0x4E, 0x34, 0x50, 0xA8, 0x79 + }, + { + 0xD1, 0x83, 0x0C, 0x58, 0x76, 0xDB, 0x10, 0x27, + 0x9A, 0x36, 0xA5, 0x4D, 0x62, 0x8F, 0xD2, 0x34, + 0xC8, 0xFF, 0x65, 0xA8, 0x8B, 0xB8, 0xB7, 0x90, + 0x80, 0x2E, 0xBA, 0x11, 0x9D, 0xE0, 0x45, 0xCF + }, + { + 0xB0, 0x1D, 0x0F, 0xF5, 0xA2, 0x5E, 0xC5, 0x1B, + 0x34, 0xEB, 0x96, 0xDA, 0x59, 0x81, 0xD7, 0x19, + 0x71, 0x9C, 0x43, 0xD9, 0x49, 0xCF, 0x10, 0x76, + 0xDD, 0xB9, 0x72, 0xC5, 0x50, 0x5A, 0x43, 0xB5 + }, + { + 0xCE, 0x74, 0x95, 0x3A, 0xAF, 0xFF, 0xE8, 0x64, + 0x7B, 0xF0, 0x95, 0x80, 0xD3, 0x50, 0xAB, 0xF2, + 0x4C, 0xE3, 0x29, 0xF9, 0x19, 0x45, 0x39, 0x34, + 0x6C, 0xD2, 0x6C, 0x91, 0xAA, 0xC5, 0x25, 0x60 + }, + { + 0x04, 0xED, 0x15, 0xB2, 0x71, 0xB9, 0xFD, 0x7B, + 0xAD, 0xA7, 0x58, 0x49, 0xE5, 0xE9, 0xCB, 0x46, + 0xA9, 0x35, 0x60, 0x19, 0xD8, 0x7E, 0xC7, 0x65, + 0x0F, 0xAB, 0x80, 0x97, 0x3F, 0xDD, 0xDA, 0xBB + }, + { + 0xD7, 0xE4, 0x71, 0xE8, 0x21, 0xE3, 0x0B, 0x71, + 0x2C, 0xFD, 0x6B, 0x6D, 0xEF, 0x59, 0xD4, 0xF7, + 0x06, 0x36, 0xBC, 0x6D, 0xE5, 0x87, 0xBF, 0x96, + 0xFA, 0x07, 0x83, 0xC1, 0xD6, 0x58, 0x52, 0x47 + }, + { + 0x32, 0x4C, 0x6D, 0x95, 0x00, 0x8D, 0x36, 0x74, + 0x85, 0x84, 0x85, 0x6E, 0xA8, 0xD6, 0x18, 0xC7, + 0x08, 0xE9, 0x8C, 0xC7, 0x49, 0xA2, 0xD1, 0xDE, + 0xBD, 0x9F, 0xEE, 0x10, 0xDD, 0x11, 0x18, 0xFB + }, + { + 0x07, 0xF8, 0xDE, 0x3F, 0x0E, 0xD5, 0x2D, 0x35, + 0x20, 0xEA, 0x0E, 0xE1, 0x1B, 0x59, 0x88, 0x48, + 0xE0, 0xFA, 0xE2, 0xB2, 0x2F, 0x00, 0xBC, 0x56, + 0x7B, 0xA3, 0x82, 0x29, 0x70, 0x60, 0x4F, 0xC9 + }, + { + 0x69, 0xD1, 0xC9, 0x07, 0x89, 0x47, 0x4C, 0xF1, + 0x08, 0x64, 0x3D, 0xD7, 0x8D, 0x31, 0x99, 0xB7, + 0x8A, 0xCA, 0x80, 0x5E, 0x28, 0x6D, 0x65, 0x0D, + 0x21, 0x06, 0xA8, 0x9E, 0x27, 0xFC, 0x12, 0x35 + }, + { + 0xBF, 0xC7, 0xD3, 0x94, 0xC6, 0x5D, 0xD9, 0xB6, + 0x71, 0x22, 0xC3, 0x5F, 0xB3, 0x62, 0x63, 0xA6, + 0x3A, 0x7C, 0x13, 0x2E, 0x18, 0xDD, 0x1C, 0x55, + 0x70, 0x9F, 0xBA, 0xC6, 0xA4, 0x96, 0x5E, 0xF7 + }, + { + 0x64, 0x22, 0xAB, 0x1A, 0xE6, 0x4D, 0xAD, 0x14, + 0x79, 0x50, 0x74, 0xB5, 0x9A, 0x4D, 0xE3, 0x81, + 0x81, 0xB1, 0x65, 0xF5, 0x6A, 0x05, 0xF7, 0x77, + 0xE8, 0x4B, 0xE1, 0x3D, 0xC5, 0x05, 0x8C, 0x73 + }, + { + 0xA8, 0x7B, 0x57, 0x90, 0x9C, 0xE8, 0xF8, 0x48, + 0x7C, 0x44, 0x3E, 0xB2, 0x87, 0x44, 0xDD, 0x1B, + 0x51, 0xD2, 0x5A, 0xE9, 0x7C, 0x2C, 0x43, 0xAE, + 0x46, 0x76, 0x06, 0x57, 0x92, 0x20, 0x73, 0x6B + }, + { + 0x5F, 0x57, 0xFD, 0x5D, 0xA7, 0x92, 0xFD, 0x2C, + 0x05, 0xCD, 0x9D, 0xD3, 0x28, 0x05, 0x8D, 0xC4, + 0xE7, 0x96, 0x46, 0x42, 0xF0, 0xF5, 0xE9, 0xA1, + 0x8C, 0xC6, 0xB1, 0x41, 0x57, 0xA8, 0x7F, 0x95 + }, + { + 0x7A, 0x18, 0x39, 0xCE, 0x0D, 0xCF, 0x8B, 0xD8, + 0xF7, 0xF0, 0xE6, 0x38, 0x99, 0x74, 0x29, 0xB6, + 0x5B, 0x01, 0xA0, 0x8B, 0xA2, 0x1E, 0xED, 0xAF, + 0x3C, 0xD5, 0xAB, 0x59, 0xAB, 0xA7, 0x20, 0xA5 + }, + { + 0x47, 0xA3, 0x90, 0x6D, 0xB7, 0xF4, 0x9F, 0x76, + 0x0C, 0x8F, 0xEC, 0x68, 0x49, 0x64, 0x89, 0xA4, + 0xA6, 0xF5, 0x93, 0xB6, 0xB3, 0x85, 0xA9, 0x2B, + 0xE3, 0x3F, 0x27, 0x4C, 0xD1, 0xAD, 0xEE, 0xEA + }, + { + 0x95, 0x0F, 0x5F, 0x9A, 0xC1, 0xBD, 0x84, 0x1B, + 0x3D, 0x75, 0x6D, 0x10, 0x66, 0x4C, 0x99, 0x9D, + 0x06, 0x74, 0xFE, 0x57, 0xA5, 0xC2, 0x0B, 0x4A, + 0x02, 0xD0, 0xF4, 0x57, 0xC5, 0x80, 0x49, 0xBA + }, + { + 0x0A, 0x4E, 0x67, 0xAB, 0x3E, 0xB8, 0xAB, 0x41, + 0x45, 0x5E, 0xDC, 0x03, 0xE5, 0xC9, 0xB3, 0xEE, + 0x55, 0x13, 0xE3, 0xE3, 0x65, 0xBD, 0xDB, 0xA9, + 0xC7, 0x7D, 0x45, 0x5B, 0xCC, 0x49, 0xD0, 0x51 + }, + { + 0x4A, 0x17, 0x4D, 0x8A, 0x44, 0x8A, 0x07, 0xBB, + 0x86, 0x48, 0x75, 0x0B, 0x50, 0x2E, 0x6A, 0x53, + 0xF6, 0x7B, 0x54, 0x9D, 0x87, 0x9A, 0xD4, 0xFB, + 0x8A, 0x92, 0x14, 0x87, 0xD7, 0x5A, 0x44, 0x28 + }, + { + 0xFF, 0xEF, 0xBE, 0x2C, 0xE8, 0x63, 0x85, 0x2B, + 0x75, 0xF9, 0xD5, 0xB8, 0x00, 0x59, 0xF1, 0x0D, + 0xAA, 0x23, 0x12, 0x87, 0x6C, 0x2D, 0x6B, 0x00, + 0x90, 0x4F, 0x6E, 0xAC, 0x30, 0xE2, 0x07, 0x21 + }, + { + 0x7F, 0x25, 0x84, 0xBD, 0x5E, 0xB0, 0x2A, 0xD0, + 0xA2, 0x53, 0xAB, 0xF1, 0x90, 0x6F, 0x14, 0xA1, + 0x8F, 0x45, 0x86, 0x7E, 0x05, 0x11, 0x2D, 0x49, + 0x28, 0x3C, 0x61, 0x6C, 0x43, 0x3A, 0x61, 0x09 + }, + { + 0x1E, 0x85, 0xDE, 0x15, 0x0C, 0xC4, 0x31, 0x45, + 0xF1, 0x21, 0x2C, 0x30, 0xCC, 0x4D, 0x45, 0xF5, + 0xFE, 0xE7, 0x56, 0x0A, 0x66, 0xE8, 0x7E, 0x27, + 0x5F, 0x27, 0xAA, 0x64, 0x19, 0x7F, 0xF1, 0x41 + }, + { + 0x7C, 0xBA, 0xCA, 0xDF, 0x6B, 0xA9, 0x9D, 0x99, + 0xF2, 0xBB, 0x97, 0xF4, 0x26, 0x44, 0x39, 0xCA, + 0x80, 0x9D, 0xF9, 0xDC, 0xE4, 0xB0, 0x57, 0x0D, + 0x73, 0x1E, 0x54, 0x5C, 0x47, 0x96, 0xDD, 0x0A + }, + { + 0x74, 0x30, 0x2E, 0x4D, 0x48, 0x50, 0x3D, 0xCF, + 0xFB, 0x8C, 0x7B, 0xC1, 0x8F, 0x4E, 0xEE, 0xB4, + 0x8D, 0x66, 0x59, 0x10, 0xD4, 0xBB, 0x9E, 0x0C, + 0x2A, 0x04, 0x3D, 0x5A, 0x4D, 0x18, 0x0B, 0x7C + }, + { + 0xE0, 0xF4, 0xE5, 0x2C, 0x18, 0x0B, 0x75, 0x9B, + 0xCF, 0xE3, 0xCA, 0x33, 0x85, 0x18, 0xDC, 0xD4, + 0x5A, 0x53, 0xF8, 0x7C, 0x7D, 0x64, 0x3D, 0xDD, + 0x9C, 0x53, 0xDE, 0x6D, 0x36, 0x43, 0x1A, 0x11 + }, + { + 0x38, 0x72, 0x6D, 0xF4, 0x34, 0x61, 0xEB, 0x3B, + 0xE9, 0xEF, 0x1B, 0xB5, 0x80, 0xE0, 0x29, 0x6B, + 0x17, 0x9F, 0x71, 0xB9, 0x1A, 0xC1, 0x4A, 0xEF, + 0x9E, 0x3C, 0xDB, 0x6D, 0xD4, 0xE6, 0xA0, 0x0C + }, + { + 0x13, 0xB8, 0xE3, 0xD3, 0x97, 0x30, 0xA2, 0xB7, + 0xA7, 0xE8, 0x61, 0x95, 0x95, 0xBE, 0x89, 0xB6, + 0x89, 0xE7, 0xAA, 0x00, 0x93, 0x25, 0x51, 0x30, + 0x5D, 0xC3, 0x40, 0x8D, 0x32, 0x22, 0xCD, 0x31 + }, + { + 0xA1, 0x3C, 0x0D, 0xA6, 0xA5, 0x52, 0x5F, 0x09, + 0x22, 0xDF, 0xD2, 0x2B, 0xD3, 0xC1, 0x9F, 0xB0, + 0x02, 0x21, 0x6A, 0xA8, 0x19, 0xB0, 0xA2, 0xF8, + 0x12, 0x2D, 0xF8, 0xFC, 0x3D, 0x53, 0xD0, 0x91 + }, + { + 0xA8, 0xB8, 0x79, 0x31, 0xCF, 0x50, 0x1F, 0x1B, + 0xD7, 0xA5, 0x79, 0x35, 0xE2, 0x93, 0xBA, 0xD2, + 0xB6, 0x6A, 0xFB, 0x03, 0xEC, 0x5B, 0x8F, 0xE8, + 0x1C, 0x3A, 0xA8, 0x26, 0x03, 0x3E, 0x47, 0x89 + }, + { + 0xF7, 0xAF, 0xF1, 0x1D, 0xDB, 0xE4, 0x1C, 0x47, + 0x07, 0x37, 0xDD, 0xF5, 0x88, 0x27, 0x39, 0x68, + 0xA7, 0x11, 0x3B, 0x34, 0x2C, 0x88, 0x6A, 0x5C, + 0x06, 0x91, 0x9D, 0xB7, 0x1E, 0x43, 0xBF, 0x07 + }, + { + 0x22, 0x6A, 0xA9, 0x10, 0x75, 0xBB, 0x90, 0x39, + 0x9E, 0xD2, 0xF9, 0x3B, 0x10, 0xD7, 0x95, 0x07, + 0x85, 0x33, 0xC2, 0x6D, 0x34, 0x1C, 0x5B, 0x61, + 0x75, 0x4E, 0x1C, 0x98, 0x6B, 0x5A, 0x11, 0xA7 + }, + { + 0xD5, 0xDA, 0x82, 0x59, 0x24, 0x89, 0x69, 0x47, + 0xDA, 0x93, 0x30, 0xBC, 0x4C, 0x36, 0x83, 0x43, + 0x0C, 0x03, 0xE0, 0xF0, 0xA3, 0x1C, 0xD5, 0x48, + 0xA0, 0x01, 0xCF, 0x93, 0xDC, 0x0D, 0xAE, 0x17 + }, + { + 0xA6, 0x96, 0xB6, 0x13, 0xBD, 0x98, 0x4E, 0x74, + 0xDB, 0xBC, 0xDB, 0x59, 0x55, 0xCF, 0xA1, 0x4B, + 0x30, 0x34, 0x0E, 0x55, 0x15, 0x26, 0xD6, 0x95, + 0x91, 0x69, 0xB3, 0x50, 0x80, 0x2F, 0xD1, 0x78 + }, + { + 0x70, 0xBC, 0xA0, 0xDF, 0x7B, 0x0E, 0x64, 0x2E, + 0x82, 0x70, 0x1C, 0x8B, 0x4D, 0x49, 0x0B, 0xCF, + 0x78, 0x6D, 0xFC, 0x5A, 0x14, 0x2E, 0xBB, 0xAF, + 0xEB, 0x6D, 0x41, 0x60, 0x74, 0x98, 0xF6, 0x41 + }, + { + 0xD4, 0x10, 0x54, 0x8D, 0x0E, 0x15, 0x7D, 0x91, + 0xF9, 0x10, 0x7E, 0xDB, 0xE4, 0xB6, 0x76, 0xF1, + 0xF2, 0x17, 0x4E, 0x98, 0xB5, 0x1D, 0x7D, 0x82, + 0x57, 0xF1, 0xC2, 0x23, 0x61, 0xC1, 0xA8, 0x64 + }, + { + 0x58, 0x99, 0xDD, 0xAD, 0x56, 0xDE, 0x44, 0x07, + 0x19, 0xB7, 0x9B, 0xA1, 0xC0, 0x5A, 0x08, 0x6F, + 0x0A, 0x23, 0x64, 0xE1, 0xA4, 0x03, 0xED, 0xB2, + 0x93, 0xB2, 0x7E, 0x82, 0x7A, 0xB3, 0x32, 0x3E + }, + { + 0x3F, 0x08, 0x5A, 0x58, 0x5B, 0x91, 0x21, 0x61, + 0x65, 0xEA, 0xD0, 0x62, 0x24, 0x95, 0x98, 0x5C, + 0xC6, 0xC3, 0x75, 0x4A, 0x7D, 0xC2, 0x7B, 0xE8, + 0x31, 0xA6, 0xD1, 0x9D, 0xB7, 0xD7, 0x59, 0x0E + }, + { + 0xEB, 0x36, 0x33, 0x50, 0x0B, 0xD9, 0xE8, 0x3B, + 0x00, 0x4E, 0x35, 0x0A, 0x12, 0x71, 0x1E, 0xDC, + 0xBE, 0x58, 0x5D, 0x73, 0xA9, 0x44, 0x6E, 0x05, + 0x3E, 0x22, 0x51, 0xA9, 0x52, 0x0D, 0x5D, 0x4A + }, + { + 0xFC, 0x01, 0xFB, 0x34, 0x86, 0x0C, 0x08, 0x50, + 0xDD, 0xCC, 0xA3, 0x48, 0xF7, 0x1D, 0x96, 0x0F, + 0x64, 0x3C, 0xDA, 0x18, 0xC3, 0xF0, 0x7E, 0xBD, + 0x08, 0x6E, 0xF1, 0x0D, 0x54, 0x75, 0x22, 0x0D + }, + { + 0xAB, 0xB3, 0x73, 0x7D, 0xE2, 0x6B, 0x5D, 0xBC, + 0x96, 0x8F, 0x91, 0x79, 0x1A, 0x24, 0x3A, 0x1F, + 0xD0, 0x8F, 0x56, 0x26, 0xA2, 0xA0, 0xCD, 0x48, + 0x49, 0xFA, 0x4A, 0xDC, 0x0E, 0xC4, 0xA5, 0x71 + }, + { + 0x9D, 0x8B, 0x9A, 0x05, 0x55, 0x3C, 0x71, 0xCF, + 0xD5, 0xA8, 0xC3, 0xCD, 0x27, 0xFE, 0xD3, 0x35, + 0x86, 0x23, 0xDF, 0xA4, 0x77, 0x8A, 0x83, 0x85, + 0x4A, 0xE7, 0xDD, 0x9E, 0x13, 0xFC, 0xCC, 0x71 + }, + { + 0x07, 0xA1, 0x48, 0xA3, 0xE2, 0x79, 0xCD, 0x96, + 0xF4, 0x59, 0x36, 0x4A, 0x43, 0x41, 0x3A, 0x9B, + 0x4E, 0xC2, 0x26, 0x4E, 0x00, 0x39, 0xF6, 0x66, + 0x8D, 0xD8, 0x6E, 0x39, 0xBA, 0x96, 0x39, 0xAB + }, + { + 0xFD, 0x80, 0xF2, 0x1D, 0x4B, 0xA4, 0xAC, 0x1F, + 0x1B, 0xCE, 0xF5, 0xBC, 0x8A, 0x41, 0xBF, 0x13, + 0x50, 0xE0, 0x36, 0x9E, 0xE7, 0xF7, 0x95, 0xC5, + 0x7E, 0x7D, 0x7D, 0xCD, 0x30, 0x83, 0x8D, 0x98 + }, + { + 0x5F, 0xD6, 0x5D, 0x89, 0xE9, 0x5A, 0xE0, 0x14, + 0xEB, 0x07, 0x26, 0xF6, 0xCD, 0x3C, 0x97, 0x3E, + 0x74, 0x58, 0x10, 0x5E, 0x02, 0xD9, 0x2B, 0x02, + 0x83, 0x30, 0x19, 0x8B, 0xF3, 0x3A, 0x67, 0x08 + }, + { + 0x83, 0x64, 0x1C, 0x48, 0xF0, 0x5A, 0x8F, 0xE6, + 0x36, 0x30, 0x0D, 0x43, 0x27, 0x7F, 0x4D, 0xCD, + 0x19, 0x9D, 0xC2, 0xDF, 0xDC, 0x68, 0x9E, 0x99, + 0x7A, 0x45, 0xE7, 0x36, 0x01, 0xC0, 0x63, 0xBB + }, + { + 0x8D, 0x28, 0x98, 0x08, 0xEC, 0x89, 0xA7, 0xC5, + 0xD6, 0xC3, 0x87, 0xD4, 0x5D, 0x02, 0x9D, 0xCE, + 0x13, 0xDB, 0xD1, 0xE8, 0xCF, 0x82, 0x72, 0x7D, + 0xFD, 0x07, 0x5C, 0x20, 0x24, 0x3C, 0xC4, 0x2A + }, + { + 0xA3, 0x20, 0x79, 0xB2, 0x7D, 0xE5, 0xB7, 0x37, + 0xB1, 0xFE, 0xCB, 0xBD, 0xAA, 0x47, 0x09, 0xFC, + 0x78, 0xE6, 0xD5, 0x39, 0xB8, 0xFC, 0xE3, 0x0A, + 0xDC, 0x97, 0x5E, 0xDB, 0xCF, 0x55, 0x26, 0x68 + }, + { + 0xE8, 0x26, 0x60, 0x81, 0x39, 0x85, 0x1D, 0x8B, + 0xCC, 0x69, 0x36, 0x74, 0x2E, 0xFE, 0x99, 0x1B, + 0x90, 0x07, 0x39, 0xC8, 0x38, 0x68, 0x1F, 0xE5, + 0x80, 0x1A, 0x75, 0xCF, 0x29, 0xF3, 0xA7, 0x7F + }, + { + 0x02, 0x35, 0x93, 0x7E, 0xF6, 0x09, 0x4C, 0xAE, + 0xF5, 0x58, 0x76, 0x22, 0xEE, 0xE7, 0x36, 0x74, + 0x42, 0x30, 0x9D, 0x19, 0xCA, 0x5C, 0x42, 0x7E, + 0x2D, 0x31, 0xCB, 0x36, 0xBD, 0x8F, 0x4C, 0xBD + }, + { + 0x97, 0xDB, 0x53, 0xDD, 0x90, 0x21, 0x6E, 0x12, + 0x2C, 0x00, 0x45, 0xC7, 0xD6, 0x23, 0xA5, 0xDA, + 0x6A, 0x85, 0x00, 0x03, 0x68, 0x6F, 0xA5, 0xD0, + 0x00, 0xAB, 0x1C, 0x15, 0xB7, 0x69, 0xB0, 0x2D + }, + { + 0x6C, 0xD1, 0x3E, 0xDB, 0x4D, 0x14, 0xD0, 0x50, + 0xB3, 0x50, 0x15, 0xA2, 0x1F, 0x70, 0x10, 0x1E, + 0x8F, 0x1B, 0x2D, 0xAE, 0x10, 0xAF, 0x21, 0x30, + 0x6C, 0x15, 0x37, 0x2A, 0x53, 0x40, 0x71, 0xFB + }, + { + 0xDF, 0x75, 0xFA, 0xCF, 0x35, 0x51, 0x80, 0x07, + 0x68, 0xD1, 0x58, 0xC2, 0x56, 0x97, 0x19, 0xE4, + 0x2B, 0xE8, 0xFC, 0x66, 0x75, 0x07, 0xD3, 0x8C, + 0x4A, 0x8F, 0x08, 0x59, 0x82, 0xF1, 0x16, 0x2B + }, + { + 0xCC, 0xDD, 0x94, 0x2D, 0x66, 0x83, 0x22, 0xA4, + 0xE9, 0xD4, 0xDD, 0xD2, 0x71, 0xB1, 0x39, 0x31, + 0x84, 0x31, 0x34, 0xDB, 0x84, 0xD4, 0xEA, 0x51, + 0x5B, 0x13, 0x81, 0xAD, 0xCE, 0x5E, 0x04, 0xE3 + }, + { + 0x8D, 0xB5, 0x48, 0x76, 0x1D, 0xA0, 0x7B, 0xD0, + 0x42, 0x87, 0x07, 0x60, 0xC8, 0xF3, 0xA3, 0x45, + 0xAF, 0x3B, 0x83, 0x1A, 0xD0, 0x86, 0xA2, 0x2D, + 0x00, 0xF7, 0x67, 0x0B, 0x76, 0x19, 0xF1, 0x8F + }, + { + 0x63, 0xF6, 0x2A, 0x32, 0x1D, 0xD4, 0x89, 0x70, + 0xD3, 0x52, 0x6E, 0x9E, 0x6D, 0x26, 0x48, 0xC4, + 0x93, 0x38, 0x50, 0x33, 0x4A, 0xEF, 0x3F, 0x0C, + 0xAC, 0x44, 0xC6, 0xCC, 0xFD, 0x81, 0x60, 0x14 + }, + { + 0x91, 0xC3, 0x8F, 0x82, 0xBD, 0xC9, 0x7A, 0x0B, + 0xCB, 0xE9, 0x88, 0x05, 0x66, 0x26, 0x71, 0x0C, + 0x82, 0xF9, 0xFD, 0xC2, 0x35, 0x2C, 0x14, 0xA2, + 0x05, 0xAA, 0x04, 0x85, 0x26, 0x6B, 0xE4, 0x97 + }, + { + 0x1C, 0x34, 0x66, 0xD0, 0xB9, 0xC7, 0x34, 0x8C, + 0x5A, 0xC2, 0x09, 0x08, 0x90, 0x39, 0x84, 0xA9, + 0x24, 0x33, 0xC4, 0x30, 0x63, 0x19, 0x94, 0x52, + 0x21, 0xD8, 0xCF, 0x1A, 0x8F, 0x28, 0x1A, 0x4C + }, + { + 0x24, 0xA3, 0x96, 0x61, 0x4F, 0x8F, 0x09, 0x3B, + 0xF3, 0x4A, 0x0C, 0x8C, 0xEA, 0x7D, 0xF0, 0x0A, + 0xBF, 0xCA, 0x79, 0xC0, 0xD1, 0x79, 0xE4, 0xC2, + 0x05, 0x12, 0x52, 0x22, 0x95, 0x2A, 0x2A, 0x81 + }, + { + 0x3B, 0xC1, 0xD0, 0xD1, 0x99, 0x4B, 0x7D, 0x88, + 0x85, 0xEB, 0x64, 0x0A, 0x67, 0x94, 0xF7, 0x70, + 0x7D, 0x30, 0x61, 0x18, 0x49, 0xD4, 0xFB, 0xBE, + 0xA4, 0xAB, 0x3C, 0x16, 0xE2, 0xE2, 0x9D, 0xA0 + }, + { + 0x07, 0x37, 0x16, 0x27, 0xA2, 0x47, 0xA0, 0xD2, + 0x0E, 0xE7, 0x09, 0x63, 0x4B, 0xDA, 0xDF, 0x91, + 0x6C, 0xAB, 0xE8, 0xE9, 0x4E, 0x38, 0xE7, 0x28, + 0x3F, 0x5A, 0xBB, 0x15, 0xB6, 0x57, 0x2F, 0x8B + }, + { + 0x60, 0xAF, 0x18, 0x04, 0x90, 0x6E, 0x13, 0xB9, + 0x66, 0x31, 0x0B, 0x43, 0xAC, 0x16, 0x1C, 0x7B, + 0x03, 0x0F, 0x00, 0xA4, 0x10, 0x6E, 0x56, 0xCA, + 0x28, 0x3A, 0xF8, 0xDC, 0x32, 0x29, 0xF3, 0x08 + }, + { + 0x41, 0xA8, 0xEA, 0x22, 0xCC, 0x6D, 0x7C, 0x93, + 0xCE, 0xE0, 0xBD, 0xD2, 0x85, 0xE8, 0x0E, 0x60, + 0x82, 0x59, 0x63, 0x92, 0x3C, 0xDC, 0xDA, 0x7E, + 0x67, 0xAB, 0xF3, 0xEF, 0xF5, 0x3E, 0x02, 0xCA + }, + { + 0xCB, 0x42, 0x2F, 0xD0, 0xE2, 0xAD, 0x1B, 0x14, + 0x57, 0x63, 0xAD, 0xC6, 0x79, 0xE5, 0x85, 0x95, + 0x52, 0x80, 0xEB, 0xB1, 0xBA, 0x8E, 0xE3, 0x29, + 0xAE, 0xC5, 0xF4, 0x2D, 0x6B, 0xC9, 0xD8, 0xFC + }, + { + 0xFE, 0x3D, 0x90, 0xDC, 0xD7, 0x68, 0x38, 0xCA, + 0xD1, 0xCC, 0xFE, 0x97, 0xD5, 0xA8, 0x7A, 0xB2, + 0x90, 0xD0, 0x75, 0x7A, 0xED, 0xAF, 0x59, 0x69, + 0xF4, 0x9C, 0x35, 0x9E, 0x44, 0x0E, 0xE2, 0xB6 + }, + { + 0xEC, 0x01, 0x66, 0xBC, 0x06, 0xAC, 0x8A, 0x0D, + 0x41, 0xC6, 0x0B, 0xC1, 0x29, 0xB2, 0xD4, 0x40, + 0xF5, 0x38, 0xE9, 0x5D, 0xF9, 0x54, 0x78, 0xF7, + 0xBD, 0xC6, 0xC7, 0x71, 0xA1, 0x59, 0xC8, 0xC2 + }, + { + 0x78, 0x0B, 0xF1, 0xF7, 0x69, 0x3B, 0xD2, 0xCF, + 0xC6, 0x57, 0x92, 0x83, 0x44, 0xBC, 0xC2, 0x63, + 0x19, 0x0A, 0x51, 0xD0, 0x89, 0x51, 0xD3, 0x50, + 0xD5, 0x81, 0x0B, 0xB2, 0x0F, 0x5C, 0x10, 0xC4 + }, + { + 0xD3, 0x4C, 0x8C, 0x45, 0xFF, 0x10, 0x81, 0xA9, + 0x11, 0x56, 0x0D, 0xCC, 0x05, 0xDC, 0xDF, 0xC5, + 0xDD, 0x9C, 0x27, 0x56, 0x31, 0x76, 0x14, 0xBF, + 0x7B, 0x2E, 0x09, 0x12, 0x97, 0x72, 0xAE, 0x90 + }, + { + 0xF4, 0x9B, 0x34, 0xEC, 0x80, 0xBC, 0x92, 0xE6, + 0xDB, 0x9A, 0x96, 0xE3, 0x1A, 0x0D, 0x4D, 0x2C, + 0x6D, 0xAB, 0x50, 0x68, 0x3F, 0xA3, 0x7C, 0x1C, + 0x82, 0x7E, 0x96, 0x6B, 0xA4, 0xD6, 0x34, 0x76 + }, + { + 0x4A, 0xDC, 0x74, 0x4D, 0xC8, 0xD7, 0x3C, 0xBE, + 0x8B, 0xCE, 0x1D, 0x5C, 0x82, 0x2D, 0xFD, 0x73, + 0x28, 0xA2, 0xA4, 0xB8, 0xA6, 0x2A, 0xA0, 0xD2, + 0xDF, 0x60, 0xF9, 0xCE, 0x4D, 0x3B, 0x04, 0xBF + }, + { + 0xC8, 0x28, 0x0D, 0x77, 0x98, 0x2C, 0x72, 0xB6, + 0x7F, 0xC8, 0xE8, 0x7F, 0x3D, 0x4C, 0xBC, 0x60, + 0xEE, 0xD4, 0x2C, 0x4D, 0x78, 0x58, 0xE5, 0xC4, + 0x85, 0xBD, 0xB0, 0xFF, 0xBA, 0x6A, 0x3B, 0x02 + }, + { + 0x56, 0x21, 0x37, 0xDB, 0x3C, 0xEB, 0x9D, 0xEA, + 0x0D, 0xF9, 0xBF, 0xDC, 0xD1, 0x44, 0x17, 0x32, + 0x08, 0xA7, 0xFA, 0x51, 0xBB, 0xF7, 0x13, 0x91, + 0x5D, 0x2B, 0xB8, 0x25, 0xAB, 0xC0, 0xA6, 0x5B + }, + { + 0x03, 0x6A, 0xCF, 0x13, 0xB9, 0x69, 0xB1, 0x84, + 0xF3, 0xB8, 0x59, 0x62, 0xF4, 0x8D, 0xF7, 0xC1, + 0xC1, 0xCD, 0x55, 0x0D, 0x7B, 0x24, 0x43, 0xF0, + 0x6F, 0x68, 0x30, 0x3D, 0x9E, 0xA2, 0x88, 0x2D + }, + { + 0x7D, 0x66, 0xB3, 0xDD, 0x53, 0x5F, 0x92, 0x87, + 0x10, 0x0D, 0x79, 0xA5, 0x1B, 0xD5, 0xA0, 0x94, + 0xAD, 0x0A, 0x3D, 0x32, 0x87, 0x7F, 0x6E, 0x18, + 0xB2, 0x97, 0x8D, 0xC9, 0x3C, 0xD2, 0x89, 0x0D + }, + { + 0xBD, 0x8F, 0xD3, 0x01, 0xCC, 0xFC, 0xD8, 0xC6, + 0xFC, 0xA6, 0x7E, 0xE1, 0x3E, 0x9D, 0xAD, 0x48, + 0x11, 0x21, 0x8E, 0x62, 0x12, 0xFD, 0xC3, 0x3D, + 0x3E, 0x06, 0x8B, 0x1B, 0x4A, 0xCA, 0x61, 0x8F + }, + { + 0xB7, 0x14, 0xD4, 0xF0, 0xFB, 0x20, 0x9B, 0x51, + 0x66, 0xC8, 0x74, 0x41, 0x4F, 0xF4, 0xB4, 0x36, + 0x18, 0x6F, 0x4E, 0xCA, 0x69, 0x9F, 0x75, 0x04, + 0x8C, 0x9D, 0x77, 0x4E, 0xD2, 0x46, 0xC0, 0xFD + }, + { + 0x0F, 0x6D, 0x8A, 0x25, 0x6C, 0x85, 0x89, 0x75, + 0x75, 0xF6, 0xCE, 0x9F, 0xAC, 0x9B, 0xA1, 0xDD, + 0x0A, 0xA5, 0x74, 0x71, 0x2C, 0x7E, 0xFD, 0x07, + 0xA9, 0x37, 0x6B, 0x82, 0x96, 0xF2, 0xAE, 0x25 + }, + { + 0xBF, 0xB1, 0x0A, 0x98, 0x32, 0x51, 0x45, 0x73, + 0x20, 0x1C, 0xD4, 0xDB, 0x27, 0x50, 0x91, 0x93, + 0x4C, 0x72, 0xC1, 0xC4, 0x7C, 0xA7, 0x67, 0xA6, + 0x1F, 0x7F, 0xCB, 0x51, 0x58, 0x7E, 0x02, 0x5B + }, + { + 0x75, 0x85, 0x32, 0x40, 0x27, 0x6B, 0xDC, 0xB5, + 0x43, 0xA2, 0xA5, 0x02, 0xB0, 0x41, 0x7D, 0x95, + 0xD1, 0xEA, 0xC7, 0x29, 0xAE, 0x0D, 0x8C, 0x2B, + 0x33, 0xC6, 0xA5, 0x36, 0x0F, 0xF0, 0x99, 0x0D + }, + { + 0x75, 0x96, 0xEA, 0x85, 0x96, 0x42, 0x69, 0xA7, + 0x52, 0x96, 0x8F, 0xF7, 0x63, 0x8B, 0x01, 0x4B, + 0x32, 0x9F, 0xCC, 0x32, 0x5C, 0xBC, 0x87, 0xD7, + 0x11, 0xAA, 0x41, 0x46, 0x2F, 0x09, 0x57, 0xD5 + }, + { + 0x4C, 0xF1, 0xE4, 0x99, 0xDD, 0x52, 0xDC, 0x80, + 0x03, 0xAF, 0x43, 0xA9, 0x06, 0x20, 0xD4, 0x12, + 0x5A, 0x59, 0xE6, 0x97, 0xA0, 0x22, 0x7A, 0x2B, + 0xBB, 0xC2, 0x9D, 0x61, 0x73, 0x18, 0x74, 0x79 + }, + { + 0xC5, 0xF9, 0x36, 0x8B, 0x76, 0x14, 0x08, 0x98, + 0x42, 0x24, 0x6B, 0xB6, 0xB9, 0x7D, 0x01, 0x72, + 0xFC, 0x42, 0x84, 0x0D, 0x56, 0xB5, 0xEC, 0x04, + 0x8F, 0xFE, 0x4E, 0x8C, 0x3C, 0x11, 0x00, 0x6D + }, + { + 0x3A, 0xF2, 0x78, 0xAC, 0x3E, 0x81, 0x0B, 0x43, + 0x2C, 0xA5, 0x7F, 0x4D, 0x7F, 0x5E, 0x03, 0xBB, + 0x70, 0xA8, 0x59, 0xEB, 0x66, 0x6F, 0x3A, 0x7A, + 0x89, 0x08, 0x6C, 0x06, 0x5E, 0xDF, 0x1B, 0x0E + }, + { + 0xB7, 0xFA, 0xB9, 0xB8, 0x16, 0xB2, 0xBD, 0xF5, + 0xDF, 0xBD, 0x65, 0xC3, 0x14, 0xF5, 0x97, 0x8D, + 0xAE, 0xB8, 0xC5, 0x42, 0xBE, 0x7D, 0x12, 0x07, + 0x9A, 0xD6, 0xC1, 0xD6, 0x63, 0x1A, 0x6D, 0xB8 + }, + { + 0x99, 0xE6, 0x1F, 0x5C, 0xD0, 0x8B, 0x39, 0x2E, + 0xE2, 0x78, 0xD9, 0xEB, 0x4A, 0x97, 0xAF, 0xB0, + 0xA8, 0x85, 0x64, 0xA8, 0x5A, 0x99, 0x63, 0x6D, + 0xD1, 0x05, 0x22, 0x7A, 0x54, 0xCE, 0x12, 0xD2 + }, + { + 0x93, 0x47, 0xD3, 0xAA, 0x34, 0x4C, 0x23, 0xB0, + 0x3B, 0xCD, 0x2E, 0x4E, 0x16, 0xF7, 0xF3, 0xC2, + 0xEF, 0xB0, 0x1C, 0xBC, 0xED, 0x81, 0x26, 0x34, + 0xC8, 0xAC, 0x4B, 0xC0, 0x83, 0xF9, 0x4A, 0xC8 + }, + { + 0x8C, 0xE1, 0xF7, 0x36, 0x14, 0x2D, 0x2A, 0xE1, + 0x4F, 0xA7, 0xC7, 0xE5, 0xAF, 0x9C, 0x99, 0x0E, + 0x8D, 0xA0, 0x37, 0xDB, 0xCF, 0x03, 0xAA, 0x20, + 0xCD, 0x94, 0xC8, 0xED, 0xF8, 0x6F, 0x34, 0xD1 + }, + { + 0x54, 0xDB, 0xA7, 0x78, 0xB4, 0x64, 0x2A, 0x67, + 0xB1, 0x66, 0x59, 0x38, 0x5A, 0xDF, 0x3A, 0xFB, + 0x9D, 0xC8, 0xF3, 0x67, 0x2C, 0xA6, 0x81, 0xC1, + 0x4A, 0x3A, 0x08, 0xF8, 0x0B, 0x10, 0xC6, 0xFE + }, + { + 0x63, 0xFD, 0x10, 0x18, 0x97, 0x52, 0xB2, 0xA4, + 0xAB, 0xF3, 0x7D, 0x82, 0x2E, 0x81, 0xDB, 0x54, + 0x19, 0xE9, 0x48, 0xAA, 0xE6, 0xBD, 0xE1, 0x9B, + 0xA2, 0xF0, 0x20, 0x63, 0x60, 0xB2, 0x42, 0x8E + }, + { + 0xAC, 0x2D, 0x42, 0xB2, 0xB2, 0x04, 0x09, 0xA2, + 0x9B, 0xF9, 0x3D, 0x56, 0xDB, 0xD7, 0x5B, 0x32, + 0xA0, 0x3C, 0xA6, 0x51, 0xF3, 0xC1, 0x9D, 0x14, + 0x01, 0x41, 0x7B, 0x50, 0x0F, 0x4F, 0x73, 0x26 + }, + { + 0x75, 0x9A, 0xB4, 0x67, 0x33, 0x28, 0x18, 0xD4, + 0xF8, 0xF6, 0xC4, 0xD3, 0x8E, 0x83, 0x5F, 0x01, + 0xC3, 0x06, 0xD7, 0x0D, 0x55, 0x44, 0x38, 0x2B, + 0x55, 0xBD, 0x8F, 0xE1, 0x31, 0x73, 0x48, 0xDB + }, + { + 0xF6, 0xED, 0x35, 0x5F, 0xA7, 0x0F, 0x37, 0x1B, + 0x92, 0x12, 0x26, 0xA9, 0xF5, 0x07, 0xFF, 0xD5, + 0x25, 0x39, 0x17, 0x73, 0x83, 0x08, 0x72, 0x5F, + 0x28, 0x36, 0x7E, 0x99, 0xB7, 0xCC, 0xD7, 0xA1 + }, + { + 0xD8, 0x04, 0xD8, 0x19, 0xB0, 0x6C, 0xB4, 0xB7, + 0xB6, 0xC2, 0x03, 0xAB, 0xF8, 0xC3, 0x82, 0x63, + 0xD3, 0x64, 0x8E, 0xAC, 0xBF, 0x7E, 0xD6, 0x11, + 0xB3, 0x3B, 0x9B, 0xFE, 0x21, 0xCC, 0x29, 0x57 + }, + { + 0x32, 0x8B, 0xC0, 0x20, 0x5D, 0x36, 0x4E, 0x26, + 0x78, 0x70, 0x34, 0xE2, 0x1D, 0x02, 0x21, 0xAC, + 0x12, 0x83, 0xB3, 0xC9, 0x48, 0xE6, 0x8F, 0x69, + 0xEA, 0xD8, 0x5F, 0xA2, 0x14, 0xAD, 0x58, 0x97 + }, + { + 0xAC, 0xD3, 0x46, 0x42, 0xEC, 0xA2, 0x1E, 0x79, + 0x10, 0xB9, 0xC2, 0xF1, 0xE1, 0x64, 0x7E, 0x93, + 0x91, 0xA7, 0xE4, 0x3D, 0xFA, 0xCD, 0x4F, 0x82, + 0xAA, 0x2D, 0x65, 0x8F, 0xC4, 0x3F, 0x38, 0xF5 + }, + { + 0x23, 0x1C, 0x25, 0x05, 0x7D, 0xA9, 0x09, 0x13, + 0x6C, 0x0C, 0x55, 0xD5, 0xE2, 0x85, 0x87, 0xE6, + 0xA4, 0xC3, 0x3E, 0x38, 0xD7, 0xAB, 0xC3, 0xB6, + 0x07, 0xF3, 0xAD, 0x4F, 0x81, 0x2A, 0xB1, 0x5C + }, + { + 0x86, 0x5D, 0x3E, 0xBF, 0x03, 0x9C, 0x38, 0xF5, + 0xCC, 0x0B, 0xB9, 0x9D, 0x97, 0xAF, 0x8D, 0x8A, + 0xDE, 0x37, 0x9D, 0x70, 0x53, 0x1D, 0x13, 0x81, + 0x9F, 0x15, 0xFF, 0x3D, 0xBF, 0xD6, 0x55, 0x2D + }, + { + 0x85, 0x87, 0x3A, 0x44, 0x41, 0x8F, 0x29, 0xD9, + 0x94, 0xD5, 0xB6, 0xD6, 0x72, 0x03, 0xC9, 0xA9, + 0x7F, 0x9A, 0xE0, 0x68, 0xF9, 0x8E, 0xC2, 0xF4, + 0x27, 0x15, 0x19, 0x61, 0x2C, 0x43, 0xB5, 0xD5 + }, + { + 0x42, 0x8B, 0xB7, 0x90, 0x10, 0x3E, 0x17, 0xAA, + 0x00, 0x0B, 0x92, 0xEE, 0x1C, 0xB7, 0x22, 0x4C, + 0x04, 0xEA, 0x50, 0x33, 0x1D, 0xC3, 0x88, 0x74, + 0x1E, 0x33, 0x2C, 0x6B, 0x6A, 0x20, 0x4C, 0xC2 + }, + { + 0xB6, 0x85, 0x6A, 0xD5, 0x77, 0xA6, 0xFB, 0xFE, + 0xF2, 0xE3, 0xE7, 0xFD, 0x69, 0x56, 0x79, 0x95, + 0x4B, 0x5A, 0x7A, 0xB3, 0x45, 0x03, 0x6B, 0x44, + 0xBE, 0xEA, 0xE3, 0x6F, 0xD5, 0x25, 0xCA, 0x66 + }, + { + 0xCE, 0x0E, 0xB3, 0xEB, 0x7D, 0xF4, 0x4B, 0x30, + 0x11, 0x11, 0x13, 0x69, 0xB0, 0x1C, 0x84, 0x9B, + 0xF3, 0xA5, 0x82, 0xC1, 0x68, 0x2B, 0x8E, 0x43, + 0x99, 0xAA, 0xB1, 0xA1, 0xC2, 0xD4, 0x6A, 0x24 + }, + { + 0x01, 0x15, 0x56, 0xF8, 0x6A, 0xB5, 0x22, 0x2C, + 0xD6, 0x58, 0x0E, 0x5B, 0x6F, 0x4F, 0x2B, 0xE5, + 0x49, 0x84, 0x30, 0x9E, 0x41, 0x3A, 0x81, 0x55, + 0xB3, 0x9E, 0x35, 0xC9, 0x2D, 0xBD, 0x82, 0x3E + }, + { + 0xD0, 0x57, 0xE5, 0xED, 0x06, 0x64, 0xF5, 0x32, + 0xAC, 0xC9, 0x11, 0xCA, 0xCA, 0x41, 0xD7, 0x82, + 0xD5, 0xDE, 0xAA, 0x81, 0xC7, 0x80, 0x5B, 0x33, + 0x72, 0xAD, 0x83, 0xE2, 0x3C, 0x24, 0xA3, 0xDE + }, + { + 0x65, 0xFC, 0xC5, 0x26, 0x26, 0x52, 0x05, 0xB8, + 0x91, 0xA4, 0x66, 0x88, 0x21, 0x98, 0xCD, 0xB3, + 0xB3, 0x04, 0xF8, 0xB4, 0x12, 0x4A, 0xC5, 0xD6, + 0x43, 0x78, 0xDB, 0x9D, 0x78, 0x75, 0xA5, 0x2C + }, + { + 0xA0, 0xF1, 0x62, 0xE9, 0x9F, 0x6B, 0x39, 0xEF, + 0xCC, 0xF9, 0xE9, 0xAA, 0xF7, 0xC9, 0x83, 0x06, + 0x21, 0x61, 0x84, 0xE7, 0x43, 0xC3, 0xD8, 0xEF, + 0xD4, 0xC5, 0xED, 0xB6, 0x0E, 0xF4, 0xFB, 0xA7 + }, + { + 0x16, 0x8B, 0xC2, 0x7D, 0x69, 0x14, 0xDA, 0x17, + 0x47, 0x8A, 0x97, 0x52, 0x49, 0x78, 0xDC, 0x21, + 0x96, 0x93, 0x6D, 0x99, 0x1B, 0xE2, 0xC0, 0xD6, + 0xB0, 0xEF, 0x88, 0x3A, 0x5C, 0x9E, 0xDA, 0xE2 + }, + { + 0x8B, 0x18, 0xFE, 0x40, 0x27, 0xE4, 0xA6, 0x42, + 0x16, 0x93, 0xAD, 0x49, 0xAE, 0x14, 0xA5, 0x76, + 0x4A, 0xBA, 0x79, 0x67, 0x71, 0xCD, 0xD1, 0xA5, + 0xC3, 0x2B, 0x19, 0x7A, 0x21, 0x42, 0x5D, 0x08 + }, + { + 0xFB, 0x6D, 0xE8, 0xFD, 0x3C, 0x6C, 0x82, 0x53, + 0xE7, 0xD2, 0xA9, 0x76, 0x1B, 0xE8, 0xF5, 0x05, + 0xAE, 0xBB, 0x51, 0xEE, 0x71, 0x73, 0x2E, 0x79, + 0x19, 0xE0, 0x7A, 0xF7, 0xCB, 0x45, 0x53, 0x8F + }, + { + 0x0D, 0x85, 0xF1, 0xB7, 0x93, 0xEE, 0x3D, 0xF3, + 0xCB, 0xA1, 0x3D, 0xA2, 0x09, 0x4E, 0xA5, 0x06, + 0xBC, 0x48, 0xA6, 0x29, 0xD2, 0xBE, 0x39, 0xD4, + 0x92, 0x5A, 0xF0, 0x9B, 0xB3, 0x0D, 0xC2, 0x9A + }, + { + 0x32, 0x62, 0xA8, 0x47, 0xF6, 0xAF, 0x14, 0xC1, + 0x3B, 0xAE, 0xD0, 0x67, 0xFA, 0x0C, 0x10, 0x61, + 0x5F, 0x8E, 0xB2, 0x68, 0xDE, 0x9F, 0x66, 0xE3, + 0x41, 0x78, 0x2B, 0xDF, 0x22, 0x4E, 0x39, 0xE9 + }, + { + 0x37, 0x85, 0x6D, 0x8A, 0xCD, 0x5B, 0xBF, 0xD5, + 0x6D, 0x8D, 0xDA, 0xAF, 0xDE, 0xF4, 0x08, 0x84, + 0x47, 0xD8, 0x28, 0x58, 0x6C, 0xA9, 0xC4, 0xD4, + 0x51, 0xC2, 0xCC, 0x63, 0x77, 0x87, 0xAA, 0x93 + }, + { + 0x57, 0x47, 0x36, 0x43, 0x3C, 0xBA, 0x1C, 0x5B, + 0x90, 0x3E, 0x7E, 0x62, 0xBB, 0x0F, 0xA2, 0xDF, + 0xF9, 0x66, 0xA1, 0x25, 0xCF, 0x51, 0xA1, 0x04, + 0x70, 0x75, 0x7A, 0xD4, 0xE4, 0x5A, 0x58, 0x6B + }, + { + 0x41, 0xF9, 0xC3, 0x56, 0xEF, 0x3E, 0x1F, 0xAE, + 0x68, 0x9A, 0x35, 0xD5, 0x4F, 0xC2, 0x6F, 0x78, + 0xE4, 0x7D, 0x93, 0x1E, 0x08, 0x72, 0xEA, 0x2E, + 0xD5, 0x54, 0x27, 0x6F, 0x4C, 0x24, 0x2B, 0xC6 + }, + { + 0x27, 0x5E, 0x80, 0xA8, 0x44, 0x99, 0x87, 0xE2, + 0x30, 0xCC, 0x42, 0x4D, 0xD2, 0xBC, 0xE1, 0xBF, + 0xE5, 0x4A, 0x6C, 0xC9, 0x43, 0x5C, 0xEA, 0xC6, + 0x3A, 0x2B, 0x5C, 0xEE, 0x35, 0x48, 0xBE, 0xBD + }, + { + 0x94, 0x25, 0xE3, 0xCC, 0x25, 0x0A, 0x2A, 0x3C, + 0x27, 0x9A, 0x1A, 0x7B, 0xE7, 0x86, 0x1F, 0xCB, + 0xBA, 0xA6, 0x8A, 0xD4, 0x7B, 0xBE, 0x13, 0xFF, + 0xE8, 0x90, 0x5C, 0x56, 0x2E, 0x37, 0x7B, 0xDC + }, + { + 0x66, 0x02, 0xBB, 0x13, 0xD0, 0xF9, 0xF7, 0x73, + 0xC5, 0xB1, 0x24, 0x4A, 0x78, 0x77, 0x42, 0xB3, + 0x3E, 0x1F, 0x4F, 0xDD, 0x00, 0xED, 0x24, 0xF6, + 0x7C, 0x3C, 0x95, 0x64, 0x78, 0x64, 0xD2, 0x8B + }, + { + 0xE2, 0x41, 0xD9, 0xDC, 0x3E, 0xEA, 0xC5, 0x24, + 0x4A, 0x38, 0x7F, 0x0A, 0xFA, 0xEE, 0x3C, 0x93, + 0x3C, 0x89, 0x2A, 0x35, 0x47, 0xB6, 0x1D, 0x08, + 0xC9, 0xF8, 0x6F, 0x4E, 0x2F, 0xE6, 0x69, 0xC3 + }, + { + 0x75, 0xF5, 0xC2, 0x0E, 0xBF, 0x49, 0xEA, 0xC9, + 0x4F, 0x9C, 0xF7, 0xB6, 0xC9, 0x5F, 0xD0, 0x0B, + 0xCA, 0x8F, 0xFB, 0xC5, 0xDF, 0x31, 0x57, 0x64, + 0x01, 0xAB, 0xD0, 0xDB, 0x75, 0x1E, 0xCC, 0xE1 + }, + { + 0xE0, 0x9E, 0x9D, 0x37, 0x42, 0x6B, 0x16, 0x49, + 0x6E, 0xB4, 0x7B, 0x85, 0xAA, 0xE7, 0x0C, 0x65, + 0x3B, 0xDE, 0xFD, 0x64, 0x40, 0xCF, 0x09, 0x88, + 0xE6, 0xA4, 0x18, 0xEB, 0xFB, 0x8A, 0x20, 0x92 + }, + { + 0x37, 0xA9, 0xEA, 0x90, 0x76, 0xCE, 0x26, 0x98, + 0x3F, 0x67, 0x05, 0x1B, 0xD4, 0x83, 0x08, 0x8F, + 0x4C, 0x7F, 0x56, 0x6B, 0xD1, 0x46, 0x5B, 0x2F, + 0x60, 0xA9, 0x4B, 0xF6, 0xF3, 0xE5, 0xDB, 0x0F + }, + { + 0x00, 0xDD, 0xA9, 0x0F, 0x93, 0x46, 0x2A, 0x79, + 0x78, 0xE0, 0xB0, 0x2C, 0x03, 0x96, 0xE0, 0x79, + 0xC7, 0xCF, 0xDD, 0x70, 0x93, 0x9A, 0x9D, 0x1D, + 0xCA, 0xDD, 0xEE, 0xE4, 0xB5, 0xA4, 0xC9, 0x33 + }, + { + 0xB7, 0xCC, 0xC3, 0x31, 0x54, 0x74, 0x2E, 0xB6, + 0xE6, 0x23, 0x50, 0x1A, 0x5C, 0x13, 0x10, 0x85, + 0x2A, 0x0F, 0x39, 0xB0, 0x02, 0xEA, 0x49, 0x06, + 0xB7, 0x4B, 0x49, 0xE3, 0x18, 0xF0, 0xFE, 0x9A + }, + { + 0x10, 0x1F, 0xEA, 0x0B, 0x7D, 0x0F, 0xDA, 0xB7, + 0x62, 0xCF, 0x05, 0xBE, 0xB9, 0xED, 0xC9, 0x29, + 0x9E, 0x56, 0x0B, 0xF7, 0x3F, 0xDD, 0x1B, 0x28, + 0xC2, 0x2F, 0x35, 0x42, 0x8E, 0x49, 0x10, 0x31 + }, + { + 0xD9, 0xDA, 0x06, 0x07, 0x66, 0xEC, 0x8E, 0x05, + 0x9A, 0x0B, 0xF7, 0x95, 0x89, 0x00, 0xDA, 0x48, + 0x61, 0x74, 0x50, 0x13, 0x17, 0x9B, 0x5D, 0xFF, + 0xB3, 0xFF, 0x37, 0x1D, 0x0C, 0xB6, 0xAC, 0xB6 + }, + { + 0x6D, 0x1D, 0x69, 0xBA, 0xFA, 0x53, 0x01, 0xC8, + 0x21, 0xC3, 0x09, 0xB7, 0xE0, 0x73, 0x0C, 0xBE, + 0xE5, 0x35, 0x28, 0x00, 0xE0, 0x57, 0x90, 0xA2, + 0xDB, 0x57, 0x2D, 0x0A, 0x20, 0x28, 0x10, 0xDF + }, + { + 0x47, 0x26, 0x62, 0xC6, 0xCB, 0x54, 0xD6, 0x0E, + 0xAB, 0x0E, 0x51, 0xFE, 0x9D, 0x38, 0x2E, 0xDA, + 0x01, 0xA3, 0xB5, 0x4D, 0xFC, 0x06, 0x8D, 0xBC, + 0x5C, 0x53, 0x07, 0x43, 0xE6, 0xC0, 0x04, 0xF6 + }, + { + 0xE8, 0x16, 0x5D, 0xB7, 0x11, 0x99, 0xB4, 0x85, + 0x13, 0x9B, 0x9D, 0x94, 0xC1, 0xB5, 0x56, 0xB0, + 0xC3, 0x64, 0xC8, 0x61, 0xC2, 0x19, 0x80, 0x09, + 0x23, 0x2C, 0x3A, 0xDB, 0xF4, 0x9D, 0x73, 0x2F + }, + { + 0x52, 0x68, 0x65, 0xEA, 0x0E, 0xAF, 0xBE, 0x6C, + 0xFF, 0x7E, 0x01, 0xE9, 0xD2, 0x97, 0xDB, 0xDC, + 0xCF, 0x03, 0x99, 0xE9, 0xA6, 0xFB, 0xD4, 0xE1, + 0x07, 0x10, 0xCB, 0x6A, 0x32, 0xFC, 0xD0, 0x35 + }, + { + 0x7C, 0xAD, 0x20, 0xCD, 0xA8, 0xC7, 0xEE, 0xFD, + 0x20, 0x13, 0x31, 0xAD, 0x0D, 0xBE, 0x0D, 0xF5, + 0xD8, 0x88, 0x24, 0x43, 0x63, 0xD4, 0x43, 0x65, + 0x23, 0xCD, 0x2F, 0x18, 0xA9, 0x37, 0xE9, 0xD8 + }, + { + 0x02, 0x83, 0xB3, 0xB8, 0x22, 0xB0, 0xE2, 0xE9, + 0x7D, 0x35, 0x53, 0xFB, 0xFE, 0x15, 0xD7, 0x60, + 0x00, 0x2E, 0x2E, 0xD0, 0x42, 0x70, 0xBC, 0xAC, + 0xA2, 0xEA, 0xF0, 0x27, 0xD7, 0xC9, 0xEF, 0xCB + }, + { + 0xE1, 0xCD, 0x2E, 0xB6, 0x4C, 0xDD, 0x07, 0xE7, + 0x19, 0x1D, 0x17, 0x97, 0x7D, 0x9B, 0xEE, 0x5D, + 0x9A, 0x7A, 0xE6, 0xF1, 0x80, 0x8E, 0x37, 0x16, + 0x61, 0xAC, 0x3A, 0x0C, 0x54, 0x76, 0x06, 0x65 + }, + { + 0xF3, 0x81, 0x2F, 0x9A, 0xE2, 0x84, 0x30, 0xFA, + 0xA4, 0xEC, 0x00, 0xE8, 0xAD, 0xD4, 0xF2, 0x14, + 0x6D, 0x71, 0x2E, 0x2E, 0x44, 0x27, 0x4E, 0x8A, + 0x57, 0xD9, 0xFF, 0xF4, 0xC2, 0x03, 0xF5, 0x2B + }, + { + 0x6A, 0x71, 0x73, 0xFE, 0xA8, 0x1C, 0x5F, 0x1A, + 0xD9, 0x7B, 0x8F, 0xC8, 0xA8, 0x54, 0xD1, 0x13, + 0x02, 0x10, 0x1A, 0x3D, 0x4B, 0xB1, 0x70, 0xCB, + 0x5E, 0x79, 0xF0, 0xEB, 0x1B, 0x31, 0x0C, 0x22 + }, + { + 0xB9, 0x28, 0x57, 0x9E, 0x09, 0xE5, 0x55, 0xBD, + 0x4B, 0x8F, 0xF6, 0x31, 0x60, 0x02, 0xFD, 0x6C, + 0xA3, 0xDC, 0x5A, 0x03, 0xB4, 0xF1, 0x88, 0xBA, + 0xAA, 0xFE, 0x81, 0x88, 0xBB, 0xF3, 0xAF, 0x15 + }, + { + 0xE7, 0x83, 0x58, 0xF9, 0x01, 0x2F, 0x06, 0xD5, + 0x18, 0x47, 0x65, 0x33, 0x9C, 0xCA, 0x85, 0xA7, + 0xBB, 0xDF, 0xC3, 0x38, 0xC6, 0x8B, 0x14, 0x40, + 0xD4, 0x08, 0x12, 0x58, 0xB2, 0x65, 0x8D, 0x0F + }, + { + 0x7C, 0x15, 0x30, 0x46, 0x19, 0x76, 0xFC, 0xF0, + 0xE0, 0xE3, 0xC7, 0xBA, 0xB4, 0xB9, 0xBE, 0xF5, + 0xB5, 0xD5, 0x72, 0x22, 0x2A, 0xF5, 0x4F, 0xDD, + 0xBD, 0x23, 0x5A, 0x21, 0x72, 0x69, 0xF3, 0xC1 + }, + { + 0xDA, 0xD2, 0x42, 0x1A, 0xB4, 0x47, 0x30, 0xDF, + 0xB0, 0x94, 0x88, 0xFA, 0x0F, 0xB7, 0x44, 0xF9, + 0x23, 0x7A, 0x4E, 0x1A, 0x1E, 0xE8, 0x01, 0x56, + 0x5C, 0x31, 0x49, 0x9D, 0x93, 0x53, 0xE9, 0x84 + }, + { + 0x49, 0x62, 0x03, 0x79, 0x17, 0x3F, 0x67, 0xFD, + 0x0D, 0xED, 0x02, 0x8D, 0x8E, 0x50, 0x4E, 0x7F, + 0xA3, 0xB2, 0x61, 0x4C, 0x22, 0x14, 0xD8, 0xCB, + 0x33, 0xA3, 0xC5, 0xF6, 0x68, 0xD8, 0x97, 0xBB + }, + { + 0xD9, 0x77, 0x3C, 0x14, 0x67, 0xBF, 0x21, 0x28, + 0x44, 0x21, 0x21, 0x3C, 0x27, 0xA5, 0x77, 0xB5, + 0x68, 0xED, 0x9D, 0x3F, 0x83, 0xCD, 0x8E, 0xFF, + 0x48, 0xA9, 0xDC, 0x06, 0x20, 0x7E, 0xD0, 0x26 + }, + { + 0x9D, 0x99, 0x52, 0xBD, 0x71, 0x86, 0x41, 0x77, + 0x89, 0xAC, 0x8F, 0xEB, 0x10, 0xCB, 0x9A, 0x0B, + 0x6A, 0x35, 0x52, 0x07, 0xB7, 0xEF, 0x89, 0x88, + 0x1B, 0x6E, 0xD1, 0x08, 0x5C, 0x12, 0x06, 0x21 + }, + { + 0x97, 0x23, 0xC9, 0xC4, 0xE3, 0x73, 0x94, 0x6B, + 0x03, 0x2C, 0x1E, 0x03, 0x98, 0xB3, 0x5E, 0x40, + 0x00, 0x47, 0x8D, 0x51, 0x71, 0x86, 0xFB, 0xBD, + 0x1D, 0x1A, 0x64, 0x77, 0x8D, 0xAD, 0xD2, 0x9D + }, + { + 0x7F, 0x5B, 0x2D, 0x19, 0x00, 0x02, 0xC9, 0xFD, + 0xB4, 0x7E, 0x10, 0xF4, 0x41, 0x0A, 0x2A, 0x23, + 0x5A, 0x7B, 0xFD, 0x9C, 0xBE, 0x5B, 0x8C, 0x69, + 0x36, 0xC5, 0x98, 0xDD, 0x4F, 0xF3, 0xC3, 0x02 + }, + { + 0xE6, 0x70, 0x2B, 0x90, 0xF0, 0xA9, 0xE8, 0xAC, + 0x3B, 0xC9, 0x0B, 0x0A, 0x5E, 0xD2, 0x96, 0xC7, + 0x38, 0xDB, 0xFB, 0x9B, 0xB4, 0x07, 0x05, 0x83, + 0xDD, 0x1B, 0x28, 0x70, 0x21, 0x50, 0xF9, 0xC9 + }, + { + 0xB0, 0x0B, 0xFA, 0x10, 0xB9, 0x9E, 0xD3, 0x1E, + 0x19, 0x1C, 0xFF, 0x0C, 0xC0, 0x2C, 0x6E, 0x37, + 0x1D, 0x6E, 0x4C, 0x17, 0x27, 0x43, 0x56, 0xBA, + 0xFE, 0x29, 0xCC, 0x7A, 0xDF, 0x1B, 0x63, 0x9D + }, + { + 0xEE, 0x72, 0x9B, 0xEF, 0xDB, 0xCF, 0x2F, 0x0E, + 0x87, 0xB8, 0x9C, 0xBB, 0xA4, 0x69, 0x68, 0x91, + 0xBE, 0xD8, 0x96, 0xA3, 0xC1, 0xC8, 0xE4, 0x32, + 0x49, 0xC5, 0x21, 0x2D, 0xE6, 0x33, 0xE5, 0x54 + }, + { + 0xE7, 0xA9, 0xD9, 0xFA, 0xE0, 0x30, 0xA7, 0x9C, + 0x2E, 0x54, 0x7E, 0xE9, 0xA9, 0xF2, 0x81, 0x1F, + 0x43, 0xCE, 0x5E, 0x5B, 0x5D, 0x36, 0xB9, 0x0A, + 0x86, 0xD6, 0x96, 0x28, 0xB9, 0x71, 0x26, 0xDB + }, + { + 0xF7, 0x5D, 0xEB, 0xBB, 0x20, 0x08, 0xA4, 0xC0, + 0x4E, 0x21, 0xE3, 0x94, 0x50, 0x16, 0x13, 0xC4, + 0xB3, 0x6B, 0x50, 0xCF, 0x29, 0xF6, 0x6D, 0x69, + 0x59, 0x1F, 0xEA, 0xC4, 0x53, 0xC4, 0x33, 0x4F + }, + { + 0xDB, 0x22, 0x6B, 0x08, 0xD5, 0xE0, 0x4F, 0xFB, + 0x1D, 0x44, 0x00, 0x78, 0x5C, 0x21, 0xD4, 0xCC, + 0x4D, 0x84, 0x22, 0xA1, 0xBA, 0x2F, 0x4A, 0x64, + 0x81, 0xA5, 0x1C, 0x9D, 0x71, 0xD1, 0x44, 0x68 + }, + { + 0xAB, 0x49, 0x6C, 0x62, 0x75, 0x95, 0xA4, 0xEA, + 0x20, 0x6C, 0x2F, 0x7A, 0xD7, 0x40, 0x94, 0x98, + 0x24, 0x2F, 0x7A, 0x48, 0x6E, 0xD7, 0x6C, 0xB9, + 0xC6, 0x7B, 0x30, 0x1D, 0x06, 0x3D, 0x0F, 0x81 + }, + { + 0x17, 0x4D, 0xA9, 0x09, 0x4B, 0x99, 0xF1, 0x44, + 0xDF, 0xD2, 0x60, 0x08, 0xB6, 0x7F, 0xB2, 0x1F, + 0x99, 0x75, 0xAD, 0x80, 0x58, 0x5F, 0x9C, 0xB3, + 0xFA, 0xDC, 0xAE, 0x51, 0x86, 0xF6, 0x8F, 0x4E + }, + { + 0x1C, 0x57, 0xF6, 0xEF, 0x35, 0x1C, 0xA1, 0xFD, + 0x98, 0xCD, 0x5D, 0x31, 0xC4, 0xEE, 0xF9, 0xDF, + 0x0D, 0x03, 0x44, 0x51, 0x81, 0x5E, 0x35, 0x61, + 0xFB, 0xEC, 0x02, 0x79, 0x08, 0x37, 0xBD, 0xE2 + }, + { + 0xD7, 0x37, 0xF1, 0xD1, 0x6D, 0x38, 0xA5, 0xF4, + 0x2C, 0xC0, 0xE6, 0xAD, 0xF6, 0xCE, 0xF4, 0x62, + 0x06, 0xD5, 0x11, 0x59, 0x88, 0x02, 0x2F, 0x87, + 0x09, 0x7A, 0x42, 0xA2, 0xEC, 0x25, 0xE6, 0x1E + }, + { + 0xAE, 0xAC, 0x48, 0x23, 0x4D, 0xC8, 0x2B, 0xCA, + 0xD4, 0x02, 0x50, 0x9F, 0x61, 0x4E, 0x63, 0x42, + 0x3D, 0xB2, 0x78, 0x89, 0x08, 0x02, 0x0A, 0xAD, + 0x7A, 0xA4, 0xD0, 0xAD, 0x9F, 0x0E, 0xFE, 0xDE + }, + { + 0x52, 0x21, 0xD8, 0xDC, 0x3A, 0x62, 0x47, 0xF3, + 0xBF, 0x75, 0xF1, 0x72, 0xBE, 0x9A, 0x05, 0xB1, + 0x84, 0xA5, 0xCF, 0xA3, 0x4E, 0xD4, 0x95, 0x6F, + 0x7C, 0x98, 0xD7, 0x80, 0xF0, 0xD0, 0x29, 0xE2 + }, + { + 0x2A, 0xFB, 0xCE, 0x82, 0x49, 0x0D, 0x5D, 0xFA, + 0x4B, 0x30, 0x5D, 0x60, 0x48, 0xE8, 0x33, 0xA2, + 0xEE, 0x6A, 0xCF, 0x8A, 0x72, 0x2E, 0xB2, 0x2E, + 0x8C, 0x89, 0x31, 0xE3, 0x38, 0x9C, 0xC0, 0x4D + }, + { + 0x6B, 0xD9, 0x13, 0x7F, 0xA1, 0xDA, 0xFB, 0x7E, + 0xF2, 0x6A, 0xFE, 0xB1, 0xB4, 0xB4, 0x38, 0x0A, + 0x19, 0x56, 0xF3, 0x28, 0x49, 0x70, 0x7B, 0x94, + 0x6F, 0x5D, 0x17, 0xF8, 0x4E, 0x6C, 0x82, 0x89 + }, + { + 0x74, 0x5B, 0x72, 0xB2, 0x2B, 0x80, 0x11, 0x1A, + 0x42, 0x1D, 0x90, 0x4B, 0xE9, 0x15, 0x9C, 0xB2, + 0x38, 0xCF, 0x33, 0xCA, 0x6E, 0x44, 0x34, 0x83, + 0xD7, 0x04, 0x33, 0xF5, 0x03, 0x28, 0xAD, 0xF1 + }, + { + 0xD9, 0x9B, 0x54, 0x9D, 0x73, 0x5D, 0x05, 0x4F, + 0x57, 0xC8, 0xF3, 0x28, 0xFF, 0x46, 0x58, 0x43, + 0x79, 0x0D, 0x23, 0x6B, 0x97, 0x11, 0x3D, 0x8F, + 0xF7, 0x7B, 0x0B, 0xD3, 0x8A, 0x0E, 0x21, 0xA1 + }, + { + 0x51, 0x68, 0xD9, 0xB2, 0x36, 0x71, 0x7E, 0x0F, + 0x8A, 0x58, 0x65, 0x37, 0xF7, 0xE3, 0x29, 0x50, + 0xF1, 0x58, 0x8A, 0x9F, 0xDC, 0x41, 0xEB, 0x4A, + 0xDC, 0xBD, 0x07, 0xE0, 0x27, 0x57, 0xFF, 0x0F + }, + { + 0x00, 0x1C, 0x11, 0x63, 0xB8, 0x91, 0x4D, 0x6C, + 0xDB, 0xF8, 0x9A, 0x97, 0x8B, 0x56, 0x6D, 0x55, + 0xBE, 0x11, 0xD5, 0xF5, 0xF6, 0x52, 0xE4, 0x33, + 0x74, 0xCE, 0x24, 0xFD, 0x33, 0xCA, 0xEA, 0x47 + }, + { + 0xA5, 0xD2, 0xDE, 0x07, 0x76, 0x8D, 0x11, 0x08, + 0xB7, 0x68, 0xE5, 0x28, 0xC1, 0xBE, 0xB1, 0x1D, + 0xCB, 0xA4, 0xC6, 0xF9, 0x53, 0xCF, 0x37, 0xF8, + 0x28, 0xC9, 0x50, 0x68, 0xC4, 0x96, 0x7E, 0x76 + }, + { + 0x29, 0xBA, 0x9C, 0x46, 0xC2, 0x59, 0xC7, 0x20, + 0x4C, 0x17, 0x68, 0x31, 0xE9, 0xDE, 0x12, 0x43, + 0x56, 0xA2, 0x75, 0x1B, 0x08, 0x73, 0xCC, 0x51, + 0xE6, 0xDB, 0x10, 0xFC, 0x07, 0x47, 0x6A, 0x2A + }, + { + 0x10, 0x00, 0xA2, 0xF4, 0xA8, 0xC3, 0x04, 0xEF, + 0x08, 0x0F, 0xDB, 0x87, 0x70, 0xF9, 0xD6, 0xBB, + 0xE2, 0xDD, 0x05, 0x87, 0xA1, 0x12, 0x4C, 0x39, + 0x19, 0xAF, 0xD8, 0x5E, 0x2B, 0xF3, 0x12, 0x41 + }, + { + 0xAF, 0x58, 0xD2, 0x82, 0x62, 0x46, 0x8A, 0x37, + 0x7B, 0x01, 0x1E, 0xCA, 0xAC, 0xD2, 0x2A, 0xCB, + 0xD7, 0xE7, 0x20, 0xB7, 0xAB, 0x1F, 0xF5, 0xAE, + 0xEF, 0x5D, 0x95, 0x64, 0xA8, 0x32, 0x71, 0xDF + }, + { + 0xA5, 0xC7, 0x52, 0x48, 0x4E, 0x0C, 0x84, 0x8A, + 0x62, 0x5F, 0xC3, 0x18, 0xA8, 0x8A, 0xF9, 0x7C, + 0xFD, 0x64, 0x08, 0x6E, 0xF2, 0xA2, 0x28, 0xB5, + 0x81, 0x3B, 0xA5, 0xC2, 0x0A, 0x54, 0x8C, 0x78 + }, + { + 0x05, 0xED, 0xAD, 0x98, 0xDD, 0xFB, 0x70, 0x46, + 0x86, 0xFE, 0xDE, 0xCB, 0xB2, 0xFD, 0xDB, 0x79, + 0x15, 0x21, 0xE3, 0xFB, 0xA0, 0xDF, 0x84, 0x54, + 0x80, 0x6C, 0x89, 0xAC, 0x96, 0x7B, 0x64, 0x26 + }, + { + 0x7E, 0xEE, 0xE9, 0x87, 0x14, 0x37, 0x5D, 0x15, + 0x42, 0xB7, 0xEA, 0xAB, 0xDD, 0x56, 0x1E, 0xE2, + 0x2F, 0x77, 0x8A, 0x06, 0xD0, 0x32, 0xEE, 0x28, + 0x7F, 0xA6, 0x12, 0x2F, 0x5A, 0xCA, 0x76, 0xC9 + }, + { + 0xBB, 0x60, 0xBF, 0xFE, 0x41, 0x02, 0xCD, 0xC2, + 0x5D, 0x77, 0x4D, 0x27, 0x40, 0x49, 0x75, 0x8C, + 0x8D, 0x31, 0xF8, 0xA0, 0x29, 0xFB, 0xCB, 0xB9, + 0x9E, 0x07, 0x59, 0x3F, 0x01, 0xC2, 0x5B, 0x30 + }, + { + 0xEC, 0x6E, 0xF0, 0x89, 0x2D, 0x01, 0x37, 0x26, + 0x7D, 0xDA, 0xEF, 0x49, 0x7C, 0x59, 0x7B, 0x28, + 0x09, 0xD3, 0xC8, 0xBB, 0x79, 0x73, 0xA8, 0x3B, + 0x96, 0x67, 0xDC, 0x39, 0xA7, 0x35, 0x84, 0x9F + }, + { + 0x1A, 0xB2, 0x33, 0xBA, 0x04, 0x4F, 0xEB, 0xC6, + 0xED, 0x8B, 0x99, 0x87, 0xD0, 0x40, 0x9D, 0xA0, + 0xB2, 0xDF, 0xB8, 0x6E, 0x2F, 0x2D, 0xEA, 0x4B, + 0xC7, 0xC6, 0x24, 0x49, 0x0F, 0xDA, 0xC9, 0xF9 + }, + { + 0xC3, 0x1F, 0xC3, 0xCA, 0x41, 0x4A, 0x28, 0x1C, + 0x91, 0x96, 0x77, 0x58, 0x74, 0xEC, 0xA8, 0xD0, + 0xBF, 0x9F, 0x6A, 0xE7, 0x23, 0xEC, 0xC4, 0xD6, + 0x58, 0x34, 0xD4, 0x1E, 0x08, 0xD7, 0x91, 0x71 + }, + { + 0x64, 0x20, 0x4A, 0x8D, 0x36, 0xCA, 0x1C, 0x7B, + 0x64, 0xB7, 0xD0, 0xAE, 0xDC, 0x4F, 0x57, 0x6F, + 0xA3, 0xB0, 0xC0, 0x02, 0x81, 0x66, 0x2B, 0x0C, + 0x8D, 0xF2, 0x33, 0x24, 0x94, 0x9E, 0x26, 0xDE + }, + { + 0x3D, 0xFC, 0xCE, 0x19, 0x89, 0xF9, 0x4B, 0xE5, + 0xC5, 0xDC, 0xA4, 0x30, 0xAB, 0x18, 0x3E, 0xDD, + 0x92, 0xC6, 0xA8, 0x82, 0x82, 0x5D, 0x08, 0xCD, + 0x0B, 0x27, 0x96, 0xC8, 0xBF, 0x88, 0x6B, 0x45 + }, + { + 0x4E, 0x48, 0x2A, 0x52, 0x79, 0x31, 0x78, 0xF2, + 0xB6, 0x59, 0x94, 0x94, 0x7C, 0xB4, 0x2B, 0x4E, + 0x1D, 0xE7, 0xB3, 0x16, 0xD6, 0xAD, 0x7A, 0x84, + 0x78, 0xCF, 0x65, 0x5C, 0xF8, 0xFF, 0xC8, 0x29 + }, + { + 0x4A, 0x3C, 0xA6, 0x30, 0x39, 0x28, 0x1F, 0x17, + 0xA1, 0x31, 0xB1, 0xE3, 0x02, 0x5E, 0x0F, 0xD0, + 0x4B, 0x51, 0x4E, 0xD3, 0x25, 0x85, 0x92, 0xB9, + 0x7D, 0xB0, 0xD6, 0x70, 0x95, 0x8C, 0x61, 0x5F + }, + { + 0x12, 0x81, 0xFC, 0x31, 0xBA, 0xBC, 0x28, 0xBF, + 0xF7, 0xCC, 0x92, 0xF8, 0x47, 0xF3, 0x4A, 0xED, + 0x3D, 0x3B, 0xD1, 0x07, 0x67, 0x64, 0x74, 0x88, + 0x72, 0x39, 0x46, 0x3F, 0x21, 0xCC, 0xD8, 0xB4 + }, + { + 0xCB, 0x55, 0x00, 0xA0, 0x01, 0x13, 0x98, 0x7A, + 0x1B, 0x5C, 0xE2, 0xB8, 0xF1, 0xB0, 0x96, 0x66, + 0xAA, 0xF1, 0x91, 0x96, 0x28, 0xD0, 0x74, 0x1B, + 0xDC, 0xAE, 0x88, 0xA0, 0xB1, 0x4F, 0xF1, 0x42 + }, + { + 0x9B, 0x07, 0xB9, 0x49, 0x1B, 0x09, 0x50, 0xA4, + 0x67, 0xAD, 0x20, 0x65, 0xA7, 0x29, 0xA0, 0x11, + 0x6F, 0xE8, 0x75, 0xAE, 0x58, 0x31, 0xDA, 0x7E, + 0xBC, 0xA0, 0xCA, 0x27, 0x19, 0xC0, 0x20, 0x24 + }, + { + 0x69, 0x37, 0x93, 0xD0, 0x73, 0xAF, 0xFE, 0x2F, + 0x41, 0x25, 0xB3, 0xE2, 0x1E, 0x3D, 0x40, 0x1E, + 0xE7, 0xF7, 0xE1, 0xE6, 0x6E, 0x02, 0x35, 0x0C, + 0x08, 0x5E, 0x0C, 0xA0, 0xC4, 0x05, 0x45, 0x2F + }, + { + 0xC7, 0xFE, 0x8C, 0xCE, 0x64, 0xBA, 0xC5, 0x45, + 0x84, 0x2B, 0x0E, 0xB3, 0x7A, 0x63, 0xCD, 0x5C, + 0x97, 0x8C, 0x86, 0xEC, 0x29, 0xDE, 0xAE, 0xBC, + 0xA7, 0x4A, 0x9A, 0xDF, 0x0B, 0xDD, 0x11, 0x05 + }, + { + 0xFF, 0x95, 0xEE, 0x25, 0x1B, 0x91, 0xEB, 0xA9, + 0xC1, 0x58, 0x37, 0xBB, 0xE5, 0x37, 0x75, 0xE7, + 0x17, 0xE1, 0x68, 0x09, 0x8E, 0xC1, 0x03, 0x18, + 0x8E, 0x1D, 0x8A, 0x6F, 0xCB, 0x22, 0x3C, 0x2A + }, + { + 0x22, 0xA3, 0x90, 0x32, 0x06, 0x4D, 0xFF, 0x57, + 0x61, 0x14, 0x3E, 0x69, 0x99, 0x3D, 0xDD, 0xDC, + 0x82, 0xEB, 0x5C, 0xE3, 0xCB, 0x4B, 0x97, 0x73, + 0x25, 0x68, 0xD6, 0x80, 0xCF, 0x69, 0xFB, 0x1A + }, + { + 0x43, 0x7D, 0xAA, 0x53, 0xB1, 0x9D, 0xD1, 0x36, + 0x38, 0x2C, 0xC6, 0x61, 0x02, 0x32, 0x0B, 0xF2, + 0xC5, 0x01, 0xA7, 0x0A, 0xE1, 0x37, 0x96, 0x74, + 0xA8, 0xD3, 0xBF, 0xCC, 0x1F, 0x20, 0xC2, 0xE0 + }, + { + 0x86, 0x58, 0x61, 0x0C, 0x43, 0xED, 0x0C, 0x5B, + 0x1C, 0x9B, 0xBD, 0xB6, 0x3C, 0x9E, 0x50, 0xAE, + 0x93, 0x3F, 0x97, 0xAB, 0xC9, 0x66, 0x53, 0x32, + 0x43, 0x70, 0x52, 0x81, 0xA6, 0x92, 0xE4, 0x32 + }, + { + 0x02, 0x1A, 0x93, 0xB1, 0x4C, 0xAB, 0xFD, 0xC2, + 0x18, 0x43, 0x24, 0x0B, 0xA1, 0xBE, 0x68, 0x57, + 0x8B, 0xB7, 0x0A, 0xF4, 0x2F, 0xEF, 0x96, 0xF1, + 0x30, 0x52, 0x19, 0xD5, 0xAE, 0x32, 0xEC, 0x19 + }, + { + 0x9D, 0xAF, 0x89, 0x0B, 0x39, 0x34, 0x81, 0xE0, + 0x00, 0x8E, 0x58, 0xD1, 0xF2, 0xD8, 0x6D, 0xEE, + 0x64, 0x79, 0x90, 0x73, 0x79, 0x1E, 0xCC, 0x7B, + 0x06, 0x64, 0x07, 0x7B, 0x84, 0x6F, 0x87, 0xE7 + }, + { + 0x2D, 0xC7, 0x0B, 0xA5, 0x9E, 0xDE, 0x22, 0x35, + 0xE3, 0x73, 0x69, 0x02, 0x51, 0x66, 0x44, 0x37, + 0x45, 0xEB, 0xE3, 0x08, 0x5B, 0xFF, 0x2C, 0x42, + 0xFB, 0xF6, 0x3A, 0x4D, 0x5D, 0xCE, 0xA0, 0x8E + }, + { + 0x0D, 0xAB, 0x29, 0x8F, 0xF8, 0x96, 0xE7, 0xEA, + 0x58, 0x6E, 0x67, 0xAE, 0x29, 0xE9, 0x23, 0xBE, + 0x6B, 0x1F, 0x52, 0xC6, 0x12, 0x34, 0xBE, 0x37, + 0x57, 0x90, 0xFD, 0xDF, 0x1B, 0xED, 0x35, 0x0D + }, + { + 0xCC, 0xF2, 0xB2, 0xA4, 0x5F, 0x2F, 0xAD, 0xC9, + 0xF3, 0x5D, 0x3D, 0x48, 0x81, 0x30, 0x7B, 0x24, + 0x7C, 0x9A, 0x2C, 0xED, 0xE2, 0x6A, 0x01, 0x8A, + 0xF5, 0x47, 0x93, 0x67, 0x8E, 0xD5, 0xE5, 0x9A + }, + { + 0xAA, 0x46, 0xA5, 0x5F, 0x87, 0xC9, 0xAA, 0x50, + 0x72, 0x33, 0xF8, 0x6A, 0x97, 0xEC, 0x65, 0x6F, + 0xE1, 0xCB, 0x82, 0x4C, 0x70, 0x31, 0xDE, 0xB0, + 0x9C, 0x06, 0xC4, 0x19, 0xDC, 0xE0, 0xE2, 0x42 + }, + { + 0x20, 0x5F, 0x3A, 0x7A, 0x6B, 0x0C, 0x7D, 0x5D, + 0xF4, 0xF1, 0x05, 0x5F, 0x80, 0x23, 0xFC, 0x71, + 0x09, 0x27, 0x50, 0x12, 0x2A, 0x5C, 0xA2, 0xDE, + 0xEE, 0x4D, 0xE2, 0x1B, 0xBF, 0x1D, 0xDD, 0xB0 + }, + { + 0xFC, 0xCC, 0xF7, 0x3A, 0xD3, 0x17, 0x42, 0x4F, + 0x24, 0x61, 0xF0, 0x8E, 0xF2, 0x74, 0x36, 0xAF, + 0xE6, 0xA0, 0x56, 0x91, 0xB5, 0x88, 0x97, 0x76, + 0xAA, 0xDF, 0x54, 0xBE, 0x6B, 0x33, 0x1B, 0x2D + }, + { + 0x9E, 0x83, 0x65, 0x19, 0x97, 0xC8, 0xB0, 0xA5, + 0x06, 0xD4, 0x41, 0xA9, 0xAE, 0xF5, 0x0D, 0x59, + 0xF6, 0x29, 0x47, 0x40, 0x30, 0xC5, 0x87, 0xC3, + 0x37, 0xA9, 0x80, 0xC7, 0xBA, 0xEB, 0x57, 0x54 + }, + { + 0x2D, 0xC8, 0x39, 0xAB, 0x4C, 0x22, 0x38, 0x1C, + 0xD7, 0xB6, 0xD3, 0x8E, 0x64, 0x0F, 0x8F, 0x65, + 0xF4, 0x5E, 0xBE, 0x1A, 0x4A, 0x60, 0xC2, 0xF4, + 0xF2, 0xC1, 0x4F, 0xB9, 0xD8, 0xE6, 0xF5, 0xCE + }, + { + 0x9F, 0xE9, 0x9A, 0x83, 0x25, 0xE2, 0xE0, 0x2E, + 0x0A, 0xC4, 0x04, 0x6B, 0xD9, 0xC8, 0xB9, 0xF3, + 0x08, 0x42, 0x51, 0x40, 0x83, 0xF9, 0xF4, 0xA7, + 0xCF, 0x7D, 0x35, 0x62, 0xB4, 0xA0, 0x46, 0x08 + }, + { + 0xCE, 0x5D, 0x74, 0x7D, 0x98, 0x27, 0x2B, 0x08, + 0xC9, 0xB8, 0xFF, 0x2E, 0x94, 0x94, 0xD0, 0xBB, + 0x90, 0xE1, 0xBF, 0x88, 0x35, 0xE3, 0xD2, 0xB7, + 0x25, 0x0A, 0x88, 0xB5, 0xA6, 0x5A, 0x83, 0x15 + }, + { + 0x0C, 0xB1, 0x93, 0x86, 0x3F, 0x79, 0x01, 0xE5, + 0x2C, 0x20, 0xF0, 0xB0, 0x7D, 0x7B, 0x0E, 0xBD, + 0x1D, 0xF4, 0x8D, 0x50, 0xED, 0xB8, 0x74, 0xF9, + 0x25, 0xE2, 0xEA, 0x62, 0x25, 0xDB, 0x88, 0x3B + }, + { + 0x1F, 0x59, 0x51, 0x5C, 0xC7, 0x50, 0x8C, 0x08, + 0x82, 0x85, 0xE8, 0x62, 0xBE, 0x03, 0x94, 0x46, + 0x1E, 0xD8, 0x41, 0xB1, 0x26, 0x62, 0xE0, 0x02, + 0xC5, 0x9E, 0xCA, 0x71, 0x5C, 0xBB, 0xD2, 0x63 + }, + { + 0x2A, 0xC6, 0x9D, 0x7D, 0x6C, 0x26, 0x6E, 0x61, + 0x00, 0xDA, 0x96, 0xC7, 0xCC, 0x1A, 0x66, 0x4D, + 0x0D, 0x39, 0xCE, 0xE8, 0x5C, 0x2D, 0x46, 0x83, + 0x42, 0xF4, 0x2A, 0xE3, 0x92, 0x0B, 0x29, 0x0F + }, + { + 0xC0, 0x37, 0x3E, 0x2C, 0xCB, 0x1F, 0xC0, 0x3C, + 0x79, 0x75, 0xA8, 0xA9, 0x5D, 0xE3, 0xBF, 0x0E, + 0x91, 0x8B, 0xB1, 0x10, 0xD0, 0x7D, 0x5A, 0xEB, + 0x7A, 0x51, 0x5A, 0xD5, 0x56, 0xDD, 0xCE, 0x27 + }, + { + 0xD1, 0xB8, 0xCC, 0x00, 0xAD, 0x06, 0xA6, 0x58, + 0xC0, 0xF3, 0x43, 0x7B, 0xD7, 0xFC, 0x30, 0x5D, + 0xFF, 0x7E, 0x89, 0x99, 0x49, 0x06, 0xBE, 0x01, + 0xDF, 0x53, 0xFB, 0xDE, 0xA7, 0x76, 0x27, 0x5E + }, + { + 0xB1, 0xAB, 0x69, 0x7A, 0xE9, 0xD3, 0x90, 0xDE, + 0x12, 0xDC, 0xF6, 0xC0, 0xDD, 0xDB, 0x3B, 0x58, + 0xC9, 0xBA, 0x34, 0x7A, 0x80, 0x04, 0x45, 0x52, + 0x9B, 0x4F, 0xC2, 0x77, 0x32, 0xEC, 0x3A, 0x82 + }, + { + 0xCB, 0x06, 0x51, 0x22, 0x0A, 0x40, 0x18, 0x63, + 0x23, 0x8C, 0x57, 0x63, 0xC2, 0xBC, 0x3F, 0x2C, + 0x7A, 0x16, 0x66, 0xDA, 0x3E, 0x80, 0x46, 0x61, + 0xDB, 0x7B, 0x0B, 0x00, 0x6D, 0xEA, 0x03, 0x3A + }, + { + 0xB8, 0x3E, 0x87, 0xC3, 0x68, 0xEA, 0xE2, 0xCF, + 0x52, 0x06, 0xD9, 0x19, 0x24, 0xC2, 0x5D, 0x4E, + 0x3F, 0x18, 0x15, 0x3A, 0x63, 0x7F, 0x0C, 0x6C, + 0x42, 0x1D, 0x6C, 0xB5, 0xE5, 0x8A, 0x6C, 0xD4 + }, + { + 0x10, 0x04, 0x82, 0x73, 0x22, 0xFA, 0x80, 0xF4, + 0x9E, 0xBB, 0xC6, 0xCA, 0xC1, 0xCE, 0x61, 0xC8, + 0x2F, 0xB4, 0xEB, 0x0B, 0xE8, 0x2C, 0x49, 0x19, + 0xAB, 0x32, 0x42, 0x22, 0xA5, 0x86, 0x65, 0x41 + }, + { + 0xDB, 0xEE, 0xC0, 0xAE, 0xEF, 0x18, 0xD1, 0x77, + 0xB8, 0x4D, 0xBE, 0xB9, 0x31, 0xCC, 0x6F, 0xDE, + 0x69, 0x9B, 0x09, 0x0D, 0x25, 0x8F, 0x95, 0xD9, + 0xAE, 0x66, 0x72, 0xAD, 0x77, 0x1D, 0xE1, 0xB1 + }, + { + 0xF9, 0x6D, 0x24, 0x71, 0x1E, 0x07, 0xD3, 0x12, + 0x9A, 0x95, 0x38, 0x07, 0x78, 0xF6, 0x2C, 0x14, + 0xBA, 0x7B, 0xB4, 0xE7, 0x08, 0x6C, 0x5B, 0x3E, + 0xE5, 0x37, 0x0B, 0x8F, 0x25, 0xBE, 0x98, 0x51 + }, + { + 0xAE, 0xDF, 0xE2, 0x6D, 0x24, 0x62, 0xA6, 0x91, + 0xB7, 0x35, 0xE5, 0x07, 0x29, 0xF3, 0xC3, 0xA3, + 0x86, 0x54, 0x4A, 0x0D, 0x28, 0x84, 0x9B, 0xE9, + 0x14, 0x78, 0xE4, 0x59, 0xBD, 0x7A, 0x81, 0x28 + }, + { + 0x0C, 0xD8, 0x2D, 0xED, 0xD5, 0xFA, 0x71, 0xED, + 0xD1, 0x8A, 0xD6, 0xA6, 0x23, 0xA9, 0xC1, 0x45, + 0xD9, 0x3A, 0x6F, 0xF4, 0xE9, 0xAF, 0x94, 0x9F, + 0xDE, 0x29, 0xCB, 0x51, 0x0D, 0xA0, 0xB0, 0x0C + }, + { + 0x2D, 0x99, 0x5F, 0xC7, 0x97, 0x74, 0xBA, 0xD1, + 0x42, 0x13, 0x90, 0x32, 0xC7, 0x65, 0x35, 0xE6, + 0xC1, 0x87, 0x56, 0x90, 0x6B, 0x54, 0xEF, 0x6D, + 0x5E, 0xD0, 0x9A, 0xD7, 0x04, 0xBA, 0xE5, 0x46 + }, +}; + + + + +static const uint8_t blake2sp_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2S_OUTBYTES] = +{ + { + 0x71, 0x5C, 0xB1, 0x38, 0x95, 0xAE, 0xB6, 0x78, + 0xF6, 0x12, 0x41, 0x60, 0xBF, 0xF2, 0x14, 0x65, + 0xB3, 0x0F, 0x4F, 0x68, 0x74, 0x19, 0x3F, 0xC8, + 0x51, 0xB4, 0x62, 0x10, 0x43, 0xF0, 0x9C, 0xC6 + }, + { + 0x40, 0x57, 0x8F, 0xFA, 0x52, 0xBF, 0x51, 0xAE, + 0x18, 0x66, 0xF4, 0x28, 0x4D, 0x3A, 0x15, 0x7F, + 0xC1, 0xBC, 0xD3, 0x6A, 0xC1, 0x3C, 0xBD, 0xCB, + 0x03, 0x77, 0xE4, 0xD0, 0xCD, 0x0B, 0x66, 0x03 + }, + { + 0x67, 0xE3, 0x09, 0x75, 0x45, 0xBA, 0xD7, 0xE8, + 0x52, 0xD7, 0x4D, 0x4E, 0xB5, 0x48, 0xEC, 0xA7, + 0xC2, 0x19, 0xC2, 0x02, 0xA7, 0xD0, 0x88, 0xDB, + 0x0E, 0xFE, 0xAC, 0x0E, 0xAC, 0x30, 0x42, 0x49 + }, + { + 0x8D, 0xBC, 0xC0, 0x58, 0x9A, 0x3D, 0x17, 0x29, + 0x6A, 0x7A, 0x58, 0xE2, 0xF1, 0xEF, 0xF0, 0xE2, + 0xAA, 0x42, 0x10, 0xB5, 0x8D, 0x1F, 0x88, 0xB8, + 0x6D, 0x7B, 0xA5, 0xF2, 0x9D, 0xD3, 0xB5, 0x83 + }, + { + 0xA9, 0xA9, 0x65, 0x2C, 0x8C, 0x67, 0x75, 0x94, + 0xC8, 0x72, 0x12, 0xD8, 0x9D, 0x5A, 0x75, 0xFB, + 0x31, 0xEF, 0x4F, 0x47, 0xC6, 0x58, 0x2C, 0xDE, + 0x5F, 0x1E, 0xF6, 0x6B, 0xD4, 0x94, 0x53, 0x3A + }, + { + 0x05, 0xA7, 0x18, 0x0E, 0x59, 0x50, 0x54, 0x73, + 0x99, 0x48, 0xC5, 0xE3, 0x38, 0xC9, 0x5F, 0xE0, + 0xB7, 0xFC, 0x61, 0xAC, 0x58, 0xA7, 0x35, 0x74, + 0x74, 0x56, 0x33, 0xBB, 0xC1, 0xF7, 0x70, 0x31 + }, + { + 0x81, 0x4D, 0xE8, 0x31, 0x53, 0xB8, 0xD7, 0x5D, + 0xFA, 0xDE, 0x29, 0xFD, 0x39, 0xAC, 0x72, 0xDD, + 0x09, 0xCA, 0x0F, 0x9B, 0xC8, 0xB7, 0xAB, 0x6A, + 0x06, 0xBA, 0xEE, 0x7D, 0xD0, 0xF9, 0xF0, 0x83 + }, + { + 0xDF, 0xD4, 0x19, 0x44, 0x91, 0x29, 0xFF, 0x60, + 0x4F, 0x0A, 0x14, 0x8B, 0x4C, 0x7D, 0x68, 0xF1, + 0x17, 0x4F, 0x7D, 0x0F, 0x8C, 0x8D, 0x2C, 0xE7, + 0x7F, 0x44, 0x8F, 0xD3, 0x41, 0x9C, 0x6F, 0xB0 + }, + { + 0xB9, 0xED, 0x22, 0xE7, 0xDD, 0x8D, 0xD1, 0x4E, + 0xE8, 0xC9, 0x5B, 0x20, 0xE7, 0x63, 0x2E, 0x85, + 0x53, 0xA2, 0x68, 0xD9, 0xFF, 0x86, 0x33, 0xED, + 0x3C, 0x21, 0xD1, 0xB8, 0xC9, 0xA7, 0x0B, 0xE1 + }, + { + 0x95, 0xF0, 0x31, 0x67, 0x1A, 0x4E, 0x3C, 0x54, + 0x44, 0x1C, 0xEE, 0x9D, 0xBE, 0xF4, 0xB7, 0xAC, + 0xA4, 0x46, 0x18, 0xA3, 0xA3, 0x33, 0xAD, 0x74, + 0x06, 0xD1, 0x97, 0xAC, 0x5B, 0xA0, 0x79, 0x1A + }, + { + 0xE2, 0x92, 0x5B, 0x9D, 0x5C, 0xA0, 0xFF, 0x62, + 0x88, 0xC5, 0xEA, 0x1A, 0xF2, 0xD2, 0x2B, 0x0A, + 0x6B, 0x79, 0xE2, 0xDA, 0xE0, 0x8B, 0xFD, 0x36, + 0xC3, 0xBE, 0x10, 0xBB, 0x8D, 0x71, 0xD8, 0x39 + }, + { + 0x16, 0x24, 0x9C, 0x74, 0x4E, 0x49, 0x51, 0x45, + 0x1D, 0x4C, 0x89, 0x4F, 0xB5, 0x9A, 0x3E, 0xCB, + 0x3F, 0xBF, 0xB7, 0xA4, 0x5F, 0x96, 0xF8, 0x5D, + 0x15, 0x80, 0xAC, 0x0B, 0x84, 0x2D, 0x96, 0xDA + }, + { + 0x43, 0x2B, 0xC9, 0x1C, 0x52, 0xAC, 0xEB, 0x9D, + 0xAE, 0xD8, 0x83, 0x28, 0x81, 0x64, 0x86, 0x50, + 0xC1, 0xB8, 0x1D, 0x11, 0x7A, 0xBD, 0x68, 0xE0, + 0x84, 0x51, 0x50, 0x8A, 0x63, 0xBE, 0x00, 0x81 + }, + { + 0xCD, 0xE8, 0x20, 0x2B, 0xCF, 0xA3, 0xF3, 0xE9, + 0x5D, 0x79, 0xBA, 0xCC, 0x16, 0x5D, 0x52, 0x70, + 0x0E, 0xF7, 0x1D, 0x87, 0x4A, 0x3C, 0x63, 0x7E, + 0x63, 0x4F, 0x64, 0x44, 0x73, 0x72, 0x0D, 0x6B + }, + { + 0x16, 0x21, 0x62, 0x1F, 0x5C, 0x3E, 0xE4, 0x46, + 0x89, 0x9D, 0x3C, 0x8A, 0xAE, 0x49, 0x17, 0xB1, + 0xE6, 0xDB, 0x4A, 0x0E, 0xD0, 0x42, 0x31, 0x5F, + 0xB2, 0xC1, 0x74, 0x82, 0x5E, 0x0A, 0x18, 0x19 + }, + { + 0x33, 0x6E, 0x8E, 0xBC, 0x71, 0xE2, 0x09, 0x5C, + 0x27, 0xF8, 0x64, 0xA3, 0x12, 0x1E, 0xFD, 0x0F, + 0xAA, 0x7A, 0x41, 0x28, 0x57, 0x25, 0xA5, 0x92, + 0xF6, 0x1B, 0xED, 0xED, 0x9D, 0xDE, 0x86, 0xED + }, + { + 0x07, 0x9B, 0xE0, 0x41, 0x0E, 0x78, 0x9B, 0x36, + 0xEE, 0x7F, 0x55, 0xC1, 0x9F, 0xAA, 0xC6, 0x91, + 0x65, 0x6E, 0xB0, 0x52, 0x1F, 0x42, 0x94, 0x9B, + 0x84, 0xEE, 0x29, 0xFE, 0x2A, 0x0E, 0x7F, 0x36 + }, + { + 0x17, 0x27, 0x0C, 0x4F, 0x34, 0x88, 0x08, 0x2D, + 0x9F, 0xF9, 0x93, 0x7E, 0xAB, 0x3C, 0xA9, 0x9C, + 0x97, 0xC5, 0xB4, 0x59, 0x61, 0x47, 0x37, 0x2D, + 0xD4, 0xE9, 0x8A, 0xCF, 0x13, 0xDB, 0x28, 0x10 + }, + { + 0x18, 0x3C, 0x38, 0x75, 0x4D, 0x03, 0x41, 0xCE, + 0x07, 0xC1, 0x7A, 0x6C, 0xB6, 0xC2, 0xFD, 0x8B, + 0xBC, 0xC1, 0x40, 0x4F, 0xDD, 0x01, 0x41, 0x99, + 0xC7, 0x8B, 0xE1, 0xA9, 0x75, 0x59, 0xA9, 0x28 + }, + { + 0x6E, 0x52, 0xD7, 0x28, 0xA4, 0x05, 0xA6, 0xE1, + 0xF8, 0x75, 0x87, 0xBB, 0xC2, 0xAC, 0x91, 0xC5, + 0xC0, 0x9B, 0x2D, 0x82, 0x8A, 0xC8, 0x1E, 0x5C, + 0x4A, 0x81, 0xD0, 0x3D, 0xD4, 0xAA, 0x8D, 0x5C + }, + { + 0xF4, 0xE0, 0x8E, 0x05, 0x9B, 0x74, 0x14, 0x4B, + 0xF9, 0x48, 0x14, 0x6D, 0x14, 0xA2, 0xC8, 0x1E, + 0x46, 0xDC, 0x15, 0xFF, 0x26, 0xEB, 0x52, 0x34, + 0x4C, 0xDD, 0x47, 0x4A, 0xBE, 0xA1, 0x4B, 0xC0 + }, + { + 0x0F, 0x2E, 0x0A, 0x10, 0x0E, 0xD8, 0xA1, 0x17, + 0x85, 0x96, 0x2A, 0xD4, 0x59, 0x6A, 0xF9, 0x55, + 0xE3, 0x0B, 0x9A, 0xEF, 0x93, 0x0A, 0x24, 0x8D, + 0xA9, 0x32, 0x2B, 0x70, 0x2D, 0x4B, 0x68, 0x72 + }, + { + 0x51, 0x90, 0xFC, 0xC7, 0x32, 0xF4, 0x04, 0xAA, + 0xD4, 0x36, 0x4A, 0xC7, 0x96, 0x0C, 0xFD, 0x5B, + 0x4E, 0x34, 0x86, 0x29, 0xC3, 0x72, 0xEE, 0xB3, + 0x25, 0xB5, 0xC6, 0xC7, 0xCB, 0xCE, 0x59, 0xAB + }, + { + 0xC0, 0xC4, 0xCB, 0x86, 0xEA, 0x25, 0xEA, 0x95, + 0x7E, 0xEC, 0x5B, 0x22, 0xD2, 0x55, 0x0A, 0x16, + 0x49, 0xE6, 0xDF, 0xFA, 0x31, 0x6B, 0xB8, 0xF4, + 0xC9, 0x1B, 0x8F, 0xF7, 0xA2, 0x4B, 0x25, 0x31 + }, + { + 0x2C, 0x9E, 0xDA, 0x13, 0x5A, 0x30, 0xAE, 0xCA, + 0xF3, 0xAC, 0xB3, 0xD2, 0x3A, 0x30, 0x35, 0xFB, + 0xAB, 0xBA, 0x98, 0x33, 0x31, 0x65, 0xD8, 0x7F, + 0xCB, 0xF8, 0xFE, 0x10, 0x33, 0x6E, 0xCF, 0x20 + }, + { + 0x3C, 0xD6, 0x69, 0xE8, 0xD5, 0x62, 0x62, 0xA2, + 0x37, 0x13, 0x67, 0x22, 0x4D, 0xAE, 0x6D, 0x75, + 0x9E, 0xE1, 0x52, 0xC3, 0x15, 0x33, 0xB2, 0x63, + 0xFA, 0x2E, 0x64, 0x92, 0x08, 0x77, 0xB2, 0xA7 + }, + { + 0x18, 0xA9, 0xA0, 0xC2, 0xD0, 0xEA, 0x6C, 0x3B, + 0xB3, 0x32, 0x83, 0x0F, 0x89, 0x18, 0xB0, 0x68, + 0x4F, 0x5D, 0x39, 0x94, 0xDF, 0x48, 0x67, 0x46, + 0x2D, 0xD0, 0x6E, 0xF0, 0x86, 0x24, 0x24, 0xCC + }, + { + 0x73, 0x90, 0xEA, 0x41, 0x04, 0xA9, 0xF4, 0xEE, + 0xA9, 0x0F, 0x81, 0xE2, 0x6A, 0x12, 0x9D, 0xCF, + 0x9F, 0x4A, 0xF3, 0x83, 0x52, 0xD9, 0xCB, 0x6A, + 0x81, 0x2C, 0xC8, 0x05, 0x69, 0x09, 0x05, 0x0E + }, + { + 0xE4, 0x9E, 0x01, 0x14, 0xC6, 0x29, 0xB4, 0x94, + 0xB1, 0x1E, 0xA9, 0x8E, 0xCD, 0x40, 0x32, 0x73, + 0x1F, 0x15, 0x3B, 0x46, 0x50, 0xAC, 0xAC, 0xD7, + 0xE0, 0xF6, 0xE7, 0xDE, 0x3D, 0xF0, 0x19, 0x77 + }, + { + 0x27, 0xC5, 0x70, 0x2B, 0xE1, 0x04, 0xB3, 0xA9, + 0x4F, 0xC4, 0x34, 0x23, 0xAE, 0xEE, 0x83, 0xAC, + 0x3C, 0xA7, 0x3B, 0x7F, 0x87, 0x83, 0x9A, 0x6B, + 0x2E, 0x29, 0x60, 0x79, 0x03, 0xB7, 0xF2, 0x87 + }, + { + 0x81, 0xD2, 0xE1, 0x2E, 0xB2, 0xF4, 0x27, 0x60, + 0xC6, 0xE3, 0xBA, 0xA7, 0x8F, 0x84, 0x07, 0x3A, + 0xE6, 0xF5, 0x61, 0x60, 0x70, 0xFE, 0x25, 0xBE, + 0xDE, 0x7C, 0x7C, 0x82, 0x48, 0xAB, 0x1F, 0xBA + }, + { + 0xFA, 0xB2, 0x35, 0xD5, 0x93, 0x48, 0xAB, 0x8C, + 0xE4, 0x9B, 0xEC, 0x77, 0xC0, 0xF1, 0x93, 0x28, + 0xFD, 0x04, 0x5D, 0xFD, 0x60, 0x8A, 0x53, 0x03, + 0x36, 0xDF, 0x4F, 0x94, 0xE1, 0x72, 0xA5, 0xC8 + }, + { + 0x8A, 0xAA, 0x8D, 0x80, 0x5C, 0x58, 0x88, 0x1F, + 0xF3, 0x79, 0xFB, 0xD4, 0x2C, 0x6B, 0xF6, 0xF1, + 0x4C, 0x6C, 0x73, 0xDF, 0x80, 0x71, 0xB3, 0xB2, + 0x28, 0x98, 0x11, 0x09, 0xCC, 0xC0, 0x15, 0xF9 + }, + { + 0x91, 0xFD, 0xD2, 0x62, 0x20, 0x39, 0x16, 0x39, + 0x47, 0x40, 0x95, 0x2B, 0xCE, 0x72, 0xB6, 0x4B, + 0xAB, 0xB6, 0xF7, 0x21, 0x34, 0x4D, 0xEE, 0x82, + 0x50, 0xBF, 0x0E, 0x46, 0xF1, 0xBA, 0x18, 0x8F + }, + { + 0xF7, 0xE5, 0x7B, 0x8F, 0x85, 0xF4, 0x7D, 0x59, + 0x03, 0xAD, 0x4C, 0xCB, 0x8A, 0xF6, 0x2A, 0x3E, + 0x85, 0x8A, 0xAB, 0x2B, 0x8C, 0xC2, 0x26, 0x49, + 0x4F, 0x7B, 0x00, 0xBE, 0xDB, 0xF5, 0xB0, 0xD0 + }, + { + 0xF7, 0x6F, 0x21, 0xAD, 0xDA, 0xE9, 0x6A, 0x96, + 0x46, 0xFC, 0x06, 0xF9, 0xBF, 0x52, 0xAE, 0x08, + 0x48, 0xF1, 0x8C, 0x35, 0x26, 0xB1, 0x29, 0xE1, + 0x5B, 0x2C, 0x35, 0x5E, 0x2E, 0x79, 0xE5, 0xDA + }, + { + 0x8A, 0xEB, 0x1C, 0x79, 0x5F, 0x34, 0x90, 0x01, + 0x5E, 0xF4, 0xCD, 0x61, 0xA2, 0x80, 0x7B, 0x23, + 0x0E, 0xFD, 0xC8, 0x46, 0x01, 0x73, 0xDA, 0xD0, + 0x26, 0xA4, 0xA0, 0xFC, 0xC2, 0xFB, 0xF2, 0x2A + }, + { + 0xC5, 0x64, 0xFF, 0xC6, 0x23, 0x07, 0x77, 0x65, + 0xBB, 0x97, 0x87, 0x58, 0x56, 0x54, 0xCE, 0x74, + 0x5D, 0xBD, 0x10, 0x8C, 0xEF, 0x24, 0x8A, 0xB0, + 0x0A, 0xD1, 0xA2, 0x64, 0x7D, 0x99, 0x03, 0x87 + }, + { + 0xFE, 0x89, 0x42, 0xA3, 0xE5, 0xF5, 0xE8, 0xCD, + 0x70, 0x51, 0x04, 0xF8, 0x82, 0x10, 0x72, 0x6E, + 0x53, 0xDD, 0x7E, 0xB3, 0xF9, 0xA2, 0x02, 0xBF, + 0x93, 0x14, 0xB3, 0xB9, 0x06, 0x5E, 0xB7, 0x12 + }, + { + 0xDC, 0x29, 0x53, 0x59, 0xD4, 0x36, 0xEE, 0xA7, + 0x80, 0x84, 0xE7, 0xB0, 0x77, 0xFE, 0x09, 0xB1, + 0x9C, 0x5B, 0xF3, 0xD2, 0xA7, 0x96, 0xDA, 0xB0, + 0x19, 0xE4, 0x20, 0x05, 0x99, 0xFD, 0x82, 0x02 + }, + { + 0x70, 0xB3, 0xF7, 0x2F, 0x74, 0x90, 0x32, 0xE2, + 0x5E, 0x38, 0x3B, 0x96, 0x43, 0x78, 0xEA, 0x1C, + 0x54, 0x3E, 0x9C, 0x15, 0xDE, 0x3A, 0x27, 0xD8, + 0x6D, 0x2A, 0x9D, 0x22, 0x31, 0xEF, 0xF4, 0x8A + }, + { + 0x79, 0x82, 0xB5, 0x4C, 0x08, 0xDB, 0x2B, 0xFB, + 0x6F, 0x45, 0xF3, 0x5B, 0xC3, 0x23, 0xBC, 0x09, + 0x37, 0x79, 0xB6, 0xBB, 0x0E, 0x3E, 0xEA, 0x3E, + 0x8C, 0x98, 0xB1, 0xDE, 0x99, 0xD3, 0xC5, 0x5E + }, + { + 0x75, 0xE4, 0x16, 0x22, 0x57, 0x01, 0x4B, 0xED, + 0xCC, 0x05, 0xC2, 0x94, 0x4D, 0xCE, 0x0D, 0xF0, + 0xC3, 0x5E, 0xBA, 0x13, 0x19, 0x54, 0x06, 0x4F, + 0x6E, 0x4E, 0x09, 0x5F, 0xD0, 0x84, 0x45, 0xEE + }, + { + 0x4A, 0x12, 0x9E, 0xA6, 0xCD, 0xBA, 0xBC, 0x2D, + 0x39, 0x24, 0x79, 0x37, 0x2F, 0x97, 0x5B, 0x9C, + 0xF5, 0xA1, 0xB7, 0xDE, 0xB6, 0x9A, 0x32, 0x66, + 0xF0, 0x3E, 0xBC, 0x6D, 0x11, 0x13, 0x93, 0xC4 + }, + { + 0x8F, 0xED, 0x70, 0xF2, 0x79, 0x55, 0xDC, 0x8A, + 0xD9, 0xF1, 0xB7, 0xB3, 0xF6, 0xF5, 0xDF, 0xBD, + 0x96, 0x2A, 0x33, 0x59, 0x2B, 0x42, 0xDE, 0x85, + 0x6D, 0x42, 0x1E, 0x29, 0x12, 0xBA, 0xB8, 0x6B + }, + { + 0xE2, 0xF2, 0x06, 0x60, 0x37, 0x6F, 0x2B, 0x18, + 0x39, 0x66, 0x7C, 0xBF, 0xE5, 0xE1, 0x6E, 0xF0, + 0x75, 0xAC, 0x39, 0x43, 0x64, 0x4F, 0x35, 0x32, + 0x28, 0x2F, 0x8B, 0xB0, 0x72, 0x3B, 0x99, 0x86 + }, + { + 0xAB, 0xF8, 0x4C, 0x91, 0x3A, 0x83, 0xDF, 0x98, + 0xC7, 0x00, 0x29, 0x81, 0x9C, 0x06, 0x5F, 0x6D, + 0x6D, 0xE4, 0xF6, 0xD4, 0x3A, 0xBF, 0x60, 0x0D, + 0xAD, 0xE0, 0x35, 0xB2, 0x3B, 0xED, 0x7B, 0xAA + }, + { + 0x45, 0x9C, 0x15, 0xD4, 0x85, 0x6C, 0x7E, 0xCF, + 0x82, 0x62, 0x03, 0x51, 0xC3, 0xC1, 0xC7, 0x6C, + 0x40, 0x3F, 0x3E, 0x97, 0x07, 0x74, 0x13, 0x87, + 0xE2, 0x99, 0x07, 0x3F, 0xB1, 0x70, 0x4B, 0x2B + }, + { + 0x9A, 0xB9, 0x12, 0xED, 0xA0, 0x76, 0x8A, 0xBD, + 0xF8, 0x26, 0xB6, 0xE0, 0x5D, 0x0D, 0x73, 0x58, + 0x39, 0xE6, 0xA5, 0xF0, 0x2E, 0x04, 0xC4, 0xCC, + 0x75, 0x65, 0x0B, 0x2C, 0x8C, 0xAB, 0x67, 0x49 + }, + { + 0x47, 0x40, 0xEB, 0xEC, 0xAC, 0x90, 0x03, 0x1B, + 0xB7, 0xE6, 0x8E, 0x51, 0xC5, 0x53, 0x91, 0xAF, + 0xB1, 0x89, 0xB3, 0x17, 0xF2, 0xDE, 0x55, 0x87, + 0x66, 0xF7, 0x8F, 0x5C, 0xB7, 0x1F, 0x81, 0xB6 + }, + { + 0x3C, 0xC4, 0x7F, 0x0E, 0xF6, 0x48, 0x21, 0x58, + 0x7C, 0x93, 0x7C, 0xDD, 0xBA, 0x85, 0xC9, 0x93, + 0xD3, 0xCE, 0x2D, 0xD0, 0xCE, 0xD4, 0x0D, 0x3B, + 0xE3, 0x3C, 0xB7, 0xDC, 0x7E, 0xDA, 0xBC, 0xF1 + }, + { + 0x9F, 0x47, 0x6A, 0x22, 0xDB, 0x54, 0xD6, 0xBB, + 0x9B, 0xEF, 0xDB, 0x26, 0x0C, 0x66, 0x57, 0x8A, + 0xE1, 0xD8, 0xA5, 0xF8, 0x7D, 0x3D, 0x8C, 0x01, + 0x7F, 0xDB, 0x74, 0x75, 0x08, 0x0F, 0xA8, 0xE1 + }, + { + 0x8B, 0x68, 0xC6, 0xFB, 0x07, 0x06, 0xA7, 0x95, + 0xF3, 0xA8, 0x39, 0xD6, 0xFE, 0x25, 0xFD, 0x4A, + 0xA7, 0xF9, 0x2E, 0x66, 0x4F, 0x76, 0x2D, 0x61, + 0x53, 0x81, 0xBC, 0x85, 0x9A, 0xFA, 0x29, 0x2C + }, + { + 0xF6, 0x40, 0xD2, 0x25, 0xA6, 0xBC, 0xD2, 0xFC, + 0x8A, 0xCC, 0xAF, 0xBE, 0xD5, 0xA8, 0x4B, 0x5B, + 0xBB, 0x5D, 0x8A, 0xE5, 0xDB, 0x06, 0xA1, 0x0B, + 0x6D, 0x9D, 0x93, 0x16, 0x0B, 0x39, 0x2E, 0xE0 + }, + { + 0x70, 0x48, 0x60, 0xA7, 0xF5, 0xBA, 0x68, 0xDB, + 0x27, 0x03, 0x1C, 0x15, 0xF2, 0x25, 0x50, 0x0D, + 0x69, 0x2A, 0xB2, 0x47, 0x53, 0x42, 0x81, 0xC4, + 0xF6, 0x84, 0xF6, 0xC6, 0xC8, 0xCD, 0x88, 0xC7 + }, + { + 0xC1, 0xA7, 0x5B, 0xDD, 0xA1, 0x2B, 0x8B, 0x2A, + 0xB1, 0xB9, 0x24, 0x84, 0x38, 0x58, 0x18, 0x3A, + 0x09, 0xD2, 0x02, 0x42, 0x1F, 0xDB, 0xCD, 0xF0, + 0xE6, 0x3E, 0xAE, 0x46, 0xF3, 0x7D, 0x91, 0xED + }, + { + 0x9A, 0x8C, 0xAB, 0x7A, 0x5F, 0x2E, 0x57, 0x62, + 0x21, 0xA6, 0xA8, 0x5E, 0x5F, 0xDD, 0xEE, 0x75, + 0x67, 0x8E, 0x06, 0x53, 0x24, 0xA6, 0x1D, 0xB0, + 0x3A, 0x39, 0x26, 0x1D, 0xDF, 0x75, 0xE3, 0xF4 + }, + { + 0x05, 0xC2, 0xB2, 0x6B, 0x03, 0xCE, 0x6C, 0xA5, + 0x87, 0x1B, 0xE0, 0xDE, 0x84, 0xEE, 0x27, 0x86, + 0xA7, 0x9B, 0xCD, 0x9F, 0x30, 0x03, 0x3E, 0x81, + 0x9B, 0x4A, 0x87, 0xCC, 0xA2, 0x7A, 0xFC, 0x6A + }, + { + 0xB0, 0xB0, 0x99, 0x3C, 0x6D, 0x0C, 0x6E, 0xD5, + 0xC3, 0x59, 0x04, 0x80, 0xF8, 0x65, 0xF4, 0x67, + 0xF4, 0x33, 0x1A, 0x58, 0xDD, 0x8E, 0x47, 0xBD, + 0x98, 0xEB, 0xBC, 0xDB, 0x8E, 0xB4, 0xF9, 0x4D + }, + { + 0xE5, 0x7C, 0x10, 0x3C, 0xF7, 0xB6, 0xBB, 0xEB, + 0x8A, 0x0D, 0xC8, 0xF0, 0x48, 0x62, 0x5C, 0x3F, + 0x4C, 0xE4, 0xF1, 0xA5, 0xAD, 0x4D, 0x07, 0x9C, + 0x11, 0x87, 0xBF, 0xE9, 0xEE, 0x3B, 0x8A, 0x5F + }, + { + 0xF1, 0x00, 0x23, 0xE1, 0x5F, 0x3B, 0x72, 0xB7, + 0x38, 0xAD, 0x61, 0xAE, 0x65, 0xAB, 0x9A, 0x07, + 0xE7, 0x77, 0x4E, 0x2D, 0x7A, 0xB0, 0x2D, 0xBA, + 0x4E, 0x0C, 0xAF, 0x56, 0x02, 0xC8, 0x01, 0x78 + }, + { + 0x9A, 0x8F, 0xB3, 0xB5, 0x38, 0xC1, 0xD6, 0xC4, + 0x50, 0x51, 0xFA, 0x9E, 0xD9, 0xB0, 0x7D, 0x3E, + 0x89, 0xB4, 0x43, 0x03, 0x30, 0x01, 0x4A, 0x1E, + 0xFA, 0x28, 0x23, 0xC0, 0x82, 0x3C, 0xF2, 0x37 + }, + { + 0x30, 0x75, 0xC5, 0xBC, 0x7C, 0x3A, 0xD7, 0xE3, + 0x92, 0x01, 0x01, 0xBC, 0x68, 0x99, 0xC5, 0x8E, + 0xA7, 0x01, 0x67, 0xA7, 0x77, 0x2C, 0xA2, 0x8E, + 0x38, 0xE2, 0xC1, 0xB0, 0xD3, 0x25, 0xE5, 0xA0 + }, + { + 0xE8, 0x55, 0x94, 0x70, 0x0E, 0x39, 0x22, 0xA1, + 0xE8, 0xE4, 0x1E, 0xB8, 0xB0, 0x64, 0xE7, 0xAC, + 0x6D, 0x94, 0x9D, 0x13, 0xB5, 0xA3, 0x45, 0x23, + 0xE5, 0xA6, 0xBE, 0xAC, 0x03, 0xC8, 0xAB, 0x29 + }, + { + 0x1D, 0x37, 0x01, 0xA5, 0x66, 0x1B, 0xD3, 0x1A, + 0xB2, 0x05, 0x62, 0xBD, 0x07, 0xB7, 0x4D, 0xD1, + 0x9A, 0xC8, 0xF3, 0x52, 0x4B, 0x73, 0xCE, 0x7B, + 0xC9, 0x96, 0xB7, 0x88, 0xAF, 0xD2, 0xF3, 0x17 + }, + { + 0x87, 0x4E, 0x19, 0x38, 0x03, 0x3D, 0x7D, 0x38, + 0x35, 0x97, 0xA2, 0xA6, 0x5F, 0x58, 0xB5, 0x54, + 0xE4, 0x11, 0x06, 0xF6, 0xD1, 0xD5, 0x0E, 0x9B, + 0xA0, 0xEB, 0x68, 0x5F, 0x6B, 0x6D, 0xA0, 0x71 + }, + { + 0x93, 0xF2, 0xF3, 0xD6, 0x9B, 0x2D, 0x36, 0x52, + 0x95, 0x56, 0xEC, 0xCA, 0xF9, 0xF9, 0x9A, 0xDB, + 0xE8, 0x95, 0xE1, 0x57, 0x22, 0x31, 0xE6, 0x49, + 0xB5, 0x05, 0x84, 0xB5, 0xD7, 0xD0, 0x8A, 0xF8 + }, + { + 0x06, 0xE0, 0x6D, 0x61, 0x0F, 0x2E, 0xEB, 0xBA, + 0x36, 0x76, 0x82, 0x3E, 0x77, 0x44, 0xD7, 0x51, + 0xAF, 0xF7, 0x30, 0x76, 0xED, 0x65, 0xF3, 0xCF, + 0xF5, 0xE7, 0x2F, 0xD2, 0x27, 0x99, 0x9C, 0x77 + }, + { + 0x8D, 0xF7, 0x57, 0xB3, 0xA1, 0xE0, 0xF4, 0x80, + 0xFA, 0x76, 0xC7, 0xF3, 0x58, 0xED, 0x03, 0x98, + 0xBE, 0x3F, 0x2A, 0x8F, 0x7B, 0x90, 0xEA, 0x8C, + 0x80, 0x75, 0x99, 0xDE, 0xDA, 0x1D, 0x05, 0x34 + }, + { + 0xEE, 0xC9, 0xC5, 0xC6, 0x3C, 0xC5, 0x16, 0x9D, + 0x96, 0x7B, 0xB1, 0x62, 0x4E, 0x9E, 0xE5, 0xCE, + 0xD9, 0x28, 0x97, 0x73, 0x6E, 0xFB, 0xD1, 0x57, + 0x54, 0x8D, 0x82, 0xE8, 0x7C, 0xC7, 0x2F, 0x25 + }, + { + 0xCC, 0x2B, 0x58, 0x32, 0xAD, 0x27, 0x2C, 0xC5, + 0x5C, 0x10, 0xD4, 0xF8, 0xC7, 0xF8, 0xBB, 0x38, + 0xE6, 0xE4, 0xEB, 0x92, 0x2F, 0x93, 0x86, 0x83, + 0x0F, 0x90, 0xB1, 0xE3, 0xDA, 0x39, 0x37, 0xD5 + }, + { + 0x36, 0x89, 0x85, 0xD5, 0x38, 0x7C, 0x0B, 0xFC, + 0x92, 0x8A, 0xC2, 0x54, 0xFA, 0x6D, 0x16, 0x67, + 0x3E, 0x70, 0x94, 0x75, 0x66, 0x96, 0x1B, 0x5F, + 0xB3, 0x32, 0x5A, 0x58, 0x8A, 0xB3, 0x17, 0x3A + }, + { + 0xF1, 0xE4, 0x42, 0xAF, 0xB8, 0x72, 0x15, 0x1F, + 0x81, 0x34, 0x95, 0x6C, 0x54, 0x8A, 0xE3, 0x24, + 0x0D, 0x07, 0xE6, 0xE3, 0x38, 0xD4, 0xA7, 0xA6, + 0xAF, 0x8D, 0xA4, 0x11, 0x9A, 0xB0, 0xE2, 0xB0 + }, + { + 0xB0, 0x12, 0xC7, 0x54, 0x6A, 0x39, 0xC4, 0x0C, + 0xAD, 0xEC, 0xE4, 0xE0, 0x4E, 0x7F, 0x33, 0xC5, + 0x93, 0xAD, 0x18, 0x2E, 0xBC, 0x5A, 0x46, 0xD2, + 0xDB, 0xF4, 0xAD, 0x1A, 0x92, 0xF5, 0x9E, 0x7B + }, + { + 0x6C, 0x60, 0x97, 0xCD, 0x20, 0x33, 0x09, 0x6B, + 0x4D, 0xF3, 0x17, 0xDE, 0x8A, 0x90, 0x8B, 0x7D, + 0x0C, 0x72, 0x94, 0x39, 0x0C, 0x5A, 0x39, 0x9C, + 0x30, 0x1B, 0xF2, 0xA2, 0x65, 0x2E, 0x82, 0x62 + }, + { + 0xBA, 0x83, 0xFE, 0xB5, 0x10, 0xB4, 0x9A, 0xDE, + 0x4F, 0xAE, 0xFB, 0xE9, 0x42, 0x78, 0x1E, 0xAF, + 0xD4, 0x1A, 0xD5, 0xD4, 0x36, 0x88, 0x85, 0x31, + 0xB6, 0x88, 0x59, 0xF2, 0x2C, 0x2D, 0x16, 0x4A + }, + { + 0x5A, 0x06, 0x9E, 0x43, 0x92, 0x19, 0x5A, 0xC9, + 0xD2, 0x84, 0xA4, 0x7F, 0x3B, 0xD8, 0x54, 0xAF, + 0x8F, 0xD0, 0xD7, 0xFD, 0xC3, 0x48, 0x3D, 0x2C, + 0x5F, 0x34, 0x24, 0xCC, 0xFD, 0xA1, 0x5C, 0x8E + }, + { + 0x7E, 0x88, 0xD6, 0x4B, 0xBB, 0xE2, 0x02, 0x4F, + 0x44, 0x54, 0xBA, 0x13, 0x98, 0xB3, 0xD8, 0x65, + 0x2D, 0xCE, 0xC8, 0x20, 0xB1, 0x4C, 0x3B, 0x0A, + 0xBF, 0xBF, 0x0F, 0x4F, 0x33, 0x06, 0xBB, 0x5E + }, + { + 0xF8, 0x74, 0x2F, 0xF4, 0x6D, 0xFD, 0xF3, 0xEC, + 0x82, 0x64, 0xF9, 0x94, 0x5B, 0x20, 0x41, 0x94, + 0x62, 0xF0, 0x69, 0xE8, 0x33, 0xC5, 0x94, 0xEC, + 0x80, 0xFF, 0xAC, 0x5E, 0x7E, 0x51, 0x34, 0xF9 + }, + { + 0xD3, 0xE0, 0xB7, 0x38, 0xD2, 0xE9, 0x2F, 0x3C, + 0x47, 0xC7, 0x94, 0x66, 0x66, 0x09, 0xC0, 0xF5, + 0x50, 0x4F, 0x67, 0xEC, 0x4E, 0x76, 0x0E, 0xEE, + 0xCC, 0xF8, 0x64, 0x4E, 0x68, 0x33, 0x34, 0x11 + }, + { + 0x0C, 0x90, 0xCE, 0x10, 0xED, 0xF0, 0xCE, 0x1D, + 0x47, 0xEE, 0xB5, 0x0B, 0x5B, 0x7A, 0xFF, 0x8E, + 0xE8, 0xA4, 0x3B, 0x64, 0xA8, 0x89, 0xC1, 0xC6, + 0xC6, 0xB8, 0xE3, 0x1A, 0x3C, 0xFC, 0x45, 0xEE + }, + { + 0x83, 0x91, 0x7A, 0xC1, 0xCD, 0xAD, 0xE8, 0xF0, + 0xE3, 0xBF, 0x42, 0x6F, 0xEA, 0xC1, 0x38, 0x8B, + 0x3F, 0xCB, 0xE3, 0xE1, 0xBF, 0x98, 0x79, 0x8C, + 0x81, 0x58, 0xBF, 0x75, 0x8E, 0x8D, 0x5D, 0x4E + }, + { + 0xDC, 0x8E, 0xB0, 0xC0, 0x13, 0xFA, 0x9D, 0x06, + 0x4E, 0xE3, 0x76, 0x23, 0x36, 0x9F, 0xB3, 0x94, + 0xAF, 0x97, 0x4B, 0x1A, 0xAC, 0x82, 0x40, 0x5B, + 0x88, 0x97, 0x6C, 0xD8, 0xFC, 0xA1, 0x25, 0x30 + }, + { + 0x9A, 0xF4, 0xFC, 0x92, 0xEA, 0x8D, 0x6B, 0x5F, + 0xE7, 0x99, 0x0E, 0x3A, 0x02, 0x70, 0x1E, 0xC2, + 0x2B, 0x2D, 0xFD, 0x71, 0x00, 0xB9, 0x0D, 0x05, + 0x51, 0x86, 0x94, 0x17, 0x95, 0x5E, 0x44, 0xC8 + }, + { + 0xC7, 0x22, 0xCE, 0xC1, 0x31, 0xBA, 0xA1, 0x63, + 0xF4, 0x7E, 0x4B, 0x33, 0x9E, 0x1F, 0xB9, 0xB4, + 0xAC, 0xA2, 0x48, 0xC4, 0x75, 0x93, 0x45, 0xEA, + 0xDB, 0xD6, 0xC6, 0xA7, 0xDD, 0xB5, 0x04, 0x77 + }, + { + 0x18, 0x37, 0xB1, 0x20, 0xD4, 0xE4, 0x04, 0x6C, + 0x6D, 0xE8, 0xCC, 0xAF, 0x09, 0xF1, 0xCA, 0xF3, + 0x02, 0xAD, 0x56, 0x23, 0x4E, 0x6B, 0x42, 0x2C, + 0xE9, 0x0A, 0x61, 0xBF, 0x06, 0xAE, 0xE4, 0x3D + }, + { + 0x87, 0xAC, 0x9D, 0x0F, 0x8A, 0x0B, 0x11, 0xBF, + 0xED, 0xD6, 0x99, 0x1A, 0x6D, 0xAF, 0x34, 0xC8, + 0xAA, 0x5D, 0x7E, 0x8A, 0xE1, 0xB9, 0xDF, 0x4A, + 0xF7, 0x38, 0x00, 0x5F, 0xE7, 0x8C, 0xE9, 0x3C + }, + { + 0xE2, 0x1F, 0xB6, 0x68, 0xEB, 0xB8, 0xBF, 0x2D, + 0x82, 0x08, 0x6D, 0xED, 0xCB, 0x3A, 0x53, 0x71, + 0xC2, 0xC4, 0x6F, 0xA1, 0xAC, 0x11, 0xD2, 0xE2, + 0xC5, 0x66, 0xD1, 0x4A, 0xD3, 0xC3, 0x65, 0x3F + }, + { + 0x5A, 0x9A, 0x69, 0x81, 0x5E, 0x4D, 0x3E, 0xB7, + 0x72, 0xED, 0x90, 0x8F, 0xE6, 0x58, 0xCE, 0x50, + 0x87, 0x31, 0x0E, 0xC1, 0xD5, 0x0C, 0xB9, 0x4F, + 0x56, 0x28, 0x33, 0x9A, 0x61, 0xDC, 0xD9, 0xEE + }, + { + 0xAA, 0xC2, 0x85, 0xF1, 0x20, 0x8F, 0x70, 0xA6, + 0x47, 0x97, 0xD0, 0xA9, 0x40, 0x0D, 0xA6, 0x46, + 0x53, 0x30, 0x18, 0x38, 0xFE, 0xF6, 0x69, 0x0B, + 0x87, 0xCD, 0xA9, 0x15, 0x9E, 0xE0, 0x7E, 0xF4 + }, + { + 0x05, 0x64, 0x3C, 0x1C, 0x6F, 0x26, 0x59, 0x25, + 0xA6, 0x50, 0x93, 0xF9, 0xDE, 0x8A, 0x19, 0x1C, + 0x4F, 0x6F, 0xD1, 0x41, 0x8F, 0xBF, 0x66, 0xBE, + 0x80, 0x59, 0xA9, 0x1B, 0xA8, 0xDC, 0xDA, 0x61 + }, + { + 0x1C, 0x6C, 0xDE, 0x5B, 0x78, 0x10, 0x3C, 0x9E, + 0x6F, 0x04, 0x6D, 0xFE, 0x30, 0xF5, 0x12, 0x1C, + 0xF9, 0xD4, 0x03, 0x9E, 0xFE, 0x22, 0x25, 0x40, + 0xA4, 0x1B, 0xBC, 0x06, 0xE4, 0x69, 0xFE, 0xB6 + }, + { + 0xB4, 0x9B, 0xB4, 0x6D, 0x1B, 0x19, 0x3B, 0x04, + 0x5E, 0x74, 0x12, 0x05, 0x9F, 0xE7, 0x2D, 0x55, + 0x25, 0x52, 0xA8, 0xFB, 0x6C, 0x36, 0x41, 0x07, + 0x23, 0xDC, 0x7D, 0x05, 0xFC, 0xCE, 0xDE, 0xD3 + }, + { + 0xB6, 0x12, 0xD3, 0xD2, 0x1F, 0xC4, 0xDE, 0x3C, + 0x79, 0x1A, 0xF7, 0x35, 0xE5, 0x9F, 0xB7, 0x17, + 0xD8, 0x39, 0x72, 0x3B, 0x42, 0x50, 0x8E, 0x9E, + 0xBF, 0x78, 0x06, 0xD9, 0x3E, 0x9C, 0x83, 0x7F + }, + { + 0x7C, 0x33, 0x90, 0xA3, 0xE5, 0xCB, 0x27, 0xD1, + 0x86, 0x8B, 0xA4, 0x55, 0xCF, 0xEB, 0x32, 0x22, + 0xFD, 0xE2, 0x7B, 0xCD, 0xA4, 0xBF, 0x24, 0x8E, + 0x3D, 0x29, 0xCF, 0x1F, 0x34, 0x32, 0x9F, 0x25 + }, + { + 0xBD, 0x42, 0xEE, 0xA7, 0xB3, 0x54, 0x86, 0xCD, + 0xD0, 0x90, 0x7C, 0xB4, 0x71, 0x2E, 0xDE, 0x2F, + 0x4D, 0xEE, 0xCC, 0xBC, 0xA1, 0x91, 0x60, 0x38, + 0x65, 0xA1, 0xCC, 0x80, 0x9F, 0x12, 0xB4, 0x46 + }, + { + 0xD1, 0xDD, 0x62, 0x01, 0x74, 0x0C, 0xFA, 0xAD, + 0x53, 0xCE, 0xCC, 0xB7, 0x56, 0xB1, 0x10, 0xF3, + 0xD5, 0x0F, 0x81, 0x7B, 0x43, 0xD7, 0x55, 0x95, + 0x57, 0xE5, 0x7A, 0xAD, 0x14, 0x3A, 0x85, 0xD9 + }, + { + 0x58, 0x29, 0x64, 0x3C, 0x1B, 0x10, 0xE1, 0xC8, + 0xCC, 0xF2, 0x0C, 0x9B, 0x4A, 0xF8, 0x21, 0xEA, + 0x05, 0x2D, 0x7F, 0x0F, 0x7C, 0x22, 0xF7, 0x38, + 0x0B, 0xBB, 0xCF, 0xAF, 0xB9, 0x77, 0xE2, 0x1F + }, + { + 0xFC, 0x4C, 0xF2, 0xA7, 0xFB, 0xE0, 0xB1, 0xE8, + 0xAE, 0xFB, 0xE4, 0xB4, 0xB7, 0x9E, 0xD8, 0x4E, + 0xC9, 0x7B, 0x03, 0x4F, 0x51, 0xB4, 0xE9, 0x7F, + 0x76, 0x0B, 0x20, 0x63, 0x97, 0x65, 0xB9, 0x33 + }, + { + 0x4D, 0x7C, 0x3B, 0x34, 0x38, 0xA0, 0xBD, 0xA2, + 0x8E, 0x7A, 0x96, 0xE4, 0x20, 0x27, 0xD8, 0x13, + 0xE8, 0x8A, 0xE6, 0x28, 0x85, 0x49, 0x98, 0x33, + 0xD3, 0xC5, 0xF6, 0x35, 0x9E, 0xF7, 0xED, 0xBC + }, + { + 0x34, 0xCB, 0xD3, 0x20, 0x68, 0xEF, 0x7E, 0x82, + 0x09, 0x9E, 0x58, 0x0B, 0xF9, 0xE2, 0x64, 0x23, + 0xE9, 0x81, 0xE3, 0x1B, 0x1B, 0xBC, 0xE6, 0x1A, + 0xEA, 0xB1, 0x4C, 0x32, 0xA2, 0x73, 0xE4, 0xCB + }, + { + 0xA0, 0x5D, 0xDA, 0x7D, 0x0D, 0xA9, 0xE0, 0x94, + 0xAE, 0x22, 0x53, 0x3F, 0x79, 0xE7, 0xDC, 0xCD, + 0x26, 0xB1, 0x75, 0x7C, 0xEF, 0xB9, 0x5B, 0xCF, + 0x62, 0xC4, 0xFF, 0x9C, 0x26, 0x92, 0xE1, 0xC0 + }, + { + 0x22, 0x4C, 0xCF, 0xFA, 0x7C, 0xCA, 0x4C, 0xE3, + 0x4A, 0xFD, 0x47, 0xF6, 0x2A, 0xDE, 0x53, 0xC5, + 0xE8, 0x48, 0x9B, 0x04, 0xAC, 0x9C, 0x41, 0xF7, + 0xFA, 0xD0, 0xC8, 0xED, 0xEB, 0x89, 0xE9, 0x41 + }, + { + 0x6B, 0xC6, 0x07, 0x64, 0x83, 0xAA, 0x11, 0xC0, + 0x7F, 0xBA, 0x55, 0xC0, 0xF9, 0xA1, 0xB5, 0xDA, + 0x87, 0xEC, 0xBF, 0xFE, 0xA7, 0x55, 0x98, 0xCC, + 0x31, 0x8A, 0x51, 0x4C, 0xEC, 0x7B, 0x3B, 0x6A + }, + { + 0x9A, 0x03, 0x60, 0xE2, 0x3A, 0x22, 0xF4, 0xF7, + 0x6C, 0x0E, 0x95, 0x28, 0xDA, 0xFD, 0x12, 0x9B, + 0xB4, 0x67, 0x5F, 0xB8, 0x8D, 0x44, 0xEA, 0xF8, + 0x57, 0x77, 0x30, 0x0C, 0xEC, 0x9B, 0xCC, 0x79 + }, + { + 0x79, 0x01, 0x99, 0xB4, 0xCA, 0x90, 0xDE, 0xDC, + 0xCF, 0xE3, 0x24, 0x74, 0xE8, 0x5B, 0x17, 0x4F, + 0x06, 0x9E, 0x35, 0x42, 0xBE, 0x31, 0x04, 0xC1, + 0x12, 0x5C, 0x2F, 0xDB, 0xD6, 0x9D, 0x32, 0xC7 + }, + { + 0x55, 0x83, 0x99, 0x25, 0x83, 0x4C, 0xA3, 0xE8, + 0x25, 0xE9, 0x92, 0x41, 0x87, 0x4D, 0x16, 0xD6, + 0xC2, 0x62, 0x36, 0x29, 0xC4, 0xC2, 0xAD, 0xDD, + 0xF0, 0xDB, 0xA0, 0x1E, 0x6C, 0xE8, 0xA0, 0xDC + }, + { + 0x61, 0x5F, 0xF8, 0x46, 0xD9, 0x93, 0x00, 0x7D, + 0x38, 0xDE, 0x1A, 0xEC, 0xB3, 0x17, 0x82, 0x89, + 0xDE, 0xD0, 0x9E, 0x6B, 0xB5, 0xCB, 0xD6, 0x0F, + 0x69, 0xC6, 0xAA, 0x36, 0x38, 0x30, 0x20, 0xF7 + }, + { + 0xF0, 0xE4, 0x0B, 0x4E, 0xD4, 0x0D, 0x34, 0x85, + 0x1E, 0x72, 0xB4, 0xEE, 0x4D, 0x00, 0xEA, 0x6A, + 0x40, 0xEA, 0x1C, 0x1B, 0xF9, 0xE5, 0xC2, 0x69, + 0x71, 0x0C, 0x9D, 0x51, 0xCB, 0xB8, 0xA3, 0xC9 + }, + { + 0x0B, 0x07, 0xB2, 0x33, 0x3B, 0x08, 0xD0, 0x8C, + 0x11, 0xCA, 0x34, 0xAB, 0x44, 0x9B, 0x71, 0xD2, + 0x9A, 0x0F, 0x43, 0xE1, 0xF7, 0x78, 0xE0, 0x73, + 0xE7, 0x90, 0x06, 0xCC, 0xB7, 0x30, 0xED, 0x62 + }, + { + 0xD1, 0xF4, 0xC2, 0x9D, 0x9F, 0x23, 0xEA, 0x35, + 0xEC, 0x40, 0x35, 0xB3, 0x77, 0xD5, 0x06, 0x53, + 0x8E, 0x72, 0x8B, 0xC7, 0x39, 0xC1, 0x45, 0x96, + 0x80, 0xCF, 0x1C, 0xC6, 0x94, 0x24, 0x92, 0x4D + }, + { + 0x12, 0x79, 0xCF, 0x6F, 0x66, 0x9F, 0x92, 0xF6, + 0xBF, 0xC2, 0x5D, 0x60, 0x5B, 0x94, 0x40, 0xC7, + 0xDC, 0xCB, 0xD2, 0x5D, 0xF2, 0x8D, 0xC7, 0x35, + 0x3A, 0xBC, 0x1C, 0x05, 0x30, 0x40, 0x5D, 0xC4 + }, + { + 0x1F, 0xA0, 0xAF, 0x00, 0x77, 0x5D, 0xC2, 0xCE, + 0x76, 0x50, 0x6D, 0x32, 0x80, 0xF4, 0x72, 0xD2, + 0xF6, 0xFF, 0x97, 0xA2, 0x15, 0x1F, 0xAA, 0x82, + 0x79, 0x42, 0xFE, 0xA4, 0x4A, 0xD0, 0xBA, 0x1F + }, + { + 0x3E, 0x1A, 0xD5, 0x4A, 0x5F, 0x83, 0x5B, 0x98, + 0x3B, 0xD2, 0xAA, 0xB0, 0xED, 0x2A, 0x4C, 0x0B, + 0xDD, 0x72, 0x16, 0x20, 0x9C, 0x36, 0xA7, 0x9E, + 0x9E, 0x2A, 0xAB, 0xB9, 0x9F, 0xAF, 0x35, 0x12 + }, + { + 0xC6, 0xED, 0x39, 0xE2, 0xD8, 0xB6, 0x36, 0xEC, + 0xCB, 0xA2, 0x45, 0xEF, 0x4E, 0x88, 0x64, 0xF4, + 0xCD, 0x94, 0x6B, 0xE2, 0x16, 0xB9, 0xBE, 0x48, + 0x30, 0x3E, 0x08, 0xB9, 0x2D, 0xD0, 0x94, 0x34 + }, + { + 0xE2, 0x47, 0x36, 0xC1, 0x3E, 0xCB, 0x9F, 0x36, + 0xA0, 0xD8, 0x29, 0xD4, 0x79, 0x8D, 0x76, 0x99, + 0xC1, 0x4C, 0xC6, 0x5B, 0x6D, 0xC4, 0x4E, 0xD6, + 0xF1, 0x0C, 0xD4, 0x85, 0x3D, 0x6E, 0x07, 0x57 + }, + { + 0x38, 0x9B, 0xE8, 0x80, 0x52, 0xA3, 0x81, 0x27, + 0x2C, 0x6D, 0xF7, 0x41, 0xA8, 0x8A, 0xD3, 0x49, + 0xB7, 0x12, 0x71, 0x84, 0x35, 0x48, 0x0A, 0x81, + 0x90, 0xB7, 0x04, 0x77, 0x1D, 0x2D, 0xE6, 0x37 + }, + { + 0x88, 0x9F, 0x2D, 0x57, 0x8A, 0x5D, 0xAE, 0xFD, + 0x34, 0x1C, 0x21, 0x09, 0x84, 0xE1, 0x26, 0xD1, + 0xD9, 0x6D, 0xA2, 0xDE, 0xE3, 0xC8, 0x1F, 0x7A, + 0x60, 0x80, 0xBF, 0x84, 0x56, 0x9B, 0x31, 0x14 + }, + { + 0xE9, 0x36, 0x09, 0x5B, 0x9B, 0x98, 0x2F, 0xFC, + 0x85, 0x6D, 0x2F, 0x52, 0x76, 0xA4, 0xE5, 0x29, + 0xEC, 0x73, 0x95, 0xDA, 0x31, 0x6D, 0x62, 0x87, + 0x02, 0xFB, 0x28, 0x1A, 0xDA, 0x6F, 0x38, 0x99 + }, + { + 0xEF, 0x89, 0xCE, 0x1D, 0x6F, 0x8B, 0x48, 0xEA, + 0x5C, 0xD6, 0xAE, 0xAB, 0x6A, 0x83, 0xD0, 0xCC, + 0x98, 0xC9, 0xA3, 0xA2, 0x07, 0xA1, 0x08, 0x57, + 0x32, 0xF0, 0x47, 0xD9, 0x40, 0x38, 0xC2, 0x88 + }, + { + 0xF9, 0x25, 0x01, 0x6D, 0x79, 0xF2, 0xAC, 0xA8, + 0xC4, 0x9E, 0xDF, 0xCD, 0x66, 0x21, 0xD5, 0xBE, + 0x3C, 0x8C, 0xEC, 0x61, 0xBD, 0x58, 0x71, 0xD8, + 0xC1, 0xD3, 0xA5, 0x65, 0xF3, 0x5E, 0x0C, 0x9F + }, + { + 0x63, 0xE8, 0x63, 0x4B, 0x75, 0x7A, 0x38, 0xF9, + 0x2B, 0x92, 0xFD, 0x23, 0x89, 0x3B, 0xA2, 0x99, + 0x85, 0x3A, 0x86, 0x13, 0x67, 0x9F, 0xDF, 0x7E, + 0x05, 0x11, 0x09, 0x5C, 0x0F, 0x04, 0x7B, 0xCA + }, + { + 0xCF, 0x2C, 0xCA, 0x07, 0x72, 0xB7, 0x05, 0xEB, + 0x57, 0xD2, 0x89, 0x43, 0xF8, 0x3D, 0x35, 0x3F, + 0xE2, 0x91, 0xE5, 0xB3, 0x77, 0x78, 0x0B, 0x37, + 0x4C, 0x8B, 0xA4, 0x66, 0x58, 0x30, 0xBE, 0x87 + }, + { + 0x46, 0xDF, 0x5B, 0x87, 0xC8, 0x0E, 0x7E, 0x40, + 0x74, 0xAE, 0xE6, 0x85, 0x59, 0x42, 0x47, 0x42, + 0x84, 0x5B, 0x9B, 0x35, 0x0F, 0x51, 0xBA, 0x55, + 0xB0, 0x74, 0xBB, 0xAE, 0x4C, 0x62, 0x6A, 0xAB + }, + { + 0x65, 0x8A, 0xA4, 0xF9, 0xD2, 0xBC, 0xBD, 0x4F, + 0x7F, 0x8E, 0xB6, 0x3E, 0x68, 0xF5, 0x36, 0x7E, + 0xDB, 0xC5, 0x00, 0xA0, 0xB1, 0xFB, 0xB4, 0x1E, + 0x9D, 0xF1, 0x41, 0xBC, 0xBA, 0x8F, 0xCD, 0x53 + }, + { + 0xEE, 0x80, 0x55, 0x50, 0x08, 0xA7, 0x16, 0x55, + 0xE0, 0x81, 0x09, 0x2B, 0xBA, 0x6F, 0x67, 0x0E, + 0xD9, 0x8A, 0xF9, 0xA0, 0x9F, 0xB5, 0xAF, 0xB9, + 0x4C, 0xBC, 0x5C, 0x75, 0x48, 0x14, 0xDB, 0x4F + }, + { + 0x2C, 0x5F, 0x9D, 0x04, 0x82, 0x20, 0xB0, 0x41, + 0xB6, 0xD4, 0x52, 0x4B, 0x44, 0x90, 0xCF, 0x8C, + 0x66, 0xFC, 0xB8, 0xE1, 0x4B, 0x0D, 0x64, 0x88, + 0x7A, 0xA1, 0xE4, 0x76, 0x1A, 0x60, 0x2B, 0x39 + }, + { + 0x44, 0xCB, 0x63, 0x11, 0xD0, 0x75, 0x0B, 0x7E, + 0x33, 0xF7, 0x33, 0x3A, 0xA7, 0x8A, 0xAC, 0xA9, + 0xC3, 0x4A, 0xD5, 0xF7, 0x9C, 0x1B, 0x15, 0x91, + 0xEC, 0x33, 0x95, 0x1E, 0x69, 0xC4, 0xC4, 0x61 + }, + { + 0x0C, 0x6C, 0xE3, 0x2A, 0x3E, 0xA0, 0x56, 0x12, + 0xC5, 0xF8, 0x09, 0x0F, 0x6A, 0x7E, 0x87, 0xF5, + 0xAB, 0x30, 0xE4, 0x1B, 0x70, 0x7D, 0xCB, 0xE5, + 0x41, 0x55, 0x62, 0x0A, 0xD7, 0x70, 0xA3, 0x40 + }, + { + 0xC6, 0x59, 0x38, 0xDD, 0x3A, 0x05, 0x3C, 0x72, + 0x9C, 0xF5, 0xB7, 0xC8, 0x9F, 0x39, 0x0B, 0xFE, + 0xBB, 0x51, 0x12, 0x76, 0x6B, 0xB0, 0x0A, 0xA5, + 0xFA, 0x31, 0x64, 0xDF, 0xDF, 0x3B, 0x56, 0x47 + }, + { + 0x7D, 0xE7, 0xF0, 0xD5, 0x9A, 0x90, 0x39, 0xAF, + 0xF3, 0xAA, 0xF3, 0x2C, 0x3E, 0xE5, 0x2E, 0x79, + 0x17, 0x53, 0x57, 0x29, 0x06, 0x21, 0x68, 0xD2, + 0x49, 0x0B, 0x6B, 0x6C, 0xE2, 0x44, 0xB3, 0x80 + }, + { + 0x89, 0x58, 0x98, 0xF5, 0x3A, 0x8F, 0x39, 0xE4, + 0x24, 0x10, 0xDA, 0x77, 0xB6, 0xC4, 0x81, 0x5B, + 0x0B, 0xB2, 0x39, 0x5E, 0x39, 0x22, 0xF5, 0xBE, + 0xD0, 0xE1, 0xFB, 0xF2, 0xA4, 0xC6, 0xDF, 0xEB + }, + { + 0xC9, 0x05, 0xA8, 0x49, 0x84, 0x34, 0x8A, 0x64, + 0xDB, 0x1F, 0x54, 0x20, 0x83, 0x74, 0x8A, 0xD9, + 0x0A, 0x4B, 0xAD, 0x98, 0x33, 0xCB, 0x6D, 0xA3, + 0x87, 0x29, 0x34, 0x31, 0xF1, 0x9E, 0x7C, 0x9C + }, + { + 0xED, 0x37, 0xD1, 0xA4, 0xD0, 0x6C, 0x90, 0xD1, + 0x95, 0x78, 0x48, 0x66, 0x7E, 0x95, 0x48, 0xFE, + 0xBB, 0x5D, 0x42, 0x3E, 0xAB, 0x4F, 0x56, 0x78, + 0x5C, 0xC4, 0xB5, 0x41, 0x6B, 0x78, 0x00, 0x08 + }, + { + 0x0B, 0xC6, 0x5D, 0x99, 0x97, 0xFB, 0x73, 0x4A, + 0x56, 0x1F, 0xB1, 0xE9, 0xF8, 0xC0, 0x95, 0x8A, + 0x02, 0xC7, 0xA4, 0xDB, 0xD0, 0x96, 0xEB, 0xEF, + 0x1A, 0x17, 0x51, 0xAE, 0xD9, 0x59, 0xEE, 0xD7 + }, + { + 0x7C, 0x5F, 0x43, 0x2E, 0xB8, 0xB7, 0x35, 0x2A, + 0x94, 0x94, 0xDE, 0xA4, 0xD5, 0x3C, 0x21, 0x38, + 0x70, 0x31, 0xCE, 0x70, 0xE8, 0x5D, 0x94, 0x08, + 0xFC, 0x6F, 0x8C, 0xD9, 0x8A, 0x6A, 0xAA, 0x1E + }, + { + 0xB8, 0xBF, 0x8E, 0x2C, 0x34, 0xE0, 0x33, 0x98, + 0x36, 0x39, 0x90, 0x9E, 0xAA, 0x37, 0x64, 0x0D, + 0x87, 0x7B, 0x04, 0x8F, 0xE2, 0x99, 0xB4, 0x70, + 0xAF, 0x2D, 0x0B, 0xA8, 0x2A, 0x5F, 0x14, 0xC0 + }, + { + 0x88, 0xA9, 0xDD, 0x13, 0xD5, 0xDA, 0xDB, 0xDE, + 0xE6, 0xBF, 0xF7, 0xEE, 0x1E, 0xF8, 0xC7, 0x1C, + 0xC1, 0x93, 0xAA, 0x4B, 0xF3, 0xE8, 0x4F, 0x8F, + 0xE8, 0x0C, 0xB0, 0x75, 0x68, 0x3C, 0x07, 0x79 + }, + { + 0x9A, 0xED, 0xB8, 0x87, 0x6D, 0xD2, 0x1C, 0x8C, + 0x84, 0xD2, 0xE7, 0x02, 0xA1, 0x36, 0x25, 0x98, + 0x04, 0x62, 0xF6, 0x8B, 0xF0, 0xA1, 0xB7, 0x25, + 0x4A, 0xD8, 0x06, 0xC3, 0x84, 0x03, 0xC9, 0xDE + }, + { + 0xD0, 0x97, 0x57, 0x3D, 0xF2, 0xD6, 0xB2, 0x48, + 0x9A, 0x47, 0x94, 0x84, 0x86, 0x98, 0x00, 0xA1, + 0xF8, 0x33, 0xEA, 0x16, 0x9E, 0xFF, 0x32, 0xAE, + 0x3C, 0xE6, 0x3A, 0x20, 0x79, 0x54, 0x8D, 0x78 + }, + { + 0xD1, 0x8F, 0x27, 0xA3, 0xE5, 0x55, 0xD7, 0xF9, + 0x1A, 0x00, 0x7C, 0x67, 0xAC, 0xEE, 0xDE, 0x39, + 0x1F, 0x75, 0xA6, 0x1F, 0xA4, 0x2A, 0x0B, 0x45, + 0x66, 0xEB, 0x58, 0x2C, 0xA0, 0x5E, 0xBC, 0xE7 + }, + { + 0xDF, 0x1D, 0xAA, 0x90, 0xB1, 0x70, 0x23, 0x13, + 0xE6, 0xA5, 0x90, 0x1C, 0x7A, 0xFC, 0x5E, 0xD9, + 0x65, 0x77, 0x17, 0xA7, 0x15, 0xFA, 0x53, 0xA4, + 0x18, 0x9E, 0xC1, 0xE5, 0xDF, 0x29, 0x3A, 0x68 + }, + { + 0x04, 0xE3, 0xA4, 0x96, 0xB6, 0x69, 0x96, 0xC6, + 0x6E, 0x32, 0x91, 0x9E, 0xD1, 0xF9, 0x4C, 0x36, + 0xEE, 0xBB, 0xF2, 0x40, 0x63, 0x3A, 0x2F, 0x73, + 0x98, 0x45, 0xF0, 0x29, 0x5D, 0x34, 0xAF, 0xBA + }, + { + 0x8C, 0x45, 0xD8, 0x8C, 0x4E, 0x9C, 0x9D, 0x0C, + 0x8C, 0x67, 0x7F, 0xE4, 0x8F, 0xA5, 0x44, 0x9B, + 0xA3, 0x01, 0x78, 0xD4, 0x0A, 0xF0, 0xF0, 0x21, + 0x79, 0x21, 0xC6, 0x2E, 0x4B, 0x60, 0xCD, 0xD3 + }, + { + 0xE1, 0x49, 0xA6, 0xB1, 0x3B, 0xDE, 0xDE, 0xA2, + 0xEE, 0xEE, 0x00, 0x9C, 0xE9, 0x44, 0x5E, 0x8D, + 0xCF, 0x76, 0xB7, 0x6E, 0x55, 0xA5, 0x01, 0xD8, + 0xF5, 0xB4, 0x3F, 0xF8, 0x96, 0x79, 0x6A, 0xD1 + }, + { + 0xA8, 0x37, 0xC4, 0xC7, 0xC6, 0xF5, 0xCF, 0xB9, + 0x9E, 0x10, 0x85, 0xFD, 0x43, 0x28, 0x7A, 0x41, + 0x05, 0xCB, 0x28, 0xB7, 0x6F, 0xC3, 0x8B, 0x60, + 0x55, 0xC5, 0xDC, 0xFF, 0x78, 0xB8, 0x25, 0x65 + }, + { + 0x42, 0x41, 0x1F, 0x28, 0x78, 0x0B, 0x4F, 0x16, + 0x38, 0x54, 0x0B, 0x87, 0x05, 0x21, 0xEC, 0x45, + 0xBC, 0xEB, 0x1E, 0x0C, 0x71, 0x31, 0xF7, 0xE1, + 0xC4, 0x67, 0x2E, 0x43, 0x6C, 0x88, 0xC8, 0xE9 + }, + { + 0x34, 0xB4, 0xE8, 0x76, 0x76, 0x94, 0x71, 0xDF, + 0x55, 0x2E, 0x55, 0x22, 0xCE, 0xA7, 0x84, 0xFA, + 0x53, 0xAC, 0x61, 0xBE, 0xDE, 0x8C, 0xFE, 0x29, + 0x14, 0x09, 0xE6, 0x8B, 0x69, 0xE8, 0x77, 0x6F + }, + { + 0x8F, 0x31, 0xD6, 0x37, 0xA9, 0x1D, 0xBD, 0x0E, + 0xCB, 0x0B, 0xA0, 0xE6, 0x94, 0xBE, 0xC1, 0x44, + 0x76, 0x58, 0xCE, 0x6C, 0x27, 0xEA, 0x9B, 0x95, + 0xFF, 0x36, 0x70, 0x1C, 0xAF, 0x36, 0xF0, 0x01 + }, + { + 0xB5, 0xC8, 0x95, 0xEB, 0x07, 0x1E, 0x3D, 0x38, + 0x52, 0x8D, 0x47, 0x5D, 0x3B, 0xB0, 0xBA, 0x88, + 0xB7, 0x17, 0x95, 0xE4, 0x0A, 0x98, 0x2E, 0x2A, + 0xC2, 0xD8, 0x44, 0x22, 0xA0, 0xF2, 0x68, 0x5D + }, + { + 0xE9, 0x06, 0x25, 0x7C, 0x41, 0x9D, 0x94, 0x1E, + 0xD2, 0xB8, 0xA9, 0xC1, 0x27, 0x81, 0xDB, 0x97, + 0x59, 0xA3, 0xFC, 0xF3, 0xDC, 0x7C, 0xDB, 0x03, + 0x15, 0x99, 0xE1, 0x08, 0x6B, 0x67, 0x2F, 0x10 + }, + { + 0x98, 0xAD, 0x24, 0x39, 0x7C, 0x6E, 0xAE, 0x4C, + 0xF7, 0x3E, 0xA8, 0xBB, 0xEF, 0x5A, 0x0B, 0x74, + 0xD2, 0x1A, 0xD1, 0x5F, 0x33, 0x92, 0x0F, 0x44, + 0x07, 0x0A, 0x98, 0xBD, 0xF5, 0x3D, 0x0B, 0x3A + }, + { + 0xDD, 0x51, 0x0C, 0xA5, 0x5B, 0x11, 0x70, 0xF9, + 0xCE, 0xFD, 0xBB, 0x16, 0xFC, 0x14, 0x52, 0x62, + 0xAA, 0x36, 0x3A, 0x87, 0x0A, 0x01, 0xE1, 0xBC, + 0x4F, 0xBE, 0x40, 0x23, 0x4B, 0x4B, 0x6F, 0x2F + }, + { + 0xF2, 0xD8, 0xD9, 0x31, 0xB9, 0x2E, 0x1C, 0xB6, + 0x98, 0xE5, 0x6E, 0xD0, 0x28, 0x19, 0xEA, 0x11, + 0xD2, 0x66, 0x19, 0xB8, 0x3A, 0x62, 0x09, 0xAD, + 0x67, 0x22, 0x53, 0x68, 0xFE, 0x11, 0x95, 0x71 + }, + { + 0xE4, 0x63, 0x70, 0x55, 0xDB, 0x91, 0xF9, 0x43, + 0x7C, 0xF4, 0x60, 0xEF, 0x40, 0xB5, 0x14, 0x5F, + 0x69, 0x98, 0x26, 0x6A, 0x5E, 0x74, 0xE9, 0x6A, + 0x00, 0x78, 0x2C, 0x62, 0xCF, 0x30, 0xCF, 0x1C + }, + { + 0x35, 0x63, 0x53, 0x0A, 0x89, 0xD3, 0x2B, 0x75, + 0xF7, 0x8D, 0x83, 0xE9, 0x87, 0x2A, 0xD4, 0xC5, + 0x75, 0xF5, 0x20, 0x39, 0x9D, 0x65, 0x03, 0x5D, + 0xED, 0x99, 0xE5, 0xEE, 0xC5, 0x80, 0x71, 0x50 + }, + { + 0x8E, 0x79, 0xF9, 0x2C, 0x86, 0x5B, 0xEB, 0x3E, + 0x1C, 0xDB, 0xF0, 0x8F, 0x75, 0x4A, 0x26, 0x06, + 0xE8, 0x53, 0x49, 0x05, 0x3D, 0x66, 0xD6, 0x16, + 0x02, 0x4A, 0x81, 0x3F, 0xCA, 0x54, 0x1A, 0x4D + }, + { + 0x86, 0x42, 0x26, 0xF2, 0x83, 0x9C, 0x76, 0xB1, + 0xD5, 0xF7, 0xC1, 0x3D, 0x98, 0xC2, 0xA5, 0x15, + 0x8C, 0x2A, 0xBB, 0x71, 0xD9, 0xD8, 0xF0, 0xFA, + 0x1F, 0x7C, 0x3F, 0x74, 0x68, 0x00, 0x16, 0x03 + }, + { + 0xD3, 0xE3, 0xF5, 0xB8, 0xCE, 0xEB, 0xB1, 0x11, + 0x84, 0x80, 0x35, 0x35, 0x90, 0x0B, 0x6E, 0xED, + 0xDA, 0x60, 0x6E, 0xEB, 0x36, 0x97, 0x51, 0xA7, + 0xCD, 0xA3, 0x6C, 0xA3, 0x02, 0x29, 0xFB, 0x02 + }, + { + 0x8C, 0x7D, 0x6B, 0x98, 0x72, 0x69, 0x16, 0x90, + 0x31, 0xF7, 0x1F, 0xD7, 0xE4, 0xC4, 0x45, 0x01, + 0x2D, 0x3E, 0x6A, 0x3C, 0x88, 0x09, 0xF6, 0x47, + 0x9B, 0xD6, 0x67, 0xCF, 0x31, 0x1E, 0x27, 0x6E + }, + { + 0xB9, 0x04, 0xB5, 0x71, 0x1B, 0xF1, 0x9E, 0x85, + 0x32, 0xF7, 0xAD, 0x64, 0x27, 0x41, 0x0A, 0x62, + 0xA1, 0xF7, 0x7F, 0x77, 0xB9, 0xB6, 0xD7, 0x1D, + 0x2F, 0xC4, 0x3B, 0xC9, 0x0F, 0x73, 0x23, 0x5A + }, + { + 0x45, 0x36, 0x63, 0x43, 0x15, 0xC8, 0x67, 0x28, + 0xF5, 0xAB, 0x74, 0x49, 0xEB, 0x2D, 0x04, 0x02, + 0x0E, 0x9E, 0xAE, 0x8D, 0xD6, 0x79, 0x55, 0x00, + 0xE9, 0xEC, 0x9A, 0x00, 0x66, 0x38, 0x6E, 0x69 + }, + { + 0xFD, 0x5E, 0x49, 0xFE, 0xD4, 0x9D, 0xC4, 0x4B, + 0xDE, 0x89, 0xF4, 0x60, 0xA9, 0x50, 0x19, 0x1E, + 0xBB, 0x06, 0x7C, 0x69, 0x8A, 0x3F, 0x21, 0xEA, + 0x14, 0x30, 0x8C, 0x74, 0x13, 0xB9, 0x16, 0x81 + }, + { + 0x31, 0xF0, 0x1D, 0x03, 0x0B, 0x9B, 0x22, 0xD0, + 0x0A, 0x0F, 0x71, 0xED, 0x2C, 0xEB, 0x5D, 0x2D, + 0xC8, 0x1A, 0xF2, 0xC2, 0x4B, 0xF5, 0x67, 0x0F, + 0xDE, 0x19, 0xA6, 0x85, 0xE8, 0xD1, 0x39, 0x2E + }, + { + 0x5F, 0x84, 0xD9, 0xDE, 0x28, 0x4B, 0x1E, 0x4F, + 0x67, 0x8E, 0x31, 0xAB, 0x6A, 0x76, 0xF5, 0x66, + 0x1B, 0x5A, 0xEA, 0xA7, 0x68, 0x53, 0x93, 0x84, + 0xAA, 0x38, 0xF9, 0xE4, 0x9C, 0xCE, 0x6E, 0x6E + }, + { + 0xB2, 0x07, 0x9E, 0x59, 0x97, 0xA4, 0xEA, 0xD3, + 0xA7, 0x1F, 0xEF, 0xC0, 0x2F, 0x90, 0xA7, 0x48, + 0x3A, 0x10, 0xFD, 0x2E, 0x6F, 0x31, 0xBD, 0xA9, + 0xD2, 0x08, 0x44, 0x85, 0xCC, 0x01, 0x6B, 0xBD + }, + { + 0xE0, 0xF8, 0x4D, 0x7F, 0x52, 0x5B, 0x6F, 0xED, + 0x79, 0x1F, 0x77, 0x28, 0x9A, 0xE5, 0x8F, 0x7D, + 0x50, 0xA2, 0x94, 0x32, 0xD4, 0x2C, 0x25, 0xC1, + 0xE8, 0x39, 0x29, 0xB8, 0x38, 0x89, 0x1D, 0x79 + }, + { + 0x70, 0x46, 0x96, 0x90, 0x95, 0x6D, 0x79, 0x18, + 0xAC, 0xE7, 0xBA, 0x5F, 0x41, 0x30, 0x2D, 0xA1, + 0x38, 0xC9, 0xB5, 0x6E, 0xCD, 0x41, 0x55, 0x44, + 0xFA, 0xCE, 0x8D, 0x99, 0x8C, 0x21, 0xAB, 0xEB + }, + { + 0x45, 0xC9, 0x1A, 0x62, 0x24, 0x9B, 0x39, 0xCD, + 0xA9, 0x4E, 0x50, 0x82, 0x95, 0xBE, 0xC7, 0x66, + 0x71, 0x19, 0x44, 0x77, 0x65, 0xEF, 0x80, 0xEF, + 0xA8, 0x2D, 0x1E, 0x92, 0xD5, 0x70, 0x67, 0xD8 + }, + { + 0x1D, 0x9E, 0x00, 0x73, 0xEE, 0xD0, 0x73, 0x15, + 0x54, 0xC3, 0xBE, 0xAA, 0x47, 0x46, 0x0D, 0x51, + 0x1A, 0xD2, 0x61, 0xDD, 0x4D, 0x4A, 0x3B, 0xED, + 0x9D, 0x8D, 0x20, 0x2F, 0x22, 0xF2, 0x15, 0x89 + }, + { + 0x40, 0x82, 0x62, 0x73, 0x6D, 0x8A, 0xEC, 0x0B, + 0x84, 0x7D, 0xBA, 0x25, 0x02, 0x58, 0x60, 0x8A, + 0x43, 0x45, 0xA6, 0x3A, 0x1E, 0xB1, 0x95, 0xE5, + 0xC7, 0xAE, 0x2E, 0xE8, 0x74, 0xC3, 0x4D, 0xA8 + }, + { + 0x23, 0xD2, 0xB7, 0x04, 0x39, 0x46, 0x99, 0x49, + 0x98, 0x23, 0x90, 0x53, 0x8D, 0x7E, 0x5A, 0xDE, + 0x9F, 0x18, 0xC8, 0xE3, 0xBB, 0xF6, 0x60, 0x5A, + 0xFC, 0xF4, 0x9B, 0x00, 0xC0, 0x61, 0xE8, 0x37 + }, + { + 0x23, 0x2F, 0xB1, 0x87, 0xD2, 0x71, 0xBE, 0xA9, + 0x12, 0xEF, 0xD4, 0x07, 0xFF, 0xE0, 0x80, 0x56, + 0xD6, 0xA4, 0x2E, 0x53, 0x21, 0xEC, 0x79, 0x2D, + 0xF3, 0xD5, 0x84, 0xA9, 0x4F, 0x63, 0x0A, 0xB2 + }, + { + 0x13, 0x8E, 0x19, 0x44, 0xE4, 0xB5, 0x4D, 0xE8, + 0x68, 0x1D, 0x7E, 0x48, 0xC4, 0xF0, 0x81, 0x48, + 0xE4, 0x0A, 0x56, 0x7E, 0x5C, 0xAD, 0x94, 0x6A, + 0x6A, 0xF4, 0xE8, 0xD5, 0xD2, 0x6F, 0x75, 0xC7 + }, + { + 0x80, 0xC1, 0x51, 0x32, 0x5F, 0xBF, 0xC6, 0x78, + 0xB7, 0xBE, 0x4E, 0x40, 0xB3, 0x0F, 0x29, 0xFE, + 0x31, 0xCD, 0xBE, 0x1C, 0x84, 0x12, 0x6E, 0x00, + 0x6D, 0xF3, 0xC1, 0x85, 0x24, 0xBD, 0x2D, 0x6C + }, + { + 0xA6, 0x42, 0x26, 0x73, 0x01, 0x66, 0x9D, 0xF2, + 0x61, 0xB8, 0x39, 0xF8, 0x73, 0x65, 0x76, 0x29, + 0x05, 0xFF, 0x32, 0x0A, 0x0A, 0x2F, 0xC4, 0xBD, + 0xC4, 0x8E, 0x5A, 0x8E, 0x15, 0xD1, 0x32, 0x33 + }, + { + 0x0F, 0x8B, 0x10, 0x99, 0x38, 0x60, 0x93, 0x7A, + 0x74, 0xCC, 0x2D, 0xE4, 0x0A, 0x27, 0x31, 0xDD, + 0x99, 0x54, 0xB6, 0x54, 0xBB, 0x94, 0xC3, 0x4E, + 0x87, 0x66, 0x52, 0xE9, 0x8D, 0x4B, 0xBD, 0x16 + }, + { + 0xE6, 0x34, 0xA5, 0x85, 0x12, 0x49, 0x32, 0x73, + 0x26, 0x0F, 0x10, 0xD4, 0x49, 0x53, 0xCD, 0x99, + 0x8E, 0x34, 0xCB, 0x82, 0x81, 0xC4, 0x1B, 0xF4, + 0x2E, 0x0A, 0xE2, 0xF2, 0x5C, 0xBD, 0x1F, 0x75 + }, + { + 0xBD, 0xE6, 0xAF, 0x9B, 0xAF, 0x3C, 0x07, 0xE9, + 0x54, 0x23, 0xCA, 0xB5, 0x04, 0xDE, 0xE7, 0x0E, + 0xDC, 0xC3, 0x31, 0x8B, 0x22, 0xDD, 0x1E, 0xB6, + 0xFD, 0x85, 0xBE, 0x44, 0x7A, 0xC9, 0xF2, 0x09 + }, + { + 0x91, 0x4B, 0x37, 0xAB, 0x5B, 0x8C, 0xFD, 0xE6, + 0xA4, 0x80, 0x46, 0x6A, 0x0D, 0x82, 0x43, 0x2C, + 0x7D, 0x76, 0x32, 0x8E, 0x9A, 0x88, 0xEF, 0x5B, + 0x4F, 0x52, 0x42, 0x9F, 0x7A, 0x3F, 0xFC, 0x7D + }, + { + 0x55, 0xBE, 0x66, 0xE9, 0xA5, 0xAA, 0x67, 0x1A, + 0x23, 0x88, 0x2E, 0xF3, 0xE7, 0xD9, 0xD3, 0x6E, + 0xA9, 0x54, 0x87, 0xDC, 0x71, 0xB7, 0x25, 0xA5, + 0xAD, 0x4B, 0x79, 0x8A, 0x87, 0x91, 0x43, 0xD0 + }, + { + 0x3F, 0xD0, 0x45, 0x89, 0x4B, 0x83, 0x6E, 0x44, + 0xE9, 0xCA, 0x75, 0xFB, 0xE3, 0xEA, 0xDC, 0x48, + 0x6C, 0xBB, 0xD0, 0xD8, 0xCE, 0xE1, 0xB3, 0xCF, + 0x14, 0xF7, 0x6E, 0x7F, 0x1E, 0x77, 0xAE, 0xF3 + }, + { + 0xCE, 0x60, 0x34, 0x3D, 0xC4, 0x87, 0x4B, 0x66, + 0x04, 0xE1, 0xFB, 0x23, 0x1E, 0x37, 0xEC, 0x1E, + 0xEC, 0x3F, 0x06, 0x56, 0x6E, 0x42, 0x8A, 0xE7, + 0x64, 0xEF, 0xFF, 0xA2, 0x30, 0xAD, 0xD4, 0x85 + }, + { + 0xE3, 0x8C, 0x9D, 0xF0, 0x24, 0xDE, 0x21, 0x53, + 0xD2, 0x26, 0x73, 0x8A, 0x0E, 0x5B, 0xA9, 0xB8, + 0xC6, 0x78, 0x4D, 0xAC, 0xA6, 0x5C, 0x22, 0xA7, + 0x62, 0x8E, 0xB5, 0x8E, 0xA0, 0xD4, 0x95, 0xA7 + }, + { + 0x8D, 0xFE, 0xC0, 0xD4, 0xF3, 0x65, 0x8A, 0x20, + 0xA0, 0xBA, 0xD6, 0x6F, 0x21, 0x60, 0x83, 0x2B, + 0x16, 0x4E, 0x70, 0x0A, 0x21, 0xEC, 0x5A, 0x01, + 0x65, 0xC3, 0x67, 0x72, 0xB2, 0x08, 0x61, 0x11 + }, + { + 0x44, 0x01, 0xB5, 0x0E, 0x09, 0x86, 0x5F, 0x42, + 0x38, 0x24, 0x3B, 0x82, 0x25, 0xCA, 0x40, 0xA0, + 0x8D, 0xBB, 0x46, 0x85, 0xF5, 0xF8, 0x62, 0xFB, + 0xDD, 0x72, 0x98, 0x04, 0x31, 0xA8, 0x5D, 0x3F + }, + { + 0x86, 0x68, 0x94, 0x27, 0x88, 0xC4, 0xCE, 0x8A, + 0x33, 0x19, 0x0F, 0xFC, 0xFA, 0xD1, 0xC6, 0x78, + 0xC4, 0xFA, 0x41, 0xE9, 0x94, 0x17, 0x09, 0x4E, + 0x24, 0x0F, 0x4A, 0x43, 0xF3, 0x87, 0xA3, 0xB6 + }, + { + 0xA7, 0x28, 0x8D, 0x5E, 0x09, 0x80, 0x9B, 0x69, + 0x69, 0x84, 0xEC, 0xD5, 0x32, 0x6C, 0xDD, 0x84, + 0xFB, 0xE3, 0x5F, 0xCF, 0x67, 0x23, 0x5D, 0x81, + 0x1C, 0x82, 0x00, 0x25, 0x36, 0xA3, 0xC5, 0xE1 + }, + { + 0x8E, 0x92, 0x5C, 0x3C, 0x14, 0x6B, 0xAC, 0xF3, + 0x35, 0x1E, 0xC5, 0x32, 0x41, 0xAC, 0xE5, 0xF7, + 0x3E, 0x8F, 0xC9, 0xBD, 0x8C, 0x61, 0xCA, 0xD9, + 0x7F, 0xD7, 0x72, 0xB0, 0x7E, 0x1B, 0x83, 0x73 + }, + { + 0xC7, 0xEB, 0x9E, 0x6D, 0xED, 0x2F, 0x99, 0x3D, + 0x48, 0xB0, 0x17, 0x0D, 0xA2, 0x7C, 0x5B, 0x75, + 0x3B, 0x12, 0x17, 0x6B, 0xE1, 0x26, 0xC7, 0xBA, + 0x2D, 0x6A, 0xF8, 0x5F, 0x85, 0x93, 0xB7, 0x52 + }, + { + 0xCA, 0x27, 0xF1, 0x6F, 0x94, 0xE4, 0xEC, 0x0E, + 0x62, 0x8E, 0x7F, 0x8A, 0xEF, 0xC6, 0x65, 0x7B, + 0xED, 0xC9, 0x37, 0x42, 0x96, 0x59, 0x40, 0xAE, + 0x78, 0x6A, 0x73, 0xB5, 0xFD, 0x59, 0x3B, 0x97 + }, + { + 0x8C, 0x21, 0xE6, 0x56, 0x8B, 0xC6, 0xDC, 0x00, + 0xE3, 0xD6, 0xEB, 0xC0, 0x9E, 0xA9, 0xC2, 0xCE, + 0x00, 0x6C, 0xD3, 0x11, 0xD3, 0xB3, 0xE9, 0xCC, + 0x9D, 0x8D, 0xDB, 0xFB, 0x3C, 0x5A, 0x77, 0x76 + }, + { + 0x52, 0x56, 0x66, 0x96, 0x8B, 0x3B, 0x7D, 0x00, + 0x7B, 0xB9, 0x26, 0xB6, 0xEF, 0xDC, 0x7E, 0x21, + 0x2A, 0x31, 0x15, 0x4C, 0x9A, 0xE1, 0x8D, 0x43, + 0xEE, 0x0E, 0xB7, 0xE6, 0xB1, 0xA9, 0x38, 0xD3 + }, + { + 0xE0, 0x9A, 0x4F, 0xA5, 0xC2, 0x8B, 0xDC, 0xD7, + 0xC8, 0x39, 0x84, 0x0E, 0x0A, 0x38, 0x3E, 0x4F, + 0x7A, 0x10, 0x2D, 0x0B, 0x1B, 0xC8, 0x49, 0xC9, + 0x49, 0x62, 0x7C, 0x41, 0x00, 0xC1, 0x7D, 0xD3 + }, + { + 0xC1, 0x9F, 0x3E, 0x29, 0x5D, 0xB2, 0xFC, 0x0E, + 0x74, 0x81, 0xC4, 0xF1, 0x6A, 0xF0, 0x11, 0x55, + 0xDD, 0xB0, 0xD7, 0xD1, 0x38, 0x3D, 0x4A, 0x1F, + 0xF1, 0x69, 0x9D, 0xB7, 0x11, 0x77, 0x34, 0x0C + }, + { + 0x76, 0x9E, 0x67, 0x8C, 0x0A, 0x09, 0x09, 0xA2, + 0x02, 0x1C, 0x4D, 0xC2, 0x6B, 0x1A, 0x3C, 0x9B, + 0xC5, 0x57, 0xAD, 0xB2, 0x1A, 0x50, 0x83, 0x4C, + 0xDC, 0x5C, 0x92, 0x93, 0xF7, 0x53, 0x65, 0xF8 + }, + { + 0xB6, 0x48, 0x74, 0xAD, 0xAB, 0x6B, 0xCB, 0x85, + 0xB9, 0x4B, 0xD9, 0xA6, 0xC5, 0x65, 0xD0, 0xD2, + 0xBC, 0x35, 0x44, 0x5D, 0x75, 0x28, 0xBC, 0x85, + 0xB4, 0x1F, 0xDC, 0x79, 0xDC, 0x76, 0xE3, 0x4F + }, + { + 0xFA, 0xF2, 0x50, 0xDE, 0x15, 0x82, 0x0F, 0x7F, + 0xC6, 0x10, 0xDD, 0x53, 0xEE, 0xAE, 0x44, 0x60, + 0x1C, 0x3E, 0xFF, 0xA3, 0xAC, 0xCD, 0x08, 0x8E, + 0xB6, 0x69, 0x05, 0xBB, 0x26, 0x53, 0xBE, 0x8C + }, + { + 0x1E, 0x20, 0x38, 0x73, 0x9B, 0x2C, 0x01, 0x8B, + 0x0E, 0x9E, 0x0E, 0x1E, 0x52, 0x2F, 0xD9, 0x65, + 0x12, 0x87, 0xEE, 0x6E, 0x36, 0x65, 0x91, 0x9B, + 0x24, 0xC2, 0x12, 0x4F, 0x0C, 0x1A, 0x3F, 0x3A + }, + { + 0x5F, 0xEC, 0x3A, 0xA0, 0x08, 0x61, 0xDE, 0x1A, + 0xC5, 0xDA, 0xB3, 0xC1, 0x37, 0x06, 0x5D, 0x1E, + 0x01, 0xBB, 0x03, 0xF6, 0x9D, 0xCC, 0x7D, 0x1C, + 0xF7, 0xCA, 0x4F, 0x43, 0x56, 0xAE, 0xC9, 0xA3 + }, + { + 0x44, 0x51, 0xFE, 0x6B, 0xBE, 0xF3, 0x93, 0x43, + 0x91, 0x92, 0x44, 0xC5, 0x1D, 0xAE, 0x1E, 0xA9, + 0xA9, 0x54, 0xCF, 0x2C, 0x09, 0x66, 0xAB, 0x04, + 0x5B, 0x15, 0x52, 0x1E, 0xCF, 0x35, 0x00, 0x81 + }, + { + 0x8C, 0x62, 0x2F, 0xA2, 0x16, 0x0E, 0x8E, 0x99, + 0x18, 0x13, 0xF1, 0x80, 0xBF, 0xEC, 0x0B, 0x43, + 0x1C, 0x6D, 0xBF, 0xA2, 0x95, 0x6D, 0x91, 0x75, + 0x81, 0x6A, 0x23, 0xC3, 0x82, 0xC4, 0xF2, 0x00 + }, + { + 0x81, 0x7D, 0x5C, 0x8F, 0x92, 0xE7, 0xB5, 0xCA, + 0x57, 0xF5, 0xE1, 0x63, 0x90, 0x16, 0xAD, 0x57, + 0x60, 0xE4, 0x46, 0xD6, 0xE9, 0xCA, 0xA7, 0x49, + 0x84, 0x14, 0xAC, 0xE8, 0x22, 0x80, 0xB5, 0xCD + }, + { + 0xA6, 0xA1, 0xAD, 0x58, 0xCE, 0xE5, 0x4E, 0x69, + 0xCB, 0xBC, 0xAA, 0x87, 0xDF, 0x07, 0xA6, 0x70, + 0x7E, 0xB2, 0x24, 0x73, 0x9C, 0x21, 0x76, 0x13, + 0x46, 0x0A, 0xB4, 0x54, 0xB4, 0x59, 0xCA, 0x9C + }, + { + 0x63, 0xB8, 0x47, 0x27, 0x52, 0x26, 0x60, 0x5B, + 0xE6, 0x76, 0x81, 0x25, 0x8F, 0x7D, 0x00, 0xBB, + 0xB3, 0x07, 0xC6, 0x6F, 0x19, 0x59, 0xBF, 0x2E, + 0x46, 0x7A, 0x41, 0xAE, 0xE7, 0x14, 0xE5, 0x5C + }, + { + 0xFE, 0x52, 0xEB, 0xE5, 0xCF, 0xCF, 0xE6, 0xA2, + 0x29, 0x7B, 0x53, 0x9F, 0xA3, 0xDA, 0xDB, 0xD6, + 0xEB, 0xD2, 0x01, 0xAA, 0x2C, 0xA1, 0x35, 0x63, + 0xE3, 0xD7, 0xF1, 0x4D, 0x15, 0xAB, 0xFF, 0x63 + }, + { + 0xB7, 0xBE, 0xF9, 0xFA, 0x5A, 0x3D, 0x10, 0x42, + 0x62, 0x46, 0xB5, 0xF6, 0x58, 0xC0, 0x8F, 0xDF, + 0x80, 0x66, 0xEA, 0xA3, 0xE5, 0x5A, 0x2F, 0x7D, + 0xA1, 0x59, 0x1E, 0x05, 0xC8, 0x7D, 0xF8, 0xC7 + }, + { + 0xDE, 0xD1, 0xD6, 0xCA, 0xA9, 0xF8, 0xF3, 0xBD, + 0xA9, 0x2C, 0xEA, 0x7F, 0x65, 0x49, 0xB1, 0xFB, + 0x86, 0xA2, 0x21, 0x14, 0x78, 0xC4, 0xEC, 0x28, + 0x9B, 0x83, 0x7E, 0xFC, 0x2B, 0x5C, 0x27, 0xD7 + }, + { + 0x9F, 0x30, 0x00, 0x8A, 0x2E, 0xB0, 0x50, 0xF1, + 0x8E, 0x56, 0xA7, 0x6B, 0xE9, 0x20, 0x91, 0xB2, + 0xFD, 0xC1, 0x64, 0xD5, 0x6E, 0x32, 0xC8, 0x7D, + 0xD6, 0x4C, 0x9E, 0x3A, 0x61, 0x10, 0x41, 0xB1 + }, + { + 0x01, 0x0B, 0x6A, 0x3B, 0x11, 0x86, 0x00, 0x88, + 0xF0, 0xAB, 0xC8, 0x0A, 0x89, 0x72, 0xCB, 0xBC, + 0x32, 0x9D, 0x52, 0x75, 0x34, 0x29, 0x50, 0xEB, + 0x9A, 0x04, 0x5A, 0xFD, 0xC8, 0xBB, 0xED, 0x24 + }, + { + 0x0C, 0xD2, 0x10, 0xAA, 0xC1, 0x1F, 0x1C, 0x1C, + 0xED, 0x49, 0x7F, 0x67, 0x3E, 0x53, 0xDB, 0x68, + 0xC3, 0xEC, 0x36, 0x07, 0xF0, 0xC5, 0x78, 0x7D, + 0xDC, 0x60, 0xA3, 0x55, 0xDF, 0xE5, 0x6C, 0x25 + }, + { + 0x0E, 0x56, 0xFD, 0x01, 0xDA, 0x3B, 0x4F, 0x8B, + 0xE2, 0xC9, 0x90, 0x55, 0x2A, 0xAC, 0x8D, 0x1E, + 0x8D, 0xA2, 0x09, 0xBC, 0xF4, 0xAA, 0xD4, 0xFF, + 0xB5, 0x42, 0x7F, 0xD6, 0x31, 0x72, 0x46, 0x3E + }, + { + 0xD6, 0xD5, 0xCD, 0xB1, 0x14, 0x40, 0xE3, 0x4A, + 0xCA, 0x3A, 0x2F, 0xCF, 0x30, 0xF5, 0x9E, 0x08, + 0xB1, 0x1A, 0x2A, 0x3D, 0xE5, 0x39, 0xE3, 0xE6, + 0x51, 0x3E, 0xD7, 0x8A, 0x4F, 0xEE, 0x51, 0x3B + }, + { + 0xAA, 0x35, 0xAC, 0x90, 0x68, 0x06, 0x70, 0xC7, + 0x32, 0xED, 0x1E, 0xF3, 0x7E, 0x8C, 0xBA, 0xAE, + 0x49, 0xA4, 0xD8, 0x8E, 0xCF, 0x4D, 0xF2, 0xB6, + 0x89, 0xA0, 0xF1, 0x01, 0xB7, 0x56, 0xAE, 0x47 + }, + { + 0x27, 0x8E, 0x56, 0x12, 0x88, 0x72, 0x26, 0x30, + 0xE2, 0x6A, 0x5F, 0xC9, 0x54, 0xBF, 0x2D, 0xCD, + 0x6A, 0x65, 0x81, 0x67, 0x39, 0xAB, 0xEE, 0x7B, + 0xE1, 0x43, 0x07, 0xA9, 0x61, 0x74, 0xE5, 0xB0 + }, + { + 0xAB, 0x4B, 0x2C, 0xA1, 0xA2, 0xB3, 0x49, 0x98, + 0x15, 0x24, 0xB6, 0x15, 0x54, 0x62, 0xF0, 0xFF, + 0x10, 0x60, 0xBF, 0x9B, 0xFA, 0x07, 0xFB, 0x9E, + 0xC6, 0x9C, 0xA4, 0x71, 0x64, 0x5B, 0x6A, 0x18 + }, + { + 0x18, 0xA9, 0xBB, 0xEC, 0x3C, 0x8E, 0x1F, 0x8E, + 0xE9, 0x57, 0x12, 0x97, 0xA9, 0x34, 0x36, 0xDE, + 0x42, 0x7C, 0xD2, 0x70, 0xEC, 0x69, 0xDF, 0xE8, + 0x88, 0xDB, 0x7D, 0xBF, 0x10, 0xB6, 0x49, 0x93 + }, + { + 0xBA, 0xFC, 0x7E, 0x43, 0xD2, 0x65, 0xA1, 0x73, + 0x02, 0x1A, 0x9D, 0x9E, 0x58, 0x3D, 0x60, 0xED, + 0x42, 0xA8, 0x03, 0xFA, 0xCD, 0x6B, 0x83, 0x60, + 0xDE, 0x1F, 0x91, 0x68, 0x35, 0x38, 0x9B, 0xF0 + }, + { + 0xA5, 0xB6, 0x7B, 0xE9, 0x50, 0xFB, 0xC2, 0xF0, + 0xDD, 0x32, 0x3A, 0x79, 0xA1, 0x9E, 0x3E, 0xD1, + 0xF4, 0xAE, 0x4B, 0xA7, 0x89, 0x4F, 0x93, 0x0E, + 0xA5, 0xEF, 0x73, 0x4D, 0xE7, 0xDB, 0x83, 0xAE + }, + { + 0xBF, 0x1E, 0x65, 0xF3, 0xCD, 0x84, 0x98, 0x88, + 0x4D, 0x9D, 0x5C, 0x19, 0xEB, 0xF7, 0xB9, 0x16, + 0x06, 0x76, 0x37, 0x60, 0x4E, 0x26, 0xDB, 0xE2, + 0xB7, 0x28, 0x8E, 0xCB, 0x11, 0x42, 0x60, 0x68 + }, + { + 0xC3, 0x34, 0x2C, 0xF9, 0xCB, 0xBF, 0x29, 0xD4, + 0x06, 0xD7, 0x89, 0x5D, 0xD4, 0xD9, 0x54, 0x8D, + 0x4A, 0xC7, 0x8B, 0x4D, 0x00, 0xE9, 0xB6, 0x3E, + 0x20, 0x3E, 0x5E, 0x19, 0xE9, 0x97, 0x46, 0x20 + }, + { + 0x1C, 0x0B, 0xE6, 0x02, 0x77, 0x43, 0x4B, 0x0E, + 0x00, 0x4B, 0x7B, 0x38, 0x8A, 0x37, 0x55, 0x9F, + 0x84, 0xB3, 0x0C, 0x6C, 0xF8, 0x60, 0x0F, 0x52, + 0x8B, 0xFC, 0xD3, 0x3C, 0xAF, 0x52, 0xCB, 0x1E + }, + { + 0x73, 0x95, 0x45, 0x30, 0xD0, 0x3F, 0x10, 0xBE, + 0xF5, 0x2A, 0xD5, 0xBC, 0x7F, 0xB4, 0xC0, 0x76, + 0xF8, 0x3F, 0x63, 0x31, 0xC8, 0xBD, 0x1E, 0xEE, + 0xC3, 0x88, 0x7F, 0x4A, 0xA2, 0x06, 0x92, 0x40 + }, + { + 0x69, 0xC1, 0x1E, 0xE0, 0x49, 0x44, 0xDE, 0xA9, + 0x85, 0xAC, 0x9F, 0x13, 0x96, 0x0E, 0x73, 0x98, + 0x0E, 0x1B, 0xB0, 0xE3, 0x09, 0xF4, 0x38, 0x4A, + 0x16, 0x76, 0xF8, 0xEF, 0xAB, 0x38, 0x42, 0x88 + }, + { + 0x36, 0xFB, 0x8F, 0xDE, 0x0E, 0xC2, 0x8C, 0xE8, + 0x53, 0xFB, 0x71, 0x75, 0xC1, 0xB7, 0x9D, 0xA3, + 0xB5, 0xE8, 0xC3, 0x91, 0x86, 0xE7, 0x8A, 0xAE, + 0xCE, 0x54, 0x64, 0xDB, 0xD9, 0xFE, 0x2A, 0xA2 + }, + { + 0x6B, 0xB2, 0xA0, 0x9D, 0xFC, 0xAF, 0x96, 0x96, + 0x2D, 0xE0, 0x0C, 0x8A, 0x08, 0x2D, 0x6D, 0xF9, + 0x32, 0x2B, 0x49, 0x66, 0xAE, 0x8D, 0x2E, 0xCF, + 0x73, 0x24, 0x11, 0xA7, 0x6A, 0x1A, 0x0E, 0xE6 + }, + { + 0x74, 0x12, 0xE7, 0xDD, 0x1B, 0xF1, 0xAA, 0x93, + 0x97, 0x41, 0x1B, 0xBA, 0x4D, 0x3E, 0x02, 0x76, + 0xD2, 0xE7, 0xA1, 0xA2, 0x9A, 0x24, 0x77, 0x15, + 0x7A, 0xD6, 0x03, 0x60, 0xD3, 0x3D, 0x4E, 0x76 + }, + { + 0xDD, 0xDE, 0xAF, 0xCF, 0xC7, 0x23, 0x21, 0xC8, + 0x49, 0xFB, 0x25, 0x94, 0x7A, 0xB4, 0x2C, 0x1A, + 0xF2, 0xA5, 0xE4, 0x3F, 0xEF, 0x68, 0x1B, 0xE4, + 0x2C, 0x7E, 0xAF, 0x36, 0x60, 0x08, 0x0A, 0xD3 + }, + { + 0x9D, 0xEF, 0xEB, 0xAD, 0xBD, 0xCB, 0x0A, 0x0E, + 0x7F, 0xF9, 0x92, 0xF9, 0x47, 0xCE, 0xD3, 0xD0, + 0xA4, 0xC8, 0x99, 0xE6, 0x4F, 0xE7, 0x73, 0x60, + 0xE8, 0x1E, 0x1F, 0x0E, 0x97, 0xF8, 0xC1, 0xA2 + }, + { + 0x84, 0x4C, 0x59, 0xFB, 0xE6, 0x47, 0x6F, 0xD1, + 0x89, 0x23, 0x99, 0x54, 0xF1, 0x7E, 0x36, 0xE1, + 0xF6, 0x9E, 0x24, 0xAA, 0xED, 0x5D, 0x5C, 0x8B, + 0x84, 0x05, 0xEF, 0x2A, 0x83, 0x0C, 0xC2, 0xA0 + }, + { + 0xFF, 0x3F, 0xAF, 0xB6, 0x77, 0x86, 0xE0, 0x1A, + 0x0C, 0x38, 0xEA, 0xDF, 0x99, 0xC4, 0xCA, 0xE8, + 0x02, 0x9D, 0xA8, 0xCF, 0x29, 0x87, 0x5F, 0xC4, + 0x19, 0xBF, 0x68, 0x00, 0x09, 0xB3, 0xBD, 0xB3 + }, + { + 0xCA, 0x67, 0x60, 0xF3, 0x45, 0x67, 0x8F, 0x30, + 0xA2, 0x8D, 0x62, 0x82, 0x94, 0x27, 0x2A, 0x19, + 0xE3, 0x07, 0x2E, 0xBC, 0x61, 0xB1, 0x9F, 0xF1, + 0x3B, 0x31, 0x89, 0x73, 0xE9, 0x7C, 0x27, 0x38 + }, + { + 0xC0, 0x8E, 0x1A, 0x90, 0x47, 0xC5, 0x05, 0x26, + 0x4A, 0x16, 0x44, 0x7C, 0x9E, 0xD9, 0x81, 0xA7, + 0x19, 0xD3, 0x81, 0xF2, 0x8E, 0x60, 0x5F, 0xD7, + 0xCA, 0xA9, 0xE8, 0xBD, 0xBB, 0x42, 0x99, 0x6A + }, + { + 0xF1, 0x73, 0xBA, 0x9D, 0x45, 0x84, 0xCD, 0x12, + 0x60, 0x50, 0xC6, 0x9F, 0xC2, 0x19, 0xA9, 0x19, + 0x0A, 0x0B, 0xF0, 0xAE, 0xCE, 0xCB, 0xE6, 0x11, + 0xBE, 0xED, 0x19, 0x3D, 0xA6, 0xCA, 0x4D, 0xE7 + }, + { + 0xB1, 0x84, 0x87, 0x65, 0x20, 0xDE, 0xD8, 0xBD, + 0x7D, 0xE2, 0x5E, 0xAE, 0xFB, 0xD3, 0xE0, 0x36, + 0x88, 0xC3, 0xBE, 0x39, 0xC1, 0x9F, 0xB7, 0x3E, + 0x1F, 0x0E, 0xCC, 0xAC, 0x7C, 0xC0, 0xF0, 0x14 + }, + { + 0x90, 0x25, 0xDB, 0x07, 0x58, 0xBD, 0xFB, 0x48, + 0xF0, 0x66, 0x7E, 0xBD, 0x7E, 0x12, 0x02, 0x46, + 0x59, 0x8F, 0xED, 0x01, 0xC2, 0x58, 0x76, 0x4F, + 0xA0, 0xFA, 0xE3, 0x34, 0xA2, 0xA0, 0x0A, 0x97 + }, + { + 0xE8, 0x3D, 0x80, 0x86, 0xFA, 0xBC, 0x46, 0x0D, + 0x5E, 0xFC, 0x45, 0x9F, 0x95, 0xA2, 0x68, 0xF5, + 0xDC, 0x4A, 0xC2, 0x84, 0x09, 0x3C, 0x24, 0x7C, + 0xA6, 0xEC, 0x84, 0x1A, 0xD6, 0x18, 0x3F, 0xE1 + }, + { + 0xCC, 0x9D, 0xF4, 0x1D, 0x35, 0xAA, 0x75, 0x92, + 0x8C, 0x18, 0x5F, 0x73, 0x93, 0x66, 0x61, 0x10, + 0xB8, 0x0F, 0x09, 0x86, 0xA2, 0x21, 0xC3, 0x70, + 0xF4, 0x5C, 0x2E, 0xB9, 0x01, 0x6C, 0x9A, 0x3B + }, + { + 0x92, 0xF9, 0xA5, 0x94, 0x95, 0x45, 0x90, 0xFA, + 0x81, 0x98, 0x17, 0xE5, 0xD1, 0xC2, 0x8A, 0xAB, + 0x2B, 0x1C, 0xC5, 0x04, 0xD8, 0x6D, 0xBA, 0x44, + 0x36, 0x76, 0xBD, 0xF8, 0x66, 0x79, 0x68, 0x11 + }, + { + 0x72, 0x95, 0x62, 0xA1, 0xE0, 0x7B, 0x0E, 0x26, + 0x05, 0x49, 0x48, 0x09, 0xBD, 0x48, 0x0F, 0x15, + 0x37, 0xCE, 0xA1, 0x0D, 0xCA, 0xD4, 0x3E, 0xF9, + 0xF6, 0x8C, 0x66, 0xE8, 0x25, 0xDC, 0x46, 0xB1 + }, + { + 0x26, 0xF1, 0x60, 0xAB, 0x96, 0xF5, 0x58, 0x20, + 0x45, 0x14, 0x6E, 0xAF, 0xF2, 0xE2, 0xA8, 0xD4, + 0xDA, 0xB2, 0x98, 0xB4, 0xC5, 0x7E, 0x11, 0x7C, + 0xDF, 0xC5, 0xD0, 0x25, 0xC9, 0x2A, 0x22, 0x68 + }, + { + 0x87, 0xEB, 0xE7, 0x21, 0x38, 0x38, 0x73, 0xD2, + 0x47, 0xF8, 0x61, 0x82, 0xE3, 0xF5, 0x99, 0xA7, + 0x63, 0x4F, 0xCA, 0xEC, 0x5E, 0x07, 0xB1, 0xE8, + 0x3E, 0xBB, 0x79, 0x62, 0x5B, 0xA3, 0x54, 0xE6 + }, + { + 0xE0, 0x8D, 0x38, 0x9F, 0x75, 0x69, 0x4A, 0xDC, + 0x99, 0x6C, 0x22, 0xF5, 0x5D, 0x4F, 0x85, 0x9F, + 0xFD, 0x0C, 0x13, 0x19, 0xFF, 0x9C, 0xED, 0xF7, + 0x8C, 0x31, 0xBE, 0x84, 0xB6, 0xF2, 0x1A, 0xBC + }, + { + 0x13, 0x63, 0xE2, 0x29, 0x13, 0xC6, 0xE1, 0x8E, + 0x7A, 0xA6, 0x5B, 0x83, 0xE7, 0x51, 0xC8, 0xA2, + 0xC6, 0x1B, 0x0F, 0x30, 0x71, 0x55, 0x86, 0x5A, + 0x57, 0xDB, 0xA5, 0x69, 0xA9, 0x9C, 0x7B, 0x0E + }, + { + 0x88, 0x78, 0x08, 0x8E, 0xB2, 0xD1, 0xF6, 0xD0, + 0xBB, 0x48, 0x1B, 0x4B, 0xB1, 0x87, 0xDA, 0x04, + 0xBC, 0xD8, 0xC2, 0xC6, 0x39, 0xF0, 0x05, 0xB0, + 0x80, 0x54, 0xCC, 0x41, 0x75, 0x39, 0x05, 0xFB + }, + { + 0x04, 0x18, 0xD6, 0x0D, 0x05, 0xB4, 0xE1, 0x24, + 0x64, 0x6E, 0xE5, 0x0E, 0x77, 0x49, 0xA1, 0xD2, + 0x09, 0x45, 0x7B, 0xC5, 0x43, 0xE3, 0xCC, 0x11, + 0x30, 0x27, 0x4A, 0xEA, 0x0F, 0x7B, 0xF3, 0xC1 + }, + { + 0x7A, 0x39, 0x7E, 0x50, 0x3F, 0x29, 0x3B, 0xC4, + 0x2D, 0x5F, 0x7E, 0xF5, 0xEC, 0x37, 0x87, 0x24, + 0x60, 0xA4, 0xF5, 0xB5, 0xCC, 0xDE, 0x77, 0xFB, + 0x4D, 0x47, 0xAC, 0x06, 0x81, 0xE5, 0xA0, 0x49 + }, + { + 0x5C, 0x0D, 0x29, 0x83, 0xE7, 0x2A, 0x6D, 0xD4, + 0xE6, 0x52, 0xD7, 0x23, 0xC1, 0xDF, 0xC1, 0x2B, + 0x41, 0x4C, 0x87, 0x3D, 0x4A, 0xB4, 0xA0, 0xA1, + 0x50, 0x40, 0x8E, 0xB3, 0x43, 0x47, 0xE9, 0x95 + }, + { + 0x56, 0x23, 0x36, 0x54, 0x53, 0xC0, 0x49, 0x89, + 0xC7, 0xCF, 0x33, 0x63, 0x5E, 0x0F, 0xC4, 0xCD, + 0xDD, 0x68, 0x6F, 0xC9, 0x5A, 0x33, 0xDF, 0xED, + 0xCF, 0x33, 0x35, 0x79, 0x4C, 0x7D, 0xC3, 0x44 + }, + { + 0x11, 0xF6, 0xDA, 0xD1, 0x88, 0x02, 0x8F, 0xDF, + 0x13, 0x78, 0xA2, 0x56, 0xE4, 0x57, 0x0E, 0x90, + 0x63, 0x10, 0x7B, 0x8F, 0x79, 0xDC, 0x66, 0x3F, + 0xA5, 0x55, 0x6F, 0x56, 0xFD, 0x44, 0xA0, 0xF0 + }, + { + 0x0E, 0xD8, 0x16, 0x17, 0x97, 0xEC, 0xEE, 0x88, + 0x1E, 0x7D, 0x0E, 0x3F, 0x4C, 0x5F, 0xB8, 0x39, + 0xC8, 0x4E, 0xB7, 0xA9, 0x24, 0x26, 0x57, 0xCC, + 0x48, 0x30, 0x68, 0x07, 0xB3, 0x2B, 0xEF, 0xDE + }, + { + 0x73, 0x66, 0x67, 0xC9, 0x36, 0x4C, 0xE1, 0x2D, + 0xB8, 0xF6, 0xB1, 0x43, 0xC6, 0xC1, 0x78, 0xCD, + 0xEF, 0x1E, 0x14, 0x45, 0xBC, 0x5A, 0x2F, 0x26, + 0x34, 0xF0, 0x8E, 0x99, 0x32, 0x27, 0x3C, 0xAA + }, + { + 0xE1, 0x5F, 0x36, 0x8B, 0x44, 0x06, 0xC1, 0xF6, + 0x55, 0x57, 0xC8, 0x35, 0x5C, 0xBE, 0x69, 0x4B, + 0x63, 0x3E, 0x26, 0xF1, 0x55, 0xF5, 0x2B, 0x7D, + 0xA9, 0x4C, 0xFB, 0x23, 0xFD, 0x4A, 0x5D, 0x96 + }, + { + 0x43, 0x7A, 0xB2, 0xD7, 0x4F, 0x50, 0xCA, 0x86, + 0xCC, 0x3D, 0xE9, 0xBE, 0x70, 0xE4, 0x55, 0x48, + 0x25, 0xE3, 0x3D, 0x82, 0x4B, 0x3A, 0x49, 0x23, + 0x62, 0xE2, 0xE9, 0xD6, 0x11, 0xBC, 0x57, 0x9D + }, + { + 0x2B, 0x91, 0x58, 0xC7, 0x22, 0x89, 0x8E, 0x52, + 0x6D, 0x2C, 0xDD, 0x3F, 0xC0, 0x88, 0xE9, 0xFF, + 0xA7, 0x9A, 0x9B, 0x73, 0xB7, 0xD2, 0xD2, 0x4B, + 0xC4, 0x78, 0xE2, 0x1C, 0xDB, 0x3B, 0x67, 0x63 + }, + { + 0x0C, 0x8A, 0x36, 0x59, 0x7D, 0x74, 0x61, 0xC6, + 0x3A, 0x94, 0x73, 0x28, 0x21, 0xC9, 0x41, 0x85, + 0x6C, 0x66, 0x83, 0x76, 0x60, 0x6C, 0x86, 0xA5, + 0x2D, 0xE0, 0xEE, 0x41, 0x04, 0xC6, 0x15, 0xDB + }, + { + 0xE5, 0xF4, 0x67, 0x51, 0xED, 0x88, 0x8C, 0x5F, + 0xB7, 0x43, 0x6C, 0x30, 0x88, 0xDE, 0xA8, 0xD3, + 0x98, 0x06, 0x6A, 0x43, 0xE5, 0x21, 0xCB, 0x13, + 0x13, 0x34, 0x38, 0xF2, 0xC8, 0x0E, 0x60, 0xE5 + }, + { + 0x24, 0xCA, 0x15, 0x58, 0x00, 0x6C, 0x2F, 0xE1, + 0x9D, 0xE4, 0xB2, 0xEE, 0x40, 0x53, 0x5E, 0xD4, + 0x1C, 0x7E, 0xB9, 0x76, 0xA4, 0xD5, 0xB5, 0x40, + 0x50, 0xA2, 0xB3, 0x01, 0xF4, 0xF4, 0x68, 0x1B + }, + { + 0x93, 0xFC, 0x04, 0x10, 0xF1, 0x5D, 0x3B, 0xBA, + 0x62, 0x6E, 0x3E, 0xB8, 0xCA, 0xD5, 0xDE, 0x18, + 0x50, 0xA9, 0x85, 0x09, 0xA6, 0x7B, 0x33, 0x9B, + 0x58, 0x5C, 0xD4, 0x2D, 0x6D, 0x34, 0x98, 0xC6 + }, + { + 0xA1, 0xAB, 0x52, 0x94, 0xCE, 0x9B, 0xE4, 0xE3, + 0x95, 0xC1, 0x29, 0x50, 0xFC, 0x43, 0xA4, 0x2C, + 0x08, 0x44, 0x98, 0x19, 0xA9, 0x9B, 0xA1, 0x0A, + 0x41, 0xA3, 0x1C, 0x36, 0x38, 0xBC, 0xDD, 0x95 + }, + { + 0x36, 0x21, 0xC9, 0x86, 0xCA, 0x68, 0x21, 0xAF, + 0xCD, 0xC6, 0x16, 0x6A, 0xCE, 0xC6, 0x7F, 0xC2, + 0x35, 0x96, 0xDA, 0x38, 0xE1, 0xE7, 0x28, 0x87, + 0xF6, 0xD5, 0x39, 0xAB, 0x43, 0x66, 0x68, 0x0A + }, + { + 0x05, 0xCE, 0xC6, 0xA5, 0xFD, 0xDC, 0x02, 0x7F, + 0x8B, 0x29, 0x22, 0x52, 0xFE, 0x46, 0x34, 0xD1, + 0xB6, 0x2C, 0x44, 0xD9, 0x36, 0x5C, 0x00, 0x67, + 0x83, 0x28, 0xDB, 0x2D, 0xC3, 0x79, 0x6C, 0xA7 + }, + { + 0x20, 0xDD, 0xA1, 0xEC, 0x70, 0x95, 0x76, 0x55, + 0xF8, 0xD4, 0xC1, 0x22, 0x4A, 0xC8, 0x0D, 0xBD, + 0x4E, 0xA5, 0xBC, 0x4D, 0xBA, 0x46, 0xD1, 0xB8, + 0xCD, 0xD1, 0x4C, 0x30, 0x48, 0x46, 0xBE, 0xA5 + }, + { + 0xA3, 0xB8, 0xFC, 0xB6, 0x4B, 0x92, 0x72, 0x43, + 0x48, 0xA9, 0x0B, 0x0E, 0x1D, 0xFC, 0x80, 0x0E, + 0xEC, 0x15, 0xB9, 0x1A, 0x54, 0x3C, 0x79, 0x5A, + 0xFD, 0xBA, 0x02, 0xF9, 0xC2, 0xF0, 0xDC, 0x68 + }, + { + 0xF7, 0xC7, 0x31, 0x15, 0x16, 0x20, 0xBD, 0xE1, + 0xAD, 0x68, 0x12, 0xBD, 0x02, 0x66, 0x0B, 0x60, + 0xDC, 0x14, 0xC1, 0xA2, 0xC3, 0xD9, 0x3A, 0x8C, + 0x0A, 0x18, 0xE7, 0x09, 0x86, 0xD9, 0xEA, 0xF9 + }, + { + 0x97, 0x94, 0x4D, 0x48, 0x00, 0x5B, 0xF5, 0x20, + 0xA0, 0x24, 0xC1, 0x34, 0xCD, 0x47, 0x0C, 0x86, + 0x1A, 0x3A, 0x87, 0x93, 0xD7, 0xFB, 0xD9, 0x87, + 0x09, 0xFE, 0x43, 0x56, 0x79, 0xBE, 0xAC, 0x0B + }, + { + 0x38, 0x95, 0x62, 0x8C, 0x40, 0x99, 0xEE, 0x33, + 0x5A, 0xC2, 0x6E, 0xC1, 0x27, 0xE1, 0xCD, 0x75, + 0x62, 0x08, 0x7A, 0x93, 0x90, 0x90, 0xE0, 0xA6, + 0x00, 0x45, 0x70, 0xF3, 0xD2, 0x7E, 0x23, 0x37 + }, + { + 0xFE, 0xB2, 0x72, 0x5E, 0xA7, 0x35, 0xE7, 0x71, + 0x25, 0xA6, 0xB2, 0x2B, 0x1A, 0xD1, 0xAC, 0xEF, + 0xFD, 0xDA, 0x44, 0xD5, 0x36, 0xE4, 0xF7, 0xB1, + 0xBB, 0x89, 0x75, 0x3D, 0xBF, 0xE4, 0xE2, 0x30 + }, + { + 0xF4, 0x5D, 0xD9, 0x61, 0x41, 0xA6, 0x0A, 0x1A, + 0xC2, 0x43, 0x14, 0x41, 0xC3, 0x7F, 0x7C, 0x78, + 0x4C, 0x70, 0xE0, 0x8B, 0x53, 0xDA, 0x14, 0xD3, + 0x50, 0x92, 0xEE, 0x0D, 0xFC, 0xF1, 0xD1, 0x33 + }, + { + 0x1C, 0x73, 0x96, 0xF8, 0xA7, 0xAF, 0x48, 0x87, + 0xDA, 0x4C, 0x98, 0x18, 0xDE, 0x30, 0xA9, 0x55, + 0x94, 0x62, 0xF9, 0xAB, 0xCC, 0xC1, 0xFA, 0x2B, + 0x4D, 0x0F, 0x60, 0x3A, 0x3C, 0x1B, 0x60, 0x4B + }, + { + 0xFC, 0xA8, 0xD7, 0xFF, 0xE9, 0xC1, 0xF7, 0x2F, + 0x50, 0x1F, 0xA5, 0x3E, 0x2C, 0x64, 0x61, 0xE7, + 0x5E, 0xE1, 0xC0, 0x04, 0x02, 0x8C, 0x74, 0x04, + 0x64, 0x0D, 0xDD, 0xD9, 0x3C, 0xA6, 0x8B, 0xFB + }, + { + 0xB7, 0x59, 0x56, 0xEC, 0xE0, 0xC3, 0xC3, 0xCB, + 0x1F, 0x32, 0x4E, 0x5A, 0xC1, 0xE1, 0xAD, 0x69, + 0x08, 0xD7, 0x0C, 0x32, 0xE5, 0x52, 0x3F, 0x30, + 0xEC, 0xD1, 0x43, 0xC8, 0x57, 0x9A, 0x74, 0xBF + }, + { + 0x9A, 0xE6, 0x6F, 0xD3, 0xD4, 0xA2, 0xE8, 0x7A, + 0x9A, 0xBD, 0x13, 0x00, 0xDF, 0x3F, 0x7E, 0x8C, + 0xB0, 0x95, 0x88, 0x73, 0xBD, 0x76, 0x7E, 0x22, + 0x60, 0x0C, 0x03, 0xFA, 0xAD, 0x8D, 0x3C, 0xBD + }, + { + 0x0B, 0xF1, 0x4C, 0x9A, 0x89, 0xBF, 0x95, 0x2A, + 0xF6, 0xCC, 0x22, 0x97, 0x37, 0x8D, 0xD9, 0x48, + 0x65, 0x56, 0x2F, 0xD1, 0x8D, 0xBB, 0xA5, 0x80, + 0xA7, 0xEE, 0xA0, 0x5F, 0xBE, 0x44, 0xFC, 0x03 + }, + { + 0xEA, 0x91, 0x38, 0x24, 0x0C, 0x4B, 0x98, 0x3B, + 0xA8, 0x27, 0x04, 0x68, 0x7B, 0x34, 0x3C, 0xFF, + 0xD4, 0x40, 0x7B, 0x17, 0x61, 0x71, 0x31, 0x88, + 0xC8, 0x9D, 0x47, 0x9C, 0xFF, 0xC3, 0x6E, 0x92 + }, + { + 0xE1, 0x84, 0x36, 0x53, 0x16, 0x29, 0xE0, 0x64, + 0x08, 0xAC, 0xDC, 0xFD, 0x20, 0x09, 0x66, 0x4F, + 0xBC, 0xAF, 0xB7, 0xF7, 0xCC, 0x6F, 0x7D, 0x08, + 0xB0, 0xA6, 0x6B, 0x5F, 0xB5, 0xA8, 0xB2, 0xD4 + }, + { + 0x57, 0xAD, 0x6C, 0x23, 0x1C, 0x70, 0x7C, 0x32, + 0x75, 0x6F, 0xEB, 0x1B, 0x28, 0x9A, 0xC7, 0x76, + 0x04, 0x21, 0x4C, 0x26, 0xC1, 0xF5, 0x89, 0xE2, + 0xAC, 0x83, 0xFF, 0x9C, 0xA7, 0x60, 0xD8, 0x96 + }, + { + 0x76, 0x18, 0x6F, 0x24, 0x87, 0xFC, 0xBE, 0xBC, + 0x33, 0x32, 0x8B, 0xBA, 0x4B, 0x8B, 0xD5, 0xB3, + 0x22, 0xED, 0xF6, 0xBD, 0x7E, 0x34, 0xEF, 0x2C, + 0x64, 0xC9, 0xE8, 0xC2, 0x51, 0xBD, 0x0B, 0x2C + }, + { + 0xC5, 0x39, 0x84, 0x30, 0x90, 0x8E, 0x55, 0x6A, + 0x6B, 0xE2, 0xDA, 0x8D, 0xB9, 0xE3, 0x01, 0x98, + 0xFD, 0x82, 0xE9, 0x84, 0x13, 0xC4, 0xE7, 0x75, + 0x2F, 0xFE, 0xCE, 0xAD, 0x8F, 0x76, 0x06, 0x1F + }, + { + 0x8D, 0x6E, 0xC2, 0xD1, 0xBB, 0xFB, 0x10, 0xA5, + 0xCE, 0xB4, 0xE3, 0x65, 0xD8, 0x2B, 0x50, 0x22, + 0x0E, 0x6A, 0xCC, 0x88, 0x96, 0xDD, 0x80, 0x4A, + 0xE5, 0xD3, 0x92, 0x35, 0x7F, 0xE0, 0xAF, 0xE5 + }, + { + 0xD4, 0x99, 0x4B, 0x7D, 0x9A, 0x44, 0x0E, 0x9F, + 0xE8, 0xF6, 0x7E, 0x86, 0xE3, 0x6E, 0x1C, 0xFC, + 0x5A, 0x7B, 0x8E, 0xED, 0x15, 0x95, 0xBE, 0x21, + 0x99, 0x9B, 0x17, 0xFE, 0xE2, 0x38, 0xEC, 0x1D + }, + { + 0x7B, 0x49, 0xD9, 0x86, 0xE1, 0x06, 0xDE, 0x57, + 0x79, 0x5C, 0x9B, 0x74, 0xAF, 0xAC, 0xE6, 0x9E, + 0xC0, 0xC1, 0xF7, 0x5D, 0xFD, 0x64, 0xBC, 0xC6, + 0x2F, 0x20, 0x10, 0x37, 0x8A, 0x70, 0xE5, 0xF0 + }, + { + 0x11, 0x07, 0xEC, 0x30, 0x7C, 0xFD, 0xC8, 0x74, + 0xB7, 0xAC, 0xB7, 0xD2, 0xC9, 0x2B, 0xC8, 0xDF, + 0x79, 0xBE, 0x61, 0x5B, 0xAA, 0x75, 0xE1, 0x11, + 0x24, 0xDD, 0xC6, 0xD8, 0x49, 0x95, 0x6F, 0x68 + }, + { + 0x90, 0x90, 0x37, 0xE3, 0x5D, 0xA4, 0x45, 0x2E, + 0xDD, 0xE2, 0x83, 0x6B, 0x38, 0x8E, 0x48, 0x47, + 0xE5, 0xAD, 0x8F, 0xC8, 0x5E, 0xC6, 0xB2, 0xAF, + 0xAC, 0x12, 0x0A, 0x64, 0x20, 0xC8, 0x17, 0x2E + }, + { + 0x5D, 0x44, 0xA2, 0xDC, 0x5D, 0x05, 0xF6, 0xB3, + 0x91, 0x45, 0x90, 0xBE, 0xF7, 0x90, 0x97, 0x0B, + 0x5F, 0x74, 0x44, 0xDF, 0x55, 0x35, 0x8D, 0x56, + 0x6E, 0xAA, 0xD7, 0x99, 0xFE, 0x30, 0xDF, 0xCF + }, + { + 0x93, 0x9F, 0xEA, 0x98, 0xB8, 0x4A, 0xF6, 0xDD, + 0x1A, 0xC2, 0x11, 0x65, 0xA6, 0x39, 0x11, 0x4C, + 0xEF, 0xD9, 0xAC, 0x7E, 0xE7, 0xEF, 0x79, 0x07, + 0xE1, 0xF1, 0x0F, 0x10, 0xD0, 0xC4, 0xF0, 0xB4 + }, + { + 0x0D, 0x62, 0x08, 0x6F, 0x71, 0xE7, 0x24, 0x57, + 0x2F, 0xB0, 0x5E, 0x50, 0x58, 0xF7, 0x7B, 0x2B, + 0x26, 0x2A, 0x22, 0x5A, 0x15, 0xE5, 0x4C, 0xF4, + 0x94, 0xF0, 0x14, 0x60, 0x01, 0x91, 0xC8, 0xEA + }, + { + 0xBA, 0x55, 0x39, 0x92, 0xE6, 0xC9, 0xC6, 0xF8, + 0x2A, 0xC2, 0xEE, 0x3B, 0x32, 0xF6, 0x84, 0xE6, + 0x13, 0x63, 0x9D, 0x31, 0x84, 0xA6, 0x88, 0xAF, + 0x56, 0xEC, 0x6E, 0xB7, 0x2C, 0x2A, 0x0F, 0xD3 + }, + { + 0xC9, 0x9E, 0x25, 0xC4, 0x0A, 0xAA, 0x8C, 0x31, + 0xC9, 0x45, 0x4A, 0x6D, 0x44, 0x43, 0xAE, 0xBE, + 0xB8, 0x82, 0xD0, 0x05, 0x0C, 0x99, 0xB4, 0xCE, + 0x41, 0x3D, 0xAB, 0x4F, 0x1A, 0xAA, 0x1A, 0xE8 + }, + { + 0xB6, 0x8E, 0x18, 0x4A, 0x9D, 0xCC, 0x75, 0x90, + 0xAF, 0x0E, 0xE4, 0x35, 0xF9, 0xD9, 0x19, 0x78, + 0x92, 0xF8, 0xE0, 0x92, 0x03, 0xE9, 0x15, 0x75, + 0x5C, 0x04, 0x34, 0x7B, 0xDC, 0x37, 0xF3, 0x7E + }, + { + 0x99, 0xF6, 0x98, 0x44, 0x17, 0x47, 0x18, 0xD8, + 0x8D, 0x2C, 0x70, 0xD3, 0xBB, 0x3E, 0xE6, 0xDC, + 0x5B, 0xC4, 0x90, 0xD8, 0x36, 0xAF, 0x88, 0x62, + 0xF4, 0xDE, 0x19, 0xED, 0x06, 0x1C, 0x0B, 0xA7 + }, + { + 0xCC, 0xFA, 0x72, 0xF8, 0xE4, 0xC2, 0x0A, 0x8B, + 0x8D, 0x61, 0xA4, 0x32, 0x6F, 0xC8, 0x59, 0x07, + 0xF8, 0xC7, 0x8F, 0x01, 0x03, 0x54, 0x1F, 0xDE, + 0xB7, 0x16, 0xF9, 0xD2, 0x9F, 0xD5, 0x06, 0xDA + }, + { + 0x7C, 0x80, 0x0A, 0x0B, 0x92, 0x0D, 0x92, 0x6A, + 0x7C, 0x0E, 0x3F, 0xD3, 0xE1, 0x5E, 0x3F, 0x8A, + 0xFC, 0xCE, 0x50, 0x74, 0xAB, 0xA0, 0xB0, 0x27, + 0x42, 0xD2, 0x1D, 0xF7, 0x4E, 0xBD, 0x78, 0xD0 + }, + { + 0xCA, 0xB0, 0x24, 0x59, 0xF0, 0x10, 0x2F, 0xB2, + 0xA9, 0xED, 0xFD, 0x79, 0xD7, 0x46, 0x71, 0xC3, + 0x59, 0x84, 0x36, 0x30, 0x44, 0x8F, 0xD8, 0x7A, + 0x17, 0xBD, 0x04, 0xCD, 0xD6, 0x50, 0xA0, 0xBD + }, + { + 0xF1, 0x2D, 0xBA, 0x08, 0xF3, 0xEC, 0x90, 0x9F, + 0x99, 0xEF, 0x63, 0xB6, 0x2A, 0x25, 0x29, 0xA1, + 0x7D, 0x17, 0xF2, 0x9F, 0x49, 0xB6, 0x47, 0x21, + 0xAF, 0x11, 0x1B, 0xD0, 0xFB, 0x8E, 0xA4, 0x25 + }, + { + 0x15, 0x23, 0x08, 0x98, 0x37, 0xB6, 0x2D, 0x46, + 0x8F, 0x86, 0x5A, 0x1E, 0xE3, 0x14, 0x82, 0xCA, + 0x4A, 0x15, 0xD5, 0x7E, 0xBF, 0x29, 0xE2, 0xB6, + 0x3A, 0x3B, 0xC6, 0xF5, 0xFD, 0x75, 0x98, 0x8C + }, + { + 0xA9, 0x4C, 0x80, 0x46, 0x1A, 0x60, 0x9C, 0x66, + 0x50, 0x7B, 0xC8, 0x47, 0x72, 0xFD, 0x71, 0x92, + 0x30, 0xEB, 0x44, 0xAF, 0x71, 0xA5, 0x64, 0x13, + 0xC9, 0x17, 0xD4, 0x38, 0xD8, 0xA6, 0x34, 0xA8 + }, + { + 0xF3, 0x6E, 0xDE, 0x43, 0xA9, 0x18, 0x66, 0xE4, + 0xE6, 0xCE, 0x26, 0x73, 0x7D, 0xFF, 0x80, 0x3B, + 0xF1, 0xBD, 0xB3, 0xEE, 0x8C, 0xD7, 0x85, 0xF9, + 0xD1, 0x67, 0x9E, 0x49, 0xD6, 0xAD, 0x4D, 0x5E + }, + { + 0x87, 0x53, 0x95, 0xAF, 0x26, 0xCF, 0xF2, 0x96, + 0xF9, 0x3F, 0x06, 0xE4, 0x11, 0x0A, 0x8A, 0xB4, + 0x80, 0xCB, 0x3D, 0x50, 0x88, 0xD4, 0x68, 0xCC, + 0xEB, 0x1F, 0x94, 0xF3, 0x54, 0x33, 0xE1, 0x14 + }, + { + 0x72, 0x8F, 0x16, 0x8E, 0x69, 0xF6, 0x1A, 0x68, + 0xA1, 0x5E, 0x9F, 0xFD, 0xDA, 0x4C, 0x62, 0x1E, + 0x34, 0xBE, 0x62, 0xD6, 0x9B, 0xE7, 0xF3, 0x61, + 0x88, 0xF6, 0x6A, 0xFB, 0x6B, 0x86, 0x70, 0x58 + }, + { + 0x69, 0x01, 0x07, 0x47, 0xF6, 0x5C, 0xF2, 0xF4, + 0x5C, 0xF0, 0x2F, 0x9D, 0x71, 0x7E, 0xB9, 0x89, + 0x7C, 0xC5, 0x1D, 0x6D, 0x73, 0xCF, 0x9E, 0xDF, + 0x7B, 0x72, 0x3A, 0x1A, 0xF5, 0xB1, 0xDD, 0x36 + }, + { + 0xCD, 0x9B, 0xD7, 0xFB, 0xE8, 0x12, 0xDB, 0x78, + 0x07, 0x0B, 0x71, 0x43, 0x22, 0x83, 0x1D, 0x07, + 0x99, 0x34, 0xE1, 0xE6, 0x33, 0xD5, 0xE6, 0x8F, + 0x52, 0xA1, 0xF0, 0x17, 0x0B, 0x83, 0x06, 0xB3 + }, + { + 0xCB, 0xD6, 0x84, 0x92, 0x33, 0xE1, 0x93, 0x7E, + 0xDC, 0xB9, 0xE3, 0xFE, 0x0A, 0x0D, 0xD1, 0x36, + 0x02, 0x0B, 0x7A, 0x6C, 0x9F, 0xBE, 0xEA, 0x62, + 0x3C, 0x6E, 0x95, 0xD2, 0xEC, 0x4F, 0x9A, 0xB7 + }, + { + 0x2B, 0xCC, 0xA5, 0xDB, 0x4C, 0x7A, 0x5F, 0xA7, + 0xEA, 0xEE, 0x59, 0x4F, 0xB9, 0xD0, 0xA6, 0x06, + 0x30, 0x87, 0x5D, 0x87, 0x81, 0x21, 0x40, 0x09, + 0x38, 0x98, 0x83, 0xAB, 0x68, 0x43, 0x6B, 0xBC + }, + { + 0xBC, 0xF1, 0x80, 0xB6, 0x98, 0x30, 0xD2, 0x3F, + 0xC3, 0x52, 0x35, 0x39, 0x0B, 0xAE, 0xCF, 0xC6, + 0xAF, 0xB6, 0x88, 0xA6, 0xC6, 0x03, 0xE6, 0x35, + 0xD5, 0x29, 0x54, 0xF4, 0xBB, 0x20, 0xF9, 0xA8 + }, + { + 0x72, 0x85, 0xBC, 0x8D, 0x04, 0xC7, 0x88, 0x76, + 0xEB, 0x43, 0xAC, 0x5E, 0xC7, 0xF3, 0x54, 0xB7, + 0x0C, 0xC3, 0x0F, 0xFA, 0xBF, 0xA0, 0xC9, 0x4A, + 0xAE, 0x26, 0xF7, 0xA6, 0x1D, 0xFB, 0xA0, 0xA3 + }, + { + 0x09, 0xA1, 0xC8, 0x46, 0x08, 0xDA, 0x10, 0x5F, + 0xAD, 0x8A, 0xE0, 0xD3, 0x89, 0xE2, 0x52, 0xC7, + 0xE2, 0x50, 0xB0, 0x9F, 0xBA, 0x82, 0x18, 0x30, + 0x08, 0x54, 0xF5, 0xE4, 0x8D, 0x3E, 0x92, 0xAC + }, + { + 0xDA, 0x34, 0x13, 0x31, 0x1D, 0xF6, 0xBD, 0x49, + 0x8D, 0x37, 0xF0, 0x5B, 0x2A, 0x80, 0x88, 0x2C, + 0x91, 0xD3, 0x49, 0xB1, 0x97, 0x4A, 0x2B, 0x10, + 0x65, 0xD4, 0x58, 0x7B, 0xF4, 0x55, 0x61, 0x89 + }, + { + 0xAE, 0x96, 0xCC, 0x61, 0x34, 0x69, 0xFF, 0x30, + 0xE9, 0xF1, 0xC1, 0xC5, 0x75, 0x58, 0x2F, 0x7A, + 0x30, 0x2B, 0x6C, 0xA3, 0x15, 0x17, 0x52, 0xC9, + 0xA0, 0xC3, 0xBD, 0xAF, 0x2D, 0x62, 0x9D, 0x73 + }, + { + 0x7C, 0x3D, 0xDF, 0xC4, 0x11, 0xA4, 0xB3, 0xB8, + 0x17, 0x12, 0x9C, 0xFB, 0xAB, 0xC0, 0x0F, 0xB0, + 0xA1, 0x7E, 0xBB, 0x0E, 0x5A, 0xF0, 0x3A, 0x03, + 0x25, 0x5B, 0xDB, 0xBF, 0x64, 0x03, 0x1E, 0x55 + }, + { + 0xBA, 0x94, 0x66, 0xF7, 0x52, 0x2D, 0xE4, 0x62, + 0xD8, 0xE9, 0x8C, 0x17, 0xF6, 0x54, 0x2C, 0x4F, + 0x13, 0x4E, 0x2B, 0xA6, 0xC7, 0x16, 0x77, 0x5D, + 0xBD, 0x84, 0x33, 0x21, 0xC4, 0x9C, 0xAF, 0x35 + }, + { + 0x33, 0x7F, 0xC9, 0xA5, 0xD3, 0x48, 0xC0, 0x1B, + 0x83, 0x7E, 0xD5, 0xE9, 0xB6, 0x1D, 0x72, 0x31, + 0x18, 0x81, 0x30, 0xA7, 0x5C, 0x6B, 0x82, 0x3B, + 0xEF, 0x53, 0xA5, 0x43, 0x63, 0x8D, 0xF7, 0x59 + }, + { + 0xBD, 0x23, 0xBD, 0xC5, 0xE9, 0x60, 0xFE, 0xC9, + 0xB6, 0x1A, 0x13, 0xBE, 0x12, 0x92, 0x39, 0xD4, + 0x5A, 0x01, 0x8E, 0x14, 0xD4, 0xA7, 0xA6, 0x86, + 0xD3, 0xF7, 0x63, 0x77, 0xEF, 0x68, 0x0D, 0x2A + }, + { + 0xF6, 0x09, 0xE8, 0x34, 0xD2, 0x0A, 0x50, 0xEC, + 0xEF, 0x89, 0x46, 0x7A, 0x79, 0x72, 0x5C, 0x1E, + 0x48, 0x76, 0x47, 0x7B, 0x84, 0x5F, 0x00, 0xE4, + 0x3E, 0x9E, 0x70, 0xD1, 0xDA, 0xFD, 0xB3, 0xE3 + }, + { + 0x54, 0xC6, 0xC6, 0x91, 0x77, 0x15, 0x4F, 0x04, + 0x10, 0xAB, 0x7D, 0x76, 0x58, 0xC0, 0xE5, 0xC3, + 0x18, 0x18, 0x3F, 0xE1, 0x63, 0x2E, 0x85, 0x3A, + 0x64, 0xAD, 0x0E, 0x49, 0x97, 0x54, 0x0D, 0xCD + }, + { + 0xDF, 0xE5, 0x5D, 0xCF, 0x77, 0xCC, 0x08, 0x47, + 0xCD, 0x9E, 0x53, 0xA1, 0xA7, 0xCB, 0x51, 0xC6, + 0xC0, 0xCF, 0xE2, 0x7E, 0x62, 0x41, 0x9F, 0xCE, + 0xD5, 0x1E, 0xC9, 0x9F, 0xA9, 0x04, 0x91, 0x79 + }, + { + 0x96, 0x81, 0xC6, 0xF5, 0x72, 0xAF, 0x13, 0xC2, + 0x9C, 0x3D, 0x68, 0x10, 0xB2, 0xDF, 0x5E, 0xAB, + 0x61, 0x18, 0xDE, 0x06, 0x03, 0x5E, 0xFE, 0x10, + 0x05, 0x86, 0x22, 0x40, 0x49, 0x52, 0x04, 0x9F + }, + { + 0x2D, 0xE7, 0xFD, 0x9E, 0xB8, 0xCC, 0x3E, 0x80, + 0x0B, 0xA0, 0x61, 0x80, 0x82, 0x86, 0xEF, 0x8C, + 0x1A, 0xE2, 0x1A, 0x9A, 0xC6, 0x20, 0x33, 0x2A, + 0xD8, 0x93, 0x03, 0x57, 0xCC, 0x34, 0x08, 0xF4 + }, + { + 0xBA, 0x1F, 0xBE, 0xE6, 0x47, 0x43, 0x65, 0x27, + 0xB9, 0x15, 0xD7, 0x30, 0xC5, 0x76, 0x53, 0x88, + 0x1A, 0xB7, 0x44, 0xA5, 0xA6, 0x2C, 0xB5, 0x43, + 0xA2, 0xDC, 0x0C, 0x17, 0xFE, 0x1F, 0x32, 0x23 + }, + { + 0x7C, 0xC3, 0xC0, 0xF5, 0x1A, 0x97, 0xC5, 0x70, + 0x60, 0x53, 0xD1, 0x9E, 0x8F, 0x9F, 0xE0, 0x2D, + 0x20, 0x02, 0xD6, 0xC1, 0xD2, 0x87, 0x24, 0x82, + 0x68, 0x0B, 0xDB, 0x6C, 0xFF, 0xBC, 0x4B, 0xC7 + }, + { + 0x1C, 0x8F, 0x01, 0x57, 0xB3, 0x32, 0xC1, 0xC3, + 0x40, 0x40, 0x50, 0xBE, 0x18, 0x3B, 0xDC, 0xF6, + 0x43, 0xCB, 0xB4, 0xC6, 0xB9, 0x91, 0x1A, 0x1F, + 0xD9, 0x7F, 0x7C, 0x0B, 0x22, 0x16, 0x9B, 0xFA + }, + { + 0xD5, 0x38, 0x4B, 0xB9, 0xA9, 0x98, 0xE6, 0x7A, + 0x7B, 0x44, 0x79, 0x7C, 0xF6, 0x57, 0xC3, 0x72, + 0x29, 0x15, 0x11, 0x50, 0x93, 0xC1, 0x29, 0x34, + 0xEF, 0x51, 0xA5, 0x4F, 0xD4, 0x69, 0xF8, 0x68 + }, + { + 0x6F, 0x7D, 0xCB, 0xB1, 0xBA, 0x13, 0x65, 0x9E, + 0x3D, 0x80, 0x45, 0xBA, 0xD7, 0x1F, 0xF3, 0xC9, + 0x80, 0xCE, 0x9D, 0x05, 0xB9, 0xEF, 0x19, 0x0C, + 0x90, 0x61, 0x47, 0xC3, 0xC4, 0x83, 0x33, 0x40 + }, + { + 0x32, 0xEC, 0xF0, 0x17, 0x96, 0xC2, 0xAE, 0xFB, + 0x54, 0xA7, 0x37, 0xC7, 0x25, 0x31, 0x26, 0xD2, + 0x09, 0x83, 0x6D, 0x60, 0xB3, 0xFF, 0xDB, 0xB6, + 0x66, 0x56, 0x88, 0x84, 0x81, 0x82, 0x32, 0xC1 + }, + { + 0x9F, 0x83, 0x0E, 0x4F, 0x2C, 0x2D, 0x89, 0x6B, + 0x4B, 0xFC, 0x7D, 0x0B, 0x21, 0x8A, 0xF9, 0x4E, + 0xE4, 0x37, 0x14, 0x00, 0x74, 0x8B, 0xD7, 0x42, + 0x72, 0xDA, 0x2C, 0x73, 0x24, 0xCA, 0x8A, 0x61 + }, + { + 0x83, 0xBA, 0x6C, 0xC6, 0xD0, 0x6E, 0x25, 0xF8, + 0x78, 0xF2, 0x2C, 0x15, 0xC3, 0xEA, 0xAB, 0xCE, + 0xE7, 0xD8, 0xA9, 0xB8, 0x0A, 0xAE, 0x8A, 0x6C, + 0x4B, 0xA6, 0x5C, 0x1B, 0xE7, 0xFC, 0x74, 0x04 + }, + { + 0x70, 0x51, 0xBD, 0x29, 0xCE, 0x82, 0x5D, 0x0D, + 0x0D, 0x83, 0xF0, 0x96, 0xFC, 0xF7, 0xF8, 0xC3, + 0x48, 0xCE, 0x36, 0xB3, 0x40, 0x04, 0xE1, 0xDF, + 0xAB, 0xBF, 0x64, 0x9A, 0x9C, 0x3D, 0x13, 0xA9 + }, + { + 0xFC, 0x42, 0xF3, 0xED, 0xCE, 0xEA, 0xF4, 0x32, + 0x28, 0x0A, 0x6D, 0xCB, 0x7F, 0xC4, 0xF8, 0x04, + 0x52, 0xC6, 0x98, 0x41, 0x40, 0xF9, 0x29, 0x25, + 0xF9, 0xA6, 0x73, 0x38, 0x31, 0xEA, 0xA2, 0xF4 + }, + { + 0x82, 0x0F, 0x29, 0x11, 0x82, 0x6E, 0x1D, 0xC9, + 0x53, 0x4A, 0xF6, 0x64, 0xE9, 0x2F, 0x2B, 0xD4, + 0x91, 0xA3, 0xBE, 0x72, 0x49, 0xDD, 0xC0, 0x72, + 0xD0, 0x40, 0x90, 0x32, 0xF9, 0xFF, 0x30, 0x15 + }, + { + 0x00, 0xFE, 0x1F, 0x87, 0x93, 0x8B, 0x0C, 0x4E, + 0xBA, 0x4D, 0x2B, 0x82, 0xB1, 0x60, 0x89, 0x19, + 0x7D, 0x64, 0x8F, 0x3D, 0x6F, 0xF3, 0xC3, 0x8F, + 0x7D, 0xBB, 0x14, 0xC3, 0xC2, 0x40, 0x17, 0x2C + }, + { + 0x37, 0x73, 0x60, 0x5B, 0x6B, 0x4E, 0x71, 0x50, + 0x0C, 0xC0, 0x29, 0x66, 0x29, 0xFB, 0xB5, 0x3D, + 0xF8, 0x66, 0xA7, 0x6A, 0xA5, 0xD3, 0x2D, 0x4F, + 0x1E, 0xE3, 0xDA, 0x9E, 0x36, 0x34, 0xF1, 0x17 + }, + { + 0x6E, 0x2E, 0x34, 0x59, 0xBB, 0xDE, 0x09, 0x3F, + 0x3D, 0xC3, 0x1C, 0x94, 0xDA, 0xD5, 0xF5, 0xFF, + 0xE4, 0x9A, 0xD4, 0x2B, 0x8B, 0x02, 0x6E, 0x8F, + 0xCC, 0x38, 0x0F, 0x37, 0x64, 0xB9, 0x05, 0x97 + }, + { + 0xC4, 0x21, 0x65, 0xDC, 0xA4, 0xCC, 0x31, 0x1B, + 0x70, 0x2B, 0x55, 0x93, 0x99, 0x94, 0x5A, 0x61, + 0x09, 0x5F, 0x07, 0xD7, 0x05, 0x26, 0xC7, 0x9D, + 0xBC, 0x07, 0xF6, 0xAB, 0x0D, 0x39, 0x55, 0x32 + }, + { + 0x26, 0x96, 0x72, 0x41, 0xBC, 0x46, 0x9F, 0xC1, + 0xD3, 0xF3, 0x37, 0x5F, 0xCD, 0x9C, 0xC0, 0xF7, + 0x9D, 0x20, 0x70, 0xB2, 0x90, 0x33, 0xBB, 0x9E, + 0x5C, 0xFA, 0x42, 0x34, 0x0E, 0xE8, 0x1C, 0xAA + }, + { + 0x09, 0xA9, 0xBF, 0x34, 0x63, 0x71, 0x9B, 0x11, + 0xCA, 0x4A, 0xE6, 0xA4, 0x3F, 0xFA, 0x46, 0xD3, + 0xD0, 0xB9, 0x7E, 0x88, 0x07, 0x15, 0xF7, 0x08, + 0x76, 0xCC, 0x32, 0x92, 0xAA, 0xE5, 0x85, 0x04 + }, + { + 0x3D, 0xDF, 0x7B, 0x05, 0xF8, 0x81, 0xEF, 0x54, + 0x5A, 0xD5, 0xEF, 0xC2, 0x2A, 0x38, 0x80, 0x9E, + 0x12, 0xAF, 0x04, 0x8A, 0x49, 0xC1, 0xA1, 0x0E, + 0x89, 0xFF, 0x06, 0x74, 0x51, 0x40, 0x09, 0xE8 + }, + { + 0xBF, 0x52, 0xC4, 0xAF, 0x18, 0xAC, 0xA6, 0xBF, + 0x7D, 0x0F, 0xD8, 0xA2, 0x0D, 0xBE, 0x83, 0xB0, + 0x96, 0x4E, 0x1D, 0x0F, 0x8A, 0xBD, 0x5B, 0xB4, + 0xBD, 0x95, 0xF2, 0x72, 0x6B, 0x07, 0x47, 0x1A + }, + { + 0x90, 0x9A, 0x3D, 0x55, 0xEF, 0x8A, 0xF3, 0xBE, + 0x73, 0x58, 0x0D, 0x22, 0x6C, 0xA7, 0x38, 0x05, + 0x13, 0xD4, 0x19, 0x21, 0x3C, 0xA0, 0x0E, 0x4F, + 0xFB, 0x09, 0xBE, 0xE9, 0x72, 0xE3, 0xF6, 0x03 + }, + { + 0xF7, 0x07, 0x65, 0xFD, 0xBE, 0xE0, 0xDA, 0x6B, + 0x2F, 0xEA, 0xA7, 0x4D, 0x48, 0x51, 0x02, 0xE8, + 0xF1, 0xE5, 0x36, 0x3C, 0x18, 0x73, 0x1E, 0xE7, + 0xE9, 0xFB, 0xE2, 0x58, 0x08, 0x32, 0x26, 0x7E + }, + { + 0x2D, 0xB2, 0x43, 0xEF, 0x74, 0x61, 0xB0, 0x22, + 0x3A, 0x3C, 0x75, 0xE2, 0x0C, 0x7B, 0xF6, 0xB3, + 0x9C, 0xDC, 0x2E, 0x0B, 0xD2, 0x3C, 0x00, 0x35, + 0x5F, 0x13, 0x1B, 0x02, 0x10, 0xB7, 0x17, 0x1E + }, + { + 0xD1, 0xF7, 0x5F, 0xA6, 0xFD, 0xDF, 0x6A, 0xD9, + 0x20, 0x21, 0x01, 0x31, 0xF3, 0x37, 0x88, 0xFE, + 0x4E, 0x56, 0x62, 0x44, 0x2F, 0xF8, 0xDA, 0xFE, + 0x3A, 0xA8, 0x0F, 0x4C, 0x79, 0x82, 0x7D, 0x81 + }, + { + 0x0C, 0x49, 0x6B, 0x97, 0xD1, 0xCC, 0x14, 0xA4, + 0xCA, 0x06, 0x9A, 0xC3, 0x68, 0x92, 0x81, 0x54, + 0xB1, 0x01, 0xDD, 0x9B, 0x2F, 0x63, 0x79, 0x84, + 0x20, 0x92, 0xE0, 0xEF, 0x94, 0x15, 0x23, 0xD3 + }, + { + 0xEF, 0x8A, 0x6B, 0x48, 0xFF, 0x48, 0x26, 0x33, + 0x73, 0x20, 0x51, 0xA2, 0x40, 0x82, 0x93, 0xCE, + 0x74, 0x36, 0x3D, 0x8A, 0x3D, 0x8E, 0x35, 0x11, + 0x39, 0x6F, 0x10, 0x2C, 0x79, 0xD5, 0x51, 0xC0 + }, + { + 0xFC, 0x00, 0x97, 0x00, 0x4D, 0x55, 0x22, 0x2E, + 0xE0, 0x37, 0x59, 0x72, 0x54, 0x81, 0x9D, 0x66, + 0xB1, 0xAE, 0x8A, 0xE5, 0x3A, 0x8C, 0xE1, 0x7F, + 0x8F, 0x02, 0x18, 0x81, 0x87, 0x75, 0xEE, 0x91 + }, + { + 0x5F, 0x1B, 0x14, 0x59, 0xBE, 0x86, 0xB8, 0x6C, + 0x52, 0x86, 0x7C, 0x7C, 0x1B, 0x57, 0xEA, 0xFC, + 0xF6, 0x38, 0x2D, 0x99, 0x4A, 0xB2, 0x91, 0xA1, + 0x22, 0x55, 0x8F, 0xAF, 0x72, 0xD6, 0xC9, 0x23 + }, + { + 0xBE, 0x95, 0x76, 0x5D, 0x33, 0x6C, 0xB7, 0x9C, + 0xB9, 0xAD, 0x70, 0xA9, 0xE6, 0x33, 0x8F, 0x81, + 0xC4, 0x22, 0xF0, 0x5E, 0xE4, 0x61, 0x66, 0xB7, + 0xB6, 0x8C, 0xDE, 0x00, 0x85, 0x95, 0xA7, 0x5D + }, + { + 0x0D, 0x6D, 0xED, 0xF9, 0x0D, 0xF4, 0x0D, 0x24, + 0xCE, 0x52, 0xAB, 0x82, 0xB3, 0x39, 0x12, 0x67, + 0xDF, 0xC9, 0x94, 0xC8, 0x67, 0x50, 0x29, 0x47, + 0xA6, 0xBD, 0x31, 0xFE, 0x6C, 0x5F, 0x66, 0xA5 + }, + { + 0x90, 0xF1, 0x8F, 0x20, 0xD9, 0x2E, 0xE2, 0x95, + 0xAF, 0x28, 0xE9, 0x32, 0x3D, 0xD3, 0x10, 0x24, + 0x44, 0x87, 0x1E, 0x7C, 0xBA, 0xC5, 0xC5, 0xEC, + 0x17, 0xD0, 0x97, 0xDC, 0x29, 0x80, 0x02, 0xC6 + }, + { + 0xFD, 0x74, 0x04, 0x08, 0x30, 0xC1, 0x89, 0x4E, + 0xA1, 0xF1, 0xF1, 0x17, 0x26, 0x30, 0x2A, 0x13, + 0xC7, 0xFB, 0x2A, 0xED, 0x33, 0x3F, 0x9D, 0x6F, + 0x1D, 0x10, 0x8C, 0x42, 0xEC, 0x90, 0xE2, 0xBD + }, + { + 0x5C, 0xC8, 0xB8, 0xCA, 0x2E, 0xB1, 0x3A, 0x26, + 0xBF, 0xAD, 0x80, 0x4A, 0x7A, 0x9E, 0x67, 0x9C, + 0x28, 0x8A, 0x2E, 0x12, 0x59, 0x96, 0x6F, 0x05, + 0xC1, 0xEC, 0xFE, 0xF1, 0xE3, 0xE2, 0x29, 0x9A + }, + { + 0xD9, 0x84, 0xE3, 0x7B, 0x90, 0x69, 0x1A, 0x19, + 0xCA, 0x3C, 0x90, 0x64, 0x27, 0x6B, 0x2D, 0x90, + 0x40, 0x86, 0x02, 0x6C, 0xB5, 0xF6, 0x05, 0x0C, + 0xAB, 0x24, 0xDC, 0x14, 0xCF, 0xAF, 0x94, 0x9F + }, + { + 0x0B, 0x80, 0xBE, 0xC0, 0x77, 0x9D, 0x8E, 0x9A, + 0x8E, 0x13, 0x1B, 0xC2, 0xE1, 0x0D, 0xCA, 0x31, + 0xA3, 0x26, 0x8A, 0x59, 0xC1, 0x5A, 0x2E, 0xD4, + 0x2B, 0x86, 0x20, 0x5B, 0x44, 0x09, 0x7C, 0xA5 + }, + { + 0xAF, 0x75, 0x8C, 0xCD, 0x85, 0xB7, 0x11, 0x5D, + 0xA5, 0xA0, 0x4A, 0xFB, 0xD8, 0xFD, 0xE6, 0x12, + 0x42, 0x3B, 0x37, 0xA2, 0x47, 0x5C, 0xE9, 0x66, + 0x4D, 0xE4, 0x2A, 0xC4, 0xAA, 0xE2, 0x4B, 0x2F + }, + { + 0x02, 0x26, 0x09, 0x83, 0xC9, 0xB8, 0xD6, 0xEF, + 0x55, 0x95, 0x73, 0x9C, 0x72, 0x7C, 0xA4, 0xC7, + 0x1B, 0xF2, 0x30, 0xED, 0x91, 0x5D, 0xA3, 0x84, + 0xAE, 0x5D, 0x34, 0x60, 0xBC, 0x20, 0x26, 0x90 + }, + { + 0xD0, 0xC0, 0xC1, 0xE0, 0x6A, 0x98, 0xD8, 0xB4, + 0xD9, 0x81, 0x57, 0x85, 0xFA, 0x1A, 0x16, 0xF0, + 0x63, 0xC5, 0xBA, 0xD7, 0x66, 0xA2, 0xF6, 0x26, + 0x09, 0xDC, 0x30, 0xB8, 0xF0, 0xF1, 0x8A, 0x18 + }, + { + 0xCA, 0x95, 0x19, 0x39, 0xF0, 0xE7, 0x93, 0x48, + 0x2A, 0x27, 0xB5, 0x0D, 0x39, 0x5E, 0x04, 0x5A, + 0x8D, 0xEE, 0x2C, 0xF0, 0x4F, 0x7E, 0x76, 0x92, + 0xDC, 0x30, 0x82, 0x1D, 0x2B, 0xD6, 0xA7, 0xA2 + }, + { + 0x66, 0x6E, 0x39, 0xA8, 0xBD, 0xDD, 0x7A, 0xFD, + 0x51, 0x74, 0x99, 0x6D, 0xCD, 0xED, 0xE6, 0x1B, + 0xF2, 0x3D, 0x67, 0x2A, 0xCA, 0xC2, 0x17, 0x8F, + 0x2E, 0x4F, 0x63, 0xAD, 0x4B, 0xBA, 0xFF, 0x8C + }, + { + 0x4B, 0xAF, 0x7F, 0x70, 0x7B, 0xA8, 0xA2, 0x0B, + 0x1C, 0x88, 0x75, 0x28, 0xF7, 0xAA, 0x76, 0x35, + 0x66, 0xA5, 0x8F, 0xE2, 0xEB, 0xFB, 0xCA, 0xC0, + 0xFB, 0x33, 0x00, 0xDC, 0x7E, 0x7D, 0xCE, 0x4E + }, + { + 0x0F, 0x60, 0x38, 0xEC, 0xD5, 0x66, 0xCB, 0x5C, + 0x8C, 0x37, 0xDF, 0xE0, 0x03, 0x45, 0x74, 0xD0, + 0x4B, 0x4B, 0x90, 0x80, 0x29, 0xF4, 0x3A, 0x45, + 0x5E, 0x2B, 0xA0, 0xAC, 0xDC, 0x37, 0xE3, 0xFE + }, + { + 0x0F, 0x32, 0x64, 0x69, 0xFB, 0xC4, 0x80, 0xE2, + 0x13, 0x32, 0xBC, 0xAC, 0xFF, 0x7C, 0xEB, 0x4A, + 0x5A, 0xB0, 0x27, 0xDF, 0x81, 0xC9, 0xDF, 0x12, + 0xB6, 0xD5, 0x29, 0xA8, 0x07, 0xA3, 0x9D, 0xD1 + }, + { + 0x58, 0xEE, 0x5C, 0x63, 0xA2, 0x0B, 0x8E, 0x86, + 0x40, 0xC9, 0x47, 0x1B, 0x50, 0xAD, 0x4D, 0xA1, + 0xD4, 0xB6, 0x9A, 0xCA, 0x4E, 0x41, 0xF6, 0xE7, + 0x77, 0x15, 0xD7, 0x06, 0xB0, 0xF0, 0xCF, 0x1D + }, + { + 0x80, 0x23, 0x64, 0xF2, 0x3C, 0x40, 0xA1, 0xA9, + 0x7A, 0x9A, 0x83, 0x81, 0x81, 0x91, 0x3D, 0x1A, + 0x5D, 0xA1, 0x35, 0x1F, 0x55, 0x5F, 0x36, 0xD0, + 0xFA, 0xCF, 0xFE, 0x7B, 0x2A, 0x1C, 0x6D, 0x3C + }, + { + 0x38, 0xFE, 0x2D, 0x6B, 0xA6, 0x04, 0xD1, 0x67, + 0x7D, 0xCD, 0x5E, 0xBA, 0x67, 0x4C, 0x34, 0x6A, + 0xBF, 0x10, 0xA1, 0x44, 0xBF, 0x3B, 0xF4, 0x93, + 0x93, 0xE7, 0x76, 0xE6, 0x0D, 0x94, 0xD7, 0x29 + }, + { + 0x8C, 0x79, 0xF4, 0x07, 0xA5, 0x43, 0x5D, 0x7E, + 0x9B, 0xD6, 0x57, 0xA0, 0x36, 0xDD, 0x27, 0x5B, + 0x85, 0xF4, 0x8E, 0xB4, 0x28, 0xAB, 0xAE, 0xAD, + 0xB4, 0x73, 0x90, 0xA6, 0xE0, 0xDF, 0xF4, 0x4A + }, + { + 0x51, 0x3A, 0x10, 0xF5, 0x89, 0x08, 0xA8, 0xE6, + 0x88, 0x18, 0x32, 0xCE, 0x87, 0x8D, 0xE0, 0x1D, + 0xA2, 0x03, 0x53, 0x5C, 0x5F, 0x5D, 0x4A, 0x2A, + 0xB5, 0xCE, 0x68, 0xA9, 0x5F, 0x45, 0x2F, 0x74 + }, + { + 0x14, 0x1F, 0x81, 0x6E, 0x4C, 0xA2, 0x13, 0x54, + 0x4C, 0xE3, 0xB1, 0xC5, 0x87, 0xD2, 0x9C, 0xD2, + 0xCB, 0x9E, 0x09, 0x41, 0x53, 0x85, 0x5D, 0x95, + 0xF3, 0x37, 0x20, 0x5F, 0xFB, 0x88, 0x13, 0xCB + }, + { + 0x47, 0xF6, 0x5C, 0xE2, 0x84, 0x58, 0x5D, 0x47, + 0x58, 0xEB, 0x23, 0xD6, 0x12, 0x5D, 0xDA, 0x32, + 0x5B, 0xA1, 0xBC, 0x13, 0x79, 0xB7, 0xC7, 0x3E, + 0x1E, 0xC9, 0xAA, 0x5B, 0xEA, 0x3A, 0x6C, 0xD2 + }, + { + 0x15, 0x2E, 0xBB, 0x4D, 0xDF, 0x1A, 0xEA, 0x28, + 0xB7, 0x64, 0x51, 0x77, 0xAE, 0x7D, 0x4D, 0x17, + 0x04, 0xB5, 0x78, 0x63, 0x49, 0x0F, 0x4D, 0xB7, + 0xE6, 0x6C, 0x7C, 0x51, 0xE9, 0xF6, 0x0E, 0x49 + }, + { + 0xA0, 0x53, 0x51, 0x79, 0xCA, 0x95, 0xCE, 0x29, + 0x72, 0x7A, 0x47, 0x5A, 0x47, 0x08, 0xC7, 0xD5, + 0x9B, 0x5E, 0x34, 0xFB, 0x2F, 0x46, 0x60, 0x1E, + 0x1B, 0xFA, 0x99, 0x18, 0x48, 0x1B, 0xBB, 0xC5 + }, + { + 0xD6, 0x93, 0xC4, 0xFD, 0xDC, 0x62, 0xE6, 0x5A, + 0x2C, 0x51, 0xC8, 0x27, 0x6E, 0x97, 0x79, 0x8F, + 0xEE, 0xB7, 0x85, 0x5C, 0x18, 0x35, 0xAE, 0x00, + 0xA4, 0xB0, 0x6D, 0xFC, 0x22, 0x0C, 0x11, 0x0E + }, + { + 0x57, 0xDF, 0x76, 0xC8, 0x3F, 0x67, 0xC8, 0xD6, + 0xAA, 0xD1, 0x1D, 0x0A, 0x58, 0x80, 0xF8, 0x95, + 0xE6, 0xE3, 0x07, 0x25, 0xF4, 0x39, 0xA7, 0xBB, + 0x8D, 0xE9, 0x97, 0x07, 0x7E, 0x90, 0xE0, 0x35 + }, + { + 0x76, 0x16, 0xAF, 0xE9, 0x7D, 0x0D, 0xF9, 0x57, + 0x2A, 0x0F, 0x88, 0xEF, 0x2C, 0x6A, 0x59, 0x63, + 0x25, 0xD2, 0x3B, 0x25, 0xB4, 0x85, 0x18, 0x1F, + 0xBF, 0x2A, 0x5A, 0x62, 0xBF, 0xED, 0x4D, 0xDE + }, + { + 0x68, 0x0B, 0xA3, 0x42, 0xAE, 0x59, 0x45, 0x5D, + 0x14, 0x61, 0xD9, 0x17, 0x37, 0x54, 0xBC, 0xF0, + 0x69, 0xD0, 0x6A, 0x92, 0xE3, 0x05, 0x82, 0xDE, + 0x04, 0xCC, 0x35, 0x6C, 0x52, 0x0A, 0xCC, 0x1A + }, + { + 0x86, 0xDD, 0xC6, 0x28, 0x5C, 0x37, 0xA5, 0x44, + 0x59, 0x7B, 0x0E, 0x92, 0xE3, 0x3B, 0xB5, 0x95, + 0x8E, 0xA2, 0x01, 0x53, 0xA1, 0x55, 0x70, 0x8A, + 0x1A, 0xF5, 0xED, 0x53, 0x28, 0x57, 0x08, 0x4D + }, + { + 0x37, 0xCC, 0x4B, 0x1E, 0x32, 0x97, 0x32, 0xF8, + 0x11, 0xDC, 0x60, 0x55, 0x54, 0xFF, 0xB5, 0xE4, + 0x27, 0xA6, 0x1F, 0xC3, 0x23, 0x8D, 0x4F, 0x24, + 0x84, 0x46, 0x2F, 0x35, 0xF5, 0xBA, 0x0B, 0x3D + }, + { + 0x44, 0x74, 0x09, 0x35, 0x27, 0x70, 0x4C, 0xF4, + 0x21, 0x97, 0xBE, 0xC6, 0xA7, 0x69, 0xDE, 0x53, + 0xAC, 0x22, 0xED, 0xF8, 0xE1, 0xF0, 0x85, 0x01, + 0x08, 0x4D, 0x22, 0x23, 0x97, 0x0D, 0x7D, 0x6D + }, + { + 0x8D, 0x04, 0x1B, 0xD6, 0x90, 0x96, 0x5F, 0x14, + 0x33, 0xDB, 0xCD, 0x6E, 0x3C, 0x4F, 0xD4, 0xBC, + 0x34, 0x7F, 0xE9, 0x79, 0xA2, 0x16, 0x00, 0xE5, + 0xC2, 0x85, 0x5D, 0x93, 0x71, 0x0B, 0x7A, 0x67 + }, + { + 0x32, 0xE2, 0xD2, 0x8F, 0xCD, 0xD9, 0xDA, 0x0E, + 0xC9, 0x42, 0xAA, 0xA6, 0x54, 0x93, 0xED, 0x40, + 0x45, 0xC2, 0x5F, 0x8E, 0xD2, 0xC8, 0x7A, 0x9D, + 0xDE, 0xA4, 0xFC, 0x9F, 0x21, 0x76, 0x71, 0x3E + }, + { + 0x95, 0x1C, 0xB5, 0x79, 0x19, 0xC3, 0x0D, 0xEB, + 0xF2, 0x78, 0x47, 0xAB, 0xC0, 0x8B, 0x40, 0x12, + 0x83, 0x78, 0xB3, 0xE4, 0x89, 0xD3, 0xFB, 0xF2, + 0xFE, 0x36, 0x94, 0x22, 0xCF, 0x6F, 0x91, 0xEE + }, + { + 0x88, 0x8C, 0x35, 0x21, 0x00, 0xAA, 0x17, 0x72, + 0xD5, 0x20, 0x97, 0xB0, 0xE2, 0xD5, 0xE3, 0x18, + 0x07, 0xF2, 0xF7, 0xD5, 0xB5, 0xE1, 0x7E, 0x5A, + 0xC6, 0x15, 0x25, 0x90, 0xA2, 0x80, 0xE6, 0xB5 + }, + { + 0x0C, 0x0D, 0x75, 0x12, 0xD2, 0xD1, 0xFB, 0xD9, + 0x96, 0x10, 0xFC, 0xB7, 0x51, 0xFA, 0xB6, 0xC1, + 0x7F, 0x78, 0x60, 0x60, 0x62, 0x4F, 0x56, 0x2E, + 0xBB, 0xFE, 0xCB, 0x16, 0xEB, 0xBB, 0x6E, 0xFD + }, + { + 0x8F, 0xB2, 0x06, 0xE0, 0xC6, 0xF1, 0xAD, 0x02, + 0x1D, 0x5C, 0x24, 0x4F, 0x80, 0xF2, 0x97, 0xAF, + 0xDB, 0x8D, 0x8C, 0x0C, 0x09, 0xE7, 0x60, 0x1E, + 0xF6, 0xBD, 0x45, 0xE8, 0x16, 0xBF, 0xC1, 0x81 + }, + { + 0xB2, 0xCB, 0xA3, 0x6B, 0x5D, 0x47, 0x46, 0xCB, + 0x72, 0xF5, 0x7C, 0x55, 0x06, 0x35, 0x7B, 0xFB, + 0xD7, 0x65, 0xEF, 0x7C, 0x83, 0xC0, 0xE7, 0x6E, + 0xEC, 0x6E, 0x59, 0xC6, 0xF3, 0x1E, 0x88, 0xBB + }, + { + 0x1F, 0x37, 0xBA, 0x51, 0x81, 0x44, 0x1A, 0x84, + 0xB4, 0x6B, 0x16, 0x02, 0x91, 0x23, 0x7D, 0xA9, + 0x4F, 0x9E, 0x25, 0xAD, 0x34, 0x8D, 0x4F, 0xE0, + 0xF0, 0x1E, 0x0A, 0x03, 0x87, 0x1C, 0x81, 0x84 + }, + { + 0x8C, 0x14, 0x22, 0x68, 0xB6, 0xFF, 0x8D, 0xC4, + 0x93, 0x7F, 0x59, 0x01, 0x73, 0x65, 0x50, 0xFF, + 0xEB, 0xC5, 0x9D, 0x21, 0x73, 0x31, 0x89, 0x66, + 0x86, 0xC4, 0x5B, 0xAD, 0x78, 0x59, 0x66, 0xA4 + }, + { + 0xA4, 0x51, 0xCA, 0x36, 0x99, 0x0F, 0x94, 0x21, + 0x67, 0x0E, 0x59, 0xAB, 0xA3, 0xD1, 0x89, 0x12, + 0xDC, 0xC0, 0x39, 0x49, 0xDC, 0x66, 0x8F, 0xAF, + 0xB3, 0xEA, 0x4F, 0xC8, 0x8A, 0x68, 0x14, 0xEA + }, + { + 0x27, 0xF1, 0x8E, 0x77, 0x1D, 0x16, 0xA1, 0xE8, + 0x7C, 0xDF, 0x6C, 0x47, 0x78, 0x25, 0x57, 0xDD, + 0x66, 0x55, 0x31, 0x6D, 0x5B, 0xB1, 0x33, 0x68, + 0xB0, 0xCF, 0x46, 0xC3, 0xEC, 0x23, 0xD8, 0x6C + }, + { + 0xF5, 0xD3, 0xB9, 0xDD, 0x94, 0x05, 0x4B, 0xBD, + 0x14, 0x76, 0x88, 0x45, 0x9D, 0x5B, 0xD4, 0xFF, + 0x06, 0xF6, 0xA1, 0x1F, 0xC4, 0x0D, 0xD0, 0xF6, + 0x40, 0x1B, 0x27, 0xDB, 0x2A, 0xB6, 0x62, 0xCF + }, + { + 0xE5, 0xA3, 0x74, 0x8D, 0x29, 0x01, 0x68, 0x13, + 0x8E, 0xD6, 0x50, 0x9C, 0x2C, 0xA9, 0x03, 0xF9, + 0xBE, 0x38, 0xB6, 0xF8, 0xF4, 0xB8, 0x59, 0xC5, + 0x22, 0x76, 0xFF, 0x6A, 0x79, 0x78, 0x55, 0x60 + }, + { + 0xD2, 0x52, 0x40, 0x4B, 0x2E, 0x8F, 0x48, 0x2D, + 0xB3, 0x7B, 0xB8, 0x81, 0x15, 0x4F, 0xA1, 0xCB, + 0x4B, 0x08, 0x67, 0x88, 0x13, 0x2A, 0x2C, 0x3F, + 0x52, 0xB8, 0x3E, 0x1D, 0x92, 0xF4, 0x45, 0x4D + }, + { + 0x0E, 0xFA, 0x2D, 0x46, 0xEE, 0x68, 0x7E, 0xB3, + 0x24, 0x03, 0xA5, 0xD4, 0xC5, 0x95, 0x82, 0x2A, + 0xD7, 0x92, 0x02, 0x80, 0xB6, 0x90, 0xB0, 0xE2, + 0x2E, 0x3E, 0xBE, 0xCB, 0x74, 0x0F, 0xAD, 0x31 + }, + { + 0x4D, 0x65, 0x99, 0x2C, 0x20, 0xFA, 0x48, 0xFE, + 0xF5, 0x72, 0x7E, 0x5D, 0x70, 0x80, 0x10, 0x49, + 0xE7, 0x87, 0x9D, 0xBF, 0x64, 0x5A, 0xFA, 0x1A, + 0xB7, 0xD5, 0x6C, 0x47, 0xA4, 0x45, 0x45, 0x34 + }, + { + 0x18, 0x25, 0x28, 0xD5, 0x19, 0x53, 0xA7, 0xD0, + 0x80, 0x57, 0x9D, 0x6D, 0xBB, 0x28, 0xF2, 0x9D, + 0xB5, 0xE3, 0xD2, 0x21, 0x24, 0xB7, 0x4F, 0x2E, + 0x8E, 0x0F, 0x44, 0x98, 0xF6, 0x42, 0x23, 0x6A + }, + { + 0x56, 0x38, 0xF9, 0x28, 0x51, 0x90, 0x65, 0x6F, + 0xAD, 0x0B, 0xB7, 0x06, 0x9F, 0x24, 0x30, 0xFA, + 0x48, 0x91, 0xF6, 0x7F, 0x81, 0xEA, 0x6D, 0x5C, + 0xE0, 0x20, 0x79, 0xBB, 0x42, 0x97, 0x5F, 0xB9 + }, + { + 0x87, 0x29, 0xB1, 0x58, 0x40, 0x30, 0x02, 0x10, + 0x36, 0x91, 0x67, 0x42, 0x91, 0xB1, 0x52, 0xBA, + 0x42, 0x9F, 0x4B, 0xBF, 0xE8, 0xFE, 0xB2, 0x07, + 0x29, 0xB0, 0xE5, 0xF6, 0x36, 0xC3, 0x82, 0xCE + }, + { + 0xD8, 0xEB, 0x10, 0xBF, 0x8D, 0xFD, 0xE0, 0x6E, + 0x79, 0x7B, 0xB9, 0x8E, 0x83, 0x48, 0xC4, 0xC5, + 0xA0, 0xDF, 0x4B, 0x48, 0x93, 0x7E, 0x55, 0x67, + 0xF4, 0x60, 0x23, 0x4C, 0xDC, 0x65, 0x6A, 0x81 + }, + { + 0x90, 0x96, 0x5F, 0x4E, 0x74, 0x7A, 0x48, 0xC1, + 0xB4, 0x65, 0xF7, 0xC6, 0xBE, 0x8F, 0xDA, 0xF0, + 0xD7, 0x45, 0x31, 0x78, 0xD1, 0x3B, 0x88, 0xD0, + 0x7F, 0x9B, 0x22, 0x8E, 0xE8, 0xC8, 0x84, 0xDA + }, + { + 0xF3, 0x3A, 0x8C, 0xFA, 0x89, 0xAE, 0xD1, 0x2D, + 0x9C, 0xAE, 0x1A, 0xC2, 0xFC, 0xF7, 0x47, 0x72, + 0x09, 0x9D, 0xCF, 0xEB, 0xA8, 0x3D, 0xF7, 0xE6, + 0x81, 0x62, 0x4D, 0x28, 0xD3, 0x18, 0xCA, 0x66 + }, + { + 0x1F, 0x7C, 0x39, 0xAB, 0x79, 0xDE, 0xF7, 0x8A, + 0x69, 0x24, 0xB1, 0x04, 0xD0, 0x86, 0x1A, 0xB6, + 0x08, 0x0C, 0x33, 0x69, 0x34, 0xEF, 0xF4, 0xF2, + 0xB3, 0x45, 0x57, 0x83, 0x0C, 0xFF, 0x5A, 0xD8 + }, + { + 0x2A, 0x71, 0x86, 0x02, 0xAA, 0x54, 0xBF, 0xEB, + 0xCC, 0x19, 0x61, 0xB4, 0xBB, 0x3F, 0x8B, 0x6E, + 0xFC, 0x5A, 0xA5, 0x74, 0xC9, 0xBA, 0x98, 0xD1, + 0x4D, 0x39, 0x3D, 0xFA, 0x36, 0xEA, 0x54, 0x48 + }, + { + 0xC5, 0x7E, 0x9E, 0xF5, 0x7D, 0x0B, 0xF2, 0xB8, + 0x48, 0x8E, 0xDD, 0x2F, 0x1A, 0x73, 0x77, 0x43, + 0xF8, 0x21, 0x34, 0x14, 0x83, 0x69, 0x20, 0xD1, + 0x84, 0x56, 0x3A, 0x25, 0xE7, 0xC9, 0x27, 0x78 + }, + { + 0xDA, 0x36, 0xD4, 0x64, 0x73, 0x6C, 0xA4, 0xB5, + 0xC2, 0xCF, 0x80, 0x69, 0x32, 0x64, 0x2F, 0x55, + 0x00, 0x21, 0x2B, 0x3C, 0xB2, 0x0A, 0xE1, 0xF5, + 0xEF, 0x50, 0x41, 0x06, 0x2F, 0xDC, 0x91, 0x44 + }, + { + 0x2B, 0x19, 0xA2, 0x02, 0x93, 0x46, 0x8A, 0x9B, + 0x18, 0x06, 0x40, 0xC6, 0x73, 0x83, 0x0F, 0x1D, + 0xF8, 0x77, 0xF2, 0xC0, 0x70, 0xC4, 0xFB, 0xE6, + 0x39, 0xBC, 0xE6, 0xC2, 0xEB, 0x61, 0x45, 0xC6 + }, + { + 0x68, 0xC1, 0x47, 0x31, 0x02, 0xE5, 0xC4, 0xA8, + 0x0E, 0x6B, 0x61, 0xC7, 0x4A, 0x81, 0x20, 0x26, + 0xC8, 0x41, 0xBC, 0x87, 0x0B, 0x1A, 0xB6, 0xAB, + 0xA5, 0x8A, 0xDD, 0xBF, 0x2B, 0x69, 0x9C, 0x7B + }, + { + 0x48, 0x1D, 0x39, 0x6E, 0x53, 0x3F, 0x7E, 0x1C, + 0x5A, 0x96, 0x63, 0xD0, 0x28, 0x52, 0x25, 0x97, + 0x68, 0x3F, 0x3F, 0x44, 0xB8, 0x05, 0xF3, 0x1F, + 0x2E, 0xA0, 0xEA, 0xAC, 0xA8, 0x12, 0xD1, 0x22 + }, + { + 0x17, 0x2C, 0x78, 0x2D, 0xB3, 0x2F, 0x17, 0x34, + 0x66, 0x76, 0x3C, 0xC7, 0xE4, 0x4D, 0xD2, 0x55, + 0x0B, 0x93, 0xA3, 0x41, 0xD3, 0xCA, 0x69, 0x93, + 0x75, 0xE0, 0x98, 0x30, 0x60, 0x4C, 0x46, 0x37 + }, + { + 0x6D, 0x11, 0x67, 0xF7, 0x6C, 0x05, 0x5D, 0xB2, + 0xD8, 0x68, 0x1D, 0xF1, 0xAB, 0x00, 0xF3, 0x4F, + 0xA8, 0x7E, 0x38, 0x76, 0xEE, 0x63, 0xFE, 0x9B, + 0x2C, 0xCB, 0xA2, 0x8C, 0x1A, 0xF4, 0xEC, 0x1E + }, + { + 0x6C, 0xDA, 0x79, 0xF6, 0xCD, 0x47, 0x36, 0x6F, + 0xBC, 0xA6, 0x83, 0x40, 0xA7, 0x58, 0xC6, 0x0C, + 0xAB, 0x2D, 0x9D, 0x9E, 0x83, 0x68, 0xD7, 0x23, + 0xFD, 0x4B, 0xD6, 0x92, 0x82, 0x77, 0x99, 0x6C + }, + { + 0x49, 0x7C, 0x3A, 0x3F, 0x2D, 0xDA, 0x4C, 0xA2, + 0x19, 0x95, 0xFC, 0xE9, 0x42, 0xAE, 0x29, 0xD3, + 0xC2, 0x52, 0x07, 0x52, 0x73, 0x4B, 0x94, 0x5A, + 0x20, 0xB0, 0x25, 0x7D, 0xB7, 0xC7, 0x21, 0x5C + }, + { + 0xAA, 0x75, 0x3E, 0x9C, 0xB6, 0x5C, 0xBA, 0xE5, + 0x39, 0x50, 0x2F, 0x5B, 0x45, 0xDB, 0xF5, 0xA7, + 0x74, 0xE2, 0xF2, 0x86, 0x20, 0xE0, 0xE6, 0x91, + 0x73, 0x06, 0x96, 0xC9, 0x42, 0x9C, 0xBC, 0x06 + }, + { + 0xAE, 0xAC, 0x06, 0x6A, 0xD6, 0x77, 0xAC, 0x7D, + 0xC5, 0xAE, 0x41, 0x96, 0x22, 0x97, 0x8C, 0x03, + 0x4F, 0x47, 0xC6, 0x67, 0xAC, 0x3E, 0xE1, 0xC0, + 0x1A, 0x88, 0x09, 0x18, 0x12, 0x67, 0xD2, 0x6D + }, + { + 0x63, 0xAA, 0x68, 0x70, 0x5A, 0x24, 0x0C, 0xDE, + 0xB9, 0x8E, 0x8C, 0xD0, 0x61, 0xC6, 0xC5, 0x1A, + 0xA6, 0x02, 0x1E, 0x8B, 0x1D, 0xAC, 0xCB, 0xFA, + 0xBF, 0x8E, 0xE0, 0xD7, 0x4E, 0x99, 0x59, 0xA3 + }, + { + 0x0D, 0x3B, 0x3C, 0xA2, 0x07, 0x54, 0x0E, 0x66, + 0x81, 0x66, 0x3B, 0x03, 0xB7, 0xBE, 0x39, 0xFC, + 0xC3, 0x1E, 0x40, 0xA3, 0x7F, 0x58, 0x03, 0xFE, + 0xBB, 0xDD, 0x65, 0x0A, 0xF3, 0x0B, 0x7E, 0x7B + }, + { + 0x11, 0x8D, 0x21, 0x95, 0x17, 0x35, 0xE2, 0xF0, + 0xC3, 0xC4, 0xA3, 0x48, 0x4B, 0x64, 0xF2, 0x05, + 0xAE, 0xEB, 0xA4, 0x08, 0xCB, 0x91, 0x6E, 0x9E, + 0x8C, 0x58, 0x0C, 0xCE, 0xC7, 0x72, 0xF7, 0x49 + }, + { + 0x23, 0x75, 0xA8, 0xE8, 0xB7, 0x74, 0x23, 0xBC, + 0x43, 0xDB, 0x84, 0xE9, 0x18, 0x1E, 0x7C, 0x2C, + 0x60, 0xF4, 0xF3, 0x01, 0x33, 0x08, 0xBB, 0xA0, + 0xF2, 0x4F, 0xCB, 0x92, 0xFA, 0x94, 0x15, 0x0C + }, + { + 0xB3, 0xFA, 0x82, 0xC8, 0x73, 0x56, 0xC8, 0x5A, + 0x42, 0xEA, 0xC7, 0x4D, 0x7D, 0xBD, 0xC9, 0xE3, + 0x18, 0xE0, 0x9F, 0x46, 0x67, 0x56, 0xC7, 0xAA, + 0x4B, 0x9C, 0xBD, 0x89, 0x4C, 0xF3, 0xF9, 0x39 + }, + { + 0x1F, 0x78, 0xDC, 0x75, 0x69, 0x13, 0x68, 0x2E, + 0xA4, 0x10, 0x2C, 0xE5, 0x74, 0x48, 0x17, 0x16, + 0x42, 0x15, 0xFB, 0x00, 0x23, 0xB1, 0x55, 0x2D, + 0xE9, 0xB5, 0xDE, 0xC6, 0xB6, 0x70, 0xEC, 0x3F + }, + { + 0xE0, 0xBD, 0x63, 0x9D, 0x5A, 0x09, 0x45, 0xC4, + 0x3A, 0xA8, 0x94, 0x55, 0xCE, 0xC3, 0x57, 0x78, + 0x4B, 0xEC, 0x2D, 0xCD, 0x7D, 0xF1, 0xE0, 0x4F, + 0x2D, 0xFC, 0xDC, 0x55, 0x6C, 0xF1, 0x5E, 0x08 + }, + { + 0xBA, 0xAB, 0x88, 0x6D, 0x94, 0x73, 0x7A, 0x10, + 0x1A, 0x4E, 0xB4, 0x39, 0xDC, 0x43, 0xED, 0x2B, + 0x3A, 0x2B, 0xE8, 0x7B, 0x8F, 0x59, 0xCF, 0xD9, + 0x73, 0x14, 0x14, 0x26, 0x4C, 0x86, 0x60, 0x03 + }, + { + 0xF1, 0x80, 0xA4, 0xB8, 0x66, 0x7F, 0xDD, 0x42, + 0x5E, 0xD2, 0xA9, 0x52, 0xF1, 0xF3, 0x3B, 0xE6, + 0x66, 0x8A, 0xCB, 0x6A, 0xDE, 0x8D, 0xB1, 0x49, + 0x84, 0xB0, 0x1B, 0xAF, 0xF3, 0xB5, 0xE1, 0x67 + }, + { + 0xA5, 0x59, 0x55, 0x0C, 0x64, 0xEA, 0x6A, 0x5A, + 0x22, 0x2D, 0xE9, 0xA6, 0xC7, 0xA0, 0x7C, 0xA5, + 0x17, 0xFB, 0x5B, 0xAC, 0x57, 0x3C, 0x16, 0xFB, + 0xF0, 0xD1, 0xFB, 0x13, 0xA5, 0x54, 0xC9, 0x77 + }, + { + 0xF4, 0x43, 0xE5, 0x96, 0x78, 0x80, 0x3E, 0x25, + 0x39, 0x48, 0x9E, 0x7F, 0x9A, 0xB1, 0x26, 0x0B, + 0x92, 0x34, 0xE6, 0xF2, 0x12, 0x40, 0x5F, 0x15, + 0x80, 0x43, 0x22, 0xE9, 0x51, 0x60, 0x1F, 0xD3 + }, + { + 0xEA, 0x71, 0xD2, 0xD9, 0x39, 0x94, 0xA4, 0x6A, + 0xBB, 0x38, 0x8F, 0xC4, 0xC6, 0x8A, 0x76, 0xC4, + 0xC5, 0x76, 0x59, 0x51, 0xB5, 0x63, 0xF4, 0xD2, + 0x68, 0xDB, 0x46, 0x93, 0x6F, 0x05, 0x4A, 0x33 + }, + { + 0x14, 0x88, 0x44, 0x7C, 0x64, 0x72, 0x2D, 0xE3, + 0x8F, 0xA2, 0x71, 0x2F, 0xAB, 0x75, 0xA5, 0xBB, + 0xFA, 0x29, 0xF9, 0x87, 0x43, 0x23, 0x8A, 0x75, + 0x7C, 0x34, 0x58, 0x2E, 0x14, 0xE2, 0x0E, 0xC4 + }, + { + 0x34, 0xAD, 0xDA, 0xD7, 0xDC, 0xBF, 0x5B, 0x3F, + 0xA1, 0xFC, 0xE7, 0x8F, 0x6A, 0xF0, 0x7E, 0xE7, + 0x09, 0x42, 0x10, 0xEA, 0xDC, 0x99, 0xEC, 0x6E, + 0x6B, 0xD5, 0x23, 0xDA, 0xA2, 0x65, 0x94, 0x3A + }, + { + 0x76, 0x7C, 0x0B, 0xCE, 0xB3, 0x3C, 0x80, 0x4F, + 0xAB, 0xA8, 0xA6, 0xD9, 0x5B, 0x24, 0xE8, 0x0E, + 0xF2, 0x4F, 0x5F, 0x45, 0x08, 0x04, 0xB1, 0x35, + 0x57, 0xD8, 0x71, 0x66, 0xF9, 0x78, 0x71, 0x56 + }, + { + 0x0C, 0x30, 0x4C, 0x49, 0x22, 0x1E, 0x84, 0x53, + 0xAD, 0x5A, 0x7D, 0xD5, 0xA2, 0xE1, 0x2D, 0x8A, + 0xFE, 0xD0, 0xDA, 0x0B, 0x31, 0x53, 0x80, 0x7B, + 0xA8, 0xAA, 0xF5, 0x20, 0xE5, 0xCE, 0xB4, 0x63 + }, + { + 0xD2, 0x93, 0xB4, 0xB2, 0xFA, 0x69, 0xD7, 0x30, + 0x32, 0x4A, 0xC8, 0x2D, 0x76, 0x34, 0x72, 0x99, + 0x8F, 0x37, 0xF8, 0x1B, 0xE0, 0x57, 0xF7, 0xAA, + 0x02, 0x5B, 0x0B, 0x8F, 0xA9, 0x3A, 0xAE, 0x58 + }, + { + 0xAF, 0x31, 0xC2, 0xD4, 0x9A, 0xAA, 0x53, 0xFC, + 0xDA, 0x60, 0x80, 0x55, 0x9B, 0xA8, 0xB1, 0xA0, + 0x7E, 0x77, 0xA4, 0xE2, 0xEC, 0xD0, 0x22, 0x27, + 0x33, 0x18, 0x89, 0x3E, 0xB9, 0x82, 0x6B, 0xBC + }, + { + 0x21, 0x4A, 0xEE, 0x8D, 0x74, 0x4A, 0xD8, 0xEB, + 0x95, 0x51, 0x51, 0x7C, 0xC8, 0xFB, 0x42, 0x60, + 0xFA, 0x97, 0xDE, 0x03, 0x6C, 0x02, 0xD4, 0x0D, + 0x1C, 0xE5, 0xCB, 0x20, 0xAA, 0x3F, 0x30, 0x0F + }, + { + 0x34, 0x53, 0x82, 0xBF, 0x6C, 0x6B, 0x6A, 0x0B, + 0x57, 0xE4, 0xF3, 0x62, 0x6C, 0x02, 0x59, 0x3D, + 0x46, 0xB5, 0xD3, 0xBA, 0x82, 0x2B, 0xE0, 0x4C, + 0x1E, 0x6C, 0x3C, 0x8F, 0x79, 0xE3, 0x27, 0x26 + }, + { + 0x26, 0x70, 0x5D, 0x74, 0x59, 0x6F, 0xC6, 0xDF, + 0x5F, 0x2F, 0x0B, 0x65, 0xD1, 0xAC, 0x2C, 0x04, + 0x31, 0x4C, 0x16, 0xEA, 0xB3, 0x37, 0x22, 0x77, + 0xC3, 0xB4, 0xCE, 0xFF, 0x70, 0x04, 0x69, 0x77 + }, + { + 0x9C, 0x6F, 0xC4, 0x7B, 0x11, 0xDA, 0x7C, 0x2A, + 0xFE, 0xA4, 0xB6, 0x2B, 0x79, 0xE0, 0xAC, 0x92, + 0xDB, 0x69, 0xC4, 0x2B, 0x9F, 0xD8, 0x23, 0xEE, + 0x45, 0x55, 0x14, 0x9D, 0x35, 0x82, 0xF8, 0xA6 + }, + { + 0x9C, 0x83, 0x43, 0x97, 0x70, 0xA3, 0x5D, 0x58, + 0x64, 0x2C, 0x7F, 0x53, 0xDD, 0x80, 0xA5, 0x1F, + 0xD7, 0x5E, 0x79, 0xAF, 0x94, 0x3A, 0x8A, 0xCF, + 0x7D, 0xD8, 0x26, 0xB3, 0x78, 0x71, 0x15, 0x89 + }, + { + 0xB9, 0x8A, 0x8E, 0x1E, 0x90, 0x21, 0xAC, 0x92, + 0x8B, 0x43, 0xAF, 0x8E, 0xDF, 0xCA, 0x16, 0x77, + 0x7E, 0xC3, 0xE8, 0x21, 0xE2, 0x03, 0x99, 0x59, + 0x60, 0x8E, 0x0B, 0xA4, 0xA1, 0x19, 0xB3, 0xFE + }, + { + 0x29, 0x44, 0x45, 0xDB, 0x83, 0x6C, 0x23, 0xCF, + 0x99, 0xF6, 0xCA, 0x8A, 0x3A, 0xAC, 0x32, 0xF6, + 0xEA, 0x77, 0xE8, 0xF6, 0x0A, 0xE2, 0x02, 0x4F, + 0xE6, 0x4F, 0xD0, 0xE0, 0xC3, 0x26, 0x86, 0xCF + }, + { + 0x46, 0xEF, 0xD8, 0x0C, 0xBD, 0x04, 0x94, 0x98, + 0x19, 0x2C, 0xD0, 0xB0, 0x4D, 0x52, 0x9A, 0x1C, + 0x21, 0x0A, 0xBF, 0x2F, 0x82, 0x61, 0xE2, 0x15, + 0x17, 0xA5, 0xBF, 0x84, 0x5F, 0x77, 0xE8, 0x5B + }, + { + 0x0E, 0xC0, 0x22, 0x60, 0x52, 0xFF, 0x6A, 0xA2, + 0x52, 0xA4, 0x78, 0x60, 0xD3, 0xD5, 0xBC, 0xCF, + 0x34, 0xA0, 0x10, 0xE0, 0x96, 0xC4, 0x31, 0xD8, + 0xF9, 0x9C, 0xC5, 0xE4, 0x53, 0xFB, 0x35, 0x1F + }, + { + 0x70, 0x15, 0xB4, 0x39, 0x02, 0xBB, 0x52, 0xA2, + 0x95, 0xA5, 0x45, 0xCA, 0x01, 0x1D, 0x21, 0xD3, + 0xA6, 0x3D, 0xAE, 0xFD, 0x7B, 0x7C, 0xFA, 0xDA, + 0x8D, 0x63, 0x25, 0x0E, 0x09, 0x95, 0x2D, 0xB8 + }, + { + 0xD2, 0xF6, 0x13, 0x85, 0x70, 0x0F, 0x32, 0xB3, + 0x29, 0x93, 0x30, 0x3B, 0x6C, 0x32, 0x3A, 0x94, + 0xEE, 0x0A, 0x34, 0x2F, 0x7C, 0xBA, 0xAD, 0x22, + 0x57, 0xCD, 0x6E, 0x34, 0x87, 0x4C, 0x9D, 0x18 + }, + { + 0x39, 0x7D, 0x98, 0xF0, 0xA8, 0x2F, 0x9F, 0x1E, + 0x89, 0x31, 0xE4, 0x05, 0xDE, 0xBD, 0x4A, 0x3D, + 0x7D, 0x71, 0x17, 0xB8, 0xDD, 0xCD, 0x0F, 0x5B, + 0x23, 0x3D, 0x5F, 0xF1, 0x3A, 0x97, 0x8A, 0x31 + }, + { + 0x33, 0x04, 0x87, 0x1B, 0x84, 0x92, 0x0C, 0xF6, + 0x60, 0x3C, 0x3D, 0x1F, 0x19, 0x92, 0x5F, 0x97, + 0xBE, 0x82, 0x3A, 0xAE, 0x2B, 0xE3, 0x44, 0x5C, + 0x7C, 0x14, 0xC3, 0xA4, 0xD1, 0xDC, 0x2E, 0xB5 + }, + { + 0x91, 0xDE, 0x7A, 0xA8, 0xE5, 0xD2, 0x95, 0x2F, + 0xB0, 0xF5, 0xEE, 0xD4, 0x8C, 0x5C, 0x0A, 0x7E, + 0x88, 0xA7, 0x3A, 0xD4, 0x90, 0xFD, 0x88, 0x79, + 0x47, 0x75, 0xC3, 0xBD, 0x8F, 0xAF, 0x31, 0x95 + }, + { + 0xEA, 0xBC, 0x24, 0x83, 0xDD, 0x06, 0x32, 0x81, + 0x01, 0xB7, 0x35, 0x39, 0x70, 0xA8, 0x62, 0x67, + 0x19, 0x84, 0xF2, 0xD1, 0xBA, 0x68, 0xE6, 0x59, + 0xBB, 0x58, 0x54, 0x35, 0x17, 0xA0, 0xB2, 0x1C + }, + { + 0xDB, 0x1F, 0xB7, 0xAF, 0xD6, 0xBF, 0xC6, 0xE6, + 0xDE, 0x89, 0x3D, 0xFD, 0xEE, 0x9D, 0x50, 0x90, + 0x06, 0xF4, 0x68, 0x21, 0xF0, 0xDC, 0xD6, 0xE4, + 0x35, 0x3C, 0xD7, 0x37, 0xBC, 0xD0, 0x5B, 0x90 + }, + { + 0x8B, 0x34, 0xFD, 0xFB, 0x6A, 0xF9, 0x70, 0x96, + 0xDF, 0x4C, 0xB2, 0x86, 0xBA, 0xD4, 0xC2, 0xA7, + 0x2E, 0xCB, 0x69, 0x76, 0xE6, 0xAA, 0x26, 0x17, + 0x38, 0xA7, 0x43, 0x5B, 0x6C, 0x57, 0x13, 0xD4 + }, + { + 0x22, 0x96, 0x5F, 0x25, 0x04, 0xEF, 0xA6, 0xB6, + 0xD0, 0x77, 0x6B, 0xA8, 0x7F, 0xC5, 0x1B, 0x9B, + 0x3F, 0xBF, 0xB4, 0x97, 0x83, 0xC3, 0x21, 0x88, + 0x9F, 0xF7, 0xE8, 0xAA, 0xFE, 0x5A, 0x99, 0x20 + }, + { + 0x3C, 0xEA, 0x5C, 0xB0, 0x09, 0xBA, 0xEA, 0x26, + 0x20, 0x38, 0x67, 0x0D, 0xCE, 0xE0, 0x6C, 0xA3, + 0x82, 0xD0, 0x86, 0x58, 0xB8, 0x67, 0x4B, 0x0B, + 0x71, 0xED, 0x36, 0xA0, 0x14, 0x6E, 0x4E, 0xA5 + }, + { + 0x27, 0xFD, 0x41, 0x71, 0x88, 0x6E, 0x98, 0xA5, + 0xEC, 0x51, 0x15, 0x21, 0xD0, 0xE3, 0x67, 0x6C, + 0x0C, 0x34, 0x3B, 0xCA, 0x5D, 0xE6, 0x3C, 0x20, + 0xE9, 0x3F, 0xB2, 0x3D, 0x29, 0x5B, 0x6D, 0x8C + }, + { + 0x41, 0x1C, 0x44, 0x4F, 0xA9, 0x77, 0xC0, 0xCD, + 0x84, 0x81, 0x78, 0x71, 0xC9, 0xDD, 0xF9, 0xFC, + 0xC6, 0x9A, 0x09, 0x2C, 0x5A, 0x28, 0x26, 0xBD, + 0x95, 0x20, 0x61, 0x8F, 0xC5, 0x74, 0x90, 0x27 + }, + { + 0x36, 0x80, 0x6F, 0xAF, 0x75, 0x04, 0x1E, 0x21, + 0x59, 0x2C, 0x6B, 0x6A, 0x7A, 0xB2, 0x0F, 0x9D, + 0x32, 0x39, 0x5B, 0xFD, 0x76, 0x81, 0x6E, 0xE3, + 0x65, 0x33, 0xD2, 0x36, 0x25, 0x11, 0xE2, 0xCC + }, + { + 0x63, 0xD3, 0x6D, 0x61, 0x24, 0x13, 0x7F, 0xCD, + 0x89, 0x78, 0xFF, 0x63, 0x2A, 0x8F, 0x8C, 0x34, + 0x71, 0x07, 0xED, 0xD1, 0x71, 0x8A, 0xA2, 0x3C, + 0x1D, 0xBD, 0xB7, 0xC0, 0x81, 0xEC, 0x02, 0x08 + }, + { + 0x1A, 0xB5, 0x28, 0x35, 0xCB, 0x9C, 0xA3, 0xA4, + 0xE2, 0x32, 0x4C, 0x9B, 0xCD, 0x89, 0x47, 0x83, + 0xBF, 0xE4, 0xEC, 0x9A, 0x7F, 0xA1, 0x2E, 0xF3, + 0x18, 0xB8, 0xA7, 0x2D, 0xF5, 0xC7, 0x93, 0x8C + }, + { + 0x54, 0x91, 0x97, 0xBE, 0x9D, 0x85, 0xA3, 0x3F, + 0xA5, 0x3A, 0xFA, 0x9D, 0x66, 0x0C, 0xED, 0xD8, + 0xC6, 0xDE, 0x7C, 0x98, 0x11, 0x24, 0xC9, 0x06, + 0x59, 0xAF, 0x53, 0x8A, 0x81, 0x08, 0xE5, 0xE0 + }, + { + 0xFA, 0x20, 0x05, 0x97, 0x82, 0x14, 0xA4, 0x8A, + 0x3B, 0xE5, 0x37, 0x5A, 0x56, 0x42, 0xA3, 0x88, + 0xE3, 0x7F, 0xEB, 0xA2, 0x3E, 0x06, 0x86, 0x94, + 0x10, 0x54, 0xC6, 0xE0, 0x6C, 0xA5, 0x1E, 0x94 + }, + { + 0xAE, 0xA6, 0x25, 0x89, 0x0D, 0xA1, 0x2F, 0xD0, + 0x1E, 0x3C, 0xEA, 0xD6, 0x60, 0xF1, 0x84, 0x07, + 0xF5, 0x79, 0x67, 0xE6, 0x3C, 0x00, 0x5A, 0x09, + 0xE0, 0x59, 0xCB, 0xC1, 0xD3, 0x51, 0x40, 0xC1 + }, + { + 0xCA, 0x96, 0x97, 0xE5, 0xEE, 0x99, 0x1D, 0x27, + 0xAA, 0x15, 0xFB, 0xBF, 0x13, 0x81, 0x73, 0x4B, + 0xAF, 0x63, 0x36, 0xF2, 0xF5, 0xD3, 0xE8, 0xDE, + 0xD4, 0x98, 0x24, 0x33, 0xF1, 0x95, 0x5B, 0xED + }, + { + 0xE9, 0x87, 0x3E, 0x0F, 0x69, 0x44, 0xA9, 0x1C, + 0x5C, 0xA5, 0xA6, 0x0B, 0x99, 0xD3, 0x68, 0x70, + 0x27, 0x97, 0x94, 0xB3, 0xB8, 0xDD, 0x1E, 0xC7, + 0x3A, 0x0C, 0x43, 0x60, 0xFF, 0xA0, 0x57, 0x16 + }, + { + 0xAF, 0x5F, 0x82, 0x7F, 0x34, 0x24, 0x67, 0xD4, + 0xC8, 0xA2, 0x78, 0x4B, 0x6B, 0x39, 0xFF, 0x5C, + 0x60, 0xFE, 0x6C, 0x9E, 0x10, 0xC4, 0xBD, 0x8B, + 0x31, 0x1A, 0x7A, 0xF9, 0xF0, 0x7A, 0x3D, 0xEC + }, + { + 0x28, 0x40, 0x0B, 0xE5, 0x5A, 0xF7, 0x18, 0xF3, + 0xCD, 0xC0, 0x91, 0x30, 0x8D, 0xCA, 0xEE, 0x4E, + 0x71, 0x63, 0xA9, 0x8F, 0xCB, 0x66, 0x0D, 0x70, + 0x55, 0x44, 0x2A, 0x64, 0x45, 0x71, 0x32, 0xB8 + }, + { + 0x73, 0xBA, 0x6B, 0x5C, 0x9C, 0xD9, 0x25, 0x50, + 0x74, 0xF2, 0xCA, 0xAD, 0x3B, 0xEE, 0x33, 0x48, + 0x22, 0xC1, 0x01, 0x58, 0x21, 0x0C, 0x75, 0x9D, + 0x67, 0x5B, 0xA7, 0xCF, 0x97, 0x06, 0x57, 0x54 + }, + { + 0x8B, 0x4D, 0x0D, 0x1B, 0x5D, 0xE0, 0xEE, 0x05, + 0x7D, 0x90, 0xCC, 0xBF, 0xAA, 0x16, 0x25, 0x3F, + 0x8A, 0xB7, 0x24, 0x2E, 0x92, 0x7E, 0x01, 0x95, + 0xF2, 0xEC, 0x53, 0xEE, 0x1A, 0xE5, 0xAC, 0x57 + }, + { + 0x0A, 0xC9, 0xF3, 0x1D, 0xF8, 0x4F, 0x33, 0xBC, + 0x58, 0xC9, 0x60, 0x4D, 0xFB, 0x08, 0x38, 0xE8, + 0x6F, 0x75, 0x9D, 0xF8, 0xF0, 0x6F, 0xC9, 0xA7, + 0xBC, 0xFE, 0xF1, 0xFA, 0xAE, 0x35, 0x31, 0x64 + }, + { + 0xDB, 0xFD, 0xB3, 0x4B, 0xA9, 0x24, 0x27, 0x23, + 0x9B, 0xF8, 0x28, 0xC0, 0x6A, 0xDC, 0xF6, 0x54, + 0x3A, 0x0F, 0xAC, 0x25, 0xF4, 0x68, 0xAC, 0x2C, + 0x78, 0xD2, 0x78, 0xDE, 0xF6, 0x65, 0x73, 0xCB + }, + { + 0x8F, 0x21, 0xA9, 0x43, 0xD7, 0xF6, 0x2A, 0xD3, + 0x05, 0x54, 0x59, 0xA1, 0x7A, 0xD5, 0x9E, 0x2F, + 0x39, 0xBF, 0x8D, 0x12, 0x67, 0xD8, 0x1B, 0xBF, + 0x81, 0xB6, 0xC5, 0x30, 0xBD, 0x9E, 0x7B, 0x79 + }, + { + 0x23, 0x06, 0x5C, 0x75, 0x3B, 0x85, 0xEE, 0x97, + 0x99, 0x6D, 0xC0, 0x0E, 0x9E, 0x5B, 0xD4, 0xFC, + 0x04, 0x68, 0x10, 0x4B, 0xBA, 0xC4, 0xF8, 0xA3, + 0xEF, 0xCE, 0x4C, 0x3C, 0xBE, 0xC9, 0x3B, 0xBC + }, + { + 0xF8, 0xA1, 0xFC, 0x99, 0x13, 0xAF, 0x33, 0x1B, + 0x38, 0x16, 0x2C, 0xAA, 0x47, 0xB6, 0xD3, 0x98, + 0xAC, 0x7D, 0x43, 0x4F, 0x01, 0x2B, 0xD6, 0x7A, + 0x1C, 0x93, 0x4E, 0x19, 0x20, 0x83, 0xC7, 0x43 + }, + { + 0x38, 0x3B, 0xFD, 0x1A, 0xFF, 0xE8, 0x0D, 0xC3, + 0xE2, 0x97, 0x63, 0x99, 0x63, 0x61, 0xF3, 0x40, + 0x61, 0x4A, 0xCE, 0xB9, 0x8A, 0x45, 0x47, 0xA3, + 0x13, 0x02, 0xBC, 0x65, 0x2D, 0x48, 0x58, 0x3E + }, + { + 0x96, 0x14, 0xC2, 0x77, 0xFF, 0xC1, 0x8E, 0x69, + 0x39, 0x68, 0xE1, 0xBB, 0xC9, 0x73, 0x81, 0x40, + 0x8E, 0xA9, 0x07, 0xFA, 0x58, 0x5B, 0x3B, 0x54, + 0x21, 0x8C, 0xA5, 0xAD, 0x01, 0xF9, 0x1F, 0x2D + }, + { + 0x8A, 0x9D, 0x43, 0x9B, 0xD9, 0x03, 0x6F, 0x3D, + 0xC7, 0x72, 0xB9, 0xA9, 0xC8, 0x2E, 0x82, 0x7A, + 0x22, 0x8A, 0x54, 0x5E, 0x52, 0xF2, 0xD1, 0xAC, + 0x27, 0x72, 0x85, 0x18, 0x21, 0x00, 0x3B, 0x81 + }, + { + 0xBA, 0x53, 0xC7, 0xBA, 0x42, 0x9E, 0x8B, 0x09, + 0xFA, 0x40, 0x44, 0xEB, 0xFA, 0x59, 0x9C, 0xFA, + 0xCD, 0x9A, 0xB9, 0xBD, 0x41, 0x89, 0xC1, 0xBB, + 0xC8, 0x9A, 0xD9, 0x9D, 0x22, 0xED, 0x3D, 0x00 + }, + { + 0x6D, 0x17, 0x5F, 0xFC, 0x0E, 0x23, 0x35, 0xDF, + 0xB9, 0x03, 0x7A, 0xA7, 0x1F, 0x29, 0xD3, 0xFE, + 0x1C, 0xAC, 0x8B, 0x0F, 0xF6, 0x4C, 0x13, 0xCA, + 0xCD, 0x7B, 0xD2, 0xB5, 0x88, 0x30, 0x11, 0x0F + }, + { + 0x6B, 0x0A, 0xBC, 0x47, 0x97, 0x88, 0xEA, 0xF0, + 0x9E, 0xD6, 0x63, 0xA6, 0x77, 0x82, 0x33, 0x0E, + 0x1F, 0xA9, 0xB1, 0x28, 0x68, 0x72, 0xC9, 0x0C, + 0x66, 0x37, 0x7D, 0x88, 0xBF, 0x1B, 0xCA, 0x1E + }, + { + 0x9E, 0xCC, 0x13, 0x94, 0x12, 0x7E, 0xAA, 0x6B, + 0x92, 0x48, 0xD2, 0xF9, 0xD9, 0x10, 0x68, 0x5D, + 0x2B, 0xA8, 0x07, 0xE2, 0xEB, 0x41, 0x43, 0x98, + 0xF5, 0x84, 0x68, 0x85, 0x60, 0x45, 0xD6, 0xF0 + }, + { + 0xEB, 0x5D, 0xC1, 0x72, 0x79, 0xE3, 0x87, 0x5E, + 0x91, 0x9B, 0x55, 0x12, 0x9D, 0x6F, 0x05, 0x19, + 0x51, 0x83, 0x19, 0x32, 0xB2, 0x09, 0x77, 0xAC, + 0x2E, 0x6D, 0x09, 0x08, 0x04, 0xE4, 0x01, 0x4B + }, + { + 0x81, 0x7D, 0xEB, 0xCC, 0xD9, 0xA9, 0x0E, 0x6B, + 0x38, 0x06, 0x45, 0xDA, 0x26, 0x39, 0xFC, 0x33, + 0xB5, 0x31, 0x09, 0xB8, 0xC4, 0x27, 0x27, 0xF7, + 0x43, 0x77, 0x00, 0xF4, 0x3A, 0x82, 0x98, 0x6A + }, + { + 0x05, 0xDA, 0xF8, 0x42, 0x1B, 0xEA, 0x7D, 0xFE, + 0x73, 0xF5, 0x97, 0xBE, 0x56, 0x68, 0x07, 0x5B, + 0x75, 0xEA, 0x13, 0x47, 0xFD, 0x58, 0xC6, 0x09, + 0x21, 0x27, 0xCE, 0x4D, 0xB5, 0xF9, 0xE5, 0x03 + }, + { + 0x15, 0x34, 0x73, 0x1A, 0xBE, 0x4B, 0x1B, 0xDC, + 0xF4, 0x3A, 0xD6, 0xCF, 0x55, 0x21, 0x03, 0x67, + 0x98, 0x06, 0x71, 0x6E, 0xC2, 0xA3, 0x44, 0x70, + 0x90, 0x11, 0xBE, 0x72, 0x61, 0x2B, 0xAD, 0xDC + }, + { + 0xA9, 0xD8, 0x4D, 0x55, 0xAC, 0x12, 0x40, 0x75, + 0x12, 0x94, 0xB6, 0x75, 0xE0, 0xB2, 0xB2, 0xA4, + 0xD2, 0x82, 0x1C, 0xEB, 0x02, 0xBF, 0x82, 0xCF, + 0x71, 0x7B, 0xEA, 0xD0, 0xBD, 0x71, 0xC2, 0x34 + }, + { + 0xDF, 0xD1, 0x22, 0xA8, 0x74, 0x92, 0xD4, 0xB7, + 0x9F, 0x3C, 0x14, 0x59, 0x9E, 0xBF, 0x11, 0x8E, + 0x25, 0x97, 0xCD, 0x17, 0x09, 0x84, 0x05, 0xF5, + 0x9C, 0xDE, 0x14, 0x41, 0x22, 0x51, 0x6D, 0xF0 + }, + { + 0xD7, 0xC0, 0x82, 0x56, 0x4A, 0xF0, 0x4A, 0x58, + 0x5A, 0x9A, 0xE5, 0x86, 0xAF, 0x8A, 0x1C, 0x36, + 0x93, 0x40, 0x82, 0x66, 0x09, 0x43, 0xCA, 0x93, + 0x11, 0xE1, 0xA9, 0x7C, 0x16, 0xCF, 0x06, 0x2B + }, + { + 0xA9, 0x43, 0xDF, 0xC9, 0x57, 0xCC, 0xC0, 0xF3, + 0x0B, 0x2C, 0x75, 0xDC, 0x4A, 0x80, 0x27, 0x33, + 0x7E, 0x38, 0x82, 0xD7, 0x98, 0x26, 0xCE, 0xE1, + 0xC2, 0xA4, 0x0D, 0x68, 0x26, 0x7D, 0xAD, 0xE5 + }, + { + 0x1C, 0x0B, 0x4C, 0x99, 0x51, 0x97, 0x45, 0x61, + 0xE8, 0xFF, 0x35, 0xE3, 0xED, 0x6F, 0xD3, 0x38, + 0x27, 0x79, 0x07, 0x9D, 0x1C, 0x3B, 0x30, 0xB0, + 0x77, 0x34, 0xAF, 0xEA, 0xE6, 0x3F, 0x59, 0x68 + }, + { + 0x5B, 0x17, 0x9E, 0x13, 0xB8, 0x16, 0x19, 0xE5, + 0x24, 0x0C, 0x7D, 0xFE, 0xF8, 0xFA, 0x7E, 0x70, + 0x7C, 0x4A, 0xAF, 0xF5, 0x6D, 0xB5, 0xB1, 0x5A, + 0x21, 0x20, 0x0F, 0x74, 0xAF, 0x0B, 0xCA, 0x2B + }, + { + 0xF2, 0xCE, 0xBA, 0xA0, 0x8A, 0x7E, 0x2C, 0xF5, + 0x0E, 0xBA, 0x1C, 0x9F, 0x87, 0xF7, 0xE2, 0x33, + 0x6A, 0xE9, 0x92, 0xC5, 0xE0, 0xCA, 0xE1, 0xEF, + 0xEC, 0xA8, 0xD0, 0x93, 0xDB, 0xEE, 0x9D, 0xAE + }, + { + 0x0F, 0x12, 0x13, 0x11, 0x08, 0xB2, 0x5C, 0xC8, + 0xAB, 0xD3, 0x93, 0x7A, 0x86, 0x48, 0x74, 0xA8, + 0x31, 0x2A, 0xF3, 0xA4, 0xF5, 0xDA, 0x15, 0xC5, + 0x85, 0x57, 0xA8, 0x36, 0xAB, 0x58, 0xBD, 0xA9 + }, + { + 0x77, 0xC0, 0x7E, 0xCE, 0x96, 0xE3, 0xD9, 0xE7, + 0x0E, 0x8A, 0xB6, 0xD5, 0x4B, 0xFC, 0xEC, 0x37, + 0x1A, 0x6B, 0x07, 0x07, 0x65, 0xF3, 0x17, 0xDE, + 0xA7, 0x3C, 0xE5, 0x19, 0xC1, 0x50, 0x25, 0x3A + }, + { + 0x28, 0xAC, 0xAE, 0xC0, 0x4D, 0x76, 0x90, 0xE0, + 0x06, 0x72, 0x70, 0x4D, 0x27, 0xAB, 0x0E, 0xC4, + 0x2E, 0x4D, 0x5E, 0xB1, 0xA1, 0x5E, 0x83, 0xF7, + 0x31, 0x6D, 0xF1, 0xE3, 0x34, 0x39, 0xBD, 0x3A + }, + { + 0xB5, 0xB3, 0x06, 0x98, 0x77, 0xCA, 0x6C, 0x99, + 0x04, 0xB3, 0x47, 0x12, 0x2C, 0x18, 0xE6, 0x00, + 0x7F, 0x09, 0x98, 0x99, 0x20, 0x97, 0x02, 0xD7, + 0xAC, 0xC6, 0x1B, 0x66, 0xEE, 0xD9, 0x44, 0x79 + }, + { + 0x2E, 0xDE, 0x7A, 0x0E, 0xB1, 0x05, 0xA4, 0xB8, + 0xD2, 0x0E, 0x53, 0x3A, 0x25, 0x5B, 0xCA, 0xBA, + 0xC2, 0xBD, 0x96, 0x52, 0x88, 0x55, 0xAD, 0xDB, + 0x46, 0x38, 0x81, 0x7A, 0x8B, 0x2B, 0x00, 0x07 + }, + { + 0x95, 0x7F, 0x5F, 0x15, 0x1E, 0x5B, 0x01, 0xD9, + 0x54, 0x3C, 0xF2, 0x53, 0x26, 0xDA, 0x53, 0x8A, + 0xDD, 0xED, 0xC7, 0x86, 0xD3, 0x0B, 0xBD, 0x39, + 0xCC, 0x37, 0x34, 0x30, 0xB0, 0x25, 0x9D, 0x62 + }, + { + 0xEA, 0xD0, 0xE6, 0x75, 0xC1, 0x25, 0x16, 0x22, + 0x10, 0x9C, 0x9A, 0x12, 0x10, 0xF7, 0x95, 0xFA, + 0x67, 0x92, 0xA0, 0x7F, 0xD7, 0x51, 0x4E, 0xAC, + 0xF9, 0xEA, 0x7E, 0x87, 0x4F, 0xA7, 0x23, 0xA3 + }, + { + 0x0F, 0xD9, 0xDF, 0x86, 0x43, 0xD0, 0x33, 0xE9, + 0xA7, 0x3B, 0x4B, 0x02, 0x3F, 0x6B, 0xC8, 0x92, + 0x26, 0x09, 0xA1, 0x86, 0x85, 0x79, 0x38, 0x7B, + 0xF5, 0xEF, 0x82, 0xFA, 0xA7, 0x4B, 0xE4, 0x63 + }, + { + 0x4E, 0x2B, 0xF5, 0xAB, 0x23, 0x5A, 0xB6, 0x11, + 0x47, 0xA6, 0xE8, 0x59, 0xFF, 0x3D, 0x44, 0xB9, + 0x45, 0x04, 0xF0, 0x88, 0x68, 0x3F, 0xFF, 0x29, + 0x39, 0x5E, 0x27, 0xAC, 0x7A, 0xD4, 0x40, 0xB7 + }, + { + 0xAF, 0x32, 0x3E, 0xE5, 0xB5, 0xF4, 0x28, 0x62, + 0x21, 0x2E, 0xE0, 0xEF, 0xEB, 0x72, 0x19, 0xBA, + 0x4F, 0x3B, 0x6D, 0xFD, 0xDB, 0x89, 0xCF, 0xA7, + 0x66, 0x8E, 0xE6, 0xF5, 0x9B, 0x0B, 0x60, 0x86 + }, + { + 0x89, 0x06, 0xF5, 0xCD, 0xB9, 0xB4, 0x26, 0xEE, + 0x80, 0x2D, 0x54, 0x55, 0xCB, 0x22, 0x7E, 0x73, + 0x60, 0x60, 0xBD, 0x14, 0x7B, 0x99, 0xA6, 0xA8, + 0x70, 0x4B, 0x82, 0x96, 0x32, 0xB4, 0xC5, 0x2E + }, + { + 0x96, 0xB4, 0x59, 0xBE, 0x51, 0x56, 0x32, 0xAE, + 0x81, 0x8F, 0x12, 0xA9, 0x3D, 0x54, 0xFA, 0x9D, + 0xB1, 0xCA, 0x6B, 0xDB, 0xAC, 0x13, 0x77, 0xE7, + 0x84, 0x50, 0xD2, 0x2E, 0xD5, 0xBF, 0xA7, 0x9A + }, + { + 0x60, 0x1D, 0xAD, 0x38, 0x7E, 0x47, 0xE3, 0xB4, + 0x35, 0xBA, 0xEE, 0xF7, 0x58, 0x2B, 0x0A, 0xE9, + 0x63, 0xA3, 0x8B, 0x0D, 0x02, 0x5E, 0xA3, 0x7D, + 0xAD, 0x58, 0x69, 0x8E, 0x7F, 0xC5, 0x0F, 0xFF + }, + { + 0x02, 0xBB, 0xF3, 0x13, 0xAD, 0x43, 0xDC, 0x74, + 0xB1, 0xB9, 0x70, 0xAC, 0x45, 0x8E, 0x58, 0x04, + 0xA1, 0x06, 0x0C, 0xC5, 0x88, 0x00, 0xF7, 0xDB, + 0x9C, 0x06, 0xAB, 0xB4, 0xE1, 0xF1, 0x3F, 0x68 + }, + { + 0x9D, 0x24, 0xED, 0xEC, 0xAF, 0x98, 0xD3, 0x8E, + 0xF7, 0x79, 0x49, 0x99, 0xFC, 0x7A, 0xE5, 0x78, + 0xAB, 0x92, 0x3C, 0xDF, 0xCD, 0x44, 0x18, 0x5E, + 0xEA, 0xDA, 0x1C, 0xFC, 0xF2, 0x18, 0xB2, 0x17 + }, + { + 0x0C, 0x6F, 0xB9, 0xBA, 0x33, 0xDA, 0x03, 0x32, + 0x48, 0xF0, 0xD4, 0xA3, 0x75, 0x70, 0xAD, 0xF7, + 0x93, 0xED, 0xB8, 0x2B, 0x43, 0x61, 0xDA, 0xFA, + 0x20, 0x07, 0x6B, 0xE6, 0x10, 0xA0, 0xBC, 0x09 + }, + { + 0x3B, 0x73, 0xC8, 0xF5, 0x98, 0x8E, 0xA5, 0xCF, + 0x3B, 0xEE, 0xBB, 0xF5, 0xED, 0x5E, 0xEE, 0x7E, + 0x6D, 0xFB, 0x6A, 0x7A, 0x1B, 0x69, 0x0C, 0x02, + 0xD6, 0xD8, 0xD7, 0x3D, 0x13, 0x12, 0xB1, 0xDC + }, + { + 0x50, 0xB2, 0xB5, 0x75, 0x30, 0x8A, 0xDC, 0x44, + 0xC3, 0x17, 0x2B, 0x64, 0x0B, 0xDF, 0x2D, 0xA5, + 0xA2, 0xB9, 0x24, 0xDA, 0xFE, 0xD5, 0xED, 0x22, + 0x99, 0x3C, 0x54, 0x33, 0x07, 0xEB, 0x03, 0x63 + }, + { + 0x41, 0x61, 0x29, 0xDB, 0xF3, 0xC6, 0xBA, 0x6B, + 0x74, 0x0B, 0x0F, 0xE5, 0xFD, 0x5E, 0xC7, 0x77, + 0x96, 0x4E, 0xEE, 0xB7, 0x42, 0x1F, 0x1E, 0x0A, + 0x68, 0x5E, 0xF0, 0xDB, 0x8A, 0x6E, 0x21, 0x04 + }, + { + 0x33, 0x45, 0xF1, 0x1B, 0x02, 0xCF, 0x0B, 0x3D, + 0xF0, 0xE9, 0xA7, 0xBA, 0x14, 0x38, 0x21, 0xFE, + 0x24, 0x42, 0x8C, 0xE2, 0xC2, 0x9E, 0xB7, 0x94, + 0xAD, 0xAA, 0x04, 0x51, 0x73, 0xED, 0x73, 0xDC + }, + { + 0xF0, 0x0A, 0xE0, 0x9B, 0xF5, 0x9F, 0xFE, 0x0D, + 0x97, 0x5B, 0x37, 0x74, 0x0F, 0x2D, 0x00, 0x3D, + 0xA7, 0x7C, 0xB3, 0x1D, 0x4C, 0xDB, 0xD0, 0x4F, + 0x5E, 0xE1, 0xE9, 0x04, 0x32, 0x8E, 0x81, 0x8C + }, + { + 0x19, 0xE1, 0x54, 0x77, 0x83, 0x8E, 0x80, 0xFF, + 0xB5, 0xEB, 0x0B, 0x52, 0x71, 0x92, 0x1D, 0xD8, + 0xDB, 0xBA, 0x22, 0x7A, 0x11, 0xBC, 0xC2, 0x96, + 0xE7, 0x2B, 0x63, 0xE0, 0x7B, 0xE9, 0x7D, 0x1E + }, + { + 0xF9, 0x23, 0xE9, 0x06, 0xB2, 0x8C, 0x60, 0x15, + 0x70, 0x03, 0x67, 0x16, 0xE8, 0x60, 0x04, 0xA5, + 0xD1, 0x3C, 0x8B, 0x9A, 0x30, 0x79, 0x47, 0xEF, + 0xA8, 0xDB, 0x2C, 0xD0, 0x27, 0x7B, 0x30, 0x2C + }, + { + 0x36, 0x2A, 0xBB, 0x11, 0x6D, 0x51, 0xE7, 0x0F, + 0xBA, 0xAE, 0x82, 0x59, 0x40, 0xDE, 0xDA, 0x55, + 0xB0, 0x51, 0xDB, 0x74, 0x0E, 0xB0, 0xAC, 0x37, + 0xD1, 0x02, 0x8E, 0xF3, 0xB8, 0x18, 0x6A, 0x82 + }, + { + 0x5E, 0xAF, 0xD8, 0x64, 0x5F, 0xA9, 0x07, 0xCA, + 0x00, 0x24, 0xF5, 0xBF, 0x26, 0xED, 0x5A, 0x56, + 0x4B, 0x63, 0x55, 0x03, 0xD7, 0x34, 0xA6, 0xAB, + 0x8B, 0xD8, 0x0F, 0xE3, 0x7B, 0x78, 0xA4, 0xF8 + }, + { + 0xA6, 0x26, 0x16, 0xD6, 0x24, 0xF6, 0xA4, 0x90, + 0x4E, 0xD6, 0xF5, 0xAC, 0xEC, 0xE2, 0xBA, 0xC5, + 0x37, 0x54, 0xE3, 0x62, 0x4C, 0x59, 0x3A, 0x12, + 0x81, 0x07, 0xB9, 0x3D, 0x4F, 0xE8, 0xFC, 0x2F + }, + { + 0x3E, 0x39, 0x48, 0xF0, 0xB6, 0x60, 0x23, 0x48, + 0xB6, 0x99, 0xDA, 0xB0, 0xEA, 0x15, 0xC0, 0x78, + 0x1F, 0xD6, 0x94, 0x18, 0x35, 0x31, 0x14, 0x2F, + 0xB5, 0xBC, 0x88, 0x47, 0x7C, 0xAC, 0xBE, 0x76 + }, + { + 0x32, 0x46, 0xBC, 0x18, 0xB4, 0x22, 0x53, 0xF5, + 0x8D, 0x3B, 0xC2, 0x1D, 0xD5, 0x1C, 0x14, 0x29, + 0x0C, 0x0B, 0x78, 0xD4, 0xD9, 0xD5, 0x27, 0x40, + 0x87, 0xBF, 0xF2, 0xCA, 0x29, 0x7C, 0x51, 0xFC + }, + { + 0x58, 0x3D, 0xC2, 0xF1, 0xF1, 0x06, 0xE8, 0xB8, + 0x5F, 0xAB, 0x47, 0x95, 0x37, 0x15, 0x76, 0xD7, + 0x5E, 0xCA, 0x0F, 0xAD, 0x5A, 0x0C, 0xC5, 0xED, + 0xE8, 0x1A, 0xD5, 0x4B, 0xD4, 0x05, 0xD8, 0x73 + }, + { + 0x91, 0x1C, 0x0F, 0x1F, 0x74, 0x50, 0x4E, 0x7F, + 0x32, 0x43, 0x72, 0x68, 0xFB, 0xFA, 0x66, 0xCD, + 0x0D, 0xDB, 0xDE, 0x5A, 0x49, 0x28, 0xE6, 0x3C, + 0x5B, 0x89, 0x4A, 0x4F, 0xE7, 0x78, 0x4B, 0xA0 + }, + { + 0x37, 0x06, 0x0D, 0x01, 0x27, 0x8B, 0x64, 0x9A, + 0x66, 0xD5, 0xD1, 0x48, 0xB6, 0xB4, 0xFB, 0x8F, + 0x2C, 0x66, 0xAA, 0xF3, 0x08, 0x49, 0xB6, 0xD3, + 0x5C, 0xFB, 0xA2, 0xE9, 0x21, 0xC4, 0x90, 0x98 + }, + { + 0x7D, 0x41, 0xD6, 0x75, 0x96, 0x24, 0xBF, 0x32, + 0xAA, 0xCB, 0x9A, 0xED, 0xCC, 0xAE, 0x6A, 0x8A, + 0x05, 0x7B, 0x70, 0x22, 0x2C, 0x54, 0x90, 0x54, + 0x9E, 0xC8, 0x30, 0x11, 0xD1, 0x4E, 0x41, 0x0C + }, + { + 0x06, 0x37, 0xD8, 0xD9, 0xB5, 0xD4, 0xFA, 0x22, + 0xC6, 0xD6, 0x4A, 0xB2, 0xBD, 0x99, 0x94, 0xD5, + 0xC6, 0x2A, 0x0C, 0xF6, 0xA0, 0xDB, 0x3F, 0x92, + 0xF6, 0x67, 0x83, 0x60, 0x5B, 0xC5, 0xC8, 0x11 + }, + { + 0x84, 0xEB, 0x91, 0x18, 0x08, 0xA7, 0xA9, 0x33, + 0xCD, 0xCC, 0xA1, 0x71, 0x6B, 0x16, 0xEE, 0x9D, + 0xC2, 0xDB, 0x8F, 0xB5, 0x7E, 0xCB, 0x98, 0xEF, + 0x43, 0xC1, 0x54, 0x90, 0xDD, 0x0A, 0xD3, 0xA6 + }, + { + 0xEC, 0xC5, 0xEF, 0x36, 0x77, 0x8D, 0x33, 0xF3, + 0x74, 0xBF, 0x47, 0x7B, 0x30, 0x0E, 0xF4, 0xAC, + 0x02, 0x0A, 0x66, 0x59, 0xA0, 0xC7, 0xB6, 0x01, + 0xAC, 0x79, 0x38, 0x22, 0xDD, 0xAD, 0x77, 0xC3 + }, + { + 0xBB, 0xE4, 0x8F, 0xF0, 0x58, 0x6A, 0x33, 0x74, + 0xEE, 0x15, 0x0A, 0x0C, 0x9D, 0xC1, 0x3C, 0x8A, + 0x2C, 0x1B, 0x9E, 0xB8, 0x30, 0xD7, 0x48, 0x59, + 0xCB, 0xF4, 0xE5, 0xE6, 0x2F, 0x43, 0x14, 0x4D + }, + { + 0x25, 0x64, 0xED, 0xE0, 0x08, 0x2D, 0x7E, 0xDB, + 0x6E, 0x76, 0x06, 0xED, 0x82, 0x62, 0xFF, 0xBE, + 0x8B, 0xE1, 0xCE, 0x8D, 0xD5, 0x30, 0xA1, 0xAA, + 0x2D, 0x3F, 0x59, 0xFA, 0x3F, 0xDB, 0x4E, 0xCA + }, + { + 0xCB, 0x41, 0x8A, 0x87, 0x18, 0xD1, 0xB4, 0x29, + 0x82, 0xC3, 0xA7, 0x33, 0x16, 0x33, 0x3B, 0x11, + 0xDE, 0xC8, 0x57, 0xB3, 0x72, 0x30, 0x5A, 0x9F, + 0xB4, 0xF0, 0xF3, 0x19, 0x12, 0xFF, 0x98, 0x32 + }, + { + 0xE5, 0x59, 0xA1, 0x7D, 0xC2, 0xC9, 0x58, 0xED, + 0x6E, 0x06, 0x69, 0x57, 0x70, 0x3A, 0x52, 0xC9, + 0xAE, 0x23, 0x2C, 0x2B, 0x13, 0x52, 0x66, 0x9E, + 0xED, 0x04, 0x5F, 0x27, 0xB2, 0x4E, 0xE2, 0x7E + }, + { + 0x24, 0xBF, 0x98, 0xED, 0xE1, 0x49, 0x8E, 0x4F, + 0xB4, 0x31, 0x61, 0x7E, 0x97, 0xF1, 0x65, 0xB9, + 0x80, 0xF2, 0xC2, 0x0C, 0xD1, 0xD1, 0xA9, 0xCE, + 0x57, 0x7A, 0xC3, 0xF0, 0xD6, 0x2D, 0x30, 0xAE + }, + { + 0x49, 0x99, 0x5F, 0xEF, 0xD5, 0xAB, 0xE5, 0x93, + 0xD1, 0x45, 0x32, 0x91, 0x02, 0x85, 0x67, 0x2F, + 0xA0, 0xBB, 0xE7, 0xC8, 0x68, 0x70, 0x8F, 0xF7, + 0xC7, 0xB5, 0xBA, 0xFC, 0x07, 0x96, 0x45, 0x6D + }, + { + 0xCB, 0x93, 0x2E, 0xFE, 0xAD, 0x5F, 0x3B, 0x5F, + 0x45, 0x05, 0xB3, 0xF8, 0x87, 0xF3, 0x43, 0xD2, + 0x4B, 0x3F, 0xEA, 0x31, 0xA2, 0x34, 0x69, 0x9C, + 0xC7, 0xCA, 0x93, 0xE2, 0x6D, 0x09, 0xC2, 0xB2 + }, + { + 0xFC, 0x9C, 0xF2, 0xBA, 0x02, 0xBE, 0x69, 0xE7, + 0x1B, 0x17, 0x34, 0x12, 0x15, 0x35, 0xEF, 0x24, + 0x27, 0x46, 0x9C, 0x9D, 0x16, 0xF4, 0x93, 0x43, + 0x4B, 0x72, 0xB2, 0xDC, 0x3D, 0x29, 0x19, 0xF8 + }, + { + 0xC7, 0x35, 0xA8, 0x6A, 0x8D, 0xCF, 0x4E, 0x81, + 0x68, 0xF8, 0x21, 0x96, 0xB1, 0xEB, 0x3D, 0x6C, + 0x57, 0x74, 0x89, 0xBF, 0xFC, 0x72, 0xA7, 0xC1, + 0x0C, 0xAC, 0xE5, 0x40, 0x91, 0x5D, 0x91, 0x2F + }, + { + 0xCE, 0x4A, 0x8F, 0xD7, 0x55, 0x7F, 0x9E, 0x08, + 0x23, 0x57, 0xDD, 0xF8, 0xE6, 0x7D, 0x9F, 0x0B, + 0x90, 0x76, 0xC8, 0x57, 0xB6, 0x3B, 0xBB, 0x4C, + 0x57, 0x56, 0x70, 0xE2, 0x5E, 0xC4, 0xA4, 0x68 + }, + { + 0xFC, 0x2E, 0xA1, 0x00, 0x29, 0xCE, 0xA3, 0x5B, + 0x8B, 0x53, 0x15, 0x0E, 0xB1, 0x52, 0x7F, 0x77, + 0xDD, 0xDF, 0x27, 0x08, 0x00, 0xD5, 0xE0, 0x61, + 0x71, 0x99, 0x3D, 0xB7, 0x0A, 0x5F, 0x55, 0x27 + }, + { + 0x6D, 0xC5, 0x8A, 0xFD, 0x24, 0xF7, 0x8E, 0x90, + 0x0A, 0x78, 0xC5, 0x76, 0xC4, 0x60, 0xB7, 0xDD, + 0x13, 0x32, 0xAB, 0xA3, 0x14, 0xF2, 0xC3, 0xDA, + 0xA1, 0xDE, 0xC8, 0xB6, 0x6E, 0x9F, 0x0C, 0x84 + }, + { + 0xD4, 0x90, 0xE3, 0xBB, 0x27, 0xCB, 0x8C, 0xC0, + 0xC6, 0xB2, 0x5E, 0x76, 0xA6, 0xB0, 0x62, 0x0B, + 0x04, 0x66, 0xC2, 0x8B, 0x59, 0x21, 0xD1, 0x57, + 0xD2, 0x07, 0x2E, 0x44, 0x29, 0x41, 0x2D, 0x84 + }, + { + 0xC7, 0x01, 0x38, 0xB9, 0xBB, 0xE9, 0x74, 0xFB, + 0x7E, 0xB3, 0xB4, 0x9D, 0xD0, 0x6E, 0x54, 0x40, + 0xEA, 0x41, 0xF4, 0xB6, 0x62, 0x41, 0x6B, 0xAC, + 0x1B, 0x98, 0x5D, 0x55, 0x1B, 0x64, 0x34, 0xB2 + }, + { + 0x61, 0xFF, 0x9D, 0xC1, 0x9D, 0xDA, 0x72, 0x5D, + 0x8B, 0x07, 0x45, 0x06, 0x24, 0x54, 0xBD, 0x57, + 0x7E, 0xCF, 0x20, 0x46, 0x8E, 0x00, 0x4F, 0x85, + 0x69, 0x00, 0xC8, 0x68, 0xE4, 0xF3, 0x67, 0x12 + }, + { + 0x86, 0xA8, 0xEB, 0x5E, 0x87, 0x6A, 0xD5, 0x41, + 0x88, 0x59, 0xBD, 0x4A, 0x8D, 0xFF, 0x4D, 0x04, + 0x91, 0x18, 0xB5, 0xF9, 0xD1, 0xFB, 0x5F, 0x84, + 0x0B, 0xA3, 0xD4, 0x4C, 0xB9, 0xA5, 0x86, 0xB1 + }, + { + 0x2D, 0x97, 0xD8, 0xDA, 0x5D, 0x71, 0x79, 0x8C, + 0xD6, 0xFB, 0x9F, 0xAC, 0x17, 0x5E, 0x69, 0x7B, + 0xE6, 0x77, 0xE0, 0x2F, 0x79, 0x29, 0xBB, 0x2D, + 0x3B, 0xEE, 0xD6, 0xD2, 0x17, 0x51, 0x6C, 0x85 + }, + { + 0x1F, 0x3D, 0x61, 0xB9, 0x40, 0x05, 0xAD, 0x31, + 0x49, 0xAC, 0x44, 0xCA, 0x7E, 0xCF, 0xE2, 0x9B, + 0xDE, 0xE5, 0x36, 0xD6, 0xB8, 0x63, 0xCE, 0xD8, + 0x7E, 0xF6, 0xD7, 0xCF, 0x7F, 0x7F, 0x72, 0x97 + }, + { + 0x3F, 0xC3, 0x9C, 0x26, 0x8E, 0x60, 0x98, 0xE4, + 0xC3, 0x37, 0x9C, 0x2B, 0xAF, 0xB7, 0x6E, 0x94, + 0x30, 0xEE, 0x38, 0xA1, 0x61, 0x18, 0xF1, 0x39, + 0x3D, 0x98, 0x9C, 0x3A, 0x2C, 0x03, 0x77, 0x70 + }, + { + 0x53, 0x05, 0x3D, 0x92, 0x8E, 0x01, 0x3A, 0x6B, + 0x6D, 0x5B, 0xA8, 0x65, 0x80, 0xE3, 0x63, 0xBD, + 0xF2, 0xF9, 0x45, 0x00, 0xE3, 0xAD, 0xE5, 0xF0, + 0xA4, 0x41, 0xBE, 0xCB, 0xD1, 0xE0, 0xB9, 0x60 + }, + { + 0x8A, 0x81, 0x5E, 0x42, 0x96, 0x09, 0x15, 0x6C, + 0xB0, 0x9B, 0xAE, 0xDC, 0xEF, 0xD6, 0x4B, 0x9E, + 0xAA, 0xD3, 0xDD, 0xC3, 0x70, 0xFD, 0x54, 0xA2, + 0x9B, 0xA2, 0x7E, 0xC6, 0x46, 0x77, 0x3E, 0xC9 + }, + { + 0x73, 0xB5, 0x6E, 0x6F, 0x7F, 0x3D, 0xE4, 0xCF, + 0x83, 0xD1, 0x8D, 0xE6, 0x81, 0x5A, 0x6F, 0x59, + 0x33, 0xEF, 0x4E, 0x12, 0x07, 0x40, 0xF4, 0xF4, + 0x01, 0xF6, 0xD4, 0xF9, 0x0D, 0x76, 0xC3, 0xAC + }, + { + 0x85, 0x57, 0xE8, 0x48, 0xD7, 0x4B, 0x82, 0x93, + 0xF9, 0x72, 0xBA, 0x10, 0x69, 0x16, 0xA1, 0xAC, + 0x62, 0xEE, 0x72, 0x36, 0x13, 0xE7, 0xA6, 0xFF, + 0x24, 0xC3, 0x30, 0xA8, 0xD4, 0x04, 0x10, 0xCA + }, + { + 0x5B, 0x67, 0xF2, 0x15, 0x15, 0xF6, 0x55, 0x8F, + 0x27, 0xF3, 0x12, 0x9C, 0x28, 0x20, 0x71, 0x87, + 0xBB, 0x8C, 0xB3, 0xEC, 0xCC, 0x98, 0xB0, 0xA1, + 0x10, 0x14, 0x0E, 0xEA, 0x30, 0x89, 0x59, 0x2B + }, + { + 0x35, 0xF3, 0x60, 0x37, 0x6E, 0x43, 0x88, 0xCA, + 0x0F, 0x32, 0xCC, 0x77, 0xED, 0x17, 0x6A, 0x26, + 0x25, 0x99, 0x00, 0xF4, 0xB3, 0x5B, 0xC7, 0xC0, + 0x8B, 0x82, 0x77, 0x7D, 0x45, 0x3A, 0x1A, 0xA9 + }, + { + 0x27, 0xA6, 0xAD, 0xEE, 0xF7, 0x49, 0x81, 0xE4, + 0x82, 0xCB, 0x4C, 0xDC, 0x33, 0x3D, 0x84, 0x5C, + 0x12, 0x73, 0xE5, 0xA7, 0x45, 0xF9, 0xFB, 0x3E, + 0x8C, 0x03, 0xA6, 0x5F, 0x57, 0xB4, 0x24, 0x4B + }, + { + 0x89, 0xF1, 0x66, 0x91, 0xAA, 0x5A, 0x6F, 0x14, + 0x12, 0xD8, 0x2D, 0xF7, 0xC5, 0x9C, 0x04, 0x38, + 0x49, 0xBA, 0x88, 0x6A, 0xC2, 0xA9, 0xF0, 0xB8, + 0xBC, 0x0F, 0x12, 0xE4, 0xFA, 0xF9, 0x53, 0xA5 + }, + { + 0x9E, 0x0B, 0x67, 0x61, 0x05, 0x04, 0x95, 0xCE, + 0x8F, 0xBE, 0x7A, 0x00, 0x23, 0xD6, 0xCB, 0x06, + 0x3F, 0xF7, 0x75, 0xC3, 0x43, 0x7A, 0x8D, 0x29, + 0xB6, 0x77, 0x27, 0x5E, 0xA0, 0x9C, 0x54, 0x8F + }, + { + 0x03, 0xED, 0x36, 0x3A, 0x6F, 0x99, 0x73, 0x38, + 0x39, 0x4B, 0xB7, 0x2C, 0x64, 0xD9, 0xF8, 0xC3, + 0xC9, 0xB2, 0x27, 0xBF, 0x32, 0xF4, 0xD4, 0xD3, + 0x24, 0x73, 0xAD, 0xF7, 0x2E, 0x3B, 0x5D, 0xCB + }, + { + 0x2D, 0x69, 0x60, 0x13, 0x79, 0x8F, 0xD4, 0x68, + 0xD0, 0xCF, 0x6A, 0x26, 0x53, 0x36, 0x12, 0x4D, + 0x55, 0xF1, 0xCC, 0xA5, 0x76, 0x27, 0x3F, 0x66, + 0xFB, 0x4F, 0xFF, 0x54, 0x85, 0x63, 0x94, 0xDA + }, + { + 0x64, 0x75, 0x0A, 0x6A, 0xC5, 0x92, 0xCC, 0xAE, + 0xC6, 0x16, 0x1C, 0x23, 0x39, 0x5B, 0x68, 0x4C, + 0xEF, 0xFB, 0xCB, 0x95, 0x7E, 0x5F, 0x5B, 0x6E, + 0x8A, 0xD8, 0x2C, 0xC3, 0x71, 0xAC, 0x30, 0x51 + }, + { + 0x61, 0xE1, 0xA9, 0x95, 0x99, 0xB1, 0x15, 0xFC, + 0xC9, 0x66, 0x5F, 0x6D, 0x5F, 0x73, 0xE7, 0x06, + 0xC4, 0xEC, 0xA4, 0x57, 0xC2, 0x1E, 0x88, 0x7A, + 0xD9, 0x5A, 0x14, 0x55, 0x03, 0x34, 0x95, 0x67 + }, + { + 0x9F, 0xAF, 0x40, 0x62, 0x67, 0x08, 0x5B, 0xD2, + 0x33, 0x01, 0x85, 0x89, 0x20, 0x2B, 0x70, 0x85, + 0xCE, 0xAE, 0x8F, 0x12, 0xA7, 0xE4, 0x15, 0x3D, + 0x1D, 0x6A, 0xFF, 0xFD, 0xE1, 0xF5, 0x06, 0x1E + }, + { + 0x85, 0xAA, 0x2D, 0x5A, 0x55, 0xDC, 0x98, 0x9E, + 0xFB, 0xBE, 0x66, 0x55, 0x3F, 0xF8, 0x57, 0xDD, + 0x7F, 0x84, 0x81, 0xC5, 0xD6, 0xF6, 0x27, 0xE0, + 0x79, 0xE2, 0xA1, 0x0D, 0x78, 0xA7, 0xDE, 0xBB + }, + { + 0xE0, 0xB2, 0xB8, 0x95, 0xE1, 0xE1, 0x2F, 0xAE, + 0x43, 0xE9, 0xD6, 0x93, 0xC1, 0xF4, 0x5A, 0x12, + 0xFD, 0x6D, 0xCB, 0xA7, 0x32, 0x0E, 0x8C, 0x46, + 0x5F, 0x47, 0xDC, 0x9C, 0xED, 0x3F, 0xEC, 0xD1 + }, + { + 0x54, 0x55, 0xEB, 0x1A, 0xA3, 0xDE, 0x0B, 0x78, + 0xA0, 0xD6, 0xAB, 0x1A, 0xD5, 0xD2, 0xB5, 0x52, + 0x18, 0x76, 0x05, 0x1C, 0x48, 0xB4, 0xC7, 0x62, + 0x6F, 0x71, 0xA5, 0xE1, 0xF0, 0x26, 0xFA, 0xAE + }, + { + 0xF8, 0xB5, 0x71, 0xB1, 0x5E, 0x12, 0x0F, 0xF7, + 0x3B, 0x54, 0x71, 0x3C, 0x8D, 0x60, 0x75, 0x18, + 0x5E, 0x84, 0x1D, 0x31, 0xD3, 0x9F, 0xEE, 0x6A, + 0x1B, 0x3B, 0xFB, 0xAA, 0x1F, 0xF2, 0xD7, 0x63 + }, + { + 0x9D, 0x3B, 0x3A, 0x42, 0x11, 0xBD, 0x26, 0x8D, + 0xF9, 0xDA, 0x59, 0x03, 0x0C, 0x78, 0x2F, 0x44, + 0x99, 0xF6, 0xF8, 0x6C, 0x6D, 0x61, 0x27, 0x8C, + 0x71, 0x31, 0x95, 0xFC, 0x59, 0x7A, 0x86, 0x78 + }, + { + 0x40, 0x8A, 0x06, 0xF5, 0x18, 0xFF, 0x8B, 0xBC, + 0x21, 0x0C, 0x0D, 0x2F, 0xFF, 0x61, 0x20, 0x9E, + 0x76, 0x09, 0x2C, 0x74, 0xF3, 0x27, 0x20, 0x02, + 0xBC, 0xE8, 0x53, 0x91, 0xE2, 0x90, 0x82, 0x49 + }, + { + 0x96, 0xFF, 0xA6, 0x18, 0xB8, 0x53, 0x33, 0x2A, + 0x0B, 0x33, 0x3A, 0xD2, 0x2D, 0x64, 0x98, 0x46, + 0xAB, 0x65, 0xF7, 0xA4, 0x23, 0x1F, 0xFF, 0x72, + 0x61, 0x60, 0x36, 0x4C, 0x4C, 0xBE, 0x66, 0xE8 + }, + { + 0x11, 0x76, 0xF4, 0x51, 0x41, 0xCB, 0x11, 0x82, + 0x2D, 0xBF, 0x7E, 0x2A, 0xD0, 0x23, 0x55, 0x24, + 0x76, 0xCC, 0x5C, 0x8B, 0x93, 0x36, 0x32, 0xA1, + 0x73, 0x55, 0x0A, 0xCE, 0xC6, 0xA1, 0xD2, 0xCC + }, + { + 0x56, 0x91, 0x7D, 0xA1, 0xE5, 0x8B, 0x9D, 0x60, + 0x7D, 0x79, 0x30, 0xF9, 0xDB, 0x1B, 0x4A, 0x87, + 0xE1, 0x5F, 0x68, 0xE6, 0x4C, 0xAE, 0x34, 0x07, + 0x19, 0x55, 0xF4, 0x50, 0x2A, 0xC3, 0xAB, 0x36 + }, + { + 0x4B, 0xE6, 0x1B, 0xD7, 0x73, 0xFC, 0x14, 0xB8, + 0x72, 0xCA, 0x1E, 0xEF, 0xEF, 0xBD, 0x5B, 0x94, + 0xEC, 0x5F, 0x43, 0x05, 0x20, 0xBD, 0x16, 0x22, + 0x9E, 0x46, 0x37, 0xB3, 0x4F, 0xA5, 0xC9, 0x3F + }, + { + 0x5C, 0x9A, 0x54, 0x88, 0x43, 0x6B, 0x96, 0x32, + 0x81, 0x4A, 0x7C, 0x03, 0x26, 0xB1, 0xB2, 0xBA, + 0x0D, 0x27, 0x2C, 0x1D, 0xD1, 0xA3, 0x34, 0x26, + 0xB8, 0x82, 0x93, 0x07, 0xD7, 0x0F, 0x04, 0x8D + }, + { + 0x57, 0x44, 0x93, 0x2B, 0x54, 0x25, 0xF5, 0x22, + 0x45, 0x94, 0x60, 0xD9, 0xC9, 0x14, 0xAE, 0x64, + 0x9D, 0xE6, 0xDF, 0x09, 0x99, 0x47, 0xC2, 0xA9, + 0x42, 0xE0, 0xA1, 0xDD, 0x05, 0x74, 0xF9, 0x4E + }, + { + 0x08, 0xE4, 0xC2, 0x49, 0x52, 0x5E, 0x62, 0x77, + 0x6B, 0x0D, 0xF9, 0x55, 0x3E, 0x3D, 0x17, 0x83, + 0xCC, 0x97, 0x6B, 0xD3, 0xE8, 0x3E, 0x0F, 0x7E, + 0x15, 0xA9, 0xF9, 0x21, 0xC0, 0xF6, 0xF7, 0xC8 + }, + { + 0xAE, 0x58, 0x73, 0xFB, 0x21, 0x51, 0xDA, 0x46, + 0x9E, 0x7B, 0xFA, 0x40, 0x1B, 0xA2, 0x29, 0xD8, + 0x4C, 0x42, 0x4C, 0x38, 0x21, 0x8A, 0xED, 0xCB, + 0x47, 0x43, 0x2B, 0x40, 0x9B, 0x02, 0x4D, 0xD7 + }, + { + 0x14, 0x1E, 0xD8, 0x59, 0x8B, 0xC2, 0x3B, 0xC8, + 0xEA, 0x42, 0xF4, 0x38, 0xF1, 0xC9, 0x55, 0x3B, + 0x39, 0x2F, 0x25, 0xD3, 0x98, 0x08, 0xA3, 0x6E, + 0xBF, 0x07, 0xDF, 0x73, 0xD7, 0x8E, 0x7B, 0x11 + }, + { + 0xC9, 0x93, 0xBB, 0x46, 0xFB, 0xE4, 0xE1, 0x39, + 0xEB, 0x41, 0xCD, 0x37, 0x9F, 0xD9, 0x9E, 0x42, + 0xB2, 0x40, 0x33, 0x4F, 0x6D, 0x92, 0x31, 0x5C, + 0xB6, 0xA6, 0xDA, 0x17, 0x76, 0xE3, 0xC0, 0xB4 + }, + { + 0xB5, 0xD0, 0x8D, 0x07, 0xB1, 0xAE, 0x6E, 0x72, + 0x6F, 0x45, 0x29, 0x5D, 0x6B, 0x30, 0x8C, 0x36, + 0x21, 0xC9, 0x6D, 0xFE, 0xDC, 0xAC, 0x47, 0xAA, + 0x79, 0x08, 0x4E, 0x24, 0xA5, 0x84, 0xB0, 0x83 + }, + { + 0xA9, 0x64, 0x50, 0xDD, 0x8D, 0x4B, 0x43, 0x5B, + 0x99, 0x82, 0xEE, 0x10, 0x3C, 0x47, 0x11, 0x74, + 0xAE, 0x75, 0x20, 0x83, 0xA4, 0x14, 0x0B, 0xC3, + 0x83, 0xE3, 0xBD, 0x09, 0xE4, 0x89, 0xB8, 0x32 + }, + { + 0xEC, 0xB6, 0x2C, 0xC7, 0xD7, 0x8D, 0x3C, 0x97, + 0x64, 0x68, 0x02, 0x5F, 0x39, 0x10, 0xBD, 0xF2, + 0xE3, 0xAB, 0x51, 0x10, 0x75, 0xB1, 0x60, 0x82, + 0x56, 0x9E, 0xEE, 0xB9, 0x3B, 0xD6, 0x36, 0xB1 + }, + { + 0xCC, 0x92, 0xB0, 0xD2, 0x38, 0x7B, 0x59, 0xE7, + 0xB8, 0x62, 0x59, 0x44, 0xFF, 0x6C, 0x60, 0xD8, + 0x72, 0xB9, 0xD6, 0xF9, 0x48, 0x18, 0x48, 0x4B, + 0x45, 0x07, 0xCD, 0x6A, 0xD7, 0x09, 0xDA, 0xB3 + }, + { + 0xEE, 0xEF, 0x3B, 0x09, 0x2A, 0x06, 0x30, 0xB5, + 0x7D, 0x49, 0x38, 0xD1, 0x1C, 0x9B, 0x66, 0xA3, + 0xC0, 0x64, 0xF8, 0x6B, 0xC0, 0x35, 0x8D, 0xA4, + 0x23, 0x8A, 0x98, 0xD6, 0x88, 0x6B, 0xCD, 0xC7 + }, + { + 0x91, 0xDB, 0x0A, 0x27, 0xF9, 0x21, 0x67, 0xEF, + 0x34, 0x39, 0x5F, 0x45, 0xB9, 0x8B, 0xC2, 0xAA, + 0x91, 0xAB, 0xB7, 0xFE, 0xD5, 0x69, 0x00, 0xE0, + 0xEE, 0x65, 0xB4, 0x18, 0x8A, 0x40, 0xAA, 0x48 + }, + { + 0x0D, 0x7B, 0xB9, 0xCC, 0x2C, 0xB9, 0x04, 0x89, + 0xFA, 0xA7, 0x12, 0xB8, 0x3F, 0x16, 0x89, 0x5C, + 0x97, 0xD3, 0xE0, 0x35, 0x04, 0x7E, 0x4B, 0xDD, + 0xC5, 0xF5, 0xDC, 0xA3, 0xB2, 0xBE, 0x0C, 0x2B + }, + { + 0x86, 0x44, 0x6F, 0xBD, 0xBD, 0x91, 0xA0, 0x9C, + 0x55, 0x89, 0xE6, 0x0B, 0x23, 0x86, 0x9C, 0xE4, + 0x67, 0xEA, 0x24, 0x1B, 0x91, 0x2D, 0x97, 0x73, + 0x67, 0x17, 0x76, 0xE3, 0xBD, 0xC7, 0x47, 0xC7 + }, + { + 0xAB, 0x29, 0x7D, 0x5B, 0x10, 0xEC, 0x2E, 0xDD, + 0xF2, 0xB8, 0xBD, 0xC2, 0xD7, 0x63, 0xB2, 0xED, + 0x09, 0xFB, 0x38, 0x32, 0xC4, 0xA1, 0xBF, 0x14, + 0x14, 0xB1, 0x08, 0x96, 0x15, 0x7C, 0xC5, 0x42 + }, + { + 0x33, 0x33, 0x85, 0xC4, 0x38, 0x82, 0xF4, 0x14, + 0x91, 0xD4, 0x74, 0x4B, 0xBF, 0x8B, 0x0B, 0x89, + 0xAC, 0x44, 0xC2, 0x51, 0x1A, 0x70, 0x5C, 0x8B, + 0x3E, 0x9D, 0x73, 0x2B, 0xA6, 0x2A, 0xD2, 0x37 + }, + { + 0x8C, 0x22, 0x30, 0xA8, 0x4C, 0xFF, 0x9E, 0x1C, + 0x01, 0x63, 0xD5, 0xE1, 0x4F, 0xDE, 0x6A, 0x0A, + 0xB0, 0x93, 0xB5, 0xC0, 0xB7, 0x18, 0x6B, 0x7C, + 0x5A, 0x1F, 0x8E, 0x0D, 0x2A, 0xA3, 0x5B, 0x08 + }, + { + 0xD4, 0x4D, 0x9A, 0xDA, 0xDE, 0xC6, 0x19, 0x4E, + 0x94, 0xDE, 0x0F, 0xF3, 0xD0, 0xE3, 0xA3, 0xB7, + 0x00, 0x31, 0x3C, 0x1A, 0x35, 0x7E, 0xA1, 0xFA, + 0xD0, 0xA0, 0xCE, 0xB1, 0x6A, 0xD3, 0x9F, 0xB6 + }, + { + 0xF2, 0xBF, 0x7E, 0xA5, 0x42, 0x20, 0x46, 0xAE, + 0x18, 0x6E, 0x69, 0xB6, 0x49, 0x8A, 0x1D, 0x6B, + 0xE9, 0x13, 0x87, 0x97, 0x7B, 0xE8, 0x3C, 0xE0, + 0xA2, 0x56, 0x57, 0x71, 0xE3, 0x89, 0x20, 0xEB + }, + { + 0x1E, 0x98, 0xB9, 0x0E, 0x27, 0xD9, 0x63, 0x8B, + 0x5B, 0xFB, 0xEE, 0x46, 0xDD, 0x3A, 0x21, 0x72, + 0x10, 0x0F, 0x23, 0xC4, 0xFF, 0x2A, 0x1C, 0x9A, + 0x10, 0x04, 0xA1, 0x0F, 0x32, 0xC1, 0x5F, 0x10 + }, + { + 0xED, 0xDE, 0x7C, 0xE9, 0x11, 0xD5, 0xD2, 0xB2, + 0xF1, 0x60, 0xCC, 0xF1, 0x56, 0xD9, 0x96, 0x12, + 0xB3, 0x5B, 0xEA, 0x1C, 0x49, 0x49, 0xC9, 0x6C, + 0x49, 0x69, 0x16, 0xE9, 0x31, 0xFE, 0xEA, 0xD8 + }, + { + 0xFD, 0xD0, 0x45, 0x15, 0x9E, 0x57, 0x0E, 0xF1, + 0x5B, 0xDC, 0xF2, 0x59, 0x01, 0xC1, 0xF9, 0x46, + 0x0C, 0x9A, 0x74, 0x92, 0x43, 0xFE, 0x91, 0x1C, + 0xB6, 0x67, 0xE9, 0x2C, 0xAF, 0x4C, 0x8C, 0x20 + }, + { + 0x78, 0x53, 0x4D, 0x17, 0x87, 0x25, 0xBF, 0xC1, + 0x8D, 0xCD, 0xE6, 0xE3, 0x88, 0x13, 0x2B, 0x1B, + 0x07, 0x7B, 0x45, 0x99, 0xB8, 0xB3, 0x82, 0x21, + 0x35, 0x66, 0xF3, 0x7A, 0x5C, 0x77, 0x84, 0x59 + }, + { + 0x89, 0x33, 0x0E, 0xA0, 0x68, 0xFA, 0x9C, 0x1E, + 0x3A, 0x2D, 0xD2, 0x4A, 0xEF, 0x34, 0x9A, 0x3E, + 0xE3, 0x76, 0x5D, 0x65, 0x8D, 0x22, 0x8B, 0x39, + 0xFE, 0x82, 0xF6, 0x4E, 0xA9, 0x66, 0x0A, 0xCB + }, + { + 0xCA, 0x9F, 0x68, 0x46, 0xE9, 0x38, 0xC6, 0x71, + 0xF4, 0xF5, 0x99, 0x57, 0xE0, 0x83, 0xC6, 0xF4, + 0x35, 0xF3, 0x73, 0xA0, 0x76, 0xFC, 0x72, 0x5B, + 0xDC, 0x9A, 0xD2, 0xF5, 0xE9, 0xBA, 0x01, 0x41 + }, + { + 0x15, 0x20, 0xF0, 0x49, 0xF3, 0xBB, 0xAD, 0xBE, + 0xD2, 0xEC, 0x54, 0x69, 0xAD, 0xEB, 0x37, 0x12, + 0x64, 0x20, 0xBF, 0x95, 0x0F, 0x72, 0x46, 0x4A, + 0x60, 0x57, 0xC9, 0xBF, 0xB4, 0x73, 0x01, 0xF5 + }, + { + 0x92, 0x4C, 0x6A, 0x02, 0xBA, 0x10, 0x95, 0xB4, + 0x26, 0x20, 0x15, 0x7F, 0x31, 0xC6, 0x6B, 0x02, + 0xF5, 0xE7, 0xAB, 0xCF, 0x53, 0x57, 0x0D, 0x06, + 0x50, 0x6F, 0x50, 0xF7, 0xD1, 0x4E, 0x2C, 0x0F + }, + { + 0x41, 0xB8, 0x7A, 0x31, 0xFB, 0x46, 0x51, 0x51, + 0x5A, 0xF3, 0x17, 0xF2, 0x26, 0x2A, 0xC6, 0x92, + 0x57, 0x89, 0x35, 0xA7, 0xA3, 0x29, 0xD0, 0x17, + 0xA7, 0x78, 0x6A, 0xD4, 0xB1, 0x0F, 0x96, 0x33 + }, + { + 0x0F, 0x77, 0xEA, 0x2B, 0xED, 0xB2, 0x33, 0x13, + 0x61, 0x61, 0x34, 0xDA, 0x20, 0x60, 0x9F, 0xBF, + 0x7B, 0x4B, 0xB4, 0xF9, 0xF5, 0x45, 0xD1, 0xC9, + 0xEB, 0x27, 0xD0, 0x33, 0x8A, 0x96, 0x1A, 0x21 + }, + { + 0x75, 0xB1, 0xB6, 0xC8, 0xDA, 0xDC, 0x62, 0xAC, + 0x94, 0x11, 0x55, 0xBF, 0x41, 0xE8, 0x04, 0xED, + 0x69, 0xF0, 0x86, 0xD7, 0x28, 0x5B, 0xAA, 0x1F, + 0x3B, 0xBC, 0x70, 0x6F, 0x6F, 0xA9, 0x65, 0x05 + }, + { + 0x4C, 0x50, 0x7A, 0xFC, 0x8B, 0xD9, 0x65, 0xA4, + 0xE0, 0x27, 0x3F, 0x61, 0xBF, 0x4D, 0x5F, 0xA0, + 0x8F, 0x88, 0x53, 0xDD, 0x0D, 0x7B, 0x35, 0x31, + 0x8E, 0x4E, 0x6F, 0x4F, 0x5B, 0xC3, 0xF5, 0x7D + }, + { + 0x03, 0xEE, 0x0C, 0x4C, 0x83, 0xF2, 0xF7, 0xE0, + 0x84, 0x35, 0xC5, 0x62, 0x42, 0xE7, 0x5B, 0x5A, + 0x4C, 0xA3, 0x44, 0x65, 0xA5, 0x68, 0x3A, 0xBD, + 0x0B, 0x2E, 0xC9, 0x4D, 0x94, 0x21, 0x9B, 0x15 + }, + { + 0x8E, 0x1A, 0x29, 0xEC, 0xE6, 0x67, 0x60, 0x54, + 0x01, 0xA7, 0x32, 0xC6, 0x88, 0x92, 0x8C, 0xA4, + 0x42, 0x69, 0xCD, 0x84, 0x97, 0x47, 0xB4, 0xD8, + 0xED, 0x36, 0xFC, 0x7E, 0x93, 0xC5, 0xB7, 0x28 + }, + { + 0x86, 0xDB, 0x35, 0xE4, 0xEC, 0x7C, 0xB6, 0xA1, + 0xEE, 0xA6, 0x6D, 0xB2, 0xC3, 0x9F, 0x5F, 0x7D, + 0xFB, 0x8F, 0x93, 0x32, 0x01, 0xFA, 0x0E, 0x5B, + 0x53, 0x8C, 0x36, 0x81, 0xA6, 0x5C, 0x74, 0x47 + }, + { + 0xA3, 0x04, 0x5F, 0x8E, 0x5B, 0x70, 0x81, 0x33, + 0x32, 0x2A, 0x6C, 0xD9, 0x90, 0x6D, 0xFB, 0x97, + 0xE4, 0x4A, 0x62, 0xBC, 0xD7, 0x79, 0x23, 0xD3, + 0x55, 0x4E, 0xCE, 0xDB, 0x8A, 0x16, 0x73, 0x46 + }, + { + 0x34, 0x8F, 0x30, 0x8A, 0x4D, 0x9C, 0x75, 0x83, + 0x0F, 0x4E, 0xDD, 0x1A, 0x0A, 0x90, 0xB8, 0x09, + 0x73, 0x93, 0x1D, 0xA3, 0x3A, 0x18, 0x0C, 0x70, + 0x8D, 0x8E, 0xB7, 0x03, 0x80, 0xA4, 0x4C, 0x46 + }, + { + 0xC6, 0x00, 0x45, 0xC4, 0x70, 0xCE, 0x90, 0x0E, + 0xDB, 0x45, 0xBF, 0xBD, 0x5B, 0x24, 0x8C, 0xAB, + 0x57, 0xBD, 0xA7, 0x66, 0xA8, 0xBF, 0x5E, 0xBD, + 0xF8, 0xA9, 0x94, 0xDB, 0x2D, 0xB2, 0x78, 0xCF + }, + { + 0x32, 0xD5, 0x5F, 0xF2, 0x17, 0x20, 0xAB, 0xDC, + 0xC2, 0x72, 0x40, 0x87, 0x01, 0x0D, 0xC5, 0xB5, + 0xC1, 0x6D, 0x02, 0x1E, 0x39, 0x4D, 0xFA, 0xA4, + 0x82, 0x35, 0xE0, 0x67, 0x8F, 0x69, 0xF1, 0xDF + }, + { + 0x39, 0x53, 0x84, 0x9D, 0x53, 0x91, 0x57, 0x38, + 0x41, 0x3F, 0x44, 0x26, 0xAB, 0x34, 0x51, 0x32, + 0xE3, 0x64, 0xF4, 0x77, 0x51, 0x04, 0xE0, 0x10, + 0xD8, 0x03, 0x34, 0x5B, 0x5C, 0x45, 0x03, 0x29 + }, + { + 0x1E, 0xCF, 0x6D, 0x31, 0xFF, 0x03, 0x49, 0x9A, + 0xF8, 0x47, 0x99, 0xF8, 0xF1, 0xA1, 0xE6, 0xF3, + 0xAB, 0x0C, 0xCE, 0x63, 0x31, 0xA0, 0x5F, 0x42, + 0x84, 0x02, 0xA9, 0xA1, 0x05, 0x92, 0x88, 0x2B + }, + { + 0x30, 0x08, 0x01, 0xFF, 0x5B, 0x55, 0x8C, 0x65, + 0x97, 0xA9, 0x73, 0x4B, 0xC8, 0x5E, 0xA8, 0xC9, + 0x21, 0x98, 0x8A, 0x40, 0x1B, 0x07, 0xE0, 0xFE, + 0x34, 0xF5, 0xD3, 0x6C, 0x49, 0xAC, 0xDE, 0x0D + }, + { + 0x1F, 0x25, 0xD0, 0xB9, 0x92, 0x18, 0x74, 0x71, + 0xD8, 0x2B, 0xCC, 0xB4, 0x45, 0xCF, 0x2D, 0x6F, + 0x04, 0x2C, 0xF9, 0x4A, 0x4A, 0x8F, 0xBB, 0x7C, + 0x19, 0x24, 0x12, 0x6A, 0xB0, 0x78, 0x6C, 0x98 + }, + { + 0x71, 0x7D, 0xA4, 0x57, 0x5A, 0x6E, 0x49, 0xFF, + 0xB8, 0xDE, 0xFA, 0x4A, 0x5D, 0xD7, 0xDF, 0xC1, + 0x49, 0x7C, 0xDA, 0xA8, 0x16, 0xD3, 0x8C, 0x9A, + 0xCA, 0x35, 0x70, 0x42, 0x5C, 0x14, 0xD0, 0x90 + }, + { + 0xCE, 0xBD, 0x04, 0xF9, 0xDA, 0x55, 0xBF, 0xFC, + 0x28, 0x9E, 0x3E, 0x4F, 0xC4, 0x17, 0xA9, 0x74, + 0x67, 0xC5, 0xAB, 0x60, 0x58, 0x9E, 0xF3, 0xE7, + 0x98, 0x5A, 0x37, 0x5A, 0x55, 0x68, 0x15, 0x75 + }, + { + 0x57, 0x12, 0xFD, 0xF7, 0xD0, 0x7A, 0x79, 0xDC, + 0x06, 0x42, 0x2F, 0xE3, 0x3F, 0x1D, 0xCB, 0x35, + 0x0F, 0xF9, 0x33, 0x2A, 0xE9, 0xAD, 0x2C, 0x1F, + 0xB9, 0x3A, 0xBB, 0x8B, 0xE0, 0x51, 0xF7, 0x69 + }, + { + 0xAA, 0x9C, 0x2A, 0x99, 0x4A, 0x9B, 0xB6, 0xB2, + 0xE5, 0x52, 0x86, 0x5D, 0x1B, 0xDF, 0xBE, 0xB6, + 0xE5, 0x9C, 0x49, 0xE9, 0xCD, 0x48, 0x97, 0x04, + 0x72, 0x1B, 0x62, 0xE8, 0xB4, 0xD8, 0x2C, 0x5C + }, + { + 0x0F, 0x3F, 0x1E, 0x83, 0x2B, 0xD3, 0xB3, 0x55, + 0xFA, 0x71, 0x05, 0xB2, 0xFE, 0x7C, 0x34, 0xEC, + 0x06, 0x66, 0x40, 0x60, 0x5E, 0x34, 0x4C, 0x32, + 0xA7, 0xD2, 0xC8, 0xA1, 0x4D, 0x0C, 0xDC, 0x1B + }, + { + 0xB2, 0xAB, 0x68, 0x4F, 0x39, 0x52, 0x02, 0xDB, + 0xE7, 0xD3, 0xDE, 0x93, 0xC4, 0x8F, 0x16, 0xC7, + 0x27, 0xA0, 0x93, 0xBF, 0xCA, 0x4A, 0x96, 0xF6, + 0x71, 0x79, 0x52, 0x6B, 0x4A, 0xBD, 0xAD, 0x58 + }, + { + 0xF9, 0xF3, 0x7A, 0x1F, 0x96, 0xEB, 0xAE, 0x93, + 0xBA, 0x53, 0x97, 0xA1, 0x01, 0xD3, 0x25, 0xB0, + 0x18, 0xB7, 0x52, 0x9C, 0x75, 0x51, 0xD4, 0x71, + 0x73, 0x16, 0x3A, 0xF6, 0x61, 0xFF, 0xF8, 0xD3 + }, + { + 0x7D, 0x81, 0xF9, 0xEC, 0xB2, 0x7E, 0xE2, 0x0D, + 0x05, 0x23, 0xB2, 0xFA, 0x7E, 0xA7, 0x54, 0x69, + 0x54, 0xF7, 0xC7, 0x53, 0x94, 0x8E, 0x57, 0x85, + 0xD2, 0x42, 0x56, 0x6E, 0x90, 0xFF, 0xB6, 0x8C + }, + { + 0xFF, 0xF7, 0xC6, 0x3A, 0x0D, 0x6F, 0x06, 0xD5, + 0xF5, 0x35, 0xE5, 0x5E, 0x7F, 0x60, 0xCE, 0xF7, + 0x27, 0x56, 0xC7, 0x9E, 0x72, 0x4D, 0x24, 0xE4, + 0x2C, 0xFF, 0x8E, 0x8E, 0xFE, 0xD9, 0xC7, 0x8A + }, + { + 0x82, 0x5D, 0xF1, 0x39, 0xF6, 0x48, 0x27, 0x26, + 0x25, 0x22, 0x68, 0x17, 0xC0, 0xB5, 0x21, 0x59, + 0xB9, 0xD7, 0x25, 0xAF, 0xBF, 0x9C, 0xFD, 0x88, + 0x20, 0x82, 0x87, 0xB6, 0xBE, 0xC8, 0xC7, 0xAB + }, + { + 0x18, 0x53, 0x19, 0xC4, 0xE9, 0xD3, 0xAE, 0x23, + 0x8B, 0x66, 0xC4, 0x5F, 0x7C, 0x5C, 0x19, 0xBD, + 0x54, 0xFB, 0xD3, 0x76, 0x71, 0x0E, 0xF3, 0x72, + 0x1B, 0xAF, 0x1D, 0x74, 0x12, 0xC5, 0x54, 0x69 + }, + { + 0x9B, 0xBC, 0x13, 0xF8, 0x25, 0xCB, 0x2D, 0x44, + 0xE2, 0x18, 0x67, 0x76, 0xB4, 0x61, 0xD8, 0xD0, + 0xFD, 0x96, 0x0E, 0x16, 0x09, 0xE1, 0x9D, 0x04, + 0x4A, 0x07, 0xFF, 0x06, 0xAF, 0x19, 0x93, 0xEB + }, + { + 0x83, 0xCB, 0x45, 0x0A, 0xD7, 0xB7, 0xCE, 0x4F, + 0x07, 0x7B, 0x6C, 0xCA, 0x9A, 0xFA, 0x24, 0xC3, + 0xB6, 0x57, 0x3A, 0x7D, 0x10, 0xBA, 0x0C, 0xDE, + 0x0C, 0x7D, 0xEC, 0xA6, 0x6E, 0xBA, 0xCE, 0x7E + }, + { + 0x14, 0xBD, 0xEF, 0x83, 0x88, 0x6E, 0xE0, 0xBA, + 0xEA, 0xA9, 0xE1, 0x22, 0x9B, 0xCC, 0xF8, 0x22, + 0xE8, 0xEA, 0x4B, 0xC6, 0x18, 0x37, 0x16, 0xB4, + 0x63, 0xFF, 0x44, 0x63, 0x5D, 0x46, 0x3B, 0x92 + }, + { + 0x98, 0x2F, 0xFA, 0x4D, 0x76, 0xD0, 0xA4, 0xC5, + 0x68, 0x6C, 0xC5, 0x5A, 0xC0, 0x9B, 0x47, 0xAF, + 0x9A, 0x15, 0x29, 0x2D, 0x55, 0x58, 0x08, 0x76, + 0x98, 0x1B, 0xB6, 0x03, 0x6C, 0x6B, 0x3A, 0x14 + }, + { + 0xBE, 0xF2, 0x11, 0x3F, 0x73, 0xFF, 0x05, 0xE2, + 0xBA, 0x87, 0x7D, 0x7A, 0x0D, 0x07, 0x96, 0x04, + 0x6A, 0x38, 0x38, 0x42, 0x83, 0xDA, 0x01, 0x7E, + 0xC8, 0xA3, 0xB3, 0x00, 0x46, 0xCC, 0x3A, 0x36 + }, + { + 0xAE, 0xD1, 0x83, 0xA3, 0xCD, 0xF1, 0xEA, 0x9C, + 0xE2, 0x08, 0xB3, 0x24, 0x38, 0xFF, 0x3D, 0xDC, + 0x7A, 0x8E, 0xEA, 0xEC, 0x18, 0xA0, 0x66, 0x45, + 0xC1, 0x13, 0xCC, 0x3A, 0x1B, 0x17, 0x49, 0x6A + }, + { + 0xDC, 0xD2, 0xC0, 0x2F, 0x35, 0x1C, 0x25, 0xF8, + 0x49, 0xBB, 0xAA, 0x94, 0x51, 0x85, 0x95, 0x0F, + 0x4B, 0x90, 0xB3, 0x13, 0x95, 0x7E, 0x19, 0xDD, + 0x0A, 0x87, 0x2C, 0x9A, 0xAB, 0x20, 0x36, 0x53 + }, + { + 0x8E, 0xF2, 0xA3, 0x3F, 0x86, 0x47, 0x54, 0x68, + 0xA2, 0x5F, 0xD6, 0x39, 0xF0, 0x37, 0xD5, 0x46, + 0x02, 0xE5, 0xFE, 0xBE, 0x4E, 0xBE, 0xEC, 0x0D, + 0x86, 0x15, 0x39, 0x23, 0x53, 0x05, 0x79, 0xD6 + }, + { + 0x74, 0x8E, 0xB6, 0x20, 0x47, 0x5F, 0x6C, 0x81, + 0x99, 0xE5, 0x78, 0x74, 0x48, 0xC6, 0x4A, 0x0D, + 0xDD, 0x7A, 0xF1, 0xD7, 0xE6, 0x26, 0xF4, 0x37, + 0x5F, 0x42, 0x33, 0xC2, 0x0E, 0xA9, 0x2F, 0x2E + }, + { + 0x47, 0xF9, 0xD4, 0x65, 0x80, 0x9D, 0x32, 0xC1, + 0x46, 0x84, 0x80, 0x64, 0x8D, 0x8E, 0x68, 0xB5, + 0x0B, 0x56, 0x88, 0x10, 0x21, 0x6E, 0x23, 0x3F, + 0xE0, 0xB0, 0x82, 0x74, 0x99, 0x69, 0xC4, 0xBF + }, + { + 0x6C, 0x9C, 0xAB, 0xCF, 0xFA, 0x60, 0x3C, 0x2D, + 0xEC, 0x77, 0x13, 0xB4, 0x53, 0x3F, 0x3C, 0x51, + 0x45, 0xC6, 0x18, 0x43, 0x46, 0xB8, 0x6C, 0x8C, + 0x95, 0x2D, 0xAE, 0x03, 0xCB, 0xF1, 0x4C, 0x80 + }, + { + 0x96, 0xC3, 0x3F, 0xEC, 0x89, 0x16, 0xA5, 0x4A, + 0xBE, 0x1B, 0x8D, 0xF7, 0x5C, 0x72, 0x80, 0x59, + 0x40, 0x08, 0xB6, 0xAC, 0x10, 0x19, 0x93, 0xBD, + 0xD0, 0x94, 0x3F, 0xF1, 0xC2, 0x50, 0x41, 0xC7 + }, + { + 0xB5, 0xB8, 0x8B, 0x1E, 0x16, 0x3E, 0x8B, 0x48, + 0x1C, 0x2D, 0x6F, 0x50, 0xD2, 0x13, 0x9E, 0xDA, + 0x35, 0x75, 0x28, 0x0A, 0x20, 0xD2, 0x85, 0x0B, + 0x1E, 0x5A, 0x0B, 0xF3, 0xA0, 0x81, 0xE9, 0xAD + }, + { + 0xAB, 0xD7, 0x1B, 0x41, 0x74, 0x00, 0x65, 0x05, + 0x54, 0x8B, 0x7B, 0xAB, 0xF0, 0xAF, 0x8E, 0x23, + 0x7E, 0x27, 0xC4, 0xA1, 0xD0, 0x8A, 0x2A, 0xB3, + 0x89, 0x81, 0x2A, 0x9C, 0x2C, 0x98, 0xB3, 0x7B + }, + { + 0xE6, 0x48, 0xFB, 0xED, 0x08, 0x20, 0x47, 0xE4, + 0x8F, 0x18, 0x9D, 0x6E, 0x3B, 0xB1, 0x88, 0x84, + 0xF8, 0xC9, 0x0F, 0xC6, 0xA7, 0x98, 0x3E, 0x14, + 0xE1, 0xF4, 0x68, 0x45, 0x79, 0x03, 0xC9, 0x5D + }, + { + 0x6E, 0x95, 0xC9, 0x54, 0x9B, 0xB9, 0xE5, 0x91, + 0xCE, 0x67, 0x5D, 0x37, 0x46, 0xCA, 0x66, 0x46, + 0x98, 0x86, 0x9C, 0x02, 0x42, 0x66, 0x64, 0x35, + 0x22, 0x63, 0x76, 0xB1, 0x89, 0xC3, 0x86, 0x1D + }, + { + 0x5E, 0xF3, 0x24, 0x2B, 0xAE, 0xC7, 0x24, 0x3F, + 0x49, 0x23, 0xBD, 0xCE, 0xA7, 0x2D, 0xDD, 0xD3, + 0x00, 0x4F, 0x15, 0x25, 0xAB, 0x6A, 0x23, 0xC8, + 0xAF, 0x23, 0xDC, 0xB0, 0x80, 0xA5, 0x38, 0xF5 + }, + { + 0xB4, 0x92, 0xB8, 0x56, 0xEA, 0x73, 0x39, 0xDC, + 0x87, 0xC2, 0x9C, 0x7D, 0x64, 0xEE, 0x76, 0xDB, + 0x9E, 0xAF, 0x63, 0x32, 0x4B, 0xBF, 0x93, 0x8E, + 0xFB, 0x2F, 0x19, 0x33, 0xC5, 0x3F, 0x31, 0x29 + }, + { + 0xA7, 0x2A, 0xB7, 0xDA, 0x3B, 0x21, 0x08, 0xCF, + 0x48, 0x8C, 0xA3, 0x96, 0x70, 0x06, 0x85, 0x23, + 0x3D, 0xCD, 0x8D, 0x4E, 0x46, 0x66, 0xBF, 0x44, + 0x1D, 0x38, 0xA0, 0xD6, 0x73, 0xF3, 0xD3, 0x36 + }, + { + 0x87, 0x6D, 0x08, 0x2C, 0x36, 0x50, 0xD7, 0x00, + 0xBF, 0x7A, 0x02, 0xF5, 0x2C, 0x65, 0x0B, 0x79, + 0xD6, 0xA6, 0x84, 0xC8, 0x46, 0x6A, 0x3E, 0x5E, + 0x91, 0xA9, 0xB7, 0x4E, 0x2C, 0x58, 0xB5, 0xF5 + }, + { + 0x40, 0xD9, 0xF4, 0x65, 0xD1, 0xCE, 0xC1, 0xCF, + 0x3F, 0x73, 0x11, 0x3C, 0xCB, 0x08, 0xE4, 0xDC, + 0x5A, 0x2D, 0xB5, 0x7E, 0xB9, 0xAA, 0xE0, 0xE6, + 0xFF, 0x2D, 0x44, 0x5B, 0x56, 0x56, 0x92, 0x5A + }, + { + 0xC1, 0x43, 0x60, 0x08, 0x2D, 0xC2, 0xDB, 0x80, + 0x87, 0xC1, 0x41, 0x3C, 0xE5, 0x82, 0xED, 0xC4, + 0xC6, 0xD7, 0x12, 0x35, 0x82, 0x2C, 0xBD, 0x2C, + 0x3B, 0xFD, 0x24, 0x6B, 0x84, 0x61, 0xCA, 0xFA + }, + { + 0x82, 0x55, 0xEA, 0xA5, 0xF0, 0xDF, 0xFE, 0x3E, + 0xBE, 0xE5, 0xE2, 0x2D, 0xEB, 0xF9, 0x1D, 0xFD, + 0xFE, 0x53, 0xA6, 0xBD, 0x9F, 0x93, 0x29, 0x28, + 0x3E, 0x46, 0xC9, 0xEF, 0x30, 0x37, 0x94, 0xC3 + }, + { + 0x80, 0x95, 0x03, 0x61, 0x1C, 0x68, 0xE6, 0x7A, + 0x74, 0x4B, 0x73, 0x94, 0xC4, 0xDD, 0x03, 0xD8, + 0xD5, 0x68, 0x05, 0x7F, 0xF1, 0xB7, 0x03, 0x88, + 0x1F, 0x32, 0xD2, 0xB8, 0x65, 0x42, 0xA7, 0x8E + }, + { + 0x2F, 0x45, 0x16, 0x13, 0x0E, 0x86, 0xC9, 0xB2, + 0x4F, 0xA9, 0x1C, 0xE0, 0x09, 0x3D, 0xAF, 0x53, + 0xD1, 0x6D, 0x90, 0xC8, 0x1A, 0xA0, 0x08, 0xDC, + 0x4D, 0xC9, 0xEA, 0x71, 0x6E, 0x32, 0x3E, 0x31 + }, + { + 0xB5, 0x94, 0x06, 0x3C, 0x01, 0x51, 0xC6, 0x5F, + 0xC4, 0x63, 0x8E, 0xA0, 0x16, 0x59, 0x29, 0x59, + 0x0E, 0x9C, 0x0C, 0xC8, 0xFF, 0x70, 0xDC, 0x55, + 0xA9, 0x59, 0x93, 0x57, 0x27, 0xE2, 0xAF, 0x4B + }, + { + 0x08, 0x78, 0x71, 0xE6, 0xD2, 0xB1, 0x40, 0x0F, + 0xEF, 0xC4, 0x3F, 0x84, 0x74, 0xBC, 0x16, 0x54, + 0x31, 0xE0, 0xA4, 0x30, 0x02, 0xD6, 0xE4, 0x5A, + 0x6D, 0xAF, 0x9F, 0x00, 0x5A, 0x1A, 0x20, 0x66 + }, + { + 0x05, 0x85, 0x88, 0x2D, 0xF5, 0x01, 0x25, 0x45, + 0x81, 0x4E, 0xAC, 0xF0, 0x83, 0xED, 0xFB, 0xF9, + 0x9F, 0x38, 0x88, 0xCE, 0x4C, 0x09, 0x30, 0xD8, + 0xAB, 0x2C, 0xCE, 0x8F, 0x69, 0x85, 0x98, 0xAE + }, + { + 0xE8, 0x02, 0x8F, 0xC4, 0x55, 0xFB, 0x2B, 0x04, + 0x9F, 0x47, 0xBF, 0xD6, 0xC3, 0xD9, 0xB7, 0xFE, + 0xA7, 0xB9, 0xA1, 0x15, 0x32, 0x1B, 0xF2, 0x6E, + 0x88, 0x3E, 0xAF, 0x69, 0xFC, 0xF4, 0x8D, 0x85 + }, + { + 0xB9, 0xCF, 0xFA, 0xAD, 0x79, 0xD5, 0x7B, 0x85, + 0xD4, 0x42, 0x1E, 0xA7, 0x14, 0xB1, 0x2C, 0xDB, + 0x12, 0xF1, 0xE0, 0x5A, 0xF1, 0x42, 0xCB, 0x6C, + 0x8C, 0xDE, 0x1B, 0x64, 0x83, 0xD7, 0x98, 0xDF + }, + { + 0x74, 0xBA, 0xD9, 0xFE, 0xDE, 0xB5, 0xB5, 0x81, + 0xD5, 0xD6, 0x23, 0x94, 0x49, 0xF3, 0xAE, 0x9D, + 0xF1, 0x27, 0x26, 0xB0, 0x89, 0xF2, 0x09, 0xEB, + 0x61, 0x30, 0x2B, 0xCC, 0x87, 0xEF, 0x44, 0x5E + }, + { + 0x1C, 0xE0, 0x70, 0x24, 0x0E, 0xAC, 0x0D, 0xEE, + 0x0A, 0x14, 0x45, 0x48, 0x1B, 0xAE, 0x52, 0x2B, + 0x03, 0x23, 0xA5, 0xAC, 0x3E, 0x6A, 0x40, 0x14, + 0x34, 0x28, 0x76, 0xA5, 0x42, 0xC6, 0x7D, 0xE8 + }, + { + 0xCE, 0x4D, 0x78, 0x13, 0xF3, 0x8E, 0x2E, 0x49, + 0xA6, 0x9C, 0x49, 0x1D, 0x47, 0xC5, 0x87, 0x49, + 0xC3, 0xAB, 0xCA, 0xEE, 0x91, 0x1B, 0x5B, 0x53, + 0x64, 0x7C, 0x7F, 0xC9, 0x7F, 0xF6, 0x06, 0x13 + }, + { + 0x1D, 0xF8, 0xA6, 0xD0, 0x6C, 0x11, 0xA5, 0xF5, + 0xDF, 0x0C, 0x85, 0xC8, 0x44, 0x6F, 0x34, 0x0A, + 0xC1, 0x73, 0xC0, 0xBF, 0x66, 0x7D, 0x6A, 0x02, + 0xD0, 0x75, 0x88, 0x25, 0x96, 0x5C, 0x71, 0xE1 + }, + { + 0xBE, 0xE9, 0xFB, 0x18, 0x0F, 0x64, 0x0B, 0xB3, + 0x5D, 0xEE, 0x40, 0x5B, 0xE3, 0x57, 0x96, 0xF7, + 0xF9, 0xE1, 0x0A, 0x72, 0xF5, 0xFB, 0xE4, 0xC5, + 0x15, 0xF2, 0xD9, 0xAD, 0xDF, 0xAB, 0x68, 0xC1 + }, + { + 0xEB, 0xDF, 0x4D, 0x68, 0xF5, 0x1C, 0x36, 0x2A, + 0x0E, 0x31, 0x7E, 0x0A, 0xA0, 0x2A, 0xBC, 0xF5, + 0xB1, 0x95, 0x77, 0xEA, 0x2E, 0x7A, 0xCB, 0x15, + 0x95, 0x98, 0xA5, 0xA6, 0x7A, 0xDF, 0x4B, 0x21 + }, + { + 0xCD, 0x54, 0x20, 0x90, 0xD0, 0xC2, 0x6B, 0x08, + 0xC3, 0xA5, 0xE0, 0x66, 0x77, 0x19, 0x17, 0x74, + 0x70, 0x3C, 0x3F, 0xF1, 0x65, 0xED, 0x16, 0xC9, + 0xB7, 0x6C, 0xBD, 0xD1, 0x9F, 0x2C, 0x28, 0x86 + }, + { + 0x80, 0xBC, 0x49, 0x4A, 0x38, 0x6A, 0xA7, 0xF9, + 0x89, 0x97, 0x84, 0x7E, 0x83, 0x07, 0xE3, 0xDD, + 0xAA, 0x15, 0x17, 0xE0, 0x5A, 0x05, 0x3B, 0xA9, + 0xE5, 0xD4, 0xBE, 0x5E, 0x8E, 0x1F, 0x06, 0x35 + }, + { + 0x81, 0x10, 0x6B, 0x4D, 0xCA, 0xB8, 0x8C, 0x7B, + 0xEC, 0xDD, 0xA9, 0x4D, 0x49, 0x51, 0x51, 0x6A, + 0x68, 0x04, 0xC2, 0x11, 0x2A, 0x59, 0x6A, 0x28, + 0x48, 0x0D, 0x54, 0x6C, 0x21, 0x9F, 0xF6, 0x18 + }, + { + 0xF0, 0x8A, 0x30, 0xC7, 0x9E, 0xAA, 0x94, 0x45, + 0x6C, 0xEF, 0x70, 0x7B, 0x0C, 0x9C, 0x8A, 0xB2, + 0x52, 0x70, 0x41, 0x88, 0x69, 0x69, 0x56, 0x71, + 0x8A, 0xE2, 0x16, 0xFC, 0x14, 0x52, 0x8A, 0xD3 + }, + { + 0x22, 0x1B, 0x38, 0xBE, 0x12, 0xDC, 0xAA, 0x34, + 0x41, 0xAD, 0x21, 0x20, 0x15, 0x6A, 0x96, 0xDD, + 0x43, 0xB9, 0x54, 0xD7, 0x3B, 0xB0, 0xAC, 0x4C, + 0xB9, 0x6C, 0x00, 0x20, 0x75, 0xB7, 0xCD, 0xE3 + }, + { + 0x12, 0x55, 0x13, 0xE0, 0x94, 0x24, 0x13, 0x53, + 0x7B, 0xBB, 0x94, 0x87, 0x65, 0x68, 0xBF, 0x9F, + 0x31, 0xCB, 0x4A, 0x20, 0xD1, 0x5B, 0x5E, 0xDA, + 0xF6, 0x51, 0x94, 0x8C, 0xB7, 0x2C, 0xF5, 0x30 + }, + { + 0xD4, 0xE3, 0x88, 0xC7, 0x43, 0x1F, 0xBD, 0x3B, + 0xFE, 0x04, 0x33, 0x41, 0x9C, 0xCF, 0x63, 0xFF, + 0xC9, 0x26, 0x73, 0x39, 0xF3, 0x37, 0xEF, 0x0B, + 0x91, 0xD4, 0x36, 0xBC, 0x70, 0xE7, 0x1C, 0x68 + }, + { + 0x86, 0x67, 0x08, 0x19, 0x38, 0xDC, 0x82, 0x6F, + 0x07, 0xC4, 0x21, 0x1C, 0x1D, 0x86, 0x50, 0x59, + 0x68, 0xCE, 0xB2, 0x88, 0x63, 0xB4, 0xA6, 0xCF, + 0xD1, 0x8B, 0x8F, 0x1E, 0x63, 0x21, 0xEB, 0xC8 + }, + { + 0x95, 0xDC, 0xF9, 0x3B, 0xB4, 0x65, 0x90, 0x76, + 0xFC, 0x4B, 0x69, 0x92, 0xD1, 0x9A, 0x87, 0xFD, + 0x28, 0x1C, 0x44, 0x2C, 0x81, 0x6D, 0x05, 0xE0, + 0x54, 0x03, 0xB5, 0xBB, 0xC2, 0x84, 0xC1, 0xEA + }, + { + 0x44, 0xA9, 0xBC, 0x62, 0x09, 0xD6, 0x17, 0x95, + 0x41, 0xCB, 0x15, 0xFB, 0x7C, 0xC2, 0x6D, 0x33, + 0x0E, 0xB9, 0xC7, 0x87, 0xBB, 0xCF, 0x1F, 0x70, + 0x87, 0xD2, 0xA2, 0x30, 0x46, 0x1C, 0xC4, 0x70 + }, + { + 0x44, 0x05, 0x73, 0xE8, 0xA0, 0x4C, 0x21, 0xC2, + 0x7A, 0x33, 0x56, 0x25, 0x60, 0x55, 0x7E, 0xB5, + 0xF3, 0xE1, 0xE0, 0x49, 0x85, 0xA9, 0xDC, 0xEF, + 0xD5, 0x3C, 0x3F, 0xD2, 0xFF, 0x35, 0x04, 0x2F + }, + { + 0x29, 0x99, 0x6D, 0x80, 0x95, 0x63, 0x5E, 0xBE, + 0x0A, 0xCD, 0xCB, 0xCB, 0x61, 0x36, 0x5F, 0xEA, + 0x05, 0x53, 0x12, 0x8A, 0x40, 0x3B, 0xB6, 0x5D, + 0x70, 0x15, 0x9B, 0x56, 0x89, 0x52, 0xAD, 0x39 + }, + { + 0x9D, 0x31, 0xC1, 0x8B, 0xA0, 0xE8, 0xC7, 0x9E, + 0x21, 0xD7, 0x60, 0xD2, 0x55, 0xC2, 0x9C, 0x1A, + 0xA4, 0xFF, 0x78, 0x09, 0x49, 0xF9, 0x36, 0x1E, + 0xA8, 0xC5, 0x51, 0x8E, 0xD9, 0x35, 0x49, 0xC3 + }, + { + 0x59, 0x39, 0x43, 0xCF, 0xB4, 0xEE, 0x1E, 0x82, + 0x68, 0x5C, 0xF3, 0xAF, 0x2C, 0xF0, 0x28, 0x61, + 0xF3, 0x8D, 0xE5, 0x8F, 0x74, 0xA1, 0xB9, 0xE0, + 0x83, 0xED, 0x23, 0x1D, 0x1D, 0xFB, 0xAD, 0xCE + }, + { + 0x1F, 0xB6, 0x69, 0x5E, 0x50, 0x7E, 0xF1, 0x12, + 0xDD, 0x57, 0xF1, 0x06, 0x34, 0x4C, 0xD5, 0xBF, + 0xFD, 0x4E, 0xA5, 0x1E, 0xEA, 0xE8, 0x25, 0x10, + 0x74, 0xFE, 0x69, 0x24, 0x0F, 0x4D, 0x4E, 0x21 + }, + { + 0x2F, 0x32, 0xF9, 0xC8, 0x38, 0x56, 0x89, 0x9B, + 0x7C, 0x53, 0xBA, 0x51, 0x5B, 0x21, 0x44, 0x87, + 0x2B, 0x66, 0x98, 0xFE, 0xF8, 0x36, 0xC8, 0xB5, + 0x1A, 0x20, 0xA4, 0x57, 0xE6, 0xD5, 0xC2, 0xBF + }, + { + 0x80, 0x44, 0x69, 0x64, 0x9C, 0x05, 0xCF, 0x11, + 0x47, 0x6A, 0x7C, 0xA8, 0x42, 0x04, 0x95, 0x5B, + 0xD1, 0xD8, 0x62, 0xC4, 0x78, 0x9C, 0x5F, 0xF7, + 0xE4, 0xC4, 0x6D, 0xDE, 0x11, 0x28, 0x1E, 0x6B + }, + { + 0xE6, 0x55, 0xD7, 0xF9, 0x02, 0x9A, 0x0D, 0xD4, + 0x5B, 0xE4, 0xE2, 0xA1, 0x7E, 0xD0, 0xA2, 0x00, + 0x47, 0x96, 0xA1, 0x61, 0x82, 0x7C, 0xBB, 0x7A, + 0x6E, 0x12, 0x0B, 0x3F, 0xB1, 0xEF, 0x5C, 0x7C + }, + { + 0x58, 0xD8, 0x31, 0xF0, 0x60, 0x8B, 0x80, 0x59, + 0xA1, 0x61, 0x8C, 0x01, 0xB3, 0x6A, 0x76, 0xCF, + 0x10, 0x22, 0xB4, 0x40, 0x37, 0x06, 0x3B, 0x3D, + 0x75, 0x22, 0xAA, 0x46, 0xE6, 0xEB, 0xBD, 0x26 + }, + { + 0x4B, 0x06, 0xD2, 0x92, 0x94, 0x3D, 0x1F, 0x03, + 0x7F, 0x37, 0x1D, 0x07, 0x1A, 0x6F, 0xA2, 0xA7, + 0xBD, 0xF0, 0xDB, 0x78, 0x06, 0x44, 0x20, 0xAA, + 0x56, 0xF2, 0x23, 0x55, 0x1E, 0x92, 0xC1, 0x8F + }, + { + 0xE2, 0xFC, 0x90, 0xE8, 0x31, 0x44, 0x84, 0xF8, + 0xA7, 0xCD, 0x89, 0x6C, 0x09, 0xBB, 0xEA, 0x2F, + 0x1E, 0x20, 0x8D, 0x1A, 0xFA, 0xAC, 0xD0, 0x48, + 0xAF, 0x27, 0x24, 0xCE, 0xEC, 0xC9, 0x5D, 0x44 + }, + { + 0x65, 0x5A, 0x35, 0xDD, 0x4C, 0x2E, 0x85, 0xA5, + 0x0C, 0xCA, 0x53, 0xE7, 0xCF, 0xBE, 0xCF, 0xEB, + 0xED, 0x15, 0x7E, 0x94, 0x13, 0x7F, 0xEC, 0x8F, + 0x0C, 0x00, 0x3B, 0x4B, 0x17, 0xA3, 0x7B, 0xD7 + }, + { + 0x0F, 0x42, 0x55, 0x3F, 0xC8, 0x48, 0xF1, 0x8C, + 0xF6, 0x41, 0x62, 0xE3, 0x52, 0x3C, 0x9D, 0x90, + 0x10, 0xB2, 0x8B, 0xB4, 0xBB, 0xCF, 0x86, 0x2A, + 0xA5, 0xE9, 0x40, 0x1E, 0x00, 0xF8, 0x60, 0x7E + }, + { + 0xD7, 0xAB, 0xFD, 0xE7, 0x61, 0x23, 0x1A, 0xDF, + 0x0C, 0x88, 0x2A, 0x00, 0x30, 0x10, 0xBC, 0x8F, + 0x3F, 0x0F, 0xE1, 0x5D, 0x41, 0x5B, 0xB4, 0x92, + 0xAD, 0xF2, 0x29, 0xDA, 0xE6, 0x55, 0xAA, 0x07 + }, + { + 0xD1, 0x7C, 0x13, 0x35, 0xD3, 0x8E, 0xA0, 0x86, + 0x43, 0x12, 0x44, 0x54, 0xAE, 0x6B, 0x04, 0x84, + 0x8B, 0x90, 0xD1, 0x7D, 0xB5, 0x52, 0xF1, 0xFF, + 0x80, 0x6E, 0x9C, 0xCA, 0x71, 0x8C, 0x2F, 0x58 + }, + { + 0xFB, 0xCF, 0x0D, 0xD8, 0x17, 0xDA, 0x28, 0xA5, + 0x2F, 0xC2, 0x25, 0x71, 0xDF, 0x5D, 0x78, 0x51, + 0x9A, 0xCB, 0x20, 0x12, 0xBE, 0x73, 0xFE, 0x88, + 0x66, 0x29, 0x8E, 0x07, 0xBD, 0x58, 0x33, 0xEF + }, + { + 0x8A, 0x46, 0x53, 0x07, 0x19, 0x8D, 0xC7, 0x3E, + 0x8F, 0xC5, 0x49, 0x7A, 0x81, 0x1F, 0x13, 0xF4, + 0x5D, 0xB9, 0xE6, 0xD4, 0xE1, 0x96, 0x0A, 0x39, + 0xCE, 0x0B, 0x44, 0x45, 0x0B, 0x17, 0x2E, 0xA6 + }, + { + 0xDC, 0x94, 0xDF, 0x5F, 0xF8, 0x39, 0x9F, 0x72, + 0xF5, 0x34, 0x8E, 0x3E, 0xD2, 0x93, 0x6D, 0x3C, + 0xDE, 0xB9, 0xCC, 0x67, 0x1B, 0x47, 0x57, 0x3C, + 0x41, 0xA8, 0x96, 0x95, 0x75, 0x06, 0x89, 0xB4 + }, + { + 0x2F, 0xF2, 0x25, 0x61, 0x37, 0x91, 0x58, 0x21, + 0xE6, 0x68, 0xFC, 0xC7, 0xB9, 0x74, 0x7F, 0x7B, + 0x66, 0xAC, 0x71, 0x42, 0x21, 0x7B, 0x82, 0x96, + 0x90, 0xBD, 0x59, 0xDE, 0x34, 0x6C, 0xD6, 0x69 + }, + { + 0x32, 0x69, 0x88, 0x3E, 0x93, 0x22, 0x71, 0x00, + 0x9D, 0xE4, 0x26, 0x0E, 0x7A, 0xC6, 0x48, 0xAD, + 0x32, 0xD5, 0x6F, 0xDD, 0xCC, 0xA5, 0x90, 0x1C, + 0xF0, 0x43, 0x5A, 0x4F, 0x17, 0x00, 0x74, 0xD2 + }, + { + 0x1D, 0xC8, 0x9D, 0x3C, 0xC0, 0x5A, 0xD0, 0x35, + 0x98, 0x3B, 0xAC, 0x1A, 0x53, 0x69, 0x39, 0xE3, + 0x61, 0xDB, 0xAF, 0x41, 0x57, 0x2D, 0x35, 0xDF, + 0x4D, 0xC4, 0xC0, 0x67, 0x95, 0xB2, 0x73, 0x38 + }, + { + 0xF9, 0x73, 0xA3, 0x4D, 0x2D, 0x5B, 0x8D, 0x28, + 0x85, 0x26, 0xD3, 0xA8, 0xCD, 0x99, 0x98, 0x0C, + 0x4C, 0xA4, 0xBB, 0x82, 0x97, 0xBA, 0xD8, 0xDA, + 0xDC, 0x4B, 0xD2, 0x41, 0xB8, 0x5E, 0xBC, 0x5A + }, + { + 0xCE, 0x35, 0x6B, 0xC7, 0xC7, 0x96, 0xC5, 0x9F, + 0x1D, 0xA8, 0xD5, 0xD1, 0xCD, 0x4A, 0x3C, 0xF1, + 0x44, 0xA3, 0x00, 0x0D, 0x5D, 0x0F, 0x1E, 0x29, + 0x20, 0x38, 0x52, 0x02, 0x54, 0x2C, 0xB6, 0xD5 + }, + { + 0x40, 0x8D, 0xF5, 0xC1, 0x6B, 0x04, 0x6C, 0x26, + 0x3B, 0x37, 0x01, 0x6C, 0xD9, 0x6F, 0x0D, 0xAF, + 0x82, 0x81, 0xD8, 0x46, 0x6E, 0x89, 0x84, 0x21, + 0x93, 0xBD, 0x1E, 0x6E, 0x8A, 0x5B, 0x53, 0xF6 + }, + { + 0xB4, 0x33, 0xBA, 0xEB, 0xAC, 0xBF, 0x62, 0x1F, + 0x43, 0x11, 0x93, 0xFF, 0xEE, 0x53, 0x00, 0x38, + 0x69, 0x52, 0xA2, 0x48, 0x13, 0x19, 0xC8, 0x95, + 0xE6, 0xDB, 0xF4, 0x14, 0x15, 0x5F, 0x1F, 0xC6 + }, + { + 0x82, 0xFB, 0x68, 0xCA, 0x6B, 0xFE, 0x05, 0x0C, + 0x0D, 0xDE, 0x01, 0x79, 0x1B, 0x00, 0x0A, 0x1B, + 0x25, 0x62, 0xFF, 0xC1, 0x0A, 0x60, 0x45, 0xF1, + 0xA0, 0x98, 0x77, 0xF4, 0x65, 0x5A, 0x2F, 0x95 + }, + { + 0x97, 0x85, 0x75, 0xFF, 0x17, 0x25, 0x17, 0xEC, + 0xCC, 0x4E, 0x1B, 0xAC, 0xE5, 0xB5, 0x0D, 0xF1, + 0x9F, 0xD4, 0x92, 0x80, 0xAC, 0x0A, 0x84, 0x4B, + 0xBC, 0x5B, 0x17, 0xF3, 0x48, 0x68, 0x3A, 0xE9 + }, + { + 0xC0, 0xF1, 0xC8, 0x61, 0x61, 0x0D, 0xE1, 0xC9, + 0xAC, 0xFC, 0x13, 0x3B, 0x90, 0x97, 0x4C, 0x57, + 0x1C, 0x39, 0x04, 0xCE, 0x73, 0xC5, 0x55, 0xB4, + 0xE6, 0xC8, 0xBD, 0xAC, 0x50, 0x98, 0x5F, 0x9C + }, + { + 0x7D, 0xCF, 0xE6, 0x3B, 0xE8, 0x38, 0xAE, 0x65, + 0x86, 0x80, 0xFA, 0xF7, 0x74, 0xC2, 0x4B, 0xFE, + 0xAE, 0x57, 0x03, 0xAE, 0xF8, 0x60, 0xCC, 0x77, + 0xAF, 0x3E, 0x9D, 0x48, 0x08, 0x99, 0x35, 0xC4 + }, + { + 0x40, 0x6A, 0x0D, 0x91, 0xB5, 0x7B, 0xEB, 0x22, + 0x8E, 0x59, 0x34, 0x10, 0xF5, 0xBB, 0x8B, 0x09, + 0xAB, 0x3C, 0x8B, 0x7A, 0x94, 0xB6, 0x78, 0xF0, + 0xEE, 0x30, 0x72, 0x1F, 0xCA, 0x7C, 0x2D, 0x30 + }, + { + 0x41, 0xD4, 0xF7, 0xAB, 0x7B, 0xAD, 0x03, 0xAB, + 0xB3, 0x34, 0xDE, 0x52, 0x84, 0xD6, 0x40, 0xE6, + 0x76, 0xFD, 0x99, 0x3B, 0xC2, 0x8A, 0x0E, 0x4E, + 0x1E, 0x8D, 0x3D, 0xA5, 0x4C, 0x3D, 0x2B, 0x5B + }, + { + 0x3B, 0x49, 0x26, 0x30, 0x25, 0xA3, 0x9E, 0x3A, + 0xAC, 0x9D, 0x78, 0x79, 0x9E, 0xCB, 0x96, 0x18, + 0xA6, 0x8D, 0x1D, 0xF9, 0xBF, 0x40, 0x5B, 0xD4, + 0xDC, 0xC7, 0x0C, 0xD2, 0x4C, 0x75, 0xD9, 0x0B + }, + { + 0x79, 0xFC, 0x76, 0xBC, 0xD1, 0x7A, 0x7A, 0x11, + 0x8E, 0x11, 0x50, 0x2D, 0xB3, 0x2D, 0x6A, 0xB6, + 0x5A, 0xFA, 0x0E, 0x36, 0xCA, 0xDB, 0x17, 0x21, + 0x8D, 0x08, 0x64, 0xFB, 0xA3, 0xF6, 0x2C, 0x89 + }, + { + 0x04, 0x5B, 0xD9, 0x2A, 0xF7, 0x3D, 0xD5, 0xCC, + 0x41, 0x99, 0x07, 0xCA, 0x7A, 0x28, 0x9C, 0xF0, + 0xCC, 0x87, 0x35, 0x11, 0x31, 0xE5, 0x06, 0xD0, + 0x2B, 0x27, 0xE7, 0x55, 0xF1, 0x20, 0x9F, 0x2D + }, + { + 0xBD, 0x9E, 0xFD, 0xB4, 0xA4, 0xED, 0xD1, 0x34, + 0x54, 0x2C, 0x1E, 0x8E, 0x0E, 0x78, 0xD4, 0xE2, + 0xA7, 0xCE, 0x97, 0x29, 0x71, 0xC6, 0xD7, 0x74, + 0x29, 0xA2, 0xE5, 0x6B, 0x8F, 0x58, 0xAC, 0xA3 + }, + { + 0xEF, 0x24, 0x2C, 0x95, 0xFB, 0xD2, 0xB4, 0x2A, + 0x15, 0x70, 0xAF, 0x5E, 0x7C, 0x87, 0xF2, 0xDD, + 0xE9, 0xFB, 0x17, 0x72, 0xEB, 0x0A, 0xC3, 0xDE, + 0xC6, 0x3A, 0xD0, 0x70, 0x9D, 0x35, 0xE9, 0x71 + }, + { + 0xC5, 0x9E, 0x30, 0x7D, 0xC8, 0x3C, 0xD1, 0x7C, + 0x64, 0xA4, 0x5C, 0x41, 0x8F, 0xF7, 0x3F, 0x66, + 0xB7, 0x4A, 0xF3, 0x41, 0x79, 0x25, 0xCA, 0x18, + 0x23, 0x0B, 0x25, 0x87, 0x32, 0xF6, 0x62, 0xBF + }, + { + 0x87, 0xBD, 0x06, 0x26, 0x1F, 0x15, 0xD2, 0x2A, + 0x66, 0x69, 0xD7, 0xC9, 0xDE, 0x81, 0x04, 0x0E, + 0x9C, 0xF7, 0x2F, 0xDA, 0x3B, 0x0E, 0x55, 0x83, + 0xE1, 0x55, 0xA4, 0x2F, 0x34, 0x49, 0xF3, 0x4C + }, + { + 0x44, 0x10, 0x4E, 0xDB, 0xD6, 0xB3, 0x49, 0x66, + 0x1C, 0x0D, 0xE5, 0x7B, 0x5E, 0x82, 0x16, 0x3C, + 0x57, 0x54, 0x7C, 0x79, 0xD2, 0xF1, 0xC4, 0x56, + 0x0F, 0x96, 0x8C, 0xB8, 0x1E, 0x7B, 0x69, 0xB0 + }, + { + 0xE2, 0x47, 0x0F, 0xFE, 0x9F, 0x7E, 0xD5, 0x09, + 0x26, 0xE0, 0x7F, 0x57, 0x8B, 0x8B, 0xA5, 0x47, + 0xF3, 0xEC, 0x0F, 0xF7, 0x67, 0x54, 0x86, 0x67, + 0xB3, 0x58, 0x70, 0x45, 0xC3, 0xE0, 0xA5, 0x99 + }, + { + 0x2D, 0xAD, 0x1C, 0xB3, 0xB2, 0x2E, 0x83, 0x85, + 0xA1, 0x9B, 0x97, 0xB0, 0x5C, 0x34, 0x31, 0x4C, + 0x60, 0x07, 0x29, 0xDC, 0x5D, 0x3A, 0x14, 0xB7, + 0x18, 0x0B, 0x3D, 0x88, 0xD3, 0xFE, 0xBD, 0x85 + }, + { + 0xE0, 0x14, 0xEA, 0xA6, 0xE3, 0xFD, 0x8D, 0x1F, + 0xB3, 0xB9, 0xC2, 0xFD, 0xF1, 0x3E, 0x7E, 0x31, + 0xB4, 0x3B, 0xA6, 0x1A, 0xC2, 0x9F, 0x24, 0xCC, + 0x1E, 0x92, 0x05, 0x36, 0x05, 0xB6, 0xD0, 0xB2 + }, + { + 0x81, 0x44, 0xB8, 0xF4, 0x8D, 0xAD, 0xD3, 0x0A, + 0x0B, 0x74, 0x7D, 0xDC, 0x89, 0x19, 0xFC, 0x5C, + 0xF3, 0x19, 0x19, 0xB2, 0xC4, 0x0A, 0x8F, 0x07, + 0xA2, 0xCE, 0xFE, 0x54, 0xC6, 0x1E, 0x0F, 0xCE + }, + { + 0xCF, 0x5E, 0x05, 0xAA, 0xEA, 0x2B, 0xB6, 0x3F, + 0xFD, 0x24, 0x6F, 0x70, 0x1F, 0x3D, 0x83, 0x42, + 0x54, 0x0E, 0x03, 0x68, 0xDC, 0x82, 0x20, 0xA5, + 0x00, 0xDE, 0xB2, 0xFD, 0x30, 0xBF, 0x81, 0xD3 + }, + { + 0x40, 0x89, 0xAC, 0x2B, 0x28, 0x1D, 0x91, 0xC3, + 0x5E, 0xF1, 0xE4, 0x15, 0x54, 0xA4, 0xEA, 0x42, + 0xF0, 0x32, 0x1C, 0x81, 0x96, 0xAD, 0x4F, 0x26, + 0xAF, 0x99, 0x04, 0x60, 0x9F, 0x3C, 0x66, 0x88 + }, + { + 0x7A, 0xB7, 0xB9, 0x04, 0x2C, 0x67, 0x14, 0x91, + 0x6A, 0x2A, 0x95, 0x83, 0x38, 0x72, 0x2D, 0xC8, + 0x53, 0xDE, 0xB9, 0xA3, 0xFD, 0x5D, 0x05, 0x3F, + 0x24, 0xE4, 0x34, 0x43, 0x75, 0x34, 0x2C, 0x11 + }, + { + 0x59, 0x14, 0xB2, 0xF5, 0xAC, 0x93, 0xAD, 0xAB, + 0x35, 0xCE, 0xFD, 0x81, 0x7C, 0xDB, 0x5D, 0x22, + 0x00, 0xDE, 0xE6, 0x5C, 0x54, 0x20, 0xDD, 0x11, + 0x69, 0x06, 0x6E, 0x00, 0x80, 0x1A, 0xDF, 0x1B + }, + { + 0x4F, 0xF1, 0xF1, 0xD7, 0x25, 0x18, 0xF5, 0x05, + 0xF4, 0x51, 0x27, 0x05, 0x7D, 0xB2, 0xE6, 0xD3, + 0xD8, 0x19, 0xF6, 0xB0, 0x98, 0xA5, 0xC2, 0xEC, + 0x75, 0xBF, 0xD1, 0x75, 0x35, 0xB5, 0xDA, 0x1D + }, + { + 0xDE, 0x90, 0x76, 0x4E, 0xAB, 0x67, 0xDE, 0x75, + 0x0F, 0x40, 0x59, 0x11, 0x65, 0x7C, 0xB0, 0xE2, + 0x83, 0x33, 0xCA, 0xEF, 0x89, 0x93, 0x2D, 0x2A, + 0x2F, 0xA5, 0x0F, 0xDE, 0xF6, 0xAB, 0xAE, 0x0E + }, + { + 0x46, 0x67, 0x21, 0x11, 0x02, 0xCD, 0x98, 0xD0, + 0x4B, 0x40, 0x42, 0x0D, 0xDB, 0x10, 0xAC, 0xA9, + 0xE4, 0xCB, 0x1E, 0xCF, 0x18, 0x72, 0xA5, 0x68, + 0xFC, 0x02, 0x25, 0xE5, 0x5B, 0xE4, 0xEF, 0xF2 + }, + { + 0x29, 0x41, 0x4D, 0x48, 0x8F, 0x69, 0xEC, 0xD3, + 0x63, 0xF0, 0x8C, 0x8E, 0x9A, 0x37, 0xB1, 0x0A, + 0xA4, 0x16, 0x94, 0x6B, 0x34, 0xC0, 0xE4, 0x8E, + 0x51, 0x05, 0x9C, 0x89, 0xB6, 0xB0, 0x1B, 0xCF + }, + { + 0xF5, 0x62, 0x99, 0x5E, 0x98, 0x08, 0x0A, 0x0E, + 0xEB, 0xAF, 0x21, 0x8B, 0x78, 0xD8, 0x71, 0x6B, + 0x2A, 0xD1, 0x3C, 0x10, 0x81, 0xD4, 0x8E, 0x2D, + 0x7F, 0x9E, 0xCA, 0x9B, 0xB7, 0x81, 0x6E, 0x8D + }, + { + 0x79, 0x9A, 0x46, 0xE6, 0x14, 0x96, 0x26, 0x9A, + 0x65, 0x6C, 0x38, 0xBB, 0xCD, 0x50, 0x7D, 0x8E, + 0xD6, 0x0C, 0x94, 0x0D, 0xBE, 0x54, 0x92, 0xFA, + 0xB5, 0x23, 0x87, 0x02, 0x98, 0x2C, 0xFA, 0xD9 + }, + { + 0xBF, 0xFE, 0x9F, 0x72, 0xAD, 0xE4, 0x45, 0xD3, + 0x08, 0x66, 0x95, 0x45, 0xDD, 0x1B, 0xB3, 0x03, + 0x18, 0xCF, 0xCD, 0xCC, 0xC8, 0xD7, 0xBC, 0xBB, + 0x74, 0x81, 0x26, 0xC8, 0xC2, 0xB2, 0xC1, 0x65 + }, + { + 0x4E, 0xEF, 0x79, 0x77, 0xCB, 0x30, 0x9F, 0x83, + 0x65, 0x2F, 0x3F, 0x5D, 0xA0, 0xCF, 0x59, 0x32, + 0xBE, 0x9F, 0xCC, 0x8E, 0xEC, 0x7F, 0xFB, 0x80, + 0x34, 0x8F, 0x00, 0xF7, 0x7D, 0xD1, 0xF0, 0x12 + }, + { + 0x89, 0xF1, 0xE3, 0x2E, 0x30, 0xF1, 0x7F, 0xAC, + 0xB4, 0xB5, 0xB0, 0x26, 0xAC, 0xA2, 0x71, 0x25, + 0xDD, 0x0A, 0xCB, 0xA3, 0xB6, 0xD9, 0xED, 0x49, + 0xDA, 0xEB, 0xED, 0x82, 0x30, 0x0D, 0x89, 0x8F + }, + { + 0x3C, 0x15, 0x11, 0x02, 0x74, 0x09, 0x1E, 0x32, + 0x23, 0x0B, 0x26, 0x3E, 0x03, 0x89, 0x1E, 0x3A, + 0x40, 0x10, 0x11, 0x22, 0x95, 0x3E, 0xAD, 0x7E, + 0xC4, 0x89, 0xBF, 0x1C, 0xD3, 0x2B, 0x32, 0xFE + }, + { + 0x23, 0x92, 0xC0, 0x08, 0xC1, 0xFB, 0x85, 0x8E, + 0x62, 0x11, 0x16, 0x89, 0x6E, 0x87, 0xB6, 0xF7, + 0x8A, 0xB9, 0xCE, 0x08, 0x9C, 0x43, 0x34, 0x9B, + 0x67, 0x4D, 0x62, 0x69, 0x2C, 0x1E, 0xBE, 0x19 + }, + { + 0x10, 0x49, 0x59, 0xDB, 0x9D, 0x89, 0xF4, 0x5D, + 0xC9, 0xA5, 0xC9, 0xDB, 0x86, 0xE0, 0xB2, 0xFE, + 0x60, 0xA8, 0xA7, 0x33, 0xC6, 0x98, 0xF2, 0x2B, + 0xB8, 0xD1, 0xED, 0x22, 0xE0, 0x67, 0x3E, 0x0B + }, + { + 0x3E, 0xB4, 0x92, 0x5F, 0x06, 0x2A, 0x5C, 0xFE, + 0x59, 0xC1, 0xAE, 0xDE, 0x34, 0xC9, 0x59, 0x71, + 0x20, 0x70, 0xD2, 0x00, 0x96, 0xAA, 0x15, 0x94, + 0x8D, 0xC3, 0xF1, 0xA8, 0xFD, 0x24, 0x62, 0x87 + }, + { + 0x0C, 0x50, 0x50, 0x93, 0xA5, 0x91, 0xC4, 0x50, + 0x48, 0x7D, 0x8E, 0xBE, 0xDA, 0x42, 0x9A, 0xEB, + 0x3F, 0x1F, 0x83, 0x62, 0x54, 0xD6, 0x9D, 0x9A, + 0x6E, 0xB7, 0x6C, 0xAB, 0x91, 0x9F, 0xC5, 0x26 + }, + { + 0x7B, 0xB6, 0xF6, 0xB1, 0x80, 0x6F, 0x78, 0x23, + 0x01, 0xEB, 0xFC, 0x20, 0x5E, 0x5A, 0x15, 0xE3, + 0xBE, 0x93, 0xE5, 0x06, 0x4E, 0x8E, 0xE6, 0x25, + 0x20, 0x8D, 0x53, 0x96, 0x36, 0x96, 0xA9, 0xCB + }, + { + 0x80, 0xED, 0x57, 0xB5, 0x49, 0x69, 0x2A, 0x22, + 0x14, 0xC1, 0xD4, 0xAF, 0x3E, 0x31, 0x5F, 0xA2, + 0xD8, 0x0E, 0x00, 0xDD, 0xB0, 0x3D, 0x57, 0x52, + 0xF3, 0x89, 0xFD, 0xAA, 0x15, 0x17, 0x36, 0x6C + }, + { + 0x8D, 0x32, 0xA9, 0x0D, 0xDF, 0x57, 0xFB, 0x3D, + 0x12, 0x26, 0xA2, 0x6B, 0xDA, 0x54, 0x76, 0xD1, + 0x26, 0x6F, 0xA6, 0x40, 0x73, 0x6A, 0x4B, 0xDC, + 0x2A, 0xCA, 0xAF, 0x5C, 0xBC, 0x69, 0x95, 0xA3 + }, + { + 0x92, 0xD3, 0x34, 0x0A, 0x5A, 0x88, 0x11, 0x59, + 0x88, 0x50, 0xAA, 0xC6, 0x12, 0x2C, 0xBE, 0xD0, + 0xA6, 0xF9, 0x78, 0x7F, 0xFC, 0xBF, 0x78, 0xC2, + 0x63, 0xC6, 0x9C, 0xF2, 0xAD, 0x8D, 0x9A, 0x0D + }, + { + 0x18, 0x8A, 0xA9, 0x07, 0x87, 0x4A, 0xE5, 0x76, + 0x40, 0x31, 0x31, 0xC7, 0xE7, 0x0B, 0xCF, 0x75, + 0x01, 0x04, 0x15, 0x1A, 0x8C, 0x32, 0x01, 0xD6, + 0xED, 0xBB, 0x15, 0xE5, 0x19, 0x6D, 0x74, 0x81 + }, + { + 0x5C, 0x27, 0x86, 0x0F, 0xBE, 0xA5, 0x91, 0x10, + 0xEC, 0xDF, 0x29, 0x48, 0x38, 0xE8, 0xC6, 0xA5, + 0xF6, 0x1B, 0xC4, 0x24, 0x98, 0x4D, 0x77, 0x3E, + 0x2D, 0x46, 0xAF, 0xA2, 0xCA, 0x7A, 0x28, 0x31 + }, + { + 0x50, 0xA4, 0xAF, 0x48, 0xBA, 0x67, 0x70, 0x5B, + 0x1B, 0xAB, 0x8B, 0xD8, 0xE5, 0x66, 0xA2, 0xFB, + 0x69, 0xE9, 0xCE, 0xE2, 0x80, 0x94, 0x3F, 0x2E, + 0xD4, 0x25, 0x31, 0xF1, 0x48, 0x20, 0x44, 0x62 + }, + { + 0x7A, 0x44, 0x3D, 0x42, 0xFF, 0x20, 0x91, 0xC0, + 0xA4, 0x49, 0x67, 0xA6, 0x23, 0x8C, 0x09, 0x27, + 0x97, 0xBF, 0xDF, 0x38, 0xB4, 0x42, 0xBA, 0x27, + 0x12, 0x4D, 0x36, 0x7D, 0x44, 0xB9, 0x2B, 0xD4 + }, + { + 0x2D, 0x22, 0xF6, 0x7D, 0xCB, 0xB4, 0x4B, 0x8E, + 0x0E, 0xE1, 0xF5, 0x3A, 0x36, 0xFD, 0xE8, 0x03, + 0xB9, 0x0A, 0x35, 0xB9, 0x4F, 0xF9, 0x06, 0x88, + 0xAB, 0x4F, 0xDC, 0x62, 0xA4, 0xEF, 0xE9, 0xA6 + }, + { + 0x73, 0xEA, 0x85, 0xCB, 0xD1, 0x1A, 0x27, 0x2A, + 0xE7, 0xBF, 0xAD, 0x49, 0x55, 0x18, 0x45, 0x12, + 0x6F, 0xF3, 0x8B, 0x79, 0x2B, 0xDF, 0x19, 0xC3, + 0x1F, 0x63, 0x75, 0x05, 0x40, 0xFB, 0x79, 0x46 + }, + { + 0xAD, 0x6B, 0x8A, 0xED, 0x7A, 0x45, 0x8C, 0x62, + 0x40, 0x39, 0xF8, 0xC5, 0x7C, 0xF6, 0xE4, 0xF3, + 0x77, 0xD2, 0xF1, 0x5B, 0xA7, 0xDA, 0x29, 0x40, + 0xA5, 0x2A, 0xA2, 0x23, 0xE3, 0xEF, 0xE8, 0xBE + }, + { + 0x56, 0xE2, 0x2D, 0x04, 0xEE, 0xD8, 0xF6, 0x4B, + 0x2F, 0xA6, 0xCB, 0xF9, 0x09, 0x8D, 0x02, 0x24, + 0x16, 0xB0, 0xE8, 0x6E, 0x34, 0x87, 0xFD, 0x12, + 0xF2, 0xDA, 0x5E, 0xEB, 0xA9, 0x14, 0x53, 0x56 + }, + { + 0xB4, 0xA5, 0x3F, 0xBE, 0x22, 0x8F, 0x48, 0xBC, + 0x33, 0xDC, 0x70, 0x2E, 0xAE, 0xB3, 0x0E, 0x13, + 0xF2, 0x83, 0x7E, 0xE8, 0xB7, 0xC0, 0x36, 0xB9, + 0x8D, 0x3C, 0xB1, 0x2B, 0x34, 0xAB, 0x33, 0x7F + }, + { + 0xA3, 0x91, 0x3A, 0x9F, 0x0C, 0xFF, 0x69, 0x0F, + 0xE3, 0xD1, 0x11, 0x8D, 0x44, 0x43, 0xF5, 0x6D, + 0x15, 0xAC, 0x4F, 0xE2, 0x7A, 0x0B, 0x21, 0xC7, + 0xC7, 0xFA, 0xC9, 0xDA, 0x00, 0x8D, 0xC1, 0x02 + }, + { + 0x42, 0xD8, 0x01, 0xFD, 0x10, 0xB8, 0x34, 0xB1, + 0x9F, 0x9A, 0x08, 0x48, 0x74, 0xBC, 0x6B, 0xCF, + 0x33, 0x4E, 0xE4, 0x6B, 0xDE, 0xC1, 0xEF, 0xDF, + 0x4E, 0x02, 0x61, 0x3F, 0x6F, 0x5E, 0xBE, 0x95 + }, + { + 0xAC, 0xF6, 0x6C, 0x0D, 0xB7, 0xDE, 0x29, 0xA2, + 0x83, 0xB7, 0x7B, 0x64, 0xA5, 0xB2, 0x78, 0xD4, + 0x4F, 0x1F, 0xCA, 0xD8, 0x1E, 0x06, 0xC3, 0xF7, + 0x24, 0x7E, 0x91, 0x7B, 0xB9, 0x41, 0xB2, 0xC9 + }, + { + 0xE5, 0xF5, 0x55, 0xE0, 0x69, 0x01, 0x6D, 0x5C, + 0x5D, 0xD6, 0xBF, 0x34, 0x80, 0x73, 0xD0, 0xB0, + 0x0B, 0x09, 0x69, 0x9E, 0xCA, 0x21, 0x35, 0xBF, + 0xF4, 0x09, 0x11, 0x4E, 0x79, 0x31, 0xE8, 0xFF + }, + { + 0x85, 0x35, 0x6A, 0xD9, 0xB6, 0x11, 0x2B, 0x4A, + 0x58, 0xB4, 0xD3, 0x62, 0x7C, 0x5A, 0x56, 0x8F, + 0x2E, 0x45, 0x5E, 0x6F, 0x32, 0x06, 0x97, 0x26, + 0x0E, 0xEB, 0xE3, 0x8F, 0xCA, 0x17, 0xB6, 0xD2 + }, + { + 0x02, 0xB4, 0xD6, 0x78, 0x03, 0x33, 0x93, 0x58, + 0x1C, 0x38, 0xC8, 0xDB, 0x39, 0xAE, 0xE6, 0x7A, + 0x67, 0x3D, 0x1B, 0x35, 0x4B, 0x70, 0xF8, 0x9F, + 0x8A, 0x86, 0xEB, 0xFA, 0x2D, 0x32, 0x0F, 0x3F + }, + { + 0xDD, 0xFB, 0xD7, 0x8B, 0xF3, 0x16, 0xC1, 0x6D, + 0x3E, 0x08, 0xA7, 0x29, 0xB0, 0xEF, 0x31, 0x5E, + 0x49, 0xB0, 0xEA, 0x13, 0xAF, 0xC0, 0xE4, 0x6A, + 0x29, 0x39, 0x9D, 0xEF, 0x82, 0xEB, 0x74, 0x86 + }, + { + 0xC9, 0x03, 0x74, 0x7F, 0x4E, 0x03, 0xC6, 0x26, + 0x47, 0xFB, 0xAC, 0x4B, 0x71, 0x40, 0x67, 0x32, + 0x3D, 0x8C, 0xF2, 0x75, 0x35, 0x1C, 0xF4, 0x33, + 0x6A, 0x81, 0x66, 0x4B, 0xDE, 0x20, 0xD7, 0x28 + }, + { + 0x77, 0x0D, 0x62, 0x00, 0xE9, 0x62, 0x61, 0x03, + 0xD1, 0xA1, 0x36, 0x2D, 0x99, 0x5F, 0xD2, 0x53, + 0x12, 0xE8, 0x4F, 0x5E, 0x23, 0x55, 0x75, 0xB3, + 0x83, 0x89, 0xDB, 0x74, 0xF4, 0x55, 0x80, 0x51 + }, + { + 0xF7, 0x05, 0xD9, 0x54, 0xBF, 0xD5, 0x7C, 0x00, + 0xA5, 0x19, 0xDB, 0x2B, 0x3A, 0xED, 0xE1, 0xF6, + 0xB5, 0xDF, 0xE8, 0x71, 0x67, 0x42, 0x92, 0x9C, + 0x19, 0x35, 0x7A, 0x85, 0x83, 0xB6, 0xCF, 0xFE + }, + { + 0x13, 0x13, 0x27, 0x0B, 0x8D, 0x0A, 0xE1, 0xC8, + 0x24, 0x73, 0xF9, 0x3A, 0x55, 0x96, 0x47, 0xC9, + 0x62, 0xD8, 0x52, 0x7C, 0x75, 0x0B, 0x27, 0xBB, + 0x49, 0x54, 0x62, 0xB1, 0xAF, 0xDE, 0x15, 0x9F + }, + { + 0x87, 0x4F, 0xD8, 0xF3, 0xC1, 0xB9, 0x90, 0xA7, + 0x8B, 0x2E, 0xF2, 0xFA, 0xCA, 0xDF, 0x52, 0x81, + 0x31, 0xF1, 0xA9, 0xB7, 0x3F, 0x93, 0x59, 0xFE, + 0xA2, 0xE1, 0x76, 0x69, 0xC8, 0xE6, 0x61, 0x07 + }, + { + 0x1F, 0x5C, 0xFB, 0x99, 0xFD, 0xA9, 0x3C, 0xB4, + 0x24, 0x76, 0xCC, 0x0A, 0xB5, 0xF9, 0xA8, 0x04, + 0x21, 0x10, 0x38, 0x76, 0x81, 0xFA, 0xFA, 0xD2, + 0x27, 0x55, 0x05, 0xD5, 0xCA, 0xF7, 0x99, 0xD4 + }, + { + 0x7F, 0x9D, 0xE6, 0x6A, 0x4A, 0x98, 0x85, 0x72, + 0xBB, 0x0D, 0x53, 0xDB, 0x94, 0x60, 0x16, 0xCF, + 0x48, 0x8D, 0xB3, 0x25, 0x71, 0xB0, 0x59, 0x17, + 0x47, 0x8D, 0x44, 0xC8, 0x14, 0x4C, 0xEE, 0x21 + }, + { + 0x96, 0x2B, 0x12, 0x44, 0xB2, 0x00, 0xED, 0x03, + 0xA0, 0xCE, 0x30, 0x2E, 0x81, 0x59, 0x6F, 0x16, + 0x5B, 0xF4, 0x25, 0xC2, 0x83, 0x6C, 0x9A, 0xB3, + 0x63, 0xA0, 0xF4, 0x2B, 0xC5, 0x93, 0xF8, 0x38 + }, + { + 0xD4, 0xF6, 0xD7, 0xBB, 0x8C, 0x09, 0x31, 0x8A, + 0x34, 0x56, 0x32, 0x9D, 0xD5, 0x2E, 0x9E, 0xC6, + 0x3F, 0xCE, 0x93, 0xD4, 0xE3, 0x2D, 0xEC, 0xA2, + 0xBB, 0xB7, 0xCB, 0xBF, 0x24, 0x71, 0xA2, 0xE8 + }, + { + 0x6C, 0x87, 0xE6, 0xEB, 0xC5, 0x7B, 0x8F, 0xAD, + 0x7A, 0x79, 0x9A, 0xAD, 0xFF, 0x23, 0x89, 0xC0, + 0x10, 0xD5, 0x88, 0x98, 0x78, 0x66, 0xDA, 0x1F, + 0xC4, 0x31, 0xB0, 0x4A, 0xB9, 0xDB, 0xC4, 0xF9 + }, + { + 0x8E, 0xD5, 0xBD, 0xB7, 0x13, 0xE1, 0xB1, 0x81, + 0xC7, 0xC4, 0xCD, 0x4D, 0xDE, 0x4A, 0xC0, 0xB2, + 0x2A, 0x53, 0x7D, 0xBE, 0x19, 0x3F, 0x46, 0x47, + 0xB6, 0xF7, 0x86, 0x48, 0xF0, 0x76, 0x5D, 0x30 + }, + { + 0xC1, 0xE5, 0x46, 0xDF, 0x67, 0xF8, 0xF4, 0xFA, + 0xF2, 0xAB, 0x1F, 0x69, 0x19, 0x26, 0x72, 0x52, + 0x5D, 0x71, 0x83, 0x3E, 0x80, 0x41, 0x17, 0xA3, + 0xAD, 0x8B, 0x4F, 0xEE, 0x0C, 0xB0, 0x7B, 0x17 + }, + { + 0xE6, 0xB3, 0x2D, 0xC7, 0xFD, 0x2F, 0xD5, 0x5C, + 0x4B, 0x69, 0x83, 0x87, 0x56, 0xAF, 0xBB, 0x20, + 0x33, 0xA8, 0x8C, 0x42, 0x9A, 0x01, 0x93, 0x80, + 0xE2, 0x45, 0x60, 0x2D, 0xEA, 0x6E, 0x3B, 0x82 + }, + { + 0xF0, 0xEB, 0xA3, 0x36, 0x01, 0x05, 0xE6, 0x80, + 0xDC, 0xC7, 0xA0, 0x76, 0xD7, 0x6D, 0x2F, 0x73, + 0x1F, 0x96, 0x22, 0x42, 0x10, 0x1D, 0xCC, 0x95, + 0x76, 0x02, 0x4D, 0xA4, 0x00, 0x39, 0x92, 0x83 + }, + { + 0x1A, 0x75, 0x2F, 0x3D, 0xA4, 0x4A, 0x0D, 0x75, + 0xC0, 0x5F, 0xBC, 0x25, 0x29, 0xAD, 0xA3, 0x1F, + 0x22, 0x66, 0x76, 0xB3, 0x6F, 0xA3, 0x56, 0x2D, + 0xD5, 0xF1, 0x29, 0x29, 0x94, 0x70, 0xA2, 0xFC + }, + { + 0x8E, 0x1D, 0x3B, 0xED, 0x4D, 0x80, 0x7B, 0x97, + 0x40, 0x9B, 0x95, 0x88, 0x46, 0xEB, 0xE1, 0xB4, + 0x19, 0x5E, 0xA4, 0x64, 0x7F, 0x97, 0xFC, 0x52, + 0x26, 0xF6, 0x35, 0x1F, 0xCF, 0x8A, 0x33, 0x68 + }, + { + 0x29, 0xC0, 0x13, 0x2D, 0x8B, 0x8F, 0x4C, 0x8B, + 0xAF, 0x54, 0x0A, 0x29, 0xF1, 0xFF, 0xC0, 0x71, + 0x45, 0xCB, 0xD7, 0x95, 0x45, 0x54, 0xCA, 0x87, + 0x27, 0x64, 0x56, 0x9D, 0x75, 0xC8, 0x1C, 0x84 + }, + { + 0x49, 0xA8, 0x8F, 0x51, 0xE2, 0xEC, 0x32, 0xEF, + 0x73, 0x87, 0x36, 0x7A, 0x5A, 0xA2, 0x60, 0xED, + 0x90, 0x25, 0x8A, 0x1A, 0x79, 0xAC, 0xF2, 0x72, + 0x2C, 0x63, 0x09, 0x3B, 0xFD, 0x0A, 0xC1, 0x1D + }, + { + 0x6B, 0x23, 0xC0, 0x3E, 0xD6, 0x61, 0x24, 0x7B, + 0x42, 0x92, 0x27, 0xFA, 0x44, 0x5E, 0x97, 0x22, + 0x4B, 0x3E, 0x41, 0x72, 0x37, 0xD4, 0x00, 0x6D, + 0x3E, 0xB8, 0x41, 0xAE, 0xA1, 0x52, 0xDC, 0x52 + }, + { + 0xDD, 0x5B, 0xE4, 0x91, 0x01, 0xF0, 0x45, 0x43, + 0xB0, 0xF6, 0x5E, 0xB4, 0x42, 0x4C, 0x6B, 0x66, + 0x76, 0x8F, 0x87, 0xD0, 0xEF, 0x8B, 0xBA, 0x54, + 0xE1, 0x33, 0xB0, 0xAD, 0x05, 0xD6, 0xD4, 0x4B + }, + { + 0x4A, 0xB0, 0x80, 0x71, 0xA5, 0x90, 0xFA, 0xA3, + 0x1C, 0x7D, 0x4F, 0xD7, 0xD9, 0x46, 0xA3, 0xE1, + 0x23, 0x6D, 0x48, 0x8C, 0x3F, 0xEA, 0x23, 0xCA, + 0x84, 0xA1, 0x24, 0x8C, 0xB2, 0xE8, 0xB7, 0x9F + }, + { + 0x7B, 0x35, 0x09, 0x38, 0x01, 0x79, 0x10, 0x2B, + 0x46, 0x0A, 0x7F, 0x54, 0x15, 0x47, 0x6E, 0x26, + 0x01, 0x17, 0x40, 0x55, 0xDA, 0xA2, 0x71, 0xA7, + 0x93, 0xA7, 0x81, 0x09, 0x42, 0x13, 0xF7, 0x21 + }, + { + 0xD3, 0x2D, 0x39, 0x07, 0x4D, 0x80, 0x78, 0xB3, + 0x63, 0x77, 0x6C, 0x09, 0x05, 0x4F, 0x6B, 0x84, + 0xDC, 0x03, 0xCD, 0x94, 0xD5, 0xD1, 0x68, 0xAD, + 0xC6, 0x23, 0x1E, 0x2F, 0xC1, 0x6E, 0x3C, 0xF7 + }, + { + 0xCA, 0x1F, 0x71, 0x71, 0x01, 0xE3, 0x55, 0x59, + 0x58, 0xC4, 0x62, 0xAD, 0x7C, 0x22, 0x99, 0x00, + 0x34, 0x39, 0xFD, 0x3E, 0x0E, 0xEA, 0x7F, 0x2C, + 0x02, 0x77, 0x9F, 0x29, 0xAB, 0xF1, 0x06, 0x1B + }, + { + 0x7E, 0x60, 0xEF, 0xE8, 0xE2, 0x5A, 0x91, 0x85, + 0x65, 0xDF, 0x2E, 0xFF, 0x0A, 0x4A, 0x0D, 0x0D, + 0xEA, 0xC3, 0xDF, 0x4A, 0x85, 0x0B, 0x22, 0x04, + 0x8D, 0x74, 0xF1, 0xB7, 0x59, 0x3C, 0xA2, 0xDD + }, + { + 0x9B, 0x42, 0x98, 0x81, 0xD8, 0x81, 0xEA, 0x98, + 0x6F, 0x30, 0x5E, 0x19, 0x44, 0x53, 0x3E, 0xC7, + 0xE0, 0x4B, 0x43, 0x2D, 0x0D, 0x37, 0xF9, 0x76, + 0x4B, 0x3D, 0x32, 0xF0, 0x6D, 0xF4, 0x17, 0x9B + }, + { + 0xCF, 0x98, 0xDD, 0xF3, 0x01, 0x21, 0x7B, 0xFA, + 0x7E, 0xCE, 0xFF, 0x05, 0x65, 0xE5, 0xD1, 0x6A, + 0x32, 0x74, 0xE7, 0x10, 0x9F, 0xF9, 0x50, 0x2C, + 0x3E, 0x95, 0x59, 0xA0, 0x5E, 0xA2, 0x63, 0x5B + }, + { + 0xE5, 0x6B, 0xFE, 0xAF, 0xD7, 0x20, 0x2F, 0x00, + 0x9A, 0xC0, 0x41, 0xBA, 0xBC, 0xC1, 0xFC, 0xB6, + 0xFA, 0x62, 0x07, 0xD6, 0x35, 0xBF, 0x7A, 0xD4, + 0x57, 0xC4, 0xB2, 0xA6, 0x63, 0x90, 0x50, 0xE7 + }, + { + 0x31, 0x55, 0x25, 0x44, 0x27, 0xAF, 0x05, 0x3C, + 0x5B, 0x48, 0x4A, 0x41, 0x32, 0xA1, 0xB7, 0x6C, + 0x73, 0xC0, 0x13, 0x7A, 0xED, 0xD8, 0x7B, 0xDE, + 0xE1, 0x0B, 0x31, 0xFD, 0xFC, 0xAD, 0x99, 0x29 + }, + { + 0xD7, 0x42, 0x01, 0x8F, 0x33, 0xE8, 0xDF, 0x22, + 0x29, 0xFC, 0x14, 0x16, 0xAE, 0x96, 0x79, 0xBC, + 0xA9, 0xDC, 0xEA, 0xAC, 0xB5, 0x26, 0x70, 0xC3, + 0x1A, 0x63, 0xE3, 0xB3, 0xEE, 0xCB, 0x8E, 0x28 + }, + { + 0x24, 0x9C, 0x05, 0xDC, 0x55, 0xD6, 0xEB, 0x6B, + 0x15, 0x8E, 0x4C, 0x77, 0x86, 0xE6, 0xC9, 0x9E, + 0x5C, 0xD9, 0x5E, 0x9F, 0x43, 0xE5, 0x5F, 0x1C, + 0x38, 0x63, 0xE7, 0x4D, 0x1F, 0x4F, 0x54, 0x6A + }, + { + 0x5C, 0x5C, 0x7C, 0x27, 0xDA, 0x28, 0x2C, 0x4C, + 0x89, 0x70, 0x44, 0x1E, 0x7F, 0x9D, 0x25, 0x37, + 0x06, 0xBC, 0xA3, 0xD1, 0xA6, 0x1E, 0xD9, 0xC5, + 0xF8, 0xF7, 0xFF, 0x9B, 0x79, 0x45, 0x93, 0xC5 + }, + { + 0xF5, 0x8B, 0xAD, 0xBE, 0xEA, 0x58, 0xD7, 0x18, + 0xCD, 0x9D, 0x70, 0x62, 0x96, 0x24, 0x9E, 0x2E, + 0xA4, 0x57, 0xC1, 0xC4, 0x1B, 0x2D, 0x7A, 0x9C, + 0xF4, 0x27, 0x1C, 0xFF, 0x5F, 0xB6, 0x81, 0xD6 + }, + { + 0xCA, 0xE8, 0x0C, 0x40, 0x4A, 0x05, 0x45, 0x37, + 0xB1, 0x47, 0x31, 0x6A, 0x32, 0xAA, 0x29, 0xBB, + 0x49, 0x67, 0xDE, 0xE9, 0xC1, 0xC8, 0x33, 0xF5, + 0x24, 0x11, 0x1D, 0xCE, 0x0D, 0xB1, 0xA0, 0x80 + }, + { + 0x47, 0xB3, 0x79, 0x43, 0x9A, 0x98, 0x96, 0x63, + 0x1E, 0x02, 0x09, 0x5B, 0xF4, 0x4A, 0x5E, 0x72, + 0x46, 0x2F, 0x38, 0x75, 0x06, 0xF1, 0x1C, 0x1E, + 0x88, 0x7F, 0xEA, 0xCA, 0x32, 0x12, 0x68, 0xA5 + }, + { + 0x32, 0x01, 0x2E, 0xE3, 0x0D, 0x2E, 0x80, 0x3E, + 0x57, 0x48, 0xA7, 0xBC, 0x6D, 0x3D, 0x2E, 0x02, + 0x49, 0x65, 0xE9, 0xD4, 0x01, 0xAD, 0xE7, 0xBB, + 0xAB, 0xB2, 0x3B, 0xF9, 0x85, 0x90, 0xA0, 0x8E + }, + { + 0xDC, 0x5D, 0x89, 0x31, 0xA5, 0xED, 0xEC, 0xB3, + 0xDC, 0xF2, 0x05, 0x9C, 0x25, 0x02, 0x0A, 0xCC, + 0x3E, 0xFD, 0x77, 0x44, 0xC9, 0x80, 0x2E, 0x08, + 0x64, 0x5D, 0xA5, 0x16, 0x57, 0xF7, 0x75, 0x18 + }, + { + 0xBD, 0x27, 0x0D, 0xB0, 0xEC, 0xDA, 0xF0, 0x9C, + 0x22, 0xBF, 0x1B, 0xB9, 0xD4, 0x73, 0xCD, 0x42, + 0x35, 0x09, 0x0A, 0x06, 0x9B, 0xA4, 0xAA, 0xF2, + 0x2E, 0xEC, 0xA5, 0xDC, 0x88, 0x8A, 0xC0, 0x78 + }, + { + 0xBF, 0xC8, 0x63, 0x27, 0x3C, 0x0E, 0xC2, 0x33, + 0x64, 0x1D, 0xE5, 0x8C, 0x6B, 0x34, 0x3C, 0xE0, + 0xCA, 0xB5, 0xA0, 0x81, 0xD0, 0x5D, 0x19, 0x78, + 0xD1, 0x82, 0x0D, 0xBF, 0xFD, 0x57, 0x04, 0x33 + }, + { + 0x5B, 0xDC, 0x6C, 0x5F, 0x12, 0xD9, 0xE6, 0xBB, + 0x7B, 0x76, 0x2F, 0xAE, 0x35, 0x67, 0xCE, 0x5F, + 0xAA, 0xBB, 0x18, 0x4A, 0xE9, 0x46, 0x04, 0x8B, + 0xB1, 0x08, 0x47, 0x65, 0x5F, 0x21, 0x3D, 0x0C + }, + { + 0x42, 0xF6, 0x86, 0x99, 0x20, 0x03, 0xA3, 0xDB, + 0xAA, 0x71, 0x30, 0x1E, 0xAB, 0x4C, 0x24, 0x62, + 0x45, 0x79, 0x5A, 0x42, 0x2C, 0x6F, 0x2B, 0xF5, + 0x90, 0xC9, 0x65, 0xA6, 0x8A, 0x89, 0x0A, 0x0F + }, + { + 0x26, 0xE8, 0x89, 0x3A, 0x92, 0xA8, 0xEC, 0x2F, + 0x52, 0x98, 0x89, 0x96, 0xB3, 0x56, 0x80, 0x29, + 0xB2, 0xAD, 0xB7, 0x33, 0xB8, 0x91, 0xF2, 0x81, + 0xB0, 0xAA, 0x97, 0x3E, 0x6A, 0x03, 0x88, 0x55 + }, + { + 0x11, 0x7F, 0xD6, 0xF4, 0x13, 0x91, 0xBF, 0x4C, + 0x79, 0x42, 0xBE, 0xC4, 0x44, 0xCC, 0xA3, 0x95, + 0xBB, 0x8B, 0xFD, 0xD1, 0x8E, 0xBA, 0x5C, 0xC5, + 0xC8, 0xDF, 0xA5, 0x08, 0x82, 0xFB, 0xA7, 0x4E + }, + { + 0xFE, 0xFE, 0x08, 0xF5, 0x26, 0x43, 0xBF, 0xB8, + 0x89, 0xBB, 0x4D, 0x4B, 0x9D, 0xF2, 0x96, 0xC3, + 0x75, 0x65, 0xE4, 0xDC, 0x42, 0x3C, 0x4D, 0x47, + 0x5E, 0x56, 0x65, 0xA5, 0x1D, 0xD7, 0x81, 0x54 + }, + { + 0x81, 0x4B, 0x48, 0x68, 0x24, 0xF7, 0xB0, 0x95, + 0x5F, 0x86, 0x0A, 0xE4, 0xA4, 0xE8, 0xD7, 0x03, + 0x64, 0xBC, 0xE8, 0xE9, 0x7C, 0x3C, 0x1D, 0xCF, + 0x71, 0x8F, 0xC4, 0xCB, 0xB5, 0x4E, 0xE4, 0xB2 + }, + { + 0x6F, 0xF4, 0x9C, 0xBA, 0x0B, 0x3B, 0x48, 0x11, + 0xBB, 0x65, 0xB0, 0xEE, 0x52, 0xD7, 0x02, 0x34, + 0x3F, 0xA6, 0xDF, 0x84, 0x27, 0xC5, 0x55, 0xD4, + 0x00, 0xEC, 0x3F, 0x90, 0xAD, 0xDB, 0xCA, 0x5D + }, + { + 0x4C, 0x3F, 0xF9, 0xF0, 0x17, 0x45, 0xBD, 0x8A, + 0xDD, 0x1B, 0x49, 0x3D, 0x20, 0x41, 0x3E, 0xA1, + 0x2F, 0x14, 0x42, 0x47, 0xB3, 0x7B, 0xEF, 0x66, + 0xA2, 0x57, 0x1B, 0xEA, 0xC8, 0xB9, 0x27, 0x26 + }, + { + 0xF3, 0x16, 0x09, 0x32, 0x49, 0x55, 0x98, 0x4C, + 0x3F, 0x7D, 0xD7, 0x05, 0x76, 0xB1, 0xD9, 0x4C, + 0xD9, 0x3C, 0x55, 0x2B, 0x68, 0xDF, 0x65, 0xB9, + 0x30, 0x2C, 0x75, 0x63, 0x79, 0x18, 0xB8, 0x7E + }, + { + 0xC9, 0x3F, 0x02, 0x85, 0x2F, 0x54, 0xAA, 0xBB, + 0x52, 0x98, 0xB2, 0x3A, 0x43, 0x31, 0x82, 0x64, + 0xED, 0xE6, 0xE8, 0xA4, 0x9C, 0x94, 0xD5, 0xA0, + 0x8C, 0x09, 0xC0, 0x73, 0x09, 0x8B, 0xE6, 0x38 + }, + { + 0x96, 0xE7, 0xD9, 0x21, 0x78, 0x27, 0xF9, 0x5B, + 0x9B, 0x15, 0x72, 0xE8, 0x3F, 0xC0, 0xA5, 0x4F, + 0x05, 0x54, 0xB1, 0xC1, 0x71, 0x1A, 0x30, 0xC0, + 0x1D, 0xAB, 0xEB, 0xAF, 0x59, 0xAE, 0xEB, 0x16 + }, + { + 0x39, 0xCC, 0x58, 0x5D, 0xF5, 0x3B, 0x92, 0x25, + 0x7C, 0x2B, 0xB6, 0x19, 0x63, 0x19, 0xD6, 0x93, + 0xA1, 0xDA, 0x5F, 0x4E, 0xEF, 0x49, 0x2A, 0x5A, + 0xBC, 0xCE, 0x92, 0x78, 0xA0, 0x98, 0x51, 0xD9 + }, + { + 0x47, 0xEB, 0x6B, 0xB2, 0x06, 0x57, 0xC3, 0x8D, + 0xE8, 0xF5, 0x19, 0x16, 0x63, 0xDA, 0x78, 0x8A, + 0x03, 0x7C, 0xF9, 0xD3, 0xF5, 0x88, 0xE6, 0x8C, + 0xB4, 0x6E, 0xF1, 0xAB, 0x04, 0xA7, 0xF8, 0xDE + }, + { + 0x06, 0x72, 0x1B, 0xAB, 0xA9, 0xFD, 0xC0, 0xAE, + 0x69, 0xF9, 0x56, 0xE5, 0xEA, 0x12, 0xC6, 0xDF, + 0xD9, 0x93, 0xE9, 0xF1, 0x90, 0x77, 0x9B, 0xCD, + 0x84, 0xA2, 0x0F, 0x46, 0x3C, 0x9F, 0x07, 0xF4 + }, + { + 0x84, 0x21, 0xD0, 0xF7, 0x1F, 0x78, 0x4F, 0xBD, + 0x99, 0x93, 0x7E, 0x6E, 0xE5, 0x24, 0xBC, 0x7B, + 0x10, 0x50, 0x62, 0xE8, 0x9F, 0xFA, 0x11, 0x84, + 0x36, 0x0A, 0x17, 0x21, 0x3C, 0x4B, 0x13, 0x6D + }, + { + 0x28, 0x90, 0xEC, 0x0F, 0xA4, 0xAF, 0x42, 0x78, + 0xAD, 0x5E, 0x96, 0xC2, 0xCC, 0x08, 0x59, 0xED, + 0x44, 0x26, 0xF9, 0xF2, 0x8F, 0xA1, 0x8F, 0xF9, + 0x3D, 0x1F, 0x42, 0x7E, 0xDB, 0xED, 0x66, 0x4F + }, + { + 0x36, 0xFB, 0x0D, 0x54, 0x96, 0x37, 0xCD, 0xDE, + 0xB0, 0xFB, 0xB0, 0xB3, 0x3D, 0xC3, 0x2A, 0xCB, + 0x4B, 0xC0, 0x6F, 0x57, 0x12, 0x1D, 0xD9, 0xAB, + 0x4B, 0x7F, 0x92, 0x7F, 0x8E, 0x6C, 0x34, 0xDE + }, + { + 0x20, 0x74, 0xE9, 0x93, 0x56, 0x47, 0x08, 0x73, + 0x85, 0xDD, 0xB9, 0xDF, 0x03, 0x07, 0x08, 0xB5, + 0x0E, 0xC3, 0xE4, 0x11, 0x83, 0xF7, 0xF6, 0x62, + 0x95, 0x5F, 0x3B, 0xEB, 0x2D, 0x5A, 0x94, 0xCC + }, + { + 0x74, 0xBD, 0xE0, 0xC4, 0x27, 0x7C, 0xDE, 0x41, + 0xAA, 0x08, 0xF1, 0x15, 0x1B, 0xB0, 0xBF, 0x6F, + 0x89, 0x22, 0xA1, 0xB5, 0x13, 0xC7, 0xA5, 0xE1, + 0x28, 0x9A, 0x9A, 0x85, 0x6B, 0xD2, 0xB5, 0x72 + }, + { + 0xDB, 0x12, 0x7A, 0xD7, 0x2F, 0x80, 0x64, 0x01, + 0x2F, 0x8A, 0x9B, 0x38, 0x94, 0x12, 0x51, 0x78, + 0x38, 0x6D, 0x6A, 0x63, 0xC0, 0x2F, 0xC1, 0x25, + 0xFF, 0xF2, 0x70, 0x7F, 0xB8, 0x39, 0x11, 0xA0 + }, + { + 0x0A, 0x3B, 0xBD, 0x04, 0x59, 0xE0, 0xFF, 0x49, + 0x40, 0x64, 0x55, 0x9F, 0x26, 0x39, 0x5A, 0xD9, + 0x27, 0x52, 0xE6, 0xE8, 0x52, 0x1C, 0x1C, 0x99, + 0x28, 0x15, 0xF4, 0x95, 0x02, 0x2D, 0xCD, 0xE0 + }, + { + 0x86, 0x12, 0x74, 0x95, 0x61, 0xC4, 0x11, 0xFF, + 0x6C, 0xF8, 0x2C, 0xEC, 0x00, 0x9A, 0xA6, 0xAB, + 0x30, 0x96, 0xE1, 0xC2, 0x95, 0x2A, 0xC8, 0xF6, + 0x9F, 0x8A, 0x83, 0xA1, 0x93, 0x34, 0x4F, 0x37 + }, + { + 0x33, 0xFC, 0x8E, 0x71, 0x84, 0x77, 0x68, 0xBE, + 0x41, 0xF5, 0x25, 0x5D, 0xAF, 0x10, 0x97, 0x83, + 0xDA, 0xCA, 0x7F, 0xD4, 0xC1, 0x11, 0xE1, 0x6B, + 0x64, 0x3E, 0x05, 0xDE, 0x4F, 0x13, 0x1A, 0xF2 + }, + { + 0xAE, 0x13, 0x4F, 0x92, 0x14, 0xE7, 0xA8, 0x4C, + 0x3C, 0x6D, 0xE8, 0xD4, 0x59, 0xE5, 0x77, 0x28, + 0x2F, 0x32, 0x5C, 0x85, 0xFD, 0x5C, 0xD1, 0x40, + 0x04, 0xD9, 0xE0, 0xC0, 0x4B, 0xBC, 0x32, 0x61 + }, + { + 0x03, 0x11, 0xF2, 0x54, 0x35, 0x2D, 0x10, 0xFE, + 0x86, 0xC3, 0xF2, 0x9A, 0x62, 0x8C, 0xDB, 0x41, + 0x22, 0x70, 0x18, 0x7D, 0xDB, 0x6A, 0xBC, 0x47, + 0x2C, 0xEA, 0x24, 0x00, 0x2A, 0xD9, 0xC0, 0x50 + }, + { + 0x84, 0x6F, 0xFB, 0xB5, 0xA3, 0x05, 0xA1, 0x79, + 0x92, 0x8D, 0xE0, 0xA0, 0x7A, 0xCD, 0x55, 0x89, + 0x98, 0x8B, 0x7E, 0x2C, 0xD7, 0x8D, 0xC4, 0x2C, + 0x3B, 0x94, 0x66, 0x2C, 0x6C, 0xE4, 0x0D, 0x43 + }, + { + 0x88, 0x26, 0xE2, 0xC8, 0xA1, 0x71, 0xE0, 0x1D, + 0xC0, 0x3E, 0x6B, 0xBE, 0x21, 0xC4, 0x42, 0x5E, + 0x55, 0x09, 0xE2, 0xC7, 0xE3, 0xD3, 0xE0, 0x39, + 0x46, 0x21, 0x60, 0x1B, 0x34, 0x32, 0x44, 0x9C + }, + { + 0xF9, 0xCC, 0xD2, 0x11, 0xB9, 0x7E, 0x03, 0xAA, + 0x2F, 0x53, 0xBD, 0xB6, 0x27, 0x95, 0x16, 0xB6, + 0x9D, 0xE5, 0xD7, 0x7D, 0xCA, 0x64, 0x4F, 0x3B, + 0xFB, 0x10, 0x88, 0x34, 0x95, 0x94, 0xF0, 0xB3 + }, + { + 0xB0, 0x0E, 0x53, 0x21, 0x93, 0x92, 0x96, 0xFC, + 0xCA, 0xD8, 0x70, 0x63, 0xE8, 0x62, 0x25, 0xE5, + 0x97, 0xD7, 0x11, 0xAE, 0x2D, 0x17, 0x26, 0x7F, + 0x5F, 0x65, 0xEA, 0x16, 0xDA, 0x8D, 0x9A, 0xC6 + }, + { + 0xEF, 0x89, 0xCF, 0x30, 0x92, 0xA4, 0x5A, 0x16, + 0x73, 0xBC, 0x6A, 0xB6, 0x5E, 0x37, 0x85, 0x5B, + 0x9F, 0x7C, 0x37, 0xD1, 0x09, 0x6A, 0x16, 0x33, + 0x92, 0xCA, 0x0F, 0x6A, 0xC4, 0x0F, 0xE4, 0x6B + }, + { + 0x78, 0xC0, 0xC5, 0xE5, 0x95, 0xC7, 0x69, 0xA1, + 0x3D, 0x96, 0x4D, 0xEC, 0x90, 0x03, 0xF1, 0xA5, + 0x96, 0xF3, 0x5A, 0xA4, 0xDA, 0xFB, 0xA8, 0xCC, + 0x79, 0x0C, 0x57, 0x2E, 0x63, 0x02, 0xC7, 0x67 + }, + { + 0xF4, 0xA8, 0x7C, 0x63, 0xAD, 0xB2, 0x9A, 0x2D, + 0xED, 0x79, 0x82, 0xA9, 0x15, 0xB7, 0xF9, 0x51, + 0xA1, 0x77, 0xA2, 0x23, 0x63, 0x0B, 0x32, 0x4C, + 0xEF, 0xD5, 0x82, 0xC1, 0x4C, 0x5F, 0x05, 0x4A + }, + { + 0x2A, 0x15, 0xDB, 0x5A, 0x84, 0x55, 0x89, 0x67, + 0xB9, 0xC6, 0x40, 0x9A, 0x2E, 0xAC, 0x9A, 0xF3, + 0xA4, 0xA5, 0xE6, 0xDB, 0x6A, 0xA1, 0xA3, 0x24, + 0x4C, 0x3C, 0x07, 0xA1, 0x81, 0xE7, 0x69, 0x81 + }, + { + 0x37, 0x69, 0x7A, 0x59, 0x11, 0x69, 0x2B, 0x9C, + 0xB0, 0x4C, 0x18, 0xAF, 0x06, 0xCA, 0x6A, 0xF4, + 0x00, 0x9B, 0x2E, 0xC0, 0xA1, 0x1D, 0x5F, 0x8B, + 0xDD, 0xC1, 0xAB, 0xB1, 0x5F, 0x06, 0xB7, 0xAF + }, + { + 0xE6, 0x19, 0x48, 0x90, 0x3A, 0x4C, 0x05, 0x1F, + 0x6D, 0xA8, 0xE3, 0x29, 0x19, 0xEF, 0x26, 0xED, + 0x9B, 0x25, 0x92, 0x17, 0x7B, 0xAF, 0xA8, 0xC2, + 0x04, 0x49, 0xC8, 0xD1, 0x4E, 0xA6, 0x26, 0xD3 + }, + { + 0x94, 0xBA, 0x19, 0xFD, 0x40, 0x80, 0xE2, 0x69, + 0xF8, 0x05, 0xDA, 0x67, 0xD7, 0xC0, 0x5A, 0xB3, + 0xCE, 0xD2, 0xBF, 0x7C, 0x0E, 0x2D, 0x4C, 0x6B, + 0x78, 0xBF, 0x55, 0x9C, 0xC0, 0xA2, 0x73, 0xAD + }, + { + 0x25, 0xEB, 0xF7, 0x78, 0x68, 0x85, 0x3D, 0x93, + 0xEE, 0x50, 0xD4, 0x60, 0x9C, 0xF8, 0x01, 0x1A, + 0x5F, 0x8C, 0xC3, 0xBC, 0x5F, 0x10, 0x9E, 0x03, + 0x86, 0x7C, 0xB2, 0xB9, 0x07, 0x87, 0x87, 0xEA + }, + { + 0xB5, 0xA9, 0xAE, 0x3C, 0x7D, 0x0C, 0xFD, 0xEC, + 0xF4, 0x34, 0x19, 0xD4, 0xD5, 0x43, 0x38, 0x6C, + 0x59, 0x0E, 0xCD, 0xAA, 0x08, 0x9C, 0x95, 0x97, + 0x25, 0x93, 0x45, 0xA6, 0xB6, 0x77, 0x5C, 0xF9 + }, + { + 0x61, 0xF8, 0x8C, 0x20, 0x8B, 0x88, 0x53, 0x58, + 0xCB, 0xE1, 0xB0, 0x9E, 0x18, 0x91, 0xBE, 0x82, + 0x32, 0x06, 0xE2, 0xFA, 0x9D, 0x07, 0x54, 0x69, + 0x33, 0x65, 0xEF, 0x68, 0x60, 0x0A, 0x7A, 0xF0 + }, + { + 0xF6, 0xFD, 0x39, 0x6A, 0xF1, 0x1F, 0x52, 0x41, + 0x88, 0x66, 0x62, 0xE2, 0xA2, 0x8B, 0x5D, 0x77, + 0x9D, 0x63, 0x39, 0x5C, 0x5F, 0xA4, 0x2D, 0xD1, + 0xB4, 0xB3, 0xFF, 0xE9, 0x15, 0xCC, 0x7E, 0xC8 + }, + { + 0x3C, 0x0D, 0xB3, 0x18, 0x89, 0xDA, 0x6B, 0x5B, + 0x6F, 0xD7, 0xE3, 0x42, 0xD5, 0x89, 0x67, 0xA8, + 0xB7, 0xB8, 0x3D, 0xF4, 0x13, 0x46, 0xED, 0x00, + 0x6E, 0xF9, 0xE7, 0x22, 0x34, 0xD9, 0x18, 0xF3 + }, + { + 0xFD, 0x43, 0x7A, 0x63, 0xE8, 0x26, 0x8E, 0xC1, + 0xB2, 0x40, 0x05, 0x3F, 0x95, 0x56, 0x26, 0xDD, + 0x7E, 0xEF, 0x33, 0xB4, 0x99, 0xB0, 0xA1, 0x84, + 0x35, 0x94, 0xDA, 0xDA, 0x49, 0x13, 0xB6, 0x41 + }, + { + 0x00, 0xC9, 0x08, 0x17, 0xD2, 0x69, 0x87, 0x4B, + 0xAC, 0xDF, 0xE7, 0x95, 0x50, 0xE6, 0x95, 0x47, + 0xC5, 0x28, 0x53, 0x86, 0x61, 0x2B, 0xC6, 0x05, + 0x8D, 0x59, 0xCB, 0x2F, 0x89, 0xA2, 0x3A, 0xC5 + }, + { + 0x85, 0x1E, 0x70, 0x90, 0xB1, 0x74, 0x90, 0x34, + 0xC8, 0x8D, 0x58, 0x69, 0xC8, 0x8F, 0xB7, 0xB4, + 0xBB, 0x30, 0x6B, 0x24, 0x2B, 0xDC, 0xF2, 0x41, + 0xAF, 0x2C, 0x18, 0xE1, 0xD5, 0x39, 0xB5, 0x3E + }, + { + 0x9F, 0x76, 0xCD, 0x71, 0x05, 0xBB, 0x5C, 0x00, + 0xF8, 0x4B, 0x12, 0x73, 0xA4, 0x55, 0xF9, 0x8E, + 0xFD, 0xD9, 0xC6, 0x8A, 0x27, 0x7A, 0x2F, 0xF3, + 0xFC, 0x23, 0x30, 0x4A, 0x97, 0x79, 0x9E, 0xC2 + }, + { + 0xF4, 0x1F, 0x79, 0xFB, 0xE5, 0xB1, 0x78, 0xD2, + 0x32, 0x30, 0xAD, 0x7D, 0x8E, 0x32, 0x56, 0x93, + 0xB9, 0x89, 0xF7, 0x43, 0x19, 0x65, 0x6D, 0x88, + 0x1B, 0xF8, 0x08, 0x3B, 0x7D, 0xAF, 0x09, 0xA3 + }, + { + 0xF2, 0xC8, 0x48, 0xFD, 0x7F, 0xB4, 0xB3, 0x44, + 0xC5, 0xDA, 0xE6, 0x36, 0xEF, 0xCA, 0xAB, 0x40, + 0xC9, 0x9A, 0xB5, 0x6D, 0xA5, 0x01, 0x57, 0xBA, + 0xE5, 0xA9, 0x4F, 0x50, 0xD3, 0x9F, 0xFA, 0xE7 + }, + { + 0x76, 0xA6, 0x51, 0xDB, 0xD4, 0x34, 0xC9, 0x73, + 0x10, 0x0C, 0xDE, 0x9A, 0x81, 0x52, 0x2A, 0xBF, + 0x34, 0x5F, 0x73, 0xB4, 0x0F, 0x9B, 0x51, 0x50, + 0x00, 0x17, 0x23, 0x85, 0x06, 0x12, 0x9B, 0x0D + }, + { + 0x46, 0x51, 0xE5, 0xC0, 0x8A, 0xFB, 0x1F, 0x53, + 0xBE, 0x19, 0x7B, 0x69, 0x42, 0x0E, 0x10, 0x33, + 0x2C, 0xBC, 0xC5, 0xBB, 0x6E, 0x57, 0xDC, 0x7F, + 0x6C, 0x49, 0xEF, 0xB5, 0xA1, 0xB5, 0x6B, 0x4C + }, + { + 0x10, 0x3C, 0x1C, 0x99, 0x96, 0x29, 0x67, 0x0A, + 0xD9, 0x35, 0x54, 0x03, 0xD7, 0x10, 0xF4, 0x0A, + 0xEA, 0x32, 0x24, 0x29, 0x2C, 0x26, 0x1C, 0x00, + 0x3E, 0x4B, 0x36, 0xF4, 0xC3, 0x5A, 0xF7, 0x98 + }, + { + 0x0E, 0x6D, 0xCF, 0x01, 0xC9, 0x33, 0x67, 0x9F, + 0xF2, 0xB3, 0x96, 0x36, 0x8B, 0xF5, 0x58, 0xA0, + 0xE3, 0x26, 0xD2, 0x9E, 0x5C, 0x80, 0x8F, 0xD2, + 0xDD, 0xE0, 0xD1, 0x82, 0x8C, 0x85, 0xA9, 0x0F + }, + { + 0xBA, 0x60, 0x7C, 0x08, 0x03, 0x0C, 0x32, 0xAA, + 0x3F, 0xA7, 0xB8, 0xF9, 0xFC, 0x7F, 0x52, 0x39, + 0xC2, 0x6F, 0xDF, 0xEA, 0x76, 0x00, 0x09, 0x7A, + 0x76, 0x3C, 0xA4, 0x0B, 0x5E, 0x56, 0xBB, 0x46 + }, + { + 0xA8, 0x3F, 0x8C, 0x1D, 0xDA, 0x99, 0xEE, 0x7F, + 0x98, 0x26, 0x68, 0x47, 0xCF, 0xB8, 0x92, 0x12, + 0x4B, 0x11, 0xA9, 0x6D, 0xFA, 0x34, 0x42, 0x23, + 0xFA, 0x8C, 0xC9, 0x6E, 0xEB, 0xF1, 0x13, 0xFB + }, + { + 0xDF, 0xB0, 0x48, 0x40, 0x8D, 0xF7, 0xF9, 0x05, + 0x49, 0xC4, 0x48, 0x6A, 0x2A, 0x38, 0x83, 0x9D, + 0xD4, 0xFF, 0x83, 0x73, 0xD5, 0x87, 0x62, 0x22, + 0x8D, 0x52, 0x79, 0x38, 0x74, 0x09, 0xFE, 0x48 + }, + { + 0x1F, 0x69, 0xE1, 0xE7, 0xD0, 0x8C, 0xE0, 0x32, + 0xCA, 0xC9, 0x13, 0x1A, 0x6B, 0x07, 0xF6, 0x6F, + 0x41, 0x79, 0x43, 0xCA, 0x81, 0x8C, 0x89, 0x9B, + 0xF5, 0xD4, 0x2F, 0xBE, 0x46, 0xB9, 0x95, 0x6B + }, + { + 0xC5, 0x61, 0xD8, 0x91, 0x14, 0xA8, 0xA5, 0xF1, + 0xFD, 0xBC, 0x03, 0xFF, 0x23, 0x95, 0x02, 0x5C, + 0x3D, 0xF4, 0xBF, 0xFE, 0xFD, 0x73, 0x09, 0x8E, + 0x4E, 0x26, 0xCF, 0x3E, 0xE3, 0xE0, 0xD3, 0x79 + }, + { + 0x9E, 0xD1, 0xEB, 0xA8, 0xA2, 0x82, 0x4A, 0xE8, + 0x45, 0x4E, 0x44, 0xE7, 0x3D, 0xDD, 0xB0, 0x2D, + 0xD8, 0xDA, 0x33, 0x0E, 0xE0, 0xD8, 0x0B, 0x55, + 0xFA, 0x0B, 0x2A, 0xBD, 0x59, 0xC8, 0x2A, 0xD4 + }, + { + 0x12, 0x80, 0x43, 0x19, 0xBC, 0xD1, 0x43, 0x93, + 0x70, 0xDD, 0x67, 0x8D, 0xC3, 0x74, 0x04, 0x29, + 0x06, 0x04, 0xE4, 0x80, 0x7A, 0x8B, 0xE4, 0xF2, + 0x1C, 0x3C, 0xA5, 0x51, 0x75, 0xC2, 0x04, 0x00 + }, + { + 0xF1, 0x1A, 0xD2, 0x7F, 0x52, 0x56, 0xAC, 0xF4, + 0xB2, 0x48, 0x16, 0x91, 0x93, 0x38, 0x46, 0x82, + 0xA3, 0x8D, 0x21, 0x42, 0x01, 0xDE, 0x4C, 0x7E, + 0x40, 0x52, 0xA4, 0xBC, 0x14, 0x16, 0x60, 0x83 + }, + { + 0x83, 0x25, 0x62, 0xB3, 0x50, 0xC9, 0x59, 0x2F, + 0xE5, 0xAB, 0x1D, 0x45, 0xA0, 0x4D, 0x2A, 0x29, + 0x5E, 0x9B, 0xE7, 0x15, 0x27, 0xD6, 0xDE, 0x8F, + 0x24, 0x6E, 0x8A, 0xF0, 0x7D, 0x7D, 0x77, 0x01 + }, + { + 0xD5, 0x1A, 0x1D, 0xA4, 0x49, 0x4D, 0x60, 0x0B, + 0x2D, 0x1B, 0x2F, 0x1E, 0x0E, 0xD7, 0xE4, 0x61, + 0xF8, 0x34, 0x1C, 0x29, 0xD2, 0x85, 0xCE, 0xE5, + 0x6E, 0x26, 0x2C, 0x7C, 0xA6, 0x7E, 0xD5, 0x2A + }, + { + 0x8C, 0x95, 0x63, 0xB4, 0x85, 0x8B, 0x03, 0xDE, + 0xC7, 0xC8, 0x4B, 0x99, 0x2B, 0x63, 0x94, 0xE0, + 0x7A, 0x5A, 0x5B, 0x67, 0xDD, 0x54, 0xE8, 0x1A, + 0x95, 0xF2, 0x24, 0x76, 0x44, 0x07, 0x45, 0xC6 + }, + { + 0x4F, 0x83, 0x56, 0x52, 0x2B, 0x20, 0x83, 0xBF, + 0x17, 0x31, 0x81, 0xD8, 0xDE, 0xDF, 0x12, 0xFF, + 0x61, 0xC3, 0xDB, 0xA6, 0xB3, 0x7A, 0xA2, 0xA8, + 0x1C, 0xDC, 0x8E, 0xC5, 0xD2, 0x77, 0xF1, 0x64 + }, + { + 0xB5, 0x7C, 0x75, 0xAE, 0x52, 0x40, 0x93, 0xF1, + 0x5E, 0x32, 0xC0, 0x7F, 0x91, 0x5C, 0x58, 0x83, + 0x77, 0xD2, 0xE7, 0xE2, 0x63, 0xB2, 0x72, 0xBE, + 0x07, 0x56, 0xEC, 0xF0, 0x9F, 0x3B, 0x63, 0x80 + }, + { + 0x0E, 0xE5, 0x51, 0x16, 0x30, 0xF2, 0x3C, 0xFB, + 0x56, 0x76, 0x50, 0x83, 0x20, 0x2B, 0xB6, 0x7C, + 0x75, 0x91, 0xA8, 0x69, 0x03, 0x7A, 0xF4, 0x30, + 0xD5, 0x49, 0x5A, 0xAB, 0xDE, 0x42, 0x16, 0x4F + }, + { + 0xA9, 0x05, 0x48, 0xF2, 0x28, 0xB2, 0xFC, 0x7B, + 0x4A, 0xFD, 0xBB, 0xE5, 0x4D, 0x37, 0x08, 0xF7, + 0x07, 0x15, 0x1C, 0x0A, 0xA2, 0x70, 0xEA, 0xE8, + 0xC8, 0x54, 0x7D, 0x6E, 0x57, 0xB1, 0x11, 0xEF + }, + { + 0x3F, 0xF0, 0xF5, 0x81, 0xA8, 0x41, 0x9C, 0x04, + 0x77, 0x4E, 0x20, 0xAF, 0xAE, 0x4A, 0x23, 0x48, + 0x50, 0x04, 0x8D, 0x49, 0x45, 0xAC, 0x19, 0x5B, + 0x87, 0xC1, 0x08, 0x8F, 0x86, 0x0B, 0xBE, 0x24 + }, + { + 0x7B, 0x2D, 0xB3, 0x9F, 0x80, 0x94, 0xA8, 0x43, + 0x2E, 0xD2, 0x9C, 0xB5, 0x87, 0xC7, 0x2D, 0x1A, + 0x8C, 0x02, 0xD0, 0x8B, 0xE0, 0xAC, 0x85, 0x09, + 0xEE, 0x15, 0x0F, 0xB8, 0x8F, 0x0B, 0x8E, 0xFC + }, + { + 0x74, 0x67, 0x1D, 0x2E, 0xEB, 0x29, 0xA9, 0x43, + 0x5B, 0x4A, 0xBC, 0x25, 0xDA, 0xF6, 0x34, 0x24, + 0xD9, 0x9F, 0x56, 0xEA, 0x54, 0x54, 0x23, 0x31, + 0x9E, 0x03, 0xDF, 0xE4, 0xBC, 0xED, 0xF5, 0xE5 + }, + { + 0xAA, 0x0D, 0x86, 0x4D, 0xC0, 0xCC, 0x56, 0x63, + 0x1E, 0x6F, 0x93, 0x41, 0x68, 0xD9, 0x14, 0x96, + 0x2D, 0x06, 0x11, 0x2D, 0xFD, 0x96, 0xEB, 0x16, + 0xF5, 0xB8, 0x62, 0x6D, 0xB1, 0x03, 0xA2, 0x66 + }, + { + 0x73, 0x1E, 0xCD, 0x99, 0x98, 0x04, 0x36, 0xD4, + 0x2C, 0x76, 0x88, 0x20, 0x05, 0xF0, 0xF7, 0xB2, + 0x51, 0xB4, 0xE0, 0xE4, 0x0A, 0x5A, 0xB2, 0x4F, + 0x85, 0x82, 0x59, 0xE9, 0x27, 0x1A, 0x17, 0x37 + }, + { + 0x04, 0x64, 0x9E, 0xDF, 0x8F, 0x24, 0xF9, 0xC5, + 0xD5, 0x98, 0x48, 0x7E, 0x2F, 0x2A, 0xCB, 0xC1, + 0xE1, 0x53, 0xA2, 0xAE, 0xF1, 0x89, 0x7C, 0x6D, + 0xAB, 0x13, 0x1E, 0x40, 0xD8, 0x07, 0x97, 0x45 + }, + { + 0xA3, 0xF3, 0xAC, 0xCA, 0x20, 0x37, 0xAF, 0x38, + 0xBC, 0x1A, 0x34, 0xC5, 0x54, 0x2C, 0x25, 0x83, + 0x1B, 0xB7, 0x3D, 0x99, 0x13, 0x13, 0xA3, 0x0D, + 0xC6, 0x47, 0x01, 0xE1, 0x56, 0x6D, 0x4E, 0x33 + }, + { + 0x6C, 0x0D, 0xB0, 0x62, 0x80, 0x7F, 0xF4, 0x10, + 0xFF, 0x91, 0xCD, 0xF9, 0xEE, 0x07, 0xCD, 0x2D, + 0xA4, 0xBB, 0x0E, 0x4D, 0x0E, 0xA6, 0xD5, 0x2D, + 0xF0, 0x51, 0x6F, 0x98, 0x21, 0x34, 0xE8, 0x41 + }, + { + 0xDE, 0xDE, 0xE7, 0x02, 0xEB, 0x79, 0x8C, 0x6E, + 0x81, 0x33, 0xA9, 0x80, 0x6C, 0x1B, 0xE4, 0xE9, + 0x47, 0x95, 0x1A, 0x42, 0xF1, 0x68, 0x63, 0x24, + 0x24, 0x5A, 0x8D, 0x9A, 0x9D, 0xEE, 0x5D, 0x79 + }, + { + 0xA3, 0xBE, 0xE7, 0x82, 0xA4, 0x4D, 0x88, 0xA8, + 0x9C, 0xFF, 0xE9, 0x8B, 0x74, 0x1E, 0x56, 0xD8, + 0x94, 0xC2, 0x4E, 0x39, 0x11, 0x8C, 0x6E, 0x97, + 0xAB, 0x5D, 0xE4, 0xC0, 0xDF, 0x86, 0x8E, 0x08 + }, + { + 0x20, 0x7B, 0x10, 0x66, 0x62, 0x05, 0x67, 0x00, + 0xB7, 0x93, 0x68, 0x0C, 0xC6, 0xAC, 0x5C, 0x20, + 0x61, 0x65, 0x1D, 0xE5, 0xBC, 0x0A, 0xDD, 0x78, + 0x78, 0xC4, 0xFA, 0x4D, 0xA3, 0x41, 0x42, 0x25 + }, + { + 0xA5, 0x53, 0x11, 0x24, 0x35, 0x93, 0x5C, 0xBC, + 0x06, 0x68, 0xB6, 0x3B, 0x8F, 0x98, 0x13, 0xFC, + 0xCA, 0x34, 0x4C, 0x01, 0x26, 0x64, 0x41, 0x50, + 0xD6, 0x04, 0xDE, 0x3E, 0x88, 0xEB, 0xE5, 0x53 + }, + { + 0xF6, 0x15, 0x19, 0x5C, 0xAD, 0x64, 0xC8, 0xB8, + 0x20, 0x25, 0x86, 0xEB, 0x06, 0xCC, 0x8C, 0xBB, + 0x9D, 0x29, 0xBA, 0x85, 0xA1, 0x59, 0x30, 0xA1, + 0x83, 0x0E, 0x41, 0x45, 0x4F, 0xFB, 0x6A, 0x27 + }, + { + 0xCD, 0x37, 0xC5, 0x0C, 0x3E, 0x37, 0xD5, 0x5D, + 0x19, 0x5F, 0x85, 0x5F, 0xEC, 0x43, 0xC6, 0x66, + 0xFB, 0x41, 0x20, 0x82, 0x9F, 0x0F, 0x37, 0xB8, + 0x6C, 0xC6, 0xB8, 0x66, 0xFC, 0x28, 0x41, 0x26 + }, + { + 0x64, 0x99, 0xDB, 0x33, 0x33, 0x8E, 0xB0, 0x3C, + 0x73, 0x17, 0x7E, 0x5F, 0xA3, 0x67, 0xAA, 0x43, + 0xE4, 0xDC, 0x35, 0xEF, 0x1F, 0xCC, 0x59, 0xEE, + 0xBA, 0xFE, 0xB6, 0x31, 0x68, 0x09, 0xCF, 0xCD + }, + { + 0x94, 0x30, 0xE8, 0x8E, 0x88, 0x6E, 0x7E, 0xD3, + 0x6E, 0xCF, 0x8F, 0x69, 0xBB, 0xC6, 0x83, 0x36, + 0x0B, 0x25, 0xC0, 0xC3, 0xAE, 0xBD, 0xD0, 0x04, + 0xCA, 0x9A, 0x17, 0x59, 0xF8, 0x22, 0x6F, 0xCC + }, + { + 0x08, 0x22, 0x2A, 0x41, 0x7E, 0x91, 0xE8, 0x75, + 0x84, 0x55, 0x2A, 0x3B, 0xC2, 0xB2, 0xF2, 0x13, + 0xC0, 0xBC, 0xAB, 0xAF, 0xDB, 0xF2, 0x62, 0x18, + 0x1A, 0x22, 0xEA, 0x47, 0x2F, 0x3A, 0xF5, 0xBA + }, + { + 0x7E, 0xDA, 0x7B, 0x44, 0x19, 0xC6, 0x3B, 0x4E, + 0x7B, 0x51, 0x10, 0x61, 0x46, 0xE8, 0x39, 0x19, + 0xED, 0x7F, 0x06, 0xFD, 0xB4, 0x23, 0xCD, 0xEC, + 0xE4, 0x5F, 0x6C, 0x29, 0xA4, 0x9A, 0x4D, 0x0B + }, + { + 0x13, 0x72, 0x72, 0xD4, 0x8E, 0x23, 0x03, 0x6D, + 0x0C, 0x3D, 0x41, 0x8B, 0xE2, 0x36, 0x7E, 0x3B, + 0xB7, 0xE4, 0x4B, 0x0D, 0xE4, 0xF2, 0xC9, 0x2F, + 0xF8, 0x61, 0x55, 0xE8, 0x7B, 0x8E, 0xFB, 0x6D + }, + { + 0xA8, 0x9E, 0x4A, 0x07, 0x8F, 0x36, 0x4E, 0xC2, + 0x78, 0x4D, 0x54, 0xA0, 0x5A, 0x14, 0x21, 0x22, + 0xE5, 0xC4, 0x15, 0x16, 0x0E, 0xE5, 0xAF, 0x75, + 0xF0, 0x09, 0x14, 0xF8, 0x85, 0xF1, 0x10, 0xFC + }, + { + 0x65, 0x92, 0x8B, 0x5B, 0xF5, 0x75, 0x5B, 0x44, + 0x23, 0x08, 0xE5, 0xCF, 0xBE, 0x04, 0x21, 0x14, + 0x9C, 0xBA, 0x9D, 0xFC, 0xF6, 0x10, 0xD2, 0xC8, + 0x41, 0x03, 0xBB, 0x69, 0x5E, 0x7A, 0x40, 0xE5 + }, + { + 0x16, 0xA3, 0xDB, 0xCF, 0x87, 0x2D, 0x83, 0xF4, + 0xA3, 0x74, 0xDC, 0x03, 0x30, 0xF6, 0x19, 0xAD, + 0xD9, 0x36, 0xF0, 0x9C, 0xDE, 0x6E, 0xD0, 0x3F, + 0xB8, 0xB2, 0x0E, 0x1C, 0x4E, 0x76, 0xE6, 0x26 + }, + { + 0x89, 0xAF, 0x7E, 0x0E, 0xEB, 0xF7, 0x14, 0x20, + 0xC6, 0x29, 0xA2, 0xB1, 0x46, 0xB4, 0x1C, 0x0D, + 0xE2, 0xB6, 0xFB, 0x77, 0x55, 0x37, 0xA3, 0x27, + 0xC5, 0x4F, 0x00, 0x1B, 0x55, 0x3E, 0xA0, 0x81 + }, + { + 0xDD, 0xFB, 0xE6, 0x74, 0xCC, 0x76, 0x95, 0xE4, + 0x5A, 0xF1, 0x8F, 0x10, 0x90, 0x90, 0x33, 0x2C, + 0x0A, 0xD6, 0x96, 0xB7, 0x40, 0x98, 0x1F, 0x21, + 0xE4, 0xD1, 0x52, 0x3B, 0x4E, 0xE9, 0x9D, 0x70 + }, + { + 0x0E, 0xE4, 0x7F, 0xF7, 0xAD, 0x3F, 0x8B, 0xDA, + 0x1F, 0xA9, 0x3D, 0xA4, 0xAD, 0x00, 0x62, 0x87, + 0xF2, 0x9D, 0x91, 0x74, 0x46, 0xC1, 0x4C, 0xBB, + 0xB1, 0xBF, 0x4B, 0xF8, 0x4C, 0x81, 0x02, 0x88 + }, + { + 0x4F, 0x0B, 0xCE, 0xE9, 0x35, 0x87, 0x06, 0x9A, + 0x38, 0xEA, 0xBA, 0x76, 0x89, 0xAF, 0x93, 0x4E, + 0x37, 0x55, 0xA1, 0x17, 0xF7, 0xCC, 0x4E, 0xAC, + 0xC1, 0xDF, 0xF6, 0x05, 0xA7, 0xC3, 0xDC, 0xE1 + }, + { + 0x7A, 0xCE, 0x32, 0x69, 0xE6, 0x2D, 0x94, 0x1F, + 0xEA, 0xE4, 0xD0, 0xEA, 0x1A, 0x46, 0x03, 0x8F, + 0x7C, 0xE0, 0x35, 0xFF, 0xB1, 0x4C, 0xDC, 0x63, + 0x44, 0x70, 0x4C, 0x3E, 0x43, 0xA4, 0x34, 0xA1 + }, + { + 0x0F, 0xAC, 0x8D, 0x56, 0x93, 0xF6, 0x93, 0xAA, + 0x91, 0x81, 0xA1, 0x61, 0xB4, 0x90, 0xFF, 0xDF, + 0x39, 0xBE, 0x85, 0xB1, 0x8D, 0x8B, 0xF3, 0x82, + 0x0A, 0x9D, 0x2F, 0x57, 0x6A, 0x53, 0x65, 0xDC + }, + { + 0x0A, 0xFE, 0xEA, 0x99, 0x9A, 0x97, 0x3B, 0xDB, + 0x56, 0xC2, 0xE6, 0x02, 0x99, 0xFD, 0x0F, 0x8F, + 0x22, 0xA7, 0x56, 0xD1, 0x1F, 0xED, 0x21, 0x80, + 0xCE, 0xB8, 0x76, 0x93, 0x86, 0x61, 0xE5, 0x20 + }, + { + 0xEF, 0x1F, 0x18, 0xA6, 0xBA, 0xEC, 0xF2, 0xAF, + 0x57, 0x4E, 0x49, 0x07, 0xD9, 0xE2, 0x1D, 0xC8, + 0x2C, 0x8C, 0x73, 0xE4, 0xFA, 0x66, 0xE4, 0x54, + 0x39, 0x12, 0x84, 0x9E, 0xC3, 0x73, 0xA2, 0x3D + }, + { + 0xBC, 0x24, 0xE1, 0x4E, 0xA7, 0x2C, 0xD4, 0xCC, + 0xCE, 0x76, 0xD2, 0x80, 0x92, 0x8D, 0x84, 0xDF, + 0x18, 0x58, 0xA5, 0xDE, 0xD7, 0x82, 0x03, 0x3A, + 0x6E, 0x62, 0xAF, 0x39, 0x1E, 0xC2, 0xA3, 0x5C + }, + { + 0xBB, 0x9E, 0x1C, 0xF1, 0x61, 0x21, 0x00, 0x26, + 0xE7, 0x1C, 0xE8, 0x64, 0x2F, 0x07, 0x92, 0x11, + 0x7A, 0x34, 0x09, 0xBA, 0xA2, 0x00, 0x84, 0xE0, + 0x27, 0xD6, 0x07, 0x70, 0x27, 0x5A, 0xAC, 0x58 + }, + { + 0x6B, 0xCC, 0x06, 0xC8, 0xA6, 0x13, 0xA3, 0x5A, + 0xFF, 0xF5, 0x7D, 0xF0, 0xC6, 0x45, 0x78, 0x17, + 0x9D, 0xE6, 0x93, 0x33, 0x81, 0x00, 0x35, 0x7A, + 0x2B, 0x74, 0xBF, 0xA4, 0x20, 0x4C, 0x9A, 0x63 + }, + { + 0x10, 0x46, 0x40, 0x87, 0x77, 0xB6, 0xFB, 0xAF, + 0x3E, 0x29, 0x59, 0x9E, 0x1E, 0xA4, 0xAB, 0x35, + 0x7E, 0x56, 0xCB, 0xCD, 0x87, 0x04, 0x74, 0x09, + 0x4A, 0x8D, 0x35, 0x5B, 0x25, 0x01, 0xAD, 0x3B + }, + { + 0xB4, 0xA2, 0xF0, 0x52, 0x93, 0x68, 0x4F, 0x33, + 0x0A, 0xEB, 0xE6, 0xE3, 0xC4, 0x44, 0xCA, 0x53, + 0xBC, 0x1B, 0xE2, 0x6B, 0xD5, 0x1D, 0x27, 0x18, + 0xCF, 0xAF, 0xCE, 0xC5, 0xD6, 0xD9, 0x31, 0xB3 + }, + { + 0x28, 0xC5, 0x14, 0xA2, 0x65, 0x03, 0xE9, 0xC5, + 0x86, 0x28, 0xB3, 0x91, 0xF3, 0x2C, 0x2B, 0xDA, + 0xFA, 0x0A, 0xC7, 0x47, 0x8D, 0x1C, 0xF8, 0x72, + 0x67, 0x97, 0x6D, 0x07, 0x10, 0xB6, 0x46, 0xA9 + }, + { + 0x97, 0x98, 0x99, 0xB7, 0x30, 0x74, 0x2D, 0x46, + 0xC7, 0x5E, 0x36, 0x5F, 0x5B, 0xB7, 0x67, 0x0D, + 0x41, 0x44, 0x48, 0x49, 0x7D, 0xC4, 0x42, 0x56, + 0x66, 0x4F, 0x69, 0xE9, 0x8C, 0xC1, 0x35, 0x6F + }, + { + 0x5A, 0x34, 0x28, 0x6E, 0x58, 0xC1, 0xDF, 0x13, + 0x5C, 0xB3, 0x3C, 0x00, 0xE3, 0xA2, 0xF3, 0x3E, + 0x86, 0xA8, 0x0B, 0xEA, 0x9B, 0x81, 0xC6, 0x56, + 0x4C, 0x7B, 0x5C, 0x33, 0xD5, 0xC3, 0x3A, 0x80 + }, + { + 0x6E, 0x63, 0x9A, 0x99, 0xE7, 0x2F, 0x2D, 0xA3, + 0xB8, 0xCD, 0x9D, 0xE4, 0x36, 0x79, 0x35, 0x4B, + 0x83, 0x4C, 0x5E, 0x68, 0xE8, 0x04, 0x1A, 0x05, + 0x26, 0xB0, 0xC8, 0x9D, 0xC0, 0xE0, 0x64, 0xCF + }, + { + 0xA7, 0x46, 0xB3, 0xAE, 0xE2, 0x84, 0xDD, 0x83, + 0xF9, 0x79, 0xFF, 0x11, 0x93, 0xFF, 0x86, 0x3D, + 0xBB, 0x5B, 0x62, 0x72, 0x7C, 0x44, 0xC9, 0x1C, + 0x24, 0x56, 0x19, 0x05, 0x89, 0xC9, 0x5E, 0x80 + }, + { + 0x1A, 0x5E, 0x54, 0x06, 0x76, 0xF3, 0x82, 0xFB, + 0xDD, 0x75, 0x03, 0x7C, 0xBC, 0xD3, 0xF1, 0x5F, + 0xB8, 0x95, 0x28, 0xE0, 0x71, 0x86, 0x87, 0x3C, + 0xE9, 0x1E, 0x8E, 0xBA, 0xED, 0xD9, 0xF6, 0x4B + }, + { + 0xD8, 0xDE, 0x6B, 0x3A, 0x6D, 0xE6, 0x28, 0x59, + 0x28, 0x9B, 0x2E, 0xE7, 0xB2, 0x38, 0x67, 0x4E, + 0x06, 0x0A, 0x11, 0xF4, 0xEE, 0x37, 0x3E, 0xF5, + 0x94, 0x82, 0x41, 0xF8, 0x6E, 0xDC, 0x7C, 0x96 + }, + { + 0x58, 0x36, 0x3F, 0x86, 0xD3, 0x80, 0xDB, 0x6F, + 0xA3, 0x54, 0x23, 0x73, 0x91, 0xE6, 0x48, 0x9A, + 0x81, 0x4B, 0x80, 0xA4, 0xDD, 0x19, 0x1D, 0x58, + 0x88, 0x8D, 0x8B, 0xED, 0xAC, 0x7A, 0x99, 0x71 + }, + { + 0x09, 0x18, 0x8C, 0x2E, 0x92, 0x40, 0x03, 0x2D, + 0xE6, 0x95, 0xCA, 0xEB, 0xDF, 0xC2, 0x68, 0xE5, + 0x62, 0x98, 0x8E, 0xB1, 0xEC, 0xFD, 0x07, 0xDE, + 0x1C, 0xB2, 0x2C, 0x58, 0xF1, 0x97, 0xA1, 0xBA + }, + { + 0x17, 0x94, 0xEC, 0x6B, 0x44, 0x91, 0x46, 0xA9, + 0xBE, 0xFD, 0xC2, 0xF9, 0x17, 0x22, 0x5B, 0x92, + 0x01, 0xAB, 0x1A, 0x86, 0xAD, 0x43, 0x29, 0x82, + 0xAE, 0x56, 0x67, 0xF4, 0x5D, 0x74, 0x9E, 0x53 + }, + { + 0xCC, 0x4D, 0x9C, 0xB6, 0xD2, 0x05, 0x24, 0x91, + 0x0C, 0x08, 0x1E, 0x3D, 0xD7, 0x7F, 0x20, 0xFD, + 0x3E, 0x51, 0x1A, 0xE3, 0x56, 0x83, 0x9C, 0x1B, + 0x08, 0xEE, 0xE8, 0xF1, 0xDC, 0x73, 0x1D, 0x56 + }, + { + 0x72, 0x37, 0x1F, 0x99, 0xF2, 0x78, 0x25, 0xFB, + 0x40, 0x70, 0xE5, 0x8F, 0x30, 0x37, 0x0B, 0x01, + 0xFE, 0x3F, 0xF6, 0x49, 0x4D, 0xD4, 0xA6, 0x60, + 0x5A, 0x49, 0x73, 0x30, 0xB6, 0x1D, 0x82, 0x9B + }, + { + 0xDE, 0x03, 0x6B, 0xAF, 0xF7, 0xA0, 0x8F, 0xEB, + 0x08, 0xBD, 0x44, 0xAE, 0x1A, 0xBB, 0xCB, 0xB0, + 0x18, 0xC9, 0x1F, 0x0F, 0x25, 0xF7, 0x47, 0xBC, + 0xE9, 0xE7, 0x6A, 0xBE, 0x29, 0x70, 0x84, 0x95 + }, + { + 0x51, 0xF2, 0x51, 0x87, 0x92, 0x82, 0xCF, 0x95, + 0xEB, 0x70, 0x8B, 0xB9, 0x39, 0xC5, 0x95, 0x5B, + 0xE5, 0x69, 0x94, 0x43, 0x4E, 0xE4, 0x0E, 0x9D, + 0xA7, 0xE6, 0xA4, 0x99, 0x46, 0x3F, 0x69, 0x76 + }, + { + 0xAD, 0x50, 0xDD, 0x00, 0x5D, 0x2E, 0x03, 0xDD, + 0xF4, 0x24, 0xE0, 0x80, 0x58, 0x7F, 0x1A, 0x8A, + 0x97, 0xCD, 0x0E, 0x0B, 0xB8, 0xB2, 0x0B, 0x19, + 0x25, 0xE7, 0xD8, 0xAF, 0xC1, 0x89, 0xC2, 0x39 + }, + { + 0xA9, 0x43, 0x26, 0x55, 0xE4, 0xB9, 0x92, 0x92, + 0xA9, 0x54, 0x46, 0x30, 0x58, 0xAC, 0x55, 0x09, + 0xD4, 0x3B, 0xBB, 0xFA, 0xAC, 0xCF, 0xDA, 0x03, + 0xD9, 0x1C, 0x2D, 0xAB, 0x82, 0xCF, 0xE6, 0xCC + }, + { + 0xF5, 0x07, 0xE1, 0xE1, 0xB6, 0x2F, 0x19, 0x82, + 0x51, 0x77, 0xBC, 0xAC, 0x28, 0x4F, 0x5A, 0x61, + 0x33, 0x12, 0x8D, 0x81, 0xE1, 0x70, 0x82, 0x5F, + 0x9E, 0xE4, 0x27, 0xF4, 0xAA, 0x80, 0x6A, 0x5D + }, + { + 0xC1, 0x61, 0x39, 0xDA, 0x5B, 0x45, 0xC0, 0x80, + 0x46, 0x4A, 0xE1, 0xF2, 0x75, 0x03, 0xD8, 0xF4, + 0x40, 0x55, 0x88, 0x0C, 0xA0, 0x36, 0xB0, 0x3A, + 0x97, 0xD2, 0x1C, 0x74, 0x2C, 0xF0, 0xA3, 0x1F + }, + { + 0x53, 0x52, 0xF3, 0x32, 0xB8, 0x01, 0x1E, 0x3F, + 0xC3, 0xB0, 0xF1, 0x67, 0x51, 0x54, 0x9D, 0x2E, + 0xBE, 0xB5, 0x99, 0x81, 0x54, 0xE5, 0xF1, 0xCB, + 0x3D, 0x99, 0x7E, 0x2C, 0xD3, 0x2E, 0x29, 0xAE + }, + { + 0x5B, 0x67, 0x84, 0xBE, 0x6F, 0x29, 0x9D, 0x14, + 0xB1, 0xBB, 0xED, 0x52, 0x46, 0xDA, 0x3D, 0xCF, + 0x43, 0xDC, 0x4F, 0x36, 0xE7, 0x38, 0x3F, 0x98, + 0xA2, 0x9B, 0x1D, 0x75, 0x0B, 0x00, 0xA0, 0x20 + }, + { + 0x55, 0xBB, 0x84, 0x7F, 0x01, 0xE6, 0x10, 0xCA, + 0x2F, 0x13, 0xA4, 0x11, 0x36, 0x8D, 0xCA, 0x87, + 0x0C, 0x5A, 0xBF, 0xD4, 0xDD, 0x18, 0x70, 0xEB, + 0x47, 0x4D, 0xD3, 0xD1, 0x08, 0xC3, 0x05, 0x8C + }, + { + 0x5E, 0x13, 0xAC, 0x62, 0xD0, 0x5D, 0x6E, 0x00, + 0x19, 0x75, 0x2A, 0xF6, 0x6D, 0x3F, 0x80, 0x31, + 0x1A, 0x10, 0x8E, 0x15, 0xD2, 0x43, 0x73, 0x1F, + 0xBE, 0x7F, 0x8D, 0xD8, 0x33, 0x39, 0x4D, 0x52 + }, + { + 0x82, 0x23, 0xC8, 0xF9, 0xE2, 0xD7, 0xB6, 0xD9, + 0x4B, 0xD1, 0x6F, 0x75, 0x75, 0xF8, 0x2B, 0x02, + 0x00, 0xCC, 0x04, 0x00, 0xE7, 0x13, 0x6F, 0xEF, + 0xAE, 0x18, 0xAF, 0xB6, 0x47, 0x40, 0xBE, 0x57 + }, + { + 0x31, 0x71, 0x66, 0xE8, 0x21, 0xE1, 0x72, 0x1A, + 0xAB, 0x98, 0xC4, 0x2E, 0x31, 0x09, 0xE9, 0x7F, + 0x7A, 0x1C, 0x64, 0x44, 0xE4, 0x9F, 0xE4, 0xC1, + 0xE9, 0xDF, 0x0B, 0x5D, 0x76, 0x33, 0xBF, 0x4C + }, + { + 0x8B, 0xA8, 0x72, 0x92, 0xBC, 0xD7, 0x1C, 0x74, + 0xB2, 0xF9, 0x36, 0x45, 0xBC, 0xA9, 0x19, 0x66, + 0x87, 0x70, 0xF2, 0x5D, 0x88, 0xAD, 0x59, 0x2F, + 0xF1, 0x06, 0xE8, 0x3C, 0xFC, 0x30, 0xC8, 0x44 + }, + { + 0xDC, 0xE9, 0xAF, 0x27, 0x1D, 0x52, 0x55, 0x86, + 0x55, 0xBC, 0x1C, 0x94, 0xF6, 0xF4, 0xAB, 0x9C, + 0x7E, 0x73, 0xC4, 0xDC, 0x4F, 0xA3, 0x14, 0xE8, + 0x7F, 0x49, 0xCA, 0x07, 0x89, 0x5E, 0xE2, 0x48 + }, + { + 0xEA, 0xD3, 0x3E, 0x13, 0x4D, 0x50, 0x4B, 0x67, + 0x73, 0x5E, 0x4F, 0x0C, 0xC3, 0xBA, 0x11, 0x2B, + 0xB9, 0xD6, 0xB9, 0x7E, 0xEB, 0xD3, 0x09, 0x1E, + 0x24, 0xAA, 0x4E, 0x34, 0x6E, 0xF1, 0xAF, 0x5B + }, + { + 0x99, 0x6F, 0x18, 0x45, 0xF5, 0x70, 0xF0, 0x65, + 0x2E, 0xBF, 0xF6, 0x87, 0x28, 0xA0, 0xE5, 0x77, + 0xAE, 0x13, 0x84, 0x4E, 0x43, 0xCA, 0xD1, 0x98, + 0x4B, 0x66, 0x40, 0x05, 0x31, 0xDA, 0x59, 0x42 + }, + { + 0x57, 0xE7, 0xCE, 0xDD, 0x61, 0xA3, 0x1F, 0xBC, + 0x26, 0xC9, 0xBB, 0xEB, 0xD0, 0xB2, 0xE2, 0x61, + 0xED, 0x83, 0xDB, 0x99, 0xD5, 0xB1, 0x94, 0x12, + 0x0E, 0x27, 0xD3, 0xFC, 0x75, 0xC9, 0x84, 0x7B + }, + { + 0x8F, 0x10, 0xC8, 0x0B, 0x59, 0x79, 0xA0, 0xC4, + 0xF9, 0xD0, 0x38, 0xAC, 0x3D, 0xA3, 0x91, 0xFC, + 0x67, 0xDC, 0x3A, 0x17, 0x5E, 0xC7, 0x5E, 0x7B, + 0x1F, 0x2F, 0x34, 0x27, 0xBC, 0xA8, 0xEB, 0x4D + }, + { + 0x40, 0xE4, 0xDA, 0xA1, 0xD7, 0xB2, 0x77, 0x3D, + 0x86, 0xB4, 0xE2, 0x81, 0xE2, 0xC3, 0x4F, 0x08, + 0x07, 0xE9, 0x40, 0x97, 0x05, 0xCC, 0x63, 0x17, + 0x53, 0x47, 0x26, 0xD3, 0xBB, 0x68, 0x64, 0x1A + }, + { + 0xF4, 0xD2, 0x60, 0x3F, 0xE5, 0xE2, 0x2D, 0x0B, + 0x28, 0x8B, 0x8C, 0x1D, 0xD5, 0x2D, 0xD8, 0x93, + 0xE5, 0xD4, 0x2B, 0x1E, 0x1C, 0x2C, 0x43, 0x28, + 0x29, 0x87, 0xFD, 0x83, 0x9D, 0x1C, 0x67, 0x72 + }, + { + 0x40, 0x03, 0x99, 0xCB, 0xC1, 0x51, 0xD0, 0x75, + 0x38, 0xF4, 0x46, 0xC1, 0xBD, 0xD8, 0x83, 0x46, + 0x8A, 0xE6, 0xB1, 0x34, 0x02, 0xFB, 0x77, 0x99, + 0x8D, 0x70, 0x48, 0x93, 0x90, 0x4E, 0x0C, 0xB2 + }, + { + 0xB2, 0x38, 0x3F, 0xC9, 0x0E, 0x78, 0x53, 0x56, + 0xFB, 0x80, 0xB4, 0x54, 0x05, 0x65, 0x08, 0xF1, + 0x6F, 0x55, 0x7B, 0x24, 0x63, 0x22, 0x6C, 0x44, + 0xDE, 0xC7, 0x71, 0xE1, 0x5B, 0x32, 0xCD, 0x31 + }, + { + 0xB7, 0xC8, 0xE1, 0x01, 0x90, 0x14, 0xB3, 0x56, + 0x89, 0x11, 0x6B, 0x75, 0xCF, 0x71, 0xF9, 0xCF, + 0xA3, 0x6B, 0x2B, 0x93, 0x10, 0x51, 0x51, 0x1E, + 0x7A, 0x1C, 0x3E, 0x24, 0x76, 0x73, 0xB1, 0x2B + }, + { + 0xEB, 0x87, 0x7E, 0x27, 0x21, 0x6A, 0xF0, 0x8E, + 0x97, 0x95, 0x4C, 0xA2, 0x28, 0x64, 0xC1, 0x35, + 0x58, 0xED, 0xB7, 0x73, 0xD8, 0x26, 0x54, 0x24, + 0x43, 0x45, 0x23, 0x92, 0xA6, 0x27, 0x1B, 0x7F + }, + { + 0x47, 0x07, 0x39, 0xDC, 0x3D, 0x3A, 0xF2, 0x4A, + 0x56, 0x61, 0xFC, 0x1B, 0x67, 0x73, 0xAD, 0xA5, + 0xD7, 0x51, 0x78, 0x07, 0x2E, 0xA2, 0x24, 0x8B, + 0x00, 0xE6, 0x30, 0xD3, 0x27, 0xC9, 0x25, 0x8A + }, + { + 0x08, 0xD0, 0xF7, 0xE8, 0x3E, 0x57, 0xCE, 0x06, + 0xDE, 0x14, 0x72, 0xEA, 0x76, 0xAD, 0x46, 0x4E, + 0x2E, 0x9B, 0xFF, 0x5F, 0x3E, 0xF8, 0xAC, 0x21, + 0x6E, 0xB5, 0x51, 0x1C, 0x8D, 0xFA, 0x4E, 0x13 + }, + { + 0x10, 0xD3, 0x35, 0x2D, 0xF3, 0x7C, 0xAF, 0xE3, + 0xF2, 0xF2, 0x37, 0x8D, 0x7D, 0xAF, 0xF8, 0x8B, + 0xE6, 0x7D, 0xD4, 0xB5, 0x2E, 0xF7, 0xED, 0x46, + 0xE6, 0x93, 0x17, 0x6F, 0x00, 0xF1, 0xF9, 0xB2 + }, + { + 0xC6, 0xE4, 0x39, 0x00, 0x32, 0x97, 0xCD, 0x32, + 0xE2, 0x04, 0x81, 0x45, 0xED, 0xBD, 0xF6, 0xCA, + 0xD8, 0x13, 0x37, 0x79, 0xCA, 0x0E, 0xC0, 0xAA, + 0x11, 0xCB, 0xA9, 0x04, 0xBD, 0x75, 0x9B, 0x2D + }, + { + 0x6C, 0xAD, 0xBA, 0x13, 0x54, 0x49, 0x14, 0x0A, + 0x8D, 0x8C, 0xEA, 0x15, 0x8D, 0x57, 0x44, 0x4F, + 0xC0, 0xC1, 0x58, 0xA6, 0xEF, 0xE5, 0x8B, 0xD3, + 0x5D, 0x55, 0x3D, 0x8B, 0x74, 0x9E, 0x42, 0xA1 + }, + { + 0x2D, 0xAC, 0xA8, 0x7F, 0xDD, 0x4C, 0xA1, 0xA9, + 0x66, 0x47, 0x68, 0x06, 0x02, 0x0F, 0x15, 0xBC, + 0x4B, 0x05, 0x57, 0xCF, 0xE4, 0xB9, 0x7A, 0xF9, + 0x70, 0x31, 0x8A, 0x1E, 0x15, 0xB7, 0x34, 0x97 + }, + { + 0xF6, 0x0E, 0xDC, 0x25, 0x54, 0x58, 0x0C, 0x7A, + 0xB8, 0xCB, 0x32, 0xFC, 0x42, 0x5D, 0xD8, 0x3B, + 0x02, 0xA7, 0xD3, 0xA7, 0xF3, 0xFC, 0xB4, 0xCD, + 0x76, 0x47, 0xEE, 0xBE, 0x1F, 0x47, 0x8F, 0xDE + }, + { + 0x7C, 0x35, 0x52, 0xFE, 0x8A, 0x63, 0x62, 0x6F, + 0x85, 0x55, 0x75, 0xED, 0x32, 0xDF, 0xC3, 0x21, + 0xA1, 0x2D, 0x7C, 0xBC, 0x39, 0x4B, 0xFA, 0x60, + 0xD5, 0xF8, 0x0A, 0xF4, 0x1A, 0xFC, 0x42, 0x1B + }, + { + 0xAF, 0x00, 0xF8, 0x76, 0xF4, 0xC8, 0xDC, 0x2B, + 0xFD, 0x51, 0xE4, 0x4F, 0x06, 0xDD, 0x49, 0xF9, + 0x84, 0x06, 0x53, 0x7D, 0x31, 0x90, 0xDA, 0x63, + 0x1D, 0xFB, 0x73, 0x6B, 0x65, 0x19, 0xAD, 0x7D + }, + { + 0x73, 0x92, 0x45, 0x2B, 0x23, 0x34, 0x75, 0x28, + 0x2D, 0x17, 0xB3, 0xC1, 0xFE, 0x92, 0x8E, 0xC4, + 0xFF, 0xB3, 0xC5, 0x15, 0xDF, 0x0B, 0xA6, 0xCE, + 0xD1, 0x3D, 0x8D, 0x4F, 0xF3, 0xF9, 0x78, 0x14 + }, + { + 0xC0, 0xBF, 0x83, 0x71, 0x6A, 0xD7, 0x8D, 0xBD, + 0x40, 0x1B, 0x9C, 0x44, 0x67, 0x57, 0xA0, 0x1D, + 0xDD, 0xCA, 0x33, 0x06, 0xE0, 0x7A, 0x18, 0xBE, + 0xB1, 0xA5, 0xEF, 0x94, 0x7C, 0xC7, 0x3C, 0xFB + }, + { + 0xEE, 0x7B, 0x61, 0x82, 0xF5, 0x81, 0xBD, 0x45, + 0x73, 0x62, 0x5C, 0x09, 0xB4, 0x98, 0x82, 0x92, + 0x91, 0x57, 0x29, 0xE3, 0xED, 0xAD, 0x20, 0xE4, + 0xD9, 0xAD, 0x3A, 0x46, 0xDB, 0xFA, 0x2C, 0x93 + }, + { + 0x92, 0xB9, 0x84, 0x4C, 0x6A, 0x50, 0x3B, 0x75, + 0xF1, 0x1F, 0x3D, 0xE1, 0xD2, 0xA3, 0x6C, 0x47, + 0x03, 0xAF, 0xC8, 0xA6, 0xDC, 0x04, 0xA0, 0x75, + 0x86, 0xD0, 0xB8, 0x10, 0x01, 0x5E, 0xDB, 0x74 + }, + { + 0xC7, 0x40, 0x3F, 0x7F, 0xB5, 0xFC, 0xCC, 0x67, + 0x1E, 0x85, 0x5B, 0x2A, 0xF0, 0x34, 0xA1, 0x3C, + 0x48, 0x1C, 0x12, 0xBF, 0xCB, 0x2C, 0x68, 0x45, + 0xF3, 0xA2, 0xF2, 0xC6, 0xF5, 0x71, 0x1A, 0x97 + }, + { + 0x21, 0xB0, 0x9F, 0x7C, 0xC0, 0x2F, 0x3E, 0x43, + 0x57, 0x82, 0xB9, 0xA0, 0x0F, 0xE6, 0x25, 0x3C, + 0x1C, 0x2F, 0xA1, 0x17, 0xF5, 0xA1, 0xD9, 0xC3, + 0x80, 0xDA, 0x47, 0xD7, 0x30, 0xF7, 0x6B, 0xC4 + }, + { + 0x36, 0x6F, 0x93, 0x9B, 0xD7, 0xA7, 0x21, 0xD8, + 0xF0, 0xC4, 0x77, 0x98, 0xDA, 0xF1, 0x3B, 0x68, + 0xD0, 0xB6, 0xC1, 0xD5, 0x18, 0xB4, 0x10, 0x34, + 0x83, 0x4C, 0x74, 0x1C, 0x65, 0x09, 0x83, 0x18 + }, + { + 0xB9, 0x54, 0xCD, 0x9D, 0x4A, 0x21, 0x25, 0x33, + 0x86, 0x88, 0x32, 0xCF, 0x08, 0x0D, 0x76, 0x9E, + 0xA4, 0x1C, 0x48, 0xD1, 0x45, 0x95, 0x5F, 0xD4, + 0x37, 0xA0, 0x9D, 0xBA, 0x4D, 0xC2, 0x61, 0x8C + }, + { + 0x06, 0x3F, 0x41, 0xB6, 0x4D, 0x38, 0xE7, 0x4F, + 0x2B, 0x29, 0x43, 0x3F, 0x13, 0x7E, 0xD7, 0xD0, + 0xFA, 0x5B, 0xE2, 0xCE, 0x7D, 0x3D, 0x97, 0x5B, + 0x0E, 0xC7, 0xF0, 0xE6, 0x10, 0x2E, 0x2C, 0x72 + }, + { + 0x31, 0xF4, 0x60, 0x91, 0x2E, 0x2C, 0xD6, 0x78, + 0x71, 0x4A, 0xE5, 0x51, 0xE6, 0x60, 0x33, 0xE6, + 0x3B, 0x41, 0xF9, 0x45, 0x80, 0x70, 0x39, 0x8E, + 0xF2, 0x50, 0x14, 0xED, 0x6E, 0xFC, 0x9D, 0xBB + }, + { + 0xAA, 0x62, 0x78, 0x58, 0x51, 0xBF, 0x45, 0x24, + 0x53, 0x68, 0xA2, 0x0E, 0x0E, 0xB8, 0xCA, 0xFF, + 0x9E, 0x96, 0xF2, 0xA0, 0x97, 0x62, 0xEC, 0x9F, + 0xDE, 0x9B, 0x98, 0xD8, 0x5A, 0x20, 0xEB, 0x8E + }, + { + 0xEE, 0xA8, 0xDA, 0x11, 0xE4, 0xAC, 0x98, 0xF4, + 0x0C, 0xAD, 0xE1, 0x77, 0x19, 0x9B, 0xDF, 0xB4, + 0xE0, 0xAF, 0x06, 0xC2, 0x90, 0x4F, 0xA1, 0x93, + 0x01, 0xE5, 0x40, 0x63, 0x48, 0x1E, 0xE0, 0x79 + }, + { + 0x7B, 0x5B, 0x98, 0xDC, 0xE1, 0x3C, 0x3C, 0xA8, + 0x8C, 0xAA, 0x09, 0x79, 0xFB, 0xF8, 0xEE, 0xDD, + 0xFD, 0xB1, 0xCB, 0xC6, 0x2A, 0x32, 0x67, 0xB4, + 0x4B, 0xCA, 0xF4, 0x0A, 0x2C, 0x4A, 0x5C, 0x28 + }, + { + 0xC9, 0xFE, 0x2E, 0xC2, 0xA8, 0x92, 0x86, 0x5A, + 0x4D, 0x54, 0x34, 0xF9, 0xFD, 0x73, 0xC8, 0xE0, + 0xA1, 0xB4, 0xC5, 0x76, 0xF2, 0xB7, 0xD5, 0xE3, + 0x28, 0xE0, 0xFC, 0x78, 0xDA, 0xDC, 0x89, 0xF8 + }, + { + 0x47, 0x09, 0xC5, 0x84, 0x70, 0x81, 0x19, 0x37, + 0x5B, 0x27, 0xB4, 0x61, 0x70, 0x3A, 0x8E, 0xE2, + 0x73, 0xA3, 0xF7, 0xF7, 0x14, 0x0F, 0x03, 0x1F, + 0xE0, 0x0E, 0xC6, 0x0C, 0xEF, 0x77, 0x9E, 0x13 + }, + { + 0x40, 0x0C, 0x33, 0x08, 0xD9, 0x5A, 0xD3, 0x52, + 0xFE, 0xD0, 0x25, 0x4A, 0x82, 0xED, 0x83, 0x08, + 0x92, 0x0B, 0x83, 0x72, 0xEB, 0x0B, 0xCF, 0x3E, + 0x73, 0x56, 0x14, 0x78, 0x21, 0xE2, 0x90, 0x30 + }, + { + 0xB4, 0xCB, 0xC5, 0xD1, 0xB8, 0x09, 0x11, 0x01, + 0x67, 0xC0, 0x35, 0x22, 0xE6, 0x0D, 0x4E, 0xBD, + 0x76, 0x9F, 0x69, 0x0D, 0xC9, 0x37, 0x25, 0xBF, + 0x34, 0x85, 0xCB, 0x63, 0xC1, 0x07, 0x04, 0xCF + }, + { + 0xEF, 0xAE, 0x0C, 0xCA, 0x29, 0x32, 0x9C, 0xD7, + 0xB7, 0xFE, 0x22, 0x40, 0x8B, 0xFA, 0x9D, 0x74, + 0xB2, 0x7D, 0xDE, 0x9D, 0x6B, 0xA2, 0xEB, 0x24, + 0xA3, 0xD4, 0xB5, 0x58, 0xE1, 0xD0, 0x67, 0x12 + }, + { + 0xC0, 0x77, 0xC1, 0x37, 0x42, 0x05, 0x8C, 0xFE, + 0x00, 0xA5, 0x26, 0x5C, 0x4E, 0xC8, 0x6B, 0x00, + 0xEE, 0x34, 0xD2, 0xA4, 0x8C, 0xBE, 0x95, 0xA0, + 0xB1, 0x93, 0x5F, 0xBC, 0xB7, 0x69, 0x1F, 0x6F + }, + { + 0x38, 0x25, 0x7D, 0x79, 0x08, 0x29, 0x93, 0xFE, + 0x72, 0x2C, 0x3F, 0x11, 0x68, 0xBB, 0x04, 0x74, + 0x9A, 0xB6, 0xFC, 0x79, 0xE3, 0xD1, 0x36, 0xE6, + 0x40, 0xA1, 0x1B, 0x61, 0xB7, 0x54, 0x81, 0x2A + }, + { + 0xE8, 0x64, 0x57, 0x30, 0x46, 0xF2, 0x4E, 0xBF, + 0xB2, 0x33, 0x7E, 0x2E, 0x93, 0x5C, 0x32, 0x3B, + 0x71, 0x01, 0x10, 0xD5, 0x5E, 0xA9, 0xB8, 0x14, + 0xE3, 0x8A, 0xEB, 0x84, 0x67, 0xD7, 0x03, 0x02 + }, + { + 0xC6, 0xFA, 0x94, 0x19, 0x0A, 0x77, 0x6F, 0xBC, + 0x12, 0xF5, 0x2F, 0xE2, 0x8A, 0xB7, 0x24, 0x6A, + 0xF5, 0xB6, 0xB6, 0x1B, 0xA8, 0x23, 0x9E, 0xEB, + 0x00, 0xF3, 0xA6, 0xEE, 0x2A, 0x7D, 0x1D, 0x7F + }, + { + 0x81, 0x08, 0x73, 0xFB, 0x7F, 0x89, 0x62, 0xD7, + 0xB5, 0x4D, 0x16, 0x13, 0xA6, 0xE5, 0x0A, 0xD5, + 0x86, 0x77, 0x3E, 0xAC, 0xCA, 0x65, 0x74, 0x82, + 0x82, 0x9E, 0xC3, 0x4C, 0x0D, 0x42, 0x13, 0x45 + }, + { + 0x98, 0x75, 0x6A, 0x29, 0x10, 0x69, 0x58, 0x32, + 0xA5, 0x86, 0xF8, 0x04, 0x14, 0x35, 0x57, 0x03, + 0x07, 0xC7, 0x31, 0x70, 0x73, 0x5A, 0x38, 0xCA, + 0x5F, 0x42, 0x4B, 0xE9, 0xB9, 0x34, 0x24, 0x3A + }, + { + 0x10, 0xD0, 0x3C, 0x18, 0x28, 0x23, 0x79, 0x10, + 0xA8, 0xE1, 0x5E, 0xAB, 0x69, 0x87, 0xD0, 0xDE, + 0xA5, 0xBC, 0xD3, 0xC7, 0xD7, 0x52, 0xAF, 0x6A, + 0x2B, 0x29, 0x4F, 0xD2, 0xD1, 0xF2, 0xE8, 0xAB + }, + { + 0x9C, 0xDD, 0x84, 0xED, 0x2A, 0xCC, 0x66, 0x92, + 0xB4, 0x80, 0xCA, 0xDD, 0x19, 0xBB, 0x80, 0x2E, + 0x2B, 0x8F, 0xD5, 0x8A, 0x94, 0x62, 0xA7, 0xFE, + 0xBC, 0x37, 0x15, 0xA6, 0xBC, 0xDB, 0x62, 0x44 + }, + { + 0x84, 0x50, 0xAA, 0x78, 0x16, 0x2A, 0xEA, 0x9D, + 0xE4, 0x98, 0xA8, 0xDE, 0x6C, 0xCA, 0x3E, 0xDE, + 0xF4, 0x2D, 0x97, 0x86, 0x11, 0x04, 0x1F, 0x9C, + 0x41, 0x99, 0xB6, 0xFF, 0xE4, 0x51, 0x8B, 0x1D + }, + { + 0xFE, 0x21, 0x75, 0x5E, 0x9B, 0x89, 0x1C, 0x76, + 0xAA, 0xB4, 0x98, 0x22, 0x80, 0x1C, 0x0D, 0xC1, + 0x6C, 0xC5, 0x68, 0x23, 0x62, 0x8C, 0xF5, 0x22, + 0x9C, 0xAD, 0xB6, 0xE4, 0x37, 0xCB, 0x1F, 0x1E + }, + { + 0x65, 0x1C, 0x54, 0x9C, 0x12, 0x7A, 0x15, 0x52, + 0xFE, 0x4A, 0xA1, 0x8D, 0x77, 0x0C, 0xC8, 0x69, + 0xC5, 0x7F, 0x7B, 0x63, 0xE5, 0xD7, 0x81, 0x1A, + 0xAE, 0x2B, 0x90, 0x2F, 0xB1, 0x46, 0x73, 0xED + }, + { + 0x27, 0xDF, 0x5B, 0xB6, 0x2D, 0x17, 0x93, 0x0B, + 0x35, 0x87, 0x39, 0x78, 0x9C, 0xB6, 0xFC, 0x6C, + 0x84, 0xFD, 0xFA, 0x92, 0x3A, 0x09, 0x4E, 0x00, + 0x30, 0xC4, 0xB5, 0x3F, 0x1E, 0xCB, 0x2A, 0xB2 + }, + { + 0xCC, 0x9A, 0x09, 0xC5, 0x1E, 0x84, 0xE2, 0x2E, + 0x72, 0x15, 0xEB, 0x3D, 0xAE, 0xDE, 0x96, 0xE8, + 0xBB, 0xA0, 0xCA, 0x06, 0x6A, 0x0A, 0xA5, 0x51, + 0x5E, 0xED, 0xD8, 0x98, 0x8A, 0x03, 0xEC, 0xF5 + }, + { + 0x83, 0xE6, 0x19, 0x29, 0x76, 0xF6, 0xA9, 0x90, + 0x1A, 0xE6, 0x13, 0x2B, 0xDF, 0x7B, 0xEA, 0xFC, + 0xD7, 0xC0, 0xA1, 0x23, 0x4C, 0xFC, 0xC9, 0xEE, + 0xEA, 0x28, 0x17, 0xB9, 0xF0, 0xAC, 0x7B, 0xC3 + }, + { + 0x46, 0x25, 0x56, 0xE0, 0xCD, 0x3C, 0x32, 0xD9, + 0x06, 0xDE, 0x00, 0x70, 0xC0, 0xFE, 0xCD, 0x5E, + 0x79, 0x47, 0x01, 0x11, 0xC5, 0x3A, 0x28, 0x9D, + 0x9C, 0x82, 0x9C, 0xF0, 0xC5, 0x5F, 0x3F, 0xDD + }, + { + 0x4E, 0x7E, 0x92, 0xCA, 0x89, 0x9D, 0x4F, 0x7B, + 0x55, 0xCC, 0xA2, 0xFA, 0x28, 0x9E, 0xED, 0x60, + 0x98, 0xAD, 0xAF, 0xE2, 0xBD, 0xDF, 0x80, 0x15, + 0x2C, 0xEA, 0xE7, 0xD7, 0x0A, 0x69, 0xF1, 0x5E + }, + { + 0xEE, 0x12, 0x27, 0x0B, 0x78, 0xB1, 0x06, 0x45, + 0xC4, 0xD2, 0x29, 0x85, 0xAB, 0x2F, 0x30, 0x80, + 0x03, 0x06, 0xA0, 0x12, 0xA6, 0x53, 0xD8, 0x9D, + 0x08, 0xEC, 0xFB, 0x18, 0x25, 0x06, 0x3E, 0x1E + }, + { + 0xBB, 0xA9, 0xEF, 0xC6, 0x06, 0x64, 0x13, 0x90, + 0x38, 0x52, 0x97, 0xAD, 0xFD, 0x15, 0xB8, 0xF5, + 0x61, 0x98, 0xD6, 0x51, 0x88, 0x65, 0xE0, 0x51, + 0x58, 0x58, 0x49, 0xE6, 0x29, 0x76, 0x6F, 0x90 + }, + { + 0x36, 0x3E, 0x1A, 0x48, 0x8F, 0x03, 0x9B, 0xBB, + 0xFB, 0xD2, 0xF0, 0x94, 0xAE, 0xE0, 0xC0, 0x07, + 0xDB, 0xDE, 0xF5, 0xAF, 0xE8, 0xA5, 0xD5, 0x89, + 0x67, 0xCD, 0x78, 0xC6, 0xC8, 0x14, 0x0B, 0x01 + }, + { + 0xEC, 0xFE, 0x7D, 0x8E, 0xCA, 0x2E, 0x71, 0xF4, + 0xD3, 0xA8, 0x69, 0x71, 0x85, 0xE7, 0xDD, 0x68, + 0x2D, 0x94, 0xA0, 0x93, 0x4A, 0x37, 0x03, 0xAC, + 0x56, 0xE6, 0x27, 0x57, 0x0B, 0x0C, 0x4F, 0xB4 + }, + { + 0xF9, 0x3E, 0x27, 0x38, 0x25, 0xEF, 0x30, 0x2D, + 0x22, 0x6E, 0xFF, 0x72, 0x1E, 0x8E, 0xCF, 0x1E, + 0x78, 0x16, 0x65, 0xF0, 0x06, 0xE9, 0xD3, 0x6F, + 0x6B, 0x39, 0xB7, 0x39, 0x3B, 0xCE, 0xAA, 0x62 + }, + { + 0xB3, 0xE6, 0x5F, 0x53, 0xD3, 0xC9, 0xF6, 0xDA, + 0x2F, 0xC3, 0x55, 0xC4, 0x8E, 0xB5, 0x6C, 0x9D, + 0x4F, 0xFF, 0x14, 0xE7, 0xF7, 0xF5, 0x69, 0x4D, + 0xF2, 0x64, 0x81, 0xA6, 0xE0, 0x5A, 0x3F, 0x66 + }, + { + 0x90, 0x06, 0xB1, 0xAC, 0xED, 0xB7, 0x4D, 0xD5, + 0x8E, 0x1E, 0xE8, 0x64, 0x79, 0x81, 0x6A, 0xE9, + 0x4F, 0xB8, 0x54, 0x32, 0xD5, 0x25, 0x63, 0xFC, + 0x42, 0x34, 0x77, 0xD4, 0x69, 0xC6, 0x39, 0x7B + }, + { + 0x52, 0xAD, 0x14, 0x76, 0x5C, 0xC8, 0x06, 0xAA, + 0xC5, 0x6B, 0x57, 0x3D, 0x82, 0x21, 0x8D, 0x61, + 0x0A, 0x2A, 0x08, 0x25, 0xA0, 0x0E, 0x4D, 0x59, + 0x50, 0x0C, 0xC5, 0x47, 0x53, 0x4D, 0xD3, 0x44 + }, + { + 0x8A, 0xC5, 0x6F, 0x62, 0x89, 0x73, 0x4B, 0x1A, + 0x26, 0x54, 0xF1, 0x72, 0x60, 0x08, 0x97, 0x50, + 0x37, 0x00, 0xBD, 0x52, 0x0B, 0x11, 0x6E, 0xA8, + 0xED, 0xBD, 0x4E, 0xA2, 0xE5, 0xBC, 0xFA, 0xA5 + }, + { + 0x39, 0xA6, 0x9E, 0x40, 0x71, 0xC0, 0x7D, 0x6B, + 0x48, 0x86, 0xB4, 0x6D, 0xF5, 0x6B, 0x4D, 0x9C, + 0x33, 0x57, 0x94, 0x81, 0x51, 0x93, 0x16, 0xDE, + 0x32, 0xEF, 0xC0, 0x8D, 0x58, 0x8E, 0x27, 0x97 + }, + { + 0x3D, 0x45, 0x78, 0x5D, 0xA1, 0x06, 0xD4, 0x53, + 0x01, 0x4A, 0x42, 0x62, 0xF2, 0x97, 0x2F, 0xE8, + 0x45, 0xB3, 0x9C, 0xCA, 0x3B, 0xAD, 0xB6, 0x0A, + 0xE3, 0xAF, 0xDF, 0xCA, 0x71, 0x34, 0x7A, 0x10 + }, + { + 0xBE, 0x15, 0xD9, 0xB8, 0xCD, 0xA6, 0xD6, 0xE3, + 0xFA, 0xFF, 0xA5, 0x11, 0xE9, 0xBC, 0x04, 0x9A, + 0x51, 0x52, 0xF6, 0x7F, 0x89, 0x9D, 0xEA, 0xB1, + 0xFA, 0x50, 0x1C, 0x8F, 0x08, 0x92, 0x7D, 0x23 + }, + { + 0x54, 0xE4, 0x06, 0xA2, 0x8F, 0x07, 0xFE, 0xE6, + 0x0D, 0x81, 0x16, 0x5E, 0x4B, 0xDE, 0x4E, 0xF1, + 0xEC, 0x62, 0xFD, 0x89, 0xB6, 0x00, 0xFB, 0xD1, + 0x96, 0xEF, 0x93, 0xEA, 0x69, 0xCF, 0xA8, 0x91 + }, + { + 0x8F, 0x44, 0x58, 0x51, 0xC3, 0x4B, 0x0D, 0x88, + 0xC8, 0x05, 0x21, 0x75, 0xDF, 0x35, 0xFB, 0x5D, + 0x3B, 0x42, 0x43, 0xB3, 0x97, 0x85, 0xCD, 0x4C, + 0x19, 0x1F, 0x52, 0xA8, 0xD2, 0xAE, 0x62, 0xB5 + }, + { + 0x27, 0xAB, 0xC0, 0x97, 0xEA, 0xB9, 0x9B, 0xFE, + 0xA4, 0xF3, 0xAD, 0x29, 0x8E, 0x7E, 0x91, 0x82, + 0x38, 0x4C, 0x93, 0x45, 0xE3, 0x41, 0x48, 0x57, + 0xAA, 0x50, 0x70, 0x88, 0x67, 0xF4, 0xB0, 0x5F + }, + { + 0xDA, 0xB7, 0x68, 0x2D, 0x30, 0xFE, 0x8D, 0xCC, + 0x91, 0x47, 0xA5, 0x7B, 0xE5, 0xC6, 0xC6, 0x25, + 0x44, 0x50, 0x4A, 0x90, 0xD0, 0xD1, 0x9C, 0x40, + 0x0B, 0xB6, 0xAA, 0x0E, 0x74, 0x02, 0x56, 0xC8 + }, + { + 0xE0, 0x59, 0xAF, 0xAC, 0xC4, 0xF7, 0x4F, 0xC9, + 0x36, 0x66, 0x11, 0xBD, 0x6D, 0x2E, 0x12, 0xDA, + 0x47, 0x65, 0x12, 0x3D, 0x62, 0xF7, 0x47, 0xB0, + 0x63, 0xC7, 0x64, 0x9F, 0xD2, 0xD6, 0x95, 0x3D + }, + { + 0xF1, 0x52, 0x8B, 0x42, 0x14, 0x1C, 0x8E, 0xA3, + 0x76, 0x34, 0x9E, 0x74, 0x62, 0xB9, 0x57, 0xE7, + 0x94, 0x8F, 0xD4, 0x18, 0x56, 0xAA, 0xDB, 0x70, + 0xA5, 0xEA, 0xEC, 0x2B, 0xD0, 0x59, 0xA3, 0xA5 + }, + { + 0xD7, 0x25, 0x8A, 0x4D, 0xF8, 0x3D, 0xFA, 0x42, + 0x62, 0xA6, 0x61, 0x92, 0xEE, 0xFE, 0xF7, 0xA0, + 0xA6, 0x79, 0xDB, 0xC4, 0x6C, 0xDE, 0x40, 0xD4, + 0x87, 0xE9, 0x1A, 0x95, 0x65, 0x16, 0x0C, 0xE2 + }, + { + 0x0B, 0x89, 0x19, 0x2C, 0x4E, 0x0F, 0x66, 0xE5, + 0xD4, 0x4B, 0x0B, 0xE6, 0x05, 0x1E, 0xDC, 0xFF, + 0x26, 0x94, 0xDF, 0xFE, 0xBC, 0xE2, 0x5B, 0x5C, + 0xB0, 0x86, 0x78, 0x74, 0x68, 0xD5, 0xA0, 0xD8 + }, + { + 0x27, 0xF3, 0xD2, 0x34, 0xFB, 0xBE, 0x43, 0xD4, + 0xC1, 0x27, 0xDA, 0xDE, 0x3C, 0xD7, 0x12, 0x94, + 0x08, 0x99, 0x97, 0x84, 0x91, 0x5D, 0xAA, 0x1B, + 0xC6, 0x44, 0xCC, 0x89, 0xC9, 0x9E, 0x3F, 0x2B + }, + { + 0xE0, 0x08, 0x19, 0x60, 0xE6, 0xAF, 0xA3, 0x84, + 0x8E, 0xC7, 0xF9, 0xCE, 0xF9, 0x02, 0xC7, 0xD0, + 0xE6, 0x7E, 0x66, 0x93, 0x0D, 0x76, 0xF4, 0xA5, + 0xED, 0x4F, 0x14, 0x3B, 0x2F, 0x20, 0xF5, 0x17 + }, + { + 0xE2, 0x3C, 0x23, 0x6A, 0xBB, 0x62, 0xBD, 0xD6, + 0xAC, 0xFE, 0x4B, 0x89, 0x42, 0x1B, 0x48, 0xE7, + 0x10, 0x60, 0x4A, 0xE2, 0x55, 0x79, 0x2A, 0xBC, + 0x51, 0x1C, 0xFE, 0x62, 0x29, 0xCF, 0x95, 0xDA + }, + { + 0x24, 0x95, 0x12, 0xD6, 0x96, 0x63, 0x72, 0x4F, + 0x82, 0x65, 0x65, 0x4C, 0x44, 0xE5, 0x9D, 0x02, + 0x15, 0xD6, 0x85, 0x79, 0x47, 0xB3, 0x54, 0x7B, + 0x4B, 0x5F, 0x3F, 0x58, 0x2E, 0xDF, 0xEF, 0x7C + }, + { + 0x64, 0x53, 0xDE, 0x39, 0x28, 0x43, 0xC7, 0xB6, + 0xD2, 0x78, 0x3D, 0x5F, 0xC4, 0x72, 0x23, 0x52, + 0xAB, 0x82, 0xD4, 0x9C, 0xE7, 0x54, 0x58, 0xBF, + 0x63, 0x61, 0xE3, 0xE6, 0xB0, 0x65, 0xE9, 0x4C + }, + { + 0x71, 0xF6, 0x81, 0x98, 0x5B, 0x26, 0x99, 0xEF, + 0xF7, 0x4C, 0xD5, 0x13, 0xA0, 0x34, 0xA9, 0x22, + 0x07, 0x27, 0xAE, 0xB1, 0x43, 0x26, 0x59, 0x8D, + 0xF9, 0xBD, 0x35, 0xFE, 0xA9, 0x5F, 0x7B, 0xD1 + }, + { + 0x4C, 0xD1, 0x8D, 0xE5, 0xE7, 0xFA, 0x10, 0x15, + 0xC3, 0x0C, 0xA1, 0x1D, 0x5A, 0x38, 0x32, 0xAE, + 0x8E, 0x08, 0xB5, 0x2F, 0x28, 0x90, 0xEE, 0x9A, + 0xF2, 0x4F, 0xBF, 0xEE, 0x05, 0x0B, 0x35, 0x62 + }, + { + 0xDA, 0xCD, 0x2C, 0xAA, 0xD5, 0x4E, 0x7A, 0x5F, + 0xC8, 0x9C, 0xC0, 0xA1, 0x6C, 0x11, 0x99, 0xE8, + 0x71, 0xDB, 0x8F, 0xBB, 0xC2, 0x27, 0x73, 0x03, + 0x7B, 0x1D, 0xEE, 0x70, 0x78, 0xEF, 0xD0, 0xB8 + }, + { + 0x84, 0xB5, 0x81, 0x5E, 0x80, 0xF4, 0xA6, 0xAF, + 0x8A, 0x1C, 0x97, 0x71, 0x20, 0x96, 0x53, 0x71, + 0x34, 0x38, 0x69, 0x9E, 0x60, 0xB4, 0x3A, 0xBD, + 0x1C, 0x46, 0x00, 0x79, 0x2C, 0x7B, 0xB7, 0x28 + }, + { + 0x75, 0xDA, 0x9B, 0xB0, 0x28, 0xC1, 0x60, 0xBD, + 0x48, 0xD0, 0x07, 0x4F, 0x78, 0x46, 0x5B, 0xB6, + 0xC0, 0xDB, 0x7F, 0x7D, 0x43, 0x6D, 0xE8, 0xE8, + 0x2A, 0x67, 0x0C, 0xAE, 0x60, 0xF4, 0xC0, 0xA8 + }, + { + 0x84, 0x8D, 0x79, 0x7C, 0xFD, 0x8F, 0xC7, 0xE7, + 0xC6, 0x53, 0xB2, 0x0C, 0x80, 0x4D, 0x17, 0xEB, + 0x2D, 0x14, 0xD0, 0x96, 0x97, 0xAA, 0x95, 0x66, + 0x97, 0xE6, 0x8E, 0xEA, 0x75, 0x47, 0x68, 0x73 + }, + { + 0x7C, 0x9D, 0xCF, 0xF4, 0x79, 0xD5, 0x69, 0x23, + 0xE3, 0x00, 0xC9, 0x9C, 0x8B, 0xD0, 0xD8, 0x63, + 0x95, 0xFB, 0xDC, 0x11, 0xBA, 0x29, 0x02, 0x01, + 0x68, 0x03, 0x91, 0x2D, 0x5C, 0x34, 0x2C, 0x72 + }, + { + 0xFD, 0x92, 0xFA, 0xA5, 0x5B, 0xC1, 0x7B, 0xBB, + 0xF8, 0xF3, 0x58, 0x3C, 0xBF, 0x7E, 0xC1, 0xFE, + 0x29, 0x66, 0x07, 0xC9, 0x8F, 0x31, 0x34, 0xB4, + 0xA9, 0xEA, 0x85, 0x48, 0x2F, 0x58, 0x6C, 0x4A + }, + { + 0xBB, 0xA7, 0x1C, 0x15, 0x57, 0xED, 0x4E, 0x44, + 0x92, 0xE1, 0xCB, 0x86, 0x77, 0x5B, 0xD6, 0x12, + 0x4E, 0x7E, 0xDF, 0xC3, 0xDD, 0x13, 0x3B, 0xDB, + 0x81, 0x7F, 0x55, 0xB1, 0xC6, 0xA6, 0xC2, 0xB6 + }, + { + 0xE5, 0xCA, 0xA0, 0x5B, 0xB4, 0x65, 0x6C, 0x06, + 0x2A, 0x39, 0xFD, 0x20, 0xBE, 0x40, 0x6C, 0x95, + 0x93, 0x09, 0x36, 0xB9, 0x42, 0x05, 0xCD, 0x71, + 0x55, 0x14, 0x96, 0xA8, 0x71, 0x68, 0xFA, 0xCA + }, + { + 0x3B, 0x6A, 0x01, 0xAA, 0x60, 0x01, 0x91, 0x38, + 0xB0, 0xF9, 0x7B, 0x46, 0x54, 0xF6, 0xBC, 0x63, + 0x5E, 0xE7, 0x18, 0xA6, 0x76, 0x7D, 0x8E, 0x3E, + 0x0F, 0x6A, 0xAD, 0x27, 0x41, 0xC3, 0x24, 0x9B + }, + { + 0x69, 0xD7, 0xC6, 0x78, 0xC3, 0xFF, 0x96, 0x00, + 0x5D, 0x47, 0xDF, 0x86, 0xAC, 0x81, 0x9A, 0xFB, + 0xF4, 0x53, 0x22, 0x39, 0x16, 0x2C, 0x11, 0x2C, + 0xF6, 0x1B, 0x35, 0xEF, 0xB8, 0x59, 0x0B, 0xC5 + }, + { + 0x3A, 0x61, 0x57, 0xD8, 0x46, 0xE2, 0x22, 0x0A, + 0xE0, 0x01, 0xEE, 0x25, 0xB6, 0xC5, 0x83, 0x67, + 0xAF, 0x78, 0xB5, 0x7E, 0x79, 0x5F, 0xBD, 0xA4, + 0x89, 0x6B, 0x8A, 0xB9, 0x03, 0x64, 0xCD, 0x73 + }, + { + 0x68, 0x6D, 0x69, 0x5F, 0x44, 0x9E, 0x51, 0x56, + 0xD7, 0x0C, 0x54, 0xCD, 0x7C, 0x3F, 0x74, 0x0C, + 0x92, 0x33, 0xDC, 0xA1, 0x72, 0xFF, 0xCA, 0xDB, + 0xA9, 0x48, 0x84, 0x14, 0xDA, 0x9C, 0x14, 0x15 + }, + { + 0x1D, 0x2F, 0x3A, 0x98, 0x4F, 0xEB, 0xE4, 0x80, + 0x0A, 0xF9, 0x32, 0x3A, 0x03, 0x44, 0xA9, 0xC9, + 0xBB, 0x85, 0x77, 0x75, 0x24, 0x69, 0x43, 0xAE, + 0x8F, 0x1C, 0xFD, 0x46, 0x8D, 0x3A, 0x43, 0xEA + }, + { + 0x73, 0x57, 0x13, 0x50, 0x95, 0xE6, 0x45, 0x6F, + 0x86, 0x57, 0xB2, 0xDE, 0xB5, 0xE5, 0x02, 0x24, + 0xF5, 0xF4, 0xC5, 0x20, 0x17, 0x9F, 0xA5, 0xC0, + 0xBD, 0x26, 0x8E, 0x58, 0x5A, 0xCA, 0x70, 0x87 + }, + { + 0xB8, 0x83, 0x2A, 0x6A, 0x6A, 0x75, 0x3C, 0x18, + 0xB7, 0xAE, 0xBF, 0xB2, 0x2B, 0xDA, 0x46, 0x04, + 0x47, 0x0E, 0x6E, 0x77, 0x35, 0x15, 0xC1, 0xDE, + 0x01, 0xAD, 0xE2, 0x08, 0x68, 0x3E, 0x11, 0x3F + }, + { + 0xE3, 0xA3, 0xC8, 0xE4, 0x8A, 0x14, 0x30, 0x4A, + 0xF5, 0xF6, 0x67, 0xDD, 0xF9, 0x05, 0xAE, 0x71, + 0x41, 0xFF, 0x74, 0x18, 0xA6, 0x3C, 0xEE, 0x1A, + 0xA7, 0xF7, 0x01, 0x11, 0x12, 0x53, 0xE3, 0x21 + }, + { + 0xCE, 0xE1, 0x9A, 0xB0, 0x28, 0x73, 0xE8, 0x33, + 0x5D, 0x94, 0x49, 0xD5, 0x67, 0x90, 0x69, 0xB3, + 0x98, 0x9E, 0x16, 0xC6, 0xA6, 0x67, 0xBD, 0xA1, + 0x49, 0xC9, 0x55, 0xC9, 0x18, 0xF0, 0x7B, 0xCB + }, + { + 0x1C, 0x1A, 0x0D, 0x63, 0xFC, 0xD0, 0x39, 0xCC, + 0x6C, 0x43, 0x8D, 0xBE, 0xAB, 0x0A, 0xB0, 0xFF, + 0x4C, 0x50, 0x47, 0x36, 0x58, 0xA3, 0xDB, 0x5A, + 0x5A, 0x8C, 0x89, 0xD6, 0xA2, 0xD2, 0x22, 0xD5 + }, + { + 0x9C, 0x0E, 0xE6, 0xF2, 0xEA, 0x61, 0xBA, 0x9A, + 0x72, 0x87, 0xF1, 0x4A, 0xEE, 0xCA, 0x1E, 0x15, + 0x9B, 0xBE, 0xD6, 0x19, 0x91, 0xA1, 0xD8, 0xA8, + 0x64, 0x08, 0xEA, 0xC0, 0x2A, 0xEC, 0xFE, 0x21 + }, + { + 0x12, 0xC5, 0x22, 0x14, 0x55, 0x58, 0xCA, 0xE2, + 0xB7, 0xE3, 0x72, 0x83, 0xE5, 0x5B, 0xF0, 0xB6, + 0x0E, 0xEF, 0xAE, 0x24, 0xF5, 0x08, 0xE6, 0x69, + 0x10, 0x7A, 0x83, 0x61, 0x94, 0x5C, 0xD8, 0x86 + }, + { + 0x89, 0x04, 0x29, 0x30, 0x79, 0x4B, 0xFF, 0x03, + 0xF1, 0x37, 0xD8, 0x0E, 0xD9, 0xE0, 0x97, 0x2F, + 0x73, 0xC3, 0x8F, 0x7B, 0x80, 0x4A, 0x36, 0x9D, + 0x80, 0xDB, 0xD1, 0x44, 0x15, 0xE9, 0xBD, 0x58 + }, + { + 0x18, 0x3B, 0xAC, 0xEA, 0x66, 0xC7, 0xB1, 0xF6, + 0x93, 0xA8, 0xB1, 0x45, 0x54, 0xA8, 0x02, 0x9B, + 0x92, 0x8C, 0x8C, 0x04, 0x10, 0xCE, 0xD9, 0xCF, + 0x43, 0x74, 0xD6, 0x69, 0xF5, 0xB9, 0xDE, 0x81 + }, + { + 0x6D, 0x04, 0x74, 0x65, 0x58, 0xC9, 0xE8, 0x88, + 0x6D, 0xFF, 0x9C, 0xB4, 0x45, 0x93, 0x84, 0x43, + 0x8B, 0xBE, 0x4C, 0x08, 0x5C, 0xF9, 0xC7, 0x87, + 0xF6, 0x28, 0xFD, 0xAA, 0x59, 0xC6, 0x79, 0xCA + }, + { + 0x36, 0x8D, 0x63, 0xF7, 0xE1, 0x9B, 0x7F, 0x85, + 0x5D, 0x12, 0x4F, 0x48, 0x78, 0x47, 0x66, 0x2B, + 0x2E, 0x39, 0x30, 0x26, 0x36, 0x93, 0xB8, 0x65, + 0xD2, 0x3F, 0xC9, 0x03, 0xFE, 0xF4, 0x41, 0x73 + }, + { + 0xDE, 0xD3, 0xC7, 0xFE, 0x94, 0x2F, 0x01, 0xF2, + 0xD8, 0x36, 0x98, 0x29, 0xA9, 0x89, 0xE8, 0xE7, + 0x17, 0xAD, 0xB5, 0xD9, 0x79, 0x2E, 0x81, 0xAE, + 0xAA, 0xCD, 0x75, 0xF8, 0x32, 0x38, 0x93, 0xCF + }, + { + 0x20, 0x5F, 0xE0, 0x08, 0x82, 0xBB, 0x41, 0x16, + 0x12, 0x0F, 0xCC, 0x82, 0x1D, 0x0F, 0x99, 0x3C, + 0xAB, 0x33, 0x84, 0x53, 0x57, 0x04, 0x59, 0xF0, + 0x83, 0xEE, 0x7C, 0x47, 0xCA, 0xD0, 0x30, 0xBB + }, + { + 0xFC, 0x94, 0x88, 0x28, 0x75, 0xC8, 0xB8, 0x72, + 0x63, 0x1B, 0x1F, 0x90, 0x66, 0x94, 0xDC, 0x50, + 0xF4, 0x7A, 0xB3, 0x6F, 0xDA, 0x3C, 0x4E, 0xA2, + 0xC4, 0x38, 0xD7, 0xFE, 0xE6, 0x2E, 0x13, 0x83 + }, + { + 0x48, 0x7B, 0x7A, 0x87, 0x0E, 0xA4, 0x75, 0xC7, + 0x84, 0x27, 0xB8, 0xA7, 0xE7, 0x8B, 0x26, 0x78, + 0x94, 0xE7, 0x17, 0x39, 0x27, 0x6F, 0xCA, 0x3A, + 0xB0, 0xAD, 0x03, 0xE0, 0xEA, 0x02, 0x92, 0x58 + }, + { + 0x8E, 0x14, 0x58, 0xB6, 0x3A, 0x53, 0x1C, 0x3C, + 0x50, 0x68, 0x1B, 0x44, 0xEA, 0xEE, 0xA0, 0x40, + 0xAB, 0x7C, 0x2C, 0xEB, 0xE5, 0x28, 0x81, 0x27, + 0x11, 0xCD, 0x69, 0xEE, 0xDE, 0x0B, 0xAA, 0x5D + }, + { + 0x5E, 0xB4, 0x9F, 0x92, 0x5C, 0x71, 0xF5, 0xAE, + 0x80, 0x00, 0x8F, 0xA9, 0x56, 0x33, 0x4A, 0x06, + 0x36, 0xB7, 0x2E, 0x6D, 0xED, 0xC0, 0xE0, 0x10, + 0xE4, 0x59, 0xCC, 0x3A, 0x2B, 0x72, 0x19, 0x47 + }, + { + 0x8E, 0x36, 0xAB, 0x53, 0x95, 0x4E, 0xDB, 0x15, + 0xE4, 0x16, 0x80, 0x6A, 0x3C, 0x51, 0x99, 0xD9, + 0x88, 0x3B, 0xE9, 0xDA, 0xAE, 0x7E, 0x46, 0x5A, + 0x2B, 0xD8, 0x64, 0xA4, 0xD3, 0xCD, 0x68, 0x53 + }, + { + 0x67, 0x3B, 0xAC, 0x4F, 0xD4, 0x18, 0x4C, 0xD0, + 0x2A, 0x10, 0xB4, 0xF9, 0x10, 0x1B, 0xA3, 0xCD, + 0xB8, 0xB2, 0x3C, 0x3E, 0x6D, 0x6A, 0xB9, 0x39, + 0x04, 0x8C, 0xCD, 0x6F, 0xD8, 0x0A, 0x32, 0xC0 + }, + { + 0x4F, 0x75, 0xE4, 0x21, 0x84, 0x76, 0x3F, 0xE9, + 0xD9, 0x04, 0x92, 0x4D, 0x5B, 0x86, 0x36, 0x38, + 0xEF, 0x34, 0x03, 0x5A, 0x25, 0x49, 0x38, 0xE4, + 0x6F, 0xA7, 0x2A, 0xFC, 0xC2, 0x1B, 0x07, 0x8C + }, + { + 0x79, 0x56, 0xB5, 0xFF, 0x75, 0x7E, 0x20, 0x0B, + 0x34, 0xBB, 0xF5, 0x32, 0xCD, 0x68, 0xF7, 0x68, + 0x9A, 0x3E, 0xA9, 0xFA, 0xBF, 0x9B, 0xDC, 0x8F, + 0xEF, 0x5B, 0x8C, 0xF7, 0x6F, 0xE3, 0xF3, 0x15 + }, + { + 0x3F, 0xE4, 0x62, 0xAA, 0xCF, 0x52, 0x58, 0x7C, + 0xA8, 0xAE, 0x0B, 0xAA, 0x0D, 0x65, 0x57, 0x1A, + 0x96, 0x72, 0xCA, 0xAB, 0xAB, 0x05, 0xFB, 0x90, + 0xDD, 0x11, 0xB1, 0x8F, 0xC1, 0xDE, 0x2D, 0x0A + }, + { + 0x70, 0xF4, 0x61, 0xC5, 0x06, 0x64, 0x94, 0xB5, + 0xEB, 0x28, 0xA9, 0x59, 0xEF, 0xA3, 0xA9, 0x19, + 0x1A, 0x5E, 0x52, 0x64, 0x2E, 0x6F, 0x5B, 0x5F, + 0x22, 0xC7, 0x51, 0x92, 0x72, 0x39, 0xD4, 0x60 + }, + { + 0x95, 0xB9, 0xC3, 0x45, 0xAA, 0x7E, 0x17, 0x91, + 0xDF, 0x02, 0x09, 0x06, 0x48, 0x37, 0x22, 0x17, + 0x17, 0xB0, 0x09, 0xDD, 0x90, 0x81, 0x6A, 0x06, + 0xAE, 0x4A, 0x83, 0xF6, 0xE6, 0xC1, 0x2F, 0x8D + }, + { + 0x84, 0x20, 0x8B, 0x40, 0x69, 0x7D, 0xD6, 0x87, + 0x7D, 0x3B, 0xCC, 0x42, 0x27, 0x8A, 0xF7, 0xE2, + 0x67, 0xA0, 0x7C, 0xD7, 0x99, 0x2D, 0x6B, 0xEF, + 0x4F, 0x1C, 0x37, 0x48, 0x08, 0xE6, 0x56, 0xBA + }, + { + 0xEA, 0x21, 0x41, 0x38, 0x54, 0xD4, 0x29, 0xFC, + 0x6D, 0x57, 0xF3, 0x39, 0x2F, 0xE5, 0x95, 0x1D, + 0xA1, 0xBA, 0xF9, 0x02, 0x59, 0x24, 0xF3, 0xAB, + 0x4C, 0xF7, 0x5D, 0x99, 0x2B, 0xCF, 0x6C, 0x49 + }, + { + 0x6F, 0x03, 0x10, 0xAD, 0x8E, 0x8F, 0x41, 0xAE, + 0xD5, 0xFA, 0xA2, 0xA4, 0x88, 0xE0, 0x0A, 0x48, + 0x4F, 0xB8, 0x5A, 0x9C, 0xF3, 0x1C, 0x5B, 0xB6, + 0xD0, 0xDD, 0xB0, 0x0D, 0x4F, 0x69, 0x22, 0x29 + }, + { + 0x3A, 0xAA, 0x8D, 0x8F, 0x2B, 0x6A, 0xB6, 0xA5, + 0x2F, 0x04, 0x6B, 0xDB, 0x58, 0x24, 0x65, 0x79, + 0x1B, 0x19, 0xD4, 0xB7, 0x89, 0x5F, 0xE6, 0x22, + 0xB9, 0x7D, 0xA1, 0xDC, 0x16, 0xCF, 0xB4, 0x1A + }, + { + 0xE0, 0xA9, 0x8D, 0xBF, 0x04, 0xBA, 0x3B, 0xEE, + 0xF1, 0x80, 0xEE, 0xDB, 0x4E, 0x62, 0xFF, 0xB4, + 0x84, 0xD2, 0x99, 0x0B, 0xF0, 0x72, 0xFE, 0x2F, + 0x87, 0xA6, 0x05, 0x09, 0xED, 0x8F, 0x7D, 0xF9 + }, + { + 0x2C, 0x41, 0x94, 0xC5, 0xB3, 0x3E, 0x07, 0x6E, + 0x95, 0x11, 0xD5, 0xD8, 0x9A, 0x02, 0xC0, 0x84, + 0x65, 0x3D, 0xC5, 0xDD, 0x14, 0x82, 0xFF, 0x25, + 0xB1, 0xDE, 0xE6, 0xD1, 0x86, 0x8D, 0x0F, 0xD7 + }, + { + 0xC8, 0xCC, 0xEA, 0x03, 0x32, 0x06, 0x0E, 0x6F, + 0xD7, 0x7C, 0x3F, 0xEA, 0xCD, 0xC0, 0x55, 0xA3, + 0x60, 0xE2, 0x04, 0xE5, 0xB0, 0xA0, 0xF3, 0x63, + 0xC0, 0x9F, 0xF8, 0x0F, 0x13, 0xE3, 0x37, 0xD7 + }, + { + 0x39, 0xB4, 0x35, 0x8D, 0xAB, 0x78, 0x23, 0xDD, + 0xF5, 0x04, 0xE0, 0xAC, 0xA2, 0xC4, 0x27, 0x84, + 0x51, 0xB7, 0xF1, 0xF3, 0x4B, 0xBE, 0x82, 0xB6, + 0xFD, 0xD7, 0x1C, 0xFB, 0x42, 0xEC, 0x2D, 0x82 + }, + { + 0xC9, 0xBA, 0xE5, 0x46, 0xED, 0x1B, 0x3D, 0x1C, + 0xD4, 0x3E, 0x47, 0x34, 0xCC, 0x14, 0x60, 0xAF, + 0x4B, 0x56, 0xA6, 0xFF, 0xE8, 0xC1, 0x02, 0x12, + 0xA8, 0xC4, 0x29, 0x42, 0xF6, 0x0A, 0xD8, 0x6C + }, + { + 0x8B, 0xAA, 0x88, 0x08, 0xB7, 0xA9, 0x3F, 0x41, + 0x67, 0x44, 0x07, 0x41, 0x52, 0x2A, 0x5F, 0x3A, + 0x4F, 0x1D, 0x3E, 0x1F, 0x50, 0x86, 0x74, 0x58, + 0x6B, 0x42, 0xC8, 0x24, 0x65, 0x17, 0xE9, 0x0E + }, + { + 0xB8, 0x92, 0x7D, 0x3C, 0xB3, 0xF0, 0xC0, 0x70, + 0x9F, 0xE7, 0xFF, 0x25, 0x38, 0x0A, 0xC6, 0xD1, + 0x0A, 0x0D, 0x86, 0x3D, 0x28, 0x0C, 0x15, 0xE4, + 0x63, 0x6E, 0x78, 0x38, 0xA8, 0x46, 0xE6, 0x29 + }, + { + 0x88, 0x51, 0x0F, 0xAD, 0x4F, 0x49, 0x10, 0xBE, + 0x14, 0xEE, 0x9A, 0x88, 0x91, 0x4D, 0xA1, 0x51, + 0xDC, 0x51, 0x3B, 0x84, 0x9C, 0xC4, 0x39, 0xBE, + 0x6F, 0x01, 0xEB, 0x10, 0x9A, 0x3E, 0xB4, 0x3F + }, + { + 0xD3, 0xCA, 0x0E, 0x24, 0x18, 0x15, 0x5D, 0x28, + 0x0D, 0x53, 0x6F, 0xB9, 0x99, 0x32, 0x49, 0xFD, + 0x37, 0x63, 0x4D, 0x66, 0xB0, 0xDF, 0x10, 0x8E, + 0x47, 0x96, 0x90, 0xAA, 0x34, 0x4A, 0x0F, 0x45 + }, + { + 0x27, 0x3E, 0xD4, 0x73, 0xE4, 0xD1, 0x82, 0x44, + 0x4A, 0x4A, 0xDF, 0xDF, 0x53, 0x81, 0x2E, 0x44, + 0x77, 0xED, 0x71, 0x1A, 0x8E, 0x6C, 0xB8, 0xAD, + 0x99, 0xBF, 0xBF, 0x14, 0x39, 0x2E, 0x1F, 0x4F + }, + { + 0x70, 0xEE, 0x26, 0xC6, 0x27, 0x23, 0xEC, 0xF0, + 0xA9, 0x8D, 0xF5, 0x1A, 0xE4, 0x44, 0x8B, 0xDE, + 0xAF, 0xE6, 0xCB, 0x09, 0xC1, 0x6C, 0xCC, 0x67, + 0xD4, 0xD8, 0xF8, 0xCF, 0x96, 0x3A, 0xF6, 0xE9 + }, + { + 0xE9, 0xA6, 0x7C, 0xEB, 0x22, 0x71, 0x6F, 0x95, + 0x14, 0xBB, 0x0C, 0xFF, 0x8F, 0x2F, 0x65, 0x7F, + 0xF0, 0xAF, 0x1A, 0x4A, 0x51, 0x64, 0xC6, 0x00, + 0x45, 0xFD, 0xDA, 0x96, 0x56, 0xE2, 0x70, 0x89 + }, + { + 0x22, 0x50, 0xF6, 0xB3, 0x96, 0x04, 0x60, 0x47, + 0x4B, 0xD9, 0xB9, 0xBC, 0x88, 0xCC, 0x72, 0xF2, + 0x5C, 0xD1, 0x2A, 0x8B, 0x17, 0x7B, 0xD8, 0x39, + 0xA5, 0x8F, 0x11, 0x6D, 0x99, 0xA0, 0x37, 0x47 + }, + { + 0x5D, 0x20, 0x25, 0x35, 0x27, 0x88, 0x5D, 0xDF, + 0x54, 0x63, 0x0C, 0xCC, 0x6A, 0x45, 0x99, 0xB2, + 0x81, 0x7F, 0x96, 0x24, 0x0A, 0xDE, 0x7C, 0x25, + 0x50, 0xEA, 0xEC, 0x3E, 0xEF, 0x9E, 0xAA, 0xB5 + }, + { + 0x29, 0xFE, 0x27, 0x2D, 0x69, 0x42, 0x39, 0x62, + 0x41, 0x0B, 0x02, 0x98, 0x63, 0x71, 0x1D, 0x79, + 0x9C, 0xB1, 0xDE, 0x77, 0xEA, 0x9C, 0xBA, 0x86, + 0x26, 0x13, 0x3D, 0xFE, 0xE9, 0x23, 0x71, 0x3A + }, + { + 0x06, 0xA5, 0x99, 0x8C, 0xDF, 0x0F, 0x99, 0xD5, + 0x32, 0xFD, 0xF9, 0x29, 0x9E, 0x18, 0xC5, 0xB1, + 0x55, 0x58, 0x8A, 0xCC, 0x69, 0xBC, 0x20, 0x98, + 0x2D, 0x8F, 0x90, 0x5D, 0xD8, 0x85, 0xA5, 0xAE + }, + { + 0x65, 0xCD, 0x38, 0x60, 0xA0, 0x6E, 0xDA, 0x30, + 0xB4, 0xFE, 0x87, 0xE0, 0x31, 0x17, 0x8E, 0xE5, + 0x35, 0xE4, 0x91, 0xC1, 0x3B, 0x8E, 0x56, 0x7A, + 0x52, 0xAB, 0x25, 0x26, 0xF4, 0x9A, 0x53, 0xC9 + }, + { + 0x3D, 0xF9, 0x1E, 0xB6, 0x03, 0x4E, 0x37, 0xC3, + 0x2B, 0x51, 0xB1, 0x98, 0x08, 0x59, 0xE5, 0xC4, + 0xD1, 0x68, 0xD6, 0xA0, 0x88, 0x97, 0x4A, 0xB0, + 0x68, 0x35, 0x19, 0xFB, 0xF3, 0x74, 0xA8, 0x3D + }, + { + 0xB1, 0x42, 0xE1, 0x52, 0x99, 0x3A, 0xC6, 0x56, + 0x2E, 0x0D, 0x0C, 0x1A, 0x2D, 0xDC, 0x54, 0x59, + 0xCE, 0x36, 0x66, 0x8B, 0x04, 0x4F, 0x65, 0xDF, + 0x4F, 0xDF, 0x50, 0x2E, 0x49, 0xA2, 0x9D, 0x91 + }, + { + 0xE9, 0x32, 0x67, 0x38, 0x0E, 0x4F, 0x2B, 0x75, + 0x72, 0xD4, 0xA4, 0x56, 0xD7, 0x5A, 0xB8, 0x50, + 0x66, 0x0A, 0x3B, 0x53, 0x80, 0xD1, 0xDB, 0x29, + 0x0F, 0x42, 0xC1, 0xEE, 0xDC, 0xAB, 0x1E, 0xB1 + }, + { + 0x95, 0x92, 0x33, 0xEB, 0x68, 0xE7, 0xEB, 0xDB, + 0x8E, 0x55, 0xAA, 0xB6, 0x7C, 0xB9, 0x8C, 0x9D, + 0xF0, 0x53, 0xA0, 0x14, 0xBF, 0x6A, 0x88, 0x01, + 0x3C, 0xDD, 0x80, 0xD7, 0x96, 0x08, 0x67, 0xD3 + }, + { + 0x30, 0xD1, 0xE3, 0x42, 0x7B, 0xC2, 0x04, 0x99, + 0xE6, 0x17, 0xF1, 0x4B, 0xA6, 0x58, 0xC0, 0x97, + 0xE8, 0x0C, 0x71, 0x04, 0x2D, 0x3E, 0xE4, 0x38, + 0x7D, 0xF8, 0x8F, 0xC1, 0x94, 0xFD, 0x4C, 0x73 + }, + { + 0xAE, 0xD3, 0x4C, 0x68, 0xFE, 0xE2, 0xD4, 0xFF, + 0xD1, 0x14, 0xC4, 0x37, 0x5C, 0x79, 0xB0, 0xFB, + 0xE0, 0x7C, 0x2B, 0x60, 0x2D, 0x5D, 0xBE, 0x94, + 0x28, 0x3C, 0xAE, 0x64, 0x6B, 0xF7, 0xC1, 0x6C + }, + { + 0xE0, 0xFD, 0x72, 0xB1, 0x06, 0x61, 0x60, 0x67, + 0xC2, 0x4B, 0xD1, 0x68, 0xD4, 0x68, 0x63, 0x1E, + 0x0F, 0x10, 0x86, 0xDB, 0x8C, 0xC5, 0xC5, 0x40, + 0xF0, 0xCC, 0x53, 0xF5, 0x86, 0x5F, 0xCA, 0x15 + }, + { + 0x39, 0x14, 0xBC, 0x77, 0x4B, 0x3F, 0xDC, 0x2F, + 0xC6, 0xB8, 0x51, 0x16, 0xC2, 0x65, 0x50, 0x60, + 0x35, 0xF0, 0x9A, 0x91, 0x09, 0xE1, 0x80, 0xA3, + 0x54, 0xBB, 0xF4, 0x41, 0xC3, 0x69, 0xA2, 0xCE + }, + { + 0xE6, 0xBD, 0x1F, 0x61, 0xF4, 0x3E, 0x35, 0xC5, + 0x80, 0x4C, 0x3B, 0x8E, 0xAC, 0xD4, 0x66, 0xCC, + 0x10, 0x3C, 0x10, 0x6E, 0x18, 0xEA, 0x83, 0x12, + 0xA4, 0xA1, 0xC2, 0xC8, 0x59, 0x1E, 0xB0, 0x12 + }, + { + 0xC8, 0xFF, 0xB1, 0xA7, 0xE3, 0xF3, 0x0C, 0x10, + 0x5A, 0x33, 0xAA, 0xC5, 0x5F, 0xB9, 0x9A, 0xA3, + 0xFE, 0xCA, 0x47, 0x13, 0x60, 0x67, 0xE0, 0xA6, + 0x9B, 0x5B, 0xD3, 0x5A, 0x9C, 0x8B, 0xD1, 0xBB + }, + { + 0xAE, 0x33, 0x8A, 0x4C, 0x69, 0x19, 0x87, 0x42, + 0x9A, 0xD8, 0x65, 0x63, 0xE9, 0xEB, 0x37, 0x44, + 0xA7, 0x1E, 0x7C, 0xE3, 0xCC, 0xA5, 0xF2, 0xBA, + 0x87, 0x69, 0x94, 0x0F, 0x2B, 0xC8, 0x08, 0xCD + }, + { + 0xAE, 0x58, 0x9D, 0x96, 0xD3, 0x03, 0x6C, 0x0E, + 0xA3, 0x99, 0x47, 0xAE, 0x65, 0x65, 0x8A, 0x4F, + 0x60, 0x58, 0x1D, 0x13, 0x51, 0x5B, 0x1D, 0xEC, + 0xCA, 0x06, 0x6F, 0x61, 0xFD, 0x67, 0xA7, 0xDF + }, + { + 0xFF, 0xEB, 0xE3, 0xA4, 0x9E, 0xEF, 0x0C, 0x56, + 0x88, 0xD1, 0x60, 0x97, 0xF9, 0xC9, 0x53, 0xF8, + 0x18, 0x71, 0x07, 0xC0, 0x73, 0x88, 0x29, 0x62, + 0x6C, 0x7D, 0xB9, 0xF1, 0xE7, 0x3D, 0xDA, 0x92 + }, + { + 0x65, 0xDB, 0xF8, 0xC6, 0x6F, 0x9E, 0x11, 0x6E, + 0x60, 0x3B, 0x3F, 0x11, 0x8B, 0x58, 0x0B, 0x71, + 0xF9, 0x3C, 0xE0, 0xB3, 0x4C, 0xDE, 0xF0, 0xC2, + 0xE2, 0xC9, 0xB9, 0x18, 0x80, 0xE3, 0x25, 0x2E + }, + { + 0xFE, 0xA0, 0xAF, 0x24, 0x86, 0x7F, 0x9B, 0xFE, + 0x85, 0xEC, 0x69, 0x86, 0xDF, 0xD0, 0x58, 0x20, + 0xA1, 0x88, 0xC6, 0x92, 0xC4, 0x25, 0x05, 0xC2, + 0xF2, 0x57, 0xDE, 0x98, 0x0D, 0x22, 0x42, 0x16 + }, + { + 0x73, 0xE9, 0xEC, 0x29, 0xB7, 0x37, 0x16, 0x1E, + 0xCC, 0x7B, 0x8F, 0x10, 0x42, 0x3D, 0x13, 0x6B, + 0xA5, 0x6A, 0xB3, 0xC1, 0x3D, 0xD6, 0x0E, 0x59, + 0x1E, 0x30, 0x1C, 0x79, 0xA6, 0xE5, 0xF4, 0xE6 + }, + { + 0x16, 0xCB, 0x14, 0xCF, 0xD0, 0x69, 0x35, 0x41, + 0xA0, 0xD1, 0xF4, 0x95, 0x7C, 0xDE, 0x98, 0xD2, + 0x2E, 0x9E, 0x15, 0x58, 0xDF, 0xBA, 0x99, 0xA3, + 0x02, 0x93, 0xD9, 0xD4, 0xB9, 0x94, 0xC8, 0x4A + }, + { + 0xE9, 0x3C, 0x42, 0xD1, 0x35, 0x0D, 0xDC, 0xE1, + 0xB5, 0x76, 0xA2, 0x9B, 0xF2, 0x77, 0x88, 0x05, + 0xEC, 0xDD, 0x95, 0xE7, 0x2F, 0xDB, 0x19, 0x34, + 0x7E, 0xA1, 0x2E, 0x42, 0xFD, 0xFD, 0xE0, 0xDC + }, + { + 0x40, 0x93, 0xB5, 0xD1, 0xCD, 0x0E, 0x73, 0x08, + 0xF1, 0x99, 0x4E, 0xB8, 0x13, 0x23, 0x6E, 0xDD, + 0xBF, 0x05, 0xE7, 0x9D, 0xDC, 0x78, 0x38, 0x57, + 0xD2, 0x4B, 0x5E, 0xC5, 0x10, 0xC1, 0xE4, 0x6F + }, + { + 0x52, 0xBC, 0xBB, 0x29, 0x8A, 0xE6, 0x70, 0xB9, + 0xF9, 0xBE, 0x74, 0x6C, 0xB9, 0x53, 0xFC, 0xF1, + 0xD3, 0xBB, 0xD3, 0xEC, 0x2F, 0xD7, 0xFC, 0x75, + 0x13, 0xE0, 0xED, 0xBC, 0x56, 0x60, 0xE6, 0xF3 + }, + { + 0x47, 0x29, 0xAA, 0xD6, 0xFB, 0x57, 0x94, 0x0B, + 0x37, 0xEB, 0x09, 0x66, 0xA3, 0xCF, 0x70, 0x0B, + 0x3B, 0x14, 0xDC, 0xCB, 0x5A, 0xCD, 0xFC, 0xBF, + 0xE1, 0x68, 0xAC, 0xBA, 0xDE, 0x87, 0x44, 0x3D + }, + { + 0x00, 0x8D, 0x06, 0xEA, 0x30, 0x30, 0x8A, 0x04, + 0x01, 0x1D, 0x07, 0x7B, 0xE1, 0xE1, 0x6E, 0x2E, + 0xE4, 0x92, 0x29, 0x10, 0x66, 0x89, 0x85, 0xD4, + 0xED, 0x1F, 0xAE, 0x42, 0xB9, 0xBC, 0x08, 0x26 + }, + { + 0x55, 0xEF, 0xF0, 0x33, 0x90, 0xDE, 0x25, 0x92, + 0x15, 0xA2, 0x50, 0xED, 0x1A, 0xA5, 0xEC, 0xEA, + 0x5E, 0x22, 0x89, 0x77, 0x30, 0xD9, 0x1A, 0x30, + 0x3D, 0x84, 0xBE, 0x51, 0x5A, 0xCF, 0x0C, 0x15 + }, + { + 0xBB, 0x6F, 0x48, 0x59, 0xAA, 0x02, 0x0A, 0xB2, + 0x42, 0xD0, 0xAF, 0xA6, 0x4B, 0xF5, 0xC1, 0x0A, + 0x9C, 0xB9, 0xDA, 0xB5, 0xA2, 0x9A, 0x95, 0x28, + 0x03, 0xB6, 0xAA, 0xE9, 0x1A, 0x06, 0xE5, 0x5E + }, + { + 0xCB, 0x71, 0x50, 0xE2, 0xD7, 0xA3, 0x2C, 0x4C, + 0xFE, 0xCB, 0xB7, 0x81, 0xB0, 0x16, 0x4A, 0x95, + 0x46, 0x76, 0x4D, 0x78, 0x1B, 0x78, 0xCA, 0xEA, + 0x21, 0x14, 0x2C, 0x41, 0x12, 0x8D, 0x5E, 0xF1 + }, + { + 0x82, 0x8E, 0x98, 0xDA, 0x68, 0x11, 0x1F, 0xDA, + 0x9B, 0x4B, 0x45, 0xBA, 0x8F, 0xBB, 0xCF, 0xBF, + 0x4D, 0x22, 0x99, 0x48, 0xF5, 0x81, 0xBB, 0x9F, + 0x5E, 0xFC, 0x76, 0x15, 0x67, 0x98, 0xE7, 0xE4 + }, + { + 0xE2, 0x95, 0xA4, 0x5A, 0xCA, 0x6E, 0x47, 0xA6, + 0x02, 0x26, 0xD6, 0x17, 0xDC, 0xEB, 0xD5, 0x26, + 0x86, 0x6E, 0xE4, 0xD1, 0x4B, 0x27, 0x15, 0x9F, + 0x32, 0xD2, 0xD9, 0xF8, 0x2A, 0x75, 0x31, 0x72 + }, + { + 0x30, 0x5A, 0x8C, 0x87, 0xED, 0x60, 0x7F, 0xB7, + 0xE6, 0xD8, 0xEB, 0xA6, 0xD9, 0xED, 0x23, 0x94, + 0x91, 0xD2, 0x29, 0xAF, 0x31, 0x17, 0x8F, 0x0B, + 0x58, 0x72, 0xF2, 0x18, 0x28, 0xF8, 0x84, 0x5C + }, + { + 0xA5, 0xB6, 0x65, 0xE3, 0x19, 0xAA, 0x45, 0x92, + 0xCF, 0x21, 0x10, 0x83, 0x45, 0x42, 0x91, 0xE7, + 0x8A, 0x3A, 0x9D, 0x21, 0x4B, 0xC1, 0x36, 0x76, + 0xB0, 0x41, 0x59, 0x23, 0xCF, 0x84, 0x06, 0x4B + }, + { + 0x20, 0xE4, 0xD5, 0x55, 0x87, 0x7A, 0xF7, 0x0C, + 0x19, 0x6F, 0x5B, 0xB8, 0x73, 0xF1, 0x7F, 0x0F, + 0x53, 0x9A, 0x0C, 0x07, 0xBF, 0x84, 0x03, 0x7A, + 0x62, 0x31, 0x82, 0xF3, 0x18, 0x41, 0x1F, 0x54 + }, + { + 0x6A, 0xB7, 0x0F, 0x67, 0x97, 0xEB, 0x08, 0xA2, + 0x93, 0x70, 0x8C, 0xCC, 0x43, 0xFB, 0x12, 0xED, + 0xA4, 0x76, 0x4C, 0x11, 0x15, 0x85, 0x5C, 0x09, + 0xB3, 0x8F, 0xF9, 0xBE, 0x04, 0x80, 0x55, 0x36 + }, + { + 0xCF, 0x5C, 0x99, 0xBA, 0x15, 0x12, 0x06, 0x7B, + 0xE0, 0xD6, 0x83, 0x8F, 0x97, 0xE2, 0xF7, 0x22, + 0xDB, 0x5D, 0xAE, 0x79, 0x56, 0x04, 0x9D, 0xA0, + 0xFA, 0xA4, 0x7D, 0xE1, 0xDC, 0xC7, 0xD2, 0x67 + }, + { + 0x33, 0xEC, 0xA4, 0xD6, 0x2E, 0x48, 0xCE, 0xED, + 0xE8, 0xF1, 0xE1, 0xA4, 0x84, 0x3F, 0x95, 0xA6, + 0x70, 0x9E, 0xDA, 0xE2, 0xA0, 0xA5, 0x9F, 0x31, + 0x03, 0xA8, 0x5D, 0x22, 0xCE, 0x2B, 0xF2, 0x58 + }, + { + 0xC4, 0x0B, 0x50, 0xF2, 0xAF, 0x2B, 0xFB, 0x79, + 0x7F, 0x69, 0x07, 0x64, 0xB9, 0xFF, 0x25, 0x4B, + 0xE5, 0x20, 0x5B, 0x12, 0x6D, 0xC2, 0xCF, 0x2D, + 0xD6, 0x77, 0xE4, 0xD6, 0x9B, 0x88, 0xA7, 0xCA + }, + { + 0x3A, 0x93, 0x4F, 0x11, 0xB6, 0x9C, 0x9E, 0x44, + 0x9B, 0x5D, 0xC7, 0x87, 0x86, 0x54, 0xED, 0xC3, + 0x0B, 0x9C, 0xEC, 0xBF, 0xC1, 0x20, 0xD6, 0xAF, + 0x4B, 0xF1, 0x0D, 0x17, 0x09, 0x2E, 0xAF, 0x8E + }, + { + 0xD1, 0xEE, 0xA8, 0x51, 0xCC, 0xD5, 0x8F, 0x88, + 0x98, 0xB7, 0x9C, 0xB0, 0xF9, 0xA0, 0x0A, 0xE0, + 0x0B, 0xF5, 0x80, 0xEB, 0xF8, 0x04, 0xEF, 0x40, + 0xBF, 0x43, 0x58, 0x6D, 0x37, 0x5D, 0x1B, 0xDC + }, + { + 0x49, 0x75, 0x70, 0xFC, 0x28, 0x36, 0xBE, 0x3B, + 0xD7, 0x1F, 0x00, 0x6F, 0xBA, 0x89, 0xC1, 0xF8, + 0x9B, 0x5F, 0x86, 0x6E, 0xF8, 0xA2, 0x18, 0xE5, + 0x61, 0xA1, 0xAD, 0x8C, 0xAC, 0x4C, 0x94, 0x8C + }, + { + 0x2D, 0x27, 0x32, 0x09, 0x20, 0xEF, 0x08, 0xCD, + 0x29, 0xE0, 0xA4, 0x71, 0x6A, 0xE8, 0xD2, 0x61, + 0xF0, 0x77, 0x10, 0xE7, 0xE8, 0xA3, 0x23, 0x28, + 0xB0, 0xD0, 0x77, 0x75, 0xB5, 0xC9, 0x00, 0x99 + }, + { + 0x79, 0xA1, 0x80, 0x8D, 0xEE, 0x9A, 0x51, 0xA9, + 0xDB, 0xBB, 0xBE, 0xB5, 0x6E, 0x20, 0x73, 0x5E, + 0xE7, 0x7C, 0x0D, 0x6F, 0xC5, 0x00, 0x22, 0xF4, + 0x30, 0xA1, 0x1E, 0x6B, 0x9E, 0x68, 0xFC, 0x2A + }, + { + 0x66, 0x49, 0x43, 0x61, 0x3A, 0xE2, 0x37, 0x38, + 0x1F, 0x0D, 0x7A, 0xBE, 0xB8, 0xD1, 0x8E, 0x11, + 0x38, 0xA1, 0x09, 0xAA, 0x81, 0x2A, 0x8C, 0x25, + 0x42, 0x55, 0xA0, 0x5F, 0xCB, 0xE8, 0x47, 0x09 + }, + { + 0x9C, 0xE1, 0xCC, 0x01, 0x7D, 0x2D, 0x15, 0x9F, + 0xF9, 0x61, 0x93, 0xAF, 0x4E, 0x49, 0x3B, 0xC7, + 0xF1, 0x8C, 0x44, 0xB8, 0xCA, 0x6F, 0xDD, 0x3C, + 0x86, 0x7C, 0x0B, 0x7B, 0x0A, 0x58, 0x53, 0x4D + }, + { + 0x68, 0x55, 0xAA, 0x27, 0x95, 0x31, 0xCE, 0x43, + 0x02, 0x01, 0xBB, 0xC7, 0xDF, 0x9B, 0xD3, 0x79, + 0x01, 0xB0, 0x36, 0x58, 0xD3, 0x0A, 0xFC, 0xEA, + 0x60, 0x12, 0x6E, 0x60, 0x02, 0xF5, 0xC9, 0x97 + }, + { + 0xED, 0x80, 0xAB, 0x2F, 0x47, 0xF8, 0xD0, 0x89, + 0x72, 0x06, 0x40, 0x73, 0xAF, 0x4C, 0x2E, 0x8F, + 0x9B, 0x05, 0x64, 0x0C, 0x2F, 0x72, 0x7A, 0x72, + 0xF4, 0xF4, 0x95, 0x32, 0xA3, 0x13, 0x29, 0xA9 + }, + { + 0x8C, 0x89, 0xAE, 0x37, 0x8E, 0xB8, 0xDC, 0x0C, + 0x84, 0xD6, 0xAB, 0x5B, 0x8A, 0x12, 0x5B, 0x90, + 0xCD, 0x2A, 0x4E, 0xA1, 0x57, 0xF5, 0x07, 0xC7, + 0x04, 0x20, 0x73, 0xD4, 0x86, 0xED, 0x34, 0x49 + }, + { + 0x2C, 0xE0, 0x01, 0x59, 0x74, 0x50, 0x41, 0xE9, + 0x06, 0xA3, 0xF6, 0x77, 0x1F, 0x25, 0x6F, 0xF3, + 0xC1, 0x70, 0x68, 0x27, 0x28, 0xD2, 0xD9, 0x39, + 0xE3, 0x1C, 0xA6, 0x33, 0x5F, 0xB6, 0x22, 0x46 + }, + { + 0x52, 0x79, 0x01, 0x66, 0x93, 0x37, 0xFE, 0x89, + 0x64, 0x6C, 0x04, 0x15, 0xDA, 0x3B, 0x28, 0xFE, + 0xE4, 0xD5, 0xE6, 0xFA, 0xD9, 0xA3, 0x27, 0x31, + 0xB9, 0x14, 0x46, 0x9D, 0x3A, 0xED, 0x68, 0x48 + }, + { + 0xEB, 0x5D, 0xF2, 0x0F, 0xD2, 0x48, 0x4E, 0x34, + 0x1B, 0xB9, 0xF0, 0xC5, 0x93, 0x5A, 0x13, 0x68, + 0xE1, 0x42, 0x8A, 0x44, 0xFC, 0x30, 0x2F, 0x3C, + 0x81, 0x34, 0x1C, 0x64, 0xC3, 0x18, 0x85, 0x82 + }, + { + 0x7D, 0x84, 0x10, 0x65, 0x6E, 0x09, 0x39, 0xEE, + 0x19, 0x78, 0x37, 0xE0, 0x5D, 0xA7, 0x71, 0x68, + 0x44, 0x41, 0xE2, 0xE6, 0x71, 0xF0, 0xE7, 0xD4, + 0x91, 0x48, 0xC5, 0x13, 0x09, 0x88, 0xA5, 0xBE + }, + { + 0xD5, 0xCD, 0x07, 0x14, 0x73, 0xA0, 0xB7, 0x4E, + 0xF9, 0xED, 0x36, 0x18, 0xD5, 0xA8, 0xC5, 0x88, + 0x31, 0x4E, 0x0A, 0x7A, 0x10, 0x83, 0xC3, 0x8B, + 0x0C, 0xFC, 0x9B, 0xA1, 0x89, 0x94, 0xF3, 0x5F + }, + { + 0x06, 0xA8, 0xA0, 0xAF, 0x79, 0x93, 0x48, 0x19, + 0xA9, 0xF9, 0xC9, 0xCE, 0x65, 0xFF, 0x87, 0xAF, + 0x9A, 0x7A, 0x71, 0xDE, 0xD5, 0x62, 0xC5, 0xF6, + 0x59, 0xEC, 0x24, 0x71, 0xFB, 0x1E, 0xF4, 0x75 + }, + { + 0xBF, 0x6D, 0x5C, 0x4A, 0xD8, 0x32, 0xDE, 0x19, + 0x1C, 0xDB, 0x6D, 0xDC, 0xF2, 0x0F, 0x6D, 0xA2, + 0x03, 0x45, 0x99, 0xFF, 0xCC, 0x95, 0x16, 0xF9, + 0x87, 0xD3, 0x39, 0x23, 0xBE, 0x12, 0x77, 0x27 + }, + { + 0x08, 0xA0, 0x6B, 0xD3, 0x45, 0x30, 0x51, 0xE3, + 0x87, 0xC1, 0x90, 0x89, 0x40, 0x94, 0x06, 0xBE, + 0x16, 0xAD, 0x4D, 0x55, 0x96, 0x61, 0x8A, 0x06, + 0x69, 0xCF, 0x42, 0x9C, 0x57, 0xD5, 0x96, 0x68 + }, + { + 0x79, 0x98, 0x6F, 0xB7, 0x44, 0x65, 0xD8, 0xF4, + 0xA0, 0x2B, 0x30, 0x72, 0xD1, 0xD5, 0x76, 0xDD, + 0x46, 0x76, 0x60, 0xE0, 0x47, 0x99, 0xD4, 0x8A, + 0x47, 0xB0, 0x8C, 0xD0, 0x65, 0xD0, 0x4A, 0x7D + }, + { + 0x79, 0x94, 0x33, 0x1B, 0x31, 0xE1, 0x51, 0x6D, + 0x44, 0x59, 0xA8, 0xE6, 0xFF, 0x52, 0xFE, 0x9A, + 0x73, 0x33, 0xA2, 0xBD, 0xC3, 0xAB, 0x52, 0xD7, + 0x02, 0x56, 0x8A, 0x1F, 0x88, 0xFA, 0x85, 0x91 + }, + { + 0x02, 0x34, 0xA1, 0xD5, 0xCB, 0xF5, 0x20, 0x91, + 0x76, 0x88, 0x4B, 0x95, 0xB4, 0xEA, 0xEB, 0xC0, + 0xF4, 0xC9, 0x36, 0x33, 0x73, 0x1E, 0xF0, 0x66, + 0x87, 0x57, 0x4A, 0x54, 0x3F, 0xBF, 0xFF, 0x5D + }, + { + 0xEB, 0x42, 0x89, 0xB0, 0x59, 0x14, 0xCC, 0x6B, + 0xB4, 0x45, 0x41, 0x5F, 0x28, 0x6F, 0xA0, 0x36, + 0xEA, 0xE0, 0x25, 0x57, 0xF3, 0x0E, 0x38, 0x3C, + 0xAF, 0x62, 0x45, 0x4F, 0xBE, 0x2F, 0x16, 0xA3 + }, + { + 0xF5, 0x8E, 0xD6, 0x55, 0xC7, 0xD7, 0xCF, 0x8D, + 0x73, 0xB5, 0x16, 0xED, 0xC1, 0xE3, 0xEB, 0xE9, + 0x09, 0xE2, 0x80, 0x4F, 0xC7, 0xD7, 0x9C, 0xC4, + 0x0C, 0xEF, 0x11, 0x88, 0x85, 0x56, 0x39, 0x5A + }, + { + 0x4A, 0xB2, 0x11, 0xEA, 0xC9, 0x22, 0x75, 0xDA, + 0x92, 0x4F, 0xAF, 0x6A, 0x98, 0xD4, 0xD1, 0x11, + 0x86, 0x8B, 0x17, 0x4A, 0xF7, 0x13, 0x98, 0xC4, + 0x04, 0x7E, 0x5F, 0x1D, 0x69, 0xB5, 0x32, 0xD0 + }, + { + 0x49, 0x04, 0x34, 0x76, 0xFD, 0xF0, 0x7C, 0x3C, + 0xFB, 0x3A, 0x41, 0xA1, 0xC7, 0x17, 0x9B, 0x38, + 0x51, 0x5F, 0x43, 0xFD, 0x98, 0x6D, 0xF4, 0x1B, + 0x21, 0x88, 0xB2, 0xF9, 0xC6, 0x72, 0xD0, 0xEE + }, + { + 0x70, 0xD4, 0xB6, 0xC9, 0xE9, 0x22, 0x7E, 0x8A, + 0xBA, 0x21, 0xB7, 0xC3, 0xE1, 0x6E, 0xA9, 0x27, + 0x66, 0x38, 0x14, 0x06, 0x90, 0x8C, 0x98, 0x9A, + 0xC0, 0x74, 0xBF, 0x54, 0xB0, 0xE7, 0xD5, 0x65 + }, + { + 0x80, 0xDA, 0x56, 0xA8, 0xF4, 0xDB, 0x22, 0x4C, + 0x12, 0x38, 0x37, 0x5D, 0x45, 0xE4, 0x90, 0x10, + 0xF0, 0x27, 0xF4, 0x9A, 0x42, 0x3C, 0x54, 0x7B, + 0x5B, 0x9A, 0xE6, 0xC9, 0x3F, 0xF3, 0x14, 0xBC + }, + { + 0xF7, 0xCC, 0xBD, 0x76, 0x4B, 0xF4, 0x84, 0x6B, + 0x53, 0xD5, 0xFD, 0x54, 0x03, 0xC6, 0x0B, 0x0E, + 0x1A, 0xF8, 0xC1, 0x58, 0xB0, 0xEA, 0xB5, 0x00, + 0x1E, 0x18, 0x8B, 0x1C, 0xE1, 0x62, 0x1D, 0x38 + }, + { + 0x39, 0x17, 0x1B, 0xE8, 0x85, 0x29, 0xDA, 0x7C, + 0xAC, 0x9D, 0xBB, 0xCC, 0xCC, 0x9A, 0x72, 0x59, + 0x9F, 0x0F, 0xA8, 0x0F, 0xF3, 0xC1, 0xCA, 0x60, + 0x01, 0xCD, 0xAE, 0xD5, 0x14, 0x9A, 0xE0, 0xAD + }, + { + 0x54, 0xF0, 0xDE, 0x7B, 0xE7, 0xB6, 0x97, 0x89, + 0x09, 0xE4, 0xBB, 0xB1, 0x53, 0x3C, 0xA5, 0xCD, + 0xCF, 0x08, 0x35, 0x0F, 0xE3, 0x7B, 0x48, 0x17, + 0x3C, 0x07, 0x39, 0xD3, 0x57, 0x60, 0x90, 0x4D + }, + { + 0x05, 0x14, 0xAB, 0x83, 0xFC, 0xF7, 0xC5, 0xD8, + 0xEF, 0xA1, 0xF7, 0x89, 0xC4, 0x51, 0xEB, 0xA3, + 0x3C, 0x06, 0x63, 0xAC, 0x59, 0x66, 0x2B, 0xAF, + 0xC0, 0xC2, 0x1F, 0x02, 0x5C, 0xD2, 0x04, 0xA6 + }, + { + 0xEC, 0xC3, 0xA3, 0xED, 0xCC, 0x98, 0xE1, 0x5C, + 0x5A, 0xEA, 0x8A, 0x00, 0x32, 0x5B, 0x0D, 0xE1, + 0x26, 0xEA, 0x16, 0x83, 0x6A, 0xB4, 0x96, 0xCE, + 0x77, 0xFF, 0x2F, 0x0A, 0xD7, 0x17, 0x72, 0x13 + }, + { + 0x13, 0x8D, 0x7D, 0x17, 0x4C, 0x7A, 0x7B, 0xDA, + 0xA8, 0xAD, 0x11, 0xD8, 0x5F, 0xE8, 0x21, 0x84, + 0x8A, 0x3A, 0x28, 0x8A, 0xEF, 0xDA, 0x89, 0xC0, + 0x07, 0x66, 0x3D, 0x04, 0xA7, 0xAA, 0xB7, 0x67 + }, + { + 0x3E, 0x39, 0xCF, 0x5F, 0x30, 0x6F, 0x92, 0x73, + 0x9B, 0x7F, 0x33, 0x29, 0x32, 0x33, 0x2F, 0x55, + 0xFF, 0x3A, 0x4A, 0xB4, 0xE0, 0xE7, 0xE5, 0x79, + 0x57, 0x30, 0xB5, 0x1C, 0xA2, 0xDB, 0x27, 0x0B + }, + { + 0x8C, 0x52, 0x93, 0xA8, 0x56, 0x64, 0xC4, 0x46, + 0xF8, 0x8B, 0x6D, 0xC6, 0x98, 0xC4, 0x6B, 0xBC, + 0xCC, 0x52, 0xE8, 0x1E, 0x47, 0x27, 0x3E, 0x8D, + 0x29, 0x5B, 0x6F, 0x18, 0xCB, 0x62, 0xF8, 0xA1 + }, + { + 0x0F, 0x6F, 0x09, 0xD3, 0xA0, 0xB2, 0x78, 0x30, + 0x93, 0x51, 0xCE, 0x7F, 0x1E, 0x30, 0x9F, 0xB1, + 0x3E, 0xAE, 0x17, 0x5F, 0x7B, 0x8C, 0x3B, 0x47, + 0x5A, 0x5C, 0xD0, 0x62, 0xAA, 0xA0, 0xC6, 0x8E + }, + { + 0xE9, 0xC3, 0xAD, 0x58, 0x20, 0xAF, 0x3C, 0x07, + 0xB3, 0x43, 0xA5, 0xA9, 0xD8, 0x23, 0x0A, 0x12, + 0x13, 0xBA, 0x0A, 0x00, 0x6D, 0x4F, 0x68, 0x60, + 0x72, 0x96, 0x5A, 0x88, 0xCB, 0x10, 0x69, 0x92 + }, + { + 0x64, 0x29, 0x37, 0x07, 0x76, 0xBA, 0x99, 0x4C, + 0xE1, 0x50, 0x0C, 0x99, 0x1C, 0x4D, 0x6F, 0xA8, + 0x75, 0x73, 0xDF, 0x7A, 0xD5, 0x3F, 0x9E, 0xA9, + 0xDC, 0x94, 0x78, 0x6C, 0x3C, 0x84, 0x3E, 0x45 + }, + { + 0x6F, 0x54, 0x3E, 0x06, 0x11, 0xDD, 0x59, 0x68, + 0x0A, 0x54, 0xCE, 0x8E, 0x06, 0xF7, 0xB5, 0xEE, + 0x2D, 0x10, 0x83, 0x2C, 0xF8, 0x0D, 0x3B, 0xDF, + 0xF0, 0x20, 0x03, 0x4B, 0xEC, 0x8E, 0x9D, 0x5E + }, + { + 0x1F, 0x9E, 0xFB, 0x6F, 0x42, 0xFD, 0xA8, 0x8A, + 0x2D, 0x33, 0xC9, 0xBB, 0x75, 0x07, 0x79, 0xBD, + 0xCA, 0x55, 0x67, 0x2C, 0xFC, 0xD3, 0x39, 0x4F, + 0x1D, 0x8A, 0x32, 0xBE, 0x28, 0x29, 0x62, 0xD9 + }, + { + 0x8E, 0x46, 0x6F, 0xA1, 0xAD, 0x93, 0xA0, 0xCA, + 0xA7, 0x00, 0x02, 0xBC, 0x8E, 0x13, 0xC0, 0xB8, + 0xB8, 0x34, 0xCC, 0x42, 0xA8, 0x57, 0xB7, 0xBC, + 0x19, 0xEF, 0x67, 0xF6, 0x6A, 0x8A, 0xBD, 0x7A + }, + { + 0xAA, 0x60, 0x02, 0x03, 0xBA, 0x4D, 0xA6, 0x38, + 0x39, 0xC4, 0x11, 0x67, 0x4F, 0x77, 0xA5, 0x59, + 0x7B, 0x93, 0x08, 0x2E, 0x93, 0x57, 0x4F, 0x39, + 0x4B, 0x57, 0x71, 0xC4, 0x2B, 0x8C, 0x9E, 0x68 + }, + { + 0x04, 0xC7, 0x2C, 0x55, 0x35, 0xDF, 0xFF, 0x6B, + 0x11, 0xCF, 0x74, 0xE5, 0x69, 0xF5, 0x80, 0x93, + 0xF9, 0x03, 0x17, 0x5C, 0xFC, 0xAB, 0xB2, 0x27, + 0x36, 0xC4, 0x28, 0xA4, 0x60, 0x34, 0x3E, 0x50 + }, + { + 0xD0, 0x98, 0xBD, 0x62, 0x8D, 0xAF, 0x33, 0x76, + 0xEA, 0x1F, 0xA5, 0xE7, 0x9D, 0x7E, 0xA3, 0x57, + 0x61, 0xE1, 0x7D, 0xB7, 0x11, 0x06, 0x8A, 0x34, + 0xA1, 0x27, 0x25, 0x6F, 0x24, 0x88, 0xA8, 0x84 + }, + { + 0x3B, 0x78, 0xAA, 0x39, 0x9E, 0xB9, 0xDD, 0x3F, + 0x76, 0x86, 0xBC, 0x96, 0xFE, 0x25, 0x8A, 0x18, + 0x6B, 0x37, 0x83, 0x3E, 0xB8, 0xE9, 0x5E, 0xFD, + 0xD3, 0x63, 0x3F, 0xA1, 0x1E, 0x0F, 0x3B, 0x79 + }, + { + 0x67, 0x91, 0x0D, 0x40, 0x37, 0xE7, 0x47, 0xC7, + 0x39, 0x2E, 0xD0, 0x33, 0x06, 0x17, 0x97, 0x18, + 0x29, 0x6B, 0xCD, 0xCD, 0x4F, 0x97, 0x7B, 0x8A, + 0x91, 0x10, 0x17, 0xAB, 0x3D, 0x9E, 0xDD, 0xE4 + }, + { + 0xE1, 0x4F, 0x30, 0x04, 0x03, 0x41, 0xD9, 0x00, + 0xD6, 0x0C, 0x68, 0x64, 0x3E, 0xBA, 0x49, 0x29, + 0xD1, 0xA4, 0x06, 0x44, 0xDF, 0xB7, 0x60, 0x83, + 0x05, 0x1A, 0x25, 0x37, 0x1E, 0x65, 0xB2, 0x6E + }, + { + 0x0A, 0xFC, 0xE2, 0x04, 0x82, 0x31, 0x39, 0xBE, + 0xC2, 0x10, 0x09, 0xDE, 0x67, 0x74, 0xEA, 0xB9, + 0x4F, 0xA9, 0x99, 0xFD, 0xB6, 0xA7, 0x4A, 0x7F, + 0x68, 0x82, 0xC5, 0x3A, 0x67, 0x49, 0xD9, 0xC4 + }, + { + 0xD9, 0xA5, 0x02, 0x8F, 0x0B, 0x56, 0xD8, 0x10, + 0xFD, 0xCE, 0x44, 0x0B, 0x27, 0xAA, 0x9E, 0xD7, + 0xF1, 0x3A, 0x70, 0x26, 0x0D, 0x7B, 0xA7, 0x82, + 0xC8, 0x0C, 0x1B, 0xB8, 0x0E, 0x70, 0xFF, 0x93 + }, + { + 0x9C, 0x86, 0xE9, 0x35, 0xE1, 0x81, 0x0C, 0xF8, + 0x2B, 0xF3, 0x42, 0x20, 0xCF, 0x23, 0xAD, 0xC4, + 0xA2, 0xEF, 0xF6, 0x92, 0x5E, 0x13, 0x75, 0x8B, + 0xAB, 0x13, 0x8D, 0xA5, 0x85, 0xE6, 0x04, 0x1D + }, + { + 0x26, 0xDC, 0xA6, 0xA5, 0xA4, 0x15, 0xE2, 0x44, + 0x3B, 0xFA, 0x0E, 0xF8, 0x78, 0x6F, 0x8B, 0x28, + 0x43, 0x24, 0xF6, 0xF1, 0xFD, 0x17, 0x22, 0xB1, + 0xD0, 0x5F, 0x93, 0xB5, 0xCB, 0xEB, 0xBA, 0xE3 + }, + { + 0x53, 0xEE, 0x0E, 0xB5, 0xE0, 0xE7, 0x4E, 0x37, + 0x38, 0xE2, 0xD7, 0x8E, 0x65, 0x8D, 0x1F, 0xF7, + 0xC5, 0xE3, 0x42, 0x57, 0xE4, 0x49, 0xCC, 0xBA, + 0xF2, 0x2E, 0xBA, 0x9D, 0x10, 0x14, 0xFC, 0x21 + }, + { + 0x9D, 0xAE, 0xF5, 0xEC, 0xB1, 0xC1, 0xBD, 0x4F, + 0x11, 0x5F, 0x11, 0xF8, 0x39, 0xBF, 0x58, 0x95, + 0x8B, 0xC2, 0x1E, 0xED, 0xE5, 0x0A, 0xB5, 0x8A, + 0x12, 0x8C, 0x8C, 0xB0, 0x54, 0x11, 0xFE, 0x55 + }, + { + 0x2A, 0x49, 0xD8, 0x47, 0x4F, 0x26, 0xCB, 0xED, + 0x33, 0xEE, 0x7E, 0x05, 0x6B, 0x36, 0x0A, 0x85, + 0xA0, 0x5D, 0x32, 0x76, 0x78, 0x29, 0xFF, 0xB3, + 0xAA, 0x9E, 0x0C, 0xCE, 0x20, 0xE9, 0x4D, 0x83 + }, + { + 0x87, 0xDE, 0x15, 0x92, 0xC4, 0x7E, 0xA0, 0x46, + 0xAE, 0x2D, 0x49, 0x77, 0x80, 0xD1, 0x0F, 0x74, + 0x41, 0x12, 0x71, 0x4C, 0x85, 0x03, 0x01, 0x96, + 0xF7, 0xCE, 0x09, 0x75, 0x9A, 0x02, 0x3D, 0xF1 + }, + { + 0xA9, 0xC1, 0xB5, 0xFF, 0xB7, 0xC4, 0xD2, 0x22, + 0x2B, 0xBC, 0xB0, 0xBF, 0x7D, 0xB1, 0x36, 0x68, + 0xDD, 0x70, 0x1B, 0xD6, 0x48, 0x03, 0xB2, 0x4B, + 0x9C, 0x6D, 0x73, 0x66, 0x41, 0x9F, 0xBD, 0x57 + }, + { + 0x6B, 0xA4, 0x90, 0x98, 0xA5, 0x71, 0x48, 0x54, + 0x2E, 0x0E, 0x60, 0xD9, 0x45, 0xD1, 0xF6, 0xED, + 0x60, 0xF6, 0x78, 0xE1, 0x14, 0xA2, 0x9A, 0xAE, + 0x54, 0x30, 0xC2, 0xD9, 0xAA, 0xAA, 0xC8, 0x66 + }, + { + 0x6F, 0xEC, 0xB4, 0xB8, 0x2D, 0x44, 0xD9, 0x59, + 0x79, 0x91, 0x11, 0xC3, 0x43, 0x14, 0x11, 0x33, + 0x8E, 0xE1, 0x50, 0xD8, 0x4B, 0x5F, 0xE5, 0x59, + 0xE7, 0xD2, 0x2B, 0xE2, 0x1F, 0xC2, 0xF2, 0xF3 + }, + { + 0x5A, 0xD1, 0xBC, 0x80, 0x2E, 0xA7, 0x4B, 0x8D, + 0x89, 0x2B, 0x99, 0x5A, 0x00, 0x5A, 0xC1, 0xEB, + 0x2E, 0xE5, 0x34, 0xA6, 0xCD, 0xF5, 0xF4, 0xF1, + 0xEB, 0x20, 0x5C, 0x76, 0x36, 0x95, 0x1F, 0xCD + }, + { + 0x19, 0xB7, 0x61, 0x82, 0xB6, 0x8A, 0xC9, 0x87, + 0x7B, 0xD8, 0x6A, 0xE4, 0x80, 0x56, 0xA4, 0x84, + 0x30, 0x60, 0xAA, 0x5F, 0x84, 0xEA, 0xE2, 0x37, + 0x0F, 0x38, 0x18, 0xC8, 0x59, 0x1C, 0x27, 0xE0 + }, + { + 0xE3, 0x0D, 0x86, 0xEA, 0xFA, 0xF0, 0x5C, 0xBD, + 0xA5, 0x50, 0x2A, 0xD1, 0x66, 0x26, 0x9C, 0x7C, + 0x72, 0x22, 0x25, 0x32, 0xB3, 0xD0, 0x94, 0x95, + 0x76, 0xB8, 0x92, 0x7A, 0xAE, 0x53, 0x6C, 0xC0 + }, + { + 0xE1, 0x49, 0x14, 0xD8, 0x11, 0xBB, 0xF0, 0xBB, + 0xC8, 0xCD, 0x8D, 0xE4, 0x46, 0x2F, 0x0E, 0x27, + 0xF9, 0x0A, 0xAF, 0xB8, 0x37, 0x52, 0xB1, 0xA8, + 0x55, 0x7B, 0x43, 0xD6, 0x75, 0x00, 0x55, 0x2E + }, + { + 0x5A, 0x50, 0x27, 0x07, 0xE0, 0x02, 0x5C, 0x62, + 0x08, 0x9A, 0xF3, 0x97, 0xD8, 0xD3, 0x1A, 0x05, + 0x6C, 0x28, 0xD1, 0x56, 0x49, 0xA0, 0x7E, 0x23, + 0x15, 0xFD, 0x3C, 0xDA, 0x39, 0x5E, 0x6E, 0x6A + }, + { + 0xBC, 0x23, 0x49, 0x5F, 0x59, 0x72, 0x0D, 0x4B, + 0x17, 0xF1, 0x84, 0x9F, 0x6E, 0xF0, 0x94, 0x6F, + 0x66, 0x03, 0x15, 0x18, 0x28, 0x45, 0x0E, 0x07, + 0x10, 0x8D, 0x71, 0x78, 0x51, 0x11, 0x96, 0x72 + }, + { + 0x0B, 0xAB, 0x04, 0x48, 0x80, 0xC3, 0xDB, 0xB8, + 0x92, 0x00, 0xA0, 0xEE, 0x72, 0xFD, 0xE1, 0x9A, + 0xD2, 0xBE, 0xE8, 0xD9, 0x49, 0xDA, 0x48, 0xBF, + 0x18, 0x6F, 0xE7, 0x43, 0x19, 0x5F, 0x6F, 0x3F + }, + { + 0xA4, 0xA5, 0x82, 0x4A, 0xEC, 0xEC, 0x4E, 0x2B, + 0x19, 0x83, 0x04, 0xC0, 0x19, 0x2B, 0x4E, 0x83, + 0x00, 0xC9, 0xDF, 0x05, 0xA0, 0x7C, 0x05, 0x65, + 0xA4, 0x5F, 0xC4, 0x66, 0xB6, 0x20, 0xE3, 0xC9 + }, + { + 0xD4, 0xA6, 0xB6, 0xDA, 0xA6, 0x65, 0x23, 0xF3, + 0x22, 0xF4, 0x67, 0x78, 0x69, 0x30, 0x9A, 0x10, + 0x6D, 0x8E, 0x6B, 0xB1, 0xDB, 0x1C, 0x79, 0x00, + 0x13, 0xFD, 0x02, 0x8F, 0x12, 0xB5, 0xEE, 0x76 + }, + { + 0x8C, 0x2C, 0xD0, 0xEB, 0x81, 0xC6, 0x0E, 0xFA, + 0x09, 0xBA, 0xF6, 0x45, 0xE4, 0xB2, 0xD7, 0x02, + 0x3D, 0x0A, 0x01, 0xEE, 0xA0, 0xDB, 0x8A, 0x41, + 0xCC, 0x6B, 0x51, 0x79, 0x0E, 0x85, 0x2E, 0xA7 + }, + { + 0xBB, 0xC0, 0xCF, 0x8B, 0xA7, 0xB8, 0xDE, 0xBD, + 0x96, 0x91, 0x61, 0x16, 0xC5, 0x16, 0x1D, 0xA4, + 0x58, 0x77, 0x4A, 0xD5, 0x62, 0x1D, 0x04, 0x05, + 0x2C, 0xCF, 0x8C, 0x48, 0xB2, 0x10, 0x3D, 0xE9 + }, + { + 0x91, 0x0E, 0x9F, 0x3D, 0x89, 0x4D, 0x27, 0xF8, + 0x27, 0x07, 0x4E, 0x57, 0x97, 0x96, 0x6F, 0x90, + 0x70, 0x9A, 0x97, 0xEA, 0xA0, 0x97, 0x03, 0x28, + 0x1F, 0x99, 0x6D, 0x30, 0x93, 0x85, 0xB2, 0x58 + }, + { + 0xFA, 0x20, 0x85, 0xE8, 0xE5, 0x7E, 0xA1, 0x75, + 0x89, 0x86, 0xCB, 0x34, 0xD3, 0x65, 0x96, 0x99, + 0xE2, 0x97, 0xB5, 0x58, 0x18, 0x9D, 0x7B, 0x94, + 0x0A, 0x9D, 0x1B, 0x5A, 0x38, 0xE6, 0x6B, 0xE1 + }, + { + 0x8F, 0x8A, 0xAB, 0xF6, 0x6F, 0x3C, 0x59, 0x61, + 0x1E, 0x71, 0xBF, 0xB9, 0xEE, 0xA1, 0x75, 0x93, + 0x36, 0x9E, 0xBD, 0xEE, 0x26, 0x8F, 0x38, 0x81, + 0x65, 0xB0, 0x01, 0xFC, 0x73, 0xD0, 0xE2, 0x5A + }, + { + 0xA6, 0x05, 0x76, 0x47, 0xEB, 0xC2, 0xCD, 0x79, + 0x02, 0x14, 0xC0, 0x35, 0x60, 0xAD, 0x53, 0xCA, + 0x76, 0xDC, 0x1D, 0x4E, 0x9A, 0xC3, 0xC2, 0x59, + 0xD6, 0x40, 0x65, 0x10, 0xF2, 0x42, 0x8B, 0xB3 + }, + { + 0x04, 0x72, 0x7F, 0x58, 0xD9, 0x8F, 0xDE, 0x34, + 0x1E, 0x1E, 0xC5, 0x2E, 0x06, 0x60, 0x00, 0x23, + 0x8F, 0x3A, 0xEA, 0xB9, 0xB9, 0xA3, 0x83, 0x73, + 0x1B, 0xAC, 0x13, 0x48, 0x51, 0xC2, 0xB4, 0x05 + }, + { + 0xCF, 0x3B, 0x23, 0x91, 0xF0, 0x8F, 0x40, 0x37, + 0x4F, 0x6E, 0x41, 0x24, 0xE5, 0x72, 0xF2, 0x4C, + 0x97, 0x8A, 0x21, 0x98, 0xD5, 0x83, 0x9C, 0xEF, + 0x03, 0xEC, 0x0E, 0x64, 0x8B, 0x00, 0x1F, 0x80 + }, + { + 0xC9, 0xCB, 0xC3, 0xC1, 0xF7, 0x60, 0x78, 0x7A, + 0x17, 0x9F, 0x07, 0xC1, 0x95, 0x32, 0x60, 0x13, + 0x04, 0x7F, 0x0B, 0x19, 0x18, 0xE2, 0x3D, 0xFF, + 0xFE, 0x23, 0xF6, 0xC4, 0xC9, 0x45, 0x6F, 0x45 + }, + { + 0x1C, 0xAC, 0x85, 0xB4, 0x45, 0xDF, 0xF5, 0xA1, + 0x9D, 0x9D, 0x0E, 0xEE, 0x13, 0xDF, 0x3D, 0x78, + 0xE9, 0xB3, 0xAC, 0xE7, 0xD2, 0xA8, 0x37, 0x52, + 0xC9, 0x83, 0xEE, 0xB6, 0xC0, 0xAE, 0x38, 0x8C + }, + { + 0xFB, 0x0D, 0x0B, 0x55, 0x3E, 0x3D, 0xF3, 0xFD, + 0x31, 0xCA, 0x3B, 0x7B, 0x49, 0xBB, 0xCE, 0x6C, + 0x2F, 0x17, 0x5E, 0x39, 0x8C, 0x7D, 0x08, 0xA4, + 0x70, 0xD6, 0xA3, 0xB1, 0x0B, 0xB7, 0xE8, 0x58 + }, + { + 0x90, 0xA1, 0x24, 0xC1, 0x3D, 0x2A, 0xB4, 0xAD, + 0x0E, 0xA7, 0xB7, 0x42, 0xF1, 0x14, 0xE3, 0x0F, + 0x02, 0xB4, 0x1A, 0x32, 0x6C, 0xC4, 0x7A, 0xBA, + 0xCC, 0xA7, 0x6A, 0x67, 0x35, 0xFF, 0xBD, 0x15 + }, + { + 0x58, 0x4D, 0x40, 0x30, 0x54, 0xEF, 0x44, 0x42, + 0x85, 0xD4, 0xF1, 0x94, 0x12, 0x58, 0x72, 0xAC, + 0xFD, 0x06, 0x42, 0xD1, 0x51, 0x7B, 0xCF, 0x75, + 0x7C, 0x6B, 0x34, 0x9F, 0x34, 0xD0, 0x02, 0xFE + }, + { + 0xC4, 0x55, 0xC2, 0x43, 0x92, 0x26, 0x8A, 0x8F, + 0xAC, 0x51, 0xF8, 0x28, 0xAE, 0x21, 0x9F, 0xF1, + 0x8E, 0x4F, 0xFD, 0x4C, 0x1B, 0x67, 0xC0, 0xC7, + 0xE3, 0x0E, 0x7E, 0x9F, 0x0F, 0xE3, 0xEF, 0x21 + }, + { + 0x3A, 0xFF, 0xCF, 0xB6, 0xF5, 0xF3, 0x08, 0xAB, + 0xD7, 0xE0, 0x15, 0xB9, 0x26, 0x03, 0x6A, 0x3A, + 0x43, 0xC8, 0x1B, 0xED, 0xFD, 0xCA, 0x67, 0x15, + 0xE3, 0xBC, 0xB2, 0x8B, 0xC9, 0x6A, 0x07, 0x90 + }, + { + 0x6B, 0x1D, 0x31, 0xDD, 0xCC, 0x9F, 0x4D, 0x61, + 0x46, 0x7C, 0xE6, 0xBD, 0x46, 0xE1, 0xAF, 0x66, + 0xC2, 0x83, 0xD7, 0x9D, 0xAB, 0x4E, 0x3B, 0x2D, + 0xC0, 0xDF, 0xAF, 0x72, 0x03, 0x01, 0x85, 0xC1 + }, + { + 0x32, 0xDD, 0x60, 0x4F, 0x6E, 0x0F, 0xFE, 0x0C, + 0xF6, 0x21, 0x88, 0x8B, 0xA1, 0xEB, 0x74, 0x9F, + 0x4E, 0xFB, 0x50, 0x36, 0xDF, 0x13, 0xD6, 0x36, + 0x10, 0x39, 0x0C, 0x4E, 0x79, 0xE2, 0x53, 0x5A + }, + { + 0x30, 0x01, 0xB5, 0x02, 0x08, 0x6C, 0xB7, 0xC1, + 0x76, 0x97, 0xBB, 0x2A, 0x54, 0xC2, 0xA7, 0x7F, + 0x66, 0xDB, 0x56, 0x03, 0xF3, 0x33, 0x1B, 0x7A, + 0x8B, 0x95, 0xDD, 0x09, 0x68, 0x8F, 0x28, 0xD5 + }, + { + 0xFA, 0xD4, 0x32, 0x91, 0xBB, 0xC3, 0xCD, 0x4D, + 0xE9, 0x82, 0xF1, 0x5D, 0x7A, 0x44, 0xEF, 0x2B, + 0x8A, 0x7D, 0x92, 0x0F, 0xEC, 0x11, 0xB3, 0xC9, + 0xF5, 0xD8, 0x10, 0xC2, 0x55, 0x65, 0xE7, 0xE4 + }, + { + 0x55, 0x3F, 0xFA, 0xA7, 0xA0, 0xDC, 0x34, 0x55, + 0x78, 0x1F, 0x76, 0x1C, 0x52, 0xF6, 0x92, 0x51, + 0xC3, 0xC4, 0x12, 0xA5, 0x84, 0xB9, 0xEB, 0x1E, + 0x0B, 0x1D, 0xAC, 0x98, 0x2F, 0xC8, 0xDF, 0xC3 + }, + { + 0xD3, 0x3C, 0x51, 0xCB, 0xD6, 0xEF, 0x44, 0x31, + 0x7E, 0x5E, 0x4A, 0x3F, 0xFE, 0x13, 0x0B, 0x98, + 0x15, 0xE5, 0x72, 0xD6, 0xA3, 0x53, 0x35, 0x33, + 0x8D, 0x7C, 0x35, 0xA4, 0x1A, 0x00, 0xB5, 0x73 + }, + { + 0xEC, 0xFE, 0x05, 0x59, 0xAD, 0x43, 0x86, 0x8B, + 0xA9, 0xEC, 0x4B, 0x45, 0xC9, 0xEC, 0x96, 0xA9, + 0xB4, 0x78, 0x54, 0x1D, 0xD6, 0x96, 0x35, 0x97, + 0x26, 0x2F, 0x22, 0x10, 0x58, 0x4D, 0x87, 0xFB + }, + { + 0x56, 0xA0, 0xF2, 0x3C, 0x58, 0x2E, 0xAE, 0x22, + 0x07, 0xE6, 0x01, 0x87, 0x15, 0x66, 0x33, 0x5B, + 0x4E, 0x0B, 0xF9, 0xF5, 0x5B, 0xD7, 0x74, 0x81, + 0xE2, 0x6E, 0xE7, 0x00, 0x57, 0x1F, 0x6C, 0xD5 + }, + { + 0x24, 0x2C, 0x2C, 0x11, 0x14, 0x6D, 0xC7, 0x1A, + 0x3D, 0x31, 0xB2, 0x20, 0x2C, 0x6C, 0x75, 0xCC, + 0x51, 0x32, 0x83, 0xDC, 0xD6, 0xE7, 0xAC, 0x97, + 0x87, 0x70, 0x13, 0xD7, 0xB6, 0xD7, 0xEB, 0x30 + }, + { + 0xDF, 0xA7, 0xB2, 0x9B, 0x82, 0x90, 0x76, 0x71, + 0xC7, 0x39, 0x9B, 0x43, 0xD4, 0x51, 0xD4, 0xD6, + 0x4F, 0xE9, 0x83, 0x35, 0x09, 0x5A, 0x10, 0xD7, + 0x2E, 0x38, 0xF9, 0x4C, 0xC6, 0xB6, 0xD9, 0xFF + }, + { + 0xF2, 0xA0, 0x70, 0x27, 0x26, 0x38, 0x4A, 0x0D, + 0x9C, 0xE3, 0xA5, 0x87, 0x3B, 0x0F, 0xF0, 0xC6, + 0x63, 0xCA, 0x87, 0xBF, 0xB4, 0x9E, 0xBF, 0xDC, + 0xF3, 0xCF, 0xB6, 0x32, 0xA4, 0x8A, 0xC4, 0x52 + }, + { + 0x9D, 0xDE, 0x5A, 0x73, 0x32, 0x1D, 0xF8, 0x8C, + 0x63, 0x0C, 0xC6, 0x30, 0xA4, 0x25, 0x6C, 0x85, + 0x26, 0x5E, 0xAA, 0xEE, 0xB4, 0x46, 0xD6, 0x70, + 0x80, 0x6E, 0x33, 0xC0, 0xBD, 0x99, 0x61, 0x8B + }, + { + 0x9B, 0x73, 0x19, 0x8F, 0xAE, 0x99, 0x35, 0x7F, + 0xD2, 0xF1, 0x27, 0xE1, 0x18, 0x54, 0x88, 0xFC, + 0x77, 0x04, 0xD4, 0x59, 0x5D, 0x34, 0xD6, 0x87, + 0xED, 0xDE, 0x1D, 0x6D, 0xCC, 0xD2, 0x57, 0x79 + }, + { + 0x95, 0x2F, 0xA9, 0x68, 0x88, 0x9A, 0x0B, 0x36, + 0x65, 0xA5, 0x31, 0xC5, 0xAE, 0xAF, 0xD9, 0x25, + 0xEA, 0x64, 0x76, 0x8F, 0xB7, 0xE3, 0x81, 0xF8, + 0xB6, 0xD3, 0x81, 0x2F, 0x3E, 0x94, 0x1F, 0xF5 + }, + { + 0x73, 0x55, 0x9E, 0x10, 0x14, 0x4D, 0x03, 0x25, + 0x16, 0x93, 0xAA, 0x30, 0x1E, 0x5D, 0x66, 0xEF, + 0x4F, 0x1F, 0x35, 0xB6, 0x38, 0xB1, 0x6B, 0x7B, + 0x78, 0x41, 0xD9, 0x88, 0x17, 0xBB, 0x21, 0xD6 + }, + { + 0x66, 0x8C, 0x79, 0x94, 0xBD, 0xDE, 0x54, 0xB1, + 0x58, 0x22, 0xB3, 0xF0, 0x02, 0x8B, 0xCA, 0x4C, + 0x87, 0x67, 0xF6, 0x49, 0xCD, 0x31, 0x04, 0x4B, + 0xB6, 0x34, 0xCB, 0xB8, 0x83, 0x0C, 0xEF, 0x64 + }, + { + 0xFB, 0x2C, 0xF6, 0x32, 0x70, 0xA8, 0xD5, 0x6A, + 0x29, 0xC0, 0x53, 0x79, 0x8E, 0x28, 0x92, 0x4A, + 0x6D, 0x77, 0xE6, 0x4B, 0xEE, 0xA1, 0x51, 0x9C, + 0xDD, 0xCC, 0xE5, 0x3D, 0x7A, 0x31, 0x6D, 0xFC + }, + { + 0x83, 0x04, 0xBC, 0x1A, 0x49, 0xEE, 0xDF, 0x5B, + 0x66, 0x21, 0x26, 0xF2, 0xB2, 0x0B, 0xA8, 0x10, + 0x60, 0x50, 0x91, 0x03, 0xC8, 0xAF, 0x6A, 0x39, + 0x32, 0x17, 0x93, 0x55, 0xD9, 0x77, 0x02, 0x88 + }, + { + 0x6D, 0x6D, 0x65, 0x53, 0x44, 0xAE, 0x07, 0xC8, + 0xE1, 0x16, 0x0E, 0x0E, 0x69, 0xBC, 0xB5, 0x54, + 0x53, 0xF6, 0xC9, 0xB2, 0xB3, 0x31, 0xEF, 0x24, + 0xEB, 0xB7, 0xCF, 0x13, 0x39, 0xFB, 0xD0, 0xDD + }, + { + 0x8C, 0xC1, 0x01, 0x7E, 0x7A, 0xED, 0xB4, 0x48, + 0x95, 0xCD, 0x69, 0xCA, 0x9E, 0x4F, 0xE6, 0xAE, + 0x49, 0x2E, 0x35, 0x85, 0xF3, 0x5A, 0xAD, 0xC1, + 0x76, 0x94, 0x7A, 0x45, 0x17, 0x1F, 0x36, 0x64 + }, + { + 0xAD, 0x31, 0x65, 0x69, 0x71, 0x50, 0x4D, 0x15, + 0x5C, 0xD5, 0xFC, 0x45, 0x85, 0x5B, 0xA5, 0xE6, + 0x51, 0xD4, 0xDE, 0x7D, 0xC9, 0x79, 0x08, 0x07, + 0x38, 0x50, 0x94, 0xE9, 0x5F, 0xE5, 0x31, 0xC6 + }, + { + 0xC3, 0x30, 0x38, 0xC9, 0x2F, 0x21, 0xDC, 0xBA, + 0xAA, 0x7D, 0x87, 0xB5, 0x77, 0x86, 0xA1, 0x38, + 0x0F, 0x7F, 0x38, 0x48, 0x2E, 0x70, 0x03, 0x32, + 0x8F, 0x5A, 0x5C, 0xCA, 0xA9, 0x2D, 0x31, 0xD2 + }, + { + 0xF1, 0xBD, 0x5B, 0xB6, 0xE0, 0x27, 0x80, 0xFE, + 0xBA, 0xA5, 0xF1, 0x17, 0x33, 0x69, 0x99, 0x0A, + 0x0B, 0x9B, 0xBF, 0xCF, 0x2A, 0xC2, 0x5E, 0x1B, + 0x97, 0xE4, 0x38, 0xAA, 0x74, 0x49, 0x9D, 0xA6 + }, + { + 0x89, 0xF6, 0x8B, 0xDB, 0x5A, 0x99, 0x3E, 0x30, + 0xBA, 0x8C, 0xF9, 0xC1, 0x26, 0xDB, 0x54, 0x16, + 0x0D, 0x2C, 0xB5, 0x48, 0x38, 0x47, 0xA8, 0xCB, + 0xC0, 0xA8, 0xA9, 0x67, 0xB0, 0x77, 0x35, 0x5E + }, + { + 0x0C, 0x48, 0xBB, 0xFE, 0xA7, 0x4D, 0xEF, 0x2E, + 0x11, 0x16, 0xB0, 0x01, 0x51, 0xA4, 0x0F, 0x5C, + 0xAF, 0xB4, 0x8E, 0x09, 0x17, 0x6C, 0x67, 0x8E, + 0x08, 0x85, 0x08, 0x64, 0xB4, 0x3B, 0x95, 0x9C + }, + { + 0xE1, 0x29, 0x16, 0x6E, 0xF2, 0xDA, 0x3F, 0x40, + 0x60, 0xE0, 0xAF, 0x41, 0x83, 0x5F, 0xF7, 0x3D, + 0x61, 0x97, 0x5F, 0xF3, 0x0A, 0xC1, 0xAE, 0xFD, + 0x49, 0x83, 0xA9, 0x27, 0xA5, 0x49, 0xAB, 0xAE + }, + { + 0xE5, 0x85, 0xA5, 0x6B, 0xD0, 0x85, 0x93, 0xE1, + 0x4C, 0x83, 0x3D, 0x77, 0x51, 0xF6, 0x52, 0x70, + 0x67, 0x6C, 0xBE, 0x39, 0xAB, 0x27, 0xA2, 0x18, + 0x81, 0x10, 0x4E, 0x35, 0x11, 0x99, 0x94, 0x1E + }, + { + 0xA3, 0x30, 0xD1, 0x2C, 0xFF, 0x24, 0xD1, 0x1A, + 0x3F, 0xB2, 0x87, 0x8E, 0xBA, 0x44, 0x31, 0x35, + 0x51, 0xE2, 0x72, 0xCF, 0xE4, 0xE7, 0x68, 0xA0, + 0xFA, 0x53, 0x3B, 0xB7, 0x88, 0x37, 0x98, 0xA9 + }, + { + 0xC0, 0x0B, 0xA8, 0x1A, 0x13, 0x5A, 0xCD, 0x7D, + 0x3E, 0x3A, 0x7F, 0xCD, 0x51, 0x17, 0x72, 0xD9, + 0x4A, 0x36, 0x9D, 0x77, 0x2B, 0xA6, 0xFA, 0x2C, + 0xD7, 0x87, 0x57, 0x71, 0xD4, 0xD0, 0x2B, 0x3E + }, + { + 0x66, 0x0B, 0xE6, 0x02, 0x8E, 0xD7, 0x84, 0x94, + 0x75, 0x25, 0x96, 0xC5, 0x3A, 0x30, 0x42, 0x18, + 0x8E, 0xF9, 0x3C, 0x53, 0x7A, 0x48, 0x39, 0xC8, + 0xCA, 0x0B, 0xD8, 0x95, 0x32, 0x4B, 0xED, 0x49 + }, + { + 0xE1, 0xD6, 0x5F, 0xF6, 0xC5, 0xBA, 0x0C, 0x84, + 0x56, 0xE8, 0xD5, 0xBC, 0x0A, 0xF4, 0x28, 0x0E, + 0x0B, 0x48, 0x1F, 0x87, 0x35, 0xC9, 0xAB, 0xFD, + 0x5A, 0x4F, 0x31, 0x2C, 0x81, 0x82, 0x1E, 0xAE + }, + { + 0x32, 0xA5, 0x90, 0x2D, 0xC7, 0x74, 0xA4, 0xD7, + 0xDC, 0x3E, 0xB0, 0x1B, 0x22, 0x53, 0xFD, 0xA4, + 0x17, 0x8E, 0x41, 0x5D, 0xDE, 0x65, 0xBA, 0x54, + 0xDA, 0xEF, 0xCF, 0x5F, 0x4A, 0x6F, 0x0F, 0xE5 + }, + { + 0x44, 0xC7, 0x98, 0xB7, 0xEC, 0x54, 0xDA, 0x25, + 0x98, 0x9D, 0x65, 0x88, 0x5A, 0x59, 0xA7, 0x66, + 0x48, 0x1E, 0x22, 0xCA, 0xB6, 0x7A, 0x5C, 0x3A, + 0x39, 0xF5, 0x2A, 0x1B, 0xBF, 0x8F, 0x27, 0x40 + }, + { + 0xF1, 0x3D, 0x1B, 0x3B, 0xA5, 0xA2, 0xBC, 0x76, + 0x16, 0xDB, 0xFF, 0x47, 0xB4, 0xDB, 0x84, 0x9F, + 0x13, 0x14, 0xDB, 0x1A, 0xD5, 0x2E, 0xEB, 0x3B, + 0x01, 0x0A, 0x76, 0xEB, 0xC3, 0x66, 0xE9, 0x3D + }, + { + 0x5F, 0xE3, 0x9D, 0xD6, 0xC2, 0xFE, 0x42, 0x79, + 0x2F, 0x11, 0xB1, 0xDC, 0x7C, 0xC5, 0x4F, 0x04, + 0xC0, 0x8A, 0x61, 0x7C, 0x8D, 0xDC, 0x9B, 0xEE, + 0x48, 0x74, 0xF2, 0x48, 0x8B, 0x97, 0xD2, 0x09 + }, + { + 0x4E, 0xD3, 0xCA, 0x25, 0xE7, 0x27, 0xDC, 0x54, + 0x5C, 0x71, 0x14, 0xD0, 0x41, 0x65, 0x16, 0xF5, + 0x3F, 0x2D, 0xFF, 0x2F, 0xD0, 0x22, 0x3C, 0xB7, + 0x17, 0xE7, 0x02, 0x38, 0xCF, 0x84, 0x6E, 0x76 + }, + { + 0xC2, 0xF9, 0x65, 0xC0, 0xE3, 0xEA, 0xBE, 0x3A, + 0x85, 0x0F, 0x26, 0xF6, 0x72, 0xFD, 0x2D, 0xAE, + 0x22, 0xE8, 0xDD, 0xD4, 0x3A, 0x6B, 0x78, 0x4E, + 0x1A, 0x4F, 0x57, 0x00, 0x3D, 0x06, 0x9B, 0xA2 + }, + { + 0xA0, 0x48, 0xD6, 0x7D, 0xD0, 0xAD, 0x75, 0xDE, + 0x5F, 0x02, 0xF1, 0x21, 0x45, 0x18, 0x46, 0x1C, + 0x9A, 0x68, 0xB4, 0xE4, 0x49, 0xBD, 0x1F, 0x27, + 0xD6, 0xF6, 0xAE, 0x5A, 0xCA, 0x61, 0x13, 0xA0 + }, + { + 0x90, 0x1A, 0xC5, 0x79, 0xD1, 0x60, 0xEE, 0x60, + 0x42, 0x6B, 0xCB, 0x09, 0xAC, 0x5F, 0x6C, 0x0A, + 0xA4, 0x42, 0xC3, 0xC1, 0x57, 0x94, 0x9B, 0x85, + 0xA6, 0xDC, 0xCF, 0x6C, 0xC5, 0x1B, 0x6D, 0x00 + }, + { + 0x8F, 0x43, 0x4E, 0x05, 0xEE, 0x9C, 0x7D, 0xD2, + 0xE4, 0x9F, 0x87, 0x4E, 0x4A, 0xDB, 0x76, 0x81, + 0x73, 0x01, 0xE5, 0x69, 0xA2, 0xC4, 0x95, 0x26, + 0xB7, 0x37, 0xFC, 0x23, 0xFB, 0x36, 0xDC, 0x52 + }, + { + 0xBE, 0x52, 0x57, 0x8B, 0xA3, 0x4C, 0x82, 0xA9, + 0xBE, 0xF8, 0x92, 0xA3, 0xF6, 0x8E, 0x03, 0x7F, + 0x0F, 0xB9, 0x8F, 0xE6, 0xB1, 0x9C, 0xC0, 0x74, + 0x4F, 0xE8, 0xB3, 0x2A, 0x05, 0x73, 0x08, 0x4F + }, + { + 0x6B, 0x71, 0xA7, 0xDF, 0x97, 0x85, 0x3E, 0xA2, + 0x4B, 0xA0, 0x0F, 0x39, 0x1D, 0x8C, 0xC7, 0x9E, + 0x6C, 0xD6, 0xB0, 0x6C, 0x6C, 0xFF, 0xAC, 0x0D, + 0x54, 0x81, 0x1B, 0x69, 0x77, 0xF0, 0xAE, 0xB2 + }, + { + 0xC5, 0x53, 0xD8, 0xA1, 0xCD, 0x5D, 0x7D, 0xA0, + 0xE0, 0x1A, 0x06, 0xA9, 0x37, 0x98, 0x75, 0x61, + 0x7D, 0x31, 0x9A, 0x73, 0x15, 0xEC, 0x95, 0x1C, + 0xE3, 0x28, 0xEB, 0x63, 0x9E, 0xDA, 0x49, 0xF3 + }, + { + 0x2C, 0x46, 0xA0, 0x5C, 0x5C, 0xF9, 0x20, 0xBB, + 0x78, 0x20, 0x42, 0xCA, 0x7E, 0x34, 0xD0, 0xED, + 0x19, 0x1A, 0x68, 0x9E, 0xE4, 0xEE, 0xF9, 0x0A, + 0x96, 0xCA, 0x1A, 0x95, 0x02, 0x66, 0x50, 0x23 + }, + { + 0xB3, 0x2E, 0x44, 0xD4, 0xE7, 0xE8, 0xBA, 0xE9, + 0x0E, 0x65, 0x75, 0xDA, 0xDE, 0xFC, 0xF2, 0xB2, + 0xEA, 0x43, 0xFE, 0x3A, 0x1B, 0x97, 0x1D, 0xBB, + 0xA6, 0x23, 0xC0, 0x25, 0xF5, 0x15, 0x86, 0x08 + }, + { + 0xFA, 0xF7, 0x98, 0x56, 0x6F, 0xFC, 0x6A, 0x08, + 0x68, 0x3C, 0x81, 0x07, 0x7A, 0x0C, 0x0D, 0x00, + 0xF2, 0x88, 0x62, 0x1B, 0x3E, 0xFD, 0x83, 0x14, + 0xA2, 0x59, 0xC7, 0xFE, 0x6F, 0x00, 0x4F, 0x73 + }, + { + 0xCA, 0xDA, 0xC4, 0xF1, 0xBE, 0xFA, 0x6D, 0xE5, + 0x36, 0xDC, 0x23, 0x73, 0x7B, 0x7C, 0x18, 0xAB, + 0x4D, 0x3E, 0x62, 0x84, 0xB8, 0x3F, 0x34, 0xA8, + 0x7F, 0x6B, 0x11, 0xBC, 0x84, 0xEC, 0xB4, 0xD0 + }, + { + 0x86, 0xDA, 0xDE, 0x53, 0x0A, 0x18, 0x01, 0xCC, + 0x9A, 0x00, 0xF5, 0xE1, 0x10, 0x3E, 0x1B, 0x0F, + 0xAE, 0xD3, 0x4E, 0x0E, 0xA6, 0x09, 0x64, 0x98, + 0xB8, 0x65, 0xB4, 0xBE, 0x69, 0x5F, 0xDE, 0xBB + }, + { + 0xDE, 0xFF, 0x04, 0x68, 0xF4, 0xFE, 0x98, 0x49, + 0x4B, 0x3F, 0x70, 0xD7, 0x66, 0xB7, 0xD0, 0xC3, + 0x56, 0x72, 0x2C, 0x7E, 0x86, 0x5E, 0x70, 0x2B, + 0xC0, 0x9B, 0xE0, 0x8C, 0x82, 0xAF, 0xAB, 0x85 + }, + { + 0x4F, 0x62, 0xF0, 0x20, 0x39, 0x8F, 0x5A, 0x12, + 0x4D, 0x1F, 0xDC, 0x9C, 0xDE, 0x5C, 0x6D, 0xAF, + 0xE2, 0xA6, 0xA2, 0x8B, 0x3F, 0xDC, 0x42, 0x6E, + 0xEA, 0x66, 0x4F, 0x6F, 0x82, 0x6B, 0xE7, 0xB8 + }, + { + 0xA8, 0xDE, 0xF4, 0xC2, 0xAE, 0xEA, 0x8E, 0xFD, + 0x20, 0xAA, 0x38, 0x70, 0xFD, 0x0C, 0x9D, 0xE5, + 0x6E, 0xAD, 0xAE, 0xCA, 0x70, 0x92, 0x03, 0xF8, + 0xFF, 0xDA, 0xE0, 0x5A, 0x00, 0xA9, 0x9E, 0x38 + }, + { + 0xCF, 0x51, 0xA9, 0xAB, 0x47, 0x04, 0x23, 0x68, + 0x56, 0x0B, 0x25, 0x7A, 0x1D, 0x88, 0x42, 0x1A, + 0xC3, 0x8E, 0x77, 0xC2, 0xA7, 0x45, 0x16, 0x30, + 0x02, 0xA7, 0xF0, 0xE5, 0x32, 0xB2, 0xA5, 0x9E + }, + { + 0xD7, 0xBC, 0x90, 0xD0, 0xAF, 0x24, 0xE6, 0x97, + 0x59, 0xBC, 0x41, 0xCE, 0xFA, 0x8F, 0x83, 0x40, + 0xA4, 0x65, 0xD6, 0x8E, 0x4F, 0x0A, 0x0F, 0x71, + 0xD5, 0xBD, 0xEF, 0x6D, 0x19, 0x53, 0xC2, 0x47 + }, + { + 0xAF, 0x7C, 0x31, 0xA7, 0xB0, 0xC9, 0x48, 0x3A, + 0x38, 0x39, 0xBA, 0x25, 0xDF, 0x37, 0xDF, 0xBB, + 0x8F, 0x20, 0x69, 0x5E, 0x36, 0x73, 0x5B, 0x39, + 0x69, 0xDB, 0xDC, 0xF4, 0xBB, 0x90, 0xF6, 0x51 + }, + { + 0x41, 0x82, 0x46, 0xD1, 0xE4, 0x10, 0x0A, 0x37, + 0x0F, 0x69, 0x4E, 0xD4, 0xAA, 0x1A, 0xB0, 0xAE, + 0xC7, 0x54, 0xC9, 0x34, 0x6F, 0x7D, 0x86, 0xD6, + 0xA1, 0xB9, 0xFF, 0xE7, 0xD2, 0xC6, 0x0F, 0xFB + }, + { + 0x4A, 0x1F, 0x40, 0x62, 0xF5, 0xF8, 0xC5, 0x32, + 0x62, 0x25, 0x35, 0x3B, 0xA7, 0xD2, 0x74, 0xC7, + 0xFD, 0xD4, 0x92, 0xE1, 0x73, 0x60, 0x8B, 0x98, + 0x4A, 0x49, 0xC5, 0x1C, 0x5F, 0xAA, 0x46, 0x81 + }, + { + 0xF7, 0x3F, 0xED, 0xB1, 0x2E, 0xC0, 0x91, 0x2D, + 0x40, 0xB1, 0x39, 0x8F, 0x17, 0xD8, 0xDD, 0x0A, + 0x94, 0xBB, 0xF5, 0x4C, 0xC5, 0xE2, 0x37, 0x81, + 0x50, 0x56, 0xA8, 0x89, 0x91, 0x2C, 0x51, 0xAA + }, + { + 0x8E, 0x91, 0xF6, 0x52, 0x58, 0x06, 0x7A, 0xB1, + 0x5D, 0x2C, 0x45, 0x51, 0x84, 0x8A, 0xD0, 0x75, + 0xBD, 0xC8, 0x46, 0xB4, 0x0D, 0xB8, 0x16, 0x89, + 0x2A, 0xA2, 0xEB, 0x24, 0xE6, 0x77, 0x6F, 0xDB + }, + { + 0xAD, 0x3E, 0xE7, 0x3C, 0x6F, 0xAB, 0x3E, 0xCE, + 0x79, 0xF4, 0xF6, 0x5E, 0x06, 0x82, 0xF3, 0xCA, + 0x2F, 0xED, 0x88, 0x4A, 0xCC, 0x54, 0xA2, 0xA2, + 0xB7, 0xB3, 0x82, 0xD9, 0x78, 0x4E, 0x39, 0xDA + }, + { + 0xB7, 0x76, 0xC8, 0xCA, 0xB7, 0x94, 0xAE, 0xF8, + 0x32, 0x05, 0x11, 0x7A, 0xF4, 0x5A, 0x01, 0x0C, + 0x23, 0xBD, 0xCA, 0x18, 0xD3, 0x70, 0x8D, 0x1B, + 0x5F, 0x3A, 0x71, 0xBF, 0x56, 0xAA, 0xD4, 0xF2 + }, + { + 0x7E, 0x87, 0x04, 0x50, 0x90, 0xE4, 0xEE, 0x8B, + 0xA7, 0x36, 0x97, 0xDE, 0x83, 0x9E, 0x06, 0x4D, + 0xFC, 0xC5, 0x2E, 0x02, 0x1F, 0x06, 0x47, 0x8C, + 0x65, 0x01, 0xA6, 0x32, 0x8F, 0x8D, 0x2B, 0x6E + }, + { + 0x88, 0x9B, 0x6E, 0x18, 0x13, 0x61, 0xBC, 0xF2, + 0x95, 0x9D, 0x1A, 0x6D, 0x4F, 0xA1, 0xB6, 0x7F, + 0xA4, 0x19, 0xAB, 0xD3, 0x36, 0xD0, 0xA5, 0x34, + 0xC7, 0x95, 0xC8, 0x17, 0x01, 0xF3, 0x52, 0x94 + }, + { + 0x19, 0x74, 0x88, 0xC9, 0xFD, 0xE2, 0x00, 0xFA, + 0x8B, 0x1C, 0x07, 0x58, 0x53, 0x86, 0xC9, 0xC1, + 0xED, 0x57, 0xBD, 0x71, 0xFC, 0xC6, 0x57, 0x73, + 0x28, 0xA1, 0xFD, 0xAE, 0x73, 0x94, 0x5F, 0x0F + }, + { + 0xB5, 0xD4, 0x35, 0x04, 0xF8, 0xBF, 0xF8, 0xE5, + 0xF8, 0x96, 0x67, 0xA9, 0x1D, 0x7B, 0xB9, 0x71, + 0xC9, 0x10, 0xBC, 0xAA, 0xCB, 0x53, 0x17, 0x42, + 0xCD, 0x0C, 0x23, 0x59, 0xB5, 0xCD, 0xE8, 0x12 + }, + { + 0x87, 0x84, 0x76, 0x44, 0xA0, 0xC1, 0x56, 0x1B, + 0xC3, 0xF7, 0xA3, 0xFC, 0xC2, 0x18, 0x84, 0xCC, + 0xC2, 0xD4, 0x10, 0x99, 0x14, 0x2F, 0x59, 0xE4, + 0x80, 0xF6, 0x53, 0x28, 0x1E, 0xD9, 0xC0, 0x01 + }, + { + 0xC6, 0x9B, 0xA6, 0x0D, 0x69, 0x00, 0x96, 0xA8, + 0x2F, 0xCE, 0xE1, 0xCE, 0x5A, 0x05, 0x29, 0x70, + 0xC0, 0xAD, 0xEE, 0x6A, 0x47, 0xCE, 0x21, 0xA5, + 0x6A, 0xC9, 0x25, 0x1F, 0xC4, 0x2D, 0x97, 0xF5 + }, + { + 0xC3, 0x00, 0xA5, 0xA7, 0x1F, 0x44, 0x54, 0xD1, + 0x81, 0xDA, 0x84, 0x24, 0x3C, 0xEA, 0xB0, 0xD3, + 0x6E, 0x85, 0x3E, 0x67, 0x26, 0x24, 0xEA, 0xA1, + 0x4A, 0xDF, 0x28, 0x4C, 0xD1, 0xD4, 0x48, 0x21 + }, + { + 0x70, 0xFF, 0x6F, 0x04, 0x1E, 0x91, 0xEE, 0xB2, + 0x4B, 0xEC, 0x16, 0x0E, 0xC2, 0xFF, 0x8E, 0x54, + 0x09, 0xD5, 0x89, 0x64, 0xE2, 0xA4, 0x60, 0xBE, + 0xC5, 0x53, 0x23, 0x2A, 0xB5, 0x5A, 0x19, 0xA2 + }, + { + 0x40, 0x21, 0x76, 0xD2, 0x0B, 0x94, 0x26, 0x4E, + 0xC2, 0xCB, 0x41, 0xEF, 0x78, 0x2A, 0x18, 0x4A, + 0xE9, 0x5F, 0xA8, 0x68, 0x04, 0xD8, 0xAB, 0xCE, + 0xD4, 0xE5, 0x93, 0xEA, 0xAB, 0xB5, 0x8D, 0x9B + }, + { + 0x7A, 0x57, 0xC1, 0xAE, 0x33, 0xE0, 0x79, 0x37, + 0x9F, 0x13, 0x26, 0xBE, 0xC7, 0xEF, 0x10, 0x3E, + 0xC2, 0x8C, 0x80, 0x1A, 0xB2, 0xF1, 0xAF, 0xB0, + 0xA5, 0x65, 0x6C, 0xF0, 0xF3, 0xEF, 0x65, 0x32 + }, + { + 0xD0, 0x9F, 0x8F, 0xF7, 0xCF, 0xF1, 0x13, 0xD9, + 0x2B, 0xA2, 0xCE, 0x42, 0x2E, 0x82, 0xB8, 0x14, + 0x2F, 0x46, 0x24, 0x99, 0xF0, 0x39, 0xCD, 0x59, + 0xDB, 0x6A, 0x72, 0x87, 0x79, 0x21, 0x65, 0x58 + }, + { + 0xF4, 0x37, 0x3F, 0x35, 0x8C, 0xEF, 0x31, 0x07, + 0x46, 0x80, 0x0A, 0xA6, 0x3E, 0x11, 0x11, 0xC3, + 0x95, 0xC6, 0x38, 0x4F, 0xF6, 0x5B, 0x19, 0x77, + 0x22, 0x67, 0x86, 0x8A, 0x73, 0x71, 0x7A, 0x12 + }, + { + 0xE8, 0x3C, 0x86, 0x2C, 0x5C, 0xD3, 0xBD, 0x18, + 0xCE, 0x66, 0x2B, 0xF2, 0x92, 0x1A, 0x5C, 0xCC, + 0x91, 0x6B, 0x2D, 0x6E, 0x5E, 0x5E, 0x12, 0xF2, + 0x0F, 0xCC, 0x3A, 0x49, 0x4F, 0x4C, 0x77, 0xE1 + }, + { + 0x26, 0xD9, 0xDE, 0x64, 0x99, 0x0C, 0xF9, 0x4B, + 0xFC, 0x2A, 0x7F, 0xD3, 0xCC, 0x38, 0xEC, 0x19, + 0xC8, 0xE9, 0xFA, 0x87, 0x41, 0x4C, 0x67, 0xC4, + 0xE5, 0xDF, 0xB1, 0x2F, 0x5D, 0x5B, 0xBC, 0x3F + }, + { + 0xA9, 0x0C, 0x84, 0xA8, 0x66, 0xEC, 0x9C, 0xFD, + 0x54, 0x98, 0x3D, 0x5A, 0x23, 0x87, 0x21, 0xBB, + 0xAF, 0xBF, 0x66, 0xF2, 0x7F, 0xCF, 0x98, 0x39, + 0xD4, 0xE2, 0x76, 0xFA, 0x3B, 0x2D, 0x5F, 0xF8 + }, + { + 0x70, 0x86, 0x2D, 0x6C, 0x13, 0xC4, 0x4F, 0x1D, + 0x17, 0x65, 0xDE, 0x2B, 0xB4, 0x0E, 0x09, 0x29, + 0x01, 0x0A, 0x45, 0xA6, 0x50, 0xD5, 0xF7, 0x37, + 0xF2, 0x91, 0xC6, 0xBE, 0xDE, 0x24, 0x0D, 0x64 + }, + { + 0xEB, 0xBB, 0x22, 0x67, 0x69, 0x71, 0xDE, 0xCD, + 0x47, 0x11, 0xD5, 0x86, 0x25, 0xA0, 0x91, 0x60, + 0xA4, 0xEF, 0x0E, 0x14, 0x23, 0x36, 0x76, 0xD1, + 0xD0, 0x18, 0xAC, 0x1D, 0x75, 0x88, 0x34, 0x70 + }, + { + 0xE5, 0x8E, 0x24, 0x55, 0x6F, 0xF2, 0xF3, 0x65, + 0x5A, 0x26, 0x79, 0xF1, 0x3B, 0x96, 0x14, 0x27, + 0x37, 0xBA, 0x06, 0x28, 0x44, 0xF6, 0x71, 0x34, + 0x20, 0x53, 0x05, 0x22, 0xBF, 0x11, 0x3C, 0x98 + }, + { + 0x1D, 0x3C, 0x2B, 0xCB, 0x49, 0x5A, 0x84, 0xFE, + 0x69, 0xDD, 0x3B, 0xBB, 0x94, 0x2D, 0x4B, 0x8E, + 0xB2, 0x85, 0xEC, 0x0B, 0x70, 0xF2, 0x78, 0xE9, + 0x4D, 0xAE, 0x63, 0x7B, 0xB8, 0x4A, 0x5F, 0x19 + }, + { + 0xDD, 0xA2, 0x04, 0x7D, 0x1B, 0xC5, 0x43, 0x30, + 0xE8, 0xA0, 0x4A, 0xAB, 0x7F, 0x65, 0x96, 0x66, + 0xA2, 0x5F, 0x17, 0xCF, 0xE8, 0xE7, 0xC9, 0x84, + 0x46, 0xAE, 0x9A, 0x83, 0xBD, 0x1B, 0x93, 0x1A + }, + { + 0x68, 0x0B, 0x22, 0x3B, 0xD2, 0xA4, 0x93, 0x8A, + 0x10, 0xB8, 0x51, 0xFA, 0xCF, 0x39, 0xC9, 0x4F, + 0x0D, 0xD5, 0x10, 0x0E, 0xFB, 0x86, 0x46, 0x09, + 0x7B, 0xA1, 0x73, 0x5F, 0xF7, 0xE6, 0x1F, 0x44 + }, + { + 0xEF, 0xFA, 0x55, 0xAF, 0x80, 0x0F, 0xAC, 0x4F, + 0xD4, 0xA9, 0xF0, 0x4C, 0x74, 0x1A, 0x07, 0xF7, + 0x4A, 0x00, 0xFC, 0x4F, 0x55, 0x34, 0x42, 0xCC, + 0xC6, 0x6B, 0x16, 0x9C, 0xAC, 0x01, 0x5C, 0x2C + }, + { + 0xB1, 0x54, 0xD5, 0x63, 0xCE, 0xFB, 0x2F, 0x1A, + 0x74, 0xA0, 0xC4, 0x78, 0x3C, 0x2D, 0xCB, 0x9D, + 0xDD, 0x6E, 0x56, 0x61, 0xA2, 0x13, 0xF1, 0x17, + 0xA1, 0x45, 0x7C, 0x5A, 0x7F, 0xE1, 0x25, 0x6B + }, + { + 0x5A, 0x6D, 0x27, 0xF3, 0xDD, 0xB7, 0xAC, 0x51, + 0x4C, 0x24, 0xC8, 0xDC, 0x94, 0x8F, 0xB3, 0x6B, + 0xD1, 0xC5, 0x75, 0xC0, 0xE9, 0x1C, 0xF4, 0xD5, + 0x2C, 0xC7, 0x21, 0xC8, 0x68, 0xFF, 0x5E, 0x0B + }, + { + 0xA9, 0xD9, 0x78, 0xF4, 0x71, 0xAF, 0xC4, 0x21, + 0x53, 0x56, 0xB2, 0x31, 0xD8, 0x76, 0x85, 0xBD, + 0x14, 0x11, 0x6D, 0x6C, 0x11, 0x50, 0xB7, 0xEE, + 0xBE, 0xDE, 0xDB, 0x61, 0xDD, 0x4F, 0x66, 0x58 + }, + { + 0xD7, 0xFF, 0xE1, 0x14, 0xD4, 0x35, 0x6E, 0x0E, + 0x6E, 0xCA, 0xBB, 0xF4, 0x52, 0x8A, 0xAB, 0xEF, + 0xA4, 0x3A, 0x4E, 0xE6, 0x14, 0x3A, 0x14, 0xAF, + 0x44, 0xFC, 0x36, 0xCB, 0x31, 0x12, 0x4E, 0x4C + }, + { + 0x46, 0xB0, 0x20, 0x2F, 0xBE, 0xEF, 0xD1, 0x32, + 0x3A, 0xA3, 0x48, 0x6A, 0xF5, 0x77, 0x97, 0x77, + 0xED, 0x6B, 0x11, 0xBC, 0xE0, 0x5D, 0x59, 0x44, + 0x0B, 0x9F, 0x30, 0xBB, 0xE4, 0x4C, 0x64, 0xB1 + }, + { + 0xB1, 0x8B, 0x45, 0xA2, 0x85, 0x85, 0x4A, 0x7F, + 0x9F, 0x71, 0x5B, 0x48, 0xF0, 0x5F, 0x87, 0x19, + 0x37, 0x67, 0xDA, 0x34, 0x56, 0x38, 0x78, 0xC0, + 0x05, 0xD4, 0x33, 0xF2, 0xE1, 0x31, 0xB1, 0x0A + }, + { + 0x7C, 0xA6, 0x44, 0x93, 0x3E, 0x54, 0x85, 0x3C, + 0x6C, 0x42, 0x9F, 0x9D, 0x08, 0x66, 0x40, 0x87, + 0xC4, 0xC3, 0x63, 0x5C, 0xF3, 0x15, 0x5D, 0xA5, + 0x5B, 0x41, 0x77, 0x33, 0xAC, 0xC1, 0x52, 0xAC + }, + { + 0x15, 0x59, 0x69, 0x63, 0x6E, 0x9E, 0x07, 0x15, + 0xE8, 0x38, 0xCD, 0x22, 0xE1, 0x34, 0x7C, 0x27, + 0x7D, 0x27, 0x23, 0xC7, 0x8D, 0x6B, 0x52, 0x46, + 0x55, 0x3E, 0x11, 0x6E, 0x80, 0xB9, 0x8C, 0x9D + }, + { + 0x27, 0xF6, 0x3B, 0xAC, 0x08, 0x1E, 0xA2, 0x31, + 0xDE, 0x95, 0x82, 0x61, 0x5B, 0xBB, 0x7E, 0x3E, + 0xE7, 0xF7, 0x90, 0xD1, 0xDF, 0x29, 0x2C, 0x0C, + 0x1A, 0x87, 0xA1, 0x0C, 0x0A, 0x66, 0x5A, 0x04 + }, + { + 0x8D, 0x21, 0x35, 0x8F, 0xDB, 0x1F, 0x61, 0x2F, + 0x28, 0x17, 0xD9, 0x7B, 0xE9, 0xA6, 0xF4, 0xB0, + 0xCD, 0xC3, 0x7E, 0x2B, 0xB8, 0x8C, 0xD7, 0xC6, + 0xB7, 0xF3, 0x97, 0x94, 0x0D, 0x6C, 0x1C, 0x12 + }, + { + 0x55, 0x1C, 0x18, 0x68, 0x7A, 0x17, 0xE8, 0xC8, + 0xA9, 0x79, 0x33, 0xA3, 0x1C, 0xA5, 0x9C, 0xC4, + 0x13, 0x9E, 0x44, 0x5A, 0x42, 0x17, 0xAA, 0x35, + 0x23, 0x1C, 0x72, 0x29, 0xF0, 0x73, 0x09, 0x80 + }, + { + 0x85, 0x29, 0xD6, 0x5F, 0xAF, 0xFC, 0x38, 0x59, + 0xEC, 0x3B, 0x73, 0x28, 0xAB, 0xA6, 0xAE, 0xB9, + 0x82, 0x62, 0x91, 0xB9, 0x86, 0x68, 0xC8, 0x10, + 0xD8, 0x74, 0x06, 0x37, 0x34, 0x85, 0x18, 0x7C + }, + { + 0x8F, 0xCA, 0x7C, 0x11, 0x9A, 0x92, 0xE3, 0x6D, + 0x5A, 0x07, 0x53, 0x98, 0x07, 0xF9, 0x3A, 0x9D, + 0x0C, 0x8C, 0x62, 0x10, 0x06, 0x73, 0x11, 0x97, + 0x9A, 0x75, 0x32, 0x55, 0xEE, 0x5D, 0x7C, 0xEC + }, + { + 0x45, 0x3C, 0xF9, 0x03, 0x72, 0x5D, 0x24, 0xF1, + 0xAE, 0x7A, 0x63, 0x0B, 0xB1, 0x6C, 0xC5, 0xCF, + 0xC1, 0x8C, 0x7A, 0x06, 0x7C, 0xEF, 0xF7, 0x9E, + 0x83, 0x45, 0x26, 0xEB, 0x95, 0x43, 0xBF, 0x7E + }, + { + 0x86, 0x0A, 0x1F, 0x88, 0x83, 0x28, 0x82, 0xD7, + 0xB8, 0xD4, 0x81, 0xD4, 0x55, 0x50, 0x4A, 0xFD, + 0x37, 0x92, 0x7D, 0x67, 0x6B, 0xC0, 0x93, 0xA6, + 0xE2, 0x9B, 0x49, 0x24, 0x00, 0x4A, 0xD7, 0x88 + }, + { + 0xFA, 0xD2, 0xE4, 0x55, 0x3B, 0xD6, 0xED, 0x4C, + 0xDA, 0x66, 0xCE, 0x49, 0x60, 0xAF, 0x3E, 0xA2, + 0xE6, 0x76, 0x83, 0x47, 0xE3, 0xB0, 0x3B, 0x8B, + 0x30, 0x8B, 0x97, 0x81, 0x18, 0x0D, 0x1C, 0xB6 + }, + { + 0xBE, 0x0D, 0x58, 0xE5, 0xBC, 0x08, 0xA8, 0xFA, + 0x63, 0x33, 0x8F, 0xA9, 0xE7, 0x54, 0xEC, 0x08, + 0xCE, 0x57, 0x40, 0x6D, 0xDC, 0xDD, 0xB1, 0x13, + 0x73, 0x69, 0xA8, 0x1B, 0x24, 0x59, 0xED, 0x1F + }, + { + 0x32, 0xAA, 0x32, 0x48, 0x3D, 0x24, 0x51, 0x5C, + 0xA6, 0x93, 0x5C, 0x95, 0x90, 0x9D, 0xE9, 0xFA, + 0x9A, 0x8C, 0x27, 0x64, 0xCF, 0x29, 0x56, 0x04, + 0x88, 0xC8, 0x45, 0xB7, 0xCB, 0x10, 0xD7, 0x9A + }, + { + 0x7A, 0xEB, 0xD7, 0x58, 0xA2, 0x59, 0x28, 0x74, + 0xF4, 0xF6, 0x5C, 0x38, 0x84, 0xD3, 0xA6, 0xA8, + 0x8D, 0x6E, 0x49, 0xC9, 0x21, 0xF5, 0xC7, 0x79, + 0xCC, 0xB5, 0x78, 0x66, 0xF1, 0x00, 0xE7, 0xE5 + }, + { + 0x12, 0x77, 0x37, 0xE9, 0x96, 0xE4, 0x13, 0xDD, + 0x72, 0xD1, 0xEB, 0x95, 0xE2, 0x97, 0xC2, 0x80, + 0xE1, 0xF4, 0x8E, 0xEB, 0x17, 0xBC, 0x71, 0x44, + 0xA3, 0xC3, 0xBC, 0x0F, 0x45, 0x50, 0xFA, 0x3D + }, + { + 0x9F, 0xD2, 0xC0, 0x5E, 0xF8, 0x75, 0x68, 0xFB, + 0x24, 0x09, 0x0F, 0x5D, 0x5B, 0xDC, 0x56, 0x19, + 0x4F, 0xA5, 0x87, 0x81, 0x68, 0x6A, 0xE6, 0xC4, + 0xAC, 0x54, 0xD8, 0x3A, 0x22, 0x87, 0x7A, 0x15 + }, + { + 0x04, 0x43, 0xC9, 0x96, 0xEE, 0xE8, 0x7E, 0x43, + 0x7E, 0x9F, 0xD0, 0x81, 0x5E, 0xFF, 0xBB, 0xEE, + 0xF8, 0x0E, 0x71, 0x1E, 0x2F, 0x1B, 0xBD, 0xAD, + 0xC3, 0xE5, 0x99, 0x39, 0x0E, 0x58, 0x23, 0x4F + }, + { + 0x3B, 0x6C, 0xDB, 0xDD, 0x42, 0x10, 0x7F, 0x05, + 0xA2, 0xDE, 0x41, 0xE8, 0x6C, 0x89, 0xE7, 0x63, + 0xA2, 0x05, 0xD3, 0xB8, 0x93, 0x41, 0x4B, 0xB8, + 0x66, 0x67, 0x74, 0x96, 0xAF, 0xC4, 0x8B, 0x99 + }, + { + 0xE8, 0xDE, 0x77, 0x06, 0xAE, 0x4E, 0x86, 0x80, + 0x81, 0x64, 0xA8, 0xEF, 0x51, 0xF3, 0x42, 0x41, + 0x84, 0xF6, 0x6A, 0x65, 0x4F, 0xC1, 0x5C, 0xD9, + 0x31, 0xB7, 0x37, 0x24, 0x9B, 0x31, 0x5B, 0x72 + }, + { + 0x5F, 0x28, 0xAD, 0x6C, 0xF4, 0x70, 0x9A, 0x85, + 0x91, 0xE1, 0x1F, 0x13, 0x39, 0xA8, 0xE6, 0xC2, + 0xD8, 0xC8, 0xB9, 0xAC, 0xB6, 0x68, 0xBF, 0xFF, + 0x9F, 0x36, 0x25, 0x7F, 0x24, 0x40, 0xCC, 0x03 + }, + { + 0x93, 0x5D, 0xC0, 0x89, 0x4D, 0xD6, 0xD4, 0xE8, + 0xAA, 0x76, 0xED, 0x46, 0xA0, 0xB6, 0xCF, 0x4B, + 0xC3, 0x61, 0x5F, 0xE9, 0xC9, 0x60, 0xF5, 0x89, + 0xF8, 0xC3, 0x5F, 0xC4, 0xD4, 0xAA, 0x8A, 0x1A + }, + { + 0xB5, 0xEC, 0x61, 0x14, 0x1E, 0xE6, 0x3F, 0xC9, + 0x5D, 0x07, 0x95, 0x84, 0x13, 0x87, 0xB9, 0xCD, + 0xE4, 0xCE, 0x84, 0x05, 0x0C, 0x12, 0x6A, 0xAB, + 0x9E, 0xE5, 0xC1, 0x5B, 0xB4, 0xBD, 0x6A, 0x14 + }, + { + 0x1A, 0x30, 0x3A, 0x3F, 0xCE, 0xCC, 0x24, 0x78, + 0xB5, 0x38, 0xDD, 0x1E, 0xC9, 0x12, 0x01, 0x68, + 0x9B, 0xD2, 0x28, 0xE1, 0x86, 0x82, 0xC3, 0x80, + 0x99, 0x90, 0xC7, 0x07, 0x02, 0x7A, 0xA6, 0x6F + }, + { + 0x68, 0x31, 0x3B, 0xEC, 0x41, 0x55, 0xFD, 0xFF, + 0xDB, 0x25, 0x07, 0xD4, 0x7C, 0x41, 0x2E, 0x9F, + 0xAD, 0xF3, 0xAF, 0x2D, 0x39, 0xA4, 0xDB, 0xA7, + 0x9E, 0x92, 0x2D, 0xE0, 0xC6, 0x76, 0x31, 0x90 + }, + { + 0xB1, 0x28, 0xCE, 0x0D, 0xF8, 0x1C, 0x99, 0x81, + 0x45, 0x89, 0xEE, 0x86, 0x3B, 0x51, 0x9B, 0x30, + 0x98, 0x0E, 0x40, 0x25, 0x3D, 0x4A, 0xF1, 0xD5, + 0x87, 0xE6, 0x43, 0x9A, 0x61, 0x24, 0x62, 0x45 + }, + { + 0xE6, 0x94, 0x7B, 0x07, 0xD0, 0xDB, 0xB8, 0x8C, + 0xBD, 0xC2, 0xE5, 0x11, 0x78, 0x96, 0x5B, 0xE9, + 0x0B, 0x07, 0x42, 0x09, 0x67, 0x11, 0xE1, 0x11, + 0x5A, 0xE9, 0x30, 0x23, 0xA1, 0x0B, 0xF6, 0xB6 + }, + { + 0x51, 0xBB, 0x79, 0xF7, 0xD7, 0x40, 0x83, 0x75, + 0x5F, 0xC0, 0x2B, 0x33, 0x31, 0x64, 0xE8, 0x14, + 0x9D, 0x28, 0x68, 0x1F, 0xB2, 0x0F, 0x3E, 0xC8, + 0x1E, 0xAC, 0x6F, 0x0B, 0x2A, 0xF7, 0x71, 0x5D + }, + { + 0x45, 0xFB, 0xD6, 0xDF, 0xBF, 0xD8, 0xB0, 0xBF, + 0x65, 0x41, 0x06, 0x22, 0xAE, 0x6E, 0x69, 0x24, + 0x94, 0x40, 0x90, 0xEE, 0x42, 0x80, 0x49, 0x15, + 0x91, 0x78, 0x5A, 0x70, 0x35, 0x33, 0x8E, 0x37 + }, + { + 0xD1, 0xF9, 0xBC, 0x88, 0x05, 0x47, 0x78, 0x8E, + 0x20, 0x29, 0x84, 0x25, 0xD6, 0xB1, 0x64, 0x54, + 0xB9, 0xC0, 0x59, 0x34, 0x28, 0xA8, 0x44, 0xE9, + 0x22, 0xD5, 0x31, 0xF5, 0xEB, 0x5C, 0x2F, 0xA6 + }, + { + 0xFE, 0x78, 0xEE, 0xF8, 0x2A, 0x54, 0xD0, 0x26, + 0x4A, 0x94, 0x2B, 0xF0, 0xC9, 0xDB, 0xDA, 0xE2, + 0x9C, 0x32, 0xF4, 0xED, 0xA9, 0x94, 0xA3, 0x37, + 0xAC, 0xF8, 0xBA, 0xEE, 0x28, 0x6C, 0xDF, 0x07 + }, + { + 0xE7, 0x2B, 0x75, 0xC4, 0x0C, 0x9F, 0x88, 0x84, + 0xEA, 0xD9, 0x84, 0xD4, 0x4F, 0x61, 0x56, 0x0E, + 0x1A, 0xF4, 0x81, 0x93, 0x38, 0xA7, 0xF0, 0xAC, + 0xFC, 0x08, 0xC0, 0x36, 0xE1, 0x67, 0x8F, 0x0F + }, + { + 0xEB, 0x50, 0x92, 0xC7, 0xF8, 0xD9, 0xC9, 0x12, + 0x98, 0x2F, 0x56, 0x58, 0x50, 0xEA, 0x8D, 0xCE, + 0xB3, 0xA2, 0x98, 0xFD, 0xB1, 0xBA, 0xD5, 0x3B, + 0xB6, 0xE5, 0x03, 0x5F, 0xEF, 0xFA, 0x7E, 0x2A + }, + { + 0x14, 0x15, 0x29, 0xA9, 0x86, 0x18, 0xFE, 0x87, + 0x1C, 0x8F, 0xAE, 0x91, 0x12, 0x89, 0x5E, 0x2E, + 0xEC, 0xA8, 0x00, 0x7E, 0xA7, 0x9B, 0xB4, 0x8C, + 0x82, 0x12, 0xDA, 0xDB, 0xD3, 0x55, 0x38, 0x2F + }, + { + 0x2F, 0xED, 0x18, 0xFC, 0xD9, 0xB3, 0x35, 0xA1, + 0x60, 0xF5, 0x0B, 0x6E, 0xF5, 0xC5, 0x87, 0xD8, + 0xBF, 0xEB, 0x5A, 0x86, 0x85, 0x9B, 0x5A, 0xEA, + 0xD1, 0x32, 0xA6, 0xAF, 0x10, 0x6C, 0x67, 0x44 + }, + { + 0xA2, 0x0F, 0x17, 0xF3, 0xD7, 0x3E, 0xCE, 0x12, + 0x85, 0x6F, 0xC3, 0xE4, 0xBC, 0x52, 0x1E, 0x9E, + 0xA3, 0x2E, 0x23, 0x53, 0xE9, 0x10, 0xF8, 0x64, + 0xB2, 0x52, 0x66, 0xC9, 0x0A, 0xA5, 0x69, 0x78 + }, + { + 0xA2, 0x1C, 0xE7, 0x71, 0x54, 0x76, 0xB1, 0xD8, + 0x0A, 0xE8, 0xEA, 0xCD, 0x0F, 0x3C, 0x67, 0x7B, + 0xD4, 0xEC, 0x09, 0x4B, 0x5A, 0x9B, 0xA6, 0xA8, + 0x3B, 0x38, 0x5D, 0x98, 0xD5, 0x46, 0x97, 0x40 + }, + { + 0x56, 0x45, 0x17, 0xD8, 0xFD, 0xD1, 0xB9, 0xAA, + 0x4B, 0xE9, 0x7D, 0x77, 0xA4, 0x53, 0x4C, 0x9C, + 0x87, 0x93, 0x1D, 0x85, 0x57, 0x11, 0x73, 0x24, + 0xB8, 0xEA, 0xC6, 0x02, 0x84, 0xC8, 0x80, 0x7B + }, + { + 0xCD, 0x7C, 0xC5, 0xA9, 0x3B, 0x0E, 0x88, 0x44, + 0x4A, 0xA8, 0xCE, 0x7B, 0xF2, 0x21, 0xCB, 0x13, + 0xEA, 0xF2, 0xA8, 0x16, 0x07, 0xC5, 0xA8, 0xF7, + 0x10, 0x32, 0x0A, 0xEC, 0x1E, 0x38, 0x81, 0x5D + }, + { + 0x79, 0xB5, 0xB2, 0x85, 0x28, 0x8A, 0xF6, 0x21, + 0x2A, 0x46, 0xC4, 0x6C, 0x72, 0x87, 0x06, 0x57, + 0x1E, 0x6B, 0x6F, 0xE8, 0x3A, 0x19, 0x0D, 0x31, + 0xDD, 0x06, 0xC6, 0xB2, 0x0C, 0xBB, 0x72, 0xB9 + }, + { + 0x40, 0x36, 0x22, 0x5B, 0x19, 0xF7, 0x13, 0x52, + 0xD5, 0x30, 0x68, 0x70, 0x2D, 0x80, 0xBC, 0x8C, + 0xA8, 0xF7, 0xC8, 0xCA, 0xD7, 0x61, 0xB6, 0x34, + 0xBB, 0x9E, 0x76, 0x28, 0x8D, 0x56, 0xEE, 0xC1 + }, + { + 0x50, 0xE1, 0x03, 0x99, 0x2D, 0xAE, 0x15, 0xBD, + 0xAB, 0x40, 0x51, 0x56, 0x37, 0x5B, 0x3F, 0xAF, + 0xE5, 0xFF, 0x34, 0xF8, 0x2B, 0x33, 0x8A, 0xFB, + 0xD0, 0xB2, 0x1B, 0xA1, 0xE9, 0xC6, 0xDF, 0x9F + }, + { + 0x6C, 0xAB, 0x45, 0x9D, 0x5F, 0xCF, 0x67, 0xD1, + 0x1E, 0x17, 0x2F, 0xF4, 0xDC, 0x54, 0x78, 0x82, + 0xAE, 0x30, 0x48, 0x98, 0xF4, 0x62, 0x9C, 0xD0, + 0x8F, 0x9C, 0x5E, 0xA6, 0x85, 0x23, 0x4A, 0x9F + }, + { + 0x26, 0x8F, 0x04, 0x95, 0x7D, 0xD5, 0xFF, 0x7D, + 0x7E, 0x2A, 0xB6, 0x2B, 0xD3, 0xCD, 0x08, 0x80, + 0x6A, 0xB3, 0xD4, 0x1B, 0x46, 0xCD, 0x3A, 0x7D, + 0x53, 0xA3, 0x1D, 0x37, 0xC0, 0x04, 0xDB, 0xE3 + }, + { + 0xEE, 0xF8, 0x11, 0xAD, 0x37, 0xD6, 0xC6, 0xA1, + 0xF7, 0x77, 0x76, 0x02, 0xED, 0x70, 0x61, 0xA6, + 0x7A, 0xE1, 0x83, 0x6D, 0xCB, 0x54, 0xF5, 0x3B, + 0x81, 0x76, 0xE5, 0x02, 0xFA, 0xEA, 0xA0, 0x8E + }, + { + 0xC5, 0xB7, 0x8F, 0xE2, 0xCD, 0xED, 0xE2, 0x6D, + 0xD5, 0xAD, 0xE3, 0xB1, 0x6A, 0xCC, 0xEB, 0x84, + 0xA1, 0x06, 0x2E, 0x8F, 0xCB, 0x6E, 0x00, 0x9C, + 0xEE, 0xCE, 0x5F, 0x92, 0x70, 0x0A, 0xBA, 0xE6 + }, + { + 0x7A, 0x6E, 0xD1, 0xED, 0xA1, 0x40, 0x62, 0x8E, + 0xB4, 0x73, 0x09, 0x77, 0xBA, 0x09, 0x9E, 0xB7, + 0x76, 0xB4, 0xD9, 0xC4, 0x1D, 0x61, 0x98, 0xE0, + 0x1E, 0xB0, 0x62, 0x4B, 0xF4, 0xA3, 0xEB, 0xB6 + }, + { + 0xD1, 0xFA, 0x65, 0x86, 0xA2, 0x5C, 0x42, 0xC3, + 0xCB, 0x79, 0x96, 0x35, 0xC6, 0x94, 0xEC, 0x63, + 0x25, 0xD3, 0xAE, 0x5F, 0x5B, 0x04, 0x7C, 0xD3, + 0xD3, 0x09, 0xB1, 0x10, 0xEF, 0x52, 0xC0, 0x6C + }, + { + 0xC9, 0xB2, 0x6C, 0xA1, 0xE8, 0x97, 0x86, 0xCB, + 0x37, 0xE7, 0x82, 0xF9, 0xD7, 0xA4, 0x5B, 0xDD, + 0x5E, 0xC7, 0x3B, 0x1B, 0x9D, 0x86, 0xCF, 0xBE, + 0xC9, 0xB1, 0x6B, 0x31, 0x32, 0x2C, 0xD7, 0xD4 + }, + { + 0xBE, 0x60, 0xD1, 0x68, 0x91, 0x84, 0xD5, 0x61, + 0xCA, 0x1A, 0xCD, 0x61, 0xF1, 0x68, 0x74, 0x54, + 0xE3, 0x3A, 0xA4, 0x9C, 0x8D, 0x71, 0x76, 0x75, + 0xA7, 0xD9, 0x38, 0x43, 0x83, 0x53, 0x82, 0x85 + }, + { + 0x27, 0xB0, 0x4E, 0x85, 0x6E, 0x03, 0xC3, 0xD3, + 0xD9, 0x07, 0x74, 0x5F, 0xF5, 0x1C, 0xBA, 0xA4, + 0x25, 0x4E, 0x83, 0xEE, 0x6F, 0xA9, 0x8C, 0xEA, + 0x44, 0xF4, 0xDD, 0x79, 0x05, 0x8C, 0x51, 0x89 + }, + { + 0x19, 0x67, 0x8A, 0x56, 0x1D, 0x8C, 0x7E, 0x7C, + 0x7A, 0x45, 0x3D, 0x99, 0xAA, 0xF8, 0xB2, 0x69, + 0x85, 0x2B, 0x26, 0x7C, 0x0C, 0x3A, 0x78, 0x6A, + 0x8E, 0x37, 0xD9, 0x05, 0x2B, 0xBF, 0x69, 0xD4 + }, + { + 0x86, 0x80, 0x0F, 0x41, 0xFF, 0x2A, 0x9E, 0x52, + 0x1C, 0x3A, 0x36, 0xF6, 0x2F, 0xBA, 0xF6, 0x50, + 0xB3, 0x93, 0x08, 0x05, 0xFE, 0xF2, 0x98, 0x09, + 0x78, 0x3C, 0x49, 0x46, 0x97, 0x3D, 0x33, 0x47 + }, + { + 0xCC, 0x47, 0x57, 0x75, 0xAA, 0x6D, 0xA7, 0x0D, + 0x9C, 0xF1, 0xD0, 0x99, 0xC6, 0x9D, 0x6B, 0x6E, + 0x7A, 0xFE, 0x9A, 0xE0, 0xDE, 0x4B, 0xA9, 0x55, + 0x1F, 0x19, 0x25, 0x53, 0xBD, 0x1C, 0x6B, 0xA1 + }, + { + 0x74, 0xC5, 0x02, 0x30, 0xEA, 0xB7, 0x0E, 0xEF, + 0x7A, 0xE7, 0x45, 0x10, 0x90, 0x4C, 0x02, 0x79, + 0xBF, 0x59, 0x09, 0x3C, 0xCA, 0x52, 0xD0, 0xD5, + 0x1B, 0x9A, 0x30, 0x68, 0x8A, 0x27, 0x86, 0x0C + }, + { + 0x07, 0xCC, 0xBD, 0x72, 0x6E, 0x68, 0x4B, 0x17, + 0x7E, 0x17, 0x73, 0xD9, 0xB9, 0x2A, 0xF8, 0x77, + 0x94, 0xEB, 0x5C, 0x2E, 0x9D, 0x21, 0x00, 0x42, + 0x05, 0x02, 0x48, 0xD2, 0x35, 0xB8, 0x23, 0x8A + }, + { + 0x92, 0x0F, 0x1D, 0x09, 0x5A, 0x74, 0x6F, 0x22, + 0xB9, 0xF9, 0x5D, 0xC1, 0x67, 0xC2, 0xA9, 0x25, + 0xD2, 0x90, 0x6D, 0x5B, 0x89, 0x65, 0xE6, 0x81, + 0x75, 0xD0, 0xA9, 0xAB, 0x26, 0x15, 0x2D, 0x55 + }, + { + 0x6D, 0x64, 0x5E, 0x69, 0x50, 0x5F, 0x5D, 0x33, + 0x60, 0xAB, 0x99, 0x8A, 0x6F, 0x4B, 0x9E, 0x1A, + 0x95, 0xAE, 0xF4, 0xD2, 0x1B, 0x6D, 0x7E, 0x43, + 0xD4, 0x57, 0x3C, 0x62, 0xB6, 0xE0, 0xA5, 0x0F + }, + { + 0xE1, 0x38, 0x3F, 0xFA, 0x66, 0xE8, 0xB0, 0x00, + 0x4F, 0x50, 0x20, 0x67, 0xF4, 0x58, 0x19, 0x67, + 0x3B, 0x9E, 0xBA, 0xA7, 0x50, 0x83, 0xCD, 0x0D, + 0xC8, 0x0D, 0x78, 0xB6, 0x52, 0xB1, 0xBC, 0x7F + }, + { + 0x04, 0x25, 0xD8, 0x0E, 0x51, 0x13, 0xE1, 0xF4, + 0x3D, 0x15, 0xF1, 0x06, 0x42, 0x1C, 0x40, 0x06, + 0xC1, 0xF4, 0xEC, 0x4B, 0xAC, 0x82, 0xD3, 0x19, + 0xFC, 0x95, 0xEF, 0x90, 0x44, 0x59, 0x29, 0xA9 + }, + { + 0x75, 0x39, 0x46, 0x0E, 0x5B, 0xEB, 0x29, 0x5A, + 0x1B, 0xE5, 0x95, 0x86, 0x8C, 0xDF, 0x16, 0xCE, + 0xC6, 0x2A, 0x1D, 0x02, 0x42, 0xFD, 0xDD, 0xFF, + 0x7F, 0x17, 0x25, 0x57, 0x67, 0xEF, 0x0C, 0xBF + }, + { + 0xF9, 0xB1, 0x15, 0xAA, 0x31, 0xC0, 0x01, 0x5E, + 0xA0, 0x1A, 0xF5, 0xB4, 0x80, 0x67, 0x2E, 0xE2, + 0x55, 0x1E, 0x1D, 0x1E, 0x59, 0xFC, 0xAA, 0x76, + 0x9B, 0x83, 0x8C, 0xDA, 0x75, 0x8D, 0xBD, 0x45 + }, + { + 0xBF, 0xD9, 0xB2, 0x2B, 0x31, 0xEA, 0xCE, 0x74, + 0x2A, 0x70, 0x05, 0x1C, 0x67, 0xBF, 0xBB, 0x48, + 0x71, 0xDD, 0xC0, 0xCF, 0x23, 0x9F, 0x8F, 0xFB, + 0x52, 0x25, 0x86, 0xA0, 0x85, 0x7A, 0x19, 0xAC + }, + { + 0xC7, 0x99, 0xDF, 0xDC, 0x2A, 0x39, 0xC5, 0xBA, + 0xDD, 0xF3, 0xFE, 0xEE, 0xDB, 0x45, 0x86, 0xD4, + 0x8E, 0xBC, 0x19, 0x7B, 0xFC, 0xE1, 0x10, 0x1D, + 0xD2, 0x11, 0x2C, 0x77, 0xDE, 0x5C, 0xA2, 0xED + }, + { + 0x9E, 0x03, 0x45, 0x03, 0xFA, 0xCF, 0xF6, 0x5D, + 0xD3, 0xD5, 0xCA, 0x38, 0xE0, 0x92, 0x94, 0x2D, + 0x95, 0x60, 0x38, 0xD1, 0xC0, 0x63, 0x68, 0xED, + 0x24, 0x91, 0xB2, 0xD8, 0x16, 0x87, 0x22, 0x0A + }, + { + 0x40, 0x0F, 0x37, 0x04, 0xF3, 0xB7, 0x1B, 0xC0, + 0xEB, 0x5F, 0x53, 0xCC, 0x74, 0xD2, 0x10, 0x5E, + 0xD1, 0xAD, 0x2C, 0xF9, 0x38, 0x70, 0xB3, 0x48, + 0xD3, 0x6E, 0xF8, 0xA3, 0x11, 0x17, 0xE7, 0xAD + }, + { + 0xB8, 0x0C, 0x56, 0x21, 0x1C, 0xCE, 0x61, 0x56, + 0xD6, 0xE6, 0x5A, 0x54, 0xAD, 0x24, 0x7A, 0x98, + 0x83, 0xD7, 0x52, 0x5C, 0xDB, 0xF5, 0xB8, 0xC0, + 0x7A, 0xD0, 0x0C, 0x78, 0x66, 0x6D, 0x01, 0x9A + }, + { + 0x48, 0xD7, 0x7C, 0x1B, 0xC9, 0xDB, 0x2A, 0xF1, + 0x99, 0x68, 0x72, 0x6E, 0x2E, 0xB5, 0x42, 0xE7, + 0xCC, 0x97, 0x54, 0xFD, 0xE5, 0x33, 0x21, 0x33, + 0xCC, 0x4B, 0xD7, 0x4A, 0x85, 0x98, 0x8E, 0x27 + }, + { + 0x2B, 0x1B, 0x03, 0xD5, 0x2D, 0xEA, 0xEA, 0xA8, + 0x2A, 0x47, 0xF8, 0x61, 0x1D, 0x94, 0x6D, 0x7F, + 0xA7, 0xCA, 0x4F, 0x16, 0x2D, 0x25, 0x56, 0x55, + 0x58, 0xAC, 0x17, 0xB5, 0x27, 0x42, 0xA7, 0xB8 + }, + { + 0x06, 0xC5, 0xFB, 0xAF, 0x6E, 0x3A, 0xD2, 0x0D, + 0x5A, 0x39, 0x3E, 0x7E, 0xDA, 0xB7, 0x3A, 0x2A, + 0x33, 0xDC, 0x9D, 0xCE, 0xF5, 0x0F, 0x87, 0x76, + 0x82, 0xA7, 0x7F, 0xC7, 0xA8, 0x0C, 0xDE, 0xD6 + }, + { + 0xC8, 0x44, 0xBF, 0x82, 0xEC, 0x7A, 0x57, 0x65, + 0xEB, 0x51, 0xD4, 0x8C, 0xF3, 0x2D, 0x60, 0x59, + 0xE7, 0xBA, 0x0E, 0xD9, 0xD5, 0xC6, 0x25, 0x69, + 0x19, 0x75, 0x8A, 0x6F, 0xA8, 0x57, 0xF8, 0xC1 + }, + { + 0xC4, 0xCD, 0x02, 0xB9, 0xDA, 0xF9, 0xFA, 0xE2, + 0xA8, 0x3E, 0x0D, 0x97, 0x7C, 0xF3, 0xCC, 0x64, + 0xFB, 0x60, 0x9A, 0xCE, 0xEE, 0x3B, 0x40, 0x0E, + 0x94, 0x6B, 0xD2, 0xA5, 0x8C, 0xE5, 0x15, 0xEA + }, + { + 0xDB, 0x61, 0x1B, 0x4B, 0x35, 0x19, 0x46, 0x1D, + 0x18, 0x98, 0x8A, 0x56, 0xFF, 0x48, 0x88, 0x94, + 0x38, 0x1D, 0xED, 0x48, 0x0A, 0x5F, 0x58, 0x02, + 0xF7, 0xC2, 0x7C, 0x1A, 0x90, 0x95, 0xD0, 0x4A + }, + { + 0x14, 0x7D, 0xA5, 0x4A, 0x60, 0xC6, 0xA5, 0xEC, + 0xCB, 0x2D, 0xC9, 0x83, 0xD0, 0x6D, 0x62, 0x29, + 0xDA, 0xA7, 0x8B, 0x58, 0xF9, 0x1D, 0x75, 0xEC, + 0x8C, 0xA1, 0x04, 0x53, 0x8F, 0xDB, 0x6D, 0x1E + }, + { + 0x8C, 0x12, 0xC7, 0xC1, 0x42, 0xBC, 0xBA, 0x45, + 0x48, 0x63, 0x11, 0x2E, 0x8A, 0x4A, 0xDB, 0x61, + 0x3F, 0xE9, 0x7A, 0xA0, 0xA4, 0x8F, 0x99, 0xEC, + 0x0A, 0x4E, 0x7E, 0x3B, 0xE3, 0xDB, 0xE6, 0xD1 + }, + { + 0x0A, 0xF8, 0x84, 0x1C, 0xCC, 0xAD, 0x8C, 0x1E, + 0x1C, 0x4A, 0xDA, 0x64, 0xC3, 0xA1, 0xDF, 0xB2, + 0x63, 0x0A, 0xDE, 0x47, 0x44, 0xFC, 0x2C, 0x01, + 0x00, 0xEE, 0x9F, 0xC3, 0xB2, 0x95, 0x5B, 0x79 + }, + { + 0x12, 0xA8, 0xB7, 0x80, 0xAD, 0x35, 0x0A, 0x7C, + 0xFE, 0x6E, 0x7D, 0xDC, 0x05, 0x50, 0xBB, 0xF0, + 0xCC, 0x26, 0x32, 0x72, 0x71, 0xA1, 0x73, 0xB6, + 0xC1, 0x01, 0x0C, 0xBB, 0x73, 0x79, 0xB7, 0x9C + }, + { + 0x54, 0x86, 0x00, 0xA1, 0x3A, 0xB7, 0xA9, 0x79, + 0xA3, 0xAB, 0x54, 0xBB, 0xAB, 0x78, 0xD4, 0xE6, + 0xB3, 0x7C, 0x38, 0xF8, 0x58, 0x5D, 0xAE, 0x3E, + 0x29, 0x60, 0xE0, 0xA0, 0xF4, 0x68, 0xF6, 0xF1 + }, + { + 0x76, 0x56, 0xA5, 0x8E, 0x39, 0xD2, 0xBE, 0xE6, + 0xD7, 0xD3, 0x02, 0x9C, 0x40, 0x56, 0x70, 0x41, + 0x4D, 0x8B, 0x2F, 0xC7, 0x33, 0x65, 0x2D, 0x37, + 0x68, 0x74, 0xBA, 0x25, 0x61, 0xDB, 0xCD, 0x51 + }, + { + 0xCB, 0x55, 0x40, 0x32, 0x54, 0xE3, 0x1F, 0xA2, + 0xD7, 0xD9, 0x62, 0xF9, 0x84, 0xC7, 0x8A, 0x61, + 0x8E, 0xFB, 0x79, 0x57, 0xDD, 0xC8, 0x44, 0x0F, + 0xDB, 0x85, 0x1A, 0xAF, 0x1D, 0x4E, 0xCB, 0x88 + }, + { + 0x61, 0xA1, 0xEB, 0x76, 0xBC, 0x7F, 0xC8, 0x6F, + 0xE9, 0x11, 0x9B, 0xCB, 0x5A, 0xC7, 0x8A, 0x23, + 0x74, 0x53, 0x1E, 0xB9, 0x55, 0xDC, 0xD9, 0x5F, + 0x12, 0x3D, 0x34, 0x94, 0x77, 0x2A, 0x25, 0xEF + }, + { + 0x7A, 0x08, 0xDF, 0x6C, 0xE9, 0x98, 0xBF, 0xE9, + 0xA4, 0x61, 0x52, 0xD0, 0xF4, 0x72, 0xFB, 0xC0, + 0xB5, 0xC8, 0xA0, 0x2F, 0xFD, 0x05, 0xCA, 0x4A, + 0xA9, 0xC1, 0x95, 0x50, 0x9A, 0xE0, 0x29, 0x28 + }, + { + 0x04, 0xD4, 0xD9, 0x0C, 0x81, 0xAA, 0x59, 0x53, + 0x32, 0xED, 0x41, 0xB2, 0x94, 0x80, 0x79, 0x63, + 0x3E, 0x21, 0x30, 0xBA, 0xE0, 0x49, 0x0C, 0x98, + 0xF8, 0x5C, 0x2B, 0x7E, 0x44, 0x40, 0xC5, 0xB8 + }, + { + 0xC5, 0xE1, 0xEA, 0xEA, 0x5E, 0x39, 0xC8, 0xED, + 0xBA, 0x92, 0x9E, 0x4B, 0x5F, 0x90, 0xC1, 0xDD, + 0x22, 0xFB, 0x80, 0x50, 0xAF, 0xAF, 0x7D, 0x3A, + 0xF8, 0x6D, 0x37, 0xA7, 0x60, 0x86, 0x34, 0xAC + }, + { + 0x52, 0x75, 0x50, 0xED, 0x87, 0xF5, 0x5A, 0x41, + 0x0E, 0x87, 0x01, 0xCC, 0x30, 0xC4, 0x5B, 0xFF, + 0xD1, 0x33, 0x92, 0xFA, 0xD0, 0xD7, 0x55, 0xE5, + 0xC1, 0x79, 0x0A, 0x24, 0x12, 0x28, 0x68, 0x08 + }, + { + 0x72, 0x9B, 0x55, 0xDC, 0x78, 0xC1, 0xCB, 0x31, + 0x77, 0x3B, 0x59, 0xC5, 0x96, 0xA0, 0x79, 0x80, + 0x4F, 0x9D, 0x39, 0x01, 0x9D, 0x95, 0x0D, 0x39, + 0x8A, 0xE4, 0xDD, 0xF9, 0xA3, 0xB9, 0xD3, 0x6D + }, + { + 0xAF, 0xC3, 0x7E, 0x6F, 0xED, 0x15, 0x21, 0xFC, + 0x42, 0x93, 0xCC, 0x26, 0x9B, 0xE1, 0x63, 0xBD, + 0x5A, 0xE7, 0xFA, 0x30, 0x83, 0x21, 0x03, 0x64, + 0x06, 0x18, 0xB4, 0x8C, 0xD5, 0x13, 0x51, 0x91 + }, + { + 0x0E, 0x11, 0xAB, 0xAB, 0x5D, 0x68, 0x6B, 0xC1, + 0xF6, 0x50, 0x03, 0x4A, 0x24, 0x87, 0xF6, 0x56, + 0x99, 0x32, 0xDA, 0xAD, 0x73, 0x98, 0xFB, 0x7F, + 0x2C, 0x92, 0x90, 0xC3, 0x45, 0x34, 0x3B, 0x8A + }, + { + 0xDC, 0x59, 0x61, 0x97, 0xCA, 0xEC, 0x60, 0x6A, + 0x20, 0xD0, 0x3C, 0x40, 0x0E, 0x62, 0xCF, 0xB4, + 0x29, 0x76, 0xEE, 0xEC, 0x34, 0x08, 0x63, 0x7F, + 0xD3, 0x45, 0xBA, 0x38, 0x6C, 0x88, 0xA4, 0x39 + }, + { + 0x0A, 0x1F, 0xE9, 0xE6, 0x7C, 0x07, 0x15, 0x57, + 0x18, 0xCA, 0xAE, 0x7C, 0xB1, 0xAC, 0x05, 0x8B, + 0xE7, 0xBB, 0xF6, 0x26, 0x63, 0xB8, 0x2A, 0x7C, + 0x25, 0xC7, 0x5D, 0x94, 0x68, 0x92, 0xA8, 0xE3 + }, + { + 0xD5, 0x0C, 0x45, 0x7B, 0x8F, 0xC0, 0xF2, 0x28, + 0xD9, 0x6F, 0x5F, 0x01, 0xD4, 0xEA, 0x80, 0xA4, + 0xD5, 0xA3, 0xC6, 0x4E, 0xE0, 0xED, 0x9E, 0xDB, + 0xA9, 0x4F, 0xA0, 0xBC, 0x37, 0x34, 0xBC, 0x4D + }, + { + 0x5D, 0x8A, 0x3F, 0x97, 0xE3, 0x48, 0xFB, 0x0B, + 0x27, 0x3A, 0x72, 0x3F, 0x00, 0xDD, 0x14, 0x24, + 0xF4, 0xC3, 0x63, 0x3E, 0xC9, 0xF3, 0xE5, 0xBE, + 0x23, 0x34, 0x36, 0x2C, 0x94, 0xE2, 0xA1, 0x38 + }, + { + 0x5A, 0xB0, 0x01, 0xA8, 0xB9, 0xA9, 0x0E, 0x45, + 0xB6, 0x87, 0x58, 0x99, 0xFC, 0xAB, 0x17, 0xA5, + 0xE1, 0x6C, 0xA8, 0x87, 0xDA, 0x0D, 0x0B, 0x73, + 0xDD, 0x56, 0x2E, 0xF8, 0xF2, 0x45, 0x33, 0x19 + }, + { + 0xB5, 0x17, 0xB7, 0xE1, 0xA7, 0x40, 0xB9, 0xC8, + 0xA9, 0x76, 0x13, 0x7B, 0xE2, 0xD5, 0x93, 0x19, + 0x16, 0xC7, 0xC3, 0x30, 0x15, 0x93, 0x67, 0x18, + 0x53, 0x2B, 0x08, 0xBF, 0xB4, 0xBF, 0xC7, 0x64 + }, + { + 0x7A, 0xF3, 0x0F, 0x17, 0x10, 0x23, 0xEB, 0xE4, + 0xF2, 0xE8, 0x02, 0x42, 0x90, 0x04, 0x00, 0x87, + 0xD5, 0x5C, 0x9D, 0x7A, 0xAE, 0xE8, 0xDA, 0x94, + 0x1D, 0x5D, 0xE2, 0x8F, 0xEE, 0x04, 0x36, 0x91 + }, + { + 0x8C, 0x0D, 0x11, 0x54, 0x7A, 0x42, 0x47, 0x10, + 0x75, 0xD6, 0xFF, 0x11, 0xF4, 0x9A, 0xF9, 0x82, + 0xF1, 0x84, 0x3F, 0x16, 0xC0, 0x42, 0xB0, 0x21, + 0x88, 0xBF, 0x4C, 0x1B, 0x80, 0x4D, 0x8A, 0x2D + }, + { + 0x88, 0x54, 0xDE, 0x18, 0xC1, 0x6D, 0x2F, 0x16, + 0x21, 0x0E, 0xC1, 0xFE, 0xA8, 0x18, 0x5D, 0x65, + 0xCA, 0xE4, 0xD7, 0x1C, 0x24, 0xAF, 0x2F, 0x8D, + 0x75, 0xE9, 0x54, 0xBA, 0x3F, 0x1B, 0xDC, 0xD4 + }, + { + 0xF7, 0xDE, 0x90, 0x94, 0x83, 0xD6, 0xDF, 0x3B, + 0x26, 0x96, 0xB6, 0x96, 0x06, 0x40, 0x34, 0x6F, + 0x6B, 0x9E, 0xAB, 0x0C, 0x64, 0xD1, 0x66, 0x25, + 0x52, 0x73, 0x0C, 0x92, 0xDC, 0xF3, 0xCF, 0x9D + }, + { + 0x95, 0xD0, 0xDE, 0x68, 0x49, 0x55, 0xF7, 0xF9, + 0x24, 0x88, 0xE5, 0x5E, 0x3A, 0xDE, 0x67, 0x5D, + 0xB3, 0x70, 0x1E, 0xDD, 0xE2, 0x15, 0xC5, 0xBA, + 0xA6, 0xE2, 0x28, 0x3F, 0xAB, 0x81, 0x3F, 0x76 + }, + { + 0x00, 0x17, 0xA0, 0xD8, 0xE5, 0x66, 0xB9, 0x3F, + 0xA3, 0x8C, 0x7D, 0xEE, 0xD9, 0x45, 0xFC, 0x05, + 0xC0, 0x03, 0x26, 0x07, 0x8C, 0x45, 0xB4, 0x49, + 0x7B, 0x90, 0xD7, 0xEF, 0xEA, 0x85, 0xAE, 0xAB + }, + { + 0x15, 0x03, 0xCC, 0xB3, 0x3C, 0xF7, 0x12, 0xE3, + 0x11, 0x0F, 0xE7, 0x8B, 0x5B, 0x39, 0xAE, 0xCB, + 0x8F, 0x2B, 0xE6, 0x63, 0xE1, 0x9A, 0x8C, 0xFB, + 0x1C, 0xC4, 0x3E, 0x2C, 0xFC, 0x37, 0xBA, 0x03 + }, + { + 0x5B, 0x6C, 0x2D, 0x25, 0xA4, 0x68, 0xD1, 0x54, + 0x43, 0x82, 0x66, 0x90, 0x6B, 0x3F, 0x27, 0x97, + 0xD5, 0x5B, 0x31, 0xF0, 0xDE, 0x7E, 0x7E, 0x17, + 0x1C, 0x4E, 0xF9, 0x79, 0x58, 0x51, 0xFB, 0x83 + }, + { + 0x0C, 0xBE, 0xC8, 0x21, 0x2E, 0x4E, 0x5B, 0xC7, + 0x11, 0xBB, 0x7A, 0xCF, 0x28, 0xA9, 0x0F, 0xB0, + 0x40, 0x21, 0x4C, 0x9E, 0x31, 0x36, 0xFD, 0x47, + 0xA6, 0x3E, 0xDE, 0x7F, 0xB9, 0x91, 0x19, 0xA4 + }, + { + 0x19, 0xCE, 0x98, 0xC5, 0x21, 0x4B, 0xE7, 0x01, + 0xA2, 0x12, 0xE8, 0x5F, 0x9A, 0x9B, 0xE6, 0x73, + 0x9B, 0xD2, 0xF0, 0xD7, 0xDE, 0x29, 0x62, 0x3A, + 0xB0, 0xF0, 0xF0, 0xBD, 0x26, 0x37, 0x77, 0x18 + }, + { + 0x39, 0xB6, 0x60, 0x1C, 0xFC, 0x06, 0xBD, 0x4D, + 0xEC, 0xBC, 0xBC, 0xD9, 0xEE, 0xBF, 0xF6, 0xA4, + 0xBB, 0x92, 0x35, 0x0E, 0x61, 0x97, 0x84, 0xA5, + 0xFB, 0x8F, 0xB1, 0x47, 0xDF, 0xDF, 0x90, 0x52 + }, + { + 0x96, 0x08, 0xCE, 0x63, 0xA3, 0x36, 0x6B, 0xD1, + 0x40, 0xA9, 0x8E, 0x16, 0x7F, 0x10, 0xD5, 0xD1, + 0x9F, 0x93, 0xBF, 0x0E, 0x26, 0xD0, 0x2F, 0x0D, + 0x5F, 0xB4, 0x35, 0xBD, 0x92, 0x28, 0xE0, 0xBA + }, + { + 0x50, 0x08, 0x47, 0x64, 0x64, 0xE7, 0x33, 0xEC, + 0x34, 0x5C, 0xD7, 0x87, 0xB4, 0x1B, 0x88, 0xEB, + 0x1B, 0x36, 0x86, 0x35, 0xDF, 0x76, 0x8D, 0x1F, + 0xB2, 0xDA, 0x7C, 0x94, 0x4D, 0x8A, 0xE1, 0x13 + }, + { + 0x1A, 0xD9, 0x68, 0x60, 0xAC, 0xD3, 0x40, 0x3E, + 0xB4, 0xB3, 0xBC, 0x2D, 0xFE, 0xF5, 0x65, 0xFD, + 0x6F, 0x6C, 0x3C, 0xE7, 0xDB, 0xC5, 0xD4, 0x7D, + 0x51, 0x21, 0x5A, 0xCE, 0xBE, 0xDF, 0x22, 0xB7 + }, + { + 0xEC, 0x31, 0x4A, 0x84, 0x02, 0xEC, 0x63, 0x86, + 0xCF, 0x57, 0xF1, 0xE0, 0x14, 0x55, 0x9C, 0xF9, + 0x5E, 0x5C, 0xBB, 0xC5, 0x04, 0x86, 0x84, 0xAD, + 0xE1, 0xDE, 0xAC, 0xC0, 0x51, 0xB4, 0xCA, 0xBF + }, + { + 0x84, 0x46, 0xDB, 0x58, 0x2A, 0x85, 0x59, 0xAF, + 0x61, 0x99, 0xD0, 0x48, 0x87, 0x4C, 0x8C, 0x22, + 0x04, 0x0D, 0x53, 0x34, 0xC5, 0x7E, 0x5A, 0x9C, + 0xD8, 0x7E, 0x6B, 0x9B, 0x25, 0xBC, 0x99, 0x6F + }, + { + 0x8B, 0x6B, 0x63, 0x5C, 0x69, 0xB7, 0xB1, 0x9D, + 0x88, 0x43, 0x85, 0x8E, 0x53, 0x54, 0x49, 0xBE, + 0x26, 0x57, 0x18, 0xB9, 0xCF, 0x3A, 0x21, 0x7D, + 0xC1, 0xA4, 0x1C, 0xC7, 0x3C, 0x80, 0xAF, 0xAD + }, + { + 0x7D, 0x2E, 0xD5, 0x75, 0x2D, 0x37, 0xFC, 0xD0, + 0x53, 0xE6, 0x4D, 0xAD, 0x06, 0xD7, 0x5D, 0xB9, + 0x64, 0xE4, 0xCA, 0x45, 0x07, 0x1D, 0x64, 0xDD, + 0x50, 0x22, 0xF0, 0x3B, 0xCF, 0x3C, 0xA7, 0x58 + }, + { + 0xC5, 0x70, 0x4D, 0xAD, 0xE1, 0x8C, 0xD7, 0x3B, + 0xF9, 0x71, 0xCB, 0x49, 0xD5, 0x3A, 0x43, 0x14, + 0xCE, 0x11, 0x69, 0x37, 0xA1, 0x6F, 0x65, 0xDE, + 0x6E, 0xA3, 0xD7, 0x4B, 0x1E, 0x33, 0x72, 0xA8 + }, + { + 0x12, 0x88, 0x26, 0xC9, 0xE5, 0x60, 0x8F, 0xEE, + 0x80, 0xA9, 0x48, 0x1A, 0x83, 0xEF, 0xE3, 0x74, + 0x86, 0x9F, 0x19, 0xBF, 0xAC, 0xB4, 0xD1, 0x61, + 0xA0, 0x78, 0xAB, 0xCF, 0x39, 0xC7, 0x45, 0x21 + }, + { + 0x8D, 0xCC, 0x86, 0xA4, 0xB7, 0xF5, 0xCA, 0xC3, + 0x89, 0x4A, 0x2F, 0xE2, 0xAF, 0x8D, 0x7D, 0x08, + 0x13, 0x4C, 0x83, 0xFD, 0x4E, 0x93, 0x70, 0x14, + 0x67, 0x4D, 0xC4, 0x99, 0x3F, 0xA5, 0xAB, 0x5D + }, + { + 0xE1, 0xC3, 0xC8, 0x87, 0xB8, 0x05, 0x80, 0xE9, + 0x9F, 0xA3, 0x12, 0x6A, 0xF7, 0x39, 0x0A, 0x7D, + 0x38, 0x1F, 0x34, 0x36, 0x26, 0x17, 0xF1, 0x37, + 0x5A, 0xB7, 0x33, 0xCB, 0x7E, 0x84, 0x7E, 0xD3 + }, + { + 0x4D, 0x9C, 0x38, 0x51, 0xDF, 0x29, 0x18, 0x31, + 0x5C, 0xB2, 0x58, 0xCF, 0x23, 0x9B, 0x68, 0xC9, + 0xE4, 0x58, 0x2B, 0xB4, 0x3D, 0x0F, 0x7A, 0xD8, + 0x35, 0xD1, 0xD8, 0x54, 0x87, 0xD4, 0x91, 0x65 + }, + { + 0xBA, 0x69, 0xC7, 0x9C, 0xB8, 0xC2, 0x5D, 0x95, + 0x15, 0x8D, 0x96, 0x58, 0x0D, 0x56, 0x86, 0xE2, + 0xD0, 0xC0, 0xD7, 0x8B, 0x40, 0x65, 0x2E, 0xF1, + 0x10, 0x8A, 0x19, 0x68, 0x3F, 0x63, 0xD4, 0x56 + }, + { + 0xA9, 0x51, 0x15, 0xA4, 0xDE, 0x76, 0x6C, 0xF0, + 0x78, 0x2C, 0x37, 0x68, 0x6C, 0xAF, 0x12, 0x9D, + 0x08, 0x46, 0xF0, 0xF8, 0xC9, 0x2A, 0x5D, 0x1A, + 0x38, 0x08, 0xC5, 0x27, 0xF9, 0x09, 0x79, 0x38 + }, + { + 0x4B, 0xF9, 0x3A, 0xD0, 0xED, 0xEC, 0x28, 0xCF, + 0x63, 0xE4, 0xD1, 0xCD, 0x18, 0xDF, 0x7D, 0x76, + 0xB6, 0x07, 0xA3, 0x1C, 0xCF, 0x71, 0x0B, 0x29, + 0xA8, 0x3A, 0xA0, 0x80, 0xA9, 0xCD, 0xD8, 0xAE + }, + { + 0xFF, 0xF4, 0x5F, 0xF6, 0x3D, 0x63, 0x7C, 0x13, + 0xA4, 0x45, 0x4C, 0x39, 0xCD, 0xFB, 0x82, 0xD9, + 0x4C, 0x95, 0xC6, 0xC0, 0xF9, 0xFE, 0xE3, 0x82, + 0xEA, 0x5C, 0x04, 0xA6, 0x43, 0xFC, 0x67, 0xC6 + }, + { + 0x70, 0x59, 0x9C, 0x03, 0x78, 0xD2, 0x6B, 0x85, + 0x90, 0x7C, 0x9D, 0x63, 0xF2, 0xC3, 0xDF, 0x51, + 0x3B, 0x2D, 0x26, 0x30, 0xB0, 0x2B, 0xD8, 0xCA, + 0x9B, 0x99, 0x04, 0x01, 0xA2, 0xA1, 0xCF, 0xA9 + }, + { + 0x8A, 0x8A, 0xD4, 0x18, 0x06, 0xC7, 0x0A, 0x48, + 0x3B, 0x6F, 0xC4, 0xC9, 0xC0, 0x20, 0xA9, 0xB8, + 0xC1, 0xCB, 0x3F, 0x9C, 0xBB, 0x06, 0x36, 0xD5, + 0x5D, 0xFA, 0xDD, 0x12, 0x02, 0xCE, 0xD3, 0xF9 + }, + { + 0x7A, 0xBF, 0xA8, 0xB5, 0xAB, 0x4C, 0xFF, 0xAB, + 0x27, 0xE9, 0x69, 0x71, 0x4C, 0x9D, 0x83, 0x16, + 0x08, 0xE2, 0xAE, 0x39, 0x07, 0x40, 0xCA, 0xE3, + 0x3E, 0x73, 0x92, 0x2E, 0x2C, 0xF5, 0x82, 0xA1 + }, + { + 0x83, 0xE6, 0xC4, 0x0F, 0x55, 0x1A, 0x25, 0x84, + 0x67, 0xB4, 0x35, 0xEB, 0xB9, 0x23, 0x17, 0x95, + 0xE2, 0xBD, 0xA6, 0x52, 0x4B, 0x50, 0x8D, 0xDA, + 0xA8, 0x86, 0x15, 0xA4, 0x93, 0x4E, 0x93, 0x8D + }, + { + 0xBA, 0x5F, 0x1F, 0x41, 0x5B, 0xCF, 0x9F, 0x82, + 0x16, 0x1F, 0xDF, 0x3C, 0x32, 0xE6, 0x57, 0x93, + 0x47, 0x81, 0x69, 0x39, 0x40, 0x95, 0x69, 0xF1, + 0xC1, 0x94, 0x81, 0x3F, 0x6C, 0xB9, 0xD3, 0x4A + }, + { + 0x23, 0x91, 0x35, 0x27, 0x73, 0x33, 0xFF, 0xFA, + 0x7A, 0x4D, 0x7D, 0x3D, 0xD3, 0x76, 0x42, 0x1D, + 0x76, 0xBA, 0x2E, 0x6F, 0xD7, 0xEE, 0xD2, 0x0A, + 0x54, 0x33, 0x29, 0x61, 0x7F, 0x26, 0x85, 0x15 + }, + { + 0xF5, 0x23, 0x17, 0x51, 0xEB, 0x34, 0xFC, 0x53, + 0xAE, 0x24, 0x2A, 0x7A, 0x26, 0x52, 0x4E, 0x47, + 0xE2, 0x62, 0x38, 0xA1, 0x6D, 0xFA, 0xF7, 0x52, + 0x3C, 0x39, 0xD5, 0x61, 0x21, 0x23, 0xA8, 0x67 + }, + { + 0x98, 0xC6, 0xAE, 0x9B, 0x0E, 0xA9, 0x03, 0x6F, + 0xDD, 0x97, 0x62, 0x1F, 0x19, 0x65, 0x2E, 0xA5, + 0xC2, 0xBF, 0xF6, 0x0A, 0x1C, 0x6E, 0xF6, 0x62, + 0xFA, 0xF8, 0x37, 0x05, 0xD1, 0xF6, 0xF9, 0x28 + }, + { + 0xFA, 0xFA, 0xE1, 0x5E, 0x1B, 0xA2, 0xAE, 0xC1, + 0xFC, 0x83, 0x47, 0x69, 0x4D, 0x51, 0xC9, 0x94, + 0x14, 0x27, 0x05, 0x51, 0x95, 0x8B, 0x07, 0xA9, + 0xFF, 0x74, 0xAB, 0xB1, 0xFA, 0xAB, 0x8A, 0xEB + }, + { + 0x53, 0x82, 0x8C, 0xF9, 0x31, 0xCE, 0x27, 0x2A, + 0x2A, 0xAA, 0xFC, 0x9A, 0x44, 0x77, 0x25, 0xB4, + 0x7A, 0x35, 0x05, 0x3C, 0x2C, 0x6B, 0xCD, 0x7D, + 0xF8, 0x3B, 0x1B, 0x4F, 0x36, 0xBF, 0x95, 0xC6 + }, + { + 0xDA, 0x37, 0x98, 0xB9, 0x70, 0x8E, 0xB5, 0x1B, + 0xC0, 0x21, 0x32, 0x30, 0x84, 0x78, 0x16, 0x81, + 0x49, 0x40, 0xB3, 0x0C, 0x30, 0x30, 0x0B, 0xFD, + 0xCF, 0xD5, 0x2E, 0x6F, 0xFA, 0x75, 0xFB, 0xD8 + }, + { + 0x5A, 0x25, 0x55, 0x2F, 0x42, 0xBA, 0xD8, 0xE8, + 0xDD, 0x06, 0x91, 0xA6, 0x62, 0x53, 0x13, 0x01, + 0xA1, 0x62, 0x17, 0xB9, 0x15, 0x79, 0x78, 0xFE, + 0x32, 0x92, 0x58, 0x09, 0x21, 0x3A, 0xFB, 0x2F + }, + { + 0x7E, 0x4B, 0xB4, 0xFD, 0x45, 0x90, 0x1C, 0x88, + 0x54, 0x39, 0x06, 0x7A, 0x8F, 0x9F, 0xE0, 0xFD, + 0xA7, 0xBF, 0x88, 0xE1, 0x47, 0xEB, 0xA8, 0x60, + 0x7C, 0x59, 0xD4, 0x2E, 0xE4, 0x1D, 0x7F, 0x1B + }, + { + 0x4E, 0xFF, 0x48, 0xFB, 0xDC, 0x47, 0xDE, 0x0F, + 0x5B, 0x4E, 0x91, 0xEB, 0x1B, 0x57, 0x7B, 0xD8, + 0x80, 0x51, 0x41, 0x4B, 0xC5, 0xE7, 0xE9, 0x83, + 0xFC, 0x4C, 0x28, 0x97, 0xC6, 0x60, 0xC0, 0x3E + }, + { + 0x61, 0x1B, 0x25, 0x88, 0x0D, 0xE1, 0xD8, 0x48, + 0x2C, 0x20, 0x17, 0xC0, 0xE7, 0x51, 0x11, 0x07, + 0x4C, 0x06, 0x07, 0x17, 0x79, 0xD1, 0x13, 0xDF, + 0x88, 0x2F, 0xA8, 0x23, 0x0C, 0xDC, 0x95, 0xCD + }, + { + 0x4E, 0xDF, 0x18, 0xB5, 0xA4, 0xCD, 0xC3, 0xA7, + 0x04, 0x2E, 0x73, 0x74, 0xDB, 0x0E, 0xC0, 0x99, + 0x50, 0x8A, 0x8B, 0xBD, 0xFE, 0xF7, 0xF0, 0x78, + 0x11, 0x16, 0x9F, 0x32, 0xDF, 0x9F, 0x46, 0x12 + }, + { + 0x2D, 0xDB, 0x40, 0x55, 0x64, 0x89, 0x9C, 0x76, + 0x22, 0xD5, 0x91, 0x5B, 0xAD, 0x7B, 0x78, 0x5C, + 0x8A, 0xB9, 0x4B, 0xBC, 0x64, 0x91, 0x5F, 0x81, + 0x69, 0x40, 0x8A, 0xEC, 0x3C, 0xD5, 0x20, 0x8A + }, + { + 0x77, 0x4A, 0x07, 0x75, 0xEE, 0x92, 0x61, 0x3C, + 0xBB, 0xB3, 0xC2, 0x2E, 0x2D, 0xAB, 0xB5, 0x9F, + 0x6F, 0xB3, 0xA6, 0x7B, 0x3F, 0x37, 0xF8, 0x50, + 0x28, 0xD7, 0x64, 0x50, 0xA3, 0xFA, 0xD7, 0x7D + }, + { + 0x0A, 0x8B, 0x27, 0xA9, 0x38, 0xFD, 0x77, 0x39, + 0x85, 0x54, 0x90, 0xD3, 0x99, 0xB2, 0xCE, 0x5E, + 0x1B, 0xB1, 0xA8, 0xEC, 0x01, 0xBE, 0x4E, 0x94, + 0x95, 0x0B, 0xFD, 0x6A, 0x40, 0x8A, 0xCD, 0xB7 + }, + { + 0x15, 0x21, 0xD6, 0x1B, 0x2D, 0x4C, 0xB0, 0x6F, + 0x3F, 0x2F, 0xAF, 0x35, 0x1E, 0x06, 0x86, 0x10, + 0x14, 0x68, 0x26, 0xBD, 0x12, 0x26, 0x04, 0x80, + 0xEC, 0x96, 0x77, 0xB2, 0xFD, 0x02, 0xCC, 0xA4 + }, + { + 0x94, 0xC1, 0x0E, 0x8A, 0xFE, 0xB0, 0xA0, 0x91, + 0xC6, 0xB5, 0x18, 0x0B, 0xB5, 0x85, 0xEC, 0xE1, + 0xDD, 0xF7, 0x17, 0x43, 0xBD, 0xF2, 0xF0, 0x5D, + 0xB5, 0xCC, 0x04, 0x4D, 0x81, 0xDC, 0x45, 0x40 + }, + { + 0x01, 0x9C, 0xEA, 0x45, 0xC1, 0x3E, 0x97, 0xC8, + 0xC7, 0xC3, 0xCD, 0xFF, 0x7F, 0x78, 0xE2, 0x6A, + 0xD8, 0xF3, 0xA9, 0xDA, 0x02, 0x6A, 0x5D, 0xA8, + 0xCA, 0xC8, 0xDA, 0x15, 0xB1, 0x37, 0x5C, 0x33 + }, + { + 0x32, 0x9B, 0x56, 0xAF, 0x30, 0xCE, 0xD8, 0xD3, + 0xE0, 0xFF, 0x48, 0x1E, 0xF4, 0x66, 0xA9, 0x0A, + 0xA3, 0x09, 0x40, 0x79, 0xCF, 0x0F, 0x78, 0x19, + 0x8F, 0x4E, 0xC2, 0x7F, 0x5B, 0xD0, 0x24, 0xBA + }, + { + 0xAF, 0x97, 0x0A, 0x45, 0x75, 0xD3, 0xA5, 0x43, + 0x61, 0x27, 0x68, 0x6F, 0x9F, 0x23, 0xA3, 0xB7, + 0xCE, 0xF1, 0x78, 0x5A, 0x32, 0xB0, 0x24, 0x87, + 0xAD, 0x86, 0x0E, 0x16, 0x8D, 0xE2, 0xC5, 0xD6 + }, + { + 0xC8, 0x16, 0x84, 0x84, 0x62, 0x35, 0x8C, 0x26, + 0x65, 0x41, 0xD2, 0x2B, 0x96, 0x05, 0x3F, 0xE8, + 0xB8, 0xAA, 0x53, 0x9F, 0x9F, 0x0C, 0x00, 0x2D, + 0x12, 0xC3, 0x9E, 0x9F, 0x0E, 0x73, 0x3A, 0x8B + }, + { + 0x32, 0x88, 0xB9, 0xFE, 0x7F, 0x48, 0xED, 0x34, + 0x78, 0xA1, 0x46, 0xB6, 0x97, 0x51, 0x2E, 0x9A, + 0xA9, 0x18, 0x04, 0x91, 0x0C, 0x83, 0xC8, 0xC5, + 0x01, 0x22, 0x86, 0xE9, 0x86, 0x1B, 0x71, 0x1C + }, + { + 0xB0, 0x7C, 0xC9, 0x14, 0x13, 0x73, 0x4E, 0xC6, + 0xBF, 0x54, 0x0F, 0x1F, 0xC7, 0x79, 0xCB, 0x5F, + 0xCE, 0x72, 0xCC, 0xB7, 0xDF, 0xA2, 0xC0, 0x7D, + 0x72, 0x3D, 0xFE, 0x7B, 0x8F, 0x8B, 0x3B, 0xA2 + }, + { + 0x61, 0x25, 0x01, 0x93, 0x21, 0xA0, 0x95, 0xE3, + 0x04, 0x03, 0x26, 0x20, 0xC7, 0x15, 0xF3, 0x48, + 0x36, 0x61, 0xF6, 0x32, 0x19, 0x3A, 0x6E, 0xB2, + 0xD7, 0xCF, 0x9B, 0x62, 0xA7, 0x43, 0xCB, 0xB8 + }, + { + 0x6F, 0x9A, 0x0C, 0x7E, 0xA7, 0x05, 0x3F, 0x2D, + 0x46, 0x6A, 0xEF, 0xAF, 0x35, 0xC4, 0x99, 0xF0, + 0xFC, 0x08, 0xC5, 0xBD, 0xED, 0x34, 0xE2, 0xA8, + 0xA6, 0x9F, 0xD7, 0x0E, 0xA0, 0xC3, 0x9F, 0xE4 + }, + { + 0x22, 0xE5, 0xC2, 0x76, 0x60, 0x8E, 0x1B, 0x7C, + 0xD7, 0x04, 0xA3, 0xBC, 0x6A, 0x28, 0x91, 0xF5, + 0x55, 0x29, 0xBD, 0x9F, 0x4C, 0x71, 0x5E, 0xCB, + 0x38, 0xD4, 0x89, 0x32, 0x59, 0xEF, 0x49, 0x0A + }, + { + 0x13, 0xDD, 0x6B, 0xD5, 0x0B, 0xBC, 0x7B, 0x27, + 0x4C, 0xA2, 0xED, 0x38, 0xE0, 0xAC, 0x25, 0x1B, + 0x5D, 0x98, 0x7C, 0xC3, 0x2A, 0x25, 0xEE, 0xE4, + 0x62, 0xF1, 0xA9, 0xD1, 0x9E, 0x8C, 0xB5, 0xF6 + }, + { + 0x8C, 0xF8, 0x29, 0x56, 0xC0, 0x97, 0xC9, 0x17, + 0x0A, 0x0D, 0x25, 0xD6, 0xC1, 0x06, 0x6B, 0x4C, + 0x64, 0x31, 0x8E, 0x52, 0xA5, 0xFC, 0x20, 0x0B, + 0x57, 0x3B, 0x47, 0x65, 0x4D, 0x0D, 0x1E, 0x8B + }, + { + 0xC1, 0x61, 0x18, 0xC5, 0xDF, 0x47, 0x6F, 0x48, + 0x43, 0x97, 0xBD, 0x1A, 0x33, 0xF3, 0x61, 0xF3, + 0x9E, 0x29, 0x41, 0xF7, 0x6A, 0x1F, 0xA1, 0xBD, + 0xF6, 0xC7, 0x7E, 0x01, 0x02, 0x08, 0x85, 0xDC + }, + { + 0x04, 0xA5, 0x6E, 0x6F, 0x95, 0x39, 0x85, 0x8D, + 0x27, 0x02, 0xBB, 0x97, 0x67, 0x67, 0x20, 0x74, + 0x06, 0xC0, 0xE7, 0x0C, 0xC3, 0x71, 0x73, 0xDC, + 0x59, 0x50, 0x80, 0x56, 0x60, 0x3D, 0xD0, 0x86 + }, + { + 0x53, 0xAD, 0xE1, 0x8E, 0xA9, 0x00, 0xD9, 0x15, + 0x24, 0x06, 0xEB, 0x3D, 0x8D, 0xC4, 0x9E, 0x7C, + 0x90, 0x36, 0xF6, 0xF6, 0x38, 0x15, 0xE0, 0x8D, + 0x23, 0x9B, 0x3B, 0xB6, 0x71, 0x8E, 0xA3, 0xAB + }, + { + 0xE3, 0x0F, 0x30, 0x20, 0x50, 0xF6, 0xA6, 0xD9, + 0xA0, 0xA5, 0x9E, 0x21, 0xAE, 0x10, 0xC5, 0x76, + 0x85, 0x04, 0xE7, 0x38, 0x5D, 0x40, 0xA7, 0x41, + 0x4A, 0x44, 0x57, 0x01, 0x1D, 0x9B, 0x91, 0x60 + }, + { + 0xD5, 0x87, 0x0C, 0x69, 0xEE, 0x37, 0x8C, 0x59, + 0x57, 0x43, 0x87, 0xFC, 0x8D, 0x93, 0x69, 0x19, + 0x3A, 0xD3, 0x99, 0xE2, 0x5E, 0x94, 0x5A, 0xBB, + 0x8B, 0x79, 0x2E, 0x9E, 0x4B, 0xC5, 0x9F, 0xF1 + }, + { + 0x9C, 0x2B, 0xF0, 0xBF, 0xBF, 0x56, 0x9B, 0xF5, + 0x8D, 0x48, 0xD0, 0xEF, 0x45, 0x15, 0x0F, 0xE5, + 0x33, 0xF0, 0xBC, 0x2B, 0xE6, 0xA7, 0x9D, 0xC9, + 0x68, 0xB5, 0xC2, 0x3B, 0xE4, 0xE9, 0xAD, 0x50 + }, + { + 0xEB, 0x5A, 0xB4, 0xFB, 0x5F, 0x59, 0xB2, 0x37, + 0x14, 0x1D, 0x2C, 0x22, 0x55, 0x69, 0xC7, 0x77, + 0x08, 0x79, 0xE9, 0x74, 0x29, 0xAF, 0xE7, 0x14, + 0x06, 0x27, 0xC1, 0x11, 0x59, 0xF2, 0xD9, 0xC7 + }, + { + 0x75, 0xDB, 0x20, 0xCE, 0xD7, 0xF4, 0x17, 0xDF, + 0x6D, 0x6B, 0xA4, 0x92, 0xE9, 0xFC, 0xD9, 0x1D, + 0x7A, 0x32, 0x3E, 0xC1, 0xC9, 0x80, 0x47, 0x9B, + 0x15, 0x45, 0x76, 0x91, 0x1D, 0x97, 0x5C, 0xF9 + }, + { + 0xF2, 0xEE, 0xB0, 0x88, 0xC6, 0xF6, 0x7A, 0x79, + 0x0D, 0x2F, 0x63, 0xA8, 0x6A, 0xAC, 0xD9, 0x79, + 0xCA, 0x65, 0xC6, 0xAB, 0xE8, 0xB9, 0xAB, 0xDB, + 0xD7, 0x0C, 0x59, 0x05, 0xF7, 0xB7, 0x05, 0xEF + }, + { + 0xF1, 0x4A, 0x35, 0x1F, 0x62, 0x53, 0x56, 0x34, + 0x6F, 0x7F, 0x73, 0x4A, 0xB0, 0x1E, 0x96, 0x02, + 0x49, 0x7D, 0x92, 0x99, 0x0C, 0x18, 0x99, 0xD9, + 0x53, 0x03, 0x27, 0x56, 0xE2, 0x68, 0xD8, 0x96 + }, + { + 0x2A, 0xB2, 0xCF, 0x52, 0xA8, 0x57, 0xC1, 0x2D, + 0xA8, 0x46, 0xFB, 0x3E, 0x5C, 0x17, 0xF8, 0xAB, + 0x19, 0x90, 0x88, 0xC8, 0xB1, 0xC1, 0xD4, 0x7B, + 0x23, 0x05, 0x3C, 0xA3, 0x7B, 0x69, 0xFD, 0x18 + }, + { + 0x2D, 0xD2, 0x9C, 0x0A, 0x29, 0xC6, 0x52, 0x77, + 0x77, 0xCA, 0xB3, 0x1E, 0xEC, 0x2C, 0x8E, 0xA2, + 0x08, 0x07, 0xC2, 0x22, 0x6B, 0xC9, 0x08, 0x66, + 0xAD, 0x60, 0x01, 0xCE, 0x87, 0x15, 0x43, 0xB6 + }, + { + 0x12, 0x4C, 0x33, 0x40, 0x38, 0xA6, 0x35, 0x9F, + 0x6B, 0x90, 0xB2, 0x57, 0xF1, 0xE4, 0x2A, 0xE5, + 0xDC, 0x21, 0xED, 0x61, 0xCF, 0xED, 0xCA, 0x6A, + 0xE3, 0x4D, 0x03, 0xD4, 0xD0, 0xE6, 0x79, 0x5D + }, + { + 0x32, 0x67, 0xF5, 0xBB, 0x95, 0x0A, 0x4B, 0x90, + 0x85, 0x98, 0xAA, 0xC5, 0x5A, 0x39, 0x4F, 0xB5, + 0xFB, 0x39, 0xB2, 0x20, 0x63, 0x01, 0x00, 0xBB, + 0xD7, 0x16, 0x90, 0x7A, 0xD3, 0x5E, 0xA2, 0xEF + }, + { + 0x36, 0xD2, 0x72, 0x7D, 0x97, 0x40, 0x21, 0x85, + 0x0A, 0xB5, 0x69, 0x23, 0xDB, 0x6D, 0xE4, 0x01, + 0x76, 0x34, 0x5A, 0xFD, 0x13, 0xEB, 0xC3, 0x45, + 0x89, 0xB2, 0xC7, 0x3D, 0x0F, 0xA6, 0x6E, 0x4B + }, + { + 0x69, 0xB0, 0x7B, 0xC3, 0x6F, 0xA6, 0x1D, 0x70, + 0xF2, 0x4A, 0x36, 0xB2, 0xDF, 0x15, 0xE8, 0x7A, + 0x3E, 0x04, 0xDF, 0x7E, 0x19, 0x69, 0x9B, 0xFB, + 0x9D, 0x4E, 0x84, 0x29, 0xF3, 0x72, 0xA1, 0x91 + }, + { + 0xAD, 0x8D, 0xE1, 0xE2, 0x0C, 0xBF, 0x77, 0x77, + 0xC0, 0x62, 0xC3, 0xD5, 0xDC, 0x21, 0x87, 0x63, + 0x26, 0xCF, 0xC6, 0xD3, 0x69, 0xBC, 0xE9, 0xB2, + 0x0C, 0xD0, 0xEF, 0x76, 0x48, 0x79, 0x79, 0x2F + }, + { + 0x97, 0xAA, 0x96, 0x9E, 0xF7, 0x9A, 0x8F, 0x0C, + 0xAB, 0x42, 0x9F, 0x28, 0x74, 0x2D, 0x31, 0xDB, + 0x82, 0x9D, 0xC2, 0x24, 0xC2, 0x60, 0x4D, 0x0B, + 0xC0, 0x5D, 0x90, 0xD9, 0xCE, 0xF1, 0xB5, 0xC4 + }, + { + 0x69, 0xF8, 0x92, 0x3A, 0x3C, 0x06, 0x52, 0x50, + 0x90, 0x2D, 0x5E, 0x65, 0x13, 0xAD, 0x73, 0xAA, + 0x1D, 0x12, 0x9D, 0x9A, 0xD3, 0xB9, 0x9F, 0x3E, + 0x55, 0x8B, 0xC1, 0x42, 0x5D, 0xAD, 0xFB, 0x44 + }, + { + 0x77, 0x63, 0x62, 0x28, 0x10, 0x09, 0xCD, 0x8B, + 0x97, 0x88, 0xEB, 0x1F, 0xFD, 0x5B, 0xF0, 0x26, + 0x49, 0x42, 0x8D, 0x4D, 0x92, 0x4B, 0xCA, 0x0D, + 0x65, 0xBC, 0xE4, 0xD4, 0x13, 0x89, 0xBA, 0xEA + }, + { + 0x1B, 0xAC, 0x86, 0xC4, 0xFC, 0x3F, 0x92, 0xC6, + 0x3E, 0x68, 0xA6, 0x65, 0xFF, 0x23, 0xC0, 0x3A, + 0x61, 0x94, 0x67, 0xEE, 0x2A, 0x8A, 0x05, 0x61, + 0x95, 0xAF, 0xDA, 0x16, 0x91, 0x13, 0x14, 0x8D + }, + { + 0x7D, 0xED, 0x2F, 0xDB, 0x77, 0x0A, 0x4A, 0x73, + 0x33, 0xDA, 0x6E, 0x72, 0xF9, 0x13, 0x5D, 0x4F, + 0xBD, 0x3D, 0xFA, 0x7B, 0xD9, 0xF0, 0x5E, 0x49, + 0x5D, 0x20, 0x60, 0x58, 0x97, 0x23, 0x7B, 0x9C + }, + { + 0xF0, 0x42, 0xE7, 0x67, 0xAF, 0x0C, 0xCD, 0x36, + 0x97, 0x94, 0xAF, 0xE5, 0x85, 0xC5, 0xFF, 0x8A, + 0x93, 0x26, 0x07, 0x09, 0xCC, 0xC0, 0x59, 0xE4, + 0x2E, 0x1A, 0x6D, 0x49, 0xE8, 0xDA, 0xB2, 0x39 + }, + { + 0xC0, 0x26, 0xB5, 0x0E, 0x65, 0x2E, 0x88, 0x73, + 0x0C, 0x4D, 0xF3, 0xC1, 0xB2, 0x95, 0xCD, 0xB7, + 0xFC, 0xCC, 0xA0, 0x25, 0xAC, 0x58, 0x9E, 0xCD, + 0x82, 0x0A, 0x27, 0x3D, 0xA8, 0x9B, 0x2D, 0x33 + }, + { + 0xD3, 0x89, 0x7F, 0x4A, 0x54, 0x37, 0x11, 0xA6, + 0x23, 0x97, 0x5D, 0x63, 0x59, 0x73, 0x41, 0xFF, + 0x63, 0x19, 0x84, 0x54, 0x85, 0x05, 0xFF, 0x6F, + 0xEE, 0x6A, 0x71, 0x3D, 0x96, 0x63, 0x2A, 0x62 + }, + { + 0x0D, 0xE2, 0x7B, 0x5B, 0x45, 0xC6, 0x31, 0x7C, + 0xB9, 0x7C, 0xAB, 0xB0, 0x9C, 0x9A, 0x91, 0x7B, + 0x13, 0x9D, 0xDE, 0xFF, 0xCE, 0x69, 0xBB, 0xC9, + 0xC8, 0x8B, 0x9F, 0x0F, 0x40, 0xB5, 0xAE, 0xA2 + }, + { + 0xBF, 0x3D, 0xAE, 0xF9, 0xC1, 0xB9, 0xEA, 0xC4, + 0x86, 0xF3, 0xF9, 0xFD, 0x8A, 0xF2, 0x19, 0x4E, + 0x3B, 0x7A, 0x8D, 0x7D, 0xEE, 0x9D, 0x96, 0x5F, + 0x2C, 0xCD, 0x15, 0x75, 0x3F, 0xBB, 0x14, 0xD8 + }, + { + 0x18, 0x58, 0x6A, 0xAF, 0x67, 0x23, 0x23, 0x45, + 0x49, 0x74, 0x88, 0x92, 0x41, 0xAA, 0xCA, 0xF6, + 0x95, 0x30, 0xBF, 0x27, 0x1E, 0x26, 0x38, 0xE0, + 0x0C, 0xAC, 0x35, 0xC7, 0xC4, 0x42, 0xC8, 0x6D + }, + { + 0x20, 0x25, 0x37, 0x17, 0x41, 0x00, 0xF9, 0x7D, + 0x4B, 0x3D, 0x60, 0xA2, 0xC2, 0x01, 0x59, 0x45, + 0xF5, 0x70, 0x6B, 0x5B, 0x4B, 0x4F, 0x93, 0xDC, + 0x29, 0xE1, 0x9C, 0xCD, 0x52, 0x47, 0x3D, 0xAB + }, + { + 0xDF, 0xB5, 0x97, 0xE9, 0x96, 0xC1, 0xA7, 0x44, + 0x75, 0x2B, 0xA6, 0x7F, 0x1D, 0x40, 0x26, 0xA1, + 0x4E, 0xBC, 0x49, 0x2C, 0xC1, 0x65, 0x00, 0x1C, + 0x8F, 0xA4, 0xA5, 0x48, 0x1F, 0xFA, 0xDD, 0x1C + }, + { + 0x47, 0x23, 0x6C, 0x8A, 0x02, 0x25, 0x8A, 0xFB, + 0x89, 0x8A, 0x4B, 0x8F, 0x80, 0xC1, 0xBA, 0x1C, + 0x12, 0x3B, 0x8B, 0x2B, 0xB3, 0xC8, 0xAE, 0xA7, + 0x06, 0xC8, 0xC6, 0xD6, 0x49, 0x3D, 0xEC, 0x0D + }, + { + 0x48, 0xF1, 0x0B, 0xC3, 0x5F, 0xB6, 0xB4, 0xC6, + 0xC1, 0xBB, 0x2A, 0xEE, 0xC4, 0x56, 0x0D, 0xB5, + 0x19, 0xE9, 0x3F, 0x81, 0xFE, 0x13, 0xB6, 0x23, + 0xC9, 0x65, 0x35, 0xEB, 0xC2, 0x4D, 0x3C, 0x32 + }, + { + 0x54, 0x9D, 0x6E, 0x08, 0xB7, 0x83, 0xB9, 0x99, + 0x8A, 0x7B, 0x7C, 0xF5, 0x82, 0x53, 0xAF, 0xB3, + 0xE3, 0xF4, 0x4E, 0x97, 0x97, 0xCF, 0xB9, 0x43, + 0x33, 0x50, 0x04, 0xCB, 0x5C, 0xBA, 0xC5, 0x33 + }, + { + 0xF7, 0x0F, 0xD5, 0xCA, 0xE7, 0xCD, 0x81, 0x44, + 0x64, 0x32, 0xBB, 0xCC, 0x5C, 0xC3, 0xD4, 0xA1, + 0xF2, 0x3C, 0xA4, 0x09, 0xBB, 0xF4, 0x80, 0x7E, + 0x5A, 0xA8, 0x42, 0x7F, 0x71, 0x85, 0x2F, 0x22 + }, + { + 0x3D, 0xF2, 0xEC, 0xC5, 0x00, 0xE4, 0x24, 0x6C, + 0x89, 0xF6, 0x6A, 0x6D, 0x3A, 0x4C, 0xB2, 0xA7, + 0xB7, 0x0D, 0x8E, 0x5E, 0x38, 0x2F, 0x26, 0xEF, + 0xFD, 0x44, 0x48, 0x45, 0x69, 0x58, 0x95, 0x60 + }, + { + 0xCE, 0x26, 0xDC, 0x5A, 0xC0, 0x03, 0xFB, 0x18, + 0x4B, 0x82, 0x06, 0x1D, 0xC2, 0x73, 0xB8, 0x3A, + 0xCD, 0xD1, 0x0D, 0xC2, 0x0C, 0x34, 0x4F, 0x0D, + 0x3F, 0x5A, 0x2B, 0x55, 0x70, 0x1C, 0x5A, 0x99 + }, + { + 0xE4, 0xB8, 0xC9, 0xEF, 0x8C, 0x9E, 0xD4, 0x30, + 0xDA, 0x01, 0x91, 0xF1, 0x3D, 0xF9, 0x3D, 0x83, + 0xE9, 0xC1, 0x67, 0x4E, 0xCA, 0x61, 0xF4, 0xD4, + 0x82, 0x65, 0x51, 0x62, 0x83, 0xFB, 0xD4, 0x49 + }, + { + 0x93, 0xBC, 0x1A, 0xA6, 0x2A, 0x54, 0xB2, 0x16, + 0x68, 0x28, 0x7D, 0x2F, 0xD7, 0x43, 0xBC, 0xF7, + 0xD9, 0x4F, 0x73, 0xBF, 0x92, 0x86, 0xC3, 0xB0, + 0x05, 0x2F, 0x5C, 0x53, 0x18, 0x2D, 0x4E, 0xE2 + }, + { + 0x63, 0x04, 0x3E, 0xB4, 0x78, 0xB6, 0xBF, 0x19, + 0x31, 0xCE, 0xC8, 0x8B, 0x43, 0x20, 0xB2, 0x74, + 0x1D, 0xF0, 0x9E, 0x5B, 0x32, 0xE8, 0x93, 0x49, + 0xC0, 0xB3, 0xBF, 0x4B, 0x8A, 0xAE, 0x2D, 0xF0 + }, + { + 0x80, 0x63, 0x5B, 0x54, 0x66, 0x89, 0x3A, 0x69, + 0xE6, 0x73, 0x15, 0x8C, 0xB3, 0x04, 0xAE, 0xDA, + 0x4F, 0x29, 0xD7, 0xC5, 0x1D, 0xCA, 0x27, 0xC1, + 0x5B, 0xA1, 0xB9, 0x3A, 0x58, 0xE7, 0x88, 0x0A + }, + { + 0x5F, 0x72, 0x5A, 0x6F, 0xD3, 0x43, 0x6A, 0x93, + 0x99, 0x01, 0xD4, 0x79, 0xE5, 0x39, 0x90, 0xF8, + 0x2B, 0xA9, 0xA9, 0xB4, 0x2B, 0x50, 0xC5, 0xBB, + 0xB7, 0xBA, 0x1D, 0x0D, 0x68, 0x71, 0xD7, 0x5A + }, + { + 0xB4, 0xB1, 0x05, 0x63, 0x26, 0x6D, 0xC6, 0x29, + 0x89, 0xE7, 0x0F, 0x36, 0x7A, 0x3E, 0x50, 0xE2, + 0x95, 0xB1, 0x68, 0x61, 0xE2, 0xC1, 0xFF, 0xBD, + 0x95, 0x61, 0x42, 0x1E, 0x37, 0x9B, 0x05, 0x0D + }, + { + 0x5C, 0x78, 0x70, 0x98, 0x69, 0x22, 0x41, 0x69, + 0x3B, 0x8E, 0x2E, 0x87, 0x36, 0xA7, 0xC1, 0x34, + 0xD3, 0xB9, 0x43, 0xF2, 0x87, 0xD4, 0x93, 0xFB, + 0x15, 0x65, 0x69, 0xD1, 0x2B, 0x97, 0x0E, 0xAA + }, + { + 0x75, 0x8E, 0x7E, 0xA7, 0x2B, 0x69, 0x12, 0xFF, + 0x31, 0xCB, 0xF1, 0xE5, 0xD7, 0x2D, 0x26, 0x47, + 0xB0, 0x05, 0xEE, 0xFD, 0x4E, 0xC0, 0xAF, 0x40, + 0xFF, 0x0C, 0xC8, 0x55, 0x40, 0x46, 0x9F, 0x0F + }, + { + 0xCF, 0x1F, 0xD3, 0x4F, 0xDA, 0xAA, 0x08, 0x29, + 0xE6, 0x6A, 0xF8, 0x51, 0xC5, 0xEB, 0x35, 0x36, + 0xBD, 0xDB, 0x8E, 0xBB, 0x29, 0x77, 0x0F, 0x3B, + 0x31, 0x5E, 0x7A, 0xE0, 0x62, 0x67, 0xB3, 0x70 + }, + { + 0x9C, 0x1D, 0x8C, 0x3D, 0xD4, 0xB0, 0xA1, 0x5B, + 0x0A, 0x7B, 0x94, 0xCB, 0x3E, 0x09, 0xAE, 0x0A, + 0x12, 0x64, 0x35, 0xFF, 0x28, 0x05, 0x3C, 0xDA, + 0x76, 0xAF, 0x1D, 0x63, 0x1E, 0x88, 0xA7, 0x23 + }, + { + 0x0B, 0xAA, 0xFE, 0x86, 0x3E, 0x06, 0xA4, 0xF5, + 0xC1, 0xA6, 0x3A, 0xDD, 0x11, 0xEF, 0x04, 0x2E, + 0x3B, 0xDA, 0x5B, 0xCC, 0xDA, 0xA5, 0xC9, 0xB8, + 0xE4, 0xE4, 0x7B, 0x85, 0x4F, 0x5B, 0xFE, 0x5C + }, + { + 0x16, 0x6B, 0xD0, 0x2E, 0xC9, 0xE0, 0xA6, 0x23, + 0x03, 0x9A, 0x5D, 0x9D, 0x9E, 0x88, 0x95, 0x70, + 0xB1, 0x70, 0x9C, 0xFD, 0xDD, 0xB8, 0xC9, 0x28, + 0x23, 0xE6, 0x9A, 0x8D, 0xC5, 0x08, 0x2D, 0x1A + }, + { + 0xA2, 0x12, 0x3C, 0xA1, 0xAF, 0x6F, 0xE2, 0x22, + 0x7E, 0xFA, 0x03, 0xF6, 0x06, 0xC0, 0xD0, 0x2C, + 0x0A, 0x2E, 0x28, 0x94, 0xEE, 0xA1, 0x8F, 0xE1, + 0xF1, 0x5C, 0xFE, 0x09, 0xE4, 0x5B, 0x6C, 0x0A + }, + { + 0x76, 0xD3, 0x27, 0x72, 0xC6, 0x90, 0x14, 0xE6, + 0xE8, 0x8E, 0x8A, 0x46, 0x56, 0x88, 0x91, 0xC8, + 0x27, 0x4D, 0xDA, 0xC8, 0xCD, 0x0A, 0x3C, 0x80, + 0x61, 0xD1, 0x9F, 0x8B, 0xDA, 0x13, 0x80, 0xB6 + }, + { + 0x1E, 0x0A, 0x56, 0x93, 0xC2, 0x88, 0x1D, 0xEA, + 0xF0, 0xFF, 0xB9, 0xF7, 0xC7, 0x40, 0xAB, 0x0F, + 0x1A, 0x9A, 0xC6, 0x54, 0x67, 0x9C, 0x29, 0x00, + 0x6F, 0x50, 0x52, 0xFF, 0x20, 0xA8, 0xCF, 0x1A + }, + { + 0x86, 0x6E, 0xE1, 0x20, 0xA2, 0xDA, 0xC0, 0x85, + 0x5B, 0x2B, 0x95, 0xB8, 0xAF, 0xAE, 0x46, 0x34, + 0x03, 0x8B, 0xDB, 0x85, 0x0F, 0x6F, 0x7C, 0x42, + 0xE7, 0xF5, 0xB2, 0xF0, 0x55, 0x96, 0x7C, 0xA9 + }, + { + 0x79, 0xAD, 0x66, 0x30, 0x48, 0x5A, 0xEB, 0x92, + 0xBD, 0x21, 0x0C, 0x18, 0xA9, 0x36, 0x78, 0x4E, + 0x95, 0x24, 0xD1, 0xD8, 0x56, 0xAE, 0x67, 0xB9, + 0x25, 0xBE, 0x35, 0xE7, 0x9F, 0x3F, 0x0F, 0x3E + }, + { + 0x5A, 0x4F, 0xAA, 0xD0, 0xCF, 0xF1, 0x12, 0x10, + 0xD8, 0x6A, 0x0C, 0xFC, 0x2D, 0x92, 0xB9, 0xEA, + 0x39, 0xFF, 0x5B, 0xB0, 0xC6, 0xC5, 0x24, 0xC1, + 0x0F, 0x0F, 0xDF, 0xAE, 0xAD, 0x75, 0x9B, 0xB2 + }, + { + 0x26, 0x9A, 0x41, 0xC1, 0xF8, 0x93, 0x9E, 0x86, + 0x0A, 0xD1, 0x6B, 0x02, 0xAE, 0xB7, 0x41, 0x9C, + 0xAE, 0x3B, 0x3F, 0x6B, 0x74, 0xD7, 0xDA, 0xC7, + 0x0D, 0xE7, 0x58, 0xE5, 0x4D, 0xDF, 0x4F, 0xB4 + }, + { + 0x3A, 0x98, 0xEA, 0x23, 0x6F, 0x9C, 0x84, 0x76, + 0x49, 0x93, 0xF2, 0xBF, 0xEF, 0x9F, 0x55, 0x6E, + 0x82, 0x74, 0x60, 0xDA, 0x90, 0x25, 0xCE, 0xA8, + 0x13, 0x36, 0xFF, 0x30, 0x1A, 0xDD, 0xFB, 0x8E + }, + { + 0xE5, 0x6E, 0xF8, 0x5A, 0xE3, 0x72, 0x90, 0xA2, + 0x79, 0xC1, 0xC0, 0x4A, 0xE3, 0x75, 0x5C, 0x7E, + 0xAA, 0x40, 0x75, 0xD0, 0x93, 0x51, 0x2B, 0xA9, + 0xE5, 0xFA, 0xD5, 0x4D, 0x6D, 0x0F, 0xAF, 0x31 + }, + { + 0xCB, 0x5D, 0x4E, 0x9D, 0xBB, 0x20, 0xD3, 0x57, + 0x87, 0xC6, 0x79, 0xDE, 0x00, 0x9F, 0x8D, 0x17, + 0x2B, 0x21, 0x83, 0xE2, 0x0E, 0xEC, 0x3E, 0x48, + 0x36, 0x9B, 0x24, 0x94, 0x6C, 0x82, 0x31, 0xA4 + }, + { + 0xC2, 0x36, 0xEE, 0x84, 0xB4, 0x5F, 0x59, 0x48, + 0x00, 0x67, 0xBB, 0x5C, 0x7E, 0xA4, 0xBA, 0x24, + 0x1D, 0xF6, 0x2F, 0x3D, 0x00, 0x8C, 0x74, 0x11, + 0x31, 0xA7, 0x90, 0x22, 0x63, 0xFF, 0xAD, 0x3B + }, + { + 0x47, 0xD3, 0x15, 0xDB, 0x19, 0x98, 0x58, 0xAE, + 0xAC, 0x6C, 0xE8, 0xD2, 0xC5, 0xBF, 0xD5, 0xBA, + 0x6C, 0x4C, 0x02, 0xD3, 0x46, 0x38, 0x89, 0x5C, + 0x7B, 0x23, 0x1D, 0x90, 0x8B, 0x4D, 0x34, 0x6D + }, + { + 0xB1, 0x53, 0x31, 0xDB, 0x8B, 0x02, 0x78, 0x1E, + 0xC7, 0x55, 0x84, 0x4F, 0x8A, 0xE3, 0xB5, 0x25, + 0x12, 0x54, 0x27, 0x35, 0xE9, 0xBE, 0x47, 0x27, + 0x90, 0x5B, 0x31, 0x62, 0x53, 0x2D, 0x3C, 0x3D + }, + { + 0x8A, 0x60, 0x68, 0x0B, 0xD4, 0x66, 0x25, 0x4D, + 0x09, 0xAA, 0xD7, 0x1A, 0x40, 0x91, 0x6C, 0xBA, + 0xCE, 0x3F, 0xB6, 0xE7, 0x31, 0x1B, 0x4C, 0x52, + 0x13, 0x3B, 0xDA, 0x72, 0xED, 0x1D, 0xA1, 0xE6 + }, + { + 0x39, 0x51, 0xA4, 0xE7, 0x31, 0x33, 0x72, 0x39, + 0x7E, 0x7A, 0xCC, 0xE8, 0x81, 0x4D, 0x32, 0x59, + 0x0E, 0x62, 0x48, 0x9E, 0x39, 0x26, 0x81, 0xEA, + 0xD3, 0x17, 0x7E, 0x29, 0x6C, 0x29, 0x3F, 0xF9 + }, + { + 0xA1, 0x76, 0xFD, 0x47, 0x40, 0x75, 0x1E, 0x63, + 0x7C, 0x58, 0x4D, 0x30, 0xA0, 0x04, 0x43, 0xBB, + 0x95, 0x73, 0x9D, 0x8E, 0x82, 0xB1, 0x43, 0x2F, + 0xAE, 0xE1, 0x0C, 0x25, 0x87, 0xBD, 0x1D, 0xDA + }, + { + 0xAA, 0x24, 0x2B, 0xB5, 0xC8, 0xDB, 0x34, 0xE7, + 0xEB, 0x2C, 0xEC, 0xAB, 0x63, 0xEF, 0xAE, 0xBC, + 0x73, 0xE7, 0x72, 0x2E, 0x43, 0xD7, 0xEB, 0xD5, + 0xE3, 0x32, 0x60, 0x39, 0xFD, 0x34, 0x91, 0x3F + }, + { + 0x69, 0xDF, 0x61, 0xE3, 0x21, 0x81, 0x55, 0xA9, + 0x49, 0x44, 0xE5, 0xC9, 0x98, 0x95, 0x45, 0x1A, + 0x84, 0x35, 0x39, 0x16, 0x96, 0xD1, 0x85, 0x32, + 0xB5, 0x25, 0xB1, 0x98, 0x01, 0x06, 0xDB, 0x2C + }, + { + 0x6F, 0x94, 0x17, 0xD6, 0xF9, 0x69, 0x05, 0x5F, + 0x00, 0x00, 0xB2, 0x85, 0x3F, 0xDF, 0x00, 0x73, + 0xD2, 0x9B, 0xE7, 0x26, 0xF9, 0x9F, 0x3D, 0xC3, + 0xB5, 0xC3, 0xF2, 0x81, 0x6D, 0xDE, 0x3C, 0xFE + }, + { + 0x27, 0xED, 0x40, 0xC8, 0xB6, 0x12, 0x15, 0x51, + 0x8E, 0x74, 0xF7, 0x27, 0x1E, 0xEB, 0x49, 0x72, + 0x6C, 0x21, 0x52, 0x3A, 0x97, 0x72, 0x21, 0x75, + 0xA9, 0x1E, 0x44, 0xFB, 0xBC, 0x65, 0xC7, 0xAF + }, + { + 0x14, 0x0E, 0x11, 0xC6, 0x93, 0x57, 0x00, 0x1A, + 0x40, 0xC6, 0x24, 0xC1, 0xF7, 0x4E, 0x15, 0xB0, + 0x20, 0x26, 0x45, 0x16, 0xDF, 0xF2, 0xF7, 0xA8, + 0x38, 0x17, 0x74, 0x11, 0x7F, 0x77, 0xFE, 0xC7 + }, + { + 0x32, 0xBF, 0x5A, 0x44, 0x07, 0xA5, 0x29, 0x7B, + 0x69, 0x89, 0x70, 0x9F, 0xF7, 0xAD, 0x86, 0x45, + 0xDD, 0x47, 0x46, 0x87, 0xDB, 0x98, 0x85, 0xBD, + 0xC0, 0x57, 0x45, 0x7F, 0x01, 0xC2, 0x87, 0x86 + }, + { + 0x60, 0x2C, 0x8C, 0xDE, 0xA6, 0x3A, 0xF2, 0x55, + 0xFD, 0xB4, 0x78, 0x4A, 0x9A, 0xD0, 0xF2, 0xE8, + 0x5E, 0x0A, 0x0B, 0xAC, 0xC3, 0x09, 0xF0, 0x87, + 0x3B, 0xB7, 0xD5, 0x5C, 0x88, 0x6B, 0xB0, 0x70 + }, + { + 0x9B, 0x44, 0xA4, 0xAC, 0x67, 0x9A, 0x74, 0xA7, + 0x09, 0xB4, 0x55, 0xF4, 0xBA, 0xF3, 0x02, 0x36, + 0xA8, 0xD7, 0x3B, 0x00, 0xFD, 0xFE, 0x50, 0x82, + 0xA5, 0xF9, 0x70, 0x81, 0xC6, 0x01, 0x84, 0xCA + }, + { + 0x68, 0xEF, 0x3B, 0xD1, 0x99, 0x38, 0xC9, 0x0F, + 0xE8, 0xAB, 0x79, 0x8B, 0x06, 0xE8, 0x91, 0x40, + 0xB9, 0x7C, 0xFC, 0x80, 0xAC, 0x5E, 0xBE, 0x12, + 0xD6, 0x30, 0x9B, 0x4E, 0x56, 0x20, 0xB2, 0x8E + }, + { + 0x67, 0x2A, 0x61, 0x38, 0x07, 0x0D, 0x92, 0x8A, + 0x9C, 0xDD, 0xF2, 0x0D, 0x67, 0x3C, 0x72, 0x99, + 0xA5, 0xD2, 0x20, 0xFB, 0x45, 0xF4, 0xA2, 0xB9, + 0x51, 0xF4, 0x22, 0xAF, 0x7B, 0xDB, 0x02, 0x95 + }, + { + 0xF8, 0xA1, 0x1D, 0x5B, 0x2E, 0x25, 0xAF, 0x3E, + 0xF1, 0x0E, 0x6F, 0x94, 0x5D, 0x39, 0xFC, 0x9B, + 0x98, 0x05, 0xFD, 0xD2, 0xD4, 0x48, 0x9C, 0x06, + 0xB3, 0x5F, 0x46, 0xD6, 0x3E, 0x82, 0x0A, 0x66 + }, + { + 0xB0, 0xE6, 0x6E, 0x69, 0xFE, 0x8D, 0xE7, 0x66, + 0xB4, 0x9C, 0x9C, 0x6A, 0xDA, 0xEF, 0x5F, 0xB6, + 0x09, 0xF3, 0xED, 0x32, 0xB0, 0xAC, 0x60, 0xFB, + 0xE6, 0xE7, 0xD3, 0xCC, 0x1C, 0x5C, 0xAD, 0x0D + }, + { + 0x13, 0x57, 0x1E, 0xE0, 0xA2, 0x37, 0x80, 0x9F, + 0x84, 0x06, 0xEA, 0x1E, 0xD3, 0x40, 0xF5, 0xE9, + 0x5E, 0xDF, 0xC4, 0x73, 0xD1, 0x70, 0x24, 0x7B, + 0xFB, 0xAB, 0x8E, 0xD0, 0x0B, 0xC6, 0xD2, 0xDF + }, + { + 0x35, 0x36, 0x1A, 0x14, 0x8F, 0x30, 0xD1, 0x08, + 0x09, 0x8F, 0x72, 0x2D, 0x6B, 0x64, 0x25, 0x89, + 0x61, 0xAE, 0x8E, 0xB9, 0x50, 0xCF, 0xE3, 0x15, + 0x4E, 0x84, 0x7E, 0xDB, 0x87, 0x77, 0xF2, 0x1B + }, + { + 0x22, 0x0F, 0xC2, 0xFE, 0xED, 0xE7, 0xCA, 0x2F, + 0x5B, 0xA5, 0x8D, 0x0E, 0xD2, 0x06, 0xFF, 0x05, + 0x2D, 0x61, 0xB9, 0x5A, 0x59, 0x24, 0xA3, 0xF3, + 0x02, 0x85, 0x22, 0xF7, 0x00, 0xD1, 0xE0, 0xEE + }, + { + 0x3A, 0x51, 0x11, 0x58, 0xC9, 0x91, 0x06, 0x4F, + 0x3A, 0x53, 0x70, 0xF4, 0x3A, 0x75, 0x0A, 0xF2, + 0xDE, 0x87, 0x4E, 0xF5, 0xDA, 0x09, 0x33, 0x8F, + 0x31, 0x8E, 0x78, 0x6E, 0x7A, 0xCD, 0x7E, 0x49 + }, + { + 0xD6, 0xCF, 0x9D, 0x32, 0x51, 0x08, 0xC9, 0xB9, + 0xAC, 0xE4, 0x84, 0xBC, 0x39, 0x72, 0x98, 0xEB, + 0x1E, 0xB8, 0xD7, 0x17, 0x59, 0xEC, 0xA1, 0x22, + 0x69, 0xF9, 0x9A, 0xDC, 0x05, 0x34, 0xF5, 0x83 + }, + { + 0x18, 0x1B, 0xA7, 0xFE, 0x8E, 0x58, 0xE4, 0x17, + 0xCA, 0x1F, 0xCF, 0xF1, 0x74, 0x27, 0x60, 0x08, + 0x01, 0xE3, 0x42, 0xA0, 0x1C, 0xA5, 0x04, 0x4B, + 0x46, 0x38, 0xB2, 0x2A, 0x90, 0x48, 0xDE, 0x2E + }, + { + 0x96, 0xD1, 0xF3, 0x8A, 0x68, 0x4C, 0xBA, 0x09, + 0xFC, 0x69, 0x07, 0xF4, 0x09, 0x9A, 0x09, 0xA0, + 0x04, 0xDF, 0x4B, 0xAC, 0x02, 0x17, 0xD5, 0x47, + 0x3C, 0xD8, 0xCB, 0x36, 0xC1, 0x7B, 0x16, 0x52 + }, + { + 0xE4, 0xD5, 0x4C, 0x6F, 0xDE, 0x21, 0x1D, 0x7C, + 0x7D, 0xCB, 0x83, 0xC8, 0xC5, 0x51, 0xAE, 0x8D, + 0x96, 0x97, 0xCF, 0xA5, 0x68, 0x71, 0x3F, 0x05, + 0xB3, 0x7A, 0x66, 0x5E, 0xF1, 0x19, 0x31, 0x91 + }, + { + 0x19, 0x99, 0x9D, 0xD7, 0x00, 0x03, 0x7F, 0x7B, + 0xBC, 0xCD, 0x1A, 0xDC, 0x00, 0x16, 0x27, 0x7F, + 0xAD, 0xCA, 0x5E, 0x72, 0x9F, 0x57, 0xEA, 0x60, + 0xD0, 0x4F, 0x26, 0xB8, 0x75, 0xC9, 0x60, 0xA3 + }, + { + 0x18, 0x12, 0xBD, 0x9C, 0xE7, 0xD8, 0x24, 0xB3, + 0x1C, 0x33, 0x28, 0x47, 0x40, 0x2C, 0x84, 0x39, + 0x8B, 0x4F, 0x7C, 0x48, 0xCC, 0x5E, 0x18, 0xCD, + 0xEB, 0x4B, 0xA0, 0x41, 0xE0, 0xAF, 0x4B, 0x48 + }, + { + 0xA0, 0x6E, 0x50, 0x33, 0xD9, 0x5D, 0x02, 0x8F, + 0x2F, 0xBD, 0xE0, 0x5E, 0x64, 0xB3, 0xDD, 0x04, + 0xBF, 0x40, 0x65, 0x15, 0x9B, 0xCA, 0xC6, 0x5A, + 0x66, 0x46, 0xBE, 0xED, 0xF3, 0x5A, 0x09, 0xC0 + }, + { + 0xB8, 0xF7, 0x3F, 0x1F, 0xE7, 0x02, 0xA5, 0xD3, + 0xD3, 0x39, 0xB7, 0xD6, 0xC4, 0x4D, 0x7C, 0x4D, + 0x8E, 0x6A, 0xA6, 0xB2, 0x97, 0xCC, 0x97, 0xC7, + 0xED, 0xFF, 0x12, 0x3E, 0x2B, 0xF0, 0x5F, 0x7B + }, + { + 0x22, 0x91, 0x61, 0x1A, 0xA8, 0x3B, 0x27, 0x01, + 0x03, 0xEC, 0x3E, 0x47, 0x13, 0xB7, 0x5D, 0xD3, + 0x47, 0x2C, 0xE9, 0x86, 0x63, 0x13, 0x18, 0x1F, + 0xBB, 0xA5, 0x2B, 0xC3, 0x8C, 0x1F, 0x63, 0xE8 + }, + { + 0x32, 0xC9, 0x39, 0x84, 0x31, 0x53, 0xCF, 0xD0, + 0xD9, 0x2B, 0x71, 0x35, 0x8B, 0x18, 0x12, 0x23, + 0x3D, 0x56, 0x3E, 0x92, 0xBD, 0x01, 0x4D, 0x50, + 0xA0, 0x4A, 0xC4, 0x0D, 0x1D, 0x97, 0x76, 0x7C + }, + { + 0x91, 0x2F, 0x77, 0x65, 0x5D, 0x87, 0xDF, 0x32, + 0x5E, 0xF8, 0xF2, 0xFB, 0xC7, 0x2B, 0xD9, 0x2D, + 0xF9, 0x40, 0xF2, 0x29, 0x84, 0xF4, 0x05, 0x94, + 0x81, 0x4F, 0x7A, 0x14, 0x50, 0xA6, 0x00, 0x4C + }, + { + 0x27, 0xB9, 0x85, 0xF7, 0x09, 0x20, 0x63, 0x76, + 0x35, 0xE7, 0xBC, 0x2F, 0x34, 0x2C, 0xE6, 0xE3, + 0xAB, 0x7E, 0xE3, 0x85, 0x6C, 0x6A, 0x2D, 0xCF, + 0x48, 0xF6, 0xDE, 0x78, 0x0A, 0xBB, 0xFC, 0x85 + }, + { + 0x2A, 0xB9, 0x8C, 0xC6, 0x4F, 0xFC, 0x0A, 0x2F, + 0x48, 0x06, 0x04, 0xA4, 0x24, 0xDF, 0xA8, 0xF2, + 0x00, 0xAA, 0xE2, 0x2F, 0xDC, 0x76, 0x89, 0xB5, + 0x48, 0xF8, 0x74, 0xCD, 0x0F, 0x1E, 0xAD, 0xE4 + }, + { + 0x4D, 0xEF, 0xB7, 0xA7, 0xB9, 0xB2, 0x36, 0xAB, + 0x85, 0x66, 0x0B, 0x72, 0xA3, 0x38, 0x2F, 0x24, + 0x15, 0x62, 0xF9, 0x33, 0x55, 0x39, 0x86, 0x9E, + 0x14, 0x96, 0x39, 0x96, 0x27, 0x3D, 0x47, 0x2E + }, + { + 0xFF, 0x04, 0x78, 0xB7, 0xFA, 0x62, 0x00, 0x4A, + 0xFD, 0xF1, 0x17, 0x61, 0x97, 0xA9, 0x43, 0x13, + 0x8C, 0x94, 0x01, 0xAA, 0xB2, 0xDA, 0xC9, 0x88, + 0x70, 0x3F, 0xF1, 0x2B, 0x0D, 0xE5, 0xE6, 0xB1 + }, + { + 0x1C, 0x12, 0x97, 0xEF, 0xFC, 0xE5, 0x5A, 0x7D, + 0xA5, 0x3D, 0xD6, 0xB3, 0xCD, 0x58, 0x6C, 0xF4, + 0x98, 0x49, 0x82, 0x75, 0xF6, 0x66, 0xC2, 0x67, + 0xDD, 0x16, 0xA0, 0x9F, 0x9B, 0x9F, 0x9D, 0x5A + }, + { + 0x8D, 0x50, 0x88, 0xB7, 0xC1, 0x0F, 0xCA, 0x03, + 0x63, 0x8E, 0xDF, 0x9C, 0x7A, 0xD0, 0x87, 0xFB, + 0x00, 0x27, 0xBE, 0xD8, 0x62, 0x7B, 0xA9, 0x94, + 0x4C, 0xB0, 0xCA, 0x2F, 0x52, 0x8E, 0xFF, 0xFD + }, + { + 0x24, 0xDB, 0xAC, 0xDF, 0xE5, 0x7D, 0x97, 0x41, + 0xAA, 0x79, 0x1E, 0xCB, 0x9E, 0xAC, 0x20, 0xDF, + 0x48, 0xB1, 0xD5, 0xA9, 0xA2, 0x4C, 0x63, 0x3F, + 0xB9, 0x2E, 0x51, 0x9C, 0x93, 0xC3, 0x16, 0x07 + }, + { + 0x39, 0xAC, 0xF1, 0xBC, 0x0F, 0x55, 0xA2, 0x7A, + 0xF8, 0xB0, 0x02, 0x49, 0x5A, 0x68, 0x39, 0x6A, + 0x6D, 0x0F, 0x29, 0x60, 0x92, 0xF7, 0x2D, 0x8A, + 0x18, 0xE7, 0x24, 0x10, 0xE8, 0x22, 0x21, 0x1F + }, + { + 0x78, 0x3E, 0x30, 0x1F, 0x1F, 0x31, 0x6C, 0xED, + 0xC0, 0xE7, 0x9A, 0x5D, 0x7A, 0x0D, 0xDC, 0x0B, + 0x67, 0x14, 0xA1, 0x98, 0x3B, 0xF0, 0x75, 0x7F, + 0x2D, 0x52, 0x6C, 0xD6, 0xFF, 0x6E, 0x71, 0x9F + }, + { + 0xD2, 0x96, 0x32, 0x21, 0xB1, 0xCB, 0xEA, 0xD1, + 0x1A, 0x4E, 0xEA, 0x17, 0x40, 0x6F, 0x96, 0xE8, + 0xE8, 0xC2, 0x47, 0xD4, 0x8C, 0x4C, 0x58, 0x1F, + 0x91, 0xBB, 0xF0, 0x2F, 0x52, 0x3A, 0x34, 0xC1 + }, + { + 0x75, 0x11, 0xD0, 0x4C, 0x95, 0x04, 0xEF, 0x2B, + 0xAA, 0xA8, 0xA3, 0x51, 0x1E, 0xD9, 0xBA, 0x5A, + 0xAC, 0xFF, 0x4B, 0x5F, 0x85, 0x25, 0xDB, 0x83, + 0xCC, 0x66, 0xAC, 0xEC, 0xF1, 0x67, 0x87, 0xA8 + }, + { + 0xD2, 0x18, 0x7D, 0x66, 0xAC, 0x31, 0x15, 0x6F, + 0x10, 0x3A, 0x87, 0x51, 0x7E, 0xDE, 0xF3, 0x77, + 0xD8, 0xFF, 0x3A, 0xA3, 0x13, 0x9D, 0x78, 0x50, + 0x45, 0x00, 0xED, 0x28, 0xDD, 0x3C, 0x4D, 0x07 + }, + { + 0xFD, 0x97, 0xAC, 0xA6, 0x6C, 0xD1, 0xD4, 0x86, + 0x01, 0x73, 0xAB, 0xC2, 0x18, 0x69, 0x2C, 0xB1, + 0x18, 0x57, 0x6E, 0x90, 0x0C, 0x1D, 0x24, 0xA0, + 0xF3, 0x18, 0xB1, 0x26, 0x65, 0xC2, 0x40, 0x80 + }, + { + 0x64, 0x21, 0x67, 0x64, 0x79, 0xAF, 0x9C, 0xBC, + 0xF5, 0x3F, 0x08, 0xB5, 0xCB, 0x14, 0xCF, 0x80, + 0xF4, 0xFC, 0xF4, 0x84, 0xB1, 0x48, 0xAC, 0xC6, + 0xE9, 0x7A, 0x6B, 0x1E, 0x18, 0xDA, 0x55, 0xFC + }, + { + 0x43, 0x93, 0x9B, 0xF5, 0x4A, 0xC1, 0xBD, 0x24, + 0xCD, 0xE2, 0x17, 0x4E, 0x54, 0x39, 0x64, 0xF8, + 0xF9, 0x84, 0xBA, 0xED, 0x34, 0x82, 0x60, 0xA7, + 0x43, 0x3C, 0x3D, 0xB6, 0x48, 0xB7, 0xF0, 0x69 + }, + { + 0xA8, 0x36, 0x92, 0x1E, 0xFF, 0x48, 0xBA, 0x51, + 0x9C, 0x1C, 0x9E, 0xF2, 0x25, 0x8B, 0x13, 0xBD, + 0x64, 0x04, 0x0D, 0xC9, 0xC9, 0x2B, 0x1C, 0x0E, + 0xCB, 0x55, 0x2B, 0x26, 0x23, 0x6B, 0x58, 0x05 + }, + { + 0x14, 0x25, 0x7C, 0x5C, 0x82, 0x3C, 0xA6, 0xC2, + 0x15, 0x17, 0x0B, 0x21, 0x45, 0x60, 0x14, 0x4F, + 0xDF, 0xB9, 0xBA, 0xB2, 0xAE, 0x46, 0x19, 0xEA, + 0x9B, 0x53, 0xD0, 0xF1, 0x7E, 0xED, 0xF4, 0xF1 + }, + { + 0xA8, 0xD5, 0x13, 0x73, 0xBD, 0x73, 0xFE, 0x49, + 0x6E, 0x0B, 0x68, 0x13, 0x08, 0x84, 0x22, 0x7B, + 0x9C, 0xFF, 0x99, 0xC5, 0x18, 0x22, 0xE1, 0xA8, + 0xBD, 0xEB, 0x5D, 0x99, 0xCA, 0xF0, 0x44, 0xD8 + }, + { + 0xA7, 0xAC, 0xFD, 0x40, 0x76, 0x7D, 0x65, 0x25, + 0x4C, 0xE5, 0xAD, 0x75, 0x07, 0xAC, 0xB4, 0x70, + 0xF7, 0xBB, 0x50, 0x59, 0x2D, 0x21, 0x3F, 0xE0, + 0x30, 0xEA, 0x58, 0xAD, 0x05, 0x19, 0x47, 0xB7 + }, + { + 0x88, 0x0B, 0x49, 0x85, 0x5A, 0x71, 0x2D, 0xE6, + 0xA7, 0x9E, 0xB7, 0x36, 0xD2, 0x2B, 0xCC, 0x7C, + 0x73, 0xAE, 0x6D, 0xF9, 0xB7, 0xD9, 0xED, 0x05, + 0xED, 0xDB, 0x05, 0x9B, 0x27, 0x57, 0xFF, 0xD8 + }, + { + 0x0A, 0xC6, 0x71, 0xA5, 0x88, 0x0B, 0xB0, 0x40, + 0x29, 0x41, 0xAD, 0x97, 0x10, 0xD1, 0xF3, 0xD6, + 0x8D, 0xD0, 0xA9, 0x05, 0xC5, 0x54, 0xC8, 0xA4, + 0xBC, 0xC1, 0x7C, 0xB6, 0x60, 0xEF, 0x5D, 0xB7 + }, + { + 0xD3, 0x35, 0x4C, 0x43, 0x06, 0xE9, 0x9B, 0x3E, + 0x77, 0xEA, 0x76, 0xAC, 0x3C, 0xEC, 0x90, 0x25, + 0x22, 0xC7, 0x5E, 0xEC, 0xD3, 0xE8, 0xFC, 0x54, + 0x6C, 0x49, 0x42, 0xF8, 0xB3, 0xB4, 0xCA, 0x2B + }, + { + 0x17, 0x61, 0xDF, 0x43, 0xFC, 0x75, 0xE7, 0x0C, + 0x29, 0xC2, 0x62, 0xA9, 0x62, 0xD4, 0x96, 0xBC, + 0x81, 0x11, 0x4D, 0xFA, 0xF0, 0x53, 0xB9, 0x9A, + 0xE3, 0x8C, 0x40, 0xF4, 0x2E, 0xCC, 0x5A, 0x9F + }, + { + 0x70, 0x63, 0x10, 0xC6, 0x85, 0x22, 0x81, 0x35, + 0x57, 0x7F, 0x70, 0x84, 0x2B, 0xF4, 0xB0, 0xCF, + 0xCD, 0x38, 0x38, 0xD6, 0x4D, 0xB3, 0xA3, 0x22, + 0xBF, 0x1E, 0x80, 0x3D, 0x40, 0xAC, 0x85, 0x3D + }, + { + 0x57, 0xD1, 0x0C, 0x07, 0x3E, 0x09, 0x8B, 0x3A, + 0x0C, 0x1E, 0x3E, 0x0A, 0x44, 0x30, 0xFC, 0x34, + 0x10, 0x6C, 0x32, 0x6D, 0xC9, 0x84, 0xF3, 0x6F, + 0xA5, 0x50, 0xBE, 0x1C, 0x22, 0xBA, 0x6E, 0xA6 + }, + { + 0x80, 0xB9, 0x7F, 0x41, 0xD0, 0x3A, 0xD7, 0x00, + 0x04, 0x3A, 0x77, 0xD2, 0x50, 0xE6, 0x36, 0xBC, + 0x1A, 0xFF, 0xF4, 0xE4, 0x05, 0x73, 0xDD, 0xE0, + 0x12, 0xE8, 0xF9, 0x70, 0x24, 0x9F, 0x79, 0x52 + }, + { + 0xE5, 0x52, 0xE9, 0x91, 0x5D, 0x79, 0x5A, 0xA7, + 0x09, 0x03, 0x2C, 0xE6, 0x74, 0x64, 0x93, 0x51, + 0x38, 0x35, 0x00, 0x9D, 0x75, 0xD3, 0x7F, 0xF9, + 0xC2, 0x5E, 0x2E, 0x5E, 0x96, 0x85, 0xB4, 0x0A + }, + { + 0x32, 0x6B, 0x86, 0xA7, 0xB3, 0xB6, 0xB6, 0x28, + 0x76, 0x0E, 0x12, 0xD1, 0x1B, 0x12, 0xDC, 0xD5, + 0xF2, 0x45, 0x3A, 0x89, 0x0E, 0x1C, 0xE2, 0xBF, + 0x64, 0x7D, 0x54, 0x50, 0xED, 0xA3, 0x49, 0xB8 + }, + { + 0x14, 0xF2, 0x76, 0x80, 0x29, 0x3D, 0xD9, 0x6C, + 0x95, 0xC6, 0x2B, 0x79, 0x57, 0x73, 0xC0, 0x55, + 0xE1, 0x96, 0x59, 0x84, 0xB8, 0xE9, 0xF7, 0x4D, + 0x90, 0x35, 0xF3, 0xDD, 0x8E, 0xCB, 0xF5, 0xC9 + }, + { + 0x2F, 0x6B, 0x41, 0x91, 0x53, 0x6D, 0x35, 0x20, + 0x48, 0xB9, 0x92, 0xB0, 0x85, 0x36, 0x58, 0x32, + 0x6E, 0x4F, 0xF9, 0x2F, 0x9E, 0xAF, 0x90, 0x56, + 0xF9, 0x1E, 0xAB, 0x9A, 0xDD, 0x3D, 0xEC, 0x95 + }, + { + 0xEB, 0x3C, 0xAE, 0xFF, 0xA1, 0xF7, 0x63, 0xA7, + 0xE4, 0xDA, 0x1E, 0xE0, 0x05, 0x3D, 0x07, 0xA4, + 0x10, 0x43, 0xF3, 0xB7, 0x51, 0x53, 0x8D, 0xE2, + 0x7E, 0x0E, 0x9C, 0x10, 0x5C, 0xCA, 0x43, 0xF6 + }, + { + 0x69, 0x11, 0xB3, 0xE6, 0xD3, 0x79, 0xCE, 0xE5, + 0x12, 0x27, 0x73, 0x8B, 0xA0, 0x32, 0x01, 0xA1, + 0x3B, 0x86, 0x25, 0x5F, 0x86, 0xE6, 0xDB, 0x90, + 0x70, 0x62, 0x9C, 0x8F, 0x9A, 0xC6, 0xFC, 0x14 + }, + { + 0x5C, 0x3E, 0xDF, 0x22, 0x2E, 0x41, 0x69, 0xCE, + 0x89, 0x01, 0x3B, 0x2B, 0x64, 0x86, 0x68, 0x59, + 0x56, 0xB1, 0xBE, 0x5A, 0x28, 0xAC, 0xA4, 0x0B, + 0x6A, 0x29, 0x37, 0xF4, 0x56, 0xD8, 0x81, 0x55 + }, + { + 0xF5, 0x5F, 0x54, 0x9B, 0xF1, 0xBB, 0x3F, 0xC1, + 0x41, 0x1A, 0xF7, 0xC2, 0xA7, 0x2D, 0xDE, 0x52, + 0x2D, 0xC6, 0x0C, 0xB7, 0x10, 0xC7, 0x93, 0x6E, + 0xB0, 0xC8, 0xB3, 0x35, 0x67, 0xAE, 0xDA, 0x90 + }, + { + 0x33, 0xEA, 0x19, 0x10, 0x1D, 0xB9, 0x8A, 0x70, + 0x68, 0x77, 0xCC, 0x3C, 0x38, 0xEB, 0x16, 0x41, + 0xD7, 0x7F, 0xDD, 0x9B, 0xB6, 0xF0, 0x17, 0x47, + 0xDE, 0x78, 0x10, 0xBF, 0xE1, 0x69, 0x28, 0x4A + }, + { + 0x97, 0x83, 0xB4, 0x80, 0x76, 0x17, 0x52, 0xED, + 0xF5, 0x53, 0x2E, 0xD9, 0xDC, 0x75, 0xE5, 0xD0, + 0x14, 0xD1, 0x40, 0xAE, 0x1E, 0x71, 0xBC, 0xFD, + 0xBC, 0x53, 0x26, 0x40, 0x0B, 0x4B, 0x1C, 0xB4 + }, + { + 0x12, 0x37, 0x68, 0xE3, 0xF0, 0x92, 0x20, 0x86, + 0x25, 0xCF, 0xFF, 0xDD, 0x22, 0x02, 0xB1, 0xC1, + 0xBA, 0xF6, 0x4B, 0x56, 0xE2, 0x5E, 0xAA, 0x9E, + 0xA3, 0x70, 0xBD, 0xF7, 0x7A, 0x89, 0x9D, 0x50 + }, + { + 0x48, 0xEE, 0x10, 0x8C, 0xB9, 0xD6, 0x91, 0xCE, + 0x60, 0x19, 0x9D, 0x60, 0x50, 0x77, 0x57, 0x58, + 0xF2, 0xD7, 0x90, 0x82, 0x4D, 0xF6, 0x08, 0xF3, + 0x0B, 0x48, 0x8E, 0xB2, 0xFB, 0x26, 0x6B, 0xE7 + }, + { + 0xAA, 0x23, 0x6E, 0x62, 0x0F, 0xFD, 0x68, 0xA2, + 0xDB, 0x42, 0x11, 0x6D, 0xC5, 0xC9, 0xC4, 0xE5, + 0x15, 0x53, 0x75, 0xCC, 0x8A, 0xE7, 0x3D, 0x9B, + 0xFA, 0x41, 0x71, 0xEB, 0xDD, 0x5C, 0x9F, 0x53 + }, + { + 0x4E, 0x03, 0xDC, 0x75, 0x0A, 0x7A, 0xA8, 0x79, + 0xFE, 0xA0, 0xBD, 0xD1, 0xDB, 0x83, 0xB5, 0x86, + 0xF2, 0x97, 0x85, 0xF9, 0x6E, 0x88, 0x24, 0xCB, + 0x7B, 0x5B, 0xAE, 0xF0, 0x7F, 0xB7, 0x79, 0xB8 + }, + { + 0x53, 0x6B, 0x1C, 0xBF, 0x7F, 0x29, 0xEB, 0x4B, + 0xE4, 0xB0, 0xD7, 0x8A, 0xC0, 0xBE, 0xCD, 0xC5, + 0x1A, 0xAD, 0x79, 0x6F, 0x5F, 0x73, 0x71, 0x4E, + 0xA4, 0x0A, 0x19, 0xAF, 0x01, 0xB5, 0xC2, 0xA5 + }, + { + 0x20, 0x1F, 0x0B, 0xF0, 0x5C, 0xEA, 0xCE, 0x13, + 0x8B, 0x29, 0xCD, 0x0C, 0x66, 0xBA, 0x29, 0xFC, + 0x54, 0xAD, 0xB0, 0xD7, 0x76, 0x0F, 0xDD, 0x3C, + 0x5E, 0x60, 0xD0, 0x18, 0x6A, 0xEB, 0x94, 0x10 + }, + { + 0xEF, 0xE2, 0x42, 0xAF, 0x57, 0x70, 0x1B, 0xCE, + 0xEA, 0x24, 0xF4, 0x82, 0x5B, 0xD1, 0xC5, 0x03, + 0x1D, 0x68, 0x63, 0x97, 0x5D, 0xE4, 0xCF, 0xCD, + 0x91, 0x76, 0xB8, 0x82, 0xAF, 0x53, 0xB4, 0xF2 + }, + { + 0xF1, 0x3A, 0x32, 0x1A, 0xF4, 0x44, 0xD1, 0xF6, + 0x2C, 0x0A, 0xA7, 0x85, 0x95, 0x21, 0x89, 0x2C, + 0xAF, 0x37, 0x19, 0xBA, 0xB8, 0x88, 0xCA, 0x37, + 0xFB, 0x29, 0x2E, 0x7E, 0x1B, 0x10, 0x40, 0xD3 + }, + { + 0xF2, 0x42, 0x39, 0xA4, 0x36, 0xF1, 0xA2, 0x5C, + 0x66, 0xC8, 0x86, 0x90, 0x5E, 0x6A, 0xFC, 0x17, + 0x3B, 0x85, 0x4D, 0xC7, 0xBC, 0x7C, 0x77, 0xE7, + 0x8B, 0x81, 0xED, 0x65, 0x56, 0x48, 0xA6, 0x42 + }, + { + 0x16, 0xDE, 0x78, 0x2F, 0x65, 0x11, 0xD1, 0x68, + 0x27, 0x57, 0x3B, 0x76, 0x6A, 0x57, 0xAB, 0xD9, + 0xE9, 0xB6, 0x06, 0x64, 0x3C, 0x1D, 0xA5, 0xDA, + 0x49, 0xC2, 0xE2, 0x76, 0xCB, 0x6D, 0x8A, 0x92 + }, + { + 0x4E, 0x61, 0xBB, 0x92, 0xE4, 0xBB, 0xA5, 0x37, + 0x4C, 0xD7, 0xC4, 0xD6, 0xF8, 0xA7, 0xDC, 0x1C, + 0x9E, 0xEB, 0x8E, 0x0F, 0x32, 0x00, 0x11, 0x24, + 0x80, 0x5E, 0x18, 0x9D, 0xB2, 0x76, 0xB3, 0xB3 + }, + { + 0x18, 0x59, 0xF6, 0xEB, 0xE4, 0x07, 0xF4, 0x61, + 0x6F, 0x1B, 0x34, 0xBE, 0x54, 0xE6, 0x69, 0xF0, + 0xCE, 0xF0, 0xE5, 0x2B, 0xD8, 0x1A, 0x5F, 0xE0, + 0x7F, 0x60, 0xC0, 0x01, 0xDB, 0x8B, 0x74, 0xB2 + }, + { + 0x6B, 0x0F, 0x50, 0x59, 0xEE, 0x7B, 0x5A, 0xCB, + 0xE2, 0xE0, 0x0D, 0x32, 0xA6, 0xB3, 0xB9, 0xD8, + 0x30, 0x01, 0xAA, 0x02, 0xDF, 0x3F, 0xA8, 0x6A, + 0x4B, 0xBE, 0x5F, 0xA8, 0xB1, 0xDA, 0xEE, 0xAA + }, + { + 0x3E, 0xF8, 0x49, 0x3F, 0xE5, 0x13, 0x64, 0x25, + 0xE3, 0xDA, 0x74, 0x24, 0x8C, 0xD8, 0x45, 0xA2, + 0xB5, 0x4A, 0x34, 0xB8, 0x3F, 0xEA, 0xEE, 0x80, + 0xCB, 0x02, 0xBD, 0x43, 0x91, 0xCD, 0xE8, 0x77 + }, + { + 0x1C, 0x58, 0x04, 0x23, 0xF7, 0x53, 0x6A, 0xB5, + 0x16, 0x36, 0x28, 0x62, 0x64, 0x45, 0x7A, 0xE6, + 0xF4, 0x47, 0xDB, 0x32, 0xE3, 0xD2, 0x4D, 0x3B, + 0xB3, 0xDD, 0x90, 0x43, 0x7B, 0xF0, 0x31, 0xB4 + }, + { + 0x35, 0x48, 0x51, 0x6A, 0x32, 0x97, 0xE1, 0xA1, + 0xCE, 0x05, 0x91, 0x9D, 0xAD, 0x49, 0xA8, 0x93, + 0x63, 0xF2, 0x1D, 0x59, 0x82, 0x65, 0xE9, 0x3A, + 0xB3, 0x8F, 0x09, 0xA9, 0x00, 0x8E, 0xB7, 0x45 + }, + { + 0x39, 0x2C, 0x30, 0x79, 0xDC, 0xED, 0xCC, 0xD1, + 0x82, 0x0E, 0x9E, 0x1B, 0x89, 0xAF, 0xA9, 0x70, + 0xC8, 0xCE, 0x69, 0x34, 0xE1, 0x22, 0x16, 0x78, + 0xB7, 0x48, 0x6B, 0x68, 0xD5, 0xD1, 0x52, 0x9D + }, + { + 0x2C, 0x8A, 0xE2, 0x9B, 0x2E, 0xA7, 0x46, 0x0B, + 0x4C, 0xFB, 0x07, 0x7B, 0x77, 0xE8, 0x82, 0x78, + 0x58, 0xAE, 0x6C, 0xD4, 0x0A, 0xA8, 0xC5, 0x4B, + 0xBF, 0x28, 0x6A, 0xA2, 0x41, 0x65, 0xCA, 0x3B + }, + { + 0x05, 0xE9, 0xB0, 0x71, 0xE0, 0x6C, 0x83, 0x45, + 0x6C, 0xE7, 0x41, 0xCB, 0x89, 0x8E, 0xBD, 0xC2, + 0x82, 0xAC, 0x02, 0x8F, 0x00, 0xC1, 0x6D, 0x85, + 0x13, 0xB3, 0x0C, 0xE1, 0x2E, 0x82, 0xDA, 0xAC + }, + { + 0x20, 0xAE, 0xB8, 0xDD, 0xB3, 0xA6, 0x03, 0xE9, + 0x6E, 0x72, 0xA2, 0x65, 0x44, 0x0E, 0x01, 0xCF, + 0xC4, 0x5F, 0xCE, 0x3E, 0xD7, 0xF9, 0x95, 0xD6, + 0x78, 0xB7, 0xD1, 0x62, 0x78, 0xA2, 0x43, 0x87 + }, + { + 0xA7, 0x35, 0x72, 0x15, 0x01, 0xFC, 0x8D, 0x80, + 0x0E, 0x9D, 0xA6, 0x2E, 0xC8, 0xCE, 0xDF, 0xEA, + 0x87, 0xA0, 0xEE, 0xD4, 0xFE, 0xE8, 0x1D, 0x8E, + 0x91, 0xAB, 0x68, 0x0F, 0xDE, 0x9B, 0x66, 0xCC + }, + { + 0x43, 0x3A, 0xE6, 0x4B, 0xBF, 0x21, 0xE1, 0xFC, + 0x19, 0xC7, 0xAE, 0x2B, 0xAD, 0xF8, 0xB8, 0xA4, + 0x73, 0xD7, 0xAC, 0x63, 0xE7, 0x6A, 0x84, 0xD5, + 0x26, 0x99, 0x48, 0x12, 0xEE, 0x2F, 0x3C, 0x1C + }, + { + 0x91, 0x59, 0x98, 0x01, 0x3A, 0xE2, 0x39, 0xC1, + 0x2D, 0xD8, 0x33, 0xAE, 0xAF, 0xCC, 0x7B, 0x9D, + 0x21, 0xA2, 0xE6, 0xD3, 0x0D, 0xD0, 0xA0, 0xBE, + 0xB4, 0xBD, 0xFF, 0x74, 0xF7, 0x01, 0x8B, 0xEC + }, + { + 0x51, 0x5E, 0x2A, 0x00, 0x48, 0x31, 0xB8, 0x2A, + 0xA8, 0x98, 0x15, 0x67, 0x57, 0xDF, 0x51, 0x3A, + 0xCF, 0x4A, 0xE1, 0xAC, 0x47, 0x9E, 0xCF, 0x18, + 0x49, 0xCB, 0x36, 0x45, 0x8F, 0x5B, 0xDE, 0xFA + }, + { + 0x5F, 0x28, 0xBD, 0xAA, 0x7D, 0x56, 0x38, 0x0E, + 0xF7, 0x29, 0xE6, 0x54, 0x57, 0x81, 0xBB, 0x04, + 0x83, 0x03, 0xBC, 0x73, 0x22, 0x6D, 0x77, 0x18, + 0x93, 0xF9, 0xBF, 0xD6, 0x42, 0x9A, 0x80, 0x40 + }, + { + 0xB8, 0x2E, 0xFF, 0x4A, 0xE5, 0xD8, 0x10, 0x57, + 0x19, 0xD0, 0x83, 0x70, 0xBA, 0x52, 0x98, 0xCD, + 0x56, 0xC4, 0x6B, 0x18, 0xE6, 0xAF, 0xC9, 0x94, + 0xC2, 0x55, 0x22, 0x80, 0xBF, 0x01, 0x3C, 0x7B + }, + { + 0xC5, 0x77, 0xC6, 0xC8, 0x91, 0x76, 0x84, 0x44, + 0xFB, 0xAA, 0x77, 0x0E, 0x54, 0x4F, 0xF1, 0x98, + 0xD5, 0x31, 0x4A, 0x31, 0xB3, 0xC2, 0x31, 0xF4, + 0x3A, 0x52, 0xBC, 0xD2, 0x04, 0xC6, 0xB2, 0x57 + }, + { + 0x7E, 0xF6, 0x3F, 0x91, 0x29, 0xEF, 0x16, 0xA4, + 0x21, 0xE4, 0x1F, 0x9B, 0x17, 0x6C, 0xAF, 0xFC, + 0x10, 0xB2, 0x3C, 0x8E, 0x61, 0x4D, 0x6C, 0xE9, + 0xCE, 0x53, 0x72, 0xF4, 0x14, 0x81, 0x26, 0xC7 + }, + { + 0xE5, 0xF7, 0x99, 0xCA, 0x0E, 0xA8, 0xF8, 0x9D, + 0xD4, 0xF6, 0x04, 0xAE, 0x97, 0x8B, 0xA2, 0x4E, + 0x92, 0x92, 0xAF, 0x59, 0x04, 0x1E, 0xD6, 0x5F, + 0xC8, 0x03, 0x7E, 0x9D, 0x7C, 0x01, 0x94, 0x66 + }, + { + 0x97, 0x29, 0xF0, 0x2F, 0x32, 0xB6, 0xE8, 0x60, + 0x02, 0xD1, 0x5A, 0xE4, 0xE8, 0x06, 0x83, 0x6E, + 0x5E, 0x77, 0x33, 0x73, 0x2E, 0xDF, 0xDD, 0xA6, + 0x30, 0x4E, 0x8D, 0x2C, 0xC6, 0x6B, 0x9F, 0x7C + }, + { + 0x6B, 0xA8, 0x8D, 0xA3, 0xFA, 0x2B, 0xB5, 0x09, + 0x4C, 0x79, 0x4C, 0x31, 0xAB, 0xAB, 0x1B, 0x6A, + 0x95, 0x42, 0x2E, 0xE9, 0x86, 0x7A, 0xE8, 0xBD, + 0xB9, 0x04, 0xC7, 0x52, 0xBD, 0xBB, 0x64, 0x52 + }, + { + 0x2C, 0xEB, 0xEE, 0x5F, 0x5A, 0x64, 0x88, 0x23, + 0x2D, 0x9F, 0x3B, 0xBF, 0xC8, 0xCD, 0x0A, 0x6B, + 0x97, 0x05, 0x6C, 0xEA, 0x91, 0xFF, 0xA7, 0x64, + 0x70, 0xB2, 0xF2, 0x1D, 0x5B, 0x1B, 0x57, 0xD9 + }, + { + 0x43, 0xA7, 0xF8, 0x57, 0xA5, 0x64, 0x05, 0x07, + 0x20, 0x31, 0x24, 0xAB, 0x20, 0x8B, 0xFA, 0x88, + 0x68, 0xC6, 0xFA, 0xF8, 0x81, 0x28, 0x37, 0xA6, + 0x1C, 0xBF, 0xB6, 0xA9, 0x8C, 0x41, 0x73, 0x3D + }, + { + 0x31, 0xB7, 0x9A, 0xAB, 0x02, 0x71, 0xD4, 0x69, + 0x6A, 0x18, 0xC1, 0x10, 0x47, 0x4B, 0x6A, 0x71, + 0xA7, 0x7D, 0x49, 0xB7, 0x50, 0x15, 0x01, 0xA8, + 0x60, 0x05, 0x34, 0x65, 0x8E, 0x8F, 0x89, 0xA4 + }, + { + 0x01, 0x58, 0x50, 0xE0, 0xCE, 0xA6, 0x42, 0x42, + 0xA5, 0x8F, 0x8C, 0xCE, 0x7A, 0x83, 0x20, 0x42, + 0x2F, 0x76, 0x8F, 0xC9, 0xC2, 0xEE, 0x7D, 0xF2, + 0x99, 0x89, 0x4F, 0xD9, 0xA3, 0xF0, 0x31, 0xDB + }, + { + 0x96, 0xFD, 0xB7, 0x9F, 0x40, 0xC5, 0x9A, 0xF7, + 0x8F, 0xED, 0x75, 0xB5, 0x26, 0xCD, 0xFE, 0xA4, + 0x09, 0x82, 0xDD, 0x43, 0xD8, 0x3F, 0x13, 0x22, + 0x20, 0x5D, 0x3C, 0x31, 0x7F, 0x60, 0x44, 0x05 + }, + { + 0xB2, 0xE4, 0x7F, 0x15, 0x8F, 0x77, 0xC8, 0x73, + 0xD7, 0x9F, 0xB4, 0xEE, 0x9B, 0x0E, 0x86, 0xFE, + 0x83, 0x98, 0x4D, 0x72, 0xB8, 0xC7, 0x4D, 0xB7, + 0x71, 0xB9, 0x98, 0xEE, 0x74, 0x16, 0xC3, 0xC8 + }, + { + 0x26, 0x61, 0xF8, 0xA6, 0xA0, 0xB0, 0xB0, 0x7D, + 0x25, 0x70, 0xBA, 0x7E, 0x69, 0xC4, 0x09, 0x19, + 0xB1, 0xA2, 0x8A, 0xA8, 0x5C, 0xA6, 0x54, 0xEF, + 0xF8, 0xDD, 0xEC, 0x62, 0x7B, 0x3D, 0x85, 0xF6 + }, + { + 0xC3, 0x94, 0x48, 0xA2, 0x80, 0xC4, 0xEE, 0x54, + 0xCF, 0x6E, 0xDC, 0x07, 0x06, 0x6C, 0x50, 0x83, + 0x67, 0x99, 0x8F, 0x47, 0x7A, 0xC3, 0x43, 0xFF, + 0x2E, 0xF9, 0x77, 0x45, 0xE0, 0x94, 0xBF, 0x9B + }, + { + 0x1C, 0xDC, 0xB9, 0xCD, 0x67, 0xDF, 0xD9, 0x62, + 0x7E, 0x16, 0x18, 0x1B, 0xFC, 0xD0, 0xE0, 0x86, + 0x0E, 0xC0, 0x4D, 0xC8, 0x8B, 0x3C, 0x0C, 0x6E, + 0xE7, 0x3C, 0xB8, 0xB9, 0x45, 0x1F, 0xB3, 0xBF + }, + { + 0xFB, 0x7D, 0x35, 0x30, 0xF0, 0x14, 0x8C, 0xA2, + 0x6F, 0x4B, 0xE2, 0xED, 0x34, 0x89, 0xE8, 0x5D, + 0xB7, 0xC8, 0xE7, 0x8A, 0x74, 0x59, 0x87, 0x2F, + 0x10, 0xE0, 0xE2, 0x98, 0x5E, 0xA5, 0x00, 0x62 + }, + { + 0xEC, 0x5D, 0x0F, 0x39, 0x54, 0x9D, 0x37, 0xDA, + 0xD2, 0xA3, 0x71, 0x0E, 0x7E, 0x35, 0x7A, 0xB8, + 0x15, 0x95, 0x4E, 0x59, 0xA9, 0x4E, 0xDE, 0xD2, + 0xB9, 0x95, 0x2C, 0x62, 0xF8, 0x23, 0x96, 0xBA + }, + { + 0x6F, 0x2A, 0xAB, 0xDC, 0x80, 0x73, 0xA8, 0xB6, + 0x72, 0x62, 0x87, 0x9B, 0x9F, 0xF7, 0xED, 0x17, + 0x73, 0x5A, 0x3A, 0xD7, 0xAB, 0xB2, 0x39, 0xC9, + 0xE8, 0x43, 0x66, 0xA9, 0xB5, 0xB4, 0x2D, 0xB8 + }, + { + 0x36, 0x94, 0x89, 0x9B, 0x04, 0x57, 0xD8, 0x08, + 0x16, 0xBF, 0xB7, 0x89, 0x3B, 0x2D, 0xA8, 0xE7, + 0x3F, 0x53, 0x5C, 0x88, 0xA7, 0x7F, 0xAD, 0xEB, + 0xE6, 0x24, 0x7E, 0xB4, 0x14, 0xF4, 0x87, 0x6C + }, + { + 0xC3, 0xFA, 0x22, 0x06, 0xCB, 0xCF, 0x16, 0x44, + 0x97, 0xE8, 0x43, 0x5A, 0xC6, 0x60, 0xD7, 0x71, + 0x76, 0x26, 0x8A, 0xFC, 0xF4, 0xA6, 0x27, 0x15, + 0x36, 0x6D, 0xA5, 0xDF, 0x1A, 0xD3, 0xBE, 0xAD + }, + { + 0x71, 0xA5, 0xC4, 0xAC, 0x42, 0x48, 0xFD, 0x6E, + 0xF5, 0x6A, 0xD4, 0x4E, 0x90, 0x13, 0x53, 0x51, + 0xE4, 0xAA, 0x03, 0x88, 0xE5, 0x51, 0xB3, 0x7E, + 0xDF, 0xCC, 0x6A, 0x5F, 0xBB, 0x26, 0x7E, 0x48 + }, + { + 0x53, 0x5F, 0xBB, 0x4E, 0x62, 0x0E, 0x51, 0x66, + 0xAB, 0x6A, 0x6A, 0x3E, 0xFD, 0x4E, 0xC5, 0x19, + 0x28, 0x1A, 0x94, 0x9E, 0xBF, 0x6A, 0xE1, 0xD9, + 0xA1, 0xC1, 0xF2, 0x9B, 0x72, 0x58, 0xCD, 0xE9 + }, + { + 0xE1, 0x38, 0x81, 0x36, 0x91, 0xA2, 0x68, 0x9D, + 0x82, 0xE6, 0x1D, 0xFA, 0x29, 0x60, 0x08, 0xA9, + 0xC1, 0xCA, 0x05, 0x6E, 0xB9, 0x01, 0x25, 0x98, + 0xB4, 0x3C, 0xC4, 0x45, 0x49, 0x20, 0x62, 0xA9 + }, + { + 0xB0, 0x88, 0x98, 0x6A, 0x6D, 0x0E, 0x56, 0x0A, + 0xFC, 0xBD, 0xD6, 0x6A, 0xB9, 0xBC, 0x4E, 0xCA, + 0xFA, 0xB7, 0x10, 0x4C, 0x78, 0x94, 0xF2, 0x16, + 0x56, 0x64, 0x4E, 0x2A, 0xF2, 0x04, 0xC6, 0x4F + }, + { + 0xA3, 0x74, 0x20, 0x7C, 0x2B, 0x46, 0xC9, 0xE3, + 0x59, 0x27, 0xF7, 0x16, 0xAC, 0xD9, 0x15, 0x38, + 0x38, 0x19, 0x23, 0xF4, 0xA9, 0xA5, 0xDC, 0x74, + 0x39, 0x48, 0x6C, 0x46, 0xCE, 0xF3, 0x6F, 0xE4 + }, + { + 0x53, 0x7C, 0xBF, 0x99, 0x87, 0x8D, 0xC3, 0xCA, + 0xDF, 0x5B, 0x7B, 0x41, 0xC2, 0x17, 0xC7, 0x9C, + 0x98, 0x05, 0xD4, 0x76, 0x9C, 0x03, 0xD6, 0xCD, + 0x29, 0x18, 0x34, 0x4A, 0x63, 0x3D, 0x9E, 0x90 + }, + { + 0xF8, 0xAE, 0x6B, 0x49, 0x59, 0x5B, 0xDB, 0x0B, + 0xD4, 0xC7, 0x60, 0x96, 0x1A, 0xBD, 0x3A, 0x48, + 0x6C, 0x7A, 0xF2, 0x76, 0xB3, 0x82, 0xEA, 0x5A, + 0x31, 0x4B, 0x91, 0xB9, 0x78, 0xBD, 0xB0, 0x7F + }, + { + 0x45, 0x24, 0x0D, 0xF1, 0x7A, 0xFA, 0xBF, 0x9F, + 0xD1, 0x49, 0x5D, 0x77, 0x44, 0xF0, 0x0E, 0x86, + 0x37, 0x21, 0x4A, 0x21, 0x0A, 0x37, 0xC2, 0x43, + 0x75, 0x67, 0x40, 0x6F, 0xA0, 0xA1, 0xB1, 0x67 + }, + { + 0xC0, 0xAE, 0x49, 0xDF, 0x6F, 0xBD, 0x50, 0x9D, + 0x17, 0x2D, 0x20, 0x65, 0xFA, 0xD9, 0x61, 0xEA, + 0xB8, 0x54, 0xDA, 0x43, 0x14, 0xD3, 0xBB, 0x8B, + 0x0A, 0xDA, 0xA7, 0xA9, 0xCC, 0x78, 0xEF, 0xE8 + }, + { + 0x6A, 0xF6, 0x67, 0x08, 0x68, 0x7A, 0xC3, 0xC4, + 0x55, 0xF6, 0xEA, 0x1F, 0xEA, 0x90, 0x65, 0x43, + 0x17, 0x5E, 0x24, 0x4F, 0x3C, 0xC2, 0xDE, 0x2E, + 0x89, 0x3E, 0x36, 0x9B, 0xAD, 0x4B, 0x85, 0x3A + }, + { + 0xE4, 0x0B, 0x76, 0xC3, 0x0B, 0x0E, 0x7C, 0xAD, + 0x9D, 0x8A, 0x62, 0xD0, 0xE5, 0xE9, 0x9B, 0xF5, + 0xE2, 0x0B, 0x76, 0xEF, 0xD4, 0x40, 0x0E, 0xC4, + 0xBD, 0x3D, 0xC2, 0x0F, 0x64, 0xEE, 0x8B, 0x09 + }, + { + 0x6D, 0x33, 0x3C, 0x03, 0x26, 0x52, 0x67, 0x8A, + 0xBE, 0xA6, 0x59, 0x83, 0x9D, 0x22, 0x88, 0xB0, + 0xA1, 0x3D, 0x24, 0x9F, 0xFA, 0xA4, 0x48, 0xF1, + 0x4D, 0x21, 0x87, 0x92, 0x4D, 0x9B, 0x04, 0x7E + }, + { + 0x31, 0xCB, 0x0A, 0xA1, 0xC4, 0x32, 0x7E, 0x4D, + 0xD3, 0x2A, 0x0C, 0x49, 0x9D, 0x5D, 0x6A, 0x04, + 0x26, 0x00, 0xCC, 0x03, 0x49, 0x6E, 0xDA, 0xAD, + 0x0F, 0x34, 0xBF, 0x48, 0x3C, 0x9A, 0x3C, 0xE5 + }, + { + 0x24, 0x2E, 0x0D, 0x80, 0x0E, 0xE5, 0xE0, 0x1E, + 0xF7, 0x8E, 0xDC, 0x98, 0xAE, 0xBC, 0x0F, 0xE4, + 0x42, 0x45, 0x0D, 0x5A, 0xBF, 0x21, 0x41, 0xDE, + 0x5D, 0xF5, 0xD3, 0x20, 0x92, 0xBB, 0x25, 0xD1 + }, + { + 0x05, 0x55, 0x51, 0x4C, 0xB9, 0xC3, 0xE3, 0x3B, + 0x42, 0xA9, 0x98, 0xBE, 0xD4, 0xE0, 0x93, 0x6E, + 0xB6, 0x90, 0x09, 0x20, 0xE9, 0x71, 0x5E, 0x42, + 0x02, 0x79, 0xFC, 0x1E, 0x0C, 0x82, 0x87, 0xD5 + }, + { + 0x6F, 0xF2, 0x87, 0x86, 0x4D, 0x27, 0xC6, 0xDA, + 0x88, 0xC2, 0xC4, 0xCA, 0x23, 0xA6, 0x07, 0xF7, + 0xA0, 0xA6, 0x51, 0xAA, 0xDD, 0x52, 0xFE, 0x94, + 0xCC, 0x0A, 0xA7, 0x13, 0x3D, 0x0A, 0x81, 0x85 + }, + { + 0x23, 0x04, 0x36, 0x86, 0x80, 0xBD, 0xE9, 0x42, + 0x42, 0x18, 0x6D, 0x33, 0x0A, 0xD2, 0x73, 0x66, + 0x85, 0x65, 0xFC, 0xB7, 0x38, 0x8B, 0x60, 0x77, + 0x1D, 0xE6, 0x4F, 0xA0, 0x7E, 0xCD, 0x36, 0xA0 + }, + { + 0x7D, 0x07, 0x7D, 0x3E, 0x12, 0xF3, 0xAD, 0x2B, + 0xC6, 0x09, 0x07, 0x60, 0xEE, 0x4D, 0xB4, 0x4B, + 0xE2, 0x56, 0xA5, 0x0D, 0xF8, 0x36, 0x4E, 0xC7, + 0xED, 0x99, 0x08, 0xAA, 0x1C, 0xAC, 0x37, 0x9F + }, + { + 0x3E, 0x69, 0xE9, 0xAC, 0xB2, 0x1F, 0x0B, 0x20, + 0xFC, 0x96, 0xFF, 0xBF, 0xA4, 0xE9, 0x92, 0xB0, + 0x90, 0x30, 0xFA, 0x11, 0x56, 0x29, 0x62, 0x68, + 0xE5, 0x7E, 0x06, 0xE3, 0xFF, 0xF6, 0x43, 0x20 + }, + { + 0x79, 0x1A, 0x85, 0x20, 0x56, 0x31, 0x26, 0x35, + 0xAB, 0x4F, 0x2E, 0x5F, 0x30, 0x2E, 0xFC, 0xBC, + 0x08, 0x58, 0x51, 0x04, 0x33, 0x6F, 0x09, 0x96, + 0xD4, 0xC3, 0x87, 0xCE, 0x0D, 0xB1, 0x24, 0x18 + }, + { + 0x66, 0xFC, 0xB5, 0x58, 0x09, 0x43, 0x45, 0x67, + 0xCE, 0x41, 0xA8, 0xE8, 0xF5, 0xEF, 0x8D, 0xA7, + 0x85, 0x4A, 0x8B, 0x90, 0x0E, 0x88, 0x5B, 0xF3, + 0x24, 0x7C, 0x90, 0xB8, 0x85, 0x30, 0x05, 0x63 + }, + { + 0xD3, 0xE8, 0x85, 0x06, 0x40, 0x5B, 0x57, 0xFE, + 0x7F, 0x97, 0x37, 0x3B, 0x70, 0xB2, 0x0C, 0x5D, + 0x3D, 0xB5, 0xCD, 0xD7, 0xA9, 0x66, 0x26, 0x44, + 0x94, 0xEE, 0x8C, 0xA1, 0x4E, 0xE4, 0x05, 0xD3 + }, + { + 0xD0, 0x6B, 0x39, 0x6A, 0x2A, 0x42, 0xD7, 0x51, + 0x19, 0x05, 0x5F, 0xA0, 0xCE, 0x70, 0x7C, 0x32, + 0x77, 0x5B, 0xC9, 0x47, 0x12, 0x20, 0xF0, 0x4F, + 0x56, 0x00, 0xDE, 0x2E, 0x52, 0x8B, 0x49, 0xFA + }, + { + 0x1F, 0x22, 0x4E, 0x4E, 0x5A, 0x76, 0x9E, 0x10, + 0xB7, 0x3A, 0xCB, 0x1F, 0x91, 0xC5, 0xA6, 0xC9, + 0x3D, 0x4D, 0x2C, 0x2F, 0x03, 0x93, 0x96, 0xF8, + 0x68, 0xEF, 0xE1, 0xAD, 0xD7, 0x0A, 0x3B, 0x9B + }, + { + 0x02, 0x42, 0xB4, 0x6E, 0x7C, 0x3D, 0x26, 0x64, + 0x39, 0xAD, 0x8B, 0xF5, 0x04, 0xD0, 0x94, 0x6F, + 0xD9, 0x2E, 0x19, 0x85, 0xB9, 0xED, 0xA2, 0x09, + 0xD4, 0xAF, 0x74, 0x36, 0x1D, 0xAD, 0x2B, 0xEA + }, + { + 0x4F, 0xF8, 0xBE, 0x24, 0x93, 0xD4, 0xEC, 0x07, + 0xCC, 0x50, 0x08, 0x7D, 0x37, 0xAE, 0xB4, 0xFE, + 0x88, 0x90, 0x33, 0x9D, 0xB9, 0x96, 0x8B, 0xA1, + 0xA3, 0x64, 0x89, 0xB8, 0xBF, 0xCF, 0xA7, 0x81 + }, + { + 0xC1, 0xC9, 0x10, 0x13, 0xEE, 0x12, 0x3E, 0xAA, + 0xFF, 0xF0, 0xDE, 0xF9, 0x34, 0x46, 0xAF, 0xEB, + 0x38, 0x98, 0xF8, 0xE4, 0x05, 0x6D, 0x04, 0xA3, + 0xFE, 0x4F, 0xB6, 0x67, 0x84, 0xE8, 0x61, 0x10 + }, + { + 0x13, 0x36, 0x1A, 0x47, 0xA1, 0x7C, 0x09, 0x51, + 0xDC, 0x95, 0xBD, 0x77, 0xD0, 0x5B, 0xD0, 0x00, + 0x60, 0x78, 0x06, 0xF7, 0x86, 0x38, 0xE9, 0xCF, + 0xC4, 0xB0, 0xEC, 0x11, 0xED, 0x30, 0xC8, 0xA8 + }, + { + 0x3E, 0xB3, 0xE4, 0x1C, 0x30, 0xFF, 0x56, 0x45, + 0x3B, 0x15, 0x1B, 0x3A, 0x2A, 0x0F, 0x23, 0xB0, + 0x09, 0x08, 0x2F, 0x72, 0x20, 0xA3, 0x30, 0x59, + 0xCA, 0xD9, 0x4B, 0x33, 0xB2, 0x4C, 0x0A, 0xB7 + }, + { + 0x1B, 0xC6, 0xCF, 0x18, 0xAF, 0xF1, 0xAF, 0x0E, + 0xDE, 0x00, 0xBD, 0xA7, 0x01, 0xD0, 0xB5, 0x53, + 0xB3, 0x21, 0x8C, 0x3B, 0x75, 0x44, 0x60, 0x74, + 0x72, 0x11, 0xA5, 0x46, 0xA2, 0x62, 0x19, 0x11 + }, + { + 0xD1, 0x81, 0xB7, 0xB4, 0x6E, 0x44, 0x41, 0x65, + 0x5E, 0x35, 0x3B, 0xC9, 0x2C, 0xF5, 0x94, 0x6A, + 0xC3, 0x13, 0x9B, 0xAC, 0x91, 0x4C, 0xF1, 0x4F, + 0x2C, 0xFA, 0x4D, 0xD4, 0xBD, 0xD1, 0x22, 0x74 + }, + { + 0x71, 0x47, 0x1F, 0x59, 0x7E, 0xA1, 0x39, 0xB7, + 0x45, 0x45, 0x7F, 0xA8, 0x45, 0x3A, 0x29, 0x54, + 0x5F, 0x19, 0x34, 0x5B, 0xCB, 0xFC, 0x76, 0xB9, + 0xBD, 0xC3, 0x6B, 0x5D, 0xE1, 0x07, 0xDC, 0x03 + }, + { + 0x1B, 0x9C, 0x98, 0x94, 0xE3, 0x64, 0xE7, 0x5D, + 0x8E, 0x80, 0x44, 0x60, 0x82, 0x58, 0xDD, 0x1C, + 0x79, 0x8D, 0x68, 0xA9, 0xCE, 0x2F, 0x5F, 0x0B, + 0xC2, 0xC4, 0x12, 0x90, 0x04, 0x6A, 0x92, 0x8A + }, + { + 0xA9, 0x77, 0xBC, 0xA3, 0x47, 0x94, 0x2E, 0x84, + 0x75, 0x7C, 0xB7, 0xF2, 0x26, 0xE3, 0xAA, 0x1D, + 0xCC, 0x07, 0x06, 0x85, 0x21, 0x12, 0x7F, 0x89, + 0xEB, 0xFD, 0xAD, 0xB7, 0x47, 0x62, 0x8B, 0x48 + }, + { + 0xFD, 0x11, 0xCC, 0x02, 0x87, 0x12, 0x8A, 0xEE, + 0x70, 0x38, 0x29, 0xF0, 0x8A, 0xB8, 0x13, 0x56, + 0x47, 0x57, 0x31, 0x08, 0xB3, 0x20, 0xDB, 0x18, + 0x7C, 0xAD, 0x37, 0x30, 0x83, 0x60, 0x4C, 0x57 + }, + { + 0x2C, 0x6E, 0xD6, 0x4E, 0x96, 0x1F, 0x0C, 0xE8, + 0x9D, 0xCB, 0xAA, 0x61, 0xAB, 0x12, 0xF2, 0x6A, + 0x74, 0xA2, 0x3A, 0x94, 0x3E, 0xD3, 0xB0, 0x2D, + 0x53, 0x48, 0x5B, 0x93, 0xB9, 0x1F, 0x49, 0x17 + }, + { + 0x67, 0x9C, 0x37, 0xD9, 0x78, 0x48, 0x02, 0x11, + 0x55, 0x05, 0x5B, 0x4F, 0x54, 0x22, 0xD0, 0x0F, + 0x9F, 0x8F, 0x9E, 0x50, 0x8F, 0xBC, 0x1A, 0x45, + 0xD2, 0xF6, 0xC7, 0xC8, 0xB3, 0xCB, 0xBB, 0xCE + }, + { + 0x3F, 0x83, 0x09, 0xC9, 0x63, 0x09, 0xB8, 0x98, + 0xCA, 0x01, 0xD3, 0xA6, 0x8C, 0x82, 0x41, 0xBC, + 0x22, 0x98, 0x9C, 0xA5, 0x67, 0x1C, 0x87, 0x33, + 0xD5, 0xC5, 0xEC, 0x1E, 0x69, 0xD7, 0x7E, 0x3F + }, + { + 0x1A, 0x2D, 0x0E, 0x0E, 0x52, 0xD1, 0x28, 0xEE, + 0xAD, 0x0E, 0x0C, 0xE3, 0xED, 0x8A, 0xED, 0x36, + 0x57, 0x7A, 0x99, 0x52, 0x17, 0xA0, 0x4D, 0x1F, + 0xBB, 0x29, 0x93, 0x43, 0x28, 0xA5, 0x62, 0xBF + }, + { + 0xC9, 0x6D, 0x91, 0x03, 0xED, 0x8C, 0x06, 0xB8, + 0xAE, 0x7C, 0x24, 0x1E, 0x43, 0x21, 0xFE, 0xD9, + 0x77, 0x2B, 0x50, 0xBB, 0x12, 0x22, 0xA7, 0x0C, + 0x66, 0x5B, 0xCE, 0x8E, 0xEB, 0x56, 0xF1, 0xE6 + }, + { + 0xC9, 0x8F, 0x45, 0x91, 0x19, 0x40, 0x84, 0xBB, + 0xCA, 0xB2, 0xF6, 0x56, 0xCD, 0x49, 0xBF, 0x55, + 0xC4, 0x99, 0x3D, 0x5F, 0xCE, 0xC7, 0xE7, 0x48, + 0xC7, 0xEF, 0xC9, 0xA9, 0xC3, 0xFF, 0x9B, 0x85 + }, + { + 0xA7, 0xB9, 0x2A, 0x59, 0x5E, 0x32, 0x13, 0x9A, + 0x85, 0xC7, 0x44, 0xED, 0x4C, 0x3E, 0x7B, 0xCD, + 0x3D, 0xA9, 0x9E, 0x71, 0x0B, 0x60, 0xD9, 0x78, + 0x28, 0xD4, 0x41, 0xF3, 0xE7, 0x93, 0x7B, 0x32 + }, + { + 0x26, 0x96, 0xEC, 0x0E, 0x4E, 0x34, 0xD3, 0xD0, + 0x61, 0x4E, 0x5F, 0xF2, 0x94, 0x3C, 0x63, 0x81, + 0x92, 0xD3, 0xC6, 0x48, 0x4B, 0x36, 0x5B, 0xEA, + 0x50, 0xB5, 0x37, 0xBE, 0x39, 0x7D, 0x66, 0x80 + }, + { + 0x3F, 0xD5, 0xF0, 0x25, 0xF7, 0xC0, 0xAD, 0xC0, + 0xFD, 0xC7, 0x84, 0x96, 0x09, 0x16, 0x13, 0x33, + 0x06, 0x16, 0x82, 0x8F, 0x12, 0xBE, 0x96, 0x5E, + 0x34, 0xDD, 0xB3, 0x9C, 0x1D, 0x1C, 0xEF, 0x00 + }, + { + 0x40, 0x7C, 0x52, 0x30, 0x35, 0xC5, 0xFA, 0xC5, + 0x17, 0xDA, 0xD7, 0x70, 0x1C, 0x9A, 0x8E, 0x05, + 0x4C, 0x94, 0x5D, 0x51, 0xDF, 0x98, 0x28, 0x53, + 0x31, 0x4B, 0x5A, 0x82, 0xC8, 0x25, 0xDA, 0x8F + }, + { + 0x28, 0xF8, 0x75, 0x56, 0x43, 0x13, 0x58, 0xD1, + 0x37, 0xE2, 0xA3, 0x92, 0x3D, 0x1E, 0x09, 0xD2, + 0x1E, 0xCA, 0x7F, 0x16, 0x77, 0x48, 0xD3, 0x51, + 0x82, 0x57, 0x4C, 0x5F, 0xAC, 0x82, 0xDC, 0xF6 + }, + { + 0x9D, 0xF2, 0x35, 0xE5, 0x76, 0xDE, 0x9B, 0x6F, + 0xBF, 0xF7, 0xE2, 0x39, 0x4F, 0xC3, 0x9D, 0x10, + 0xC4, 0x45, 0x2E, 0x47, 0xEC, 0x31, 0x24, 0x80, + 0xDB, 0x76, 0x42, 0x92, 0x33, 0x14, 0xB9, 0x4D + }, + { + 0x13, 0x33, 0x8E, 0xC4, 0x31, 0xD7, 0x3A, 0x8D, + 0xBE, 0xE7, 0x6B, 0x80, 0xDD, 0x49, 0xB1, 0x09, + 0x04, 0x5C, 0x5F, 0xD1, 0x64, 0x65, 0xCE, 0x33, + 0x18, 0xB5, 0x2D, 0x7A, 0xB9, 0x4A, 0x17, 0x8D + }, + { + 0xC2, 0xDE, 0x12, 0x43, 0xD1, 0xEF, 0x73, 0x67, + 0x02, 0x92, 0x90, 0xD5, 0xCE, 0xC7, 0x3E, 0x2D, + 0x5C, 0x8A, 0x0B, 0x25, 0x8F, 0xDF, 0x2B, 0x3D, + 0x0B, 0x72, 0xE6, 0x9D, 0x8B, 0x85, 0x4A, 0x21 + }, + { + 0x60, 0xAE, 0xD5, 0x4E, 0x7C, 0x4A, 0x03, 0x0B, + 0x76, 0xEE, 0xBD, 0x58, 0x00, 0xDC, 0xE4, 0xF6, + 0x8F, 0x2D, 0x71, 0x94, 0xDA, 0x06, 0xD0, 0x40, + 0x17, 0x19, 0x8C, 0xDD, 0xAD, 0x26, 0x50, 0xE7 + }, + { + 0xB0, 0x14, 0x6B, 0x8E, 0xD6, 0xBE, 0xBD, 0x1C, + 0xF1, 0x71, 0xC2, 0x06, 0xE4, 0x55, 0xB5, 0x59, + 0x61, 0xF1, 0x40, 0x2E, 0xC2, 0xD6, 0xC3, 0xAA, + 0x0E, 0x30, 0x47, 0x9E, 0x1B, 0x94, 0xD3, 0xBE + }, + { + 0x4C, 0xA3, 0x1F, 0x03, 0x77, 0x8E, 0xF0, 0x05, + 0xA8, 0x1D, 0xB0, 0xE0, 0x6A, 0x1C, 0xFE, 0x37, + 0xA6, 0xD1, 0x1A, 0xC1, 0xEA, 0x5E, 0x68, 0x61, + 0x93, 0xAE, 0x02, 0x1B, 0x24, 0x9D, 0x0D, 0x07 + }, + { + 0xD7, 0x89, 0x09, 0x16, 0x26, 0xFA, 0xD6, 0xF3, + 0xC1, 0x85, 0x24, 0x8F, 0x32, 0x41, 0x90, 0x51, + 0x34, 0x07, 0x34, 0x28, 0xA4, 0x91, 0x03, 0xBB, + 0xC4, 0x9D, 0xB5, 0x30, 0x04, 0x87, 0xF7, 0x0E + }, + { + 0xD3, 0x1D, 0xB2, 0x95, 0x90, 0x24, 0x5E, 0xEC, + 0x42, 0x0E, 0x91, 0x9B, 0x98, 0x5D, 0xBD, 0x74, + 0x0F, 0x58, 0x7C, 0x84, 0x16, 0xFE, 0xA9, 0x6A, + 0x33, 0x15, 0xFD, 0x58, 0x87, 0x30, 0xED, 0xEA + }, + { + 0x76, 0x65, 0x77, 0xED, 0x67, 0xB6, 0xFD, 0x67, + 0x41, 0x13, 0x1E, 0xCE, 0x25, 0xC0, 0x6F, 0xBB, + 0x91, 0x75, 0x83, 0xAF, 0x96, 0xFF, 0x92, 0x6F, + 0x7F, 0xD8, 0xF1, 0xAA, 0xD0, 0x9D, 0x19, 0x43 + }, + { + 0x27, 0x0E, 0xDA, 0xB6, 0x2D, 0xB1, 0x18, 0x99, + 0xAB, 0xB8, 0x27, 0x6D, 0xA6, 0x70, 0x86, 0x6C, + 0xE6, 0xB9, 0xB0, 0x4B, 0x97, 0x1E, 0x59, 0x7A, + 0x45, 0x29, 0xE6, 0x37, 0x65, 0x15, 0xF7, 0x28 + }, + { + 0xE4, 0x23, 0x8F, 0x2D, 0x35, 0x39, 0x40, 0xF7, + 0x7A, 0x2B, 0xD2, 0xFC, 0x44, 0x67, 0xA5, 0xAA, + 0x2B, 0x02, 0xBC, 0x2D, 0xCA, 0xFD, 0xC7, 0xB6, + 0x2B, 0xD1, 0x60, 0x4C, 0x7F, 0x62, 0x3B, 0x35 + }, + { + 0x94, 0x91, 0xFF, 0xA5, 0x7A, 0x83, 0xDA, 0xE8, + 0x98, 0x8D, 0x53, 0x05, 0x48, 0xA3, 0xDA, 0x62, + 0xCA, 0xD3, 0x82, 0xB5, 0x2F, 0x04, 0x29, 0x33, + 0x7A, 0xE6, 0xD2, 0xA7, 0x5C, 0xD6, 0x03, 0x9F + }, + { + 0x49, 0x34, 0x9A, 0xE1, 0x07, 0x82, 0xD6, 0x81, + 0x32, 0x94, 0x77, 0xA5, 0x53, 0x2E, 0x8C, 0x4E, + 0xA8, 0xDE, 0x18, 0x2A, 0x7D, 0x38, 0x2E, 0x13, + 0x28, 0xC3, 0x0C, 0x6D, 0xD6, 0xF8, 0xDA, 0x40 + }, + { + 0xFC, 0x86, 0xAD, 0x1C, 0x8E, 0xB8, 0xE4, 0xA1, + 0x0E, 0xAD, 0x27, 0x3B, 0xA6, 0x47, 0xC2, 0x10, + 0x45, 0x9C, 0xE7, 0x73, 0xA2, 0xF3, 0xFF, 0x0B, + 0x42, 0x5B, 0x06, 0x14, 0xBD, 0x09, 0x52, 0x85 + }, + { + 0x70, 0x48, 0x6A, 0x86, 0x21, 0xFD, 0x5E, 0xD4, + 0xF2, 0x4D, 0x97, 0x1D, 0xCA, 0x45, 0x77, 0xCB, + 0xFF, 0x61, 0xA1, 0x62, 0xEF, 0x8C, 0xD6, 0x8F, + 0x63, 0x8E, 0x81, 0xDA, 0xB1, 0x56, 0x7C, 0x58 + }, + { + 0x2D, 0xC5, 0x8E, 0x53, 0xCC, 0x31, 0xFB, 0xF1, + 0x0F, 0x69, 0xA0, 0x77, 0xE4, 0x89, 0x28, 0x21, + 0x12, 0xF7, 0x1E, 0x1E, 0xD4, 0x5F, 0xB3, 0xD9, + 0xFB, 0xEE, 0x3F, 0xD8, 0x7E, 0x10, 0x87, 0xB1 + }, + { + 0x5A, 0x61, 0xC9, 0x36, 0xD3, 0x22, 0x98, 0x5C, + 0x2F, 0xAE, 0x8C, 0x05, 0xFF, 0x92, 0x19, 0xC8, + 0x2F, 0xAA, 0x42, 0x46, 0xB2, 0xA0, 0xA6, 0x21, + 0xD6, 0xC8, 0x56, 0x68, 0x3E, 0xCA, 0xEE, 0xB0 + }, + { + 0x51, 0x02, 0xB7, 0x3B, 0x63, 0x33, 0x8A, 0xC8, + 0x51, 0x11, 0xF6, 0x0D, 0x1E, 0xF6, 0x33, 0xE5, + 0x09, 0x4B, 0x08, 0x10, 0xA7, 0x0A, 0x21, 0xDB, + 0x63, 0x76, 0xE9, 0x0A, 0xDE, 0x5B, 0x50, 0x72 + }, + { + 0x19, 0x56, 0x91, 0x7F, 0x75, 0x49, 0xFB, 0xE5, + 0x20, 0x62, 0x61, 0x6D, 0x47, 0x0A, 0x30, 0x1B, + 0x9D, 0x62, 0x4D, 0x75, 0x1E, 0x63, 0x42, 0x3D, + 0x91, 0x0A, 0x46, 0x2C, 0x5C, 0x73, 0x6C, 0x79 + }, + { + 0x3E, 0x0B, 0xAC, 0x6F, 0xE0, 0x63, 0xD8, 0xE2, + 0x41, 0x77, 0xB6, 0x51, 0x4F, 0xD2, 0xC0, 0xAC, + 0xF4, 0xA5, 0x1E, 0x24, 0xC6, 0x8B, 0x0E, 0xFD, + 0x4D, 0xCB, 0x68, 0xBB, 0xB9, 0x87, 0xAA, 0x32 + }, + { + 0x1B, 0x6D, 0x18, 0x43, 0xE6, 0x12, 0xC0, 0x85, + 0x88, 0x7B, 0xCE, 0x7A, 0x14, 0x90, 0xA9, 0xB0, + 0x0A, 0x5A, 0x96, 0x47, 0x60, 0xEC, 0xA7, 0xD5, + 0x6C, 0xA9, 0x82, 0x86, 0x0A, 0xF1, 0x0A, 0x08 + }, + { + 0x0F, 0xB5, 0x34, 0x08, 0x32, 0x73, 0xD3, 0x70, + 0x4E, 0x00, 0x69, 0x0B, 0x54, 0x7F, 0x04, 0xCA, + 0x7F, 0x02, 0xCF, 0xF7, 0x25, 0xC1, 0xC7, 0x51, + 0xAA, 0x96, 0xCB, 0x0A, 0x96, 0xDE, 0x44, 0x5D + }, + { + 0xCC, 0x29, 0x59, 0x06, 0xD2, 0x27, 0xB5, 0x11, + 0x2D, 0x3F, 0x70, 0x9D, 0x2E, 0x27, 0x60, 0x07, + 0x6C, 0xEE, 0x1F, 0xD9, 0xFD, 0x66, 0x1F, 0x9E, + 0xD5, 0xCF, 0xF8, 0xDB, 0x77, 0x0D, 0x9B, 0x9A + }, + { + 0x2F, 0x54, 0x9E, 0x16, 0x39, 0x5D, 0xA7, 0x57, + 0x45, 0x92, 0xF1, 0x5B, 0xB1, 0x58, 0xE7, 0xAF, + 0x37, 0xD5, 0xCA, 0x9E, 0xA0, 0xE5, 0xA4, 0xFE, + 0xE5, 0x2A, 0x66, 0xAC, 0x31, 0xCF, 0x8B, 0xB1 + }, + { + 0xE4, 0xBD, 0x48, 0x09, 0x41, 0xC3, 0x12, 0x23, + 0x97, 0xCF, 0x82, 0x22, 0x2F, 0xE0, 0xD0, 0x05, + 0x4B, 0x8E, 0x20, 0xB2, 0x33, 0xDF, 0xD8, 0x4E, + 0x58, 0x88, 0x54, 0x53, 0x13, 0x22, 0xBC, 0xE3 + }, + { + 0x31, 0xAA, 0xEE, 0x0B, 0xE2, 0x1D, 0x1B, 0x30, + 0x1D, 0xE0, 0x7E, 0x97, 0xA8, 0x92, 0x90, 0x63, + 0x90, 0xDB, 0xE2, 0x14, 0xAF, 0xFD, 0x64, 0x66, + 0x0F, 0x30, 0xF0, 0x55, 0x2C, 0x68, 0x24, 0x9B + }, + { + 0x5B, 0xB2, 0xE2, 0x9D, 0x85, 0xB5, 0x88, 0xDC, + 0x9B, 0xD1, 0xF3, 0xD2, 0xDD, 0x9F, 0xE9, 0x17, + 0x98, 0xA4, 0x3D, 0xEF, 0x7D, 0x1C, 0xE8, 0x33, + 0x97, 0x92, 0x5A, 0xC7, 0xDD, 0x09, 0x19, 0xA7 + }, + { + 0x2B, 0x87, 0x56, 0x5F, 0x80, 0x61, 0x16, 0xC6, + 0x15, 0xE7, 0x7E, 0xB7, 0xC1, 0xE0, 0xCE, 0xE3, + 0x8C, 0x50, 0x61, 0xC7, 0xE0, 0xD0, 0x1F, 0x83, + 0x80, 0xD6, 0xF0, 0x0A, 0xF2, 0x44, 0xBC, 0xAE + }, + { + 0x13, 0x58, 0x4F, 0x83, 0xF9, 0x14, 0xD7, 0x4D, + 0x2A, 0x88, 0xF8, 0xCD, 0xB5, 0xCD, 0xB5, 0xE2, + 0x47, 0x3B, 0xED, 0x8F, 0xC2, 0xDB, 0xB5, 0xDB, + 0x30, 0x1F, 0x12, 0x75, 0xF5, 0xE6, 0x1C, 0x79 + }, + { + 0x4A, 0x46, 0x6E, 0x3D, 0xF4, 0xFE, 0x7B, 0x72, + 0x81, 0x85, 0x46, 0x80, 0x85, 0xB1, 0x79, 0xD3, + 0xB8, 0x38, 0xEC, 0x37, 0x90, 0x83, 0x5D, 0xED, + 0xE7, 0xC7, 0xFF, 0x19, 0x96, 0x5E, 0x7C, 0x4D + }, + { + 0x1B, 0xE4, 0xEF, 0x5E, 0xBE, 0xDC, 0x29, 0x4D, + 0x70, 0x32, 0x6E, 0x89, 0x6E, 0x5F, 0x06, 0x11, + 0xE8, 0x1B, 0xFD, 0x2F, 0x4F, 0x54, 0x40, 0xFA, + 0x3F, 0xAC, 0x1F, 0xC9, 0x46, 0xE3, 0xFF, 0xED + }, + { + 0xB2, 0xC9, 0x01, 0xC9, 0x91, 0xA2, 0xF1, 0x5D, + 0xF4, 0xC5, 0x4B, 0xB0, 0x08, 0x19, 0xC9, 0x3A, + 0x4C, 0xA0, 0xB7, 0xC6, 0x6C, 0x49, 0xCE, 0x6E, + 0xB8, 0x56, 0x93, 0xC9, 0xF7, 0xD7, 0xED, 0x21 + }, + { + 0x1C, 0x5F, 0xF6, 0xF8, 0xD0, 0x64, 0x2A, 0xB9, + 0x39, 0x3D, 0x45, 0x2A, 0x8B, 0xD6, 0x20, 0x12, + 0xB3, 0x4F, 0xBF, 0x97, 0x82, 0x38, 0x0F, 0xD8, + 0x4C, 0x95, 0x7A, 0xB4, 0xDA, 0x3C, 0x93, 0x22 + }, + { + 0x84, 0x17, 0x69, 0x63, 0xFE, 0x55, 0x3B, 0x40, + 0x7A, 0x1A, 0x53, 0xA6, 0xBF, 0xC9, 0x8B, 0xAB, + 0x80, 0xB3, 0x65, 0x9E, 0x3D, 0xC9, 0xDE, 0x5D, + 0xD4, 0x44, 0xEB, 0xFF, 0xDE, 0x85, 0x99, 0x2D + }, + { + 0x78, 0x9C, 0x4A, 0x8C, 0xA2, 0xB2, 0xD6, 0xAF, + 0x70, 0x67, 0x0B, 0x28, 0xF5, 0x91, 0xB1, 0x3E, + 0x7C, 0x72, 0xEC, 0x45, 0x81, 0xA2, 0xD4, 0x3D, + 0xF9, 0x31, 0x80, 0x77, 0xB6, 0x73, 0x6E, 0x6A + }, + { + 0x0F, 0x91, 0x16, 0xAF, 0x61, 0xD2, 0x41, 0xE0, + 0x16, 0x6F, 0x6D, 0x25, 0x74, 0x7B, 0xD7, 0x93, + 0xA4, 0x59, 0x53, 0x54, 0xE2, 0xAA, 0xA4, 0x0A, + 0xCF, 0xAA, 0x46, 0xB7, 0xE7, 0x24, 0x4E, 0xCF + }, + { + 0xC6, 0xEB, 0xB3, 0xDB, 0x2A, 0x6F, 0x9C, 0xA4, + 0x3E, 0x1F, 0xF8, 0x6B, 0x5B, 0xD3, 0xD8, 0x8C, + 0x07, 0xDC, 0x0E, 0x50, 0xDB, 0x10, 0xAA, 0x19, + 0x87, 0xEE, 0xFA, 0xB0, 0xFE, 0xF0, 0x3C, 0xC4 + }, + { + 0xE9, 0x9B, 0x8D, 0xCF, 0x27, 0xA4, 0xE0, 0xA6, + 0xAE, 0xCE, 0x7E, 0x72, 0x8D, 0xA7, 0x70, 0xCF, + 0x69, 0x7F, 0x4B, 0x61, 0x48, 0x20, 0x18, 0xB4, + 0x10, 0xD2, 0xDA, 0x50, 0x3E, 0x26, 0x30, 0x4B + }, + { + 0x9C, 0x15, 0xEE, 0x0E, 0xB7, 0xFA, 0x42, 0x2C, + 0x4B, 0x2E, 0xB1, 0x72, 0x91, 0xC7, 0xE1, 0xF5, + 0xC3, 0x27, 0x9C, 0x91, 0x63, 0x0D, 0xC4, 0xBB, + 0xB6, 0x21, 0x71, 0xE4, 0xB0, 0x0D, 0xA0, 0xDB + }, + { + 0x19, 0xC0, 0xB1, 0xB1, 0xCF, 0xD5, 0x42, 0xA0, + 0x48, 0xA2, 0x4B, 0x0A, 0xE5, 0x43, 0x71, 0x32, + 0x8E, 0x46, 0xCE, 0xE1, 0x03, 0xF8, 0xA1, 0x85, + 0x6A, 0x0A, 0xE0, 0xAF, 0x8F, 0xCC, 0xCE, 0x79 + }, + { + 0xC9, 0x60, 0x4E, 0xAA, 0xB5, 0xB7, 0xD2, 0xD3, + 0x6B, 0x54, 0xBE, 0x52, 0x30, 0x9C, 0x11, 0x9E, + 0xF7, 0xDD, 0xCB, 0xFE, 0x3E, 0xA0, 0x8E, 0xBB, + 0x5A, 0x08, 0x69, 0x1F, 0xF7, 0xD1, 0x61, 0x19 + }, + { + 0x85, 0x6B, 0x4E, 0x14, 0xC8, 0xC8, 0x1E, 0x4B, + 0xFE, 0xC5, 0x78, 0x0D, 0xD2, 0x5C, 0xD1, 0x1B, + 0x00, 0x51, 0x35, 0x0B, 0x87, 0xBC, 0xB2, 0xCA, + 0x70, 0x3F, 0x83, 0x1A, 0x17, 0x12, 0x11, 0x76 + }, + { + 0x41, 0xF6, 0x9C, 0xFB, 0xA7, 0xCA, 0x7E, 0x0D, + 0x13, 0x59, 0x61, 0xDA, 0xB9, 0x94, 0x9C, 0x16, + 0xC2, 0xD1, 0xDE, 0x08, 0x90, 0xD5, 0x05, 0x59, + 0x6D, 0x7A, 0x1F, 0x58, 0x9B, 0xC0, 0x4D, 0xF9 + }, + { + 0xCC, 0x21, 0x29, 0xD2, 0xC8, 0xCB, 0x29, 0x46, + 0x5A, 0x0C, 0x9E, 0x7D, 0x63, 0x29, 0xAE, 0xCC, + 0x4E, 0xAF, 0xE9, 0x6F, 0xE8, 0x49, 0x53, 0xAA, + 0x75, 0x3A, 0x62, 0x28, 0x70, 0x36, 0x24, 0x0F + }, + { + 0xDB, 0x9F, 0x3C, 0xBA, 0xBE, 0xE5, 0x60, 0x9B, + 0x45, 0x12, 0x9D, 0x09, 0x34, 0x03, 0x4C, 0x90, + 0xF3, 0xB4, 0x2A, 0xA2, 0x43, 0xCB, 0xC8, 0xC7, + 0x4F, 0x66, 0xC8, 0x35, 0xB6, 0x77, 0x64, 0x43 + }, + { + 0xB8, 0xC3, 0x98, 0x04, 0xC6, 0x93, 0xAD, 0xC6, + 0x95, 0x50, 0x43, 0xEF, 0xF4, 0xFF, 0xDE, 0x3B, + 0x74, 0x27, 0x71, 0xAA, 0x81, 0xA7, 0x31, 0xC7, + 0x48, 0xEF, 0xBC, 0x0F, 0x13, 0xFA, 0xF9, 0x87 + }, + { + 0x0F, 0x2E, 0x81, 0x8C, 0x54, 0x57, 0x60, 0xEC, + 0x83, 0x76, 0x5A, 0xB2, 0x1A, 0xDA, 0x2F, 0x1D, + 0x0B, 0x65, 0xB0, 0x71, 0x3D, 0x13, 0x38, 0x25, + 0x01, 0xD8, 0x92, 0x32, 0x41, 0xA8, 0xDA, 0xD5 + }, + { + 0xAF, 0x95, 0x3B, 0x52, 0xA9, 0x30, 0x98, 0xA3, + 0xB7, 0x11, 0x10, 0x0E, 0xFF, 0x06, 0xD6, 0xD7, + 0x85, 0x10, 0x6E, 0xB1, 0x06, 0x68, 0xCB, 0xCA, + 0xE7, 0x32, 0x68, 0x68, 0x83, 0x72, 0x9B, 0xA8 + }, + { + 0x49, 0xF9, 0xDA, 0xA7, 0x46, 0x55, 0x1E, 0xFE, + 0x4F, 0x70, 0x0E, 0x7C, 0x06, 0xD2, 0xC0, 0x45, + 0x74, 0x3A, 0x5D, 0x81, 0x70, 0xA9, 0xD8, 0x18, + 0xD7, 0xDA, 0xC6, 0x9C, 0x38, 0xE3, 0x89, 0x43 + }, + { + 0xF6, 0xB6, 0x45, 0x91, 0x3A, 0x09, 0x4A, 0xB2, + 0xC3, 0x71, 0x58, 0x8E, 0x3B, 0x64, 0xA0, 0x04, + 0x97, 0xE8, 0x8F, 0x73, 0xDE, 0xFB, 0x0E, 0x52, + 0x6C, 0x5B, 0xD1, 0x27, 0x6A, 0x8E, 0x7A, 0x5A + }, + { + 0x2B, 0xBE, 0x9F, 0x16, 0xE1, 0xE1, 0xD6, 0x4E, + 0xED, 0x1F, 0x93, 0x4C, 0x65, 0x00, 0x11, 0xDC, + 0xC3, 0xFF, 0x91, 0x00, 0x67, 0x39, 0x33, 0x29, + 0x45, 0x72, 0xA5, 0xB4, 0x45, 0x37, 0x8A, 0x5E + }, + { + 0x85, 0x44, 0x90, 0xEE, 0xD1, 0x25, 0x30, 0xDC, + 0x72, 0x6F, 0xBA, 0x74, 0xA2, 0x1E, 0xE5, 0x62, + 0xE1, 0x06, 0x6E, 0x66, 0x29, 0x34, 0x40, 0xC6, + 0xD5, 0x0F, 0x28, 0x21, 0x31, 0x7C, 0x15, 0xF8 + }, + { + 0x38, 0x0F, 0x1F, 0x00, 0x56, 0x73, 0x25, 0xD2, + 0x52, 0x45, 0x24, 0x82, 0x1C, 0x92, 0x52, 0x2A, + 0xA8, 0xD8, 0xDC, 0x88, 0x88, 0x49, 0xA1, 0x77, + 0xD0, 0x79, 0xA4, 0x8C, 0x75, 0x30, 0x3B, 0x88 + }, + { + 0xCF, 0xFA, 0xE0, 0xBF, 0x43, 0x90, 0x90, 0xE2, + 0x63, 0x6F, 0x07, 0x35, 0xD8, 0xB7, 0xE6, 0x78, + 0xC7, 0xD3, 0xA9, 0x42, 0xA5, 0xF3, 0xF8, 0xEE, + 0x8B, 0xCE, 0x90, 0xDE, 0x03, 0x23, 0x96, 0x2F + }, + { + 0xDD, 0xDF, 0xCE, 0xF4, 0x03, 0x41, 0xA2, 0xF3, + 0x3F, 0xD8, 0xD2, 0xB0, 0xB7, 0x60, 0xBE, 0xA7, + 0x22, 0x96, 0x93, 0x86, 0x79, 0x52, 0xFC, 0x9F, + 0x0B, 0xFB, 0xEB, 0x63, 0x97, 0x3B, 0x72, 0x65 + }, + { + 0xBB, 0x1E, 0x07, 0xB5, 0xEB, 0xE3, 0xFB, 0x65, + 0xCF, 0xE9, 0xFF, 0xFD, 0xE7, 0x54, 0x34, 0xE7, + 0xB3, 0xA9, 0xEA, 0xDB, 0x9A, 0xC4, 0x24, 0x4E, + 0xC2, 0x0B, 0x9D, 0xD4, 0x87, 0xD5, 0x38, 0x86 + }, + { + 0xD5, 0x58, 0x98, 0xEF, 0x37, 0x30, 0x58, 0xA0, + 0x17, 0x37, 0xA7, 0x42, 0x79, 0x99, 0x12, 0x36, + 0xD2, 0x5F, 0x50, 0x97, 0xB7, 0x61, 0x6C, 0x31, + 0x9B, 0x12, 0xA2, 0xBA, 0x30, 0x0F, 0xE3, 0x3F + }, + { + 0xEB, 0x37, 0xF8, 0x35, 0x48, 0xFC, 0x7B, 0x63, + 0xCB, 0x73, 0x1A, 0xB1, 0xB8, 0x29, 0x38, 0x08, + 0x8D, 0x23, 0x4F, 0x5C, 0xB3, 0x5F, 0x7A, 0xE1, + 0xE6, 0x6D, 0x70, 0x0D, 0x36, 0xCD, 0x85, 0x00 + }, + { + 0xA5, 0x68, 0xB6, 0xB7, 0x9C, 0xE0, 0x14, 0x52, + 0xEC, 0x1F, 0xC1, 0x1F, 0x85, 0x20, 0xAE, 0x7B, + 0xB5, 0xCA, 0xB1, 0xC2, 0x33, 0x03, 0x96, 0x78, + 0xC1, 0x45, 0x22, 0x55, 0xA6, 0x1D, 0x4A, 0x66 + }, + { + 0x84, 0x5B, 0x98, 0x2B, 0xF8, 0xE3, 0xF3, 0x56, + 0xA9, 0xC2, 0xD4, 0x6E, 0x5C, 0x27, 0x10, 0x30, + 0x86, 0xAE, 0xAC, 0xEB, 0x03, 0xBA, 0xD7, 0x0B, + 0x02, 0x89, 0xFF, 0x9C, 0x7E, 0x6A, 0x60, 0x89 + }, + { + 0x34, 0x8C, 0xD3, 0x05, 0x1F, 0x47, 0x47, 0xB5, + 0x35, 0x58, 0xC2, 0x54, 0xE1, 0xEE, 0x29, 0x26, + 0x5F, 0x1C, 0x90, 0x18, 0x4E, 0x83, 0x9B, 0x9B, + 0xC6, 0x4C, 0xE9, 0x1A, 0x94, 0x40, 0x1F, 0x0B + }, + { + 0xCB, 0xAC, 0x75, 0x49, 0x66, 0x8B, 0x92, 0x58, + 0x5C, 0x22, 0xFF, 0x28, 0x2B, 0x7B, 0xFE, 0x3D, + 0xAB, 0x42, 0xF5, 0xCC, 0x06, 0x22, 0x94, 0x01, + 0x6F, 0x1D, 0x0A, 0xF6, 0xCD, 0xC5, 0x6D, 0x04 + }, + { + 0x65, 0x38, 0xBD, 0x43, 0x88, 0x5E, 0xCA, 0xB3, + 0x89, 0xFA, 0x1D, 0x20, 0x57, 0x60, 0x3B, 0x31, + 0x61, 0xB9, 0x23, 0x8A, 0x03, 0xF7, 0xDE, 0x18, + 0xED, 0xFD, 0xFA, 0xDC, 0xF2, 0xC2, 0xF0, 0xEB + }, + { + 0x29, 0xC9, 0x45, 0xBA, 0x80, 0x00, 0xC9, 0x25, + 0xC4, 0x10, 0x76, 0x93, 0x9C, 0xF3, 0x14, 0x76, + 0x67, 0x42, 0xDD, 0x64, 0x39, 0x17, 0xE3, 0xA5, + 0xF9, 0x7A, 0x5A, 0xAB, 0x12, 0x12, 0x72, 0x73 + }, + { + 0xB1, 0x24, 0x2F, 0x33, 0x9E, 0x76, 0x0C, 0xC5, + 0x3B, 0x3D, 0x06, 0x66, 0xC0, 0x9A, 0x73, 0x74, + 0x64, 0x0D, 0x0C, 0xF4, 0x75, 0x02, 0x09, 0xDE, + 0x28, 0x1E, 0x27, 0x84, 0x91, 0x79, 0xC3, 0x0D + }, + { + 0x84, 0x2F, 0xAE, 0x8C, 0xE2, 0xA6, 0xA7, 0xF0, + 0xC2, 0x3B, 0x13, 0x35, 0xDB, 0x37, 0x67, 0xAA, + 0x07, 0x13, 0xF2, 0xE4, 0x5C, 0xC0, 0xC1, 0x04, + 0x80, 0x7C, 0xCE, 0xDC, 0x35, 0xFC, 0x56, 0x98 + }, + { + 0x88, 0x16, 0x15, 0x3B, 0xA1, 0x3B, 0xBE, 0x63, + 0xAB, 0x06, 0xEC, 0xD8, 0x98, 0xF0, 0xBA, 0x48, + 0xB2, 0x48, 0xBE, 0x96, 0x6D, 0x56, 0x2D, 0xD9, + 0x6A, 0x04, 0xBE, 0xD2, 0x0C, 0x62, 0xB9, 0xBE + }, + { + 0x67, 0x77, 0x14, 0x34, 0x04, 0x7D, 0xE5, 0xF2, + 0xF1, 0xDE, 0x13, 0xC7, 0x68, 0xFB, 0x5B, 0x03, + 0x6D, 0x16, 0xBB, 0x33, 0xAF, 0x04, 0x66, 0x5D, + 0x18, 0x09, 0x28, 0x04, 0x21, 0x77, 0xEE, 0xEA + }, + { + 0x96, 0xCC, 0xC7, 0x0B, 0xA6, 0x8E, 0x96, 0x74, + 0x6B, 0x2D, 0x38, 0x87, 0xAF, 0x98, 0x38, 0xEE, + 0x65, 0xAC, 0xDB, 0x74, 0xFC, 0xD2, 0x37, 0x9A, + 0x10, 0xCC, 0x9D, 0x6C, 0x2D, 0x3D, 0x66, 0x66 + }, + { + 0x68, 0x94, 0x3D, 0x88, 0x3E, 0x24, 0xEE, 0x53, + 0xD6, 0x7A, 0x68, 0x85, 0xFA, 0xF7, 0x15, 0xF4, + 0x34, 0x90, 0x6A, 0x86, 0x33, 0xFB, 0x27, 0x40, + 0x22, 0x60, 0x5A, 0x9D, 0x24, 0xB2, 0xB2, 0x04 + }, + { + 0xF2, 0x95, 0xB7, 0x19, 0x76, 0xD6, 0xB7, 0x46, + 0xC2, 0x44, 0xAA, 0xC0, 0x3C, 0x10, 0x1D, 0xDB, + 0xF2, 0x4B, 0xD4, 0x32, 0x4F, 0x83, 0xD3, 0xC6, + 0xD4, 0xC6, 0x37, 0x6C, 0x5E, 0x7D, 0x57, 0x87 + }, + { + 0x57, 0x08, 0x3D, 0x30, 0x8C, 0x00, 0x53, 0xC7, + 0x43, 0x2F, 0x9E, 0x36, 0x21, 0x34, 0xA7, 0xD5, + 0x4C, 0xA2, 0x31, 0xD1, 0xCC, 0x43, 0xF4, 0x9C, + 0xC8, 0x42, 0x0D, 0x52, 0x46, 0x03, 0x41, 0xC9 + }, + { + 0x5E, 0x5A, 0x18, 0x94, 0xFC, 0xB6, 0x07, 0x9A, + 0x72, 0xB5, 0x95, 0x78, 0xE4, 0xC0, 0xC9, 0x17, + 0xC7, 0xE8, 0x56, 0x50, 0x11, 0x92, 0x9F, 0xAC, + 0xB8, 0x0A, 0x16, 0x67, 0x97, 0x53, 0x66, 0xAE + }, + { + 0xD1, 0x58, 0x08, 0xA6, 0xA2, 0x57, 0x7B, 0xCA, + 0x2E, 0x9E, 0xBD, 0xC4, 0x79, 0xB3, 0xDE, 0x27, + 0x77, 0x6C, 0x41, 0x19, 0xA7, 0xD9, 0x91, 0xA5, + 0x83, 0xBA, 0xEF, 0x02, 0x36, 0xEE, 0x5F, 0x6E + }, + { + 0x65, 0x45, 0xFB, 0x93, 0xAA, 0x01, 0x8F, 0x40, + 0x5E, 0x20, 0x53, 0x89, 0xFB, 0x8E, 0xE0, 0x3E, + 0xE7, 0xF3, 0xB7, 0xE7, 0xC1, 0xB1, 0xA6, 0xB0, + 0xC3, 0x22, 0x17, 0x6C, 0x02, 0xEA, 0x39, 0x67 + }, + { + 0x52, 0x30, 0x30, 0x04, 0xF5, 0x07, 0x97, 0xC1, + 0xF9, 0x35, 0x0E, 0x2D, 0x4F, 0xCD, 0x20, 0x82, + 0x12, 0xEF, 0x6B, 0xEA, 0xF6, 0x26, 0x5E, 0x92, + 0xF3, 0x9D, 0x30, 0x46, 0x3B, 0x92, 0xCE, 0xF2 + }, + { + 0xB6, 0x89, 0x4E, 0x26, 0xEA, 0x12, 0xCB, 0x4B, + 0x79, 0xA9, 0xB9, 0x67, 0xC5, 0x12, 0x51, 0xC0, + 0xEB, 0x39, 0x37, 0x70, 0xFE, 0x1F, 0x3C, 0x7A, + 0x1B, 0xB3, 0xEA, 0x81, 0xA8, 0xA4, 0xD0, 0x26 + }, + { + 0x3E, 0xC8, 0x47, 0x11, 0x15, 0x38, 0x61, 0x99, + 0x1F, 0x2A, 0x25, 0x98, 0x52, 0x62, 0x69, 0x5F, + 0x05, 0x84, 0x57, 0x03, 0x6F, 0x15, 0x04, 0xC9, + 0xB6, 0x33, 0xBC, 0xEF, 0x83, 0x65, 0x3C, 0x4E + }, + { + 0x28, 0x7F, 0x78, 0x6B, 0x89, 0x32, 0x0D, 0x19, + 0xEB, 0x9B, 0x42, 0xC4, 0x8E, 0x82, 0x05, 0x3F, + 0x83, 0x08, 0xBF, 0x8A, 0x7D, 0x5F, 0x03, 0x80, + 0xBB, 0x1E, 0xF8, 0x8F, 0xAB, 0x07, 0x95, 0xAA + }, + { + 0xD7, 0x5D, 0x25, 0x8C, 0x3F, 0x09, 0x5F, 0x0B, + 0x0D, 0xAA, 0x35, 0x35, 0x54, 0xB4, 0xD6, 0x08, + 0x81, 0x71, 0x86, 0x19, 0x36, 0x87, 0x9D, 0xB1, + 0xCC, 0x1C, 0xFC, 0x1F, 0x3E, 0x95, 0x7D, 0x0E + }, + { + 0x43, 0xB6, 0x68, 0xF6, 0xC7, 0x69, 0x75, 0xAC, + 0x5D, 0xBA, 0x11, 0x68, 0xA5, 0xC7, 0x26, 0x7F, + 0x8E, 0xB5, 0x7B, 0xDB, 0x15, 0x49, 0x62, 0x18, + 0x3F, 0xBB, 0xE5, 0xBF, 0x10, 0x77, 0xC4, 0x00 + }, + { + 0x6F, 0x37, 0x27, 0x80, 0x56, 0x56, 0xAB, 0x6E, + 0x53, 0xCA, 0x93, 0x11, 0x2D, 0xF1, 0x1B, 0x98, + 0x83, 0x5A, 0x5D, 0xB1, 0xE2, 0x2A, 0x26, 0x3D, + 0xC1, 0x24, 0x2A, 0xB9, 0xD6, 0xD7, 0xA8, 0xF7 + }, + { + 0x60, 0x74, 0xD2, 0x76, 0x96, 0xD1, 0x93, 0xD5, + 0x38, 0x97, 0x2A, 0x6C, 0x9D, 0x6B, 0x7F, 0xD0, + 0xD8, 0x1F, 0xCB, 0x50, 0x71, 0x57, 0xA4, 0x55, + 0x3B, 0x82, 0xEF, 0x3A, 0xF0, 0x5C, 0x7D, 0x17 + }, + { + 0x2B, 0x26, 0xD6, 0x1E, 0xC3, 0x2A, 0xE4, 0x01, + 0x3B, 0x59, 0x46, 0x81, 0x57, 0xE1, 0x4F, 0xBA, + 0x33, 0xD8, 0xB5, 0x07, 0x71, 0x37, 0xE6, 0xA9, + 0xF1, 0x58, 0x44, 0x9E, 0xF0, 0x15, 0x7C, 0x76 + }, + { + 0xE4, 0x49, 0x16, 0x86, 0xA1, 0x2D, 0xFF, 0xE0, + 0x6F, 0x51, 0x6F, 0x3B, 0x81, 0x8D, 0x88, 0x3B, + 0x9B, 0x9E, 0xC6, 0x49, 0xD2, 0xF3, 0x7A, 0x1E, + 0xE3, 0x99, 0xB2, 0xC5, 0x0C, 0x74, 0x88, 0x48 + }, + { + 0x76, 0x83, 0xBE, 0xEF, 0x7C, 0x16, 0x86, 0x61, + 0xEB, 0x99, 0xCC, 0x05, 0x5F, 0xE9, 0x51, 0xC5, + 0x0B, 0xEB, 0x8B, 0xB5, 0xF9, 0x40, 0x49, 0x3F, + 0x78, 0x1C, 0xC2, 0x3A, 0x1B, 0xA8, 0x9A, 0xB2 + }, + { + 0x1C, 0x29, 0x49, 0x9F, 0x97, 0xF7, 0x8B, 0xE5, + 0x4C, 0xB2, 0x83, 0x9A, 0xFD, 0xAE, 0x65, 0x04, + 0xBB, 0xDF, 0x0D, 0x33, 0x3B, 0x7A, 0x82, 0x74, + 0xD4, 0xCA, 0x08, 0x93, 0x3A, 0xB1, 0x8A, 0x2C + }, + { + 0xA7, 0x5D, 0x2C, 0xFA, 0x87, 0xCC, 0x99, 0x32, + 0x1F, 0x20, 0x33, 0x4F, 0x55, 0x06, 0x60, 0xEE, + 0x7E, 0xB8, 0x8B, 0x7A, 0x63, 0x59, 0xF5, 0x88, + 0x6B, 0x2F, 0x8D, 0x70, 0x91, 0xDE, 0x36, 0xA6 + }, + { + 0xBA, 0x5B, 0xD0, 0x62, 0x5E, 0x8F, 0xF5, 0x50, + 0x93, 0x1A, 0xF9, 0x45, 0x49, 0x8C, 0xFF, 0x0D, + 0x59, 0xFB, 0x7D, 0x7E, 0x72, 0xF0, 0xEA, 0xC7, + 0xAE, 0xE3, 0xB4, 0x0A, 0x6C, 0x35, 0x20, 0x68 + }, + { + 0xF1, 0x49, 0xBE, 0x3F, 0xDF, 0x1E, 0x07, 0x48, + 0x86, 0x84, 0x35, 0x77, 0x0C, 0x96, 0xD2, 0x18, + 0x7F, 0x15, 0xF3, 0xC1, 0xCF, 0xE7, 0xAB, 0x32, + 0x31, 0x9F, 0x22, 0x55, 0x57, 0xB5, 0x3A, 0x30 + }, + { + 0xD0, 0xEA, 0x4D, 0x60, 0x0A, 0x51, 0xCB, 0x6B, + 0x9B, 0x8D, 0xDA, 0xA2, 0xA5, 0x0E, 0x25, 0x3E, + 0x97, 0xDD, 0x82, 0xE8, 0x50, 0x0B, 0x57, 0xC3, + 0x0E, 0x29, 0xD2, 0x9A, 0x2D, 0xE9, 0x45, 0xA6 + }, + { + 0x30, 0x51, 0x4D, 0x12, 0xD0, 0xBC, 0x0D, 0xB0, + 0x79, 0x46, 0x86, 0x18, 0xC1, 0xE1, 0x02, 0x4D, + 0x85, 0x98, 0xBA, 0xCF, 0xA8, 0xA6, 0x62, 0x8D, + 0xF3, 0xBA, 0xB3, 0xC9, 0xC7, 0x29, 0x6A, 0xB6 + }, + { + 0xA3, 0x3A, 0xB8, 0xD1, 0x16, 0xFD, 0x82, 0x67, + 0x9B, 0xE3, 0x5F, 0x7B, 0x15, 0x49, 0x96, 0xF9, + 0x39, 0xB0, 0xC1, 0xA7, 0xA3, 0xD1, 0xB3, 0x6D, + 0xFF, 0x20, 0x3F, 0xDE, 0xB2, 0x45, 0xAF, 0x91 + }, + { + 0xC6, 0xCE, 0xF0, 0x4B, 0x95, 0x46, 0x4F, 0x73, + 0x3B, 0x97, 0x58, 0xBA, 0x8A, 0xFD, 0xF4, 0x89, + 0xE8, 0x6C, 0x40, 0x53, 0xC7, 0x7B, 0xB2, 0x27, + 0xD5, 0x55, 0x97, 0xD3, 0x3E, 0x48, 0x43, 0xEE + }, + { + 0xFD, 0x71, 0x7B, 0x41, 0x0A, 0x43, 0xC3, 0x42, + 0xAC, 0x78, 0x99, 0xB9, 0xA5, 0x3D, 0x8B, 0x17, + 0xB2, 0x97, 0x1B, 0xEE, 0xCA, 0x15, 0x04, 0x6A, + 0x32, 0x77, 0x5F, 0x01, 0x27, 0x63, 0x92, 0x22 + }, + { + 0xF3, 0x7F, 0x77, 0x21, 0xCD, 0x4E, 0xBA, 0x1A, + 0xF0, 0x39, 0x22, 0x93, 0x85, 0x7D, 0x5C, 0x8A, + 0x93, 0xA5, 0xAE, 0x89, 0x1F, 0xB2, 0x49, 0xA1, + 0x2A, 0xDD, 0xE5, 0x97, 0x81, 0xDD, 0x4E, 0x21 + }, + { + 0x72, 0xBE, 0xDE, 0xA2, 0xC3, 0xF5, 0xCE, 0x20, + 0xE0, 0xE1, 0x5A, 0x56, 0xD5, 0xBC, 0x82, 0x82, + 0xF7, 0x1E, 0xB0, 0x55, 0x8D, 0xD4, 0xCC, 0x27, + 0xC0, 0x78, 0x3A, 0xD1, 0x2A, 0x93, 0x15, 0xCA + }, + { + 0x6C, 0x13, 0x7F, 0x02, 0x29, 0xB7, 0xCE, 0x3F, + 0xAC, 0x0D, 0x7B, 0xA8, 0x81, 0xD0, 0x1B, 0x56, + 0x75, 0xBC, 0x83, 0x26, 0x5A, 0x5F, 0x34, 0x27, + 0xF4, 0x59, 0xE0, 0x9D, 0x9E, 0xCC, 0xC2, 0xC4 + }, + { + 0x8E, 0x87, 0x7E, 0xFA, 0xE1, 0xEC, 0x76, 0x67, + 0x57, 0x98, 0xA3, 0xEA, 0x10, 0xC1, 0xD5, 0xC1, + 0x8E, 0x08, 0xD4, 0xA6, 0x9B, 0xC4, 0x51, 0x21, + 0xC7, 0x9E, 0x47, 0xC0, 0x20, 0xD0, 0x25, 0xE6 + }, + { + 0x73, 0xFF, 0xC1, 0xB5, 0x5B, 0xF4, 0xE0, 0xCB, + 0x67, 0xE0, 0x06, 0x5B, 0x54, 0x71, 0xD2, 0x35, + 0xC3, 0x03, 0x79, 0x63, 0x8B, 0x5E, 0x98, 0xC2, + 0xC8, 0xB5, 0xF1, 0xCA, 0xD8, 0x92, 0xB0, 0x84 + }, + { + 0x63, 0xD5, 0xF4, 0x87, 0x9E, 0xBE, 0xC1, 0x05, + 0xCA, 0x0F, 0xA0, 0x62, 0xA7, 0xDA, 0xAF, 0x61, + 0x33, 0x82, 0x3A, 0x55, 0xDF, 0x35, 0x53, 0x42, + 0xEF, 0x04, 0xC2, 0x8D, 0xBE, 0xD0, 0x3D, 0xC6 + }, + { + 0x5B, 0x97, 0x68, 0x05, 0x48, 0x63, 0x2D, 0x56, + 0xF6, 0x99, 0xEC, 0x3D, 0x6B, 0xA8, 0x87, 0x7F, + 0xF8, 0x4E, 0xFB, 0xA7, 0xCD, 0x7A, 0x39, 0x83, + 0xAB, 0x63, 0xAB, 0x38, 0x4C, 0x1A, 0x33, 0xD6 + }, + { + 0xEF, 0x06, 0x19, 0x12, 0x6B, 0x72, 0x40, 0xA7, + 0x91, 0x7E, 0xD9, 0x60, 0x82, 0xB6, 0x12, 0x77, + 0x1A, 0x84, 0x05, 0xD8, 0x66, 0xC3, 0x35, 0x9C, + 0x99, 0xE4, 0xE9, 0xCC, 0x54, 0x7C, 0xDB, 0x95 + }, + { + 0x8C, 0xBB, 0xC1, 0x1A, 0x57, 0xED, 0x0F, 0x64, + 0x80, 0xD8, 0xA3, 0x6F, 0x65, 0xF8, 0x53, 0x0F, + 0x59, 0xFE, 0x8B, 0x2A, 0x5F, 0xAB, 0xED, 0x22, + 0xBB, 0xDB, 0x2A, 0x35, 0x0A, 0xE1, 0xD7, 0x24 + }, + { + 0x65, 0x97, 0x67, 0x5A, 0xD3, 0x75, 0xB6, 0x85, + 0xEB, 0xD1, 0xF3, 0xE2, 0x14, 0x86, 0x7C, 0x70, + 0x20, 0x4D, 0x6F, 0x45, 0xB1, 0x4C, 0x31, 0xC8, + 0x27, 0xE8, 0x30, 0x8D, 0xEB, 0x09, 0xF1, 0x3D + }, + { + 0x1C, 0xD1, 0x5C, 0x0A, 0x53, 0x4C, 0x25, 0xAC, + 0xE8, 0xFE, 0x69, 0xA8, 0x6E, 0x61, 0x87, 0xC8, + 0x95, 0xE1, 0xB8, 0x7F, 0x3A, 0x84, 0x41, 0xF4, + 0x92, 0xC3, 0x65, 0x93, 0x8D, 0x59, 0x88, 0x1E + }, + { + 0xF5, 0xCC, 0x9F, 0xB4, 0x25, 0x0C, 0xEF, 0xC5, + 0x8E, 0x99, 0x81, 0x37, 0x89, 0x44, 0xB1, 0x12, + 0x5B, 0x28, 0x1C, 0xEB, 0xC7, 0xA7, 0xFF, 0x37, + 0x32, 0x07, 0xD6, 0x37, 0x9A, 0x65, 0x4B, 0x71 + }, + { + 0x26, 0x2F, 0xE7, 0x16, 0x57, 0xCF, 0x1B, 0x89, + 0x86, 0xFB, 0x65, 0x4E, 0xE7, 0x23, 0x7E, 0x60, + 0x5A, 0xB1, 0x81, 0xA0, 0xF0, 0x48, 0x34, 0x78, + 0xBD, 0x5A, 0x91, 0x31, 0xF1, 0x12, 0xAD, 0x4E + }, + { + 0x5B, 0x5E, 0x29, 0x44, 0x13, 0x71, 0x09, 0x77, + 0xEF, 0x78, 0x35, 0xBE, 0x1C, 0x9B, 0x86, 0xBA, + 0x91, 0xF6, 0xF4, 0xDB, 0xF6, 0x2A, 0x2C, 0xED, + 0xBD, 0x0A, 0xA4, 0xEC, 0x07, 0x58, 0x69, 0x48 + }, + { + 0xAE, 0x26, 0x93, 0x6C, 0xB9, 0x11, 0x31, 0x9C, + 0xCC, 0xBB, 0xE3, 0x40, 0xB2, 0x8D, 0x61, 0x56, + 0x85, 0x37, 0xFB, 0xB7, 0x95, 0x1F, 0x57, 0x5C, + 0x82, 0xF1, 0x76, 0x5A, 0x82, 0xAF, 0x64, 0xFC + }, + { + 0xBA, 0x1F, 0x4D, 0x51, 0x21, 0xC3, 0xA3, 0x92, + 0x01, 0xD0, 0x53, 0xC3, 0x27, 0x4D, 0x45, 0x43, + 0xFA, 0xCF, 0x34, 0x39, 0x70, 0xC9, 0x6D, 0x67, + 0xAD, 0x18, 0x85, 0xBD, 0x1C, 0x8B, 0x72, 0xD9 + }, + { + 0x77, 0x67, 0xFD, 0xF5, 0xD2, 0x16, 0xE1, 0x77, + 0x47, 0x76, 0x2E, 0x02, 0x8E, 0x33, 0x3D, 0x4D, + 0xD6, 0xC7, 0xB3, 0x9F, 0x71, 0x60, 0xDA, 0x42, + 0x93, 0xBB, 0x92, 0xF3, 0x77, 0x7A, 0x70, 0xD6 + }, + { + 0xAC, 0x26, 0x51, 0xC4, 0xE5, 0x09, 0x11, 0x58, + 0x0D, 0x4D, 0xD7, 0xB2, 0xD1, 0xA3, 0x71, 0xDF, + 0x87, 0xEB, 0x05, 0xC0, 0x4A, 0x73, 0x19, 0xB6, + 0xA4, 0x31, 0xAA, 0xC4, 0x72, 0x3B, 0x89, 0xFB + }, + { + 0xFF, 0x0F, 0x98, 0x7A, 0x67, 0xB6, 0x17, 0x36, + 0xC8, 0xFF, 0x17, 0xFA, 0x43, 0x57, 0x02, 0x0A, + 0xB4, 0xBA, 0xE3, 0xFD, 0x4F, 0x3B, 0x25, 0xE4, + 0x43, 0xAF, 0xDD, 0xA1, 0x0D, 0x8E, 0x52, 0x63 + }, + { + 0x7A, 0x7F, 0x61, 0x49, 0x57, 0xA5, 0xDB, 0x9E, + 0xE8, 0xDC, 0x3B, 0xFE, 0x3E, 0x7F, 0x83, 0x7D, + 0x22, 0x40, 0x8F, 0xF3, 0xF5, 0x35, 0x66, 0x53, + 0x75, 0x81, 0xB7, 0x05, 0xEB, 0x0C, 0xB8, 0x25 + }, + { + 0x05, 0x30, 0xFE, 0xDA, 0x47, 0x92, 0xFD, 0x77, + 0x82, 0xF5, 0x53, 0x5D, 0xCD, 0x41, 0x59, 0x5C, + 0x49, 0xF0, 0x45, 0xAF, 0x12, 0xE4, 0xAC, 0x02, + 0x44, 0xFA, 0x81, 0x77, 0x03, 0x4D, 0x26, 0x36 + }, + { + 0x00, 0x17, 0x75, 0xDD, 0xE8, 0x98, 0xC5, 0x7D, + 0x4C, 0x67, 0x7F, 0x23, 0xA0, 0x8E, 0xD4, 0x06, + 0xA4, 0x71, 0x44, 0x2F, 0x37, 0xE9, 0x69, 0x6D, + 0xF9, 0xE1, 0x82, 0xB0, 0x76, 0xB5, 0x47, 0xE0 + }, + { + 0x86, 0x3A, 0x87, 0xB7, 0xD2, 0xCB, 0x5D, 0x50, + 0x08, 0x55, 0xFC, 0x5B, 0xDB, 0xA3, 0x74, 0x8F, + 0xE1, 0x83, 0x43, 0x8F, 0x44, 0xC0, 0x1F, 0x24, + 0x80, 0xF4, 0x07, 0x93, 0x91, 0xCF, 0xE8, 0x62 + }, + { + 0x95, 0x27, 0x80, 0x2D, 0x88, 0xD4, 0x76, 0x77, + 0x32, 0x34, 0x0E, 0x26, 0xAC, 0xF7, 0xEC, 0x29, + 0x9B, 0x62, 0x03, 0x26, 0xAD, 0xCB, 0xB0, 0xEE, + 0x71, 0x4A, 0xEC, 0xA8, 0x61, 0x3B, 0x84, 0x83 + }, + { + 0x8E, 0x2C, 0xCF, 0x33, 0xBA, 0x93, 0x43, 0xC6, + 0x7A, 0xDC, 0x6F, 0xF3, 0xAE, 0xFC, 0x37, 0xF2, + 0x3F, 0xE8, 0xFF, 0x36, 0xAF, 0x2C, 0xD8, 0xB5, + 0xE7, 0x7B, 0x50, 0x87, 0x55, 0x25, 0xA7, 0xBA + }, + { + 0x8C, 0x9A, 0x99, 0x68, 0x26, 0xBB, 0x18, 0xBF, + 0xF7, 0x51, 0xEB, 0xC0, 0x10, 0x26, 0x07, 0x3A, + 0x83, 0xF9, 0x71, 0x85, 0x9A, 0x96, 0xF8, 0x4D, + 0xC5, 0x2C, 0x7D, 0xF9, 0x42, 0xB1, 0x68, 0xD6 + }, + { + 0x2B, 0x12, 0xE0, 0x11, 0x80, 0xBB, 0xD7, 0x0B, + 0x58, 0x4F, 0xBA, 0x22, 0x1A, 0x74, 0x93, 0xA8, + 0x24, 0xFB, 0x16, 0xFB, 0x48, 0x99, 0x68, 0xD9, + 0xBF, 0x2B, 0x45, 0x11, 0x75, 0x53, 0xBF, 0xC5 + }, + { + 0x66, 0xC5, 0xD7, 0x4A, 0x65, 0x43, 0x5B, 0xDC, + 0x6E, 0x09, 0x89, 0x37, 0xF9, 0x5B, 0x76, 0xEF, + 0x66, 0x89, 0xB6, 0x60, 0x5A, 0x39, 0x7A, 0xF4, + 0xF5, 0xBC, 0xE7, 0x59, 0x1C, 0x08, 0x61, 0x6E + }, + { + 0x1E, 0xF1, 0xBD, 0xC4, 0x01, 0x4F, 0x0A, 0x9F, + 0xA8, 0xA3, 0x66, 0x63, 0xEE, 0x8B, 0x4F, 0xA9, + 0x87, 0x1F, 0x5E, 0x2F, 0x5A, 0x9A, 0x70, 0x0C, + 0x83, 0x42, 0x4B, 0x88, 0x7F, 0x24, 0x7C, 0x2B + }, + { + 0x36, 0xC4, 0xC8, 0x88, 0x14, 0x06, 0xC4, 0xBA, + 0x24, 0x30, 0x57, 0x38, 0xF6, 0x22, 0x17, 0xB7, + 0x17, 0x1C, 0xB1, 0x34, 0x93, 0x84, 0xC6, 0x47, + 0x7F, 0x8E, 0xE6, 0x75, 0xBB, 0x46, 0x9C, 0x4C + }, + { + 0x83, 0xA8, 0x58, 0x5D, 0x10, 0x22, 0x35, 0x64, + 0x1A, 0xCF, 0xF1, 0x95, 0xCF, 0x7C, 0x6C, 0xED, + 0x23, 0xE4, 0x44, 0x8F, 0xBD, 0xB0, 0x5E, 0xBA, + 0xD8, 0x1A, 0x6B, 0x59, 0xA8, 0x59, 0x1A, 0xAA + }, + { + 0xF7, 0x09, 0x97, 0xBA, 0x73, 0xFC, 0xFE, 0x34, + 0xDA, 0x35, 0x42, 0x80, 0x90, 0x4A, 0xD0, 0xC1, + 0x7E, 0x95, 0x6A, 0xDA, 0x61, 0x27, 0x97, 0x77, + 0x6E, 0x03, 0xC3, 0x20, 0x71, 0xEA, 0xDD, 0x17 + }, + { + 0xBC, 0x86, 0xDD, 0xE2, 0xE3, 0x2F, 0xDD, 0xD4, + 0xD7, 0x84, 0x22, 0xBE, 0xF8, 0x13, 0x78, 0xCC, + 0x52, 0x97, 0x18, 0x7D, 0x33, 0x8E, 0x4C, 0x5B, + 0x89, 0x2D, 0x3C, 0xA3, 0x20, 0xFE, 0x60, 0x85 + }, + { + 0x46, 0x7B, 0xF3, 0x6E, 0xBD, 0x8F, 0x4A, 0x7B, + 0xB1, 0xEF, 0x54, 0xF3, 0x34, 0x9D, 0x47, 0x57, + 0x84, 0x52, 0xA9, 0x26, 0x15, 0xBC, 0xFC, 0xCB, + 0xFE, 0xB6, 0x90, 0x78, 0x18, 0x51, 0x23, 0xF9 + }, + { + 0xA1, 0xA1, 0x7C, 0x39, 0x01, 0xED, 0x1A, 0x1F, + 0xD6, 0xA1, 0xB5, 0x14, 0xD3, 0x3F, 0x22, 0x8E, + 0x14, 0x36, 0xFD, 0xE2, 0x92, 0x83, 0x6C, 0xEB, + 0xE3, 0x9B, 0x6F, 0x7D, 0x9C, 0xA6, 0x53, 0x33 + }, + { + 0x1A, 0xF9, 0x49, 0x35, 0xD5, 0xF3, 0xE3, 0x7D, + 0xFF, 0x10, 0x9A, 0x9D, 0x2B, 0x12, 0x54, 0x48, + 0x56, 0x43, 0x75, 0x40, 0xBD, 0x55, 0xE8, 0x23, + 0x3F, 0x7A, 0x42, 0xA8, 0xDA, 0x97, 0x86, 0x7B + }, + { + 0x8F, 0x15, 0x9B, 0x34, 0x48, 0xB6, 0xA8, 0x8B, + 0x3A, 0x6B, 0x8B, 0xF4, 0xFE, 0x4F, 0xE6, 0xB6, + 0x33, 0xD8, 0xDE, 0x52, 0x0B, 0x5C, 0x88, 0x32, + 0xB0, 0xF1, 0xC7, 0x73, 0x6D, 0x09, 0x83, 0x3D + }, + { + 0xBF, 0xF1, 0xC1, 0xA3, 0x87, 0xAB, 0x6E, 0x7A, + 0xE6, 0x85, 0xD8, 0x21, 0x8E, 0x47, 0x39, 0x30, + 0x46, 0x15, 0x56, 0xFD, 0x42, 0xC8, 0xF7, 0x27, + 0xCD, 0x84, 0x77, 0xEF, 0x68, 0x0A, 0x3D, 0x17 + }, + { + 0x45, 0x9C, 0x22, 0xCE, 0xE3, 0xE9, 0xD1, 0xC0, + 0x83, 0xDB, 0x66, 0xDC, 0xB8, 0x7B, 0xF8, 0x5C, + 0x78, 0x62, 0xB5, 0x44, 0x43, 0x33, 0x7D, 0x9F, + 0x44, 0x4A, 0xF7, 0x97, 0x32, 0xEB, 0x46, 0x33 + }, + { + 0xF4, 0x2A, 0xA0, 0x49, 0x95, 0xC3, 0xC4, 0xCF, + 0xA3, 0x96, 0xF3, 0x40, 0x8D, 0x6B, 0x91, 0xA4, + 0x77, 0x1D, 0x18, 0x7E, 0x03, 0xE6, 0x44, 0xA2, + 0xB3, 0xA6, 0x4C, 0x2A, 0xD7, 0xB5, 0x75, 0x33 + }, + { + 0xC9, 0xE7, 0x27, 0xB1, 0xDF, 0x56, 0x91, 0xC4, + 0x49, 0xB7, 0x41, 0x71, 0x03, 0xBF, 0xBD, 0xDB, + 0x9A, 0x9C, 0x7F, 0x0C, 0xAB, 0xAA, 0x6D, 0xF5, + 0x67, 0x82, 0x37, 0x75, 0x84, 0x08, 0xF4, 0x7D + }, + { + 0xE8, 0x78, 0xEB, 0x31, 0xBD, 0xA2, 0xA9, 0x34, + 0xB3, 0x45, 0xA0, 0x5B, 0x67, 0x52, 0xC3, 0x28, + 0x1F, 0x43, 0xE4, 0x8C, 0x50, 0x82, 0xD9, 0xAA, + 0x8C, 0x59, 0x1E, 0x82, 0xEF, 0xAD, 0xC6, 0xDA + }, + { + 0x5D, 0x5E, 0xE3, 0xFC, 0x72, 0xE4, 0x64, 0xC8, + 0x77, 0xE3, 0x84, 0x11, 0x7A, 0x61, 0x3E, 0x97, + 0x02, 0x84, 0xF1, 0xE5, 0x55, 0xE7, 0xD5, 0xB0, + 0x6C, 0x14, 0xFC, 0xF0, 0x46, 0x55, 0xFE, 0xD7 + }, + { + 0x7E, 0x49, 0xA7, 0x62, 0x46, 0x00, 0xDC, 0xD7, + 0x11, 0x59, 0xB3, 0x1E, 0x25, 0x7C, 0x3A, 0x5D, + 0x18, 0x44, 0x92, 0x66, 0xEF, 0x03, 0xEB, 0xF0, + 0xE7, 0xBA, 0x7A, 0xB3, 0x25, 0xD0, 0xD7, 0x71 + }, + { + 0xFB, 0x79, 0xCB, 0x98, 0xF7, 0xF3, 0xB0, 0xF6, + 0x19, 0xFF, 0xBB, 0xFB, 0x76, 0xDE, 0x8B, 0x9B, + 0x93, 0xB1, 0x75, 0x5F, 0x47, 0xBF, 0x3B, 0x1C, + 0x13, 0xD2, 0xB3, 0xC3, 0x72, 0x9D, 0x5A, 0x5A + }, + { + 0xED, 0x5B, 0x4A, 0xFE, 0x1E, 0x04, 0x7D, 0xB0, + 0xDE, 0xBE, 0xAE, 0x75, 0x27, 0xE1, 0xDB, 0xE9, + 0xD1, 0x77, 0xC2, 0x34, 0xCB, 0xD4, 0x36, 0xCD, + 0x90, 0xAB, 0xC2, 0xDD, 0x67, 0x51, 0xA6, 0xAE + }, + { + 0xCC, 0x2C, 0x88, 0x57, 0xFE, 0xAC, 0x2F, 0xE8, + 0x02, 0xED, 0x4E, 0xB3, 0x89, 0xC5, 0x01, 0x33, + 0xEB, 0x33, 0x91, 0x92, 0x9E, 0xA5, 0xC6, 0x60, + 0x49, 0x10, 0xA9, 0x09, 0xCB, 0x3E, 0x7D, 0x0C + }, + { + 0x63, 0xAB, 0x49, 0x3D, 0x2C, 0xFD, 0x46, 0x70, + 0x43, 0x36, 0x1C, 0x44, 0xC1, 0x5E, 0x34, 0x85, + 0x86, 0xCA, 0x6F, 0xB9, 0x55, 0x21, 0x33, 0x5B, + 0xAA, 0x50, 0x34, 0x97, 0xA9, 0x3F, 0xFA, 0x57 + }, + { + 0xB8, 0x73, 0x2C, 0xA4, 0x8B, 0xBB, 0x36, 0x39, + 0x6E, 0x07, 0x29, 0xE0, 0x63, 0x1A, 0x00, 0x82, + 0xE1, 0x46, 0x04, 0xD8, 0x57, 0x36, 0x59, 0x35, + 0xD2, 0x20, 0xDF, 0xFB, 0x57, 0xE8, 0xA1, 0xE1 + }, + { + 0xE8, 0xA7, 0x13, 0x3D, 0xFB, 0x90, 0xEF, 0xA4, + 0x06, 0x27, 0xC8, 0x45, 0x29, 0x1C, 0xC0, 0x2D, + 0xE2, 0x12, 0x49, 0x57, 0xD6, 0x3D, 0x1A, 0x4F, + 0xC6, 0xF5, 0x36, 0x6E, 0x94, 0xFA, 0x28, 0x5A + }, + { + 0xC1, 0x03, 0x45, 0x52, 0x61, 0x22, 0xF8, 0x88, + 0x96, 0xD3, 0xA2, 0x5F, 0x57, 0x50, 0xA5, 0x16, + 0x13, 0xD4, 0x3C, 0xF2, 0xB5, 0xB7, 0x98, 0xD1, + 0xB6, 0xF7, 0xCF, 0x38, 0x0C, 0xB7, 0xD2, 0x46 + }, + { + 0x94, 0x4A, 0x83, 0xF6, 0x61, 0x34, 0xD5, 0x77, + 0xAC, 0x3C, 0xE7, 0x5D, 0x2C, 0x0E, 0x78, 0x9F, + 0x30, 0x94, 0x7B, 0x39, 0x01, 0xF9, 0x5F, 0x5F, + 0x7C, 0x42, 0xE9, 0xB1, 0x53, 0xE8, 0xF5, 0x89 + }, + { + 0xC5, 0x86, 0xD1, 0x56, 0x3C, 0xD6, 0x76, 0x78, + 0x8A, 0x8A, 0xAA, 0x95, 0xBD, 0xD2, 0x87, 0x34, + 0x1D, 0x92, 0x46, 0xFE, 0x2C, 0xF1, 0xFA, 0xDC, + 0x23, 0xD4, 0x51, 0x30, 0xCB, 0x87, 0xD1, 0x1D + }, + { + 0xA6, 0xEB, 0xF2, 0xB4, 0x57, 0xD5, 0x6D, 0xD2, + 0x8D, 0xD4, 0x34, 0x74, 0x15, 0x91, 0x3A, 0xC8, + 0xEE, 0x77, 0xE3, 0xA1, 0x1D, 0x06, 0x1E, 0x2B, + 0xB7, 0x4C, 0x62, 0x39, 0x88, 0xBF, 0x3D, 0xD5 + }, + { + 0xCE, 0x39, 0xCA, 0xE2, 0x5F, 0x54, 0x99, 0x4F, + 0x2F, 0xB5, 0x40, 0x62, 0x9E, 0xC7, 0x3C, 0xF0, + 0xFC, 0xB2, 0x24, 0xCE, 0x00, 0x14, 0x53, 0x3A, + 0x17, 0xEC, 0xFB, 0xA6, 0xA1, 0xB4, 0x74, 0x99 + }, + { + 0x61, 0x87, 0xCF, 0xF1, 0x2C, 0x79, 0x9C, 0x51, + 0xE0, 0xC7, 0xA1, 0x4F, 0x28, 0x0B, 0x8A, 0x72, + 0xDA, 0xA5, 0x57, 0x91, 0x00, 0x2A, 0x45, 0xC5, + 0x91, 0x32, 0xB8, 0x44, 0x38, 0x81, 0xB1, 0xE9 + }, + { + 0x6E, 0xB4, 0x81, 0x9E, 0x26, 0x37, 0xF5, 0x7B, + 0xAF, 0xAD, 0x03, 0x31, 0x2C, 0xFA, 0xC6, 0xBF, + 0x80, 0xA6, 0xE7, 0x59, 0x40, 0x4F, 0x11, 0x9B, + 0xB0, 0x78, 0x73, 0x90, 0xBF, 0x17, 0x65, 0x29 + }, + { + 0xD0, 0x4B, 0xC6, 0x46, 0xBE, 0xE7, 0xE5, 0x9A, + 0x7A, 0xF9, 0x88, 0xE7, 0x62, 0x8A, 0x1F, 0xA6, + 0x25, 0xCF, 0x5A, 0xA5, 0x21, 0x6F, 0x66, 0xD7, + 0x8E, 0x33, 0x85, 0x71, 0x78, 0x74, 0xD1, 0xBF + }, + { + 0xEF, 0x36, 0x8A, 0xD2, 0x05, 0x86, 0x9B, 0x84, + 0x6F, 0xD7, 0xE9, 0xB3, 0xC6, 0xD8, 0x04, 0x9C, + 0x99, 0xF1, 0x9E, 0x7E, 0x34, 0xA5, 0xD8, 0xCF, + 0x50, 0x48, 0xFA, 0xA9, 0x77, 0x8D, 0x7D, 0x3D + }, + { + 0x95, 0xAC, 0x86, 0x75, 0x0B, 0x3E, 0x13, 0x9F, + 0x00, 0x44, 0xA0, 0xF9, 0xCF, 0x51, 0xD8, 0x78, + 0x21, 0x92, 0x77, 0xD2, 0xDF, 0x14, 0x37, 0xDA, + 0x21, 0x8C, 0x48, 0x60, 0x56, 0xEA, 0x5B, 0x9A + }, + { + 0x49, 0xBA, 0x0B, 0x83, 0x6B, 0x78, 0x86, 0xEC, + 0x00, 0x6C, 0x25, 0xCA, 0xFD, 0xB3, 0x97, 0xCE, + 0xEF, 0xAD, 0x3B, 0x96, 0x5E, 0x32, 0xC8, 0xB1, + 0x13, 0x63, 0x20, 0x21, 0x87, 0xC2, 0xE5, 0x7B + }, + { + 0x7F, 0x82, 0x83, 0x3B, 0x46, 0xB6, 0xD9, 0xC2, + 0x12, 0xC3, 0x80, 0x1E, 0xBC, 0x1C, 0x5D, 0xA7, + 0xF8, 0x3B, 0x0E, 0x5C, 0x57, 0x02, 0xB9, 0xD4, + 0x94, 0xC4, 0x05, 0xCC, 0xD8, 0xDE, 0x47, 0xD5 + }, + { + 0xD3, 0xA7, 0xBF, 0x9F, 0x60, 0xBA, 0xB1, 0xE9, + 0x3D, 0x7C, 0xB3, 0x83, 0x7E, 0xF3, 0x23, 0xEC, + 0xE4, 0x34, 0x46, 0x52, 0xC0, 0xC7, 0x6A, 0xB0, + 0x61, 0x67, 0xE0, 0xCC, 0x79, 0x4A, 0x69, 0x30 + }, + { + 0x93, 0xD2, 0x9B, 0xE8, 0xC7, 0xBE, 0xDF, 0x5F, + 0x46, 0x63, 0x80, 0x2A, 0x00, 0x02, 0x88, 0x61, + 0x5F, 0xD0, 0x3E, 0x54, 0x8A, 0x08, 0x7C, 0xC2, + 0xEA, 0xDE, 0x12, 0x52, 0x74, 0xB6, 0xDA, 0xA5 + }, + { + 0x4B, 0x9E, 0xBB, 0xAA, 0x0F, 0x04, 0x71, 0x2E, + 0x5A, 0xF5, 0x72, 0xCF, 0x2C, 0x72, 0xFF, 0x8C, + 0xF9, 0x27, 0x4B, 0xC4, 0x30, 0x98, 0x09, 0x8C, + 0x11, 0xD8, 0xEB, 0x43, 0xFD, 0x6B, 0x4C, 0x23 + }, + { + 0x03, 0x48, 0xAE, 0xFB, 0x53, 0x93, 0xCC, 0x47, + 0x5F, 0x41, 0x90, 0x68, 0x66, 0xF3, 0xDC, 0x6F, + 0x2E, 0xF4, 0xDF, 0x3D, 0xA7, 0x77, 0x04, 0x74, + 0xF3, 0xAD, 0x6F, 0xDD, 0x5A, 0xF0, 0xC3, 0x17 + }, + { + 0x9C, 0xA4, 0xE1, 0x8A, 0xF6, 0x7A, 0x0C, 0x1C, + 0x8F, 0x52, 0xE2, 0x58, 0xA0, 0x64, 0x1B, 0x94, + 0xA6, 0x84, 0x47, 0xDC, 0x35, 0x55, 0x1D, 0x64, + 0x1E, 0x47, 0xC6, 0x08, 0xF1, 0x85, 0xFC, 0x3C + }, + { + 0x4F, 0xB9, 0x3A, 0x80, 0xB9, 0x29, 0x0B, 0xE2, + 0xD4, 0x16, 0xB1, 0xFA, 0xAF, 0xB7, 0x09, 0xE9, + 0x5C, 0x89, 0xF7, 0x4B, 0x92, 0x61, 0xE9, 0x72, + 0x74, 0xBF, 0x84, 0x41, 0xD4, 0xD3, 0x56, 0xAA + }, + { + 0xE9, 0xE9, 0x42, 0x31, 0x26, 0xAF, 0x7F, 0x5C, + 0x3C, 0x32, 0xB3, 0x16, 0xBA, 0xAB, 0xEC, 0x08, + 0x97, 0xA9, 0x7E, 0xDE, 0x4B, 0x32, 0x43, 0xFA, + 0xE0, 0xC0, 0xCC, 0x03, 0x08, 0x87, 0xA4, 0x67 + }, + { + 0xD2, 0x23, 0x57, 0x48, 0x08, 0x18, 0x57, 0x61, + 0x56, 0xB0, 0x22, 0xAC, 0xB7, 0x6C, 0xE9, 0x0A, + 0xF4, 0xB1, 0x05, 0xE6, 0xCC, 0xED, 0x8C, 0xB8, + 0x37, 0x1B, 0x4C, 0xB7, 0x56, 0x8F, 0x43, 0xE6 + }, + { + 0x08, 0x42, 0xF0, 0x3E, 0x27, 0xBB, 0x9D, 0xE2, + 0xB7, 0x71, 0x8D, 0x70, 0x1C, 0xC3, 0xA1, 0x1B, + 0xCF, 0x5F, 0xD6, 0x1B, 0xFC, 0x6D, 0x7B, 0x8F, + 0x03, 0x75, 0xB2, 0xCB, 0x53, 0x80, 0xF6, 0x2A + }, + { + 0x67, 0xF7, 0x34, 0x8F, 0xD2, 0xF2, 0x57, 0xDA, + 0x29, 0x10, 0xEB, 0xBD, 0x79, 0x48, 0x31, 0x1C, + 0xF6, 0xC0, 0xAD, 0x9F, 0x6F, 0xA0, 0xD3, 0xFB, + 0xC8, 0x73, 0x49, 0x2E, 0xBC, 0x33, 0x3F, 0x3E + }, + { + 0xBA, 0x67, 0x06, 0x58, 0x01, 0x0C, 0x33, 0x76, + 0xF5, 0xF6, 0xBF, 0x38, 0x9B, 0x4B, 0x8D, 0x2D, + 0x29, 0x79, 0x50, 0x87, 0x21, 0x6D, 0x88, 0xF3, + 0x9F, 0xC5, 0xCF, 0x16, 0x9A, 0x57, 0x3B, 0x83 + }, + { + 0x8C, 0x19, 0x40, 0xF3, 0x86, 0xCB, 0x35, 0xDB, + 0x21, 0x73, 0x9F, 0x01, 0xCE, 0x98, 0x8E, 0x75, + 0x2D, 0x50, 0x84, 0x2A, 0xE7, 0xF7, 0x29, 0xA3, + 0xF3, 0xC6, 0x74, 0x1B, 0x40, 0xA7, 0x73, 0x74 + }, + { + 0xE8, 0xA8, 0xAC, 0xBB, 0x92, 0x17, 0x5A, 0x2F, + 0x5B, 0x7D, 0xD0, 0x3B, 0x9D, 0xAC, 0x22, 0x56, + 0xB6, 0x9A, 0x7D, 0xFB, 0xF2, 0x75, 0xEE, 0xD9, + 0x64, 0xF8, 0xB7, 0xDF, 0xD8, 0x99, 0x35, 0x5E + }, + { + 0x17, 0x55, 0xD8, 0xE0, 0x01, 0xDB, 0xD5, 0x22, + 0xFE, 0xC9, 0x55, 0x3E, 0xBF, 0xEE, 0x52, 0xD5, + 0xB7, 0xC8, 0xE4, 0x46, 0x48, 0x84, 0x29, 0xCF, + 0xA4, 0xFA, 0x7F, 0xB1, 0x4A, 0xB3, 0x2B, 0x79 + }, + { + 0xB2, 0xB4, 0x47, 0x9B, 0xDD, 0x51, 0x00, 0xB4, + 0xBD, 0xFC, 0xFF, 0x3A, 0xD3, 0x19, 0x17, 0x6B, + 0xAD, 0x00, 0x86, 0x22, 0x7F, 0x8D, 0xA0, 0x0C, + 0xDD, 0x7F, 0x4E, 0xAC, 0x9A, 0x00, 0xE9, 0x58 + }, + { + 0xA9, 0x58, 0x0B, 0xFE, 0x40, 0xE4, 0xA0, 0xC2, + 0xA0, 0xEB, 0x5F, 0x54, 0xB5, 0x8D, 0x15, 0x13, + 0x1C, 0x03, 0x14, 0x2E, 0x44, 0xA8, 0x00, 0x23, + 0x06, 0xB7, 0x77, 0x79, 0x8F, 0x3A, 0x79, 0x5C + }, + { + 0x28, 0x11, 0xE1, 0x84, 0x21, 0x5B, 0x59, 0x7F, + 0xFB, 0x6A, 0x65, 0x6C, 0xF0, 0xFF, 0xD6, 0xBE, + 0x71, 0xE6, 0xF8, 0xA3, 0x0F, 0x12, 0xC7, 0x33, + 0x8C, 0x34, 0x29, 0x21, 0xED, 0x7F, 0x61, 0xCB + }, + { + 0x86, 0x32, 0x8D, 0xE0, 0xC9, 0xEB, 0xFB, 0x1B, + 0x84, 0x47, 0x52, 0x85, 0x82, 0xAD, 0x8B, 0xA3, + 0x9A, 0x01, 0x3C, 0x61, 0xD2, 0xD6, 0x11, 0xFB, + 0x36, 0x4C, 0x71, 0xD9, 0x10, 0x9C, 0xAF, 0x0A + }, + { + 0xF4, 0x12, 0x1F, 0xD5, 0x5A, 0x36, 0x57, 0x3E, + 0x69, 0xD7, 0xFB, 0x0E, 0x5D, 0x29, 0x11, 0x42, + 0x0D, 0xDD, 0xFF, 0xCA, 0xC2, 0xE0, 0x6B, 0xA0, + 0xD6, 0x08, 0x01, 0xE9, 0x5C, 0x62, 0x89, 0xBF + }, + { + 0x60, 0x43, 0xD4, 0x29, 0x50, 0x15, 0xEE, 0xAA, + 0xB0, 0x69, 0x4A, 0xFE, 0xF5, 0x4F, 0xB7, 0xE8, + 0x68, 0x13, 0x49, 0xBB, 0x74, 0x20, 0x4B, 0x8F, + 0xD8, 0x29, 0x41, 0x27, 0xCC, 0x80, 0x2F, 0x34 + }, + { + 0xAB, 0x85, 0x08, 0x3F, 0xB1, 0xA1, 0x88, 0x2E, + 0x2E, 0xB3, 0x6C, 0x15, 0xB7, 0xC6, 0x3A, 0xB0, + 0x0B, 0xB2, 0x0C, 0x4E, 0x39, 0x4A, 0x3B, 0x2C, + 0xF4, 0x12, 0xC9, 0x5C, 0xDF, 0xA0, 0xC9, 0x3B + }, + { + 0xFD, 0xD6, 0x9E, 0x64, 0x72, 0xFF, 0x28, 0xE6, + 0x30, 0x91, 0x7F, 0xFC, 0x74, 0x85, 0x06, 0x64, + 0x06, 0x76, 0x98, 0x62, 0xC0, 0xDA, 0xC0, 0x53, + 0x77, 0xDF, 0x26, 0x02, 0x1E, 0xCF, 0xB9, 0xE2 + }, + { + 0xBF, 0x40, 0xF5, 0xB0, 0x4E, 0x11, 0xD4, 0x96, + 0xF2, 0x73, 0x42, 0x3B, 0xD0, 0x14, 0xA5, 0x6D, + 0xAA, 0x26, 0x06, 0xA0, 0xDD, 0x19, 0x23, 0x80, + 0x7D, 0xAF, 0xF1, 0x3B, 0x7A, 0x45, 0x98, 0x5D + }, + { + 0x31, 0x80, 0xFB, 0x66, 0x8C, 0x8D, 0x22, 0x5F, + 0x8F, 0x62, 0x62, 0x66, 0x99, 0xAF, 0x12, 0x58, + 0x00, 0x5C, 0x72, 0x93, 0xD6, 0xE7, 0xB2, 0xC6, + 0xAC, 0x1C, 0x39, 0x32, 0xC5, 0x56, 0x78, 0x99 + }, + { + 0x33, 0x81, 0x63, 0xCB, 0x4A, 0x84, 0xBE, 0x6D, + 0xDB, 0x55, 0xCA, 0xB8, 0xB9, 0xF4, 0xA6, 0xD5, + 0x89, 0x26, 0xA3, 0xC4, 0xCA, 0x9F, 0x9F, 0x24, + 0x52, 0xC1, 0x02, 0xA9, 0xFC, 0xAB, 0xD3, 0x34 + }, + { + 0xF5, 0x44, 0xE0, 0x58, 0x71, 0x7C, 0xB6, 0xDF, + 0xFC, 0x1E, 0xAA, 0xF6, 0x72, 0xD0, 0xD6, 0x55, + 0x36, 0x39, 0xEA, 0x3A, 0x4D, 0xDB, 0x47, 0xD9, + 0xD8, 0x2F, 0x7D, 0x15, 0x95, 0xC1, 0xA7, 0x9E + }, + { + 0xC6, 0xC5, 0x82, 0xBC, 0x99, 0x05, 0xEA, 0x1A, + 0xB9, 0x62, 0x63, 0x62, 0xE5, 0x7A, 0xE5, 0xA7, + 0x94, 0x5B, 0xDF, 0x2F, 0x80, 0x04, 0xC0, 0x55, + 0x31, 0xEF, 0x92, 0x70, 0x33, 0xDB, 0x8F, 0x12 + }, + { + 0xE5, 0xD0, 0xD4, 0x22, 0x43, 0x1E, 0xA7, 0xF6, + 0x21, 0xAF, 0x3E, 0x90, 0x50, 0x31, 0x83, 0x27, + 0xB0, 0xB3, 0x12, 0x51, 0x5F, 0xC2, 0xB2, 0x98, + 0x76, 0xE2, 0x17, 0x85, 0xF3, 0x9C, 0x81, 0x8B + }, + { + 0x62, 0xD0, 0x06, 0x53, 0x5E, 0x21, 0x67, 0x4F, + 0xC8, 0xC7, 0x03, 0x46, 0x16, 0x75, 0x45, 0x4A, + 0xF8, 0x40, 0x19, 0x2B, 0x28, 0x8B, 0xF4, 0x73, + 0xDE, 0x4B, 0x8E, 0x18, 0xEF, 0xCE, 0x8B, 0x0A + }, + { + 0x99, 0xA8, 0x4B, 0xA4, 0xDD, 0x80, 0xBE, 0x40, + 0xA6, 0xE4, 0x44, 0x7F, 0x4D, 0xD6, 0x60, 0x3B, + 0xE6, 0x21, 0xBC, 0x11, 0x7D, 0xA4, 0x45, 0x65, + 0x61, 0xAF, 0x6E, 0x2C, 0x70, 0xC3, 0x0F, 0x60 + }, + { + 0x25, 0xF3, 0x02, 0xB6, 0xDA, 0xE4, 0x03, 0x22, + 0xDE, 0x3A, 0xF1, 0xFE, 0x45, 0xE9, 0xFE, 0x73, + 0x96, 0x14, 0xF6, 0xA8, 0x0D, 0x59, 0xB7, 0xBC, + 0x2A, 0xB3, 0x2F, 0x1B, 0x16, 0x76, 0xF3, 0x96 + }, + { + 0x63, 0xA7, 0xCD, 0xE7, 0x09, 0x69, 0x79, 0xB0, + 0xAB, 0x2F, 0x90, 0x43, 0xAE, 0x35, 0x24, 0x22, + 0xA9, 0x3E, 0x77, 0x44, 0x9F, 0x46, 0x4B, 0xAE, + 0x1C, 0x25, 0xD9, 0x71, 0x8B, 0x2B, 0x37, 0x9F + }, + { + 0xB4, 0x19, 0x74, 0x10, 0x34, 0x32, 0xC5, 0x40, + 0xBE, 0xFC, 0x7E, 0xFC, 0xF5, 0xE6, 0x26, 0xA3, + 0xF8, 0x1A, 0x12, 0x36, 0x48, 0x3F, 0x55, 0xC2, + 0x7E, 0x70, 0xEA, 0x2D, 0xEF, 0xEE, 0x88, 0xA8 + }, + { + 0x03, 0x37, 0x16, 0x2C, 0xFE, 0xA5, 0x49, 0x50, + 0x02, 0x38, 0x1B, 0xF0, 0x19, 0x74, 0xBC, 0x74, + 0x62, 0xAE, 0xEB, 0x64, 0xA7, 0xCC, 0xF6, 0x0F, + 0x9A, 0xA8, 0x40, 0x33, 0xB1, 0x54, 0x3B, 0x19 + }, + { + 0x69, 0xE4, 0xAF, 0xD6, 0x4A, 0x48, 0xA2, 0x87, + 0x7B, 0xA0, 0x79, 0x58, 0x8B, 0x4D, 0x43, 0x1E, + 0x40, 0x18, 0x64, 0x66, 0x50, 0xF5, 0x33, 0xE5, + 0xE4, 0xED, 0x79, 0xEB, 0xD0, 0x4D, 0x99, 0xB6 + }, + { + 0x3E, 0x38, 0x0E, 0x5D, 0xAB, 0x3F, 0xD7, 0xAA, + 0x82, 0x3D, 0xEA, 0x52, 0xCB, 0x94, 0x17, 0xC8, + 0x02, 0x5E, 0xCB, 0xA5, 0x63, 0xBA, 0xA7, 0x79, + 0x64, 0x8D, 0xBB, 0x7F, 0xE8, 0xB5, 0x88, 0xAE + }, + { + 0x8A, 0x0A, 0x63, 0xF3, 0xE2, 0x70, 0xED, 0x38, + 0x9C, 0x42, 0xF8, 0xFF, 0x60, 0x88, 0xFE, 0x29, + 0x9D, 0xD2, 0xA7, 0x9C, 0x61, 0xCF, 0x41, 0xE8, + 0xD4, 0xC1, 0xCD, 0xAC, 0x01, 0xAA, 0x0E, 0xD5 + }, + { + 0xB6, 0xE2, 0x2D, 0xB9, 0x61, 0x71, 0x9D, 0x11, + 0x81, 0xE1, 0x16, 0x69, 0x3F, 0x24, 0x71, 0xB1, + 0x84, 0x7C, 0xB3, 0x59, 0xB7, 0xE9, 0xDA, 0xBA, + 0x83, 0x3C, 0x67, 0x52, 0xCF, 0x1A, 0xAD, 0x95 + }, + { + 0x4F, 0x3F, 0x2C, 0x1D, 0x34, 0xE6, 0x34, 0x78, + 0x75, 0xB8, 0x0F, 0xB2, 0x81, 0xCE, 0x7D, 0x66, + 0x8B, 0x6A, 0x7E, 0xFA, 0xEB, 0xB7, 0x05, 0xE5, + 0x90, 0x6C, 0xED, 0x5D, 0x05, 0xE8, 0x10, 0xF1 + }, + { + 0x9C, 0xC9, 0xFD, 0x83, 0x12, 0x87, 0xA6, 0x6B, + 0x31, 0x1D, 0x8C, 0x14, 0x87, 0x9D, 0xAB, 0xFE, + 0xF1, 0xAA, 0xC0, 0xD2, 0x37, 0xA7, 0x7B, 0x4D, + 0xE7, 0xD3, 0xA6, 0x9F, 0x51, 0xB5, 0xA0, 0x85 + }, + { + 0x9D, 0x9E, 0xF3, 0x34, 0x09, 0xDA, 0x49, 0xE3, + 0xEB, 0xA1, 0xD6, 0x28, 0xFF, 0x6E, 0x51, 0x66, + 0xCF, 0xD5, 0xB9, 0x5C, 0xBC, 0xE3, 0x13, 0xA4, + 0xD5, 0xF1, 0x16, 0x00, 0xC5, 0x44, 0xC4, 0x35 + }, + { + 0xD1, 0xFD, 0x87, 0xBF, 0x45, 0x86, 0xA6, 0x1F, + 0x16, 0x73, 0x0B, 0x77, 0x64, 0xEC, 0x96, 0x52, + 0xEF, 0xF2, 0xF1, 0x17, 0xFA, 0x9D, 0x31, 0x9B, + 0x2F, 0x90, 0x71, 0x4C, 0x90, 0xAD, 0x95, 0x85 + }, + { + 0xCA, 0xC5, 0xB6, 0x72, 0xDB, 0xBE, 0x37, 0x30, + 0xD5, 0xFB, 0x73, 0x9C, 0xD6, 0xE8, 0x0B, 0x84, + 0x04, 0x58, 0x98, 0xED, 0xB2, 0xA3, 0x80, 0xDA, + 0xC1, 0x08, 0x42, 0x48, 0x7D, 0x4F, 0x66, 0x86 + }, + { + 0x79, 0x14, 0x43, 0x7A, 0xC2, 0xA7, 0x1F, 0xD2, + 0x0A, 0x66, 0x0C, 0xA4, 0xDA, 0x1D, 0x8E, 0x42, + 0x09, 0xDD, 0xE6, 0x5D, 0x55, 0x6B, 0xED, 0x52, + 0xCD, 0x6F, 0xBC, 0xB3, 0xB4, 0x18, 0x34, 0x2E + }, + { + 0xEC, 0x50, 0x96, 0xF7, 0xB7, 0x6F, 0x84, 0x8D, + 0x42, 0xCF, 0x3D, 0x08, 0x0F, 0x4E, 0xBC, 0x6F, + 0x6D, 0xD2, 0x4A, 0x3F, 0x94, 0xA4, 0xB8, 0xFF, + 0x7B, 0xF9, 0x4C, 0x81, 0x55, 0x47, 0xB3, 0x0C + }, + { + 0x2F, 0x8E, 0x84, 0x63, 0x07, 0x43, 0x26, 0x1F, + 0x3B, 0xE5, 0xAA, 0xC6, 0x59, 0xD9, 0x5B, 0x07, + 0xF4, 0xAA, 0x50, 0xEE, 0x02, 0xA5, 0xA2, 0x78, + 0x3A, 0xDA, 0x4A, 0xF9, 0x54, 0xA8, 0x27, 0xDF + }, + { + 0x82, 0xB2, 0x7F, 0x83, 0x09, 0x6E, 0x07, 0x05, + 0xE8, 0xEF, 0x75, 0x53, 0x99, 0xB5, 0xB1, 0x08, + 0x52, 0x08, 0xDB, 0xAD, 0x8A, 0x6A, 0x76, 0x7B, + 0xC3, 0xBA, 0x97, 0x34, 0x5E, 0xEB, 0xA1, 0x67 + }, + { + 0x75, 0xC5, 0xAE, 0xC7, 0x2F, 0xA4, 0xBF, 0x06, + 0xB1, 0xF4, 0xD2, 0x7C, 0xAE, 0x6C, 0xD2, 0x8C, + 0x6D, 0xC6, 0x62, 0xC2, 0xF3, 0xD5, 0x9E, 0x04, + 0xEA, 0x12, 0x66, 0x56, 0xF1, 0x64, 0x1F, 0x59 + }, + { + 0xBF, 0x37, 0x1A, 0x84, 0x2F, 0x2A, 0x9B, 0x6F, + 0xBB, 0xCE, 0x68, 0x39, 0x5A, 0x6F, 0x78, 0x58, + 0xF1, 0x51, 0x71, 0xFA, 0xE8, 0xB5, 0x8D, 0x02, + 0x92, 0x77, 0xEF, 0xE7, 0x48, 0x45, 0x3C, 0x87 + }, + { + 0x59, 0xC8, 0xA8, 0x91, 0x6A, 0x31, 0x4C, 0xF6, + 0xEB, 0x1B, 0x35, 0xA2, 0xD5, 0x50, 0x39, 0xB4, + 0xE8, 0x47, 0x9B, 0x52, 0xD5, 0xE8, 0x74, 0x43, + 0x05, 0x7F, 0x9A, 0x8E, 0xE0, 0x2C, 0xEA, 0x0A + }, + { + 0x51, 0xDA, 0x4F, 0x6D, 0xB8, 0xB7, 0x76, 0xDC, + 0x0B, 0x1A, 0x74, 0xF8, 0x41, 0x76, 0xC7, 0xA3, + 0xF0, 0x60, 0x65, 0x89, 0x61, 0x56, 0x72, 0xE5, + 0x07, 0xB9, 0xA3, 0x7C, 0x5D, 0x55, 0xF4, 0x17 + }, + { + 0xDC, 0x33, 0x19, 0x17, 0xB4, 0xDE, 0x03, 0x3A, + 0xE1, 0x91, 0xB3, 0x26, 0xF7, 0x8B, 0x9B, 0xFA, + 0x51, 0x00, 0x71, 0x5E, 0x5B, 0x90, 0x99, 0xC5, + 0x96, 0x68, 0x02, 0xCB, 0x38, 0x3D, 0x45, 0x3B + }, + { + 0x95, 0x0E, 0xFF, 0x7C, 0x84, 0x22, 0x3C, 0xD8, + 0x32, 0xCA, 0x5D, 0xD2, 0x2C, 0x03, 0xB6, 0x4C, + 0x89, 0x0C, 0x90, 0x4C, 0xF3, 0xAF, 0xD7, 0x48, + 0x78, 0x2F, 0x64, 0x2A, 0x5D, 0x97, 0xF1, 0x7F + }, + { + 0x45, 0x2E, 0xE1, 0x9B, 0x1B, 0x20, 0x30, 0xA8, + 0x41, 0x06, 0x78, 0xA4, 0x0F, 0xC2, 0xB2, 0x94, + 0x71, 0x9D, 0x72, 0x99, 0xBE, 0x87, 0xEB, 0xAB, + 0xE6, 0xB4, 0x64, 0x67, 0xDC, 0x56, 0x89, 0x6A + }, + { + 0xEE, 0xFE, 0x60, 0xB2, 0xC5, 0x58, 0x35, 0xF4, + 0xC3, 0xA4, 0x91, 0xF1, 0x0F, 0xAE, 0xD7, 0xE7, + 0x78, 0x18, 0xA1, 0x4B, 0xD9, 0xAA, 0xEA, 0x44, + 0xFB, 0x2C, 0x85, 0x0C, 0xCA, 0x70, 0x14, 0xBE + }, + { + 0x3F, 0x1F, 0x8E, 0xAC, 0x0C, 0x84, 0x1D, 0xE1, + 0xEE, 0x67, 0x08, 0x67, 0x40, 0xCA, 0x64, 0x24, + 0x0F, 0x1B, 0xCC, 0xA7, 0xD4, 0xCC, 0x2E, 0x55, + 0x25, 0xB2, 0xA6, 0xCD, 0x2D, 0xE2, 0x97, 0xC1 + }, + { + 0x9B, 0xF0, 0xFD, 0x8C, 0x25, 0x4B, 0x2B, 0xA8, + 0xE4, 0x34, 0xB6, 0x4A, 0x36, 0x86, 0x8D, 0x7B, + 0x24, 0x8E, 0xD5, 0x55, 0xFD, 0xEC, 0x8C, 0xE7, + 0x27, 0xD4, 0x05, 0xCA, 0x50, 0xCD, 0x51, 0x6C + }, + { + 0xBF, 0x54, 0x97, 0x3A, 0x03, 0x11, 0x47, 0x3B, + 0x4F, 0x4A, 0x69, 0xF2, 0x6E, 0xEC, 0xE8, 0xE9, + 0xC1, 0xC0, 0x39, 0x1B, 0x5E, 0xEC, 0xB6, 0xAA, + 0x68, 0x24, 0x8D, 0xC9, 0x5E, 0xA6, 0xD7, 0x7E + }, + { + 0x88, 0x05, 0x92, 0xF2, 0xB1, 0x5A, 0x04, 0x6E, + 0x5C, 0xC2, 0x4C, 0xA1, 0x6B, 0x2E, 0xF2, 0x87, + 0xD0, 0x85, 0xE3, 0xCA, 0x20, 0x07, 0xE2, 0xC9, + 0xE3, 0xD5, 0xE5, 0x64, 0xD6, 0x2E, 0xE8, 0xE9 + }, + { + 0x9B, 0xB0, 0x69, 0x84, 0x4C, 0x91, 0x5F, 0x96, + 0x18, 0x63, 0x37, 0x36, 0x3A, 0x62, 0xEA, 0x7E, + 0x4E, 0x82, 0x53, 0x9E, 0xD8, 0xA1, 0x7D, 0x46, + 0x07, 0x23, 0xA7, 0xE4, 0x5E, 0x32, 0x33, 0xA4 + }, + { + 0x23, 0xB2, 0xF3, 0xF5, 0x5B, 0x51, 0xD6, 0x81, + 0x49, 0x99, 0xC2, 0x2A, 0xDA, 0xD7, 0xDB, 0x59, + 0xCB, 0x20, 0xB3, 0xD3, 0xF0, 0x07, 0x24, 0xE3, + 0x98, 0xBE, 0xC3, 0xA4, 0x57, 0x87, 0x8B, 0x04 + }, + { + 0x22, 0xAA, 0x87, 0x0A, 0xA1, 0xAB, 0x44, 0x29, + 0x22, 0xF8, 0x47, 0xD7, 0xB6, 0x60, 0x18, 0xAD, + 0x32, 0x53, 0xCB, 0xA3, 0x6A, 0xC7, 0x04, 0x0C, + 0xED, 0xC2, 0x5C, 0x55, 0x86, 0x69, 0x9B, 0x63 + }, + { + 0x80, 0xDD, 0x65, 0x95, 0x95, 0x3D, 0x03, 0xF2, + 0xF3, 0xD3, 0x91, 0x90, 0x54, 0xB2, 0x8C, 0x22, + 0x35, 0xF5, 0xE0, 0xFC, 0x12, 0xE1, 0xA0, 0x1E, + 0x07, 0x15, 0xA4, 0x9A, 0x20, 0x9C, 0xB5, 0x2D + }, + { + 0x39, 0x59, 0x09, 0x43, 0xA8, 0x98, 0x85, 0x19, + 0x7C, 0xBC, 0x24, 0xCB, 0x74, 0x2A, 0x5D, 0xD2, + 0xD1, 0xDA, 0xD8, 0x5A, 0x8B, 0x40, 0x2D, 0xAA, + 0x0D, 0x7C, 0x27, 0xA9, 0xEC, 0x1A, 0x5C, 0x0B + }, + { + 0x06, 0x63, 0x51, 0x99, 0x1A, 0xEC, 0x82, 0x11, + 0x62, 0x5E, 0xC6, 0x6D, 0x07, 0xC7, 0xC8, 0x5C, + 0xB9, 0x63, 0x53, 0x36, 0xF7, 0x78, 0x08, 0xF1, + 0xC0, 0x39, 0xC1, 0xFF, 0x36, 0xAF, 0x4B, 0x00 + }, + { + 0xFF, 0x3C, 0x41, 0xF0, 0x72, 0x3F, 0x6D, 0x91, + 0xF2, 0x19, 0x1B, 0x44, 0x8E, 0x4D, 0x34, 0xFB, + 0x05, 0xD1, 0x92, 0xDD, 0x23, 0xE4, 0xB7, 0x1F, + 0xFE, 0x0C, 0x30, 0xD9, 0x14, 0x32, 0xA2, 0xCA + }, + { + 0x05, 0xE8, 0x64, 0x23, 0x89, 0xEE, 0xA7, 0x0D, + 0xB6, 0xD0, 0xAF, 0x15, 0x34, 0x83, 0x92, 0xD1, + 0xDB, 0x62, 0x4B, 0xE6, 0x07, 0xAE, 0x25, 0xA0, + 0x88, 0x30, 0x78, 0xDB, 0x96, 0x1E, 0xDC, 0xDB + }, + { + 0xDF, 0x1C, 0x74, 0x77, 0x6A, 0x61, 0xA4, 0xBA, + 0xAB, 0x91, 0x50, 0xB7, 0x5E, 0xDF, 0x2E, 0xB9, + 0x8A, 0xC7, 0x0E, 0x23, 0x8B, 0xC9, 0xD8, 0x94, + 0xB7, 0x34, 0x4B, 0x51, 0x11, 0xBA, 0xBF, 0x67 + }, + { + 0xBB, 0x13, 0x82, 0x9E, 0x5A, 0x29, 0xF1, 0xBC, + 0x4C, 0x45, 0xAC, 0xCF, 0x4E, 0xBE, 0xB0, 0xFA, + 0xE8, 0x8D, 0x71, 0xFA, 0x66, 0x41, 0x5B, 0xA1, + 0xAC, 0x3C, 0x9B, 0x3D, 0xB0, 0x55, 0x69, 0x74 + }, + { + 0xD6, 0xCF, 0x56, 0x18, 0xF0, 0x0B, 0x09, 0xBA, + 0x97, 0x79, 0x68, 0xCC, 0x87, 0x8A, 0x14, 0xC5, + 0xC7, 0xFF, 0x9D, 0x9A, 0x44, 0xE8, 0x69, 0x93, + 0x09, 0x3F, 0x81, 0x16, 0xFF, 0xBC, 0xD2, 0xFD + }, + { + 0x79, 0x6C, 0x53, 0x3B, 0x7F, 0x56, 0x4E, 0x17, + 0xE2, 0x6F, 0x69, 0xD7, 0x12, 0xD0, 0x8A, 0x2D, + 0x0F, 0xCE, 0x37, 0xA4, 0x53, 0x95, 0x62, 0x7A, + 0x1E, 0x17, 0xEA, 0x27, 0xE7, 0x11, 0xBD, 0xD4 + }, + { + 0xEA, 0xFD, 0x36, 0x55, 0x05, 0xC3, 0x89, 0x9E, + 0x8B, 0x12, 0xA4, 0x81, 0xFB, 0x13, 0x0A, 0xA5, + 0x67, 0xDD, 0x2B, 0xF3, 0x6C, 0x22, 0x73, 0x27, + 0xA7, 0x82, 0x49, 0x39, 0x19, 0x4F, 0xED, 0x89 + }, + { + 0xA7, 0x7C, 0x2D, 0x35, 0x6D, 0x92, 0x38, 0x03, + 0x55, 0xA6, 0x74, 0xE5, 0x4F, 0x64, 0x8E, 0x7B, + 0xEB, 0xF7, 0x4C, 0xEC, 0x50, 0x19, 0x2D, 0xD7, + 0xF8, 0xCB, 0x3F, 0xFF, 0x1A, 0xC8, 0x50, 0x4B + }, + { + 0xDA, 0xD4, 0xA9, 0xE6, 0x43, 0x2B, 0x91, 0x07, + 0x2A, 0x9D, 0x0A, 0x83, 0x70, 0xBB, 0x71, 0x3A, + 0xAE, 0x79, 0xE5, 0xE2, 0x1E, 0x7B, 0xEB, 0x61, + 0xA8, 0xE2, 0x51, 0x4E, 0x9A, 0x78, 0xC6, 0xE7 + }, + { + 0x9D, 0x29, 0xF1, 0xE3, 0xD0, 0x93, 0x6C, 0x16, + 0xF6, 0x70, 0xD0, 0x72, 0x41, 0x9E, 0xE1, 0xAB, + 0x2F, 0x20, 0x05, 0xD6, 0x6F, 0xC9, 0xFE, 0xC2, + 0x9C, 0x83, 0x29, 0xC5, 0x1F, 0x4B, 0xF1, 0x09 + }, + { + 0x48, 0xB1, 0x1A, 0x18, 0x5A, 0x9D, 0x8C, 0x27, + 0x2F, 0xF6, 0xC6, 0x22, 0xB9, 0x33, 0xCB, 0xFB, + 0xFB, 0x22, 0x43, 0xD8, 0x77, 0x74, 0x1E, 0xED, + 0x8E, 0xEB, 0xD6, 0x75, 0x9D, 0x04, 0x19, 0xBE + }, + { + 0x30, 0xAC, 0x57, 0x8E, 0x83, 0xCE, 0xBA, 0x82, + 0x8D, 0x7B, 0x8D, 0xA5, 0x67, 0xD2, 0x95, 0xEA, + 0x95, 0x94, 0x6A, 0xF2, 0x50, 0x54, 0x06, 0x9B, + 0x74, 0x4E, 0x54, 0xCF, 0xD9, 0x37, 0xA3, 0xD8 + }, + { + 0xF4, 0x6B, 0x54, 0xF7, 0xC1, 0x7B, 0xDC, 0x3C, + 0x97, 0x6B, 0xE5, 0xB1, 0xBE, 0x5F, 0x4E, 0x94, + 0x64, 0x27, 0x20, 0xD7, 0xC6, 0x5B, 0x65, 0x1D, + 0x32, 0xFE, 0x4E, 0xE7, 0x80, 0x79, 0xB7, 0x72 + }, + { + 0xCB, 0x0D, 0xDC, 0x1E, 0x91, 0xA2, 0x2F, 0xD2, + 0xB1, 0x78, 0xB5, 0xDC, 0x60, 0x76, 0x1B, 0x0F, + 0x6F, 0x05, 0xA0, 0xA3, 0x0E, 0x01, 0xAC, 0x7A, + 0x96, 0x71, 0xCE, 0x6F, 0xE0, 0xBC, 0xF8, 0x78 + }, + { + 0x1D, 0x30, 0xAF, 0x20, 0x94, 0xB2, 0xD6, 0xCA, + 0x9B, 0xBF, 0x3E, 0xC0, 0xA9, 0x8D, 0x2C, 0xBF, + 0xBA, 0xC9, 0xC7, 0x86, 0xC0, 0xD7, 0xBF, 0xAB, + 0x0C, 0xFD, 0x44, 0x3E, 0x00, 0x54, 0xA7, 0x8C + }, + { + 0x9A, 0xD3, 0xDC, 0xED, 0x10, 0x99, 0xD8, 0x3C, + 0x20, 0x8C, 0x16, 0x3E, 0x07, 0x88, 0xDD, 0x32, + 0xF5, 0xCD, 0x02, 0xA4, 0x92, 0xF6, 0x51, 0x10, + 0xD6, 0x12, 0x0F, 0xF3, 0xEE, 0xD4, 0x1E, 0xEE + }, + { + 0xF6, 0x1D, 0x60, 0xF4, 0xD8, 0xD7, 0x32, 0x3F, + 0xCB, 0x8D, 0xF0, 0x17, 0xA8, 0x27, 0x54, 0x1A, + 0xB9, 0xE1, 0x77, 0xC2, 0x9A, 0xA9, 0xA8, 0xFD, + 0x60, 0x9B, 0x1F, 0x5A, 0x11, 0x34, 0x69, 0x66 + }, + { + 0x4D, 0x94, 0x3F, 0x59, 0x62, 0xF3, 0x0A, 0x5D, + 0x76, 0xCF, 0xA1, 0x45, 0xFD, 0x00, 0xBE, 0x64, + 0x28, 0x4B, 0xFA, 0xF3, 0xA4, 0x32, 0x64, 0xC3, + 0xA1, 0x51, 0x12, 0xA5, 0x78, 0x23, 0xDA, 0x23 + }, + { + 0x53, 0xEC, 0xE5, 0x9F, 0x43, 0x57, 0xDE, 0xBD, + 0x10, 0xC9, 0x1E, 0x28, 0x4E, 0x75, 0xF1, 0x31, + 0x73, 0x55, 0xB8, 0xE7, 0xDE, 0x76, 0x7B, 0x35, + 0x5F, 0x14, 0x05, 0x09, 0x13, 0x45, 0x92, 0x4B + }, + { + 0x55, 0x2F, 0xE2, 0xF2, 0x51, 0xD4, 0xDA, 0x17, + 0x55, 0x10, 0x3D, 0x5C, 0xA0, 0xB5, 0xA9, 0x2E, + 0xC2, 0xDE, 0xC8, 0x7B, 0x30, 0xF7, 0xB8, 0x68, + 0xFC, 0xB4, 0xD1, 0x99, 0x1E, 0x42, 0xD6, 0x52 + }, + { + 0x3D, 0x1C, 0x91, 0x60, 0x21, 0xF0, 0x9E, 0x82, + 0xA5, 0x08, 0xBC, 0xAA, 0x88, 0x10, 0x20, 0x32, + 0xB5, 0x12, 0xAF, 0xAE, 0x2A, 0x5C, 0x6F, 0x0C, + 0x08, 0x93, 0x68, 0x15, 0x15, 0xEF, 0x66, 0x99 + }, + { + 0xB7, 0x01, 0x0B, 0xF7, 0xAB, 0x1F, 0x5F, 0x51, + 0xFF, 0xD4, 0x55, 0x18, 0xA8, 0x54, 0xE6, 0x0E, + 0x25, 0x9E, 0x40, 0x3D, 0x34, 0x63, 0x4D, 0x4A, + 0xBC, 0xCE, 0x00, 0x87, 0x1E, 0xAF, 0xFA, 0xA2 + }, + { + 0xEF, 0x93, 0xEC, 0xA3, 0x3E, 0x84, 0x2F, 0xC8, + 0xF8, 0xFD, 0x82, 0xFD, 0x38, 0x9F, 0x03, 0x3F, + 0xC4, 0x6A, 0x1F, 0x0F, 0x2D, 0x31, 0x54, 0x4E, + 0xBD, 0xA9, 0xE1, 0x54, 0xD9, 0xBC, 0x8C, 0xF8 + }, + { + 0x42, 0x47, 0x4F, 0x95, 0x78, 0x0A, 0xFE, 0xA8, + 0xA6, 0x66, 0xAF, 0x28, 0x57, 0x9C, 0xD2, 0x39, + 0x69, 0x4E, 0x40, 0xC9, 0x66, 0x4B, 0x7F, 0x2A, + 0x93, 0x7C, 0x62, 0x5C, 0xBD, 0xCE, 0x81, 0x9B + }, + { + 0xC3, 0xCB, 0x05, 0x0D, 0xA7, 0x24, 0xB9, 0x0C, + 0x81, 0xFD, 0x71, 0x9A, 0x20, 0xE5, 0xE0, 0x02, + 0x3B, 0x0D, 0xD5, 0xAD, 0xE8, 0x20, 0x3D, 0xFE, + 0xBC, 0xC3, 0x28, 0x03, 0x74, 0x3E, 0xDC, 0xB6 + }, + { + 0xA2, 0xD5, 0x70, 0xD3, 0xA0, 0xDA, 0x36, 0x91, + 0x2D, 0xAA, 0xD1, 0xD0, 0x3D, 0x09, 0xE8, 0x75, + 0x79, 0xBF, 0x60, 0xCA, 0x8E, 0x34, 0x30, 0xA1, + 0x66, 0x44, 0x9D, 0x68, 0x77, 0x47, 0xD3, 0xAE + }, + { + 0xA3, 0x02, 0xE9, 0x9F, 0x3F, 0x94, 0xC7, 0x4C, + 0xD6, 0x35, 0x78, 0xEF, 0xD8, 0xB1, 0x67, 0x94, + 0x99, 0x94, 0x22, 0x6D, 0x0F, 0x6F, 0x6C, 0x3F, + 0xFF, 0x11, 0x0A, 0x55, 0x7C, 0x37, 0x3D, 0xCA + }, + { + 0xE8, 0xEC, 0xBD, 0x61, 0xF4, 0x28, 0xF6, 0x10, + 0xE3, 0xD9, 0x60, 0x0C, 0x9A, 0x0C, 0x15, 0x01, + 0x79, 0xA7, 0x6C, 0x1D, 0x2A, 0x53, 0x89, 0x45, + 0x57, 0x0D, 0xDF, 0x10, 0x51, 0x82, 0x0D, 0xF4 + }, + { + 0x8A, 0xBE, 0x00, 0x43, 0x5C, 0x2A, 0x4B, 0xC4, + 0xDD, 0x24, 0x88, 0x15, 0x8F, 0xDA, 0x2B, 0x44, + 0xC0, 0x5F, 0xAF, 0x6B, 0xD0, 0x5B, 0x88, 0x47, + 0x6E, 0x69, 0x18, 0x33, 0xB7, 0xB5, 0x76, 0xA6 + }, + { + 0x52, 0xF9, 0x11, 0x22, 0xF4, 0x64, 0xAF, 0x7C, + 0x6C, 0x96, 0xC1, 0xAA, 0x9C, 0xAB, 0x90, 0x28, + 0xFD, 0x61, 0x36, 0x30, 0xFC, 0xEE, 0x33, 0x73, + 0x34, 0x75, 0x4B, 0xCF, 0xEA, 0x8A, 0x83, 0xE6 + }, + { + 0xE3, 0xF4, 0xC2, 0x8B, 0x48, 0x16, 0x8C, 0xAF, + 0x36, 0x4C, 0x56, 0xA4, 0x99, 0x08, 0xD2, 0x43, + 0x42, 0x1C, 0xD8, 0x55, 0xD9, 0x9E, 0x5B, 0xBF, + 0xE2, 0x33, 0x20, 0xD7, 0x0F, 0x92, 0x35, 0xC6 + }, + { + 0x13, 0x78, 0x58, 0xAE, 0xE9, 0xA6, 0xA4, 0x8F, + 0x4A, 0x02, 0x76, 0xB0, 0x2E, 0x4B, 0x9F, 0x6A, + 0x87, 0xC1, 0xBE, 0x4D, 0x54, 0xCE, 0x73, 0x67, + 0x26, 0x5D, 0xE2, 0x4C, 0x13, 0x90, 0x19, 0x81 + }, + { + 0x2A, 0x94, 0x37, 0xFF, 0x98, 0xC7, 0x75, 0xC9, + 0xE4, 0xD4, 0xE6, 0xC8, 0x46, 0x70, 0x12, 0xA5, + 0x53, 0x42, 0x2A, 0x33, 0x25, 0xEC, 0x6F, 0x72, + 0xA2, 0xB8, 0x24, 0x76, 0x00, 0x5F, 0x6A, 0xF1 + }, + { + 0xB1, 0xE2, 0xA4, 0x61, 0x9E, 0xAA, 0x43, 0xB5, + 0xEE, 0x18, 0xB3, 0x20, 0xBE, 0xA6, 0xFB, 0xAD, + 0x4E, 0x40, 0x0E, 0xF2, 0x83, 0xA3, 0x43, 0xED, + 0xD1, 0xD2, 0x96, 0xE4, 0x0E, 0x10, 0xF0, 0xC6 + }, + { + 0x75, 0x7A, 0xE2, 0x65, 0x28, 0xEE, 0x69, 0x28, + 0xE0, 0xC0, 0xBE, 0xEE, 0xAA, 0xF1, 0xB6, 0xF1, + 0xEC, 0x20, 0x68, 0xF4, 0x93, 0xD5, 0x08, 0xC1, + 0xCF, 0x36, 0x85, 0x8A, 0x56, 0x92, 0x19, 0xFD + }, + { + 0xDC, 0x53, 0xBD, 0xFC, 0xA3, 0xAE, 0x16, 0x3D, + 0x32, 0x54, 0x53, 0x61, 0x36, 0x85, 0x23, 0x99, + 0xA8, 0xA8, 0xB3, 0xA1, 0xD6, 0xA3, 0x1B, 0x8E, + 0x01, 0xDD, 0x0C, 0xA5, 0x19, 0x5C, 0x2C, 0xC2 + }, + { + 0x53, 0xA4, 0x9B, 0x0C, 0x79, 0xF9, 0x57, 0x3C, + 0xB5, 0x33, 0x1E, 0x22, 0x2A, 0x01, 0x02, 0x2C, + 0xC4, 0xBA, 0xFD, 0x28, 0x89, 0x12, 0xF0, 0xD0, + 0xF2, 0xCA, 0x49, 0x63, 0xB1, 0xB2, 0xF4, 0x92 + }, + { + 0x1D, 0xB5, 0x94, 0xE0, 0xEE, 0x24, 0x05, 0x9F, + 0xAD, 0x06, 0x13, 0xDB, 0x1C, 0xCA, 0xF4, 0x52, + 0xD2, 0x89, 0x8D, 0xFB, 0x53, 0xB0, 0x2A, 0x90, + 0x71, 0x32, 0xCD, 0xB6, 0xA0, 0xE6, 0x03, 0xB8 + }, + { + 0xA0, 0x98, 0x61, 0xB7, 0x51, 0x79, 0xD1, 0xE2, + 0x58, 0x3F, 0x9D, 0x5F, 0xE9, 0x7B, 0x31, 0x81, + 0x0B, 0x66, 0x3D, 0x14, 0x70, 0x9D, 0xF2, 0x09, + 0x58, 0x19, 0x17, 0xF0, 0x1F, 0x80, 0x0E, 0xB2 + }, + { + 0x6E, 0x0D, 0x30, 0xE8, 0xEB, 0x04, 0xB8, 0xE5, + 0x82, 0x59, 0x41, 0x41, 0x87, 0x1F, 0x25, 0x12, + 0xE5, 0x24, 0xEE, 0x0A, 0xE9, 0xF2, 0xF9, 0x58, + 0x78, 0x31, 0x59, 0x77, 0xA3, 0x23, 0x36, 0xFD + }, + { + 0x54, 0xFB, 0x91, 0x3D, 0x4C, 0x8B, 0x62, 0x3E, + 0x44, 0x3F, 0x09, 0x11, 0x84, 0x0D, 0x67, 0x94, + 0xC5, 0xCF, 0xA3, 0x99, 0x35, 0xD2, 0x4F, 0x77, + 0x62, 0x32, 0x19, 0x01, 0x5C, 0xEB, 0x09, 0x18 + }, + { + 0xAD, 0x7C, 0xB0, 0xE9, 0x45, 0x56, 0x09, 0x4B, + 0x58, 0xF0, 0x6F, 0x8B, 0x8A, 0x5D, 0x2B, 0x8D, + 0xE0, 0x29, 0xD8, 0x62, 0xFC, 0x28, 0x33, 0x34, + 0xF0, 0x09, 0xAB, 0xC0, 0x4A, 0xB6, 0xA6, 0xA5 + }, + { + 0x42, 0xFB, 0x05, 0xF8, 0x25, 0x1D, 0xCC, 0x44, + 0xA6, 0xDF, 0x34, 0x72, 0xE7, 0xEA, 0xE2, 0x36, + 0x42, 0x0F, 0xD7, 0xBF, 0xCC, 0xD8, 0xEA, 0x8C, + 0x93, 0x7D, 0xF9, 0x8F, 0x5C, 0x3D, 0xA1, 0x9B + }, + { + 0xA2, 0x21, 0x60, 0x2B, 0xB3, 0x44, 0x75, 0x9F, + 0xE1, 0x5B, 0x75, 0xB9, 0x58, 0x41, 0x5E, 0x17, + 0x60, 0xFC, 0x57, 0x72, 0x9A, 0xAF, 0x05, 0x10, + 0x40, 0xEF, 0x9B, 0x18, 0x35, 0xA3, 0x7A, 0x0E + }, + { + 0xF2, 0x17, 0x72, 0x67, 0x48, 0x85, 0x17, 0x73, + 0xFC, 0x36, 0xC4, 0x7C, 0xDC, 0xF2, 0xCC, 0x8D, + 0x29, 0x11, 0x79, 0x7E, 0xCA, 0x46, 0x64, 0x2D, + 0x89, 0x1D, 0x7A, 0x71, 0x86, 0x03, 0xA9, 0x34 + }, + { + 0x57, 0x7C, 0x61, 0x4B, 0x17, 0xE5, 0x95, 0x47, + 0x9D, 0x99, 0x14, 0x82, 0xAC, 0x05, 0x13, 0x54, + 0x45, 0x5C, 0x82, 0x0E, 0x8C, 0x5D, 0x4C, 0x7C, + 0x2B, 0xE2, 0x21, 0xA3, 0x27, 0x62, 0xF7, 0xD6 + }, + { + 0xBE, 0x5B, 0x1F, 0x24, 0x53, 0x8B, 0xA4, 0x5D, + 0xE2, 0x58, 0x83, 0x4D, 0x88, 0x69, 0x3A, 0xA3, + 0xCC, 0xDF, 0x01, 0x6C, 0x5A, 0x07, 0xC7, 0xDD, + 0x43, 0x0C, 0x06, 0x97, 0x2E, 0x36, 0xD5, 0xAA + }, + { + 0x52, 0x6E, 0x4B, 0x62, 0x8B, 0xFB, 0x12, 0x74, + 0xA9, 0x9E, 0xBF, 0xCF, 0x31, 0x2B, 0x4E, 0x73, + 0x57, 0xA8, 0x44, 0x78, 0x9E, 0xBB, 0x5E, 0x57, + 0x50, 0xB7, 0x9E, 0xD5, 0x13, 0x34, 0xA4, 0x69 + }, + { + 0xF5, 0xB2, 0xBC, 0xBE, 0xDB, 0xBD, 0x6E, 0x14, + 0xD6, 0xBB, 0x20, 0x45, 0x12, 0x0B, 0x86, 0xFC, + 0xC9, 0xF3, 0x20, 0xF4, 0xDC, 0x55, 0x59, 0x85, + 0xE0, 0x4B, 0x9F, 0x1D, 0x71, 0x00, 0xAD, 0x84 + }, + { + 0x1D, 0x48, 0xD4, 0x93, 0x2B, 0x5B, 0x7A, 0xEA, + 0x96, 0x26, 0xBD, 0xE9, 0xCC, 0xEF, 0xB3, 0x42, + 0x24, 0x82, 0xF6, 0xAB, 0x9A, 0x08, 0x48, 0x51, + 0xB1, 0x32, 0x66, 0x0A, 0x0E, 0x0E, 0x4D, 0x07 + }, + { + 0x1C, 0x41, 0x59, 0x40, 0xA4, 0x3B, 0xED, 0xF2, + 0x5B, 0xA8, 0xAE, 0x51, 0x8F, 0xAB, 0x8F, 0x8D, + 0x84, 0xAC, 0x41, 0xC7, 0x31, 0x9A, 0x31, 0xC6, + 0xDA, 0x55, 0xCA, 0xED, 0x98, 0xC4, 0xA1, 0x16 + }, + { + 0xE1, 0xF8, 0x14, 0x7A, 0x5D, 0x51, 0xAE, 0x55, + 0x9B, 0x0D, 0x44, 0x86, 0x22, 0xA6, 0xF8, 0x6E, + 0x60, 0x15, 0x4A, 0xD1, 0x8A, 0x08, 0xB7, 0x49, + 0xBE, 0x83, 0x7A, 0x7D, 0x1B, 0xF9, 0xA0, 0x9A + }, + { + 0xA0, 0xB6, 0x12, 0x1B, 0xAC, 0x66, 0x16, 0xFD, + 0x7D, 0xBE, 0x88, 0x8E, 0x95, 0xF1, 0xC4, 0xE9, + 0xDD, 0x2B, 0x84, 0xAD, 0xDC, 0x06, 0x8E, 0xB4, + 0x3A, 0xA4, 0x6E, 0x05, 0x33, 0x52, 0x49, 0x0A + }, + { + 0xB7, 0xD0, 0x06, 0xA0, 0x4B, 0x21, 0xE3, 0x24, + 0x83, 0x7F, 0x12, 0xA9, 0xF2, 0x3A, 0xE6, 0x33, + 0xA5, 0xD4, 0xF3, 0x1A, 0x33, 0x0F, 0x50, 0x66, + 0x26, 0xE3, 0x2A, 0x64, 0x9F, 0x23, 0x5D, 0xD6 + }, + { + 0xAC, 0xD8, 0x64, 0xD8, 0xBC, 0x34, 0xBE, 0x04, + 0x38, 0x02, 0x61, 0x63, 0x1D, 0x66, 0x32, 0xEE, + 0xF0, 0x2D, 0xDA, 0x73, 0x0F, 0xBE, 0x35, 0xF4, + 0x66, 0xAF, 0x75, 0x5B, 0xAC, 0x34, 0x87, 0x14 + }, + { + 0x56, 0x90, 0x11, 0x5F, 0x4C, 0x6E, 0x89, 0x59, + 0x9B, 0x01, 0x6D, 0x40, 0x78, 0x03, 0x94, 0x6A, + 0x0C, 0xDF, 0xD1, 0x29, 0x85, 0x27, 0x6B, 0xF3, + 0xA5, 0x9C, 0x86, 0x75, 0x1F, 0xF7, 0xB8, 0x9A + }, + { + 0x96, 0xD3, 0x86, 0x4B, 0x16, 0x77, 0x97, 0x73, + 0xE8, 0x19, 0xC2, 0xA1, 0x82, 0x9B, 0x17, 0x7D, + 0x70, 0x62, 0x3F, 0x45, 0xBB, 0x4D, 0x5C, 0xA4, + 0x47, 0x51, 0x3C, 0x9C, 0x26, 0x75, 0x62, 0x66 + }, + { + 0xCC, 0x26, 0x5D, 0x7C, 0xAD, 0xD7, 0xCA, 0xD1, + 0x93, 0x31, 0x4A, 0xC5, 0xA2, 0x80, 0x2C, 0x4F, + 0x48, 0xD7, 0xB2, 0xC5, 0xE7, 0x2C, 0xF3, 0x1F, + 0xC2, 0x52, 0xC8, 0x6D, 0xB5, 0x96, 0x57, 0xA8 + }, + { + 0x02, 0xB3, 0x46, 0xB5, 0x77, 0xEF, 0x91, 0x8C, + 0x31, 0xA0, 0x12, 0x1C, 0x86, 0x74, 0xCA, 0x3D, + 0xDF, 0x13, 0x3A, 0xBB, 0x47, 0x87, 0x5A, 0xED, + 0x0B, 0x57, 0xC8, 0x69, 0x7A, 0xA2, 0x17, 0x6A + }, + { + 0x07, 0x72, 0x69, 0x70, 0xAF, 0x4A, 0x09, 0xC5, + 0x38, 0x34, 0x36, 0x9A, 0xBD, 0xF5, 0x4A, 0x19, + 0x7F, 0xA1, 0x62, 0x15, 0x88, 0x87, 0xB6, 0x85, + 0xBC, 0xB0, 0xC5, 0x6D, 0x7C, 0x9B, 0xC3, 0x0E + }, + { + 0x5D, 0x52, 0x47, 0xAB, 0xE8, 0xCB, 0x30, 0x92, + 0x0E, 0xBB, 0x16, 0x95, 0xDF, 0x23, 0xE9, 0x99, + 0xA8, 0x3C, 0x7F, 0x98, 0xFE, 0x05, 0xCD, 0x9C, + 0x38, 0xEC, 0x67, 0x10, 0xF9, 0xBE, 0x16, 0x79 + }, + { + 0x0D, 0x69, 0x25, 0x70, 0xA1, 0x6B, 0xE4, 0xD4, + 0xDD, 0xA8, 0x1A, 0x5F, 0xDF, 0x98, 0x06, 0x4B, + 0x92, 0x49, 0x01, 0x59, 0x98, 0x91, 0x94, 0x33, + 0xFE, 0x04, 0x63, 0xA0, 0x57, 0xE2, 0x1C, 0x58 + }, + { + 0x24, 0xC5, 0x65, 0x7E, 0xAF, 0x2C, 0x3B, 0x3A, + 0x3F, 0xEE, 0x01, 0xD4, 0xC0, 0xE0, 0xDB, 0x15, + 0x4E, 0x49, 0x13, 0x90, 0x41, 0x64, 0x5D, 0x34, + 0x49, 0x11, 0x91, 0xBB, 0x51, 0xE7, 0xFB, 0x0A + }, + { + 0xF9, 0x13, 0xFC, 0xE1, 0xA3, 0x01, 0x2E, 0xE4, + 0x4A, 0x4A, 0x0C, 0x21, 0xBC, 0xA0, 0x34, 0xCB, + 0x51, 0x22, 0xC9, 0x2E, 0x69, 0xCF, 0xC5, 0xF6, + 0x87, 0x82, 0xD1, 0x94, 0x99, 0x63, 0x74, 0xD4 + }, + { + 0xBE, 0x80, 0x5E, 0x5A, 0x34, 0x05, 0xC7, 0x4D, + 0x09, 0x85, 0xA8, 0xC8, 0x94, 0x79, 0x75, 0x13, + 0x7B, 0xA6, 0xCC, 0x46, 0xA4, 0xEA, 0x3F, 0xA6, + 0x1E, 0x14, 0xB0, 0x07, 0xEB, 0x01, 0xE7, 0xD3 + }, + { + 0x21, 0xBF, 0x1E, 0xA1, 0x72, 0xB9, 0x8A, 0xF2, + 0x34, 0xDC, 0x6E, 0x5B, 0xEF, 0x34, 0x13, 0xF2, + 0x88, 0x1A, 0x01, 0x5D, 0xE4, 0xDB, 0xF4, 0x02, + 0xCF, 0x29, 0x6C, 0x27, 0xBE, 0x1C, 0x02, 0x56 + }, + { + 0xBB, 0x9A, 0xDA, 0x4B, 0x61, 0xA5, 0xD9, 0x8D, + 0x15, 0xE6, 0x92, 0xC3, 0x8E, 0xF4, 0xFF, 0x01, + 0x36, 0xAB, 0xFE, 0x2A, 0x99, 0x09, 0xE8, 0xCC, + 0x08, 0xE8, 0xAD, 0x5A, 0x88, 0x76, 0x49, 0x9B + }, + { + 0x0D, 0xC6, 0x04, 0x11, 0xEB, 0x4E, 0x82, 0xC4, + 0xCD, 0x96, 0xAF, 0x2E, 0x45, 0xE7, 0x9B, 0x4A, + 0xF5, 0xBA, 0xC6, 0x3F, 0xDF, 0xB0, 0xF1, 0x96, + 0xDB, 0x25, 0x9B, 0x7B, 0x0F, 0x76, 0x27, 0x11 + }, + { + 0x1D, 0xD0, 0x84, 0x0F, 0xC8, 0xFD, 0x22, 0x99, + 0x91, 0xC8, 0x6D, 0xC5, 0xF3, 0xD6, 0x0E, 0xA4, + 0x9F, 0xB0, 0x94, 0x33, 0xF2, 0xCC, 0xDF, 0x0F, + 0x67, 0xF4, 0xA1, 0x29, 0xEF, 0x51, 0x34, 0xAF + }, + { + 0xA4, 0x2E, 0xF8, 0x0F, 0x72, 0x29, 0x1A, 0x1B, + 0x77, 0x1B, 0xCA, 0x87, 0xC0, 0x78, 0x73, 0x4E, + 0x7F, 0x6E, 0xE0, 0x8A, 0x60, 0x86, 0x5A, 0xD6, + 0x32, 0xAA, 0x6A, 0x12, 0xBF, 0x5D, 0xAB, 0x58 + }, + { + 0x58, 0x82, 0x4D, 0xB9, 0xB8, 0xC8, 0x62, 0x52, + 0xCE, 0x09, 0x5B, 0x5E, 0x51, 0xA6, 0xE3, 0xB0, + 0x97, 0x49, 0x6F, 0x39, 0xFD, 0xBE, 0x33, 0xB0, + 0xDB, 0xC0, 0xA6, 0xF7, 0x63, 0x04, 0x64, 0x94 + }, + { + 0x4F, 0xFD, 0x69, 0x22, 0x78, 0x2C, 0xD8, 0xD4, + 0x0A, 0x23, 0xB6, 0x78, 0x8B, 0x54, 0xD5, 0x14, + 0x39, 0xD7, 0xF2, 0xB3, 0xB4, 0x0B, 0xE7, 0xC5, + 0x4D, 0x7F, 0x2B, 0xDF, 0xB9, 0xEC, 0x0F, 0x2B + }, + { + 0xE5, 0x68, 0x6D, 0x70, 0xCD, 0x7E, 0xE6, 0x97, + 0x65, 0x5C, 0xD1, 0x26, 0xC7, 0x4B, 0x25, 0x55, + 0x3B, 0xFE, 0x20, 0xC1, 0xF0, 0xBC, 0x83, 0x9B, + 0x78, 0xC7, 0x83, 0x53, 0xCD, 0x2C, 0xC5, 0x7A + }, + { + 0xC4, 0x0A, 0x52, 0x88, 0x60, 0x39, 0x0D, 0x8A, + 0x8A, 0x73, 0x21, 0x0A, 0x48, 0xC0, 0xCD, 0x70, + 0x71, 0x24, 0x25, 0x93, 0xC7, 0x6E, 0x49, 0x56, + 0x11, 0x76, 0x8A, 0x80, 0x24, 0xC4, 0xCA, 0xC5 + }, + { + 0x21, 0x61, 0xDB, 0x49, 0x09, 0x13, 0x37, 0xE1, + 0x6C, 0x36, 0xF1, 0x68, 0x4B, 0x49, 0x6C, 0xB1, + 0x9C, 0xC0, 0x32, 0xBA, 0x2F, 0x37, 0x89, 0x49, + 0xE7, 0x49, 0x08, 0xEA, 0x17, 0xA6, 0x51, 0x1F + }, + { + 0x54, 0x07, 0x2B, 0x8E, 0x5A, 0x82, 0x28, 0x07, + 0x5B, 0xF9, 0x9D, 0xD2, 0xCA, 0xB2, 0x25, 0x0B, + 0x93, 0xD9, 0x75, 0xC6, 0x51, 0x0B, 0x68, 0x05, + 0xAE, 0x17, 0x60, 0xB3, 0x92, 0x8A, 0xE1, 0xF7 + }, + { + 0x3D, 0xB2, 0x8A, 0xE7, 0x1F, 0xAA, 0x31, 0xE0, + 0xAF, 0xF7, 0x85, 0x20, 0x35, 0xE8, 0xCF, 0x6E, + 0xCC, 0xD1, 0x49, 0x47, 0x05, 0x25, 0xD7, 0x6F, + 0xE2, 0x42, 0x9C, 0x09, 0x93, 0x90, 0x22, 0x65 + }, + { + 0x70, 0xC0, 0xEC, 0x3E, 0x43, 0x7B, 0x3A, 0xE2, + 0x90, 0x69, 0x19, 0xBD, 0xA5, 0x85, 0x4B, 0xC6, + 0xAE, 0x4E, 0x72, 0xA0, 0x94, 0x57, 0x8B, 0xF0, + 0xB8, 0x1B, 0xDA, 0x6A, 0x08, 0x73, 0x4E, 0x65 + }, + { + 0xCB, 0x9A, 0xF7, 0xDA, 0x80, 0xD1, 0x1D, 0x77, + 0x70, 0x49, 0xD8, 0x68, 0x75, 0x8B, 0x74, 0xED, + 0x0F, 0x67, 0xD9, 0x94, 0x30, 0xED, 0xFA, 0x40, + 0x0C, 0xC2, 0x5B, 0x28, 0x81, 0xED, 0xE2, 0x3A + }, + { + 0x6A, 0x4A, 0xAE, 0xAB, 0x99, 0xA4, 0xF9, 0xD6, + 0xF3, 0xA7, 0xE1, 0x25, 0x1D, 0xBC, 0x29, 0xDD, + 0x04, 0xA7, 0xF4, 0x2B, 0x1A, 0x5A, 0x21, 0x8B, + 0x5A, 0xCE, 0x85, 0x59, 0x4E, 0xDC, 0x4E, 0x29 + }, + { + 0x2A, 0xE2, 0xC2, 0x4B, 0x42, 0xDE, 0xCD, 0x2B, + 0x05, 0x2F, 0x4A, 0xB1, 0x9F, 0xD4, 0xEF, 0xF4, + 0x13, 0xA2, 0xE3, 0x9F, 0xF0, 0x42, 0xE5, 0xEC, + 0xB1, 0xF6, 0x69, 0xED, 0x59, 0xCF, 0x06, 0xD1 + }, + { + 0xA7, 0xAF, 0xDD, 0xB1, 0x9F, 0x6E, 0xD6, 0x4C, + 0x87, 0x96, 0x2D, 0x46, 0x32, 0xE5, 0x12, 0xF1, + 0x14, 0x66, 0xFE, 0xEB, 0xF3, 0x8F, 0x7D, 0x96, + 0xC1, 0x9A, 0xD9, 0xF5, 0x26, 0x46, 0x58, 0x22 + }, + { + 0xB7, 0xCE, 0xE5, 0xE9, 0x0C, 0xA6, 0xEF, 0xEB, + 0x47, 0x9A, 0xA8, 0x4A, 0xD3, 0xA4, 0x40, 0xD2, + 0xEF, 0x82, 0x25, 0x35, 0x82, 0xD5, 0xAE, 0xEA, + 0x22, 0x62, 0x4B, 0xFA, 0x09, 0xC6, 0x0D, 0xE5 + }, + { + 0x34, 0xFA, 0xAF, 0x23, 0x6B, 0x62, 0x76, 0xCA, + 0x3E, 0x51, 0xBB, 0xD4, 0x71, 0x6C, 0x09, 0x5C, + 0x2A, 0x23, 0x9D, 0xF2, 0xEE, 0xB0, 0xC8, 0xF6, + 0x3D, 0x53, 0xDA, 0x01, 0xBF, 0x66, 0xEC, 0x17 + }, + { + 0x99, 0x4D, 0x40, 0xC1, 0x4A, 0xC2, 0x2B, 0x1A, + 0xD3, 0x5A, 0x4E, 0x0A, 0xD9, 0xF2, 0x3D, 0xA6, + 0xD8, 0xEA, 0x0B, 0x68, 0xFF, 0xD2, 0xD0, 0x48, + 0x3E, 0x02, 0x22, 0xCB, 0xA2, 0x94, 0xCC, 0x8B + }, + { + 0xB9, 0xEA, 0xC1, 0x2D, 0x90, 0x9C, 0xF1, 0x63, + 0xEF, 0x8E, 0x5F, 0x5A, 0xD8, 0xAD, 0x34, 0x13, + 0x25, 0x0D, 0x76, 0xB8, 0x28, 0x1D, 0x8B, 0x93, + 0x4C, 0x8E, 0x05, 0xC1, 0xCA, 0x62, 0x2B, 0x7B + }, + { + 0x21, 0xBB, 0x17, 0xEA, 0x6F, 0xBA, 0xE7, 0x4A, + 0xC2, 0x8E, 0x07, 0x3A, 0x10, 0xA4, 0x7F, 0x7F, + 0xEA, 0x4B, 0x97, 0x89, 0x03, 0xF8, 0x3D, 0x60, + 0xE3, 0xCF, 0xB3, 0xC8, 0x9A, 0x82, 0xA5, 0xAF + }, + { + 0xEB, 0xEA, 0x20, 0xF7, 0x46, 0x6A, 0x04, 0x58, + 0xD9, 0x2C, 0xF5, 0xF4, 0x48, 0x50, 0x7F, 0x1E, + 0xEF, 0xD2, 0x72, 0xD3, 0xA6, 0x25, 0x6C, 0xF8, + 0xBF, 0xFA, 0x98, 0x27, 0xD1, 0x25, 0x56, 0x90 + }, + { + 0x06, 0x09, 0xCA, 0xCA, 0x49, 0xB4, 0xC3, 0xB9, + 0x92, 0x18, 0x26, 0xB3, 0x91, 0xC6, 0x2C, 0xF9, + 0x3A, 0x4B, 0xC6, 0x5B, 0x36, 0x78, 0x74, 0x01, + 0x0F, 0x7B, 0x28, 0x6C, 0xDF, 0x08, 0xD7, 0x85 + }, + { + 0x23, 0x9E, 0x55, 0xB0, 0x05, 0xD1, 0xF6, 0xFE, + 0x78, 0xC6, 0x21, 0xED, 0x8E, 0xAE, 0x75, 0xEA, + 0x8E, 0x16, 0x72, 0x1B, 0xFF, 0x60, 0x98, 0xF4, + 0x04, 0x36, 0xA4, 0x57, 0xF3, 0x6D, 0x64, 0xEC + }, + { + 0x4C, 0x57, 0x40, 0xC0, 0xF5, 0xC9, 0x7A, 0xE4, + 0xEA, 0xD8, 0x29, 0xA6, 0x73, 0x89, 0x3C, 0xDF, + 0xA7, 0xC4, 0xCC, 0xC2, 0xED, 0xC0, 0xF2, 0xDE, + 0x51, 0x85, 0xCD, 0x4D, 0xF9, 0x7C, 0x56, 0x27 + }, + { + 0x24, 0xB9, 0x15, 0x61, 0xC8, 0x18, 0xA8, 0xC0, + 0x68, 0xE0, 0x3A, 0x08, 0x72, 0x17, 0x32, 0x4C, + 0x22, 0x0D, 0xA4, 0xC0, 0xA9, 0x11, 0xA1, 0xF7, + 0xB7, 0xE9, 0x96, 0x5A, 0xC5, 0x31, 0x91, 0xAF + }, + { + 0x77, 0x00, 0x50, 0x0C, 0x0C, 0x90, 0xB1, 0x10, + 0xC5, 0xB6, 0x70, 0x70, 0x33, 0x7C, 0xEF, 0x74, + 0xA7, 0x79, 0xA4, 0x20, 0xEC, 0xA0, 0xA8, 0x67, + 0x9A, 0xCC, 0x07, 0x69, 0xDB, 0xCD, 0x75, 0x6C + }, + { + 0x81, 0x2B, 0x01, 0xDE, 0x35, 0x6F, 0xF2, 0xBE, + 0x22, 0x2B, 0xC6, 0x65, 0x8C, 0x7F, 0x0F, 0xFE, + 0x24, 0x1D, 0x61, 0xDA, 0x0E, 0xFE, 0x0E, 0x70, + 0x01, 0xED, 0xE6, 0x23, 0x28, 0x79, 0xA7, 0x18 + }, + { + 0x57, 0x77, 0x7C, 0x6C, 0x9A, 0x7F, 0x8B, 0x2A, + 0xE1, 0x6A, 0x70, 0xA2, 0xD1, 0x4C, 0xEB, 0xC6, + 0xC7, 0x73, 0xF1, 0x0D, 0xA0, 0x9A, 0xCB, 0x13, + 0x39, 0xBA, 0xDD, 0x26, 0xE5, 0x41, 0xA9, 0xC0 + }, + { + 0x6B, 0xE2, 0x10, 0xF2, 0x79, 0x7A, 0x9A, 0xB6, + 0xFD, 0xE5, 0x6D, 0x6F, 0xF6, 0x09, 0x21, 0x67, + 0x65, 0xE2, 0x2D, 0xCC, 0x9D, 0x24, 0x25, 0x5B, + 0x3F, 0xED, 0x08, 0x72, 0xA5, 0x69, 0x50, 0x64 + }, + { + 0xE8, 0x8D, 0xCF, 0x2F, 0x80, 0xB8, 0x45, 0xCC, + 0x10, 0xE1, 0xB8, 0x47, 0xE9, 0xEC, 0x0F, 0xB6, + 0x9B, 0x7C, 0x47, 0x8A, 0x07, 0x19, 0x1B, 0x62, + 0xF7, 0x89, 0x7D, 0xA4, 0xE3, 0xF6, 0x6C, 0x60 + }, + { + 0x98, 0xE8, 0x3A, 0x17, 0x4D, 0xB6, 0xB3, 0x65, + 0x80, 0xF6, 0x43, 0x1F, 0xC8, 0x71, 0x9E, 0x58, + 0x3B, 0xF1, 0x6E, 0xA4, 0x06, 0xD2, 0x5F, 0xC0, + 0xD6, 0x73, 0x52, 0x60, 0xA5, 0xDC, 0x97, 0xBB + }, + { + 0x09, 0xC0, 0xC8, 0xD4, 0xAF, 0x9F, 0x45, 0xEA, + 0x76, 0xF1, 0xBC, 0xB5, 0xBB, 0x4B, 0xF8, 0x8D, + 0xAE, 0x5D, 0x7D, 0xF2, 0x1F, 0xFA, 0x2E, 0x00, + 0xD7, 0xC4, 0x96, 0x03, 0x5C, 0x73, 0x37, 0x33 + }, + { + 0xCF, 0x88, 0x9D, 0x2F, 0x82, 0x4D, 0x76, 0x36, + 0xB4, 0xCD, 0xE5, 0xC8, 0x37, 0x56, 0x1B, 0x52, + 0xE6, 0x67, 0xB8, 0x99, 0x1C, 0xB9, 0x09, 0x35, + 0x7D, 0x07, 0xB5, 0x5F, 0xB1, 0x69, 0x50, 0x17 + }, + { + 0x45, 0x32, 0x43, 0x23, 0x0A, 0xD4, 0x67, 0xDF, + 0xF6, 0x49, 0x17, 0x89, 0xBD, 0x61, 0x0E, 0x01, + 0xD0, 0x3A, 0xFD, 0xD7, 0x56, 0x68, 0x8E, 0xF8, + 0x0A, 0xE6, 0xA8, 0xD5, 0xD3, 0x28, 0x94, 0x58 + }, + { + 0x46, 0x92, 0x68, 0x45, 0x38, 0xE1, 0xA6, 0x55, + 0xB2, 0x1A, 0x6E, 0x91, 0x98, 0x62, 0x9A, 0x41, + 0xBC, 0x70, 0x36, 0x79, 0x16, 0xE1, 0x17, 0x17, + 0x8E, 0x91, 0x93, 0x90, 0xC5, 0x4C, 0x27, 0x84 + }, + { + 0x08, 0x0D, 0x25, 0x7F, 0xD9, 0x20, 0x62, 0x24, + 0x99, 0x95, 0xA7, 0x9D, 0xC2, 0x11, 0x7C, 0x65, + 0xFD, 0x37, 0xA4, 0x57, 0xC5, 0xF3, 0x98, 0x24, + 0xB1, 0xBF, 0xA2, 0xE0, 0x4D, 0xED, 0x00, 0xB2 + }, + { + 0xFF, 0x7D, 0xDC, 0x2A, 0x19, 0x34, 0x36, 0x2C, + 0x8C, 0x17, 0x85, 0xED, 0x83, 0x60, 0x4B, 0xFA, + 0xE2, 0x4E, 0xBA, 0x1C, 0xC5, 0xD7, 0x8F, 0xE1, + 0x40, 0x55, 0x08, 0x8B, 0x5E, 0x2F, 0x16, 0x21 + }, + { + 0xD4, 0x3A, 0x3D, 0xE8, 0x11, 0x12, 0x8E, 0x87, + 0x91, 0xF3, 0x05, 0xF6, 0xB7, 0x80, 0xF3, 0x07, + 0xCD, 0x49, 0x8F, 0x76, 0xA9, 0xBC, 0xD9, 0x7B, + 0xAB, 0xA9, 0x87, 0x0C, 0x86, 0x6B, 0x37, 0x7E + }, + { + 0x8B, 0xE3, 0x6F, 0x07, 0x6F, 0x2A, 0x22, 0xC2, + 0x86, 0xA8, 0x60, 0x1A, 0xBA, 0x19, 0x8E, 0x7F, + 0xD4, 0x03, 0x14, 0x2E, 0xD5, 0xE0, 0x5C, 0x58, + 0xE0, 0x6D, 0x4C, 0x1C, 0xA0, 0x01, 0xDC, 0xFF + }, + { + 0xDD, 0xFD, 0x38, 0xA5, 0x8A, 0xB0, 0x11, 0x4B, + 0xA7, 0xB2, 0xB7, 0xF2, 0x2D, 0x4F, 0xAB, 0xA6, + 0x35, 0x08, 0x30, 0x0B, 0x05, 0x27, 0x1B, 0xD1, + 0x3C, 0xD3, 0x4E, 0xE1, 0x49, 0xEB, 0x22, 0x97 + }, + { + 0x4D, 0xE4, 0xDE, 0xC5, 0xF7, 0x02, 0xF2, 0x52, + 0x11, 0xEE, 0x67, 0x45, 0xB8, 0xA6, 0x47, 0x10, + 0x8A, 0xBA, 0xE0, 0xF2, 0xDE, 0xE4, 0x51, 0x23, + 0x93, 0x79, 0xF8, 0x86, 0x64, 0x8C, 0xE4, 0x10 + }, + { + 0xDF, 0xA4, 0xF9, 0x29, 0xB0, 0x36, 0x30, 0xCD, + 0x0B, 0xD2, 0x88, 0xFD, 0x95, 0xD1, 0xF7, 0x00, + 0x71, 0x2B, 0x3C, 0x04, 0x73, 0xC0, 0x7C, 0x98, + 0xC0, 0xBD, 0xAF, 0x80, 0x04, 0xC4, 0x0A, 0x00 + }, + { + 0xA7, 0x15, 0x9D, 0x53, 0xFD, 0xA9, 0xDC, 0xFE, + 0x21, 0xC8, 0xBF, 0x52, 0x19, 0x45, 0x40, 0x26, + 0xD9, 0x7F, 0x19, 0x56, 0x35, 0xAC, 0xF6, 0xBA, + 0x69, 0x0A, 0x30, 0x7F, 0xA6, 0x92, 0xD7, 0xFB + }, + { + 0x13, 0x54, 0x0E, 0x9B, 0xFC, 0x80, 0xED, 0x12, + 0x4C, 0x8C, 0xBA, 0x0F, 0xCB, 0x78, 0x99, 0xF5, + 0x19, 0xA1, 0x58, 0xEC, 0x59, 0xE5, 0x87, 0xC1, + 0xE1, 0x85, 0x18, 0x8B, 0xFA, 0x88, 0xD2, 0x43 + }, + { + 0x30, 0x74, 0x72, 0x75, 0x81, 0xF4, 0x4E, 0xF0, + 0x6C, 0x21, 0x77, 0x8C, 0x90, 0x5E, 0x67, 0xCA, + 0x11, 0x15, 0x5D, 0x1B, 0xAD, 0x1C, 0x03, 0x09, + 0x7A, 0x73, 0x33, 0x4B, 0x71, 0xE9, 0xDF, 0xEF + }, + { + 0x49, 0xD3, 0x9A, 0x93, 0x46, 0xFC, 0x7C, 0x4E, + 0x1A, 0x65, 0xE8, 0x47, 0x80, 0x77, 0x29, 0x69, + 0x77, 0x9B, 0x61, 0xA8, 0x29, 0x3C, 0xF8, 0x59, + 0xC7, 0x61, 0x98, 0x2D, 0xD5, 0x74, 0xC0, 0x69 + }, + { + 0x6D, 0x6E, 0x68, 0x86, 0x2B, 0x15, 0xC2, 0xCB, + 0xB2, 0xAA, 0x79, 0xBE, 0x3E, 0x59, 0xA9, 0x59, + 0x70, 0x81, 0x42, 0x48, 0x39, 0x96, 0x56, 0xC7, + 0x93, 0x68, 0x3B, 0xEA, 0x0C, 0xD5, 0x79, 0xB1 + }, + { + 0x49, 0x28, 0xBE, 0x9A, 0x15, 0x25, 0xD2, 0xE9, + 0xAA, 0xBA, 0x5D, 0x62, 0x16, 0xFA, 0xF5, 0x61, + 0x8D, 0xDD, 0x6C, 0x36, 0x2A, 0x2C, 0x3E, 0xB9, + 0x53, 0x60, 0xA0, 0x4F, 0xD1, 0x20, 0x91, 0x9E + }, + { + 0x17, 0xB0, 0xE5, 0x41, 0xE3, 0x0F, 0xA4, 0xF5, + 0x42, 0xB2, 0x2D, 0xCD, 0x29, 0xCD, 0xC5, 0x96, + 0xCF, 0xED, 0x9B, 0x01, 0x7E, 0x4A, 0xD5, 0x0E, + 0x97, 0x37, 0xC9, 0xE1, 0x01, 0x51, 0x31, 0x10 + }, + { + 0xA9, 0x7E, 0xE5, 0x1D, 0x5F, 0x6D, 0x8F, 0x28, + 0x6B, 0x45, 0xF9, 0xD5, 0xD8, 0x02, 0xF5, 0xF0, + 0x29, 0xEA, 0x04, 0x0E, 0xC8, 0x96, 0xAC, 0xC4, + 0xF2, 0x64, 0x8C, 0xD9, 0xAB, 0x5C, 0xBD, 0x89 + }, + { + 0x2C, 0x44, 0x90, 0xA9, 0x66, 0xED, 0x1C, 0xF6, + 0xDD, 0xCA, 0xB7, 0xE0, 0xD0, 0x56, 0xFB, 0xC6, + 0x6A, 0x8D, 0x6F, 0xE9, 0x29, 0xFC, 0xDB, 0x36, + 0x39, 0xEF, 0x02, 0x27, 0x3A, 0x2D, 0x3B, 0xA9 + }, + { + 0x40, 0xFA, 0x2C, 0x0F, 0x03, 0xDD, 0x65, 0xDB, + 0x98, 0xC7, 0x02, 0x60, 0xC5, 0x98, 0xF4, 0xDD, + 0xE9, 0x60, 0x1E, 0xB1, 0xA2, 0xAC, 0xAF, 0xB1, + 0x18, 0x28, 0x2F, 0xA8, 0xDB, 0xBA, 0x97, 0x80 + }, + { + 0x26, 0x99, 0x17, 0xF3, 0x20, 0x74, 0x20, 0xC9, + 0x21, 0xA5, 0x63, 0xDE, 0x0D, 0x85, 0x43, 0x6F, + 0x29, 0xED, 0xA5, 0x0D, 0x45, 0x4E, 0x20, 0xD3, + 0xC3, 0xB3, 0x5C, 0x26, 0x47, 0xEF, 0x0B, 0xA2 + }, + { + 0x54, 0xDE, 0xF7, 0xA5, 0x7F, 0x87, 0xAE, 0x1A, + 0xA7, 0x6A, 0xF5, 0x73, 0x23, 0x1F, 0xA7, 0xE5, + 0x66, 0xE8, 0xB7, 0x2A, 0x2D, 0x86, 0x8B, 0x93, + 0x8B, 0x80, 0x77, 0xD6, 0xCD, 0xC5, 0xDF, 0x15 + }, + { + 0x6C, 0x6B, 0xB2, 0x1F, 0x54, 0x20, 0x80, 0xE2, + 0x66, 0xC8, 0xA7, 0x7D, 0xF7, 0x34, 0x1E, 0x21, + 0x1B, 0x50, 0xCF, 0x6A, 0x7A, 0x6E, 0xDC, 0xAF, + 0xAD, 0x10, 0xDA, 0x08, 0x7C, 0xAD, 0xD1, 0x7A + }, + { + 0x5D, 0x28, 0x4C, 0x6D, 0xAC, 0x7C, 0xA1, 0x28, + 0xC0, 0x3D, 0x65, 0xEE, 0x02, 0xE9, 0x52, 0x8D, + 0x16, 0x1C, 0xAE, 0x89, 0x14, 0x4C, 0xBE, 0x45, + 0x1E, 0xEC, 0x56, 0xDD, 0x73, 0xF0, 0x1F, 0xFC + }, + { + 0x5A, 0x4E, 0x1F, 0xDA, 0xDC, 0x11, 0x48, 0x84, + 0xE6, 0x85, 0x34, 0x03, 0xFB, 0x33, 0x4B, 0x01, + 0x3F, 0xEA, 0x60, 0x62, 0x2E, 0x73, 0x10, 0xB5, + 0x8E, 0x1C, 0x22, 0x23, 0x9D, 0x1B, 0xBA, 0x2E + }, + { + 0xF3, 0x46, 0x52, 0x34, 0x2C, 0xB6, 0xDB, 0x1B, + 0x2D, 0xF0, 0xC2, 0xE1, 0x6D, 0x42, 0x0C, 0x88, + 0x74, 0x87, 0x5F, 0x1A, 0x69, 0x4C, 0xE2, 0x1D, + 0x71, 0x2B, 0x23, 0xEA, 0xA5, 0x27, 0x5C, 0xEF + }, + { + 0x10, 0xC6, 0x19, 0x0B, 0x86, 0x29, 0x16, 0x31, + 0xA8, 0x9E, 0xDD, 0x77, 0x32, 0xB2, 0x48, 0x9F, + 0xFC, 0x9A, 0xC5, 0xFB, 0xEA, 0xC0, 0x11, 0x23, + 0x54, 0x1B, 0x3B, 0xF6, 0xE0, 0xE0, 0xD3, 0x47 + }, + { + 0x46, 0x10, 0xAC, 0x5B, 0xB8, 0x21, 0xDF, 0xDE, + 0x64, 0xBC, 0xCE, 0xF1, 0x46, 0xEC, 0x6F, 0xD4, + 0xFC, 0x85, 0x18, 0x2F, 0x13, 0x9B, 0x35, 0xC9, + 0xDA, 0x2B, 0x5E, 0x32, 0x3C, 0x66, 0xF4, 0xFC + }, + { + 0x7A, 0xAB, 0x6B, 0x93, 0xEC, 0x1A, 0x3D, 0x8C, + 0x0E, 0x95, 0xB0, 0x94, 0xB6, 0xF3, 0x24, 0xC9, + 0x33, 0x85, 0x95, 0xD0, 0x21, 0xEF, 0x0E, 0x7C, + 0x5F, 0x1C, 0x1D, 0x90, 0x16, 0xFA, 0xF0, 0x2F + }, + { + 0xEA, 0x67, 0xEB, 0xA2, 0xF0, 0x84, 0x67, 0x27, + 0x88, 0x2E, 0x4D, 0xCE, 0xA3, 0x87, 0x5D, 0xF7, + 0xE1, 0x07, 0xC3, 0x4E, 0xBA, 0x70, 0xBC, 0x6F, + 0x3F, 0x18, 0x46, 0x93, 0xCF, 0xFC, 0x70, 0x68 + }, + { + 0x24, 0x42, 0xA1, 0x2F, 0x9C, 0xDB, 0x91, 0xB7, + 0xB9, 0x68, 0x94, 0x9E, 0x4C, 0x06, 0x04, 0x22, + 0x1F, 0x92, 0xFF, 0x79, 0x3D, 0x02, 0xD0, 0xAA, + 0x0F, 0x45, 0x3D, 0xEF, 0x48, 0x08, 0x45, 0x26 + }, + { + 0x50, 0x00, 0x35, 0x99, 0x9F, 0x9B, 0xBD, 0x90, + 0xBD, 0xE2, 0xDC, 0x73, 0x5A, 0x29, 0x9B, 0x10, + 0xE9, 0x5E, 0x30, 0x3E, 0x2E, 0xF2, 0x58, 0x81, + 0x67, 0x8D, 0x86, 0x57, 0xD7, 0x62, 0xF4, 0xBD + }, + { + 0xD1, 0xB6, 0x65, 0x7F, 0xA2, 0xA4, 0x9A, 0x2F, + 0x82, 0x7A, 0x41, 0xB5, 0xCE, 0xF6, 0xD9, 0x7A, + 0x1E, 0x42, 0x87, 0xFF, 0x28, 0x99, 0xA8, 0xC3, + 0x1F, 0xC8, 0xFD, 0xA1, 0x64, 0x5E, 0x6E, 0xEF + }, + { + 0x92, 0xC7, 0x38, 0x7B, 0xF4, 0x9B, 0xCA, 0x3A, + 0x4F, 0x87, 0x1D, 0x2A, 0x7D, 0xC6, 0x9C, 0x20, + 0x8A, 0xAB, 0x74, 0x73, 0x83, 0xF3, 0xBE, 0x7C, + 0xD1, 0xDE, 0x6F, 0x71, 0x1C, 0x32, 0xAE, 0xC8 + }, + { + 0x64, 0x4D, 0xFD, 0x2F, 0x93, 0x49, 0xEA, 0x74, + 0x40, 0x6B, 0xA0, 0xC4, 0x8C, 0x3F, 0xBA, 0xD6, + 0xE8, 0xF5, 0x5A, 0xAB, 0x98, 0xC7, 0xCC, 0x91, + 0xBE, 0xBF, 0xEC, 0x87, 0xF2, 0xDD, 0xFF, 0x3E + }, + { + 0x75, 0xBF, 0x74, 0xF2, 0x22, 0xF6, 0x97, 0x70, + 0x7A, 0x08, 0xBE, 0xCB, 0xEA, 0xA1, 0x59, 0x5E, + 0x26, 0xB3, 0x1D, 0x64, 0x16, 0xBF, 0xC2, 0x85, + 0x35, 0xBA, 0x4F, 0xB0, 0x15, 0x35, 0xBD, 0x4D + }, + { + 0xC3, 0xB9, 0xEA, 0x7B, 0x82, 0xF3, 0xB3, 0xB1, + 0x10, 0xC2, 0x04, 0xED, 0x16, 0x02, 0xC4, 0x98, + 0xA3, 0x05, 0x13, 0x49, 0x59, 0xEA, 0x7D, 0xE9, + 0x24, 0xEE, 0x9A, 0xD5, 0x70, 0x09, 0x29, 0xBB + }, + { + 0xB9, 0x8E, 0x34, 0x48, 0x86, 0xFC, 0xD9, 0x28, + 0x67, 0xBD, 0x28, 0xD6, 0x8F, 0xC7, 0x60, 0xB6, + 0xB8, 0x6B, 0xAA, 0xAC, 0xD2, 0x89, 0x13, 0xD7, + 0x16, 0x14, 0x08, 0x30, 0x58, 0x83, 0x26, 0x99 + }, + { + 0x3A, 0xF9, 0x25, 0x89, 0xE6, 0x80, 0x67, 0xD3, + 0x93, 0x25, 0xFA, 0xE5, 0x93, 0xB4, 0x7B, 0xD5, + 0x85, 0x4A, 0xA6, 0x9F, 0xF7, 0xFE, 0xA7, 0xCE, + 0x3A, 0x49, 0x19, 0xCA, 0xBB, 0xA6, 0xA0, 0x4E + }, + { + 0x55, 0xF0, 0x4D, 0xD3, 0x6F, 0x2C, 0x6C, 0x93, + 0xA2, 0xD9, 0x3D, 0xFE, 0x92, 0x03, 0x49, 0x74, + 0x89, 0x1A, 0x31, 0xB5, 0xF9, 0x53, 0x77, 0x5B, + 0xBB, 0x0E, 0xBE, 0x0B, 0x37, 0x89, 0x90, 0x9C + }, + { + 0x10, 0xCE, 0x5F, 0x1A, 0x65, 0x23, 0xCF, 0xBD, + 0xD3, 0x84, 0x85, 0x9E, 0x8B, 0x95, 0x3D, 0x23, + 0x10, 0xB0, 0x83, 0xF0, 0x1A, 0xE0, 0x3F, 0xE5, + 0x1D, 0x18, 0xF9, 0x3D, 0x70, 0x5D, 0x20, 0xB0 + }, + { + 0x66, 0xB6, 0x37, 0xEC, 0xE4, 0x3D, 0x0F, 0x84, + 0xF6, 0xE3, 0xB7, 0x09, 0xE1, 0x26, 0x7B, 0x03, + 0xD8, 0xD2, 0x6E, 0x86, 0x88, 0x49, 0x45, 0xD5, + 0xA7, 0x2A, 0x1F, 0x10, 0x1C, 0x5E, 0x3B, 0xCE + }, + { + 0x57, 0xF9, 0x96, 0x9E, 0x0F, 0xF9, 0x12, 0x44, + 0xFE, 0x70, 0x01, 0xDE, 0x23, 0x75, 0xCC, 0x69, + 0xEF, 0x1B, 0xA1, 0xDE, 0x78, 0xB1, 0x2E, 0x69, + 0xAA, 0x32, 0xF3, 0x1A, 0xBF, 0x26, 0xFB, 0x94 + }, + { + 0x3F, 0x00, 0x0A, 0xBA, 0x2D, 0xB1, 0x04, 0xF3, + 0xEC, 0x05, 0x26, 0xE4, 0x67, 0xC1, 0x96, 0x32, + 0xB1, 0xE3, 0xE7, 0x76, 0xE9, 0xF9, 0x6A, 0x16, + 0x5A, 0xDF, 0xE2, 0x86, 0x6D, 0x28, 0xD4, 0xAA + }, + { + 0x50, 0x41, 0xD4, 0xDA, 0xFC, 0x70, 0x28, 0x22, + 0x24, 0xC3, 0x6E, 0x9E, 0xB4, 0x3B, 0xA4, 0x51, + 0xAD, 0x1F, 0x6A, 0x81, 0xE5, 0xBF, 0x4B, 0xCF, + 0x34, 0x6B, 0xEC, 0xD0, 0xDD, 0xFB, 0x02, 0x12 + }, + { + 0xB2, 0x8B, 0x77, 0x1E, 0x98, 0xC2, 0x6F, 0xB9, + 0x5F, 0x89, 0xA4, 0xC5, 0x05, 0x6D, 0x47, 0x8D, + 0xEB, 0x05, 0x11, 0x9B, 0x05, 0x2F, 0x29, 0x11, + 0xE8, 0xF5, 0x0A, 0x88, 0x47, 0x87, 0x85, 0xF4 + }, + { + 0xDC, 0xA1, 0x04, 0xAC, 0x63, 0x7D, 0x10, 0x47, + 0x98, 0xA1, 0x83, 0xFD, 0x29, 0xE0, 0xB5, 0x89, + 0x23, 0xF9, 0xD5, 0x36, 0xED, 0x88, 0x84, 0x4C, + 0x5F, 0x63, 0x3E, 0x64, 0x38, 0xAD, 0xA4, 0x11 + }, + { + 0x7F, 0xD1, 0x37, 0x9C, 0x50, 0x0C, 0xEB, 0x17, + 0x51, 0x99, 0x5C, 0xCB, 0xD5, 0xEC, 0x6A, 0xA9, + 0x05, 0x3F, 0xE3, 0x39, 0x12, 0x38, 0x28, 0x2C, + 0x62, 0x2C, 0x21, 0x7E, 0x4C, 0xDC, 0x6D, 0x04 + }, + { + 0x92, 0x2A, 0xC9, 0x7E, 0x73, 0xA6, 0x65, 0x37, + 0xC7, 0xF7, 0x68, 0x32, 0x7E, 0xB4, 0x4B, 0x2A, + 0x5E, 0x0F, 0xAF, 0x8A, 0x93, 0x64, 0x83, 0x8D, + 0x95, 0x8F, 0xCE, 0x76, 0x9A, 0xE5, 0x21, 0xEC + }, + { + 0x5F, 0x63, 0x9C, 0xFD, 0x17, 0x3E, 0xEE, 0xEB, + 0x00, 0x77, 0x89, 0x43, 0x73, 0xC3, 0xD7, 0x91, + 0xD8, 0x6E, 0x69, 0x6A, 0xBD, 0xEF, 0xC7, 0xC1, + 0xCA, 0x8D, 0x44, 0x85, 0x04, 0xCF, 0x5A, 0xF7 + }, + { + 0xA5, 0x6A, 0x9D, 0x98, 0x31, 0x3F, 0xE2, 0xA4, + 0x91, 0xF4, 0x46, 0x83, 0xE3, 0x76, 0x7D, 0x1F, + 0xB0, 0xF7, 0xAA, 0xA1, 0xB1, 0x6B, 0xF7, 0x1A, + 0x2C, 0x47, 0x01, 0x80, 0xDA, 0x7B, 0x18, 0x09 + }, + { + 0x20, 0x01, 0xC5, 0xB5, 0x8E, 0x44, 0x4D, 0x47, + 0x3A, 0x36, 0x8C, 0x0E, 0x7B, 0x28, 0x86, 0x3A, + 0xF9, 0xCC, 0x88, 0x60, 0xE9, 0xCB, 0xE0, 0x04, + 0xA6, 0x36, 0x13, 0xCF, 0xA7, 0x83, 0xFF, 0x74 + }, + { + 0x1A, 0x5D, 0xD2, 0xF8, 0x6D, 0x39, 0x66, 0xF1, + 0xD4, 0xEC, 0x90, 0x15, 0xAC, 0x28, 0x8D, 0x58, + 0x63, 0x15, 0x13, 0xDE, 0x4C, 0x72, 0xF7, 0x7D, + 0x41, 0x66, 0xE7, 0x22, 0xE2, 0x57, 0x41, 0x76 + }, + { + 0x99, 0xCA, 0x6A, 0xE4, 0x81, 0x14, 0x5A, 0x7E, + 0x40, 0xBB, 0x29, 0x7D, 0xBD, 0x96, 0x71, 0x49, + 0x10, 0xE7, 0x87, 0x09, 0xF5, 0x41, 0xC6, 0x49, + 0xD8, 0x6F, 0x83, 0xE7, 0x5E, 0x16, 0xCF, 0x1D + }, + { + 0x68, 0x3C, 0xFC, 0x67, 0xA8, 0x51, 0x78, 0xD3, + 0xA2, 0x36, 0xEB, 0x01, 0xD3, 0x33, 0xE7, 0xDB, + 0x52, 0xB7, 0x32, 0x54, 0xCA, 0x85, 0x32, 0xE9, + 0x1A, 0xE3, 0xEC, 0xA4, 0xEA, 0xE8, 0x6E, 0x4F + }, + { + 0xAB, 0x8B, 0x33, 0xA6, 0x07, 0x40, 0xF5, 0x59, + 0x86, 0xA8, 0x55, 0xF0, 0x94, 0x61, 0x4A, 0x52, + 0x56, 0xC6, 0x67, 0x2F, 0x83, 0x9A, 0x8B, 0x13, + 0x1F, 0xB7, 0x22, 0x59, 0xAA, 0x29, 0xBE, 0x56 + }, + { + 0x96, 0x88, 0x4B, 0x7E, 0xA0, 0xA3, 0xEF, 0x15, + 0xED, 0xDA, 0x0B, 0x89, 0x32, 0x2D, 0x89, 0x7B, + 0xC7, 0x30, 0xD3, 0x18, 0x6F, 0x8A, 0xAF, 0x31, + 0x7B, 0x84, 0x35, 0x3B, 0x90, 0xE0, 0x2C, 0x8C + }, + { + 0x53, 0xC5, 0x7E, 0x50, 0x00, 0xA5, 0xF7, 0x83, + 0x43, 0x86, 0xC9, 0xB6, 0xCC, 0x96, 0xFA, 0xA0, + 0xAF, 0xF5, 0x7D, 0xDC, 0x98, 0x2E, 0x23, 0xD6, + 0x7C, 0x70, 0x62, 0x2D, 0x0A, 0x11, 0x6A, 0xB1 + }, + { + 0x51, 0xB4, 0x12, 0x85, 0x48, 0xBB, 0xC6, 0x86, + 0x42, 0xB7, 0x99, 0xDC, 0xFE, 0xD9, 0x9C, 0xCE, + 0x77, 0xE9, 0x72, 0x55, 0xD4, 0xC4, 0xD1, 0xB5, + 0xA0, 0x60, 0x26, 0xDC, 0x45, 0xB8, 0xDC, 0x96 + }, + { + 0x03, 0x10, 0x4F, 0x09, 0x56, 0xBE, 0x3E, 0x9A, + 0x68, 0xC4, 0xB7, 0xA6, 0x87, 0x6F, 0x1E, 0xB5, + 0x12, 0xFA, 0x9B, 0x14, 0x6C, 0x95, 0x95, 0x97, + 0xC8, 0x22, 0x9E, 0x29, 0xF2, 0x58, 0xCD, 0x29 + }, + { + 0x5F, 0x76, 0xFC, 0x55, 0xC9, 0x2B, 0x02, 0x3C, + 0xA3, 0xC0, 0xC2, 0x38, 0xD3, 0x23, 0xE1, 0x16, + 0x03, 0x4C, 0xB3, 0x2C, 0x58, 0x87, 0x96, 0xDB, + 0xF7, 0x26, 0x43, 0x19, 0xB6, 0x9B, 0x7D, 0xBD + }, + { + 0x6D, 0xA2, 0xCF, 0x90, 0x0E, 0xA5, 0xB1, 0x8D, + 0xDA, 0xBA, 0xA3, 0xDA, 0xAD, 0x63, 0x43, 0x04, + 0x16, 0xD1, 0x69, 0xA6, 0x6E, 0x8B, 0x78, 0x96, + 0xDF, 0x70, 0x50, 0x08, 0x78, 0x35, 0x16, 0x82 + }, + { + 0xE6, 0x97, 0x4E, 0x03, 0xD9, 0x97, 0x53, 0x2B, + 0x5F, 0x69, 0x5C, 0x9B, 0x91, 0x69, 0x6D, 0xDA, + 0x69, 0x7B, 0xCB, 0x62, 0xBB, 0x95, 0x57, 0x7B, + 0x70, 0xF0, 0x0A, 0x78, 0x3C, 0x38, 0x80, 0x8F + }, + { + 0x54, 0xC0, 0xFB, 0xEC, 0x69, 0x1C, 0x9B, 0xEB, + 0x7A, 0xF1, 0x3C, 0xFA, 0x80, 0x08, 0xD7, 0xFC, + 0xE4, 0xDB, 0xB5, 0x44, 0xE3, 0x93, 0xD5, 0xD7, + 0x28, 0xFA, 0x73, 0x15, 0x5D, 0x49, 0x37, 0x68 + }, + { + 0x17, 0xE5, 0xCA, 0x31, 0x38, 0x66, 0x2F, 0xE6, + 0xAA, 0xDD, 0x64, 0xCE, 0xB0, 0x01, 0xBF, 0xE5, + 0x8B, 0x1B, 0x72, 0x05, 0x05, 0xC7, 0x7D, 0x70, + 0xE8, 0x2F, 0x88, 0x85, 0x96, 0x30, 0xB2, 0xDB + }, + { + 0xBC, 0x43, 0xC4, 0x4F, 0xB5, 0xDB, 0x56, 0xC1, + 0x0A, 0xF5, 0x0C, 0xF0, 0x32, 0x16, 0x99, 0x08, + 0x8D, 0xE0, 0xDB, 0xC8, 0x77, 0xFB, 0xDD, 0x36, + 0xEB, 0x45, 0x34, 0xA5, 0xED, 0xEA, 0xF0, 0x20 + }, + { + 0xA4, 0x06, 0x1A, 0x9A, 0x6F, 0xEC, 0x03, 0xBD, + 0xF2, 0xEA, 0xD2, 0x81, 0x1B, 0x25, 0xB6, 0x67, + 0xC1, 0xB8, 0xCA, 0xEF, 0x81, 0x99, 0xC9, 0xEE, + 0x74, 0x99, 0xE5, 0x1F, 0x4D, 0xFB, 0xE1, 0xE2 + }, + { + 0x90, 0x3F, 0x0B, 0x12, 0x10, 0x2D, 0xC0, 0x21, + 0x98, 0x98, 0xB4, 0xDD, 0x5A, 0x45, 0xA6, 0x0A, + 0x85, 0x0C, 0x28, 0x21, 0xB0, 0xC4, 0xA9, 0x60, + 0x59, 0xFE, 0xC4, 0xFF, 0xA2, 0x4B, 0xC0, 0x4B + }, + { + 0xDD, 0x98, 0xAD, 0xDF, 0x72, 0xB8, 0xB1, 0x80, + 0x0F, 0x43, 0xED, 0x0F, 0xC0, 0x39, 0x20, 0xD9, + 0x8E, 0x60, 0x73, 0x53, 0xA0, 0x56, 0x54, 0x25, + 0x08, 0x37, 0x3F, 0xBA, 0xFD, 0x14, 0x32, 0xB9 + }, + { + 0x29, 0xA7, 0xC1, 0x77, 0xC0, 0xB9, 0x12, 0x49, + 0x04, 0xE1, 0xDD, 0xBB, 0xC8, 0x2A, 0x80, 0x05, + 0x16, 0x38, 0xC3, 0x4B, 0xE1, 0xA6, 0xD6, 0x33, + 0x55, 0xCF, 0x58, 0x91, 0x0D, 0xB5, 0xBB, 0xE8 + }, + { + 0x0A, 0xE0, 0x82, 0x1A, 0x00, 0xE8, 0x4D, 0xAE, + 0xD7, 0x92, 0xC2, 0x04, 0x51, 0x13, 0xC8, 0xC2, + 0x7B, 0x31, 0x4E, 0xF1, 0x22, 0xA8, 0xF8, 0xD2, + 0x5E, 0x40, 0xA6, 0xCA, 0xD3, 0x66, 0x3C, 0x2F + }, + { + 0x52, 0x13, 0xAE, 0x83, 0x02, 0x86, 0x91, 0x83, + 0x4D, 0xFA, 0x3E, 0xEC, 0x2E, 0xD3, 0x0D, 0x36, + 0xDC, 0xB1, 0x9B, 0xB9, 0xD8, 0x3E, 0xBC, 0x5B, + 0x3D, 0xA5, 0xAA, 0xA6, 0x3C, 0x6C, 0x49, 0x91 + }, + { + 0x77, 0x37, 0x39, 0xA0, 0x1D, 0x3B, 0xDE, 0xCD, + 0xCD, 0x1C, 0x7D, 0x8D, 0x44, 0x84, 0x73, 0x2E, + 0x05, 0x54, 0xE4, 0xBE, 0x67, 0xA3, 0x19, 0x2A, + 0x1E, 0x47, 0x42, 0x9B, 0x4E, 0xCC, 0x41, 0x5C + }, + { + 0xBD, 0xB7, 0xF6, 0x3A, 0x5D, 0xFC, 0x97, 0xE0, + 0xF4, 0xBD, 0xB5, 0xCD, 0x0E, 0xEA, 0x2B, 0x1E, + 0x6C, 0xE8, 0x41, 0x1D, 0x75, 0x18, 0xC0, 0x7B, + 0xA5, 0x5E, 0xB0, 0x5A, 0x52, 0x4E, 0x0F, 0xD0 + }, + { + 0x74, 0x5E, 0x9C, 0x0B, 0x03, 0xFB, 0xF8, 0x78, + 0xCD, 0xAA, 0x2B, 0x3F, 0xA4, 0xAA, 0xD2, 0x3D, + 0x72, 0xC1, 0x13, 0x59, 0xFA, 0x9B, 0xF0, 0xB7, + 0x14, 0x88, 0x32, 0xEC, 0xA4, 0x83, 0xCA, 0x5D + }, + { + 0x6B, 0x27, 0x20, 0x3E, 0xA3, 0x94, 0x39, 0x8A, + 0x1B, 0x02, 0x91, 0x5A, 0x34, 0xE2, 0xD8, 0xAF, + 0x27, 0x6F, 0x4E, 0x19, 0xD4, 0xB7, 0xB5, 0x7A, + 0x7F, 0x33, 0x5B, 0x48, 0xB2, 0xDF, 0x13, 0xAB + }, + { + 0xF8, 0x15, 0x19, 0x47, 0x39, 0xD0, 0xBD, 0x4C, + 0xE9, 0x42, 0xA1, 0xC1, 0x8C, 0x51, 0x75, 0xB5, + 0xED, 0xEB, 0x79, 0xBF, 0x83, 0xF9, 0xC2, 0xE7, + 0xD3, 0xAC, 0xCF, 0x2A, 0x48, 0x04, 0x6A, 0xAF + }, + { + 0x3D, 0x53, 0x39, 0xA6, 0xD7, 0xA4, 0x94, 0xBE, + 0x8B, 0xCF, 0xEB, 0xC5, 0xDF, 0x7C, 0x37, 0xC7, + 0x20, 0x50, 0xB5, 0x32, 0x5B, 0xEB, 0x01, 0x94, + 0x97, 0xBD, 0x6C, 0x1C, 0xCB, 0xEF, 0x79, 0x0D + }, + { + 0x9D, 0x3B, 0x40, 0x7F, 0x2C, 0xB9, 0x11, 0x8E, + 0x97, 0xA7, 0xF2, 0x71, 0x82, 0x56, 0xBA, 0x98, + 0x89, 0x66, 0xEB, 0xEB, 0xFB, 0xF0, 0x07, 0x64, + 0x2B, 0x2A, 0x7B, 0x6A, 0xB2, 0x7A, 0x83, 0xA9 + }, + { + 0xA4, 0x06, 0xBE, 0x19, 0xB3, 0xC6, 0x2F, 0x7D, + 0x45, 0x7A, 0xFB, 0xF5, 0x0B, 0x81, 0x30, 0xBD, + 0x2E, 0xF3, 0x06, 0x10, 0x38, 0x20, 0x15, 0xFC, + 0xC8, 0x66, 0x09, 0x0B, 0x07, 0xE0, 0x18, 0x19 + }, + { + 0x2F, 0x7C, 0x94, 0x53, 0xA3, 0xC0, 0x80, 0x90, + 0x15, 0x31, 0xF0, 0x40, 0xBA, 0x03, 0xBE, 0xD5, + 0x02, 0x8E, 0x10, 0x79, 0xE5, 0xCB, 0x59, 0xBB, + 0x9B, 0x06, 0x45, 0xB0, 0xB4, 0x7C, 0xD4, 0xF0 + }, + { + 0x11, 0xE7, 0x76, 0x85, 0xD7, 0x90, 0x7A, 0x19, + 0x6B, 0xAA, 0xF2, 0x03, 0xDC, 0x3D, 0x61, 0x79, + 0x19, 0xD0, 0xFD, 0xED, 0x95, 0x96, 0xE6, 0xCE, + 0xF1, 0xAA, 0xF4, 0x3E, 0x57, 0x70, 0x06, 0xEB + }, + { + 0xB8, 0x9A, 0x73, 0x86, 0xF8, 0xFF, 0x82, 0xBD, + 0x48, 0x09, 0x62, 0x68, 0xFB, 0xDD, 0x71, 0x37, + 0xC0, 0xB5, 0x39, 0xD0, 0xD7, 0x5D, 0x48, 0x7D, + 0x56, 0x0C, 0xD8, 0x12, 0x5C, 0xEB, 0x31, 0x92 + }, + { + 0x8F, 0x1C, 0x2F, 0x33, 0xE8, 0xE1, 0x73, 0xCE, + 0xF2, 0x1A, 0xFD, 0x31, 0xF5, 0x60, 0xCC, 0x65, + 0x1B, 0x5F, 0xF1, 0xE4, 0x2C, 0xBA, 0xE2, 0x98, + 0xAD, 0xB9, 0x2F, 0x1D, 0x05, 0x06, 0xB5, 0x13 + }, + { + 0xBF, 0xA7, 0xB3, 0x29, 0x61, 0xA7, 0xA2, 0xB2, + 0xF7, 0x78, 0x98, 0x49, 0xBF, 0x60, 0x3F, 0x2D, + 0xA0, 0xE2, 0xD7, 0x3C, 0x30, 0x7A, 0x9E, 0x76, + 0x8F, 0x3E, 0xE3, 0xAF, 0x7E, 0x06, 0x40, 0x8E + }, + { + 0xFD, 0xA3, 0xBC, 0x3D, 0x7B, 0xF8, 0x4A, 0x16, + 0xF1, 0xCF, 0x2E, 0x5B, 0x9D, 0x28, 0x97, 0xA7, + 0xA6, 0x0B, 0xC2, 0x9E, 0x60, 0x6E, 0xA0, 0x64, + 0x41, 0x57, 0xB4, 0x62, 0xE8, 0xD7, 0x8C, 0x90 + }, + { + 0x47, 0x3A, 0xF7, 0x8E, 0xAC, 0x8C, 0xCB, 0x81, + 0x55, 0xD6, 0x29, 0x5C, 0x3A, 0x1A, 0x1C, 0x9C, + 0x7C, 0x29, 0x56, 0x3B, 0x5B, 0x9D, 0x20, 0xC8, + 0xB3, 0xA9, 0xB2, 0x2F, 0xFA, 0x0B, 0x98, 0x2A + }, + { + 0xAF, 0xA5, 0x7F, 0x10, 0x11, 0x8C, 0x27, 0x03, + 0xC1, 0x78, 0x96, 0xBF, 0xF5, 0xA4, 0xE6, 0xB7, + 0x4C, 0xC0, 0x34, 0x6A, 0xE0, 0x4F, 0x60, 0x26, + 0xAD, 0xE7, 0xF4, 0x9D, 0x76, 0x9D, 0xC2, 0xCE + }, + { + 0xC7, 0x27, 0xE5, 0xFA, 0xEC, 0x5E, 0x90, 0x8B, + 0x8A, 0x0C, 0x91, 0x4C, 0x21, 0xD2, 0x42, 0xE5, + 0xDB, 0x87, 0x11, 0xEC, 0x96, 0x1F, 0xBB, 0xA7, + 0xC4, 0x2F, 0x97, 0x27, 0x5F, 0xB2, 0x4C, 0x2F + }, + { + 0x10, 0x8E, 0x7F, 0xEF, 0x3E, 0x2E, 0x71, 0x41, + 0x7A, 0x0C, 0x61, 0xB4, 0x35, 0xE9, 0xCF, 0x6F, + 0x90, 0xA7, 0x64, 0x76, 0xCF, 0xE6, 0x52, 0xED, + 0x77, 0x21, 0x8C, 0x4A, 0x56, 0x52, 0x16, 0xEE + }, + { + 0xF1, 0x1B, 0x23, 0xF2, 0x86, 0x54, 0xA6, 0x95, + 0xDD, 0x39, 0x55, 0x87, 0xBB, 0x2A, 0xCF, 0x7E, + 0x44, 0xF3, 0x9B, 0x30, 0x10, 0x0E, 0xEE, 0xF3, + 0xA0, 0x9A, 0x28, 0xDA, 0x44, 0x07, 0x78, 0xF2 + }, + { + 0xC3, 0xC8, 0x17, 0xB3, 0x8B, 0xC8, 0x6A, 0x83, + 0x8B, 0x9B, 0x56, 0x8A, 0x6D, 0x6A, 0xE8, 0xCF, + 0x7A, 0x1C, 0x17, 0xAB, 0x13, 0xF5, 0x56, 0xD6, + 0x28, 0x28, 0xB1, 0x28, 0x69, 0x89, 0x9F, 0x7D + }, + { + 0x8C, 0x1F, 0xB1, 0xEE, 0x91, 0x78, 0x4C, 0x61, + 0xE6, 0xC4, 0x2A, 0x14, 0x3C, 0x71, 0x81, 0x04, + 0x09, 0x29, 0x47, 0x26, 0xFD, 0x8C, 0x01, 0x85, + 0xD7, 0x96, 0x33, 0xA5, 0xC2, 0x00, 0xF2, 0x73 + }, + { + 0x46, 0x15, 0xD4, 0x50, 0x7D, 0xC7, 0x6A, 0x38, + 0xF8, 0x07, 0x2E, 0x6D, 0x47, 0x42, 0x14, 0xF6, + 0xCB, 0xCF, 0x44, 0x3E, 0x68, 0x4E, 0x96, 0x39, + 0x72, 0x9C, 0x9B, 0x97, 0xBE, 0xD4, 0xC2, 0x61 + }, + { + 0x51, 0xD5, 0xA1, 0x35, 0xA5, 0xF5, 0xEB, 0xA5, + 0x47, 0x10, 0x54, 0x8F, 0xFD, 0xB7, 0xFE, 0x2A, + 0xD5, 0xDB, 0xB4, 0x98, 0xD1, 0xB7, 0x76, 0xEA, + 0xFB, 0x10, 0x56, 0x85, 0xD4, 0xC7, 0x55, 0xC7 + }, + { + 0x2F, 0x88, 0x62, 0x0D, 0x0D, 0x28, 0xA1, 0xA2, + 0x54, 0x8D, 0x22, 0xA9, 0x9C, 0x0D, 0x8B, 0x75, + 0xD8, 0x9E, 0x58, 0xB5, 0x9E, 0x13, 0xB5, 0x44, + 0x81, 0x24, 0xAD, 0xCB, 0x42, 0x82, 0x74, 0x7C + }, + { + 0xD2, 0x64, 0xBD, 0x3F, 0x92, 0xC6, 0xF7, 0x82, + 0xF2, 0xAE, 0xAC, 0x23, 0x55, 0x8B, 0x9C, 0xCE, + 0x40, 0x93, 0x21, 0x99, 0x94, 0x74, 0xD9, 0x9F, + 0xF6, 0x85, 0xD6, 0x73, 0x64, 0x78, 0xAD, 0x5E + }, + { + 0xF8, 0x13, 0x04, 0x84, 0x2F, 0x4C, 0xC0, 0x10, + 0x90, 0xFA, 0xA6, 0x75, 0x1A, 0xC0, 0xEE, 0x74, + 0x8A, 0x0A, 0x21, 0xC8, 0x44, 0x49, 0x8C, 0xAE, + 0x19, 0xE6, 0x76, 0xC8, 0x93, 0x13, 0x45, 0x5B + }, + { + 0x65, 0x9F, 0x88, 0xE3, 0x91, 0x58, 0x0F, 0xA6, + 0xC6, 0x2F, 0xD1, 0x0E, 0xD5, 0x9C, 0x91, 0x5A, + 0xAE, 0x47, 0xD6, 0x8B, 0xF0, 0x31, 0xB0, 0xA2, + 0x04, 0x08, 0x01, 0xCC, 0x1C, 0x2E, 0xC9, 0x16 + }, + { + 0xBB, 0xA3, 0x27, 0x00, 0x50, 0xB9, 0x32, 0x08, + 0x7A, 0xB7, 0x52, 0x0E, 0xEB, 0xED, 0x4B, 0x15, + 0x86, 0x12, 0x81, 0xEA, 0x8D, 0x07, 0x9E, 0x0E, + 0x2A, 0xC7, 0xF0, 0x99, 0x81, 0x04, 0x47, 0xD5 + }, + { + 0x59, 0x99, 0xDF, 0x92, 0x11, 0x19, 0xC1, 0xBA, + 0x23, 0xD3, 0x40, 0x3C, 0xDA, 0x9E, 0xA3, 0x69, + 0xFD, 0xB1, 0x0A, 0x2F, 0x18, 0x53, 0x4C, 0xA1, + 0xDF, 0x23, 0x18, 0xDD, 0xAD, 0x70, 0x40, 0x48 + }, + { + 0xFF, 0x9A, 0xA3, 0x2A, 0x5F, 0xA0, 0xD8, 0xFD, + 0xA4, 0x5F, 0x52, 0x88, 0x6F, 0x79, 0xCE, 0x28, + 0xC5, 0x49, 0x5F, 0xFF, 0x54, 0x83, 0xE3, 0x51, + 0x00, 0xFB, 0x10, 0x17, 0x8C, 0x55, 0xE2, 0x99 + }, + { + 0xC0, 0x96, 0x67, 0x36, 0x7A, 0xA5, 0xA4, 0xC7, + 0x1E, 0x98, 0x34, 0x62, 0x08, 0xD9, 0xD6, 0xB6, + 0xEA, 0xAB, 0x7E, 0x0A, 0xDC, 0x11, 0x1E, 0xA4, + 0xBF, 0x9E, 0x40, 0x9D, 0x2A, 0xEC, 0x1D, 0xBC + }, + { + 0x4D, 0xC9, 0xC1, 0x37, 0x19, 0xD4, 0xC2, 0xB4, + 0xA0, 0x9F, 0xEC, 0x8F, 0xEA, 0xAB, 0x03, 0xFB, + 0xDA, 0xE6, 0xEF, 0x62, 0x9F, 0x7F, 0x81, 0xDF, + 0x80, 0x2D, 0x4D, 0x7B, 0x73, 0x47, 0x3C, 0xB2 + }, + { + 0xD6, 0x89, 0xF8, 0x93, 0xA9, 0x0D, 0x71, 0x6F, + 0x35, 0xC6, 0xB1, 0xA0, 0x0D, 0x91, 0x08, 0xC8, + 0x0A, 0x95, 0xF8, 0x85, 0x74, 0x8E, 0x4D, 0x9D, + 0xCD, 0xD4, 0xEC, 0xAD, 0xAF, 0x56, 0xB5, 0x5C + }, + { + 0x29, 0x49, 0xA9, 0xFD, 0xD1, 0xB8, 0x9C, 0xF1, + 0x2A, 0xA6, 0x8C, 0xDC, 0x21, 0x31, 0x18, 0x68, + 0x8F, 0x56, 0xF1, 0xA7, 0x36, 0xF1, 0x98, 0xAA, + 0x58, 0x33, 0x27, 0xAC, 0x73, 0x1F, 0x86, 0x36 + }, + { + 0x92, 0xDA, 0x8E, 0xF3, 0x5A, 0x63, 0xB9, 0xB1, + 0x4B, 0xC8, 0xA6, 0xA8, 0xD1, 0x4F, 0xB1, 0x8F, + 0x45, 0x76, 0x8B, 0x4C, 0x38, 0xAD, 0x48, 0xBB, + 0x7E, 0x80, 0xAD, 0xCE, 0xCC, 0x70, 0x15, 0xE2 + }, +}; + + + + +static const uint8_t blake2bp_kat[BLAKE2_KAT_LENGTH][BLAKE2B_OUTBYTES] = +{ + { + 0xB5, 0xEF, 0x81, 0x1A, 0x80, 0x38, 0xF7, 0x0B, + 0x62, 0x8F, 0xA8, 0xB2, 0x94, 0xDA, 0xAE, 0x74, + 0x92, 0xB1, 0xEB, 0xE3, 0x43, 0xA8, 0x0E, 0xAA, + 0xBB, 0xF1, 0xF6, 0xAE, 0x66, 0x4D, 0xD6, 0x7B, + 0x9D, 0x90, 0xB0, 0x12, 0x07, 0x91, 0xEA, 0xB8, + 0x1D, 0xC9, 0x69, 0x85, 0xF2, 0x88, 0x49, 0xF6, + 0xA3, 0x05, 0x18, 0x6A, 0x85, 0x50, 0x1B, 0x40, + 0x51, 0x14, 0xBF, 0xA6, 0x78, 0xDF, 0x93, 0x80 + }, + { + 0xA1, 0x39, 0x28, 0x0E, 0x72, 0x75, 0x7B, 0x72, + 0x3E, 0x64, 0x73, 0xD5, 0xBE, 0x59, 0xF3, 0x6E, + 0x9D, 0x50, 0xFC, 0x5C, 0xD7, 0xD4, 0x58, 0x5C, + 0xBC, 0x09, 0x80, 0x48, 0x95, 0xA3, 0x6C, 0x52, + 0x12, 0x42, 0xFB, 0x27, 0x89, 0xF8, 0x5C, 0xB9, + 0xE3, 0x54, 0x91, 0xF3, 0x1D, 0x4A, 0x69, 0x52, + 0xF9, 0xD8, 0xE0, 0x97, 0xAE, 0xF9, 0x4F, 0xA1, + 0xCA, 0x0B, 0x12, 0x52, 0x57, 0x21, 0xF0, 0x3D + }, + { + 0xEF, 0x8C, 0xDA, 0x96, 0x35, 0xD5, 0x06, 0x3A, + 0xF8, 0x11, 0x15, 0xDA, 0x3C, 0x52, 0x32, 0x5A, + 0x86, 0xE8, 0x40, 0x74, 0xF9, 0xF7, 0x24, 0xB7, + 0xCB, 0xD0, 0xB0, 0x85, 0x6F, 0xF0, 0x01, 0x77, + 0xCD, 0xD2, 0x83, 0xC2, 0x98, 0x32, 0x6C, 0xD0, + 0x91, 0x77, 0x54, 0xC5, 0x24, 0x1F, 0x14, 0x80, + 0xFB, 0x50, 0x9C, 0xF2, 0xD2, 0xC4, 0x49, 0x81, + 0x80, 0x77, 0xAE, 0x35, 0xFC, 0x33, 0x07, 0x37 + }, + { + 0x8C, 0xF9, 0x33, 0xA2, 0xD3, 0x61, 0xA3, 0xE6, + 0xA1, 0x36, 0xDB, 0xE4, 0xA0, 0x1E, 0x79, 0x03, + 0x79, 0x7A, 0xD6, 0xCE, 0x76, 0x6E, 0x2B, 0x91, + 0xB9, 0xB4, 0xA4, 0x03, 0x51, 0x27, 0xD6, 0x5F, + 0x4B, 0xE8, 0x65, 0x50, 0x11, 0x94, 0x18, 0xE2, + 0x2D, 0xA0, 0x0F, 0xD0, 0x6B, 0xF2, 0xB2, 0x75, + 0x96, 0xB3, 0x7F, 0x06, 0xBE, 0x0A, 0x15, 0x4A, + 0xAF, 0x7E, 0xCA, 0x54, 0xC4, 0x52, 0x0B, 0x97 + }, + { + 0x24, 0xDC, 0x1E, 0x6D, 0xC4, 0xE5, 0x1A, 0x3A, + 0x3C, 0x8D, 0xA6, 0x7A, 0xAC, 0xB4, 0xC5, 0x41, + 0xE4, 0x18, 0x18, 0xD1, 0x80, 0xE5, 0xBB, 0x69, + 0x75, 0x3D, 0xBB, 0xFF, 0x2F, 0x44, 0xD0, 0xE7, + 0xDA, 0x83, 0x03, 0x86, 0xBF, 0xC8, 0x3B, 0x27, + 0xA5, 0x9D, 0xBB, 0x62, 0xB9, 0x64, 0xFC, 0x8E, + 0xA6, 0xCB, 0xDF, 0x30, 0x49, 0xBF, 0xF8, 0x1F, + 0x24, 0xF3, 0x48, 0xDB, 0x4E, 0xFD, 0x0D, 0x07 + }, + { + 0xBC, 0x23, 0xF5, 0xAB, 0xDF, 0xFD, 0x6A, 0x32, + 0xA5, 0xD4, 0x08, 0x11, 0x26, 0x2E, 0xD4, 0x47, + 0x9E, 0xF7, 0x0B, 0x42, 0x33, 0xCA, 0x20, 0x5B, + 0xC5, 0xB9, 0xBF, 0x85, 0x96, 0x73, 0x19, 0x82, + 0xD0, 0x41, 0x69, 0xA9, 0x04, 0xDD, 0x43, 0xB0, + 0xE0, 0xF9, 0x48, 0x99, 0xF7, 0x33, 0x02, 0x2D, + 0x24, 0xD8, 0x4F, 0xAD, 0x0A, 0x99, 0x16, 0x00, + 0xF1, 0x97, 0x9B, 0x27, 0x2A, 0xD6, 0x20, 0x73 + }, + { + 0xEF, 0x10, 0x7F, 0xCD, 0x0D, 0x92, 0xD8, 0x4E, + 0xF5, 0xEF, 0x94, 0x63, 0xE6, 0xE9, 0x62, 0x41, + 0x25, 0x45, 0x29, 0xD2, 0xB9, 0x7F, 0xDB, 0xE5, + 0x64, 0x19, 0x07, 0x0A, 0xDB, 0xC7, 0xD5, 0x70, + 0x6F, 0xEB, 0x8F, 0x44, 0x95, 0x79, 0x81, 0x9E, + 0xD4, 0xBE, 0x61, 0x97, 0x85, 0xFF, 0xFA, 0xAF, + 0x0D, 0x97, 0x89, 0xCF, 0xE7, 0x26, 0x24, 0x9A, + 0xB0, 0x8C, 0x94, 0x68, 0xCB, 0x5F, 0xDE, 0x22 + }, + { + 0x23, 0x1F, 0xBF, 0xB7, 0xA1, 0xDD, 0xC5, 0xB7, + 0x49, 0x33, 0xA2, 0x85, 0xA4, 0x22, 0x4C, 0x04, + 0x9C, 0xBA, 0x14, 0x85, 0xCE, 0x35, 0x64, 0x0D, + 0x9C, 0x51, 0x6E, 0xD7, 0x8E, 0xAA, 0x22, 0x6D, + 0x36, 0xF6, 0x5B, 0x25, 0x89, 0xB8, 0x26, 0xC4, + 0x59, 0xFA, 0x6A, 0x91, 0xC4, 0x26, 0xFD, 0x2A, + 0x8A, 0xB4, 0x61, 0xC9, 0x76, 0x7E, 0x7B, 0xDD, + 0x99, 0x6B, 0xEF, 0x5A, 0x78, 0xF4, 0x81, 0xB7 + }, + { + 0x3A, 0x83, 0x1F, 0x2D, 0xA9, 0x69, 0xB9, 0xB7, + 0x36, 0x0E, 0x74, 0xEE, 0x53, 0xB5, 0x18, 0x98, + 0x0A, 0x5E, 0xBC, 0xDF, 0xD4, 0xEE, 0x23, 0xED, + 0x80, 0x5C, 0x26, 0x39, 0x4D, 0x18, 0x24, 0x20, + 0x8D, 0x7E, 0x8F, 0x63, 0x27, 0xD4, 0xEC, 0x87, + 0x97, 0x9C, 0xE4, 0xAF, 0x8A, 0xB0, 0x97, 0xD6, + 0x9E, 0x26, 0x1C, 0xA3, 0x2D, 0xB0, 0xEE, 0xFD, + 0xBC, 0x18, 0xD1, 0x63, 0x77, 0xA6, 0xBD, 0x20 + }, + { + 0x83, 0x49, 0xA2, 0x0F, 0xDD, 0xBA, 0xE1, 0xD8, + 0x47, 0x2B, 0x67, 0xF0, 0x34, 0x7A, 0xA0, 0xFD, + 0x40, 0x4D, 0x65, 0xC6, 0xFA, 0x14, 0x72, 0xB3, + 0x10, 0x39, 0x0D, 0x75, 0x65, 0xBA, 0x6B, 0xC1, + 0x02, 0x60, 0xD3, 0xDC, 0xE6, 0xA1, 0x4F, 0x4D, + 0xD9, 0xB8, 0xB3, 0xE0, 0xA0, 0xC4, 0x7F, 0x6D, + 0xB7, 0xE7, 0x10, 0x0A, 0x7A, 0x9B, 0x64, 0xA8, + 0x44, 0xF0, 0x10, 0x64, 0xD0, 0x79, 0x05, 0xC5 + }, + { + 0x23, 0x9A, 0xE3, 0xD6, 0x85, 0x9C, 0x7C, 0x97, + 0x2A, 0x5D, 0xC8, 0xB9, 0xC5, 0x5A, 0xEB, 0x93, + 0x85, 0x90, 0xCF, 0xB8, 0x55, 0x2A, 0xA3, 0x05, + 0xA6, 0xF6, 0xF3, 0x1F, 0xFA, 0x95, 0xA8, 0x40, + 0xF4, 0xEC, 0x36, 0xF6, 0xFB, 0x8F, 0x83, 0xB6, + 0x9C, 0x1D, 0xA9, 0x81, 0xFC, 0x9B, 0xA1, 0x63, + 0x60, 0xDB, 0x0F, 0x4F, 0x7C, 0x68, 0xEB, 0x54, + 0x3E, 0xD5, 0x8B, 0x28, 0x75, 0x6A, 0x1E, 0x0D + }, + { + 0x7C, 0x56, 0x73, 0x28, 0x63, 0x08, 0x40, 0x8F, + 0xBC, 0x62, 0x24, 0x0E, 0x07, 0x47, 0x28, 0xB2, + 0x7A, 0x57, 0x5C, 0xAD, 0x2A, 0x15, 0x6E, 0x00, + 0xB5, 0xC0, 0x8B, 0x21, 0x8D, 0x88, 0x87, 0x79, + 0x1E, 0x47, 0xBF, 0x10, 0xB0, 0xBC, 0x61, 0xA5, + 0x82, 0x54, 0x5A, 0x24, 0x69, 0x63, 0x9C, 0xE6, + 0x28, 0xC4, 0x0F, 0x20, 0xEA, 0x8B, 0x84, 0x9C, + 0xD0, 0x05, 0x44, 0x5F, 0x29, 0xA0, 0x8C, 0xCE + }, + { + 0xDD, 0x07, 0x7E, 0x76, 0x9E, 0x0D, 0xEF, 0x78, + 0xDD, 0x7A, 0xAD, 0xD5, 0x7D, 0x58, 0x42, 0x1B, + 0xDA, 0x3A, 0x1A, 0x4E, 0x69, 0x72, 0x05, 0x9F, + 0x8E, 0x64, 0x9C, 0xD6, 0xBC, 0xA4, 0x4A, 0x13, + 0xAB, 0x71, 0xEB, 0x53, 0x5D, 0x24, 0x49, 0x22, + 0x94, 0x84, 0x65, 0xD7, 0x3B, 0xD6, 0x4E, 0xFB, + 0x09, 0x10, 0x46, 0x94, 0x90, 0x66, 0x65, 0x36, + 0x03, 0x57, 0x5A, 0x2E, 0x89, 0x1E, 0xBD, 0x54 + }, + { + 0xB3, 0x6C, 0xEF, 0x28, 0x53, 0x2B, 0x40, 0xD8, + 0x17, 0x86, 0x28, 0xF0, 0xFA, 0xB5, 0xE5, 0xB4, + 0xA1, 0xDE, 0xC0, 0xC0, 0xE9, 0x11, 0xD7, 0x27, + 0xBF, 0x09, 0x49, 0x0F, 0x5E, 0x8D, 0x9F, 0xAC, + 0x57, 0x21, 0x3F, 0xD2, 0xA2, 0xD1, 0x2E, 0xD3, + 0xD7, 0x7A, 0x41, 0xF5, 0xE2, 0xFE, 0xCC, 0x40, + 0xE4, 0xEE, 0xCA, 0x16, 0x12, 0xF5, 0x1C, 0x45, + 0x23, 0x31, 0xAE, 0x93, 0x96, 0x62, 0x35, 0xBC + }, + { + 0xDE, 0x73, 0x7D, 0xBC, 0x61, 0x2E, 0xBD, 0x31, + 0xBC, 0x49, 0xA2, 0xD7, 0xC6, 0x44, 0xD4, 0xB1, + 0x37, 0x81, 0x74, 0x19, 0x42, 0x1C, 0x32, 0xF4, + 0xE7, 0x51, 0x14, 0xD8, 0x99, 0xE3, 0x13, 0x1D, + 0x45, 0xCA, 0x54, 0x51, 0x24, 0x8F, 0x24, 0x16, + 0x9F, 0xBF, 0x17, 0xEE, 0x60, 0xA9, 0xB7, 0x07, + 0x98, 0xA4, 0xB9, 0x37, 0xCE, 0xA6, 0x27, 0x95, + 0x28, 0x96, 0x39, 0xD1, 0x8F, 0xCD, 0x89, 0xE4 + }, + { + 0xB4, 0xC1, 0xBB, 0xCB, 0xBC, 0xCD, 0xFC, 0xE4, + 0xD2, 0xBE, 0x9D, 0xCD, 0xB9, 0x83, 0xC1, 0xB0, + 0x20, 0xC5, 0xF7, 0x20, 0xDA, 0x5B, 0xEC, 0xF4, + 0xCB, 0x2A, 0x9A, 0x3D, 0x1B, 0x8D, 0x23, 0xCE, + 0xA7, 0xA9, 0xF5, 0xFD, 0x70, 0xD3, 0x74, 0x0E, + 0xCD, 0x67, 0xCE, 0x7D, 0x1E, 0x9C, 0x5E, 0x31, + 0xA3, 0x30, 0x2D, 0xF6, 0x6A, 0x9B, 0x5D, 0x54, + 0x30, 0x44, 0x90, 0xFB, 0xE1, 0xC4, 0xA8, 0xB9 + }, + { + 0xB1, 0xD6, 0x5E, 0x70, 0xC6, 0x9B, 0xA7, 0xE3, + 0xA7, 0x28, 0xE8, 0xB6, 0x44, 0x94, 0x93, 0xF2, + 0x37, 0x51, 0x0B, 0x23, 0xB6, 0xE7, 0x7D, 0x95, + 0x84, 0xD0, 0x5F, 0xF4, 0xD3, 0xF0, 0x87, 0x80, + 0x92, 0x9D, 0x74, 0xFA, 0x5B, 0xED, 0x9B, 0x75, + 0xD4, 0xD6, 0xD1, 0xCA, 0x91, 0xAB, 0x8D, 0x26, + 0x37, 0xDC, 0x2E, 0x79, 0xBA, 0x0F, 0xE0, 0x59, + 0x4A, 0xCD, 0x68, 0xFB, 0x3C, 0xC6, 0x60, 0xB9 + }, + { + 0xDA, 0x79, 0xF7, 0x29, 0xEA, 0xB9, 0x8C, 0x04, + 0xF3, 0x7F, 0xCC, 0x85, 0x4B, 0x69, 0xA8, 0x4E, + 0x46, 0x7D, 0xEA, 0x1E, 0x77, 0x82, 0xE7, 0xAF, + 0x02, 0xCB, 0x44, 0xA4, 0x9D, 0x21, 0x0D, 0x25, + 0x23, 0x68, 0x3D, 0x42, 0x0A, 0xC1, 0xDE, 0xC8, + 0xAD, 0x1F, 0xB4, 0x0E, 0x65, 0xAB, 0x3F, 0xE2, + 0x51, 0xA8, 0x51, 0xE2, 0x83, 0xD8, 0x58, 0x38, + 0x08, 0x42, 0x61, 0x30, 0x1E, 0xCD, 0x08, 0x9B + }, + { + 0x71, 0x40, 0x40, 0x40, 0x39, 0x21, 0xAE, 0x55, + 0x48, 0xA2, 0x03, 0x39, 0xD6, 0x9E, 0x09, 0x3F, + 0x60, 0x9A, 0xA9, 0x9C, 0x22, 0xDB, 0x72, 0x59, + 0x1D, 0x1E, 0xF4, 0xFC, 0xB0, 0xAF, 0x01, 0x61, + 0x73, 0xE5, 0x77, 0xD8, 0xC1, 0xA3, 0x06, 0x3B, + 0x44, 0x3A, 0x0E, 0x48, 0xF3, 0x13, 0xCF, 0x2E, + 0x0F, 0x9B, 0x0C, 0x2E, 0xF9, 0x6A, 0x96, 0xC4, + 0x24, 0x32, 0x2C, 0xCC, 0x0C, 0xD5, 0x30, 0x4C + }, + { + 0x8B, 0x2E, 0x8C, 0x3F, 0x0E, 0x3C, 0x31, 0x9B, + 0xA6, 0x7E, 0x86, 0x01, 0x4B, 0xDA, 0x68, 0x3E, + 0x53, 0x57, 0xA0, 0x40, 0x37, 0xB4, 0x56, 0x32, + 0x86, 0xAC, 0x89, 0xCD, 0xDB, 0x7E, 0xE0, 0x4C, + 0xF6, 0x67, 0x5F, 0x9A, 0xB6, 0x1F, 0xC8, 0x33, + 0x2D, 0x21, 0x8D, 0x2B, 0xCA, 0x97, 0x15, 0xE7, + 0xDB, 0xE5, 0x83, 0x72, 0xD1, 0xEE, 0xBF, 0x6B, + 0xC2, 0x94, 0x84, 0x71, 0xCF, 0xCE, 0xBB, 0x77 + }, + { + 0x32, 0xEE, 0x95, 0x49, 0xD4, 0xE3, 0x2F, 0x4B, + 0xE9, 0xC5, 0x00, 0xBD, 0x85, 0x43, 0xAF, 0xD0, + 0xB6, 0x97, 0x82, 0xD0, 0xB3, 0xFF, 0x7E, 0xD4, + 0x7A, 0x88, 0x1A, 0x0E, 0x49, 0x1F, 0x37, 0x65, + 0x0A, 0x21, 0xB2, 0x6C, 0x3F, 0x5D, 0x0A, 0x64, + 0xE0, 0x90, 0x58, 0xB3, 0x00, 0x4A, 0x23, 0x68, + 0xB9, 0x50, 0xE4, 0x72, 0x30, 0xC2, 0x29, 0x66, + 0xD3, 0xF7, 0x9D, 0xA7, 0xBA, 0xA0, 0xB8, 0x7F + }, + { + 0xCA, 0xE7, 0xF2, 0x92, 0x71, 0x37, 0x82, 0xC4, + 0x71, 0xFE, 0x31, 0x78, 0xA9, 0x42, 0x0C, 0xD4, + 0xC1, 0x1F, 0xCD, 0x3F, 0x6D, 0xBE, 0x5D, 0x15, + 0xC8, 0x4A, 0xB7, 0x35, 0x3C, 0x73, 0x9E, 0xF0, + 0x64, 0x16, 0x39, 0xA2, 0xF9, 0x2A, 0xED, 0x31, + 0xC5, 0x6A, 0x20, 0x21, 0xCC, 0x5E, 0x58, 0xCB, + 0xEA, 0xD3, 0x74, 0xE2, 0xDC, 0x8A, 0x0D, 0xBC, + 0xE5, 0x45, 0x0F, 0xE7, 0xA0, 0x18, 0xCF, 0xA4 + }, + { + 0xF1, 0x7F, 0xEF, 0xAE, 0xAE, 0x7D, 0x40, 0xCD, + 0x88, 0x5D, 0xAC, 0x0B, 0xC3, 0x50, 0xC0, 0x27, + 0x36, 0x68, 0xEA, 0x02, 0x22, 0xDF, 0x5C, 0x75, + 0x69, 0x4F, 0x5C, 0xB3, 0xA3, 0x21, 0x51, 0x9F, + 0x6E, 0x0E, 0xC4, 0x3B, 0xA0, 0xC8, 0x59, 0x3D, + 0xC7, 0x34, 0x13, 0x41, 0xE5, 0x19, 0x48, 0x8F, + 0x20, 0xAB, 0xD5, 0xB8, 0x12, 0x4D, 0xFA, 0xCE, + 0xA5, 0xCD, 0xE0, 0x96, 0x5B, 0x69, 0x70, 0xF9 + }, + { + 0xE2, 0xCF, 0x86, 0xDD, 0xC8, 0x42, 0x4E, 0xE5, + 0x47, 0xEB, 0x72, 0x45, 0xB7, 0x32, 0x5E, 0x02, + 0xF2, 0xE3, 0xAC, 0x01, 0x3C, 0x8D, 0x38, 0x6B, + 0x3D, 0x2E, 0x09, 0x20, 0x8A, 0x9B, 0xCC, 0x0B, + 0x44, 0xC4, 0xC4, 0x38, 0xEA, 0xAF, 0x52, 0xD2, + 0x07, 0x7E, 0x91, 0x77, 0xEB, 0x8E, 0xE1, 0xD5, + 0x90, 0x75, 0xB5, 0x25, 0x92, 0x20, 0x20, 0x62, + 0x22, 0x93, 0x54, 0xBF, 0x23, 0xC9, 0x62, 0x39 + }, + { + 0x38, 0xF2, 0x6A, 0x11, 0x02, 0xCB, 0x16, 0x2D, + 0x35, 0x1F, 0x84, 0x3B, 0x3C, 0x49, 0xF6, 0xFF, + 0x85, 0x44, 0x16, 0x33, 0xB6, 0x70, 0x4A, 0x28, + 0x6A, 0xF8, 0x1C, 0xCB, 0xAE, 0x5A, 0x67, 0xD3, + 0x01, 0x5C, 0xC0, 0xEF, 0xAF, 0xB7, 0x05, 0x7D, + 0xC2, 0xB2, 0x8D, 0x67, 0x66, 0xE8, 0x2A, 0x06, + 0x8A, 0x4C, 0x0B, 0x52, 0x4B, 0x66, 0xD0, 0xA6, + 0x32, 0x77, 0x5D, 0x93, 0x06, 0x15, 0x75, 0xF9 + }, + { + 0xA2, 0xC4, 0x30, 0x2D, 0xAC, 0xA7, 0xA7, 0xC6, + 0x32, 0xF6, 0x76, 0x30, 0x4E, 0x62, 0x75, 0xC1, + 0xC1, 0xF0, 0xDB, 0xFE, 0x38, 0xDC, 0x57, 0x1C, + 0xB2, 0x3E, 0x1F, 0x7B, 0xA5, 0xDC, 0x18, 0x18, + 0x0F, 0xC4, 0x8A, 0x01, 0x5F, 0x92, 0x7C, 0x89, + 0x96, 0x7C, 0x1E, 0x10, 0x4E, 0x66, 0xF5, 0xEA, + 0x5B, 0x2D, 0xD3, 0x1D, 0x78, 0x1C, 0x38, 0x49, + 0xBF, 0xC6, 0x49, 0x22, 0x0C, 0x38, 0x5C, 0x82 + }, + { + 0xC1, 0x9C, 0x6B, 0x3F, 0xB5, 0x35, 0x2B, 0xB3, + 0x94, 0xC2, 0x68, 0x46, 0x52, 0x3C, 0x25, 0xE8, + 0x26, 0x5D, 0x50, 0x5F, 0x50, 0x1F, 0x96, 0x03, + 0xA4, 0xF8, 0xBD, 0x55, 0x38, 0x6C, 0xF4, 0xCC, + 0x9F, 0x4D, 0x71, 0xF3, 0x8F, 0xF4, 0x45, 0xF4, + 0xEF, 0xC8, 0x30, 0x98, 0xD4, 0x79, 0x69, 0x33, + 0x4E, 0x79, 0xA2, 0xBC, 0xB4, 0x02, 0x6B, 0xC6, + 0x3B, 0x79, 0x59, 0xDE, 0xDB, 0x62, 0xB7, 0xBD + }, + { + 0x1F, 0x4A, 0xB9, 0x84, 0x0A, 0x1C, 0xFA, 0x8F, + 0xE6, 0xC5, 0x62, 0x2D, 0x9B, 0x53, 0x8B, 0xEC, + 0xB8, 0x80, 0x7A, 0x87, 0x78, 0xB6, 0x9D, 0x93, + 0x05, 0xF9, 0x08, 0x57, 0x65, 0x73, 0xB2, 0x0C, + 0xA3, 0x70, 0x4E, 0x89, 0x12, 0x97, 0x26, 0xD5, + 0x02, 0xE1, 0x98, 0x58, 0x8D, 0x07, 0x26, 0x68, + 0xBF, 0x03, 0x63, 0x0B, 0x5B, 0x5A, 0x92, 0x32, + 0xFF, 0x39, 0x25, 0x27, 0x24, 0x9D, 0xF9, 0x9B + }, + { + 0xFE, 0x03, 0x17, 0x7B, 0x58, 0xB4, 0x88, 0x83, + 0xA8, 0x6D, 0x42, 0x68, 0x33, 0x4B, 0x95, 0x91, + 0xD9, 0xFB, 0xD8, 0xBF, 0x7C, 0xC2, 0xAA, 0xCC, + 0x50, 0x25, 0xEF, 0x47, 0x6B, 0x45, 0x33, 0xBA, + 0x7B, 0xD7, 0x81, 0xDF, 0x01, 0x11, 0x47, 0xB3, + 0xCF, 0x51, 0x1D, 0x8B, 0x3D, 0xCD, 0x8C, 0x78, + 0x0D, 0x30, 0xD7, 0xDA, 0x71, 0x8C, 0x22, 0x44, + 0x23, 0x19, 0x81, 0x7B, 0xE3, 0x18, 0x6B, 0xC5 + }, + { + 0xF4, 0xC3, 0xB0, 0x59, 0x10, 0x5B, 0x6A, 0xA5, + 0xFE, 0x78, 0x84, 0x3A, 0x07, 0xD9, 0x4F, 0x71, + 0x20, 0x62, 0xCB, 0x5A, 0x4D, 0xD6, 0x05, 0x9F, + 0x97, 0x90, 0x4D, 0x0C, 0x57, 0x97, 0x3B, 0xA8, + 0xDF, 0x71, 0xD1, 0x5A, 0x51, 0x1A, 0x06, 0x68, + 0x64, 0xFE, 0x45, 0x5E, 0xDC, 0x9E, 0x5F, 0x16, + 0x52, 0x4C, 0xEC, 0x7E, 0xE2, 0x48, 0xEE, 0x3E, + 0xC9, 0x29, 0x06, 0x3B, 0xD1, 0x07, 0x98, 0xDA + }, + { + 0x57, 0xA1, 0x6F, 0x96, 0x4B, 0x18, 0x1B, 0x12, + 0x03, 0xA5, 0x80, 0x3B, 0x73, 0x81, 0x7D, 0x77, + 0x44, 0x83, 0x82, 0x6C, 0xEA, 0x11, 0x3B, 0x9C, + 0xCF, 0xCF, 0x0E, 0xB8, 0x7C, 0xB2, 0x30, 0x64, + 0x28, 0x49, 0x62, 0xD8, 0x47, 0xBB, 0x1F, 0xAE, + 0x8C, 0xBF, 0x5C, 0xC6, 0x3B, 0x3C, 0xEA, 0xA1, + 0x24, 0x1E, 0xA4, 0x2C, 0x63, 0xF8, 0x98, 0x01, + 0x1F, 0xC4, 0xDB, 0xCA, 0xE6, 0xF5, 0xE8, 0xC5 + }, + { + 0x79, 0x52, 0xFC, 0x83, 0xAC, 0xF1, 0x3A, 0x95, + 0xCA, 0x9C, 0x27, 0xA2, 0x15, 0x6D, 0x9C, 0x1B, + 0x63, 0x00, 0xB0, 0xEF, 0x79, 0x0F, 0x57, 0x2B, + 0xC3, 0x94, 0xC6, 0x77, 0xF7, 0xC1, 0x46, 0x29, + 0xEB, 0xD8, 0xE7, 0xD5, 0xD7, 0xC7, 0xF1, 0xA5, + 0xEB, 0xBD, 0xC3, 0x90, 0xCC, 0x08, 0xCD, 0x58, + 0xC2, 0x00, 0x89, 0x00, 0xCB, 0x55, 0xEB, 0x05, + 0xE4, 0x44, 0xA6, 0x8C, 0x3B, 0x39, 0x3E, 0x60 + }, + { + 0x2C, 0x22, 0x40, 0xD6, 0xB5, 0x41, 0xF4, 0x29, + 0x4F, 0xF9, 0x76, 0x79, 0x1D, 0x35, 0xE6, 0xA2, + 0xD4, 0x92, 0xF5, 0x7A, 0x91, 0x5F, 0xBA, 0xC5, + 0x83, 0x26, 0x60, 0xC1, 0x0E, 0x9C, 0x96, 0x46, + 0x5C, 0x7B, 0xD5, 0xFC, 0xA7, 0x51, 0xBF, 0x68, + 0xE2, 0x67, 0x3A, 0x63, 0x8E, 0x3A, 0xF7, 0x35, + 0xB0, 0x20, 0x91, 0xD7, 0x5D, 0x1A, 0x7F, 0x89, + 0xE3, 0xF7, 0x61, 0xC5, 0xDF, 0x82, 0x1A, 0x6B + }, + { + 0x59, 0xDC, 0x84, 0x6D, 0x34, 0x05, 0xCC, 0xD8, + 0x06, 0xF8, 0xFA, 0x20, 0xC8, 0x96, 0x9E, 0xF6, + 0x8A, 0x43, 0x85, 0xEF, 0x6C, 0x27, 0x4E, 0xEE, + 0x6D, 0xC0, 0x69, 0x2C, 0x3E, 0xCF, 0xB1, 0xA8, + 0x34, 0xCE, 0x64, 0x43, 0x76, 0xC5, 0x2B, 0x80, + 0x42, 0x1B, 0xAE, 0x94, 0xD6, 0xC7, 0xFD, 0xCC, + 0xA5, 0xA8, 0xF1, 0x85, 0x9C, 0x45, 0xA1, 0x0C, + 0x4E, 0xB2, 0x74, 0x82, 0x6F, 0x1F, 0x08, 0x9F + }, + { + 0xB7, 0x52, 0x96, 0x27, 0x07, 0xA1, 0x7B, 0x66, + 0x4F, 0xAE, 0xB3, 0x13, 0xE2, 0xB9, 0x52, 0xDC, + 0x03, 0xE7, 0x4A, 0x7E, 0x94, 0x47, 0x09, 0x8A, + 0xA6, 0xD4, 0xEA, 0x5B, 0xD2, 0x87, 0xD0, 0x7A, + 0x12, 0x25, 0xEC, 0xED, 0xA9, 0x81, 0x15, 0x70, + 0x58, 0x0A, 0x51, 0x2B, 0x2B, 0x20, 0xB3, 0xFC, + 0xFC, 0xA7, 0x0B, 0x44, 0xF6, 0x45, 0x4E, 0xF3, + 0xC3, 0x52, 0x4C, 0xCA, 0x6B, 0x69, 0x47, 0x5B + }, + { + 0xDA, 0x0D, 0x8E, 0x54, 0x61, 0xF8, 0x10, 0x24, + 0xEF, 0xFE, 0xED, 0x5D, 0x70, 0x76, 0xA0, 0x4F, + 0xED, 0xED, 0xAC, 0x57, 0xE7, 0xC9, 0x8A, 0x59, + 0x45, 0xBF, 0xDE, 0x66, 0x75, 0x58, 0x18, 0x85, + 0x1B, 0xE1, 0x13, 0x6B, 0x71, 0xF4, 0x33, 0xA5, + 0x6B, 0xDA, 0x18, 0x41, 0xAE, 0x71, 0x39, 0x2C, + 0x4B, 0x82, 0x90, 0x82, 0x63, 0x59, 0xF5, 0x87, + 0x22, 0x3C, 0x3E, 0xF7, 0x37, 0xFF, 0x73, 0x2A + }, + { + 0xED, 0xB8, 0x6A, 0x23, 0x7C, 0x6F, 0x13, 0x7D, + 0xFB, 0xB3, 0x47, 0x01, 0x1E, 0xDB, 0x4C, 0x6E, + 0x86, 0x1F, 0x4D, 0x58, 0x14, 0x60, 0x85, 0x46, + 0x34, 0x41, 0x04, 0x2F, 0xA3, 0x63, 0x16, 0xF1, + 0xFA, 0xF8, 0x87, 0x11, 0xBB, 0x0F, 0x18, 0x11, + 0xDF, 0xBB, 0xBF, 0xA7, 0xB5, 0x1F, 0x9C, 0xE2, + 0xD4, 0x96, 0x05, 0x24, 0x3E, 0xD0, 0x16, 0xCB, + 0xAD, 0x68, 0x85, 0xEA, 0xE2, 0x03, 0x67, 0x4F + }, + { + 0xE6, 0xD8, 0xE0, 0xFB, 0xAA, 0x29, 0xDB, 0xEB, + 0x60, 0xF3, 0xC7, 0xF9, 0x85, 0xBA, 0xD7, 0x54, + 0xD7, 0x21, 0xAA, 0xC6, 0x3D, 0xA6, 0xF4, 0x49, + 0x0C, 0x9D, 0x7E, 0xA2, 0x31, 0xD2, 0x62, 0x2F, + 0xDF, 0xDE, 0xF1, 0x48, 0xD0, 0xCA, 0x44, 0x2B, + 0x8D, 0x59, 0xCF, 0x3E, 0x4F, 0x98, 0x35, 0xCB, + 0xC2, 0x40, 0xAF, 0x40, 0xFB, 0xA6, 0x3A, 0x2E, + 0xA5, 0xA2, 0x35, 0xD4, 0x6E, 0xEA, 0x6E, 0xAC + }, + { + 0xD4, 0xE4, 0x63, 0xC4, 0x88, 0x29, 0x87, 0xEB, + 0x44, 0xA5, 0xED, 0x0C, 0x82, 0x1D, 0x68, 0xB0, + 0xFE, 0xF9, 0x9D, 0x6F, 0x53, 0xA5, 0x7B, 0xF3, + 0x19, 0xBD, 0xAC, 0x25, 0xAC, 0x38, 0xEB, 0x0B, + 0x23, 0xE1, 0x13, 0x8C, 0x00, 0x12, 0xF5, 0xF3, + 0x83, 0x46, 0xA1, 0xDE, 0x9D, 0x4A, 0x99, 0x2A, + 0x64, 0xB9, 0x42, 0x83, 0x4A, 0x85, 0x6E, 0xFB, + 0xAA, 0x06, 0x20, 0xBD, 0xA2, 0x9F, 0x6A, 0x86 + }, + { + 0x42, 0xD8, 0x10, 0xD0, 0x1C, 0x2D, 0xA2, 0x47, + 0x35, 0xF0, 0x4A, 0x5E, 0x90, 0x13, 0x38, 0xFD, + 0xFC, 0x2D, 0xE1, 0x71, 0x5F, 0xF6, 0x64, 0x3A, + 0x37, 0x2F, 0x88, 0x0E, 0x6C, 0x5C, 0x6C, 0x13, + 0xD2, 0xB3, 0xAD, 0x70, 0x77, 0x46, 0x9D, 0x64, + 0x33, 0x54, 0x05, 0x4D, 0x32, 0xDD, 0x80, 0x49, + 0xEA, 0x63, 0x73, 0x2B, 0x57, 0x45, 0xBD, 0xB2, + 0x3B, 0xE2, 0xB5, 0x8E, 0x48, 0xC1, 0x01, 0x3A + }, + { + 0xCF, 0xBF, 0x54, 0x30, 0x07, 0x6F, 0x82, 0x5A, + 0x3B, 0xBB, 0x88, 0xC1, 0xBC, 0x0A, 0xEF, 0x61, + 0x25, 0x9E, 0x8F, 0x4D, 0x5F, 0xA3, 0x3C, 0x39, + 0x82, 0x50, 0x62, 0xF1, 0x5D, 0x19, 0xFD, 0x4A, + 0x01, 0x82, 0xCD, 0x97, 0x36, 0xD2, 0xAE, 0xC9, + 0x74, 0x9C, 0xCF, 0x83, 0x18, 0x6C, 0x35, 0x74, + 0xAB, 0x94, 0x42, 0x65, 0x40, 0x66, 0x0A, 0x9D, + 0xB8, 0xC3, 0xAA, 0xBB, 0xCB, 0xDD, 0x9D, 0x0F + }, + { + 0x6C, 0x24, 0x34, 0xA1, 0xAF, 0xA1, 0x57, 0xAC, + 0xCC, 0x34, 0xA5, 0xC4, 0x87, 0x2D, 0xFF, 0x69, + 0xFE, 0x7F, 0x31, 0x96, 0xCB, 0x1A, 0x75, 0x0C, + 0x54, 0x1D, 0x8B, 0x73, 0x92, 0x28, 0x88, 0xBA, + 0xBE, 0x89, 0xB1, 0xC3, 0x82, 0x02, 0x21, 0x86, + 0x20, 0xD8, 0x8D, 0x77, 0xDA, 0xD9, 0xDF, 0xBA, + 0xB3, 0xFB, 0xF7, 0x40, 0xB2, 0xD1, 0xD8, 0xF3, + 0x7E, 0xAD, 0x25, 0x8E, 0x2E, 0xF1, 0x06, 0x52 + }, + { + 0x48, 0xB7, 0x26, 0x8A, 0xA4, 0x34, 0x2F, 0xAB, + 0x02, 0x1D, 0x14, 0x72, 0xE9, 0x25, 0x7F, 0x76, + 0x58, 0x5C, 0xC5, 0x68, 0x10, 0xC8, 0xF2, 0xA6, + 0xE1, 0xD4, 0xA8, 0x94, 0x6B, 0x77, 0x71, 0x42, + 0xD4, 0x4A, 0xE5, 0x13, 0xA8, 0x80, 0x9F, 0x2D, + 0x6D, 0xC7, 0x26, 0x30, 0x5F, 0x79, 0x44, 0x60, + 0x4D, 0x95, 0x2D, 0x4A, 0x9F, 0x08, 0x5C, 0x5C, + 0x10, 0x50, 0xBA, 0xFD, 0xD2, 0x1D, 0x1E, 0x60 + }, + { + 0xCE, 0xCF, 0xCE, 0x4B, 0x12, 0xC6, 0xCF, 0x53, + 0xD1, 0xB1, 0xB2, 0xD4, 0x18, 0xA4, 0x93, 0xE3, + 0xF4, 0x29, 0x17, 0x03, 0x21, 0xE8, 0x1A, 0xA2, + 0x52, 0x63, 0xAA, 0xA7, 0x15, 0xD5, 0xCA, 0x38, + 0x9F, 0x65, 0xC3, 0xAC, 0xF9, 0x9B, 0x18, 0x0E, + 0x44, 0x6B, 0x50, 0xE6, 0x01, 0xFC, 0xBF, 0x44, + 0x61, 0xD0, 0x42, 0x6A, 0x85, 0x92, 0xA0, 0x77, + 0x42, 0x20, 0x18, 0x57, 0x12, 0x5F, 0x71, 0xEE + }, + { + 0x38, 0x5A, 0x75, 0x22, 0x42, 0xEB, 0x9E, 0xD5, + 0x6B, 0x07, 0x4B, 0x70, 0x2C, 0x91, 0xE7, 0x5A, + 0xEC, 0x0B, 0xE9, 0x06, 0x4B, 0xD9, 0xCF, 0x88, + 0x03, 0x04, 0xC2, 0x13, 0x27, 0x0C, 0xB2, 0xEA, + 0xE8, 0xE2, 0x1D, 0x9A, 0xE8, 0xC6, 0x08, 0x15, + 0x19, 0xF7, 0x5D, 0xFA, 0xBB, 0x00, 0x3B, 0x24, + 0x32, 0xB0, 0x47, 0x55, 0xB8, 0xC3, 0x2C, 0x97, + 0xAC, 0x29, 0x14, 0xE8, 0xBF, 0x45, 0xB2, 0x34 + }, + { + 0xD8, 0x9A, 0x12, 0x4A, 0x9B, 0x95, 0x8B, 0xA2, + 0x3D, 0x09, 0x20, 0x7A, 0xCF, 0xA6, 0x2A, 0x33, + 0xB8, 0x70, 0x89, 0xB2, 0x86, 0xE8, 0x43, 0x8B, + 0xDC, 0x01, 0xE2, 0x33, 0xAB, 0x2A, 0x86, 0x30, + 0xA1, 0xEE, 0xB6, 0xB2, 0xB9, 0xBA, 0x6B, 0x7D, + 0x21, 0x00, 0x10, 0x77, 0x33, 0xDE, 0xAF, 0x4C, + 0x20, 0x47, 0x8C, 0x26, 0xF2, 0x49, 0xC6, 0x89, + 0xC5, 0x26, 0x84, 0x73, 0xE2, 0xE9, 0xFA, 0x60 + }, + { + 0x43, 0xDE, 0x10, 0x92, 0xFF, 0x9F, 0xF5, 0x28, + 0x20, 0x6C, 0x6F, 0xCF, 0x81, 0x32, 0x2E, 0xAD, + 0x3D, 0x22, 0xEA, 0xA4, 0xC8, 0x54, 0x52, 0x15, + 0x77, 0xDF, 0x33, 0x62, 0x47, 0x49, 0x5C, 0xE1, + 0x72, 0xFC, 0x87, 0x39, 0x95, 0x30, 0x0B, 0x21, + 0xB9, 0x46, 0x10, 0xC9, 0xD2, 0xF6, 0x33, 0xB5, + 0x33, 0xBD, 0xE4, 0x56, 0x8C, 0xA0, 0x9C, 0x38, + 0x0E, 0x84, 0x68, 0xFE, 0x6A, 0xD8, 0xD8, 0x1D + }, + { + 0x86, 0x8B, 0x60, 0x11, 0x99, 0xEF, 0x00, 0x0B, + 0x70, 0x5C, 0xD6, 0x4D, 0x39, 0x30, 0x26, 0x2A, + 0x5A, 0xB9, 0x10, 0xE3, 0x4E, 0x2D, 0x78, 0xE8, + 0x58, 0x7B, 0x4E, 0x01, 0x0D, 0x37, 0x6D, 0xD4, + 0xA0, 0x0D, 0xE4, 0x48, 0x67, 0xD0, 0xE9, 0x33, + 0xEE, 0x39, 0xA1, 0xFA, 0x91, 0x47, 0xD4, 0x99, + 0xD1, 0x84, 0xF3, 0xA9, 0xCF, 0x35, 0x4F, 0x2D, + 0x3C, 0x51, 0x14, 0x6F, 0xF7, 0x15, 0x2D, 0x68 + }, + { + 0x15, 0x17, 0xF8, 0xF0, 0x44, 0x2F, 0x0D, 0x50, + 0xBB, 0xC0, 0xAA, 0xB6, 0x84, 0x6F, 0xDC, 0xE3, + 0xB7, 0x0F, 0xAE, 0xA4, 0xBB, 0x51, 0x13, 0xAC, + 0xB2, 0x3A, 0xBE, 0x10, 0x1D, 0x99, 0xA4, 0x0A, + 0x1B, 0x76, 0xC1, 0xE8, 0xDC, 0x2E, 0xA1, 0x93, + 0x62, 0x94, 0x82, 0x3A, 0xD8, 0x35, 0x4C, 0x11, + 0xE2, 0xE9, 0x6C, 0x67, 0x12, 0xBE, 0x4C, 0xF7, + 0x7C, 0x58, 0x3F, 0xD0, 0x6B, 0x5E, 0x5C, 0x55 + }, + { + 0xAF, 0x4C, 0x6C, 0x67, 0xC5, 0xCA, 0x38, 0x38, + 0x73, 0x48, 0xCA, 0x3E, 0xC2, 0xBE, 0xD7, 0xFB, + 0xA8, 0xC2, 0xB3, 0xD2, 0x2D, 0xE1, 0x48, 0xD0, + 0x8A, 0x61, 0x8C, 0x29, 0x70, 0x23, 0xFB, 0x7B, + 0x6D, 0x2C, 0x15, 0x3D, 0x5E, 0xFC, 0xD1, 0x68, + 0x89, 0x99, 0x91, 0x0B, 0x20, 0xE1, 0xEA, 0xC7, + 0xC1, 0x00, 0xA2, 0xC5, 0xA6, 0xC1, 0xAC, 0xF5, + 0xE9, 0x8F, 0x14, 0x3B, 0x41, 0xDC, 0x8A, 0x12 + }, + { + 0xA2, 0xAD, 0x94, 0x24, 0x3B, 0x8E, 0xEA, 0x68, + 0xF5, 0xFA, 0xDD, 0x69, 0x08, 0xAD, 0xB0, 0xDA, + 0xCD, 0xAA, 0x6A, 0x6D, 0x24, 0xC2, 0x50, 0xD3, + 0x39, 0x40, 0x3D, 0xBA, 0x82, 0x31, 0xBD, 0x51, + 0xE8, 0x87, 0xCB, 0x5B, 0x1B, 0x7B, 0xDE, 0x27, + 0x74, 0xC6, 0xB0, 0x8A, 0xCC, 0xE0, 0xF7, 0x49, + 0x56, 0x48, 0xDA, 0x3B, 0xEB, 0xC7, 0xB1, 0xC2, + 0x82, 0x15, 0x08, 0xC4, 0xD3, 0x82, 0xF7, 0x30 + }, + { + 0x28, 0xF8, 0x8C, 0xDB, 0xE9, 0x03, 0xAD, 0x63, + 0xA0, 0x23, 0x31, 0xDE, 0x1A, 0x32, 0xAF, 0x6D, + 0xBB, 0xA8, 0x2D, 0x7F, 0xC0, 0x79, 0x87, 0x02, + 0x72, 0x49, 0x33, 0xDA, 0x77, 0x38, 0x07, 0xBC, + 0x80, 0x42, 0x78, 0x13, 0x47, 0x81, 0xF1, 0x26, + 0x23, 0x32, 0x20, 0xE3, 0x07, 0x92, 0x81, 0x31, + 0xB2, 0x47, 0x10, 0xB4, 0x67, 0x4E, 0xD7, 0x05, + 0x11, 0x2F, 0x95, 0xD1, 0xAA, 0x37, 0xA2, 0xDC + }, + { + 0x5B, 0xB2, 0x92, 0x65, 0xE2, 0x46, 0xB8, 0x84, + 0xFF, 0x40, 0x91, 0x4F, 0xFA, 0x93, 0xD9, 0xA1, + 0x2E, 0xDC, 0x19, 0xEE, 0xE9, 0xCC, 0x8A, 0x83, + 0x63, 0x1D, 0x68, 0xBD, 0x46, 0xAA, 0xD3, 0x35, + 0x4B, 0xA6, 0x67, 0x4B, 0x91, 0x3F, 0x4F, 0x82, + 0x3E, 0x79, 0x1F, 0x0C, 0xB1, 0x9E, 0xA6, 0xA6, + 0x7C, 0x6E, 0x32, 0xE9, 0xBE, 0x0D, 0x0F, 0xF5, + 0x76, 0x0F, 0x16, 0xDD, 0x75, 0xA8, 0x7B, 0x5D + }, + { + 0xBF, 0x3C, 0x06, 0xDC, 0x6D, 0x94, 0xE3, 0x85, + 0x9A, 0x4D, 0xAA, 0x50, 0xEC, 0xA1, 0xAF, 0x53, + 0x57, 0xE3, 0x45, 0x79, 0xE5, 0x99, 0xF8, 0x20, + 0x49, 0xE1, 0xCC, 0xA7, 0xA7, 0xD4, 0xF3, 0x3F, + 0xEA, 0x44, 0x3B, 0x44, 0x69, 0x1B, 0xD4, 0x36, + 0x88, 0xF5, 0x55, 0x05, 0x31, 0xCF, 0x22, 0xB7, + 0x12, 0x77, 0x89, 0x0B, 0xFF, 0xAE, 0x1E, 0xCE, + 0x78, 0x3F, 0x56, 0x63, 0xA1, 0xC4, 0xD7, 0x1A + }, + { + 0xC9, 0x0D, 0xF5, 0x32, 0xF2, 0xF1, 0x49, 0x3A, + 0x11, 0x55, 0xBE, 0x8C, 0x2A, 0x44, 0x00, 0x92, + 0x20, 0x49, 0x97, 0x4E, 0x7D, 0x4F, 0x4B, 0x54, + 0xF8, 0x20, 0xC2, 0x26, 0x9D, 0x3B, 0x16, 0x1B, + 0x6E, 0x88, 0xEB, 0x77, 0x6B, 0x85, 0x9B, 0x89, + 0xB8, 0x56, 0x7F, 0xBC, 0x55, 0x0C, 0x4F, 0x54, + 0xAA, 0xD2, 0x7A, 0x16, 0x10, 0x65, 0x6D, 0x62, + 0x5C, 0x32, 0x7F, 0x66, 0x5D, 0xCA, 0x70, 0x7C + }, + { + 0x3D, 0x39, 0xEE, 0xCC, 0x9E, 0x90, 0x42, 0x36, + 0xDC, 0x85, 0x7B, 0xA4, 0x9D, 0x55, 0xD3, 0xBA, + 0xD7, 0x65, 0x72, 0xA9, 0x1A, 0x75, 0x95, 0x03, + 0x37, 0x6B, 0x77, 0x08, 0xD6, 0x2D, 0x5A, 0x78, + 0x5C, 0x23, 0x06, 0x80, 0x59, 0xCF, 0x68, 0x89, + 0x7F, 0x23, 0xEE, 0xC5, 0x07, 0x21, 0x9B, 0x0A, + 0x02, 0xED, 0xA2, 0xD8, 0xBC, 0x94, 0xFA, 0x69, + 0x89, 0xA5, 0x14, 0x82, 0x22, 0x03, 0xC8, 0xD1 + }, + { + 0xE0, 0x8C, 0x54, 0xD9, 0x98, 0xF9, 0x2B, 0x7A, + 0x54, 0xA2, 0x4C, 0xA6, 0xAE, 0xB1, 0x53, 0xA6, + 0x4F, 0x9C, 0x9F, 0x1F, 0xC3, 0x36, 0x58, 0xB3, + 0xED, 0xAC, 0x2C, 0x4B, 0xB5, 0x26, 0x31, 0x58, + 0xDA, 0xDF, 0x00, 0xD3, 0x51, 0x9A, 0x11, 0x9A, + 0x56, 0x14, 0xC7, 0xF3, 0x79, 0x40, 0xE5, 0x5D, + 0x13, 0xCC, 0xE4, 0x66, 0xCB, 0x71, 0xA4, 0x07, + 0xC3, 0x9F, 0xC5, 0x1E, 0x1E, 0xFE, 0x18, 0xDA + }, + { + 0x74, 0x76, 0x76, 0x07, 0x04, 0x1D, 0xD4, 0xB7, + 0xC5, 0x6B, 0x18, 0x9E, 0xE8, 0xF2, 0x77, 0x31, + 0xA5, 0x16, 0x72, 0x23, 0xEB, 0x7A, 0xF9, 0xB9, + 0x39, 0xE1, 0x18, 0xF8, 0x7D, 0x80, 0xB4, 0x9E, + 0xA8, 0xD0, 0xD0, 0x1F, 0x74, 0xF3, 0x98, 0xB1, + 0x72, 0xA8, 0xAD, 0x0D, 0xBF, 0x99, 0x41, 0x4F, + 0x08, 0xD2, 0xB7, 0xD8, 0xD7, 0x52, 0x16, 0xA1, + 0x82, 0x25, 0x27, 0x3D, 0x8D, 0x7F, 0xD0, 0x5D + }, + { + 0xFE, 0xE8, 0x9A, 0x92, 0xCC, 0xF9, 0xF1, 0xEB, + 0x08, 0x4A, 0xAB, 0xA9, 0x54, 0x97, 0xEF, 0x0F, + 0x30, 0x13, 0x4C, 0x19, 0x1C, 0xF9, 0x0A, 0x49, + 0xD2, 0x2C, 0x7D, 0x2F, 0x66, 0x14, 0x99, 0x3C, + 0xBE, 0x1A, 0x4B, 0x65, 0x13, 0xED, 0xC1, 0x53, + 0x86, 0x8A, 0x3D, 0x56, 0x2B, 0x5B, 0x02, 0x26, + 0xBA, 0x8E, 0x1B, 0x0D, 0xCB, 0x69, 0xED, 0x45, + 0xAF, 0x47, 0xCE, 0x4F, 0x86, 0xBA, 0x47, 0x4A + }, + { + 0xCD, 0xAE, 0x94, 0xB6, 0xD1, 0xD8, 0x35, 0xF6, + 0xC7, 0x4C, 0x76, 0xEC, 0x3A, 0x2D, 0xB6, 0x5B, + 0xBD, 0xFA, 0xE1, 0x9D, 0x7B, 0x05, 0x0D, 0xC9, + 0x5D, 0x65, 0x87, 0x33, 0xB8, 0xB2, 0x2C, 0x6F, + 0x9E, 0x0B, 0x63, 0xCC, 0x90, 0x5A, 0x29, 0xEA, + 0x88, 0x78, 0xCA, 0x39, 0x45, 0x56, 0xB3, 0x67, + 0x3C, 0x62, 0x79, 0x15, 0x46, 0xA9, 0xA1, 0xF0, + 0xD1, 0x56, 0x5F, 0xAD, 0xC5, 0x35, 0x36, 0xC1 + }, + { + 0xC7, 0x22, 0x8B, 0x6F, 0x00, 0x00, 0x17, 0xD2, + 0xBE, 0x4B, 0xF2, 0xAE, 0x48, 0xAD, 0xDB, 0x78, + 0x5E, 0x27, 0x35, 0xBF, 0x3C, 0x61, 0x4D, 0x3C, + 0x34, 0x23, 0x1F, 0x1D, 0x0C, 0x88, 0x7D, 0x3A, + 0x8E, 0x88, 0x88, 0x0B, 0x67, 0xAD, 0x3B, 0x2F, + 0x65, 0x23, 0xDD, 0x67, 0x19, 0x34, 0x2C, 0xD4, + 0xF0, 0x59, 0x35, 0xD2, 0xE5, 0x26, 0x7F, 0x36, + 0x80, 0xE7, 0x73, 0xBD, 0x5E, 0xAD, 0xFE, 0x1D + }, + { + 0x12, 0x27, 0x44, 0xFE, 0x3F, 0xFF, 0x9A, 0x05, + 0x5F, 0x0F, 0x3B, 0xDE, 0x01, 0xEB, 0x2F, 0x44, + 0x6B, 0x0C, 0xDA, 0xF3, 0xAE, 0xD7, 0x2C, 0xAA, + 0x29, 0x40, 0x74, 0x19, 0x20, 0x12, 0x0A, 0x96, + 0x4F, 0xCF, 0xF8, 0x70, 0x99, 0xB0, 0x8E, 0xF3, + 0x34, 0x96, 0xE3, 0x99, 0x03, 0x2A, 0x82, 0xDA, + 0xAD, 0x4F, 0xED, 0x30, 0x31, 0x17, 0x2F, 0x77, + 0x47, 0x92, 0x58, 0xFA, 0x39, 0xDB, 0x92, 0xFD + }, + { + 0x1F, 0xB4, 0xE3, 0x67, 0xEA, 0xB6, 0x42, 0xB7, + 0x2E, 0x43, 0xAD, 0x4A, 0xBD, 0xFC, 0xAD, 0x74, + 0x62, 0x0C, 0x3F, 0x6C, 0x63, 0xA8, 0x91, 0x31, + 0x28, 0xD2, 0x22, 0x6E, 0xB1, 0x92, 0xF9, 0x99, + 0x2E, 0xB9, 0xC8, 0xF7, 0x6A, 0xE2, 0x06, 0xD3, + 0xF5, 0xDE, 0xC7, 0x26, 0xA5, 0xA6, 0x86, 0xB4, + 0xAE, 0x37, 0xB5, 0x57, 0xAB, 0x57, 0xF9, 0x56, + 0x48, 0x53, 0x34, 0xF7, 0x3D, 0xCE, 0x02, 0xE0 + }, + { + 0x04, 0x25, 0xCA, 0xAA, 0x92, 0x3B, 0x47, 0xB3, + 0x50, 0x45, 0xEB, 0x50, 0x82, 0x9C, 0x04, 0x8B, + 0xC8, 0x90, 0x44, 0x4A, 0xFE, 0xEF, 0xC0, 0xAF, + 0xC9, 0xD1, 0x87, 0x7B, 0x82, 0x1E, 0x04, 0x3C, + 0x9C, 0x7B, 0x9D, 0x6D, 0xC3, 0x3F, 0xBB, 0xDF, + 0xA5, 0x37, 0xC1, 0xEC, 0xE3, 0x11, 0x96, 0x5B, + 0x2F, 0xEE, 0x89, 0x82, 0xBC, 0x46, 0xA2, 0xA7, + 0x50, 0xBF, 0xC7, 0x1D, 0x79, 0xDB, 0xEA, 0x04 + }, + { + 0x6B, 0x9D, 0x86, 0xF1, 0x5C, 0x09, 0x0A, 0x00, + 0xFC, 0x3D, 0x90, 0x7F, 0x90, 0x6C, 0x5E, 0xB7, + 0x92, 0x65, 0xE5, 0x8B, 0x88, 0xEB, 0x64, 0x29, + 0x4B, 0x4C, 0xC4, 0xE2, 0xB8, 0x9B, 0x1A, 0x7C, + 0x5E, 0xE3, 0x12, 0x7E, 0xD2, 0x1B, 0x45, 0x68, + 0x62, 0xDE, 0x6B, 0x2A, 0xBD, 0xA5, 0x9E, 0xAA, + 0xCF, 0x2D, 0xCB, 0xE9, 0x22, 0xCA, 0x75, 0x5E, + 0x40, 0x73, 0x5B, 0xE8, 0x1D, 0x9C, 0x88, 0xA5 + }, + { + 0x14, 0x6A, 0x18, 0x7A, 0x99, 0xE8, 0xA2, 0xD2, + 0x33, 0xE0, 0xEB, 0x37, 0x3D, 0x43, 0x7B, 0x02, + 0xBF, 0xA8, 0xD6, 0x51, 0x5B, 0x3C, 0xA1, 0xDE, + 0x48, 0xA6, 0xB6, 0xAC, 0xF7, 0x43, 0x7E, 0xB7, + 0xE7, 0xAC, 0x3F, 0x2D, 0x19, 0xEF, 0x3B, 0xB9, + 0xB8, 0x33, 0xCC, 0x57, 0x61, 0xDB, 0xA2, 0x2D, + 0x1A, 0xD0, 0x60, 0xBE, 0x76, 0xCD, 0xCB, 0x81, + 0x2D, 0x64, 0xD5, 0x78, 0xE9, 0x89, 0xA5, 0xA4 + }, + { + 0x25, 0x75, 0x4C, 0xA6, 0x66, 0x9C, 0x48, 0x70, + 0x84, 0x03, 0x88, 0xEA, 0x64, 0xE9, 0x5B, 0xD2, + 0xE0, 0x81, 0x0D, 0x36, 0x3C, 0x4C, 0xF6, 0xA1, + 0x6E, 0xA1, 0xBD, 0x06, 0x68, 0x6A, 0x93, 0xC8, + 0xA1, 0x25, 0xF2, 0x30, 0x22, 0x9D, 0x94, 0x84, + 0x85, 0xE1, 0xA8, 0x2D, 0xE4, 0x82, 0x00, 0x35, + 0x8F, 0x3E, 0x02, 0xB5, 0x05, 0xDA, 0xBC, 0x4F, + 0x13, 0x9C, 0x03, 0x79, 0xDC, 0x2B, 0x30, 0x80 + }, + { + 0x0E, 0x26, 0xCB, 0xC7, 0x8D, 0xC7, 0x54, 0xEC, + 0xA0, 0x6C, 0xF8, 0xCB, 0x31, 0xFC, 0xBA, 0xBB, + 0x18, 0x88, 0x92, 0xC1, 0x04, 0x50, 0x89, 0x05, + 0x49, 0xB2, 0xD4, 0x03, 0xA2, 0xA3, 0xC4, 0x57, + 0x70, 0x01, 0xF7, 0x4A, 0x76, 0xBD, 0x38, 0x99, + 0x0D, 0x75, 0x5B, 0xAE, 0x05, 0x26, 0x64, 0x83, + 0x29, 0xF6, 0x35, 0x45, 0xED, 0x16, 0x99, 0x5C, + 0xB1, 0xE6, 0x34, 0x3F, 0x18, 0x9F, 0x8E, 0x6F + }, + { + 0x58, 0xE7, 0x98, 0x0B, 0x8B, 0x1A, 0x0B, 0x88, + 0xDA, 0x9D, 0xA8, 0x64, 0x0F, 0x2B, 0x96, 0xE3, + 0xE0, 0x48, 0x36, 0x61, 0x30, 0xC2, 0x66, 0x21, + 0x7D, 0xDC, 0x79, 0x53, 0x50, 0x8F, 0x4A, 0x40, + 0xD1, 0x67, 0x4D, 0xAB, 0xD3, 0x92, 0x89, 0xE3, + 0xF1, 0x0C, 0x61, 0x19, 0x68, 0xCC, 0xD1, 0xE9, + 0xCC, 0xC1, 0x8C, 0xAD, 0xC7, 0x77, 0x4A, 0x99, + 0x7D, 0xD1, 0xFA, 0x94, 0xE8, 0x35, 0x47, 0x07 + }, + { + 0x69, 0x6F, 0xB8, 0x47, 0x63, 0xE0, 0x23, 0x58, + 0x4B, 0x35, 0x90, 0x7A, 0x8B, 0x8A, 0xAA, 0x9E, + 0x0E, 0x78, 0x6F, 0x2C, 0xA5, 0x91, 0x45, 0x41, + 0x91, 0x58, 0x48, 0xFB, 0x6D, 0xDA, 0xB8, 0xD3, + 0xD2, 0xEA, 0xB6, 0x00, 0xC1, 0x38, 0xCE, 0x67, + 0x17, 0xB0, 0xC7, 0x02, 0x59, 0xD3, 0x19, 0x3E, + 0xA1, 0x56, 0x95, 0xC8, 0x50, 0x53, 0x7F, 0x2C, + 0x70, 0x6C, 0xA4, 0xAF, 0x15, 0x8E, 0x95, 0x7E + }, + { + 0x23, 0xDE, 0x6E, 0x73, 0x07, 0x9C, 0x8C, 0x20, + 0x47, 0xA7, 0x84, 0x6A, 0x83, 0xCC, 0xAC, 0xAB, + 0xD3, 0x71, 0x16, 0x3B, 0x7B, 0x6D, 0x54, 0xEB, + 0x03, 0x2B, 0xC4, 0x9B, 0x66, 0x97, 0x42, 0xBE, + 0x71, 0x7B, 0x99, 0xDA, 0x12, 0xC6, 0x46, 0xAD, + 0x52, 0x57, 0x06, 0xF2, 0x22, 0xE1, 0xDF, 0x4A, + 0x91, 0xDD, 0x0C, 0xC6, 0x4D, 0xF1, 0x82, 0xDA, + 0x00, 0x73, 0x1D, 0x43, 0x9C, 0x46, 0xF8, 0xD2 + }, + { + 0xBB, 0x74, 0xF3, 0x6A, 0x9D, 0xB6, 0x96, 0xC9, + 0x33, 0x35, 0xE6, 0xC4, 0x6A, 0xAB, 0x58, 0xDB, + 0x10, 0xCB, 0x07, 0xEA, 0x4F, 0x1B, 0x71, 0x93, + 0x63, 0x05, 0x22, 0x83, 0x90, 0x95, 0x94, 0x78, + 0xF8, 0x73, 0x4E, 0x21, 0x54, 0x90, 0xE9, 0xAE, + 0x2A, 0x3E, 0xC8, 0xF7, 0xF7, 0x67, 0x33, 0xAE, + 0x3F, 0x8B, 0x9A, 0x3F, 0xD7, 0xC4, 0x06, 0xC6, + 0xCA, 0xC7, 0x09, 0x97, 0x5C, 0x40, 0xF8, 0x56 + }, + { + 0xEC, 0x63, 0x04, 0xD3, 0x8E, 0x23, 0x2C, 0x09, + 0x6A, 0xB5, 0x86, 0xCA, 0xDF, 0x27, 0x02, 0x6D, + 0xC5, 0xE5, 0x32, 0x17, 0xD0, 0xE8, 0xB0, 0xC6, + 0x0A, 0xDA, 0xAE, 0x22, 0xF4, 0xE8, 0xC2, 0x2D, + 0x30, 0xBC, 0x51, 0x77, 0xF1, 0xC8, 0x3A, 0xCD, + 0x92, 0x5E, 0x02, 0xA2, 0xDA, 0x89, 0x59, 0x5F, + 0xC1, 0x06, 0x09, 0x0E, 0x2E, 0x53, 0xED, 0xB3, + 0x1C, 0xDB, 0x76, 0xFF, 0x37, 0xEB, 0x61, 0x80 + }, + { + 0x92, 0xF9, 0xFC, 0x6B, 0xC5, 0x9A, 0x54, 0x3F, + 0x0D, 0xC9, 0xA1, 0x79, 0x8F, 0xB1, 0xE5, 0xD5, + 0x23, 0x47, 0x4E, 0x48, 0xFF, 0x3E, 0x29, 0x49, + 0x7F, 0x72, 0x80, 0xD1, 0xC4, 0x08, 0xC8, 0x66, + 0x33, 0x48, 0xFE, 0x2A, 0xF7, 0x8F, 0x6C, 0x4E, + 0x5E, 0xF5, 0xC0, 0xA0, 0x17, 0xF3, 0xD3, 0xF2, + 0x15, 0xEC, 0xDD, 0x7A, 0x40, 0x0A, 0xC5, 0x77, + 0x3B, 0x9E, 0x25, 0x60, 0x68, 0x84, 0x5A, 0x92 + }, + { + 0x4A, 0x25, 0xB5, 0x62, 0xF2, 0xFA, 0x01, 0xDD, + 0xEE, 0x7E, 0xA2, 0xE9, 0xFB, 0xF5, 0x2F, 0x8C, + 0x75, 0x6D, 0x28, 0xDB, 0x4A, 0x8B, 0xF7, 0x0E, + 0x74, 0x0E, 0x90, 0x27, 0x42, 0x6E, 0x51, 0x63, + 0x9D, 0xF8, 0x78, 0x8D, 0x13, 0x38, 0x56, 0x85, + 0x8D, 0x01, 0xFD, 0xDB, 0xDD, 0x5B, 0x98, 0x79, + 0x44, 0xC3, 0x00, 0xDC, 0x7F, 0x82, 0x41, 0xFB, + 0xCE, 0xFA, 0x4F, 0x12, 0x94, 0x8A, 0xFE, 0xAE + }, + { + 0x34, 0x21, 0x2D, 0xD9, 0xF0, 0x65, 0x1F, 0x81, + 0x80, 0x9A, 0x14, 0xED, 0xBC, 0xF7, 0xF3, 0xAC, + 0xDE, 0xDE, 0x78, 0x72, 0xC7, 0xA4, 0x84, 0x7B, + 0xEA, 0x9F, 0x7A, 0xB7, 0x59, 0x73, 0x82, 0x47, + 0x7A, 0x4C, 0xB8, 0x47, 0x9A, 0x27, 0x63, 0x21, + 0x23, 0x5E, 0x90, 0x21, 0x57, 0x94, 0x46, 0xA4, + 0x38, 0x8A, 0x99, 0xE5, 0x60, 0xA3, 0x90, 0x7A, + 0xEE, 0xF2, 0xB4, 0x38, 0xFE, 0x6B, 0x90, 0xC4 + }, + { + 0xD6, 0x2C, 0xF7, 0xAB, 0xBC, 0x7D, 0x7B, 0xCD, + 0x5B, 0xEB, 0x1E, 0xE4, 0x8C, 0x43, 0xB8, 0x04, + 0xFD, 0x0D, 0xB4, 0x55, 0xE7, 0xF4, 0xFE, 0xBB, + 0xCF, 0xF1, 0x4B, 0x05, 0xBE, 0x90, 0x47, 0xE2, + 0x7E, 0x51, 0x8D, 0x6D, 0x3A, 0x6A, 0xDA, 0x4D, + 0x58, 0x63, 0xB7, 0xEC, 0x7F, 0x84, 0x92, 0x45, + 0x89, 0x40, 0xAC, 0x6B, 0xDD, 0xB5, 0x06, 0x59, + 0x2C, 0xCB, 0xC8, 0x96, 0xAF, 0xBB, 0x77, 0xA3 + }, + { + 0x33, 0xA3, 0xA2, 0x63, 0x6F, 0x91, 0x98, 0xD3, + 0x7A, 0x5F, 0xF1, 0xBF, 0xF9, 0xEB, 0x10, 0x02, + 0x4B, 0x28, 0x46, 0x80, 0x39, 0xF4, 0x91, 0x40, + 0x2D, 0x39, 0xB7, 0x08, 0xC5, 0x5D, 0x27, 0xE5, + 0xE8, 0xDF, 0x5E, 0x3E, 0x19, 0x49, 0x95, 0x82, + 0x35, 0xCA, 0xD9, 0x80, 0x74, 0x20, 0x96, 0xF2, + 0x77, 0x9A, 0x1D, 0x71, 0xDA, 0xD5, 0x8F, 0xAF, + 0xA3, 0xCD, 0x02, 0xCB, 0x5E, 0xAA, 0x98, 0xC5 + }, + { + 0xB7, 0xA3, 0x89, 0x90, 0xE6, 0xF4, 0x56, 0x4A, + 0xA3, 0xD9, 0x3A, 0x79, 0x37, 0x10, 0x0C, 0x29, + 0xF9, 0x40, 0xAF, 0xF7, 0xCB, 0x20, 0x86, 0x5A, + 0x1C, 0x21, 0x89, 0x81, 0xA5, 0x42, 0x04, 0x86, + 0x08, 0x17, 0x81, 0xF8, 0xD5, 0x0C, 0x86, 0x62, + 0x5C, 0xC5, 0xD7, 0x6D, 0x0F, 0x5C, 0xCC, 0x4E, + 0xB6, 0x5D, 0x43, 0x66, 0x09, 0x62, 0x4F, 0x21, + 0xD0, 0x53, 0x39, 0xAB, 0x0C, 0xF7, 0x9F, 0x4C + }, + { + 0x9D, 0x66, 0x5A, 0x3F, 0xDD, 0x10, 0x45, 0x9E, + 0x77, 0xF0, 0x3A, 0xC8, 0xC0, 0xE2, 0x39, 0x01, + 0x94, 0x89, 0x69, 0x3C, 0xC9, 0x31, 0x5A, 0xA3, + 0xFF, 0x11, 0x29, 0x11, 0xD2, 0xAC, 0xF0, 0xB7, + 0xD2, 0x76, 0xAC, 0x76, 0x9B, 0xED, 0xFD, 0x85, + 0x2D, 0x28, 0x89, 0xDD, 0x12, 0xDB, 0x91, 0x39, + 0x8B, 0x01, 0xC4, 0xF4, 0xA5, 0xDA, 0x27, 0x80, + 0xB1, 0xDE, 0xFE, 0x0D, 0x95, 0xB6, 0x32, 0x70 + }, + { + 0x70, 0xFB, 0x9E, 0xFD, 0x5B, 0xCA, 0x7F, 0x19, + 0xB6, 0xE3, 0x1D, 0x64, 0x0D, 0xCF, 0x88, 0xD7, + 0x7E, 0x76, 0x8A, 0xE2, 0x27, 0xEC, 0xB3, 0xFD, + 0x6B, 0x47, 0x13, 0x78, 0x94, 0xF5, 0x49, 0xBF, + 0x1C, 0xF0, 0x6E, 0x5D, 0xB4, 0x54, 0x60, 0x44, + 0xDD, 0x9F, 0x46, 0x5C, 0x9C, 0x85, 0xF7, 0x28, + 0x4F, 0xE5, 0x4D, 0x2B, 0x71, 0x52, 0x69, 0x9B, + 0xE4, 0xBD, 0x55, 0x5A, 0x90, 0x9A, 0x88, 0xA9 + }, + { + 0x7A, 0xFD, 0xB0, 0x19, 0x30, 0x87, 0xE0, 0xC9, + 0xF8, 0xB4, 0xDD, 0x8B, 0x48, 0xD9, 0xF2, 0x0A, + 0xCE, 0x27, 0x13, 0xAF, 0xC7, 0x1B, 0xCC, 0x93, + 0x82, 0xB5, 0x42, 0x90, 0xAE, 0xBF, 0xFE, 0xB2, + 0xD1, 0x38, 0xF4, 0xDC, 0xF0, 0x28, 0xF9, 0xC4, + 0x3C, 0xC1, 0x80, 0x89, 0x84, 0x77, 0xA3, 0x9E, + 0x3F, 0x53, 0xA8, 0xD1, 0xBF, 0x67, 0xCE, 0xB6, + 0x08, 0x26, 0x1F, 0xAE, 0x6D, 0xDB, 0x1A, 0xBC + }, + { + 0x05, 0x99, 0x0D, 0x7D, 0x7D, 0xF1, 0xD4, 0x84, + 0xF5, 0xB1, 0xCA, 0xE9, 0xEE, 0x5D, 0xFC, 0xB4, + 0x3F, 0x2C, 0xBE, 0x18, 0x6C, 0x1A, 0x5B, 0x18, + 0x1A, 0x37, 0x31, 0xD4, 0xB1, 0x54, 0x8E, 0xBF, + 0xF5, 0xBF, 0x61, 0xCB, 0x0F, 0x6D, 0x9F, 0xC2, + 0x30, 0xF2, 0x5E, 0x86, 0x78, 0xB7, 0x99, 0xE0, + 0xE8, 0x30, 0x26, 0xA0, 0x86, 0x6B, 0xF0, 0xAC, + 0xAB, 0x08, 0x9E, 0x10, 0x2E, 0x67, 0xAB, 0x6B + }, + { + 0x1A, 0xF7, 0xA5, 0xCE, 0x58, 0x7C, 0x8D, 0x87, + 0xC7, 0xB7, 0x9F, 0xA3, 0xE7, 0x23, 0xD7, 0x4C, + 0xE0, 0x26, 0xB5, 0x28, 0x67, 0x52, 0xFD, 0x0C, + 0x37, 0x42, 0xC6, 0xF0, 0x41, 0x8E, 0xD7, 0x85, + 0x99, 0x0D, 0x21, 0xF2, 0x8D, 0xA8, 0x39, 0xCE, + 0x82, 0x12, 0xED, 0x55, 0x0C, 0x37, 0x3E, 0x6D, + 0x3A, 0x75, 0xD5, 0x5C, 0x31, 0x77, 0x04, 0x41, + 0xEE, 0xAF, 0xF2, 0xD5, 0x0F, 0x6E, 0x61, 0xB6 + }, + { + 0xDD, 0xEE, 0x0C, 0x76, 0xC9, 0xBD, 0xD3, 0x2D, + 0x70, 0x49, 0x35, 0x4C, 0xFC, 0x85, 0xDC, 0x68, + 0x67, 0xE2, 0x49, 0x2E, 0x47, 0xFE, 0xB0, 0x8E, + 0x39, 0x83, 0xD0, 0xB6, 0x78, 0x84, 0x5D, 0x7E, + 0xC6, 0xC9, 0x79, 0x3C, 0x33, 0x26, 0xBF, 0xDC, + 0x1E, 0x11, 0x32, 0x76, 0xD1, 0x77, 0xFE, 0x38, + 0x82, 0x52, 0x04, 0xDD, 0x00, 0x07, 0x39, 0x89, + 0xC0, 0x81, 0xCC, 0x3B, 0x71, 0xC6, 0x8D, 0x5F + }, + { + 0xDE, 0x07, 0x06, 0x48, 0xB3, 0x7C, 0x47, 0xDC, + 0x9F, 0x2F, 0x6D, 0x2A, 0xB2, 0x07, 0x73, 0xCD, + 0x82, 0xFA, 0x57, 0x25, 0xA6, 0x90, 0x0E, 0xB7, + 0x1C, 0xDD, 0xB0, 0xC9, 0xF3, 0x9B, 0x31, 0xDF, + 0x6D, 0x07, 0x73, 0x24, 0x6E, 0x8E, 0xF9, 0x03, + 0x49, 0x67, 0x75, 0x2D, 0xB7, 0xED, 0x22, 0x73, + 0x3F, 0x43, 0x79, 0x94, 0x8D, 0xC3, 0x96, 0xDC, + 0x35, 0xAD, 0xBB, 0xE9, 0xF6, 0x53, 0x77, 0x40 + }, + { + 0xA6, 0x45, 0x6F, 0xBC, 0xFF, 0x9E, 0x3D, 0x5B, + 0x11, 0x6A, 0x0E, 0x33, 0x1A, 0x1F, 0x97, 0x4F, + 0x07, 0x0E, 0x95, 0x56, 0x09, 0x78, 0x1F, 0xA5, + 0x99, 0xD6, 0x08, 0xA3, 0x1D, 0xA7, 0x6A, 0xD8, + 0xAB, 0xFE, 0x34, 0x66, 0x17, 0xC2, 0x57, 0x86, + 0x51, 0x3B, 0x2C, 0x44, 0xBF, 0xE2, 0xCB, 0x45, + 0x7C, 0x43, 0xFA, 0x6F, 0x45, 0x36, 0x1C, 0xA9, + 0xC6, 0x34, 0x13, 0x11, 0xB7, 0xDD, 0xFB, 0xD5 + }, + { + 0x5C, 0x95, 0xD3, 0x82, 0x02, 0x18, 0x91, 0x04, + 0x8B, 0x5E, 0xC8, 0x1C, 0xC8, 0x8E, 0x66, 0xB1, + 0xB4, 0xD8, 0x0A, 0x00, 0xB5, 0xEE, 0x66, 0xB3, + 0xC0, 0x30, 0x77, 0x49, 0xE6, 0xF2, 0x4D, 0x17, + 0x0D, 0x23, 0xFA, 0xCC, 0x8E, 0xB2, 0x53, 0xB3, + 0x56, 0x2B, 0xF8, 0xA4, 0x5C, 0x37, 0x99, 0x0C, + 0xD2, 0xD3, 0xE4, 0x43, 0xB1, 0x8C, 0x68, 0xBB, + 0xCC, 0x6C, 0x83, 0x1D, 0xFD, 0xE2, 0xF8, 0xE5 + }, + { + 0xE3, 0x74, 0x00, 0xDB, 0xD9, 0x21, 0x0F, 0x31, + 0x37, 0xAC, 0xAF, 0x49, 0x24, 0x2F, 0xA1, 0x23, + 0xA0, 0x52, 0x95, 0x8A, 0x4C, 0x0D, 0x98, 0x90, + 0x62, 0x47, 0xD5, 0x35, 0xA3, 0x51, 0xFD, 0x52, + 0x29, 0x6E, 0x70, 0x10, 0x32, 0x5B, 0xDA, 0x84, + 0x1F, 0xA2, 0xAA, 0xB4, 0x47, 0x63, 0x76, 0x3C, + 0x55, 0x04, 0xD7, 0xB3, 0x0C, 0x6D, 0x79, 0xFC, + 0x1D, 0xC8, 0xCF, 0x10, 0x24, 0x46, 0x6D, 0xB0 + }, + { + 0x52, 0x73, 0xA3, 0xA1, 0x3C, 0xF0, 0xEC, 0x72, + 0x00, 0x44, 0x2C, 0xBD, 0x7B, 0x37, 0x44, 0x66, + 0xA7, 0x19, 0x0D, 0xDC, 0xA1, 0x31, 0xD9, 0x63, + 0xF8, 0xF8, 0x39, 0x65, 0xAE, 0xD3, 0xDD, 0x86, + 0xE9, 0xD4, 0x5A, 0xB4, 0x89, 0xB9, 0xC5, 0x62, + 0x47, 0xC9, 0xF2, 0xAA, 0x69, 0xFD, 0x7E, 0x31, + 0x87, 0xB8, 0xFA, 0x0D, 0xAC, 0x77, 0xC4, 0x7C, + 0xB2, 0x95, 0xBA, 0x62, 0x96, 0x78, 0x43, 0x94 + }, + { + 0x2A, 0xDB, 0x93, 0x49, 0xA9, 0xEC, 0x37, 0xFF, + 0x49, 0x62, 0xF4, 0x21, 0x7E, 0x80, 0xEB, 0xDC, + 0xD3, 0x60, 0x96, 0x7B, 0x51, 0x3D, 0x12, 0x02, + 0xD9, 0x98, 0x28, 0x31, 0x15, 0x5D, 0x2F, 0x43, + 0xEB, 0x9A, 0xDD, 0x63, 0xB5, 0xEC, 0x10, 0xD3, + 0xD0, 0x43, 0x0D, 0xC9, 0xCF, 0x76, 0x48, 0x11, + 0x7F, 0xC6, 0x0B, 0xAB, 0xBF, 0x8E, 0xBF, 0x19, + 0xFA, 0xCE, 0xE5, 0x50, 0x45, 0x5B, 0x60, 0xC9 + }, + { + 0xAC, 0xAA, 0xDA, 0x3E, 0x47, 0x37, 0xC6, 0x63, + 0xEB, 0xF0, 0x3C, 0x02, 0x49, 0xCC, 0xA6, 0xF3, + 0x17, 0x9A, 0x03, 0x84, 0xEA, 0x2A, 0xB1, 0x35, + 0xD4, 0xD7, 0xA2, 0xBB, 0x8A, 0x2F, 0x40, 0x53, + 0x9C, 0xDC, 0xE8, 0xA3, 0x76, 0x0F, 0xD1, 0x3D, + 0xEE, 0xEC, 0xD1, 0x60, 0x61, 0x7F, 0x72, 0xDE, + 0x63, 0x75, 0x4E, 0x21, 0x57, 0xCA, 0xDC, 0xF0, + 0x67, 0x32, 0x9C, 0x2A, 0x51, 0x98, 0xF8, 0xE0 + }, + { + 0xEF, 0x15, 0xE6, 0xDB, 0x96, 0xE6, 0xD0, 0xC1, + 0x8C, 0x70, 0xAD, 0xC3, 0xCD, 0xB3, 0x2B, 0x28, + 0x67, 0x74, 0x02, 0xE8, 0xEA, 0x44, 0x11, 0xEA, + 0x2F, 0x34, 0x68, 0xED, 0x93, 0x82, 0xE1, 0x9B, + 0xFE, 0xCA, 0xF5, 0xAC, 0xB8, 0x28, 0xA5, 0x2B, + 0xE1, 0x6B, 0x98, 0x1E, 0x48, 0x7E, 0x5B, 0xB4, + 0xA1, 0x43, 0x08, 0x65, 0x35, 0x8E, 0x97, 0x9F, + 0xB1, 0x07, 0x1F, 0xB9, 0x51, 0x14, 0xFF, 0xDD + }, + { + 0x05, 0x7E, 0xAB, 0x8F, 0xA6, 0x1C, 0x23, 0x09, + 0x67, 0xD9, 0x5D, 0xFB, 0x75, 0x45, 0x57, 0x0E, + 0x34, 0x1A, 0xE3, 0xC6, 0x73, 0x7C, 0x7D, 0xB2, + 0xA2, 0x27, 0xD9, 0x0F, 0xF3, 0x15, 0xD0, 0x98, + 0xD4, 0x76, 0xF7, 0x15, 0x77, 0x9E, 0x67, 0x72, + 0xB4, 0xED, 0x37, 0x54, 0x82, 0x66, 0xE6, 0x59, + 0x8C, 0x6F, 0x09, 0x69, 0x13, 0xC2, 0xFD, 0xD8, + 0xD6, 0xE4, 0x4F, 0xE2, 0xB5, 0x4D, 0x97, 0x80 + }, + { + 0xED, 0xE6, 0x8D, 0x1B, 0x13, 0xE7, 0xEF, 0x78, + 0xD9, 0xC4, 0xEE, 0x10, 0xEC, 0xEB, 0x1D, 0x2A, + 0xEE, 0xC3, 0xB8, 0x15, 0x7F, 0xDB, 0x91, 0x41, + 0x8C, 0x22, 0x19, 0xF6, 0x41, 0x49, 0x74, 0x70, + 0x17, 0xAC, 0xA7, 0xD4, 0x65, 0xB8, 0xB4, 0x7F, + 0xFA, 0x53, 0x64, 0x4B, 0x8B, 0xC6, 0xDA, 0x12, + 0xDD, 0x45, 0xD1, 0x05, 0x5E, 0x47, 0xB4, 0xD8, + 0x39, 0x0E, 0xB2, 0xBD, 0x60, 0x2B, 0xA0, 0x30 + }, + { + 0x27, 0xF8, 0x56, 0xE6, 0x3E, 0xB9, 0x4D, 0x08, + 0xFB, 0xBE, 0x50, 0x22, 0xB0, 0xED, 0xDB, 0xC7, + 0xD8, 0xDB, 0x86, 0x5E, 0xF4, 0xFE, 0xC2, 0x05, + 0x86, 0xDF, 0x3D, 0xD9, 0x02, 0xA0, 0x5B, 0x26, + 0x35, 0x9E, 0x26, 0x7C, 0x78, 0x8D, 0x7C, 0x88, + 0x03, 0x2E, 0x76, 0x6B, 0x11, 0x87, 0x40, 0x20, + 0x0F, 0x49, 0xCB, 0x4D, 0x6E, 0xDB, 0x15, 0x61, + 0xB2, 0xDE, 0x7D, 0xC6, 0x5E, 0xE6, 0x42, 0x3B + }, + { + 0xE9, 0xE9, 0x8D, 0x6D, 0xE0, 0xEF, 0x53, 0xFD, + 0x24, 0x27, 0x66, 0x1E, 0x1A, 0xCF, 0x10, 0x3D, + 0x4C, 0xAA, 0x4D, 0xC6, 0x10, 0x03, 0x62, 0x09, + 0xEC, 0x99, 0x74, 0x19, 0xC1, 0x20, 0x63, 0x1C, + 0x2C, 0x09, 0x4A, 0x8E, 0xE7, 0x82, 0x2D, 0x43, + 0xF8, 0x77, 0x80, 0x11, 0xC6, 0x03, 0x11, 0x1F, + 0x26, 0x28, 0xF8, 0x97, 0xC9, 0xB4, 0x31, 0x31, + 0x54, 0x77, 0x75, 0x6B, 0x03, 0x2E, 0x1F, 0x8D + }, + { + 0x52, 0xEB, 0x1E, 0x6C, 0x8A, 0x54, 0x49, 0x2C, + 0xA7, 0x60, 0xB5, 0x6C, 0xA8, 0x7D, 0xA3, 0xE1, + 0xA9, 0xA6, 0xD8, 0xA4, 0x21, 0x92, 0x19, 0x35, + 0x1D, 0x18, 0x71, 0x5A, 0x9A, 0x2C, 0x26, 0x70, + 0x8B, 0xB7, 0x12, 0xCD, 0xAC, 0x04, 0x34, 0x48, + 0x2E, 0x55, 0x1C, 0xB0, 0x9E, 0x3F, 0x16, 0x33, + 0x8D, 0xE2, 0x9B, 0xE2, 0xC6, 0x67, 0x40, 0xC3, + 0x44, 0xDF, 0x54, 0x88, 0xC5, 0xC2, 0xBB, 0x26 + }, + { + 0x47, 0x3F, 0xA6, 0xC5, 0x1A, 0x48, 0x10, 0x5F, + 0x72, 0x1C, 0x5C, 0xB8, 0xDB, 0xA6, 0x1C, 0x64, + 0xA1, 0xE3, 0xDD, 0xCC, 0xC3, 0x25, 0x0E, 0x68, + 0x22, 0x62, 0xF2, 0x12, 0xC0, 0x1A, 0xB4, 0x87, + 0x4A, 0xFF, 0x68, 0x8F, 0xEA, 0x96, 0x37, 0x73, + 0x9E, 0x2A, 0x25, 0xD2, 0xEE, 0x88, 0xDB, 0xDC, + 0xC4, 0xF0, 0x4D, 0x01, 0x47, 0x9B, 0x30, 0x17, + 0x17, 0x53, 0x3A, 0x64, 0x32, 0xB8, 0x50, 0xCD + }, + { + 0x6B, 0x76, 0x60, 0xD4, 0x10, 0xEA, 0xE5, 0xF3, + 0x5A, 0xD0, 0xAE, 0x85, 0xE6, 0x3D, 0xA4, 0x53, + 0xEB, 0xB0, 0x57, 0xE4, 0x3F, 0x42, 0xE8, 0x42, + 0xCB, 0xF6, 0x25, 0x0D, 0xA6, 0x78, 0x66, 0xB4, + 0x24, 0x0D, 0x57, 0xC8, 0x3B, 0x77, 0x1B, 0x0F, + 0x70, 0x66, 0x3E, 0x17, 0xFB, 0xD9, 0x08, 0x7F, + 0x76, 0xB4, 0xCE, 0x6B, 0xCD, 0x0B, 0x50, 0x2E, + 0x33, 0x74, 0xB1, 0x50, 0x9B, 0xBA, 0x55, 0xA8 + }, + { + 0xA4, 0xD0, 0x8A, 0xCA, 0x7A, 0x9E, 0xA6, 0x43, + 0x99, 0x99, 0xEA, 0x21, 0xE4, 0xCF, 0xE9, 0x86, + 0x9B, 0xB9, 0x0E, 0x3A, 0x01, 0x48, 0x71, 0xAD, + 0x88, 0xED, 0x3A, 0x97, 0xAA, 0x89, 0x15, 0x95, + 0x1C, 0x3F, 0xD0, 0xB3, 0x93, 0x3A, 0x50, 0x85, + 0x88, 0x93, 0x8A, 0xF7, 0x54, 0x49, 0x44, 0xEF, + 0x43, 0xC4, 0x40, 0xAA, 0x8F, 0xF1, 0xE5, 0xA8, + 0x18, 0xA4, 0x66, 0x43, 0x5D, 0xE7, 0x0F, 0xA8 + }, + { + 0x85, 0xE0, 0xE9, 0xB5, 0x0D, 0x2D, 0xB0, 0x22, + 0xC2, 0x39, 0xD7, 0x23, 0x2A, 0xE4, 0x7C, 0x02, + 0x59, 0x22, 0xE4, 0xF0, 0x7E, 0x2A, 0xFC, 0x65, + 0x6C, 0xDC, 0x55, 0x53, 0xA2, 0x7D, 0x95, 0xBF, + 0xA5, 0x8A, 0x57, 0x4D, 0x4E, 0xC3, 0xA9, 0x73, + 0x28, 0x1A, 0x8F, 0x4E, 0x46, 0xA7, 0x1A, 0xB0, + 0x34, 0x1C, 0x25, 0x77, 0x28, 0x74, 0x63, 0xE2, + 0x51, 0x04, 0x4D, 0xB2, 0x39, 0x8D, 0x55, 0xE2 + }, + { + 0x81, 0xA0, 0xD0, 0x24, 0x42, 0x90, 0x51, 0x91, + 0x16, 0x33, 0x70, 0xAE, 0x29, 0xC7, 0xF8, 0x9C, + 0x0F, 0x48, 0xBC, 0x1A, 0x1E, 0xB2, 0x94, 0x70, + 0x47, 0xDA, 0x1C, 0x62, 0x2B, 0x86, 0x77, 0xE9, + 0xEA, 0x9B, 0xEC, 0xED, 0x55, 0xD3, 0x3A, 0xDB, + 0x15, 0x53, 0xBD, 0x58, 0x4A, 0xD2, 0xF8, 0x6A, + 0x62, 0x07, 0xE8, 0x4E, 0x40, 0xE4, 0x60, 0x7E, + 0x11, 0x65, 0x0E, 0xE2, 0x87, 0x9F, 0x4E, 0x0B + }, + { + 0x87, 0x79, 0x0D, 0xF6, 0xCF, 0x73, 0x94, 0x45, + 0x1B, 0xCC, 0x73, 0x0E, 0x53, 0xFC, 0x57, 0xBE, + 0x56, 0x45, 0x22, 0x77, 0x1E, 0x14, 0x43, 0x2A, + 0x80, 0xAB, 0x0B, 0x06, 0xB7, 0xB1, 0xD2, 0x09, + 0xAD, 0x69, 0x89, 0x95, 0x12, 0x53, 0x85, 0xDB, + 0x8B, 0x3C, 0x09, 0x59, 0xB8, 0xA5, 0x33, 0x9E, + 0xDA, 0x0A, 0xE6, 0x78, 0x59, 0xD8, 0x47, 0xF4, + 0x4C, 0x81, 0x59, 0x72, 0x72, 0xCB, 0xF1, 0x95 + }, + { + 0xCC, 0x06, 0x4E, 0xA8, 0x53, 0xDC, 0x01, 0x52, + 0xCC, 0x03, 0xFE, 0xB5, 0xFB, 0x5D, 0xE7, 0x8B, + 0x9B, 0x88, 0xE9, 0x61, 0x55, 0xD5, 0x35, 0x8B, + 0xCE, 0x84, 0xA5, 0x4C, 0x0E, 0x0C, 0x42, 0xFB, + 0xDA, 0x09, 0x2F, 0x22, 0xD0, 0x56, 0xDF, 0x99, + 0x93, 0x26, 0x2E, 0x2B, 0xA4, 0x4A, 0x5B, 0x2D, + 0x53, 0xC3, 0x75, 0x9D, 0x09, 0x45, 0xFE, 0xBA, + 0xA6, 0xFD, 0x51, 0xB8, 0xFF, 0x38, 0xD8, 0x39 + }, + { + 0x7E, 0x51, 0x7F, 0xC3, 0x83, 0xEE, 0x8C, 0x9F, + 0x0A, 0x01, 0x68, 0x1D, 0x39, 0xE7, 0x3B, 0xEB, + 0xA5, 0x96, 0x95, 0x95, 0xCE, 0x77, 0x92, 0x7F, + 0x91, 0x69, 0x1F, 0x33, 0xBB, 0x3E, 0x13, 0x07, + 0xEE, 0x03, 0x61, 0x6C, 0x27, 0xE6, 0x79, 0x51, + 0x86, 0xF6, 0x94, 0x0F, 0xED, 0xD9, 0xD5, 0xC7, + 0xF2, 0x1B, 0x6D, 0x2A, 0xAF, 0x70, 0x29, 0x9C, + 0xDD, 0x83, 0x51, 0x25, 0x05, 0x0A, 0x8B, 0x3C + }, + { + 0x84, 0x5F, 0xCF, 0xA6, 0x7F, 0x6E, 0x06, 0x55, + 0x10, 0xD2, 0x62, 0xF1, 0xDD, 0x69, 0x39, 0xEA, + 0x4C, 0x0A, 0x4A, 0x59, 0xC8, 0xEE, 0x39, 0x77, + 0xDB, 0x70, 0x05, 0xE1, 0xAE, 0xE4, 0x20, 0xBD, + 0x3F, 0x38, 0x26, 0xEC, 0xFE, 0x59, 0x01, 0x5B, + 0x4D, 0xFA, 0x0B, 0xD5, 0xBB, 0xF8, 0xD8, 0xA4, + 0x34, 0x48, 0x5D, 0xC1, 0x1C, 0xB9, 0xCC, 0x85, + 0x97, 0xCB, 0x8C, 0x95, 0x66, 0x11, 0x5F, 0x31 + }, + { + 0x17, 0xCF, 0x2C, 0x23, 0x21, 0x5B, 0xCD, 0xFC, + 0x24, 0x3D, 0x8A, 0x94, 0x5F, 0x3C, 0x5C, 0x25, + 0x1D, 0x27, 0x18, 0xA3, 0xF7, 0x5F, 0xED, 0x6F, + 0x33, 0x20, 0xBC, 0xC6, 0xFD, 0x92, 0x73, 0x86, + 0xD5, 0x6F, 0x87, 0x19, 0xCC, 0xA0, 0x2E, 0xC5, + 0xE9, 0x9C, 0xDA, 0xC4, 0xEA, 0x10, 0x95, 0xB4, + 0x65, 0xBA, 0x9A, 0x29, 0x8B, 0x1D, 0x23, 0x8E, + 0x38, 0xB3, 0xFA, 0x15, 0xE8, 0xB1, 0x4E, 0xE4 + }, + { + 0xD7, 0x89, 0xCE, 0xC7, 0xD7, 0x52, 0x0F, 0x10, + 0xE8, 0xB8, 0xB6, 0xC8, 0x40, 0x95, 0x89, 0xDF, + 0x57, 0xB8, 0x56, 0xB8, 0x24, 0x55, 0x68, 0xF6, + 0x4E, 0x2D, 0x21, 0x83, 0xE3, 0x59, 0xA7, 0x84, + 0xC8, 0xD2, 0x6C, 0xF9, 0xB7, 0x20, 0xF5, 0xDF, + 0x56, 0x7B, 0x01, 0xF3, 0xF4, 0x8D, 0xE6, 0x4D, + 0x4F, 0x0D, 0xB1, 0x56, 0xBE, 0x52, 0x5D, 0x7C, + 0x7A, 0x66, 0x5A, 0xAD, 0xC5, 0x91, 0xF0, 0xB6 + }, + { + 0xB5, 0xE2, 0x46, 0xA9, 0x02, 0x77, 0x10, 0xC0, + 0xB0, 0x55, 0xC7, 0x1F, 0x11, 0x67, 0xE0, 0xEE, + 0x36, 0xEB, 0xC4, 0x32, 0xCF, 0x5D, 0x14, 0x27, + 0x75, 0xA7, 0xAE, 0xCC, 0xCE, 0xA7, 0x83, 0x25, + 0xED, 0x8C, 0x12, 0xF5, 0x0F, 0xBE, 0x64, 0x8A, + 0xDD, 0xF0, 0x59, 0xB8, 0xC0, 0x2A, 0x61, 0x49, + 0x2F, 0x83, 0x57, 0xBE, 0xE1, 0x42, 0xE7, 0xF7, + 0xDE, 0x04, 0x33, 0x78, 0xDB, 0xCF, 0x2D, 0x33 + }, + { + 0xB5, 0x23, 0xFD, 0x77, 0xAB, 0x9E, 0xEE, 0x42, + 0x48, 0x72, 0xBC, 0x2E, 0x83, 0xFC, 0x0A, 0x77, + 0xFF, 0x8A, 0x90, 0xC9, 0xA0, 0xCE, 0x9E, 0x8C, + 0x87, 0x68, 0x0A, 0x0F, 0x62, 0x86, 0x33, 0x1F, + 0x15, 0xC9, 0x3A, 0x2A, 0xFE, 0xCF, 0x75, 0x66, + 0x65, 0x3F, 0x24, 0xD9, 0x30, 0xC3, 0x23, 0x19, + 0x2D, 0x30, 0x43, 0xB9, 0x05, 0x72, 0x1C, 0xBD, + 0xB6, 0x31, 0x11, 0xCA, 0x42, 0xF2, 0x8F, 0x4E + }, + { + 0x43, 0x59, 0xA4, 0x58, 0x76, 0xBF, 0x6A, 0xCC, + 0x0A, 0xEC, 0xE7, 0xB9, 0xB4, 0xB4, 0xA8, 0x38, + 0xB9, 0xDB, 0xA5, 0x77, 0x6A, 0x3B, 0x14, 0xDA, + 0x2F, 0xBA, 0x91, 0x02, 0xE7, 0x8B, 0xF6, 0x48, + 0xFF, 0xB4, 0xD8, 0x67, 0xBA, 0xE8, 0x5F, 0xD9, + 0xB7, 0x13, 0x12, 0xDC, 0x46, 0x02, 0xD0, 0xD4, + 0x9C, 0x90, 0x7B, 0xB9, 0x28, 0x9B, 0x22, 0x95, + 0x96, 0x1E, 0x54, 0x13, 0x81, 0x23, 0xF5, 0x4A + }, + { + 0xD3, 0xF2, 0xC8, 0xE7, 0x4F, 0x34, 0x3A, 0x4E, + 0x71, 0x90, 0xD4, 0x75, 0xCF, 0x9A, 0xF7, 0x54, + 0xEE, 0xD5, 0x57, 0x72, 0x62, 0xB3, 0x5B, 0xD9, + 0xA9, 0xC4, 0x2B, 0x58, 0xCE, 0x88, 0x26, 0x2E, + 0x31, 0x14, 0x91, 0x7F, 0xB9, 0xE6, 0x83, 0xC6, + 0x2D, 0x9F, 0x89, 0x47, 0xB5, 0x8A, 0x29, 0x4D, + 0xA5, 0x06, 0xFB, 0x86, 0xB3, 0xED, 0xF2, 0x5C, + 0xB9, 0xE2, 0xD2, 0xDF, 0x61, 0x1C, 0xD4, 0x48 + }, + { + 0x41, 0xB8, 0x90, 0xF8, 0xE8, 0x45, 0x0D, 0xAD, + 0xB6, 0x95, 0x9A, 0xCC, 0xBA, 0x19, 0x49, 0x17, + 0xE0, 0x2F, 0x30, 0x67, 0x82, 0x1D, 0x4E, 0x99, + 0x5A, 0x37, 0xAC, 0x18, 0xBA, 0x3E, 0x47, 0xC7, + 0x50, 0x6E, 0x7A, 0x3D, 0xD1, 0xE1, 0x12, 0xE6, + 0xEC, 0x41, 0xBE, 0xF5, 0x30, 0x85, 0x11, 0x20, + 0x89, 0x4A, 0x7B, 0x34, 0xB3, 0xDB, 0xCD, 0xAE, + 0x40, 0x73, 0x27, 0xF0, 0xC5, 0x73, 0x6E, 0xDF + }, + { + 0x19, 0xD7, 0x14, 0x4F, 0x0C, 0x85, 0x1E, 0xB8, + 0xB0, 0x53, 0xA3, 0xA4, 0x35, 0x86, 0x52, 0x6D, + 0xC5, 0xC7, 0x73, 0xE4, 0x97, 0x97, 0x51, 0x64, + 0xD1, 0x11, 0x51, 0x36, 0x43, 0x68, 0xDF, 0x24, + 0xBC, 0x44, 0xD5, 0x36, 0x07, 0x23, 0x04, 0xD7, + 0x06, 0x31, 0xA8, 0x40, 0xB6, 0x36, 0xB9, 0x66, + 0xFD, 0x02, 0x8F, 0x61, 0x06, 0x2B, 0xFC, 0x52, + 0x85, 0x67, 0x01, 0x53, 0xA6, 0x36, 0x3A, 0x0A + }, + { + 0xC2, 0x18, 0x4C, 0x1A, 0x81, 0xE9, 0x83, 0xBE, + 0x2C, 0x96, 0xE4, 0xCF, 0xD6, 0x5A, 0xFB, 0xDA, + 0x1A, 0xC6, 0xEF, 0x35, 0x26, 0x6E, 0xE4, 0xB3, + 0xAB, 0x1F, 0xB0, 0x3A, 0xBA, 0xDD, 0xFD, 0xD4, + 0x03, 0xFF, 0xFC, 0xAF, 0xB4, 0xAD, 0xE0, 0xE9, + 0x2D, 0xA3, 0x82, 0xDA, 0x8C, 0x40, 0x22, 0x2E, + 0x10, 0xE9, 0xFD, 0xE8, 0x56, 0xC5, 0x1B, 0xDA, + 0xCD, 0xE7, 0x41, 0xA6, 0x49, 0xF7, 0x33, 0x5D + }, + { + 0x48, 0x8C, 0x0D, 0x65, 0x2E, 0x42, 0xFD, 0x78, + 0xAB, 0x3A, 0x2D, 0xC2, 0x8C, 0xF3, 0xEB, 0x35, + 0xFC, 0xDD, 0xC8, 0xDE, 0xF7, 0xEA, 0xD4, 0x81, + 0x7B, 0xFF, 0xB6, 0x4C, 0x1A, 0xE0, 0xF2, 0x08, + 0xF7, 0x8C, 0xF4, 0x09, 0x76, 0xF7, 0xE2, 0xA2, + 0xCB, 0x2D, 0xD3, 0x0F, 0x1C, 0x99, 0x13, 0x02, + 0x08, 0xCE, 0xB6, 0x92, 0xC6, 0x68, 0x80, 0xD9, + 0x52, 0x8C, 0xD6, 0xD3, 0x8A, 0xD2, 0x9D, 0xB2 + }, + { + 0x51, 0x5B, 0x65, 0xBF, 0x65, 0x68, 0x83, 0x99, + 0x57, 0x5F, 0x0E, 0x06, 0x77, 0xBB, 0x6A, 0x91, + 0x9B, 0x66, 0x33, 0x55, 0x46, 0xD6, 0xCA, 0xE3, + 0x36, 0xF5, 0xC6, 0xFE, 0xAE, 0x5E, 0x2B, 0xF7, + 0x45, 0xE3, 0xA7, 0xB1, 0x3C, 0x32, 0x05, 0xDD, + 0x8B, 0x5B, 0x92, 0xCF, 0x05, 0x3B, 0xE9, 0x69, + 0xDF, 0x71, 0x20, 0xFC, 0xEF, 0x77, 0xE3, 0x89, + 0x5F, 0x56, 0x0F, 0xD2, 0x32, 0xFB, 0x89, 0x50 + }, + { + 0x3F, 0xDB, 0xC7, 0xD6, 0x9F, 0x4B, 0x53, 0xC2, + 0x25, 0x66, 0x3D, 0xA3, 0x0D, 0x80, 0xF7, 0x2E, + 0x54, 0x28, 0x10, 0x44, 0xA2, 0x2B, 0x98, 0x82, + 0xC6, 0x63, 0x8F, 0x55, 0x26, 0x83, 0x4B, 0xD3, + 0x16, 0x01, 0xCA, 0x5E, 0xB2, 0xCC, 0xA4, 0xF5, + 0xFF, 0xCF, 0x67, 0x5D, 0xCB, 0xCF, 0xCA, 0x60, + 0xC8, 0xA3, 0x61, 0x2D, 0x1A, 0xA9, 0xDA, 0xB6, + 0x93, 0xB2, 0x35, 0x60, 0x69, 0x60, 0x3A, 0x0E + }, + { + 0x4F, 0xF6, 0xC3, 0x1A, 0x8F, 0xC0, 0x01, 0xAC, + 0x3B, 0x7A, 0xE0, 0x20, 0xC5, 0xF7, 0xC4, 0x5E, + 0xFB, 0x62, 0x71, 0xA2, 0xD7, 0xCC, 0xAB, 0x87, + 0x13, 0xE5, 0x48, 0xB7, 0x29, 0xF0, 0xFF, 0xF9, + 0xC8, 0x2F, 0xD4, 0xDB, 0x5C, 0xF6, 0x56, 0x43, + 0xD4, 0x07, 0x6A, 0x3F, 0xB1, 0x7B, 0x3E, 0x89, + 0x3C, 0x30, 0x2D, 0xC7, 0x5B, 0x61, 0x22, 0xFF, + 0x86, 0x81, 0xD0, 0x37, 0x12, 0x0E, 0x27, 0x6A + }, + { + 0x43, 0xDF, 0xF2, 0x60, 0xDF, 0xEF, 0x1C, 0xB2, + 0xD6, 0x16, 0x00, 0xE2, 0x40, 0xAA, 0xD6, 0xB7, + 0x20, 0xE5, 0xF4, 0xF8, 0x30, 0x86, 0xE2, 0x6A, + 0x49, 0xA0, 0xCE, 0x3E, 0x0C, 0xA4, 0x4B, 0x9A, + 0x60, 0xFC, 0xF4, 0x6A, 0x8C, 0x3F, 0x1B, 0xB1, + 0xA6, 0xF5, 0x76, 0x2B, 0x66, 0x51, 0x3F, 0xE3, + 0xF7, 0xC5, 0xB0, 0xBC, 0x15, 0x0C, 0x08, 0x49, + 0x1A, 0xCB, 0xC4, 0x36, 0x1C, 0xAB, 0xCF, 0xDF + }, + { + 0xB4, 0xDE, 0xA9, 0x4C, 0x9D, 0x36, 0x75, 0xBE, + 0x05, 0x12, 0xEF, 0xDE, 0xA8, 0x16, 0x38, 0x70, + 0xFE, 0x34, 0x25, 0xDC, 0xD7, 0x61, 0xF3, 0x63, + 0xC4, 0x3A, 0x0C, 0xA5, 0x71, 0x6B, 0x76, 0x54, + 0x06, 0x63, 0xFB, 0x2B, 0xE4, 0x9E, 0x2D, 0xB1, + 0x06, 0x48, 0x5C, 0x9C, 0xDD, 0x3C, 0x16, 0x48, + 0x98, 0xA9, 0x54, 0xB5, 0x87, 0x48, 0xC4, 0x2F, + 0xEA, 0x16, 0xA4, 0x0F, 0xC4, 0x53, 0xD2, 0x10 + }, + { + 0xE5, 0x27, 0x7B, 0x6F, 0x93, 0xEA, 0x1D, 0xE3, + 0xE2, 0xD9, 0xFC, 0xD8, 0xC6, 0x79, 0x79, 0x3C, + 0x6C, 0xCB, 0x8A, 0x3B, 0xE2, 0x6E, 0x8E, 0x31, + 0x14, 0xF3, 0x5D, 0xA4, 0xF2, 0xAC, 0x01, 0x4F, + 0x55, 0xC2, 0xF1, 0x5E, 0x09, 0xE9, 0x4A, 0xA0, + 0x71, 0x29, 0x81, 0x67, 0xA2, 0xFB, 0x9B, 0xE3, + 0x11, 0x70, 0x1F, 0xFB, 0xA9, 0xD3, 0xEE, 0xFF, + 0x8F, 0xFC, 0x79, 0x93, 0xA3, 0xCE, 0xCE, 0x18 + }, + { + 0xF0, 0x95, 0xA7, 0xC6, 0xE2, 0xB9, 0x16, 0x64, + 0x73, 0x4F, 0x3E, 0x23, 0xF1, 0x8E, 0xB2, 0xBA, + 0x9B, 0x00, 0xE7, 0x1F, 0xBF, 0xCB, 0x99, 0x31, + 0xC0, 0xA6, 0x14, 0x79, 0x2A, 0x9D, 0x86, 0x75, + 0x62, 0x2A, 0x87, 0x4C, 0x1B, 0xF5, 0x24, 0x1A, + 0x2A, 0x87, 0x41, 0xED, 0x1C, 0x89, 0x3B, 0xDF, + 0xA8, 0xE2, 0x8C, 0x2E, 0x20, 0xBB, 0x1C, 0x58, + 0xEB, 0x4D, 0xE7, 0xD8, 0x01, 0x11, 0x6C, 0x78 + }, + { + 0xDF, 0xA1, 0xFD, 0x80, 0x3A, 0x1D, 0x4A, 0x3E, + 0x66, 0x1D, 0xF0, 0x1F, 0x49, 0x43, 0xEA, 0x66, + 0x26, 0x0A, 0x18, 0xFE, 0xCE, 0x13, 0x4D, 0x62, + 0xF9, 0x7D, 0xAC, 0xDB, 0x8B, 0x3B, 0xF9, 0xC8, + 0x00, 0xAF, 0xE5, 0x79, 0xCF, 0xD1, 0x3F, 0xC0, + 0x14, 0x8B, 0xDE, 0xFB, 0xFF, 0x4E, 0x76, 0x83, + 0x56, 0x1C, 0x06, 0xA6, 0xF7, 0x22, 0x5E, 0x47, + 0x81, 0x99, 0x3B, 0x4F, 0x4F, 0x2B, 0xCB, 0xFA + }, + { + 0x2B, 0x86, 0xCE, 0xB2, 0x70, 0xF6, 0x90, 0x8D, + 0x8B, 0x16, 0x00, 0x75, 0xEA, 0x7F, 0x57, 0x16, + 0x3A, 0xF5, 0xD5, 0xC6, 0xF8, 0xAA, 0xC5, 0x20, + 0x40, 0xCC, 0x68, 0x7C, 0x17, 0xAB, 0xF3, 0xC7, + 0x78, 0xC1, 0x39, 0x06, 0xE0, 0xE6, 0xF2, 0x9A, + 0x6A, 0xB1, 0x23, 0xDE, 0xEB, 0xCE, 0x39, 0x1F, + 0x90, 0x7D, 0x75, 0xD3, 0xA2, 0xCE, 0xFA, 0x0E, + 0xFC, 0xB8, 0x80, 0xA0, 0xE7, 0x0D, 0x71, 0x96 + }, + { + 0x32, 0x46, 0x6B, 0xCB, 0xDE, 0xD5, 0x38, 0xE5, + 0x68, 0x79, 0x54, 0x30, 0x35, 0x25, 0x36, 0xFE, + 0xB9, 0x19, 0xBF, 0x4D, 0x97, 0xCC, 0x44, 0xAB, + 0x1D, 0x80, 0x50, 0x40, 0xF4, 0xBC, 0x4C, 0x2E, + 0x79, 0x52, 0x72, 0x10, 0x18, 0x95, 0x8B, 0x4E, + 0xE7, 0x83, 0x03, 0x59, 0x0E, 0xF6, 0xAC, 0x45, + 0x0D, 0xF9, 0x2E, 0xC7, 0x7F, 0x47, 0x70, 0x54, + 0xBF, 0xF8, 0x67, 0xB8, 0x89, 0x71, 0xD4, 0x21 + }, + { + 0xEA, 0x64, 0xB0, 0x03, 0xA1, 0x35, 0x76, 0x61, + 0x21, 0xCF, 0xBC, 0xCB, 0xDC, 0x08, 0xDC, 0xA2, + 0x40, 0x29, 0x26, 0xBE, 0x78, 0xCE, 0xA3, 0xD0, + 0xA7, 0x25, 0x3D, 0x9E, 0xC9, 0xE6, 0x3B, 0x8A, + 0xCD, 0xD9, 0x94, 0x55, 0x99, 0x17, 0xE0, 0xE0, + 0x3B, 0x5E, 0x15, 0x5F, 0x94, 0x4D, 0x71, 0x98, + 0xD9, 0x92, 0x45, 0xA7, 0x94, 0xCE, 0x19, 0xC9, + 0xB4, 0xDF, 0x4D, 0xA4, 0xA3, 0x39, 0x93, 0x34 + }, + { + 0x05, 0xAD, 0x0F, 0x27, 0x1F, 0xAF, 0x7E, 0x36, + 0x13, 0x20, 0x51, 0x84, 0x52, 0x81, 0x3F, 0xF9, + 0xFB, 0x99, 0x76, 0xAC, 0x37, 0x80, 0x50, 0xB6, + 0xEE, 0xFB, 0x05, 0xF7, 0x86, 0x7B, 0x57, 0x7B, + 0x8F, 0x14, 0x47, 0x57, 0x94, 0xCF, 0xF6, 0x1B, + 0x2B, 0xC0, 0x62, 0xD3, 0x46, 0xA7, 0xC6, 0x5C, + 0x6E, 0x00, 0x67, 0xC6, 0x0A, 0x37, 0x4A, 0xF7, + 0x94, 0x0F, 0x10, 0xAA, 0x44, 0x9D, 0x5F, 0xB9 + }, + { + 0xB5, 0x45, 0x88, 0x02, 0x94, 0xAF, 0xA1, 0x53, + 0xF8, 0xB9, 0xF4, 0x9C, 0x73, 0xD9, 0x52, 0xB5, + 0xD1, 0x22, 0x8F, 0x1A, 0x1A, 0xB5, 0xEB, 0xCB, + 0x05, 0xFF, 0x79, 0xE5, 0x60, 0xC0, 0x30, 0xF7, + 0x50, 0x0F, 0xE2, 0x56, 0xA4, 0x0B, 0x6A, 0x0E, + 0x6C, 0xB3, 0xD4, 0x2A, 0xCD, 0x4B, 0x98, 0x59, + 0x5C, 0x5B, 0x51, 0xEA, 0xEC, 0x5A, 0xD6, 0x9C, + 0xD4, 0x0F, 0x1F, 0xC1, 0x6D, 0x2D, 0x5F, 0x50 + }, + { + 0xBB, 0xFB, 0x94, 0x77, 0xEC, 0x6A, 0x9F, 0x0C, + 0x25, 0x40, 0x5A, 0xCD, 0x8A, 0x30, 0xD5, 0xDD, + 0x7C, 0x73, 0x57, 0x1F, 0x1D, 0x1A, 0x6E, 0x8C, + 0xE7, 0x2F, 0x8B, 0x9C, 0x94, 0x1C, 0xF7, 0x79, + 0xB7, 0x64, 0x03, 0xAC, 0x7F, 0x04, 0x50, 0x05, + 0x25, 0x84, 0x39, 0x0A, 0x14, 0xEA, 0xA3, 0x7C, + 0x20, 0xB5, 0xBD, 0xB0, 0x38, 0x10, 0x54, 0xA9, + 0xA4, 0x95, 0x34, 0xF8, 0x14, 0x66, 0xBA, 0x9D + }, + { + 0xC8, 0x28, 0x7E, 0x93, 0x3D, 0x95, 0x04, 0xBF, + 0xFD, 0x7B, 0xE2, 0xAC, 0x02, 0x2B, 0x32, 0xF3, + 0xF4, 0x6D, 0x87, 0xA7, 0xA0, 0xE7, 0x9B, 0xB2, + 0xA1, 0xCB, 0xAA, 0xCC, 0x2E, 0x84, 0xCD, 0x70, + 0x84, 0x5D, 0x0D, 0x42, 0x78, 0x48, 0xA6, 0xD7, + 0x88, 0xD3, 0x96, 0x22, 0xE1, 0x0F, 0x43, 0x42, + 0x23, 0x7E, 0xEF, 0xA6, 0xD3, 0xC0, 0x12, 0xDA, + 0xE9, 0x6C, 0xC8, 0xA6, 0x50, 0xCC, 0x2E, 0x30 + }, + { + 0xC4, 0x59, 0x6F, 0xCB, 0x0A, 0x28, 0xD2, 0x4A, + 0xAD, 0x70, 0xCF, 0x18, 0x53, 0xEC, 0x29, 0xDA, + 0xC0, 0xFB, 0x20, 0x2D, 0x8E, 0xC1, 0x40, 0xDA, + 0x30, 0x00, 0x88, 0xBB, 0x85, 0xB9, 0x2C, 0x30, + 0x29, 0x19, 0x46, 0xAD, 0x30, 0x7C, 0x09, 0x6E, + 0x3B, 0x28, 0x66, 0x33, 0x5C, 0x93, 0x17, 0xAF, + 0xE2, 0x8C, 0xAD, 0xAB, 0x5D, 0x62, 0xC3, 0x54, + 0x32, 0x9C, 0x98, 0xD9, 0x93, 0xC5, 0xBE, 0x1C + }, + { + 0xE8, 0x8C, 0x38, 0xE6, 0x7E, 0x8D, 0x19, 0x83, + 0x58, 0x08, 0x85, 0x46, 0x70, 0x77, 0x9E, 0xCA, + 0x60, 0xBA, 0xD8, 0x54, 0xC5, 0x77, 0x87, 0x90, + 0xA0, 0x72, 0x54, 0xA3, 0x0A, 0x14, 0xAE, 0x82, + 0xB6, 0x1B, 0xB1, 0x69, 0x11, 0xFE, 0x57, 0x77, + 0x1D, 0x19, 0xE9, 0xB7, 0xF5, 0x02, 0x3C, 0x0D, + 0x4E, 0x8A, 0x8D, 0x37, 0x2E, 0x3D, 0x85, 0xE4, + 0x3B, 0x03, 0xE5, 0xE0, 0x0E, 0x6E, 0xBA, 0x4B + }, + { + 0x2D, 0x66, 0x3E, 0x03, 0xE6, 0xF3, 0x55, 0x2C, + 0xCD, 0xFB, 0xA4, 0x96, 0xA1, 0x4C, 0xC6, 0x22, + 0x4C, 0xEB, 0x1E, 0xB6, 0x1A, 0xA2, 0x65, 0xE6, + 0xA7, 0xD4, 0xA2, 0x6E, 0x54, 0x10, 0x61, 0x04, + 0xA9, 0x6E, 0x33, 0x09, 0x59, 0xF9, 0x71, 0x3B, + 0x34, 0x87, 0xC1, 0xB9, 0x49, 0x7C, 0xCF, 0x82, + 0x61, 0x1D, 0xBF, 0xA3, 0x4F, 0xF1, 0x1D, 0x31, + 0x33, 0xB5, 0xB5, 0xD1, 0xF1, 0xE4, 0xF8, 0xD0 + }, + { + 0x70, 0x7D, 0x6A, 0x58, 0x42, 0x1B, 0x8F, 0x7E, + 0x44, 0xFF, 0x1F, 0x83, 0x62, 0xBC, 0x70, 0x0F, + 0x71, 0xEF, 0x7C, 0x39, 0x35, 0xE0, 0x76, 0x4B, + 0xD1, 0x4D, 0x39, 0x0C, 0x1C, 0x72, 0x79, 0x2A, + 0xF9, 0xC2, 0xC0, 0x2F, 0xB7, 0x2A, 0x2B, 0x9D, + 0x9A, 0x07, 0x29, 0xCB, 0x3E, 0x99, 0x62, 0x6C, + 0xF0, 0x34, 0xDF, 0x54, 0xB5, 0x06, 0xB5, 0xB1, + 0x64, 0x64, 0xF4, 0x75, 0x86, 0x4F, 0x25, 0x90 + }, + { + 0x9D, 0x88, 0xF8, 0xBA, 0xA4, 0xEB, 0x0F, 0x9A, + 0xB2, 0x29, 0x2E, 0x49, 0x82, 0xAC, 0x80, 0x44, + 0x53, 0x58, 0x22, 0x7D, 0x7F, 0x9C, 0xE7, 0xA4, + 0xA6, 0x29, 0xF1, 0x80, 0xF7, 0x14, 0x1E, 0x08, + 0xFE, 0x63, 0x55, 0xC6, 0x45, 0x21, 0xA6, 0x9B, + 0xA2, 0xBF, 0xBD, 0x1C, 0x4A, 0x3E, 0xA0, 0x48, + 0xD0, 0xBC, 0x8A, 0xB3, 0x70, 0x1F, 0x30, 0xEA, + 0x83, 0xFB, 0xE0, 0x24, 0x74, 0xD8, 0x92, 0xBF + }, + { + 0x65, 0xEA, 0x4D, 0xB0, 0x4A, 0x75, 0x81, 0xC1, + 0x81, 0x94, 0xA8, 0x92, 0x1A, 0xFD, 0xFA, 0x4F, + 0x8D, 0x9A, 0xF6, 0x29, 0xDE, 0xD2, 0x77, 0x2C, + 0x65, 0x8E, 0x08, 0x48, 0x5F, 0x67, 0xAD, 0x2C, + 0xE2, 0x1A, 0x98, 0xCD, 0x29, 0x3F, 0xF2, 0x8D, + 0x4D, 0xFC, 0xDF, 0x65, 0x8C, 0xDC, 0x7A, 0xE6, + 0x70, 0x27, 0x84, 0x8E, 0x71, 0xCC, 0xC1, 0x15, + 0xA3, 0xFF, 0xBA, 0xC4, 0xFA, 0x61, 0xBB, 0x73 + }, + { + 0x0B, 0x4A, 0x68, 0x92, 0x9E, 0x7F, 0x15, 0xCA, + 0x91, 0xBB, 0x44, 0x39, 0xF2, 0x40, 0x37, 0x02, + 0x03, 0x4C, 0xD4, 0x74, 0x8E, 0x46, 0x92, 0x7A, + 0xBA, 0x95, 0xCB, 0xEF, 0x80, 0x04, 0x8B, 0x25, + 0xA6, 0x75, 0x97, 0x0F, 0xAC, 0x33, 0xC8, 0x74, + 0xAB, 0xD3, 0xD8, 0x3A, 0xA0, 0xF3, 0x7B, 0xE2, + 0x30, 0x83, 0x10, 0xE8, 0xDD, 0x79, 0x4F, 0x81, + 0x92, 0x93, 0x0E, 0xD5, 0x6E, 0x70, 0xA8, 0xE4 + }, + { + 0xC1, 0xC5, 0xD8, 0xAC, 0xFE, 0x3F, 0xDE, 0x67, + 0x4E, 0xDD, 0x36, 0x20, 0x15, 0x7A, 0x8B, 0x6B, + 0x4C, 0x8E, 0x67, 0xC6, 0xA7, 0xA9, 0x72, 0x67, + 0x41, 0xD9, 0xC3, 0x05, 0xE2, 0xA5, 0x2A, 0x87, + 0x97, 0xFD, 0xA0, 0xB2, 0xF1, 0x3A, 0xC7, 0x87, + 0x34, 0xDB, 0x2F, 0x4F, 0xC8, 0x3E, 0xF3, 0x24, + 0x14, 0xD9, 0x31, 0xEB, 0xAE, 0xAE, 0xCD, 0x82, + 0x6D, 0x7C, 0x2B, 0xE2, 0x03, 0xBD, 0xC2, 0xD1 + }, + { + 0x2D, 0xAD, 0xC8, 0xC9, 0xF7, 0x42, 0x5A, 0x01, + 0x14, 0x49, 0x12, 0x87, 0xBD, 0xC6, 0x8E, 0xAE, + 0x4F, 0xB6, 0x19, 0x4D, 0x1A, 0x10, 0x9D, 0xB9, + 0xB6, 0xE8, 0xA2, 0xAC, 0x94, 0xD4, 0xE4, 0x40, + 0x90, 0x99, 0x85, 0xC4, 0x29, 0x1F, 0xE8, 0x9F, + 0xD8, 0x28, 0x1F, 0x8F, 0xCE, 0xF6, 0xF6, 0xBC, + 0x32, 0x55, 0x0E, 0x53, 0xCB, 0x7A, 0x49, 0x42, + 0x89, 0x81, 0xE8, 0xD5, 0x3C, 0xF5, 0xA2, 0x12 + }, + { + 0xE5, 0x55, 0xF2, 0xA5, 0x8A, 0xCA, 0xC5, 0x50, + 0x3F, 0x9E, 0x2D, 0x97, 0xB2, 0x46, 0x87, 0x2B, + 0x4C, 0xA7, 0x8B, 0xD5, 0x6D, 0x47, 0xB7, 0x65, + 0xF0, 0x52, 0xAA, 0xB3, 0xDC, 0x77, 0xDB, 0xE9, + 0x93, 0x93, 0x6F, 0x22, 0x52, 0xF0, 0xAB, 0x2E, + 0x01, 0xFB, 0x08, 0x74, 0x72, 0xCC, 0xB5, 0xA1, + 0x21, 0xDD, 0xFF, 0xDE, 0x53, 0x1D, 0x3D, 0xC4, + 0x02, 0x2A, 0x7D, 0x19, 0x56, 0xCE, 0x0E, 0x20 + }, + { + 0x9B, 0x4E, 0xAE, 0x12, 0x95, 0x00, 0x0A, 0xEA, + 0x79, 0x83, 0xEC, 0x3B, 0xCB, 0x48, 0x57, 0xCC, + 0x71, 0x25, 0xFD, 0x73, 0x06, 0x78, 0x7C, 0x63, + 0x13, 0x24, 0x73, 0xCF, 0xE8, 0xF4, 0xEB, 0x45, + 0x31, 0x8A, 0x60, 0xDA, 0xAD, 0x64, 0x6D, 0x63, + 0xA2, 0x7C, 0x4B, 0x9D, 0x1F, 0x50, 0x73, 0x70, + 0x0A, 0x30, 0x57, 0xDE, 0x22, 0xA7, 0xFD, 0xF0, + 0x9A, 0x87, 0xAA, 0xC6, 0x6E, 0xBE, 0x47, 0x58 + }, + { + 0x96, 0x64, 0xAC, 0xC2, 0xDC, 0x72, 0x98, 0xB9, + 0x86, 0x8D, 0xB4, 0x95, 0xEE, 0xBC, 0x6B, 0x59, + 0x65, 0x7D, 0x13, 0x9A, 0x6A, 0xF0, 0x60, 0xA7, + 0x2F, 0xB6, 0x91, 0x24, 0xBD, 0xD3, 0xA6, 0x59, + 0x18, 0x88, 0xF0, 0x35, 0x4F, 0x70, 0x2B, 0x1B, + 0x88, 0x86, 0x84, 0x41, 0x10, 0x58, 0xA3, 0x75, + 0x9F, 0x7F, 0xD3, 0x7F, 0x06, 0xEA, 0xFB, 0x3B, + 0x58, 0xEC, 0xF2, 0x6F, 0x45, 0x53, 0xBE, 0x27 + }, + { + 0xFC, 0x16, 0xE0, 0x92, 0x5A, 0x35, 0xAA, 0xD4, + 0x7A, 0xD6, 0x95, 0x54, 0xB2, 0x57, 0x96, 0xFC, + 0xF9, 0x26, 0x0C, 0xB5, 0x0E, 0x6C, 0xC3, 0x74, + 0x75, 0x35, 0x55, 0x9E, 0x99, 0xC8, 0x58, 0x81, + 0xC7, 0x58, 0x89, 0xAC, 0x79, 0x3A, 0xB7, 0x8B, + 0x88, 0xB0, 0x5F, 0xB1, 0x60, 0x89, 0x56, 0x55, + 0xE4, 0xD6, 0x63, 0xA2, 0xA0, 0x9B, 0xA9, 0xFA, + 0x61, 0x4A, 0x10, 0xC2, 0x29, 0x47, 0x21, 0x0D + }, + { + 0x22, 0x5E, 0x73, 0x41, 0xF8, 0x57, 0x52, 0x4F, + 0x78, 0x90, 0x37, 0x6C, 0x50, 0xE6, 0x35, 0x4B, + 0x16, 0xC1, 0xCD, 0xFB, 0xF5, 0x8F, 0xE5, 0xF3, + 0xA4, 0x03, 0x94, 0x93, 0xB5, 0xDD, 0x40, 0x8D, + 0x79, 0xD4, 0x8C, 0x56, 0xE1, 0xF8, 0x9B, 0x68, + 0x7F, 0xBE, 0x33, 0x62, 0xA7, 0x7F, 0xA7, 0x5A, + 0x54, 0x37, 0x4B, 0x7A, 0x48, 0x5E, 0x91, 0xB1, + 0x89, 0xAF, 0x2E, 0x2F, 0x74, 0x9E, 0x2A, 0xDB + }, + { + 0xA0, 0x7A, 0x4C, 0x02, 0x3A, 0xC7, 0x04, 0xCE, + 0x7C, 0x09, 0xDD, 0x6C, 0x92, 0xC6, 0xF1, 0x84, + 0xF5, 0x3E, 0x8D, 0xD9, 0x6F, 0xE3, 0xBE, 0x9E, + 0x93, 0xC3, 0x9C, 0x53, 0x44, 0x85, 0xB6, 0x4B, + 0x39, 0xD5, 0xBE, 0x7F, 0x7B, 0x71, 0x70, 0x60, + 0x4D, 0xE7, 0x7C, 0xE5, 0xA4, 0x37, 0xA9, 0x8E, + 0x71, 0x2C, 0xC4, 0x4F, 0x19, 0xE2, 0x1D, 0x41, + 0xF0, 0xE6, 0xE3, 0xEC, 0x1E, 0x00, 0xAC, 0x55 + }, + { + 0x62, 0x85, 0x84, 0x63, 0x58, 0x2D, 0x22, 0xE6, + 0x8E, 0x52, 0x27, 0xBF, 0xBA, 0xB5, 0x40, 0x04, + 0x8F, 0x65, 0xED, 0xD6, 0xA6, 0x75, 0x5F, 0x6F, + 0xAB, 0x53, 0xC0, 0x25, 0xB6, 0x63, 0xCA, 0x37, + 0x7A, 0x0E, 0xD5, 0xEF, 0xD6, 0xAF, 0x16, 0x6C, + 0xA5, 0x5A, 0x9C, 0x73, 0x3F, 0xCA, 0x80, 0x5A, + 0xC4, 0xE4, 0x09, 0xCA, 0x56, 0x17, 0x7A, 0xA7, + 0x49, 0x40, 0xDB, 0x9F, 0x40, 0xC3, 0xB9, 0xFF + }, + { + 0xA1, 0xAC, 0x53, 0x9D, 0x1A, 0xBB, 0xC2, 0xB0, + 0x96, 0xFF, 0xAB, 0x81, 0x3B, 0x64, 0x45, 0x7F, + 0xE6, 0xEB, 0x3B, 0x50, 0xFC, 0xD8, 0x89, 0x53, + 0xD0, 0xCD, 0x9F, 0x65, 0x02, 0xF6, 0x89, 0x62, + 0x0A, 0xD4, 0x42, 0xB5, 0x51, 0x70, 0x90, 0xB5, + 0x0C, 0xFF, 0xB9, 0x58, 0x86, 0x6D, 0x7C, 0x16, + 0x1D, 0x8A, 0x7D, 0x75, 0x60, 0xC8, 0x93, 0xE1, + 0xDE, 0xF6, 0xAE, 0xC4, 0x37, 0xAD, 0x6D, 0x06 + }, + { + 0xB5, 0x86, 0xB7, 0x5D, 0xA7, 0x0F, 0x6C, 0xC0, + 0x62, 0x7E, 0xF3, 0xCF, 0x12, 0x37, 0xC9, 0x4B, + 0x12, 0xD0, 0xF7, 0x4D, 0xCB, 0xA2, 0x6A, 0x9E, + 0x7C, 0x7B, 0xC6, 0xC2, 0x1A, 0x33, 0x53, 0x37, + 0xBF, 0x9F, 0x5B, 0x83, 0x0C, 0x63, 0x24, 0xAF, + 0xA6, 0xEF, 0x64, 0x9E, 0x95, 0xAF, 0x87, 0x90, + 0x87, 0x52, 0x34, 0xC6, 0xE6, 0x61, 0xD3, 0xF5, + 0xE9, 0x8C, 0xA0, 0x12, 0xAE, 0x81, 0x48, 0x8A + }, + { + 0x56, 0x68, 0xA2, 0x98, 0x21, 0x37, 0xCB, 0xC6, + 0x22, 0xEF, 0x8D, 0x06, 0xCF, 0x4E, 0x86, 0x16, + 0x8C, 0xDD, 0x4A, 0x89, 0x9C, 0xD4, 0x46, 0x2A, + 0xF6, 0xC3, 0xD4, 0x15, 0x42, 0x61, 0x56, 0xA5, + 0xD8, 0xDD, 0x67, 0xC9, 0x60, 0x4F, 0x31, 0xB5, + 0x7D, 0x6C, 0x9D, 0x59, 0x72, 0x50, 0x45, 0x7E, + 0x4A, 0xB5, 0x2A, 0x58, 0x11, 0x55, 0x42, 0xAC, + 0xF2, 0x7F, 0x92, 0x59, 0x30, 0xF6, 0xA1, 0x12 + }, + { + 0xF2, 0xB1, 0xBD, 0x16, 0xD8, 0x8E, 0x37, 0xF3, + 0xA5, 0x18, 0xD1, 0x93, 0xED, 0x06, 0x1A, 0x1D, + 0xF7, 0xB4, 0x43, 0xA1, 0x8C, 0xE9, 0xF8, 0x44, + 0x45, 0xEF, 0x86, 0xEF, 0xFB, 0xDF, 0xF1, 0x60, + 0x55, 0x02, 0x3C, 0xD4, 0xE7, 0x8D, 0x03, 0x4D, + 0xE4, 0x03, 0x2A, 0x77, 0xDD, 0xC1, 0xD3, 0x43, + 0x52, 0xFE, 0x61, 0x7F, 0x82, 0x56, 0x24, 0x45, + 0x9B, 0xC3, 0x26, 0x9F, 0x70, 0x4F, 0x34, 0x5B + }, + { + 0xF0, 0x85, 0xF3, 0xD8, 0xBD, 0x13, 0x8E, 0x05, + 0x69, 0x24, 0x3F, 0x74, 0x52, 0x3E, 0x87, 0xFF, + 0x37, 0x6F, 0x04, 0xEA, 0xBD, 0x5A, 0x2F, 0x6E, + 0x53, 0xDF, 0x38, 0x99, 0x00, 0x0E, 0x2E, 0x94, + 0xAF, 0x0D, 0x2B, 0xC7, 0x1C, 0x3F, 0x71, 0x10, + 0x25, 0xC5, 0x38, 0xA6, 0xC8, 0xB1, 0x0B, 0x09, + 0x04, 0xDF, 0xC3, 0x46, 0xAD, 0xAD, 0x7E, 0xF3, + 0x6B, 0x1A, 0xE8, 0x8A, 0x6C, 0xFE, 0xAB, 0xBD + }, + { + 0x82, 0x91, 0xA4, 0xAF, 0xD2, 0xE4, 0xB7, 0x16, + 0x61, 0x77, 0x3A, 0x46, 0xB3, 0xD4, 0x45, 0x5A, + 0x8D, 0x33, 0xA7, 0x26, 0xD9, 0xD3, 0x87, 0x30, + 0x83, 0xAB, 0x33, 0x70, 0x20, 0xC2, 0x7B, 0x4D, + 0xD6, 0x43, 0xE2, 0x8C, 0x2F, 0xE4, 0x7A, 0xB2, + 0xFB, 0xF5, 0xD1, 0x40, 0x81, 0xA3, 0xFC, 0x1C, + 0x83, 0x9B, 0x12, 0xEA, 0x31, 0xD1, 0x3C, 0xF4, + 0x9E, 0xEE, 0x97, 0xEF, 0x2E, 0xD7, 0xFA, 0x3E + }, + { + 0xB1, 0x26, 0xAE, 0x46, 0xA7, 0xA4, 0x59, 0x5E, + 0x31, 0x60, 0x7E, 0xF8, 0x07, 0xA5, 0x60, 0x1F, + 0x4E, 0xCD, 0x9E, 0x7D, 0x66, 0xC8, 0x2D, 0xAE, + 0xB9, 0x71, 0x5F, 0x8D, 0xA1, 0xC1, 0x7D, 0x7D, + 0x71, 0xC3, 0xE6, 0x82, 0x50, 0xC9, 0xDC, 0x01, + 0xAC, 0x40, 0xA3, 0x6D, 0x2E, 0x63, 0x8B, 0xEF, + 0x3D, 0x7B, 0xC7, 0x0E, 0xA2, 0xD0, 0xE3, 0x31, + 0xE3, 0xD3, 0x3E, 0x17, 0x04, 0xEB, 0xA9, 0x2D + }, + { + 0x63, 0xB1, 0x4D, 0x8E, 0xD2, 0x47, 0x9C, 0xAA, + 0x17, 0xC3, 0xE4, 0xCF, 0x20, 0x3B, 0x23, 0x3A, + 0x7E, 0x37, 0x3E, 0xDB, 0x0C, 0x2F, 0x19, 0x71, + 0x29, 0xA9, 0xA3, 0x6C, 0x5B, 0x3E, 0x1F, 0x38, + 0x38, 0xF2, 0xE8, 0x2A, 0xC2, 0xC2, 0xAD, 0x9D, + 0x52, 0xB3, 0x35, 0x79, 0x0B, 0xFF, 0x57, 0x73, + 0x04, 0xA3, 0x78, 0xE3, 0x8E, 0xB6, 0xBB, 0x41, + 0x62, 0x03, 0x0C, 0xE2, 0xA8, 0xBA, 0x29, 0x3C + }, + { + 0x34, 0x42, 0x2A, 0x32, 0x29, 0x66, 0x99, 0x28, + 0xC4, 0x90, 0xF5, 0x7B, 0x8E, 0x76, 0x88, 0x52, + 0xE5, 0xB7, 0xC0, 0x0D, 0xCA, 0xD6, 0x0B, 0x01, + 0x2A, 0x5D, 0xB3, 0x9A, 0x2D, 0x59, 0x7C, 0x3D, + 0x0A, 0x63, 0xBE, 0x6A, 0x26, 0x3E, 0xA5, 0x36, + 0x08, 0xB7, 0x06, 0x92, 0xD7, 0x8E, 0x1B, 0x42, + 0x7E, 0xAC, 0xEC, 0x01, 0xF4, 0xBE, 0xE0, 0xBD, + 0xBB, 0x8F, 0x08, 0x81, 0x48, 0x8E, 0xFC, 0x28 + }, + { + 0xE2, 0x6B, 0x7E, 0xD6, 0xB9, 0x07, 0xB5, 0x4C, + 0xA2, 0x65, 0x67, 0xF1, 0x1E, 0xE5, 0xBB, 0x6D, + 0x73, 0x9A, 0x00, 0x08, 0xA5, 0x34, 0x37, 0xAD, + 0x75, 0x90, 0xA3, 0x13, 0x4C, 0xEB, 0x95, 0x19, + 0x6E, 0x49, 0xB3, 0x44, 0x3F, 0x32, 0x49, 0x22, + 0x51, 0x75, 0x23, 0xC0, 0xCD, 0x5A, 0x00, 0xD7, + 0x7E, 0x4C, 0x4D, 0xE7, 0xA0, 0xDE, 0x96, 0x8A, + 0x84, 0xFB, 0x1B, 0x3B, 0xE7, 0xB3, 0xB9, 0x63 + }, + { + 0x26, 0x01, 0x97, 0xCA, 0xFB, 0xF4, 0x56, 0xB4, + 0x11, 0xFA, 0x26, 0xD3, 0x83, 0xD6, 0x4D, 0x61, + 0xE8, 0x1E, 0x5E, 0x52, 0xF8, 0x4C, 0xD9, 0xD5, + 0x73, 0x86, 0xC7, 0x76, 0x23, 0x0C, 0x65, 0xA2, + 0x68, 0x1C, 0xD2, 0xFD, 0xFD, 0x28, 0x67, 0x9F, + 0x67, 0xFE, 0x1B, 0xD7, 0x46, 0x9C, 0xF7, 0x26, + 0x95, 0x85, 0xFC, 0xCB, 0xAE, 0xCC, 0x22, 0xF5, + 0x03, 0xD6, 0xE3, 0xFC, 0x39, 0x30, 0x14, 0x36 + }, + { + 0xCB, 0xD5, 0xAB, 0xE3, 0x7B, 0xCC, 0x4F, 0x9A, + 0x12, 0x70, 0xAD, 0xD0, 0xA5, 0x27, 0x0F, 0x42, + 0x83, 0x9C, 0x7D, 0x24, 0x93, 0x20, 0xD1, 0xF1, + 0xD8, 0x85, 0x53, 0xD0, 0x5F, 0xAF, 0x9A, 0x26, + 0x79, 0xF4, 0x9B, 0x49, 0xC9, 0xE2, 0x0C, 0x1C, + 0x85, 0xC6, 0x29, 0xAA, 0x0F, 0x09, 0x0C, 0xAE, + 0x8F, 0x6E, 0x32, 0xC6, 0xCA, 0xD7, 0x17, 0x21, + 0xFD, 0x06, 0x23, 0xE4, 0xED, 0x25, 0xB2, 0x56 + }, + { + 0x78, 0x0E, 0x31, 0x4F, 0xD6, 0x97, 0xD2, 0xA9, + 0x7D, 0x22, 0x1A, 0x22, 0xC3, 0x90, 0x11, 0xE2, + 0x50, 0x69, 0x16, 0x3C, 0xD0, 0x8F, 0x00, 0x70, + 0xD0, 0x67, 0xE8, 0xCD, 0xB0, 0xBC, 0x86, 0x73, + 0xFD, 0xB0, 0xEC, 0x4F, 0x46, 0xE3, 0x1D, 0x74, + 0x8C, 0xD3, 0xBB, 0x3D, 0x61, 0xB9, 0x01, 0x0A, + 0x66, 0x12, 0xF3, 0x41, 0xD4, 0x71, 0xD9, 0xC5, + 0xA2, 0xDE, 0x6B, 0x6D, 0xD5, 0x38, 0xA6, 0xB5 + }, + { + 0x40, 0x8F, 0x16, 0xCE, 0x86, 0xF8, 0x01, 0xD0, + 0x8B, 0xD0, 0x51, 0x36, 0x4B, 0x3E, 0xCD, 0x9A, + 0x39, 0x45, 0x71, 0x58, 0x88, 0xDF, 0x46, 0x63, + 0x21, 0x9A, 0x19, 0x0B, 0x35, 0x04, 0xE4, 0x61, + 0x8E, 0x7B, 0xF5, 0x51, 0x71, 0x17, 0x8B, 0x04, + 0x00, 0xFB, 0xEB, 0xFA, 0xA0, 0x1F, 0x6E, 0xEA, + 0xB5, 0x4F, 0xF5, 0xE3, 0x1E, 0x6D, 0x7A, 0x55, + 0xB8, 0x4A, 0xDB, 0x9E, 0x03, 0xDF, 0x48, 0x36 + }, + { + 0x0B, 0xF9, 0x88, 0x69, 0xEC, 0x05, 0x80, 0x19, + 0x9C, 0xA3, 0x70, 0x8E, 0xC9, 0xC4, 0x2C, 0x37, + 0x6C, 0x5C, 0x36, 0xE0, 0xFB, 0x74, 0x92, 0x42, + 0x57, 0x23, 0x98, 0xA0, 0xDA, 0x57, 0xF9, 0x8D, + 0x1C, 0x4C, 0xD2, 0x96, 0x3B, 0x37, 0xC3, 0xC6, + 0x5A, 0x10, 0xF1, 0x06, 0xB5, 0x6D, 0xCB, 0x96, + 0xDC, 0xDD, 0x32, 0x57, 0x96, 0x29, 0x7A, 0xDB, + 0xF6, 0xEE, 0x62, 0x70, 0xED, 0xD4, 0x59, 0x2A + }, + { + 0x05, 0x2C, 0x32, 0x98, 0x43, 0x87, 0xB1, 0x93, + 0x0D, 0x3A, 0x96, 0xBE, 0x72, 0x36, 0x85, 0x35, + 0x44, 0x4F, 0x13, 0x07, 0x57, 0xBF, 0x87, 0xE0, + 0x76, 0x2D, 0x8B, 0x1C, 0x4F, 0x65, 0x70, 0xF4, + 0xDC, 0x67, 0x4C, 0x4E, 0x6F, 0x5E, 0x21, 0xAB, + 0xD0, 0xB3, 0x5E, 0x1C, 0xA1, 0x9D, 0xB8, 0x40, + 0x68, 0x8D, 0x1B, 0x6E, 0x9E, 0xC9, 0x1F, 0x37, + 0x30, 0xE8, 0xB2, 0x88, 0x0E, 0xC2, 0xC3, 0xDF + }, + { + 0x4B, 0xB7, 0x14, 0x09, 0xC1, 0x5A, 0x0D, 0x39, + 0x32, 0xC5, 0x99, 0xEF, 0x0F, 0xF3, 0xEF, 0xF5, + 0xC7, 0x60, 0x2D, 0x70, 0x00, 0xCD, 0xA9, 0x74, + 0x08, 0x2C, 0x4A, 0x46, 0x82, 0x24, 0x9A, 0x19, + 0xD4, 0x3A, 0x5C, 0x14, 0xE0, 0xAE, 0xEF, 0x89, + 0x78, 0x21, 0x05, 0x63, 0x80, 0xAF, 0xF2, 0x75, + 0x20, 0x1D, 0x74, 0x59, 0x14, 0x84, 0x96, 0xEA, + 0xE9, 0x42, 0x0E, 0x71, 0x82, 0x88, 0xB4, 0x14 + }, + { + 0x47, 0x95, 0xB2, 0x51, 0xCC, 0x7B, 0x35, 0xE6, + 0x96, 0x92, 0xDB, 0x7F, 0xB4, 0x0E, 0xFD, 0x34, + 0xF2, 0x94, 0xF5, 0x1A, 0xEC, 0x15, 0xD6, 0xC8, + 0x67, 0x3E, 0x59, 0xF2, 0x04, 0xBE, 0xCF, 0x4C, + 0xF9, 0xDF, 0x84, 0x95, 0x23, 0xF1, 0xDB, 0x73, + 0xBE, 0x2A, 0x66, 0xC8, 0x39, 0xD8, 0x01, 0x97, + 0x4D, 0x43, 0x3B, 0x47, 0x80, 0x67, 0x01, 0xA1, + 0x63, 0xA7, 0x94, 0xB2, 0x6A, 0x84, 0x6B, 0x06 + }, + { + 0xDD, 0x50, 0xF9, 0x65, 0xB6, 0x0B, 0xAF, 0x16, + 0x8F, 0x5E, 0xA0, 0x5A, 0xC2, 0x0B, 0x8A, 0x78, + 0xF4, 0x47, 0x5C, 0x18, 0x61, 0x0B, 0x9D, 0x9F, + 0xC2, 0xB7, 0xC3, 0xAD, 0x5C, 0x6F, 0x97, 0xA4, + 0xCF, 0x5E, 0xA4, 0x8E, 0xE4, 0x0A, 0x3C, 0xA2, + 0x29, 0x3C, 0xC4, 0x21, 0x40, 0x82, 0xCF, 0x0F, + 0x8E, 0xC8, 0x95, 0x55, 0x32, 0x69, 0xE1, 0x4D, + 0xA9, 0xBD, 0x1A, 0x19, 0x65, 0x62, 0xCA, 0x59 + }, + { + 0xE0, 0xB5, 0x4B, 0x61, 0x7F, 0x44, 0x92, 0x2C, + 0x7F, 0x61, 0xC6, 0xA5, 0x4C, 0x98, 0xC6, 0x1E, + 0x93, 0x2D, 0xED, 0x1F, 0xA9, 0x34, 0x02, 0x66, + 0xEE, 0xA2, 0x5F, 0x01, 0xE8, 0x18, 0x0D, 0x1D, + 0xDC, 0x6A, 0xD8, 0xDD, 0x6A, 0x0B, 0x8F, 0xAB, + 0x8C, 0x73, 0xAE, 0xBB, 0x97, 0x73, 0x17, 0x1B, + 0xBA, 0x04, 0xA7, 0x81, 0xB1, 0x13, 0x14, 0xD5, + 0xA3, 0x0A, 0x9D, 0x1C, 0x28, 0x12, 0xCA, 0x7C + }, + { + 0x2D, 0xC4, 0xAD, 0x06, 0x89, 0xA4, 0x46, 0x0B, + 0x5B, 0x39, 0x9E, 0x91, 0x1B, 0xDB, 0x41, 0x58, + 0x6A, 0xC8, 0xAD, 0x36, 0x7B, 0x7A, 0xA3, 0x9E, + 0x3E, 0xAE, 0xC8, 0x89, 0x9A, 0x2D, 0x3C, 0xE3, + 0x8E, 0x34, 0xAB, 0x46, 0x08, 0x23, 0x4D, 0x75, + 0xEB, 0x67, 0x37, 0xFE, 0x21, 0x58, 0x24, 0xC2, + 0xA9, 0x78, 0x83, 0x59, 0x6F, 0x6F, 0x18, 0xDD, + 0xEB, 0xBF, 0x16, 0x27, 0xDE, 0xD9, 0x1D, 0x84 + }, + { + 0xF5, 0x6A, 0x11, 0xCB, 0xBF, 0x8A, 0x99, 0x7E, + 0x14, 0x77, 0xEC, 0x76, 0xE5, 0x3C, 0x89, 0x4B, + 0x14, 0x8D, 0x69, 0x25, 0xA4, 0x33, 0x6F, 0x0C, + 0xB7, 0xAA, 0xB9, 0xD8, 0x02, 0xAC, 0x9B, 0x45, + 0x36, 0xF4, 0x80, 0x10, 0x1F, 0x3F, 0x9A, 0x77, + 0xEE, 0xCD, 0xCB, 0xAE, 0x7A, 0xA6, 0xEA, 0x44, + 0x7A, 0x85, 0xDA, 0x90, 0xB5, 0x01, 0xF7, 0xDB, + 0x2E, 0xF8, 0xDD, 0xF5, 0xDE, 0x17, 0x33, 0x63 + }, + { + 0x6E, 0x17, 0x1D, 0x19, 0x6D, 0x0F, 0xC8, 0x2F, + 0xB4, 0x73, 0xE2, 0x9D, 0xA8, 0xF4, 0x0F, 0x37, + 0xEE, 0x97, 0x41, 0xAC, 0x3E, 0xAF, 0x17, 0x5D, + 0xD4, 0x9F, 0xDB, 0x56, 0x53, 0x0D, 0xB5, 0x98, + 0x98, 0xBA, 0xF3, 0xCE, 0xE7, 0x2E, 0xEF, 0x5E, + 0x77, 0x27, 0x6C, 0xAD, 0xAB, 0xCD, 0x75, 0x2C, + 0xA3, 0xA1, 0xB8, 0x64, 0xC1, 0x0A, 0xD2, 0x8D, + 0x27, 0xEA, 0xAD, 0x86, 0xE3, 0xF2, 0x1D, 0x33 + }, + { + 0x95, 0x20, 0x12, 0x33, 0x0D, 0x92, 0xBB, 0x9C, + 0x18, 0x92, 0xF2, 0x5B, 0x7B, 0x5A, 0xA0, 0xFE, + 0xD3, 0xC0, 0x39, 0x8A, 0x17, 0x08, 0x50, 0x9A, + 0x66, 0x14, 0x74, 0xA3, 0xF5, 0xE5, 0x11, 0xD0, + 0x9F, 0x21, 0xC3, 0x00, 0x08, 0x00, 0x2F, 0x10, + 0x42, 0xD8, 0x3D, 0x2F, 0x7B, 0x11, 0x33, 0x6B, + 0x8C, 0x2F, 0xE1, 0xD9, 0x79, 0xC1, 0xE3, 0x86, + 0xE0, 0x20, 0x97, 0x48, 0x9B, 0x2D, 0xFC, 0xF5 + }, + { + 0x2D, 0xCE, 0x47, 0xC3, 0x3A, 0x7E, 0x7F, 0x21, + 0x5D, 0x34, 0xA5, 0x47, 0x1B, 0xCD, 0x11, 0x10, + 0x60, 0x6C, 0x77, 0x13, 0x8F, 0x19, 0xD4, 0x17, + 0x41, 0xED, 0x5D, 0x1B, 0x89, 0xE8, 0xF7, 0xC7, + 0x74, 0xEE, 0xC4, 0xBB, 0xC1, 0x02, 0x76, 0x6E, + 0xA1, 0x53, 0x2F, 0x2E, 0x43, 0x13, 0x4A, 0xD3, + 0x66, 0xBD, 0xCC, 0x27, 0xD1, 0xA0, 0xCC, 0x95, + 0x9E, 0x16, 0x48, 0x65, 0x9E, 0x44, 0xCB, 0xBE + }, + { + 0x7F, 0x06, 0x59, 0x59, 0x7E, 0x7A, 0xD1, 0x22, + 0xD1, 0xC9, 0xED, 0x91, 0x93, 0x0B, 0x07, 0xDE, + 0x40, 0xE2, 0x55, 0x20, 0x1A, 0x33, 0xEB, 0x2B, + 0x31, 0x81, 0x37, 0x6E, 0x36, 0x8D, 0xF7, 0x76, + 0x4C, 0x0C, 0x14, 0xBF, 0x79, 0x9F, 0x16, 0x1B, + 0x9B, 0x00, 0x79, 0x57, 0x8B, 0x47, 0x09, 0x71, + 0x3E, 0x24, 0xE4, 0x2F, 0xE7, 0xDD, 0x71, 0xB5, + 0x09, 0x43, 0xF4, 0x40, 0xE2, 0x3C, 0xD1, 0xBE + }, + { + 0x1E, 0x66, 0xF7, 0xB3, 0x58, 0x80, 0x5D, 0xDD, + 0xFF, 0xC5, 0x82, 0x68, 0x3E, 0x0B, 0xAD, 0x81, + 0x8C, 0x87, 0x34, 0x03, 0xD4, 0xBA, 0x15, 0x06, + 0xB9, 0x2F, 0xB3, 0x20, 0xCA, 0x8C, 0xF9, 0xCE, + 0xE8, 0x15, 0x47, 0x15, 0xD6, 0xDB, 0x6F, 0x04, + 0x09, 0x3D, 0x4B, 0x3F, 0xD8, 0xA6, 0xFC, 0x8E, + 0x7E, 0xDD, 0xEA, 0xF2, 0x79, 0x5B, 0x3D, 0x22, + 0xDE, 0x7C, 0x75, 0xEC, 0xFF, 0x6F, 0x92, 0xAF + }, + { + 0x1F, 0x60, 0xC1, 0x8D, 0xB1, 0x68, 0xD9, 0x0D, + 0x2B, 0x46, 0x60, 0xE7, 0x58, 0xA3, 0xCD, 0x28, + 0x02, 0x3D, 0x4C, 0x0B, 0x84, 0x8B, 0x5E, 0x33, + 0xEA, 0x5C, 0xC1, 0x56, 0x29, 0xFD, 0x35, 0x2E, + 0xAC, 0xB1, 0x4F, 0x05, 0xFD, 0xEC, 0x07, 0xAC, + 0x23, 0xDA, 0x92, 0x04, 0x74, 0x5F, 0xA9, 0x73, + 0xC3, 0x29, 0x55, 0x13, 0x5F, 0x8E, 0xC7, 0x41, + 0x0A, 0x1C, 0xB5, 0x3B, 0xC7, 0x58, 0x06, 0x84 + }, + { + 0xB9, 0xDF, 0x57, 0xB3, 0x45, 0xEE, 0x6F, 0x87, + 0x0E, 0xE0, 0xE6, 0x3C, 0x55, 0x8B, 0x81, 0xC1, + 0xBC, 0x38, 0x42, 0x97, 0x6F, 0xD3, 0xCF, 0xB1, + 0xB5, 0x3B, 0x76, 0x6B, 0xF4, 0x36, 0xD1, 0xD1, + 0x75, 0xF4, 0xD4, 0xC5, 0xF1, 0xBD, 0x8D, 0x7A, + 0xF6, 0x5B, 0x5D, 0x18, 0xA7, 0x2F, 0x95, 0x71, + 0xF2, 0x34, 0x70, 0x19, 0x32, 0xAF, 0xB7, 0xC3, + 0xC9, 0x4A, 0x8C, 0x8F, 0xA0, 0x23, 0xDB, 0x4F + }, + { + 0xD8, 0xC8, 0x24, 0x95, 0xA2, 0xB5, 0xF6, 0x64, + 0x51, 0xF8, 0xC5, 0xB2, 0xE8, 0xA1, 0x73, 0x33, + 0xC2, 0xBE, 0x32, 0x20, 0xCE, 0x06, 0xA8, 0x14, + 0xC2, 0xCE, 0xA9, 0x5C, 0xC8, 0x65, 0x92, 0xAA, + 0x02, 0x15, 0xBF, 0x29, 0x46, 0x14, 0xA3, 0x28, + 0xCF, 0x07, 0x22, 0x2B, 0x73, 0xF9, 0x3F, 0x24, + 0x2A, 0x94, 0x8B, 0xCA, 0xE9, 0x56, 0x5F, 0xC9, + 0x70, 0x57, 0xB5, 0x2E, 0x02, 0x80, 0xEB, 0x82 + }, + { + 0x81, 0x34, 0xCE, 0x66, 0xD9, 0x5C, 0x40, 0x88, + 0xA5, 0x66, 0xD4, 0xE4, 0x35, 0x99, 0x06, 0x9A, + 0xD0, 0x45, 0x53, 0xB0, 0xFE, 0xA3, 0xD7, 0x48, + 0x19, 0xA6, 0xFD, 0x76, 0x6F, 0x43, 0x67, 0x42, + 0xF6, 0xB6, 0xEC, 0xC8, 0x27, 0x93, 0x98, 0x60, + 0x9F, 0x60, 0xB4, 0xE4, 0xBB, 0x44, 0xFD, 0x72, + 0xCD, 0xFB, 0xFF, 0x18, 0xD8, 0x03, 0x8A, 0xA7, + 0x12, 0x30, 0x83, 0x8B, 0x12, 0x6B, 0xC3, 0x00 + }, + { + 0x3D, 0xA8, 0x9F, 0x5C, 0x52, 0xB0, 0x52, 0xE0, + 0x42, 0xE5, 0x11, 0x7B, 0x96, 0x80, 0x6E, 0xDB, + 0x1C, 0x55, 0x22, 0x7E, 0x85, 0x14, 0xB3, 0x9E, + 0x8B, 0x22, 0xBE, 0xA4, 0xC9, 0x53, 0x30, 0x80, + 0xA4, 0xD7, 0xA9, 0x24, 0x92, 0xB7, 0x51, 0x76, + 0x9B, 0x0E, 0x11, 0x9E, 0xF4, 0xDB, 0x2B, 0xB8, + 0x8D, 0x5C, 0x1E, 0x75, 0xB4, 0x03, 0x10, 0x74, + 0xD7, 0xF2, 0x1A, 0x78, 0x01, 0x4A, 0x1F, 0x96 + }, + { + 0x9B, 0xDC, 0xB4, 0x69, 0xC2, 0x66, 0x5D, 0xD8, + 0x46, 0x83, 0xE5, 0x81, 0x01, 0xFD, 0xAE, 0x5C, + 0x88, 0x29, 0x2A, 0x4E, 0x05, 0xC4, 0x00, 0xCA, + 0x08, 0x26, 0xDA, 0x79, 0x38, 0x2B, 0x8A, 0x28, + 0x26, 0xFF, 0x24, 0xFC, 0xD5, 0x56, 0xC9, 0xD5, + 0xB5, 0xAA, 0x89, 0x2F, 0x02, 0xB1, 0x67, 0x04, + 0x77, 0x27, 0x9B, 0xD7, 0x5F, 0x1B, 0x2B, 0x7B, + 0x67, 0x5E, 0xFA, 0xC3, 0x80, 0x60, 0x70, 0x36 + }, + { + 0x6C, 0x77, 0x85, 0x7B, 0x38, 0x53, 0x3E, 0x41, + 0x4A, 0xF7, 0x38, 0x7C, 0x98, 0x56, 0x8D, 0x71, + 0xC8, 0xF0, 0xE3, 0x5E, 0x22, 0xB0, 0x2E, 0x2A, + 0x1C, 0x0D, 0xC6, 0xD5, 0x7E, 0x37, 0xD8, 0x68, + 0x72, 0x5A, 0xD8, 0x23, 0x58, 0x6A, 0x0B, 0xEE, + 0xF3, 0x98, 0x89, 0xCC, 0x31, 0xF1, 0xF7, 0xFA, + 0xD0, 0x96, 0x0A, 0x12, 0x5E, 0x29, 0xDF, 0xEA, + 0x74, 0x55, 0x12, 0xD1, 0x79, 0xE5, 0xF5, 0x89 + }, + { + 0x88, 0xC9, 0x83, 0x3A, 0x6D, 0x44, 0xFC, 0x25, + 0xBB, 0x64, 0xF3, 0xE9, 0x8E, 0x83, 0x8F, 0xB4, + 0xFF, 0x56, 0x48, 0x96, 0xDC, 0xD3, 0x58, 0x3A, + 0x8B, 0x57, 0xC9, 0x46, 0x6E, 0x74, 0x0C, 0x62, + 0x8B, 0x2D, 0x26, 0xEA, 0x14, 0x7C, 0xB3, 0x11, + 0x10, 0xFB, 0xAD, 0xCF, 0x9D, 0x01, 0x08, 0xAC, + 0xCE, 0xBE, 0x04, 0x31, 0x7D, 0x19, 0xFC, 0x03, + 0x66, 0xDE, 0x0C, 0x28, 0xA1, 0xA4, 0x5E, 0x2A + }, + { + 0x0A, 0xAB, 0xB3, 0xA1, 0x78, 0x46, 0x4A, 0x01, + 0x47, 0x64, 0x5F, 0x05, 0x71, 0x2A, 0x0A, 0x15, + 0x55, 0xC5, 0xB9, 0xA3, 0xE9, 0x99, 0xAB, 0x25, + 0x5A, 0xCA, 0x35, 0xC5, 0x03, 0x81, 0xF4, 0x90, + 0x55, 0x1A, 0x40, 0x89, 0x31, 0xAA, 0x6B, 0xE9, + 0xA4, 0xEF, 0x49, 0x7A, 0x16, 0x5B, 0x36, 0x66, + 0x3B, 0x1E, 0x1F, 0x05, 0x13, 0x48, 0x02, 0xB1, + 0x78, 0xB7, 0xC7, 0x04, 0x68, 0xCB, 0x98, 0xE8 + }, + { + 0x58, 0x50, 0xD8, 0x93, 0x70, 0x6B, 0x3B, 0xC2, + 0xDB, 0xBA, 0x9C, 0xFA, 0xB0, 0x28, 0xBE, 0xD8, + 0x19, 0xA2, 0x83, 0x11, 0xD2, 0xD6, 0xF0, 0xCD, + 0x8E, 0x27, 0x2E, 0xE6, 0x77, 0xBC, 0x87, 0x8A, + 0x0C, 0xED, 0x6C, 0x0D, 0xEA, 0x9E, 0x5C, 0xC9, + 0x4B, 0x2B, 0x4F, 0x59, 0x1A, 0x40, 0xEC, 0x9F, + 0xB1, 0x82, 0x22, 0xD6, 0xDE, 0xAC, 0xE1, 0xF9, + 0xC0, 0x83, 0xDC, 0x05, 0xDE, 0x11, 0x7A, 0x53 + }, + { + 0xBE, 0xE6, 0x96, 0xA4, 0x76, 0x4F, 0x94, 0x25, + 0xD9, 0x1B, 0x14, 0x17, 0x38, 0x62, 0x5A, 0x04, + 0x47, 0xA8, 0x22, 0xBB, 0xA7, 0xA8, 0x47, 0x78, + 0xCC, 0x3A, 0x77, 0xA3, 0x86, 0xCB, 0x18, 0x24, + 0x87, 0xDB, 0x51, 0x3B, 0xB8, 0xF3, 0x6F, 0xC2, + 0xF7, 0xE6, 0xD2, 0x89, 0x6E, 0x44, 0x56, 0xA5, + 0x23, 0x46, 0xC4, 0x94, 0x8E, 0x3E, 0xC6, 0x34, + 0xCB, 0xF1, 0x8F, 0x39, 0xC4, 0x46, 0xCB, 0xAB + }, + { + 0x3D, 0x9F, 0x75, 0xD3, 0xE5, 0x0D, 0x9B, 0xA3, + 0xBC, 0xAC, 0x4A, 0x4E, 0x11, 0x6B, 0x9B, 0x30, + 0x8D, 0xC6, 0x45, 0x99, 0xA3, 0x86, 0x4A, 0x9D, + 0xAF, 0xD7, 0x5C, 0xB7, 0x1F, 0x2D, 0xE3, 0x10, + 0x9F, 0x79, 0x56, 0xA7, 0xD2, 0xDD, 0x37, 0x4F, + 0x84, 0x06, 0xD7, 0x7F, 0x79, 0x63, 0x11, 0xE3, + 0xD3, 0x00, 0x89, 0xE5, 0x4D, 0xD6, 0xCE, 0x8A, + 0xBB, 0x02, 0xA8, 0x5A, 0x85, 0xAE, 0x92, 0xE4 + }, + { + 0xEF, 0x39, 0x51, 0x47, 0x5A, 0x16, 0xDF, 0x64, + 0x98, 0x32, 0x24, 0x04, 0x65, 0x30, 0xDC, 0x7C, + 0xB0, 0x53, 0xD2, 0x93, 0x94, 0x75, 0x39, 0x11, + 0xC4, 0x94, 0x99, 0x50, 0xF2, 0x3E, 0x8A, 0x92, + 0xC7, 0x09, 0xF4, 0x63, 0x69, 0xB2, 0x3A, 0x0D, + 0x70, 0x3A, 0x6F, 0x36, 0x49, 0x0F, 0x75, 0xBE, + 0x1E, 0x3E, 0x81, 0x29, 0xA8, 0x29, 0xF3, 0xDC, + 0xD7, 0x2D, 0x0E, 0x55, 0x49, 0x7B, 0x81, 0x33 + }, + { + 0xD4, 0x19, 0x7D, 0x2A, 0x68, 0x5B, 0xCA, 0x6B, + 0xFB, 0xDD, 0x0E, 0x3D, 0x84, 0xC7, 0x48, 0x01, + 0x35, 0x48, 0xBC, 0x84, 0x9F, 0xE6, 0x49, 0xDA, + 0xE7, 0xC4, 0xA2, 0x77, 0xFC, 0xBD, 0x8F, 0x81, + 0x8A, 0x9E, 0xDF, 0xA6, 0xCA, 0x14, 0xD7, 0xFE, + 0xEA, 0x72, 0x6B, 0x23, 0xB4, 0xA3, 0x3A, 0xA8, + 0xA3, 0xF5, 0xA6, 0x61, 0x67, 0x21, 0x5C, 0x61, + 0x48, 0xC0, 0x6B, 0x94, 0xCD, 0x8B, 0xFE, 0x37 + }, + { + 0x7A, 0x24, 0x40, 0x33, 0x35, 0xB8, 0x64, 0x10, + 0xD8, 0xD6, 0x93, 0xF1, 0x63, 0xD6, 0x19, 0x8A, + 0x68, 0x0F, 0x7E, 0x3A, 0xC0, 0x25, 0xEC, 0x44, + 0x74, 0x24, 0x9B, 0x01, 0x16, 0x77, 0xFE, 0x1C, + 0x86, 0x6A, 0xAF, 0x45, 0x3D, 0xB0, 0xE8, 0xF6, + 0x54, 0x33, 0x51, 0x50, 0x86, 0x3A, 0xCE, 0x57, + 0x66, 0x50, 0x80, 0x31, 0x91, 0x27, 0x8E, 0x9D, + 0x4B, 0x54, 0x7A, 0x43, 0x4C, 0x56, 0x54, 0xE2 + }, + { + 0xAF, 0x07, 0xC6, 0x7D, 0x58, 0x74, 0x3A, 0xEB, + 0x18, 0x50, 0xEB, 0x53, 0xB2, 0xDA, 0x78, 0xEC, + 0xF7, 0x09, 0x58, 0x18, 0x32, 0x5B, 0xEB, 0x86, + 0x6F, 0xF3, 0x13, 0xE3, 0x94, 0xC0, 0x07, 0xE0, + 0xC0, 0xB5, 0xA1, 0xCD, 0x7A, 0xE6, 0xBB, 0x37, + 0xCD, 0x27, 0x81, 0xB5, 0x2D, 0x15, 0x4D, 0x18, + 0x86, 0x5D, 0x5E, 0x37, 0xDB, 0xAA, 0x5F, 0x96, + 0x73, 0x9B, 0xF7, 0x69, 0x59, 0x96, 0xAE, 0x30 + }, + { + 0x28, 0xB3, 0xC2, 0x60, 0xFA, 0x7F, 0x23, 0xB9, + 0xCC, 0xAD, 0xD6, 0x15, 0xA1, 0x14, 0x69, 0x49, + 0x8A, 0xDB, 0x18, 0xD7, 0xA9, 0xF6, 0x84, 0xFD, + 0xE4, 0x35, 0xC0, 0x65, 0x33, 0xF5, 0xF5, 0x08, + 0xB2, 0x9B, 0x5E, 0xCD, 0x0E, 0xCD, 0x57, 0x36, + 0x9F, 0x22, 0xF1, 0xC5, 0x4E, 0x61, 0xBE, 0x6C, + 0xD1, 0x04, 0xC8, 0xF7, 0xD3, 0xE1, 0x84, 0x7A, + 0xAD, 0x67, 0x07, 0x3A, 0x47, 0x86, 0xE1, 0xDB + }, + { + 0xD6, 0x43, 0x23, 0x33, 0x25, 0x23, 0x9E, 0x2E, + 0xBD, 0x41, 0x1F, 0x0E, 0x00, 0x23, 0x30, 0x56, + 0x2E, 0xB1, 0xBB, 0x08, 0xE6, 0x88, 0x24, 0xB7, + 0x1B, 0x98, 0x19, 0x9C, 0x76, 0xD5, 0x31, 0x58, + 0xD9, 0x1D, 0xDD, 0x6F, 0x4F, 0x82, 0x61, 0xEC, + 0x1D, 0x72, 0xFC, 0x77, 0xC2, 0xCC, 0x23, 0x7E, + 0xDA, 0x15, 0xF0, 0x25, 0x7C, 0xF0, 0x7B, 0x84, + 0xCF, 0x1F, 0xBD, 0x1D, 0xBA, 0xFA, 0x1D, 0xFC + }, + { + 0x3D, 0x7B, 0x44, 0xCC, 0x82, 0xEF, 0xCA, 0xFC, + 0xAB, 0xA6, 0xB1, 0x91, 0x05, 0x48, 0x95, 0x8C, + 0x18, 0x0A, 0x0E, 0x8D, 0x84, 0xBC, 0x66, 0x3E, + 0x8E, 0xF9, 0x53, 0x3B, 0xD8, 0x0C, 0x4B, 0xBA, + 0xAA, 0x25, 0x5B, 0x19, 0x81, 0xF7, 0x56, 0xEB, + 0x10, 0x79, 0xAD, 0x0F, 0x34, 0x71, 0xA1, 0xFC, + 0x9D, 0x7A, 0x43, 0x23, 0x39, 0x30, 0x3A, 0x57, + 0x81, 0xA3, 0x45, 0x35, 0x30, 0x9E, 0x5A, 0x24 + }, + { + 0xEB, 0x08, 0x12, 0xC9, 0x67, 0x06, 0x46, 0xD5, + 0x63, 0x19, 0x8B, 0x11, 0x7A, 0xAF, 0xC5, 0x6F, + 0xA1, 0xB6, 0x56, 0x0F, 0x88, 0xB5, 0x75, 0x4E, + 0xBF, 0xC3, 0x1B, 0x35, 0x52, 0x16, 0xD8, 0xD7, + 0x4D, 0x34, 0x1E, 0x35, 0xB2, 0x43, 0xBC, 0x93, + 0x8C, 0xF5, 0x46, 0xAF, 0x1F, 0x73, 0xC1, 0xB0, + 0x04, 0x55, 0xDC, 0x06, 0xB2, 0xC6, 0xC5, 0x35, + 0x27, 0x9E, 0x87, 0x67, 0x49, 0x8F, 0x14, 0xE6 + }, + { + 0x7B, 0xBA, 0x7D, 0x73, 0x04, 0x02, 0x1C, 0x75, + 0xB5, 0xD6, 0xCE, 0x66, 0xB4, 0xEF, 0xA5, 0x50, + 0x19, 0xD9, 0x42, 0xD2, 0x08, 0xAF, 0xAC, 0x82, + 0x11, 0xAA, 0x7E, 0x5E, 0x11, 0x1E, 0x27, 0x69, + 0x76, 0x70, 0xE4, 0xEC, 0x91, 0xBA, 0x30, 0x8E, + 0xBD, 0xFB, 0x19, 0x15, 0x4C, 0x3B, 0xAD, 0x05, + 0x26, 0xA6, 0x25, 0x41, 0xAE, 0x5D, 0x43, 0xD0, + 0xF5, 0x47, 0xB9, 0xD9, 0x8E, 0x07, 0x36, 0x60 + }, + { + 0xA8, 0xE2, 0xA9, 0x46, 0x8D, 0xA3, 0xE3, 0x54, + 0x3A, 0x23, 0xA5, 0x78, 0x78, 0x0E, 0x25, 0x62, + 0xC7, 0xCE, 0x57, 0xFD, 0x11, 0x20, 0xE1, 0xC0, + 0x24, 0xD7, 0xEA, 0x32, 0x90, 0x31, 0x70, 0x46, + 0x61, 0x6E, 0x14, 0xCD, 0x0F, 0x15, 0xA8, 0x6B, + 0x99, 0x39, 0x54, 0x9B, 0x14, 0x76, 0x11, 0xB6, + 0xA5, 0x5D, 0x85, 0xAB, 0xC2, 0x5F, 0x63, 0x95, + 0x46, 0xB8, 0x9D, 0xD2, 0x3D, 0x39, 0xA9, 0x85 + }, + { + 0xCE, 0x87, 0x4C, 0xD6, 0xE1, 0x95, 0x8B, 0x9D, + 0x7F, 0x11, 0xFF, 0x44, 0xAB, 0x08, 0x32, 0xE8, + 0x48, 0x70, 0x2C, 0x8F, 0x26, 0x65, 0x6B, 0xA1, + 0x0B, 0xF5, 0x72, 0x0A, 0x7C, 0xAA, 0x1F, 0x59, + 0x08, 0xC9, 0x9A, 0x96, 0x03, 0xA9, 0x8B, 0x41, + 0x6C, 0x57, 0x22, 0x8C, 0x81, 0x9C, 0xEA, 0xF8, + 0x27, 0x01, 0x3B, 0x2E, 0x6D, 0x6B, 0x2D, 0xAE, + 0x59, 0xDF, 0xF1, 0x04, 0xB9, 0x02, 0xC3, 0x1B + }, + { + 0x30, 0xFF, 0xFE, 0x37, 0x21, 0x8D, 0xB1, 0x94, + 0xB2, 0x32, 0x73, 0x49, 0x8F, 0x45, 0x44, 0xD3, + 0x84, 0x14, 0xBE, 0xE4, 0x1B, 0x17, 0x55, 0xA0, + 0xC6, 0xC2, 0xDB, 0xCB, 0x41, 0x19, 0x42, 0xD5, + 0xEC, 0xB9, 0xD4, 0x52, 0x3F, 0xB4, 0x79, 0x4B, + 0xA3, 0x6E, 0x57, 0x9A, 0xF2, 0xF8, 0xDD, 0x85, + 0x19, 0x99, 0x23, 0x31, 0x83, 0xFA, 0xB2, 0x7B, + 0x47, 0xAD, 0xD8, 0x7D, 0xF3, 0x59, 0x14, 0xBB + }, + { + 0xCE, 0xF4, 0x43, 0x1D, 0xCE, 0x9F, 0xF5, 0x5A, + 0x00, 0x30, 0x0E, 0xC8, 0x64, 0x9E, 0x27, 0x58, + 0x36, 0x18, 0x22, 0x43, 0x69, 0xF6, 0x0A, 0x5C, + 0x89, 0x6B, 0x2A, 0x31, 0x10, 0xB0, 0x32, 0xB8, + 0x7C, 0x9E, 0xE4, 0xF2, 0x6C, 0x5F, 0x0B, 0xDB, + 0x50, 0x3E, 0xA7, 0x44, 0x7A, 0x5D, 0xB3, 0xF7, + 0x07, 0xFE, 0x34, 0x10, 0xDA, 0xCD, 0xD7, 0x57, + 0x22, 0x19, 0xBD, 0xEA, 0x8E, 0x17, 0xDC, 0x04 + }, + { + 0x8F, 0xF0, 0xBC, 0xB7, 0x5F, 0x00, 0x61, 0xB5, + 0xF9, 0x09, 0x29, 0x8F, 0x56, 0x9E, 0x45, 0xC7, + 0x5E, 0xD2, 0xD6, 0x4A, 0x81, 0x89, 0xCE, 0xBD, + 0x4E, 0x02, 0x56, 0x6E, 0x1A, 0x1B, 0x8B, 0xE5, + 0x3A, 0x78, 0x32, 0x28, 0x55, 0x8E, 0x28, 0xB5, + 0xF8, 0x7C, 0xCC, 0x2F, 0x42, 0x8F, 0x7F, 0x87, + 0x97, 0x44, 0xB5, 0x25, 0xB2, 0x49, 0x62, 0xB3, + 0x60, 0x4B, 0x12, 0x0F, 0x06, 0x77, 0x9F, 0x2E + }, + { + 0x7F, 0x8D, 0xDF, 0xFB, 0x4D, 0xC1, 0x51, 0x91, + 0xDE, 0x3D, 0xDB, 0xE4, 0xA0, 0xF8, 0x8B, 0x7A, + 0xB0, 0x2D, 0x48, 0xE2, 0x5C, 0xFC, 0x1F, 0xE9, + 0x1D, 0xA5, 0x57, 0xE8, 0x85, 0xD0, 0x12, 0xB8, + 0xF6, 0x55, 0x26, 0xC5, 0xB7, 0xB1, 0x01, 0x3F, + 0xC8, 0x16, 0x58, 0x50, 0x43, 0xA3, 0x45, 0x60, + 0x5A, 0x39, 0xD8, 0xDA, 0xD7, 0x0D, 0x8A, 0x64, + 0x48, 0x51, 0x32, 0x50, 0xAA, 0xC4, 0xF3, 0xD5 + }, + { + 0xB1, 0xFE, 0x8C, 0x68, 0xAE, 0xF6, 0xB4, 0xD4, + 0xB2, 0x33, 0x54, 0xEB, 0x8C, 0x1D, 0x8F, 0x5A, + 0x56, 0xE3, 0x2E, 0x76, 0xB9, 0x6A, 0xC8, 0x44, + 0x3B, 0x2A, 0xB8, 0x35, 0xE4, 0xC8, 0xB6, 0x74, + 0xB3, 0x3E, 0x4C, 0x6C, 0x6D, 0xC1, 0x21, 0xD7, + 0xC2, 0xD3, 0x4B, 0x59, 0xB3, 0x7A, 0x56, 0x8A, + 0x1C, 0x98, 0xD5, 0x00, 0x32, 0x4E, 0x53, 0x08, + 0x87, 0x85, 0xB6, 0xB0, 0x80, 0x63, 0x47, 0xD1 + }, + { + 0x8E, 0x87, 0x34, 0xFC, 0xF9, 0x25, 0x9E, 0xE3, + 0x7F, 0xE9, 0xC6, 0xCD, 0xA2, 0x82, 0xC2, 0xD5, + 0xEB, 0x83, 0xD0, 0xCF, 0x43, 0x9C, 0x86, 0x19, + 0xD4, 0xB0, 0x42, 0xFF, 0x69, 0x96, 0x6B, 0x03, + 0x56, 0x5B, 0xE4, 0xDF, 0x96, 0x39, 0x3F, 0xE6, + 0xBF, 0x35, 0xAF, 0xA1, 0x6E, 0x02, 0x73, 0xB6, + 0xD3, 0x39, 0xC0, 0x09, 0x95, 0xBF, 0x6F, 0x60, + 0xA7, 0x14, 0xEF, 0x18, 0x0E, 0xBB, 0x93, 0x15 + }, + { + 0xAE, 0x15, 0x6D, 0x43, 0xA7, 0x2C, 0x04, 0x29, + 0x42, 0x59, 0x58, 0x78, 0xA7, 0x83, 0x07, 0x97, + 0x60, 0xF5, 0x21, 0xED, 0xB8, 0xB2, 0xC3, 0xD4, + 0x1A, 0x56, 0x6B, 0x7C, 0xF7, 0x4A, 0x4A, 0x08, + 0xEA, 0x0F, 0x11, 0x9D, 0x24, 0x0A, 0x62, 0xEC, + 0x73, 0xB9, 0x50, 0x97, 0x88, 0xFA, 0x3A, 0xED, + 0xF1, 0x20, 0xEE, 0x88, 0xCB, 0x95, 0x1B, 0x69, + 0x3F, 0x8F, 0x7C, 0xAF, 0x8C, 0xBA, 0x37, 0x7F + }, + { + 0x93, 0x30, 0xAA, 0xCA, 0x8C, 0x08, 0x84, 0x46, + 0x58, 0xC2, 0x95, 0x06, 0xB1, 0xC3, 0x42, 0x72, + 0xE2, 0xB3, 0xC7, 0xB4, 0xE7, 0x5E, 0x6F, 0xE9, + 0x9A, 0x01, 0x07, 0xEC, 0x5D, 0xA4, 0x53, 0x0F, + 0xB1, 0xC8, 0x8C, 0xAA, 0x66, 0xDD, 0x9C, 0x47, + 0x1E, 0x01, 0xCA, 0x21, 0xA1, 0x3A, 0x5D, 0x6F, + 0x82, 0x15, 0xDE, 0xD3, 0x14, 0x7E, 0x94, 0xDE, + 0x20, 0x88, 0x57, 0x1F, 0xD1, 0xBF, 0x23, 0xB6 + }, + { + 0xC1, 0x29, 0xF2, 0x2C, 0x50, 0xF5, 0x99, 0x72, + 0x32, 0xE2, 0xB9, 0xF9, 0x3D, 0xFA, 0xA0, 0x0A, + 0xD8, 0xA5, 0x34, 0x29, 0xF9, 0xD1, 0x5B, 0x98, + 0x42, 0xE3, 0xAE, 0x08, 0xD8, 0x49, 0xEB, 0xDD, + 0x45, 0x23, 0x8C, 0x85, 0xF9, 0x2C, 0x6F, 0x91, + 0x7E, 0x0F, 0x8F, 0x6F, 0x94, 0xE2, 0x34, 0xBE, + 0x07, 0x61, 0x68, 0xE0, 0xDF, 0x43, 0xD0, 0x28, + 0x45, 0x52, 0x79, 0xA6, 0xFF, 0x65, 0xDC, 0x84 + }, + { + 0x0E, 0x2B, 0x4B, 0xC2, 0xF6, 0xA7, 0x5B, 0xE4, + 0xB7, 0xC9, 0xD4, 0xB5, 0x3D, 0x10, 0x4D, 0xA0, + 0x65, 0x85, 0x8D, 0x38, 0x7B, 0x34, 0x0B, 0xC1, + 0x63, 0x4F, 0x3A, 0x83, 0x32, 0xD5, 0x4C, 0xAA, + 0x94, 0x30, 0x24, 0xB2, 0x13, 0xDC, 0x8D, 0x4F, + 0x21, 0x9E, 0xC8, 0xE1, 0xDE, 0xCA, 0xC7, 0xD5, + 0xC6, 0xAE, 0x69, 0xC9, 0xEF, 0xD8, 0x81, 0x49, + 0x36, 0x78, 0x38, 0x20, 0x5D, 0x0D, 0xC7, 0xC0 + }, + { + 0x83, 0xB5, 0x43, 0x85, 0x3B, 0x81, 0x42, 0xA8, + 0x3B, 0xEF, 0xF0, 0x73, 0x5F, 0x20, 0x18, 0x91, + 0xE7, 0xFF, 0xC6, 0x7D, 0xBD, 0xCD, 0x21, 0xA4, + 0x22, 0xBB, 0x33, 0x6D, 0xE3, 0x29, 0x72, 0xAE, + 0x03, 0x92, 0x64, 0x6F, 0x68, 0x27, 0xD8, 0x0C, + 0xDA, 0x65, 0x4F, 0xD3, 0xA0, 0x77, 0x4C, 0xD2, + 0xF9, 0x95, 0x51, 0x7C, 0xF0, 0x64, 0xC6, 0x17, + 0xF2, 0x1A, 0x54, 0x27, 0x5F, 0xE5, 0x0C, 0x8D + }, + { + 0x09, 0xBE, 0x15, 0xEB, 0x6A, 0x5C, 0x22, 0x6F, + 0x6D, 0x95, 0x08, 0xCB, 0xA4, 0xA2, 0x51, 0x9F, + 0xBA, 0x17, 0x2A, 0xF8, 0x37, 0x58, 0x27, 0xD7, + 0x54, 0xA7, 0xA1, 0xBC, 0x19, 0x25, 0xD1, 0x3F, + 0x5E, 0x63, 0x43, 0xF3, 0xE1, 0x4D, 0x08, 0xA0, + 0x6E, 0x8D, 0x37, 0xF8, 0xEC, 0x56, 0xFB, 0x43, + 0x8E, 0x62, 0x36, 0x66, 0xB6, 0xFB, 0x0E, 0x23, + 0xFB, 0x50, 0x47, 0x7D, 0x41, 0x1B, 0x0C, 0x3A + }, + { + 0xC3, 0x57, 0x97, 0xE9, 0x83, 0x2D, 0x3E, 0x23, + 0x23, 0x33, 0x5B, 0x8C, 0x19, 0xC5, 0xFA, 0x74, + 0x91, 0x60, 0x2D, 0xBF, 0x6B, 0xEA, 0x77, 0xFA, + 0xEE, 0xC9, 0x51, 0x0B, 0xC2, 0xE8, 0x91, 0xC8, + 0xC3, 0x46, 0x21, 0x99, 0xF6, 0x04, 0x18, 0xD2, + 0xE0, 0xAB, 0xFF, 0xE3, 0x1B, 0x61, 0x3B, 0xB9, + 0x80, 0xEA, 0x32, 0xB7, 0x6C, 0x82, 0x43, 0x8D, + 0x02, 0x5F, 0x67, 0x8C, 0xAF, 0x48, 0x24, 0xA4 + }, + { + 0xCF, 0xC0, 0x57, 0xFD, 0xA7, 0x8A, 0x50, 0x31, + 0x8F, 0x49, 0x78, 0xFF, 0xFF, 0xAF, 0x77, 0x17, + 0x98, 0xE1, 0x2C, 0x3E, 0xA8, 0xC7, 0x98, 0x19, + 0x5B, 0xC5, 0xB4, 0xE6, 0x89, 0x1E, 0x61, 0xAA, + 0x25, 0xF7, 0xAF, 0x4A, 0xA7, 0x28, 0x6A, 0xC8, + 0x50, 0x76, 0x62, 0xC9, 0x07, 0xED, 0x91, 0x3E, + 0xDA, 0x65, 0x8F, 0x63, 0xFC, 0x47, 0x99, 0x7C, + 0x59, 0xB8, 0x59, 0x70, 0xF8, 0x78, 0xCA, 0x18 + }, + { + 0xD8, 0xEB, 0xE0, 0xE6, 0x38, 0xFC, 0x53, 0x5B, + 0x52, 0xCB, 0x0A, 0xFC, 0xE0, 0xF8, 0x2D, 0xDE, + 0x28, 0x57, 0x01, 0xAF, 0xF3, 0x29, 0xA5, 0x4B, + 0xA0, 0x6D, 0xFD, 0x3D, 0x1B, 0x4B, 0x31, 0xF9, + 0xF4, 0xB2, 0x4D, 0x9D, 0x68, 0x36, 0xF1, 0x22, + 0x3D, 0x6D, 0xE6, 0x6B, 0xAE, 0x78, 0x88, 0xFE, + 0xBC, 0x20, 0x40, 0xCF, 0xE9, 0x30, 0xE6, 0x9C, + 0xED, 0x59, 0xDA, 0x6D, 0xA8, 0xA0, 0xA6, 0xA6 + }, + { + 0x16, 0xB8, 0xC5, 0x5C, 0xF2, 0xF1, 0x35, 0xA4, + 0x32, 0x59, 0x0D, 0x2D, 0x4C, 0xFA, 0x38, 0x59, + 0x2F, 0x59, 0x35, 0xF8, 0xE7, 0x1C, 0xE0, 0x8A, + 0x02, 0x06, 0xA0, 0xE5, 0xAB, 0xEA, 0x90, 0xB2, + 0xE1, 0x07, 0xEB, 0x86, 0xB9, 0x18, 0x82, 0x3B, + 0xDD, 0x3B, 0xD2, 0x66, 0x07, 0x22, 0xC8, 0xDB, + 0xFA, 0x66, 0xAB, 0xB9, 0xF8, 0x63, 0x8E, 0x46, + 0x34, 0x02, 0xF6, 0x57, 0xA1, 0x68, 0x64, 0x0A + }, + { + 0x6A, 0x6E, 0x89, 0x38, 0x4F, 0x53, 0x5F, 0x02, + 0x17, 0x6C, 0x48, 0xA9, 0x93, 0xD3, 0x68, 0x7B, + 0x38, 0x9B, 0xFC, 0x03, 0x05, 0x0C, 0x77, 0x70, + 0x86, 0x35, 0x5C, 0x1A, 0x55, 0x59, 0x77, 0x42, + 0xF0, 0xB7, 0x48, 0x34, 0xA7, 0x1D, 0x05, 0x2A, + 0xE8, 0xA8, 0x3D, 0xC3, 0x4A, 0x8F, 0xD7, 0xBA, + 0x5A, 0xA6, 0x9D, 0xBD, 0x61, 0x2A, 0x4C, 0x22, + 0xDF, 0x4F, 0x74, 0xE2, 0x52, 0x8F, 0xB7, 0xA3 + }, + { + 0x1E, 0x40, 0x38, 0xCF, 0xA5, 0x0D, 0x8B, 0x13, + 0xEF, 0x68, 0xBE, 0xC3, 0xB0, 0xFF, 0xD5, 0x62, + 0xA0, 0x7A, 0xD6, 0x34, 0xB5, 0x82, 0x82, 0x57, + 0xDB, 0xA8, 0x73, 0x04, 0xF8, 0x23, 0xA9, 0x00, + 0x49, 0x2A, 0x31, 0x37, 0x19, 0x8B, 0x60, 0x5C, + 0xC7, 0xF7, 0x7C, 0x33, 0xB8, 0xCA, 0x3D, 0x94, + 0x0F, 0xD9, 0xB3, 0x38, 0xCF, 0x6B, 0x7B, 0x36, + 0xE7, 0xD9, 0xD9, 0x27, 0x20, 0x97, 0x93, 0xD0 + }, + { + 0x5B, 0xA6, 0xCD, 0x98, 0x8F, 0xF9, 0xA4, 0x81, + 0x91, 0x42, 0x21, 0x7E, 0xD6, 0x5D, 0x43, 0x7B, + 0x41, 0x3B, 0xA5, 0x02, 0x6B, 0x55, 0x4D, 0x8D, + 0x94, 0xEA, 0x27, 0x02, 0xC0, 0x96, 0xD1, 0x01, + 0x47, 0x75, 0xDB, 0xA2, 0xCA, 0xE9, 0x6F, 0x1E, + 0x2E, 0x72, 0x29, 0xC3, 0x78, 0xF2, 0x0B, 0x03, + 0x89, 0xE1, 0x19, 0x54, 0x7F, 0xDD, 0x35, 0x22, + 0x4A, 0x61, 0x7F, 0xCD, 0xCD, 0x0C, 0xB3, 0xAF + }, + { + 0x2D, 0x20, 0x96, 0x12, 0x30, 0xE2, 0x50, 0xF8, + 0x1D, 0xDC, 0xD2, 0xD2, 0xAB, 0x3E, 0xF0, 0xDA, + 0xCF, 0x96, 0x85, 0x1E, 0xBA, 0xE5, 0x96, 0x34, + 0x47, 0x19, 0x2C, 0xDB, 0x89, 0xE4, 0x8E, 0x84, + 0xF3, 0x96, 0xEC, 0x9A, 0x09, 0x25, 0x27, 0x84, + 0xE1, 0x73, 0xAD, 0xA5, 0x2A, 0x9C, 0x81, 0xAC, + 0xDA, 0xB3, 0xD8, 0xD6, 0x83, 0x80, 0x24, 0x7A, + 0xE9, 0x75, 0x23, 0x9B, 0x01, 0x7D, 0xC1, 0xCE + }, + { + 0x35, 0x38, 0x3E, 0xA7, 0x76, 0x2B, 0x55, 0x31, + 0x0A, 0x7D, 0x57, 0xFB, 0xD5, 0xA5, 0x49, 0x97, + 0x57, 0x9B, 0x0B, 0xA3, 0x9A, 0x4E, 0xB8, 0x87, + 0x94, 0x2B, 0xD1, 0x4F, 0xD8, 0x48, 0x31, 0x88, + 0xE5, 0x00, 0x48, 0x83, 0x8D, 0x6C, 0x02, 0xDC, + 0x75, 0x89, 0x59, 0xA9, 0xF7, 0x4D, 0x83, 0x37, + 0x27, 0x43, 0xE8, 0x64, 0xC6, 0x01, 0xED, 0x70, + 0x40, 0xA9, 0xE8, 0x71, 0x52, 0xD4, 0xCF, 0xFB + }, + { + 0x0B, 0x22, 0x3B, 0x6A, 0x1C, 0x2D, 0x3A, 0xB3, + 0xF9, 0x07, 0x7A, 0x31, 0x7B, 0x7F, 0xE3, 0x2F, + 0x6F, 0x95, 0x7B, 0x7B, 0x17, 0x41, 0xF2, 0x71, + 0x77, 0x71, 0x83, 0x4D, 0x37, 0x96, 0xA1, 0x9B, + 0xA3, 0x62, 0x73, 0xC9, 0xEE, 0xD6, 0x4C, 0x07, + 0xFA, 0x4E, 0x9A, 0xF7, 0xA9, 0x8A, 0xCE, 0x9C, + 0x78, 0x9A, 0x79, 0xA5, 0xA0, 0xF9, 0x4D, 0x04, + 0x05, 0xAA, 0xF0, 0x4A, 0xF3, 0x1E, 0xD7, 0x97 + }, + { + 0x5A, 0x00, 0x7F, 0x58, 0x95, 0x52, 0x4A, 0x5E, + 0x80, 0x37, 0x03, 0x6E, 0x0F, 0x26, 0x39, 0xFD, + 0xA8, 0xC5, 0xC1, 0x51, 0x2D, 0x76, 0xE9, 0xD1, + 0x9B, 0x3D, 0xD2, 0xD5, 0xBA, 0x43, 0xF5, 0x07, + 0x97, 0x41, 0xA4, 0x58, 0x31, 0x3C, 0x5E, 0x02, + 0x40, 0x0C, 0xE0, 0x2C, 0xB6, 0x56, 0x80, 0xBE, + 0x28, 0x2E, 0xAC, 0xD9, 0xA2, 0x54, 0xEF, 0x1C, + 0xDD, 0xEE, 0xBD, 0xCE, 0xE8, 0x5D, 0x41, 0x87 + }, + { + 0xBE, 0x4D, 0xD1, 0xCC, 0xBD, 0xE1, 0x67, 0x00, + 0x04, 0xD0, 0xEF, 0xAB, 0x65, 0x43, 0xE9, 0x1C, + 0x4E, 0x46, 0x64, 0xE5, 0xA2, 0xA8, 0x8B, 0xAC, + 0x6D, 0xD2, 0x7D, 0x27, 0x64, 0x8D, 0x30, 0x2A, + 0x06, 0x5B, 0xE6, 0x07, 0x8B, 0x22, 0xE4, 0xC4, + 0xAB, 0x4F, 0x7F, 0x7C, 0xBF, 0xAF, 0xC1, 0xAD, + 0x86, 0xEC, 0x2A, 0x50, 0x4F, 0xE5, 0x85, 0x17, + 0x66, 0xF7, 0xA3, 0x24, 0x47, 0x57, 0xCB, 0x6F + }, + { + 0x0F, 0xB4, 0x48, 0x3F, 0x96, 0x59, 0x29, 0x6C, + 0xB9, 0x24, 0x5B, 0x57, 0x79, 0x2A, 0x1E, 0x6A, + 0x99, 0xF2, 0x87, 0x90, 0x07, 0x72, 0x87, 0x96, + 0x8A, 0xB3, 0xEF, 0x35, 0x89, 0xE6, 0x90, 0x24, + 0x06, 0xF1, 0xF3, 0x9D, 0xCC, 0xE0, 0x06, 0x1D, + 0xEA, 0x94, 0x0F, 0xC8, 0xC1, 0xC4, 0x9F, 0x4B, + 0x54, 0x5E, 0xED, 0x59, 0xE9, 0x6D, 0xDA, 0xE9, + 0x6A, 0x6C, 0x35, 0xB5, 0x59, 0x3C, 0x29, 0x77 + }, + { + 0x41, 0xD1, 0xFA, 0xDC, 0x60, 0xA4, 0x6C, 0x9A, + 0xD0, 0x12, 0x0A, 0x3F, 0x54, 0xD0, 0x05, 0xF5, + 0xA1, 0x07, 0x5E, 0x2F, 0x71, 0xEE, 0x0D, 0xA6, + 0x18, 0xBA, 0xC1, 0x46, 0x1E, 0xFA, 0xE9, 0x69, + 0xEC, 0xCD, 0x7A, 0xA5, 0x75, 0xC4, 0xCD, 0xAE, + 0x97, 0x1D, 0xED, 0x13, 0xAE, 0x13, 0xC5, 0x06, + 0x87, 0x2C, 0xEC, 0xB5, 0xB2, 0x08, 0xFA, 0x72, + 0xA9, 0x48, 0x40, 0x02, 0x3E, 0xDB, 0x3E, 0xFE + }, + { + 0x2F, 0x7F, 0xDC, 0x1D, 0xA4, 0x4B, 0x6E, 0x5D, + 0x2D, 0xEC, 0xDE, 0x82, 0x1A, 0xAF, 0x4B, 0x49, + 0x16, 0x8C, 0x02, 0xE8, 0xD5, 0xF2, 0x5D, 0x5C, + 0x69, 0x98, 0x71, 0x08, 0x3A, 0xEB, 0xD9, 0x28, + 0xB7, 0x4D, 0xC2, 0x2D, 0xCB, 0xED, 0xFA, 0xBA, + 0x93, 0x16, 0xAE, 0xFC, 0xA8, 0x48, 0xD1, 0x5F, + 0x05, 0x17, 0x32, 0x99, 0x03, 0xD3, 0x4B, 0x83, + 0x70, 0xDD, 0xF9, 0xBD, 0x58, 0xC6, 0xD0, 0xCD + }, + { + 0x88, 0x55, 0x8A, 0x46, 0x4E, 0xE1, 0xA8, 0x80, + 0x3B, 0x23, 0x95, 0xAF, 0x6A, 0x64, 0x90, 0x84, + 0x2B, 0x5C, 0xD4, 0x3D, 0x41, 0xF6, 0xC0, 0x7C, + 0xD6, 0xC5, 0xF8, 0x5F, 0x82, 0xF5, 0x84, 0x32, + 0xA0, 0xB1, 0x62, 0xB4, 0x38, 0xBF, 0x0C, 0xB7, + 0x08, 0x2A, 0x76, 0x73, 0xE2, 0x87, 0xD6, 0xB9, + 0x0F, 0x8D, 0x0D, 0xC8, 0xAA, 0x5C, 0xEB, 0xA3, + 0x6B, 0xFA, 0x77, 0xB1, 0x5B, 0xA0, 0x69, 0x16 + }, + { + 0xEC, 0xC1, 0x49, 0x91, 0x7B, 0x26, 0x63, 0x98, + 0xB6, 0xF3, 0x29, 0x7E, 0x96, 0x96, 0x73, 0xB1, + 0x4E, 0xAE, 0x69, 0xCE, 0x43, 0x67, 0x1F, 0xD3, + 0xC6, 0xC2, 0x15, 0xC7, 0xCF, 0x42, 0xDE, 0xA1, + 0x02, 0xFC, 0x6B, 0xD9, 0x0C, 0x87, 0xDB, 0xD4, + 0x29, 0x02, 0x51, 0x12, 0x9C, 0xC1, 0x9B, 0x38, + 0xCC, 0xF0, 0x0C, 0xBD, 0xB1, 0x6D, 0xD8, 0xDE, + 0x51, 0x58, 0x60, 0x1A, 0x41, 0x6B, 0x1F, 0x00 + }, + { + 0xED, 0x30, 0x12, 0xF8, 0x9D, 0x71, 0xED, 0x13, + 0xBB, 0x82, 0x72, 0xEC, 0xDC, 0x3D, 0x0F, 0x51, + 0xE1, 0x4A, 0x37, 0xC1, 0xEF, 0x77, 0x57, 0x77, + 0x7A, 0xDA, 0x67, 0x12, 0x78, 0x4B, 0xE1, 0x6E, + 0xCF, 0xD3, 0xE6, 0x40, 0x58, 0x30, 0xF5, 0x1D, + 0xB3, 0x3D, 0xCB, 0x85, 0x52, 0x92, 0x93, 0xE2, + 0x3E, 0x47, 0x3A, 0xBF, 0x8C, 0x5C, 0x76, 0x55, + 0xD0, 0xC4, 0xF1, 0x52, 0xD0, 0x48, 0xBA, 0xB2 + }, + { + 0x09, 0x7A, 0x81, 0x19, 0x1E, 0x10, 0x05, 0x67, + 0x6D, 0x6E, 0x22, 0xA9, 0x63, 0x48, 0xFA, 0x4A, + 0x7C, 0x95, 0x61, 0xFD, 0x4D, 0x22, 0x8E, 0xB2, + 0x5F, 0x29, 0x47, 0x56, 0xBB, 0x87, 0xA2, 0xBA, + 0x88, 0x47, 0x5B, 0x03, 0x6F, 0x79, 0xFE, 0x37, + 0x3D, 0x75, 0x40, 0x87, 0x05, 0x52, 0x00, 0x1D, + 0x54, 0x79, 0x5F, 0x25, 0x92, 0x39, 0xBE, 0x6D, + 0x32, 0xC4, 0x87, 0xD1, 0x94, 0x4F, 0x1F, 0xE7 + }, + { + 0x3F, 0xC7, 0x98, 0xE4, 0x69, 0xD3, 0x90, 0x86, + 0xBA, 0x0B, 0xB4, 0x06, 0x3E, 0x80, 0x5F, 0xDF, + 0xB2, 0x20, 0x8D, 0xE4, 0x99, 0x18, 0x41, 0x73, + 0xF9, 0xA2, 0x36, 0x4D, 0x56, 0xBC, 0xD5, 0x63, + 0xED, 0x61, 0x9B, 0xB6, 0x87, 0x32, 0x24, 0x25, + 0x01, 0x4A, 0x1A, 0xAD, 0x3B, 0xCF, 0x50, 0xD2, + 0x2D, 0x83, 0xA9, 0x9D, 0x09, 0x73, 0x0A, 0x92, + 0xEC, 0x65, 0x46, 0xB3, 0xFC, 0x40, 0xA2, 0xC6 + }, + { + 0x69, 0x12, 0xB4, 0xB3, 0x41, 0xC7, 0xDD, 0x70, + 0x68, 0x37, 0x38, 0xBA, 0x0E, 0x7D, 0xEB, 0xBA, + 0xBF, 0xCA, 0x5F, 0x4F, 0xB0, 0x76, 0x0C, 0x84, + 0x97, 0x76, 0xE9, 0x20, 0x75, 0x0B, 0xF1, 0x37, + 0x89, 0xA6, 0x99, 0x97, 0x96, 0x23, 0x4E, 0x9E, + 0x24, 0x07, 0x15, 0xB2, 0x67, 0x67, 0x78, 0x2B, + 0x85, 0xA6, 0x4D, 0x68, 0x0C, 0x6D, 0x4C, 0xD4, + 0x26, 0xAD, 0x72, 0xB2, 0xFC, 0xE0, 0x81, 0xE8 + }, + { + 0xCE, 0xCD, 0x14, 0x01, 0x50, 0x15, 0x7D, 0xC9, + 0x06, 0xC0, 0xFF, 0x7F, 0x87, 0xC0, 0x08, 0x8F, + 0x31, 0x64, 0x80, 0x78, 0x3B, 0x4F, 0xE0, 0xA5, + 0x94, 0x45, 0x10, 0xC6, 0x4A, 0x87, 0xE3, 0xED, + 0x06, 0x67, 0x97, 0xA2, 0x7C, 0xE9, 0xD0, 0xF2, + 0x84, 0xDC, 0xA5, 0x18, 0x44, 0x18, 0x08, 0xAC, + 0x18, 0x29, 0x0A, 0xFD, 0xC0, 0x31, 0x29, 0x4B, + 0x31, 0xAA, 0x8B, 0x4A, 0x9F, 0xCD, 0x78, 0xF8 + }, + { + 0x2A, 0x2B, 0xED, 0x5D, 0x6A, 0xC0, 0x89, 0x28, + 0x11, 0xA4, 0x09, 0xD9, 0xF1, 0xFF, 0x63, 0x03, + 0xCC, 0xF9, 0x55, 0x44, 0x57, 0x46, 0x99, 0xCD, + 0xA7, 0xF7, 0x35, 0x03, 0x01, 0xF6, 0xD0, 0xC4, + 0xE8, 0x6E, 0x63, 0x5C, 0x80, 0x87, 0x56, 0x66, + 0xE2, 0xBB, 0x39, 0x07, 0x51, 0x0D, 0x0E, 0x72, + 0x12, 0x0F, 0x04, 0x86, 0x5E, 0xDC, 0x4C, 0x6C, + 0xEE, 0xCB, 0x44, 0x62, 0xD6, 0xAF, 0x60, 0xFB + }, + { + 0x03, 0x85, 0xAE, 0x9B, 0x73, 0x5D, 0xC5, 0x9F, + 0x30, 0x4D, 0x41, 0x4C, 0xA0, 0x43, 0x74, 0x9A, + 0xB5, 0x1A, 0xB6, 0x65, 0xEE, 0x01, 0xBE, 0x5E, + 0x52, 0xDC, 0xF7, 0x25, 0xEE, 0x7D, 0xFE, 0xFE, + 0xA6, 0xAD, 0x73, 0xF3, 0x35, 0xEE, 0xCF, 0x2A, + 0x51, 0x02, 0xE8, 0x88, 0x07, 0xFD, 0xC7, 0x5A, + 0xE6, 0xDC, 0x49, 0x0D, 0x7B, 0x8B, 0x5F, 0x11, + 0x63, 0x03, 0xEF, 0x60, 0xA5, 0xF1, 0x7C, 0x06 + }, + { + 0x0C, 0xA3, 0xFF, 0x03, 0x89, 0x65, 0xC0, 0x3B, + 0xC6, 0x5B, 0xBE, 0x2D, 0x86, 0x6C, 0xE9, 0xE0, + 0xE4, 0xE7, 0xD0, 0x3D, 0xC7, 0xF8, 0x6B, 0xA5, + 0x65, 0x0F, 0x82, 0xDD, 0xB3, 0xA9, 0xAA, 0x84, + 0x6B, 0x2B, 0x1F, 0x55, 0x3B, 0xD8, 0x9F, 0xB4, + 0xF9, 0xB6, 0x2E, 0x3C, 0x7F, 0xAF, 0x9E, 0xC3, + 0x10, 0x9F, 0xA9, 0x0E, 0xE5, 0x6C, 0x24, 0x63, + 0xE6, 0xEF, 0xD1, 0xAB, 0xAD, 0x8E, 0x28, 0xE6 + }, + { + 0x6D, 0xFD, 0x4F, 0x22, 0x18, 0x4E, 0xD0, 0x91, + 0xFD, 0x5A, 0xBA, 0x03, 0x9F, 0xCD, 0x3D, 0xB9, + 0x22, 0xF5, 0xE5, 0x9B, 0xF8, 0x38, 0xC0, 0x37, + 0x35, 0x7F, 0xAD, 0x93, 0x4B, 0x45, 0x10, 0x60, + 0x3F, 0x43, 0xA7, 0x31, 0x9F, 0xFF, 0xA6, 0x23, + 0x86, 0xF8, 0x78, 0x8F, 0xDF, 0x9D, 0xED, 0x40, + 0xC6, 0x66, 0xB4, 0xBD, 0xCA, 0x86, 0xD9, 0x32, + 0x8F, 0xE5, 0x5A, 0xD8, 0x6B, 0x37, 0x2F, 0xC8 + }, + { + 0xA3, 0x18, 0x97, 0x61, 0x02, 0x74, 0x7D, 0x80, + 0x0F, 0x58, 0x4D, 0xF6, 0x5B, 0xFB, 0x44, 0x3B, + 0x85, 0x6F, 0x00, 0x9E, 0x74, 0xF7, 0x29, 0x46, + 0xD0, 0x07, 0x6C, 0xED, 0xAC, 0x04, 0x37, 0x6F, + 0xAB, 0x97, 0x34, 0x53, 0xAD, 0xAD, 0xC3, 0x10, + 0xF7, 0x20, 0x81, 0xCB, 0xBA, 0x96, 0x26, 0x4F, + 0xFE, 0x2B, 0x21, 0xA3, 0xB1, 0x8B, 0xE9, 0xD8, + 0x8C, 0x42, 0x46, 0xCB, 0xA6, 0xD3, 0x09, 0x01 + }, + { + 0xB5, 0xE6, 0xE4, 0xFC, 0xA0, 0xCF, 0x98, 0x48, + 0xA0, 0x05, 0x89, 0xC6, 0x54, 0x57, 0xDB, 0x68, + 0xB3, 0x25, 0x3A, 0x6E, 0x17, 0x78, 0x85, 0x41, + 0x47, 0x2E, 0x1F, 0xB9, 0x48, 0x17, 0xF8, 0x04, + 0x05, 0x4D, 0x07, 0xA5, 0xD3, 0x2D, 0xFA, 0x0C, + 0xDB, 0x6F, 0xB4, 0x4E, 0xED, 0x50, 0xD2, 0x0E, + 0x5F, 0x22, 0x64, 0x36, 0x11, 0x32, 0xFA, 0x5F, + 0xCF, 0xD6, 0xE1, 0xB3, 0x67, 0xC1, 0xBE, 0x28 + }, + { + 0x2E, 0xA4, 0x57, 0x38, 0x29, 0x25, 0xE0, 0x3C, + 0xF8, 0x11, 0x10, 0x05, 0x0E, 0x63, 0x6A, 0xD6, + 0x78, 0xE0, 0xAA, 0x3C, 0xBC, 0x69, 0x00, 0xBD, + 0xEF, 0x27, 0x8A, 0xAA, 0x18, 0xF2, 0x35, 0xE2, + 0x51, 0x60, 0xA2, 0x0E, 0x23, 0xFE, 0x0E, 0x62, + 0xA8, 0x51, 0x1B, 0x5D, 0xD0, 0x59, 0x2F, 0x79, + 0xCB, 0xC8, 0xEB, 0x7D, 0xEA, 0x64, 0xAC, 0x86, + 0x67, 0x49, 0x43, 0x45, 0xC6, 0x89, 0x2D, 0xD4 + }, + { + 0x96, 0xB3, 0x49, 0x8B, 0xCC, 0xD7, 0x8B, 0x5A, + 0x40, 0x1B, 0x27, 0x38, 0x78, 0x7D, 0x28, 0xA9, + 0x8A, 0x0E, 0xDF, 0xDC, 0x7C, 0x0B, 0x5F, 0xF9, + 0x43, 0xCF, 0xE1, 0xB1, 0x4E, 0x9C, 0xF5, 0xD9, + 0xED, 0x43, 0x10, 0x7D, 0xFB, 0xDD, 0x9E, 0x97, + 0x28, 0xD5, 0xFD, 0xD6, 0xF7, 0x1F, 0xBC, 0x77, + 0x0E, 0xAD, 0xDC, 0x4F, 0x2E, 0x40, 0x9A, 0xBE, + 0x71, 0x92, 0x7B, 0xAE, 0x1F, 0x8F, 0x73, 0xD1 + }, + { + 0xCE, 0x1B, 0xFB, 0x9A, 0xFE, 0xD2, 0x8A, 0xF4, + 0xDC, 0x75, 0x35, 0xAD, 0xEF, 0x71, 0xB8, 0xF1, + 0xB8, 0x0A, 0x8D, 0x72, 0x94, 0xB4, 0x11, 0xFD, + 0x1E, 0xD3, 0x93, 0xCF, 0x23, 0x2D, 0x3A, 0x5C, + 0x5D, 0xF2, 0x3D, 0xBB, 0x1D, 0xB2, 0x6D, 0xDD, + 0xF6, 0xF7, 0x45, 0xF8, 0xBC, 0x24, 0xC3, 0x78, + 0x1F, 0x2D, 0xBB, 0xC8, 0x18, 0xA0, 0x0A, 0xE1, + 0xFB, 0x9D, 0x64, 0x63, 0xE9, 0x5F, 0x29, 0x86 + }, + { + 0xE6, 0x4D, 0x37, 0x35, 0x6B, 0x29, 0x6B, 0x36, + 0x93, 0x0E, 0xAB, 0xE4, 0x54, 0xDB, 0x11, 0xB2, + 0x09, 0x7B, 0x0C, 0x04, 0x0B, 0xED, 0x57, 0x98, + 0x87, 0x8D, 0x38, 0xA8, 0xC4, 0xD1, 0xC6, 0xF3, + 0x26, 0x1F, 0x36, 0xBF, 0xF7, 0x64, 0xE3, 0xB4, + 0xD6, 0x06, 0xB3, 0x17, 0xE5, 0xFF, 0x50, 0x04, + 0x18, 0x45, 0x92, 0xB0, 0xB7, 0xDD, 0xFB, 0x8C, + 0x2F, 0xD8, 0x35, 0x23, 0x26, 0xCD, 0xDD, 0xB1 + }, + { + 0x85, 0xE6, 0xFE, 0x54, 0xE1, 0xE7, 0x60, 0x46, + 0xAF, 0x68, 0xF5, 0xC6, 0x04, 0x4C, 0x1E, 0x3F, + 0xFF, 0x3B, 0xFC, 0xA0, 0xBA, 0xEC, 0xAE, 0xF6, + 0xA1, 0xDF, 0x90, 0x35, 0x0D, 0xF2, 0xB0, 0xBE, + 0xC6, 0xA4, 0x20, 0xEE, 0x8F, 0x49, 0xAD, 0x44, + 0x64, 0xEC, 0x4C, 0x1E, 0x7D, 0x71, 0xF6, 0x67, + 0x61, 0x4A, 0xCE, 0xBD, 0xAD, 0xA3, 0xDF, 0x32, + 0x07, 0x79, 0x07, 0x83, 0x23, 0xF6, 0xA8, 0xAF + }, + { + 0xB1, 0x2F, 0xF1, 0xEB, 0x3B, 0xAB, 0x32, 0x0D, + 0x78, 0x55, 0xB5, 0x49, 0xD7, 0x2B, 0x72, 0x47, + 0x59, 0x91, 0x68, 0x11, 0xCB, 0xCF, 0x3E, 0x1A, + 0x12, 0x82, 0x3F, 0x98, 0xB6, 0x4A, 0xB5, 0xC4, + 0x59, 0x41, 0x61, 0x0F, 0x6B, 0x47, 0x1E, 0x35, + 0xFF, 0x79, 0x28, 0x29, 0xDD, 0x5A, 0xDE, 0x51, + 0x79, 0x12, 0x57, 0x38, 0xF3, 0xF2, 0x37, 0x28, + 0x63, 0x0F, 0x1E, 0xEC, 0x57, 0x77, 0x5A, 0x19 + }, + { + 0xB4, 0xDB, 0xE7, 0x2A, 0x1E, 0x21, 0x69, 0x7A, + 0x47, 0x44, 0xBE, 0x65, 0x00, 0x0C, 0xB1, 0xBA, + 0xD3, 0x7C, 0xE2, 0x14, 0x16, 0xEE, 0x6F, 0xCE, + 0xA8, 0x4E, 0xBA, 0xF1, 0x2A, 0x59, 0xC1, 0x1D, + 0x7C, 0x08, 0x0D, 0xF9, 0x2F, 0xB2, 0xAA, 0x8F, + 0x1C, 0x4E, 0xE8, 0xE2, 0xA2, 0x2D, 0x30, 0xBE, + 0x49, 0x85, 0x82, 0xD7, 0xC5, 0xFB, 0xBA, 0x16, + 0x5A, 0x47, 0x26, 0x89, 0xAF, 0xF6, 0x01, 0xB6 + }, + { + 0x34, 0x82, 0x18, 0xBE, 0x4D, 0xE0, 0x8D, 0xFB, + 0x24, 0x5B, 0xF2, 0x52, 0x86, 0xE3, 0x66, 0x18, + 0x63, 0x1D, 0x3B, 0xDB, 0x58, 0x27, 0xD9, 0xF7, + 0x4F, 0xA0, 0x43, 0x01, 0x66, 0x11, 0x31, 0xA4, + 0xD5, 0x5C, 0x76, 0x09, 0xB1, 0xA6, 0xA0, 0x3B, + 0x85, 0x3F, 0x07, 0x33, 0xE0, 0xAE, 0xC0, 0x26, + 0x16, 0xA0, 0xA4, 0x0E, 0x84, 0x91, 0xF4, 0x94, + 0xD7, 0x6C, 0x15, 0x43, 0xCF, 0xC6, 0x82, 0x14 + }, + { + 0x42, 0x87, 0xE1, 0x9B, 0xAB, 0x1D, 0x4F, 0x75, + 0xE1, 0xD1, 0x97, 0xCB, 0xB4, 0x3F, 0x11, 0x33, + 0x13, 0x07, 0xF2, 0xF7, 0x5B, 0x8D, 0x0D, 0x50, + 0x27, 0x8E, 0xEC, 0x54, 0x09, 0x99, 0xA0, 0x09, + 0xC0, 0x33, 0x73, 0x52, 0x96, 0x07, 0xFD, 0xA6, + 0x05, 0xAA, 0x0F, 0x07, 0x39, 0xE2, 0x0B, 0xD1, + 0xFD, 0xAA, 0x27, 0xD7, 0xC0, 0xCD, 0xC8, 0x28, + 0x4D, 0x98, 0xE6, 0xC7, 0x55, 0xA7, 0x56, 0x2E + }, + { + 0x08, 0x56, 0x0C, 0x99, 0x88, 0xC8, 0xCE, 0x5A, + 0x88, 0x76, 0xA6, 0x00, 0xB6, 0xE5, 0x12, 0xB4, + 0xE2, 0x43, 0xA4, 0xA4, 0x30, 0x0A, 0xD5, 0xAB, + 0x2F, 0xF0, 0x63, 0x7C, 0xC5, 0x6A, 0x04, 0x41, + 0x64, 0x5B, 0x3D, 0xEB, 0x16, 0x84, 0x06, 0x4E, + 0xA4, 0x3B, 0xAE, 0x1C, 0xB6, 0x2D, 0x3B, 0xC4, + 0x15, 0x37, 0xFE, 0x8D, 0x7D, 0xEC, 0xA7, 0x17, + 0x29, 0x37, 0x77, 0x6B, 0xBE, 0xD7, 0x93, 0xA9 + }, + { + 0xB5, 0x36, 0x16, 0x23, 0x94, 0x77, 0x6F, 0xA7, + 0xDD, 0x5E, 0x9F, 0xDD, 0x01, 0x53, 0x0F, 0xDA, + 0x52, 0xBE, 0x1D, 0x39, 0xBD, 0x60, 0x9B, 0x3F, + 0x3B, 0xD0, 0x47, 0x6B, 0x81, 0x60, 0xAA, 0x18, + 0xAB, 0x2D, 0x37, 0xD2, 0x99, 0x16, 0x28, 0xBE, + 0x2F, 0xCC, 0x12, 0x56, 0xCD, 0x48, 0x55, 0x25, + 0xD1, 0xFA, 0x35, 0x6B, 0x04, 0xD3, 0x0E, 0x4A, + 0x0F, 0x9F, 0xFF, 0xC9, 0x93, 0x5C, 0xF4, 0x32 + }, + { + 0x02, 0xAB, 0xC9, 0x71, 0x75, 0xED, 0xB4, 0x7A, + 0x4C, 0xB4, 0xBD, 0x38, 0xD8, 0x2F, 0x86, 0xAA, + 0x09, 0x9C, 0x8B, 0x8F, 0xA8, 0xAB, 0x3F, 0xE1, + 0xCE, 0x10, 0x5A, 0x22, 0xBD, 0x61, 0x65, 0x78, + 0xC6, 0xDD, 0x15, 0x15, 0xDF, 0xB0, 0x39, 0x7E, + 0x1D, 0x9D, 0x06, 0x71, 0x91, 0x6D, 0xE4, 0xB5, + 0x22, 0xE7, 0x4E, 0x63, 0x75, 0x23, 0x68, 0x93, + 0xC8, 0xFD, 0xA6, 0xD2, 0x36, 0xBC, 0x8D, 0xA1 + }, + { + 0x21, 0xE1, 0xEB, 0x73, 0x12, 0x76, 0xA8, 0x35, + 0xA6, 0xDD, 0xEA, 0x71, 0x78, 0xB2, 0x3E, 0xBC, + 0x9A, 0xEC, 0xAA, 0xBC, 0x7C, 0xCD, 0x70, 0x65, + 0x87, 0xD7, 0x1B, 0x85, 0x44, 0x97, 0x93, 0xB0, + 0x7E, 0x7B, 0x17, 0x9A, 0x3D, 0xA7, 0xA5, 0x71, + 0x98, 0x29, 0x97, 0xE8, 0xF5, 0xA6, 0x7F, 0x8C, + 0x93, 0xDA, 0xF1, 0x1A, 0xAA, 0x23, 0xF0, 0x7E, + 0x4D, 0xF7, 0xA1, 0x31, 0x05, 0xA5, 0x42, 0x09 + }, + { + 0x1C, 0xC5, 0x37, 0xD3, 0xE5, 0x0E, 0xD9, 0xFD, + 0xCD, 0xC4, 0xF3, 0xCC, 0xB4, 0x81, 0x93, 0x75, + 0x41, 0x53, 0x04, 0xD8, 0xE5, 0xA6, 0xC0, 0x58, + 0x05, 0xB6, 0xB5, 0xD9, 0xE1, 0xFC, 0x18, 0x25, + 0x68, 0x64, 0xF1, 0x0C, 0xD8, 0x12, 0xF8, 0x48, + 0x01, 0xB8, 0x61, 0x6A, 0x92, 0xB4, 0x07, 0x95, + 0xA1, 0x55, 0x93, 0x24, 0x64, 0xF6, 0x2D, 0xBF, + 0x6E, 0xBD, 0x2F, 0x9A, 0xC3, 0xEE, 0x28, 0x16 + }, + { + 0x6F, 0x6C, 0xD2, 0x60, 0x05, 0xC8, 0xA5, 0x61, + 0xCF, 0xF5, 0x1E, 0x30, 0x1D, 0x1A, 0x06, 0x8F, + 0xC2, 0x8B, 0x9B, 0x65, 0x0D, 0xDD, 0x27, 0xAE, + 0x97, 0xB5, 0x22, 0xDA, 0xE9, 0x63, 0x91, 0x34, + 0xD5, 0xA1, 0x50, 0x58, 0x7B, 0x0A, 0x90, 0x1F, + 0x3B, 0x9A, 0xAB, 0xC7, 0xE3, 0x97, 0x84, 0x98, + 0x4C, 0xC5, 0x85, 0x23, 0x5D, 0x8E, 0x17, 0xCE, + 0x9E, 0x3B, 0x42, 0x10, 0x5B, 0xF9, 0x03, 0x4C + }, + { + 0x69, 0xC1, 0x7C, 0x28, 0x64, 0xC3, 0x37, 0x9F, + 0xAF, 0xB7, 0x14, 0xC0, 0x47, 0x5E, 0x00, 0xCF, + 0x7C, 0x9B, 0x37, 0x7D, 0x57, 0xA8, 0xBC, 0x96, + 0x98, 0xB4, 0xD3, 0x4A, 0x54, 0x85, 0x41, 0x76, + 0xA2, 0xF8, 0xD1, 0x5A, 0xFB, 0x54, 0x77, 0x56, + 0x04, 0x78, 0x73, 0x90, 0xD6, 0x00, 0x74, 0xCD, + 0x4B, 0xCA, 0x69, 0x02, 0xEA, 0x23, 0xD3, 0xAE, + 0x1A, 0xC0, 0x83, 0x40, 0x9F, 0xE3, 0x8A, 0x4D + }, + { + 0x86, 0x69, 0xB0, 0xAD, 0x35, 0x82, 0x9E, 0xDC, + 0x2A, 0x8A, 0x09, 0x85, 0x2B, 0x0E, 0xE9, 0xB3, + 0x90, 0x3B, 0xF6, 0xC1, 0xF8, 0x2F, 0x90, 0xA3, + 0xF0, 0xED, 0x95, 0x24, 0x19, 0x2F, 0x10, 0x91, + 0xFD, 0x64, 0x84, 0xE0, 0x4C, 0x3F, 0xEA, 0x8B, + 0x02, 0x2F, 0x4A, 0x89, 0x50, 0xDB, 0x17, 0xD4, + 0x73, 0x41, 0x45, 0xC0, 0xCE, 0xC5, 0xDC, 0x38, + 0x74, 0x55, 0xC1, 0x26, 0x90, 0x3F, 0x77, 0x66 + }, + { + 0x3F, 0x35, 0xC4, 0x5D, 0x24, 0xFC, 0xFB, 0x4A, + 0xCC, 0xA6, 0x51, 0x07, 0x6C, 0x08, 0x00, 0x0E, + 0x27, 0x9E, 0xBB, 0xFF, 0x37, 0xA1, 0x33, 0x3C, + 0xE1, 0x9F, 0xD5, 0x77, 0x20, 0x2D, 0xBD, 0x24, + 0xB5, 0x8C, 0x51, 0x4E, 0x36, 0xDD, 0x9B, 0xA6, + 0x4A, 0xF4, 0xD7, 0x8E, 0xEA, 0x4E, 0x2D, 0xD1, + 0x3B, 0xC1, 0x8D, 0x79, 0x88, 0x87, 0xDD, 0x97, + 0x13, 0x76, 0xBC, 0xAE, 0x00, 0x87, 0xE1, 0x7E + }, + { + 0xEF, 0x11, 0x32, 0xD8, 0x66, 0x05, 0x58, 0x76, + 0xC1, 0x59, 0x59, 0x55, 0x7D, 0x79, 0xCF, 0xF0, + 0x53, 0x9B, 0x93, 0xB2, 0x6F, 0x47, 0xBF, 0x41, + 0x83, 0x74, 0x89, 0x21, 0xDF, 0x72, 0xC3, 0xED, + 0x94, 0xB0, 0xA5, 0xE9, 0x5E, 0x17, 0xA4, 0xBB, + 0xC5, 0x94, 0x37, 0xF3, 0x45, 0x64, 0xE6, 0x0D, + 0x20, 0x92, 0x3D, 0xD6, 0x43, 0x42, 0x0F, 0x5C, + 0xA2, 0x5B, 0x2C, 0xA7, 0xEC, 0x1C, 0xED, 0xA4 + }, + { + 0xA4, 0xCE, 0x27, 0x08, 0x20, 0xB7, 0x5A, 0xED, + 0xD3, 0x2A, 0x0E, 0xE0, 0x9E, 0x10, 0x87, 0xAC, + 0x8C, 0xCD, 0x67, 0xF2, 0x00, 0xFB, 0xCB, 0x7E, + 0xA7, 0x6E, 0xEE, 0x60, 0x24, 0xD4, 0xCB, 0x0F, + 0x09, 0x2A, 0xE8, 0x20, 0x74, 0x90, 0x70, 0xEF, + 0xA9, 0xAC, 0x6A, 0xC0, 0x78, 0x83, 0x25, 0x2C, + 0xD9, 0xBB, 0x74, 0x67, 0x83, 0xD9, 0x45, 0xAC, + 0x07, 0x23, 0x50, 0xAC, 0xAB, 0x80, 0xB0, 0x1C + }, + { + 0xC4, 0xB0, 0x58, 0xED, 0x68, 0xBF, 0xCD, 0x16, + 0x5A, 0x27, 0x0D, 0x8B, 0x4E, 0xF9, 0xC9, 0x8E, + 0x0A, 0x09, 0x34, 0xB4, 0x67, 0x82, 0xA1, 0xE2, + 0x58, 0xD9, 0x2C, 0x8C, 0xD5, 0x95, 0xD6, 0x56, + 0x5B, 0xA1, 0xB0, 0x42, 0x26, 0x77, 0xA1, 0x5E, + 0x91, 0x65, 0x23, 0x24, 0xA8, 0xF8, 0xCE, 0x03, + 0x5E, 0x7D, 0x11, 0xC3, 0x6F, 0xD7, 0x3E, 0xF2, + 0xF8, 0xEA, 0x6A, 0xDE, 0x78, 0xD3, 0xD0, 0x6F + }, + { + 0x1F, 0x38, 0xC1, 0x7A, 0xAC, 0x0E, 0xE9, 0xC5, + 0xD8, 0xC0, 0x97, 0x0D, 0x9A, 0xA2, 0xDF, 0xE2, + 0xC6, 0x61, 0xBE, 0xA3, 0xDF, 0x69, 0xBF, 0xAC, + 0x5A, 0xCE, 0x1F, 0x4A, 0x24, 0xFC, 0x5B, 0x54, + 0x6A, 0x2A, 0xA3, 0xBD, 0xA1, 0x77, 0x1E, 0xBA, + 0xC2, 0xE0, 0x4B, 0xD4, 0x58, 0x73, 0x0E, 0x81, + 0x13, 0xA3, 0x7C, 0x0C, 0x70, 0x10, 0xDD, 0xD9, + 0xD6, 0x57, 0x85, 0xCC, 0xB3, 0x47, 0x38, 0x9E + }, + { + 0x78, 0x8F, 0x37, 0x9F, 0xF2, 0xC0, 0x6B, 0x8B, + 0xB0, 0xD4, 0x5C, 0x69, 0x3C, 0xFB, 0xE3, 0x43, + 0x06, 0x4B, 0xB2, 0x9D, 0xD1, 0xA0, 0xE6, 0x16, + 0x64, 0xDF, 0xB4, 0x10, 0x15, 0xB0, 0xE1, 0x67, + 0xC0, 0xF2, 0xCF, 0x2F, 0x70, 0x39, 0xFE, 0xC2, + 0xC5, 0xD3, 0x95, 0x76, 0xAB, 0x29, 0x51, 0x27, + 0x61, 0x11, 0x2F, 0x94, 0xFB, 0x24, 0x27, 0x01, + 0x4A, 0xF3, 0x27, 0x71, 0xDF, 0x02, 0xDA, 0xE2 + }, + { + 0xB2, 0x98, 0x60, 0xE5, 0x48, 0xB4, 0x18, 0x2A, + 0xBB, 0xC6, 0x44, 0x10, 0x05, 0x6C, 0xFB, 0x6B, + 0x56, 0x21, 0x0F, 0x76, 0xA7, 0x87, 0x71, 0x90, + 0x98, 0xDB, 0xE7, 0x59, 0xB3, 0x05, 0xC7, 0xCA, + 0xB1, 0x30, 0x45, 0x35, 0x32, 0xAE, 0x68, 0xD1, + 0xD1, 0x33, 0xAE, 0xA9, 0x05, 0x1B, 0x27, 0x5C, + 0xAE, 0xAB, 0xC5, 0xBE, 0x96, 0x33, 0xED, 0x02, + 0x47, 0x54, 0xDC, 0x5E, 0x4E, 0xF9, 0x82, 0x3C + }, + { + 0xCC, 0xC7, 0x2D, 0x82, 0x2F, 0x6E, 0x3B, 0xF7, + 0x32, 0xF5, 0xEC, 0x6A, 0x5D, 0x5F, 0x17, 0xB4, + 0xD6, 0xAF, 0x0C, 0xDE, 0x67, 0xCB, 0x6F, 0xEA, + 0x25, 0x98, 0xA1, 0x51, 0xF4, 0x9D, 0xCE, 0xE8, + 0xB0, 0xF5, 0x2D, 0x64, 0x2A, 0xEB, 0x1C, 0xD3, + 0x0C, 0x47, 0xA0, 0x11, 0xA9, 0x94, 0x1E, 0x5E, + 0x78, 0x7F, 0x0C, 0x55, 0xF0, 0xE8, 0x99, 0x25, + 0xE7, 0xC0, 0x16, 0x38, 0x93, 0x03, 0x22, 0xC8 + }, + { + 0xF0, 0x1A, 0xF2, 0xDD, 0x29, 0x61, 0x76, 0x6E, + 0x7C, 0x6C, 0xB4, 0xB4, 0xA2, 0x13, 0xA3, 0xEA, + 0xC4, 0xE0, 0x11, 0xE5, 0xD6, 0x49, 0xCC, 0x8E, + 0x57, 0xB4, 0x58, 0x8C, 0x58, 0xE0, 0x86, 0x72, + 0x46, 0xF1, 0x5F, 0xB2, 0xA7, 0x98, 0xB9, 0x56, + 0xBE, 0xE2, 0x0A, 0x3B, 0x58, 0x6A, 0x48, 0xE5, + 0x6D, 0xD5, 0x91, 0xD8, 0xE4, 0xF7, 0x34, 0xF6, + 0x12, 0xFF, 0x04, 0x24, 0x9B, 0x53, 0x43, 0x04 + }, + { + 0xC9, 0x42, 0x09, 0xAD, 0x07, 0xD1, 0x9C, 0x77, + 0x76, 0x0A, 0xF2, 0xA2, 0x21, 0xD6, 0x89, 0x23, + 0xBF, 0x97, 0x0A, 0x5F, 0xE9, 0x73, 0x5F, 0x89, + 0x1C, 0x8A, 0xFB, 0x95, 0x9B, 0x36, 0xD3, 0x4A, + 0x9B, 0xD1, 0xF2, 0x4D, 0xE1, 0xBF, 0x2E, 0x1C, + 0x4A, 0x40, 0x97, 0x7B, 0x90, 0x4A, 0xAB, 0xAA, + 0xF6, 0x4B, 0x5C, 0x58, 0xBD, 0x26, 0x86, 0xE8, + 0xE6, 0x27, 0x70, 0x61, 0xDA, 0xA5, 0xC3, 0xC4 + }, + { + 0x48, 0x21, 0xA2, 0x71, 0x36, 0x7D, 0xA5, 0xD7, + 0xCB, 0xA9, 0x2A, 0x30, 0x61, 0xCB, 0x61, 0x7B, + 0x93, 0x58, 0x74, 0xB8, 0xAE, 0x1C, 0x90, 0x82, + 0x19, 0x3C, 0xCD, 0xD5, 0x39, 0x85, 0x1D, 0xF5, + 0xA4, 0xC7, 0x77, 0x57, 0x90, 0x75, 0x2D, 0x89, + 0xBA, 0x61, 0xBF, 0xDC, 0x88, 0x7B, 0x21, 0x72, + 0x64, 0x3C, 0x69, 0x34, 0x7C, 0x11, 0xD9, 0xF2, + 0x63, 0x62, 0x52, 0x0A, 0x24, 0x7D, 0xE0, 0xD6 + }, + { + 0x8A, 0xBC, 0xDD, 0x65, 0x20, 0xDB, 0x09, 0x47, + 0x89, 0x62, 0x43, 0x13, 0x23, 0xB0, 0xB9, 0x2D, + 0x9D, 0xB5, 0x0B, 0x57, 0x50, 0x59, 0xA1, 0x52, + 0x4E, 0x46, 0xCF, 0x81, 0xE7, 0xDD, 0x9B, 0x3C, + 0x17, 0x5A, 0xBA, 0x9C, 0x18, 0x50, 0x7C, 0x31, + 0x3B, 0xFE, 0xE2, 0x5F, 0x01, 0xB9, 0xE9, 0xD3, + 0xE2, 0xCB, 0xD0, 0xEA, 0x9B, 0x48, 0x24, 0xC4, + 0x0D, 0xBC, 0xA3, 0x4E, 0x5C, 0x39, 0x48, 0x0A + }, + { + 0x20, 0xA2, 0xE0, 0x36, 0x76, 0xB2, 0xE9, 0xA7, + 0xC4, 0xBC, 0x1F, 0x5E, 0x35, 0xBC, 0x0A, 0x02, + 0x5E, 0x52, 0xC1, 0x2A, 0x14, 0xC3, 0x63, 0x3E, + 0x76, 0xF0, 0x78, 0x4D, 0xF5, 0x8B, 0xBB, 0x07, + 0x5C, 0xD7, 0x67, 0x92, 0x48, 0xCD, 0x0D, 0x56, + 0x90, 0x2B, 0x6D, 0xE9, 0x77, 0xCB, 0x14, 0x78, + 0x1C, 0xB7, 0x75, 0x1E, 0xED, 0x60, 0xE5, 0x39, + 0xAA, 0x6E, 0x66, 0xDB, 0x31, 0x20, 0x9F, 0xF4 + }, + { + 0xCF, 0xE6, 0x12, 0x51, 0xC6, 0x77, 0x8A, 0x77, + 0x15, 0x93, 0x9E, 0x42, 0xA5, 0x63, 0xBA, 0x45, + 0xC7, 0x5D, 0x0B, 0xAE, 0x49, 0x3F, 0x34, 0xE4, + 0xC4, 0x13, 0x6A, 0x02, 0xCB, 0x53, 0x15, 0xEE, + 0xB1, 0x8B, 0x20, 0x44, 0x14, 0xB2, 0xBF, 0xB9, + 0xC2, 0xD3, 0x79, 0x8A, 0x8C, 0xAC, 0x87, 0x8C, + 0xC2, 0x28, 0x35, 0x19, 0x78, 0xAD, 0x3B, 0xE0, + 0xCF, 0x03, 0xA1, 0x64, 0x4B, 0x88, 0xEC, 0x0B + }, + { + 0x6F, 0x32, 0xCB, 0x7C, 0xCC, 0x56, 0x00, 0x30, + 0x5A, 0xC4, 0xAC, 0x02, 0xAC, 0xAA, 0x75, 0x6C, + 0x36, 0xBE, 0xF0, 0x96, 0x43, 0x82, 0xE1, 0xB6, + 0x24, 0xE4, 0x1D, 0xDC, 0x00, 0xAB, 0x45, 0x0E, + 0x04, 0x3B, 0x76, 0x52, 0x20, 0x22, 0x3A, 0xEE, + 0x11, 0x70, 0xE3, 0xD3, 0xFA, 0xF3, 0x4D, 0x78, + 0x24, 0x9F, 0xF9, 0xAB, 0x06, 0x80, 0x1D, 0xC2, + 0x99, 0x9C, 0xCF, 0xE1, 0xA8, 0xC2, 0x6A, 0x52 + }, + { + 0xB3, 0xAF, 0xEA, 0x06, 0xAE, 0xCE, 0xF7, 0x72, + 0xC3, 0x26, 0x0A, 0x91, 0x41, 0x18, 0xCB, 0xFC, + 0x9E, 0x87, 0x24, 0x6A, 0x70, 0x2C, 0x3A, 0xDA, + 0x41, 0x46, 0xFE, 0xD8, 0x47, 0xDC, 0xEF, 0xDE, + 0x5C, 0x8D, 0x7E, 0x76, 0x4A, 0xF8, 0x59, 0xE1, + 0x26, 0x57, 0xDC, 0xFA, 0xDF, 0xCC, 0x0E, 0xB9, + 0xF1, 0xA4, 0x5B, 0x8A, 0x92, 0x0C, 0x67, 0x53, + 0x3B, 0x4C, 0x37, 0x72, 0xB1, 0x2B, 0xEC, 0x6C + }, + { + 0x91, 0x6C, 0x73, 0x23, 0x31, 0xA7, 0x99, 0x7C, + 0xAD, 0x19, 0xA9, 0x02, 0x5A, 0xC3, 0x95, 0xC0, + 0x0B, 0x24, 0x8F, 0x81, 0xEB, 0x69, 0x33, 0xB0, + 0xD8, 0xFA, 0x56, 0x65, 0x78, 0x5D, 0xBD, 0x49, + 0x9F, 0xE2, 0x62, 0xE4, 0x64, 0x17, 0xC7, 0x3C, + 0x5B, 0xBC, 0x27, 0xE4, 0x3D, 0xCB, 0xD9, 0xD3, + 0x08, 0xFA, 0xE1, 0x20, 0xB2, 0x00, 0xBB, 0x70, + 0xF4, 0x7D, 0x4A, 0xD3, 0xE6, 0xAE, 0x57, 0x73 + }, + { + 0xC5, 0x00, 0x7A, 0x33, 0x8E, 0xF6, 0xF0, 0xEC, + 0x7E, 0x42, 0xCD, 0x24, 0x06, 0x86, 0xCB, 0x69, + 0x62, 0xA6, 0x80, 0xDA, 0x32, 0x8C, 0x98, 0xCE, + 0x63, 0x0E, 0xED, 0x43, 0x3D, 0x27, 0x60, 0x5D, + 0xF9, 0xF1, 0x70, 0xE2, 0x2D, 0x0B, 0x22, 0xD2, + 0x3D, 0x64, 0xE5, 0xDC, 0xFF, 0xAA, 0xAF, 0x9D, + 0xC4, 0x23, 0xA7, 0x5D, 0x6C, 0x92, 0xEA, 0x45, + 0x4B, 0xAA, 0x8E, 0x7B, 0x51, 0x41, 0xF3, 0xAD + }, + { + 0xB2, 0x74, 0x1F, 0xD4, 0xE6, 0x6D, 0x52, 0x6A, + 0x29, 0xF4, 0x1C, 0x2B, 0xCF, 0x49, 0xF6, 0x34, + 0xF2, 0x3B, 0xDD, 0xCC, 0xC8, 0x2E, 0x2A, 0xD9, + 0x7C, 0x02, 0x20, 0x8C, 0xEB, 0xF3, 0x88, 0xFC, + 0x76, 0xC3, 0x05, 0xA3, 0x61, 0xC1, 0xF5, 0xC6, + 0xDE, 0x20, 0xA2, 0xFD, 0xEB, 0x70, 0xAB, 0x6C, + 0x2D, 0x77, 0x4F, 0x2E, 0xCB, 0xB5, 0xDF, 0x93, + 0xB4, 0x03, 0x48, 0x8E, 0x21, 0x1E, 0xEF, 0x6B + }, + { + 0xC7, 0xF6, 0x95, 0x1D, 0x81, 0xA4, 0x73, 0x5B, + 0x77, 0xEE, 0x74, 0x24, 0x07, 0x73, 0x0A, 0xE7, + 0x65, 0x7C, 0xC1, 0x64, 0xFB, 0x13, 0x9E, 0x80, + 0x87, 0xCD, 0xBA, 0xA5, 0x39, 0xFC, 0x0A, 0x28, + 0xCB, 0xEE, 0x7E, 0x82, 0xD6, 0xE8, 0x19, 0x62, + 0x11, 0xE2, 0xC6, 0x57, 0xA5, 0x53, 0xED, 0x83, + 0x82, 0xF7, 0x25, 0xB6, 0x72, 0x36, 0xCA, 0x0D, + 0x9D, 0xD9, 0x9B, 0xD0, 0xC0, 0x54, 0xDC, 0x29 + }, + { + 0x14, 0xCB, 0xD7, 0xB5, 0x9B, 0x6E, 0xFE, 0x79, + 0x4E, 0xDC, 0x47, 0xAC, 0xE5, 0x98, 0xFD, 0x46, + 0x28, 0xA0, 0x80, 0x63, 0x4A, 0x99, 0xBB, 0xA1, + 0x6A, 0x85, 0x8A, 0xF2, 0xB6, 0x75, 0x28, 0xC3, + 0xBC, 0x76, 0x7A, 0x95, 0x46, 0xA4, 0x12, 0xEF, + 0x48, 0xDA, 0xB7, 0x04, 0x19, 0xBB, 0x33, 0x7B, + 0x9F, 0x43, 0x96, 0xD1, 0xF3, 0x64, 0xA8, 0x8A, + 0x77, 0x24, 0xD6, 0x3F, 0x12, 0xC0, 0x02, 0xBF + }, + { + 0x6F, 0x75, 0x61, 0xB3, 0x3C, 0xE8, 0x83, 0x1B, + 0x8C, 0xFB, 0x8F, 0xBE, 0xF9, 0x12, 0x13, 0xA2, + 0x2F, 0x21, 0x91, 0x68, 0xA5, 0xD5, 0x10, 0xBB, + 0xEA, 0x08, 0xF3, 0xAA, 0xB1, 0xD1, 0xDA, 0x77, + 0x17, 0x13, 0x0C, 0x92, 0x7A, 0xD1, 0xFC, 0xD9, + 0xCE, 0xB8, 0x44, 0x5F, 0xD2, 0xED, 0x58, 0x6E, + 0xFC, 0x9B, 0xFF, 0x76, 0x37, 0x57, 0x24, 0xDC, + 0xA9, 0x0C, 0x5F, 0xB3, 0x41, 0xB5, 0x2C, 0x6E + }, + { + 0xB4, 0x84, 0x77, 0xF7, 0xBA, 0x12, 0x74, 0x02, + 0x93, 0xF3, 0x56, 0xCA, 0x1F, 0x5D, 0x99, 0x4F, + 0x93, 0x06, 0xDB, 0xA0, 0x50, 0x75, 0x80, 0x2F, + 0xAC, 0x0E, 0x8E, 0xFE, 0x0B, 0x20, 0xFC, 0x10, + 0x20, 0x1C, 0x85, 0x75, 0x65, 0x3B, 0x22, 0x2C, + 0xEA, 0xB1, 0x79, 0xCE, 0xB8, 0x73, 0x38, 0x4A, + 0x40, 0xC4, 0xDA, 0x9D, 0x5B, 0xCF, 0x12, 0x58, + 0xEF, 0x4D, 0xAE, 0x05, 0x9C, 0xE8, 0x9E, 0xBA + }, + { + 0x41, 0xE8, 0xCD, 0x2C, 0x32, 0xB0, 0x53, 0xFC, + 0x21, 0xB9, 0xF2, 0xB3, 0x06, 0x91, 0x4F, 0xA4, + 0xF2, 0xC1, 0x17, 0xA5, 0xA1, 0x9C, 0x9B, 0x21, + 0xCC, 0xB3, 0x37, 0xB1, 0x9B, 0x9C, 0x5E, 0x54, + 0x6A, 0xA0, 0x83, 0x0B, 0xEA, 0x93, 0x33, 0x39, + 0x3C, 0x80, 0xA3, 0xF7, 0x1C, 0x4B, 0x53, 0x4D, + 0x5A, 0x36, 0x82, 0x0C, 0x9C, 0x32, 0xBB, 0xFC, + 0x57, 0xCE, 0xD5, 0xFF, 0x99, 0x78, 0x9C, 0x9E + }, + { + 0x9A, 0x8C, 0x9A, 0x69, 0xE9, 0xB6, 0x44, 0xB0, + 0x04, 0x0E, 0xCA, 0x6D, 0xF7, 0xCE, 0xB7, 0x20, + 0x0E, 0xD2, 0x05, 0xE7, 0x0F, 0xBE, 0x2A, 0xFB, + 0x12, 0x38, 0xD4, 0xFB, 0x0B, 0xFD, 0x76, 0xC2, + 0x19, 0x88, 0x7E, 0x78, 0x0B, 0x7C, 0x56, 0x9D, + 0x81, 0x48, 0x87, 0xC7, 0x13, 0xE9, 0xB6, 0xE1, + 0x95, 0x39, 0x93, 0x8E, 0x7C, 0x89, 0xFA, 0x55, + 0xE3, 0x31, 0x47, 0xA4, 0xF4, 0x4E, 0x02, 0x69 + }, + { + 0xB4, 0x8F, 0x52, 0xED, 0xAD, 0x5E, 0xEE, 0x32, + 0xCE, 0x4A, 0xA6, 0x67, 0x29, 0x29, 0x0A, 0xF9, + 0xBB, 0x4C, 0xE5, 0x2B, 0x77, 0x86, 0x44, 0x4D, + 0x02, 0xEF, 0x6D, 0x35, 0x63, 0x5B, 0xF3, 0xD4, + 0xAD, 0xBB, 0xE1, 0xBC, 0xAB, 0x67, 0x50, 0xF9, + 0xFB, 0x2A, 0x57, 0xD3, 0xE1, 0xA9, 0x56, 0x13, + 0x82, 0x56, 0xFB, 0xB8, 0x50, 0xCE, 0x29, 0xFC, + 0xC6, 0xC8, 0x88, 0x72, 0x0B, 0x0A, 0xCD, 0x64 + }, + { + 0x36, 0x3E, 0x22, 0xF0, 0xC9, 0x93, 0xD8, 0x0B, + 0x0F, 0x8E, 0xCE, 0xC7, 0x76, 0xD7, 0xD7, 0xE4, + 0xE4, 0x12, 0x34, 0x3E, 0x5D, 0x0C, 0x99, 0xA4, + 0x1D, 0xFB, 0xBC, 0xBD, 0xA3, 0xC7, 0x6B, 0x92, + 0x44, 0x61, 0x36, 0x1E, 0xA3, 0xFD, 0x99, 0xB6, + 0x73, 0x3C, 0x38, 0x5D, 0x0A, 0xD8, 0xBB, 0x81, + 0xA6, 0xA1, 0x54, 0x4E, 0x4F, 0xF1, 0x93, 0xAD, + 0x65, 0x55, 0x28, 0x89, 0x69, 0x3C, 0xF6, 0x38 + }, + { + 0x9E, 0xC5, 0x2C, 0x2F, 0x20, 0xAF, 0xF4, 0x04, + 0x2B, 0x9A, 0x47, 0xA2, 0xFF, 0xB5, 0x40, 0x3C, + 0xB1, 0xC6, 0xF9, 0x8A, 0x1D, 0x2B, 0x8D, 0xA1, + 0x88, 0x88, 0xE0, 0x38, 0x6B, 0x3C, 0xFF, 0xAF, + 0xBD, 0x68, 0x62, 0xAC, 0x6F, 0x16, 0xD1, 0x67, + 0x77, 0x9A, 0x6D, 0x06, 0x49, 0x26, 0x8F, 0xA2, + 0xFE, 0xEE, 0x9A, 0xC4, 0xAC, 0x4D, 0x90, 0x4E, + 0x55, 0x97, 0x59, 0x64, 0x49, 0x97, 0x4E, 0x1A + }, + { + 0xC6, 0x46, 0x7F, 0x49, 0xB4, 0x78, 0xAF, 0x12, + 0x2A, 0xC3, 0x90, 0xA1, 0x33, 0xB0, 0xDA, 0xA0, + 0xAF, 0x3F, 0x0A, 0x22, 0x5C, 0x86, 0x21, 0xB7, + 0x14, 0x77, 0x11, 0xEB, 0xFE, 0x4C, 0x78, 0x92, + 0x1A, 0xF2, 0xF0, 0xA7, 0x9A, 0x01, 0x34, 0xFE, + 0x17, 0xC9, 0x07, 0xD5, 0x6A, 0x40, 0xB3, 0xC1, + 0x15, 0x8A, 0x8B, 0x39, 0x28, 0xDE, 0x9E, 0xA8, + 0xF2, 0x73, 0x9C, 0xDF, 0x48, 0xC6, 0x39, 0x64 + }, + { + 0x12, 0xBE, 0xB3, 0x2B, 0xBE, 0x26, 0xE0, 0xF5, + 0xB6, 0x71, 0xFC, 0x2B, 0xEB, 0x20, 0xB6, 0xF4, + 0x49, 0xD9, 0x8B, 0xE6, 0x2A, 0xF9, 0x66, 0x98, + 0xCB, 0x75, 0x51, 0x31, 0x1A, 0x19, 0xC8, 0xC6, + 0xB7, 0x19, 0xD9, 0x37, 0x88, 0x94, 0x3A, 0x20, + 0xDE, 0xE5, 0x67, 0x80, 0x39, 0x79, 0x5A, 0x21, + 0xCF, 0x89, 0x6A, 0x89, 0xED, 0xB5, 0x47, 0x99, + 0xFC, 0x6E, 0x0C, 0x69, 0x03, 0x0D, 0xAE, 0x44 + }, + { + 0xB1, 0xE4, 0xEF, 0x36, 0xEF, 0x57, 0xF5, 0x26, + 0xCA, 0x59, 0x49, 0xA1, 0xAB, 0x1E, 0xD7, 0xBB, + 0x01, 0xA1, 0xCF, 0x93, 0x73, 0xAE, 0x24, 0x70, + 0x4C, 0x84, 0xB3, 0xEA, 0x5D, 0x8F, 0xF2, 0x4F, + 0x8F, 0xB0, 0x7E, 0xB3, 0x1E, 0xE9, 0x74, 0x8D, + 0x3C, 0xAE, 0xEC, 0x75, 0xA0, 0xB9, 0x7A, 0x54, + 0x44, 0xED, 0xA6, 0x92, 0x76, 0xE4, 0x53, 0x3D, + 0xD6, 0xDF, 0xA7, 0xD9, 0xCA, 0x03, 0x6A, 0x23 + }, + { + 0xAC, 0x43, 0x93, 0x8E, 0xB9, 0x82, 0x5F, 0x36, + 0xEC, 0x93, 0x01, 0x6C, 0x88, 0xB1, 0x6C, 0x3B, + 0xAC, 0xD3, 0xA6, 0x3C, 0x38, 0xC4, 0xFF, 0x3B, + 0xC8, 0xD1, 0x49, 0x89, 0xF9, 0x35, 0x5A, 0x1D, + 0xD3, 0x99, 0xE2, 0x42, 0x01, 0x01, 0xEF, 0x14, + 0x96, 0x76, 0xEF, 0x8E, 0xE5, 0x55, 0xF9, 0xFE, + 0x8D, 0xD7, 0x3F, 0xA6, 0xBE, 0xA4, 0x9A, 0xA2, + 0x97, 0xBC, 0xAA, 0x3F, 0x04, 0x2E, 0x41, 0xE5 + }, + { + 0xB3, 0x4E, 0x7F, 0x19, 0xFB, 0x16, 0x1D, 0x4A, + 0xE8, 0xAB, 0xC7, 0xFE, 0x44, 0xB3, 0xBB, 0x0C, + 0x09, 0xAD, 0xB3, 0x7E, 0x11, 0xDE, 0xF9, 0xF0, + 0x92, 0x76, 0x59, 0x5E, 0xDA, 0x7B, 0xD8, 0x98, + 0xA5, 0x80, 0x3A, 0xF0, 0x3F, 0xF6, 0x2B, 0xF2, + 0x2C, 0x3F, 0xDC, 0x32, 0xAD, 0x5B, 0x9F, 0xE1, + 0x3E, 0x02, 0xD3, 0x55, 0x17, 0x35, 0x6B, 0x5C, + 0x56, 0x41, 0xA0, 0xFB, 0x1B, 0xA3, 0x6D, 0x28 + }, + { + 0xAD, 0xD1, 0x98, 0x79, 0xC9, 0x3E, 0x55, 0xF3, + 0xB4, 0x70, 0x9B, 0x78, 0x9B, 0x92, 0x6E, 0x4A, + 0xF6, 0x6A, 0x17, 0xDD, 0xD8, 0x42, 0x42, 0xD8, + 0xA7, 0xE6, 0x7D, 0x94, 0x7C, 0xE0, 0xB4, 0x80, + 0x67, 0x89, 0xF6, 0xD3, 0xF0, 0xF2, 0x37, 0x85, + 0xEA, 0xB5, 0xB9, 0x03, 0xCC, 0x53, 0xC1, 0xD4, + 0xC8, 0x21, 0x20, 0x8D, 0x5E, 0x01, 0x66, 0xA5, + 0x23, 0x02, 0x53, 0xB5, 0xF5, 0xE0, 0xF5, 0xC9 + }, + { + 0x0C, 0x74, 0xC1, 0x7D, 0x06, 0xFC, 0x51, 0x11, + 0x87, 0x59, 0x5A, 0xB5, 0x87, 0xCB, 0xA5, 0x10, + 0xEF, 0x59, 0x97, 0x95, 0xBD, 0xB2, 0xAF, 0x61, + 0x57, 0x62, 0xE5, 0x1A, 0x82, 0xF9, 0x80, 0x19, + 0x7C, 0x05, 0xFE, 0x18, 0x53, 0xA6, 0xD8, 0xB8, + 0xFB, 0x09, 0x60, 0x6D, 0x09, 0xFC, 0xA2, 0x11, + 0xF6, 0x06, 0x06, 0x22, 0xB0, 0x6F, 0x96, 0xCC, + 0xBC, 0xCC, 0x57, 0x9F, 0xC5, 0x0F, 0x97, 0x45 + }, + { + 0x91, 0x92, 0x91, 0x57, 0x0E, 0x20, 0xF0, 0x7A, + 0x9D, 0x39, 0xE3, 0xEA, 0x47, 0xD2, 0xA2, 0xBA, + 0x43, 0xD3, 0x2A, 0xD7, 0x62, 0xE1, 0x4F, 0x46, + 0x6A, 0x60, 0x48, 0xA7, 0xEB, 0x6F, 0xBF, 0x69, + 0xF4, 0x79, 0x6E, 0x0B, 0x9B, 0x5B, 0x55, 0x40, + 0x3E, 0x7A, 0x2F, 0x5E, 0xF2, 0xBF, 0xB7, 0xC5, + 0xDF, 0xD2, 0xF1, 0x50, 0xB2, 0x1E, 0x65, 0x34, + 0x81, 0xD5, 0xA1, 0xA7, 0x85, 0x96, 0xD7, 0xCB + }, + { + 0x93, 0x41, 0x33, 0x1B, 0x53, 0xD0, 0x3E, 0xA5, + 0x1E, 0xE0, 0x52, 0xCD, 0x72, 0xAD, 0xD0, 0xF0, + 0xCB, 0x0E, 0x91, 0xB1, 0xB9, 0xD7, 0xE2, 0xE3, + 0x28, 0x8D, 0x3A, 0x0E, 0x92, 0x69, 0x32, 0x18, + 0x86, 0x60, 0x24, 0xAB, 0xC5, 0x54, 0x40, 0xCF, + 0xCC, 0x79, 0x7E, 0x6D, 0xE9, 0xCA, 0x3B, 0xD6, + 0x37, 0xB7, 0x74, 0xF9, 0x1B, 0x24, 0xCD, 0x2E, + 0x48, 0x97, 0x7D, 0x49, 0x15, 0x51, 0x8E, 0x9F + }, + { + 0x1E, 0x9F, 0x80, 0x5A, 0xD8, 0xC6, 0x4D, 0x39, + 0x67, 0xD3, 0xB6, 0x92, 0x9F, 0x8C, 0xB3, 0x05, + 0x6D, 0xBF, 0x50, 0xF0, 0x48, 0x17, 0x40, 0x76, + 0x99, 0x4B, 0x27, 0x30, 0x6D, 0x65, 0xFB, 0x8A, + 0x70, 0xE7, 0xD8, 0x59, 0x35, 0xAE, 0x39, 0xFB, + 0xB6, 0xC4, 0x05, 0xA3, 0xA3, 0xE9, 0xCA, 0x2D, + 0x63, 0x3E, 0x34, 0x50, 0xEE, 0x80, 0x7D, 0x42, + 0xD3, 0xE7, 0x6D, 0xAB, 0xDA, 0xD7, 0x52, 0x49 + }, + { + 0x92, 0x0A, 0xFC, 0x4D, 0x41, 0x25, 0x56, 0xE1, + 0x90, 0x12, 0x95, 0x98, 0xE9, 0xF7, 0x90, 0x86, + 0xBF, 0xD0, 0x66, 0xDC, 0x6C, 0x7C, 0xEB, 0x6A, + 0xCD, 0x10, 0x70, 0xBA, 0x93, 0x32, 0x2A, 0x03, + 0x4E, 0xF9, 0x78, 0xA6, 0x9A, 0x34, 0x3C, 0x45, + 0xA7, 0xB6, 0xAC, 0xD0, 0x9E, 0xF3, 0x9C, 0xF2, + 0x67, 0x63, 0xA1, 0xFE, 0x2B, 0x1B, 0xFC, 0x20, + 0xCB, 0xB7, 0xC1, 0x1E, 0x48, 0xA7, 0xE1, 0x91 + }, + { + 0x6C, 0xD2, 0x10, 0x7F, 0xD1, 0x3F, 0x78, 0x14, + 0x53, 0x56, 0xB9, 0x4B, 0x0C, 0xC5, 0xDF, 0x06, + 0xD9, 0x5C, 0xF9, 0xE3, 0x4F, 0x19, 0xB9, 0x82, + 0x17, 0x12, 0x14, 0x6C, 0x73, 0x6A, 0x3B, 0x5D, + 0x33, 0x35, 0xF9, 0x3C, 0xA9, 0x69, 0x64, 0x0A, + 0x59, 0x35, 0x0A, 0xE0, 0x46, 0x4B, 0x58, 0xE8, + 0x81, 0xF9, 0x80, 0x27, 0x55, 0x05, 0x73, 0xE2, + 0xA6, 0xDD, 0x6B, 0xDD, 0x47, 0x29, 0x15, 0x73 + }, + { + 0xC0, 0x7E, 0x5C, 0xAE, 0x5D, 0x81, 0x31, 0x04, + 0x65, 0x2E, 0x49, 0xDC, 0x03, 0x1A, 0x98, 0xDD, + 0x4D, 0x10, 0x51, 0x25, 0x61, 0x23, 0x77, 0x63, + 0x52, 0x8B, 0x66, 0xF9, 0xA2, 0x4F, 0x53, 0x38, + 0x6D, 0x85, 0x54, 0xBC, 0xB2, 0x85, 0xE5, 0x10, + 0xFC, 0x3F, 0x89, 0x13, 0x1F, 0x95, 0x2A, 0x05, + 0x1E, 0x61, 0x85, 0x21, 0xA5, 0xF2, 0x53, 0x93, + 0xAE, 0x3A, 0xFF, 0x11, 0x14, 0x34, 0x85, 0x54 + }, + { + 0x72, 0x78, 0x89, 0xAE, 0x38, 0xA7, 0x76, 0x38, + 0xBD, 0x5C, 0xB2, 0x85, 0x47, 0x5D, 0xAA, 0x3A, + 0xFB, 0x4A, 0x00, 0x1F, 0x5B, 0x3B, 0xA1, 0x02, + 0xC9, 0x76, 0x63, 0xB6, 0x29, 0x86, 0x04, 0x95, + 0x0E, 0x1F, 0x4D, 0x47, 0x62, 0x5D, 0xB5, 0x5C, + 0xFC, 0x87, 0x87, 0x19, 0x45, 0xC4, 0x4E, 0xA3, + 0xB7, 0x53, 0x6A, 0x02, 0xA4, 0x25, 0x38, 0x62, + 0xC6, 0x15, 0x00, 0x7D, 0xC8, 0x17, 0xE8, 0x76 + }, + { + 0xED, 0x97, 0x9D, 0xB4, 0x2E, 0x24, 0x6A, 0xB2, + 0x6E, 0xD0, 0xD0, 0x52, 0x15, 0x9C, 0xBE, 0xBB, + 0x8B, 0xE9, 0x1C, 0xC3, 0xC4, 0xD8, 0xF2, 0xB3, + 0xDD, 0x72, 0x33, 0x5C, 0x66, 0x3A, 0x44, 0x1F, + 0x9D, 0x4C, 0xC9, 0x1C, 0x4A, 0x4A, 0x6B, 0x87, + 0xB0, 0x5B, 0x78, 0x62, 0xD4, 0x54, 0xCE, 0x75, + 0xCD, 0x3C, 0x8C, 0xE1, 0xEC, 0x23, 0x5E, 0x11, + 0x81, 0x3D, 0x86, 0xB6, 0x89, 0x53, 0xAD, 0x28 + }, + { + 0x41, 0x13, 0xF1, 0xC0, 0xE5, 0x2D, 0x2C, 0xB1, + 0x14, 0x12, 0x8A, 0x06, 0x1C, 0xC4, 0x5B, 0x33, + 0x4E, 0xA7, 0xAF, 0x46, 0x4D, 0xDD, 0xB3, 0x9B, + 0x00, 0x1A, 0xD4, 0xEC, 0xFA, 0xE4, 0x88, 0x85, + 0x12, 0xE6, 0x3F, 0x8A, 0xB4, 0xE5, 0x46, 0xE6, + 0x19, 0xC2, 0x0A, 0x21, 0x9A, 0x66, 0x70, 0xF9, + 0x5C, 0xCE, 0xDB, 0x68, 0x6B, 0xAC, 0xC9, 0x85, + 0x50, 0xD4, 0xC8, 0x6B, 0x49, 0x76, 0x8A, 0xF3 + }, + { + 0x3A, 0x17, 0xD3, 0xA4, 0x54, 0xE3, 0xA9, 0xF0, + 0x8A, 0xB5, 0x59, 0x64, 0xBF, 0x0D, 0x3E, 0x8A, + 0x0F, 0xD7, 0x36, 0xEF, 0x9D, 0xCE, 0xD3, 0x1E, + 0xE7, 0x5C, 0x36, 0xA9, 0xF6, 0x69, 0x10, 0x38, + 0x89, 0x8B, 0xBF, 0xE2, 0x2E, 0xBD, 0xE4, 0x1C, + 0xA9, 0x80, 0x71, 0x95, 0xAA, 0x49, 0x3A, 0x96, + 0xCC, 0x22, 0x71, 0xB0, 0x72, 0xAC, 0x48, 0xC8, + 0x02, 0x7D, 0x64, 0x44, 0x9D, 0x37, 0x1A, 0x3A + }, + { + 0x2F, 0xBE, 0x8C, 0xC0, 0x5F, 0x77, 0xEF, 0xA1, + 0x63, 0xE0, 0x6F, 0x58, 0xBA, 0x4B, 0xB2, 0x0A, + 0x85, 0xA4, 0xDD, 0x9B, 0xD7, 0x70, 0x36, 0xA4, + 0x8B, 0x00, 0xE8, 0xC6, 0xF8, 0x55, 0x8F, 0x7F, + 0x16, 0xFC, 0x8F, 0x7F, 0x84, 0x60, 0xD5, 0xF2, + 0x7F, 0x44, 0xA5, 0x2D, 0x09, 0x30, 0x9A, 0x3C, + 0x07, 0xDD, 0x63, 0xAF, 0x9B, 0xD3, 0x7D, 0xCA, + 0x27, 0x6B, 0x8B, 0xB5, 0xC7, 0x7E, 0x1C, 0x24 + }, + { + 0x83, 0xA6, 0x55, 0xD0, 0x83, 0x2E, 0x95, 0x7F, + 0x45, 0x91, 0x4D, 0x12, 0x37, 0x64, 0x08, 0xED, + 0xD3, 0xAE, 0x02, 0x53, 0xA7, 0x72, 0xA8, 0xE3, + 0x3F, 0x71, 0x4B, 0xE5, 0x3D, 0xA1, 0xE8, 0x6C, + 0xAD, 0x81, 0xC1, 0xAD, 0x55, 0xCF, 0x70, 0xC8, + 0xE3, 0x51, 0xA7, 0x28, 0x69, 0x87, 0xAF, 0xBD, + 0x5A, 0x9B, 0x13, 0xE5, 0x1E, 0x86, 0x8A, 0x15, + 0xFD, 0xE0, 0xE8, 0x88, 0x3F, 0x80, 0x40, 0xD8 + }, + { + 0x2A, 0x14, 0x05, 0x8C, 0x23, 0x78, 0x6E, 0x6F, + 0xEE, 0x1F, 0x34, 0xBB, 0xE5, 0xF3, 0x4A, 0xB5, + 0x9E, 0x09, 0x75, 0x07, 0x55, 0xDE, 0xED, 0x0C, + 0x1C, 0x50, 0x05, 0x38, 0xCC, 0xB2, 0x73, 0xD4, + 0xFE, 0x4F, 0x8B, 0x50, 0x76, 0x95, 0x6B, 0xBC, + 0xEE, 0x9E, 0xF1, 0xC8, 0x42, 0xB4, 0xD3, 0x6A, + 0xEB, 0x3E, 0x37, 0x29, 0x86, 0x06, 0x71, 0xAF, + 0xD6, 0x26, 0xDE, 0x3C, 0xFD, 0xEE, 0x3D, 0xC9 + }, + { + 0x82, 0x88, 0x2D, 0x43, 0xBD, 0xA1, 0x72, 0xFD, + 0x97, 0x50, 0xAC, 0x25, 0x75, 0x65, 0x5F, 0x6A, + 0x48, 0x74, 0x1A, 0x63, 0x9E, 0x33, 0x82, 0x62, + 0x8D, 0x54, 0x8A, 0xD2, 0x8E, 0xDF, 0xBD, 0x39, + 0xE9, 0x7C, 0xC6, 0xA5, 0x7A, 0x14, 0x1F, 0xF6, + 0x04, 0x22, 0xB9, 0xC6, 0xBC, 0x8A, 0xBD, 0x51, + 0x00, 0x0A, 0xFC, 0x39, 0xB8, 0x8C, 0xE0, 0xD8, + 0xC8, 0xF4, 0x70, 0x95, 0x14, 0x46, 0x7C, 0x55 + }, + { + 0xEC, 0x0A, 0x19, 0x91, 0x28, 0xD3, 0x12, 0xE0, + 0x33, 0x6B, 0xD4, 0x6B, 0xE6, 0x2D, 0x05, 0x40, + 0xBA, 0xB0, 0x3F, 0x41, 0x96, 0x7F, 0xA8, 0xA7, + 0x8A, 0x19, 0x95, 0x7B, 0x03, 0x47, 0x0F, 0xBE, + 0x91, 0x11, 0x9E, 0xD7, 0x47, 0x33, 0x81, 0xAB, + 0x89, 0x29, 0xBE, 0xE7, 0xCB, 0xD6, 0xFE, 0xF7, + 0x74, 0x2B, 0x87, 0xDE, 0x67, 0xC4, 0x94, 0x94, + 0x7F, 0xA3, 0x61, 0x63, 0xE3, 0xBA, 0x5A, 0xFE + }, + { + 0xE3, 0x9C, 0xE8, 0xBF, 0x4C, 0xC8, 0x07, 0xB0, + 0x06, 0x71, 0xB8, 0x21, 0x53, 0xC7, 0xC0, 0x44, + 0x97, 0xDA, 0xDF, 0x36, 0xD7, 0x15, 0xCD, 0x27, + 0x1A, 0x22, 0x63, 0xDC, 0x22, 0x58, 0x8B, 0x68, + 0xF1, 0x08, 0x05, 0xCE, 0xDC, 0xD4, 0x0E, 0x3F, + 0x27, 0xD7, 0x0C, 0xE3, 0xEA, 0xD2, 0xEE, 0xA7, + 0x33, 0xA5, 0x24, 0xE4, 0xC4, 0x23, 0x09, 0xD2, + 0x0A, 0x89, 0xDE, 0x80, 0x83, 0xCB, 0x49, 0x58 + }, + { + 0x35, 0x10, 0xC7, 0x43, 0x98, 0x53, 0x40, 0x4C, + 0x11, 0x53, 0x83, 0xF9, 0x00, 0xA3, 0x09, 0xA6, + 0xD4, 0xBF, 0x6C, 0x6B, 0xB2, 0x7B, 0x94, 0xDE, + 0x53, 0xA2, 0x93, 0x77, 0x0B, 0xDA, 0x4B, 0xE9, + 0xC6, 0x2A, 0x12, 0x3C, 0xDE, 0x3F, 0xF5, 0x17, + 0x42, 0xF0, 0x9E, 0x06, 0x9E, 0xA9, 0x65, 0x1E, + 0xE1, 0x0B, 0xF7, 0x3D, 0xFB, 0x12, 0x06, 0xB2, + 0xDB, 0x43, 0xCF, 0xFD, 0x36, 0x88, 0xFC, 0xEA + }, + { + 0x7D, 0x70, 0x11, 0x78, 0x16, 0x71, 0xF4, 0xAD, + 0x99, 0x85, 0x5C, 0xDB, 0xC9, 0x19, 0x45, 0x05, + 0xEB, 0xB0, 0x53, 0x3C, 0xD4, 0xCB, 0x2B, 0x33, + 0x0B, 0x81, 0x16, 0x21, 0xD8, 0x70, 0x0A, 0x6C, + 0x45, 0x23, 0x29, 0x7D, 0x60, 0xC6, 0xC9, 0x47, + 0xF9, 0x0C, 0x5E, 0x8C, 0x36, 0xEE, 0x6F, 0xD5, + 0x8C, 0x42, 0x29, 0x0C, 0x1F, 0x7F, 0x9F, 0xA0, + 0xAC, 0x59, 0xB8, 0xE7, 0xA6, 0x06, 0x65, 0x3A + }, + { + 0xE3, 0x92, 0x94, 0xF3, 0xFF, 0xF5, 0x39, 0xF0, + 0x2A, 0xDF, 0x91, 0x36, 0x11, 0xA6, 0x59, 0xFA, + 0x5E, 0xFB, 0xE8, 0xFD, 0xA2, 0x8E, 0x10, 0xDA, + 0x88, 0x3A, 0x08, 0xF0, 0xC2, 0xDD, 0xEF, 0x58, + 0x85, 0x09, 0x9E, 0x13, 0x5E, 0x80, 0xCE, 0x97, + 0x80, 0x91, 0xD2, 0x23, 0x5E, 0xBF, 0x2A, 0xFF, + 0xE3, 0xDD, 0x5B, 0x63, 0x37, 0x4B, 0x8D, 0x90, + 0x60, 0x28, 0xCE, 0x30, 0x60, 0x61, 0x2C, 0x87 + }, + { + 0x76, 0x9D, 0x08, 0x9B, 0xBB, 0x0E, 0x2D, 0x46, + 0x35, 0xDF, 0x26, 0x27, 0x15, 0xB0, 0x88, 0xF4, + 0xD5, 0xC6, 0xFC, 0xFC, 0x5F, 0x6D, 0x7D, 0x52, + 0x5D, 0xE2, 0x7C, 0xDF, 0x22, 0x8D, 0x5F, 0x81, + 0x6F, 0x08, 0xA6, 0xF4, 0xAD, 0x75, 0x31, 0x96, + 0xEA, 0xA3, 0x69, 0x7E, 0x4F, 0x73, 0xB5, 0x40, + 0xE6, 0x5D, 0x07, 0x22, 0x8D, 0x4C, 0x6A, 0x2F, + 0xC6, 0xC3, 0x9B, 0x37, 0xF6, 0x22, 0x2F, 0x21 + }, + { + 0x27, 0x88, 0x0F, 0x24, 0x92, 0xA1, 0x75, 0x08, + 0x0C, 0xC7, 0x9C, 0x63, 0x08, 0x38, 0xDC, 0x4D, + 0xB1, 0xB3, 0xD2, 0xEA, 0x4A, 0xB7, 0x2A, 0xF2, + 0xAC, 0x97, 0x88, 0x63, 0xA8, 0x3B, 0x1A, 0xC7, + 0x56, 0x5B, 0xA6, 0x36, 0x21, 0xAE, 0x84, 0xC8, + 0x35, 0x62, 0xE4, 0x15, 0x08, 0x3D, 0x7C, 0xAA, + 0x2C, 0x53, 0x12, 0xB8, 0xEE, 0xFF, 0x60, 0xA8, + 0xC0, 0x67, 0xE6, 0x37, 0xF9, 0x98, 0x56, 0x13 + }, + { + 0xA0, 0xD0, 0x2C, 0x6A, 0x7A, 0xBA, 0x4F, 0x3A, + 0xC2, 0xC9, 0x03, 0xA3, 0x5D, 0x83, 0x2D, 0x72, + 0xC3, 0x46, 0x37, 0x1C, 0x49, 0xC1, 0x14, 0x33, + 0xE5, 0x8A, 0x53, 0xAB, 0x74, 0xC4, 0xC3, 0xA5, + 0x24, 0xA8, 0xAF, 0x4E, 0xDF, 0x5F, 0x5E, 0x87, + 0x23, 0x5D, 0xCD, 0x6A, 0xD5, 0x21, 0x12, 0x5A, + 0xFF, 0xCE, 0xDE, 0xF0, 0x05, 0xE9, 0xED, 0xA0, + 0x30, 0x41, 0xF9, 0xCA, 0xBD, 0x31, 0xFC, 0xB4 + }, + { + 0xFB, 0xBB, 0xF0, 0x62, 0x9E, 0xD8, 0x0C, 0x66, + 0x73, 0xD4, 0xB9, 0x2E, 0x60, 0xD9, 0x77, 0xFE, + 0xF7, 0x2F, 0xDA, 0x83, 0x76, 0x07, 0x2A, 0x1D, + 0xF0, 0xA8, 0x30, 0x4A, 0x9E, 0xE3, 0xA2, 0xE0, + 0xAA, 0xCC, 0x03, 0xD2, 0xAE, 0xC9, 0x06, 0x22, + 0xC8, 0x57, 0xD6, 0xCF, 0xF9, 0xD1, 0xA4, 0xF0, + 0x6E, 0xA2, 0x93, 0xB7, 0x98, 0xFC, 0x89, 0x4E, + 0xB7, 0x7E, 0x52, 0x46, 0x45, 0x51, 0x26, 0xB2 + }, + { + 0xAE, 0xA0, 0x8D, 0xCA, 0x2D, 0xEB, 0xCE, 0x85, + 0xBC, 0x46, 0x77, 0x0B, 0xCD, 0x85, 0xA3, 0xD6, + 0xB1, 0x94, 0xB3, 0xC7, 0x04, 0x45, 0x6A, 0xD1, + 0x75, 0x8F, 0x7B, 0x77, 0xFB, 0x20, 0xE2, 0xF4, + 0xB1, 0xE9, 0x2B, 0x00, 0xA9, 0x1B, 0x32, 0xCF, + 0x6A, 0x6C, 0xD6, 0xDE, 0x73, 0xDE, 0x8D, 0x05, + 0x9C, 0xAF, 0xA9, 0x83, 0x51, 0x63, 0xD3, 0xA7, + 0x83, 0x5C, 0x78, 0xF5, 0xA0, 0x95, 0x58, 0x4E + }, + { + 0x38, 0x4C, 0xB7, 0x35, 0x05, 0xFD, 0xFA, 0xB6, + 0x3C, 0x76, 0x7B, 0x7F, 0x24, 0x26, 0xAF, 0x65, + 0x49, 0xAE, 0x62, 0x34, 0x9E, 0xF1, 0xFB, 0xA2, + 0xE3, 0x4A, 0xE8, 0x1D, 0x0E, 0x35, 0xE6, 0xBD, + 0x7F, 0x70, 0x08, 0x51, 0x5D, 0x12, 0x3D, 0x73, + 0x4D, 0xB9, 0x2B, 0x2A, 0xB2, 0xC7, 0x1D, 0x6D, + 0xDB, 0xBA, 0x57, 0x93, 0xF6, 0xB6, 0x9E, 0x39, + 0x77, 0x42, 0x5F, 0xCF, 0x08, 0x5C, 0x8C, 0x6C + }, + { + 0x28, 0xC1, 0x8B, 0xA7, 0xEE, 0xE6, 0x95, 0xDD, + 0x73, 0x90, 0xB2, 0xF7, 0x19, 0x87, 0x2C, 0x70, + 0x80, 0x26, 0x47, 0x58, 0x79, 0xE7, 0xCE, 0xEA, + 0x2B, 0xE6, 0xE1, 0x31, 0x4A, 0xBB, 0x30, 0x6C, + 0xAB, 0xD8, 0xD5, 0x93, 0xE4, 0x28, 0xB2, 0x94, + 0xCB, 0xDD, 0x9D, 0x3E, 0x0E, 0xC0, 0x2B, 0xBF, + 0x72, 0xDF, 0x8A, 0x9C, 0xAB, 0x7E, 0x5A, 0x8D, + 0x65, 0x92, 0xFA, 0xB3, 0x8D, 0xFE, 0x5C, 0x01 + }, + { + 0x6D, 0xCB, 0x11, 0x99, 0x4F, 0x12, 0x0C, 0x92, + 0x13, 0x3E, 0x93, 0x79, 0x83, 0xE1, 0x33, 0xD1, + 0xE8, 0x45, 0x28, 0xE5, 0x5F, 0xC1, 0xDB, 0x4C, + 0x16, 0x35, 0x79, 0x4F, 0xEC, 0xAD, 0xFA, 0xE3, + 0x74, 0x49, 0x36, 0x8D, 0x6B, 0xA2, 0xC5, 0xC0, + 0xD5, 0xDA, 0xA1, 0x80, 0x77, 0x7A, 0xC1, 0x2F, + 0x25, 0xF2, 0xD2, 0x8B, 0x51, 0x07, 0x22, 0xC9, + 0xE7, 0xB5, 0x41, 0xF9, 0xBA, 0x84, 0x23, 0xED + }, + { + 0x56, 0xEC, 0x20, 0x36, 0x66, 0xFE, 0x0A, 0x70, + 0x51, 0x49, 0x13, 0x3C, 0x26, 0x76, 0xFC, 0xA0, + 0xDF, 0x5B, 0x2F, 0x75, 0x59, 0xE3, 0xCA, 0x9A, + 0x38, 0x6D, 0xC2, 0x0B, 0x5B, 0x5D, 0xE9, 0x66, + 0x82, 0xA4, 0x09, 0x45, 0xE8, 0x7C, 0x33, 0x3F, + 0xE7, 0xB3, 0xD4, 0x38, 0xFF, 0xBF, 0x17, 0x0F, + 0xF2, 0xDD, 0xB2, 0x58, 0xA8, 0x67, 0x9B, 0x24, + 0xF0, 0x4D, 0x0B, 0x31, 0x45, 0x89, 0x6E, 0x0E + }, + { + 0x54, 0x02, 0xEA, 0x2B, 0xC4, 0xEC, 0x8D, 0xCB, + 0x67, 0x7B, 0x57, 0x97, 0xD9, 0x0D, 0x55, 0x77, + 0xBC, 0x1A, 0xDE, 0x18, 0xA7, 0x74, 0xF3, 0x1E, + 0x0A, 0x67, 0x3D, 0xBE, 0x58, 0xC1, 0x4C, 0x23, + 0x79, 0xD6, 0xE5, 0xB2, 0xBB, 0x5C, 0x5B, 0x6E, + 0x4A, 0xD3, 0x21, 0x56, 0xE9, 0xB5, 0xE2, 0x32, + 0xDE, 0xEC, 0x6F, 0xEB, 0x19, 0x6A, 0x0B, 0x70, + 0x5C, 0x91, 0x98, 0x16, 0xB6, 0x1E, 0x30, 0x05 + }, + { + 0x71, 0x22, 0x3D, 0xCD, 0x4E, 0x26, 0x15, 0x82, + 0xB0, 0xBB, 0xD9, 0xCC, 0xE0, 0xEB, 0xED, 0x9F, + 0xA9, 0x82, 0xCD, 0xBD, 0x11, 0x0F, 0xB4, 0x3D, + 0xF7, 0x72, 0x82, 0xA5, 0xAC, 0x69, 0x0D, 0x65, + 0x62, 0xA5, 0x52, 0xD0, 0xF6, 0x5F, 0xEF, 0x6C, + 0x05, 0xEB, 0xD2, 0xF0, 0xE5, 0xED, 0x1E, 0x3E, + 0xA5, 0x8D, 0xDD, 0x8E, 0x33, 0x13, 0x66, 0x7D, + 0x27, 0x95, 0xC1, 0xA7, 0x32, 0x1F, 0xA3, 0x14 + }, + { + 0xD4, 0x13, 0x1D, 0xE0, 0x13, 0x92, 0x7A, 0xC0, + 0x55, 0x4D, 0x26, 0xA5, 0xAE, 0xD7, 0x8C, 0x34, + 0x53, 0x93, 0x5D, 0x00, 0x29, 0xDA, 0x9C, 0x66, + 0x69, 0xEA, 0x48, 0x86, 0xE3, 0x20, 0x7D, 0x88, + 0x0D, 0x03, 0xBB, 0x48, 0xF1, 0x60, 0xFA, 0xE6, + 0x58, 0xBD, 0xBF, 0x08, 0x70, 0xF1, 0x04, 0x34, + 0x8E, 0x7F, 0x19, 0x08, 0xBC, 0xC0, 0x79, 0x10, + 0x04, 0x48, 0xD4, 0x9C, 0xC9, 0x7A, 0x30, 0x64 + }, + { + 0x3E, 0x7A, 0xBC, 0x0A, 0x55, 0x16, 0xD2, 0xCE, + 0x53, 0xB8, 0xC8, 0x55, 0x50, 0x5F, 0x02, 0xDA, + 0xD6, 0x9E, 0x66, 0x2B, 0x07, 0x10, 0x60, 0x21, + 0xFA, 0x07, 0x1D, 0xBA, 0xF6, 0xB0, 0xC9, 0x3F, + 0xC0, 0x62, 0x29, 0xAD, 0x14, 0x4B, 0xA7, 0xC6, + 0xD5, 0x21, 0x35, 0xDF, 0x35, 0xDB, 0xB3, 0xE8, + 0x66, 0x83, 0xE3, 0x04, 0x57, 0x30, 0x7B, 0xA0, + 0xBF, 0xB8, 0x1D, 0x96, 0x14, 0xA5, 0x65, 0x1A + }, + { + 0x8E, 0x11, 0xD6, 0x51, 0x4D, 0x70, 0xA5, 0x95, + 0xB2, 0xFA, 0x3C, 0xE5, 0xA0, 0x3B, 0xAE, 0x6C, + 0x6E, 0xC4, 0xC5, 0xD6, 0x01, 0xBD, 0x7D, 0xB7, + 0xAF, 0x91, 0x64, 0x6A, 0x17, 0x3A, 0x95, 0xED, + 0x34, 0xC2, 0x63, 0xEA, 0x33, 0x87, 0x8C, 0xA7, + 0xE5, 0xF7, 0xE8, 0xFE, 0xEF, 0xA5, 0xB0, 0x5B, + 0x33, 0x07, 0x8D, 0xD8, 0x6B, 0xB2, 0x75, 0x9C, + 0x61, 0x95, 0x64, 0x01, 0x29, 0x28, 0x02, 0x42 + }, + { + 0xCB, 0x74, 0x5E, 0x20, 0x5E, 0x7B, 0x73, 0x71, + 0xB3, 0x06, 0xEB, 0x7F, 0xC5, 0x95, 0xE1, 0x72, + 0x94, 0xBC, 0xB8, 0x5D, 0x01, 0x9B, 0x29, 0x0B, + 0x72, 0xF6, 0xCC, 0xA5, 0x2A, 0xEC, 0xD4, 0x23, + 0x63, 0x30, 0xAF, 0xA4, 0xAE, 0xEB, 0x25, 0xC7, + 0x97, 0xE7, 0xB9, 0xE3, 0xA1, 0x4E, 0x02, 0x0C, + 0x31, 0x2A, 0x52, 0xAB, 0xE2, 0x7B, 0x0F, 0x5C, + 0x3B, 0xE0, 0x1E, 0x9E, 0xEE, 0x40, 0x78, 0x01 + }, + { + 0x73, 0x46, 0x3C, 0x48, 0x7F, 0xA9, 0x41, 0xF7, + 0x43, 0x32, 0x94, 0x75, 0x4E, 0x67, 0x8E, 0xC6, + 0x35, 0x61, 0x07, 0x94, 0x26, 0x5F, 0x7C, 0xC4, + 0x56, 0xF9, 0x5F, 0x79, 0xA7, 0x0D, 0x41, 0x7A, + 0x92, 0xB1, 0x8B, 0x3E, 0x75, 0x9B, 0xD8, 0xB7, + 0x62, 0xD0, 0x14, 0x7D, 0xFB, 0x0D, 0x4E, 0x53, + 0xF5, 0x5F, 0x5D, 0x06, 0x62, 0xF7, 0x59, 0xBD, + 0x8B, 0xBF, 0xF9, 0xE7, 0x21, 0x6B, 0xBC, 0x38 + }, + { + 0xBB, 0xB0, 0x97, 0xD8, 0xB0, 0x2C, 0x6A, 0x73, + 0xE5, 0x52, 0xBE, 0x18, 0xEC, 0x67, 0xCF, 0xD5, + 0xB6, 0x3A, 0x49, 0x38, 0x70, 0xFB, 0x08, 0xC8, + 0xFD, 0x07, 0x6A, 0x9D, 0x6C, 0xFE, 0x22, 0x10, + 0x54, 0x86, 0x10, 0x4E, 0x85, 0xA6, 0xB3, 0xBB, + 0xB8, 0xA5, 0x3E, 0x2F, 0xE8, 0xC8, 0x6C, 0x71, + 0x79, 0xF3, 0xB5, 0x74, 0xFB, 0xEB, 0xF4, 0xD8, + 0x75, 0xE8, 0x6F, 0xDF, 0x04, 0x9D, 0x44, 0x7C + }, + { + 0x92, 0x9A, 0x55, 0x3C, 0x1E, 0xC8, 0xBC, 0xB0, + 0xA8, 0x46, 0xFE, 0xD0, 0xBB, 0x7C, 0xF3, 0x5D, + 0xE4, 0x68, 0x71, 0x7A, 0xB2, 0xBB, 0x74, 0xF4, + 0x49, 0x7C, 0x12, 0x32, 0x7C, 0xA9, 0xE7, 0x8B, + 0x74, 0x3F, 0x96, 0xAF, 0x98, 0xCB, 0xB2, 0x0F, + 0xA4, 0x9A, 0x46, 0x3C, 0x18, 0xA9, 0x81, 0xD1, + 0xE9, 0x20, 0xF8, 0x68, 0xA7, 0x84, 0x8C, 0xE3, + 0x84, 0x70, 0x63, 0x19, 0x3D, 0xD6, 0x8C, 0x73 + }, + { + 0x1E, 0xA0, 0xDC, 0xCC, 0xF5, 0x3C, 0x2E, 0x8F, + 0x38, 0xAA, 0x93, 0xE4, 0x20, 0xCA, 0x40, 0xD2, + 0x5A, 0x93, 0x90, 0xE9, 0x33, 0x7E, 0xA5, 0x55, + 0x6C, 0x6B, 0x99, 0x9B, 0xCE, 0x39, 0x0E, 0x0E, + 0xDA, 0xA2, 0x73, 0x65, 0xE4, 0x6C, 0xD5, 0x92, + 0x9D, 0x68, 0x49, 0xE5, 0x71, 0x01, 0x22, 0x7C, + 0x46, 0x9D, 0x1E, 0xDF, 0x13, 0x5D, 0xDD, 0xAB, + 0x87, 0x13, 0xB7, 0x28, 0x72, 0x86, 0x7E, 0xDD + }, + { + 0xE3, 0x22, 0x4A, 0xD4, 0xF4, 0x24, 0x7B, 0x22, + 0x41, 0x21, 0x2D, 0x39, 0xAB, 0x51, 0x2E, 0xD0, + 0xA0, 0x1F, 0x38, 0x7D, 0xB7, 0x1E, 0xE5, 0x62, + 0x35, 0xBC, 0x4C, 0x6E, 0xCD, 0x0C, 0x73, 0xA6, + 0x81, 0x7E, 0x8F, 0xF5, 0x58, 0x86, 0xB6, 0xF2, + 0xDB, 0x31, 0x4B, 0xC5, 0xEE, 0xDA, 0xE7, 0xBF, + 0xA0, 0x72, 0xDC, 0x01, 0x3B, 0x48, 0x58, 0x90, + 0x28, 0x96, 0x8E, 0x9D, 0xC0, 0xB7, 0xE3, 0xDD + }, + { + 0xEA, 0x83, 0x7F, 0x58, 0x22, 0xA2, 0x95, 0xA8, + 0xFE, 0x74, 0xBF, 0x8F, 0x1B, 0x02, 0x62, 0xDD, + 0xE7, 0x20, 0x93, 0xAA, 0x8F, 0x87, 0x0C, 0xED, + 0x7E, 0xD8, 0xC3, 0xD2, 0xE0, 0x96, 0xC1, 0xDF, + 0xD9, 0x2C, 0xAC, 0x5E, 0xDA, 0x2C, 0xF2, 0xDE, + 0xC3, 0x1A, 0x13, 0xBA, 0x33, 0x5E, 0x44, 0xFB, + 0x14, 0x10, 0x9A, 0x73, 0x01, 0x9A, 0xBD, 0x62, + 0x22, 0x3B, 0x36, 0x83, 0xA6, 0xC7, 0xC4, 0x0D + }, + { + 0x47, 0xE9, 0xC2, 0x26, 0xD2, 0x55, 0xB2, 0x28, + 0x00, 0x2C, 0x34, 0x02, 0x19, 0xC3, 0x4F, 0x51, + 0xF5, 0x99, 0x63, 0xDD, 0xAF, 0xD5, 0xA9, 0x5B, + 0x53, 0x16, 0x9D, 0xF3, 0xFD, 0x2F, 0x64, 0x96, + 0x67, 0xE3, 0xF6, 0x3D, 0x9E, 0x33, 0xB4, 0x22, + 0xC0, 0xD8, 0x60, 0x2A, 0x94, 0x0C, 0x6B, 0x90, + 0x55, 0x9B, 0xDE, 0x2E, 0xDC, 0x8E, 0x67, 0x9E, + 0x72, 0x5F, 0x86, 0xF5, 0xED, 0x09, 0x72, 0xFF + }, + { + 0x98, 0xE3, 0x72, 0xFF, 0x05, 0x8A, 0xB2, 0xAD, + 0xCF, 0xBC, 0x68, 0xA9, 0xB7, 0x43, 0x90, 0xEB, + 0xA2, 0xD3, 0xB0, 0x47, 0xB2, 0x08, 0x08, 0xDA, + 0x98, 0xE2, 0x28, 0x75, 0x68, 0xA7, 0x69, 0x51, + 0xC9, 0xFE, 0x2C, 0x67, 0x6A, 0x56, 0x8F, 0x35, + 0xEA, 0x58, 0x5E, 0x5E, 0x0D, 0x03, 0x1E, 0x69, + 0x33, 0x8B, 0xBF, 0x53, 0xC7, 0x2B, 0x92, 0x5D, + 0x26, 0x4E, 0xF3, 0x4A, 0xCB, 0xEB, 0xF1, 0xD3 + }, + { + 0xFF, 0x8A, 0x61, 0xA9, 0x9E, 0x74, 0x63, 0x22, + 0x93, 0x28, 0xA5, 0x6B, 0x2B, 0xA2, 0x52, 0xF9, + 0x79, 0xAF, 0x2A, 0x4D, 0x90, 0xD9, 0x17, 0xFA, + 0xF4, 0xAE, 0x85, 0x72, 0xE2, 0x33, 0x0B, 0xF5, + 0x59, 0xAB, 0xE1, 0xCF, 0x5C, 0x83, 0xA5, 0x0D, + 0x2B, 0x10, 0x48, 0x3D, 0x47, 0xAB, 0x00, 0x2F, + 0xCC, 0xB9, 0x53, 0xEA, 0x63, 0x0F, 0x32, 0x84, + 0xCE, 0xEF, 0x13, 0x86, 0x8F, 0x70, 0x26, 0x07 + }, + { + 0x46, 0xDA, 0xF6, 0xC5, 0x2E, 0xC4, 0x65, 0x35, + 0xEB, 0x0A, 0xAB, 0x36, 0xC9, 0x1D, 0xDA, 0x35, + 0x49, 0x87, 0xF2, 0xF1, 0x72, 0x89, 0xE8, 0xC5, + 0xA1, 0x5C, 0xA9, 0x3A, 0x17, 0x47, 0xDC, 0xF1, + 0xFC, 0xEB, 0x77, 0x92, 0x45, 0x8A, 0xC5, 0x56, + 0x19, 0xB0, 0xB6, 0x60, 0x72, 0x7F, 0x4B, 0x48, + 0x7D, 0x1C, 0x17, 0xCC, 0xB4, 0xD4, 0x46, 0xF7, + 0x2A, 0xC2, 0xB0, 0xF2, 0x4F, 0xE6, 0xBC, 0xC1 + }, + { + 0x49, 0x92, 0xA9, 0xBC, 0x9C, 0x59, 0x67, 0xFB, + 0x8A, 0x29, 0x38, 0x9E, 0xFF, 0x11, 0xE8, 0xE4, + 0x73, 0x81, 0xED, 0x39, 0x4B, 0x99, 0xF1, 0x52, + 0x10, 0x11, 0x56, 0x22, 0x7F, 0xA1, 0x7A, 0xB6, + 0xDE, 0x17, 0x80, 0xAD, 0xA8, 0x15, 0xF1, 0xDB, + 0x20, 0x88, 0xC3, 0xB9, 0x4A, 0x06, 0x36, 0x06, + 0x80, 0xEB, 0x1E, 0x58, 0xC7, 0xEB, 0x69, 0x06, + 0x2B, 0xF9, 0x41, 0x6D, 0xF9, 0xD2, 0xEB, 0x9A + }, + { + 0x5B, 0xF2, 0xE6, 0x4D, 0x29, 0x46, 0x03, 0xE6, + 0x7D, 0xBB, 0x4B, 0xBE, 0xDE, 0x78, 0xB6, 0xB5, + 0xB6, 0xF6, 0xC0, 0x02, 0x8E, 0xBE, 0x25, 0x6A, + 0x0A, 0x45, 0x06, 0x23, 0xDC, 0x52, 0x0E, 0x2E, + 0xF6, 0x65, 0x3D, 0x58, 0x9F, 0xC6, 0xF1, 0xCE, + 0xF6, 0x5E, 0x21, 0xEE, 0xD0, 0xBC, 0xD1, 0xB6, + 0xB6, 0x24, 0x38, 0xCD, 0x20, 0x9F, 0x27, 0xA7, + 0xA1, 0x13, 0x43, 0x83, 0xC8, 0x33, 0xFB, 0xB5 + }, + { + 0xF1, 0xE9, 0xAC, 0xE9, 0x02, 0xAA, 0xBA, 0xD6, + 0x85, 0x0A, 0xAB, 0x99, 0xF3, 0xD9, 0xC5, 0x4A, + 0xEE, 0xA8, 0x74, 0xC2, 0x3E, 0xAE, 0xAE, 0xB8, + 0xD9, 0x98, 0xAC, 0xF2, 0x68, 0xD5, 0xB7, 0x95, + 0xFB, 0xF7, 0xA0, 0x7E, 0xE0, 0x9F, 0x5A, 0x1C, + 0xCA, 0xB0, 0xBC, 0x3D, 0xF4, 0x78, 0x74, 0xB2, + 0xAA, 0xB4, 0x37, 0x8F, 0x28, 0x95, 0x37, 0xC6, + 0xDF, 0x80, 0xE2, 0x3E, 0x68, 0xAB, 0x01, 0xC5 + }, + { + 0x81, 0xF4, 0x41, 0x24, 0x31, 0xFA, 0x72, 0xF9, + 0x7B, 0x45, 0x3F, 0x7A, 0x2B, 0x9D, 0x4F, 0xE9, + 0xAA, 0xA4, 0xAE, 0x82, 0x6B, 0xA2, 0xB6, 0xE4, + 0x4C, 0x8A, 0xBF, 0x5B, 0x6F, 0x57, 0x62, 0xD6, + 0x14, 0x92, 0xE9, 0x5D, 0x64, 0x47, 0xFC, 0xAA, + 0xED, 0x4F, 0x8E, 0x7C, 0x40, 0xF0, 0x47, 0xAC, + 0xB9, 0x21, 0x97, 0x78, 0x51, 0x8D, 0x0E, 0xBA, + 0xA3, 0xB0, 0x2C, 0xF4, 0x8D, 0x9F, 0x06, 0x89 + }, + { + 0x39, 0xCC, 0xC7, 0xFB, 0x27, 0x45, 0x85, 0x9F, + 0x02, 0x74, 0xAE, 0xDF, 0x6B, 0xA5, 0xC5, 0x66, + 0x63, 0x09, 0x4B, 0x8E, 0x1D, 0x0E, 0xDC, 0x6F, + 0xFB, 0x78, 0x85, 0xF9, 0x3E, 0xA9, 0x32, 0x20, + 0x32, 0x36, 0xA9, 0x7E, 0xD2, 0xAF, 0x50, 0x7F, + 0x8E, 0x5F, 0x1B, 0xDF, 0x01, 0x80, 0x4D, 0xB0, + 0xC4, 0xB0, 0x3F, 0x77, 0x9F, 0xB2, 0x15, 0xB4, + 0x73, 0x09, 0x72, 0x17, 0xFF, 0xDD, 0x14, 0xDB + }, + { + 0x32, 0x43, 0x8C, 0x2B, 0x85, 0x4A, 0x99, 0x9C, + 0xE2, 0x5A, 0x59, 0x91, 0x63, 0x21, 0xE6, 0xF8, + 0x45, 0x9C, 0x31, 0x32, 0x1F, 0x45, 0x56, 0x81, + 0xC6, 0xE6, 0xE7, 0x2A, 0xA8, 0x15, 0x81, 0x16, + 0xD3, 0x8D, 0xDD, 0xC2, 0x7A, 0xED, 0x5C, 0x17, + 0xD0, 0xD1, 0x71, 0xB1, 0x6F, 0xA4, 0x03, 0x48, + 0x53, 0x82, 0x18, 0xD5, 0xE6, 0x07, 0xA1, 0x4D, + 0x74, 0x2C, 0x8B, 0xD4, 0x6A, 0x0C, 0x66, 0xA5 + }, + { + 0x51, 0x66, 0xB9, 0xB0, 0x0C, 0x1F, 0xF3, 0xC4, + 0x0D, 0xBA, 0x7F, 0xEC, 0xE9, 0xC4, 0xB0, 0xB1, + 0x7C, 0x2A, 0x31, 0xBF, 0xD4, 0x47, 0x4F, 0x2C, + 0x45, 0x41, 0xE6, 0x2E, 0x79, 0xA9, 0x76, 0x58, + 0x3D, 0x8C, 0x8C, 0xE6, 0x4F, 0xED, 0xD5, 0xF2, + 0xF5, 0x5E, 0x04, 0xC5, 0xB1, 0x73, 0xA4, 0x93, + 0x87, 0x16, 0x12, 0x48, 0x91, 0xF2, 0x7C, 0xED, + 0x64, 0x03, 0xE9, 0xE8, 0xE4, 0x4C, 0xB8, 0x19 + }, + { + 0x99, 0xFF, 0x7D, 0xC3, 0x49, 0x70, 0x72, 0x6F, + 0x46, 0x93, 0x51, 0x7E, 0x05, 0x15, 0x1C, 0x59, + 0x9A, 0x9F, 0xB9, 0xDF, 0x44, 0x0A, 0xBE, 0x02, + 0x37, 0x83, 0xE7, 0x7D, 0xE3, 0xCB, 0x8D, 0x40, + 0x19, 0x4E, 0xAB, 0xBB, 0x32, 0xD1, 0x2B, 0xE3, + 0x52, 0x1C, 0x42, 0x6E, 0x4C, 0xA8, 0x18, 0x05, + 0xFD, 0xD2, 0x7B, 0xE7, 0x26, 0x1F, 0x44, 0xE9, + 0x36, 0xEF, 0x67, 0x31, 0x68, 0xF0, 0xC1, 0x85 + }, + { + 0xE1, 0x44, 0x1E, 0xF6, 0xD9, 0x74, 0xF6, 0x62, + 0x26, 0xE0, 0x13, 0x45, 0x47, 0x44, 0x30, 0xD7, + 0x15, 0x66, 0xB2, 0x8A, 0x22, 0x19, 0xF8, 0x6F, + 0x28, 0x11, 0xEF, 0xA0, 0x2B, 0xB4, 0xC1, 0x7A, + 0x3D, 0x77, 0x7D, 0xEA, 0x90, 0x2A, 0xD1, 0x91, + 0x71, 0xD4, 0xBA, 0x74, 0xF6, 0x17, 0x00, 0x23, + 0x0F, 0xD6, 0x73, 0x68, 0x8D, 0xE3, 0x0C, 0x96, + 0x79, 0xD2, 0xF3, 0x74, 0xE6, 0x96, 0x47, 0x6A + }, + { + 0xA8, 0x7A, 0xE4, 0x7D, 0x89, 0x61, 0x69, 0xC1, + 0x61, 0x4A, 0xF2, 0xB1, 0x51, 0x72, 0xAE, 0x7F, + 0xFB, 0x29, 0xF6, 0x9B, 0x09, 0x64, 0xB1, 0xEE, + 0x03, 0x4C, 0x2A, 0xAC, 0x9E, 0xB9, 0xD6, 0x6A, + 0xD7, 0x65, 0x41, 0xDE, 0xEA, 0x86, 0x1E, 0x26, + 0x8F, 0x7C, 0x6C, 0x10, 0x2F, 0x58, 0x28, 0x71, + 0x1F, 0x4D, 0x80, 0x3A, 0xF0, 0xA9, 0xEF, 0xE3, + 0x9F, 0xEE, 0x72, 0x38, 0xEB, 0xE8, 0xF5, 0xB4 + }, + { + 0xA9, 0x79, 0x93, 0x61, 0x18, 0x90, 0xA5, 0xF0, + 0x99, 0x95, 0xC7, 0xA3, 0x8B, 0x7B, 0x46, 0x13, + 0xF4, 0x21, 0xB8, 0x8A, 0x9A, 0xF7, 0xCC, 0xD4, + 0xBE, 0x9C, 0xC9, 0x60, 0x81, 0xC5, 0x6B, 0x09, + 0xD5, 0xE2, 0x8F, 0x6C, 0xE4, 0x2F, 0x26, 0x13, + 0xAA, 0xB9, 0x7B, 0xF1, 0x4B, 0xE9, 0x07, 0xD0, + 0x36, 0x62, 0xBD, 0x84, 0x23, 0xCC, 0x00, 0x79, + 0x9A, 0x86, 0x21, 0x08, 0xF5, 0x50, 0xE2, 0xDC + }, + { + 0xCD, 0x28, 0x0B, 0x18, 0x89, 0xCB, 0xAF, 0xD0, + 0xB3, 0xBF, 0xA2, 0x6F, 0xA2, 0x26, 0x40, 0xB2, + 0xAF, 0x14, 0xF9, 0xBD, 0xF4, 0x65, 0x12, 0x81, + 0x5A, 0x52, 0x3D, 0xE0, 0x54, 0x30, 0x75, 0xC9, + 0x2D, 0x11, 0xC3, 0x30, 0xFD, 0x83, 0xFF, 0x41, + 0x18, 0xB2, 0x00, 0x0D, 0x22, 0x46, 0x0E, 0xAA, + 0x7F, 0x3C, 0x4D, 0xCF, 0xA9, 0x5F, 0x71, 0xCF, + 0x2C, 0xE7, 0xF7, 0x4C, 0xE6, 0x8E, 0x14, 0xEF + }, + { + 0xD2, 0xEC, 0xCE, 0x0B, 0x14, 0x61, 0x30, 0xB1, + 0x8E, 0xA7, 0xEA, 0x66, 0x34, 0xB8, 0xDE, 0x4A, + 0x8E, 0xBD, 0xD2, 0xF9, 0x78, 0xD5, 0x1A, 0xC8, + 0xD7, 0xEC, 0x41, 0x54, 0xC5, 0xB2, 0xC4, 0x07, + 0x24, 0x0E, 0x59, 0x27, 0x56, 0x38, 0x45, 0xAB, + 0x6A, 0x8C, 0xED, 0x66, 0x39, 0x0C, 0x20, 0x9F, + 0xC0, 0xEB, 0x6B, 0x5F, 0xEE, 0x38, 0x97, 0xD3, + 0x1E, 0xE5, 0x83, 0x42, 0x32, 0xF2, 0xA5, 0x31 + }, + { + 0x85, 0xD6, 0x9B, 0xBB, 0xB4, 0x06, 0x1B, 0x88, + 0x53, 0x20, 0xCC, 0x51, 0xD1, 0x69, 0x12, 0xBE, + 0x04, 0x11, 0x4B, 0x90, 0xA1, 0x62, 0x3B, 0xA1, + 0x64, 0x05, 0x10, 0x47, 0x28, 0xD7, 0x81, 0xBB, + 0xCE, 0x8A, 0x3A, 0x9B, 0xB2, 0x6C, 0x74, 0xB2, + 0x91, 0xFE, 0x2A, 0x8D, 0xF0, 0xF8, 0x91, 0xF6, + 0x25, 0xB8, 0x7E, 0x5E, 0xE4, 0xED, 0x51, 0xAC, + 0xB9, 0xBB, 0x0F, 0xB5, 0xF2, 0xF3, 0xC3, 0xF5 + }, + { + 0xED, 0x5B, 0x34, 0xA5, 0x00, 0xD4, 0xF4, 0x06, + 0xE2, 0xDB, 0x4A, 0x36, 0xC4, 0x93, 0x89, 0x51, + 0xFC, 0x0D, 0x50, 0xCE, 0x9C, 0x85, 0xBC, 0x61, + 0x8A, 0x25, 0xDC, 0xAC, 0x0F, 0x94, 0x31, 0x8D, + 0x28, 0x69, 0x9B, 0x11, 0xFE, 0x99, 0x44, 0xBF, + 0xD2, 0xB2, 0x55, 0x05, 0x3B, 0x91, 0x37, 0xE2, + 0xC4, 0x9D, 0x1B, 0x26, 0x90, 0xD8, 0xC6, 0x18, + 0xAA, 0x07, 0xB5, 0x6D, 0x16, 0xE2, 0x26, 0x14 + }, + { + 0xCA, 0xE4, 0xB9, 0x02, 0x37, 0xFE, 0x37, 0xDB, + 0x2E, 0x2A, 0x03, 0xCE, 0xEF, 0xFB, 0xB7, 0x4F, + 0x2F, 0xDA, 0xDD, 0x93, 0xD4, 0x68, 0x0E, 0x6F, + 0xB3, 0x38, 0xD9, 0xBF, 0x82, 0xDA, 0x53, 0xB5, + 0x1D, 0x28, 0xFE, 0xD2, 0xC1, 0x27, 0x93, 0xF5, + 0x7C, 0x10, 0x82, 0xDF, 0xBF, 0x7D, 0x18, 0xF6, + 0x84, 0x73, 0xDB, 0x6E, 0xC3, 0x7A, 0x4B, 0xA8, + 0x27, 0x4B, 0xB3, 0x00, 0xA0, 0x31, 0x1A, 0xA7 + }, + { + 0x02, 0xE3, 0x6A, 0xD5, 0x61, 0xC2, 0xC6, 0x75, + 0xBB, 0xC9, 0xA4, 0x0E, 0xBB, 0xC1, 0x35, 0x48, + 0x75, 0xEA, 0x4E, 0x65, 0x01, 0x0F, 0x08, 0x46, + 0x60, 0x54, 0xD7, 0x77, 0x56, 0x34, 0x5C, 0xDB, + 0x43, 0xAC, 0x60, 0x60, 0xE2, 0x40, 0xF9, 0xB7, + 0xAD, 0x71, 0xE1, 0x58, 0xB8, 0x39, 0x08, 0x80, + 0x73, 0xA0, 0xD0, 0xE0, 0x9F, 0xFF, 0x83, 0x6C, + 0x76, 0x80, 0x4E, 0xA6, 0xAD, 0xED, 0x8D, 0x6E + }, + { + 0x13, 0x15, 0x4A, 0x93, 0xE7, 0x8B, 0x11, 0x47, + 0xAC, 0xD0, 0x01, 0x95, 0x87, 0x55, 0xBE, 0xEE, + 0xEC, 0x09, 0x1E, 0x1B, 0x6B, 0xC1, 0xB7, 0xB1, + 0x4D, 0xF3, 0xB5, 0x5A, 0x0D, 0x27, 0xDE, 0x73, + 0x49, 0xC4, 0x37, 0x46, 0xAC, 0x34, 0x1A, 0xF4, + 0x12, 0x68, 0x7A, 0x79, 0xDE, 0xD8, 0xB8, 0x89, + 0x31, 0xFA, 0xD5, 0xFA, 0xF4, 0xA1, 0x86, 0x85, + 0x2F, 0xC6, 0xCC, 0xF9, 0x90, 0x00, 0x44, 0x78 + }, + { + 0x21, 0x60, 0xFF, 0x86, 0x46, 0x6B, 0x09, 0x4E, + 0xBA, 0xE7, 0x4D, 0xD5, 0x97, 0xC5, 0x68, 0xC0, + 0x75, 0xF9, 0x94, 0x1C, 0x9F, 0x6E, 0x1D, 0x5B, + 0x56, 0x8F, 0x78, 0x1F, 0x03, 0x3E, 0x1F, 0x68, + 0x79, 0x97, 0xCF, 0x35, 0x8D, 0x61, 0x12, 0xC1, + 0x89, 0x9B, 0x2A, 0x8F, 0xC9, 0xAC, 0xDB, 0x62, + 0xFB, 0x38, 0x6B, 0xB7, 0x3F, 0x63, 0x63, 0x18, + 0xEA, 0x61, 0x8F, 0x19, 0x20, 0xBC, 0x0C, 0x7C + }, + { + 0x19, 0x17, 0x07, 0x7D, 0x19, 0xBF, 0x98, 0xCC, + 0xC9, 0x18, 0x39, 0xF0, 0x93, 0xF1, 0x6F, 0x9A, + 0x0B, 0x28, 0x20, 0xBD, 0xEF, 0x6C, 0xA8, 0x81, + 0x77, 0xAD, 0xD6, 0x6D, 0xB5, 0x00, 0x6D, 0x60, + 0x6D, 0x24, 0x16, 0x98, 0xC2, 0x5F, 0x36, 0xA9, + 0x44, 0x0D, 0xD4, 0x45, 0xDA, 0x62, 0x65, 0xFE, + 0x4B, 0x29, 0x46, 0xE9, 0xDF, 0x9C, 0x33, 0x27, + 0x1E, 0x2C, 0x2C, 0x15, 0x16, 0x02, 0x25, 0x6A + }, + { + 0x65, 0xBC, 0x85, 0xAC, 0x9C, 0xCB, 0xD7, 0x9A, + 0x91, 0x9D, 0x77, 0x93, 0x80, 0x0E, 0xA8, 0x6E, + 0x75, 0x2E, 0x7C, 0xE4, 0x11, 0xB2, 0xFD, 0x1F, + 0x84, 0x4B, 0x30, 0xCC, 0xBB, 0x62, 0x95, 0x1F, + 0x2D, 0x7C, 0xC4, 0x21, 0xF7, 0x61, 0x22, 0x30, + 0xA1, 0xAA, 0x3C, 0xD2, 0x4B, 0xD6, 0x05, 0x30, + 0x62, 0x48, 0xF8, 0xD1, 0xCC, 0xD3, 0x7B, 0xA5, + 0x2B, 0x7F, 0xB7, 0x25, 0xB3, 0xE8, 0xB1, 0xC1 + }, + { + 0x57, 0x2F, 0x80, 0x9D, 0x9B, 0xA8, 0x20, 0x5D, + 0x25, 0xAA, 0xCD, 0x35, 0xF1, 0x72, 0xA4, 0xF2, + 0xC4, 0xB4, 0x6A, 0x2C, 0x6C, 0x50, 0xFA, 0xC5, + 0x3B, 0x66, 0xE1, 0xE4, 0x87, 0x66, 0x2E, 0x81, + 0x39, 0x2A, 0xC5, 0xB6, 0x64, 0x98, 0x30, 0x4C, + 0x3C, 0xCD, 0xF3, 0x6A, 0x54, 0xA9, 0xFF, 0x32, + 0x4F, 0x42, 0x61, 0x55, 0xD9, 0xEC, 0x5B, 0xE4, + 0xA7, 0x98, 0x95, 0xFC, 0xBD, 0xAA, 0x2D, 0x89 + }, + { + 0xDB, 0x0C, 0xBA, 0x2D, 0x13, 0xE0, 0xB1, 0xF2, + 0xB6, 0x7D, 0x2A, 0x67, 0x70, 0x08, 0x02, 0xD2, + 0x8A, 0x23, 0x3E, 0x94, 0xDD, 0x12, 0x52, 0x97, + 0x29, 0x96, 0x91, 0x55, 0x29, 0x26, 0x34, 0xE8, + 0xDF, 0xC9, 0xA4, 0x80, 0x01, 0xAE, 0x8C, 0xF0, + 0xC9, 0xC9, 0x75, 0x0C, 0xB9, 0x5D, 0xC4, 0x5D, + 0xEF, 0x7E, 0xB8, 0xE2, 0x32, 0x23, 0xD5, 0x92, + 0x34, 0xCF, 0x08, 0x8C, 0xD8, 0x12, 0x06, 0xFB + }, + { + 0xDA, 0xC7, 0x72, 0x3A, 0xA4, 0xCF, 0xEE, 0xBD, + 0xA3, 0x7C, 0xF8, 0x59, 0xC0, 0x7C, 0xE4, 0x42, + 0xFE, 0x3A, 0x60, 0xDA, 0x47, 0x9C, 0xC5, 0xC9, + 0xFC, 0xAA, 0xEB, 0xA8, 0xFC, 0x6B, 0x23, 0x7C, + 0x70, 0xBF, 0xE8, 0x11, 0xD1, 0xEC, 0xEB, 0x46, + 0x7E, 0x67, 0x0F, 0x4C, 0xA5, 0x1F, 0xF7, 0x02, + 0x80, 0x95, 0xD2, 0x5A, 0x57, 0x02, 0x14, 0xEF, + 0xC2, 0x6B, 0x50, 0x2A, 0x64, 0x04, 0xD6, 0x1D + }, + { + 0x1B, 0xB6, 0xE1, 0x6B, 0x4D, 0x1C, 0x87, 0x71, + 0xFB, 0xB9, 0xC4, 0x9F, 0x25, 0x1F, 0x54, 0xA1, + 0xC3, 0x27, 0xDE, 0x47, 0x8A, 0x7D, 0x64, 0xAE, + 0x95, 0xDE, 0x6C, 0x19, 0x88, 0x0E, 0x52, 0xC9, + 0x6D, 0xBC, 0x60, 0x7A, 0x05, 0x4E, 0xDF, 0xF5, + 0x3D, 0x02, 0x3F, 0xE6, 0xDC, 0x6D, 0x90, 0xB5, + 0x3B, 0x34, 0x07, 0xAC, 0xB5, 0xEF, 0xEC, 0x70, + 0x91, 0xA5, 0xE2, 0x39, 0x2A, 0x2A, 0x64, 0x8C + }, + { + 0x8F, 0xE3, 0x6F, 0x48, 0x3F, 0xAA, 0x68, 0xDC, + 0x57, 0x38, 0x5B, 0x55, 0x0F, 0x1C, 0x48, 0x08, + 0x55, 0x87, 0xCE, 0x8E, 0x6B, 0x5B, 0xA9, 0x93, + 0x16, 0xB0, 0x37, 0x8E, 0x46, 0x55, 0xB7, 0x28, + 0xEA, 0x29, 0x41, 0x0E, 0xA6, 0xC0, 0x1B, 0x21, + 0x4A, 0x19, 0x7D, 0x30, 0xFD, 0x11, 0x64, 0x5C, + 0xFE, 0xB8, 0x81, 0x39, 0x69, 0x67, 0xED, 0x80, + 0x77, 0xBC, 0x22, 0x79, 0x7A, 0x79, 0xE4, 0xEA + }, + { + 0x14, 0x38, 0x5A, 0xE8, 0x9F, 0xF8, 0x14, 0x72, + 0xBA, 0x8B, 0xCE, 0x38, 0x4A, 0x31, 0x16, 0x7A, + 0xD6, 0x72, 0x2D, 0x66, 0x56, 0x65, 0x81, 0xE0, + 0x3D, 0x57, 0x47, 0x6F, 0x5D, 0xB6, 0x97, 0x99, + 0x39, 0x56, 0xC4, 0x48, 0x4A, 0xA9, 0x8F, 0x99, + 0x73, 0x2F, 0xDE, 0x3D, 0xC6, 0xFE, 0x0F, 0xA2, + 0xAB, 0x65, 0x0A, 0x5F, 0x84, 0xE4, 0x49, 0xA6, + 0x8B, 0x57, 0x2B, 0x68, 0x84, 0x84, 0xC0, 0xBC + }, + { + 0x8F, 0xB1, 0x25, 0x65, 0xF1, 0xDE, 0x50, 0x6D, + 0xBE, 0xF2, 0x2F, 0xEC, 0x70, 0x45, 0xAE, 0x02, + 0xFF, 0x0A, 0xD4, 0xBC, 0xAE, 0x87, 0xB9, 0x01, + 0xEC, 0x98, 0x9A, 0xDB, 0x65, 0xF3, 0xDB, 0xAF, + 0x78, 0x8C, 0x7F, 0x31, 0x35, 0x68, 0xD1, 0x62, + 0x72, 0x77, 0xDB, 0xB0, 0x96, 0xC5, 0x62, 0x92, + 0x2E, 0xB6, 0x31, 0x77, 0x57, 0xBB, 0xD3, 0x47, + 0xBC, 0xC6, 0x1F, 0xD4, 0xE0, 0xDD, 0xAF, 0xC0 + }, + { + 0x5D, 0x1C, 0x6E, 0x45, 0x64, 0xEE, 0x29, 0x35, + 0xED, 0xFC, 0xA2, 0x8B, 0xE9, 0x75, 0x22, 0x49, + 0xB6, 0xF7, 0xB3, 0x12, 0x48, 0x39, 0xC6, 0x50, + 0x1C, 0x67, 0x8F, 0x3B, 0x08, 0x4D, 0xE4, 0xAE, + 0xA5, 0xDA, 0x05, 0xDC, 0x11, 0x17, 0x14, 0xDA, + 0xE0, 0xE0, 0xD0, 0x53, 0x3B, 0xD1, 0xA0, 0x77, + 0x69, 0xA0, 0xC3, 0xF4, 0x54, 0xC5, 0x16, 0x86, + 0x22, 0x55, 0x05, 0x96, 0x22, 0x65, 0x56, 0x33 + }, + { + 0xF3, 0x2E, 0x8B, 0x50, 0xF8, 0x1C, 0x42, 0xE8, + 0xB9, 0xE8, 0x8F, 0x23, 0x77, 0xF5, 0xE8, 0xF7, + 0x7A, 0x83, 0x92, 0x6C, 0xEC, 0x38, 0xBB, 0x38, + 0xCF, 0x5E, 0x9F, 0x94, 0xF3, 0xAF, 0x10, 0x1F, + 0xD9, 0xEE, 0x7E, 0x1F, 0x6A, 0xD9, 0xD2, 0xD8, + 0x0B, 0x68, 0xDA, 0x80, 0xC5, 0x65, 0x72, 0x18, + 0x1D, 0x20, 0x15, 0x74, 0x50, 0x21, 0xE6, 0x68, + 0xA6, 0xD9, 0xF7, 0x2B, 0x66, 0x82, 0xB6, 0x4B + }, + { + 0xF0, 0xC6, 0x05, 0x1B, 0x35, 0x08, 0xF4, 0x3F, + 0xB1, 0xA1, 0x44, 0x5E, 0xE3, 0xE4, 0xB3, 0x70, + 0xF9, 0xE4, 0x36, 0x8E, 0xAC, 0x78, 0x54, 0x9A, + 0x86, 0x9C, 0x39, 0xE7, 0x3A, 0x37, 0x25, 0xB1, + 0x7E, 0x9C, 0x33, 0xB8, 0xBF, 0xB4, 0xFD, 0x7A, + 0x60, 0xB7, 0x64, 0xBD, 0x00, 0x6E, 0x30, 0x80, + 0xF3, 0xC2, 0x88, 0xFF, 0x99, 0x7D, 0x44, 0x78, + 0x39, 0x88, 0x08, 0x69, 0x67, 0xB0, 0x2B, 0xC2 + }, + { + 0xB7, 0x55, 0x09, 0x2E, 0x2D, 0x86, 0x09, 0x72, + 0xEC, 0xFA, 0x2A, 0x32, 0x60, 0x36, 0xE3, 0x71, + 0xA2, 0x99, 0x5C, 0x22, 0xD2, 0x64, 0xF4, 0xCB, + 0xF4, 0xB9, 0xA9, 0x30, 0x41, 0x50, 0x6E, 0x48, + 0x44, 0xD9, 0x19, 0xBC, 0x1F, 0xAC, 0x5E, 0xE0, + 0xF5, 0xA6, 0x27, 0xBD, 0xF2, 0x5D, 0x70, 0x05, + 0xCD, 0x80, 0x3A, 0xF0, 0x8F, 0xCC, 0xF6, 0xC2, + 0x41, 0x8A, 0x65, 0x59, 0xB1, 0x5A, 0x07, 0x6C + }, + { + 0x03, 0x23, 0x69, 0x07, 0x69, 0xDB, 0x41, 0xB8, + 0x0A, 0xDD, 0xE1, 0x9A, 0xD6, 0xB9, 0xF5, 0x80, + 0x9D, 0x4C, 0xB0, 0x26, 0xB2, 0x69, 0xA3, 0x1E, + 0x99, 0xAF, 0x98, 0xF1, 0xEF, 0xAF, 0xB8, 0x0D, + 0x50, 0x2C, 0x43, 0x4D, 0x35, 0xC1, 0x85, 0xA1, + 0x81, 0x6C, 0xB9, 0x15, 0xEE, 0x4F, 0x7D, 0x89, + 0xED, 0x74, 0x85, 0x90, 0x69, 0xFB, 0x31, 0x6F, + 0x19, 0x86, 0x57, 0x35, 0xBE, 0xD3, 0xCA, 0xA2 + }, + { + 0xDF, 0x66, 0x2D, 0xAC, 0xF1, 0x9B, 0x03, 0xDD, + 0x61, 0x1F, 0x7E, 0x96, 0xC5, 0x59, 0x3F, 0xF8, + 0xB4, 0x26, 0x18, 0x36, 0x6A, 0x62, 0x03, 0x21, + 0xD7, 0xD2, 0x0B, 0x4D, 0x8F, 0xA4, 0x00, 0x1E, + 0x63, 0x24, 0x0D, 0x9B, 0xBB, 0xBE, 0xD6, 0x37, + 0xB5, 0x38, 0xBA, 0xE5, 0x35, 0x7B, 0xE2, 0xC8, + 0x68, 0x12, 0xC2, 0xD0, 0x35, 0xD6, 0xB5, 0x52, + 0xCB, 0x9F, 0x1B, 0x63, 0x65, 0x4C, 0xFC, 0xDA + }, + { + 0x7D, 0x68, 0x68, 0x00, 0xE0, 0xBA, 0xB7, 0x18, + 0x73, 0x05, 0x43, 0x46, 0x4B, 0x6E, 0xE6, 0xA6, + 0x28, 0xAD, 0x25, 0xAE, 0xBC, 0xEF, 0x80, 0x3C, + 0x80, 0xDC, 0xB5, 0xA5, 0xCA, 0x9B, 0xCF, 0x06, + 0xEC, 0x52, 0x77, 0x66, 0x4A, 0x51, 0x51, 0x0F, + 0x27, 0x90, 0x1C, 0xFD, 0x96, 0xC2, 0xAF, 0xEF, + 0x0D, 0x6A, 0x28, 0x17, 0xCB, 0xC9, 0x28, 0xB2, + 0x98, 0xA1, 0x66, 0xCE, 0xD8, 0x42, 0x91, 0xF2 + }, + { + 0x3B, 0x75, 0x56, 0x9B, 0x7C, 0x0A, 0x16, 0xCD, + 0xD0, 0xA5, 0x1A, 0xB8, 0x8D, 0xC6, 0xCD, 0xF4, + 0x63, 0xA6, 0x0D, 0xF0, 0xC9, 0x55, 0xC6, 0x0D, + 0xF1, 0xE1, 0x03, 0x2C, 0xF1, 0x1D, 0xB9, 0x39, + 0xDF, 0x50, 0x5E, 0x71, 0xD3, 0xEF, 0xC3, 0xCD, + 0x4D, 0x46, 0x79, 0x89, 0x4D, 0x15, 0x04, 0x18, + 0x85, 0xBC, 0xF7, 0x53, 0x0D, 0x58, 0x0F, 0x3A, + 0x3E, 0x9F, 0x05, 0x9D, 0xE3, 0x8E, 0xB7, 0x61 + }, + { + 0xF1, 0x68, 0x40, 0xCB, 0x7F, 0x5C, 0x7A, 0xDD, + 0x3B, 0x2F, 0xFD, 0x2A, 0xBB, 0xC1, 0x7B, 0x29, + 0x2D, 0x5F, 0xA1, 0x93, 0xE1, 0xDF, 0x33, 0x50, + 0xF6, 0x78, 0xB4, 0x35, 0x80, 0xCA, 0xFE, 0x70, + 0x4F, 0x26, 0xFD, 0xC4, 0xC7, 0xAF, 0x6E, 0x56, + 0x55, 0x0A, 0x7F, 0x4B, 0x6D, 0x0A, 0x27, 0x8E, + 0x82, 0xB6, 0x0E, 0x78, 0x04, 0xCD, 0xA7, 0x42, + 0x93, 0xC0, 0x72, 0xCD, 0x58, 0x65, 0x5C, 0x0B + }, + { + 0x34, 0x11, 0x84, 0xBB, 0xD2, 0x28, 0xDE, 0x51, + 0x84, 0x2C, 0x94, 0xBB, 0xAF, 0x59, 0x33, 0x6A, + 0xF1, 0x2F, 0xCC, 0x4F, 0xA4, 0x12, 0x46, 0xD9, + 0x8D, 0x91, 0xBE, 0xE1, 0xA8, 0xBF, 0xEF, 0x70, + 0xF4, 0x2F, 0x82, 0xB8, 0x68, 0xAD, 0xCC, 0x25, + 0x79, 0x05, 0xF0, 0x77, 0xF1, 0xE8, 0xD4, 0xB7, + 0xC7, 0xEF, 0x55, 0x00, 0xC6, 0x2C, 0xC5, 0x7E, + 0x94, 0x09, 0x76, 0x4B, 0xF2, 0x85, 0xB3, 0x2F + }, + { + 0x51, 0x29, 0xE5, 0xAF, 0xA1, 0xB7, 0x06, 0x9F, + 0xEC, 0xF1, 0x86, 0x29, 0x62, 0xB0, 0xCA, 0x23, + 0xA8, 0x93, 0x02, 0xB7, 0x86, 0xD1, 0x56, 0x09, + 0x6B, 0x09, 0x89, 0xE7, 0xE9, 0xE3, 0x7D, 0x8E, + 0x50, 0xDB, 0x5B, 0x05, 0x3C, 0x76, 0x39, 0xB0, + 0x4B, 0xDC, 0x20, 0x5C, 0x62, 0x36, 0x62, 0x19, + 0x9C, 0x97, 0xDA, 0x6C, 0xF0, 0x2F, 0xAF, 0x3B, + 0x28, 0x2F, 0x8A, 0xB6, 0xA3, 0x28, 0x71, 0x5A + }, + { + 0x28, 0xD5, 0x8F, 0xD8, 0x4C, 0x6D, 0xE7, 0x16, + 0xFF, 0xD6, 0xEE, 0x82, 0x24, 0xC8, 0xAB, 0x1D, + 0x83, 0x8C, 0xFD, 0x88, 0x7C, 0x0E, 0x74, 0x90, + 0x24, 0x21, 0x88, 0x32, 0x31, 0x5F, 0x95, 0xEA, + 0xB3, 0x7B, 0xFB, 0x40, 0xE7, 0x1B, 0x0C, 0xCC, + 0x11, 0xE2, 0x27, 0x5B, 0x4C, 0x1F, 0x4D, 0xE2, + 0x25, 0x34, 0x82, 0xEB, 0x54, 0x2B, 0x9C, 0xA4, + 0x3F, 0xF8, 0xD2, 0x18, 0xAD, 0xC8, 0x7B, 0x26 + }, + { + 0x62, 0xFD, 0x5A, 0x46, 0xA5, 0x62, 0xCC, 0x63, + 0x96, 0x23, 0x68, 0xA0, 0x07, 0xBA, 0xB1, 0x17, + 0xB6, 0xAA, 0x0F, 0x24, 0xBF, 0x79, 0x31, 0x1A, + 0x61, 0xF1, 0x8F, 0x98, 0x88, 0xE2, 0x11, 0x4C, + 0x8D, 0x97, 0x98, 0xA6, 0x39, 0x1C, 0x09, 0x4F, + 0xCF, 0xDF, 0x49, 0x31, 0x2B, 0x03, 0x24, 0x2C, + 0x71, 0xE6, 0x35, 0x2D, 0x3C, 0x4A, 0x00, 0x12, + 0xA2, 0x36, 0xDC, 0x78, 0x2F, 0xF5, 0x46, 0x1F + }, + { + 0x2C, 0x1A, 0xB3, 0x47, 0xCB, 0x0A, 0xD4, 0x75, + 0xDA, 0x1E, 0x5E, 0x7F, 0xA9, 0xF8, 0xB6, 0xDF, + 0x97, 0x1A, 0xE0, 0x23, 0x65, 0x3B, 0x86, 0x59, + 0xE6, 0x81, 0x47, 0xC7, 0x39, 0xB4, 0x42, 0x80, + 0xBD, 0xF9, 0xC2, 0xC4, 0xE6, 0x96, 0xA3, 0x45, + 0xF9, 0x15, 0x00, 0x2F, 0x5E, 0x66, 0x42, 0x7A, + 0x93, 0x50, 0x12, 0x3C, 0xA9, 0xAB, 0xE2, 0xDF, + 0x23, 0x9D, 0x3A, 0xA5, 0x1F, 0x47, 0xD5, 0x37 + }, + { + 0xAD, 0x4C, 0x7A, 0x4A, 0x4E, 0x79, 0xC9, 0x06, + 0x71, 0xAF, 0x9D, 0xFB, 0x5D, 0x34, 0x3F, 0x38, + 0x92, 0xC2, 0x55, 0x31, 0x03, 0x7C, 0x7F, 0x35, + 0xC8, 0x03, 0xC3, 0x83, 0xB6, 0x0B, 0xE6, 0xC3, + 0x9B, 0xAA, 0x31, 0xE3, 0x3C, 0xC5, 0xD0, 0x8A, + 0x26, 0x6B, 0xC9, 0x67, 0xA2, 0xFB, 0x90, 0x0C, + 0x85, 0x0F, 0xEA, 0x1D, 0x55, 0xAD, 0xD8, 0xAD, + 0xD3, 0xB3, 0xFA, 0xE5, 0xEF, 0x85, 0x28, 0xE7 + }, + { + 0x70, 0x1C, 0xC9, 0xAA, 0xB7, 0xDC, 0x7C, 0x10, + 0xA6, 0x3B, 0x2C, 0x8B, 0xBD, 0xD3, 0x99, 0x44, + 0x48, 0x52, 0xF0, 0x4E, 0xD9, 0x83, 0x38, 0x68, + 0x08, 0x8C, 0xD8, 0x4A, 0x6C, 0x0E, 0xD7, 0xC0, + 0xB1, 0x16, 0x7F, 0x1D, 0x72, 0x4B, 0xD8, 0x46, + 0xA0, 0x21, 0xA8, 0xE8, 0xA3, 0x0A, 0xDE, 0x96, + 0x6E, 0x58, 0xED, 0x46, 0x18, 0x40, 0x64, 0x9F, + 0x26, 0xF7, 0xB1, 0xA4, 0x6A, 0x13, 0x8A, 0x16 + }, + { + 0x39, 0xAC, 0xC0, 0xAC, 0xA4, 0xB1, 0x81, 0x25, + 0xEE, 0x01, 0x7D, 0xBB, 0x0F, 0xA1, 0xC9, 0xFD, + 0x36, 0xFA, 0x86, 0x85, 0x5F, 0xA7, 0xB9, 0x42, + 0x55, 0x44, 0xC5, 0x36, 0xC5, 0x6F, 0x71, 0x92, + 0xBC, 0x42, 0xA9, 0x70, 0x33, 0xB1, 0x11, 0xE1, + 0x2A, 0x3C, 0x1A, 0x2F, 0xEF, 0x62, 0x5F, 0x86, + 0xDD, 0x50, 0xF6, 0xE0, 0x9E, 0x2F, 0xBC, 0x46, + 0x6B, 0x5D, 0x93, 0x84, 0x2F, 0xDB, 0x94, 0xC7 + }, + { + 0xE0, 0x8F, 0xD4, 0x8A, 0x17, 0xBE, 0x58, 0xF2, + 0x29, 0xD7, 0xC8, 0x24, 0xA2, 0xC2, 0x3F, 0x3C, + 0x2C, 0x4C, 0x42, 0x25, 0x24, 0x71, 0xF1, 0xF7, + 0x8D, 0x0E, 0xF4, 0x44, 0xD0, 0x18, 0xC5, 0x9F, + 0x8B, 0x0D, 0x06, 0x1D, 0x8E, 0x30, 0x3E, 0x69, + 0x8F, 0x96, 0x2C, 0xA4, 0x3B, 0x1A, 0x8E, 0x46, + 0xF2, 0x4A, 0x81, 0x91, 0xB3, 0x13, 0xBF, 0xDC, + 0xB8, 0x64, 0x98, 0x3B, 0x6A, 0xDC, 0x49, 0xBF + }, + { + 0x4A, 0x1F, 0x34, 0x2E, 0xC1, 0xF6, 0x6D, 0xAC, + 0xF2, 0x6A, 0xAB, 0xAF, 0x44, 0xE3, 0xC1, 0xEF, + 0x5A, 0x36, 0x9A, 0x62, 0x9A, 0x78, 0xE6, 0xDE, + 0x54, 0x15, 0xDF, 0xF1, 0xC9, 0xAC, 0xC6, 0x6C, + 0xD3, 0x56, 0x1F, 0x59, 0x4D, 0xE8, 0xAC, 0x7C, + 0x8C, 0x84, 0xA8, 0x89, 0x38, 0x2E, 0xB1, 0xEF, + 0x19, 0x63, 0x08, 0xC1, 0x77, 0x7C, 0x4B, 0xA7, + 0x5C, 0xC3, 0xBB, 0xDD, 0x16, 0xA5, 0x18, 0xC6 + }, + { + 0x31, 0xF7, 0x12, 0xC8, 0x88, 0x9D, 0x91, 0x4F, + 0x52, 0xAB, 0xF7, 0x50, 0x5D, 0xAB, 0xEE, 0x88, + 0xDD, 0x6F, 0x9A, 0x92, 0x14, 0x01, 0x71, 0x08, + 0x2E, 0xB1, 0xB7, 0xB1, 0xE6, 0x3D, 0xA0, 0x04, + 0x63, 0x5C, 0xF2, 0xC1, 0x72, 0x46, 0x88, 0xBF, + 0xCD, 0x49, 0x43, 0x63, 0xC2, 0x50, 0x2D, 0x1A, + 0xA8, 0x09, 0x48, 0xDE, 0xCA, 0xAF, 0xD1, 0x11, + 0xBF, 0xD6, 0x68, 0x9E, 0x34, 0xDD, 0x5C, 0x7A + }, + { + 0xB7, 0xA2, 0x07, 0x07, 0x12, 0xC3, 0x24, 0xF0, + 0xF7, 0x95, 0x9F, 0x87, 0xCC, 0xDB, 0x9A, 0xFF, + 0x4F, 0xBB, 0xDC, 0x32, 0x5E, 0x24, 0x95, 0xD3, + 0xEA, 0x89, 0xB7, 0x5A, 0x12, 0x4F, 0x8B, 0xBD, + 0xF2, 0x99, 0xAC, 0xFE, 0xA2, 0x0C, 0x90, 0x9A, + 0xFE, 0xBD, 0xED, 0x38, 0x74, 0x0C, 0xE3, 0x44, + 0x6F, 0xCB, 0x9A, 0x87, 0x87, 0xC8, 0xF1, 0x98, + 0x15, 0xCA, 0x2C, 0xE8, 0x22, 0x56, 0x4F, 0xFF + }, + { + 0x60, 0x57, 0x0E, 0x16, 0x18, 0xCA, 0x54, 0x2C, + 0x64, 0x6B, 0xFB, 0xE5, 0x66, 0x3B, 0xB6, 0x38, + 0x34, 0x6C, 0x07, 0x39, 0x82, 0x32, 0xFD, 0x41, + 0xA8, 0x4C, 0x0D, 0xAA, 0x75, 0xC8, 0xF6, 0x6A, + 0x62, 0x02, 0x68, 0x52, 0x0A, 0xF1, 0x69, 0x1F, + 0xDA, 0x74, 0x6D, 0x78, 0x9A, 0x7D, 0xE7, 0x8A, + 0xF3, 0x5A, 0xE6, 0x76, 0xDD, 0xF3, 0x73, 0xA7, + 0x3F, 0xB1, 0xBC, 0x5D, 0xB8, 0x27, 0xC2, 0x0C + }, + { + 0x97, 0xFE, 0x90, 0x9A, 0x0A, 0x7D, 0x14, 0xCD, + 0x1F, 0x27, 0x38, 0x9E, 0x04, 0xD1, 0xCA, 0xA1, + 0xD1, 0x8B, 0x9E, 0xFF, 0x79, 0x92, 0xBE, 0xCA, + 0xD9, 0x67, 0x7F, 0xA9, 0x87, 0xD0, 0x29, 0xE0, + 0x1C, 0xB3, 0x82, 0xE2, 0x05, 0x14, 0x33, 0x1D, + 0x8D, 0x9B, 0x55, 0x46, 0x23, 0x6E, 0x32, 0xB8, + 0xD8, 0x59, 0xDD, 0xD4, 0x7B, 0xE2, 0x47, 0xA9, + 0x59, 0x5A, 0x5F, 0x24, 0xFA, 0xBE, 0x77, 0xE5 + }, + { + 0x3B, 0xAB, 0x89, 0x74, 0x27, 0x8D, 0x3F, 0x9B, + 0x04, 0x86, 0xCF, 0x3D, 0xA0, 0x2A, 0xCE, 0xE7, + 0x8F, 0x3E, 0x5F, 0x5E, 0x03, 0x9A, 0x60, 0x2D, + 0x56, 0x78, 0x2E, 0x52, 0x51, 0x74, 0x07, 0x15, + 0x65, 0x98, 0x5E, 0x41, 0x42, 0x9B, 0x6F, 0xCC, + 0x1B, 0xA6, 0x3C, 0xAF, 0x2C, 0x74, 0xCF, 0x23, + 0xEE, 0x53, 0xF0, 0xF2, 0x1C, 0x86, 0x3C, 0xBA, + 0x19, 0xE7, 0x5E, 0xD1, 0xED, 0x3B, 0xF8, 0xB4 + }, + { + 0x4E, 0x76, 0x15, 0xA4, 0x47, 0xD8, 0x67, 0x92, + 0xE9, 0x6B, 0x15, 0x39, 0x82, 0x9A, 0x02, 0xFD, + 0xF4, 0x2F, 0x83, 0xEB, 0x75, 0x8B, 0x79, 0xC5, + 0xB2, 0xF7, 0xB2, 0x78, 0x8A, 0x46, 0xA0, 0xC1, + 0x0C, 0x80, 0x75, 0x17, 0x24, 0x8F, 0xC8, 0xEA, + 0x6F, 0x69, 0xCF, 0xA4, 0x12, 0x5B, 0xEB, 0xC9, + 0xE0, 0x19, 0xB8, 0x2F, 0xA0, 0x0F, 0x4C, 0x62, + 0xA7, 0x0C, 0x83, 0x67, 0xF2, 0x2D, 0x94, 0x3B + }, + { + 0x95, 0x90, 0x24, 0x15, 0xA5, 0xD1, 0x50, 0xA5, + 0x39, 0x0E, 0x05, 0xCE, 0x95, 0x80, 0x8F, 0xA0, + 0xA3, 0x26, 0x2B, 0xF6, 0xB8, 0xB0, 0x41, 0x2A, + 0x18, 0xDB, 0x68, 0x68, 0x9C, 0x24, 0xEF, 0x72, + 0x88, 0x8C, 0x4E, 0x3B, 0x3F, 0xA0, 0xE2, 0x20, + 0x39, 0xCC, 0xCF, 0x63, 0x52, 0xEC, 0x64, 0x33, + 0xFC, 0x88, 0x1E, 0x5B, 0x84, 0xA8, 0x79, 0x42, + 0xA4, 0xAA, 0x6B, 0x51, 0x55, 0xAE, 0xAC, 0xAE + }, + { + 0xFF, 0xFC, 0xE1, 0xDD, 0x72, 0xD1, 0xEA, 0x1D, + 0x19, 0x67, 0x0F, 0x4D, 0xF3, 0xE1, 0x2B, 0x8B, + 0xBF, 0xFF, 0x09, 0xA3, 0x0C, 0x90, 0x51, 0xDF, + 0xB0, 0xEC, 0x96, 0x29, 0x34, 0x71, 0xE1, 0x6F, + 0xF1, 0xBE, 0xC5, 0x11, 0xF0, 0x02, 0xDA, 0xB4, + 0x9E, 0xA0, 0xF7, 0x79, 0xB1, 0xD7, 0xBA, 0x8C, + 0x96, 0xF0, 0x85, 0xB5, 0x3E, 0xC8, 0x9E, 0x98, + 0xD5, 0xFA, 0xEE, 0x06, 0x05, 0xEB, 0xAB, 0xF6 + }, + { + 0x14, 0x87, 0x26, 0xEE, 0x22, 0xB5, 0xF7, 0xE2, + 0x59, 0x9C, 0x41, 0x1B, 0x43, 0xAF, 0x8A, 0x5D, + 0x34, 0xC5, 0x1B, 0x47, 0x5B, 0x90, 0x04, 0x0D, + 0xB4, 0xC0, 0xD2, 0x6D, 0xD5, 0xCD, 0x75, 0x24, + 0xCB, 0x4E, 0x42, 0xD1, 0xA7, 0x5E, 0xDC, 0xC2, + 0xC8, 0xA7, 0xF4, 0x79, 0x32, 0x9B, 0x36, 0xA1, + 0x2A, 0xBF, 0x7A, 0x9D, 0xF5, 0xD2, 0xDF, 0x8A, + 0x3A, 0xD9, 0x7B, 0xF7, 0xFF, 0xEB, 0x68, 0x58 + }, + { + 0xDA, 0x31, 0x01, 0x93, 0xF4, 0x39, 0xCA, 0x49, + 0x8A, 0x74, 0x58, 0xA4, 0xFE, 0x7F, 0x53, 0xAE, + 0xDE, 0x1D, 0x23, 0x85, 0xB8, 0x71, 0x12, 0x64, + 0x14, 0x01, 0x85, 0x3F, 0xCD, 0x22, 0xA1, 0x4A, + 0x4E, 0xAA, 0xBD, 0x0C, 0x38, 0x81, 0x58, 0x3E, + 0x05, 0x67, 0xF0, 0xC0, 0xB7, 0xF2, 0x03, 0x6C, + 0x14, 0xEC, 0xDF, 0xE7, 0xAD, 0x5B, 0x3C, 0x54, + 0x72, 0xE7, 0x51, 0xE7, 0xD3, 0xE8, 0xA7, 0xF0 + }, + { + 0x65, 0x43, 0xA7, 0x9B, 0x03, 0xE9, 0xF6, 0x3D, + 0x32, 0x03, 0x14, 0x2D, 0x55, 0x5A, 0xD4, 0xB7, + 0x49, 0x7D, 0xDA, 0xFA, 0xA7, 0xD7, 0x11, 0x0A, + 0xF1, 0x65, 0xA7, 0x8F, 0x69, 0xE8, 0x5B, 0x10, + 0xB3, 0xAF, 0x32, 0x6F, 0x6E, 0x79, 0x42, 0x3E, + 0xF1, 0x2D, 0x6B, 0x74, 0xE1, 0xB6, 0x88, 0xED, + 0x58, 0xD9, 0x86, 0xA9, 0x07, 0xA9, 0x15, 0x89, + 0xD5, 0x3B, 0xA3, 0xB4, 0x08, 0x69, 0x66, 0x78 + }, + { + 0xED, 0x63, 0xA5, 0x35, 0x14, 0xB1, 0x50, 0x04, + 0x6B, 0xF0, 0xF7, 0xC4, 0x8E, 0x52, 0x96, 0xC3, + 0xE3, 0xA3, 0xAE, 0x9A, 0x16, 0x12, 0xBD, 0x69, + 0x62, 0x1A, 0x21, 0x9C, 0x18, 0x4C, 0x48, 0xFF, + 0xE8, 0xD0, 0xE0, 0xA6, 0x66, 0x78, 0xF6, 0x28, + 0xF3, 0x91, 0x5B, 0x98, 0x16, 0xEB, 0x06, 0x39, + 0xF2, 0x8E, 0xD6, 0xEA, 0xF9, 0x87, 0x42, 0x6B, + 0xF8, 0x82, 0x9A, 0x53, 0x12, 0xCF, 0xEC, 0x60 + }, + { + 0x51, 0x3A, 0x48, 0x93, 0xD4, 0x82, 0x61, 0x6E, + 0x33, 0xEF, 0x2D, 0x61, 0x0A, 0xBB, 0xAF, 0xA1, + 0x96, 0x69, 0x54, 0x5C, 0xE8, 0x99, 0x01, 0x0E, + 0x1A, 0x01, 0x09, 0xA9, 0x1F, 0x34, 0x5E, 0x90, + 0x9D, 0x7D, 0xB6, 0x19, 0x13, 0x79, 0xA4, 0x51, + 0x52, 0xF8, 0xE2, 0xCD, 0xDA, 0x54, 0xD5, 0xD4, + 0x7A, 0x89, 0xC6, 0xDC, 0x55, 0x10, 0xF8, 0xE8, + 0x7C, 0x54, 0x30, 0x26, 0xDC, 0xD1, 0x8B, 0x7F + }, + { + 0x73, 0x38, 0x4F, 0x5D, 0xC2, 0x94, 0x65, 0x16, + 0xFE, 0x33, 0xD9, 0x8A, 0x94, 0x2D, 0xDB, 0x82, + 0x37, 0x1C, 0x7B, 0xF2, 0x26, 0xBC, 0x82, 0x6A, + 0xB9, 0xC1, 0x4E, 0x4E, 0xEC, 0x52, 0xB2, 0xCD, + 0x1E, 0x25, 0x20, 0x61, 0xF3, 0x9F, 0xC9, 0x95, + 0xB7, 0xDC, 0x6E, 0xF9, 0xFD, 0xDA, 0xA4, 0x5F, + 0x00, 0xCC, 0x15, 0x89, 0x8B, 0xF2, 0xD7, 0x74, + 0x37, 0x94, 0xC4, 0xB3, 0x0E, 0x64, 0xA5, 0x97 + }, + { + 0xE8, 0x8C, 0xA5, 0xD1, 0x6D, 0x76, 0xEF, 0x4C, + 0xDC, 0x26, 0xFE, 0x95, 0xDF, 0xFB, 0x40, 0x8C, + 0x4E, 0xFA, 0x13, 0xF6, 0xE9, 0x3E, 0x4E, 0xAE, + 0x5D, 0xC4, 0x87, 0xF6, 0x99, 0xD1, 0xF2, 0x5D, + 0x3E, 0xC6, 0xA3, 0xA7, 0xE4, 0x49, 0xFD, 0x75, + 0x91, 0xD4, 0x3D, 0xFF, 0x6F, 0x78, 0xC2, 0x0B, + 0x90, 0xA0, 0x0E, 0x9A, 0x25, 0x85, 0x70, 0x3A, + 0xD1, 0xD8, 0x93, 0x62, 0x23, 0xF3, 0xFF, 0xEE + }, + { + 0x64, 0x6E, 0x73, 0x20, 0x5A, 0x1A, 0xDA, 0xFA, + 0x16, 0x44, 0x6E, 0xE1, 0x20, 0x51, 0x6A, 0x2B, + 0x09, 0x80, 0x00, 0x23, 0xBF, 0x21, 0x31, 0x70, + 0x81, 0x23, 0xBE, 0x17, 0x24, 0x2F, 0x00, 0xC9, + 0xE3, 0xD0, 0x34, 0x78, 0xAC, 0x4C, 0xE3, 0x7A, + 0xA9, 0xD3, 0x3C, 0x28, 0x42, 0x72, 0x22, 0xC6, + 0xB3, 0xDD, 0x71, 0x4E, 0x4D, 0xE3, 0xBE, 0xFE, + 0x73, 0x77, 0x30, 0x8B, 0xB7, 0xCA, 0x51, 0x70 + }, + { + 0x74, 0xDD, 0x50, 0x86, 0xEB, 0x86, 0xE7, 0xBE, + 0x51, 0xAF, 0x3E, 0x5D, 0x58, 0x37, 0x35, 0x17, + 0xE2, 0x88, 0xBD, 0xD2, 0x41, 0x77, 0x3F, 0x30, + 0xCA, 0xF1, 0x63, 0xF6, 0xE6, 0x60, 0x96, 0x42, + 0xF6, 0x10, 0x2D, 0x18, 0x07, 0x74, 0xC0, 0x35, + 0xDE, 0x38, 0xE6, 0x97, 0x59, 0x55, 0x3D, 0xA7, + 0x0C, 0xEE, 0xB3, 0xAB, 0x3B, 0x75, 0x26, 0x70, + 0xBB, 0x77, 0x34, 0x71, 0x53, 0xA9, 0xFA, 0xE6 + }, + { + 0x24, 0xCF, 0x43, 0xA7, 0x4A, 0x65, 0x36, 0xB4, + 0xCA, 0x4A, 0x51, 0xED, 0x13, 0x76, 0x43, 0x44, + 0xD0, 0x72, 0x07, 0x9D, 0x1D, 0xA6, 0xDF, 0x6D, + 0x41, 0xB3, 0xB4, 0x69, 0xBF, 0x38, 0x1C, 0x63, + 0x1C, 0x0D, 0x5C, 0xC6, 0x03, 0xC9, 0x84, 0x6B, + 0x1C, 0x6E, 0x7D, 0x5A, 0x18, 0x5E, 0xDA, 0x72, + 0x26, 0x0E, 0xF3, 0x4D, 0x04, 0x72, 0x26, 0xCE, + 0xDB, 0x77, 0x0C, 0x58, 0x93, 0xA1, 0x38, 0x36 + }, + { + 0xAA, 0x24, 0x5B, 0x77, 0x6F, 0x5A, 0x47, 0x32, + 0x3A, 0x8E, 0xD4, 0xD1, 0x55, 0x7C, 0xB8, 0x16, + 0xB2, 0xB3, 0x7E, 0xF3, 0x69, 0x35, 0xBE, 0x81, + 0xF5, 0x3C, 0xDD, 0x76, 0x29, 0x21, 0xC6, 0xAC, + 0xC0, 0xAA, 0x4C, 0x5C, 0x25, 0xF2, 0x55, 0xB9, + 0xB3, 0xB7, 0x9C, 0x9C, 0x0D, 0x76, 0x5E, 0x7C, + 0x50, 0x49, 0x85, 0x71, 0x5E, 0x6A, 0xA3, 0xC2, + 0x0D, 0x65, 0x1D, 0x82, 0x44, 0x0B, 0x6C, 0x04 + }, + { + 0x66, 0xFD, 0xCC, 0xA4, 0xA6, 0x3D, 0x39, 0xE4, + 0xDB, 0x27, 0xB5, 0xDC, 0xBB, 0x31, 0xC0, 0xBB, + 0xDD, 0x1E, 0xD0, 0x91, 0x7A, 0x0C, 0x00, 0xA7, + 0xE3, 0x09, 0x41, 0x1D, 0xBB, 0x28, 0x2C, 0x3C, + 0x1C, 0xC2, 0x52, 0x5C, 0x6F, 0xB0, 0x41, 0xCF, + 0x8A, 0xA2, 0x99, 0x11, 0x3E, 0x50, 0xB2, 0x64, + 0xFC, 0x8D, 0x49, 0xAA, 0xD8, 0x3D, 0xCB, 0x23, + 0x07, 0xC6, 0x37, 0xCD, 0x37, 0x7E, 0x36, 0xDC + }, + { + 0xCE, 0x6D, 0xFF, 0xD3, 0x97, 0xA1, 0x7C, 0x89, + 0x9B, 0x2A, 0x38, 0x40, 0xEF, 0x2E, 0x69, 0x49, + 0xC5, 0xB1, 0x57, 0xC6, 0xEC, 0xFC, 0xA9, 0x08, + 0xD8, 0x46, 0xD3, 0x6A, 0x7E, 0x78, 0xD8, 0xCC, + 0x0F, 0xBD, 0x4A, 0xD9, 0xC7, 0xFD, 0x2F, 0xAA, + 0x6B, 0x17, 0xDA, 0x84, 0x42, 0x4A, 0x40, 0xBF, + 0xBB, 0xB4, 0x09, 0x16, 0xA8, 0xF9, 0x5D, 0x92, + 0x4F, 0xCB, 0x16, 0x0B, 0xA6, 0xD5, 0x46, 0xF1 + }, + { + 0xE8, 0xFF, 0xA0, 0x28, 0xA0, 0x81, 0x00, 0x1C, + 0xE0, 0x44, 0x2F, 0x58, 0x63, 0x17, 0x0F, 0x1B, + 0x69, 0x5A, 0x81, 0x82, 0xCE, 0x29, 0x93, 0x42, + 0xDB, 0x99, 0x2E, 0x4D, 0xE3, 0xC4, 0x32, 0x4D, + 0x07, 0x9A, 0xF8, 0xF0, 0x4A, 0x7A, 0xB8, 0xB4, + 0x3A, 0x92, 0x63, 0x30, 0x67, 0xBF, 0xAD, 0xFE, + 0xD4, 0xF7, 0x9F, 0xE5, 0xD3, 0x46, 0x02, 0xE9, + 0x5E, 0x1E, 0x45, 0x61, 0x3C, 0x5C, 0xDC, 0xDF + }, + { + 0x40, 0xC4, 0x40, 0x37, 0x75, 0x8A, 0x84, 0x9F, + 0x77, 0xF3, 0x62, 0xDF, 0xC8, 0x1B, 0x4C, 0x4A, + 0x05, 0x6E, 0x83, 0x55, 0xE5, 0xE9, 0xB1, 0xA0, + 0x80, 0x5B, 0x94, 0xEF, 0x9F, 0x98, 0xBC, 0xAD, + 0xEF, 0xCD, 0x44, 0x79, 0x2A, 0xF9, 0xE8, 0x80, + 0x0E, 0x90, 0x91, 0x2F, 0xA2, 0x3D, 0xD6, 0x62, + 0xA9, 0x9B, 0x68, 0xC6, 0x3B, 0x1F, 0xB1, 0xFD, + 0x45, 0xA3, 0xF0, 0xD5, 0xE7, 0x4C, 0x92, 0xCC + }, + { + 0x55, 0xF2, 0x66, 0x13, 0x70, 0xD7, 0x80, 0xB0, + 0x4B, 0x1C, 0xAE, 0x46, 0x63, 0x33, 0x72, 0xD6, + 0xEC, 0xE6, 0x3C, 0xBE, 0xE8, 0xE6, 0xAB, 0xEA, + 0xC2, 0xFF, 0xB5, 0x0F, 0x2E, 0x40, 0xAE, 0x36, + 0x06, 0x8C, 0x3B, 0xDF, 0xBE, 0xE9, 0x77, 0xC9, + 0x19, 0xB1, 0x79, 0x99, 0xD5, 0x01, 0x7E, 0xB1, + 0xB3, 0xB4, 0x47, 0x88, 0x2C, 0xB0, 0xF0, 0xAB, + 0x0E, 0x92, 0xA2, 0x15, 0x9B, 0x88, 0xAB, 0x0F + }, + { + 0x05, 0xE6, 0xF9, 0x70, 0x44, 0xDD, 0x96, 0xF3, + 0x99, 0x3C, 0x4B, 0x79, 0xAD, 0xBB, 0xBC, 0x20, + 0xB8, 0xF0, 0x1D, 0x54, 0xE8, 0x73, 0xEB, 0xE5, + 0xC7, 0x75, 0xF6, 0x61, 0xD2, 0xDC, 0xF1, 0x44, + 0xFB, 0xB6, 0x84, 0x3C, 0xB2, 0xE0, 0x21, 0xAD, + 0x24, 0xC1, 0xA7, 0xBA, 0x12, 0x3F, 0x91, 0xAE, + 0x3D, 0xD4, 0x9E, 0x01, 0x0C, 0x74, 0x3B, 0xD4, + 0xC6, 0x78, 0x53, 0xCC, 0x37, 0x39, 0xAE, 0x64 + }, + { + 0x76, 0x0F, 0x3A, 0x9F, 0x92, 0x4F, 0x10, 0x7A, + 0x87, 0xCF, 0x8F, 0x65, 0x23, 0x58, 0x9B, 0x3C, + 0x7A, 0x50, 0x0E, 0x9B, 0x0C, 0x9A, 0xE4, 0x7F, + 0x86, 0x5B, 0x42, 0x57, 0x65, 0x2E, 0x0D, 0x84, + 0x20, 0xB0, 0xDE, 0x1C, 0x74, 0x1A, 0x73, 0x75, + 0xC1, 0x77, 0x9F, 0xAA, 0xDE, 0xEE, 0xE3, 0xE5, + 0xAE, 0x65, 0x18, 0x68, 0xEE, 0x8B, 0xB6, 0xBF, + 0xDC, 0x2F, 0x25, 0x17, 0x34, 0x9F, 0x91, 0x4D + }, + { + 0xC2, 0xA9, 0xFB, 0xF7, 0x74, 0x02, 0x67, 0xA9, + 0xE2, 0x46, 0x82, 0x46, 0x9C, 0xC5, 0x13, 0x3E, + 0xA1, 0xDA, 0x56, 0x3D, 0x23, 0xBE, 0x50, 0xE2, + 0x32, 0x0B, 0xB1, 0x39, 0x4B, 0xF1, 0xFB, 0xEE, + 0xC2, 0x68, 0x26, 0x35, 0x7E, 0xE6, 0xCC, 0xAA, + 0xA7, 0xBE, 0xE8, 0x27, 0xFE, 0x69, 0xC9, 0x30, + 0x3D, 0x64, 0xE7, 0x01, 0x58, 0xCC, 0xDF, 0xCE, + 0x18, 0x44, 0x95, 0xAA, 0xD9, 0x02, 0xEB, 0x30 + }, + { + 0x15, 0x3D, 0xD9, 0xE4, 0x13, 0x4A, 0x7B, 0x41, + 0xB2, 0x48, 0xEC, 0xD0, 0xDC, 0xC7, 0x50, 0xF7, + 0xFF, 0x47, 0x0C, 0x32, 0x4F, 0x50, 0xFE, 0xDA, + 0x50, 0x51, 0x43, 0x75, 0xB5, 0xC7, 0xF5, 0xAF, + 0x79, 0x20, 0x23, 0x84, 0x80, 0x90, 0x5A, 0x24, + 0xB7, 0xF5, 0x21, 0xC7, 0x14, 0x4F, 0x1C, 0xF1, + 0x4F, 0xC0, 0x37, 0x5E, 0xB8, 0x61, 0x16, 0x8F, + 0xA1, 0xB3, 0x87, 0xB9, 0xDC, 0x45, 0xD0, 0xFA + }, + { + 0x46, 0x2B, 0xD2, 0xE3, 0x36, 0x7D, 0x1F, 0xBE, + 0xF9, 0x97, 0x10, 0x38, 0x50, 0x2B, 0xFE, 0xBE, + 0xDC, 0x77, 0x9C, 0x99, 0x7F, 0x59, 0x62, 0xEA, + 0xF9, 0x1F, 0x36, 0x0B, 0x06, 0x21, 0x6F, 0x42, + 0x25, 0x6F, 0xE6, 0xFD, 0x2D, 0xF6, 0xE8, 0xAB, + 0x49, 0xE8, 0x3E, 0xA5, 0x43, 0x67, 0x15, 0xDE, + 0xCB, 0xF4, 0xA9, 0xC6, 0x04, 0x4F, 0xC9, 0xA6, + 0x3A, 0xAB, 0x51, 0xEC, 0xC5, 0x51, 0x50, 0x67 + }, + { + 0x4B, 0x5F, 0x8E, 0x81, 0x0B, 0xDA, 0x81, 0x49, + 0x40, 0xA5, 0xC7, 0xF4, 0xBD, 0xA8, 0x95, 0xCE, + 0xDC, 0x04, 0x3B, 0x77, 0xF5, 0x41, 0xBB, 0x9F, + 0x2D, 0x16, 0x4C, 0x1D, 0x36, 0x0C, 0x8E, 0xD3, + 0x45, 0xC0, 0x87, 0x78, 0x36, 0xBD, 0xD8, 0xCF, + 0xDD, 0xB7, 0xB5, 0xEB, 0x48, 0x81, 0x50, 0x9E, + 0x1F, 0x24, 0x6B, 0x06, 0x9A, 0x21, 0x2F, 0x02, + 0x16, 0x0C, 0x80, 0xF7, 0x6D, 0xEF, 0x8C, 0x07 + }, + { + 0xD3, 0xCD, 0xEF, 0xA8, 0xA7, 0xEF, 0x11, 0x2F, + 0x3E, 0x63, 0xE4, 0x65, 0xAC, 0x36, 0x32, 0x2D, + 0xE6, 0x27, 0xBC, 0x83, 0x9D, 0xDE, 0x24, 0x22, + 0x7C, 0xE0, 0x9B, 0xB9, 0xA1, 0x0B, 0x1D, 0x2B, + 0x54, 0x2F, 0xE8, 0xFC, 0x72, 0xD1, 0x66, 0xD5, + 0x23, 0xBF, 0xBB, 0x61, 0x9F, 0xA0, 0xF3, 0x19, + 0xB4, 0x1C, 0x00, 0xDE, 0xF0, 0x68, 0xFF, 0x82, + 0xCA, 0x87, 0x6C, 0x7A, 0x05, 0xC3, 0xBE, 0xFB + }, + { + 0x11, 0x32, 0x94, 0x47, 0x9E, 0xAA, 0x5D, 0x0F, + 0x54, 0xE5, 0xDD, 0x4F, 0x8F, 0xF7, 0xB7, 0x31, + 0xD9, 0x6D, 0x92, 0xCF, 0x80, 0x07, 0xBD, 0xAA, + 0x33, 0x92, 0xC2, 0x7E, 0xB9, 0xC7, 0x0A, 0x70, + 0xEE, 0xA6, 0x0E, 0x3A, 0x7C, 0x3D, 0xD9, 0x56, + 0x27, 0x9E, 0xC7, 0x06, 0x47, 0xA0, 0xD9, 0x32, + 0xCC, 0x5F, 0xCD, 0xAC, 0x11, 0xE6, 0x6B, 0x9A, + 0x2F, 0x22, 0x4D, 0xA6, 0xC6, 0xE4, 0xD8, 0xFA + }, + { + 0xEA, 0x76, 0x34, 0xF5, 0xCE, 0x4F, 0xBA, 0x47, + 0xDB, 0x0C, 0x6C, 0x60, 0x1B, 0xB3, 0x07, 0xE8, + 0xF2, 0x46, 0xA7, 0xFF, 0x7C, 0xF2, 0xED, 0xD7, + 0xEE, 0xFA, 0x22, 0xD8, 0xA3, 0x02, 0x82, 0xE7, + 0x28, 0xC8, 0xF9, 0x6C, 0x9E, 0x41, 0xD8, 0x19, + 0xCD, 0x39, 0x0A, 0x85, 0x74, 0x17, 0xAD, 0x98, + 0x68, 0x25, 0xAB, 0x07, 0xD4, 0x2E, 0x00, 0x0E, + 0x53, 0xED, 0xEA, 0xDE, 0xC6, 0x69, 0x96, 0x87 + }, + { + 0x8D, 0xE7, 0xCA, 0xBF, 0x2B, 0x70, 0x37, 0x3B, + 0xFA, 0x7D, 0x5A, 0x83, 0x7A, 0x8C, 0x25, 0xD4, + 0xFE, 0x73, 0x67, 0x56, 0x25, 0x7E, 0x73, 0xEA, + 0x5E, 0x1C, 0x91, 0x3F, 0x8E, 0xE5, 0xEF, 0xD1, + 0x5A, 0x19, 0x3C, 0x99, 0x54, 0x2D, 0x95, 0x03, + 0x19, 0x0E, 0x44, 0xFF, 0x47, 0x31, 0xB0, 0x18, + 0xD5, 0x0C, 0x3F, 0xB3, 0x78, 0xA1, 0x17, 0x0F, + 0x7E, 0x91, 0x1F, 0xD2, 0xC7, 0xCF, 0x5B, 0x45 + }, + { + 0x06, 0xD6, 0x4E, 0x5A, 0x37, 0xFF, 0xEE, 0x13, + 0xDC, 0x6F, 0x6E, 0xEB, 0x02, 0xBD, 0x9F, 0xD5, + 0x90, 0x98, 0xFE, 0xFB, 0x13, 0x3D, 0x88, 0x7F, + 0x56, 0xEC, 0xAA, 0xEC, 0x68, 0xA0, 0x20, 0x05, + 0xFB, 0x86, 0x0D, 0x0B, 0x48, 0x38, 0xF6, 0x37, + 0x44, 0x9A, 0x0B, 0x11, 0xB3, 0x3C, 0x22, 0x1A, + 0x1B, 0x46, 0x47, 0x2B, 0x7F, 0xBA, 0x3A, 0x75, + 0xA8, 0x5B, 0x3E, 0xD0, 0x5A, 0xDE, 0xDD, 0xEB + }, + { + 0xB7, 0x22, 0xAD, 0x52, 0x82, 0xB3, 0x20, 0xDF, + 0x8A, 0x96, 0x3A, 0x4B, 0x90, 0xB8, 0xCD, 0x77, + 0x90, 0x76, 0x59, 0x3E, 0xF9, 0x6E, 0x9C, 0xAB, + 0x74, 0xC9, 0x57, 0xB8, 0x59, 0x31, 0x37, 0x5F, + 0xD3, 0xE9, 0x18, 0x97, 0xAA, 0x0F, 0xE2, 0x19, + 0xC9, 0x35, 0xCF, 0x50, 0x41, 0x9A, 0x5D, 0x2C, + 0xF0, 0x35, 0x1C, 0xBF, 0x3F, 0x52, 0x9E, 0x7D, + 0xC8, 0xB6, 0xF7, 0x2A, 0x8D, 0x2B, 0x8E, 0xBA + }, + { + 0x68, 0x33, 0x9F, 0x63, 0x1E, 0x4D, 0xAD, 0xAF, + 0xBD, 0x4B, 0x3E, 0x2F, 0x7B, 0xDD, 0x0A, 0x6D, + 0xA1, 0xB7, 0xA8, 0x36, 0x7A, 0x32, 0x2F, 0x46, + 0xD9, 0xC4, 0xD7, 0x8B, 0xC5, 0x99, 0xE1, 0x9F, + 0x9A, 0x08, 0x94, 0x98, 0x78, 0x0B, 0xB0, 0x7E, + 0x0F, 0xF7, 0xD7, 0x35, 0xF4, 0xE5, 0xEB, 0xEA, + 0x2E, 0xC4, 0x90, 0x63, 0x63, 0x86, 0xFA, 0x6F, + 0xC9, 0x81, 0xE8, 0x64, 0xBF, 0xF3, 0x69, 0x8D + }, + { + 0xA3, 0xC8, 0x76, 0x57, 0x7B, 0xBD, 0xE5, 0x48, + 0x33, 0x69, 0x8B, 0xAC, 0x05, 0x7A, 0x45, 0xEE, + 0x06, 0x33, 0xAB, 0xDC, 0xEF, 0x9B, 0xCB, 0xB3, + 0x97, 0x19, 0x91, 0xD4, 0x01, 0x11, 0x41, 0x72, + 0xCA, 0x27, 0x1E, 0x59, 0xE7, 0x52, 0x67, 0x0F, + 0x9F, 0x94, 0x1E, 0x5E, 0x71, 0xE7, 0xBB, 0xD1, + 0x87, 0x13, 0xBA, 0xA2, 0x82, 0x97, 0x44, 0x2E, + 0x07, 0xBE, 0x31, 0xB9, 0x1D, 0x1A, 0x0A, 0xD7 + }, + { + 0x19, 0x33, 0x84, 0x47, 0x0E, 0x11, 0x20, 0xF4, + 0x4E, 0xF8, 0xF8, 0x3F, 0xFB, 0xA0, 0x38, 0xC8, + 0x59, 0x00, 0x61, 0xA7, 0x0D, 0xEE, 0x70, 0x77, + 0xEC, 0xEA, 0x68, 0xEA, 0xDC, 0x09, 0x82, 0x62, + 0x0D, 0x3B, 0x32, 0x07, 0x57, 0xD7, 0x6F, 0xD2, + 0x68, 0xD5, 0x89, 0x22, 0x93, 0x72, 0x53, 0x85, + 0xE8, 0xDF, 0x3B, 0x9C, 0xBA, 0x9A, 0xD0, 0x32, + 0xF4, 0xAF, 0x7B, 0x6F, 0x02, 0x85, 0x89, 0x63 + }, + { + 0x4F, 0xD9, 0x6F, 0x4F, 0xBF, 0x70, 0x9E, 0xE2, + 0x83, 0xD5, 0xA3, 0x6D, 0x87, 0x8F, 0x1C, 0xF2, + 0x70, 0xBD, 0x70, 0x1B, 0x9A, 0x31, 0xFC, 0x04, + 0xBA, 0x93, 0xA5, 0x55, 0x2E, 0xB6, 0x8E, 0x3B, + 0x0B, 0x90, 0xC5, 0xA8, 0x7D, 0x5B, 0x97, 0x5E, + 0x6D, 0x2E, 0xDB, 0xB8, 0xAE, 0x08, 0xD4, 0xBB, + 0x8F, 0x02, 0xE6, 0x45, 0xC0, 0x81, 0xC3, 0xC1, + 0x5B, 0xC8, 0x8B, 0x0B, 0x97, 0xDC, 0x71, 0x23 + }, + { + 0xFF, 0x79, 0x75, 0xF3, 0x98, 0xCB, 0x66, 0xAB, + 0x49, 0x22, 0x50, 0xB0, 0x50, 0xF1, 0x63, 0x17, + 0x76, 0x92, 0xFA, 0xD2, 0xB5, 0xF3, 0x6C, 0x50, + 0xB0, 0xB4, 0xAC, 0x16, 0xD6, 0x85, 0xB3, 0x00, + 0x75, 0xCB, 0x89, 0x46, 0x55, 0x3D, 0xD2, 0x57, + 0x04, 0x99, 0xCB, 0x91, 0x6D, 0x2F, 0xFC, 0x97, + 0xA9, 0x3E, 0xD4, 0x23, 0xE1, 0x8F, 0x10, 0xDD, + 0x3D, 0xB0, 0x8A, 0x67, 0x60, 0x3B, 0x0A, 0xEE + }, + { + 0xCE, 0x84, 0x81, 0xA0, 0xE4, 0xFD, 0xBA, 0x85, + 0xD3, 0xFB, 0x5D, 0xFC, 0x0C, 0x41, 0xEF, 0xF0, + 0xBD, 0x2D, 0x0F, 0x8F, 0x53, 0x3B, 0x43, 0x2D, + 0x05, 0x1B, 0x5E, 0x9E, 0x08, 0xC4, 0x04, 0x7C, + 0xF9, 0x13, 0xB4, 0xB1, 0xC0, 0x92, 0x67, 0xE2, + 0xDD, 0x99, 0x6C, 0x74, 0x4E, 0x52, 0x6A, 0x85, + 0x1A, 0x66, 0x1F, 0x02, 0xF4, 0xC0, 0xCF, 0x4D, + 0xE7, 0x4D, 0xD6, 0x2A, 0xF2, 0x10, 0xE6, 0x0C + }, + { + 0x2D, 0xD8, 0x72, 0x0A, 0x3F, 0x22, 0x00, 0x4E, + 0x18, 0x1A, 0xF9, 0x8C, 0x90, 0x69, 0x0D, 0x1A, + 0x13, 0x49, 0xEE, 0xC9, 0x06, 0xE9, 0x01, 0x8B, + 0x16, 0x14, 0x66, 0x68, 0x0C, 0xC2, 0x99, 0xC8, + 0xC4, 0x2D, 0x26, 0xC9, 0x7A, 0xF5, 0x0C, 0xBC, + 0xD2, 0x62, 0xB8, 0xF1, 0xAB, 0x02, 0xBF, 0x84, + 0xE2, 0xE0, 0xF9, 0xE1, 0x08, 0x62, 0x16, 0xD6, + 0xC7, 0x12, 0x1E, 0xEA, 0x72, 0x56, 0x4C, 0xD6 + }, + { + 0x48, 0x98, 0x0E, 0xA7, 0x1B, 0x36, 0xCB, 0x6B, + 0xF3, 0x66, 0x2B, 0xB6, 0xD6, 0xFB, 0x77, 0xF4, + 0x0E, 0x84, 0xC6, 0x0E, 0xC0, 0x9E, 0x1A, 0xF1, + 0x0A, 0x04, 0x8B, 0xE6, 0x9F, 0xF9, 0x5D, 0xF7, + 0x67, 0x14, 0xAD, 0xFF, 0x45, 0x08, 0x5C, 0xE4, + 0x50, 0xE7, 0xCE, 0xA7, 0x11, 0x83, 0xF1, 0x5C, + 0x64, 0xF8, 0xB7, 0xC7, 0x0B, 0x75, 0xFD, 0xED, + 0x1E, 0x79, 0x97, 0x50, 0xAD, 0x77, 0x31, 0x85 + }, + { + 0x7A, 0xDB, 0x17, 0xA2, 0xB3, 0x76, 0x19, 0x80, + 0x3E, 0x26, 0xA8, 0x45, 0xCC, 0xCF, 0xA4, 0xEA, + 0xC9, 0xE9, 0x93, 0xA0, 0xCB, 0x7A, 0xB0, 0x75, + 0x2E, 0x30, 0xCA, 0xB4, 0xFE, 0xD4, 0x22, 0x85, + 0x44, 0x87, 0x51, 0x01, 0x19, 0xE2, 0x1D, 0x71, + 0x12, 0xA0, 0x27, 0x1D, 0x6E, 0xB3, 0xAF, 0xA2, + 0x8B, 0x15, 0xEB, 0x68, 0x38, 0xBB, 0xCD, 0xC9, + 0x7D, 0x97, 0x50, 0x03, 0xEC, 0xDE, 0xD3, 0xCF + }, + { + 0x57, 0xEB, 0x38, 0x13, 0x4C, 0x6A, 0x02, 0xD5, + 0x9B, 0x1C, 0xAF, 0x4A, 0x94, 0x30, 0x36, 0x5A, + 0xC5, 0x43, 0x6E, 0xFA, 0x50, 0x59, 0x07, 0xD0, + 0x0C, 0x47, 0x68, 0x18, 0x39, 0xA8, 0x2D, 0xD6, + 0x7A, 0xA3, 0x3C, 0x2C, 0x9C, 0xFA, 0x67, 0x3C, + 0x16, 0xB6, 0x89, 0xB3, 0x06, 0x0F, 0x3B, 0x58, + 0x35, 0x87, 0xDE, 0x70, 0x8D, 0x1B, 0x3C, 0x8C, + 0x71, 0x77, 0x71, 0xD5, 0xB0, 0x7A, 0x92, 0xDA + }, + { + 0x9B, 0x2A, 0x63, 0x1A, 0x0F, 0x80, 0xB8, 0xB2, + 0xB1, 0x12, 0x4C, 0x0E, 0xCF, 0x71, 0x26, 0x24, + 0xF8, 0x57, 0x02, 0xB8, 0x51, 0x96, 0x6A, 0x67, + 0xDA, 0x42, 0xC5, 0xC1, 0x6F, 0x7F, 0x0C, 0x1B, + 0x72, 0x01, 0x79, 0x04, 0xE5, 0x53, 0x15, 0x89, + 0xDA, 0xEF, 0x0F, 0x41, 0x8E, 0x23, 0x0E, 0x93, + 0xD7, 0x70, 0xCD, 0x19, 0x5A, 0xD9, 0x65, 0x0D, + 0xC7, 0x42, 0x6D, 0xE3, 0xA1, 0xD1, 0x35, 0x5A + }, + { + 0x6D, 0x0A, 0x1F, 0xD7, 0x8D, 0x53, 0x39, 0xF2, + 0x2E, 0x9B, 0xFF, 0xE2, 0xF8, 0xC1, 0x2B, 0xB6, + 0x13, 0x41, 0x6E, 0x0F, 0x89, 0xD1, 0x28, 0xF9, + 0xB7, 0xD8, 0x59, 0x72, 0x2F, 0xAF, 0xBB, 0x8A, + 0xD8, 0x29, 0xE1, 0x7F, 0x2D, 0xF4, 0x02, 0x0A, + 0x7D, 0x47, 0x89, 0x5E, 0x93, 0xE0, 0x97, 0x87, + 0x7B, 0xC8, 0xEE, 0xB1, 0x14, 0xD7, 0x50, 0x31, + 0x2D, 0x0E, 0x81, 0x3B, 0x7D, 0xE6, 0x23, 0x6A + }, + { + 0x83, 0xDA, 0x9A, 0xC3, 0x13, 0xA2, 0x81, 0x30, + 0x6E, 0xDB, 0x75, 0x8A, 0xC0, 0x45, 0x2F, 0xBF, + 0x2C, 0x1E, 0xAD, 0x07, 0x91, 0xB6, 0x6D, 0xF8, + 0x88, 0x6A, 0xCB, 0x05, 0xB5, 0x56, 0x9D, 0xBE, + 0x55, 0xE8, 0xEC, 0xD2, 0x61, 0xC5, 0x7C, 0x68, + 0x18, 0x81, 0x8F, 0xA5, 0xBE, 0xF8, 0xDF, 0xDD, + 0x55, 0xEC, 0x3E, 0xB9, 0x06, 0x3D, 0xF6, 0x60, + 0xB5, 0xB7, 0xC0, 0xFE, 0x9B, 0x41, 0x1C, 0x45 + }, + { + 0x7C, 0x45, 0x00, 0xF1, 0x81, 0x83, 0x7D, 0x53, + 0xA1, 0x86, 0x82, 0xE8, 0x48, 0x4D, 0xA1, 0x91, + 0x48, 0xA7, 0xC9, 0xE5, 0xCA, 0xBF, 0xAF, 0x2C, + 0x38, 0x19, 0xF6, 0x1E, 0xB1, 0x45, 0xFC, 0x53, + 0xE5, 0x0D, 0x6B, 0x41, 0xC8, 0x37, 0xAD, 0x32, + 0x66, 0xF5, 0xAB, 0x75, 0x6F, 0xC7, 0xE4, 0x9B, + 0x01, 0x0D, 0x89, 0x87, 0xB5, 0xDA, 0x0A, 0x9E, + 0x8E, 0xA4, 0x65, 0x0D, 0xB2, 0xA1, 0xC1, 0x5E + }, + { + 0x7E, 0xA0, 0x74, 0xDF, 0x1A, 0x12, 0x20, 0x78, + 0x0F, 0x9D, 0xEE, 0x3E, 0x06, 0x59, 0x5D, 0x86, + 0xA1, 0x88, 0x99, 0x46, 0x5A, 0xD6, 0x40, 0x68, + 0x4B, 0xC6, 0xA2, 0x2E, 0xA4, 0xF3, 0x50, 0xFE, + 0xF8, 0xDC, 0x12, 0xBF, 0x0A, 0xCF, 0x92, 0xBC, + 0x74, 0x66, 0x52, 0xB1, 0xB2, 0xB3, 0x1A, 0x7C, + 0x99, 0x24, 0xEA, 0x72, 0xEC, 0xD0, 0xB5, 0xEF, + 0xEF, 0x3C, 0x93, 0xDD, 0xEC, 0xBE, 0x52, 0x24 + }, + { + 0x9A, 0x80, 0x16, 0x7A, 0xF4, 0x14, 0x81, 0x09, + 0x52, 0xB9, 0x52, 0x1D, 0x73, 0xE4, 0xBE, 0x17, + 0x69, 0x46, 0x6C, 0xF7, 0x8E, 0x31, 0x63, 0x63, + 0xBD, 0xCB, 0x5C, 0x1E, 0xEC, 0xB2, 0x1C, 0x81, + 0x91, 0xC5, 0x4A, 0xE2, 0xF1, 0x20, 0xA0, 0xE6, + 0x85, 0xFA, 0x50, 0x47, 0xA5, 0x36, 0x59, 0xDF, + 0x05, 0x01, 0xB2, 0xB4, 0x0E, 0x3F, 0x97, 0xF9, + 0xB5, 0x7E, 0x9E, 0x6C, 0x19, 0x91, 0x65, 0x19 + }, + { + 0x5A, 0xBC, 0x7D, 0x07, 0x42, 0x06, 0xA2, 0xD3, + 0xD0, 0x28, 0x14, 0x56, 0xFA, 0xCA, 0x0C, 0x72, + 0x8A, 0x71, 0x7D, 0x0F, 0xD8, 0xCC, 0xB8, 0xFB, + 0x6F, 0x53, 0x43, 0x35, 0x6F, 0xE9, 0xA3, 0xA2, + 0xAD, 0x31, 0x56, 0xF4, 0x4C, 0xC7, 0x79, 0xDC, + 0xD0, 0x02, 0x74, 0xA6, 0xBC, 0x40, 0xFF, 0x7D, + 0x95, 0xDF, 0x67, 0x5B, 0xC0, 0x74, 0x4D, 0x22, + 0x60, 0x44, 0x72, 0xF3, 0x3E, 0x39, 0x2C, 0x39 + }, + { + 0x42, 0x5E, 0x49, 0x1D, 0xFF, 0xF2, 0xE8, 0x91, + 0x2F, 0x62, 0x43, 0x3F, 0x2C, 0x0D, 0xDE, 0xFF, + 0x8F, 0x1F, 0x08, 0xFB, 0x05, 0xB6, 0x67, 0xDD, + 0xE7, 0x7F, 0x96, 0x10, 0x84, 0x49, 0x39, 0x64, + 0xC4, 0x7F, 0x74, 0x34, 0x4A, 0xA9, 0x41, 0x2B, + 0xC4, 0xC5, 0x2C, 0x7C, 0x56, 0x47, 0x9C, 0x21, + 0xA2, 0xC1, 0x46, 0x83, 0x9C, 0xA2, 0x8A, 0xC0, + 0x95, 0xEF, 0x6F, 0x9F, 0xDE, 0xD8, 0xAD, 0xFE + }, + { + 0x64, 0xBC, 0xCB, 0x53, 0x95, 0x42, 0x33, 0xE5, + 0x85, 0x05, 0xDB, 0xC3, 0x6F, 0xA8, 0x7D, 0x3F, + 0x6F, 0xBA, 0x56, 0xE5, 0xD5, 0x4C, 0x9D, 0x82, + 0x8F, 0x6C, 0xD4, 0x08, 0xC1, 0xAE, 0x06, 0x2A, + 0x7B, 0x9C, 0x8D, 0x8A, 0xAA, 0x4C, 0xAA, 0x72, + 0xF4, 0x17, 0xCF, 0x7F, 0xC2, 0xB4, 0xEC, 0x0B, + 0xE7, 0x23, 0x60, 0xDE, 0x36, 0x6A, 0xC9, 0x17, + 0xA3, 0x35, 0xE2, 0xE3, 0xF8, 0xA5, 0xAE, 0x37 + }, + { + 0x3C, 0x18, 0x07, 0xE8, 0x50, 0xDE, 0x87, 0x8F, + 0xC9, 0x2D, 0x08, 0xFC, 0x4A, 0x1C, 0xFD, 0x97, + 0x08, 0xFE, 0x73, 0x27, 0x68, 0x84, 0x60, 0x52, + 0x55, 0x3B, 0x75, 0xD0, 0x6B, 0x37, 0xE0, 0xE4, + 0xF2, 0x38, 0xBA, 0xA8, 0x5D, 0x89, 0xC8, 0x30, + 0xDA, 0xB1, 0x95, 0xE1, 0x53, 0xA9, 0x31, 0xB5, + 0x68, 0x3F, 0x55, 0x1D, 0xAC, 0x27, 0x18, 0xB0, + 0x13, 0xC8, 0x5F, 0x36, 0x8F, 0x24, 0x25, 0x5E + }, + { + 0x6A, 0xBF, 0x61, 0xCC, 0x00, 0xA8, 0xAB, 0xE9, + 0xBD, 0x1F, 0x0F, 0xE2, 0x65, 0x3D, 0x66, 0xFC, + 0xA8, 0xC1, 0xDE, 0x44, 0x2E, 0xF4, 0xAF, 0xED, + 0xDD, 0x26, 0x4D, 0x66, 0xCB, 0xFF, 0x7A, 0x59, + 0xBF, 0xCB, 0x47, 0xEE, 0x2B, 0x5B, 0x3D, 0x97, + 0x1E, 0x8A, 0x0C, 0xCB, 0x4E, 0x92, 0x21, 0x9A, + 0xC7, 0x9D, 0xB8, 0xA7, 0x0A, 0x9D, 0x62, 0x1F, + 0x6B, 0x01, 0xBB, 0x0B, 0xF8, 0x92, 0x0C, 0x87 + }, + { + 0x88, 0x6F, 0x9B, 0xB4, 0x94, 0xDD, 0xF9, 0x9F, + 0xAA, 0xDC, 0x81, 0xE2, 0x5E, 0x52, 0x7F, 0x79, + 0x12, 0xBD, 0x14, 0x8C, 0x4E, 0x6E, 0x2D, 0x89, + 0xB5, 0xEA, 0xC9, 0x67, 0xCB, 0xFA, 0xC8, 0x32, + 0xE4, 0x99, 0xFE, 0xAD, 0xD6, 0x68, 0xFD, 0x47, + 0x8F, 0x44, 0xFB, 0x7C, 0x5C, 0xB3, 0x13, 0xEA, + 0x1C, 0xFF, 0x9D, 0x3A, 0xB4, 0x0C, 0xC6, 0xC1, + 0x5A, 0x68, 0xDF, 0xE4, 0x8F, 0xED, 0x04, 0x1E + }, + { + 0xAF, 0x6F, 0xF3, 0x84, 0x0C, 0x53, 0x36, 0x7B, + 0x84, 0xC3, 0x97, 0xDC, 0x6A, 0x12, 0x41, 0xC5, + 0xDB, 0xA4, 0x9E, 0xCF, 0x8F, 0x68, 0x50, 0xC3, + 0x75, 0x32, 0xF7, 0x55, 0x27, 0xD2, 0x5F, 0xFE, + 0x0F, 0xF6, 0xE9, 0xB0, 0xEA, 0xBC, 0x12, 0xA6, + 0x97, 0x68, 0x06, 0xDF, 0xDC, 0xD5, 0xDE, 0xB6, + 0x1B, 0x11, 0xC7, 0xCB, 0x4C, 0xA5, 0xBC, 0xDC, + 0x8C, 0xC1, 0xB1, 0x5A, 0x55, 0x35, 0x7F, 0x6F + }, + { + 0xE7, 0xC1, 0x3E, 0x3E, 0x32, 0x80, 0x21, 0x0E, + 0xBC, 0x9A, 0x61, 0x27, 0x16, 0xEB, 0x91, 0x73, + 0xD1, 0x9A, 0x26, 0x4C, 0xC9, 0x49, 0x1A, 0xD2, + 0x98, 0x7C, 0x1D, 0x51, 0xDB, 0x4B, 0x57, 0x1B, + 0x7A, 0x7C, 0xCE, 0x92, 0x6C, 0xCC, 0xEC, 0xB1, + 0x07, 0x9B, 0x33, 0x3C, 0xB1, 0x6A, 0x24, 0x5D, + 0x38, 0xEA, 0x72, 0x37, 0x2C, 0x95, 0x44, 0x90, + 0x79, 0x33, 0x50, 0x80, 0xBC, 0x9D, 0x6B, 0xAC + }, + { + 0x66, 0xF7, 0xED, 0x48, 0x00, 0x71, 0x20, 0x4A, + 0x0F, 0xD9, 0x1D, 0xA9, 0x6F, 0x76, 0x7D, 0x91, + 0x0B, 0x2C, 0x1C, 0xD5, 0x39, 0xE1, 0xD2, 0xAD, + 0xEB, 0x02, 0x13, 0xD1, 0x68, 0xAF, 0x9A, 0x42, + 0x76, 0x93, 0xBA, 0x98, 0x0D, 0xFF, 0x7F, 0xD2, + 0x99, 0x3C, 0xFB, 0x6D, 0x8A, 0x15, 0x4F, 0x97, + 0x07, 0xAE, 0x3C, 0x8E, 0xBD, 0xDF, 0xB4, 0xCB, + 0x2D, 0x18, 0x70, 0xDF, 0xE8, 0x6C, 0xBB, 0xA1 + }, + { + 0x0E, 0x4F, 0x8C, 0xA8, 0xFF, 0xCA, 0xC0, 0x3C, + 0xF5, 0x64, 0x3C, 0x2D, 0x1B, 0x81, 0xEE, 0x3C, + 0x38, 0x38, 0x64, 0xDB, 0x1D, 0x4F, 0x51, 0x05, + 0x2D, 0xE7, 0x30, 0x22, 0xA3, 0x3B, 0xBF, 0xE9, + 0x4B, 0xA6, 0x6C, 0xB8, 0x51, 0xEE, 0x66, 0x12, + 0xD2, 0xCE, 0x3B, 0x58, 0xEC, 0x8F, 0xCE, 0x72, + 0xCE, 0xD9, 0xF7, 0x44, 0xAC, 0x8C, 0xF1, 0xBE, + 0x9D, 0x92, 0xD9, 0x4C, 0x0A, 0xA5, 0x19, 0x62 + }, + { + 0x2B, 0x04, 0x92, 0x4F, 0x16, 0x8B, 0xBB, 0x50, + 0x32, 0xF9, 0x36, 0x2D, 0x23, 0xF6, 0x67, 0x35, + 0x57, 0xA1, 0xF6, 0x97, 0x2F, 0x48, 0x7E, 0xA8, + 0x13, 0xD2, 0xAE, 0xEB, 0x54, 0x98, 0xF6, 0x92, + 0xB3, 0x2A, 0xB3, 0xA2, 0x17, 0xE4, 0xEA, 0x4E, + 0x27, 0x31, 0xE6, 0xE8, 0xCA, 0xDB, 0x5A, 0x56, + 0xCF, 0xD7, 0xEF, 0x7A, 0x3C, 0x11, 0xBA, 0xEE, + 0x20, 0xF2, 0xDA, 0xB1, 0xF9, 0x80, 0x80, 0x22 + }, + { + 0x43, 0x9B, 0x40, 0x44, 0x91, 0xBE, 0x82, 0x8A, + 0xBC, 0x39, 0x44, 0x27, 0x17, 0xAC, 0x13, 0x6F, + 0xBF, 0x6D, 0x6E, 0xE0, 0xCC, 0x61, 0x6F, 0x3E, + 0xC0, 0xAF, 0xED, 0x08, 0xB1, 0x67, 0xCA, 0xA4, + 0xDD, 0x93, 0x87, 0xBA, 0x5C, 0xC9, 0xB5, 0x67, + 0x97, 0xED, 0xE8, 0x9D, 0x93, 0x09, 0x4A, 0x0D, + 0x65, 0x2D, 0xC9, 0xC5, 0x7C, 0xE3, 0x5A, 0x76, + 0xAD, 0x6F, 0x59, 0xCF, 0xAD, 0x82, 0x68, 0x8A + }, + { + 0xB0, 0xA3, 0x42, 0x1E, 0xCA, 0x4C, 0x8F, 0x92, + 0x3D, 0xD2, 0x9B, 0x5E, 0xFE, 0xA8, 0x3D, 0xF3, + 0x39, 0xCC, 0xBC, 0x0D, 0x0B, 0xA6, 0x9E, 0x1A, + 0x43, 0xC7, 0xB7, 0x95, 0x74, 0xAB, 0x05, 0xB6, + 0xC0, 0x8A, 0x73, 0x0D, 0x45, 0x59, 0xFD, 0x89, + 0x12, 0xAB, 0x9F, 0x8D, 0xF8, 0x26, 0xB4, 0x47, + 0xBC, 0x3C, 0x1B, 0xF0, 0xA8, 0x9D, 0x9F, 0x5A, + 0x05, 0xCF, 0xBE, 0x9F, 0x99, 0x77, 0xD6, 0xBF + }, + { + 0x98, 0xC4, 0x72, 0x3D, 0x00, 0x73, 0xB2, 0x24, + 0x54, 0x89, 0x28, 0x47, 0x62, 0x70, 0xA8, 0xAB, + 0x3E, 0xFD, 0xB3, 0xE8, 0x55, 0xFF, 0x7F, 0x90, + 0xAD, 0x87, 0x59, 0x78, 0x2A, 0x4A, 0x4E, 0xB2, + 0x54, 0x7B, 0x2A, 0x86, 0xF4, 0x6A, 0x48, 0x8C, + 0xCA, 0x87, 0x7D, 0x77, 0xA6, 0xD3, 0x40, 0x2F, + 0x94, 0x20, 0xB0, 0xFD, 0x95, 0x09, 0x1A, 0xBE, + 0xE5, 0x96, 0xB4, 0xC7, 0x9D, 0x4F, 0x34, 0xD9 + }, + { + 0xD4, 0x3D, 0xFF, 0xC6, 0x19, 0x0C, 0xFF, 0xFA, + 0x96, 0xE0, 0xAE, 0x42, 0x64, 0x35, 0x17, 0x3E, + 0xCD, 0xB3, 0xB1, 0xAB, 0x84, 0x40, 0x10, 0xAE, + 0x14, 0xE4, 0x72, 0x19, 0xCD, 0xC4, 0xC0, 0xF3, + 0x38, 0xF5, 0x3F, 0x7D, 0xE5, 0x3F, 0x94, 0xEC, + 0x85, 0x9B, 0x7A, 0xC0, 0x8F, 0xB9, 0xE5, 0x71, + 0xD9, 0x68, 0xBB, 0xDA, 0x95, 0x80, 0x18, 0x31, + 0x85, 0xED, 0x64, 0x82, 0x51, 0xA4, 0xBA, 0x78 + }, + { + 0x72, 0x8F, 0x7B, 0xCA, 0xB8, 0x18, 0x2D, 0xE0, + 0x3E, 0xD4, 0x09, 0xC7, 0x19, 0x7F, 0x19, 0x92, + 0xE5, 0x9F, 0xAE, 0x20, 0x44, 0xC5, 0x9B, 0xDF, + 0xC4, 0x1A, 0x93, 0x22, 0x3B, 0x9A, 0x21, 0xDB, + 0x39, 0xB7, 0x1E, 0xD4, 0x0C, 0x4F, 0xAD, 0x8E, + 0xCD, 0xE0, 0x87, 0xBC, 0x5C, 0xEA, 0x72, 0xC9, + 0xF4, 0x62, 0xC0, 0x3F, 0xD8, 0xB2, 0x39, 0x9D, + 0x45, 0x89, 0xC3, 0x8A, 0x88, 0x90, 0x35, 0x56 + }, + { + 0x05, 0xE7, 0xA7, 0x4F, 0x43, 0xA4, 0x7E, 0x8C, + 0x7A, 0x03, 0x61, 0x1E, 0x26, 0xC9, 0x2A, 0x89, + 0xF5, 0x54, 0x30, 0xE3, 0x8F, 0x1F, 0xFC, 0xCC, + 0x0E, 0xCF, 0x3D, 0x55, 0x87, 0x46, 0x4A, 0xFB, + 0xDA, 0x1D, 0xE0, 0xF5, 0x2D, 0x07, 0xED, 0x22, + 0xD6, 0xF9, 0xC2, 0x6E, 0xE2, 0xB6, 0x3E, 0x5C, + 0x35, 0xC2, 0x94, 0x85, 0x93, 0xD7, 0xE9, 0xD9, + 0x1F, 0xFA, 0x2C, 0x0B, 0xC7, 0x2C, 0xF7, 0x33 + }, + { + 0x60, 0xD7, 0xB1, 0xB7, 0xB1, 0xFE, 0x56, 0xD7, + 0x9D, 0x1C, 0xBA, 0x30, 0xF0, 0xAD, 0x60, 0xF0, + 0x7E, 0x86, 0xA8, 0x9E, 0x65, 0x2F, 0xCE, 0x0D, + 0x12, 0xE3, 0x7B, 0xCD, 0x1C, 0x47, 0xB7, 0x62, + 0x5F, 0xEF, 0x31, 0xE8, 0x27, 0x68, 0x55, 0x93, + 0x9C, 0x04, 0x57, 0x56, 0xCA, 0xBE, 0x9C, 0x02, + 0x0D, 0xA0, 0x56, 0xA0, 0x5D, 0x07, 0xD4, 0xBF, + 0x8F, 0xC8, 0x68, 0xCD, 0xA3, 0x0E, 0x1A, 0x26 + }, + { + 0xF8, 0x48, 0xA7, 0x77, 0x83, 0x03, 0x8B, 0xE8, + 0x16, 0x82, 0x47, 0xE9, 0x35, 0x68, 0x7F, 0x61, + 0x94, 0xF5, 0xD7, 0x71, 0x22, 0x6C, 0x18, 0xD9, + 0xE2, 0xF3, 0x7A, 0x5B, 0xA0, 0x04, 0xAE, 0xEA, + 0x7F, 0x0B, 0xD2, 0xE4, 0x7B, 0x91, 0x78, 0xA4, + 0xFC, 0xEE, 0x58, 0x6F, 0x61, 0x70, 0xA4, 0xF8, + 0x93, 0xCC, 0x31, 0xC2, 0xF7, 0x71, 0x33, 0xF1, + 0xD9, 0x8C, 0xD6, 0xC2, 0x09, 0x85, 0x51, 0x3C + }, + { + 0x28, 0x1B, 0x17, 0xB0, 0xBB, 0xEA, 0x80, 0xEB, + 0x83, 0x96, 0x6A, 0x15, 0x23, 0x9B, 0x27, 0x52, + 0x49, 0x7A, 0x5F, 0xD6, 0x9F, 0x28, 0x79, 0x29, + 0x99, 0xFE, 0x74, 0xDA, 0x11, 0x9D, 0x10, 0x2A, + 0x83, 0x63, 0x35, 0xE6, 0x11, 0xD0, 0x97, 0xDE, + 0xAA, 0x47, 0x4C, 0xDE, 0xB3, 0x39, 0xEF, 0x1E, + 0x44, 0x3E, 0xFF, 0x27, 0x92, 0xB3, 0xF4, 0x56, + 0x5F, 0xB0, 0x62, 0xAA, 0x2C, 0xC9, 0x08, 0xCA + }, + { + 0x40, 0x35, 0xC3, 0x79, 0x6F, 0x29, 0x09, 0xC0, + 0x67, 0x00, 0xD6, 0x9D, 0xCE, 0x87, 0xAD, 0x10, + 0x2F, 0xAF, 0x2F, 0x4F, 0xD5, 0x6F, 0xE7, 0x97, + 0x14, 0x8C, 0xDA, 0x0D, 0xAF, 0xC9, 0x3C, 0x56, + 0x93, 0x9B, 0xAF, 0x03, 0xC9, 0x79, 0xB0, 0x50, + 0xE3, 0x81, 0x6B, 0xD3, 0x13, 0xB8, 0x68, 0x66, + 0xAC, 0x6B, 0x48, 0xD8, 0xA0, 0xD7, 0x75, 0x00, + 0x3E, 0x61, 0x1C, 0x82, 0x4B, 0x01, 0x9A, 0x9E + }, + { + 0x6C, 0xAF, 0xBF, 0x9C, 0x5E, 0xA4, 0x5E, 0xD2, + 0x21, 0x93, 0xA1, 0xA1, 0xC8, 0x8C, 0x2D, 0x92, + 0x7A, 0x9C, 0x09, 0xBA, 0xCD, 0xE2, 0x82, 0xB7, + 0x5E, 0x61, 0x86, 0xC8, 0xF0, 0xFB, 0x85, 0x2B, + 0x73, 0x25, 0xE0, 0xE3, 0xCD, 0x33, 0xCD, 0x94, + 0xC7, 0x67, 0x5A, 0x96, 0x4A, 0x6F, 0x58, 0xE1, + 0x47, 0x6C, 0x3F, 0xCF, 0x6F, 0x78, 0xB0, 0x9D, + 0x99, 0x61, 0xCA, 0x8F, 0x58, 0x5F, 0x42, 0xF0 + }, + { + 0x4A, 0x15, 0xC1, 0x6E, 0x38, 0xBC, 0x6C, 0x8A, + 0x34, 0x89, 0xC7, 0x25, 0x41, 0xEC, 0x72, 0xD2, + 0x1A, 0xCB, 0x80, 0xAF, 0xBF, 0xE2, 0x24, 0xD4, + 0x32, 0xD1, 0xE2, 0x95, 0x79, 0x7E, 0x81, 0x36, + 0x15, 0xE4, 0xA4, 0xCD, 0xCB, 0xB7, 0xC9, 0xA1, + 0xC8, 0x70, 0x27, 0xCA, 0xF8, 0x60, 0xA1, 0xA2, + 0x25, 0x53, 0xB8, 0x60, 0x54, 0xB2, 0x26, 0x2B, + 0xA9, 0x5C, 0x6F, 0xDE, 0xCA, 0xC4, 0x86, 0x30 + }, + { + 0x6B, 0x4A, 0x28, 0x13, 0x7F, 0xD7, 0x46, 0x6D, + 0x8F, 0x8F, 0x98, 0x4F, 0x69, 0xE2, 0xA5, 0x11, + 0xB9, 0x78, 0xA3, 0xF5, 0x35, 0x54, 0x44, 0x93, + 0x72, 0x51, 0x96, 0x72, 0x45, 0x6F, 0xDD, 0xBD, + 0x02, 0x4E, 0x41, 0x45, 0x1B, 0xFF, 0x09, 0x3F, + 0x57, 0xC8, 0x08, 0xCE, 0xC0, 0x07, 0x66, 0x7F, + 0xF9, 0x12, 0xA9, 0xAD, 0x33, 0xC7, 0x6C, 0x9F, + 0x0D, 0xF9, 0xCC, 0xB3, 0x00, 0x16, 0xFA, 0xF0 + }, + { + 0xEA, 0xAF, 0x8B, 0x4D, 0x96, 0x71, 0xBB, 0xF3, + 0xF1, 0x21, 0x9D, 0xB5, 0x18, 0xB7, 0x5D, 0x81, + 0xE6, 0x20, 0x55, 0x39, 0x01, 0xB3, 0xE4, 0xB8, + 0x08, 0x60, 0x60, 0xD6, 0x97, 0x18, 0x0C, 0x5A, + 0xDB, 0x72, 0xE3, 0x50, 0x81, 0x3F, 0x5C, 0xB5, + 0xF5, 0xA3, 0x82, 0x2A, 0xA5, 0xD7, 0x48, 0xAE, + 0x17, 0x77, 0xB3, 0x7C, 0x86, 0x70, 0x4E, 0xAC, + 0x10, 0x4E, 0xEE, 0x70, 0xAF, 0x24, 0x15, 0x6A + }, + { + 0xAF, 0x32, 0x91, 0x37, 0x3E, 0x68, 0x7A, 0x4E, + 0xCF, 0x1D, 0x38, 0x84, 0x13, 0xC9, 0xC0, 0x3C, + 0x9A, 0x12, 0x45, 0xFA, 0x14, 0xCA, 0xEB, 0xE7, + 0xF1, 0x8B, 0x85, 0x0A, 0x24, 0x3C, 0x54, 0x16, + 0x6E, 0xC1, 0xBB, 0xFD, 0xA7, 0xF5, 0xB5, 0x89, + 0xEF, 0x2F, 0x62, 0x0A, 0x31, 0x8B, 0xD5, 0x97, + 0xE5, 0x9C, 0x0F, 0x97, 0x13, 0x63, 0x41, 0x74, + 0xAE, 0x00, 0xD2, 0x1B, 0xEC, 0x09, 0x7D, 0x3F + }, + { + 0x9A, 0x86, 0x62, 0x3E, 0xFC, 0x22, 0x1E, 0xBB, + 0xBD, 0x43, 0x4D, 0x53, 0xCA, 0x58, 0xEC, 0xDC, + 0x71, 0xF0, 0xA0, 0xE4, 0xC2, 0x6A, 0x25, 0x21, + 0x39, 0x42, 0x03, 0x21, 0x25, 0x3E, 0xBC, 0xD2, + 0x3D, 0xCA, 0x89, 0x20, 0x0D, 0x4D, 0x79, 0xA0, + 0xFA, 0x2E, 0x1D, 0xB5, 0x7B, 0xB4, 0xB3, 0x2A, + 0x42, 0x6F, 0x69, 0xCF, 0x08, 0x4A, 0x31, 0x1D, + 0x81, 0x5D, 0x5C, 0x8D, 0xE4, 0x37, 0x3B, 0xBD + }, + { + 0x6C, 0x27, 0x92, 0xE3, 0xB2, 0xB3, 0x41, 0x0D, + 0xAB, 0xC1, 0x70, 0xA6, 0x51, 0xA3, 0x62, 0x32, + 0x42, 0x37, 0xEB, 0xDA, 0x0F, 0xFA, 0x1D, 0xF8, + 0x8B, 0x02, 0x1F, 0x1A, 0x24, 0x3D, 0xAC, 0x41, + 0xE3, 0x74, 0x73, 0xDF, 0xBC, 0xF1, 0xFC, 0x69, + 0x36, 0x24, 0xB4, 0xAD, 0xAC, 0xA4, 0x68, 0x33, + 0x06, 0xB6, 0xFC, 0x32, 0xBC, 0xF7, 0xA6, 0x9D, + 0x7F, 0x49, 0x65, 0xB1, 0x44, 0x5B, 0x30, 0xC4 + }, + { + 0x3A, 0xD5, 0x95, 0x57, 0xD7, 0xFF, 0x5D, 0x89, + 0xBA, 0x70, 0x5E, 0xBA, 0xD8, 0x12, 0x71, 0xF2, + 0x4B, 0x42, 0x93, 0x14, 0x03, 0xFC, 0x2F, 0xA6, + 0xC5, 0x4A, 0xFA, 0x8F, 0x77, 0xBC, 0xFA, 0xB7, + 0xA1, 0x56, 0x50, 0xAC, 0xFB, 0x89, 0xC3, 0x92, + 0x62, 0xDF, 0x5E, 0x74, 0x92, 0x74, 0xCE, 0x6E, + 0x14, 0xF7, 0xEA, 0xBC, 0xDC, 0x05, 0x1F, 0x59, + 0x32, 0x1E, 0x2A, 0x1D, 0xFA, 0xF6, 0x66, 0x2A + }, + { + 0x53, 0x8C, 0xAA, 0x94, 0x80, 0xF3, 0xFC, 0xF1, + 0xAD, 0xF4, 0x2D, 0x2B, 0x0F, 0x78, 0x6B, 0x5F, + 0x3F, 0x6E, 0x98, 0x19, 0x11, 0xE7, 0x05, 0xD1, + 0xB8, 0xC8, 0xD8, 0xA8, 0x1B, 0x17, 0x90, 0x43, + 0x0B, 0x77, 0x20, 0xED, 0x39, 0x9D, 0x63, 0xDB, + 0xE0, 0xCC, 0x07, 0x4D, 0x95, 0x47, 0xFB, 0x7A, + 0x0C, 0xC7, 0xAB, 0x04, 0xE3, 0x99, 0x13, 0xD8, + 0x73, 0xE0, 0x12, 0xFD, 0x2E, 0xCA, 0x69, 0x4B + }, + { + 0x61, 0x01, 0x34, 0x8E, 0x7E, 0xA6, 0xB5, 0xF3, + 0x54, 0xA0, 0x7B, 0x0F, 0xD1, 0xF5, 0xD5, 0xA0, + 0x7B, 0x26, 0xD6, 0x58, 0xD3, 0x1D, 0x0B, 0x63, + 0xC3, 0x92, 0x39, 0x06, 0x61, 0xAE, 0x56, 0x28, + 0x51, 0x0D, 0xE9, 0xA1, 0x62, 0xA4, 0x79, 0xEF, + 0x83, 0x8E, 0xE3, 0xFC, 0x27, 0xC9, 0x7C, 0xD8, + 0x6C, 0xFC, 0xD9, 0x8D, 0x33, 0xAD, 0x85, 0x86, + 0x96, 0x6C, 0x07, 0x87, 0x12, 0x9C, 0xC4, 0xAE + }, + { + 0x40, 0x93, 0x07, 0xAA, 0x56, 0xEA, 0x05, 0x60, + 0xCC, 0x11, 0x85, 0x81, 0x30, 0x4E, 0x5E, 0x30, + 0xA0, 0xB4, 0x96, 0x85, 0xD9, 0xE7, 0x28, 0xC3, + 0xE8, 0x0D, 0xC1, 0x90, 0x5A, 0x34, 0x35, 0x4B, + 0xC5, 0xC4, 0x27, 0xF7, 0x56, 0x9B, 0x46, 0x50, + 0x8C, 0x5F, 0x0D, 0x52, 0x56, 0x55, 0x5B, 0x7E, + 0x4B, 0x36, 0x60, 0xDB, 0x65, 0x01, 0x1A, 0xB2, + 0x49, 0x4B, 0x4A, 0x43, 0xC3, 0xA6, 0x7E, 0x5A + }, + { + 0xA9, 0xC0, 0x0D, 0x77, 0x10, 0x69, 0x5A, 0xAE, + 0x43, 0xCB, 0x4E, 0x7D, 0x01, 0xA3, 0xDB, 0x45, + 0x93, 0x78, 0x65, 0xBF, 0x7F, 0xA7, 0xCA, 0x57, + 0x14, 0x1C, 0xD8, 0xFB, 0x15, 0xC6, 0xE4, 0x5F, + 0x1C, 0xE4, 0x90, 0x6E, 0x61, 0x76, 0x5F, 0xD4, + 0x15, 0xB9, 0x34, 0x12, 0x9E, 0xD8, 0x3C, 0xE6, + 0x33, 0x4F, 0xF9, 0x32, 0x12, 0xD3, 0x30, 0xB5, + 0x63, 0xC7, 0x66, 0x3A, 0x55, 0xD7, 0x60, 0xE4 + }, + { + 0xEA, 0xA3, 0x11, 0xE8, 0x81, 0x5D, 0x55, 0x2F, + 0x53, 0x1C, 0xF8, 0xBE, 0x7D, 0x60, 0xC2, 0xDD, + 0xBF, 0x76, 0x0A, 0x8D, 0xC2, 0x2E, 0x6C, 0xFB, + 0x5B, 0xC3, 0xF4, 0xBC, 0xEB, 0x64, 0xC1, 0xFC, + 0x37, 0xB6, 0x36, 0xC8, 0xBD, 0x32, 0xEB, 0xFA, + 0xA7, 0x07, 0x91, 0x49, 0x00, 0xD9, 0x67, 0xC4, + 0x88, 0x20, 0x18, 0x2B, 0xE0, 0x5F, 0xBE, 0xF8, + 0x04, 0x18, 0x94, 0x66, 0xD3, 0x09, 0x4D, 0x7D + }, + { + 0x9A, 0xEC, 0x78, 0xAE, 0xE8, 0x18, 0x19, 0x9C, + 0x4D, 0x04, 0x63, 0xB2, 0x65, 0x51, 0xE0, 0x36, + 0xE1, 0x76, 0xFF, 0x5A, 0xE1, 0x8C, 0x11, 0xB4, + 0xBD, 0x93, 0x68, 0x59, 0xF6, 0x99, 0xCE, 0x6F, + 0x7F, 0x81, 0x9E, 0xE6, 0xAA, 0x32, 0x6F, 0x3E, + 0x37, 0x9D, 0x79, 0xB2, 0x0D, 0x43, 0x79, 0xFE, + 0x0A, 0x02, 0xCE, 0xE5, 0x15, 0xE1, 0xC0, 0x87, + 0x54, 0xEE, 0x78, 0xB2, 0x3C, 0x9B, 0xC9, 0x4E + }, + { + 0x4B, 0xE3, 0x1B, 0xAE, 0x66, 0x36, 0xB9, 0x20, + 0x1C, 0x33, 0xA8, 0xA0, 0x80, 0xA7, 0xC7, 0x3B, + 0x16, 0xB7, 0xA6, 0xB8, 0x90, 0x64, 0x16, 0x7D, + 0xCF, 0xA0, 0x76, 0x1A, 0x5B, 0xED, 0x3C, 0x6E, + 0x0E, 0xB2, 0x87, 0x75, 0x60, 0x68, 0xC0, 0x82, + 0x79, 0x86, 0xBB, 0x6F, 0xC4, 0x21, 0xCE, 0x56, + 0x9C, 0xA2, 0x99, 0x78, 0x21, 0x3F, 0x8F, 0x42, + 0x22, 0x74, 0x19, 0x3C, 0x9A, 0x0A, 0xA5, 0x3C + }, + { + 0x4F, 0x42, 0xD3, 0x4E, 0x3A, 0x87, 0xA8, 0x25, + 0x67, 0x7B, 0xEC, 0xC9, 0xC7, 0xD2, 0xAB, 0x7D, + 0x8F, 0x50, 0x6A, 0xE2, 0x06, 0x73, 0x9C, 0x0A, + 0x8A, 0x76, 0x11, 0xD8, 0x46, 0x3F, 0x88, 0x29, + 0xB5, 0xF8, 0x24, 0xC0, 0x9E, 0x2C, 0xAA, 0x0E, + 0xDA, 0x23, 0x20, 0x8C, 0xF8, 0x44, 0x3F, 0x9F, + 0x75, 0x62, 0x6A, 0xD6, 0x8F, 0x37, 0x6B, 0xC7, + 0x81, 0x01, 0x90, 0xE0, 0xE0, 0x69, 0x31, 0x07 + }, + { + 0xCF, 0x51, 0x3E, 0x92, 0x44, 0x4A, 0x4D, 0x51, + 0x1B, 0x7A, 0x05, 0xB5, 0x00, 0x18, 0xF4, 0x91, + 0xE2, 0x23, 0x4A, 0x06, 0x3C, 0x13, 0x9F, 0x18, + 0xB2, 0x62, 0x46, 0xF5, 0x6B, 0xE4, 0x44, 0x11, + 0x52, 0xD4, 0x24, 0x3A, 0x5A, 0x72, 0x54, 0xDA, + 0xA7, 0x83, 0x76, 0x5B, 0x90, 0xB9, 0x99, 0x25, + 0x38, 0x90, 0x9C, 0x8F, 0x16, 0xF8, 0x39, 0x4C, + 0xD8, 0x06, 0xE2, 0xF4, 0x1B, 0x2D, 0x52, 0x67 + }, + { + 0xF6, 0x78, 0xE5, 0x54, 0x7F, 0x24, 0xDF, 0x58, + 0xD5, 0x6C, 0x2D, 0x1B, 0x11, 0x0C, 0x53, 0x67, + 0x5E, 0x6D, 0x9A, 0x78, 0xC7, 0xC5, 0x4C, 0xA3, + 0xC9, 0x16, 0x0E, 0xD8, 0x32, 0x28, 0xE9, 0x8C, + 0xF1, 0x08, 0x37, 0x1B, 0x61, 0x6E, 0xA6, 0x2E, + 0xD6, 0xEC, 0xAC, 0xC6, 0x05, 0xF2, 0xF4, 0xF6, + 0x47, 0xF7, 0x94, 0x10, 0xA2, 0x91, 0xB8, 0x03, + 0x61, 0x36, 0xF3, 0x6A, 0x29, 0x0B, 0x11, 0xAE + }, + { + 0x72, 0x63, 0xF5, 0xBD, 0x52, 0xB2, 0x42, 0xB3, + 0xCB, 0x6B, 0xB8, 0x04, 0xCF, 0xCD, 0x83, 0xC6, + 0xAA, 0x35, 0x65, 0xEB, 0xC5, 0x0F, 0x2D, 0x00, + 0x53, 0xD6, 0x83, 0x9B, 0x36, 0xA5, 0xC5, 0x9D, + 0xEE, 0x3C, 0x81, 0xBE, 0x71, 0x85, 0xD3, 0x6E, + 0x78, 0x39, 0x78, 0xFF, 0xF5, 0x7F, 0x33, 0xE7, + 0x7F, 0x77, 0x1D, 0x45, 0x5F, 0x40, 0x69, 0x2B, + 0x63, 0x0A, 0x6A, 0x76, 0x17, 0xFF, 0xA1, 0xB6 + }, + { + 0xCB, 0x96, 0x10, 0x2D, 0x27, 0x7F, 0x30, 0x0F, + 0x5D, 0x91, 0xCC, 0x66, 0x41, 0xCC, 0x40, 0x8E, + 0x52, 0x8C, 0x62, 0x1A, 0x74, 0xF9, 0x8F, 0x20, + 0xA1, 0x15, 0x51, 0x67, 0x59, 0x91, 0x2B, 0xA5, + 0xD3, 0x57, 0x74, 0x83, 0x77, 0x4C, 0x60, 0x0F, + 0xEE, 0xC1, 0x7A, 0x5D, 0xEC, 0xAE, 0x0E, 0x9D, + 0xC8, 0x1E, 0x32, 0x6B, 0xBA, 0xCE, 0x0A, 0xCC, + 0xA1, 0x44, 0xC7, 0xB1, 0x91, 0x0D, 0xD5, 0x53 + }, + { + 0xA9, 0xBE, 0x7E, 0x3D, 0xDA, 0x9D, 0xAC, 0xBD, + 0xB7, 0x07, 0x50, 0x1D, 0xD1, 0x37, 0x54, 0x4A, + 0x30, 0x95, 0xD0, 0xB1, 0x40, 0x4E, 0x0A, 0xC2, + 0x23, 0xA7, 0x21, 0x38, 0x13, 0x6D, 0x9E, 0x59, + 0x34, 0x65, 0x80, 0x58, 0x29, 0xD8, 0x6F, 0x01, + 0xD8, 0x83, 0x48, 0xE7, 0xE1, 0xA7, 0x7D, 0xDF, + 0x52, 0x23, 0xC9, 0x7D, 0x06, 0x48, 0xDD, 0x55, + 0x5D, 0x77, 0x3A, 0xF0, 0x41, 0xF7, 0x0E, 0x99 + }, + { + 0xA9, 0x8D, 0xC2, 0x83, 0x47, 0xCE, 0x13, 0xFC, + 0x39, 0x37, 0x5B, 0x5E, 0x88, 0xFA, 0x97, 0x10, + 0xB3, 0x5C, 0xF2, 0xC6, 0x0F, 0xDA, 0x95, 0xC2, + 0x31, 0x35, 0xBB, 0x76, 0xA9, 0xC0, 0x55, 0x8E, + 0x74, 0xE0, 0xD9, 0x1B, 0xED, 0x51, 0x97, 0x09, + 0xB2, 0xCC, 0xC3, 0x75, 0x92, 0x6B, 0x7F, 0x7A, + 0x51, 0x51, 0x96, 0x81, 0x55, 0x67, 0x7C, 0x00, + 0x82, 0xAB, 0xDA, 0xE0, 0x3A, 0x0D, 0xCD, 0xD6 + }, + { + 0x75, 0x69, 0x52, 0x60, 0x13, 0x17, 0x2E, 0xA9, + 0xB6, 0x38, 0x75, 0xC1, 0xB5, 0x87, 0xD4, 0xA3, + 0xDF, 0x9D, 0x7E, 0xB5, 0xB9, 0xDB, 0x63, 0x9D, + 0xDF, 0x5F, 0xD8, 0xE2, 0x70, 0x22, 0xBF, 0x35, + 0x54, 0xE9, 0xFA, 0x5F, 0x27, 0xC8, 0xF1, 0x2B, + 0x0D, 0x0F, 0x80, 0x8E, 0x4A, 0xDB, 0x03, 0xFD, + 0x95, 0x73, 0x4D, 0x94, 0x23, 0x26, 0xA0, 0x9D, + 0x22, 0xC2, 0x6A, 0xFA, 0xD9, 0xD6, 0xFC, 0xDB + }, + { + 0x3E, 0xC2, 0x26, 0x09, 0x9E, 0x97, 0xC3, 0x9C, + 0xCA, 0x1B, 0xB4, 0x3D, 0x0A, 0x49, 0x9A, 0x2C, + 0x25, 0x3D, 0x54, 0xF9, 0x50, 0x52, 0xFE, 0x87, + 0x82, 0xE3, 0x60, 0x96, 0xAF, 0x98, 0xE8, 0xEE, + 0x26, 0xEF, 0x72, 0x86, 0x65, 0xA9, 0x9E, 0x63, + 0x59, 0x85, 0x32, 0x1B, 0xA2, 0x4A, 0x86, 0xE6, + 0x1F, 0xB5, 0xF9, 0xC8, 0x33, 0x15, 0x49, 0x7C, + 0x13, 0xEC, 0xD6, 0xC5, 0xA9, 0x5C, 0x6E, 0x29 + }, + { + 0x0B, 0x99, 0x26, 0x15, 0x5A, 0x9C, 0x8B, 0x8B, + 0x74, 0x7E, 0xE3, 0xB9, 0x37, 0x08, 0x1E, 0x38, + 0x92, 0x61, 0x0A, 0x85, 0xD2, 0x64, 0xE9, 0x91, + 0xD1, 0xC5, 0x4B, 0x59, 0x6A, 0x1C, 0x67, 0xF4, + 0x9C, 0x11, 0x53, 0x89, 0x55, 0xB8, 0x4C, 0x61, + 0xEF, 0xBB, 0xAA, 0xDB, 0x28, 0xB8, 0x8D, 0xB4, + 0x3C, 0x5D, 0x82, 0xE9, 0xE5, 0xFC, 0xDB, 0x30, + 0x07, 0x7F, 0xC2, 0xBD, 0x55, 0x4C, 0xBF, 0x70 + }, + { + 0x5C, 0x3B, 0x21, 0xAF, 0xEA, 0xEC, 0x6A, 0x0B, + 0x05, 0x5B, 0x22, 0x2E, 0x19, 0xCE, 0x6A, 0x82, + 0x52, 0x90, 0x78, 0xE6, 0xEC, 0xA8, 0x5A, 0x01, + 0x96, 0x8E, 0x80, 0x1D, 0xA0, 0x71, 0x9B, 0xDD, + 0xFA, 0x7A, 0x92, 0x9A, 0xB4, 0x53, 0x15, 0x22, + 0x25, 0x55, 0xE7, 0xBA, 0x82, 0xAE, 0x7E, 0x9A, + 0x86, 0xE5, 0x91, 0x83, 0x77, 0x15, 0x91, 0xEF, + 0x4F, 0x33, 0xF2, 0x55, 0x80, 0x17, 0x2C, 0x24 + }, + { + 0x99, 0x3E, 0x46, 0x68, 0x01, 0xCD, 0x7E, 0x63, + 0xC5, 0x38, 0x02, 0xB3, 0xB7, 0xB3, 0x14, 0x9D, + 0x49, 0xC2, 0x35, 0x18, 0x6A, 0xE3, 0x5B, 0xE7, + 0xCE, 0x54, 0xC4, 0x7A, 0xE3, 0x9F, 0xE3, 0x58, + 0xA5, 0x5A, 0x04, 0xA4, 0xE6, 0x4D, 0x3D, 0x38, + 0x91, 0x6D, 0x57, 0x5B, 0xCB, 0xD8, 0xA3, 0xCA, + 0x6C, 0x88, 0xA8, 0x9F, 0xE1, 0x21, 0xFB, 0x73, + 0xAA, 0xB6, 0x74, 0xCC, 0xAD, 0xCA, 0x09, 0x1A + }, + { + 0x9F, 0xFE, 0x78, 0xC5, 0xB6, 0x03, 0xAD, 0xE7, + 0xDA, 0x26, 0x32, 0xE6, 0x3D, 0x00, 0x6F, 0x45, + 0xEA, 0xDF, 0xDE, 0x21, 0x41, 0x38, 0x4E, 0x72, + 0x6E, 0x19, 0x46, 0xFC, 0xF1, 0x6C, 0x4D, 0xC8, + 0x82, 0x09, 0xD2, 0x70, 0x72, 0x38, 0xA4, 0xF6, + 0x8D, 0x84, 0x1D, 0xB8, 0x87, 0x9A, 0xA0, 0x75, + 0x1C, 0x43, 0x4C, 0x91, 0xAE, 0x50, 0x9B, 0xF0, + 0x80, 0x8F, 0x86, 0x5F, 0x4F, 0x5D, 0xAD, 0x4F + }, + { + 0x14, 0xEF, 0xBE, 0x44, 0xD7, 0xE9, 0x6F, 0xA4, + 0x99, 0x37, 0x77, 0x1E, 0xD8, 0xC8, 0xE3, 0xF1, + 0xCD, 0x76, 0x9C, 0xC9, 0x53, 0xA1, 0x79, 0xFC, + 0x4F, 0x3C, 0x67, 0xEA, 0xF0, 0x23, 0x68, 0xA2, + 0xAB, 0x2B, 0x29, 0x41, 0x42, 0xF7, 0xC0, 0x7B, + 0xAE, 0x4C, 0x40, 0xC3, 0xDF, 0x73, 0xEB, 0x6F, + 0x9C, 0x3F, 0x0F, 0xBE, 0x75, 0x66, 0xFE, 0xCB, + 0xD5, 0x7A, 0x09, 0x2B, 0xBF, 0xD7, 0x2A, 0x5A + }, + { + 0x87, 0x9C, 0xCE, 0x40, 0x04, 0xF3, 0xA6, 0x91, + 0x3B, 0x10, 0x89, 0xE4, 0x26, 0x99, 0xD4, 0xF8, + 0x6D, 0x44, 0x9C, 0xFA, 0x5A, 0xCB, 0x35, 0x3C, + 0xD3, 0x26, 0x9E, 0x49, 0x19, 0xD2, 0xAD, 0xE5, + 0x8D, 0x7E, 0xF8, 0x2F, 0x4E, 0x21, 0x6E, 0x06, + 0x6B, 0xAD, 0xA3, 0x6B, 0xC9, 0x80, 0x2B, 0x76, + 0x6C, 0x56, 0xA5, 0x16, 0xE0, 0x90, 0x4C, 0x9F, + 0xB5, 0x73, 0x1E, 0x8C, 0x80, 0x68, 0x4B, 0xEF + }, + { + 0x46, 0xE0, 0x31, 0xC3, 0x78, 0x91, 0x7C, 0x50, + 0x9C, 0x2A, 0xD6, 0x88, 0x4B, 0x8C, 0x7E, 0x45, + 0x95, 0xB2, 0x87, 0xB2, 0x83, 0x03, 0x82, 0x48, + 0x0E, 0x1E, 0xF7, 0xCC, 0x21, 0xE7, 0x57, 0x23, + 0xB8, 0xB6, 0xF7, 0xD1, 0x42, 0x00, 0xC9, 0xB6, + 0x4F, 0x7D, 0xF2, 0x77, 0xCC, 0xF3, 0x8F, 0x26, + 0x94, 0x1E, 0x43, 0xD1, 0x6D, 0xB8, 0xB0, 0x0B, + 0xE4, 0x86, 0x98, 0xBA, 0x0D, 0x1A, 0xE8, 0xD2 + }, + { + 0xFD, 0x54, 0x5C, 0xF9, 0x4E, 0xA7, 0xFE, 0x38, + 0xA4, 0xAD, 0xBB, 0xC5, 0x62, 0xCB, 0x72, 0xE6, + 0x9D, 0x73, 0x46, 0xCB, 0xA0, 0x0F, 0x49, 0x01, + 0xD7, 0x22, 0x18, 0xDF, 0x04, 0x08, 0xB7, 0xB2, + 0x20, 0x4D, 0x1F, 0x44, 0x4F, 0xA1, 0xBD, 0xDD, + 0x4B, 0x7D, 0x96, 0xB1, 0x8C, 0xC8, 0xBD, 0xC1, + 0x5F, 0x5B, 0x05, 0x58, 0x7D, 0x58, 0xAF, 0xCA, + 0x27, 0x56, 0xE2, 0x6B, 0xB9, 0x08, 0x04, 0x54 + }, + { + 0x3F, 0x55, 0x74, 0x8E, 0x30, 0xC0, 0x39, 0xE3, + 0xC3, 0xA7, 0x51, 0x8C, 0x5A, 0x1A, 0x80, 0xA1, + 0xB4, 0xC0, 0x79, 0x10, 0xCC, 0xE5, 0xDA, 0x66, + 0x9A, 0xB1, 0x02, 0xC0, 0xF3, 0x03, 0x9D, 0x77, + 0xFD, 0xF1, 0xC7, 0xE0, 0x20, 0x24, 0x40, 0x8F, + 0xEA, 0x0F, 0x06, 0x17, 0x35, 0x5A, 0xCE, 0x86, + 0x6C, 0x9A, 0xAD, 0xDC, 0xA3, 0x5C, 0x0D, 0x09, + 0xAE, 0x01, 0xAC, 0xF6, 0x20, 0x0D, 0x34, 0x89 + }, + { + 0x19, 0x38, 0xFD, 0x06, 0x59, 0x83, 0x58, 0x01, + 0x49, 0x04, 0x5F, 0x77, 0x59, 0x85, 0xE6, 0x31, + 0xAC, 0xFE, 0xF6, 0x5C, 0x18, 0x4E, 0x51, 0x49, + 0x26, 0x34, 0x84, 0xE9, 0x7D, 0x6A, 0x44, 0x10, + 0xAC, 0x04, 0x84, 0xA8, 0x7D, 0xE4, 0x9D, 0x06, + 0x67, 0x11, 0x96, 0x7A, 0x0C, 0xA4, 0xF6, 0xDA, + 0xBE, 0x05, 0xFC, 0x17, 0xDE, 0x73, 0x1F, 0xDF, + 0x0E, 0x3B, 0xCE, 0xFC, 0xA8, 0xF6, 0x54, 0xB7 + }, + { + 0xC9, 0x71, 0xE4, 0x2B, 0xF6, 0xCF, 0x32, 0x9C, + 0x6F, 0xD6, 0x72, 0xED, 0x1B, 0x3E, 0xF9, 0x96, + 0xDC, 0xB6, 0xF8, 0x17, 0x14, 0x3B, 0xA1, 0x13, + 0xC7, 0xF9, 0x58, 0x6F, 0xA5, 0x88, 0x85, 0x5F, + 0xEF, 0x13, 0xED, 0x7C, 0x1D, 0xE8, 0xBD, 0xCA, + 0xFD, 0x9C, 0xF9, 0x05, 0xDA, 0xCC, 0x5E, 0x59, + 0xE3, 0x31, 0x04, 0x9E, 0x74, 0xF7, 0x5E, 0x34, + 0xE3, 0x92, 0xDC, 0xC5, 0x3B, 0x8A, 0xDE, 0x87 + }, + { + 0x91, 0x3A, 0x0D, 0xAA, 0xE6, 0xC7, 0xB8, 0xD8, + 0x5E, 0x8D, 0x68, 0xFB, 0x28, 0xEE, 0x42, 0x3A, + 0x10, 0x06, 0xEC, 0x92, 0xDA, 0xFD, 0xF5, 0x08, + 0xC5, 0x15, 0xAB, 0x7D, 0xE1, 0xD1, 0x9E, 0x36, + 0xD1, 0xCE, 0x94, 0x89, 0x15, 0x32, 0x8E, 0x0A, + 0x91, 0xB1, 0xA9, 0x5E, 0x10, 0x4F, 0xC3, 0x43, + 0x6A, 0x16, 0x6B, 0x3E, 0x3E, 0x96, 0xE0, 0xCA, + 0x71, 0x22, 0x35, 0x1F, 0x21, 0x71, 0x40, 0xB0 + }, + { + 0x47, 0x98, 0x3F, 0x0E, 0x93, 0x77, 0xF0, 0x2F, + 0xC0, 0x3D, 0x1F, 0xA4, 0x6D, 0x13, 0xD3, 0x39, + 0x1C, 0x6E, 0x2E, 0xFB, 0x94, 0x0D, 0xF5, 0x3D, + 0x2C, 0xA0, 0xF7, 0x94, 0x5E, 0x5D, 0xB0, 0xA9, + 0x4A, 0xAB, 0x8C, 0x1B, 0xCA, 0x5B, 0x70, 0x04, + 0x84, 0x00, 0x70, 0x7D, 0x9C, 0x04, 0x02, 0x09, + 0xED, 0xD0, 0x87, 0xFD, 0xF1, 0x4D, 0x61, 0x65, + 0xF0, 0x4F, 0xED, 0x72, 0xE5, 0xD2, 0x28, 0xF7 + }, + { + 0x08, 0x6F, 0x83, 0xD6, 0x9D, 0xA2, 0xD3, 0x23, + 0xE2, 0x0B, 0xB6, 0x66, 0x80, 0x91, 0x01, 0xB6, + 0xD8, 0xF3, 0x33, 0xBE, 0xD7, 0x8D, 0x49, 0xB1, + 0x99, 0x74, 0x84, 0xE0, 0x6B, 0xEB, 0x25, 0x9C, + 0xE0, 0xF9, 0x8C, 0xDD, 0x6B, 0xFA, 0x2E, 0xDF, + 0xAB, 0xA8, 0xC8, 0x8C, 0x0D, 0x02, 0xC1, 0x07, + 0x92, 0xC1, 0xFF, 0xBF, 0x29, 0xD8, 0x72, 0x3D, + 0x0D, 0x9A, 0x52, 0xC8, 0x64, 0xD2, 0xC3, 0x7B + }, + { + 0xC8, 0x82, 0x1D, 0x04, 0x6A, 0xCE, 0x4B, 0x51, + 0x05, 0x71, 0x56, 0xD3, 0xB5, 0x5F, 0x29, 0xA3, + 0x43, 0x67, 0x32, 0x59, 0x84, 0x59, 0x95, 0x9B, + 0xB6, 0x87, 0xA9, 0xCB, 0x65, 0x66, 0x48, 0x08, + 0x15, 0xC2, 0xAC, 0x8B, 0x31, 0x66, 0xA6, 0x27, + 0x9F, 0xFB, 0xB1, 0x79, 0xD5, 0x4F, 0xD0, 0x35, + 0xDE, 0x4E, 0x5D, 0xE8, 0xE5, 0xC2, 0x30, 0xF2, + 0xF5, 0x1C, 0xA1, 0x94, 0xE7, 0x9F, 0x4E, 0x6A + }, + { + 0xEC, 0x1E, 0x4B, 0x16, 0x1E, 0x0D, 0xDD, 0xC0, + 0x80, 0x49, 0x4C, 0x4F, 0xCD, 0x8C, 0x23, 0x65, + 0xB3, 0x47, 0x52, 0x8A, 0x74, 0x72, 0xD3, 0x3D, + 0xFA, 0xBF, 0x34, 0x89, 0xBF, 0x9B, 0x9C, 0xC7, + 0xAD, 0x3C, 0x70, 0x67, 0x63, 0xC6, 0x0E, 0x72, + 0xDB, 0x8A, 0x61, 0x8D, 0x31, 0xF7, 0xAD, 0x8C, + 0x17, 0xE2, 0xBC, 0x93, 0x7F, 0x7B, 0xB4, 0x1B, + 0x14, 0xD7, 0xF6, 0x2D, 0xE4, 0x68, 0xBA, 0x7A + }, + { + 0x20, 0x88, 0x9F, 0xA8, 0x2B, 0x9A, 0x4B, 0x77, + 0xB6, 0x86, 0xC4, 0xB2, 0xFD, 0x57, 0x6C, 0x94, + 0x6E, 0x6B, 0xE9, 0x9A, 0x37, 0x3A, 0x5F, 0x3B, + 0xB5, 0x13, 0x11, 0xFA, 0x86, 0x38, 0x15, 0xA2, + 0x47, 0x47, 0xA1, 0xFF, 0x11, 0x62, 0xC6, 0x18, + 0x46, 0x6F, 0x90, 0xAA, 0x50, 0xAC, 0xA1, 0xB2, + 0x83, 0x26, 0x41, 0x48, 0xAF, 0x71, 0x61, 0xE8, + 0x8D, 0x90, 0x47, 0xFE, 0xA1, 0x64, 0xA9, 0x44 + }, + { + 0x5E, 0xB9, 0x79, 0x0F, 0x32, 0x68, 0x4E, 0x34, + 0xFE, 0x8D, 0x7A, 0xC8, 0xE5, 0xCD, 0x1A, 0x62, + 0x15, 0x10, 0x1C, 0x3B, 0xFB, 0x40, 0xC0, 0xFE, + 0x6F, 0xDA, 0xA1, 0x58, 0xBF, 0x94, 0x64, 0x4D, + 0x57, 0x91, 0xBE, 0xA6, 0x60, 0xF1, 0x36, 0x7A, + 0x0A, 0x6D, 0x27, 0x3A, 0x36, 0x9D, 0x23, 0xD7, + 0x4F, 0x33, 0x4A, 0xDF, 0x64, 0x6D, 0x9F, 0xB7, + 0xC1, 0xE2, 0xF6, 0x5F, 0x7A, 0x6E, 0x4F, 0xB8 + }, + { + 0x5A, 0x20, 0x76, 0x9F, 0xEF, 0x74, 0x46, 0x37, + 0xBE, 0x50, 0x14, 0xAA, 0x2A, 0xEB, 0x51, 0xA3, + 0xD3, 0xA2, 0xB4, 0xE7, 0xE0, 0x1E, 0xAC, 0x10, + 0x1C, 0xDA, 0x59, 0xFF, 0x30, 0x5E, 0xEC, 0x1E, + 0x8A, 0x72, 0xE5, 0x8A, 0x08, 0xF6, 0xF4, 0x40, + 0x2E, 0x18, 0x31, 0x76, 0x4C, 0x00, 0xD6, 0xEB, + 0x6A, 0x46, 0x8F, 0x34, 0x43, 0x30, 0x62, 0x10, + 0xA3, 0x98, 0x54, 0x3C, 0x61, 0x48, 0xD4, 0xB1 + }, + { + 0x78, 0x1A, 0x39, 0x70, 0x4C, 0x6E, 0x61, 0x68, + 0x8E, 0x1E, 0x4C, 0xD1, 0x4E, 0x16, 0x2E, 0xB8, + 0xF7, 0xA2, 0x2D, 0x6A, 0xE5, 0x3E, 0x39, 0x08, + 0xB6, 0x09, 0x53, 0xB1, 0x97, 0xE4, 0xAA, 0xAF, + 0x0C, 0xCE, 0x98, 0xF6, 0x12, 0x3C, 0x2A, 0xBD, + 0x6A, 0xE8, 0x14, 0x8C, 0xC6, 0x2C, 0x2D, 0x51, + 0x1C, 0xAD, 0xA4, 0x6E, 0xE8, 0x29, 0x59, 0x78, + 0xAC, 0x56, 0x16, 0xAB, 0x6D, 0xC8, 0x88, 0xAC + }, + { + 0x93, 0x63, 0xD6, 0x19, 0x70, 0xE4, 0xA3, 0xA0, + 0x80, 0xA8, 0x22, 0x43, 0x9B, 0x04, 0x52, 0x42, + 0xB8, 0x51, 0x5C, 0xC6, 0x0B, 0x13, 0x89, 0xF8, + 0xFF, 0xD3, 0x97, 0x44, 0xB4, 0x4D, 0x77, 0x66, + 0xF1, 0x26, 0x75, 0x43, 0xCA, 0x0D, 0x2C, 0x32, + 0x92, 0x2C, 0xB6, 0xE9, 0x6F, 0x71, 0x70, 0x9F, + 0xA7, 0x04, 0xEA, 0x28, 0x2D, 0xAC, 0x9F, 0x94, + 0x46, 0x86, 0xBD, 0xD5, 0xE1, 0xC7, 0x79, 0x78 + }, + { + 0xB2, 0xAA, 0x30, 0x65, 0x10, 0x73, 0x80, 0x74, + 0x89, 0x05, 0x25, 0xAA, 0xBE, 0x71, 0x98, 0x09, + 0x4D, 0xE7, 0x98, 0x16, 0x80, 0x09, 0x0B, 0x9D, + 0xC1, 0xB1, 0x09, 0x3E, 0x1E, 0x0F, 0xE6, 0xC4, + 0xC5, 0x82, 0x82, 0xB9, 0x86, 0x3D, 0x62, 0x3F, + 0x2A, 0x65, 0x4C, 0xE9, 0x23, 0xD4, 0x40, 0x35, + 0x8B, 0x77, 0x61, 0x7D, 0x3C, 0xC3, 0x68, 0x47, + 0x5A, 0x6A, 0x8C, 0x25, 0xAF, 0x0A, 0xB7, 0xF9 + }, + { + 0x4D, 0x45, 0x04, 0x78, 0xA8, 0x62, 0x0D, 0x1B, + 0x01, 0x88, 0xD6, 0xB9, 0xC5, 0xEF, 0x13, 0x86, + 0xC8, 0x18, 0x25, 0x56, 0x44, 0xB7, 0xD3, 0xCF, + 0xFA, 0x3C, 0xD1, 0xF9, 0x88, 0xCD, 0xAF, 0xFF, + 0xC3, 0x37, 0xFA, 0x5B, 0x33, 0xCE, 0xBF, 0x7B, + 0xE5, 0xDD, 0x51, 0x55, 0x91, 0xF5, 0x18, 0x72, + 0x17, 0xCD, 0x8D, 0xE9, 0x82, 0x44, 0x63, 0x72, + 0xDA, 0x27, 0x4E, 0x4F, 0x8C, 0x30, 0xC0, 0xFA + }, + { + 0xB2, 0xB3, 0xC3, 0xF4, 0x75, 0x9C, 0xA5, 0xE7, + 0xB6, 0x24, 0x26, 0x4B, 0x89, 0xA5, 0xBE, 0xDD, + 0x63, 0xD3, 0x6F, 0x6E, 0x0A, 0xA2, 0x58, 0x4C, + 0x91, 0x44, 0xC2, 0x06, 0x3C, 0x5F, 0x59, 0xD2, + 0xD8, 0xBC, 0xE2, 0xCA, 0x40, 0x80, 0x6D, 0xA4, + 0xA7, 0x27, 0xB7, 0x45, 0xC3, 0xA3, 0xB8, 0x23, + 0xD8, 0x33, 0x6E, 0x71, 0x9E, 0xDE, 0x11, 0xB0, + 0xE7, 0xE9, 0x8D, 0x48, 0x4E, 0x79, 0xBD, 0xBF + }, + { + 0x61, 0x2F, 0x99, 0x5E, 0xE8, 0x99, 0xC8, 0xC8, + 0xF1, 0x58, 0x01, 0x52, 0x67, 0x39, 0xEC, 0xC1, + 0x45, 0x0A, 0x1E, 0xD5, 0x60, 0x9C, 0x11, 0x56, + 0xFA, 0x7A, 0x8A, 0x81, 0x2E, 0x53, 0xBF, 0x5D, + 0x37, 0x08, 0x0C, 0x12, 0x8F, 0x5E, 0xAD, 0x61, + 0x30, 0xC3, 0xDB, 0xC6, 0xAF, 0x86, 0xE1, 0x3C, + 0x15, 0x2C, 0x36, 0x3E, 0xBA, 0x13, 0x6D, 0x5D, + 0xA8, 0x61, 0x05, 0x50, 0x82, 0xC6, 0x23, 0x14 + }, + { + 0x1F, 0x18, 0x7E, 0x41, 0xDD, 0x00, 0x7F, 0x29, + 0x9F, 0x6D, 0xAE, 0xF3, 0x2D, 0xFA, 0x03, 0x88, + 0x61, 0x61, 0x20, 0x58, 0x02, 0xD9, 0xAF, 0x78, + 0x0C, 0xE9, 0x44, 0x2D, 0x68, 0x44, 0xCF, 0xAC, + 0xCC, 0x28, 0xD9, 0x03, 0x97, 0x04, 0xFF, 0xA8, + 0x91, 0x34, 0xDB, 0xDE, 0x61, 0xB0, 0xA7, 0x6A, + 0x17, 0x47, 0x48, 0xFA, 0xEB, 0x32, 0x58, 0x21, + 0xED, 0x3A, 0x3D, 0x95, 0xE8, 0xA8, 0xFB, 0xFE + }, + { + 0x16, 0x9A, 0x15, 0xAD, 0x70, 0x4F, 0x9F, 0x9D, + 0xD7, 0xB0, 0xC8, 0xBF, 0x8D, 0x26, 0xFA, 0x25, + 0x4B, 0x8A, 0xD0, 0x44, 0x03, 0xBA, 0x47, 0x29, + 0xB4, 0xE6, 0xC8, 0xA5, 0xC1, 0x41, 0xC9, 0xAC, + 0xF8, 0x06, 0xDD, 0x27, 0xCC, 0x46, 0x27, 0x93, + 0xAF, 0xBE, 0x4A, 0xA2, 0xA8, 0xB3, 0x3E, 0xE9, + 0x89, 0xFE, 0x5B, 0x61, 0xD0, 0xE5, 0x76, 0xBD, + 0x0C, 0x1B, 0xA2, 0x63, 0x26, 0xE5, 0xA1, 0xEA + }, + { + 0x75, 0x95, 0x71, 0x65, 0x03, 0x36, 0xDD, 0x6D, + 0xA7, 0x0D, 0x06, 0x80, 0x47, 0xD7, 0x88, 0x15, + 0x61, 0x83, 0x46, 0xEB, 0x14, 0x87, 0xBE, 0x09, + 0x3C, 0x47, 0x95, 0xD4, 0x7C, 0xA8, 0x07, 0x88, + 0x2C, 0x55, 0xFB, 0xBF, 0x46, 0x4E, 0x63, 0x8A, + 0xC1, 0x1C, 0x56, 0xA7, 0x5C, 0x5D, 0xF7, 0x8E, + 0x31, 0xB6, 0xF5, 0xAB, 0x49, 0x53, 0x04, 0x86, + 0x83, 0xBA, 0x2D, 0x15, 0x08, 0x84, 0xD9, 0x57 + }, + { + 0x47, 0xAB, 0xBD, 0x37, 0x60, 0xAB, 0xA2, 0x8C, + 0xB0, 0x7A, 0xB3, 0xC2, 0xEE, 0x0E, 0xE3, 0x2B, + 0xE3, 0x93, 0x83, 0x3B, 0x3A, 0x1A, 0x9C, 0x51, + 0xB8, 0xFE, 0xF6, 0x54, 0xCC, 0x07, 0x5C, 0xAD, + 0xCC, 0x2E, 0xE7, 0xC4, 0x44, 0x6E, 0x7E, 0x89, + 0xB1, 0x28, 0x2F, 0x3A, 0x15, 0xBC, 0x5B, 0x04, + 0xFB, 0x44, 0xFE, 0x6A, 0xA2, 0xB9, 0x11, 0x22, + 0xB8, 0x59, 0xBF, 0xA9, 0x44, 0x3B, 0x7E, 0x88 + }, + { + 0x22, 0xC2, 0x8F, 0x6C, 0x33, 0x42, 0x6A, 0x70, + 0x4E, 0x1A, 0x96, 0x4F, 0xDA, 0xCE, 0xBF, 0x60, + 0x3E, 0xA4, 0x2A, 0x09, 0x6A, 0xE8, 0x71, 0x35, + 0xE7, 0xB2, 0x32, 0xF2, 0x9D, 0xBF, 0xD4, 0x94, + 0xAC, 0x2F, 0xB6, 0x71, 0x8B, 0x5C, 0x6D, 0x9F, + 0x82, 0x21, 0x2A, 0x3A, 0xCB, 0x3C, 0x19, 0x87, + 0x7C, 0xB7, 0xBB, 0xE4, 0xCB, 0x56, 0x91, 0x28, + 0xCB, 0xD6, 0x23, 0xE4, 0xC9, 0xA1, 0xDF, 0xE1 + }, + { + 0x9F, 0x32, 0x3F, 0x4F, 0xDA, 0xB2, 0x71, 0x01, + 0xBB, 0x98, 0x06, 0x1E, 0x1E, 0xAA, 0xDA, 0x9E, + 0x85, 0x87, 0x1E, 0x79, 0x08, 0x0B, 0x95, 0x14, + 0x0D, 0xC3, 0x52, 0xFE, 0x96, 0x30, 0x15, 0x87, + 0xD3, 0xAA, 0x9A, 0x27, 0x91, 0xBF, 0x79, 0xCF, + 0x76, 0x87, 0x0D, 0x87, 0xE6, 0x65, 0xF5, 0x87, + 0xE1, 0x8A, 0xE6, 0xC7, 0x1C, 0xE4, 0x8F, 0xC1, + 0x3A, 0x16, 0x9A, 0xC4, 0x76, 0x2E, 0xE1, 0xE3 + }, + { + 0x0F, 0xBA, 0x73, 0x71, 0x5B, 0x2C, 0xEF, 0x94, + 0x3E, 0xE8, 0xEF, 0x48, 0x5C, 0xBA, 0x6A, 0x94, + 0x07, 0xC1, 0x16, 0x62, 0xC5, 0x62, 0xF9, 0xD4, + 0xBD, 0x62, 0xE8, 0x86, 0x15, 0x9B, 0x91, 0x97, + 0x99, 0xE3, 0x20, 0x09, 0xEC, 0xF1, 0xB0, 0x91, + 0x92, 0x18, 0x06, 0xC9, 0x7B, 0xD6, 0x18, 0xE6, + 0x90, 0x14, 0x40, 0x0D, 0x69, 0xD8, 0x0B, 0x4B, + 0x64, 0x61, 0x53, 0x24, 0x35, 0x00, 0x60, 0x98 + }, + { + 0x75, 0xDA, 0x82, 0x51, 0xC6, 0x4D, 0x24, 0xFD, + 0x7A, 0x15, 0x21, 0x50, 0x66, 0xB7, 0x5B, 0xE4, + 0xD1, 0x46, 0xB9, 0x3E, 0x50, 0x6E, 0xB7, 0xEE, + 0x2C, 0xAE, 0x9E, 0x09, 0x8C, 0x1A, 0xBB, 0x2C, + 0x2D, 0x1B, 0x8D, 0x71, 0xD5, 0xC2, 0x93, 0x89, + 0xBA, 0xDC, 0xD9, 0xA4, 0xCE, 0x22, 0xDE, 0x32, + 0x36, 0xAE, 0xF2, 0xE6, 0xA5, 0x4F, 0xBE, 0x6D, + 0x6F, 0x27, 0x38, 0xAD, 0xDB, 0x41, 0x23, 0x84 + }, + { + 0xFA, 0x14, 0x89, 0x74, 0x33, 0xDD, 0x69, 0x32, + 0x1B, 0x19, 0x33, 0xA1, 0xFE, 0x10, 0x1F, 0xDD, + 0x46, 0x3D, 0xC1, 0x5F, 0xFF, 0xE3, 0xF5, 0x72, + 0xC0, 0xB4, 0x89, 0xBB, 0x60, 0x7E, 0xDF, 0xF8, + 0xB6, 0xDD, 0x04, 0xA2, 0x38, 0x71, 0xBE, 0x99, + 0x3D, 0x64, 0xAF, 0x5A, 0xAA, 0x9B, 0x76, 0xAF, + 0x48, 0x2A, 0x23, 0x63, 0xA3, 0x6C, 0x1E, 0x6D, + 0xAA, 0xEF, 0x21, 0xD3, 0xE3, 0xAC, 0x29, 0xC6 + }, + { + 0x5B, 0x3A, 0x0E, 0x99, 0x0C, 0x4E, 0x8C, 0x6E, + 0x54, 0x63, 0xE7, 0x63, 0xA6, 0x68, 0x65, 0x51, + 0xA1, 0x29, 0xA8, 0x1A, 0xB4, 0x8C, 0x49, 0xCD, + 0x8D, 0xC1, 0x05, 0x19, 0xDF, 0xE2, 0xD0, 0x2D, + 0x2A, 0x45, 0x1C, 0xBB, 0xA6, 0x51, 0x17, 0x75, + 0xB6, 0xA9, 0xCB, 0x26, 0xDB, 0x88, 0x36, 0x3C, + 0xDD, 0x06, 0x7F, 0xFB, 0x71, 0x83, 0xEF, 0xE1, + 0x98, 0x26, 0x67, 0x8B, 0x2F, 0xC9, 0xF3, 0x49 + }, + { + 0xCD, 0x79, 0xFB, 0xBD, 0xED, 0x91, 0x82, 0x32, + 0x72, 0xAB, 0xB7, 0xA9, 0x7A, 0x55, 0x30, 0x60, + 0x8F, 0x05, 0x83, 0xBD, 0x54, 0x05, 0xC7, 0x76, + 0x51, 0x56, 0xC4, 0xD8, 0x75, 0x4D, 0xDF, 0x43, + 0x5D, 0x6D, 0x71, 0xB8, 0x4F, 0x83, 0xC6, 0x38, + 0x10, 0x78, 0x93, 0x5E, 0x37, 0x8D, 0x4B, 0xF0, + 0xF7, 0x52, 0xB3, 0x09, 0xD1, 0x39, 0x8A, 0xF5, + 0x78, 0xE1, 0x03, 0xE4, 0x43, 0xB8, 0xAC, 0x55 + }, + { + 0x62, 0xD5, 0x55, 0xED, 0x8F, 0x3A, 0xB4, 0xEC, + 0xAB, 0x0D, 0x91, 0x98, 0x87, 0xC5, 0xFF, 0x57, + 0x0A, 0x5E, 0x03, 0x8D, 0xD5, 0x5F, 0x69, 0x88, + 0x2E, 0x53, 0xD9, 0x83, 0x72, 0xC8, 0x0E, 0xA2, + 0xEE, 0xB7, 0x25, 0x95, 0x49, 0x35, 0x73, 0x1D, + 0x9D, 0x90, 0xD7, 0xDD, 0x33, 0xB9, 0xCD, 0xC8, + 0xA9, 0xCC, 0x07, 0x42, 0x6C, 0x5A, 0x89, 0x8F, + 0xA6, 0x4D, 0xC6, 0x7C, 0x04, 0x32, 0xF6, 0x86 + }, + { + 0x64, 0xC3, 0x94, 0x2E, 0xE8, 0x5D, 0x6C, 0xE0, + 0xAE, 0x1D, 0x1F, 0xC5, 0x8A, 0x06, 0xE2, 0x02, + 0x6A, 0x2D, 0xE5, 0x91, 0xD5, 0xEC, 0x7E, 0x13, + 0x6F, 0x3F, 0x9C, 0x7E, 0x5E, 0xBC, 0x95, 0xCC, + 0x62, 0xBC, 0xB4, 0xEB, 0xCF, 0x0D, 0xA2, 0x4E, + 0x7F, 0xD2, 0xC8, 0x8E, 0xA2, 0x0B, 0x97, 0x45, + 0x54, 0xDB, 0x69, 0x6A, 0x39, 0x64, 0x56, 0x98, + 0xD9, 0xC3, 0x45, 0xBB, 0x93, 0x48, 0x09, 0xE9 + }, + { + 0x28, 0x78, 0xA3, 0x32, 0x53, 0x29, 0x2B, 0xAA, + 0xE8, 0xDD, 0x13, 0xEB, 0xD3, 0x50, 0x49, 0x51, + 0x2C, 0x1A, 0xC4, 0xCF, 0xD1, 0x9D, 0x2C, 0xBF, + 0x5A, 0x95, 0xD7, 0x42, 0x3D, 0xE4, 0x38, 0x71, + 0xDF, 0xDF, 0x92, 0x4D, 0x14, 0xDA, 0x2E, 0x35, + 0xD9, 0xEB, 0x3C, 0x2B, 0x83, 0x53, 0x2C, 0xD9, + 0xE5, 0x39, 0x4C, 0x4B, 0xC4, 0xD7, 0x9E, 0xEA, + 0x74, 0x62, 0x2F, 0x70, 0xFF, 0xC8, 0x6F, 0x4D + }, + { + 0x90, 0x2A, 0x4E, 0x23, 0x01, 0x3E, 0x49, 0xC4, + 0x3F, 0x67, 0x0D, 0x1B, 0x85, 0x6A, 0x8D, 0xB6, + 0x37, 0xE7, 0x46, 0xCF, 0x71, 0xAB, 0xC1, 0x79, + 0x28, 0x03, 0xC2, 0xC4, 0xEA, 0xB1, 0xEA, 0x69, + 0x72, 0x2A, 0xC8, 0x2E, 0xD0, 0xF1, 0xA2, 0x36, + 0x0E, 0x90, 0x20, 0xFD, 0x86, 0x01, 0x10, 0x96, + 0x65, 0x4E, 0x54, 0x80, 0xD2, 0x28, 0x01, 0xDB, + 0x97, 0xC7, 0xB6, 0x91, 0x57, 0xF6, 0x9E, 0x3B + }, + { + 0x0A, 0xC8, 0xA0, 0xDA, 0x5D, 0x9C, 0x73, 0xE0, + 0x3E, 0x09, 0x96, 0x95, 0xD9, 0xE6, 0xB7, 0x57, + 0xEF, 0xC9, 0xF8, 0x54, 0xE1, 0xC2, 0x65, 0x00, + 0xD9, 0x87, 0xB5, 0x41, 0xAF, 0x48, 0x13, 0x31, + 0xFA, 0xE8, 0x4F, 0xB1, 0x04, 0x61, 0xB7, 0x4A, + 0xB5, 0x0D, 0x93, 0x16, 0x3D, 0x3B, 0xF3, 0xEE, + 0xB5, 0x67, 0x05, 0x88, 0x43, 0xD1, 0xD2, 0x68, + 0xE1, 0x4C, 0x27, 0x0D, 0xBC, 0x76, 0xC1, 0x26 + }, + { + 0xBD, 0xA5, 0xC2, 0x56, 0x5E, 0x7E, 0x9F, 0x84, + 0xBC, 0x9D, 0x19, 0xAE, 0xF8, 0x4C, 0xB4, 0x22, + 0xC2, 0xC1, 0xA7, 0xB7, 0x8F, 0xC4, 0x5D, 0x50, + 0xAB, 0x82, 0x70, 0x80, 0xE9, 0xBE, 0x2B, 0xE4, + 0x79, 0x81, 0x55, 0xD6, 0x35, 0xF0, 0x7F, 0x01, + 0xC2, 0xA5, 0xF4, 0x8A, 0x6D, 0x30, 0x27, 0xBE, + 0x7C, 0x0A, 0xDE, 0xBA, 0xC1, 0xC5, 0x12, 0x40, + 0x74, 0x1C, 0x9C, 0x0E, 0x1C, 0x02, 0x3F, 0x68 + }, + { + 0xE9, 0xB1, 0x18, 0xB7, 0xD3, 0x38, 0x9A, 0xEC, + 0xE0, 0x93, 0xEA, 0x70, 0xCC, 0x25, 0xA5, 0x69, + 0x6A, 0xA8, 0x3E, 0xC5, 0x1C, 0x99, 0x79, 0xB0, + 0xBE, 0x57, 0x0F, 0xBB, 0x48, 0x65, 0xC0, 0xD8, + 0x81, 0x01, 0x41, 0x61, 0xE6, 0xF7, 0xE6, 0xF7, + 0x45, 0x99, 0x20, 0xC1, 0xC9, 0x58, 0xE9, 0xE7, + 0xB2, 0x68, 0x32, 0x89, 0xE3, 0x9D, 0x46, 0xB5, + 0x7F, 0xAB, 0x5D, 0xCC, 0xA2, 0x23, 0xE3, 0x17 + }, + { + 0x87, 0x50, 0xDF, 0x5C, 0x5A, 0x56, 0x0E, 0x15, + 0x8B, 0x2F, 0xA6, 0x7F, 0x08, 0x66, 0x18, 0x5A, + 0x39, 0xF9, 0x68, 0xD8, 0x18, 0x74, 0x8D, 0xD5, + 0xEA, 0x57, 0x83, 0x6D, 0x9A, 0xE1, 0xE7, 0x92, + 0x6C, 0x7A, 0xBA, 0x1F, 0x1F, 0x9D, 0x2D, 0xAC, + 0xA3, 0x47, 0x85, 0xF6, 0x3F, 0xCB, 0xD8, 0x5F, + 0xBC, 0xB8, 0x25, 0x00, 0x46, 0xC1, 0x01, 0x2E, + 0xF3, 0xDC, 0x90, 0x66, 0xFA, 0x15, 0x68, 0xC6 + }, + { + 0xA5, 0x45, 0x79, 0x4E, 0x1B, 0xB0, 0x81, 0x88, + 0xC3, 0xB9, 0x7F, 0xEA, 0xF7, 0xA1, 0x50, 0x05, + 0x76, 0x25, 0x59, 0x7D, 0xD3, 0xDC, 0x06, 0xFD, + 0x26, 0x1F, 0x7C, 0x51, 0x0A, 0xFE, 0x35, 0xA7, + 0x0D, 0xD6, 0x7F, 0x93, 0xBC, 0x20, 0xCE, 0xAA, + 0x5A, 0xAF, 0xFF, 0xD8, 0x48, 0x18, 0xFF, 0xAD, + 0x61, 0x45, 0x50, 0x9C, 0x90, 0xE7, 0xDD, 0x41, + 0x0D, 0xCF, 0xDB, 0xBD, 0xB2, 0x07, 0xAD, 0x12 + }, + { + 0x5F, 0x2B, 0x27, 0xF2, 0x3E, 0x94, 0xA6, 0x6F, + 0xAD, 0xA4, 0xB1, 0x1F, 0xE4, 0xAC, 0xCE, 0x7A, + 0xC5, 0xEE, 0xDE, 0xE2, 0x18, 0x10, 0xBA, 0x2C, + 0xB9, 0xCF, 0x32, 0x1F, 0x84, 0xF8, 0xAE, 0x41, + 0xA4, 0x77, 0x04, 0x3A, 0x84, 0x6F, 0x45, 0x9A, + 0x35, 0x17, 0x9D, 0x53, 0xC7, 0xF2, 0xA0, 0xC6, + 0xA0, 0x2D, 0x06, 0x41, 0x48, 0x90, 0xF7, 0xDD, + 0x9C, 0x85, 0x5B, 0xF3, 0x92, 0x30, 0xC8, 0xF3 + }, + { + 0x4E, 0x37, 0xCE, 0x4F, 0xD6, 0x22, 0xBD, 0x08, + 0x8B, 0x9F, 0x36, 0xC6, 0x6A, 0xA3, 0x73, 0x6A, + 0x8C, 0x0D, 0x1D, 0xDE, 0x87, 0x49, 0xEC, 0xEA, + 0x92, 0x4D, 0xB7, 0x69, 0x57, 0x78, 0xD3, 0xEB, + 0x5B, 0xAB, 0x5E, 0x65, 0xE3, 0xCE, 0x14, 0xAD, + 0x20, 0x0B, 0xEB, 0x75, 0x28, 0x95, 0xD3, 0xB9, + 0x8C, 0x35, 0xD0, 0x50, 0xA6, 0x44, 0x76, 0x8C, + 0x9B, 0xE4, 0x76, 0xB8, 0x8A, 0x01, 0xA7, 0xD7 + }, + { + 0x3B, 0xEB, 0xDC, 0x2C, 0xA1, 0xA8, 0xF3, 0x4D, + 0x7D, 0xF7, 0x1B, 0xE3, 0x55, 0x82, 0x62, 0x7B, + 0x83, 0x27, 0x6B, 0xAF, 0x3C, 0x69, 0xC2, 0x8D, + 0xB4, 0x83, 0x56, 0x3D, 0xC0, 0xF9, 0x0D, 0x68, + 0xC5, 0x75, 0x0D, 0x01, 0x3E, 0xB6, 0x55, 0xB6, + 0xAE, 0x9B, 0xC6, 0xB9, 0xA9, 0xD2, 0x64, 0xF2, + 0x8D, 0x0F, 0x7F, 0x31, 0xEF, 0x1F, 0x09, 0x26, + 0x05, 0x28, 0x7C, 0xEE, 0x7F, 0x41, 0x5C, 0x98 + }, + { + 0x0E, 0x94, 0xA9, 0x17, 0x73, 0xDD, 0xC1, 0xAB, + 0x2C, 0x6C, 0xEC, 0x89, 0xD9, 0x53, 0x34, 0xA3, + 0x53, 0xCD, 0xC7, 0x5C, 0xFB, 0xAA, 0x04, 0x10, + 0xFB, 0x6E, 0xDF, 0xE7, 0xA1, 0x0E, 0x83, 0xEE, + 0x71, 0xC0, 0x38, 0xCA, 0x37, 0xC0, 0x62, 0x75, + 0x20, 0x79, 0x93, 0xDE, 0x3A, 0x48, 0x9E, 0xA7, + 0xAF, 0x0D, 0x30, 0x10, 0x83, 0x52, 0x78, 0xB6, + 0x5B, 0xE2, 0xEE, 0x1D, 0x16, 0x2E, 0x6F, 0x93 + }, + { + 0xBD, 0xBF, 0x0B, 0xB2, 0x5B, 0x69, 0x67, 0x29, + 0x65, 0xD7, 0x61, 0x82, 0x7D, 0x54, 0x58, 0xF6, + 0xC1, 0xE6, 0xB8, 0x57, 0x6E, 0x2D, 0xDB, 0x29, + 0xB6, 0x5E, 0xA9, 0xF9, 0x4E, 0x28, 0x74, 0xB7, + 0xB7, 0x18, 0xA2, 0x3B, 0x64, 0x6A, 0x39, 0x7E, + 0xD6, 0xC8, 0xAF, 0xE4, 0x04, 0x8B, 0xCB, 0xA5, + 0xA8, 0x4D, 0x20, 0x53, 0xCD, 0x39, 0x42, 0xBC, + 0x6C, 0x7F, 0x23, 0x93, 0x60, 0x04, 0x1D, 0x0B + }, + { + 0x29, 0x34, 0xA2, 0x57, 0xDE, 0x3E, 0x2F, 0x92, + 0x16, 0x58, 0x8A, 0xD7, 0xB8, 0xB2, 0x51, 0x39, + 0x5C, 0xCF, 0x51, 0x4D, 0x36, 0xDC, 0xD6, 0x4F, + 0x2A, 0x09, 0x7D, 0xA4, 0x03, 0x40, 0x51, 0x0E, + 0x5C, 0xDC, 0xCE, 0x56, 0x1D, 0x22, 0x5B, 0xA3, + 0xF1, 0x6F, 0x13, 0x62, 0x6D, 0xFF, 0xEE, 0x99, + 0x04, 0x5B, 0x15, 0xCD, 0xD7, 0xF5, 0xA0, 0xA6, + 0x89, 0x29, 0xA0, 0x04, 0x6B, 0x72, 0x31, 0xED + }, + { + 0xA3, 0x0E, 0x83, 0x5B, 0xA1, 0xE8, 0x1B, 0x5C, + 0xA9, 0xE5, 0xAD, 0x30, 0x8E, 0x45, 0x85, 0xFB, + 0x20, 0x70, 0xFE, 0x74, 0x7E, 0xD9, 0xD0, 0xC4, + 0x72, 0xB4, 0x1A, 0xD5, 0xB3, 0x24, 0x04, 0xC6, + 0x13, 0xAB, 0x34, 0xFB, 0x12, 0x69, 0xF5, 0xDE, + 0x04, 0x0C, 0x33, 0x16, 0xCA, 0x2A, 0x94, 0xA2, + 0x0A, 0x59, 0x1E, 0x05, 0xA1, 0x47, 0x7F, 0x19, + 0x35, 0x57, 0x91, 0x59, 0xFF, 0xF6, 0xCC, 0x31 + }, + { + 0xC0, 0xB0, 0x12, 0x37, 0xA3, 0xE5, 0x2F, 0xD8, + 0x48, 0x33, 0x19, 0x14, 0xA1, 0x3B, 0x5A, 0x3B, + 0xF3, 0x4D, 0x03, 0x9C, 0x35, 0xEC, 0xD5, 0x56, + 0xDD, 0xAB, 0x5E, 0x01, 0xCE, 0x5C, 0x85, 0xCB, + 0xAD, 0xE0, 0x71, 0xDB, 0xC3, 0x89, 0xD5, 0x64, + 0x92, 0xCB, 0x4D, 0xE9, 0x3C, 0x4A, 0x14, 0x53, + 0x9F, 0xC3, 0xF7, 0x3C, 0x71, 0xF7, 0x81, 0x03, + 0xE7, 0xF4, 0x5A, 0x3E, 0xDE, 0x45, 0x9E, 0x2D + }, + { + 0x66, 0xF5, 0xBB, 0x91, 0x83, 0x73, 0x2B, 0x46, + 0xF1, 0xFD, 0x5F, 0xB2, 0x25, 0x26, 0xF5, 0xF3, + 0x61, 0x04, 0x2D, 0x32, 0xE3, 0x7B, 0xF0, 0x8D, + 0xAA, 0xCF, 0xD2, 0xD3, 0xAF, 0xD8, 0x1F, 0x5C, + 0x53, 0xCD, 0xDF, 0xA0, 0xA2, 0x38, 0x14, 0xF4, + 0x20, 0xCF, 0x8C, 0x73, 0xD9, 0x64, 0x95, 0xBE, + 0xE5, 0x74, 0xB0, 0xB0, 0xC1, 0xC5, 0xDB, 0x3F, + 0x54, 0xC3, 0xE0, 0x5F, 0x6F, 0x2A, 0x34, 0xB4 + }, + { + 0xBF, 0x0D, 0x81, 0xFB, 0x89, 0x70, 0x0E, 0x81, + 0x7D, 0x4F, 0xCE, 0xB3, 0x55, 0x8C, 0xC0, 0xEE, + 0xE3, 0xD8, 0x70, 0x4C, 0x99, 0x13, 0x12, 0x64, + 0xB5, 0xFC, 0xAC, 0x40, 0xB2, 0xCD, 0xB1, 0xCD, + 0xC2, 0xCE, 0xF4, 0x13, 0xC7, 0x69, 0x92, 0x43, + 0xBB, 0xCF, 0x1B, 0x09, 0xDD, 0x90, 0x98, 0xBF, + 0x3B, 0xD0, 0xB1, 0x3E, 0x24, 0xD0, 0x31, 0x12, + 0x88, 0x87, 0xA3, 0x7C, 0x0F, 0x91, 0x8A, 0x5B + }, + { + 0xF5, 0xD2, 0x95, 0xE4, 0x60, 0xDF, 0x2B, 0xDC, + 0xAA, 0xFB, 0x0F, 0x92, 0x9B, 0x21, 0xB3, 0x29, + 0xC3, 0x38, 0x69, 0x4B, 0x51, 0x2E, 0x6D, 0xD3, + 0xB6, 0x24, 0xD6, 0x9B, 0x51, 0xCE, 0xBF, 0x43, + 0x51, 0x4B, 0xCA, 0xBF, 0x47, 0x8A, 0x8A, 0xE1, + 0xD4, 0xDF, 0x9B, 0x3E, 0x46, 0x3E, 0x00, 0xF7, + 0x15, 0x50, 0xEE, 0xC9, 0xEA, 0x95, 0xD3, 0x4A, + 0x8E, 0x68, 0x6C, 0xB8, 0x0B, 0xE7, 0x72, 0xD7 + }, + { + 0x09, 0x71, 0x7D, 0xBC, 0x95, 0xF2, 0xF4, 0x10, + 0x26, 0xAD, 0x3C, 0xCD, 0x31, 0x0E, 0x93, 0x22, + 0x2F, 0x15, 0xB5, 0xF2, 0x8A, 0x33, 0x31, 0x35, + 0x5C, 0xCC, 0x6A, 0x0C, 0x52, 0xD2, 0x16, 0x22, + 0x98, 0xC2, 0x97, 0x46, 0xEF, 0xDF, 0x23, 0x18, + 0x00, 0x9C, 0x73, 0x33, 0x29, 0xE1, 0xB2, 0x40, + 0xFD, 0x2C, 0x24, 0x6B, 0xAB, 0xA4, 0xF5, 0x76, + 0xC4, 0x65, 0x8C, 0x85, 0x20, 0x22, 0xD4, 0x9D + }, + { + 0x22, 0x69, 0x19, 0xD8, 0x9F, 0x96, 0xFC, 0xE2, + 0x7C, 0x8E, 0xE9, 0x58, 0x46, 0xA1, 0x67, 0xB6, + 0x51, 0xD3, 0xC5, 0x7C, 0x39, 0x50, 0x71, 0x7E, + 0xA3, 0x77, 0x9C, 0xA1, 0x61, 0x6A, 0xA7, 0x4C, + 0x10, 0xC1, 0x32, 0xCD, 0xCA, 0xEC, 0x41, 0xE8, + 0x74, 0xF3, 0x81, 0xF6, 0xA6, 0x6C, 0xBB, 0xF8, + 0x23, 0x7D, 0xBB, 0x07, 0x5D, 0x65, 0x32, 0xAD, + 0xCD, 0xB2, 0x36, 0x24, 0xDB, 0x0D, 0x85, 0x2C + }, + { + 0x7A, 0xC6, 0xB1, 0xE4, 0x91, 0xAD, 0x4B, 0x59, + 0x74, 0x7B, 0xC0, 0x4E, 0xE3, 0xF7, 0xBF, 0x8B, + 0xD8, 0x18, 0x17, 0xBE, 0xDD, 0x59, 0xE5, 0x41, + 0x93, 0x06, 0x39, 0x80, 0x0A, 0xCD, 0xAB, 0x09, + 0x33, 0x2F, 0xC0, 0x4B, 0x46, 0x6A, 0x0D, 0x1D, + 0xF0, 0xD6, 0x41, 0x72, 0x85, 0x06, 0x79, 0xC5, + 0xBD, 0x39, 0xEA, 0xED, 0x6B, 0x82, 0xDB, 0x82, + 0xB5, 0x70, 0xAA, 0xA2, 0xAF, 0x99, 0x11, 0xDD + }, + { + 0xDB, 0x55, 0xA4, 0xA3, 0xE1, 0xEC, 0x48, 0xB4, + 0x10, 0xD5, 0x9D, 0xB6, 0x50, 0x12, 0x8F, 0xCC, + 0x05, 0x1C, 0x87, 0x64, 0x57, 0x85, 0x4E, 0x46, + 0xF1, 0xFC, 0x19, 0xA9, 0x40, 0x77, 0x5F, 0x4B, + 0xA0, 0x55, 0x0E, 0x96, 0xDE, 0x28, 0xE5, 0xF0, + 0x17, 0xE7, 0xBC, 0x27, 0x5E, 0x2B, 0x36, 0x1C, + 0xCB, 0xE4, 0x66, 0x76, 0x81, 0xDE, 0x1C, 0x2C, + 0x20, 0x6A, 0xC5, 0xAC, 0x97, 0x8B, 0xB9, 0xF9 + }, + { + 0x37, 0xFE, 0xB2, 0xD4, 0x22, 0x28, 0x8B, 0x25, + 0x04, 0xB3, 0x08, 0x16, 0xA9, 0x51, 0x74, 0xDD, + 0x4B, 0x8A, 0x78, 0xB9, 0x0A, 0x5E, 0xA7, 0xFE, + 0xDD, 0xE4, 0x2E, 0x2E, 0x37, 0x6E, 0x97, 0xE4, + 0x99, 0x78, 0xED, 0x6E, 0x91, 0xF6, 0x4A, 0x7D, + 0xEE, 0xB9, 0xBC, 0xB1, 0x94, 0xD0, 0x3C, 0x07, + 0xB2, 0x63, 0x61, 0xA3, 0xDC, 0x49, 0xAC, 0x09, + 0x76, 0xA3, 0x16, 0xEA, 0x99, 0x84, 0xC6, 0xB2 + }, + { + 0xF9, 0x78, 0xE4, 0x4F, 0x50, 0xBD, 0x1E, 0x72, + 0x6A, 0xCE, 0x96, 0x32, 0xE8, 0xFE, 0x51, 0xEA, + 0xFB, 0x6A, 0xE3, 0x01, 0xFF, 0xF1, 0xA2, 0x7D, + 0xAC, 0xF7, 0x0F, 0xA2, 0x86, 0xE0, 0x8D, 0xB7, + 0xEC, 0x92, 0xEC, 0xDF, 0xBA, 0x7C, 0x73, 0x7B, + 0xA2, 0xD2, 0xC8, 0xDC, 0x0A, 0xB5, 0x12, 0xFE, + 0x43, 0xE9, 0x68, 0x63, 0xE4, 0x08, 0xA1, 0xEF, + 0xEE, 0xFC, 0xC5, 0x1B, 0x54, 0x41, 0xB6, 0xEE + }, + { + 0xE4, 0x84, 0x93, 0x1A, 0xA5, 0xF9, 0xA3, 0x56, + 0x02, 0x3B, 0x46, 0x6F, 0xA9, 0x32, 0x88, 0x45, + 0x7E, 0xA4, 0x72, 0x59, 0x07, 0x52, 0xAA, 0xA6, + 0xC3, 0x6E, 0x3A, 0x39, 0xE5, 0x24, 0xE8, 0x8D, + 0x39, 0x08, 0x4B, 0xCA, 0x34, 0x26, 0x60, 0x39, + 0xF2, 0x41, 0x2C, 0xFF, 0xDE, 0xA9, 0xE7, 0x44, + 0x7B, 0x3A, 0xDA, 0x5E, 0x0F, 0xD4, 0x8C, 0xBE, + 0x4B, 0xDF, 0xF1, 0x97, 0x81, 0x0F, 0xFC, 0x12 + }, + { + 0xE6, 0x08, 0x0A, 0x0E, 0xAB, 0x7A, 0xEC, 0x76, + 0x8D, 0xA2, 0x54, 0xA6, 0x1F, 0xED, 0xB4, 0x47, + 0x35, 0xAF, 0x75, 0xA8, 0x1D, 0xC0, 0x32, 0x79, + 0xCA, 0xBA, 0xF7, 0x4A, 0xCD, 0x44, 0xA6, 0x27, + 0x47, 0xB8, 0x16, 0x77, 0x52, 0x0B, 0x0B, 0x8D, + 0xF4, 0xD0, 0x04, 0x4C, 0xA6, 0x21, 0x58, 0x67, + 0xE9, 0x4A, 0x45, 0x18, 0x4B, 0x49, 0x44, 0xDF, + 0xA0, 0xBD, 0xD6, 0x79, 0x0E, 0x1D, 0xDD, 0x89 + }, + { + 0xB6, 0x46, 0xCA, 0x29, 0x4F, 0x7C, 0xEF, 0xC5, + 0x59, 0x96, 0x3C, 0x4F, 0x3D, 0x84, 0xC3, 0x2C, + 0xF5, 0x55, 0x9F, 0xDE, 0x7B, 0xED, 0xE9, 0xF4, + 0x41, 0xD6, 0x5E, 0x00, 0x52, 0xD0, 0x75, 0x20, + 0x18, 0xA0, 0x98, 0xCB, 0xB9, 0x88, 0x92, 0xEF, + 0x93, 0xD3, 0x4F, 0xA1, 0xA5, 0x17, 0xC5, 0xDC, + 0x20, 0x82, 0xEF, 0x4B, 0x40, 0x2D, 0x9A, 0x01, + 0x0B, 0xED, 0xC7, 0x19, 0xAF, 0xFA, 0x07, 0xE7 + }, + { + 0x70, 0x89, 0x92, 0xFB, 0xE1, 0x32, 0x47, 0x5D, + 0x33, 0x06, 0xA2, 0xD4, 0xA4, 0x73, 0xDB, 0xCE, + 0xEE, 0xC7, 0x34, 0x88, 0x28, 0x4E, 0x1C, 0x99, + 0xB8, 0xC2, 0x73, 0x3D, 0x1D, 0xB0, 0xA7, 0x6D, + 0xAC, 0x9C, 0xDA, 0x97, 0xE4, 0xD2, 0x41, 0xE2, + 0x35, 0x69, 0xB1, 0x62, 0xDD, 0x94, 0x7E, 0xCB, + 0x08, 0xD4, 0xD7, 0x95, 0x08, 0x57, 0x00, 0x21, + 0x86, 0xA0, 0xE3, 0x02, 0xC9, 0x93, 0xDC, 0x8B + }, + { + 0xFE, 0xF4, 0xB6, 0x93, 0x04, 0x27, 0x38, 0xFB, + 0xD3, 0x65, 0xC3, 0x1F, 0xD2, 0x73, 0x54, 0xBC, + 0x53, 0x2C, 0x9C, 0x90, 0x0F, 0xE2, 0xD3, 0xA9, + 0x16, 0x08, 0x85, 0x87, 0xD7, 0x32, 0x3F, 0x69, + 0x0F, 0xF2, 0x8D, 0x55, 0x0A, 0x70, 0x7F, 0x8B, + 0x59, 0xEC, 0xAE, 0x29, 0x57, 0xA7, 0x15, 0x23, + 0x1F, 0xF6, 0x13, 0x1D, 0x35, 0xBB, 0xC0, 0x32, + 0xF5, 0x7A, 0xCF, 0xA3, 0xDA, 0x7B, 0x56, 0xD8 + }, + { + 0x1E, 0x78, 0x48, 0x23, 0xF0, 0x07, 0x67, 0xD8, + 0x41, 0x09, 0x1C, 0xB4, 0x88, 0x76, 0xFF, 0xA2, + 0x35, 0x27, 0x8C, 0xAE, 0x35, 0x8D, 0xA9, 0xA7, + 0xD7, 0x1F, 0x02, 0x3B, 0xF2, 0xF6, 0x76, 0x51, + 0x90, 0xD3, 0x17, 0x19, 0xD9, 0xFF, 0x45, 0x65, + 0x35, 0x93, 0x0A, 0xFC, 0x25, 0xBD, 0x71, 0xEC, + 0x84, 0x2B, 0x11, 0xED, 0x38, 0xD3, 0xEA, 0x8F, + 0x3B, 0x19, 0x6A, 0xE7, 0xB9, 0x8F, 0xAD, 0xCF + }, + { + 0x34, 0x04, 0xA9, 0xCF, 0x08, 0xAA, 0xCB, 0x53, + 0x95, 0xDA, 0x99, 0x36, 0xD2, 0xF8, 0x6C, 0xA3, + 0x24, 0x0B, 0xD6, 0x6A, 0x27, 0x93, 0xFE, 0x30, + 0x4C, 0x74, 0xEE, 0x51, 0x01, 0xDF, 0xA7, 0xBF, + 0x5F, 0x07, 0x2C, 0x4A, 0xC2, 0x29, 0xB1, 0x81, + 0x4E, 0x79, 0xCB, 0x72, 0xBD, 0x41, 0x76, 0x6F, + 0x21, 0x7C, 0x67, 0x47, 0x78, 0xA9, 0x3C, 0x3F, + 0xAD, 0xD5, 0x0F, 0x70, 0x30, 0x87, 0xE4, 0x81 + }, + { + 0x73, 0xE5, 0xE4, 0xB8, 0xE6, 0x00, 0x4A, 0xBD, + 0x7B, 0xFB, 0x5D, 0x0F, 0xD4, 0x96, 0x83, 0xB8, + 0x42, 0xE2, 0xF0, 0xA5, 0x4D, 0x3E, 0xDB, 0x0F, + 0x79, 0x55, 0xB3, 0x64, 0x00, 0x04, 0xAE, 0x62, + 0x3B, 0x09, 0x7B, 0x91, 0x01, 0x40, 0x12, 0x17, + 0xEF, 0x94, 0x8B, 0x10, 0x81, 0x8C, 0x1B, 0xB0, + 0x88, 0xEB, 0xDB, 0x02, 0x9A, 0xFE, 0xD6, 0x08, + 0x5C, 0xCB, 0x32, 0x17, 0xFC, 0x2B, 0x4E, 0xF4 + }, + { + 0xD5, 0x6D, 0x78, 0x92, 0x51, 0xED, 0x6B, 0xAA, + 0x3C, 0xA3, 0xAA, 0x67, 0x49, 0x33, 0xCD, 0x99, + 0x32, 0x6C, 0x7E, 0xE4, 0x7B, 0x2F, 0x81, 0x56, + 0x10, 0x56, 0xBE, 0xC5, 0x42, 0x89, 0x26, 0x69, + 0x8B, 0x45, 0x3C, 0xA6, 0x38, 0x3E, 0x37, 0x0D, + 0x73, 0xCD, 0x05, 0x71, 0xDD, 0x10, 0xE8, 0x29, + 0x03, 0xCD, 0x25, 0xAF, 0xDE, 0xA2, 0xBB, 0x8B, + 0x13, 0x83, 0x56, 0xAF, 0xCF, 0x01, 0xB7, 0x62 + }, + { + 0x98, 0x96, 0x8F, 0x95, 0x11, 0x35, 0x45, 0xD3, + 0x09, 0x57, 0xDE, 0x1A, 0x02, 0xF8, 0x50, 0xCA, + 0x55, 0x0B, 0x6D, 0x4D, 0x71, 0xE3, 0x63, 0xED, + 0x08, 0xBC, 0xD4, 0xF9, 0x0D, 0xB9, 0x27, 0xBA, + 0x40, 0x57, 0x22, 0x9B, 0x93, 0xD1, 0xAC, 0x10, + 0x39, 0x4A, 0x5F, 0x30, 0x16, 0x07, 0xC8, 0x65, + 0x69, 0x64, 0xF4, 0x58, 0x2D, 0x04, 0xBF, 0xBF, + 0xBF, 0x4F, 0x77, 0x02, 0xCF, 0xF7, 0x39, 0xDA + }, + { + 0xDE, 0x1A, 0x54, 0xA5, 0x9F, 0x0F, 0x91, 0x52, + 0xDE, 0x11, 0xEC, 0x4E, 0xA9, 0x78, 0xC2, 0x63, + 0xDF, 0x10, 0xD9, 0xEE, 0xC6, 0x25, 0x58, 0x1B, + 0x00, 0xBD, 0xF2, 0x0F, 0x46, 0x8E, 0xC0, 0xE2, + 0x93, 0xCF, 0x50, 0x6A, 0x94, 0x62, 0x4B, 0xF9, + 0x60, 0xCA, 0x51, 0x8F, 0xF9, 0x04, 0x57, 0xFB, + 0xEA, 0x60, 0x9B, 0xE8, 0xD4, 0x36, 0xF3, 0xAD, + 0x37, 0xA1, 0x5E, 0x41, 0x55, 0x48, 0x1A, 0xBF + }, + { + 0x29, 0xF4, 0xEA, 0x34, 0xCE, 0x8F, 0x43, 0x0F, + 0x6D, 0x89, 0xEB, 0xC6, 0x2F, 0x95, 0xBC, 0xF1, + 0xC3, 0x8D, 0x9A, 0x1D, 0xF4, 0xF9, 0x78, 0x4B, + 0x77, 0x00, 0x92, 0x60, 0x71, 0x8C, 0x2B, 0x5E, + 0xFC, 0xA8, 0x86, 0x58, 0x80, 0x7F, 0x1A, 0x3D, + 0x1F, 0xF8, 0x69, 0x55, 0xB2, 0xB2, 0x9E, 0x28, + 0x90, 0x54, 0xC2, 0x66, 0x79, 0x23, 0x6F, 0xD0, + 0x56, 0x21, 0x33, 0x04, 0xEE, 0x9A, 0x00, 0x0E + }, + { + 0x59, 0x94, 0x6E, 0xBC, 0x83, 0xD7, 0x76, 0x1C, + 0xB9, 0x67, 0x9A, 0x84, 0xAA, 0x88, 0xFA, 0x5B, + 0xF2, 0xF8, 0x2F, 0x70, 0x0F, 0xB8, 0x09, 0xD1, + 0x84, 0x9C, 0x4C, 0xEB, 0xCC, 0x17, 0x32, 0xB8, + 0x8C, 0xAA, 0x06, 0xE3, 0xA8, 0x25, 0x34, 0x57, + 0x61, 0x1C, 0x55, 0x76, 0x66, 0x25, 0x81, 0x0D, + 0xC2, 0xDF, 0x63, 0xD9, 0x06, 0xA6, 0x67, 0x43, + 0xF6, 0xCD, 0x5E, 0x79, 0x8D, 0x5F, 0xEB, 0x8D + }, + { + 0x81, 0x3E, 0x44, 0x7F, 0x34, 0xFC, 0x6A, 0x27, + 0x9F, 0xE8, 0x78, 0xF6, 0x4F, 0xEF, 0xAB, 0x73, + 0x18, 0x7C, 0x81, 0x03, 0x02, 0xF5, 0x0F, 0x54, + 0x81, 0x03, 0xCB, 0xF3, 0x6E, 0xD7, 0x1B, 0xF3, + 0xB5, 0xAE, 0x3A, 0x85, 0x83, 0x7D, 0x27, 0xD4, + 0xD5, 0xB9, 0x27, 0x35, 0x35, 0x19, 0xD2, 0x9A, + 0xA3, 0x5E, 0xD9, 0x58, 0xA9, 0xB5, 0x2B, 0x2E, + 0x60, 0x82, 0x17, 0xAE, 0x4A, 0x20, 0x94, 0xB2 + }, + { + 0x7D, 0xFC, 0x58, 0x19, 0xD5, 0x84, 0xE9, 0xC4, + 0x22, 0x4A, 0x70, 0x05, 0x7A, 0xEE, 0x9F, 0xCC, + 0x11, 0x97, 0xA0, 0xBD, 0xEC, 0xC5, 0xCE, 0xB0, + 0xFB, 0xA1, 0x0B, 0xC2, 0x8D, 0x93, 0xB3, 0xA4, + 0xD3, 0x07, 0x2B, 0xA4, 0x42, 0x73, 0xE9, 0x11, + 0xB9, 0x08, 0x03, 0x11, 0x35, 0x84, 0xBE, 0xB1, + 0xB6, 0xC4, 0x6F, 0xAD, 0x67, 0x23, 0x3D, 0x9B, + 0x4C, 0xFF, 0xBE, 0x44, 0xA9, 0x76, 0x06, 0xC6 + }, + { + 0x72, 0x0F, 0x09, 0x72, 0x43, 0x4C, 0xC6, 0x8D, + 0x0C, 0x1F, 0xA2, 0xD6, 0x8F, 0xE2, 0xB4, 0xE2, + 0x79, 0xAD, 0x77, 0x96, 0xB1, 0xF7, 0x39, 0xC5, + 0xF6, 0x25, 0xAA, 0x59, 0x50, 0x8A, 0x80, 0xDE, + 0xE7, 0xF0, 0xCE, 0x20, 0x10, 0x83, 0x06, 0x16, + 0x85, 0x94, 0x62, 0xFF, 0xB3, 0x7B, 0x00, 0xA3, + 0xA2, 0xC1, 0xE8, 0x9D, 0x4E, 0x31, 0x82, 0xAE, + 0xF6, 0x71, 0xF3, 0x51, 0x0F, 0x3D, 0xF4, 0x47 + }, + { + 0xE3, 0xA3, 0xAB, 0xE4, 0x8E, 0x34, 0x16, 0x81, + 0x6B, 0x89, 0x39, 0xF9, 0xAE, 0x12, 0x19, 0xB8, + 0x61, 0xAC, 0x4A, 0x0A, 0xAC, 0xC5, 0x10, 0x8C, + 0xFA, 0x06, 0x50, 0x3E, 0xFD, 0x99, 0x2D, 0x19, + 0x49, 0x46, 0x70, 0x79, 0x03, 0x62, 0xCE, 0xCA, + 0x95, 0x49, 0x82, 0x86, 0xAB, 0xAB, 0xB1, 0x7A, + 0x9E, 0xE0, 0x4F, 0xF6, 0xDE, 0x4A, 0x8F, 0xC8, + 0xF1, 0x52, 0x64, 0x0F, 0xF0, 0x94, 0xA1, 0x9B + }, + { + 0x4E, 0x30, 0x24, 0x58, 0x14, 0x70, 0x3F, 0xF7, + 0x63, 0x2D, 0x1E, 0x41, 0x41, 0x2A, 0xEE, 0x40, + 0xA8, 0xBC, 0xB1, 0x28, 0xFE, 0x97, 0x63, 0x8F, + 0xF6, 0xB8, 0xB6, 0xD5, 0x10, 0xE6, 0x1C, 0x40, + 0x8F, 0x3D, 0xC2, 0x3F, 0x42, 0xDD, 0xA8, 0xE5, + 0x6A, 0xF1, 0x88, 0x06, 0x6A, 0x6D, 0xF7, 0x57, + 0xD5, 0xCE, 0xE4, 0x22, 0x59, 0x0B, 0x99, 0xB8, + 0x8D, 0x4E, 0xD0, 0x6E, 0xB1, 0x97, 0x16, 0xBF + }, + { + 0x85, 0x7B, 0x7B, 0x98, 0xE6, 0x48, 0x28, 0xE6, + 0xCA, 0xF3, 0x6B, 0x9F, 0x72, 0xC4, 0x8D, 0xD5, + 0xFF, 0xA9, 0x25, 0x6F, 0x87, 0x4E, 0xC5, 0xD3, + 0xB0, 0x1A, 0x30, 0x5F, 0x7C, 0x63, 0x4A, 0x73, + 0x74, 0x69, 0x11, 0x16, 0xE3, 0x03, 0x90, 0x24, + 0xF5, 0xDC, 0xD4, 0xEB, 0xEB, 0xA4, 0x39, 0x8F, + 0x24, 0x30, 0xB7, 0x5A, 0x43, 0x7B, 0x42, 0x6D, + 0x9E, 0x4B, 0xE2, 0x3D, 0x09, 0x19, 0x6C, 0x88 + }, + { + 0xB7, 0x59, 0x58, 0xB4, 0x82, 0x59, 0x23, 0xE1, + 0x6C, 0xCF, 0x3B, 0xBE, 0x88, 0x94, 0x7C, 0x60, + 0xB7, 0x61, 0xBB, 0x8B, 0x1B, 0x62, 0x5B, 0x5D, + 0xEE, 0xEE, 0xCA, 0x89, 0xB1, 0xC3, 0x00, 0xAB, + 0x6E, 0xEA, 0x98, 0x88, 0xE0, 0x16, 0x10, 0x4C, + 0x0B, 0x44, 0xDB, 0x6A, 0xF1, 0x4D, 0x08, 0x3D, + 0x6E, 0x99, 0x83, 0xBB, 0xD2, 0x4C, 0xDB, 0x1B, + 0xED, 0x5A, 0x5C, 0x17, 0x69, 0x66, 0xC5, 0xEA + }, + { + 0xDC, 0x63, 0xC4, 0x40, 0xC2, 0x81, 0xD7, 0x62, + 0x86, 0x6D, 0xF1, 0x61, 0x7D, 0x89, 0xB8, 0x09, + 0x38, 0x00, 0x39, 0xA5, 0xBE, 0xCF, 0xC3, 0x28, + 0x1A, 0x7D, 0x88, 0x8F, 0xD0, 0xD2, 0x01, 0xC8, + 0xED, 0x0E, 0xDF, 0xAE, 0xDE, 0x36, 0x4B, 0x16, + 0x5C, 0x95, 0xF4, 0x81, 0xB6, 0x0B, 0xAC, 0x4A, + 0x17, 0x51, 0x74, 0x64, 0x2B, 0x15, 0x96, 0xD5, + 0xE6, 0x58, 0x90, 0x80, 0xF9, 0xE6, 0x5C, 0xF3 + }, + { + 0x1D, 0xE5, 0x2B, 0x23, 0xFE, 0xC7, 0x2C, 0x2C, + 0x0B, 0xD5, 0x33, 0x18, 0xE9, 0x02, 0x1E, 0xA1, + 0x4E, 0xA2, 0x25, 0xE2, 0xDF, 0x79, 0x8E, 0x21, + 0x02, 0x6A, 0xAE, 0x75, 0x34, 0x66, 0xCB, 0xBD, + 0x22, 0xF5, 0x9D, 0x80, 0x08, 0x1E, 0x95, 0x9A, + 0x96, 0x36, 0x3C, 0x53, 0xC2, 0xF2, 0x70, 0x6A, + 0x86, 0x29, 0xA3, 0xE4, 0x51, 0x1D, 0xF7, 0x54, + 0xBC, 0x9D, 0x48, 0x0F, 0x79, 0x8B, 0xD3, 0xDA + }, + { + 0xE5, 0x74, 0x23, 0x02, 0x65, 0x86, 0xC4, 0xE1, + 0xD5, 0x54, 0x91, 0x0A, 0xB0, 0xA7, 0x2E, 0x01, + 0x3A, 0x52, 0x0A, 0x34, 0xE6, 0x6A, 0x83, 0xC0, + 0xFD, 0xE0, 0xFA, 0x7E, 0x48, 0x8F, 0x5C, 0xFD, + 0x99, 0x21, 0x0B, 0x4A, 0x5A, 0xED, 0x23, 0xDA, + 0x70, 0xEB, 0xEF, 0x8F, 0x68, 0x2D, 0xC2, 0x34, + 0xA1, 0xD2, 0x02, 0x12, 0x31, 0x0C, 0x5E, 0x4B, + 0x08, 0x20, 0x3C, 0x34, 0xE0, 0xEF, 0xA8, 0xD2 + }, + { + 0x46, 0xF8, 0x8B, 0xB2, 0xB0, 0x13, 0x92, 0xD1, + 0xCE, 0x71, 0x4F, 0xF3, 0x73, 0xD7, 0xC5, 0x98, + 0x30, 0x14, 0x65, 0x91, 0x49, 0x5F, 0x2A, 0x05, + 0x51, 0xD5, 0x34, 0xF5, 0x65, 0xCD, 0xB8, 0xEA, + 0xC1, 0xB0, 0xAC, 0x6E, 0x65, 0x65, 0x53, 0x59, + 0x7C, 0x50, 0x05, 0x1B, 0xBF, 0x37, 0xE2, 0x74, + 0xF1, 0x1E, 0xC2, 0x01, 0xFD, 0xA1, 0x1C, 0x0D, + 0xB6, 0x47, 0x23, 0x38, 0x7D, 0x29, 0x37, 0x43 + }, + { + 0x1A, 0xED, 0x86, 0x54, 0x14, 0xA0, 0x30, 0x41, + 0x9B, 0x95, 0xA8, 0x69, 0xA7, 0x07, 0x0D, 0x58, + 0xDB, 0x53, 0x15, 0xF4, 0x31, 0xFA, 0xF3, 0xB5, + 0xCD, 0xF5, 0x7D, 0x4D, 0x48, 0x6F, 0x9C, 0x3A, + 0x5A, 0xBB, 0x7F, 0xBA, 0xBE, 0xB7, 0xD0, 0x2E, + 0xD8, 0x70, 0xA0, 0x58, 0x88, 0xC3, 0x30, 0x2D, + 0xE3, 0xC6, 0x83, 0xCA, 0x62, 0xF0, 0xE4, 0x89, + 0x60, 0xBB, 0x4E, 0x8B, 0x95, 0x3A, 0xC2, 0x18 + }, + { + 0xA3, 0x01, 0x0D, 0xFF, 0x77, 0xB3, 0xA2, 0x03, + 0xBB, 0x73, 0x28, 0x17, 0x6C, 0xC0, 0x4E, 0x11, + 0x8F, 0x70, 0x37, 0x07, 0x9A, 0x0D, 0xB6, 0xB4, + 0x10, 0x91, 0x6E, 0xA5, 0xD4, 0x2E, 0x76, 0xD5, + 0x16, 0x7B, 0x94, 0x49, 0xAC, 0xDF, 0xAF, 0x38, + 0x49, 0x56, 0xB0, 0xE8, 0x65, 0xF0, 0x2E, 0xCC, + 0x04, 0x2D, 0xFC, 0x84, 0xA7, 0x76, 0x9A, 0x4A, + 0x76, 0xA3, 0xC4, 0xEC, 0x34, 0x91, 0x92, 0x95 + }, + { + 0x45, 0xCB, 0xF7, 0x31, 0xEB, 0x3D, 0x23, 0x2F, + 0xD1, 0x70, 0x06, 0xF5, 0x3A, 0x6A, 0x70, 0x1C, + 0x19, 0xE6, 0x1B, 0x0B, 0xDF, 0xD7, 0xFA, 0xA9, + 0xDD, 0x1B, 0xEB, 0xD8, 0xEC, 0x67, 0x77, 0xE1, + 0xC5, 0xB0, 0x91, 0xA9, 0x5A, 0x64, 0xAA, 0xFD, + 0x0C, 0xCD, 0x3F, 0x58, 0x54, 0x7A, 0x5B, 0x51, + 0x2B, 0x99, 0xD2, 0xE9, 0xB2, 0xB4, 0x1C, 0xBF, + 0x49, 0xD3, 0xD2, 0x07, 0xB4, 0x19, 0xCE, 0x20 + }, + { + 0x5A, 0x8A, 0xB2, 0x1E, 0xDD, 0x51, 0xCF, 0x63, + 0x46, 0xF4, 0x59, 0xAD, 0x39, 0x74, 0x42, 0xAD, + 0xFE, 0x5E, 0x0F, 0xCA, 0x74, 0x4D, 0x84, 0xB0, + 0x4F, 0x1A, 0x35, 0x3A, 0xC1, 0x32, 0xE0, 0x19, + 0xF5, 0x45, 0x4C, 0xFF, 0x52, 0x53, 0xB2, 0xDD, + 0x06, 0xCD, 0x94, 0x87, 0xDA, 0x7E, 0x1F, 0x6A, + 0x78, 0x7C, 0xF0, 0xD7, 0x4C, 0x1D, 0x6F, 0xC2, + 0x19, 0x3B, 0xF4, 0x48, 0xBE, 0x3E, 0x3B, 0xC7 + }, + { + 0xB9, 0xB9, 0xAE, 0x74, 0xAE, 0x6A, 0xBB, 0x69, + 0x28, 0xBF, 0x16, 0xAC, 0x28, 0x81, 0xD7, 0x02, + 0x9D, 0xD3, 0x9B, 0x89, 0xF7, 0x36, 0xB4, 0xF9, + 0x9F, 0x55, 0x5E, 0x55, 0x5A, 0x54, 0xE0, 0x4C, + 0x5A, 0x12, 0x67, 0x02, 0x5D, 0x9A, 0x51, 0x28, + 0x4F, 0x30, 0x4B, 0xC7, 0xEA, 0x9F, 0xBC, 0x64, + 0x90, 0xBE, 0xA3, 0x8A, 0x09, 0xB4, 0x3C, 0x06, + 0x17, 0x76, 0xEF, 0xE5, 0x48, 0xF5, 0xD7, 0x70 + }, + { + 0xDE, 0xE5, 0xB5, 0x5A, 0x2A, 0x73, 0xD9, 0x59, + 0x35, 0x9E, 0x68, 0x09, 0xDF, 0x00, 0x7D, 0x78, + 0x14, 0x9A, 0x2C, 0x93, 0x07, 0x29, 0x7B, 0x57, + 0x1D, 0x22, 0x03, 0xAA, 0x8F, 0x96, 0x99, 0x10, + 0xBE, 0xE1, 0xAC, 0x73, 0xDB, 0xC6, 0xC0, 0x97, + 0x36, 0xBC, 0xB9, 0x79, 0x44, 0xC9, 0xCF, 0x4A, + 0x09, 0x27, 0xD1, 0x95, 0xB0, 0x62, 0x23, 0x9A, + 0xDD, 0x63, 0x47, 0x61, 0x13, 0x41, 0x5F, 0x4F + }, + { + 0xFF, 0x97, 0x0C, 0x9A, 0x22, 0x37, 0x78, 0x09, + 0x82, 0x7C, 0xA3, 0x32, 0x05, 0x0D, 0x04, 0xBD, + 0x9A, 0x11, 0x5B, 0x12, 0x43, 0x6C, 0xC9, 0xA7, + 0x87, 0x62, 0x65, 0xCB, 0x30, 0xDA, 0x5B, 0xFC, + 0xC3, 0x56, 0x38, 0xD3, 0xFA, 0x04, 0x09, 0x8D, + 0x69, 0x3E, 0x0C, 0x0B, 0xE0, 0x96, 0x0B, 0xA7, + 0x61, 0xB6, 0x2A, 0xC0, 0xDB, 0x68, 0xAD, 0x5B, + 0xDB, 0x36, 0x46, 0x04, 0xF6, 0x46, 0x28, 0xFC + }, + { + 0x4C, 0x52, 0x4E, 0xD9, 0xC4, 0x85, 0xD0, 0xFA, + 0xE7, 0x0E, 0x18, 0x14, 0x56, 0x9C, 0x0A, 0xDC, + 0x11, 0x36, 0xE8, 0xC9, 0xD5, 0xA6, 0x77, 0xA1, + 0x8E, 0x03, 0xCC, 0x9C, 0x0E, 0xA2, 0xC3, 0xCE, + 0xA8, 0xFB, 0x0D, 0x72, 0x46, 0x70, 0x18, 0x04, + 0x84, 0xC0, 0xD3, 0x53, 0x88, 0xA6, 0x21, 0xF5, + 0x26, 0x1A, 0x7D, 0xB0, 0x3B, 0xC7, 0x84, 0x58, + 0x80, 0xA9, 0xCA, 0xC1, 0x74, 0xAF, 0xD5, 0xD1 + }, + { + 0x8F, 0x7A, 0x84, 0x12, 0x15, 0x89, 0x3F, 0xE0, + 0x18, 0x2D, 0xE3, 0x30, 0x8C, 0xA3, 0x78, 0xDC, + 0x60, 0x0B, 0x2B, 0x6A, 0x98, 0x85, 0x6B, 0xFE, + 0xB0, 0xDA, 0xD9, 0x2B, 0x8D, 0x48, 0x6C, 0x61, + 0x67, 0xF8, 0x12, 0x80, 0x97, 0x8D, 0x0F, 0xB0, + 0x76, 0x2B, 0x14, 0x3F, 0x74, 0xF1, 0x41, 0xA7, + 0x59, 0xE4, 0x2F, 0x8C, 0xBC, 0xEF, 0x95, 0x7E, + 0x7B, 0x00, 0x99, 0x3D, 0xFF, 0x7B, 0x32, 0xF4 + }, + { + 0x1B, 0x25, 0xD9, 0x0D, 0xFC, 0x49, 0xB7, 0x56, + 0xCC, 0x2F, 0x6E, 0x0E, 0xC9, 0x13, 0x8D, 0xE3, + 0xEF, 0x45, 0x25, 0x71, 0xE9, 0x9D, 0x9C, 0x70, + 0xEA, 0x16, 0x04, 0x9C, 0x0D, 0x9C, 0xB7, 0xDE, + 0x87, 0x60, 0x57, 0xB7, 0x81, 0xE4, 0x8B, 0x60, + 0xD8, 0xFE, 0x0E, 0xCE, 0x66, 0xB3, 0x96, 0x4F, + 0xBC, 0x98, 0x38, 0xFF, 0x3A, 0xC0, 0xC1, 0x1A, + 0x8C, 0x6D, 0x79, 0x2A, 0x8E, 0xE0, 0xC0, 0x90 + }, + { + 0x43, 0x17, 0xDE, 0x05, 0x61, 0x6F, 0xA5, 0x98, + 0x53, 0x9E, 0x1E, 0x7A, 0x28, 0xB7, 0x15, 0xE6, + 0x08, 0xE3, 0x19, 0xDD, 0x98, 0x44, 0x3C, 0x81, + 0x63, 0xF0, 0x48, 0x36, 0xBE, 0x93, 0x5B, 0x66, + 0x73, 0x1B, 0xAE, 0x48, 0x4A, 0xDB, 0x24, 0xB1, + 0xCF, 0xEC, 0x35, 0x3C, 0x45, 0xD3, 0x5E, 0xC7, + 0x36, 0x68, 0x61, 0xF2, 0xD2, 0x2F, 0x04, 0x07, + 0x73, 0x20, 0x21, 0x90, 0xC0, 0x25, 0x48, 0x53 + }, + { + 0x87, 0x4E, 0x9D, 0x8B, 0xD6, 0x52, 0x1B, 0x58, + 0x6A, 0x83, 0x95, 0x1C, 0x69, 0x5F, 0x59, 0xDF, + 0x31, 0x14, 0xF0, 0x33, 0xB6, 0xFA, 0x57, 0xD3, + 0xF8, 0x70, 0xD1, 0x2C, 0xCC, 0x39, 0x5D, 0xD5, + 0x9C, 0x1E, 0xB2, 0xB2, 0x70, 0xBF, 0x88, 0x69, + 0x3A, 0x7A, 0xDA, 0x40, 0xDF, 0xA9, 0x58, 0xED, + 0x47, 0x04, 0x28, 0x19, 0x16, 0xCD, 0xA9, 0x0F, + 0x56, 0xB3, 0x6E, 0x75, 0x33, 0xAF, 0xD8, 0x44 + }, + { + 0xCA, 0x40, 0x92, 0xCF, 0x61, 0xBE, 0x7D, 0x75, + 0x19, 0xC6, 0xFF, 0x05, 0x0E, 0x3C, 0xDA, 0xAF, + 0x2A, 0x61, 0xD0, 0x61, 0x32, 0x92, 0x1D, 0x5C, + 0x23, 0xE2, 0x33, 0xEA, 0x86, 0x61, 0x6B, 0x32, + 0x59, 0x68, 0x5C, 0x6C, 0x1C, 0x49, 0x2A, 0x5F, + 0x6A, 0x8F, 0xC4, 0x53, 0xFB, 0x34, 0xA2, 0xBF, + 0x4E, 0xB2, 0xE7, 0xD8, 0x53, 0x3A, 0x7A, 0x32, + 0x8D, 0x46, 0x12, 0x9C, 0x78, 0x38, 0xAE, 0x23 + }, + { + 0xB9, 0xE8, 0xA9, 0xA1, 0x0D, 0x54, 0x88, 0x39, + 0x6F, 0xAE, 0xB9, 0x00, 0xF4, 0x9F, 0x0A, 0xBD, + 0x5C, 0x04, 0x13, 0x5F, 0x54, 0xC6, 0x89, 0xAA, + 0x6C, 0x2E, 0x92, 0x84, 0xB1, 0xC3, 0x0A, 0x1A, + 0x6B, 0xC0, 0x80, 0x3D, 0xB1, 0x27, 0x85, 0x8C, + 0x2C, 0x5F, 0xB2, 0xBC, 0xB9, 0x4C, 0xBA, 0xBB, + 0xAF, 0xA2, 0xCD, 0xCF, 0xF0, 0x40, 0x64, 0x1D, + 0xFB, 0x73, 0xB7, 0xC7, 0x25, 0x7F, 0x38, 0x59 + }, + { + 0x36, 0x38, 0x9B, 0x97, 0x43, 0xA0, 0xF6, 0xE9, + 0x70, 0xF1, 0xC1, 0x6D, 0x09, 0xDC, 0x9E, 0x39, + 0x65, 0x0C, 0xFE, 0xB8, 0xE2, 0x4A, 0x65, 0x5C, + 0xFF, 0xE6, 0x29, 0x5F, 0x0B, 0xDE, 0xB7, 0x16, + 0xA8, 0x24, 0x26, 0x3F, 0x10, 0x18, 0x24, 0xB6, + 0x76, 0xCD, 0x01, 0x0C, 0xD0, 0x68, 0xCF, 0x77, + 0x55, 0x76, 0xC5, 0x20, 0x9F, 0xF9, 0x02, 0x10, + 0x30, 0x4F, 0x81, 0x1C, 0xD6, 0x9A, 0x6E, 0xCE + }, + { + 0x61, 0xE0, 0xC7, 0x09, 0x4E, 0xA7, 0xFE, 0xF1, + 0x11, 0x2F, 0xF4, 0xE5, 0xF2, 0xEC, 0xBE, 0x95, + 0x82, 0xE2, 0xAB, 0xE8, 0x31, 0x8E, 0x4C, 0xF1, + 0xBF, 0xA0, 0x0F, 0x9E, 0xFB, 0xB6, 0x38, 0x69, + 0x1C, 0x4F, 0x78, 0x78, 0xAF, 0x90, 0x63, 0xE3, + 0x9A, 0x72, 0xF0, 0x90, 0x78, 0x82, 0xDB, 0x5F, + 0x38, 0xC9, 0x96, 0x52, 0x50, 0xE2, 0x6F, 0x5E, + 0xFA, 0xDE, 0xDB, 0x28, 0x30, 0x7F, 0xFF, 0xF1 + }, + { + 0x7B, 0x7B, 0x17, 0x0C, 0x6F, 0x91, 0xC1, 0xC4, + 0x58, 0x12, 0xC9, 0xDF, 0xF0, 0x02, 0x5F, 0xFD, + 0x02, 0xEE, 0x1E, 0x35, 0x1A, 0x7D, 0x6A, 0x16, + 0x6D, 0x63, 0x60, 0x12, 0xBB, 0x64, 0xDB, 0x57, + 0x74, 0xB5, 0x9C, 0xC5, 0xC6, 0xE6, 0xA5, 0x19, + 0x4F, 0x08, 0xA4, 0xF9, 0xC7, 0x91, 0x32, 0x9F, + 0xCF, 0xA0, 0x32, 0xAE, 0xA1, 0xF0, 0xC8, 0x1F, + 0xCC, 0x10, 0x46, 0xD8, 0xFD, 0xE3, 0xA2, 0x60 + }, + { + 0x4A, 0x3F, 0xAA, 0x67, 0x87, 0xC0, 0xCF, 0x6E, + 0xC3, 0xD3, 0x5C, 0x18, 0xF1, 0xDF, 0x03, 0xDB, + 0xF6, 0x3B, 0x1D, 0xF0, 0xD9, 0x88, 0xE4, 0x8B, + 0xE4, 0xEB, 0x64, 0x13, 0x7F, 0x92, 0x4A, 0x29, + 0x1E, 0xBD, 0xE6, 0x6F, 0x01, 0xC2, 0x85, 0xCD, + 0x76, 0xC9, 0x3C, 0xED, 0x63, 0x8F, 0x61, 0xC6, + 0x73, 0x07, 0xE0, 0xB9, 0xE7, 0x0A, 0x3E, 0xBE, + 0x76, 0x3F, 0x0B, 0x0B, 0x71, 0x25, 0x81, 0xB4 + }, + { + 0x39, 0x1D, 0x53, 0x09, 0x77, 0xBD, 0x6C, 0x32, + 0x3C, 0x58, 0x4A, 0x97, 0x5F, 0xF4, 0x8D, 0x62, + 0x37, 0x24, 0xFF, 0x1F, 0x5D, 0xD4, 0x3A, 0x45, + 0x1E, 0x1E, 0xF7, 0x17, 0xEC, 0xFB, 0xDF, 0x48, + 0x5E, 0x78, 0x63, 0x50, 0x3C, 0x91, 0x70, 0x0B, + 0xB5, 0x35, 0x7D, 0x91, 0x09, 0x2E, 0xCE, 0x54, + 0xEA, 0xAE, 0x78, 0xC5, 0xA2, 0xD0, 0xF1, 0x5E, + 0xC2, 0x31, 0xD6, 0xCA, 0xA5, 0x2B, 0x78, 0xA0 + }, + { + 0xBE, 0xA5, 0x10, 0x6B, 0xBF, 0xB6, 0xC9, 0x39, + 0x9C, 0xB9, 0x9D, 0xDD, 0x7A, 0x9A, 0xF8, 0xD1, + 0x81, 0x4C, 0xE0, 0x94, 0x78, 0xAA, 0xC9, 0x23, + 0x80, 0x78, 0x6D, 0xE4, 0xF7, 0x58, 0x2F, 0x65, + 0x04, 0x6A, 0x8D, 0x7A, 0xE0, 0x9C, 0xF6, 0x08, + 0xC8, 0x38, 0x46, 0x34, 0x1D, 0x66, 0x75, 0x7C, + 0x30, 0x6F, 0xF9, 0x7A, 0x11, 0x3D, 0xA8, 0x54, + 0x5C, 0x8C, 0x03, 0x1A, 0x73, 0x7C, 0x89, 0xA3 + }, + { + 0x67, 0xEE, 0xD2, 0x18, 0x78, 0x28, 0x1E, 0xB1, + 0x9F, 0x7C, 0xA7, 0xC8, 0x48, 0x9B, 0x36, 0xBB, + 0xA3, 0x1F, 0x2C, 0x51, 0x26, 0x78, 0xE1, 0x33, + 0x8F, 0xFF, 0x23, 0x42, 0xBC, 0x76, 0xD1, 0xA9, + 0x9D, 0x9E, 0x6A, 0x82, 0x05, 0x92, 0x27, 0x36, + 0x3D, 0x8E, 0x2A, 0xBE, 0x59, 0x42, 0xAB, 0x4A, + 0x4C, 0xE0, 0xCA, 0x36, 0x7E, 0x36, 0x36, 0xD0, + 0x38, 0x88, 0x01, 0xC1, 0x56, 0x97, 0x71, 0xA1 + }, + { + 0xBA, 0xB5, 0x7A, 0x6F, 0xD6, 0x88, 0xDE, 0xB3, + 0xD8, 0x03, 0x65, 0xCA, 0x36, 0xDB, 0x25, 0x98, + 0xDF, 0xB6, 0x10, 0x2B, 0x02, 0xFA, 0x6B, 0x25, + 0x1D, 0x66, 0xD3, 0xED, 0xA6, 0x1A, 0x19, 0x94, + 0x01, 0x8F, 0xA0, 0xA5, 0x37, 0xCC, 0x2F, 0xC7, + 0x11, 0x7F, 0x39, 0xB0, 0x1E, 0x0A, 0x5A, 0xB4, + 0xD5, 0xF7, 0x90, 0xFD, 0x16, 0xAC, 0x64, 0x0A, + 0x88, 0x6D, 0xDB, 0x75, 0xCB, 0x70, 0x84, 0x7C + }, + { + 0x76, 0x5A, 0x35, 0xE8, 0x02, 0xD9, 0x3D, 0x85, + 0x9F, 0x95, 0xAC, 0x01, 0x3F, 0xCB, 0xC5, 0xA9, + 0xC5, 0xEC, 0xBE, 0x3E, 0xAB, 0xB6, 0x2D, 0x25, + 0x0C, 0x87, 0x83, 0xED, 0x8C, 0xAB, 0xD2, 0x96, + 0x65, 0xCC, 0xE2, 0x21, 0xB9, 0x6D, 0xE5, 0x4C, + 0x86, 0x69, 0xF2, 0xD9, 0xA0, 0x63, 0xF9, 0x47, + 0x8E, 0xE7, 0x73, 0x1A, 0xE0, 0xBE, 0xBD, 0xF8, + 0x9C, 0xB8, 0x83, 0x51, 0x7F, 0xA9, 0x62, 0x05 + }, + { + 0x3D, 0xDF, 0xDD, 0x50, 0xBD, 0xCE, 0xA5, 0xDA, + 0xE2, 0x75, 0xEB, 0x4A, 0x8E, 0x84, 0x72, 0x53, + 0x66, 0xCC, 0x61, 0xBA, 0xB5, 0x89, 0x44, 0xD1, + 0x4F, 0x5A, 0x45, 0xA8, 0xF4, 0xED, 0x7B, 0x2B, + 0xFA, 0xC0, 0xD7, 0xD4, 0x21, 0x2D, 0x54, 0x7D, + 0xF8, 0x92, 0x15, 0x56, 0x85, 0x41, 0xD8, 0xDD, + 0x89, 0x22, 0x66, 0xB6, 0x47, 0x39, 0x66, 0x3E, + 0x34, 0xD6, 0xAC, 0xEA, 0xDF, 0x3D, 0xE1, 0xED + }, + { + 0xEF, 0x7F, 0x97, 0x18, 0x52, 0xCD, 0x28, 0xD7, + 0xF2, 0x05, 0x9F, 0x72, 0xC7, 0x4F, 0x5F, 0x96, + 0xD8, 0xEA, 0x50, 0x0C, 0xF4, 0xF8, 0x7F, 0x82, + 0xD0, 0x17, 0xD7, 0x05, 0x6D, 0xB8, 0xB6, 0x4F, + 0x87, 0x6D, 0xFB, 0x14, 0x81, 0x28, 0x31, 0xC1, + 0x56, 0x9F, 0xA2, 0xCC, 0x11, 0x29, 0x59, 0x90, + 0x0C, 0x70, 0x37, 0x08, 0x1F, 0xCA, 0x7D, 0x80, + 0xEA, 0x06, 0xC7, 0x92, 0x41, 0x70, 0x7A, 0x42 + }, + { + 0x6C, 0xC1, 0xB5, 0x1F, 0xB8, 0xC7, 0x86, 0x30, + 0x2C, 0xA6, 0xC6, 0x3F, 0x90, 0xC1, 0xF5, 0x0D, + 0x76, 0x4C, 0x09, 0x00, 0x6D, 0x62, 0x0D, 0xFD, + 0x60, 0x6E, 0xCE, 0x7C, 0xC0, 0xDD, 0x98, 0x12, + 0x7B, 0x2C, 0x28, 0x06, 0xCE, 0x9B, 0xB3, 0xA8, + 0x17, 0xE5, 0xA3, 0x63, 0x07, 0x31, 0xB1, 0x75, + 0xD8, 0xEB, 0x4D, 0x15, 0x28, 0x1D, 0xFC, 0x6D, + 0x3A, 0xBB, 0xC6, 0xB3, 0xD8, 0x93, 0x19, 0xF1 + }, + { + 0x1C, 0xCD, 0x45, 0xEC, 0x64, 0x27, 0xD9, 0x15, + 0x90, 0x57, 0x4A, 0xC0, 0xE4, 0x60, 0x40, 0xC4, + 0x43, 0x36, 0x36, 0xAC, 0x28, 0x18, 0x9D, 0xBE, + 0x5A, 0x72, 0xD4, 0xA9, 0x01, 0x71, 0xA6, 0xCC, + 0x4A, 0x1A, 0xCA, 0xE3, 0x01, 0xD2, 0x64, 0x73, + 0x13, 0xF5, 0x40, 0xE2, 0x7B, 0x8E, 0x4D, 0xC7, + 0xFB, 0xC6, 0x7A, 0xC4, 0xEC, 0x1A, 0x5D, 0x4B, + 0x95, 0x3C, 0x38, 0xF6, 0x69, 0x0C, 0x87, 0x13 + }, + { + 0xF7, 0x42, 0xAA, 0xF6, 0x16, 0x0D, 0x14, 0xC8, + 0x65, 0xAD, 0x01, 0x67, 0xFB, 0x1F, 0x4B, 0x91, + 0x3E, 0x65, 0x30, 0x95, 0xFA, 0x73, 0x6F, 0x19, + 0x62, 0xA4, 0xDA, 0xA7, 0x8A, 0x3F, 0xBE, 0xBF, + 0x55, 0x03, 0x42, 0x71, 0x0C, 0x4D, 0x1E, 0xCE, + 0x57, 0x8C, 0x5C, 0xFD, 0x71, 0xB8, 0x42, 0x3E, + 0x18, 0x6C, 0x87, 0x84, 0x7A, 0x64, 0xC8, 0x06, + 0xBC, 0xF2, 0x65, 0x7D, 0x75, 0x8F, 0x0A, 0xC9 + }, + { + 0x4B, 0x99, 0x3E, 0x71, 0xCE, 0xB3, 0xC3, 0x5E, + 0x48, 0xC1, 0xA4, 0xD2, 0xF2, 0xD2, 0x51, 0x51, + 0x1E, 0x7F, 0xB4, 0x0F, 0xC5, 0x4D, 0x4C, 0xCB, + 0x72, 0x30, 0xC8, 0xC7, 0x1C, 0xED, 0xD8, 0x00, + 0x06, 0x65, 0x49, 0x95, 0xED, 0xAC, 0x4F, 0x46, + 0xF6, 0xFE, 0xA5, 0xCF, 0x1C, 0xB8, 0x23, 0xB7, + 0x22, 0x7D, 0x02, 0x97, 0x29, 0x43, 0xC1, 0xB7, + 0xBB, 0x2B, 0x48, 0x36, 0x48, 0x9E, 0x0D, 0x3B + }, + { + 0x54, 0x80, 0x96, 0x8F, 0x38, 0x38, 0x48, 0x7E, + 0x34, 0xC7, 0xB9, 0x44, 0x63, 0x0B, 0xB9, 0x55, + 0xD3, 0x84, 0xA0, 0xEB, 0xC5, 0xB3, 0x69, 0x5B, + 0xE4, 0x5C, 0x39, 0x24, 0x0F, 0xB2, 0xCE, 0xFD, + 0x59, 0xEB, 0xE3, 0xFD, 0x6C, 0x7E, 0x1E, 0xFB, + 0xBD, 0x8D, 0xEA, 0xC8, 0x3A, 0x02, 0x62, 0x8E, + 0x7B, 0xEC, 0x0B, 0x03, 0x4C, 0x7B, 0x9E, 0x72, + 0xD2, 0x8E, 0x0D, 0xAE, 0x02, 0x1B, 0x34, 0x1A + }, + { + 0x50, 0x91, 0xA7, 0xC6, 0x6F, 0x69, 0xDA, 0x9B, + 0x66, 0xC1, 0x62, 0xEC, 0x6E, 0xC0, 0x98, 0xA2, + 0xB9, 0xB6, 0x00, 0xAD, 0x9E, 0xC6, 0x78, 0x26, + 0xFD, 0xEB, 0xB0, 0x2B, 0xD4, 0xA5, 0xB1, 0xC6, + 0xDA, 0x3D, 0xBF, 0xD4, 0x8D, 0x1B, 0x8E, 0xA9, + 0x3E, 0x42, 0x56, 0x7E, 0xD1, 0x07, 0xB2, 0x75, + 0x96, 0xCA, 0x35, 0x6F, 0x4D, 0xE4, 0x76, 0xF0, + 0x89, 0x2F, 0x7F, 0xC9, 0xDC, 0xD0, 0x06, 0x44 + }, + { + 0xE8, 0xFB, 0xC2, 0x39, 0xC0, 0x0E, 0x2A, 0x1D, + 0x21, 0x2E, 0xE9, 0x1C, 0xC2, 0xD0, 0x11, 0x4A, + 0x53, 0x52, 0xAE, 0xF9, 0x10, 0xA0, 0xC2, 0x29, + 0x57, 0xCA, 0xC5, 0x4F, 0xCF, 0x45, 0x67, 0xAC, + 0x03, 0xEB, 0x07, 0x7E, 0x2A, 0xB8, 0x31, 0xAE, + 0xE8, 0x79, 0x1D, 0xB5, 0xD6, 0x24, 0xA5, 0x0C, + 0xDD, 0x33, 0xDE, 0x43, 0x6D, 0x7A, 0xB7, 0x72, + 0x5F, 0x2C, 0x57, 0xB0, 0x39, 0x36, 0x46, 0x05 + }, + { + 0x3E, 0x04, 0xFB, 0x93, 0x1F, 0xB4, 0xEC, 0xBB, + 0xB3, 0x8B, 0x96, 0xB1, 0xC2, 0x8D, 0x58, 0x71, + 0xB9, 0x81, 0xF9, 0x83, 0xD9, 0x68, 0x42, 0xAE, + 0x90, 0x85, 0xE9, 0xAE, 0x85, 0x3C, 0xC5, 0x4A, + 0xEB, 0x5F, 0x32, 0xE0, 0xCA, 0x56, 0x50, 0xE5, + 0x0C, 0x13, 0xF7, 0x2F, 0x9E, 0x18, 0xB0, 0x39, + 0x4C, 0xD3, 0x1B, 0x3A, 0x43, 0xED, 0x27, 0x43, + 0x7D, 0x97, 0xF7, 0x9A, 0xA0, 0x1F, 0x66, 0x1B + }, + { + 0x11, 0x6A, 0x85, 0x4B, 0x0F, 0xAA, 0xB1, 0x47, + 0xE6, 0x11, 0x08, 0xEA, 0xF8, 0xDE, 0x24, 0xB2, + 0x07, 0x1C, 0xF3, 0x9F, 0x2B, 0x05, 0xFA, 0x97, + 0xD3, 0x35, 0x61, 0xAC, 0x69, 0xFE, 0x50, 0xEC, + 0x7B, 0x33, 0xDD, 0xE9, 0x75, 0xCA, 0xCB, 0xCA, + 0xF1, 0x12, 0xF6, 0x0E, 0xC5, 0x5F, 0x3A, 0xD6, + 0x20, 0xC6, 0x70, 0x6C, 0x83, 0x0F, 0x07, 0xFD, + 0x5A, 0x74, 0x5C, 0xC4, 0xD7, 0xA2, 0xDD, 0x97 + }, + { + 0xB3, 0x35, 0x89, 0x7E, 0x5F, 0x29, 0x41, 0xCA, + 0x11, 0x6D, 0x71, 0x36, 0x22, 0x1A, 0x3F, 0x85, + 0xB2, 0xC5, 0x49, 0x77, 0x5A, 0x38, 0x13, 0x39, + 0x9F, 0x87, 0x59, 0x03, 0xB7, 0x0B, 0xA1, 0xDF, + 0x4F, 0xC7, 0x42, 0x62, 0x91, 0x13, 0x48, 0xEB, + 0x25, 0xA6, 0x1D, 0xFF, 0xCF, 0x5D, 0x6E, 0x41, + 0x27, 0x16, 0x84, 0x85, 0x9E, 0xA3, 0xB8, 0xFA, + 0xBA, 0xF4, 0x67, 0x1D, 0x6D, 0x2A, 0x89, 0x49 + }, + { + 0x96, 0xE4, 0xE7, 0x17, 0x60, 0xD2, 0xCB, 0x93, + 0x36, 0x6A, 0xDA, 0x20, 0x17, 0xBA, 0xA5, 0x25, + 0x20, 0x76, 0xA0, 0xC2, 0x93, 0xB9, 0x10, 0x36, + 0x6C, 0x4D, 0x0E, 0x28, 0xC8, 0x49, 0x45, 0xAB, + 0x22, 0xE3, 0x22, 0x78, 0xC3, 0x4F, 0x4F, 0xDD, + 0x7D, 0x89, 0xD7, 0x6E, 0x1F, 0x08, 0xBD, 0x9B, + 0x04, 0x28, 0x18, 0xED, 0x6F, 0x04, 0x98, 0x97, + 0x9A, 0x1B, 0x36, 0xDC, 0x87, 0x21, 0x80, 0xF0 + }, + { + 0xDD, 0xB9, 0x67, 0xDF, 0xF3, 0x06, 0xB4, 0xD8, + 0x60, 0x5D, 0xA6, 0xD1, 0x06, 0x4E, 0x5F, 0xF7, + 0xFC, 0xBB, 0xA4, 0xFB, 0x9E, 0xDF, 0x85, 0x98, + 0xE8, 0xB1, 0xEA, 0xDE, 0x86, 0x6E, 0x35, 0x94, + 0xEF, 0x7C, 0x82, 0xF8, 0xC4, 0xE9, 0x02, 0x30, + 0x42, 0x37, 0x51, 0xE4, 0x92, 0x90, 0xF8, 0x51, + 0x68, 0x22, 0xC9, 0x9D, 0xB3, 0x87, 0x1C, 0x2F, + 0x89, 0xAB, 0x2C, 0xF6, 0x2E, 0xE2, 0x98, 0x3F + }, + { + 0x49, 0xE4, 0x97, 0xEE, 0x1A, 0xEC, 0xD7, 0x9F, + 0x52, 0x26, 0xB4, 0x60, 0x3F, 0x22, 0xBE, 0x83, + 0x64, 0xEB, 0xAF, 0x39, 0xEB, 0x13, 0x93, 0x67, + 0x8E, 0xE2, 0x77, 0xE6, 0x92, 0x44, 0x8F, 0x1F, + 0x79, 0xE7, 0xC5, 0x58, 0xDE, 0x12, 0x03, 0xBA, + 0x01, 0xF3, 0x10, 0xD6, 0x71, 0xD5, 0x4C, 0xC4, + 0x15, 0x59, 0x1A, 0xA5, 0x88, 0xBE, 0x61, 0x8F, + 0xD0, 0x5D, 0x0F, 0xC2, 0xE9, 0xE2, 0xA6, 0x6E + }, + { + 0x0C, 0xD9, 0xCF, 0x64, 0x54, 0x77, 0x70, 0xD3, + 0x33, 0x18, 0x68, 0x2A, 0x9B, 0x7F, 0x37, 0x89, + 0x4A, 0x32, 0x5E, 0x8F, 0x3E, 0xC1, 0x6D, 0x88, + 0x0A, 0x30, 0x3E, 0xC2, 0x89, 0x72, 0x32, 0xEF, + 0x77, 0xD6, 0xD2, 0x1D, 0x0B, 0x9E, 0xD5, 0x74, + 0x95, 0xDC, 0xE3, 0x38, 0x28, 0x8E, 0x1F, 0x4C, + 0x8E, 0xBB, 0x8F, 0xF0, 0x81, 0x50, 0x0A, 0x18, + 0xBC, 0x06, 0x79, 0xB1, 0xB2, 0xBA, 0x8E, 0x8A + }, + { + 0x2A, 0x69, 0x10, 0xD7, 0xC4, 0x60, 0x48, 0xFD, + 0x0D, 0x72, 0x7F, 0x9A, 0xDC, 0x03, 0xB0, 0x9C, + 0x9B, 0x20, 0x12, 0x69, 0x38, 0x2C, 0xF2, 0x8D, + 0x7A, 0x18, 0xE5, 0xAC, 0x43, 0x09, 0xE3, 0xCA, + 0xC0, 0x7D, 0x6B, 0x96, 0xC3, 0xF7, 0x89, 0x47, + 0x6C, 0x1E, 0x86, 0xBB, 0x88, 0x02, 0x8B, 0x12, + 0x9F, 0xD6, 0x4C, 0x4D, 0xD5, 0xDA, 0x38, 0xA4, + 0xD4, 0x58, 0x89, 0x6B, 0xB6, 0x85, 0x4D, 0x7E + }, + { + 0xE7, 0x2D, 0x3B, 0x8A, 0xB5, 0xB2, 0xB1, 0xE1, + 0x9E, 0x9C, 0x32, 0x8B, 0xED, 0x1F, 0x0C, 0x7D, + 0x10, 0x7D, 0xBC, 0xA2, 0x67, 0xA5, 0xC3, 0xDA, + 0x7C, 0x31, 0x06, 0xAF, 0xEC, 0xF0, 0x9D, 0xDB, + 0x9C, 0x52, 0x98, 0x2B, 0x83, 0xC9, 0xEA, 0x34, + 0x24, 0xCB, 0x33, 0x28, 0x6C, 0x80, 0x3B, 0x99, + 0x89, 0xFE, 0xBA, 0x0A, 0xDB, 0xF8, 0x62, 0x4A, + 0xAD, 0xFF, 0xEB, 0x75, 0xE6, 0x7A, 0x75, 0x81 + }, + { + 0xD0, 0x61, 0xEB, 0x1B, 0x08, 0xEF, 0xB1, 0xD5, + 0x6E, 0xB5, 0xFD, 0x2B, 0xC0, 0xFD, 0xDF, 0xDA, + 0x88, 0x1C, 0xA6, 0x48, 0x1F, 0x48, 0x10, 0x88, + 0x0C, 0xB1, 0x19, 0xEA, 0xEC, 0xFA, 0x84, 0x85, + 0x86, 0x21, 0xE2, 0xD9, 0x70, 0xC7, 0x4C, 0x9B, + 0x3D, 0xA2, 0x8E, 0x6B, 0x40, 0x23, 0xF8, 0xFF, + 0x68, 0xFD, 0x55, 0x1C, 0x45, 0xDD, 0x77, 0xBD, + 0x99, 0x65, 0x10, 0xA8, 0xA6, 0xE5, 0x7E, 0x2B + }, + { + 0xB6, 0x98, 0x9C, 0x7D, 0xFD, 0xCB, 0xC5, 0x05, + 0x56, 0x16, 0xC7, 0xCD, 0x4A, 0x1B, 0x38, 0xD3, + 0xEC, 0x5B, 0x39, 0x06, 0x76, 0x78, 0x12, 0xD8, + 0x5D, 0x6F, 0x2D, 0xDF, 0x90, 0x52, 0x01, 0xC6, + 0x3F, 0x33, 0xFF, 0x89, 0x5C, 0x08, 0x21, 0x8B, + 0x86, 0xA4, 0x9E, 0x29, 0xA0, 0xA9, 0x39, 0x60, + 0x70, 0x7C, 0x32, 0x8A, 0x70, 0x7D, 0x1B, 0xD3, + 0x21, 0x76, 0x67, 0xF5, 0x55, 0x99, 0x61, 0x31 + }, + { + 0x22, 0x34, 0x4B, 0x87, 0xC5, 0xBA, 0xC3, 0x4E, + 0x49, 0x7C, 0xB1, 0x25, 0xCA, 0x03, 0x40, 0x5F, + 0x20, 0xD4, 0x2C, 0x43, 0x0B, 0x43, 0x0E, 0x3A, + 0xE5, 0xD0, 0x91, 0x8A, 0xEB, 0xE9, 0x25, 0xD1, + 0xF9, 0x12, 0xF1, 0xBD, 0x2A, 0xC8, 0xD1, 0x21, + 0xAB, 0x80, 0x8D, 0x10, 0x2A, 0xD8, 0xA1, 0x5C, + 0x27, 0x16, 0x49, 0xC5, 0x09, 0x9F, 0x8F, 0xBD, + 0x19, 0x42, 0x73, 0x58, 0xC2, 0xA6, 0xE1, 0x69 + }, + { + 0x8C, 0xA7, 0xC0, 0x3D, 0x08, 0x12, 0x07, 0x6D, + 0xE5, 0x32, 0x58, 0x70, 0xFF, 0x79, 0x8A, 0x93, + 0x8F, 0x8F, 0xDA, 0xFF, 0x9D, 0x9A, 0x21, 0x6A, + 0xE0, 0xF7, 0x83, 0x17, 0xC0, 0xFF, 0xC5, 0x38, + 0x14, 0xCB, 0x06, 0x26, 0xA5, 0xD4, 0x8C, 0x33, + 0xCE, 0x41, 0x08, 0xDA, 0x50, 0x1B, 0xC5, 0x00, + 0xD6, 0x98, 0x3A, 0x5A, 0x28, 0xBD, 0x4D, 0xDD, + 0x0A, 0x7C, 0x1A, 0xA5, 0xD8, 0x26, 0x41, 0x08 + }, + { + 0x24, 0x05, 0xCC, 0xCF, 0xCA, 0xD1, 0x3C, 0x00, + 0x5F, 0xC1, 0x5C, 0xDF, 0x9C, 0x5E, 0xC2, 0x52, + 0x6D, 0x2E, 0x00, 0xA4, 0x98, 0x3A, 0x59, 0x41, + 0x0B, 0x21, 0x3C, 0x51, 0x9E, 0x5C, 0x9B, 0x7A, + 0xD2, 0xDA, 0x0E, 0x1B, 0x52, 0x10, 0xE1, 0xF9, + 0xB1, 0x05, 0x84, 0xA2, 0xB0, 0x8F, 0x4B, 0x32, + 0xBD, 0x47, 0x1A, 0xA7, 0x59, 0x65, 0x69, 0x9D, + 0x62, 0xCC, 0x56, 0xAE, 0x8C, 0xFC, 0xFE, 0xBA + }, + { + 0xE8, 0x23, 0x40, 0x6C, 0x47, 0x2B, 0xA9, 0x26, + 0x90, 0x7C, 0x50, 0xB5, 0x4C, 0x34, 0xB9, 0xC1, + 0x7A, 0xD4, 0x50, 0x32, 0xC4, 0xA8, 0x5E, 0xBB, + 0x81, 0xFE, 0x46, 0x42, 0x75, 0xBD, 0x42, 0x66, + 0x57, 0x37, 0xC4, 0xF6, 0x58, 0x53, 0x49, 0x27, + 0x4B, 0x15, 0x40, 0x16, 0x15, 0xE5, 0x0A, 0xCC, + 0x48, 0xF5, 0xCD, 0xE7, 0x0E, 0x49, 0xC2, 0xAF, + 0x47, 0x0C, 0x82, 0x49, 0x58, 0x92, 0x65, 0xCF + }, + { + 0x71, 0x33, 0x5A, 0xA4, 0x4B, 0x41, 0x5F, 0x13, + 0xE2, 0x5E, 0xED, 0x98, 0x27, 0x81, 0xAE, 0xA6, + 0x0F, 0xF0, 0xC2, 0x83, 0x23, 0xE6, 0x43, 0xFB, + 0x2E, 0x29, 0xE9, 0x8E, 0x90, 0xEE, 0x6B, 0x46, + 0x36, 0x3B, 0x93, 0xEE, 0xDE, 0x59, 0x6B, 0x49, + 0x31, 0xA4, 0x89, 0xA8, 0x6E, 0x6C, 0x18, 0x59, + 0xCE, 0x01, 0x55, 0xDD, 0xD5, 0x0C, 0xAE, 0xEF, + 0xA3, 0x3B, 0x49, 0x9D, 0x95, 0xC2, 0x88, 0x6A + }, + { + 0x98, 0x00, 0xC3, 0xBB, 0x41, 0xEB, 0xCE, 0x50, + 0x1D, 0xF8, 0x6A, 0xCC, 0x40, 0xB5, 0x51, 0xDC, + 0xEF, 0xD6, 0xC5, 0x6C, 0xEA, 0x36, 0x51, 0xE6, + 0xB2, 0x9F, 0xA2, 0x9F, 0x25, 0x7A, 0x6B, 0xBF, + 0x1F, 0xED, 0xAA, 0x00, 0x2D, 0x04, 0x3D, 0xE1, + 0xCF, 0x61, 0x63, 0xEE, 0x22, 0x24, 0x7D, 0x2F, + 0x54, 0x46, 0xC0, 0x56, 0xE0, 0x17, 0x9E, 0xB5, + 0xFD, 0xF2, 0x3C, 0x8E, 0xCF, 0xA3, 0x36, 0xB1 + }, + { + 0x99, 0x84, 0xA1, 0x1E, 0xF3, 0xEF, 0x5B, 0x83, + 0x3C, 0x8C, 0x25, 0x3E, 0xD8, 0xC1, 0x50, 0xCE, + 0xBA, 0x48, 0xAC, 0x21, 0x87, 0x07, 0x21, 0x98, + 0x1B, 0xDF, 0x23, 0xF5, 0x59, 0xEC, 0xE1, 0x9E, + 0xA8, 0x08, 0x36, 0x02, 0x79, 0xBD, 0x4A, 0xA0, + 0xDD, 0xA2, 0x92, 0xF6, 0x25, 0xA8, 0x3B, 0x9D, + 0x76, 0x1D, 0x46, 0x51, 0xA0, 0x9B, 0xCA, 0x81, + 0x4B, 0x71, 0xAD, 0xDD, 0x3E, 0x8F, 0x31, 0x7B + }, + { + 0xE6, 0xF5, 0x68, 0xA3, 0x4B, 0x27, 0xD1, 0x1F, + 0xA1, 0x70, 0x75, 0x80, 0x59, 0xAF, 0x76, 0xA6, + 0x7A, 0x42, 0x49, 0xED, 0x2B, 0x57, 0x1B, 0xF0, + 0xD4, 0xB7, 0x0A, 0xC8, 0x05, 0x8C, 0xEA, 0xCE, + 0xDE, 0x63, 0x7B, 0x16, 0x8A, 0x23, 0x2E, 0xC2, + 0xB3, 0xFB, 0x38, 0xB4, 0x09, 0x5A, 0xBC, 0x30, + 0x5A, 0x9D, 0xFC, 0xED, 0xBC, 0xEE, 0xDF, 0x00, + 0xD3, 0x00, 0xFF, 0xA2, 0x0A, 0x6F, 0x96, 0x25 + }, + { + 0x83, 0xD4, 0x3B, 0xD2, 0x4C, 0xF4, 0x98, 0x94, + 0xD8, 0x44, 0x57, 0x94, 0x89, 0x57, 0x33, 0x94, + 0x84, 0x8C, 0x27, 0xE5, 0x80, 0xBC, 0xCE, 0x40, + 0x23, 0x01, 0x74, 0xDC, 0x55, 0xB0, 0x2D, 0x72, + 0xA4, 0x37, 0xAF, 0xE0, 0x54, 0x53, 0x38, 0x47, + 0xCC, 0x68, 0xDB, 0x3E, 0x02, 0x9C, 0x21, 0x2B, + 0xDC, 0x30, 0xFA, 0x73, 0x42, 0x33, 0xD7, 0x79, + 0xEE, 0xD5, 0xD5, 0x3F, 0xAA, 0x82, 0x4F, 0x4C + }, + { + 0x62, 0x29, 0xD1, 0x33, 0x0B, 0xF2, 0x32, 0x7D, + 0x5D, 0x00, 0x5B, 0x40, 0x41, 0x02, 0xEB, 0xFD, + 0xED, 0xD4, 0x0F, 0x51, 0x92, 0x23, 0xCD, 0x54, + 0x42, 0x8E, 0x86, 0x3E, 0xA0, 0x5B, 0x97, 0x4F, + 0xCE, 0x1C, 0x72, 0xCA, 0xFB, 0xD8, 0x8E, 0xCA, + 0xB0, 0xFD, 0xAF, 0xE4, 0x3D, 0x6C, 0xD9, 0x9A, + 0x26, 0x8B, 0xEF, 0xAE, 0xA0, 0x7D, 0x6F, 0xCD, + 0x42, 0x97, 0x8E, 0x01, 0x79, 0x89, 0x01, 0x23 + }, + { + 0x62, 0xA9, 0x1D, 0xA2, 0x39, 0x80, 0x41, 0x9E, + 0xF7, 0xDD, 0x67, 0xB8, 0x4D, 0x36, 0x4E, 0x47, + 0x3B, 0x02, 0x69, 0xF5, 0x67, 0x68, 0x45, 0x80, + 0xB9, 0xF6, 0x97, 0x40, 0xEE, 0x18, 0xA0, 0xEB, + 0xDB, 0x36, 0x41, 0xEF, 0x24, 0x3A, 0xD4, 0x16, + 0xAB, 0x78, 0xFD, 0xD9, 0x79, 0x5E, 0xFB, 0x5B, + 0xD8, 0xD1, 0xCE, 0xDF, 0xA1, 0xE8, 0x99, 0x9D, + 0xDD, 0x01, 0x21, 0x7F, 0x51, 0xCF, 0xB3, 0x4E + }, + { + 0x33, 0x3B, 0xCA, 0x99, 0x4D, 0x2C, 0xF7, 0x14, + 0x1B, 0xEA, 0x09, 0xA4, 0x44, 0xC8, 0x2F, 0x7C, + 0xCC, 0xC0, 0xC8, 0x90, 0x82, 0x27, 0x68, 0xBD, + 0xC0, 0x16, 0xA4, 0xA3, 0x6E, 0xDB, 0xCA, 0xAA, + 0x02, 0x49, 0x33, 0x71, 0xFD, 0x04, 0xE3, 0x05, + 0x15, 0x38, 0xE7, 0x30, 0x68, 0x1E, 0xBB, 0x0F, + 0xAA, 0xEB, 0xCC, 0x24, 0x19, 0x0C, 0x4B, 0x15, + 0x07, 0x6A, 0x09, 0xFE, 0x4D, 0x1A, 0x3B, 0x36 + }, + { + 0x9B, 0xB0, 0xCC, 0xD8, 0x58, 0x5C, 0x34, 0x20, + 0x8F, 0x59, 0x48, 0x84, 0xC9, 0x71, 0x97, 0x97, + 0x70, 0xF4, 0x43, 0x11, 0x20, 0xFE, 0xC6, 0x39, + 0xE4, 0x6C, 0x2B, 0xD6, 0xCF, 0xAA, 0xE0, 0xD3, + 0x17, 0xA9, 0xF2, 0xBA, 0x13, 0x22, 0x71, 0xA5, + 0x88, 0x49, 0xDC, 0x9B, 0x76, 0x05, 0x0F, 0xC6, + 0xB7, 0x37, 0x16, 0xF8, 0x50, 0xAC, 0xA0, 0xD8, + 0x54, 0xA4, 0x49, 0x47, 0xA4, 0xCA, 0x97, 0xED + }, + { + 0xAC, 0x69, 0xEE, 0xA9, 0x0F, 0x0B, 0x94, 0x0B, + 0x41, 0xA5, 0xFF, 0xF0, 0x54, 0xDD, 0x4F, 0x2E, + 0x4F, 0xE1, 0xDF, 0x92, 0x29, 0x2A, 0x95, 0x5B, + 0xF1, 0x2B, 0x57, 0x31, 0x84, 0x52, 0xCA, 0x38, + 0xE5, 0xAD, 0xCE, 0x72, 0x64, 0x3D, 0x77, 0xB1, + 0xA4, 0x98, 0xC7, 0x67, 0xE3, 0xBF, 0x92, 0x38, + 0x7D, 0xB1, 0x85, 0x40, 0x3C, 0xE9, 0xA5, 0x67, + 0x8E, 0x18, 0xDA, 0xE1, 0xA8, 0x63, 0x39, 0xDE + }, + { + 0x57, 0x13, 0xA1, 0xB9, 0x29, 0xFC, 0x57, 0xD4, + 0x8D, 0xFA, 0x68, 0x54, 0x92, 0xC1, 0xEB, 0x2B, + 0xE1, 0xAC, 0x6E, 0xC1, 0xE1, 0xB8, 0xB8, 0xA7, + 0x9E, 0xDC, 0x7A, 0x78, 0x31, 0x77, 0x52, 0x1A, + 0x10, 0x69, 0x07, 0x56, 0xDA, 0xCB, 0xFD, 0xDE, + 0x50, 0x2C, 0xA3, 0x78, 0x44, 0xB0, 0x03, 0x04, + 0x05, 0x19, 0xC8, 0x30, 0xB4, 0xC1, 0x07, 0x13, + 0xDF, 0xE1, 0x0D, 0x38, 0x26, 0xB3, 0x0D, 0x5B + }, + { + 0x7B, 0x13, 0x24, 0x01, 0x0D, 0xAC, 0x93, 0xBE, + 0x15, 0xE4, 0x1D, 0xBE, 0xC1, 0x8F, 0x74, 0xF5, + 0xC3, 0x93, 0x39, 0x98, 0x48, 0xC1, 0x26, 0x3F, + 0x18, 0x9D, 0x7B, 0xFD, 0xEB, 0xC5, 0x4E, 0xDF, + 0x76, 0x64, 0x3E, 0x4E, 0xDE, 0x13, 0xF6, 0xB0, + 0x4C, 0xB5, 0x31, 0x5D, 0x4B, 0xE4, 0x44, 0xCE, + 0xF4, 0x56, 0xF0, 0xF8, 0xF4, 0x96, 0x51, 0x72, + 0x20, 0xB0, 0x44, 0x09, 0xEC, 0xEC, 0x2A, 0x53 + }, + { + 0x04, 0x43, 0x83, 0xD4, 0x2B, 0xE9, 0x16, 0x6C, + 0x6D, 0x4C, 0x53, 0xBB, 0x16, 0x7F, 0x67, 0xFA, + 0x8B, 0xA9, 0xDF, 0x01, 0x58, 0xEF, 0x7C, 0xA6, + 0x79, 0xBC, 0xF8, 0x2C, 0x9A, 0x68, 0xE0, 0x0B, + 0x6B, 0x8D, 0x82, 0x10, 0x6F, 0x03, 0xB2, 0xEC, + 0xF0, 0xE7, 0x1C, 0x78, 0xF2, 0xB8, 0x03, 0xFE, + 0xE4, 0xD5, 0x1A, 0x8D, 0xD2, 0xFE, 0xD5, 0xD6, + 0xDC, 0x0C, 0x22, 0x50, 0x96, 0xD6, 0x7A, 0x86 + }, + { + 0x04, 0x56, 0x14, 0xE4, 0x07, 0xB6, 0x17, 0x41, + 0x32, 0x04, 0x96, 0xF8, 0x79, 0x6F, 0xD0, 0xF3, + 0xF0, 0x51, 0xF3, 0x51, 0x1B, 0x48, 0x0C, 0x01, + 0xB2, 0x48, 0x27, 0x61, 0x21, 0x42, 0x7E, 0x35, + 0xEE, 0x4B, 0xFE, 0x9A, 0x89, 0xC6, 0x7D, 0xAA, + 0x42, 0x34, 0xEE, 0xD7, 0x32, 0x4C, 0x51, 0xA2, + 0x26, 0xC6, 0xAE, 0x33, 0x7B, 0xB2, 0xDD, 0xCC, + 0xDE, 0xA6, 0x38, 0xEB, 0x95, 0xCF, 0x75, 0x2E + }, + { + 0x6D, 0x3A, 0x28, 0x57, 0x8E, 0xC2, 0xE1, 0xEB, + 0x50, 0x2B, 0x35, 0xC0, 0x41, 0x3C, 0xB7, 0x38, + 0x72, 0xE2, 0x55, 0xE2, 0xF4, 0xCE, 0xC8, 0x51, + 0x83, 0xAF, 0xDC, 0x48, 0xC0, 0xAE, 0x3E, 0x3B, + 0xB4, 0xED, 0x47, 0xCD, 0x07, 0x6D, 0x1C, 0xF3, + 0x6C, 0x2F, 0x27, 0x19, 0x2D, 0xC8, 0xE7, 0xD3, + 0x2C, 0x06, 0x3C, 0x4C, 0xA3, 0x11, 0x7F, 0x91, + 0x74, 0x59, 0x2E, 0xB4, 0x26, 0x42, 0xD0, 0x45 + }, + { + 0x11, 0x8E, 0x9C, 0x89, 0xD8, 0xA9, 0x57, 0x71, + 0x4F, 0x76, 0xB3, 0xA8, 0x23, 0x32, 0x3B, 0xAF, + 0xBA, 0xFC, 0x90, 0x61, 0x4E, 0xDE, 0x08, 0xCD, + 0xB1, 0x8B, 0xC9, 0x9A, 0xB7, 0x8D, 0xC8, 0x81, + 0xA4, 0x94, 0xF2, 0x4D, 0xF7, 0xD1, 0x3A, 0x7C, + 0xED, 0xAE, 0xFB, 0x0F, 0x2A, 0xF6, 0xD0, 0x74, + 0xE6, 0x48, 0x64, 0x96, 0xD6, 0x13, 0xE1, 0xE4, + 0x7B, 0xE5, 0xDB, 0x1B, 0xD2, 0xCB, 0xA8, 0xA6 + }, + { + 0x4C, 0x20, 0x4E, 0x4D, 0x39, 0x7D, 0x0D, 0xF1, + 0x03, 0x04, 0xE1, 0xBA, 0x53, 0x49, 0x1C, 0xAB, + 0x09, 0xF1, 0xE6, 0x61, 0x99, 0xBA, 0x30, 0x63, + 0xFB, 0x69, 0x66, 0x3D, 0xDC, 0x09, 0xF3, 0x02, + 0xA7, 0xD8, 0x89, 0xC7, 0xFA, 0x51, 0x7F, 0xD8, + 0x23, 0x5D, 0xC1, 0xD6, 0x94, 0x18, 0xC2, 0x26, + 0x73, 0x86, 0x66, 0x6C, 0x36, 0x3B, 0xB0, 0x78, + 0x13, 0x06, 0x74, 0xCA, 0x14, 0x52, 0x1C, 0x6F + }, + { + 0x23, 0x8F, 0xBD, 0x41, 0xB7, 0xEC, 0xA6, 0x49, + 0x5E, 0xCB, 0xE8, 0x5F, 0x75, 0x13, 0xC7, 0x0C, + 0x08, 0xD5, 0x32, 0x9B, 0x60, 0x97, 0xE3, 0xD9, + 0x5F, 0xB1, 0x6D, 0x91, 0x3B, 0x4F, 0x1D, 0x32, + 0x86, 0x94, 0xE5, 0x6D, 0x7A, 0xF2, 0xDD, 0x57, + 0x9C, 0xAE, 0x78, 0xDE, 0x9A, 0x7E, 0x13, 0xB0, + 0xB4, 0x00, 0xAB, 0xA6, 0x76, 0x30, 0xAF, 0x0E, + 0x9D, 0x22, 0x29, 0x75, 0x16, 0xA4, 0x6F, 0x18 + }, + { + 0xA5, 0xFD, 0xC4, 0xE6, 0xDA, 0x4E, 0xB2, 0xF4, + 0x96, 0x9C, 0xC6, 0x46, 0x49, 0xC5, 0x46, 0x9C, + 0x8C, 0x1E, 0x9F, 0x3F, 0x90, 0xA5, 0x2A, 0x53, + 0x91, 0xBB, 0x8C, 0x7D, 0x19, 0x75, 0x49, 0x3F, + 0x88, 0x0A, 0x2E, 0xC5, 0x0F, 0x97, 0xC7, 0x7C, + 0x4E, 0x30, 0x36, 0x8A, 0x28, 0xFD, 0x1D, 0xAA, + 0x94, 0x95, 0x0D, 0x99, 0x9E, 0xF9, 0x86, 0x8D, + 0x8C, 0xF8, 0x22, 0xA6, 0x60, 0xF5, 0x0D, 0x6A + }, + { + 0x4E, 0xCF, 0x67, 0x24, 0xFF, 0xD5, 0x20, 0x6C, + 0xEB, 0x96, 0x2F, 0x44, 0x98, 0xBD, 0x29, 0x4E, + 0xF8, 0x8C, 0x2B, 0xAE, 0x77, 0xD0, 0x08, 0x57, + 0x50, 0x78, 0xCB, 0x81, 0xDF, 0x2C, 0x2C, 0x54, + 0xBC, 0x6F, 0x9A, 0xE7, 0x56, 0x9C, 0x10, 0xFA, + 0xDC, 0xA8, 0x7D, 0xB2, 0x23, 0x86, 0xDC, 0xF2, + 0xF5, 0x3B, 0x73, 0x55, 0x01, 0xF2, 0x45, 0x59, + 0x08, 0xBA, 0xB7, 0x46, 0xAE, 0xFF, 0xC4, 0xA0 + }, + { + 0x43, 0xFD, 0x19, 0x59, 0xC4, 0x37, 0x88, 0x58, + 0xE5, 0xD5, 0xE9, 0x38, 0x6C, 0xF8, 0x26, 0xA1, + 0xAA, 0xB0, 0x74, 0x08, 0x98, 0x96, 0x35, 0x13, + 0x7E, 0x16, 0x6D, 0x0A, 0x30, 0x75, 0xD0, 0x5C, + 0x9A, 0xD9, 0xEB, 0xD1, 0xD1, 0x41, 0x7D, 0x1C, + 0x5B, 0x89, 0xB3, 0x9B, 0xD6, 0xEA, 0x24, 0x60, + 0xA4, 0x14, 0xDA, 0x18, 0x3B, 0x87, 0x03, 0xF8, + 0x6A, 0x90, 0xE8, 0x30, 0x55, 0x65, 0xAC, 0xA2 + }, + { + 0xCD, 0x1F, 0x48, 0xE9, 0x95, 0x00, 0xF7, 0x58, + 0x54, 0xBA, 0x47, 0x1C, 0x68, 0x91, 0x97, 0xCF, + 0x41, 0x15, 0x1F, 0x31, 0xFB, 0x9A, 0xBC, 0xCD, + 0x98, 0x1D, 0xEB, 0x8A, 0x31, 0x76, 0x9D, 0xBC, + 0x7D, 0x86, 0x95, 0xD5, 0x44, 0x22, 0xFC, 0xFA, + 0xDA, 0x86, 0xD6, 0x14, 0xDC, 0x1B, 0x4D, 0xC6, + 0xEB, 0x96, 0x7E, 0x4D, 0xC8, 0xBC, 0xFA, 0xFA, + 0x39, 0xFD, 0x9E, 0x87, 0x54, 0xD7, 0xEE, 0xD3 + }, + { + 0xAC, 0x03, 0xB8, 0x0E, 0x5E, 0xFD, 0x49, 0x17, + 0x55, 0xF8, 0x4D, 0xC9, 0xB9, 0x62, 0xBE, 0x8D, + 0x39, 0x18, 0x3D, 0xC2, 0xFC, 0x74, 0x77, 0xB9, + 0x4D, 0xF0, 0x0A, 0x40, 0x93, 0xA5, 0x1B, 0x48, + 0xE7, 0x46, 0x75, 0xFC, 0x00, 0xD1, 0x82, 0x0E, + 0xE0, 0xE4, 0xA2, 0x04, 0x94, 0x6A, 0x32, 0xB3, + 0x11, 0x95, 0x67, 0xFD, 0xD7, 0x93, 0xF7, 0x07, + 0x97, 0x72, 0x7D, 0xF1, 0xAB, 0xD7, 0x52, 0xB7 + }, + { + 0x41, 0xEA, 0xF5, 0x2A, 0x4E, 0x2A, 0x07, 0x74, + 0xFF, 0x2B, 0x57, 0x29, 0x46, 0x7B, 0xAA, 0x82, + 0x72, 0x30, 0x01, 0xE8, 0xB6, 0xBB, 0x27, 0x62, + 0xDB, 0xD5, 0x53, 0xC3, 0xA8, 0x15, 0xAB, 0x42, + 0xD3, 0xC3, 0x94, 0x39, 0x7D, 0x72, 0xDC, 0x14, + 0xC6, 0x70, 0xFA, 0xA2, 0x5B, 0xF8, 0x90, 0x73, + 0xF5, 0x92, 0xE7, 0xDF, 0xEA, 0xED, 0x58, 0x1A, + 0x8B, 0x04, 0x5B, 0x00, 0x0C, 0xEE, 0xE9, 0x2D + }, + { + 0x62, 0x3E, 0x7C, 0x15, 0xC1, 0xE3, 0x08, 0x9B, + 0xBB, 0x11, 0xAB, 0xC8, 0xD7, 0xB1, 0xFF, 0xFC, + 0xA0, 0xEE, 0xB0, 0x13, 0xA5, 0xBC, 0x8F, 0xAB, + 0x5B, 0x31, 0x7F, 0xC4, 0xE3, 0x8E, 0xB3, 0xB8, + 0xCD, 0x7B, 0xFE, 0x06, 0x52, 0xB8, 0xAE, 0xE0, + 0xF1, 0x09, 0xAA, 0x75, 0xFE, 0x7E, 0x99, 0x51, + 0x62, 0xA6, 0x4D, 0x55, 0x6B, 0xA7, 0x19, 0xAF, + 0x68, 0xAE, 0xB3, 0xE6, 0xEF, 0xBE, 0x24, 0x75 + }, + { + 0x12, 0x78, 0x2C, 0x64, 0x51, 0x0D, 0xAE, 0xDF, + 0xDF, 0xF5, 0x8E, 0x0A, 0x73, 0xC7, 0xE6, 0x35, + 0x24, 0x53, 0x6B, 0x09, 0x33, 0xAD, 0xCA, 0x98, + 0xDE, 0x61, 0x36, 0xEB, 0x41, 0x3E, 0x24, 0xEE, + 0x49, 0xF2, 0x6E, 0xEC, 0x7B, 0xC1, 0x34, 0xDB, + 0x18, 0x9F, 0xF4, 0x49, 0xE6, 0xB6, 0x98, 0x97, + 0x02, 0xE1, 0x02, 0xD5, 0x4A, 0x38, 0xD5, 0xF9, + 0x3D, 0x7E, 0x06, 0x15, 0x9A, 0xA9, 0x5C, 0x2E + }, + { + 0x12, 0x73, 0xDA, 0x31, 0x28, 0x04, 0x2F, 0xBF, + 0x00, 0xAB, 0x92, 0x60, 0x5D, 0xFF, 0x07, 0xF7, + 0xA8, 0xEC, 0x2F, 0x95, 0xCA, 0xC1, 0xED, 0xE5, + 0x07, 0xF0, 0x01, 0xCC, 0xE9, 0x78, 0xB0, 0xBD, + 0x0D, 0x90, 0x23, 0xBE, 0x5E, 0x3F, 0xBD, 0xEE, + 0x8E, 0x21, 0xC0, 0xAC, 0xB5, 0xF6, 0x2F, 0x00, + 0x67, 0xF6, 0x4D, 0x3E, 0x28, 0x25, 0x9D, 0x1C, + 0x3A, 0xBE, 0x58, 0xD8, 0x43, 0x0D, 0x41, 0xB2 + }, + { + 0x31, 0x3A, 0x2B, 0x22, 0x70, 0xEA, 0x5D, 0xF4, + 0x24, 0x12, 0x8F, 0xBF, 0xFA, 0x1C, 0x94, 0x35, + 0xD1, 0x2E, 0x74, 0xB6, 0x48, 0xDA, 0x34, 0xF7, + 0x58, 0xA6, 0x8C, 0x10, 0xA9, 0xED, 0x57, 0x24, + 0x5E, 0x00, 0x3D, 0x99, 0x3C, 0xDB, 0x82, 0xD9, + 0x44, 0x0B, 0x72, 0x71, 0x82, 0xB9, 0xB9, 0x2D, + 0x42, 0xD1, 0x3A, 0xFE, 0x0E, 0xEE, 0xC9, 0xD9, + 0x4A, 0x57, 0x2F, 0x34, 0xBC, 0xDC, 0x87, 0xA4 + }, + { + 0xF5, 0xF4, 0x67, 0x65, 0x82, 0x3E, 0xB5, 0x93, + 0x54, 0x54, 0x23, 0x89, 0xBA, 0xE0, 0x2C, 0xD8, + 0x25, 0xE3, 0xD9, 0x8C, 0x65, 0x56, 0xAE, 0x07, + 0x86, 0x47, 0x2F, 0xF0, 0x88, 0x2D, 0xE0, 0xA6, + 0x27, 0xAB, 0x78, 0x98, 0xDF, 0x58, 0x89, 0x70, + 0xDB, 0x27, 0x68, 0xEB, 0xE4, 0xAB, 0xBB, 0xD5, + 0xAE, 0x0C, 0x22, 0x71, 0xDB, 0x96, 0xDA, 0x2C, + 0xD1, 0x4A, 0xD6, 0x3D, 0xB1, 0x88, 0x4E, 0x35 + }, + { + 0xA2, 0x3E, 0x25, 0xCF, 0x78, 0xAE, 0x80, 0x1D, + 0xFE, 0xA8, 0x98, 0x82, 0x89, 0xF8, 0x98, 0x72, + 0x61, 0x7E, 0x20, 0xF4, 0x65, 0x8C, 0x72, 0x8E, + 0x1C, 0x12, 0xAB, 0x26, 0xA7, 0x11, 0x08, 0x7E, + 0xB7, 0x35, 0xB1, 0x2A, 0x27, 0xE5, 0x0A, 0x6F, + 0xC7, 0xBF, 0xC6, 0x54, 0x24, 0xA9, 0x1D, 0xA4, + 0x9E, 0x5B, 0x73, 0xD9, 0x80, 0x1F, 0xF2, 0xE1, + 0x73, 0xB5, 0x73, 0xF1, 0x4C, 0x53, 0xA5, 0x4F + }, + { + 0xBE, 0x14, 0xF1, 0x97, 0xA7, 0x64, 0x67, 0x00, + 0x45, 0x5A, 0x56, 0x29, 0x58, 0xE5, 0x78, 0xA8, + 0x23, 0xE4, 0x91, 0x94, 0x5C, 0xD3, 0xFB, 0xE8, + 0x19, 0xD7, 0x6A, 0x8C, 0xC8, 0x47, 0xD8, 0x91, + 0x04, 0xC2, 0x74, 0x72, 0xE5, 0xF9, 0x08, 0x6E, + 0xEC, 0xF4, 0x82, 0xC6, 0xFA, 0xC3, 0x1A, 0x78, + 0x9A, 0x1F, 0xBE, 0xF2, 0xCF, 0x9F, 0x6F, 0x15, + 0x46, 0x6B, 0x5D, 0xD6, 0x9C, 0x08, 0xA6, 0x64 + }, + { + 0x5A, 0xB6, 0x61, 0xFF, 0x03, 0xA4, 0xD5, 0x77, + 0x82, 0x05, 0xA2, 0xF1, 0x0C, 0x83, 0x3B, 0x68, + 0x62, 0xA3, 0x8F, 0x13, 0xD3, 0x83, 0x4E, 0xC3, + 0xAA, 0x5B, 0x08, 0x3B, 0xA5, 0x34, 0x45, 0x2E, + 0xCB, 0x0D, 0x5B, 0x24, 0x2A, 0x8F, 0xCF, 0x76, + 0x39, 0x78, 0x6F, 0xA6, 0x26, 0x60, 0xC2, 0xFC, + 0xD7, 0x3A, 0x25, 0xFA, 0x9D, 0x7B, 0x6C, 0xA3, + 0xD9, 0xCF, 0xBC, 0xAD, 0xBD, 0x29, 0xE7, 0xA4 + }, + { + 0x21, 0x3D, 0x0C, 0xEE, 0xB2, 0x5E, 0x47, 0x01, + 0xA0, 0x61, 0x2D, 0xA1, 0x2A, 0xE4, 0x97, 0xE2, + 0x42, 0x87, 0xD6, 0x04, 0x38, 0x24, 0xBB, 0xD1, + 0xB3, 0x4D, 0x4E, 0x37, 0x01, 0x38, 0x4A, 0x16, + 0xC3, 0x82, 0xF0, 0x1B, 0x80, 0x83, 0x61, 0x19, + 0x51, 0xA2, 0xF5, 0x46, 0xFD, 0x55, 0x39, 0x67, + 0x42, 0x7C, 0x36, 0xA7, 0xD7, 0xF5, 0x18, 0xB2, + 0x33, 0x7F, 0x21, 0x76, 0x95, 0x06, 0x45, 0x73 + }, + { + 0x11, 0x3B, 0xDE, 0x5C, 0xB6, 0x3B, 0x1C, 0x45, + 0xCA, 0x3F, 0xB7, 0x1C, 0xF8, 0xC2, 0x09, 0x17, + 0x6B, 0x0C, 0x99, 0xA4, 0xD4, 0x41, 0x1B, 0x73, + 0x4C, 0x0B, 0x3F, 0x0D, 0xA7, 0x71, 0x96, 0xEF, + 0xFC, 0x50, 0xFA, 0x30, 0xFC, 0x3B, 0xD0, 0xD0, + 0x2A, 0x72, 0xF9, 0x19, 0x1C, 0x03, 0x16, 0x3B, + 0xAE, 0x15, 0x26, 0x91, 0x04, 0xE9, 0xB3, 0x9E, + 0xA5, 0x90, 0x2A, 0xF0, 0x45, 0xEE, 0x2F, 0xE6 + }, + { + 0x85, 0xDD, 0x6E, 0xE6, 0x16, 0x7D, 0x8D, 0xB5, + 0x32, 0x2D, 0xC8, 0x53, 0x2E, 0x5A, 0x4D, 0xF6, + 0x4D, 0x3E, 0x7C, 0x9D, 0x21, 0xE9, 0x55, 0x8C, + 0x83, 0xD1, 0x15, 0xAC, 0xAA, 0xA2, 0x31, 0x24, + 0xED, 0xD2, 0x5A, 0xF5, 0xCF, 0xE2, 0x5D, 0x31, + 0xEF, 0xB0, 0x8D, 0xEE, 0x56, 0x93, 0x9A, 0x40, + 0x12, 0xC3, 0x77, 0xC0, 0x52, 0x16, 0x78, 0x81, + 0x77, 0x42, 0x89, 0x7F, 0xA9, 0x35, 0x0A, 0x58 + }, + { + 0x1B, 0xD7, 0x3E, 0x14, 0x85, 0xBD, 0x4F, 0x65, + 0x17, 0x70, 0xF1, 0x9B, 0x69, 0x4C, 0x7E, 0xA1, + 0x8A, 0x22, 0x45, 0x12, 0x7A, 0xE4, 0x8A, 0x16, + 0xA3, 0xBD, 0xA9, 0xE9, 0x81, 0x8A, 0xF5, 0x8A, + 0x20, 0xD2, 0xC8, 0xBC, 0x7F, 0xAA, 0x32, 0x16, + 0x4E, 0xEB, 0x41, 0x1D, 0x56, 0x81, 0x1E, 0x8A, + 0x73, 0x56, 0x26, 0x6F, 0xF4, 0x99, 0x2B, 0x12, + 0x34, 0xD3, 0xAE, 0x6E, 0xF4, 0xC2, 0x0D, 0x82 + }, + { + 0xBC, 0xD7, 0x49, 0xFB, 0x79, 0xBF, 0x78, 0x91, + 0xA0, 0x79, 0xE4, 0x81, 0x5E, 0x3C, 0xE6, 0xDD, + 0xC0, 0xFD, 0x0B, 0x35, 0x02, 0x47, 0x5D, 0x34, + 0xF8, 0xAD, 0x23, 0x7C, 0x68, 0x85, 0x5C, 0x92, + 0x22, 0x8A, 0xA7, 0x57, 0xE0, 0x6E, 0xB9, 0x4D, + 0x49, 0xC5, 0xFB, 0x2F, 0x48, 0x3C, 0x58, 0xAC, + 0x33, 0xB1, 0x37, 0x65, 0x19, 0x0F, 0x2A, 0x33, + 0xE2, 0x38, 0x7A, 0x72, 0xBA, 0x90, 0x0A, 0xF7 + }, + { + 0xA5, 0xED, 0x21, 0x68, 0x74, 0xC2, 0x33, 0x63, + 0xA4, 0x65, 0x49, 0xB2, 0x4A, 0xF1, 0x62, 0x61, + 0x7A, 0x15, 0x2D, 0xE5, 0x15, 0x1F, 0x17, 0x9D, + 0xA3, 0xD2, 0x11, 0x01, 0x6C, 0xAD, 0x8D, 0x22, + 0x3A, 0x63, 0x78, 0xAD, 0x9F, 0x9D, 0x6B, 0x7F, + 0xBE, 0x47, 0xB9, 0x38, 0x61, 0x47, 0x56, 0x63, + 0x4F, 0x2A, 0x49, 0x4B, 0x56, 0x2B, 0x99, 0x15, + 0xC4, 0x65, 0x9F, 0xFE, 0xA3, 0x36, 0xBC, 0x79 + }, + { + 0x0B, 0x21, 0x89, 0x9A, 0xCA, 0x1B, 0xC8, 0x1E, + 0x59, 0xEE, 0x8A, 0x15, 0x38, 0x2D, 0x02, 0x91, + 0x3B, 0x97, 0x67, 0xC3, 0x0E, 0x3C, 0x52, 0xC5, + 0x50, 0x03, 0xDB, 0x82, 0x13, 0x06, 0x00, 0x00, + 0x3D, 0xD4, 0x2E, 0x11, 0x5F, 0xC8, 0x44, 0x4C, + 0xE4, 0x43, 0xD2, 0x7C, 0x58, 0x9C, 0x40, 0x23, + 0x5D, 0x0D, 0x29, 0x3F, 0x12, 0xB0, 0xE2, 0x21, + 0x54, 0x59, 0x1C, 0x6F, 0x62, 0xEF, 0x5C, 0x47 + }, + { + 0x1B, 0x89, 0x58, 0x68, 0x86, 0x93, 0xB8, 0x4D, + 0xF8, 0x7C, 0xA8, 0xCF, 0xE6, 0x23, 0x3A, 0x40, + 0x07, 0x03, 0x9B, 0x44, 0x26, 0xD6, 0xA1, 0x41, + 0xD7, 0x21, 0x27, 0x4C, 0xA5, 0x9A, 0x02, 0x7E, + 0x84, 0x99, 0x8A, 0x0A, 0x8B, 0x72, 0xD2, 0xB1, + 0x3A, 0xA3, 0xB8, 0x66, 0x73, 0x3F, 0x1E, 0xBE, + 0xF0, 0x13, 0xBD, 0x18, 0xD0, 0x5A, 0x01, 0xD9, + 0xA4, 0x94, 0x51, 0x1D, 0x81, 0x35, 0x5F, 0x1B + }, + { + 0x22, 0x29, 0x45, 0xAB, 0x39, 0x73, 0x27, 0xF6, + 0xC8, 0x17, 0x87, 0x87, 0x0F, 0xE3, 0x87, 0x67, + 0x2D, 0x8B, 0x8B, 0xD8, 0x1E, 0xBA, 0x96, 0x6E, + 0xF7, 0x87, 0xF4, 0x2A, 0x80, 0x0B, 0xE4, 0x5E, + 0xEC, 0xB4, 0xAB, 0xA3, 0x56, 0xF9, 0x18, 0x6C, + 0x3F, 0x3B, 0xB3, 0x80, 0xD0, 0xCB, 0xB2, 0x26, + 0x2E, 0x98, 0xE4, 0x70, 0xF2, 0x7F, 0x08, 0x1E, + 0x11, 0xB0, 0x22, 0x03, 0xC9, 0x67, 0x63, 0xE5 + }, + { + 0xC8, 0x9A, 0x48, 0xF6, 0x29, 0xFF, 0xCC, 0xDE, + 0x9A, 0x33, 0x68, 0x39, 0x0D, 0xBC, 0x11, 0x97, + 0x20, 0x87, 0x33, 0x94, 0x40, 0xEC, 0x3B, 0xF5, + 0x42, 0xF3, 0x24, 0x70, 0x2F, 0x00, 0xB5, 0x73, + 0x16, 0x16, 0xAB, 0x3B, 0xF1, 0x93, 0x3E, 0xCE, + 0x2C, 0x34, 0x3D, 0x1C, 0xFF, 0xA1, 0x99, 0x2D, + 0xC0, 0xA5, 0x06, 0x80, 0xAA, 0x07, 0xF2, 0x74, + 0x22, 0x3B, 0x02, 0x9B, 0x18, 0x9F, 0xBA, 0xEA + }, + { + 0x16, 0xB1, 0xCF, 0x3D, 0x23, 0xF4, 0xB0, 0x2B, + 0x4C, 0xC7, 0xF7, 0x81, 0x54, 0xC9, 0x89, 0xC0, + 0x1C, 0xFB, 0xCC, 0xA3, 0x33, 0x23, 0x91, 0x9E, + 0x04, 0x49, 0xB7, 0x7B, 0xD5, 0xD1, 0x08, 0xAC, + 0xA5, 0x6F, 0xB1, 0x27, 0x44, 0xF5, 0x4A, 0xC3, + 0x8A, 0xF2, 0xB7, 0x0B, 0xC9, 0x4E, 0x86, 0x73, + 0x91, 0xE6, 0x05, 0x2D, 0x3A, 0x39, 0x9C, 0x19, + 0xD2, 0xFD, 0x55, 0xF5, 0x65, 0x6E, 0xB8, 0x03 + }, + { + 0x0E, 0xD3, 0xFE, 0x31, 0x71, 0xB9, 0x23, 0x5A, + 0x4D, 0x1C, 0x4B, 0x77, 0x24, 0x84, 0x0D, 0x65, + 0x3D, 0x0A, 0xD0, 0x01, 0x81, 0x11, 0x3B, 0x24, + 0xF8, 0x29, 0x65, 0x34, 0x7C, 0x7A, 0x66, 0xE6, + 0xDE, 0xB7, 0x3E, 0x60, 0xC5, 0x9A, 0x1D, 0x4B, + 0x18, 0x29, 0x1D, 0xA2, 0x17, 0x95, 0x6A, 0xB9, + 0x59, 0x0F, 0xBF, 0x58, 0x55, 0x77, 0xC0, 0xF0, + 0x28, 0xC1, 0xB2, 0x89, 0x26, 0xB7, 0xDA, 0xE6 + }, + { + 0x64, 0xE2, 0xC6, 0xC0, 0xA6, 0x10, 0x26, 0x94, + 0xE5, 0x8C, 0x64, 0x77, 0x75, 0x90, 0x58, 0x2A, + 0xD6, 0x2B, 0xB7, 0x68, 0x83, 0x4A, 0x03, 0x5F, + 0x81, 0x97, 0x19, 0x7D, 0xBC, 0x68, 0x55, 0x0E, + 0x5B, 0x2C, 0x93, 0x8B, 0x84, 0x8E, 0xF4, 0x50, + 0xAD, 0xEC, 0xF7, 0x58, 0x8E, 0x36, 0xBE, 0xCE, + 0x4C, 0x20, 0x3E, 0xCC, 0x4A, 0x16, 0xC4, 0x38, + 0x8A, 0xB9, 0x7D, 0x04, 0xCD, 0xC1, 0xDA, 0x1A + }, + { + 0x8F, 0xE2, 0xC9, 0xE4, 0x8E, 0xC9, 0x97, 0x92, + 0xF6, 0xD2, 0x4E, 0xFE, 0x61, 0x4E, 0x2B, 0x88, + 0xD5, 0x02, 0x75, 0xD1, 0xA2, 0xFD, 0x61, 0x0C, + 0xCC, 0xF4, 0xED, 0x92, 0xDC, 0x67, 0x81, 0xB1, + 0x79, 0xE8, 0x0D, 0x42, 0x6D, 0xDF, 0x61, 0x35, + 0xFE, 0x37, 0x8E, 0x9F, 0xB6, 0x37, 0x52, 0x0D, + 0xE4, 0x05, 0x04, 0xA2, 0x87, 0xA0, 0xF5, 0x1D, + 0x00, 0xD6, 0x0A, 0x42, 0x22, 0x9A, 0xD3, 0x39 + }, + { + 0x7D, 0xED, 0x19, 0x04, 0xA4, 0xAD, 0xD3, 0xAC, + 0x59, 0x02, 0x6B, 0x7C, 0xC3, 0x9E, 0xB2, 0x77, + 0x1F, 0x8C, 0x01, 0x30, 0xBE, 0xFF, 0xBC, 0x09, + 0xE3, 0x05, 0x25, 0x9F, 0x03, 0xE5, 0x99, 0x04, + 0x13, 0x3E, 0x01, 0xBD, 0x8E, 0x08, 0x61, 0x2C, + 0x9A, 0x15, 0xB1, 0x58, 0xB6, 0x99, 0x31, 0x56, + 0x1E, 0xD4, 0xD9, 0x02, 0x8B, 0x02, 0x68, 0x7B, + 0xA9, 0x20, 0xEC, 0x77, 0x3F, 0x83, 0x5A, 0xF6 + }, + { + 0xD8, 0x6B, 0x2A, 0xD4, 0x53, 0x32, 0x4F, 0x0A, + 0xD5, 0x69, 0x9B, 0x14, 0x75, 0xD0, 0xAB, 0x52, + 0x0A, 0x13, 0x3E, 0x0C, 0x78, 0xC0, 0x3E, 0x54, + 0xB4, 0x56, 0xDE, 0xF9, 0x3B, 0xFE, 0xB2, 0x14, + 0x81, 0x92, 0xA7, 0xC1, 0xAF, 0xA5, 0xAE, 0x79, + 0x0F, 0xA2, 0xCB, 0x0D, 0x46, 0xAE, 0xAB, 0xE6, + 0x22, 0x82, 0x69, 0xAD, 0x6D, 0x7B, 0xC6, 0x92, + 0x80, 0xC6, 0x2B, 0x18, 0xFA, 0xC2, 0xD9, 0xDD + }, + { + 0x33, 0x46, 0x04, 0x3E, 0x59, 0x2B, 0x8C, 0x4D, + 0xDB, 0xC0, 0x79, 0x0D, 0x4D, 0x66, 0x8D, 0xAC, + 0xDA, 0x30, 0x83, 0x02, 0xA1, 0xA4, 0xC7, 0x23, + 0xAC, 0x0C, 0x0E, 0x90, 0x12, 0xD3, 0x54, 0x83, + 0x27, 0xD8, 0xD2, 0x8A, 0xDD, 0x4B, 0x6A, 0x72, + 0x91, 0x2E, 0x68, 0x73, 0x88, 0x61, 0xDD, 0x1F, + 0xFF, 0x24, 0xAC, 0x24, 0xE3, 0xF3, 0x14, 0x35, + 0x21, 0x13, 0x0B, 0x21, 0xAF, 0x70, 0x04, 0x56 + }, + { + 0x26, 0x68, 0xBB, 0xFD, 0xB4, 0x18, 0x77, 0xB5, + 0x13, 0x90, 0xB4, 0x34, 0x71, 0xC7, 0xF8, 0x56, + 0x8C, 0xC3, 0x46, 0xE0, 0x6F, 0x57, 0x84, 0x5E, + 0x22, 0x4F, 0x04, 0x6B, 0xA5, 0x6A, 0x98, 0xD1, + 0x96, 0x11, 0xC7, 0xB6, 0xBB, 0xB0, 0x6D, 0xD1, + 0xF6, 0x2F, 0x59, 0x7C, 0x7B, 0xF4, 0x0F, 0x1F, + 0x32, 0xB2, 0xA6, 0x7C, 0xA6, 0xEA, 0x47, 0x90, + 0x97, 0x31, 0x54, 0x32, 0xB9, 0x13, 0xC0, 0x64 + }, + { + 0x44, 0x90, 0x81, 0x02, 0x9D, 0xC8, 0x75, 0x92, + 0xAB, 0xE2, 0x4A, 0xB4, 0x0D, 0x42, 0x63, 0x59, + 0x38, 0x8A, 0x74, 0x83, 0x54, 0x00, 0xB2, 0x67, + 0x0D, 0x20, 0xFD, 0xDB, 0x2B, 0x60, 0x4A, 0x44, + 0x5B, 0xAD, 0xA3, 0x88, 0xE3, 0x7A, 0x9F, 0xD0, + 0x6B, 0xED, 0xAF, 0x49, 0x01, 0xBE, 0xAD, 0x4D, + 0x5F, 0x95, 0x7D, 0x44, 0xE5, 0xF4, 0xE7, 0xB6, + 0x0A, 0x1B, 0x77, 0xA1, 0x94, 0x89, 0x75, 0x6F + }, + { + 0x5C, 0x5C, 0x4D, 0xDC, 0xEC, 0x76, 0x67, 0x6F, + 0x89, 0x40, 0xE4, 0xDE, 0x84, 0x7F, 0xC9, 0xDD, + 0x7C, 0xC6, 0x7C, 0xD1, 0xAA, 0xF9, 0xBD, 0x08, + 0x64, 0x08, 0x08, 0xDB, 0xC0, 0xEE, 0x35, 0x14, + 0x21, 0x57, 0x9B, 0x0B, 0xD1, 0x7F, 0x62, 0x33, + 0x4F, 0x2A, 0x57, 0xB7, 0x2A, 0x8F, 0xFA, 0x89, + 0x89, 0x33, 0x9F, 0x95, 0x0B, 0x5D, 0x54, 0xF9, + 0xDF, 0xFE, 0x3D, 0xF6, 0xD1, 0xCB, 0xA9, 0x40 + }, + { + 0xE1, 0x42, 0x92, 0xDC, 0x9B, 0x00, 0x07, 0xCA, + 0x85, 0x7A, 0x15, 0x5F, 0xC2, 0x86, 0xEF, 0x30, + 0x57, 0x98, 0x8C, 0xAA, 0xC7, 0x44, 0xB0, 0x22, + 0xAE, 0x92, 0x68, 0xDC, 0x1B, 0xB7, 0xD6, 0x42, + 0xEB, 0x3B, 0x93, 0x68, 0x5F, 0x3D, 0x4B, 0xD1, + 0xD6, 0x8D, 0x17, 0x44, 0x7C, 0x54, 0x8E, 0x4F, + 0xB6, 0xCB, 0xCC, 0x32, 0x74, 0x27, 0x20, 0xA7, + 0x28, 0x85, 0xEA, 0x36, 0x11, 0xD5, 0xE5, 0x60 + }, + { + 0x43, 0xC5, 0xAD, 0xF0, 0x77, 0x07, 0xF5, 0x40, + 0xA7, 0x39, 0x69, 0xD3, 0x9A, 0xDA, 0x72, 0x38, + 0xCA, 0xEA, 0x94, 0xFB, 0x98, 0xFC, 0x7F, 0x50, + 0xD1, 0x39, 0x54, 0x31, 0xE6, 0x76, 0xD2, 0xFA, + 0x10, 0xF9, 0x78, 0xF9, 0x11, 0x74, 0x57, 0x99, + 0x6A, 0x9A, 0x92, 0x8A, 0x0A, 0x17, 0xFA, 0xF4, + 0xFA, 0xB4, 0xE2, 0xC8, 0xE0, 0x9D, 0x4D, 0x55, + 0xD3, 0x79, 0x94, 0x44, 0x8A, 0x7A, 0x53, 0x06 + }, + { + 0xCE, 0x87, 0x6E, 0x20, 0x26, 0xFF, 0x3E, 0x00, + 0x8D, 0x97, 0x8A, 0x45, 0xA9, 0x60, 0x23, 0x00, + 0x39, 0x97, 0x15, 0x4A, 0x7F, 0x30, 0x17, 0x6A, + 0x23, 0x31, 0xCC, 0xC4, 0xB9, 0x9E, 0xB1, 0x50, + 0xFA, 0xC0, 0x52, 0x24, 0xD2, 0x39, 0x75, 0xA2, + 0x70, 0x30, 0x12, 0x8F, 0x8A, 0xA8, 0xA8, 0xA4, + 0x7B, 0x59, 0x08, 0x90, 0x77, 0x58, 0x31, 0x8F, + 0xA0, 0x39, 0x9B, 0x5B, 0x68, 0x1A, 0x23, 0x92 + }, + { + 0xDA, 0x53, 0x56, 0xDC, 0x21, 0x06, 0x12, 0xE3, + 0xAC, 0xDB, 0xC3, 0x58, 0xCF, 0x3B, 0xA4, 0x98, + 0xE2, 0xA3, 0x94, 0x72, 0x87, 0x46, 0x57, 0xBD, + 0xDF, 0xE9, 0xCA, 0xA9, 0x62, 0x5B, 0x54, 0x46, + 0x63, 0x64, 0xA7, 0xA8, 0xEE, 0x7B, 0xD6, 0xE3, + 0x23, 0x4C, 0x8F, 0x28, 0x5C, 0xBE, 0x02, 0x97, + 0x08, 0xF3, 0xC9, 0x69, 0xA6, 0xD7, 0xCA, 0xBE, + 0x47, 0x2D, 0xFC, 0xF5, 0x3E, 0x69, 0x63, 0xDC + }, + { + 0xD6, 0x9B, 0xA7, 0x78, 0xEA, 0xF4, 0x9C, 0x4E, + 0x1E, 0x6F, 0x5B, 0xEA, 0x3D, 0xAA, 0xB2, 0xD9, + 0xD4, 0xAB, 0x74, 0x70, 0x72, 0x8B, 0x2A, 0xDF, + 0x49, 0xD8, 0xD4, 0x01, 0x68, 0x8B, 0xAE, 0x10, + 0xBD, 0x0D, 0xFA, 0x3F, 0x9A, 0x9E, 0xAF, 0x3E, + 0x7A, 0x48, 0xBC, 0xF4, 0xE8, 0xA5, 0xC9, 0x33, + 0x69, 0x16, 0x0F, 0x4A, 0xE9, 0xE8, 0x93, 0x77, + 0x3A, 0x68, 0x11, 0x93, 0x82, 0x53, 0x20, 0xB1 + }, + { + 0x72, 0xFE, 0x3B, 0xC6, 0xEC, 0x32, 0x94, 0xA1, + 0x3D, 0xC7, 0xC3, 0x9F, 0x0B, 0x9A, 0xA5, 0x2A, + 0x42, 0x4F, 0xFA, 0x11, 0x05, 0xF8, 0x54, 0x27, + 0xAF, 0xC9, 0x42, 0xBF, 0x83, 0x26, 0x8E, 0xCC, + 0xC0, 0x7A, 0x7F, 0x1E, 0xEA, 0x16, 0x51, 0x97, + 0x3D, 0x97, 0x8C, 0x5E, 0x93, 0x3E, 0x3F, 0x14, + 0xD1, 0x22, 0x9E, 0xF4, 0xCE, 0xF6, 0x00, 0x1F, + 0x2D, 0x74, 0xAF, 0xA4, 0x34, 0xA6, 0x46, 0x09 + }, + { + 0xB8, 0xF6, 0x39, 0xBA, 0x7F, 0x49, 0x61, 0x57, + 0x97, 0xE9, 0xAA, 0x22, 0xF4, 0x6B, 0x8F, 0x75, + 0x8A, 0x76, 0x70, 0x84, 0x1E, 0xA9, 0xB2, 0xC4, + 0x6D, 0x1B, 0x45, 0x73, 0xF7, 0x2E, 0xF8, 0xBE, + 0xEF, 0x95, 0xF6, 0x2B, 0xD8, 0x6B, 0x1D, 0xFF, + 0xA9, 0x24, 0x41, 0xA2, 0xC7, 0xDD, 0x45, 0x20, + 0xA9, 0x4A, 0x0A, 0x2C, 0x97, 0x2A, 0xB3, 0x82, + 0x89, 0xBD, 0xB8, 0x92, 0x56, 0x87, 0xFD, 0xFE + }, + { + 0x0B, 0x5E, 0xD4, 0x7F, 0x95, 0x1B, 0x57, 0x5D, + 0x10, 0xCA, 0xA6, 0xF9, 0x66, 0xF8, 0x0A, 0xD6, + 0xF1, 0x63, 0x3F, 0xA8, 0xA1, 0x71, 0x04, 0xDC, + 0x45, 0x4E, 0xB0, 0xA7, 0x00, 0x5F, 0x67, 0x18, + 0x68, 0xB3, 0x98, 0xB1, 0x9F, 0x69, 0xA5, 0x9C, + 0x5F, 0xE5, 0x8C, 0x0B, 0x76, 0x5C, 0x5B, 0xB4, + 0x91, 0xC0, 0xD2, 0x0C, 0x0A, 0xB7, 0x43, 0xA2, + 0xB7, 0x78, 0x6E, 0x9C, 0xBD, 0xC6, 0x42, 0x93 + }, + { + 0xFF, 0x08, 0xEF, 0x78, 0xAC, 0x2C, 0x89, 0x58, + 0xF2, 0xBF, 0x93, 0x97, 0x84, 0x4C, 0x5C, 0xE2, + 0x61, 0x6F, 0x48, 0x11, 0x1B, 0x2B, 0x7D, 0xD9, + 0x6B, 0x92, 0x64, 0xB2, 0xA6, 0x2C, 0x21, 0xA4, + 0x42, 0x81, 0xC3, 0xD3, 0x4F, 0x96, 0xD8, 0x86, + 0xD3, 0xC8, 0xA2, 0x05, 0x10, 0xB2, 0xB1, 0x99, + 0x92, 0xF3, 0x97, 0xBF, 0x26, 0xB5, 0xD4, 0x9E, + 0x50, 0xEA, 0xC2, 0x2B, 0x6D, 0xA9, 0xD7, 0xA0 + }, + { + 0xD0, 0xF3, 0xCC, 0xD5, 0xC5, 0x96, 0xAF, 0xDC, + 0x0F, 0xFA, 0x9E, 0x32, 0xF5, 0x2D, 0xF2, 0xAF, + 0xB3, 0xDF, 0xC3, 0xA7, 0x01, 0x3A, 0x7C, 0x66, + 0x84, 0x55, 0xCC, 0x89, 0xF2, 0x24, 0xD7, 0x0A, + 0x8F, 0x36, 0xD5, 0xDA, 0x74, 0x46, 0x64, 0xA0, + 0x3C, 0xB8, 0x4A, 0xF8, 0x03, 0x69, 0xD2, 0xA5, + 0x19, 0x29, 0x1A, 0x1C, 0x6F, 0x50, 0xAC, 0xC1, + 0xF0, 0x54, 0xF2, 0x85, 0xB0, 0xB8, 0x14, 0x06 + }, + { + 0x6D, 0x23, 0x60, 0x08, 0x69, 0x8A, 0x2D, 0x37, + 0xC3, 0x3D, 0x31, 0xA5, 0x56, 0x05, 0xF0, 0x73, + 0xF4, 0x3A, 0xD3, 0xD2, 0x6D, 0xD2, 0x4A, 0x19, + 0xBF, 0x37, 0xA5, 0x6E, 0x44, 0x15, 0xA6, 0xEE, + 0x9C, 0x76, 0x47, 0x48, 0x83, 0xED, 0xDA, 0x7B, + 0xDC, 0xF5, 0x64, 0xA4, 0x53, 0x54, 0x1E, 0xBD, + 0x39, 0xE5, 0x20, 0xDD, 0xFC, 0x5B, 0xA2, 0x95, + 0xCD, 0x2E, 0x46, 0x9C, 0x6D, 0xE7, 0x0C, 0xD0 + }, + { + 0xBC, 0xCE, 0xDD, 0xF6, 0xD2, 0x91, 0x76, 0xD3, + 0x99, 0xFB, 0x18, 0x60, 0x12, 0xAC, 0x2F, 0x9C, + 0x93, 0x37, 0xDF, 0x04, 0x79, 0x52, 0xCC, 0x0D, + 0xFC, 0x40, 0x18, 0x7D, 0xD9, 0x2B, 0xE9, 0x0E, + 0xEE, 0xF6, 0x7D, 0x89, 0x82, 0x43, 0xEF, 0xE7, + 0x78, 0xB2, 0x2F, 0x97, 0x5E, 0xB9, 0xEF, 0xEF, + 0x3C, 0x35, 0xEF, 0xFF, 0x6F, 0x37, 0xA7, 0xB0, + 0x4D, 0x63, 0x3D, 0x1F, 0x44, 0x91, 0x1A, 0xFD + }, + { + 0xC0, 0xE4, 0x5F, 0x11, 0x5A, 0x4A, 0x25, 0x10, + 0xCA, 0xA7, 0xA1, 0x56, 0x11, 0xBE, 0x33, 0x2A, + 0x81, 0x59, 0x44, 0x49, 0x11, 0xE8, 0x97, 0xD9, + 0x48, 0x4F, 0x6F, 0x5B, 0xE5, 0x7F, 0xE7, 0x7E, + 0xF7, 0x9D, 0xD1, 0x7E, 0xCF, 0x5D, 0x57, 0x92, + 0x8E, 0xE7, 0xC5, 0x62, 0xC6, 0x3D, 0xE9, 0xAD, + 0x37, 0xB7, 0x17, 0x48, 0xB9, 0x27, 0xD7, 0xC7, + 0x2C, 0xF3, 0x21, 0xED, 0xA2, 0xA7, 0x38, 0x23 + }, + { + 0x71, 0xC2, 0x8A, 0x2D, 0x2F, 0x3C, 0xE8, 0xD8, + 0x8B, 0x32, 0xB3, 0x78, 0xED, 0x85, 0x7F, 0x42, + 0x5C, 0x2E, 0xDB, 0xFD, 0x2C, 0xDA, 0xFC, 0xDE, + 0xF2, 0x86, 0x3D, 0xA4, 0x8C, 0xD0, 0x11, 0x03, + 0xCC, 0xAF, 0x3A, 0xC7, 0x0B, 0x92, 0x89, 0xEE, + 0x2F, 0xFA, 0x84, 0x52, 0x2B, 0xDE, 0x30, 0x74, + 0x31, 0xC0, 0xF2, 0x18, 0x81, 0x85, 0xD5, 0x04, + 0x96, 0x95, 0x66, 0xB7, 0xCC, 0xB9, 0x3F, 0xA1 + }, + { + 0x54, 0xEC, 0xC4, 0x4D, 0xA9, 0x71, 0xA0, 0xE3, + 0x69, 0xCE, 0xDC, 0x73, 0x68, 0xE9, 0xE0, 0x64, + 0x92, 0xD7, 0xE7, 0x03, 0x64, 0xBF, 0x96, 0xEA, + 0x4E, 0xB5, 0xFB, 0x9C, 0x1E, 0x2B, 0x56, 0x26, + 0x8D, 0xC3, 0xB0, 0xD3, 0xE5, 0xEB, 0x9A, 0x8D, + 0x53, 0x9F, 0x2E, 0x01, 0x01, 0x2C, 0x7D, 0x11, + 0x5F, 0x40, 0xA9, 0x91, 0x16, 0xE1, 0x33, 0x95, + 0xAE, 0x31, 0x1E, 0x2B, 0xDB, 0x72, 0x95, 0xEC + }, + { + 0x42, 0xAC, 0x1C, 0x71, 0xB8, 0x43, 0xDC, 0x51, + 0x34, 0xB2, 0x29, 0xF8, 0xB9, 0x59, 0x90, 0x14, + 0x8E, 0x91, 0x04, 0x64, 0xAA, 0x2A, 0x41, 0xAB, + 0x06, 0xFE, 0xB0, 0xD2, 0xC2, 0xF3, 0x2E, 0x97, + 0x5A, 0xC5, 0x36, 0x8A, 0xFD, 0x67, 0x52, 0xEC, + 0xD4, 0xF9, 0xD1, 0xEC, 0x18, 0x7F, 0x33, 0x1B, + 0x2A, 0xA4, 0x9A, 0x66, 0x63, 0x3F, 0xC7, 0x12, + 0xB0, 0x91, 0xCE, 0x58, 0x19, 0x19, 0xE2, 0x97 + }, + { + 0xB8, 0x25, 0x5F, 0x94, 0x22, 0x11, 0x30, 0x0D, + 0x71, 0x3E, 0xC1, 0xEE, 0x4E, 0x8F, 0x0D, 0x61, + 0x69, 0x88, 0x6E, 0x61, 0x8F, 0x8F, 0x3B, 0x8B, + 0xA0, 0xE6, 0xDE, 0x05, 0xDD, 0xB4, 0xC3, 0xCE, + 0x8F, 0xCC, 0x40, 0x16, 0x10, 0x54, 0xD4, 0xCE, + 0x67, 0x4D, 0xAD, 0xF8, 0x22, 0x9D, 0xC2, 0x08, + 0xB9, 0x47, 0xE8, 0x21, 0x07, 0xBF, 0x9D, 0x8E, + 0x5C, 0x81, 0x8F, 0xF3, 0xB7, 0x7C, 0x79, 0xFC + }, + { + 0x11, 0xC1, 0x81, 0x23, 0x9E, 0xA2, 0x7B, 0xD9, + 0xD9, 0x3D, 0x44, 0x04, 0x30, 0x51, 0x0A, 0x70, + 0x88, 0x9F, 0x39, 0xA3, 0xE4, 0xE6, 0x64, 0xDC, + 0x92, 0xEB, 0x1E, 0x08, 0x4D, 0x69, 0x66, 0x0B, + 0xEF, 0xA6, 0x41, 0xF1, 0x59, 0x9F, 0xD3, 0xE7, + 0xBC, 0xB1, 0xA2, 0x90, 0x1E, 0xEA, 0x9C, 0x26, + 0xC0, 0x66, 0x78, 0x96, 0xE5, 0x79, 0x0B, 0x30, + 0xF0, 0x12, 0xD2, 0xFE, 0x7A, 0x0E, 0x56, 0x7E + }, + { + 0x29, 0xAB, 0xC6, 0xA8, 0xC3, 0x5E, 0x29, 0x6C, + 0x34, 0x36, 0x4F, 0x4F, 0xAA, 0x62, 0xD2, 0x6C, + 0x9E, 0x52, 0x09, 0x8E, 0xF9, 0x57, 0xE3, 0xB5, + 0xDA, 0x7A, 0x3D, 0xB6, 0x1C, 0xC6, 0xE0, 0xF3, + 0xD7, 0xB0, 0x83, 0x30, 0x38, 0x9C, 0x1B, 0x61, + 0xDD, 0x89, 0x97, 0x65, 0x6B, 0xA0, 0x23, 0x68, + 0xEB, 0xCC, 0xB9, 0x88, 0x13, 0xF5, 0x97, 0x62, + 0x3F, 0x8A, 0x9B, 0x29, 0xC7, 0x64, 0x1F, 0xF6 + }, + { + 0xDD, 0x0C, 0x22, 0x8A, 0xAA, 0x09, 0x2B, 0xEE, + 0xA6, 0x49, 0x39, 0x1A, 0xAB, 0x53, 0x50, 0x01, + 0xF6, 0xD4, 0x7F, 0x1F, 0xCE, 0x88, 0xFD, 0x10, + 0xF8, 0xAC, 0xAD, 0x3D, 0x06, 0xA0, 0xA7, 0x34, + 0x90, 0x11, 0x35, 0x5F, 0x86, 0xE9, 0x7B, 0xA2, + 0xD3, 0x82, 0xF2, 0x52, 0x81, 0x98, 0xC4, 0x0A, + 0x48, 0xD6, 0x7F, 0x95, 0xCD, 0x5D, 0x74, 0x46, + 0xDB, 0xF4, 0x92, 0x40, 0x33, 0x7C, 0x52, 0x25 + }, + { + 0xB6, 0x26, 0x50, 0x54, 0xAC, 0xCB, 0xEE, 0x12, + 0x75, 0x54, 0x91, 0x86, 0x5A, 0x2D, 0x1F, 0xCC, + 0x1F, 0x8D, 0xFA, 0xD5, 0xC2, 0x94, 0xBC, 0x36, + 0x56, 0x18, 0x2E, 0xB9, 0xDB, 0xA9, 0x2A, 0x68, + 0xEA, 0x04, 0xA2, 0x5F, 0xF4, 0x75, 0x25, 0xA3, + 0x74, 0xD8, 0x1F, 0x72, 0x3D, 0x6C, 0xE4, 0xE3, + 0x47, 0x3D, 0xC0, 0x3D, 0x6A, 0xF0, 0xFE, 0x80, + 0xBF, 0x27, 0x12, 0xDD, 0x7F, 0x18, 0x84, 0xC3 + }, + { + 0x43, 0xEF, 0x0F, 0x73, 0xF9, 0x1B, 0x78, 0x31, + 0xB3, 0xCF, 0x69, 0x97, 0x36, 0x3E, 0xCC, 0x74, + 0x25, 0xFB, 0x0A, 0x89, 0x5A, 0x95, 0x52, 0x6B, + 0x96, 0x28, 0xE0, 0x44, 0x1C, 0x0B, 0x56, 0xC7, + 0xA4, 0xDF, 0x4A, 0xEC, 0x6E, 0xF3, 0xF8, 0x3A, + 0x56, 0xCC, 0xE0, 0xF6, 0xE4, 0x6B, 0x1A, 0xB8, + 0x52, 0x7C, 0xC2, 0x23, 0x18, 0x72, 0xEF, 0xD1, + 0x5D, 0x6D, 0x7D, 0x5B, 0xFB, 0x89, 0x90, 0xB5 + }, + { + 0x78, 0x4E, 0x8E, 0x62, 0x9A, 0x7B, 0x7B, 0xFD, + 0x56, 0x73, 0x86, 0x10, 0xF8, 0x32, 0xD6, 0x4B, + 0x94, 0x5A, 0xB2, 0xA1, 0x7D, 0x80, 0x0B, 0xB9, + 0x42, 0x89, 0x60, 0xFE, 0x04, 0x8C, 0x10, 0xC4, + 0x2F, 0x04, 0xD8, 0xE2, 0x52, 0x34, 0x8F, 0xCE, + 0x11, 0x9E, 0xAC, 0xC6, 0x24, 0x12, 0x8B, 0xC5, + 0x4E, 0x23, 0xDA, 0xE0, 0xDD, 0xAB, 0x50, 0x53, + 0x17, 0x98, 0x67, 0x95, 0x35, 0xE4, 0xEA, 0xC7 + }, + { + 0xB8, 0x1F, 0x9F, 0xA3, 0x42, 0x8C, 0x73, 0x13, + 0x9B, 0xA1, 0x50, 0x1D, 0x98, 0xF8, 0x00, 0x20, + 0xAF, 0x30, 0x8C, 0x49, 0x81, 0xEC, 0x3D, 0x50, + 0xE4, 0x07, 0xB8, 0x99, 0xF0, 0x62, 0x1D, 0x15, + 0x2F, 0x83, 0x0D, 0x08, 0x9A, 0x85, 0xD7, 0xD7, + 0x4D, 0x23, 0xD0, 0x2A, 0x6A, 0xF7, 0x8C, 0x4B, + 0x7B, 0x62, 0x40, 0x38, 0x15, 0x01, 0x42, 0x92, + 0xBF, 0x59, 0x89, 0x58, 0x38, 0x6B, 0x48, 0x20 + }, + { + 0xB8, 0x4C, 0xE7, 0x35, 0x15, 0x62, 0xBB, 0x8D, + 0xD4, 0x54, 0x9E, 0x11, 0x14, 0x25, 0x1C, 0x17, + 0xA8, 0xFA, 0xB2, 0x1F, 0xA2, 0x11, 0xFA, 0x1D, + 0x1B, 0x0A, 0x6F, 0x4E, 0xF1, 0xCF, 0x02, 0x73, + 0xC8, 0xAC, 0x61, 0x21, 0xED, 0xBD, 0xDF, 0x2F, + 0x3E, 0x86, 0x62, 0x83, 0x5D, 0x5E, 0xC0, 0x2F, + 0xED, 0x96, 0x94, 0xFD, 0xA2, 0xBD, 0x78, 0x75, + 0x9C, 0xBE, 0x66, 0x03, 0xBD, 0xF2, 0x29, 0x6C + }, + { + 0x98, 0xA1, 0x7B, 0x30, 0xBB, 0x60, 0x85, 0x8D, + 0x59, 0x47, 0x48, 0x81, 0x68, 0xDB, 0x2E, 0xF2, + 0xA1, 0xF3, 0x9B, 0x29, 0x1D, 0x0C, 0x51, 0xBC, + 0x9C, 0x98, 0xFC, 0x91, 0xFF, 0x05, 0xDE, 0xE5, + 0xEE, 0x25, 0xF9, 0xB6, 0x74, 0xBA, 0x6B, 0x27, + 0x2D, 0x21, 0xDC, 0xC8, 0xC0, 0xF3, 0x1A, 0x85, + 0x0A, 0x80, 0x2D, 0x9B, 0x82, 0xB8, 0x6B, 0x7A, + 0x99, 0x1A, 0xB7, 0x5C, 0x9F, 0xFC, 0x8F, 0xD1 + }, + { + 0xA1, 0xB2, 0x08, 0xE0, 0xF0, 0xAD, 0xFC, 0x1D, + 0x16, 0x49, 0xF5, 0x7A, 0xBC, 0x1B, 0x72, 0xE3, + 0x21, 0x1B, 0x10, 0x9A, 0x77, 0xA0, 0x1A, 0x3B, + 0x8C, 0xEE, 0x61, 0x9F, 0xBC, 0xEC, 0xF7, 0xCA, + 0x4F, 0xB9, 0x4F, 0xF1, 0xC3, 0x10, 0x48, 0x70, + 0xC1, 0xA9, 0x39, 0x5F, 0xDC, 0x95, 0x5C, 0x16, + 0x6B, 0xA5, 0x79, 0xDC, 0x45, 0x4A, 0x49, 0x14, + 0x03, 0x6C, 0xE8, 0x4E, 0x50, 0x54, 0xEB, 0x29 + }, + { + 0xE8, 0x49, 0xF3, 0x70, 0x45, 0x39, 0x02, 0x73, + 0xE9, 0xA2, 0x6D, 0xF1, 0x33, 0xCD, 0x8A, 0xC9, + 0x46, 0xC9, 0x0A, 0x6B, 0xBD, 0x97, 0x76, 0xE6, + 0xF4, 0x39, 0xD4, 0x97, 0x51, 0x41, 0x1C, 0x3F, + 0xC9, 0xBA, 0xE3, 0xB8, 0xD3, 0x0D, 0x04, 0xFF, + 0x3A, 0x2F, 0x48, 0x6E, 0x24, 0xCC, 0x6E, 0xC6, + 0x67, 0xCD, 0x51, 0xCE, 0xB1, 0xA5, 0xD7, 0x05, + 0xB5, 0xE2, 0x7C, 0x73, 0x98, 0x10, 0x64, 0x86 + }, + { + 0x74, 0xF1, 0x1A, 0x75, 0x0F, 0x6A, 0x38, 0xEA, + 0x53, 0x23, 0xC2, 0x43, 0x12, 0xDE, 0xD5, 0x6D, + 0x4E, 0x94, 0x1D, 0x16, 0x5D, 0x85, 0x03, 0x0E, + 0x48, 0x87, 0x79, 0x10, 0x13, 0x37, 0x95, 0xFB, + 0xE3, 0x8D, 0xD0, 0x86, 0xD9, 0x2D, 0x6C, 0x38, + 0x1B, 0x2A, 0xD8, 0xD2, 0xA1, 0x95, 0x70, 0x9E, + 0x7D, 0x56, 0x9C, 0xF1, 0x3D, 0x83, 0x20, 0x98, + 0x72, 0x6D, 0x0A, 0x3E, 0xFA, 0xC5, 0xA1, 0x37 + }, + { + 0xF8, 0x42, 0xBB, 0x7D, 0x49, 0x42, 0x9A, 0x65, + 0xB2, 0x82, 0x53, 0xF8, 0x95, 0x60, 0xBB, 0x15, + 0xBF, 0xE6, 0x89, 0x94, 0xF6, 0xA8, 0x08, 0x8D, + 0x23, 0x23, 0xE2, 0x0A, 0xDE, 0xCF, 0x69, 0x73, + 0xF1, 0x53, 0x0C, 0x6E, 0x4E, 0x99, 0x5E, 0xFA, + 0x23, 0x24, 0x48, 0x55, 0x06, 0x24, 0xF9, 0x43, + 0xF2, 0x36, 0x1C, 0x03, 0xF2, 0x94, 0x4A, 0xBF, + 0x38, 0x1E, 0xFD, 0xE5, 0x02, 0xD2, 0x96, 0x0D + }, + { + 0xF0, 0xCF, 0xB8, 0x7D, 0xBC, 0x06, 0x85, 0x47, + 0xAA, 0xD5, 0x13, 0x82, 0x8D, 0x47, 0x25, 0x3C, + 0xBC, 0x77, 0xEC, 0xE6, 0xEA, 0x64, 0x75, 0x63, + 0xE0, 0x67, 0x55, 0x2B, 0xAC, 0x8F, 0xAD, 0xE2, + 0x1B, 0x75, 0x35, 0x2D, 0xE0, 0x19, 0x03, 0x68, + 0x19, 0x48, 0xC7, 0x97, 0x8D, 0x75, 0x71, 0x06, + 0xF0, 0xFB, 0x2F, 0xCB, 0xC3, 0x7B, 0xA5, 0xE9, + 0x33, 0xD1, 0x4B, 0xAD, 0x88, 0x0B, 0x9C, 0x71 + }, + { + 0xA5, 0x11, 0xF3, 0x2C, 0x55, 0x4B, 0xC9, 0xD0, + 0xB9, 0x84, 0xB9, 0xB7, 0x51, 0xB2, 0x5E, 0x1C, + 0x8C, 0x34, 0xC7, 0xB7, 0x6A, 0xBA, 0x0C, 0x08, + 0x82, 0x36, 0x0E, 0x6E, 0xFF, 0x02, 0xA5, 0xAD, + 0x98, 0x9E, 0x6A, 0xBA, 0xF1, 0xD1, 0x83, 0x1F, + 0x67, 0xFA, 0xB3, 0xAA, 0xFC, 0x0F, 0x9F, 0x48, + 0xEB, 0x2C, 0xF6, 0xC5, 0x9C, 0x06, 0xF6, 0x60, + 0x46, 0x2E, 0xA8, 0x01, 0x50, 0xDD, 0x4A, 0x0D + }, + { + 0x17, 0x12, 0xF5, 0x5F, 0xF8, 0xFA, 0xF0, 0xBE, + 0x5F, 0x0A, 0xBC, 0x29, 0x31, 0x30, 0xC1, 0xA2, + 0x08, 0x7D, 0x5E, 0xBF, 0x20, 0xE9, 0xE7, 0x94, + 0x4D, 0x5F, 0xDC, 0xC2, 0xB8, 0x91, 0x14, 0xC0, + 0xB7, 0x90, 0xB5, 0x45, 0xA9, 0x9F, 0xC6, 0x80, + 0xC8, 0x3B, 0xDD, 0x4B, 0xFB, 0x83, 0x46, 0x8C, + 0xEF, 0x60, 0x7F, 0x0D, 0x1B, 0xCA, 0x5B, 0xC7, + 0x08, 0x9E, 0xC6, 0x85, 0x30, 0x42, 0xC5, 0xB7 + }, + { + 0x5B, 0xEE, 0x7B, 0x3C, 0x2D, 0x4B, 0xAA, 0xAA, + 0xD5, 0x64, 0xE9, 0xE0, 0xD4, 0xF1, 0x52, 0xC1, + 0x8F, 0xC3, 0xC7, 0x64, 0x8C, 0x2D, 0xD5, 0x77, + 0xC2, 0x03, 0x59, 0xE2, 0x36, 0xC0, 0xE7, 0x4C, + 0x9C, 0x56, 0xBA, 0xE7, 0x93, 0xC8, 0xF3, 0xE5, + 0xFF, 0xBF, 0x51, 0x17, 0xB3, 0x65, 0x81, 0xF9, + 0xFE, 0xD5, 0x8B, 0xF0, 0x9F, 0x70, 0x34, 0xBF, + 0x86, 0x26, 0xE5, 0x77, 0x1B, 0x4C, 0x61, 0x34 + }, + { + 0x6D, 0xD8, 0x76, 0xB9, 0xD5, 0xFB, 0xE6, 0xC8, + 0xF2, 0x67, 0xD5, 0x87, 0x8B, 0x6F, 0x11, 0x3F, + 0x02, 0x9D, 0xDC, 0xAB, 0xCE, 0x66, 0xAE, 0x1F, + 0x9D, 0x2C, 0x86, 0x73, 0x52, 0x95, 0xAB, 0x91, + 0xC3, 0x9D, 0xF8, 0x0C, 0xEF, 0xDB, 0xD2, 0x8E, + 0x5C, 0xF4, 0xF8, 0x06, 0x4C, 0x86, 0x0B, 0x8C, + 0x17, 0x20, 0xBF, 0xA2, 0xD7, 0x55, 0xE2, 0x4A, + 0x6C, 0x3B, 0xB2, 0x96, 0xBD, 0x6C, 0xBC, 0x1C + }, + { + 0xF2, 0xB7, 0xBE, 0xCD, 0x8C, 0x19, 0x64, 0xFD, + 0xBC, 0x12, 0xDA, 0xB2, 0xD9, 0x23, 0x91, 0xAB, + 0x3A, 0xC8, 0xF8, 0x40, 0xD5, 0x84, 0x95, 0xE3, + 0x1E, 0x6D, 0x16, 0x75, 0xB0, 0x76, 0x4E, 0xF8, + 0xE3, 0x65, 0x96, 0x4E, 0x65, 0xF6, 0x8A, 0x4C, + 0xBC, 0xCF, 0x9D, 0xBC, 0x05, 0x4C, 0x1D, 0x51, + 0xA6, 0xF4, 0xDB, 0xFF, 0xDF, 0x57, 0x01, 0x86, + 0xEE, 0x37, 0xA6, 0xDC, 0xA2, 0xD4, 0xA7, 0x3A + }, + { + 0x2F, 0x7D, 0x77, 0x94, 0x55, 0xCB, 0x52, 0xE9, + 0x46, 0xF5, 0xD9, 0xBE, 0x5F, 0xE8, 0x52, 0x96, + 0xDA, 0x30, 0x82, 0x62, 0xCB, 0xEB, 0x3C, 0x08, + 0x71, 0xC1, 0x8B, 0x23, 0xC9, 0xF4, 0xA6, 0xEB, + 0x9F, 0xC3, 0x67, 0x42, 0x3A, 0xE1, 0xE1, 0xC5, + 0x53, 0xA9, 0x0E, 0xD1, 0x73, 0x1D, 0xF2, 0x6C, + 0xAC, 0xB4, 0xF7, 0x50, 0xEE, 0x45, 0xFC, 0x37, + 0xC6, 0xE6, 0x38, 0x3C, 0x2C, 0xD7, 0x3D, 0x1E + }, + { + 0x75, 0x8C, 0x2F, 0x67, 0x95, 0xA2, 0x22, 0xBA, + 0x31, 0x01, 0xB6, 0x0C, 0x57, 0x99, 0x35, 0x59, + 0x73, 0x60, 0x13, 0x4B, 0x5F, 0x5D, 0xBF, 0xB6, + 0xE1, 0x7F, 0xF0, 0xA9, 0x64, 0x75, 0x4E, 0x07, + 0xAB, 0x85, 0x1B, 0x24, 0x9E, 0xE7, 0x44, 0x0C, + 0x75, 0x03, 0x9C, 0x05, 0x26, 0x4B, 0x1B, 0xE2, + 0x8C, 0x39, 0x84, 0x32, 0xC4, 0x66, 0xB1, 0x56, + 0xAB, 0xC3, 0x77, 0xA2, 0xAE, 0x5C, 0xF1, 0x34 + }, + { + 0x56, 0xA6, 0xA8, 0xC9, 0x25, 0xE7, 0x73, 0x99, + 0x9C, 0xE4, 0xAE, 0xC9, 0xEC, 0x87, 0x85, 0x64, + 0x2B, 0x1F, 0x4D, 0x89, 0x9B, 0x60, 0x2A, 0x43, + 0x7F, 0x0D, 0x8C, 0x9B, 0x8E, 0x14, 0xF2, 0x4A, + 0xBB, 0x91, 0x24, 0x76, 0xC3, 0xAC, 0x1B, 0x2F, + 0x25, 0xBF, 0x22, 0x7B, 0xBB, 0xDB, 0x01, 0xBE, + 0x5A, 0x21, 0x2F, 0xDD, 0x30, 0x16, 0xE4, 0xE6, + 0xD6, 0xF2, 0x58, 0x6F, 0xCA, 0xD3, 0x96, 0xE8 + }, + { + 0xE7, 0xD9, 0x81, 0x42, 0xD7, 0x3F, 0x9C, 0x21, + 0x6D, 0x83, 0x39, 0x26, 0x40, 0xDE, 0x3D, 0x53, + 0x7E, 0x48, 0xA8, 0x65, 0x36, 0x8C, 0x1E, 0xE3, + 0xA2, 0x41, 0x5C, 0xF2, 0x06, 0x48, 0x0C, 0x0A, + 0x74, 0xA6, 0xE7, 0x95, 0x6C, 0x32, 0xEB, 0x3F, + 0x8B, 0x01, 0xA2, 0xB7, 0x74, 0x61, 0x8F, 0x48, + 0x56, 0x8E, 0x63, 0x79, 0xDE, 0xDB, 0x34, 0x58, + 0xCB, 0x19, 0x1B, 0x62, 0xBC, 0x5C, 0x2D, 0xF5 + }, + { + 0xE2, 0xA8, 0x53, 0x1C, 0x38, 0xDB, 0x1A, 0xA5, + 0x9A, 0x8B, 0xD6, 0xE4, 0x81, 0x58, 0xAE, 0x7C, + 0x8D, 0x15, 0x42, 0x27, 0x7E, 0xEA, 0x96, 0x10, + 0x20, 0xD6, 0x21, 0x45, 0xFA, 0xFD, 0xC8, 0x96, + 0x34, 0xFF, 0xEE, 0xDA, 0xE2, 0xD8, 0x7B, 0xB9, + 0xC0, 0x8D, 0xC9, 0xC9, 0x0E, 0x9D, 0x89, 0xBD, + 0x9B, 0x5C, 0x12, 0xCF, 0x4F, 0xBB, 0xAA, 0x93, + 0xC4, 0x11, 0x60, 0x07, 0x0C, 0xAB, 0x84, 0x83 + }, + { + 0xC0, 0x6D, 0x84, 0xE9, 0xB8, 0xC9, 0x82, 0xA9, + 0xCC, 0xA3, 0xF3, 0x67, 0x9B, 0x4C, 0x12, 0xE5, + 0xBD, 0x29, 0x79, 0x08, 0x90, 0xEE, 0x84, 0xBA, + 0x43, 0x1D, 0x1E, 0x79, 0x11, 0x29, 0x8C, 0xDA, + 0xAB, 0x1F, 0x52, 0x73, 0xC6, 0xF1, 0xFE, 0x5E, + 0xBE, 0x9D, 0x03, 0xD6, 0x68, 0x30, 0x41, 0x0B, + 0x3A, 0xAC, 0x39, 0x54, 0xB7, 0xA0, 0xAC, 0x41, + 0x98, 0xF8, 0x39, 0x41, 0x16, 0xDD, 0x2D, 0x2E + }, + { + 0x92, 0x1C, 0xB6, 0x04, 0x88, 0xCF, 0x1E, 0xF7, + 0x48, 0xA8, 0x45, 0x44, 0x72, 0xA8, 0xD2, 0x84, + 0xF6, 0xE9, 0x24, 0xC7, 0x3D, 0x4B, 0x10, 0xAA, + 0x98, 0xAB, 0x27, 0x11, 0x4D, 0x98, 0x6D, 0xB8, + 0x36, 0xB1, 0x36, 0x89, 0x21, 0xA1, 0x27, 0x03, + 0x76, 0x1D, 0x61, 0x9A, 0x8D, 0x47, 0x88, 0x6B, + 0x51, 0x72, 0x8A, 0x48, 0x81, 0xAD, 0x27, 0x89, + 0x25, 0xB9, 0x35, 0xD1, 0x0C, 0x47, 0x96, 0x6A + }, + { + 0x41, 0x91, 0x7E, 0xD3, 0x67, 0xDE, 0x4B, 0x71, + 0x52, 0x93, 0x46, 0xB9, 0xFA, 0xAE, 0xE9, 0xD2, + 0xBA, 0xE1, 0xB0, 0x73, 0x86, 0xAC, 0x42, 0xCF, + 0xFB, 0xD2, 0x69, 0x3D, 0xF0, 0x71, 0x7D, 0x0F, + 0xB6, 0x4E, 0x4B, 0x4E, 0x38, 0x2C, 0xC7, 0x42, + 0x00, 0x8D, 0xD7, 0x01, 0x3E, 0x66, 0x70, 0x3E, + 0x38, 0xBC, 0xCC, 0x30, 0x17, 0x90, 0x2C, 0x04, + 0x7C, 0xC5, 0x95, 0xDB, 0x0B, 0x64, 0xF2, 0xC3 + }, + { + 0x6C, 0x71, 0x17, 0xD5, 0x32, 0xD9, 0xC5, 0xA9, + 0x96, 0x86, 0xB7, 0x13, 0x99, 0x0E, 0x62, 0x26, + 0xFB, 0x12, 0x47, 0xCB, 0xCB, 0x9E, 0x6F, 0xE4, + 0x21, 0x90, 0xDE, 0xE7, 0x43, 0xDB, 0xD1, 0xE3, + 0xC5, 0x7E, 0xEF, 0x75, 0xE2, 0x91, 0x8F, 0x28, + 0xFA, 0xDF, 0xF5, 0x21, 0xE6, 0xC4, 0x0F, 0xAE, + 0xF1, 0x5B, 0x10, 0x1A, 0x57, 0x3A, 0x84, 0x7E, + 0x70, 0x26, 0x81, 0x95, 0x0E, 0x52, 0xEC, 0x9D + }, + { + 0xB2, 0xC3, 0x79, 0x5F, 0x25, 0x5D, 0x09, 0x0A, + 0xC1, 0x15, 0x94, 0x10, 0xEF, 0x92, 0xBE, 0x9D, + 0x20, 0xD4, 0x8C, 0x1D, 0xA1, 0xF0, 0xA6, 0xBD, + 0x07, 0x68, 0x72, 0xD3, 0xF0, 0x84, 0x7E, 0xAE, + 0x6D, 0x6F, 0x1F, 0xC1, 0x23, 0x87, 0x85, 0xC2, + 0x0E, 0x7D, 0x3E, 0xF3, 0xC9, 0xAA, 0x6D, 0x8F, + 0x5A, 0x9E, 0xDF, 0x9E, 0x4B, 0x67, 0xEC, 0x5B, + 0x06, 0x19, 0x86, 0xA4, 0x49, 0x78, 0xB7, 0x0A + }, + { + 0x45, 0xE1, 0x04, 0x1C, 0x1D, 0x97, 0x36, 0x09, + 0x49, 0x18, 0x6F, 0x61, 0xC9, 0xF0, 0x42, 0x8C, + 0x6E, 0x5C, 0x1E, 0xE6, 0xF2, 0x8C, 0x9B, 0xB0, + 0xA4, 0xB8, 0x9D, 0xF5, 0x23, 0x6E, 0x40, 0xE0, + 0xBD, 0x51, 0x12, 0xFD, 0x65, 0x14, 0x88, 0xF3, + 0xD7, 0x47, 0x02, 0x4C, 0xD2, 0x7E, 0xE9, 0xA6, + 0x0A, 0x38, 0xCC, 0xBB, 0x1F, 0xF8, 0xED, 0xD2, + 0x35, 0x7C, 0xA0, 0xD4, 0xEC, 0x6E, 0x4F, 0x5B + }, + { + 0xE9, 0xD7, 0x7D, 0xCC, 0x3B, 0x6D, 0x15, 0x9B, + 0x00, 0x4C, 0x46, 0x48, 0x25, 0x42, 0xFF, 0x12, + 0x27, 0x1C, 0x3D, 0x65, 0xE5, 0xD6, 0xBC, 0x2A, + 0x84, 0xEB, 0x83, 0xCA, 0xE8, 0x36, 0x87, 0x53, + 0x62, 0x0A, 0x15, 0x41, 0x36, 0x5F, 0xC2, 0xD2, + 0xBD, 0x6A, 0x00, 0x44, 0xF2, 0x47, 0x9C, 0x82, + 0x90, 0xD1, 0x4E, 0x5D, 0x46, 0x77, 0x6A, 0x41, + 0xEC, 0x4B, 0xEE, 0x33, 0xE9, 0x2C, 0x53, 0x68 + }, + { + 0xF7, 0xD5, 0xD7, 0x54, 0x63, 0x5F, 0x44, 0x78, + 0xB3, 0xEA, 0xFD, 0x41, 0x13, 0xE8, 0x57, 0x82, + 0xAE, 0x3A, 0xA4, 0x29, 0xAF, 0x5B, 0x61, 0xCE, + 0x44, 0x30, 0x7A, 0xFD, 0x15, 0xE7, 0x68, 0x94, + 0x34, 0xA2, 0xD8, 0x3A, 0x5B, 0x75, 0x8C, 0xCB, + 0xED, 0xF3, 0x3A, 0xD9, 0x07, 0x58, 0x5C, 0x31, + 0x6F, 0x94, 0xDC, 0x2D, 0xC8, 0xC4, 0x01, 0xA9, + 0x74, 0x08, 0x60, 0x2A, 0xAE, 0x3B, 0xFE, 0x81 + }, + { + 0x0B, 0x8A, 0x72, 0xC5, 0x24, 0xDE, 0x87, 0x78, + 0x7D, 0x55, 0xEE, 0xE2, 0xDA, 0xD0, 0x16, 0x42, + 0xE0, 0x18, 0x28, 0x23, 0xB7, 0x3A, 0xE1, 0x97, + 0xE5, 0xF1, 0x4A, 0xD1, 0x75, 0x9D, 0x2C, 0xC9, + 0xFC, 0x35, 0x9B, 0xF7, 0x33, 0x1A, 0xDF, 0xBB, + 0xC1, 0x4B, 0x5C, 0x91, 0x55, 0xCE, 0xE7, 0xA7, + 0xA9, 0x1F, 0xBF, 0x6E, 0x49, 0xC4, 0x69, 0x60, + 0x6C, 0xD8, 0xA3, 0xF9, 0xA1, 0x65, 0xFD, 0xD1 + }, + { + 0x81, 0xE4, 0xDC, 0xEA, 0x88, 0x5C, 0x2D, 0x28, + 0xCE, 0x23, 0xE4, 0xF3, 0xB8, 0x70, 0x9E, 0x3B, + 0xE6, 0xD3, 0x4B, 0x14, 0xF7, 0xE1, 0x34, 0x6A, + 0x4A, 0x7D, 0x0F, 0xA2, 0x6B, 0xED, 0xC3, 0x51, + 0xE7, 0x4F, 0x7B, 0xB8, 0x03, 0xB9, 0x4B, 0x07, + 0x4D, 0xBC, 0x4D, 0xD1, 0xB6, 0xED, 0xFE, 0xF9, + 0xE9, 0x41, 0x21, 0x83, 0x0A, 0x78, 0x02, 0x46, + 0x88, 0x55, 0x19, 0x66, 0x5F, 0x67, 0xCA, 0xD4 + }, + { + 0x04, 0x7B, 0x4C, 0x91, 0x86, 0x05, 0x9E, 0xD6, + 0xBB, 0x72, 0x11, 0xA6, 0xD9, 0x87, 0xFD, 0x59, + 0x28, 0x71, 0xF3, 0xC0, 0x25, 0x41, 0xE5, 0x7B, + 0x4E, 0xF4, 0x6C, 0xA4, 0xBF, 0xE4, 0xBA, 0x77, + 0xD7, 0xDE, 0x1B, 0xBC, 0x94, 0xEA, 0xAB, 0xE4, + 0x70, 0x21, 0x64, 0x3B, 0xAE, 0x6D, 0xA2, 0xD6, + 0x71, 0x88, 0xC8, 0xE9, 0xF9, 0x63, 0x98, 0xA5, + 0x35, 0xD0, 0x10, 0x26, 0x83, 0xCB, 0xF5, 0x6D + }, + { + 0xF4, 0x04, 0x7B, 0x85, 0xDD, 0x2F, 0xDE, 0xD1, + 0xD4, 0xB3, 0x86, 0x90, 0xFD, 0xFD, 0x20, 0xB8, + 0xA1, 0x36, 0xD7, 0xA0, 0x0C, 0x8A, 0x74, 0x63, + 0xBA, 0xB2, 0xEE, 0x91, 0x21, 0x4A, 0x8D, 0x69, + 0xDF, 0x5B, 0xE3, 0xB4, 0x2B, 0x90, 0x66, 0x80, + 0x9A, 0xB5, 0x7C, 0x6A, 0xF3, 0x91, 0xEB, 0x57, + 0x5F, 0x77, 0x56, 0x47, 0xA4, 0x24, 0x1A, 0x12, + 0x28, 0x3E, 0x02, 0x69, 0x15, 0xBB, 0x6F, 0xD2 + }, + { + 0xFF, 0x7D, 0x70, 0xAD, 0xEC, 0x77, 0x29, 0xFA, + 0x65, 0x26, 0x09, 0x7D, 0x0D, 0x0C, 0x61, 0x0F, + 0x4A, 0x75, 0xFC, 0xE4, 0xF1, 0x6C, 0x7D, 0xC4, + 0xDB, 0xF6, 0xD5, 0x09, 0x9A, 0x88, 0xD0, 0x79, + 0xD7, 0x4D, 0x1C, 0xEC, 0x77, 0xE0, 0xB4, 0xC5, + 0xD8, 0x4F, 0x44, 0x15, 0x62, 0x90, 0xB9, 0xF1, + 0xB0, 0x92, 0x09, 0x35, 0xE6, 0x6A, 0x05, 0x90, + 0xE2, 0x99, 0x90, 0x33, 0x98, 0xEB, 0x9E, 0x65 + }, + { + 0x8E, 0xC5, 0xCC, 0xA7, 0x75, 0x70, 0x17, 0x67, + 0xAE, 0xEF, 0xAB, 0x6F, 0x3B, 0xAF, 0x3B, 0xDE, + 0x35, 0xEA, 0x22, 0x5B, 0x59, 0x9D, 0x2F, 0xF6, + 0xA7, 0x17, 0xFB, 0x78, 0x63, 0x0B, 0x4D, 0x81, + 0x22, 0x26, 0x20, 0xA3, 0xD5, 0xBE, 0x6E, 0xF1, + 0x2E, 0x2C, 0x21, 0x65, 0xA2, 0x87, 0x7E, 0x2E, + 0x50, 0xA0, 0x64, 0x51, 0x0A, 0x10, 0x37, 0xD5, + 0x1C, 0x93, 0x6C, 0xB8, 0x96, 0xB0, 0x57, 0x33 + }, + { + 0xB3, 0x42, 0x44, 0xAE, 0xBB, 0x1E, 0xDA, 0xF3, + 0x1E, 0x03, 0x1F, 0x5B, 0xB7, 0xBB, 0x51, 0x52, + 0x4C, 0x0E, 0x6A, 0x3E, 0x19, 0xD6, 0xEB, 0x80, + 0xDB, 0xAD, 0x05, 0xDE, 0x83, 0x67, 0x90, 0x27, + 0x21, 0x94, 0xB6, 0x6B, 0x80, 0x09, 0x03, 0xD5, + 0x12, 0xBD, 0xED, 0x2E, 0x26, 0x1E, 0xF5, 0x04, + 0xFE, 0x9B, 0xEA, 0x9B, 0x36, 0x34, 0x75, 0x36, + 0x09, 0x92, 0x95, 0x9C, 0x88, 0x09, 0x48, 0x2F + }, + { + 0xF9, 0xD7, 0x76, 0xC8, 0x60, 0x4C, 0x17, 0xF4, + 0x8C, 0xA0, 0x0F, 0xD2, 0x96, 0xF9, 0x22, 0xBB, + 0xDE, 0x96, 0xF3, 0xD3, 0x3A, 0x38, 0x4F, 0xBB, + 0x5E, 0xDE, 0xAC, 0x7C, 0x4F, 0x32, 0x6D, 0x29, + 0xC7, 0x0B, 0x7C, 0xC6, 0x46, 0x09, 0x6D, 0xB5, + 0x4E, 0xEA, 0xF1, 0xA4, 0x94, 0x80, 0x4C, 0x1A, + 0x2B, 0x0B, 0x11, 0xEB, 0x1D, 0x7D, 0x4E, 0x61, + 0xB9, 0x12, 0xD7, 0xF9, 0x50, 0x4D, 0x36, 0x38 + }, + { + 0x44, 0x07, 0x3E, 0xBC, 0x76, 0x53, 0xA7, 0x86, + 0xDF, 0xC7, 0x91, 0x39, 0xE5, 0xF1, 0x97, 0x1E, + 0xB5, 0x81, 0xB5, 0x83, 0xEA, 0xEE, 0x7A, 0x39, + 0x66, 0xEE, 0x56, 0x49, 0xC5, 0xE6, 0xC3, 0xD5, + 0x42, 0x8A, 0x96, 0x7D, 0x84, 0x2E, 0x59, 0x18, + 0x90, 0x15, 0x77, 0x55, 0xAF, 0x4E, 0x9D, 0xF8, + 0x7B, 0x3C, 0x2E, 0xBB, 0x95, 0x46, 0x61, 0x4D, + 0x2A, 0xD2, 0x30, 0x8D, 0x65, 0x27, 0x2D, 0x3F + }, + { + 0xC4, 0xEC, 0xB0, 0xCF, 0xFF, 0xD0, 0x69, 0x24, + 0x74, 0xA3, 0xA4, 0x4E, 0x58, 0xC1, 0x83, 0x3D, + 0x64, 0xA1, 0xD0, 0x73, 0xB0, 0x09, 0x1F, 0x51, + 0x61, 0x31, 0x0B, 0x64, 0x2F, 0xDD, 0x58, 0x0C, + 0xD4, 0x6F, 0x80, 0x92, 0xA6, 0x86, 0x38, 0x7F, + 0x36, 0x3E, 0x84, 0xB7, 0xF8, 0xCA, 0x8E, 0x17, + 0x5E, 0x83, 0xE5, 0x71, 0x45, 0x61, 0x50, 0x89, + 0x9B, 0x17, 0xBF, 0x68, 0x86, 0x23, 0xF9, 0xD3 + }, + { + 0x86, 0xF6, 0x59, 0xC1, 0x71, 0x7E, 0x68, 0x17, + 0xAD, 0xD9, 0xC8, 0xC3, 0xC8, 0x8A, 0xD6, 0x74, + 0x2A, 0x1C, 0xEC, 0x7A, 0xAF, 0xE8, 0x82, 0x26, + 0xA7, 0xB8, 0xA6, 0x40, 0x3F, 0x85, 0x93, 0xC2, + 0x68, 0xA0, 0xBB, 0x00, 0xB5, 0xFA, 0x55, 0xE0, + 0x58, 0x75, 0x18, 0x58, 0x8A, 0x0C, 0x8D, 0x1F, + 0x1D, 0x65, 0x21, 0x47, 0xF3, 0xA8, 0xAB, 0xC1, + 0x5B, 0xF2, 0x36, 0x2E, 0x60, 0x89, 0xB6, 0xE3 + }, + { + 0x58, 0x02, 0x40, 0xE9, 0xC6, 0xA5, 0x64, 0xC6, + 0xBE, 0xC5, 0x3C, 0x7B, 0x9C, 0xC1, 0x79, 0x98, + 0x64, 0x4D, 0x11, 0xCD, 0x64, 0x71, 0x1D, 0xAC, + 0x56, 0x05, 0xDE, 0xB0, 0x54, 0x08, 0xA2, 0x0E, + 0x24, 0xA6, 0xBB, 0x39, 0xDC, 0x16, 0x6E, 0x89, + 0x9D, 0x51, 0xDF, 0x9D, 0xC3, 0x68, 0xB4, 0x3D, + 0x2B, 0x85, 0x4D, 0x5D, 0x63, 0x44, 0xC7, 0x28, + 0xB1, 0x7A, 0x2F, 0x2A, 0xF1, 0x40, 0xA0, 0xB8 + }, + { + 0x2B, 0xA5, 0xA8, 0x84, 0x37, 0x05, 0xC7, 0x2D, + 0x45, 0x4E, 0xFC, 0x72, 0xBA, 0xA9, 0x7E, 0x38, + 0x71, 0xC8, 0xF2, 0xFF, 0x1C, 0x53, 0x1B, 0x93, + 0xBD, 0xD1, 0x5E, 0x0F, 0xD7, 0xB1, 0x61, 0x10, + 0x12, 0xCF, 0xFE, 0x0B, 0x73, 0x5C, 0x55, 0x0A, + 0xAC, 0x11, 0x48, 0xD0, 0x95, 0xBE, 0xD5, 0x3A, + 0x9D, 0xC1, 0x67, 0xAE, 0xF1, 0x67, 0x4B, 0xD9, + 0x60, 0x18, 0x07, 0x25, 0xED, 0x2A, 0x6C, 0x9C + }, + { + 0x85, 0x85, 0x7E, 0xF5, 0xB3, 0xE1, 0x5F, 0xBC, + 0xC1, 0xB4, 0x0C, 0x21, 0xAF, 0x7D, 0x4B, 0x97, + 0x8B, 0xC6, 0xEE, 0xB5, 0x54, 0x17, 0xC8, 0x2E, + 0xC7, 0x8D, 0xB7, 0x09, 0x7E, 0xB9, 0xD1, 0xB1, + 0x16, 0x4F, 0xB7, 0x56, 0x62, 0x06, 0xDE, 0xA9, + 0x88, 0xB2, 0x01, 0x65, 0x47, 0x8B, 0x2D, 0xD2, + 0xA1, 0xAA, 0xC8, 0xF7, 0x95, 0xD0, 0x4B, 0xAE, + 0x1E, 0x7D, 0x64, 0x9C, 0x70, 0x6A, 0x21, 0x41 + }, + { + 0x28, 0x40, 0x17, 0xAE, 0xC0, 0xE9, 0x64, 0x1A, + 0xE6, 0x2C, 0xA0, 0x41, 0xEE, 0x61, 0x2E, 0xE6, + 0xE5, 0xA7, 0x33, 0xB9, 0x04, 0xED, 0xB7, 0x5A, + 0x4F, 0x20, 0x5C, 0x60, 0x9F, 0xB2, 0x92, 0x73, + 0x68, 0xA1, 0xB7, 0xEB, 0xC5, 0x37, 0x90, 0xB1, + 0x82, 0x7C, 0x7C, 0xEC, 0xF8, 0x8D, 0xA6, 0x92, + 0xB5, 0x33, 0xE1, 0xE0, 0xCB, 0x63, 0xF2, 0xE7, + 0x02, 0x29, 0xDA, 0x59, 0xFB, 0x12, 0x4A, 0xC2 + }, + { + 0x77, 0x87, 0xCB, 0x17, 0x3D, 0x62, 0x10, 0xA0, + 0x59, 0xDE, 0x53, 0x9B, 0x0D, 0x04, 0x88, 0x92, + 0x6B, 0xC6, 0x1A, 0xBB, 0x37, 0xA9, 0x31, 0x0A, + 0xE2, 0x89, 0xD7, 0x43, 0x22, 0x46, 0xE3, 0xC0, + 0xA4, 0x4B, 0xFF, 0xAE, 0xD3, 0x77, 0x43, 0x4E, + 0x46, 0x0D, 0x0D, 0x72, 0xD9, 0xF9, 0x37, 0x91, + 0x45, 0x74, 0x41, 0xFB, 0x59, 0x2D, 0x7A, 0x13, + 0x8B, 0x9A, 0xAF, 0x9A, 0x28, 0x08, 0x5C, 0x9B + }, + { + 0xA8, 0x91, 0xC2, 0x0D, 0x33, 0x3A, 0x22, 0x18, + 0xF7, 0x6E, 0xC1, 0xF8, 0x42, 0x9F, 0x12, 0xC8, + 0xFA, 0x3D, 0xAC, 0x42, 0x98, 0xE3, 0x05, 0x74, + 0x74, 0x3E, 0x0D, 0xB8, 0x5A, 0x40, 0x51, 0x21, + 0x5C, 0x3F, 0x77, 0x16, 0x5E, 0x75, 0x3F, 0xA8, + 0x6C, 0x15, 0x2E, 0xD5, 0x80, 0xC0, 0x76, 0xD1, + 0xB8, 0x3E, 0xBD, 0x27, 0x89, 0xA3, 0x6B, 0x2A, + 0x13, 0xA9, 0xBF, 0xC8, 0x10, 0x55, 0x3E, 0xDC + }, + { + 0xC3, 0x90, 0xA4, 0x58, 0xFD, 0x12, 0x03, 0x7F, + 0x45, 0x83, 0x3A, 0x35, 0x76, 0xFF, 0x6B, 0x28, + 0x99, 0x7B, 0xD5, 0x10, 0x90, 0x72, 0x12, 0xBA, + 0xA7, 0xED, 0x8B, 0x84, 0xD3, 0x64, 0xF2, 0xD7, + 0x87, 0x08, 0x5E, 0x51, 0x6A, 0x0D, 0x28, 0x8E, + 0xD5, 0x40, 0x0D, 0x36, 0x52, 0x7E, 0xAB, 0xBF, + 0x60, 0x29, 0xDE, 0x9D, 0x28, 0xBA, 0xD9, 0x9F, + 0x29, 0x7D, 0xEC, 0x01, 0xE5, 0x37, 0x8F, 0xDE + }, + { + 0xB1, 0x32, 0x45, 0xDB, 0xB9, 0x4B, 0x49, 0x5A, + 0x8B, 0x51, 0x9E, 0x72, 0x17, 0x1C, 0x26, 0x1A, + 0x2F, 0xB2, 0xFA, 0xD4, 0x7B, 0x4A, 0x99, 0x82, + 0xAC, 0x94, 0xBA, 0x1F, 0x9B, 0x3E, 0xD5, 0x17, + 0xDC, 0x87, 0x83, 0x1A, 0xA5, 0xDB, 0x0D, 0x64, + 0x46, 0x42, 0xEA, 0x0A, 0x2B, 0x2F, 0x33, 0xD4, + 0x6B, 0x29, 0xBC, 0x81, 0x2E, 0xB5, 0xCC, 0x0A, + 0x70, 0xCA, 0x9F, 0x30, 0xE5, 0xAE, 0x52, 0x79 + }, + { + 0x11, 0xC5, 0xC3, 0xF7, 0xCC, 0x74, 0xB6, 0x1B, + 0xDC, 0x59, 0xEC, 0x7B, 0x1F, 0xF2, 0x87, 0x64, + 0xE0, 0xD8, 0x56, 0x29, 0xB5, 0xE3, 0xD3, 0xFE, + 0x39, 0x86, 0x6C, 0xAF, 0xFD, 0x69, 0x8C, 0x3D, + 0x96, 0xDB, 0x17, 0xE4, 0x49, 0x7F, 0xF9, 0xD8, + 0xC5, 0x58, 0x5E, 0x5B, 0x8B, 0x21, 0xB0, 0xB4, + 0x59, 0x6E, 0x1F, 0x71, 0xBE, 0x8C, 0xA6, 0x90, + 0x5B, 0x45, 0xC0, 0x8C, 0xAA, 0x60, 0x3F, 0xCC + }, + { + 0x97, 0x81, 0x00, 0x0A, 0x84, 0x52, 0x6D, 0xA1, + 0xEB, 0x53, 0x2C, 0xB3, 0x3D, 0x7E, 0xE7, 0x4F, + 0xFA, 0xE5, 0x3B, 0x9E, 0x29, 0x3D, 0x5F, 0x5D, + 0xAE, 0xB5, 0x90, 0xCA, 0x1B, 0xEF, 0x59, 0xB4, + 0x2D, 0x34, 0x97, 0x1E, 0x30, 0x81, 0xE2, 0x2F, + 0x37, 0xC3, 0x35, 0x0F, 0x15, 0xB6, 0xAE, 0x42, + 0xF3, 0xFC, 0x1B, 0xAA, 0x6B, 0x3A, 0xAD, 0xD3, + 0xD5, 0x0B, 0xD4, 0x25, 0x9C, 0xA1, 0x43, 0x45 + }, + { + 0xE1, 0x12, 0x8C, 0xA8, 0x6D, 0xA6, 0xF8, 0x6C, + 0x8C, 0x1C, 0x77, 0x5F, 0x07, 0x10, 0x19, 0x48, + 0x02, 0x79, 0x40, 0x7B, 0xB4, 0xDD, 0xDD, 0xE4, + 0x2C, 0xF4, 0x5C, 0x13, 0xBF, 0xD7, 0x64, 0xC8, + 0xFC, 0xF5, 0xDE, 0x27, 0xE1, 0x2B, 0x94, 0x20, + 0x52, 0x3F, 0xC7, 0x6A, 0x46, 0xA2, 0xE2, 0x66, + 0xFB, 0xFA, 0xB6, 0xF2, 0x38, 0xCD, 0x3B, 0x86, + 0xF8, 0x2A, 0x5A, 0xA3, 0xF0, 0x84, 0x89, 0x71 + }, + { + 0xD9, 0x4E, 0xBB, 0x59, 0xCB, 0x25, 0x9A, 0xA1, + 0x07, 0xD3, 0x77, 0x99, 0x90, 0x70, 0x4D, 0x90, + 0x40, 0xEE, 0xC8, 0xBD, 0x40, 0x8C, 0x9F, 0x98, + 0x23, 0xB1, 0x25, 0x53, 0x1B, 0x57, 0x95, 0x45, + 0x09, 0x1E, 0x5B, 0xDA, 0x02, 0x1E, 0x7B, 0xDA, + 0x7B, 0xFF, 0xD8, 0x9F, 0x63, 0x49, 0x4F, 0xE3, + 0x54, 0x13, 0x85, 0x70, 0xBB, 0xB9, 0xC0, 0x20, + 0x91, 0xEA, 0x47, 0x9A, 0x45, 0x91, 0x45, 0xA3 + }, + { + 0xD0, 0xF4, 0xAF, 0x1E, 0xA7, 0x81, 0xCD, 0x5C, + 0xE5, 0xCE, 0xBC, 0xCB, 0xD0, 0xF1, 0xE3, 0xEF, + 0x91, 0x84, 0xDF, 0x74, 0x02, 0x78, 0x67, 0xB6, + 0xA8, 0x43, 0xD4, 0x69, 0x14, 0x44, 0xD4, 0x6D, + 0x36, 0x7C, 0xD0, 0x30, 0x2C, 0xB4, 0x08, 0x21, + 0x1F, 0x9F, 0x5E, 0xE9, 0xF2, 0x57, 0x93, 0x69, + 0x2B, 0x9E, 0x7D, 0x37, 0x5D, 0x48, 0x26, 0xEF, + 0xED, 0x25, 0x39, 0x8A, 0xE5, 0x93, 0x0B, 0x94 + }, + { + 0xC6, 0x51, 0x4B, 0x0C, 0xE7, 0xE0, 0xB2, 0x0B, + 0x52, 0x82, 0x8D, 0x57, 0x36, 0xDF, 0xB4, 0x50, + 0x3C, 0xD7, 0x71, 0x83, 0x69, 0x61, 0x4F, 0xAE, + 0x0A, 0xD2, 0x3F, 0x8C, 0xB5, 0xE2, 0xFD, 0x07, + 0x2A, 0x9C, 0xAA, 0x4D, 0x91, 0x1D, 0xA3, 0x5D, + 0x64, 0x16, 0x49, 0xED, 0xCE, 0xFF, 0x0D, 0x78, + 0xBA, 0x15, 0xB1, 0xD1, 0x9B, 0x74, 0x1F, 0x00, + 0xCD, 0x00, 0xDA, 0x16, 0xAA, 0xDC, 0x12, 0x3E + }, + { + 0xA7, 0x08, 0x8A, 0xA1, 0x22, 0x7F, 0xA8, 0x5B, + 0x3C, 0xEA, 0x00, 0x38, 0x77, 0x63, 0xCD, 0x08, + 0x36, 0xCB, 0xE5, 0x4D, 0xE6, 0x15, 0xF8, 0x74, + 0x13, 0xC7, 0x6A, 0x1C, 0xDC, 0x9C, 0x70, 0x08, + 0x8B, 0x86, 0xA3, 0x89, 0x78, 0x5F, 0x1F, 0x01, + 0x7A, 0xAD, 0x57, 0x25, 0xE6, 0xE4, 0x73, 0x1C, + 0x44, 0x49, 0x00, 0x62, 0x4E, 0x44, 0xB2, 0x69, + 0x91, 0xB2, 0xC6, 0x23, 0x2C, 0x70, 0x35, 0x33 + }, + { + 0x48, 0x8C, 0xFD, 0x42, 0x2D, 0x01, 0x3B, 0x3F, + 0xD0, 0x65, 0xE5, 0x05, 0x19, 0x50, 0x5C, 0xFB, + 0x02, 0xB3, 0x8A, 0xBC, 0xCB, 0xA7, 0xC1, 0x3E, + 0x15, 0x21, 0x2F, 0x4F, 0x4C, 0x2B, 0x67, 0xC9, + 0xD2, 0x09, 0xB9, 0x89, 0xB9, 0xFB, 0x26, 0x60, + 0xDA, 0xC9, 0xA6, 0x4F, 0x00, 0x04, 0x25, 0x26, + 0xEB, 0xE2, 0xFC, 0xCC, 0x1E, 0xED, 0x36, 0x4A, + 0x98, 0x9F, 0xD6, 0xAB, 0x4E, 0xF0, 0x6A, 0x60 + }, + { + 0x3A, 0xBB, 0xAB, 0x87, 0x0C, 0x74, 0xDE, 0xCC, + 0x8F, 0xC1, 0x12, 0xF7, 0xA6, 0x1F, 0x68, 0xFE, + 0x11, 0xF1, 0xE8, 0x81, 0xF1, 0xA7, 0xCB, 0x20, + 0x53, 0x07, 0x60, 0x55, 0x41, 0x8F, 0xD4, 0x0A, + 0x93, 0x63, 0xF4, 0xC8, 0x1E, 0x3A, 0x30, 0x9C, + 0x75, 0x0F, 0x84, 0xFB, 0xB5, 0xF9, 0x84, 0x04, + 0x0E, 0x4D, 0xE1, 0xD3, 0x07, 0x02, 0x48, 0x5F, + 0x79, 0x36, 0x30, 0xD6, 0xB0, 0x9C, 0xE3, 0x69 + }, + { + 0x0E, 0xEE, 0x8D, 0xF9, 0x2A, 0x33, 0x28, 0xAC, + 0x0C, 0x46, 0x14, 0x28, 0x74, 0xA6, 0x37, 0x5D, + 0xFB, 0xBB, 0x41, 0x0E, 0x2F, 0xB4, 0x4F, 0x94, + 0x7F, 0xA3, 0xB0, 0x69, 0xAD, 0xF8, 0x3A, 0xDB, + 0xA2, 0x6C, 0x37, 0x56, 0xF0, 0x2D, 0x6F, 0x2B, + 0x42, 0x5D, 0xC4, 0x87, 0xD6, 0x49, 0xBA, 0x81, + 0x5D, 0x2A, 0x08, 0xDC, 0x5F, 0x24, 0xAB, 0x1C, + 0x02, 0xE0, 0xAF, 0x9A, 0xC4, 0x6D, 0x2E, 0x4F + }, + { + 0x00, 0xC9, 0x9E, 0xAF, 0x93, 0x4E, 0x74, 0x86, + 0x8D, 0xF4, 0xFB, 0x22, 0x43, 0xA2, 0x98, 0x3E, + 0xB3, 0xEC, 0x31, 0x76, 0x83, 0xA6, 0xD7, 0xA8, + 0x82, 0x7D, 0xFA, 0xAA, 0xDE, 0xC3, 0x97, 0xE8, + 0x1B, 0x33, 0x1F, 0xC6, 0xB2, 0x22, 0x4F, 0xDD, + 0x31, 0x27, 0xF7, 0x6D, 0xD6, 0x54, 0xC7, 0xF6, + 0x2C, 0x33, 0x1A, 0x82, 0x8E, 0x0A, 0xAD, 0x0A, + 0xD0, 0x84, 0xE1, 0x32, 0x2C, 0xB0, 0x97, 0x15 + }, + { + 0x29, 0xB7, 0x1B, 0xC9, 0x17, 0x7D, 0xFD, 0xF3, + 0x8C, 0xB3, 0xF0, 0x71, 0x7F, 0x82, 0x12, 0xBB, + 0x61, 0x86, 0xD6, 0xAA, 0x6C, 0xAB, 0xF0, 0xFD, + 0x85, 0x6E, 0x56, 0x54, 0xB5, 0xE0, 0x5D, 0x52, + 0xA2, 0xA7, 0x9F, 0x22, 0x49, 0xA3, 0xEB, 0xDA, + 0x08, 0x2A, 0x32, 0x1E, 0x02, 0x9D, 0xEE, 0xDC, + 0x2F, 0xF7, 0xE5, 0x42, 0xD2, 0x3D, 0xD9, 0xD3, + 0xB0, 0x0E, 0x49, 0x93, 0x3A, 0x66, 0x9C, 0x19 + }, + { + 0x2D, 0x00, 0x8B, 0x85, 0x9A, 0x3D, 0x5D, 0x93, + 0xE3, 0x9D, 0x89, 0xD9, 0x30, 0x1A, 0x94, 0x86, + 0x50, 0xF2, 0xBB, 0xE3, 0xCF, 0x2E, 0xD2, 0x07, + 0x18, 0xE5, 0xE0, 0x5D, 0xA6, 0x79, 0xF2, 0xA6, + 0x91, 0xBD, 0xC3, 0x0B, 0x44, 0x8A, 0x3E, 0x85, + 0xBA, 0x4D, 0xB3, 0x49, 0xBB, 0x06, 0x9C, 0x5D, + 0x3F, 0x54, 0xEB, 0xAA, 0x92, 0xD6, 0x9A, 0x62, + 0xEB, 0x2C, 0x9E, 0xA8, 0xED, 0xF3, 0x21, 0x67 + }, + { + 0xB8, 0x9C, 0xC1, 0x9C, 0x4D, 0xCC, 0x96, 0xC4, + 0x8F, 0x02, 0x4F, 0x8C, 0x18, 0xCB, 0x7B, 0x8F, + 0xE1, 0xAC, 0x6C, 0x4C, 0x07, 0xBB, 0xDD, 0x07, + 0xB8, 0xE5, 0x7C, 0x7F, 0x84, 0x87, 0x91, 0x79, + 0xFF, 0xB8, 0xAD, 0x0D, 0x72, 0xCA, 0xEE, 0xDE, + 0x61, 0x99, 0x1C, 0xA1, 0xA3, 0xF9, 0x65, 0xC6, + 0x83, 0x50, 0x4A, 0x74, 0x04, 0x23, 0x2D, 0x6C, + 0x14, 0xE7, 0x56, 0x99, 0x09, 0x8F, 0x3D, 0xE1 + }, + { + 0x66, 0x6A, 0x03, 0xE3, 0x52, 0x6E, 0xB5, 0x6E, + 0x25, 0x6C, 0x2B, 0x79, 0xFC, 0x86, 0x8E, 0x07, + 0x7C, 0x45, 0x98, 0x83, 0xC0, 0xA0, 0xCC, 0x54, + 0x48, 0x5E, 0x17, 0xC7, 0x5A, 0x25, 0x89, 0xF6, + 0x36, 0x39, 0xA2, 0x80, 0x6A, 0x78, 0xEE, 0x19, + 0xB0, 0xD3, 0x66, 0x08, 0x7E, 0x6A, 0xBC, 0x13, + 0x81, 0xA6, 0xAA, 0xE0, 0xC9, 0x39, 0xB0, 0x86, + 0xFF, 0x19, 0x6D, 0xFF, 0x72, 0xC8, 0xE4, 0x32 + }, + { + 0xD0, 0x00, 0xEA, 0xD5, 0xD2, 0x29, 0x18, 0x4C, + 0xE2, 0x3A, 0xDE, 0x38, 0xEE, 0x1B, 0x01, 0x63, + 0x6F, 0x3E, 0x85, 0xAD, 0x3A, 0x2C, 0xBE, 0x6A, + 0x70, 0xC2, 0x9D, 0x99, 0x95, 0x66, 0x43, 0x7F, + 0xBE, 0xEC, 0xD3, 0x3E, 0x84, 0x2A, 0x94, 0x2E, + 0x43, 0x1B, 0xB6, 0xDB, 0xAB, 0xF6, 0xCE, 0x3B, + 0xCC, 0x2F, 0x2E, 0x82, 0x5B, 0x1D, 0xCC, 0xA6, + 0xB3, 0x8F, 0x75, 0x4A, 0x4E, 0x31, 0x52, 0x4A + }, + { + 0x5A, 0x52, 0x8C, 0x0E, 0x58, 0x37, 0x40, 0x16, + 0xCF, 0xA9, 0xB7, 0x84, 0xC4, 0xC1, 0x18, 0x9F, + 0x22, 0x89, 0x7E, 0x97, 0x0F, 0xC9, 0x3C, 0xA6, + 0x6F, 0x56, 0x59, 0xED, 0xDE, 0xCF, 0x0F, 0xFF, + 0x87, 0x79, 0x5F, 0x63, 0x15, 0xDD, 0xF8, 0x36, + 0xD9, 0x1E, 0x7A, 0xEE, 0x2F, 0x8F, 0xA5, 0x8A, + 0x99, 0x7B, 0x0D, 0x46, 0xC5, 0x45, 0x85, 0x47, + 0xE0, 0xDA, 0x96, 0x60, 0x52, 0x2C, 0x0F, 0xCA + }, + { + 0x3C, 0xC7, 0xCD, 0x86, 0x04, 0xB8, 0xB7, 0xB2, + 0x6D, 0x20, 0xB4, 0x71, 0xA2, 0x73, 0x7C, 0x34, + 0xA6, 0x1A, 0x48, 0xCB, 0xF2, 0x98, 0x28, 0x57, + 0x70, 0x4D, 0x84, 0xD3, 0x35, 0xEB, 0x20, 0x40, + 0x18, 0x4F, 0x5B, 0x33, 0x03, 0x08, 0x87, 0x5B, + 0x03, 0x26, 0x92, 0xFB, 0xD0, 0xCB, 0x54, 0x73, + 0xA3, 0xD1, 0xEF, 0xD0, 0xE4, 0x2F, 0xC5, 0xE8, + 0xF2, 0x76, 0x59, 0x70, 0xFB, 0x58, 0xF9, 0x72 + }, + { + 0x52, 0xAC, 0x89, 0x47, 0x0E, 0xCB, 0x6E, 0x64, + 0x40, 0x1B, 0x9C, 0xA3, 0x8F, 0x4D, 0x6D, 0x0F, + 0xE6, 0x29, 0x2D, 0x28, 0x89, 0x6C, 0x85, 0x1D, + 0x32, 0x15, 0x55, 0x32, 0x3A, 0xC3, 0x83, 0xEF, + 0x68, 0x0B, 0xA3, 0xDA, 0xD5, 0xD4, 0xE5, 0xC5, + 0xC0, 0x16, 0x62, 0xDF, 0x64, 0x11, 0x9B, 0x84, + 0x02, 0xFC, 0x9B, 0x44, 0xDC, 0x75, 0x77, 0xF6, + 0x9C, 0x5A, 0x51, 0x8C, 0x14, 0x4A, 0x4B, 0xCD + }, + { + 0x3B, 0xB5, 0xD8, 0xBF, 0xFC, 0x96, 0x93, 0x22, + 0x3A, 0xBF, 0x9A, 0x71, 0x33, 0xAC, 0x9C, 0x9A, + 0xD4, 0x1B, 0x8C, 0x22, 0x21, 0x28, 0xA6, 0x4C, + 0xCE, 0xD6, 0x6B, 0x2C, 0x95, 0x22, 0x7F, 0x33, + 0x51, 0x97, 0x0B, 0xB5, 0x4E, 0xD0, 0x0F, 0x5E, + 0xAC, 0xEA, 0xF7, 0x2D, 0x25, 0xA7, 0x8E, 0xB2, + 0xB8, 0xA8, 0x90, 0x27, 0x29, 0xB5, 0xF7, 0x99, + 0x26, 0xEA, 0x99, 0xDB, 0x65, 0xC7, 0xFB, 0x30 + }, + { + 0xF6, 0x03, 0x20, 0x50, 0x26, 0x1F, 0xA4, 0xBC, + 0x00, 0x7B, 0xC1, 0xC2, 0x0A, 0x25, 0x82, 0x12, + 0xB8, 0x95, 0xA5, 0x11, 0x11, 0x28, 0x77, 0x29, + 0x85, 0x35, 0x7C, 0x66, 0x66, 0x39, 0xA1, 0x30, + 0x54, 0x24, 0x90, 0x45, 0xAB, 0x65, 0x28, 0x1A, + 0x39, 0x77, 0xAD, 0x7A, 0x16, 0x64, 0x31, 0x3E, + 0x7B, 0xD5, 0x9D, 0x51, 0x08, 0x93, 0xC9, 0x55, + 0x08, 0xEE, 0x47, 0x18, 0x24, 0xF7, 0x05, 0xB0 + }, + { + 0xD5, 0xD2, 0xB1, 0x30, 0x5B, 0x08, 0xA7, 0xFB, + 0x79, 0xF2, 0xC7, 0x0C, 0x57, 0x27, 0x33, 0x0F, + 0xF8, 0x1B, 0x17, 0xEE, 0x89, 0xEB, 0x8F, 0xD4, + 0xCA, 0xAA, 0x55, 0x98, 0x0B, 0xDB, 0x9B, 0x31, + 0x7D, 0x99, 0x32, 0xCB, 0x52, 0x77, 0x1F, 0xE8, + 0xC7, 0x9E, 0x70, 0x82, 0x0B, 0xF4, 0x46, 0x73, + 0xB7, 0xB0, 0x2E, 0x9C, 0x86, 0x5C, 0x54, 0xA6, + 0x6C, 0x5C, 0x34, 0xE1, 0xED, 0x47, 0x96, 0x36 + }, + { + 0x51, 0xCE, 0xCB, 0xE3, 0x1A, 0xE9, 0x6B, 0xA9, + 0x83, 0x8F, 0x2C, 0x93, 0x52, 0x3C, 0x3E, 0x29, + 0x97, 0x82, 0x01, 0x61, 0xDF, 0x8F, 0x5F, 0x9E, + 0xF8, 0xA0, 0x5A, 0xD1, 0xE8, 0x0E, 0xA2, 0xAB, + 0x09, 0x4D, 0xB2, 0x68, 0x93, 0xE4, 0xC3, 0x8F, + 0x61, 0x98, 0x78, 0x03, 0x03, 0x77, 0xC7, 0xAC, + 0xF7, 0x83, 0x17, 0xD0, 0x60, 0xD1, 0xF7, 0x00, + 0x65, 0xDB, 0xA3, 0xAE, 0x0B, 0x63, 0x79, 0x00 + }, + { + 0x9A, 0x86, 0x4C, 0xB5, 0x8C, 0x7D, 0xC0, 0xC0, + 0x74, 0xD2, 0x51, 0xC0, 0xD6, 0xB4, 0x9A, 0xBA, + 0xEA, 0x93, 0x00, 0xFE, 0xE3, 0x68, 0xE3, 0x55, + 0x11, 0xAC, 0x26, 0x78, 0x59, 0x06, 0x78, 0x00, + 0x80, 0x7B, 0x66, 0x41, 0x9B, 0x02, 0x2B, 0xA3, + 0x1C, 0x53, 0xE9, 0x3A, 0x58, 0x4B, 0x1E, 0xC2, + 0x8C, 0xD9, 0xD4, 0x21, 0x37, 0xF2, 0x0C, 0xE8, + 0x10, 0x6A, 0x54, 0xAD, 0xC4, 0x0C, 0xA5, 0xAE + }, + { + 0x63, 0x2B, 0x70, 0x72, 0xCD, 0x39, 0x23, 0x94, + 0x62, 0x7F, 0x07, 0x0C, 0x7A, 0x7D, 0x30, 0x8E, + 0xFC, 0x92, 0x2E, 0x48, 0x75, 0x42, 0x8B, 0x0F, + 0x4F, 0xAB, 0x83, 0x8B, 0x1E, 0x96, 0x70, 0x48, + 0x41, 0xCE, 0x19, 0xBB, 0x2D, 0x7B, 0x7E, 0x01, + 0xB4, 0xA7, 0x07, 0x33, 0x76, 0x30, 0x27, 0x57, + 0xE2, 0xAE, 0x09, 0x05, 0xC4, 0x61, 0xCC, 0x2E, + 0xCA, 0x85, 0x19, 0xE4, 0xCF, 0xE1, 0x25, 0x8C + }, + { + 0xBA, 0x00, 0x78, 0x58, 0x16, 0xCF, 0x09, 0xA5, + 0x72, 0xBC, 0x48, 0x8F, 0x28, 0xA9, 0xD9, 0x85, + 0x58, 0xC7, 0xCB, 0xD6, 0x6C, 0x73, 0x69, 0x72, + 0xE9, 0xF7, 0x15, 0x49, 0xAD, 0xD5, 0x74, 0x68, + 0x97, 0x33, 0x30, 0xF8, 0x02, 0x36, 0xFD, 0x61, + 0x5A, 0x1A, 0xC0, 0xDA, 0x80, 0x73, 0xF3, 0x89, + 0xBC, 0x41, 0x59, 0xA6, 0xCB, 0xB9, 0x1A, 0x03, + 0x5D, 0x0E, 0x39, 0xF1, 0x39, 0x36, 0xE6, 0x5C + }, + { + 0xC1, 0x8F, 0xAA, 0x6F, 0xF7, 0xC3, 0x64, 0x6D, + 0xAF, 0x04, 0xB3, 0xF8, 0x55, 0x6D, 0x3A, 0xA8, + 0x72, 0x2D, 0x66, 0x69, 0x35, 0x94, 0x3D, 0xB8, + 0x60, 0xD8, 0x01, 0x2E, 0x29, 0x0E, 0x54, 0x41, + 0xB0, 0x19, 0x00, 0xAD, 0x96, 0x1E, 0x51, 0xDB, + 0x7F, 0x7D, 0x08, 0x34, 0x16, 0x0E, 0x43, 0x65, + 0xFD, 0xD8, 0x05, 0x5B, 0x07, 0x37, 0x8D, 0xAE, + 0x3E, 0xE0, 0x27, 0xE8, 0x00, 0x82, 0xFE, 0xC4 + }, + { + 0x35, 0xB1, 0x9F, 0x8F, 0xAF, 0x18, 0x43, 0xCB, + 0x7C, 0x5E, 0xBC, 0xB4, 0x75, 0xA8, 0xCA, 0xDE, + 0x04, 0xE5, 0xBF, 0x2C, 0x64, 0x43, 0x7E, 0x67, + 0x6A, 0xD5, 0xBE, 0xFF, 0x37, 0xBB, 0x87, 0x18, + 0x2C, 0xC2, 0xC9, 0xD3, 0x79, 0xC4, 0xDA, 0x44, + 0x10, 0x76, 0x5A, 0x77, 0x34, 0xBD, 0x3A, 0xD2, + 0x8C, 0x1F, 0x80, 0x8C, 0xC0, 0x63, 0x39, 0xEE, + 0x58, 0x6D, 0x93, 0x19, 0x41, 0x18, 0xB1, 0x83 + }, + { + 0x7A, 0x8C, 0x37, 0x91, 0xE5, 0xA8, 0x65, 0x55, + 0x78, 0xE5, 0x4D, 0xD8, 0x00, 0xDE, 0x5E, 0x71, + 0xB5, 0x81, 0xA8, 0xF1, 0x6D, 0xC6, 0x4E, 0xAB, + 0x9D, 0x65, 0x1E, 0x93, 0x4A, 0xF6, 0xD4, 0x3E, + 0x7C, 0x72, 0x61, 0xE8, 0xCE, 0x69, 0xCB, 0x9D, + 0x82, 0xC2, 0x4A, 0xAD, 0x54, 0x49, 0x81, 0x53, + 0x83, 0xEC, 0x02, 0x1D, 0x42, 0x80, 0xFB, 0x9B, + 0xEF, 0xDA, 0xBB, 0x93, 0x41, 0xDF, 0x34, 0x5C + }, + { + 0x40, 0xC6, 0x21, 0x94, 0x03, 0x3D, 0xD1, 0x5D, + 0x17, 0x92, 0xB1, 0x8F, 0x30, 0x10, 0x75, 0x0F, + 0xAF, 0x9D, 0x07, 0xDF, 0x34, 0xAA, 0x8A, 0xAF, + 0xF0, 0x17, 0x7D, 0x80, 0xBE, 0x4C, 0xFE, 0x3F, + 0xD8, 0xF2, 0x95, 0x84, 0xB5, 0xED, 0x12, 0x58, + 0x05, 0xDE, 0xD3, 0xE6, 0xD8, 0xE0, 0x26, 0xB6, + 0x5B, 0x62, 0xFE, 0x5F, 0x68, 0xEA, 0x8A, 0xDA, + 0xE8, 0x02, 0x13, 0x46, 0x68, 0x64, 0x3A, 0x6F + }, + { + 0x2D, 0x2D, 0x45, 0xC7, 0x10, 0xE7, 0xC3, 0x1E, + 0x72, 0x8C, 0x99, 0x9B, 0x18, 0x1C, 0x46, 0x78, + 0x16, 0x26, 0xFA, 0xCA, 0x65, 0xA2, 0x7D, 0x4D, + 0x68, 0xE3, 0x69, 0x0E, 0x57, 0xA5, 0x7C, 0xB4, + 0x0D, 0xCF, 0x99, 0xDE, 0xA9, 0x9E, 0x87, 0xA4, + 0x4B, 0x5F, 0x45, 0xFB, 0xBE, 0xA8, 0x77, 0x1D, + 0x57, 0x7F, 0x66, 0x0A, 0xBC, 0xEA, 0x3F, 0xAF, + 0xE6, 0x8B, 0x93, 0xD7, 0x47, 0x7B, 0x82, 0xA2 + }, + { + 0x79, 0xA5, 0xD6, 0x2D, 0x91, 0xA8, 0xF0, 0x3B, + 0x8C, 0xB7, 0x37, 0x0B, 0xC4, 0xA7, 0x82, 0xBD, + 0x05, 0x5D, 0x43, 0xAC, 0x89, 0x52, 0xEA, 0x34, + 0x9D, 0xEB, 0xAC, 0xF7, 0x8A, 0x98, 0x86, 0x3D, + 0x14, 0xBD, 0x70, 0xF5, 0x1D, 0x78, 0xB0, 0xE2, + 0xC2, 0xEC, 0x8A, 0xCC, 0x06, 0xAE, 0xFF, 0x6C, + 0xD3, 0x75, 0xCC, 0x7B, 0x5B, 0x81, 0x96, 0xF9, + 0x84, 0x5A, 0xDD, 0xDD, 0x23, 0x17, 0xD0, 0xBF + }, + { + 0xCE, 0x11, 0x54, 0xB1, 0x37, 0x6E, 0x8C, 0x5B, + 0x03, 0x78, 0x9F, 0x58, 0x35, 0x30, 0x95, 0x5B, + 0xF1, 0x06, 0xEA, 0x98, 0x85, 0x0F, 0x06, 0x21, + 0xBD, 0x99, 0x6C, 0xE6, 0xA7, 0xE1, 0x3B, 0x92, + 0x6E, 0x2E, 0x67, 0x77, 0x99, 0x4B, 0x91, 0x61, + 0xB0, 0xD3, 0xFF, 0x0E, 0x3C, 0x34, 0x81, 0x09, + 0x2D, 0x8D, 0x0D, 0xAB, 0x19, 0xCE, 0x83, 0x40, + 0x5B, 0xFF, 0x2B, 0x31, 0xBA, 0x46, 0x53, 0x69 + }, + { + 0x80, 0x5C, 0x81, 0x2E, 0xBF, 0x5E, 0xE3, 0x50, + 0xC6, 0xFE, 0x7C, 0xD9, 0x65, 0x44, 0x58, 0x22, + 0x10, 0x1F, 0x3B, 0xEB, 0x47, 0x5A, 0xF4, 0x74, + 0xC4, 0x2F, 0xA5, 0xDC, 0x8C, 0x40, 0x2F, 0x9D, + 0x2B, 0x5D, 0x9A, 0x93, 0x72, 0xA2, 0x31, 0x48, + 0xAE, 0x61, 0xA2, 0x64, 0x0D, 0x12, 0x22, 0xA8, + 0x0B, 0x3D, 0xE2, 0x89, 0x1F, 0xDC, 0xB9, 0xBC, + 0x98, 0xB7, 0x53, 0x99, 0x26, 0x2C, 0xB9, 0xBA + }, + { + 0xA8, 0x52, 0xF1, 0xD5, 0x55, 0x2A, 0xA7, 0xDA, + 0xF5, 0x24, 0xC4, 0x58, 0x94, 0x49, 0x7D, 0x22, + 0x77, 0xD4, 0x50, 0x99, 0xBE, 0x07, 0xB7, 0x8A, + 0x7F, 0x42, 0xFF, 0x11, 0xE1, 0x6F, 0xCE, 0x4B, + 0x33, 0x5A, 0xE0, 0xC9, 0xD6, 0x8B, 0x67, 0x97, + 0xA7, 0x0F, 0xBF, 0x5A, 0x21, 0x1C, 0x0F, 0x1D, + 0xF0, 0x98, 0x88, 0x00, 0x0E, 0xD1, 0x07, 0xC8, + 0x84, 0xDE, 0x4F, 0x2F, 0xA9, 0xE3, 0xF5, 0x3F + }, + { + 0x8A, 0xCA, 0x6B, 0xBC, 0x61, 0xD0, 0x99, 0x38, + 0x03, 0x0D, 0x7B, 0xC1, 0x8B, 0x0A, 0x7E, 0x52, + 0x9F, 0xAC, 0x05, 0x0B, 0x0B, 0xEC, 0x13, 0xE2, + 0xA1, 0x65, 0xEB, 0x5C, 0x61, 0x03, 0xA8, 0x4D, + 0x35, 0xFF, 0xDA, 0x6B, 0x07, 0x29, 0xAF, 0x9B, + 0xFA, 0xF7, 0xB9, 0x1F, 0xB9, 0xBA, 0x37, 0xB7, + 0x66, 0x1B, 0xAA, 0x97, 0xEE, 0xFE, 0xFE, 0x5E, + 0x22, 0xF6, 0x3E, 0x41, 0x66, 0xF0, 0x75, 0x9D + }, + { + 0xE0, 0x80, 0x51, 0x47, 0xA8, 0xAD, 0xCE, 0xBE, + 0x58, 0x66, 0x71, 0x16, 0xB3, 0xED, 0x29, 0xBE, + 0x96, 0x1A, 0x34, 0x0B, 0xD4, 0x11, 0x53, 0x69, + 0x70, 0x06, 0x69, 0x42, 0xC2, 0x42, 0x45, 0xF6, + 0x5F, 0x5F, 0xE6, 0x9B, 0xA5, 0xE0, 0xB3, 0x84, + 0x54, 0x0E, 0x86, 0x3D, 0x0C, 0x8D, 0x08, 0x7E, + 0xA2, 0x5B, 0x67, 0x25, 0x7B, 0x93, 0x82, 0xBE, + 0x40, 0x5C, 0x65, 0x3A, 0x90, 0xA6, 0xB5, 0x5F + }, + { + 0xF5, 0x50, 0x1D, 0xF1, 0x54, 0x14, 0xE1, 0x27, + 0x83, 0x02, 0x2A, 0x60, 0xBB, 0x58, 0x30, 0x37, + 0x91, 0x0F, 0xF3, 0x91, 0xAE, 0x7C, 0x5E, 0x3F, + 0xB0, 0xFE, 0x0F, 0x8D, 0x94, 0xAE, 0x6F, 0x51, + 0x12, 0x8E, 0x68, 0xC1, 0x6B, 0x1B, 0x82, 0xCE, + 0xF6, 0x90, 0xBD, 0x7E, 0x10, 0x83, 0x11, 0x2B, + 0x8F, 0x63, 0xE5, 0xD9, 0x79, 0xB6, 0xB2, 0x4D, + 0x9D, 0xBC, 0x57, 0x66, 0xA7, 0x20, 0x83, 0x48 + }, + { + 0x06, 0x23, 0xB1, 0xAE, 0xD4, 0xB9, 0x71, 0x56, + 0x71, 0xDF, 0x32, 0xF5, 0xCF, 0xC6, 0xF2, 0x93, + 0xA1, 0xA6, 0x24, 0x00, 0xBA, 0x1D, 0x8C, 0x7A, + 0x4D, 0xD9, 0xF0, 0xBF, 0x65, 0xD4, 0xB5, 0x33, + 0x10, 0xD7, 0x29, 0x2E, 0xB7, 0x1B, 0xEA, 0x04, + 0x14, 0x00, 0x33, 0x0C, 0x43, 0xDA, 0x10, 0x17, + 0x68, 0x28, 0x12, 0xBA, 0x9F, 0x59, 0x09, 0x06, + 0xCF, 0x20, 0x75, 0x83, 0x7F, 0x0D, 0x2D, 0x2B + }, + { + 0x07, 0xF1, 0xEB, 0xD3, 0x3F, 0x6A, 0x3F, 0x6F, + 0xBC, 0x22, 0xEA, 0x9A, 0xAB, 0x59, 0xA4, 0xC5, + 0xE6, 0x1D, 0x38, 0x4D, 0x17, 0x2B, 0x3E, 0x16, + 0x42, 0x33, 0x94, 0x2E, 0xAE, 0x93, 0x82, 0x86, + 0x0F, 0x87, 0xC1, 0x69, 0x5F, 0x87, 0xEC, 0xA0, + 0x50, 0x02, 0xC8, 0xD0, 0xE9, 0xFA, 0x9C, 0x6D, + 0x80, 0x81, 0x36, 0x99, 0xAE, 0xC7, 0x24, 0xAF, + 0x7E, 0x18, 0x6E, 0x8C, 0xFC, 0xDB, 0xF3, 0x5D + }, + { + 0x30, 0x97, 0x7B, 0xB0, 0x80, 0x0B, 0x04, 0xB7, + 0x5E, 0x86, 0xCB, 0x26, 0xB9, 0xFB, 0x06, 0x3A, + 0x4A, 0x95, 0x45, 0xF5, 0xAB, 0x57, 0x87, 0x7D, + 0x95, 0xF0, 0xE0, 0x82, 0xCC, 0x21, 0x0B, 0x6C, + 0xA9, 0xD9, 0x2A, 0x6F, 0x34, 0x12, 0x58, 0xE1, + 0xB1, 0x33, 0x5B, 0xC6, 0xD5, 0xD2, 0xC3, 0xB7, + 0xDF, 0xDE, 0x6B, 0xD4, 0x21, 0x79, 0xD8, 0x1A, + 0x34, 0x7B, 0xB4, 0xBB, 0x5A, 0x6C, 0x65, 0xA3 + }, + { + 0x52, 0x0A, 0x6B, 0x12, 0x94, 0xAE, 0x6A, 0x4E, + 0x9C, 0xA8, 0x75, 0x63, 0xD9, 0x4D, 0xA4, 0xB0, + 0xCF, 0x3A, 0x47, 0xF4, 0x0C, 0x36, 0xF7, 0xD1, + 0xAD, 0xD9, 0xCD, 0xB8, 0x7D, 0x28, 0x11, 0x33, + 0x28, 0x6A, 0xF0, 0xD2, 0x55, 0xEA, 0x66, 0x2F, + 0x15, 0x54, 0x0C, 0x71, 0x4C, 0x2C, 0x15, 0x68, + 0x14, 0x47, 0xB1, 0xCA, 0x2A, 0x1C, 0x90, 0x0D, + 0xD0, 0x00, 0xEB, 0x3C, 0x2C, 0xF1, 0x94, 0x88 + }, + { + 0xFE, 0xE5, 0xE3, 0xC6, 0xEC, 0x28, 0x26, 0x1B, + 0x5A, 0x78, 0xEE, 0xE7, 0xD5, 0xDE, 0xCC, 0x7E, + 0x2E, 0x24, 0xB8, 0xDE, 0x2B, 0xA0, 0x16, 0x88, + 0xE7, 0x00, 0x42, 0xE3, 0x1C, 0xD9, 0x7F, 0x18, + 0xA4, 0x3C, 0x29, 0x5E, 0x09, 0x34, 0xAD, 0xD8, + 0xA7, 0x89, 0x32, 0xFE, 0xD0, 0x5A, 0x47, 0xAC, + 0xC7, 0xC6, 0xFA, 0x24, 0x97, 0x80, 0xB3, 0xAA, + 0xEC, 0xF4, 0x41, 0xA1, 0x3A, 0xBB, 0x34, 0xCD + }, + { + 0x47, 0x4F, 0x97, 0xFF, 0x77, 0x82, 0xD9, 0x98, + 0x55, 0xBF, 0x1F, 0x52, 0xA3, 0x3C, 0xE3, 0xE6, + 0x00, 0x0A, 0x2E, 0xDA, 0x69, 0xBC, 0xB8, 0x2D, + 0x88, 0xB0, 0x86, 0x73, 0xBC, 0xF6, 0x0E, 0x88, + 0x05, 0x92, 0xF1, 0xC3, 0x46, 0x0E, 0xCF, 0xEF, + 0xD6, 0xF1, 0x42, 0xED, 0x7F, 0x3F, 0xCD, 0xE1, + 0xC3, 0x6A, 0x7D, 0x15, 0x7F, 0x7A, 0xA7, 0xDD, + 0x56, 0x5D, 0x26, 0x9E, 0x49, 0x9A, 0xE9, 0x1F + }, + { + 0xA7, 0x6D, 0xD1, 0xAB, 0x7E, 0xDA, 0x57, 0x52, + 0xC5, 0xB4, 0x2A, 0x85, 0x29, 0x63, 0xD1, 0x0D, + 0x61, 0x52, 0x8C, 0x07, 0x51, 0x4E, 0x5B, 0xDE, + 0xBC, 0xE1, 0x21, 0x7B, 0x7E, 0x5D, 0x97, 0x89, + 0xBF, 0x29, 0xD1, 0x57, 0x6C, 0xA7, 0x4A, 0x97, + 0x51, 0x7B, 0xC8, 0xC0, 0x25, 0xCC, 0xB8, 0x6E, + 0x20, 0x4E, 0x4D, 0xA8, 0x19, 0x7D, 0xEF, 0x36, + 0x79, 0xB3, 0x3B, 0x61, 0xC1, 0x6F, 0x2E, 0x32 + }, + { + 0x67, 0x36, 0x8F, 0x54, 0xC7, 0xB5, 0x7E, 0x59, + 0xFA, 0xA7, 0x3F, 0xCD, 0xE3, 0xCD, 0xE7, 0xEA, + 0xB2, 0x04, 0x45, 0x6A, 0xC9, 0xC3, 0xC1, 0x48, + 0x3F, 0xBB, 0x69, 0x03, 0xDC, 0xC2, 0xB2, 0xD3, + 0x26, 0x82, 0xF3, 0x4D, 0x56, 0x88, 0xAD, 0x6E, + 0x29, 0xCF, 0xA6, 0x48, 0xC9, 0xDF, 0x71, 0x07, + 0xE2, 0x92, 0xF4, 0x21, 0x43, 0xE6, 0x1B, 0x85, + 0x2E, 0x36, 0xB7, 0xE8, 0xC3, 0x18, 0x31, 0x93 + }, + { + 0x96, 0x56, 0x80, 0x4F, 0x23, 0x44, 0x28, 0x12, + 0xA7, 0x5F, 0xE9, 0xC4, 0x3B, 0x9B, 0x75, 0x69, + 0xE7, 0x83, 0x78, 0xB2, 0xB5, 0xEC, 0x7D, 0x07, + 0xC5, 0xD2, 0x33, 0xEA, 0xB0, 0x6F, 0x6E, 0x40, + 0xEC, 0x82, 0x7E, 0xD9, 0xC8, 0x6E, 0xA5, 0x51, + 0x58, 0x47, 0x74, 0x0B, 0xAB, 0xFB, 0xA5, 0xE7, + 0x0F, 0x6C, 0xF8, 0x82, 0xEB, 0xE6, 0x53, 0xC6, + 0x29, 0xFA, 0xA9, 0xE7, 0x8F, 0xA0, 0xC2, 0x75 + }, + { + 0x1E, 0x86, 0x52, 0xE2, 0x8A, 0x9E, 0x60, 0x3F, + 0xE5, 0xDE, 0x9D, 0xCA, 0x9F, 0x53, 0x6E, 0x72, + 0x62, 0x12, 0xD5, 0xFE, 0x19, 0x6B, 0xAF, 0x86, + 0xD6, 0x4F, 0x44, 0xE9, 0x56, 0x5D, 0xB8, 0x65, + 0xCA, 0x8C, 0x25, 0xAE, 0x0F, 0x72, 0x04, 0x23, + 0x8C, 0x02, 0x4B, 0x4E, 0x96, 0x20, 0xD5, 0xDB, + 0xDC, 0xA7, 0x5E, 0x1D, 0x21, 0xB0, 0xE4, 0x26, + 0x2C, 0xF2, 0xE6, 0xB0, 0xA2, 0x11, 0xC4, 0x55 + }, + { + 0x9D, 0x1D, 0xB9, 0xC9, 0xAD, 0x45, 0x0D, 0x19, + 0xB4, 0xBE, 0x37, 0x5C, 0xA2, 0x93, 0xD5, 0xF8, + 0x37, 0x2E, 0x3E, 0xD9, 0xA5, 0xB0, 0xF3, 0x46, + 0x5D, 0x51, 0x8A, 0x39, 0x80, 0x26, 0x0C, 0x64, + 0xC8, 0x20, 0x0A, 0x8F, 0x8A, 0x86, 0xBD, 0xB3, + 0xBE, 0xA2, 0x87, 0x74, 0x5A, 0xC8, 0xE4, 0x9F, + 0x34, 0x34, 0x06, 0x33, 0x4C, 0x88, 0x04, 0x6F, + 0x04, 0x9B, 0x3A, 0x63, 0xC5, 0xF5, 0x07, 0x9D + }, + { + 0x95, 0x36, 0xCC, 0xCA, 0xBE, 0xDB, 0xE7, 0xF3, + 0x58, 0x6E, 0x48, 0xE7, 0x8A, 0x94, 0x23, 0x81, + 0xDB, 0xD5, 0xF1, 0xF0, 0x73, 0x00, 0x4E, 0x09, + 0x8C, 0xC8, 0x27, 0xBC, 0x9D, 0x3A, 0x35, 0xD3, + 0x2A, 0x8C, 0xC2, 0x1B, 0x26, 0xB5, 0xA5, 0xFC, + 0xA6, 0x69, 0x30, 0xE3, 0x62, 0xD9, 0xB5, 0x0A, + 0xC1, 0xE7, 0xA7, 0x20, 0x93, 0x1A, 0xEB, 0x48, + 0x43, 0xE7, 0x3C, 0x45, 0x50, 0x2F, 0x74, 0xBE + }, + { + 0xF1, 0x34, 0xDF, 0xB0, 0x35, 0x92, 0x51, 0x26, + 0x91, 0xB0, 0x6E, 0x17, 0x01, 0xDB, 0x0B, 0x0F, + 0x05, 0x31, 0x69, 0x75, 0x95, 0x7B, 0x08, 0xF5, + 0x12, 0xD8, 0xCC, 0xAC, 0x7D, 0x3C, 0x21, 0x4B, + 0xE9, 0xDA, 0x1D, 0x0D, 0x73, 0x5B, 0xDC, 0x2B, + 0xFC, 0x82, 0x04, 0xA4, 0x46, 0x94, 0xED, 0x9B, + 0x40, 0x47, 0x7D, 0x6B, 0xE7, 0x37, 0x3C, 0x57, + 0x10, 0x0A, 0x01, 0xE6, 0x3F, 0xB5, 0x36, 0xDA + }, + { + 0x82, 0x6F, 0x80, 0x00, 0xCC, 0x75, 0x36, 0x82, + 0xDD, 0x14, 0x6B, 0x0E, 0xCA, 0xA3, 0x3A, 0xF0, + 0x74, 0x82, 0x3D, 0xF4, 0x47, 0x76, 0xF1, 0x6F, + 0x47, 0x49, 0xEF, 0x67, 0xFB, 0x5B, 0xFA, 0xC5, + 0x80, 0xBE, 0x5E, 0x05, 0xE4, 0x46, 0xF8, 0x43, + 0xB5, 0xFA, 0xD4, 0xC1, 0x24, 0x7A, 0xF1, 0x71, + 0x63, 0x3C, 0x25, 0x4E, 0x46, 0x96, 0x1B, 0x12, + 0xED, 0x27, 0x78, 0x0F, 0x95, 0x34, 0x69, 0x38 + }, + { + 0x8C, 0x45, 0xC7, 0x67, 0xDC, 0x13, 0xE7, 0x59, + 0x84, 0xBF, 0x57, 0x2A, 0x40, 0x7E, 0xBB, 0xCE, + 0xE0, 0xCD, 0xE4, 0xDB, 0x09, 0x41, 0xC2, 0xF5, + 0x9F, 0x43, 0x86, 0x9A, 0x12, 0x12, 0xA4, 0xE6, + 0x77, 0xA2, 0x81, 0xA9, 0xC3, 0x6E, 0x8C, 0x47, + 0x3D, 0x99, 0x53, 0xDE, 0xB8, 0x2E, 0x5C, 0x67, + 0xD2, 0x44, 0x23, 0xFC, 0x8A, 0xE7, 0xEF, 0xF4, + 0xEB, 0xC6, 0xCB, 0x1C, 0xDC, 0xBB, 0x96, 0x92 + }, + { + 0xC9, 0x3B, 0xDF, 0xB1, 0x2A, 0x05, 0x53, 0x7D, + 0x25, 0x5B, 0xF5, 0x45, 0xFF, 0x74, 0xF8, 0xD0, + 0x87, 0x91, 0x46, 0xC6, 0x28, 0x5E, 0xF6, 0xD1, + 0x71, 0xCC, 0x7C, 0x3F, 0xED, 0xDD, 0x82, 0x65, + 0x31, 0x28, 0xCE, 0xB8, 0x99, 0xE8, 0xEA, 0xE3, + 0x3C, 0xC8, 0x1F, 0x6C, 0x93, 0xD1, 0xE7, 0x9A, + 0xF7, 0xD9, 0xCD, 0xAE, 0x13, 0x1B, 0x3A, 0x04, + 0xCF, 0x68, 0xAC, 0xC3, 0xD4, 0x51, 0x9C, 0x84 + }, + { + 0x89, 0x12, 0x2D, 0x72, 0x5B, 0xB4, 0xA8, 0xF2, + 0x88, 0x36, 0x4D, 0x78, 0xBD, 0xDC, 0x04, 0xDD, + 0xC4, 0x3B, 0x9D, 0xA6, 0x8A, 0x29, 0x6E, 0x70, + 0xA1, 0x1D, 0xCE, 0x96, 0x8F, 0xF9, 0xD9, 0x88, + 0xCC, 0x9C, 0xAD, 0x88, 0x3F, 0x4C, 0x2A, 0x3C, + 0x1C, 0x89, 0x21, 0x1B, 0xA8, 0x05, 0x18, 0x17, + 0x2A, 0x4B, 0xD5, 0xED, 0x3F, 0x44, 0x86, 0xAF, + 0x25, 0x43, 0xAD, 0x07, 0xD2, 0x31, 0xC2, 0xB7 + }, + { + 0x7A, 0x44, 0x1B, 0x0C, 0xA5, 0x48, 0xA6, 0xBC, + 0xF1, 0x09, 0x37, 0x4D, 0xC9, 0x76, 0xB1, 0xEC, + 0x20, 0xCB, 0x2B, 0xBD, 0x8A, 0xBE, 0x82, 0xCC, + 0x77, 0x06, 0x0D, 0xE1, 0x92, 0xE6, 0xDD, 0x0A, + 0x16, 0x2D, 0x3C, 0xDF, 0xA9, 0xA3, 0xBC, 0x85, + 0xD0, 0x09, 0x5A, 0xE6, 0xB8, 0x91, 0x4D, 0x48, + 0x9E, 0xE3, 0x1B, 0x67, 0x81, 0x34, 0xD4, 0x29, + 0x6B, 0x0A, 0x9D, 0x93, 0xE6, 0x6D, 0x53, 0xC5 + }, + { + 0x19, 0x0F, 0x0D, 0xD6, 0xA7, 0xE4, 0x66, 0x5C, + 0x14, 0x2C, 0x33, 0xB6, 0xD8, 0xAE, 0x59, 0xD8, + 0x13, 0xB1, 0xE6, 0xC5, 0xF2, 0x8B, 0x91, 0x91, + 0x49, 0xB3, 0x2A, 0xD9, 0xB1, 0x3C, 0x7D, 0x1A, + 0xD4, 0x15, 0x3A, 0x31, 0xB5, 0x87, 0xE2, 0x84, + 0x98, 0x73, 0xC3, 0xCD, 0x56, 0xCD, 0xEB, 0x36, + 0x78, 0x54, 0xA9, 0x3B, 0x26, 0x49, 0x97, 0x23, + 0xED, 0xED, 0xFA, 0x03, 0x08, 0x16, 0xDB, 0xBD + }, + { + 0x56, 0x96, 0x4B, 0xD6, 0xF2, 0x3F, 0xC8, 0xC6, + 0x9A, 0x88, 0x6F, 0x56, 0x5A, 0x3E, 0x08, 0x54, + 0xF6, 0x16, 0xE8, 0x04, 0x8B, 0xE0, 0x14, 0xF4, + 0x38, 0x45, 0x2D, 0x57, 0xAF, 0x8C, 0x28, 0x59, + 0xC1, 0x92, 0x90, 0x4B, 0xEB, 0x83, 0xFD, 0xC0, + 0x08, 0x0A, 0xCA, 0xF9, 0xB1, 0x1B, 0x71, 0x86, + 0xA5, 0xAF, 0x5A, 0x60, 0x6E, 0xC7, 0x68, 0x7E, + 0x44, 0x3F, 0xA1, 0x40, 0x90, 0x3E, 0xF6, 0x3C + }, + { + 0x1A, 0x65, 0xD9, 0x98, 0x21, 0xE1, 0x22, 0x21, + 0xD4, 0x53, 0x9E, 0x70, 0x93, 0x2C, 0x8E, 0x7A, + 0x4B, 0x9A, 0x2A, 0xB6, 0x1D, 0x2C, 0xE9, 0xE3, + 0xC3, 0xD8, 0x89, 0xC5, 0x7D, 0x30, 0xCF, 0xC5, + 0xB4, 0xFD, 0x1A, 0x21, 0xF0, 0x27, 0xB6, 0x63, + 0x87, 0xCB, 0xFD, 0xC3, 0x5B, 0xF7, 0x2D, 0xEE, + 0xC4, 0x27, 0xDE, 0xB1, 0x1B, 0xDF, 0x60, 0x56, + 0x7E, 0xAE, 0xEA, 0x47, 0x7F, 0x8E, 0xE4, 0x41 + }, + { + 0x1D, 0xDF, 0x09, 0x9B, 0x1B, 0xAC, 0xDA, 0x9F, + 0xE5, 0xF5, 0x8D, 0xE7, 0x31, 0x83, 0x4A, 0xFD, + 0x13, 0x48, 0x44, 0x70, 0xCB, 0xB8, 0x0A, 0xA1, + 0x8C, 0xB5, 0x4B, 0x68, 0xA9, 0x13, 0x52, 0x28, + 0xF7, 0x6E, 0x2B, 0x9E, 0x19, 0x82, 0x2C, 0x2A, + 0x55, 0x5A, 0xBE, 0xDC, 0xCF, 0x8C, 0x3C, 0x77, + 0xFF, 0xB9, 0xED, 0x28, 0xDD, 0x52, 0xD1, 0x57, + 0xDD, 0x82, 0xCA, 0xD5, 0x7C, 0xF0, 0xC2, 0xE7 + }, + { + 0x73, 0xB1, 0x4A, 0x92, 0xD7, 0x5C, 0xDA, 0x00, + 0xD3, 0xF9, 0xB2, 0x6C, 0xA3, 0x01, 0x03, 0x54, + 0xC1, 0x23, 0xC2, 0xB9, 0x70, 0x6A, 0x40, 0xC0, + 0x30, 0x50, 0xA4, 0xF9, 0x28, 0x9A, 0x0B, 0xBD, + 0x41, 0x19, 0xCC, 0x78, 0xCC, 0x5C, 0xF5, 0xD4, + 0x43, 0x59, 0x07, 0x8A, 0x2D, 0x2C, 0x87, 0xA7, + 0xEB, 0xF7, 0xC0, 0x70, 0x3E, 0x0F, 0xE5, 0xE6, + 0x4D, 0x92, 0x0B, 0x79, 0x8D, 0xB7, 0xC8, 0x4C + }, + { + 0x08, 0xD7, 0x5D, 0x52, 0xE8, 0x14, 0x4B, 0xFA, + 0x76, 0x35, 0xD0, 0xF1, 0xDB, 0xBC, 0x17, 0xEE, + 0x16, 0xE2, 0x32, 0xBF, 0xDA, 0xA4, 0xA5, 0x2A, + 0x43, 0xBD, 0xD4, 0x8C, 0x18, 0x03, 0x70, 0x9D, + 0xE0, 0xEF, 0xB6, 0x4C, 0xA1, 0x5E, 0x64, 0xF6, + 0xF1, 0x02, 0xB9, 0xBA, 0x1C, 0xEE, 0x15, 0x5F, + 0x2E, 0x5A, 0xF8, 0x5B, 0x33, 0xA9, 0xFD, 0x77, + 0x18, 0xD0, 0x68, 0xD7, 0xEE, 0x6E, 0x24, 0x60 + }, + { + 0x4A, 0x8E, 0x6D, 0xCD, 0x6B, 0xB0, 0x0C, 0x75, + 0xF3, 0x6B, 0xAF, 0x2C, 0x48, 0xC5, 0xB5, 0xA7, + 0xB3, 0x52, 0x44, 0xBC, 0x14, 0xB6, 0x52, 0x63, + 0xF1, 0x85, 0x76, 0x27, 0xE9, 0x46, 0x55, 0xA8, + 0xCC, 0x6A, 0xE9, 0xDD, 0x88, 0xEA, 0x6A, 0xC9, + 0x27, 0xE1, 0xC9, 0x38, 0x53, 0x7B, 0xC4, 0x31, + 0xF4, 0xCC, 0x2A, 0x0C, 0x4A, 0xA8, 0x17, 0x64, + 0x1F, 0xAD, 0xCC, 0xE0, 0xD5, 0x96, 0xF7, 0xCF + }, + { + 0x0D, 0xE9, 0xFE, 0x6C, 0x62, 0x09, 0x00, 0x59, + 0x34, 0x96, 0xB7, 0x21, 0x83, 0xE9, 0xF8, 0x82, + 0x8F, 0xEE, 0xD3, 0xBD, 0x8F, 0xF4, 0x90, 0x99, + 0x14, 0x88, 0x59, 0x19, 0x25, 0x25, 0x21, 0xF7, + 0x95, 0x0C, 0x47, 0x15, 0x8A, 0x8F, 0x20, 0x50, + 0xC6, 0x5A, 0x04, 0x24, 0x6B, 0x18, 0x93, 0x8B, + 0x06, 0xA4, 0xA2, 0x08, 0x8C, 0xFD, 0xB8, 0x71, + 0x7B, 0x98, 0xFD, 0x2D, 0x75, 0xB6, 0x6D, 0x32 + }, + { + 0xCF, 0x92, 0x26, 0xE1, 0x01, 0x61, 0x2B, 0x37, + 0x8F, 0x7B, 0x41, 0x33, 0x11, 0xE8, 0x82, 0xD3, + 0xE9, 0x83, 0xFB, 0x23, 0x08, 0x6F, 0x52, 0x85, + 0xF4, 0x9D, 0xB6, 0x3A, 0xDC, 0x14, 0x23, 0x1A, + 0x57, 0x48, 0xEF, 0xDD, 0xDE, 0x3B, 0x70, 0x61, + 0x04, 0xCE, 0x29, 0x01, 0x34, 0x8E, 0x64, 0x85, + 0xF3, 0x8F, 0xDE, 0x85, 0x9F, 0xDB, 0x1B, 0xD8, + 0x36, 0x3C, 0x12, 0xE5, 0x78, 0xAA, 0xBC, 0x54 + }, + { + 0x35, 0x30, 0xEC, 0x09, 0x83, 0x86, 0xDF, 0x50, + 0xF2, 0xAA, 0x47, 0xD7, 0xBA, 0x8E, 0x08, 0x71, + 0xA6, 0x3A, 0x6B, 0x8F, 0x58, 0xA2, 0xEF, 0x05, + 0x88, 0xE6, 0x6C, 0x74, 0x65, 0x88, 0x71, 0xA5, + 0x17, 0xE4, 0x14, 0xA1, 0x82, 0x7C, 0x71, 0x19, + 0xD6, 0xE0, 0x0D, 0x29, 0xD2, 0xE5, 0xE5, 0x17, + 0x1D, 0x36, 0x6D, 0x8E, 0x79, 0xD3, 0x3E, 0xE6, + 0x43, 0x62, 0x05, 0x26, 0x56, 0x6C, 0x29, 0x76 + }, + { + 0x9E, 0x46, 0x92, 0x26, 0x63, 0xD1, 0xFB, 0x73, + 0xE4, 0x6C, 0x48, 0xE2, 0xAD, 0xFD, 0xF2, 0xC3, + 0x83, 0x17, 0x57, 0x6A, 0xAC, 0x45, 0x3F, 0x1F, + 0x05, 0x9C, 0x6C, 0x12, 0x7B, 0xCD, 0x94, 0xB3, + 0x58, 0xB8, 0xFB, 0xCA, 0x0E, 0xD3, 0x11, 0xF3, + 0x7A, 0x7B, 0xEF, 0xC5, 0xEF, 0xB6, 0xD7, 0x0A, + 0x80, 0x17, 0xEC, 0xF0, 0xB3, 0x15, 0x91, 0xC3, + 0x01, 0x4D, 0x1F, 0x5D, 0xCC, 0x84, 0x69, 0x72 + }, + { + 0xA1, 0x34, 0xE8, 0xBD, 0x30, 0xD5, 0xDF, 0x2E, + 0x39, 0x00, 0x3E, 0x32, 0x9D, 0x97, 0xD0, 0x80, + 0x55, 0x74, 0xAB, 0xF6, 0xB5, 0x8F, 0xEB, 0xA1, + 0x9E, 0xEA, 0x32, 0x0B, 0xF5, 0xE1, 0x72, 0x9A, + 0xF5, 0x03, 0x6A, 0xF8, 0xA1, 0x8B, 0x1C, 0xCC, + 0x0B, 0xCB, 0x22, 0x4B, 0x92, 0xFA, 0x76, 0x62, + 0x59, 0xB1, 0x54, 0x93, 0xE1, 0xCB, 0xD3, 0xCE, + 0x19, 0xA4, 0x35, 0x09, 0x7A, 0xE9, 0xC2, 0x3B + }, + { + 0xE1, 0x9F, 0x26, 0x03, 0xB6, 0xEE, 0x05, 0x57, + 0x93, 0xF8, 0x0B, 0xD2, 0xB5, 0xE9, 0x09, 0x5A, + 0xEF, 0x7E, 0x99, 0x82, 0xB8, 0xEB, 0xBE, 0x72, + 0x20, 0x69, 0x05, 0x2C, 0xFE, 0x29, 0xB0, 0xEB, + 0x7E, 0x10, 0xC2, 0xF8, 0x3B, 0x81, 0x46, 0xF6, + 0xB4, 0x9D, 0x00, 0xAE, 0xE9, 0x90, 0x25, 0xC5, + 0xD4, 0xB1, 0x25, 0x59, 0x9D, 0xD8, 0x44, 0x04, + 0xCC, 0x2E, 0xD5, 0xC9, 0x2F, 0x02, 0x36, 0x47 + }, + { + 0x45, 0x98, 0x00, 0x72, 0x7C, 0x79, 0x23, 0x76, + 0x67, 0x35, 0xA1, 0xC1, 0xEE, 0x6F, 0x34, 0xE1, + 0x1B, 0x2D, 0x35, 0x67, 0xA1, 0xE2, 0xBB, 0x94, + 0xDD, 0x24, 0xBD, 0xED, 0x01, 0x48, 0x8E, 0x32, + 0x3E, 0x8F, 0x39, 0x42, 0xE8, 0x79, 0x85, 0x2E, + 0x05, 0x61, 0xD7, 0xE5, 0x57, 0x92, 0x9B, 0x94, + 0x81, 0xF0, 0x27, 0xA5, 0x1C, 0x27, 0x50, 0x06, + 0x7A, 0xD3, 0x1A, 0x63, 0x46, 0x5F, 0xA3, 0xC7 + }, + { + 0xB2, 0x09, 0xB3, 0xAD, 0xE2, 0x9E, 0x9C, 0x58, + 0x22, 0x09, 0x0B, 0x9B, 0x75, 0x5F, 0xDA, 0xA6, + 0x79, 0xDB, 0x80, 0x57, 0x55, 0x4E, 0x74, 0xE4, + 0x97, 0x6A, 0xAF, 0xFA, 0xA8, 0xC9, 0x0E, 0xF3, + 0x85, 0x0A, 0x4D, 0x5A, 0x0B, 0xF5, 0xC9, 0x02, + 0x40, 0x54, 0xC8, 0xB9, 0x71, 0x08, 0xD8, 0xB5, + 0x34, 0x30, 0x4A, 0xEF, 0x34, 0xFD, 0x64, 0x95, + 0xCC, 0xF1, 0x44, 0x05, 0x32, 0x32, 0xDF, 0x87 + }, + { + 0xB1, 0x52, 0xEF, 0x79, 0x54, 0x76, 0x13, 0x95, + 0x26, 0xB0, 0x3A, 0x99, 0x9F, 0xDC, 0xF2, 0xF0, + 0xBB, 0x92, 0xAE, 0xDE, 0xFC, 0x32, 0x82, 0x31, + 0x56, 0x69, 0xF5, 0xD5, 0x0D, 0x6C, 0x42, 0x9C, + 0xE9, 0x08, 0xBE, 0xC3, 0x87, 0xAC, 0x63, 0xF2, + 0xDC, 0xA9, 0xB0, 0xB0, 0xB6, 0x3E, 0xA3, 0x6F, + 0x29, 0x6F, 0x33, 0x35, 0xFB, 0x0C, 0x55, 0xD2, + 0x1C, 0x61, 0xD5, 0xFF, 0x55, 0x2D, 0x31, 0x1F + }, + { + 0x2F, 0x8A, 0x5F, 0x86, 0xA0, 0x1F, 0x0A, 0x0A, + 0xA7, 0x8C, 0x46, 0x97, 0xD7, 0x74, 0xFB, 0xC6, + 0x59, 0xC1, 0x99, 0x24, 0xC4, 0xC7, 0x61, 0xF0, + 0x94, 0x43, 0x84, 0x77, 0xD2, 0x70, 0x6C, 0x08, + 0x6B, 0xF7, 0xC9, 0xED, 0xB4, 0x08, 0x8B, 0x59, + 0x10, 0x5E, 0x2A, 0xA3, 0xC8, 0x5E, 0xB6, 0xDB, + 0xD4, 0xB5, 0x9E, 0x57, 0xDF, 0x62, 0x31, 0xB6, + 0xB7, 0x44, 0xE8, 0x9A, 0x8C, 0x51, 0x70, 0x17 + }, + { + 0x7F, 0xC3, 0x71, 0x74, 0x54, 0x40, 0xBB, 0xF1, + 0x85, 0xDB, 0xF3, 0x7E, 0x46, 0x99, 0x90, 0xEE, + 0x3B, 0xA3, 0x6A, 0x33, 0xEB, 0x70, 0x11, 0xBB, + 0xC4, 0x1E, 0x77, 0xF1, 0xAE, 0x37, 0xB0, 0xF6, + 0x0D, 0x07, 0x56, 0x7E, 0x8B, 0x4C, 0x40, 0xD1, + 0xAC, 0x25, 0x56, 0xD9, 0x98, 0x96, 0xA3, 0x0B, + 0xC0, 0x27, 0xF8, 0xF5, 0xFD, 0x34, 0x4B, 0x39, + 0x31, 0x5D, 0x13, 0x1F, 0x5B, 0x48, 0x3B, 0x2C + }, + { + 0x3F, 0x10, 0xC0, 0x2F, 0xB1, 0xB4, 0xDE, 0x58, + 0x5E, 0xF0, 0x50, 0xA2, 0xF9, 0xDA, 0x7A, 0xDB, + 0x8B, 0x77, 0x74, 0xE6, 0xEB, 0x3E, 0x4D, 0x2A, + 0xA6, 0x2F, 0x73, 0xA8, 0x3D, 0xB7, 0x0C, 0x5F, + 0x16, 0x50, 0x1E, 0x4B, 0x25, 0xB9, 0x50, 0x9A, + 0xD8, 0xAC, 0x62, 0x53, 0x7F, 0x90, 0x39, 0xFF, + 0x9D, 0x00, 0x4F, 0x9D, 0x7D, 0x6E, 0x41, 0x68, + 0x29, 0x65, 0x28, 0x96, 0x8B, 0xE5, 0xDE, 0xC9 + }, + { + 0x53, 0x2A, 0xA8, 0x0E, 0x49, 0xD5, 0xDE, 0xE4, + 0xB2, 0x63, 0xE7, 0x94, 0xF6, 0xDC, 0x7D, 0x28, + 0x4E, 0x78, 0x52, 0xB2, 0x8C, 0xB6, 0x02, 0x94, + 0x99, 0x51, 0xC2, 0x01, 0x67, 0x88, 0xD4, 0xE4, + 0x88, 0xFD, 0xDD, 0x80, 0x8E, 0xFA, 0xA4, 0x8C, + 0x07, 0xB1, 0x37, 0xBE, 0x94, 0x33, 0x5F, 0x8D, + 0x70, 0x9A, 0x93, 0x9D, 0xCB, 0x1C, 0x32, 0xD4, + 0x7D, 0x92, 0x08, 0xA4, 0xAF, 0x11, 0x69, 0x64 + }, + { + 0xE2, 0x6A, 0xFC, 0x66, 0x15, 0xFE, 0x73, 0x3D, + 0xA4, 0x52, 0xB7, 0x9A, 0x5B, 0x59, 0x2B, 0xAD, + 0xCF, 0x3D, 0x27, 0xC3, 0x72, 0xF8, 0xA9, 0x75, + 0x24, 0x01, 0x8B, 0x23, 0x08, 0xF0, 0xDD, 0xCF, + 0xF5, 0xD6, 0x84, 0x06, 0xEA, 0x4F, 0xBE, 0x80, + 0xF6, 0x57, 0x84, 0x31, 0x71, 0xD9, 0x91, 0x0A, + 0x61, 0x61, 0x68, 0x45, 0xB9, 0x28, 0xB5, 0xE5, + 0xD3, 0x68, 0xB9, 0xDB, 0xF1, 0x79, 0xA9, 0x77 + }, + { + 0xC5, 0x8C, 0xF4, 0xCC, 0x1D, 0x44, 0x8C, 0x62, + 0x0E, 0x7D, 0x74, 0x94, 0x5C, 0x99, 0x1B, 0x96, + 0xF6, 0x54, 0x76, 0x8B, 0x17, 0x42, 0x29, 0x51, + 0x24, 0xDC, 0x7A, 0xBF, 0x37, 0x73, 0xD7, 0x83, + 0x91, 0x05, 0x7F, 0xAB, 0x58, 0xA4, 0x7C, 0x23, + 0x74, 0x9A, 0x47, 0x4D, 0x8F, 0x96, 0x6E, 0xF9, + 0xFE, 0xA5, 0x42, 0x64, 0x46, 0x47, 0xE4, 0x74, + 0x99, 0xE0, 0xFC, 0x1F, 0x2F, 0x66, 0xD1, 0xB5 + }, + { + 0x22, 0x8D, 0x8B, 0x5A, 0xAE, 0x45, 0xF6, 0xB1, + 0x42, 0xAD, 0x19, 0x92, 0xB2, 0xC9, 0xE6, 0x8F, + 0xBF, 0xE7, 0x6E, 0x70, 0x70, 0x03, 0x4C, 0x18, + 0xC0, 0x88, 0xC2, 0x30, 0x38, 0x17, 0xE8, 0xE7, + 0xEA, 0x7D, 0x84, 0xC5, 0x94, 0x41, 0x2F, 0x35, + 0x44, 0x7E, 0x3C, 0xAC, 0xFD, 0xCF, 0x0E, 0xA4, + 0x4F, 0x6D, 0x8D, 0x5D, 0xBE, 0x47, 0x98, 0x67, + 0x3D, 0x12, 0x59, 0x4E, 0xC5, 0xA5, 0xE2, 0x1C + }, + { + 0x1B, 0x52, 0x15, 0xE0, 0xE8, 0x06, 0x29, 0x29, + 0x36, 0xF6, 0xF6, 0xC0, 0x12, 0x8E, 0x19, 0x1B, + 0xDD, 0x9A, 0x92, 0x0E, 0x90, 0x5E, 0xFE, 0xD7, + 0xAC, 0x34, 0x3F, 0x74, 0x5F, 0x34, 0x77, 0x3D, + 0x16, 0xAE, 0x27, 0x40, 0x4E, 0xB3, 0x7D, 0xBA, + 0xEE, 0x54, 0x77, 0x80, 0xED, 0x1F, 0xA2, 0x2D, + 0x6D, 0x7D, 0xE7, 0xE3, 0x29, 0x1F, 0x75, 0xD6, + 0x5E, 0x88, 0xA5, 0x2E, 0xD7, 0x21, 0xBE, 0x7F + }, + { + 0xB4, 0xFB, 0x6B, 0xA2, 0xFB, 0x0F, 0xEC, 0x73, + 0xC1, 0x00, 0x89, 0xDC, 0xD8, 0x24, 0xDD, 0xCB, + 0x04, 0x75, 0xFA, 0xE9, 0xC4, 0xE6, 0x95, 0x4A, + 0xF8, 0x96, 0xF4, 0xFE, 0xF2, 0xB7, 0xEB, 0x25, + 0x0B, 0xDE, 0x0C, 0x71, 0x30, 0xAE, 0x91, 0x8D, + 0x33, 0x69, 0x63, 0xFB, 0x7C, 0xE7, 0x55, 0xF6, + 0x3A, 0xC0, 0xD7, 0xD8, 0xC1, 0x94, 0x8B, 0xA0, + 0x50, 0xD6, 0xCC, 0x38, 0xC5, 0x0D, 0xA5, 0xD7 + }, + { + 0xED, 0x53, 0x89, 0x30, 0xBF, 0xB9, 0xCF, 0x0B, + 0x0D, 0xC1, 0x71, 0xFC, 0x9E, 0xD2, 0xD2, 0x0D, + 0xF3, 0xA4, 0xF0, 0xCF, 0xCE, 0xD4, 0xB1, 0x09, + 0xD8, 0x91, 0x97, 0x83, 0xF3, 0x81, 0x88, 0x60, + 0xEF, 0xA0, 0xD3, 0xB4, 0x28, 0x63, 0xC4, 0x54, + 0x32, 0xB4, 0x05, 0x59, 0xD1, 0x57, 0x10, 0xC8, + 0x8A, 0x14, 0x08, 0x6B, 0xED, 0x71, 0x53, 0x73, + 0x1D, 0xFC, 0x76, 0xF8, 0x4E, 0x46, 0x9D, 0x94 + }, + { + 0xF5, 0xD3, 0xC3, 0x90, 0xF3, 0x8C, 0x9F, 0x6E, + 0xE4, 0xCC, 0xD5, 0x6F, 0x56, 0xD6, 0x23, 0x58, + 0x12, 0x51, 0xEC, 0xB2, 0xE1, 0x4D, 0x59, 0x4F, + 0x6C, 0x41, 0x25, 0x44, 0xAE, 0x65, 0x81, 0x1B, + 0xF1, 0xE7, 0x92, 0xBE, 0x47, 0xD3, 0x87, 0x44, + 0x03, 0x5B, 0x25, 0xE3, 0x1C, 0x6B, 0xED, 0xCB, + 0xD2, 0xCA, 0x91, 0x39, 0xDE, 0xF0, 0x34, 0x00, + 0xE6, 0x13, 0xE6, 0xD8, 0xA5, 0x3A, 0x9B, 0x78 + }, + { + 0x86, 0x26, 0x6A, 0x8E, 0xD4, 0x14, 0x67, 0xEC, + 0xEB, 0x55, 0x74, 0x23, 0xDD, 0xDF, 0xD0, 0xD3, + 0xBC, 0x8B, 0x05, 0xD0, 0xB0, 0x6E, 0xCA, 0x85, + 0x9C, 0x30, 0x59, 0x77, 0x9F, 0x10, 0xEA, 0x03, + 0x96, 0x27, 0x8B, 0x0E, 0x63, 0x97, 0x3B, 0x94, + 0xB4, 0xCF, 0x1B, 0x58, 0x32, 0xE7, 0xCB, 0xDD, + 0x5C, 0x7B, 0x06, 0x58, 0xF6, 0x9E, 0x3A, 0x6F, + 0x67, 0xFD, 0x7A, 0xC9, 0x1D, 0xB2, 0x18, 0x87 + }, + { + 0x2B, 0xE9, 0xBF, 0xCD, 0xD5, 0xAC, 0x3D, 0x9A, + 0xBE, 0x47, 0xDF, 0x79, 0x8D, 0xB0, 0x20, 0x65, + 0x28, 0xF0, 0xED, 0xE8, 0xF5, 0xA1, 0x19, 0xC7, + 0x20, 0x58, 0x99, 0x80, 0x50, 0xA8, 0x1E, 0x8D, + 0xA6, 0x48, 0xAA, 0xE0, 0xE0, 0xF2, 0x94, 0x98, + 0x98, 0xB6, 0x9C, 0x29, 0x10, 0x2A, 0xDF, 0x99, + 0x0D, 0xC6, 0x60, 0x8D, 0x75, 0x4B, 0x46, 0x16, + 0xA4, 0xE2, 0x44, 0x0B, 0xFE, 0x76, 0xEE, 0x27 + }, + { + 0xCD, 0x57, 0xF5, 0x64, 0x4F, 0xD8, 0x06, 0x5E, + 0x97, 0x14, 0x3C, 0x3D, 0x7B, 0xC5, 0xF7, 0xFB, + 0x5E, 0x2D, 0x14, 0x4D, 0xF9, 0xA6, 0x2F, 0x35, + 0xA8, 0x12, 0xA3, 0xBA, 0x34, 0xCC, 0x74, 0x42, + 0x07, 0x6F, 0x32, 0x71, 0x50, 0xB2, 0xAA, 0xB7, + 0x7C, 0x84, 0x4C, 0xBE, 0x1F, 0x97, 0x84, 0x3C, + 0x3D, 0xBF, 0xB4, 0x76, 0x0F, 0xF6, 0x50, 0x33, + 0xD5, 0x0C, 0x58, 0xCC, 0x3E, 0xEF, 0xDC, 0x7C + }, + { + 0xA6, 0xF0, 0xDF, 0xB1, 0x7B, 0x3B, 0x24, 0xDE, + 0x33, 0x7C, 0x3A, 0x60, 0x73, 0x48, 0xE6, 0xF9, + 0xE0, 0xC6, 0x07, 0x16, 0xEA, 0x04, 0xCB, 0xAA, + 0x07, 0xE3, 0x32, 0xAE, 0xBB, 0xF7, 0x78, 0xB9, + 0x14, 0xC9, 0x39, 0x03, 0xC3, 0x72, 0x5C, 0xA2, + 0xEA, 0x8F, 0x99, 0x03, 0x43, 0x19, 0x91, 0x67, + 0x1A, 0x05, 0x7C, 0x6C, 0xFA, 0xFA, 0x91, 0xC6, + 0x0E, 0x0E, 0xF1, 0x4A, 0x1C, 0xFB, 0x5E, 0x44 + }, + { + 0x79, 0xF5, 0xFB, 0xD8, 0xC0, 0x5B, 0xFE, 0x70, + 0x21, 0x33, 0x36, 0x80, 0xCB, 0xB5, 0xCC, 0xA3, + 0x49, 0x66, 0xBA, 0x78, 0x32, 0x88, 0xF9, 0xB4, + 0xA4, 0xB8, 0xD1, 0x52, 0x29, 0x82, 0x47, 0x77, + 0x45, 0xF3, 0xCE, 0x7D, 0x88, 0xB7, 0xED, 0x84, + 0xCF, 0xC2, 0x66, 0x62, 0x9A, 0x56, 0x46, 0x2C, + 0x34, 0x68, 0x34, 0x87, 0xE2, 0x5F, 0xFA, 0x98, + 0x82, 0x6F, 0x66, 0xF8, 0xD7, 0x3F, 0xFD, 0xE4 + }, + { + 0x06, 0xE8, 0x68, 0x73, 0xA6, 0x0E, 0xEC, 0xE6, + 0xF4, 0xDF, 0xE4, 0x67, 0x27, 0x1B, 0x01, 0x45, + 0x29, 0x4C, 0x79, 0xCD, 0x3A, 0x11, 0x58, 0x8A, + 0x14, 0x61, 0x5F, 0xD8, 0xD9, 0xE9, 0xA2, 0x40, + 0x81, 0x4E, 0xD7, 0xEF, 0xD2, 0xD4, 0xDD, 0x70, + 0xC8, 0x61, 0x5D, 0x47, 0xCC, 0x42, 0xC4, 0xD8, + 0x89, 0x69, 0xC2, 0xEF, 0x91, 0x7C, 0xAD, 0x62, + 0x5D, 0xBD, 0x5D, 0x85, 0x4D, 0xB5, 0xD3, 0x69 + }, + { + 0x24, 0x5A, 0x55, 0x05, 0x5B, 0x25, 0xD7, 0x1F, + 0x10, 0xFF, 0x86, 0x16, 0xC2, 0x86, 0xFC, 0x6E, + 0xA5, 0x9C, 0xD3, 0x11, 0x6D, 0x4C, 0x62, 0x8F, + 0x3C, 0xEA, 0x60, 0x9F, 0x99, 0xC3, 0x17, 0xBB, + 0x48, 0x3A, 0xB3, 0xCB, 0x9B, 0x23, 0x15, 0x15, + 0x01, 0x23, 0x77, 0x01, 0x36, 0xF3, 0x1C, 0x8D, + 0x9D, 0x00, 0x44, 0x57, 0x2C, 0x44, 0x7D, 0x2A, + 0xD8, 0x13, 0xD3, 0x88, 0x30, 0x37, 0x95, 0x37 + }, + { + 0x4B, 0xAB, 0x89, 0x1E, 0x68, 0x5D, 0xA1, 0xA3, + 0x0A, 0x73, 0x16, 0x8D, 0x9A, 0x58, 0x84, 0xF9, + 0xF4, 0xE8, 0x4C, 0x20, 0x01, 0x7A, 0x81, 0xC2, + 0x7F, 0x26, 0xA8, 0xCE, 0xB6, 0xC4, 0x67, 0xF0, + 0xB6, 0x93, 0xD4, 0x57, 0x2F, 0x27, 0x9E, 0x06, + 0xEB, 0x86, 0xAF, 0x36, 0xA8, 0xDF, 0xEF, 0xEF, + 0x8C, 0x67, 0xBC, 0x8C, 0xCF, 0xD4, 0xE8, 0x97, + 0x32, 0xF3, 0xCD, 0x77, 0xFF, 0xD8, 0x33, 0x12 + }, + { + 0xAD, 0x81, 0xE5, 0x94, 0x77, 0xD7, 0xF6, 0x91, + 0x64, 0xBD, 0x1D, 0x71, 0x1D, 0x35, 0x6E, 0xF9, + 0xEB, 0xC4, 0x10, 0xA1, 0x10, 0x43, 0x2A, 0x90, + 0x6D, 0xFC, 0x18, 0xBC, 0x3F, 0xF1, 0x5D, 0xBB, + 0x08, 0x2F, 0x1E, 0xB9, 0x61, 0xAD, 0x4F, 0x70, + 0x5E, 0x1D, 0xDE, 0x99, 0x9F, 0xB3, 0x28, 0xEE, + 0xA5, 0x1E, 0xF2, 0x07, 0xB7, 0xE5, 0xD8, 0xC0, + 0x5C, 0xFA, 0xD3, 0x65, 0xE6, 0xAA, 0x3C, 0xEB + }, + { + 0xC2, 0xA3, 0xA4, 0x0F, 0x5C, 0x80, 0xA9, 0x88, + 0xF5, 0x1B, 0x6C, 0x01, 0xC6, 0x47, 0x49, 0x50, + 0x78, 0x38, 0x30, 0x27, 0x2C, 0x49, 0x47, 0x52, + 0x2A, 0x7D, 0x78, 0xB3, 0x75, 0x3D, 0x0B, 0x64, + 0x3A, 0xFF, 0x08, 0x4C, 0x96, 0xF6, 0x91, 0xE0, + 0x82, 0xA2, 0x24, 0x27, 0x68, 0x09, 0x9B, 0x30, + 0xE7, 0x4A, 0x3B, 0x35, 0x15, 0x81, 0xE9, 0x6E, + 0x23, 0xF8, 0x9F, 0x8F, 0xA1, 0xA7, 0xB3, 0xEF + }, + { + 0xFC, 0x67, 0xAF, 0xD5, 0x99, 0x09, 0x1E, 0xBE, + 0xA5, 0x51, 0x20, 0x0D, 0x24, 0xD4, 0xBF, 0x03, + 0x27, 0xFD, 0xE3, 0xF1, 0x6A, 0x0A, 0x43, 0x43, + 0x1B, 0x08, 0xE2, 0x15, 0xC9, 0x27, 0x95, 0x44, + 0xF1, 0xD4, 0x21, 0x8B, 0x75, 0x02, 0xD2, 0xB7, + 0x4B, 0x0C, 0xB3, 0xE1, 0x2F, 0x68, 0x5F, 0xD1, + 0x7C, 0x42, 0xCA, 0x71, 0xF7, 0x00, 0x55, 0x8C, + 0xCD, 0x9E, 0x9F, 0x0B, 0xCA, 0xDE, 0x4E, 0xD2 + }, + { + 0x5D, 0x38, 0xA2, 0xA3, 0xC4, 0x4E, 0xB3, 0x9E, + 0x91, 0x96, 0x94, 0xA4, 0x9F, 0xFE, 0xAA, 0x1D, + 0xB5, 0xDE, 0xCD, 0xD5, 0xCF, 0x3E, 0xD6, 0xA2, + 0x24, 0xCB, 0xE8, 0x21, 0x5A, 0xBA, 0xB6, 0x5F, + 0x62, 0x7A, 0xC7, 0x1F, 0x6D, 0xFC, 0xB1, 0x31, + 0x37, 0x92, 0x95, 0xE2, 0xCD, 0x50, 0x50, 0x88, + 0xA8, 0x76, 0x57, 0x3D, 0x9B, 0x23, 0x95, 0xE5, + 0xBF, 0xF2, 0xA2, 0x79, 0xE6, 0x9E, 0x37, 0x6C + }, + { + 0xEF, 0xA1, 0x42, 0x38, 0xD7, 0x34, 0x10, 0x69, + 0xFD, 0x0A, 0x3D, 0x52, 0x47, 0x7D, 0x75, 0x6C, + 0x48, 0xCF, 0xBF, 0x8F, 0x6B, 0xC0, 0x57, 0x74, + 0x7B, 0xAB, 0xF1, 0x70, 0x42, 0x8F, 0x6E, 0xFA, + 0x92, 0xEB, 0x02, 0x47, 0xCE, 0xE0, 0x81, 0xED, + 0x9C, 0xEA, 0x25, 0xEA, 0x0B, 0xF8, 0xCE, 0xB9, + 0xF1, 0xEC, 0x87, 0xF0, 0x95, 0x62, 0x7C, 0x4E, + 0x05, 0x25, 0xF8, 0x7C, 0xF8, 0xCA, 0xE4, 0x0B + }, + { + 0x5A, 0x29, 0xDE, 0x2C, 0x57, 0x66, 0x59, 0xE6, + 0xCF, 0xAE, 0xE2, 0xC1, 0xEA, 0xDA, 0x7F, 0x81, + 0x1F, 0x56, 0x19, 0x50, 0x23, 0xC8, 0x25, 0xE5, + 0x4E, 0xB1, 0xC0, 0xB1, 0xED, 0xFE, 0x69, 0x24, + 0x74, 0x0D, 0x7B, 0xB8, 0x08, 0x37, 0x5B, 0x07, + 0x62, 0x4E, 0x76, 0x6E, 0x2A, 0xC4, 0x67, 0x98, + 0xCB, 0xBD, 0xEA, 0xFA, 0x66, 0x06, 0x75, 0x09, + 0x37, 0x3A, 0x4C, 0x9A, 0xD6, 0x38, 0xA3, 0x97 + }, + { + 0x61, 0x37, 0xAF, 0x21, 0x84, 0x90, 0x2B, 0x45, + 0x34, 0x4D, 0x22, 0x46, 0x02, 0x36, 0x6A, 0x3A, + 0x50, 0x3B, 0xC6, 0x77, 0x1A, 0x90, 0xA7, 0xAF, + 0x4B, 0x13, 0x29, 0xA7, 0xF4, 0xE8, 0x8B, 0x60, + 0x83, 0x07, 0xAF, 0xEB, 0xF2, 0x26, 0xE5, 0x04, + 0x55, 0xDC, 0x54, 0x32, 0x4B, 0xCB, 0x26, 0x8E, + 0x60, 0x50, 0x1B, 0x6E, 0x62, 0x3D, 0x75, 0x4C, + 0xF2, 0xED, 0x42, 0x44, 0xDF, 0xD2, 0xBF, 0x65 + }, + { + 0x63, 0xE2, 0xF7, 0xF8, 0xA5, 0x45, 0xB3, 0x30, + 0xC1, 0xCC, 0xB0, 0xF5, 0x18, 0x30, 0x9F, 0x18, + 0xF8, 0xA7, 0x02, 0x74, 0x5B, 0xF2, 0x53, 0x39, + 0x6D, 0x4E, 0x2B, 0xBB, 0x03, 0x1D, 0x68, 0x09, + 0xEB, 0xF9, 0x07, 0xC0, 0x95, 0xB3, 0xA9, 0xF1, + 0x21, 0x62, 0xB6, 0x28, 0xAF, 0x31, 0x0A, 0xDC, + 0x56, 0x42, 0x3D, 0x3A, 0x8F, 0x1C, 0x6E, 0xB1, + 0xF1, 0xE1, 0x2D, 0x28, 0xCF, 0xF8, 0x08, 0xE0 + }, + { + 0x3D, 0xDB, 0x88, 0x7B, 0xC7, 0xB9, 0x0C, 0x49, + 0x8C, 0xAA, 0x21, 0x96, 0x13, 0xA6, 0x32, 0x07, + 0x54, 0x90, 0x83, 0xE9, 0x48, 0x54, 0x23, 0x05, + 0xA5, 0xAF, 0x84, 0x6B, 0x62, 0xD2, 0x4C, 0x6A, + 0x8E, 0x44, 0x15, 0x30, 0xF4, 0xE1, 0x1C, 0x45, + 0x4C, 0x3B, 0x39, 0x14, 0xF5, 0xD6, 0x30, 0xC2, + 0x50, 0x2D, 0x77, 0x87, 0xE2, 0xD8, 0xC2, 0x2F, + 0x98, 0xA1, 0xA1, 0x96, 0xB2, 0xDC, 0x7A, 0x8D + }, + { + 0x5B, 0x06, 0x5C, 0xCF, 0x5C, 0x8C, 0x9C, 0xF0, + 0xD4, 0x24, 0x76, 0x1B, 0x51, 0x42, 0x6A, 0x6C, + 0x76, 0x5A, 0x9D, 0xD0, 0xA0, 0x39, 0xD4, 0x97, + 0x0F, 0xCA, 0x3A, 0xA0, 0x8E, 0x76, 0x3D, 0x76, + 0xCC, 0x03, 0xBC, 0xD5, 0xF9, 0x28, 0x01, 0xFA, + 0x1F, 0x07, 0x85, 0x7A, 0xEA, 0x46, 0x5E, 0xBE, + 0x77, 0xEA, 0x9E, 0x95, 0xD2, 0x05, 0x3E, 0xF0, + 0xE0, 0x48, 0x62, 0xC7, 0x16, 0xCE, 0x4E, 0xAB + }, + { + 0xD0, 0xC2, 0xC1, 0x84, 0x48, 0x7F, 0x44, 0x58, + 0x77, 0x56, 0x08, 0x0B, 0xD6, 0x5A, 0x4E, 0x4B, + 0x82, 0x4B, 0x49, 0x7D, 0x37, 0x8E, 0xD2, 0x12, + 0x4C, 0x51, 0xA6, 0xFC, 0xA9, 0x32, 0x0D, 0xBD, + 0x09, 0x23, 0x4B, 0x10, 0xF2, 0x64, 0x2F, 0x75, + 0x6F, 0x6A, 0xB6, 0x50, 0x3A, 0x37, 0x03, 0x68, + 0x88, 0x0D, 0xA9, 0xD9, 0xA1, 0x98, 0x87, 0x75, + 0x3E, 0x92, 0xDF, 0xB4, 0x9E, 0x79, 0xCE, 0x0D + }, + { + 0x9E, 0x14, 0x8B, 0x12, 0x52, 0x07, 0x2F, 0x1B, + 0xAB, 0x7B, 0x84, 0x3A, 0x1C, 0xFC, 0xBA, 0xE3, + 0x81, 0x9B, 0xB5, 0x05, 0x3D, 0x31, 0x05, 0xC6, + 0x5B, 0xDF, 0x18, 0xC1, 0x72, 0x6A, 0x46, 0x46, + 0x3B, 0xE1, 0x11, 0xD9, 0x4B, 0xC0, 0x65, 0x62, + 0x4A, 0x24, 0xA9, 0x90, 0xF8, 0xA4, 0x62, 0x46, + 0x2E, 0xF3, 0xD0, 0xFD, 0x6D, 0x02, 0x7A, 0xAB, + 0x3A, 0x2D, 0x84, 0x1A, 0x35, 0x38, 0xA6, 0x86 + }, + { + 0x30, 0xFD, 0xC2, 0xF5, 0xC0, 0x70, 0x44, 0x09, + 0xFB, 0x51, 0x56, 0x28, 0x2C, 0x52, 0xCA, 0x55, + 0x25, 0x41, 0xAE, 0x4A, 0x50, 0x4B, 0xE4, 0xCC, + 0xDA, 0xDE, 0x05, 0xDC, 0x77, 0xE5, 0x21, 0x01, + 0xE8, 0xC9, 0x43, 0x60, 0x93, 0x3F, 0x5D, 0xEE, + 0xFE, 0xB9, 0xB5, 0xA6, 0xA5, 0xD1, 0xCA, 0x5B, + 0xA2, 0x51, 0x5C, 0xFF, 0x66, 0x98, 0x6C, 0xA3, + 0xC7, 0x51, 0x30, 0x54, 0xF3, 0xFC, 0x7C, 0x68 + }, + { + 0x5A, 0x80, 0x2B, 0x27, 0xEF, 0x16, 0x38, 0x8E, + 0x03, 0xAA, 0x1E, 0xA9, 0x17, 0xCD, 0x1A, 0xB4, + 0x01, 0xAB, 0x99, 0xF3, 0x45, 0xAB, 0x62, 0x1F, + 0x36, 0x05, 0x3A, 0x33, 0x77, 0xF2, 0x7A, 0x59, + 0x39, 0xD6, 0x0B, 0x34, 0xC4, 0xA8, 0xC8, 0x03, + 0x8F, 0x18, 0x37, 0x68, 0x43, 0x2B, 0xFB, 0x8F, + 0xF7, 0x1B, 0x16, 0xD3, 0x76, 0x79, 0x57, 0x22, + 0x66, 0x43, 0x39, 0xAD, 0x20, 0xDC, 0xCD, 0x0C + }, + { + 0x2B, 0xF9, 0xBB, 0xF0, 0x52, 0x0F, 0xC1, 0xC2, + 0xD5, 0x98, 0xC7, 0x8B, 0x95, 0x01, 0xCF, 0xDC, + 0xF6, 0xCD, 0x9C, 0x6B, 0x3C, 0xEB, 0x0A, 0x3E, + 0xC5, 0xC8, 0x01, 0x4D, 0x2F, 0xBD, 0x70, 0x4B, + 0x75, 0x92, 0xCB, 0x23, 0x73, 0xD2, 0x3A, 0xC0, + 0x5D, 0x2A, 0x13, 0x17, 0x8C, 0x4C, 0xF1, 0xF4, + 0x83, 0xEA, 0x84, 0x24, 0x66, 0xB3, 0xD5, 0x59, + 0x79, 0xE1, 0x50, 0x50, 0x7C, 0xC1, 0x56, 0xFA + }, + { + 0x32, 0xC0, 0x73, 0xD0, 0x9F, 0x1C, 0x86, 0x29, + 0x21, 0x75, 0x0F, 0xD1, 0x05, 0x3D, 0xBA, 0xC8, + 0xC1, 0xF5, 0xD5, 0x99, 0xC2, 0xB4, 0x9B, 0xBB, + 0x5E, 0xF2, 0xD9, 0x8A, 0xC4, 0xF4, 0x50, 0x89, + 0x1F, 0xB6, 0x50, 0x3A, 0x77, 0x64, 0x35, 0x05, + 0x31, 0x51, 0xBA, 0x70, 0xB4, 0x67, 0x7F, 0x9A, + 0x89, 0x82, 0xB7, 0x86, 0xDC, 0x9C, 0xBB, 0x63, + 0x43, 0x98, 0x69, 0x07, 0xB2, 0x94, 0xB5, 0xA7 + }, + { + 0x84, 0x2C, 0xF9, 0x6D, 0xE2, 0x26, 0x25, 0x81, + 0xD1, 0xE1, 0x97, 0x96, 0x18, 0x7C, 0xDA, 0x45, + 0xDA, 0xF2, 0x57, 0xE2, 0x60, 0xDE, 0x30, 0x72, + 0xD6, 0xE6, 0xE5, 0x66, 0xCE, 0x6C, 0xE4, 0x80, + 0xC4, 0x09, 0x71, 0x70, 0xFD, 0x01, 0x99, 0x10, + 0x2B, 0xCA, 0x36, 0xEC, 0x50, 0x3E, 0xD4, 0xF9, + 0x29, 0xA9, 0x23, 0x2A, 0xC0, 0xE9, 0xCC, 0x24, + 0xBD, 0x26, 0x39, 0x21, 0xF4, 0x2C, 0xC4, 0xBE + }, + { + 0xEA, 0x6E, 0xC8, 0xD5, 0x36, 0x34, 0x90, 0xF4, + 0x9A, 0x91, 0xEA, 0xFF, 0x66, 0x4F, 0xDB, 0x52, + 0xCF, 0x37, 0xD2, 0xDC, 0x3C, 0xE6, 0x42, 0xA8, + 0x42, 0xD3, 0xC9, 0x6E, 0x8E, 0xDB, 0xEA, 0xAE, + 0x18, 0x02, 0x10, 0x35, 0x5B, 0xC6, 0x9F, 0xCF, + 0x00, 0x4E, 0x83, 0x89, 0x74, 0x62, 0xB8, 0x2D, + 0xE9, 0x18, 0x07, 0x03, 0xED, 0xA4, 0x59, 0x17, + 0x58, 0xA6, 0xED, 0xA9, 0xCE, 0x30, 0xA9, 0x2B + }, + { + 0x3C, 0xC7, 0xEB, 0xEF, 0xB9, 0x88, 0xA2, 0xCE, + 0xFB, 0xCC, 0x79, 0x75, 0x4B, 0x6E, 0xF9, 0xF4, + 0xD2, 0x18, 0x95, 0xF9, 0x01, 0x0C, 0xAB, 0x26, + 0xE8, 0x64, 0x82, 0x7B, 0x05, 0x84, 0x0F, 0x51, + 0xEA, 0x54, 0x68, 0xF3, 0x00, 0x37, 0x3A, 0x14, + 0x51, 0xB7, 0x8D, 0x5F, 0xDE, 0xC5, 0x2D, 0xE9, + 0x50, 0xF0, 0xE4, 0xD0, 0xE8, 0xCC, 0xD0, 0x91, + 0x96, 0x0A, 0x8D, 0x8C, 0xEB, 0xBB, 0x70, 0x76 + }, + { + 0x8A, 0x1E, 0x09, 0xB4, 0x71, 0x1D, 0x8B, 0x5F, + 0x1D, 0x4C, 0xA6, 0xEE, 0xB4, 0xB8, 0x2E, 0xCF, + 0xBF, 0x9D, 0x30, 0x1B, 0x83, 0xA9, 0x82, 0xEB, + 0xD0, 0x2D, 0xAD, 0xF4, 0xAF, 0x08, 0x4D, 0xC4, + 0x7C, 0x39, 0xAD, 0xDD, 0x2A, 0x23, 0x7C, 0xF2, + 0xA6, 0xAC, 0x09, 0xA0, 0x85, 0xD8, 0x6B, 0x25, + 0xD7, 0x45, 0x7F, 0xD9, 0x63, 0xA4, 0x40, 0xD6, + 0xFF, 0x04, 0x5E, 0x60, 0x87, 0x4E, 0x21, 0x1A + }, + { + 0x14, 0x6C, 0xAA, 0x94, 0xA2, 0xFE, 0x7D, 0x84, + 0x73, 0xAD, 0xF5, 0x27, 0x71, 0x00, 0x39, 0x5C, + 0xC0, 0x00, 0xEB, 0x74, 0x2F, 0x08, 0x66, 0x54, + 0x6C, 0xFD, 0xB8, 0x37, 0xB1, 0xC9, 0x3C, 0x5F, + 0x19, 0x7D, 0x29, 0x4A, 0x7A, 0xE6, 0xB3, 0x4C, + 0xB0, 0x1A, 0x11, 0x8D, 0xFA, 0x4A, 0xBF, 0xEF, + 0x50, 0xA6, 0x92, 0xBC, 0xC0, 0xAA, 0xA6, 0x44, + 0xC1, 0x76, 0x5F, 0x77, 0x48, 0x21, 0xC1, 0xFE + }, + { + 0x87, 0x4B, 0xCE, 0xCD, 0x2A, 0x56, 0xC5, 0x9D, + 0xFE, 0x47, 0xE9, 0x50, 0xFC, 0xBA, 0xB1, 0x02, + 0xF6, 0x20, 0xCA, 0xEE, 0xE1, 0xE3, 0x5C, 0x61, + 0xD5, 0xBE, 0x0E, 0x8E, 0xBD, 0x56, 0x3B, 0x0E, + 0x0F, 0xD9, 0xE3, 0x01, 0xC6, 0xB8, 0x39, 0x0D, + 0xF4, 0x1F, 0x30, 0x41, 0xF4, 0xEB, 0x46, 0x7B, + 0x4D, 0xF7, 0x63, 0xB9, 0xE3, 0x83, 0x94, 0x47, + 0x28, 0x20, 0xAB, 0xD9, 0x61, 0xC1, 0x53, 0x06 + }, + { + 0x03, 0x0F, 0x04, 0xF1, 0xA4, 0x3A, 0x33, 0xB7, + 0x60, 0xBA, 0x86, 0xBD, 0xFF, 0x05, 0xF5, 0x95, + 0xE6, 0x59, 0x2A, 0x5A, 0x08, 0x60, 0x82, 0x73, + 0xAE, 0xC7, 0x1A, 0xC0, 0x40, 0x5A, 0xC2, 0x97, + 0x6A, 0x62, 0x31, 0x39, 0x2F, 0x7F, 0xFD, 0x39, + 0xED, 0x8F, 0x2C, 0xBE, 0x34, 0x3D, 0xF2, 0xE1, + 0x1A, 0xA7, 0x6B, 0xE8, 0x5E, 0x08, 0x1F, 0x47, + 0x23, 0xEA, 0xA3, 0x13, 0xF2, 0x5C, 0x1A, 0xC5 + }, + { + 0xD7, 0x12, 0xA7, 0xC1, 0x4E, 0x19, 0xEA, 0x55, + 0x20, 0x0B, 0x31, 0x96, 0x96, 0x15, 0x20, 0x40, + 0xC1, 0x8A, 0x64, 0x3A, 0xFE, 0x1B, 0xEF, 0xA9, + 0x53, 0x2E, 0x93, 0x01, 0xB2, 0x2F, 0x30, 0xC1, + 0x64, 0x5F, 0x6A, 0x71, 0xA1, 0x88, 0x6B, 0xCE, + 0x84, 0xCE, 0x3B, 0xF2, 0x93, 0x61, 0xB0, 0xDE, + 0x82, 0x70, 0x42, 0xC8, 0x28, 0xEC, 0x5C, 0x15, + 0x61, 0x37, 0x54, 0xFE, 0x60, 0x40, 0xB8, 0x61 + }, + { + 0x87, 0x2E, 0xF1, 0x72, 0x80, 0x75, 0xF4, 0x53, + 0x35, 0xA4, 0x0F, 0x27, 0xA1, 0x90, 0x18, 0x73, + 0x6B, 0x71, 0xE7, 0xE7, 0xFE, 0x4A, 0x38, 0x9E, + 0x61, 0x80, 0x1B, 0x1E, 0x51, 0xB7, 0xDA, 0x8A, + 0x64, 0x28, 0x85, 0x71, 0x98, 0x57, 0x1E, 0x66, + 0xF3, 0xD9, 0x3D, 0xE6, 0xC5, 0x3C, 0xEC, 0x8E, + 0x5A, 0xE1, 0x79, 0xAB, 0x4F, 0x5F, 0x55, 0xF0, + 0x91, 0x9C, 0x5E, 0xE6, 0x6A, 0x26, 0xAB, 0x3B + }, + { + 0xB3, 0xF8, 0x39, 0xE2, 0xC0, 0x21, 0x31, 0xC9, + 0x0F, 0xD9, 0x0F, 0x89, 0x30, 0x5D, 0x3C, 0x26, + 0x75, 0xF1, 0x81, 0x5A, 0x51, 0xB4, 0xA8, 0xFB, + 0xE1, 0x05, 0x14, 0x38, 0xC1, 0x98, 0xA6, 0xEA, + 0x07, 0xE6, 0xD8, 0x81, 0x9A, 0x1D, 0xE2, 0x81, + 0x5B, 0xFD, 0xA4, 0xA2, 0xF3, 0x77, 0xF4, 0x76, + 0x29, 0x16, 0x90, 0xD7, 0xEF, 0xD9, 0xC9, 0x71, + 0x38, 0xDB, 0x58, 0x48, 0x82, 0x7B, 0x2F, 0x0A + }, + { + 0xAE, 0x87, 0x35, 0x27, 0x37, 0x90, 0xB1, 0x56, + 0xB9, 0xCC, 0xB2, 0x7F, 0xDC, 0x30, 0x3B, 0x3E, + 0xA1, 0xAE, 0xBF, 0x45, 0x0B, 0x8F, 0xA1, 0xBC, + 0x4F, 0x66, 0x00, 0xAB, 0x2C, 0xBF, 0xAE, 0xD0, + 0xD0, 0xC8, 0xFF, 0x56, 0x35, 0x44, 0xE7, 0x5D, + 0x52, 0x53, 0xFB, 0x47, 0xC2, 0xC9, 0xF7, 0xD8, + 0x98, 0x5F, 0x7F, 0x15, 0x20, 0x9A, 0x54, 0x1D, + 0x25, 0x14, 0xBB, 0xDB, 0x66, 0x96, 0x47, 0x73 + }, + { + 0x6D, 0x7D, 0x8F, 0x49, 0x7E, 0xDC, 0x8E, 0x4C, + 0xF8, 0xED, 0x83, 0xE3, 0xCB, 0xBA, 0xEF, 0x9D, + 0x7A, 0x50, 0x81, 0x54, 0x3F, 0xC6, 0x58, 0x08, + 0xB3, 0x72, 0xE3, 0x87, 0xBD, 0x6F, 0xCC, 0x9F, + 0x5C, 0x30, 0x46, 0x5D, 0x36, 0x12, 0x9A, 0x14, + 0x9E, 0x22, 0xF5, 0x58, 0x9F, 0xC4, 0x2F, 0x70, + 0x4C, 0x4E, 0x3F, 0x2E, 0x55, 0xF1, 0x9D, 0x54, + 0x66, 0xB4, 0x86, 0x3C, 0xE8, 0xA8, 0x56, 0x25 + }, + { + 0xF1, 0x4F, 0x01, 0xAB, 0xD4, 0xFC, 0x1E, 0xB8, + 0x38, 0x3A, 0xBA, 0xF2, 0x3A, 0xE7, 0x83, 0x21, + 0x95, 0x94, 0x40, 0xF7, 0xD8, 0x7B, 0x64, 0x94, + 0x06, 0x38, 0x6D, 0x37, 0xDD, 0x17, 0x80, 0x48, + 0x59, 0x47, 0x2E, 0xF6, 0xCF, 0x91, 0xE1, 0x78, + 0xEC, 0xEE, 0x0D, 0xC8, 0xAA, 0xEE, 0x3D, 0x72, + 0xD6, 0xE2, 0x24, 0x31, 0xCB, 0x51, 0xD6, 0xEA, + 0x51, 0x5B, 0xE1, 0xC2, 0x36, 0xA3, 0x3D, 0xA8 + }, + { + 0x44, 0x67, 0xD8, 0x3E, 0x14, 0x5C, 0x71, 0xB0, + 0x4E, 0x02, 0x14, 0x73, 0xEE, 0x48, 0xDF, 0x6F, + 0x0A, 0x07, 0x38, 0xA2, 0x39, 0x77, 0x17, 0x1E, + 0x10, 0x15, 0x93, 0x4F, 0x51, 0x8C, 0x5A, 0x3B, + 0xBE, 0xCC, 0x2C, 0x6B, 0x0D, 0x80, 0xE3, 0x9E, + 0x3C, 0x37, 0xCD, 0x39, 0x45, 0xCE, 0x6A, 0xEE, + 0x18, 0x5E, 0x17, 0x13, 0xA8, 0xCC, 0xC6, 0x36, + 0xD3, 0x84, 0xA5, 0xC1, 0xA9, 0xAA, 0x8C, 0x95 + }, + { + 0xC2, 0xA7, 0x30, 0x1A, 0x65, 0x33, 0x6A, 0x43, + 0x5B, 0xF2, 0xB5, 0x46, 0xFC, 0x51, 0x05, 0x12, + 0x88, 0xE8, 0x08, 0x10, 0xF2, 0x54, 0x7F, 0x27, + 0x10, 0x07, 0xBE, 0xDE, 0x9F, 0x74, 0xB9, 0x8D, + 0x19, 0x09, 0xDF, 0x5A, 0x57, 0xEC, 0x33, 0x14, + 0x05, 0xB6, 0x44, 0x3F, 0x6F, 0x31, 0x0B, 0xB2, + 0xF8, 0x9E, 0xC8, 0x12, 0x3D, 0xA7, 0x5E, 0x23, + 0xAF, 0x9F, 0x58, 0xAE, 0xEB, 0x5E, 0x61, 0xC0 + }, + { + 0x49, 0x26, 0x89, 0x96, 0xB1, 0x31, 0x7E, 0xED, + 0xD4, 0x17, 0xC0, 0x10, 0xFC, 0x95, 0x53, 0xB1, + 0x75, 0x3B, 0x84, 0x6F, 0xBF, 0x78, 0x6C, 0xB2, + 0xA4, 0x29, 0x85, 0xD4, 0xBB, 0x78, 0x2D, 0xA1, + 0xEC, 0x17, 0x50, 0xA2, 0x06, 0xB9, 0x10, 0x9A, + 0x8F, 0xE8, 0x95, 0x05, 0xE3, 0x49, 0x1F, 0xB7, + 0xB7, 0x0A, 0x34, 0x2E, 0xDD, 0xDD, 0x36, 0x83, + 0xC0, 0xF6, 0x5D, 0xD9, 0xF0, 0xE2, 0x22, 0xED + }, + { + 0xA4, 0x2E, 0xDB, 0xC4, 0xAB, 0x35, 0xBD, 0x46, + 0x90, 0x05, 0xA3, 0x58, 0x94, 0x03, 0xF2, 0x1B, + 0x70, 0x5D, 0xD0, 0xC7, 0xE1, 0xF1, 0x5D, 0x55, + 0x16, 0x09, 0xDD, 0xDF, 0xC8, 0xCB, 0x73, 0x26, + 0x8C, 0x22, 0x08, 0x55, 0xA3, 0x7A, 0xA6, 0x92, + 0x63, 0x15, 0xBE, 0x62, 0x05, 0xAA, 0xEF, 0x14, + 0x22, 0x6E, 0xFC, 0x5E, 0x7B, 0x8C, 0x36, 0x5F, + 0x53, 0xB9, 0x11, 0x66, 0x87, 0x12, 0x5D, 0xAA + }, + { + 0xEC, 0xA7, 0x5E, 0x27, 0x6B, 0x64, 0x1B, 0x59, + 0xA0, 0x17, 0xB6, 0x21, 0x7F, 0x9D, 0x9B, 0x98, + 0x43, 0xC8, 0x82, 0x1E, 0x71, 0x73, 0x17, 0xB0, + 0xB6, 0x4C, 0x94, 0x88, 0xD2, 0x32, 0x09, 0xC8, + 0x83, 0xFE, 0xBD, 0x96, 0xB1, 0x7A, 0xCC, 0x17, + 0x76, 0x2D, 0x0A, 0x5A, 0xB8, 0x02, 0xB6, 0x9D, + 0x5B, 0x31, 0x3F, 0x1C, 0xB5, 0x86, 0x42, 0x72, + 0x1E, 0x13, 0xDC, 0x12, 0x69, 0xBB, 0x3D, 0x57 + }, + { + 0x65, 0x75, 0x34, 0xE9, 0xF5, 0x00, 0xFC, 0xD4, + 0xFD, 0x26, 0x2C, 0x9A, 0x0C, 0x40, 0x45, 0x1F, + 0x8B, 0xC7, 0x62, 0x42, 0x9F, 0xAD, 0x23, 0xA9, + 0xCD, 0x99, 0x0A, 0x8F, 0xA7, 0xDA, 0x38, 0xAF, + 0xB2, 0xE8, 0x57, 0x42, 0xEF, 0x96, 0x89, 0x00, + 0x4C, 0x74, 0xA0, 0xE7, 0xD5, 0xA9, 0x14, 0x6A, + 0x66, 0x6E, 0xDA, 0x46, 0x2D, 0x90, 0xC4, 0xAF, + 0xDF, 0xD9, 0x3B, 0x97, 0x5A, 0x31, 0x74, 0x51 + }, + { + 0x1E, 0x73, 0xF8, 0x86, 0x9F, 0xC2, 0xB9, 0x8A, + 0x22, 0xB6, 0x6B, 0x2F, 0xF4, 0x5E, 0xD7, 0x12, + 0x3B, 0x57, 0xCF, 0x6D, 0x80, 0xCC, 0x89, 0x1E, + 0x7B, 0x83, 0x83, 0x47, 0xE4, 0x61, 0x8A, 0x08, + 0x5F, 0xF7, 0x34, 0x58, 0x88, 0xA3, 0xA7, 0xF3, + 0x36, 0x01, 0xC9, 0x9E, 0x14, 0xA2, 0x06, 0x57, + 0xAD, 0x98, 0x55, 0x47, 0xD9, 0x0D, 0x74, 0x9F, + 0x63, 0x19, 0x33, 0x02, 0xC5, 0xE8, 0x2C, 0x9A + }, + { + 0xAB, 0xE7, 0xEE, 0x16, 0x58, 0xC1, 0x40, 0x1F, + 0x43, 0x53, 0xA2, 0x6D, 0xDF, 0xF3, 0x22, 0x30, + 0x81, 0xA7, 0xB9, 0x4A, 0x30, 0x6B, 0x7D, 0xE9, + 0xF8, 0x4F, 0x03, 0x01, 0x40, 0xAD, 0x2D, 0x58, + 0x69, 0x6F, 0xDE, 0xDA, 0x97, 0xBF, 0xE6, 0x91, + 0x5E, 0x7C, 0xFA, 0x7D, 0xA3, 0x44, 0x20, 0x9E, + 0xDD, 0xE4, 0x31, 0x45, 0x6B, 0x06, 0xC4, 0x13, + 0xE4, 0x51, 0x56, 0xD3, 0x87, 0x41, 0xB8, 0xE0 + }, + { + 0xC1, 0xE8, 0xBF, 0xFC, 0x8A, 0xFA, 0x29, 0x31, + 0x4E, 0xBF, 0xBA, 0xFB, 0xE8, 0x38, 0x87, 0x3D, + 0x7E, 0x95, 0xAF, 0xF2, 0x15, 0x0A, 0x79, 0xA0, + 0x6A, 0x43, 0x70, 0xE9, 0x85, 0x3D, 0x59, 0x20, + 0xEB, 0x59, 0xD7, 0x6F, 0xE8, 0x73, 0xAD, 0xFC, + 0x30, 0xD5, 0xC4, 0x28, 0x10, 0x74, 0xBE, 0xD7, + 0x95, 0xF7, 0xDE, 0xA8, 0xE6, 0xED, 0x3F, 0xA3, + 0x4C, 0x81, 0x3B, 0x2B, 0x48, 0x98, 0x58, 0x89 + }, + { + 0xA9, 0xE7, 0x19, 0xDF, 0x23, 0x63, 0x61, 0x58, + 0x5D, 0x30, 0x11, 0x28, 0xAC, 0x9A, 0xDA, 0x1F, + 0xE6, 0x86, 0x96, 0x63, 0x63, 0x3A, 0xBC, 0x76, + 0xC6, 0x75, 0x82, 0x4E, 0x04, 0x4C, 0xFE, 0xCE, + 0x07, 0xBA, 0x50, 0x37, 0x0D, 0xD7, 0x2D, 0x25, + 0xCC, 0x9A, 0x4B, 0xBE, 0x21, 0x92, 0xFC, 0x80, + 0xCB, 0xA4, 0x27, 0x2D, 0xAC, 0x3A, 0x39, 0x40, + 0x7C, 0x12, 0xCA, 0x81, 0xB8, 0x15, 0x1E, 0x70 + }, + { + 0xBB, 0x4E, 0x7F, 0x53, 0xB3, 0x46, 0x2A, 0xA0, + 0x01, 0xF6, 0x8A, 0x52, 0x71, 0xB9, 0xF4, 0x6A, + 0xB2, 0xAE, 0x44, 0x19, 0xA6, 0x0F, 0x05, 0xEE, + 0x31, 0xB8, 0x3F, 0x6A, 0xD7, 0xC7, 0x1B, 0x09, + 0xD0, 0x2E, 0xAD, 0x93, 0xC3, 0xE1, 0xD3, 0x37, + 0x19, 0xAF, 0x23, 0x46, 0x05, 0x9E, 0xD0, 0x06, + 0x65, 0x5A, 0xAE, 0x0C, 0x81, 0xC6, 0x7C, 0x14, + 0xE2, 0x81, 0xC6, 0x36, 0x3D, 0x52, 0x6C, 0x07 + }, + { + 0x2E, 0x22, 0x44, 0xFD, 0x35, 0x36, 0xA8, 0x27, + 0x12, 0x60, 0x98, 0x7F, 0xE9, 0x28, 0xE7, 0xFB, + 0x23, 0x79, 0x79, 0x72, 0xA1, 0x5B, 0x67, 0xC6, + 0x8D, 0x26, 0x89, 0x13, 0x95, 0xB4, 0x51, 0x87, + 0x04, 0xAD, 0x30, 0xE0, 0x89, 0xB7, 0x5A, 0x63, + 0xA8, 0xCF, 0x77, 0x34, 0xB3, 0x0D, 0xE0, 0xEB, + 0x73, 0xB4, 0xDD, 0xC3, 0xD7, 0x47, 0x25, 0xE6, + 0x52, 0x84, 0xE4, 0x7E, 0x74, 0x5A, 0x05, 0x4D + }, + { + 0x02, 0xF2, 0x3C, 0xB1, 0x78, 0x03, 0xC5, 0x9A, + 0x08, 0x13, 0xC0, 0xE0, 0x91, 0xB9, 0x02, 0xEF, + 0x58, 0x2E, 0x61, 0x95, 0xCD, 0xF9, 0xC0, 0x5A, + 0x6A, 0x1F, 0xA2, 0x45, 0xBF, 0x55, 0x95, 0x68, + 0xD1, 0x46, 0x91, 0xE8, 0xD7, 0xE9, 0x4D, 0xE0, + 0xB6, 0x4A, 0xBC, 0x55, 0x75, 0x0D, 0x3E, 0x89, + 0x0A, 0xF0, 0xB8, 0xDF, 0x5F, 0xCB, 0x3E, 0x8E, + 0x0A, 0x37, 0xFF, 0x81, 0x4B, 0x24, 0x32, 0x57 + }, + { + 0x99, 0xF1, 0x87, 0x27, 0xB2, 0x3A, 0x29, 0xEE, + 0xB5, 0xD9, 0x18, 0x72, 0x98, 0x70, 0x88, 0x2F, + 0x13, 0x28, 0x89, 0x20, 0xF4, 0xD2, 0xC6, 0x48, + 0x72, 0xE9, 0x43, 0xB7, 0xA0, 0x63, 0x92, 0x8C, + 0xE9, 0xD6, 0xCF, 0xE1, 0xB1, 0x9D, 0x09, 0x77, + 0xE2, 0x68, 0x19, 0x03, 0xBB, 0xF8, 0x2E, 0xB8, + 0xDC, 0x17, 0x93, 0x5D, 0x53, 0x23, 0xB7, 0x3E, + 0xB0, 0x91, 0xB7, 0x6A, 0x38, 0x2E, 0x1D, 0x09 + }, + { + 0xDC, 0x9E, 0x79, 0x14, 0xF6, 0x6A, 0xAB, 0xB5, + 0x38, 0xB5, 0xF7, 0xA7, 0xF0, 0x93, 0x41, 0xB6, + 0xC7, 0x71, 0x64, 0xB2, 0x1D, 0x69, 0x8F, 0x6F, + 0x8E, 0xA9, 0x16, 0x83, 0xFE, 0xD6, 0xA1, 0x61, + 0x2A, 0xDA, 0x1A, 0x9B, 0x26, 0x67, 0xA5, 0x5C, + 0x6D, 0x3B, 0xEA, 0x65, 0xA1, 0x45, 0xB2, 0x78, + 0xBD, 0x05, 0x2F, 0xEC, 0x41, 0x40, 0xD2, 0x04, + 0x25, 0xFC, 0x67, 0x3F, 0xD7, 0x82, 0x0E, 0x61 + }, + { + 0x4F, 0x0E, 0xE5, 0x96, 0x70, 0x14, 0x2D, 0x8D, + 0xF6, 0x01, 0x73, 0xA6, 0x33, 0x07, 0x84, 0x75, + 0x0B, 0x19, 0x75, 0x6A, 0x95, 0xC3, 0x6C, 0x5F, + 0x53, 0x42, 0x68, 0x7D, 0xCD, 0x8F, 0xB7, 0xF2, + 0x77, 0x80, 0x24, 0x21, 0xCA, 0xC3, 0x47, 0x97, + 0x61, 0x8F, 0xC0, 0x5F, 0xFB, 0xAB, 0x17, 0x9E, + 0x0A, 0xEF, 0xC9, 0x12, 0xCF, 0xC5, 0x78, 0xCE, + 0xE4, 0x36, 0xE4, 0x50, 0xB6, 0x40, 0xC7, 0x78 + }, + { + 0xF7, 0x9E, 0xE2, 0x38, 0xB7, 0xD9, 0xB8, 0xAB, + 0x82, 0x78, 0xD5, 0x16, 0x8F, 0xC1, 0x96, 0x10, + 0xC7, 0x9B, 0xDB, 0xAD, 0x29, 0xB2, 0x4E, 0x3C, + 0xB3, 0xF8, 0xDB, 0x82, 0xB7, 0xA8, 0x54, 0xBA, + 0xEA, 0xE4, 0x06, 0x97, 0x77, 0x77, 0xEF, 0xF2, + 0x7E, 0x76, 0x4C, 0x76, 0x92, 0x35, 0x43, 0x50, + 0x8C, 0xDA, 0x1B, 0x1B, 0xE0, 0xEA, 0x83, 0x3A, + 0x5E, 0x23, 0xD5, 0x9B, 0x57, 0xA0, 0x7A, 0x5E + }, + { + 0x3F, 0x72, 0xA6, 0xE8, 0xB2, 0xA3, 0xEE, 0x2E, + 0x0D, 0x87, 0xC4, 0x6B, 0xB2, 0x0F, 0x37, 0x77, + 0xE6, 0x8A, 0xA3, 0xE7, 0x7D, 0x39, 0xBB, 0x18, + 0xBA, 0xDA, 0x86, 0x31, 0xDC, 0x3C, 0xDF, 0x76, + 0xED, 0x8E, 0xAF, 0xDA, 0xFB, 0xB6, 0xC1, 0x86, + 0xC9, 0x76, 0x88, 0x13, 0x68, 0x8B, 0x17, 0x69, + 0xBA, 0x76, 0x59, 0x9D, 0xB2, 0x84, 0x8A, 0x3B, + 0x87, 0xAD, 0xCD, 0xBC, 0x10, 0x8F, 0xAC, 0x4B + }, + { + 0x80, 0x68, 0xE0, 0xCE, 0x0A, 0xF2, 0xFC, 0x83, + 0xF5, 0x1C, 0x84, 0x89, 0xB4, 0xEA, 0x27, 0x2F, + 0x63, 0x27, 0x5E, 0x80, 0x2B, 0xFA, 0x89, 0x09, + 0x00, 0xC7, 0x92, 0xF5, 0x30, 0x4F, 0x77, 0x26, + 0x06, 0xBF, 0xF7, 0xA9, 0x0C, 0xC6, 0x0A, 0x5A, + 0x97, 0xE6, 0xCC, 0xBB, 0x0A, 0xB8, 0x6E, 0x15, + 0x3E, 0x1F, 0x26, 0xAF, 0xED, 0x81, 0xB1, 0x6E, + 0x09, 0x71, 0xBE, 0xC3, 0x5A, 0xE7, 0x97, 0xDD + }, + { + 0xCA, 0x98, 0x9F, 0x20, 0x9B, 0x7E, 0x17, 0xEC, + 0x8C, 0xC9, 0x51, 0x9F, 0xEF, 0xAA, 0xB2, 0xEB, + 0xC7, 0x0B, 0xD2, 0x4F, 0xA6, 0x32, 0x6F, 0x9C, + 0xBD, 0x8C, 0x09, 0x2C, 0x67, 0x6B, 0xDB, 0x02, + 0xE7, 0x08, 0x31, 0x16, 0x6C, 0xF4, 0x58, 0x51, + 0x4D, 0x33, 0xE3, 0x24, 0x0B, 0xD8, 0xE6, 0x12, + 0xE4, 0xB3, 0x42, 0xBA, 0x39, 0x12, 0xAA, 0x4C, + 0xA9, 0x59, 0x80, 0x1A, 0x1E, 0x69, 0xE0, 0xC1 + }, + { + 0x3E, 0xE8, 0x78, 0x2D, 0xC0, 0x23, 0xAF, 0xD2, + 0x6D, 0x99, 0xB5, 0x0B, 0x09, 0x50, 0xB5, 0x4D, + 0x9E, 0x33, 0x17, 0x59, 0x1C, 0x83, 0x0E, 0x24, + 0xA1, 0xCF, 0x61, 0xEE, 0x7F, 0x8C, 0x08, 0x43, + 0xB1, 0x33, 0x36, 0xB6, 0x74, 0x04, 0x84, 0x92, + 0x52, 0xBA, 0xA8, 0x7B, 0x30, 0x4E, 0x01, 0x6D, + 0xF9, 0x14, 0x90, 0xD2, 0xA6, 0x03, 0x4E, 0xD3, + 0xE2, 0xAC, 0x5E, 0x93, 0xA0, 0xC6, 0x00, 0xD9 + }, + { + 0x76, 0x59, 0x88, 0xBF, 0x71, 0x90, 0x4A, 0xF2, + 0x6A, 0xA2, 0x86, 0xE9, 0xB2, 0x6B, 0x92, 0x30, + 0xAB, 0xEA, 0xD1, 0xB0, 0x0B, 0xD1, 0x7C, 0x37, + 0x01, 0x08, 0x62, 0x20, 0x7E, 0x45, 0xAC, 0x20, + 0x5C, 0x6C, 0xC4, 0x7B, 0x4E, 0xBC, 0xAD, 0x40, + 0x30, 0x54, 0xB3, 0xC0, 0xC3, 0xC7, 0x66, 0x1F, + 0x1E, 0x95, 0xC7, 0x48, 0x13, 0x6D, 0xBE, 0x66, + 0x54, 0xF9, 0xA7, 0x11, 0x0F, 0x9A, 0x04, 0x8B + }, + { + 0x48, 0xFE, 0xEE, 0x3E, 0xD3, 0x50, 0x71, 0xC5, + 0x21, 0xC3, 0x98, 0x7D, 0x30, 0xED, 0x16, 0xF3, + 0x88, 0xDE, 0x3C, 0x32, 0x4A, 0x0F, 0x83, 0xCB, + 0x24, 0xB3, 0x46, 0x8D, 0xA4, 0x04, 0x1B, 0x28, + 0x62, 0x39, 0x7D, 0x89, 0xC4, 0x8A, 0xAF, 0xD7, + 0xD9, 0x87, 0xF2, 0x7A, 0x4A, 0x7E, 0x5B, 0xC8, + 0x2A, 0x42, 0x0C, 0xAF, 0x21, 0x7E, 0x17, 0xB3, + 0x52, 0xD2, 0xCE, 0x44, 0x4F, 0x7C, 0xFD, 0x99 + }, + { + 0x19, 0x9F, 0xE1, 0xA9, 0xB4, 0x7F, 0x33, 0xE1, + 0xC4, 0xD3, 0x62, 0x52, 0xCF, 0xEC, 0x98, 0x6D, + 0xE7, 0x69, 0x45, 0xF9, 0x92, 0xF9, 0xE5, 0x5C, + 0xCC, 0xD0, 0x41, 0xE3, 0xAA, 0xFE, 0xEB, 0xEA, + 0x12, 0xBA, 0x46, 0x52, 0x22, 0x09, 0x91, 0x0C, + 0x2D, 0x4A, 0x0C, 0xAC, 0x56, 0x2D, 0x68, 0x76, + 0xD8, 0x1A, 0x5C, 0xF9, 0x24, 0x6C, 0xCA, 0xD2, + 0x0B, 0x8B, 0x4A, 0x01, 0x1F, 0xDD, 0xC4, 0x3E + }, + { + 0x05, 0xF2, 0x40, 0xAB, 0x03, 0x2B, 0x93, 0x77, + 0xC2, 0xBA, 0xA2, 0xB3, 0x37, 0x27, 0x0A, 0x40, + 0x8A, 0xBA, 0x91, 0x1D, 0x92, 0x0E, 0x55, 0x61, + 0x87, 0x7D, 0x38, 0xE7, 0xC6, 0xB5, 0x45, 0x0E, + 0x0B, 0x0E, 0xC4, 0xDD, 0xB3, 0x5E, 0x17, 0x9C, + 0x9C, 0x91, 0xE2, 0x3D, 0xEC, 0xA2, 0x05, 0x28, + 0x05, 0x3E, 0xDE, 0x72, 0x1B, 0xC2, 0xD3, 0xA7, + 0x7D, 0x2E, 0x5E, 0x57, 0x3C, 0x80, 0x5C, 0x1C + }, + { + 0x3A, 0xE5, 0x2B, 0x0B, 0x2E, 0xD6, 0x25, 0x3F, + 0xD0, 0x01, 0x2A, 0xD7, 0xB9, 0x67, 0x1A, 0xC1, + 0x6C, 0xBE, 0x0E, 0xCE, 0xD9, 0x8C, 0x79, 0x6A, + 0x37, 0x78, 0x07, 0x3D, 0x03, 0xF8, 0xF7, 0x5D, + 0xC0, 0x3C, 0x16, 0xE3, 0x6D, 0x16, 0x2D, 0x55, + 0xBB, 0x1B, 0x86, 0x9B, 0xCA, 0x80, 0x4C, 0x8A, + 0x67, 0xB5, 0xA6, 0xD5, 0x6E, 0x7B, 0x1F, 0x7F, + 0x3D, 0x87, 0xFD, 0x27, 0x6D, 0xB0, 0xD0, 0xE3 + }, + { + 0x64, 0x0F, 0x35, 0x74, 0xFC, 0x03, 0xBC, 0x06, + 0x08, 0x26, 0x9E, 0x89, 0x57, 0x0E, 0xFB, 0x8C, + 0x51, 0x8A, 0xA7, 0x2A, 0x0B, 0x69, 0xB0, 0xBF, + 0xA0, 0x9E, 0x9F, 0xB5, 0x62, 0x0E, 0x97, 0x72, + 0x27, 0x9A, 0x92, 0x69, 0x7C, 0xA5, 0x74, 0xFB, + 0x6C, 0x80, 0x94, 0xB3, 0x03, 0xFB, 0x1A, 0xF9, + 0x56, 0x23, 0xE1, 0xE0, 0xC3, 0xEE, 0x4B, 0xAF, + 0x13, 0x7A, 0xE3, 0xAA, 0x91, 0xB4, 0x0B, 0x7B + }, + { + 0x5C, 0x89, 0xCA, 0xCD, 0x3F, 0xFD, 0xEA, 0xC2, + 0xDF, 0x20, 0x90, 0x8C, 0x06, 0x96, 0x23, 0xAC, + 0x0C, 0x31, 0x4F, 0x23, 0x22, 0xC9, 0xE5, 0x05, + 0x82, 0xCB, 0xF4, 0x9C, 0xDE, 0xE1, 0x6D, 0x95, + 0x3E, 0xD7, 0x1E, 0xDA, 0x74, 0x5F, 0x5E, 0xB7, + 0xFE, 0x88, 0xB9, 0xAA, 0x72, 0xDD, 0x95, 0xDB, + 0x42, 0x4F, 0x4F, 0x8B, 0xFD, 0x70, 0x9A, 0xD3, + 0x13, 0x24, 0x67, 0x63, 0xB6, 0x0C, 0x2B, 0xCD + }, + { + 0xD9, 0xF0, 0x52, 0x07, 0x8A, 0x97, 0x30, 0xE0, + 0xC6, 0xFA, 0x3E, 0x47, 0x8D, 0x72, 0x08, 0xB4, + 0xFA, 0x18, 0x6A, 0x05, 0x68, 0x60, 0x30, 0xEE, + 0x5A, 0xCD, 0x2B, 0x4A, 0xEB, 0x6D, 0xE0, 0xE2, + 0x5A, 0xB4, 0x20, 0xAC, 0xF6, 0xC5, 0xE5, 0x3C, + 0x59, 0x8B, 0x5F, 0xEA, 0xC9, 0x70, 0xC4, 0x59, + 0x65, 0xAE, 0x91, 0x90, 0x14, 0xA8, 0x16, 0x75, + 0xFB, 0x37, 0x87, 0x15, 0xE1, 0xE2, 0x45, 0xD5 + }, + { + 0x24, 0xBC, 0xE7, 0x71, 0x44, 0x3F, 0xD8, 0x51, + 0x88, 0x17, 0x0C, 0xE3, 0x92, 0x9B, 0xF0, 0xB3, + 0x73, 0x5E, 0x63, 0xB8, 0x66, 0x10, 0x85, 0x52, + 0x18, 0xD5, 0xFA, 0x67, 0x7F, 0x75, 0x2B, 0xAA, + 0xA1, 0x2F, 0xE5, 0xA7, 0xC3, 0xA5, 0x2D, 0x60, + 0xEA, 0x11, 0x03, 0xF4, 0x97, 0x6F, 0x35, 0xF2, + 0xC1, 0x68, 0x7A, 0x16, 0xD8, 0x4C, 0xDF, 0xA3, + 0xC7, 0xE9, 0xC5, 0x4D, 0x2A, 0xD9, 0x48, 0x33 + }, + { + 0xC3, 0x91, 0xBF, 0x05, 0x5D, 0x76, 0x48, 0x99, + 0x86, 0xCC, 0x10, 0x62, 0x9D, 0x8F, 0x68, 0xB8, + 0xB9, 0x68, 0x63, 0x39, 0x42, 0x18, 0xE9, 0x7A, + 0x21, 0x6F, 0x2B, 0xBB, 0xA5, 0xCB, 0x8F, 0xBC, + 0xC1, 0x6B, 0x82, 0xDC, 0xAE, 0x27, 0xFE, 0x77, + 0x41, 0x1E, 0xD7, 0x26, 0x49, 0xC4, 0x12, 0xD9, + 0x7F, 0x05, 0xF9, 0x29, 0x02, 0x86, 0xF2, 0x43, + 0x02, 0x65, 0x67, 0x51, 0x9E, 0xBC, 0xA4, 0xBB + }, + { + 0x01, 0x01, 0x17, 0xA3, 0x90, 0x2E, 0xF6, 0x10, + 0x37, 0x4C, 0x2A, 0x90, 0x7E, 0xCF, 0xA4, 0x78, + 0x48, 0x22, 0xD6, 0x81, 0xA4, 0x79, 0x52, 0x89, + 0x08, 0x1F, 0x5C, 0x22, 0xB4, 0xFE, 0x9F, 0x38, + 0xDC, 0x86, 0xCE, 0x1B, 0xBF, 0x8B, 0x39, 0x75, + 0xF2, 0x10, 0xC9, 0x1E, 0xBB, 0x57, 0xB8, 0xD2, + 0xB4, 0x6F, 0x2D, 0x73, 0xB1, 0x76, 0x59, 0x84, + 0x50, 0x1C, 0x20, 0xA2, 0x42, 0xF6, 0x40, 0xE7 + }, + { + 0x39, 0xD5, 0xF9, 0x86, 0xFC, 0xD9, 0x3C, 0xBB, + 0xCC, 0x1E, 0xA5, 0xCF, 0x2A, 0xE2, 0x83, 0x0E, + 0xA5, 0x6C, 0x5C, 0x04, 0x43, 0xAA, 0x68, 0x8E, + 0xCB, 0xCA, 0x89, 0x3A, 0x7E, 0x3D, 0xCC, 0x1E, + 0x77, 0xC4, 0x0B, 0x49, 0x80, 0xBF, 0x71, 0x38, + 0xCD, 0x13, 0x92, 0xEA, 0xD8, 0x84, 0x0D, 0xDB, + 0xF0, 0x2E, 0xE1, 0x46, 0x5F, 0xB8, 0x6B, 0xE7, + 0xCB, 0xFB, 0xEB, 0xC1, 0xC2, 0x86, 0x49, 0x94 + }, + { + 0xE7, 0x34, 0xFC, 0x4C, 0x63, 0x3E, 0x81, 0x9F, + 0xD4, 0xC3, 0xAF, 0xD7, 0xE9, 0xEE, 0x03, 0x83, + 0x76, 0xD1, 0x72, 0x08, 0xB3, 0x9D, 0x1D, 0xF3, + 0xE2, 0x43, 0xFA, 0x24, 0x85, 0x1A, 0xEE, 0x0F, + 0x17, 0x1C, 0xEF, 0x95, 0xF8, 0x67, 0x56, 0x39, + 0x3C, 0x5B, 0x6F, 0x73, 0x02, 0x38, 0xD9, 0x90, + 0x46, 0x0E, 0x25, 0x7A, 0x4F, 0xD8, 0xA0, 0xA7, + 0x64, 0x29, 0x3C, 0x06, 0x1B, 0x4A, 0x41, 0x52 + }, + { + 0x7E, 0xCA, 0x4C, 0x34, 0x1E, 0xD9, 0xF6, 0xAC, + 0x38, 0xFA, 0x96, 0xAB, 0x81, 0xDC, 0x95, 0x82, + 0xEF, 0xAC, 0xE3, 0x73, 0x99, 0xDA, 0x5E, 0xE9, + 0x7F, 0x7F, 0xBE, 0x7A, 0xE4, 0x65, 0x16, 0x46, + 0x86, 0x5C, 0xBA, 0xAD, 0x11, 0x80, 0x23, 0xA4, + 0x47, 0x38, 0xFB, 0x27, 0xD9, 0x84, 0x99, 0xAD, + 0x5B, 0xD6, 0xEB, 0x16, 0xF6, 0x94, 0xC1, 0x05, + 0xE2, 0xD7, 0x33, 0x7A, 0x8E, 0xBE, 0x3B, 0x25 + }, + { + 0x3B, 0xCA, 0x09, 0xDB, 0x40, 0x51, 0x29, 0xC6, + 0x01, 0xAC, 0xF9, 0x69, 0x89, 0x6A, 0x79, 0xA2, + 0x96, 0x38, 0xC1, 0x8C, 0xC9, 0x89, 0x23, 0xF0, + 0xD8, 0x8F, 0xAF, 0xBF, 0x75, 0x1D, 0xF9, 0xFF, + 0x01, 0x50, 0x06, 0xA8, 0x12, 0xC2, 0x0F, 0x4E, + 0x98, 0x20, 0x0E, 0x8F, 0x8E, 0x17, 0xF0, 0xBD, + 0xE7, 0x43, 0xFC, 0xD1, 0x2E, 0xB0, 0x5A, 0x75, + 0x2A, 0xA5, 0x1A, 0xFD, 0xFD, 0x6D, 0x9F, 0xAA + }, + { + 0x17, 0x78, 0x1D, 0xE6, 0x2E, 0x77, 0x6A, 0x52, + 0x74, 0xA1, 0xC5, 0xAF, 0x4C, 0xA0, 0x0B, 0x7D, + 0x8E, 0xAF, 0x8D, 0x2E, 0x31, 0x81, 0x1D, 0xBE, + 0xA1, 0xD9, 0xCF, 0x4F, 0xF4, 0xEE, 0x36, 0x0B, + 0x1D, 0xB8, 0x7D, 0xC4, 0x96, 0xF0, 0x12, 0x18, + 0xD0, 0xC0, 0xD7, 0x4B, 0xBF, 0xA0, 0xFE, 0x76, + 0x12, 0x6B, 0xEA, 0x4A, 0xA6, 0xC7, 0xF5, 0x0C, + 0x82, 0xF2, 0xCD, 0xB3, 0x90, 0xB4, 0xF1, 0xE8 + }, + { + 0x40, 0xD4, 0x97, 0x71, 0xD6, 0x03, 0x6C, 0x79, + 0x8E, 0x70, 0xCE, 0x78, 0x78, 0x16, 0x3E, 0x5F, + 0x3C, 0x85, 0xE1, 0x52, 0xE8, 0x4F, 0x58, 0x0A, + 0xDB, 0xF1, 0xE9, 0x5E, 0x06, 0x00, 0xAE, 0x7A, + 0xF6, 0x1D, 0x31, 0x65, 0x93, 0x42, 0xF6, 0x7D, + 0x8A, 0x27, 0x60, 0x30, 0x44, 0x1F, 0x8B, 0x99, + 0x2D, 0x65, 0xC9, 0x40, 0x04, 0xA7, 0x8B, 0x55, + 0xC6, 0x86, 0x9C, 0xE3, 0x78, 0xE2, 0x6F, 0xD8 + }, + { + 0xED, 0xF9, 0x75, 0x79, 0x04, 0xDC, 0x3B, 0x97, + 0x79, 0xB5, 0x8A, 0x96, 0x7E, 0x64, 0x41, 0x68, + 0x11, 0x97, 0x81, 0x04, 0x3C, 0xE8, 0x5A, 0x31, + 0x39, 0xD8, 0x28, 0x8B, 0x42, 0x98, 0x78, 0x02, + 0x65, 0x8B, 0x46, 0xE5, 0x28, 0x3B, 0x81, 0xA2, + 0xBB, 0x66, 0xEF, 0xDA, 0xFE, 0x17, 0x92, 0x07, + 0xE4, 0x73, 0xFB, 0x8A, 0x30, 0x69, 0x31, 0x37, + 0x6D, 0xBC, 0xAE, 0x42, 0xC3, 0xB6, 0xBE, 0xD2 + }, + { + 0x40, 0x59, 0xE1, 0x10, 0xD0, 0x0B, 0x0D, 0xA7, + 0xCB, 0xC6, 0xCB, 0x45, 0x3B, 0xF7, 0xA1, 0x05, + 0x92, 0xD3, 0x08, 0xC8, 0x15, 0xA3, 0x1A, 0xFE, + 0x15, 0xEA, 0x6B, 0xE1, 0xA5, 0x44, 0xB0, 0xDE, + 0xE5, 0xE7, 0x34, 0xDD, 0xED, 0xCD, 0x29, 0x2E, + 0x63, 0x3F, 0x89, 0x68, 0x03, 0x1A, 0x4D, 0xEC, + 0x61, 0x5C, 0xCD, 0x4C, 0x6D, 0xE7, 0x3F, 0xB2, + 0x3F, 0x08, 0xAA, 0x44, 0x96, 0xF1, 0xB5, 0xEC + }, + { + 0xE7, 0xE1, 0x23, 0x27, 0x4C, 0x31, 0xAD, 0x76, + 0x86, 0x31, 0x30, 0x1C, 0xF3, 0xBA, 0x74, 0x1C, + 0x70, 0xFE, 0xC8, 0x91, 0x35, 0xEA, 0x0E, 0xA8, + 0x7F, 0xBD, 0xD5, 0xA6, 0xD3, 0x82, 0x74, 0x8E, + 0x22, 0x62, 0xEE, 0xE9, 0x5F, 0xC0, 0xAB, 0xE9, + 0x92, 0x5D, 0x7C, 0xB3, 0x5A, 0x45, 0x4B, 0x8E, + 0x02, 0xC9, 0xC4, 0xC1, 0x10, 0xF1, 0x4F, 0xE6, + 0x0E, 0xF3, 0xBB, 0xAD, 0xE9, 0xC8, 0x92, 0xE0 + }, + { + 0x0F, 0x92, 0xFB, 0x35, 0x6E, 0x32, 0xDF, 0xCA, + 0x9B, 0xEC, 0xD9, 0xFD, 0x7B, 0xF8, 0x7F, 0x52, + 0x2B, 0x91, 0xED, 0xDE, 0x32, 0xF7, 0x09, 0xBB, + 0x60, 0x0B, 0x18, 0x38, 0xD4, 0x8F, 0x09, 0x5A, + 0xC3, 0x31, 0x4D, 0x47, 0x67, 0xFE, 0xD9, 0xCB, + 0x9A, 0xAC, 0xF6, 0xB9, 0x4E, 0x47, 0x01, 0x4F, + 0x57, 0x56, 0xF6, 0x3D, 0xA0, 0x26, 0xB4, 0x5E, + 0x65, 0x3F, 0x81, 0x69, 0x73, 0x2B, 0x31, 0x30 + }, + { + 0x6B, 0x36, 0xFC, 0x62, 0x63, 0xE0, 0x4A, 0xDE, + 0xC2, 0xDC, 0xC1, 0x03, 0x36, 0x0A, 0x4B, 0xB2, + 0xBF, 0x16, 0x26, 0x79, 0x77, 0xEB, 0xD3, 0x5E, + 0xB9, 0x8F, 0x90, 0xE9, 0x70, 0x7B, 0xE5, 0xCB, + 0x96, 0x42, 0xF1, 0xD2, 0x66, 0x2E, 0x3E, 0xE3, + 0x37, 0x6D, 0xAE, 0xA5, 0xB1, 0x43, 0xCF, 0x3D, + 0x63, 0x38, 0x2F, 0xD1, 0xE8, 0x0D, 0x79, 0x78, + 0xE6, 0xD5, 0x48, 0xBA, 0x31, 0x4B, 0xD3, 0x52 + }, + { + 0x99, 0x16, 0xBD, 0x6A, 0x99, 0xE8, 0x78, 0xF5, + 0x49, 0x89, 0xBC, 0x6C, 0xBD, 0x6E, 0x5B, 0xE9, + 0x7C, 0x13, 0x71, 0xE3, 0x5F, 0x67, 0xA5, 0x74, + 0x99, 0xFA, 0x5A, 0x4F, 0x23, 0x70, 0xE4, 0x26, + 0xA1, 0xC3, 0x14, 0xE0, 0xD2, 0x5C, 0x2E, 0x42, + 0xCA, 0x8B, 0x7D, 0xBC, 0xBD, 0x16, 0x92, 0xF2, + 0x70, 0x5C, 0xB2, 0x43, 0x36, 0x47, 0xDD, 0xEA, + 0xE1, 0x9E, 0xB3, 0x30, 0x15, 0xD2, 0x5B, 0x0E + }, + { + 0x26, 0xC1, 0x34, 0xCF, 0x72, 0x80, 0xEC, 0x9F, + 0x01, 0xD3, 0xAD, 0x42, 0x19, 0x87, 0x1B, 0x91, + 0x63, 0xC3, 0xAA, 0x75, 0xE3, 0x59, 0x68, 0xD8, + 0x03, 0x10, 0x38, 0x27, 0x8E, 0xEC, 0x27, 0x8D, + 0xE6, 0xAB, 0xF3, 0x2F, 0xB9, 0x4C, 0x97, 0x12, + 0x30, 0xF9, 0x9D, 0xD5, 0x49, 0x02, 0xF5, 0x21, + 0x5A, 0xED, 0x44, 0x5B, 0x8F, 0xB7, 0x87, 0x45, + 0x7F, 0x87, 0xC6, 0xA4, 0xBB, 0x06, 0x5C, 0x0E + }, + { + 0x64, 0x4A, 0x57, 0x37, 0xC8, 0xDC, 0xDB, 0x68, + 0xB1, 0xEA, 0xEE, 0x39, 0x9B, 0x87, 0x44, 0xC2, + 0x0B, 0xF5, 0x0A, 0x3D, 0x63, 0xF4, 0x50, 0xC3, + 0xEA, 0x78, 0xC5, 0x7A, 0x47, 0x0E, 0xA8, 0x27, + 0xB2, 0x32, 0xCD, 0x51, 0x61, 0x84, 0x47, 0x5B, + 0x9A, 0xDF, 0x1A, 0xAD, 0x4F, 0xE4, 0x7C, 0xCC, + 0x1F, 0x7F, 0xDD, 0xC1, 0x39, 0x72, 0x86, 0x69, + 0xFA, 0x8A, 0x9B, 0x23, 0x27, 0xDE, 0x62, 0xAB + }, + { + 0x66, 0x69, 0xF5, 0xED, 0x8D, 0x27, 0x37, 0x26, + 0x52, 0x70, 0x20, 0x4F, 0x36, 0xE2, 0x36, 0x13, + 0xD4, 0x67, 0xC3, 0x6D, 0x6A, 0x89, 0x11, 0xF6, + 0x55, 0x8A, 0x18, 0xF9, 0x82, 0x40, 0xB7, 0x76, + 0x96, 0xAC, 0x5E, 0xF1, 0x2A, 0x15, 0x86, 0x85, + 0x8E, 0x0D, 0xB1, 0xAF, 0xF4, 0x0A, 0x73, 0x83, + 0xF4, 0x2A, 0x23, 0x6A, 0x30, 0x16, 0xAC, 0xC8, + 0xA0, 0xAD, 0xB8, 0x51, 0x02, 0x60, 0x94, 0x57 + }, + { + 0x9B, 0x48, 0x81, 0xD6, 0xC6, 0x78, 0x51, 0xCA, + 0x40, 0x48, 0x3F, 0xA4, 0x1E, 0x13, 0x45, 0xFB, + 0xB1, 0xD7, 0x15, 0x06, 0xAC, 0x1C, 0x30, 0x5D, + 0xD2, 0x39, 0xA8, 0x82, 0xB8, 0x03, 0x78, 0x46, + 0x44, 0x53, 0x25, 0xD5, 0x1E, 0x61, 0x13, 0xF8, + 0xDC, 0xAA, 0x93, 0x5D, 0x52, 0x68, 0x2D, 0x3D, + 0xEB, 0x6F, 0x45, 0x5C, 0x76, 0xE2, 0x55, 0x4A, + 0xFB, 0x34, 0xB9, 0x9A, 0x2F, 0x1B, 0xA4, 0x6A + }, + { + 0xFD, 0x8B, 0x8C, 0x16, 0xC5, 0x33, 0x09, 0x75, + 0x06, 0x35, 0x43, 0x62, 0x5E, 0x6D, 0xAF, 0x6D, + 0xFF, 0x2F, 0xF8, 0xEB, 0xE9, 0xFE, 0x92, 0xBF, + 0x05, 0xE6, 0xF2, 0x93, 0x88, 0x27, 0x6C, 0xFC, + 0x46, 0x36, 0x3C, 0xE3, 0xA2, 0x77, 0xD9, 0xFE, + 0x95, 0xDD, 0x1C, 0x19, 0x3A, 0xBE, 0x75, 0x21, + 0x18, 0x51, 0xF5, 0x63, 0xE6, 0xC1, 0x5C, 0x9B, + 0x3C, 0x38, 0x25, 0x6F, 0xB0, 0xE4, 0x4D, 0x16 + }, + { + 0xCD, 0x0B, 0x5F, 0x96, 0x7D, 0x75, 0x20, 0x32, + 0xBC, 0xD1, 0x2C, 0x37, 0x5B, 0x8E, 0x5C, 0xC0, + 0xB4, 0xE8, 0x58, 0x14, 0x84, 0x32, 0x7C, 0xB8, + 0xA6, 0x88, 0x43, 0x97, 0x8F, 0xD0, 0x14, 0xCE, + 0x15, 0xE7, 0x5E, 0xBA, 0xFA, 0x93, 0x75, 0x82, + 0xAA, 0x6B, 0x96, 0x94, 0xDE, 0x9E, 0x94, 0x9C, + 0x19, 0x28, 0xF5, 0xC1, 0x9E, 0xEE, 0x9C, 0xD2, + 0x1D, 0x79, 0x35, 0xB1, 0x00, 0xC8, 0xD1, 0x10 + }, + { + 0x23, 0x8F, 0x26, 0x17, 0x01, 0xE5, 0x40, 0x9B, + 0x14, 0x32, 0x05, 0xAC, 0x0C, 0x17, 0x77, 0xFF, + 0x08, 0x1A, 0x5E, 0x10, 0x11, 0xD8, 0x8B, 0xB3, + 0x43, 0x73, 0xA3, 0x70, 0x6B, 0x5E, 0x04, 0xE0, + 0xF9, 0xBE, 0x14, 0x2F, 0x66, 0xD8, 0x46, 0x13, + 0xB8, 0xE5, 0x3C, 0xE1, 0x73, 0x86, 0x10, 0x88, + 0x1D, 0x5A, 0xE9, 0x08, 0x27, 0x9A, 0xEA, 0xBD, + 0x89, 0x38, 0x1B, 0x88, 0x0F, 0x41, 0x1D, 0xBF + }, + { + 0x3E, 0x4D, 0x56, 0x34, 0x7A, 0x58, 0xEF, 0x92, + 0x8A, 0xE5, 0x63, 0x85, 0x85, 0x11, 0x2B, 0x1E, + 0x62, 0x39, 0x56, 0x99, 0x5B, 0xEB, 0x73, 0x69, + 0xEF, 0xDC, 0xF2, 0x47, 0x61, 0x34, 0xC8, 0x40, + 0x11, 0xDB, 0x7E, 0x58, 0x36, 0xEF, 0x8C, 0x3C, + 0x18, 0x9F, 0x22, 0xA0, 0x9D, 0x1D, 0x65, 0xDB, + 0xE0, 0x33, 0x86, 0xDE, 0x1D, 0xBE, 0x23, 0xF6, + 0x91, 0xFE, 0xEB, 0x67, 0xE9, 0xBE, 0x55, 0x29 + }, + { + 0x23, 0x55, 0xA3, 0x39, 0x83, 0x50, 0x49, 0xF0, + 0x01, 0x5E, 0xEC, 0x4F, 0x72, 0xEC, 0x6B, 0xC7, + 0x7C, 0x3F, 0x45, 0x12, 0x4B, 0xB8, 0x0F, 0xBB, + 0x90, 0xB2, 0x1E, 0x88, 0xB4, 0xEC, 0x73, 0xD6, + 0x38, 0xEB, 0x3E, 0xC7, 0xEA, 0x9A, 0x9B, 0x73, + 0xBE, 0x99, 0xCF, 0x38, 0x29, 0xC2, 0x30, 0xC2, + 0x88, 0xD5, 0xD0, 0x58, 0x09, 0x75, 0xDA, 0xAD, + 0x08, 0x54, 0xD3, 0xD2, 0x63, 0xCE, 0x8A, 0x77 + }, + { + 0x0E, 0x9D, 0xD0, 0xCC, 0x3B, 0x9B, 0xAE, 0xE5, + 0x17, 0xDE, 0x71, 0xA6, 0x89, 0x25, 0xF1, 0xD5, + 0xF8, 0x06, 0x62, 0x09, 0x3E, 0x47, 0x94, 0x3D, + 0xDE, 0x3A, 0xDD, 0x99, 0x96, 0xC2, 0x4C, 0xC9, + 0x08, 0x46, 0xBB, 0x48, 0xBE, 0xFF, 0x66, 0xA7, + 0x80, 0x70, 0xFD, 0x22, 0x2D, 0xDF, 0x25, 0x10, + 0xAA, 0x49, 0x88, 0x53, 0x8F, 0xCF, 0x1B, 0x03, + 0x95, 0x22, 0x34, 0xAA, 0x48, 0xD3, 0xB1, 0xB9 + }, + { + 0x5F, 0xE7, 0x3D, 0x55, 0x44, 0x9E, 0xE0, 0xDB, + 0x95, 0xF1, 0x41, 0x62, 0x42, 0x43, 0xE7, 0xFF, + 0x15, 0x28, 0xFD, 0x1D, 0xC2, 0x8C, 0x20, 0x1D, + 0x94, 0xA9, 0xF1, 0xF1, 0xDC, 0x21, 0x44, 0x24, + 0xA3, 0xB0, 0x2F, 0x30, 0xA7, 0xA5, 0x00, 0x51, + 0x1E, 0xE2, 0x74, 0x5E, 0x48, 0xD1, 0x4E, 0x0D, + 0x4D, 0x61, 0x0A, 0x66, 0xD6, 0x07, 0xE5, 0x75, + 0x01, 0xD5, 0x9C, 0xC6, 0x4A, 0x56, 0x4A, 0xA4 + }, + { + 0x83, 0xA2, 0x07, 0x8F, 0xA1, 0x37, 0xBD, 0x5F, + 0x2A, 0x21, 0x75, 0x65, 0x5C, 0x5F, 0xD7, 0x9F, + 0x95, 0x12, 0x7C, 0x56, 0x35, 0x2A, 0xCE, 0x15, + 0x4E, 0xF4, 0xAE, 0x13, 0xDD, 0x0F, 0x9D, 0x9E, + 0x9C, 0xA8, 0xF7, 0x45, 0xB3, 0x4D, 0xD7, 0x94, + 0x61, 0xD7, 0xD2, 0x1F, 0x06, 0x30, 0x5B, 0xC2, + 0x3F, 0x1C, 0x54, 0x70, 0x54, 0x01, 0xC5, 0x3B, + 0x58, 0xB8, 0xB4, 0x6E, 0xBE, 0x8F, 0xF4, 0x01 + }, + { + 0xFC, 0x88, 0x89, 0x34, 0x07, 0x36, 0xC9, 0x38, + 0xE6, 0x0B, 0x41, 0x9B, 0x73, 0x90, 0x74, 0xAC, + 0xC9, 0xCA, 0xF8, 0xD2, 0x44, 0x0F, 0xCF, 0x5B, + 0x09, 0xD5, 0x8C, 0xA9, 0x97, 0x56, 0xD7, 0xB6, + 0xB7, 0x9B, 0x0C, 0xC3, 0xFD, 0x22, 0x3F, 0xA3, + 0x25, 0x84, 0xB7, 0x31, 0x9D, 0x2C, 0x50, 0x36, + 0x9F, 0x1F, 0x55, 0x48, 0x2C, 0x85, 0x1C, 0x41, + 0xAD, 0x18, 0xA4, 0xD8, 0xCC, 0xD1, 0xC4, 0x22 + }, + { + 0xF4, 0x90, 0xF9, 0x90, 0x12, 0x35, 0xC9, 0x95, + 0x59, 0x10, 0x14, 0xDD, 0x87, 0x89, 0xE1, 0x0A, + 0x03, 0xD4, 0xC0, 0x77, 0x3A, 0x4E, 0xC8, 0x86, + 0x2B, 0xCE, 0x9C, 0xE9, 0x65, 0x36, 0x44, 0x2E, + 0x7E, 0x6C, 0x77, 0xE8, 0xF5, 0x82, 0xB3, 0x7B, + 0x76, 0x22, 0x93, 0x2E, 0x36, 0xE3, 0xAC, 0x01, + 0xDD, 0xEB, 0x5F, 0xA2, 0x4D, 0xEF, 0xC1, 0x22, + 0x02, 0xD9, 0xE7, 0x64, 0x1D, 0x4A, 0xB6, 0x4A + }, + { + 0x10, 0x90, 0x73, 0x7B, 0xA8, 0xE5, 0x10, 0xA7, + 0x20, 0x91, 0xE0, 0x6C, 0x54, 0xC2, 0xC0, 0x2F, + 0x72, 0x56, 0x26, 0x04, 0x4B, 0x62, 0xA4, 0x3E, + 0xAF, 0x9F, 0x6B, 0xC9, 0x99, 0x00, 0x0C, 0x6A, + 0x6C, 0xF7, 0x32, 0x32, 0xE7, 0x61, 0x6B, 0xB2, + 0xEC, 0xBD, 0xBD, 0x6A, 0x89, 0x00, 0xD7, 0x8A, + 0x1D, 0x15, 0x08, 0x0C, 0x93, 0x75, 0x69, 0x70, + 0xDD, 0x2F, 0xE7, 0x93, 0x01, 0x4A, 0xA6, 0x53 + }, + { + 0x27, 0xFC, 0x6B, 0x93, 0x64, 0x5E, 0x01, 0x84, + 0xF9, 0xCE, 0x94, 0xF0, 0xBB, 0x7C, 0x42, 0x31, + 0xD0, 0x4B, 0xB0, 0x19, 0x33, 0xEC, 0xFD, 0x23, + 0x66, 0x46, 0x58, 0x3D, 0x98, 0x56, 0x2C, 0x1D, + 0x69, 0x91, 0xAB, 0xBB, 0x75, 0x96, 0x28, 0x50, + 0xC2, 0x0C, 0x41, 0xF3, 0x6C, 0xD3, 0xA0, 0x34, + 0xBE, 0xD1, 0xFE, 0xD8, 0x06, 0x6C, 0xFB, 0x3A, + 0x38, 0xAF, 0x76, 0xC5, 0x28, 0xF0, 0x54, 0xCD + }, + { + 0xD7, 0x0B, 0xE8, 0xC1, 0xE3, 0xC2, 0x0E, 0x85, + 0x11, 0xD8, 0x2E, 0x9A, 0xB2, 0x8D, 0x6A, 0x1E, + 0x36, 0xF1, 0x20, 0xBC, 0x58, 0xC7, 0x8F, 0x36, + 0xCC, 0x05, 0xE5, 0x6B, 0x26, 0x82, 0xE4, 0xC1, + 0x3B, 0xD3, 0x2D, 0xAF, 0x20, 0xF3, 0x81, 0xA6, + 0x1B, 0x40, 0x5E, 0x39, 0x47, 0x89, 0xF4, 0xB3, + 0x98, 0x5B, 0x4D, 0x43, 0xD9, 0x2F, 0x16, 0x66, + 0x52, 0x68, 0x2E, 0xA2, 0x67, 0x63, 0x74, 0x1E + }, + { + 0x64, 0x25, 0xE0, 0xAB, 0x59, 0x7B, 0xB0, 0x10, + 0x78, 0x09, 0xAF, 0xA2, 0x52, 0x2A, 0x28, 0x51, + 0x13, 0xD7, 0x6A, 0x44, 0x52, 0xB3, 0x70, 0x2C, + 0xF2, 0x80, 0x85, 0x21, 0x7C, 0xA6, 0x01, 0x20, + 0x80, 0x95, 0x6E, 0x5A, 0x7E, 0x92, 0x95, 0x40, + 0x1F, 0xE5, 0xC5, 0x87, 0xC8, 0xAB, 0x67, 0x75, + 0x4B, 0x94, 0x54, 0xED, 0x2C, 0xA2, 0x8D, 0xC4, + 0x81, 0x51, 0x11, 0x66, 0x8B, 0x40, 0xFA, 0xE1 + }, + { + 0x66, 0x0A, 0xFD, 0x56, 0xF8, 0x49, 0xCB, 0x35, + 0x4D, 0xF2, 0xB5, 0xB8, 0x37, 0xD9, 0x8D, 0x10, + 0x6B, 0xCE, 0x40, 0x4C, 0x74, 0x24, 0x07, 0x0E, + 0xE3, 0xF4, 0x92, 0xF5, 0x6D, 0x15, 0xF6, 0xC4, + 0x0A, 0xF9, 0xAE, 0xB9, 0xFB, 0xD2, 0xA9, 0x81, + 0x38, 0x07, 0x18, 0x15, 0xBD, 0xEE, 0x73, 0x89, + 0xC4, 0xF4, 0xFB, 0x58, 0xB1, 0xBD, 0xBB, 0x69, + 0x17, 0x0C, 0x57, 0x54, 0x94, 0x60, 0x83, 0x21 + }, + { + 0xFA, 0x51, 0x5A, 0xDA, 0x0D, 0x4A, 0xA7, 0xA8, + 0xB5, 0x2B, 0xD9, 0xE3, 0xDA, 0x6C, 0xF2, 0x67, + 0x12, 0x2F, 0x60, 0x07, 0x57, 0x82, 0xBE, 0x65, + 0x78, 0x8F, 0x97, 0x0C, 0xEE, 0x75, 0x1B, 0x6A, + 0x90, 0xAF, 0x33, 0xD5, 0x89, 0x53, 0x2D, 0x08, + 0xF7, 0xB5, 0x91, 0xDA, 0x94, 0x58, 0xA7, 0xAF, + 0x16, 0x47, 0x36, 0xB3, 0xE2, 0x71, 0x6A, 0x62, + 0x91, 0x66, 0x35, 0x83, 0x93, 0x1B, 0xC5, 0x4C + }, + { + 0xB8, 0xEB, 0xB6, 0x94, 0x83, 0x89, 0x9F, 0xF9, + 0xEE, 0x7F, 0x37, 0x75, 0xD0, 0x64, 0x1B, 0x63, + 0xB5, 0x83, 0xE0, 0xEE, 0x21, 0xC5, 0xF8, 0x3A, + 0x83, 0x5C, 0x25, 0xBE, 0x32, 0xB4, 0x70, 0xE9, + 0x31, 0x65, 0xDF, 0x26, 0x16, 0x91, 0x6C, 0xD8, + 0xB0, 0xBB, 0xD3, 0x06, 0x6A, 0xCF, 0x2F, 0x63, + 0xF4, 0xD2, 0x58, 0x6E, 0x53, 0xA2, 0xA6, 0xB2, + 0x8D, 0x52, 0x9E, 0xCE, 0xDE, 0xFB, 0x55, 0x03 + }, + { + 0x56, 0x68, 0x20, 0x4D, 0xBE, 0x7A, 0x3B, 0x96, + 0xCA, 0x24, 0x00, 0x17, 0x0F, 0x81, 0x3C, 0xFB, + 0x0F, 0xA5, 0x6D, 0x34, 0x6A, 0x7F, 0x51, 0x76, + 0x0A, 0x0A, 0x62, 0xCB, 0x3B, 0x3B, 0x17, 0x50, + 0x57, 0x6E, 0x79, 0xA9, 0x69, 0xFF, 0x1C, 0x00, + 0xBE, 0xFF, 0xC9, 0xB1, 0xED, 0x0E, 0x92, 0xA1, + 0x35, 0x86, 0xBF, 0x0A, 0x7A, 0x02, 0x32, 0xEC, + 0x0C, 0xF4, 0x74, 0x05, 0x3E, 0xAF, 0x80, 0x06 + }, + { + 0xC5, 0x6D, 0x47, 0xC3, 0x86, 0x2E, 0x6C, 0x9B, + 0x01, 0x0B, 0xDE, 0x2C, 0x1F, 0x3D, 0x40, 0x4F, + 0x2D, 0xC6, 0xD8, 0x4E, 0x3C, 0x34, 0x64, 0xBC, + 0x07, 0x2B, 0xD2, 0xE0, 0x3D, 0x67, 0x6F, 0x90, + 0xB3, 0x83, 0xDE, 0x4B, 0xB1, 0x08, 0xFD, 0x52, + 0x7D, 0xF5, 0xCE, 0x16, 0x98, 0x68, 0x55, 0x96, + 0x64, 0x0B, 0xBD, 0x12, 0x5F, 0x2C, 0x72, 0x1D, + 0xA7, 0x65, 0x95, 0xF6, 0x7B, 0x88, 0x07, 0x72 + }, + { + 0xF5, 0xBC, 0x3C, 0xF9, 0x34, 0xC5, 0x7A, 0xA5, + 0x31, 0x9E, 0x46, 0xB8, 0xE4, 0x9C, 0xEC, 0x41, + 0xAF, 0xFC, 0x8E, 0x27, 0x79, 0x01, 0x5E, 0xC4, + 0x13, 0x08, 0x03, 0x04, 0xB7, 0x7E, 0x4E, 0x63, + 0x9E, 0x75, 0xE9, 0x95, 0x23, 0xAB, 0x2B, 0x68, + 0xFE, 0x43, 0x2A, 0x72, 0x5D, 0xA7, 0xCA, 0x7A, + 0x87, 0x6F, 0x1B, 0xA3, 0x0C, 0x30, 0x52, 0x94, + 0xF0, 0x4F, 0xC2, 0x3B, 0x39, 0x18, 0x0C, 0x77 + }, + { + 0x37, 0x58, 0x64, 0x03, 0x9B, 0xD1, 0x3D, 0xB8, + 0xC9, 0x91, 0xCA, 0xB2, 0xBD, 0xFA, 0xEC, 0xCA, + 0x75, 0x23, 0x88, 0xD0, 0xCE, 0x72, 0x74, 0x6A, + 0xC0, 0x6D, 0xA0, 0x80, 0x14, 0x9D, 0xF1, 0x44, + 0x58, 0x86, 0xC7, 0x2D, 0xF1, 0xF3, 0x2B, 0x3B, + 0x2D, 0xEF, 0x02, 0xE7, 0xB9, 0x9A, 0x06, 0x1D, + 0x98, 0x00, 0x67, 0x10, 0x52, 0x69, 0x66, 0x56, + 0x96, 0x44, 0xDF, 0xAC, 0x7D, 0x08, 0x10, 0x81 + }, + { + 0x1F, 0x14, 0x9D, 0x2C, 0xBD, 0x23, 0xC3, 0x76, + 0x14, 0xFE, 0x57, 0x0B, 0x76, 0x0A, 0x4E, 0x82, + 0x1A, 0x51, 0xD4, 0xAD, 0x7E, 0x0F, 0x83, 0xA8, + 0xF7, 0x79, 0xC0, 0x42, 0xBD, 0xDE, 0x95, 0xCF, + 0x5B, 0x47, 0x6B, 0x1C, 0xFA, 0x33, 0xA4, 0x2C, + 0x2A, 0xD1, 0x47, 0x15, 0xED, 0x68, 0xE8, 0x56, + 0x9C, 0xC9, 0xC6, 0xC8, 0x17, 0x22, 0x47, 0x44, + 0x1B, 0xE7, 0x11, 0xC9, 0xF9, 0x22, 0x91, 0xD4 + }, + { + 0xFD, 0xBD, 0xB1, 0x36, 0x61, 0x07, 0xBB, 0xEC, + 0xB2, 0xF6, 0x24, 0x61, 0xE5, 0x18, 0x89, 0x55, + 0xAD, 0x5A, 0xB3, 0xD4, 0xC8, 0xEE, 0x86, 0x7C, + 0x08, 0x93, 0xDE, 0xCD, 0xFB, 0x62, 0x09, 0x66, + 0xCF, 0xF4, 0xED, 0x4D, 0x0B, 0xCD, 0x75, 0x82, + 0x6A, 0x82, 0x51, 0x9A, 0x62, 0x4A, 0xE9, 0x4E, + 0x65, 0xBE, 0xF1, 0x25, 0x7F, 0x5B, 0x10, 0x8E, + 0x74, 0x7F, 0xE7, 0x21, 0x3C, 0x11, 0xF0, 0xD7 + }, + { + 0x40, 0xA0, 0x38, 0xDB, 0x2B, 0x74, 0x20, 0xAF, + 0x7A, 0x8B, 0xF9, 0x1F, 0x0A, 0xBD, 0x72, 0x79, + 0x5D, 0xE6, 0x24, 0x08, 0x88, 0xE7, 0xB4, 0xFA, + 0x77, 0xC3, 0x90, 0x40, 0x6F, 0xAE, 0xA0, 0x58, + 0x25, 0x3D, 0xE9, 0xD8, 0xDE, 0x47, 0xF6, 0xB9, + 0xE4, 0x31, 0x1D, 0x4F, 0x9E, 0x3C, 0x1D, 0x5F, + 0xA7, 0x5A, 0x65, 0xCC, 0xAA, 0x80, 0x35, 0x6D, + 0xB3, 0x45, 0xB0, 0xF1, 0x16, 0x9A, 0xFA, 0xF1 + }, + { + 0xB6, 0x31, 0x11, 0x8C, 0x4D, 0xFF, 0x1E, 0x00, + 0x64, 0x9C, 0x6D, 0xAB, 0x7E, 0x4D, 0x51, 0xA5, + 0x5E, 0xEF, 0x9D, 0x43, 0x3D, 0x19, 0x37, 0x86, + 0xDD, 0x6F, 0x32, 0x39, 0xBA, 0xF3, 0xA0, 0xDC, + 0xFF, 0xEF, 0xFB, 0x03, 0xF8, 0x53, 0x59, 0x88, + 0x2D, 0xBE, 0xC6, 0x4C, 0x4C, 0xB1, 0xA2, 0xA7, + 0x9B, 0xD6, 0xCB, 0x2A, 0xC9, 0xEC, 0x5E, 0x73, + 0x26, 0xC5, 0x44, 0x0D, 0xEB, 0xBC, 0x74, 0x7F + }, + { + 0x71, 0x9B, 0x42, 0x03, 0xD4, 0x24, 0x21, 0xE1, + 0x1E, 0x04, 0xF1, 0xD1, 0x1C, 0xF2, 0xCF, 0xAA, + 0x9F, 0xB2, 0xED, 0x13, 0x5A, 0x24, 0x89, 0x99, + 0x8D, 0x51, 0x56, 0xA2, 0x15, 0x2F, 0xAE, 0xC9, + 0xAD, 0x95, 0x66, 0xA3, 0x1F, 0xA2, 0x5D, 0xF8, + 0x80, 0xD5, 0x34, 0xDD, 0x13, 0x8B, 0xA1, 0x11, + 0xFB, 0x5A, 0xB2, 0x97, 0x08, 0x90, 0x6C, 0x04, + 0xF9, 0x41, 0x08, 0xE7, 0x9C, 0x26, 0x3A, 0xF6 + }, + { + 0x1E, 0x1E, 0xED, 0x20, 0x11, 0xC6, 0xF2, 0xF3, + 0x5B, 0x42, 0xB7, 0xD7, 0xED, 0x32, 0x53, 0x2A, + 0xB9, 0x61, 0xBB, 0xFD, 0x34, 0x5F, 0x2C, 0xBA, + 0x4B, 0x51, 0x22, 0xCD, 0xE4, 0xE0, 0x3B, 0xC9, + 0xE8, 0x11, 0x2C, 0x51, 0x22, 0xBA, 0xA6, 0x0E, + 0x5F, 0xBF, 0x6A, 0x0A, 0xE0, 0xE5, 0x5A, 0xC1, + 0xBF, 0xD4, 0xAE, 0x32, 0x08, 0x76, 0xDC, 0x34, + 0x6B, 0x50, 0x58, 0x1E, 0xEC, 0x44, 0x4F, 0xBE + }, + { + 0x5A, 0x29, 0xDB, 0xB1, 0x03, 0xAA, 0x1B, 0xCE, + 0x05, 0x3A, 0x12, 0x8F, 0x68, 0x2A, 0x0A, 0x42, + 0x60, 0x6A, 0xBA, 0x8D, 0x17, 0x79, 0xC1, 0x85, + 0x51, 0x97, 0x4B, 0xD7, 0xC9, 0xDD, 0x61, 0x2A, + 0x57, 0xFF, 0x12, 0x0D, 0x39, 0x44, 0x2D, 0x52, + 0x14, 0xB3, 0xD6, 0xAC, 0x09, 0x1F, 0x2C, 0xAF, + 0xF5, 0xB7, 0x3F, 0x51, 0x65, 0x95, 0x06, 0x8E, + 0x43, 0xE4, 0x4E, 0xD9, 0x29, 0x4D, 0xE8, 0x85 + }, + { + 0x29, 0x38, 0x63, 0x94, 0x3C, 0x47, 0x64, 0x52, + 0xEB, 0x9A, 0xC7, 0x44, 0xEC, 0xDD, 0x38, 0xA7, + 0x14, 0xA3, 0x63, 0x57, 0x5E, 0xDD, 0x4A, 0x40, + 0xDA, 0x28, 0xC3, 0x33, 0x62, 0xDB, 0xBC, 0x16, + 0xA4, 0x0F, 0xB3, 0x11, 0x6B, 0x99, 0xA8, 0x4B, + 0x4A, 0x6A, 0x31, 0x0E, 0x69, 0x6C, 0x57, 0x30, + 0xFC, 0x28, 0x28, 0x48, 0x5C, 0x5D, 0xAD, 0x40, + 0x65, 0x78, 0xD0, 0xE4, 0x27, 0x52, 0xF9, 0xDE + }, + { + 0x1D, 0x60, 0x17, 0x66, 0x59, 0x42, 0x80, 0x63, + 0x4A, 0xA3, 0xEB, 0x61, 0xF6, 0x9D, 0x4B, 0xEB, + 0xB6, 0x14, 0x73, 0x9F, 0x4F, 0xFE, 0xD1, 0x39, + 0x45, 0x58, 0xE4, 0xD4, 0xAC, 0x74, 0xC4, 0x88, + 0x69, 0x35, 0x2F, 0x79, 0x52, 0x6C, 0xB9, 0x9C, + 0x66, 0x3A, 0x11, 0x10, 0xEB, 0x02, 0x49, 0x60, + 0xB9, 0xEF, 0xB7, 0xB2, 0x26, 0x4B, 0xDD, 0xA4, + 0xB8, 0x8B, 0x16, 0x67, 0xA7, 0xE9, 0x67, 0x02 + }, + { + 0xF1, 0x9A, 0xE4, 0xCA, 0x55, 0xC8, 0xB2, 0xBD, + 0xC3, 0x66, 0x8A, 0x6B, 0x6C, 0xFB, 0x23, 0xE9, + 0xDA, 0x41, 0x43, 0x14, 0x1E, 0x78, 0x31, 0xE0, + 0x3B, 0x2A, 0x94, 0x03, 0x50, 0x7A, 0x78, 0x0B, + 0xF6, 0x00, 0xF9, 0x84, 0xB6, 0xB8, 0x6A, 0x96, + 0x3C, 0x6C, 0x65, 0xD7, 0xD1, 0xAA, 0x49, 0xFA, + 0x1A, 0xA4, 0xDD, 0x71, 0xCC, 0xFB, 0x6C, 0xE5, + 0x85, 0x8A, 0x8B, 0xFD, 0x1A, 0xC3, 0x74, 0x18 + }, + { + 0x5B, 0x4C, 0x36, 0xDA, 0xAC, 0x05, 0x60, 0x3B, + 0xE9, 0xCC, 0x36, 0x9D, 0x1A, 0xC5, 0xAB, 0x42, + 0xC0, 0xC9, 0x87, 0xFB, 0x9F, 0x25, 0xD1, 0xFB, + 0x45, 0xCE, 0x6F, 0x9B, 0x43, 0x19, 0x62, 0xFC, + 0x0F, 0x06, 0x2C, 0x10, 0x4E, 0x76, 0x8A, 0x48, + 0xD4, 0xB0, 0x67, 0xD5, 0xBB, 0x49, 0x79, 0x43, + 0x8E, 0x63, 0x3B, 0x08, 0x70, 0x67, 0x04, 0x8F, + 0x18, 0xA0, 0x0E, 0x52, 0x87, 0xF4, 0xA2, 0xD6 + }, + { + 0x0C, 0xB7, 0x1A, 0x3D, 0xE4, 0x7F, 0x33, 0x29, + 0xB0, 0xF6, 0xF1, 0x98, 0xD7, 0x37, 0x8B, 0x73, + 0x22, 0xA9, 0x43, 0x78, 0x95, 0x7A, 0x4F, 0x4A, + 0xF3, 0x28, 0x0B, 0x8D, 0xA1, 0xEA, 0x85, 0x42, + 0x6D, 0xDD, 0x41, 0xA0, 0x7C, 0xBB, 0x96, 0xD4, + 0xB0, 0xA2, 0x55, 0x6E, 0xF9, 0x0D, 0xD0, 0x45, + 0x88, 0x12, 0xB0, 0x2C, 0x23, 0x6A, 0x4B, 0xAB, + 0xBA, 0x5F, 0x9C, 0xC6, 0x99, 0x94, 0x9C, 0x7F + }, + { + 0xCE, 0x52, 0x11, 0xFE, 0xA3, 0x6A, 0x1D, 0x4C, + 0x40, 0xEB, 0x86, 0xCF, 0x8C, 0xC6, 0xA0, 0xF6, + 0x8A, 0xB8, 0x7D, 0x6F, 0x62, 0x17, 0x7D, 0x3C, + 0xCC, 0xA4, 0xF8, 0x93, 0x43, 0xD4, 0xFE, 0xD2, + 0x7B, 0x21, 0xB5, 0x4E, 0x4B, 0x82, 0xBE, 0x47, + 0xAA, 0xC0, 0x71, 0xDE, 0x35, 0xB9, 0xAA, 0x77, + 0xA2, 0x3D, 0x6D, 0x5A, 0xD3, 0x4F, 0xB5, 0x04, + 0x37, 0xB9, 0xDF, 0x35, 0x87, 0xB5, 0xDA, 0x25 + }, + { + 0x4B, 0x0A, 0x24, 0x48, 0x19, 0xD8, 0x08, 0xA7, + 0x20, 0xD4, 0x30, 0x42, 0xEF, 0x8A, 0xDE, 0x1A, + 0x5D, 0xF5, 0xD0, 0xB8, 0xBC, 0xA6, 0xF7, 0x6A, + 0x28, 0x3F, 0x85, 0x47, 0xE8, 0xC9, 0xB2, 0xE4, + 0xDD, 0x77, 0x40, 0x3C, 0xE4, 0x1E, 0x35, 0x27, + 0xD8, 0x5D, 0x58, 0xCF, 0x30, 0xF3, 0xA7, 0xD7, + 0x35, 0x58, 0x58, 0x04, 0x46, 0xCC, 0xEB, 0x3B, + 0x3D, 0x8B, 0xE9, 0xB6, 0x6E, 0xFC, 0xFA, 0x37 + }, + { + 0x86, 0x02, 0x63, 0xFE, 0x0B, 0xCC, 0x54, 0x16, + 0x1B, 0xEA, 0x9C, 0x66, 0x98, 0xCD, 0x66, 0xBC, + 0x58, 0x60, 0x8D, 0xBF, 0x57, 0x66, 0xD9, 0x35, + 0x40, 0xCD, 0x3E, 0xAC, 0x99, 0x42, 0xBD, 0x7B, + 0xAC, 0x5C, 0x32, 0xA5, 0xAB, 0xD9, 0x6D, 0xCD, + 0xBD, 0xDC, 0x0E, 0x23, 0x78, 0x45, 0x27, 0x76, + 0x85, 0x40, 0x9F, 0xBE, 0x78, 0xCF, 0x24, 0x16, + 0x09, 0x8E, 0x19, 0xB1, 0x87, 0x08, 0x2B, 0x07 + }, + { + 0x58, 0x64, 0x6F, 0x61, 0xEF, 0x6A, 0xF8, 0x23, + 0x55, 0x96, 0x49, 0x52, 0xB9, 0xDC, 0x9B, 0xF5, + 0xCD, 0xA9, 0x49, 0x7F, 0x44, 0x86, 0xE0, 0x1C, + 0x71, 0x2E, 0x7B, 0x38, 0x0A, 0x63, 0xF0, 0xF2, + 0x4F, 0x21, 0x3F, 0xC0, 0x2B, 0x1C, 0xF1, 0x8D, + 0x21, 0x65, 0x63, 0x2C, 0x6A, 0xB6, 0x3C, 0xF2, + 0x01, 0x6A, 0x78, 0x24, 0x70, 0xC9, 0xB1, 0x74, + 0x78, 0x4B, 0xE4, 0xD7, 0x80, 0xB5, 0xED, 0x00 + }, + { + 0xBD, 0xAA, 0x58, 0xF0, 0x49, 0x38, 0xFA, 0x4F, + 0xD2, 0x92, 0xFA, 0xE5, 0x47, 0x54, 0x54, 0xD1, + 0x45, 0xBA, 0x43, 0xE4, 0xF5, 0x60, 0x4F, 0x84, + 0x54, 0x29, 0x1A, 0xB3, 0xF2, 0x1F, 0x1F, 0xAA, + 0xB2, 0x17, 0x57, 0x78, 0xA2, 0x4E, 0x9C, 0xD7, + 0x1D, 0x5F, 0x28, 0x65, 0x78, 0xDE, 0x0C, 0x96, + 0x2C, 0x94, 0xA9, 0x5A, 0xAF, 0x4D, 0xAF, 0x01, + 0x0A, 0x0F, 0x1E, 0x49, 0x46, 0x0F, 0xDF, 0x79 + }, + { + 0x04, 0x96, 0xC0, 0x29, 0xE0, 0x92, 0x58, 0x60, + 0xB7, 0x89, 0x71, 0xCD, 0xC2, 0x75, 0x26, 0xCF, + 0x69, 0xC9, 0x38, 0xE1, 0x15, 0xB3, 0xEA, 0x5D, + 0x04, 0x0B, 0x96, 0xE1, 0x76, 0xAB, 0xA9, 0x31, + 0x7D, 0x70, 0x89, 0xB5, 0x53, 0x21, 0x91, 0x16, + 0x73, 0xA1, 0x9F, 0xAA, 0x3F, 0x4D, 0x5B, 0x80, + 0xC6, 0xA6, 0x1C, 0xBE, 0xEC, 0x99, 0x5E, 0xB8, + 0x90, 0x55, 0x93, 0x74, 0x58, 0xD5, 0x44, 0x99 + }, + { + 0xC2, 0xC5, 0x39, 0xD4, 0x02, 0x7C, 0x47, 0xDD, + 0xDA, 0x7D, 0x89, 0xD5, 0xD5, 0x28, 0xE1, 0xC8, + 0x95, 0xEF, 0xCA, 0x21, 0x85, 0x81, 0x6E, 0x0C, + 0x13, 0xB8, 0x24, 0x24, 0xC4, 0x92, 0xCB, 0x28, + 0xC3, 0x21, 0x71, 0x2E, 0xED, 0xDD, 0x81, 0xFF, + 0xF3, 0x09, 0xCA, 0x17, 0x2A, 0xF5, 0xAA, 0xBB, + 0x96, 0xEB, 0x5B, 0x0D, 0xE0, 0xDF, 0xB6, 0x6C, + 0x71, 0x46, 0x04, 0x2F, 0xBB, 0xC4, 0x57, 0x66 + }, + { + 0xEB, 0xFA, 0x25, 0xF7, 0x2B, 0xC1, 0x28, 0xC6, + 0x3B, 0xC3, 0x3E, 0xF3, 0xCB, 0xDD, 0x33, 0x2E, + 0xFD, 0x16, 0xE5, 0x2A, 0x26, 0xDB, 0x52, 0x7E, + 0x9E, 0xF1, 0x4E, 0x7C, 0xB6, 0xC9, 0xDF, 0xB4, + 0x74, 0xC2, 0x59, 0x22, 0x98, 0xF9, 0x0D, 0xF3, + 0x8A, 0x7E, 0xF8, 0x33, 0xA2, 0xC5, 0x30, 0xD4, + 0x03, 0xDA, 0x88, 0xCE, 0xDB, 0x4D, 0x6A, 0x2E, + 0x86, 0x5E, 0xB4, 0x0B, 0x79, 0x27, 0xB9, 0xEC + }, + { + 0xF5, 0xD2, 0x13, 0xFC, 0x95, 0x95, 0xAC, 0xC9, + 0x1D, 0x6A, 0x7B, 0xCF, 0xC6, 0xAB, 0x98, 0xA3, + 0x00, 0xAB, 0x37, 0xA5, 0x0E, 0x94, 0xAF, 0x7F, + 0x68, 0xED, 0xCB, 0x2D, 0xE5, 0xB4, 0xAB, 0xFF, + 0x5D, 0x74, 0xFF, 0x67, 0x1D, 0x25, 0xCC, 0x41, + 0x21, 0x03, 0xB4, 0xEA, 0xD7, 0x92, 0x58, 0xBF, + 0x7F, 0x3F, 0x3B, 0x37, 0x4D, 0xDF, 0xEE, 0x6E, + 0x99, 0xA1, 0xD8, 0x94, 0xC9, 0xBF, 0xAD, 0xAA + }, + { + 0xA6, 0x44, 0x12, 0x24, 0xDE, 0x46, 0x57, 0x9F, + 0x65, 0x23, 0x53, 0x25, 0xE4, 0x63, 0x64, 0x4E, + 0x38, 0x95, 0x08, 0x61, 0x9B, 0x13, 0x15, 0x03, + 0xC6, 0x4B, 0x7B, 0x53, 0x2E, 0x80, 0xFA, 0x3D, + 0xE6, 0xCF, 0x42, 0x26, 0xEF, 0xB1, 0xB1, 0x49, + 0xBA, 0x29, 0x5C, 0xBE, 0xDA, 0x48, 0xC2, 0xEC, + 0x29, 0x9B, 0x58, 0x83, 0xF3, 0x05, 0x3D, 0xB0, + 0xBE, 0x2A, 0x4A, 0xD3, 0x6F, 0xB7, 0xF2, 0x1E + }, + { + 0x2C, 0x3D, 0x1D, 0x3D, 0x52, 0x70, 0x13, 0x68, + 0x63, 0x31, 0x3C, 0x84, 0xFC, 0xD6, 0x79, 0xC7, + 0x51, 0x2C, 0xEE, 0xFF, 0x65, 0x98, 0x30, 0x81, + 0xB6, 0xAF, 0x17, 0xF7, 0xDE, 0xD5, 0x94, 0x0A, + 0xCA, 0xF1, 0xF4, 0xCE, 0x72, 0xC1, 0xC6, 0xC7, + 0x61, 0x5C, 0xD6, 0x33, 0x1F, 0xF9, 0xEC, 0x01, + 0x56, 0x90, 0x3E, 0x1E, 0xA3, 0x93, 0x75, 0x14, + 0x73, 0xD7, 0x46, 0xF1, 0xA8, 0x82, 0xFA, 0x84 + }, + { + 0xD5, 0x0C, 0x1C, 0xBC, 0xAB, 0xF3, 0x91, 0x47, + 0xF2, 0xDB, 0x83, 0x5D, 0x7A, 0x11, 0x31, 0x66, + 0x7E, 0xB7, 0x97, 0x72, 0x71, 0x5A, 0x14, 0x82, + 0xBA, 0xCD, 0xC8, 0xF4, 0x10, 0xCC, 0x77, 0x8F, + 0x9A, 0xB8, 0x78, 0xB2, 0xDA, 0x42, 0xD4, 0x22, + 0x28, 0x2B, 0x29, 0x72, 0xFD, 0x3D, 0x78, 0x48, + 0x74, 0x89, 0xCB, 0xD2, 0x5F, 0xC6, 0x10, 0xED, + 0x2D, 0x2C, 0x4A, 0x88, 0x8D, 0x35, 0x3E, 0xCB + }, + { + 0x3F, 0x5B, 0x40, 0xB4, 0x6A, 0xB1, 0x5E, 0xD9, + 0xFB, 0x27, 0xF0, 0xC2, 0xE0, 0x79, 0x40, 0xCA, + 0x1B, 0x8B, 0x9B, 0xA6, 0x42, 0xBB, 0xEB, 0x6B, + 0x80, 0x7D, 0x45, 0x13, 0x0D, 0xA1, 0xA7, 0xDE, + 0x7D, 0xCB, 0x83, 0xDA, 0x6C, 0x74, 0x49, 0x17, + 0xCD, 0xE9, 0x7D, 0xAA, 0xE5, 0x2C, 0x6C, 0x72, + 0x67, 0x1A, 0x5F, 0x30, 0xDD, 0xC9, 0x55, 0xE1, + 0x1D, 0xBC, 0xFB, 0x55, 0xFF, 0xEC, 0x29, 0xBB + }, + { + 0x60, 0x7F, 0x57, 0x7E, 0xAD, 0xE4, 0xD4, 0x14, + 0x99, 0x5B, 0xEF, 0x63, 0xE5, 0x36, 0x3D, 0x47, + 0xB0, 0x74, 0x91, 0xE9, 0xA0, 0x1E, 0x95, 0xAE, + 0xDE, 0xEF, 0xAD, 0xBB, 0xE7, 0xB9, 0xB1, 0xEB, + 0x79, 0xB2, 0xED, 0x6D, 0xA2, 0xC9, 0x2F, 0x75, + 0xF2, 0x8F, 0x87, 0x5C, 0x13, 0xCD, 0xA5, 0x57, + 0x11, 0x35, 0x5B, 0x0E, 0x56, 0x69, 0xAC, 0x77, + 0x9A, 0xE6, 0xF3, 0x6F, 0x2E, 0x85, 0xC0, 0xB5 + }, + { + 0xB0, 0x8E, 0xDD, 0xD3, 0xB2, 0x25, 0xC4, 0x5F, + 0x1E, 0x9E, 0x76, 0xC8, 0x3F, 0x35, 0xB3, 0x74, + 0xF5, 0xE6, 0x59, 0xE1, 0xF3, 0x9B, 0x9E, 0xAA, + 0xCA, 0x00, 0x01, 0xF6, 0xA8, 0x16, 0x25, 0x9C, + 0x38, 0xBA, 0x24, 0xA7, 0xD5, 0xF1, 0x48, 0xD4, + 0x9E, 0x71, 0x52, 0xC8, 0x5A, 0x9A, 0xC8, 0xBF, + 0xDB, 0xB9, 0x68, 0x4E, 0x00, 0x98, 0x9E, 0x5A, + 0xBE, 0xFB, 0xD7, 0xCD, 0x91, 0xFC, 0x61, 0xB2 + }, + { + 0x1E, 0xAF, 0x7B, 0x2D, 0xD8, 0x42, 0x52, 0x70, + 0xC6, 0x10, 0x96, 0x88, 0x2E, 0x37, 0x4B, 0x79, + 0x19, 0x6B, 0x36, 0x6B, 0x47, 0x51, 0xF5, 0x29, + 0x40, 0x32, 0x8A, 0x80, 0xC8, 0xB9, 0x5C, 0x36, + 0x1A, 0xF2, 0x73, 0xA5, 0x19, 0xF7, 0xF3, 0x56, + 0xC0, 0x11, 0x2A, 0x0A, 0x66, 0xCE, 0xB5, 0xF0, + 0x4E, 0x6D, 0x1D, 0x96, 0xAE, 0x7D, 0xBF, 0xB6, + 0x6C, 0x6D, 0xA7, 0xFB, 0x99, 0x08, 0xAB, 0x9D + }, + { + 0x39, 0xCE, 0x9B, 0x9D, 0xC9, 0xD8, 0x5B, 0xAA, + 0x39, 0xEA, 0x10, 0x6F, 0x73, 0xD1, 0x4C, 0xA4, + 0xDF, 0x4F, 0x4C, 0xD8, 0xF9, 0x3D, 0x7F, 0x6B, + 0x25, 0xA7, 0x44, 0x2A, 0x43, 0x71, 0x1D, 0x2C, + 0x4B, 0x55, 0x18, 0xD6, 0x3D, 0xA5, 0xDF, 0xD2, + 0x18, 0xEA, 0xB3, 0xE9, 0x88, 0x3E, 0xAC, 0xF3, + 0x77, 0xD4, 0x51, 0x8D, 0x2B, 0xD8, 0xCF, 0xCE, + 0x9D, 0x20, 0xA2, 0xAA, 0x3A, 0xAE, 0xB8, 0x9E + }, + { + 0xE0, 0x13, 0x9B, 0xCE, 0x92, 0xDE, 0x9E, 0x13, + 0xC2, 0xC9, 0xAC, 0x82, 0xF3, 0x7E, 0x91, 0xB1, + 0x56, 0x76, 0x15, 0x07, 0x8B, 0xF5, 0xF8, 0xD0, + 0xD8, 0xA0, 0x0B, 0xA5, 0xE7, 0x8E, 0xA6, 0xCF, + 0x4D, 0x21, 0x3E, 0x01, 0x96, 0xD1, 0x3C, 0xE0, + 0x90, 0x74, 0xDC, 0xEA, 0x51, 0xB5, 0x11, 0xC7, + 0x18, 0xE2, 0xE9, 0x4A, 0x68, 0xD4, 0xBA, 0x08, + 0x2B, 0xC7, 0x5F, 0x8B, 0xE5, 0xBC, 0x42, 0x50 + }, + { + 0x1F, 0x10, 0x40, 0xB7, 0x3D, 0x09, 0xDF, 0x25, + 0xD0, 0x85, 0x39, 0x41, 0xF9, 0xF8, 0xE7, 0x4E, + 0xB4, 0xA5, 0x2C, 0xD9, 0x9B, 0xE0, 0xC3, 0x87, + 0xCD, 0xDC, 0x51, 0x1E, 0xB5, 0x9D, 0x86, 0x4F, + 0xA8, 0xD9, 0x3E, 0x7C, 0xE2, 0x2A, 0x4F, 0xF1, + 0x02, 0xB3, 0xE3, 0x40, 0x83, 0x77, 0xF3, 0x6E, + 0xDA, 0xEA, 0xB0, 0x83, 0x24, 0x24, 0x7F, 0x7B, + 0x1F, 0x70, 0xAD, 0x63, 0x9B, 0xD9, 0x94, 0x0A + }, + { + 0x9B, 0x27, 0x40, 0x70, 0xE4, 0x40, 0xFE, 0x96, + 0x2F, 0xDB, 0x02, 0xBF, 0x1C, 0x07, 0x91, 0xA1, + 0x11, 0xC9, 0xC0, 0x5E, 0xD0, 0xCA, 0xBB, 0x93, + 0xA6, 0x04, 0x38, 0x43, 0x61, 0x30, 0xDD, 0x0A, + 0x65, 0xA2, 0xDE, 0xF1, 0x2F, 0x41, 0xB2, 0xE0, + 0x67, 0xBA, 0xA3, 0x34, 0xCF, 0x8B, 0xD2, 0x6A, + 0x93, 0x44, 0x2B, 0x2E, 0x7E, 0x72, 0xB6, 0x4B, + 0x5B, 0x74, 0x45, 0x08, 0x53, 0xE3, 0xC7, 0x8D + }, + { + 0xE0, 0x82, 0x14, 0x0D, 0x00, 0xBF, 0x3D, 0xF0, + 0x68, 0x10, 0x38, 0x72, 0x5F, 0x8B, 0xCF, 0x34, + 0x7A, 0x10, 0x29, 0x81, 0xC6, 0x0B, 0x8A, 0x5D, + 0xF9, 0x96, 0x85, 0xF7, 0x3B, 0x33, 0xEC, 0x3E, + 0xE2, 0xFA, 0x7B, 0x7A, 0xC6, 0xFB, 0x5F, 0x32, + 0x29, 0x13, 0x54, 0x30, 0x21, 0xF9, 0xE8, 0x59, + 0x7E, 0x0A, 0x52, 0x92, 0x27, 0xA9, 0x63, 0x32, + 0xAE, 0xA3, 0x5C, 0x1A, 0x0B, 0x76, 0x5C, 0x1B + }, + { + 0xB1, 0xC1, 0x40, 0xC6, 0x19, 0xC3, 0x17, 0x2A, + 0x82, 0x94, 0x70, 0xB2, 0xCE, 0x4D, 0x4B, 0x08, + 0xC0, 0xBD, 0x5A, 0xCF, 0x65, 0x98, 0xFF, 0x56, + 0x79, 0x1B, 0xB1, 0xA1, 0x76, 0x1D, 0xE8, 0xA2, + 0x52, 0x49, 0x04, 0x64, 0xCD, 0x4A, 0xB7, 0x78, + 0x4A, 0x13, 0x9C, 0x38, 0x15, 0x2D, 0x18, 0x9C, + 0x36, 0x77, 0xD9, 0x57, 0x28, 0xAF, 0xBD, 0x77, + 0x15, 0x6A, 0x5B, 0x51, 0x6F, 0x9D, 0x09, 0x93 + }, + { + 0xD4, 0xDE, 0x56, 0xD6, 0xE7, 0xE4, 0xBF, 0x27, + 0x77, 0x31, 0x09, 0x16, 0x35, 0xCA, 0x2C, 0x52, + 0x7D, 0x8E, 0xBA, 0xA8, 0xCA, 0x60, 0x1A, 0xDA, + 0x5B, 0xD9, 0xCF, 0x61, 0x04, 0x57, 0xBD, 0xFF, + 0xA2, 0x73, 0x0E, 0x11, 0xF9, 0x97, 0xA4, 0x9B, + 0x57, 0x2C, 0xC3, 0x28, 0x8D, 0xA3, 0x61, 0xE9, + 0xA9, 0xFE, 0xCB, 0x09, 0x07, 0xE9, 0xC2, 0x90, + 0x22, 0xA8, 0x79, 0x05, 0xEE, 0x80, 0xDD, 0xBD + }, + { + 0x6A, 0xA2, 0xB4, 0x5C, 0x91, 0xD3, 0x6A, 0x26, + 0x92, 0x65, 0x4C, 0xF5, 0xAA, 0xDB, 0xA2, 0x09, + 0x10, 0xE1, 0xDD, 0x93, 0xB3, 0x39, 0x84, 0x0B, + 0x41, 0xCB, 0xB5, 0xE2, 0x98, 0x86, 0x46, 0x29, + 0xA9, 0xA8, 0xA5, 0x17, 0xB0, 0x0E, 0x46, 0xCB, + 0x01, 0xA3, 0x14, 0xB3, 0x8F, 0xAA, 0x63, 0x95, + 0x02, 0x2E, 0xC9, 0x01, 0x3D, 0xA7, 0xBB, 0xB2, + 0x81, 0xB5, 0xFA, 0x8D, 0x07, 0x76, 0x15, 0x21 + }, + { + 0xFA, 0x19, 0xB2, 0x00, 0x13, 0xBA, 0x3F, 0x8F, + 0x04, 0x6C, 0x1F, 0xA9, 0x5B, 0x5B, 0x14, 0x7C, + 0xF7, 0xD2, 0x34, 0x9E, 0x97, 0x73, 0xE7, 0xB0, + 0x64, 0xED, 0xB4, 0x14, 0xE2, 0x85, 0x26, 0xB0, + 0x34, 0xB4, 0x83, 0xA8, 0xF6, 0x45, 0x4A, 0x6D, + 0x3E, 0x71, 0x77, 0xF7, 0x51, 0x87, 0x02, 0xC2, + 0x9E, 0x35, 0xD4, 0x75, 0x89, 0x09, 0x19, 0x49, + 0xF4, 0x52, 0xDB, 0x3A, 0x5D, 0x40, 0xAF, 0x37 + }, + { + 0x8E, 0x49, 0x6A, 0xB2, 0x0B, 0x53, 0xAA, 0x93, + 0x3D, 0xAB, 0xBE, 0xD4, 0x01, 0x17, 0xE7, 0x1F, + 0x66, 0xB2, 0xD8, 0xA7, 0x2A, 0x16, 0xAC, 0xA1, + 0x21, 0x8B, 0xBD, 0x42, 0xD8, 0x70, 0x9C, 0x80, + 0xD5, 0x16, 0x0F, 0xD4, 0x81, 0x00, 0x10, 0x92, + 0x35, 0x13, 0x50, 0xA8, 0x00, 0x59, 0x6B, 0x1A, + 0xAE, 0xB1, 0x9A, 0x30, 0xD2, 0x72, 0x4D, 0x1F, + 0xED, 0x18, 0x4A, 0xFB, 0x7D, 0x7F, 0xDB, 0x59 + }, + { + 0xAD, 0x4B, 0xF9, 0x03, 0xE1, 0xD1, 0x20, 0xE2, + 0x59, 0x89, 0x6F, 0x03, 0xA7, 0x7F, 0xF6, 0xC5, + 0x02, 0xAD, 0x3F, 0xD5, 0xF8, 0xCF, 0xA8, 0x08, + 0xAC, 0x77, 0x43, 0x45, 0x58, 0x1E, 0xE4, 0xD0, + 0x0C, 0x78, 0xA4, 0xE3, 0xC2, 0x4D, 0x53, 0x15, + 0x2F, 0x7A, 0x9B, 0x50, 0xCB, 0xA9, 0xD9, 0xBC, + 0xF3, 0x8C, 0x96, 0x92, 0x29, 0xA5, 0x9C, 0xD9, + 0x78, 0x0C, 0xA2, 0x0D, 0x59, 0xA3, 0x9F, 0xB8 + }, + { + 0x99, 0xD4, 0x2A, 0xAE, 0xAC, 0x55, 0xB3, 0x53, + 0xE5, 0xAE, 0x27, 0x47, 0x1D, 0x4F, 0xB9, 0xC0, + 0xD9, 0x66, 0x92, 0xAD, 0x47, 0xEF, 0x01, 0xA7, + 0x16, 0x7D, 0x95, 0xF5, 0xEC, 0xE8, 0x34, 0x66, + 0xAE, 0x22, 0x0E, 0x17, 0x3D, 0x4D, 0xB6, 0xC2, + 0xF4, 0x70, 0xD6, 0x1C, 0x3D, 0x52, 0x6C, 0xC1, + 0x8A, 0x72, 0xBA, 0xD6, 0x62, 0x65, 0xF5, 0x4E, + 0x20, 0x9D, 0x14, 0xC3, 0xE2, 0xE4, 0x4A, 0x0C + }, + { + 0x52, 0xBD, 0x02, 0x08, 0x22, 0x2D, 0xD6, 0xA0, + 0x78, 0x88, 0x18, 0x22, 0x3B, 0x70, 0xB3, 0x9F, + 0x58, 0x8F, 0x28, 0x77, 0x63, 0x27, 0x4C, 0xB3, + 0x62, 0xAE, 0x6C, 0xFB, 0xCE, 0x97, 0xF6, 0x08, + 0xEE, 0x38, 0x44, 0xCA, 0xE4, 0xBE, 0x10, 0x1B, + 0x35, 0x0F, 0x97, 0x69, 0x4A, 0xBD, 0xA6, 0xD1, + 0x2B, 0x11, 0x5C, 0x8B, 0x89, 0xBE, 0x7A, 0xBC, + 0x62, 0xA3, 0xCD, 0xFE, 0xAE, 0xBE, 0xA2, 0x1B + }, + { + 0xF3, 0xD7, 0x75, 0xAA, 0x81, 0x22, 0x52, 0x48, + 0xB3, 0x90, 0x89, 0x5A, 0x7A, 0x66, 0xA5, 0xE5, + 0x61, 0xD0, 0x62, 0x8A, 0xB5, 0xF7, 0x9D, 0x8D, + 0x34, 0x3E, 0x09, 0xE9, 0x2A, 0x7E, 0x74, 0x1A, + 0xB1, 0x37, 0x09, 0x1B, 0xD7, 0x29, 0xBA, 0x2C, + 0x4D, 0x42, 0x02, 0xAD, 0xEF, 0xC6, 0xE3, 0x25, + 0x2E, 0x56, 0x01, 0xF1, 0x6A, 0x63, 0xB6, 0xA9, + 0x46, 0x2A, 0x58, 0x16, 0x88, 0xB0, 0xB6, 0x01 + }, + { + 0x37, 0xC7, 0xA7, 0xAC, 0x84, 0x33, 0x3B, 0x04, + 0x52, 0x01, 0x21, 0x7A, 0x2A, 0x07, 0x24, 0xB3, + 0xBF, 0xD3, 0xD2, 0x49, 0x86, 0x32, 0x6D, 0x07, + 0xA7, 0x45, 0xEE, 0x2E, 0x54, 0x7A, 0xA7, 0x3F, + 0xB2, 0x91, 0x99, 0x00, 0x09, 0x9D, 0x9D, 0xEB, + 0x50, 0xDF, 0xB6, 0x28, 0x79, 0x82, 0x7B, 0x67, + 0x2C, 0x31, 0xE5, 0x27, 0xA1, 0xBF, 0x8E, 0xB7, + 0x11, 0xF8, 0xE1, 0xC6, 0x07, 0x39, 0x05, 0x50 + }, + { + 0x8B, 0x34, 0x5A, 0x11, 0x0A, 0x60, 0x85, 0xE0, + 0x5E, 0xFD, 0x09, 0x69, 0xD0, 0x08, 0x7C, 0x89, + 0xA6, 0xC4, 0xAF, 0x8A, 0xFE, 0xCD, 0x32, 0x16, + 0xA5, 0xF8, 0x18, 0xF1, 0x6D, 0xAD, 0xBD, 0x90, + 0xE5, 0xBB, 0x36, 0xE4, 0x26, 0x17, 0xE2, 0xA6, + 0x73, 0x71, 0x0C, 0x85, 0x35, 0xC1, 0xF5, 0x4D, + 0x2E, 0xE0, 0x80, 0x6B, 0x8E, 0x85, 0x9A, 0xC0, + 0x27, 0x4C, 0x10, 0x80, 0xF2, 0x17, 0x97, 0x6C + }, + { + 0xD2, 0x2F, 0x16, 0x68, 0xA9, 0xE8, 0xB2, 0x1D, + 0x60, 0xAE, 0x0A, 0x00, 0x0D, 0xE3, 0x8A, 0x91, + 0xF0, 0x81, 0x94, 0xE4, 0x1A, 0x33, 0xBF, 0x07, + 0x01, 0xAF, 0xAE, 0x89, 0x07, 0xE7, 0xDF, 0x78, + 0xB7, 0x9A, 0x86, 0xEA, 0x42, 0x35, 0x6D, 0xAB, + 0xF4, 0x58, 0x67, 0xD8, 0x99, 0x2E, 0xB3, 0xB5, + 0xD9, 0x40, 0xB0, 0xF4, 0x17, 0xA2, 0x2E, 0x43, + 0x2F, 0x71, 0xFB, 0xA8, 0xF8, 0xD2, 0x5C, 0x26 + }, + { + 0xFE, 0x68, 0x25, 0xD6, 0x23, 0x88, 0x6B, 0x79, + 0x1D, 0x25, 0x00, 0x7C, 0x2C, 0x11, 0x8D, 0xF6, + 0x34, 0x4B, 0x37, 0xC5, 0x09, 0x18, 0x6F, 0xA5, + 0x9E, 0xC0, 0xA3, 0x84, 0x6C, 0xF7, 0xE1, 0xB6, + 0x51, 0x31, 0xE4, 0xF2, 0xEB, 0x90, 0xD4, 0x8A, + 0x14, 0x38, 0x59, 0xD0, 0x30, 0xC0, 0x9F, 0x7F, + 0x35, 0xAC, 0x32, 0x23, 0x61, 0xA7, 0xB8, 0xA2, + 0xEE, 0xA7, 0x6A, 0xDA, 0xDB, 0xE7, 0xEB, 0x48 + }, + { + 0x6F, 0x07, 0x2F, 0x92, 0xCF, 0xBE, 0x43, 0xDA, + 0x59, 0x8C, 0xDF, 0xCB, 0xB1, 0x41, 0x0A, 0xD3, + 0x78, 0x97, 0x79, 0x10, 0xBE, 0x42, 0x49, 0x94, + 0xCA, 0x39, 0x0C, 0xA1, 0x86, 0xED, 0xD2, 0xB0, + 0xD7, 0xE8, 0x6F, 0x12, 0xC1, 0x67, 0xDF, 0xC7, + 0x0C, 0xC8, 0x62, 0x9D, 0xBE, 0xFC, 0xFA, 0xB0, + 0x8A, 0xAE, 0x9A, 0xBF, 0x90, 0x58, 0x0C, 0xE2, + 0x32, 0xAB, 0xC1, 0x3B, 0x7A, 0x1C, 0xB0, 0xD7 + }, + { + 0xD5, 0xF5, 0xEE, 0x64, 0x5E, 0xF7, 0x7C, 0x18, + 0xA5, 0x08, 0x8F, 0x2E, 0x1E, 0x24, 0xF6, 0x76, + 0xEA, 0x7F, 0x74, 0xC9, 0x1B, 0xA0, 0x92, 0x80, + 0xDC, 0x84, 0xE1, 0xC8, 0x55, 0xAF, 0xBC, 0x00, + 0x4D, 0x51, 0x92, 0xE2, 0x51, 0xC2, 0x4B, 0x86, + 0x29, 0x7C, 0x27, 0x0D, 0xBD, 0xC2, 0xA2, 0x2B, + 0xF1, 0x58, 0x07, 0xB8, 0xF8, 0xD9, 0xA6, 0x28, + 0x20, 0xD1, 0xA1, 0xF6, 0xD9, 0x1E, 0x57, 0xB0 + }, + { + 0x19, 0x7E, 0x64, 0xFE, 0xC8, 0x65, 0x14, 0xE5, + 0x4C, 0xC5, 0x19, 0x61, 0xB8, 0x9A, 0xFB, 0x4C, + 0x0E, 0xED, 0x06, 0x75, 0x4E, 0x91, 0x45, 0x7C, + 0x4E, 0xFE, 0x5C, 0xCD, 0x5D, 0x29, 0x79, 0x44, + 0x2B, 0xE4, 0xB4, 0xE8, 0x13, 0x67, 0xFA, 0xB0, + 0x62, 0xAA, 0x0D, 0x47, 0x47, 0x0E, 0x31, 0xEB, + 0x10, 0xAA, 0x45, 0xA1, 0x40, 0x3C, 0x72, 0x60, + 0x3E, 0x79, 0x72, 0x27, 0xCE, 0x90, 0x27, 0xD4 + }, + { + 0xC4, 0x1A, 0x6A, 0xD9, 0x71, 0x2B, 0x27, 0xF4, + 0x95, 0x43, 0x34, 0xCD, 0xC9, 0x58, 0x14, 0x0D, + 0x1E, 0x0C, 0x04, 0xE4, 0xF5, 0xF2, 0x64, 0x10, + 0x9A, 0x3A, 0xA3, 0x67, 0xF3, 0x1D, 0x25, 0xD9, + 0x9B, 0xC2, 0x32, 0xE4, 0x8D, 0x3B, 0x73, 0x53, + 0xC3, 0x36, 0x0E, 0xC3, 0x23, 0xD6, 0x7E, 0xEE, + 0x92, 0x90, 0x02, 0x37, 0xA3, 0x16, 0x97, 0xD4, + 0xB2, 0xAF, 0x1A, 0x6A, 0xB3, 0x82, 0xB6, 0xF7 + }, + { + 0xB0, 0x9B, 0xA3, 0x34, 0x8B, 0x5F, 0x4C, 0x01, + 0xCC, 0x1C, 0xCA, 0x4C, 0x5B, 0xBE, 0x97, 0xB9, + 0x76, 0x15, 0x05, 0xCF, 0xAE, 0x95, 0x80, 0x65, + 0x49, 0x69, 0x8F, 0x4A, 0xEB, 0x8B, 0xE7, 0x8F, + 0xF0, 0x60, 0xC1, 0x27, 0x3E, 0x4E, 0xE0, 0x83, + 0xCE, 0xEC, 0x8A, 0xC4, 0xBD, 0xAE, 0x50, 0x9F, + 0xD8, 0x44, 0x1A, 0x12, 0x7E, 0xA2, 0x89, 0x44, + 0x28, 0x2B, 0x4A, 0x16, 0x88, 0x8A, 0xA1, 0x3A + }, + { + 0xFA, 0x85, 0x5C, 0x7C, 0x01, 0xD9, 0x84, 0x48, + 0x78, 0x6F, 0xF2, 0x3D, 0x6E, 0xC4, 0xC3, 0xEF, + 0x0E, 0x6C, 0x38, 0xF5, 0xA0, 0x69, 0xAA, 0x45, + 0xD9, 0x27, 0xD5, 0xDA, 0xAE, 0x6C, 0x6C, 0xFD, + 0x63, 0x8F, 0x26, 0xA3, 0xF3, 0x72, 0xDF, 0x58, + 0x35, 0xC8, 0xDA, 0x2C, 0x58, 0x8F, 0x4B, 0x32, + 0xBA, 0x10, 0xBF, 0xBD, 0x31, 0xF5, 0x50, 0xC9, + 0x91, 0xC4, 0x3A, 0x35, 0x69, 0xFD, 0x1D, 0x58 + }, + { + 0x2D, 0x91, 0xB4, 0x91, 0xA4, 0x60, 0x9B, 0x75, + 0xC8, 0x9E, 0xE1, 0x1A, 0x99, 0xB1, 0x29, 0x1B, + 0x2D, 0xF7, 0xCF, 0xDE, 0x86, 0xAA, 0x33, 0xEC, + 0x71, 0x23, 0xDB, 0xFC, 0x2F, 0x5C, 0x6F, 0x73, + 0x6B, 0x84, 0xD1, 0xF7, 0xC6, 0x77, 0xC9, 0x46, + 0x60, 0x1B, 0xAB, 0x47, 0x0D, 0xBD, 0x3D, 0x1E, + 0x4B, 0xBB, 0x6B, 0xD1, 0x0B, 0xFD, 0x08, 0x62, + 0x1F, 0xF2, 0xFA, 0x5D, 0xF9, 0x2D, 0x4E, 0xBF + }, + { + 0x3B, 0x5D, 0x63, 0xA8, 0x64, 0x63, 0xDA, 0x42, + 0x8D, 0xA3, 0xB2, 0xDE, 0xFF, 0x5B, 0x4C, 0xEB, + 0x07, 0xA7, 0x78, 0x45, 0xD4, 0x00, 0x8A, 0xC1, + 0x95, 0x6A, 0xF1, 0x86, 0x7D, 0xD3, 0xFC, 0x16, + 0x77, 0x24, 0x95, 0xB6, 0x58, 0xC0, 0x3A, 0x0D, + 0xAA, 0xFC, 0xCE, 0xA2, 0x25, 0x01, 0xDF, 0xEA, + 0x06, 0x97, 0xB8, 0x0C, 0x8F, 0xD7, 0x32, 0x46, + 0x41, 0x3F, 0xCF, 0x82, 0xE0, 0xF5, 0xB3, 0x34 + }, + { + 0x2C, 0xAD, 0x3A, 0xB2, 0x8B, 0xCA, 0x59, 0x1B, + 0x0D, 0x78, 0x57, 0x26, 0x50, 0x80, 0x72, 0x43, + 0xB9, 0xE3, 0x48, 0x0F, 0x13, 0x87, 0xF5, 0x41, + 0xC5, 0x8A, 0x0A, 0x11, 0xB5, 0x55, 0xC6, 0xF4, + 0x2D, 0xBA, 0x90, 0x57, 0xFB, 0x34, 0x5F, 0xBA, + 0xDA, 0x12, 0x5D, 0xDC, 0xDD, 0xD2, 0x75, 0xA8, + 0x1A, 0x94, 0xEE, 0xCA, 0x94, 0x56, 0x75, 0xE5, + 0x16, 0x75, 0x51, 0x7D, 0xCE, 0x44, 0x86, 0xCA + }, + { + 0x4D, 0x5D, 0x75, 0x98, 0x36, 0x09, 0xD7, 0xB4, + 0x52, 0xD3, 0x9F, 0x34, 0x58, 0x05, 0x78, 0xC8, + 0x29, 0x9C, 0x02, 0x26, 0x67, 0xDA, 0x06, 0x44, + 0x1A, 0x4F, 0x22, 0xC8, 0x3A, 0x4E, 0x70, 0x0A, + 0xFC, 0x4A, 0x3F, 0xCD, 0x77, 0x84, 0x42, 0x93, + 0x81, 0x4E, 0x20, 0x7A, 0xF0, 0xA4, 0xEA, 0x27, + 0xF8, 0xCF, 0x02, 0x8B, 0x95, 0x6E, 0xA9, 0x73, + 0xDE, 0xFD, 0xF7, 0x3E, 0x4E, 0xB5, 0x2D, 0xE3 + }, + { + 0x0D, 0xAD, 0x07, 0xA6, 0x84, 0xA7, 0xD3, 0xD6, + 0x2E, 0x5B, 0x77, 0x1B, 0xFE, 0xB7, 0x8A, 0x10, + 0x03, 0x66, 0x81, 0x92, 0xEB, 0x68, 0x3B, 0x8C, + 0x4C, 0xB4, 0xFF, 0x5F, 0x84, 0x35, 0x4C, 0x42, + 0xAD, 0xBD, 0x7C, 0x95, 0xB7, 0x16, 0x2C, 0xF5, + 0x14, 0x59, 0x18, 0x78, 0x34, 0x6D, 0x58, 0x86, + 0x73, 0xCC, 0x4C, 0x1D, 0x6C, 0x60, 0x9C, 0x5A, + 0x21, 0x0A, 0xA1, 0x4A, 0x10, 0xFC, 0xEB, 0x26 + }, + { + 0xFE, 0x7E, 0x5E, 0x54, 0xB1, 0x93, 0xD0, 0xBA, + 0xD4, 0x68, 0x76, 0xD7, 0x6A, 0x0F, 0x7F, 0xCA, + 0xBB, 0x45, 0x68, 0xC6, 0x7D, 0xE4, 0xB6, 0x0D, + 0x8B, 0xDE, 0xE2, 0x5F, 0x8F, 0x2A, 0x32, 0x43, + 0xA1, 0x73, 0x43, 0x74, 0xAC, 0xB1, 0x79, 0x9A, + 0x34, 0xB3, 0x4D, 0x45, 0xB1, 0x42, 0xC2, 0x2D, + 0x38, 0x6C, 0xD7, 0xA0, 0xEF, 0x57, 0xC6, 0xBE, + 0x82, 0x72, 0xD5, 0xBE, 0x8B, 0x4D, 0x02, 0xB4 + }, + { + 0x24, 0x75, 0x89, 0x76, 0x3A, 0xC0, 0xB2, 0xDC, + 0x9B, 0x94, 0x3E, 0xF9, 0xFC, 0xD8, 0x95, 0xEB, + 0xC7, 0x3F, 0xA6, 0x95, 0xF5, 0x44, 0xAD, 0xD8, + 0x22, 0x15, 0x3E, 0x87, 0xEA, 0xFE, 0x14, 0xF1, + 0xA3, 0x18, 0xE6, 0x9D, 0x5A, 0x52, 0xA6, 0x68, + 0x97, 0x61, 0x42, 0x69, 0x36, 0xBF, 0x4E, 0x88, + 0xC0, 0xAA, 0x1F, 0x35, 0xD2, 0x55, 0xF4, 0x44, + 0x02, 0x13, 0xDC, 0x6A, 0x22, 0x53, 0x49, 0x26 + }, + { + 0x0B, 0xB7, 0x8F, 0xA9, 0x33, 0x11, 0xCB, 0xDD, + 0xEC, 0x30, 0xFD, 0x3B, 0x80, 0x53, 0xC9, 0xAC, + 0x43, 0xA2, 0x7E, 0xD8, 0xBD, 0x64, 0x54, 0x0F, + 0xD5, 0x18, 0xD9, 0x53, 0x5B, 0xD5, 0x44, 0x71, + 0xA3, 0xBA, 0x73, 0x65, 0x08, 0x6A, 0xD7, 0x29, + 0xFA, 0xC2, 0xF2, 0x0E, 0xC6, 0xC8, 0xAB, 0x82, + 0x5E, 0x53, 0xF3, 0x75, 0x04, 0x21, 0x2A, 0x66, + 0x13, 0x36, 0x8D, 0xDC, 0x0F, 0x74, 0x51, 0xF2 + }, + { + 0xDE, 0xA2, 0xEA, 0x06, 0x51, 0xE2, 0xC8, 0x04, + 0xF7, 0x6F, 0xDE, 0x2E, 0x70, 0xC4, 0xF1, 0x0F, + 0x80, 0x01, 0x49, 0x60, 0x2D, 0x08, 0x85, 0x96, + 0xD2, 0x9E, 0x17, 0xA4, 0xE8, 0x49, 0x20, 0x13, + 0xFD, 0xD7, 0xDA, 0x8F, 0x53, 0x00, 0x59, 0xED, + 0xE7, 0x4D, 0x5C, 0xF4, 0x09, 0xC0, 0xB1, 0xE2, + 0xFF, 0x70, 0x71, 0x92, 0xEC, 0xFC, 0x12, 0x7A, + 0x37, 0x89, 0xD6, 0x48, 0xFD, 0x83, 0x83, 0x94 + }, + { + 0xA2, 0x95, 0xC5, 0xEF, 0x9A, 0x88, 0x36, 0x23, + 0x1B, 0xD9, 0x91, 0x3D, 0xB3, 0xAC, 0x4B, 0xC4, + 0x8B, 0xD4, 0x85, 0x65, 0xBF, 0x32, 0xBB, 0x19, + 0x20, 0x95, 0x86, 0x57, 0x67, 0x2A, 0xA1, 0xC6, + 0xFB, 0x0F, 0x06, 0x44, 0xD9, 0x43, 0x58, 0xF9, + 0x52, 0x51, 0x66, 0x15, 0x41, 0x5F, 0xD6, 0x41, + 0x02, 0xCB, 0x97, 0x89, 0x87, 0x90, 0x83, 0x32, + 0xC3, 0x7B, 0x0F, 0x7D, 0xB7, 0x41, 0x5A, 0x42 + }, + { + 0xF6, 0xA6, 0x9C, 0xAA, 0xDE, 0x19, 0xAE, 0x59, + 0xFB, 0x9C, 0xC3, 0xEF, 0xC8, 0xF0, 0x78, 0x9E, + 0x90, 0x97, 0x91, 0xCD, 0x33, 0x0D, 0x7A, 0xB6, + 0xDF, 0x89, 0xB8, 0x74, 0x88, 0x04, 0x82, 0xD2, + 0x52, 0x67, 0xB7, 0xC2, 0xA8, 0x87, 0xC9, 0x7C, + 0xE1, 0x9A, 0x04, 0x28, 0x18, 0x5F, 0xE9, 0x14, + 0xB7, 0xC5, 0x9B, 0xA2, 0xB4, 0x4C, 0x02, 0x9D, + 0x43, 0x8C, 0x8F, 0x3D, 0xA3, 0xC8, 0xA5, 0x68 + }, + { + 0x04, 0x4D, 0x48, 0xED, 0x90, 0xBF, 0x8A, 0xD8, + 0x20, 0x1F, 0x58, 0xA9, 0x74, 0xFF, 0x9C, 0xD1, + 0x90, 0x4A, 0x80, 0xFD, 0x99, 0x0D, 0x09, 0x68, + 0x3A, 0x90, 0xD9, 0xDB, 0x5B, 0xB3, 0x9E, 0xB7, + 0x9D, 0xD2, 0xCA, 0x70, 0xFE, 0xA7, 0x81, 0x59, + 0xBB, 0x05, 0xF6, 0x2D, 0xE6, 0x56, 0x4C, 0x34, + 0xED, 0xEF, 0xD9, 0x1F, 0x72, 0x30, 0xE8, 0x04, + 0xCD, 0x50, 0xF1, 0x53, 0xF2, 0xCD, 0x10, 0x76 + }, + { + 0x51, 0x0F, 0xD4, 0xDF, 0xBF, 0x16, 0xD3, 0x41, + 0xBE, 0xBC, 0xA0, 0xC4, 0x62, 0x47, 0xDA, 0xB2, + 0xDE, 0xFA, 0x9E, 0xC3, 0x11, 0x6A, 0xA7, 0x10, + 0xFA, 0xE4, 0x3A, 0xFB, 0x53, 0x05, 0xCB, 0x37, + 0x6C, 0x87, 0x7E, 0xAD, 0x6D, 0x77, 0xE0, 0x45, + 0x9E, 0x20, 0xC4, 0x9F, 0x26, 0xA0, 0x80, 0xE8, + 0x7E, 0xCE, 0xA7, 0x7A, 0xD2, 0x30, 0xD2, 0x85, + 0x40, 0x7E, 0xE3, 0xEA, 0x27, 0x84, 0xA6, 0x1F + }, + { + 0xCA, 0xAF, 0xD6, 0xE6, 0x09, 0x5E, 0x9E, 0x42, + 0xD4, 0xF4, 0x12, 0xED, 0xF2, 0xB4, 0x9F, 0xBB, + 0xFF, 0x8D, 0xD2, 0xEF, 0xC3, 0xDB, 0xB9, 0x5C, + 0xF3, 0x66, 0xB9, 0x24, 0x4C, 0x61, 0x1D, 0x8D, + 0xF5, 0xCD, 0x31, 0xA6, 0x0F, 0x3E, 0x5C, 0xBF, + 0x77, 0x61, 0x17, 0x92, 0x9B, 0x21, 0x16, 0xA1, + 0x76, 0x9C, 0xBC, 0x06, 0xAE, 0x71, 0xD7, 0x61, + 0x14, 0x31, 0x96, 0x2D, 0x69, 0x78, 0x4C, 0x28 + }, + { + 0x91, 0x68, 0x45, 0xE6, 0x7C, 0xFD, 0x23, 0xA8, + 0xC7, 0x2C, 0x3D, 0xEF, 0x15, 0x9F, 0xC2, 0x68, + 0x6C, 0xC0, 0x20, 0xC4, 0x69, 0xE2, 0xE6, 0x53, + 0x41, 0xC9, 0x1B, 0x63, 0x88, 0xE7, 0x9A, 0x27, + 0x52, 0x60, 0x36, 0x47, 0x54, 0x67, 0x43, 0x1C, + 0x27, 0x61, 0x77, 0x19, 0x90, 0x1F, 0xEB, 0xEC, + 0xE5, 0x11, 0xA9, 0x16, 0x3D, 0x24, 0xF2, 0x73, + 0x88, 0x24, 0x77, 0x01, 0x80, 0xFF, 0x66, 0x0D + }, + { + 0x0C, 0x53, 0x78, 0x6E, 0x5F, 0xD1, 0xBE, 0x9D, + 0x00, 0x39, 0x62, 0x84, 0x10, 0xD4, 0x77, 0x9D, + 0x77, 0xA8, 0x54, 0x35, 0x53, 0xAA, 0x65, 0xAD, + 0xCA, 0x68, 0xF9, 0xF0, 0x3A, 0x34, 0x58, 0xC8, + 0x0C, 0x01, 0x24, 0xFE, 0xF1, 0xF3, 0x0A, 0xBA, + 0x20, 0x5B, 0x47, 0x09, 0x74, 0xEB, 0x4D, 0xEC, + 0x92, 0x15, 0x88, 0xBB, 0x6B, 0xF5, 0x96, 0xD6, + 0x3E, 0xC9, 0x02, 0x8B, 0xE1, 0x1A, 0xF1, 0xD6 + }, + { + 0x8A, 0x2B, 0xE9, 0x65, 0xB3, 0xC7, 0x95, 0x32, + 0x58, 0x49, 0xFA, 0x7F, 0xCE, 0x64, 0x9E, 0x3E, + 0x63, 0x92, 0x4E, 0x39, 0x2A, 0x26, 0xA2, 0xAC, + 0x0C, 0x7D, 0x50, 0x39, 0x31, 0x18, 0xF6, 0x5A, + 0x4E, 0xA4, 0xCB, 0xB7, 0xA4, 0x58, 0x89, 0x0B, + 0x18, 0x6D, 0xD1, 0xC0, 0x0D, 0x16, 0x08, 0xB5, + 0x3D, 0xDA, 0x10, 0x38, 0x92, 0xFE, 0x74, 0x24, + 0x56, 0x54, 0xE6, 0x83, 0x46, 0x19, 0xCB, 0x37 + }, + { + 0x06, 0xD9, 0x74, 0xC3, 0x2F, 0xB0, 0x1A, 0x63, + 0x99, 0x66, 0x56, 0x45, 0xFE, 0x51, 0x79, 0xCE, + 0x4B, 0xB9, 0xB7, 0x96, 0xF2, 0x19, 0xB6, 0xE4, + 0x98, 0xC6, 0x5E, 0x1C, 0x98, 0x9A, 0x42, 0x18, + 0x86, 0xD4, 0xD6, 0x9F, 0xAD, 0xAA, 0x54, 0x66, + 0x0B, 0x4B, 0xF7, 0xB1, 0xF0, 0xD6, 0x6F, 0xBD, + 0x15, 0xB2, 0x75, 0xC6, 0xD2, 0x74, 0x03, 0x46, + 0xD3, 0x0A, 0x85, 0xA8, 0x65, 0xBB, 0x69, 0xBB + }, + { + 0x42, 0xB4, 0x74, 0xDF, 0x79, 0x05, 0x98, 0xB8, + 0x0D, 0x61, 0x9D, 0x64, 0x06, 0xCF, 0xDC, 0xB2, + 0xF7, 0xD4, 0x6C, 0x61, 0xFA, 0x5A, 0x54, 0xEF, + 0xBC, 0xF8, 0x4D, 0x91, 0x38, 0xA6, 0x22, 0x36, + 0x74, 0xDD, 0x4A, 0xA6, 0xC4, 0xC9, 0x77, 0xB3, + 0x95, 0x43, 0x4D, 0x4E, 0x40, 0x8B, 0xCC, 0x94, + 0xCA, 0xBD, 0x33, 0x4D, 0x45, 0x12, 0x81, 0xFE, + 0x9F, 0xF1, 0x9C, 0x29, 0xFD, 0xE9, 0x7A, 0x25 + }, + { + 0x5E, 0xCE, 0xF5, 0xE9, 0xE2, 0xF9, 0x8E, 0xFB, + 0xA3, 0x0A, 0xCB, 0x11, 0xC5, 0x8B, 0xEE, 0x8F, + 0x2E, 0x0A, 0x4C, 0x29, 0xCD, 0x21, 0x9F, 0x3A, + 0xCA, 0x29, 0x66, 0x44, 0x50, 0x99, 0xFC, 0x38, + 0xCE, 0xB9, 0xBD, 0xBF, 0x7B, 0x4D, 0x23, 0x1E, + 0x0F, 0x6A, 0x42, 0x14, 0xD6, 0xD6, 0x02, 0xB9, + 0xAF, 0x6C, 0x79, 0xDA, 0x83, 0x14, 0x60, 0xB3, + 0xF6, 0x77, 0x01, 0x27, 0xC2, 0x05, 0x4C, 0x49 + }, + { + 0x83, 0x77, 0xAB, 0x41, 0x8A, 0x8D, 0x24, 0x85, + 0xD7, 0xF8, 0x5F, 0xFE, 0xFA, 0x0E, 0xBB, 0x84, + 0xF0, 0xE3, 0x7B, 0xBB, 0x2E, 0x6F, 0x2C, 0xB6, + 0x75, 0x45, 0x38, 0x09, 0x3D, 0xEC, 0x02, 0xEB, + 0x64, 0x49, 0x2A, 0xD4, 0x4E, 0xE1, 0x9C, 0x0D, + 0x4E, 0xDF, 0xF2, 0xFF, 0xB2, 0x90, 0xD3, 0x32, + 0x9E, 0x46, 0xBB, 0x34, 0x5D, 0x92, 0xB3, 0xE4, + 0x5B, 0xE2, 0xEF, 0x72, 0x69, 0x07, 0x16, 0xF8 + }, + { + 0x30, 0x83, 0x41, 0x60, 0xDC, 0xB8, 0x76, 0xC3, + 0x3C, 0xC8, 0xB0, 0xCB, 0xAC, 0x84, 0xD1, 0xED, + 0x79, 0x88, 0x41, 0x90, 0x3B, 0xE9, 0x2F, 0xA3, + 0x2B, 0x1D, 0x2F, 0xAC, 0x01, 0x0B, 0x4F, 0x36, + 0x98, 0x24, 0xD9, 0x06, 0x2F, 0x1E, 0x97, 0xEF, + 0x1E, 0xBA, 0x1B, 0x6E, 0x46, 0x1A, 0xB6, 0xB1, + 0x89, 0x3E, 0x82, 0x73, 0x54, 0xA1, 0xB9, 0x17, + 0xDE, 0xE4, 0x08, 0x5D, 0xCD, 0x96, 0xC4, 0x2C + }, + { + 0xBE, 0x44, 0x83, 0x26, 0xA5, 0xF0, 0x0B, 0x05, + 0xF7, 0xD7, 0x52, 0xCF, 0x08, 0xC7, 0x44, 0x2A, + 0x20, 0x8A, 0xA3, 0x8C, 0x4A, 0x50, 0xBD, 0x44, + 0x73, 0x39, 0x67, 0x2F, 0xDF, 0x2E, 0x74, 0xD0, + 0xFA, 0xA5, 0xB0, 0x70, 0xAE, 0xDE, 0xEB, 0x8A, + 0xFC, 0xCA, 0x5B, 0x02, 0x41, 0x37, 0x23, 0xAB, + 0x98, 0x2D, 0x35, 0x32, 0x22, 0xEF, 0xA3, 0x57, + 0x3D, 0xFC, 0x43, 0x5E, 0xE0, 0x43, 0x26, 0x54 + }, + { + 0x82, 0x2C, 0xAD, 0x4C, 0x0B, 0x2F, 0x10, 0x67, + 0x8E, 0xB0, 0x66, 0x61, 0xE8, 0x09, 0x30, 0xEC, + 0x85, 0x50, 0x5D, 0x74, 0x35, 0x80, 0x48, 0x99, + 0x4A, 0xF8, 0xE0, 0x93, 0xBA, 0xC1, 0xB5, 0xFD, + 0x46, 0xC8, 0x99, 0xC1, 0x63, 0x91, 0xB2, 0xE1, + 0xE3, 0x26, 0x1A, 0xCC, 0x1A, 0x85, 0x06, 0x64, + 0x59, 0x67, 0xD0, 0xE4, 0x66, 0xD8, 0xD3, 0x20, + 0x74, 0x39, 0x46, 0x57, 0xE4, 0x40, 0x73, 0xDA + }, + { + 0xED, 0xD2, 0xBE, 0xE5, 0xE1, 0x19, 0x3D, 0x92, + 0x7F, 0x5A, 0xED, 0x61, 0xBD, 0x5C, 0x38, 0x13, + 0x99, 0x0A, 0x34, 0x39, 0x64, 0x6B, 0xD2, 0x78, + 0x91, 0x39, 0x80, 0xD3, 0x09, 0xF1, 0xAF, 0x38, + 0x05, 0x73, 0x17, 0xED, 0xCA, 0x94, 0xB5, 0x01, + 0x48, 0xBF, 0xAF, 0x84, 0xD2, 0x5B, 0xAF, 0xB3, + 0xC0, 0xD1, 0xE4, 0x52, 0xD2, 0x23, 0xB0, 0x17, + 0xD7, 0xD8, 0x3B, 0xC1, 0xC7, 0xE4, 0x7F, 0xC1 + }, + { + 0x39, 0x07, 0xC6, 0xC8, 0xF6, 0x15, 0x77, 0x2A, + 0xDF, 0x3B, 0x75, 0xB1, 0xEE, 0xC0, 0x38, 0xEC, + 0xBA, 0x0D, 0x59, 0x6D, 0x75, 0x40, 0x51, 0x3E, + 0xFE, 0xA2, 0xBF, 0xF9, 0x93, 0x92, 0x66, 0xE7, + 0xC7, 0x73, 0x89, 0xA1, 0x4C, 0x49, 0x2E, 0x4B, + 0x00, 0x73, 0xA2, 0x55, 0xEB, 0x0C, 0x71, 0xC7, + 0x81, 0xCC, 0xCB, 0x95, 0x61, 0x1A, 0x72, 0x4C, + 0xC0, 0x15, 0xF6, 0xD6, 0x92, 0x54, 0xD7, 0x28 + }, + { + 0x4A, 0x33, 0x6E, 0x81, 0x8A, 0x9E, 0xDD, 0x95, + 0x41, 0x32, 0xE0, 0x85, 0x32, 0xB6, 0x31, 0x62, + 0x66, 0xDC, 0xB6, 0xD9, 0x68, 0x29, 0x36, 0x11, + 0xB3, 0xB2, 0x26, 0x01, 0xC5, 0x64, 0x41, 0x57, + 0xA6, 0x0B, 0xDA, 0x56, 0x49, 0x6C, 0x9B, 0x18, + 0xCD, 0xB1, 0x59, 0x18, 0x2A, 0xCF, 0x79, 0x95, + 0xC1, 0x00, 0x1F, 0x1D, 0xF8, 0x17, 0x55, 0x44, + 0xCC, 0x7D, 0x42, 0x93, 0x3C, 0xCC, 0x36, 0xA5 + }, + { + 0xCF, 0x65, 0x7F, 0x15, 0x04, 0x9C, 0x04, 0x00, + 0xA5, 0xE1, 0xB2, 0x28, 0xB2, 0x51, 0x36, 0xC1, + 0x03, 0xB7, 0xC6, 0xDA, 0x3E, 0x55, 0x95, 0x6D, + 0x15, 0x83, 0x30, 0x31, 0xC6, 0x96, 0x56, 0xA7, + 0x37, 0xEE, 0xE6, 0x89, 0xF9, 0x15, 0xE9, 0xA5, + 0xCA, 0x75, 0x80, 0x49, 0x47, 0x8B, 0x6E, 0x1F, + 0xF4, 0x0B, 0xD6, 0x1B, 0xB1, 0x77, 0xA1, 0x7A, + 0xC9, 0xE7, 0x22, 0x9F, 0x5C, 0x91, 0xB9, 0xEE + }, + { + 0x1C, 0xE5, 0xB8, 0xD6, 0xF6, 0xFC, 0xC8, 0x9F, + 0xCB, 0x6E, 0xD2, 0x9F, 0x12, 0x79, 0x6C, 0xC2, + 0x10, 0xA0, 0x3F, 0x47, 0x63, 0xE5, 0x28, 0xCB, + 0x2C, 0x0E, 0x1B, 0x4B, 0x12, 0x55, 0xD6, 0xAE, + 0x86, 0xC7, 0x93, 0x32, 0x52, 0x9F, 0x63, 0x68, + 0xD0, 0xBC, 0xFE, 0x9D, 0x31, 0x6A, 0x5F, 0x99, + 0x9A, 0x53, 0xAF, 0x47, 0xA8, 0xF0, 0xEC, 0x44, + 0x12, 0xCE, 0x19, 0x15, 0x6B, 0xBA, 0xFD, 0x04 + }, + { + 0x84, 0x73, 0xF9, 0xB7, 0xFE, 0x42, 0xF3, 0x95, + 0x35, 0x1A, 0xE1, 0x6B, 0x6A, 0xF0, 0x98, 0x93, + 0x81, 0x4E, 0xC4, 0xD2, 0x03, 0x90, 0x57, 0x97, + 0x9D, 0x65, 0xCE, 0x66, 0x13, 0x21, 0x61, 0x43, + 0x02, 0x9A, 0xE1, 0x8E, 0x97, 0x6A, 0x47, 0x23, + 0x6B, 0x78, 0xD7, 0xDA, 0x32, 0x65, 0x13, 0x9D, + 0x74, 0xD6, 0x55, 0x99, 0x40, 0x3F, 0xEA, 0xCC, + 0xBA, 0x07, 0xB6, 0x44, 0x03, 0x4E, 0xC1, 0x0B + }, + { + 0x3D, 0xD9, 0xE3, 0x6B, 0xBC, 0x80, 0x5B, 0xAC, + 0xD1, 0x16, 0x04, 0xD5, 0x97, 0xE2, 0x3A, 0xA1, + 0xBF, 0x4C, 0x88, 0xC4, 0xDB, 0x8E, 0x8F, 0xE4, + 0xED, 0x08, 0x78, 0x16, 0xFF, 0x06, 0x01, 0x47, + 0xD4, 0x73, 0x3A, 0x33, 0x34, 0x63, 0x23, 0x07, + 0xE4, 0x13, 0x89, 0x36, 0x77, 0xB4, 0xE4, 0x69, + 0x3E, 0x8F, 0x47, 0x15, 0xD8, 0xF9, 0x71, 0x9B, + 0xF6, 0x2E, 0x62, 0x28, 0xC1, 0xA9, 0x01, 0xDF + }, + { + 0x22, 0xAB, 0x69, 0x5A, 0xA0, 0x0F, 0x8B, 0x62, + 0xC2, 0xE0, 0xFF, 0xF1, 0x63, 0x37, 0x81, 0xC7, + 0x28, 0xD1, 0x82, 0xE5, 0x33, 0x1C, 0x9E, 0xC4, + 0x7A, 0xE8, 0xB2, 0x45, 0x3B, 0x6A, 0x2F, 0x78, + 0x5D, 0x14, 0x5E, 0x89, 0x43, 0x5A, 0x49, 0x4F, + 0x7F, 0x83, 0xE0, 0xD3, 0x2E, 0x7C, 0x72, 0xB9, + 0x55, 0x7F, 0xD1, 0xF9, 0xD8, 0x90, 0x13, 0x52, + 0x8E, 0x7F, 0xDE, 0x98, 0xB2, 0x65, 0x9E, 0x26 + }, + { + 0xF4, 0xF2, 0x76, 0x00, 0x34, 0x5F, 0x4F, 0xAC, + 0x67, 0x51, 0x61, 0x6A, 0x81, 0x6E, 0x75, 0xDF, + 0x70, 0xC6, 0x2B, 0x90, 0xB6, 0xD2, 0x5B, 0xF2, + 0xBC, 0xD6, 0x30, 0x9D, 0x93, 0x9B, 0xC4, 0x80, + 0xFC, 0x51, 0x1F, 0x0F, 0x92, 0x71, 0x4A, 0xE7, + 0xB8, 0x3F, 0xF2, 0xF5, 0x04, 0x75, 0xD9, 0x37, + 0xAC, 0x98, 0x03, 0x3F, 0x98, 0x69, 0x25, 0x93, + 0xD6, 0xC3, 0xBA, 0x4F, 0xC1, 0x28, 0xC6, 0xF8 + }, + { + 0x9D, 0xE5, 0xFB, 0x5B, 0x19, 0x15, 0x44, 0x73, + 0x9D, 0x5B, 0x82, 0xF6, 0xE8, 0xFA, 0x28, 0x7D, + 0xF2, 0x7B, 0x23, 0x5C, 0x7D, 0x6F, 0x97, 0xB2, + 0x53, 0x90, 0x0F, 0x71, 0x81, 0xBE, 0x54, 0x39, + 0x42, 0x2D, 0xCC, 0x06, 0x38, 0x4F, 0x73, 0xD7, + 0xEC, 0xFF, 0x14, 0x47, 0x27, 0xDE, 0xBA, 0xF9, + 0x42, 0xC4, 0xBD, 0xA6, 0x19, 0x54, 0x85, 0x69, + 0x2D, 0xE0, 0x2C, 0xA8, 0xA8, 0x6A, 0xE3, 0x32 + }, + { + 0xF5, 0x10, 0x80, 0xD7, 0xEF, 0xBC, 0xFB, 0xCC, + 0x87, 0x19, 0x45, 0x27, 0xDE, 0x74, 0x4D, 0xE7, + 0xB3, 0x8B, 0x65, 0x9C, 0x9F, 0x00, 0x6D, 0x4E, + 0x63, 0x78, 0x81, 0xD9, 0x8C, 0x64, 0xF4, 0xB1, + 0x46, 0x5B, 0xFF, 0x1C, 0x53, 0x13, 0x4D, 0x06, + 0x98, 0xE8, 0x3C, 0xD4, 0xCF, 0xB7, 0x78, 0xBA, + 0x62, 0x98, 0x54, 0x17, 0xF8, 0xC9, 0xE5, 0x92, + 0x3E, 0x90, 0x1A, 0x29, 0x2F, 0x13, 0x92, 0x5D + }, + { + 0xA0, 0x27, 0x70, 0xBC, 0x16, 0xC0, 0x3C, 0x9E, + 0xCE, 0xFB, 0x7D, 0x98, 0x6F, 0x7C, 0x56, 0x0C, + 0xAD, 0xDF, 0x55, 0x19, 0x74, 0x60, 0x27, 0x4D, + 0xBF, 0x08, 0xFF, 0xA0, 0xBF, 0xE1, 0xB5, 0x9C, + 0x29, 0xDD, 0xBB, 0xA2, 0x99, 0x93, 0xA9, 0x7E, + 0x37, 0x3F, 0xA5, 0xF4, 0xE8, 0x82, 0x76, 0x76, + 0x5A, 0x59, 0x43, 0x7F, 0x06, 0x09, 0xA9, 0x96, + 0x4D, 0x5C, 0x1C, 0xB6, 0x63, 0xA8, 0x82, 0x8F + }, + { + 0xDA, 0x33, 0x85, 0xF8, 0x41, 0xEB, 0xDC, 0x8B, + 0x2E, 0x20, 0x01, 0x4B, 0x09, 0x88, 0x37, 0xC4, + 0x6A, 0xBD, 0x5E, 0x0B, 0x6C, 0x74, 0x34, 0xAD, + 0x1A, 0x94, 0x33, 0xCE, 0xCB, 0x55, 0x91, 0xAB, + 0xBB, 0x3E, 0xA0, 0x28, 0xC0, 0xEE, 0x2E, 0xD4, + 0x02, 0xB1, 0xE9, 0xA2, 0xDD, 0xB3, 0xFC, 0x68, + 0x6B, 0x8D, 0x02, 0x4F, 0x36, 0xE7, 0x4C, 0xA4, + 0xAB, 0x93, 0x4D, 0x32, 0x8A, 0x6B, 0xF5, 0x3A + }, + { + 0x2C, 0xCC, 0x4A, 0x8B, 0x5D, 0xC7, 0x89, 0x62, + 0x33, 0x6D, 0x76, 0x48, 0x2F, 0xEE, 0x37, 0x0C, + 0xCB, 0xB8, 0x7D, 0x48, 0x9B, 0x2A, 0xB5, 0xDF, + 0x83, 0x52, 0x57, 0x50, 0x35, 0xAC, 0x8A, 0xA3, + 0xBF, 0xFA, 0x4A, 0xA7, 0xBA, 0x54, 0x6C, 0x20, + 0xCD, 0x49, 0xF7, 0x64, 0x07, 0xB7, 0x89, 0x06, + 0xCD, 0x4C, 0x7A, 0x61, 0xF9, 0x10, 0xA6, 0xFC, + 0x1A, 0xB0, 0xB4, 0x0B, 0xE4, 0xF0, 0x11, 0x6C + }, + { + 0xC8, 0xB8, 0xB5, 0xC4, 0xC9, 0xD0, 0x23, 0xF1, + 0x88, 0x37, 0x01, 0x8D, 0x7B, 0x78, 0x91, 0x87, + 0x0B, 0x70, 0xA9, 0x89, 0x27, 0x72, 0x27, 0xCA, + 0x41, 0x89, 0x83, 0x98, 0x27, 0x8B, 0x38, 0xB2, + 0x2F, 0x30, 0x96, 0x5F, 0x82, 0x62, 0x7E, 0x32, + 0x2E, 0x8F, 0x6E, 0xF2, 0x20, 0x56, 0xDF, 0x37, + 0x6A, 0x7B, 0x70, 0x7A, 0xDD, 0xC7, 0x49, 0x4C, + 0x55, 0x12, 0xB7, 0x29, 0x03, 0xF3, 0x0A, 0x14 + }, + { + 0x1C, 0x59, 0xC8, 0x13, 0x56, 0xAB, 0x60, 0x69, + 0x7C, 0xFF, 0xEC, 0x4D, 0x71, 0x70, 0x66, 0x9D, + 0x70, 0xB2, 0x72, 0x92, 0xAE, 0x83, 0xCA, 0xCB, + 0x8B, 0xEB, 0xEE, 0xAB, 0xE8, 0x5F, 0xDA, 0x7A, + 0xC4, 0x1A, 0xDE, 0x8D, 0x2C, 0x6A, 0xBA, 0xB9, + 0xEF, 0x95, 0xEC, 0x56, 0x80, 0xC8, 0xE7, 0xF4, + 0x94, 0x37, 0x29, 0xAC, 0x83, 0x67, 0xD1, 0x28, + 0xAF, 0x49, 0x04, 0x0F, 0x63, 0xC4, 0xE3, 0x2E + }, + { + 0x9B, 0xCB, 0x84, 0x94, 0xAC, 0x46, 0x83, 0xC6, + 0x74, 0xF0, 0x04, 0x03, 0xE1, 0xEF, 0xF9, 0xC8, + 0x01, 0x76, 0xE4, 0x21, 0x30, 0x11, 0x1B, 0x3E, + 0x08, 0x25, 0xC7, 0x76, 0x15, 0x2B, 0x3C, 0xFA, + 0x6D, 0x30, 0x2B, 0x2D, 0xD5, 0xC6, 0xB6, 0xD6, + 0x3C, 0x65, 0xB8, 0xB1, 0x5E, 0xF8, 0xF0, 0xFB, + 0x08, 0x3F, 0xDC, 0x23, 0x4D, 0x03, 0x57, 0xF7, + 0xEC, 0x80, 0xE3, 0x43, 0x3E, 0x26, 0x88, 0x30 + }, + { + 0xD3, 0x51, 0x5A, 0x06, 0x82, 0xE8, 0xDB, 0xBE, + 0xAA, 0xF7, 0xBC, 0x77, 0x8D, 0xF0, 0x32, 0xB9, + 0x55, 0x8B, 0xA1, 0x7E, 0xED, 0x17, 0xE9, 0x84, + 0xE9, 0xC7, 0xEE, 0x77, 0xD4, 0x22, 0x5A, 0xF5, + 0xE7, 0x59, 0x3D, 0x16, 0x05, 0xB6, 0x78, 0x14, + 0x88, 0x6F, 0xEC, 0x81, 0x94, 0x9F, 0x53, 0xF9, + 0x7D, 0x59, 0xE1, 0xD2, 0x37, 0x72, 0xDA, 0xD0, + 0xCC, 0x49, 0x6D, 0xE7, 0xB4, 0x64, 0x32, 0x5E + }, + { + 0xF9, 0x9D, 0xE3, 0xBA, 0x29, 0xD4, 0x67, 0x65, + 0xA0, 0x8D, 0x97, 0x7F, 0xA4, 0xC1, 0x25, 0x6B, + 0x13, 0xA6, 0x15, 0x37, 0x74, 0x2B, 0x1D, 0x88, + 0x7C, 0x1C, 0xB1, 0x7C, 0xDF, 0x67, 0x39, 0xBF, + 0xDF, 0x1C, 0x19, 0x79, 0xDB, 0x4A, 0xDE, 0xA3, + 0x2B, 0x6D, 0x97, 0xA9, 0xDD, 0x53, 0xCC, 0x7B, + 0xCE, 0x66, 0x4B, 0x94, 0xBC, 0x38, 0x7C, 0x2C, + 0xC3, 0xA2, 0xA0, 0x7E, 0x21, 0xC5, 0x66, 0xFD + }, + { + 0x84, 0x92, 0xC3, 0x43, 0xC8, 0xE0, 0x87, 0xE7, + 0x9C, 0x78, 0x96, 0x82, 0x0C, 0x14, 0x73, 0xEE, + 0xA9, 0x92, 0x7B, 0x7F, 0x29, 0x16, 0x20, 0x34, + 0xF9, 0x52, 0xDD, 0x2E, 0x8F, 0xAE, 0x01, 0x42, + 0xD3, 0x41, 0x2D, 0x42, 0x8D, 0xCD, 0x8C, 0xEA, + 0xDA, 0x24, 0xE4, 0x26, 0x73, 0x09, 0x43, 0x2D, + 0xF1, 0x38, 0x7F, 0xBD, 0x01, 0xEB, 0xB6, 0x23, + 0x56, 0x40, 0x14, 0xF1, 0x9B, 0xBC, 0x89, 0x97 + }, + { + 0x83, 0x0C, 0x46, 0x44, 0xA2, 0x0B, 0x3E, 0x46, + 0x74, 0xCC, 0x5F, 0xF4, 0xB6, 0xC3, 0x03, 0x55, + 0xB3, 0xD3, 0xB9, 0xC5, 0xDF, 0x13, 0xCB, 0x74, + 0x16, 0xF4, 0x57, 0xC9, 0x45, 0x14, 0x0C, 0x7F, + 0xAF, 0x1A, 0x80, 0x4E, 0x6D, 0xA6, 0xAC, 0xDC, + 0x5E, 0x29, 0x7C, 0x3E, 0xAF, 0x5F, 0x35, 0xA5, + 0x11, 0x9B, 0x11, 0x15, 0x25, 0x2E, 0xCF, 0x2A, + 0x04, 0xFD, 0xF6, 0xFE, 0x88, 0xD2, 0x71, 0x81 + }, + { + 0x12, 0x3B, 0x72, 0x7F, 0xDA, 0x0F, 0x2D, 0x0E, + 0xC3, 0x53, 0x23, 0x4D, 0xC4, 0xC0, 0x40, 0x14, + 0x31, 0x53, 0xF1, 0x7D, 0x46, 0x76, 0x28, 0x87, + 0x54, 0x9A, 0x24, 0x94, 0xFD, 0xFD, 0xBF, 0x82, + 0xFD, 0xF5, 0x14, 0x69, 0xA8, 0x5E, 0x6C, 0xFB, + 0x6A, 0xF1, 0x7E, 0x1E, 0xE1, 0xF9, 0x4D, 0xF2, + 0x3A, 0xAA, 0xE3, 0xEC, 0xA9, 0xA9, 0xE5, 0xE3, + 0x45, 0xB2, 0xFB, 0xAA, 0x60, 0x65, 0x98, 0xEC + }, + { + 0x3C, 0xC3, 0x3C, 0x7A, 0x19, 0x84, 0x14, 0xA5, + 0x65, 0x0B, 0x9A, 0xBC, 0x48, 0xA5, 0xE8, 0xBE, + 0x4C, 0x1F, 0xC0, 0xA4, 0x5A, 0xD0, 0x06, 0x14, + 0x47, 0xB7, 0x13, 0xC6, 0x3F, 0xFD, 0x27, 0x2B, + 0x6E, 0xE9, 0xE5, 0xD2, 0x40, 0xC2, 0x0A, 0x58, + 0xBB, 0xF5, 0xB9, 0x2C, 0x29, 0xB9, 0xF6, 0x74, + 0xAF, 0x8F, 0xA6, 0xFC, 0xD5, 0x71, 0x55, 0x73, + 0xCE, 0xDA, 0x8F, 0xF3, 0xC5, 0x6A, 0x09, 0x93 + }, + { + 0xAA, 0x1B, 0xBC, 0xEA, 0x0D, 0x02, 0x1A, 0x8C, + 0xCE, 0x25, 0x2B, 0xAE, 0x46, 0x2A, 0x0F, 0xE0, + 0xFD, 0x63, 0x9D, 0x36, 0x09, 0x5A, 0xE2, 0xAC, + 0x85, 0xD8, 0x53, 0xA3, 0xC3, 0xE7, 0xB5, 0x1A, + 0x95, 0xE0, 0x23, 0x1E, 0xE9, 0xAF, 0x27, 0xA7, + 0x72, 0x9E, 0xD4, 0x61, 0xB6, 0x80, 0x92, 0x5C, + 0x3D, 0x4B, 0xAE, 0xE9, 0xE9, 0xC5, 0xF8, 0xEA, + 0x62, 0xBD, 0xA1, 0x4E, 0x31, 0x3A, 0x50, 0xE4 + }, + { + 0xC2, 0xDD, 0x92, 0x10, 0xB3, 0xB3, 0x55, 0x52, + 0x04, 0xC5, 0x02, 0xFD, 0xA0, 0xCF, 0x92, 0xC6, + 0x25, 0x96, 0xAB, 0x49, 0xDE, 0x7A, 0x29, 0xBE, + 0x64, 0x7A, 0x26, 0x3D, 0xE7, 0x22, 0xF3, 0x20, + 0xDA, 0x0C, 0x07, 0xAC, 0xAB, 0xD5, 0x5E, 0x1D, + 0x0D, 0xD6, 0x04, 0x39, 0xFE, 0xF1, 0x82, 0xBE, + 0x24, 0xE6, 0x6C, 0xE0, 0x54, 0xBF, 0x99, 0xE4, + 0x95, 0x3D, 0xC5, 0x85, 0xE7, 0x17, 0xF7, 0x8C + }, + { + 0x18, 0x08, 0x14, 0x5C, 0xC1, 0x5A, 0x49, 0x9C, + 0x6E, 0x6B, 0x90, 0x59, 0x39, 0x7E, 0x2A, 0xB5, + 0x60, 0xD7, 0x9A, 0x09, 0xAE, 0x40, 0x66, 0xD1, + 0xC7, 0x58, 0x0F, 0x6F, 0x73, 0xB6, 0xE3, 0x6F, + 0xCB, 0xF7, 0x1D, 0x0D, 0x93, 0x68, 0x94, 0x6C, + 0xDE, 0x53, 0x64, 0x8D, 0xB6, 0xC0, 0x9E, 0xB5, + 0x76, 0x99, 0x8B, 0xF9, 0xCA, 0xE8, 0x3C, 0x06, + 0x83, 0x8E, 0xA3, 0x06, 0xD6, 0x3B, 0xB7, 0x9C + }, + { + 0xEF, 0x2D, 0x25, 0x5D, 0x50, 0x37, 0xB9, 0x2B, + 0x76, 0x8A, 0xC3, 0xE4, 0x7F, 0x26, 0x24, 0x92, + 0xD5, 0xE2, 0xB5, 0x91, 0x2A, 0x08, 0x8C, 0xFB, + 0xEE, 0xAC, 0x18, 0x60, 0xE7, 0x94, 0x98, 0xF6, + 0xD0, 0x8D, 0xA5, 0xF3, 0x11, 0x79, 0xF2, 0xB6, + 0x23, 0x48, 0xEB, 0x36, 0xB4, 0xCE, 0xC4, 0x2F, + 0x0B, 0x9D, 0x6C, 0xFF, 0x6A, 0x67, 0xE6, 0x99, + 0x14, 0x59, 0x62, 0xBD, 0x24, 0x8E, 0x39, 0xE7 + }, + { + 0xA3, 0x84, 0xFB, 0x09, 0xF2, 0x34, 0x6C, 0xCA, + 0x44, 0xB0, 0x0A, 0xF2, 0x9F, 0xB4, 0x91, 0xFE, + 0x01, 0x01, 0x1F, 0xC7, 0x20, 0x07, 0x80, 0x24, + 0x3B, 0xAD, 0xE5, 0x8C, 0xB3, 0x37, 0x22, 0x7F, + 0x49, 0xAE, 0x3A, 0x64, 0x2B, 0x34, 0x89, 0x58, + 0x7C, 0xC1, 0xED, 0x67, 0x6A, 0xC3, 0x9A, 0xFB, + 0x70, 0x79, 0x35, 0x7A, 0xE3, 0xAF, 0x3B, 0x05, + 0xCF, 0x26, 0xC0, 0xBE, 0x54, 0x78, 0xAA, 0x98 + }, + { + 0x98, 0xB6, 0xDE, 0x75, 0xC4, 0x2E, 0x1E, 0x5C, + 0xDD, 0x66, 0x23, 0xAC, 0xA4, 0x7A, 0x1A, 0x35, + 0x9E, 0x9A, 0xEF, 0x84, 0xF1, 0x0D, 0x6B, 0xF1, + 0x25, 0x09, 0x33, 0x31, 0xD9, 0xF5, 0xC6, 0x3F, + 0xC7, 0xA2, 0x90, 0x8B, 0x66, 0xF5, 0x1B, 0xF0, + 0x68, 0xDD, 0x21, 0x3B, 0x90, 0xF7, 0x2F, 0xB1, + 0x3D, 0xA8, 0xD7, 0xD3, 0x7C, 0xC7, 0xB0, 0x20, + 0x18, 0x8D, 0xF4, 0x51, 0xFF, 0xD3, 0x26, 0x84 + }, + { + 0x92, 0x24, 0x70, 0xCB, 0x5A, 0xE0, 0xFE, 0x54, + 0x81, 0x05, 0x87, 0xDE, 0x23, 0x8B, 0xC4, 0x07, + 0xF5, 0x97, 0xEF, 0x6B, 0x51, 0x9B, 0x16, 0x07, + 0x51, 0x5A, 0x2B, 0x46, 0x7B, 0x95, 0x92, 0xC9, + 0x89, 0xFA, 0xA4, 0x96, 0xCC, 0xF7, 0x34, 0xB8, + 0x38, 0x8D, 0x3C, 0x61, 0xA0, 0x18, 0x0F, 0x76, + 0xBB, 0x86, 0x80, 0xF0, 0xAE, 0x1C, 0xDB, 0x85, + 0x38, 0x73, 0x70, 0x84, 0xC1, 0x34, 0x98, 0x32 + }, + { + 0xF6, 0xFF, 0x8A, 0x11, 0xEC, 0x7A, 0x3C, 0x51, + 0xD7, 0xB6, 0xE0, 0xC4, 0x7B, 0x42, 0x42, 0xF0, + 0x01, 0x4C, 0xF5, 0xFA, 0xB6, 0x07, 0x45, 0xB6, + 0x91, 0x39, 0x18, 0x65, 0xE3, 0x08, 0xF1, 0xD8, + 0xCB, 0xA8, 0x4D, 0xD4, 0x7D, 0x7B, 0xCA, 0x1A, + 0xD3, 0xB8, 0x0C, 0xA0, 0x52, 0x14, 0x53, 0x57, + 0xFB, 0xCD, 0x3C, 0xC7, 0x18, 0x20, 0x1B, 0xF9, + 0x58, 0x44, 0x5E, 0x95, 0x5D, 0x11, 0x35, 0x72 + }, + { + 0x67, 0x6E, 0x83, 0x57, 0xAA, 0xAA, 0xB0, 0xB3, + 0xDF, 0xD4, 0xAE, 0x6C, 0x93, 0xE5, 0x70, 0x29, + 0xF3, 0x70, 0xA3, 0x58, 0x0C, 0x6A, 0x1E, 0xC1, + 0x3B, 0x63, 0xD8, 0xD6, 0xD8, 0x94, 0x92, 0xB2, + 0xC1, 0xBF, 0xC5, 0x47, 0x83, 0x03, 0x1F, 0xB6, + 0x38, 0x49, 0x1D, 0xB8, 0xCF, 0xCD, 0xE4, 0x1D, + 0x0B, 0x78, 0x46, 0x46, 0xB3, 0x06, 0x14, 0x5C, + 0x83, 0xAF, 0x9A, 0xDE, 0x7A, 0xB2, 0x18, 0xC1 + }, + { + 0xA8, 0xF7, 0xD9, 0x43, 0xAF, 0x07, 0x4D, 0xA4, + 0xC9, 0x8D, 0x98, 0x4F, 0xA9, 0x47, 0xE9, 0x81, + 0x3E, 0xC5, 0x85, 0x5F, 0x39, 0x9D, 0xD3, 0x5E, + 0xE4, 0x2E, 0xAF, 0x1B, 0x5D, 0x0B, 0x78, 0xCC, + 0x08, 0x9E, 0x1D, 0x66, 0x0D, 0x51, 0x9D, 0x54, + 0x1B, 0xC4, 0x9F, 0xF7, 0x46, 0x7A, 0x5E, 0x8D, + 0x38, 0x8C, 0x4F, 0x8A, 0x45, 0xAE, 0xC7, 0x7B, + 0x08, 0x34, 0x3B, 0xB0, 0x98, 0x9F, 0xCA, 0xCD + }, + { + 0x2D, 0xDF, 0x6B, 0xD1, 0x0F, 0x36, 0x1A, 0x6F, + 0x8A, 0x06, 0x06, 0xA7, 0x5D, 0x52, 0x37, 0x84, + 0xCD, 0x5A, 0xE6, 0x6C, 0x49, 0x2C, 0xB7, 0x42, + 0xEB, 0x43, 0x9D, 0x72, 0xB1, 0x0E, 0x0A, 0x3D, + 0x86, 0x97, 0xD9, 0x59, 0x93, 0x99, 0x16, 0x48, + 0x45, 0x28, 0xCA, 0x59, 0x9A, 0x37, 0x04, 0xAD, + 0x99, 0x2D, 0xB6, 0x0A, 0x9C, 0x4C, 0x6F, 0x54, + 0x95, 0xF1, 0x3B, 0xD3, 0x58, 0x4D, 0x5B, 0xE4 + }, + { + 0x25, 0xC4, 0xED, 0x78, 0xF5, 0x36, 0xFA, 0xF9, + 0xD4, 0xF4, 0x0D, 0x5A, 0xE1, 0xFD, 0xF8, 0x1B, + 0x4D, 0xF9, 0x46, 0x4D, 0x1B, 0x96, 0xBE, 0xBC, + 0x16, 0x07, 0xE5, 0xBF, 0x9C, 0x32, 0xD9, 0xB5, + 0xEF, 0x49, 0x07, 0x8F, 0x48, 0x83, 0xD5, 0x7E, + 0x85, 0x38, 0x4F, 0x73, 0xAA, 0x65, 0xDD, 0x2C, + 0x25, 0x5D, 0x14, 0x36, 0x26, 0x4A, 0x48, 0x0B, + 0x8F, 0x91, 0x73, 0x9E, 0x1E, 0xB9, 0xD6, 0x15 + }, + { + 0xB2, 0x39, 0x2E, 0xBD, 0x9B, 0x23, 0xDA, 0x87, + 0xA2, 0xF4, 0x96, 0xC1, 0x1E, 0x23, 0x17, 0xC9, + 0xD0, 0x51, 0xA9, 0x49, 0x52, 0x6A, 0xC6, 0xED, + 0xF6, 0x74, 0xAB, 0x13, 0xB7, 0x65, 0xD1, 0xC3, + 0xAC, 0x25, 0x08, 0x1D, 0x19, 0x8C, 0xDD, 0x75, + 0x32, 0xAC, 0xFE, 0x40, 0x97, 0x7E, 0x4A, 0x88, + 0x0E, 0xAF, 0xF3, 0x39, 0x7B, 0x4C, 0x7D, 0xA6, + 0x91, 0x46, 0x04, 0xE5, 0xE4, 0x37, 0x51, 0x11 + }, + { + 0x61, 0x22, 0x52, 0x52, 0x06, 0xF0, 0x2D, 0xD4, + 0xC0, 0xE4, 0x2F, 0x2F, 0x36, 0x31, 0xF3, 0x81, + 0xD2, 0xD8, 0x99, 0x06, 0xD8, 0x67, 0xBB, 0xED, + 0x78, 0x7A, 0x54, 0xB4, 0x0B, 0xE6, 0xE8, 0x69, + 0xB0, 0x9B, 0x12, 0xC3, 0xFF, 0xE3, 0xC9, 0x95, + 0xA8, 0x85, 0xB5, 0xD2, 0xEB, 0x24, 0x0B, 0x76, + 0x7D, 0xC4, 0x36, 0x8D, 0x8E, 0x1D, 0xEE, 0xE2, + 0x68, 0xD4, 0xB1, 0x4C, 0x9D, 0xCB, 0x09, 0x9E + }, + { + 0xE6, 0xEB, 0xF1, 0x20, 0xBE, 0x2C, 0x7B, 0x1B, + 0x0E, 0x9E, 0x4B, 0xBB, 0x3B, 0x14, 0x9A, 0xCB, + 0xA1, 0x02, 0x0A, 0x50, 0x4F, 0x6D, 0xF5, 0x87, + 0x9D, 0x39, 0x5B, 0xB5, 0x0A, 0x04, 0xC9, 0x6A, + 0xD1, 0xDB, 0x02, 0x8A, 0x8D, 0xB6, 0x42, 0x9E, + 0x1C, 0x61, 0x6B, 0x2F, 0x15, 0x71, 0xB4, 0xE5, + 0x46, 0x01, 0x7B, 0x08, 0x87, 0xCA, 0xFB, 0xF9, + 0xD3, 0x21, 0xF9, 0xB0, 0x3A, 0x10, 0x08, 0x98 + }, + { + 0x0A, 0x82, 0xE3, 0x66, 0x4C, 0x8D, 0x25, 0xC8, + 0x6F, 0x06, 0xB1, 0xE8, 0x12, 0xB7, 0x28, 0xFD, + 0xBB, 0x20, 0xAE, 0x39, 0x0E, 0x7C, 0xA8, 0xBE, + 0xB6, 0x92, 0x87, 0x74, 0x58, 0x7C, 0x49, 0x44, + 0xC4, 0xBE, 0xD9, 0xFC, 0x3B, 0x55, 0xD3, 0xFD, + 0x6C, 0x2C, 0x52, 0xFD, 0x7B, 0x2C, 0xC9, 0xA4, + 0x5D, 0x6A, 0x77, 0x78, 0x1E, 0x38, 0x9C, 0xD4, + 0xF0, 0xF1, 0x76, 0xF5, 0xFF, 0xC4, 0x6E, 0x6F + }, + { + 0x59, 0xF0, 0x28, 0xD3, 0x45, 0x85, 0x77, 0x2D, + 0x9F, 0x24, 0x47, 0xB2, 0xB2, 0x64, 0x63, 0xC2, + 0xCB, 0x79, 0xEC, 0xDC, 0xED, 0x7C, 0x59, 0x42, + 0x50, 0x7D, 0xE6, 0xF5, 0x67, 0xC7, 0xB7, 0x64, + 0xCF, 0xF9, 0xD3, 0xA9, 0x26, 0xA8, 0xA1, 0x10, + 0x4B, 0x60, 0xCF, 0x59, 0xDE, 0x94, 0x66, 0x47, + 0x9F, 0x3A, 0x74, 0x06, 0xED, 0x03, 0x6D, 0xFF, + 0x31, 0x7C, 0x1A, 0x95, 0xDD, 0xD5, 0x16, 0x78 + }, + { + 0x89, 0x45, 0xAA, 0xA9, 0x65, 0x64, 0x3A, 0x8F, + 0x64, 0xD4, 0xB8, 0xF6, 0xAB, 0xAA, 0x11, 0x72, + 0x1A, 0xBA, 0xDC, 0x8A, 0x81, 0x2A, 0xC7, 0x4E, + 0x54, 0xFC, 0xC2, 0x4F, 0x34, 0x2D, 0xCB, 0xBB, + 0xFC, 0x9C, 0x87, 0x40, 0xB4, 0x06, 0xEB, 0xB6, + 0xD1, 0x00, 0x1B, 0xEA, 0x62, 0xD4, 0x00, 0xE7, + 0xE7, 0xD4, 0x88, 0xCF, 0x61, 0x6B, 0x3A, 0xAD, + 0x56, 0x9C, 0xB1, 0xB7, 0x1B, 0xC3, 0xAD, 0x22 + }, + { + 0x74, 0xEE, 0x25, 0xE5, 0x35, 0x20, 0x9F, 0x88, + 0x26, 0x1F, 0xF1, 0x3C, 0x9D, 0x2F, 0x35, 0x9D, + 0x69, 0x9D, 0x43, 0xE4, 0x93, 0x01, 0x65, 0xF7, + 0xB1, 0xE3, 0xDE, 0x9E, 0xAF, 0x45, 0xA5, 0x64, + 0x1E, 0xDD, 0xD1, 0x72, 0xE4, 0xBE, 0x74, 0x5F, + 0xA0, 0x0D, 0xB0, 0xA4, 0xC1, 0x3E, 0x54, 0x7C, + 0xD7, 0xF7, 0x08, 0x28, 0x48, 0x5F, 0xC9, 0xBC, + 0xBF, 0xC2, 0x5D, 0x43, 0x81, 0x0D, 0x13, 0xA8 + }, + { + 0x93, 0x80, 0x4B, 0xEB, 0x6A, 0xB6, 0x9D, 0x68, + 0x85, 0xB7, 0xA3, 0x13, 0x12, 0xD9, 0x4C, 0x2E, + 0xFA, 0xFF, 0xCE, 0xDC, 0x6E, 0x87, 0x6C, 0xAC, + 0xC5, 0x71, 0xB6, 0xCE, 0xC5, 0xA4, 0x81, 0xBF, + 0xA4, 0x37, 0x7C, 0xE6, 0x5F, 0x41, 0x7E, 0x9E, + 0x18, 0x47, 0x8E, 0x62, 0xF2, 0x4E, 0xB8, 0x26, + 0xC6, 0x07, 0x74, 0xB8, 0x37, 0xDE, 0x0F, 0x5B, + 0x9B, 0x27, 0x55, 0x51, 0x1D, 0x6F, 0xEC, 0x83 + }, + { + 0x25, 0x7F, 0x51, 0x1D, 0xA2, 0x1A, 0x33, 0xD8, + 0xCB, 0x23, 0x5A, 0xD0, 0x6A, 0x38, 0x3E, 0xC2, + 0xEA, 0xCA, 0xC8, 0xA9, 0x6C, 0x80, 0xB4, 0x08, + 0x64, 0x73, 0x2A, 0x08, 0x80, 0x32, 0xC1, 0x03, + 0x89, 0xB2, 0xA6, 0xED, 0x9C, 0x13, 0x7E, 0x17, + 0x6E, 0x78, 0xE7, 0xF4, 0x13, 0xAF, 0xD0, 0x31, + 0xDA, 0x34, 0xF8, 0x31, 0x0C, 0xAC, 0xB7, 0x01, + 0xD3, 0xDE, 0xD6, 0x2C, 0xD1, 0x4E, 0xE8, 0xF2 + }, + { + 0xD2, 0x85, 0xDA, 0xCB, 0x1A, 0x80, 0x29, 0x25, + 0xB9, 0x18, 0xCA, 0xA5, 0xB5, 0xAE, 0xF4, 0x0A, + 0x56, 0xC4, 0x28, 0x5F, 0x56, 0xEF, 0x98, 0x61, + 0x24, 0x3B, 0x74, 0x74, 0x22, 0xD0, 0x75, 0x62, + 0x91, 0xAA, 0x8D, 0x73, 0x98, 0xA3, 0xEC, 0x1D, + 0x37, 0xD1, 0x05, 0xFA, 0xB2, 0xEF, 0x87, 0x45, + 0xF6, 0x2F, 0x2A, 0x14, 0xCF, 0xED, 0xDA, 0x7E, + 0xF9, 0xA0, 0x5A, 0xCD, 0x7B, 0xF2, 0xB7, 0x05 + }, + { + 0x57, 0x69, 0x03, 0x83, 0x45, 0x70, 0xF8, 0x73, + 0x30, 0x48, 0x7C, 0x91, 0x71, 0x31, 0x05, 0xA8, + 0x3A, 0xDF, 0x64, 0xC6, 0x95, 0xAD, 0xBF, 0x9F, + 0x2D, 0xAB, 0x45, 0xAB, 0x20, 0xA2, 0x49, 0x7E, + 0x0D, 0x91, 0x30, 0x99, 0x14, 0x79, 0x64, 0x37, + 0x5E, 0xE0, 0x9C, 0xFB, 0xE0, 0x97, 0xD5, 0x15, + 0x1F, 0xEE, 0xB3, 0x4C, 0x4C, 0x15, 0x8B, 0x60, + 0xE4, 0xD3, 0xB4, 0x63, 0x72, 0x11, 0x3C, 0x42 + }, + { + 0x76, 0x6F, 0x65, 0xDC, 0x2B, 0xCF, 0x7F, 0x30, + 0x3E, 0xBA, 0x61, 0x3B, 0xEB, 0x4A, 0x90, 0xE1, + 0xC4, 0x35, 0xC8, 0x45, 0xB8, 0x70, 0x2E, 0xF6, + 0xB8, 0x74, 0xE6, 0xE6, 0xAB, 0x39, 0x16, 0x24, + 0xD7, 0x91, 0x27, 0xF1, 0xEF, 0x64, 0x57, 0x02, + 0x35, 0x45, 0x37, 0xD2, 0x86, 0xD3, 0x0C, 0xCB, + 0xF7, 0x5B, 0x7C, 0xE1, 0x92, 0xE2, 0x72, 0x1A, + 0xDC, 0x3F, 0x19, 0xEB, 0x79, 0x0B, 0xE5, 0x9A + }, + { + 0xB2, 0xB5, 0x77, 0xFD, 0xBB, 0xE8, 0x40, 0x57, + 0xEC, 0x55, 0xC7, 0xA6, 0x21, 0x80, 0x87, 0x04, + 0x60, 0x2A, 0x00, 0x1C, 0x35, 0xBB, 0x82, 0xB1, + 0x9D, 0x79, 0x08, 0xDE, 0x91, 0x10, 0x0B, 0x84, + 0x16, 0x42, 0xE7, 0x0D, 0xDA, 0x9B, 0x95, 0xBD, + 0xB2, 0xC8, 0x86, 0x9F, 0xBA, 0x7C, 0x39, 0xC1, + 0x83, 0x19, 0x54, 0xEB, 0xC5, 0x0B, 0xE6, 0x37, + 0xAF, 0xF0, 0x7B, 0x61, 0xD8, 0x19, 0x3B, 0x4F + }, + { + 0xB8, 0x61, 0xF7, 0xBE, 0x01, 0x69, 0x7B, 0x8E, + 0x0E, 0xEA, 0x4B, 0x9D, 0xFE, 0x5F, 0x0F, 0x0C, + 0xD1, 0xA4, 0x02, 0x29, 0x43, 0xAC, 0x02, 0x06, + 0x26, 0x92, 0xBC, 0xA7, 0xB8, 0x7F, 0x44, 0x6D, + 0xA5, 0x81, 0x9A, 0x5A, 0xCF, 0x9F, 0x0E, 0x92, + 0xDF, 0x29, 0xC0, 0x48, 0xA6, 0x1C, 0xC3, 0x9C, + 0x71, 0x47, 0xE6, 0x84, 0xD7, 0xD6, 0x0A, 0x64, + 0x17, 0x31, 0x18, 0xAD, 0xD3, 0x9B, 0x3A, 0x0E + }, + { + 0x12, 0xBD, 0xFD, 0x23, 0xC0, 0x72, 0xFE, 0xC7, + 0xD3, 0xF0, 0xFC, 0x56, 0x6F, 0xD5, 0x37, 0x9F, + 0x82, 0x64, 0xF0, 0x89, 0xAB, 0x7E, 0xA5, 0x17, + 0xC7, 0x76, 0x4D, 0x12, 0x51, 0x15, 0xF2, 0x64, + 0x6E, 0x61, 0x43, 0xA2, 0x11, 0x55, 0x1F, 0xB1, + 0x5B, 0x22, 0xAC, 0x65, 0xC6, 0x33, 0x1E, 0x70, + 0x29, 0xCF, 0x76, 0x58, 0x14, 0x2E, 0x3B, 0xC3, + 0x4E, 0xAF, 0x84, 0xF6, 0x7D, 0xAD, 0x81, 0x44 + }, + { + 0x1C, 0x3B, 0x23, 0xC6, 0x53, 0x83, 0xF6, 0x5E, + 0x3D, 0x80, 0xCB, 0x49, 0xD7, 0xE9, 0x92, 0x8B, + 0x83, 0xBB, 0x09, 0xDB, 0xF6, 0x6E, 0xCD, 0x05, + 0x01, 0x6B, 0xB9, 0x8C, 0x3F, 0x37, 0xB3, 0xD6, + 0xDC, 0x00, 0xA6, 0x48, 0x8A, 0x3D, 0x0F, 0x39, + 0xA7, 0x7A, 0xCE, 0x25, 0xA4, 0x4B, 0x1B, 0x22, + 0x2F, 0xAC, 0xC1, 0xFE, 0x00, 0x50, 0x05, 0x85, + 0xF9, 0x53, 0x60, 0x73, 0x2E, 0x01, 0x19, 0xA6 + }, + { + 0xA4, 0x06, 0xF6, 0xDF, 0x84, 0x65, 0x18, 0x4B, + 0x38, 0x6D, 0x0D, 0xA7, 0x10, 0x74, 0x1D, 0x40, + 0x2C, 0x59, 0x3C, 0x7A, 0x08, 0xF6, 0xD9, 0x1B, + 0xA3, 0x2C, 0x59, 0xF0, 0x1C, 0xC4, 0x44, 0xC1, + 0x72, 0x24, 0x80, 0x8C, 0x56, 0x5F, 0x0F, 0xDF, + 0x03, 0xD9, 0x05, 0x11, 0xEC, 0xD4, 0xF4, 0x75, + 0x2E, 0xEF, 0x08, 0x15, 0x06, 0x4D, 0x3D, 0xA8, + 0x8E, 0x9F, 0xD1, 0x18, 0x08, 0xA1, 0x55, 0x0B + }, + { + 0x59, 0x02, 0x69, 0x91, 0x27, 0x8E, 0xC6, 0x4E, + 0x5B, 0x40, 0x91, 0x65, 0x03, 0xA4, 0x86, 0xCC, + 0xD0, 0x92, 0x51, 0x97, 0xD1, 0xCE, 0x7F, 0x02, + 0x6F, 0x88, 0x7E, 0x8A, 0xA8, 0x08, 0x42, 0x51, + 0xC1, 0x49, 0x65, 0xA0, 0x53, 0xA5, 0x26, 0x90, + 0x25, 0xB0, 0xCC, 0xE5, 0xB5, 0xFF, 0x4E, 0x91, + 0x19, 0xCF, 0xB1, 0x76, 0x7E, 0x7B, 0x5E, 0x0B, + 0x62, 0x3E, 0x4B, 0xFE, 0x63, 0x16, 0x0B, 0x37 + }, + { + 0xA3, 0x1B, 0xFE, 0x81, 0x4C, 0x34, 0xC3, 0x08, + 0xCA, 0x7E, 0x88, 0x30, 0xF5, 0x09, 0x2A, 0xDD, + 0x80, 0x56, 0x96, 0x9D, 0xF0, 0xEA, 0x02, 0xC3, + 0xC2, 0xA6, 0x41, 0x0B, 0xA5, 0x83, 0xEA, 0x49, + 0x07, 0xC0, 0xC1, 0x7E, 0x19, 0xC8, 0xAC, 0xF6, + 0x15, 0x6E, 0x6F, 0x90, 0xBD, 0x8F, 0xAE, 0x06, + 0xD7, 0xB9, 0x85, 0xDD, 0xA8, 0xBE, 0x56, 0x46, + 0x2D, 0x10, 0xAB, 0x28, 0x8D, 0xDA, 0x99, 0xE3 + }, + { + 0xEA, 0xE5, 0x56, 0x9A, 0xBA, 0x3B, 0x44, 0x8E, + 0xB0, 0x9B, 0x10, 0x2A, 0x5A, 0x88, 0xF2, 0x4D, + 0x18, 0xE8, 0x31, 0x50, 0x43, 0x4B, 0xE0, 0x60, + 0x1F, 0xD3, 0xE4, 0xB7, 0x66, 0x36, 0x20, 0x6F, + 0x93, 0x45, 0x82, 0xD9, 0x5C, 0xC4, 0x09, 0x6C, + 0x55, 0xB0, 0x00, 0xAB, 0x1E, 0xEB, 0x64, 0xE2, + 0xB2, 0x91, 0xE3, 0xB3, 0xDC, 0xB6, 0x12, 0x80, + 0xDB, 0xC2, 0xD5, 0x8A, 0xE0, 0x2F, 0x54, 0xEB + }, + { + 0x69, 0x27, 0x35, 0xAF, 0xBB, 0xC9, 0xE3, 0x47, + 0xBB, 0x72, 0x98, 0xBE, 0x15, 0x73, 0x3D, 0x5F, + 0x21, 0x25, 0x6D, 0x6A, 0x2C, 0xBE, 0x9C, 0xF8, + 0x20, 0xD8, 0xF8, 0x50, 0xA5, 0xDD, 0x74, 0x2A, + 0x5C, 0x44, 0x0B, 0xE9, 0x64, 0x37, 0xEB, 0xB7, + 0xE1, 0xCA, 0x80, 0xCD, 0xCD, 0xDC, 0xA3, 0xD5, + 0xE6, 0x34, 0xCA, 0xDC, 0x9C, 0x58, 0xF1, 0x8D, + 0x0F, 0x0C, 0xC4, 0xF1, 0xEE, 0x80, 0x0A, 0x05 + }, + { + 0x7C, 0x88, 0x03, 0xC6, 0x2A, 0xF3, 0x42, 0x1C, + 0xE5, 0xCB, 0xA5, 0xF0, 0xAC, 0xF1, 0x99, 0xD1, + 0x0B, 0xE6, 0xF2, 0x12, 0x55, 0xA7, 0xC0, 0x37, + 0x0D, 0x68, 0xB1, 0xE1, 0xD2, 0x9B, 0x73, 0xD5, + 0x62, 0xDB, 0xE5, 0x71, 0x76, 0xCF, 0x5C, 0xB0, + 0x0A, 0x39, 0x02, 0x46, 0x64, 0x25, 0x2D, 0xC1, + 0xBE, 0xB6, 0xF5, 0x0F, 0x73, 0x81, 0xAE, 0x74, + 0x3F, 0x3B, 0x24, 0x62, 0xD7, 0x88, 0x9A, 0x56 + }, + { + 0x7A, 0x72, 0x4D, 0x05, 0xBA, 0x7D, 0x2E, 0x79, + 0x72, 0x9D, 0xEC, 0xBC, 0x16, 0xB4, 0xAA, 0x11, + 0x1B, 0xD6, 0xE1, 0x40, 0x9E, 0x32, 0xF3, 0x90, + 0x79, 0xD7, 0xA6, 0xE2, 0x2B, 0x28, 0x83, 0x94, + 0x53, 0x73, 0x1D, 0xE6, 0xF6, 0x3C, 0xFE, 0x52, + 0x49, 0x12, 0x73, 0xC0, 0x18, 0x84, 0x5D, 0x23, + 0xE3, 0x05, 0xF5, 0xE0, 0x77, 0x2E, 0xE2, 0xEA, + 0x36, 0xDE, 0x53, 0x8B, 0x39, 0x24, 0x62, 0x19 + }, + { + 0xF3, 0x06, 0xAC, 0xDD, 0x6D, 0xF4, 0xF4, 0x25, + 0x01, 0x30, 0x9A, 0xAF, 0x58, 0x6B, 0x45, 0x97, + 0x3E, 0x59, 0x0B, 0x8E, 0x38, 0x59, 0x7D, 0x9D, + 0x18, 0xED, 0x47, 0x7C, 0xEF, 0xFF, 0xC1, 0xE7, + 0x04, 0xC2, 0x0C, 0xDB, 0xC5, 0x15, 0x18, 0xB6, + 0x9E, 0x08, 0x37, 0x2C, 0xF4, 0x56, 0x6E, 0xC0, + 0xDE, 0x95, 0x2F, 0x38, 0xDF, 0xBD, 0xC3, 0xF3, + 0x7C, 0x16, 0xD3, 0x98, 0x11, 0xE8, 0xA5, 0x7B + }, + { + 0x5A, 0x4C, 0xF7, 0x59, 0x06, 0x27, 0x4C, 0xEC, + 0x70, 0x73, 0xA0, 0xC7, 0xB5, 0xB1, 0xEB, 0x19, + 0x1D, 0x27, 0x6F, 0x9E, 0x38, 0xE8, 0x69, 0x65, + 0x53, 0x3A, 0x67, 0x0C, 0x0B, 0xF1, 0xE5, 0xA1, + 0xF1, 0x4B, 0xBA, 0x99, 0x3F, 0x77, 0xD8, 0x35, + 0xD5, 0x3E, 0xD7, 0x41, 0xEE, 0xFF, 0xA1, 0x79, + 0x20, 0x13, 0x03, 0x6C, 0x67, 0xB1, 0xF4, 0x9C, + 0xB7, 0xF7, 0x6B, 0x8D, 0xE2, 0xBA, 0xC8, 0xA7 + }, + { + 0xF1, 0xEA, 0x17, 0x0D, 0x35, 0xA5, 0xB9, 0x4D, + 0x9C, 0x49, 0xD9, 0xA0, 0xE9, 0xDB, 0x49, 0x25, + 0xE1, 0x5B, 0xC2, 0xA1, 0x3B, 0x05, 0xDB, 0x6B, + 0x5C, 0x3C, 0x05, 0xDE, 0x31, 0x8E, 0xEC, 0x02, + 0x3D, 0x0E, 0x75, 0x46, 0x27, 0xEA, 0x10, 0xB2, + 0x84, 0x3B, 0x86, 0xF2, 0x4F, 0xEA, 0x02, 0x67, + 0x17, 0x46, 0xD8, 0x8E, 0x89, 0xB5, 0x83, 0xAB, + 0x4E, 0x92, 0x2D, 0xE0, 0x46, 0x96, 0x7D, 0x42 + }, + { + 0x33, 0x88, 0x2C, 0x39, 0x21, 0x5A, 0xA5, 0xBB, + 0x99, 0x0A, 0x0D, 0x12, 0xDC, 0xFB, 0xEC, 0x68, + 0xD1, 0x28, 0x55, 0x3F, 0xB1, 0xA4, 0x0B, 0x47, + 0xE8, 0x64, 0x5D, 0x1C, 0x11, 0xAE, 0x65, 0x7B, + 0x63, 0xFB, 0xC1, 0xFF, 0x70, 0x25, 0xB3, 0x1A, + 0x1A, 0xFB, 0xEC, 0x80, 0x96, 0x3E, 0x14, 0x7C, + 0xFC, 0x1F, 0xD9, 0x6A, 0x65, 0x56, 0xED, 0xD4, + 0xAD, 0x89, 0xA9, 0xF5, 0x3B, 0xFA, 0xDB, 0x5E + }, + { + 0xF4, 0x52, 0xCE, 0x63, 0xF2, 0xBA, 0xC3, 0x2B, + 0x99, 0xB7, 0x9D, 0xB4, 0x0F, 0xA5, 0x56, 0xBD, + 0x30, 0x36, 0x78, 0x5A, 0x02, 0xE6, 0xD2, 0x18, + 0xA2, 0xD5, 0x49, 0x16, 0x2D, 0x03, 0x85, 0x62, + 0x36, 0x5B, 0x33, 0x61, 0xF5, 0x5D, 0xBE, 0xDE, + 0x51, 0x60, 0xE4, 0xF1, 0xAB, 0x8D, 0x1B, 0xA0, + 0xAF, 0x0C, 0xA0, 0xFF, 0x3C, 0xCD, 0xE9, 0xB8, + 0xC1, 0x53, 0x20, 0x68, 0x7C, 0x07, 0x2C, 0xAC + }, + { + 0xE3, 0x12, 0xBA, 0x59, 0x5C, 0x44, 0xB3, 0x1D, + 0x8D, 0xE0, 0xFE, 0x00, 0xB0, 0x10, 0x24, 0x09, + 0x6E, 0x0E, 0x59, 0x39, 0xB4, 0x60, 0x32, 0x30, + 0x86, 0x3D, 0x69, 0x51, 0xF1, 0x87, 0x12, 0xC3, + 0xF1, 0x89, 0x01, 0x95, 0x16, 0x68, 0xC8, 0xC2, + 0xC5, 0x45, 0x4C, 0xD5, 0xE9, 0xB2, 0xAA, 0x04, + 0x26, 0x63, 0x3E, 0x2E, 0x88, 0x19, 0x82, 0x6D, + 0x4F, 0x71, 0x51, 0x38, 0x2A, 0x4C, 0x63, 0x41 + }, + { + 0xFE, 0xF4, 0x3B, 0x62, 0xCC, 0x2D, 0x0D, 0x0A, + 0xAD, 0xAE, 0x7F, 0x88, 0x18, 0xA1, 0x9E, 0x2E, + 0x38, 0xFF, 0x77, 0x6D, 0xC4, 0xC5, 0x2A, 0x9B, + 0xC0, 0x3F, 0xF2, 0x97, 0xEB, 0xFA, 0x8F, 0x8A, + 0x48, 0x05, 0x1C, 0xD0, 0xCE, 0x91, 0xD0, 0x62, + 0x0B, 0x40, 0x1A, 0x0C, 0x48, 0xCC, 0x07, 0x58, + 0xBB, 0x39, 0xB9, 0x4F, 0x9A, 0x78, 0x3A, 0x63, + 0x59, 0x58, 0x5A, 0x4C, 0x35, 0xFA, 0xAF, 0xEC + }, + { + 0x4E, 0x4D, 0x5F, 0x85, 0x6D, 0xF7, 0xF5, 0xDD, + 0x16, 0x8C, 0x02, 0xD0, 0x7C, 0x0E, 0x6A, 0x86, + 0x7E, 0xBB, 0x23, 0x3F, 0x0F, 0xD5, 0x0B, 0x54, + 0x6B, 0x4C, 0x82, 0x16, 0xDB, 0x7D, 0x4E, 0x7B, + 0x90, 0x1C, 0xBF, 0xDB, 0x8F, 0xE4, 0x22, 0xFE, + 0x85, 0x83, 0x3B, 0x0B, 0xC0, 0x13, 0xC1, 0x08, + 0x19, 0x93, 0x39, 0xA8, 0x38, 0x0B, 0x6F, 0x34, + 0x83, 0xCA, 0x25, 0x2D, 0x7A, 0x00, 0x0F, 0x13 + }, + { + 0x34, 0x01, 0x09, 0x72, 0xF8, 0x18, 0xA6, 0xCF, + 0x7C, 0x04, 0xB1, 0x57, 0xF8, 0xE5, 0x9B, 0x4B, + 0x31, 0xEC, 0xE8, 0x63, 0xAA, 0x34, 0x20, 0xF1, + 0x74, 0x98, 0xA7, 0x05, 0x92, 0x30, 0xC9, 0xB2, + 0x6D, 0xE7, 0xBA, 0x2B, 0x1A, 0xE5, 0xDF, 0x83, + 0x11, 0xF1, 0xF5, 0xCB, 0xAD, 0x41, 0x60, 0x73, + 0x19, 0xE9, 0x7F, 0xC6, 0xA6, 0xDC, 0xAA, 0xF0, + 0x7A, 0x8B, 0x9C, 0x23, 0xA9, 0x4B, 0xDC, 0xD7 + }, + { + 0xE8, 0xF8, 0xE1, 0xAB, 0x0C, 0xB6, 0x54, 0xD8, + 0xDE, 0x24, 0x29, 0x28, 0xE2, 0xB3, 0x4C, 0x18, + 0x7E, 0x09, 0xA3, 0xFF, 0xE1, 0x20, 0x08, 0xF4, + 0xFA, 0x04, 0xDF, 0x3E, 0x6B, 0x08, 0x4D, 0xEA, + 0x1F, 0xF1, 0x91, 0xE9, 0x01, 0x29, 0x34, 0x64, + 0xCD, 0x59, 0x25, 0xD1, 0xB2, 0x1E, 0x55, 0xDD, + 0xD3, 0xDD, 0xF5, 0xCE, 0x69, 0x06, 0x29, 0x0D, + 0x5F, 0x69, 0x65, 0xAB, 0x27, 0x56, 0xDD, 0x72 + }, + { + 0xEB, 0x9D, 0x39, 0xE5, 0xF1, 0xB1, 0x05, 0xD3, + 0x81, 0x66, 0x67, 0x4E, 0xC6, 0x96, 0xCA, 0x6B, + 0x27, 0xE9, 0xAF, 0xAF, 0xAA, 0xEA, 0x95, 0x76, + 0xC1, 0xE2, 0xFF, 0xCE, 0x9B, 0xA3, 0xC5, 0x85, + 0x4C, 0x64, 0xF0, 0x81, 0x09, 0x67, 0x19, 0x90, + 0x23, 0x93, 0x80, 0xCD, 0x7A, 0x8E, 0xEF, 0x4B, + 0x02, 0x59, 0x0A, 0x6A, 0x44, 0xAC, 0x66, 0x6A, + 0xF7, 0xFF, 0x77, 0xEE, 0x11, 0x26, 0x57, 0xD2 + }, + { + 0xE4, 0xFC, 0x6E, 0xD6, 0xF0, 0x35, 0x3F, 0x78, + 0x06, 0x2B, 0xEC, 0x0E, 0x72, 0x7E, 0x13, 0x90, + 0xB1, 0xCE, 0x9F, 0x03, 0x62, 0xA2, 0xD7, 0xF1, + 0xD9, 0x5A, 0xAA, 0xA8, 0xFA, 0xF5, 0x9E, 0x06, + 0xDA, 0xA5, 0xE2, 0x30, 0x5D, 0x5E, 0xB7, 0xC6, + 0xC9, 0xEA, 0x81, 0x55, 0x3E, 0xEF, 0x4E, 0x04, + 0x5C, 0xAF, 0xE6, 0x29, 0xC5, 0xC6, 0xE8, 0x47, + 0x59, 0x7E, 0xEF, 0x57, 0xB8, 0x17, 0x73, 0x93 + }, + { + 0x53, 0xF0, 0x66, 0xA2, 0x69, 0xA7, 0x53, 0x00, + 0x82, 0x21, 0x58, 0x40, 0xA3, 0xFA, 0xF4, 0x5D, + 0x70, 0x39, 0xCF, 0xEA, 0x29, 0x22, 0xF5, 0x8A, + 0xE3, 0x8D, 0x62, 0x18, 0xFF, 0x5A, 0x5E, 0xCE, + 0xDE, 0x5B, 0x7D, 0xFB, 0x53, 0x15, 0xF1, 0x98, + 0x20, 0x32, 0x01, 0x6B, 0x07, 0xB9, 0x06, 0x81, + 0x12, 0x0C, 0x42, 0xDD, 0x98, 0x98, 0x03, 0x6A, + 0x35, 0xE0, 0x71, 0x6F, 0xD8, 0x0C, 0x14, 0x38 + }, + { + 0xEB, 0xAA, 0x28, 0x13, 0x07, 0x2C, 0x51, 0x6A, + 0x5B, 0xF1, 0x7B, 0x9D, 0x98, 0x11, 0xB3, 0xD2, + 0x32, 0xA1, 0x97, 0x00, 0xEB, 0xB4, 0x16, 0xC7, + 0xDC, 0xF3, 0x45, 0x24, 0xDB, 0xEB, 0xC9, 0x67, + 0x35, 0x74, 0x62, 0x60, 0xFA, 0x5A, 0xC8, 0x1F, + 0xFE, 0x35, 0x39, 0x1C, 0x44, 0x76, 0x70, 0x5D, + 0x0D, 0x4E, 0xC3, 0x45, 0xB2, 0x8C, 0xC6, 0x3A, + 0xBC, 0xF1, 0xB3, 0x18, 0x99, 0x6F, 0x45, 0x4C + }, + { + 0xB1, 0x3D, 0x5D, 0x0B, 0xC8, 0xA8, 0x6D, 0xDE, + 0x8F, 0x36, 0xD0, 0x97, 0x26, 0x89, 0x3C, 0x3A, + 0x78, 0x19, 0x61, 0x3A, 0x72, 0xB2, 0x8C, 0xFA, + 0x98, 0x54, 0x57, 0x67, 0xE2, 0x2F, 0x5B, 0x4D, + 0x3C, 0xC6, 0xA7, 0x75, 0x7E, 0xC4, 0xFC, 0xCF, + 0xB4, 0x42, 0x41, 0xDF, 0xE8, 0xE3, 0x91, 0xA1, + 0xFC, 0x83, 0x96, 0x4A, 0x5E, 0x10, 0xAD, 0x3F, + 0x4B, 0x18, 0x2C, 0x4B, 0x05, 0x9F, 0xBC, 0xFA + }, + { + 0xCA, 0x2D, 0x12, 0xFC, 0x11, 0x78, 0xF0, 0xEF, + 0xC8, 0xDF, 0x8B, 0xC5, 0x14, 0x06, 0x3B, 0x9D, + 0x2A, 0x1B, 0x20, 0x1E, 0xA8, 0x6B, 0x88, 0x25, + 0xE1, 0x62, 0x44, 0x70, 0x88, 0xEF, 0xC0, 0x16, + 0xAA, 0x4D, 0xF8, 0xF8, 0x78, 0x26, 0x3D, 0x2C, + 0xB8, 0x82, 0x95, 0x6B, 0x3B, 0x9F, 0x1F, 0x39, + 0xE2, 0xDC, 0x55, 0x6D, 0x80, 0x4C, 0xB3, 0x9F, + 0x3F, 0x34, 0xD1, 0x90, 0x4D, 0xC9, 0x04, 0xB8 + }, + { + 0x94, 0xE4, 0x83, 0x6C, 0x56, 0x86, 0x37, 0x24, + 0xD7, 0x39, 0xA8, 0xFE, 0x84, 0x5D, 0xF5, 0xB0, + 0x7F, 0xFC, 0x6B, 0x8A, 0xE3, 0x10, 0x67, 0xF1, + 0xE3, 0xB2, 0x89, 0x64, 0x43, 0x2E, 0xC1, 0x9B, + 0x53, 0xD3, 0x2A, 0xE0, 0x94, 0x84, 0xD7, 0x96, + 0xF9, 0xB1, 0x4F, 0xE1, 0xAC, 0x3C, 0x1A, 0x12, + 0x79, 0x5F, 0x26, 0xC4, 0x0D, 0xDB, 0xF0, 0x9D, + 0x3B, 0x7E, 0x3D, 0xF9, 0xD1, 0x21, 0x45, 0xBC + }, + { + 0x66, 0x1E, 0xBE, 0xD0, 0xC9, 0x1D, 0xFE, 0x37, + 0x8A, 0xD3, 0x4A, 0x26, 0xAC, 0x62, 0x31, 0x59, + 0x6B, 0x14, 0x8F, 0x9E, 0x29, 0x77, 0x65, 0xFD, + 0x00, 0xED, 0xE2, 0x89, 0x2D, 0x4B, 0xBF, 0x0C, + 0x86, 0x70, 0xCB, 0xA8, 0xF5, 0x24, 0x23, 0x5E, + 0x6E, 0x72, 0xE6, 0x25, 0x91, 0x5E, 0x76, 0xC7, + 0x53, 0x3F, 0x3E, 0x0A, 0x89, 0x6D, 0x2F, 0xCE, + 0xA8, 0xDF, 0xA0, 0x8C, 0xDE, 0x70, 0x49, 0x5A + }, + { + 0x0E, 0xE2, 0x0C, 0xDD, 0xD3, 0x27, 0xB8, 0x41, + 0x10, 0xE0, 0x50, 0x7D, 0x2B, 0x4C, 0xDA, 0x9E, + 0xEB, 0x61, 0x00, 0xEC, 0xFD, 0xE3, 0xCC, 0xF8, + 0xAC, 0xED, 0xF1, 0x2A, 0x13, 0xBA, 0x3B, 0x88, + 0x14, 0x60, 0x32, 0x53, 0xC5, 0x12, 0x03, 0x81, + 0x70, 0x08, 0x76, 0x58, 0xC8, 0x35, 0x3B, 0xF3, + 0xC8, 0x18, 0x04, 0x20, 0x37, 0x02, 0x3A, 0x5C, + 0xD2, 0x2F, 0xA0, 0x53, 0x4B, 0x6D, 0x06, 0xA3 + }, + { + 0x57, 0x0F, 0xB9, 0x56, 0xBF, 0xE6, 0x2B, 0xB7, + 0x49, 0x59, 0x52, 0x4E, 0x1A, 0x96, 0x1B, 0xCA, + 0xE7, 0x82, 0xD7, 0x5F, 0x02, 0xA3, 0x1E, 0x44, + 0xFE, 0xD1, 0x65, 0xB2, 0x39, 0xDA, 0x31, 0xD6, + 0x8A, 0x32, 0x5E, 0x8D, 0x0F, 0xBE, 0xA4, 0x40, + 0xCA, 0x62, 0x6C, 0x0E, 0x8D, 0x36, 0x5E, 0xB7, + 0xFE, 0xFC, 0x40, 0xC1, 0x5D, 0x02, 0x57, 0xA8, + 0x00, 0xF5, 0x24, 0xCF, 0xE2, 0x01, 0xBB, 0x32 + }, + { + 0x35, 0x68, 0x95, 0xE5, 0x46, 0xDF, 0x6C, 0x42, + 0x44, 0xAC, 0x79, 0xA7, 0x8E, 0xB6, 0xFC, 0xEB, + 0xBF, 0xCC, 0xD5, 0xDC, 0xF2, 0xA6, 0xA8, 0x4C, + 0xBE, 0x87, 0x1B, 0xCD, 0x77, 0xC2, 0xA5, 0xB4, + 0xE7, 0x1B, 0x2B, 0x19, 0x56, 0xF2, 0x01, 0xBB, + 0x7A, 0x55, 0x43, 0x99, 0xFF, 0x91, 0xCE, 0xAB, + 0x5F, 0x1B, 0xFA, 0x22, 0x1E, 0x03, 0x31, 0xCC, + 0x4E, 0xB9, 0x6A, 0x7D, 0x75, 0x44, 0xB5, 0xFE + }, + { + 0x84, 0xC2, 0xE7, 0x0E, 0x73, 0x1E, 0x6D, 0x49, + 0x81, 0xE6, 0x76, 0x62, 0xC4, 0xF9, 0xB4, 0xE6, + 0x13, 0x44, 0x69, 0xB5, 0xDE, 0x7D, 0x3A, 0x0D, + 0xD7, 0x24, 0xB8, 0x40, 0xB7, 0x95, 0x8E, 0x23, + 0x1D, 0x5E, 0x86, 0xFD, 0x4C, 0x36, 0x2C, 0xDE, + 0x7B, 0xE7, 0xBD, 0x14, 0x6A, 0x9F, 0xAE, 0x64, + 0xBD, 0x02, 0x5B, 0x45, 0xD3, 0x50, 0x6B, 0x08, + 0x8B, 0x38, 0x81, 0xC2, 0xCB, 0x42, 0x80, 0x68 + }, + { + 0xA4, 0xFD, 0xCC, 0x4F, 0x9C, 0x61, 0x1A, 0xBA, + 0x18, 0x4F, 0x3A, 0x51, 0x95, 0x56, 0xD3, 0x40, + 0x99, 0x3D, 0xC6, 0x16, 0x76, 0xDC, 0xA5, 0xDB, + 0xAE, 0x66, 0x53, 0x2E, 0x0F, 0xA2, 0x23, 0x52, + 0xCE, 0x95, 0xAC, 0x81, 0xE1, 0x63, 0xE7, 0x93, + 0x6C, 0xD8, 0xBD, 0x09, 0xCF, 0xFF, 0x05, 0x84, + 0xF1, 0x32, 0x1B, 0x26, 0x25, 0x99, 0xFA, 0x28, + 0xEA, 0xBF, 0x86, 0xEF, 0x12, 0xBE, 0x0E, 0x27 + }, + { + 0x14, 0x4B, 0xC3, 0xA0, 0x52, 0x5A, 0xC5, 0x7F, + 0x7F, 0x1A, 0xB5, 0x19, 0x05, 0x30, 0x39, 0xC8, + 0x0C, 0xAA, 0xE8, 0x04, 0x92, 0xC5, 0xC4, 0x3C, + 0x4E, 0x42, 0xED, 0xBE, 0xBA, 0x8D, 0x91, 0xDF, + 0x26, 0x16, 0xF2, 0x0E, 0xFE, 0x27, 0x4E, 0xB4, + 0x25, 0x38, 0x1D, 0x01, 0xE4, 0x87, 0x49, 0x24, + 0x7D, 0xF0, 0xB6, 0x6A, 0xF6, 0x58, 0xB2, 0xE1, + 0x40, 0x8F, 0x85, 0x96, 0x51, 0x03, 0x57, 0xDB + }, + { + 0xF3, 0x8C, 0x94, 0xF5, 0xA9, 0x65, 0x1F, 0x33, + 0x16, 0x46, 0x5B, 0x7D, 0x07, 0x38, 0x70, 0x4E, + 0xD6, 0xE1, 0x04, 0xD2, 0x9C, 0x4C, 0x01, 0xE5, + 0x5E, 0xD8, 0x64, 0x89, 0x92, 0x07, 0x1C, 0xB4, + 0xCB, 0xF2, 0x05, 0xBD, 0x60, 0x87, 0xB8, 0x05, + 0x0B, 0xBC, 0x20, 0xEB, 0x8E, 0xB4, 0xD7, 0x55, + 0x0F, 0x46, 0x22, 0x7E, 0x2F, 0x5F, 0x35, 0x5D, + 0x10, 0xB4, 0xB9, 0x81, 0x93, 0xD0, 0x12, 0xBF + }, + { + 0xB5, 0x2F, 0x7C, 0xB5, 0x42, 0xF9, 0x92, 0xDB, + 0x6B, 0x43, 0x08, 0x26, 0xCF, 0x11, 0x4E, 0xE1, + 0xEB, 0xAA, 0x3F, 0xF1, 0xE2, 0x6D, 0xB6, 0x34, + 0x97, 0x9B, 0x58, 0x02, 0x2A, 0x71, 0xB6, 0x8A, + 0x6C, 0x22, 0x0C, 0x52, 0x0B, 0xF6, 0x4D, 0x0A, + 0x7F, 0xCD, 0x11, 0x81, 0x6E, 0xD7, 0x67, 0xD9, + 0xF9, 0x1F, 0x84, 0x68, 0x2C, 0xBE, 0x14, 0x5F, + 0x62, 0x0D, 0xC8, 0xBB, 0xEF, 0xF3, 0xD3, 0xA6 + }, + { + 0x6E, 0x57, 0xD4, 0x83, 0x73, 0x41, 0x82, 0x99, + 0x35, 0x4F, 0xF3, 0xF9, 0xAA, 0x71, 0x61, 0x08, + 0xE7, 0xBF, 0x2F, 0x31, 0x2E, 0xF8, 0x6A, 0x43, + 0x7A, 0x87, 0x41, 0x06, 0x0B, 0xC3, 0xB0, 0xA6, + 0x5C, 0xDF, 0x61, 0xC8, 0x75, 0xD0, 0x6D, 0x48, + 0xE6, 0x37, 0x7E, 0x2A, 0x07, 0xD1, 0x52, 0x72, + 0x8F, 0x78, 0x5F, 0x9A, 0x2E, 0xCD, 0x98, 0xF8, + 0x13, 0x3E, 0x4F, 0x69, 0x49, 0x03, 0x8B, 0x1B + }, + { + 0x73, 0x8C, 0xB9, 0xAB, 0x52, 0x54, 0x44, 0x5C, + 0xD0, 0x47, 0xCE, 0x6C, 0xAD, 0x23, 0x98, 0xA1, + 0xCE, 0x8A, 0x27, 0x88, 0x28, 0x07, 0x42, 0x20, + 0xD0, 0xC8, 0x3E, 0xBF, 0x74, 0xA3, 0xBB, 0xF6, + 0xCC, 0xF7, 0x2D, 0xAA, 0x86, 0xDD, 0xAD, 0x7F, + 0x88, 0x27, 0x98, 0xCF, 0x25, 0x1B, 0xE9, 0x65, + 0x4C, 0x8D, 0x77, 0x06, 0xDE, 0x8A, 0x3E, 0x5A, + 0xA3, 0x1F, 0x78, 0x8F, 0xC5, 0x32, 0xA5, 0x93 + }, + { + 0x0C, 0xB9, 0x68, 0x17, 0x1D, 0x8F, 0xBF, 0xC8, + 0x37, 0x4B, 0x0D, 0x92, 0x22, 0x46, 0x73, 0x15, + 0x8D, 0x46, 0xD0, 0x96, 0x3A, 0x97, 0xB8, 0xD0, + 0x4D, 0x2B, 0x32, 0x97, 0xD1, 0x5F, 0xED, 0xB2, + 0xF3, 0xBD, 0x76, 0xC5, 0xFE, 0x0C, 0x97, 0x89, + 0xC8, 0xD2, 0x57, 0x2D, 0x64, 0xD8, 0x64, 0xC0, + 0x3D, 0x81, 0x3A, 0xCC, 0xFD, 0x5C, 0x0B, 0x70, + 0xAF, 0x17, 0xCF, 0x5A, 0x9B, 0xAE, 0x84, 0x87 + }, + { + 0xAB, 0xEA, 0xE8, 0xB1, 0xB6, 0xFF, 0x22, 0x47, + 0xB5, 0x4D, 0xB4, 0x69, 0x4E, 0x2A, 0x9F, 0x30, + 0xAA, 0x35, 0xFE, 0x3D, 0x9B, 0x68, 0x61, 0x24, + 0xCA, 0xBC, 0x79, 0x10, 0x6C, 0x3B, 0x05, 0x0A, + 0xAB, 0xC9, 0xDD, 0x9E, 0xB8, 0x8D, 0xB1, 0x82, + 0x7F, 0x0D, 0xDA, 0xC5, 0x5F, 0x9D, 0x33, 0x15, + 0xE5, 0x3C, 0x54, 0x33, 0xED, 0xC0, 0x9F, 0x53, + 0xE9, 0xE2, 0xEB, 0x2B, 0xEC, 0xF1, 0x13, 0x71 + }, + { + 0xF8, 0x69, 0x01, 0x84, 0x40, 0xF0, 0x07, 0xAF, + 0xE3, 0x7D, 0x3C, 0x2A, 0xD0, 0xFB, 0x20, 0x47, + 0x29, 0x15, 0x45, 0x42, 0x56, 0x9A, 0x48, 0xE0, + 0x14, 0x54, 0x2F, 0x66, 0x21, 0xDE, 0x31, 0x77, + 0x2A, 0x01, 0x78, 0x0A, 0x51, 0x3C, 0x28, 0x97, + 0xA1, 0xBA, 0xCB, 0x9D, 0x75, 0x7F, 0x27, 0xA7, + 0xB7, 0x44, 0xE8, 0x3D, 0x0F, 0xFC, 0x34, 0xFE, + 0x74, 0xAE, 0x73, 0xDA, 0x7C, 0x5D, 0x75, 0x69 + }, + { + 0xBE, 0x59, 0x05, 0x72, 0x18, 0xAC, 0xEF, 0x8B, + 0x77, 0x79, 0x1D, 0xFA, 0xC3, 0x71, 0x6E, 0x14, + 0xDE, 0x39, 0xFD, 0x3F, 0xC9, 0xE3, 0xA3, 0xE3, + 0xD8, 0x6A, 0x3C, 0x8F, 0x6F, 0x60, 0xC5, 0x90, + 0x96, 0x67, 0x6E, 0x58, 0x36, 0x04, 0xDB, 0x45, + 0x35, 0x6A, 0x4C, 0x67, 0x47, 0xEC, 0x56, 0x5C, + 0xCF, 0x99, 0xAB, 0x83, 0xE9, 0xE1, 0xC6, 0x10, + 0xFB, 0xA4, 0xC4, 0x96, 0x05, 0xC7, 0x8F, 0x72 + }, + { + 0xE6, 0x62, 0x75, 0x7D, 0xB6, 0x9F, 0xE7, 0xB6, + 0xF6, 0x1B, 0x82, 0x3F, 0x38, 0xA7, 0x5A, 0xE2, + 0xB9, 0x3A, 0x18, 0xE2, 0x7A, 0xEF, 0x6D, 0xCE, + 0x99, 0x39, 0x8F, 0xF3, 0x55, 0x8B, 0x98, 0x19, + 0xC7, 0x29, 0xA5, 0x89, 0xDA, 0xDB, 0xA3, 0xF4, + 0xB2, 0x4B, 0x03, 0x74, 0x6E, 0xF7, 0xC8, 0x8C, + 0x17, 0xE0, 0x89, 0x78, 0xE7, 0xFC, 0xC8, 0xF2, + 0xAC, 0x39, 0xEB, 0xA4, 0xEE, 0x5F, 0xE8, 0xEE + }, + { + 0xC2, 0xC6, 0xC8, 0x45, 0xCC, 0xEC, 0x0A, 0xC8, + 0x60, 0x07, 0x71, 0xF6, 0xFB, 0xF7, 0x41, 0xFC, + 0xE7, 0xDE, 0x8E, 0xC6, 0x4E, 0x60, 0x3E, 0x41, + 0xB1, 0x95, 0x4D, 0x59, 0xE4, 0x92, 0x17, 0xFB, + 0x65, 0x40, 0x2F, 0x44, 0x15, 0x9B, 0x3C, 0x4A, + 0x54, 0x2D, 0x2D, 0x66, 0xE0, 0xFA, 0x71, 0x84, + 0x32, 0x2F, 0xA4, 0xDC, 0xA5, 0x5A, 0x6B, 0x5C, + 0x74, 0x62, 0x7E, 0xA4, 0xA7, 0x36, 0x03, 0x68 + }, + { + 0x6D, 0xBA, 0x40, 0xDD, 0x2B, 0x73, 0x3A, 0x9D, + 0xBB, 0x8C, 0x85, 0x60, 0xC5, 0x44, 0xAE, 0x0D, + 0xB2, 0xCD, 0xC0, 0x9A, 0x0D, 0xC7, 0x5F, 0xF9, + 0xB4, 0x2D, 0xED, 0xBB, 0xEB, 0x55, 0x1A, 0x24, + 0x03, 0x43, 0xC4, 0xDB, 0x45, 0x2E, 0xE3, 0xF8, + 0x42, 0xE9, 0xBF, 0xB1, 0xD6, 0x63, 0x29, 0xEA, + 0xB1, 0xAF, 0x65, 0x9F, 0x0A, 0x8D, 0x3A, 0x9E, + 0x75, 0xC0, 0xA1, 0x8E, 0xD2, 0x91, 0xAB, 0x25 + }, + { + 0x95, 0x09, 0xF4, 0x6D, 0x3F, 0x72, 0xBE, 0x67, + 0xA7, 0xFE, 0x51, 0x87, 0x61, 0x53, 0x3C, 0x4B, + 0x86, 0xD7, 0xBA, 0xBC, 0xED, 0xA3, 0x2E, 0xE5, + 0x29, 0x75, 0x10, 0xB8, 0x91, 0x9D, 0x81, 0x2E, + 0x5C, 0x69, 0x42, 0x2B, 0x3C, 0x11, 0x18, 0xF2, + 0xC5, 0x15, 0xD1, 0x49, 0x3E, 0x50, 0x08, 0x48, + 0xA1, 0xBB, 0xC1, 0xB5, 0x6B, 0x62, 0x3B, 0x19, + 0x20, 0xE4, 0x0B, 0x4A, 0xDC, 0xFE, 0xD1, 0x10 + }, + { + 0xDE, 0x75, 0x12, 0xA5, 0x2D, 0xE0, 0x55, 0x0F, + 0xC2, 0x4F, 0x5F, 0x1B, 0xF9, 0x4B, 0x49, 0x61, + 0xF1, 0x86, 0x1D, 0xB5, 0xE5, 0xFC, 0x52, 0x74, + 0x45, 0x64, 0x7B, 0x8C, 0xD3, 0xF2, 0xC6, 0xAD, + 0x8E, 0x20, 0xDE, 0x0F, 0x77, 0x4B, 0x83, 0x89, + 0x25, 0xAC, 0x8E, 0x4C, 0x84, 0x66, 0x68, 0x06, + 0x5F, 0xC4, 0x5A, 0xA7, 0x78, 0x32, 0xE0, 0xC6, + 0xB8, 0x5B, 0x4C, 0x4E, 0x19, 0x01, 0xAC, 0x8A + }, + { + 0xDE, 0xBD, 0x8B, 0xCE, 0xD7, 0xA0, 0x4F, 0xD6, + 0x76, 0x5A, 0xB5, 0x41, 0x76, 0x8C, 0x83, 0x98, + 0x0E, 0x4E, 0xAC, 0x28, 0xB1, 0x4E, 0x83, 0x3A, + 0xAE, 0x11, 0xAD, 0x6B, 0xFF, 0x30, 0xEE, 0x78, + 0xB7, 0xFB, 0xA8, 0x0B, 0x55, 0x94, 0xBB, 0x44, + 0x41, 0x3C, 0xF9, 0xE5, 0x21, 0x95, 0xE6, 0x22, + 0x3B, 0xC6, 0x64, 0x70, 0x70, 0xA4, 0xFF, 0xCD, + 0x65, 0xAA, 0x77, 0xC8, 0x3A, 0xB3, 0x6F, 0xAF + }, + { + 0x08, 0x2E, 0x4D, 0xBE, 0x58, 0x0F, 0x90, 0x5B, + 0xAE, 0x7D, 0x08, 0xBD, 0xA2, 0x15, 0x33, 0xF4, + 0x20, 0x4F, 0xC5, 0xF1, 0x86, 0xAF, 0xD6, 0x8A, + 0x98, 0x6B, 0x19, 0x07, 0xC5, 0xE9, 0x3B, 0xA2, + 0x42, 0x21, 0x7D, 0x50, 0xDD, 0x11, 0xCB, 0x31, + 0xA0, 0x65, 0x39, 0xF1, 0x0F, 0x9E, 0x02, 0x2E, + 0x59, 0x6A, 0x8B, 0x03, 0xC0, 0xA4, 0x01, 0xA0, + 0xCF, 0xF0, 0xA6, 0xE7, 0xD0, 0x54, 0x86, 0x13 + }, + { + 0xE3, 0x5E, 0x4C, 0x12, 0xEC, 0x5D, 0xA9, 0x1A, + 0x96, 0xE9, 0x9A, 0x1E, 0x50, 0xC0, 0x5D, 0x4D, + 0x06, 0x84, 0xE8, 0x24, 0x36, 0x2C, 0x01, 0x53, + 0xF5, 0x6B, 0xFD, 0x8C, 0x0F, 0x37, 0x1E, 0x53, + 0xD1, 0xD4, 0xB5, 0xBE, 0x1F, 0xBE, 0x37, 0x28, + 0x3D, 0xF4, 0xF2, 0x76, 0xC2, 0xAD, 0x1E, 0x99, + 0x7A, 0xF7, 0xCA, 0xCA, 0x51, 0xA7, 0x29, 0x17, + 0x3F, 0x1D, 0x13, 0x19, 0x3D, 0xC7, 0xC5, 0x8E + }, + { + 0x61, 0x5C, 0x37, 0xF7, 0x33, 0xAC, 0x21, 0xA8, + 0xC6, 0xC3, 0xAB, 0x1B, 0xB5, 0xC1, 0x31, 0x1C, + 0xE1, 0x6A, 0x2E, 0xD2, 0xBA, 0x03, 0x7D, 0x6F, + 0x2B, 0x35, 0x60, 0x51, 0x7A, 0x7D, 0xBD, 0xAD, + 0x2A, 0x95, 0xD0, 0x8F, 0x1F, 0xA1, 0x6D, 0x55, + 0x59, 0x44, 0xD7, 0x3B, 0x73, 0x7F, 0xD2, 0x16, + 0x32, 0x14, 0x78, 0x35, 0x19, 0xC2, 0x0D, 0xA4, + 0xAE, 0x15, 0xF1, 0x01, 0x4F, 0x8C, 0x12, 0x13 + }, + { + 0x15, 0x2D, 0xFC, 0x56, 0xDC, 0xC8, 0x8B, 0xCD, + 0x50, 0x45, 0xF5, 0x9E, 0x45, 0x24, 0xE4, 0x7F, + 0x5C, 0xA3, 0xC9, 0x48, 0xBE, 0x69, 0x69, 0x8E, + 0x5D, 0xC7, 0xA6, 0x18, 0x66, 0x8E, 0x00, 0x8C, + 0x81, 0xF5, 0x6A, 0xEB, 0xC8, 0x18, 0xDA, 0xA6, + 0x7F, 0xB5, 0x91, 0xE8, 0xB0, 0xAC, 0x12, 0xED, + 0x68, 0xA3, 0xF8, 0x7C, 0xDF, 0xAD, 0x23, 0x07, + 0x5D, 0x60, 0xF8, 0x30, 0x76, 0xDD, 0x7F, 0xBF + }, + { + 0x0C, 0x78, 0x7A, 0x7C, 0xC5, 0x37, 0xBB, 0xD8, + 0x82, 0xF1, 0x99, 0x49, 0xE3, 0x9A, 0x56, 0x49, + 0x36, 0x60, 0xAC, 0x8B, 0x3B, 0xB3, 0x5D, 0x07, + 0x6E, 0x0A, 0xDD, 0x24, 0x37, 0x67, 0xC1, 0xB8, + 0x62, 0xC6, 0x6B, 0xCB, 0x8D, 0x92, 0xBA, 0xF9, + 0x6D, 0x19, 0x18, 0xC2, 0x9A, 0xA5, 0x40, 0xDB, + 0xD6, 0xA4, 0xEB, 0xF6, 0x00, 0xE6, 0xE1, 0x91, + 0x46, 0x0D, 0x75, 0x55, 0xF4, 0x33, 0x9A, 0x09 + }, + { + 0x4D, 0xC5, 0x7C, 0xF0, 0xFE, 0x97, 0xE6, 0x80, + 0x0D, 0x3A, 0xE7, 0xB7, 0xF0, 0x95, 0x6B, 0x13, + 0xA7, 0xE2, 0x70, 0x2D, 0xCF, 0x35, 0x56, 0x2D, + 0x03, 0x98, 0xF5, 0x84, 0x29, 0x52, 0x1E, 0x20, + 0xCC, 0x9B, 0xD7, 0x48, 0xB2, 0x56, 0x03, 0xEA, + 0xE6, 0xAA, 0x15, 0x07, 0x17, 0x3B, 0xF7, 0x4E, + 0x0E, 0x75, 0xA8, 0xCE, 0xD2, 0x92, 0x6A, 0xE4, + 0xFD, 0x10, 0xEF, 0x4C, 0x89, 0x14, 0xB2, 0x24 + }, + { + 0x55, 0xF0, 0x96, 0x69, 0x35, 0xEA, 0x50, 0x20, + 0x3C, 0xD3, 0x59, 0x90, 0x55, 0x88, 0x82, 0x61, + 0x6E, 0x6A, 0xDD, 0x21, 0xAE, 0x71, 0x42, 0xC8, + 0x41, 0x12, 0xEF, 0x3E, 0x2C, 0x41, 0xE9, 0x32, + 0xCC, 0xB6, 0x78, 0x74, 0x23, 0x32, 0x15, 0x46, + 0x6C, 0x85, 0xCE, 0x5A, 0x5B, 0xA9, 0x62, 0x4C, + 0x65, 0xD1, 0x93, 0x3A, 0x12, 0x34, 0x70, 0xCF, + 0x2D, 0xB4, 0x83, 0x6F, 0xF8, 0xE2, 0xCD, 0x9F + }, + { + 0xA8, 0x5B, 0x15, 0xAF, 0xB8, 0x8A, 0xD4, 0x65, + 0xAF, 0x91, 0x26, 0x2F, 0x9B, 0xCC, 0x8E, 0xBA, + 0x74, 0x88, 0x93, 0xA2, 0xA9, 0x8E, 0xBF, 0xE2, + 0x30, 0x37, 0x26, 0x13, 0x62, 0x22, 0xCB, 0xE7, + 0x38, 0xE2, 0x0D, 0x7E, 0xDE, 0xB4, 0x38, 0xFF, + 0x46, 0x81, 0x6E, 0xA6, 0x39, 0x54, 0xD4, 0x2B, + 0x42, 0x0A, 0x98, 0x1D, 0x4C, 0xEF, 0x8E, 0x08, + 0x91, 0x7A, 0xB6, 0xD0, 0x50, 0x27, 0x93, 0xFC + }, + { + 0x1F, 0xBB, 0x59, 0x62, 0x6E, 0x91, 0xBB, 0x75, + 0x33, 0x33, 0x95, 0x15, 0x9D, 0x75, 0x44, 0x53, + 0xBF, 0xE6, 0x99, 0x60, 0x9D, 0x61, 0x7D, 0x0C, + 0xA9, 0x4F, 0xA5, 0x02, 0x8A, 0xAA, 0xC5, 0x76, + 0xF2, 0xFA, 0x9C, 0x6F, 0x31, 0xD5, 0x11, 0x34, + 0x12, 0x56, 0x13, 0x2F, 0x65, 0xE2, 0x4C, 0xE7, + 0x80, 0x97, 0x06, 0x08, 0x00, 0x46, 0x51, 0x13, + 0x29, 0x8F, 0xBD, 0x06, 0x9F, 0x3C, 0x98, 0x8F + }, + { + 0xD0, 0x7F, 0xB6, 0x56, 0x91, 0xD1, 0x8A, 0xD6, + 0x03, 0x8C, 0x14, 0xFD, 0xC4, 0x03, 0x74, 0xB6, + 0x87, 0x97, 0xF2, 0x7E, 0xD9, 0x1E, 0x9A, 0xDE, + 0xDF, 0x60, 0x9B, 0xFF, 0x62, 0xBA, 0xA6, 0xFB, + 0x00, 0xA7, 0x96, 0x73, 0x56, 0x84, 0x41, 0x79, + 0xEF, 0xD7, 0x3A, 0x28, 0xD2, 0x4A, 0xEE, 0xF2, + 0xAC, 0x3B, 0x4E, 0x69, 0xD5, 0xCF, 0x36, 0x21, + 0xFF, 0x98, 0x97, 0xE7, 0xEC, 0x5F, 0xB5, 0x75 + }, + { + 0xB8, 0x55, 0xB7, 0x95, 0xA1, 0xC7, 0x1B, 0xAA, + 0xC8, 0x48, 0x45, 0x8B, 0x22, 0xE1, 0x63, 0x26, + 0xFC, 0x21, 0xBA, 0xC1, 0xA5, 0x2E, 0x45, 0x0E, + 0xD5, 0x6B, 0xB5, 0xC8, 0xB1, 0x06, 0x7F, 0xE6, + 0x77, 0x3B, 0x1F, 0x60, 0x34, 0xAD, 0xAD, 0xE1, + 0xFD, 0x1D, 0x39, 0xD0, 0xC4, 0x5B, 0x24, 0xE8, + 0x97, 0x13, 0x5E, 0x2A, 0xC0, 0xEA, 0xDF, 0xFA, + 0x7A, 0xDB, 0x43, 0x4A, 0xEA, 0xAA, 0xAF, 0xB6 + }, + { + 0xD4, 0x64, 0x18, 0x44, 0x86, 0xAF, 0x35, 0xB4, + 0x35, 0x37, 0x90, 0x2E, 0x5D, 0xA6, 0x57, 0x82, + 0x48, 0x0E, 0x01, 0xB6, 0x5C, 0xBE, 0x63, 0xB0, + 0x50, 0x01, 0x49, 0x24, 0x7A, 0xF2, 0x71, 0x63, + 0xED, 0xDB, 0x95, 0xBE, 0xCD, 0x5F, 0xB4, 0xD7, + 0x89, 0x58, 0xD4, 0x65, 0x1E, 0xAF, 0xFE, 0x52, + 0x8E, 0x22, 0x44, 0x7C, 0xD5, 0xF1, 0xBC, 0x28, + 0x6B, 0x54, 0xE8, 0x38, 0x33, 0x26, 0xC8, 0x33 + }, + { + 0x19, 0x01, 0xA9, 0x6E, 0x21, 0x1D, 0x2B, 0x33, + 0x59, 0x35, 0xE2, 0x42, 0xC6, 0xB9, 0x5E, 0x62, + 0xA9, 0xC0, 0xC1, 0x63, 0x56, 0x7C, 0xC9, 0x6D, + 0x0C, 0x0F, 0xDB, 0x77, 0xB5, 0x5A, 0x31, 0x78, + 0x65, 0x0D, 0x2D, 0x89, 0xD7, 0x95, 0x87, 0xA7, + 0x73, 0x9E, 0xE0, 0x01, 0xA2, 0xFF, 0xA8, 0x36, + 0xA6, 0xCF, 0x47, 0x54, 0x62, 0x5D, 0x63, 0x18, + 0xEF, 0x44, 0x20, 0x98, 0xB2, 0xBA, 0x85, 0x37 + }, + { + 0xAE, 0xA3, 0xA8, 0x63, 0x8A, 0x93, 0x2A, 0x67, + 0xEE, 0x7B, 0xB7, 0xE0, 0xED, 0x52, 0x59, 0x2F, + 0xEA, 0x54, 0xB2, 0x7F, 0xA5, 0x30, 0xC3, 0x20, + 0x3D, 0x23, 0x2A, 0xD3, 0x23, 0x34, 0xB1, 0x2E, + 0x7C, 0x97, 0x64, 0x70, 0x22, 0xC6, 0x88, 0xB4, + 0xF9, 0xA9, 0x76, 0xE4, 0x50, 0x38, 0x2E, 0x29, + 0x7F, 0x87, 0x6B, 0x7A, 0xA2, 0x9E, 0xA2, 0xBF, + 0xF9, 0x70, 0xD1, 0x46, 0x1B, 0x98, 0x96, 0x7C + }, + { + 0xB6, 0xE0, 0x6F, 0xBF, 0xD0, 0x66, 0xF8, 0xED, + 0x54, 0xC9, 0xBF, 0x5F, 0x21, 0x4D, 0x79, 0x5A, + 0x71, 0x63, 0x05, 0xA8, 0x83, 0xEA, 0x6E, 0x37, + 0x7F, 0xD0, 0x02, 0x8B, 0x0E, 0x55, 0x0F, 0x59, + 0xDB, 0x8C, 0x62, 0x75, 0x11, 0x3D, 0x70, 0x63, + 0xAF, 0xA9, 0x8A, 0x46, 0x92, 0xFD, 0x1B, 0x75, + 0x99, 0x92, 0x29, 0xE1, 0x78, 0xE2, 0xF2, 0x23, + 0xD5, 0x78, 0xBC, 0x93, 0x66, 0x3E, 0xD8, 0xFF + }, + { + 0x64, 0x77, 0xAA, 0x59, 0xAA, 0xFA, 0x46, 0x69, + 0x92, 0xF1, 0x03, 0x54, 0x76, 0xEC, 0xEB, 0x3A, + 0xA9, 0xFB, 0x50, 0x37, 0x3C, 0xDD, 0x2F, 0x0E, + 0xE7, 0xFF, 0xF2, 0x88, 0x5E, 0x48, 0xB9, 0xF1, + 0xB3, 0xCE, 0xBC, 0xC1, 0x1F, 0x59, 0xCB, 0xFE, + 0x61, 0x65, 0x58, 0xB0, 0x0D, 0x7F, 0xE8, 0x02, + 0x9B, 0x58, 0x66, 0xB0, 0xBE, 0x26, 0xCC, 0x02, + 0xAA, 0xC8, 0x62, 0x65, 0xE4, 0xE9, 0x5D, 0x5F + }, + { + 0x2C, 0xB7, 0x6E, 0xA2, 0xEF, 0x59, 0x2F, 0x15, + 0x16, 0x8B, 0x17, 0xBD, 0xE8, 0x4D, 0xF3, 0xCD, + 0x8C, 0xCB, 0x89, 0x89, 0x6D, 0xEC, 0x62, 0x0B, + 0xEC, 0x40, 0x45, 0x73, 0xA7, 0xB7, 0x16, 0xF5, + 0xB2, 0x9B, 0x9A, 0x2A, 0xF3, 0x4C, 0xB0, 0x5E, + 0xAE, 0x47, 0x10, 0xDA, 0x62, 0x88, 0xBA, 0x30, + 0x04, 0x32, 0x0C, 0xD5, 0x4D, 0x2D, 0x2E, 0xD3, + 0x89, 0x84, 0x4D, 0x83, 0x09, 0xC9, 0xC5, 0xA2 + }, + { + 0x9E, 0x7F, 0x90, 0x0E, 0x4B, 0x03, 0x9F, 0x3F, + 0x4F, 0x81, 0x02, 0x9A, 0x74, 0xC6, 0x5A, 0xD3, + 0xE1, 0xAB, 0xBC, 0x6D, 0x36, 0x64, 0xCC, 0x0F, + 0x37, 0x06, 0xBA, 0x59, 0xA5, 0x3C, 0x8E, 0xB7, + 0x29, 0x76, 0x2B, 0x32, 0x43, 0x14, 0x96, 0x7E, + 0x9B, 0x02, 0x5D, 0x84, 0x64, 0xF9, 0x60, 0xAB, + 0xEF, 0xB3, 0x2F, 0x43, 0xDC, 0xA0, 0x2E, 0x11, + 0x60, 0xB7, 0x46, 0x8A, 0x0C, 0xA2, 0x90, 0x28 + }, + { + 0x78, 0xE4, 0x62, 0x84, 0x4B, 0x48, 0xCD, 0x58, + 0xEC, 0x34, 0xE6, 0x69, 0xDB, 0x2C, 0x91, 0x98, + 0xF1, 0x0C, 0xCA, 0x4B, 0x16, 0x1D, 0x42, 0xF2, + 0x22, 0xF4, 0x3D, 0xA6, 0x11, 0xA8, 0x16, 0xD8, + 0x2D, 0x60, 0xED, 0x1B, 0xE6, 0xAB, 0xA1, 0x28, + 0x48, 0x7A, 0x80, 0x19, 0xC7, 0x6B, 0x10, 0x6A, + 0x03, 0x23, 0xBD, 0xF8, 0x40, 0xC9, 0x88, 0x9C, + 0xDF, 0x99, 0xAC, 0x48, 0x6C, 0xC2, 0x5C, 0x42 + }, + { + 0xAA, 0x3E, 0x4E, 0xC9, 0x53, 0x42, 0x04, 0x8F, + 0x51, 0x38, 0x09, 0xFC, 0x3F, 0x7B, 0xDA, 0x7F, + 0xF9, 0x3C, 0x50, 0x55, 0x45, 0xE2, 0x4D, 0x1C, + 0xD3, 0x0C, 0xAA, 0x2F, 0x0C, 0xD7, 0x62, 0xAD, + 0x6A, 0x2A, 0xC8, 0x0F, 0x4C, 0x37, 0x11, 0x4C, + 0x60, 0xEF, 0x98, 0xF2, 0xEF, 0x0C, 0x3F, 0xB0, + 0xE1, 0x0C, 0xFA, 0x17, 0xC6, 0x8C, 0xD4, 0xBD, + 0x40, 0xEF, 0x2F, 0x69, 0xE9, 0x36, 0xC1, 0xA3 + }, + { + 0x0B, 0xAF, 0x7E, 0xC7, 0x80, 0x13, 0x7E, 0xA0, + 0x54, 0xCD, 0x53, 0x55, 0x79, 0x33, 0xDD, 0xE1, + 0xF3, 0xF8, 0x6C, 0xA7, 0x18, 0x15, 0x53, 0xA7, + 0x38, 0x05, 0x10, 0x06, 0xA9, 0x6C, 0xAC, 0x9A, + 0x2D, 0x94, 0xFB, 0x0E, 0x78, 0xB4, 0x72, 0xA8, + 0xCC, 0x5B, 0xF9, 0x60, 0xCB, 0x9C, 0x55, 0x98, + 0x91, 0x02, 0x04, 0x67, 0x10, 0x2E, 0x65, 0xFB, + 0x76, 0xD5, 0x74, 0x52, 0x02, 0x26, 0xAA, 0x7B + }, + { + 0xC9, 0x1B, 0x08, 0x5F, 0xBE, 0xCA, 0x1A, 0x37, + 0xC6, 0xDC, 0x97, 0x65, 0xA7, 0x1E, 0xBD, 0xE6, + 0x5B, 0xBC, 0x0F, 0xC7, 0xF4, 0xF1, 0x2D, 0xE1, + 0x6C, 0xC8, 0x56, 0xF7, 0x16, 0xE1, 0xC9, 0x1C, + 0x85, 0x72, 0x96, 0x1B, 0x59, 0xD0, 0x9D, 0x95, + 0xE7, 0x2E, 0xE3, 0x6E, 0x79, 0xD9, 0xAD, 0x4E, + 0x4D, 0xF6, 0x20, 0xF9, 0xCA, 0x83, 0x8E, 0x4C, + 0x9F, 0x4F, 0x44, 0x2A, 0x09, 0x4A, 0xE1, 0x41 + }, + { + 0xFB, 0xCB, 0x42, 0x1D, 0x5F, 0xE8, 0xA5, 0x55, + 0xBB, 0x44, 0x42, 0x37, 0xAE, 0xFC, 0x22, 0x4A, + 0x94, 0xE4, 0x3D, 0x90, 0x7B, 0xC6, 0x22, 0xE6, + 0xBC, 0x63, 0xE4, 0x7C, 0x5F, 0x96, 0x15, 0x0F, + 0x4A, 0x8E, 0x5F, 0xA3, 0x62, 0x0F, 0x62, 0x93, + 0x33, 0xAB, 0x34, 0x84, 0x2E, 0x9C, 0x20, 0xA5, + 0xCE, 0x02, 0xAA, 0xA8, 0x06, 0x10, 0xFB, 0x63, + 0xE5, 0x5F, 0x4C, 0x6E, 0x11, 0xA6, 0x39, 0x2A + }, + { + 0xC8, 0x08, 0x12, 0xDA, 0xA1, 0x7C, 0x7B, 0x7F, + 0x02, 0xA3, 0x9B, 0x41, 0x9A, 0xA7, 0x2A, 0xCF, + 0xC3, 0x38, 0x2D, 0x39, 0x21, 0xE4, 0xC0, 0x72, + 0x8B, 0x0B, 0xB9, 0x4B, 0x3A, 0xF2, 0xDB, 0xD9, + 0x9E, 0x0F, 0x1D, 0x9D, 0xD3, 0x96, 0xD1, 0xAD, + 0x14, 0x68, 0x85, 0xF5, 0xDA, 0xDE, 0x08, 0x5A, + 0xC7, 0xAA, 0x4A, 0xB4, 0xCB, 0x8E, 0x40, 0x99, + 0x24, 0xB9, 0x48, 0xD2, 0x79, 0x61, 0x42, 0x8E + }, + { + 0x9C, 0x0A, 0x5D, 0x35, 0x8E, 0x16, 0xAD, 0x8A, + 0xF3, 0x28, 0xAC, 0x04, 0x06, 0x71, 0xBB, 0xEB, + 0xFC, 0x5F, 0xCF, 0x3F, 0xAA, 0x7B, 0xA8, 0x86, + 0x43, 0xA9, 0xFF, 0x97, 0x95, 0x2A, 0x6A, 0xBE, + 0xD6, 0x0C, 0xCB, 0x47, 0xAC, 0x77, 0x83, 0xA3, + 0x20, 0xAF, 0x5F, 0xF2, 0xCE, 0x47, 0xE7, 0x35, + 0xA7, 0xAB, 0x66, 0x52, 0xB2, 0xF0, 0xF5, 0x02, + 0x91, 0x5C, 0xC7, 0x8E, 0x7A, 0x2E, 0x99, 0x3F + }, + { + 0x66, 0x86, 0xAC, 0xE2, 0x20, 0x13, 0x52, 0x2E, + 0x4F, 0x69, 0xB8, 0x6E, 0x05, 0x66, 0xB3, 0xBF, + 0x81, 0x24, 0x04, 0xF3, 0x7E, 0x74, 0xB7, 0xA7, + 0x68, 0xE4, 0x75, 0xDF, 0x96, 0x05, 0x4A, 0x98, + 0xE7, 0x67, 0x82, 0xC0, 0x1A, 0x22, 0x72, 0x56, + 0x34, 0x6E, 0xA8, 0x6B, 0xBC, 0x50, 0x8B, 0x50, + 0xD6, 0x3C, 0x34, 0xC2, 0x78, 0xA1, 0xF6, 0xC6, + 0x5C, 0x71, 0xAB, 0x16, 0x19, 0x92, 0x1F, 0xA2 + }, + { + 0xF7, 0x26, 0x94, 0x4C, 0xF1, 0x72, 0x88, 0xE0, + 0x96, 0x7B, 0xFE, 0xA8, 0x5D, 0xCE, 0x80, 0x5B, + 0xCC, 0x20, 0x56, 0x44, 0x65, 0xAA, 0xB7, 0x71, + 0xB6, 0xA5, 0x00, 0xB1, 0x46, 0x95, 0x4F, 0xE9, + 0x60, 0x27, 0x2D, 0x09, 0x3A, 0xC3, 0x35, 0x2F, + 0xF2, 0x00, 0xF3, 0xBC, 0x2A, 0x4C, 0x56, 0xBD, + 0x91, 0x51, 0x6B, 0x84, 0x67, 0x76, 0x8E, 0xE9, + 0x21, 0xA5, 0xAD, 0x7E, 0x89, 0x18, 0xDA, 0x39 + }, + { + 0xCF, 0xC7, 0x2E, 0xD4, 0xB1, 0x50, 0x92, 0x85, + 0x6F, 0xFE, 0x8E, 0x68, 0x02, 0x3F, 0x32, 0xBD, + 0xE1, 0x78, 0x5A, 0xF3, 0x83, 0x05, 0x1A, 0x1D, + 0xD6, 0xB0, 0xFA, 0x45, 0x5F, 0x31, 0x85, 0xBD, + 0x7D, 0x90, 0x61, 0x7C, 0xDF, 0x59, 0xEC, 0xA6, + 0x92, 0x3E, 0xC4, 0x80, 0xC2, 0x2A, 0x09, 0x1E, + 0xD3, 0xB0, 0x12, 0xC6, 0x71, 0xA2, 0x6E, 0xE6, + 0x5C, 0xEB, 0x00, 0x78, 0xBA, 0xEA, 0xF3, 0x68 + }, + { + 0x62, 0x52, 0xAF, 0xDB, 0xBB, 0x6B, 0xB6, 0x4D, + 0x24, 0x12, 0x2D, 0xDC, 0x3C, 0x99, 0x9D, 0x45, + 0xDA, 0xF0, 0x8E, 0x20, 0x4B, 0xEB, 0x4D, 0x37, + 0xA6, 0x4B, 0xA2, 0xE2, 0x80, 0x38, 0xEB, 0x57, + 0x2D, 0xD7, 0x62, 0x6B, 0xF7, 0x42, 0xBA, 0x21, + 0x45, 0xBB, 0x86, 0xE5, 0x20, 0x3E, 0x3D, 0xA3, + 0x2A, 0x68, 0xBA, 0x27, 0x74, 0xCF, 0xF1, 0xB0, + 0x59, 0x2A, 0x92, 0x46, 0x28, 0x0E, 0x84, 0x96 + }, + { + 0xF1, 0x3F, 0x62, 0x17, 0xE3, 0x0A, 0x6E, 0x90, + 0xD8, 0xD5, 0x49, 0x7B, 0xCE, 0x0C, 0x5E, 0x01, + 0xBA, 0x65, 0x4F, 0x6B, 0x0B, 0x9A, 0x31, 0xBB, + 0x64, 0x98, 0xAC, 0x8C, 0x1A, 0x7F, 0x9E, 0xD8, + 0x05, 0xCE, 0x82, 0x7F, 0x3E, 0x03, 0xE6, 0x22, + 0x29, 0x11, 0x70, 0x93, 0x52, 0xCD, 0x28, 0xD4, + 0x29, 0xDF, 0xB6, 0x1C, 0x2D, 0x5F, 0x8C, 0x83, + 0x46, 0x5E, 0x17, 0x79, 0xBC, 0x66, 0x30, 0x87 + }, + { + 0x25, 0x75, 0x0C, 0xC1, 0x26, 0x91, 0x68, 0x73, + 0xE3, 0x47, 0x25, 0x97, 0xC5, 0x74, 0xE8, 0x27, + 0x1A, 0x9D, 0x25, 0x3A, 0xC3, 0xAB, 0x6A, 0x64, + 0x4A, 0x46, 0xDA, 0x7C, 0xB7, 0xFD, 0x96, 0xAB, + 0x57, 0x11, 0x06, 0xB7, 0x37, 0xB6, 0xA5, 0x9D, + 0x4C, 0x95, 0xAC, 0xF1, 0xCC, 0xD4, 0x9D, 0xEB, + 0xD3, 0x99, 0xAE, 0xB2, 0xAF, 0xA8, 0xDA, 0xB5, + 0x03, 0x9B, 0x71, 0xC9, 0x78, 0x0C, 0x32, 0x52 + }, + { + 0xC2, 0xCB, 0x34, 0x88, 0x39, 0xCD, 0x61, 0x99, + 0xE3, 0xAB, 0xB1, 0xD7, 0x92, 0x7B, 0xDD, 0x38, + 0x3A, 0x35, 0x65, 0x4A, 0xAF, 0x18, 0x2E, 0x27, + 0x1C, 0x1F, 0x80, 0x8E, 0x61, 0x53, 0x83, 0xCE, + 0xA4, 0xA2, 0x67, 0xCE, 0x54, 0x7D, 0x94, 0xBE, + 0x4E, 0xA0, 0xE7, 0x25, 0x27, 0x9C, 0x79, 0x93, + 0xB0, 0x57, 0xB7, 0xE6, 0x0F, 0xF6, 0xE0, 0x67, + 0xFF, 0x61, 0x16, 0xD3, 0xD3, 0x33, 0x95, 0x94 + }, + { + 0xDA, 0x58, 0x8E, 0x29, 0xB4, 0xFE, 0x08, 0x1F, + 0xBA, 0xF2, 0xF6, 0xEF, 0x90, 0x0D, 0x7E, 0xB3, + 0x2B, 0x46, 0xDB, 0xB5, 0x17, 0xC5, 0xFB, 0x89, + 0x7F, 0x09, 0x2C, 0x80, 0xA7, 0xE2, 0x19, 0x6D, + 0x50, 0xFC, 0xA0, 0xFB, 0x3A, 0x58, 0x22, 0xF1, + 0xDD, 0x67, 0x24, 0x90, 0x9F, 0x7B, 0x34, 0x28, + 0x0D, 0xE3, 0x54, 0x35, 0x43, 0x05, 0x9E, 0x7C, + 0x6B, 0x78, 0xB8, 0xBB, 0x60, 0xA5, 0xD2, 0x52 + }, + { + 0xFA, 0x1E, 0xE9, 0x94, 0x0B, 0x09, 0x3E, 0xCB, + 0xB2, 0x68, 0xDF, 0xF2, 0x91, 0x38, 0x00, 0xC5, + 0x59, 0xE3, 0xD9, 0x54, 0x60, 0x3A, 0x33, 0x28, + 0xFA, 0x7C, 0x28, 0x97, 0x38, 0x7B, 0x7B, 0x37, + 0xF7, 0x9A, 0x4A, 0x63, 0xCB, 0xA6, 0xA2, 0xA5, + 0xF9, 0x3C, 0x6E, 0xE4, 0x6B, 0xF3, 0x2E, 0xCE, + 0xF5, 0x52, 0x7D, 0x6C, 0x52, 0xE3, 0x56, 0x0F, + 0xEA, 0xCC, 0xA3, 0xCD, 0x3F, 0xA4, 0x6D, 0xFA + }, + { + 0x97, 0x3E, 0xAC, 0xC0, 0xA3, 0x3C, 0x84, 0x29, + 0xB6, 0x6C, 0x52, 0x59, 0x66, 0xA5, 0x2C, 0x45, + 0xEC, 0x41, 0xED, 0x29, 0x72, 0xD6, 0xA9, 0x9E, + 0xCE, 0x9C, 0x5B, 0x1B, 0x76, 0x0B, 0x32, 0x34, + 0x4D, 0x52, 0xE2, 0x41, 0x23, 0x32, 0xC3, 0x8C, + 0x15, 0xD2, 0x98, 0x90, 0x3D, 0x85, 0x29, 0x8A, + 0x4C, 0x93, 0x35, 0x9D, 0x4C, 0xF4, 0x92, 0xF9, + 0x4F, 0x16, 0xD5, 0xD9, 0x3B, 0x87, 0xCC, 0x9C + }, + { + 0xD3, 0xAF, 0x58, 0xC5, 0xC6, 0x7F, 0x1D, 0xB5, + 0xEA, 0x46, 0x67, 0x66, 0xDB, 0xC3, 0xE5, 0xB0, + 0x1E, 0x44, 0x04, 0x14, 0x20, 0x8A, 0x22, 0x53, + 0x16, 0xBD, 0xE4, 0x1A, 0x7B, 0xA9, 0xDB, 0x5D, + 0xCF, 0xF3, 0xDC, 0x35, 0x9D, 0xB4, 0x2E, 0x30, + 0x5E, 0x74, 0xC3, 0x33, 0xA3, 0x08, 0xEB, 0x6F, + 0xC1, 0xF1, 0xC9, 0x5F, 0x96, 0xE2, 0xD6, 0x23, + 0x26, 0x4F, 0x86, 0x28, 0xD5, 0x9A, 0xC6, 0x95 + }, + { + 0x98, 0x62, 0xE4, 0x1E, 0x09, 0xAC, 0xDE, 0xA8, + 0xEC, 0x6C, 0xEC, 0xE9, 0xD6, 0xB6, 0x71, 0xBF, + 0x34, 0x70, 0xC9, 0x24, 0xB3, 0x19, 0x49, 0x57, + 0x1E, 0xB8, 0xAD, 0x06, 0x06, 0x56, 0x5F, 0x52, + 0xF0, 0x69, 0xF0, 0x7E, 0xDD, 0x19, 0xD9, 0x2A, + 0x0E, 0x36, 0x30, 0xAC, 0x1B, 0xBF, 0x0A, 0xF2, + 0xD3, 0xD2, 0x95, 0x3C, 0x67, 0x08, 0x64, 0x77, + 0xC9, 0x21, 0x57, 0x71, 0x2C, 0x5A, 0x7A, 0x52 + }, + { + 0xA2, 0xD3, 0xC9, 0x69, 0x9B, 0xA0, 0x8F, 0x6F, + 0xC1, 0x05, 0xF5, 0x88, 0x9D, 0xC0, 0x63, 0x24, + 0x7F, 0x1C, 0xBD, 0x96, 0x23, 0x8A, 0xFF, 0xD8, + 0x16, 0xE6, 0x93, 0xF2, 0xEF, 0x0D, 0x80, 0x24, + 0x0E, 0x73, 0x16, 0x25, 0x6E, 0xCA, 0x29, 0xCF, + 0xBA, 0xB4, 0x2A, 0x29, 0x11, 0x47, 0x14, 0xD2, + 0x45, 0xBA, 0x91, 0xB7, 0xC2, 0x39, 0x00, 0xAE, + 0x4C, 0xFE, 0xDC, 0x2E, 0xE3, 0xE8, 0x14, 0x10 + }, + { + 0x66, 0x54, 0x61, 0x69, 0x11, 0x0A, 0x44, 0xF5, + 0xCF, 0x38, 0x72, 0x9D, 0x73, 0x39, 0x2D, 0x0D, + 0x37, 0xF1, 0x83, 0xF1, 0x89, 0x94, 0xD6, 0xA3, + 0x8B, 0xF6, 0x38, 0xAD, 0xDE, 0xBB, 0x87, 0x51, + 0x21, 0x7A, 0x5E, 0x07, 0x31, 0x7F, 0xBB, 0x15, + 0xA2, 0xB8, 0x4D, 0x00, 0xA2, 0x70, 0xCF, 0xDE, + 0x88, 0x50, 0xCA, 0xFB, 0xC9, 0x21, 0x96, 0x09, + 0x29, 0x2E, 0xAC, 0x16, 0x26, 0xDC, 0xBA, 0xA6 + }, + { + 0x15, 0xAA, 0x14, 0x71, 0xCF, 0xA9, 0x81, 0x79, + 0xF4, 0xF6, 0x9D, 0x1A, 0x06, 0x1A, 0x40, 0x33, + 0x65, 0x08, 0xF4, 0x7D, 0x3B, 0x39, 0x4E, 0x30, + 0xEE, 0x6F, 0x9A, 0x9A, 0xA6, 0x97, 0x46, 0x52, + 0x87, 0x3C, 0x2B, 0x50, 0x5A, 0x1C, 0x66, 0x5B, + 0x6D, 0xB5, 0xAD, 0xD1, 0xD7, 0xF9, 0x12, 0xE6, + 0x18, 0xC2, 0x21, 0x79, 0xC7, 0x41, 0xE7, 0x7F, + 0xCF, 0x2E, 0x84, 0x19, 0x20, 0xF5, 0xA7, 0x6F + }, + { + 0x10, 0x2F, 0x12, 0x18, 0xCF, 0x3D, 0xF3, 0x8E, + 0x98, 0xEE, 0xE6, 0xDA, 0x5B, 0xB5, 0x0A, 0xD1, + 0x28, 0xC1, 0x38, 0x65, 0xC3, 0x3A, 0xEF, 0x0B, + 0x23, 0xAC, 0x95, 0xB9, 0x27, 0x2B, 0x46, 0xF9, + 0xE2, 0xA2, 0x74, 0x56, 0x76, 0x1B, 0x2B, 0x42, + 0x2F, 0x96, 0x65, 0x62, 0x22, 0x91, 0x09, 0xC9, + 0xEA, 0x13, 0xBE, 0x8B, 0x35, 0xF7, 0x16, 0x98, + 0x2D, 0x64, 0xC8, 0x7A, 0x15, 0xF5, 0x92, 0xCE + }, + { + 0xFF, 0xED, 0xF8, 0x80, 0x26, 0x23, 0xB1, 0x13, + 0xB4, 0x8F, 0x46, 0xC7, 0xBA, 0x9E, 0x84, 0x00, + 0xB7, 0x66, 0xEC, 0xD6, 0x3D, 0x6A, 0x84, 0x75, + 0x6F, 0xE7, 0x25, 0xA5, 0xDD, 0x08, 0x08, 0x37, + 0x37, 0x53, 0x55, 0x72, 0xB3, 0x14, 0x37, 0x0F, + 0x04, 0xA9, 0xD6, 0x1F, 0x99, 0xE5, 0x69, 0x94, + 0xA3, 0xCB, 0x3D, 0xF6, 0xEA, 0x36, 0x09, 0x48, + 0xF1, 0xFE, 0xF9, 0x8D, 0x4E, 0x95, 0x84, 0xC1 + }, + { + 0x24, 0xEF, 0xDF, 0xF8, 0xD1, 0x85, 0x74, 0x2A, + 0xF5, 0x1E, 0xFB, 0xEE, 0xA0, 0xD8, 0x98, 0x17, + 0x30, 0x3F, 0xBD, 0x07, 0xF9, 0xA2, 0xF3, 0x45, + 0xA2, 0xBE, 0x9B, 0x8A, 0x89, 0x9A, 0x0A, 0x1F, + 0x98, 0xF4, 0x6E, 0xBA, 0x10, 0x8E, 0x7B, 0xF4, + 0xBF, 0x5E, 0x5F, 0x19, 0x75, 0x25, 0x5F, 0x05, + 0xF7, 0x47, 0x57, 0xC7, 0xBE, 0x4C, 0xD6, 0x62, + 0x05, 0xB5, 0x6A, 0x81, 0x8E, 0xFF, 0xE8, 0x45 + }, + { + 0x83, 0x73, 0x60, 0xA3, 0xF1, 0xC8, 0xD2, 0xCF, + 0xD0, 0x6D, 0x40, 0x8E, 0xAA, 0xC3, 0xE8, 0x33, + 0x22, 0x3D, 0xE6, 0xCE, 0xEF, 0x18, 0xD2, 0x91, + 0x1E, 0xED, 0xD4, 0x57, 0xA9, 0x0F, 0xA3, 0xE4, + 0xFE, 0x80, 0x48, 0xB5, 0x23, 0x94, 0x91, 0x57, + 0x4B, 0x9C, 0xA8, 0x21, 0xF6, 0x60, 0xD1, 0xD8, + 0xA3, 0xFC, 0x67, 0x6A, 0x30, 0x4E, 0x53, 0xD8, + 0x3D, 0xA5, 0x33, 0xD8, 0x77, 0xB3, 0x93, 0xA1 + }, + { + 0xFD, 0xDE, 0x18, 0x8F, 0x01, 0xDB, 0x64, 0x32, + 0x3A, 0x70, 0x8B, 0xFC, 0x65, 0x5C, 0xFB, 0xFA, + 0xCB, 0x87, 0x6F, 0x5D, 0xDC, 0x67, 0xB0, 0x09, + 0xAE, 0x49, 0x3E, 0xE1, 0xDE, 0x4E, 0xDB, 0x50, + 0xC4, 0x03, 0x02, 0x12, 0xE4, 0x68, 0xD4, 0x4F, + 0x8B, 0x40, 0xE0, 0x74, 0x52, 0x6B, 0xC9, 0xC1, + 0x92, 0xE6, 0x7E, 0xB4, 0x69, 0x72, 0x2D, 0x03, + 0x14, 0x22, 0x96, 0x2A, 0xBF, 0x2B, 0xCA, 0x3D + }, + { + 0x4D, 0x6C, 0xF2, 0x17, 0xA3, 0xFF, 0x4C, 0x67, + 0xDD, 0xF8, 0x48, 0x71, 0xAF, 0x58, 0x63, 0xEC, + 0x29, 0xE5, 0x99, 0x01, 0x3F, 0x6D, 0x1C, 0x25, + 0x24, 0x28, 0x81, 0x92, 0x2A, 0xEC, 0xFD, 0xE3, + 0x9F, 0x5F, 0x17, 0xEB, 0x4C, 0x84, 0x78, 0x0D, + 0xEB, 0xE2, 0x9C, 0x5B, 0xDD, 0x7E, 0x03, 0xCF, + 0x0A, 0x3F, 0x31, 0xFB, 0x09, 0xDE, 0x57, 0xE5, + 0xE2, 0xA6, 0x30, 0x60, 0x82, 0x6B, 0x4B, 0x65 + }, + { + 0xDD, 0x25, 0xA9, 0xE4, 0x01, 0x6F, 0xD8, 0x67, + 0x35, 0x44, 0x23, 0xFE, 0x72, 0x13, 0xDF, 0x11, + 0x08, 0x12, 0x44, 0x9E, 0xA8, 0x8F, 0x8F, 0xC3, + 0x0D, 0xF0, 0x01, 0xCE, 0xD1, 0xA6, 0x95, 0xE1, + 0x4E, 0xAA, 0xE4, 0x4A, 0x14, 0x3C, 0xDB, 0x94, + 0xF5, 0x61, 0x73, 0x8C, 0x50, 0x84, 0xEE, 0x78, + 0x3D, 0xBC, 0xC3, 0xC3, 0x4C, 0xBE, 0xEC, 0x2C, + 0x86, 0xF1, 0x32, 0xC8, 0x5B, 0xB4, 0xEB, 0x1E + }, + { + 0x90, 0xC4, 0x65, 0xDD, 0x70, 0x00, 0xFF, 0x58, + 0x47, 0x68, 0x2D, 0xDE, 0xDD, 0x49, 0xE1, 0x2F, + 0x7C, 0x46, 0x16, 0x77, 0x0B, 0xE3, 0x01, 0x38, + 0x39, 0x84, 0xA5, 0xFE, 0x79, 0x0A, 0x44, 0x2E, + 0x81, 0x4B, 0x2D, 0xF1, 0xBB, 0xA4, 0x71, 0x9F, + 0x54, 0xAB, 0x77, 0x28, 0x27, 0x5D, 0x02, 0x6F, + 0x97, 0x24, 0xE9, 0xFA, 0xFC, 0x51, 0xD1, 0xD0, + 0xEA, 0x2C, 0x3F, 0xB0, 0xA6, 0x1D, 0xD1, 0x05 + }, + { + 0xC8, 0x45, 0xA8, 0x55, 0xDA, 0x29, 0xB7, 0x84, + 0x04, 0x36, 0xF2, 0x61, 0x9F, 0xE7, 0x4D, 0x06, + 0x9F, 0x8A, 0x8B, 0xC3, 0x2D, 0x4B, 0xF3, 0x15, + 0x78, 0xF5, 0xAB, 0xAD, 0x32, 0xE6, 0x84, 0x52, + 0xD3, 0x40, 0x56, 0x4C, 0x9C, 0x1D, 0xBE, 0xBA, + 0x21, 0x3B, 0x84, 0x50, 0xB6, 0x78, 0xC4, 0x61, + 0x5F, 0x77, 0x95, 0x2B, 0x97, 0x8B, 0x5F, 0xAB, + 0x39, 0xF6, 0x5C, 0x01, 0x46, 0x20, 0xEB, 0xDA + }, + { + 0x71, 0x9C, 0xB5, 0x2C, 0xCA, 0x7C, 0x39, 0xCE, + 0x4F, 0xAB, 0xFF, 0x64, 0x23, 0x64, 0x67, 0x17, + 0x21, 0x64, 0x50, 0x60, 0x9B, 0x4C, 0x61, 0xA0, + 0x0C, 0x79, 0x73, 0xA2, 0x2B, 0x8C, 0x6A, 0x27, + 0x19, 0x5D, 0x2F, 0xCD, 0x42, 0x3E, 0x76, 0x48, + 0xA9, 0xE4, 0x49, 0xAE, 0x8B, 0xB2, 0xB2, 0x93, + 0x6E, 0x22, 0x2E, 0x2A, 0xFE, 0xE7, 0x6D, 0xA5, + 0x6F, 0x2B, 0x94, 0xBE, 0xD9, 0x4F, 0x21, 0xA4 + }, + { + 0xF1, 0xF2, 0xEF, 0xE3, 0xDB, 0x66, 0xB6, 0x41, + 0x6D, 0x80, 0x09, 0xE8, 0xDD, 0x76, 0xB0, 0x78, + 0x3A, 0xDD, 0x4B, 0x4B, 0x82, 0x84, 0xC6, 0x91, + 0xE9, 0xC9, 0x67, 0xBC, 0xDB, 0x2A, 0x7B, 0xC8, + 0x98, 0x58, 0x64, 0x2C, 0x17, 0xE8, 0x46, 0x22, + 0x4C, 0x33, 0x94, 0xA0, 0x06, 0xE3, 0x5F, 0xA7, + 0x86, 0x60, 0x3A, 0x42, 0x04, 0x19, 0x6C, 0x4C, + 0x6A, 0xA1, 0x62, 0x75, 0xEF, 0xED, 0xD3, 0xE1 + }, + { + 0x23, 0x95, 0xB9, 0xEA, 0x8A, 0x99, 0xE2, 0x45, + 0xEF, 0xB0, 0xAC, 0x05, 0x71, 0x0E, 0x8C, 0x7A, + 0xAF, 0xD2, 0x27, 0xB9, 0x80, 0xD5, 0x45, 0x8E, + 0x18, 0xE5, 0x83, 0x5E, 0x49, 0x43, 0xD1, 0x11, + 0x5A, 0x84, 0xE9, 0x24, 0x8F, 0x33, 0x98, 0xDF, + 0x96, 0xA2, 0xD3, 0xB5, 0xEC, 0xD9, 0x5E, 0x2E, + 0x05, 0xA7, 0x6D, 0x87, 0x3D, 0xA8, 0xD1, 0x6B, + 0xDB, 0xA3, 0xCA, 0x5C, 0x00, 0x7C, 0x70, 0xAB + }, + { + 0x73, 0xFF, 0xA5, 0x42, 0x50, 0xCE, 0x76, 0x8E, + 0x9E, 0xCD, 0x0B, 0xAA, 0xA1, 0x1B, 0x14, 0xF8, + 0x7A, 0xD8, 0xB7, 0x6D, 0xD9, 0x72, 0x5A, 0x2E, + 0x47, 0x67, 0x8D, 0xE3, 0xBF, 0x54, 0x1C, 0x99, + 0xA9, 0xB0, 0x9C, 0x7E, 0x56, 0x3D, 0x59, 0xAA, + 0xF6, 0xEE, 0x05, 0x95, 0xAD, 0xCD, 0x22, 0x07, + 0x34, 0x53, 0x2C, 0x82, 0xCA, 0x7F, 0xBE, 0x96, + 0xB1, 0x19, 0x9A, 0xCE, 0x84, 0xF9, 0x3F, 0x93 + }, + { + 0x3D, 0x49, 0x32, 0x2C, 0xA6, 0x1A, 0x58, 0x39, + 0x99, 0x87, 0xD6, 0xDA, 0x22, 0x49, 0xC3, 0xFE, + 0x26, 0x31, 0x64, 0x1A, 0x6A, 0x2E, 0x94, 0x6C, + 0x8E, 0x57, 0x32, 0xB4, 0xCF, 0xF6, 0x53, 0xC3, + 0xFA, 0xAB, 0x2E, 0x19, 0xF5, 0x67, 0x3F, 0xD9, + 0x8A, 0xF9, 0x8A, 0x78, 0xAC, 0x1A, 0x75, 0x4B, + 0x0D, 0x2B, 0x96, 0xD7, 0x4C, 0x3B, 0xA6, 0x4E, + 0xC7, 0x94, 0x11, 0x7E, 0x0C, 0xB4, 0xCF, 0x61 + }, + { + 0x3A, 0xC9, 0x41, 0xD4, 0x6D, 0xD0, 0xE1, 0xF3, + 0x3B, 0x9F, 0x45, 0xC1, 0x63, 0x50, 0xAF, 0xB4, + 0xF7, 0xB6, 0xAF, 0x3C, 0x97, 0xC5, 0x19, 0xDC, + 0x59, 0x94, 0xE1, 0x95, 0xA3, 0xE0, 0x7F, 0xEE, + 0xF2, 0x9A, 0xBA, 0x45, 0x1D, 0x73, 0x61, 0xDB, + 0x81, 0x4E, 0x61, 0xFD, 0x8B, 0x9C, 0x07, 0xF5, + 0xF0, 0xBB, 0x3E, 0xEA, 0x33, 0xD1, 0x4D, 0xDE, + 0xF2, 0x4E, 0x1A, 0xBD, 0xA8, 0xE0, 0x3C, 0x39 + }, + { + 0x7E, 0x0B, 0x03, 0xB9, 0xB5, 0x8B, 0x89, 0xCC, + 0xAD, 0xCB, 0xB1, 0xF8, 0x81, 0x3D, 0x3F, 0x15, + 0xAD, 0xA1, 0xFB, 0x74, 0x7F, 0x93, 0xA7, 0xBB, + 0x4F, 0x8A, 0xA0, 0x39, 0x88, 0x5D, 0x99, 0xBD, + 0x59, 0xFB, 0xA4, 0xE7, 0x4D, 0x4B, 0x36, 0x32, + 0xBC, 0x5C, 0x06, 0xCE, 0x98, 0xAE, 0x73, 0x85, + 0xA0, 0x08, 0xE2, 0xF8, 0x83, 0x31, 0xE5, 0x24, + 0x7C, 0x46, 0x90, 0x31, 0x51, 0xDF, 0xD0, 0x8B + }, + { + 0xB2, 0xF6, 0x38, 0x36, 0x28, 0x21, 0xB9, 0xC6, + 0x72, 0x92, 0xA7, 0x95, 0xCF, 0x2C, 0xBC, 0x23, + 0x5C, 0x1B, 0xD9, 0x6C, 0x0C, 0x95, 0xF9, 0x42, + 0xED, 0x6D, 0xB0, 0x75, 0xE6, 0xEE, 0xC0, 0x4F, + 0x1C, 0x6C, 0xF8, 0x12, 0xAE, 0x2E, 0x57, 0x41, + 0xF4, 0xB9, 0x21, 0x62, 0x5A, 0xD5, 0xC9, 0xB9, + 0x2A, 0x96, 0xDB, 0x30, 0x29, 0x5D, 0x22, 0x3F, + 0xE2, 0x1B, 0x29, 0xFF, 0x96, 0x18, 0x1B, 0x9C + }, + { + 0x73, 0xE8, 0x21, 0x69, 0x29, 0x54, 0xC3, 0x0D, + 0x70, 0xE0, 0xFC, 0xC5, 0x35, 0x11, 0x07, 0x0C, + 0x77, 0xF3, 0x69, 0x65, 0x51, 0x73, 0x59, 0xD6, + 0x17, 0xE9, 0x4E, 0x3E, 0xF9, 0x69, 0x6D, 0x38, + 0x5F, 0x14, 0x69, 0xFA, 0x53, 0x18, 0xA3, 0x5B, + 0x94, 0x00, 0xC4, 0x86, 0x80, 0xBB, 0xBA, 0x54, + 0x97, 0x65, 0xF4, 0xBF, 0x35, 0x11, 0xC4, 0xFC, + 0xB6, 0xE4, 0x4F, 0x4F, 0xCA, 0xA5, 0x9D, 0x21 + }, + { + 0x12, 0xFC, 0xC1, 0xD3, 0x60, 0xF2, 0xD3, 0x4C, + 0x6E, 0x15, 0x3F, 0x9A, 0x57, 0x87, 0x02, 0xDB, + 0xC6, 0xB5, 0x2F, 0xDF, 0x34, 0xCE, 0x01, 0x46, + 0x6E, 0x22, 0xA6, 0xE6, 0x05, 0x6E, 0xDD, 0xF4, + 0x01, 0x5F, 0xD1, 0x15, 0xF9, 0xBA, 0x8D, 0x10, + 0xCF, 0x8C, 0xCB, 0x1A, 0x5F, 0x81, 0xF4, 0x8A, + 0x4A, 0x63, 0x35, 0x77, 0x90, 0xA5, 0x8C, 0xEE, + 0x61, 0xC0, 0x3D, 0xA4, 0x5B, 0xE3, 0x6F, 0xF6 + }, + { + 0x6C, 0xC4, 0x5F, 0x5A, 0xD6, 0xF4, 0x70, 0x89, + 0xE7, 0x9D, 0x2D, 0xCF, 0x21, 0x30, 0x8C, 0x76, + 0xA5, 0xC7, 0x38, 0x7C, 0xBA, 0xCB, 0xF6, 0x12, + 0x42, 0xAE, 0x49, 0x49, 0x02, 0xC5, 0xEA, 0x99, + 0x0E, 0x61, 0xC7, 0xC9, 0xD7, 0x8E, 0x51, 0x0E, + 0x32, 0xB7, 0xC4, 0x15, 0x32, 0x33, 0x1C, 0x67, + 0xB7, 0xFF, 0x1B, 0xB3, 0xD6, 0x3E, 0x1A, 0x58, + 0xE3, 0x22, 0x85, 0x06, 0xF5, 0xA5, 0x00, 0x07 + }, + { + 0xD2, 0x4B, 0xF4, 0x64, 0xC2, 0x2D, 0x73, 0x64, + 0x33, 0xF6, 0xC6, 0x31, 0x86, 0x35, 0xDA, 0x62, + 0xE2, 0xEC, 0x10, 0xB8, 0x78, 0x34, 0x93, 0x00, + 0x8A, 0xC2, 0x69, 0x92, 0x8F, 0x64, 0x49, 0x0E, + 0x3E, 0x78, 0xBE, 0xF1, 0xD3, 0xC4, 0x0A, 0x80, + 0x3B, 0xBE, 0xDB, 0x93, 0xDD, 0x3F, 0x8F, 0x49, + 0xAC, 0xF1, 0xEF, 0x50, 0x26, 0xDA, 0x06, 0x76, + 0x04, 0x15, 0xDB, 0x0F, 0x6C, 0x0F, 0xC8, 0x98 + }, + { + 0x04, 0x97, 0xD8, 0x3E, 0xBE, 0x59, 0x0A, 0xDD, + 0x7C, 0x33, 0x1C, 0xE7, 0xE2, 0x9D, 0x07, 0x40, + 0x26, 0x2A, 0xC5, 0x4F, 0x3B, 0xFC, 0xD0, 0x52, + 0x2F, 0x82, 0x7F, 0xE6, 0xDC, 0x32, 0xAA, 0x6D, + 0xA7, 0x86, 0x1B, 0x2F, 0xF5, 0xB2, 0x57, 0xCD, + 0x84, 0x84, 0xCF, 0x00, 0x6D, 0xFA, 0xFC, 0xD1, + 0x27, 0xE6, 0x32, 0x2A, 0x4E, 0x4A, 0x01, 0x54, + 0x34, 0x66, 0x6A, 0x72, 0xD7, 0x96, 0x2D, 0xC9 + }, + { + 0xAD, 0xF9, 0x88, 0xB9, 0xC7, 0x3E, 0x40, 0x25, + 0xDE, 0x8B, 0x21, 0xF8, 0x30, 0x1B, 0x7F, 0x7A, + 0x94, 0xE5, 0xB8, 0xA0, 0x43, 0x8C, 0xC1, 0x87, + 0x76, 0x7D, 0xDE, 0xA1, 0x25, 0xF3, 0x82, 0xBD, + 0xB0, 0x76, 0x91, 0x69, 0x78, 0x9B, 0x9E, 0xE1, + 0x5D, 0xE2, 0xF1, 0xB4, 0x58, 0xA3, 0xBC, 0x85, + 0xBE, 0xA0, 0x54, 0x89, 0x23, 0xEA, 0xEE, 0x6C, + 0xBC, 0x78, 0x5C, 0x86, 0xE9, 0x47, 0x68, 0x05 + }, + { + 0x13, 0x54, 0x09, 0x66, 0x8F, 0x4D, 0x8A, 0x55, + 0x05, 0x4E, 0x45, 0xC6, 0x95, 0xBB, 0xBC, 0xC2, + 0x19, 0x06, 0x78, 0x85, 0xC9, 0xBA, 0x1B, 0xF8, + 0x3C, 0x20, 0xD5, 0x4F, 0xEE, 0x3D, 0xD1, 0xA7, + 0x85, 0x20, 0xA7, 0x3D, 0x45, 0x00, 0x41, 0xB7, + 0xA1, 0xCA, 0xDE, 0xDD, 0x75, 0xF4, 0xFD, 0x55, + 0x7B, 0x1B, 0xB9, 0x1E, 0x23, 0x0A, 0x74, 0xD5, + 0xC0, 0xB7, 0x65, 0x6F, 0x1D, 0x63, 0x99, 0xD4 + }, + { + 0x80, 0x3C, 0x9B, 0xA6, 0x8D, 0x22, 0xBD, 0xDE, + 0x9C, 0x35, 0x9F, 0xFB, 0x90, 0xDC, 0x0F, 0x09, + 0xD3, 0x88, 0xEB, 0x41, 0x64, 0x07, 0x4B, 0x37, + 0x91, 0x99, 0x76, 0x61, 0xB7, 0xEB, 0x0D, 0xB4, + 0xBD, 0x46, 0x91, 0x37, 0xD8, 0xFF, 0xC6, 0xEA, + 0x39, 0xE4, 0x47, 0x93, 0x9A, 0x9C, 0xFB, 0xAF, + 0x59, 0xE1, 0x0B, 0x00, 0xE7, 0x80, 0x7F, 0x77, + 0x97, 0xFC, 0xD2, 0xA9, 0xB4, 0x07, 0x03, 0xBA + }, + { + 0xB4, 0xFD, 0x64, 0x73, 0xE0, 0x33, 0xA1, 0x93, + 0x19, 0xC3, 0x9E, 0x78, 0x20, 0x50, 0xC5, 0xA2, + 0x3B, 0x68, 0xE1, 0x01, 0x3E, 0x76, 0xBE, 0x82, + 0xF6, 0x3E, 0x25, 0x90, 0x2A, 0x36, 0x54, 0x30, + 0x65, 0x94, 0x53, 0x25, 0x1B, 0x56, 0x9A, 0x24, + 0x87, 0x98, 0xC0, 0xD6, 0xD1, 0xBE, 0x8F, 0xB8, + 0xB6, 0xA9, 0x6B, 0xC5, 0x4D, 0x32, 0x2A, 0xE7, + 0x6C, 0x20, 0x2E, 0xC4, 0x6D, 0xA2, 0xF4, 0xDC + }, + { + 0xC9, 0xFE, 0x6D, 0x5A, 0xB3, 0x38, 0x0B, 0x6E, + 0xD3, 0xFA, 0x55, 0x27, 0x5E, 0x40, 0xB1, 0x4A, + 0x52, 0x28, 0x03, 0x34, 0xCF, 0x8B, 0xDE, 0x48, + 0xD6, 0x25, 0x92, 0xA9, 0x3D, 0x76, 0x4F, 0x0E, + 0xA8, 0x7E, 0xA8, 0x63, 0x18, 0x5A, 0xA3, 0x78, + 0x98, 0xE1, 0xAD, 0x39, 0x4A, 0xA5, 0xD7, 0xAA, + 0x4F, 0xF3, 0x1D, 0x23, 0x7D, 0x4C, 0x82, 0x25, + 0xA4, 0x5E, 0x48, 0x75, 0x60, 0xBF, 0xF9, 0xA9 + }, + { + 0xD3, 0x2A, 0x51, 0xED, 0xF3, 0x3C, 0x63, 0x6C, + 0x18, 0x15, 0xD7, 0x0A, 0xEA, 0x53, 0x98, 0x80, + 0xF7, 0xCC, 0xEE, 0x06, 0x8D, 0x5F, 0x7F, 0x20, + 0x97, 0xD7, 0xAF, 0x74, 0x8E, 0x5E, 0xE5, 0x81, + 0x70, 0xC8, 0x5A, 0x55, 0x1A, 0xAF, 0x68, 0x7C, + 0x27, 0xC7, 0x36, 0x71, 0xC6, 0x58, 0xF7, 0xB6, + 0x0C, 0xC0, 0xBF, 0x07, 0xC0, 0x2C, 0x53, 0x98, + 0xFB, 0x56, 0xB3, 0xF7, 0xE2, 0xF1, 0x34, 0x0F + }, + { + 0x6A, 0x2A, 0x17, 0x23, 0xD3, 0xCF, 0xC4, 0xE4, + 0xAE, 0x1E, 0x31, 0x8F, 0x50, 0xC4, 0x93, 0x94, + 0xCB, 0xB8, 0x20, 0x37, 0x68, 0x5C, 0x39, 0x8F, + 0x2B, 0x82, 0xC9, 0xA9, 0x93, 0x00, 0xE6, 0x86, + 0x23, 0x70, 0x8E, 0xA3, 0xA3, 0xDA, 0x05, 0x49, + 0x90, 0x97, 0xDB, 0x79, 0x91, 0xC2, 0x07, 0x97, + 0xFF, 0x73, 0x91, 0x66, 0x10, 0xC8, 0xDD, 0xD6, + 0xFD, 0x83, 0x05, 0xAE, 0x66, 0x94, 0xA4, 0xD3 + }, + { + 0x5D, 0xDF, 0xDF, 0x17, 0xA2, 0x28, 0xA9, 0xA7, + 0x40, 0xE8, 0xEA, 0x68, 0xDC, 0x59, 0x45, 0x77, + 0x59, 0x30, 0x94, 0x9E, 0xE7, 0xA8, 0x6B, 0x5A, + 0x18, 0xB5, 0x1A, 0x58, 0x28, 0x9E, 0x0A, 0x99, + 0x93, 0xC5, 0xD4, 0xB4, 0x18, 0xA5, 0x1B, 0x6F, + 0xC5, 0x9D, 0x28, 0x4C, 0xBD, 0x29, 0xC7, 0xBC, + 0x44, 0x07, 0x48, 0x21, 0x05, 0x42, 0x6D, 0x64, + 0xCF, 0x0C, 0x8B, 0xAA, 0x64, 0x30, 0x28, 0x89 + }, + { + 0x05, 0x68, 0xF8, 0x8A, 0x61, 0x0B, 0x2F, 0x4F, + 0x8C, 0x4E, 0x07, 0x41, 0xEB, 0x8B, 0x98, 0x98, + 0x93, 0x9F, 0xF6, 0x0C, 0xB7, 0xA7, 0x40, 0xEF, + 0xE5, 0x84, 0x37, 0xF4, 0x1C, 0x4A, 0x38, 0xD7, + 0x25, 0x97, 0xCD, 0x3C, 0x81, 0x57, 0xE6, 0x2B, + 0xA8, 0xE7, 0xA4, 0xA0, 0xB0, 0xB8, 0x5A, 0xC8, + 0x86, 0xF3, 0x79, 0xC9, 0xD6, 0x96, 0x72, 0x1D, + 0xC7, 0xF0, 0x72, 0x8A, 0xD8, 0x9B, 0x24, 0x0F + }, + { + 0x9D, 0xA3, 0xCC, 0x62, 0xC9, 0x5A, 0xCF, 0xF0, + 0x1E, 0x08, 0xBC, 0xC5, 0x93, 0xEC, 0x9F, 0x1E, + 0xAE, 0x3F, 0x44, 0x04, 0x18, 0xFD, 0x45, 0xEA, + 0xE1, 0x30, 0xB8, 0x81, 0xA0, 0xD3, 0xB9, 0xE3, + 0x93, 0x34, 0xCF, 0x0C, 0x66, 0xCC, 0xD7, 0xC9, + 0x0F, 0xDC, 0x72, 0xAA, 0x27, 0x14, 0xFD, 0x80, + 0x9C, 0x04, 0x1D, 0xCF, 0xDB, 0x5D, 0x28, 0x4C, + 0xF4, 0x46, 0x1E, 0x87, 0x8D, 0x38, 0x64, 0xDB + }, + { + 0xF8, 0x27, 0x39, 0x32, 0xF7, 0xAE, 0x71, 0x54, + 0x61, 0xD7, 0x7E, 0x82, 0xE3, 0x73, 0x2A, 0xB7, + 0x92, 0x12, 0xC4, 0x1C, 0x47, 0x1C, 0x0D, 0xCD, + 0xEA, 0x01, 0x87, 0xED, 0x78, 0x6D, 0x3B, 0xDC, + 0xAF, 0x1D, 0xA4, 0xBF, 0x38, 0x97, 0xA7, 0x77, + 0x90, 0xFC, 0x46, 0x59, 0xCE, 0x3B, 0xE2, 0xFA, + 0x3D, 0xE5, 0xA0, 0x9E, 0xFE, 0x15, 0xE7, 0xD4, + 0xDD, 0x69, 0xA9, 0x56, 0x90, 0xB8, 0x06, 0xAD + }, + { + 0xDF, 0xF5, 0x5F, 0x41, 0xDF, 0x47, 0xB1, 0x5F, + 0x9C, 0xB2, 0x51, 0xC9, 0xB4, 0x3C, 0x4F, 0xA2, + 0x50, 0xEE, 0xC4, 0x67, 0x8C, 0x99, 0x66, 0xEE, + 0x4A, 0xB5, 0x9D, 0xF9, 0x0F, 0x45, 0xF0, 0xF6, + 0x63, 0x2C, 0xC4, 0x4E, 0xE2, 0xCA, 0xA8, 0x89, + 0x4E, 0xD7, 0x32, 0x7C, 0x04, 0xFC, 0x55, 0x1D, + 0x1A, 0x81, 0x6F, 0xA4, 0xFD, 0xEA, 0x34, 0x12, + 0x2E, 0x90, 0x40, 0xAE, 0xC9, 0x96, 0x84, 0x58 + }, + { + 0xAA, 0x07, 0x16, 0x30, 0xBC, 0x76, 0xBD, 0x8E, + 0xE7, 0x85, 0x85, 0x16, 0xA0, 0x45, 0xD7, 0x95, + 0x9F, 0xC9, 0x58, 0x55, 0xC0, 0xA8, 0xE6, 0xB5, + 0x4C, 0x28, 0xCB, 0x82, 0x85, 0xB4, 0x61, 0x24, + 0x7D, 0x29, 0x80, 0x9B, 0x67, 0x87, 0x3F, 0xAE, + 0x86, 0xD4, 0x3A, 0x8E, 0x2C, 0x6A, 0x55, 0xAF, + 0x8F, 0xF6, 0x30, 0x8C, 0xBD, 0x38, 0x02, 0x42, + 0xF1, 0x95, 0xA7, 0x3D, 0x4F, 0x9E, 0xD7, 0x45 + }, + { + 0xF1, 0x9F, 0xB2, 0xEA, 0x63, 0x09, 0xAE, 0x31, + 0xA7, 0xC3, 0xAE, 0x36, 0xD8, 0x09, 0x7E, 0x28, + 0x70, 0x2A, 0xFC, 0x80, 0x49, 0xFC, 0x4D, 0x57, + 0xC8, 0xAD, 0x06, 0xAC, 0xBC, 0x3B, 0x20, 0xB1, + 0x01, 0xEB, 0x3D, 0x0F, 0x9F, 0x10, 0x22, 0xB1, + 0x91, 0xCD, 0x18, 0xC7, 0xFE, 0x1C, 0x3B, 0x45, + 0x16, 0xE0, 0x7D, 0x30, 0x4A, 0x9A, 0x7D, 0x4A, + 0x30, 0x7A, 0x44, 0x5F, 0x1B, 0x69, 0xE1, 0xBD + }, + { + 0x3B, 0x18, 0x3F, 0xB1, 0x65, 0xC0, 0xFD, 0xD0, + 0xF7, 0x84, 0xEC, 0x47, 0xB8, 0x04, 0xCF, 0x00, + 0xF4, 0x51, 0xA2, 0x64, 0x73, 0xD7, 0xD9, 0xE6, + 0x27, 0x38, 0x89, 0x87, 0x5C, 0x96, 0xD2, 0x6E, + 0x18, 0x0C, 0x87, 0x7A, 0xB0, 0xEB, 0x65, 0x5B, + 0xE2, 0xB2, 0x31, 0x16, 0xE1, 0xA5, 0x62, 0x59, + 0x84, 0x3F, 0xA5, 0x6F, 0xE2, 0x05, 0x4E, 0xBB, + 0x89, 0xA0, 0xBF, 0xF5, 0xAE, 0x52, 0x41, 0x0A + }, + { + 0x2F, 0x9C, 0xAA, 0x4E, 0xC8, 0x1D, 0x6D, 0x3A, + 0xAA, 0x68, 0xC0, 0xE9, 0x43, 0x00, 0x39, 0x56, + 0xFF, 0x18, 0x78, 0x96, 0x24, 0x4D, 0x2D, 0x5E, + 0x6E, 0x09, 0xFC, 0x32, 0x1E, 0x7A, 0x39, 0x91, + 0xF1, 0x37, 0x4B, 0x6C, 0xA6, 0x82, 0x17, 0xA2, + 0x1C, 0x2D, 0x93, 0x92, 0x6E, 0xC9, 0x9A, 0x79, + 0x4E, 0xD8, 0x81, 0xD9, 0x53, 0x19, 0x3A, 0x8D, + 0xF9, 0x58, 0xF8, 0x64, 0x0F, 0x3B, 0x64, 0xD0 + }, + { + 0x40, 0xB4, 0x2E, 0xC4, 0xA0, 0xF0, 0x24, 0xD0, + 0x21, 0x41, 0xD3, 0x4A, 0x98, 0x16, 0x73, 0x24, + 0xE2, 0x60, 0xB7, 0xD3, 0x02, 0x43, 0x55, 0x82, + 0x3B, 0xCC, 0x4F, 0x05, 0xC5, 0x32, 0x53, 0x8D, + 0x83, 0xA3, 0xAD, 0x2A, 0xC1, 0xAB, 0x2F, 0x7F, + 0x0B, 0x4D, 0x1D, 0x77, 0xBB, 0x61, 0x74, 0x6E, + 0x26, 0xEE, 0x74, 0xEC, 0x22, 0x7B, 0x53, 0x46, + 0xEB, 0x64, 0x10, 0x1A, 0xF9, 0xAE, 0x8C, 0xC8 + }, + { + 0x97, 0x68, 0x06, 0x6B, 0x7A, 0xA4, 0x31, 0xB9, + 0x8A, 0xCD, 0x64, 0xA5, 0x12, 0x77, 0xF9, 0x2C, + 0xDA, 0x4F, 0x11, 0x6C, 0x0E, 0x39, 0x51, 0x0A, + 0xEE, 0x19, 0xC7, 0xD7, 0x29, 0xCA, 0x9B, 0x32, + 0x75, 0x6F, 0x30, 0xC6, 0x48, 0x5E, 0xFE, 0x44, + 0x10, 0xCE, 0x14, 0xD6, 0xFF, 0xB2, 0xBC, 0x44, + 0xB1, 0x5F, 0xA9, 0x0D, 0xD6, 0xCC, 0x71, 0x39, + 0xFA, 0xA9, 0x7C, 0xB5, 0xA4, 0xA2, 0xF6, 0x74 + }, + { + 0x2B, 0x43, 0xA9, 0x89, 0x36, 0x98, 0x53, 0x0D, + 0x1C, 0x8E, 0x46, 0x81, 0x7B, 0x09, 0x54, 0xEF, + 0xB0, 0xF3, 0xB2, 0x6D, 0xE2, 0xBA, 0x78, 0x30, + 0x28, 0x53, 0xC6, 0xD3, 0x24, 0x88, 0x4A, 0xB8, + 0x0D, 0xFF, 0xFB, 0x0C, 0xF4, 0xE4, 0x93, 0xBF, + 0x15, 0x61, 0xDB, 0x1E, 0x93, 0x83, 0x8C, 0x96, + 0x63, 0xFA, 0xE1, 0xD8, 0x00, 0x35, 0x7C, 0x60, + 0x0F, 0x63, 0x38, 0x57, 0xAD, 0x49, 0xCF, 0xE0 + }, + { + 0x14, 0xE1, 0xAD, 0xAF, 0x85, 0x5B, 0x06, 0xB9, + 0xA0, 0xD9, 0x7D, 0x36, 0xBF, 0x16, 0x7F, 0xAE, + 0xC5, 0xC0, 0xAE, 0x0A, 0x60, 0x27, 0xE4, 0xCF, + 0x4F, 0x4A, 0xDE, 0x8E, 0x40, 0x13, 0x55, 0x6F, + 0x87, 0x2B, 0xD5, 0xDA, 0x12, 0xDD, 0xE6, 0x1D, + 0x75, 0x31, 0x47, 0xDE, 0x08, 0xA6, 0xEA, 0x96, + 0x09, 0x8C, 0x48, 0xA0, 0xFC, 0xA2, 0x98, 0x22, + 0xE2, 0x4C, 0x80, 0xA9, 0xEA, 0xD6, 0xA2, 0x94 + }, + { + 0x9D, 0x50, 0x4F, 0x30, 0x2F, 0xC0, 0x1F, 0x04, + 0x21, 0x56, 0x36, 0xFA, 0xEF, 0x19, 0x41, 0xB8, + 0x9D, 0x17, 0x9B, 0x0B, 0x1D, 0x7C, 0x0F, 0xCB, + 0x5C, 0x06, 0x46, 0x14, 0xC4, 0x33, 0xA2, 0x93, + 0x93, 0x64, 0xA2, 0xAE, 0xF9, 0x39, 0xF7, 0x94, + 0x9F, 0xCC, 0x94, 0x20, 0xE2, 0x35, 0x54, 0x10, + 0x42, 0xAB, 0xD7, 0xBC, 0x4F, 0x89, 0x67, 0x36, + 0xE8, 0x5B, 0xF0, 0x1B, 0xCC, 0x64, 0x49, 0x86 + }, + { + 0x3A, 0x64, 0x2F, 0xC3, 0x97, 0x64, 0xCB, 0x12, + 0x99, 0x95, 0x94, 0xA2, 0x88, 0x32, 0xEE, 0xA0, + 0x50, 0xFE, 0x70, 0x68, 0x96, 0x18, 0x61, 0x80, + 0xF1, 0x9F, 0x04, 0x0F, 0x24, 0x43, 0xD8, 0x59, + 0x5B, 0xA2, 0x02, 0xCD, 0x33, 0x2D, 0x3E, 0x7C, + 0xA6, 0x65, 0x31, 0xBE, 0x20, 0x6B, 0xBA, 0xA1, + 0xDA, 0xD7, 0x96, 0x18, 0x75, 0xFC, 0xE7, 0xE4, + 0xB6, 0xCA, 0x9E, 0x70, 0xA3, 0x50, 0x59, 0x3D + }, + { + 0x11, 0xFA, 0x7A, 0x5E, 0x44, 0xEC, 0xB7, 0xF9, + 0x7E, 0xA0, 0xA4, 0x8C, 0x97, 0xBB, 0x49, 0x39, + 0x4A, 0x6E, 0x81, 0x60, 0xC7, 0x03, 0xD1, 0xBE, + 0x9D, 0x13, 0xE7, 0xE2, 0x10, 0xAD, 0x83, 0x46, + 0xA6, 0x3D, 0x18, 0x3D, 0x14, 0x8B, 0xD0, 0x4F, + 0x30, 0xE8, 0x6D, 0xB5, 0x85, 0xF8, 0xB7, 0x27, + 0x6C, 0x46, 0x86, 0x4D, 0x68, 0x5A, 0x05, 0x6F, + 0x29, 0xA0, 0x90, 0x61, 0xFC, 0xA6, 0xF5, 0x8A + }, + { + 0xAA, 0x1B, 0x81, 0xC7, 0xDC, 0xE6, 0xDA, 0x3C, + 0x14, 0x65, 0x27, 0xD6, 0x2D, 0xC7, 0xEB, 0x27, + 0xDC, 0x8A, 0x4B, 0xF4, 0xAF, 0x60, 0x9F, 0x46, + 0x0A, 0x3F, 0x03, 0x7E, 0xFC, 0x23, 0x59, 0x32, + 0xC4, 0xA8, 0x1B, 0x0D, 0xE4, 0x12, 0x53, 0xEF, + 0x74, 0x28, 0xAB, 0x29, 0x8C, 0x33, 0x03, 0x1B, + 0xAF, 0x85, 0xF8, 0x08, 0xED, 0x23, 0x67, 0x3D, + 0x15, 0x54, 0x6B, 0xE1, 0x45, 0x44, 0xA2, 0xEF + }, + { + 0xCC, 0x85, 0x9B, 0x06, 0x6C, 0xF9, 0xE5, 0x08, + 0x21, 0x57, 0x62, 0x25, 0x51, 0x29, 0x94, 0xE3, + 0x64, 0x8E, 0xDE, 0x30, 0x12, 0x2F, 0xEC, 0x79, + 0xF1, 0x8E, 0x3E, 0x55, 0x73, 0xEE, 0x89, 0x94, + 0xCC, 0x8D, 0xF5, 0xF5, 0xBF, 0x68, 0x98, 0x73, + 0x45, 0xF0, 0x89, 0x79, 0x75, 0xD3, 0xA0, 0xA5, + 0x3A, 0x9C, 0x9C, 0x71, 0xC1, 0x02, 0x98, 0x77, + 0xF3, 0xC3, 0x1F, 0xC0, 0x73, 0x19, 0xDE, 0x58 + }, + { + 0x2D, 0x55, 0xC3, 0x92, 0x31, 0x74, 0xE6, 0x4B, + 0x94, 0x9B, 0x74, 0xBB, 0xAA, 0xCE, 0x78, 0xAE, + 0xB3, 0x59, 0x2D, 0xBB, 0xED, 0xCC, 0x30, 0x2A, + 0xF5, 0xA8, 0x3D, 0xF2, 0xE7, 0xBE, 0xC4, 0xDA, + 0xFE, 0x45, 0xCA, 0x74, 0xC3, 0x54, 0x92, 0x9B, + 0x5E, 0x9B, 0xB2, 0x3E, 0x70, 0xDD, 0x51, 0x3D, + 0xFB, 0xC6, 0x7D, 0xF0, 0x89, 0x1D, 0x76, 0xE1, + 0x4B, 0xBE, 0x60, 0xC1, 0x8A, 0xE6, 0xFC, 0x49 + }, + { + 0x0B, 0x8E, 0xF0, 0x74, 0x07, 0x0A, 0x79, 0x50, + 0x6B, 0x49, 0xB1, 0xC9, 0xF5, 0x7E, 0x2C, 0x41, + 0x53, 0x5A, 0x36, 0xA1, 0xF9, 0x2C, 0xFD, 0x18, + 0x31, 0xE0, 0x61, 0xE1, 0x6E, 0x4F, 0x46, 0x83, + 0xF3, 0xC3, 0x7E, 0x0A, 0xDD, 0x10, 0xC9, 0x58, + 0xCE, 0xB3, 0x94, 0xF3, 0x25, 0xC7, 0x10, 0x4C, + 0x30, 0x8B, 0x68, 0x8A, 0x08, 0x46, 0x9B, 0x53, + 0x50, 0x39, 0x72, 0x8E, 0xDA, 0x89, 0x23, 0x37 + }, + { + 0x24, 0x57, 0x12, 0xC0, 0xB8, 0x4B, 0x6C, 0xF9, + 0x52, 0x40, 0xFB, 0x28, 0x52, 0x83, 0xF9, 0xA6, + 0x37, 0x83, 0x3B, 0xBE, 0x58, 0x17, 0xAA, 0x2C, + 0xCB, 0x6D, 0x63, 0xCA, 0x34, 0xB2, 0xAC, 0x27, + 0x6E, 0xF8, 0xB0, 0x70, 0x91, 0xE5, 0x09, 0x93, + 0x09, 0x70, 0x7A, 0x0D, 0x4E, 0x6B, 0x42, 0xC9, + 0x21, 0x5F, 0x23, 0x9A, 0x6F, 0xFF, 0xAE, 0xC4, + 0x1A, 0x8A, 0x07, 0x26, 0x56, 0x6A, 0xBA, 0x61 + }, + { + 0xBD, 0x52, 0x90, 0xC4, 0xE0, 0xF9, 0x0D, 0xE8, + 0x2F, 0x7B, 0x15, 0x8B, 0xC7, 0x8C, 0x0B, 0x16, + 0x17, 0x54, 0x49, 0x5F, 0x6A, 0x66, 0x96, 0x44, + 0x21, 0x00, 0x3E, 0xA0, 0xE2, 0x5D, 0x62, 0x71, + 0xFE, 0x96, 0xB9, 0x67, 0xCC, 0xA6, 0xA9, 0xB9, + 0x1F, 0xDC, 0x1B, 0x92, 0x7C, 0x70, 0x78, 0xC3, + 0x90, 0xAD, 0xD5, 0x1D, 0x5C, 0xE4, 0x4D, 0xA3, + 0x4E, 0x6E, 0x26, 0x06, 0xFA, 0xDD, 0xE8, 0x13 + }, + { + 0xA6, 0x00, 0x6E, 0xF5, 0x07, 0x21, 0x17, 0x15, + 0xC1, 0xD6, 0xD3, 0x4F, 0x1E, 0xC1, 0x64, 0x21, + 0xA0, 0x3E, 0xFB, 0x75, 0xCF, 0xD4, 0xB8, 0xCD, + 0xE8, 0x1F, 0x0D, 0x14, 0x10, 0xB2, 0xEC, 0xE0, + 0x37, 0xCB, 0x3A, 0x3D, 0xAD, 0x14, 0x85, 0x2B, + 0x78, 0x2E, 0x2F, 0x9A, 0x9D, 0x20, 0xCD, 0x5B, + 0xC3, 0x4A, 0x76, 0xF4, 0xAC, 0xB8, 0x33, 0xDC, + 0xD2, 0xA7, 0xC8, 0x0D, 0xA2, 0x75, 0xAD, 0xE4 + }, + { + 0xB1, 0x3B, 0x1F, 0xC5, 0x8C, 0x18, 0xDF, 0x1E, + 0x80, 0x5D, 0xE6, 0x3F, 0xEB, 0xE4, 0x7A, 0x83, + 0x9D, 0x94, 0x52, 0x95, 0x40, 0xF4, 0xA1, 0xC6, + 0xA2, 0x4C, 0x21, 0xEA, 0xAE, 0x6D, 0x5A, 0xCF, + 0x53, 0xF2, 0x07, 0x43, 0x16, 0xF4, 0xBA, 0x40, + 0x2A, 0x6C, 0xE1, 0x79, 0x0D, 0xB6, 0x21, 0xD3, + 0x33, 0x1F, 0x05, 0x7D, 0x35, 0x1F, 0x18, 0xCE, + 0x0C, 0xC0, 0x53, 0xB7, 0x03, 0x15, 0xAC, 0x20 + }, + { + 0xA0, 0x62, 0x50, 0xA3, 0x71, 0x2B, 0xBD, 0x12, + 0xD9, 0xA7, 0x01, 0xF4, 0xB1, 0x6F, 0x2A, 0xEC, + 0xC6, 0xC9, 0x48, 0x82, 0x58, 0x83, 0xE2, 0x8E, + 0xA0, 0x9F, 0xF4, 0x95, 0x46, 0x20, 0x91, 0xD3, + 0xA1, 0xC4, 0xB4, 0xED, 0xBD, 0xDF, 0x16, 0xE0, + 0x15, 0x74, 0x5D, 0x39, 0x10, 0x5F, 0x44, 0x7D, + 0x6E, 0xAB, 0x11, 0x09, 0xE3, 0x88, 0xE4, 0x2E, + 0xCF, 0x14, 0x68, 0x02, 0x14, 0x38, 0x6B, 0x26 + }, + { + 0x2A, 0x48, 0x92, 0x57, 0x3F, 0x51, 0x0E, 0x40, + 0x80, 0x18, 0x91, 0xCD, 0x8F, 0x59, 0x41, 0x05, + 0x72, 0x65, 0x91, 0xDA, 0x73, 0x6D, 0xB1, 0xB0, + 0x00, 0xD1, 0x2D, 0xE8, 0x0E, 0xA1, 0x91, 0xA6, + 0xFC, 0xCC, 0xD9, 0xE5, 0x81, 0xA1, 0xA5, 0x0E, + 0x24, 0x44, 0xE5, 0xFD, 0xBE, 0xE5, 0xE1, 0x29, + 0xD1, 0xCD, 0x66, 0xCE, 0x3C, 0xA5, 0xA0, 0x6B, + 0x61, 0x37, 0xBE, 0xB5, 0x90, 0xEA, 0xBF, 0x97 + }, + { + 0x28, 0x62, 0x2C, 0xD0, 0x48, 0x59, 0x8E, 0xB3, + 0x5B, 0x61, 0xDD, 0x67, 0x5D, 0x11, 0xDC, 0x3A, + 0x0E, 0xC6, 0x72, 0xE7, 0x12, 0x76, 0x6F, 0xD4, + 0xFD, 0x6A, 0x39, 0xB6, 0x43, 0xF7, 0xE7, 0x9B, + 0x13, 0xAB, 0xEC, 0x19, 0xB4, 0x0E, 0x95, 0x7C, + 0xE7, 0x79, 0x1D, 0xF3, 0xA9, 0x7E, 0x68, 0x29, + 0x9E, 0xE3, 0x19, 0x17, 0x12, 0x8A, 0xF3, 0xF2, + 0x19, 0x3F, 0x42, 0x61, 0xA2, 0x05, 0xB8, 0x92 + }, + { + 0x4D, 0x59, 0xDE, 0xD7, 0xE9, 0xCD, 0xC2, 0x4A, + 0xDD, 0xF0, 0xAE, 0xB4, 0xFA, 0x05, 0xD3, 0x58, + 0xD8, 0x39, 0xEC, 0xBA, 0x71, 0xB9, 0x5A, 0x40, + 0xB7, 0xA8, 0xE1, 0xF2, 0x92, 0xB3, 0x94, 0xD7, + 0x03, 0xBB, 0x8E, 0x74, 0xB3, 0xDB, 0xEA, 0x21, + 0xF5, 0x96, 0x0D, 0xCE, 0x72, 0x9E, 0x76, 0x74, + 0x62, 0x81, 0x00, 0x90, 0xF9, 0x61, 0x36, 0xB2, + 0x75, 0x0D, 0x34, 0x73, 0x54, 0x33, 0x6F, 0x62 + }, + { + 0x7D, 0x81, 0xC6, 0x28, 0x19, 0x19, 0x8D, 0x44, + 0x96, 0x4C, 0x81, 0x31, 0x96, 0xA2, 0x83, 0xC5, + 0x91, 0x57, 0x66, 0xDD, 0x54, 0x97, 0xE3, 0x3D, + 0xEB, 0x13, 0xE1, 0x04, 0x6E, 0xF2, 0x8B, 0x90, + 0x3E, 0x45, 0xA3, 0x8A, 0x57, 0x52, 0xF8, 0x3A, + 0x90, 0x17, 0x97, 0x18, 0xDA, 0x91, 0xC7, 0x3F, + 0x2A, 0xCB, 0x7A, 0x26, 0x67, 0xC5, 0x0A, 0x86, + 0xAD, 0x7F, 0x8E, 0xBD, 0xF0, 0x91, 0xA1, 0x1D + }, + { + 0x38, 0xD2, 0x18, 0xED, 0xAA, 0x18, 0xB1, 0x52, + 0x54, 0xE1, 0x7B, 0x6C, 0x13, 0xE1, 0x9F, 0x52, + 0x35, 0x7C, 0xCF, 0xE9, 0xDD, 0xFB, 0x61, 0x6F, + 0x38, 0x23, 0x26, 0xCB, 0x4F, 0x51, 0xE0, 0x18, + 0x69, 0xFA, 0xB5, 0x66, 0x40, 0x52, 0x51, 0x32, + 0x9E, 0xA1, 0xA9, 0x08, 0xD3, 0x7D, 0xC0, 0xE2, + 0xC2, 0x62, 0x8A, 0x57, 0x6C, 0xC5, 0x42, 0x57, + 0x0A, 0x44, 0xB6, 0x33, 0xFD, 0xAA, 0x68, 0xEE + }, + { + 0xD8, 0x6E, 0x1C, 0x89, 0x71, 0xD7, 0x0A, 0x81, + 0x20, 0x03, 0x4E, 0xE4, 0xD4, 0xC9, 0x96, 0x34, + 0x62, 0x1A, 0x38, 0x78, 0x96, 0xE5, 0x32, 0x54, + 0xC1, 0x09, 0x62, 0x79, 0x0D, 0x45, 0xCD, 0x0A, + 0xAD, 0x0A, 0x2E, 0x89, 0x08, 0xDD, 0x0F, 0xBF, + 0xFF, 0x14, 0x38, 0xE9, 0x77, 0x70, 0x69, 0x01, + 0x58, 0x2A, 0x8C, 0x8B, 0x1E, 0x71, 0x21, 0x05, + 0x87, 0x70, 0x60, 0xE1, 0x41, 0x79, 0x6B, 0xE3 + }, + { + 0x11, 0xDD, 0xB7, 0x53, 0x53, 0xEE, 0x05, 0xF2, + 0x67, 0xC8, 0x6F, 0xD8, 0xEE, 0x2A, 0x0F, 0x75, + 0xFD, 0xE0, 0x5C, 0x19, 0x4F, 0x52, 0xA5, 0x4D, + 0x61, 0x66, 0x9E, 0xA3, 0xCE, 0x6B, 0xA3, 0x7E, + 0x55, 0xFA, 0x39, 0x45, 0x7B, 0xA3, 0xCF, 0x08, + 0x30, 0x1F, 0x6C, 0x62, 0xE4, 0x6C, 0x74, 0x60, + 0xC3, 0x9E, 0xF4, 0xAB, 0x7D, 0xA0, 0x59, 0x65, + 0xB4, 0x50, 0xCD, 0x45, 0xF2, 0x50, 0x9C, 0x50 + }, + { + 0xE1, 0x4E, 0xCC, 0x8E, 0x83, 0x65, 0x73, 0x9E, + 0xAB, 0x97, 0xC0, 0x11, 0x36, 0x09, 0xA1, 0xFD, + 0x27, 0x34, 0xF9, 0x23, 0xCF, 0xA9, 0x5C, 0x1B, + 0x76, 0x03, 0x23, 0x03, 0x4D, 0xB9, 0x54, 0xFB, + 0xD0, 0x6F, 0xF8, 0x08, 0x64, 0xEB, 0x7A, 0x4B, + 0x69, 0xCB, 0x2A, 0x69, 0x8A, 0xAD, 0x94, 0x6B, + 0x28, 0xF5, 0xC1, 0x05, 0x90, 0x59, 0x61, 0x99, + 0x02, 0x7C, 0x82, 0xF4, 0xE0, 0xC4, 0x43, 0xA1 + }, + { + 0x92, 0x23, 0xB0, 0x01, 0x52, 0x53, 0x55, 0x2A, + 0x72, 0x56, 0xA6, 0x30, 0x40, 0x00, 0xB1, 0x93, + 0x8A, 0xD5, 0xC2, 0x8B, 0x0C, 0x76, 0x7E, 0x06, + 0x31, 0xF4, 0xC2, 0x21, 0x69, 0x13, 0xB5, 0x6F, + 0xF8, 0x2D, 0xB1, 0xB0, 0xD7, 0xCF, 0xED, 0x79, + 0xDF, 0x88, 0x81, 0x67, 0xFA, 0xBD, 0xA8, 0xB4, + 0x1C, 0x24, 0x72, 0x18, 0xB2, 0xE1, 0x9E, 0x57, + 0x47, 0xE9, 0x5D, 0xF5, 0xF4, 0x6E, 0xF7, 0xF8 + }, + { + 0x69, 0x64, 0x5E, 0x8C, 0x8B, 0xD0, 0x2A, 0xD1, + 0x23, 0x09, 0x47, 0x56, 0x66, 0x69, 0xC0, 0xD9, + 0xFC, 0xF3, 0x2E, 0x40, 0xAC, 0xE8, 0x18, 0xC7, + 0x09, 0x55, 0x66, 0x86, 0xF4, 0x9C, 0x34, 0x52, + 0xD9, 0x95, 0x44, 0x99, 0xCC, 0xDC, 0x56, 0x51, + 0xAB, 0xCA, 0x5F, 0x86, 0x09, 0x52, 0x83, 0x82, + 0x8D, 0xDA, 0xD1, 0x94, 0x00, 0x51, 0x62, 0xD9, + 0x49, 0x1C, 0xE6, 0xB6, 0x46, 0xA7, 0xB1, 0xA4 + }, + { + 0xD1, 0x7D, 0x96, 0xFE, 0xF6, 0x2D, 0x9E, 0x5F, + 0x64, 0xCE, 0x0A, 0x9A, 0x1C, 0x05, 0xC3, 0xA7, + 0x6D, 0x27, 0x8D, 0x65, 0x16, 0xDC, 0x97, 0x22, + 0xEA, 0x57, 0x0D, 0xC4, 0x4A, 0xC7, 0x5A, 0x96, + 0xC1, 0x8B, 0x68, 0x42, 0x03, 0x5B, 0x6A, 0xB0, + 0x63, 0x61, 0x6F, 0xAF, 0x3C, 0x99, 0x4F, 0x08, + 0x10, 0x8E, 0xC0, 0x8A, 0xD7, 0xAF, 0x9E, 0x54, + 0xB8, 0x4D, 0xD6, 0xA0, 0xC7, 0xF2, 0xDB, 0x36 + }, + { + 0x5B, 0xC7, 0x81, 0x56, 0x63, 0x06, 0xF3, 0x37, + 0xDE, 0x6D, 0x2F, 0xEB, 0xA9, 0x0B, 0xC6, 0x55, + 0xD9, 0xEA, 0xCC, 0xA0, 0x82, 0xD6, 0x6D, 0xA1, + 0x21, 0xAF, 0x6F, 0xCF, 0x04, 0x4C, 0x9F, 0x19, + 0x73, 0x07, 0xF9, 0x93, 0x43, 0x0D, 0x36, 0x05, + 0xCE, 0x0D, 0x84, 0xFC, 0x30, 0xD3, 0xAA, 0x10, + 0x76, 0x6C, 0xA8, 0xC4, 0xA4, 0x7B, 0xC4, 0xDC, + 0xA9, 0xAA, 0x9C, 0x5B, 0x32, 0x5A, 0x08, 0x2A + }, + { + 0xBD, 0x6E, 0x20, 0x0E, 0x4F, 0xE3, 0x8D, 0x0B, + 0x41, 0xCA, 0xFB, 0xCF, 0xB4, 0xEC, 0x14, 0x2E, + 0x36, 0x94, 0xD7, 0xA3, 0xB3, 0xCB, 0x38, 0xBA, + 0x77, 0x06, 0x5A, 0x1C, 0xC9, 0xEF, 0xB1, 0xDF, + 0x9E, 0xEB, 0xB9, 0x0B, 0x9E, 0xD4, 0x7A, 0x30, + 0xAD, 0x91, 0xBD, 0x99, 0xA0, 0x05, 0x38, 0xAB, + 0xBA, 0xA8, 0xC9, 0x1C, 0x04, 0xCC, 0x42, 0x45, + 0x34, 0x17, 0x6E, 0xE9, 0xD0, 0x0E, 0x40, 0xA5 + }, + { + 0x24, 0x69, 0x63, 0xA0, 0xB2, 0xB2, 0xF9, 0x51, + 0x56, 0x77, 0x46, 0xFA, 0xE4, 0x08, 0x07, 0x75, + 0xD6, 0x96, 0x20, 0x1E, 0x20, 0xF0, 0xA0, 0xD7, + 0xBD, 0x84, 0xF6, 0x74, 0xB5, 0x30, 0x12, 0x19, + 0x88, 0xAD, 0x1A, 0x0B, 0x4B, 0x59, 0x94, 0x0E, + 0x85, 0xC3, 0x1D, 0xAC, 0x6D, 0x1D, 0xE3, 0xFF, + 0x17, 0xD3, 0x79, 0x34, 0x8D, 0x24, 0xCA, 0xD4, + 0x9D, 0x85, 0xB4, 0x0C, 0xB5, 0xBF, 0xE8, 0xAD + }, + { + 0x60, 0x0C, 0xA7, 0x0C, 0xC7, 0x14, 0x22, 0xB9, + 0x66, 0x67, 0x7D, 0x52, 0x15, 0x72, 0xAD, 0x4A, + 0x8D, 0x0E, 0xE7, 0x2F, 0xC6, 0x9D, 0xA3, 0xCB, + 0x39, 0x99, 0xEC, 0x6D, 0x55, 0xA9, 0x54, 0x7C, + 0x11, 0x2E, 0x05, 0x59, 0x05, 0xFE, 0xE9, 0x9B, + 0xDF, 0xEA, 0x71, 0x81, 0x2F, 0x6D, 0xD0, 0x41, + 0x63, 0xAC, 0x22, 0x3F, 0x58, 0x68, 0x2E, 0x60, + 0x8A, 0x24, 0x06, 0x61, 0x17, 0x1F, 0x6F, 0xB6 + }, + { + 0x30, 0x64, 0xF6, 0xF8, 0x3A, 0x64, 0x83, 0x89, + 0x62, 0x74, 0xF7, 0x14, 0x9D, 0x67, 0xE3, 0xAF, + 0x70, 0x92, 0x01, 0xB4, 0xBB, 0x5F, 0x68, 0x5A, + 0x38, 0x8D, 0x22, 0x86, 0xC1, 0x30, 0x43, 0x0F, + 0x31, 0x5C, 0x8C, 0xCB, 0xA0, 0x6D, 0xC7, 0x72, + 0x33, 0x26, 0x7B, 0x67, 0xF8, 0x4E, 0x66, 0xBA, + 0x68, 0x0E, 0xA3, 0x39, 0xBF, 0xF4, 0x8A, 0x7D, + 0x93, 0xD7, 0x2C, 0xBE, 0x3C, 0x78, 0x43, 0x9F + }, + { + 0xE7, 0x00, 0xF7, 0xA0, 0xFC, 0xF9, 0xEB, 0xF7, + 0x1C, 0xA4, 0xEA, 0x39, 0x1E, 0x9E, 0x84, 0x84, + 0x0D, 0xF7, 0x89, 0x45, 0xD7, 0x05, 0xD3, 0xA9, + 0x70, 0x53, 0xAA, 0xAB, 0x4F, 0x71, 0x7D, 0xFF, + 0x7D, 0x01, 0xB2, 0x56, 0x76, 0x18, 0x29, 0xE1, + 0x39, 0xBA, 0xB8, 0x82, 0x1A, 0xAA, 0xC5, 0x14, + 0x2F, 0x14, 0xA6, 0x02, 0x93, 0xB1, 0x29, 0x02, + 0x77, 0xA5, 0xF7, 0x36, 0x6C, 0x94, 0x9F, 0x04 + }, + { + 0x78, 0xA6, 0x9B, 0x2F, 0xD1, 0x24, 0xE2, 0x22, + 0xCB, 0x9F, 0xBB, 0xAE, 0xE6, 0xE1, 0x42, 0x74, + 0xD0, 0x35, 0x4C, 0x48, 0xAE, 0xF2, 0x9D, 0x76, + 0x68, 0x28, 0x38, 0x35, 0x8B, 0xB6, 0x8D, 0x5E, + 0x4F, 0xEF, 0xE2, 0x84, 0x5D, 0x7F, 0xF6, 0x20, + 0xE4, 0x6A, 0x15, 0xCE, 0x2D, 0x79, 0x6E, 0x59, + 0xA4, 0x04, 0xF9, 0x38, 0x66, 0x01, 0xB5, 0x06, + 0xDD, 0xF9, 0xAF, 0x9B, 0xAB, 0x5C, 0x62, 0x62 + }, + { + 0xCA, 0x9D, 0xB2, 0xFF, 0x57, 0x40, 0xB1, 0xEC, + 0x9A, 0xAF, 0xF8, 0x4C, 0x62, 0x5A, 0x09, 0x2E, + 0x7E, 0x16, 0x0A, 0x58, 0xBB, 0xA4, 0x31, 0xCC, + 0x0F, 0x99, 0x87, 0x63, 0x09, 0x51, 0xAA, 0xF0, + 0xFA, 0x2F, 0x26, 0xCE, 0x8A, 0x75, 0xFE, 0xF9, + 0xF5, 0x6D, 0x8C, 0x7F, 0x00, 0x8E, 0x9C, 0x75, + 0x2F, 0x17, 0x2C, 0x47, 0xD0, 0xF7, 0x43, 0x0A, + 0x62, 0x72, 0x5D, 0x9A, 0xE3, 0x05, 0x23, 0x80 + }, + { + 0xD6, 0xDA, 0x3A, 0x89, 0xA7, 0xE8, 0x1F, 0x55, + 0x0D, 0xD9, 0xAE, 0xEE, 0x1C, 0x52, 0x0C, 0xC8, + 0xCE, 0xB0, 0x9B, 0x39, 0x74, 0xF5, 0xEF, 0xCC, + 0x89, 0x69, 0xF6, 0xEE, 0xCA, 0xDE, 0x36, 0x5F, + 0x6E, 0xB1, 0x40, 0x89, 0xCB, 0x7F, 0x48, 0x02, + 0xAD, 0xCE, 0x29, 0x83, 0xD3, 0xB5, 0xF0, 0x03, + 0x10, 0x6E, 0xD0, 0x70, 0x86, 0x11, 0x7C, 0xB1, + 0x64, 0xC8, 0xA5, 0xED, 0xA3, 0xEF, 0x13, 0x31 + }, + { + 0x22, 0x31, 0xFF, 0x67, 0xCC, 0xDB, 0xDA, 0x94, + 0xE3, 0x08, 0x9B, 0xEA, 0xDA, 0x74, 0x12, 0x46, + 0xE6, 0xAE, 0x72, 0xC5, 0x84, 0x14, 0xD6, 0x0D, + 0x96, 0xCB, 0x3F, 0x2D, 0xB4, 0x52, 0xF5, 0x7C, + 0xEE, 0x0A, 0xD9, 0x43, 0x94, 0xE0, 0x21, 0xF2, + 0x4B, 0x2D, 0x35, 0x45, 0x47, 0x41, 0x54, 0x76, + 0xD8, 0xBF, 0xF7, 0xF3, 0x1F, 0xAA, 0xA5, 0x79, + 0x2A, 0x4D, 0xC5, 0x1E, 0xCD, 0xF9, 0x2A, 0xE2 + }, + { + 0x94, 0xB9, 0x6D, 0xD2, 0x59, 0x7B, 0x84, 0x74, + 0xF5, 0xBD, 0x5E, 0x59, 0xC3, 0x0C, 0x42, 0x52, + 0xFA, 0x04, 0xF0, 0x19, 0xC8, 0x6E, 0x5C, 0x38, + 0x58, 0x0A, 0x49, 0x97, 0xEB, 0x34, 0x79, 0x98, + 0x5E, 0xBE, 0x1C, 0x54, 0xE3, 0x60, 0x8B, 0xA3, + 0x2E, 0x58, 0xA3, 0xE4, 0x5B, 0xAE, 0x29, 0x44, + 0x4F, 0x61, 0x6A, 0x41, 0x67, 0x4D, 0x1E, 0xD6, + 0x8C, 0x1D, 0x6D, 0xD9, 0x8B, 0xEF, 0x89, 0xB2 + }, + { + 0xB5, 0x38, 0x91, 0x54, 0x03, 0x03, 0xED, 0x44, + 0xA1, 0xA7, 0xF6, 0xE4, 0x64, 0x9B, 0x1B, 0x62, + 0xD1, 0x12, 0xD3, 0x58, 0x9D, 0x76, 0x02, 0x1E, + 0x6B, 0x8A, 0xD2, 0xC8, 0xD6, 0x08, 0x52, 0x8C, + 0x07, 0xC0, 0x1F, 0xB0, 0x11, 0x00, 0x62, 0x90, + 0x62, 0xF2, 0x40, 0x80, 0x65, 0x82, 0x30, 0x0B, + 0x5E, 0xDC, 0xDC, 0x94, 0xE1, 0xB9, 0x3D, 0x38, + 0xB0, 0xD8, 0x89, 0x8B, 0x3A, 0x3F, 0xED, 0x79 + }, + { + 0xD8, 0x73, 0xCD, 0x32, 0x92, 0xF0, 0xAF, 0xCD, + 0xF3, 0xFF, 0xC3, 0xB3, 0x2A, 0x75, 0x29, 0x3A, + 0x69, 0xE7, 0xA3, 0x48, 0x9E, 0x38, 0x51, 0x84, + 0x3A, 0xA9, 0x57, 0x92, 0x41, 0xCA, 0xE1, 0xC2, + 0xA7, 0x6D, 0x71, 0xE3, 0x64, 0xE7, 0xB1, 0x73, + 0xCF, 0x0F, 0x9A, 0xC2, 0x32, 0x89, 0xED, 0x40, + 0xD7, 0x29, 0x3B, 0x84, 0x5A, 0x19, 0x3C, 0xB7, + 0x4E, 0x91, 0x3C, 0xFA, 0xB4, 0xE5, 0x04, 0x3D + }, + { + 0xF0, 0xCE, 0x54, 0x6A, 0x5F, 0xED, 0x69, 0xDE, + 0xD8, 0xFC, 0x29, 0x37, 0xD4, 0x55, 0x5B, 0x5B, + 0x90, 0x6F, 0x10, 0x2A, 0x33, 0x7C, 0xBA, 0x2A, + 0xBF, 0x92, 0x30, 0xB4, 0x66, 0x79, 0xEE, 0x06, + 0xA2, 0x2D, 0x52, 0x9B, 0xF8, 0x12, 0xF8, 0xA3, + 0x9F, 0x8C, 0xF7, 0x40, 0x23, 0xCF, 0xCE, 0xED, + 0x41, 0x22, 0x44, 0x3B, 0xBA, 0xFF, 0xFA, 0xA5, + 0x9A, 0x33, 0x0F, 0x4C, 0x96, 0xCC, 0xBE, 0xB2 + }, + { + 0xEB, 0x4F, 0x6C, 0xC8, 0xDE, 0x11, 0xD2, 0x26, + 0x92, 0x5B, 0xA9, 0x29, 0x1C, 0x96, 0xCB, 0x36, + 0x91, 0x14, 0x95, 0x10, 0x34, 0x14, 0xCF, 0xEC, + 0x45, 0x3E, 0x90, 0x10, 0xB7, 0x25, 0x95, 0x30, + 0xD3, 0xCC, 0x78, 0x49, 0x30, 0x6D, 0x2C, 0x0F, + 0xB8, 0xC1, 0x4B, 0x30, 0x74, 0x13, 0xE3, 0x8A, + 0x5A, 0x24, 0xBD, 0xC3, 0xE5, 0x11, 0xB2, 0x25, + 0x91, 0x9F, 0xB0, 0x8A, 0x7C, 0xBF, 0xAA, 0x5E + }, + { + 0x14, 0x38, 0x4F, 0xF7, 0x39, 0xDF, 0xD6, 0xCC, + 0xFD, 0xDB, 0xB2, 0xDB, 0xC1, 0x12, 0xBE, 0xAC, + 0xA7, 0xCE, 0x5C, 0xA7, 0xBB, 0xF5, 0xF4, 0xB0, + 0x5E, 0xAB, 0xA7, 0x34, 0xCA, 0xB7, 0x24, 0x2C, + 0x8B, 0x47, 0x15, 0x3B, 0x3B, 0x68, 0x8A, 0x6A, + 0x66, 0xA4, 0xF1, 0x28, 0x0D, 0x39, 0xD1, 0x32, + 0xA6, 0x74, 0x18, 0x26, 0x4E, 0x0B, 0xBA, 0xDA, + 0x6A, 0xC7, 0xD9, 0xB5, 0xF4, 0xDE, 0x81, 0x98 + }, + { + 0x63, 0xE1, 0x22, 0x17, 0x78, 0xC7, 0xB1, 0xF3, + 0xEF, 0xDF, 0x5E, 0x39, 0x59, 0xA7, 0x6A, 0x14, + 0xBC, 0x7A, 0x4C, 0xBF, 0x97, 0xC5, 0xD9, 0x02, + 0xEF, 0x40, 0x2B, 0x21, 0xF1, 0x10, 0xDD, 0x23, + 0x99, 0x0C, 0x58, 0x4F, 0x49, 0x5F, 0x84, 0x28, + 0x5C, 0xA3, 0x81, 0x07, 0x99, 0xD0, 0xF4, 0x33, + 0xE8, 0xA2, 0xB8, 0x37, 0x15, 0x75, 0x20, 0x57, + 0x4D, 0xE5, 0x34, 0x43, 0x78, 0x31, 0x7E, 0x30 + }, + { + 0x2A, 0x44, 0x9C, 0x9D, 0x2B, 0x51, 0x98, 0x66, + 0x49, 0xC1, 0xE0, 0x9F, 0x77, 0x9D, 0x7A, 0xF6, + 0x5D, 0x4D, 0xC9, 0x5F, 0x1C, 0xCB, 0xEF, 0xC4, + 0x47, 0xE1, 0x92, 0xCA, 0x58, 0x0E, 0x74, 0x7F, + 0x28, 0x55, 0xC6, 0x87, 0x9C, 0xFF, 0xB4, 0x60, + 0x62, 0x68, 0x8B, 0x02, 0x32, 0x1F, 0x34, 0x58, + 0x14, 0xFF, 0x00, 0x88, 0x11, 0x4A, 0x07, 0xA7, + 0x4A, 0xA3, 0x7F, 0xC1, 0x54, 0xB2, 0x87, 0x46 + }, + { + 0x2F, 0x38, 0x35, 0xE0, 0x11, 0xF5, 0x71, 0x1C, + 0xEF, 0x27, 0x67, 0xC3, 0xBE, 0x32, 0xAD, 0x74, + 0x68, 0x17, 0xF8, 0xA8, 0xD2, 0x15, 0xE3, 0x3B, + 0x57, 0x3A, 0x87, 0x85, 0x62, 0x0E, 0x23, 0x9A, + 0xDF, 0x8C, 0x70, 0xC5, 0x0C, 0xF5, 0x30, 0x8B, + 0x01, 0x3A, 0x4A, 0x9C, 0xFF, 0xB4, 0x97, 0xA7, + 0xDE, 0xD1, 0xCD, 0xAB, 0xC4, 0xCE, 0xA5, 0xF0, + 0x76, 0x82, 0xC6, 0xE6, 0xD7, 0x12, 0xDD, 0xEA + }, + { + 0xD3, 0xF6, 0xBF, 0x22, 0x0E, 0xEF, 0x97, 0x6C, + 0x8E, 0xBB, 0xDE, 0xFC, 0xB3, 0x8A, 0x41, 0x5C, + 0xC9, 0xB3, 0x6D, 0xA3, 0x66, 0xF8, 0xED, 0x57, + 0x64, 0x0B, 0x7B, 0x1C, 0xAE, 0xAB, 0x16, 0x6A, + 0xFF, 0x5A, 0x38, 0x5F, 0x9C, 0x56, 0xA5, 0x6B, + 0x66, 0x5C, 0x68, 0xFE, 0x77, 0xF6, 0xCE, 0xAD, + 0xE1, 0xE3, 0xA6, 0x89, 0xA8, 0xC9, 0x5C, 0x14, + 0x13, 0x74, 0xE9, 0x0A, 0x2B, 0x46, 0x0C, 0x18 + }, + { + 0xB6, 0xDA, 0x26, 0xA7, 0xC7, 0xA6, 0x30, 0xBA, + 0xDB, 0x84, 0xC1, 0xEC, 0x53, 0x5B, 0x05, 0x49, + 0x53, 0xCD, 0x3A, 0xA2, 0x04, 0x3B, 0xFE, 0x3B, + 0x17, 0x25, 0x25, 0x42, 0xDB, 0x00, 0xE1, 0x08, + 0xCF, 0x29, 0x00, 0xE1, 0x8D, 0x55, 0xF0, 0x4D, + 0xB8, 0x76, 0x61, 0x4A, 0x77, 0x1F, 0x3A, 0x58, + 0xD4, 0xA1, 0x27, 0xB0, 0xF1, 0x11, 0x29, 0xF3, + 0x05, 0xB0, 0x0F, 0xDF, 0x6B, 0x15, 0x8B, 0x44 + }, + { + 0xDB, 0x57, 0xC0, 0x3B, 0x79, 0x22, 0x88, 0x15, + 0xD3, 0xA8, 0xDA, 0xF5, 0xEB, 0x77, 0xAA, 0x6D, + 0xE8, 0x7E, 0x71, 0xA3, 0xB4, 0x53, 0xB7, 0x3A, + 0x77, 0xDF, 0x7E, 0x47, 0xAF, 0xAC, 0x6D, 0xB0, + 0x7E, 0xCF, 0x8F, 0x14, 0xAE, 0x3C, 0xF8, 0xDD, + 0xD7, 0x35, 0x93, 0x1E, 0x70, 0x40, 0x4B, 0xA2, + 0xFE, 0x99, 0x63, 0xB9, 0x1C, 0x3C, 0x45, 0x1E, + 0x2F, 0x9A, 0x98, 0x71, 0x49, 0x22, 0x8C, 0xE6 + }, + { + 0x5A, 0x7B, 0x4D, 0x73, 0xAC, 0xA0, 0xB0, 0x28, + 0x83, 0x06, 0x04, 0x3D, 0x1D, 0x0E, 0xAF, 0xA8, + 0x25, 0x46, 0x90, 0xE6, 0x35, 0x78, 0x1A, 0xA1, + 0xA7, 0x64, 0xDC, 0x3E, 0x3C, 0x1E, 0xA7, 0xA5, + 0xC7, 0xD1, 0x47, 0x45, 0x98, 0x49, 0x7B, 0x2C, + 0xBC, 0x84, 0x03, 0x5E, 0x18, 0x4C, 0x6B, 0xEF, + 0xE2, 0x23, 0x49, 0xC0, 0x36, 0x6A, 0xA1, 0xAB, + 0xEE, 0x8F, 0x1D, 0x39, 0x8F, 0x4D, 0x7F, 0x38 + }, + { + 0x81, 0x67, 0xC5, 0x51, 0x60, 0xE1, 0xE7, 0xD4, + 0x02, 0x29, 0x03, 0xDE, 0x23, 0x47, 0xF5, 0xA5, + 0x26, 0x2F, 0xFF, 0x94, 0x3B, 0x9B, 0x6F, 0xEA, + 0x5D, 0xBF, 0x09, 0x30, 0x83, 0x11, 0xB9, 0x5B, + 0xA4, 0x97, 0x8C, 0xC8, 0x74, 0x91, 0xC6, 0xF4, + 0xEE, 0x0A, 0xCA, 0xA4, 0x7A, 0x5E, 0x1D, 0x59, + 0x9D, 0x53, 0x1F, 0xC9, 0x82, 0x2C, 0x8F, 0x04, + 0xD0, 0x8C, 0x41, 0x7A, 0xD2, 0x86, 0xF1, 0xAC + }, + { + 0xC9, 0x37, 0x6C, 0x70, 0x68, 0xCE, 0xFB, 0x8E, + 0x2F, 0xE2, 0x41, 0xFE, 0xCF, 0x3A, 0x42, 0x7D, + 0x7A, 0x50, 0x3D, 0x07, 0x2E, 0x4F, 0x86, 0xCB, + 0x4F, 0xD1, 0x38, 0xEB, 0xA5, 0xD8, 0x4B, 0x10, + 0xFB, 0xDF, 0xB1, 0xCB, 0x31, 0x6D, 0xBF, 0x29, + 0x5F, 0x39, 0xDC, 0x1D, 0xBB, 0x78, 0x29, 0x96, + 0xCE, 0x81, 0x47, 0x53, 0x7C, 0xBA, 0x36, 0x62, + 0x00, 0xC4, 0xD1, 0x5A, 0xEA, 0x3B, 0xB4, 0xCD + }, + { + 0x61, 0xFF, 0xD0, 0x87, 0xF2, 0x31, 0x3F, 0xFB, + 0x3E, 0x21, 0x0B, 0x94, 0xF6, 0xF9, 0x45, 0x2D, + 0x53, 0xA7, 0x13, 0xBE, 0x1E, 0x9D, 0xB5, 0x54, + 0x11, 0xAB, 0x16, 0x92, 0x9A, 0x03, 0x1B, 0xCB, + 0xF9, 0xED, 0x88, 0xC4, 0x18, 0x75, 0x68, 0xA6, + 0xDC, 0xAE, 0x96, 0x67, 0x0E, 0x75, 0xC8, 0x1B, + 0x66, 0x1E, 0x7A, 0xAF, 0x26, 0x4C, 0x4C, 0xDB, + 0x7A, 0x9C, 0xC4, 0x4B, 0x62, 0xD5, 0x58, 0x13 + }, + { + 0x90, 0x10, 0x46, 0x9D, 0x1D, 0xC2, 0xC5, 0x5E, + 0x8D, 0x4A, 0x79, 0x7F, 0x31, 0xCA, 0x05, 0x30, + 0x06, 0xC7, 0xF2, 0xE1, 0xD2, 0x2F, 0x79, 0x4C, + 0xC3, 0x46, 0x5C, 0x8E, 0xBD, 0xAD, 0xE3, 0xC7, + 0xCF, 0x24, 0x75, 0x4C, 0x98, 0x9E, 0x8A, 0xB7, + 0x4E, 0x47, 0xFF, 0x29, 0x31, 0x48, 0x97, 0xDF, + 0x85, 0x1B, 0xB7, 0xA5, 0xC5, 0xDB, 0x81, 0x2D, + 0xCE, 0x2F, 0xE2, 0xA5, 0xB0, 0x0A, 0x24, 0x73 + }, + { + 0xF6, 0x06, 0x04, 0x69, 0xEB, 0x64, 0x7B, 0xCB, + 0xE3, 0x1D, 0x48, 0xBC, 0xC6, 0xC9, 0x97, 0xE0, + 0xFB, 0x92, 0x2E, 0xA0, 0x77, 0x99, 0x8D, 0x28, + 0x28, 0x59, 0xAE, 0xED, 0x68, 0xDB, 0xD1, 0x0E, + 0x68, 0x34, 0xDF, 0x93, 0xD7, 0xB6, 0xDF, 0x5C, + 0x9A, 0xF8, 0x10, 0xF5, 0x82, 0x23, 0x32, 0xF3, + 0xD9, 0x27, 0x2B, 0x42, 0xD3, 0xB7, 0x21, 0x43, + 0xF9, 0x12, 0x3A, 0x03, 0x83, 0x94, 0x69, 0x09 + }, + { + 0xE2, 0x7F, 0xF9, 0x30, 0x9F, 0x3F, 0xA9, 0xF6, + 0x82, 0x62, 0x45, 0x3C, 0x61, 0xD1, 0xA7, 0x93, + 0xB6, 0x7E, 0x98, 0x8B, 0x7D, 0xA3, 0x38, 0x3D, + 0x26, 0x52, 0xAC, 0xC4, 0xC7, 0x12, 0x57, 0x91, + 0x1A, 0xE4, 0x61, 0x30, 0xA1, 0xE8, 0x68, 0xA9, + 0x3E, 0x43, 0x52, 0x9A, 0xCA, 0x79, 0x1B, 0x3A, + 0xF5, 0x2E, 0x42, 0x13, 0x98, 0xAB, 0x60, 0x89, + 0x4F, 0x20, 0x39, 0x43, 0xB2, 0xE4, 0xC9, 0x8D + }, + { + 0x83, 0xB2, 0x5B, 0x63, 0x33, 0xDB, 0x95, 0xDE, + 0x04, 0xBB, 0x75, 0xAA, 0xB8, 0x49, 0x5E, 0xAA, + 0x0C, 0x4A, 0x41, 0x5E, 0x8D, 0xD1, 0x12, 0xC0, + 0xA0, 0x74, 0x0A, 0xE0, 0xB6, 0x30, 0xD2, 0x6F, + 0xBB, 0x4F, 0x26, 0x04, 0x1A, 0x9B, 0x87, 0xE6, + 0x94, 0x14, 0x20, 0xA9, 0x2D, 0x26, 0x5A, 0xB4, + 0x73, 0xBE, 0xAE, 0x26, 0x20, 0xE8, 0x81, 0x60, + 0x26, 0x4E, 0xA9, 0x81, 0x61, 0x87, 0x99, 0xE2 + }, + { + 0x6A, 0x4A, 0x19, 0xDD, 0xF4, 0xE5, 0x3D, 0x11, + 0xCD, 0x06, 0x34, 0x63, 0x3A, 0x00, 0x96, 0x3C, + 0xE4, 0xC2, 0x2C, 0x8C, 0xE1, 0x11, 0x5F, 0x3D, + 0xE8, 0xBA, 0x3A, 0x6F, 0x0D, 0x53, 0x16, 0xC3, + 0x03, 0x83, 0x78, 0x78, 0x13, 0xAF, 0x9B, 0xFE, + 0x04, 0xF5, 0x3C, 0x36, 0xE0, 0x7B, 0xB3, 0x99, + 0x8D, 0x7E, 0xD5, 0x21, 0x70, 0x09, 0x53, 0x60, + 0x6B, 0xF9, 0xD0, 0x92, 0x66, 0xA8, 0xB5, 0x0D + }, + { + 0xD6, 0xB7, 0x75, 0x1B, 0x2E, 0x82, 0x29, 0x23, + 0x97, 0xCA, 0xAA, 0xAC, 0x59, 0x3D, 0x90, 0x2D, + 0xB8, 0xBD, 0xA1, 0xBA, 0x8F, 0xF3, 0x13, 0x80, + 0xFA, 0x0A, 0xA0, 0xB0, 0x57, 0x43, 0xFA, 0x70, + 0xC6, 0xD3, 0xA2, 0x59, 0x52, 0x6D, 0xED, 0xCD, + 0x22, 0xB2, 0xA8, 0x28, 0x23, 0xBE, 0x0A, 0x14, + 0xC5, 0x9B, 0x59, 0x64, 0xDF, 0x74, 0x7F, 0x26, + 0xAC, 0xC5, 0xCB, 0x8F, 0x60, 0x8A, 0x05, 0xE3 + }, + { + 0x59, 0x2E, 0xA9, 0xCB, 0x5C, 0x2A, 0x21, 0x3B, + 0x70, 0x16, 0x19, 0x07, 0xC9, 0x88, 0x4B, 0x29, + 0xB3, 0x12, 0x04, 0xFA, 0x21, 0x48, 0x8A, 0x51, + 0xAF, 0x77, 0x0B, 0x5C, 0x44, 0x37, 0x7F, 0x4B, + 0x28, 0xA3, 0x31, 0x40, 0xB1, 0x02, 0xB7, 0xF3, + 0xC2, 0xCC, 0x06, 0x2D, 0xE8, 0x09, 0x3C, 0xEE, + 0xAB, 0xD2, 0xC3, 0x62, 0xFE, 0xEA, 0x95, 0x9F, + 0x0B, 0xBD, 0x8B, 0x15, 0x1F, 0xC8, 0xE3, 0x85 + }, + { + 0x51, 0x54, 0x47, 0x55, 0xAF, 0x80, 0xAA, 0x77, + 0x0C, 0x3C, 0x77, 0xDA, 0xD4, 0x00, 0x07, 0xBE, + 0x37, 0x55, 0x55, 0x25, 0x68, 0xD7, 0x52, 0x6F, + 0xD6, 0x04, 0xF7, 0xF2, 0xA1, 0xAD, 0x0E, 0x02, + 0x79, 0xC7, 0x67, 0xA2, 0x98, 0x1F, 0x23, 0x2B, + 0xED, 0x99, 0xBB, 0x17, 0x86, 0xBB, 0x72, 0xED, + 0xA1, 0x7E, 0x11, 0x74, 0xCA, 0x41, 0xDE, 0x5E, + 0x6D, 0x61, 0x57, 0xC0, 0x19, 0xD7, 0xC3, 0x51 + }, + { + 0xB9, 0xCF, 0x68, 0xA8, 0x73, 0x82, 0x98, 0x1C, + 0x82, 0x38, 0x07, 0x1B, 0x1C, 0x50, 0x39, 0x80, + 0x4B, 0xCE, 0xE1, 0x24, 0x67, 0xFE, 0x10, 0x2F, + 0x5F, 0xDA, 0x5E, 0x19, 0x4C, 0x9E, 0xD9, 0xD6, + 0x19, 0x9E, 0x94, 0x4E, 0xBA, 0x58, 0x6B, 0x64, + 0x03, 0x65, 0x54, 0xD4, 0xC6, 0xE3, 0x10, 0xAD, + 0x81, 0x9B, 0x2E, 0xE2, 0x5D, 0x08, 0x44, 0x2E, + 0xA7, 0x32, 0x1A, 0x5C, 0xBF, 0x3C, 0x23, 0x77 + }, + { + 0x27, 0x22, 0xF8, 0xB3, 0x53, 0xCA, 0xD4, 0x71, + 0xA5, 0xE0, 0x01, 0xEB, 0xAD, 0x1F, 0x5F, 0x87, + 0x87, 0xFB, 0x48, 0x0D, 0x87, 0xE8, 0x6E, 0x61, + 0x4F, 0x5B, 0xA0, 0x88, 0xDD, 0x21, 0xC8, 0x65, + 0x62, 0x1D, 0xEC, 0xEE, 0x30, 0xFA, 0x71, 0x43, + 0x4E, 0x67, 0x7A, 0x87, 0xBB, 0x47, 0xB4, 0xDB, + 0x5A, 0x41, 0xAC, 0xC2, 0x6C, 0x64, 0x5E, 0x4E, + 0x02, 0xFA, 0x8B, 0xE1, 0xCB, 0xF8, 0x81, 0x05 + }, + { + 0xB2, 0xC9, 0xEF, 0x55, 0xDB, 0x6E, 0x54, 0x92, + 0xBA, 0xCB, 0x03, 0x58, 0x0E, 0x98, 0x55, 0xDB, + 0xEE, 0xE4, 0x21, 0xC3, 0x56, 0xDD, 0xB5, 0xC8, + 0x1F, 0x96, 0x90, 0x79, 0x18, 0xF5, 0xED, 0x3D, + 0xFE, 0xBA, 0x52, 0x12, 0xE8, 0xA8, 0x94, 0xAE, + 0x2A, 0x81, 0x17, 0x02, 0x95, 0xDE, 0x0D, 0xEA, + 0x1D, 0x4A, 0x7A, 0xE2, 0x94, 0x99, 0x84, 0x58, + 0xAD, 0x2D, 0x63, 0xE6, 0xCB, 0x81, 0xAA, 0x73 + }, + { + 0xFC, 0xD7, 0x5D, 0x36, 0xC5, 0x5C, 0x1F, 0x42, + 0xD9, 0xBA, 0xD8, 0x6A, 0xF6, 0xAA, 0x06, 0x84, + 0xF4, 0x3C, 0x3E, 0x67, 0x84, 0xDE, 0xBB, 0x1F, + 0xAD, 0xD9, 0xA1, 0x7B, 0x84, 0x69, 0x43, 0xE4, + 0x3B, 0x39, 0x8A, 0xA6, 0xE8, 0xB8, 0x75, 0x38, + 0x3B, 0xC6, 0x29, 0x3A, 0x99, 0x84, 0xC9, 0xAD, + 0x48, 0xD8, 0x8A, 0x00, 0x7C, 0x4C, 0x0E, 0xC3, + 0x03, 0x8A, 0x7B, 0xCB, 0x7A, 0x9D, 0xFD, 0x1C + }, + { + 0x43, 0xCE, 0x35, 0x80, 0x30, 0x06, 0xA3, 0x37, + 0x1E, 0x62, 0xC3, 0x15, 0x85, 0xF2, 0x52, 0x35, + 0xF3, 0xF5, 0x54, 0xC8, 0xA6, 0xD3, 0x65, 0xD6, + 0x30, 0xEB, 0x52, 0x76, 0x76, 0x7B, 0x36, 0x14, + 0x5A, 0x76, 0xE0, 0x70, 0x53, 0x6E, 0x33, 0x79, + 0xA7, 0x3C, 0x63, 0xAC, 0xFE, 0xC8, 0x41, 0x4F, + 0xA0, 0x0D, 0x71, 0x50, 0xB3, 0x0D, 0xF5, 0x82, + 0x19, 0x82, 0x32, 0x53, 0x40, 0x30, 0xA4, 0x7C + }, + { + 0x64, 0x5D, 0x89, 0x53, 0x84, 0x64, 0xDF, 0xE1, + 0x52, 0xC5, 0x06, 0xAC, 0x28, 0x63, 0xA4, 0xCC, + 0x70, 0xC7, 0xA4, 0x1B, 0xC4, 0x76, 0x30, 0x82, + 0xC0, 0xF8, 0xF6, 0x0D, 0x55, 0xAC, 0x9D, 0x1E, + 0x7D, 0x6C, 0x64, 0xA1, 0xDF, 0xD4, 0x15, 0x90, + 0xAE, 0x59, 0xEE, 0x3A, 0xAA, 0x2F, 0x26, 0x6E, + 0x52, 0x6D, 0xAD, 0x9F, 0x3F, 0xD7, 0x23, 0x66, + 0x63, 0x12, 0xBE, 0x07, 0xFF, 0xF5, 0xC8, 0x95 + }, + { + 0xE1, 0xE0, 0x63, 0xF6, 0xE0, 0xC2, 0xA9, 0x1C, + 0xAD, 0xB2, 0x68, 0xC4, 0x82, 0x05, 0x59, 0x36, + 0x57, 0x85, 0xF8, 0x02, 0x86, 0xA0, 0x15, 0xB6, + 0xE9, 0xED, 0xCE, 0x78, 0xA6, 0xFF, 0xDD, 0xDA, + 0xF3, 0xC0, 0x15, 0x5A, 0x18, 0x1D, 0x36, 0x8E, + 0x22, 0x8F, 0x2E, 0x16, 0xDF, 0xB0, 0xF2, 0x2E, + 0x00, 0x0E, 0xFC, 0x5B, 0x72, 0x63, 0xA8, 0xF7, + 0x6D, 0x1E, 0xFE, 0xAD, 0x53, 0x09, 0x2C, 0xBC + }, + { + 0x32, 0x1F, 0xA6, 0x93, 0x8E, 0x33, 0x69, 0x4C, + 0xF4, 0x4E, 0x21, 0xF6, 0x01, 0x0B, 0x74, 0xF9, + 0xE8, 0xC3, 0xEF, 0xDD, 0xE6, 0x27, 0x5E, 0xAE, + 0x20, 0xE1, 0x34, 0x61, 0x95, 0x53, 0x7D, 0x16, + 0x0A, 0xC0, 0xC7, 0x96, 0xF4, 0xC0, 0xF0, 0x89, + 0xD2, 0x9A, 0x0E, 0x2B, 0xE9, 0x9F, 0x7D, 0x95, + 0x83, 0x6B, 0x2F, 0x39, 0xDB, 0x4B, 0xA9, 0xA4, + 0x54, 0x42, 0x58, 0x65, 0x60, 0xCB, 0xF1, 0x6D + }, + { + 0x3A, 0x44, 0xC8, 0x43, 0x61, 0x6C, 0x9B, 0xEC, + 0x24, 0x04, 0x90, 0x39, 0x35, 0x5F, 0x7E, 0x2D, + 0xBE, 0x05, 0xED, 0xD6, 0x9E, 0x69, 0x46, 0xDA, + 0x0F, 0x79, 0x22, 0xB1, 0xA9, 0x12, 0x67, 0xAB, + 0xE8, 0xD0, 0x5D, 0xA7, 0xF1, 0x3C, 0x9F, 0x4E, + 0xB8, 0xA7, 0x53, 0xFA, 0x99, 0x90, 0x91, 0x38, + 0x8D, 0x1B, 0xCE, 0x35, 0x00, 0x77, 0x5A, 0xB8, + 0x28, 0xB5, 0x37, 0x69, 0x47, 0xDB, 0xE0, 0x72 + }, + { + 0xBF, 0x39, 0xE9, 0x37, 0xFF, 0x6B, 0x54, 0x14, + 0xE7, 0x44, 0x64, 0x26, 0x87, 0x59, 0x07, 0x8B, + 0x2A, 0x8C, 0x22, 0x59, 0xA7, 0x15, 0x8F, 0x6D, + 0x06, 0xD6, 0x4B, 0xA2, 0x2E, 0xB8, 0x39, 0xAA, + 0xCF, 0x88, 0x30, 0xDD, 0x71, 0xB5, 0xFC, 0xB4, + 0x95, 0x8B, 0x9C, 0xC6, 0xE0, 0xF4, 0xD1, 0xCC, + 0xC3, 0x52, 0x2F, 0x52, 0xB1, 0x9D, 0xBA, 0x7C, + 0x97, 0x60, 0x63, 0x48, 0x35, 0xB7, 0xC1, 0x75 + }, + { + 0x4B, 0xD1, 0x37, 0xB4, 0xDF, 0x03, 0x5B, 0x18, + 0x86, 0xA4, 0x20, 0x13, 0x78, 0x25, 0xF1, 0x78, + 0x3F, 0x99, 0x58, 0xEF, 0xC8, 0xDF, 0x3F, 0x72, + 0x4D, 0x76, 0xAD, 0x08, 0xA2, 0x2F, 0x9B, 0xB2, + 0xB5, 0x2C, 0xD3, 0x79, 0xEF, 0x39, 0x14, 0xAE, + 0x22, 0x23, 0xE6, 0xDD, 0x45, 0x3A, 0x94, 0xAD, + 0x86, 0x01, 0xAA, 0x8C, 0x8D, 0x39, 0x8D, 0x6B, + 0x33, 0x37, 0xA9, 0x7B, 0x92, 0x03, 0x24, 0xAC + }, + { + 0xDE, 0x75, 0xE7, 0x05, 0xF0, 0x91, 0xC4, 0x40, + 0x7A, 0x0A, 0x4D, 0xE7, 0x50, 0xB9, 0x72, 0xA6, + 0x11, 0xB2, 0x81, 0xCF, 0x8F, 0x6C, 0x32, 0xF1, + 0xC0, 0xD9, 0x4A, 0x8E, 0x98, 0xEE, 0xBD, 0x19, + 0x23, 0xD1, 0xF1, 0xDC, 0xBA, 0x28, 0xF0, 0xAD, + 0x5C, 0x9A, 0x5D, 0x92, 0x6D, 0xF8, 0xCC, 0x09, + 0xA7, 0xCB, 0x7F, 0x9B, 0xB0, 0x40, 0x19, 0x16, + 0x39, 0x9F, 0x41, 0xC1, 0x89, 0x33, 0x4A, 0xFB + }, + { + 0xDC, 0x48, 0x71, 0xF1, 0xA5, 0x3F, 0x13, 0x47, + 0x18, 0x45, 0xC9, 0x5D, 0xCC, 0x4D, 0x07, 0x99, + 0x6E, 0x89, 0xE7, 0xA8, 0x53, 0x58, 0xD3, 0xF6, + 0x66, 0xC6, 0x3B, 0x6D, 0xC4, 0x66, 0x48, 0xA9, + 0x5D, 0xD2, 0xBA, 0xC4, 0xF5, 0x27, 0x81, 0x2A, + 0xE1, 0xE7, 0x42, 0x88, 0x2C, 0x30, 0x48, 0xE1, + 0xF1, 0x9F, 0x11, 0x5E, 0x7F, 0x25, 0x21, 0xDC, + 0xF5, 0xA4, 0x11, 0xED, 0xCF, 0x17, 0x01, 0xFD + }, + { + 0x26, 0x58, 0x56, 0x0C, 0xCF, 0xF5, 0xDE, 0x55, + 0x4D, 0xA6, 0xD1, 0x70, 0x3C, 0x02, 0x57, 0xD2, + 0xED, 0x9F, 0xC7, 0x7F, 0xA8, 0x3B, 0xB7, 0x59, + 0xD2, 0x56, 0x2B, 0x2D, 0x6C, 0x80, 0x23, 0xCD, + 0x4F, 0x5E, 0x63, 0x3F, 0x5C, 0xD2, 0xEB, 0x18, + 0x47, 0xBE, 0xF6, 0x99, 0xB8, 0xF8, 0x27, 0x88, + 0xB9, 0x92, 0x40, 0x93, 0x3E, 0xA2, 0x02, 0x87, + 0x57, 0x81, 0xD3, 0xC9, 0xBB, 0x91, 0xD8, 0xE6 + }, + { + 0x7C, 0x86, 0xD2, 0xF5, 0xE1, 0xC3, 0x57, 0xB3, + 0xDC, 0x9C, 0x9E, 0x2C, 0xAB, 0x9B, 0x80, 0xD4, + 0xED, 0xB5, 0xF1, 0x07, 0x1B, 0x21, 0xB2, 0x9D, + 0x18, 0x13, 0x86, 0xFA, 0x32, 0x37, 0xEA, 0xE3, + 0x38, 0xC2, 0x60, 0xF7, 0x67, 0x02, 0xD1, 0x70, + 0x8E, 0x2A, 0x74, 0xD9, 0x74, 0xB2, 0x2E, 0xEF, + 0xB7, 0x72, 0x52, 0xA8, 0x38, 0x90, 0xF4, 0x21, + 0x56, 0xD6, 0x56, 0xFC, 0xB6, 0xA7, 0xFD, 0x9C + }, + { + 0x63, 0x02, 0x35, 0xE9, 0xF6, 0x04, 0x3F, 0x04, + 0xA2, 0x2B, 0xBB, 0x94, 0x7C, 0xBE, 0x1E, 0x4F, + 0xCC, 0x5E, 0xD7, 0xB9, 0x1A, 0xC3, 0x9E, 0x0E, + 0xB6, 0xB9, 0x7F, 0x48, 0x85, 0x91, 0xF9, 0x60, + 0x1A, 0x05, 0x38, 0xB5, 0x95, 0x1B, 0x2D, 0xB7, + 0x02, 0x6E, 0x20, 0xE2, 0xBF, 0xEB, 0x31, 0x7B, + 0x50, 0x9E, 0xFC, 0x14, 0x91, 0x78, 0xE7, 0xF5, + 0x6A, 0x34, 0xA7, 0x19, 0x6D, 0x6B, 0xD2, 0xC1 + }, + { + 0x73, 0x4A, 0x22, 0x9A, 0xA5, 0x54, 0xEB, 0xD8, + 0x00, 0x07, 0x3A, 0xA5, 0x3F, 0xA7, 0x01, 0x9C, + 0x1D, 0xF8, 0x56, 0xBE, 0xFD, 0xC0, 0xEB, 0xA8, + 0x34, 0x13, 0x8E, 0x83, 0x83, 0xB5, 0xF9, 0x1A, + 0x2C, 0xD2, 0xF0, 0x62, 0x81, 0x17, 0x0C, 0xF9, + 0x79, 0x17, 0x85, 0xC0, 0x4D, 0xF4, 0xE6, 0x8E, + 0x5C, 0x0A, 0xB4, 0xCE, 0xCA, 0x8C, 0x34, 0x2F, + 0x4A, 0x6B, 0x7D, 0x84, 0xBF, 0x2F, 0x4D, 0x25 + }, + { + 0x73, 0xDA, 0xF1, 0xC1, 0x53, 0x87, 0x3F, 0xCD, + 0x9D, 0xB5, 0xBA, 0x3A, 0x7B, 0x8C, 0x43, 0xE4, + 0xAA, 0x3D, 0x2F, 0x7F, 0x5B, 0x27, 0xE9, 0xDB, + 0x82, 0x97, 0xE4, 0x14, 0x81, 0x98, 0xF4, 0x0D, + 0xB9, 0x6E, 0x33, 0x96, 0xD8, 0x28, 0x91, 0xFA, + 0x86, 0x5C, 0xA9, 0x96, 0x73, 0xF0, 0xBF, 0x4E, + 0xC1, 0x61, 0x02, 0xC9, 0xA4, 0xF0, 0x6C, 0xB8, + 0xC0, 0xDB, 0x05, 0xDF, 0xCA, 0x08, 0x11, 0x8D + }, + { + 0x94, 0x82, 0x21, 0xB2, 0xBD, 0x93, 0xA4, 0xAB, + 0x59, 0x04, 0xE6, 0x92, 0x9A, 0xA1, 0xAA, 0xAD, + 0x38, 0x1C, 0x4E, 0xB2, 0x8D, 0x08, 0x77, 0xFC, + 0xDF, 0x16, 0xC3, 0x99, 0xBD, 0x96, 0x72, 0x85, + 0xA5, 0x98, 0xD2, 0x0A, 0x98, 0x8E, 0xFE, 0xA2, + 0xBC, 0xE2, 0x51, 0xDD, 0x4A, 0x92, 0x56, 0x3C, + 0xB2, 0x6C, 0x5B, 0x17, 0x26, 0x94, 0xFE, 0x0E, + 0x17, 0x35, 0xB7, 0x75, 0x76, 0x1A, 0x47, 0x95 + }, + { + 0x24, 0xB1, 0x8D, 0x95, 0xA7, 0xDB, 0x83, 0x28, + 0xDE, 0x72, 0x5F, 0xD4, 0x8A, 0x42, 0x5A, 0xB7, + 0xC5, 0x9B, 0x76, 0xEE, 0xC4, 0xE5, 0x53, 0xED, + 0xB6, 0xF2, 0x87, 0x61, 0xB3, 0x91, 0x0B, 0x3F, + 0x20, 0xFE, 0x06, 0x1C, 0xA2, 0x70, 0x33, 0x3C, + 0x26, 0xD4, 0x49, 0xD2, 0xC1, 0x4D, 0x8D, 0x43, + 0x96, 0xC0, 0x44, 0xA4, 0xD5, 0x61, 0xF9, 0xE9, + 0xCD, 0x50, 0xC5, 0x6C, 0x35, 0x74, 0xB9, 0x47 + }, + { + 0x45, 0x2E, 0x1B, 0xD4, 0x70, 0x1B, 0x6B, 0xE9, + 0x1C, 0x10, 0x19, 0x45, 0x15, 0x27, 0x60, 0xBB, + 0xA8, 0x68, 0xF4, 0x9F, 0x70, 0xFF, 0xF4, 0x1F, + 0x54, 0xF6, 0x7E, 0xEF, 0x72, 0x4A, 0xFA, 0x6B, + 0x2C, 0xCD, 0x3A, 0x54, 0xDD, 0x04, 0xD6, 0x10, + 0x06, 0x24, 0xB6, 0xF8, 0xFD, 0xD3, 0xBB, 0x6B, + 0x0C, 0xDA, 0xF3, 0xAD, 0xD6, 0x69, 0x98, 0xB1, + 0x7E, 0x8A, 0x1D, 0x4E, 0xB0, 0x15, 0x77, 0xAF + }, + { + 0x7B, 0xD7, 0xF2, 0x24, 0x07, 0x8F, 0x0D, 0xA0, + 0x19, 0x3E, 0x5B, 0x57, 0xED, 0xBC, 0xE7, 0x7E, + 0x85, 0x0A, 0xFB, 0x75, 0x1E, 0x5E, 0x5C, 0x04, + 0x25, 0x68, 0xAF, 0x51, 0x52, 0xE3, 0x69, 0xB6, + 0x21, 0xF9, 0xA9, 0x01, 0x72, 0x58, 0x60, 0x92, + 0x0E, 0x23, 0xBB, 0x82, 0xA2, 0x75, 0xDB, 0x15, + 0x7A, 0x8A, 0xBB, 0xD6, 0x87, 0xF8, 0x73, 0x34, + 0x37, 0x2E, 0x29, 0xAB, 0x13, 0xD4, 0x15, 0xEF + }, + { + 0x49, 0xED, 0xEA, 0x21, 0xAA, 0x33, 0xE1, 0x1E, + 0x35, 0x82, 0x4A, 0x00, 0x95, 0xF9, 0xC8, 0x95, + 0x6B, 0x52, 0x8C, 0xF2, 0x73, 0x29, 0xD1, 0x91, + 0x37, 0x15, 0x67, 0x6F, 0x15, 0x42, 0x74, 0x5E, + 0xCC, 0x83, 0x85, 0x77, 0x46, 0xB5, 0xC6, 0xB7, + 0xB0, 0x89, 0x88, 0xD3, 0xD0, 0x19, 0xDB, 0x63, + 0xB9, 0xFE, 0x49, 0x41, 0x8C, 0x9E, 0x57, 0x1F, + 0xE4, 0xAA, 0x1D, 0xAC, 0xCF, 0xA5, 0x6E, 0xC5 + }, + { + 0x06, 0xFF, 0x65, 0xE8, 0xCC, 0xBA, 0x13, 0x9F, + 0x34, 0x99, 0x20, 0x18, 0xBC, 0xB2, 0x38, 0xB0, + 0x73, 0x32, 0x90, 0x20, 0xDE, 0x6E, 0xE7, 0x89, + 0xF9, 0x70, 0x81, 0x2C, 0x27, 0xCE, 0x6A, 0xDE, + 0xDC, 0x6B, 0x7C, 0xF5, 0x45, 0xDB, 0xB9, 0x93, + 0x5E, 0x12, 0x33, 0xD4, 0xD5, 0x9E, 0x48, 0x47, + 0xCA, 0x8D, 0xE8, 0xC4, 0xC8, 0x59, 0x0B, 0xB1, + 0xA8, 0x7A, 0x68, 0x1D, 0x67, 0xCE, 0x1F, 0x07 + }, + { + 0x73, 0x6F, 0x4A, 0x14, 0xFA, 0xB5, 0xE3, 0x34, + 0x33, 0x31, 0xC1, 0x4C, 0x5D, 0x66, 0x6A, 0xB0, + 0x46, 0x31, 0x16, 0x5F, 0x5F, 0x5A, 0x11, 0xFB, + 0x93, 0x5F, 0xF0, 0xB3, 0xD2, 0x19, 0xD2, 0xC5, + 0xED, 0x90, 0x43, 0x60, 0x77, 0x3A, 0x19, 0x8C, + 0x58, 0xBE, 0x9D, 0xD2, 0x6C, 0x8D, 0xBB, 0x94, + 0x08, 0xF4, 0x64, 0x94, 0x65, 0x09, 0x80, 0x1C, + 0x2F, 0xCC, 0xE0, 0x6F, 0x85, 0xAA, 0x6B, 0xD4 + }, + { + 0x15, 0x91, 0x02, 0x3F, 0xB0, 0xC0, 0x11, 0x9B, + 0xA9, 0xD2, 0x38, 0x1B, 0xE4, 0xC0, 0xC0, 0xCE, + 0x09, 0x8D, 0x3D, 0xF7, 0x25, 0x0D, 0x17, 0x37, + 0xB1, 0x3F, 0x24, 0x8E, 0xD6, 0x01, 0x2A, 0xCF, + 0xD4, 0x8A, 0x6B, 0x08, 0x38, 0x4B, 0x8B, 0x09, + 0x01, 0x34, 0xE0, 0x2C, 0x0D, 0xE7, 0xC7, 0xB0, + 0x6E, 0xD8, 0x1F, 0x3F, 0xCF, 0x21, 0x1E, 0xEC, + 0x77, 0xCD, 0x9A, 0x4C, 0xDB, 0x7C, 0xFB, 0xAC + }, + { + 0xA5, 0xE7, 0xE6, 0x29, 0xA0, 0xB8, 0xAA, 0xAF, + 0x34, 0xA9, 0xF5, 0x1F, 0x35, 0x9B, 0xA0, 0x43, + 0x0A, 0xE0, 0x75, 0xF1, 0xAB, 0xAD, 0x74, 0x55, + 0x05, 0xAE, 0x1C, 0x51, 0x83, 0xBC, 0x60, 0xA5, + 0x86, 0x93, 0xB4, 0x4A, 0x9A, 0x8A, 0x9D, 0xE4, + 0xB9, 0x92, 0x44, 0xE9, 0xF4, 0xEE, 0x07, 0x78, + 0x98, 0x26, 0x3A, 0x48, 0x55, 0xFF, 0xF7, 0x8C, + 0x5A, 0xBD, 0x93, 0x8C, 0xA2, 0xC7, 0xDD, 0xA6 + }, + { + 0xAA, 0xBF, 0xB3, 0x4D, 0xF0, 0x68, 0x2E, 0xFD, + 0x0C, 0x19, 0xE9, 0x3E, 0x0F, 0x5A, 0x85, 0x63, + 0x13, 0xFB, 0x18, 0xA3, 0x39, 0x93, 0x00, 0xA0, + 0x9D, 0xB3, 0xE6, 0x77, 0x03, 0xE9, 0x7C, 0xCE, + 0xE7, 0x63, 0xE1, 0xA4, 0x5F, 0xCA, 0x0F, 0x25, + 0xD9, 0xF6, 0x46, 0xB0, 0x51, 0x91, 0x1F, 0x03, + 0x4C, 0x26, 0x89, 0x57, 0x4E, 0xB5, 0x4F, 0x02, + 0x24, 0x88, 0xD9, 0x44, 0xC0, 0xC7, 0x48, 0x49 + }, + { + 0xC9, 0x41, 0x1A, 0xE6, 0x1D, 0xCA, 0x7C, 0x4C, + 0x83, 0x98, 0x75, 0xA9, 0xEE, 0x75, 0x1B, 0x24, + 0x93, 0x36, 0x6C, 0x64, 0xEF, 0x85, 0x19, 0xB5, + 0x27, 0xB4, 0xEC, 0x4F, 0xE8, 0xF6, 0x08, 0x23, + 0xC2, 0xA5, 0x9F, 0xEC, 0x9E, 0x73, 0xB6, 0x11, + 0x89, 0xEE, 0x20, 0xBD, 0x63, 0xB0, 0x98, 0xF8, + 0x79, 0x10, 0x1C, 0xDC, 0xBC, 0xB7, 0x50, 0xD7, + 0xDE, 0xF4, 0xDB, 0x99, 0x5C, 0x04, 0x92, 0x26 + }, + { + 0xCF, 0x35, 0xDF, 0xAF, 0xF8, 0x49, 0xE0, 0xA5, + 0x2C, 0xCA, 0xEE, 0x2B, 0xF0, 0x5B, 0x34, 0x43, + 0x40, 0x12, 0x66, 0x45, 0x26, 0xF8, 0x38, 0xAE, + 0x08, 0x9A, 0x13, 0x8E, 0x4C, 0x45, 0x91, 0xE4, + 0xB1, 0x89, 0xA5, 0xDC, 0x60, 0xF9, 0x97, 0x16, + 0xBA, 0x53, 0xFC, 0xE2, 0x95, 0x69, 0x30, 0x8D, + 0x06, 0x0C, 0x81, 0x3E, 0xCB, 0x0E, 0xF5, 0xFA, + 0xB2, 0xD1, 0x2B, 0xF6, 0x37, 0x2A, 0x54, 0xF8 + }, + { + 0xA1, 0x9B, 0x94, 0x2C, 0x7F, 0xAB, 0xEC, 0x14, + 0xB1, 0x5B, 0x33, 0xC9, 0x40, 0xEE, 0xC8, 0x42, + 0x34, 0x61, 0x16, 0x78, 0x88, 0x6C, 0xEA, 0x63, + 0xE9, 0xD0, 0xD0, 0x26, 0xA8, 0x44, 0x94, 0x0C, + 0x72, 0x80, 0x3E, 0x63, 0x8E, 0x38, 0x9E, 0x90, + 0x99, 0xF8, 0x02, 0xC6, 0x48, 0xBD, 0x1D, 0xA3, + 0xFA, 0x44, 0xB2, 0x65, 0xE6, 0xA5, 0x9E, 0x9E, + 0x18, 0x19, 0xAB, 0x91, 0x00, 0xD9, 0xC5, 0x16 + }, + { + 0xBE, 0x19, 0xCF, 0x99, 0x8F, 0x9D, 0x84, 0xB5, + 0x1D, 0xE3, 0x20, 0xF8, 0x59, 0x92, 0x5E, 0x49, + 0x96, 0x48, 0x6E, 0xD5, 0x73, 0xB6, 0xDF, 0x6A, + 0x80, 0x34, 0xF2, 0x02, 0x36, 0xE4, 0x2E, 0x70, + 0x72, 0xFC, 0xBA, 0x52, 0x0D, 0x24, 0xB1, 0xCE, + 0xDC, 0x5A, 0x00, 0xC2, 0x57, 0x18, 0x8D, 0xC1, + 0x41, 0xCD, 0xE2, 0x1F, 0x05, 0x16, 0x0D, 0x3C, + 0x55, 0xF5, 0x66, 0x68, 0x07, 0x79, 0x4F, 0xC5 + }, + { + 0x28, 0xDB, 0x22, 0xF8, 0x65, 0xE4, 0xE2, 0xED, + 0x1E, 0x8E, 0x10, 0x34, 0x20, 0xCE, 0x71, 0x4D, + 0x0B, 0xCD, 0xFD, 0x20, 0x0C, 0x48, 0x3A, 0x9A, + 0x9A, 0x0C, 0xE7, 0x9A, 0x5B, 0x60, 0xB7, 0xE1, + 0xA0, 0x29, 0x94, 0x6E, 0xAA, 0x3C, 0x69, 0xFF, + 0xF8, 0x63, 0x18, 0x5F, 0x33, 0x19, 0xA1, 0x41, + 0x43, 0x80, 0xEA, 0xB0, 0x26, 0x27, 0x95, 0xBE, + 0x13, 0x68, 0x4E, 0x7A, 0xAD, 0x25, 0xA5, 0xDE + }, + { + 0x47, 0x57, 0x58, 0x85, 0x96, 0xEA, 0x8D, 0xAE, + 0xAB, 0x3B, 0x00, 0xAB, 0x42, 0x74, 0x4E, 0xC9, + 0x20, 0xE0, 0x10, 0xDB, 0x38, 0x11, 0xB0, 0x21, + 0x7C, 0xC7, 0xF4, 0x89, 0x37, 0x50, 0x78, 0x44, + 0xB2, 0x5B, 0x76, 0x77, 0x3E, 0x3A, 0xFD, 0x77, + 0x26, 0xB7, 0xA0, 0x73, 0x5B, 0xD8, 0x51, 0xB7, + 0x53, 0xAB, 0x30, 0x22, 0x0D, 0x72, 0x44, 0x47, + 0xCE, 0x87, 0x72, 0x80, 0xC4, 0x63, 0x22, 0x92 + }, + { + 0xC3, 0x72, 0x2F, 0x1D, 0x83, 0xA4, 0xF6, 0x30, + 0x62, 0xB9, 0xAE, 0x96, 0x0A, 0x9E, 0x5A, 0xA9, + 0x76, 0xA5, 0xD9, 0x3E, 0xA9, 0xEE, 0x29, 0xD9, + 0xBE, 0x95, 0xA9, 0x7A, 0x5C, 0xC9, 0x71, 0x30, + 0x5F, 0x59, 0x23, 0xCB, 0x2C, 0xA2, 0x9C, 0x13, + 0x19, 0x75, 0xB8, 0x77, 0xB7, 0x85, 0xC2, 0x2D, + 0x97, 0xF1, 0x58, 0x91, 0x8A, 0x18, 0xB3, 0x56, + 0xCC, 0xB0, 0xA0, 0x85, 0x16, 0xFE, 0x24, 0xFE + }, + { + 0x32, 0x95, 0xEC, 0x73, 0x85, 0x7E, 0x45, 0x22, + 0x30, 0x3B, 0x80, 0xCE, 0x5F, 0x8C, 0x63, 0xED, + 0x34, 0x62, 0x04, 0x99, 0x51, 0x48, 0x2A, 0x49, + 0x7E, 0x6F, 0xAE, 0x2B, 0xFC, 0x35, 0x4C, 0x4D, + 0x96, 0x5C, 0x87, 0x9C, 0x7C, 0x7E, 0x11, 0x86, + 0xA1, 0xFE, 0x48, 0xFC, 0x88, 0x82, 0x23, 0x01, + 0x81, 0x1B, 0xE1, 0x31, 0xDE, 0x70, 0x6E, 0x18, + 0x75, 0x80, 0x4D, 0xA0, 0x2A, 0xBA, 0xF5, 0x0B + }, + { + 0x33, 0x3D, 0xA0, 0xF5, 0xAE, 0x49, 0xC1, 0x9D, + 0x29, 0xFC, 0x10, 0x6B, 0x45, 0xEB, 0xAC, 0xB8, + 0xEA, 0x6C, 0x54, 0x7A, 0x38, 0xCA, 0x20, 0xA9, + 0x3F, 0xD7, 0x37, 0x63, 0x23, 0x04, 0x8E, 0x1D, + 0x05, 0x13, 0xF9, 0x82, 0x0B, 0x76, 0x49, 0x8E, + 0x80, 0xFB, 0xE7, 0xF9, 0xBA, 0x82, 0x2B, 0xCA, + 0xC4, 0xA4, 0x19, 0x2A, 0xBC, 0x25, 0x33, 0xAD, + 0x53, 0x33, 0x23, 0x6F, 0x8E, 0x7A, 0x90, 0x99 + }, + { + 0xCE, 0xD6, 0x2E, 0x1B, 0xD5, 0x91, 0x10, 0xC2, + 0x27, 0x45, 0x8E, 0xE9, 0x33, 0x57, 0x74, 0x6B, + 0x4D, 0xB6, 0xEC, 0x52, 0xE4, 0x11, 0x97, 0xAF, + 0x98, 0xB4, 0xC7, 0xB5, 0xCE, 0x3F, 0xD9, 0xE9, + 0x73, 0x6A, 0x68, 0xB7, 0xE0, 0xDD, 0x37, 0xB4, + 0x88, 0xBD, 0x98, 0x16, 0xD4, 0x1F, 0x88, 0xA4, + 0xC6, 0xD7, 0xC9, 0xD7, 0x69, 0xE7, 0x5C, 0x5B, + 0x34, 0xD3, 0x23, 0x74, 0xE3, 0xBB, 0x79, 0x51 + }, + { + 0x0E, 0x73, 0xC9, 0x4A, 0xE8, 0x51, 0x92, 0xEB, + 0xD0, 0xC2, 0x51, 0xDD, 0x2E, 0x53, 0xEE, 0xD1, + 0x02, 0x31, 0x64, 0x12, 0x13, 0xED, 0x03, 0x8E, + 0x7A, 0x52, 0x6C, 0xE1, 0x6D, 0x72, 0x96, 0x83, + 0xC2, 0xF6, 0xCF, 0xC6, 0xCC, 0x17, 0x2E, 0x1C, + 0xB5, 0x62, 0x29, 0xCB, 0xAF, 0x03, 0xAE, 0x87, + 0xC3, 0xE6, 0xB9, 0xA0, 0x65, 0x31, 0xCE, 0xE6, + 0xE8, 0x19, 0x72, 0xD4, 0xB6, 0x92, 0x19, 0x0C + }, + { + 0xCE, 0xFD, 0xE9, 0x0B, 0x5F, 0x01, 0x6C, 0x4A, + 0x68, 0x93, 0xD0, 0x40, 0x40, 0x41, 0xC3, 0xFF, + 0xF8, 0x6E, 0x66, 0xAC, 0x9D, 0x68, 0x1B, 0x15, + 0x98, 0xAE, 0x15, 0xAD, 0xCD, 0x95, 0x3F, 0xC5, + 0x1D, 0xAE, 0x32, 0x1D, 0xB5, 0xA6, 0xBD, 0x05, + 0x3A, 0xAA, 0x53, 0x91, 0x19, 0x73, 0x20, 0x4E, + 0xFD, 0x10, 0x12, 0xBE, 0xD2, 0xE6, 0x52, 0x1B, + 0xD2, 0xEE, 0x70, 0xD1, 0x2E, 0x16, 0x3F, 0x1A + }, + { + 0x25, 0xAC, 0x0D, 0x7B, 0xD2, 0xCD, 0x2E, 0x29, + 0xED, 0x4E, 0xC1, 0xFB, 0xD5, 0x28, 0xCC, 0x0D, + 0xB0, 0xB2, 0xEB, 0xC0, 0xA8, 0x2E, 0x2F, 0x8E, + 0x9A, 0xF0, 0x07, 0xE2, 0x6E, 0xD0, 0x96, 0x53, + 0x86, 0xCD, 0x66, 0xB8, 0x3F, 0x26, 0xA9, 0xCF, + 0x1B, 0xDF, 0xF1, 0xCF, 0x99, 0xD7, 0xB2, 0x64, + 0xD9, 0x00, 0x94, 0x7A, 0x52, 0xE4, 0x83, 0xCB, + 0x81, 0x89, 0x39, 0xCA, 0x28, 0xF8, 0x11, 0xED + }, + { + 0xD1, 0x3B, 0xD4, 0x94, 0x4E, 0xF2, 0x92, 0x1F, + 0xA0, 0xE4, 0x94, 0x4D, 0xA0, 0xE5, 0x7B, 0x84, + 0x01, 0xF6, 0xC0, 0x01, 0x4E, 0xA6, 0x14, 0xB3, + 0xBE, 0xA4, 0x55, 0x05, 0xE7, 0xCA, 0x51, 0x49, + 0x81, 0x85, 0xEF, 0x7D, 0x28, 0x88, 0x1B, 0x41, + 0xE6, 0x89, 0x74, 0x8A, 0x9E, 0xFE, 0xF5, 0xF8, + 0xBE, 0xA3, 0x9B, 0xFC, 0x7B, 0x45, 0x3C, 0x63, + 0x1E, 0x55, 0x39, 0x6B, 0x2D, 0x2E, 0x22, 0xC5 + }, + { + 0x1B, 0x07, 0x08, 0x47, 0xE0, 0x7A, 0x62, 0x84, + 0x9C, 0xE5, 0xFC, 0xE9, 0x1A, 0xFA, 0xEF, 0xB5, + 0xE4, 0x05, 0xD0, 0x6F, 0x4D, 0x09, 0x07, 0x1F, + 0x0B, 0x11, 0x0E, 0xC1, 0x0E, 0x87, 0x0E, 0x5E, + 0x92, 0xB3, 0x2F, 0x10, 0xEB, 0xF4, 0xC3, 0xB7, + 0x92, 0x1B, 0x9C, 0x07, 0x2E, 0x7F, 0x25, 0x73, + 0x4E, 0x72, 0x28, 0x2C, 0xCA, 0x6B, 0x95, 0x7B, + 0x23, 0x41, 0xE0, 0x6D, 0x53, 0xC7, 0x93, 0xB9 + }, + { + 0x41, 0xB2, 0x97, 0xDD, 0x68, 0x4E, 0x5D, 0xD9, + 0x4D, 0xF1, 0x1D, 0x02, 0xC7, 0xD6, 0x7F, 0x5E, + 0xC3, 0xE5, 0x6C, 0xB8, 0xA9, 0x8B, 0xA2, 0xBD, + 0x65, 0x6C, 0x2D, 0x65, 0x14, 0x84, 0x5E, 0xE5, + 0xC1, 0xAC, 0x53, 0x55, 0x81, 0x1D, 0x79, 0x9F, + 0x11, 0x5F, 0xB8, 0x79, 0xDE, 0x9E, 0x2C, 0xC2, + 0x7E, 0x03, 0x6D, 0x2C, 0xA4, 0x79, 0x1B, 0x96, + 0x9F, 0xFD, 0x9F, 0x15, 0x9E, 0xF8, 0x29, 0x41 + }, + { + 0xF3, 0xF8, 0x95, 0x02, 0xC2, 0x83, 0xD7, 0x67, + 0x4F, 0xD9, 0x0D, 0x36, 0x1B, 0xD7, 0x96, 0xFE, + 0xEC, 0x5D, 0x3B, 0x5C, 0xA5, 0x7D, 0x14, 0x84, + 0x52, 0x17, 0x71, 0xC3, 0x47, 0xB6, 0x60, 0xF6, + 0x15, 0xD9, 0x0F, 0xE3, 0xC9, 0xA0, 0xAF, 0xEF, + 0x68, 0x14, 0xB9, 0xD7, 0xF2, 0x4B, 0x13, 0x0B, + 0x05, 0xF4, 0x3C, 0x88, 0x9E, 0x1A, 0x6D, 0xC7, + 0xB8, 0xB1, 0xE5, 0x7E, 0xD6, 0x1A, 0x1E, 0xAA + }, + { + 0xE4, 0xF7, 0xB9, 0x22, 0x13, 0x02, 0xE6, 0xF6, + 0x33, 0x94, 0xA8, 0xAF, 0xB9, 0x9A, 0x8B, 0x39, + 0xF4, 0x0F, 0x81, 0xCD, 0xD5, 0xF3, 0x15, 0x55, + 0x6A, 0x17, 0x7E, 0xA3, 0x4F, 0x10, 0x88, 0x79, + 0x6B, 0x85, 0x5D, 0x31, 0x22, 0x81, 0x20, 0x98, + 0x67, 0xAF, 0xDC, 0xB7, 0x94, 0x96, 0x23, 0x05, + 0x81, 0xDF, 0x64, 0x5B, 0x3D, 0x0A, 0x2B, 0x3E, + 0x94, 0xA5, 0x94, 0xFB, 0xE2, 0xFB, 0x1B, 0x63 + }, + { + 0xC3, 0x2D, 0x12, 0x3B, 0x4A, 0x6B, 0x10, 0x62, + 0x4D, 0x03, 0xB5, 0xAF, 0xE2, 0x9B, 0xEB, 0x53, + 0x2E, 0xC2, 0xD6, 0x51, 0x81, 0x19, 0x44, 0xFD, + 0xB0, 0xE0, 0x35, 0xEB, 0xDA, 0xC0, 0x95, 0x4D, + 0xAB, 0x74, 0xC2, 0x32, 0x1D, 0x24, 0xA4, 0xBA, + 0xA7, 0x71, 0x23, 0x43, 0x86, 0x40, 0x0A, 0x99, + 0x3A, 0xA7, 0x81, 0x9A, 0x23, 0xE7, 0x12, 0x6F, + 0x21, 0x82, 0x72, 0xB1, 0x55, 0xF6, 0xC7, 0xF5 + }, + { + 0x97, 0xEF, 0xAD, 0x5E, 0x3B, 0x80, 0xAF, 0x09, + 0xAF, 0x34, 0x27, 0x9A, 0x49, 0xB1, 0x5F, 0x39, + 0xCE, 0x0C, 0x8E, 0x29, 0xEB, 0xBD, 0x75, 0x60, + 0x7F, 0x59, 0xD6, 0xF6, 0xD1, 0x45, 0xCE, 0x9A, + 0x1F, 0xA8, 0xC3, 0xF3, 0x10, 0xA0, 0x75, 0x79, + 0xD3, 0x36, 0x57, 0xAF, 0xD5, 0x07, 0x17, 0x2E, + 0x71, 0x21, 0x95, 0xE3, 0xDB, 0x1B, 0xF5, 0x5F, + 0xD5, 0xB8, 0x6C, 0xBB, 0xED, 0x48, 0x9F, 0x20 + }, + { + 0xD8, 0xFD, 0x87, 0xE8, 0x24, 0x04, 0xC2, 0x67, + 0xC4, 0xC3, 0x46, 0x69, 0x4D, 0xC0, 0xC2, 0xE7, + 0xB0, 0xEB, 0x8D, 0x8A, 0x6A, 0xE4, 0x2B, 0xB4, + 0x53, 0xA4, 0x55, 0x0B, 0x75, 0xC8, 0x14, 0x37, + 0x11, 0xE7, 0xC6, 0xA4, 0xE8, 0x5F, 0x5E, 0x68, + 0xBD, 0x8C, 0xED, 0xF6, 0x19, 0x66, 0x35, 0x83, + 0x80, 0xD1, 0xFD, 0x15, 0x0E, 0xF3, 0xF0, 0x2E, + 0xCF, 0x7A, 0x6D, 0xAD, 0x68, 0xB0, 0x26, 0x1B + }, + { + 0xE2, 0x0E, 0xE9, 0x44, 0x71, 0xFB, 0xC4, 0x69, + 0x65, 0xB8, 0x33, 0xCA, 0xBB, 0xFE, 0xE1, 0x80, + 0x39, 0x66, 0xE5, 0x5E, 0x8A, 0x3B, 0xAE, 0x8E, + 0x02, 0x15, 0x1D, 0xA5, 0x99, 0x2E, 0x28, 0xEF, + 0xC5, 0x94, 0x31, 0xA9, 0x67, 0x79, 0xD0, 0x10, + 0xF5, 0xA1, 0x3C, 0xF8, 0x2B, 0x52, 0xED, 0x28, + 0x6A, 0xC7, 0xB1, 0x48, 0x6A, 0x3F, 0x8D, 0xF8, + 0x3B, 0xE3, 0x85, 0xF2, 0xDA, 0x9D, 0x42, 0xDC + }, + { + 0xA6, 0xBD, 0x13, 0x42, 0x3E, 0xA7, 0x00, 0x8C, + 0xB9, 0x30, 0xE0, 0xAB, 0x1F, 0xEA, 0xD7, 0x1C, + 0xEA, 0xD3, 0x75, 0x0E, 0x6E, 0x41, 0xF3, 0x1E, + 0x88, 0x23, 0x36, 0x96, 0x8B, 0x73, 0xBE, 0x3E, + 0x4E, 0x72, 0x4D, 0x78, 0x90, 0xEE, 0x7C, 0xF5, + 0xA1, 0xEC, 0x9A, 0xF3, 0x79, 0x8D, 0xA9, 0x67, + 0x1E, 0xB3, 0xE1, 0xEB, 0x45, 0xC9, 0xC0, 0xB9, + 0x5C, 0xD3, 0x10, 0x7D, 0x78, 0x58, 0x56, 0x2F + }, + { + 0xFC, 0x97, 0x17, 0x61, 0x22, 0x59, 0x63, 0x30, + 0xE2, 0x2A, 0xB5, 0xC6, 0x26, 0xF5, 0xAA, 0xBF, + 0xD6, 0x48, 0x92, 0xE5, 0x03, 0xA6, 0xD9, 0x89, + 0x5D, 0x8E, 0x63, 0x8B, 0x54, 0x61, 0x27, 0xFC, + 0x5E, 0x2D, 0x77, 0xF7, 0xB5, 0xB4, 0x09, 0x88, + 0x67, 0x16, 0x8B, 0x39, 0xB1, 0xB6, 0xC3, 0xEC, + 0xAC, 0xCD, 0x26, 0xBE, 0x83, 0x7D, 0xC5, 0xF8, + 0x74, 0x34, 0xAF, 0x10, 0x8B, 0xA9, 0xA9, 0x9A + }, + { + 0xDE, 0x60, 0xAE, 0x86, 0x74, 0x2A, 0x5A, 0xB9, + 0x14, 0x1D, 0xF7, 0xFA, 0xE2, 0x94, 0xE3, 0x97, + 0xCA, 0x60, 0x61, 0xB6, 0x84, 0x97, 0x6E, 0x6B, + 0x79, 0x27, 0x8E, 0x20, 0x05, 0x79, 0x49, 0x81, + 0x4C, 0xEA, 0xDD, 0x13, 0x0B, 0xF5, 0x3C, 0x51, + 0x47, 0x58, 0x78, 0xB1, 0x35, 0xD3, 0x96, 0x10, + 0x08, 0x36, 0xCD, 0xAC, 0x27, 0x54, 0x73, 0x43, + 0xB9, 0xF1, 0xC3, 0x8B, 0x33, 0x6C, 0x79, 0xCA + }, + { + 0xB6, 0xCF, 0x01, 0x4A, 0xDE, 0xFF, 0xF4, 0xE9, + 0xA2, 0xDB, 0x94, 0x21, 0x0A, 0x68, 0xDC, 0xEC, + 0x70, 0x69, 0x30, 0x52, 0x2F, 0x9A, 0xFB, 0xA4, + 0xB2, 0xAD, 0xBB, 0x00, 0x77, 0xFC, 0xCB, 0xE2, + 0x53, 0x7B, 0xAE, 0x53, 0xF8, 0x2E, 0xF5, 0x7B, + 0x9D, 0xD8, 0x29, 0x7A, 0xD0, 0x02, 0xB4, 0xD9, + 0x23, 0xD9, 0x9F, 0x4C, 0xD1, 0x69, 0x51, 0xFE, + 0x73, 0x27, 0x48, 0xB6, 0x2E, 0x4C, 0xED, 0x75 + }, + { + 0x80, 0xAA, 0xAA, 0xCD, 0xCC, 0x21, 0x05, 0xD1, + 0xAE, 0x3E, 0xCA, 0x82, 0x6D, 0xCB, 0x9B, 0x63, + 0x4F, 0x4C, 0xB1, 0xD9, 0x23, 0x64, 0xC1, 0x21, + 0x89, 0xEA, 0x66, 0x45, 0xF2, 0x70, 0x5A, 0xDC, + 0x27, 0x76, 0x41, 0xCB, 0xA6, 0x1B, 0xAF, 0xE2, + 0x81, 0xEC, 0x5C, 0xE0, 0x30, 0x1A, 0xBB, 0x89, + 0x46, 0x12, 0x42, 0x9E, 0x66, 0xD2, 0x72, 0x8C, + 0x08, 0x71, 0x62, 0xB7, 0x01, 0x64, 0xD7, 0xEB + }, + { + 0x1B, 0x4E, 0xD7, 0xC6, 0xD5, 0x21, 0xAB, 0xBB, + 0x8F, 0xF3, 0x6F, 0xDC, 0x6A, 0x0E, 0x33, 0x7D, + 0x4F, 0x8E, 0xE8, 0xD5, 0x22, 0x42, 0x91, 0xED, + 0xE6, 0xFD, 0xEB, 0xAE, 0x3D, 0xB7, 0x1E, 0x77, + 0xFD, 0x70, 0x82, 0x33, 0x87, 0x77, 0x24, 0x9B, + 0x2D, 0x17, 0x5F, 0x0C, 0xE2, 0x32, 0xBC, 0x6A, + 0x59, 0x6A, 0xF4, 0x0B, 0xB9, 0x5C, 0x8A, 0x9A, + 0x6C, 0x16, 0x75, 0x57, 0x30, 0x5B, 0xB1, 0x7E + }, + { + 0xBA, 0x86, 0xC0, 0xA4, 0xE5, 0xFA, 0xD1, 0x15, + 0x89, 0xBA, 0x3A, 0x7D, 0x33, 0xD9, 0x76, 0x44, + 0xBE, 0xFB, 0xA8, 0x1D, 0x32, 0xBF, 0x0F, 0x6E, + 0xF9, 0x9E, 0xE4, 0xB9, 0x55, 0xD6, 0x63, 0x70, + 0xCC, 0x7B, 0x86, 0x29, 0x34, 0xA3, 0x2C, 0x8C, + 0x1C, 0xEE, 0x61, 0xF1, 0x54, 0xC2, 0xD4, 0x2A, + 0xA6, 0x41, 0x85, 0x8B, 0x11, 0x1C, 0xE6, 0xF4, + 0x64, 0x14, 0xA6, 0x6E, 0x6A, 0x98, 0x43, 0x78 + }, + { + 0xBE, 0xF4, 0x4C, 0x52, 0x1C, 0x26, 0xAF, 0xD7, + 0x8A, 0x78, 0xA0, 0x3C, 0x9A, 0xB7, 0x64, 0xAB, + 0xBA, 0xBF, 0xE0, 0x55, 0x78, 0xB5, 0x73, 0x94, + 0x7F, 0x9E, 0x4A, 0x24, 0xCE, 0x59, 0xE0, 0xB3, + 0xB0, 0x89, 0xE0, 0xC4, 0x28, 0xB4, 0xB0, 0xC4, + 0xF9, 0x3A, 0xD7, 0x7B, 0x2D, 0xCA, 0x21, 0x79, + 0xB4, 0xC8, 0x8C, 0x1E, 0x92, 0xD0, 0xC1, 0x66, + 0x13, 0x93, 0xBD, 0xEC, 0xDF, 0x08, 0x8E, 0xE2 + }, + { + 0x31, 0xFD, 0xDE, 0x34, 0x05, 0x23, 0x14, 0x13, + 0x80, 0xEB, 0x7E, 0xAB, 0x59, 0x8B, 0x0C, 0x98, + 0x53, 0xDF, 0xA8, 0x74, 0xB8, 0x68, 0x73, 0xCC, + 0x3D, 0xFB, 0x7D, 0xB6, 0x55, 0x44, 0x0F, 0xF7, + 0x38, 0x5F, 0x70, 0xCA, 0xA5, 0xF4, 0x38, 0xE3, + 0x07, 0x04, 0x34, 0xDB, 0x29, 0x4C, 0x18, 0x19, + 0xDD, 0x0F, 0x28, 0x56, 0x14, 0x9C, 0x82, 0xD1, + 0x52, 0xE3, 0x86, 0xE2, 0xE3, 0x66, 0xB7, 0x22 + }, + { + 0xC5, 0xD5, 0x7A, 0x0B, 0x41, 0x81, 0xB3, 0x7B, + 0x30, 0x45, 0x5A, 0x97, 0x3F, 0x71, 0x38, 0x79, + 0x39, 0xE4, 0x67, 0xF6, 0x64, 0x71, 0xA5, 0x51, + 0x0C, 0xF9, 0x58, 0x26, 0x1E, 0xB0, 0x3D, 0xDF, + 0xFA, 0x7F, 0x53, 0x09, 0xE5, 0xEF, 0x9B, 0xBB, + 0xEF, 0xD0, 0x2E, 0x73, 0x86, 0x74, 0xCB, 0xBE, + 0xA3, 0x3B, 0x33, 0x1D, 0x59, 0xE6, 0x2F, 0xEB, + 0x9C, 0xE6, 0x7C, 0x7C, 0xD4, 0x74, 0x7A, 0x87 + }, + { + 0x4F, 0xE7, 0x34, 0x2E, 0xAA, 0x78, 0xFE, 0xD0, + 0xEC, 0xAD, 0x6C, 0x4E, 0xF4, 0x1E, 0xB8, 0x9D, + 0xA1, 0x72, 0x08, 0x5F, 0x69, 0xB4, 0x15, 0xE2, + 0x68, 0x40, 0xFA, 0x36, 0xBE, 0x36, 0x2D, 0xA6, + 0x3B, 0xD6, 0xBD, 0x01, 0x16, 0xD5, 0x19, 0x4F, + 0xF7, 0xE4, 0x3C, 0x41, 0x10, 0x12, 0x0E, 0x94, + 0xDF, 0x61, 0xE7, 0xB9, 0xB7, 0xD9, 0x8E, 0x61, + 0x28, 0xF7, 0xD6, 0xD9, 0xEB, 0x23, 0x4C, 0xDF + }, + { + 0x31, 0x8B, 0xBE, 0x9A, 0x86, 0x70, 0xA5, 0x7C, + 0xF5, 0x74, 0x79, 0xEF, 0x73, 0x79, 0xEF, 0xC8, + 0xBD, 0x05, 0xEE, 0xF9, 0x18, 0x37, 0x4A, 0x52, + 0xE0, 0x55, 0x9C, 0x21, 0x91, 0x61, 0x29, 0xF1, + 0xA0, 0xDD, 0xED, 0xEF, 0xF7, 0xC2, 0xAE, 0xF6, + 0x7E, 0x96, 0x63, 0xFC, 0xCB, 0x1D, 0x07, 0xB7, + 0x3F, 0x7D, 0xB3, 0x16, 0xCB, 0x6B, 0xE1, 0xF3, + 0xB0, 0x6F, 0x4F, 0xE6, 0x54, 0xB5, 0xF5, 0xA8 + }, + { + 0x4F, 0x65, 0xE2, 0xD8, 0x2B, 0xDC, 0xF2, 0xBA, + 0x22, 0x98, 0x1A, 0x80, 0xAC, 0x07, 0x71, 0x58, + 0x25, 0x2E, 0x1C, 0x02, 0x0E, 0xB1, 0xB8, 0x54, + 0x71, 0xD3, 0xA3, 0x1D, 0x61, 0x6A, 0x5A, 0x79, + 0xC9, 0xD3, 0x9B, 0x5D, 0x22, 0x86, 0xD7, 0xCC, + 0x4B, 0x72, 0xED, 0x6D, 0x2D, 0xCE, 0x5D, 0xE6, + 0x6E, 0x63, 0x6A, 0xBD, 0x21, 0x0E, 0x8B, 0x66, + 0x87, 0x1B, 0xC5, 0x9C, 0xA7, 0xE1, 0x59, 0x8A + }, + { + 0x3A, 0x12, 0x7A, 0xBD, 0x7F, 0x0F, 0x06, 0xAB, + 0xF0, 0x88, 0x9D, 0xB0, 0x0A, 0x82, 0xEC, 0xE7, + 0x02, 0xAE, 0x29, 0x08, 0x61, 0xC4, 0x9F, 0x8A, + 0xA2, 0xAB, 0x73, 0x75, 0x1D, 0x6C, 0x60, 0xD3, + 0x9C, 0xBF, 0x7E, 0x0D, 0xFF, 0x2E, 0x6F, 0xFC, + 0x0A, 0x8F, 0x2E, 0xC1, 0x74, 0xED, 0x68, 0x1E, + 0x65, 0x75, 0xE7, 0xE6, 0xCF, 0x18, 0x4B, 0x44, + 0xBE, 0x9E, 0x2A, 0x7F, 0xB5, 0x2D, 0x07, 0xFD + }, + { + 0x2A, 0x08, 0x8E, 0xF6, 0xE7, 0x81, 0x41, 0x56, + 0x67, 0x8D, 0xD0, 0x04, 0x64, 0x4D, 0x57, 0xEC, + 0x16, 0x81, 0x18, 0x3B, 0xC4, 0xF5, 0xF5, 0x49, + 0x4B, 0x6C, 0x11, 0x3A, 0x86, 0x49, 0xCF, 0x1F, + 0xD6, 0xBD, 0xF8, 0x64, 0x21, 0xB8, 0xD5, 0x5C, + 0x10, 0x81, 0x0B, 0x3C, 0x5E, 0xB8, 0xB2, 0x58, + 0x2A, 0xD4, 0xF9, 0x98, 0x28, 0x5A, 0xAA, 0xD4, + 0x61, 0x98, 0xDE, 0xA7, 0x4A, 0x5F, 0xED, 0xDD + }, + { + 0xFE, 0xCC, 0xCD, 0x68, 0x41, 0x66, 0xCC, 0xFE, + 0xAB, 0xEE, 0xCA, 0x0B, 0xE9, 0xF0, 0x35, 0x93, + 0x8B, 0xF3, 0xDA, 0x41, 0x8D, 0x2F, 0x2F, 0xE8, + 0xC1, 0xEE, 0xE1, 0x8B, 0x4C, 0x82, 0x6C, 0xC2, + 0xCB, 0x11, 0x26, 0x53, 0x7E, 0xFF, 0x0A, 0xEE, + 0x52, 0x48, 0x2D, 0xA6, 0x56, 0x51, 0x53, 0x30, + 0xE9, 0x2F, 0xF7, 0x04, 0xF4, 0x95, 0x7E, 0x62, + 0x75, 0x52, 0x89, 0x00, 0x99, 0x02, 0x63, 0x21 + }, + { + 0x6D, 0xC0, 0x37, 0xBF, 0x91, 0xDC, 0xD1, 0x68, + 0x5B, 0xD2, 0xBB, 0x9F, 0x02, 0x9D, 0x57, 0x54, + 0xAB, 0x18, 0x38, 0x04, 0xE9, 0x7D, 0xB3, 0xF2, + 0x78, 0xD8, 0x7E, 0x61, 0x19, 0x15, 0xE8, 0x40, + 0x93, 0x99, 0x63, 0xF5, 0x5F, 0xC5, 0xD4, 0x6F, + 0xC0, 0x5F, 0xC3, 0x62, 0x5C, 0x7E, 0x98, 0x42, + 0x91, 0x9C, 0xAF, 0x6A, 0x32, 0x35, 0x90, 0x1E, + 0x42, 0xFC, 0x8B, 0xE6, 0x75, 0x25, 0x11, 0x54 + }, + { + 0x2C, 0x0A, 0xB9, 0xDD, 0x8E, 0x4B, 0x7A, 0x9C, + 0x71, 0x86, 0xEE, 0x65, 0x4A, 0x56, 0x29, 0xC2, + 0xD7, 0xDA, 0x6C, 0x45, 0x5F, 0x3C, 0xBA, 0x97, + 0xBC, 0xFF, 0x28, 0x0F, 0xFF, 0x35, 0x88, 0x91, + 0x15, 0xB5, 0xDA, 0xBA, 0x41, 0x1C, 0x43, 0x51, + 0xEE, 0xEF, 0x70, 0x86, 0x9D, 0xE7, 0xD2, 0x70, + 0x61, 0x12, 0xF7, 0xDF, 0xE0, 0xC9, 0xD7, 0xFD, + 0x4E, 0xD4, 0x40, 0xC5, 0xF2, 0x67, 0xE0, 0x01 + }, + { + 0x80, 0x15, 0xFA, 0x25, 0xB6, 0xF6, 0xF8, 0xBB, + 0x3C, 0x28, 0xC7, 0xBC, 0x65, 0x89, 0x70, 0x1B, + 0xC5, 0xA1, 0x91, 0x6C, 0x9C, 0x15, 0x60, 0xE0, + 0xC6, 0x62, 0xB9, 0x13, 0xAE, 0x8B, 0x24, 0x0E, + 0xAC, 0xBD, 0x77, 0x6B, 0x74, 0xCF, 0x45, 0x82, + 0xEE, 0x74, 0x05, 0x1D, 0xCE, 0x39, 0x11, 0x44, + 0x4B, 0x1A, 0xC1, 0x6A, 0xF0, 0x5E, 0x26, 0x2D, + 0xCB, 0x4E, 0x31, 0x80, 0x2E, 0x44, 0x9D, 0xBE + }, + { + 0x84, 0x30, 0x9E, 0x10, 0x5C, 0x49, 0x64, 0x7F, + 0x42, 0x51, 0xA3, 0x47, 0xB3, 0x5D, 0xA2, 0x61, + 0xEE, 0x8F, 0xF9, 0x11, 0x8A, 0x99, 0x72, 0x1E, + 0xAD, 0xFF, 0xD4, 0xC7, 0x9E, 0xF2, 0xF9, 0x91, + 0x99, 0x70, 0xCA, 0xF6, 0x33, 0x97, 0x98, 0x20, + 0xD9, 0xEC, 0x79, 0xCC, 0x05, 0xD2, 0x35, 0xF7, + 0x71, 0xDC, 0x14, 0x10, 0xDD, 0x21, 0x86, 0x46, + 0x34, 0x41, 0x6C, 0x4D, 0x8D, 0x81, 0x93, 0xB9 + }, + { + 0x44, 0xE3, 0x25, 0xFB, 0x97, 0xD8, 0xBA, 0xB7, + 0xB2, 0xD1, 0x9D, 0xE4, 0x9C, 0x19, 0x23, 0x19, + 0xBF, 0xFC, 0xBF, 0xDE, 0xCF, 0xFA, 0x04, 0xE4, + 0xDE, 0xDC, 0xC9, 0xF4, 0x3D, 0x07, 0xE3, 0x73, + 0xC6, 0x99, 0x51, 0xBC, 0x6F, 0x68, 0xC4, 0xEB, + 0x99, 0xE5, 0xCD, 0x52, 0x36, 0x4C, 0x53, 0x25, + 0xDC, 0xD6, 0x15, 0xDE, 0x5F, 0x7E, 0x6E, 0x2C, + 0xC0, 0x68, 0xB2, 0x72, 0x7F, 0xF4, 0x10, 0x8C + }, + { + 0xBF, 0xA4, 0xBD, 0x36, 0x8E, 0x5A, 0xF0, 0xB0, + 0x48, 0x6C, 0x92, 0x25, 0xEE, 0x38, 0xDC, 0x42, + 0x6D, 0xDA, 0x66, 0x97, 0x53, 0x6E, 0x90, 0x06, + 0x5C, 0xBA, 0xEB, 0xB7, 0x94, 0xDC, 0xBB, 0x36, + 0x2D, 0x37, 0x65, 0xF8, 0xD0, 0x70, 0xDC, 0xDF, + 0xEF, 0xB7, 0xF2, 0x35, 0x39, 0x46, 0xCB, 0x4A, + 0xAC, 0x35, 0xE2, 0x87, 0x2E, 0xBF, 0xC2, 0x0D, + 0x9B, 0x02, 0x74, 0xA7, 0x45, 0x42, 0x2A, 0xB5 + }, + { + 0x02, 0xB8, 0x8B, 0x1F, 0x9E, 0xE4, 0x6B, 0xBB, + 0x36, 0x1D, 0x34, 0x1C, 0x95, 0xA9, 0x49, 0x2F, + 0x38, 0xD7, 0x2D, 0x86, 0xB7, 0x8F, 0x65, 0xC8, + 0x15, 0x87, 0x94, 0x4E, 0xCD, 0x21, 0x9D, 0x3C, + 0x2F, 0xC3, 0xAB, 0x93, 0x3A, 0x52, 0xF5, 0x2C, + 0x9E, 0xE2, 0xF4, 0xA2, 0x51, 0xDC, 0x3F, 0x66, + 0xE5, 0xCE, 0xA0, 0x77, 0xEA, 0x9B, 0xBC, 0x7B, + 0x45, 0x5B, 0x48, 0x5C, 0x67, 0x7C, 0xB3, 0xCC + }, + { + 0xE7, 0x89, 0xE6, 0x24, 0x71, 0xA1, 0xFC, 0xDC, + 0x60, 0xE2, 0x49, 0x27, 0xF3, 0x16, 0x36, 0xF9, + 0x57, 0x17, 0xAC, 0xFF, 0xD3, 0xD1, 0x23, 0x58, + 0xE1, 0xF2, 0xB3, 0xBA, 0xA5, 0x7D, 0x3F, 0x5E, + 0xA9, 0x22, 0x2D, 0x22, 0x08, 0xD3, 0x0C, 0xD8, + 0x09, 0xEF, 0x74, 0x16, 0x09, 0x5F, 0x8C, 0x92, + 0x62, 0xB9, 0xC3, 0x15, 0xBE, 0x58, 0xE6, 0x99, + 0xF1, 0x87, 0x08, 0xA6, 0x90, 0x40, 0x92, 0xD6 + }, + { + 0x70, 0x0A, 0x6A, 0x25, 0xF2, 0x44, 0xDA, 0xA2, + 0xD2, 0x96, 0xE8, 0x1C, 0x94, 0xEE, 0x65, 0x4F, + 0x87, 0x33, 0x78, 0x14, 0x11, 0xD5, 0x54, 0x5B, + 0x37, 0x4D, 0xEE, 0xC8, 0x7E, 0xA4, 0x66, 0xB4, + 0xD3, 0x19, 0x8F, 0x26, 0x01, 0xD7, 0xD5, 0x7F, + 0x4A, 0xCC, 0x30, 0xC4, 0x38, 0xCE, 0x45, 0x85, + 0x7D, 0xBE, 0x1F, 0x8D, 0xD6, 0x0F, 0x4B, 0xF0, + 0x9C, 0xAA, 0x8F, 0x65, 0x76, 0xCB, 0xE2, 0x5F + }, + { + 0x0F, 0x3D, 0x45, 0xFB, 0xEF, 0x20, 0x09, 0xED, + 0xF5, 0x7D, 0x57, 0x9E, 0x5C, 0xA9, 0xDD, 0x26, + 0x71, 0x55, 0x96, 0xBC, 0x58, 0xA2, 0xC0, 0xE6, + 0x5A, 0xB3, 0x70, 0xCD, 0xC2, 0x6D, 0x77, 0xA5, + 0xCF, 0x88, 0xB2, 0x63, 0xCD, 0xCE, 0xA8, 0xE7, + 0x8A, 0x0B, 0x0D, 0xCC, 0xC6, 0xC3, 0xFD, 0xD8, + 0xFC, 0x33, 0x2B, 0x77, 0x42, 0x3D, 0x20, 0xC5, + 0xD1, 0x36, 0x07, 0x2E, 0x5D, 0x3D, 0x8A, 0xD4 + }, + { + 0x82, 0x7E, 0xB3, 0xF1, 0xDA, 0x5F, 0x6C, 0x2D, + 0xDA, 0xA8, 0x74, 0x1D, 0x84, 0x91, 0x1A, 0x59, + 0xF5, 0x6D, 0x5C, 0x10, 0x45, 0x0A, 0x92, 0x60, + 0x76, 0x2A, 0x3E, 0x6F, 0x56, 0xF7, 0x75, 0x05, + 0x76, 0x2F, 0x21, 0xDB, 0xB7, 0x23, 0xB9, 0xD5, + 0x50, 0x85, 0x78, 0xB6, 0xC9, 0xE7, 0xD3, 0x57, + 0xCE, 0xDD, 0x22, 0x83, 0xE2, 0x8F, 0xCD, 0x30, + 0x48, 0xC1, 0x0B, 0x1E, 0x84, 0x26, 0x68, 0xA4 + }, + { + 0xC9, 0xF3, 0x10, 0x82, 0xC2, 0x30, 0x75, 0x8A, + 0x4F, 0xAD, 0x8D, 0xA0, 0x28, 0x7F, 0x74, 0x6F, + 0xDF, 0x1F, 0x69, 0x37, 0x78, 0x8B, 0xE4, 0x79, + 0x3C, 0x9E, 0xC4, 0x8C, 0xC1, 0x2E, 0x81, 0x69, + 0xA1, 0xE8, 0xB5, 0x9D, 0x81, 0xF9, 0x70, 0x6C, + 0xB2, 0xB1, 0x80, 0x98, 0x28, 0x7D, 0xD2, 0xB6, + 0xF5, 0xC7, 0x1C, 0x72, 0xEE, 0x1A, 0xBC, 0x89, + 0xD6, 0x6C, 0xFC, 0x15, 0xAD, 0xEE, 0x36, 0xB2 + }, + { + 0x50, 0x8C, 0x9A, 0x49, 0x2B, 0xEC, 0x39, 0x41, + 0xCB, 0x4E, 0xF9, 0x66, 0xD3, 0x8B, 0x8F, 0x10, + 0x68, 0x57, 0xD9, 0xAF, 0xAF, 0xE9, 0xC5, 0xFD, + 0x09, 0x6D, 0x09, 0x0F, 0x02, 0x6E, 0xD2, 0xA6, + 0xA4, 0x6A, 0xAA, 0x20, 0xDF, 0x4B, 0x93, 0xF8, + 0xB1, 0x21, 0x99, 0xD6, 0xF1, 0x36, 0x48, 0x4B, + 0x27, 0x00, 0xCA, 0xCD, 0xA6, 0x88, 0xA8, 0x0D, + 0x08, 0x51, 0xDC, 0xCA, 0xE8, 0xFE, 0x26, 0x44 + }, + { + 0x55, 0x64, 0x16, 0xE7, 0x93, 0x15, 0x4C, 0xB4, + 0xE0, 0x79, 0x8E, 0x30, 0xF1, 0x05, 0x9D, 0x0D, + 0x72, 0x83, 0x5F, 0x7B, 0x41, 0x59, 0xF4, 0x7C, + 0xF3, 0xE8, 0x8A, 0x1A, 0x9A, 0x58, 0x4B, 0xBE, + 0xB1, 0xC0, 0xD9, 0x59, 0xB9, 0x2A, 0x2A, 0x47, + 0xA0, 0x9B, 0xE2, 0x0B, 0xCC, 0x38, 0xA7, 0x6C, + 0x49, 0xC4, 0xED, 0xC8, 0xAB, 0xD3, 0xB2, 0x62, + 0xDB, 0x1C, 0x7B, 0xF4, 0x21, 0xB0, 0x1E, 0x4F + }, + { + 0x8F, 0x1D, 0x26, 0x01, 0x0E, 0xA1, 0x35, 0xFA, + 0x26, 0x25, 0x4D, 0x5C, 0xA7, 0x47, 0x70, 0x05, + 0x03, 0xD6, 0xF5, 0x0E, 0xD1, 0x94, 0x9F, 0xAC, + 0x8A, 0x81, 0x61, 0x30, 0x44, 0x76, 0xFB, 0x0C, + 0x2F, 0x81, 0xBF, 0xA2, 0xA3, 0x9A, 0x9B, 0x60, + 0x4A, 0xA0, 0x93, 0xD8, 0xAE, 0x90, 0x10, 0x41, + 0xC9, 0x34, 0x11, 0xA1, 0xFF, 0xA3, 0x26, 0xF3, + 0x69, 0xB9, 0xFF, 0xA6, 0x1F, 0xE1, 0xC0, 0xBE + }, + { + 0x04, 0x3F, 0xE6, 0x7B, 0xE7, 0x23, 0xCC, 0x93, + 0xFA, 0x48, 0x94, 0xCC, 0xF8, 0x88, 0x8C, 0x08, + 0x03, 0x6E, 0xBA, 0x38, 0x7F, 0xBB, 0x9E, 0x9C, + 0xC5, 0x07, 0xFE, 0xD6, 0xC5, 0xAD, 0x87, 0xF0, + 0xF9, 0xFF, 0x23, 0xD1, 0x16, 0x20, 0x86, 0x22, + 0x28, 0x2A, 0xAD, 0x93, 0x01, 0x6C, 0x04, 0x07, + 0x1F, 0x9B, 0xB0, 0xEB, 0x4F, 0x5A, 0x97, 0xE5, + 0x8B, 0x1C, 0x9C, 0xBD, 0x0B, 0x6C, 0xF5, 0x05 + }, + { + 0xCE, 0x0D, 0xC8, 0xDD, 0x8F, 0xA5, 0x61, 0xD9, + 0x96, 0x8A, 0xCB, 0x3E, 0xDA, 0xC8, 0x53, 0x45, + 0x57, 0xF8, 0xC8, 0xE6, 0x7B, 0xBF, 0x27, 0x4F, + 0xE8, 0xC0, 0x18, 0xF1, 0x96, 0x90, 0xBC, 0x3F, + 0x05, 0x28, 0x66, 0x24, 0xDB, 0x0D, 0x2C, 0xF7, + 0xFA, 0xEC, 0xC4, 0x25, 0xFD, 0xD2, 0xDA, 0x88, + 0x7D, 0xE6, 0x8A, 0xA1, 0x3B, 0x0A, 0x6E, 0x43, + 0x74, 0x90, 0x2E, 0x9F, 0x13, 0xB0, 0x1F, 0xCD + }, + { + 0x01, 0x5D, 0x30, 0x16, 0x6E, 0x3F, 0xF0, 0xC1, + 0xF6, 0xC8, 0xCA, 0xC5, 0xF4, 0x9A, 0x35, 0xCD, + 0xFD, 0x4C, 0x58, 0x2A, 0x63, 0x37, 0xBC, 0xB2, + 0x1F, 0x08, 0x31, 0x59, 0x91, 0x85, 0xAD, 0x90, + 0xA9, 0x6A, 0x53, 0xCA, 0x91, 0xB1, 0x3B, 0xD2, + 0xDB, 0xBA, 0x0A, 0xD6, 0x74, 0x12, 0xB4, 0xEB, + 0x8C, 0xA5, 0x7D, 0xDB, 0xE0, 0x00, 0x43, 0x91, + 0xFF, 0x3D, 0xDE, 0x4A, 0xE9, 0x39, 0xA8, 0x73 + }, + { + 0x78, 0x3D, 0x38, 0x80, 0x8E, 0xC7, 0x0E, 0x9C, + 0xE1, 0x7C, 0xBF, 0xAE, 0xA1, 0x59, 0x79, 0x1D, + 0xB3, 0x12, 0xEA, 0x27, 0xD3, 0xB4, 0x20, 0x6F, + 0x4D, 0xB5, 0x02, 0x79, 0x22, 0x90, 0x98, 0x77, + 0x03, 0x44, 0x6C, 0xFC, 0x0D, 0xC8, 0x8D, 0xC6, + 0xE9, 0x93, 0xB6, 0x23, 0xB8, 0x38, 0xB7, 0xBC, + 0x8C, 0x96, 0x35, 0x94, 0x79, 0x4B, 0x8F, 0xFC, + 0x08, 0xC0, 0xEC, 0x5A, 0xEC, 0x11, 0xB4, 0x8B + }, + { + 0xED, 0xEA, 0x13, 0x40, 0x04, 0xB3, 0xA2, 0xDB, + 0x5B, 0x47, 0xB6, 0xE1, 0x73, 0xEA, 0xF1, 0x64, + 0x2D, 0x48, 0xF0, 0x02, 0x3A, 0xDD, 0xEE, 0x4A, + 0x59, 0x09, 0x3B, 0xC2, 0x0A, 0xE3, 0x19, 0x1C, + 0x28, 0x74, 0xE5, 0x02, 0x5C, 0x64, 0x28, 0xE8, + 0xA9, 0x15, 0xF2, 0x7F, 0xA3, 0x71, 0x6A, 0xDA, + 0xDA, 0xC4, 0x70, 0x51, 0xC3, 0x18, 0xC4, 0x24, + 0x19, 0xE9, 0xDC, 0xDA, 0x64, 0x9E, 0xE3, 0xFD + }, + { + 0x8D, 0xEE, 0x1A, 0xE2, 0x88, 0xB5, 0xDF, 0xFA, + 0x0B, 0xCC, 0xD0, 0xB2, 0x8F, 0x6E, 0x41, 0xAE, + 0x7B, 0x71, 0xBA, 0xB9, 0x37, 0xD4, 0x2C, 0x92, + 0xAD, 0x6F, 0x06, 0x6B, 0xA9, 0xBD, 0x2E, 0x6F, + 0xD3, 0xD6, 0xBD, 0xD8, 0x0C, 0x66, 0x91, 0x4D, + 0xC5, 0x7C, 0x03, 0xA5, 0x42, 0x42, 0x98, 0xF3, + 0xB3, 0x8C, 0x64, 0x59, 0x2C, 0x40, 0xE7, 0x04, + 0xE7, 0xDD, 0xB9, 0x20, 0x43, 0x8D, 0xF9, 0xFA + }, + { + 0x94, 0x65, 0x7B, 0x89, 0x07, 0x06, 0xB0, 0xDC, + 0x0F, 0x6A, 0xCC, 0x7A, 0x9E, 0x4E, 0xC1, 0xA7, + 0xA9, 0x67, 0x2B, 0xD4, 0x57, 0x27, 0xAF, 0x8C, + 0xD9, 0xFC, 0xEE, 0xDC, 0xF2, 0x2A, 0x4A, 0xF8, + 0xE6, 0xCD, 0x01, 0x83, 0xDE, 0x88, 0x8B, 0x92, + 0xD5, 0xCB, 0xD4, 0xB8, 0xEB, 0x3C, 0x79, 0x56, + 0x2C, 0x79, 0x51, 0x86, 0x65, 0x21, 0x84, 0x1F, + 0xA0, 0x1C, 0x56, 0x59, 0x3C, 0x74, 0xDA, 0xC1 + }, + { + 0x9E, 0x0E, 0x7A, 0x5B, 0x00, 0xEA, 0xD3, 0x29, + 0xEB, 0x19, 0x6B, 0xEB, 0x17, 0xB1, 0x95, 0x55, + 0x4B, 0xBB, 0x19, 0xF3, 0x6F, 0xEA, 0xEB, 0x93, + 0x55, 0x83, 0x00, 0xAA, 0xB2, 0xC9, 0x9C, 0x2D, + 0xE5, 0xD0, 0x22, 0xE4, 0xB6, 0x3A, 0x8E, 0xFF, + 0xDE, 0x21, 0xCF, 0xF7, 0xB2, 0x8F, 0xA9, 0x75, + 0x19, 0x98, 0x09, 0xE5, 0x78, 0x31, 0x2E, 0x9B, + 0x40, 0x31, 0x21, 0xAE, 0x27, 0xE7, 0xF4, 0x48 + }, + { + 0xEC, 0x0D, 0x00, 0x7B, 0x32, 0x64, 0x20, 0xB3, + 0xCE, 0x3D, 0xC4, 0xCE, 0xEB, 0xF0, 0x9F, 0xBD, + 0x4D, 0x8E, 0x49, 0xAB, 0xFD, 0x72, 0xB4, 0x59, + 0x21, 0x96, 0x2E, 0x93, 0xDE, 0x59, 0xF3, 0x87, + 0x2D, 0xAB, 0x38, 0x3B, 0x32, 0x35, 0x75, 0x25, + 0x59, 0x8B, 0xA0, 0x78, 0xBB, 0x82, 0x4D, 0x6B, + 0x69, 0xB8, 0x2A, 0xBD, 0xCA, 0x12, 0x38, 0x1E, + 0xEE, 0xAD, 0x5F, 0x58, 0xE0, 0xEF, 0xA1, 0x58 + }, + { + 0xB2, 0xE0, 0x9C, 0x75, 0xFE, 0x5B, 0x83, 0xE5, + 0xCA, 0xC2, 0x7F, 0x1F, 0x19, 0xBF, 0xCE, 0x7C, + 0x31, 0x04, 0x1C, 0xAE, 0x8B, 0xC0, 0xC5, 0x33, + 0xB7, 0x0C, 0x9C, 0x2E, 0x57, 0x48, 0x9A, 0xA0, + 0xC8, 0x98, 0xB9, 0x13, 0xF5, 0x08, 0x10, 0xFB, + 0xE2, 0xEA, 0x14, 0x48, 0x93, 0xF6, 0x6C, 0x4A, + 0x55, 0x85, 0x94, 0x1E, 0xF8, 0xCB, 0x7D, 0xE5, + 0x2C, 0xC1, 0xFD, 0x2F, 0x7E, 0x13, 0x16, 0x96 + }, + { + 0x4E, 0xA4, 0xD0, 0x88, 0x75, 0x04, 0xC9, 0xDE, + 0x6A, 0xB6, 0xF0, 0x6E, 0x81, 0x40, 0x13, 0xEC, + 0x77, 0x30, 0x43, 0x1E, 0x6E, 0xC5, 0x83, 0x5D, + 0x00, 0x50, 0x0C, 0xF0, 0x08, 0x0C, 0xF7, 0x7B, + 0x6B, 0x69, 0x84, 0x7B, 0xA6, 0xCC, 0x48, 0x25, + 0xC5, 0xA3, 0xBA, 0x58, 0x45, 0xE7, 0xD6, 0xC7, + 0x8A, 0x45, 0x81, 0x56, 0xE3, 0x8A, 0x6B, 0x0F, + 0xEA, 0xD7, 0xFB, 0xFF, 0xC1, 0x6E, 0x20, 0x90 + }, + { + 0x22, 0x6B, 0xDC, 0x63, 0xD2, 0x4A, 0x49, 0xD4, + 0x97, 0xB9, 0x60, 0x2C, 0x63, 0xBA, 0x49, 0xD9, + 0x59, 0xE7, 0x55, 0x65, 0xA8, 0xB5, 0xEA, 0xC5, + 0xC2, 0xBE, 0xD5, 0x9A, 0x87, 0x14, 0xCC, 0x0A, + 0x7D, 0xA0, 0x49, 0xF3, 0x0B, 0x96, 0x92, 0x96, + 0x0D, 0x84, 0x20, 0x78, 0x36, 0x86, 0x62, 0x11, + 0x2A, 0x96, 0x5B, 0xE3, 0x84, 0xCD, 0xF4, 0xF1, + 0x42, 0xD9, 0x00, 0x5E, 0x1D, 0x31, 0x7C, 0xA8 + }, + { + 0xDE, 0x1F, 0xCD, 0xAA, 0x59, 0xAA, 0xD2, 0x3A, + 0x0F, 0x3C, 0x4C, 0x22, 0x18, 0x3C, 0x27, 0x16, + 0x63, 0xD3, 0x58, 0x73, 0xF8, 0x57, 0x1F, 0x02, + 0x49, 0x56, 0xA7, 0xAD, 0x55, 0x9E, 0x43, 0x4C, + 0x4E, 0x5D, 0x26, 0xFA, 0xB2, 0xA9, 0x30, 0x10, + 0x67, 0x36, 0xC0, 0x5B, 0x3C, 0xD1, 0x70, 0x9B, + 0x47, 0xF2, 0x8B, 0xD5, 0xF6, 0x44, 0x5A, 0x23, + 0x52, 0xBC, 0x91, 0x55, 0x9D, 0xEC, 0x4D, 0xFA + }, + { + 0x26, 0xEA, 0x80, 0x0C, 0x49, 0xD4, 0x17, 0xDA, + 0x96, 0x69, 0x3E, 0x25, 0x3F, 0xDC, 0x89, 0x8B, + 0x65, 0xA4, 0xDD, 0xD2, 0x16, 0x04, 0x76, 0x9B, + 0x88, 0xDF, 0x20, 0xB3, 0x4A, 0xD6, 0x8C, 0x5A, + 0xCE, 0xA8, 0x5F, 0x7A, 0x6B, 0x73, 0x31, 0xF6, + 0x7F, 0xDF, 0x56, 0x28, 0x5E, 0xC8, 0xDF, 0xA0, + 0xCF, 0xDD, 0xE1, 0x38, 0xA7, 0xDB, 0x1D, 0x01, + 0xF3, 0x82, 0x56, 0xC4, 0x60, 0x26, 0x3A, 0xFB + }, + { + 0xF3, 0x53, 0xE2, 0xC8, 0xB1, 0xE9, 0x58, 0x05, + 0x8E, 0xA4, 0xFD, 0x90, 0x55, 0xF9, 0x5D, 0x1D, + 0xEA, 0xB8, 0x21, 0x38, 0xF4, 0x47, 0xB0, 0x95, + 0x94, 0xE1, 0x9F, 0xED, 0x11, 0x27, 0x24, 0xCE, + 0xAD, 0x30, 0x1D, 0x95, 0x2B, 0x2D, 0x99, 0xA8, + 0x70, 0x2D, 0x15, 0xCA, 0xB4, 0xDA, 0xCF, 0xA0, + 0x4C, 0x00, 0x1D, 0x27, 0x4D, 0xFB, 0x1B, 0xDB, + 0xEA, 0xB0, 0x83, 0x9E, 0xA8, 0xAF, 0x01, 0xE2 + }, + { + 0xAB, 0xA6, 0x68, 0x9B, 0x38, 0x52, 0x51, 0x8B, + 0x4E, 0x84, 0xDD, 0xDF, 0xA3, 0xE1, 0x51, 0x2D, + 0x54, 0x8E, 0x52, 0xD7, 0xB3, 0x8F, 0x8D, 0x42, + 0xA2, 0xF4, 0x77, 0xB0, 0x5A, 0x47, 0xD8, 0x28, + 0xB9, 0x6C, 0xB7, 0x7D, 0x07, 0x96, 0x29, 0x95, + 0x01, 0x06, 0x06, 0x2F, 0x25, 0x84, 0x81, 0xBE, + 0xFB, 0x36, 0x14, 0xC3, 0x4E, 0x4F, 0x48, 0xCB, + 0x91, 0x13, 0x23, 0xCA, 0x41, 0xDE, 0x7C, 0xA0 + }, + { + 0x65, 0x06, 0x3C, 0xC6, 0xAD, 0xDC, 0x6A, 0x2F, + 0x91, 0x75, 0x95, 0xA8, 0xCD, 0x31, 0xB6, 0x51, + 0x15, 0x65, 0x99, 0x92, 0xE7, 0xB4, 0xB8, 0xD3, + 0x59, 0x71, 0x16, 0xF2, 0x37, 0xF0, 0xE7, 0xDB, + 0xC3, 0xD3, 0x0B, 0x70, 0x54, 0xA8, 0x9F, 0x08, + 0x1E, 0xC3, 0x89, 0x3E, 0xD0, 0x38, 0x65, 0x61, + 0x38, 0xD3, 0x6F, 0xAD, 0x8E, 0xED, 0xCD, 0x5E, + 0x12, 0xC2, 0x01, 0x3C, 0x01, 0xF2, 0x15, 0x48 + }, + { + 0x40, 0xFF, 0xE2, 0x0E, 0x33, 0xD4, 0x50, 0x0A, + 0xD9, 0x22, 0xC2, 0x79, 0x89, 0x89, 0x92, 0x2D, + 0x83, 0xEB, 0xBE, 0xD8, 0xDE, 0x60, 0xC9, 0xD8, + 0x2E, 0xF0, 0xB3, 0x9B, 0xD7, 0xAB, 0xF2, 0x3F, + 0xDF, 0x83, 0xB2, 0x9F, 0x2E, 0x55, 0xB7, 0xF9, + 0x20, 0x84, 0xC5, 0xE6, 0xAC, 0x23, 0x1F, 0x72, + 0xC5, 0xB1, 0x43, 0xA4, 0xD8, 0x24, 0xCC, 0x12, + 0x4D, 0xC4, 0xC5, 0xDE, 0x45, 0x4A, 0x63, 0xB5 + }, + { + 0x49, 0xC6, 0x47, 0x9A, 0xB8, 0xD2, 0x2F, 0x1E, + 0x22, 0x87, 0xF0, 0xEB, 0x55, 0x67, 0x40, 0xFC, + 0xEE, 0x58, 0x27, 0xEF, 0x68, 0xB1, 0x37, 0x26, + 0x02, 0x2C, 0x58, 0xE4, 0xD8, 0x08, 0x8E, 0xA6, + 0x6A, 0x9E, 0x79, 0x55, 0x91, 0xC2, 0x2F, 0x43, + 0x8B, 0xBC, 0x25, 0x11, 0x8A, 0xE3, 0xBC, 0xC3, + 0xF6, 0xF3, 0xDC, 0x59, 0xE7, 0x66, 0x66, 0xB3, + 0x8E, 0x65, 0x9E, 0x55, 0xEC, 0x7A, 0x63, 0x97 + }, + { + 0xD1, 0xB0, 0xEC, 0xB0, 0x69, 0x52, 0x04, 0xF9, + 0xC2, 0x01, 0x5D, 0xF6, 0xAD, 0x08, 0xE3, 0xB5, + 0x39, 0x7F, 0xB3, 0x84, 0xE8, 0x12, 0xB7, 0x4C, + 0xA1, 0xBA, 0xB5, 0xD6, 0x02, 0x76, 0x4D, 0xA9, + 0x37, 0xF1, 0x65, 0xCB, 0xFB, 0x16, 0xEA, 0xBD, + 0x1C, 0x24, 0x8D, 0x3D, 0x4F, 0xC5, 0x09, 0x1E, + 0x3F, 0xED, 0x61, 0x55, 0x40, 0x63, 0xD5, 0x3F, + 0x14, 0x03, 0x70, 0x27, 0xDC, 0x28, 0x93, 0x66 + }, + { + 0x1C, 0x47, 0x58, 0xD9, 0x80, 0x60, 0x52, 0x5F, + 0x72, 0x9C, 0x2C, 0x9B, 0xFE, 0x54, 0xF0, 0x20, + 0xF8, 0x2A, 0xA2, 0x5E, 0xFB, 0xC4, 0x97, 0x4D, + 0x10, 0xCD, 0xBC, 0x21, 0x34, 0xC6, 0xE7, 0x4A, + 0xD0, 0xEC, 0x29, 0xE0, 0x5A, 0x23, 0x6A, 0x15, + 0x14, 0x48, 0x5C, 0x48, 0x8B, 0x6D, 0x8F, 0x3C, + 0xCF, 0xA8, 0x68, 0x6B, 0x0C, 0x65, 0x03, 0x66, + 0x4A, 0x25, 0x21, 0x03, 0x5F, 0x0F, 0x45, 0x54 + }, + { + 0x33, 0xB4, 0x64, 0x53, 0x46, 0xF0, 0x1E, 0x85, + 0xD1, 0xA5, 0x22, 0x98, 0xA3, 0x69, 0xC7, 0xC1, + 0xEB, 0xAB, 0xF2, 0x5F, 0xE9, 0x4A, 0xD7, 0x94, + 0x05, 0xD3, 0x9B, 0x7F, 0x84, 0x3B, 0xD1, 0xE7, + 0x34, 0x43, 0x9E, 0x36, 0xDF, 0xB4, 0x20, 0x85, + 0xAE, 0x0B, 0xE9, 0x3F, 0x93, 0x74, 0x98, 0xCF, + 0x00, 0xE3, 0x46, 0x4D, 0xAD, 0xEE, 0x1F, 0x73, + 0x9A, 0xF5, 0xC6, 0x46, 0x60, 0xA4, 0xB7, 0xF3 + }, + { + 0x9B, 0x04, 0x2E, 0xA2, 0xEF, 0x2A, 0x97, 0x9C, + 0x36, 0xE9, 0x24, 0x82, 0xE9, 0x18, 0xFA, 0x25, + 0xC8, 0x82, 0x93, 0x40, 0x6C, 0x61, 0xE0, 0x99, + 0x53, 0x07, 0xD3, 0xD6, 0xF5, 0x0B, 0x8F, 0x66, + 0x42, 0xA0, 0xAF, 0xC0, 0x67, 0x30, 0xD6, 0x8E, + 0x7D, 0x94, 0xF3, 0x39, 0xE4, 0xD6, 0xF9, 0x36, + 0xC5, 0x9F, 0x04, 0x2D, 0xCE, 0x1E, 0x50, 0x8E, + 0xA5, 0x9C, 0xA9, 0x77, 0x52, 0xC1, 0x6C, 0x8B + }, + { + 0xC3, 0x8D, 0x15, 0x00, 0xDC, 0x91, 0xBD, 0xF4, + 0x31, 0xC0, 0xBF, 0xF1, 0x65, 0x0A, 0xA0, 0xA1, + 0x46, 0x57, 0xB9, 0x86, 0x12, 0x61, 0x22, 0x54, + 0x5B, 0x8F, 0x29, 0x94, 0x80, 0x3B, 0x23, 0xA9, + 0x44, 0x1E, 0x02, 0x39, 0xF2, 0x83, 0xDC, 0xC2, + 0xA9, 0x10, 0x2F, 0x1C, 0x0A, 0x6A, 0x28, 0x87, + 0xCB, 0xD0, 0x9B, 0x59, 0xAC, 0x6B, 0x58, 0xF8, + 0x19, 0x33, 0x97, 0x0A, 0x78, 0xB8, 0xC9, 0xF6 + }, + { + 0x70, 0x41, 0x31, 0xD7, 0x37, 0x16, 0x23, 0x40, + 0x28, 0xBD, 0x9B, 0x1D, 0x08, 0x83, 0x3F, 0x56, + 0xCD, 0x60, 0x1A, 0x2C, 0xF2, 0x47, 0x45, 0xDF, + 0x48, 0x2C, 0xE3, 0x9F, 0x44, 0x1B, 0x76, 0x56, + 0x9E, 0xE6, 0x5A, 0xF1, 0x54, 0x78, 0xAF, 0x55, + 0x69, 0x40, 0x40, 0xE7, 0x44, 0x8F, 0xDA, 0x65, + 0x6F, 0x31, 0x4B, 0x9A, 0x0C, 0xC1, 0x12, 0xBF, + 0x48, 0xC4, 0x8F, 0x39, 0x7D, 0x82, 0x91, 0x41 + }, + { + 0x93, 0x32, 0xAD, 0x61, 0x71, 0x70, 0x30, 0x46, + 0x25, 0x64, 0x2D, 0xD7, 0x7C, 0x07, 0x52, 0x43, + 0xF8, 0xC7, 0x5D, 0xAE, 0x72, 0x2E, 0xC1, 0xB2, + 0x7C, 0xFC, 0x08, 0x8A, 0xDC, 0xD4, 0xCF, 0x3E, + 0xA1, 0x2B, 0x3A, 0x23, 0x35, 0xAA, 0x3B, 0xBC, + 0xB3, 0x64, 0xCB, 0xF4, 0x1B, 0x8D, 0x46, 0xD1, + 0x32, 0x17, 0x4E, 0x6F, 0x9E, 0x41, 0x57, 0x8B, + 0x7B, 0x7E, 0x49, 0x56, 0x1A, 0x2E, 0xFD, 0xBB + }, + { + 0x86, 0x36, 0xAA, 0x7C, 0x89, 0xAC, 0x4D, 0x04, + 0x40, 0xE5, 0x69, 0xAE, 0x2E, 0x60, 0x29, 0xB5, + 0xD2, 0x5F, 0xEB, 0x32, 0xE4, 0xA4, 0xA0, 0xBB, + 0xDB, 0xA1, 0x16, 0x64, 0xE3, 0x78, 0x3B, 0x40, + 0x90, 0x77, 0x6E, 0x6C, 0x51, 0x33, 0xB1, 0xD9, + 0x84, 0x3C, 0xCC, 0x82, 0xF4, 0xC0, 0xE9, 0xA0, + 0x5C, 0xB1, 0xC3, 0x0F, 0xA5, 0x90, 0x76, 0x99, + 0xA9, 0x9E, 0xCD, 0xDD, 0xEE, 0x7C, 0xF8, 0xB9 + }, + { + 0xEE, 0xE1, 0xDC, 0xE5, 0xA4, 0x2F, 0x9A, 0x1C, + 0x5A, 0xA2, 0x46, 0x40, 0x02, 0x0A, 0x22, 0xFA, + 0xAB, 0xA8, 0xAA, 0x5E, 0x68, 0xBB, 0x73, 0x00, + 0x6B, 0x3F, 0x54, 0x45, 0xE1, 0xB6, 0x4D, 0xF2, + 0x8A, 0x3C, 0x2D, 0xC4, 0xF1, 0x24, 0x00, 0x98, + 0x4F, 0x66, 0x46, 0x2A, 0x1F, 0xCC, 0x44, 0x28, + 0x1C, 0x28, 0xE7, 0x0F, 0x58, 0xDA, 0x7C, 0xC1, + 0xF2, 0x8B, 0x16, 0x02, 0x3A, 0x52, 0xAC, 0xA7 + }, + { + 0xE3, 0x2D, 0x05, 0x00, 0xE8, 0xDC, 0x44, 0xB3, + 0xBC, 0x4B, 0x40, 0x6A, 0x98, 0x6C, 0xA4, 0xA8, + 0xFF, 0x07, 0x4C, 0x69, 0x6C, 0x2B, 0x1B, 0x19, + 0xB7, 0x37, 0xA5, 0xD2, 0xC1, 0xB5, 0x6A, 0xB2, + 0xEA, 0x70, 0x13, 0x76, 0xDC, 0x61, 0x83, 0x7F, + 0x3A, 0x49, 0x09, 0x8C, 0x62, 0xE5, 0x91, 0x7E, + 0xC3, 0x6C, 0xC3, 0x24, 0x31, 0x30, 0x61, 0x29, + 0x47, 0xDF, 0x54, 0xDB, 0x21, 0x1B, 0x9C, 0x10 + }, + { + 0xE5, 0xDB, 0xE8, 0xF9, 0x83, 0x41, 0xDF, 0x14, + 0x36, 0xF6, 0x05, 0xAB, 0x0A, 0x94, 0x90, 0xA7, + 0x0E, 0x49, 0xD9, 0x32, 0xD7, 0x50, 0x53, 0x7E, + 0xC3, 0xDE, 0x14, 0x04, 0x16, 0x4C, 0xD1, 0x4D, + 0xF9, 0x88, 0xA5, 0xF3, 0x4B, 0x92, 0x11, 0xD1, + 0x8D, 0xF1, 0x02, 0x18, 0x1E, 0x9D, 0x32, 0x7C, + 0xC4, 0xA4, 0x92, 0xC9, 0x6F, 0xB6, 0x99, 0x2E, + 0xAC, 0x4B, 0x89, 0x9F, 0xCD, 0x3A, 0x22, 0x5C + }, + { + 0x41, 0xD8, 0xB3, 0x03, 0x94, 0x09, 0x64, 0xA4, + 0x5A, 0x4F, 0x7F, 0x46, 0xE1, 0x0D, 0xB3, 0xDE, + 0xDA, 0x02, 0x9A, 0x52, 0x2E, 0xD9, 0x3E, 0x56, + 0x2E, 0xBC, 0x05, 0x02, 0xD1, 0x13, 0xC3, 0x83, + 0xDD, 0xC2, 0xE8, 0x13, 0xE6, 0xDF, 0xCA, 0x40, + 0xD7, 0x57, 0xBB, 0x4E, 0xF5, 0x6E, 0xF6, 0x7B, + 0x6A, 0x3A, 0xF7, 0x53, 0x83, 0xB3, 0xC7, 0x83, + 0x97, 0x4E, 0xD0, 0x9D, 0x79, 0x6B, 0xF9, 0xE1 + }, + { + 0x5B, 0xAF, 0x34, 0xC8, 0x84, 0x94, 0xF4, 0xE9, + 0x80, 0x0D, 0xF2, 0x7D, 0xA6, 0x99, 0x21, 0x63, + 0xCE, 0x23, 0x26, 0x00, 0x8A, 0x2E, 0xBC, 0xE8, + 0x65, 0xBD, 0x29, 0x17, 0x8A, 0xC9, 0x04, 0x79, + 0x69, 0x1F, 0xAA, 0x6F, 0x1C, 0x6A, 0xB6, 0xA2, + 0xE0, 0x73, 0xAC, 0xFD, 0xEF, 0xF6, 0x03, 0xF5, + 0x06, 0xE5, 0x38, 0x2F, 0xDC, 0x01, 0x6C, 0x4F, + 0xCD, 0x4F, 0x3A, 0xEA, 0xC2, 0xC7, 0x0C, 0x88 + }, + { + 0x76, 0x80, 0xD4, 0xAA, 0xDA, 0xA8, 0xA0, 0xDB, + 0xEA, 0xB7, 0x6A, 0xED, 0x4E, 0x67, 0x75, 0x5D, + 0x79, 0xEC, 0x7E, 0x1A, 0x3E, 0xCD, 0x22, 0x6C, + 0x41, 0x13, 0x0B, 0x0F, 0x85, 0x06, 0x0C, 0xF9, + 0x54, 0x63, 0xB9, 0x5E, 0x16, 0xCE, 0x16, 0xC1, + 0x69, 0x0F, 0x1E, 0x88, 0x73, 0xDA, 0x86, 0x30, + 0x4A, 0x1B, 0x33, 0xF7, 0xFC, 0xE0, 0x37, 0x00, + 0x6D, 0x92, 0x56, 0x3C, 0x65, 0x6E, 0x62, 0xF7 + }, + { + 0x40, 0x07, 0xE3, 0x83, 0x50, 0x1A, 0xEF, 0x1F, + 0x0D, 0x28, 0xD6, 0xAA, 0x87, 0x0C, 0x87, 0xF5, + 0x24, 0xD7, 0x27, 0x3A, 0x91, 0x52, 0x3D, 0x21, + 0x08, 0x50, 0x63, 0x84, 0x6E, 0xAE, 0x54, 0x1A, + 0x29, 0xFC, 0xD9, 0x59, 0xAC, 0x99, 0x2B, 0x62, + 0xA4, 0x76, 0xAB, 0x0E, 0x32, 0x64, 0x2C, 0xB2, + 0x4D, 0x4D, 0xDE, 0x67, 0xD0, 0xCA, 0xD8, 0x65, + 0xD3, 0xF5, 0x37, 0x61, 0xC7, 0xC4, 0xA8, 0x98 + }, + { + 0xD0, 0x75, 0xAF, 0x16, 0xF1, 0x7B, 0x80, 0xEF, + 0x4B, 0x65, 0x1A, 0x5E, 0x00, 0xC0, 0x2E, 0x45, + 0xAD, 0x30, 0xF9, 0x79, 0xAB, 0x91, 0xFE, 0x9D, + 0x08, 0x9A, 0xC4, 0x28, 0x32, 0x56, 0xD1, 0x1C, + 0xB9, 0x39, 0x3D, 0x58, 0x1D, 0x6E, 0x49, 0x45, + 0xC6, 0x33, 0xDB, 0x64, 0x9F, 0x56, 0xB2, 0xB0, + 0x31, 0xDA, 0x33, 0xA0, 0xBC, 0x24, 0x82, 0xC4, + 0x31, 0x2E, 0x80, 0x3F, 0x69, 0x73, 0x3D, 0x16 + }, + { + 0xA5, 0xA4, 0xF2, 0xC8, 0x37, 0x85, 0xF8, 0x33, + 0x95, 0xB6, 0xA9, 0xC3, 0x22, 0x61, 0xBD, 0xBB, + 0xA3, 0x81, 0x2B, 0x4B, 0x61, 0xDA, 0x52, 0xD7, + 0xD4, 0x94, 0x12, 0x5D, 0x17, 0x7D, 0xEB, 0x23, + 0xFC, 0xC9, 0xC8, 0x8E, 0xD5, 0x95, 0x0F, 0xE7, + 0x15, 0x4B, 0xD0, 0x29, 0x43, 0xF0, 0xA3, 0xF3, + 0x43, 0x3D, 0xB2, 0xD7, 0xF9, 0x2C, 0x6C, 0xE7, + 0xA6, 0x43, 0x12, 0xB0, 0xC8, 0x45, 0xF5, 0xCC + }, + { + 0x33, 0x0C, 0xBD, 0xC1, 0x7D, 0xC4, 0xFD, 0xB2, + 0xE4, 0x75, 0x98, 0x0F, 0xEA, 0xB3, 0x90, 0x84, + 0x51, 0xC5, 0x64, 0xC2, 0x00, 0x43, 0xA5, 0x61, + 0x1F, 0x34, 0x0B, 0x68, 0x58, 0xD0, 0x26, 0xF5, + 0x1A, 0xB5, 0x90, 0xB5, 0x3F, 0xA8, 0xA9, 0x8B, + 0x4D, 0xEB, 0x38, 0xA3, 0x98, 0xE4, 0xF6, 0xE5, + 0x87, 0x73, 0x73, 0x75, 0xB5, 0x97, 0xF3, 0x52, + 0xE3, 0x27, 0xC7, 0x7B, 0xCF, 0xCD, 0x9A, 0x6F + }, + { + 0x15, 0xA1, 0x3B, 0xC1, 0xF5, 0x0A, 0xB0, 0x4A, + 0xA0, 0x61, 0x78, 0x98, 0xF2, 0x5C, 0x8E, 0x70, + 0x6B, 0x90, 0x34, 0x12, 0xBE, 0xF0, 0x10, 0x73, + 0x4B, 0xEB, 0x4E, 0x77, 0x6C, 0xA5, 0x10, 0x66, + 0xAF, 0x4C, 0xA2, 0xB7, 0x09, 0xF1, 0x90, 0xAA, + 0x6F, 0xF2, 0x84, 0x1C, 0x18, 0xD7, 0x9C, 0xEA, + 0x80, 0x64, 0x54, 0x18, 0x07, 0x7A, 0x66, 0xE6, + 0x16, 0x29, 0xBD, 0x9D, 0xF2, 0xEF, 0x01, 0xF8 + }, + { + 0x63, 0x1C, 0x85, 0x7E, 0xAC, 0x1B, 0x44, 0x68, + 0xB9, 0x8A, 0x16, 0xFF, 0x97, 0x08, 0x7C, 0x1B, + 0x0B, 0x66, 0x55, 0x60, 0xBC, 0x12, 0xCD, 0xF5, + 0x1A, 0xA0, 0xC4, 0xA0, 0xCA, 0xEF, 0x81, 0xB1, + 0x9D, 0x74, 0x0A, 0xE1, 0x97, 0xA3, 0xA1, 0x9E, + 0xF8, 0xCE, 0x22, 0x57, 0x09, 0x80, 0x99, 0x33, + 0x98, 0xB2, 0xE8, 0xF2, 0x7B, 0xFC, 0x05, 0x99, + 0xA9, 0xAA, 0xCE, 0x08, 0x09, 0x51, 0x4C, 0x21 + }, + { + 0xB2, 0x61, 0x9A, 0xA2, 0xFB, 0xD2, 0x24, 0xE5, + 0x3A, 0xA0, 0x53, 0x00, 0xE8, 0xAF, 0xDC, 0xEB, + 0x3C, 0xBB, 0xD4, 0x7A, 0x62, 0x4F, 0x6D, 0xB2, + 0x2E, 0xD4, 0xEE, 0x0A, 0xB3, 0x7D, 0xA9, 0xA0, + 0x89, 0x70, 0x6A, 0x3A, 0x2A, 0x5A, 0x3B, 0xD0, + 0x3D, 0xC3, 0x18, 0xDD, 0x4D, 0x3D, 0xB1, 0x0E, + 0x23, 0x9F, 0x16, 0xB1, 0xE0, 0xF2, 0x15, 0x0B, + 0xC1, 0xB3, 0xFA, 0x1E, 0x65, 0xAF, 0x65, 0x7D + }, + { + 0x51, 0xFE, 0xED, 0x3B, 0xC4, 0x98, 0x8A, 0xB8, + 0x4B, 0x6E, 0x54, 0x44, 0xDA, 0xF4, 0x96, 0xD5, + 0xC9, 0x70, 0xAA, 0x4E, 0xC0, 0x17, 0x89, 0x1C, + 0xE1, 0xE1, 0xF3, 0x50, 0xAF, 0x02, 0x80, 0x8F, + 0x78, 0x5B, 0x5E, 0x06, 0xEC, 0xAF, 0xFE, 0xC5, + 0xC8, 0xBD, 0xFF, 0x2C, 0x20, 0x32, 0x45, 0x6D, + 0x74, 0x74, 0x53, 0xE0, 0x56, 0xAA, 0x4F, 0x68, + 0xB0, 0x99, 0xB4, 0x64, 0x05, 0xDE, 0x97, 0x02 + }, + { + 0xB4, 0x35, 0x5B, 0x2A, 0x77, 0xC8, 0x18, 0x1C, + 0xDD, 0xDA, 0xD7, 0x44, 0xD2, 0x32, 0x7F, 0xDD, + 0x19, 0x33, 0xDE, 0xFB, 0x02, 0x34, 0x11, 0x90, + 0x3E, 0x52, 0x0B, 0x01, 0xA7, 0x14, 0x8A, 0x42, + 0x8B, 0x7F, 0xB4, 0xFF, 0xF5, 0x6D, 0x52, 0x71, + 0x3E, 0xEB, 0x21, 0x6F, 0xFE, 0x1D, 0xEA, 0x28, + 0x76, 0x8F, 0x9D, 0x3A, 0x77, 0x65, 0xB7, 0x3E, + 0x38, 0x75, 0xD0, 0x53, 0x8C, 0xEF, 0xF0, 0xA1 + }, + { + 0x8E, 0x14, 0x5F, 0x60, 0x65, 0x24, 0x23, 0xE2, + 0x3B, 0xAE, 0x1E, 0xD6, 0xFF, 0xAF, 0xFA, 0x48, + 0x8C, 0x9F, 0x3A, 0xE2, 0x37, 0xE0, 0x9F, 0x9F, + 0xBD, 0xC4, 0x86, 0x62, 0xB9, 0x58, 0xDE, 0x28, + 0x96, 0x42, 0xD7, 0xC6, 0xCD, 0x19, 0x4F, 0x59, + 0x58, 0x4D, 0x8A, 0x75, 0xB6, 0x7F, 0x76, 0x72, + 0xAD, 0x01, 0x08, 0x96, 0x06, 0xCA, 0x36, 0x51, + 0x07, 0x08, 0xDE, 0x35, 0x50, 0xF9, 0x25, 0x2E + }, + { + 0xFD, 0xE3, 0x2B, 0x3E, 0x1E, 0xB9, 0x96, 0x42, + 0x85, 0x47, 0x91, 0xCB, 0x2C, 0x4D, 0xEB, 0x0B, + 0x85, 0xC4, 0x1A, 0x72, 0xD7, 0x6B, 0xAD, 0xC4, + 0xEF, 0xEA, 0x67, 0x19, 0x40, 0x3F, 0xA7, 0x8B, + 0x66, 0xBA, 0xEF, 0x74, 0x47, 0x35, 0xEC, 0x62, + 0x3D, 0x7F, 0x85, 0xC8, 0x5B, 0xE1, 0x8C, 0xE0, + 0x20, 0x5F, 0x18, 0x95, 0x16, 0x6F, 0x0D, 0xDF, + 0x09, 0x48, 0xC7, 0xCD, 0x8F, 0xBC, 0x9E, 0xB7 + }, + { + 0x6F, 0xDF, 0xDA, 0x29, 0xDF, 0xFC, 0xB3, 0xF4, + 0xD4, 0x9D, 0x3F, 0x1C, 0x6B, 0x64, 0x35, 0x27, + 0xAF, 0xB1, 0xA5, 0x3A, 0x8B, 0xF0, 0xD3, 0xC5, + 0xC6, 0xA6, 0x62, 0x9D, 0xCD, 0x4B, 0xC2, 0xB2, + 0xAC, 0xC3, 0x2E, 0x2A, 0x87, 0xFD, 0xC4, 0x3C, + 0x33, 0x04, 0x78, 0xFA, 0x07, 0x59, 0xBD, 0x84, + 0xFD, 0xCD, 0x67, 0x6C, 0x8C, 0xE4, 0x87, 0x4E, + 0xC6, 0x33, 0x9F, 0x39, 0xFA, 0xF2, 0xFB, 0x02 + }, + { + 0x4C, 0x46, 0x2D, 0x1B, 0xB5, 0xC9, 0x54, 0xE6, + 0xA5, 0xAA, 0x65, 0x78, 0x0B, 0x4A, 0x25, 0xA0, + 0x4B, 0xF7, 0x01, 0x74, 0xBB, 0x68, 0x1B, 0x87, + 0x96, 0xF7, 0x0E, 0xC8, 0x9A, 0x5D, 0x1F, 0x26, + 0xB5, 0x44, 0x63, 0x4F, 0x92, 0x0E, 0x0D, 0x75, + 0x30, 0xDC, 0x34, 0x9E, 0x57, 0x91, 0xDE, 0x35, + 0xD4, 0x2B, 0x09, 0x73, 0x2B, 0x4E, 0xC6, 0x75, + 0x4D, 0x8D, 0xC6, 0xC9, 0x3B, 0x55, 0xC9, 0x86 + }, + { + 0x59, 0x1C, 0x63, 0x24, 0xDD, 0x2D, 0x8A, 0xD6, + 0x66, 0xC0, 0x6D, 0x50, 0x6F, 0x40, 0x40, 0x8C, + 0x01, 0xF0, 0x95, 0x36, 0x29, 0xE2, 0xDE, 0x92, + 0xF0, 0x16, 0x1B, 0x25, 0x91, 0xA0, 0x7B, 0xA3, + 0x58, 0x60, 0x12, 0x38, 0x81, 0xC8, 0xE9, 0x43, + 0x8B, 0xA3, 0xD0, 0x05, 0x52, 0xF2, 0x35, 0x39, + 0xEC, 0x34, 0xF5, 0xA9, 0x4F, 0x52, 0x33, 0x71, + 0xF7, 0xC6, 0x93, 0x5B, 0x5F, 0x0D, 0xEA, 0xFA + }, + { + 0xC5, 0xF9, 0x1A, 0x22, 0x82, 0x1C, 0x4C, 0x11, + 0xCE, 0x79, 0x6F, 0x2B, 0x5E, 0x0D, 0xE5, 0x06, + 0x50, 0x3D, 0x93, 0x1A, 0x55, 0x99, 0x58, 0x22, + 0xF1, 0x0C, 0x13, 0x39, 0x2B, 0x0F, 0xA4, 0x89, + 0x02, 0xFA, 0xEF, 0x2E, 0xB5, 0x79, 0xE9, 0xB4, + 0xC0, 0xE3, 0x52, 0xB3, 0x27, 0x1B, 0x23, 0xA1, + 0x43, 0xE4, 0xE0, 0x1D, 0xCD, 0x92, 0x0C, 0x76, + 0x73, 0xA6, 0xD9, 0xA5, 0xDF, 0x1C, 0x6D, 0x13 + }, + { + 0x1B, 0x3D, 0xD2, 0x6E, 0x0A, 0x27, 0xA9, 0x43, + 0xA7, 0xB6, 0xE6, 0x6B, 0x0A, 0x55, 0xC2, 0x8D, + 0xD6, 0x3F, 0x77, 0xC6, 0xF5, 0x5E, 0x25, 0x75, + 0x72, 0x95, 0xFF, 0x3F, 0x76, 0xB9, 0x17, 0xA8, + 0x77, 0x5D, 0x22, 0x0D, 0x0E, 0xD0, 0xD5, 0xA0, + 0x42, 0xC5, 0x6A, 0xB1, 0x39, 0x83, 0xEA, 0x02, + 0xFE, 0x65, 0x5A, 0x87, 0xC5, 0x1A, 0xDC, 0x0C, + 0x9C, 0x93, 0xEE, 0x10, 0xF9, 0x98, 0x7E, 0xA8 + }, + { + 0xA2, 0x45, 0xAB, 0x5C, 0xAC, 0xA7, 0x43, 0x2F, + 0xFB, 0xA1, 0xBE, 0x48, 0x4B, 0x08, 0xA6, 0x84, + 0x82, 0x4A, 0x23, 0x20, 0x55, 0xF6, 0xE2, 0x89, + 0xFA, 0x97, 0xB9, 0x3F, 0xC9, 0xFD, 0x84, 0xE8, + 0x18, 0x30, 0x65, 0xF1, 0x29, 0x4E, 0xB2, 0x0E, + 0x9B, 0xFC, 0x04, 0xE3, 0x86, 0x22, 0xB3, 0xC1, + 0xDD, 0x21, 0x3F, 0xA7, 0x47, 0xBB, 0x67, 0x90, + 0x9D, 0x7A, 0x39, 0xE5, 0xFB, 0x90, 0x32, 0xAE + }, + { + 0x0C, 0xD4, 0xFB, 0x4F, 0x72, 0xD5, 0x25, 0x2E, + 0x8E, 0x0B, 0xB6, 0x42, 0xB5, 0x28, 0xE8, 0xD9, + 0xBE, 0x82, 0x4C, 0x02, 0x9B, 0xF6, 0x8A, 0x46, + 0x99, 0x3B, 0x8D, 0x1D, 0x7C, 0x2D, 0x83, 0x1F, + 0x88, 0xF6, 0x55, 0x40, 0xDA, 0x11, 0x9D, 0xFA, + 0xAA, 0x4C, 0xD2, 0x74, 0xCF, 0xA3, 0x07, 0x29, + 0x94, 0xA7, 0xAD, 0x39, 0x91, 0x84, 0x33, 0x69, + 0x26, 0x80, 0x02, 0xE8, 0x8F, 0x85, 0x4C, 0x96 + }, + { + 0x18, 0x0B, 0xAA, 0xAF, 0x7A, 0x4D, 0x4D, 0xF1, + 0xB9, 0x41, 0x68, 0xF0, 0xD4, 0x8F, 0x46, 0xC6, + 0x90, 0x37, 0x7D, 0x2E, 0x9F, 0x9A, 0x65, 0x81, + 0xB9, 0x1F, 0x09, 0x90, 0xC0, 0x71, 0x02, 0xE4, + 0x0D, 0xB7, 0xDB, 0xBF, 0x9C, 0xFC, 0x79, 0x51, + 0xD1, 0xAD, 0xD9, 0x5E, 0xEE, 0xA6, 0xEC, 0xB1, + 0x11, 0x27, 0x62, 0xAB, 0x62, 0x27, 0x15, 0xC1, + 0xE5, 0xFE, 0x7C, 0xD5, 0x80, 0xC8, 0xA8, 0x42 + }, + { + 0xBD, 0x14, 0xAB, 0x1F, 0x8F, 0xDA, 0x51, 0xF9, + 0xF4, 0x98, 0x65, 0x0E, 0xAD, 0xB8, 0x88, 0xF0, + 0xA8, 0x4C, 0x25, 0x94, 0xCA, 0xD2, 0x29, 0x4E, + 0x3E, 0x13, 0xC1, 0x52, 0xF0, 0x7F, 0xAE, 0xB8, + 0x3E, 0x9E, 0xE7, 0x61, 0xBC, 0xA3, 0x2C, 0x08, + 0x62, 0x81, 0xED, 0x27, 0x0D, 0xA6, 0x7E, 0xD2, + 0x1A, 0x9A, 0xBE, 0x1B, 0xED, 0x25, 0xBE, 0x74, + 0x69, 0x64, 0x7F, 0x2F, 0xCC, 0x93, 0x90, 0xFA + }, + { + 0xE1, 0x33, 0x88, 0x21, 0xB8, 0x67, 0xB6, 0xA9, + 0x15, 0xDE, 0x98, 0x3C, 0x84, 0x6B, 0x04, 0x5F, + 0x30, 0x7D, 0xAF, 0x05, 0x4B, 0xA5, 0xFA, 0x48, + 0x00, 0x83, 0xA1, 0x18, 0x4F, 0xCC, 0x4E, 0x5A, + 0xFD, 0xE5, 0x09, 0x2B, 0xE8, 0xA1, 0x36, 0x6D, + 0xB6, 0xC8, 0x11, 0xE8, 0xE4, 0x67, 0xA9, 0x94, + 0x95, 0x77, 0xD9, 0xA5, 0xF9, 0x2F, 0x88, 0x39, + 0xE4, 0x01, 0x1F, 0xDC, 0x17, 0x7D, 0x4D, 0xD9 + }, + { + 0xB1, 0x6B, 0xBB, 0xEB, 0x3F, 0xE1, 0xC5, 0x20, + 0xB1, 0x29, 0xDC, 0xE4, 0xF0, 0x0A, 0xED, 0xB3, + 0x66, 0xCF, 0x80, 0x78, 0x34, 0x9C, 0x84, 0xF0, + 0x95, 0x92, 0x5B, 0x80, 0x61, 0x86, 0x41, 0x45, + 0xEE, 0xFD, 0xE4, 0x6C, 0xE6, 0x6B, 0xC8, 0xB7, + 0x57, 0xA1, 0xEC, 0x52, 0x71, 0xEF, 0xCA, 0x3C, + 0x87, 0xB8, 0xEE, 0xE0, 0x77, 0x75, 0x09, 0x9B, + 0x73, 0xF4, 0x02, 0x1A, 0xA4, 0x11, 0x04, 0x4B + }, + { + 0xB1, 0xFF, 0xF4, 0xFC, 0x36, 0x58, 0x21, 0x1D, + 0xA5, 0x58, 0x01, 0x00, 0xDB, 0x6B, 0x6B, 0xB8, + 0xFA, 0xDC, 0x71, 0x82, 0x3C, 0x1E, 0x8F, 0xCD, + 0xEF, 0xF6, 0xF6, 0x25, 0xD7, 0x41, 0xC8, 0x2A, + 0x03, 0xE9, 0x9C, 0x7E, 0x48, 0xBA, 0xCF, 0x22, + 0x06, 0xB8, 0xB9, 0xA6, 0xA0, 0x50, 0xC4, 0xA5, + 0x33, 0xB0, 0xFD, 0x1A, 0xCB, 0xBB, 0x45, 0x25, + 0x80, 0x5F, 0x29, 0x3C, 0x8A, 0x43, 0x00, 0xA2 + }, + { + 0x0C, 0xAC, 0x97, 0x78, 0x99, 0x4E, 0xEC, 0x6E, + 0x9E, 0x8D, 0xCD, 0xD2, 0xB4, 0x9C, 0x66, 0xE4, + 0x6C, 0x0E, 0x83, 0xBC, 0x3B, 0x3D, 0x66, 0xE0, + 0x31, 0x27, 0x3A, 0x3D, 0x34, 0x9E, 0x86, 0x95, + 0x01, 0xCD, 0xCC, 0x69, 0xEE, 0xE5, 0x9B, 0x3D, + 0x1C, 0xBA, 0x67, 0x4B, 0xD1, 0x25, 0xA1, 0xED, + 0x7E, 0x49, 0xC0, 0x19, 0x7B, 0x0F, 0x9E, 0xA6, + 0x2D, 0xF1, 0x71, 0xF3, 0x23, 0x40, 0xB8, 0xB8 + }, + { + 0xAA, 0x74, 0x39, 0x49, 0x95, 0x68, 0xC1, 0x65, + 0xF3, 0xFE, 0x36, 0x5E, 0xE0, 0x20, 0xBD, 0x6E, + 0x33, 0xBB, 0xC4, 0x73, 0xE7, 0x69, 0xB4, 0x7F, + 0x3B, 0x6F, 0xB5, 0x1F, 0x59, 0x0D, 0x01, 0x39, + 0x0D, 0x6B, 0xCF, 0xFE, 0x60, 0x2A, 0x5A, 0xF7, + 0x74, 0x8F, 0xAB, 0xA1, 0xDA, 0x62, 0x8B, 0x6A, + 0x94, 0x7A, 0xCD, 0xB7, 0x73, 0xA8, 0xCB, 0x39, + 0xC9, 0x8F, 0xB5, 0xB6, 0xD9, 0xBD, 0x6E, 0x1F + }, + { + 0x0A, 0xE4, 0x7E, 0x9B, 0x21, 0x49, 0x01, 0x6D, + 0x4E, 0x0C, 0x12, 0x83, 0xCE, 0xB2, 0x2E, 0xA2, + 0x7A, 0x74, 0xCE, 0x3B, 0x63, 0xC3, 0x71, 0xCB, + 0x77, 0xA0, 0x68, 0x43, 0xC8, 0x0A, 0x24, 0xC4, + 0xD0, 0xF2, 0x8D, 0x01, 0x81, 0x17, 0x6D, 0xBD, + 0x83, 0x94, 0xA5, 0x41, 0xBC, 0x44, 0x8E, 0xF2, + 0xA4, 0xBB, 0x11, 0xCC, 0xBF, 0x8F, 0xE6, 0xD9, + 0x26, 0x4A, 0xE8, 0x82, 0x44, 0xCA, 0xAE, 0x31 + }, + { + 0x2A, 0x11, 0xEB, 0x66, 0x12, 0x1A, 0x27, 0xFB, + 0xFF, 0x65, 0x86, 0x4A, 0x01, 0x3F, 0x4F, 0x80, + 0x3F, 0x3D, 0x96, 0x2B, 0xE3, 0x1A, 0xBA, 0x80, + 0xBE, 0xD9, 0xC6, 0xFD, 0x33, 0x5C, 0x3C, 0xB6, + 0xAB, 0xF8, 0x74, 0xAC, 0x70, 0x9D, 0x1E, 0x41, + 0x40, 0x35, 0x5A, 0xAF, 0xD0, 0x37, 0xA1, 0x8A, + 0x94, 0x79, 0xD7, 0x6C, 0xA0, 0xB0, 0x80, 0xC5, + 0x8C, 0x54, 0x65, 0x8E, 0xB1, 0x20, 0x3D, 0x8C + }, + { + 0xEC, 0xF2, 0x47, 0x5A, 0x7C, 0xE7, 0x93, 0xEA, + 0xD8, 0xF0, 0x9D, 0xE4, 0xD5, 0x04, 0x0D, 0xCD, + 0xDB, 0xF6, 0xA8, 0x70, 0x16, 0x8E, 0xF9, 0xB1, + 0x55, 0x62, 0x19, 0xA6, 0x64, 0x20, 0x18, 0xE3, + 0x72, 0x9C, 0x9A, 0x69, 0xCC, 0x76, 0xBA, 0x37, + 0x7B, 0x61, 0xD2, 0x14, 0xCC, 0x1B, 0x66, 0x90, + 0x97, 0xEA, 0x05, 0x4C, 0x24, 0x4B, 0xC8, 0x6C, + 0x1B, 0xC7, 0xAC, 0x64, 0xD4, 0xAD, 0xB5, 0x9F + }, + { + 0xF8, 0x8F, 0x4D, 0xE9, 0x47, 0x2C, 0xAB, 0x26, + 0x0A, 0xDD, 0x2E, 0xD5, 0x43, 0x09, 0xEC, 0x9C, + 0xC4, 0xFB, 0xDA, 0xDE, 0xC8, 0x67, 0x2E, 0xF0, + 0x36, 0xC7, 0xB6, 0xE7, 0xE1, 0x23, 0xDA, 0xF2, + 0x17, 0x7C, 0xAE, 0x4A, 0x69, 0x8F, 0x36, 0x9D, + 0x1F, 0xA8, 0x71, 0x4D, 0x59, 0x94, 0x74, 0x36, + 0x80, 0x3E, 0x2E, 0xD5, 0x07, 0x18, 0xFD, 0x8F, + 0x29, 0xB0, 0x6D, 0x0B, 0xD8, 0x7C, 0xD9, 0xEC + }, + { + 0x73, 0x98, 0xFB, 0xE9, 0x4E, 0x98, 0x1E, 0x6E, + 0x38, 0xBF, 0x48, 0x31, 0xEF, 0xD4, 0xAA, 0xB9, + 0x69, 0xC5, 0x41, 0x05, 0xEC, 0xF6, 0xA6, 0xE8, + 0x37, 0x7D, 0x0F, 0x9C, 0x74, 0x9E, 0x49, 0x01, + 0xB4, 0x86, 0xA2, 0x6B, 0xD2, 0x01, 0x3A, 0x54, + 0xF7, 0xFF, 0xB3, 0x54, 0x22, 0x5B, 0xA0, 0x07, + 0x47, 0xAF, 0x1D, 0x17, 0x79, 0x6D, 0xA9, 0x31, + 0x90, 0xE0, 0x92, 0xCF, 0x7C, 0x94, 0x3E, 0xBA + }, + { + 0xA8, 0x10, 0x23, 0xA3, 0x0B, 0x00, 0x6C, 0x14, + 0xCB, 0x99, 0x66, 0x98, 0xB8, 0xE1, 0xF9, 0x55, + 0x3D, 0xE0, 0x39, 0x54, 0x7C, 0xA5, 0x5B, 0x83, + 0xAC, 0x3A, 0x34, 0x00, 0x58, 0xD6, 0xC6, 0xD5, + 0xD8, 0xC7, 0xAA, 0xF0, 0xA3, 0x47, 0x56, 0xAA, + 0xDB, 0x8F, 0x6F, 0x30, 0x34, 0x3C, 0x9B, 0xE5, + 0x42, 0x4D, 0x90, 0x62, 0x3C, 0x1D, 0x06, 0x87, + 0x37, 0xE4, 0x75, 0x6F, 0x63, 0xE7, 0x32, 0x7F + }, + { + 0x6E, 0x36, 0xBF, 0xB3, 0x45, 0x32, 0x9D, 0x14, + 0x02, 0x7B, 0xF0, 0xFC, 0xEB, 0xDD, 0xC1, 0x82, + 0x57, 0x05, 0xDA, 0xE1, 0xF4, 0x21, 0xFA, 0x22, + 0xAD, 0xC4, 0xE1, 0x8E, 0xFC, 0x62, 0x83, 0xD3, + 0x64, 0x7B, 0xEA, 0x54, 0x9B, 0xD3, 0xB6, 0x1F, + 0xA0, 0x94, 0xFC, 0x35, 0xA1, 0xF5, 0x30, 0xA9, + 0x1B, 0xEB, 0x0C, 0x63, 0xD5, 0xC7, 0xD4, 0x03, + 0x28, 0xDE, 0x79, 0x21, 0xA8, 0xEC, 0x58, 0xFF + }, + { + 0xFA, 0x61, 0xC0, 0x0C, 0xE3, 0x5F, 0x08, 0x8E, + 0x88, 0x8A, 0x51, 0xB1, 0x47, 0xE3, 0x0E, 0xE2, + 0xFD, 0x30, 0xEC, 0x84, 0xDC, 0x7B, 0x5C, 0xE2, + 0x5D, 0x5B, 0x98, 0x17, 0xFF, 0xD7, 0x5F, 0x28, + 0x61, 0x07, 0xFC, 0x79, 0xDE, 0x96, 0x03, 0x9C, + 0x00, 0x16, 0xAF, 0x10, 0x09, 0x5B, 0x98, 0x9E, + 0x6F, 0xF2, 0xE3, 0x07, 0x0F, 0x7A, 0x70, 0xFD, + 0xF8, 0xA1, 0x90, 0x83, 0x03, 0x3C, 0x9E, 0x50 + }, + { + 0x74, 0x5F, 0x84, 0xDA, 0xAE, 0xBD, 0xDB, 0xDD, + 0x9E, 0xBB, 0x8A, 0xA0, 0x49, 0x70, 0x6E, 0xB6, + 0x19, 0xA8, 0xAC, 0x82, 0x6B, 0x80, 0x56, 0x43, + 0x21, 0xAE, 0x9A, 0xEE, 0x96, 0x24, 0xDD, 0xE4, + 0xD2, 0xAF, 0xFF, 0xC3, 0x90, 0xB7, 0xD3, 0xD3, + 0xD3, 0x34, 0x86, 0x45, 0x2D, 0x80, 0xE0, 0x5F, + 0x96, 0x2F, 0xA7, 0x88, 0x3F, 0x64, 0x54, 0xED, + 0xB3, 0x8F, 0x1C, 0x67, 0x2B, 0x54, 0xEC, 0x6C + }, + { + 0x2E, 0x6D, 0xE8, 0x91, 0x77, 0x8F, 0x1C, 0x2C, + 0xF5, 0x5A, 0x35, 0x08, 0xD6, 0x45, 0xE6, 0x95, + 0x15, 0xE1, 0xB2, 0x20, 0xDF, 0x2B, 0x87, 0x63, + 0x07, 0xB8, 0x4A, 0x16, 0x3B, 0x4C, 0xDD, 0x82, + 0xE0, 0x6F, 0x83, 0x75, 0x62, 0xC0, 0x7D, 0x04, + 0x59, 0x8F, 0xB2, 0x93, 0x01, 0x11, 0x91, 0xC3, + 0xB9, 0x25, 0x3B, 0x64, 0xF1, 0xDB, 0x4C, 0x6E, + 0x98, 0x33, 0x2D, 0xF8, 0x99, 0x17, 0x03, 0x26 + }, + { + 0x71, 0x46, 0x73, 0x70, 0xD3, 0x1B, 0x56, 0xA3, + 0xAD, 0x6B, 0x6C, 0x67, 0x8C, 0x65, 0x40, 0x8D, + 0x39, 0x0D, 0x67, 0x69, 0x99, 0xAF, 0x9C, 0x3D, + 0x7A, 0xDC, 0xDC, 0xA4, 0x83, 0xD0, 0xBD, 0x15, + 0x03, 0x2B, 0x4A, 0x16, 0xDB, 0xAD, 0x5E, 0x11, + 0xE4, 0x6F, 0x63, 0xCC, 0xE8, 0x8C, 0x27, 0xA6, + 0x9D, 0x55, 0xF3, 0x2E, 0xBA, 0x2B, 0x21, 0x6A, + 0x85, 0xB8, 0x09, 0x3E, 0xFB, 0x4B, 0xAC, 0x11 + }, + { + 0xB2, 0x7D, 0x18, 0x10, 0xA2, 0xE4, 0x2C, 0x67, + 0x3C, 0x44, 0xFB, 0x5A, 0xC7, 0xC5, 0xD3, 0xDB, + 0xB6, 0x51, 0x91, 0x04, 0x0F, 0x31, 0xB1, 0x11, + 0x65, 0xDF, 0x35, 0x06, 0xB8, 0xA8, 0xB7, 0xF2, + 0xB4, 0x39, 0xA9, 0xA5, 0xF8, 0x0E, 0x50, 0x12, + 0x41, 0xF1, 0xDD, 0x0F, 0x33, 0xCF, 0xBB, 0x9C, + 0x5F, 0xA1, 0x1C, 0x6D, 0x56, 0x1D, 0xC5, 0xFB, + 0x8E, 0x20, 0xDA, 0xD8, 0x08, 0xC8, 0x2D, 0xCA + }, + { + 0xEC, 0x62, 0xCA, 0x23, 0x91, 0x1D, 0x96, 0x0B, + 0xBC, 0xEC, 0x72, 0xEA, 0x65, 0xB6, 0x86, 0x52, + 0xDF, 0xA5, 0x3D, 0x54, 0x90, 0x15, 0xD5, 0xEF, + 0x62, 0x69, 0x54, 0x5B, 0xDA, 0x94, 0x08, 0x46, + 0x49, 0x7C, 0x8C, 0xD8, 0xB2, 0xC9, 0x71, 0x9B, + 0x45, 0x10, 0xC6, 0xB8, 0xA3, 0xD6, 0x49, 0xD8, + 0x16, 0x2E, 0xC5, 0x5D, 0xB0, 0x0B, 0x3E, 0x1C, + 0x88, 0xD2, 0xEE, 0x16, 0x27, 0x8D, 0x71, 0xE1 + }, + { + 0x25, 0x2F, 0xF2, 0xB5, 0x3B, 0x2A, 0x85, 0x9B, + 0xFF, 0x89, 0x42, 0x27, 0xCF, 0x87, 0x05, 0x4D, + 0xE6, 0x8C, 0x29, 0x95, 0xAC, 0xE6, 0x1A, 0x12, + 0x95, 0x74, 0x16, 0x2E, 0x7C, 0xD0, 0x7E, 0xA9, + 0x59, 0xBC, 0xAD, 0xCF, 0x9E, 0x22, 0xE3, 0x6F, + 0xF9, 0xF1, 0x6A, 0xBD, 0x2A, 0x92, 0x97, 0x06, + 0x5A, 0x7D, 0xF2, 0x17, 0xE4, 0xB8, 0x76, 0xC4, + 0x6B, 0x2E, 0x9C, 0x8B, 0x97, 0xE1, 0x54, 0x26 + }, + { + 0x30, 0x21, 0x08, 0x4F, 0x1A, 0x9E, 0xA6, 0xBD, + 0xD3, 0x9C, 0xF6, 0x4A, 0xD2, 0x24, 0xA0, 0x57, + 0xAA, 0xE3, 0x09, 0x0C, 0x23, 0x06, 0x57, 0x83, + 0xE6, 0x3F, 0x62, 0xDE, 0x32, 0x1C, 0xA3, 0x3A, + 0x52, 0x9E, 0x6F, 0x93, 0x73, 0x64, 0xD1, 0xD1, + 0xC0, 0xD4, 0x5F, 0x28, 0x61, 0xEE, 0xA1, 0xCC, + 0x17, 0xC9, 0xCA, 0x54, 0xA1, 0xC5, 0xA8, 0x1A, + 0x99, 0x5E, 0xDA, 0xA7, 0x94, 0x84, 0x26, 0xF9 + }, + { + 0x6B, 0x8E, 0x5D, 0x75, 0x9C, 0x07, 0x06, 0x6B, + 0xD6, 0x1A, 0x91, 0x6F, 0xA7, 0x82, 0x6A, 0xFE, + 0x80, 0x8E, 0xC5, 0xCB, 0x17, 0xBB, 0x85, 0x3C, + 0x47, 0x4A, 0x7A, 0x42, 0x0F, 0xCC, 0xCC, 0x30, + 0x36, 0x9D, 0x57, 0x33, 0x42, 0xAB, 0xE5, 0x8C, + 0xD9, 0xBE, 0xCA, 0x17, 0x06, 0xBA, 0x67, 0x10, + 0x39, 0x3E, 0x4C, 0x72, 0x6E, 0xBD, 0x41, 0x79, + 0xCA, 0x9C, 0x85, 0xF6, 0xC0, 0x35, 0xDE, 0xF1 + }, + { + 0x98, 0x61, 0xA5, 0xE6, 0x3E, 0x20, 0xF4, 0xF0, + 0x91, 0x8E, 0x2B, 0xF2, 0x39, 0x6E, 0x02, 0x93, + 0x79, 0xF4, 0x95, 0x64, 0xD3, 0x6A, 0xEC, 0x1A, + 0x72, 0xAB, 0x46, 0x63, 0x8C, 0x71, 0xE9, 0x74, + 0x1E, 0xA2, 0xD9, 0xEA, 0xC9, 0xB4, 0x77, 0x6E, + 0x4F, 0x48, 0x4C, 0xE4, 0xF3, 0x90, 0x5A, 0x26, + 0xFC, 0x42, 0x58, 0x11, 0xF5, 0xCA, 0x27, 0x58, + 0xDF, 0x02, 0xDC, 0x37, 0xFB, 0x5D, 0xE7, 0xA8 + }, + { + 0x3B, 0xEC, 0x60, 0x68, 0x81, 0x0C, 0x53, 0x0A, + 0x12, 0x0E, 0xD1, 0xD7, 0xBE, 0xD6, 0xD8, 0x71, + 0x2C, 0x0E, 0x83, 0x9B, 0xF0, 0x3E, 0x7C, 0x99, + 0xF0, 0x53, 0xB9, 0xAE, 0x25, 0xAB, 0x26, 0xCC, + 0xE3, 0x95, 0xE7, 0xD2, 0xFB, 0xB0, 0xB2, 0x0C, + 0xA5, 0x8C, 0x57, 0xCE, 0x7E, 0x2C, 0x11, 0xCB, + 0xEA, 0xA4, 0xE7, 0x62, 0xE6, 0x72, 0x38, 0x44, + 0x73, 0x0C, 0x35, 0x36, 0x4D, 0xB1, 0xE2, 0x93 + }, + { + 0xFA, 0xAA, 0x63, 0x24, 0xC5, 0x6A, 0xBB, 0x86, + 0x19, 0x84, 0x57, 0x20, 0x83, 0xB1, 0xB9, 0xE5, + 0xB7, 0x4B, 0x54, 0x3C, 0xFD, 0x48, 0x19, 0xA0, + 0xDA, 0x45, 0xFF, 0x47, 0xEC, 0x44, 0xB9, 0xD2, + 0x1D, 0x57, 0x98, 0xCB, 0x48, 0xAB, 0x3D, 0x36, + 0x9F, 0x9B, 0x49, 0xBB, 0xB6, 0x47, 0xA7, 0xE8, + 0x86, 0x33, 0xD3, 0x75, 0xA1, 0x85, 0xCD, 0x82, + 0xC9, 0xEC, 0xD1, 0x93, 0x5A, 0xA6, 0x4B, 0xA9 + }, + { + 0x43, 0xE1, 0x13, 0xBB, 0x06, 0xD9, 0x3E, 0x6F, + 0xAD, 0x43, 0x9D, 0xDD, 0xEE, 0x68, 0xF0, 0xE7, + 0xA5, 0xFA, 0x0E, 0xC8, 0x87, 0xAD, 0xE1, 0xA6, + 0x44, 0xD4, 0x3D, 0xA8, 0x54, 0xCF, 0x64, 0x9B, + 0x4D, 0x6A, 0xBA, 0x0F, 0xA9, 0x85, 0xE0, 0x4C, + 0xDE, 0x0A, 0xA6, 0xB2, 0x6B, 0xFA, 0xE7, 0x45, + 0xCE, 0x7F, 0x41, 0xCA, 0xEE, 0xDA, 0xB7, 0x29, + 0x11, 0xDD, 0x4F, 0x6E, 0x06, 0x95, 0x06, 0x62 + }, + { + 0x4F, 0x11, 0x41, 0xC2, 0x94, 0xC2, 0x6C, 0x83, + 0xCD, 0x1D, 0x06, 0x40, 0x0F, 0x2E, 0xA9, 0x36, + 0x86, 0xD1, 0x96, 0x7B, 0xA8, 0xAC, 0xCA, 0xA0, + 0x3B, 0x94, 0x2E, 0x15, 0x3E, 0xBA, 0xB5, 0x98, + 0x0C, 0x4B, 0xD9, 0x54, 0xF5, 0xAD, 0x70, 0x6E, + 0xE4, 0x60, 0x36, 0x10, 0x09, 0x35, 0x94, 0x66, + 0xC8, 0xAA, 0x83, 0xD2, 0xD8, 0x46, 0xA2, 0xB0, + 0xAD, 0x8E, 0xBC, 0x74, 0x40, 0x17, 0x68, 0x56 + }, + { + 0xAD, 0xB6, 0xC2, 0xAE, 0xEC, 0x42, 0xA5, 0x78, + 0x53, 0x82, 0x56, 0xBC, 0x48, 0x95, 0x33, 0x47, + 0x55, 0x64, 0xBD, 0x11, 0x5E, 0x13, 0xB1, 0x61, + 0x1D, 0x52, 0x01, 0x8B, 0x57, 0x9B, 0x46, 0x3D, + 0x07, 0x86, 0xF1, 0x74, 0x22, 0xA4, 0x74, 0x09, + 0x73, 0x6B, 0xFA, 0xDA, 0xE8, 0xF7, 0xC6, 0x36, + 0x5D, 0x5D, 0x62, 0x15, 0xC1, 0x39, 0xA2, 0x72, + 0x0A, 0xCC, 0xFA, 0xBF, 0xC8, 0x8E, 0x0A, 0xBF + }, + { + 0x10, 0x87, 0x94, 0xC6, 0x9F, 0x5F, 0x74, 0xBF, + 0x47, 0xD8, 0x17, 0xF7, 0xF4, 0x68, 0xE8, 0x2A, + 0xF1, 0x69, 0x5D, 0x91, 0x7F, 0x32, 0x7F, 0xE0, + 0x56, 0x20, 0x04, 0x46, 0xA2, 0x7A, 0x57, 0x98, + 0x31, 0xD7, 0x8C, 0x57, 0x7B, 0xF3, 0x34, 0x8D, + 0x8A, 0x95, 0x5B, 0x39, 0x9C, 0x2E, 0xC6, 0xB5, + 0x27, 0xFB, 0xFA, 0xCC, 0x5B, 0x84, 0x00, 0x4C, + 0xFC, 0x7B, 0x39, 0x0B, 0xF4, 0x5F, 0xBB, 0xE7 + }, + { + 0x6C, 0xC3, 0xE3, 0xA2, 0x2D, 0x1D, 0x3B, 0x4A, + 0xE5, 0xF1, 0xA6, 0x8F, 0x74, 0xE7, 0x39, 0x68, + 0xB8, 0x08, 0x3C, 0x4F, 0x66, 0x6D, 0x05, 0x5C, + 0xF0, 0x46, 0xCC, 0xB5, 0x88, 0x67, 0xC7, 0x88, + 0xED, 0xFC, 0xD4, 0xFC, 0x2A, 0x9D, 0xD6, 0xC1, + 0x52, 0x37, 0x4C, 0xD4, 0x9E, 0x9F, 0x09, 0x9A, + 0x42, 0xD6, 0x95, 0x78, 0xC2, 0x9B, 0x3F, 0x6D, + 0x82, 0x55, 0x3C, 0xD2, 0x69, 0xD6, 0xFD, 0xDB + }, + { + 0xAE, 0x28, 0x11, 0x11, 0x34, 0x59, 0xF8, 0x5D, + 0x81, 0xA9, 0x26, 0x88, 0xAB, 0xD8, 0xEA, 0xA5, + 0x2D, 0x0B, 0xBB, 0x08, 0x4B, 0xBC, 0x79, 0x13, + 0x6E, 0x4E, 0x62, 0xD5, 0xE8, 0x8A, 0x61, 0x79, + 0x2A, 0xC0, 0x41, 0xCE, 0x1C, 0x5E, 0x4D, 0x4C, + 0x27, 0x2F, 0x90, 0xFA, 0xE2, 0x99, 0xCC, 0xE9, + 0x59, 0xD4, 0xBE, 0x1D, 0xC5, 0xE2, 0xE9, 0xCF, + 0xBA, 0x57, 0x98, 0x34, 0xCD, 0xB4, 0xEB, 0x0F + }, + { + 0xE5, 0x36, 0x6D, 0x70, 0x59, 0x4F, 0xA5, 0x23, + 0xF8, 0x7C, 0x4B, 0x8C, 0x14, 0x42, 0x16, 0x7D, + 0x95, 0xAD, 0x13, 0x97, 0x81, 0x55, 0xE1, 0x9D, + 0x01, 0x98, 0xFD, 0x2D, 0xF9, 0x59, 0xF5, 0x2A, + 0xEF, 0x84, 0xF0, 0x47, 0x3C, 0xF2, 0x5A, 0x4E, + 0x4D, 0x8F, 0xE1, 0x25, 0xBC, 0x16, 0xEB, 0x0C, + 0x87, 0xFE, 0x97, 0x26, 0xE6, 0xC6, 0x8F, 0x8F, + 0x8C, 0x1D, 0x33, 0x88, 0xC4, 0x70, 0xCD, 0x75 + }, + { + 0x82, 0xAF, 0x10, 0xAD, 0x22, 0xDE, 0x20, 0xDC, + 0xFD, 0xB5, 0xF5, 0x8E, 0xC5, 0x48, 0x50, 0xAD, + 0x49, 0x53, 0x8A, 0xE6, 0x40, 0x70, 0x28, 0xFD, + 0x5D, 0x98, 0xA1, 0x91, 0xE5, 0x8C, 0x48, 0x74, + 0x4C, 0xD3, 0x01, 0xA8, 0xCE, 0xF2, 0xC2, 0xF7, + 0x83, 0xB4, 0x20, 0xFA, 0x78, 0x4C, 0x73, 0x50, + 0x21, 0xE9, 0xDF, 0xFA, 0xC7, 0xE7, 0xD0, 0xB1, + 0xF2, 0xE2, 0x1B, 0xDF, 0x10, 0x84, 0x15, 0xB4 + }, + { + 0x93, 0xA8, 0x9E, 0x10, 0xF4, 0xD3, 0x90, 0xE0, + 0x6E, 0x15, 0xFD, 0x32, 0x28, 0xD5, 0x61, 0x79, + 0xE1, 0x06, 0xBD, 0xC8, 0x21, 0x32, 0x1E, 0xAC, + 0xF7, 0xE7, 0xAB, 0xE6, 0x41, 0x36, 0x78, 0x38, + 0x2B, 0x6E, 0xD1, 0xCE, 0x36, 0x49, 0xF9, 0x5E, + 0x5D, 0x16, 0x59, 0xA3, 0x14, 0x8E, 0x9B, 0x19, + 0x8E, 0xB9, 0x03, 0xA1, 0x60, 0x91, 0x63, 0x0B, + 0xCF, 0xD5, 0x8C, 0x62, 0x07, 0x9B, 0x05, 0x84 + }, + { + 0x76, 0x63, 0x92, 0x8B, 0x57, 0x05, 0x39, 0x9D, + 0x43, 0xB0, 0x62, 0x20, 0xD2, 0xF0, 0x0C, 0xF0, + 0x57, 0xA3, 0x52, 0x5F, 0x80, 0xF1, 0xA0, 0xC3, + 0x2E, 0x3D, 0x32, 0xE1, 0xC3, 0x37, 0xE7, 0x0E, + 0x19, 0x44, 0xF9, 0x4D, 0x3B, 0xD3, 0xBA, 0xB2, + 0x65, 0xB0, 0x8D, 0x28, 0x0F, 0xFB, 0xDA, 0xA2, + 0xBE, 0x18, 0x4D, 0x7D, 0x34, 0xBF, 0xD6, 0xA9, + 0x84, 0x8C, 0xDA, 0x24, 0xA9, 0x6F, 0x7A, 0x66 + }, + { + 0x56, 0x7A, 0x29, 0x3A, 0xE2, 0xA5, 0x5A, 0x66, + 0xD8, 0xAB, 0xF8, 0xA5, 0x73, 0xFE, 0x62, 0xAB, + 0xB6, 0x4D, 0x7B, 0x16, 0xA3, 0xE8, 0xC2, 0xA3, + 0xDC, 0xC1, 0x16, 0xFE, 0x4C, 0xAF, 0x00, 0x90, + 0xF8, 0x47, 0xB5, 0x24, 0xFA, 0xC7, 0x0A, 0x91, + 0xC4, 0xA1, 0x04, 0x78, 0x33, 0xB7, 0x8E, 0x2E, + 0xBE, 0x6A, 0x60, 0xFD, 0x79, 0x2F, 0xC3, 0x19, + 0x52, 0xC8, 0x68, 0xD8, 0x58, 0xE8, 0xAD, 0x52 + }, + { + 0xD8, 0x18, 0xE3, 0x1E, 0xE4, 0x76, 0x57, 0x3E, + 0x09, 0x29, 0x36, 0x01, 0x44, 0xF6, 0x79, 0x37, + 0x8B, 0x13, 0xAF, 0x1D, 0x2D, 0x12, 0x9E, 0xE1, + 0xF8, 0x2E, 0x43, 0x5C, 0x68, 0x2F, 0x80, 0x32, + 0x44, 0x5F, 0x2B, 0x14, 0x22, 0xEA, 0xE4, 0xCE, + 0x7B, 0x31, 0x43, 0xB3, 0x8B, 0x28, 0x57, 0x30, + 0x6E, 0x5E, 0x40, 0x98, 0xF7, 0x65, 0x03, 0x33, + 0x70, 0x67, 0x2A, 0x7E, 0x95, 0xFA, 0x5B, 0x0D + }, + { + 0x7A, 0x5A, 0x36, 0xA1, 0x0B, 0xD2, 0x1C, 0xC8, + 0x8C, 0x6F, 0xBE, 0x1F, 0x83, 0x79, 0x54, 0xBE, + 0xC3, 0x43, 0xE7, 0xD4, 0xF9, 0xA3, 0x7C, 0x33, + 0xE7, 0xAB, 0x76, 0x09, 0xC1, 0x9E, 0xA1, 0xD8, + 0xFE, 0xAD, 0x2E, 0xD1, 0x2B, 0x77, 0xB5, 0xDA, + 0x95, 0x3B, 0xA2, 0x6F, 0x9C, 0xC0, 0xF2, 0xAD, + 0xD5, 0x4B, 0x81, 0xF8, 0xFA, 0x0A, 0xC4, 0x8A, + 0x1D, 0x7F, 0x86, 0x78, 0x86, 0x0C, 0x6B, 0xBC + }, + { + 0xB9, 0x59, 0xA5, 0xC2, 0xEA, 0xA9, 0x7E, 0x51, + 0xEE, 0xFA, 0x41, 0x8F, 0xE0, 0x84, 0x12, 0xCD, + 0xAD, 0xC8, 0x70, 0xB4, 0x07, 0x53, 0xA5, 0x6F, + 0x3C, 0x8C, 0xDC, 0x07, 0xD5, 0xCF, 0x20, 0x89, + 0xC0, 0xF1, 0x2D, 0x73, 0x65, 0x44, 0x2D, 0x82, + 0xE6, 0x00, 0x5E, 0xC4, 0x6B, 0x64, 0x94, 0x7B, + 0x2F, 0xB3, 0x22, 0xEC, 0x96, 0x46, 0x3D, 0x4F, + 0xEF, 0x6C, 0x2F, 0x1F, 0x48, 0xB8, 0xED, 0xE7 + }, + { + 0xBF, 0xFB, 0x53, 0xDC, 0xEF, 0x65, 0xA7, 0xAF, + 0x88, 0x00, 0x93, 0xE3, 0xCE, 0xEF, 0x80, 0x52, + 0x3F, 0xE6, 0xE3, 0xDA, 0xEF, 0x4A, 0xCB, 0xAA, + 0x60, 0xCA, 0xD8, 0xB2, 0xBC, 0x77, 0x7E, 0x94, + 0x9A, 0x4C, 0xBC, 0xE2, 0x90, 0xAC, 0x2E, 0x45, + 0xFF, 0xA1, 0xD2, 0x86, 0x76, 0xDD, 0x98, 0x41, + 0x32, 0x8D, 0x33, 0xAD, 0xDB, 0x69, 0xB5, 0xCA, + 0x9C, 0x8E, 0x7B, 0xDD, 0x09, 0x6E, 0xD9, 0xFD + }, + { + 0x72, 0x52, 0x10, 0xFE, 0x90, 0x23, 0x89, 0xA3, + 0xA9, 0x88, 0xDA, 0x0F, 0x60, 0x61, 0x3E, 0x44, + 0xA1, 0xE1, 0x08, 0x82, 0xFD, 0xC2, 0x80, 0x15, + 0xCD, 0x18, 0x95, 0x50, 0xFF, 0xA7, 0x88, 0x33, + 0x4E, 0x1F, 0x40, 0xE8, 0xA1, 0x67, 0x53, 0xF1, + 0xF3, 0x5E, 0xD2, 0x76, 0x68, 0x4F, 0xC2, 0x18, + 0xDA, 0xC4, 0x8A, 0xD4, 0x86, 0xD4, 0xDB, 0x99, + 0x67, 0xCF, 0x6A, 0x5A, 0x5F, 0xBA, 0xC9, 0x9D + }, + { + 0x8A, 0x32, 0x99, 0x56, 0xF2, 0x68, 0x79, 0xC3, + 0xAF, 0xE0, 0x75, 0x6D, 0x56, 0x71, 0xA5, 0x64, + 0x4F, 0x17, 0xAC, 0x14, 0x0F, 0x98, 0x39, 0x92, + 0x93, 0x9A, 0xBB, 0x6C, 0x8C, 0x40, 0xC7, 0x37, + 0x6B, 0x3C, 0x2A, 0xDD, 0x23, 0x13, 0x35, 0xE3, + 0x61, 0x20, 0x0C, 0xFA, 0x0A, 0x6F, 0x09, 0x68, + 0xBD, 0xC2, 0xD4, 0x63, 0xE2, 0xC0, 0x73, 0x2E, + 0x83, 0x40, 0xFE, 0x3D, 0x1A, 0x35, 0x09, 0xAE + }, + { + 0x5D, 0xC8, 0xEC, 0x0D, 0xA7, 0xBA, 0x8F, 0x70, + 0x97, 0x19, 0x12, 0x4A, 0x11, 0x90, 0x50, 0x8D, + 0x1E, 0x14, 0xF8, 0xF7, 0x00, 0xF3, 0x71, 0xB9, + 0x5F, 0xA7, 0xA7, 0xA8, 0xED, 0x6A, 0xBB, 0x8E, + 0x67, 0xBE, 0x90, 0x44, 0x71, 0x35, 0xA3, 0x8B, + 0x1C, 0x71, 0xCB, 0xCB, 0x57, 0xA3, 0x53, 0x83, + 0x91, 0x20, 0x46, 0xB1, 0x4F, 0x77, 0x4A, 0xD6, + 0x9C, 0xBA, 0x25, 0x57, 0xE2, 0x8D, 0x89, 0xCD + }, + { + 0xCF, 0x55, 0x7A, 0xD5, 0xF5, 0x44, 0x37, 0x87, + 0x12, 0xF7, 0x45, 0x23, 0x93, 0x29, 0xEB, 0x3F, + 0xD6, 0xA7, 0x3B, 0x56, 0x95, 0x1F, 0x16, 0x3A, + 0xCB, 0xA3, 0x81, 0x54, 0x2C, 0xDB, 0x23, 0xE0, + 0x11, 0xB1, 0x6E, 0x60, 0xE4, 0xFA, 0xFD, 0xCE, + 0x2B, 0x6A, 0xD0, 0x3A, 0x02, 0xE3, 0xF1, 0x9D, + 0x17, 0xF3, 0xDD, 0xC9, 0xE5, 0xDB, 0xC3, 0x28, + 0x99, 0x7D, 0x4D, 0xB8, 0xAC, 0x64, 0x71, 0xA0 + }, + { + 0xE1, 0xE0, 0xA1, 0xC7, 0x0E, 0xBB, 0xC8, 0xFA, + 0xC4, 0x43, 0x29, 0x4D, 0x74, 0x7D, 0xE7, 0x9E, + 0xF4, 0xBC, 0x5C, 0xEB, 0x42, 0xFF, 0x5B, 0x40, + 0x0A, 0x98, 0xF3, 0x3A, 0x4B, 0xEB, 0xF2, 0xF3, + 0x8D, 0x0E, 0x28, 0x51, 0x03, 0xCF, 0xE2, 0x41, + 0x14, 0x97, 0x9F, 0x57, 0x83, 0x77, 0xD6, 0xF8, + 0x6F, 0xD4, 0x83, 0x2D, 0x5C, 0x63, 0xCF, 0xDB, + 0x26, 0x79, 0xDE, 0x36, 0x63, 0x5F, 0xB5, 0xCD + }, + { + 0xB8, 0x96, 0xDC, 0x71, 0x30, 0x12, 0xD5, 0xB7, + 0x62, 0x9A, 0xB9, 0x9E, 0x99, 0xD8, 0xE8, 0xC0, + 0xB6, 0xB6, 0xC5, 0x09, 0x18, 0x67, 0x4F, 0x33, + 0x1D, 0x9F, 0x8F, 0x47, 0x38, 0x8D, 0x07, 0xF3, + 0x84, 0xFC, 0x50, 0x70, 0x2B, 0xEA, 0x0C, 0xDD, + 0xAE, 0x8D, 0xF0, 0xAB, 0x2A, 0x99, 0xEB, 0xF0, + 0x45, 0xF5, 0xCF, 0xBE, 0x0E, 0x1B, 0xF2, 0x22, + 0x8B, 0x44, 0xA8, 0x2F, 0x1D, 0xFC, 0xF5, 0xF9 + }, + { + 0xA8, 0xDD, 0x74, 0xEA, 0x8B, 0xED, 0x78, 0xB3, + 0x33, 0x92, 0x7F, 0xE5, 0x1E, 0x85, 0x0B, 0xF2, + 0x4E, 0xA6, 0xCB, 0xDD, 0x67, 0x7D, 0x12, 0x2E, + 0xC9, 0x2C, 0xCB, 0x62, 0x7B, 0xEB, 0x22, 0x58, + 0xCD, 0x4C, 0x9E, 0x8B, 0x7F, 0x23, 0x88, 0xDD, + 0x6C, 0xC8, 0xC7, 0x5A, 0x1F, 0xC4, 0x92, 0xE2, + 0x39, 0x48, 0x9F, 0x36, 0x72, 0x03, 0xD7, 0x8E, + 0xA4, 0xDB, 0xE0, 0x1B, 0x5B, 0xE2, 0xCC, 0xEC + }, + { + 0x18, 0x56, 0xD8, 0xC2, 0x91, 0xA7, 0x0A, 0x06, + 0xEF, 0x78, 0xF0, 0xAD, 0x3E, 0x3F, 0xFB, 0x6D, + 0x00, 0x58, 0x1E, 0xEC, 0x9C, 0x70, 0xB9, 0x3A, + 0x36, 0xB1, 0x19, 0x59, 0xD8, 0x9C, 0x0A, 0xEE, + 0x3A, 0x23, 0x1B, 0x0A, 0x22, 0x24, 0x6F, 0xA8, + 0x7C, 0x2C, 0xFB, 0xC5, 0x64, 0xF4, 0x7A, 0x4E, + 0x4F, 0x82, 0x8A, 0x62, 0x78, 0xD9, 0xA6, 0x6B, + 0x3A, 0xCB, 0x23, 0xD7, 0x4D, 0xA5, 0xEC, 0x35 + }, + { + 0xE0, 0xF9, 0x0E, 0x93, 0x8D, 0x6C, 0x2F, 0x5E, + 0xCC, 0xDD, 0x79, 0x6D, 0x2D, 0xAE, 0xD5, 0x73, + 0x12, 0x5F, 0x67, 0xBA, 0xE9, 0xDB, 0xAD, 0xBB, + 0xC7, 0x0A, 0x6F, 0xCD, 0x05, 0x01, 0xA2, 0x74, + 0x81, 0xFF, 0x19, 0xAB, 0xB4, 0xE2, 0x24, 0xD3, + 0x49, 0xA9, 0x5F, 0xE1, 0xFA, 0x1D, 0x95, 0x5D, + 0x4D, 0xA5, 0x0B, 0xEE, 0x5D, 0x83, 0x08, 0x0D, + 0xC7, 0xBE, 0x6F, 0xCF, 0x09, 0xC8, 0xD5, 0x14 + }, + { + 0xCD, 0x2D, 0x8B, 0xA9, 0x1F, 0x1D, 0xD2, 0x9F, + 0x90, 0x38, 0x9A, 0x31, 0xFA, 0x3D, 0x02, 0x74, + 0xB1, 0x81, 0xAA, 0x17, 0x1A, 0x50, 0x14, 0x1D, + 0x92, 0xC1, 0x6B, 0x83, 0x3A, 0xD9, 0x84, 0xC8, + 0x9C, 0xCA, 0x5C, 0x50, 0xAF, 0xE9, 0xEF, 0xCE, + 0x9F, 0xB5, 0xA3, 0x4F, 0xF2, 0x65, 0x50, 0xCE, + 0xF7, 0x2F, 0xFB, 0x0E, 0x96, 0xEC, 0x65, 0xE0, + 0xEE, 0xC9, 0x8C, 0x2A, 0x1F, 0xEB, 0x6C, 0x71 + }, + { + 0xD0, 0x91, 0x7E, 0xF8, 0xFC, 0x49, 0x71, 0x6A, + 0x72, 0x1A, 0x13, 0x6B, 0xC0, 0x71, 0x66, 0x8E, + 0xDF, 0x99, 0xEA, 0xE6, 0x5E, 0x0D, 0x78, 0xB3, + 0x59, 0x4D, 0x9B, 0xA1, 0xFD, 0x38, 0xD4, 0xF9, + 0xE6, 0xC8, 0x69, 0x08, 0xF5, 0xAC, 0x2D, 0x1C, + 0xC8, 0xC7, 0xBB, 0x7E, 0x76, 0xD6, 0xF8, 0x35, + 0xB1, 0x92, 0xD1, 0xDB, 0xD6, 0x23, 0xE0, 0xE2, + 0x9F, 0x31, 0x0C, 0x6D, 0x53, 0xDC, 0x39, 0x8D + }, + { + 0xFF, 0x72, 0x1B, 0xCE, 0x4E, 0xC7, 0x2C, 0x25, + 0x21, 0xF0, 0x46, 0x66, 0x00, 0x05, 0x3C, 0xC6, + 0x25, 0x26, 0xA0, 0xEC, 0xAC, 0x54, 0x5E, 0x3D, + 0x5D, 0x63, 0xF8, 0x5C, 0xDC, 0x43, 0xF3, 0x1C, + 0x15, 0x87, 0xFC, 0xFB, 0x7F, 0xAE, 0x9D, 0x48, + 0xC1, 0x22, 0xB8, 0xAD, 0x8B, 0x4E, 0x51, 0xFF, + 0x44, 0xBB, 0x28, 0x81, 0x35, 0x06, 0x88, 0x5C, + 0xEE, 0x6C, 0x71, 0x68, 0x86, 0x4F, 0xFE, 0x4C + }, + { + 0x13, 0x42, 0x7B, 0xD5, 0x31, 0xC7, 0x7A, 0x29, + 0xC1, 0x0D, 0x86, 0x4E, 0x01, 0x82, 0x11, 0xA1, + 0x3D, 0xF4, 0x7B, 0x55, 0x67, 0x34, 0x16, 0x3A, + 0x20, 0xC6, 0xB1, 0x97, 0x82, 0x37, 0xF6, 0xBD, + 0x43, 0x36, 0x43, 0x95, 0x5A, 0x4A, 0x6C, 0x83, + 0x8C, 0x38, 0xF4, 0x78, 0x7A, 0xF1, 0x8D, 0x5B, + 0x44, 0x88, 0x45, 0x05, 0x51, 0x91, 0x32, 0xB7, + 0x64, 0x73, 0xA9, 0x02, 0xC2, 0xF9, 0x29, 0x5B + }, + { + 0xA3, 0x07, 0xF7, 0xCB, 0x8E, 0xA9, 0xA4, 0xB7, + 0xBC, 0xE2, 0xC4, 0x82, 0xB1, 0x63, 0xA6, 0x7A, + 0x2C, 0xD7, 0x8E, 0x08, 0x9A, 0xC4, 0x5A, 0xC6, + 0x21, 0x59, 0xAF, 0x56, 0x61, 0xC0, 0xCF, 0x8C, + 0x3E, 0xBB, 0x9A, 0x7B, 0xE2, 0xAF, 0xE1, 0x16, + 0xAD, 0x7F, 0x13, 0xC5, 0x0A, 0x6E, 0x73, 0xEF, + 0xA7, 0xDD, 0x2D, 0x37, 0x31, 0x8E, 0xFC, 0x19, + 0x51, 0x37, 0xB8, 0x86, 0x88, 0x3E, 0x22, 0x91 + }, + { + 0x6F, 0xAF, 0x0B, 0xD8, 0xB0, 0x61, 0xC0, 0x90, + 0xD6, 0xEA, 0x5B, 0x74, 0x2C, 0xBC, 0xBD, 0xA9, + 0xC4, 0x68, 0x5E, 0x09, 0x06, 0x78, 0xE8, 0xC6, + 0x12, 0x17, 0xF7, 0xC2, 0x4F, 0xFD, 0x8B, 0x49, + 0x70, 0x41, 0xA5, 0xDE, 0xE6, 0x09, 0x6C, 0x71, + 0xA5, 0xDA, 0x90, 0x8E, 0xC9, 0xF0, 0x87, 0xA8, + 0xF6, 0x69, 0xDD, 0xB9, 0xEF, 0x65, 0x42, 0x77, + 0x88, 0x7C, 0x86, 0x99, 0x05, 0xCC, 0xBC, 0xE5 + }, + { + 0x30, 0x83, 0x3E, 0xA6, 0x93, 0x43, 0x9E, 0xF2, + 0xAA, 0xFB, 0xA5, 0xCB, 0xCA, 0x28, 0xC3, 0x20, + 0x08, 0x80, 0xF4, 0x6F, 0x1D, 0x75, 0x1A, 0x89, + 0x08, 0x42, 0xAB, 0x5C, 0x05, 0xE4, 0x99, 0x45, + 0xA3, 0xF4, 0xED, 0xEF, 0xAB, 0xD1, 0xA3, 0xF6, + 0xD3, 0xE9, 0xE4, 0x3C, 0x9F, 0x32, 0x8B, 0x69, + 0x5E, 0xCE, 0x39, 0xB6, 0xBF, 0x42, 0xB7, 0x92, + 0xE1, 0xD4, 0x10, 0xEA, 0x14, 0x76, 0x94, 0x13 + }, + { + 0x1D, 0xF9, 0xDD, 0x6E, 0x00, 0x8A, 0x94, 0xAB, + 0xCC, 0xA7, 0x01, 0xF8, 0x6C, 0x85, 0xA4, 0xEF, + 0xF1, 0x3D, 0xAD, 0xA2, 0x11, 0x18, 0x38, 0x1E, + 0x59, 0x11, 0x11, 0xCF, 0xFB, 0xBC, 0x4C, 0x89, + 0x99, 0x40, 0xF1, 0x5C, 0x7B, 0x03, 0xA9, 0x58, + 0xF4, 0x44, 0xEC, 0x73, 0xBF, 0x3F, 0x32, 0x9B, + 0x8E, 0x25, 0x70, 0xBF, 0xA6, 0xE2, 0x79, 0x01, + 0x8A, 0xA9, 0x06, 0xF7, 0x23, 0x68, 0xD0, 0x40 + }, + { + 0x8B, 0x63, 0xBC, 0xD5, 0xA1, 0x88, 0xF6, 0xD0, + 0x47, 0x7B, 0xCA, 0x3C, 0x68, 0x46, 0xF3, 0x9C, + 0xF6, 0x0F, 0x8C, 0x00, 0x85, 0xCF, 0xF5, 0x7B, + 0x7B, 0xBC, 0x78, 0xE2, 0x1D, 0xFD, 0x8D, 0x3B, + 0xBC, 0x39, 0xA0, 0xFA, 0x6D, 0xBB, 0xCF, 0xA6, + 0x0E, 0x9D, 0x59, 0x15, 0x44, 0xF0, 0x67, 0x84, + 0x86, 0x79, 0x1A, 0xD5, 0x1D, 0xFB, 0x36, 0x1F, + 0xE6, 0x31, 0x1D, 0xF4, 0x48, 0xAD, 0x38, 0xB5 + }, + { + 0x75, 0xFD, 0x30, 0xC2, 0x2D, 0x5A, 0x65, 0x8A, + 0xB8, 0x92, 0x6B, 0x5C, 0xA0, 0x5C, 0xE5, 0x70, + 0x58, 0xED, 0xBF, 0x80, 0xA4, 0xE7, 0x9F, 0x02, + 0xA0, 0x7E, 0xDF, 0xFC, 0x9E, 0xC2, 0xF7, 0x56, + 0x4D, 0xB8, 0xEC, 0x11, 0xF0, 0x53, 0x9F, 0x88, + 0x5B, 0x95, 0xF9, 0x15, 0x18, 0x1A, 0xCF, 0x53, + 0xB9, 0x7E, 0x3B, 0x66, 0x9F, 0x17, 0xA3, 0xFC, + 0xCC, 0x28, 0x06, 0x40, 0xA5, 0x23, 0x60, 0x2C + }, + { + 0x9B, 0x76, 0x7E, 0xF0, 0x0A, 0x75, 0x64, 0xCD, + 0xE5, 0x98, 0x0C, 0xB7, 0xD2, 0xD9, 0x58, 0x1B, + 0x54, 0x15, 0x23, 0xA4, 0x07, 0xAE, 0xA6, 0xFF, + 0x4B, 0x1A, 0x8E, 0x77, 0xD1, 0x03, 0x5F, 0x9C, + 0x7B, 0x6B, 0xBD, 0x3C, 0x53, 0xF3, 0xD4, 0x2B, + 0xF9, 0x1D, 0x40, 0x84, 0xBB, 0x79, 0xDD, 0x04, + 0xC6, 0xA8, 0xB7, 0xB2, 0x90, 0xDA, 0x7B, 0x1D, + 0x04, 0x3E, 0x5A, 0x6A, 0x22, 0x30, 0xFC, 0x7F + }, + { + 0xFB, 0xBB, 0x46, 0x2B, 0xF4, 0x26, 0x7A, 0x03, + 0x80, 0xB8, 0xB2, 0xE8, 0xC3, 0xB3, 0x7E, 0xF4, + 0x55, 0xD5, 0xB3, 0xF4, 0x27, 0x9C, 0xE4, 0x3B, + 0xC4, 0x6F, 0xC3, 0x72, 0xCE, 0xEE, 0xAE, 0xD8, + 0x35, 0xE9, 0xE1, 0x94, 0x25, 0xD6, 0xCC, 0xBB, + 0xCF, 0xEF, 0x5F, 0x4C, 0x25, 0x2B, 0x5A, 0x54, + 0xD4, 0x9D, 0x03, 0x76, 0x08, 0xF0, 0x28, 0x8F, + 0x61, 0xC3, 0xED, 0xB6, 0x29, 0x01, 0x30, 0x36 + }, + { + 0x6A, 0x04, 0x2D, 0xA6, 0x90, 0xA9, 0x25, 0x1D, + 0xF9, 0xAC, 0xC7, 0x6C, 0x9E, 0x00, 0x8B, 0x83, + 0x13, 0xDB, 0xE7, 0x39, 0x0D, 0xBE, 0x93, 0x8D, + 0xCE, 0x73, 0xFB, 0x18, 0x26, 0x52, 0x79, 0x89, + 0x4C, 0x6B, 0xAA, 0x8E, 0x14, 0x83, 0x8A, 0x9E, + 0xD2, 0x99, 0xB1, 0xC8, 0xDB, 0x3C, 0xD0, 0x37, + 0x81, 0x7C, 0x7C, 0x45, 0x84, 0x71, 0xBA, 0xC3, + 0x9F, 0x86, 0x2A, 0x60, 0xB2, 0x6D, 0x65, 0x0A + }, + { + 0xB5, 0xB9, 0x0E, 0x48, 0x23, 0xE5, 0xC4, 0x68, + 0x2F, 0xCF, 0x8F, 0x30, 0xEE, 0x41, 0x50, 0xB2, + 0x59, 0x61, 0x31, 0xAE, 0x53, 0xEC, 0x90, 0x75, + 0xE1, 0xDE, 0x72, 0x43, 0xDE, 0x58, 0x10, 0xC8, + 0x61, 0x72, 0x7C, 0x38, 0xF4, 0xDE, 0x0F, 0xF6, + 0xBC, 0x84, 0x8D, 0x9C, 0xAE, 0x9F, 0x13, 0x78, + 0x95, 0x5E, 0x85, 0x32, 0x07, 0x47, 0x62, 0xA7, + 0xEB, 0xB1, 0x4B, 0x99, 0xDA, 0xB5, 0x3F, 0x8E + }, + { + 0xAA, 0x90, 0x03, 0x55, 0xAE, 0xDE, 0xCC, 0x58, + 0xF5, 0x1F, 0x5A, 0x08, 0x28, 0x62, 0xCF, 0xDF, + 0x53, 0x01, 0x33, 0xBD, 0x3C, 0x94, 0xAE, 0xD0, + 0x6C, 0x48, 0x94, 0x17, 0xC6, 0xC9, 0x2D, 0x6E, + 0xEA, 0x67, 0x07, 0xE8, 0xDC, 0x03, 0x29, 0x5B, + 0xFB, 0x7F, 0xE1, 0xA2, 0x3D, 0x40, 0x33, 0x8E, + 0xC1, 0x71, 0x03, 0xC5, 0x26, 0x20, 0x68, 0xB9, + 0xA3, 0x3D, 0x27, 0xF8, 0xDC, 0xCE, 0x59, 0xFB + }, + { + 0x95, 0xA3, 0xDF, 0x2F, 0xD3, 0x3B, 0x94, 0xBB, + 0xE3, 0xE4, 0xD2, 0x6C, 0x03, 0x2D, 0x08, 0x1B, + 0xE9, 0xBB, 0x15, 0x87, 0xF6, 0x57, 0xB4, 0xF6, + 0xF0, 0x58, 0x27, 0x43, 0x1D, 0x9C, 0xFA, 0x43, + 0x9A, 0xC2, 0x81, 0x29, 0xB6, 0xDC, 0x8C, 0x16, + 0x0B, 0xC7, 0x07, 0x7A, 0x38, 0x76, 0xBC, 0x44, + 0xFA, 0xEF, 0x21, 0x04, 0x1D, 0xF6, 0xDB, 0xE9, + 0x12, 0x24, 0x31, 0xA6, 0x0B, 0x74, 0x25, 0x6A + }, + { + 0x98, 0x2C, 0x35, 0xFA, 0xCB, 0xE7, 0xF6, 0x65, + 0xD1, 0x3B, 0x61, 0x35, 0xCB, 0x02, 0x1B, 0xCD, + 0x46, 0x91, 0xB4, 0x39, 0x6D, 0xDF, 0x95, 0xBE, + 0x79, 0x80, 0x01, 0x95, 0x77, 0x72, 0x0D, 0xCA, + 0x7A, 0xC1, 0xDB, 0x8D, 0x0F, 0x1E, 0xDA, 0xD6, + 0xEA, 0xFF, 0x09, 0xB7, 0xB3, 0xE1, 0x24, 0xB9, + 0x95, 0x91, 0xFA, 0x8A, 0xD0, 0xE9, 0x55, 0x89, + 0xB2, 0x1F, 0x9A, 0xF5, 0x2A, 0x35, 0xAC, 0x73 + }, + { + 0xD9, 0xDB, 0x0D, 0x75, 0x06, 0x53, 0x5B, 0xCA, + 0xA2, 0x18, 0x31, 0xEA, 0x01, 0xBD, 0x70, 0x9D, + 0x07, 0x0E, 0x30, 0xDC, 0xE1, 0x5D, 0x62, 0xAE, + 0x50, 0x2F, 0xBC, 0x21, 0xD2, 0xF9, 0xDB, 0xA0, + 0x02, 0x5C, 0xD3, 0x66, 0x3E, 0x6D, 0x1A, 0x0B, + 0xAA, 0x2E, 0xB7, 0xE8, 0xFF, 0xEF, 0x87, 0x33, + 0x0A, 0xE1, 0x45, 0x81, 0xD4, 0xE5, 0xF8, 0x6B, + 0x1E, 0x17, 0x0B, 0xEB, 0x17, 0x44, 0x98, 0x0A + }, + { + 0x0C, 0xB4, 0xFF, 0x95, 0xE5, 0x4F, 0x90, 0xA1, + 0xC3, 0xF7, 0x3C, 0xB9, 0xF1, 0x78, 0x43, 0x1C, + 0x26, 0xE4, 0xCB, 0x84, 0x6B, 0x81, 0xF3, 0xCF, + 0x80, 0x69, 0x4D, 0x77, 0x04, 0x46, 0x53, 0x8B, + 0x23, 0xA9, 0x75, 0x63, 0x40, 0x0F, 0x39, 0x45, + 0xD3, 0x2F, 0x9E, 0xF5, 0x89, 0x1B, 0x20, 0x1E, + 0x93, 0xF2, 0x43, 0xED, 0x78, 0x1F, 0xAA, 0x6B, + 0xF9, 0x4B, 0xBF, 0x02, 0xF4, 0x49, 0x27, 0x28 + }, + { + 0xF4, 0x2E, 0x25, 0xD5, 0x4B, 0x75, 0xCD, 0x54, + 0x5A, 0x1A, 0x6A, 0x0D, 0x49, 0xAE, 0x80, 0x71, + 0x59, 0xCC, 0xF0, 0x89, 0x8A, 0x1E, 0xD7, 0x3A, + 0xCA, 0x2F, 0x5A, 0xE6, 0x9E, 0xD8, 0xEF, 0x07, + 0x89, 0xA2, 0x6B, 0x0D, 0xBF, 0x78, 0x6B, 0x6E, + 0x2A, 0x67, 0x60, 0xED, 0x4B, 0x03, 0xCF, 0x22, + 0x2F, 0x79, 0xD2, 0x48, 0x9C, 0xC3, 0xF8, 0x9C, + 0xFF, 0x4A, 0xCD, 0x57, 0x65, 0x0F, 0xD8, 0x6E + }, + { + 0xD1, 0xDA, 0x0F, 0x5D, 0xB4, 0xC4, 0x61, 0x92, + 0x89, 0xB6, 0x53, 0x4C, 0xAF, 0x80, 0xD1, 0x0A, + 0x68, 0xBB, 0xC9, 0x3F, 0xD1, 0x38, 0x2C, 0x9B, + 0x57, 0x33, 0xF0, 0x2D, 0x85, 0x1D, 0xF8, 0xCA, + 0x52, 0x8F, 0x32, 0xE0, 0xDA, 0x37, 0x2A, 0x65, + 0x05, 0x0C, 0x85, 0xC3, 0x44, 0x8F, 0xDF, 0x2E, + 0x33, 0x69, 0x5B, 0xE6, 0xEB, 0xF0, 0x06, 0x4C, + 0x0A, 0x79, 0x48, 0xEC, 0x54, 0x14, 0xA1, 0xDD + }, + { + 0xF8, 0x24, 0xF6, 0x0C, 0x73, 0x2A, 0x7B, 0x92, + 0x67, 0x7C, 0x36, 0x65, 0xE5, 0x83, 0xD7, 0x74, + 0x28, 0x23, 0x17, 0x36, 0xBD, 0x67, 0x0D, 0xDB, + 0x97, 0x33, 0xB7, 0x5B, 0x3D, 0xA7, 0xDE, 0xE2, + 0x80, 0xA7, 0xFA, 0xBC, 0x1C, 0x73, 0x2E, 0xBD, + 0x86, 0x4F, 0xE5, 0xD5, 0x65, 0xDA, 0x7B, 0x28, + 0x7B, 0x2E, 0x80, 0xE5, 0x4F, 0x38, 0x37, 0x7D, + 0x9A, 0xE7, 0xCF, 0x5C, 0x34, 0x3D, 0x64, 0x15 + }, + { + 0x4C, 0xD3, 0x8F, 0xD1, 0x5F, 0x4E, 0x48, 0x64, + 0x0F, 0x81, 0xF6, 0x51, 0xD0, 0xE5, 0xA1, 0x9F, + 0xEE, 0x48, 0x6D, 0x97, 0xF6, 0xCD, 0x0F, 0xC2, + 0x1B, 0x8E, 0x26, 0x1B, 0xAD, 0xE2, 0x6F, 0x55, + 0xC6, 0x5A, 0x22, 0xB6, 0x9A, 0xC1, 0xED, 0xFB, + 0x3C, 0x18, 0xA6, 0xBB, 0x49, 0x03, 0x89, 0x34, + 0x1B, 0x4B, 0x7A, 0x4B, 0x94, 0x81, 0x52, 0x28, + 0x55, 0x6A, 0xDA, 0xED, 0xCF, 0xC1, 0x65, 0x85 + }, + { + 0x5D, 0x25, 0x96, 0x4C, 0x20, 0x49, 0x54, 0xD7, + 0x84, 0xE1, 0x24, 0xE7, 0x49, 0x0D, 0x7B, 0x21, + 0x50, 0xD8, 0xA0, 0x5D, 0x44, 0x0B, 0x11, 0xEF, + 0xBB, 0x4D, 0x50, 0xB8, 0xD6, 0x34, 0x03, 0x0C, + 0xFB, 0x7E, 0x26, 0x66, 0x78, 0x34, 0xDF, 0x6B, + 0x77, 0x24, 0x95, 0xD5, 0x27, 0x86, 0xC3, 0xA9, + 0x23, 0xBC, 0xF6, 0x4F, 0xF6, 0x9E, 0xAF, 0x99, + 0xBA, 0x06, 0xD2, 0x0C, 0xEC, 0x38, 0xFF, 0x32 + }, + { + 0xE0, 0xB2, 0x16, 0x7B, 0xF8, 0x0D, 0x62, 0xD3, + 0xFC, 0xA0, 0x56, 0xE1, 0x77, 0xD7, 0x5B, 0x30, + 0x98, 0x88, 0xB7, 0xBC, 0x0B, 0x95, 0x83, 0xF4, + 0xCA, 0x6D, 0xD4, 0x58, 0x1C, 0xA7, 0x45, 0xB8, + 0x03, 0xC8, 0x0A, 0xA6, 0xD6, 0x84, 0xA9, 0xB4, + 0xE2, 0x12, 0xEB, 0x2B, 0xE1, 0x94, 0xD5, 0xE9, + 0x9D, 0x14, 0x41, 0x2B, 0x73, 0x74, 0x7F, 0x71, + 0x11, 0x2C, 0x3A, 0x16, 0xAC, 0xFC, 0x05, 0x05 + }, + { + 0xD3, 0xE7, 0xE9, 0xBF, 0xAC, 0x90, 0xBE, 0xE0, + 0x99, 0xA6, 0x93, 0xD1, 0x5A, 0x5D, 0x35, 0x93, + 0x3C, 0x64, 0x55, 0xAF, 0x3D, 0x7B, 0x81, 0xC9, + 0x7F, 0xA7, 0x65, 0xD8, 0x2E, 0x9D, 0x30, 0x05, + 0x55, 0x84, 0x1F, 0x42, 0x66, 0x3A, 0xEE, 0x7D, + 0x3F, 0x55, 0xC4, 0x4B, 0x70, 0x7C, 0x8A, 0x26, + 0xDD, 0x58, 0x16, 0xDC, 0x47, 0xE4, 0x57, 0x6D, + 0xE2, 0x97, 0xCF, 0xD0, 0x4D, 0x4A, 0xC4, 0xFE + }, + { + 0xA5, 0x27, 0xF8, 0x56, 0x87, 0x07, 0xAC, 0x4A, + 0xC1, 0x3B, 0x44, 0xC2, 0x6C, 0x03, 0xE6, 0x6C, + 0xCE, 0x50, 0x7A, 0xAC, 0x73, 0xBB, 0x33, 0x52, + 0xB3, 0xCB, 0x43, 0x4F, 0xA6, 0x10, 0x48, 0x31, + 0xBE, 0xF8, 0x1C, 0x50, 0xAF, 0x9E, 0x09, 0x37, + 0xFA, 0xD8, 0xF2, 0x89, 0x97, 0x63, 0xC3, 0x5F, + 0x2B, 0x85, 0x3D, 0x7F, 0x95, 0x32, 0x16, 0xB7, + 0xC6, 0x97, 0xE7, 0x73, 0x56, 0x76, 0xCA, 0x39 + }, + { + 0xB9, 0xE4, 0x20, 0x3D, 0x34, 0xBA, 0xFD, 0xD4, + 0x1D, 0x3D, 0x09, 0xD0, 0x55, 0x36, 0x51, 0x1A, + 0xEF, 0x55, 0x47, 0x76, 0x31, 0xDE, 0x37, 0x68, + 0x18, 0x9B, 0xA5, 0x94, 0x49, 0x62, 0x36, 0xE5, + 0xCE, 0x1D, 0xC7, 0x8E, 0x22, 0x05, 0xCB, 0xBC, + 0xAB, 0x41, 0x69, 0xD0, 0xFA, 0xE8, 0x9E, 0xEB, + 0x8D, 0xA7, 0xC8, 0x13, 0x20, 0x81, 0x11, 0xB3, + 0xC6, 0xB8, 0xC0, 0x9A, 0x64, 0x59, 0x79, 0xE5 + }, + { + 0xA1, 0x44, 0xF8, 0xF0, 0xD0, 0xD8, 0x5E, 0x7A, + 0xD4, 0x20, 0x9D, 0x2F, 0xF6, 0x3D, 0x9F, 0x7F, + 0x2F, 0xF2, 0x2C, 0x83, 0xFC, 0x7D, 0xDC, 0xD5, + 0x7A, 0x47, 0x7C, 0x29, 0x72, 0x41, 0xEB, 0x26, + 0x01, 0xFA, 0xDB, 0x09, 0xCC, 0xE2, 0x4C, 0x9C, + 0x65, 0x87, 0x02, 0x74, 0x5E, 0xB4, 0x2C, 0x30, + 0xB4, 0x13, 0x74, 0x4A, 0xD2, 0xF2, 0x84, 0xC8, + 0xD2, 0xD7, 0xE6, 0xDE, 0x13, 0xF3, 0x96, 0x28 + }, + { + 0xDE, 0x09, 0x52, 0x5E, 0x35, 0xC0, 0xBE, 0x9C, + 0x1A, 0x17, 0x73, 0x9A, 0xB5, 0xFC, 0x8A, 0xB6, + 0xEA, 0x2D, 0xC0, 0x39, 0x14, 0x3C, 0x09, 0x00, + 0xAD, 0xF5, 0xEE, 0x23, 0x5E, 0x2C, 0xB0, 0x2D, + 0x4B, 0x20, 0x16, 0xDD, 0x50, 0x3B, 0xBA, 0x29, + 0xC1, 0x4F, 0xC9, 0xB7, 0xE1, 0x0A, 0x62, 0x1E, + 0x9E, 0xF4, 0x05, 0xB7, 0x24, 0x2A, 0x63, 0xED, + 0xF8, 0xAB, 0x6C, 0xCB, 0x37, 0xB0, 0xA0, 0xC6 + }, + { + 0xD9, 0x6C, 0x2C, 0x2C, 0x82, 0xB6, 0x00, 0x02, + 0xC5, 0xA7, 0x48, 0xF9, 0x7D, 0xDA, 0xEF, 0xF3, + 0x42, 0x58, 0x96, 0x74, 0x66, 0x44, 0x79, 0x34, + 0x9F, 0xA1, 0x8D, 0x44, 0x35, 0x59, 0x73, 0xEF, + 0xEE, 0x19, 0xD2, 0x40, 0x0E, 0xB2, 0xBF, 0x29, + 0xAD, 0x7D, 0xB3, 0x86, 0x5E, 0xE0, 0x76, 0xB9, + 0xFD, 0xC4, 0xE3, 0xF9, 0x07, 0xB7, 0x6F, 0x76, + 0x10, 0xC7, 0x1D, 0xB7, 0x69, 0x9E, 0xD8, 0xB2 + }, + { + 0x36, 0x3A, 0xE6, 0x91, 0x88, 0x74, 0x94, 0x76, + 0x52, 0x97, 0xEC, 0x1F, 0x17, 0x36, 0x6B, 0x30, + 0x2F, 0xE7, 0x9F, 0x75, 0xDB, 0xA2, 0x3B, 0x3B, + 0x19, 0xF8, 0xA5, 0x10, 0x3F, 0x4E, 0xC7, 0xD2, + 0xE8, 0x0E, 0x36, 0xFC, 0xE4, 0xFA, 0xD2, 0xDB, + 0xC9, 0xB0, 0x26, 0x46, 0x58, 0xF8, 0x99, 0xA2, + 0x25, 0x51, 0xD2, 0x64, 0x6A, 0xF8, 0x4B, 0x20, + 0xAD, 0xF7, 0x22, 0x74, 0xC1, 0x7F, 0xC3, 0xB5 + }, + { + 0x08, 0x68, 0x59, 0xA4, 0x27, 0x49, 0xBF, 0x22, + 0x2F, 0xEF, 0x79, 0x26, 0xB9, 0x55, 0xFD, 0x85, + 0xB5, 0xE7, 0x0D, 0x81, 0x35, 0x9A, 0x89, 0x9B, + 0x75, 0xC4, 0x23, 0x6B, 0xC8, 0x87, 0x4A, 0x5C, + 0x37, 0x86, 0x09, 0x93, 0x44, 0x84, 0xD9, 0x86, + 0x96, 0xF0, 0xF8, 0x8E, 0xF7, 0x94, 0x78, 0x6B, + 0x8C, 0xBC, 0x00, 0x76, 0x75, 0xCE, 0x8E, 0x46, + 0xE1, 0x8E, 0x03, 0x79, 0x88, 0xF3, 0xF0, 0xED + }, + { + 0x3B, 0xA2, 0x72, 0xDC, 0x11, 0x12, 0x85, 0xCD, + 0x8F, 0xF7, 0xCA, 0x58, 0x55, 0x35, 0x6B, 0xA2, + 0x74, 0xC7, 0xB1, 0xBF, 0x42, 0x3B, 0xFF, 0xB5, + 0xEA, 0xA6, 0x77, 0x86, 0xA5, 0x36, 0x69, 0x1D, + 0xE9, 0x21, 0x91, 0xAE, 0xD6, 0xFA, 0xAA, 0x35, + 0x8D, 0x23, 0xA3, 0xD2, 0x64, 0xBE, 0x2E, 0xDA, + 0xE6, 0x7C, 0x0C, 0x6D, 0xB8, 0xEB, 0xA5, 0xC4, + 0x43, 0xD5, 0xC5, 0xE4, 0x7C, 0xD0, 0xB1, 0xB2 + }, + { + 0xDA, 0xA9, 0xB1, 0x99, 0xA1, 0xE6, 0x11, 0xC5, + 0x11, 0xFE, 0x54, 0xCE, 0xB6, 0x50, 0x7F, 0xDE, + 0x1D, 0x77, 0x73, 0x01, 0xAE, 0x18, 0xC3, 0x2B, + 0x4F, 0x90, 0x95, 0x94, 0x03, 0x0E, 0xCF, 0x3C, + 0x85, 0x73, 0xBE, 0xB2, 0x98, 0x4E, 0x56, 0xF8, + 0xA4, 0xED, 0x3D, 0xA2, 0x82, 0x9A, 0xDD, 0xC0, + 0x29, 0xBA, 0x97, 0x6E, 0x98, 0xD2, 0xA2, 0x11, + 0xE3, 0x36, 0xBF, 0xF9, 0x56, 0x71, 0x1F, 0xEE + }, + { + 0x15, 0x48, 0x8B, 0xFF, 0xD5, 0x95, 0x21, 0x7F, + 0xD1, 0xF8, 0xDA, 0xB8, 0xCC, 0x98, 0x29, 0x38, + 0xB1, 0x87, 0x0A, 0x69, 0x26, 0xBC, 0x89, 0xD0, + 0xAE, 0x28, 0x63, 0x2E, 0xAB, 0x1E, 0x5A, 0x61, + 0x7D, 0x5B, 0xB5, 0x2F, 0xD7, 0x94, 0xBE, 0xDB, + 0x64, 0xCE, 0xB2, 0x6E, 0xFA, 0xE1, 0xFF, 0x65, + 0xDC, 0x8B, 0xF4, 0xE2, 0xCD, 0x5D, 0xA6, 0xC0, + 0xB3, 0x31, 0x62, 0xDF, 0xAD, 0x54, 0xD2, 0x14 + }, + { + 0x8C, 0x89, 0xF4, 0x0F, 0x7D, 0xB3, 0xAE, 0xB6, + 0x34, 0x3C, 0x6A, 0x4C, 0x85, 0x9F, 0xDA, 0xDF, + 0xA0, 0xF8, 0xC8, 0x87, 0x11, 0x0C, 0x04, 0xA5, + 0x9D, 0xB2, 0xFC, 0xF3, 0x34, 0x5F, 0xE4, 0x75, + 0x18, 0xCC, 0xE4, 0xD2, 0x04, 0xBA, 0x36, 0x3A, + 0x45, 0xF3, 0x04, 0x3F, 0x9E, 0x6F, 0xCC, 0x67, + 0x85, 0x4A, 0xD9, 0xF9, 0x67, 0xBB, 0xC1, 0x89, + 0x41, 0x44, 0x22, 0xBB, 0x2C, 0x37, 0xEE, 0x67 + }, + { + 0x3A, 0x95, 0x4F, 0xA7, 0x56, 0xC9, 0x2F, 0xAF, + 0x33, 0xDA, 0xDB, 0xB0, 0x4D, 0xE7, 0x51, 0x5D, + 0x1B, 0x29, 0xDC, 0xED, 0xB0, 0x6A, 0x95, 0x7E, + 0x69, 0xA1, 0xFD, 0xD9, 0x85, 0xA4, 0x81, 0xC6, + 0xC6, 0x91, 0x22, 0x72, 0x9A, 0xCE, 0xBE, 0x3D, + 0x94, 0xE3, 0xAE, 0x57, 0x20, 0x14, 0x19, 0x2E, + 0x8C, 0x71, 0x56, 0x18, 0xDD, 0xD4, 0xF2, 0x64, + 0xD6, 0xF4, 0xD7, 0xA4, 0x6E, 0x6A, 0x64, 0x54 + }, + { + 0xB3, 0x01, 0x85, 0xCF, 0x0D, 0x35, 0x4B, 0xB9, + 0x51, 0x78, 0x1D, 0xD7, 0xAC, 0x2E, 0xB6, 0x00, + 0x5B, 0xE0, 0xA6, 0x2D, 0x97, 0x7A, 0x42, 0x4F, + 0xD9, 0x6E, 0x50, 0x35, 0x47, 0x12, 0x21, 0xB8, + 0x23, 0xDC, 0x87, 0xDD, 0xAE, 0x42, 0x85, 0x9D, + 0x99, 0x3A, 0xD3, 0x28, 0x5B, 0xA4, 0x67, 0x6F, + 0x12, 0xD0, 0x19, 0x19, 0x03, 0x97, 0xEE, 0x7E, + 0x3F, 0x2A, 0xCA, 0xAF, 0x67, 0x28, 0xE3, 0xF5 + }, + { + 0x7D, 0x6E, 0x25, 0x9D, 0x3F, 0xFE, 0x93, 0x2C, + 0x99, 0x05, 0x70, 0x85, 0xAA, 0x3D, 0x57, 0x92, + 0x35, 0xAB, 0x39, 0x63, 0xE8, 0x5B, 0x58, 0x67, + 0x06, 0x26, 0x11, 0xF9, 0x82, 0x86, 0x77, 0xC3, + 0x2C, 0xFD, 0x25, 0xA9, 0x23, 0x53, 0xC6, 0x36, + 0xDF, 0x01, 0x1F, 0x6D, 0x59, 0x40, 0x0D, 0xED, + 0x23, 0xFD, 0x55, 0xF5, 0x16, 0xD6, 0x33, 0xDC, + 0xCD, 0x0E, 0xF2, 0x2C, 0x28, 0x27, 0xDA, 0xEF + }, + { + 0x49, 0xB7, 0x9B, 0x8A, 0x87, 0xD4, 0xA3, 0x02, + 0x68, 0x85, 0x9B, 0xCE, 0x48, 0xE1, 0x3E, 0x6E, + 0xC1, 0xF3, 0x30, 0xD6, 0x61, 0x40, 0x32, 0xA0, + 0x9A, 0xE6, 0x13, 0xAE, 0xEE, 0xB8, 0x8F, 0xFA, + 0xD1, 0x39, 0x5A, 0xC1, 0xE2, 0x86, 0x17, 0xA9, + 0x01, 0x66, 0x0B, 0x63, 0x6D, 0x68, 0x06, 0x8F, + 0x8F, 0x5B, 0xB1, 0x0C, 0x79, 0x9F, 0x6F, 0x12, + 0x12, 0x73, 0x04, 0xA0, 0x96, 0x03, 0x37, 0x2D + }, + { + 0x70, 0x49, 0x78, 0x08, 0xB3, 0x1C, 0x54, 0xF1, + 0xC3, 0x74, 0xCD, 0x53, 0xDA, 0x46, 0xA4, 0xCA, + 0x71, 0xAF, 0x62, 0x65, 0xBC, 0xC9, 0xB0, 0x37, + 0x80, 0x8E, 0x2D, 0x32, 0xB8, 0x4E, 0xC9, 0x5C, + 0x83, 0x38, 0x5C, 0x70, 0x57, 0x83, 0x01, 0x58, + 0x7C, 0x11, 0x2E, 0xB4, 0xB6, 0x56, 0xB7, 0x4F, + 0x6D, 0x66, 0x01, 0xDA, 0x2E, 0x00, 0x82, 0x1D, + 0xA7, 0x29, 0xF8, 0xF8, 0x82, 0x80, 0xBC, 0x96 + }, + { + 0x7B, 0xA6, 0x25, 0x75, 0x28, 0x45, 0x71, 0x6F, + 0x71, 0x6F, 0xEE, 0x02, 0xD0, 0xD4, 0xC4, 0x4B, + 0xBC, 0xF3, 0xD9, 0x28, 0xF4, 0x72, 0xC1, 0xD6, + 0xDD, 0x8F, 0x44, 0xA5, 0x12, 0x76, 0x49, 0x74, + 0x6D, 0xD1, 0x86, 0xEF, 0xAE, 0xF7, 0x73, 0x6D, + 0x71, 0x1C, 0x53, 0xF1, 0x23, 0x17, 0x18, 0x99, + 0x71, 0xFF, 0xEB, 0xA9, 0x08, 0xD4, 0x9E, 0xFF, + 0xF7, 0x70, 0x9A, 0xBC, 0x59, 0x47, 0x24, 0x88 + }, + { + 0x8C, 0xDF, 0x97, 0x2A, 0x65, 0x28, 0xE9, 0x06, + 0x32, 0xE8, 0x48, 0x57, 0x8E, 0x8E, 0x5E, 0xC3, + 0x35, 0x32, 0xA8, 0x64, 0xFA, 0x00, 0x52, 0x5C, + 0x7D, 0x65, 0x45, 0x3E, 0x45, 0x66, 0x84, 0xCF, + 0xDB, 0x90, 0xB7, 0x0F, 0x11, 0x64, 0x0A, 0x01, + 0xC4, 0xB6, 0xF7, 0xC9, 0x09, 0x4A, 0xDC, 0xF4, + 0xE1, 0xEC, 0xB8, 0xB8, 0x17, 0x00, 0xB4, 0x46, + 0x58, 0xC4, 0xE6, 0xDE, 0x8B, 0xD7, 0x52, 0x93 + }, + { + 0xED, 0x40, 0x4F, 0xFD, 0xFA, 0x7E, 0x6B, 0xBD, + 0xDB, 0xF4, 0xAB, 0x2C, 0xE8, 0xD2, 0xC8, 0x1C, + 0xC3, 0x3F, 0x41, 0xC7, 0xD1, 0xF4, 0xAE, 0x57, + 0x0B, 0x9A, 0x79, 0x9C, 0x35, 0x5C, 0x8B, 0x7F, + 0x81, 0x27, 0xD8, 0x86, 0xE4, 0x8D, 0x63, 0x59, + 0xB1, 0x59, 0xE8, 0xE3, 0x81, 0x55, 0x7C, 0xAE, + 0x2E, 0x75, 0x63, 0x67, 0xF9, 0x9A, 0xF6, 0x5A, + 0x1B, 0x34, 0xB8, 0xB6, 0xD1, 0x77, 0xD6, 0x41 + }, + { + 0x7F, 0x6B, 0xE3, 0x81, 0xF0, 0xD2, 0x79, 0x95, + 0x11, 0xB0, 0x54, 0xDA, 0x76, 0x9D, 0x35, 0xAD, + 0xAC, 0x11, 0x9B, 0x89, 0x67, 0x29, 0x40, 0x42, + 0x00, 0x5F, 0x1D, 0x60, 0x7B, 0x77, 0x0D, 0x82, + 0xC9, 0x0F, 0x8C, 0xCE, 0x3A, 0xE1, 0x79, 0xE2, + 0xCD, 0xA6, 0x7B, 0x9C, 0xEB, 0xEE, 0x6E, 0xB5, + 0x6F, 0x8D, 0x93, 0x31, 0xFC, 0xF2, 0x08, 0xA5, + 0x4B, 0x8E, 0xC8, 0x2D, 0xED, 0x31, 0x0D, 0x89 + }, + { + 0x8E, 0xD2, 0x41, 0x53, 0xD7, 0x7F, 0x3A, 0xDA, + 0x26, 0x26, 0xD3, 0xB8, 0xF9, 0x18, 0x90, 0xCE, + 0xF7, 0x95, 0x51, 0x47, 0xDA, 0xC4, 0x5B, 0xAE, + 0xF0, 0x48, 0xCA, 0x15, 0xC9, 0xCF, 0x43, 0xFC, + 0x36, 0x3A, 0x6B, 0x83, 0x6B, 0x5F, 0xEA, 0x8C, + 0x2C, 0x82, 0xC2, 0x3B, 0x32, 0x24, 0xF5, 0x42, + 0x22, 0x36, 0x43, 0xC3, 0xD0, 0x6C, 0x46, 0x42, + 0xF6, 0x73, 0x16, 0x07, 0x62, 0x21, 0xBB, 0x5F + }, + { + 0x44, 0x06, 0x79, 0x5D, 0x1F, 0xC4, 0x99, 0xCC, + 0xF9, 0xC2, 0xE2, 0x40, 0x52, 0x60, 0xF4, 0x6F, + 0x72, 0xE9, 0x1F, 0x3A, 0xFF, 0xA0, 0xB2, 0x56, + 0x48, 0x59, 0xC0, 0xEA, 0x1B, 0x53, 0x65, 0x3F, + 0xFF, 0x36, 0x55, 0x1F, 0x19, 0x57, 0x83, 0x66, + 0x1B, 0xE7, 0xE1, 0xA3, 0x7E, 0xD2, 0x9D, 0x8D, + 0x5B, 0x6E, 0xA0, 0xC4, 0x91, 0xF5, 0xE6, 0x40, + 0x00, 0x5E, 0x21, 0x70, 0x9A, 0x52, 0x1B, 0x80 + }, + { + 0x37, 0xC5, 0xEB, 0xAD, 0xF8, 0xA8, 0x06, 0x00, + 0xB5, 0x9A, 0xAB, 0x9E, 0xC0, 0x3C, 0xF9, 0xBF, + 0xB7, 0xB9, 0x4B, 0x82, 0x1B, 0x3F, 0x91, 0x76, + 0x34, 0xB6, 0xE3, 0xE3, 0xC6, 0x9E, 0xF5, 0xBA, + 0x3D, 0xB0, 0xB1, 0x4C, 0x9F, 0x7A, 0xF2, 0xF8, + 0x94, 0xAF, 0xFB, 0xC5, 0xFB, 0x6C, 0x62, 0x5F, + 0x6A, 0x28, 0x3B, 0xCA, 0x84, 0xB8, 0x78, 0xDE, + 0x2C, 0xA7, 0xE5, 0x24, 0x72, 0x60, 0xCB, 0xFC + }, + { + 0xC6, 0xD1, 0x60, 0x26, 0x34, 0xE8, 0xA7, 0xB4, + 0x1C, 0x7A, 0x44, 0x4E, 0x0E, 0xB9, 0xE3, 0xB4, + 0x16, 0x45, 0x0C, 0x27, 0x1D, 0x9E, 0x6B, 0xA2, + 0xAA, 0x34, 0x1B, 0x0C, 0x3A, 0xED, 0x67, 0x7B, + 0x2D, 0xF0, 0xDB, 0x74, 0x87, 0x36, 0x54, 0x86, + 0xEC, 0x09, 0x44, 0xC2, 0xE7, 0x73, 0xEB, 0x18, + 0x36, 0xE4, 0x6A, 0x1E, 0x77, 0x06, 0x90, 0x13, + 0x8D, 0x31, 0xC5, 0xC1, 0x5B, 0x36, 0x73, 0xDC + }, + { + 0xBF, 0xF6, 0xAE, 0xB8, 0x5B, 0x21, 0x5A, 0xD5, + 0x9D, 0xEC, 0x69, 0x75, 0x6B, 0xA4, 0xF5, 0xA1, + 0x5D, 0xEC, 0x17, 0x61, 0x9E, 0x84, 0xE0, 0x14, + 0x18, 0x64, 0x2F, 0x56, 0x5A, 0x1A, 0x1E, 0x58, + 0x30, 0x3A, 0xEB, 0xD3, 0xEE, 0x3B, 0x1A, 0xA7, + 0x49, 0xE4, 0x13, 0xDF, 0x90, 0x97, 0xA0, 0xB1, + 0x38, 0xCF, 0x67, 0xBA, 0x3D, 0xB7, 0xA5, 0x81, + 0x85, 0x9F, 0x59, 0x8C, 0xE7, 0x4F, 0x2F, 0x29 + }, + { + 0xD9, 0x85, 0x12, 0x34, 0x45, 0xD0, 0x6D, 0x77, + 0x52, 0x08, 0xA3, 0xD9, 0xEE, 0x43, 0x4D, 0x47, + 0xA1, 0x9E, 0x03, 0x18, 0x98, 0xE8, 0x5E, 0xAD, + 0xE9, 0xB9, 0xA7, 0xB5, 0xC3, 0xA6, 0x9F, 0xE2, + 0xC9, 0x20, 0xC9, 0xC2, 0x29, 0xBD, 0xAA, 0x04, + 0xD6, 0x58, 0x14, 0x66, 0x46, 0xF7, 0xA0, 0x9A, + 0x98, 0x0F, 0xA8, 0x2D, 0x9E, 0x5D, 0x4D, 0xEF, + 0x82, 0xBB, 0xF6, 0xF5, 0xEC, 0x26, 0x88, 0xA9 + }, + { + 0xBB, 0x87, 0xEB, 0xB2, 0x91, 0x23, 0xEE, 0xD2, + 0xAF, 0x85, 0x54, 0x81, 0x62, 0x23, 0xE9, 0x91, + 0xE7, 0xB5, 0x7A, 0x64, 0x7A, 0x70, 0x79, 0xF7, + 0x69, 0xE9, 0x34, 0xB7, 0x04, 0x82, 0x15, 0xD2, + 0xFC, 0xE7, 0x6D, 0xF1, 0xFB, 0x1D, 0x04, 0xB2, + 0x1F, 0x29, 0x39, 0xB9, 0x87, 0xFC, 0x08, 0xCD, + 0x75, 0xA7, 0xA1, 0xA8, 0x8A, 0x2C, 0x3F, 0x81, + 0xC2, 0xBC, 0x44, 0x42, 0xA5, 0x77, 0x28, 0x85 + }, + { + 0x96, 0xE4, 0x84, 0x78, 0x24, 0x67, 0xD3, 0xB2, + 0x0B, 0x17, 0xE2, 0xF7, 0x6F, 0x68, 0x74, 0x05, + 0xC0, 0x73, 0xBD, 0x0D, 0x1E, 0xDD, 0xDC, 0x8F, + 0xFA, 0xD2, 0x1B, 0x32, 0x7A, 0x59, 0x37, 0x7D, + 0x40, 0x5B, 0x7B, 0x01, 0xA7, 0x02, 0x3F, 0xB8, + 0xA7, 0xC8, 0x05, 0x63, 0xE3, 0xA5, 0x69, 0x27, + 0x36, 0x71, 0xC0, 0x96, 0x57, 0x18, 0xF9, 0x60, + 0x57, 0xE5, 0x7C, 0x8F, 0x2D, 0xA2, 0xA9, 0x69 + }, + { + 0x45, 0x8F, 0xE6, 0x0D, 0xEE, 0xEF, 0x7D, 0x6C, + 0x27, 0xE0, 0xF8, 0x46, 0x84, 0xF3, 0x0D, 0x1A, + 0xA6, 0x9F, 0x3D, 0x1C, 0xBC, 0xC3, 0x93, 0xE6, + 0x22, 0x67, 0x91, 0x2B, 0x57, 0x34, 0x41, 0xD6, + 0x86, 0x51, 0xA3, 0x26, 0x2A, 0xCE, 0xC6, 0x9D, + 0x18, 0xA3, 0x8F, 0xE9, 0x1E, 0x6C, 0x31, 0x63, + 0x0E, 0x0D, 0xA4, 0x07, 0x95, 0xC8, 0xE8, 0x70, + 0x37, 0x7A, 0xE2, 0xBE, 0x8E, 0x5E, 0xAF, 0x87 + }, + { + 0x2B, 0xD9, 0x3B, 0xC7, 0xB9, 0xA9, 0xDA, 0x6F, + 0x0F, 0xB9, 0xEF, 0x04, 0x17, 0x9A, 0x7C, 0xD6, + 0x02, 0xD8, 0x7C, 0x7E, 0x91, 0x7F, 0x76, 0x24, + 0xA2, 0xB6, 0x3F, 0xF1, 0x6E, 0x9E, 0x0F, 0x6B, + 0xF2, 0x58, 0x99, 0x6D, 0x7F, 0x2A, 0xD8, 0x9B, + 0x66, 0x21, 0x06, 0x17, 0x3B, 0xCE, 0x87, 0xC4, + 0xD7, 0x26, 0x64, 0xE2, 0xEC, 0x2F, 0x25, 0x6B, + 0x32, 0x0E, 0xC1, 0x14, 0x2A, 0x3E, 0x0A, 0xE3 + }, + { + 0xEA, 0x91, 0xA0, 0xE3, 0xCD, 0x6F, 0xFA, 0x59, + 0xF8, 0x4F, 0xE6, 0x83, 0xDD, 0xE0, 0x13, 0x73, + 0x05, 0x77, 0x1E, 0x36, 0xC3, 0xFB, 0x83, 0x01, + 0x91, 0xE6, 0xC9, 0xA2, 0x7F, 0x49, 0xB8, 0xA9, + 0x30, 0x5D, 0x51, 0x27, 0x8E, 0x71, 0x6A, 0xE9, + 0xFF, 0x31, 0x8E, 0x09, 0x95, 0x49, 0x8A, 0xAA, + 0x97, 0x86, 0x0C, 0xB3, 0x65, 0xD8, 0x14, 0x14, + 0x2B, 0xA0, 0xF0, 0x92, 0x0B, 0xF1, 0x21, 0x1B + }, + { + 0x85, 0x6C, 0x74, 0x79, 0xFB, 0xEF, 0x1D, 0xCC, + 0x7C, 0xC7, 0x89, 0x27, 0xD5, 0x84, 0x92, 0xB1, + 0x8B, 0x1E, 0x1D, 0xD7, 0x42, 0x01, 0x4B, 0x01, + 0x9A, 0x27, 0xE7, 0xA6, 0x64, 0x3D, 0xC5, 0xE1, + 0xB5, 0x5F, 0x76, 0x4C, 0xF0, 0xDD, 0x41, 0x4E, + 0x89, 0xE7, 0x9E, 0x2E, 0x9B, 0x40, 0x4A, 0xF6, + 0x01, 0x8D, 0x3C, 0x74, 0x64, 0x2C, 0x59, 0x5D, + 0x41, 0x33, 0x84, 0xA3, 0xCF, 0xC2, 0x67, 0x27 + }, + { + 0x8E, 0x42, 0x7E, 0x0E, 0xEF, 0x69, 0x2E, 0x67, + 0x23, 0xED, 0x6E, 0x62, 0x89, 0x5A, 0xD5, 0x75, + 0xAB, 0x5F, 0x53, 0x7C, 0x81, 0xB2, 0x1A, 0x39, + 0x54, 0x8D, 0xD3, 0x05, 0x22, 0x32, 0x1D, 0x7A, + 0x0D, 0x56, 0x45, 0xED, 0xDD, 0x90, 0xA6, 0x0F, + 0xF7, 0x1D, 0xF9, 0x72, 0x8F, 0x9C, 0x4B, 0x6A, + 0x2E, 0x43, 0xAE, 0x14, 0x56, 0x60, 0xD4, 0x3E, + 0x9B, 0xE4, 0x0F, 0xC0, 0xF9, 0xE5, 0x61, 0xFA + }, + { + 0x27, 0xC4, 0x1C, 0x36, 0x47, 0xBB, 0x2E, 0x16, + 0xBF, 0xA9, 0xA7, 0x5D, 0xA5, 0x25, 0x0F, 0x3F, + 0x05, 0xBE, 0x5B, 0x59, 0xBB, 0x5F, 0x0C, 0x18, + 0x55, 0x71, 0x34, 0x11, 0x47, 0x60, 0x22, 0x18, + 0x8D, 0xBD, 0xE8, 0x7E, 0xC0, 0xCE, 0x6A, 0xF8, + 0xBC, 0x3C, 0xC1, 0xB0, 0x46, 0xCD, 0x0D, 0x63, + 0x2A, 0x13, 0x04, 0x32, 0x8B, 0xD8, 0x3D, 0x5F, + 0x36, 0x18, 0xFA, 0x47, 0x42, 0xBC, 0xB8, 0x9E + }, + { + 0x3C, 0x35, 0x8F, 0x6D, 0x23, 0xC3, 0x5E, 0xFB, + 0xCD, 0x02, 0xF4, 0xB5, 0x45, 0x5E, 0xEE, 0x00, + 0x08, 0x30, 0x2F, 0xB2, 0xBB, 0xCA, 0xAD, 0xD7, + 0x4A, 0xD8, 0x74, 0x3E, 0x9D, 0x26, 0x06, 0x97, + 0x7B, 0x0B, 0x5C, 0xFF, 0xE7, 0x5C, 0x43, 0xEA, + 0xBB, 0xE3, 0x58, 0xEC, 0xDD, 0xFA, 0x8F, 0x9D, + 0x41, 0xB4, 0x5D, 0x1B, 0x01, 0xA9, 0xB0, 0x7A, + 0x07, 0xCF, 0x88, 0x94, 0x2A, 0x56, 0x85, 0x83 + }, + { + 0x1A, 0xBB, 0x44, 0xB1, 0x2E, 0x4F, 0x31, 0x39, + 0xE2, 0xA9, 0xB0, 0x96, 0x02, 0x76, 0x64, 0xED, + 0xE2, 0x42, 0x37, 0x36, 0xC1, 0x53, 0xC4, 0x40, + 0x15, 0x36, 0x71, 0xC1, 0x5E, 0x83, 0x8A, 0x3E, + 0x94, 0x10, 0x7D, 0x02, 0x9D, 0x54, 0xB2, 0x73, + 0xA1, 0x84, 0xF2, 0x4C, 0x84, 0x30, 0x19, 0xF4, + 0xC9, 0x68, 0x83, 0xA6, 0x9E, 0x83, 0x11, 0x35, + 0x7F, 0x2D, 0xC3, 0xB3, 0xD3, 0x36, 0x67, 0x7C + }, + { + 0x80, 0x00, 0xF7, 0xB8, 0x18, 0x14, 0x98, 0x9E, + 0x9D, 0x17, 0xD1, 0xE6, 0x99, 0x13, 0x29, 0x67, + 0x53, 0x87, 0x61, 0xF5, 0xFE, 0x5F, 0xCA, 0x02, + 0x81, 0x57, 0x82, 0x7F, 0x98, 0x62, 0x4B, 0xF6, + 0x23, 0xBD, 0xC7, 0xC5, 0x05, 0x73, 0x22, 0xE4, + 0xBC, 0x89, 0xF2, 0x50, 0x32, 0x35, 0xD7, 0x9A, + 0x51, 0x0A, 0xEB, 0x1B, 0x93, 0xC5, 0xD6, 0x80, + 0x1A, 0xB0, 0x61, 0x1E, 0x5A, 0x14, 0xB7, 0x3D + }, + { + 0x6A, 0xB3, 0x81, 0x18, 0xB1, 0xBB, 0xE2, 0x49, + 0x7B, 0x8B, 0x66, 0x11, 0x01, 0x62, 0x5A, 0xE6, + 0xF8, 0x12, 0xC2, 0x3D, 0x5B, 0x2E, 0x03, 0x1D, + 0x9C, 0x4E, 0x4A, 0xFD, 0x3B, 0xBC, 0x41, 0x73, + 0xFD, 0x4B, 0x75, 0x35, 0x2E, 0x98, 0x4E, 0x24, + 0xC5, 0x08, 0xB3, 0x05, 0x12, 0x46, 0x17, 0x2F, + 0xC9, 0x06, 0x64, 0x67, 0x8A, 0xD3, 0x94, 0x1A, + 0x80, 0x61, 0x9E, 0x5D, 0xB2, 0x22, 0xA2, 0x48 + }, + { + 0xB3, 0xE5, 0xFD, 0xCA, 0x8F, 0xAA, 0x94, 0x20, + 0x97, 0x15, 0x66, 0x8F, 0x1A, 0x73, 0xF5, 0x4F, + 0x58, 0x65, 0xA0, 0xD4, 0x5C, 0x27, 0xE4, 0x3F, + 0x84, 0x86, 0xBB, 0xC0, 0xB9, 0x0E, 0xB9, 0x8C, + 0x30, 0x84, 0x34, 0xC0, 0x9F, 0x8C, 0xD5, 0xB2, + 0x13, 0x01, 0xAD, 0xAB, 0x50, 0xD3, 0x11, 0x7E, + 0x24, 0x1F, 0xE2, 0xC6, 0xCA, 0x41, 0xDA, 0xB4, + 0x2D, 0x72, 0x65, 0x67, 0xD0, 0x05, 0x25, 0x13 + }, + { + 0x0A, 0xFD, 0xD3, 0x15, 0x85, 0x42, 0x8D, 0x00, + 0x66, 0xF1, 0xAA, 0xBB, 0x3D, 0x16, 0x43, 0xB7, + 0xD2, 0x5B, 0x7C, 0x7A, 0xB0, 0xFA, 0x5F, 0x8E, + 0x68, 0xAD, 0xEC, 0x16, 0xAB, 0xF6, 0xC9, 0x37, + 0xB9, 0x49, 0x1B, 0x6B, 0x33, 0x9A, 0x75, 0x56, + 0x44, 0xE8, 0xD9, 0x9E, 0x64, 0x78, 0xF9, 0x7F, + 0x6A, 0xC3, 0xA8, 0x08, 0xA1, 0xD0, 0x6D, 0xBA, + 0x45, 0xAE, 0x3F, 0xF5, 0xBC, 0x71, 0xDC, 0x05 + }, + { + 0xB8, 0x2A, 0x00, 0x8E, 0x81, 0x94, 0x71, 0x84, + 0x98, 0x52, 0x4C, 0x37, 0xF1, 0x2E, 0xB1, 0xF3, + 0xE0, 0x8D, 0xCA, 0x56, 0x54, 0x35, 0xF8, 0x77, + 0xDE, 0x4D, 0xAA, 0x99, 0x50, 0x46, 0xD7, 0xF2, + 0x30, 0x49, 0xF8, 0x27, 0xBB, 0xDB, 0xFC, 0x11, + 0xDA, 0x17, 0x0E, 0xF7, 0x41, 0x63, 0xC7, 0xE3, + 0x01, 0x62, 0xF2, 0x6B, 0x1E, 0xA2, 0xAC, 0x34, + 0x7A, 0x99, 0xF5, 0x20, 0x92, 0x19, 0x8C, 0x42 + }, + { + 0xB5, 0x70, 0xB1, 0xD7, 0xB6, 0x30, 0x15, 0x59, + 0x96, 0x47, 0x64, 0xFF, 0x04, 0x94, 0x76, 0x7F, + 0xFF, 0x2A, 0xD6, 0x8D, 0xD8, 0x0A, 0x69, 0x3F, + 0xE5, 0x60, 0xA3, 0xE1, 0x2F, 0x41, 0xFB, 0x92, + 0x08, 0xD8, 0x30, 0x26, 0x3F, 0x0D, 0x0B, 0xFE, + 0xCA, 0xBC, 0x8E, 0x3F, 0x40, 0xFB, 0x52, 0x4E, + 0x15, 0xA4, 0xDB, 0x3F, 0x50, 0x03, 0x46, 0x99, + 0x23, 0x2B, 0x1E, 0xAD, 0x73, 0x54, 0xDA, 0xBA + }, + { + 0x01, 0xA0, 0x63, 0xAD, 0x46, 0x2B, 0x9C, 0x7D, + 0xD9, 0x35, 0x1C, 0xF5, 0xF6, 0xA6, 0xDC, 0x08, + 0x1B, 0x3F, 0x21, 0x05, 0xF6, 0x6F, 0x72, 0xF2, + 0x62, 0x3C, 0x4F, 0xC1, 0x64, 0xBC, 0x5A, 0x75, + 0xDF, 0xBF, 0xCD, 0xF4, 0xF0, 0xF2, 0x84, 0x6A, + 0x99, 0x09, 0xD5, 0x6B, 0x79, 0xA7, 0xD8, 0x89, + 0x94, 0x47, 0x53, 0x5B, 0x33, 0xC0, 0x78, 0xAA, + 0xC5, 0xA7, 0xC8, 0x99, 0x90, 0xB8, 0xAC, 0xDC + }, + { + 0x6B, 0x68, 0x68, 0xC2, 0x68, 0xBE, 0x4B, 0x0F, + 0x4E, 0x65, 0x6B, 0x02, 0x9B, 0xB5, 0x3A, 0x6A, + 0x97, 0x4A, 0x3B, 0xD7, 0xD4, 0xB7, 0x4D, 0x24, + 0xC6, 0xD5, 0x1B, 0xBB, 0xA2, 0xCB, 0xFF, 0xFC, + 0xB9, 0xC2, 0x25, 0x5F, 0xC7, 0x46, 0x40, 0xD9, + 0x01, 0xE0, 0x2D, 0xD8, 0x71, 0xEF, 0xC9, 0xB3, + 0x8F, 0x16, 0xA0, 0x26, 0xAD, 0x5F, 0xF5, 0x46, + 0x57, 0x74, 0x4B, 0xD0, 0xAD, 0x5C, 0xA1, 0x86 + }, + { + 0x0B, 0xA1, 0x27, 0xAB, 0x90, 0x3F, 0xA0, 0x63, + 0x21, 0xD9, 0x3B, 0xF3, 0x73, 0x03, 0xFF, 0x17, + 0xFF, 0x16, 0xE1, 0x06, 0x30, 0x2B, 0xC0, 0x2A, + 0x9B, 0x05, 0x72, 0x5A, 0xA0, 0xCF, 0x2A, 0x15, + 0xB8, 0x83, 0xD1, 0xC0, 0x3C, 0x98, 0x87, 0x99, + 0xD4, 0x38, 0xCA, 0x87, 0xB4, 0x4F, 0x71, 0xAF, + 0xE3, 0x57, 0xAE, 0xEE, 0x6E, 0x81, 0x64, 0x6E, + 0x11, 0x03, 0xD3, 0x2F, 0x3F, 0x88, 0xD3, 0x6B + }, + { + 0x01, 0x6F, 0x4F, 0x45, 0x6F, 0x36, 0xAA, 0xBA, + 0xBF, 0xB3, 0x04, 0x1C, 0xFC, 0x46, 0x6B, 0x4E, + 0x0D, 0x11, 0xF5, 0x97, 0x1B, 0x1F, 0x90, 0x9A, + 0xA7, 0xA0, 0x4A, 0x70, 0x48, 0x05, 0x21, 0xB6, + 0x68, 0x9D, 0xAD, 0x5B, 0xF9, 0x5B, 0xC1, 0xAE, + 0xA5, 0x9C, 0xA8, 0x50, 0x25, 0x26, 0xBD, 0x1C, + 0x68, 0xE5, 0xE6, 0xA5, 0xEE, 0x14, 0x8A, 0x07, + 0x1E, 0xED, 0x53, 0x6D, 0xB8, 0x0E, 0x32, 0x49 + }, + { + 0xB2, 0xBE, 0x16, 0x7A, 0x21, 0x84, 0xAD, 0xA8, + 0xF5, 0x98, 0xC1, 0xA4, 0xCE, 0x33, 0x32, 0x13, + 0x69, 0xCA, 0xF4, 0x72, 0x63, 0xFD, 0xCF, 0xC6, + 0x69, 0x13, 0x74, 0x68, 0xF8, 0xF5, 0xB6, 0xD7, + 0xDD, 0x67, 0xD7, 0xC4, 0xE4, 0x4A, 0x64, 0x2B, + 0xC3, 0x05, 0x5E, 0x1E, 0x8D, 0xF1, 0x8E, 0x18, + 0xDA, 0xEA, 0xA2, 0xDA, 0xB3, 0x48, 0xB5, 0x33, + 0x85, 0x76, 0x72, 0xE7, 0x37, 0xDC, 0xAB, 0x4F + }, + { + 0x65, 0x71, 0xD6, 0x5E, 0x9F, 0x63, 0x8E, 0x92, + 0x70, 0x3A, 0xA6, 0x2B, 0x54, 0x1E, 0xA8, 0x45, + 0xE7, 0x2C, 0x60, 0xC0, 0x15, 0xE6, 0x45, 0xA4, + 0x2A, 0x49, 0x0E, 0xE8, 0x15, 0x95, 0xB2, 0x8D, + 0x1B, 0x2E, 0x21, 0xE2, 0x69, 0xA5, 0x2E, 0x9F, + 0x17, 0xA9, 0x56, 0x04, 0x66, 0x44, 0x1B, 0x7A, + 0x28, 0xBB, 0x6A, 0x50, 0x41, 0x5F, 0xD0, 0x07, + 0xF8, 0x1E, 0x77, 0xFF, 0xFA, 0xA2, 0x1C, 0x50 + }, + { + 0x88, 0x99, 0xEC, 0x1B, 0x8D, 0x9C, 0x32, 0x60, + 0xF0, 0xF3, 0xF5, 0xD3, 0x96, 0xE3, 0xDF, 0xBC, + 0xA3, 0xB3, 0x10, 0xDD, 0x1D, 0xC0, 0xDC, 0x1A, + 0xE7, 0xCA, 0x84, 0xC8, 0xA6, 0x10, 0x89, 0x2C, + 0xB2, 0x78, 0x74, 0x63, 0x20, 0xAC, 0x88, 0x4C, + 0xC8, 0xD2, 0xED, 0x9F, 0x41, 0x24, 0x60, 0x4D, + 0xB2, 0x8C, 0xB3, 0x12, 0x09, 0xAA, 0x5F, 0x11, + 0xC9, 0x52, 0xDF, 0x02, 0x02, 0xFD, 0xB2, 0x52 + }, + { + 0x7C, 0x9A, 0xD3, 0x52, 0x3A, 0x4B, 0x15, 0x01, + 0xA6, 0xDD, 0x01, 0xB0, 0x60, 0xED, 0xCE, 0x55, + 0x21, 0xAB, 0xC0, 0x99, 0x7D, 0x7B, 0x83, 0x42, + 0x68, 0x7B, 0x05, 0xD1, 0x5F, 0xEC, 0xDA, 0xAF, + 0x90, 0xCD, 0xD8, 0xAB, 0x15, 0x5C, 0x79, 0x85, + 0x23, 0x95, 0x6D, 0x80, 0x8A, 0x48, 0x30, 0xA4, + 0x2E, 0x3C, 0xC3, 0x4A, 0xAE, 0xFE, 0x4A, 0x6E, + 0x0C, 0x80, 0x29, 0xC3, 0xC9, 0x56, 0xBE, 0x89 + }, + { + 0x27, 0xE7, 0xBC, 0x25, 0x19, 0x71, 0xF4, 0x82, + 0xCC, 0xAF, 0x35, 0x28, 0xFD, 0x48, 0x7A, 0x44, + 0x97, 0xBE, 0x16, 0x3D, 0x6B, 0xF6, 0x48, 0xF1, + 0xAD, 0x3A, 0xFB, 0xC8, 0xAC, 0xBE, 0x81, 0xE8, + 0xB1, 0x1D, 0x4E, 0x97, 0xD9, 0x40, 0xF7, 0xA8, + 0x28, 0xDE, 0xFC, 0xE5, 0x07, 0x4F, 0x61, 0x25, + 0x93, 0x77, 0xB8, 0x1B, 0x2E, 0xAC, 0x46, 0xA0, + 0x74, 0x74, 0x17, 0xE4, 0x58, 0xE6, 0xB1, 0x81 + }, + { + 0x1F, 0xC8, 0x00, 0x39, 0x0D, 0x90, 0x31, 0x9A, + 0x6F, 0x92, 0xC7, 0xA2, 0xF4, 0x80, 0x4C, 0xD5, + 0x86, 0x97, 0xFF, 0x2B, 0xE5, 0x18, 0xFD, 0xEA, + 0x1C, 0xB4, 0xF2, 0xA7, 0x0A, 0xEC, 0xEC, 0x8D, + 0x1A, 0x1F, 0xF3, 0xFE, 0x6D, 0x30, 0x9C, 0xA9, + 0x62, 0xEF, 0xE2, 0xF1, 0xC2, 0x65, 0x75, 0x9D, + 0x4D, 0x17, 0x9E, 0x41, 0xFB, 0xA9, 0x44, 0x0C, + 0xBC, 0x8B, 0x19, 0x71, 0x72, 0x1D, 0x56, 0xC7 + }, + { + 0xFF, 0x69, 0xA8, 0x1D, 0xCD, 0x46, 0xBB, 0xF4, + 0xA7, 0x27, 0x6A, 0xF6, 0xCA, 0x79, 0xE0, 0x56, + 0x67, 0x8D, 0x31, 0xB3, 0xC2, 0x40, 0x1A, 0x53, + 0xFA, 0x27, 0x6B, 0x57, 0xFC, 0x5D, 0x73, 0x6F, + 0x5A, 0x5E, 0x6D, 0xC6, 0x4B, 0xB7, 0x03, 0xE9, + 0x2F, 0x06, 0x0F, 0x2E, 0x65, 0x1B, 0x91, 0x93, + 0x02, 0x87, 0xD2, 0xCE, 0xE0, 0xDD, 0x5A, 0x12, + 0xFF, 0xF2, 0x02, 0x6D, 0xA2, 0x37, 0x4B, 0x7F + }, + { + 0x5A, 0x99, 0x3D, 0xCB, 0xB3, 0x0A, 0xE3, 0x29, + 0xA3, 0x2B, 0x03, 0x95, 0xF3, 0x0D, 0xA6, 0x0B, + 0xCF, 0xA1, 0x21, 0x74, 0x4B, 0x2A, 0x34, 0xFE, + 0x9A, 0xC0, 0x54, 0xBC, 0x8C, 0x66, 0xE9, 0x86, + 0xCC, 0x08, 0x65, 0xF7, 0x22, 0xD4, 0xFC, 0xD5, + 0x52, 0x76, 0xFF, 0x21, 0x6A, 0x2C, 0xDD, 0x85, + 0x7E, 0xFA, 0x49, 0xC3, 0x9C, 0x26, 0xA5, 0x7F, + 0x69, 0x76, 0x80, 0x4A, 0xAB, 0xE1, 0xC8, 0xF9 + }, + { + 0xC0, 0x62, 0xF4, 0x4C, 0xBF, 0x41, 0xB6, 0xB6, + 0x26, 0x9C, 0xD3, 0x70, 0x17, 0x84, 0xAD, 0x22, + 0xE0, 0x58, 0x7C, 0x0F, 0x3B, 0xB7, 0x80, 0x19, + 0xAE, 0x6C, 0x62, 0x3C, 0x8D, 0x82, 0xF7, 0xBE, + 0x2D, 0x7B, 0xC7, 0x33, 0xE4, 0x64, 0x9F, 0x99, + 0xF8, 0x69, 0x30, 0x59, 0x72, 0xDA, 0x28, 0x6B, + 0x00, 0xB9, 0x50, 0x39, 0x6D, 0x0A, 0x72, 0x12, + 0x70, 0x95, 0xB7, 0xA7, 0xE8, 0xE4, 0x20, 0x2B + }, + { + 0xC0, 0x95, 0x22, 0xEC, 0x85, 0x01, 0x68, 0xBA, + 0x36, 0xE0, 0xCE, 0xF7, 0x8A, 0xDF, 0x92, 0xBD, + 0x4A, 0x6F, 0x00, 0x56, 0x31, 0xCD, 0xA4, 0x4E, + 0x4E, 0x15, 0x1E, 0x80, 0x15, 0x6F, 0x5D, 0x64, + 0xFE, 0x29, 0xBD, 0x1F, 0x09, 0x45, 0x76, 0x55, + 0xC8, 0xDE, 0xA1, 0x4B, 0x7C, 0x8D, 0x82, 0xF2, + 0xF2, 0xAF, 0x45, 0xD0, 0xEF, 0x92, 0xE9, 0x64, + 0xF8, 0xDA, 0x54, 0xB5, 0x9B, 0x4C, 0x58, 0x34 + }, + { + 0x6F, 0xD2, 0xA8, 0xED, 0xF3, 0xEF, 0xB9, 0x80, + 0xD6, 0x8F, 0xC9, 0x37, 0xB6, 0x7E, 0xBB, 0x1B, + 0xDB, 0x15, 0xED, 0x51, 0x8A, 0xF8, 0x80, 0x46, + 0x93, 0xCC, 0x6E, 0xFC, 0x0B, 0xD7, 0xE7, 0x0A, + 0x53, 0x62, 0x31, 0x21, 0x9B, 0x05, 0x54, 0x03, + 0x98, 0x4D, 0x2F, 0xF1, 0xDB, 0xC5, 0x4E, 0xC5, + 0x39, 0x22, 0x5D, 0x63, 0xD9, 0xED, 0xFE, 0xB5, + 0x1B, 0x78, 0xA1, 0xC6, 0x54, 0x21, 0x7B, 0x68 + }, + { + 0x0B, 0x51, 0xF1, 0x89, 0x49, 0x61, 0x4C, 0x59, + 0xBB, 0x45, 0x1D, 0x25, 0x81, 0x93, 0x28, 0x67, + 0x6B, 0x5E, 0x08, 0x6E, 0x29, 0x94, 0x5B, 0x0E, + 0x5F, 0x38, 0x0E, 0x3B, 0xBC, 0xF5, 0x80, 0x9A, + 0x7F, 0x23, 0x39, 0xD3, 0xAA, 0xBB, 0x0B, 0x3A, + 0x7D, 0x78, 0x9E, 0xC9, 0x94, 0x48, 0xCF, 0x36, + 0x3A, 0x7C, 0x3F, 0x22, 0x87, 0x71, 0x23, 0x2F, + 0x7F, 0x09, 0x0A, 0xF1, 0xAB, 0x03, 0xF0, 0x89 + }, + { + 0xB8, 0x1B, 0x40, 0x26, 0x55, 0xCA, 0xC0, 0xEA, + 0x8E, 0xA1, 0xE7, 0x9D, 0x36, 0xAC, 0x8E, 0x0A, + 0x2F, 0xE3, 0x35, 0x0C, 0x14, 0x01, 0x20, 0x24, + 0x76, 0xA1, 0x93, 0x70, 0x3D, 0xEF, 0x8B, 0x06, + 0xCA, 0x7A, 0xA3, 0x8D, 0x3C, 0x73, 0xC5, 0x1C, + 0x4D, 0x3F, 0x5E, 0xE5, 0x4F, 0x51, 0x56, 0x0E, + 0x66, 0x93, 0x4F, 0xA9, 0xE7, 0xD8, 0x17, 0x93, + 0x87, 0x13, 0x64, 0xFF, 0x73, 0xC2, 0x3D, 0x29 + }, + { + 0x5F, 0x6A, 0x29, 0x49, 0xD1, 0x1D, 0xDA, 0x9E, + 0xBB, 0xD6, 0xEB, 0xE6, 0xD3, 0x2A, 0x35, 0x8A, + 0x04, 0xD3, 0x9E, 0x30, 0xD0, 0x8B, 0x94, 0x54, + 0x60, 0xAC, 0x14, 0xDC, 0x00, 0x82, 0x73, 0xE3, + 0x4B, 0x0E, 0x73, 0x38, 0x71, 0x81, 0x6C, 0x22, + 0xE9, 0xF9, 0x47, 0x6B, 0xBA, 0xEA, 0xFA, 0xC0, + 0x91, 0xA4, 0x3C, 0x81, 0x6D, 0x26, 0xF5, 0x89, + 0xC0, 0x3E, 0x73, 0x80, 0xBD, 0xD9, 0x95, 0xD5 + }, + { + 0x8B, 0xCD, 0x88, 0x58, 0x7E, 0xF8, 0x88, 0x63, + 0x93, 0xC2, 0xBC, 0x69, 0xB8, 0xDC, 0xE2, 0x78, + 0xE6, 0xBB, 0x98, 0xB7, 0x7A, 0xE5, 0x98, 0x5D, + 0x78, 0x87, 0x0F, 0x49, 0xDD, 0x91, 0xF8, 0x0C, + 0xD6, 0x79, 0x3C, 0x39, 0xD7, 0x9C, 0xA2, 0x04, + 0x5B, 0x0A, 0xCC, 0x28, 0xEC, 0xBE, 0xB8, 0x3A, + 0x7E, 0xB3, 0x16, 0xBF, 0x81, 0xF4, 0xD0, 0x0E, + 0xBB, 0xE3, 0x9E, 0xC9, 0xE2, 0xA8, 0x72, 0x62 + }, + { + 0x4D, 0x5E, 0x9A, 0x80, 0xBC, 0x7F, 0x73, 0xAE, + 0x9E, 0xFB, 0xF7, 0x37, 0x71, 0xFF, 0xE7, 0x9B, + 0x23, 0xEA, 0xFB, 0x1A, 0x69, 0x7B, 0x54, 0x23, + 0x39, 0x00, 0xDF, 0x22, 0x6F, 0xA5, 0x7D, 0xF7, + 0x32, 0x31, 0xAE, 0xCC, 0xDF, 0xC3, 0xD7, 0xCA, + 0xC0, 0x76, 0xBC, 0x9C, 0x24, 0x6E, 0xA9, 0x84, + 0xCA, 0x99, 0x34, 0x60, 0x3F, 0xBB, 0x9B, 0x29, + 0x42, 0xDE, 0x16, 0xBC, 0x97, 0x38, 0x89, 0xB1 + }, + { + 0x1B, 0x24, 0x3C, 0xAE, 0x01, 0xB4, 0xB6, 0x5F, + 0x16, 0xB3, 0x6A, 0xC6, 0x5C, 0x6F, 0x0A, 0x29, + 0x88, 0x0E, 0xE3, 0xC6, 0xBC, 0x3A, 0x7F, 0x77, + 0xEE, 0xFB, 0xED, 0xE4, 0xA5, 0x8C, 0xA0, 0xAB, + 0x7C, 0xE7, 0x03, 0xD6, 0x47, 0xD0, 0x6B, 0x5D, + 0x0D, 0x9A, 0x71, 0x77, 0x48, 0x4B, 0x4F, 0x8A, + 0xA8, 0xEA, 0x9B, 0x62, 0xFD, 0xE3, 0x23, 0x77, + 0xC3, 0x8D, 0xB1, 0x18, 0xFF, 0x84, 0x38, 0xBB + }, + { + 0x35, 0x6F, 0xB6, 0xAE, 0x3A, 0x57, 0x98, 0x75, + 0xB5, 0xC8, 0x84, 0x28, 0x0A, 0x90, 0x65, 0xB3, + 0x4E, 0xD9, 0xC8, 0xEE, 0x73, 0x8F, 0xEA, 0xD2, + 0x33, 0x3D, 0x02, 0xC7, 0x45, 0xA1, 0x68, 0x60, + 0x7A, 0xF6, 0x35, 0x3D, 0x65, 0x1F, 0x69, 0xBE, + 0xB5, 0x06, 0x7C, 0x5C, 0xF6, 0x40, 0xE1, 0xBC, + 0xAA, 0xB8, 0x64, 0xD8, 0x3B, 0x4E, 0xEF, 0x17, + 0x57, 0xF0, 0x7F, 0x4E, 0x53, 0x4E, 0x47, 0xF8 + }, + { + 0x11, 0x60, 0x31, 0x84, 0xF3, 0x30, 0x6D, 0x52, + 0x5A, 0x9B, 0x34, 0x3A, 0x43, 0xAB, 0x3C, 0xD4, + 0x45, 0x41, 0x8C, 0x88, 0xAB, 0xAE, 0x57, 0x1C, + 0x5F, 0x49, 0xAE, 0x60, 0x74, 0x25, 0xAB, 0x1A, + 0x31, 0xA4, 0x00, 0x87, 0x4B, 0x17, 0x17, 0x0E, + 0x12, 0xFC, 0xA3, 0xA5, 0x6A, 0x9E, 0x60, 0x15, + 0x97, 0x3B, 0x93, 0xAD, 0xEF, 0x7C, 0x79, 0xFE, + 0x3D, 0x65, 0xD4, 0x4A, 0x3C, 0xFA, 0x21, 0xBD + }, + { + 0xEB, 0x1F, 0xED, 0x67, 0x22, 0x37, 0xDC, 0x3A, + 0xB3, 0x28, 0xF6, 0x68, 0xEC, 0x30, 0xA0, 0x25, + 0x86, 0xD1, 0x6A, 0x75, 0xA0, 0xE7, 0xD2, 0x5C, + 0x5F, 0x08, 0x4C, 0x73, 0x32, 0x3C, 0x60, 0xB7, + 0xD3, 0x78, 0x36, 0x37, 0x3B, 0x7A, 0xD1, 0x55, + 0xB3, 0xAB, 0x56, 0x7A, 0xF9, 0xE1, 0x29, 0x95, + 0xC8, 0x6D, 0x3E, 0x6D, 0x78, 0x31, 0x58, 0xC7, + 0x05, 0xAE, 0x59, 0xDA, 0x08, 0x6F, 0xF6, 0xAC + }, + { + 0xF4, 0xF1, 0xC7, 0xFB, 0x27, 0xBD, 0xFE, 0x3E, + 0xAC, 0x2C, 0x95, 0x4C, 0xCD, 0x2B, 0x8B, 0x15, + 0x6F, 0xFB, 0xE4, 0xF9, 0x55, 0x61, 0xA6, 0x97, + 0xA4, 0xF9, 0xC0, 0x08, 0x30, 0x8D, 0x47, 0x55, + 0xB0, 0x4E, 0x0C, 0xA2, 0xB0, 0xFF, 0xE3, 0x9B, + 0xD8, 0xCD, 0xF7, 0x56, 0x90, 0x84, 0x46, 0xC2, + 0x64, 0xB6, 0x83, 0xD0, 0xE9, 0xB5, 0xA8, 0x96, + 0xF6, 0x05, 0xEB, 0x28, 0x64, 0xC9, 0xF1, 0x31 + }, + { + 0x8D, 0x43, 0xF3, 0x94, 0xA5, 0x59, 0xB7, 0xC3, + 0x43, 0xA3, 0xCB, 0xE7, 0x4D, 0x6A, 0x76, 0xFA, + 0xCC, 0x42, 0xF1, 0x81, 0x87, 0x39, 0x97, 0x24, + 0x4C, 0xEC, 0xC8, 0x0A, 0xB1, 0xDF, 0xDC, 0x2C, + 0x95, 0x00, 0x95, 0x36, 0x14, 0x1B, 0x36, 0x30, + 0x13, 0x49, 0xA1, 0xF0, 0x32, 0x82, 0xCA, 0x07, + 0xCE, 0xB9, 0x40, 0xCA, 0x8E, 0x09, 0x5D, 0xFB, + 0x31, 0x0A, 0x1A, 0xE1, 0x0B, 0xB2, 0x61, 0xB1 + }, + { + 0x17, 0x16, 0xC8, 0xF2, 0x20, 0x8B, 0xCD, 0x6B, + 0xF4, 0xC8, 0xD8, 0x15, 0xD1, 0x1C, 0x66, 0x27, + 0x79, 0x9B, 0xBD, 0xD3, 0x40, 0x1F, 0xEE, 0x0D, + 0x94, 0x5F, 0xBF, 0xBF, 0xC9, 0x7B, 0xE0, 0x53, + 0x27, 0x12, 0xF0, 0x2C, 0xAD, 0x39, 0x31, 0x91, + 0xD9, 0x40, 0xCC, 0xDD, 0x22, 0x03, 0x5D, 0xE7, + 0xB8, 0x4E, 0x4D, 0xF1, 0x7F, 0xD3, 0x8E, 0xDA, + 0x03, 0x27, 0xB5, 0x18, 0xE3, 0x17, 0x8D, 0x88 + }, + { + 0x47, 0xE6, 0x8E, 0x2A, 0x83, 0x0A, 0xA9, 0x84, + 0x0E, 0xB4, 0xDC, 0xF4, 0x46, 0x76, 0x85, 0xBB, + 0x70, 0xD6, 0xFB, 0x64, 0x39, 0xCB, 0x38, 0x6A, + 0xD2, 0xEE, 0x96, 0x57, 0x98, 0xE4, 0x19, 0xCF, + 0xBC, 0x40, 0xAE, 0xE6, 0x72, 0x87, 0x23, 0xB1, + 0xBD, 0x9A, 0xE3, 0xE5, 0x1B, 0x30, 0xE8, 0xCE, + 0x28, 0xAF, 0x31, 0x5A, 0x35, 0xA1, 0xE1, 0x72, + 0xE1, 0xDB, 0xBD, 0x4D, 0x5F, 0x4E, 0xBD, 0x69 + }, + { + 0xAE, 0x5E, 0x7C, 0xCD, 0xD0, 0x34, 0x45, 0xE5, + 0x96, 0xF3, 0x80, 0xF2, 0x5C, 0x05, 0x8D, 0xE4, + 0x12, 0xA8, 0xE5, 0x00, 0x62, 0xF1, 0x45, 0x6C, + 0x2F, 0xA7, 0xC3, 0x72, 0xA9, 0x08, 0x4B, 0xE5, + 0x6B, 0x29, 0xBE, 0xD8, 0x91, 0x67, 0xCF, 0x8F, + 0xC1, 0xFB, 0xAA, 0x49, 0x38, 0xC1, 0xFB, 0x97, + 0xA9, 0x5C, 0x37, 0x7E, 0x77, 0xFA, 0xDB, 0xB7, + 0xCC, 0xCD, 0x21, 0xE3, 0xF1, 0x4C, 0xB5, 0x17 + }, + { + 0x87, 0x0D, 0x67, 0x94, 0x72, 0x69, 0x64, 0xE4, + 0x79, 0x05, 0xF0, 0xCB, 0xFA, 0x09, 0x8D, 0xA7, + 0x65, 0x4C, 0xF9, 0xAB, 0xB4, 0x06, 0x17, 0xF1, + 0x56, 0x69, 0x6F, 0x29, 0x1A, 0x83, 0xD3, 0x22, + 0x0B, 0xEA, 0x24, 0xBA, 0xEA, 0x41, 0x2B, 0x3C, + 0x73, 0x4D, 0xFA, 0xD2, 0x5D, 0x09, 0x9F, 0x52, + 0x12, 0x38, 0xF1, 0x4C, 0x9E, 0x36, 0xCE, 0x98, + 0x69, 0x62, 0x63, 0x44, 0xAD, 0xE4, 0x85, 0xA0 + }, + { + 0xCF, 0x42, 0xCD, 0x07, 0x75, 0xF0, 0xF8, 0xF9, + 0x91, 0x03, 0x3F, 0x3D, 0xE6, 0xCC, 0xD7, 0xE8, + 0x10, 0x97, 0x35, 0x82, 0x41, 0xF9, 0x58, 0x8E, + 0x51, 0xEB, 0xBB, 0x3C, 0xF1, 0x70, 0x80, 0x5A, + 0xD4, 0xC7, 0x7F, 0x53, 0x84, 0xCE, 0x5A, 0x12, + 0x5B, 0x00, 0xBB, 0xE3, 0xAA, 0xF4, 0x68, 0x7F, + 0xBE, 0x7E, 0x08, 0x9A, 0xC0, 0x63, 0xE1, 0x01, + 0x88, 0x9C, 0x46, 0xB3, 0x80, 0xAD, 0x6A, 0xDE + }, + { + 0x05, 0xE1, 0xC2, 0x05, 0x27, 0xA7, 0xD6, 0x5F, + 0x87, 0x67, 0x75, 0xC2, 0x45, 0x82, 0x39, 0xF4, + 0x3B, 0x39, 0x63, 0x9A, 0x62, 0x1A, 0x37, 0xF6, + 0x58, 0x27, 0x33, 0x64, 0x6A, 0x1E, 0x66, 0x50, + 0xDD, 0x2A, 0xBB, 0x8C, 0x0D, 0xEF, 0x55, 0x26, + 0x3F, 0x7F, 0x7F, 0xFA, 0x43, 0x71, 0x1E, 0x38, + 0x7A, 0xA8, 0xE9, 0xF3, 0x59, 0x50, 0x8D, 0xE0, + 0x6A, 0x8A, 0x55, 0x75, 0x94, 0xD7, 0xF1, 0xBD + }, + { + 0xF2, 0x06, 0x65, 0xE6, 0xAB, 0x30, 0xDA, 0x97, + 0x53, 0xA4, 0x17, 0x93, 0xD1, 0x88, 0xF0, 0xB2, + 0x83, 0xEB, 0x08, 0x24, 0x05, 0xAC, 0x3F, 0x9F, + 0x06, 0xEB, 0x4D, 0xE3, 0x2B, 0xBA, 0x0D, 0x33, + 0x61, 0x52, 0x40, 0x8B, 0x5A, 0xB5, 0x83, 0x45, + 0xAA, 0xE0, 0xC1, 0x55, 0xCC, 0x47, 0x4B, 0xB3, + 0x51, 0x5D, 0x6D, 0xE3, 0x4D, 0x5C, 0x3A, 0xD4, + 0x1C, 0x64, 0xCA, 0xA0, 0x34, 0x0F, 0x7D, 0xFF + }, + { + 0x4B, 0x37, 0x5C, 0x93, 0x46, 0x17, 0x95, 0xFC, + 0x16, 0x74, 0x69, 0xC4, 0xD5, 0xA1, 0x0B, 0xE5, + 0x5A, 0x26, 0x41, 0xD5, 0x14, 0xA3, 0xA3, 0x52, + 0xD0, 0xDA, 0xA9, 0x83, 0xC6, 0x54, 0xC5, 0x99, + 0x6D, 0xBC, 0xAD, 0xAC, 0xC3, 0x93, 0xEB, 0x0B, + 0x55, 0x1A, 0xF9, 0x8A, 0x74, 0x7C, 0x44, 0xD8, + 0x2D, 0xFD, 0xB5, 0x9F, 0xE7, 0x29, 0xEF, 0xB1, + 0x94, 0x8D, 0x36, 0x38, 0x0F, 0x9A, 0x28, 0xC1 + }, + { + 0x38, 0x92, 0x87, 0xF3, 0x99, 0x59, 0x1F, 0x02, + 0x11, 0xCC, 0x7B, 0x6C, 0xA5, 0x39, 0xB2, 0x7D, + 0x17, 0xA1, 0xB8, 0x58, 0x7A, 0xFF, 0xAE, 0x5B, + 0x17, 0x07, 0x59, 0x0E, 0x2E, 0xFB, 0x9C, 0x25, + 0x64, 0xCE, 0x7D, 0x27, 0x49, 0x71, 0xCA, 0xB2, + 0xB0, 0x86, 0xFE, 0x0E, 0xFD, 0x73, 0x84, 0x53, + 0x02, 0x0B, 0x0D, 0xF5, 0x2B, 0x72, 0xB0, 0xF7, + 0x5B, 0x34, 0x78, 0x72, 0x0F, 0xA1, 0x59, 0x09 + }, + { + 0x01, 0xF3, 0x85, 0xDA, 0x75, 0x20, 0x35, 0x4A, + 0x2B, 0x72, 0x4A, 0x81, 0x68, 0x4D, 0x49, 0x28, + 0xD7, 0xBE, 0xFB, 0xDE, 0xC2, 0x99, 0x1A, 0x10, + 0x89, 0xF9, 0x5B, 0x2E, 0x89, 0x8A, 0xEC, 0xE4, + 0x36, 0x1D, 0xF6, 0x61, 0xB9, 0xAC, 0x3B, 0xB0, + 0x7B, 0x2C, 0x0D, 0x31, 0x23, 0x8B, 0xE5, 0xF6, + 0x6E, 0x42, 0x7B, 0x39, 0xDC, 0xF4, 0x1E, 0x3B, + 0x29, 0xE7, 0x9D, 0xD5, 0x21, 0x3F, 0x4F, 0x11 + }, + { + 0x42, 0xE7, 0x12, 0x59, 0x30, 0x55, 0x3D, 0xBD, + 0x94, 0x49, 0x8A, 0x6F, 0x3E, 0x53, 0x7C, 0x74, + 0xA6, 0x8B, 0x97, 0x84, 0x3D, 0x9B, 0x81, 0xFD, + 0x17, 0x59, 0xEF, 0x39, 0x64, 0x65, 0xE7, 0x85, + 0x08, 0xBA, 0x9B, 0x48, 0x70, 0x86, 0xC1, 0x08, + 0xCF, 0xCF, 0x11, 0xF9, 0x12, 0x51, 0xEF, 0x06, + 0x4D, 0xEB, 0x10, 0xEA, 0xAE, 0xD0, 0x5D, 0x64, + 0x0E, 0x82, 0x16, 0x40, 0xDA, 0xD0, 0x08, 0xE0 + }, + { + 0x69, 0xE9, 0x0B, 0x35, 0x85, 0x7E, 0x11, 0x13, + 0xF7, 0x4C, 0x21, 0xE9, 0x15, 0xCE, 0xC6, 0xEF, + 0xFC, 0x30, 0x0C, 0xBF, 0x4C, 0xA3, 0x23, 0xD5, + 0x0E, 0x8D, 0x00, 0x87, 0xA3, 0x5B, 0x9D, 0x9A, + 0xBE, 0x4D, 0xDA, 0x26, 0x4D, 0x0D, 0x93, 0x91, + 0x30, 0x9B, 0x42, 0xD8, 0xC2, 0x2A, 0xD6, 0xC3, + 0xB6, 0xC5, 0xE8, 0x99, 0x09, 0xAB, 0xE4, 0xCA, + 0x29, 0x5C, 0x1B, 0xC8, 0xF5, 0xC9, 0x7D, 0xC7 + }, + { + 0x03, 0xAF, 0x23, 0x60, 0xD5, 0xFC, 0x42, 0x15, + 0xDD, 0x69, 0x40, 0x82, 0x74, 0x07, 0xF5, 0xFB, + 0x91, 0x69, 0x69, 0x9E, 0x4A, 0xC6, 0x2B, 0xF0, + 0x8E, 0xA6, 0x2C, 0xFE, 0xDC, 0xC4, 0xE4, 0xBA, + 0x3A, 0x38, 0x1E, 0x3B, 0x83, 0x54, 0xEB, 0x20, + 0xB0, 0xA0, 0x3C, 0x21, 0xC0, 0x52, 0x0F, 0x1D, + 0x75, 0xE3, 0xBB, 0x0F, 0x11, 0xB7, 0xBB, 0xE1, + 0x6E, 0xE1, 0x23, 0x42, 0x41, 0x31, 0x1A, 0x33 + }, + { + 0x19, 0x2A, 0xA4, 0x30, 0xC6, 0x98, 0x5A, 0x5F, + 0xE0, 0xE1, 0x62, 0x63, 0x3D, 0x17, 0x4F, 0x5E, + 0xB6, 0x75, 0x9C, 0x05, 0xC2, 0x9C, 0xD7, 0xEB, + 0xBB, 0x98, 0x60, 0xBF, 0x33, 0x85, 0x92, 0x81, + 0x87, 0x24, 0x98, 0x6C, 0x6A, 0xBF, 0x23, 0x90, + 0xF4, 0xF3, 0x1B, 0xCD, 0x00, 0x49, 0xCF, 0x24, + 0x29, 0x91, 0x7D, 0x6C, 0x0D, 0xED, 0xB4, 0x25, + 0x2A, 0xB0, 0x60, 0x02, 0xED, 0x41, 0xF3, 0xB4 + }, + { + 0xCC, 0xDF, 0xE4, 0x88, 0xD7, 0x01, 0xA8, 0x1F, + 0x89, 0x29, 0x06, 0xE5, 0x84, 0xE3, 0xF9, 0x42, + 0xE3, 0x7C, 0xC2, 0xF1, 0x33, 0x55, 0x8B, 0x36, + 0x49, 0xC8, 0xBF, 0xDB, 0x28, 0xF9, 0xC6, 0x6D, + 0x2C, 0xC2, 0x06, 0xF5, 0xDC, 0x0B, 0x96, 0x20, + 0xBF, 0x4A, 0x65, 0x82, 0xB7, 0x69, 0x4B, 0xCE, + 0xCB, 0x91, 0xAB, 0xAA, 0x78, 0xB7, 0xCE, 0x4B, + 0xB3, 0xF1, 0x96, 0x55, 0x22, 0x26, 0xD4, 0x01 + }, + { + 0x6B, 0x36, 0xDC, 0xFA, 0xB4, 0x9D, 0x07, 0x69, + 0xAA, 0xFC, 0xCB, 0xE1, 0x05, 0x36, 0xB4, 0x87, + 0x05, 0xDB, 0xD4, 0x6A, 0x23, 0x47, 0xE6, 0xBA, + 0xEA, 0x9A, 0xE7, 0x69, 0xD4, 0xC3, 0x2A, 0x38, + 0xEB, 0xCC, 0x64, 0xC5, 0x14, 0x7D, 0x6B, 0xB8, + 0xC7, 0x0A, 0x74, 0x22, 0x5C, 0x32, 0x1B, 0x46, + 0xC4, 0x39, 0x3E, 0x3F, 0x38, 0xB5, 0xD4, 0x7A, + 0x6E, 0xD6, 0x87, 0x91, 0xA6, 0x04, 0xEE, 0xB7 + }, + { + 0xF6, 0x30, 0x75, 0xF1, 0xB8, 0xC8, 0xB3, 0x7C, + 0x1B, 0x66, 0x9F, 0x39, 0x76, 0x74, 0x7E, 0x0F, + 0x20, 0xB5, 0x98, 0x4E, 0x75, 0x25, 0x4B, 0x26, + 0x55, 0x9E, 0xDC, 0x45, 0x5D, 0x6C, 0xC4, 0x4E, + 0x8C, 0xDD, 0x35, 0x45, 0x3B, 0x5F, 0x49, 0x3C, + 0x1E, 0x69, 0x03, 0xD3, 0x0E, 0xD9, 0xAA, 0xF1, + 0x9C, 0x83, 0xF3, 0x09, 0x93, 0x64, 0x54, 0x74, + 0x41, 0x3A, 0x16, 0x8A, 0x8C, 0x33, 0x64, 0x1E + }, + { + 0xBC, 0x24, 0xFA, 0xFE, 0x67, 0xD4, 0xB9, 0xEF, + 0x79, 0x6C, 0xDF, 0x35, 0xEF, 0x4D, 0xB3, 0xCE, + 0xBE, 0x52, 0x2B, 0xFF, 0x2E, 0x77, 0x68, 0x09, + 0x67, 0x51, 0xF9, 0x06, 0x78, 0xA5, 0x16, 0x8F, + 0xC2, 0x85, 0x6C, 0x61, 0x24, 0xBE, 0x84, 0x8C, + 0x00, 0x04, 0x62, 0x57, 0x9F, 0x90, 0xDF, 0x1A, + 0xC4, 0x1F, 0x06, 0x0E, 0x65, 0x5C, 0x74, 0x98, + 0xB8, 0x80, 0x51, 0x79, 0x29, 0xC3, 0x4A, 0x51 + }, + { + 0xEF, 0xB9, 0xAB, 0xEA, 0x99, 0x89, 0xAB, 0xD7, + 0x49, 0x06, 0x8E, 0x50, 0x28, 0xDC, 0x96, 0x78, + 0x82, 0xE9, 0xCC, 0x34, 0x82, 0x24, 0x16, 0x4C, + 0xDA, 0xC8, 0x6A, 0x68, 0x5D, 0x05, 0x33, 0x00, + 0x9D, 0x22, 0x73, 0x7D, 0xD8, 0xC6, 0xA4, 0x52, + 0x64, 0x9A, 0xB9, 0x37, 0xF6, 0x59, 0xE7, 0x06, + 0x37, 0x7E, 0xEA, 0xAB, 0x67, 0xE0, 0x91, 0x7B, + 0x70, 0x30, 0x62, 0x95, 0x9C, 0xAB, 0x75, 0x6B + }, + { + 0xDC, 0xA1, 0x92, 0x2D, 0xB8, 0xDA, 0xD7, 0xA0, + 0xD5, 0x26, 0x8F, 0xD5, 0x4B, 0xE4, 0x14, 0x7F, + 0xA9, 0x51, 0x68, 0x30, 0xF1, 0xD9, 0xCF, 0x65, + 0x5D, 0x35, 0xA4, 0xAE, 0xEC, 0x16, 0xB6, 0x3C, + 0xFE, 0xFA, 0x0D, 0x45, 0xBF, 0x4D, 0x7E, 0x5F, + 0x97, 0xA9, 0xA2, 0x78, 0x1A, 0x98, 0xE3, 0x7B, + 0xAD, 0xC4, 0xAA, 0xBE, 0x51, 0xC8, 0x6B, 0x82, + 0x3E, 0x54, 0x50, 0x6A, 0xDF, 0xF0, 0xE2, 0x9A + }, + { + 0xE1, 0x23, 0x70, 0x48, 0x0B, 0x44, 0x51, 0x84, + 0x07, 0xB5, 0xCE, 0x40, 0xE4, 0xCE, 0xFD, 0x3C, + 0xB2, 0x65, 0x60, 0xEC, 0xA7, 0xE0, 0x48, 0x72, + 0xF6, 0x0B, 0xB0, 0xB3, 0x01, 0x19, 0x45, 0xD4, + 0x74, 0x6D, 0x56, 0x84, 0x18, 0x39, 0x05, 0x16, + 0x9F, 0x7A, 0xDD, 0xA2, 0x4A, 0x63, 0x50, 0x63, + 0x96, 0x37, 0xEB, 0x5F, 0x94, 0x93, 0xF6, 0xF6, + 0xEC, 0x87, 0xBF, 0x32, 0x6C, 0x53, 0x56, 0xE6 + }, + { + 0x32, 0x22, 0x3D, 0x3D, 0xD5, 0xDF, 0x0D, 0x70, + 0xEF, 0x89, 0xF9, 0x69, 0xA0, 0x55, 0xE7, 0xFE, + 0xE0, 0xB7, 0x53, 0x63, 0xCA, 0x07, 0x71, 0x3B, + 0x06, 0xD4, 0x31, 0xC3, 0x00, 0xD9, 0x36, 0x47, + 0x3D, 0x67, 0xEA, 0x0D, 0xF5, 0x85, 0x9E, 0x58, + 0xA3, 0x40, 0x71, 0x8B, 0xE6, 0x4D, 0x8B, 0xDB, + 0x14, 0x76, 0xE4, 0x4D, 0x72, 0x3B, 0x28, 0xB0, + 0xAE, 0xC5, 0xEF, 0x8B, 0x00, 0xB9, 0x5F, 0x6E + }, + { + 0xB9, 0x81, 0xFC, 0x9A, 0xE5, 0x1A, 0x11, 0xBE, + 0x6B, 0xE0, 0xA4, 0x50, 0x04, 0x84, 0xD2, 0xDD, + 0x56, 0x52, 0x10, 0x40, 0x1D, 0xE4, 0xE2, 0x84, + 0x81, 0x07, 0x17, 0xF1, 0x41, 0x86, 0x0B, 0x5C, + 0x56, 0x39, 0x95, 0x31, 0xA9, 0x40, 0xAF, 0x62, + 0xFF, 0x06, 0x5F, 0x80, 0x44, 0xCA, 0x63, 0xAD, + 0xE6, 0xF7, 0x19, 0xCD, 0xF0, 0x23, 0x27, 0x02, + 0x22, 0x93, 0x1D, 0x8A, 0xAF, 0xCC, 0x03, 0x11 + }, + { + 0xD9, 0xF9, 0x39, 0x56, 0x25, 0xD0, 0x79, 0x90, + 0xB7, 0x1E, 0x78, 0x94, 0xAE, 0x8F, 0xEA, 0x70, + 0xA9, 0x28, 0x71, 0xB6, 0x7E, 0x9E, 0xA4, 0x7B, + 0x4A, 0xB8, 0x8A, 0x2E, 0xAE, 0xBA, 0x70, 0x2F, + 0x89, 0xAD, 0xA0, 0x57, 0x63, 0x63, 0xEA, 0xD0, + 0x66, 0x91, 0x5F, 0x9E, 0xBA, 0x0D, 0x91, 0xC4, + 0xAB, 0x09, 0xD7, 0x29, 0xF5, 0x68, 0xFA, 0xB8, + 0x9C, 0x39, 0x44, 0x18, 0x7F, 0x3C, 0xF4, 0x1A + }, + { + 0x9C, 0x41, 0x59, 0x99, 0x81, 0xC9, 0x2C, 0xC9, + 0x62, 0x17, 0x5D, 0x0B, 0xCE, 0x99, 0x25, 0xFF, + 0x65, 0x57, 0x0B, 0x41, 0x08, 0xB8, 0x20, 0x95, + 0xC9, 0x99, 0xD1, 0xEE, 0x0F, 0x7E, 0x6C, 0xB7, + 0x7F, 0xF4, 0xB7, 0x69, 0x1E, 0x71, 0xB1, 0x04, + 0xAB, 0xE4, 0x33, 0xB9, 0x20, 0x1C, 0xE3, 0xA7, + 0x49, 0x5C, 0x03, 0x40, 0x2C, 0x65, 0xAC, 0x20, + 0x13, 0xF7, 0x35, 0xAE, 0x08, 0xB1, 0x42, 0xBC + }, + { + 0x43, 0xB5, 0x9F, 0xB0, 0x1E, 0xC2, 0x7A, 0x13, + 0x3E, 0x87, 0x36, 0x4E, 0xDA, 0xE6, 0x27, 0x9D, + 0x78, 0x40, 0x93, 0xFA, 0x33, 0x45, 0xC0, 0x90, + 0x10, 0x50, 0x20, 0x05, 0x45, 0x27, 0x27, 0x02, + 0xC2, 0xA1, 0x5C, 0xB9, 0xA0, 0xED, 0x98, 0x79, + 0x40, 0x24, 0x8D, 0x2F, 0x85, 0x24, 0x69, 0xD1, + 0xF0, 0xD1, 0x18, 0x97, 0x10, 0x59, 0x2A, 0x9B, + 0xFB, 0xE8, 0x16, 0x65, 0x15, 0x18, 0xDE, 0xE6 + }, + { + 0x56, 0xD3, 0x7F, 0x59, 0x62, 0xF5, 0xBE, 0xCF, + 0x66, 0x66, 0x09, 0x16, 0xD4, 0xCA, 0x63, 0xEE, + 0x07, 0xB0, 0x06, 0x1D, 0x98, 0x23, 0x23, 0x92, + 0xBC, 0xFD, 0xD6, 0x4E, 0xFF, 0x74, 0x23, 0x2C, + 0xA0, 0xF4, 0x4B, 0x87, 0x8E, 0x6D, 0xFC, 0xBE, + 0xC7, 0x32, 0x32, 0x76, 0x4B, 0x37, 0xD4, 0xB6, + 0x67, 0xB7, 0x44, 0x0A, 0x10, 0x7E, 0xA6, 0x58, + 0x4D, 0x50, 0x5C, 0x58, 0x55, 0xA9, 0xAB, 0xFD + }, + { + 0xC8, 0xAD, 0x73, 0xD2, 0xDB, 0x17, 0xFE, 0x7D, + 0x13, 0x87, 0x39, 0x60, 0x8E, 0xBB, 0x8E, 0xC1, + 0x1D, 0x37, 0xC4, 0xC1, 0x21, 0xA5, 0xDB, 0x74, + 0x2A, 0x00, 0x0D, 0x97, 0xBF, 0xFA, 0xCD, 0xD5, + 0x46, 0x04, 0x23, 0x92, 0x81, 0x2A, 0xE7, 0xC7, + 0x7A, 0x85, 0x3C, 0xCE, 0x5D, 0x84, 0xC6, 0x4B, + 0x84, 0x30, 0x91, 0x26, 0x7F, 0xB1, 0x99, 0xA7, + 0x39, 0xCA, 0xE1, 0x1A, 0x39, 0x93, 0x35, 0x42 + }, + { + 0x45, 0x0D, 0x53, 0x94, 0x30, 0x3F, 0xE8, 0x90, + 0xA8, 0x81, 0x88, 0x48, 0xE5, 0x53, 0xFD, 0x81, + 0x75, 0xED, 0x45, 0xA9, 0xAE, 0x0C, 0x0D, 0x8C, + 0x05, 0x4A, 0x7F, 0xC9, 0xBE, 0x59, 0x21, 0xFD, + 0x49, 0x74, 0x61, 0xC1, 0x72, 0xD3, 0x9C, 0x18, + 0x8F, 0x8A, 0xE3, 0x70, 0x14, 0xAB, 0x00, 0xCF, + 0x78, 0xA5, 0x53, 0x7F, 0xD1, 0x75, 0x72, 0x76, + 0xA5, 0xA1, 0x58, 0x12, 0x6D, 0xCC, 0x99, 0xCB + }, + { + 0x40, 0xF9, 0x65, 0x93, 0x99, 0x34, 0xE8, 0xAB, + 0xBB, 0x0E, 0x79, 0x04, 0xA9, 0x6C, 0x58, 0xF6, + 0xBE, 0x63, 0xDF, 0x67, 0xE6, 0x70, 0xA9, 0x8E, + 0xD0, 0x05, 0xC0, 0xF4, 0x17, 0x23, 0x53, 0x54, + 0xD3, 0xF9, 0x5F, 0x57, 0xBA, 0xAE, 0x7A, 0xCD, + 0x7A, 0xE9, 0x66, 0xD4, 0x35, 0x6D, 0x34, 0x00, + 0xAD, 0xF4, 0x58, 0xE1, 0x4C, 0x8E, 0xEF, 0xED, + 0xB7, 0x2C, 0xDC, 0xC1, 0x1E, 0x65, 0xE1, 0xF4 + }, + { + 0x6D, 0x11, 0x56, 0x2E, 0x72, 0x66, 0xB4, 0x02, + 0xD2, 0xFA, 0xCF, 0x3F, 0xCB, 0x9E, 0x6D, 0x74, + 0xB7, 0x4C, 0xC9, 0x21, 0x7C, 0x4C, 0x2A, 0xF3, + 0xBF, 0x51, 0xD5, 0x98, 0xE5, 0xAE, 0x1B, 0x62, + 0x20, 0x45, 0x4D, 0xF0, 0x36, 0xC2, 0xB3, 0xF3, + 0x2F, 0xA5, 0x2D, 0x74, 0x48, 0xFC, 0xBC, 0xD7, + 0x43, 0xE6, 0x6C, 0xAA, 0x87, 0xFB, 0xAA, 0x02, + 0xE0, 0x2B, 0x0E, 0x32, 0x07, 0xDF, 0x54, 0xA9 + }, + { + 0xDE, 0xED, 0xCD, 0x45, 0x0E, 0xEE, 0xC6, 0x5F, + 0x94, 0x40, 0xDA, 0x3A, 0x0F, 0x82, 0x70, 0x11, + 0x48, 0x70, 0x2C, 0x9C, 0x58, 0x53, 0x7F, 0xD5, + 0xF1, 0xBB, 0x7B, 0xE8, 0xE2, 0x83, 0x2D, 0xCE, + 0x2F, 0x2E, 0xD9, 0xB7, 0x86, 0x32, 0x55, 0x3B, + 0x8D, 0xD1, 0xA0, 0x0B, 0xCE, 0x91, 0x27, 0x6A, + 0x80, 0x17, 0x54, 0xBC, 0xD6, 0x56, 0x89, 0x96, + 0xD1, 0x4D, 0x7E, 0x7D, 0x1C, 0x95, 0x4B, 0x26 + }, + { + 0x50, 0xD3, 0xA3, 0x68, 0xA0, 0x23, 0xB8, 0x09, + 0x9A, 0x1A, 0x68, 0xA1, 0x9C, 0x55, 0x83, 0x20, + 0x2A, 0x6C, 0x14, 0xD6, 0x89, 0x32, 0x77, 0x93, + 0x3F, 0xA6, 0x14, 0x0B, 0xBA, 0xA5, 0xE8, 0x07, + 0xF6, 0x17, 0xE6, 0x3B, 0x60, 0x23, 0x7B, 0x25, + 0x6C, 0xB5, 0x9D, 0x69, 0x7B, 0x26, 0xB8, 0xCA, + 0x4C, 0x7E, 0xA0, 0xC0, 0x4A, 0xEA, 0xD2, 0x22, + 0x39, 0x79, 0x16, 0xA3, 0x56, 0xB0, 0x84, 0x0B + }, + { + 0x67, 0x70, 0x99, 0xE1, 0x5A, 0x77, 0x69, 0xA7, + 0xD6, 0x42, 0x16, 0x66, 0x2B, 0xA7, 0x13, 0x5D, + 0x09, 0x70, 0x4A, 0x34, 0x0D, 0x06, 0x17, 0x68, + 0x6B, 0x11, 0xD5, 0x5D, 0x7B, 0x2D, 0xB2, 0x56, + 0xA6, 0xEE, 0x95, 0x4A, 0x75, 0xF2, 0x11, 0xCF, + 0xF7, 0xAD, 0x72, 0x70, 0xB0, 0x1E, 0xA1, 0x28, + 0x35, 0xE0, 0xF5, 0x26, 0xF7, 0x6A, 0xE0, 0x1B, + 0xC5, 0x9D, 0x19, 0x3B, 0xA7, 0x72, 0x8C, 0x19 + }, + { + 0xA7, 0xB7, 0x70, 0xF3, 0x8F, 0xF8, 0xA9, 0xFA, + 0x09, 0x8D, 0x8F, 0xA8, 0x31, 0x45, 0x0C, 0x90, + 0x23, 0x62, 0x0D, 0x46, 0x1A, 0x48, 0xAF, 0xDA, + 0x43, 0xED, 0x1A, 0x09, 0x49, 0xD5, 0x0F, 0x9F, + 0xE7, 0x39, 0x8E, 0x83, 0x02, 0x7A, 0x6C, 0x3B, + 0xD4, 0xE3, 0xC9, 0xF4, 0xA7, 0x01, 0x9F, 0xA5, + 0x67, 0xFF, 0x6D, 0xB5, 0x2E, 0xDC, 0x2F, 0xDE, + 0x72, 0xCD, 0x5A, 0xC5, 0x2E, 0x8B, 0x06, 0x42 + }, + { + 0x1A, 0x50, 0x17, 0x46, 0xD5, 0xB6, 0x97, 0x8B, + 0x10, 0x3F, 0xE9, 0xD1, 0x38, 0x66, 0x83, 0xD0, + 0xB3, 0x83, 0x24, 0x95, 0x2D, 0x64, 0xD7, 0x69, + 0x48, 0x4E, 0x91, 0x26, 0x85, 0xC5, 0xFA, 0x38, + 0x29, 0x88, 0xD5, 0x9C, 0xF9, 0xD1, 0x0F, 0x24, + 0x2F, 0xC0, 0xE6, 0xBF, 0xDE, 0x0B, 0x75, 0xE5, + 0xE0, 0x75, 0xC5, 0x2E, 0xB8, 0x11, 0x64, 0x93, + 0x42, 0x89, 0x6A, 0xE0, 0xAE, 0xB2, 0x32, 0x1F + }, + { + 0x26, 0x7F, 0x6E, 0x1C, 0x0C, 0xE6, 0xD3, 0xC7, + 0x50, 0x19, 0x2D, 0xF3, 0xB7, 0x10, 0xCD, 0x06, + 0xFC, 0x66, 0x0D, 0xCC, 0x22, 0x03, 0x0A, 0x55, + 0x37, 0x56, 0xA8, 0xF1, 0x39, 0x95, 0xFA, 0xC0, + 0x7B, 0x42, 0xB7, 0xC3, 0xCB, 0x43, 0xF8, 0xDE, + 0xFA, 0x9C, 0x5F, 0x38, 0xDA, 0x58, 0x4A, 0xE5, + 0x27, 0x18, 0xF2, 0xF2, 0x3C, 0x07, 0xA0, 0xA9, + 0x0A, 0x14, 0x25, 0x3D, 0xE6, 0xF9, 0x62, 0xCC + }, + { + 0x4C, 0xE2, 0xD3, 0xB3, 0x8D, 0xB5, 0x54, 0xA7, + 0x2C, 0x03, 0x4A, 0xDC, 0x0C, 0x10, 0x08, 0x26, + 0x87, 0xAB, 0x40, 0xC2, 0xDC, 0x31, 0x66, 0x49, + 0x6A, 0xDC, 0x05, 0x47, 0xC0, 0x54, 0xCF, 0x56, + 0xB5, 0xC6, 0x62, 0x82, 0xB7, 0xDD, 0x35, 0xAB, + 0x58, 0x7A, 0x24, 0x6C, 0xC7, 0x6D, 0xE5, 0xE1, + 0x4F, 0x23, 0x45, 0xD3, 0x9D, 0x5D, 0x80, 0x7F, + 0x34, 0x00, 0x93, 0x04, 0x11, 0x09, 0xB4, 0x25 + }, + { + 0xDB, 0x75, 0xBA, 0x6E, 0x9D, 0x9B, 0x37, 0xAF, + 0xC3, 0x7A, 0xE3, 0x3A, 0xBD, 0x5A, 0xD7, 0x6D, + 0x37, 0x9B, 0xAA, 0x5F, 0xA1, 0x4E, 0xB5, 0x85, + 0x39, 0xAA, 0x68, 0x47, 0x26, 0x5C, 0x89, 0xEA, + 0x20, 0xEB, 0xD1, 0x1D, 0xF8, 0x79, 0x6F, 0x14, + 0x35, 0x12, 0xC2, 0x03, 0x24, 0x7B, 0x5E, 0x05, + 0xF0, 0x1F, 0xE4, 0x27, 0x63, 0xC6, 0x2D, 0x5A, + 0xBD, 0xFB, 0xB8, 0xAF, 0x4E, 0x67, 0x36, 0x50 + }, + { + 0xCB, 0x06, 0xE9, 0x99, 0x31, 0xB5, 0x09, 0x81, + 0xA7, 0x1F, 0x32, 0x30, 0x28, 0xD4, 0xC5, 0xE4, + 0x3A, 0xD4, 0x2D, 0x2F, 0x95, 0x3A, 0x48, 0xDB, + 0xDA, 0xCC, 0xD5, 0xE3, 0x07, 0xEA, 0xB0, 0x4C, + 0x26, 0x12, 0xFB, 0x0D, 0xED, 0x97, 0x03, 0xFC, + 0x6E, 0xD3, 0x48, 0x97, 0xB2, 0xE6, 0x62, 0xE1, + 0x18, 0xA8, 0x78, 0xBE, 0x5E, 0x65, 0x9F, 0x57, + 0x6B, 0x6C, 0xEA, 0xFF, 0x81, 0x54, 0x43, 0x2A + }, + { + 0xC2, 0x7E, 0x34, 0x20, 0xC3, 0x81, 0x90, 0x1A, + 0x9E, 0x3A, 0x71, 0x57, 0x89, 0x72, 0x3C, 0x8E, + 0x12, 0x49, 0xD4, 0x22, 0x36, 0x0F, 0x9E, 0x3E, + 0x6D, 0x60, 0x9C, 0xB6, 0xE3, 0x9C, 0x24, 0xC8, + 0x3D, 0x1D, 0x8C, 0x4F, 0xA1, 0x9E, 0xB9, 0xB6, + 0x9D, 0x53, 0x35, 0x95, 0x6B, 0xB8, 0x5F, 0x60, + 0xE7, 0x8E, 0xED, 0x24, 0xD2, 0x61, 0x77, 0xEE, + 0xBC, 0xDC, 0x79, 0x8E, 0x6E, 0x22, 0x58, 0xC9 + }, + { + 0x39, 0xA0, 0xE8, 0x48, 0x54, 0x26, 0x81, 0x5B, + 0xF4, 0xA6, 0x74, 0xE5, 0xB8, 0x16, 0xC3, 0x97, + 0xE4, 0x63, 0xD4, 0x3D, 0x64, 0xA1, 0x60, 0x15, + 0xA3, 0x54, 0x5E, 0x42, 0x78, 0xB0, 0xDD, 0x94, + 0xF0, 0xF8, 0x35, 0xDD, 0x6C, 0x93, 0x21, 0xB3, + 0x5B, 0xC7, 0xF5, 0xD1, 0x2F, 0x3C, 0x98, 0x0E, + 0xBF, 0x66, 0x00, 0x48, 0xA4, 0x0E, 0x01, 0xB7, + 0x27, 0xCD, 0x7B, 0xE9, 0xC0, 0x52, 0xB4, 0x72 + }, + { + 0x5C, 0x53, 0x54, 0xED, 0x80, 0x23, 0x00, 0xEB, + 0x30, 0x59, 0x11, 0x24, 0xB7, 0xF3, 0x29, 0x9A, + 0xA0, 0xE0, 0x6D, 0x1A, 0x9C, 0x03, 0x25, 0xB4, + 0xF8, 0x36, 0xEB, 0x45, 0x97, 0x1B, 0x1D, 0xB0, + 0x36, 0xD4, 0x2B, 0x15, 0x70, 0x36, 0xC2, 0xBF, + 0x69, 0xB9, 0x37, 0x01, 0x92, 0x61, 0xFB, 0xEA, + 0x21, 0x7F, 0x03, 0x45, 0x3E, 0x4D, 0x1F, 0xCD, + 0xF1, 0x44, 0xC9, 0xB1, 0xC7, 0x48, 0xB4, 0xD5 + }, + { + 0xC2, 0xFB, 0x3B, 0xE6, 0x49, 0x44, 0xC2, 0x05, + 0x49, 0xFB, 0x0E, 0xB8, 0xBA, 0x54, 0xB8, 0x7E, + 0x59, 0x70, 0x59, 0xD1, 0xCE, 0x90, 0xAD, 0xF7, + 0x64, 0x91, 0xED, 0x94, 0xAF, 0x7C, 0x98, 0xE1, + 0x7B, 0x63, 0x19, 0xBA, 0xC2, 0x5B, 0xEB, 0xAE, + 0x10, 0x0D, 0xBF, 0x4A, 0x67, 0x6C, 0x52, 0x95, + 0xCF, 0x3A, 0x62, 0xB3, 0xF7, 0x5C, 0x66, 0xDC, + 0x24, 0xA7, 0x7C, 0x5B, 0xA3, 0xF3, 0xE3, 0x41 + }, + { + 0xAB, 0xC7, 0x4D, 0x63, 0x45, 0xD0, 0x9D, 0xCE, + 0xD4, 0xAD, 0x1F, 0x9B, 0xE0, 0x9A, 0x80, 0x0F, + 0x62, 0xD5, 0x93, 0xE0, 0x5B, 0x2B, 0x1C, 0x40, + 0x1B, 0xE8, 0xA3, 0x3F, 0xC0, 0xB0, 0x06, 0x3F, + 0xCD, 0xF9, 0x09, 0xD1, 0x87, 0xE7, 0xDA, 0x36, + 0x3C, 0xBE, 0x9B, 0xD4, 0xFA, 0x55, 0xD4, 0xCD, + 0x12, 0xA9, 0x93, 0x58, 0xCF, 0xF5, 0x7C, 0xB0, + 0x47, 0x63, 0xDD, 0x8A, 0x7C, 0x19, 0x86, 0xD9 + }, + { + 0x59, 0x69, 0x07, 0x7E, 0x85, 0x43, 0x91, 0x7D, + 0xB8, 0xA7, 0xE8, 0xEF, 0x16, 0xE9, 0x1E, 0xD0, + 0xCC, 0x84, 0xEF, 0xAA, 0x3C, 0x25, 0xA7, 0xAA, + 0x22, 0x23, 0xB9, 0x6D, 0x73, 0x99, 0xB2, 0x97, + 0x4E, 0xD0, 0x98, 0xBA, 0x0A, 0xC7, 0x52, 0xB6, + 0xE4, 0xB0, 0x9A, 0x17, 0xC4, 0xD4, 0xA2, 0x01, + 0xE0, 0x6F, 0xE9, 0xC8, 0x8F, 0xAF, 0x37, 0xEB, + 0x2F, 0x39, 0xE5, 0x4A, 0x25, 0x60, 0x8A, 0xDD + }, + { + 0xCF, 0xFE, 0x9B, 0x5B, 0x4E, 0xB4, 0x9D, 0xE0, + 0x93, 0xB5, 0x67, 0x70, 0x77, 0x8C, 0x97, 0xDA, + 0x4A, 0x08, 0x8C, 0x47, 0x8D, 0xAB, 0xED, 0x71, + 0x70, 0x51, 0x68, 0x20, 0xBF, 0x28, 0x13, 0xAA, + 0xCA, 0x02, 0x68, 0xB0, 0x67, 0x1E, 0x1D, 0x9C, + 0xED, 0xC3, 0x77, 0x18, 0x8B, 0x92, 0x59, 0x33, + 0xC3, 0xCA, 0x59, 0xC9, 0xD3, 0xE6, 0xCF, 0xCB, + 0x71, 0x9D, 0x0A, 0x10, 0x43, 0xCE, 0x0C, 0x3D + }, + { + 0x60, 0xC2, 0xBC, 0x18, 0x31, 0x4E, 0x14, 0x24, + 0xFA, 0xBC, 0xC2, 0x49, 0x56, 0x49, 0xAD, 0xA0, + 0x79, 0x6D, 0x07, 0xDF, 0x6C, 0x8C, 0x1F, 0x02, + 0xF6, 0xCB, 0x9E, 0x39, 0x99, 0x76, 0x99, 0x69, + 0xF0, 0x4E, 0xF5, 0x2B, 0xDB, 0xB5, 0x44, 0x6E, + 0x3A, 0xD2, 0x07, 0xAF, 0x93, 0xC5, 0x39, 0xC8, + 0x19, 0x06, 0x3B, 0x2C, 0x90, 0x35, 0x0C, 0x8B, + 0x30, 0xC6, 0x23, 0x9A, 0x6A, 0xE1, 0xF0, 0xD2 + }, + { + 0xB0, 0x0A, 0x22, 0x45, 0x52, 0xB2, 0x86, 0xD7, + 0xD7, 0x50, 0xAD, 0xCB, 0x50, 0x75, 0x8C, 0x6B, + 0xF6, 0xE3, 0x18, 0x85, 0xC9, 0x2C, 0x16, 0x2A, + 0xFE, 0x62, 0x70, 0xC4, 0x62, 0xEF, 0x2C, 0x0C, + 0x2E, 0x32, 0x26, 0x96, 0x2F, 0x83, 0xB3, 0x3B, + 0xD4, 0x76, 0xFF, 0x55, 0xC2, 0x2E, 0x47, 0x85, + 0x26, 0x8D, 0x90, 0x80, 0x83, 0xFD, 0xA5, 0x58, + 0x26, 0x27, 0x60, 0x30, 0x9C, 0x2C, 0xC3, 0xAB + }, + { + 0xD8, 0xE5, 0x93, 0x22, 0x3C, 0x8E, 0x29, 0x5E, + 0xA7, 0xCE, 0x67, 0x43, 0x70, 0x69, 0xC3, 0x12, + 0x16, 0xC0, 0x75, 0x60, 0xC7, 0xBC, 0xCB, 0x7C, + 0xE7, 0x51, 0x11, 0x4C, 0x96, 0x50, 0xA1, 0x1C, + 0x0F, 0x76, 0x20, 0xCE, 0x2A, 0x4D, 0xD0, 0x34, + 0x14, 0x2D, 0x5C, 0x26, 0xCD, 0x4C, 0x2F, 0xE6, + 0x3E, 0x7D, 0x7E, 0x0F, 0x0D, 0x95, 0x2C, 0x8E, + 0x4C, 0x43, 0x56, 0x62, 0x2E, 0xA2, 0xA1, 0xB9 + }, + { + 0xEA, 0x9A, 0xC3, 0xD6, 0x81, 0x01, 0xD9, 0xFE, + 0x66, 0x27, 0x21, 0x42, 0xFC, 0x04, 0x1E, 0xDC, + 0xF0, 0xBF, 0xE0, 0xE3, 0xD6, 0xA7, 0x4A, 0xD4, + 0xAA, 0x4E, 0x03, 0x59, 0xC7, 0x37, 0x8D, 0x35, + 0xFF, 0x45, 0x08, 0x7B, 0xA0, 0xCD, 0xC5, 0x82, + 0xE1, 0xCA, 0xF0, 0x38, 0x23, 0xF4, 0x6A, 0x50, + 0x99, 0x5C, 0x9E, 0x6A, 0x2A, 0xAA, 0xA0, 0xE8, + 0x85, 0xB5, 0x57, 0xAD, 0x22, 0x65, 0x73, 0xE4 + }, + { + 0xC9, 0xBB, 0x49, 0x42, 0xB8, 0x7F, 0x22, 0xD9, + 0xB0, 0x49, 0xC9, 0x11, 0xE3, 0xB8, 0xA4, 0x99, + 0xC9, 0xE9, 0xC1, 0xA3, 0x9C, 0xE3, 0x7E, 0xD5, + 0xD0, 0xA3, 0x47, 0xDB, 0x7C, 0x1D, 0x3B, 0xC1, + 0xB7, 0x0D, 0x28, 0xAF, 0x05, 0x5F, 0xA1, 0xBA, + 0xAB, 0x9A, 0x95, 0x53, 0x43, 0x26, 0x13, 0x9C, + 0xCD, 0xAA, 0xD3, 0x5B, 0x2E, 0x23, 0xAD, 0x4A, + 0xEA, 0xB4, 0xF6, 0xF0, 0x9F, 0x33, 0x39, 0x50 + }, + { + 0xE4, 0x4B, 0xB7, 0x02, 0x3A, 0x3C, 0x9B, 0x32, + 0xBC, 0x56, 0x8F, 0xD0, 0x7F, 0x26, 0xA8, 0x4D, + 0x19, 0xA2, 0xBB, 0x21, 0x7C, 0x4F, 0x1E, 0x55, + 0x29, 0x7D, 0x17, 0x3A, 0x66, 0xF0, 0x08, 0x58, + 0xCF, 0x7A, 0xCD, 0x32, 0xAB, 0x55, 0x87, 0x5D, + 0xFA, 0x6E, 0xFD, 0x49, 0xD3, 0x1D, 0x7A, 0xA7, + 0xB8, 0xE7, 0xF5, 0xCD, 0x81, 0xD5, 0xEF, 0x38, + 0x82, 0x26, 0x78, 0x33, 0xD6, 0x32, 0xD5, 0x25 + }, + { + 0x40, 0x5E, 0x11, 0xAA, 0x6F, 0xA6, 0xE3, 0xDC, + 0x27, 0xDF, 0xC2, 0x89, 0xF1, 0x5A, 0x93, 0x64, + 0x5B, 0x62, 0xD8, 0x12, 0x91, 0xB9, 0xDF, 0xC1, + 0xA3, 0xD3, 0x90, 0x5C, 0x97, 0x8D, 0x6D, 0x1C, + 0x49, 0x38, 0x48, 0xF2, 0x6D, 0x95, 0x52, 0xA9, + 0xBB, 0x94, 0xDB, 0x76, 0xC5, 0xA3, 0xD2, 0x55, + 0xE6, 0xB7, 0xB7, 0x40, 0x9C, 0x9C, 0x5C, 0xD3, + 0xE9, 0xBA, 0x9B, 0x34, 0x80, 0xB4, 0x14, 0x65 + }, + { + 0x02, 0xFA, 0x70, 0x00, 0x7C, 0x60, 0x1C, 0x31, + 0x93, 0x44, 0x23, 0x10, 0x08, 0x99, 0x61, 0xC5, + 0x60, 0xB8, 0xA8, 0x88, 0xDB, 0x52, 0x6F, 0x8A, + 0x7B, 0xF6, 0xA4, 0xC5, 0x34, 0x9B, 0xC2, 0x7F, + 0x85, 0x6C, 0xD8, 0x61, 0x18, 0x15, 0x74, 0x5B, + 0xE8, 0x53, 0xD7, 0xC3, 0x84, 0xC3, 0x89, 0xE7, + 0x6A, 0x4E, 0x59, 0xB5, 0xD5, 0xD2, 0x7B, 0x06, + 0xBA, 0x7A, 0xEE, 0x44, 0x1E, 0x0E, 0x8C, 0xE2 + }, + { + 0xC6, 0x7F, 0x9F, 0x8A, 0xA7, 0x58, 0x22, 0x56, + 0x9E, 0x69, 0x9A, 0x36, 0x7D, 0x92, 0xC3, 0x4B, + 0x1F, 0xD0, 0x72, 0x5D, 0x80, 0xF7, 0xEC, 0xDA, + 0x28, 0x78, 0x06, 0x54, 0xDB, 0xE5, 0xB2, 0x5F, + 0x2D, 0xB7, 0xA6, 0x7A, 0x3C, 0x0F, 0x86, 0x8E, + 0xA9, 0x2C, 0x9A, 0x73, 0x35, 0x25, 0xBB, 0xA4, + 0xDD, 0xDD, 0x3C, 0xF5, 0x20, 0x1D, 0xD1, 0x24, + 0xC3, 0x6B, 0xF9, 0x72, 0xE8, 0xE4, 0x0F, 0xEB + }, + { + 0xB5, 0x6E, 0x76, 0xDC, 0x03, 0xCF, 0xAA, 0x30, + 0xAF, 0x88, 0xB4, 0x2B, 0xB2, 0xD5, 0xC3, 0xDF, + 0x4D, 0x33, 0x58, 0x46, 0x4C, 0x97, 0x4E, 0x38, + 0x21, 0xB9, 0x15, 0x7A, 0x98, 0x95, 0xFA, 0x96, + 0x52, 0xF0, 0x15, 0xD7, 0x94, 0xB3, 0xC1, 0x3C, + 0xB1, 0x3D, 0x38, 0xD6, 0x5E, 0x23, 0x3A, 0x79, + 0x18, 0x30, 0x81, 0x1B, 0x79, 0x96, 0x52, 0x2A, + 0xBD, 0x6F, 0x46, 0xB5, 0xC7, 0xEE, 0x67, 0x29 + }, + { + 0xF1, 0x80, 0xE2, 0x99, 0x93, 0x91, 0x6F, 0x2B, + 0xAC, 0xC7, 0x41, 0xAF, 0x9D, 0x03, 0x49, 0x10, + 0xC4, 0xD4, 0xAD, 0xB2, 0xBE, 0x16, 0x30, 0xDE, + 0x76, 0x18, 0x5F, 0x6C, 0x0C, 0x03, 0x8D, 0x4E, + 0xAC, 0x72, 0x27, 0x92, 0xF6, 0x16, 0xC2, 0xA3, + 0xF1, 0xA5, 0xCA, 0x26, 0xE0, 0xFB, 0xF7, 0x97, + 0x03, 0x31, 0x35, 0x6B, 0x39, 0xE6, 0x31, 0x44, + 0xEB, 0xCF, 0xAF, 0x31, 0x38, 0x19, 0x84, 0xE3 + }, + { + 0x6B, 0x14, 0x28, 0xA1, 0xD5, 0xF8, 0x0B, 0x06, + 0xC4, 0x3B, 0x1D, 0xD4, 0x55, 0xCD, 0xA7, 0x7A, + 0xF0, 0x98, 0x05, 0x0B, 0x17, 0xD0, 0x42, 0xBA, + 0x42, 0x39, 0x09, 0x01, 0x75, 0x2F, 0x85, 0x05, + 0xB7, 0x5A, 0xA6, 0x97, 0x13, 0xF4, 0x5B, 0xD7, + 0xA8, 0xFF, 0x93, 0x56, 0xD3, 0xD0, 0xDC, 0x2B, + 0xB2, 0xCE, 0xD0, 0x06, 0xD7, 0x7C, 0x33, 0x83, + 0x4C, 0x42, 0x2B, 0x49, 0x73, 0x0D, 0x3F, 0x13 + }, + { + 0x7E, 0x18, 0x75, 0x71, 0x80, 0x05, 0xD3, 0x80, + 0xD5, 0x1A, 0x36, 0xC2, 0x39, 0x9B, 0x6F, 0x0C, + 0xEB, 0xC0, 0x9D, 0x92, 0x91, 0xF4, 0xF0, 0xD8, + 0x48, 0x4B, 0xA0, 0x5D, 0x6C, 0x05, 0x55, 0xDA, + 0x55, 0x50, 0xCA, 0xCA, 0xD0, 0xA3, 0x12, 0x83, + 0x2B, 0x18, 0xFF, 0xEE, 0x0C, 0x8C, 0x42, 0x92, + 0x48, 0x6D, 0x69, 0x87, 0xEC, 0x0E, 0x9D, 0x1A, + 0x16, 0xCB, 0x84, 0x0C, 0x19, 0x17, 0x05, 0xC5 + }, + { + 0x6E, 0xC8, 0xFF, 0xBB, 0x92, 0xC0, 0xC6, 0x20, + 0x1F, 0x27, 0x71, 0xFD, 0xF9, 0x78, 0x68, 0xD3, + 0xAC, 0x60, 0x3F, 0x55, 0xB9, 0xB6, 0x7A, 0xB1, + 0x3C, 0xBE, 0xC0, 0x24, 0x97, 0x58, 0xCB, 0xEC, + 0x62, 0x68, 0xAF, 0x51, 0x82, 0x1C, 0x7F, 0x8B, + 0x3F, 0xDE, 0x1B, 0xF4, 0x97, 0x1D, 0x44, 0x71, + 0xA8, 0x41, 0xF3, 0xBD, 0xB3, 0x1A, 0x31, 0x9C, + 0xAF, 0x0C, 0xFB, 0xAE, 0x26, 0x1E, 0xD7, 0xFB + }, + { + 0x3A, 0x3E, 0x2F, 0x3B, 0x2C, 0x30, 0xE5, 0x01, + 0x91, 0x9F, 0x5B, 0xF9, 0x32, 0x65, 0x77, 0x1F, + 0x93, 0xD3, 0x38, 0x07, 0x02, 0x03, 0x7B, 0xCC, + 0x58, 0x24, 0xAB, 0x2B, 0xB9, 0x37, 0xD9, 0x77, + 0xF7, 0xF9, 0xD0, 0x8A, 0xC2, 0xFB, 0xAD, 0x6C, + 0xDF, 0xFE, 0xD2, 0x10, 0xD3, 0xBD, 0x50, 0x81, + 0xB4, 0x6C, 0xFE, 0xB9, 0x2E, 0xC0, 0x90, 0xF7, + 0xB7, 0xAB, 0xB6, 0xFC, 0x90, 0x51, 0x78, 0x0F + }, + { + 0x62, 0xAC, 0xA9, 0x22, 0xF8, 0x58, 0x51, 0x6E, + 0xCA, 0x56, 0x8F, 0x57, 0x07, 0xF3, 0x50, 0xBF, + 0x8B, 0xE9, 0x38, 0x21, 0xF2, 0xC4, 0xBA, 0x1F, + 0x55, 0xC5, 0xC9, 0xF0, 0x1D, 0xE7, 0xEE, 0x2B, + 0x37, 0xC7, 0xF5, 0x4D, 0x5F, 0xB1, 0xD1, 0x7E, + 0x15, 0x62, 0x2F, 0x5F, 0xB2, 0x07, 0xCC, 0xDC, + 0xA1, 0x5B, 0x52, 0x8D, 0xE0, 0x00, 0xB2, 0x2D, + 0xE5, 0xBD, 0x5B, 0xD5, 0x57, 0x7A, 0xC4, 0x17 + }, + { + 0x14, 0x9E, 0x61, 0x72, 0x4F, 0xF0, 0x59, 0xB8, + 0x6E, 0x8A, 0x9B, 0x67, 0x9B, 0x91, 0x14, 0x88, + 0xAF, 0x75, 0x7B, 0xB0, 0xB0, 0xBB, 0xCA, 0x01, + 0x67, 0xB7, 0x3E, 0x7B, 0xB3, 0x29, 0x63, 0x45, + 0x60, 0x4D, 0x85, 0xE8, 0xDA, 0x9A, 0x09, 0x97, + 0x8D, 0xF5, 0xD2, 0x14, 0xD9, 0x69, 0x50, 0xE7, + 0xF5, 0xE6, 0x18, 0x4D, 0x17, 0xEE, 0x30, 0x31, + 0xE3, 0x09, 0xCC, 0x79, 0x3F, 0xB9, 0xDE, 0x37 + }, + { + 0x48, 0x3C, 0xF8, 0xEC, 0xF2, 0xD0, 0x51, 0x62, + 0xBD, 0x4E, 0xBA, 0xC6, 0x7E, 0x3B, 0x7F, 0xC1, + 0xA2, 0xEB, 0x59, 0x2B, 0x64, 0x31, 0x72, 0xB4, + 0x29, 0x1F, 0x3C, 0xC4, 0xF0, 0x75, 0xCA, 0x49, + 0x95, 0x96, 0x11, 0xAC, 0xBC, 0x7D, 0xF4, 0x9D, + 0x14, 0x3D, 0x85, 0xD3, 0x3F, 0xE5, 0x61, 0x4E, + 0x11, 0x17, 0xA3, 0xA7, 0x59, 0xF2, 0xAE, 0x95, + 0xDD, 0x7F, 0x5E, 0xDC, 0x1E, 0x53, 0x89, 0xF8 + }, + { + 0x74, 0x46, 0x27, 0x14, 0xAB, 0xEE, 0x38, 0x7F, + 0x9E, 0x83, 0xBB, 0x30, 0x35, 0xA2, 0xEE, 0x14, + 0x4C, 0x39, 0x1F, 0xC5, 0xD1, 0x8E, 0x65, 0x71, + 0x04, 0x9C, 0x8B, 0xB7, 0xAD, 0xE0, 0x67, 0xC4, + 0x21, 0x58, 0xDB, 0x7B, 0x9D, 0xD8, 0x87, 0x68, + 0x96, 0xF0, 0x04, 0x83, 0x73, 0x6A, 0x06, 0x3D, + 0x74, 0x13, 0x21, 0x71, 0x62, 0x5B, 0x7A, 0x35, + 0x46, 0x26, 0x36, 0xBA, 0x33, 0x6A, 0x9B, 0xC6 + }, + { + 0x45, 0xEF, 0x37, 0xD4, 0x5B, 0x4A, 0xEA, 0x47, + 0x43, 0xBD, 0xFB, 0x11, 0x26, 0x5A, 0x1A, 0x48, + 0xEB, 0x3C, 0x50, 0x74, 0xF9, 0x45, 0x7D, 0xE5, + 0x3D, 0xF6, 0x14, 0x34, 0x27, 0x20, 0xDF, 0x59, + 0x44, 0x56, 0x71, 0xBB, 0xF1, 0xF0, 0x10, 0x82, + 0x50, 0xF8, 0x7D, 0x10, 0xCD, 0x54, 0x45, 0x1E, + 0x0D, 0x68, 0x1B, 0x0D, 0x21, 0x36, 0x68, 0x4B, + 0x09, 0x45, 0x23, 0xA8, 0xF0, 0xC2, 0xBA, 0x94 + }, + { + 0xC2, 0x8E, 0xED, 0x11, 0x94, 0x6E, 0x2F, 0x44, + 0x77, 0x04, 0x48, 0x3F, 0x78, 0x63, 0xC8, 0x9A, + 0xF5, 0x64, 0x94, 0xC0, 0xA7, 0x7A, 0x70, 0xA3, + 0x0E, 0xAB, 0x5D, 0xB7, 0x93, 0x8A, 0x02, 0x28, + 0xD3, 0xF7, 0x44, 0x87, 0x32, 0xF4, 0xEB, 0xBF, + 0x92, 0xCD, 0x88, 0x51, 0x5F, 0x9B, 0x7E, 0x03, + 0x15, 0xC7, 0x25, 0x9F, 0xDC, 0x3B, 0xFE, 0x52, + 0x6E, 0xCC, 0xE0, 0xCE, 0x66, 0x4D, 0x9D, 0xED + }, + { + 0x77, 0x51, 0x53, 0x22, 0xA1, 0x42, 0xBD, 0x2B, + 0x68, 0x27, 0xEB, 0xED, 0x95, 0x19, 0x7C, 0x90, + 0x26, 0xE7, 0x72, 0x93, 0x64, 0x99, 0x74, 0xDF, + 0x36, 0x6C, 0xE4, 0x90, 0xD9, 0x49, 0xD1, 0x25, + 0xFD, 0xB8, 0x48, 0x16, 0xE8, 0xBC, 0xC8, 0xCB, + 0x74, 0x92, 0xE4, 0xD4, 0x89, 0xAB, 0x9B, 0xF2, + 0xD6, 0x38, 0xC6, 0x22, 0x9E, 0x48, 0xCF, 0xEE, + 0x09, 0x60, 0x79, 0x0B, 0xE7, 0xDD, 0x57, 0x06 + }, + { + 0x4C, 0x01, 0x68, 0xA9, 0xDE, 0x14, 0xFF, 0x99, + 0x25, 0x71, 0x45, 0xD0, 0x55, 0x91, 0x93, 0x54, + 0x36, 0x38, 0xDF, 0x2E, 0x5B, 0x02, 0x6D, 0x19, + 0x9E, 0xFC, 0x57, 0x9B, 0xE7, 0xC3, 0xAE, 0xE4, + 0x82, 0xCB, 0x0E, 0xAE, 0xC6, 0xC0, 0x5D, 0xF7, + 0x6F, 0xC0, 0xE1, 0x1D, 0x2C, 0x45, 0x0E, 0xC6, + 0xEE, 0x3B, 0x48, 0xBB, 0x61, 0xD1, 0xDB, 0xB4, + 0xED, 0x90, 0xE9, 0x7D, 0x5C, 0x34, 0x50, 0x2A + }, + { + 0xE9, 0x96, 0xA5, 0x94, 0xFA, 0x6C, 0xFF, 0x57, + 0xBE, 0x24, 0xE0, 0xC8, 0x00, 0x3F, 0x2C, 0x79, + 0xB5, 0xE0, 0x2B, 0xFF, 0xB1, 0x4D, 0xE2, 0xB4, + 0x6A, 0x29, 0x47, 0x8D, 0x63, 0x80, 0x09, 0xBE, + 0xC4, 0x75, 0x55, 0x4F, 0xA2, 0xD7, 0x60, 0x08, + 0xD4, 0x90, 0x36, 0xDF, 0xE1, 0x3E, 0x57, 0xD0, + 0x0F, 0x74, 0x44, 0xB2, 0x19, 0xCF, 0x55, 0xBA, + 0x48, 0xAE, 0xB2, 0x42, 0xDB, 0x06, 0x95, 0x35 + }, + { + 0xDB, 0x59, 0x68, 0xBE, 0x06, 0xD9, 0x16, 0xBE, + 0xB1, 0xC5, 0x62, 0xDF, 0x4F, 0x6F, 0x11, 0xCF, + 0xFE, 0xC9, 0xAF, 0xAC, 0x2C, 0x7B, 0x45, 0xFC, + 0xF2, 0x32, 0x3F, 0xCE, 0xB3, 0x50, 0xC5, 0xDF, + 0x90, 0x21, 0x28, 0x39, 0x02, 0x96, 0x8D, 0x29, + 0x44, 0x8D, 0x2F, 0x48, 0xF2, 0xF6, 0x2B, 0x8F, + 0x59, 0x98, 0x3A, 0x22, 0x0F, 0xB7, 0x82, 0x92, + 0x41, 0x0E, 0xD9, 0x80, 0x63, 0x79, 0x3F, 0x26 + }, + { + 0x20, 0x25, 0x66, 0x66, 0xE5, 0x33, 0xE9, 0xF0, + 0xF2, 0x27, 0x61, 0x10, 0x95, 0x0D, 0xC8, 0x59, + 0x1E, 0x2B, 0xBF, 0x78, 0xB5, 0xC9, 0x53, 0xB2, + 0x6F, 0x85, 0xFF, 0x3B, 0x6F, 0x85, 0x8B, 0xB3, + 0xDA, 0x6D, 0xB1, 0x7A, 0x53, 0x2D, 0xDB, 0xFD, + 0xA0, 0xFC, 0x28, 0xE7, 0xC5, 0xEE, 0xBA, 0x41, + 0x02, 0x95, 0xB1, 0x2F, 0xE9, 0x3E, 0x48, 0xBE, + 0x45, 0xAE, 0xA0, 0xB1, 0xC6, 0x45, 0xDD, 0x11 + }, + { + 0x59, 0xF7, 0x83, 0x5E, 0xBA, 0x1D, 0xC2, 0xC2, + 0x85, 0x7D, 0x32, 0x55, 0x46, 0x25, 0xCB, 0xB0, + 0x38, 0x1C, 0xFC, 0x95, 0x56, 0xD2, 0x0F, 0x62, + 0x94, 0x6D, 0x6F, 0x13, 0x3D, 0x52, 0x93, 0x64, + 0x46, 0xD7, 0xBD, 0x94, 0xA3, 0x75, 0x91, 0x4B, + 0xCF, 0xE4, 0xAA, 0xA6, 0x4A, 0xE4, 0xA4, 0x10, + 0xB5, 0xC8, 0x9C, 0x7B, 0x48, 0x6C, 0xF1, 0xCA, + 0x83, 0x35, 0x38, 0x48, 0x62, 0x5E, 0xAC, 0xD1 + }, + { + 0xE9, 0x12, 0x5B, 0x61, 0x6B, 0xDB, 0xD7, 0xFE, + 0xE6, 0xEA, 0xD7, 0x6D, 0x24, 0xDF, 0xCA, 0x57, + 0xDF, 0xD0, 0x94, 0x99, 0x46, 0x34, 0xBA, 0x62, + 0x1D, 0x0F, 0x91, 0xB7, 0x91, 0x78, 0xE4, 0x70, + 0x92, 0x94, 0x71, 0xE8, 0x8A, 0x7D, 0x51, 0x9D, + 0x79, 0x14, 0x53, 0x0F, 0x48, 0xFA, 0xA9, 0x73, + 0xCA, 0x11, 0xDE, 0xB3, 0xAB, 0x07, 0x17, 0x50, + 0x3E, 0x1F, 0xA8, 0x0A, 0xDB, 0xE1, 0xC9, 0xBD + }, + { + 0xCC, 0xED, 0x46, 0xE3, 0x4D, 0xF4, 0x3D, 0x69, + 0x23, 0xE6, 0x82, 0x49, 0xFC, 0xD3, 0x0A, 0xCB, + 0x02, 0xB8, 0x0D, 0xAE, 0x3B, 0x2D, 0x18, 0xF6, + 0x76, 0xCE, 0x79, 0xD8, 0xD6, 0x03, 0x44, 0xBD, + 0x6A, 0x74, 0xDB, 0x79, 0x11, 0x59, 0x01, 0x9A, + 0x0A, 0xFC, 0xEE, 0xE3, 0x91, 0xA2, 0x5B, 0x96, + 0x27, 0x96, 0x53, 0x61, 0x25, 0x97, 0xD7, 0x83, + 0x7B, 0xA5, 0x93, 0x6C, 0x8D, 0x85, 0xEA, 0xF1 + }, + { + 0x24, 0x7C, 0xA4, 0x54, 0xA2, 0xF8, 0xC8, 0xFF, + 0x72, 0x2D, 0x74, 0x75, 0x30, 0x22, 0xE5, 0x84, + 0xD4, 0x33, 0xBF, 0x2B, 0x8C, 0xD8, 0x01, 0x39, + 0x97, 0x32, 0x65, 0x18, 0x7B, 0x8A, 0xB8, 0xD8, + 0x32, 0xAB, 0xFB, 0x8B, 0x51, 0x4F, 0xBC, 0xCC, + 0x60, 0x95, 0x2C, 0x91, 0x6E, 0x59, 0xBF, 0x67, + 0x1B, 0x38, 0x62, 0x06, 0x88, 0x56, 0xD5, 0xCD, + 0xB9, 0xC2, 0xB5, 0x46, 0x11, 0xA2, 0x5A, 0xA9 + }, + { + 0xD3, 0x39, 0xBE, 0x49, 0x7B, 0x6A, 0xD1, 0xB9, + 0x32, 0x84, 0x80, 0x35, 0x5E, 0xB7, 0xB4, 0x0D, + 0xFC, 0x7A, 0x25, 0x37, 0x4A, 0xA3, 0xDC, 0x39, + 0xC5, 0x7A, 0x3C, 0xBE, 0x6F, 0xBD, 0x2A, 0x1D, + 0x4C, 0x0B, 0x4C, 0xEE, 0x6E, 0x69, 0xF8, 0xAD, + 0x28, 0x96, 0xD4, 0xCD, 0x07, 0x4B, 0x1D, 0x55, + 0xF4, 0x12, 0x5E, 0xB2, 0x81, 0x0C, 0xD8, 0x04, + 0x43, 0x55, 0x1E, 0x7F, 0x21, 0x3C, 0x64, 0xB7 + }, + { + 0xE5, 0xDB, 0xE6, 0x26, 0xCA, 0x30, 0x8C, 0x16, + 0xAB, 0x55, 0x40, 0xAC, 0xA7, 0xE2, 0x67, 0x1C, + 0x46, 0xE4, 0x80, 0x69, 0xFC, 0xBD, 0x72, 0x53, + 0x78, 0x26, 0x62, 0x1B, 0x5C, 0x26, 0x40, 0xEE, + 0xE2, 0xC4, 0xEA, 0x50, 0x94, 0xB0, 0xE1, 0x30, + 0x26, 0x48, 0xB8, 0xA5, 0xAB, 0x03, 0xED, 0x50, + 0xF9, 0xB3, 0x76, 0x1A, 0x2F, 0x92, 0xC4, 0x34, + 0xAE, 0x1A, 0x5D, 0x16, 0x40, 0x74, 0xE3, 0x66 + }, + { + 0x20, 0xA5, 0x0B, 0xB7, 0x98, 0x72, 0x4F, 0x2D, + 0x00, 0xFE, 0xEE, 0x71, 0xBA, 0xF0, 0x76, 0x8B, + 0xAB, 0x9C, 0x02, 0x3F, 0x25, 0x74, 0xDB, 0x44, + 0x17, 0x06, 0x44, 0x2A, 0x21, 0x4D, 0x5D, 0x21, + 0x66, 0xA8, 0xEC, 0x94, 0xF1, 0xEB, 0x73, 0xDF, + 0x3C, 0xD0, 0x17, 0x39, 0x63, 0x57, 0x7D, 0x2C, + 0xA1, 0x0B, 0x48, 0x84, 0x99, 0x55, 0x9D, 0x99, + 0xA0, 0x93, 0x12, 0xAE, 0x54, 0x29, 0x4D, 0x2F + }, + { + 0xAD, 0x7F, 0xB7, 0x29, 0x67, 0x0D, 0x38, 0xEA, + 0xB6, 0xD0, 0x53, 0xF2, 0x55, 0x70, 0x83, 0xE0, + 0xCE, 0xF6, 0x28, 0x9A, 0x76, 0x9C, 0xC6, 0x89, + 0x1A, 0xA6, 0x80, 0xE4, 0xB3, 0x3F, 0x59, 0x5D, + 0x26, 0xFA, 0x98, 0x9A, 0xEA, 0x67, 0x78, 0x0E, + 0x5B, 0x64, 0x79, 0x21, 0x06, 0xB8, 0x28, 0x3E, + 0x78, 0x55, 0x2C, 0xA3, 0x2D, 0x18, 0x5D, 0x6C, + 0x88, 0x7A, 0x81, 0xA3, 0xCC, 0xDB, 0xDF, 0xDC + }, + { + 0x7B, 0xB4, 0x0B, 0xB6, 0xB5, 0x25, 0x8E, 0xE4, + 0x1B, 0x52, 0xEC, 0x92, 0x80, 0x9C, 0x54, 0x64, + 0x87, 0x83, 0xF0, 0x87, 0x41, 0x9A, 0xC5, 0x9C, + 0xC9, 0xD3, 0x78, 0x32, 0xD8, 0xAC, 0xAC, 0x19, + 0xB6, 0xDA, 0x19, 0xA6, 0x61, 0x20, 0xF6, 0x38, + 0x69, 0x14, 0x87, 0xF5, 0xA2, 0xC9, 0x7F, 0xCA, + 0x2B, 0xFE, 0x69, 0x32, 0x72, 0x91, 0x4C, 0x5F, + 0x11, 0x5E, 0x0F, 0x72, 0xD5, 0xF3, 0xA0, 0xCC + }, + { + 0x4C, 0x0C, 0xF8, 0x74, 0xF5, 0x80, 0xC8, 0x04, + 0xC7, 0x8B, 0x81, 0xEE, 0x1A, 0x74, 0xAA, 0x53, + 0xC8, 0x73, 0x66, 0x24, 0xF1, 0x2E, 0x78, 0x16, + 0xCA, 0x07, 0x6C, 0x94, 0xFA, 0x1D, 0x4E, 0xE6, + 0xDB, 0x21, 0x9D, 0x7E, 0x4F, 0x0D, 0xF6, 0x65, + 0x8A, 0xBD, 0x32, 0x0E, 0x5A, 0x8E, 0xEC, 0x44, + 0x37, 0x21, 0x25, 0x31, 0x8E, 0xEB, 0x7B, 0xD7, + 0x84, 0xB3, 0xFE, 0x6D, 0x7C, 0x19, 0xC1, 0xC7 + }, + { + 0x1A, 0x0D, 0x09, 0x02, 0xD0, 0xF3, 0x79, 0xEC, + 0x49, 0x7F, 0x3D, 0x9D, 0xBA, 0x84, 0xF9, 0x5B, + 0x15, 0xCB, 0xDE, 0xEC, 0x75, 0x4D, 0x9D, 0x0E, + 0xFF, 0x0B, 0x59, 0x24, 0xDA, 0x70, 0xBE, 0xB4, + 0xF3, 0x51, 0x31, 0xC9, 0xD5, 0xAA, 0x2B, 0x9A, + 0x6A, 0xAF, 0x68, 0x52, 0xDC, 0xC1, 0x37, 0x31, + 0x32, 0x98, 0x94, 0xFE, 0x20, 0xB3, 0x30, 0x9F, + 0xFD, 0x99, 0x9C, 0x6E, 0xEA, 0xF1, 0x74, 0x91 + }, + { + 0xCD, 0xDE, 0x5A, 0x50, 0x78, 0x6C, 0x46, 0xC3, + 0xD8, 0xCE, 0x77, 0xA3, 0x91, 0xFB, 0x1D, 0x2C, + 0x20, 0x0A, 0x4E, 0x61, 0xB1, 0x69, 0x9C, 0x3C, + 0xCC, 0x4D, 0xD3, 0xA4, 0x14, 0xDE, 0x72, 0xA9, + 0x7D, 0x51, 0x1F, 0x38, 0x1E, 0x27, 0x68, 0x0B, + 0xED, 0x08, 0x64, 0xE7, 0xD9, 0x86, 0x07, 0x47, + 0xAE, 0x07, 0x63, 0xA5, 0xB1, 0xBC, 0xBB, 0xEE, + 0x87, 0xC6, 0xDE, 0xA1, 0xE8, 0x54, 0x05, 0x39 + }, + { + 0xA6, 0x55, 0xEE, 0xF6, 0xE7, 0x34, 0x0F, 0x87, + 0xD0, 0x74, 0xA6, 0x50, 0x5C, 0x0F, 0x5F, 0xBC, + 0xD0, 0xB5, 0x71, 0x58, 0xBD, 0x0F, 0xB1, 0x6C, + 0x07, 0x82, 0xE6, 0x6B, 0x30, 0x19, 0x6B, 0x19, + 0x7A, 0x70, 0x12, 0x5B, 0x3A, 0x4C, 0x78, 0x70, + 0xC0, 0xB5, 0x57, 0x01, 0xBB, 0x54, 0x09, 0x67, + 0xB0, 0xCE, 0xDA, 0xFC, 0xB1, 0xF5, 0x22, 0x58, + 0x9C, 0x18, 0x58, 0x20, 0x60, 0x04, 0x63, 0x04 + }, + { + 0x86, 0xBC, 0x99, 0x23, 0x66, 0x92, 0xC4, 0x8E, + 0x6A, 0x35, 0x8D, 0x52, 0x59, 0x15, 0x2C, 0x3D, + 0x9D, 0xB8, 0x7F, 0x41, 0x68, 0xF4, 0xBD, 0x1D, + 0xE7, 0xB8, 0x72, 0x2D, 0xA8, 0x49, 0x50, 0xF4, + 0xD1, 0x36, 0xD8, 0x6D, 0xA1, 0xFA, 0x34, 0x06, + 0xBE, 0xFB, 0x70, 0x54, 0x8D, 0x32, 0x6A, 0x78, + 0xF6, 0xBF, 0x3F, 0xFC, 0x6F, 0x30, 0x39, 0x93, + 0x17, 0xE8, 0xBC, 0xE7, 0x4A, 0x1D, 0x6C, 0x15 + }, + { + 0x58, 0x69, 0xD6, 0x51, 0xD6, 0x80, 0x21, 0xB3, + 0x0F, 0xF1, 0x79, 0x26, 0xDE, 0xF6, 0xD4, 0xEB, + 0x0B, 0x71, 0x65, 0x1B, 0xA8, 0xC4, 0x0B, 0x2E, + 0x4B, 0xEB, 0x4E, 0xB1, 0x58, 0x85, 0x63, 0x53, + 0x36, 0xE4, 0x83, 0x5D, 0x63, 0xEB, 0x95, 0x1A, + 0x1B, 0xDB, 0xBF, 0x4A, 0xB6, 0xC0, 0xD1, 0xE3, + 0xB6, 0x85, 0x9A, 0xA0, 0xC0, 0x8D, 0x19, 0xD9, + 0xF8, 0x8D, 0xF1, 0xB1, 0x7B, 0xF0, 0x88, 0x77 + }, + { + 0x47, 0xAA, 0xD9, 0x78, 0x55, 0x68, 0xD2, 0xBC, + 0xE3, 0x35, 0x7E, 0xA9, 0xDA, 0xF1, 0x8F, 0xA4, + 0xD4, 0x19, 0x1D, 0x96, 0xED, 0x24, 0xCE, 0x96, + 0x3D, 0x0B, 0x1E, 0x96, 0x6E, 0x82, 0xE5, 0x29, + 0xB4, 0x5F, 0x70, 0xE4, 0x09, 0xAD, 0x04, 0xD1, + 0xFC, 0x82, 0x96, 0x05, 0x86, 0xC1, 0xCB, 0xD4, + 0x2F, 0x6C, 0x78, 0x2E, 0x5F, 0xA7, 0x59, 0xA8, + 0x2D, 0x80, 0xBB, 0x3C, 0x5E, 0xD7, 0x0A, 0x79 + }, + { + 0xCC, 0xA6, 0xAC, 0xE2, 0xB1, 0xCF, 0xCC, 0xE8, + 0xBB, 0xC8, 0xC7, 0xB9, 0xFA, 0x61, 0x50, 0x35, + 0x60, 0x29, 0x71, 0xD7, 0xE6, 0x36, 0xC8, 0xF3, + 0x44, 0xB6, 0x2D, 0x1D, 0xD7, 0x6E, 0xE5, 0xC7, + 0xC5, 0x7F, 0x32, 0x96, 0xEE, 0xC0, 0x43, 0x1F, + 0xF9, 0xC7, 0x37, 0x0A, 0x27, 0x7B, 0x23, 0x1A, + 0xE3, 0x17, 0x0D, 0xE5, 0x62, 0x14, 0xF7, 0xCB, + 0xE1, 0xE4, 0xB4, 0xA1, 0x49, 0x26, 0xEB, 0x7C + }, + { + 0x88, 0xEF, 0x75, 0xA7, 0x5B, 0xA6, 0x56, 0x03, + 0xE7, 0xDF, 0x67, 0xAB, 0x9B, 0xC1, 0x8C, 0x0F, + 0xA9, 0xED, 0xFC, 0xEF, 0xBB, 0x09, 0x76, 0xEF, + 0xF4, 0x84, 0x57, 0x15, 0xF6, 0xA9, 0xDD, 0x17, + 0x53, 0xAA, 0x9E, 0xAE, 0x09, 0xC3, 0x8D, 0xD1, + 0xD2, 0xD2, 0xD3, 0xB5, 0xC8, 0x9A, 0x59, 0x07, + 0x05, 0xC2, 0x40, 0x60, 0x90, 0x5A, 0x7B, 0x08, + 0x55, 0x75, 0x41, 0xE0, 0x3B, 0x6C, 0xB5, 0xD6 + }, + { + 0x8F, 0xD2, 0xDD, 0xED, 0xC8, 0x80, 0x26, 0x7F, + 0x52, 0x39, 0x92, 0xDA, 0x22, 0xFA, 0xAE, 0x1B, + 0x22, 0x5B, 0x13, 0xD1, 0xA8, 0xAE, 0xB6, 0xD0, + 0x3B, 0x12, 0x71, 0x6E, 0x7C, 0x74, 0xFD, 0x87, + 0xE9, 0xF0, 0x5B, 0xC6, 0x60, 0x31, 0xB9, 0xBB, + 0xE9, 0x34, 0x6B, 0x3F, 0x8E, 0xF3, 0x9F, 0x0D, + 0xA8, 0xE3, 0x48, 0x4C, 0x99, 0x79, 0x84, 0x96, + 0x8A, 0xD4, 0xA2, 0xDC, 0x61, 0xF8, 0xC8, 0x29 + }, + { + 0x73, 0x76, 0xE6, 0x39, 0x93, 0x63, 0x4A, 0x44, + 0xAE, 0xBA, 0x28, 0x09, 0xB3, 0xE2, 0x53, 0xC2, + 0xBF, 0x8B, 0x8C, 0x02, 0x93, 0x44, 0x7B, 0xF1, + 0xB6, 0xD3, 0x66, 0x1A, 0x07, 0x3B, 0x5F, 0x4A, + 0x2B, 0x5E, 0x85, 0x72, 0x95, 0xB2, 0x84, 0x55, + 0xE0, 0x88, 0xE7, 0x30, 0x8D, 0x5D, 0x41, 0x34, + 0xC1, 0xE5, 0x28, 0x73, 0x74, 0x0F, 0x99, 0x71, + 0xF8, 0x64, 0xE5, 0x0C, 0x15, 0x48, 0xF1, 0x49 + }, + { + 0x7D, 0x80, 0x33, 0x52, 0x80, 0x4C, 0x4E, 0x73, + 0x32, 0x8C, 0x9D, 0x82, 0xB4, 0xA2, 0xE6, 0x29, + 0x32, 0x14, 0xE1, 0xBE, 0xE7, 0x2A, 0xDC, 0x87, + 0x30, 0x92, 0x41, 0xEC, 0xFE, 0x76, 0x15, 0x0E, + 0xA4, 0x4F, 0x4C, 0x4D, 0x36, 0x60, 0xB4, 0xB0, + 0x77, 0xF4, 0xC6, 0xCF, 0x99, 0x65, 0x50, 0x63, + 0xAD, 0xBB, 0x03, 0xCC, 0x1A, 0x73, 0xC4, 0xD9, + 0xE2, 0xD2, 0xBB, 0x64, 0xEC, 0xD7, 0x03, 0x39 + }, + { + 0xC5, 0x2A, 0xC1, 0xAE, 0xC6, 0x37, 0x9B, 0x05, + 0x19, 0x54, 0x39, 0xEA, 0x8B, 0x89, 0x29, 0x31, + 0x59, 0x78, 0xEE, 0x8B, 0xE5, 0xD9, 0x17, 0x38, + 0xB1, 0x96, 0xE2, 0xA7, 0x09, 0x70, 0x17, 0x49, + 0x08, 0x4C, 0x45, 0x02, 0x4B, 0xD7, 0xB0, 0x61, + 0x5C, 0x13, 0xD1, 0x9A, 0x46, 0x1D, 0xEC, 0xC2, + 0xF0, 0x63, 0xE9, 0x78, 0xC5, 0xE8, 0xC9, 0x52, + 0x87, 0xED, 0xAD, 0x0E, 0xA1, 0x7F, 0x93, 0xA7 + }, + { + 0x7D, 0xB0, 0x5A, 0x02, 0xA6, 0x08, 0x12, 0xD0, + 0xA9, 0x0E, 0x38, 0xBE, 0x32, 0x85, 0x9D, 0x45, + 0xB4, 0x8B, 0xC9, 0x58, 0xCA, 0xB2, 0x44, 0xF6, + 0x3D, 0xB0, 0x0B, 0xE1, 0x72, 0x15, 0xAE, 0x41, + 0x4A, 0xA1, 0xE9, 0x04, 0x9D, 0xCB, 0x79, 0xC0, + 0x41, 0xE5, 0xF0, 0xDE, 0xE9, 0x12, 0x19, 0x50, + 0xDF, 0xE6, 0xF4, 0xC0, 0x10, 0xEF, 0xA7, 0x8C, + 0xC5, 0x75, 0xE1, 0x6C, 0x66, 0xAA, 0xC2, 0x11 + }, + { + 0x1C, 0x47, 0x09, 0x81, 0x67, 0xB2, 0xF3, 0x8E, + 0xEB, 0x11, 0x1C, 0x18, 0x46, 0xC9, 0x87, 0xE2, + 0x38, 0x5E, 0x23, 0x83, 0xA4, 0xEB, 0xCE, 0x8A, + 0xF3, 0x3D, 0x4F, 0xCB, 0x81, 0xE5, 0xE2, 0x35, + 0x12, 0xAE, 0x42, 0xD0, 0x01, 0x57, 0x0A, 0xE4, + 0x28, 0x17, 0xC2, 0x1B, 0x6E, 0xBC, 0xB6, 0x8E, + 0xB4, 0x34, 0x80, 0x9F, 0xBA, 0x89, 0x14, 0xA3, + 0x3E, 0x90, 0x9E, 0x49, 0xC3, 0x79, 0xB2, 0xDB + }, + { + 0x72, 0x05, 0x44, 0x7E, 0x5E, 0x3A, 0xE3, 0x43, + 0x5F, 0x72, 0x9F, 0xCF, 0x32, 0x76, 0x1E, 0x61, + 0xA8, 0xBA, 0x9D, 0x89, 0xBA, 0xEF, 0x3B, 0xCD, + 0x75, 0x3E, 0x95, 0xFE, 0x9D, 0xF5, 0x65, 0x95, + 0xE7, 0xBC, 0x1D, 0x12, 0x17, 0xD7, 0x5C, 0xDB, + 0x48, 0xF6, 0x1F, 0x49, 0x15, 0x15, 0x0E, 0xE1, + 0x7B, 0xD0, 0x85, 0x0F, 0xBA, 0xAC, 0xE1, 0xF3, + 0xBB, 0x39, 0xD3, 0xCA, 0x65, 0xE4, 0x5B, 0x7D + }, + { + 0xAC, 0xFC, 0x03, 0xC3, 0xEB, 0xFF, 0x93, 0xB8, + 0xAF, 0xC6, 0x74, 0x7B, 0x09, 0x10, 0x42, 0xB1, + 0xCE, 0x72, 0xB5, 0x15, 0xC4, 0x35, 0x8A, 0xB3, + 0x8C, 0x92, 0xDE, 0x3E, 0xD6, 0x4A, 0x5C, 0x25, + 0xB9, 0x4E, 0x9A, 0x51, 0x0B, 0x52, 0x36, 0xFA, + 0xB7, 0x95, 0xD2, 0x37, 0x91, 0xF1, 0x4A, 0x81, + 0x5A, 0x87, 0xD8, 0x36, 0xB8, 0x0B, 0x89, 0x8B, + 0xFB, 0xF5, 0x02, 0x50, 0xE4, 0xC4, 0x46, 0x0A + }, + { + 0x72, 0x4C, 0x41, 0xA8, 0xF0, 0x67, 0xCD, 0x18, + 0x89, 0x54, 0x5C, 0xAA, 0x2C, 0x73, 0x5E, 0x2B, + 0xAB, 0xD8, 0x99, 0xFD, 0xA5, 0xCB, 0x54, 0x83, + 0xCA, 0x4C, 0xAB, 0x22, 0x2A, 0x78, 0x23, 0x0A, + 0x83, 0x58, 0x96, 0x7E, 0xEC, 0x40, 0x32, 0x9A, + 0xB5, 0xFC, 0x0B, 0xDB, 0x61, 0x18, 0x99, 0xBB, + 0x5D, 0x63, 0xE2, 0x5D, 0xED, 0x9D, 0xC5, 0xA8, + 0x79, 0x6A, 0x5E, 0xF3, 0x69, 0xF3, 0x05, 0xE9 + }, + { + 0x4F, 0x5C, 0x7E, 0xAD, 0xB6, 0x9D, 0xFD, 0x19, + 0xDC, 0x08, 0x89, 0x94, 0xE4, 0x62, 0xA5, 0x9B, + 0x26, 0x0C, 0x44, 0x51, 0x9C, 0xE6, 0x04, 0x2A, + 0xCB, 0xC3, 0xD7, 0x75, 0xA6, 0xE6, 0xA7, 0xBB, + 0x6A, 0xCF, 0xC2, 0x16, 0xF5, 0x16, 0x5D, 0x23, + 0x2A, 0x5B, 0x39, 0xC0, 0x18, 0x2D, 0x35, 0x02, + 0x78, 0xEE, 0x55, 0x8E, 0x9A, 0xF5, 0x57, 0x44, + 0x4F, 0x88, 0x59, 0xD4, 0x31, 0x4F, 0x5F, 0xDC + }, + { + 0x01, 0x7A, 0x70, 0x2F, 0x48, 0x9C, 0xC3, 0x37, + 0x47, 0xAC, 0xCA, 0x20, 0x9E, 0xB9, 0x64, 0xFA, + 0x6B, 0xF7, 0x43, 0x42, 0x17, 0xFC, 0x12, 0xF9, + 0x12, 0x10, 0x0E, 0x14, 0xDB, 0xE2, 0xC5, 0x56, + 0x6A, 0xDA, 0xB6, 0xDF, 0x9B, 0xBF, 0x14, 0x4F, + 0x05, 0x1E, 0xA6, 0x87, 0xC8, 0x58, 0xAA, 0xF1, + 0x2D, 0xDC, 0x00, 0xC2, 0x1E, 0x0B, 0x60, 0x01, + 0x9B, 0x01, 0xE6, 0xE8, 0x3A, 0x49, 0xEA, 0xA3 + }, + { + 0xE1, 0x25, 0xCE, 0xC6, 0xE9, 0xB8, 0xD3, 0x26, + 0xFC, 0xE8, 0xE1, 0xDF, 0x0E, 0xDD, 0x03, 0x05, + 0x12, 0xDB, 0x3C, 0x2E, 0xAA, 0x22, 0x20, 0xD8, + 0xE4, 0x5E, 0x6C, 0xFF, 0xD4, 0xEA, 0xF2, 0xD3, + 0xBF, 0x44, 0x5A, 0x75, 0x84, 0xBD, 0x97, 0xBB, + 0xE0, 0x7C, 0x21, 0x6D, 0xD1, 0xA4, 0xA3, 0x35, + 0x84, 0x8D, 0xE2, 0xAB, 0x12, 0x30, 0x1A, 0x56, + 0x03, 0x91, 0xAF, 0x00, 0x9D, 0x17, 0x9A, 0x09 + }, + { + 0xFE, 0x8F, 0xCD, 0xFB, 0xD9, 0xFD, 0xDC, 0xE9, + 0x7F, 0x54, 0x8C, 0xCD, 0x38, 0x96, 0x10, 0x0D, + 0x14, 0xA6, 0x38, 0x04, 0x7C, 0xB3, 0x9D, 0xBD, + 0x82, 0x7C, 0x71, 0x25, 0x9A, 0xFA, 0xF2, 0x58, + 0xCB, 0x48, 0xEB, 0xAB, 0x92, 0x6E, 0xD7, 0x58, + 0x59, 0x20, 0x8F, 0xB4, 0x58, 0x37, 0x22, 0x0A, + 0xC7, 0x84, 0x86, 0xA9, 0xB1, 0x3A, 0x98, 0xF0, + 0xB9, 0xF5, 0xF3, 0xD2, 0x64, 0x74, 0xAD, 0xE1 + }, + { + 0xEF, 0xF9, 0xC3, 0xB3, 0xA8, 0xB4, 0x21, 0xB3, + 0x32, 0x57, 0x56, 0xD5, 0x69, 0xA1, 0x0D, 0xE8, + 0xF4, 0xB4, 0xF8, 0x73, 0x46, 0x22, 0x45, 0xD8, + 0xA1, 0x3F, 0xB9, 0x44, 0x85, 0x24, 0xAE, 0x49, + 0x7B, 0x70, 0x8A, 0x45, 0xF8, 0xAB, 0x67, 0x6A, + 0x1D, 0xD4, 0xBD, 0xFE, 0xBC, 0x4B, 0x7F, 0xE2, + 0x4B, 0xFC, 0x8A, 0x9A, 0xA2, 0xE7, 0x67, 0x64, + 0x40, 0x25, 0xEA, 0x60, 0xF2, 0xC6, 0x47, 0x34 + }, + { + 0x73, 0x52, 0x22, 0x06, 0xC1, 0xFC, 0x8F, 0x20, + 0xBA, 0x8E, 0xB7, 0xFA, 0xBF, 0xCC, 0x50, 0x3A, + 0x74, 0xBB, 0xB5, 0x84, 0xEE, 0xD5, 0xF2, 0xB7, + 0x7A, 0x96, 0xAC, 0x10, 0x1A, 0x8A, 0x16, 0xA7, + 0x61, 0x33, 0xBD, 0x7F, 0x4C, 0x2F, 0xEE, 0x36, + 0x00, 0xC9, 0x03, 0x4C, 0x0F, 0xF9, 0x42, 0xA8, + 0x82, 0xFD, 0x34, 0xE8, 0x57, 0xF9, 0xD1, 0xA4, + 0xA3, 0x18, 0xB7, 0x2A, 0xE1, 0xA6, 0x78, 0x87 + }, + { + 0x2E, 0x7C, 0x71, 0x74, 0x62, 0x48, 0xD3, 0x0B, + 0x84, 0x01, 0xA6, 0x39, 0x1B, 0x7D, 0x49, 0xFD, + 0x98, 0x5A, 0xC2, 0x22, 0x27, 0x4B, 0x49, 0xE9, + 0x5D, 0x86, 0x71, 0xB6, 0x42, 0x10, 0x25, 0x37, + 0x94, 0x80, 0x1F, 0xD7, 0x92, 0x2C, 0x62, 0x30, + 0x4B, 0x91, 0x33, 0x48, 0x47, 0xA6, 0xDE, 0x39, + 0x9C, 0x29, 0x2F, 0xC3, 0x7E, 0x62, 0xA0, 0x69, + 0x14, 0x1D, 0xC4, 0x02, 0x03, 0x5D, 0xE3, 0xD7 + }, + { + 0x02, 0x57, 0x7C, 0x7E, 0x4B, 0x6E, 0xD6, 0x3B, + 0x67, 0xE4, 0xF8, 0xAC, 0x8E, 0x9A, 0xAF, 0xFF, + 0x8F, 0x8C, 0x04, 0x9E, 0x3D, 0x25, 0x52, 0xF0, + 0x56, 0x22, 0x59, 0x06, 0xFD, 0x18, 0xA9, 0xCE, + 0x62, 0x21, 0xCC, 0xEA, 0xE9, 0x0E, 0x52, 0xBB, + 0x78, 0xF8, 0x28, 0xB9, 0xD3, 0xFF, 0xD6, 0x7F, + 0xD4, 0x01, 0x44, 0x66, 0x4A, 0xEC, 0x38, 0x30, + 0x59, 0xFF, 0x93, 0x8B, 0x35, 0x87, 0x24, 0x51 + }, + { + 0xDF, 0x87, 0x23, 0x53, 0x62, 0xB6, 0xB2, 0x01, + 0x9E, 0x3C, 0xDB, 0x10, 0x5F, 0xDD, 0x9B, 0x3B, + 0x54, 0xB2, 0x49, 0x88, 0x5D, 0x8B, 0xCA, 0x70, + 0xC4, 0x48, 0xC5, 0x23, 0x5D, 0xCD, 0x11, 0x8D, + 0x17, 0x23, 0x4D, 0xC9, 0x01, 0xF9, 0x74, 0xF7, + 0x2B, 0x4B, 0xDB, 0x49, 0xDF, 0x4D, 0xC1, 0xB7, + 0x40, 0xE3, 0xB3, 0xC1, 0x4E, 0xBD, 0x7C, 0x4B, + 0xC0, 0x53, 0x44, 0x7F, 0x70, 0xE9, 0x07, 0x1A + }, + { + 0x42, 0x31, 0x2F, 0x27, 0x31, 0x09, 0xED, 0x24, + 0x9C, 0x82, 0x86, 0xAD, 0x1F, 0xCB, 0xBC, 0xD8, + 0x0A, 0x99, 0xFF, 0x85, 0x13, 0x6A, 0x1C, 0x11, + 0xAB, 0x5E, 0x56, 0xC4, 0xB7, 0x64, 0x0C, 0xA7, + 0xBD, 0xE4, 0x3B, 0xF9, 0x94, 0x36, 0x85, 0xF7, + 0x74, 0x7F, 0x93, 0x72, 0x1A, 0xE5, 0x22, 0x56, + 0xDB, 0x6E, 0x10, 0x7C, 0xAB, 0x52, 0xF8, 0xB1, + 0xB6, 0x2B, 0xFE, 0x47, 0x0B, 0x6E, 0x50, 0x7F + }, + { + 0x14, 0x4F, 0x30, 0x56, 0xBE, 0xB7, 0x72, 0x87, + 0x6E, 0xFB, 0xB4, 0x51, 0xE7, 0x42, 0x93, 0xAE, + 0xBE, 0xA5, 0x35, 0x54, 0xDD, 0xC1, 0x03, 0xB6, + 0xC0, 0xF6, 0x9F, 0xA6, 0xC8, 0x76, 0x10, 0x10, + 0x4C, 0x14, 0xEB, 0xB5, 0x1E, 0xA1, 0x1A, 0x7A, + 0x67, 0xF4, 0x1C, 0x89, 0x67, 0xBF, 0xDA, 0x2E, + 0x1A, 0x7F, 0x9B, 0x55, 0x07, 0x65, 0xC6, 0xE2, + 0xB2, 0xB2, 0x06, 0x86, 0x25, 0x80, 0x7E, 0x1B + }, + { + 0x92, 0x6D, 0x55, 0x19, 0xF0, 0xA6, 0x5F, 0x09, + 0xA7, 0x4A, 0x32, 0x47, 0x1D, 0x68, 0x8D, 0x51, + 0x69, 0xE8, 0xC0, 0x66, 0xC6, 0xA6, 0x82, 0x5B, + 0xC2, 0x35, 0x4B, 0x00, 0xD5, 0xE8, 0x8A, 0x05, + 0x15, 0x94, 0x3A, 0x00, 0x3C, 0x1B, 0xBD, 0x8F, + 0x03, 0x12, 0x53, 0x47, 0x48, 0x5A, 0x55, 0x66, + 0x4F, 0x2B, 0xCB, 0xB9, 0xF5, 0x6E, 0x22, 0x30, + 0xD7, 0x27, 0xE2, 0xD3, 0x3D, 0x8D, 0xD2, 0x9D + }, + { + 0x49, 0x8A, 0x4A, 0xA7, 0xEB, 0xEE, 0x66, 0xB4, + 0x79, 0x78, 0xE9, 0x44, 0x77, 0x8D, 0x3B, 0x74, + 0xF8, 0xAE, 0xA1, 0xD4, 0x88, 0x2D, 0xCF, 0x33, + 0x08, 0xE6, 0x94, 0x49, 0xCD, 0x8E, 0xC0, 0x86, + 0x87, 0x69, 0x7F, 0xAA, 0x88, 0xD8, 0x9D, 0xAB, + 0x24, 0x41, 0x39, 0x88, 0xB2, 0x37, 0x2B, 0xCD, + 0xFD, 0x42, 0xEA, 0xE9, 0xA0, 0x4E, 0x57, 0x8E, + 0x6F, 0x2E, 0x62, 0x8E, 0x9B, 0x09, 0xD9, 0x6F + }, + { + 0xC1, 0x39, 0x70, 0x7F, 0x83, 0xA7, 0x9F, 0xF8, + 0xBA, 0x36, 0x6D, 0x27, 0xE0, 0xE9, 0xDE, 0x3F, + 0xE9, 0x91, 0x8E, 0x92, 0xC4, 0x9F, 0x73, 0xC4, + 0x2C, 0x4B, 0x52, 0x1D, 0x8D, 0xE8, 0x27, 0x32, + 0xE8, 0xF4, 0xA5, 0x26, 0xF4, 0x09, 0x5D, 0x1F, + 0x9A, 0x86, 0xB5, 0xF5, 0x3B, 0x17, 0x05, 0x76, + 0xEE, 0x03, 0xF0, 0x8D, 0xE1, 0xD9, 0x04, 0x48, + 0x77, 0xCE, 0xF7, 0xFC, 0x20, 0xC0, 0x92, 0x8D + }, + { + 0xFE, 0x54, 0x97, 0xE2, 0x3E, 0xF0, 0x2B, 0xB3, + 0x32, 0x3A, 0x92, 0x28, 0x2F, 0x61, 0xE4, 0x3B, + 0xD1, 0x1E, 0xBF, 0x8D, 0x1D, 0x92, 0xB4, 0x5C, + 0x97, 0x60, 0x05, 0xCC, 0x3D, 0xF1, 0x64, 0x00, + 0xF7, 0x4B, 0xBA, 0xD4, 0x53, 0xFD, 0x02, 0xA2, + 0x63, 0x11, 0x0F, 0x98, 0x6E, 0xF2, 0x71, 0x4E, + 0xF9, 0xCD, 0x2C, 0xFF, 0x93, 0x20, 0xC8, 0x32, + 0xB4, 0x56, 0x7A, 0x90, 0xB9, 0x4F, 0x33, 0x9A + }, + { + 0xED, 0xAE, 0x4A, 0x0C, 0xB2, 0x43, 0x28, 0x8A, + 0x47, 0x5A, 0x3D, 0x93, 0x07, 0xF4, 0xA4, 0xE1, + 0x2C, 0xC1, 0xC1, 0xC6, 0xC6, 0x43, 0x17, 0x94, + 0xE2, 0xD7, 0x5B, 0xC0, 0x1A, 0xC2, 0x2C, 0x2F, + 0x51, 0xE3, 0xD7, 0xCD, 0x14, 0x4E, 0x19, 0x10, + 0x3E, 0x1F, 0x07, 0xE3, 0x09, 0xF4, 0x51, 0x66, + 0xA9, 0x98, 0x17, 0x52, 0x9C, 0x2B, 0x9D, 0xDA, + 0xAC, 0xCF, 0x41, 0xB2, 0xAB, 0x59, 0x53, 0x75 + }, + { + 0xAE, 0x19, 0x11, 0xB6, 0x94, 0xE5, 0xC1, 0x01, + 0xE9, 0xD6, 0xD4, 0x51, 0x26, 0x44, 0xB5, 0x64, + 0x17, 0xCF, 0x51, 0x8B, 0x01, 0xAA, 0x2F, 0x04, + 0xBA, 0xFA, 0x1E, 0x99, 0xC7, 0xBE, 0xF4, 0x38, + 0x10, 0xAF, 0x20, 0x66, 0xF2, 0x65, 0xEE, 0x7C, + 0x41, 0xC6, 0xAD, 0x51, 0x6E, 0x65, 0xC1, 0x88, + 0x20, 0x65, 0x8B, 0x04, 0xAC, 0xDD, 0x2E, 0xE4, + 0x3D, 0xA0, 0x90, 0xA4, 0x03, 0x4D, 0x0F, 0xF5 + }, + { + 0x5D, 0x26, 0x9B, 0xFF, 0x2B, 0x29, 0x04, 0x15, + 0x21, 0xA4, 0x71, 0x00, 0x3A, 0xC6, 0x6E, 0x06, + 0x8B, 0x9F, 0x7D, 0x61, 0x0C, 0xA3, 0x03, 0x5F, + 0x9C, 0x54, 0x3C, 0x4D, 0xFE, 0x22, 0xA9, 0x07, + 0xC0, 0x02, 0x01, 0xCA, 0x10, 0xDD, 0xA1, 0xE9, + 0x77, 0x2E, 0xBD, 0xCF, 0x7E, 0x09, 0x19, 0x5E, + 0x59, 0xB8, 0x59, 0x25, 0xA2, 0x0A, 0x9E, 0x18, + 0xE1, 0x37, 0xC3, 0x19, 0xAD, 0xC2, 0x8F, 0x9F + }, + { + 0x74, 0xF0, 0x06, 0xCA, 0xB2, 0x8C, 0x4D, 0xBE, + 0x67, 0xF0, 0xAA, 0xE8, 0x4B, 0xF2, 0xBE, 0x68, + 0x0C, 0x60, 0xD6, 0xCE, 0xE9, 0x14, 0x3D, 0x56, + 0x4C, 0x9B, 0xEF, 0x0B, 0x22, 0xEE, 0x41, 0x18, + 0x6F, 0x7C, 0x45, 0xA5, 0x1B, 0xA0, 0x7F, 0x4D, + 0xAE, 0xD4, 0x55, 0x9D, 0x94, 0xF1, 0xFE, 0x94, + 0xD6, 0x3E, 0xC7, 0x21, 0xF2, 0x6C, 0xF5, 0x3C, + 0x3B, 0x21, 0xA6, 0x5F, 0xF1, 0xB8, 0xB5, 0xE8 + }, + { + 0x79, 0x33, 0x9E, 0x7D, 0x7D, 0xE9, 0x13, 0x87, + 0x7B, 0x2B, 0x9B, 0x45, 0xB5, 0xEF, 0x02, 0x12, + 0xB5, 0xB9, 0x26, 0x89, 0x86, 0x72, 0x78, 0xA3, + 0x67, 0xE6, 0x00, 0xC6, 0x16, 0x9E, 0x81, 0x66, + 0xBB, 0x12, 0xE4, 0x4B, 0x21, 0x97, 0x68, 0x95, + 0x7E, 0x3F, 0x68, 0xDA, 0xF9, 0xEA, 0x8D, 0x99, + 0x96, 0x75, 0xA0, 0xDC, 0xBD, 0x3D, 0xF3, 0x2C, + 0xD2, 0x29, 0xD7, 0xFA, 0x31, 0xFA, 0x6C, 0x69 + }, + { + 0x64, 0x02, 0xBD, 0x9F, 0x45, 0xBE, 0xAC, 0x84, + 0xFD, 0x52, 0x84, 0x9F, 0x75, 0x66, 0xB6, 0x0F, + 0x25, 0x7A, 0x51, 0x7F, 0x6D, 0x75, 0xD3, 0xE3, + 0xBA, 0xE6, 0x8C, 0x01, 0xEE, 0xE1, 0xC0, 0x41, + 0x26, 0x6B, 0xA6, 0xD3, 0xB6, 0x3E, 0xCB, 0x27, + 0xE9, 0x10, 0x38, 0x81, 0x9E, 0x64, 0x3B, 0x52, + 0xAD, 0xE2, 0xAC, 0x0A, 0x26, 0x3A, 0x52, 0xC2, + 0xFB, 0xE3, 0x8A, 0xA9, 0x6E, 0xAA, 0x29, 0x49 + }, + { + 0x61, 0x34, 0x46, 0x7C, 0x9E, 0x06, 0x5C, 0x45, + 0x81, 0xEF, 0xFD, 0x9A, 0xDA, 0x87, 0x6F, 0x66, + 0xCD, 0x95, 0xD8, 0x0E, 0xDF, 0xDE, 0x75, 0xAA, + 0x59, 0x09, 0x0B, 0x6A, 0x86, 0x5A, 0xA8, 0xA3, + 0xAC, 0xAB, 0x0A, 0xBD, 0x06, 0x12, 0xAE, 0xC3, + 0xD3, 0xD8, 0xF7, 0xAA, 0x66, 0xEC, 0x0F, 0xED, + 0xAB, 0x61, 0x55, 0x8E, 0xC5, 0xC6, 0xAF, 0x8A, + 0x61, 0x7B, 0x1F, 0x35, 0x06, 0x11, 0x83, 0x6B + }, + { + 0xA0, 0x63, 0x1F, 0x93, 0x53, 0x9E, 0x10, 0xBC, + 0xBC, 0xD9, 0xA9, 0x14, 0x30, 0x23, 0x72, 0x3A, + 0xEE, 0x72, 0x27, 0xBD, 0xAF, 0x5F, 0xE3, 0xE9, + 0x74, 0x63, 0xBA, 0xA3, 0xA3, 0x7E, 0x46, 0x58, + 0x97, 0xA1, 0x66, 0x99, 0x1D, 0x44, 0x3E, 0x40, + 0x92, 0x8A, 0xD1, 0xAD, 0x27, 0x7D, 0x4D, 0xA0, + 0x51, 0xBE, 0xB8, 0xBF, 0xBF, 0x34, 0xCD, 0xFC, + 0x33, 0xE7, 0xEA, 0xCA, 0x93, 0x33, 0x80, 0x1C + }, + { + 0xB7, 0xBA, 0xBC, 0x89, 0xBD, 0x15, 0xCF, 0x08, + 0xD5, 0x14, 0x8E, 0x35, 0xA1, 0xE4, 0x3C, 0x2B, + 0x96, 0x6F, 0xA8, 0x5D, 0xA1, 0xC3, 0xFB, 0xCC, + 0x5C, 0x68, 0xAB, 0xDD, 0x12, 0x2F, 0xF9, 0xC8, + 0x7E, 0xB9, 0x78, 0x0D, 0xA7, 0xD4, 0xEC, 0xF5, + 0x09, 0x39, 0x4A, 0x30, 0x0E, 0xD6, 0xD7, 0x91, + 0x8D, 0x9A, 0x29, 0x86, 0x02, 0x3E, 0x92, 0x5C, + 0x26, 0x78, 0x8A, 0x4F, 0x36, 0x13, 0xC1, 0x6B + }, + { + 0x2D, 0x2A, 0x69, 0xFE, 0xD6, 0xE8, 0x6F, 0x1C, + 0xA0, 0x2F, 0x81, 0xEF, 0xE1, 0x5B, 0x54, 0x53, + 0x37, 0xEE, 0x17, 0x46, 0x46, 0xFB, 0xD2, 0x0D, + 0xBF, 0x46, 0xC0, 0x72, 0xB5, 0xBF, 0x2C, 0x40, + 0x6D, 0x11, 0x1E, 0xCE, 0x3A, 0xB7, 0x98, 0x02, + 0x5C, 0xFF, 0xDF, 0xD5, 0xA9, 0xFA, 0x36, 0x3F, + 0x1E, 0xB4, 0x03, 0x84, 0x0C, 0xB8, 0xA5, 0xE9, + 0xF8, 0xCD, 0x29, 0xB7, 0x6C, 0x62, 0xE8, 0x08 + }, + { + 0x4D, 0x70, 0xAC, 0x48, 0x0D, 0x10, 0xD4, 0x13, + 0x6F, 0xC6, 0x37, 0x81, 0xAE, 0xD0, 0x81, 0x9C, + 0x7B, 0x74, 0x61, 0x9A, 0x55, 0x7A, 0xF9, 0x75, + 0x06, 0xD8, 0xA8, 0xAB, 0xA2, 0x84, 0x16, 0x41, + 0x84, 0xB8, 0xC2, 0xBA, 0x2C, 0xCB, 0x3C, 0x52, + 0xEE, 0x87, 0x7F, 0xE5, 0x13, 0x32, 0x8E, 0x39, + 0xE3, 0x32, 0xE7, 0x6B, 0x4D, 0x70, 0x15, 0x45, + 0xA5, 0xA4, 0x48, 0x88, 0xF2, 0x3C, 0x58, 0xBD + }, + { + 0x49, 0x7D, 0xCE, 0xED, 0x08, 0x5C, 0x78, 0xFC, + 0x8E, 0xFE, 0xE6, 0x27, 0xA1, 0x48, 0x2C, 0xD5, + 0xD8, 0xCF, 0x95, 0x77, 0x6A, 0x2C, 0x5C, 0x37, + 0x61, 0x2F, 0x47, 0x15, 0x28, 0x5B, 0xA9, 0x1C, + 0x31, 0x63, 0x55, 0x6D, 0xD3, 0x1A, 0x2A, 0x99, + 0x1C, 0xE9, 0x9A, 0x55, 0x18, 0x35, 0xC5, 0xD6, + 0x76, 0x8D, 0xA8, 0x52, 0x27, 0x61, 0x32, 0xBD, + 0xFA, 0x07, 0x2C, 0x81, 0x52, 0x4D, 0x22, 0x5D + }, + { + 0x7B, 0xB5, 0x26, 0xA7, 0x8B, 0xEA, 0xEB, 0x06, + 0x48, 0x59, 0xEE, 0xBB, 0xCE, 0xF7, 0x62, 0x8B, + 0x68, 0x58, 0xBB, 0xA9, 0x7F, 0x7C, 0xE6, 0x18, + 0xFA, 0x95, 0xC9, 0x6C, 0x6E, 0x16, 0xDE, 0xC1, + 0x50, 0xFF, 0xA4, 0x1E, 0xBB, 0x3D, 0x54, 0x73, + 0x9A, 0xA5, 0xC0, 0xEC, 0x18, 0x1F, 0x74, 0x73, + 0xF7, 0x9A, 0xAA, 0xE4, 0xFB, 0x2D, 0x3C, 0x24, + 0x43, 0xA3, 0x5E, 0x92, 0x7B, 0xC4, 0x6C, 0xDD + }, + { + 0xB1, 0xE9, 0x99, 0xE0, 0xD6, 0x8A, 0x96, 0x6A, + 0xCD, 0x6C, 0x3E, 0x32, 0xBD, 0xD8, 0x82, 0x3D, + 0x43, 0xE3, 0x0F, 0x33, 0x12, 0x26, 0xA1, 0xD5, + 0x41, 0xA2, 0x6A, 0xB1, 0xB9, 0x37, 0x7A, 0x09, + 0xB9, 0xDD, 0x8E, 0x3A, 0xEF, 0xAE, 0x47, 0x8F, + 0x98, 0xC8, 0x8B, 0x88, 0xEF, 0xF6, 0xBB, 0x77, + 0x28, 0xCE, 0xD9, 0xF5, 0x93, 0x0C, 0xE5, 0x5B, + 0xA6, 0x65, 0x96, 0xBD, 0xAB, 0xD9, 0x9A, 0x6B + }, + { + 0x58, 0xA5, 0x90, 0x26, 0xB4, 0xCC, 0xBB, 0xBA, + 0x4B, 0x70, 0x9F, 0xA3, 0x2F, 0xE4, 0x97, 0x8C, + 0x22, 0x42, 0x6C, 0xF6, 0x9D, 0xFD, 0xA2, 0x8F, + 0x80, 0x04, 0x3D, 0x67, 0x43, 0xB4, 0x59, 0xD0, + 0x99, 0x94, 0xF7, 0x9A, 0x23, 0xB0, 0xBF, 0xA9, + 0x13, 0x17, 0x66, 0x48, 0x02, 0x0C, 0x8F, 0xF2, + 0x72, 0x74, 0x8C, 0x2A, 0x91, 0xF0, 0x23, 0xF6, + 0xDF, 0x4A, 0x79, 0x93, 0x3C, 0xA9, 0x20, 0x6D + }, + { + 0x57, 0x18, 0x08, 0x21, 0xAA, 0xC4, 0x1B, 0x7B, + 0x39, 0xEC, 0x7A, 0xC1, 0xDA, 0xEC, 0xE7, 0x7D, + 0x3E, 0xE8, 0x56, 0x56, 0xFA, 0x11, 0x37, 0x3E, + 0xD1, 0x10, 0x69, 0xE3, 0xEE, 0x14, 0x68, 0xE5, + 0xD1, 0x58, 0x5D, 0x4C, 0x4B, 0x58, 0xD0, 0xC9, + 0xA5, 0x61, 0xEA, 0xF3, 0xFE, 0x63, 0x86, 0x1C, + 0x01, 0xB2, 0x83, 0xAD, 0x49, 0x91, 0x15, 0x30, + 0x15, 0xE7, 0x63, 0xB2, 0xB3, 0xB9, 0x7C, 0x51 + }, + { + 0x03, 0x28, 0x47, 0xB0, 0xCB, 0x34, 0x98, 0x0C, + 0x62, 0x32, 0x64, 0x37, 0x64, 0x26, 0xE5, 0xCA, + 0xE2, 0xFF, 0xEE, 0xF8, 0x77, 0x76, 0xD3, 0x59, + 0xC9, 0x13, 0x97, 0x3F, 0xED, 0x62, 0xD9, 0xD8, + 0x41, 0xAF, 0x3C, 0xB2, 0x49, 0x9F, 0x65, 0x45, + 0x67, 0x67, 0x6B, 0x27, 0xE7, 0x3E, 0x31, 0x36, + 0x99, 0xE9, 0x92, 0x6B, 0x4B, 0x54, 0x7E, 0x23, + 0x27, 0x63, 0x23, 0x44, 0xD3, 0xA1, 0xF7, 0xBB + }, + { + 0x30, 0xF2, 0x71, 0x08, 0xC6, 0x28, 0x35, 0xE5, + 0x9F, 0x69, 0x69, 0x31, 0x1F, 0x3D, 0x7D, 0x20, + 0x2F, 0x11, 0x1C, 0xB5, 0x86, 0x29, 0xEB, 0x1D, + 0xA3, 0x72, 0x5D, 0xD8, 0xF0, 0xDD, 0x79, 0x64, + 0xF5, 0x78, 0x41, 0x50, 0x02, 0x6D, 0x1E, 0x06, + 0x12, 0xBF, 0xCF, 0xD5, 0x08, 0xE7, 0x93, 0xDE, + 0xBC, 0x10, 0x32, 0xA7, 0x23, 0xF4, 0x31, 0x28, + 0x48, 0x42, 0x87, 0x65, 0x82, 0xFE, 0xA6, 0x9B + }, + { + 0xBD, 0x7D, 0xAE, 0x2C, 0x09, 0x63, 0xAF, 0x10, + 0xCD, 0x04, 0x9D, 0xB4, 0x0E, 0xDB, 0x3F, 0x2B, + 0x3B, 0xE9, 0xFD, 0x67, 0x15, 0xC2, 0xDA, 0xCE, + 0xFE, 0x34, 0xE2, 0xC3, 0x07, 0xE7, 0x07, 0x5E, + 0x09, 0x2F, 0x8F, 0xE7, 0x4F, 0xDA, 0x06, 0x07, + 0x4C, 0x03, 0xF6, 0x6B, 0x3A, 0xDE, 0xEF, 0x4B, + 0xB6, 0x92, 0x52, 0x71, 0x68, 0x80, 0x01, 0xDF, + 0x00, 0x73, 0xCF, 0x91, 0x70, 0x71, 0x40, 0x7F + }, + { + 0x94, 0xDD, 0xCD, 0x9C, 0x37, 0xAC, 0x4B, 0xC3, + 0x59, 0x24, 0x8F, 0x71, 0xEE, 0xB1, 0xD7, 0xE7, + 0x6C, 0x4C, 0xDE, 0x51, 0x34, 0xDC, 0x0B, 0xB2, + 0x57, 0x00, 0x18, 0xE1, 0x0B, 0x3B, 0x52, 0x5F, + 0x92, 0xCB, 0xFA, 0x3D, 0x19, 0x1B, 0xA1, 0xB7, + 0xE9, 0xB1, 0x14, 0x14, 0x9B, 0x4E, 0xA4, 0x90, + 0x9A, 0x3B, 0xEC, 0xDF, 0xA8, 0x87, 0xD3, 0xDB, + 0xF5, 0x3F, 0x57, 0x4B, 0xBF, 0x33, 0x8B, 0x3A + }, + { + 0x8F, 0x9F, 0xF3, 0x8C, 0x8E, 0x40, 0xDE, 0x52, + 0xC3, 0xDC, 0x2C, 0xB2, 0xC6, 0xFD, 0x25, 0x25, + 0x46, 0x54, 0x04, 0xD4, 0x64, 0x21, 0x2F, 0xEF, + 0x7A, 0xD0, 0x9B, 0x09, 0xFB, 0xC8, 0x7F, 0x27, + 0xD5, 0xC6, 0x26, 0x32, 0x4B, 0x1D, 0x9E, 0xCD, + 0x4A, 0xD8, 0x71, 0x96, 0xEE, 0x2D, 0xA8, 0x30, + 0x3D, 0x2E, 0xD4, 0x96, 0xDB, 0xB4, 0xA4, 0xBD, + 0x76, 0xBF, 0x32, 0x5B, 0xD1, 0x8F, 0xFC, 0x7A + }, + { + 0x72, 0xBE, 0xB0, 0xE6, 0x3F, 0xDD, 0x31, 0x0D, + 0xFE, 0x77, 0x15, 0xB7, 0xFB, 0xD1, 0xF1, 0x42, + 0xAD, 0xA9, 0x87, 0x79, 0x59, 0x25, 0x3A, 0xA8, + 0xB8, 0xF6, 0x48, 0x0B, 0xEB, 0xDC, 0x50, 0x6D, + 0xB4, 0x50, 0x51, 0x00, 0x8B, 0xFC, 0xBC, 0x00, + 0xFB, 0x70, 0x2A, 0x73, 0x0D, 0xDD, 0xC3, 0xA3, + 0x0E, 0xA4, 0xC7, 0xAA, 0x38, 0x6E, 0xF4, 0xA7, + 0x48, 0x36, 0x8B, 0x2D, 0xBF, 0x10, 0x0D, 0x5C + }, + { + 0xF8, 0xF7, 0xD4, 0x80, 0xB5, 0xD4, 0xB6, 0x1C, + 0x92, 0xCE, 0x0B, 0xD8, 0xB3, 0x61, 0xC3, 0xAC, + 0x28, 0x01, 0x17, 0xDB, 0x5B, 0x2A, 0xDE, 0x00, + 0x3A, 0xF2, 0x5B, 0x78, 0xB6, 0x92, 0x5F, 0x73, + 0x74, 0x44, 0xE4, 0x6D, 0x00, 0xC2, 0xEE, 0x97, + 0xC2, 0x73, 0x31, 0x5D, 0xFA, 0xB2, 0x4D, 0x10, + 0x29, 0x1B, 0x40, 0x14, 0xDD, 0xF9, 0x3F, 0x17, + 0x4A, 0x7D, 0x01, 0x7C, 0x21, 0xCD, 0x62, 0xE4 + }, + { + 0xB0, 0x32, 0x55, 0xB5, 0x17, 0x23, 0x6C, 0x2C, + 0xC7, 0xFC, 0xEC, 0x25, 0x62, 0x0D, 0x6C, 0x94, + 0x92, 0xE9, 0x89, 0x76, 0x26, 0x2F, 0xD5, 0xA1, + 0x0E, 0xDF, 0x05, 0xEE, 0xAF, 0x13, 0x89, 0x39, + 0xD5, 0x86, 0x8F, 0x9A, 0xD5, 0x50, 0xDA, 0xC6, + 0x6D, 0x2F, 0x6E, 0x4F, 0x6F, 0x46, 0x73, 0x7F, + 0xFC, 0x05, 0xDC, 0xA1, 0xA1, 0xCF, 0xC0, 0xE2, + 0x4C, 0x13, 0x6C, 0x5A, 0xA7, 0xC5, 0xAA, 0xC1 + }, + { + 0xEA, 0xB1, 0x40, 0x44, 0x1C, 0x3F, 0x5E, 0x2E, + 0x8D, 0x27, 0x69, 0x74, 0x3E, 0xD1, 0x2D, 0x1B, + 0xC5, 0x48, 0x93, 0xEE, 0xA9, 0xAE, 0x17, 0x49, + 0x0A, 0x5B, 0x58, 0xD4, 0xD5, 0x70, 0xD6, 0x1E, + 0xD9, 0xC1, 0x7C, 0x3E, 0x81, 0xAD, 0x4A, 0xCA, + 0x16, 0xEB, 0xFF, 0xAB, 0xB3, 0x1D, 0x58, 0x53, + 0xE3, 0x93, 0xA7, 0x88, 0x19, 0x41, 0x21, 0xED, + 0x1A, 0x2A, 0xE4, 0x08, 0x56, 0x57, 0xEE, 0x75 + }, + { + 0x69, 0xEC, 0x60, 0xF6, 0x1F, 0xF1, 0xC5, 0x09, + 0xA1, 0x20, 0xD8, 0x49, 0xA4, 0x87, 0x0C, 0x61, + 0x0B, 0xDD, 0xD0, 0x01, 0x45, 0x5C, 0x3F, 0x1F, + 0xBD, 0xB0, 0xE0, 0x7F, 0x35, 0x55, 0x84, 0x45, + 0xC1, 0xE1, 0xFC, 0x43, 0xEE, 0x70, 0x15, 0xD2, + 0xBB, 0x35, 0xC4, 0x17, 0xA7, 0x2D, 0x2B, 0xFD, + 0xB3, 0x53, 0x67, 0xE3, 0x99, 0xEC, 0x9A, 0x35, + 0xAF, 0xAC, 0x4E, 0xA8, 0x16, 0xEA, 0x2F, 0x47 + }, + { + 0xAD, 0x1E, 0x74, 0xF4, 0x91, 0x6E, 0x31, 0x6E, + 0x95, 0x61, 0x65, 0x5E, 0x59, 0x18, 0xB9, 0xCC, + 0xDC, 0x2C, 0x89, 0x33, 0xAB, 0x94, 0x11, 0xF0, + 0x05, 0x96, 0x4D, 0xA7, 0x10, 0x5F, 0x6F, 0x27, + 0x45, 0x7E, 0x27, 0x90, 0xC5, 0x2A, 0x5D, 0x06, + 0xA4, 0x81, 0x75, 0x08, 0xA5, 0xA2, 0x29, 0x46, + 0x11, 0xC0, 0xAF, 0xB6, 0xC5, 0xA2, 0x83, 0x12, + 0x32, 0xA7, 0x3C, 0x37, 0xA6, 0x65, 0xA5, 0x7F + }, + { + 0x4F, 0xAA, 0x99, 0x1B, 0x58, 0x5B, 0x7C, 0x5C, + 0x96, 0x0D, 0x4C, 0x22, 0x1C, 0x44, 0x1D, 0xDD, + 0x51, 0x88, 0x69, 0x56, 0x94, 0x17, 0xA8, 0xFE, + 0xDA, 0xF2, 0x00, 0x4E, 0x1E, 0x36, 0x44, 0xAD, + 0xF3, 0x8E, 0x1C, 0x54, 0xD1, 0x99, 0x7B, 0xF4, + 0x5E, 0x9E, 0x88, 0x3C, 0x4B, 0xB7, 0x95, 0xF0, + 0x9F, 0x8F, 0x1D, 0x3A, 0xA3, 0x9D, 0x36, 0x90, + 0x20, 0x1D, 0xB1, 0x99, 0xA5, 0x13, 0x84, 0x37 + }, + { + 0x5E, 0xF0, 0xA0, 0x7B, 0xF8, 0x57, 0xBC, 0xCD, + 0x49, 0x10, 0x34, 0x16, 0x88, 0x76, 0x0A, 0x75, + 0x50, 0xF1, 0x5F, 0xC0, 0xB1, 0xA9, 0xCE, 0x18, + 0xA2, 0xE8, 0x59, 0xD0, 0x0A, 0x39, 0xAA, 0xC1, + 0xF1, 0xA3, 0xF4, 0x7A, 0xAF, 0x5B, 0x6A, 0xE3, + 0xCD, 0x28, 0xA1, 0xE1, 0x18, 0x61, 0xCE, 0x70, + 0x9B, 0x67, 0x3A, 0x5E, 0x8E, 0x58, 0x09, 0x01, + 0xA3, 0x4C, 0xF4, 0x8C, 0xED, 0xE4, 0x07, 0x7C + }, + { + 0xC0, 0x6D, 0x52, 0xC5, 0x1F, 0x89, 0xA8, 0xAD, + 0x8D, 0xC2, 0x41, 0xAC, 0xAF, 0x97, 0x96, 0x61, + 0x75, 0x55, 0x8C, 0x47, 0x80, 0x1D, 0x09, 0xA4, + 0xFE, 0xD4, 0x7D, 0x51, 0x26, 0x90, 0x38, 0x16, + 0x2F, 0xA1, 0x4D, 0x8D, 0x88, 0x11, 0x4F, 0x70, + 0x60, 0xDF, 0x65, 0x16, 0x79, 0x99, 0xAF, 0x67, + 0x73, 0xCF, 0x09, 0xA3, 0x01, 0x7E, 0x5E, 0x82, + 0x54, 0xD3, 0x01, 0x46, 0x34, 0xA8, 0xF4, 0x28 + }, + { + 0x3C, 0x1E, 0x39, 0x1B, 0xB4, 0x3D, 0xF0, 0x55, + 0x40, 0x24, 0xFE, 0x43, 0x26, 0xF5, 0x6C, 0xE0, + 0x4D, 0xE5, 0xF2, 0x3D, 0xA6, 0xEB, 0x01, 0x1C, + 0x26, 0x1D, 0xF1, 0x5D, 0xEE, 0xCA, 0xE1, 0x1C, + 0xA5, 0x25, 0xF2, 0x15, 0x16, 0xAA, 0xB6, 0x43, + 0x8F, 0x1A, 0x79, 0xE5, 0xE1, 0x4B, 0x31, 0xFB, + 0x55, 0xB3, 0xE8, 0x50, 0x47, 0x3A, 0x4A, 0x13, + 0x0D, 0x6C, 0x20, 0x6B, 0x7C, 0x41, 0x8D, 0xF5 + }, + { + 0xDD, 0xCC, 0x6E, 0xC6, 0x1D, 0xAF, 0x7A, 0x63, + 0xE0, 0x55, 0x2A, 0x14, 0x71, 0xE6, 0x01, 0x9B, + 0x7C, 0x0E, 0x58, 0x3E, 0xEE, 0x89, 0x0D, 0x5A, + 0x51, 0x03, 0x01, 0x68, 0xA2, 0xC5, 0x0B, 0x7E, + 0x20, 0x79, 0xE5, 0xEC, 0x9B, 0xE3, 0x73, 0xA7, + 0x59, 0xB7, 0x83, 0x6F, 0xE2, 0x5B, 0xF5, 0x07, + 0xF3, 0x86, 0xD3, 0xC2, 0x28, 0x0A, 0xA8, 0xCA, + 0x6A, 0x08, 0xF6, 0xA3, 0x20, 0x5B, 0xE2, 0x9E + }, + { + 0x79, 0x14, 0x4F, 0x2B, 0x41, 0xFA, 0xE8, 0xE5, + 0xBE, 0xFB, 0xE9, 0xE9, 0x3C, 0x33, 0xA4, 0xA2, + 0x8A, 0x7C, 0x2E, 0x0F, 0xAF, 0xFE, 0x57, 0x7C, + 0x6F, 0xE6, 0xB0, 0x56, 0xE4, 0xC2, 0x21, 0x27, + 0xEF, 0x0E, 0x12, 0x28, 0x61, 0x99, 0xE1, 0x12, + 0xB9, 0x80, 0x1E, 0x71, 0xC5, 0xB5, 0x1D, 0x7C, + 0x09, 0xD6, 0x6B, 0x32, 0x52, 0xAF, 0x7E, 0x3E, + 0xA3, 0x98, 0x2D, 0x2E, 0xCB, 0x1E, 0x3F, 0xEA + }, + { + 0x05, 0x10, 0xD5, 0xE3, 0xB5, 0xF4, 0xBE, 0x52, + 0x56, 0x7B, 0x2F, 0x2C, 0x71, 0x8E, 0xA3, 0xAF, + 0xBC, 0xAC, 0x92, 0xB2, 0x54, 0xC2, 0xE8, 0xF8, + 0xCE, 0x6E, 0xC0, 0xF3, 0xCC, 0x78, 0x48, 0x3D, + 0xF6, 0xD5, 0x7A, 0x2C, 0xA8, 0x1B, 0x40, 0x64, + 0x4D, 0x77, 0x72, 0x7E, 0xD8, 0xF1, 0x2E, 0x94, + 0xFC, 0xEE, 0x20, 0xEA, 0xFE, 0x76, 0x09, 0x4D, + 0xE5, 0x93, 0x3E, 0x30, 0x06, 0xCA, 0xA1, 0xA5 + }, + { + 0x5F, 0x88, 0x5A, 0xDD, 0x1B, 0x4A, 0x05, 0xB2, + 0x58, 0xAE, 0xF8, 0xE7, 0x5C, 0x0D, 0xB1, 0x4E, + 0x6F, 0x80, 0xE1, 0xF5, 0x5B, 0x08, 0xF1, 0xBA, + 0xC2, 0x47, 0x4F, 0x50, 0x91, 0x8B, 0x62, 0xD7, + 0x6D, 0xC6, 0xB5, 0x55, 0x39, 0x34, 0x6C, 0x6A, + 0xB1, 0xBB, 0x55, 0x7B, 0x77, 0x12, 0x96, 0xA1, + 0xBD, 0x5B, 0x6B, 0x6D, 0x3B, 0x7C, 0x6D, 0x97, + 0xD7, 0x97, 0x7C, 0x68, 0xD9, 0x5B, 0x37, 0x24 + }, + { + 0xF2, 0x59, 0x0A, 0x35, 0x31, 0xA0, 0x69, 0xA0, + 0x6E, 0x47, 0x8E, 0x06, 0x67, 0xC3, 0x49, 0x6A, + 0xB1, 0x41, 0xC7, 0x80, 0x38, 0x6C, 0x14, 0xD4, + 0x48, 0x95, 0xF3, 0x68, 0x06, 0xA8, 0x78, 0xFD, + 0xFA, 0xEA, 0x3A, 0x33, 0x16, 0xBF, 0x3C, 0x46, + 0x3B, 0x5D, 0xD5, 0x33, 0x0A, 0x6D, 0x06, 0xBD, + 0xAA, 0x2F, 0x53, 0xCA, 0x7B, 0xBF, 0xC2, 0xDD, + 0xD7, 0x67, 0x7B, 0x7E, 0x49, 0x1D, 0xA0, 0xE7 + }, + { + 0x52, 0xFD, 0x44, 0x00, 0x44, 0xCB, 0x7D, 0x3C, + 0x86, 0x13, 0x9E, 0x32, 0xCC, 0xFD, 0xF6, 0x7D, + 0x35, 0x5B, 0xFB, 0xB3, 0x42, 0x02, 0x4A, 0xB5, + 0x05, 0x35, 0x82, 0xCA, 0xFC, 0x6E, 0x90, 0xBF, + 0x86, 0xBE, 0x0D, 0x87, 0x46, 0x16, 0xBA, 0x9F, + 0xE6, 0x55, 0xCF, 0x3C, 0x32, 0xB7, 0xC9, 0xF0, + 0x1E, 0xC0, 0x21, 0x1B, 0x46, 0x1C, 0x5F, 0x1A, + 0x8C, 0xCD, 0xDE, 0xBB, 0x3A, 0xC9, 0x35, 0x79 + }, + { + 0x55, 0x38, 0xC0, 0xDB, 0xD7, 0x8E, 0xCB, 0x5D, + 0x87, 0x43, 0x26, 0xBF, 0x5E, 0x84, 0x4C, 0xF4, + 0xEB, 0x52, 0x72, 0x55, 0x84, 0x5B, 0xC4, 0xC3, + 0xE9, 0x2A, 0xDA, 0x1D, 0x59, 0xAB, 0xA4, 0x5E, + 0x61, 0x2A, 0x88, 0x31, 0x23, 0x19, 0x18, 0x53, + 0x7A, 0x42, 0xCA, 0x59, 0xC0, 0x93, 0xD6, 0x79, + 0xCA, 0x14, 0x5D, 0xE0, 0x1E, 0x9D, 0xE5, 0x53, + 0xC1, 0x9A, 0xF6, 0x8B, 0xA0, 0x5E, 0x63, 0x71 + }, + { + 0x13, 0xFB, 0xDB, 0x2C, 0x0E, 0x7C, 0x99, 0x6A, + 0xE9, 0x44, 0x1D, 0x03, 0x25, 0x98, 0x52, 0xD9, + 0x79, 0x9D, 0x94, 0xC4, 0x34, 0x01, 0xF2, 0xE1, + 0x68, 0xC7, 0x9F, 0x61, 0x52, 0x32, 0x14, 0x34, + 0xF4, 0xA2, 0x3D, 0x14, 0x55, 0x48, 0xE3, 0x8E, + 0x47, 0xAA, 0x6E, 0x02, 0x12, 0x05, 0x3A, 0xAE, + 0x13, 0x15, 0x17, 0xE9, 0x9E, 0x68, 0xE8, 0x36, + 0x44, 0xAD, 0x08, 0x4D, 0xE0, 0xB3, 0xB0, 0x71 + }, + { + 0x07, 0xB4, 0x9B, 0x24, 0x9C, 0xAE, 0xC2, 0xD8, + 0x5B, 0xBF, 0x6A, 0x4F, 0xB5, 0x3E, 0x6F, 0xC8, + 0xD3, 0xB0, 0xEF, 0xCB, 0xF9, 0x40, 0x91, 0x7C, + 0x39, 0x50, 0xAC, 0x21, 0xC5, 0x91, 0x69, 0xF1, + 0x54, 0xA1, 0x03, 0x49, 0xA0, 0x7A, 0x20, 0x5C, + 0x5A, 0xFF, 0x8D, 0xB1, 0xAE, 0xC4, 0x7C, 0x43, + 0x23, 0xC5, 0xED, 0xB2, 0x62, 0xCC, 0xF3, 0xF2, + 0xA7, 0xF7, 0xEC, 0x3F, 0xF1, 0xC1, 0x81, 0x35 + }, + { + 0x8F, 0x55, 0x53, 0xE6, 0x48, 0x52, 0x31, 0x36, + 0xFA, 0xD1, 0x09, 0x12, 0xE3, 0x4A, 0xAE, 0xE0, + 0xD1, 0x47, 0x7A, 0x88, 0x6C, 0xCC, 0x28, 0xD2, + 0xAE, 0x65, 0x27, 0xEB, 0xAD, 0x63, 0xD5, 0x2C, + 0x4A, 0x69, 0x53, 0xED, 0x22, 0x4B, 0x1D, 0xDB, + 0x11, 0x47, 0x82, 0x69, 0x22, 0xB9, 0x12, 0x51, + 0xF8, 0xF6, 0xB5, 0x50, 0x46, 0xE3, 0x57, 0x03, + 0x4C, 0x56, 0x68, 0xA5, 0x54, 0xA2, 0xCC, 0xE6 + }, + { + 0xDC, 0x57, 0x7E, 0xDB, 0x06, 0x9F, 0x5F, 0xF9, + 0x5C, 0xBE, 0xCB, 0x43, 0xFC, 0x4F, 0xA8, 0x97, + 0x80, 0x48, 0x47, 0xBD, 0xEF, 0xD1, 0xD1, 0x4A, + 0xBD, 0xBB, 0xF4, 0x71, 0xAD, 0x97, 0x52, 0xF2, + 0xBA, 0xC0, 0x03, 0x70, 0x16, 0x42, 0x7A, 0xBC, + 0x37, 0x94, 0xF7, 0x5A, 0xB1, 0x85, 0x00, 0xEC, + 0x55, 0xA7, 0x83, 0x2D, 0x99, 0xE1, 0x65, 0xFF, + 0x95, 0x04, 0x45, 0x9A, 0xA2, 0xBA, 0x33, 0x3E + }, + { + 0x25, 0x0E, 0xD0, 0x2E, 0x8F, 0x2E, 0x44, 0x75, + 0x1B, 0x88, 0xD6, 0xEE, 0x09, 0x3D, 0x75, 0xEE, + 0xE0, 0x53, 0x4A, 0x73, 0x3B, 0xCD, 0x06, 0x1E, + 0xF6, 0xF0, 0x71, 0x5F, 0x34, 0x02, 0x38, 0x53, + 0x29, 0xC3, 0x99, 0x9E, 0x28, 0x5F, 0xAE, 0x71, + 0x1C, 0x9C, 0xF5, 0x02, 0x77, 0x09, 0x61, 0x01, + 0x23, 0x6B, 0x52, 0x10, 0x1D, 0x40, 0xF3, 0x58, + 0x91, 0x32, 0xCE, 0x46, 0x55, 0xDB, 0xB0, 0x5F + }, + { + 0xFB, 0x11, 0x24, 0x67, 0xEF, 0x14, 0xE4, 0x7A, + 0x72, 0x61, 0x41, 0x3A, 0x2A, 0x1A, 0x01, 0x45, + 0x1A, 0x0E, 0xF2, 0x09, 0x8A, 0x75, 0x39, 0xAF, + 0xEF, 0xAA, 0x7A, 0x31, 0xF9, 0xED, 0x0C, 0xDD, + 0x39, 0x30, 0x32, 0xAE, 0x08, 0x28, 0x6D, 0xF4, + 0x40, 0xD7, 0x9C, 0x28, 0x56, 0x89, 0x5F, 0xEA, + 0x98, 0xA5, 0xFC, 0x5E, 0x74, 0x57, 0xAD, 0x23, + 0xAF, 0xE8, 0xD5, 0x7C, 0xB3, 0xBF, 0x62, 0x5C + }, + { + 0x9F, 0xA4, 0xAE, 0xDE, 0x8F, 0xD4, 0x7D, 0x97, + 0x31, 0x8C, 0x46, 0x0D, 0x45, 0x10, 0xDA, 0x52, + 0x8E, 0x46, 0x5E, 0x9C, 0x21, 0x2C, 0x3C, 0xC7, + 0x01, 0xFA, 0x4D, 0xC3, 0x5F, 0xB4, 0xE4, 0x60, + 0x99, 0x59, 0x03, 0x45, 0x28, 0x50, 0xB8, 0x22, + 0x9D, 0x35, 0xA7, 0x18, 0xD8, 0x38, 0xDC, 0xA9, + 0xA8, 0xCB, 0x99, 0xCB, 0x49, 0x1F, 0x87, 0xFA, + 0xF7, 0xB1, 0xE5, 0x0D, 0x22, 0x82, 0xA2, 0x64 + }, + { + 0xA3, 0x0B, 0xC3, 0x44, 0x41, 0xE6, 0x12, 0x15, + 0xD1, 0xCE, 0xCE, 0xB4, 0xAE, 0x2F, 0xB9, 0xC2, + 0x15, 0x10, 0xC4, 0x37, 0x3E, 0x5D, 0x3F, 0x36, + 0x9C, 0xD9, 0x2D, 0x33, 0x97, 0x33, 0xBD, 0x2D, + 0x10, 0xCF, 0x24, 0xB2, 0x26, 0x33, 0x51, 0x24, + 0xB6, 0xA8, 0xEB, 0x75, 0x76, 0x29, 0x90, 0x02, + 0xC1, 0x99, 0xF9, 0x2D, 0x7D, 0x08, 0x5D, 0xE3, + 0x73, 0x07, 0xA0, 0x64, 0x1A, 0xB2, 0x70, 0xDB + }, + { + 0x49, 0xBD, 0xCB, 0xB2, 0xF5, 0xDB, 0x31, 0xA6, + 0xF2, 0x04, 0x80, 0x04, 0x3E, 0xDA, 0x7A, 0x50, + 0xD9, 0x03, 0x36, 0xA7, 0x74, 0x9E, 0x02, 0x37, + 0x60, 0xAE, 0x91, 0x84, 0xB6, 0xF8, 0x60, 0x24, + 0x9C, 0xE9, 0x13, 0x16, 0xA0, 0x8B, 0x9D, 0x4B, + 0xF8, 0xFA, 0x49, 0xA7, 0x22, 0x9D, 0x5F, 0x0E, + 0xA3, 0x87, 0x5D, 0x0C, 0x2A, 0xF9, 0xE2, 0x4E, + 0x9B, 0x1E, 0x03, 0x32, 0x83, 0x39, 0x66, 0x13 + }, + { + 0x8D, 0x1B, 0xAB, 0x49, 0xE7, 0xFA, 0x9D, 0xCD, + 0x1A, 0xE8, 0x86, 0x16, 0xEF, 0x9A, 0x34, 0x90, + 0xFB, 0xC0, 0x02, 0xC4, 0xAE, 0x25, 0xC9, 0xCE, + 0xF5, 0xB6, 0xBF, 0x10, 0x52, 0xC3, 0x40, 0x3F, + 0x84, 0xFD, 0x80, 0x40, 0xA9, 0x13, 0xEE, 0xFD, + 0xEC, 0x61, 0x26, 0xE4, 0xE5, 0x14, 0x00, 0x59, + 0xC0, 0xA4, 0x66, 0x86, 0x8B, 0x30, 0x46, 0xF7, + 0xE6, 0x67, 0xF7, 0xDC, 0x38, 0xA4, 0xE4, 0xC4 + }, + { + 0x73, 0x77, 0xB6, 0xFD, 0x1F, 0xCF, 0xD0, 0xAB, + 0xEB, 0x1C, 0xC9, 0xAA, 0x45, 0xD6, 0xEA, 0x79, + 0x15, 0x87, 0x7A, 0x3B, 0xB2, 0x95, 0xFF, 0x88, + 0x0B, 0xCF, 0x9E, 0x40, 0x37, 0x12, 0x4B, 0x32, + 0xEE, 0x47, 0x43, 0xC6, 0xB6, 0x62, 0xAB, 0x5D, + 0xF8, 0x46, 0xF1, 0x79, 0x5A, 0x1C, 0xD4, 0x7F, + 0x02, 0x5B, 0x13, 0xFF, 0xFB, 0x55, 0xE7, 0x1D, + 0x70, 0xA7, 0x40, 0x5D, 0xF9, 0x4E, 0x46, 0x67 + }, + { + 0xF4, 0xC5, 0x23, 0x5C, 0xE9, 0x22, 0xC0, 0xA6, + 0xBA, 0xD1, 0x3B, 0xF3, 0x32, 0x36, 0x43, 0x39, + 0x76, 0x3F, 0xEF, 0x61, 0x1D, 0x17, 0xBE, 0x01, + 0xB0, 0x04, 0x56, 0x76, 0x67, 0x9F, 0x9F, 0xB1, + 0x86, 0x31, 0x39, 0xE9, 0x0A, 0xE2, 0xCC, 0xA9, + 0xA7, 0xB0, 0xFD, 0x3E, 0x4E, 0x7E, 0xD7, 0xD7, + 0x09, 0x78, 0x69, 0x3C, 0xB9, 0x57, 0x2D, 0xEB, + 0xE4, 0xCA, 0x6C, 0x61, 0x5E, 0xCC, 0x9F, 0x44 + }, + { + 0xC7, 0x44, 0x17, 0x92, 0x94, 0xBF, 0xF6, 0xF0, + 0x00, 0xFA, 0xD7, 0x35, 0x06, 0x1E, 0x06, 0x68, + 0x4B, 0x61, 0x65, 0x05, 0x47, 0x27, 0xE4, 0x72, + 0x6A, 0x5A, 0xC9, 0x03, 0x42, 0x42, 0x98, 0xBB, + 0x8B, 0x1E, 0xF6, 0xD4, 0xED, 0x8D, 0xE0, 0x06, + 0x2B, 0xF4, 0xE1, 0x1A, 0x9B, 0xA7, 0x14, 0x18, + 0xB3, 0x72, 0x51, 0x3E, 0x8F, 0x0E, 0xEC, 0x7A, + 0xC0, 0xCC, 0xBF, 0xB4, 0x36, 0x77, 0x78, 0x5B + }, + { + 0xAF, 0xA5, 0x7C, 0x1F, 0xB1, 0x32, 0x69, 0x13, + 0xAA, 0x1F, 0xBD, 0x7C, 0x03, 0x15, 0x87, 0xC1, + 0x4C, 0xA4, 0xC8, 0x38, 0xD0, 0x7E, 0xF6, 0x95, + 0xC0, 0x8B, 0xE3, 0x39, 0x1F, 0x39, 0xE9, 0x34, + 0xAA, 0x39, 0xBB, 0x9B, 0x91, 0x9C, 0xFB, 0x8C, + 0xBD, 0xE4, 0x40, 0x4C, 0xF9, 0x18, 0x17, 0x76, + 0x97, 0x6E, 0x0A, 0xB8, 0xDF, 0xD2, 0xF1, 0xCA, + 0x1F, 0x00, 0x62, 0xAB, 0x9C, 0xCA, 0x9B, 0x31 + }, + { + 0x78, 0x05, 0x4D, 0xC9, 0xFA, 0x53, 0x69, 0xC0, + 0xAA, 0x44, 0x6F, 0x30, 0x2E, 0x78, 0x4F, 0x4F, + 0x29, 0x50, 0x0D, 0xF6, 0xB6, 0x4C, 0xCD, 0xAF, + 0x2F, 0x1C, 0x54, 0xA7, 0x9C, 0x19, 0x13, 0x24, + 0xFD, 0x9C, 0xEE, 0x00, 0x09, 0x31, 0x1F, 0xD0, + 0xCF, 0xB7, 0xDD, 0x63, 0x60, 0x8A, 0x25, 0x49, + 0xC4, 0x8A, 0x0E, 0x81, 0x2D, 0x10, 0x46, 0x04, + 0x24, 0xF1, 0x8C, 0xFB, 0x74, 0x7B, 0x88, 0x9A + }, + { + 0x15, 0x86, 0x12, 0xDE, 0xB1, 0xDE, 0xCA, 0xB6, + 0x1E, 0x4B, 0x65, 0xD0, 0x8C, 0x5B, 0x0F, 0xA5, + 0xC9, 0x01, 0xC2, 0x13, 0xC4, 0xE4, 0x94, 0xD1, + 0x72, 0xB0, 0x3A, 0x51, 0xD6, 0x54, 0x11, 0xBE, + 0xFC, 0x3F, 0xB8, 0xA8, 0x05, 0xF2, 0x5A, 0xAE, + 0xB6, 0x67, 0x87, 0xAE, 0xE1, 0x90, 0x05, 0x84, + 0x3B, 0x09, 0x5A, 0xDF, 0xC2, 0x8E, 0xD0, 0xF0, + 0x43, 0xFE, 0x65, 0x5D, 0x1E, 0x4A, 0xBD, 0xE2 + }, + { + 0xB0, 0xAC, 0x44, 0xC3, 0x1C, 0x9E, 0x91, 0x45, + 0x0B, 0xEF, 0x87, 0x2B, 0x9B, 0x26, 0x5A, 0x08, + 0xC3, 0xDC, 0x05, 0x38, 0x70, 0xA1, 0x1F, 0xF5, + 0x7C, 0x36, 0x36, 0x41, 0x95, 0xE3, 0x63, 0xAF, + 0x8E, 0xD8, 0x08, 0x1A, 0x80, 0x91, 0x10, 0xD5, + 0x0C, 0xED, 0x6E, 0xD6, 0x98, 0xA7, 0xA5, 0x1D, + 0xDB, 0xA2, 0xD5, 0x70, 0x08, 0x2A, 0x58, 0x33, + 0xD8, 0x96, 0xA4, 0x97, 0x5E, 0x35, 0x26, 0xBB + }, + { + 0x46, 0xEB, 0x9F, 0x25, 0x39, 0x65, 0xC0, 0x32, + 0xB0, 0xD6, 0xB4, 0xDA, 0x01, 0x09, 0x02, 0x86, + 0x53, 0xA8, 0x6F, 0xDB, 0x2B, 0xCF, 0x14, 0x0A, + 0x18, 0xB3, 0x20, 0x26, 0x83, 0x69, 0xD7, 0xAF, + 0x65, 0x82, 0xE2, 0x91, 0x84, 0x0A, 0x03, 0x76, + 0x9B, 0x10, 0xFB, 0x71, 0x86, 0x6E, 0xE0, 0x0B, + 0x75, 0x39, 0x8A, 0xEB, 0x19, 0xB8, 0x86, 0x7A, + 0xBD, 0x7E, 0x5B, 0x6A, 0x22, 0x13, 0x1E, 0x3D + }, + { + 0x18, 0x80, 0x73, 0xFD, 0xED, 0x4E, 0xCE, 0x70, + 0xDD, 0xF0, 0x54, 0x5A, 0x9C, 0x08, 0xC3, 0xF0, + 0xF2, 0x3E, 0xE0, 0x37, 0xBB, 0x1B, 0xD6, 0x7F, + 0x42, 0x6C, 0x51, 0x14, 0x6D, 0x89, 0x62, 0xE9, + 0xA9, 0x58, 0x72, 0x1D, 0xF3, 0xE5, 0x30, 0x23, + 0x8E, 0x7E, 0xBC, 0x80, 0x08, 0xB6, 0x06, 0x6E, + 0xDA, 0xAF, 0x3C, 0x0E, 0x0C, 0x89, 0x79, 0x07, + 0xB3, 0x67, 0x2B, 0x7B, 0x5C, 0x2D, 0x00, 0x2D + }, + { + 0xD9, 0x7A, 0x56, 0x4B, 0x2E, 0x09, 0x6A, 0xCA, + 0x25, 0x78, 0x79, 0xCD, 0x34, 0x65, 0xDF, 0xAB, + 0x6D, 0xE0, 0x75, 0x9F, 0xB2, 0x07, 0xA9, 0xB4, + 0xB3, 0x51, 0x52, 0xFB, 0x16, 0x89, 0xBE, 0x5E, + 0xF5, 0x5D, 0x57, 0x76, 0xF4, 0x55, 0xF9, 0x21, + 0x2D, 0x0C, 0x35, 0xC8, 0xAE, 0xAA, 0x74, 0x1D, + 0x4E, 0x8C, 0x82, 0x47, 0x9E, 0x38, 0xE2, 0xF1, + 0x2E, 0xAD, 0xFF, 0x41, 0xA9, 0xDB, 0x9A, 0xDF + }, + { + 0x41, 0xDB, 0x43, 0x1A, 0x8C, 0x8C, 0xF6, 0x7A, + 0x84, 0x83, 0xB4, 0x85, 0x2E, 0xDD, 0x1C, 0x7B, + 0x44, 0x76, 0x6C, 0xC3, 0xC4, 0x8A, 0xA5, 0x00, + 0x05, 0xD7, 0xE1, 0x16, 0xAA, 0xE3, 0x1B, 0x75, + 0xDA, 0xBF, 0xE4, 0xD3, 0x4B, 0xE1, 0xDB, 0x63, + 0x12, 0xA1, 0x83, 0x9B, 0xF7, 0xFB, 0x07, 0xCB, + 0x70, 0x9E, 0x00, 0x63, 0x03, 0x32, 0x16, 0xE3, + 0x94, 0x6E, 0xAF, 0x8A, 0x76, 0xFC, 0x7C, 0x91 + }, + { + 0x3C, 0x26, 0x42, 0xA4, 0x4A, 0xAE, 0xF8, 0x38, + 0xCC, 0xCE, 0x50, 0x5F, 0x3D, 0xB7, 0xAF, 0x49, + 0x01, 0x1D, 0xCF, 0x16, 0x6E, 0xE5, 0xF4, 0x98, + 0x29, 0x4C, 0xEC, 0xCF, 0x24, 0x5C, 0xA8, 0x54, + 0x39, 0x48, 0x3C, 0x2F, 0xE9, 0x5F, 0xD9, 0x09, + 0xB3, 0x93, 0xC0, 0xB5, 0xC4, 0xBB, 0xAF, 0x3D, + 0xC8, 0xE6, 0xA8, 0x9A, 0x81, 0xF7, 0x67, 0x97, + 0x03, 0x1C, 0x4E, 0x12, 0xB1, 0xBA, 0x00, 0x18 + }, + { + 0xDC, 0x5D, 0xA8, 0x40, 0xFA, 0xD4, 0x91, 0xC9, + 0xB5, 0x7F, 0x2C, 0x77, 0xCC, 0xD4, 0x75, 0xA6, + 0xAF, 0x23, 0x2C, 0x08, 0x4A, 0x76, 0x20, 0x45, + 0x5C, 0xFB, 0x26, 0x00, 0x60, 0xAC, 0xE5, 0xBC, + 0x5D, 0x3F, 0xE0, 0xE3, 0x80, 0x4D, 0x4A, 0x91, + 0xF6, 0x6B, 0x63, 0x60, 0xC3, 0x48, 0xCF, 0xD0, + 0xF9, 0x09, 0x2B, 0x64, 0x78, 0xDB, 0x51, 0xB8, + 0x38, 0xD0, 0x8B, 0x0B, 0xF1, 0x4D, 0x64, 0xDD + }, + { + 0x04, 0xEB, 0x0D, 0x8C, 0xC8, 0xF2, 0x37, 0x98, + 0xD2, 0x6A, 0xCD, 0xC1, 0x59, 0x5D, 0x24, 0x7B, + 0x4A, 0x53, 0xD8, 0x70, 0x8C, 0x79, 0xA4, 0x9D, + 0x1A, 0x24, 0x98, 0xD5, 0xF4, 0x1E, 0xF6, 0xFE, + 0x31, 0x74, 0xB6, 0xB8, 0x37, 0x8D, 0x91, 0x3F, + 0x1E, 0x6B, 0x40, 0x08, 0x0B, 0x03, 0xAC, 0x3E, + 0xBA, 0x54, 0xFD, 0xAF, 0xDB, 0x6F, 0x71, 0x53, + 0x24, 0x62, 0x4C, 0x07, 0x7F, 0xA2, 0x94, 0x50 + }, + { + 0x4D, 0x6E, 0xB1, 0xDB, 0x09, 0x6C, 0x95, 0x86, + 0xBA, 0xF8, 0xB0, 0x8C, 0x83, 0xC5, 0x2F, 0x2A, + 0x1F, 0xF0, 0x95, 0xE8, 0xFA, 0xC3, 0x08, 0xCE, + 0xBA, 0x1F, 0x49, 0xF8, 0xB9, 0xB5, 0xB7, 0xA9, + 0xE2, 0x48, 0x93, 0x04, 0xE2, 0xF5, 0x27, 0x1B, + 0x38, 0x6F, 0x3F, 0x0A, 0x0B, 0x9A, 0x5A, 0xB8, + 0x06, 0xF4, 0xD1, 0x88, 0x21, 0xFD, 0xC7, 0xBD, + 0x93, 0x4F, 0xE5, 0xFA, 0xCE, 0x54, 0xAC, 0x9F + }, + { + 0x88, 0xAB, 0x20, 0x0C, 0x21, 0x8C, 0x44, 0x7E, + 0x09, 0xA8, 0x4E, 0xCB, 0x5C, 0x51, 0x64, 0xA1, + 0x98, 0x4F, 0x27, 0xA1, 0xF5, 0x7F, 0x5F, 0x62, + 0x60, 0xEF, 0x4B, 0x7D, 0x83, 0x43, 0x28, 0x4E, + 0x8D, 0x1A, 0x6E, 0x73, 0x5E, 0x01, 0x09, 0xB2, + 0x87, 0xBA, 0xBB, 0x31, 0xA5, 0xD4, 0xB1, 0xE7, + 0x05, 0xB3, 0xCD, 0xF5, 0xDB, 0xC4, 0x59, 0x50, + 0x06, 0xA2, 0xE9, 0xD5, 0x17, 0x40, 0x65, 0xDB + }, + { + 0xF1, 0xCA, 0x8F, 0xC1, 0xC7, 0xE6, 0x55, 0x0F, + 0x50, 0xFD, 0x5B, 0xE5, 0x6C, 0x12, 0xC2, 0x52, + 0x60, 0xD6, 0x40, 0xF5, 0x79, 0xCE, 0x0D, 0xB8, + 0x95, 0x2F, 0x1E, 0xF1, 0x18, 0x19, 0x98, 0x20, + 0xB3, 0xB8, 0xFC, 0xD9, 0x15, 0xC7, 0xEB, 0xB5, + 0xB9, 0x55, 0xFA, 0x2C, 0x7F, 0xF2, 0x4C, 0x26, + 0x36, 0x0F, 0xBF, 0x28, 0xB0, 0xD4, 0xA4, 0xB6, + 0xB6, 0x92, 0x61, 0xC9, 0x05, 0x56, 0xFE, 0xAD + }, + { + 0xC7, 0x44, 0xFD, 0xA2, 0x9B, 0xE5, 0x63, 0xFE, + 0x4C, 0x38, 0xCF, 0x1F, 0x91, 0xB8, 0x66, 0x7A, + 0xBF, 0xB9, 0x2F, 0xB9, 0x7B, 0x9E, 0x71, 0x1B, + 0x0A, 0x69, 0x55, 0xD3, 0x74, 0x4F, 0x83, 0x69, + 0xF7, 0x1A, 0xCD, 0x18, 0x81, 0x1D, 0x49, 0xDA, + 0x28, 0x76, 0x1B, 0xAC, 0x4D, 0x4F, 0xD5, 0x33, + 0xA8, 0x89, 0x83, 0x02, 0xF3, 0xC2, 0x36, 0xAD, + 0xBA, 0x9C, 0x24, 0xD6, 0x03, 0xE1, 0x77, 0xAB + }, + { + 0x6C, 0xB3, 0xFA, 0x95, 0x8F, 0x99, 0xB9, 0x4F, + 0x17, 0x10, 0xB0, 0x18, 0x73, 0xD5, 0x25, 0x9D, + 0x21, 0x5A, 0xF6, 0xA2, 0x40, 0x5C, 0xC7, 0x6B, + 0x3B, 0xF3, 0xBC, 0x10, 0xF1, 0x79, 0x0C, 0xF2, + 0x9D, 0x2D, 0xA4, 0xA8, 0x9D, 0x89, 0x7F, 0xE7, + 0x99, 0x7D, 0x80, 0xFC, 0xB4, 0x6D, 0x67, 0x9D, + 0xD3, 0x4B, 0x1D, 0xF7, 0xB5, 0x2A, 0xAE, 0x67, + 0xA2, 0x32, 0x25, 0xAA, 0x99, 0x1C, 0x43, 0xCC + }, + { + 0x3A, 0xC9, 0x38, 0x8B, 0x06, 0xEE, 0xF6, 0x9D, + 0xD4, 0x35, 0xB5, 0x62, 0xE7, 0xC9, 0xCC, 0x98, + 0x91, 0x4F, 0x77, 0xF0, 0xB7, 0xDA, 0xB4, 0x91, + 0xA4, 0xC1, 0xC2, 0x9C, 0x4D, 0x20, 0xCE, 0x73, + 0x75, 0x1D, 0xCE, 0x41, 0xAE, 0x1D, 0x35, 0x74, + 0xDD, 0x11, 0xFD, 0xE1, 0x05, 0xB4, 0x3F, 0xDE, + 0x82, 0xEA, 0xA7, 0x9F, 0xA1, 0xD2, 0x41, 0x19, + 0xCE, 0xC2, 0x95, 0x53, 0x7E, 0x65, 0x19, 0xC7 + }, + { + 0x05, 0x12, 0xEF, 0xF7, 0x35, 0x55, 0xD0, 0x8C, + 0xB7, 0x26, 0x52, 0xF8, 0x5C, 0xE9, 0x70, 0x91, + 0x0E, 0x92, 0xD6, 0x44, 0x9A, 0x3E, 0xF2, 0x0A, + 0x38, 0xA2, 0xDC, 0x68, 0x93, 0xE5, 0xF3, 0x6A, + 0x95, 0x8F, 0x77, 0x1E, 0x6F, 0x49, 0x13, 0xD2, + 0xAB, 0xED, 0x50, 0xBE, 0xCC, 0xBD, 0x41, 0x13, + 0xEC, 0xFE, 0x48, 0xB5, 0xB9, 0x4F, 0x4A, 0xEB, + 0x48, 0x7A, 0x4B, 0x7D, 0x0C, 0xA4, 0x97, 0xA8 + }, + { + 0xBC, 0x76, 0x95, 0xC8, 0xDA, 0xCE, 0x37, 0x2B, + 0xCF, 0x81, 0x1E, 0xAA, 0x6F, 0x60, 0xF5, 0xDC, + 0xDD, 0xB0, 0x28, 0xDD, 0x44, 0x12, 0xF1, 0xC7, + 0xBC, 0x8A, 0x13, 0xEC, 0xA8, 0x9F, 0x73, 0x5E, + 0x47, 0x2E, 0x92, 0x6F, 0xE5, 0xF4, 0xD1, 0xE9, + 0x91, 0x42, 0xCD, 0x4F, 0x7B, 0x90, 0x53, 0x0E, + 0x6D, 0xEE, 0xA3, 0xDB, 0x61, 0x50, 0x95, 0x8A, + 0x7E, 0x0C, 0xE8, 0x07, 0x37, 0xEE, 0xCA, 0xBC + }, + { + 0x53, 0x70, 0xD3, 0xE5, 0x5E, 0x4C, 0xC3, 0xDE, + 0x5A, 0x02, 0xFE, 0xFB, 0xB5, 0x6F, 0x30, 0x1D, + 0x8B, 0xF0, 0x5B, 0xCE, 0x9C, 0x41, 0xE6, 0x1E, + 0x0B, 0x47, 0xE9, 0xE7, 0x78, 0x46, 0xBD, 0x77, + 0xC0, 0xAF, 0xAB, 0x9C, 0x59, 0x53, 0xB7, 0xB2, + 0x8F, 0x3C, 0x1B, 0xF2, 0x7F, 0x22, 0xE0, 0x43, + 0x20, 0x9A, 0xAE, 0x85, 0x92, 0x18, 0xF2, 0x3F, + 0x02, 0xE4, 0x16, 0x68, 0x87, 0xF0, 0x90, 0xD3 + }, + { + 0x18, 0x24, 0xFA, 0x85, 0xA7, 0x76, 0xA9, 0x6F, + 0x92, 0x00, 0xB0, 0xBA, 0xAA, 0x01, 0x25, 0x75, + 0x15, 0x2E, 0x58, 0x53, 0xA3, 0x92, 0x54, 0xD2, + 0x19, 0xEA, 0xCB, 0xF8, 0xA3, 0x29, 0xF6, 0xAC, + 0x0C, 0xB0, 0xF3, 0xFF, 0xE1, 0xAF, 0xD6, 0xA1, + 0x3A, 0x55, 0xB8, 0x8C, 0x67, 0x6A, 0xAF, 0xF6, + 0x97, 0x63, 0xE6, 0xEF, 0x05, 0x67, 0x8C, 0x49, + 0xC2, 0x8A, 0x10, 0x4E, 0xDB, 0xCF, 0x44, 0x9F + }, + { + 0x0C, 0x15, 0x0D, 0x31, 0x03, 0x24, 0x6B, 0x91, + 0x09, 0xC2, 0xF8, 0xBC, 0xF3, 0x52, 0xB8, 0x20, + 0x49, 0xA2, 0x99, 0x0C, 0x10, 0xAB, 0xBC, 0xF7, + 0x29, 0x5E, 0x05, 0x3C, 0x14, 0x1E, 0x4B, 0x04, + 0xAA, 0xB3, 0x6E, 0x2E, 0x4B, 0xDF, 0xD3, 0x2E, + 0xD5, 0xCC, 0x67, 0xBB, 0x28, 0xF4, 0x00, 0xA7, + 0xF7, 0xCD, 0xDE, 0xA5, 0xA9, 0xF0, 0xAB, 0x63, + 0x9A, 0xB2, 0x5E, 0xA2, 0x33, 0x00, 0x5F, 0xEF + }, + { + 0xEF, 0x5B, 0x86, 0x35, 0x4B, 0x30, 0x55, 0xF0, + 0xD2, 0x84, 0xCB, 0x09, 0x42, 0xCA, 0x3A, 0xA5, + 0x40, 0xC0, 0x33, 0xF0, 0x1F, 0xBD, 0xB5, 0xAA, + 0x52, 0x1B, 0x8C, 0xE1, 0x79, 0x2A, 0xFC, 0x42, + 0x37, 0x0D, 0x14, 0x0B, 0xF4, 0x12, 0x80, 0xBC, + 0xF8, 0x29, 0x95, 0x99, 0x90, 0x62, 0x09, 0x1F, + 0xB7, 0x48, 0xE0, 0x3B, 0x7B, 0x75, 0x58, 0x22, + 0x25, 0xB4, 0x4F, 0xC6, 0x79, 0xA7, 0xE8, 0xCF + }, + { + 0x98, 0x5F, 0x4D, 0x83, 0x27, 0x02, 0x95, 0xF4, + 0xB1, 0x8E, 0x9E, 0xEA, 0x63, 0x25, 0xA0, 0xD4, + 0x1A, 0x79, 0x09, 0xCC, 0x8E, 0x79, 0x74, 0xFB, + 0x4B, 0xDB, 0xC0, 0xF1, 0x2B, 0x84, 0x55, 0x23, + 0x3B, 0x90, 0xE9, 0xF1, 0x01, 0x90, 0x03, 0xE2, + 0xF4, 0x13, 0x3B, 0x45, 0x6E, 0x33, 0xF0, 0xA6, + 0x45, 0xC9, 0x35, 0xAD, 0x47, 0x55, 0xF2, 0x26, + 0x52, 0x2A, 0xA1, 0xF6, 0xE3, 0x86, 0x09, 0xC8 + }, + { + 0x40, 0xB8, 0xA1, 0x5A, 0xA4, 0x19, 0x99, 0x07, + 0xE5, 0xB6, 0xB5, 0x88, 0x25, 0xB8, 0x6F, 0x85, + 0xDE, 0xEA, 0x2A, 0x0B, 0x88, 0x14, 0x6A, 0x73, + 0xDF, 0x14, 0xBA, 0xD2, 0xD0, 0xCA, 0xD1, 0x8A, + 0x19, 0xE1, 0x68, 0x70, 0x21, 0x52, 0xED, 0x95, + 0x9F, 0x54, 0xD4, 0x40, 0xFF, 0x19, 0xBC, 0x5E, + 0xF0, 0xE5, 0x76, 0xBB, 0x40, 0xA5, 0xFF, 0x64, + 0x45, 0xC8, 0x59, 0x11, 0xDF, 0xC5, 0x50, 0xA1 + }, + { + 0x58, 0x2C, 0x3F, 0xE0, 0x3F, 0x52, 0x3D, 0xD1, + 0xCC, 0x64, 0xE1, 0x79, 0x84, 0x64, 0x60, 0x95, + 0x5E, 0x86, 0xFB, 0x2B, 0x3A, 0xED, 0x82, 0xD0, + 0x67, 0x5B, 0x6C, 0x50, 0xC4, 0x30, 0xC6, 0x65, + 0x89, 0xDF, 0x5D, 0x4E, 0x47, 0x86, 0x56, 0x59, + 0x24, 0x4F, 0xEB, 0x63, 0x89, 0xE5, 0x4B, 0xC6, + 0x72, 0xD6, 0xF3, 0x08, 0x95, 0xC8, 0x02, 0x66, + 0x7E, 0xA5, 0xA0, 0xB0, 0x0F, 0xC9, 0xBE, 0x53 + }, + { + 0x86, 0x0E, 0xA4, 0xFC, 0x63, 0xDC, 0xE6, 0x84, + 0x41, 0xAD, 0xFC, 0x14, 0xD2, 0xFC, 0x1B, 0x4B, + 0xEF, 0x78, 0x53, 0x86, 0x55, 0xBF, 0x26, 0xB9, + 0x55, 0x9C, 0xD4, 0x44, 0x63, 0x1E, 0xC8, 0x69, + 0x2D, 0x1A, 0x6A, 0xC4, 0x50, 0x22, 0xD5, 0x14, + 0x53, 0xFA, 0x49, 0x51, 0x3D, 0x80, 0x8F, 0xC0, + 0xA5, 0xB3, 0x8D, 0xC2, 0x3A, 0x93, 0xF4, 0x8E, + 0x8F, 0x61, 0x58, 0x89, 0xD3, 0x49, 0x24, 0xE3 + }, + { + 0x3A, 0x02, 0x1B, 0xD1, 0x9F, 0x1D, 0x8F, 0xA5, + 0x81, 0x6C, 0xA4, 0x68, 0x77, 0x76, 0x84, 0x86, + 0xE8, 0xE9, 0x57, 0xE1, 0x36, 0xFE, 0xE2, 0x35, + 0xA0, 0x5B, 0x86, 0xA9, 0xCE, 0xFA, 0x44, 0x76, + 0x59, 0x42, 0xE2, 0xDF, 0xC3, 0xC4, 0xDB, 0x3A, + 0xC8, 0x4D, 0x13, 0xE6, 0x4D, 0x56, 0x8E, 0x05, + 0x57, 0x8D, 0x9E, 0x94, 0xD9, 0x39, 0x29, 0xE2, + 0xF5, 0x2D, 0x77, 0x43, 0xFA, 0xD8, 0x78, 0x46 + }, + { + 0x33, 0x67, 0x8F, 0x86, 0xBF, 0x9F, 0xDA, 0xCA, + 0x48, 0x29, 0x71, 0x8E, 0x88, 0xA6, 0xDD, 0x9F, + 0xF6, 0xB7, 0x08, 0x93, 0xDE, 0x10, 0xF5, 0x2E, + 0xC8, 0x6C, 0x5D, 0xE0, 0x6D, 0xB1, 0xC8, 0xD3, + 0x10, 0x79, 0xB6, 0x09, 0x11, 0xEF, 0xE1, 0x85, + 0x38, 0x2C, 0x61, 0xCC, 0xC2, 0x4A, 0x9E, 0x7E, + 0x80, 0xC7, 0x34, 0xED, 0x9C, 0xAE, 0xDF, 0x82, + 0xAF, 0x5E, 0xD2, 0xC0, 0x26, 0xEC, 0x8E, 0x7F + }, + { + 0x63, 0x96, 0x10, 0x02, 0xA1, 0x9C, 0xF7, 0x2C, + 0x3B, 0x2D, 0x56, 0x5F, 0xED, 0x01, 0x80, 0xF0, + 0x2D, 0x13, 0x7B, 0xD4, 0x7D, 0x2F, 0x2D, 0x34, + 0x62, 0x5A, 0xD3, 0x1D, 0x4F, 0x3C, 0x1B, 0x03, + 0x26, 0xB4, 0xD6, 0xFD, 0xE0, 0x0F, 0x94, 0xF5, + 0x0A, 0xE2, 0x2D, 0x44, 0x6D, 0x0B, 0x96, 0x46, + 0x0F, 0x68, 0x8E, 0x97, 0x88, 0x01, 0x60, 0xD8, + 0xFB, 0x75, 0xBB, 0x5C, 0x7E, 0x0D, 0xB1, 0xAB + }, + { + 0x28, 0x39, 0xB2, 0x9A, 0x16, 0x42, 0x13, 0xDE, + 0x2D, 0xAE, 0x33, 0xF1, 0x76, 0xF6, 0xD8, 0x28, + 0x62, 0xDE, 0xCF, 0x27, 0xCA, 0x76, 0x46, 0xDF, + 0x67, 0x96, 0x0E, 0xCB, 0xA2, 0xEC, 0x10, 0x14, + 0x3F, 0x6C, 0x3B, 0xBA, 0x83, 0x55, 0x2C, 0xFE, + 0xC2, 0x68, 0x5F, 0x41, 0xF5, 0x07, 0x7D, 0x3A, + 0xE9, 0xC8, 0x69, 0x54, 0xE1, 0x4D, 0x30, 0x1D, + 0x87, 0xBE, 0x2F, 0x23, 0x00, 0xB4, 0x24, 0xD0 + }, + { + 0x73, 0xEC, 0x1D, 0x3B, 0x75, 0x9B, 0x7D, 0xDF, + 0xE6, 0x70, 0xA7, 0x9B, 0xDE, 0x86, 0x3F, 0xB9, + 0xB1, 0x85, 0xA7, 0x7C, 0xFA, 0x5C, 0x3B, 0xA9, + 0x86, 0xBA, 0xC8, 0x5A, 0x79, 0x10, 0xEB, 0xAB, + 0xBF, 0x4D, 0xF0, 0x3E, 0x16, 0x0A, 0x94, 0xC9, + 0x19, 0xA5, 0x37, 0xDD, 0x21, 0x81, 0x2D, 0x83, + 0x26, 0x1A, 0x5E, 0xCA, 0xE6, 0xCE, 0xEE, 0x99, + 0x70, 0xF3, 0xB8, 0x2F, 0x9C, 0x45, 0xFB, 0x10 + }, + { + 0x45, 0xDD, 0x45, 0xF4, 0x3D, 0x3C, 0xA5, 0x8A, + 0xB3, 0xBE, 0x64, 0xC6, 0x09, 0xE9, 0x26, 0xA2, + 0x15, 0xA5, 0xA5, 0x41, 0x32, 0xF0, 0x6B, 0x82, + 0xB8, 0xE3, 0xC3, 0xCD, 0x97, 0xF5, 0x66, 0x8B, + 0xB9, 0xAB, 0x43, 0x51, 0x6F, 0x1D, 0xC4, 0x0B, + 0xDE, 0xC0, 0x2F, 0x34, 0xBF, 0x89, 0x9C, 0x08, + 0x71, 0x00, 0x11, 0x0F, 0x8C, 0x8F, 0xCC, 0x55, + 0xAE, 0x32, 0x94, 0xD2, 0x69, 0x57, 0x16, 0x1C + }, + { + 0xFD, 0x93, 0x14, 0x19, 0x13, 0x33, 0x1D, 0xB0, + 0x1A, 0xF2, 0x59, 0xF8, 0x73, 0x64, 0x46, 0x69, + 0x5E, 0xA3, 0x58, 0xEE, 0xA7, 0x17, 0xB1, 0x4E, + 0x76, 0x09, 0x0E, 0x05, 0x47, 0x68, 0x04, 0x9F, + 0x18, 0x5C, 0x7A, 0x03, 0x84, 0x54, 0xBB, 0xC0, + 0x1F, 0xBA, 0xFA, 0xA5, 0xFB, 0xEF, 0x9D, 0xAA, + 0x55, 0x30, 0xE2, 0xBB, 0xA1, 0xCF, 0x72, 0xA5, + 0xE9, 0x4E, 0xCA, 0xA4, 0xB0, 0x11, 0x75, 0x8A + }, + { + 0x16, 0x76, 0x20, 0x6C, 0xC6, 0x1F, 0x8D, 0x1D, + 0x15, 0x5F, 0x02, 0x40, 0x8C, 0x5F, 0x1B, 0x5D, + 0x02, 0x86, 0x47, 0x68, 0x84, 0x4E, 0x95, 0x0C, + 0x96, 0x25, 0x67, 0x1E, 0xDF, 0x76, 0x4C, 0x57, + 0xD6, 0x6C, 0xF2, 0x56, 0x65, 0x40, 0xFB, 0xE8, + 0xBC, 0x2C, 0xB5, 0x3C, 0xBA, 0x3A, 0x8B, 0xF7, + 0x75, 0x1D, 0xB8, 0x2B, 0x7D, 0x1D, 0xAA, 0xA9, + 0xB5, 0xE3, 0x06, 0x2C, 0x95, 0x8B, 0xAF, 0x11 + }, + { + 0x82, 0xB5, 0xC4, 0x4A, 0xEE, 0xE5, 0xBA, 0x16, + 0x8B, 0x9D, 0x43, 0x06, 0x0F, 0xE0, 0xA4, 0x21, + 0xBB, 0x0A, 0xE6, 0xC3, 0x87, 0x2D, 0x43, 0x78, + 0x2B, 0x2F, 0xB6, 0x50, 0xF3, 0xF0, 0x71, 0xB4, + 0x2F, 0x9D, 0x50, 0x20, 0x91, 0xDF, 0xEB, 0xBB, + 0xFF, 0x36, 0x01, 0x2E, 0xAF, 0x5C, 0xF2, 0xD4, + 0xFD, 0x2F, 0x8B, 0x3A, 0x00, 0xA6, 0x02, 0x74, + 0x61, 0x77, 0xF2, 0x92, 0xC6, 0x0C, 0x84, 0xEA + }, + { + 0xD4, 0x24, 0xDA, 0x9D, 0x16, 0xD0, 0xC2, 0xE1, + 0x17, 0xD0, 0xB1, 0x1D, 0xCA, 0x42, 0xFA, 0x31, + 0x0C, 0x7A, 0x80, 0xED, 0x99, 0xB8, 0xC8, 0x8D, + 0x2C, 0x51, 0xDC, 0x36, 0x17, 0x54, 0x4E, 0x4A, + 0xF7, 0x7F, 0x8E, 0xA3, 0xEA, 0xA5, 0xB9, 0xB2, + 0x9E, 0x22, 0x1C, 0x1F, 0xEB, 0x13, 0xD8, 0x3B, + 0x8B, 0xDD, 0x41, 0x84, 0xAF, 0x4B, 0x90, 0xAC, + 0x79, 0x44, 0xFF, 0x69, 0x50, 0x64, 0x65, 0x66 + }, + { + 0x0B, 0x8F, 0x90, 0x6F, 0xFF, 0x1F, 0xA6, 0xEA, + 0x34, 0x00, 0xFC, 0x8B, 0x93, 0x34, 0x81, 0x8C, + 0xC0, 0x2D, 0xD0, 0x96, 0xDF, 0xE1, 0xE6, 0x6F, + 0x95, 0x27, 0xC0, 0xB4, 0x7E, 0xD9, 0x73, 0xB0, + 0xDA, 0xEE, 0xDB, 0x9A, 0xAC, 0xAA, 0x1B, 0x4D, + 0x05, 0x22, 0xE7, 0x81, 0x05, 0xC2, 0x68, 0xC3, + 0xC8, 0xCC, 0xA0, 0x7B, 0x22, 0xA8, 0x27, 0xD0, + 0x46, 0x07, 0x4B, 0x5F, 0x7D, 0x47, 0xF7, 0xAD + }, + { + 0xB3, 0xBA, 0x90, 0xC4, 0x36, 0xED, 0x58, 0x8E, + 0x08, 0xE0, 0x63, 0xC4, 0x53, 0xE9, 0x86, 0x80, + 0xA8, 0x30, 0x83, 0x4D, 0xE0, 0x7C, 0xD6, 0x59, + 0x5D, 0xF6, 0x3A, 0x12, 0x51, 0xE8, 0xA7, 0xB8, + 0xB5, 0xB8, 0xF5, 0xFE, 0x1D, 0x0B, 0x50, 0x63, + 0xA9, 0xFF, 0x4A, 0xD4, 0x36, 0xFC, 0x53, 0x72, + 0x58, 0xAF, 0x19, 0x6F, 0x56, 0xB9, 0x25, 0xCC, + 0x87, 0x9D, 0x88, 0x2C, 0x1E, 0xCC, 0x0E, 0xD8 + }, + { + 0x2D, 0x30, 0x8A, 0x80, 0xB8, 0xE9, 0xE1, 0x8A, + 0x27, 0xBE, 0x7E, 0x97, 0x05, 0x9E, 0xC0, 0xD7, + 0xF8, 0x41, 0xDE, 0x45, 0x1E, 0xB1, 0x7D, 0x21, + 0x9D, 0x5B, 0x81, 0xA4, 0x62, 0x7F, 0x77, 0x2E, + 0x51, 0xA8, 0x12, 0xC0, 0x6C, 0xA1, 0x74, 0x00, + 0x74, 0x86, 0xEC, 0xE1, 0x17, 0xD7, 0x75, 0xA0, + 0x08, 0x6C, 0x20, 0xF4, 0x1F, 0xE1, 0x2B, 0x62, + 0x09, 0xC3, 0x09, 0x30, 0xFE, 0x71, 0xA3, 0xD6 + }, + { + 0x48, 0x80, 0x15, 0x28, 0x18, 0x39, 0x3F, 0x33, + 0x3A, 0xD3, 0xE5, 0x4D, 0x06, 0xD7, 0x35, 0x30, + 0xF6, 0xCC, 0xC1, 0x55, 0x82, 0xBE, 0xD9, 0x39, + 0x8A, 0x39, 0xC8, 0x01, 0x7E, 0x40, 0x09, 0xF3, + 0x18, 0x30, 0x46, 0xAE, 0xFE, 0x92, 0x08, 0x2B, + 0xF7, 0x01, 0x44, 0x4F, 0x5D, 0x62, 0x71, 0x54, + 0x2F, 0x3B, 0xD1, 0x37, 0x0F, 0x14, 0x2A, 0x83, + 0x75, 0xCA, 0x33, 0xD4, 0x4A, 0xBF, 0x57, 0x9E + }, + { + 0x31, 0xFE, 0xD4, 0x3D, 0x58, 0x28, 0x73, 0x7D, + 0x3F, 0x91, 0x0E, 0x6A, 0x1B, 0x8B, 0xC6, 0x9B, + 0x48, 0xEA, 0xFD, 0x97, 0x90, 0xF8, 0x51, 0xEE, + 0x2F, 0x4C, 0x50, 0xC9, 0x10, 0xD8, 0x7D, 0xED, + 0x0E, 0x7C, 0xCD, 0xC9, 0xC7, 0x95, 0xEC, 0xCD, + 0xF6, 0xE5, 0xE8, 0x82, 0x90, 0xA2, 0x23, 0x87, + 0xFE, 0x86, 0x10, 0xCF, 0x9A, 0x6C, 0xC5, 0x3A, + 0x60, 0x99, 0xE0, 0xA0, 0xAC, 0x72, 0x05, 0x6B + }, + { + 0xD9, 0xB4, 0xE8, 0xD8, 0x81, 0x81, 0x53, 0xA8, + 0xE4, 0xCA, 0x9F, 0xD1, 0xA1, 0xB4, 0x35, 0xBA, + 0xC9, 0x5A, 0xE3, 0x37, 0xDB, 0x80, 0x09, 0x67, + 0xDC, 0xF6, 0x97, 0xF2, 0x4E, 0xDE, 0x6D, 0x7D, + 0xB7, 0x85, 0xD3, 0x8F, 0x39, 0xD2, 0xE1, 0x6C, + 0x63, 0xE4, 0x66, 0x5D, 0xDE, 0xA0, 0x5E, 0x81, + 0x57, 0x46, 0x5C, 0xC1, 0x7C, 0x56, 0x25, 0xF8, + 0xA6, 0xA1, 0x37, 0x3D, 0x78, 0xC5, 0x81, 0xD2 + }, + { + 0x59, 0xE2, 0x67, 0x1C, 0x4E, 0x8C, 0xFC, 0xB1, + 0x54, 0x3A, 0xA7, 0xCA, 0xCC, 0x56, 0xE7, 0x5B, + 0xE5, 0x3A, 0x0C, 0x2A, 0x73, 0x4E, 0x8E, 0xEA, + 0x9C, 0xF9, 0xC1, 0xC6, 0x71, 0xA4, 0x24, 0x38, + 0x23, 0x5E, 0xA1, 0x55, 0xB3, 0x39, 0x53, 0xAC, + 0x64, 0xB0, 0x6C, 0x75, 0x63, 0xED, 0xF2, 0x72, + 0x1B, 0xD3, 0xD2, 0xB4, 0x42, 0x3F, 0xD7, 0x87, + 0xF6, 0x41, 0x48, 0x79, 0x3F, 0x4A, 0x21, 0x45 + }, + { + 0x11, 0x2D, 0x0C, 0x10, 0x90, 0x3A, 0x20, 0xFD, + 0x33, 0x65, 0x2F, 0x28, 0xDD, 0x7F, 0x77, 0x93, + 0x3A, 0x19, 0xFA, 0x6C, 0xD8, 0xCF, 0xD8, 0x5C, + 0x84, 0x29, 0xCB, 0x70, 0xA0, 0xBC, 0x0F, 0xB2, + 0x47, 0x15, 0x80, 0x78, 0x39, 0x4A, 0x0B, 0xA6, + 0x43, 0xF3, 0xBC, 0xBD, 0xD3, 0xFC, 0x66, 0x20, + 0x8B, 0x78, 0x86, 0x93, 0x01, 0x06, 0x02, 0x19, + 0xDF, 0xE8, 0x42, 0x07, 0x92, 0xC8, 0x53, 0x36 + }, + { + 0xEB, 0xDE, 0xCA, 0x0F, 0x1B, 0xBD, 0x77, 0x33, + 0xBD, 0x17, 0xCB, 0x04, 0xA5, 0xCF, 0xB0, 0x77, + 0x54, 0xD7, 0xA3, 0x8F, 0xB1, 0x9D, 0x8C, 0x4D, + 0xFC, 0xA1, 0xFC, 0x2C, 0xCE, 0x80, 0x16, 0x4D, + 0x8B, 0x21, 0xF1, 0x1C, 0x95, 0xDC, 0x3D, 0xEF, + 0x0F, 0x5F, 0x1D, 0x52, 0x8A, 0x38, 0x72, 0xFA, + 0x55, 0xBC, 0x17, 0x56, 0x92, 0x33, 0xDD, 0xB3, + 0x16, 0x4F, 0xF2, 0xE0, 0x47, 0xA3, 0x85, 0xAE + }, + { + 0x5D, 0x5E, 0x06, 0x04, 0x35, 0x74, 0x26, 0xEA, + 0x7D, 0x9E, 0x52, 0xAA, 0x97, 0xA2, 0xC4, 0x7A, + 0xE1, 0x85, 0x8A, 0x6C, 0x33, 0xA9, 0xD8, 0x07, + 0x8E, 0xA2, 0x1A, 0x0C, 0x66, 0xFA, 0xE7, 0xC6, + 0x0E, 0xB1, 0x07, 0xE3, 0xBA, 0x47, 0x55, 0xA2, + 0x8A, 0xCE, 0xE3, 0x89, 0x14, 0x3C, 0x4A, 0x0A, + 0xF4, 0x7A, 0x4E, 0x2C, 0xBE, 0xD3, 0x99, 0x08, + 0x8F, 0xDD, 0x6B, 0x00, 0x9E, 0xAC, 0x52, 0x86 + }, + { + 0x4F, 0x6B, 0x5F, 0x09, 0xFA, 0xF1, 0x86, 0x88, + 0x13, 0x09, 0x27, 0x44, 0xC1, 0x3F, 0x96, 0x31, + 0x9F, 0x97, 0xA0, 0xBE, 0xAF, 0x31, 0xDE, 0x53, + 0x96, 0x55, 0x13, 0xAE, 0xBC, 0x78, 0x21, 0xE8, + 0x61, 0xB3, 0x18, 0xD7, 0xE1, 0x4F, 0x6A, 0x49, + 0xC6, 0x82, 0x6F, 0x51, 0x29, 0x4B, 0xB5, 0xA6, + 0x72, 0x85, 0xCC, 0xEE, 0x3E, 0xB0, 0x3E, 0x5B, + 0x05, 0x32, 0x33, 0x0B, 0xE6, 0x73, 0x42, 0x7E + }, + { + 0x03, 0x9A, 0x26, 0x07, 0xF7, 0x18, 0xE0, 0xDC, + 0xE4, 0xE5, 0x03, 0x4D, 0x96, 0x30, 0xEA, 0xC9, + 0xE7, 0x79, 0x14, 0xAA, 0x4E, 0x71, 0xC0, 0x93, + 0xE6, 0x0D, 0x89, 0x37, 0xC5, 0x35, 0xD4, 0x6F, + 0x57, 0xEF, 0x57, 0x5E, 0xDA, 0x63, 0x98, 0x44, + 0x00, 0xFF, 0x53, 0xD9, 0x40, 0xFC, 0x75, 0x7B, + 0xE0, 0x7B, 0x44, 0x7E, 0xF5, 0xD5, 0xC9, 0xB2, + 0x3A, 0x8E, 0x32, 0xCA, 0x4F, 0x43, 0x28, 0x67 + }, + { + 0xED, 0x5A, 0x6B, 0xEA, 0x5D, 0xA4, 0x43, 0xEE, + 0xB6, 0x89, 0xB3, 0x15, 0x8F, 0xD1, 0xD6, 0xF9, + 0x4F, 0x51, 0x85, 0x80, 0x9E, 0x45, 0xAA, 0x82, + 0xFC, 0xBC, 0x94, 0xE3, 0x67, 0x8B, 0x01, 0xE9, + 0x6A, 0x90, 0xF9, 0xEB, 0x25, 0xC9, 0x68, 0xA6, + 0xCE, 0x4D, 0xDE, 0x1C, 0x5F, 0x6E, 0x5C, 0x4E, + 0x1C, 0x2C, 0x59, 0x51, 0xF2, 0xD9, 0xA7, 0xF4, + 0x0F, 0x02, 0x11, 0x98, 0x8F, 0xC6, 0x17, 0x1B + }, + { + 0xB3, 0x22, 0x82, 0x5F, 0x69, 0x6F, 0xC3, 0x32, + 0x73, 0xC0, 0x06, 0xE0, 0x9E, 0xA1, 0xB1, 0x9C, + 0x59, 0x1A, 0x97, 0x18, 0x93, 0xDC, 0xA9, 0x72, + 0x48, 0x45, 0x69, 0x8E, 0x47, 0xD6, 0xFB, 0x3B, + 0xCC, 0x84, 0x18, 0x4F, 0x5B, 0x40, 0x17, 0xB8, + 0xFF, 0xB9, 0x30, 0xC1, 0x79, 0xF9, 0xDC, 0xDB, + 0x29, 0x9E, 0x4D, 0x1E, 0x2E, 0x80, 0x54, 0xF8, + 0x57, 0x70, 0xF7, 0x77, 0xF1, 0xF6, 0x15, 0x39 + }, + { + 0x84, 0xBA, 0x14, 0x95, 0x36, 0x92, 0xF3, 0xEC, + 0xBA, 0x05, 0x94, 0xE4, 0x52, 0x4F, 0xAA, 0xDE, + 0x28, 0xD1, 0x5C, 0x8A, 0x1C, 0xC4, 0x57, 0x05, + 0xE8, 0xFB, 0x5C, 0x74, 0xBC, 0x0A, 0x34, 0x1C, + 0x66, 0x7F, 0x02, 0xC5, 0x7F, 0x61, 0xF5, 0x98, + 0xCA, 0xF9, 0xB8, 0xF4, 0x60, 0x64, 0x4B, 0xED, + 0xD9, 0x6C, 0xBE, 0xCC, 0x92, 0xF5, 0x9D, 0x5F, + 0xC3, 0x63, 0x5A, 0x14, 0x1F, 0xA5, 0x4B, 0xCC + }, + { + 0x45, 0xFA, 0xD7, 0x18, 0xE2, 0x53, 0x6B, 0x80, + 0x82, 0xE0, 0xA3, 0x5D, 0x2B, 0x42, 0x73, 0x6D, + 0x2B, 0x07, 0x2C, 0x97, 0x48, 0xBB, 0x73, 0xDA, + 0xFA, 0x0A, 0x4A, 0xF3, 0x60, 0x60, 0xEA, 0x43, + 0x99, 0x71, 0x2A, 0x14, 0xC4, 0xFA, 0xD3, 0x05, + 0x62, 0x8B, 0xAC, 0x50, 0x81, 0x9A, 0x53, 0xA5, + 0x79, 0x3B, 0x39, 0x5A, 0x1F, 0x50, 0xC2, 0xC0, + 0x0D, 0x18, 0xD3, 0x73, 0x32, 0xA0, 0xCD, 0xF6 + }, + { + 0x27, 0x73, 0xC8, 0xA4, 0xBD, 0x4D, 0x08, 0x0D, + 0x51, 0x13, 0xCB, 0x71, 0x24, 0x27, 0x31, 0x3A, + 0x1A, 0x28, 0x9E, 0x97, 0x54, 0x7B, 0x60, 0x6E, + 0xBC, 0xC4, 0x4D, 0xAF, 0x41, 0x87, 0x29, 0xDA, + 0x35, 0xC0, 0x2E, 0x9A, 0x34, 0xD6, 0x36, 0x2E, + 0xAE, 0xE8, 0x5E, 0xAA, 0x8E, 0xDA, 0xC7, 0x01, + 0x31, 0xB0, 0x22, 0x57, 0xD8, 0x2B, 0xA9, 0x91, + 0xD3, 0x25, 0x34, 0xB4, 0x5E, 0x57, 0xBC, 0x89 + }, + { + 0x9B, 0xB3, 0xB7, 0xA3, 0xA3, 0xB0, 0x79, 0x7C, + 0xB0, 0xA5, 0xF2, 0xCC, 0x12, 0x6E, 0xF1, 0xB8, + 0x9D, 0x2D, 0x1D, 0x93, 0xC7, 0xB0, 0x17, 0x7D, + 0x00, 0xA6, 0x50, 0xE5, 0x6B, 0xD3, 0x83, 0xB9, + 0x79, 0xDB, 0xEC, 0xC9, 0x25, 0x42, 0xBC, 0x69, + 0x31, 0x3B, 0xB2, 0x05, 0x62, 0xD3, 0x7F, 0x7A, + 0xAE, 0x85, 0x83, 0xC8, 0xF2, 0xCD, 0xDF, 0xE6, + 0x94, 0xC2, 0x70, 0x03, 0xAF, 0x3E, 0xE1, 0xED + }, + { + 0xDE, 0x71, 0xE5, 0x5C, 0xEF, 0x54, 0xEC, 0xAD, + 0x5F, 0xA8, 0xB1, 0x57, 0x9B, 0x13, 0xAA, 0xE9, + 0x4A, 0xBF, 0xAD, 0xBC, 0xC9, 0x39, 0x3F, 0x81, + 0xB0, 0x47, 0xD6, 0xA2, 0x52, 0x1B, 0xB9, 0xFB, + 0x04, 0xB4, 0xCD, 0xDF, 0xB1, 0xC2, 0x2C, 0xF2, + 0x14, 0x0E, 0xB1, 0x07, 0x68, 0xB8, 0xA7, 0xB5, + 0x55, 0xF6, 0x1A, 0xB8, 0xB4, 0x5F, 0x15, 0x81, + 0x45, 0xC7, 0x92, 0x8B, 0x26, 0x85, 0x0D, 0x13 + }, + { + 0x1B, 0x50, 0x00, 0x49, 0x63, 0x90, 0x90, 0xC0, + 0xA9, 0x9A, 0xC7, 0x69, 0xAA, 0xB3, 0xAF, 0xAF, + 0x2A, 0x24, 0xF9, 0xAF, 0x7F, 0x98, 0x62, 0x4A, + 0xD2, 0xB0, 0xFA, 0x17, 0x96, 0x32, 0x52, 0xED, + 0x78, 0x7C, 0xBB, 0x01, 0xF0, 0x35, 0xFE, 0x13, + 0x2E, 0xEB, 0x85, 0x3B, 0xA9, 0x28, 0xAA, 0x03, + 0x6D, 0x4D, 0x33, 0x7D, 0x88, 0x0B, 0x34, 0xF5, + 0x7D, 0xFA, 0x05, 0x88, 0x54, 0xB9, 0x4A, 0x1E + }, + { + 0x6B, 0xB5, 0x45, 0xB2, 0xF7, 0x9C, 0x29, 0x19, + 0x73, 0x20, 0x3A, 0x34, 0x12, 0x5C, 0xF5, 0x29, + 0x09, 0xBD, 0xD4, 0xC4, 0xE7, 0xD6, 0x23, 0x25, + 0x63, 0xE1, 0xC3, 0xCD, 0xBB, 0x4F, 0xC9, 0xD1, + 0x29, 0xB7, 0xF6, 0xB5, 0xA7, 0xCE, 0x6F, 0x35, + 0xAF, 0xA1, 0xEE, 0x07, 0xB0, 0x22, 0xB8, 0xCC, + 0x61, 0x84, 0xF2, 0x76, 0xFE, 0x03, 0xC3, 0x70, + 0x46, 0x4E, 0x48, 0x6A, 0xAF, 0xDD, 0x43, 0xBC + }, + { + 0x1F, 0x9F, 0x2E, 0x01, 0x80, 0x68, 0x13, 0x2D, + 0x48, 0xD0, 0x70, 0x2C, 0x9A, 0x8D, 0x0C, 0xC2, + 0x17, 0xB0, 0xB6, 0x89, 0x23, 0xD3, 0x13, 0xAE, + 0x48, 0xC5, 0x20, 0x3B, 0x08, 0x68, 0x34, 0x4B, + 0x7F, 0x06, 0x37, 0x34, 0xF8, 0x86, 0x17, 0x86, + 0xFC, 0x06, 0xE7, 0xA3, 0x81, 0xE3, 0x85, 0x95, + 0x4C, 0x51, 0xDD, 0xF8, 0x1E, 0xD6, 0xA9, 0xFC, + 0x53, 0x6A, 0xE9, 0xC9, 0xEA, 0xBE, 0xBC, 0xA6 + }, + { + 0x11, 0x00, 0xC8, 0x49, 0xF6, 0xA5, 0x2B, 0x1C, + 0x58, 0x51, 0x20, 0x35, 0xFF, 0x2F, 0xBF, 0xDE, + 0xD8, 0x13, 0x1D, 0x03, 0x92, 0xFC, 0x43, 0x6F, + 0xE8, 0x2B, 0xB8, 0xBB, 0xDB, 0xC7, 0xF9, 0xA8, + 0x4A, 0x46, 0x00, 0x4D, 0xB8, 0x3E, 0xBA, 0x0C, + 0xD5, 0x0E, 0x72, 0x68, 0xF9, 0x71, 0x10, 0xAC, + 0x9B, 0xDF, 0x57, 0x58, 0x0B, 0x51, 0x24, 0xA3, + 0xA0, 0x4E, 0x99, 0xB6, 0x16, 0x4E, 0x60, 0x51 + }, + { + 0xAA, 0x5C, 0x5C, 0xEF, 0x76, 0x5C, 0xF0, 0x03, + 0x31, 0xFC, 0xF3, 0xB8, 0xBA, 0x51, 0xD4, 0xBF, + 0x5D, 0x93, 0x11, 0x22, 0x9B, 0xDC, 0xE3, 0xC5, + 0xF3, 0x45, 0x07, 0xE2, 0x7C, 0xCA, 0x69, 0xD4, + 0x24, 0xAB, 0xE4, 0x49, 0xF5, 0x20, 0xFF, 0xF8, + 0x65, 0x7C, 0x6E, 0xB8, 0x8D, 0x0F, 0xF8, 0xD8, + 0xF6, 0xB8, 0x23, 0x5A, 0xCB, 0xF3, 0x3E, 0x28, + 0x7C, 0x02, 0x92, 0x07, 0x24, 0xC6, 0xBD, 0x70 + }, + { + 0x84, 0xD9, 0xDD, 0x41, 0x25, 0xF3, 0x71, 0xDD, + 0xDB, 0x0A, 0x16, 0xFE, 0x1D, 0x8C, 0x9D, 0x71, + 0x53, 0x7E, 0xC0, 0x87, 0x8E, 0xB0, 0xBF, 0xE4, + 0x84, 0xDF, 0xE3, 0x88, 0xC8, 0x42, 0x25, 0xA8, + 0xA6, 0xD8, 0xCE, 0x6F, 0x99, 0x5C, 0xB0, 0x53, + 0xD4, 0x1D, 0xB6, 0x12, 0xA4, 0x21, 0x31, 0xF8, + 0x3C, 0x3D, 0x3F, 0xE8, 0x0C, 0x3D, 0x02, 0xAD, + 0xD7, 0x21, 0xF3, 0xDB, 0x91, 0x95, 0xCE, 0xC8 + }, + { + 0xD2, 0x83, 0xDF, 0x5D, 0x82, 0x02, 0xEF, 0xD9, + 0xC5, 0x75, 0x56, 0x02, 0xBD, 0x0B, 0x33, 0xB0, + 0x54, 0x9B, 0x1F, 0x8D, 0x8A, 0x83, 0xCC, 0xEF, + 0x6E, 0x75, 0x90, 0x28, 0x52, 0x24, 0xE4, 0xA6, + 0x1C, 0xF6, 0x84, 0xEE, 0xF8, 0xB9, 0x30, 0x3F, + 0x99, 0x1F, 0x9E, 0x8C, 0xDC, 0x37, 0xE6, 0xA4, + 0xCE, 0x5A, 0x48, 0xCE, 0xE9, 0x9F, 0x46, 0x05, + 0xC8, 0x58, 0xA7, 0x72, 0xF9, 0x6E, 0x10, 0xDE + }, + { + 0x7D, 0x01, 0xF3, 0xA9, 0xFD, 0x6A, 0x6B, 0x3C, + 0xC7, 0x9E, 0x94, 0xDB, 0x6E, 0x5D, 0x2C, 0xC2, + 0x3C, 0x4D, 0x45, 0x24, 0x28, 0x1F, 0x44, 0x6F, + 0x7B, 0x94, 0x00, 0xD2, 0x32, 0xD4, 0x23, 0x24, + 0x2A, 0x5B, 0xCB, 0x99, 0xA9, 0x86, 0x7F, 0x15, + 0x00, 0xDC, 0xE6, 0xB2, 0x35, 0x5A, 0xDA, 0x4E, + 0x48, 0xCC, 0x1B, 0x08, 0x7C, 0xA0, 0xCE, 0x1D, + 0xBA, 0x43, 0x7C, 0xBD, 0x84, 0x21, 0x64, 0xEF + }, + { + 0x4B, 0x31, 0xE4, 0x8E, 0x00, 0x8B, 0xF6, 0xF3, + 0x96, 0x60, 0xFE, 0x62, 0x2B, 0xE1, 0xD0, 0xB3, + 0xAD, 0x9F, 0xD6, 0xA4, 0x93, 0xEC, 0xE0, 0xE8, + 0xEA, 0xC3, 0x00, 0xD3, 0xDC, 0x90, 0x07, 0x10, + 0x60, 0x95, 0x90, 0xB7, 0xBF, 0xE3, 0xD2, 0xEB, + 0x47, 0x96, 0x8C, 0xAB, 0x25, 0xEB, 0x9C, 0xDC, + 0x42, 0x03, 0xFA, 0xE5, 0xB7, 0x0F, 0xEC, 0xB4, + 0x23, 0x73, 0x05, 0xC1, 0xE8, 0x07, 0x1A, 0xC2 + }, + { + 0x1D, 0x33, 0x54, 0x6A, 0xF0, 0x17, 0xAF, 0x2B, + 0xAA, 0x85, 0x2B, 0x7B, 0xF3, 0x5A, 0xFA, 0x5B, + 0x08, 0x18, 0xEE, 0x15, 0x21, 0x71, 0xCB, 0x9D, + 0x22, 0xE8, 0x3E, 0x6A, 0x6E, 0xF1, 0x74, 0x78, + 0x19, 0x0C, 0x57, 0x74, 0x03, 0x59, 0xC1, 0x56, + 0x5C, 0xB3, 0x3C, 0x72, 0xAA, 0xB5, 0x0F, 0xDE, + 0xF8, 0x08, 0x48, 0x08, 0xA5, 0xB4, 0x0B, 0x5C, + 0x0A, 0x70, 0xF5, 0x30, 0xB7, 0x57, 0x38, 0xE7 + }, + { + 0x6C, 0x73, 0x9E, 0xBC, 0x73, 0x3B, 0xB9, 0xFF, + 0x0B, 0x26, 0x16, 0x82, 0x40, 0xB5, 0xBE, 0xB1, + 0xF2, 0x2E, 0xCE, 0xD9, 0xEE, 0x42, 0x29, 0xBB, + 0x64, 0x7B, 0x40, 0x45, 0xCF, 0xD6, 0x3E, 0xAA, + 0x7C, 0x70, 0xD9, 0x5D, 0x82, 0xC0, 0x4D, 0x12, + 0x67, 0x26, 0x34, 0xC3, 0xE4, 0xD2, 0x50, 0xE3, + 0x83, 0x76, 0xA7, 0xFD, 0x66, 0xCD, 0x5E, 0xB5, + 0x1C, 0x5F, 0x2E, 0x7A, 0xF0, 0xAD, 0x43, 0x61 + }, + { + 0x42, 0x24, 0x2D, 0xA7, 0xB6, 0x6C, 0x6A, 0xCF, + 0x25, 0x19, 0x28, 0xA0, 0xEC, 0x97, 0x8B, 0x4C, + 0x66, 0x10, 0x3A, 0x68, 0x7A, 0xD7, 0xC1, 0xE7, + 0xC3, 0xEB, 0x96, 0x95, 0xE7, 0x66, 0x9F, 0x5D, + 0x84, 0x4C, 0x91, 0xEC, 0x2A, 0xDD, 0x56, 0x0A, + 0x28, 0xB1, 0x80, 0xDF, 0x4D, 0x33, 0xCC, 0x90, + 0x34, 0x8E, 0xA0, 0xDE, 0x2A, 0xE0, 0xC1, 0xE9, + 0x11, 0x96, 0x33, 0x7F, 0x47, 0x9B, 0x0C, 0xE2 + }, + { + 0x2E, 0xDC, 0x12, 0x59, 0x4A, 0x79, 0x86, 0xB2, + 0xB7, 0x74, 0xC9, 0xC1, 0x74, 0x99, 0x6B, 0xDE, + 0x7B, 0xC9, 0x12, 0xF7, 0x8D, 0xCE, 0x4C, 0xD9, + 0xFD, 0xA4, 0x4B, 0xD4, 0x67, 0xE6, 0x90, 0xAE, + 0xC9, 0xAB, 0xC3, 0x19, 0x2C, 0x51, 0xD4, 0x53, + 0xCC, 0xAE, 0xD4, 0x1B, 0xEC, 0xEB, 0x15, 0xE9, + 0x25, 0x2E, 0xA6, 0xC6, 0xC1, 0x3B, 0xBF, 0xCD, + 0xD9, 0xA9, 0x23, 0xAC, 0xF9, 0xFF, 0x0F, 0x5F + }, + { + 0x2F, 0xA8, 0xC1, 0x69, 0xD6, 0x09, 0xFC, 0xA3, + 0xD4, 0xA5, 0x33, 0x3D, 0xCB, 0x87, 0xAC, 0x48, + 0xEA, 0xD6, 0xE2, 0xF4, 0x59, 0xB5, 0xC1, 0x8C, + 0xB0, 0xBB, 0x67, 0x52, 0x09, 0xE2, 0x4C, 0x39, + 0x47, 0x8E, 0x87, 0x36, 0x15, 0xE8, 0x7F, 0xF4, + 0x21, 0xCD, 0x6C, 0x0A, 0x9E, 0xF8, 0x7C, 0xC8, + 0xAC, 0x67, 0x1C, 0x2B, 0xB3, 0x7F, 0x6B, 0x47, + 0xE7, 0x55, 0xAC, 0x5B, 0x1E, 0x7C, 0xEB, 0xBD + }, + { + 0x32, 0xF4, 0xFD, 0x80, 0xBE, 0x78, 0x2C, 0xBA, + 0x46, 0x09, 0x28, 0x64, 0xF1, 0xC9, 0x85, 0xAD, + 0x37, 0x29, 0xE8, 0x28, 0x2C, 0xE0, 0x34, 0x20, + 0x63, 0xF4, 0x5C, 0xBA, 0xC6, 0xB3, 0xDD, 0x04, + 0x84, 0x04, 0x44, 0xFE, 0x38, 0xCC, 0x47, 0x3C, + 0xD5, 0x94, 0x07, 0xC8, 0x00, 0x7C, 0xF6, 0xA8, + 0xAF, 0xB9, 0x60, 0x7D, 0xB3, 0x64, 0xF1, 0xD1, + 0x87, 0x01, 0xAF, 0x4B, 0xE2, 0x3C, 0x41, 0x8F + }, + { + 0x5F, 0xF1, 0x16, 0xF4, 0xC3, 0xD7, 0x96, 0xD9, + 0x18, 0x99, 0x6D, 0x8D, 0x33, 0xAB, 0xC9, 0x90, + 0xE5, 0xA2, 0xE1, 0x7F, 0x5C, 0x61, 0xA9, 0x6A, + 0xDD, 0xBA, 0x08, 0x4E, 0x4D, 0x18, 0xEB, 0xA6, + 0x3F, 0x32, 0x04, 0xD3, 0x7F, 0xBE, 0x56, 0xBB, + 0x84, 0x5A, 0x12, 0xED, 0x8B, 0x5B, 0xA5, 0xCF, + 0x74, 0x8A, 0x31, 0x06, 0x1D, 0x48, 0xF1, 0x8C, + 0x5F, 0xEC, 0x35, 0x03, 0x25, 0x72, 0xC6, 0x37 + }, + { + 0xC5, 0xA4, 0xF4, 0x0B, 0x8C, 0x80, 0x89, 0x38, + 0x5A, 0x57, 0xB9, 0xE1, 0x67, 0x78, 0x23, 0xFC, + 0x3A, 0xD3, 0xB4, 0x31, 0x52, 0xCE, 0x49, 0x48, + 0x6C, 0x06, 0xB0, 0x87, 0x4A, 0xCA, 0x35, 0xE9, + 0xFE, 0xD9, 0x8E, 0xC1, 0x35, 0x45, 0x62, 0xD2, + 0x11, 0xC2, 0xA9, 0xF4, 0x2D, 0x54, 0x47, 0x00, + 0x83, 0x95, 0x24, 0x82, 0x72, 0x9C, 0xF5, 0x7D, + 0x66, 0xB0, 0x5D, 0xA9, 0x4B, 0xAF, 0xB1, 0x9F + }, + { + 0x2A, 0x71, 0x23, 0xA2, 0x67, 0xEF, 0x01, 0xAF, + 0x03, 0x56, 0xBA, 0xB4, 0x88, 0x6E, 0xB7, 0xF3, + 0xAC, 0x88, 0x36, 0x53, 0x1E, 0x97, 0x40, 0xC2, + 0xB0, 0x3F, 0xA9, 0x24, 0x48, 0xEC, 0x38, 0x60, + 0xD6, 0xAD, 0xFF, 0x4E, 0xEA, 0x9A, 0xD8, 0xDC, + 0x77, 0x16, 0xB4, 0xDB, 0x6D, 0x79, 0xF9, 0x24, + 0xE0, 0xEE, 0xF1, 0x77, 0x73, 0xA2, 0x00, 0x29, + 0xA3, 0xBF, 0xA9, 0xB5, 0xA0, 0x58, 0xB0, 0xE3 + }, + { + 0xD6, 0xCA, 0xF4, 0xA4, 0xC8, 0x5D, 0x37, 0x9E, + 0xF6, 0x81, 0xBA, 0xEC, 0x2D, 0xBF, 0xB0, 0x48, + 0x0C, 0xB1, 0x87, 0x78, 0x81, 0x97, 0x84, 0x0D, + 0xD9, 0xAD, 0x8E, 0x1A, 0xF8, 0xF1, 0x09, 0x2D, + 0x91, 0xC4, 0x23, 0xA2, 0xB4, 0xC5, 0x06, 0xFA, + 0x63, 0x8C, 0xEF, 0x1D, 0x22, 0x52, 0x18, 0xAB, + 0xB1, 0xDB, 0x9C, 0xD3, 0x30, 0x61, 0x70, 0xE0, + 0x9A, 0x06, 0xF2, 0xC3, 0xC5, 0x34, 0x7C, 0x0E + }, + { + 0xA6, 0x35, 0x8D, 0xDD, 0xD5, 0x64, 0x25, 0xA1, + 0x75, 0x4A, 0xDD, 0x1E, 0xDC, 0xFF, 0x86, 0xF3, + 0xE4, 0xE5, 0x2C, 0xED, 0x5F, 0x05, 0x2E, 0x67, + 0x92, 0x8E, 0x8F, 0x32, 0xC5, 0xE0, 0x5B, 0xA4, + 0x98, 0x22, 0xA4, 0xDC, 0x76, 0x0B, 0x9B, 0x77, + 0x84, 0x31, 0x53, 0xDB, 0x34, 0xA3, 0xFA, 0xF5, + 0x64, 0xFF, 0xB2, 0xBD, 0xE5, 0x54, 0xD7, 0x5E, + 0x8E, 0x8C, 0x09, 0x4A, 0x95, 0x67, 0xC4, 0xC0 + }, + { + 0x72, 0x61, 0x2B, 0x7B, 0x30, 0x1E, 0xAA, 0x95, + 0x5E, 0x10, 0x49, 0xB4, 0xA1, 0x0F, 0x7F, 0x95, + 0x12, 0xAF, 0x23, 0xAE, 0x01, 0xA1, 0x4D, 0xA1, + 0x1D, 0xA9, 0xED, 0xC1, 0x83, 0x58, 0x9C, 0xA4, + 0x3C, 0x26, 0x34, 0x9E, 0xE8, 0x10, 0xFE, 0xDA, + 0xFD, 0xDE, 0xB5, 0xE8, 0x95, 0x1E, 0xA6, 0x28, + 0xCC, 0x14, 0xD2, 0x96, 0xB2, 0x79, 0xDD, 0xF8, + 0xDA, 0x57, 0xBD, 0x40, 0xE7, 0x0D, 0x24, 0xB9 + }, + { + 0xCE, 0xD5, 0xAD, 0x16, 0xB2, 0x13, 0xD3, 0x4D, + 0x37, 0x25, 0xF3, 0xB7, 0x3C, 0x01, 0x6F, 0x01, + 0xB4, 0x59, 0xC9, 0x8E, 0xE2, 0x2B, 0x7E, 0x88, + 0xC9, 0xE8, 0x50, 0x38, 0xAE, 0x8D, 0x22, 0x75, + 0x21, 0x8C, 0xDD, 0xF3, 0xF9, 0x08, 0xDF, 0x4C, + 0x06, 0x29, 0x43, 0x4B, 0xB6, 0x94, 0x53, 0x9D, + 0x1D, 0x29, 0xA9, 0x4D, 0x46, 0xBD, 0x0E, 0x4A, + 0x50, 0xCB, 0xE5, 0xE0, 0x74, 0xA5, 0x9A, 0x2C + }, + { + 0x1D, 0xA5, 0x79, 0xDD, 0x5C, 0x89, 0xCA, 0xC9, + 0x2A, 0x93, 0x48, 0xF8, 0xFE, 0xF3, 0xC0, 0xC5, + 0xB0, 0xC4, 0xCF, 0x42, 0x77, 0x0B, 0x7B, 0xDD, + 0xDC, 0x4C, 0xD2, 0x51, 0x62, 0x78, 0x99, 0x9F, + 0xD3, 0xB9, 0x12, 0x12, 0x88, 0xC8, 0x52, 0x59, + 0x80, 0xA0, 0xCB, 0x0F, 0x71, 0x3B, 0x6E, 0xCF, + 0xD9, 0x87, 0xB1, 0x16, 0x7A, 0xCC, 0x47, 0x1A, + 0x2A, 0xCC, 0xF6, 0xE1, 0x10, 0xB3, 0xFB, 0x13 + }, + { + 0x4E, 0x4D, 0x96, 0xBE, 0x0A, 0xD2, 0xBC, 0x78, + 0xA0, 0xC1, 0x28, 0xED, 0xC6, 0xA1, 0x60, 0xAE, + 0x8C, 0x63, 0x1C, 0xEB, 0x92, 0x70, 0x0B, 0xA6, + 0x3F, 0x82, 0x90, 0xCD, 0x8C, 0x0D, 0xB4, 0xA6, + 0xA1, 0x51, 0x55, 0x3C, 0x9A, 0x6A, 0x87, 0xFD, + 0x5D, 0x83, 0x2F, 0x15, 0x68, 0x64, 0x7B, 0xFF, + 0xBD, 0xD9, 0x67, 0xEF, 0x2F, 0xB0, 0xEA, 0x30, + 0x0D, 0x3B, 0x61, 0x95, 0x32, 0xB1, 0x8E, 0x9B + }, + { + 0xAE, 0xCB, 0xFB, 0x46, 0x2B, 0xF9, 0x53, 0x66, + 0x49, 0x61, 0x14, 0x4D, 0x19, 0xF0, 0xB5, 0x3B, + 0x18, 0xD8, 0xD4, 0xDB, 0x86, 0xC7, 0xF2, 0x1D, + 0x84, 0x2E, 0x23, 0xA4, 0x9F, 0xF3, 0x3C, 0x0F, + 0x15, 0x04, 0xBB, 0xCE, 0xE7, 0x2F, 0xFB, 0x12, + 0xD8, 0x85, 0xB1, 0xED, 0x7D, 0x71, 0x96, 0x94, + 0xE0, 0x02, 0x1B, 0x5F, 0xF1, 0x51, 0xA2, 0x43, + 0xFA, 0x27, 0x74, 0x72, 0x76, 0x95, 0xD3, 0x24 + }, + { + 0xC8, 0x3E, 0x0F, 0x4A, 0xA0, 0x25, 0x00, 0x5C, + 0xB0, 0x4D, 0xB6, 0x89, 0x55, 0x5B, 0x13, 0x87, + 0xAE, 0xB3, 0xFB, 0xDE, 0x27, 0xB3, 0x14, 0xDC, + 0xB6, 0x73, 0x89, 0x81, 0x5A, 0xE2, 0xB1, 0xA1, + 0x45, 0x9E, 0xD7, 0xA1, 0xAD, 0xD6, 0xC9, 0x68, + 0x73, 0x84, 0xCD, 0x3C, 0xDA, 0xE4, 0x69, 0xEE, + 0x34, 0x51, 0x0A, 0x13, 0xC7, 0x3B, 0x32, 0x66, + 0x93, 0xB0, 0x7F, 0x34, 0x78, 0x43, 0x10, 0x74 + }, + { + 0xF1, 0x72, 0xF1, 0xCC, 0xBE, 0x37, 0x2A, 0x13, + 0x6E, 0x49, 0x5C, 0x5E, 0x2E, 0x0E, 0xBC, 0x86, + 0xC9, 0xEC, 0x75, 0x42, 0xF4, 0xCD, 0xBC, 0xE6, + 0xAA, 0x8D, 0x96, 0xDC, 0x2E, 0x94, 0x08, 0xD5, + 0x2E, 0x00, 0x67, 0x59, 0x09, 0x31, 0xFD, 0xCD, + 0xB1, 0x41, 0xFE, 0x30, 0x48, 0xF7, 0xF0, 0x60, + 0x2E, 0xC1, 0xFF, 0x23, 0xA7, 0xA9, 0x80, 0x91, + 0x53, 0x67, 0x1A, 0x98, 0x0D, 0x51, 0x9F, 0x4C + }, + { + 0xC1, 0x71, 0x20, 0x48, 0xD6, 0xA8, 0xA3, 0x0D, + 0xA1, 0x18, 0x0D, 0x34, 0x1F, 0xD1, 0x38, 0x2D, + 0x28, 0xC7, 0xB6, 0x28, 0x9D, 0x47, 0x27, 0xA7, + 0x57, 0xCC, 0x2F, 0xC7, 0x2E, 0xC4, 0x19, 0x38, + 0x14, 0x1A, 0xAF, 0x7C, 0xFD, 0x8D, 0x9B, 0x40, + 0x3B, 0x9C, 0x0C, 0x4B, 0x97, 0x0C, 0xE0, 0xFC, + 0x35, 0x5F, 0x4C, 0x4A, 0xD7, 0x31, 0x46, 0x2D, + 0xB3, 0xA3, 0x31, 0xA5, 0x5B, 0xA3, 0xA3, 0x76 + }, + { + 0xC7, 0x09, 0xB5, 0x16, 0xFF, 0xAD, 0xC8, 0x64, + 0x4C, 0x72, 0x91, 0xD5, 0xC2, 0xFD, 0xF2, 0xC9, + 0x18, 0xD2, 0x3D, 0xC1, 0xF3, 0x35, 0xCE, 0x28, + 0x9D, 0xB8, 0x2E, 0xBA, 0xE9, 0x7D, 0x32, 0x71, + 0xC6, 0x1E, 0xA5, 0x7E, 0xB4, 0xE2, 0x13, 0x90, + 0x5C, 0xEE, 0x80, 0x48, 0x41, 0xF1, 0xFF, 0x72, + 0xC2, 0xE0, 0xC3, 0x05, 0x3B, 0xAC, 0x71, 0xF6, + 0xEA, 0x4F, 0xE2, 0x47, 0xE9, 0x29, 0xDB, 0x04 + }, + { + 0x35, 0x17, 0x88, 0xD0, 0x24, 0x5F, 0x53, 0x09, + 0xB2, 0xE5, 0x5A, 0x9F, 0x5B, 0x34, 0x4B, 0x89, + 0xC5, 0xFE, 0x05, 0xDB, 0x9B, 0xEC, 0x14, 0x20, + 0x20, 0x56, 0x5C, 0x7B, 0x79, 0x8E, 0xE8, 0x6E, + 0x6E, 0xD9, 0x4C, 0x38, 0x65, 0x37, 0x84, 0xAA, + 0xE0, 0x87, 0x0B, 0xF4, 0x18, 0x63, 0xD1, 0x86, + 0x3C, 0x68, 0x32, 0x57, 0x33, 0xAB, 0x1A, 0x4E, + 0xB6, 0xD1, 0x3B, 0xB7, 0xDA, 0xC9, 0x13, 0x4E + }, + { + 0x85, 0xC1, 0xF2, 0x6C, 0x9C, 0x42, 0x11, 0xDF, + 0xEE, 0x63, 0xE7, 0xF3, 0x4E, 0x7D, 0x3A, 0x46, + 0x51, 0xFC, 0x39, 0x80, 0x6F, 0x03, 0x0D, 0x18, + 0xED, 0x43, 0xFC, 0x13, 0x9B, 0x72, 0xEF, 0x91, + 0xAD, 0x19, 0x9F, 0x9A, 0x76, 0x4C, 0x79, 0x21, + 0xCC, 0x1E, 0x78, 0x63, 0xBF, 0x24, 0xFB, 0x74, + 0x83, 0x73, 0xDD, 0xBA, 0xED, 0x0C, 0x71, 0x34, + 0x84, 0x02, 0x33, 0x05, 0x1B, 0xCA, 0x35, 0x42 + }, + { + 0x66, 0xD4, 0xD3, 0x79, 0x65, 0xBE, 0x06, 0x52, + 0x5C, 0x2A, 0x04, 0xF0, 0x46, 0xDD, 0x7E, 0xF3, + 0x1C, 0xF0, 0x17, 0xB2, 0x70, 0x78, 0x2A, 0x73, + 0xF4, 0x03, 0xF8, 0x6E, 0xCE, 0xFF, 0x5C, 0x23, + 0x83, 0x11, 0x06, 0x04, 0x2E, 0xB9, 0x43, 0x43, + 0x49, 0x58, 0xC6, 0x8A, 0xAC, 0x35, 0xB4, 0x8C, + 0x0F, 0xA2, 0x7C, 0xDD, 0x66, 0xAD, 0x17, 0xDF, + 0x68, 0xE6, 0x66, 0xD3, 0x64, 0x68, 0x8B, 0xD6 + }, + { + 0x13, 0x1E, 0x4A, 0xB4, 0xBC, 0x05, 0x90, 0x2C, + 0xA8, 0xE0, 0xD0, 0x00, 0xAD, 0x25, 0xC8, 0x12, + 0xCC, 0x8B, 0xE2, 0x7F, 0x72, 0xEB, 0x1F, 0x55, + 0x26, 0x29, 0xAD, 0x0E, 0xB5, 0xC7, 0xD0, 0x4C, + 0xE9, 0xF7, 0xD4, 0xFA, 0x87, 0x24, 0x8D, 0x25, + 0x1A, 0x2D, 0x1F, 0x7E, 0xF4, 0x52, 0x18, 0x41, + 0x7D, 0xD6, 0x3D, 0x22, 0xE8, 0x88, 0xAA, 0x67, + 0xA8, 0x4F, 0xD1, 0xB2, 0xD9, 0xC1, 0x89, 0xB9 + }, + { + 0xF2, 0xCB, 0x10, 0x9B, 0xC5, 0x83, 0x01, 0xBA, + 0xED, 0xC0, 0xAC, 0x80, 0xC6, 0x36, 0x00, 0xE4, + 0x1D, 0x2B, 0xA2, 0x88, 0x88, 0x02, 0x49, 0x36, + 0x95, 0x3A, 0xC8, 0x61, 0x7D, 0xCC, 0xD1, 0x5C, + 0x0B, 0x65, 0x2F, 0x97, 0x8D, 0xEB, 0x45, 0xE8, + 0x24, 0xDF, 0x6B, 0xC6, 0xBE, 0xE3, 0x8D, 0x8F, + 0x3B, 0x0B, 0xEF, 0x51, 0xE4, 0x89, 0x47, 0xA7, + 0x41, 0x50, 0x94, 0xDA, 0x6D, 0x24, 0xFB, 0x73 + }, + { + 0x5A, 0x67, 0x1A, 0xD6, 0x9A, 0x2C, 0x5C, 0x30, + 0xBD, 0x04, 0x4A, 0x0E, 0xFF, 0xE9, 0x53, 0x13, + 0x75, 0x9A, 0x26, 0x46, 0xC3, 0x0F, 0xE6, 0x4D, + 0xEA, 0x7F, 0x5F, 0x89, 0x66, 0x8A, 0x54, 0x74, + 0x10, 0xC0, 0x55, 0x97, 0x41, 0x58, 0xBA, 0x30, + 0xC7, 0x1C, 0xA5, 0xFD, 0xD5, 0xBE, 0xB1, 0xBA, + 0xDB, 0x2C, 0x13, 0x3A, 0xBF, 0x6D, 0x9F, 0x6C, + 0xD6, 0x0D, 0xAB, 0x17, 0x9F, 0x8E, 0xB6, 0x9D + }, + { + 0x04, 0x51, 0xFB, 0x06, 0xAE, 0x60, 0xEA, 0x29, + 0xEF, 0xFA, 0x35, 0xB1, 0x6D, 0x33, 0xBA, 0xB8, + 0x77, 0xA1, 0x78, 0x64, 0xC3, 0xC0, 0xD4, 0x02, + 0xBC, 0x00, 0x55, 0x57, 0x77, 0xB2, 0xFB, 0x4F, + 0x64, 0x8B, 0xC6, 0x25, 0xBB, 0xC9, 0x00, 0x18, + 0x8B, 0x74, 0xCF, 0x9A, 0xB7, 0x8F, 0x8C, 0x88, + 0x26, 0x05, 0xB4, 0x43, 0xA3, 0x66, 0xC1, 0xFC, + 0x89, 0x3E, 0x5C, 0x5E, 0x5E, 0x93, 0x8F, 0xD3 + }, + { + 0x87, 0x6A, 0x1E, 0x07, 0x84, 0xDA, 0xFA, 0xA8, + 0xF4, 0xD5, 0xD3, 0x55, 0xEE, 0x26, 0xD2, 0x45, + 0x7C, 0x3C, 0x64, 0xCC, 0x35, 0x0A, 0xF9, 0x35, + 0x09, 0x21, 0xAC, 0x8B, 0x20, 0x9D, 0x82, 0xC3, + 0x37, 0x26, 0x9C, 0x6A, 0x6A, 0xE4, 0x90, 0x87, + 0xD2, 0x3D, 0x86, 0x20, 0xA0, 0x66, 0x8E, 0x0A, + 0x62, 0x7C, 0x7E, 0xD2, 0x1D, 0xE4, 0x3E, 0x5C, + 0x31, 0x35, 0xA6, 0xCF, 0xCB, 0xDD, 0x62, 0x53 + }, + { + 0x74, 0x25, 0x62, 0xBD, 0xA5, 0xAF, 0x51, 0xAF, + 0x5B, 0x71, 0x70, 0x18, 0x15, 0x5E, 0x02, 0x61, + 0xB7, 0xBE, 0x0B, 0x30, 0x31, 0xF1, 0x37, 0xEB, + 0xB0, 0xFA, 0x0D, 0xCE, 0x79, 0x6A, 0xDA, 0x33, + 0xE5, 0x7D, 0xDA, 0x70, 0xD4, 0xEF, 0x7C, 0x34, + 0x3A, 0x57, 0x87, 0x72, 0x3C, 0x15, 0x47, 0xEB, + 0xE8, 0x11, 0x9E, 0x41, 0x0F, 0x8B, 0x93, 0xA3, + 0x65, 0xE4, 0x22, 0xB1, 0xBE, 0x6A, 0x7B, 0xEA + }, + { + 0x23, 0x47, 0xDF, 0xA6, 0xED, 0x3E, 0x47, 0x16, + 0xA9, 0xBB, 0x7B, 0x91, 0x7F, 0x1E, 0xEB, 0x93, + 0xF3, 0x4C, 0x87, 0x5B, 0x39, 0xBD, 0xEF, 0x93, + 0xB3, 0x6B, 0xF1, 0x1A, 0xFF, 0xB9, 0xC2, 0x7F, + 0x6D, 0x57, 0x0D, 0x5E, 0xF2, 0xB8, 0x8E, 0xBB, + 0x3B, 0xC5, 0x01, 0x3F, 0xDA, 0x28, 0x73, 0x22, + 0x94, 0x44, 0xBB, 0xCB, 0xCE, 0x92, 0xB4, 0x1A, + 0xE8, 0xF2, 0xED, 0xBF, 0x93, 0x79, 0xEE, 0xE2 + }, + { + 0x57, 0xFD, 0xD2, 0x03, 0x80, 0x7F, 0xD1, 0xCC, + 0x74, 0xA9, 0xF1, 0x2F, 0x3F, 0x6B, 0x3D, 0x57, + 0xEC, 0xCC, 0x1D, 0x98, 0xE7, 0xAD, 0xB0, 0x76, + 0x3E, 0x42, 0x79, 0xDC, 0xB5, 0xB6, 0xFB, 0xD8, + 0xA5, 0x42, 0x1C, 0x73, 0xB0, 0x4A, 0x51, 0x92, + 0xF4, 0x4B, 0x3C, 0x67, 0xF5, 0x69, 0x0A, 0xA4, + 0x54, 0x59, 0x7A, 0xBD, 0x0D, 0x70, 0x88, 0x8F, + 0xCF, 0x93, 0xA2, 0x55, 0x67, 0xCE, 0x38, 0x39 + }, + { + 0xB9, 0xD8, 0x22, 0x65, 0x23, 0x6B, 0xEA, 0x7A, + 0xDE, 0x6B, 0xA6, 0xF8, 0x20, 0xFD, 0x16, 0xCC, + 0xB9, 0x3C, 0x79, 0x17, 0xCE, 0x24, 0x67, 0xAB, + 0xD8, 0xE4, 0xFC, 0xD4, 0x9E, 0xBB, 0xAF, 0x4B, + 0xDB, 0xB9, 0x40, 0x8E, 0x83, 0x04, 0xB6, 0x6C, + 0x00, 0xAD, 0x93, 0xEC, 0xF8, 0xCB, 0x57, 0x9F, + 0xC6, 0x1E, 0x45, 0x95, 0x98, 0x5A, 0xD9, 0x73, + 0x4C, 0x00, 0x9E, 0xC7, 0x63, 0x56, 0x3D, 0xDB + }, + { + 0x22, 0x71, 0x1E, 0xFC, 0x2E, 0xEC, 0xEA, 0xBD, + 0x96, 0x83, 0x8F, 0xB8, 0x66, 0x0E, 0x0B, 0x5D, + 0x23, 0x1A, 0x45, 0x54, 0xB6, 0xCC, 0x7A, 0x02, + 0x1D, 0x12, 0xB5, 0xA4, 0x1B, 0xF8, 0xA9, 0xAE, + 0x15, 0x41, 0xE9, 0x12, 0x09, 0x9C, 0xCE, 0x70, + 0x97, 0x51, 0x0F, 0x89, 0x8E, 0x92, 0x3C, 0x5B, + 0x8C, 0x84, 0xC0, 0x21, 0xE1, 0x81, 0x67, 0x79, + 0x43, 0x1B, 0x21, 0x05, 0x30, 0x01, 0x72, 0x2B + }, + { + 0x66, 0xEB, 0x5B, 0x01, 0x49, 0x5A, 0x00, 0xCA, + 0x1C, 0xF6, 0xA3, 0xAC, 0xFF, 0x1B, 0xDC, 0x02, + 0x25, 0xFF, 0x25, 0x40, 0x2B, 0x05, 0xB8, 0x68, + 0x8C, 0xEC, 0xFD, 0x0F, 0xF2, 0x11, 0x18, 0x5C, + 0xA2, 0xE3, 0xEF, 0x06, 0xE2, 0xC4, 0x26, 0x0E, + 0x43, 0xD6, 0xCB, 0x0D, 0xDE, 0x25, 0x68, 0x15, + 0x67, 0x54, 0x89, 0x5D, 0xAB, 0xB1, 0xE0, 0x3A, + 0xB7, 0x8C, 0xA9, 0xBF, 0xB4, 0x24, 0x69, 0x75 + }, + { + 0xAB, 0x1F, 0x2A, 0xF5, 0xE3, 0x23, 0xE0, 0xF2, + 0xAC, 0x4A, 0xA3, 0x1B, 0x59, 0x5B, 0x84, 0x77, + 0xC5, 0x80, 0x50, 0x2A, 0x71, 0x9C, 0xF9, 0xBC, + 0x0E, 0xB7, 0xA1, 0xA9, 0xCB, 0x4C, 0x0A, 0x7A, + 0x14, 0x2F, 0xB4, 0x25, 0x93, 0xB1, 0x09, 0x4C, + 0x44, 0x82, 0xCC, 0x78, 0xFB, 0x70, 0xDD, 0x82, + 0xF8, 0xC4, 0x4D, 0x1E, 0x17, 0x2D, 0xF3, 0x43, + 0x20, 0xC3, 0x26, 0x44, 0x37, 0x6C, 0xE7, 0xC0 + }, + { + 0xBB, 0xA9, 0x28, 0xDB, 0x0D, 0xCF, 0x53, 0xEC, + 0x8C, 0x97, 0x7C, 0x0A, 0x32, 0x67, 0xBF, 0x12, + 0x21, 0x75, 0x9C, 0x1D, 0x8F, 0x08, 0x51, 0xB9, + 0x8E, 0x59, 0x85, 0xFD, 0x8F, 0x8D, 0x63, 0x3E, + 0xAD, 0x35, 0x0E, 0xEF, 0x1D, 0x62, 0xCC, 0x9A, + 0x30, 0x2D, 0x54, 0x1A, 0x28, 0xD4, 0xD2, 0xF7, + 0x44, 0xF9, 0x0A, 0x2B, 0x69, 0x1C, 0x51, 0xF6, + 0x24, 0xF5, 0x0D, 0x40, 0x2F, 0xD9, 0x8B, 0xD4 + }, + { + 0x66, 0xE2, 0x2F, 0x73, 0x49, 0xC9, 0x71, 0xD5, + 0x5D, 0x58, 0xB3, 0x2A, 0x75, 0x66, 0x68, 0xC5, + 0x29, 0xE1, 0xCE, 0x87, 0x2D, 0xFA, 0x73, 0x8B, + 0x49, 0x89, 0x1D, 0xFD, 0xAD, 0x33, 0x79, 0x4C, + 0xF8, 0x41, 0x65, 0x38, 0x66, 0xB5, 0x3B, 0x3E, + 0xED, 0xAD, 0xD6, 0xAE, 0x25, 0x4C, 0x23, 0x60, + 0x3E, 0xD4, 0x26, 0x29, 0x1E, 0x3D, 0x9D, 0x42, + 0x49, 0x8F, 0xA8, 0xAC, 0xEE, 0x87, 0xBD, 0xEF + }, + { + 0x23, 0x1B, 0x18, 0x13, 0xEA, 0xA8, 0xA3, 0xBB, + 0x5A, 0x6A, 0x1C, 0x35, 0x85, 0x7A, 0x3A, 0x53, + 0x40, 0x39, 0xF0, 0x84, 0xAC, 0x71, 0x47, 0x29, + 0x6F, 0x81, 0x1B, 0x85, 0x55, 0x6D, 0xFE, 0xF7, + 0x0F, 0xDF, 0xAE, 0xB4, 0x02, 0x36, 0x0E, 0xD6, + 0x48, 0xBE, 0x36, 0xFA, 0xD9, 0x08, 0x12, 0xBE, + 0xCF, 0xBF, 0xEF, 0xFF, 0xBC, 0x76, 0x02, 0x77, + 0xD0, 0xA4, 0xA3, 0xC3, 0x57, 0xB1, 0x90, 0x1D + }, + { + 0xF2, 0x95, 0x29, 0xB3, 0xC8, 0x80, 0x49, 0xE7, + 0x2D, 0x84, 0x95, 0x92, 0x4A, 0x1A, 0x90, 0xDD, + 0xC6, 0xB9, 0x37, 0x93, 0x0A, 0x42, 0x79, 0x90, + 0x14, 0x1C, 0x4E, 0xB6, 0x21, 0x9D, 0x8F, 0xF6, + 0x0B, 0x34, 0xFD, 0x77, 0x25, 0x2A, 0x84, 0x14, + 0xEB, 0x21, 0x88, 0xB2, 0xA4, 0x4A, 0x3D, 0x0C, + 0x1C, 0x8F, 0xA8, 0x25, 0xEF, 0xE4, 0x74, 0x1F, + 0x93, 0x03, 0x4B, 0x87, 0xCE, 0x8F, 0x1A, 0x9C + }, + { + 0x94, 0x38, 0xAD, 0xA2, 0x4A, 0x12, 0x05, 0x99, + 0xE9, 0x52, 0x30, 0x39, 0xB5, 0x10, 0x04, 0xFC, + 0x34, 0x4F, 0x86, 0xEE, 0xAA, 0xC0, 0xBE, 0xB1, + 0x00, 0x04, 0x8C, 0xDF, 0x8F, 0xF4, 0x4C, 0xF7, + 0x13, 0x4A, 0x9B, 0xB8, 0xDE, 0xA5, 0x34, 0x35, + 0xC1, 0x5B, 0x14, 0x34, 0x4D, 0xAD, 0x01, 0x0E, + 0x92, 0xDE, 0x64, 0x85, 0x3E, 0xD1, 0xCF, 0xF4, + 0xA4, 0x8A, 0x76, 0xF0, 0x74, 0x35, 0xCE, 0xCD + }, + { + 0xDD, 0x9C, 0xAA, 0x06, 0x4D, 0xD2, 0xB5, 0x76, + 0xCF, 0x63, 0x5D, 0x17, 0xA3, 0x53, 0x46, 0x0A, + 0x47, 0x62, 0xC2, 0x63, 0xBD, 0xC9, 0xFE, 0x0E, + 0x26, 0x81, 0xE7, 0x9D, 0x77, 0x50, 0xC0, 0x8E, + 0x51, 0x1A, 0xF1, 0xFA, 0x04, 0x25, 0x83, 0x49, + 0x96, 0x63, 0x29, 0x14, 0xE7, 0xCB, 0x4E, 0x8E, + 0x12, 0xA4, 0x1A, 0x50, 0x46, 0x2F, 0x65, 0x25, + 0xFE, 0x10, 0xE8, 0xFA, 0x73, 0xE2, 0x94, 0xD5 + }, + { + 0xB2, 0x66, 0xEC, 0x23, 0x03, 0x34, 0xD4, 0x65, + 0xE2, 0xD6, 0x50, 0xA7, 0xBA, 0x8E, 0x3D, 0x5F, + 0x6A, 0xB2, 0xF4, 0x6D, 0xD0, 0x4E, 0x53, 0x4C, + 0x67, 0x1E, 0x24, 0xAC, 0x22, 0x28, 0xC7, 0x10, + 0xA5, 0x46, 0xB8, 0x24, 0x25, 0x34, 0xF6, 0x53, + 0x17, 0x10, 0xBD, 0x6A, 0x02, 0x46, 0x66, 0xCB, + 0x36, 0x5E, 0x37, 0x62, 0x4C, 0x0F, 0x9F, 0x9F, + 0xA0, 0xE9, 0xF3, 0xE7, 0x55, 0xA7, 0xCD, 0xB8 + }, + { + 0xF8, 0x48, 0x6B, 0x0E, 0x67, 0xF6, 0x83, 0xE8, + 0x03, 0x69, 0xF4, 0x77, 0x20, 0x95, 0xE6, 0x5F, + 0xF8, 0x19, 0x25, 0xD2, 0xFE, 0x90, 0xA0, 0xB0, + 0x28, 0xE0, 0xD3, 0xA4, 0xD6, 0x1A, 0x1B, 0xE8, + 0xD3, 0x14, 0x18, 0xCE, 0x3B, 0xC9, 0x1B, 0x08, + 0x34, 0x92, 0x0B, 0xC1, 0x12, 0x5B, 0xB7, 0x6F, + 0xC7, 0x14, 0x96, 0xAA, 0x98, 0xCB, 0x07, 0x68, + 0xC5, 0x02, 0xA8, 0xC3, 0x81, 0x74, 0x75, 0xC9 + }, + { + 0x7D, 0x5D, 0x76, 0xCD, 0x15, 0xD6, 0x79, 0x09, + 0xD3, 0x1F, 0xE9, 0xD6, 0x1C, 0x37, 0x6D, 0x7E, + 0x92, 0x10, 0x81, 0x67, 0x25, 0x99, 0xE4, 0x45, + 0x7E, 0x85, 0x52, 0xE1, 0xB9, 0x9B, 0x66, 0xA6, + 0xC6, 0xFE, 0x99, 0xFB, 0x8D, 0xC4, 0x7A, 0x04, + 0x43, 0x74, 0x6C, 0x2D, 0x00, 0x16, 0x60, 0xDE, + 0x8F, 0x61, 0x50, 0xAA, 0x73, 0x85, 0x9F, 0x8C, + 0x96, 0x2B, 0xE6, 0xF4, 0x2E, 0x2B, 0xDF, 0x2F + }, + { + 0xE0, 0x97, 0x3B, 0xB8, 0x0B, 0x67, 0x30, 0x77, + 0x4F, 0xF5, 0x55, 0x08, 0x00, 0x55, 0x54, 0xCF, + 0x60, 0xFB, 0xF3, 0x46, 0x81, 0x15, 0x6C, 0x74, + 0xA9, 0x22, 0x0B, 0x2E, 0x74, 0x2C, 0xF8, 0xCC, + 0x76, 0xC6, 0xA6, 0x43, 0x8E, 0x73, 0xB3, 0x7D, + 0x3A, 0x5F, 0xFF, 0x98, 0xAE, 0x6C, 0x04, 0xEC, + 0xB7, 0x33, 0x78, 0xBA, 0x28, 0x04, 0x5C, 0x20, + 0x8C, 0x3C, 0xFC, 0x0D, 0xE8, 0x79, 0xE6, 0xE6 + }, + { + 0xF2, 0xFF, 0x53, 0x62, 0x1D, 0x4D, 0x43, 0xB0, + 0x05, 0x41, 0xC3, 0xDB, 0x43, 0x32, 0x94, 0x36, + 0xEA, 0xD6, 0x88, 0x86, 0xDB, 0xB2, 0x7C, 0xE3, + 0x7A, 0xAD, 0x26, 0x21, 0x47, 0x6D, 0xBF, 0x1F, + 0xD5, 0x33, 0x01, 0xDD, 0x42, 0xD2, 0xB9, 0x14, + 0x5D, 0x77, 0x3E, 0xD1, 0xDD, 0x1D, 0x1D, 0x27, + 0xBB, 0x3C, 0x65, 0xF2, 0xE3, 0x3D, 0x36, 0xB3, + 0x4F, 0x4D, 0x48, 0x80, 0xC9, 0x54, 0x38, 0x82 + }, + { + 0x5B, 0x62, 0x7E, 0x28, 0xD3, 0x53, 0x72, 0xAB, + 0x8F, 0xD9, 0xC8, 0xCE, 0xB6, 0x03, 0x9D, 0x45, + 0xCC, 0x37, 0x12, 0xFB, 0xFA, 0x94, 0xBD, 0xFD, + 0x68, 0x6C, 0x9F, 0x08, 0xDB, 0x78, 0xED, 0xF2, + 0xEF, 0x37, 0x47, 0x31, 0x58, 0x6A, 0x1C, 0x99, + 0xD3, 0xA6, 0xCD, 0x61, 0xF2, 0x86, 0xAC, 0xD0, + 0xF2, 0x5D, 0x4A, 0x8B, 0xDA, 0x28, 0xD7, 0x1F, + 0x6E, 0x3D, 0x44, 0xB4, 0x44, 0xEA, 0xDB, 0x5C + }, + { + 0xB7, 0x24, 0x16, 0x57, 0xA8, 0xBE, 0x5D, 0x47, + 0xD2, 0x7C, 0xC0, 0xBC, 0x53, 0xF1, 0xD5, 0xC1, + 0x4B, 0x64, 0x1D, 0xC3, 0x33, 0xC1, 0xCB, 0xF1, + 0x5F, 0x19, 0x36, 0xD8, 0xC2, 0x63, 0x7B, 0x86, + 0x46, 0xCE, 0x5B, 0x56, 0x54, 0xE0, 0x6B, 0xCA, + 0x07, 0x6C, 0xB2, 0x6E, 0xBA, 0x57, 0xBD, 0x5A, + 0xA4, 0x46, 0x4E, 0xFB, 0x02, 0xC0, 0xE2, 0x50, + 0x91, 0xBF, 0x14, 0xF5, 0x28, 0x9C, 0x02, 0x20 + }, + { + 0xE4, 0x3F, 0x93, 0x97, 0x8F, 0x0E, 0x62, 0x34, + 0xBE, 0xEB, 0xCC, 0x0E, 0x64, 0xF4, 0x46, 0x2F, + 0xD6, 0x05, 0x8E, 0xF3, 0x20, 0x23, 0x52, 0x7C, + 0x5E, 0x2A, 0x78, 0x69, 0x8F, 0x28, 0xC2, 0x9C, + 0x99, 0x5B, 0x9D, 0xA8, 0x7D, 0x7F, 0x5D, 0xAF, + 0x6D, 0xB9, 0x6D, 0x1F, 0x61, 0x06, 0x07, 0x3A, + 0x04, 0x41, 0xB4, 0xE9, 0x3A, 0x50, 0x23, 0xBC, + 0xF6, 0x5A, 0x6B, 0x6E, 0x03, 0x36, 0xDD, 0xFC + }, + { + 0x67, 0x5A, 0xE7, 0x70, 0x6A, 0xBC, 0xFA, 0xF4, + 0xE9, 0x81, 0xD4, 0x93, 0xA4, 0x57, 0xD8, 0xF0, + 0x63, 0x5C, 0x75, 0x55, 0x97, 0x55, 0x4E, 0x8F, + 0xA5, 0x37, 0x06, 0xF6, 0xDE, 0xCA, 0xF1, 0x67, + 0xCF, 0x5E, 0x36, 0x0E, 0x7C, 0x1A, 0x7F, 0x24, + 0xF7, 0x49, 0x70, 0x51, 0xE1, 0x7B, 0x15, 0xF1, + 0xED, 0x9F, 0x4F, 0xD3, 0x63, 0x83, 0x72, 0xA3, + 0x50, 0x81, 0xAC, 0xDE, 0x10, 0x3B, 0x71, 0x95 + }, + { + 0x3E, 0xFB, 0x8F, 0xF8, 0x04, 0x73, 0xC9, 0xE3, + 0xDE, 0xC4, 0x15, 0xA0, 0xBD, 0x63, 0x77, 0xEC, + 0x0E, 0xED, 0x70, 0xB9, 0xF3, 0xBF, 0x7A, 0x3E, + 0xCC, 0x1B, 0x2E, 0xBE, 0x25, 0xB1, 0x5A, 0x99, + 0xED, 0x12, 0x5C, 0x57, 0x47, 0xCF, 0x17, 0x39, + 0x6B, 0xA0, 0x0C, 0xD9, 0xC0, 0x0F, 0xC3, 0xD4, + 0x64, 0x6F, 0x64, 0x93, 0x95, 0x29, 0xED, 0x83, + 0xA1, 0x48, 0xE2, 0x67, 0x25, 0x6A, 0xE4, 0x75 + }, + { + 0xDE, 0x08, 0x69, 0x9E, 0x36, 0xE2, 0x57, 0xD0, + 0xE9, 0x26, 0x1E, 0xEE, 0x30, 0x3F, 0xFE, 0xF9, + 0xD4, 0x8D, 0xFF, 0xFB, 0xC2, 0xBD, 0x4D, 0xDF, + 0x27, 0x56, 0xFF, 0xC8, 0x14, 0xBC, 0x06, 0xB0, + 0x3E, 0x40, 0x00, 0xCA, 0xC8, 0x88, 0x04, 0x4C, + 0x3A, 0xC5, 0x09, 0x0F, 0xB5, 0xF5, 0x48, 0x02, + 0x71, 0xE8, 0x9F, 0xDC, 0x08, 0xAE, 0xE4, 0xAF, + 0x61, 0x88, 0x57, 0x7A, 0xC9, 0xBE, 0x9B, 0xB9 + }, + { + 0x91, 0x76, 0x45, 0x38, 0xA3, 0x32, 0x23, 0x26, + 0xE8, 0x88, 0x2C, 0xA3, 0x9D, 0x44, 0xD8, 0x21, + 0x41, 0xE1, 0xFD, 0x0B, 0xA2, 0xBC, 0xF0, 0xF9, + 0x99, 0xC6, 0xEF, 0x8D, 0x3A, 0xA6, 0x59, 0x68, + 0x28, 0xC4, 0x70, 0x8E, 0xBD, 0xE4, 0x9A, 0x8B, + 0xD5, 0x37, 0xAC, 0x9A, 0x34, 0x0F, 0x13, 0x17, + 0xAC, 0x9F, 0x06, 0x6D, 0xA4, 0x3E, 0x41, 0x9F, + 0xF8, 0x50, 0x50, 0xD7, 0xD7, 0xD8, 0xE6, 0x10 + }, + { + 0xE4, 0x64, 0xB9, 0x1F, 0x41, 0x61, 0xCF, 0xD7, + 0x9A, 0xE1, 0xC3, 0xBA, 0xBF, 0x6B, 0x0F, 0x89, + 0xDB, 0x7C, 0xC5, 0xE3, 0x6C, 0xAB, 0x70, 0xE4, + 0x6C, 0xAC, 0xF4, 0x85, 0x05, 0xA0, 0x32, 0x42, + 0x9F, 0xE8, 0x95, 0xFB, 0x10, 0x45, 0x53, 0x9B, + 0xAC, 0xD7, 0xE1, 0x21, 0x51, 0xD9, 0xFF, 0x1C, + 0xA1, 0x4D, 0x0F, 0x64, 0xF7, 0x1A, 0x52, 0x49, + 0x02, 0xA7, 0x90, 0x92, 0x79, 0xF0, 0xCC, 0x17 + }, + { + 0x25, 0x1A, 0x4B, 0xB6, 0xF9, 0x6E, 0xD2, 0x30, + 0x2C, 0x23, 0xA9, 0x1D, 0x01, 0x0C, 0x2F, 0x06, + 0x17, 0x91, 0xE3, 0x3C, 0x13, 0x3C, 0x59, 0x9F, + 0x6B, 0x92, 0x09, 0x8D, 0xA1, 0xEE, 0x8C, 0xDB, + 0xEF, 0xFE, 0x63, 0x20, 0xDA, 0x63, 0xB8, 0xD8, + 0xF1, 0x05, 0x6C, 0x86, 0x03, 0x65, 0x81, 0x2C, + 0x29, 0x23, 0x8F, 0x48, 0x77, 0xCF, 0x3B, 0x92, + 0xEF, 0x01, 0x3E, 0x4D, 0x85, 0xEE, 0xEC, 0x2A + }, + { + 0xD2, 0xA2, 0xCB, 0xFF, 0xE8, 0xBE, 0xBB, 0x98, + 0xDD, 0x2B, 0x1F, 0x5A, 0xDF, 0x29, 0x35, 0x51, + 0xBF, 0x7F, 0xB7, 0xEC, 0x21, 0x82, 0x4E, 0x51, + 0xFD, 0x5A, 0x4B, 0xA2, 0xD4, 0x5A, 0x9D, 0x00, + 0xC5, 0x2D, 0x24, 0x52, 0x55, 0x6E, 0x6B, 0xF3, + 0x88, 0x5E, 0xDD, 0x84, 0xEB, 0x1A, 0x71, 0x47, + 0xD5, 0xE4, 0xAA, 0x72, 0xA4, 0x19, 0x58, 0x22, + 0x40, 0x81, 0x18, 0x13, 0xEC, 0xEE, 0xF5, 0xDC + }, + { + 0x8A, 0x7F, 0xAB, 0x24, 0xBE, 0xAA, 0x1D, 0x18, + 0x2F, 0x93, 0xF5, 0x14, 0xBB, 0xAB, 0x76, 0x19, + 0x9C, 0x1F, 0x5D, 0x0B, 0x15, 0xA8, 0xAA, 0x99, + 0x54, 0xB3, 0xE5, 0xFA, 0xCC, 0x40, 0x1A, 0x99, + 0x80, 0x0A, 0x71, 0x2F, 0x14, 0xA3, 0x49, 0xB3, + 0xB2, 0x94, 0x70, 0x7A, 0x1F, 0xF4, 0x02, 0xA8, + 0xDE, 0xB5, 0x74, 0xF7, 0x1F, 0x2E, 0xE9, 0xFB, + 0xFB, 0xD4, 0x8D, 0xEB, 0x28, 0x0D, 0xC6, 0xF5 + }, + { + 0x27, 0x9C, 0x05, 0x1A, 0xCF, 0x86, 0x85, 0x62, + 0x98, 0x41, 0x0F, 0x99, 0x9E, 0x56, 0x3A, 0x2E, + 0x17, 0x37, 0xBA, 0xA8, 0xCD, 0x08, 0x31, 0xC0, + 0x59, 0x12, 0x0E, 0xE0, 0xB8, 0x3C, 0xFA, 0x5B, + 0xBD, 0xCE, 0x93, 0x80, 0xC5, 0x53, 0x2C, 0x35, + 0xAF, 0xB8, 0x16, 0x5A, 0x83, 0x42, 0xE7, 0xE9, + 0x62, 0x32, 0x0C, 0xC0, 0x1A, 0x8B, 0x6C, 0x57, + 0x1B, 0x54, 0xFD, 0x82, 0x49, 0xC8, 0x2E, 0x93 + }, + { + 0x9D, 0xE6, 0xF1, 0xB5, 0x8F, 0x23, 0xA2, 0xAB, + 0x89, 0x08, 0x96, 0x68, 0x50, 0x71, 0x39, 0xF2, + 0x39, 0xEC, 0x5C, 0xC7, 0x7F, 0x9B, 0x47, 0xE1, + 0x7D, 0xFF, 0x3E, 0x96, 0x66, 0xE9, 0xC5, 0xE9, + 0x2C, 0xD9, 0x7D, 0x9C, 0x87, 0x79, 0xD9, 0xF9, + 0xB3, 0x3C, 0xE8, 0xB2, 0xCA, 0xC4, 0x26, 0x74, + 0x33, 0xCF, 0x4A, 0x7F, 0x42, 0x42, 0xAF, 0x2B, + 0x17, 0xE6, 0x05, 0xEE, 0x00, 0xE9, 0x51, 0xD4 + }, + { + 0xCF, 0xBD, 0xC7, 0x8E, 0xEE, 0x4B, 0x29, 0x84, + 0xA0, 0x91, 0xDF, 0x48, 0x2E, 0x46, 0xAD, 0x1F, + 0x08, 0x51, 0x47, 0xF8, 0xBD, 0x19, 0x00, 0xFD, + 0x87, 0x16, 0x53, 0xD7, 0xB7, 0x4B, 0x95, 0xE6, + 0x05, 0x1E, 0x2F, 0xA6, 0x74, 0x9F, 0xEC, 0xA1, + 0x82, 0x41, 0x92, 0x92, 0xE7, 0x16, 0x88, 0x43, + 0x05, 0xBF, 0xD2, 0x8A, 0xD6, 0x43, 0x69, 0x00, + 0x49, 0xE5, 0x4C, 0x99, 0xEF, 0x9A, 0xE0, 0x43 + }, + { + 0xD4, 0x47, 0x05, 0x5F, 0xAE, 0xB4, 0x48, 0x5C, + 0x4F, 0xB7, 0xBD, 0x80, 0x65, 0xEC, 0x54, 0xE1, + 0x8B, 0xF6, 0x84, 0xC7, 0x38, 0x7D, 0xB2, 0x3D, + 0xD6, 0xF8, 0x7F, 0x4F, 0xA6, 0xD3, 0x42, 0x31, + 0x60, 0x28, 0x7E, 0xC7, 0x29, 0xD6, 0xE0, 0xC3, + 0xB9, 0xD8, 0x1E, 0x76, 0x4B, 0x41, 0xDF, 0xC6, + 0x9E, 0x64, 0xF4, 0xAD, 0x2D, 0xA5, 0x92, 0x00, + 0x77, 0xF5, 0xF0, 0x21, 0xF2, 0xEB, 0x73, 0x04 + }, + { + 0x81, 0xB0, 0x2B, 0xC8, 0x93, 0x80, 0x71, 0xAE, + 0x6D, 0x95, 0x9C, 0x94, 0x82, 0x84, 0xFB, 0x5B, + 0xFC, 0xC9, 0x1C, 0x11, 0xD0, 0x9C, 0xC6, 0xC1, + 0xC1, 0xC2, 0x19, 0x0D, 0x1C, 0x1C, 0x18, 0x23, + 0xF8, 0xD1, 0xB9, 0x7B, 0x02, 0x18, 0x29, 0x41, + 0x23, 0x75, 0x3F, 0x01, 0x46, 0xE0, 0xAD, 0x6E, + 0x0F, 0x1E, 0xC9, 0xBB, 0x28, 0x7F, 0x80, 0xE5, + 0x8E, 0x7D, 0x00, 0x0B, 0x0F, 0x9B, 0x4A, 0x2D + }, + { + 0x8A, 0x55, 0x8B, 0xE7, 0x5D, 0xA9, 0x61, 0x14, + 0x2A, 0xD3, 0x3A, 0xBA, 0x0A, 0x75, 0xA5, 0x95, + 0x7B, 0x68, 0x46, 0x1E, 0x31, 0xA9, 0x3D, 0x15, + 0xF8, 0xA7, 0x7D, 0x29, 0xF7, 0xE2, 0xF1, 0xD4, + 0x3E, 0xDE, 0x24, 0xB4, 0xF6, 0x4D, 0xF4, 0x98, + 0xD8, 0x3F, 0x87, 0xB4, 0x91, 0xA0, 0xB8, 0xA3, + 0x80, 0xC6, 0x69, 0xF2, 0x98, 0xF7, 0xC9, 0xB0, + 0x7D, 0xBC, 0xB0, 0x31, 0x67, 0x73, 0x01, 0x94 + }, + { + 0x92, 0xBE, 0xDD, 0x60, 0x5E, 0xBA, 0xFD, 0xB0, + 0x5D, 0xC0, 0x0F, 0xFA, 0x08, 0x92, 0x70, 0xFB, + 0xC9, 0x0A, 0x84, 0x8E, 0x1D, 0x07, 0x67, 0xB7, + 0x8F, 0x6A, 0x63, 0x23, 0x7C, 0x7C, 0x34, 0xA1, + 0x2B, 0x6A, 0x8F, 0x4D, 0x35, 0x7E, 0xA7, 0x96, + 0x66, 0x55, 0xE2, 0x6B, 0x39, 0x7C, 0x59, 0x35, + 0x61, 0xB2, 0x8C, 0x77, 0xB6, 0x4B, 0x28, 0xB6, + 0x07, 0xA5, 0xD3, 0xF8, 0xAF, 0x96, 0x77, 0x0A + }, + { + 0x77, 0x59, 0x7D, 0x11, 0x4C, 0x44, 0xFB, 0x8A, + 0x0B, 0xD1, 0x37, 0x8E, 0x05, 0x90, 0xE9, 0xC7, + 0x9B, 0x17, 0xA9, 0x4A, 0x69, 0x9D, 0x99, 0x6B, + 0x8F, 0x09, 0xA9, 0x0F, 0xB9, 0x42, 0x00, 0x80, + 0x2A, 0x95, 0x44, 0xA0, 0xFE, 0x04, 0x3B, 0x62, + 0x87, 0xBC, 0xFD, 0x80, 0x90, 0xEA, 0x96, 0x87, + 0x6B, 0x43, 0xC3, 0xFE, 0x73, 0x20, 0x22, 0x1D, + 0xE9, 0xCE, 0x37, 0xB8, 0x6D, 0xE2, 0xCD, 0x02 + }, + { + 0x35, 0x50, 0x08, 0xF2, 0xA0, 0x7E, 0x16, 0x35, + 0xE8, 0xC3, 0x85, 0xE8, 0x75, 0x7F, 0x4F, 0xC6, + 0xCC, 0xF1, 0x21, 0xA5, 0xE3, 0x32, 0x05, 0x9D, + 0xBF, 0x6D, 0x21, 0x16, 0x03, 0x4D, 0x65, 0x7A, + 0x46, 0xB1, 0x2F, 0xEC, 0x15, 0xB4, 0x30, 0x49, + 0xE5, 0xB7, 0x35, 0xBD, 0x89, 0x28, 0x9A, 0x78, + 0x69, 0xA9, 0xAE, 0x6D, 0xD8, 0xD2, 0x47, 0x6D, + 0x16, 0xB0, 0xD4, 0xF6, 0x27, 0xA3, 0xBA, 0x3C + }, + { + 0xFC, 0x28, 0x2E, 0x38, 0xC0, 0xCD, 0x8F, 0x86, + 0x0E, 0x33, 0x64, 0x0F, 0xC7, 0x6E, 0x0F, 0x3B, + 0x9A, 0xA1, 0x9B, 0x50, 0x59, 0x22, 0xF4, 0x12, + 0xCA, 0xEB, 0x13, 0x45, 0xB1, 0x77, 0xAF, 0xE2, + 0x9B, 0x64, 0xB4, 0xC9, 0x95, 0x63, 0xF6, 0xCE, + 0xCC, 0x70, 0x38, 0x61, 0xFB, 0x31, 0xF6, 0x77, + 0xD9, 0x29, 0x86, 0x71, 0x1E, 0x01, 0x03, 0xE0, + 0xDE, 0x65, 0x73, 0x0C, 0x97, 0x0B, 0x32, 0x5A + }, + { + 0xA8, 0x08, 0x10, 0x3E, 0x04, 0x4D, 0x68, 0xE4, + 0xDF, 0x16, 0xE5, 0x0A, 0x2B, 0xC7, 0xB6, 0x01, + 0x67, 0x01, 0x66, 0xAB, 0xA9, 0xED, 0x08, 0xB5, + 0x14, 0x78, 0x98, 0x26, 0xCB, 0xE0, 0x3A, 0xB2, + 0x71, 0xFC, 0x83, 0x96, 0x2E, 0xC5, 0xAD, 0x0B, + 0x09, 0x7D, 0xCF, 0x11, 0x01, 0x89, 0x63, 0x8E, + 0xB6, 0x91, 0xAE, 0xE2, 0x32, 0x34, 0x8B, 0xBE, + 0x62, 0xDE, 0x33, 0x7D, 0xF0, 0x3C, 0xD7, 0x87 + }, + { + 0xA8, 0x78, 0x0D, 0x13, 0x4E, 0x4C, 0x31, 0xAC, + 0x97, 0x4B, 0xC4, 0x40, 0xD3, 0x7E, 0x45, 0xC0, + 0xA1, 0x5D, 0x9C, 0x0C, 0xD7, 0x1A, 0xF5, 0x4A, + 0x94, 0xD0, 0x08, 0x4E, 0xED, 0xD3, 0x57, 0xF8, + 0xA3, 0xFE, 0x80, 0x98, 0x8C, 0x5F, 0x75, 0x01, + 0xAA, 0xA3, 0xB9, 0x4E, 0x37, 0x96, 0x9E, 0x40, + 0xA5, 0x8C, 0xEF, 0xF9, 0x43, 0xC6, 0xFD, 0x4A, + 0x25, 0xD3, 0x3C, 0xA4, 0x9A, 0x5B, 0x5E, 0x66 + }, + { + 0xC8, 0x40, 0x72, 0x1B, 0xEC, 0xF2, 0xC0, 0x9A, + 0xF3, 0x39, 0x8B, 0x16, 0xC4, 0x89, 0xAD, 0x17, + 0x6D, 0xBA, 0x76, 0xCC, 0xF3, 0xF5, 0x6B, 0x7F, + 0xC8, 0x40, 0xF5, 0x15, 0x16, 0x68, 0x51, 0x1F, + 0x42, 0x96, 0x59, 0x8F, 0x34, 0x39, 0x20, 0x76, + 0xCC, 0xD0, 0xCA, 0x77, 0x78, 0x47, 0xE8, 0x40, + 0x82, 0xFC, 0x9A, 0x1E, 0x7D, 0x87, 0xC1, 0x0E, + 0x8E, 0x02, 0x54, 0xFC, 0xED, 0xEB, 0x86, 0x98 + }, + { + 0x7C, 0x0F, 0xF6, 0xC7, 0xD8, 0xD8, 0x4D, 0xBA, + 0x7D, 0xDC, 0xB2, 0x0A, 0x10, 0xE7, 0x1C, 0x2F, + 0x2A, 0x75, 0xBE, 0x91, 0xA4, 0x4E, 0x42, 0x8E, + 0xF3, 0x8F, 0x8F, 0x22, 0x19, 0x13, 0x98, 0x08, + 0x09, 0xC3, 0xAD, 0xDD, 0xA6, 0xB1, 0xCB, 0xDD, + 0xC3, 0x2D, 0xC7, 0x2F, 0x15, 0xD5, 0x25, 0xFF, + 0x54, 0x7E, 0x22, 0xC0, 0xDB, 0xE0, 0xDC, 0x63, + 0x31, 0x60, 0x40, 0x29, 0x0D, 0xF5, 0x5E, 0x69 + }, + { + 0xE5, 0xC7, 0x85, 0xA1, 0xE4, 0xD5, 0x1F, 0x7E, + 0x2F, 0x6B, 0x86, 0x77, 0x97, 0xD3, 0xE0, 0x43, + 0x87, 0x65, 0x7D, 0x9B, 0xFC, 0x39, 0x24, 0x82, + 0x13, 0x99, 0x52, 0xC4, 0x21, 0x9E, 0x94, 0x4B, + 0x9A, 0x15, 0x29, 0x16, 0x25, 0x8D, 0xFA, 0x4C, + 0x4F, 0xB1, 0xEE, 0xBA, 0xFB, 0xAA, 0xEB, 0xD6, + 0xBF, 0x23, 0x33, 0x23, 0x1A, 0x51, 0x17, 0xED, + 0x5E, 0x4E, 0xB4, 0xC4, 0x4C, 0x53, 0x3F, 0xA8 + }, + { + 0x72, 0x53, 0x19, 0x12, 0x5A, 0xB1, 0xB5, 0x30, + 0x46, 0xC8, 0x92, 0xD1, 0xBA, 0xB4, 0x5F, 0xC4, + 0x7E, 0xF8, 0x43, 0x79, 0xB1, 0x03, 0xF5, 0x2A, + 0x29, 0xA3, 0x11, 0x65, 0xF0, 0x54, 0x98, 0x48, + 0x1F, 0x09, 0xEC, 0x9F, 0x57, 0x24, 0x40, 0x09, + 0x8C, 0x03, 0x87, 0xE9, 0x6D, 0x5A, 0xDE, 0x29, + 0x27, 0x86, 0xF9, 0x21, 0x14, 0x95, 0x69, 0x7F, + 0xD9, 0xCD, 0x5D, 0xB1, 0x6D, 0x7B, 0xCF, 0xB6 + }, + { + 0x44, 0xF3, 0x37, 0x46, 0x0A, 0xE0, 0x78, 0xCF, + 0x79, 0xA7, 0xB3, 0x90, 0x43, 0xBB, 0xE7, 0x71, + 0x0A, 0x49, 0x6D, 0x48, 0xB0, 0xC8, 0x93, 0xBC, + 0xC8, 0x02, 0x7D, 0x9B, 0xD7, 0x2A, 0x3D, 0x9B, + 0x24, 0xFD, 0xC6, 0xEE, 0xD5, 0x79, 0x7C, 0xDA, + 0xB4, 0x79, 0x0D, 0x63, 0xCD, 0x1B, 0x13, 0xE9, + 0xF0, 0x43, 0xF8, 0xB0, 0x37, 0x79, 0xEE, 0x37, + 0xC0, 0xD2, 0x29, 0xBF, 0xB1, 0xEE, 0xAD, 0x12 + }, + { + 0xA3, 0xD7, 0xC7, 0xFB, 0x9B, 0x17, 0x1E, 0x47, + 0x33, 0x11, 0xFD, 0x37, 0x73, 0xAB, 0x50, 0xD1, + 0xEA, 0xAB, 0xAC, 0x0E, 0xB2, 0xB3, 0x14, 0x85, + 0xB4, 0x67, 0xC4, 0x2B, 0xBC, 0x16, 0x9C, 0xCA, + 0x19, 0x4B, 0xDE, 0x75, 0x85, 0xDE, 0xB8, 0xC2, + 0x40, 0x9C, 0xFC, 0xB7, 0x56, 0xBA, 0x33, 0x59, + 0x56, 0x42, 0x26, 0x11, 0xEA, 0x6E, 0xD8, 0xD3, + 0x26, 0xAA, 0x90, 0xD5, 0x96, 0xF1, 0x38, 0x9E + }, + { + 0x0F, 0xDF, 0xF7, 0x82, 0xB3, 0x29, 0xBF, 0x56, + 0xAE, 0x0F, 0x7F, 0x29, 0xE0, 0x12, 0x63, 0x0E, + 0x68, 0xF7, 0xD3, 0x1C, 0xEC, 0x3B, 0x8E, 0xA6, + 0xFC, 0x28, 0xBB, 0x34, 0x28, 0xD6, 0x49, 0x68, + 0x9C, 0x8C, 0x1D, 0xBD, 0x12, 0xB0, 0x8F, 0xE0, + 0xD6, 0x03, 0xC1, 0x00, 0xDF, 0x3E, 0x08, 0xD3, + 0x2D, 0xA0, 0x60, 0x31, 0x6E, 0xF9, 0x62, 0xFA, + 0x03, 0x00, 0xAD, 0x59, 0xCC, 0x3E, 0xF6, 0x8A + }, + { + 0x61, 0x94, 0xA6, 0x44, 0x35, 0x06, 0x5F, 0x93, + 0xDA, 0xC3, 0xC9, 0x8A, 0x2C, 0x0E, 0xC3, 0x65, + 0x62, 0x75, 0x71, 0x01, 0x6F, 0x3D, 0x8B, 0x7F, + 0xEE, 0xD0, 0xA8, 0x01, 0x8C, 0x1F, 0x69, 0x37, + 0x20, 0x36, 0xD0, 0x8C, 0xD2, 0xD6, 0xE1, 0xD0, + 0x7A, 0x1F, 0xC0, 0x32, 0xAB, 0x56, 0x31, 0xE0, + 0x05, 0x8A, 0x01, 0xC7, 0x27, 0x47, 0x11, 0xD1, + 0xB7, 0x27, 0xB9, 0x05, 0xEB, 0xAD, 0x3A, 0xB1 + }, + { + 0x59, 0xE2, 0x21, 0xF9, 0x1B, 0x05, 0x91, 0x0F, + 0xBF, 0x27, 0x49, 0x13, 0x44, 0xFA, 0xDD, 0xBC, + 0x03, 0x15, 0xA4, 0x73, 0x06, 0x30, 0x95, 0x71, + 0x95, 0xDC, 0xEC, 0xA5, 0xD9, 0x61, 0xE5, 0xC7, + 0x88, 0xD1, 0xE3, 0x00, 0xC6, 0x28, 0x55, 0xB7, + 0x60, 0xC3, 0x05, 0x80, 0x55, 0x43, 0x19, 0xA3, + 0xE7, 0xD0, 0x08, 0x89, 0xDE, 0x87, 0xAD, 0x7C, + 0xBE, 0xB9, 0x12, 0x09, 0xEA, 0x35, 0x90, 0xE6 + }, + { + 0x10, 0x9F, 0x93, 0x6D, 0x3B, 0x38, 0x79, 0x2D, + 0xB2, 0x98, 0x38, 0x14, 0xE0, 0x50, 0x33, 0x0A, + 0x63, 0x65, 0x5D, 0x3B, 0x69, 0xD7, 0x3F, 0x3D, + 0x11, 0x3D, 0x31, 0x50, 0x9D, 0xEB, 0x0E, 0x83, + 0x54, 0x1A, 0x5D, 0x9F, 0x1B, 0x0F, 0xDA, 0x09, + 0xB8, 0x1F, 0xC8, 0xFB, 0x22, 0x3D, 0x2A, 0x34, + 0x80, 0xC6, 0x82, 0x78, 0x50, 0xD8, 0x5A, 0x8F, + 0x1D, 0x72, 0x74, 0x4C, 0xFD, 0x2B, 0xD5, 0xD9 + }, + { + 0xBD, 0xED, 0x04, 0x99, 0x36, 0x3C, 0x7A, 0x09, + 0xC7, 0xB1, 0xA6, 0xDA, 0x25, 0x2A, 0x17, 0x3F, + 0x76, 0x55, 0x78, 0x07, 0xD0, 0xD7, 0x33, 0x64, + 0xF1, 0x42, 0x45, 0x8D, 0xDE, 0x29, 0xE1, 0x74, + 0x27, 0xEA, 0x1C, 0x29, 0xFC, 0x3C, 0xB4, 0x1C, + 0x31, 0x75, 0x32, 0x48, 0x59, 0x06, 0x7D, 0x58, + 0x30, 0x34, 0x37, 0xFC, 0x96, 0x84, 0xBE, 0xA1, + 0x8F, 0xD4, 0x4F, 0xB1, 0xBC, 0x70, 0x7E, 0x4A + }, + { + 0x52, 0x0C, 0xE1, 0xAD, 0x70, 0x50, 0xE8, 0x17, + 0x3A, 0xA1, 0xD3, 0x78, 0x53, 0x79, 0x5B, 0xF5, + 0xC4, 0xAF, 0x60, 0x59, 0x93, 0xDF, 0x3B, 0xC1, + 0xC7, 0x40, 0x94, 0xA9, 0xF5, 0xD3, 0x4C, 0x27, + 0x8E, 0x22, 0x00, 0x49, 0x6D, 0x62, 0xDE, 0x57, + 0x56, 0x8A, 0x1E, 0x3E, 0x92, 0xAE, 0x75, 0x11, + 0xB3, 0xE6, 0x0F, 0xB5, 0x52, 0x99, 0xAF, 0x6C, + 0x5D, 0x25, 0x2F, 0xF9, 0xBD, 0x51, 0xC8, 0x0A + }, + { + 0xCA, 0x3F, 0xE4, 0x17, 0xD6, 0x42, 0x6A, 0x20, + 0x94, 0x81, 0x3B, 0x37, 0xC8, 0x10, 0x78, 0x00, + 0x3D, 0xAB, 0x9C, 0xB2, 0xB6, 0xF9, 0x43, 0x01, + 0xF7, 0x10, 0x6A, 0x85, 0xDC, 0x31, 0x10, 0xD7, + 0x20, 0x71, 0x29, 0x53, 0x8F, 0x80, 0x6C, 0xD6, + 0x65, 0x0F, 0x13, 0x24, 0x5C, 0x41, 0x6C, 0x59, + 0x74, 0x4C, 0xFE, 0xC8, 0xA0, 0xA8, 0x0B, 0x91, + 0x48, 0xBC, 0x8F, 0xA7, 0x59, 0x99, 0x49, 0x6D + }, + { + 0x3C, 0x3B, 0x9F, 0x44, 0x7B, 0x40, 0x04, 0x12, + 0x6F, 0x6E, 0x4F, 0xBE, 0x81, 0x21, 0x4D, 0x6C, + 0x19, 0x69, 0x82, 0x7F, 0x47, 0x39, 0x2F, 0xF9, + 0x52, 0x03, 0x05, 0xB0, 0x53, 0xE9, 0xA8, 0x1F, + 0x93, 0x8B, 0x69, 0x8A, 0x39, 0xE3, 0xFE, 0x00, + 0x37, 0x39, 0xB6, 0x8F, 0x75, 0xF5, 0x1E, 0xAB, + 0x77, 0x1B, 0x25, 0x9E, 0x20, 0xAA, 0x4D, 0x6A, + 0xDB, 0x67, 0x49, 0x1E, 0x92, 0x19, 0x07, 0xC6 + }, + { + 0x98, 0xAE, 0x84, 0xB5, 0xE6, 0x71, 0xC4, 0x0F, + 0x1B, 0x56, 0xD8, 0x42, 0x6A, 0xD7, 0x77, 0xE0, + 0x77, 0xDE, 0x82, 0xE6, 0xD8, 0x34, 0x07, 0x87, + 0x65, 0x79, 0x33, 0xB8, 0x7A, 0x19, 0xE7, 0x6D, + 0xA9, 0x9D, 0x4B, 0x8C, 0x2E, 0x06, 0x6F, 0x62, + 0xBF, 0x43, 0xFD, 0xB7, 0xED, 0xF9, 0xBA, 0xF3, + 0x2A, 0x3B, 0xCE, 0x03, 0x08, 0xAB, 0xAA, 0x5B, + 0x27, 0x05, 0xCF, 0xFA, 0xF4, 0x64, 0x1E, 0xCD + }, + { + 0x2B, 0x09, 0x7B, 0xE1, 0x70, 0xA3, 0x0E, 0x52, + 0xF5, 0x9A, 0x13, 0x87, 0x1D, 0xA8, 0x65, 0x3F, + 0x14, 0xB7, 0x0F, 0xED, 0x0F, 0x54, 0x00, 0x13, + 0x5B, 0x80, 0xCA, 0xC1, 0x27, 0xE0, 0x7B, 0x0B, + 0xE5, 0x00, 0x09, 0xB4, 0x22, 0xE7, 0xED, 0xA2, + 0x3E, 0x05, 0x7E, 0x24, 0xD6, 0xDF, 0x0E, 0x99, + 0x2F, 0x16, 0x71, 0x07, 0xF4, 0x39, 0x6E, 0xFC, + 0x44, 0x1D, 0x71, 0x40, 0x14, 0x5C, 0xB1, 0xD6 + }, + { + 0x82, 0xD0, 0x04, 0xF4, 0x68, 0x4B, 0x91, 0x7B, + 0x4F, 0xBE, 0xD3, 0x8B, 0x0B, 0xE3, 0x52, 0xE1, + 0x4F, 0x1F, 0xA5, 0xCC, 0xE0, 0x8F, 0x08, 0x7D, + 0xA3, 0x8A, 0xA6, 0xFC, 0xE5, 0x53, 0xEB, 0x23, + 0xF6, 0x3C, 0x3D, 0x5E, 0x49, 0x18, 0xD6, 0xDF, + 0x8E, 0xD5, 0xE7, 0x42, 0x6E, 0x3C, 0x57, 0x38, + 0xEC, 0x19, 0x63, 0x2E, 0x06, 0x47, 0x31, 0x00, + 0xC0, 0x59, 0x31, 0x0D, 0x74, 0xE9, 0xBA, 0xBF + }, + { + 0x2A, 0x24, 0x82, 0x0A, 0x1C, 0xAC, 0x6B, 0x6C, + 0x88, 0x95, 0xA7, 0xF2, 0x82, 0x65, 0x21, 0xEE, + 0x6B, 0x3F, 0xED, 0x87, 0x34, 0x61, 0x3C, 0xDB, + 0x0B, 0x74, 0x30, 0xF0, 0x66, 0x8F, 0x8C, 0x46, + 0x4C, 0x06, 0xDF, 0x5A, 0xF3, 0xFD, 0xDE, 0x72, + 0x8D, 0xE3, 0xB5, 0x4B, 0x71, 0x69, 0xCB, 0xC4, + 0x4D, 0xA4, 0x43, 0xA7, 0xF5, 0x3D, 0x28, 0xD6, + 0x27, 0xE7, 0x1D, 0xFC, 0xED, 0x4F, 0x7D, 0xAD + }, + { + 0xCB, 0x2A, 0x07, 0x8C, 0x34, 0xEE, 0x43, 0x30, + 0xC3, 0x8E, 0x61, 0x8D, 0xE8, 0x31, 0x28, 0xB0, + 0x56, 0x6E, 0x2C, 0x7D, 0x1D, 0x05, 0x93, 0xAB, + 0x31, 0xEE, 0x74, 0xD5, 0x0D, 0xCE, 0xEF, 0x05, + 0x64, 0xE5, 0xDC, 0x9F, 0xE3, 0xB4, 0x75, 0x45, + 0x60, 0xC1, 0x4D, 0x29, 0xCC, 0x37, 0xF5, 0x56, + 0x28, 0x37, 0xFF, 0x3F, 0xB2, 0xC5, 0xF2, 0x35, + 0xC9, 0xB5, 0x73, 0xD3, 0xE4, 0xFB, 0xF5, 0x43 + }, + { + 0x15, 0x70, 0x60, 0xEC, 0xAF, 0xFB, 0x53, 0x19, + 0x7D, 0x7F, 0x34, 0x2E, 0x7E, 0x55, 0x3F, 0x50, + 0x7E, 0x0A, 0xF9, 0x72, 0x3B, 0x4D, 0x11, 0x24, + 0x00, 0x12, 0xA7, 0xEB, 0xCA, 0x0A, 0x17, 0xC1, + 0x6B, 0x57, 0x72, 0x7F, 0x3F, 0x3E, 0xA8, 0xE5, + 0x43, 0x06, 0xE6, 0x13, 0x61, 0x1D, 0xA7, 0x96, + 0xB4, 0x81, 0x19, 0x38, 0x96, 0x99, 0x16, 0xDC, + 0x80, 0x7E, 0x5D, 0xEF, 0x35, 0x73, 0x90, 0x49 + }, + { + 0x69, 0x44, 0x3C, 0x17, 0x77, 0x31, 0xBC, 0x8B, + 0x34, 0xAD, 0xFF, 0x20, 0x66, 0xCE, 0x03, 0xE3, + 0x19, 0x1B, 0x97, 0x2C, 0xEF, 0x94, 0xAC, 0xF3, + 0xE3, 0x7D, 0xBE, 0x93, 0x3F, 0xB9, 0xA1, 0x4F, + 0x62, 0x02, 0xAC, 0xEE, 0xE4, 0x22, 0x7D, 0x7E, + 0x0B, 0x73, 0x0A, 0x0C, 0x82, 0x80, 0x2F, 0x3C, + 0xEE, 0x2E, 0x76, 0xEA, 0x7E, 0x79, 0xB5, 0x6F, + 0xDF, 0x02, 0xEE, 0x93, 0x4E, 0x8E, 0x25, 0xC9 + }, + { + 0x50, 0xD9, 0x80, 0x58, 0x16, 0x4B, 0x94, 0xB8, + 0x3A, 0x68, 0xA6, 0xB5, 0x9E, 0xB5, 0xCB, 0x54, + 0x34, 0x4B, 0x5C, 0x88, 0x6C, 0x0A, 0x7F, 0x39, + 0xB5, 0x25, 0x3F, 0xE7, 0xEC, 0xB8, 0x46, 0x3D, + 0xF2, 0xD7, 0xEE, 0x0C, 0x27, 0xCF, 0xD0, 0x64, + 0x40, 0x5B, 0x09, 0x49, 0x3E, 0xC2, 0x86, 0x86, + 0xBD, 0x35, 0x0C, 0x5D, 0xAA, 0x9F, 0xA8, 0xBD, + 0x79, 0xBF, 0x78, 0x80, 0x05, 0xD0, 0x30, 0xA2 + }, + { + 0xBC, 0x82, 0x52, 0x1E, 0xEB, 0x75, 0xAE, 0xA6, + 0x05, 0x0C, 0xAE, 0x3D, 0x2D, 0x15, 0xA2, 0x8C, + 0x75, 0x6A, 0xB1, 0x53, 0xD1, 0x72, 0x3F, 0xF5, + 0x4C, 0x80, 0x98, 0x06, 0xF9, 0x61, 0x67, 0x5F, + 0x17, 0x32, 0xCD, 0xA3, 0x48, 0xF7, 0x3E, 0x42, + 0xED, 0xDE, 0x0B, 0x71, 0x2C, 0xCB, 0xA0, 0x0D, + 0x85, 0x7B, 0xBE, 0x6A, 0x4D, 0x3B, 0x55, 0xB3, + 0xF2, 0x48, 0x42, 0xB2, 0x20, 0xEF, 0xB4, 0x1B + }, + { + 0xA7, 0x3D, 0x95, 0xB4, 0x11, 0xCB, 0xCB, 0x79, + 0x23, 0x57, 0x72, 0x2A, 0x01, 0xC6, 0xAB, 0xEA, + 0xAD, 0xF9, 0x79, 0x61, 0x2A, 0x58, 0x00, 0xB7, + 0x03, 0x4C, 0x86, 0x40, 0x0D, 0x4A, 0x0B, 0x28, + 0xF7, 0x1E, 0x2E, 0xCC, 0xCA, 0x24, 0x7D, 0xDF, + 0xDF, 0xDB, 0xAD, 0x8A, 0xA6, 0xBD, 0x2D, 0x79, + 0x78, 0xE6, 0x1C, 0xD5, 0x6E, 0x09, 0xB1, 0x28, + 0xBA, 0x0D, 0xB2, 0x4E, 0x2C, 0x0D, 0xC2, 0x58 + }, + { + 0xA9, 0xB5, 0xC0, 0x99, 0xAE, 0x5A, 0xFA, 0x46, + 0xDB, 0x67, 0x3C, 0xAC, 0x48, 0x62, 0x58, 0xE8, + 0x43, 0xDC, 0x8B, 0x87, 0x3A, 0x70, 0x97, 0xDC, + 0xEA, 0xE4, 0xAE, 0x1A, 0x2F, 0x37, 0xAC, 0x57, + 0x9E, 0xEF, 0x5F, 0x58, 0x77, 0xCD, 0x52, 0xB1, + 0x38, 0x8E, 0x5E, 0x32, 0x09, 0x15, 0x2B, 0xC6, + 0x29, 0xE6, 0x0E, 0xE7, 0xB0, 0x63, 0x0F, 0x79, + 0x9A, 0xBA, 0x77, 0xDD, 0xF8, 0xE7, 0x1B, 0xB9 + }, + { + 0x8A, 0x00, 0x4D, 0xF1, 0x9D, 0x90, 0x0E, 0x76, + 0x9C, 0x38, 0x17, 0xF9, 0xCA, 0x68, 0x5D, 0x3C, + 0x72, 0x10, 0x9C, 0xD0, 0x1E, 0x4B, 0xA5, 0xD7, + 0xD5, 0xFA, 0x94, 0x8C, 0x4B, 0xF0, 0x48, 0xD2, + 0xF9, 0x7B, 0x6B, 0x96, 0x19, 0xA4, 0x76, 0xBF, + 0xF1, 0x77, 0x4B, 0x8B, 0x63, 0xFC, 0x1E, 0x56, + 0x87, 0x76, 0x0D, 0x34, 0xEB, 0x6B, 0x58, 0x84, + 0x27, 0xB0, 0x36, 0xA0, 0x4A, 0x1D, 0xFC, 0x99 + }, + { + 0x34, 0x8B, 0xDD, 0x04, 0xD7, 0x73, 0xE1, 0xC9, + 0xB4, 0x51, 0x6A, 0xB0, 0x96, 0x37, 0x4F, 0xBC, + 0x17, 0x43, 0xCB, 0xA3, 0xFF, 0x41, 0xD2, 0x46, + 0x03, 0xC4, 0xB9, 0x31, 0x27, 0xB0, 0x79, 0xA7, + 0xF9, 0xA8, 0x95, 0x2A, 0x21, 0xD4, 0xFF, 0x9B, + 0x34, 0xA7, 0x8A, 0x23, 0xFD, 0xB1, 0xBD, 0x01, + 0xED, 0x37, 0xD2, 0x42, 0x5F, 0x54, 0x53, 0x89, + 0x28, 0x18, 0xF2, 0x6D, 0xB5, 0x94, 0x42, 0x30 + }, + { + 0xAB, 0xE4, 0xAD, 0x6D, 0xAC, 0x42, 0x87, 0x72, + 0x5B, 0xEC, 0x3D, 0x47, 0x88, 0x24, 0x03, 0x0C, + 0x08, 0x88, 0x71, 0xC5, 0x04, 0xF8, 0xF6, 0xE2, + 0xF2, 0x28, 0xB5, 0xC2, 0x05, 0x23, 0x3C, 0x98, + 0x84, 0x21, 0x31, 0x21, 0x63, 0x25, 0xE2, 0x4B, + 0xDF, 0xA9, 0xB7, 0x94, 0x2E, 0xD2, 0x3E, 0x9F, + 0xE8, 0xAB, 0x1B, 0x63, 0x83, 0x96, 0x39, 0xB6, + 0xE8, 0xF1, 0xFC, 0xF5, 0x83, 0x49, 0xC5, 0xC7 + }, + { + 0x83, 0x94, 0xB8, 0x82, 0xD9, 0xFE, 0x60, 0x5E, + 0x00, 0x49, 0xA4, 0x79, 0x7D, 0xC0, 0xF2, 0x09, + 0x1F, 0x1A, 0xB2, 0x78, 0x53, 0x54, 0x70, 0x50, + 0xDD, 0x51, 0x6A, 0x95, 0x6A, 0xBD, 0xD0, 0x8F, + 0x82, 0xAF, 0x80, 0x88, 0xB2, 0xB1, 0xD1, 0x80, + 0x45, 0x72, 0x77, 0x59, 0x4A, 0x98, 0x2F, 0xAF, + 0x18, 0x6A, 0xD3, 0x3D, 0x35, 0xA6, 0xFE, 0xD8, + 0xC2, 0xE4, 0x5C, 0xCC, 0x9C, 0xB8, 0x77, 0xFC + }, + { + 0xA0, 0xDD, 0xEA, 0x18, 0xC0, 0x18, 0x0F, 0x5C, + 0xEE, 0x79, 0x1C, 0xF0, 0xA5, 0x06, 0x09, 0x91, + 0x5E, 0xD9, 0xE1, 0x90, 0x0D, 0x9E, 0x9F, 0x99, + 0xCA, 0x1A, 0xC8, 0x62, 0x31, 0xE9, 0x16, 0x38, + 0x84, 0xCD, 0xF9, 0x8A, 0x2F, 0x55, 0xA6, 0x5A, + 0x34, 0x43, 0xC9, 0x3A, 0xBA, 0x6C, 0x43, 0xD5, + 0x38, 0xD3, 0x45, 0xAB, 0x89, 0xA7, 0x53, 0x54, + 0x87, 0x77, 0x7D, 0x1A, 0xB3, 0xAB, 0xDA, 0xEA + }, + { + 0xFD, 0xED, 0x2B, 0xD2, 0xB8, 0xDD, 0x9B, 0x07, + 0xB3, 0x67, 0x5A, 0xD2, 0x7B, 0x6B, 0x8D, 0x85, + 0xC7, 0x5B, 0x56, 0xB3, 0x63, 0xC7, 0x9B, 0xF9, + 0xF3, 0x8A, 0x5E, 0x1E, 0xF1, 0xEC, 0x93, 0xD8, + 0x81, 0x70, 0xE9, 0x2A, 0x8E, 0xA7, 0xDE, 0x06, + 0x36, 0x8D, 0x14, 0x43, 0xC7, 0x36, 0x1D, 0xD1, + 0x85, 0x45, 0x0D, 0x0D, 0x3A, 0xE5, 0x14, 0xA6, + 0xA5, 0xC0, 0xA8, 0x66, 0x81, 0xD0, 0xA6, 0xDF + }, + { + 0x0B, 0xF1, 0x09, 0xFE, 0x63, 0x32, 0xE3, 0x06, + 0x7F, 0x83, 0xB7, 0x74, 0x0C, 0x57, 0x4D, 0xA2, + 0xE5, 0x9C, 0xC4, 0x72, 0xF9, 0x96, 0xDD, 0x7A, + 0xAD, 0xE1, 0x24, 0xE7, 0x7D, 0xA8, 0xCE, 0xB6, + 0x01, 0xEC, 0xAC, 0x6A, 0xDD, 0xAA, 0xF1, 0x22, + 0xFF, 0x5F, 0x71, 0x07, 0x08, 0x5F, 0x59, 0x35, + 0x42, 0x65, 0x23, 0xA7, 0x2E, 0x81, 0x6F, 0xE4, + 0xA8, 0x0A, 0x4E, 0x78, 0xAE, 0xEB, 0xDC, 0xB1 + }, + { + 0x7C, 0x64, 0xB2, 0xEB, 0x44, 0xF1, 0x1C, 0x57, + 0x20, 0xD9, 0xD0, 0xDD, 0x21, 0x9B, 0xA6, 0xFE, + 0x52, 0x53, 0x09, 0x08, 0x6A, 0x42, 0xCD, 0xD3, + 0x8F, 0x7B, 0xE7, 0xE3, 0x0B, 0x8F, 0x2B, 0x8E, + 0xC7, 0x95, 0xE2, 0x23, 0x5F, 0x40, 0x15, 0xCD, + 0x95, 0xC9, 0x04, 0xF6, 0x8E, 0xF3, 0x17, 0x25, + 0x1C, 0x61, 0xF8, 0x2B, 0x49, 0xB6, 0x79, 0x0B, + 0x3D, 0xAD, 0x1B, 0xB1, 0x83, 0xCE, 0xEA, 0xB3 + }, + { + 0xC8, 0x2F, 0xF7, 0x45, 0xCC, 0x8E, 0x1C, 0x36, + 0x12, 0x30, 0x57, 0x96, 0x33, 0x5D, 0x76, 0x89, + 0x4E, 0x71, 0x00, 0x76, 0x1A, 0x76, 0xA5, 0xE8, + 0x52, 0xE6, 0xF3, 0xE1, 0x11, 0x33, 0xB7, 0x97, + 0x16, 0x1A, 0x2B, 0xA3, 0xD9, 0xF6, 0x79, 0x0D, + 0xF6, 0x27, 0x81, 0x42, 0x41, 0x74, 0xFC, 0xD3, + 0x80, 0x91, 0x9F, 0x7F, 0xDF, 0x76, 0x80, 0xDA, + 0xB0, 0xB0, 0x6B, 0x04, 0xB1, 0xEC, 0xD8, 0xD9 + }, + { + 0x30, 0x91, 0x7D, 0xA6, 0x39, 0x7C, 0xCC, 0x07, + 0xBF, 0x29, 0x25, 0xE1, 0x60, 0xF2, 0xBB, 0x18, + 0x80, 0x49, 0xCA, 0xF1, 0xCB, 0x3E, 0xBD, 0x57, + 0xCD, 0x58, 0x52, 0xEE, 0x14, 0x41, 0x24, 0x4B, + 0x56, 0x25, 0xD7, 0x20, 0xEB, 0x4E, 0x9B, 0x59, + 0x9D, 0xBC, 0x6A, 0x64, 0xAF, 0xA0, 0xFB, 0x01, + 0x19, 0x2C, 0x3B, 0x91, 0x17, 0x1A, 0x98, 0x3D, + 0xAE, 0x15, 0xB6, 0x56, 0xFB, 0xD5, 0xBE, 0x7E + }, + { + 0x8D, 0x46, 0xD1, 0x26, 0xC5, 0x6A, 0x5E, 0xEE, + 0xB2, 0x68, 0xE2, 0x0D, 0xBE, 0x0B, 0x8F, 0xF4, + 0x01, 0xB5, 0x8D, 0x83, 0x9C, 0x5B, 0x02, 0x06, + 0x27, 0xA4, 0x69, 0x38, 0x67, 0x43, 0x2B, 0x69, + 0x22, 0xDC, 0x82, 0x84, 0x02, 0xF5, 0x12, 0xDC, + 0x88, 0xB4, 0xA5, 0x53, 0x0E, 0x30, 0x50, 0x9E, + 0x27, 0xD0, 0x6E, 0x36, 0x9C, 0x66, 0x11, 0x80, + 0x3A, 0xEB, 0x34, 0xBA, 0xB8, 0xE5, 0x75, 0x93 + }, + { + 0xC8, 0xCB, 0x44, 0xCB, 0xE9, 0x8E, 0x86, 0xA3, + 0xB9, 0x47, 0xAE, 0x3E, 0x3E, 0x0E, 0x33, 0x68, + 0x68, 0x4D, 0xA4, 0x04, 0xFE, 0xB7, 0xAE, 0xFE, + 0xCD, 0xFC, 0x03, 0x4D, 0xC4, 0x64, 0x35, 0x8E, + 0x55, 0x01, 0x54, 0x50, 0xE2, 0xE2, 0x8C, 0x5D, + 0x62, 0x56, 0x3E, 0x3D, 0xCC, 0x60, 0x2F, 0xA9, + 0xB0, 0x19, 0x07, 0x32, 0x3C, 0xFB, 0x69, 0x28, + 0xF6, 0xB3, 0xAA, 0x1B, 0x69, 0x57, 0x98, 0xDA + }, + { + 0xE5, 0xB2, 0x84, 0x46, 0x81, 0xEB, 0xE7, 0x24, + 0x9E, 0xE1, 0xBC, 0x0D, 0xFE, 0xFF, 0x59, 0x7B, + 0x8E, 0x9A, 0x3F, 0x37, 0x7C, 0x8A, 0x35, 0x94, + 0xF1, 0x96, 0xB6, 0x38, 0x6D, 0xF7, 0x70, 0x9C, + 0x0F, 0xDC, 0xA7, 0xF3, 0x7E, 0x70, 0x47, 0xD0, + 0x1C, 0x64, 0x70, 0x4A, 0x7D, 0x73, 0x78, 0x2C, + 0x6F, 0xED, 0x66, 0xA4, 0x75, 0xC5, 0x5D, 0xFC, + 0xCB, 0xCC, 0x3B, 0x25, 0x36, 0x58, 0x5B, 0x14 + }, + { + 0x9B, 0x53, 0x8B, 0x27, 0x36, 0x37, 0x32, 0x59, + 0x18, 0x8C, 0xC7, 0x9C, 0x7C, 0x46, 0xC3, 0xB6, + 0xD2, 0x2B, 0xDE, 0xB8, 0x4F, 0x31, 0xF9, 0x04, + 0x89, 0x3D, 0x90, 0x1F, 0xC9, 0x38, 0x78, 0x0C, + 0x34, 0x08, 0x2B, 0xA5, 0x66, 0x68, 0x9B, 0x8B, + 0xAB, 0xA3, 0x2B, 0xBE, 0xB9, 0x9A, 0xEF, 0xC5, + 0x66, 0xC1, 0x0D, 0x25, 0x92, 0xBD, 0xDF, 0xF3, + 0xAF, 0x62, 0x67, 0xE0, 0x54, 0xB5, 0x30, 0x90 + }, + { + 0x37, 0x27, 0x7A, 0xF5, 0xA9, 0x89, 0x16, 0x27, + 0x7C, 0xA6, 0x2E, 0x25, 0x75, 0x84, 0x9E, 0x2D, + 0x48, 0x5A, 0x85, 0xE4, 0xD5, 0x4F, 0xB0, 0x30, + 0x54, 0x6E, 0x88, 0xA0, 0x7D, 0x69, 0xED, 0x1A, + 0x44, 0xF0, 0x4E, 0x7D, 0x7F, 0x15, 0x00, 0xED, + 0x09, 0x39, 0x45, 0x39, 0x9D, 0x25, 0x23, 0xBA, + 0xAD, 0x35, 0x89, 0x2B, 0x01, 0xE2, 0x3B, 0x5B, + 0x8A, 0x3D, 0x1E, 0xBB, 0x8E, 0x8C, 0x3C, 0x7B + }, + { + 0x19, 0x1D, 0x18, 0x4C, 0x9B, 0xCA, 0xC9, 0xD1, + 0xAB, 0xA6, 0xF7, 0x9C, 0xDF, 0xAE, 0x57, 0x2B, + 0xA4, 0x19, 0xB8, 0x3C, 0xB4, 0x92, 0x20, 0xAD, + 0xBD, 0x87, 0xC3, 0xF3, 0x1A, 0xC1, 0x65, 0x8E, + 0x81, 0xBC, 0x53, 0x8C, 0x72, 0x47, 0xCC, 0x8D, + 0xAF, 0x4E, 0x53, 0xF2, 0x79, 0x49, 0x27, 0x2C, + 0xB1, 0x69, 0x23, 0xC6, 0x28, 0x5C, 0x5A, 0x5D, + 0x74, 0x34, 0x2E, 0xBC, 0xCE, 0x41, 0x1B, 0xB2 + }, + { + 0xEE, 0x6C, 0xAC, 0x41, 0x40, 0xBF, 0x63, 0x30, + 0x47, 0x9B, 0x6F, 0x7F, 0xE2, 0x84, 0x15, 0xCD, + 0x85, 0x90, 0xD6, 0x06, 0xD6, 0xA6, 0x54, 0xC9, + 0xDF, 0x1F, 0x9D, 0x02, 0xE0, 0x90, 0x9B, 0x02, + 0x80, 0xB4, 0xCB, 0x30, 0x9D, 0x41, 0x63, 0x94, + 0x19, 0x0F, 0xC4, 0x4B, 0x1A, 0xC4, 0xAF, 0x13, + 0x76, 0x0D, 0xA1, 0x81, 0xBC, 0xC8, 0xF6, 0x05, + 0x2C, 0x14, 0xCB, 0x7E, 0xE1, 0x20, 0x69, 0xA1 + }, + { + 0x16, 0x33, 0x1B, 0x31, 0x63, 0xBB, 0x00, 0x1E, + 0xF0, 0x24, 0x59, 0xF4, 0x6F, 0x72, 0x21, 0xB9, + 0xB3, 0x4E, 0x20, 0xFF, 0x6B, 0x3F, 0xF1, 0xC7, + 0x23, 0x01, 0xA6, 0x25, 0x99, 0xB5, 0x7A, 0x51, + 0xD7, 0xCF, 0x38, 0x53, 0xFB, 0xF9, 0xFE, 0x1D, + 0x57, 0x7D, 0x62, 0xC2, 0x4F, 0xBB, 0xFD, 0x2D, + 0xEB, 0x3E, 0xA6, 0xCD, 0xF2, 0x41, 0x5A, 0x71, + 0x2E, 0xF4, 0xD1, 0xC6, 0x9F, 0x79, 0xED, 0xFE + }, + { + 0xDD, 0x14, 0xA7, 0x9C, 0x0E, 0x80, 0x61, 0x83, + 0xB0, 0x1B, 0x94, 0xD7, 0xA0, 0x79, 0xAC, 0xAA, + 0xEB, 0x15, 0xEF, 0xAC, 0x58, 0xBD, 0x21, 0x5F, + 0x8C, 0xE7, 0x77, 0xD9, 0xF4, 0x15, 0x65, 0x9B, + 0xEC, 0xD3, 0x0F, 0x38, 0xC7, 0xB2, 0x5E, 0x86, + 0x99, 0x7F, 0x4C, 0xB1, 0x09, 0x50, 0x68, 0x2D, + 0xA0, 0x3A, 0x60, 0x65, 0xF2, 0x47, 0x43, 0x9A, + 0xA6, 0x42, 0x19, 0x80, 0xD7, 0xF9, 0xBE, 0x73 + }, + { + 0x2D, 0x8E, 0x0A, 0x33, 0xEA, 0x96, 0x1F, 0xA6, + 0x8A, 0x95, 0x5A, 0x35, 0x7F, 0x36, 0x3F, 0xB4, + 0x48, 0xBD, 0x17, 0xC3, 0xEF, 0x95, 0x22, 0x73, + 0x4F, 0x2E, 0x83, 0x1D, 0xF5, 0xA9, 0xD4, 0x2B, + 0x7F, 0xF1, 0x88, 0x10, 0xE0, 0x87, 0x2F, 0xF3, + 0xD4, 0x11, 0xC8, 0xC3, 0x56, 0x53, 0x29, 0x27, + 0x33, 0xE1, 0xC5, 0x17, 0x41, 0x82, 0x45, 0xB4, + 0x0B, 0x6B, 0x66, 0xC0, 0xD0, 0x9A, 0xF8, 0x30 + }, + { + 0xA1, 0x0E, 0xAC, 0x05, 0x3B, 0x67, 0x8F, 0x66, + 0x0C, 0xD6, 0x41, 0xFF, 0x75, 0x8A, 0x7E, 0xD4, + 0x73, 0x08, 0x32, 0x83, 0xC2, 0x0A, 0x2A, 0x05, + 0x7C, 0xF9, 0x84, 0x1E, 0x6B, 0x27, 0xE9, 0x5D, + 0x59, 0x73, 0xD6, 0x09, 0x0A, 0x50, 0x74, 0xBD, + 0x42, 0xF8, 0x99, 0x80, 0x4B, 0xD1, 0x4A, 0x72, + 0x4A, 0x3E, 0x61, 0x97, 0xEB, 0xCE, 0x20, 0x08, + 0x92, 0x7D, 0x5A, 0x86, 0x88, 0xDB, 0x29, 0xA1 + }, + { + 0xA1, 0x02, 0x4E, 0x5F, 0xDE, 0x45, 0x64, 0xD7, + 0x58, 0xD8, 0x7C, 0x4E, 0xB2, 0x55, 0xA6, 0x6A, + 0x36, 0x82, 0xC1, 0x2C, 0x9B, 0x1A, 0xD8, 0x77, + 0x40, 0xA6, 0xF2, 0xA1, 0x72, 0xB5, 0xCC, 0x86, + 0x87, 0x7E, 0x51, 0x10, 0x35, 0x6E, 0xD1, 0x0A, + 0x38, 0x16, 0x3B, 0x86, 0x22, 0xD4, 0xF8, 0x87, + 0xB3, 0x4E, 0x7C, 0xFE, 0x84, 0x5E, 0xB2, 0x7F, + 0x63, 0x98, 0xD7, 0xD1, 0x6D, 0x5E, 0x46, 0x4E + }, + { + 0xB2, 0x8E, 0x89, 0x1D, 0x9D, 0x7A, 0x3F, 0x65, + 0x26, 0x80, 0x8D, 0x75, 0xB3, 0x2C, 0x4C, 0xAC, + 0xF2, 0xA6, 0x75, 0xB3, 0x69, 0xD1, 0xA7, 0xD2, + 0x42, 0xE1, 0x4E, 0x97, 0x97, 0xC1, 0xEC, 0x47, + 0x8A, 0x2A, 0xB5, 0x94, 0x5B, 0x11, 0xAD, 0x4C, + 0x60, 0x56, 0xA3, 0x6C, 0xEF, 0x9A, 0x31, 0x26, + 0x62, 0xFD, 0x7F, 0xA9, 0x1D, 0xE5, 0xE9, 0x91, + 0x04, 0xF4, 0x8B, 0x7E, 0xF2, 0x41, 0x06, 0x54 + }, + { + 0x1D, 0x01, 0x1D, 0x8A, 0xD1, 0xEA, 0x03, 0x85, + 0x42, 0x15, 0x81, 0xEF, 0xC8, 0xA2, 0xE8, 0xB6, + 0x7B, 0xC3, 0xF5, 0x2C, 0x65, 0xDC, 0x94, 0x50, + 0x5B, 0xA9, 0x91, 0x5E, 0xDD, 0x6B, 0xEE, 0xA0, + 0x2C, 0xAF, 0xF7, 0x59, 0x33, 0xC6, 0xDB, 0xDD, + 0x4F, 0x89, 0x9F, 0x12, 0x7F, 0x86, 0x08, 0xFB, + 0xC0, 0x75, 0xB5, 0xB2, 0xD0, 0x90, 0x67, 0x6E, + 0x35, 0x99, 0xA4, 0xB9, 0x66, 0xDA, 0xA7, 0xE8 + }, + { + 0x42, 0xFE, 0x7A, 0xF4, 0x74, 0x6D, 0x98, 0x3A, + 0xD7, 0x91, 0xA7, 0x60, 0x25, 0x26, 0x39, 0x09, + 0x58, 0xB7, 0x68, 0xED, 0x98, 0x4B, 0x38, 0xC4, + 0xFB, 0xF1, 0x5B, 0x47, 0xDC, 0x7E, 0xB2, 0xBB, + 0xBC, 0xCB, 0x9C, 0x06, 0xCD, 0xE4, 0xEA, 0xB5, + 0xCA, 0x85, 0xB1, 0xF9, 0x8D, 0x27, 0xA8, 0xE7, + 0xEC, 0xCC, 0x45, 0x3D, 0x39, 0xB8, 0x7D, 0x27, + 0x53, 0xA8, 0xFA, 0x2B, 0x60, 0xD8, 0xF6, 0x77 + }, + { + 0x29, 0x57, 0xA8, 0xD4, 0xA9, 0x69, 0x14, 0x24, + 0x0B, 0x4C, 0x72, 0x96, 0x3F, 0xD5, 0xFB, 0x58, + 0x92, 0x38, 0xA8, 0x0F, 0x9F, 0x74, 0x82, 0xFF, + 0xFC, 0xE8, 0x69, 0x60, 0x85, 0x84, 0x1E, 0xD2, + 0xB5, 0x4F, 0x23, 0x9E, 0xFC, 0xE0, 0x40, 0xC9, + 0x86, 0xF0, 0x84, 0x83, 0xC2, 0x18, 0x1A, 0x4D, + 0xDB, 0xCA, 0x62, 0x43, 0x48, 0x93, 0x0B, 0x84, + 0x6F, 0xC0, 0x50, 0x5F, 0xC7, 0x7D, 0xB8, 0xCF + }, + { + 0x03, 0x37, 0xAF, 0xD9, 0x29, 0x27, 0xAB, 0xED, + 0xDA, 0x97, 0x6E, 0x25, 0xB1, 0xC5, 0xDF, 0x47, + 0xB7, 0xC0, 0xE6, 0xD4, 0x80, 0xAA, 0x99, 0x66, + 0x78, 0xEA, 0xAC, 0x10, 0x24, 0xED, 0xE2, 0x72, + 0xBB, 0x2E, 0x65, 0x0F, 0x0B, 0xBE, 0xD6, 0xF0, + 0x6A, 0x9C, 0x82, 0xA7, 0x1E, 0x69, 0xB4, 0xBB, + 0xBC, 0xEB, 0x5C, 0x1D, 0xB4, 0x0B, 0x2E, 0xC1, + 0x10, 0xD4, 0xAC, 0xF4, 0x1A, 0x69, 0xF6, 0x06 + }, + { + 0x92, 0xDE, 0x2E, 0x08, 0x13, 0x0C, 0xAB, 0x72, + 0xBD, 0x41, 0xF3, 0xE8, 0xB8, 0x96, 0x54, 0x83, + 0xF7, 0x4B, 0x5F, 0xAB, 0xC3, 0x64, 0x3F, 0x2E, + 0xB7, 0xD4, 0x76, 0xDC, 0x8D, 0xF8, 0x60, 0xE5, + 0x83, 0x9D, 0x3B, 0x7E, 0xCE, 0x04, 0x84, 0x52, + 0xBB, 0xF3, 0x4F, 0xBB, 0x11, 0xB4, 0xAD, 0x6E, + 0x1A, 0x61, 0xA3, 0xEC, 0xD8, 0xCC, 0x32, 0x55, + 0xE9, 0x85, 0x40, 0x0C, 0x05, 0x42, 0x1C, 0xDD + }, + { + 0x0A, 0x88, 0xD2, 0x82, 0x92, 0xE9, 0x06, 0xE0, + 0x55, 0x44, 0x52, 0x1E, 0x5B, 0xEB, 0x31, 0xE4, + 0xC8, 0x84, 0x7F, 0xE1, 0x04, 0x3C, 0xD6, 0x7A, + 0xD3, 0x50, 0xAF, 0xBA, 0x67, 0x8F, 0x6D, 0x90, + 0x85, 0x6C, 0xC3, 0x60, 0xC7, 0x9A, 0x09, 0x20, + 0x5E, 0x76, 0xBB, 0x5A, 0x09, 0xD6, 0xBF, 0x05, + 0x88, 0x43, 0xD2, 0xAE, 0x96, 0x65, 0xC0, 0x80, + 0x75, 0x94, 0x86, 0xF5, 0xFD, 0x87, 0x95, 0x53 + }, + { + 0xBC, 0x1B, 0xA9, 0x08, 0x82, 0x1B, 0x71, 0x71, + 0xD1, 0x42, 0xE9, 0x73, 0x24, 0x9D, 0x47, 0x21, + 0x86, 0x7F, 0xFB, 0x43, 0x3B, 0x53, 0x05, 0xC2, + 0x75, 0x47, 0xC6, 0xE8, 0x33, 0x04, 0x73, 0x9C, + 0xA1, 0xBD, 0x08, 0x5B, 0x4F, 0x41, 0xCD, 0x52, + 0x5C, 0x69, 0x72, 0xBF, 0x85, 0xC7, 0x1B, 0x2E, + 0x1E, 0xC0, 0x11, 0x8F, 0xAE, 0x21, 0x34, 0x96, + 0x34, 0x06, 0x11, 0x18, 0xD3, 0x00, 0x43, 0x85 + }, + { + 0xB6, 0x35, 0x4B, 0x7A, 0x4C, 0xD7, 0x1C, 0x19, + 0x0E, 0xF5, 0xAC, 0xA4, 0x76, 0x27, 0xD8, 0x4F, + 0x58, 0xD2, 0xF5, 0x7B, 0xED, 0xBD, 0x22, 0x98, + 0x30, 0x43, 0x83, 0x8F, 0x18, 0x07, 0x5B, 0x32, + 0xEC, 0x83, 0xE0, 0xB1, 0xE3, 0x90, 0x45, 0x73, + 0x2B, 0xAD, 0x64, 0xAE, 0xD8, 0xD0, 0xCF, 0x74, + 0x8B, 0xDC, 0xDD, 0x27, 0x49, 0xFF, 0xAE, 0xC6, + 0x2F, 0xDE, 0x47, 0x9D, 0x0A, 0xD9, 0x22, 0xFD + }, + { + 0xD7, 0xCC, 0x0E, 0x77, 0x02, 0x62, 0x1F, 0x5C, + 0xF7, 0x42, 0x68, 0xBA, 0x23, 0x0F, 0xBC, 0x8D, + 0xA0, 0x45, 0x49, 0x24, 0x93, 0xFB, 0x55, 0x75, + 0xCF, 0x02, 0x18, 0x2A, 0xF2, 0xF3, 0xFB, 0x95, + 0x5A, 0x4A, 0x01, 0x83, 0xD0, 0x2C, 0x28, 0x77, + 0x8C, 0xD5, 0x09, 0x96, 0x72, 0xD7, 0x66, 0xE4, + 0x17, 0xE3, 0x53, 0x31, 0xE1, 0x7F, 0x49, 0xEC, + 0x74, 0xB3, 0xE1, 0xF8, 0x68, 0x59, 0x60, 0x95 + }, + { + 0x86, 0x93, 0x80, 0x79, 0xD2, 0x08, 0xDB, 0xC2, + 0x8B, 0x75, 0x54, 0x2D, 0x0F, 0xEF, 0x5F, 0x45, + 0xEA, 0x46, 0xC4, 0xC7, 0x8E, 0x78, 0x7E, 0x9B, + 0xFA, 0x86, 0x4C, 0x89, 0x7C, 0xBF, 0x33, 0xD6, + 0x1C, 0xD7, 0x82, 0x90, 0xE4, 0x33, 0xC6, 0x88, + 0xF4, 0x6A, 0x83, 0x72, 0xC6, 0x0B, 0xCD, 0xC2, + 0xC8, 0x67, 0x25, 0x7E, 0xD6, 0x3A, 0x1B, 0xEB, + 0xA2, 0x7A, 0x5A, 0x38, 0xBD, 0xF3, 0x9A, 0x04 + }, + { + 0x82, 0x0F, 0x1A, 0x4F, 0xFC, 0x90, 0xEB, 0x6A, + 0x51, 0xB2, 0x2C, 0x02, 0xCF, 0xE4, 0x93, 0xEF, + 0x24, 0x6A, 0x8D, 0xCD, 0x20, 0x13, 0x73, 0x73, + 0xEF, 0x94, 0xB9, 0xE3, 0xA2, 0x56, 0x0C, 0x3A, + 0x3F, 0xEE, 0x23, 0x3B, 0x85, 0x60, 0x92, 0xAE, + 0x85, 0x1C, 0xAD, 0x7D, 0x16, 0x57, 0xBE, 0x63, + 0xD1, 0x24, 0xF1, 0xA6, 0x06, 0xD6, 0x37, 0x40, + 0x88, 0x40, 0x11, 0x42, 0xE4, 0x1E, 0x24, 0xB4 + }, + { + 0x61, 0xD4, 0x14, 0x01, 0xAF, 0x8F, 0x64, 0x62, + 0xB6, 0xF7, 0xB0, 0x36, 0x09, 0x7C, 0x9F, 0x2E, + 0x14, 0x88, 0xF1, 0x25, 0xBC, 0x3F, 0x8A, 0x4B, + 0x89, 0x37, 0xB8, 0x35, 0xBE, 0x40, 0xCE, 0xE2, + 0x1D, 0x52, 0x7B, 0xB1, 0x8A, 0x11, 0xA5, 0x5E, + 0xE0, 0x2D, 0x20, 0x5B, 0x34, 0xEC, 0x16, 0x46, + 0x9B, 0xD4, 0xD6, 0xEE, 0x46, 0x27, 0xDB, 0x36, + 0x69, 0x30, 0xE5, 0x46, 0x7F, 0xE1, 0x03, 0x96 + }, + { + 0x33, 0x17, 0x1D, 0x90, 0xD9, 0x43, 0x00, 0xA1, + 0xB4, 0xD8, 0xEF, 0xA8, 0xBD, 0xBD, 0x69, 0x05, + 0x2D, 0xD7, 0x87, 0xE8, 0xFA, 0x66, 0x61, 0xB7, + 0xF8, 0x86, 0x18, 0xCD, 0x01, 0xFF, 0xF2, 0x9E, + 0x11, 0xFD, 0x34, 0x02, 0xAB, 0xA0, 0x82, 0x66, + 0xC0, 0xFC, 0xC5, 0x1C, 0x1F, 0x81, 0xA4, 0xC5, + 0x56, 0x43, 0xDD, 0x8D, 0x9C, 0x1A, 0x70, 0x5D, + 0xBE, 0x23, 0x15, 0x84, 0x4B, 0xE2, 0x0D, 0xAC + }, + { + 0x5F, 0x99, 0x54, 0x11, 0xBE, 0x6C, 0x6C, 0xA5, + 0x8C, 0x2D, 0xCC, 0x4A, 0x73, 0xCF, 0xD5, 0x98, + 0xED, 0x20, 0x73, 0xD1, 0x87, 0x30, 0xFF, 0x66, + 0x74, 0xA0, 0x50, 0x51, 0x2E, 0x69, 0x3E, 0x0A, + 0x7A, 0x9A, 0xBA, 0x70, 0x42, 0x38, 0xC3, 0xD9, + 0x4B, 0xCF, 0x50, 0xBA, 0x9E, 0x5B, 0xA6, 0x5E, + 0x3F, 0x9A, 0xB2, 0x55, 0x7A, 0x84, 0xCF, 0x06, + 0x0D, 0x26, 0x14, 0x41, 0xBB, 0xC9, 0xE5, 0x0E + }, + { + 0x2D, 0xF6, 0xF7, 0x96, 0xF2, 0x60, 0x6F, 0x13, + 0x88, 0x61, 0xBD, 0x9E, 0x4A, 0x52, 0x29, 0x3B, + 0x43, 0xFA, 0xBF, 0xF7, 0xDC, 0xA2, 0x92, 0x94, + 0xD2, 0xAA, 0x8B, 0x2B, 0x2E, 0xA8, 0xC4, 0x02, + 0x23, 0x16, 0xC2, 0x3B, 0xB5, 0xA9, 0x8B, 0x8A, + 0x89, 0x89, 0xDF, 0xA9, 0x90, 0xCB, 0x5C, 0x21, + 0x10, 0x6D, 0xC5, 0x8C, 0x3D, 0x8C, 0x8A, 0xFA, + 0x6D, 0x54, 0xFD, 0xB2, 0x06, 0x6A, 0xCE, 0x7F + }, + { + 0x14, 0x20, 0xDB, 0x94, 0x43, 0xA8, 0xEB, 0xB4, + 0x46, 0xE6, 0x38, 0x0B, 0xB1, 0xF7, 0x43, 0xA1, + 0xC5, 0x19, 0xC5, 0xBF, 0x7B, 0xB5, 0x99, 0xDA, + 0xA8, 0xD6, 0x4D, 0x1F, 0x89, 0xD3, 0xA3, 0x06, + 0x28, 0x08, 0xA2, 0x30, 0x7C, 0x1B, 0x65, 0xF0, + 0xDB, 0x75, 0xB2, 0xF8, 0x86, 0x81, 0xF4, 0xF6, + 0xE2, 0x04, 0x9B, 0x8A, 0xCD, 0x47, 0xE2, 0xF6, + 0x4F, 0xDD, 0xA2, 0x19, 0x65, 0xF1, 0x02, 0xBD + }, + { + 0x3E, 0x3A, 0xBC, 0xD1, 0xF4, 0x74, 0x52, 0x76, + 0x1B, 0xD0, 0x17, 0xE8, 0x77, 0xFB, 0xE0, 0x87, + 0x2E, 0xF1, 0x2F, 0xA3, 0x32, 0x9F, 0xE9, 0x01, + 0xBC, 0x53, 0x06, 0x5E, 0x4B, 0x8F, 0xB1, 0x10, + 0x52, 0x9A, 0xAD, 0x7D, 0x65, 0x40, 0xE7, 0x4D, + 0xE9, 0x8B, 0x0D, 0x61, 0xDF, 0x33, 0xF8, 0x3A, + 0xF3, 0x95, 0x70, 0x75, 0x54, 0xA3, 0xDF, 0x7F, + 0xF9, 0xAB, 0xE2, 0xC0, 0x22, 0x17, 0x25, 0x92 + }, + { + 0xF6, 0xF5, 0xAA, 0x66, 0x61, 0x5B, 0xF9, 0x24, + 0xBD, 0x52, 0x8E, 0x4E, 0xBA, 0x6C, 0x7E, 0x2A, + 0x63, 0x28, 0xCD, 0xE1, 0xFA, 0xF7, 0x8B, 0x81, + 0x48, 0xC0, 0x21, 0xDB, 0xA8, 0x5B, 0x14, 0x14, + 0x90, 0x6C, 0xEF, 0x39, 0xA9, 0x73, 0x76, 0x5D, + 0xDE, 0x21, 0x4A, 0xE3, 0x6E, 0x14, 0xB3, 0xC0, + 0xC4, 0xCB, 0xF1, 0x10, 0x7B, 0x72, 0x6A, 0xB1, + 0x0D, 0xE0, 0x5D, 0x03, 0x0E, 0x2F, 0x14, 0x3D + }, + { + 0x66, 0x13, 0x45, 0xB6, 0xEC, 0xD5, 0x7D, 0xEA, + 0x95, 0x67, 0x07, 0xE1, 0xFE, 0x31, 0x4A, 0xE9, + 0x47, 0x7F, 0x2F, 0x52, 0xB0, 0x6B, 0x74, 0x23, + 0x27, 0x03, 0x1B, 0x14, 0x46, 0xF8, 0x39, 0x60, + 0x86, 0x4F, 0x0E, 0xFD, 0x4B, 0x01, 0x2C, 0x33, + 0x17, 0xEB, 0x81, 0x52, 0x0E, 0xEC, 0x0A, 0x9A, + 0xC1, 0x81, 0x30, 0x7D, 0xF4, 0x06, 0x2C, 0x1E, + 0x90, 0xE2, 0x81, 0x92, 0x11, 0x6F, 0xA4, 0xDA + }, + { + 0x49, 0x57, 0x15, 0xD9, 0xD3, 0x6C, 0x5C, 0x31, + 0xCC, 0x43, 0x30, 0x1A, 0x7E, 0x03, 0x4F, 0x16, + 0xF5, 0xE8, 0x1D, 0x4C, 0x7C, 0xCF, 0x94, 0x43, + 0x0C, 0x42, 0x4F, 0x06, 0xB9, 0x2B, 0xE5, 0xA2, + 0x0F, 0x03, 0xC5, 0xDA, 0x74, 0x45, 0x3F, 0x7D, + 0xDB, 0x23, 0x09, 0xC2, 0x35, 0x3A, 0x51, 0x7B, + 0x91, 0x38, 0x64, 0x35, 0x1E, 0x1E, 0x6B, 0xE6, + 0xA8, 0x71, 0xE7, 0x87, 0x20, 0xEA, 0x36, 0xBE + }, + { + 0x1F, 0x32, 0xE0, 0x1C, 0x75, 0x62, 0xAF, 0xAB, + 0x82, 0xA3, 0xEA, 0x89, 0x33, 0x3D, 0x97, 0x04, + 0x7C, 0xBE, 0xB3, 0x28, 0xFB, 0xC1, 0x69, 0x4D, + 0xFB, 0x39, 0x1C, 0xCB, 0x9A, 0xCD, 0xC0, 0xBB, + 0xAA, 0x8F, 0x88, 0x4B, 0x15, 0xC1, 0xF6, 0x75, + 0xC9, 0x36, 0xC1, 0x28, 0x55, 0x11, 0x24, 0x6C, + 0x4E, 0x28, 0x93, 0xCC, 0xE7, 0x89, 0xCB, 0x8E, + 0x77, 0xC6, 0x48, 0xC4, 0x77, 0x24, 0x3E, 0xCB + }, + { + 0x38, 0x1D, 0x11, 0x68, 0xC9, 0xCF, 0x9F, 0x03, + 0x52, 0x66, 0xEE, 0x81, 0x6B, 0xBC, 0x54, 0xD0, + 0x27, 0x67, 0xCB, 0xC3, 0x6C, 0x42, 0x0C, 0xF2, + 0x01, 0x82, 0x7B, 0x9A, 0xE5, 0xB6, 0xBE, 0x6F, + 0xD4, 0xFD, 0x8E, 0x88, 0x94, 0x38, 0x24, 0x9D, + 0x41, 0x28, 0x92, 0x12, 0x6E, 0xE4, 0x24, 0x60, + 0x20, 0x08, 0x32, 0x3E, 0xFD, 0x6A, 0xAD, 0x27, + 0xEE, 0x7E, 0x26, 0xB7, 0xF7, 0x9F, 0xEE, 0x85 + }, + { + 0x59, 0x73, 0xC5, 0x01, 0x8E, 0xA8, 0x22, 0x78, + 0xB1, 0x13, 0x61, 0x43, 0x47, 0x60, 0x69, 0xA0, + 0xC7, 0xF3, 0xDA, 0x8D, 0xA0, 0x53, 0x14, 0xB7, + 0x77, 0x3F, 0x3B, 0xE1, 0x29, 0x93, 0x2E, 0x29, + 0xAD, 0xE7, 0x3F, 0xE0, 0xE1, 0x55, 0x46, 0x5F, + 0x23, 0xEC, 0x6B, 0xFC, 0xFC, 0x1E, 0xA0, 0xA6, + 0x27, 0x77, 0xC1, 0xE5, 0xDE, 0x1E, 0xB9, 0x71, + 0xEB, 0xEA, 0x4D, 0xBC, 0x82, 0x9E, 0xF4, 0xA2 + }, + { + 0x75, 0xD8, 0xEA, 0x69, 0xCE, 0x3B, 0x15, 0x8A, + 0xE9, 0x44, 0x94, 0x5A, 0x03, 0x28, 0x76, 0xDF, + 0x31, 0x79, 0x35, 0xED, 0x9C, 0xF6, 0xF5, 0xBC, + 0x60, 0x0E, 0x64, 0x4B, 0x0D, 0xF3, 0xBA, 0x5E, + 0xDC, 0xBA, 0x1D, 0xC5, 0x47, 0x6F, 0x84, 0x8C, + 0x65, 0x6D, 0x92, 0x6B, 0x87, 0x14, 0x52, 0x06, + 0x8F, 0xC3, 0x44, 0x9A, 0x19, 0xA3, 0x3E, 0xCE, + 0xA3, 0x42, 0x2E, 0x0E, 0x4C, 0xEB, 0x68, 0x49 + }, + { + 0xD7, 0x9D, 0x03, 0x57, 0xB3, 0xBF, 0x36, 0x01, + 0x39, 0x8E, 0x7B, 0x2C, 0x00, 0x64, 0xC6, 0x2A, + 0xA2, 0xE3, 0x68, 0x7E, 0xF5, 0xE4, 0xA4, 0x53, + 0x6E, 0xE9, 0x3F, 0x5F, 0x5C, 0x94, 0x4C, 0x0E, + 0x59, 0x9F, 0xC6, 0x60, 0xEE, 0x0D, 0x59, 0xF6, + 0x27, 0x3F, 0x3C, 0xDB, 0xB4, 0xE5, 0x98, 0x53, + 0x86, 0xB4, 0x37, 0x8A, 0x77, 0x6B, 0xAF, 0xAE, + 0xDF, 0x31, 0x9C, 0xB1, 0xE6, 0xCE, 0x07, 0x78 + }, + { + 0xED, 0x08, 0xF5, 0x1C, 0xDA, 0x1C, 0xF9, 0xAA, + 0x97, 0xCB, 0x92, 0x5C, 0x41, 0xDF, 0x08, 0x63, + 0xA9, 0xA9, 0x40, 0xB4, 0x20, 0xF3, 0x14, 0xC0, + 0xA2, 0x40, 0xFC, 0x80, 0x4C, 0x75, 0x15, 0x4C, + 0x3A, 0xA1, 0x12, 0xA1, 0x7D, 0xA0, 0x50, 0x82, + 0x6B, 0x3D, 0x84, 0x6B, 0xAB, 0x2F, 0xE6, 0x24, + 0x76, 0x62, 0x8F, 0x17, 0x72, 0xAE, 0xE3, 0xF6, + 0x84, 0x0E, 0xD1, 0x35, 0xF0, 0x23, 0x1A, 0x92 + }, + { + 0x79, 0x8A, 0x3C, 0xF7, 0xE9, 0x8C, 0xF1, 0xDA, + 0x12, 0xF8, 0xB7, 0x3B, 0xB7, 0x17, 0x6C, 0x0A, + 0x05, 0x34, 0xC9, 0x17, 0x46, 0x14, 0x4A, 0x0C, + 0x6F, 0xB9, 0x3F, 0x49, 0xC0, 0xD5, 0xB0, 0xF3, + 0x5B, 0x07, 0x0F, 0xF2, 0x21, 0x8E, 0x9D, 0x1C, + 0x4F, 0x7A, 0x11, 0x9E, 0x32, 0x45, 0xB5, 0x30, + 0x25, 0x47, 0xF7, 0x26, 0xEB, 0xF6, 0x2F, 0xD5, + 0x7B, 0x2C, 0x0A, 0xF9, 0x35, 0x41, 0x59, 0xE6 + }, + { + 0x32, 0x49, 0xC3, 0xFE, 0x00, 0x05, 0x51, 0xE8, + 0x96, 0xDA, 0xD2, 0xF1, 0xA2, 0xC0, 0xA3, 0x94, + 0x85, 0xDA, 0xCD, 0xC8, 0x99, 0xD3, 0x6F, 0xC6, + 0x82, 0xBC, 0x0F, 0x3B, 0x80, 0x1E, 0x19, 0xCF, + 0x87, 0xEC, 0x12, 0xC3, 0xCD, 0x65, 0x72, 0xA7, + 0x98, 0x99, 0xE0, 0x99, 0x4B, 0x96, 0xD5, 0x05, + 0x6E, 0xB8, 0x51, 0xEE, 0x85, 0xC2, 0x2C, 0xED, + 0x41, 0xD9, 0xA0, 0xF2, 0x32, 0xFE, 0x71, 0x8C + }, + { + 0x84, 0xE9, 0x3B, 0x95, 0x37, 0xB6, 0x89, 0x3C, + 0xC6, 0xBD, 0x95, 0xDF, 0x94, 0xE4, 0x47, 0x2B, + 0x18, 0x3C, 0x6A, 0x03, 0x22, 0x15, 0xF9, 0x76, + 0x5F, 0xAC, 0x5B, 0x6C, 0x7D, 0xA6, 0xFD, 0xC6, + 0x50, 0xA8, 0x3A, 0x17, 0x10, 0x87, 0x2B, 0xDB, + 0x09, 0xC0, 0x11, 0x7E, 0xFA, 0x65, 0xFA, 0xB7, + 0xFF, 0x40, 0x2D, 0x89, 0xB1, 0x7D, 0x39, 0x89, + 0x38, 0xD2, 0x56, 0xB1, 0x55, 0x8F, 0x83, 0x1F + }, + { + 0xAD, 0x43, 0x42, 0x49, 0x1A, 0x18, 0x28, 0x41, + 0xB1, 0x44, 0x53, 0x77, 0xAD, 0x19, 0xF8, 0x09, + 0x4D, 0xDB, 0x79, 0x5D, 0x85, 0x27, 0x2E, 0xCA, + 0x50, 0xC0, 0x7E, 0xD5, 0xAD, 0x7C, 0xB6, 0xC4, + 0xF1, 0x2C, 0xC0, 0x7D, 0x88, 0x41, 0xE2, 0xAD, + 0x47, 0xC3, 0x75, 0xE1, 0x5D, 0x9E, 0xA6, 0x81, + 0x8F, 0xB0, 0xF8, 0xD9, 0x1F, 0x85, 0xD3, 0x96, + 0xA4, 0x77, 0x9C, 0x46, 0x1E, 0x10, 0x1A, 0x2C + }, + { + 0xA7, 0x5C, 0x6F, 0x69, 0xEE, 0x14, 0x73, 0x2A, + 0xA9, 0x2B, 0x72, 0x9D, 0x8B, 0x1F, 0x96, 0x6B, + 0xF4, 0x82, 0x23, 0x85, 0x38, 0xCA, 0xC1, 0xFE, + 0xF3, 0xBC, 0x58, 0xE4, 0x73, 0xC1, 0x55, 0xB7, + 0x15, 0x2C, 0x98, 0x40, 0x09, 0xD8, 0x62, 0x57, + 0x89, 0x98, 0x53, 0x0B, 0x04, 0x9E, 0x48, 0x44, + 0x51, 0x16, 0x94, 0x03, 0x09, 0x07, 0x0D, 0x55, + 0x06, 0x7D, 0x73, 0xDC, 0x12, 0x43, 0x0D, 0xB2 + }, + { + 0x9B, 0x3F, 0x5B, 0x4F, 0x40, 0x9C, 0x5B, 0xCB, + 0xFB, 0xF9, 0x83, 0x0B, 0x37, 0xFE, 0x8A, 0xE9, + 0x80, 0x40, 0x8E, 0xE6, 0x2E, 0xFE, 0x6A, 0xA7, + 0x37, 0x66, 0x68, 0x6E, 0x2D, 0x30, 0xE1, 0xE6, + 0x76, 0x2B, 0xB7, 0x0D, 0x3E, 0xD4, 0xE5, 0xE6, + 0xFF, 0xC5, 0x8C, 0x6F, 0xDB, 0xD8, 0x6E, 0xB8, + 0xF5, 0x33, 0x8A, 0xEE, 0x03, 0xF6, 0x5C, 0xCC, + 0x87, 0xB5, 0x49, 0x59, 0xA3, 0x4A, 0x76, 0xF9 + }, + { + 0xB4, 0xBB, 0xAD, 0xC1, 0x0F, 0x61, 0xDE, 0x03, + 0x52, 0x25, 0xEE, 0xDC, 0x9F, 0x84, 0x1B, 0xCC, + 0x24, 0x6C, 0xC0, 0x5E, 0x18, 0x58, 0x1B, 0x53, + 0xBF, 0xA1, 0xEC, 0x31, 0xF4, 0xA7, 0x91, 0x56, + 0x4F, 0xEB, 0x22, 0x9F, 0x1E, 0xE1, 0x2F, 0x95, + 0x7F, 0xF0, 0xE7, 0xE5, 0x43, 0xFE, 0xEF, 0xEB, + 0x31, 0x09, 0x50, 0x45, 0x77, 0xFA, 0x9B, 0xE2, + 0x94, 0xD5, 0x48, 0x5D, 0xEE, 0x7C, 0xC3, 0x24 + }, + { + 0x9F, 0x5D, 0xF9, 0x6F, 0xB6, 0x45, 0x3D, 0x0E, + 0x03, 0x25, 0xA2, 0x49, 0x6C, 0xA7, 0xA5, 0x63, + 0xFD, 0xC9, 0x8A, 0xB4, 0x50, 0x67, 0x88, 0xC8, + 0xF6, 0xB9, 0x1E, 0x21, 0x13, 0xCB, 0x6F, 0xA1, + 0xA8, 0xD4, 0x1D, 0x5A, 0x43, 0x0F, 0xCD, 0xA5, + 0xA4, 0x23, 0x19, 0x94, 0xC4, 0xC2, 0xDB, 0x4F, + 0x92, 0x72, 0xF0, 0x4A, 0xDF, 0xD5, 0xE7, 0x3F, + 0x56, 0x30, 0xF4, 0xEF, 0xA0, 0x6E, 0x86, 0xCF + }, + { + 0x23, 0x03, 0x6C, 0x67, 0xFE, 0xCE, 0xD1, 0x98, + 0xEF, 0x92, 0x28, 0x68, 0x89, 0x80, 0x29, 0xFA, + 0x41, 0x78, 0xE1, 0x90, 0xBD, 0x45, 0x0F, 0x6F, + 0xBC, 0x76, 0x7F, 0x1B, 0x18, 0xA9, 0x2D, 0x05, + 0xB4, 0x8A, 0x5B, 0xBB, 0x35, 0xF0, 0xD5, 0x16, + 0x8D, 0xA5, 0x2D, 0x47, 0x4C, 0x05, 0x87, 0x20, + 0xB8, 0xB9, 0x90, 0x7C, 0x50, 0xF8, 0x01, 0x57, + 0x59, 0x40, 0x57, 0xD5, 0xAE, 0xF4, 0x00, 0xAF + }, + { + 0x37, 0x28, 0x6F, 0x72, 0xFF, 0xFB, 0xB7, 0xE1, + 0x09, 0xBD, 0xB5, 0xEB, 0x3F, 0x6A, 0x9F, 0x99, + 0x6F, 0x59, 0x07, 0x85, 0xF4, 0xA2, 0x6B, 0x86, + 0x88, 0x3D, 0x38, 0x57, 0x05, 0xE4, 0x2D, 0xBA, + 0x13, 0x31, 0x71, 0x73, 0xC6, 0xD8, 0xCB, 0x6B, + 0x5D, 0xE4, 0x2C, 0x60, 0xB6, 0x73, 0x66, 0x87, + 0x7D, 0x6D, 0x88, 0x50, 0x61, 0x61, 0xC1, 0xF7, + 0x91, 0x31, 0xC2, 0x19, 0x52, 0xD6, 0xEA, 0x9E + }, + { + 0x62, 0xCC, 0x84, 0x72, 0x17, 0x4A, 0xF9, 0xA5, + 0xF8, 0xF9, 0xD3, 0xBC, 0x27, 0x14, 0x22, 0xCF, + 0x61, 0xF4, 0x01, 0xC4, 0x6A, 0xF1, 0x7E, 0x65, + 0xFB, 0x8B, 0xA4, 0x2D, 0x64, 0x75, 0xF3, 0x05, + 0x8D, 0xC7, 0x50, 0xA5, 0x01, 0x3D, 0xBD, 0x2D, + 0x4F, 0x5D, 0xF2, 0x10, 0x7A, 0xBD, 0x44, 0xC6, + 0xCA, 0x8C, 0x02, 0x86, 0x3A, 0x5D, 0xEA, 0xF9, + 0x5D, 0x78, 0x9D, 0xE6, 0x4E, 0x01, 0xC9, 0x10 + }, + { + 0x19, 0xDA, 0xA3, 0x4E, 0x47, 0x03, 0x13, 0x69, + 0x72, 0x42, 0x6D, 0xDB, 0xFF, 0xC1, 0xF7, 0x1A, + 0x40, 0xE5, 0xF1, 0xCB, 0xF1, 0xCE, 0xFD, 0x44, + 0x77, 0x51, 0x0E, 0xE8, 0x9A, 0x93, 0x66, 0x1B, + 0x24, 0xF4, 0xF0, 0x09, 0xA1, 0x5E, 0x8F, 0x81, + 0x1D, 0x99, 0xB9, 0xED, 0x33, 0x4B, 0x4D, 0x7E, + 0x8D, 0x52, 0xEF, 0xB2, 0x8C, 0x35, 0x12, 0xC9, + 0xAF, 0x20, 0x0A, 0xAB, 0xF1, 0x5D, 0xAC, 0x4E + }, + { + 0x48, 0x88, 0xE3, 0xEF, 0xD7, 0xDF, 0x88, 0x89, + 0x80, 0xF7, 0x09, 0xDC, 0x44, 0x84, 0xB5, 0xEE, + 0xDF, 0xC9, 0xCA, 0xB9, 0xE3, 0xFE, 0xFA, 0x39, + 0xA2, 0xD4, 0x57, 0x9F, 0xC7, 0xB6, 0xA0, 0xCE, + 0x43, 0x9B, 0x9F, 0x2E, 0xF4, 0xF1, 0xE0, 0x16, + 0xFA, 0x06, 0xDF, 0x5D, 0x65, 0x3C, 0xEF, 0x6E, + 0xFD, 0x81, 0x65, 0x7D, 0x92, 0x23, 0x0D, 0x00, + 0xAF, 0x12, 0x02, 0xF5, 0x80, 0xDB, 0xAB, 0x3A + }, + { + 0x3E, 0x56, 0x4B, 0x92, 0xF5, 0xB7, 0x04, 0xC6, + 0x22, 0x25, 0x08, 0x60, 0x8E, 0xFC, 0x04, 0x31, + 0xB9, 0x3C, 0x39, 0x96, 0xD8, 0xF0, 0xD5, 0xB2, + 0xF9, 0xC9, 0x12, 0xE5, 0x12, 0x45, 0x30, 0x73, + 0x60, 0x51, 0x0D, 0xBA, 0xAF, 0x8F, 0xB7, 0x2E, + 0x64, 0x35, 0x61, 0x11, 0xFD, 0xE9, 0x51, 0x85, + 0x48, 0xD6, 0xFF, 0xE4, 0x75, 0x38, 0x04, 0x2D, + 0x5C, 0x86, 0x8B, 0x33, 0xAD, 0x83, 0x5D, 0x79 + }, + { + 0x1D, 0x05, 0x20, 0x72, 0x9F, 0xEA, 0x0E, 0xC5, + 0x9D, 0x6E, 0x28, 0x74, 0xB7, 0x34, 0xC3, 0x41, + 0x7B, 0xD5, 0xA4, 0xB0, 0xDC, 0x46, 0x10, 0x4D, + 0x65, 0x78, 0x87, 0x00, 0x96, 0xAF, 0x63, 0xB7, + 0xFD, 0x0E, 0x18, 0xAA, 0x0E, 0x51, 0x34, 0x73, + 0x2B, 0x9B, 0xBA, 0x07, 0x82, 0x88, 0x19, 0xFD, + 0x28, 0x41, 0x15, 0x53, 0x5A, 0x02, 0x23, 0x5F, + 0xF7, 0x37, 0x22, 0xC6, 0xCE, 0x1D, 0x7A, 0x08 + }, + { + 0x1A, 0x71, 0x89, 0x6C, 0x86, 0x1C, 0xC6, 0xDB, + 0x92, 0x78, 0x00, 0xC7, 0x2A, 0x83, 0x41, 0x4F, + 0x26, 0x60, 0x6C, 0x8A, 0x55, 0x74, 0xB3, 0x8D, + 0x2A, 0xE6, 0xD0, 0x43, 0x2C, 0x6F, 0x75, 0x22, + 0xBD, 0x33, 0xAB, 0xC3, 0x5C, 0x5A, 0x1B, 0x88, + 0x98, 0x27, 0xA4, 0xFD, 0xA4, 0x89, 0x4C, 0xAD, + 0xAE, 0x2D, 0x24, 0xB0, 0x7D, 0x73, 0xC3, 0x50, + 0x83, 0x55, 0xEA, 0xC6, 0x27, 0x43, 0x53, 0xDA + }, + { + 0x85, 0x18, 0x7F, 0xE6, 0xC6, 0xC1, 0x87, 0x15, + 0xF5, 0x7C, 0xE4, 0xF0, 0xFD, 0xC7, 0x3F, 0x84, + 0xA7, 0x26, 0x3C, 0xFF, 0x38, 0x8B, 0x41, 0x5D, + 0xF7, 0x89, 0xCD, 0xC7, 0xA6, 0x07, 0xD5, 0x2C, + 0x89, 0xA6, 0x8A, 0x14, 0xB2, 0xF0, 0xC4, 0x74, + 0x4B, 0x0C, 0x6F, 0x79, 0xA8, 0xD8, 0xFC, 0x18, + 0x9B, 0x71, 0x23, 0x6C, 0x12, 0x62, 0x7C, 0x19, + 0x36, 0xD7, 0xF9, 0x1B, 0x1B, 0x33, 0x8E, 0x96 + }, + { + 0xE7, 0x55, 0xC3, 0x4C, 0x9E, 0xB2, 0x7D, 0x0D, + 0x8B, 0x22, 0xB6, 0x7A, 0x66, 0xB9, 0xDB, 0x4A, + 0x2C, 0x1B, 0x85, 0x3B, 0xFC, 0x9B, 0x70, 0x83, + 0x4D, 0x39, 0x04, 0xAE, 0xE5, 0xA3, 0xE1, 0xF3, + 0x50, 0xB4, 0xE5, 0x3A, 0x26, 0xB4, 0x69, 0xDD, + 0xDC, 0x56, 0x86, 0x00, 0x00, 0x45, 0xD4, 0x5E, + 0x59, 0x44, 0x16, 0x55, 0x54, 0x45, 0xD2, 0x89, + 0x55, 0x32, 0xB3, 0x3F, 0x21, 0x41, 0x8B, 0x08 + }, + { + 0xC3, 0x86, 0x92, 0xE3, 0xAA, 0x0D, 0xFA, 0xAA, + 0x72, 0x2A, 0xC2, 0x77, 0x06, 0xB1, 0xAF, 0xFA, + 0x13, 0xCC, 0x67, 0xD2, 0x49, 0x38, 0xD9, 0xF0, + 0x91, 0x86, 0x3F, 0x81, 0xFC, 0x8A, 0x77, 0x96, + 0xD7, 0xBC, 0xC8, 0x57, 0x67, 0xFB, 0xBC, 0x96, + 0x99, 0xAC, 0xBE, 0xE1, 0xF2, 0xDB, 0x64, 0x1D, + 0x73, 0x13, 0x17, 0x46, 0xE4, 0xEB, 0xC0, 0x16, + 0xBF, 0x8B, 0xEC, 0x8C, 0x1C, 0xBB, 0x74, 0x25 + }, + { + 0xCC, 0x04, 0x50, 0xE4, 0x24, 0x01, 0x4B, 0x56, + 0x06, 0xB6, 0x98, 0x8C, 0x9B, 0xEF, 0x9F, 0xB5, + 0x73, 0x9F, 0x8E, 0xA8, 0xEA, 0xC9, 0xA0, 0x8D, + 0xA3, 0x95, 0xC3, 0x77, 0xA5, 0x46, 0x46, 0xFB, + 0xC2, 0x51, 0xE7, 0x69, 0x2A, 0x4C, 0x4F, 0x48, + 0x1B, 0x9D, 0xB1, 0xD4, 0xA0, 0x40, 0xE5, 0xAF, + 0x28, 0x08, 0xAB, 0x32, 0x50, 0x9C, 0x31, 0xA2, + 0x30, 0xDB, 0x7E, 0x9F, 0xFB, 0x0C, 0xEA, 0x4C + }, + { + 0xE5, 0x47, 0x03, 0xA7, 0x75, 0x41, 0xA0, 0xD9, + 0xB1, 0x4D, 0x6B, 0x75, 0x43, 0xD0, 0x6A, 0xF2, + 0x0D, 0x53, 0xFF, 0x6B, 0x7F, 0x5F, 0x61, 0xD3, + 0xA5, 0x3F, 0x86, 0x49, 0x18, 0x48, 0x0F, 0x96, + 0x96, 0xAE, 0xD2, 0x03, 0x2C, 0x10, 0x8C, 0x66, + 0xE4, 0x65, 0x5C, 0x39, 0xCE, 0x36, 0x76, 0xF2, + 0xDA, 0xD8, 0xC0, 0xD7, 0x4D, 0x59, 0x64, 0xE8, + 0x67, 0x50, 0xF4, 0xD3, 0x00, 0xDC, 0xA1, 0xC8 + }, + { + 0x53, 0x0F, 0xCB, 0x3D, 0xEE, 0x7C, 0xC1, 0x80, + 0x0D, 0x04, 0x92, 0xF5, 0x02, 0xC8, 0x2C, 0x3A, + 0xC9, 0x79, 0x0E, 0x44, 0x2D, 0x3A, 0xBB, 0x5D, + 0xB9, 0x47, 0xF5, 0x5D, 0xA8, 0x15, 0x97, 0x81, + 0x58, 0x4D, 0x66, 0xB9, 0x45, 0x39, 0xC7, 0x72, + 0xF1, 0xC5, 0xFF, 0xE5, 0x20, 0x90, 0xC9, 0x32, + 0x31, 0x93, 0xD9, 0xBA, 0xD6, 0x02, 0xC1, 0xF6, + 0xF1, 0xFE, 0xCA, 0xC2, 0x1B, 0x46, 0xBB, 0x23 + }, + { + 0x01, 0xD7, 0x91, 0x1D, 0xA0, 0xC9, 0x50, 0xD3, + 0xFF, 0x13, 0xEF, 0x16, 0xBA, 0x10, 0x9A, 0x7A, + 0xF7, 0xDF, 0xA8, 0x87, 0x86, 0xAD, 0x0B, 0xF3, + 0xB8, 0x9A, 0x3E, 0xE5, 0x76, 0xF0, 0x3C, 0x90, + 0xDA, 0xC6, 0x14, 0xD9, 0xD8, 0xC8, 0x08, 0xA0, + 0x50, 0x0F, 0x92, 0x1C, 0xAA, 0x5F, 0x8F, 0xCD, + 0x10, 0x79, 0xB5, 0xC3, 0x00, 0x41, 0x2B, 0xB2, + 0x79, 0x25, 0x7F, 0x03, 0xCF, 0x86, 0xE3, 0x7B + }, + { + 0x6A, 0xFB, 0xBE, 0xC8, 0x5C, 0xFB, 0x0C, 0xEC, + 0x49, 0x9F, 0xC1, 0x5D, 0x42, 0xFF, 0x5A, 0xAD, + 0x33, 0xFA, 0x61, 0x04, 0xF5, 0xEE, 0x7A, 0x3E, + 0x15, 0xE5, 0xFC, 0x92, 0x86, 0x0C, 0x63, 0x48, + 0xC8, 0xC9, 0x80, 0x50, 0xFE, 0x0F, 0x05, 0xD4, + 0x26, 0xD9, 0x6B, 0xE6, 0x8B, 0xC8, 0x20, 0x6F, + 0xE4, 0x0E, 0x81, 0x69, 0xA6, 0x18, 0x26, 0x00, + 0x1E, 0xAF, 0xBE, 0xEE, 0xF7, 0xEA, 0x3E, 0xFB + }, + { + 0x3D, 0x46, 0x85, 0x51, 0x66, 0xE2, 0xCA, 0x05, + 0x6E, 0xB8, 0x3C, 0xBA, 0x61, 0xD6, 0x67, 0xE3, + 0x47, 0x2A, 0x6F, 0xD5, 0x16, 0x11, 0x48, 0xC9, + 0xD5, 0xE2, 0x7C, 0xB5, 0x92, 0x99, 0xD5, 0xBA, + 0xDE, 0x1F, 0x83, 0xDA, 0xD9, 0x10, 0x03, 0x2F, + 0x43, 0x7E, 0x69, 0x4E, 0xC6, 0x21, 0xEB, 0x7E, + 0x83, 0x40, 0x1E, 0x05, 0xCF, 0x5A, 0x83, 0xDB, + 0xE4, 0xC8, 0x68, 0x9B, 0xEE, 0x34, 0xA9, 0x13 + }, + { + 0x08, 0x0D, 0x70, 0xBE, 0xB9, 0x5D, 0xB4, 0xBC, + 0xC4, 0x7F, 0xA8, 0xC1, 0x85, 0x50, 0x16, 0x46, + 0x93, 0x20, 0x60, 0x09, 0x9B, 0xE6, 0xF6, 0x62, + 0x37, 0x90, 0x09, 0xC9, 0xD5, 0xCB, 0xA0, 0xE1, + 0x79, 0x59, 0x66, 0xA6, 0x35, 0xDE, 0xC6, 0x5D, + 0x85, 0xC2, 0xC2, 0xDC, 0x71, 0xB9, 0xF8, 0xFB, + 0x8A, 0x7A, 0xA6, 0x6F, 0x63, 0x0B, 0x1F, 0x14, + 0x97, 0xA6, 0xB7, 0x3A, 0xFC, 0x43, 0x19, 0xF1 + }, + { + 0x4F, 0xA7, 0x4A, 0x86, 0x63, 0x7E, 0x77, 0x79, + 0xD4, 0x2A, 0x3E, 0x3C, 0xDA, 0x7F, 0x61, 0xC1, + 0xF1, 0xA6, 0x3E, 0xBA, 0x17, 0x60, 0x19, 0x89, + 0x24, 0x4E, 0x79, 0xC6, 0x4F, 0xEA, 0x17, 0x93, + 0xAF, 0xCB, 0x7C, 0xD0, 0xB3, 0x32, 0x9C, 0xB1, + 0x85, 0x8B, 0x2A, 0xCD, 0xA9, 0x2F, 0xC2, 0x17, + 0x02, 0x0A, 0x22, 0xC7, 0x9E, 0x15, 0x56, 0xDD, + 0x5B, 0xF2, 0xD4, 0x57, 0x54, 0x4D, 0x92, 0x27 + }, + { + 0xB0, 0xDC, 0x78, 0xE6, 0x12, 0xE6, 0xEB, 0x99, + 0x8C, 0xDD, 0xB8, 0x0F, 0xEF, 0xCA, 0xF4, 0xAF, + 0x46, 0xC0, 0x13, 0x23, 0xA8, 0xDA, 0x25, 0xCA, + 0x7F, 0x2D, 0xE0, 0x5F, 0x9D, 0xAE, 0xF6, 0x48, + 0xEA, 0xDB, 0x8D, 0x47, 0x75, 0x26, 0xCF, 0x83, + 0xDF, 0x21, 0x4A, 0x57, 0x73, 0x8E, 0x2B, 0x38, + 0x8F, 0x41, 0xC9, 0xDC, 0x38, 0x0B, 0x32, 0x98, + 0x4F, 0x3F, 0xA2, 0x5B, 0xB8, 0xC4, 0x6A, 0x6E + }, + { + 0x3D, 0x57, 0xA7, 0x6F, 0xFC, 0xA0, 0xD0, 0x47, + 0x68, 0x17, 0x49, 0x2D, 0xD4, 0x8B, 0xA2, 0x99, + 0x1A, 0x43, 0xBD, 0x87, 0xE8, 0x0F, 0x21, 0xEB, + 0x07, 0x50, 0x99, 0x87, 0x37, 0xED, 0x31, 0x9F, + 0x4F, 0xC1, 0x97, 0xE7, 0x9B, 0x52, 0x0D, 0xD1, + 0x67, 0x51, 0x07, 0x55, 0x63, 0x89, 0xA1, 0xCE, + 0x43, 0xD9, 0xA1, 0xB7, 0x70, 0xD5, 0x4E, 0x37, + 0xF6, 0xCE, 0xCE, 0xEA, 0xD9, 0xF4, 0x45, 0x8D + }, + { + 0xEC, 0x22, 0x7A, 0x98, 0xA0, 0xF3, 0xE6, 0x91, + 0x57, 0x6F, 0xE0, 0x0B, 0xE8, 0x95, 0x3D, 0x81, + 0x88, 0x96, 0xEB, 0x08, 0xFF, 0xE9, 0x45, 0xD2, + 0xC8, 0xEA, 0x62, 0x8F, 0x16, 0x28, 0x93, 0x85, + 0x23, 0x65, 0xE6, 0x60, 0x66, 0x97, 0x6E, 0xB1, + 0x49, 0x10, 0x56, 0xDE, 0xBB, 0xC1, 0xD8, 0x22, + 0xB3, 0x6A, 0x1F, 0xF8, 0xB2, 0x8F, 0xDB, 0x92, + 0x6E, 0xC8, 0xA7, 0xF3, 0x72, 0x5E, 0x4C, 0x85 + }, + { + 0x30, 0x06, 0x69, 0x0D, 0x36, 0x91, 0x6C, 0x6B, + 0x44, 0x56, 0x8D, 0x7F, 0xBB, 0x12, 0x66, 0x7F, + 0xBC, 0xDD, 0x9A, 0x86, 0xC2, 0x48, 0xE7, 0x05, + 0xC6, 0x74, 0x05, 0x57, 0xAD, 0x8D, 0x93, 0x6F, + 0x1A, 0xE7, 0xB2, 0x87, 0x0B, 0x44, 0xFC, 0xA2, + 0x7D, 0xF5, 0x06, 0xCF, 0x95, 0x3C, 0x0D, 0x3E, + 0x1C, 0x54, 0x6E, 0xE0, 0x69, 0x8F, 0xC6, 0xED, + 0x5B, 0xA4, 0xD0, 0x5D, 0xBF, 0x94, 0x69, 0xAE + }, + { + 0xC1, 0x8D, 0x0E, 0x75, 0x7A, 0xE6, 0xAD, 0xC7, + 0x74, 0x10, 0xD7, 0xA9, 0x58, 0x9D, 0x67, 0xA4, + 0xAE, 0xEE, 0x57, 0x69, 0xC6, 0xD9, 0xE5, 0xD0, + 0x40, 0xCD, 0x37, 0x02, 0xA3, 0xBC, 0x00, 0x1C, + 0xF9, 0xF1, 0x58, 0x46, 0xCF, 0xBD, 0x99, 0xE2, + 0x35, 0x61, 0x97, 0xF0, 0x87, 0x18, 0xD3, 0x22, + 0x3E, 0x46, 0x31, 0x26, 0x95, 0x63, 0x39, 0x6E, + 0x85, 0x3B, 0x55, 0x44, 0x7D, 0xD9, 0x41, 0xE7 + }, + { + 0x69, 0x71, 0xD3, 0xE0, 0x04, 0x82, 0xCD, 0x39, + 0x87, 0xE5, 0x99, 0x33, 0xFB, 0x0E, 0x67, 0xA4, + 0x89, 0x73, 0x6E, 0xBF, 0x4B, 0x02, 0xDC, 0x51, + 0x2E, 0xD0, 0xCA, 0x14, 0x9B, 0x0C, 0xDE, 0x60, + 0xB0, 0x75, 0x29, 0x94, 0x9F, 0x69, 0xBC, 0x83, + 0xC6, 0xD4, 0xF9, 0x77, 0x47, 0x95, 0x2A, 0x59, + 0x3E, 0xDF, 0xBB, 0x72, 0x47, 0x27, 0x7D, 0x97, + 0xAF, 0x97, 0x4F, 0xD7, 0x39, 0x9A, 0x47, 0x06 + }, + { + 0xA2, 0x2A, 0x31, 0x30, 0xAA, 0xBA, 0x4B, 0x3F, + 0x59, 0xED, 0x1C, 0xA5, 0x9E, 0xC9, 0xF9, 0x83, + 0x3D, 0x23, 0x3C, 0x19, 0x82, 0xFF, 0xF1, 0xF0, + 0x6F, 0x80, 0x98, 0x0B, 0xE5, 0xA8, 0x42, 0xB9, + 0x37, 0x21, 0x5C, 0xCA, 0x80, 0xDC, 0xBB, 0x8E, + 0x8E, 0xC7, 0x27, 0x22, 0xB7, 0xB5, 0x1B, 0xCF, + 0x45, 0x04, 0xC6, 0x8F, 0xE9, 0xEF, 0xC6, 0xE1, + 0x1E, 0x9B, 0xD9, 0x44, 0xBA, 0x48, 0x8F, 0xB2 + }, + { + 0x89, 0x7A, 0xBA, 0x07, 0x79, 0xA6, 0x33, 0x0B, + 0xB5, 0xC0, 0x71, 0x8D, 0xD7, 0xD0, 0x06, 0x00, + 0x21, 0xD5, 0x22, 0x25, 0x8F, 0x01, 0x8E, 0x11, + 0xD5, 0x8A, 0xC7, 0x65, 0x50, 0xFA, 0xE4, 0x52, + 0x6E, 0x68, 0x08, 0x9A, 0xE9, 0x12, 0xC9, 0x5B, + 0x56, 0x7B, 0x7E, 0xD4, 0xCA, 0x81, 0x77, 0x4F, + 0x53, 0x5B, 0x84, 0xB4, 0x96, 0x54, 0x9A, 0x47, + 0xDF, 0xF0, 0xCF, 0xB2, 0xFD, 0x4F, 0xBB, 0x3E + }, + { + 0xB5, 0xE1, 0xF9, 0xC1, 0x76, 0x99, 0x4B, 0xD9, + 0xD6, 0xB7, 0x19, 0x03, 0x2B, 0xB6, 0xE1, 0x9C, + 0x2B, 0x53, 0xB0, 0x44, 0xEA, 0x48, 0x53, 0xC5, + 0x92, 0xF4, 0x09, 0x30, 0x0F, 0x9B, 0xC3, 0x6C, + 0x2F, 0xF9, 0x93, 0xBD, 0xF3, 0x24, 0x76, 0x90, + 0xF0, 0xA6, 0xC0, 0xD2, 0x11, 0xEE, 0xED, 0x23, + 0x73, 0x8B, 0x33, 0xE2, 0x14, 0xD7, 0x39, 0xFA, + 0x19, 0xD8, 0xB0, 0x1B, 0xAF, 0xE7, 0x8C, 0xFE + }, + { + 0x28, 0x30, 0xF6, 0xCF, 0x25, 0xF1, 0xC2, 0xB7, + 0x52, 0x69, 0x19, 0x59, 0x2F, 0xD7, 0x1A, 0xE0, + 0xC5, 0x5A, 0xB8, 0xD2, 0x6B, 0x4F, 0x4D, 0xC5, + 0x9D, 0x9D, 0x13, 0xD5, 0x04, 0x7B, 0x81, 0x92, + 0x96, 0x97, 0x86, 0x17, 0x44, 0x41, 0xCE, 0x1E, + 0xBC, 0x06, 0xA1, 0x04, 0x83, 0x69, 0xEF, 0xA4, + 0x3E, 0xCC, 0x94, 0xD8, 0xBA, 0x0E, 0xC7, 0x0C, + 0x40, 0x92, 0xB0, 0xAC, 0x84, 0xDC, 0x00, 0x70 + }, + { + 0xED, 0xC0, 0x4A, 0xEF, 0x5D, 0x10, 0xB7, 0x7A, + 0x90, 0x3F, 0x30, 0xA2, 0x39, 0x3F, 0xFE, 0x3A, + 0x99, 0x02, 0x41, 0x53, 0x2D, 0x61, 0xD1, 0x6A, + 0xD7, 0x64, 0x36, 0xDD, 0x6D, 0x63, 0x7B, 0x36, + 0x39, 0xC3, 0x3D, 0x01, 0xEE, 0x16, 0x9E, 0xF0, + 0x9A, 0xDB, 0x8D, 0x64, 0xB3, 0x96, 0x63, 0x2E, + 0xC1, 0x2B, 0x14, 0xA9, 0xFA, 0x89, 0x8C, 0x6B, + 0x1A, 0xA6, 0x43, 0x26, 0xE4, 0xCC, 0x27, 0x50 + }, + { + 0xEC, 0x3E, 0xD1, 0x64, 0x60, 0xC4, 0xBC, 0xF8, + 0x1C, 0xAD, 0xCF, 0x12, 0x54, 0xA1, 0x62, 0x1D, + 0xC8, 0xA7, 0x08, 0xF2, 0x46, 0x5D, 0xCF, 0xBF, + 0xB0, 0x17, 0xB1, 0xD4, 0xF6, 0x72, 0xC1, 0x63, + 0x0D, 0xAE, 0xDB, 0x8A, 0x75, 0xD2, 0xF3, 0xD3, + 0x70, 0x46, 0x8A, 0x85, 0xAA, 0xD1, 0xD7, 0xC8, + 0x8E, 0x93, 0x65, 0x9B, 0xD8, 0x99, 0x19, 0xFE, + 0xB3, 0xB5, 0xDF, 0xC4, 0xC9, 0x74, 0x10, 0x82 + }, + { + 0xA9, 0x28, 0x62, 0x3F, 0x22, 0xF7, 0xB8, 0x19, + 0xE5, 0x9D, 0x5B, 0x98, 0x69, 0x44, 0x7B, 0x84, + 0x2B, 0xF0, 0x4C, 0xC6, 0x8F, 0xC8, 0xAA, 0x13, + 0x14, 0x28, 0x9F, 0x39, 0x4C, 0xEF, 0x5D, 0xE7, + 0xF3, 0x92, 0x77, 0x61, 0xC0, 0xBB, 0x3F, 0x67, + 0x40, 0xEC, 0x65, 0x33, 0x79, 0xC1, 0x46, 0xA4, + 0xB8, 0x93, 0x27, 0x31, 0xC1, 0x02, 0xE7, 0x41, + 0xC3, 0xE2, 0x18, 0xD0, 0xE2, 0x80, 0xC6, 0xCF + }, + { + 0xE1, 0xD3, 0x0D, 0xBD, 0xE3, 0xA8, 0x15, 0x22, + 0x09, 0xCD, 0x58, 0xB4, 0x36, 0x40, 0x1D, 0x1D, + 0x5E, 0x23, 0xF7, 0x87, 0x0C, 0xD9, 0x36, 0xE3, + 0x15, 0xFB, 0x94, 0x71, 0xF3, 0xA5, 0xFA, 0xFC, + 0xC5, 0xA7, 0xBE, 0x1A, 0xC3, 0x07, 0xF3, 0x83, + 0x2E, 0xB5, 0xA1, 0xCA, 0x34, 0x63, 0xDF, 0x55, + 0x3C, 0xFC, 0xEB, 0x44, 0xED, 0xAA, 0x8A, 0xA8, + 0x7A, 0xF4, 0x8F, 0x76, 0xC3, 0xEA, 0x97, 0xB1 + }, + { + 0xEF, 0xD5, 0x21, 0x7D, 0x6B, 0x0C, 0x03, 0xCD, + 0xFC, 0x04, 0xEB, 0x8F, 0x43, 0x1D, 0x85, 0x1C, + 0x63, 0x72, 0x63, 0x98, 0xDB, 0x48, 0x4B, 0x52, + 0x09, 0x5C, 0x6E, 0x6D, 0x9B, 0x4F, 0x15, 0xAE, + 0xFD, 0x1D, 0xE0, 0xBC, 0xF3, 0xD6, 0x99, 0xBC, + 0xA4, 0xC7, 0x26, 0xD1, 0xE7, 0xEA, 0x27, 0x57, + 0x21, 0x04, 0xE9, 0x2C, 0xCB, 0x12, 0x16, 0x52, + 0xE4, 0xEF, 0x2B, 0xCE, 0xEE, 0xB4, 0x42, 0x63 + }, + { + 0x85, 0x84, 0x50, 0x70, 0x73, 0x92, 0xF2, 0x95, + 0x2D, 0xEC, 0x9E, 0x4E, 0x1B, 0x93, 0x8C, 0x01, + 0x95, 0xF3, 0x57, 0xE6, 0xFF, 0x22, 0xFE, 0xB2, + 0xB7, 0x00, 0xFA, 0x7A, 0xE9, 0x7C, 0x9D, 0x77, + 0x10, 0x2D, 0x8A, 0xD8, 0x37, 0xF3, 0x45, 0x09, + 0x60, 0xEC, 0x3F, 0xE5, 0x44, 0xE2, 0xEB, 0xF2, + 0x01, 0xD8, 0xD0, 0x57, 0x3F, 0x66, 0xA3, 0x6B, + 0x48, 0x60, 0x04, 0x01, 0x2A, 0xE9, 0x76, 0x9D + }, + { + 0xA8, 0x05, 0xD9, 0x28, 0x35, 0x30, 0xFB, 0x81, + 0x58, 0x40, 0x05, 0x9C, 0xB3, 0xFD, 0x80, 0x00, + 0xC4, 0x49, 0xEB, 0xB9, 0x57, 0x4E, 0xEF, 0xF2, + 0x87, 0x5B, 0x6A, 0xFD, 0x27, 0xF4, 0x7A, 0x0E, + 0x16, 0xE2, 0xAC, 0xB1, 0x40, 0xCB, 0xB5, 0xBE, + 0x83, 0xB3, 0x77, 0x98, 0xFA, 0x48, 0x52, 0x8A, + 0x3E, 0xC6, 0x8F, 0x5A, 0xC5, 0x89, 0x23, 0xBA, + 0x6C, 0xB5, 0x77, 0x7F, 0x3D, 0x21, 0xA9, 0x73 + }, + { + 0x80, 0xC3, 0x3B, 0xA1, 0x4F, 0x45, 0xA1, 0x21, + 0x8F, 0x2C, 0xBC, 0x36, 0x74, 0xA9, 0xA0, 0x36, + 0xA3, 0xAB, 0x25, 0xB9, 0x98, 0x59, 0x83, 0x07, + 0xD1, 0x44, 0xB3, 0xA7, 0x4C, 0x40, 0x0A, 0x0E, + 0xF1, 0xF7, 0x9F, 0x2C, 0xBB, 0xB3, 0xA3, 0xDE, + 0x10, 0x52, 0xED, 0x70, 0x79, 0xA3, 0x17, 0xA0, + 0xDD, 0x4E, 0x1C, 0x35, 0xD7, 0x5A, 0xDE, 0xE5, + 0x93, 0x49, 0x78, 0x33, 0x96, 0x6E, 0x28, 0xC8 + }, + { + 0x02, 0x0D, 0x66, 0xB6, 0x52, 0xB7, 0x8D, 0xBE, + 0x5E, 0x2C, 0x25, 0x6A, 0x9B, 0x89, 0x81, 0x75, + 0xF1, 0x86, 0x1D, 0xFF, 0x03, 0xF3, 0x6D, 0xFE, + 0x1A, 0x04, 0xF3, 0xDD, 0xC9, 0x72, 0xB3, 0x9B, + 0x5F, 0xB3, 0xB5, 0xBD, 0x1C, 0x4C, 0xE8, 0x5A, + 0x80, 0x14, 0x2D, 0x0C, 0xFF, 0x30, 0x4D, 0x59, + 0xF3, 0x99, 0x0B, 0x3A, 0x01, 0x39, 0x9B, 0xC1, + 0xA0, 0x87, 0x14, 0x62, 0x27, 0x75, 0x88, 0x2A + }, + { + 0xE3, 0xFC, 0xE7, 0x4D, 0x5E, 0xEB, 0xD8, 0x53, + 0xF6, 0xA2, 0x4D, 0x9E, 0x13, 0x40, 0xBD, 0xCA, + 0xE2, 0xE8, 0xD6, 0xD8, 0x7A, 0xEC, 0x03, 0x23, + 0x99, 0xA1, 0xDC, 0xDB, 0x15, 0xF3, 0xD2, 0x2B, + 0xFC, 0x8B, 0xA0, 0x13, 0xBB, 0x5C, 0x35, 0xB3, + 0x0F, 0x09, 0x63, 0x6B, 0xE5, 0x9F, 0x5B, 0xEE, + 0xA0, 0xE6, 0x30, 0x8C, 0xE8, 0x22, 0xD6, 0xA7, + 0xCD, 0x97, 0xA4, 0xB9, 0x3A, 0x10, 0xF2, 0x89 + }, + { + 0x22, 0x3E, 0xB1, 0x96, 0x81, 0xA3, 0x9C, 0x26, + 0xA1, 0xE9, 0x82, 0x84, 0x88, 0x24, 0x3A, 0xC3, + 0x39, 0x5C, 0x88, 0xCB, 0xFC, 0xA4, 0xA5, 0xB5, + 0x75, 0xBB, 0x2A, 0x87, 0xC3, 0x34, 0xB5, 0x88, + 0x81, 0xFD, 0x46, 0x24, 0xD9, 0x6C, 0x1D, 0x65, + 0xE3, 0x4A, 0xD1, 0xBE, 0xE6, 0x77, 0xD2, 0x32, + 0x7D, 0xEA, 0x6A, 0x42, 0xE7, 0xEB, 0xCD, 0xD8, + 0x96, 0x92, 0xF6, 0xEA, 0xA7, 0x15, 0x8B, 0x79 + }, + { + 0x6C, 0x4A, 0xB7, 0x41, 0xAA, 0x9B, 0xE3, 0x58, + 0x1C, 0x98, 0x52, 0xE2, 0xF6, 0x7B, 0x34, 0xB5, + 0x36, 0x8A, 0x31, 0xC7, 0x4C, 0xA8, 0x5A, 0x8A, + 0x5D, 0x44, 0xEF, 0x9E, 0xA6, 0x8B, 0x6B, 0xC6, + 0x73, 0xF3, 0x3F, 0x70, 0xF3, 0x3A, 0xE8, 0xE0, + 0xF4, 0xF7, 0xE3, 0xCE, 0x28, 0x18, 0x9A, 0x4A, + 0x83, 0xD8, 0x2F, 0x63, 0x68, 0x2C, 0xC4, 0xE0, + 0xA9, 0x6E, 0x35, 0x9B, 0xC7, 0xFB, 0xE9, 0x0B + }, + { + 0xB6, 0x81, 0x27, 0xFB, 0x85, 0x5F, 0x54, 0x5D, + 0x44, 0x61, 0x3C, 0x7A, 0xA2, 0xA2, 0xFE, 0x6A, + 0x3B, 0xD5, 0x6D, 0x89, 0x4C, 0xC2, 0x8F, 0x28, + 0x8A, 0xFB, 0x53, 0x1A, 0x9C, 0x3A, 0x83, 0x4E, + 0x41, 0xA9, 0xC2, 0x49, 0xB2, 0xEF, 0x57, 0x32, + 0x9E, 0x1E, 0x35, 0xA8, 0x37, 0x03, 0xD1, 0xAC, + 0x8C, 0xC8, 0xF0, 0xA4, 0x9D, 0x8B, 0x75, 0x79, + 0x40, 0x14, 0xEE, 0xD5, 0xB0, 0xD2, 0x9B, 0x09 + }, + { + 0xA3, 0xC7, 0x4B, 0xF0, 0xB3, 0xBB, 0xF2, 0xA2, + 0x47, 0xB0, 0x97, 0x47, 0x9C, 0x79, 0x0F, 0x1B, + 0x80, 0x7F, 0x82, 0xF9, 0x5F, 0x11, 0xDC, 0xB0, + 0xCE, 0xC2, 0x28, 0xCD, 0x5A, 0x91, 0xDB, 0x10, + 0xB2, 0xA0, 0x2A, 0xCD, 0xE4, 0xEA, 0xA2, 0x0F, + 0x28, 0xF5, 0x65, 0x71, 0x79, 0xFA, 0xB8, 0x43, + 0x28, 0x26, 0xDA, 0x35, 0x94, 0xA8, 0x1B, 0x73, + 0x6D, 0xFA, 0xB7, 0x6E, 0xAD, 0xEA, 0xB3, 0xD4 + }, + { + 0x56, 0x50, 0x97, 0xDA, 0xBB, 0xA5, 0xC6, 0x5E, + 0x2A, 0xBC, 0xDE, 0xA6, 0x94, 0xF2, 0xDB, 0x02, + 0x1F, 0xB3, 0x0F, 0xD4, 0xFF, 0x37, 0x1C, 0x23, + 0x0A, 0xA1, 0x2C, 0x51, 0x8B, 0x85, 0x06, 0x46, + 0x94, 0x19, 0x27, 0x1B, 0x07, 0xEA, 0x39, 0x41, + 0xFB, 0x13, 0x0B, 0xE1, 0x0F, 0xB3, 0xA4, 0x58, + 0x00, 0xD3, 0xB4, 0x5C, 0x79, 0x14, 0x6A, 0x30, + 0xD5, 0xB5, 0x75, 0x2C, 0xE6, 0x26, 0x7E, 0xE3 + }, + { + 0x92, 0x01, 0x0E, 0x49, 0xD3, 0x1B, 0xEB, 0xD4, + 0x31, 0x71, 0x43, 0x19, 0x0F, 0x63, 0xA3, 0x5B, + 0x23, 0x4E, 0xE2, 0xA3, 0x8A, 0x33, 0x3C, 0xF7, + 0x47, 0x47, 0x1F, 0x36, 0x8D, 0x45, 0xD7, 0x9D, + 0x62, 0x39, 0xCA, 0x81, 0x1B, 0x83, 0x15, 0xFB, + 0xD0, 0xAD, 0x42, 0x98, 0xB1, 0xD7, 0xE1, 0xF4, + 0x6F, 0x5E, 0x4F, 0x28, 0x1B, 0x6A, 0x4D, 0xC2, + 0x52, 0x18, 0xBE, 0x44, 0xF8, 0xF6, 0x60, 0x76 + }, + { + 0x69, 0x75, 0x25, 0xEF, 0xD4, 0x37, 0x11, 0xE1, + 0x5B, 0x72, 0x68, 0x19, 0x97, 0xBA, 0x84, 0xDF, + 0x52, 0xD1, 0x4E, 0xA1, 0x03, 0x9B, 0xB6, 0xBE, + 0x76, 0x29, 0x32, 0xB0, 0xC3, 0xFA, 0xC6, 0x61, + 0x0E, 0x80, 0xA9, 0x47, 0x9C, 0x3C, 0x5B, 0x8B, + 0x25, 0x39, 0x46, 0xF7, 0x1C, 0x1F, 0xCA, 0x7F, + 0x7C, 0x44, 0xEA, 0xB5, 0x84, 0x57, 0x5E, 0x07, + 0x1E, 0xEC, 0x4C, 0x3E, 0x39, 0x04, 0xDD, 0x1B + }, + { + 0x8F, 0x04, 0xFE, 0x51, 0x70, 0xED, 0x30, 0x6E, + 0x76, 0x6B, 0x33, 0x67, 0xB5, 0x70, 0x99, 0x6A, + 0x34, 0xC0, 0x8D, 0xC1, 0x41, 0x9C, 0xFF, 0x22, + 0x38, 0xAE, 0x74, 0x7F, 0x01, 0x8E, 0x88, 0xB2, + 0xA7, 0x24, 0x26, 0xAE, 0x70, 0xC1, 0xFB, 0x7D, + 0x8D, 0xE9, 0xDD, 0x0C, 0x7D, 0xE8, 0x4E, 0xED, + 0xD2, 0x7F, 0x3E, 0xA1, 0x16, 0xD8, 0xD2, 0xAE, + 0x02, 0x96, 0xF6, 0xC3, 0xEB, 0x03, 0xEA, 0x08 + }, + { + 0xDC, 0x45, 0x08, 0xCB, 0xE4, 0xB2, 0xE7, 0x72, + 0xCE, 0x43, 0x75, 0xED, 0x07, 0x63, 0x9D, 0x9A, + 0x89, 0x87, 0xC6, 0xE7, 0x8F, 0x17, 0xA5, 0x24, + 0x86, 0xB9, 0x9B, 0x88, 0xEA, 0x0D, 0x8B, 0xFC, + 0xCB, 0x77, 0xD3, 0x89, 0xE2, 0x47, 0x7D, 0xBD, + 0x71, 0x23, 0x21, 0x45, 0x06, 0x30, 0x8C, 0xAF, + 0x41, 0x18, 0x12, 0x12, 0x31, 0x35, 0x49, 0x68, + 0xC8, 0xF7, 0xB5, 0xB9, 0x67, 0xEF, 0x5C, 0x21 + }, + { + 0x68, 0x04, 0xEC, 0x69, 0xBA, 0x6B, 0x55, 0x64, + 0x30, 0x96, 0xA2, 0x50, 0x33, 0x30, 0xC9, 0x6E, + 0x39, 0x89, 0xCD, 0xA9, 0x7C, 0xBC, 0xA9, 0x80, + 0x19, 0xE9, 0x93, 0x4A, 0xCB, 0x51, 0xDB, 0xD0, + 0x9E, 0xB8, 0xD1, 0x76, 0xE8, 0x86, 0x04, 0x70, + 0x3E, 0x56, 0xF1, 0x45, 0x2F, 0xEB, 0xFC, 0x2F, + 0xC2, 0x16, 0xD1, 0x86, 0x8B, 0x31, 0x57, 0x9F, + 0x0B, 0x05, 0xF8, 0x7C, 0x66, 0x83, 0x38, 0x95 + }, + { + 0xD0, 0x89, 0xF7, 0xAB, 0xF2, 0x96, 0xC1, 0x40, + 0x0B, 0xC6, 0x8C, 0x3D, 0x01, 0x81, 0xB9, 0x1D, + 0xC2, 0x07, 0x7F, 0xF6, 0xC8, 0x93, 0xA7, 0x78, + 0x97, 0x75, 0xEE, 0xD2, 0xED, 0x3A, 0xF0, 0xBD, + 0x3F, 0x1B, 0xB7, 0x9B, 0xA4, 0xF7, 0xFB, 0xF2, + 0x97, 0x42, 0xA7, 0x2E, 0x02, 0x50, 0x4C, 0x4E, + 0x1A, 0xB6, 0xC2, 0x95, 0x76, 0xA2, 0x06, 0x22, + 0xE7, 0xA6, 0xCB, 0x87, 0x4D, 0xFD, 0x11, 0xA1 + }, + { + 0xE1, 0x57, 0x70, 0xF5, 0x82, 0xA4, 0xC9, 0x6E, + 0x88, 0x92, 0xBA, 0xF8, 0x98, 0x4C, 0x80, 0xD7, + 0x2B, 0x93, 0x67, 0xEB, 0x2C, 0xDF, 0x62, 0xA5, + 0xC5, 0x56, 0xEE, 0xFE, 0xAB, 0xDD, 0x48, 0xE8, + 0xBE, 0x83, 0x0D, 0xD7, 0x36, 0x8A, 0xB5, 0x11, + 0x87, 0x90, 0x14, 0x8B, 0x45, 0xE3, 0xFF, 0xF4, + 0x76, 0xA7, 0x8D, 0xCF, 0x5C, 0x33, 0x55, 0x63, + 0xB2, 0x66, 0xB8, 0x4B, 0x6E, 0x55, 0xD9, 0x44 + }, + { + 0x10, 0xDB, 0xBC, 0xC2, 0x0A, 0xEF, 0x80, 0xBC, + 0xCA, 0x51, 0xA9, 0x7C, 0xF1, 0xBC, 0x05, 0x88, + 0x61, 0x96, 0xA9, 0x10, 0xAD, 0x12, 0x24, 0x01, + 0x1A, 0x1E, 0x8D, 0x46, 0x18, 0xF7, 0x18, 0xB7, + 0xAF, 0x78, 0xB4, 0xC9, 0xEF, 0xB3, 0xB1, 0xBC, + 0x91, 0x8C, 0x49, 0xCC, 0xD1, 0x1C, 0x62, 0xB7, + 0xFB, 0xC4, 0x3A, 0xC7, 0xEA, 0x32, 0x4E, 0xE4, + 0xDA, 0x12, 0xCB, 0x91, 0x03, 0x70, 0x3F, 0x40 + }, + { + 0xEC, 0xE4, 0xC5, 0xDE, 0xB1, 0xF8, 0x46, 0x87, + 0x4D, 0xCE, 0x05, 0x3E, 0x91, 0x4A, 0x5C, 0x2F, + 0x5B, 0xEF, 0x80, 0xFB, 0x35, 0xA3, 0xA5, 0xDB, + 0xAB, 0x61, 0x51, 0xBC, 0x21, 0x13, 0xB2, 0xD9, + 0x6B, 0xBD, 0x6D, 0xED, 0xF3, 0x53, 0x1C, 0xE9, + 0xCE, 0x91, 0x2F, 0x4F, 0xBD, 0x32, 0xDD, 0xFA, + 0xD5, 0xAD, 0x9B, 0x32, 0x31, 0x42, 0x41, 0xA0, + 0xE1, 0x6F, 0xA9, 0xE8, 0x9D, 0x5F, 0xCA, 0x89 + }, + { + 0x94, 0x78, 0x72, 0x88, 0x04, 0x21, 0x8A, 0x6A, + 0xA1, 0x0E, 0xD1, 0xCB, 0x27, 0x78, 0x9D, 0xA8, + 0xF0, 0xD1, 0x6F, 0xD0, 0x9C, 0x64, 0x1D, 0x7C, + 0xC4, 0x62, 0x1E, 0x9E, 0xF9, 0x8D, 0xF7, 0xC4, + 0x98, 0xED, 0x73, 0x7A, 0x17, 0x04, 0x94, 0xFE, + 0xD8, 0xD8, 0x94, 0xE1, 0x54, 0x10, 0x80, 0x54, + 0x7F, 0xC1, 0x19, 0xDF, 0xFA, 0x60, 0x5F, 0x2A, + 0x08, 0x1A, 0x62, 0x5F, 0x46, 0x67, 0x5C, 0xB1 + }, + { + 0x33, 0x60, 0x7E, 0xC3, 0xCE, 0x90, 0xB6, 0x9E, + 0xFD, 0x47, 0x8A, 0x9A, 0xDD, 0xAF, 0x5E, 0x13, + 0xA8, 0xCB, 0x74, 0x43, 0x41, 0x86, 0x28, 0xA3, + 0x28, 0x69, 0xC5, 0x2D, 0x0A, 0xCF, 0x23, 0xFD, + 0x3D, 0xC6, 0xDA, 0xD6, 0x4A, 0xE5, 0x32, 0xAC, + 0x18, 0x19, 0x73, 0xD7, 0x9F, 0x7C, 0x52, 0xCB, + 0x01, 0xBD, 0xA7, 0xA4, 0xA5, 0x28, 0x4B, 0x18, + 0x9B, 0x3F, 0x23, 0x47, 0x43, 0xFF, 0x9B, 0x06 + }, + { + 0x8D, 0xD0, 0x00, 0xED, 0xAB, 0xF2, 0xA9, 0x66, + 0x61, 0x63, 0x85, 0x8E, 0x28, 0x27, 0xAE, 0x4A, + 0x3F, 0x3E, 0x34, 0x7F, 0xAB, 0x60, 0x98, 0xB4, + 0x19, 0x6B, 0x36, 0xA5, 0xE3, 0x95, 0xFE, 0x83, + 0x38, 0xA5, 0xEB, 0x0D, 0xB3, 0x63, 0x49, 0x21, + 0xA8, 0xDB, 0xC4, 0x71, 0x6D, 0x3D, 0xA1, 0xBE, + 0xA6, 0xCF, 0xB6, 0x95, 0x07, 0xB3, 0xD2, 0x48, + 0x3C, 0x2E, 0x07, 0x3E, 0x87, 0x16, 0x8D, 0x50 + }, + { + 0xC7, 0x0E, 0x9F, 0x7C, 0xE4, 0x26, 0x87, 0xD8, + 0x45, 0x88, 0x32, 0xF1, 0xCA, 0x98, 0x46, 0x23, + 0xC6, 0xE7, 0x65, 0x82, 0xB9, 0x82, 0x8E, 0x24, + 0x7B, 0x10, 0x59, 0x10, 0x42, 0xA7, 0x05, 0xBF, + 0xBA, 0x77, 0x79, 0x00, 0xE1, 0x76, 0x96, 0xD8, + 0xC7, 0xE3, 0x80, 0xFD, 0x91, 0x85, 0x0F, 0x34, + 0xF6, 0x03, 0xDD, 0xF4, 0x0F, 0x57, 0x5F, 0x36, + 0x6E, 0xFF, 0xE3, 0xCF, 0x0E, 0xE7, 0x5E, 0x75 + }, + { + 0xA9, 0xAF, 0x2F, 0x63, 0x3E, 0xF3, 0x07, 0x13, + 0x2D, 0x00, 0xCC, 0xA7, 0x87, 0x0D, 0x0D, 0xBA, + 0x69, 0x40, 0x12, 0x89, 0x07, 0x6F, 0x0F, 0xAA, + 0x97, 0xC5, 0x05, 0x1D, 0xFA, 0xB7, 0xD0, 0x7C, + 0x6F, 0x29, 0x39, 0x1A, 0x3E, 0xAA, 0xAA, 0x22, + 0x99, 0xDA, 0x23, 0x23, 0x08, 0x01, 0x69, 0x50, + 0xBF, 0xE8, 0xBA, 0xE3, 0xFC, 0x50, 0xF4, 0xCF, + 0x15, 0x93, 0x3B, 0x36, 0x00, 0xA1, 0x62, 0x40 + }, + { + 0xD8, 0xC6, 0x6D, 0x30, 0x4B, 0x27, 0xB9, 0x27, + 0xD4, 0xA8, 0x69, 0x68, 0x01, 0x8B, 0xC0, 0x25, + 0xBA, 0x1C, 0x26, 0x70, 0x94, 0x95, 0x6A, 0xF0, + 0x55, 0x51, 0x46, 0xD3, 0x63, 0xDE, 0xFE, 0x26, + 0x69, 0x2D, 0xD5, 0x4F, 0x5A, 0x17, 0x5D, 0x83, + 0x21, 0xF8, 0x92, 0x92, 0x68, 0xC6, 0x74, 0x7F, + 0xDC, 0x75, 0x64, 0x56, 0x50, 0x21, 0x12, 0x83, + 0xC5, 0x73, 0x66, 0xA9, 0x2E, 0x15, 0x04, 0x27 + }, + { + 0xDA, 0x55, 0x20, 0x51, 0x12, 0x6A, 0x30, 0xE2, + 0x57, 0xDD, 0xAC, 0x0C, 0x9A, 0x62, 0xCC, 0x73, + 0x9D, 0x61, 0x45, 0x10, 0x90, 0xF5, 0x95, 0xA3, + 0x3D, 0x21, 0x9D, 0x2A, 0x2F, 0xC6, 0x6E, 0x55, + 0xE5, 0xC4, 0x50, 0xB6, 0x91, 0x3C, 0x8A, 0x0E, + 0xC0, 0xB9, 0x7E, 0x32, 0xA8, 0x9F, 0xCF, 0x46, + 0x77, 0xE8, 0xDE, 0xA3, 0xFE, 0x3C, 0x62, 0x6D, + 0x7F, 0x04, 0x96, 0x80, 0xFE, 0x9B, 0xF0, 0xB3 + }, + { + 0xC7, 0xD2, 0xC0, 0xEB, 0xCA, 0x83, 0x56, 0x30, + 0x25, 0x33, 0xE2, 0x7E, 0xB5, 0x8F, 0x59, 0xB6, + 0xBB, 0xD3, 0xDF, 0x6F, 0xDB, 0x10, 0x94, 0xC3, + 0xF7, 0x38, 0xEC, 0x40, 0xE4, 0xEB, 0x5B, 0x55, + 0x73, 0x82, 0xFD, 0xDD, 0xB1, 0x3E, 0x0A, 0xED, + 0x5C, 0x49, 0xB4, 0x8A, 0x2D, 0x45, 0x29, 0xE5, + 0xF1, 0x6D, 0xC7, 0x33, 0x64, 0xE4, 0x30, 0xDA, + 0x07, 0x66, 0x84, 0x31, 0xB8, 0x6D, 0xB3, 0xC7 + }, + { + 0x9B, 0xDC, 0x4A, 0x48, 0x73, 0x80, 0xE6, 0xE8, + 0xEE, 0x66, 0x01, 0xC5, 0x9F, 0x04, 0xED, 0x21, + 0x47, 0x58, 0xBC, 0x00, 0xF7, 0xEF, 0xF4, 0xC4, + 0xCF, 0xC0, 0xD8, 0x24, 0xF7, 0x3D, 0xA9, 0x8B, + 0xC2, 0xA7, 0x8F, 0x4D, 0xB5, 0x3D, 0x5A, 0xA7, + 0x75, 0xD2, 0x70, 0x8C, 0xEE, 0xE3, 0xA0, 0x2B, + 0x97, 0x00, 0x41, 0xBF, 0xC5, 0x80, 0x1E, 0x4A, + 0x71, 0x5A, 0x7C, 0x64, 0xA0, 0x39, 0x42, 0xEB + }, + { + 0xDB, 0x11, 0xAA, 0x3B, 0x01, 0x80, 0xE6, 0xB3, + 0xB0, 0xDB, 0xF3, 0xED, 0x77, 0xA2, 0x22, 0x30, + 0xD3, 0x32, 0x5F, 0x29, 0x46, 0xFF, 0x2A, 0x0F, + 0x15, 0xED, 0xD7, 0x87, 0xCB, 0x9A, 0x56, 0xE5, + 0x85, 0xAA, 0xF7, 0x74, 0xDC, 0x90, 0x84, 0xDE, + 0xA6, 0x1C, 0x7B, 0x3D, 0x3E, 0xBC, 0xA9, 0xCB, + 0xD2, 0x64, 0xDD, 0x1A, 0x72, 0xB9, 0x1C, 0xCA, + 0xC5, 0xB9, 0xD8, 0x20, 0x95, 0x3B, 0x90, 0x9C + }, + { + 0x20, 0xDD, 0x26, 0x41, 0xE5, 0xA9, 0xC9, 0xBD, + 0x60, 0x0C, 0x11, 0xAA, 0x2D, 0xA1, 0xE1, 0x3B, + 0x44, 0xDC, 0xDA, 0xFF, 0xED, 0x21, 0xDE, 0x85, + 0xE7, 0x05, 0x70, 0xC0, 0x23, 0xC0, 0x45, 0xD7, + 0x7C, 0xA3, 0x9F, 0x66, 0x51, 0xE1, 0x05, 0xEA, + 0x70, 0xE7, 0x77, 0x34, 0x75, 0xA5, 0x76, 0x10, + 0xD6, 0x01, 0xB5, 0x9F, 0x93, 0x19, 0x72, 0xBC, + 0x38, 0xEC, 0xA3, 0xA9, 0x5E, 0x33, 0x21, 0x41 + }, + { + 0xF9, 0xEC, 0xC4, 0xC3, 0x77, 0x83, 0x90, 0x3D, + 0x62, 0xE4, 0xEB, 0x4C, 0x02, 0x61, 0x1A, 0x8B, + 0x73, 0x67, 0x52, 0xE0, 0x81, 0x7C, 0x68, 0xA3, + 0xED, 0x5D, 0x80, 0x26, 0xA1, 0x73, 0xCE, 0x19, + 0x25, 0x91, 0x25, 0x4B, 0x61, 0x25, 0xC0, 0x12, + 0xFC, 0x14, 0x9A, 0xFD, 0x2F, 0xCF, 0x77, 0x08, + 0xD3, 0x0C, 0x52, 0x51, 0x37, 0x9C, 0xFF, 0xAF, + 0x1A, 0x5C, 0x4F, 0x15, 0xEA, 0x33, 0x8A, 0x98 + }, + { + 0x28, 0xB3, 0xBD, 0xDC, 0x02, 0xB8, 0xC6, 0x4F, + 0x99, 0xD6, 0xBD, 0xE2, 0xCA, 0xFA, 0xFD, 0x93, + 0x9C, 0x2E, 0x02, 0xB2, 0xF6, 0xB9, 0x52, 0x67, + 0xCF, 0xB2, 0xCE, 0x3B, 0xD2, 0xD9, 0x35, 0xE4, + 0x73, 0x5E, 0x5D, 0xFA, 0xC9, 0xC9, 0x2D, 0x76, + 0x64, 0x17, 0x84, 0x97, 0x4C, 0xBF, 0x09, 0xC3, + 0x9A, 0x49, 0xCB, 0x4F, 0xBF, 0x2A, 0xE6, 0x91, + 0xB8, 0x7C, 0xC4, 0x5F, 0x19, 0xE2, 0x2E, 0xB8 + }, + { + 0xEA, 0x90, 0xD6, 0x41, 0x53, 0x35, 0x22, 0x05, + 0x83, 0xE4, 0x1D, 0x53, 0x0F, 0x7C, 0x44, 0xBF, + 0x0B, 0x2F, 0xF9, 0xF6, 0x3D, 0xAA, 0xD0, 0x74, + 0x92, 0x74, 0x6E, 0xEC, 0xBC, 0x79, 0xB4, 0x31, + 0xE9, 0x37, 0x63, 0xB7, 0x48, 0x41, 0xA4, 0x74, + 0xAA, 0xF1, 0x5D, 0x79, 0x53, 0x90, 0x59, 0xAB, + 0x06, 0x9A, 0x97, 0x12, 0xDA, 0xB7, 0xE2, 0x80, + 0xDE, 0xB1, 0x4A, 0xF9, 0x21, 0xA9, 0x14, 0x9F + }, + { + 0x19, 0xBC, 0xFF, 0x95, 0xE5, 0xD5, 0x4C, 0xD2, + 0x62, 0x4F, 0xC4, 0x5D, 0x41, 0xED, 0x9C, 0xBA, + 0xF8, 0x23, 0x1C, 0xE8, 0xB2, 0xD6, 0xFF, 0xEE, + 0xB3, 0xF4, 0xBE, 0xA3, 0x5C, 0x40, 0xBE, 0x40, + 0x2B, 0x9C, 0x81, 0x6D, 0x28, 0x60, 0x23, 0xDF, + 0xF7, 0xD0, 0x23, 0x48, 0x48, 0x38, 0x48, 0x52, + 0x82, 0x0D, 0x2B, 0x74, 0x72, 0xD9, 0xE5, 0x13, + 0x4B, 0xBF, 0x44, 0xAE, 0x31, 0xEE, 0xF9, 0x7B + }, + { + 0xAB, 0xC8, 0xCC, 0xAE, 0x8E, 0x8E, 0x6F, 0x85, + 0x9D, 0x6A, 0x4B, 0x8E, 0x68, 0x77, 0xA5, 0x5F, + 0xE0, 0xA6, 0x5B, 0xD0, 0x9F, 0x63, 0xAF, 0xBD, + 0xE3, 0x27, 0x02, 0xF6, 0xAB, 0x34, 0xF1, 0x56, + 0xB2, 0xC6, 0x30, 0xED, 0xA2, 0xBE, 0x34, 0xAE, + 0xC9, 0x64, 0xC0, 0x38, 0xB2, 0x5C, 0xF0, 0x9D, + 0x80, 0x69, 0x20, 0x02, 0xEB, 0x70, 0x44, 0x52, + 0x63, 0xE3, 0x36, 0x06, 0xCD, 0x18, 0x46, 0x70 + }, + { + 0xF0, 0x4B, 0x59, 0x75, 0xE8, 0xA7, 0x1E, 0x40, + 0x8A, 0x9A, 0x9E, 0x79, 0xA1, 0xD0, 0x4D, 0x83, + 0x54, 0x5F, 0x3E, 0x4A, 0x8A, 0xEC, 0x11, 0xEA, + 0xED, 0x23, 0xA6, 0x27, 0x17, 0x18, 0xDD, 0xEF, + 0x40, 0xD6, 0x80, 0x5B, 0xEA, 0xF5, 0x50, 0x86, + 0xBD, 0xC3, 0xE8, 0x72, 0xA1, 0x0F, 0x03, 0x63, + 0xD3, 0x6F, 0x99, 0x2B, 0x99, 0xCC, 0x69, 0x1A, + 0xEF, 0x90, 0x74, 0xF2, 0x13, 0x4E, 0x85, 0x4D + }, + { + 0xEE, 0x18, 0x8D, 0x38, 0x19, 0xF3, 0x39, 0xB1, + 0x94, 0xA9, 0x74, 0xCE, 0x53, 0x1E, 0x4A, 0xE7, + 0x03, 0x98, 0x1D, 0x2F, 0xA6, 0x3F, 0xA9, 0xD4, + 0x82, 0x5B, 0x34, 0x4D, 0x1B, 0x33, 0x9E, 0xF3, + 0x4F, 0x28, 0xE1, 0xA5, 0xFD, 0xDB, 0x0E, 0xEC, + 0x2C, 0x42, 0x45, 0xD1, 0x79, 0x83, 0x28, 0xE0, + 0x56, 0x83, 0x41, 0x77, 0xF5, 0x38, 0xD6, 0xBD, + 0x74, 0xA3, 0xFB, 0x65, 0x4E, 0xF7, 0x61, 0x78 + }, + { + 0x86, 0x47, 0xEB, 0x32, 0xBD, 0x29, 0x25, 0xCA, + 0x26, 0x4B, 0x19, 0x04, 0xCD, 0xBC, 0xB1, 0xCF, + 0xF8, 0x82, 0x3B, 0x36, 0x11, 0xC6, 0x3E, 0xBE, + 0x24, 0x15, 0xF5, 0xA3, 0x11, 0x5A, 0xA4, 0x7D, + 0x44, 0xE9, 0x06, 0x46, 0x41, 0xFD, 0xFD, 0x09, + 0x92, 0x79, 0xCC, 0x21, 0x0A, 0x75, 0x06, 0x17, + 0xD9, 0x80, 0x07, 0x43, 0x66, 0xC4, 0x4D, 0x53, + 0x41, 0xFA, 0x18, 0xEE, 0x56, 0xBC, 0x00, 0x55 + }, + { + 0x4D, 0x64, 0x44, 0x2D, 0x14, 0xD4, 0x62, 0xEA, + 0xE8, 0x21, 0x8A, 0x9B, 0x5E, 0xC4, 0xAD, 0xB4, + 0xAF, 0x81, 0x96, 0xDA, 0x32, 0x05, 0x1D, 0x4A, + 0xC7, 0xB6, 0x3A, 0x17, 0x25, 0x29, 0x42, 0xA1, + 0xAE, 0x64, 0x84, 0x9E, 0xE5, 0xE3, 0xF9, 0x47, + 0x4C, 0xEC, 0x26, 0x2B, 0xBE, 0xF6, 0x66, 0xC6, + 0x99, 0xD8, 0x40, 0xD4, 0xD9, 0x92, 0xEC, 0xA7, + 0xD0, 0xB2, 0xD9, 0x1C, 0xBC, 0x00, 0x30, 0xD1 + }, + { + 0x82, 0xC6, 0xC7, 0xC6, 0x23, 0x62, 0x15, 0xB6, + 0x71, 0xFB, 0x17, 0x54, 0x8B, 0x7F, 0xBF, 0x10, + 0x92, 0xF4, 0xA7, 0x39, 0xDF, 0x9F, 0x9D, 0xBE, + 0x97, 0x7F, 0x42, 0xF4, 0xA6, 0x61, 0xC7, 0x4B, + 0x82, 0x6F, 0x1B, 0x19, 0xF7, 0xB3, 0x98, 0x5D, + 0xE3, 0x0C, 0xA6, 0x87, 0x28, 0x39, 0x92, 0xC0, + 0x48, 0x4B, 0x94, 0x6F, 0x36, 0x16, 0x46, 0x0F, + 0x8C, 0x5D, 0xBE, 0xB5, 0x71, 0x16, 0x64, 0xD5 + }, + { + 0xBA, 0x11, 0x5F, 0xE6, 0x71, 0x2D, 0xEB, 0x3B, + 0x25, 0xBE, 0x94, 0xAE, 0x5E, 0xE4, 0x5D, 0x5A, + 0xBE, 0xE7, 0x91, 0xF4, 0x3E, 0x55, 0xEF, 0x22, + 0xF5, 0x57, 0x0F, 0x0A, 0x6D, 0x41, 0x42, 0x5A, + 0x3B, 0x8E, 0x18, 0x9C, 0xC8, 0x9A, 0xF9, 0xED, + 0x57, 0xF0, 0x35, 0xF3, 0x51, 0xA9, 0x09, 0x83, + 0x57, 0xE6, 0xF1, 0x8C, 0xAC, 0xB0, 0xDB, 0x08, + 0xEC, 0x65, 0xB7, 0x87, 0x5E, 0xC3, 0x7F, 0x1A + }, + { + 0xBE, 0xDD, 0x4C, 0x00, 0x05, 0x59, 0x47, 0xED, + 0x37, 0x38, 0x2C, 0x0E, 0xCF, 0x85, 0x4C, 0x86, + 0xFD, 0x0D, 0x95, 0x45, 0xE6, 0x4E, 0xF7, 0xEC, + 0x70, 0xAB, 0xB6, 0xA1, 0x1A, 0xA6, 0xA5, 0x43, + 0x4A, 0xC6, 0x1A, 0xEC, 0xAD, 0x5F, 0xA0, 0xA9, + 0x20, 0x9C, 0x3A, 0x34, 0x7F, 0xBC, 0xF1, 0x08, + 0x4D, 0x6D, 0xDC, 0xA5, 0xD0, 0x50, 0x5E, 0xEF, + 0xA2, 0x48, 0xDD, 0x85, 0xBB, 0x93, 0x40, 0x94 + }, + { + 0x02, 0xA5, 0xC3, 0xF8, 0xAB, 0x85, 0xE0, 0x3C, + 0x4D, 0x44, 0xF9, 0x8D, 0xFD, 0x94, 0x11, 0xDE, + 0x9D, 0x47, 0x82, 0x01, 0x57, 0x59, 0xCB, 0xF2, + 0x88, 0xF5, 0x36, 0x9E, 0x25, 0x22, 0xC7, 0x15, + 0x40, 0x29, 0x01, 0x69, 0x27, 0x16, 0xA1, 0x39, + 0xDF, 0x18, 0x31, 0x47, 0xB3, 0xE0, 0xA4, 0x70, + 0x2E, 0xB4, 0x4F, 0x9B, 0xD4, 0x86, 0x46, 0xC0, + 0x5D, 0x90, 0x76, 0x74, 0xAA, 0xA3, 0x7C, 0x5D + }, + { + 0xBD, 0xBC, 0x9C, 0xF9, 0xFC, 0x40, 0x30, 0x03, + 0x09, 0x35, 0x6A, 0x8D, 0x01, 0xF2, 0xD6, 0xB1, + 0x90, 0x15, 0x3B, 0x33, 0x10, 0x69, 0xA6, 0x8D, + 0x33, 0x83, 0xF8, 0x22, 0xAD, 0xAA, 0x43, 0xA4, + 0x3D, 0xEE, 0xA4, 0xE5, 0xFC, 0xFB, 0x09, 0x91, + 0x82, 0xE3, 0xFA, 0x45, 0xE8, 0x81, 0x26, 0xA3, + 0xFE, 0x4C, 0x10, 0x83, 0x5F, 0x41, 0x8A, 0xC3, + 0x9E, 0xB2, 0x04, 0x84, 0x4D, 0x1B, 0xC7, 0x71 + }, + { + 0xDD, 0xFA, 0x1E, 0xBF, 0x29, 0xFF, 0xFD, 0x9F, + 0x2D, 0xC6, 0x1C, 0x60, 0x53, 0xC6, 0x66, 0x8C, + 0xB8, 0x62, 0x9B, 0x4B, 0xE2, 0xCE, 0xE5, 0x23, + 0xC8, 0x92, 0x66, 0x99, 0x80, 0x45, 0x52, 0x4D, + 0x56, 0xEA, 0x74, 0x21, 0x8D, 0x3A, 0x0F, 0x54, + 0x1C, 0x02, 0x2C, 0xC1, 0x0A, 0x53, 0xBB, 0x89, + 0x06, 0x4B, 0x6F, 0x60, 0xE3, 0x12, 0x5E, 0x92, + 0x83, 0x4E, 0x93, 0x09, 0x7A, 0xCB, 0x95, 0x09 + }, + { + 0x36, 0x2B, 0xB8, 0xC7, 0xF3, 0xF3, 0xE9, 0x42, + 0xE8, 0x59, 0xE7, 0xE5, 0xAC, 0x1F, 0x1C, 0xB0, + 0x9B, 0x5B, 0x58, 0xD3, 0x3E, 0x27, 0x35, 0x7B, + 0x62, 0x40, 0xC0, 0x70, 0xC1, 0xD3, 0x9D, 0x20, + 0x9A, 0x73, 0xA4, 0x06, 0xCF, 0x7E, 0x4D, 0x3C, + 0x49, 0x46, 0xE5, 0xD6, 0x0E, 0xC5, 0x46, 0x24, + 0xCA, 0xC2, 0xA3, 0xED, 0x2E, 0x9B, 0xB7, 0xA7, + 0x7B, 0x5A, 0x9F, 0x16, 0x74, 0xE3, 0x71, 0x9B + }, + { + 0x64, 0x63, 0x0A, 0xF1, 0x9E, 0x98, 0x93, 0x19, + 0xE5, 0x19, 0x0B, 0x6D, 0x3A, 0x07, 0x81, 0x11, + 0xA5, 0xB4, 0x95, 0x55, 0x2E, 0x26, 0xC1, 0x79, + 0x51, 0xD6, 0x44, 0x7C, 0x96, 0x41, 0x02, 0x04, + 0xD6, 0x13, 0x0F, 0xE0, 0x09, 0x41, 0x61, 0x3B, + 0xEB, 0x1F, 0xE0, 0xC3, 0x68, 0xDF, 0x06, 0x36, + 0xF0, 0x39, 0x8B, 0xB6, 0x17, 0x44, 0x62, 0x6C, + 0xF6, 0x53, 0x9F, 0x8C, 0x48, 0x6C, 0x63, 0x16 + }, + { + 0x3E, 0xE2, 0xC5, 0x88, 0x28, 0x0B, 0xF8, 0xF5, + 0xCD, 0x2A, 0x36, 0x7F, 0xB6, 0xC8, 0x16, 0x07, + 0xE6, 0xA3, 0xD6, 0xE6, 0x5B, 0x2A, 0xB4, 0xE8, + 0x89, 0x4B, 0x56, 0xED, 0x81, 0x79, 0x6D, 0x6E, + 0x05, 0x9F, 0x6D, 0xA1, 0x0B, 0x8B, 0x8D, 0xAA, + 0x0C, 0x44, 0x8D, 0x67, 0x6E, 0x73, 0x33, 0x1E, + 0x72, 0xFC, 0xA5, 0x58, 0xD6, 0x1D, 0x8E, 0x2A, + 0x0B, 0x86, 0xEA, 0x81, 0x7D, 0x58, 0xA8, 0x7F + }, + { + 0x0E, 0x6B, 0xF9, 0xB5, 0x6F, 0xA8, 0xFE, 0x74, + 0xDB, 0x07, 0x73, 0x16, 0x4C, 0x5D, 0x50, 0x2C, + 0x3D, 0x42, 0xE3, 0x3E, 0x97, 0x86, 0xCC, 0xA0, + 0xAE, 0x72, 0xFB, 0x44, 0x13, 0x46, 0x9E, 0xB4, + 0xDC, 0x1E, 0xAE, 0x68, 0xD0, 0x23, 0xA3, 0xA3, + 0xA1, 0x1F, 0x49, 0x51, 0x0A, 0xC0, 0x34, 0x1F, + 0x06, 0xD0, 0x1C, 0xB7, 0x97, 0xD6, 0xF9, 0x6D, + 0xB1, 0x1E, 0x96, 0x0F, 0xB5, 0xC6, 0x84, 0xCB + }, + { + 0xA1, 0xBA, 0xFC, 0x26, 0xC6, 0x2A, 0x6A, 0xA4, + 0x30, 0xD5, 0xDA, 0xCF, 0x3E, 0x0D, 0xDF, 0xA8, + 0xB8, 0xD1, 0x06, 0xF2, 0x6A, 0x64, 0x66, 0x72, + 0xBB, 0x5E, 0xAB, 0x22, 0x47, 0x44, 0xBD, 0x31, + 0x47, 0x96, 0xC7, 0x20, 0x61, 0x23, 0x35, 0x00, + 0xED, 0x06, 0x65, 0x4D, 0x75, 0xC2, 0x9B, 0xF0, + 0x09, 0xDD, 0x79, 0x05, 0xAC, 0xFC, 0x79, 0xB8, + 0x1F, 0x7D, 0xCE, 0x27, 0x90, 0xAE, 0x49, 0xE3 + }, + { + 0x08, 0xCE, 0x39, 0xE7, 0x82, 0x15, 0x50, 0xC0, + 0xA1, 0xBE, 0xF2, 0xCF, 0x0F, 0x9D, 0x05, 0xE6, + 0x6C, 0x00, 0x94, 0xF2, 0x01, 0x14, 0x69, 0xE4, + 0x7F, 0x36, 0x44, 0x51, 0xE3, 0x10, 0x35, 0x66, + 0xB5, 0x4F, 0x52, 0x74, 0xBF, 0x32, 0x11, 0x6F, + 0xA2, 0xA7, 0x31, 0xD3, 0x16, 0x9A, 0xBE, 0x16, + 0x4F, 0x96, 0x88, 0x0D, 0x32, 0x5A, 0x8B, 0x63, + 0x08, 0xE6, 0x31, 0xB1, 0x68, 0xC4, 0x93, 0x07 + }, + { + 0xD5, 0xAC, 0x14, 0x5C, 0x2C, 0x2C, 0xBA, 0x52, + 0xE6, 0x24, 0xF9, 0x29, 0x1C, 0x3B, 0xB8, 0x5F, + 0x98, 0x98, 0xB5, 0x26, 0x96, 0x27, 0x64, 0x9D, + 0x63, 0xBB, 0xC2, 0x7A, 0xFC, 0x43, 0x8E, 0xF6, + 0x5E, 0xA3, 0xC7, 0x9B, 0x89, 0x8B, 0x43, 0x0C, + 0xEB, 0x97, 0x16, 0xF1, 0x92, 0x20, 0x7F, 0x9E, + 0xF8, 0x62, 0x41, 0x60, 0x08, 0x2D, 0x18, 0x8D, + 0xC9, 0x82, 0x7E, 0x19, 0x88, 0xAB, 0x6C, 0x47 + }, + { + 0x0D, 0xD8, 0x56, 0x87, 0x85, 0xB1, 0xED, 0x47, + 0x44, 0x91, 0x28, 0x78, 0x65, 0xA4, 0x0F, 0x67, + 0xDB, 0xD1, 0x3D, 0xC2, 0xB1, 0x52, 0x67, 0x43, + 0x17, 0x32, 0x05, 0xB6, 0x7B, 0x21, 0x39, 0xFC, + 0x2F, 0x67, 0xCC, 0x33, 0xA2, 0xB6, 0xBF, 0x8C, + 0x2A, 0xA1, 0x12, 0xED, 0x48, 0x91, 0x0D, 0xEE, + 0x3D, 0xA1, 0xB6, 0x28, 0xF4, 0x9E, 0xF7, 0xFB, + 0xAD, 0xCC, 0xCD, 0x08, 0xE9, 0x21, 0x78, 0xF9 + }, + { + 0x5A, 0xA3, 0xBA, 0x71, 0x7F, 0x9F, 0x4E, 0x78, + 0x33, 0x4A, 0x82, 0x8D, 0xEB, 0x81, 0x35, 0x21, + 0x1C, 0x72, 0xF4, 0xFC, 0x5C, 0xE0, 0xF0, 0x96, + 0xEB, 0x70, 0x3D, 0xB5, 0x56, 0x1E, 0xBE, 0x66, + 0x9F, 0xC3, 0xCE, 0x5F, 0xC9, 0x20, 0x28, 0x61, + 0x45, 0x02, 0xFF, 0x6B, 0xDF, 0xCB, 0x87, 0xA1, + 0xC7, 0xDD, 0x68, 0x9A, 0xA9, 0xAF, 0x45, 0x2B, + 0x77, 0x1E, 0x03, 0xE5, 0x67, 0x60, 0x15, 0xF6 + }, + { + 0x1A, 0xDF, 0xD0, 0x8E, 0x8B, 0xF9, 0xFE, 0x7B, + 0x70, 0x4A, 0xA5, 0x4C, 0xBC, 0xCB, 0x96, 0x82, + 0x8B, 0xE8, 0x96, 0x3C, 0xA4, 0x58, 0x2A, 0x93, + 0x92, 0xC3, 0xCC, 0x63, 0xF5, 0x72, 0x09, 0x33, + 0x81, 0x96, 0xAC, 0xCF, 0xE3, 0x0A, 0x64, 0x25, + 0xCB, 0x52, 0x8D, 0x92, 0xA0, 0x00, 0x7A, 0x78, + 0xEC, 0x2C, 0x44, 0xDB, 0xA1, 0x04, 0xDA, 0xA7, + 0x0B, 0x6C, 0x5E, 0x3F, 0x47, 0x3C, 0xC0, 0x9C + }, + { + 0xB8, 0x8B, 0x46, 0x64, 0x8B, 0x56, 0xED, 0x33, + 0xCB, 0xEA, 0x9D, 0x00, 0xCD, 0xCF, 0x46, 0x48, + 0xEA, 0x02, 0x99, 0x5E, 0x5D, 0x59, 0xC5, 0x32, + 0x1B, 0x32, 0x8F, 0x33, 0xE7, 0x8E, 0x52, 0xE8, + 0xD7, 0x5E, 0xDE, 0xBF, 0x63, 0x1F, 0x15, 0xFF, + 0x84, 0xDE, 0xB1, 0x7B, 0x96, 0xDB, 0xAA, 0xE9, + 0xA1, 0xDA, 0x9E, 0xAC, 0x66, 0x96, 0xE8, 0x25, + 0x60, 0x7F, 0xD3, 0xD8, 0x37, 0xFE, 0xDC, 0x21 + }, + { + 0x2F, 0xAE, 0xD3, 0x8F, 0x72, 0xA8, 0xA8, 0x85, + 0x52, 0xA4, 0x11, 0x78, 0xBD, 0x74, 0x31, 0x11, + 0x08, 0xBA, 0x44, 0x41, 0x66, 0xA5, 0xD3, 0x95, + 0x72, 0x54, 0x29, 0x5A, 0x18, 0x64, 0xD8, 0x4F, + 0xE7, 0xEE, 0x2F, 0x36, 0x5E, 0x14, 0x46, 0xBA, + 0x5B, 0xEC, 0x10, 0x2E, 0xF6, 0x7A, 0x20, 0xA1, + 0x42, 0x1F, 0x8F, 0x42, 0x31, 0x22, 0x09, 0xFF, + 0xA0, 0x8D, 0x91, 0xD0, 0x32, 0x19, 0x97, 0xC9 + }, + { + 0x0D, 0x5E, 0x65, 0xEF, 0x66, 0xD2, 0x42, 0xAF, + 0xC8, 0x8A, 0x47, 0x1C, 0xCD, 0x17, 0x82, 0xE4, + 0xED, 0x26, 0x47, 0x59, 0x87, 0x35, 0xCC, 0x35, + 0x83, 0xA3, 0xA8, 0xBA, 0xE3, 0x0C, 0x3A, 0x8B, + 0xA5, 0x22, 0xA0, 0xBD, 0xE5, 0x9E, 0x0B, 0x42, + 0xD4, 0x3C, 0x88, 0x7E, 0x25, 0xF1, 0xC2, 0x5F, + 0x81, 0x42, 0x58, 0xCA, 0x33, 0x76, 0xBB, 0x82, + 0xBA, 0xB6, 0x33, 0x5F, 0x9F, 0x02, 0xEF, 0x9F + }, + { + 0x2A, 0xC6, 0x56, 0x47, 0x7A, 0xA6, 0x31, 0xF6, + 0x79, 0x1E, 0x7E, 0xB8, 0xDA, 0xD8, 0x72, 0x57, + 0x84, 0x72, 0xFC, 0x86, 0xC8, 0xA5, 0x7A, 0x98, + 0x74, 0x73, 0xE4, 0x64, 0x0C, 0xFC, 0xBE, 0xE6, + 0x7A, 0x4F, 0xFE, 0x51, 0x94, 0x18, 0x9B, 0x42, + 0x43, 0x25, 0x72, 0x14, 0x0B, 0xD1, 0xF2, 0xC1, + 0x7D, 0xB8, 0x6C, 0x73, 0xB5, 0xCC, 0xF2, 0x76, + 0xD4, 0xB9, 0x45, 0x6D, 0xF3, 0xBD, 0x21, 0xF0 + }, + { + 0x2F, 0x75, 0xCC, 0x3F, 0x5D, 0xA9, 0x9A, 0x57, + 0x53, 0xD3, 0x43, 0x10, 0x8E, 0x32, 0x20, 0xB4, + 0xFA, 0xAF, 0x99, 0xDC, 0xA1, 0x1D, 0xF0, 0x29, + 0x70, 0x1F, 0x1F, 0xB7, 0x73, 0x81, 0x99, 0xE6, + 0x1C, 0x23, 0x4B, 0x16, 0x99, 0x7D, 0xCF, 0x95, + 0x20, 0xF4, 0x6C, 0xD8, 0xD3, 0x2F, 0xFA, 0xE6, + 0x27, 0x14, 0xA8, 0x6C, 0x47, 0x27, 0xE0, 0xEC, + 0x1D, 0xB3, 0x1C, 0x76, 0x9F, 0x79, 0x1D, 0x25 + }, + { + 0xE8, 0xCE, 0xAA, 0x98, 0x3D, 0xE4, 0x76, 0x3D, + 0xAB, 0x15, 0x90, 0x20, 0xB8, 0xA0, 0xE5, 0x00, + 0x0C, 0xC3, 0x83, 0xFE, 0xC3, 0x74, 0x66, 0xB4, + 0x60, 0x0D, 0x63, 0xFA, 0x7B, 0x2F, 0x71, 0xB1, + 0x50, 0x0D, 0x2E, 0xD2, 0x57, 0xCE, 0x3C, 0xA4, + 0x35, 0x68, 0xC7, 0x94, 0xF2, 0x8E, 0xCE, 0x54, + 0xE1, 0x65, 0xD3, 0x70, 0x07, 0xB2, 0xB3, 0xF4, + 0x78, 0xFF, 0x90, 0xEA, 0xBA, 0xD7, 0xC3, 0xC5 + }, + { + 0x9C, 0x44, 0x69, 0x03, 0x44, 0xF1, 0x34, 0xC0, + 0xBA, 0x9E, 0xF0, 0xC8, 0xB9, 0x7F, 0x83, 0x08, + 0x0F, 0xC8, 0x44, 0x46, 0x68, 0xC4, 0x93, 0xBE, + 0xD1, 0x3B, 0xAB, 0xF0, 0x0C, 0x11, 0x29, 0x46, + 0x56, 0x33, 0x25, 0xDE, 0xC2, 0x6A, 0xF9, 0x23, + 0xF4, 0x83, 0x12, 0x0D, 0x89, 0x81, 0x6E, 0x39, + 0x02, 0x86, 0x4E, 0xBF, 0xE5, 0xD3, 0x66, 0x6B, + 0xDD, 0xD8, 0x04, 0x5D, 0xA3, 0x2C, 0x78, 0x1A + }, + { + 0xE4, 0xDA, 0x98, 0xF0, 0x12, 0x51, 0xC6, 0x7C, + 0x35, 0xEE, 0xA2, 0x42, 0xAD, 0x8C, 0xD1, 0x26, + 0x90, 0x67, 0xEA, 0x4A, 0x34, 0x30, 0x20, 0xCB, + 0x1F, 0xB7, 0xBE, 0x48, 0x11, 0x8F, 0x5C, 0xF1, + 0xB8, 0xF1, 0x27, 0xF4, 0xA8, 0x03, 0xDD, 0x82, + 0x94, 0x75, 0x00, 0x2D, 0x19, 0x8E, 0xAF, 0x1F, + 0x50, 0x3A, 0x6C, 0x0B, 0x6E, 0x79, 0xDB, 0x0E, + 0x55, 0xC3, 0x8C, 0x3F, 0xB4, 0xE4, 0x3A, 0x8F + }, + { + 0x2B, 0x39, 0x9E, 0xE6, 0x04, 0xCE, 0x80, 0xFC, + 0x00, 0x44, 0x0C, 0xB6, 0x4A, 0xD5, 0xA6, 0xDD, + 0x19, 0xA0, 0x6E, 0x73, 0xEA, 0x26, 0x3B, 0x9F, + 0x09, 0xD5, 0x85, 0x77, 0x25, 0xC2, 0xF8, 0xD3, + 0x8B, 0xBD, 0x55, 0x13, 0x24, 0xCC, 0x27, 0x3D, + 0x1C, 0xE3, 0x98, 0x53, 0xD2, 0x0B, 0xE2, 0xE3, + 0xDE, 0x39, 0xAE, 0x64, 0x21, 0xCF, 0x03, 0x18, + 0x1A, 0xCA, 0xEB, 0x75, 0xCE, 0x39, 0x5B, 0xEA + }, + { + 0x91, 0x28, 0x53, 0x76, 0x73, 0xA4, 0x80, 0x96, + 0xCB, 0xFD, 0xC9, 0xA2, 0x2C, 0x0D, 0xA6, 0x45, + 0x05, 0x4A, 0x1E, 0x83, 0xE0, 0x11, 0x06, 0x6C, + 0x51, 0x84, 0xF6, 0xEB, 0xD8, 0x1F, 0xEA, 0x1F, + 0x42, 0x8D, 0x24, 0x01, 0xDA, 0xA4, 0x48, 0x28, + 0x85, 0x27, 0xBA, 0x6C, 0x26, 0xAF, 0x57, 0xCF, + 0x5C, 0xFF, 0xC0, 0xDB, 0x14, 0xCD, 0x34, 0xA8, + 0x27, 0x55, 0x7B, 0xAE, 0xDB, 0x0C, 0x40, 0x9F + }, + { + 0xE1, 0xCA, 0x14, 0x7F, 0x3D, 0x07, 0xE5, 0x22, + 0x54, 0x2D, 0xC7, 0x7B, 0x2D, 0x22, 0xAB, 0xAD, + 0xE8, 0xC1, 0xD5, 0xF1, 0x2F, 0x86, 0x52, 0x87, + 0xA9, 0xF7, 0xC4, 0x0F, 0x31, 0x73, 0x6A, 0x7D, + 0x7A, 0x4A, 0x57, 0xC3, 0xB8, 0xE4, 0xBB, 0xFD, + 0xC9, 0xE8, 0x5E, 0x63, 0x41, 0x2A, 0x35, 0x0A, + 0x16, 0x16, 0x58, 0x24, 0x95, 0x77, 0x7D, 0x1D, + 0xE7, 0x00, 0x40, 0x7A, 0xC6, 0x9F, 0x89, 0x05 + }, + { + 0x79, 0x8D, 0x9D, 0xB6, 0x14, 0x2F, 0x6E, 0x8F, + 0x31, 0x0A, 0x46, 0xC8, 0x98, 0x87, 0x42, 0x7C, + 0x77, 0x7E, 0xAC, 0x94, 0x61, 0x37, 0x80, 0x25, + 0xE3, 0x1D, 0x6A, 0xE2, 0x98, 0x73, 0x6A, 0x41, + 0x28, 0x19, 0xAC, 0x69, 0x29, 0x5E, 0xD4, 0x6E, + 0x75, 0x18, 0xAF, 0xC5, 0xC6, 0xE3, 0x3D, 0x1C, + 0xE7, 0xD3, 0x86, 0x22, 0x56, 0x37, 0x54, 0xDF, + 0xF2, 0x2E, 0x06, 0x95, 0x74, 0xD8, 0x22, 0xF3 + }, + { + 0xC0, 0x1D, 0xA2, 0x75, 0xE2, 0xB2, 0x2E, 0x35, + 0x32, 0xDC, 0xA0, 0x25, 0xCC, 0x03, 0x65, 0x38, + 0x99, 0x67, 0x1F, 0xBE, 0x71, 0x93, 0xF6, 0xFC, + 0x1C, 0xD5, 0x0E, 0xB4, 0x17, 0xD9, 0x0F, 0x40, + 0x24, 0x9A, 0x36, 0xAF, 0x3F, 0x57, 0x31, 0xEC, + 0xB0, 0x64, 0xB5, 0xED, 0x3B, 0x25, 0x80, 0xD5, + 0xFD, 0xC3, 0xE2, 0xAA, 0x9D, 0x7B, 0x88, 0xF1, + 0x48, 0x45, 0xE7, 0x22, 0xF8, 0x85, 0x5A, 0xCA + }, + { + 0x5E, 0x86, 0xC7, 0x35, 0xE2, 0xD6, 0x87, 0x2A, + 0xA4, 0xCD, 0xF1, 0x3D, 0x5E, 0xAA, 0xF4, 0xFD, + 0xB3, 0xA7, 0xDC, 0x9C, 0x5C, 0x54, 0xE4, 0x6E, + 0x1E, 0x85, 0x3E, 0x1E, 0xE8, 0x76, 0x4A, 0xE4, + 0x16, 0xF4, 0xAE, 0xAB, 0x66, 0x31, 0x46, 0x28, + 0xC4, 0xDB, 0xA2, 0x55, 0xDE, 0xEC, 0x0D, 0x6D, + 0x54, 0x09, 0x49, 0x95, 0xCF, 0x4E, 0xA3, 0xD1, + 0x7D, 0x26, 0xF9, 0x0C, 0x49, 0xB6, 0x30, 0x46 + }, + { + 0x19, 0xDC, 0xBC, 0xB8, 0xD4, 0xEB, 0x72, 0x50, + 0x44, 0x78, 0x0F, 0xC5, 0x8C, 0x5C, 0x70, 0x36, + 0x5A, 0xD7, 0x1A, 0x84, 0x18, 0x25, 0x91, 0x9E, + 0xBF, 0x1C, 0x0F, 0x52, 0x09, 0xA2, 0x2F, 0x01, + 0x58, 0x11, 0x95, 0xD0, 0x75, 0xB1, 0x67, 0x9A, + 0x84, 0x7C, 0x15, 0xC6, 0x5F, 0x2F, 0x81, 0x7B, + 0xE6, 0x45, 0x97, 0x70, 0x5E, 0xBB, 0x6F, 0xDE, + 0x00, 0x80, 0x03, 0x06, 0xFE, 0x0E, 0xAC, 0x25 + }, + { + 0x66, 0x87, 0x4C, 0x32, 0x16, 0x4D, 0x13, 0xFD, + 0xB4, 0xC9, 0xFD, 0xB5, 0xB0, 0x13, 0x4B, 0x66, + 0x07, 0x33, 0xEA, 0x9E, 0x88, 0x54, 0xB4, 0xE9, + 0xBA, 0xC2, 0xF4, 0x70, 0xF4, 0xA3, 0xBA, 0x40, + 0xD3, 0xBC, 0xC6, 0xD3, 0xB3, 0x76, 0x91, 0xFC, + 0xC6, 0x83, 0x80, 0xFD, 0x2B, 0xA4, 0xAA, 0x55, + 0x35, 0x04, 0x6E, 0xF9, 0xF3, 0xED, 0xF3, 0x19, + 0xFF, 0xE7, 0xC6, 0xB6, 0xAC, 0xA0, 0xBD, 0xA2 + }, + { + 0x6D, 0x44, 0xB8, 0x18, 0x78, 0xDB, 0xCF, 0x96, + 0x70, 0x5A, 0x82, 0x5F, 0x97, 0xB8, 0x4C, 0x69, + 0xC1, 0xA9, 0x0C, 0x65, 0x22, 0xD6, 0x55, 0x6A, + 0x62, 0xC3, 0xBF, 0xEA, 0x8C, 0x1C, 0x3A, 0x3E, + 0xE7, 0x13, 0x84, 0xB8, 0xD9, 0x24, 0xD8, 0x4A, + 0xFB, 0xC0, 0xF3, 0xF7, 0x56, 0x2F, 0x0F, 0xED, + 0x76, 0xD3, 0xEC, 0xEE, 0xE3, 0x96, 0xDF, 0xE6, + 0x56, 0x7A, 0x81, 0x8E, 0x5F, 0x18, 0x23, 0xEC + }, + { + 0x75, 0x89, 0xF4, 0x80, 0xAD, 0xD9, 0x87, 0x0A, + 0x67, 0x9B, 0x42, 0x2D, 0xD5, 0x7E, 0x6C, 0xCB, + 0x7F, 0x6D, 0x36, 0x50, 0xB8, 0x36, 0xA9, 0x53, + 0xD4, 0x7A, 0xA9, 0x92, 0x0D, 0x0C, 0x08, 0xAA, + 0x84, 0x93, 0x22, 0x8B, 0x28, 0x0D, 0xF7, 0xC7, + 0x5A, 0xFB, 0x06, 0x4D, 0x43, 0xE7, 0x65, 0x15, + 0xF1, 0xD2, 0xCC, 0x0A, 0x30, 0xA4, 0x31, 0xF3, + 0xD3, 0x92, 0xAA, 0x04, 0xBF, 0xB3, 0xBE, 0xFA + }, + { + 0xCA, 0x33, 0x4C, 0x20, 0x8C, 0x7B, 0x0D, 0xA3, + 0xF7, 0x30, 0x5E, 0xA7, 0xDA, 0xAE, 0xCB, 0x55, + 0x39, 0xCA, 0x22, 0x26, 0x03, 0x43, 0x96, 0xC2, + 0x66, 0x46, 0xE0, 0xA2, 0x13, 0xE5, 0x16, 0xEA, + 0xE1, 0x3B, 0xCA, 0xCE, 0xD7, 0xE8, 0x46, 0x33, + 0xED, 0xE8, 0xA0, 0x5E, 0x7B, 0xBD, 0x88, 0x3D, + 0x18, 0x63, 0x25, 0xFB, 0x76, 0x36, 0x7D, 0x4F, + 0x31, 0xBD, 0xE8, 0xEA, 0xCC, 0xDA, 0x89, 0x31 + }, + { + 0xAB, 0x61, 0xA8, 0x28, 0x1E, 0x4A, 0x3B, 0x80, + 0xBD, 0x81, 0x3D, 0xDB, 0xF1, 0x43, 0x65, 0xBA, + 0xD2, 0x46, 0x5B, 0x0E, 0x72, 0xE9, 0x0F, 0xCB, + 0xD4, 0x02, 0x12, 0xF6, 0x02, 0xA7, 0x11, 0xFD, + 0x11, 0xEC, 0x57, 0xF1, 0x64, 0x5E, 0x08, 0xE8, + 0x35, 0x01, 0xF9, 0x91, 0x2B, 0xE5, 0x7A, 0x10, + 0x0C, 0x0E, 0xC2, 0x34, 0x90, 0xDB, 0xB8, 0xC9, + 0x62, 0x29, 0x29, 0xF4, 0xF2, 0x4F, 0xDA, 0x2D + }, + { + 0x73, 0xCD, 0x42, 0x11, 0xFE, 0xAA, 0x37, 0x66, + 0x32, 0x70, 0xF2, 0x2E, 0xCC, 0xED, 0x0D, 0x94, + 0xBD, 0x98, 0x7B, 0x09, 0x91, 0x10, 0xAF, 0x90, + 0x53, 0x65, 0xB8, 0x3D, 0xFE, 0xC3, 0x3F, 0x6D, + 0x1D, 0x47, 0x67, 0xA6, 0xE1, 0xAF, 0x31, 0x85, + 0x17, 0x96, 0x99, 0x9C, 0xD3, 0xAC, 0x69, 0xD2, + 0xFF, 0xC6, 0xB6, 0x53, 0xA4, 0xC3, 0x26, 0x44, + 0x19, 0xFE, 0x58, 0x53, 0xCD, 0xCA, 0xC5, 0x60 + }, + { + 0x84, 0xC0, 0x21, 0x1E, 0xDE, 0xD1, 0x89, 0xDB, + 0xB6, 0xB2, 0x34, 0xD0, 0x29, 0x23, 0x58, 0xB6, + 0x20, 0x76, 0x34, 0xB1, 0x38, 0x5D, 0x7E, 0x65, + 0xB3, 0x06, 0x16, 0x17, 0xEB, 0x78, 0xCE, 0x84, + 0xB7, 0xEF, 0xC4, 0xDA, 0x1D, 0xB3, 0xAF, 0xF3, + 0xEA, 0x59, 0xF8, 0x52, 0xAC, 0x19, 0x04, 0x68, + 0xD4, 0xC4, 0xC9, 0xA5, 0xBB, 0xA8, 0x73, 0xB8, + 0x05, 0x96, 0xEE, 0xC1, 0x02, 0xE4, 0x91, 0x01 + }, + { + 0x00, 0xF7, 0x22, 0x5F, 0xFD, 0x39, 0x73, 0x8B, + 0x39, 0xC6, 0x4B, 0x1F, 0x9B, 0xC4, 0xEA, 0x3A, + 0x8B, 0x68, 0xD3, 0x49, 0x87, 0x02, 0x63, 0x64, + 0x53, 0x2D, 0xAE, 0x32, 0xEA, 0x07, 0x42, 0x1E, + 0x03, 0x56, 0x6E, 0xB9, 0x36, 0xFF, 0x4F, 0x7E, + 0x63, 0xB7, 0xC7, 0x83, 0xC2, 0x0E, 0xDB, 0x64, + 0x2C, 0x82, 0xA8, 0xA3, 0x55, 0x49, 0x89, 0xDD, + 0x63, 0x57, 0x25, 0x6E, 0x61, 0xA0, 0xB1, 0x93 + }, + { + 0x12, 0xA2, 0xCC, 0x5E, 0xD4, 0xCC, 0x12, 0xB8, + 0xED, 0x5B, 0xD1, 0xF8, 0x49, 0xCD, 0x6F, 0xCD, + 0xD6, 0x69, 0x23, 0xF9, 0xAA, 0x9A, 0x02, 0x78, + 0x30, 0x4E, 0x79, 0xB1, 0x5C, 0x35, 0x08, 0xDF, + 0xA3, 0x9E, 0x2D, 0x78, 0xFD, 0x9B, 0xA6, 0x7F, + 0x1A, 0x85, 0xA0, 0x4B, 0xEE, 0xD6, 0xB0, 0x58, + 0xAD, 0x3C, 0x53, 0x34, 0x2C, 0x29, 0x15, 0xB3, + 0x29, 0x33, 0xB9, 0x61, 0xC8, 0xEB, 0x2D, 0xDE + }, + { + 0xBE, 0x44, 0x6C, 0xC3, 0xAE, 0xF1, 0xE7, 0x2B, + 0x14, 0xDD, 0x5F, 0xD4, 0x21, 0xF3, 0xE1, 0x58, + 0x77, 0x37, 0xC2, 0x2F, 0xC1, 0x84, 0x63, 0x71, + 0x80, 0x51, 0x69, 0x89, 0x92, 0x26, 0xBD, 0x65, + 0x0D, 0x03, 0x1B, 0xC5, 0xBD, 0xF6, 0x6B, 0xFF, + 0xDA, 0x2E, 0x08, 0xA2, 0x75, 0x10, 0xC1, 0x1B, + 0xC3, 0xE0, 0xBF, 0xDF, 0x83, 0x9E, 0xB3, 0xD2, + 0x5C, 0xA8, 0xD1, 0x24, 0x03, 0x65, 0xE4, 0x8D + }, + { + 0x97, 0xCA, 0x69, 0x21, 0x93, 0x9F, 0xFA, 0x00, + 0x89, 0x2E, 0x8E, 0xFB, 0x8B, 0x33, 0xF2, 0xE3, + 0x1D, 0xCA, 0xB0, 0xE5, 0xB5, 0xBC, 0x7E, 0x38, + 0x17, 0x36, 0x97, 0x29, 0xC0, 0x53, 0x89, 0xC9, + 0xF0, 0x51, 0xB8, 0xC5, 0xED, 0x19, 0x3C, 0x6C, + 0x1F, 0xA0, 0x93, 0x4F, 0x3A, 0xCD, 0x52, 0xDB, + 0x03, 0x5F, 0xF9, 0xD1, 0xD3, 0x64, 0x09, 0x64, + 0xB7, 0xF6, 0xD7, 0x36, 0xD6, 0x33, 0x6F, 0x53 + }, + { + 0xC7, 0x9E, 0x9E, 0x39, 0x44, 0x17, 0x46, 0x18, + 0x34, 0x9B, 0x7A, 0x4C, 0x97, 0x78, 0x20, 0x07, + 0xA3, 0x96, 0x5E, 0xC5, 0x9B, 0x61, 0x6A, 0x93, + 0xB9, 0x21, 0x6B, 0x76, 0x0B, 0x19, 0xD7, 0x43, + 0x78, 0x62, 0x21, 0xFD, 0xDC, 0xB9, 0xCE, 0x3C, + 0x28, 0x4F, 0x23, 0x2C, 0xB3, 0x2D, 0xB0, 0xE0, + 0x48, 0x60, 0x8A, 0x0B, 0x57, 0x05, 0xD8, 0x4F, + 0x0F, 0x10, 0x07, 0x11, 0x44, 0xD5, 0xF0, 0x76 + }, + { + 0x0C, 0xF5, 0x1E, 0x77, 0xC6, 0x97, 0xE0, 0xD2, + 0x10, 0x0D, 0x28, 0x58, 0x1F, 0xE2, 0x47, 0x4E, + 0x33, 0xF3, 0xB2, 0xCA, 0xDE, 0xA1, 0x7E, 0xFE, + 0xE2, 0x3A, 0xB0, 0xCA, 0x8B, 0x9C, 0x5B, 0x88, + 0xE4, 0x64, 0x2F, 0x1C, 0x5A, 0xD4, 0x3E, 0x16, + 0x49, 0x37, 0x5F, 0x18, 0xC2, 0x66, 0x8B, 0xF1, + 0x1A, 0x3F, 0xC7, 0x43, 0x75, 0xC7, 0xB9, 0xB7, + 0xD8, 0x68, 0x44, 0x34, 0x13, 0xBB, 0xCD, 0x26 + }, + { + 0xE1, 0x0F, 0xF2, 0xC1, 0x5A, 0xBE, 0x8F, 0x70, + 0xAC, 0xBB, 0xFF, 0x52, 0x0E, 0x88, 0x63, 0x16, + 0xF2, 0xD0, 0x94, 0x6D, 0x59, 0x78, 0xC9, 0x76, + 0x1B, 0x3C, 0xF6, 0x25, 0x8B, 0xF5, 0x94, 0x6D, + 0x54, 0x64, 0xCD, 0x12, 0xF2, 0xBA, 0x79, 0x34, + 0x77, 0xC5, 0xA3, 0x21, 0xFE, 0x02, 0x68, 0x9F, + 0x5B, 0x66, 0x8D, 0x51, 0xAD, 0xDF, 0x2F, 0x80, + 0x0F, 0x53, 0xA2, 0x24, 0x34, 0xF8, 0xF5, 0x81 + }, + { + 0x62, 0x65, 0x52, 0x39, 0x48, 0x19, 0xE9, 0x4F, + 0xD7, 0x35, 0x7B, 0x6C, 0x25, 0xDB, 0x41, 0xC0, + 0x81, 0x22, 0xE5, 0x28, 0xC0, 0xC9, 0x04, 0x0B, + 0x5C, 0x76, 0x43, 0x74, 0x29, 0x43, 0xC0, 0x7D, + 0xF8, 0xE5, 0x34, 0x22, 0xB2, 0x1B, 0x9D, 0xA7, + 0xAC, 0x7C, 0xA4, 0x27, 0xC6, 0xD6, 0x59, 0xE0, + 0x27, 0x20, 0xF3, 0xB1, 0xA9, 0x0B, 0x7A, 0x6C, + 0x04, 0x2A, 0x3F, 0x84, 0x69, 0x92, 0x63, 0x55 + }, + { + 0x8F, 0x29, 0x83, 0xF4, 0xE7, 0x37, 0x01, 0xC4, + 0x5A, 0x43, 0x32, 0x11, 0xD5, 0x6E, 0xCA, 0xD3, + 0x77, 0x86, 0x33, 0x78, 0x76, 0xDB, 0xE9, 0x9C, + 0xAF, 0xDE, 0xF3, 0x1E, 0xBC, 0xBE, 0xAD, 0x8F, + 0x67, 0x54, 0xF7, 0x29, 0xA0, 0x88, 0x7D, 0x73, + 0x2C, 0x80, 0x9E, 0x1D, 0x51, 0x3E, 0x23, 0x76, + 0x9B, 0xA0, 0xD7, 0xCE, 0x31, 0x58, 0xF4, 0x9F, + 0x1F, 0x6C, 0x9A, 0x00, 0xA9, 0xBA, 0x51, 0xC6 + }, + { + 0x82, 0xA3, 0x1F, 0x40, 0xD6, 0x83, 0x7C, 0xD4, + 0xAA, 0xED, 0x3E, 0xB3, 0xF6, 0xC0, 0x76, 0xFB, + 0xF0, 0x97, 0xC8, 0xAA, 0x2D, 0x74, 0x78, 0xF2, + 0x83, 0x1A, 0x83, 0xA4, 0xFD, 0xFA, 0x3B, 0x67, + 0x0E, 0x54, 0xFA, 0xB5, 0x72, 0x54, 0xA0, 0x8C, + 0x71, 0x40, 0x43, 0x25, 0xAA, 0xD0, 0xB8, 0x7D, + 0x15, 0x50, 0xAE, 0x6C, 0x8D, 0x11, 0xFA, 0xC7, + 0xF7, 0xC3, 0xBE, 0x07, 0xF1, 0xE4, 0xF0, 0xBA + }, + { + 0xF3, 0xB9, 0x2F, 0x87, 0xAD, 0xEF, 0x09, 0xBB, + 0x62, 0x46, 0xA0, 0x07, 0xC1, 0xFF, 0x24, 0xC9, + 0x0C, 0x85, 0x43, 0xE2, 0x1F, 0x77, 0x3F, 0x69, + 0xF3, 0x2E, 0x61, 0x26, 0xA7, 0xEC, 0x12, 0x5E, + 0x92, 0xEA, 0xA8, 0xB1, 0xD9, 0xBB, 0xA1, 0x4A, + 0xB3, 0xBD, 0x39, 0xAE, 0xAC, 0xDA, 0xC1, 0x85, + 0x1B, 0xC5, 0x12, 0x23, 0x23, 0x15, 0xFF, 0x83, + 0x38, 0xEF, 0x17, 0x39, 0x07, 0x50, 0x7B, 0x0D + }, + { + 0xFF, 0xB3, 0x11, 0xED, 0x43, 0x65, 0x8D, 0xC8, + 0x33, 0x09, 0x9E, 0x56, 0x68, 0x4C, 0x3E, 0xE1, + 0x40, 0x22, 0xCD, 0xB4, 0xBE, 0xD3, 0xE6, 0x96, + 0xB9, 0xB6, 0x97, 0xD2, 0xDB, 0x18, 0x1C, 0x75, + 0xE6, 0x1C, 0xBA, 0x53, 0x29, 0x20, 0x93, 0xB5, + 0x66, 0x9C, 0x75, 0x03, 0x11, 0x7E, 0x32, 0x3F, + 0x12, 0x6A, 0x02, 0x6F, 0x33, 0xFD, 0x9C, 0xE5, + 0xCA, 0x66, 0x2A, 0x4F, 0xC0, 0xE6, 0xC4, 0x72 + }, + { + 0x5F, 0x3B, 0x61, 0xFD, 0xEA, 0x43, 0xF3, 0xA1, + 0xBD, 0x70, 0x61, 0x00, 0x5A, 0x51, 0x19, 0x74, + 0xD1, 0xBC, 0xFF, 0xF7, 0xB1, 0xB2, 0x11, 0xB3, + 0xCE, 0x80, 0x9B, 0x90, 0x5E, 0xEA, 0x9D, 0x20, + 0x40, 0x53, 0x09, 0x96, 0xE9, 0xB1, 0xFE, 0x13, + 0x43, 0x6F, 0x1A, 0x79, 0x9B, 0xE6, 0xA9, 0xF2, + 0x08, 0x84, 0x92, 0xEE, 0x27, 0x87, 0x8B, 0x74, + 0xE2, 0xA7, 0x9F, 0xDE, 0x46, 0x4D, 0xA3, 0x64 + }, + { + 0x36, 0x2D, 0x91, 0xBB, 0x17, 0xF3, 0x06, 0xF5, + 0x6A, 0x20, 0xA4, 0x5C, 0xC8, 0x34, 0xFA, 0xD8, + 0x66, 0xC6, 0x8D, 0xB4, 0x3B, 0xA4, 0x34, 0xEE, + 0x20, 0x92, 0xD3, 0x20, 0x69, 0x11, 0xEB, 0xA0, + 0xD8, 0xC3, 0xFD, 0xD5, 0xDC, 0xF8, 0x7F, 0xF3, + 0xF4, 0x04, 0x8F, 0xF5, 0x8C, 0xB0, 0xC0, 0x20, + 0xCF, 0x12, 0x51, 0xDC, 0x2C, 0xC0, 0x9F, 0xA9, + 0xDC, 0x1B, 0xFB, 0x82, 0xC9, 0xB7, 0x9B, 0x7B + }, + { + 0x81, 0xB9, 0x3B, 0x9E, 0x70, 0x15, 0x23, 0x6E, + 0xEC, 0xB1, 0x34, 0xD0, 0xEA, 0xD7, 0xC2, 0x7A, + 0xC0, 0xA2, 0x50, 0x84, 0x8F, 0xC4, 0x53, 0x4A, + 0x44, 0xCB, 0xC4, 0x27, 0x59, 0x7F, 0x37, 0x3E, + 0xC3, 0xE9, 0x2C, 0x34, 0x12, 0x57, 0xF5, 0x19, + 0xB6, 0x53, 0x8F, 0x4A, 0x4A, 0x80, 0x48, 0xCB, + 0x3C, 0xA7, 0x95, 0xD5, 0xE4, 0xB9, 0x8D, 0xE7, + 0xCE, 0xBA, 0x41, 0x7F, 0xC2, 0xC2, 0x33, 0x8B + }, + { + 0x06, 0x58, 0x0B, 0x3A, 0x01, 0xAE, 0x41, 0x02, + 0x0B, 0x86, 0x4B, 0x0F, 0x77, 0x95, 0x88, 0xF5, + 0x9A, 0xC5, 0xC8, 0x86, 0xE5, 0x7D, 0x5A, 0x66, + 0x50, 0x8E, 0x27, 0xEE, 0xDF, 0xEC, 0x28, 0x1E, + 0xCB, 0x88, 0x45, 0x51, 0xD4, 0x0C, 0x07, 0x65, + 0x96, 0xDD, 0x6B, 0x51, 0x61, 0xA1, 0x7D, 0xC5, + 0x38, 0xD6, 0x38, 0x38, 0xE3, 0x74, 0xF5, 0xFF, + 0x69, 0x59, 0xD3, 0x32, 0xFE, 0x89, 0xC7, 0xF3 + }, + { + 0x19, 0xC6, 0x81, 0x8D, 0x6A, 0x22, 0x8D, 0x41, + 0xAB, 0xC8, 0xB4, 0xD4, 0xF3, 0x0D, 0x80, 0x9D, + 0x36, 0x3C, 0x01, 0x5C, 0x63, 0xE8, 0xC0, 0x1A, + 0x65, 0x14, 0xDD, 0xE5, 0xA4, 0xE1, 0x27, 0x22, + 0xC5, 0xD7, 0xB3, 0x11, 0xCB, 0x79, 0xCD, 0x3A, + 0x44, 0xA2, 0x4D, 0x58, 0x56, 0x25, 0xC5, 0x67, + 0x21, 0xD9, 0x16, 0x39, 0x30, 0x73, 0x49, 0x05, + 0x53, 0x05, 0x8B, 0x28, 0x6A, 0x65, 0xB9, 0xA8 + }, + { + 0xD3, 0x41, 0x64, 0x7A, 0xCA, 0x38, 0xB1, 0xA9, + 0x49, 0x94, 0x45, 0xAD, 0x01, 0x11, 0xCD, 0x30, + 0x1B, 0xC3, 0x82, 0x83, 0x51, 0x44, 0x4B, 0x1A, + 0x97, 0x77, 0xA5, 0xE6, 0x77, 0x2F, 0x84, 0x12, + 0x8C, 0x36, 0xA4, 0xFE, 0xC0, 0x4D, 0xCF, 0x78, + 0x6C, 0xF1, 0x7C, 0x4F, 0xD5, 0xBF, 0x39, 0x05, + 0x66, 0x5E, 0x4C, 0x4C, 0xE4, 0x2A, 0xA4, 0x2A, + 0x68, 0x83, 0x99, 0x94, 0xE9, 0x9B, 0x3B, 0x25 + }, + { + 0x33, 0xCB, 0x32, 0xCA, 0xF3, 0x4B, 0x10, 0xEF, + 0xAF, 0xE6, 0x85, 0xAE, 0x25, 0x81, 0x2E, 0x3D, + 0xD1, 0x8C, 0xFF, 0x9C, 0x9C, 0x87, 0xC0, 0x3F, + 0xF5, 0xAB, 0x47, 0x6C, 0x0F, 0xBC, 0x98, 0x46, + 0x37, 0x81, 0xCC, 0x31, 0x0C, 0xA4, 0x49, 0xA0, + 0xBF, 0x5F, 0xD1, 0x06, 0x12, 0x85, 0x6D, 0x70, + 0x7A, 0x79, 0x15, 0x01, 0xC3, 0x8F, 0xFF, 0xE2, + 0x50, 0xC7, 0x86, 0xD0, 0x08, 0xAF, 0x6E, 0x74 + }, + { + 0x3F, 0x5A, 0x30, 0xCD, 0xEB, 0x8D, 0x42, 0x88, + 0x6D, 0xC5, 0xAB, 0xF1, 0x01, 0x27, 0x54, 0x53, + 0x54, 0x0C, 0x62, 0xB2, 0x2B, 0x97, 0x00, 0x2C, + 0x74, 0x52, 0x90, 0x0A, 0x1C, 0xA3, 0x13, 0xB4, + 0xDC, 0x5F, 0x3E, 0xDE, 0xF3, 0x2D, 0x2C, 0xBD, + 0xE8, 0x76, 0x85, 0x7A, 0xE5, 0xA7, 0x9B, 0x8C, + 0xB7, 0x67, 0xDD, 0x6A, 0x66, 0x98, 0xA0, 0xD7, + 0x0F, 0x96, 0x80, 0x53, 0x22, 0x9D, 0x86, 0xCF + }, + { + 0x35, 0x5C, 0xCC, 0x1C, 0x76, 0x1D, 0xC7, 0xB5, + 0x88, 0xDB, 0x91, 0xFD, 0xA3, 0x71, 0xCD, 0x78, + 0x5E, 0x42, 0xE1, 0xD0, 0xBC, 0x39, 0xD3, 0xA7, + 0x5C, 0xC5, 0x92, 0xAB, 0xD5, 0x11, 0x6B, 0xB6, + 0xA1, 0x84, 0x76, 0xCF, 0xCD, 0x3B, 0xD9, 0xDD, + 0x3C, 0x27, 0xCC, 0x2E, 0x74, 0xD6, 0x08, 0xE6, + 0x4E, 0xB5, 0x2F, 0x4C, 0x61, 0xC9, 0x05, 0x26, + 0xC4, 0x03, 0xC2, 0xE9, 0x1F, 0x35, 0x51, 0xB2 + }, + { + 0xE2, 0x4A, 0x23, 0xAD, 0x2C, 0xE0, 0x85, 0x1B, + 0xB2, 0x80, 0xD5, 0x95, 0x23, 0x92, 0x12, 0x3E, + 0xE2, 0xB6, 0xF7, 0xA1, 0xBC, 0xC3, 0x7D, 0x1F, + 0xA3, 0xE2, 0x9B, 0xB6, 0xF2, 0x8F, 0x54, 0x63, + 0x7C, 0xC8, 0x80, 0x93, 0xF7, 0xBC, 0x16, 0x31, + 0x4D, 0x04, 0xAC, 0x04, 0xBB, 0x2D, 0x62, 0xEB, + 0xDF, 0x62, 0xDF, 0x70, 0xEA, 0x51, 0x09, 0x0F, + 0x1E, 0x0A, 0x78, 0x7B, 0x6D, 0x04, 0xFE, 0x0A + }, + { + 0xB6, 0xA1, 0xD0, 0x01, 0x24, 0xAF, 0x3F, 0x83, + 0xE0, 0xEA, 0x28, 0x49, 0x87, 0xF6, 0x79, 0x8B, + 0x52, 0xD9, 0x7A, 0x38, 0xF0, 0x9D, 0xE2, 0x97, + 0x1D, 0x59, 0x4B, 0x56, 0x5B, 0xEC, 0x48, 0xE1, + 0xE1, 0xF8, 0xEF, 0x58, 0xB8, 0x9B, 0xA1, 0xE1, + 0x40, 0x05, 0xAB, 0xB9, 0x98, 0x07, 0x7A, 0x9C, + 0xC3, 0x5F, 0x9B, 0xC0, 0xD8, 0xB7, 0x0A, 0xED, + 0x60, 0x1F, 0xDF, 0x25, 0x57, 0x24, 0x58, 0xB6 + }, + { + 0xE8, 0x01, 0x48, 0x70, 0x5A, 0x52, 0x0F, 0x6D, + 0x48, 0x9A, 0xB8, 0xCF, 0xCA, 0xA1, 0x2F, 0xB4, + 0xDC, 0x29, 0xD5, 0xCA, 0xDC, 0x22, 0x4F, 0xD2, + 0x74, 0x0E, 0xB9, 0xE6, 0x70, 0x5D, 0x87, 0xC9, + 0x37, 0x83, 0xBD, 0x33, 0x5B, 0x19, 0xE5, 0x4C, + 0x72, 0x24, 0x8E, 0x19, 0xC5, 0x73, 0xB1, 0x50, + 0x65, 0x3A, 0x3D, 0x83, 0x19, 0xA7, 0x6A, 0xC6, + 0x99, 0xAC, 0xB9, 0xD4, 0xD9, 0xE9, 0x43, 0x4C + }, + { + 0x3A, 0x4E, 0x57, 0x23, 0xEA, 0xE8, 0x67, 0xA0, + 0x38, 0x58, 0x53, 0x20, 0x00, 0x9A, 0xF2, 0xAE, + 0x6C, 0x27, 0x07, 0x27, 0x3D, 0x4E, 0xEC, 0x39, + 0xF1, 0x29, 0x22, 0x0E, 0xF4, 0x11, 0x01, 0x06, + 0xDC, 0x8B, 0x45, 0xCF, 0x61, 0xCB, 0x57, 0x49, + 0xD3, 0x02, 0x53, 0x88, 0xB4, 0xA2, 0xB0, 0x40, + 0x18, 0x92, 0xCA, 0x44, 0x29, 0x92, 0xE4, 0xDD, + 0x83, 0x75, 0x4D, 0xFF, 0xBA, 0x46, 0xED, 0xA3 + }, + { + 0x27, 0x05, 0x67, 0x40, 0x30, 0x70, 0x99, 0xA7, + 0x4E, 0x24, 0x81, 0x7F, 0xFB, 0x52, 0xF5, 0x90, + 0xCE, 0x6D, 0xB9, 0x7F, 0x42, 0x95, 0xC4, 0x10, + 0x67, 0x72, 0xFE, 0xD1, 0xAD, 0x91, 0xCA, 0x2D, + 0xCD, 0xA3, 0x91, 0x5C, 0x56, 0xD7, 0x13, 0x1E, + 0x4E, 0x76, 0xB3, 0xA1, 0x51, 0xDA, 0x00, 0xCD, + 0xD6, 0x83, 0x23, 0x56, 0x3A, 0x23, 0x57, 0xB3, + 0xFD, 0xC9, 0x48, 0xAE, 0xD7, 0x1B, 0x1B, 0xAF + }, + { + 0xE5, 0x0B, 0xDE, 0xC4, 0x7C, 0x6C, 0x92, 0x16, + 0x28, 0x72, 0x00, 0x27, 0xC8, 0xC2, 0xE4, 0x91, + 0x3D, 0xA3, 0x09, 0x8A, 0x0B, 0xF7, 0xDF, 0x3B, + 0xC2, 0x1A, 0xA6, 0x80, 0xEB, 0x47, 0xB1, 0xAF, + 0xAA, 0x79, 0xEE, 0x16, 0xEB, 0x90, 0x1D, 0xD9, + 0x76, 0xA6, 0x13, 0x43, 0x68, 0xEE, 0xEA, 0x33, + 0xC1, 0xE9, 0x0E, 0xF4, 0x8F, 0x9A, 0x76, 0xF3, + 0xA0, 0xFF, 0xBA, 0x07, 0x19, 0x15, 0x24, 0x36 + }, + { + 0x76, 0x93, 0xE1, 0x57, 0x7D, 0x39, 0x58, 0x6A, + 0x32, 0x24, 0x44, 0x0D, 0xCC, 0x48, 0x32, 0x16, + 0x62, 0x06, 0xA6, 0x57, 0x23, 0xCE, 0x14, 0x85, + 0x22, 0x15, 0xCA, 0x45, 0xF7, 0x73, 0x26, 0xEC, + 0x19, 0x3C, 0x21, 0xB4, 0x83, 0x0C, 0x79, 0xBD, + 0x13, 0xB3, 0x4F, 0x11, 0x98, 0xC2, 0x41, 0x6C, + 0xEB, 0xF4, 0x44, 0xDA, 0xDF, 0x08, 0xEA, 0x80, + 0x94, 0xD6, 0x3E, 0x1B, 0xC0, 0x3C, 0xF3, 0x85 + }, + { + 0x20, 0x93, 0x3C, 0xDD, 0x07, 0x37, 0x18, 0x31, + 0xDC, 0x86, 0x71, 0xA5, 0xBF, 0xDA, 0x61, 0xFD, + 0x53, 0x57, 0xE0, 0x4F, 0x62, 0xBE, 0x62, 0x85, + 0xDC, 0x05, 0x17, 0x9A, 0x83, 0x55, 0x2D, 0x08, + 0x11, 0x46, 0x81, 0x94, 0xAB, 0x46, 0xB3, 0x53, + 0x4E, 0x89, 0xC6, 0x28, 0x93, 0x9F, 0x7E, 0x8D, + 0xEF, 0xFB, 0xAC, 0x2D, 0xF7, 0x6A, 0x90, 0x93, + 0xF1, 0x73, 0x96, 0xAD, 0xEE, 0x5F, 0xD1, 0x72 + }, + { + 0xC3, 0xCE, 0x74, 0x9C, 0x35, 0x08, 0x1A, 0x48, + 0x2B, 0x51, 0x46, 0x24, 0x32, 0xBC, 0x18, 0x2A, + 0xF7, 0x9E, 0xBB, 0xBB, 0x6D, 0x65, 0xB9, 0x9D, + 0xE4, 0xFC, 0xBA, 0x5B, 0x76, 0x97, 0x7C, 0xD1, + 0x61, 0x24, 0x24, 0xBF, 0x8C, 0x09, 0x88, 0xCE, + 0xA3, 0x82, 0x58, 0xDF, 0x24, 0x45, 0xF8, 0xAC, + 0x5C, 0x56, 0x9D, 0x75, 0x32, 0x0C, 0x13, 0xA3, + 0x42, 0x0F, 0xBD, 0x1D, 0x30, 0xFD, 0x0C, 0x4E + }, + { + 0x29, 0xDC, 0xC0, 0xB1, 0x3B, 0x92, 0x27, 0x31, + 0xE3, 0x50, 0x9A, 0x51, 0x1C, 0x60, 0xBD, 0x4E, + 0x5E, 0x09, 0x78, 0xAC, 0x9A, 0xDD, 0xB6, 0x40, + 0xA5, 0x0D, 0xD1, 0xD8, 0x82, 0x11, 0x48, 0x00, + 0xE0, 0x9B, 0xC1, 0x0D, 0x7E, 0x06, 0x47, 0x49, + 0x2B, 0xFF, 0x40, 0x1F, 0xA2, 0x47, 0x17, 0x42, + 0xF1, 0xEE, 0xFF, 0x84, 0xC0, 0x95, 0xFF, 0x8F, + 0xCD, 0x9F, 0x6E, 0x6F, 0x6A, 0x82, 0x72, 0xA3 + }, + { + 0xD6, 0xD0, 0xE9, 0x58, 0xB6, 0x46, 0xF6, 0x26, + 0x6C, 0xC5, 0x84, 0xF4, 0x51, 0x92, 0xA5, 0x2C, + 0x2A, 0x17, 0xF2, 0xCE, 0xA9, 0xE2, 0xEE, 0x47, + 0x69, 0xEF, 0x82, 0xF0, 0x30, 0x82, 0xB7, 0x47, + 0xB7, 0x0A, 0xF9, 0x5B, 0xEE, 0x06, 0xD9, 0x06, + 0x24, 0x14, 0xAA, 0xAE, 0xA9, 0xFC, 0x60, 0xBE, + 0xF2, 0xFE, 0xBA, 0xA1, 0x18, 0xEF, 0x1A, 0xE7, + 0xA1, 0x79, 0xAA, 0x49, 0x1C, 0x7D, 0xE0, 0x80 + }, + { + 0x1E, 0xC9, 0x4A, 0x95, 0x6D, 0xFE, 0xC8, 0xFB, + 0x1E, 0xAC, 0x45, 0x67, 0x10, 0x5D, 0x36, 0x88, + 0xF6, 0xF9, 0xB9, 0x40, 0xC2, 0x31, 0xFA, 0xD2, + 0xC6, 0xDF, 0xAE, 0xAD, 0x1A, 0x94, 0xA3, 0x4D, + 0x25, 0x71, 0x6E, 0x3A, 0x6A, 0x4E, 0x7A, 0xB2, + 0xD6, 0xBB, 0x1E, 0xD4, 0x13, 0xB1, 0x15, 0xE5, + 0x91, 0x40, 0xC1, 0xFE, 0x59, 0x8D, 0x91, 0x43, + 0x48, 0x3B, 0xA8, 0x12, 0x46, 0xEE, 0x1E, 0xA8 + }, + { + 0xE2, 0xC2, 0xF3, 0x32, 0x80, 0x68, 0x88, 0x0B, + 0x9A, 0x4A, 0xC1, 0xFE, 0x60, 0x56, 0x39, 0x73, + 0xC4, 0x7A, 0x36, 0x47, 0x6F, 0xE7, 0xAF, 0x93, + 0xC4, 0x37, 0x6A, 0x31, 0x2B, 0x79, 0x16, 0x5F, + 0x0F, 0x13, 0x2D, 0xC4, 0x3A, 0x96, 0x2C, 0x32, + 0x7E, 0xB0, 0x79, 0xAF, 0xB7, 0x1D, 0x36, 0x45, + 0xE4, 0x07, 0xD2, 0x0E, 0x18, 0x7A, 0xBE, 0xA9, + 0x44, 0xDF, 0x56, 0xBE, 0xB3, 0x79, 0xED, 0x4C + }, + { + 0x60, 0x5D, 0x71, 0x8D, 0xF3, 0x45, 0x86, 0x82, + 0x12, 0x72, 0x70, 0x7F, 0xBE, 0xA0, 0x96, 0xEE, + 0xEF, 0x0C, 0x58, 0xBD, 0x8C, 0xB6, 0x39, 0x15, + 0x1D, 0xF0, 0x95, 0x7E, 0xDD, 0xE0, 0xC6, 0x28, + 0xE8, 0xAE, 0x54, 0xC1, 0x72, 0x23, 0x39, 0xEB, + 0x1D, 0xD6, 0x56, 0x5C, 0xBD, 0x12, 0x76, 0x10, + 0xCD, 0x16, 0x2A, 0x7C, 0x96, 0x45, 0x8F, 0x90, + 0x75, 0x7E, 0x25, 0x53, 0x3C, 0xB2, 0x6C, 0x6F + }, + { + 0xF3, 0x62, 0xF5, 0x63, 0x29, 0x98, 0xF6, 0x62, + 0x09, 0xCA, 0xDC, 0x87, 0x1B, 0x83, 0xBC, 0x93, + 0x63, 0x4C, 0xE1, 0xDE, 0x24, 0x52, 0x36, 0x96, + 0xF0, 0xB2, 0xAC, 0xE8, 0x5E, 0xC7, 0xBB, 0x2D, + 0xDB, 0x45, 0xD4, 0x18, 0xA4, 0xFA, 0xE7, 0xAC, + 0xB7, 0x0C, 0xCB, 0xA7, 0xF3, 0x67, 0x36, 0x28, + 0x0D, 0x59, 0xAA, 0xB2, 0xDA, 0xEF, 0x24, 0x7A, + 0xBC, 0x75, 0x60, 0x15, 0xFB, 0x44, 0x4D, 0xD2 + }, + { + 0xF2, 0x60, 0x28, 0xF7, 0x02, 0x85, 0x4B, 0x32, + 0xBF, 0xAA, 0x9C, 0x0B, 0xC2, 0x6C, 0xC3, 0xD0, + 0x6B, 0xC2, 0x0C, 0xD8, 0xBE, 0xE1, 0x15, 0x49, + 0xA2, 0xF9, 0x86, 0xF4, 0x33, 0x6F, 0xA2, 0xD6, + 0x25, 0x5F, 0xE7, 0x91, 0xF3, 0xFB, 0xF5, 0x49, + 0x9C, 0xDB, 0x5F, 0xA2, 0x79, 0x85, 0xF7, 0xFD, + 0xC4, 0xB8, 0x0D, 0xF4, 0x55, 0x84, 0x4C, 0x08, + 0x0F, 0x0E, 0x41, 0xB0, 0x5E, 0x66, 0xD4, 0xF6 + }, + { + 0x74, 0xAD, 0x0C, 0xE9, 0x53, 0xA5, 0x3C, 0xD2, + 0xBB, 0x71, 0x1A, 0x7F, 0x0A, 0xA2, 0xE3, 0x73, + 0x42, 0x7D, 0xFC, 0x76, 0xE8, 0x45, 0x14, 0x0E, + 0x51, 0x96, 0xD3, 0x7C, 0x89, 0xF8, 0x19, 0x80, + 0x3C, 0xF3, 0x11, 0x96, 0xCD, 0x47, 0x6C, 0xF2, + 0x7F, 0x7C, 0x2B, 0x44, 0xCF, 0x66, 0x6A, 0xAD, + 0x25, 0xFC, 0x65, 0xD8, 0xD9, 0x0E, 0x8D, 0x9C, + 0x39, 0xDD, 0x98, 0xCD, 0x00, 0xD3, 0x79, 0x01 + }, + { + 0xE5, 0x6B, 0x43, 0x08, 0x8E, 0x71, 0x2C, 0xF1, + 0x77, 0x4E, 0x6C, 0x80, 0xB6, 0x6B, 0xA2, 0x7F, + 0x0D, 0xFC, 0x0C, 0x9B, 0x5F, 0x13, 0x75, 0xD1, + 0x9D, 0xF8, 0x5C, 0x5B, 0x30, 0x15, 0xBD, 0xFF, + 0xA9, 0x51, 0x2D, 0x40, 0x89, 0x6E, 0xB6, 0x1E, + 0xE5, 0xC6, 0x49, 0x98, 0xD7, 0xA1, 0x80, 0xC2, + 0x5C, 0x6B, 0xDF, 0x06, 0x7D, 0x75, 0x80, 0xAD, + 0x93, 0xBF, 0x2C, 0xB3, 0xC9, 0xBC, 0x15, 0xEE + }, + { + 0xE2, 0x8A, 0x58, 0x3A, 0x27, 0x55, 0xB1, 0xE0, + 0xDF, 0xD9, 0xC0, 0x17, 0xE0, 0x07, 0x0A, 0xD2, + 0xC3, 0x9D, 0x19, 0xEF, 0xCF, 0x72, 0xC8, 0xE6, + 0x55, 0xE0, 0x2E, 0x50, 0x86, 0x55, 0x75, 0x39, + 0x13, 0x5D, 0x1B, 0xAA, 0xB7, 0x36, 0x35, 0x5D, + 0x67, 0x2A, 0x26, 0xE2, 0x40, 0x8D, 0x33, 0x02, + 0x56, 0x66, 0x6C, 0xC6, 0x4E, 0x2F, 0x69, 0x00, + 0x44, 0xC9, 0xBE, 0x67, 0xE7, 0x69, 0x8D, 0x5B + }, + { + 0xC3, 0x6C, 0x28, 0x1F, 0x73, 0x05, 0xF6, 0x39, + 0x1C, 0xAA, 0x59, 0xA3, 0x90, 0x79, 0x82, 0x94, + 0xCD, 0x7E, 0x1D, 0x22, 0x5C, 0xC4, 0x58, 0x75, + 0x08, 0x33, 0x17, 0x5B, 0x5C, 0x5D, 0x08, 0x77, + 0x8E, 0x39, 0x08, 0x07, 0x71, 0xEF, 0xDD, 0x37, + 0x45, 0xFB, 0x5B, 0x37, 0x48, 0xA8, 0xC8, 0x98, + 0xF1, 0x9D, 0x37, 0xBF, 0xD8, 0x47, 0xC1, 0x02, + 0xDE, 0xDB, 0x6A, 0x3D, 0xC7, 0xB4, 0xFE, 0x7B + }, + { + 0x7E, 0x67, 0xA1, 0x44, 0xED, 0x40, 0xA5, 0xCC, + 0xF7, 0x13, 0x3D, 0x0D, 0xA6, 0x29, 0x84, 0x6E, + 0xA5, 0xA8, 0xB5, 0x48, 0x42, 0xA5, 0xCA, 0x1B, + 0x38, 0x95, 0x82, 0x3A, 0x43, 0x21, 0x69, 0x96, + 0xBF, 0xC2, 0xFF, 0xD2, 0x94, 0x50, 0x2B, 0x0F, + 0x54, 0xF9, 0x28, 0xC6, 0x4C, 0xEB, 0x1E, 0xD5, + 0x98, 0x4E, 0xDC, 0xE1, 0x36, 0x63, 0xA6, 0x45, + 0x44, 0xDA, 0xB8, 0xF6, 0x14, 0x33, 0xB5, 0xA3 + }, + { + 0x6B, 0x0D, 0x2B, 0x54, 0x5C, 0x12, 0x09, 0x69, + 0xCD, 0x2B, 0x76, 0x1B, 0x65, 0x9B, 0x58, 0x27, + 0x37, 0xFA, 0x1B, 0x50, 0xFF, 0xFE, 0x3C, 0xDA, + 0x80, 0xAE, 0xB6, 0x28, 0x81, 0x26, 0x7E, 0x02, + 0xF9, 0x96, 0x8D, 0xD2, 0xDD, 0x41, 0x82, 0x9E, + 0x48, 0xBE, 0xDF, 0x10, 0xF9, 0x02, 0x11, 0xE4, + 0x81, 0xEF, 0xD4, 0x2D, 0x9B, 0xFC, 0x39, 0x63, + 0xF2, 0x2D, 0xC0, 0xE0, 0x21, 0xAC, 0xF1, 0x82 + }, + { + 0x0A, 0x70, 0x45, 0x9D, 0x36, 0x09, 0xA5, 0x87, + 0xDF, 0x83, 0xC0, 0x1B, 0x19, 0x8C, 0x82, 0x80, + 0xE9, 0xE0, 0x1E, 0x94, 0x91, 0x56, 0x28, 0xDE, + 0x9E, 0x43, 0xEF, 0xFE, 0x61, 0x4D, 0x97, 0x30, + 0x41, 0x9F, 0x25, 0x86, 0x2F, 0x34, 0x56, 0x75, + 0xAF, 0x27, 0x54, 0x72, 0x78, 0xDD, 0xA7, 0xCE, + 0xF2, 0x36, 0xAD, 0xC1, 0x21, 0x18, 0xD1, 0xD6, + 0xAC, 0x6E, 0x82, 0x69, 0x67, 0xEA, 0x7A, 0x4A + }, + { + 0xA9, 0x16, 0xC7, 0xD4, 0x5C, 0xC9, 0x96, 0xD2, + 0xAD, 0xFF, 0x9F, 0x61, 0xB6, 0x04, 0x1C, 0xF1, + 0x6A, 0xA9, 0x6C, 0xB5, 0xE4, 0x20, 0x13, 0x43, + 0x43, 0xE5, 0xEF, 0x4D, 0x14, 0xAF, 0x70, 0xB7, + 0x19, 0x35, 0x75, 0xC4, 0xE7, 0xBD, 0x30, 0x34, + 0xE6, 0x7F, 0x4D, 0x9B, 0xD5, 0x62, 0x62, 0xAB, + 0x90, 0x33, 0x30, 0xEE, 0x52, 0x1C, 0xFD, 0x99, + 0x80, 0xDB, 0xBC, 0x13, 0xBE, 0xF7, 0x53, 0x9B + }, + { + 0xFD, 0xAF, 0xEC, 0x4E, 0x7E, 0x7D, 0x4F, 0x76, + 0x98, 0xE9, 0xE6, 0x6E, 0x9A, 0xA8, 0x2B, 0x20, + 0xB7, 0xF6, 0xE6, 0x59, 0xD1, 0xC6, 0xBE, 0xAF, + 0x06, 0xB0, 0x3C, 0x44, 0xBF, 0xEB, 0xDC, 0xC3, + 0x9D, 0x38, 0x13, 0xE6, 0xFD, 0xF1, 0x94, 0x7F, + 0x4D, 0x81, 0x54, 0xB8, 0xA2, 0x59, 0x36, 0x2D, + 0xD7, 0x39, 0x6E, 0xD3, 0xAF, 0x77, 0x1E, 0xC2, + 0xDE, 0x76, 0x78, 0xB1, 0x90, 0x3A, 0x9C, 0xE3 + }, + { + 0x8A, 0x29, 0xF8, 0x01, 0x38, 0xF7, 0x84, 0xA4, + 0xA5, 0x4C, 0x90, 0x82, 0xC2, 0x25, 0xD5, 0xB8, + 0x1B, 0x75, 0x94, 0x99, 0xF3, 0x49, 0x64, 0x1A, + 0x79, 0xA0, 0xFA, 0xE8, 0xED, 0x02, 0xEA, 0x71, + 0x8D, 0x08, 0x64, 0x20, 0x79, 0x4F, 0x60, 0x35, + 0xE8, 0x35, 0x7C, 0xEA, 0xAC, 0x97, 0xC8, 0x0A, + 0xB1, 0xB9, 0x39, 0x12, 0x94, 0xCA, 0x17, 0x4B, + 0x33, 0x56, 0x25, 0x33, 0x17, 0xC4, 0x41, 0xC8 + }, + { + 0xB8, 0x53, 0x84, 0x46, 0x0F, 0xFB, 0x14, 0x04, + 0x84, 0xCE, 0xEC, 0xC1, 0x46, 0x9D, 0x03, 0x8F, + 0x13, 0xE4, 0x05, 0xC3, 0x2D, 0x4B, 0x04, 0x25, + 0x62, 0x83, 0x9F, 0xFA, 0xBF, 0x72, 0x40, 0x3B, + 0x9A, 0x79, 0x05, 0x7C, 0x35, 0xA0, 0x63, 0x76, + 0x90, 0xCA, 0xF4, 0xA0, 0x87, 0x69, 0xDF, 0x02, + 0xB4, 0x3F, 0xD0, 0xC5, 0x3B, 0xBF, 0xE5, 0x04, + 0xDE, 0x62, 0x8B, 0x10, 0x3A, 0x7D, 0x51, 0x7D + }, +}; + + + + +static const uint8_t blake2bp_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2B_OUTBYTES] = +{ + { + 0x9D, 0x94, 0x61, 0x07, 0x3E, 0x4E, 0xB6, 0x40, + 0xA2, 0x55, 0x35, 0x7B, 0x83, 0x9F, 0x39, 0x4B, + 0x83, 0x8C, 0x6F, 0xF5, 0x7C, 0x9B, 0x68, 0x6A, + 0x3F, 0x76, 0x10, 0x7C, 0x10, 0x66, 0x72, 0x8F, + 0x3C, 0x99, 0x56, 0xBD, 0x78, 0x5C, 0xBC, 0x3B, + 0xF7, 0x9D, 0xC2, 0xAB, 0x57, 0x8C, 0x5A, 0x0C, + 0x06, 0x3B, 0x9D, 0x9C, 0x40, 0x58, 0x48, 0xDE, + 0x1D, 0xBE, 0x82, 0x1C, 0xD0, 0x5C, 0x94, 0x0A + }, + { + 0xFF, 0x8E, 0x90, 0xA3, 0x7B, 0x94, 0x62, 0x39, + 0x32, 0xC5, 0x9F, 0x75, 0x59, 0xF2, 0x60, 0x35, + 0x02, 0x9C, 0x37, 0x67, 0x32, 0xCB, 0x14, 0xD4, + 0x16, 0x02, 0x00, 0x1C, 0xBB, 0x73, 0xAD, 0xB7, + 0x92, 0x93, 0xA2, 0xDB, 0xDA, 0x5F, 0x60, 0x70, + 0x30, 0x25, 0x14, 0x4D, 0x15, 0x8E, 0x27, 0x35, + 0x52, 0x95, 0x96, 0x25, 0x1C, 0x73, 0xC0, 0x34, + 0x5C, 0xA6, 0xFC, 0xCB, 0x1F, 0xB1, 0xE9, 0x7E + }, + { + 0xD6, 0x22, 0x0C, 0xA1, 0x95, 0xA0, 0xF3, 0x56, + 0xA4, 0x79, 0x5E, 0x07, 0x1C, 0xEE, 0x1F, 0x54, + 0x12, 0xEC, 0xD9, 0x5D, 0x8A, 0x5E, 0x01, 0xD7, + 0xC2, 0xB8, 0x67, 0x50, 0xCA, 0x53, 0xD7, 0xF6, + 0x4C, 0x29, 0xCB, 0xB3, 0xD2, 0x89, 0xC6, 0xF4, + 0xEC, 0xC6, 0xC0, 0x1E, 0x3C, 0xA9, 0x33, 0x89, + 0x71, 0x17, 0x03, 0x88, 0xE3, 0xE4, 0x02, 0x28, + 0x47, 0x90, 0x06, 0xD1, 0xBB, 0xEB, 0xAD, 0x51 + }, + { + 0x30, 0x30, 0x2C, 0x3F, 0xC9, 0x99, 0x06, 0x5D, + 0x10, 0xDC, 0x98, 0x2C, 0x8F, 0xEE, 0xF4, 0x1B, + 0xBB, 0x66, 0x42, 0x71, 0x8F, 0x62, 0x4A, 0xF6, + 0xE3, 0xEA, 0xBE, 0xA0, 0x83, 0xE7, 0xFE, 0x78, + 0x53, 0x40, 0xDB, 0x4B, 0x08, 0x97, 0xEF, 0xFF, + 0x39, 0xCE, 0xE1, 0xDC, 0x1E, 0xB7, 0x37, 0xCD, + 0x1E, 0xEA, 0x0F, 0xE7, 0x53, 0x84, 0x98, 0x4E, + 0x7D, 0x8F, 0x44, 0x6F, 0xAA, 0x68, 0x3B, 0x80 + }, + { + 0x32, 0xF3, 0x98, 0xA6, 0x0C, 0x1E, 0x53, 0xF1, + 0xF8, 0x1D, 0x6D, 0x8D, 0xA2, 0xEC, 0x11, 0x75, + 0x42, 0x2D, 0x6B, 0x2C, 0xFA, 0x0C, 0x0E, 0x66, + 0xD8, 0xC4, 0xE7, 0x30, 0xB2, 0x96, 0xA4, 0xB5, + 0x3E, 0x39, 0x2E, 0x39, 0x85, 0x98, 0x22, 0xA1, + 0x45, 0xAE, 0x5F, 0x1A, 0x24, 0xC2, 0x7F, 0x55, + 0x33, 0x9E, 0x2B, 0x4B, 0x44, 0x58, 0xE8, 0xC5, + 0xEB, 0x19, 0xAA, 0x14, 0x20, 0x64, 0x27, 0xAA + }, + { + 0x23, 0x6D, 0xB9, 0x33, 0xF1, 0x8A, 0x9D, 0xBD, + 0x4E, 0x50, 0xB7, 0x29, 0x53, 0x90, 0x65, 0xBD, + 0xA4, 0x20, 0xDF, 0x97, 0xAC, 0x78, 0x0B, 0xE4, + 0x3F, 0x59, 0x10, 0x3C, 0x47, 0x2E, 0x0B, 0xCC, + 0xA6, 0xD4, 0x97, 0x38, 0x97, 0x86, 0xAF, 0x22, + 0xBA, 0x94, 0x30, 0xB7, 0x4D, 0x6F, 0x74, 0xB1, + 0x3F, 0x6F, 0x94, 0x9E, 0x25, 0x6A, 0x14, 0x0A, + 0xA3, 0x4B, 0x47, 0x70, 0x0B, 0x10, 0x03, 0x43 + }, + { + 0x23, 0x8C, 0x9D, 0x08, 0x02, 0x85, 0xE3, 0x54, + 0x35, 0xCB, 0x53, 0x15, 0x5D, 0x9F, 0x79, 0x2C, + 0xA1, 0xBB, 0x27, 0xDE, 0x4F, 0x9B, 0x6C, 0x87, + 0x26, 0xE1, 0x1C, 0x02, 0x8E, 0x7B, 0x87, 0x87, + 0x33, 0x54, 0x91, 0x12, 0xA3, 0x28, 0xB5, 0x0E, + 0x8C, 0xD8, 0xBA, 0x27, 0x87, 0x21, 0x7E, 0x46, + 0xB8, 0x16, 0x8D, 0x57, 0x11, 0x3D, 0xD4, 0x04, + 0xD9, 0x14, 0xE2, 0x9A, 0x6A, 0x54, 0x70, 0xE6 + }, + { + 0x9A, 0x02, 0x1E, 0xBD, 0x50, 0x4A, 0x97, 0x59, + 0x6D, 0x0E, 0x85, 0x04, 0x8A, 0xE1, 0xDA, 0x89, + 0x99, 0xE3, 0xA0, 0x47, 0x01, 0x6F, 0x17, 0xC6, + 0xC5, 0x55, 0x6C, 0x27, 0x31, 0xE9, 0xB1, 0x39, + 0x26, 0x1F, 0x84, 0x3F, 0xAD, 0x6B, 0xD4, 0x3F, + 0x7C, 0x7C, 0x58, 0x7F, 0x69, 0x8D, 0x69, 0xB6, + 0x82, 0xE5, 0x68, 0xB4, 0x42, 0xAC, 0x45, 0x88, + 0x98, 0x57, 0xB7, 0x69, 0x07, 0x34, 0xCD, 0xBB + }, + { + 0x3A, 0xBA, 0x07, 0xAE, 0x98, 0x0E, 0x33, 0x86, + 0x37, 0x47, 0x9D, 0xCA, 0x1E, 0x35, 0x28, 0x00, + 0xF4, 0x58, 0x8E, 0x62, 0xD8, 0x23, 0x36, 0x5A, + 0xA6, 0x9C, 0x5B, 0x25, 0xFC, 0xE1, 0x29, 0x68, + 0xD2, 0x6C, 0x9B, 0xDB, 0xEE, 0x9A, 0x32, 0xBF, + 0xFD, 0x42, 0xE6, 0xB2, 0x2C, 0x81, 0x38, 0xA6, + 0x1C, 0x1F, 0xCE, 0x49, 0xFF, 0xBC, 0x19, 0x0E, + 0x1E, 0x15, 0x16, 0x01, 0x53, 0xCC, 0xB6, 0xB4 + }, + { + 0x77, 0x4C, 0xDF, 0x9A, 0xBB, 0x50, 0x81, 0xFE, + 0x07, 0xEB, 0x57, 0x25, 0xE6, 0x06, 0x9B, 0x8D, + 0x6C, 0x7E, 0x60, 0x04, 0xA2, 0x4D, 0x70, 0xF7, + 0xDF, 0xAB, 0xFC, 0x03, 0x82, 0x5B, 0xBC, 0x3B, + 0x30, 0xE6, 0x20, 0xB6, 0x04, 0x1F, 0x3C, 0xC2, + 0x89, 0x6B, 0x14, 0xAB, 0x66, 0x0A, 0xF7, 0x2E, + 0x24, 0x95, 0x10, 0xAC, 0x2F, 0xE8, 0x10, 0xCC, + 0x77, 0x63, 0xA2, 0xE5, 0xC3, 0xFC, 0xA7, 0xFC + }, + { + 0x9E, 0x08, 0x9F, 0x51, 0x65, 0x7B, 0x29, 0xC2, + 0x66, 0x8E, 0x28, 0x50, 0x52, 0x4E, 0x53, 0xAE, + 0xAA, 0xA7, 0x30, 0x6F, 0x2A, 0xD5, 0xA2, 0x32, + 0xB5, 0xF0, 0x7F, 0x68, 0x8D, 0x8A, 0xB2, 0xB4, + 0x25, 0xDF, 0x7E, 0xA5, 0xBD, 0x3E, 0x9F, 0xFD, + 0x61, 0x68, 0x38, 0x90, 0x15, 0x1D, 0x78, 0xBB, + 0x94, 0x03, 0x11, 0x85, 0xAC, 0xA4, 0x81, 0xE2, + 0x14, 0x0F, 0xE3, 0x79, 0x85, 0x36, 0x76, 0x43 + }, + { + 0xB3, 0x5B, 0xD5, 0x4E, 0x4F, 0x81, 0x69, 0x6B, + 0x4F, 0x22, 0x31, 0x6A, 0x1E, 0x33, 0x7D, 0x98, + 0xD1, 0xC6, 0xB0, 0x61, 0x10, 0x99, 0x87, 0x63, + 0xB5, 0x91, 0x33, 0x35, 0x92, 0x3A, 0x40, 0x76, + 0xCB, 0x80, 0xD6, 0xD8, 0xA5, 0x18, 0x62, 0x91, + 0x13, 0x47, 0x7B, 0x30, 0xA1, 0x32, 0xA6, 0xB2, + 0x7F, 0xC1, 0xEE, 0x79, 0xF6, 0xB2, 0xE0, 0xD3, + 0x5D, 0x5B, 0xC2, 0x97, 0x27, 0x46, 0x3D, 0xB5 + }, + { + 0x12, 0x39, 0x30, 0xD5, 0xA4, 0xB7, 0x3B, 0x49, + 0x1F, 0x50, 0xE5, 0x6E, 0x2B, 0x73, 0x97, 0xA4, + 0x3D, 0x2E, 0x47, 0x87, 0x23, 0x76, 0x02, 0xB6, + 0x6F, 0xE0, 0xA8, 0x47, 0xBD, 0x13, 0xCB, 0xE8, + 0xB3, 0x7D, 0xC7, 0x03, 0xD7, 0xB2, 0xB4, 0xEA, + 0xA8, 0xBF, 0xB9, 0xA5, 0x8A, 0x7D, 0x71, 0x9C, + 0x90, 0x8F, 0x19, 0x66, 0xA2, 0xF1, 0x9F, 0xE6, + 0xEB, 0x1A, 0x78, 0x96, 0x2A, 0xFA, 0x5B, 0xF9 + }, + { + 0x08, 0x9C, 0xBC, 0x7E, 0xE1, 0xB1, 0x2C, 0x0C, + 0xC9, 0xC8, 0x3F, 0xF6, 0x66, 0xFE, 0xC8, 0x02, + 0x6B, 0xB7, 0x1B, 0x90, 0x84, 0x97, 0x9B, 0x0E, + 0xA8, 0xB7, 0x23, 0xBB, 0xBE, 0x8B, 0x00, 0xD4, + 0x10, 0x08, 0xB6, 0x04, 0x99, 0xF2, 0x4F, 0x24, + 0x1B, 0x63, 0x28, 0x1F, 0xE5, 0xB4, 0xD8, 0x89, + 0x66, 0x30, 0x9C, 0x0D, 0x7E, 0x64, 0x66, 0x91, + 0x05, 0xE5, 0x1E, 0x69, 0xD7, 0xAF, 0x8C, 0xE5 + }, + { + 0x6B, 0x3C, 0x67, 0x89, 0x47, 0xF6, 0x12, 0x52, + 0x65, 0x7C, 0x35, 0x49, 0x78, 0xC1, 0x01, 0xB2, + 0xFD, 0xD2, 0x72, 0x9E, 0xC3, 0x49, 0x27, 0xDD, + 0x5E, 0xFF, 0x0A, 0x7C, 0x0A, 0x86, 0x58, 0x26, + 0xE8, 0x33, 0xC3, 0x63, 0x23, 0x21, 0x31, 0xB1, + 0x05, 0x93, 0xBE, 0x1C, 0xCF, 0x6B, 0xA5, 0x4E, + 0xCC, 0x14, 0x31, 0x2F, 0x45, 0xBF, 0xFC, 0x24, + 0x04, 0x62, 0x9F, 0xF8, 0x02, 0x67, 0xF0, 0x94 + }, + { + 0xAA, 0x0C, 0x23, 0xEA, 0x1C, 0x6F, 0xE2, 0xE9, + 0x0A, 0x77, 0x18, 0xEF, 0x4A, 0xA4, 0x75, 0x1F, + 0xF6, 0xBE, 0xB9, 0xD4, 0x61, 0x63, 0x59, 0x5B, + 0x5D, 0x4F, 0xB8, 0x96, 0x00, 0x52, 0x5C, 0x5B, + 0x6C, 0xF1, 0x9E, 0xCD, 0xB2, 0x47, 0x78, 0x72, + 0xA7, 0xA1, 0x2D, 0x40, 0xE5, 0x06, 0x36, 0x08, + 0xE5, 0xF0, 0x00, 0x8E, 0x79, 0x72, 0xA9, 0xC0, + 0x1A, 0x4B, 0xE2, 0xAF, 0xE9, 0x53, 0x2F, 0x9C + }, + { + 0x63, 0x34, 0x7A, 0xB4, 0xCB, 0xB6, 0xF2, 0x89, + 0x52, 0x99, 0x2C, 0x07, 0x9D, 0x18, 0xD4, 0x20, + 0x01, 0xB7, 0xF3, 0xA9, 0xD0, 0xFD, 0x90, 0xB0, + 0xA4, 0x77, 0x1F, 0x69, 0x72, 0xF0, 0xC5, 0x32, + 0x89, 0xC8, 0xAE, 0xE1, 0x43, 0x29, 0x4B, 0x50, + 0xC6, 0x34, 0x12, 0x58, 0x5C, 0xDC, 0xE4, 0xFF, + 0x7B, 0xED, 0x11, 0x2C, 0xD0, 0x3C, 0x9B, 0x1D, + 0xF3, 0xDE, 0xF0, 0xCC, 0x32, 0x0D, 0x6B, 0x70 + }, + { + 0x23, 0x96, 0xC0, 0xCB, 0x9E, 0xDA, 0xAC, 0xA9, + 0xD8, 0xB1, 0x04, 0x65, 0x2C, 0xB7, 0xF1, 0x25, + 0xF1, 0x93, 0x55, 0x1A, 0xE5, 0xD7, 0xBC, 0x94, + 0x63, 0x30, 0x7C, 0x9E, 0x69, 0xCA, 0x7D, 0xA2, + 0x3A, 0x9F, 0xBC, 0xBC, 0xB8, 0x66, 0x69, 0xD5, + 0xBA, 0x63, 0x43, 0x85, 0x93, 0xE1, 0x32, 0xF9, + 0x92, 0xB5, 0x7C, 0x00, 0x17, 0xC8, 0x6D, 0xDB, + 0x9B, 0x47, 0x28, 0x6E, 0xF5, 0xB6, 0x87, 0x18 + }, + { + 0xA9, 0x4B, 0x80, 0x22, 0x57, 0xFD, 0x03, 0x1E, + 0xE6, 0x0F, 0x1B, 0xE1, 0x84, 0x38, 0x3A, 0x76, + 0x32, 0x85, 0x39, 0xF9, 0xD8, 0x06, 0x08, 0x72, + 0xEF, 0x35, 0x73, 0xBE, 0xB6, 0xF2, 0x73, 0x68, + 0x08, 0x95, 0x90, 0xED, 0xBB, 0x21, 0xF4, 0xD8, + 0xF1, 0x81, 0xBA, 0x66, 0x20, 0x75, 0xF9, 0x19, + 0x05, 0x97, 0x4B, 0xEE, 0xEF, 0x1F, 0xC5, 0xCB, + 0x9B, 0xCF, 0xB2, 0x8A, 0xAE, 0x1E, 0x4D, 0xE3 + }, + { + 0x52, 0xC7, 0xD3, 0x39, 0x9A, 0x03, 0x80, 0x04, + 0xBE, 0xA5, 0x2D, 0x3E, 0xA9, 0xE9, 0x1E, 0x25, + 0x44, 0xC8, 0x65, 0x2A, 0xB8, 0xF5, 0x28, 0x5C, + 0x9D, 0x32, 0x18, 0x63, 0x7A, 0x6D, 0x9F, 0xCA, + 0xF0, 0xD9, 0x65, 0xB3, 0x58, 0x8E, 0xE6, 0xD7, + 0x3F, 0xA5, 0x99, 0xDE, 0xCA, 0x1F, 0x41, 0xDE, + 0xD8, 0x02, 0x5B, 0xF7, 0x76, 0x8E, 0x0E, 0x20, + 0x0E, 0x8C, 0xD3, 0xFF, 0x86, 0x8C, 0x38, 0x00 + }, + { + 0xB6, 0x29, 0xF5, 0x71, 0x62, 0x87, 0x6A, 0xDB, + 0x8F, 0xA9, 0x57, 0x2E, 0xBA, 0x4E, 0x1E, 0xCD, + 0x75, 0xA6, 0x56, 0x73, 0x08, 0xDE, 0x90, 0xDB, + 0xB8, 0xFF, 0xDE, 0x77, 0xDE, 0x82, 0x13, 0xA4, + 0xD7, 0xF7, 0xCB, 0x85, 0xAE, 0x1B, 0x71, 0xE6, + 0x45, 0x7B, 0xC4, 0xE8, 0x9C, 0x0D, 0x9D, 0xE2, + 0x41, 0xB6, 0xB9, 0xF3, 0x74, 0xB7, 0x34, 0x19, + 0x4D, 0xB2, 0xB2, 0x67, 0x02, 0xD7, 0xCB, 0x7C + }, + { + 0x72, 0x28, 0x46, 0xDD, 0xAC, 0xAA, 0x94, 0xFD, + 0xE6, 0x63, 0x2A, 0x2D, 0xC7, 0xDC, 0x70, 0x8B, + 0xDF, 0x98, 0x31, 0x1C, 0x9F, 0xB6, 0x3C, 0x61, + 0xE5, 0x25, 0xFD, 0x4B, 0x0D, 0x87, 0xB6, 0x38, + 0x8B, 0x5A, 0xF7, 0x04, 0x20, 0x18, 0xDD, 0xCA, + 0x06, 0x5E, 0x8A, 0x55, 0xBB, 0xFD, 0x68, 0xEE, + 0x61, 0xFC, 0xD3, 0xC6, 0x87, 0x8F, 0x5B, 0x09, + 0xBC, 0xC2, 0x7B, 0xED, 0x61, 0xDD, 0x93, 0xED + }, + { + 0x1C, 0xED, 0x6A, 0x0C, 0x78, 0x9D, 0xDB, 0x29, + 0x56, 0x78, 0xAD, 0x43, 0xA3, 0x22, 0xD8, 0x96, + 0x61, 0x7F, 0xDE, 0x27, 0x5F, 0x13, 0x8C, 0xCC, + 0xFB, 0x13, 0x26, 0xCD, 0x3F, 0x76, 0x09, 0xC2, + 0xAA, 0xA5, 0xEC, 0x10, 0x26, 0x97, 0x17, 0x3E, + 0x12, 0x1A, 0xE1, 0x63, 0x02, 0x4F, 0x42, 0x8C, + 0x98, 0x28, 0x35, 0xB4, 0xFA, 0x6D, 0xA6, 0xD6, + 0x78, 0xAE, 0xB9, 0xEE, 0x10, 0x6A, 0x3F, 0x6C + }, + { + 0xE8, 0x69, 0x14, 0x8C, 0x05, 0x45, 0xB3, 0x58, + 0x0E, 0x39, 0x5A, 0xFD, 0xC7, 0x45, 0xCD, 0x24, + 0x3B, 0x6B, 0x5F, 0xE3, 0xB6, 0x7E, 0x29, 0x43, + 0xF6, 0xF8, 0xD9, 0xF2, 0x4F, 0xFA, 0x40, 0xE8, + 0x81, 0x75, 0x6E, 0x1C, 0x18, 0xD9, 0x2F, 0x3E, + 0xBE, 0x84, 0x55, 0x9B, 0x57, 0xE2, 0xEE, 0x3A, + 0x65, 0xD9, 0xEC, 0xE0, 0x49, 0x72, 0xB3, 0x5D, + 0x4C, 0x4E, 0xBE, 0x78, 0x6C, 0x88, 0xDA, 0x62 + }, + { + 0xDA, 0xDA, 0x15, 0x5E, 0x55, 0x42, 0x32, 0xB1, + 0x6E, 0xCA, 0xD9, 0x31, 0xCB, 0x42, 0xE3, 0x25, + 0xB5, 0x86, 0xDB, 0xF1, 0xCB, 0xD0, 0xCE, 0x38, + 0x14, 0x45, 0x16, 0x6B, 0xD1, 0xBF, 0xA3, 0x32, + 0x49, 0x85, 0xE7, 0x7C, 0x6F, 0x0D, 0x51, 0x2A, + 0x02, 0x6E, 0x09, 0xD4, 0x86, 0x1C, 0x3B, 0xB8, + 0x52, 0x9D, 0x72, 0x02, 0xEA, 0xC1, 0xC0, 0x44, + 0x27, 0x44, 0xD3, 0x7C, 0x7F, 0x5A, 0xB8, 0xAF + }, + { + 0x2D, 0x14, 0x8C, 0x8E, 0x8F, 0x76, 0xFA, 0xAC, + 0x6F, 0x7F, 0x01, 0xF2, 0x03, 0x9E, 0xA0, 0x2A, + 0x42, 0xD9, 0x32, 0x57, 0x94, 0xC2, 0xC7, 0xA0, + 0x0F, 0x83, 0xF4, 0xA7, 0x79, 0x8A, 0xFB, 0xA9, + 0x93, 0xFF, 0x94, 0x91, 0x1E, 0x09, 0x8B, 0x00, + 0x1A, 0x0B, 0xDF, 0xF4, 0xC8, 0x5A, 0x2A, 0x61, + 0x31, 0xE0, 0xCF, 0xE7, 0x0F, 0x1D, 0x2E, 0x07, + 0xAF, 0x02, 0x09, 0xDA, 0x77, 0x96, 0x09, 0x1F + }, + { + 0x99, 0x98, 0x3A, 0x75, 0x9C, 0xCF, 0x9C, 0xAC, + 0xAE, 0x70, 0x2D, 0xCB, 0xFC, 0xDF, 0x72, 0x04, + 0xDD, 0xF0, 0x33, 0x4B, 0xC6, 0x5D, 0xAD, 0x84, + 0x6F, 0x83, 0x1F, 0x9F, 0x9D, 0x8A, 0x45, 0x3F, + 0x0D, 0x24, 0x93, 0x5C, 0x4C, 0x65, 0x7F, 0xFF, + 0x2E, 0xBB, 0xDB, 0xAF, 0x7B, 0xCE, 0x6A, 0xAC, + 0xDB, 0xB8, 0x87, 0x6F, 0x16, 0x04, 0x59, 0xB1, + 0xA4, 0xAA, 0xC9, 0x56, 0x97, 0xE0, 0x0D, 0x98 + }, + { + 0x7E, 0x4A, 0x02, 0x12, 0x6D, 0x75, 0x52, 0xF4, + 0xC9, 0xB9, 0x4D, 0x80, 0xE3, 0xCF, 0x7B, 0x89, + 0x7E, 0x09, 0x84, 0xE4, 0x06, 0xF0, 0x78, 0x13, + 0x5C, 0xF4, 0x56, 0xC0, 0xD5, 0x1E, 0x13, 0x91, + 0xFF, 0x18, 0xA8, 0x8F, 0x93, 0x12, 0x2C, 0x83, + 0x2C, 0xAC, 0x7D, 0x79, 0x6A, 0x6B, 0x42, 0x51, + 0x9B, 0x1D, 0xB4, 0xEA, 0xD8, 0xF4, 0x98, 0x40, + 0xCE, 0xB5, 0x52, 0x33, 0x6B, 0x29, 0xDE, 0x44 + }, + { + 0xD7, 0xE1, 0x6F, 0xD1, 0x59, 0x65, 0x8A, 0xD7, + 0xEE, 0x25, 0x1E, 0x51, 0x7D, 0xCE, 0x5A, 0x29, + 0xF4, 0x6F, 0xD4, 0xB8, 0xD3, 0x19, 0xDB, 0x80, + 0x5F, 0xC2, 0x5A, 0xA6, 0x20, 0x35, 0x0F, 0xF4, + 0x23, 0xAD, 0x8D, 0x05, 0x37, 0xCD, 0x20, 0x69, + 0x43, 0x2E, 0xBF, 0xF2, 0x92, 0x36, 0xF8, 0xC2, + 0xA8, 0xA0, 0x4D, 0x04, 0xB3, 0xB4, 0x8C, 0x59, + 0xA3, 0x55, 0xFC, 0xC6, 0x2D, 0x27, 0xF8, 0xEE + }, + { + 0x0D, 0x45, 0x17, 0xD4, 0xF1, 0xD0, 0x47, 0x30, + 0xC6, 0x91, 0x69, 0x18, 0xA0, 0x4C, 0x9E, 0x90, + 0xCC, 0xA3, 0xAC, 0x1C, 0x63, 0xD6, 0x45, 0x97, + 0x8A, 0x7F, 0x07, 0x03, 0x9F, 0x92, 0x20, 0x64, + 0x7C, 0x25, 0xC0, 0x4E, 0x85, 0xF6, 0xE2, 0x28, + 0x6D, 0x2E, 0x35, 0x46, 0x0D, 0x0B, 0x2C, 0x1E, + 0x25, 0xAF, 0x9D, 0x35, 0x37, 0xEF, 0x33, 0xFD, + 0x7F, 0xE5, 0x1E, 0x2B, 0xA8, 0x76, 0x4B, 0x36 + }, + { + 0x56, 0xB7, 0x2E, 0x51, 0x37, 0xC6, 0x89, 0xB2, + 0x73, 0x66, 0xFB, 0x22, 0xC7, 0xC6, 0x75, 0x44, + 0xF6, 0xBC, 0xE5, 0x76, 0x19, 0x41, 0x31, 0xC5, + 0xBF, 0xAB, 0x1C, 0xF9, 0x3C, 0x2B, 0x51, 0xAA, + 0xA3, 0x03, 0x36, 0x8A, 0xA8, 0x44, 0xD5, 0x8D, + 0xF0, 0xEE, 0x5D, 0x4E, 0x31, 0x9F, 0xCD, 0x8E, + 0xFF, 0xC6, 0x02, 0xCE, 0xE4, 0x35, 0x1B, 0xD2, + 0xF5, 0x51, 0x43, 0x0B, 0x92, 0x11, 0xE7, 0x3C + }, + { + 0xF3, 0x35, 0xCC, 0x22, 0xFF, 0xEA, 0x5A, 0xA5, + 0x9C, 0xDF, 0xC8, 0xF5, 0x02, 0x89, 0xCC, 0x92, + 0x31, 0x9B, 0x8B, 0x14, 0x40, 0x8D, 0x7A, 0x5A, + 0xA1, 0x23, 0x2A, 0xE2, 0x3A, 0xA1, 0xEA, 0x7F, + 0x77, 0x48, 0xCF, 0xEF, 0x03, 0x20, 0x10, 0xF8, + 0x62, 0x6D, 0x93, 0x18, 0xED, 0xBA, 0x98, 0xD4, + 0x16, 0x62, 0x03, 0x35, 0xC9, 0x01, 0xED, 0x02, + 0xEA, 0xBD, 0x27, 0x6A, 0x1B, 0x82, 0x9C, 0x9D + }, + { + 0xA9, 0x9A, 0x3D, 0x10, 0xF9, 0x5B, 0x44, 0x2F, + 0xFF, 0xF7, 0xC4, 0x18, 0xFA, 0x94, 0x9D, 0x48, + 0x30, 0x86, 0x9B, 0x0E, 0x60, 0xEC, 0x8B, 0x97, + 0x2C, 0x30, 0xA3, 0x16, 0x9C, 0x27, 0xBE, 0xB5, + 0xCF, 0x33, 0x05, 0x94, 0xF0, 0x14, 0xB6, 0x6B, + 0x22, 0x00, 0xA7, 0xF0, 0x86, 0xD2, 0xC2, 0xF3, + 0xF9, 0xFD, 0x85, 0x32, 0xA5, 0x71, 0x88, 0x76, + 0xDF, 0xCA, 0x66, 0x1B, 0xA0, 0xF7, 0xB3, 0x6D + }, + { + 0x15, 0x8E, 0x25, 0x70, 0xD0, 0x84, 0xA4, 0x86, + 0x9D, 0x96, 0x93, 0x43, 0xC0, 0x10, 0x86, 0x07, + 0x17, 0xFF, 0x74, 0x11, 0x61, 0x88, 0x17, 0x5F, + 0x2E, 0xD7, 0x4C, 0xD5, 0x78, 0xFA, 0x0D, 0x80, + 0x91, 0xB0, 0x3F, 0xAD, 0x0C, 0x65, 0xCF, 0x59, + 0xAB, 0x91, 0xDD, 0x73, 0xB3, 0x7F, 0xE3, 0xF5, + 0x8A, 0x58, 0xE7, 0xB4, 0x47, 0x9C, 0x87, 0x5A, + 0xCD, 0x63, 0xEC, 0x52, 0x58, 0x12, 0x35, 0x3F + }, + { + 0x7C, 0x49, 0x50, 0x1C, 0x58, 0x08, 0xB1, 0x5C, + 0x0D, 0x31, 0xBD, 0xD5, 0xBB, 0x56, 0x31, 0xD5, + 0x3A, 0xE0, 0x0D, 0xF4, 0x31, 0x02, 0x5F, 0xEA, + 0x51, 0xEB, 0x47, 0x62, 0x54, 0x4E, 0xFD, 0xEE, + 0x97, 0x8A, 0x83, 0x50, 0x8D, 0xEA, 0x6B, 0xFD, + 0x3B, 0x93, 0x1A, 0x0E, 0x95, 0x83, 0xCC, 0xFC, + 0x04, 0x9E, 0xA8, 0x46, 0x44, 0x70, 0x5D, 0x31, + 0x9F, 0xDC, 0x5C, 0x16, 0x3B, 0xF4, 0x82, 0x24 + }, + { + 0xFE, 0xF4, 0x36, 0xB3, 0x5F, 0x71, 0x7D, 0x59, + 0xAC, 0xA1, 0x7E, 0x9B, 0xF5, 0xFF, 0xDA, 0x28, + 0xF5, 0xF4, 0x01, 0x94, 0x3E, 0xFE, 0x93, 0xEB, + 0x58, 0x0F, 0xFB, 0x98, 0xF1, 0x3B, 0xEA, 0x80, + 0x94, 0x69, 0xA3, 0x44, 0xE7, 0x82, 0xA4, 0x43, + 0xC6, 0x4E, 0xB2, 0x5A, 0xD0, 0x9D, 0x8D, 0xE2, + 0x05, 0xFE, 0xE7, 0xD5, 0x63, 0x96, 0x86, 0xA1, + 0x9E, 0x7C, 0x42, 0xB4, 0x0F, 0x70, 0x6A, 0x08 + }, + { + 0x4D, 0x47, 0xA6, 0x7A, 0x5F, 0x8E, 0x17, 0xB7, + 0x22, 0xDF, 0x98, 0x58, 0xAE, 0xB6, 0x7B, 0x99, + 0x56, 0xB4, 0x59, 0x62, 0xEC, 0x35, 0x3D, 0xC2, + 0xE2, 0x7F, 0x0F, 0x50, 0x1C, 0x39, 0x8E, 0x34, + 0x39, 0x7B, 0xEB, 0xE0, 0x2B, 0x54, 0x92, 0x7E, + 0x2D, 0x31, 0xF1, 0x2E, 0xCF, 0x55, 0xE8, 0x82, + 0x69, 0xFA, 0xB5, 0x37, 0x0E, 0x7F, 0xA5, 0x70, + 0x35, 0x26, 0x6F, 0x89, 0xD5, 0xC2, 0x64, 0x41 + }, + { + 0x1B, 0x58, 0xDC, 0x7A, 0xAC, 0x36, 0x3B, 0x00, + 0x44, 0x6E, 0xA8, 0x03, 0xBC, 0xD7, 0x49, 0xC3, + 0xF5, 0xCA, 0xBE, 0xAA, 0xF2, 0x23, 0x99, 0x4C, + 0x0C, 0x3E, 0xCC, 0x1B, 0x28, 0x47, 0x73, 0x44, + 0xD7, 0xBF, 0x97, 0xC0, 0x8A, 0x95, 0x9D, 0x1A, + 0xC2, 0x06, 0x0B, 0x47, 0x27, 0x89, 0x86, 0x92, + 0x91, 0x88, 0xAD, 0x73, 0xDE, 0x67, 0x07, 0x8B, + 0xA6, 0x80, 0x96, 0x3B, 0x9D, 0x3B, 0x12, 0xA4 + }, + { + 0x3C, 0x52, 0x2C, 0x84, 0x3E, 0x69, 0x74, 0xEC, + 0x75, 0x0D, 0xF2, 0x20, 0xD4, 0x1A, 0x00, 0x4A, + 0xC2, 0xAD, 0xF0, 0x94, 0x56, 0xFA, 0x78, 0x7F, + 0x7C, 0x65, 0x43, 0xAB, 0x17, 0x97, 0x9C, 0x77, + 0x7B, 0x3E, 0x79, 0xD1, 0x78, 0x7D, 0xA5, 0xA8, + 0x3F, 0x17, 0x8D, 0xA9, 0xF0, 0x4C, 0xF6, 0xF5, + 0xB2, 0x55, 0xDD, 0xCB, 0x18, 0x74, 0x84, 0x1B, + 0xBF, 0x70, 0x16, 0xE6, 0x13, 0x2B, 0x99, 0x8A + }, + { + 0x5A, 0x4F, 0xEB, 0x8F, 0x70, 0x75, 0xB4, 0xDC, + 0x9C, 0xA1, 0x6C, 0x6F, 0x05, 0xCD, 0x6B, 0x70, + 0x27, 0x48, 0x5F, 0xFE, 0xD9, 0x15, 0x7D, 0x82, + 0x4D, 0x9D, 0x1A, 0x17, 0x20, 0xEE, 0xEE, 0xEA, + 0x3F, 0x6C, 0x12, 0x5F, 0xDA, 0x4B, 0xA4, 0x40, + 0x9D, 0x79, 0x80, 0x49, 0xFD, 0x18, 0x82, 0xC6, + 0x90, 0x28, 0x8F, 0x33, 0x54, 0x7A, 0x3D, 0x8D, + 0x62, 0x60, 0xB6, 0x54, 0x54, 0x88, 0x53, 0xD7 + }, + { + 0xBC, 0xAA, 0x79, 0x36, 0x32, 0x56, 0x9E, 0x2F, + 0x84, 0x17, 0xCC, 0x60, 0x32, 0x53, 0x53, 0x5B, + 0xD7, 0xD8, 0x5F, 0x38, 0x53, 0x19, 0x92, 0x59, + 0x1E, 0x56, 0xC1, 0xA4, 0xB6, 0xF5, 0x8E, 0xE7, + 0xF8, 0x18, 0xFA, 0xE0, 0x27, 0x88, 0x8A, 0x86, + 0x28, 0x43, 0x05, 0x10, 0x1E, 0xC0, 0x46, 0x61, + 0xF5, 0x99, 0x53, 0x47, 0xA4, 0x67, 0xED, 0x8B, + 0x92, 0x79, 0xF1, 0xAC, 0xC2, 0xB4, 0xBB, 0x1F + }, + { + 0x34, 0xAF, 0x91, 0xCC, 0x22, 0xA6, 0x9B, 0xCB, + 0x55, 0xDD, 0xBF, 0x7F, 0x0F, 0x43, 0xEC, 0x56, + 0x48, 0x40, 0x43, 0x32, 0x13, 0xEA, 0x55, 0xD9, + 0xF8, 0x1A, 0xC4, 0x75, 0x20, 0x8D, 0x74, 0x85, + 0x1D, 0xB7, 0x0F, 0xE4, 0x96, 0xAF, 0x9D, 0xA1, + 0xD3, 0x93, 0xEC, 0xF8, 0x78, 0x69, 0x5D, 0xD3, + 0x3F, 0xD5, 0x43, 0x49, 0xA6, 0xF8, 0x24, 0xAE, + 0xED, 0x18, 0x3C, 0xB1, 0xB0, 0x8C, 0x54, 0x85 + }, + { + 0xB8, 0xB7, 0xAD, 0x2E, 0xA2, 0xB6, 0xFA, 0x06, + 0xD0, 0x0B, 0xCD, 0x59, 0x9C, 0x99, 0x71, 0xC5, + 0xB4, 0xE1, 0x65, 0x58, 0xE1, 0x52, 0x12, 0xC9, + 0xBF, 0xD3, 0x73, 0xE4, 0xBC, 0x79, 0x17, 0x05, + 0x26, 0x01, 0xFF, 0xDB, 0x68, 0x01, 0xBE, 0x80, + 0xBA, 0x50, 0x9D, 0xB8, 0x2A, 0x0B, 0x71, 0x95, + 0x92, 0x91, 0x33, 0xAD, 0x53, 0x99, 0x56, 0x06, + 0x52, 0x33, 0xF4, 0x9D, 0x07, 0x1C, 0x84, 0xE4 + }, + { + 0xDC, 0xEE, 0x9C, 0x45, 0xBC, 0x5D, 0x1F, 0xE6, + 0x30, 0xB1, 0x8B, 0x06, 0x3C, 0xE8, 0x2C, 0x38, + 0x57, 0xE3, 0x0D, 0x20, 0xC6, 0x4B, 0x5C, 0xC2, + 0x58, 0x84, 0x94, 0x3E, 0x7A, 0xE9, 0x4E, 0xDF, + 0xF8, 0x50, 0xEB, 0x0E, 0x82, 0x44, 0x02, 0x3D, + 0x3D, 0x07, 0xA8, 0xA0, 0x07, 0x06, 0xF0, 0x58, + 0x2C, 0xC1, 0x02, 0xB6, 0x6C, 0x6D, 0xDA, 0x86, + 0xE8, 0xF2, 0xDF, 0x32, 0x56, 0x59, 0x88, 0x6F + }, + { + 0x04, 0xF6, 0xE8, 0x22, 0xF1, 0x7C, 0xC7, 0xA5, + 0x94, 0x6D, 0xF8, 0x0D, 0x95, 0x8A, 0xEF, 0x06, + 0x5D, 0x87, 0x49, 0x16, 0xE1, 0x03, 0xA6, 0x83, + 0x0C, 0x6E, 0x46, 0xB6, 0x05, 0x59, 0x18, 0x18, + 0x0D, 0x14, 0x52, 0x29, 0x3C, 0x58, 0xA9, 0x74, + 0x9C, 0xBC, 0x8F, 0x0A, 0xC4, 0x08, 0xA9, 0xCA, + 0x89, 0x57, 0x61, 0xCF, 0xC4, 0x51, 0x16, 0x46, + 0x41, 0xA1, 0x79, 0xFB, 0x5C, 0xD8, 0xFE, 0xBC + }, + { + 0x51, 0x1F, 0xDB, 0x7C, 0x88, 0x26, 0x85, 0x35, + 0xE9, 0x7E, 0x4E, 0xD8, 0x92, 0xF3, 0xC0, 0x65, + 0x83, 0x2B, 0x26, 0x59, 0x14, 0xFC, 0x61, 0x07, + 0xA1, 0xD2, 0x7D, 0xBB, 0x7D, 0x51, 0xC3, 0x7E, + 0x95, 0x98, 0x15, 0x06, 0xC1, 0x14, 0x72, 0x44, + 0xD5, 0xBA, 0xE9, 0x0E, 0xE9, 0x0D, 0x08, 0x49, + 0x84, 0xBA, 0xA7, 0x58, 0x7F, 0x41, 0xFF, 0x6F, + 0x4B, 0xA7, 0x22, 0xC8, 0xB9, 0x2A, 0xEB, 0x99 + }, + { + 0x2B, 0xA2, 0xBD, 0x17, 0xE9, 0x26, 0x27, 0x5B, + 0x06, 0x83, 0xB2, 0x36, 0xBF, 0xE3, 0x76, 0x30, + 0x26, 0x6E, 0x37, 0xF4, 0x18, 0x2F, 0x53, 0xA9, + 0x82, 0x34, 0xE9, 0x15, 0xAB, 0x64, 0xC9, 0x59, + 0x96, 0xC6, 0xCB, 0x7A, 0xE8, 0x80, 0xC3, 0xDF, + 0xCB, 0x47, 0xD0, 0x5A, 0xAD, 0xD2, 0x1A, 0xBF, + 0x8E, 0x40, 0xB7, 0x3F, 0x40, 0xF3, 0x98, 0xDC, + 0x5B, 0x02, 0x14, 0x14, 0x57, 0x45, 0x6A, 0x09 + }, + { + 0x9B, 0x66, 0x8D, 0x9B, 0x44, 0x47, 0xE3, 0x76, + 0xF6, 0xC6, 0xCF, 0xA6, 0x8D, 0xBC, 0x79, 0x19, + 0x83, 0x81, 0xAB, 0x60, 0x5F, 0x55, 0xD5, 0xA7, + 0xEF, 0x68, 0x3B, 0xCE, 0xD4, 0x6F, 0x9A, 0xFD, + 0x36, 0x85, 0x41, 0x1A, 0x66, 0xE2, 0x34, 0x6F, + 0x96, 0x07, 0x77, 0xD0, 0xC9, 0x22, 0x71, 0x24, + 0x30, 0xE0, 0x18, 0xBF, 0xAE, 0x86, 0x53, 0x01, + 0x7E, 0xA2, 0x0E, 0xCD, 0x5F, 0x1F, 0x95, 0x6C + }, + { + 0x56, 0x81, 0x02, 0x4F, 0x53, 0x85, 0x88, 0xA0, + 0x1B, 0x2C, 0x83, 0x94, 0xCA, 0xE8, 0x73, 0xC6, + 0xD8, 0x5D, 0x6A, 0xA0, 0x6E, 0xDD, 0xB3, 0xA5, + 0x02, 0x09, 0x6F, 0xC0, 0x82, 0xBB, 0x89, 0xCB, + 0x24, 0x15, 0x31, 0xB3, 0x15, 0x75, 0x0D, 0x31, + 0xBB, 0x0B, 0x63, 0x01, 0x28, 0xD1, 0x9D, 0x11, + 0x39, 0x2B, 0xCF, 0x4B, 0x34, 0x78, 0xD5, 0x23, + 0xD7, 0xD2, 0x13, 0xE4, 0x75, 0x0F, 0x55, 0x92 + }, + { + 0x2A, 0xA9, 0x1B, 0xA6, 0xDE, 0x60, 0x17, 0xF1, + 0x93, 0x0F, 0xC7, 0xD9, 0x6D, 0xCC, 0xD6, 0x70, + 0x74, 0x8B, 0x7E, 0xB1, 0xD0, 0x94, 0xDF, 0xB4, + 0xB3, 0xB1, 0x47, 0x8A, 0x61, 0x2E, 0xBF, 0x03, + 0xDD, 0xD7, 0x21, 0x27, 0x9A, 0x26, 0x6D, 0xE3, + 0x88, 0x45, 0xE6, 0x12, 0xC9, 0x30, 0x98, 0xC2, + 0xEF, 0xFF, 0x34, 0xFE, 0x50, 0x06, 0x17, 0x20, + 0x5B, 0x1D, 0xE2, 0xFE, 0xA1, 0xD8, 0x02, 0x46 + }, + { + 0x82, 0x4D, 0x89, 0xC0, 0x63, 0x7C, 0xE1, 0x78, + 0xB6, 0x30, 0x68, 0x4C, 0x72, 0x9E, 0x26, 0x65, + 0x3F, 0x34, 0xEA, 0xC7, 0xE9, 0x04, 0x12, 0xE9, + 0x63, 0xD3, 0xF1, 0x9D, 0x64, 0x51, 0xE8, 0x25, + 0x85, 0x21, 0x67, 0xC4, 0x8D, 0xF7, 0xCC, 0x55, + 0xB2, 0x57, 0xB2, 0x50, 0xA7, 0x0C, 0x7B, 0xCC, + 0xFA, 0x9A, 0xA1, 0x5C, 0x18, 0x8A, 0xC4, 0x63, + 0x7A, 0x52, 0x22, 0x89, 0xC0, 0x87, 0x6A, 0xD4 + }, + { + 0x87, 0xE4, 0xAE, 0x11, 0xDA, 0x1A, 0x2C, 0xA8, + 0x82, 0x2A, 0xE3, 0x30, 0xDC, 0x97, 0xAB, 0x2E, + 0x47, 0xFF, 0x62, 0x32, 0x30, 0x93, 0xC2, 0xB7, + 0xA6, 0xC0, 0xE2, 0xC1, 0x68, 0x21, 0xCD, 0x7C, + 0xEC, 0x92, 0x18, 0x4D, 0xF4, 0xBB, 0x6E, 0x2B, + 0x62, 0x6A, 0x44, 0x78, 0x03, 0x90, 0x63, 0xAF, + 0xEE, 0xB0, 0xD2, 0x87, 0xF2, 0x42, 0x19, 0x20, + 0x78, 0x98, 0xCC, 0xE7, 0xAD, 0xE0, 0x63, 0x9C + }, + { + 0xDD, 0x7F, 0x2F, 0x44, 0xA4, 0x02, 0xA0, 0x1E, + 0x82, 0x16, 0xB1, 0x03, 0xA4, 0xE7, 0x23, 0x5C, + 0x28, 0x30, 0x31, 0x9D, 0x56, 0xAF, 0x63, 0x9F, + 0x23, 0xC4, 0x8C, 0x27, 0x59, 0xAB, 0xA6, 0xEB, + 0x5E, 0xEE, 0xE3, 0x8C, 0x29, 0x8E, 0xBE, 0x41, + 0x98, 0x26, 0x7A, 0x00, 0xEB, 0x2A, 0x08, 0xD9, + 0x3A, 0x50, 0x37, 0x03, 0x17, 0x1C, 0x77, 0x33, + 0x38, 0x62, 0x10, 0x10, 0x55, 0xBD, 0x7A, 0xD2 + }, + { + 0x4C, 0xB8, 0x46, 0x59, 0x61, 0x93, 0xF7, 0xF2, + 0x78, 0xAA, 0xAA, 0xC5, 0xCC, 0xFF, 0xD5, 0x35, + 0x7A, 0xB0, 0xD1, 0x24, 0x5F, 0x69, 0x79, 0xD1, + 0x41, 0xA4, 0x71, 0xBD, 0xAB, 0x55, 0xE2, 0x38, + 0xB1, 0xAE, 0xD6, 0x7B, 0x73, 0x39, 0x95, 0x04, + 0xB9, 0x7D, 0xF1, 0xA2, 0x5E, 0xB6, 0xFE, 0x27, + 0x2B, 0x5C, 0xD4, 0x96, 0xA7, 0xC8, 0xA0, 0x60, + 0x92, 0x6E, 0x74, 0x04, 0xFD, 0xA0, 0x79, 0x0D + }, + { + 0x6F, 0x44, 0xEC, 0xDA, 0xE1, 0x4E, 0x3B, 0x81, + 0xA1, 0x91, 0x22, 0x03, 0x01, 0x5F, 0x59, 0x18, + 0xEA, 0xC6, 0xFB, 0xF4, 0x96, 0x60, 0x10, 0xF4, + 0x9D, 0x2B, 0xC2, 0xBC, 0xEF, 0xE7, 0xB1, 0xDF, + 0xEC, 0x5C, 0x83, 0x5D, 0x7D, 0x87, 0xA4, 0x43, + 0x71, 0xF1, 0x5A, 0x6C, 0x08, 0x42, 0x52, 0xB9, + 0x34, 0x65, 0x26, 0x42, 0x72, 0xA4, 0x10, 0xD5, + 0x0F, 0x89, 0xA1, 0x17, 0xF3, 0x1A, 0xF4, 0x63 + }, + { + 0x1F, 0x70, 0x5F, 0x6E, 0x9F, 0x07, 0x0D, 0x87, + 0xFD, 0xE8, 0xE2, 0x77, 0x46, 0x74, 0xFA, 0x9B, + 0xF1, 0x20, 0xD2, 0x88, 0xEB, 0x0B, 0xE7, 0xAA, + 0x12, 0x8D, 0xFB, 0x5D, 0x10, 0x11, 0xCE, 0x1F, + 0xDA, 0x99, 0xB2, 0x55, 0x22, 0x66, 0x65, 0xD8, + 0x3F, 0x63, 0x4E, 0x8F, 0xCA, 0xBD, 0xA9, 0xA2, + 0x3C, 0x03, 0x51, 0x5E, 0x9C, 0xFE, 0xCE, 0x6E, + 0x94, 0xA8, 0xEC, 0x92, 0xE4, 0xED, 0xEC, 0xB7 + }, + { + 0x2D, 0x96, 0xC5, 0xB0, 0x15, 0x74, 0x72, 0x2B, + 0x81, 0x7F, 0xEB, 0x48, 0x6C, 0x5F, 0xC9, 0x8F, + 0x5F, 0x84, 0x61, 0xF4, 0xCE, 0xE9, 0x90, 0x5A, + 0xF2, 0x06, 0xD4, 0x72, 0x33, 0x86, 0xD1, 0xC4, + 0xC7, 0xCA, 0xC5, 0x84, 0x00, 0x28, 0xD7, 0xAF, + 0xED, 0x0E, 0x38, 0xAD, 0x13, 0x96, 0x28, 0xEB, + 0x6A, 0xF9, 0x2B, 0x4B, 0x88, 0xEB, 0xF0, 0x9B, + 0x1F, 0xA0, 0x47, 0xFB, 0xE1, 0x0B, 0xC3, 0x1D + }, + { + 0x65, 0xDA, 0x78, 0x0A, 0x0A, 0x37, 0x47, 0x9D, + 0xD8, 0xF4, 0xD6, 0x55, 0x64, 0xF9, 0xA7, 0x08, + 0x9E, 0x42, 0x07, 0xEB, 0x16, 0xAC, 0xA3, 0xF6, + 0x55, 0x31, 0xCF, 0xEE, 0x76, 0x25, 0xBA, 0x13, + 0x80, 0xA4, 0x97, 0xB6, 0x24, 0x72, 0xFC, 0x7E, + 0x00, 0x07, 0xA6, 0xB0, 0x35, 0x61, 0x04, 0x16, + 0xA5, 0xF8, 0x2C, 0x10, 0x82, 0xFA, 0x06, 0x5C, + 0x46, 0xDD, 0xEE, 0x49, 0x40, 0xD1, 0xFC, 0x46 + }, + { + 0x1C, 0x09, 0xA3, 0xB3, 0x80, 0xB8, 0xA7, 0xFC, + 0x33, 0x3F, 0xD2, 0x71, 0x4D, 0xF7, 0x12, 0x9B, + 0x44, 0xA4, 0x67, 0x68, 0xBA, 0xCF, 0x0A, 0x67, + 0xA3, 0x8A, 0x47, 0xB3, 0xAB, 0x31, 0xF5, 0x1B, + 0x05, 0x33, 0xC2, 0xAA, 0x2B, 0x4B, 0x7B, 0xBB, + 0x6A, 0xE5, 0xED, 0xF3, 0xDC, 0xB0, 0xEC, 0xC1, + 0xA2, 0x83, 0xE8, 0x43, 0xF2, 0x90, 0x7B, 0x34, + 0x1F, 0x17, 0x9A, 0xFD, 0x8B, 0x67, 0xDA, 0x90 + }, + { + 0x67, 0x88, 0x8B, 0x83, 0xFA, 0xAF, 0xBB, 0x62, + 0x29, 0x34, 0xB8, 0xD5, 0x59, 0x63, 0xE1, 0x86, + 0x15, 0x3E, 0x59, 0x51, 0x88, 0x7C, 0x7F, 0x4A, + 0x76, 0x35, 0xC7, 0x98, 0xD9, 0xA5, 0x82, 0x94, + 0xBE, 0x26, 0xA3, 0xC5, 0x49, 0xC9, 0xFD, 0x59, + 0x86, 0xAB, 0xD1, 0x9F, 0x40, 0x1E, 0xE2, 0x4E, + 0xDA, 0x36, 0x02, 0x04, 0x2A, 0xD3, 0x83, 0x35, + 0x7A, 0x31, 0x7D, 0x38, 0x07, 0x3B, 0x38, 0xCE + }, + { + 0xB4, 0xF7, 0x99, 0x63, 0xCA, 0x31, 0xBB, 0x62, + 0x26, 0x5D, 0xD9, 0x29, 0xAF, 0x7D, 0x51, 0x27, + 0x2F, 0xA6, 0x63, 0x1D, 0xE7, 0xFA, 0x35, 0xF7, + 0xA6, 0xB0, 0x3F, 0x9F, 0xCF, 0xDB, 0x8E, 0x3B, + 0x5B, 0xAC, 0xE3, 0x35, 0x91, 0xB7, 0xEC, 0x2C, + 0xFA, 0xB4, 0x9C, 0x91, 0xA6, 0xDB, 0x1F, 0xF8, + 0xF6, 0x78, 0x6D, 0x08, 0xF4, 0x4E, 0x80, 0x62, + 0xD2, 0xFF, 0x69, 0x6A, 0x7D, 0x98, 0x41, 0x42 + }, + { + 0x40, 0x84, 0x83, 0x69, 0x7B, 0xB6, 0xF9, 0xD0, + 0x11, 0xA1, 0xF2, 0x9A, 0x23, 0xC2, 0x78, 0xA8, + 0x1D, 0x37, 0x57, 0x8D, 0xCC, 0xCF, 0x42, 0x3B, + 0xDF, 0x48, 0x93, 0x37, 0xF1, 0x82, 0xEA, 0xB7, + 0x9A, 0x50, 0xB0, 0x5F, 0x3D, 0x2C, 0xCC, 0x49, + 0x13, 0x37, 0xC7, 0xE4, 0x1F, 0x30, 0x79, 0x3B, + 0xD2, 0x7D, 0x76, 0x61, 0xC2, 0xE3, 0x04, 0xC9, + 0x46, 0xA5, 0xA4, 0x01, 0xAF, 0x8D, 0x94, 0x6F + }, + { + 0xEE, 0xB5, 0xAD, 0xE1, 0xAB, 0x97, 0xE7, 0x15, + 0x43, 0x43, 0xA4, 0x6E, 0xB4, 0xCD, 0xD2, 0xA7, + 0x73, 0xF3, 0x63, 0x01, 0xED, 0xC6, 0xA1, 0xBC, + 0x1D, 0xD6, 0x48, 0x0E, 0x08, 0xF5, 0x87, 0x65, + 0xCB, 0x93, 0x87, 0x82, 0x92, 0x3B, 0xC0, 0x1F, + 0x8E, 0x0C, 0x61, 0xC6, 0xBE, 0x0D, 0xD1, 0xAB, + 0x4C, 0x18, 0xCB, 0x15, 0xED, 0x52, 0x10, 0x11, + 0x24, 0x05, 0xF1, 0xEA, 0x8F, 0x2E, 0x8C, 0x4E + }, + { + 0x71, 0x4A, 0xD1, 0x85, 0xF1, 0xEE, 0xC4, 0x3F, + 0x46, 0xB6, 0x7E, 0x99, 0x2D, 0x2D, 0x38, 0xBC, + 0x31, 0x49, 0xE3, 0x7D, 0xA7, 0xB4, 0x47, 0x48, + 0xD4, 0xD1, 0x4C, 0x16, 0x1E, 0x08, 0x78, 0x02, + 0x04, 0x42, 0x14, 0x95, 0x79, 0xA8, 0x65, 0xD8, + 0x04, 0xB0, 0x49, 0xCD, 0x01, 0x55, 0xBA, 0x98, + 0x33, 0x78, 0x75, 0x7A, 0x13, 0x88, 0x30, 0x1B, + 0xDC, 0x0F, 0xAE, 0x2C, 0xEA, 0xEA, 0x07, 0xDD + }, + { + 0x22, 0xB8, 0x24, 0x9E, 0xAF, 0x72, 0x29, 0x64, + 0xCE, 0x42, 0x4F, 0x71, 0xA7, 0x4D, 0x03, 0x8F, + 0xF9, 0xB6, 0x15, 0xFB, 0xA5, 0xC7, 0xC2, 0x2C, + 0xB6, 0x27, 0x97, 0xF5, 0x39, 0x82, 0x24, 0xC3, + 0xF0, 0x72, 0xEB, 0xC1, 0xDA, 0xCB, 0xA3, 0x2F, + 0xC6, 0xF6, 0x63, 0x60, 0xB3, 0xE1, 0x65, 0x8D, + 0x0F, 0xA0, 0xDA, 0x1E, 0xD1, 0xC1, 0xDA, 0x66, + 0x2A, 0x20, 0x37, 0xDA, 0x82, 0x3A, 0x33, 0x83 + }, + { + 0xB8, 0xE9, 0x03, 0xE6, 0x91, 0xB9, 0x92, 0x78, + 0x25, 0x28, 0xF8, 0xDB, 0x96, 0x4D, 0x08, 0xE3, + 0xBA, 0xAF, 0xBD, 0x08, 0xBA, 0x60, 0xC7, 0x2A, + 0xEC, 0x0C, 0x28, 0xEC, 0x6B, 0xFE, 0xCA, 0x4B, + 0x2E, 0xC4, 0xC4, 0x6F, 0x22, 0xBF, 0x62, 0x1A, + 0x5D, 0x74, 0xF7, 0x5C, 0x0D, 0x29, 0x69, 0x3E, + 0x56, 0xC5, 0xC5, 0x84, 0xF4, 0x39, 0x9E, 0x94, + 0x2F, 0x3B, 0xD8, 0xD3, 0x86, 0x13, 0xE6, 0x39 + }, + { + 0xD5, 0xB4, 0x66, 0xFF, 0x1F, 0xD6, 0x8C, 0xFA, + 0x8E, 0xDF, 0x0B, 0x68, 0x02, 0x44, 0x8F, 0x30, + 0x2D, 0xCC, 0xDA, 0xF5, 0x66, 0x28, 0x78, 0x6B, + 0x9D, 0xA0, 0xF6, 0x62, 0xFD, 0xA6, 0x90, 0x26, + 0x6B, 0xD4, 0x0A, 0xB6, 0xF0, 0xBE, 0xC0, 0x43, + 0xF1, 0x01, 0x28, 0xB3, 0x3D, 0x05, 0xDB, 0x82, + 0xD4, 0xAB, 0x26, 0x8A, 0x4F, 0x91, 0xAC, 0x42, + 0x86, 0x79, 0x5F, 0xC0, 0xF7, 0xCB, 0x48, 0x5C + }, + { + 0x0A, 0x1E, 0x8C, 0x0A, 0x8C, 0x48, 0xB8, 0x4B, + 0x71, 0xBA, 0x0F, 0xE5, 0x6F, 0xA0, 0x56, 0x09, + 0x8C, 0xA6, 0x92, 0xE9, 0x2F, 0x27, 0x6E, 0x85, + 0xB3, 0x38, 0x26, 0xCD, 0x78, 0x75, 0xFC, 0xF8, + 0x83, 0x85, 0x13, 0x1B, 0x43, 0xDF, 0x74, 0x53, + 0x2E, 0xAA, 0x86, 0xCF, 0x17, 0x1F, 0x50, 0x76, + 0xE6, 0xD1, 0x7B, 0x1C, 0x75, 0xFB, 0xA1, 0xDB, + 0x00, 0x1B, 0x6E, 0x66, 0x97, 0x7C, 0xB8, 0xD7 + }, + { + 0x65, 0xAA, 0x17, 0x99, 0x14, 0x36, 0x93, 0xAB, + 0xD9, 0xCB, 0x21, 0x8D, 0x9B, 0x5E, 0xC6, 0x0C, + 0x0E, 0xDD, 0xB0, 0x67, 0xE6, 0xA3, 0x2F, 0x76, + 0x79, 0x60, 0x10, 0xAC, 0xB1, 0x1A, 0xD0, 0x13, + 0x6C, 0xE4, 0x9F, 0x97, 0x6E, 0x74, 0xF8, 0x95, + 0x04, 0x2F, 0x7C, 0xBF, 0x13, 0xFB, 0x73, 0xD1, + 0x9D, 0xC8, 0x89, 0xD7, 0xE9, 0x03, 0x46, 0x9D, + 0xEB, 0x33, 0x73, 0x1F, 0x24, 0x06, 0xB6, 0x63 + }, + { + 0xDE, 0xB7, 0x12, 0xB9, 0xCC, 0x64, 0xF5, 0x88, + 0x14, 0x86, 0x0B, 0x51, 0xFA, 0x89, 0xAD, 0x8A, + 0x92, 0x6A, 0x69, 0x08, 0xC7, 0x96, 0xDE, 0x55, + 0x7F, 0x90, 0xCF, 0xAD, 0xB0, 0xC6, 0x2C, 0x07, + 0x87, 0x2F, 0x33, 0xFE, 0x18, 0x4E, 0x5E, 0x21, + 0x2A, 0x3C, 0x5C, 0x37, 0x31, 0x74, 0x18, 0x44, + 0x6E, 0xFD, 0x95, 0x61, 0x3F, 0x61, 0x8A, 0x35, + 0xF7, 0xD2, 0x78, 0x9E, 0xFE, 0x0D, 0x96, 0x60 + }, + { + 0xB4, 0x2F, 0x4A, 0x40, 0xB3, 0xC8, 0x8B, 0xCE, + 0xCF, 0xE3, 0x28, 0xC8, 0x46, 0xBF, 0x06, 0x48, + 0xA1, 0x69, 0x90, 0xCA, 0x53, 0x91, 0x95, 0xC0, + 0xC1, 0xDC, 0x8D, 0x70, 0x30, 0x80, 0x67, 0x68, + 0x5A, 0xF6, 0x77, 0xAD, 0x65, 0xAC, 0x0C, 0x7A, + 0x9B, 0xCF, 0xA8, 0xF7, 0xAC, 0xC0, 0xAA, 0xCF, + 0x45, 0xCA, 0x18, 0xAC, 0x83, 0x1F, 0xED, 0x64, + 0x4E, 0xC3, 0xD9, 0x28, 0x31, 0x01, 0xFF, 0xEF + }, + { + 0xED, 0xCF, 0x6C, 0x81, 0xCC, 0xF1, 0x6E, 0x11, + 0xDD, 0xF7, 0x19, 0xA3, 0x3D, 0xD0, 0xE5, 0x34, + 0x9C, 0xAB, 0xAC, 0x5C, 0xFA, 0xE5, 0x97, 0x00, + 0x98, 0x40, 0xE1, 0xC3, 0x93, 0x62, 0xC0, 0xF1, + 0x19, 0x82, 0xFE, 0x2C, 0x27, 0x65, 0x85, 0x9A, + 0x94, 0x26, 0x2D, 0xA2, 0x8D, 0xD3, 0x37, 0x3D, + 0x52, 0x26, 0x93, 0x89, 0x75, 0x11, 0xEB, 0xA5, + 0xE0, 0x7B, 0x8B, 0xC6, 0xB6, 0x06, 0x4D, 0xC0 + }, + { + 0x46, 0xB9, 0x62, 0xD2, 0x28, 0x36, 0x94, 0xD2, + 0x79, 0x75, 0xDC, 0xBF, 0x32, 0x56, 0x4C, 0x9B, + 0x04, 0x03, 0x2B, 0x30, 0xA9, 0x3E, 0x05, 0x8F, + 0xB7, 0x7B, 0x2B, 0x71, 0x8B, 0x4A, 0xD5, 0xFB, + 0x78, 0x9A, 0xB7, 0xD7, 0xAA, 0x90, 0x85, 0x2D, + 0xA2, 0xBF, 0xB6, 0xB3, 0x93, 0xB0, 0x9F, 0x98, + 0xE8, 0x69, 0xB1, 0x6E, 0x41, 0x0E, 0x7D, 0xE2, + 0x30, 0xB1, 0x79, 0xF6, 0x2E, 0xB5, 0x74, 0x71 + }, + { + 0x29, 0x03, 0x6C, 0x3F, 0x53, 0x82, 0xE3, 0x5D, + 0xE7, 0xA6, 0x9F, 0xA7, 0xA6, 0x3E, 0xC7, 0xBD, + 0xCB, 0xC4, 0xE0, 0xCC, 0x5A, 0x7B, 0x64, 0x14, + 0xCF, 0x44, 0xBF, 0x9A, 0x83, 0x83, 0xEF, 0xB5, + 0x97, 0x23, 0x50, 0x6F, 0x0D, 0x51, 0xAD, 0x50, + 0xAC, 0x1E, 0xAC, 0xF7, 0x04, 0x30, 0x8E, 0x8A, + 0xEC, 0xB9, 0x66, 0xF6, 0xAC, 0x94, 0x1D, 0xB1, + 0xCD, 0xE4, 0xB5, 0x9E, 0x84, 0xC1, 0xEB, 0xBA + }, + { + 0x17, 0x3F, 0x8A, 0xB8, 0x93, 0x3E, 0xB0, 0x7C, + 0xC5, 0xFD, 0x6E, 0x4B, 0xCE, 0xBA, 0xE1, 0xFF, + 0x35, 0xC7, 0x87, 0x9B, 0x93, 0x8A, 0x5A, 0x15, + 0x79, 0xEA, 0x02, 0xF3, 0x83, 0x32, 0x48, 0x86, + 0xC7, 0x0E, 0xD9, 0x10, 0x9D, 0xE1, 0x69, 0x0B, + 0x8E, 0xE8, 0x01, 0xBC, 0x95, 0x9B, 0x21, 0xD3, + 0x81, 0x17, 0xEB, 0xB8, 0x4A, 0xB5, 0x6F, 0x88, + 0xF8, 0xA3, 0x72, 0x62, 0x00, 0x2D, 0xD9, 0x8E + }, + { + 0xC6, 0xAF, 0xA6, 0xA1, 0x91, 0x93, 0x1F, 0xD4, + 0x5C, 0x3B, 0xAD, 0xBA, 0x72, 0x6E, 0x68, 0xA9, + 0xBC, 0x73, 0x88, 0xC8, 0xCF, 0x37, 0xAD, 0xEC, + 0x7C, 0x64, 0x56, 0x1C, 0xF4, 0x81, 0xFD, 0x25, + 0x9A, 0x64, 0x6C, 0x8B, 0xD8, 0x43, 0xE7, 0x70, + 0x9E, 0x11, 0xE6, 0x4D, 0xCF, 0xD5, 0xDF, 0xFF, + 0xED, 0x79, 0x23, 0x5C, 0x68, 0x9B, 0x42, 0x00, + 0xFE, 0x7A, 0xC8, 0xDF, 0xDA, 0xDD, 0xEC, 0xE0 + }, + { + 0xA6, 0xDC, 0xCD, 0x8C, 0x19, 0x26, 0x64, 0x88, + 0xBF, 0x77, 0xB9, 0xF2, 0x4B, 0x91, 0x43, 0xDE, + 0xF1, 0xFE, 0xD6, 0x1D, 0x0C, 0x60, 0xB5, 0x00, + 0x0A, 0x52, 0x3F, 0x45, 0x0D, 0xA2, 0x3D, 0x74, + 0xE4, 0xE3, 0xF6, 0xEF, 0x04, 0x09, 0x0D, 0x10, + 0x66, 0xB6, 0xAC, 0xE8, 0x5A, 0xBC, 0x0F, 0x03, + 0x01, 0x73, 0xF5, 0x28, 0x17, 0x72, 0x7C, 0x4E, + 0x40, 0x43, 0x2D, 0xD3, 0x4C, 0x6E, 0xF9, 0xF0 + }, + { + 0xAA, 0xF8, 0x90, 0x8D, 0x54, 0x6E, 0x4F, 0x1E, + 0x31, 0x4C, 0x00, 0xE9, 0xD2, 0xE8, 0x85, 0x5C, + 0xB2, 0x56, 0x44, 0x5A, 0xAE, 0x3E, 0xCA, 0x44, + 0x23, 0x83, 0x22, 0xAE, 0xC7, 0x40, 0x34, 0xA1, + 0x45, 0x8A, 0x29, 0x36, 0x75, 0xDA, 0xD9, 0x49, + 0x40, 0x8D, 0xE5, 0x55, 0x4F, 0x22, 0xD7, 0x34, + 0x54, 0xF3, 0xF0, 0x70, 0x9C, 0xBC, 0xCC, 0x85, + 0xCB, 0x05, 0x3A, 0x6F, 0x50, 0x38, 0x91, 0xA1 + }, + { + 0x52, 0x5F, 0x4A, 0xAB, 0x9C, 0x32, 0x7D, 0x2A, + 0x6A, 0x3C, 0x9D, 0xF8, 0x1F, 0xB7, 0xBE, 0x97, + 0xEE, 0x03, 0xE3, 0xF7, 0xCE, 0x33, 0x21, 0x1C, + 0x47, 0x78, 0x8A, 0xCD, 0x13, 0x46, 0x40, 0xDD, + 0x90, 0xAD, 0x74, 0x99, 0x2D, 0x3D, 0xD6, 0xAC, + 0x80, 0x63, 0x50, 0xF3, 0xBA, 0xBC, 0x7F, 0xE1, + 0x98, 0xA6, 0x1D, 0xB3, 0x2D, 0x4A, 0xD1, 0xD6, + 0x56, 0x9A, 0xE8, 0x41, 0x31, 0x04, 0xDE, 0xA4 + }, + { + 0x2D, 0xAC, 0xCD, 0x88, 0x71, 0x9D, 0x0A, 0x00, + 0xB5, 0x2C, 0x6E, 0xB7, 0x9E, 0x1C, 0xA8, 0xB4, + 0xA1, 0xB4, 0xB4, 0x4F, 0xFA, 0x20, 0x88, 0x9F, + 0x23, 0x63, 0xEF, 0x5C, 0x0D, 0x73, 0x7F, 0x1F, + 0x81, 0xF5, 0x0D, 0xA1, 0xCA, 0xAC, 0x23, 0x1D, + 0x6F, 0xCB, 0x48, 0x89, 0x5E, 0x72, 0x99, 0xB7, + 0x7A, 0xF8, 0x1F, 0x0A, 0xA4, 0xA7, 0x61, 0x8A, + 0xD2, 0x4B, 0x7A, 0xAF, 0xC8, 0xE3, 0xA2, 0xBE + }, + { + 0x7D, 0x28, 0x6F, 0x1F, 0x72, 0x1E, 0xC2, 0xD2, + 0x11, 0x5E, 0xF4, 0xCC, 0xD8, 0x28, 0x58, 0xA4, + 0xD5, 0x12, 0x21, 0x13, 0x55, 0xD4, 0xFC, 0x58, + 0xE5, 0x34, 0xBF, 0xA5, 0x9C, 0x2E, 0x1B, 0xF5, + 0x52, 0xA9, 0x6D, 0xC4, 0xB3, 0xE4, 0x6B, 0x01, + 0x28, 0x65, 0xDA, 0x88, 0x13, 0x4C, 0xF0, 0x4E, + 0x73, 0x1B, 0x19, 0x30, 0x75, 0x9E, 0x15, 0x8F, + 0xF6, 0x20, 0xB6, 0xEC, 0x5A, 0xAF, 0xD0, 0x12 + }, + { + 0x21, 0x82, 0x6B, 0x95, 0x29, 0xC4, 0xBC, 0x51, + 0x91, 0x47, 0xF5, 0xF9, 0xFE, 0x6D, 0xB8, 0x78, + 0x34, 0x52, 0x15, 0xE5, 0x09, 0x4F, 0x4E, 0x99, + 0xB1, 0x31, 0xED, 0x54, 0xE2, 0x49, 0x53, 0xCE, + 0xE9, 0xAD, 0xB7, 0x18, 0xD1, 0x74, 0x3E, 0x6C, + 0x27, 0xFC, 0x94, 0x51, 0x6A, 0x99, 0x22, 0xFB, + 0x97, 0x5A, 0x78, 0x16, 0xB8, 0xAA, 0xB0, 0x21, + 0x12, 0x60, 0x8C, 0x03, 0x2B, 0xF1, 0x38, 0xE3 + }, + { + 0xC1, 0x68, 0x9C, 0x69, 0x8A, 0xB0, 0x65, 0xF6, + 0x2E, 0xEE, 0x65, 0xDD, 0xCA, 0x67, 0x6B, 0xAA, + 0x45, 0xB5, 0x2F, 0x30, 0x8A, 0xFA, 0x80, 0x4A, + 0xB4, 0xAA, 0x6A, 0xB8, 0x4B, 0x7A, 0xC1, 0xAA, + 0x1D, 0xFF, 0x07, 0x17, 0x56, 0x10, 0xB1, 0x2A, + 0xE1, 0x1F, 0x27, 0xB7, 0xC4, 0x30, 0xAF, 0xD5, + 0x75, 0x56, 0xBD, 0x18, 0x1D, 0x02, 0x83, 0x2C, + 0xD8, 0xD0, 0xA5, 0xFD, 0xC3, 0x02, 0x01, 0x24 + }, + { + 0xA1, 0xA6, 0x28, 0x17, 0x47, 0xE3, 0x4D, 0x3E, + 0xDE, 0x5E, 0x93, 0x34, 0x01, 0x74, 0x7C, 0xA7, + 0xF7, 0x66, 0x28, 0xB6, 0x14, 0xC8, 0xA3, 0x94, + 0xF5, 0x02, 0x56, 0x2B, 0xFE, 0xE0, 0xB9, 0x94, + 0xEC, 0xB6, 0x5F, 0xBF, 0xE1, 0xFF, 0x70, 0x67, + 0xDC, 0xB0, 0x1D, 0x02, 0xA9, 0x2B, 0xA4, 0x62, + 0x20, 0x75, 0x87, 0xCE, 0xF7, 0xDC, 0x2C, 0xFD, + 0xB4, 0x58, 0x48, 0x48, 0xAD, 0x55, 0x91, 0x4A + }, + { + 0x00, 0x70, 0xA0, 0x19, 0x0A, 0xA6, 0x96, 0x57, + 0x2D, 0x85, 0x3F, 0x1D, 0x24, 0xAB, 0x63, 0x08, + 0x48, 0xAC, 0x56, 0xAD, 0x5C, 0x2E, 0xBF, 0xCF, + 0xDE, 0x27, 0xD1, 0x11, 0xCD, 0x55, 0x93, 0x9C, + 0x1E, 0x4D, 0x07, 0x87, 0x2D, 0xDE, 0x7C, 0xE7, + 0x8B, 0x53, 0x4B, 0x53, 0x0F, 0x0A, 0x39, 0x6E, + 0x86, 0xAF, 0x9D, 0x57, 0x53, 0x54, 0xB5, 0xD7, + 0xE3, 0x4A, 0xCD, 0xE1, 0x8C, 0xC7, 0x67, 0xAE + }, + { + 0x51, 0xB9, 0xB5, 0xED, 0x19, 0x3F, 0xD4, 0xB1, + 0xA3, 0xA9, 0x2B, 0x46, 0xBD, 0x4B, 0xD1, 0xF6, + 0xEC, 0x6B, 0x38, 0xA6, 0x0F, 0x2D, 0x02, 0x61, + 0xD7, 0x2A, 0xBF, 0xD1, 0x64, 0x36, 0x12, 0x8D, + 0xCB, 0xF2, 0x2C, 0x25, 0xE3, 0xE3, 0xC4, 0x3F, + 0xE4, 0xD2, 0x9D, 0xB9, 0x12, 0x4D, 0x03, 0x33, + 0x30, 0x18, 0x45, 0x92, 0xD2, 0x0C, 0x5B, 0x08, + 0x2C, 0x23, 0x20, 0x64, 0x54, 0xCB, 0x3D, 0xD7 + }, + { + 0x57, 0x8F, 0x24, 0x27, 0x46, 0x91, 0x4E, 0x36, + 0xD0, 0xD9, 0xD4, 0x80, 0x96, 0x89, 0x57, 0x12, + 0x16, 0xA4, 0x3E, 0x47, 0x33, 0x32, 0x39, 0x51, + 0x62, 0x0F, 0x5E, 0xE7, 0x8C, 0xCF, 0xEE, 0x91, + 0x9B, 0xF5, 0x5F, 0x28, 0x7B, 0x45, 0xA7, 0x3D, + 0x44, 0x85, 0xAC, 0x74, 0x22, 0x87, 0x92, 0x39, + 0x65, 0x3B, 0x05, 0x91, 0xC3, 0x6C, 0x86, 0x69, + 0x41, 0xF8, 0xAF, 0xFE, 0x4A, 0xE5, 0x6E, 0x9E + }, + { + 0x94, 0x71, 0x30, 0xEF, 0x0B, 0x94, 0x8E, 0xE0, + 0x45, 0x81, 0xAB, 0xA3, 0xE2, 0xCC, 0x4C, 0xEF, + 0xC3, 0x8C, 0xCE, 0xDC, 0x86, 0x17, 0x92, 0xB7, + 0xB5, 0xDC, 0xD9, 0xD9, 0x36, 0x1C, 0x72, 0x4A, + 0x12, 0x20, 0x03, 0xBF, 0x79, 0x6C, 0xE0, 0x97, + 0x98, 0x00, 0xAD, 0xAB, 0xC7, 0x45, 0x6F, 0x17, + 0x3A, 0xE5, 0x26, 0x93, 0x15, 0xAF, 0xC0, 0x1B, + 0x60, 0x6D, 0xB2, 0x9C, 0x75, 0x50, 0xE8, 0xCA + }, + { + 0xC8, 0x52, 0xE6, 0x77, 0xF7, 0x7B, 0x14, 0xB5, + 0x85, 0xBD, 0x10, 0x2A, 0x0F, 0x14, 0x42, 0x43, + 0x05, 0x9D, 0xAB, 0xEC, 0x7C, 0xB0, 0x1F, 0xFA, + 0x61, 0xDF, 0x19, 0xFC, 0xE8, 0xAB, 0x43, 0x6B, + 0xF5, 0xE2, 0xD5, 0xC7, 0x9A, 0xA2, 0xD7, 0xB6, + 0x77, 0xF6, 0xC3, 0x75, 0xE9, 0x34, 0x3D, 0x34, + 0x2E, 0x4F, 0xF4, 0xE3, 0xAB, 0x00, 0x1B, 0xC7, + 0x98, 0x8C, 0x3C, 0x7A, 0x83, 0xCC, 0xB6, 0x9F + }, + { + 0x01, 0x19, 0x75, 0x26, 0x91, 0x7A, 0xC2, 0xC7, + 0xBC, 0x53, 0x95, 0x19, 0xE6, 0x8B, 0xB2, 0x79, + 0x81, 0x35, 0xF6, 0x03, 0x3E, 0xD5, 0x8F, 0x5C, + 0x45, 0x1E, 0x0C, 0xE9, 0x46, 0xAF, 0xF0, 0xF9, + 0x8D, 0xFD, 0xD1, 0x51, 0x01, 0x73, 0x1A, 0xC1, + 0x66, 0x12, 0x6E, 0xAF, 0xB5, 0xE7, 0xCB, 0xE2, + 0xE2, 0x72, 0xEE, 0x23, 0x3F, 0x34, 0xE5, 0xF3, + 0xF8, 0xEA, 0x3D, 0x2D, 0x12, 0x24, 0x82, 0xFB + }, + { + 0x05, 0x9C, 0x90, 0x85, 0x89, 0x5E, 0xB7, 0x18, + 0x30, 0x4E, 0x2D, 0xDA, 0x78, 0x68, 0x6B, 0xD9, + 0x57, 0x49, 0x81, 0x5A, 0x5E, 0xE9, 0x02, 0x51, + 0x0B, 0x00, 0x9A, 0xF6, 0x92, 0x48, 0xB6, 0xA7, + 0xA7, 0x2F, 0xF8, 0xA6, 0x28, 0xD8, 0x17, 0x73, + 0xE1, 0x1D, 0x5A, 0x1E, 0x7F, 0x69, 0x7A, 0x44, + 0x9B, 0x7A, 0x1E, 0x27, 0x12, 0xD5, 0xCF, 0xAE, + 0x7A, 0xB2, 0x65, 0x07, 0xD1, 0x11, 0x29, 0x18 + }, + { + 0x29, 0x52, 0x43, 0xBD, 0x75, 0x8C, 0xF2, 0x1C, + 0x80, 0x31, 0x25, 0xFC, 0xF3, 0x21, 0xDE, 0x5F, + 0x97, 0x98, 0x7C, 0x8D, 0xB3, 0xBB, 0x3C, 0xB5, + 0x1F, 0xF9, 0x7C, 0x4C, 0xDA, 0xC9, 0xD3, 0xBF, + 0x0A, 0x67, 0xCE, 0xE7, 0xED, 0x35, 0x0A, 0x41, + 0xFD, 0xE6, 0xAB, 0xCC, 0x25, 0x4F, 0xBC, 0x9F, + 0x8E, 0x6B, 0x3E, 0x3C, 0xCE, 0xCB, 0xD0, 0xE4, + 0xA6, 0x40, 0xA2, 0x0F, 0x36, 0x2B, 0xA3, 0xA0 + }, + { + 0xDD, 0x82, 0x32, 0xD2, 0x41, 0x2C, 0xCE, 0xEC, + 0xB5, 0x12, 0x31, 0x91, 0xF6, 0xE9, 0x22, 0x1E, + 0x85, 0x1E, 0xCC, 0xE0, 0xFA, 0xEB, 0xF0, 0x50, + 0x5F, 0x2A, 0xEE, 0xFF, 0x8A, 0x8C, 0x92, 0xD4, + 0x1D, 0xAC, 0xF1, 0x77, 0xBD, 0xAE, 0x27, 0x76, + 0x3E, 0xA4, 0xA8, 0x62, 0x05, 0xEF, 0x76, 0x34, + 0xF7, 0xA6, 0x87, 0xCC, 0x44, 0xBB, 0xBB, 0xDE, + 0xEE, 0x5E, 0x11, 0xE6, 0x5F, 0x9F, 0xBD, 0x69 + }, + { + 0xB0, 0x46, 0xB6, 0x83, 0x71, 0x6D, 0x31, 0xC9, + 0x14, 0xC7, 0x0B, 0x10, 0xF7, 0x64, 0x6D, 0xA3, + 0x1E, 0xFA, 0xB2, 0x23, 0x63, 0x47, 0x45, 0x9C, + 0xF8, 0xFA, 0x2C, 0x09, 0x12, 0x34, 0x31, 0xF7, + 0x28, 0x07, 0xF1, 0x1D, 0x86, 0x7C, 0x37, 0x70, + 0xB1, 0xF0, 0x61, 0xD5, 0x6C, 0xA0, 0xE5, 0xB1, + 0xE8, 0x8A, 0x6B, 0x44, 0xA3, 0x3C, 0xF9, 0x3E, + 0x18, 0xBC, 0xC9, 0xCE, 0xBB, 0xA5, 0xAD, 0xE7 + }, + { + 0x20, 0xE5, 0xA2, 0x55, 0x05, 0x8B, 0xE5, 0x1E, + 0x1A, 0x62, 0x9B, 0x4E, 0xBF, 0x81, 0xE5, 0xCB, + 0xE0, 0x78, 0x1C, 0xB6, 0x7C, 0xA4, 0xE5, 0x7B, + 0xA8, 0x6B, 0x30, 0x88, 0x96, 0xBC, 0xE7, 0x38, + 0x20, 0xEB, 0x08, 0x43, 0x1C, 0xE8, 0xC9, 0xBC, + 0x58, 0x10, 0xCC, 0x8D, 0x8B, 0x9C, 0x9D, 0x6F, + 0xCF, 0x83, 0x4E, 0x42, 0xEA, 0x33, 0xEF, 0x73, + 0xCE, 0xC4, 0x7D, 0x71, 0x3B, 0x6D, 0x8D, 0xFD + }, + { + 0x1E, 0x48, 0x04, 0xF9, 0xC0, 0xB1, 0xE8, 0x2B, + 0x9E, 0xD3, 0x63, 0xBD, 0xE4, 0x47, 0x28, 0xAC, + 0xF7, 0xD0, 0x90, 0xA1, 0xBF, 0xE2, 0xDD, 0xF8, + 0x81, 0x9D, 0x65, 0x92, 0xEF, 0x45, 0x3B, 0x83, + 0x5B, 0xD2, 0xEF, 0xE8, 0xB0, 0x20, 0x6E, 0x29, + 0x25, 0x5B, 0x07, 0xFB, 0x90, 0xC7, 0xD3, 0x0D, + 0x2C, 0x11, 0x48, 0x00, 0xB8, 0x6C, 0xB0, 0xE3, + 0xE0, 0x7D, 0x38, 0x7E, 0x98, 0xCE, 0x95, 0x37 + }, + { + 0x41, 0xC9, 0x53, 0xD8, 0xD2, 0x2A, 0x86, 0xC3, + 0x63, 0x4D, 0xF4, 0x22, 0xB6, 0xDE, 0x4A, 0x4F, + 0x14, 0x96, 0x66, 0xBE, 0x8C, 0x4F, 0x58, 0x1B, + 0x26, 0x23, 0xEE, 0x65, 0xC3, 0x92, 0xA5, 0xC3, + 0x28, 0x36, 0x63, 0x9E, 0xF5, 0x6B, 0x93, 0x68, + 0x62, 0x20, 0xF4, 0x5C, 0xE6, 0x5B, 0x4F, 0xA8, + 0x58, 0x9C, 0x91, 0x25, 0x64, 0x17, 0x90, 0xB6, + 0x92, 0x5F, 0xAA, 0xD9, 0x48, 0xB8, 0xBE, 0x04 + }, + { + 0x8B, 0xFC, 0xA4, 0xC8, 0xDF, 0xE3, 0xFD, 0xE4, + 0x25, 0x7B, 0x75, 0xC3, 0xDB, 0x01, 0x86, 0x2E, + 0xD3, 0x11, 0x67, 0xDE, 0x66, 0xC2, 0xE0, 0x3A, + 0x25, 0x56, 0xC4, 0xF4, 0x6C, 0x9D, 0xFF, 0xC1, + 0xAC, 0x45, 0xF7, 0xBC, 0x59, 0xA6, 0x7A, 0xB9, + 0x36, 0x24, 0xBE, 0xB8, 0x6D, 0xDD, 0x0D, 0x02, + 0x60, 0x3F, 0x0D, 0xCD, 0x03, 0x64, 0xF0, 0xF8, + 0x08, 0x81, 0x9B, 0xE9, 0x6C, 0xD8, 0xD3, 0xB6 + }, + { + 0xF6, 0xBF, 0x59, 0xD8, 0xD4, 0x5A, 0x55, 0x71, + 0x11, 0xA2, 0x36, 0xCB, 0xBA, 0x52, 0x61, 0x9A, + 0xE3, 0xDF, 0xCC, 0x43, 0x16, 0x94, 0x38, 0x43, + 0xAF, 0xD1, 0x28, 0x1B, 0x28, 0x21, 0x4A, 0x4A, + 0x5E, 0x85, 0x1E, 0xF8, 0xC5, 0x4F, 0x50, 0x5E, + 0x3C, 0x4B, 0x60, 0x0E, 0xFF, 0xBE, 0xBB, 0x3E, + 0xAC, 0x17, 0x08, 0x7F, 0x22, 0x27, 0x58, 0x12, + 0x63, 0xF1, 0x7D, 0x7E, 0x5F, 0x68, 0xEA, 0x83 + }, + { + 0x1B, 0xC9, 0xED, 0xE4, 0xD4, 0x1A, 0x4D, 0xF6, + 0xE8, 0xE6, 0xF4, 0x7C, 0x2F, 0x4A, 0xD8, 0x73, + 0x37, 0xB6, 0x9B, 0x19, 0xF7, 0x10, 0xF7, 0x66, + 0xE1, 0xFA, 0xF5, 0xAA, 0x05, 0xA4, 0x3B, 0x66, + 0x45, 0x39, 0x6E, 0x7F, 0xBE, 0xF4, 0x3B, 0xB7, + 0x79, 0x5D, 0x39, 0x40, 0x7B, 0x58, 0x15, 0xB9, + 0x2E, 0xCC, 0x23, 0xA6, 0xC1, 0x24, 0x14, 0x21, + 0x15, 0x3A, 0x55, 0xD5, 0x1F, 0x12, 0xBF, 0xD8 + }, + { + 0x76, 0xB3, 0x8B, 0x36, 0x31, 0x55, 0x5D, 0xBC, + 0xFB, 0x21, 0x21, 0x8F, 0xF9, 0xE4, 0x12, 0xA2, + 0x29, 0x88, 0x9E, 0xF2, 0xCE, 0x8A, 0xD7, 0x05, + 0xE9, 0x0F, 0x96, 0xAA, 0xBB, 0xD5, 0xBE, 0x7E, + 0x53, 0x29, 0xA4, 0x26, 0x53, 0x4C, 0x81, 0x5A, + 0x56, 0x53, 0x77, 0x13, 0x18, 0x72, 0x66, 0x41, + 0x42, 0x4E, 0x3B, 0x88, 0x29, 0x2F, 0xB1, 0xD8, + 0x95, 0x44, 0x40, 0x6A, 0xDE, 0x9B, 0xCC, 0xB5 + }, + { + 0xE5, 0x3F, 0x60, 0x07, 0x40, 0x22, 0x4E, 0x4D, + 0x10, 0xD3, 0x1D, 0x24, 0x38, 0x00, 0x31, 0x43, + 0xAF, 0xDB, 0x43, 0x6E, 0xB1, 0x79, 0x1B, 0x15, + 0x0D, 0xE3, 0x56, 0x76, 0xF0, 0xE3, 0x2F, 0x80, + 0xB0, 0xB6, 0x5F, 0x0A, 0xCF, 0x48, 0x1A, 0x5F, + 0xBF, 0x95, 0x96, 0xC0, 0xCB, 0x0A, 0x27, 0xC7, + 0xAF, 0xC1, 0x1D, 0x1E, 0x2C, 0x4D, 0x54, 0x02, + 0x47, 0x5E, 0x4F, 0xFC, 0xC1, 0xCD, 0xA8, 0x11 + }, + { + 0x62, 0x06, 0xB9, 0x1F, 0xC0, 0xB6, 0xF1, 0x21, + 0x1E, 0x9F, 0xDE, 0xCD, 0xC9, 0xD5, 0x1A, 0x6F, + 0x1E, 0xEE, 0x65, 0x54, 0xB1, 0x38, 0xAD, 0xCD, + 0x4A, 0x82, 0x3D, 0xF0, 0x0D, 0xDE, 0xF6, 0x75, + 0x9A, 0x9B, 0xFD, 0x7A, 0x4E, 0x98, 0x1E, 0x04, + 0x52, 0x36, 0x83, 0x8F, 0x4A, 0xF6, 0x93, 0xF6, + 0x93, 0x77, 0x93, 0x14, 0x84, 0xB3, 0xE8, 0x1E, + 0x3E, 0x3B, 0xC2, 0xCB, 0x7E, 0xF7, 0x9F, 0xE9 + }, + { + 0x76, 0xFD, 0x02, 0xDA, 0xDD, 0x96, 0x3B, 0xC0, + 0x35, 0x39, 0x91, 0x46, 0xCE, 0x42, 0x98, 0x8C, + 0xC0, 0x99, 0xD3, 0xCF, 0x4D, 0x32, 0xDF, 0x5C, + 0x0B, 0xBF, 0x64, 0x10, 0x12, 0x46, 0xB1, 0xC7, + 0x08, 0xD1, 0x67, 0xE2, 0x95, 0x95, 0xD1, 0x1D, + 0x09, 0xB3, 0xF6, 0x34, 0x86, 0xB4, 0x05, 0x26, + 0xAC, 0x1D, 0xFE, 0x31, 0xBC, 0x22, 0xDE, 0xC7, + 0x0B, 0x74, 0x5E, 0x90, 0xE2, 0xEA, 0xAF, 0x5A + }, + { + 0xF0, 0xA1, 0xFB, 0xE3, 0x11, 0x63, 0xE4, 0x21, + 0x01, 0x50, 0x72, 0x18, 0x3D, 0x68, 0xEE, 0x51, + 0x91, 0xA9, 0x9C, 0xFD, 0xA1, 0x69, 0xBA, 0x5A, + 0x19, 0x54, 0xC9, 0xF3, 0x10, 0x7D, 0x4E, 0xCA, + 0x06, 0x3E, 0x13, 0x7A, 0x71, 0x14, 0xD3, 0x97, + 0xC9, 0xDB, 0x67, 0x2B, 0x9F, 0x47, 0x8D, 0x41, + 0xC3, 0x4E, 0x99, 0x1B, 0x06, 0x69, 0xA9, 0x51, + 0x53, 0x92, 0x90, 0xC8, 0xED, 0x65, 0xE4, 0x6A + }, + { + 0x13, 0xC7, 0x2A, 0x6A, 0xA5, 0x71, 0xB1, 0x43, + 0xDC, 0xCF, 0x45, 0xAD, 0xCD, 0x98, 0xEA, 0xE6, + 0x99, 0xA1, 0x54, 0xB1, 0x10, 0xF2, 0x5E, 0x7E, + 0x9E, 0x82, 0xB7, 0x65, 0xB9, 0xA0, 0x89, 0x23, + 0x68, 0x8E, 0x8E, 0x0F, 0xF3, 0x11, 0xA6, 0x8A, + 0x77, 0x1E, 0x14, 0x50, 0x96, 0xD6, 0x07, 0x76, + 0xC6, 0xD6, 0xEE, 0x70, 0xAD, 0x6F, 0x69, 0xFA, + 0x2B, 0x76, 0x77, 0x63, 0x40, 0x55, 0xA0, 0x0E + }, + { + 0x0E, 0x06, 0x2B, 0xFE, 0x81, 0x8E, 0xE1, 0x0F, + 0x33, 0x48, 0x1D, 0xEA, 0x43, 0x02, 0x8B, 0x2C, + 0xFB, 0xB4, 0x9E, 0xC9, 0x5E, 0x0F, 0x75, 0xA9, + 0xE1, 0x6D, 0x40, 0x4B, 0xC5, 0x19, 0xB9, 0xAD, + 0x50, 0xB4, 0xA7, 0x33, 0x69, 0x2C, 0xA5, 0x4E, + 0xFB, 0x68, 0x04, 0x69, 0xED, 0x83, 0xDD, 0xEF, + 0xBD, 0xDD, 0xB1, 0x39, 0x04, 0x2E, 0x0E, 0x1C, + 0x09, 0xC3, 0xEB, 0x79, 0x03, 0xFA, 0x08, 0xDF + }, + { + 0x45, 0x3B, 0xE4, 0xAA, 0xB9, 0xF4, 0x23, 0xB3, + 0x36, 0x52, 0xA0, 0xB5, 0xD0, 0x2A, 0x9A, 0xF8, + 0x55, 0xDD, 0x0D, 0x42, 0xDD, 0x83, 0x11, 0x0B, + 0xA3, 0xBC, 0x4B, 0x39, 0x94, 0xEA, 0x3F, 0x88, + 0x5A, 0x71, 0x30, 0x89, 0x75, 0x08, 0x9B, 0x49, + 0x03, 0xE2, 0xE4, 0xD6, 0xBA, 0x6D, 0xC2, 0xE8, + 0x40, 0x31, 0xFF, 0xE9, 0xC8, 0x56, 0x39, 0x75, + 0xC8, 0x61, 0x6A, 0xCA, 0x07, 0x42, 0xE8, 0x29 + }, + { + 0x53, 0x61, 0xE3, 0xE8, 0x93, 0xDD, 0x36, 0x0B, + 0xCB, 0xF5, 0x1C, 0x79, 0x3E, 0xC0, 0x92, 0xA6, + 0xB0, 0x52, 0x05, 0x4F, 0x5F, 0x00, 0x0B, 0x9F, + 0xCE, 0x50, 0x7B, 0x66, 0x45, 0xF8, 0xD4, 0x70, + 0x13, 0xA8, 0x70, 0x6A, 0x58, 0xD4, 0xB1, 0x06, + 0x29, 0xCC, 0x82, 0xB8, 0xD2, 0xD7, 0x96, 0xFD, + 0xD3, 0x7B, 0x60, 0x8A, 0x58, 0x79, 0x52, 0xD6, + 0x55, 0x3E, 0x01, 0xD1, 0xAF, 0x0E, 0x04, 0xB8 + }, + { + 0x74, 0xB5, 0x67, 0x39, 0xF0, 0x1F, 0x82, 0x09, + 0xA4, 0x04, 0x44, 0xDF, 0x4C, 0xCD, 0xEE, 0xEA, + 0x8F, 0x97, 0xE8, 0xE7, 0x6E, 0xFA, 0x3C, 0x04, + 0x33, 0x7F, 0x69, 0x94, 0x5C, 0x4D, 0x44, 0xC0, + 0x85, 0xF1, 0xF4, 0x78, 0x96, 0x96, 0x36, 0x1E, + 0x3C, 0x97, 0x77, 0x4A, 0x93, 0x5F, 0x86, 0x0D, + 0x67, 0x46, 0x86, 0xDC, 0xBA, 0x3D, 0x45, 0xEC, + 0xD8, 0x63, 0x9A, 0x64, 0xAE, 0xA0, 0x62, 0x1B + }, + { + 0xB4, 0xD3, 0x15, 0x87, 0xB9, 0x2B, 0x53, 0x61, + 0xCD, 0xC2, 0xD3, 0xC4, 0x10, 0x86, 0xC1, 0x55, + 0x3E, 0x7B, 0x55, 0xA1, 0xF6, 0x1E, 0x94, 0xD2, + 0xBC, 0x30, 0xBC, 0x25, 0x1D, 0xAF, 0x8A, 0x5E, + 0xBF, 0xC5, 0x07, 0x09, 0xCC, 0x04, 0xCB, 0xAF, + 0x4B, 0x3B, 0x4D, 0xA2, 0xD2, 0x6B, 0x81, 0x23, + 0x8F, 0xBA, 0x71, 0x8F, 0xA9, 0x17, 0x59, 0xB8, + 0x0B, 0xD3, 0x10, 0x3A, 0xEC, 0x11, 0xE0, 0x6F + }, + { + 0xAA, 0xF6, 0x12, 0x7F, 0x00, 0xA0, 0x3D, 0x96, + 0x40, 0x6B, 0x9F, 0xB4, 0xAC, 0x70, 0x16, 0x0D, + 0xB5, 0x22, 0x42, 0x9B, 0x5C, 0xD9, 0x4E, 0x7F, + 0xA0, 0x30, 0x3A, 0x74, 0x94, 0x78, 0xFE, 0x31, + 0x89, 0xC8, 0xEA, 0x23, 0x93, 0x0A, 0x66, 0x25, + 0x2A, 0x80, 0x26, 0x74, 0xDC, 0xAF, 0x77, 0x00, + 0x46, 0x82, 0x0D, 0xD9, 0x64, 0xC6, 0x6F, 0x0F, + 0x54, 0x75, 0x1A, 0x72, 0xF9, 0x7D, 0x9C, 0x35 + }, + { + 0x2C, 0x30, 0xD4, 0x8D, 0xF9, 0x98, 0x4E, 0x02, + 0xF7, 0x5A, 0x94, 0x54, 0x92, 0x17, 0x18, 0x4D, + 0xD0, 0x2A, 0xAD, 0x3B, 0x57, 0x68, 0x3D, 0x09, + 0xB5, 0xA8, 0xC2, 0xEF, 0x53, 0xA9, 0x6A, 0xFB, + 0x73, 0xFE, 0xB6, 0xF9, 0x14, 0xE2, 0xD8, 0x15, + 0xBB, 0x3B, 0x08, 0x65, 0x43, 0x32, 0xFC, 0xFE, + 0x79, 0xF8, 0x0E, 0xC5, 0xF0, 0x51, 0xDA, 0x10, + 0xD7, 0x21, 0x41, 0x3D, 0xDD, 0xE8, 0xFA, 0x60 + }, + { + 0x92, 0xE2, 0xC5, 0xF7, 0x5D, 0x0C, 0xEA, 0xFC, + 0x81, 0x8F, 0xA7, 0x93, 0x59, 0x39, 0xE4, 0x8B, + 0x91, 0x59, 0x41, 0xEF, 0x73, 0x4D, 0x75, 0x27, + 0x0E, 0xB3, 0x21, 0xBA, 0x20, 0x80, 0xEF, 0x6D, + 0x25, 0x5E, 0x90, 0xEF, 0x96, 0xC6, 0x4C, 0xFF, + 0x1D, 0x8C, 0x18, 0xF3, 0x3C, 0x2E, 0xAB, 0x10, + 0x7F, 0xEF, 0x53, 0xE0, 0xD8, 0xBB, 0x16, 0x05, + 0x16, 0x80, 0x74, 0x80, 0xFC, 0xBA, 0x53, 0x73 + }, + { + 0x6E, 0x03, 0xA9, 0x1E, 0x20, 0x44, 0x46, 0x27, + 0xE3, 0xD2, 0xE2, 0x22, 0x26, 0xCF, 0x47, 0x00, + 0x26, 0x69, 0x44, 0x34, 0xED, 0x64, 0x79, 0x82, + 0x8C, 0xB6, 0xDC, 0x8F, 0x27, 0x96, 0x0A, 0xEE, + 0xE2, 0xF4, 0xAB, 0x87, 0x2A, 0x5C, 0xA2, 0xF7, + 0xF6, 0x52, 0xF7, 0xDC, 0x77, 0xD5, 0xF9, 0x6D, + 0x85, 0x82, 0x8B, 0x8F, 0x9C, 0x2D, 0x6C, 0x23, + 0x9E, 0x79, 0x77, 0x24, 0xA1, 0x31, 0x31, 0xB1 + }, + { + 0xBA, 0x43, 0x2D, 0xB0, 0xA3, 0x31, 0xBB, 0x8C, + 0x39, 0xB1, 0x7B, 0xEE, 0x34, 0x46, 0x2B, 0x26, + 0xDD, 0xB7, 0xAD, 0x91, 0xB6, 0xC7, 0x5A, 0xEC, + 0x27, 0x65, 0xFB, 0xAE, 0x3A, 0x0E, 0x60, 0xEC, + 0x54, 0x6D, 0x45, 0xF8, 0xE5, 0x84, 0x37, 0xB9, + 0xD7, 0x7C, 0x3D, 0x2E, 0x8D, 0x7C, 0xE0, 0x69, + 0x73, 0x15, 0x66, 0x51, 0xD4, 0x08, 0x22, 0x2A, + 0xA2, 0x90, 0xCB, 0x58, 0xCA, 0xBC, 0x0A, 0xE5 + }, + { + 0x83, 0xA0, 0x1E, 0x23, 0xAB, 0x27, 0x7B, 0x1F, + 0xC2, 0x8C, 0xD8, 0xBB, 0x8D, 0xA7, 0xE9, 0x4C, + 0x70, 0xF1, 0xDE, 0xE3, 0x2D, 0x19, 0x55, 0xCE, + 0xE2, 0x50, 0xEE, 0x58, 0x41, 0x9A, 0x1F, 0xEE, + 0x10, 0xA8, 0x99, 0x17, 0x97, 0xCE, 0x3D, 0x20, + 0x93, 0x80, 0xCA, 0x9F, 0x98, 0x93, 0x39, 0xE2, + 0xD8, 0xA8, 0x1C, 0x67, 0xD7, 0x37, 0xD8, 0x28, + 0x8C, 0x7F, 0xAE, 0x46, 0x02, 0x83, 0x4A, 0x8B + }, + { + 0x0E, 0xA3, 0x21, 0x72, 0xCC, 0x19, 0x1D, 0xFC, + 0x13, 0x1C, 0xD8, 0x8A, 0xA0, 0x3F, 0xF4, 0x18, + 0x5C, 0x0B, 0xFA, 0x7B, 0x19, 0x11, 0x12, 0x19, + 0xEE, 0xCB, 0x45, 0xB0, 0xFF, 0x60, 0x4D, 0x3E, + 0xDB, 0x00, 0x55, 0x0A, 0xBB, 0xA1, 0x11, 0x52, + 0x2B, 0x77, 0xAE, 0x61, 0xC9, 0xA8, 0xD6, 0xE9, + 0x4F, 0xCA, 0x9D, 0x96, 0xC3, 0x8D, 0x6B, 0x7C, + 0xCE, 0x27, 0x52, 0xF0, 0xD0, 0xC3, 0x7E, 0x78 + }, + { + 0x54, 0xAD, 0xD6, 0x55, 0x2B, 0x08, 0x85, 0x8B, + 0x23, 0xD6, 0x64, 0x5F, 0x6C, 0xE7, 0x9E, 0x92, + 0xF3, 0x8B, 0x66, 0xAE, 0x91, 0x86, 0x77, 0xE6, + 0xD9, 0x1F, 0x71, 0x87, 0xC4, 0x16, 0x05, 0x24, + 0xDF, 0xA8, 0xD0, 0x1F, 0x00, 0xEA, 0x93, 0xDD, + 0x29, 0x9F, 0x3C, 0xC4, 0x09, 0x01, 0xBD, 0x33, + 0x27, 0xA0, 0xF1, 0x8C, 0xCD, 0x7B, 0x6B, 0x8E, + 0x4E, 0x47, 0xCD, 0x28, 0xCF, 0x83, 0x8F, 0xAB + }, + { + 0xEF, 0x84, 0x74, 0x6D, 0xC2, 0x01, 0x56, 0xB6, + 0x6B, 0xA5, 0xC7, 0x8A, 0x50, 0x83, 0x0A, 0xBD, + 0x2A, 0xEF, 0x90, 0xE6, 0x67, 0xB9, 0x7E, 0xB5, + 0x22, 0x91, 0xBC, 0x86, 0x9D, 0x8A, 0xA2, 0x45, + 0x59, 0xA1, 0x42, 0xC6, 0x8F, 0xEA, 0x2E, 0xF3, + 0x2A, 0xF2, 0x2D, 0xFC, 0xEA, 0x4C, 0x90, 0xB3, + 0xD4, 0x90, 0x8C, 0xC9, 0xEA, 0x5C, 0xFC, 0x4E, + 0x91, 0xBF, 0x11, 0xCE, 0x6A, 0x7E, 0x57, 0x61 + }, + { + 0x5A, 0x1B, 0xF3, 0x81, 0xA0, 0x41, 0x19, 0xF9, + 0x42, 0xE4, 0x63, 0xAB, 0xA2, 0xB1, 0x64, 0x38, + 0x82, 0x46, 0x8A, 0xEC, 0xC1, 0xB1, 0xAA, 0x1E, + 0x7B, 0xCA, 0xAB, 0x3B, 0x47, 0x8F, 0xC5, 0xF0, + 0x56, 0xF1, 0x0D, 0xA9, 0x03, 0x7D, 0x40, 0xFA, + 0x7F, 0x55, 0x70, 0x8E, 0x10, 0x3B, 0xDA, 0x96, + 0x5E, 0x92, 0x0C, 0xF6, 0x7C, 0xE3, 0xAD, 0xF7, + 0xE2, 0x00, 0xE8, 0x61, 0x01, 0x4D, 0xEC, 0xC6 + }, + { + 0xAC, 0xF7, 0x8A, 0xA3, 0x28, 0x45, 0x96, 0xF3, + 0x30, 0xB7, 0xE8, 0x47, 0x51, 0xB9, 0x4C, 0x31, + 0x4C, 0xD8, 0x36, 0x36, 0x27, 0xBA, 0x99, 0x78, + 0x81, 0x30, 0x85, 0x78, 0x87, 0x37, 0x59, 0x89, + 0x5D, 0x13, 0xDF, 0xFF, 0xA5, 0xE5, 0x74, 0x50, + 0x13, 0x61, 0xF0, 0x43, 0xC7, 0x4F, 0x57, 0xD2, + 0xD0, 0xF1, 0x5C, 0x7A, 0x41, 0xC7, 0xC4, 0x5E, + 0x3C, 0x09, 0xAD, 0x89, 0xD6, 0x99, 0xA9, 0x77 + }, + { + 0x18, 0xB3, 0xE9, 0x04, 0x38, 0x44, 0xD4, 0xF3, + 0xA2, 0xD0, 0x21, 0xF5, 0x4C, 0x38, 0xFA, 0xCC, + 0x36, 0x4F, 0x84, 0xBA, 0x10, 0x58, 0xF2, 0x10, + 0x09, 0xFC, 0x37, 0x1D, 0x2E, 0x4F, 0x38, 0xC7, + 0x27, 0x51, 0x8A, 0xAB, 0xA6, 0xA2, 0x9E, 0x0F, + 0xDA, 0xE6, 0xE7, 0x60, 0xA4, 0xF1, 0xA6, 0xD7, + 0x58, 0xEB, 0xE4, 0x2C, 0x2A, 0xFC, 0x9D, 0x2C, + 0xDC, 0x6D, 0xD5, 0x80, 0x77, 0x8C, 0x4B, 0x32 + }, + { + 0x18, 0x96, 0xB2, 0x31, 0x70, 0x33, 0xCF, 0x31, + 0x04, 0x68, 0x73, 0xD8, 0x7F, 0x26, 0xE6, 0xA4, + 0x2A, 0x9D, 0x77, 0x0B, 0xBA, 0xF6, 0xE0, 0x62, + 0xDF, 0x11, 0xF9, 0xB4, 0xA0, 0xEA, 0xB2, 0x75, + 0xAA, 0xB1, 0x2C, 0xAA, 0xC2, 0xD3, 0xF5, 0x29, + 0xEB, 0x20, 0xD0, 0x70, 0xFD, 0x84, 0x4D, 0x86, + 0xD0, 0xA5, 0x71, 0xCD, 0xF6, 0x28, 0x5F, 0x80, + 0xE2, 0x30, 0x8B, 0xB8, 0x2C, 0x6C, 0x5B, 0x3B + }, + { + 0x8C, 0x3D, 0xC4, 0x01, 0x94, 0xAA, 0x02, 0x1F, + 0x3C, 0x4A, 0x1F, 0x9A, 0x05, 0x5E, 0x4D, 0x41, + 0x9E, 0xB3, 0xA2, 0x6D, 0x4C, 0x2F, 0x1A, 0x8C, + 0x7E, 0x18, 0x8B, 0x73, 0x48, 0x13, 0x40, 0x80, + 0xB6, 0x3F, 0x6E, 0x57, 0x0A, 0xD1, 0x1C, 0x28, + 0x78, 0x66, 0x53, 0x55, 0x41, 0x9C, 0x10, 0x20, + 0xDE, 0x4B, 0x65, 0x5E, 0x7A, 0x6C, 0x2C, 0xCD, + 0xE9, 0x07, 0x2C, 0xD4, 0x27, 0xFE, 0x8C, 0x4E + }, + { + 0x70, 0xAE, 0x04, 0x30, 0xD5, 0x45, 0xEC, 0x42, + 0x7F, 0x85, 0x41, 0x21, 0x1D, 0x4F, 0xE0, 0x42, + 0xB9, 0x82, 0x3A, 0xCE, 0xC0, 0x4B, 0x15, 0xC9, + 0x0B, 0x7F, 0x4B, 0x8B, 0xDD, 0x3D, 0xC7, 0x85, + 0x19, 0x90, 0xF3, 0x70, 0xE7, 0x14, 0x16, 0x75, + 0x10, 0x66, 0x49, 0xD3, 0x91, 0x51, 0x09, 0x03, + 0x18, 0x23, 0x1E, 0x4D, 0xED, 0x51, 0x22, 0x5D, + 0x9A, 0x6F, 0xA6, 0xC4, 0x24, 0x69, 0x5D, 0xE2 + }, + { + 0x07, 0x33, 0x6C, 0x42, 0xBD, 0x51, 0x49, 0x0E, + 0xF8, 0x4D, 0xFB, 0xDF, 0xAB, 0x74, 0x66, 0xF6, + 0xB6, 0x39, 0x99, 0xA5, 0xC0, 0x88, 0x72, 0xDF, + 0xED, 0xA0, 0x20, 0x6F, 0xDA, 0x80, 0xB9, 0xA6, + 0x2D, 0xE7, 0x28, 0xE3, 0xE3, 0xC3, 0xFD, 0x6B, + 0x7D, 0x21, 0xA4, 0x38, 0xAA, 0xD1, 0xB8, 0xDD, + 0x22, 0x38, 0x63, 0xC0, 0xD2, 0x6A, 0xCA, 0x27, + 0x79, 0x01, 0x74, 0xD9, 0xD4, 0x42, 0xA6, 0x4C + }, + { + 0x79, 0x26, 0x70, 0x88, 0x59, 0xE6, 0xE2, 0xAB, + 0x68, 0xF6, 0x04, 0xDA, 0x69, 0xA9, 0xFB, 0x50, + 0x87, 0xBB, 0x33, 0xF4, 0xE8, 0xD8, 0x95, 0x73, + 0x0E, 0x30, 0x1A, 0xB2, 0xD7, 0xDF, 0x74, 0x8B, + 0x67, 0xDF, 0x0B, 0x6B, 0x86, 0x22, 0xE5, 0x2D, + 0xD5, 0x7D, 0x8D, 0x3A, 0xD8, 0x7D, 0x58, 0x20, + 0xD4, 0xEC, 0xFD, 0x24, 0x17, 0x8B, 0x2D, 0x2B, + 0x78, 0xD6, 0x4F, 0x4F, 0xBD, 0x38, 0x75, 0x82 + }, + { + 0x92, 0x80, 0xF4, 0xD1, 0x15, 0x70, 0x32, 0xAB, + 0x31, 0x5C, 0x10, 0x0D, 0x63, 0x62, 0x83, 0xFB, + 0xF4, 0xFB, 0xA2, 0xFB, 0xAD, 0x0F, 0x8B, 0xC0, + 0x20, 0x72, 0x1D, 0x76, 0xBC, 0x1C, 0x89, 0x73, + 0xCE, 0xD2, 0x88, 0x71, 0xCC, 0x90, 0x7D, 0xAB, + 0x60, 0xE5, 0x97, 0x56, 0x98, 0x7B, 0x0E, 0x0F, + 0x86, 0x7F, 0xA2, 0xFE, 0x9D, 0x90, 0x41, 0xF2, + 0xC9, 0x61, 0x80, 0x74, 0xE4, 0x4F, 0xE5, 0xE9 + }, + { + 0x55, 0x30, 0xC2, 0xD5, 0x9F, 0x14, 0x48, 0x72, + 0xE9, 0x87, 0xE4, 0xE2, 0x58, 0xA7, 0xD8, 0xC3, + 0x8C, 0xE8, 0x44, 0xE2, 0xCC, 0x2E, 0xED, 0x94, + 0x0F, 0xFC, 0x68, 0x3B, 0x49, 0x88, 0x15, 0xE5, + 0x3A, 0xDB, 0x1F, 0xAA, 0xF5, 0x68, 0x94, 0x61, + 0x22, 0x80, 0x5A, 0xC3, 0xB8, 0xE2, 0xFE, 0xD4, + 0x35, 0xFE, 0xD6, 0x16, 0x2E, 0x76, 0xF5, 0x64, + 0xE5, 0x86, 0xBA, 0x46, 0x44, 0x24, 0xE8, 0x85 + }, + { + 0xDA, 0x85, 0x0A, 0x2F, 0x54, 0xE9, 0x44, 0x89, + 0x17, 0xD0, 0xDC, 0xAA, 0x63, 0x93, 0x7B, 0x95, + 0xA4, 0xDA, 0x1E, 0xAC, 0x8A, 0xF4, 0xDD, 0xF2, + 0x11, 0x3E, 0x5C, 0x8B, 0x0D, 0x4D, 0xB2, 0x66, + 0x9A, 0xF3, 0xC2, 0xAC, 0xB0, 0x80, 0x3D, 0x05, + 0x32, 0x3F, 0x3E, 0xC5, 0x5A, 0xBD, 0x33, 0xBD, + 0xF9, 0xB2, 0xBE, 0x89, 0x0E, 0xE7, 0x9E, 0x7F, + 0x3F, 0xCE, 0x4E, 0x19, 0x86, 0x96, 0xA7, 0xA3 + }, + { + 0xF1, 0x60, 0x95, 0xDD, 0x9F, 0x1E, 0xEB, 0x77, + 0xD5, 0xB9, 0x2F, 0x4B, 0x1F, 0xAC, 0x3A, 0x2C, + 0x5D, 0xA6, 0xAE, 0x5D, 0x0A, 0xB3, 0xF2, 0x54, + 0xE2, 0xA7, 0xFE, 0x52, 0x67, 0x24, 0x11, 0xD0, + 0x1C, 0xFA, 0x6A, 0xC0, 0x5B, 0xF3, 0x9E, 0xF6, + 0x5F, 0x4B, 0x22, 0x26, 0x4B, 0x41, 0xC3, 0xF3, + 0x63, 0x56, 0x3A, 0xBF, 0x0E, 0x92, 0x42, 0x90, + 0xC1, 0xC6, 0x80, 0xB1, 0x8A, 0xA6, 0x5B, 0x44 + }, + { + 0x76, 0xD0, 0x0A, 0x09, 0xC5, 0xBD, 0xD3, 0x9E, + 0xD3, 0x28, 0x71, 0x72, 0x2C, 0xFA, 0x00, 0x47, + 0x67, 0x4B, 0xEC, 0x8D, 0x35, 0x17, 0x5A, 0xF9, + 0x0D, 0x7A, 0xE9, 0x10, 0x74, 0x40, 0xA2, 0xA0, + 0x63, 0x88, 0x56, 0xD8, 0x38, 0x4C, 0x81, 0x7D, + 0x77, 0x2A, 0x4A, 0x59, 0x7A, 0x89, 0x55, 0x49, + 0xC8, 0x48, 0x66, 0x37, 0x56, 0x31, 0xCB, 0xA0, + 0x42, 0xF0, 0xEF, 0x6F, 0xFE, 0xB8, 0x9D, 0x44 + }, + { + 0xA6, 0x51, 0x13, 0x7B, 0x2C, 0x47, 0xFB, 0x79, + 0x51, 0xE7, 0xBD, 0xA7, 0x15, 0x43, 0xA6, 0xEB, + 0xC6, 0x24, 0x2A, 0xCA, 0xB4, 0x34, 0x7D, 0x38, + 0x8B, 0xE8, 0x35, 0x0F, 0x0C, 0x3F, 0xA3, 0xDF, + 0x8D, 0x95, 0x2C, 0x7C, 0x8A, 0x3D, 0xAF, 0x01, + 0xE0, 0x6C, 0x1D, 0xA6, 0x94, 0x96, 0xBB, 0xA8, + 0xDE, 0x62, 0xD8, 0x6B, 0x50, 0x93, 0x25, 0x6F, + 0x77, 0xA1, 0x87, 0xB5, 0x3D, 0xB0, 0x39, 0x88 + }, + { + 0xF3, 0x2F, 0x15, 0x0C, 0x2D, 0x67, 0xC0, 0xC4, + 0x37, 0x40, 0x1B, 0x70, 0xF6, 0x0B, 0x38, 0xF0, + 0xA3, 0xA4, 0x70, 0x59, 0x03, 0x3E, 0x75, 0x05, + 0xE6, 0x9A, 0x1D, 0x30, 0x12, 0x96, 0x03, 0x0B, + 0xC9, 0xB2, 0x95, 0x19, 0xC7, 0xF8, 0xB7, 0xD5, + 0x9A, 0x71, 0xFA, 0xB9, 0x05, 0x57, 0xDC, 0x3D, + 0xC8, 0x23, 0xFA, 0xC9, 0x5B, 0x9E, 0x85, 0xE6, + 0x52, 0x52, 0x8C, 0xBF, 0xB0, 0x1B, 0x11, 0x78 + }, + { + 0x27, 0x02, 0x56, 0x61, 0x36, 0xC4, 0x92, 0xF4, + 0x10, 0x89, 0xB0, 0x60, 0x10, 0x84, 0x60, 0xFA, + 0x30, 0x22, 0xC9, 0xC2, 0x5D, 0x34, 0x3B, 0xCB, + 0xD8, 0xAF, 0x2A, 0xF1, 0x9C, 0x17, 0xEF, 0x4C, + 0xA9, 0xF2, 0x22, 0x4F, 0xE7, 0xC4, 0x70, 0x0A, + 0x10, 0x19, 0x8E, 0xE5, 0x24, 0x8F, 0x30, 0x0B, + 0x54, 0x8E, 0xBF, 0x5C, 0x8E, 0x71, 0x16, 0x32, + 0x0C, 0xC8, 0x93, 0xFF, 0x7E, 0x23, 0x1F, 0xFB + }, + { + 0xFF, 0xE6, 0x87, 0x9F, 0x46, 0xB6, 0x29, 0x2B, + 0x21, 0x96, 0x97, 0x2E, 0x3F, 0xDF, 0x4F, 0xE9, + 0xEA, 0x4A, 0x81, 0x6D, 0x18, 0x07, 0xA3, 0x1C, + 0xAE, 0xAD, 0x6A, 0xAC, 0x5F, 0x06, 0x3C, 0x8F, + 0xE8, 0x77, 0x79, 0x75, 0x59, 0xA7, 0x59, 0xA0, + 0x0F, 0x8B, 0xA8, 0xF6, 0x68, 0xD8, 0x96, 0x8F, + 0xB3, 0x1D, 0x8A, 0x3B, 0x84, 0x57, 0x35, 0x90, + 0x2C, 0x5E, 0x42, 0xE2, 0x89, 0xEE, 0x0B, 0x62 + }, + { + 0x14, 0x48, 0x84, 0x28, 0x68, 0x22, 0xC2, 0x51, + 0x2D, 0x61, 0xB0, 0x46, 0xE6, 0x74, 0xD8, 0x6B, + 0x26, 0x4E, 0x9C, 0xC6, 0x89, 0x3E, 0xFF, 0x36, + 0x73, 0x11, 0x24, 0xF5, 0x9D, 0x1A, 0x82, 0x00, + 0x1E, 0x63, 0xF3, 0xE8, 0x05, 0x1C, 0xFE, 0x52, + 0xE7, 0x59, 0x7E, 0x28, 0x73, 0x8E, 0x3C, 0x3A, + 0x70, 0xF1, 0xBE, 0xD9, 0x68, 0x0E, 0x2C, 0x0E, + 0xF3, 0x72, 0x8B, 0x10, 0xA5, 0x6E, 0xD9, 0x87 + }, + { + 0x17, 0xC3, 0xF1, 0x46, 0xEE, 0x8D, 0xEC, 0x3B, + 0xAF, 0xCB, 0x51, 0xC0, 0xDA, 0x37, 0xF1, 0x78, + 0x71, 0xF2, 0x34, 0xC4, 0xA0, 0xFB, 0x7F, 0xA6, + 0xD0, 0x70, 0x7A, 0x54, 0x3E, 0x3C, 0xBF, 0x3A, + 0xDB, 0x81, 0xE3, 0x0C, 0x1E, 0x0A, 0xE9, 0xE1, + 0xAC, 0xE7, 0x22, 0x3B, 0xDA, 0x99, 0xBD, 0x59, + 0x19, 0xA3, 0xCF, 0xCC, 0x92, 0xC6, 0xA7, 0x55, + 0xE4, 0x56, 0xF0, 0x93, 0x82, 0x3B, 0xD3, 0x3E + }, + { + 0x1B, 0x83, 0x7A, 0xF2, 0x33, 0xA8, 0xA6, 0x8B, + 0xE7, 0x09, 0x52, 0xF7, 0x83, 0xC4, 0x96, 0x1A, + 0x81, 0x52, 0xD1, 0xE0, 0xB0, 0xFA, 0x32, 0x5F, + 0xF0, 0x86, 0xEA, 0x5B, 0x5F, 0x13, 0x12, 0xB8, + 0x9C, 0x42, 0xE0, 0x1B, 0x8C, 0x3A, 0x47, 0x7C, + 0xB5, 0x40, 0xC0, 0x6B, 0x2F, 0x37, 0xEE, 0x0E, + 0x39, 0x24, 0xD7, 0x45, 0xB4, 0xFF, 0x5C, 0x6A, + 0xF7, 0xD6, 0x1E, 0x0E, 0x37, 0xAC, 0x19, 0x31 + }, + { + 0x78, 0x97, 0x88, 0x0C, 0x1E, 0xB0, 0x0F, 0xD2, + 0x56, 0x7A, 0xE8, 0xA5, 0x9E, 0x64, 0x82, 0xAF, + 0xE1, 0x73, 0x49, 0xCF, 0x93, 0x92, 0x4A, 0x91, + 0x5F, 0x8C, 0x59, 0x26, 0x93, 0xD4, 0x52, 0x07, + 0x55, 0x19, 0x68, 0x9D, 0xFC, 0xD2, 0x93, 0xE3, + 0x76, 0x89, 0x7B, 0x3B, 0x0E, 0x03, 0x6F, 0x11, + 0x4F, 0xE8, 0x1E, 0xBC, 0xB3, 0x15, 0x36, 0x71, + 0xBD, 0x23, 0xBC, 0x2B, 0xED, 0x46, 0xF9, 0xC2 + }, + { + 0xCA, 0x7B, 0x6C, 0x77, 0x5D, 0x20, 0x1E, 0x5B, + 0x5A, 0x77, 0x22, 0x61, 0xDE, 0x52, 0x8E, 0x47, + 0x5F, 0x4B, 0xDE, 0x51, 0x76, 0x60, 0x52, 0x9F, + 0x41, 0xBE, 0xEB, 0x15, 0x78, 0xB2, 0x4B, 0xCB, + 0x94, 0xB9, 0x41, 0x0F, 0x9B, 0xF3, 0x36, 0xC1, + 0x09, 0xF9, 0xD4, 0x70, 0x93, 0xA1, 0x0B, 0xA6, + 0xDE, 0xBE, 0x50, 0x43, 0x80, 0xD9, 0xD1, 0x50, + 0x73, 0xBD, 0xD1, 0x11, 0xC8, 0xD1, 0x29, 0xFA + }, + { + 0x57, 0x18, 0xE0, 0xD4, 0x5D, 0xEB, 0xC3, 0x00, + 0x2D, 0x52, 0xB2, 0x2C, 0x52, 0x73, 0x29, 0xAE, + 0x5E, 0xBF, 0x27, 0xE8, 0xFA, 0x9C, 0x8F, 0xEA, + 0xB4, 0x6C, 0x40, 0xBC, 0x64, 0x22, 0xCA, 0x03, + 0x35, 0x30, 0x4C, 0xF9, 0xE7, 0xF1, 0x41, 0xDE, + 0x7F, 0xA6, 0xAD, 0xB6, 0x78, 0x9B, 0xDB, 0xF3, + 0x8D, 0x14, 0xDA, 0xBA, 0x3E, 0x62, 0x97, 0xD2, + 0x5B, 0xF1, 0x7D, 0xE1, 0x70, 0xD6, 0xE3, 0xC8 + }, + { + 0x48, 0xD0, 0xED, 0x24, 0x9F, 0x90, 0x28, 0x41, + 0x99, 0x7C, 0x25, 0x5D, 0xAF, 0x99, 0x08, 0x9C, + 0x9A, 0x31, 0x24, 0x69, 0x8B, 0x16, 0x4A, 0x30, + 0x28, 0x33, 0x0F, 0xDD, 0x4C, 0xEE, 0x41, 0xE1, + 0x68, 0x3F, 0xA4, 0xD9, 0xDC, 0x66, 0xB2, 0xA7, + 0x9C, 0x8A, 0xA4, 0xC8, 0x28, 0x4E, 0x27, 0xBE, + 0xE2, 0xA4, 0x28, 0xA6, 0x71, 0x9D, 0x6E, 0xC6, + 0x55, 0xED, 0x76, 0x9D, 0xCB, 0x62, 0x4E, 0x24 + }, + { + 0x79, 0x4E, 0x0B, 0x64, 0xAC, 0xE1, 0xFE, 0x5A, + 0xE3, 0x79, 0x93, 0x70, 0x68, 0xD8, 0x2D, 0xF0, + 0x48, 0x68, 0x61, 0x6C, 0xAE, 0x0C, 0x17, 0xD3, + 0x05, 0x72, 0xC2, 0x02, 0x4E, 0x77, 0x48, 0x94, + 0xE0, 0x66, 0x8C, 0x47, 0x2D, 0x62, 0x3C, 0x90, + 0x3C, 0xC5, 0x88, 0x5F, 0x17, 0x84, 0x94, 0x51, + 0x10, 0x32, 0x9E, 0xB4, 0x98, 0xA8, 0x95, 0xA9, + 0xE5, 0x9A, 0x75, 0xE5, 0x27, 0x15, 0x8A, 0x5C + }, + { + 0x21, 0x79, 0xAA, 0x82, 0x0E, 0x03, 0xFA, 0x33, + 0xD9, 0xBD, 0xE5, 0x56, 0x8C, 0x26, 0x2E, 0x2D, + 0x34, 0x17, 0xA4, 0x02, 0xE0, 0x7A, 0x59, 0x1F, + 0x9D, 0x55, 0x70, 0x68, 0x2D, 0xB5, 0xF9, 0xBB, + 0xA4, 0xBB, 0x9D, 0x5A, 0x82, 0xEE, 0x5E, 0xFD, + 0xB4, 0xF6, 0x5B, 0xBB, 0xFE, 0xEE, 0x2F, 0x4A, + 0xB9, 0xE4, 0x6C, 0xF2, 0xCE, 0x7E, 0x3B, 0x05, + 0x43, 0x27, 0xA7, 0x18, 0xD3, 0xF1, 0x08, 0x06 + }, + { + 0xB0, 0xA4, 0x8C, 0x6A, 0xDA, 0x54, 0x87, 0x25, + 0x79, 0x9B, 0x59, 0x86, 0xBA, 0xB4, 0x32, 0x69, + 0x79, 0x60, 0x92, 0x24, 0xD8, 0x97, 0x18, 0x4B, + 0x89, 0x97, 0x10, 0x4E, 0x0C, 0x6A, 0x24, 0xB3, + 0xAB, 0xE5, 0x62, 0x16, 0x54, 0x22, 0xA4, 0x5D, + 0x8A, 0xC8, 0x19, 0xB9, 0x9D, 0x37, 0x56, 0xEB, + 0xBB, 0x64, 0xF8, 0x43, 0xE3, 0xE0, 0x93, 0x4D, + 0xEC, 0x48, 0x7A, 0xED, 0x12, 0x13, 0x72, 0x79 + }, + { + 0x84, 0x8D, 0x7F, 0x2E, 0xAD, 0x41, 0x29, 0x1D, + 0x05, 0x38, 0x68, 0x0C, 0x64, 0x9D, 0x07, 0x89, + 0x7E, 0x45, 0xC7, 0x0A, 0x0A, 0xA4, 0xF9, 0x35, + 0x3F, 0x82, 0xC3, 0xF6, 0xFB, 0xB8, 0xE8, 0x48, + 0x9C, 0x75, 0x3E, 0x90, 0xDB, 0xE8, 0x89, 0x00, + 0x41, 0xA1, 0xAE, 0xEF, 0x84, 0xCD, 0x31, 0x36, + 0x43, 0x4F, 0x53, 0x0E, 0x9D, 0xD9, 0xC2, 0x3F, + 0xA5, 0x4F, 0xE1, 0x24, 0xEA, 0xFB, 0x72, 0xAD + }, + { + 0x0E, 0xD1, 0x46, 0x26, 0xEE, 0x6D, 0x0C, 0x8E, + 0xD3, 0xF0, 0xC2, 0x00, 0xC1, 0x29, 0x85, 0x0F, + 0xFF, 0x76, 0x31, 0x8F, 0xFF, 0xA1, 0xDD, 0xD7, + 0xDD, 0x56, 0x3A, 0x01, 0xB7, 0x77, 0x97, 0x06, + 0x86, 0x2B, 0x23, 0x99, 0x59, 0xB6, 0x15, 0xAE, + 0x2E, 0xBE, 0x27, 0xC4, 0x50, 0x37, 0xE6, 0xFF, + 0xAF, 0x99, 0x14, 0xDA, 0x8F, 0xF2, 0x77, 0x2B, + 0xA5, 0xEE, 0x08, 0x11, 0xCD, 0x9E, 0xD5, 0x32 + }, + { + 0x52, 0x03, 0xC0, 0x76, 0x38, 0xC4, 0xB6, 0x5F, + 0x78, 0x43, 0x1E, 0x8B, 0x02, 0xE2, 0x0F, 0x6D, + 0x68, 0x3F, 0x19, 0xFA, 0x8F, 0x83, 0xB5, 0x13, + 0x4C, 0xD0, 0xF4, 0xE4, 0x68, 0xC9, 0x7E, 0xAC, + 0xB5, 0x26, 0x7C, 0x7D, 0x3E, 0xAB, 0x58, 0x3C, + 0xCA, 0xAC, 0xD0, 0xDB, 0xA4, 0xD5, 0x8A, 0xCE, + 0x52, 0x19, 0x3A, 0x51, 0x78, 0xA7, 0xB1, 0x2D, + 0x27, 0x95, 0xF5, 0xFD, 0xE8, 0xA3, 0x7B, 0xB9 + }, + { + 0x48, 0xBE, 0x43, 0xD5, 0xE0, 0x04, 0x36, 0x88, + 0xDF, 0x35, 0x32, 0xF7, 0x12, 0x1A, 0xFF, 0xFA, + 0x16, 0x7D, 0xAB, 0xE4, 0xA4, 0x84, 0xFB, 0x75, + 0xA0, 0x3A, 0xF3, 0x04, 0xA5, 0xC6, 0xF8, 0x25, + 0xF3, 0x6C, 0xEC, 0xCB, 0xBB, 0xC0, 0x75, 0xEE, + 0xF3, 0x20, 0xC4, 0xCD, 0x8D, 0x7E, 0xF8, 0xCB, + 0x49, 0xE6, 0xDD, 0x59, 0x73, 0x37, 0x9E, 0xEC, + 0x4C, 0x23, 0x3C, 0x45, 0x43, 0xD1, 0x32, 0xCE + }, + { + 0xB5, 0x46, 0x4E, 0x6A, 0xBA, 0xF5, 0xD3, 0xD4, + 0x08, 0x3D, 0x1D, 0x7D, 0x2A, 0x8B, 0x0B, 0xAB, + 0x78, 0xB6, 0x17, 0x09, 0x50, 0x0B, 0xBF, 0x77, + 0x82, 0x3F, 0x60, 0x2D, 0x57, 0xD5, 0x13, 0xCA, + 0x9E, 0x9F, 0xFF, 0x65, 0xEF, 0xAA, 0x89, 0x9C, + 0xFE, 0x7B, 0xF8, 0x8A, 0x01, 0x88, 0x82, 0x9C, + 0x24, 0xE4, 0x98, 0xAD, 0x00, 0x23, 0x5A, 0xBE, + 0x8E, 0xEF, 0xA7, 0x19, 0xFA, 0x6A, 0xE6, 0xF6 + }, + { + 0xAF, 0xE5, 0xE5, 0xE8, 0x3F, 0x19, 0xAD, 0xAD, + 0x9E, 0x95, 0x90, 0x3E, 0xA9, 0xB2, 0x98, 0x10, + 0x7D, 0x37, 0xDD, 0x38, 0x63, 0x2C, 0x95, 0x90, + 0xBB, 0xFF, 0xC6, 0x24, 0xD4, 0xDE, 0x95, 0x8C, + 0xB6, 0xB6, 0x1A, 0xF0, 0x80, 0xF0, 0x37, 0xAD, + 0x17, 0xD0, 0x35, 0xB6, 0xBF, 0x58, 0xF7, 0x80, + 0xFA, 0xDF, 0x70, 0xF3, 0xC9, 0x59, 0x66, 0x8A, + 0x1B, 0x47, 0x21, 0x98, 0xA5, 0x9A, 0x8A, 0x00 + }, + { + 0xEF, 0xA2, 0xC7, 0xC8, 0x02, 0xE2, 0x10, 0xD2, + 0xD8, 0x0F, 0xB3, 0x50, 0xB3, 0xC2, 0xCB, 0x31, + 0x56, 0x13, 0x18, 0x11, 0xE7, 0x18, 0xEE, 0xE5, + 0xC9, 0xC6, 0x64, 0x0F, 0x87, 0x68, 0x2A, 0x55, + 0x81, 0x2B, 0x10, 0xF4, 0x03, 0x10, 0xBA, 0xA7, + 0xB8, 0x2B, 0x27, 0x3E, 0xF3, 0xAC, 0xC5, 0x5F, + 0xED, 0xE0, 0xB5, 0xF1, 0x94, 0x9D, 0xE4, 0x29, + 0x3D, 0x91, 0xB5, 0x89, 0xA2, 0x17, 0x5F, 0xF7 + }, + { + 0xD6, 0xC6, 0x2A, 0x61, 0x82, 0x71, 0xF3, 0xBC, + 0xBE, 0x00, 0x79, 0x24, 0xA0, 0xC9, 0x81, 0x2F, + 0x83, 0x17, 0x44, 0x5F, 0xB6, 0xFB, 0x19, 0xEB, + 0x58, 0x9A, 0x62, 0x9F, 0x51, 0x2F, 0xB3, 0x8A, + 0x0B, 0x4E, 0x24, 0x7D, 0xEA, 0x88, 0xC5, 0x6A, + 0x1B, 0xAF, 0x17, 0x88, 0x33, 0x65, 0xB4, 0x36, + 0xF2, 0x84, 0x46, 0xFF, 0x66, 0xEA, 0x43, 0x18, + 0x0B, 0xD0, 0x1E, 0xB5, 0xA6, 0x50, 0x9B, 0xD5 + }, + { + 0x0B, 0x41, 0x16, 0x6B, 0xE6, 0x2F, 0x65, 0xE1, + 0x93, 0xB3, 0xB8, 0x65, 0xE6, 0xC4, 0x7A, 0xAD, + 0x26, 0x0A, 0xF5, 0xFC, 0xEE, 0xC9, 0xAB, 0x44, + 0xAB, 0xAA, 0x46, 0x0A, 0x0C, 0x02, 0x46, 0xB6, + 0xC6, 0x9B, 0x67, 0xD7, 0x1D, 0x3A, 0xDF, 0xEC, + 0x60, 0xDC, 0x8E, 0x77, 0x37, 0x2F, 0x09, 0x49, + 0x52, 0x34, 0x4F, 0xE1, 0x0C, 0x0D, 0x59, 0xEF, + 0xEC, 0x0E, 0x11, 0xC4, 0xA5, 0x16, 0x93, 0x6D + }, + { + 0x79, 0xD5, 0xF9, 0xFF, 0xC0, 0x5E, 0xCF, 0x33, + 0x7D, 0xE9, 0xF1, 0xE0, 0xF1, 0xD8, 0x9B, 0x30, + 0xAC, 0xFE, 0xBB, 0xB8, 0x8A, 0x69, 0x35, 0x86, + 0x78, 0x18, 0xCD, 0x8D, 0x45, 0xDA, 0x3D, 0x25, + 0x18, 0xDE, 0x61, 0xA7, 0xFE, 0x28, 0x75, 0x1B, + 0x61, 0x8F, 0x7A, 0x87, 0x5E, 0x11, 0x89, 0x8F, + 0xFF, 0x74, 0x15, 0x7A, 0xB9, 0x06, 0x81, 0xBD, + 0x53, 0xFA, 0x69, 0x62, 0x67, 0x1E, 0xD9, 0x9D + }, + { + 0xBE, 0xA9, 0x83, 0xD7, 0x6F, 0x24, 0xB1, 0xEE, + 0xDE, 0x1D, 0x06, 0x71, 0x48, 0x05, 0x76, 0x8F, + 0xAA, 0xAD, 0x47, 0x08, 0xC9, 0xA4, 0xFF, 0x9C, + 0xD2, 0x42, 0x2F, 0x70, 0x6B, 0x6F, 0x0C, 0x30, + 0x6D, 0x8B, 0x67, 0xF3, 0x40, 0x89, 0xC6, 0x5E, + 0xD3, 0x88, 0x0C, 0x75, 0xF6, 0x7B, 0xBC, 0x4D, + 0x89, 0xAD, 0x87, 0x12, 0x0A, 0x77, 0xD0, 0xFF, + 0xE4, 0x36, 0xFB, 0x7B, 0x58, 0xB2, 0xCA, 0x41 + }, + { + 0x46, 0x6F, 0xD9, 0x15, 0xEF, 0xD9, 0x50, 0xBC, + 0x96, 0x65, 0x78, 0xCD, 0x92, 0xC6, 0x85, 0x92, + 0x9D, 0x7B, 0x51, 0xA6, 0x3D, 0xB1, 0x42, 0xC7, + 0xB9, 0xA9, 0x3D, 0x16, 0x52, 0x04, 0x95, 0x31, + 0x9B, 0x87, 0xF6, 0x58, 0xE6, 0xAF, 0xDA, 0x1B, + 0x42, 0x77, 0x3E, 0x2D, 0x49, 0xDA, 0x81, 0x45, + 0x94, 0xA5, 0x54, 0x90, 0x89, 0xEF, 0xB1, 0xF3, + 0xAB, 0x5F, 0x15, 0x90, 0xCA, 0x0A, 0x02, 0xAF + }, + { + 0xF6, 0x46, 0x11, 0x13, 0x7A, 0xD2, 0x95, 0x46, + 0x70, 0xEA, 0xEC, 0xD6, 0x26, 0xD2, 0x12, 0xCF, + 0xC5, 0xB9, 0xF6, 0xBB, 0x41, 0xAA, 0xEB, 0xB1, + 0xD7, 0x1E, 0x89, 0x79, 0x2E, 0xB1, 0x31, 0x7A, + 0xED, 0xC6, 0x38, 0x13, 0xFE, 0x63, 0xDE, 0x40, + 0x17, 0x98, 0xDF, 0x75, 0x6C, 0xA1, 0xF2, 0x20, + 0x35, 0xA0, 0xFA, 0xBD, 0x37, 0xFB, 0x11, 0x03, + 0x43, 0x7F, 0x89, 0x1E, 0xAD, 0x5E, 0x64, 0x29 + }, + { + 0x32, 0xE1, 0xF9, 0x38, 0xA2, 0x7F, 0xAA, 0xD8, + 0xAC, 0x4A, 0x13, 0xFD, 0x4F, 0x6A, 0x8B, 0xF3, + 0xDA, 0xBE, 0x4B, 0xC7, 0x2A, 0xF1, 0x1C, 0x8F, + 0x0E, 0x1A, 0x06, 0x56, 0x7E, 0xD7, 0x04, 0xB8, + 0xE7, 0x8E, 0x11, 0x40, 0xA0, 0xC7, 0x72, 0x4E, + 0x3E, 0xFB, 0x70, 0xD2, 0x38, 0x07, 0xCF, 0x38, + 0xE6, 0x27, 0xE3, 0x26, 0xAF, 0xC1, 0x64, 0xCD, + 0xED, 0x52, 0xB4, 0x41, 0x39, 0xFF, 0xB3, 0xF3 + }, + { + 0x48, 0x33, 0xAC, 0x92, 0xE3, 0x02, 0xAC, 0x2B, + 0x67, 0xB0, 0x2B, 0x88, 0x27, 0x14, 0x3B, 0xAD, + 0xA1, 0x5C, 0xED, 0x22, 0x0E, 0x1D, 0x1F, 0x5B, + 0x71, 0x12, 0x0C, 0x51, 0xEE, 0x54, 0xC1, 0x9D, + 0x30, 0x1F, 0x29, 0x60, 0xBD, 0xB5, 0xA2, 0xCE, + 0x27, 0xD4, 0x41, 0xD1, 0x4A, 0xF0, 0x80, 0xCB, + 0x01, 0x0A, 0x8A, 0x23, 0xEE, 0xFF, 0x58, 0x11, + 0xDF, 0xA4, 0x4D, 0x1D, 0x7B, 0x35, 0x8B, 0x48 + }, + { + 0x9A, 0x03, 0x88, 0xCE, 0xE1, 0xAD, 0x01, 0x46, + 0x17, 0x7C, 0x48, 0xB5, 0xA0, 0x8A, 0x2D, 0xB3, + 0xC4, 0x89, 0xE8, 0x4C, 0xE2, 0xAB, 0xA8, 0xC6, + 0x45, 0x11, 0x2A, 0x02, 0x1E, 0x41, 0x1C, 0xF8, + 0x29, 0x12, 0x7F, 0xA2, 0xF1, 0xD1, 0xAE, 0x1B, + 0xAF, 0x3A, 0x33, 0xEA, 0x53, 0x09, 0x84, 0x77, + 0xA7, 0xD1, 0x2B, 0xA7, 0x48, 0xD2, 0xAF, 0x24, + 0xD1, 0x66, 0x02, 0xE9, 0x19, 0x07, 0x76, 0x23 + }, + { + 0xE3, 0xDF, 0x00, 0x74, 0xA9, 0x37, 0x35, 0x13, + 0x0D, 0x99, 0x22, 0xD2, 0xBE, 0x91, 0x6F, 0x35, + 0x34, 0x3D, 0x98, 0x8C, 0xE5, 0x9D, 0x76, 0x97, + 0x15, 0xA9, 0x83, 0xB4, 0xBA, 0x80, 0x7C, 0xE1, + 0xEE, 0x70, 0xA3, 0x13, 0xE5, 0x92, 0x31, 0x58, + 0x4F, 0x55, 0x6E, 0xBB, 0xA1, 0xB9, 0x0B, 0x1B, + 0xB6, 0xA6, 0xC5, 0x81, 0xA4, 0xB4, 0x7C, 0x3F, + 0xF5, 0x21, 0x89, 0x65, 0x2A, 0xAB, 0x36, 0xF5 + }, + { + 0x91, 0x91, 0xCF, 0x46, 0x1B, 0x69, 0x59, 0xBE, + 0xC9, 0x3E, 0xAE, 0x7F, 0xB1, 0xC6, 0xE3, 0x70, + 0x73, 0xD1, 0xA6, 0x15, 0x27, 0xAD, 0x75, 0xD1, + 0x0B, 0x7F, 0x89, 0x49, 0xD9, 0xB8, 0xAF, 0x70, + 0xA2, 0x3A, 0xD1, 0x31, 0x2E, 0xD5, 0x1F, 0x70, + 0xF0, 0xE9, 0xDF, 0x60, 0x1D, 0xDA, 0xE2, 0x38, + 0x90, 0x6C, 0x0F, 0xE3, 0xF7, 0x66, 0xB1, 0x4F, + 0x11, 0x3B, 0x26, 0xBC, 0x85, 0x42, 0xD1, 0xD2 + }, + { + 0x2A, 0x8B, 0xAD, 0xE2, 0x72, 0xEE, 0x7A, 0xC6, + 0x43, 0xC5, 0xE3, 0x71, 0x47, 0xFA, 0xAC, 0x92, + 0xC3, 0x97, 0x0B, 0xD3, 0x86, 0x2F, 0x53, 0x1E, + 0x5D, 0xCE, 0xA5, 0xCE, 0xAC, 0xD1, 0x83, 0x74, + 0x53, 0xAA, 0x49, 0x8D, 0x78, 0x5B, 0x4D, 0x1F, + 0x89, 0xE1, 0xB2, 0xA7, 0x39, 0xCA, 0x4A, 0x38, + 0x49, 0x87, 0x30, 0x27, 0x46, 0xB4, 0xF1, 0x13, + 0x42, 0x43, 0x02, 0xC4, 0xA1, 0xE0, 0xF9, 0xDF + }, + { + 0x32, 0x3E, 0x67, 0x93, 0xC7, 0xDD, 0x9B, 0x4D, + 0x7B, 0xB7, 0xFB, 0xF2, 0x15, 0x31, 0xD3, 0x7F, + 0x72, 0x64, 0x53, 0x2C, 0x58, 0xF1, 0x22, 0x55, + 0x48, 0xD0, 0x6E, 0x69, 0x40, 0xC6, 0x3E, 0x91, + 0x27, 0x09, 0x90, 0xE7, 0xF5, 0x64, 0x32, 0x03, + 0xC9, 0x87, 0x64, 0x7E, 0x5C, 0xF6, 0x61, 0x03, + 0xE7, 0x9B, 0x71, 0x4C, 0x58, 0x1B, 0xD8, 0x77, + 0x2E, 0x19, 0xD0, 0xF0, 0x05, 0xDC, 0x86, 0x33 + }, + { + 0xF9, 0x22, 0x07, 0x6D, 0x29, 0x5D, 0x23, 0xE2, + 0x98, 0x58, 0x30, 0xAA, 0xD2, 0xF2, 0x3F, 0x65, + 0x2F, 0x7F, 0x4D, 0xB4, 0x2C, 0x11, 0x9E, 0xD2, + 0x20, 0xA5, 0x45, 0x14, 0x88, 0xA4, 0x53, 0xF5, + 0x9F, 0xA8, 0xA2, 0xDE, 0x23, 0x03, 0x00, 0x0D, + 0x6B, 0xFD, 0x8C, 0x48, 0x23, 0xA8, 0x5F, 0xAD, + 0xB4, 0xFB, 0x8E, 0x7E, 0xAC, 0x12, 0x2B, 0xF0, + 0x12, 0x47, 0xD7, 0x6F, 0x65, 0x24, 0x7D, 0x45 + }, + { + 0xDC, 0x40, 0x00, 0x95, 0x60, 0x95, 0x92, 0x91, + 0x55, 0x8E, 0xBE, 0x07, 0x20, 0x64, 0xCE, 0x67, + 0x12, 0xC9, 0x21, 0xB5, 0x40, 0x9B, 0x44, 0xE0, + 0x4F, 0x9A, 0x56, 0x5E, 0xEA, 0xDD, 0x39, 0xA7, + 0x71, 0x6E, 0x21, 0xB4, 0x6D, 0xD8, 0x61, 0x65, + 0x17, 0xA2, 0x1A, 0x0C, 0x03, 0x41, 0x9E, 0x94, + 0xDB, 0x82, 0x0A, 0x35, 0x3F, 0x15, 0x2D, 0x10, + 0x83, 0x84, 0xBE, 0x94, 0x70, 0x09, 0x3F, 0x89 + }, + { + 0x7F, 0xA4, 0xBE, 0x91, 0xCA, 0x52, 0x07, 0xFF, + 0x08, 0x7D, 0xE9, 0x2F, 0x1D, 0xB0, 0x9B, 0xF7, + 0x1A, 0x67, 0x87, 0x8B, 0xED, 0x19, 0x3A, 0x5C, + 0x2C, 0xC4, 0xE3, 0x53, 0x23, 0xB8, 0xDF, 0x99, + 0xA2, 0x6E, 0xCB, 0x98, 0x88, 0xD7, 0xB3, 0x4A, + 0x73, 0x9D, 0x64, 0x1A, 0x0E, 0xCD, 0x0A, 0x66, + 0x47, 0xA6, 0xA0, 0x64, 0x26, 0xF3, 0xCC, 0x1F, + 0xEF, 0xDF, 0x90, 0x69, 0x92, 0x2F, 0xAE, 0x4C + }, + { + 0xBA, 0xD3, 0xCD, 0x75, 0x90, 0x5D, 0x7B, 0xFD, + 0xA3, 0x32, 0x2B, 0x44, 0xA7, 0xD3, 0x58, 0x87, + 0x14, 0xD3, 0x33, 0xEE, 0x86, 0x85, 0x5A, 0x87, + 0x27, 0x47, 0xE7, 0x04, 0xF6, 0x11, 0x94, 0x84, + 0xBD, 0xB7, 0xD0, 0x77, 0xFA, 0x08, 0xED, 0xC4, + 0xA7, 0x9D, 0xE0, 0xF4, 0x3F, 0xCA, 0x8D, 0x43, + 0x6E, 0x8A, 0x10, 0x08, 0x57, 0xF5, 0x9B, 0xC7, + 0xB0, 0x55, 0xB9, 0x87, 0xF9, 0x7A, 0xC6, 0xB9 + }, + { + 0xB7, 0xDE, 0xE8, 0xE8, 0x33, 0x9D, 0xB2, 0x97, + 0xFD, 0xAA, 0x3C, 0xA5, 0xC1, 0xDC, 0x19, 0x88, + 0xD9, 0x7F, 0x5F, 0xB6, 0x20, 0x8C, 0x64, 0xDE, + 0xA9, 0x5E, 0x1C, 0x78, 0xF3, 0x37, 0xCE, 0x20, + 0xA2, 0xB4, 0xDF, 0x17, 0xA7, 0xB8, 0x23, 0x6A, + 0x90, 0xD6, 0x28, 0x67, 0x33, 0x16, 0x35, 0x72, + 0xC8, 0x67, 0xD9, 0x3D, 0xE8, 0x9E, 0xF6, 0x2F, + 0xA0, 0x5D, 0xAB, 0x70, 0x7E, 0xC3, 0xA7, 0x70 + }, + { + 0xA0, 0xF7, 0xE9, 0x3C, 0xF3, 0x25, 0x02, 0xB9, + 0xFD, 0x79, 0xEC, 0x20, 0x54, 0x62, 0x07, 0xF3, + 0x31, 0xC5, 0x29, 0x9E, 0xCE, 0xF3, 0x50, 0xD6, + 0x6E, 0xA8, 0x55, 0xC8, 0x7F, 0xBD, 0xDF, 0x18, + 0xE6, 0x91, 0xC2, 0x0D, 0x04, 0x5A, 0x30, 0x8F, + 0x83, 0xF6, 0xCB, 0x8F, 0xCA, 0x69, 0xD7, 0xE2, + 0xB3, 0x9B, 0x34, 0xD2, 0xF8, 0x77, 0x27, 0x6C, + 0x19, 0x6B, 0xF5, 0x14, 0xBA, 0xC6, 0x02, 0x70 + }, + { + 0x6F, 0x50, 0x93, 0xCF, 0xC8, 0x83, 0x00, 0xBF, + 0x68, 0x8E, 0x88, 0x4B, 0x4C, 0x5E, 0xC2, 0xC3, + 0x1A, 0x8C, 0xC2, 0x8D, 0x63, 0x31, 0xAD, 0x7C, + 0xA7, 0x1D, 0x97, 0x60, 0x21, 0x64, 0x82, 0x05, + 0x28, 0x15, 0xD4, 0x4F, 0xC6, 0x9E, 0x18, 0xA8, + 0xDC, 0x8B, 0xD7, 0x1B, 0x31, 0xF2, 0xB5, 0x89, + 0xA7, 0xC0, 0x78, 0x0B, 0x61, 0x99, 0x38, 0x5F, + 0x8D, 0xAE, 0x6C, 0x9B, 0x79, 0x74, 0xC4, 0xCB + }, + { + 0x3C, 0xFF, 0x46, 0xAC, 0x35, 0x46, 0xF6, 0x5A, + 0xD7, 0xA7, 0x20, 0x87, 0x1A, 0xFA, 0x20, 0xA9, + 0x21, 0x6D, 0xDA, 0x5C, 0x45, 0x18, 0x81, 0x56, + 0xA5, 0xBB, 0xED, 0xF2, 0x15, 0x46, 0xD4, 0xBB, + 0x39, 0x40, 0xB2, 0x1A, 0x41, 0xA3, 0x94, 0x03, + 0xE3, 0xCF, 0xD5, 0xE7, 0xA0, 0xE7, 0x90, 0x4D, + 0xA9, 0x5F, 0x4D, 0x8E, 0x0C, 0x5B, 0xF5, 0xB7, + 0x0E, 0xB0, 0x29, 0x55, 0x6E, 0xFD, 0x49, 0x7E + }, + { + 0xAF, 0x66, 0x8A, 0x80, 0x5E, 0x6D, 0x70, 0x4B, + 0x1E, 0x58, 0x1F, 0x1E, 0x8E, 0x3C, 0x00, 0xCF, + 0x4C, 0xF3, 0xE5, 0x46, 0x14, 0x7C, 0x40, 0x6D, + 0x17, 0xCA, 0x97, 0x4D, 0x19, 0xA0, 0x14, 0xC7, + 0x8B, 0x44, 0xE7, 0x2D, 0xDE, 0xEB, 0x65, 0x26, + 0x07, 0xE8, 0x6D, 0x69, 0x02, 0x59, 0xDC, 0xAB, + 0x0D, 0xDA, 0x81, 0xC7, 0x7C, 0x7E, 0xE2, 0x72, + 0x1E, 0x82, 0xBB, 0xB1, 0x39, 0x43, 0x07, 0x1D + }, + { + 0x79, 0xDD, 0xEB, 0x5C, 0x54, 0xDE, 0xD1, 0xE4, + 0x48, 0x40, 0x71, 0xC4, 0x6B, 0xB4, 0x28, 0x02, + 0xD2, 0x3B, 0x3A, 0x08, 0xC1, 0x23, 0x11, 0xBE, + 0x36, 0x3C, 0x7C, 0x7A, 0x02, 0x5A, 0x17, 0x64, + 0xC8, 0xD8, 0x50, 0x69, 0xFD, 0xA8, 0xD5, 0x17, + 0x77, 0x7D, 0x8D, 0xD8, 0x09, 0xE3, 0xD4, 0xA9, + 0x56, 0x04, 0x1A, 0x70, 0x79, 0xF9, 0x16, 0x7B, + 0x0F, 0xE9, 0x71, 0x2E, 0x5F, 0x12, 0x29, 0xF5 + }, + { + 0x99, 0x8E, 0x82, 0xF4, 0x26, 0x3D, 0x53, 0xAE, + 0xDA, 0xC9, 0x39, 0xEB, 0xB6, 0xEB, 0x8B, 0x19, + 0x69, 0x74, 0x6C, 0xB8, 0x15, 0xBD, 0x72, 0x1F, + 0x17, 0xA4, 0x8B, 0xEE, 0x9E, 0xCF, 0xF2, 0xFE, + 0x59, 0x8C, 0x53, 0x9C, 0x41, 0x9A, 0x60, 0xE0, + 0xD5, 0xA0, 0x4F, 0x1C, 0xB5, 0x23, 0xA2, 0xFD, + 0x05, 0x38, 0xBB, 0x17, 0x8E, 0x44, 0x75, 0x8D, + 0x31, 0x59, 0xAB, 0x9E, 0x02, 0x84, 0x01, 0xA3 + }, + { + 0x33, 0x96, 0xCF, 0xD5, 0xCD, 0xE1, 0x4A, 0xEC, + 0x1A, 0xAE, 0xD3, 0xE1, 0x22, 0x52, 0xCF, 0xD6, + 0xE3, 0x42, 0xED, 0x25, 0x5E, 0x8E, 0x9E, 0x1B, + 0xE1, 0x0F, 0x1F, 0x27, 0x38, 0x77, 0xF3, 0x63, + 0x33, 0x81, 0xE3, 0xC9, 0x61, 0xE6, 0x7E, 0xC4, + 0x1E, 0x8F, 0x9E, 0x16, 0x11, 0x0F, 0xC0, 0x3D, + 0xDE, 0x88, 0xBF, 0xC0, 0x96, 0xFC, 0x15, 0x14, + 0x46, 0x1D, 0x70, 0xD0, 0xBE, 0xCE, 0x0A, 0xF6 + }, + { + 0x77, 0x7D, 0x9D, 0xC5, 0x5A, 0x2F, 0x57, 0xA4, + 0x6E, 0xA0, 0x6A, 0x2F, 0x4C, 0xB9, 0x76, 0x0D, + 0x00, 0xD7, 0xA8, 0x62, 0xD0, 0xA2, 0xAA, 0x19, + 0x46, 0x7B, 0x57, 0x0F, 0x7C, 0x7D, 0x5E, 0xA7, + 0x62, 0x9A, 0x95, 0xEB, 0x20, 0x0E, 0x1F, 0x9D, + 0xB0, 0x66, 0x10, 0xCF, 0x8E, 0x30, 0xD5, 0xE6, + 0xAD, 0x0A, 0x7B, 0x63, 0x29, 0x77, 0xFC, 0x21, + 0xBB, 0x17, 0x89, 0x67, 0xF3, 0xB0, 0xE0, 0x9B + }, + { + 0x32, 0xEE, 0x35, 0x7F, 0xC9, 0x16, 0x36, 0xA8, + 0x55, 0xBA, 0x01, 0xA0, 0xB8, 0xDA, 0x6F, 0x35, + 0x53, 0xB1, 0xD5, 0x20, 0xAD, 0xCF, 0xE8, 0xFE, + 0x9D, 0xEB, 0xCC, 0xB2, 0x6C, 0x5C, 0x4C, 0xE8, + 0x50, 0x5B, 0xB1, 0xEF, 0xB5, 0xED, 0x5B, 0xAA, + 0x4C, 0x52, 0x45, 0xB5, 0x0D, 0x74, 0x46, 0x3F, + 0x07, 0x67, 0xB2, 0xC7, 0x83, 0xC4, 0x7A, 0x93, + 0xB0, 0xFD, 0xA6, 0x68, 0x95, 0x69, 0x3C, 0xE6 + }, + { + 0x34, 0x0C, 0x0A, 0x7C, 0xE4, 0x96, 0xFE, 0xBD, + 0xA1, 0x3F, 0xA2, 0x40, 0x7A, 0x21, 0xDC, 0x19, + 0x83, 0x9B, 0xED, 0xAE, 0x1A, 0x08, 0x6A, 0xD0, + 0xFE, 0xD3, 0x91, 0x7D, 0xF9, 0xBF, 0x40, 0x94, + 0x4A, 0x78, 0x7F, 0x64, 0x1E, 0x90, 0xDD, 0xBA, + 0xE0, 0x3A, 0x93, 0x37, 0x72, 0x3E, 0x51, 0x66, + 0x8F, 0xB8, 0x93, 0x77, 0x2C, 0x0F, 0xBD, 0xB3, + 0xEB, 0x7E, 0xF7, 0x90, 0xDF, 0xCB, 0xB9, 0xAB + }, + { + 0xD8, 0x6A, 0x5B, 0xAA, 0x33, 0x65, 0xAB, 0xD8, + 0xF4, 0x42, 0xCD, 0x6E, 0xBB, 0x93, 0x11, 0x38, + 0x19, 0xF0, 0xB4, 0x60, 0x61, 0xE1, 0x34, 0x04, + 0xEF, 0xAA, 0x1A, 0x58, 0xE1, 0xFF, 0x27, 0x2A, + 0xD4, 0xBF, 0xD3, 0x08, 0x15, 0xAD, 0xD8, 0x8A, + 0xD9, 0x8F, 0xCE, 0x9A, 0xF0, 0x18, 0x37, 0x4C, + 0xA6, 0x0D, 0x89, 0x79, 0x0F, 0x71, 0xA6, 0x07, + 0x5F, 0x3D, 0x68, 0xD3, 0x20, 0x21, 0xA9, 0xEB + }, + { + 0xA6, 0x7E, 0x6E, 0xC6, 0x57, 0xC9, 0x5E, 0xAB, + 0x3C, 0x3C, 0x32, 0xE4, 0x1F, 0xBF, 0x39, 0xCF, + 0x20, 0x33, 0xAB, 0x4B, 0xE2, 0xE2, 0xB8, 0x21, + 0x10, 0x4A, 0xDB, 0xE6, 0x9D, 0x16, 0xE9, 0x48, + 0xDC, 0xE4, 0xC4, 0xC6, 0xA3, 0xCF, 0x22, 0x76, + 0x90, 0x1F, 0x7D, 0x4F, 0xFD, 0x69, 0x65, 0x46, + 0x49, 0x88, 0x2C, 0x01, 0x4D, 0x2C, 0x10, 0xA1, + 0x30, 0x2B, 0x79, 0xC6, 0x15, 0x69, 0xCD, 0x36 + }, + { + 0x55, 0xCE, 0x19, 0x2A, 0xE4, 0xB3, 0xEA, 0xF8, + 0x55, 0x59, 0x0E, 0x2D, 0x44, 0xE6, 0x25, 0xD9, + 0xBA, 0x14, 0x6E, 0xB7, 0x50, 0x48, 0xE6, 0xB5, + 0x6E, 0x02, 0x50, 0x31, 0xEF, 0xBA, 0x0B, 0xDA, + 0x8A, 0xAA, 0xFA, 0x04, 0x70, 0xB7, 0xAC, 0x3D, + 0x40, 0x6E, 0x5A, 0xBA, 0x3E, 0x83, 0x2F, 0x27, + 0xA5, 0x07, 0x24, 0x6D, 0x1B, 0x5F, 0x33, 0xDE, + 0xA1, 0xF7, 0x24, 0xE2, 0xB8, 0x1B, 0x0C, 0x98 + }, + { + 0xB3, 0xA2, 0x0C, 0x1F, 0xB0, 0xB4, 0xF0, 0xD3, + 0x77, 0x26, 0xC2, 0x3B, 0x58, 0x77, 0xDD, 0x8E, + 0x72, 0xF6, 0x98, 0x86, 0xE0, 0x9A, 0x8C, 0x68, + 0xCF, 0xC3, 0x01, 0xD2, 0xA3, 0xF2, 0xF9, 0x5C, + 0xEF, 0xCF, 0xAB, 0xB8, 0x88, 0x99, 0x03, 0xC7, + 0x32, 0xF4, 0xE8, 0x14, 0x32, 0xD3, 0xF6, 0x78, + 0xCC, 0xDF, 0xC3, 0x98, 0xAC, 0xD8, 0xA2, 0xF0, + 0x66, 0x41, 0x10, 0x04, 0x50, 0xD8, 0x9F, 0x32 + }, + { + 0xF7, 0x27, 0x2D, 0x93, 0xC7, 0x01, 0x2D, 0x38, + 0xB2, 0x7F, 0x0C, 0x9A, 0xE2, 0x01, 0x79, 0x58, + 0xBB, 0xA6, 0x66, 0xA9, 0xDE, 0x1E, 0x88, 0x12, + 0xE9, 0x74, 0x37, 0xAE, 0xB2, 0xE0, 0x3C, 0x99, + 0x94, 0x38, 0xF0, 0xBE, 0x33, 0x3D, 0x09, 0xAD, + 0xDB, 0xCF, 0xAA, 0xC7, 0xAA, 0x73, 0xF7, 0xB6, + 0xCC, 0xEC, 0x67, 0xDC, 0x07, 0x79, 0x98, 0xDE, + 0xDB, 0x8C, 0x13, 0x32, 0xBA, 0xC0, 0xFB, 0xA8 + }, + { + 0x1F, 0xE7, 0xB3, 0xDE, 0x34, 0xC0, 0x47, 0x9C, + 0xA8, 0x40, 0x5F, 0x3C, 0xBC, 0xD2, 0xDB, 0x64, + 0xBB, 0x18, 0xDB, 0xB2, 0x91, 0xA5, 0xFE, 0xAA, + 0x16, 0xC5, 0x22, 0x8C, 0x93, 0xEE, 0x21, 0xC7, + 0x11, 0xD6, 0x8A, 0x01, 0x0C, 0x2A, 0xE8, 0x80, + 0x05, 0xEB, 0xAC, 0x95, 0x9E, 0x3A, 0x32, 0x24, + 0x52, 0xF8, 0x62, 0xDD, 0xE9, 0x4B, 0xB9, 0x41, + 0x81, 0x3E, 0x52, 0x4D, 0x23, 0x47, 0xFE, 0xEE + }, + { + 0x4E, 0xE1, 0xD3, 0x88, 0x05, 0xC3, 0x22, 0x84, + 0xEC, 0xEB, 0xE9, 0x2E, 0x3D, 0xF6, 0xCD, 0x98, + 0xC7, 0xD6, 0x68, 0x0E, 0xAB, 0x0D, 0x68, 0x66, + 0x4F, 0x96, 0x70, 0x6C, 0x45, 0x63, 0x3B, 0x1E, + 0x26, 0x82, 0x22, 0xAA, 0x5A, 0x52, 0x79, 0xEF, + 0x01, 0xFC, 0x28, 0x54, 0x32, 0xAB, 0xEE, 0xD7, + 0x4B, 0xA3, 0xDF, 0x18, 0x9F, 0x50, 0xA9, 0x89, + 0xD5, 0x8E, 0x71, 0x30, 0x62, 0x2D, 0xAA, 0x59 + }, + { + 0x0E, 0x14, 0x05, 0x87, 0x1C, 0x87, 0xA5, 0xEA, + 0x40, 0x83, 0x42, 0xF3, 0x9D, 0x34, 0x94, 0xF9, + 0x39, 0xF7, 0x3C, 0x22, 0x60, 0xC2, 0xA4, 0x3A, + 0x5C, 0x9F, 0x1B, 0x57, 0x33, 0x0C, 0xCA, 0x40, + 0x93, 0xFC, 0x1F, 0x42, 0xF9, 0x6D, 0x83, 0x00, + 0x56, 0x77, 0x03, 0x7D, 0xB5, 0x1A, 0xEF, 0x26, + 0xF0, 0x54, 0x38, 0x05, 0x7A, 0xE7, 0x9E, 0xD1, + 0x44, 0x64, 0xFD, 0x8E, 0x57, 0xD1, 0x55, 0x86 + }, + { + 0x17, 0xC5, 0xCA, 0xB4, 0x09, 0x10, 0x73, 0x62, + 0x1B, 0x5C, 0x24, 0xC3, 0x36, 0x31, 0x6D, 0x0C, + 0xF6, 0x49, 0xBA, 0x1E, 0xFF, 0xEB, 0xFC, 0x87, + 0xE0, 0x43, 0x9C, 0xDF, 0x57, 0x88, 0x87, 0xB2, + 0x21, 0x65, 0x6D, 0x33, 0x9A, 0x6F, 0xD1, 0x98, + 0xAB, 0xAE, 0xE6, 0x7E, 0xA1, 0x88, 0xDD, 0x66, + 0x56, 0x78, 0x23, 0xFC, 0x22, 0x0C, 0x52, 0xB5, + 0x74, 0x90, 0x25, 0x14, 0x69, 0xD2, 0x5D, 0x8C + }, + { + 0x57, 0xDC, 0x27, 0x97, 0xD1, 0x42, 0x68, 0x1C, + 0x94, 0xFE, 0x48, 0x86, 0x26, 0x98, 0x6E, 0xD4, + 0xB2, 0x67, 0x03, 0xCB, 0xF6, 0xBF, 0xE5, 0x93, + 0x91, 0x64, 0x36, 0x57, 0x06, 0x5B, 0x2D, 0x46, + 0xE4, 0xB1, 0xDD, 0xB3, 0xAA, 0x83, 0x2C, 0x9B, + 0xD4, 0x49, 0x75, 0x5A, 0xC8, 0xB1, 0xBF, 0x93, + 0x68, 0x97, 0xFB, 0xC6, 0xAD, 0xE3, 0x78, 0xF2, + 0xBD, 0x64, 0x93, 0xE4, 0x86, 0xF4, 0x20, 0x29 + }, + { + 0x44, 0x12, 0xDD, 0x6B, 0xED, 0x6D, 0xB2, 0xA8, + 0x03, 0xC2, 0xE0, 0xDF, 0x8F, 0x58, 0x29, 0xE7, + 0xA4, 0xB0, 0x41, 0x78, 0x89, 0x51, 0x0D, 0xF7, + 0xDF, 0xEE, 0x49, 0x57, 0x4A, 0x71, 0xEC, 0x0D, + 0x9E, 0x0D, 0x46, 0x06, 0x50, 0x17, 0xC7, 0x2D, + 0xD9, 0x74, 0x39, 0x33, 0xCA, 0x83, 0x9A, 0x76, + 0x8D, 0xD1, 0x5A, 0xB0, 0xB7, 0xC1, 0x4C, 0x62, + 0x6A, 0x35, 0x41, 0x09, 0x69, 0x01, 0x96, 0xAE + }, + { + 0xD0, 0xEB, 0xC7, 0x71, 0x03, 0x1B, 0x7C, 0x16, + 0x00, 0x21, 0xC9, 0xB6, 0xFB, 0xB2, 0xB6, 0x70, + 0xE3, 0xB4, 0x02, 0x70, 0x02, 0x69, 0x07, 0xA3, + 0x91, 0x63, 0xDB, 0x18, 0x73, 0xEC, 0xC3, 0xB8, + 0x00, 0x11, 0x1D, 0xD7, 0xBF, 0x13, 0x8F, 0x83, + 0xA6, 0x10, 0xDC, 0x04, 0x6D, 0xA2, 0x68, 0xB7, + 0x2B, 0x8C, 0x90, 0x86, 0x92, 0x23, 0x77, 0xDB, + 0xED, 0x73, 0x94, 0x82, 0x43, 0xCA, 0x1E, 0x14 + }, + { + 0x10, 0xC4, 0xBA, 0x31, 0x55, 0x91, 0x69, 0x8D, + 0xFB, 0x91, 0xA5, 0x73, 0x37, 0x63, 0x18, 0x84, + 0xB4, 0x73, 0x8D, 0x9F, 0x59, 0x80, 0x78, 0x51, + 0xA6, 0x79, 0x84, 0x0C, 0xC2, 0x87, 0xAC, 0xE3, + 0x01, 0x1C, 0xCD, 0xC8, 0xF4, 0xA4, 0x85, 0xBB, + 0x19, 0x73, 0x40, 0x4E, 0xF9, 0xEE, 0x9B, 0x9C, + 0xF1, 0xEA, 0xDB, 0xC5, 0x40, 0x74, 0xC6, 0xD1, + 0x13, 0xDE, 0x8F, 0xC9, 0x1D, 0x07, 0x97, 0xEB + }, + { + 0x14, 0x64, 0x34, 0x7B, 0xE3, 0x2C, 0x79, 0x59, + 0x17, 0x2B, 0x74, 0x72, 0xD1, 0x1F, 0xE0, 0x78, + 0x44, 0xA5, 0x2E, 0x2D, 0x3B, 0x2D, 0x05, 0x8C, + 0xC6, 0xBC, 0xC0, 0xA8, 0xA2, 0x75, 0xD6, 0xB8, + 0x2B, 0x2D, 0x62, 0x63, 0x75, 0x5E, 0xAF, 0x2A, + 0x65, 0x88, 0xB6, 0xA1, 0xEB, 0x79, 0x9A, 0xF8, + 0x3A, 0x4C, 0xE7, 0x53, 0xF8, 0xC7, 0x5A, 0x22, + 0x84, 0xD0, 0x28, 0x5B, 0xAB, 0x5F, 0x7C, 0x1C + }, + { + 0xF4, 0x09, 0x23, 0x1E, 0xD1, 0x87, 0xF5, 0xC4, + 0xE8, 0x33, 0xFA, 0x9E, 0x30, 0x42, 0xAC, 0xA6, + 0xC8, 0x58, 0xB0, 0x8B, 0x49, 0x6B, 0x25, 0x31, + 0xF8, 0x4F, 0xD5, 0xCE, 0xA9, 0x3E, 0xCD, 0x06, + 0xDA, 0xFE, 0x0A, 0x10, 0xC3, 0xFF, 0x23, 0x76, + 0xC7, 0x4D, 0xC8, 0x0D, 0xA0, 0x7D, 0xA0, 0x18, + 0x64, 0xFB, 0xF2, 0x68, 0x59, 0x60, 0xB5, 0x40, + 0xB3, 0xA2, 0xE9, 0x42, 0xCB, 0x8D, 0x90, 0x9F + }, + { + 0x39, 0x51, 0x32, 0xC5, 0x80, 0xC3, 0x55, 0xB5, + 0xB0, 0xE2, 0x35, 0x33, 0x6C, 0x8D, 0xC1, 0x08, + 0x5E, 0x59, 0x59, 0x64, 0x04, 0x3D, 0x38, 0x9E, + 0x08, 0x1E, 0xFE, 0x48, 0x5B, 0xA4, 0xC6, 0x37, + 0x72, 0xDB, 0x8D, 0x7E, 0x0F, 0x18, 0x6C, 0x50, + 0x98, 0x2E, 0x12, 0x23, 0xEA, 0x78, 0x5A, 0xDC, + 0x74, 0x0B, 0x0C, 0xF2, 0x18, 0x70, 0x74, 0x58, + 0xB8, 0xB8, 0x03, 0x40, 0x42, 0xF9, 0x23, 0xC2 + }, + { + 0xF9, 0x2A, 0xBA, 0xCA, 0x21, 0x32, 0x29, 0x66, + 0x06, 0x49, 0xEF, 0x2D, 0x8F, 0x88, 0x11, 0x5B, + 0x5B, 0xED, 0x8A, 0xB5, 0xB9, 0xBC, 0xA9, 0xA1, + 0xB4, 0xC5, 0x24, 0x57, 0x03, 0x53, 0x10, 0xC4, + 0x1A, 0x6B, 0xEA, 0x2B, 0x23, 0xB7, 0x91, 0x8B, + 0x5B, 0x8B, 0xF3, 0x8B, 0x52, 0xEA, 0xC6, 0xFF, + 0x3B, 0x62, 0x13, 0xA5, 0x22, 0xF3, 0x81, 0xBE, + 0x7F, 0xF0, 0x90, 0x6D, 0xBA, 0x7B, 0xD0, 0x0C + }, + { + 0xCB, 0xAD, 0xE7, 0xAD, 0x3B, 0x5D, 0xEE, 0x0F, + 0xF1, 0xA4, 0x6B, 0x08, 0x2C, 0xF4, 0xE1, 0xE1, + 0xDC, 0x21, 0x62, 0x0D, 0xD2, 0xCC, 0x0E, 0xDC, + 0x2C, 0x70, 0x7A, 0x21, 0x62, 0xD2, 0x14, 0x99, + 0x69, 0xAB, 0xBB, 0x29, 0xC5, 0x72, 0x0B, 0x04, + 0xBD, 0x15, 0x68, 0xA9, 0x55, 0x61, 0x95, 0xE6, + 0x7F, 0x24, 0x32, 0x2D, 0xD9, 0xAA, 0x4E, 0x83, + 0x65, 0x19, 0x1A, 0xA5, 0xB6, 0xC4, 0x45, 0x79 + }, + { + 0xF5, 0x1B, 0x4A, 0xE4, 0xD4, 0xC5, 0x4A, 0x29, + 0xCF, 0x71, 0x35, 0xA8, 0xFE, 0x1E, 0xAB, 0xD5, + 0xE1, 0xBC, 0xBF, 0x82, 0x08, 0x96, 0x96, 0x7D, + 0xC4, 0x1E, 0x38, 0x49, 0xDA, 0xC2, 0x25, 0x07, + 0x69, 0x42, 0x10, 0xCA, 0x11, 0xC4, 0xEB, 0xF1, + 0xC2, 0x9A, 0x8D, 0x4F, 0x71, 0xB3, 0x0F, 0x76, + 0xC9, 0xB6, 0x01, 0x0A, 0xD9, 0x5B, 0xDF, 0xB0, + 0xDE, 0x83, 0x79, 0x25, 0xF0, 0x61, 0x25, 0x97 + }, + { + 0xCE, 0x38, 0x72, 0x11, 0x5D, 0x83, 0x3B, 0x34, + 0x56, 0xCA, 0x94, 0x2E, 0x6E, 0x38, 0x5F, 0x28, + 0xA9, 0x03, 0xBE, 0xAB, 0xFB, 0x75, 0x3F, 0x8A, + 0xFC, 0xCC, 0x12, 0xF2, 0x58, 0x2C, 0xE1, 0xF3, + 0x62, 0x12, 0xBD, 0x05, 0xE0, 0x5A, 0x46, 0xFC, + 0x88, 0xD3, 0x19, 0x50, 0xB4, 0x91, 0x1A, 0xE5, + 0xDC, 0xD8, 0xFF, 0x7A, 0x0B, 0x50, 0x47, 0x4C, + 0xB4, 0x88, 0xCC, 0xF2, 0xA8, 0x9C, 0xD0, 0xEB + }, + { + 0x9B, 0xB7, 0x4C, 0xBD, 0x47, 0xA6, 0x24, 0xCB, + 0xEA, 0xFC, 0xC1, 0x6D, 0x46, 0x29, 0x47, 0xBB, + 0xEA, 0x13, 0x70, 0xB8, 0x5C, 0x96, 0x1A, 0x40, + 0x7D, 0xF9, 0x86, 0x3E, 0x54, 0xE6, 0xD9, 0xE6, + 0xA8, 0xD2, 0xEF, 0x0C, 0x64, 0x97, 0x20, 0x5E, + 0x5E, 0xB7, 0xC3, 0xE5, 0x9E, 0x69, 0x8D, 0x99, + 0x24, 0x63, 0xCA, 0x9D, 0xD4, 0xCF, 0x28, 0xCF, + 0x9A, 0x2D, 0x4E, 0x30, 0xC1, 0x33, 0xE8, 0x55 + }, + { + 0x72, 0x96, 0x33, 0x82, 0x0B, 0xF0, 0x13, 0xD9, + 0xD2, 0xBD, 0x37, 0x3C, 0xCA, 0xC7, 0xBC, 0x9F, + 0x37, 0x16, 0xF6, 0x9E, 0x16, 0xA4, 0x4E, 0x94, + 0x9C, 0x7A, 0x9A, 0x93, 0xDC, 0xA1, 0x26, 0xBB, + 0x1A, 0xA5, 0x4E, 0x5E, 0x70, 0x40, 0x70, 0x7F, + 0x02, 0x87, 0x6A, 0xFD, 0x02, 0x0A, 0xF4, 0x72, + 0x63, 0x9D, 0x49, 0xF5, 0x42, 0x0D, 0x29, 0x4C, + 0x3A, 0xA3, 0x1D, 0x06, 0x7E, 0x3E, 0x85, 0x75 + }, + { + 0x06, 0x86, 0x1D, 0xB3, 0x07, 0xC6, 0x78, 0x08, + 0x6E, 0x8B, 0x2A, 0xEC, 0xDF, 0x18, 0x29, 0xD2, + 0x88, 0x3D, 0x28, 0xB7, 0x31, 0xAB, 0xD0, 0xF1, + 0xE7, 0x2F, 0x1C, 0xED, 0x6C, 0x7A, 0xD4, 0x17, + 0x2E, 0xCA, 0x63, 0x22, 0xA8, 0x3F, 0xB6, 0xA6, + 0x5A, 0xFA, 0x37, 0xE9, 0x4A, 0x3E, 0x2B, 0xA2, + 0x05, 0xB8, 0x7B, 0xF3, 0x82, 0xD9, 0x15, 0x88, + 0x49, 0x7A, 0x46, 0x50, 0x88, 0x3B, 0xD8, 0x75 + }, + { + 0x35, 0x6E, 0xCE, 0xAF, 0x17, 0x02, 0xB3, 0x70, + 0xF4, 0xAA, 0xB8, 0xEA, 0x82, 0x84, 0x86, 0xF3, + 0x30, 0x13, 0xF7, 0x44, 0xB3, 0x9E, 0x7E, 0xA2, + 0x6C, 0x69, 0x18, 0xD6, 0x0E, 0x1A, 0xBC, 0xF4, + 0x4F, 0xB1, 0x6E, 0xDC, 0xA7, 0x72, 0x0A, 0xCF, + 0xC6, 0xA7, 0x01, 0xBF, 0x1E, 0x2C, 0x35, 0xDD, + 0xBD, 0x69, 0x5A, 0x8D, 0x40, 0x8E, 0x8C, 0x96, + 0x32, 0xE8, 0xCD, 0x27, 0x23, 0x0C, 0xAD, 0x8D + }, + { + 0x48, 0x9A, 0x39, 0xD0, 0xFC, 0x3C, 0xDE, 0xAF, + 0x42, 0x89, 0x2E, 0xD8, 0x03, 0x85, 0xC1, 0x1C, + 0xE2, 0x93, 0xC9, 0x32, 0x21, 0x5B, 0xB2, 0x31, + 0x88, 0x69, 0x2A, 0x86, 0xE6, 0x1B, 0xCA, 0xD9, + 0x2C, 0x2A, 0x1D, 0x11, 0x42, 0x60, 0x1B, 0x1B, + 0xDF, 0x09, 0x82, 0xD1, 0xCD, 0x1E, 0x05, 0xC0, + 0x52, 0xDE, 0x81, 0x9E, 0x64, 0xF2, 0x47, 0xDB, + 0x35, 0x91, 0x5D, 0xD1, 0xDB, 0x79, 0xA3, 0xB5 + }, + { + 0xC0, 0x2F, 0x46, 0x4B, 0x4D, 0xD1, 0x81, 0x17, + 0xE3, 0x0A, 0x8D, 0xB8, 0xEF, 0x1D, 0xA0, 0x67, + 0x13, 0x4B, 0x60, 0x4E, 0xFA, 0x19, 0x51, 0x76, + 0x7E, 0xE6, 0x32, 0xDC, 0x02, 0x4D, 0x64, 0xC0, + 0x0F, 0x24, 0x49, 0xF0, 0x42, 0xDB, 0x3A, 0xEA, + 0x01, 0x74, 0xEB, 0xCD, 0xBB, 0x4F, 0xF5, 0x9D, + 0xAE, 0x75, 0x4F, 0x72, 0x39, 0x46, 0xF1, 0xB9, + 0x0A, 0x77, 0xFD, 0x95, 0x23, 0x69, 0x0B, 0x7B + }, + { + 0xFB, 0x31, 0xE6, 0xDD, 0xB8, 0x6D, 0xBF, 0xF3, + 0x72, 0x64, 0x6D, 0x1E, 0x3A, 0x3F, 0x31, 0xDD, + 0x61, 0x15, 0x9F, 0xC3, 0x93, 0x65, 0x8C, 0x2E, + 0xE9, 0x57, 0x10, 0x3B, 0xF2, 0x11, 0x6B, 0xDE, + 0xF8, 0x2C, 0x33, 0xE8, 0x69, 0xF3, 0xC8, 0x3A, + 0xC3, 0xC2, 0xF6, 0x38, 0x0C, 0xF6, 0x92, 0xF7, + 0xB1, 0xDC, 0xBA, 0xE0, 0xBB, 0x22, 0x7A, 0xD3, + 0x47, 0xE7, 0x54, 0x13, 0x74, 0x66, 0xC6, 0x9F + }, + { + 0x00, 0x60, 0x62, 0xAB, 0xE1, 0x6C, 0x2F, 0xE7, + 0x9A, 0xF8, 0x80, 0x85, 0xE0, 0xB5, 0x82, 0xB1, + 0x06, 0xE7, 0xF7, 0x9F, 0x01, 0xA4, 0x39, 0x46, + 0xC7, 0x8B, 0x19, 0xF9, 0xBD, 0xD7, 0x25, 0x99, + 0x76, 0x36, 0xA3, 0x32, 0xEB, 0x9A, 0x3A, 0xAA, + 0x6D, 0xE0, 0xD4, 0xA8, 0xE9, 0xE2, 0x8E, 0x8C, + 0x77, 0x87, 0x74, 0x22, 0x4C, 0x66, 0x5B, 0xF7, + 0xBC, 0x36, 0x44, 0xFC, 0xE4, 0x11, 0x22, 0x8C + }, + { + 0xD4, 0x4A, 0x6D, 0xB3, 0xDE, 0x9F, 0xD4, 0xE4, + 0xA7, 0xEF, 0x15, 0x5A, 0x01, 0xBC, 0xCB, 0x91, + 0xC1, 0xBC, 0xF1, 0xCB, 0x53, 0x22, 0x56, 0x89, + 0xA7, 0x7A, 0x0D, 0x23, 0xB4, 0xD3, 0x9A, 0x89, + 0xA1, 0x89, 0xF2, 0x89, 0x80, 0xF9, 0x1C, 0x56, + 0xEA, 0xC5, 0x87, 0x9E, 0xAE, 0x93, 0x3C, 0xED, + 0x7F, 0x26, 0x7E, 0x2F, 0x70, 0x40, 0xEB, 0x38, + 0x0F, 0xDB, 0xBF, 0x34, 0xA6, 0xB7, 0xB6, 0x15 + }, + { + 0x5A, 0xFB, 0xFE, 0xA1, 0xDE, 0xDA, 0x5A, 0xEA, + 0xB9, 0x2E, 0x4D, 0x0C, 0x31, 0xD1, 0x6A, 0x9A, + 0x86, 0xBF, 0x7C, 0x75, 0x23, 0x27, 0x4A, 0x05, + 0xC5, 0x05, 0x29, 0xF5, 0xC1, 0x39, 0xDB, 0x10, + 0x93, 0x3A, 0x52, 0xC6, 0x22, 0x9C, 0xD3, 0x11, + 0x08, 0xF0, 0x83, 0xFB, 0x0C, 0x85, 0xCF, 0x52, + 0x83, 0x1B, 0x5A, 0x05, 0xF2, 0x55, 0x0A, 0x77, + 0xB5, 0x70, 0x3C, 0xC6, 0x68, 0x91, 0x2D, 0xBC + }, + { + 0xD1, 0x7F, 0xCA, 0xD4, 0xE0, 0xD8, 0xBD, 0xE2, + 0xED, 0xFD, 0xA1, 0x68, 0xBA, 0x47, 0x10, 0x4B, + 0xBC, 0xA4, 0xD2, 0x6D, 0xA2, 0xD3, 0x1A, 0x07, + 0x0B, 0x0F, 0xBA, 0x0B, 0x26, 0xEE, 0xDD, 0x95, + 0xEE, 0xC1, 0xFC, 0x34, 0xD7, 0x6C, 0xD4, 0xA1, + 0xCB, 0x15, 0xF2, 0x62, 0x16, 0x88, 0xA9, 0xCC, + 0x0E, 0x96, 0x35, 0x8D, 0xE9, 0x93, 0x22, 0x2B, + 0xB3, 0xE3, 0xCD, 0x0B, 0xFD, 0xCB, 0x74, 0x6C + }, + { + 0xBD, 0x6A, 0x59, 0x21, 0x63, 0x37, 0xB4, 0x5D, + 0x6B, 0x71, 0xAE, 0xAC, 0x01, 0x36, 0x6B, 0xFE, + 0x96, 0x60, 0xE0, 0xFB, 0xC2, 0x95, 0x9A, 0xDB, + 0xB6, 0x8D, 0x52, 0x6C, 0x43, 0xD4, 0x8F, 0xFF, + 0xFE, 0x2F, 0xFC, 0x43, 0x05, 0x88, 0xE7, 0x8E, + 0x66, 0x54, 0x6A, 0x3C, 0x70, 0x9B, 0x0A, 0xCE, + 0xA1, 0x7C, 0xBC, 0x5A, 0x21, 0x8C, 0x53, 0xCD, + 0x47, 0xAA, 0x48, 0x71, 0xC1, 0xDD, 0x98, 0x4A + }, + { + 0x83, 0xEA, 0x5A, 0xE1, 0x89, 0x11, 0x45, 0xC4, + 0x1A, 0x7C, 0x6C, 0x87, 0xFE, 0x92, 0x24, 0x87, + 0xF5, 0xD2, 0x82, 0x93, 0x35, 0x69, 0xB7, 0xAE, + 0x0E, 0x34, 0x56, 0x53, 0x38, 0x1E, 0xDE, 0x6D, + 0x4B, 0x16, 0xE1, 0x44, 0xD1, 0xC3, 0xE8, 0xF0, + 0x60, 0x5D, 0xAA, 0x0D, 0xB5, 0x96, 0x5A, 0x7B, + 0x79, 0xD9, 0x1A, 0x8A, 0xFE, 0x11, 0xF1, 0xE0, + 0xBC, 0x54, 0x9A, 0xC0, 0x74, 0xA0, 0x1A, 0xB7 + }, + { + 0x37, 0x50, 0x50, 0xCF, 0x2E, 0x43, 0x0D, 0x0E, + 0x29, 0x87, 0x58, 0x35, 0x20, 0x8E, 0x89, 0x06, + 0xD7, 0x05, 0x2E, 0x47, 0x29, 0x2C, 0x5A, 0x38, + 0xA6, 0x30, 0x82, 0x87, 0x3D, 0x31, 0xD5, 0x83, + 0x13, 0x5C, 0x07, 0xA2, 0x0C, 0x52, 0xD9, 0x5B, + 0x2D, 0x5D, 0xC3, 0xEA, 0xDE, 0x6B, 0xE1, 0x43, + 0xCA, 0x34, 0x38, 0xF4, 0x4D, 0x02, 0x0A, 0xAE, + 0x16, 0x0E, 0xD7, 0x7A, 0xB9, 0x88, 0x4F, 0x7D + }, + { + 0x30, 0x28, 0xB0, 0xE8, 0x24, 0x95, 0x7F, 0xF3, + 0xB3, 0x05, 0xE9, 0x7F, 0xF5, 0x92, 0xAA, 0x8E, + 0xF2, 0x9B, 0x3B, 0xEC, 0x1D, 0xC4, 0x7B, 0x76, + 0x13, 0x3D, 0x10, 0x3F, 0xFE, 0x38, 0x71, 0xBF, + 0x05, 0x12, 0xA2, 0x31, 0xAF, 0xCB, 0x1D, 0xF8, + 0x65, 0x97, 0xEC, 0x5E, 0x46, 0xE9, 0x23, 0xC8, + 0xB9, 0x85, 0xC2, 0x85, 0x08, 0x57, 0xC6, 0x40, + 0x01, 0xB2, 0xC5, 0x51, 0xEA, 0x83, 0x3D, 0x0E + }, + { + 0x08, 0x7C, 0xCB, 0x1E, 0x5B, 0xD1, 0x72, 0x22, + 0xB8, 0xAF, 0x20, 0x6D, 0xD6, 0x39, 0x08, 0xF8, + 0x91, 0x72, 0x97, 0x62, 0x1A, 0x8C, 0xB9, 0x33, + 0x0A, 0xE0, 0xBA, 0x4A, 0xF3, 0xE9, 0xD6, 0x0C, + 0x98, 0xFC, 0xF1, 0xEF, 0xFC, 0xEC, 0x20, 0x13, + 0x6B, 0x4F, 0x91, 0x88, 0x12, 0x6D, 0xFA, 0x04, + 0x4E, 0x1C, 0x1C, 0xCD, 0xA3, 0xCE, 0xD8, 0x73, + 0x73, 0xD9, 0x37, 0x9C, 0xCB, 0xED, 0xBD, 0xB3 + }, + { + 0x7F, 0x17, 0x06, 0x24, 0x98, 0xBF, 0xA2, 0xBB, + 0x58, 0x56, 0xCD, 0x0A, 0x62, 0xC5, 0x68, 0xC5, + 0xC6, 0xB8, 0x97, 0x43, 0x24, 0x74, 0xEF, 0xB2, + 0xE6, 0xA2, 0xEE, 0x18, 0xCA, 0xFF, 0xD2, 0x1E, + 0x1E, 0xF3, 0x0D, 0x06, 0x47, 0x23, 0x85, 0x0F, + 0x79, 0x90, 0xD2, 0x1B, 0xA3, 0x4E, 0x8F, 0x2B, + 0x3B, 0xB0, 0x67, 0x02, 0x3A, 0x77, 0x27, 0x82, + 0x15, 0x8A, 0x27, 0xC6, 0xC4, 0x67, 0xC9, 0x28 + }, + { + 0x6B, 0xA9, 0x86, 0xA9, 0x42, 0x49, 0x7F, 0xD3, + 0x84, 0x62, 0x97, 0x2F, 0x50, 0xA6, 0x19, 0x68, + 0xC0, 0x65, 0x2D, 0xAC, 0x56, 0xCE, 0x9B, 0x9A, + 0xC1, 0xBC, 0x06, 0x1A, 0xB6, 0x34, 0xFE, 0x5A, + 0x77, 0xAC, 0xD0, 0x27, 0x5F, 0x83, 0x96, 0xE3, + 0xC0, 0xBE, 0xF0, 0x12, 0xAE, 0x93, 0xB7, 0x27, + 0x58, 0xB8, 0xD7, 0x67, 0x9C, 0x87, 0xE8, 0x47, + 0xE6, 0x30, 0x17, 0xB5, 0x5A, 0x69, 0xC5, 0xC6 + }, + { + 0x96, 0x7C, 0x81, 0xF5, 0x61, 0x95, 0x18, 0x33, + 0xFA, 0x56, 0x6F, 0x6B, 0x36, 0x07, 0x7E, 0xAD, + 0xB2, 0xA6, 0x15, 0xCC, 0x15, 0xF0, 0xED, 0xBB, + 0xAE, 0x4F, 0x84, 0x4D, 0xDC, 0x8E, 0x9C, 0x1F, + 0xB8, 0x3D, 0x31, 0xA9, 0x3F, 0xCB, 0x17, 0x74, + 0xD7, 0x40, 0xD6, 0x92, 0x08, 0xCA, 0x59, 0x30, + 0xBC, 0xFA, 0xC4, 0xA1, 0xF9, 0x44, 0x46, 0x9F, + 0xEF, 0xD1, 0x9B, 0x6E, 0x93, 0x75, 0xE0, 0xB5 + }, + { + 0xE8, 0xAE, 0xF1, 0x78, 0xE6, 0xDA, 0x3E, 0xF5, + 0xCA, 0xED, 0x65, 0x30, 0xF7, 0xEB, 0x25, 0x60, + 0x82, 0x56, 0xC2, 0x37, 0x7C, 0x4C, 0xF9, 0x6B, + 0x0C, 0xFD, 0x0D, 0x76, 0xEE, 0xB4, 0xBB, 0x86, + 0xEE, 0xFF, 0x7B, 0x7D, 0xF1, 0x58, 0x5C, 0x8D, + 0x7A, 0x20, 0xC0, 0x63, 0x3A, 0x67, 0x90, 0x7F, + 0x6D, 0x28, 0x67, 0xC3, 0x26, 0x4A, 0x91, 0xC0, + 0x51, 0xAB, 0xAE, 0x6E, 0xEA, 0x5A, 0x91, 0xD8 + }, + { + 0x64, 0x81, 0xDC, 0xC8, 0x15, 0x7A, 0xE6, 0x28, + 0xB5, 0xCD, 0x52, 0x6B, 0xAC, 0x8F, 0x93, 0x31, + 0x56, 0xDE, 0xDA, 0xC9, 0x56, 0xA2, 0xB2, 0x2A, + 0x97, 0x4B, 0xF5, 0xF7, 0xEC, 0x2D, 0xB5, 0x80, + 0x6F, 0x53, 0xDD, 0x0E, 0x2D, 0xD5, 0x3D, 0xB8, + 0x7C, 0xD8, 0xF5, 0x8A, 0x58, 0x6F, 0x9B, 0x3C, + 0x5C, 0x52, 0x23, 0x31, 0xA3, 0x11, 0x74, 0xC4, + 0xE7, 0xB9, 0xB6, 0xF7, 0xF0, 0x57, 0xC2, 0x8F + }, + { + 0xA7, 0x1E, 0xA4, 0x5C, 0xE6, 0x61, 0x6A, 0x3D, + 0x2F, 0x0A, 0x59, 0x2D, 0x5D, 0x02, 0x86, 0x93, + 0x2D, 0xA6, 0x3C, 0x6D, 0xB1, 0x1D, 0x59, 0xC6, + 0x69, 0x1C, 0x35, 0xA5, 0x6F, 0x7E, 0xE4, 0xF8, + 0x0B, 0x6F, 0xC3, 0x40, 0xB4, 0xDB, 0xC1, 0x84, + 0x4C, 0x50, 0x40, 0xE6, 0x68, 0xD2, 0x89, 0x2F, + 0x4A, 0x4A, 0xE8, 0x53, 0x3F, 0x1B, 0x67, 0x71, + 0xBC, 0xFC, 0xE7, 0xC3, 0xA2, 0x3E, 0x0D, 0x97 + }, + { + 0x96, 0x93, 0x44, 0x87, 0x70, 0xFE, 0xAE, 0x42, + 0x17, 0x26, 0xEB, 0x20, 0x3B, 0x01, 0xC7, 0x08, + 0x23, 0xD5, 0xF4, 0x4C, 0xC5, 0x21, 0x3E, 0x6A, + 0x68, 0x28, 0x47, 0x29, 0xBD, 0x11, 0x7D, 0x9B, + 0xD1, 0x8F, 0xEC, 0x4A, 0x0A, 0x82, 0x4A, 0x24, + 0x08, 0x0F, 0x29, 0x8B, 0xAC, 0xD2, 0x96, 0xD7, + 0xB4, 0x97, 0x83, 0x8F, 0xBD, 0x7B, 0x0D, 0x57, + 0x5C, 0x52, 0x49, 0x2B, 0x3E, 0x6F, 0x92, 0x6B + }, + { + 0x37, 0xA1, 0x50, 0x66, 0xF2, 0xB9, 0xF9, 0x4C, + 0x24, 0x61, 0x1B, 0xC4, 0x53, 0xED, 0x02, 0x74, + 0x07, 0x8D, 0x1F, 0x70, 0xB2, 0xD3, 0x4C, 0x8B, + 0x96, 0x36, 0x08, 0x48, 0x9D, 0xCB, 0xE8, 0xDF, + 0x44, 0x8E, 0xDD, 0x9C, 0x73, 0x36, 0x2B, 0xB2, + 0xB6, 0x6B, 0xEE, 0xF6, 0x1F, 0xCE, 0x60, 0x10, + 0x6F, 0x70, 0x19, 0xED, 0x37, 0x3C, 0x69, 0x22, + 0x59, 0xD9, 0x55, 0x6A, 0x94, 0x0B, 0x1A, 0x06 + }, + { + 0xBD, 0x44, 0xE7, 0x39, 0xE1, 0xF9, 0xDB, 0x1C, + 0x6B, 0xAF, 0x42, 0xCA, 0x4A, 0x12, 0xAC, 0x09, + 0x9B, 0x96, 0xF6, 0xB3, 0x6C, 0x4B, 0xCB, 0x1B, + 0x72, 0xEE, 0xFF, 0x08, 0xA6, 0x49, 0x68, 0x35, + 0xEC, 0x65, 0x15, 0x0B, 0xE8, 0xFE, 0x16, 0xCB, + 0xE3, 0x27, 0x07, 0xE3, 0x47, 0x54, 0x7D, 0xC5, + 0xA5, 0x83, 0xD2, 0x65, 0x74, 0x6F, 0xA5, 0x95, + 0xC5, 0xE7, 0x73, 0x0F, 0xCF, 0x24, 0x58, 0x1E + }, + { + 0xFA, 0xB2, 0x03, 0x8E, 0x94, 0x98, 0xA1, 0xC3, + 0x9E, 0x05, 0x78, 0xA0, 0xA5, 0xEA, 0x6B, 0x44, + 0xF3, 0xC1, 0xB4, 0x1A, 0xE5, 0x67, 0xF9, 0x91, + 0x4A, 0x95, 0xB1, 0x31, 0xC4, 0x8D, 0x12, 0x1E, + 0xCA, 0xCE, 0xA8, 0x95, 0xA0, 0x9B, 0x1D, 0x4E, + 0x04, 0x42, 0xBE, 0xC9, 0xC5, 0x0C, 0x50, 0xE0, + 0x0A, 0x9F, 0xAF, 0xEF, 0xFA, 0xE0, 0x70, 0x88, + 0x4C, 0x26, 0x25, 0xA8, 0xB1, 0xA2, 0x17, 0x26 + }, + { + 0x05, 0xA1, 0xB7, 0x6B, 0x2F, 0xD5, 0x62, 0x11, + 0xE0, 0xF2, 0xD7, 0x5A, 0x25, 0x16, 0x54, 0xA7, + 0x72, 0xF5, 0x5E, 0x18, 0xCA, 0x02, 0x2A, 0xF5, + 0x2C, 0xB3, 0x30, 0x19, 0x1E, 0x98, 0xA3, 0xB8, + 0xEB, 0x87, 0xE5, 0x11, 0x7B, 0xAE, 0x58, 0x04, + 0x4D, 0x94, 0x4C, 0x1F, 0x18, 0x85, 0x45, 0x12, + 0x25, 0x41, 0x77, 0x35, 0xFC, 0x72, 0xF7, 0x39, + 0x36, 0x69, 0x3C, 0xFF, 0x45, 0x46, 0x9F, 0x8C + }, + { + 0x2A, 0x30, 0xC9, 0x6B, 0xDA, 0xC7, 0x8A, 0x39, + 0x94, 0xEE, 0xCA, 0xA5, 0xA5, 0x3F, 0x82, 0x7F, + 0x58, 0xE1, 0x32, 0x31, 0xA0, 0xD1, 0x13, 0x08, + 0x6C, 0x06, 0xB1, 0xBD, 0xAB, 0xDA, 0x38, 0xD0, + 0x8F, 0x1A, 0xE2, 0x7D, 0xE2, 0x5F, 0xD2, 0x2E, + 0xEA, 0x70, 0xC0, 0x5F, 0x01, 0x32, 0xBF, 0x7A, + 0x50, 0x1C, 0x82, 0xAE, 0x62, 0x15, 0xBF, 0xEF, + 0x3C, 0x01, 0x63, 0x98, 0xBA, 0xF2, 0xCB, 0x62 + }, + { + 0x48, 0xDB, 0x53, 0x76, 0x5B, 0x82, 0xBD, 0x6F, + 0x25, 0x33, 0xEA, 0xE1, 0x7F, 0x67, 0x69, 0xD7, + 0xA4, 0xE3, 0xB2, 0x43, 0x74, 0x60, 0x1C, 0xDD, + 0x8E, 0xC0, 0xCA, 0x3A, 0xAB, 0x30, 0x93, 0xFD, + 0x2B, 0x99, 0x24, 0x38, 0x46, 0x0B, 0xAF, 0x8D, + 0xA5, 0x8F, 0xB9, 0xA8, 0x9B, 0x2C, 0x58, 0xF9, + 0x68, 0xE6, 0x36, 0x17, 0xCB, 0xEB, 0x18, 0x44, + 0xB0, 0x2D, 0x6A, 0x27, 0xC5, 0xB4, 0xAD, 0x41 + }, + { + 0x5C, 0x8B, 0x2E, 0x0E, 0x1B, 0x5C, 0x8F, 0x45, + 0x7D, 0x7F, 0x7B, 0xD9, 0xF0, 0x5A, 0x97, 0xE5, + 0x8D, 0xDA, 0x1D, 0x28, 0xDB, 0x9F, 0x34, 0xD1, + 0xCE, 0x73, 0x25, 0x28, 0xF9, 0x68, 0xBE, 0xDD, + 0x9E, 0x1C, 0xC9, 0x35, 0x2D, 0x0A, 0x5D, 0xF6, + 0x67, 0x29, 0x28, 0xBD, 0xD3, 0xEA, 0x6F, 0x5C, + 0xB0, 0x60, 0x77, 0xCF, 0x3A, 0xD3, 0xA7, 0x6E, + 0x29, 0xB2, 0x2E, 0x82, 0xBA, 0xC6, 0x7B, 0x61 + }, + { + 0x5B, 0x73, 0x91, 0xAA, 0x52, 0xF2, 0x76, 0xFA, + 0xB9, 0xC1, 0x38, 0x77, 0xF1, 0x22, 0x32, 0x70, + 0x84, 0x97, 0xFC, 0x02, 0x8F, 0xAA, 0x17, 0x32, + 0xA5, 0xDB, 0x07, 0x9E, 0x7F, 0xE0, 0x73, 0xED, + 0x0C, 0xC9, 0x52, 0x9C, 0xFC, 0x86, 0x3A, 0x4E, + 0xCB, 0xA4, 0xDC, 0x2F, 0x1E, 0xA9, 0xF6, 0xBD, + 0x69, 0x04, 0xF3, 0xA0, 0xC1, 0x07, 0x19, 0x3C, + 0x5E, 0x71, 0x1C, 0xB9, 0x11, 0xF3, 0x80, 0x25 + }, + { + 0x1D, 0x5A, 0xF7, 0x0F, 0x09, 0xA5, 0xFC, 0x69, + 0x16, 0xEF, 0x59, 0xA3, 0x8A, 0x86, 0x92, 0x6D, + 0xCA, 0xAE, 0x39, 0xA8, 0x95, 0x4D, 0x73, 0xFC, + 0x80, 0xA3, 0x50, 0x75, 0x1A, 0xDD, 0xA3, 0x8C, + 0x9D, 0x59, 0x75, 0x06, 0xDC, 0x05, 0xE1, 0xED, + 0x37, 0xBD, 0x2D, 0xB1, 0x59, 0x0F, 0x99, 0xAA, + 0x29, 0x6A, 0xEA, 0x13, 0xAB, 0x84, 0x43, 0xD5, + 0xA9, 0x23, 0x47, 0xFB, 0x85, 0xFC, 0x81, 0x6D + }, + { + 0x80, 0xE3, 0x70, 0x92, 0x97, 0xD4, 0x41, 0x14, + 0xB9, 0xFB, 0xDF, 0x55, 0x67, 0xF0, 0x5F, 0x33, + 0x00, 0x94, 0xCF, 0x09, 0xF4, 0xC0, 0xEF, 0xCF, + 0xAC, 0x05, 0x09, 0x5C, 0x36, 0x08, 0x10, 0x77, + 0x30, 0xC1, 0xAA, 0x07, 0xFF, 0x23, 0x00, 0x25, + 0x62, 0xC7, 0xE8, 0x41, 0xA9, 0xF5, 0x66, 0x24, + 0xFF, 0xE2, 0xAB, 0xEC, 0x61, 0x1E, 0xB9, 0xE7, + 0x3E, 0x1C, 0xCB, 0xD8, 0xF6, 0x2B, 0x11, 0x49 + }, + { + 0xF9, 0x94, 0x5C, 0x19, 0x06, 0x77, 0x84, 0x61, + 0x94, 0x13, 0x2B, 0x49, 0x6E, 0xC6, 0x01, 0x2C, + 0x08, 0x75, 0x0E, 0x02, 0x5F, 0xD5, 0x52, 0xED, + 0x32, 0x4D, 0x3A, 0x49, 0xD8, 0x63, 0x66, 0xC0, + 0x3D, 0xCC, 0xDE, 0x8D, 0x5B, 0x5A, 0xC9, 0xA4, + 0xBC, 0xB7, 0x19, 0x5E, 0x63, 0xBC, 0xAA, 0x93, + 0x9E, 0x8E, 0xDA, 0x18, 0xF1, 0x16, 0x94, 0xB6, + 0xFA, 0x69, 0x37, 0x39, 0x3B, 0xFF, 0xDB, 0xF4 + }, + { + 0x8D, 0x8F, 0x2E, 0xD9, 0xAE, 0x39, 0x80, 0x9A, + 0xAC, 0xAD, 0x2F, 0xCE, 0xDB, 0xD2, 0xDC, 0xA7, + 0x30, 0xC7, 0x83, 0xE6, 0x2F, 0xF7, 0x0B, 0x8D, + 0x3C, 0x53, 0x62, 0xF0, 0x73, 0xF8, 0x34, 0x67, + 0x19, 0x7D, 0x37, 0x56, 0xB4, 0x45, 0x19, 0x5F, + 0xE7, 0x52, 0x11, 0x73, 0x64, 0xD9, 0x2C, 0xF4, + 0x2C, 0x02, 0x6E, 0x40, 0x9D, 0x5F, 0xF7, 0xA9, + 0x53, 0x3E, 0xAB, 0x78, 0xF1, 0x75, 0x4A, 0x2D + }, + { + 0x3A, 0xC9, 0x9A, 0xC5, 0x3A, 0xC4, 0x9A, 0x56, + 0xFA, 0xA1, 0x86, 0x46, 0xB8, 0xE0, 0x8A, 0x2D, + 0x35, 0xBE, 0x80, 0xDF, 0x3E, 0xFB, 0xBB, 0xA6, + 0xBD, 0xA4, 0xAE, 0x90, 0x2B, 0x8D, 0x3E, 0x17, + 0x0A, 0x7B, 0xE8, 0x60, 0x5C, 0x34, 0xA4, 0xDC, + 0x9A, 0x73, 0x62, 0xB1, 0xC2, 0x01, 0xD7, 0x02, + 0x39, 0x1B, 0xD7, 0xD5, 0x20, 0x7F, 0x95, 0xFA, + 0x39, 0x0C, 0xE3, 0x3C, 0x43, 0x14, 0xD4, 0x11 + }, + { + 0xE4, 0x69, 0x4B, 0xDB, 0x31, 0x01, 0x6F, 0x25, + 0x53, 0x2C, 0x04, 0x3C, 0x5C, 0x63, 0x08, 0xCC, + 0x61, 0x9B, 0x0F, 0x87, 0x16, 0xF0, 0xC2, 0x9E, + 0xEB, 0x9F, 0x34, 0x0F, 0x47, 0xB0, 0x7B, 0x4A, + 0x4C, 0xE0, 0x98, 0x4C, 0x47, 0x24, 0xB1, 0x2A, + 0xB3, 0xD3, 0x2A, 0xF5, 0x16, 0xAD, 0xA2, 0x64, + 0x4C, 0xA6, 0x55, 0x8C, 0x1C, 0xB5, 0x81, 0x5C, + 0x12, 0x12, 0xA9, 0xB5, 0xFA, 0x83, 0x44, 0x12 + }, + { + 0xC6, 0x3C, 0x70, 0x3E, 0x62, 0x10, 0x8A, 0xA0, + 0xED, 0xC6, 0x83, 0xF3, 0x67, 0x8A, 0x00, 0x78, + 0x8F, 0xB1, 0x00, 0xC0, 0x96, 0x0B, 0x4E, 0x98, + 0xB7, 0x6A, 0x48, 0xE4, 0xE5, 0x92, 0x3D, 0x34, + 0x13, 0x44, 0x8D, 0xB8, 0x87, 0x5E, 0x3B, 0xCE, + 0xA7, 0xB6, 0xB8, 0x5D, 0x9E, 0x3E, 0xEA, 0xB7, + 0x2C, 0xD1, 0x50, 0x96, 0xFB, 0xBB, 0x2C, 0xC4, + 0x27, 0x03, 0x17, 0xFC, 0x34, 0xD4, 0x04, 0x71 + }, + { + 0x90, 0x80, 0xB7, 0xE8, 0x41, 0xEF, 0x51, 0x9C, + 0x54, 0x17, 0xE6, 0x90, 0xAA, 0xF4, 0x32, 0x79, + 0x07, 0xA8, 0x3D, 0xBC, 0xB7, 0x38, 0xD0, 0xF7, + 0x30, 0x8B, 0x1D, 0x61, 0x1D, 0xEF, 0x16, 0x9A, + 0x4F, 0x47, 0x42, 0x3E, 0x69, 0x0F, 0x27, 0xA7, + 0xE2, 0x74, 0x1A, 0xE7, 0x86, 0x5D, 0xA2, 0x3C, + 0x5D, 0x3F, 0x13, 0xC3, 0x16, 0x06, 0x3C, 0x7A, + 0xA1, 0xA9, 0x58, 0xE5, 0xBE, 0x83, 0x8F, 0x04 + }, + { + 0x29, 0x8D, 0xF6, 0x46, 0x91, 0x5F, 0x04, 0xD6, + 0x65, 0xE9, 0x67, 0x5E, 0x6A, 0x10, 0x31, 0x87, + 0x0D, 0x28, 0xEB, 0x7A, 0x04, 0x05, 0x66, 0x3E, + 0xAC, 0x3B, 0x10, 0xD1, 0xB4, 0xFA, 0x2E, 0x86, + 0x8E, 0x63, 0x73, 0xA5, 0x86, 0xCD, 0x73, 0xE0, + 0x6D, 0x8E, 0x7A, 0xD7, 0x71, 0xB4, 0xFB, 0x0A, + 0x8B, 0x4F, 0xC2, 0xDC, 0x6C, 0xE0, 0x9C, 0x64, + 0x2E, 0xE8, 0x99, 0x26, 0xFD, 0xC6, 0x52, 0x60 + }, + { + 0x4F, 0x2D, 0xE9, 0xC4, 0xF4, 0x34, 0x8B, 0xDB, + 0x32, 0x3A, 0x66, 0x83, 0x72, 0xE7, 0x71, 0x42, + 0x99, 0xC7, 0x76, 0xF9, 0x60, 0x2F, 0x3A, 0xF8, + 0xFB, 0x77, 0x46, 0xF1, 0x76, 0x86, 0x8D, 0xF3, + 0x54, 0x2B, 0x2F, 0xA6, 0x9E, 0xAE, 0x38, 0xB6, + 0xA2, 0x6A, 0x06, 0xCA, 0x89, 0x42, 0xF8, 0x82, + 0x78, 0xC6, 0x4E, 0x3D, 0x01, 0x7F, 0xEE, 0x67, + 0xA9, 0x4E, 0xA0, 0x23, 0xB2, 0xB5, 0xBE, 0x5F + }, + { + 0x40, 0x18, 0xC5, 0xEE, 0x90, 0x93, 0xA6, 0x81, + 0x11, 0x2F, 0x4C, 0xE1, 0x93, 0xA1, 0xD6, 0x5E, + 0x05, 0x48, 0x72, 0x5F, 0x96, 0xAE, 0x31, 0x53, + 0x87, 0xCD, 0x76, 0x5C, 0x2B, 0x9C, 0x30, 0x68, + 0xAE, 0x4C, 0xBE, 0x5C, 0xD5, 0x40, 0x2C, 0x11, + 0xC5, 0x5A, 0x9D, 0x78, 0x5F, 0xFD, 0xFC, 0x2B, + 0xDE, 0x6E, 0x7A, 0xCF, 0x19, 0x61, 0x74, 0x75, + 0xDA, 0xE0, 0xEB, 0x01, 0x44, 0x56, 0xCE, 0x45 + }, + { + 0x6F, 0xCE, 0x66, 0x75, 0xE8, 0x6D, 0x7E, 0x85, + 0x70, 0x4C, 0x96, 0xC2, 0x95, 0x70, 0x3C, 0xD9, + 0x54, 0x98, 0x59, 0x0E, 0x50, 0x76, 0x4D, 0x23, + 0xD7, 0xA7, 0xA3, 0xA3, 0x22, 0x68, 0xA0, 0xB3, + 0xC9, 0x91, 0xE8, 0xF7, 0x84, 0x87, 0x69, 0x9A, + 0x55, 0x4B, 0x58, 0x1E, 0x33, 0x9C, 0x09, 0xAE, + 0xC9, 0x82, 0xE0, 0xBA, 0xA4, 0x31, 0x87, 0x93, + 0x62, 0x06, 0x35, 0xE1, 0xE2, 0xC8, 0xD9, 0xF2 + }, + { + 0xEB, 0xA9, 0x37, 0x85, 0x91, 0x97, 0xC7, 0xFD, + 0x41, 0x2D, 0xBC, 0x9A, 0xFC, 0x0D, 0x67, 0xCC, + 0x19, 0x81, 0x60, 0xB5, 0xA9, 0xCC, 0xEE, 0x87, + 0xC4, 0x1A, 0x86, 0x64, 0x85, 0x9F, 0x3E, 0xFD, + 0x96, 0x13, 0x66, 0xA8, 0x09, 0xC7, 0xC6, 0xBC, + 0x6F, 0xA8, 0x44, 0x92, 0x68, 0x14, 0xE0, 0xB4, + 0xEF, 0xA3, 0x7E, 0xDE, 0x2C, 0x88, 0x44, 0x26, + 0x8D, 0x7F, 0x35, 0x56, 0xE4, 0x46, 0x58, 0x1D + }, + { + 0x83, 0xF4, 0x33, 0xE4, 0xF1, 0xC5, 0x07, 0x97, + 0x49, 0x3C, 0x58, 0xC2, 0x64, 0xCF, 0xFA, 0x70, + 0xC4, 0xA7, 0xA2, 0x4C, 0x33, 0x4D, 0xBA, 0xA3, + 0xC5, 0x74, 0x89, 0xD9, 0x70, 0xD4, 0x9D, 0x69, + 0x49, 0xFE, 0x45, 0xB7, 0x04, 0xF2, 0x65, 0xEF, + 0xD2, 0xAE, 0xE1, 0xAC, 0x1B, 0x46, 0xF4, 0xAA, + 0x3E, 0x4F, 0xAD, 0x68, 0xB3, 0x79, 0x61, 0xD2, + 0xC7, 0x28, 0x0A, 0xE1, 0x96, 0x72, 0xC8, 0x50 + }, + { + 0xB5, 0x57, 0xEC, 0xE1, 0x22, 0x72, 0x49, 0x3D, + 0xC2, 0x7E, 0x88, 0xA0, 0x5A, 0xDC, 0xD8, 0x61, + 0x87, 0x5A, 0x0C, 0xD0, 0x0B, 0xD6, 0x8A, 0xDC, + 0x3A, 0x30, 0x1D, 0x26, 0x3A, 0x9C, 0xD9, 0x93, + 0xA9, 0x6A, 0xE1, 0x4C, 0xFC, 0xDD, 0xCB, 0x99, + 0x7C, 0xC9, 0x86, 0x23, 0x93, 0x50, 0x50, 0xEA, + 0x43, 0x55, 0x2A, 0x34, 0x11, 0x07, 0x18, 0x7D, + 0xE7, 0x5C, 0x4E, 0xDE, 0xD7, 0xC7, 0x86, 0xBD + }, + { + 0x95, 0x89, 0xC0, 0x81, 0x3B, 0x73, 0x93, 0xDB, + 0xAA, 0xAF, 0xE4, 0x7A, 0xF5, 0xB4, 0x08, 0xB2, + 0x3C, 0x8A, 0x8C, 0x8B, 0xAC, 0x62, 0x55, 0x4B, + 0x8F, 0xA1, 0x32, 0xA3, 0x58, 0xCE, 0x30, 0x83, + 0xB1, 0xD4, 0xE3, 0x97, 0x07, 0xCD, 0x54, 0xA5, + 0x5F, 0x67, 0x3D, 0x48, 0x11, 0x6E, 0xB1, 0xF9, + 0xED, 0x8D, 0xE9, 0xC9, 0x43, 0xCD, 0x2D, 0xE4, + 0x60, 0xA6, 0x8B, 0xDD, 0xF7, 0x1E, 0x98, 0x03 + }, + { + 0xAE, 0x4C, 0xCF, 0x27, 0xAB, 0x00, 0xA4, 0x0C, + 0x36, 0x37, 0xD3, 0xD2, 0xCE, 0x51, 0xA8, 0x3E, + 0xFB, 0xA6, 0x2D, 0x4A, 0x6F, 0xDA, 0xD6, 0x95, + 0x06, 0x3F, 0xBC, 0x60, 0xA2, 0xD8, 0x2E, 0xC5, + 0xA5, 0x4A, 0xCB, 0xE0, 0x9B, 0xA9, 0x38, 0x8F, + 0x49, 0xAA, 0xC2, 0x7C, 0x99, 0x2D, 0x84, 0x63, + 0x20, 0x36, 0xE1, 0xBD, 0xD4, 0xC5, 0x29, 0xBB, + 0xF1, 0x85, 0x1E, 0xAE, 0x0C, 0x6E, 0xA9, 0x02 + }, + { + 0xA3, 0x94, 0x4B, 0x2C, 0x31, 0xCB, 0x49, 0x40, + 0x80, 0xB7, 0xEE, 0x1D, 0xB0, 0x81, 0x68, 0x53, + 0xE4, 0x25, 0xB5, 0x4C, 0x48, 0xD6, 0x31, 0x44, + 0x7E, 0xA5, 0x2C, 0x1D, 0x29, 0x52, 0x07, 0x9B, + 0xD8, 0x8F, 0xAB, 0x9E, 0xD0, 0xB7, 0xD8, 0xC0, + 0xBA, 0xAF, 0x0C, 0x4E, 0xCA, 0x19, 0x10, 0xDB, + 0x6F, 0x98, 0x53, 0x4F, 0x0D, 0x42, 0xE5, 0xEB, + 0xB6, 0xC0, 0xA7, 0x5E, 0xF0, 0xD8, 0xB2, 0xC0 + }, + { + 0xCF, 0xA1, 0xA2, 0x24, 0x68, 0x5A, 0x5F, 0xB2, + 0x01, 0x04, 0x58, 0x20, 0x1C, 0xEB, 0x0C, 0xDA, + 0x21, 0xC8, 0x2B, 0x16, 0x02, 0xDC, 0x41, 0x35, + 0x85, 0xFB, 0xCE, 0x80, 0x97, 0x6F, 0x06, 0x1C, + 0x23, 0x5B, 0x13, 0x67, 0x71, 0x24, 0x98, 0x14, + 0x4A, 0xC1, 0x6A, 0x98, 0x54, 0xF6, 0xFB, 0x32, + 0x3C, 0xBE, 0xB6, 0x23, 0x69, 0xCF, 0x9B, 0x75, + 0x2B, 0x92, 0x52, 0xA2, 0xA7, 0xAC, 0xE1, 0xFD + }, + { + 0xFA, 0x62, 0xC6, 0xCF, 0xC8, 0xF0, 0x79, 0xE5, + 0x8F, 0x3D, 0x3F, 0xEF, 0xD7, 0xC2, 0x24, 0xE7, + 0x1E, 0xBC, 0x69, 0xA9, 0x5B, 0x18, 0x35, 0xCC, + 0xC3, 0x2F, 0x35, 0x07, 0x77, 0x05, 0x11, 0x02, + 0x61, 0x54, 0x92, 0xD6, 0x7F, 0xB6, 0xDE, 0x62, + 0xCF, 0x2A, 0xD5, 0xB1, 0x84, 0x67, 0xFE, 0x87, + 0x15, 0x74, 0x88, 0x82, 0xDB, 0x89, 0xFF, 0x86, + 0xEF, 0xDF, 0x2F, 0x96, 0xF8, 0x13, 0x5E, 0xD2 + }, + { + 0xCC, 0x63, 0x3F, 0xD4, 0xEA, 0x6A, 0xC4, 0x08, + 0xC3, 0x87, 0x57, 0x56, 0xB9, 0x01, 0x28, 0x8A, + 0x1D, 0xE1, 0x91, 0x89, 0x28, 0x32, 0xBE, 0x2E, + 0x90, 0x26, 0xDC, 0x65, 0xC2, 0xFF, 0x00, 0x00, + 0x9F, 0x14, 0x36, 0xDD, 0xFF, 0x42, 0x06, 0x26, + 0x0A, 0x3D, 0x66, 0xEF, 0x61, 0x92, 0x14, 0x3E, + 0x57, 0x2F, 0x1E, 0x4B, 0xB8, 0xE5, 0xA7, 0x4B, + 0x12, 0x05, 0x5E, 0x42, 0x41, 0x1C, 0x18, 0xBC + }, + { + 0x44, 0xD2, 0xBF, 0x7F, 0x36, 0x96, 0xB8, 0x93, + 0x3F, 0x25, 0x5B, 0x9B, 0xE1, 0xA4, 0xA6, 0xAE, + 0x33, 0x16, 0xC2, 0x5D, 0x03, 0x95, 0xF5, 0x90, + 0xB9, 0xB9, 0x89, 0x8F, 0x12, 0x7E, 0x40, 0xD3, + 0xF4, 0x12, 0x4D, 0x7B, 0xDB, 0xC8, 0x72, 0x5F, + 0x00, 0xB0, 0xD2, 0x81, 0x50, 0xFF, 0x05, 0xB4, + 0xA7, 0x9E, 0x5E, 0x04, 0xE3, 0x4A, 0x47, 0xE9, + 0x08, 0x7B, 0x3F, 0x79, 0xD4, 0x13, 0xAB, 0x7F + }, + { + 0x96, 0xFB, 0xCB, 0xB6, 0x0B, 0xD3, 0x13, 0xB8, + 0x84, 0x50, 0x33, 0xE5, 0xBC, 0x05, 0x8A, 0x38, + 0x02, 0x74, 0x38, 0x57, 0x2D, 0x7E, 0x79, 0x57, + 0xF3, 0x68, 0x4F, 0x62, 0x68, 0xAA, 0xDD, 0x3A, + 0xD0, 0x8D, 0x21, 0x76, 0x7E, 0xD6, 0x87, 0x86, + 0x85, 0x33, 0x1B, 0xA9, 0x85, 0x71, 0x48, 0x7E, + 0x12, 0x47, 0x0A, 0xAD, 0x66, 0x93, 0x26, 0x71, + 0x6E, 0x46, 0x66, 0x7F, 0x69, 0xF8, 0xD7, 0xE8 + }, + { + 0x99, 0x15, 0xA9, 0x7D, 0xC3, 0xDF, 0x81, 0x25, + 0x1F, 0x17, 0x78, 0xDF, 0xC4, 0xFA, 0x02, 0xA2, + 0xAD, 0x8C, 0xFC, 0x8F, 0x89, 0xB5, 0x1A, 0xC1, + 0x9E, 0x90, 0xA4, 0x5F, 0x37, 0x20, 0x69, 0x01, + 0x5D, 0x8B, 0x4E, 0x87, 0x7B, 0x33, 0x0D, 0x7E, + 0x53, 0xD1, 0xEF, 0x63, 0x6F, 0xA7, 0xB6, 0xF8, + 0x73, 0x6B, 0x2E, 0x04, 0x9A, 0xA9, 0x8D, 0x2F, + 0x7C, 0x85, 0xC9, 0x61, 0x5D, 0xF9, 0xE2, 0xEC + }, + { + 0x26, 0x3F, 0x9E, 0x81, 0x5D, 0x37, 0x4D, 0x5E, + 0x04, 0xF9, 0x34, 0xB9, 0x34, 0xC5, 0x30, 0x79, + 0x3E, 0x56, 0x5A, 0xB5, 0xF0, 0x71, 0xCB, 0xCD, + 0xE8, 0x4A, 0x01, 0x81, 0x8A, 0x0D, 0x9D, 0x35, + 0x57, 0xA6, 0xDF, 0x53, 0x92, 0x06, 0xFD, 0x81, + 0x55, 0x81, 0x60, 0x4B, 0x68, 0xAC, 0x67, 0xA9, + 0xB8, 0xC2, 0x44, 0xA8, 0x66, 0x37, 0xF7, 0xD1, + 0x58, 0x14, 0x06, 0xC4, 0xA5, 0x95, 0x68, 0xB3 + }, + { + 0xEB, 0xD1, 0xDC, 0x84, 0xCF, 0x77, 0x57, 0x6C, + 0x77, 0x9D, 0x8A, 0x81, 0x12, 0xC2, 0xEE, 0x7D, + 0xA3, 0xF0, 0xCF, 0xED, 0xFC, 0x6D, 0xFE, 0xAB, + 0x65, 0x68, 0x4B, 0x2F, 0xE7, 0xFE, 0x6D, 0x03, + 0x68, 0x65, 0x57, 0x74, 0x12, 0x42, 0x1C, 0xF7, + 0x49, 0x87, 0x8A, 0x71, 0xA3, 0xAC, 0x79, 0x1A, + 0x5A, 0x7E, 0x66, 0xB7, 0x4C, 0xFA, 0x7C, 0xC9, + 0x29, 0x01, 0x32, 0x59, 0x8E, 0x34, 0xE6, 0x02 + }, + { + 0x43, 0xD1, 0x0A, 0x2C, 0x0A, 0xC7, 0x9E, 0x08, + 0x72, 0x8E, 0xBE, 0xC5, 0x96, 0xA7, 0xAD, 0x3B, + 0x9A, 0x84, 0x0B, 0xAA, 0xD5, 0xB5, 0x84, 0xAB, + 0xB9, 0xD7, 0x8C, 0xC2, 0x78, 0x01, 0xB2, 0x8D, + 0xC7, 0x44, 0xD7, 0x95, 0x34, 0x66, 0xBB, 0x69, + 0x97, 0x55, 0x5A, 0x3A, 0x7B, 0xC3, 0xB4, 0x5E, + 0x89, 0x5E, 0xCC, 0xB1, 0xB1, 0xE1, 0x69, 0xB0, + 0x68, 0x76, 0x00, 0xF9, 0x8E, 0x85, 0x4A, 0x0B + }, + { + 0x1A, 0x9E, 0xA2, 0xF5, 0x71, 0x2A, 0x4D, 0xC1, + 0x37, 0xAF, 0x97, 0x38, 0xE2, 0x75, 0x72, 0xC2, + 0x15, 0x2E, 0x2B, 0x86, 0x1B, 0x77, 0xF6, 0xAF, + 0x53, 0xF4, 0x25, 0x5F, 0x53, 0xA9, 0x1C, 0x6A, + 0x53, 0x97, 0x85, 0x2D, 0x6A, 0x1B, 0x5B, 0xF8, + 0xC4, 0x39, 0x71, 0x05, 0xB8, 0x06, 0x3C, 0x8D, + 0x95, 0x08, 0xBF, 0x02, 0xB3, 0x5F, 0x5A, 0x0F, + 0x25, 0x77, 0x10, 0x6C, 0x28, 0xE4, 0xEC, 0x48 + }, + { + 0x4D, 0xA5, 0xF6, 0x51, 0x70, 0xD1, 0xB8, 0x19, + 0xD3, 0x13, 0xA3, 0x44, 0x51, 0x5A, 0x99, 0xA9, + 0x48, 0xB6, 0xA7, 0x96, 0x5A, 0xBE, 0x92, 0x9B, + 0x9B, 0x2B, 0xA2, 0xD0, 0xA6, 0xC9, 0x27, 0xB1, + 0x26, 0xB5, 0x6C, 0x5F, 0x83, 0x25, 0x91, 0x3D, + 0x88, 0x6B, 0xC1, 0x75, 0xA2, 0xE2, 0xFA, 0x2F, + 0x87, 0x6E, 0xB3, 0x10, 0x69, 0xA8, 0xB1, 0xCC, + 0xE9, 0xF6, 0x4D, 0xA6, 0x42, 0x16, 0xA5, 0x56 + }, + { + 0xBA, 0x25, 0xCC, 0x1A, 0xE4, 0xAF, 0x2D, 0xA8, + 0xBE, 0x9B, 0xF8, 0xFF, 0x02, 0x68, 0xC3, 0x4D, + 0xEA, 0x43, 0x09, 0x8C, 0x29, 0xE3, 0x75, 0x61, + 0x6D, 0x5C, 0x1D, 0xA3, 0xBB, 0x23, 0x1F, 0x6B, + 0xA2, 0x74, 0x79, 0xD4, 0x97, 0xB2, 0x3C, 0x24, + 0x47, 0xA9, 0x12, 0x9F, 0x8E, 0x5A, 0x29, 0x3D, + 0x1F, 0xD4, 0x7D, 0x04, 0xA4, 0xF0, 0x17, 0x43, + 0x26, 0x01, 0x80, 0x65, 0xA9, 0xCD, 0x60, 0x79 + }, + { + 0xB9, 0x46, 0x18, 0x95, 0x4E, 0x9D, 0xF3, 0xE3, + 0xDF, 0x11, 0xC8, 0x4B, 0x62, 0xC7, 0x43, 0x54, + 0x85, 0x47, 0xC5, 0x31, 0xC0, 0xCD, 0xBA, 0xEB, + 0x43, 0x12, 0xE9, 0x1D, 0x32, 0xAC, 0x2E, 0xBB, + 0xC1, 0x71, 0x42, 0xCA, 0x57, 0x68, 0x56, 0x20, + 0x5F, 0x29, 0x19, 0xE1, 0x10, 0x5C, 0x51, 0x15, + 0xF0, 0xB9, 0x68, 0x97, 0xB3, 0xAF, 0x80, 0x32, + 0xDA, 0x0E, 0x1C, 0x5C, 0x25, 0x3C, 0x2E, 0xF8 + }, + { + 0x21, 0xFC, 0x89, 0x47, 0x74, 0x1D, 0xCD, 0x8F, + 0x8F, 0x23, 0xB3, 0x54, 0xC1, 0xC3, 0xEC, 0x7D, + 0xDA, 0x82, 0xC8, 0x16, 0x55, 0xD3, 0xD1, 0x36, + 0xC8, 0xBD, 0x07, 0x01, 0x01, 0x28, 0x08, 0x37, + 0x3A, 0xAC, 0x79, 0xE3, 0xED, 0x42, 0x52, 0xB8, + 0xDF, 0x0D, 0x78, 0x39, 0x8E, 0xFB, 0x18, 0x6F, + 0xFB, 0x04, 0x70, 0xD4, 0x55, 0xF5, 0x92, 0x8D, + 0xC5, 0xD3, 0xBA, 0xC0, 0x32, 0xC1, 0xC8, 0x1A + }, + { + 0xE0, 0x51, 0xE9, 0x09, 0xE7, 0x36, 0x1C, 0x3A, + 0x91, 0xBB, 0x06, 0xA8, 0x44, 0x10, 0x82, 0x47, + 0x70, 0x2D, 0xB7, 0xDA, 0xE8, 0xB5, 0x18, 0xC8, + 0x7F, 0x8F, 0x4A, 0x49, 0x24, 0xCA, 0x75, 0xC0, + 0xC3, 0x12, 0x06, 0x63, 0xAE, 0x82, 0xE3, 0xFC, + 0xF8, 0x49, 0x49, 0x27, 0x8A, 0x36, 0xB2, 0x5E, + 0x42, 0x3C, 0xDE, 0x26, 0xDB, 0x40, 0x3D, 0x86, + 0x31, 0x1D, 0xCD, 0xA5, 0xF5, 0x2B, 0xC5, 0xC5 + }, + { + 0x26, 0xF0, 0x51, 0x36, 0xAE, 0x5E, 0xC6, 0x26, + 0xE6, 0x71, 0x8D, 0x6A, 0x5A, 0xB0, 0x7B, 0xE6, + 0x8B, 0xCA, 0xF9, 0x05, 0xE4, 0x8D, 0xDE, 0x39, + 0xA3, 0x27, 0x2D, 0x79, 0x06, 0xCA, 0xF6, 0x2A, + 0x16, 0x68, 0x66, 0x5C, 0x92, 0x48, 0x84, 0x44, + 0xE8, 0x89, 0x60, 0xA4, 0x42, 0x7A, 0x73, 0x5D, + 0x31, 0xE7, 0xC3, 0x1B, 0xBA, 0x44, 0x75, 0x52, + 0xD6, 0x69, 0x25, 0x61, 0xC7, 0xEA, 0x45, 0xAD + }, + { + 0xD7, 0x4E, 0xA3, 0xD1, 0x77, 0x9C, 0x5F, 0x4B, + 0x71, 0x3E, 0x49, 0x7D, 0x4A, 0xFA, 0xB6, 0x12, + 0x23, 0x3D, 0x30, 0xDE, 0xC5, 0x2B, 0xA1, 0x32, + 0xE2, 0x7B, 0x35, 0x3A, 0xAF, 0xF8, 0x87, 0x2F, + 0xDB, 0x00, 0x24, 0x22, 0x33, 0x77, 0xC6, 0x74, + 0x24, 0xDA, 0x3A, 0x8A, 0x5E, 0x7B, 0x0D, 0xAD, + 0x6A, 0xD4, 0x23, 0x07, 0xD2, 0x18, 0x4C, 0x62, + 0xC6, 0xCF, 0xEE, 0x34, 0x5A, 0x25, 0xDD, 0x6B + }, + { + 0x00, 0x3F, 0xD1, 0xF7, 0x78, 0x21, 0x10, 0xEE, + 0x75, 0x15, 0x45, 0xBA, 0x57, 0xBD, 0x57, 0x84, + 0x63, 0x0D, 0x2D, 0xE4, 0x74, 0x4F, 0x76, 0x5F, + 0x2F, 0x23, 0xF8, 0x57, 0x85, 0x74, 0x60, 0xA8, + 0x79, 0x41, 0x34, 0x90, 0x35, 0x31, 0x5B, 0xF9, + 0xBD, 0x70, 0x53, 0x91, 0x82, 0xE3, 0x31, 0x63, + 0x58, 0x9C, 0xA7, 0x22, 0x7D, 0x2F, 0x17, 0xCC, + 0x2E, 0xAC, 0xDE, 0xAC, 0xDE, 0x63, 0x5A, 0x8F + }, + { + 0xE0, 0x14, 0x4C, 0xF3, 0x7F, 0x0B, 0x1A, 0x2E, + 0x35, 0xDE, 0x8E, 0x92, 0xD4, 0xF5, 0xC4, 0x68, + 0xCE, 0x02, 0x5A, 0x21, 0x5A, 0x41, 0x7E, 0xCC, + 0x54, 0x60, 0xCE, 0xBB, 0x8B, 0x87, 0xE8, 0x14, + 0x67, 0x82, 0xF7, 0x5D, 0xA8, 0x88, 0xC2, 0xA4, + 0x2C, 0x07, 0x1B, 0x44, 0xB5, 0xB0, 0x37, 0x67, + 0x99, 0x40, 0x59, 0x36, 0x14, 0xCB, 0xE0, 0x5E, + 0x85, 0xBF, 0x40, 0xA6, 0x29, 0xD0, 0xED, 0xB4 + }, + { + 0x5A, 0xCA, 0x90, 0x9B, 0x5A, 0x14, 0x75, 0x7A, + 0x4E, 0xC7, 0xF8, 0xBF, 0x60, 0x98, 0x04, 0xA2, + 0x06, 0x73, 0x79, 0x21, 0x79, 0x95, 0x29, 0xF1, + 0xE7, 0x20, 0xFD, 0xB9, 0x4D, 0x8B, 0xE0, 0xBB, + 0x56, 0x04, 0x74, 0xC3, 0x5E, 0xEF, 0x88, 0x92, + 0x41, 0x50, 0xC4, 0x5D, 0x60, 0x0A, 0x4D, 0xE4, + 0x09, 0x4A, 0xA0, 0x92, 0x9E, 0x80, 0x61, 0xE7, + 0x19, 0x39, 0x7C, 0x30, 0x56, 0x02, 0x44, 0x3D + }, + { + 0x76, 0x23, 0xBE, 0xE0, 0x1B, 0x34, 0x83, 0x1B, + 0x11, 0xCB, 0xEE, 0x18, 0x30, 0xA8, 0xC4, 0x37, + 0x9A, 0x67, 0x99, 0xDB, 0xEA, 0x4A, 0xEB, 0x79, + 0xFC, 0xE7, 0x6A, 0x50, 0x5E, 0x41, 0xF4, 0x4E, + 0x5B, 0xC6, 0xE3, 0xC4, 0x68, 0xCF, 0xCE, 0xC5, + 0x21, 0x0F, 0x02, 0xF0, 0x86, 0xAA, 0xB7, 0x98, + 0x64, 0x0D, 0xCB, 0x8C, 0xC2, 0xED, 0xE5, 0x53, + 0x9E, 0x89, 0xEB, 0x84, 0x41, 0xFC, 0x4A, 0xFC + }, + { + 0xE5, 0xF0, 0xD5, 0x3A, 0xD8, 0xFA, 0xE4, 0x59, + 0xB8, 0xF1, 0xFB, 0xE4, 0xF0, 0x33, 0xC6, 0x0B, + 0x17, 0x08, 0x9B, 0x84, 0x24, 0xCE, 0xCE, 0x3A, + 0x81, 0x52, 0x3C, 0xC5, 0x05, 0x0A, 0xD3, 0x44, + 0x43, 0x45, 0x06, 0x05, 0x0D, 0x57, 0xB1, 0x50, + 0xB5, 0xE6, 0x39, 0xC4, 0x58, 0xF0, 0xE5, 0x72, + 0xC7, 0x06, 0xCE, 0xDA, 0x8A, 0x00, 0xA2, 0x71, + 0xB6, 0x91, 0x9F, 0xE6, 0x82, 0x29, 0x25, 0x62 + }, + { + 0x05, 0xFC, 0xA8, 0x9E, 0x79, 0x79, 0xBE, 0xE5, + 0xC3, 0x7A, 0xBC, 0xA7, 0xBD, 0x0A, 0x1C, 0x0B, + 0xC0, 0x2D, 0xFA, 0x43, 0x45, 0x2E, 0xB9, 0x90, + 0x84, 0x04, 0x66, 0x8D, 0x0C, 0xBD, 0x86, 0x3C, + 0x7A, 0x82, 0x29, 0x00, 0xCA, 0xF9, 0xC6, 0xF0, + 0x2A, 0xAC, 0xFE, 0x9A, 0x48, 0x71, 0x18, 0xE4, + 0xEC, 0x29, 0x7B, 0xE3, 0x1E, 0x03, 0x29, 0x5D, + 0x64, 0x7C, 0xA0, 0x23, 0xE4, 0xD2, 0xE9, 0x01 + }, + { + 0xFC, 0x37, 0x83, 0x5E, 0xF2, 0x7C, 0xFA, 0xD2, + 0x27, 0x20, 0xBE, 0xEA, 0x2B, 0xFC, 0x98, 0xBA, + 0x70, 0x89, 0x57, 0xB7, 0x2A, 0x93, 0xF9, 0x70, + 0xED, 0x07, 0x44, 0xB8, 0x97, 0x88, 0xD8, 0x6C, + 0x18, 0x68, 0x8A, 0x35, 0xF2, 0x0B, 0xCB, 0x9E, + 0xFC, 0x49, 0xC5, 0x59, 0x35, 0x13, 0x5F, 0xA0, + 0x49, 0xA0, 0x25, 0x65, 0x72, 0x33, 0x9F, 0x5D, + 0x8D, 0xDC, 0x4E, 0xC3, 0xFD, 0x27, 0x99, 0x66 + }, + { + 0x55, 0x45, 0x72, 0xC9, 0xF1, 0x26, 0x60, 0xF9, + 0x65, 0x73, 0x56, 0x60, 0xA4, 0x5A, 0xAC, 0xA1, + 0xB6, 0x98, 0xFA, 0xD1, 0x5D, 0x49, 0x8B, 0x27, + 0x09, 0x79, 0x66, 0xC5, 0x92, 0xE3, 0xF4, 0x56, + 0x7E, 0xF1, 0x51, 0x7D, 0x1C, 0x79, 0x70, 0xF6, + 0x3D, 0xC4, 0xA1, 0x52, 0x9D, 0xA8, 0xD7, 0x0D, + 0x5F, 0xC4, 0x3F, 0xEB, 0x0C, 0x12, 0xF0, 0x06, + 0xB3, 0x8F, 0x4E, 0x02, 0xC1, 0x60, 0xD7, 0x9F + }, + { + 0x14, 0xB3, 0x8B, 0xE1, 0x3D, 0xE0, 0x4C, 0x86, + 0x15, 0xAB, 0xAE, 0x8E, 0x1E, 0x2F, 0x6E, 0x2D, + 0x82, 0xDF, 0x3A, 0xF0, 0xC7, 0x4D, 0x88, 0x28, + 0x16, 0x6C, 0x0A, 0x6C, 0x71, 0xAF, 0x32, 0xC8, + 0xC1, 0x1A, 0xF3, 0xFF, 0x7A, 0x15, 0x75, 0xA0, + 0xF4, 0xCE, 0x09, 0xFF, 0x28, 0xE4, 0xA7, 0x51, + 0x5C, 0x33, 0x67, 0xDE, 0x67, 0x42, 0x27, 0x10, + 0x80, 0xF7, 0x05, 0xDF, 0xE0, 0x42, 0x30, 0x38 + }, + { + 0x61, 0x34, 0xE9, 0x4F, 0xE8, 0xAA, 0x16, 0x40, + 0x75, 0xDF, 0x60, 0xF7, 0x61, 0xF0, 0xAE, 0xF3, + 0x8A, 0x0C, 0xEC, 0xB4, 0x22, 0x15, 0x3C, 0x17, + 0xB8, 0x0A, 0x6A, 0xA1, 0x5B, 0x79, 0x1C, 0x04, + 0x5F, 0x3F, 0x53, 0xDC, 0x1A, 0xCB, 0xF5, 0xAD, + 0x36, 0x5B, 0x85, 0xD5, 0x95, 0x7D, 0x42, 0xB5, + 0xD5, 0x75, 0x2D, 0x05, 0xFD, 0x0B, 0x26, 0xFB, + 0xA4, 0x26, 0xB2, 0x40, 0x10, 0xDC, 0x0F, 0x00 + }, + { + 0x38, 0xAF, 0x12, 0x0D, 0x09, 0x1E, 0xF2, 0x7A, + 0x73, 0x74, 0x2B, 0x5E, 0x26, 0x43, 0x6A, 0x65, + 0x2D, 0xF2, 0xD1, 0x59, 0xBB, 0xA8, 0xFA, 0x8D, + 0x3D, 0xA2, 0xD1, 0xDC, 0x05, 0x27, 0x64, 0x68, + 0x20, 0xF1, 0x1B, 0x65, 0x4E, 0x56, 0xCB, 0xC0, + 0xA2, 0xAA, 0xEA, 0xCA, 0xCD, 0x09, 0xB1, 0xDB, + 0x53, 0xE9, 0xC8, 0xFF, 0x5A, 0x4A, 0x46, 0x47, + 0x3A, 0x70, 0xD9, 0x0F, 0x45, 0xCF, 0x78, 0x96 + }, + { + 0xA5, 0x74, 0x9D, 0x3F, 0x64, 0xB4, 0x04, 0xD7, + 0x26, 0xDC, 0x62, 0x5D, 0x6C, 0x31, 0x89, 0x1C, + 0x09, 0x25, 0x5B, 0x76, 0x51, 0x85, 0x1E, 0x0B, + 0xC1, 0x1D, 0xFC, 0xB5, 0xED, 0x19, 0x37, 0xD0, + 0x7A, 0x05, 0x60, 0x53, 0x10, 0xA4, 0x2C, 0x36, + 0x26, 0x3E, 0xD3, 0x1D, 0xD1, 0xBC, 0x77, 0x92, + 0x17, 0x7B, 0xED, 0xEF, 0xDD, 0x0A, 0x65, 0xA1, + 0xB0, 0x4F, 0x27, 0xE0, 0xBE, 0xC4, 0x69, 0xFA + }, + { + 0x1F, 0x0B, 0x31, 0x10, 0x9F, 0x7D, 0x53, 0x4F, + 0x25, 0xFC, 0x41, 0x09, 0x7C, 0xA1, 0xA2, 0xFD, + 0xC5, 0x81, 0xF8, 0x47, 0x91, 0xDB, 0x7B, 0x7B, + 0x9A, 0xCE, 0x5E, 0xD6, 0xAA, 0x91, 0xE3, 0xB4, + 0x00, 0x81, 0x80, 0x59, 0xAD, 0x41, 0xA8, 0xC3, + 0x8B, 0xBF, 0xA7, 0xB5, 0x98, 0x82, 0x9A, 0x1C, + 0x63, 0x82, 0xD5, 0xFD, 0x69, 0x70, 0x82, 0xEB, + 0x56, 0x18, 0x56, 0x63, 0x47, 0x1B, 0x7C, 0x6C + }, + { + 0x93, 0x85, 0x77, 0xAE, 0x4D, 0xFC, 0x73, 0x57, + 0x38, 0x45, 0x90, 0x69, 0x4A, 0x6C, 0x05, 0x1C, + 0xD4, 0xA3, 0x76, 0xC0, 0xF0, 0xF4, 0x29, 0x9D, + 0xA2, 0x9F, 0x25, 0xBB, 0x72, 0x3B, 0x29, 0xAA, + 0x9B, 0x8A, 0xCE, 0xA5, 0x64, 0xC6, 0xF9, 0x33, + 0x46, 0xE1, 0x5D, 0x05, 0x1B, 0x24, 0x76, 0x3B, + 0x28, 0x3E, 0x84, 0xA5, 0xAA, 0xF8, 0x4B, 0xD0, + 0xE6, 0xC1, 0x1D, 0xBD, 0x00, 0xED, 0x00, 0x22 + }, + { + 0xFF, 0x1D, 0x65, 0x3E, 0x9B, 0x2D, 0x16, 0x79, + 0x57, 0x6A, 0x23, 0xD8, 0xF5, 0x34, 0x85, 0x16, + 0x01, 0x09, 0xAA, 0xF5, 0xE8, 0x1F, 0x72, 0x82, + 0x48, 0x28, 0xE3, 0x5B, 0x51, 0x0D, 0x43, 0x1D, + 0xA5, 0xB3, 0x3F, 0xF0, 0x9F, 0x21, 0x7D, 0xFE, + 0xA1, 0xF3, 0xA0, 0x7B, 0x23, 0x16, 0x35, 0x60, + 0x2D, 0xA9, 0xA9, 0x98, 0x1E, 0x48, 0x65, 0xC2, + 0x80, 0x2C, 0x86, 0xD3, 0x09, 0x87, 0xBC, 0x58 + }, + { + 0x7C, 0x3D, 0x41, 0x17, 0x00, 0xB0, 0x06, 0x4A, + 0x44, 0x2C, 0xFE, 0xF6, 0xC9, 0x29, 0xA3, 0x07, + 0xBE, 0xA8, 0xA1, 0x0A, 0x84, 0x59, 0x21, 0x78, + 0xEB, 0xC6, 0x65, 0x7A, 0x2C, 0xA0, 0x42, 0x8F, + 0xE3, 0xBD, 0x59, 0x4C, 0x21, 0x22, 0xA9, 0xBB, + 0xDB, 0xE0, 0xB3, 0x79, 0x14, 0x20, 0xB5, 0x60, + 0x23, 0x36, 0x92, 0xF5, 0xBB, 0x95, 0x69, 0xF6, + 0x77, 0x0E, 0x25, 0xEC, 0x40, 0x62, 0xBF, 0x8A + }, + { + 0x50, 0x5A, 0x36, 0x3B, 0x11, 0x0E, 0x05, 0x1B, + 0xE9, 0x6A, 0x77, 0xBE, 0x3A, 0x19, 0xD5, 0x11, + 0x99, 0x4A, 0x87, 0x6F, 0x66, 0x69, 0x59, 0xDF, + 0xB0, 0xC0, 0x6F, 0xED, 0x79, 0xC7, 0x47, 0xA8, + 0xB1, 0x31, 0xF3, 0x75, 0x54, 0x6A, 0x19, 0x2F, + 0x20, 0xDF, 0x1F, 0x36, 0x8B, 0x8F, 0x0F, 0xC8, + 0xF3, 0xB9, 0xF3, 0x52, 0x14, 0x5E, 0xE5, 0x82, + 0x93, 0x23, 0xBA, 0x72, 0xF6, 0x32, 0x17, 0x55 + }, + { + 0x53, 0x6D, 0x74, 0xA9, 0x19, 0x48, 0xC8, 0xAF, + 0x83, 0x86, 0xA5, 0xB2, 0xE5, 0x67, 0x32, 0x20, + 0x4C, 0x62, 0x4E, 0x0C, 0x01, 0xE9, 0x1A, 0x0E, + 0x30, 0xC9, 0x11, 0x65, 0xF5, 0x19, 0xB1, 0xCE, + 0x9E, 0x6B, 0x8A, 0xDB, 0xC1, 0x08, 0xB7, 0xAE, + 0x85, 0x7F, 0xA3, 0x68, 0x61, 0xB2, 0xCF, 0x37, + 0xB7, 0xC8, 0xD6, 0x97, 0x92, 0x60, 0x6A, 0x39, + 0x5C, 0x62, 0x57, 0x6F, 0x4E, 0x88, 0x3A, 0xA0 + }, + { + 0x4F, 0xB1, 0xDE, 0x28, 0xFA, 0x98, 0xCD, 0x2C, + 0x7D, 0x5C, 0xA9, 0x42, 0x1F, 0xC5, 0x84, 0x3D, + 0x5F, 0xAD, 0x4E, 0x2C, 0x1A, 0x14, 0x6D, 0x9E, + 0x26, 0xF6, 0x72, 0x91, 0x90, 0x11, 0x08, 0x8B, + 0x5A, 0xE3, 0x96, 0xE1, 0xAA, 0xEE, 0x70, 0x46, + 0x00, 0x6A, 0xCC, 0xD3, 0xE7, 0xC3, 0xD7, 0x06, + 0xD7, 0x91, 0x5A, 0x28, 0xF6, 0x5C, 0x69, 0xBE, + 0x45, 0xF2, 0xA7, 0xEB, 0x41, 0x6D, 0x6C, 0xA0 + }, + { + 0xAD, 0x06, 0x67, 0xF5, 0x37, 0x4D, 0xFC, 0x8B, + 0x9E, 0x35, 0xD1, 0x72, 0x4B, 0xEE, 0x22, 0x22, + 0x5F, 0xE0, 0x9C, 0x56, 0x4D, 0x08, 0x9E, 0x11, + 0x33, 0x93, 0x33, 0x9D, 0x62, 0xAB, 0x3C, 0x80, + 0x28, 0xD0, 0x79, 0xE1, 0x65, 0x3E, 0x57, 0x98, + 0xB3, 0x6F, 0x72, 0xF7, 0x49, 0x97, 0x58, 0x5E, + 0xE1, 0x11, 0xBA, 0x99, 0x58, 0xAC, 0x14, 0x8E, + 0x44, 0x0E, 0x7D, 0x8F, 0x18, 0x92, 0x05, 0xD3 + }, + { + 0xA9, 0x3F, 0xCE, 0x38, 0x28, 0xEE, 0x0B, 0xBC, + 0x37, 0x05, 0xF4, 0xED, 0x67, 0x55, 0x63, 0x61, + 0xA7, 0x30, 0xBE, 0x1F, 0x07, 0x72, 0x0A, 0xBF, + 0xE8, 0xB2, 0x4E, 0xD6, 0x54, 0xE4, 0x04, 0x45, + 0xD1, 0x35, 0x8E, 0xCE, 0xED, 0x0F, 0xE2, 0xC5, + 0x2D, 0x84, 0x1D, 0x2F, 0x26, 0x17, 0x2D, 0x97, + 0x7A, 0x43, 0x6C, 0x6E, 0x14, 0x8F, 0x63, 0x31, + 0xA5, 0x70, 0x0E, 0x89, 0xC5, 0x2B, 0x72, 0x27 + }, + { + 0x64, 0x1B, 0xD6, 0x52, 0x9C, 0x87, 0xF5, 0xFD, + 0x6A, 0xFD, 0x5C, 0x5A, 0xC5, 0xEE, 0xFB, 0xBF, + 0x03, 0x7A, 0xDB, 0x6A, 0x09, 0x19, 0x8F, 0xE6, + 0x4E, 0x15, 0xCB, 0x1E, 0x77, 0x26, 0x27, 0x08, + 0x19, 0x0D, 0x7A, 0x3D, 0xCD, 0x18, 0x38, 0x08, + 0x7D, 0xE7, 0x70, 0xF5, 0xE1, 0x8C, 0xA6, 0xAE, + 0x0C, 0x4C, 0x1E, 0x7C, 0xB1, 0x27, 0x45, 0x2F, + 0x4D, 0x0D, 0x4B, 0xA9, 0x18, 0xAB, 0xA9, 0x74 + }, + { + 0xE5, 0x34, 0xFB, 0xCE, 0xCE, 0x71, 0x6C, 0xF1, + 0x87, 0x17, 0xBB, 0x23, 0x15, 0x81, 0xE0, 0x5D, + 0x8C, 0x27, 0xF3, 0x75, 0x2B, 0x79, 0xA1, 0xF2, + 0x2C, 0xED, 0xD5, 0x02, 0xD0, 0x5C, 0x1D, 0xAA, + 0x0A, 0x73, 0x83, 0xC6, 0x6F, 0xA9, 0x8F, 0x59, + 0x84, 0x26, 0x98, 0x9A, 0x4D, 0x03, 0x34, 0x99, + 0xB2, 0xD6, 0x11, 0xF5, 0x8A, 0x77, 0x9D, 0x46, + 0x19, 0x20, 0x8A, 0x51, 0x25, 0x66, 0x97, 0xBE + }, + { + 0x29, 0xA4, 0xBD, 0x0C, 0x5C, 0x50, 0x3B, 0x57, + 0xF3, 0x4D, 0x5E, 0xE8, 0x7F, 0xC4, 0x50, 0x93, + 0xE5, 0x4A, 0xA1, 0xAF, 0x16, 0x47, 0x71, 0xAD, + 0x04, 0xBC, 0x72, 0xD9, 0xCC, 0x49, 0x5C, 0x11, + 0x2D, 0x41, 0xF8, 0x3F, 0xD0, 0xEF, 0x1A, 0x4D, + 0xBD, 0xE9, 0x63, 0xCD, 0x5F, 0x3E, 0xE8, 0x4C, + 0x88, 0xF2, 0xF1, 0x1E, 0xDD, 0xC3, 0xBD, 0x5F, + 0xE9, 0x4F, 0x08, 0x8E, 0x10, 0xC2, 0xDE, 0x75 + }, + { + 0xC4, 0x5D, 0xB1, 0x90, 0x2D, 0xF1, 0x12, 0x25, + 0xCB, 0xA9, 0x62, 0x1D, 0xC0, 0xDF, 0x73, 0x3D, + 0x5E, 0x08, 0xA1, 0x8E, 0x8B, 0xD8, 0xD2, 0xA2, + 0x27, 0x54, 0x68, 0x52, 0xED, 0x64, 0x40, 0xFB, + 0xC6, 0x0A, 0x57, 0x50, 0x64, 0x57, 0xDC, 0xB7, + 0x31, 0xD6, 0xF6, 0x2F, 0x9A, 0x9D, 0x25, 0xE0, + 0x36, 0x2D, 0x24, 0x48, 0x49, 0x14, 0xF0, 0x35, + 0x4A, 0xFC, 0x38, 0x5A, 0x2B, 0xC7, 0x21, 0x89 + }, + { + 0x95, 0x08, 0x18, 0x6E, 0xD8, 0xAB, 0x86, 0x96, + 0x70, 0x57, 0x00, 0xC5, 0x97, 0x84, 0xC5, 0xFF, + 0x1B, 0x77, 0xB9, 0x1C, 0x25, 0x97, 0x2F, 0x40, + 0xDA, 0xF1, 0xD9, 0x6F, 0x18, 0x4C, 0xC1, 0x6B, + 0x9E, 0x1A, 0x93, 0x96, 0x57, 0x67, 0xF1, 0x1B, + 0x47, 0xC9, 0xEA, 0x59, 0x7C, 0xF6, 0x85, 0x29, + 0xE2, 0x70, 0x7E, 0x64, 0xBE, 0x6F, 0x12, 0x88, + 0x9E, 0x6D, 0xE5, 0xE9, 0x9D, 0xC4, 0x1E, 0x69 + }, + { + 0x51, 0x8A, 0xB9, 0x5E, 0xA4, 0xD2, 0x28, 0x19, + 0x65, 0xC2, 0xE9, 0x90, 0x7E, 0xE4, 0x93, 0x75, + 0x05, 0x2F, 0xC6, 0x0E, 0xAB, 0xAD, 0x8F, 0xB8, + 0x86, 0xB2, 0xCD, 0xA1, 0x77, 0xFF, 0x9E, 0x17, + 0xD9, 0x22, 0x59, 0xD7, 0x40, 0x3B, 0x4C, 0xAE, + 0x02, 0x8A, 0xCB, 0x47, 0xFC, 0xDC, 0xF0, 0xAC, + 0x45, 0xC1, 0x6D, 0xBF, 0xA0, 0x29, 0xAF, 0x71, + 0x1E, 0x95, 0x30, 0x2C, 0x0C, 0xE0, 0xF0, 0x29 + }, + { + 0xE8, 0x2B, 0x36, 0xD2, 0x31, 0x15, 0xF6, 0xCB, + 0xD2, 0x7F, 0x98, 0x7A, 0x5B, 0x69, 0x29, 0x06, + 0x30, 0xDF, 0x6A, 0x5B, 0xED, 0xA5, 0xF5, 0xB7, + 0x49, 0x41, 0x84, 0xCE, 0x82, 0xA6, 0xBE, 0x0E, + 0x69, 0xE1, 0x94, 0xB8, 0x53, 0x99, 0x34, 0x04, + 0x20, 0x14, 0xEF, 0xA1, 0x2D, 0x45, 0x27, 0x3A, + 0xF6, 0x70, 0x08, 0x91, 0x15, 0x33, 0x74, 0xAB, + 0x70, 0xED, 0xA2, 0x87, 0x59, 0xC6, 0x1F, 0x52 + }, + { + 0xB0, 0x09, 0xFB, 0x07, 0xCB, 0x8E, 0x42, 0x44, + 0xCF, 0xC1, 0x82, 0xCC, 0x94, 0x05, 0xCF, 0x12, + 0xA4, 0x3B, 0xFF, 0x10, 0x35, 0x2B, 0x65, 0x95, + 0xA7, 0xF7, 0xC5, 0xC5, 0x19, 0xCC, 0x68, 0xE3, + 0x95, 0x0E, 0xFA, 0x02, 0x27, 0x9F, 0x89, 0xD5, + 0xAC, 0x2D, 0xCC, 0x3E, 0x08, 0x56, 0x96, 0x45, + 0xC1, 0xF3, 0x28, 0x15, 0xE6, 0x7E, 0x23, 0x4C, + 0x74, 0xB8, 0x86, 0x47, 0xB1, 0x87, 0xED, 0x99 + }, + { + 0x17, 0xD4, 0x7B, 0x6C, 0x10, 0x16, 0xEE, 0x66, + 0xBD, 0x51, 0x64, 0xA5, 0xEF, 0xBA, 0x58, 0xE8, + 0xFD, 0xF9, 0x8C, 0x0E, 0xAC, 0x08, 0x27, 0xA6, + 0x48, 0x72, 0x94, 0x46, 0xBE, 0x61, 0x32, 0xE6, + 0xDE, 0x77, 0x06, 0x6F, 0xB9, 0xBE, 0x79, 0xF2, + 0x12, 0x0A, 0x45, 0xD7, 0x28, 0x39, 0x17, 0x07, + 0xEC, 0x01, 0x26, 0xA2, 0x97, 0xEE, 0xA4, 0x10, + 0xE9, 0xDA, 0x2A, 0x27, 0x04, 0x29, 0x72, 0x0A + }, + { + 0x72, 0x2C, 0x28, 0x9B, 0xFB, 0x20, 0x32, 0x0E, + 0x8D, 0x96, 0x3A, 0x47, 0xA6, 0x03, 0x83, 0xE4, + 0x9B, 0x16, 0x2E, 0x39, 0x16, 0x59, 0x89, 0x1C, + 0xC5, 0xEC, 0x99, 0x27, 0xA8, 0x47, 0x52, 0xBA, + 0x95, 0xF7, 0xBC, 0xB4, 0x57, 0x82, 0x95, 0xA5, + 0x16, 0x56, 0x1D, 0xA9, 0x23, 0x3F, 0xC5, 0xB4, + 0xB9, 0x78, 0x4C, 0xDA, 0x45, 0x8D, 0x64, 0xE4, + 0x65, 0xC8, 0xBC, 0x7E, 0xD0, 0xF4, 0xCF, 0x77 + }, + { + 0xEE, 0xC8, 0xCD, 0x14, 0x47, 0xB6, 0x53, 0xBA, + 0x31, 0x91, 0x5F, 0xF3, 0x92, 0x6C, 0x31, 0x81, + 0x5B, 0x8E, 0x8C, 0x2C, 0xCB, 0x70, 0x49, 0xF6, + 0x2F, 0x2C, 0xDE, 0x98, 0x77, 0x39, 0x28, 0xBB, + 0xEE, 0xFD, 0x7B, 0x33, 0xDE, 0x2F, 0x9F, 0x40, + 0x24, 0x00, 0xB3, 0x3A, 0xBB, 0x37, 0x9A, 0xA7, + 0x4F, 0x00, 0x1E, 0xD4, 0xCA, 0xCD, 0x0E, 0xFA, + 0xC9, 0xF8, 0x30, 0xB5, 0x5A, 0x97, 0xFD, 0x08 + }, + { + 0xCA, 0x39, 0x83, 0xF0, 0x77, 0xDE, 0x5C, 0x00, + 0x05, 0x96, 0xB1, 0x1E, 0x67, 0x40, 0x75, 0xCA, + 0xA9, 0x5E, 0xEA, 0x7E, 0xFE, 0xA2, 0x27, 0x95, + 0x41, 0xE6, 0x8F, 0xB4, 0xAD, 0xE5, 0x66, 0x3C, + 0x02, 0x32, 0x69, 0xBE, 0x73, 0x2F, 0x0D, 0x84, + 0xF0, 0x18, 0x39, 0x5F, 0xEA, 0xA0, 0xFD, 0x03, + 0xB9, 0x96, 0x8D, 0x2F, 0x94, 0x9E, 0xD5, 0x7E, + 0x08, 0x64, 0x2A, 0xA4, 0xCD, 0xCC, 0x8E, 0x39 + }, + { + 0xFF, 0x96, 0x8D, 0x51, 0x6E, 0x88, 0x5A, 0xA5, + 0x49, 0xFB, 0x8D, 0x83, 0xDB, 0x58, 0x80, 0x51, + 0x9C, 0x2B, 0x81, 0xEF, 0x80, 0x70, 0xFD, 0x44, + 0x06, 0xDF, 0x7C, 0x10, 0xFB, 0x86, 0xA2, 0xC7, + 0x80, 0x9C, 0x15, 0xEC, 0x8D, 0x40, 0x18, 0xD9, + 0x35, 0x15, 0xBA, 0xCD, 0x6C, 0xEE, 0xB5, 0x21, + 0x5D, 0x7A, 0x3A, 0x36, 0xBE, 0x07, 0x9C, 0x13, + 0x3A, 0x85, 0xB2, 0xF5, 0xE1, 0x9D, 0x7A, 0xCE + }, + { + 0xAA, 0x6F, 0x47, 0xA6, 0x98, 0x8E, 0xB3, 0x14, + 0x1F, 0x30, 0x0A, 0x8E, 0x40, 0xBE, 0xCA, 0xD5, + 0x10, 0x7C, 0x04, 0xDD, 0xDC, 0xE5, 0x1A, 0x7D, + 0xB4, 0xFD, 0xEF, 0xDA, 0xBE, 0xFC, 0x68, 0x9B, + 0x35, 0x77, 0xF4, 0x07, 0x9E, 0xF9, 0x51, 0x06, + 0x5D, 0x4C, 0xB8, 0x70, 0x17, 0x18, 0xFB, 0xAF, + 0x94, 0x8B, 0xAC, 0x77, 0x96, 0x09, 0x9F, 0x0B, + 0x70, 0x83, 0xA7, 0x84, 0x87, 0x15, 0xBE, 0x31 + }, + { + 0x7F, 0xC4, 0x7D, 0xAC, 0x5C, 0x52, 0xEB, 0xDF, + 0xC5, 0x2F, 0xBF, 0xA7, 0xAC, 0x64, 0x9C, 0x60, + 0x86, 0x76, 0x20, 0xA9, 0xF5, 0xAA, 0xB0, 0x27, + 0xDB, 0x68, 0xAF, 0x97, 0x67, 0x0B, 0x39, 0xF2, + 0x75, 0xB4, 0xC4, 0x4E, 0x9C, 0x30, 0x36, 0x7F, + 0xBA, 0x7C, 0x5E, 0x9A, 0xC8, 0x29, 0x53, 0x8F, + 0x0D, 0x58, 0x0F, 0xC9, 0xF9, 0xD6, 0x15, 0xB3, + 0xD4, 0x65, 0x02, 0xB3, 0xC1, 0x33, 0xAF, 0x77 + }, + { + 0xED, 0x55, 0x08, 0x5C, 0x59, 0x72, 0xDC, 0x3A, + 0xF4, 0x68, 0x82, 0x80, 0x8F, 0x96, 0xDC, 0xCB, + 0x73, 0x91, 0x55, 0x1C, 0x40, 0xFD, 0x42, 0xC7, + 0x48, 0x3A, 0xBC, 0xDA, 0x28, 0x72, 0x69, 0xEC, + 0x12, 0xD6, 0x7F, 0xDA, 0x55, 0x93, 0xB2, 0xC5, + 0x63, 0xF4, 0x00, 0x92, 0xC8, 0x65, 0x3C, 0x17, + 0xFF, 0x98, 0xD8, 0x14, 0x2A, 0xF5, 0x69, 0xC4, + 0xA6, 0xBD, 0xEE, 0x02, 0xCD, 0x0A, 0x6A, 0xD8 + }, + { + 0xA7, 0x35, 0x41, 0xDC, 0xA9, 0xC5, 0x73, 0xAF, + 0xE1, 0x26, 0x04, 0x0D, 0xCA, 0xB4, 0xB7, 0xC5, + 0x12, 0xB4, 0x5C, 0xB3, 0x6C, 0x3D, 0xEB, 0xEA, + 0xBD, 0xA9, 0x54, 0x8D, 0xED, 0x20, 0x0D, 0x51, + 0x26, 0x08, 0x7D, 0xB3, 0x7C, 0x2F, 0xA8, 0xAA, + 0x23, 0x22, 0x0C, 0x0A, 0xBA, 0x31, 0xAC, 0x2C, + 0x36, 0x14, 0x89, 0x34, 0x56, 0xD4, 0xEE, 0xC0, + 0x15, 0x7F, 0x6F, 0x79, 0xEE, 0x60, 0x64, 0xB8 + }, + { + 0x3A, 0x5A, 0x43, 0x7E, 0x20, 0x55, 0xA4, 0x25, + 0x3B, 0xCB, 0xBE, 0x7B, 0x71, 0x41, 0x2E, 0x13, + 0x07, 0xCF, 0xE1, 0xA9, 0x49, 0x0B, 0xCE, 0x5A, + 0x96, 0xAF, 0x35, 0x81, 0xAE, 0x6F, 0x5E, 0x12, + 0xC2, 0x39, 0x92, 0x4B, 0x34, 0x98, 0xBB, 0xE8, + 0x9E, 0xD2, 0xB4, 0x6F, 0xAB, 0x6F, 0x1A, 0x8A, + 0xAB, 0x01, 0xA0, 0x6E, 0x0D, 0x80, 0x95, 0x59, + 0xBB, 0x1A, 0xC7, 0x8B, 0x4F, 0xC0, 0x87, 0xEE + }, + { + 0x2F, 0x2B, 0x29, 0x6C, 0xF1, 0x8D, 0x25, 0xDC, + 0x43, 0x9A, 0x6F, 0xBC, 0xDF, 0x8D, 0x54, 0x81, + 0x40, 0x4A, 0xF5, 0x37, 0x32, 0x45, 0x0C, 0xEC, + 0x10, 0xA2, 0xAF, 0xFC, 0x2B, 0x00, 0x34, 0xDA, + 0x00, 0x43, 0x09, 0xE5, 0x14, 0xF2, 0x80, 0xCD, + 0x14, 0x2F, 0xF7, 0x17, 0x49, 0x4D, 0xD1, 0xCE, + 0xD1, 0xB6, 0x59, 0x02, 0x1F, 0xE9, 0x52, 0x41, + 0x3B, 0xA3, 0x5D, 0xA2, 0x80, 0xB6, 0x73, 0xAA + }, + { + 0xDB, 0xF1, 0x97, 0x0D, 0x1A, 0x04, 0x30, 0x7D, + 0x47, 0xAC, 0x67, 0xB8, 0xDA, 0x94, 0xC6, 0x6C, + 0x0E, 0x07, 0x59, 0xBA, 0xB9, 0x5C, 0x66, 0x91, + 0x19, 0xDA, 0xD3, 0x22, 0x61, 0xFA, 0x82, 0x27, + 0xA3, 0xED, 0x90, 0x57, 0xEE, 0xE0, 0xCC, 0xBC, + 0x7B, 0xFB, 0x9A, 0xED, 0x3C, 0x8B, 0xF5, 0xB3, + 0x82, 0xC6, 0x5A, 0x17, 0x1B, 0xC5, 0x72, 0x94, + 0x8F, 0x2B, 0xBF, 0x03, 0xDC, 0xE4, 0xA1, 0x62 + }, + { + 0x5A, 0x34, 0x64, 0x7D, 0x7F, 0xE1, 0x61, 0xA8, + 0xD1, 0x69, 0x50, 0xC7, 0xB2, 0xD8, 0xAF, 0x26, + 0x07, 0x93, 0x1B, 0x4D, 0xDA, 0x34, 0xF5, 0x0D, + 0x6A, 0x66, 0x31, 0x23, 0x78, 0xDF, 0xA3, 0x69, + 0x4C, 0xAD, 0xB9, 0x62, 0x29, 0x58, 0x13, 0xDA, + 0x05, 0x49, 0x63, 0x95, 0xA6, 0xD5, 0x6E, 0xA4, + 0xF7, 0x63, 0xC1, 0xAC, 0x70, 0xB8, 0x99, 0x62, + 0x89, 0x56, 0x1B, 0xF1, 0xE2, 0xAC, 0x39, 0x86 + }, + { + 0x43, 0xDD, 0x4E, 0x56, 0x55, 0xEC, 0x51, 0x8B, + 0xAC, 0x8D, 0x9C, 0x7A, 0xA6, 0xA5, 0x8C, 0x82, + 0xF8, 0x03, 0xFB, 0xC3, 0x5D, 0x38, 0x8D, 0x19, + 0x0E, 0xC0, 0x09, 0xEB, 0x16, 0x8A, 0xF4, 0x32, + 0xCE, 0x5F, 0xFB, 0xF6, 0xA1, 0x7A, 0x1A, 0x79, + 0x6E, 0xC4, 0x67, 0x34, 0x82, 0x66, 0x6A, 0xEB, + 0x6F, 0xBE, 0xC1, 0xCF, 0x73, 0x81, 0x71, 0x20, + 0x4C, 0x4C, 0xA6, 0x43, 0x5D, 0x8E, 0xEA, 0xD3 + }, + { + 0xC4, 0x6C, 0x60, 0x87, 0x85, 0x94, 0xFB, 0xF1, + 0xFD, 0x3C, 0x4A, 0xE3, 0x28, 0x03, 0xCC, 0x44, + 0x38, 0xCB, 0xD8, 0xAA, 0x10, 0x69, 0x34, 0xDB, + 0x22, 0x8F, 0x95, 0xBB, 0x24, 0x40, 0x45, 0xC1, + 0x1C, 0x19, 0x2A, 0xC9, 0x59, 0x1A, 0x10, 0x8A, + 0xE3, 0x91, 0x56, 0xAB, 0x1B, 0xDE, 0xED, 0x33, + 0xAE, 0xF9, 0xC5, 0xB1, 0x86, 0x34, 0x9C, 0xCE, + 0xE1, 0x81, 0x54, 0x3E, 0x99, 0x1E, 0x48, 0x36 + }, + { + 0xAB, 0x75, 0x5F, 0xF1, 0xF3, 0x27, 0x62, 0xBF, + 0x50, 0x73, 0xF0, 0x8C, 0x02, 0x16, 0xD6, 0x6B, + 0xF5, 0x1C, 0x8E, 0x55, 0x9F, 0x2B, 0x9A, 0xD5, + 0x12, 0x5C, 0x61, 0x75, 0xF1, 0x5C, 0xAD, 0xEB, + 0x06, 0x8B, 0x5A, 0x91, 0x03, 0xD8, 0x5B, 0xA8, + 0xC3, 0xF4, 0x19, 0x5E, 0xE5, 0xA7, 0x20, 0xC5, + 0xEA, 0xF4, 0x79, 0x1F, 0xD0, 0x35, 0x0F, 0xDF, + 0x4D, 0x85, 0x3C, 0x56, 0xDF, 0x62, 0x0C, 0x81 + }, + { + 0xFE, 0x8A, 0x85, 0xBC, 0xD3, 0x4C, 0x02, 0xD3, + 0x09, 0xC7, 0x5C, 0xFF, 0x9A, 0x1B, 0x75, 0x94, + 0x44, 0xA9, 0x7B, 0x78, 0xB7, 0x1B, 0x47, 0x28, + 0xCE, 0x12, 0x37, 0xA5, 0x61, 0xA9, 0x94, 0xD9, + 0xFA, 0xC6, 0xF3, 0x77, 0x57, 0xC1, 0x94, 0xE3, + 0x48, 0x77, 0x7D, 0xBE, 0x01, 0xB9, 0x95, 0x11, + 0x6F, 0xF0, 0x3B, 0x1D, 0x00, 0x21, 0x4E, 0xEC, + 0x6E, 0x50, 0x07, 0xD0, 0xB8, 0x7D, 0x89, 0xE7 + }, + { + 0x99, 0x95, 0xE4, 0x8E, 0x09, 0xD7, 0x45, 0xBB, + 0x79, 0x1F, 0x59, 0x69, 0xD0, 0x7C, 0xAC, 0x31, + 0xCB, 0x35, 0xE5, 0x61, 0xF7, 0x6E, 0x38, 0x18, + 0x6A, 0x19, 0x7F, 0x5C, 0x35, 0xF9, 0x8E, 0x94, + 0xC5, 0x00, 0xED, 0x34, 0xE1, 0x99, 0x90, 0x2D, + 0x96, 0xB6, 0x1D, 0xA3, 0x57, 0xF6, 0x49, 0x8E, + 0x5C, 0xAE, 0x50, 0x27, 0xCB, 0xBC, 0xAE, 0x88, + 0x6A, 0x82, 0xF4, 0x1A, 0x6B, 0x7C, 0x3C, 0xF5 + }, + { + 0x55, 0x7A, 0x3E, 0x68, 0x26, 0x9E, 0x0A, 0x25, + 0xC5, 0x4E, 0xF0, 0x34, 0x5E, 0x37, 0x1A, 0xF3, + 0x56, 0xBB, 0x69, 0x1E, 0x6E, 0x7E, 0x51, 0xCE, + 0x6C, 0x61, 0xBB, 0xEF, 0x82, 0x3B, 0xF5, 0x2D, + 0x50, 0xC0, 0xAF, 0x29, 0x57, 0xC8, 0xE8, 0x32, + 0xE2, 0xC2, 0x73, 0x9F, 0xDE, 0x23, 0x72, 0x3F, + 0x7B, 0xF5, 0x05, 0x8C, 0xF3, 0xA4, 0xB8, 0x6B, + 0xE6, 0x68, 0x42, 0x1B, 0x49, 0xD2, 0xF2, 0x06 + }, + { + 0xDD, 0xCD, 0x3E, 0x41, 0x36, 0x97, 0xCA, 0xE9, + 0x4D, 0xF7, 0x52, 0x27, 0xEE, 0xB7, 0x08, 0xDF, + 0xE6, 0x63, 0x30, 0x1C, 0x8E, 0xA3, 0xDB, 0xE4, + 0x9C, 0x4E, 0x52, 0xD7, 0xA7, 0x4E, 0x9E, 0xA2, + 0x7C, 0x25, 0xFF, 0xAB, 0xE1, 0xE4, 0xDB, 0x7A, + 0xBA, 0x98, 0x16, 0xB7, 0x97, 0x36, 0x76, 0xAF, + 0x8F, 0x39, 0xC9, 0x9F, 0x2A, 0x4D, 0xE6, 0xE0, + 0x6D, 0x18, 0x9B, 0x0D, 0x9F, 0xDA, 0x5E, 0xE7 + }, + { + 0x48, 0xE6, 0x19, 0x5A, 0x80, 0x7A, 0x9A, 0x79, + 0xD6, 0x1C, 0x00, 0x01, 0xBB, 0x74, 0xDF, 0x2F, + 0xA4, 0x2A, 0x7E, 0x4E, 0x22, 0xDF, 0x7A, 0x6F, + 0xCA, 0x3A, 0x75, 0xA4, 0x5F, 0xEA, 0x9A, 0xB1, + 0x42, 0xE1, 0x3D, 0x4F, 0xD9, 0xBF, 0x2F, 0xD1, + 0x39, 0xFC, 0x09, 0xC2, 0xB1, 0xF0, 0x35, 0xD7, + 0xEB, 0xC8, 0x47, 0x76, 0x0A, 0xC2, 0x66, 0x9B, + 0xB8, 0x82, 0xE0, 0x8E, 0x8D, 0x50, 0x92, 0x2C + }, + { + 0x8C, 0x28, 0x55, 0x62, 0x70, 0x7C, 0x13, 0xEC, + 0xC1, 0xD8, 0x01, 0x67, 0x51, 0x36, 0x17, 0x40, + 0xED, 0x15, 0x4F, 0x38, 0x52, 0xD5, 0x6F, 0xEA, + 0x82, 0x89, 0x85, 0xDD, 0x31, 0x8C, 0x58, 0x6B, + 0xE2, 0x90, 0xAB, 0x4D, 0x16, 0x7E, 0x51, 0x7F, + 0x5B, 0xD6, 0x30, 0x3C, 0x83, 0x1F, 0xE6, 0x46, + 0xB6, 0xA2, 0xCA, 0xB0, 0xBD, 0xDD, 0xFD, 0x36, + 0xEE, 0x83, 0x70, 0x0D, 0x63, 0x6F, 0x44, 0x85 + }, + { + 0x4B, 0x73, 0x46, 0x81, 0xDB, 0xD8, 0x0D, 0xB2, + 0x9B, 0xBA, 0x7E, 0xAF, 0x63, 0x5E, 0xA6, 0xCD, + 0xDF, 0xA5, 0xA8, 0xA6, 0xBF, 0xDB, 0x6D, 0x47, + 0x82, 0x3A, 0xF5, 0x0C, 0xC9, 0xFD, 0x02, 0xA9, + 0x99, 0xC9, 0xE0, 0x3E, 0x38, 0xF6, 0xBB, 0x1A, + 0x11, 0x1D, 0x09, 0xF7, 0xFD, 0x84, 0x20, 0x6A, + 0x4B, 0xF6, 0x9B, 0x08, 0xC6, 0xED, 0x7F, 0x90, + 0xF6, 0xCB, 0xFE, 0x13, 0x4F, 0x3D, 0x3C, 0xF0 + }, + { + 0xA7, 0x48, 0xF0, 0x0A, 0xFE, 0x23, 0x76, 0xE3, + 0x1C, 0xFA, 0x42, 0x9C, 0x3B, 0x98, 0x59, 0xEC, + 0x98, 0x67, 0x3F, 0xCA, 0xB2, 0xD6, 0xC3, 0x35, + 0x8C, 0xDD, 0xB2, 0xCA, 0x70, 0x02, 0x6C, 0xEC, + 0x2F, 0xC5, 0x9B, 0x02, 0xF6, 0x34, 0x18, 0xA4, + 0x87, 0x45, 0xDD, 0x03, 0xCB, 0x20, 0x1A, 0xC5, + 0x46, 0x6A, 0xB8, 0xB9, 0x37, 0x6B, 0xC7, 0xD1, + 0xA2, 0x97, 0x33, 0x8D, 0x3B, 0x29, 0xCD, 0xE8 + }, + { + 0xAF, 0x35, 0xA9, 0x34, 0xD9, 0x62, 0xB0, 0xE6, + 0x4F, 0x9D, 0xD1, 0x2E, 0x5D, 0x71, 0x64, 0xC0, + 0xDF, 0x1E, 0x10, 0xDA, 0x79, 0x35, 0xB0, 0xC1, + 0x57, 0x2D, 0xBD, 0x39, 0xFF, 0xC2, 0xF3, 0xA8, + 0x90, 0x83, 0x2F, 0xB2, 0x0A, 0xDB, 0x49, 0xA9, + 0x9B, 0x97, 0xCF, 0x5C, 0x11, 0x35, 0xF7, 0x21, + 0x87, 0xBB, 0xEE, 0xE3, 0xDB, 0xA9, 0xA1, 0xA2, + 0x20, 0x7F, 0xE6, 0x0F, 0xFD, 0x8F, 0xF9, 0x0E + }, + { + 0xA2, 0x3D, 0x26, 0x46, 0x78, 0xBF, 0x45, 0xE5, + 0xF7, 0x5D, 0x7F, 0x90, 0x1B, 0xBA, 0xC2, 0x43, + 0x56, 0x29, 0xD9, 0x53, 0x70, 0x02, 0x78, 0x48, + 0x56, 0xBA, 0x47, 0x37, 0x99, 0x5F, 0xDB, 0xE8, + 0xEA, 0x79, 0xF6, 0xE8, 0x81, 0x55, 0xEF, 0x5F, + 0x52, 0xEC, 0x77, 0xDF, 0x96, 0xD3, 0x19, 0xA2, + 0xF5, 0x5F, 0x57, 0x52, 0x3C, 0x46, 0xE5, 0xC9, + 0xAD, 0x0F, 0x1F, 0x16, 0xBB, 0x6A, 0x62, 0xF4 + }, + { + 0xBB, 0x1E, 0x60, 0xC3, 0x77, 0x0E, 0x48, 0xC4, + 0x37, 0xF6, 0xC0, 0x54, 0xB5, 0xE9, 0x7C, 0x48, + 0x70, 0x22, 0x4C, 0x6C, 0x01, 0xE5, 0xF0, 0xAD, + 0xD1, 0x0F, 0x24, 0x7A, 0x9A, 0x43, 0xC2, 0x12, + 0xF9, 0x7C, 0xCA, 0x1C, 0x28, 0x04, 0x28, 0x1F, + 0x6A, 0xED, 0xDF, 0x5B, 0xD5, 0x7F, 0x77, 0xC4, + 0xD3, 0xA9, 0xFB, 0x14, 0x48, 0x9F, 0x03, 0x0D, + 0x52, 0xF6, 0xF2, 0x56, 0x19, 0x3E, 0x3C, 0xFE + }, + { + 0x7D, 0x1C, 0x21, 0xA2, 0x85, 0x45, 0x73, 0xE1, + 0xC8, 0x73, 0xEC, 0x58, 0x76, 0x1B, 0xBC, 0xB8, + 0x42, 0x1D, 0xE3, 0x76, 0xF3, 0x1A, 0x91, 0xAA, + 0x61, 0x27, 0x25, 0x98, 0x9A, 0x52, 0xBD, 0xCB, + 0x01, 0xCC, 0xB4, 0xAE, 0x0C, 0x07, 0x22, 0x23, + 0x00, 0x8B, 0xF0, 0xFF, 0xCA, 0x67, 0x7C, 0x12, + 0x4E, 0x1E, 0xC3, 0xB5, 0x7D, 0x0D, 0x76, 0x99, + 0xB9, 0x4D, 0xC5, 0xEB, 0xA2, 0x4A, 0x2E, 0x0E + }, + { + 0x0F, 0xBD, 0x03, 0x5E, 0xF7, 0xF8, 0x3D, 0xB0, + 0x5C, 0xC1, 0xB1, 0x98, 0xCA, 0x08, 0x03, 0xCE, + 0xB0, 0x01, 0x1C, 0x68, 0x84, 0x4A, 0x33, 0x7E, + 0xDB, 0x42, 0xA2, 0xF7, 0x58, 0x89, 0x07, 0x6E, + 0xA6, 0xF3, 0x2E, 0x55, 0xE3, 0xE8, 0xCC, 0xE8, + 0xEC, 0xBD, 0xCE, 0xD6, 0x5B, 0xA3, 0x2B, 0x91, + 0x6F, 0x51, 0x29, 0x58, 0xCF, 0xFD, 0x30, 0x55, + 0x16, 0xC7, 0xA1, 0xD0, 0x9F, 0xE2, 0xED, 0xC9 + }, + { + 0xE9, 0xC3, 0x98, 0xCA, 0x30, 0x72, 0x95, 0x36, + 0xB3, 0x68, 0xDD, 0x5C, 0x17, 0xAC, 0x74, 0xB2, + 0x20, 0xD6, 0x74, 0x71, 0xBC, 0x4C, 0xEB, 0xFE, + 0x66, 0x13, 0x0F, 0xFC, 0x54, 0x62, 0xD9, 0x16, + 0x86, 0xB6, 0x13, 0xCA, 0x4B, 0xAD, 0xA8, 0x9B, + 0x19, 0xFF, 0x23, 0xE1, 0xA0, 0xF6, 0xEB, 0x7F, + 0x27, 0x9C, 0x1E, 0x78, 0x89, 0x40, 0xFD, 0x39, + 0x20, 0x93, 0xA3, 0x0C, 0xF6, 0x8C, 0x92, 0x71 + }, + { + 0xF4, 0x83, 0xF5, 0x13, 0x77, 0xA8, 0x8D, 0x7B, + 0xC9, 0x5C, 0x52, 0x0E, 0x91, 0x44, 0xBD, 0x3F, + 0xEB, 0x8F, 0xBB, 0x75, 0x47, 0xE8, 0x89, 0x78, + 0xC5, 0xCB, 0x45, 0xD8, 0x0D, 0x40, 0xD1, 0xE2, + 0x94, 0x5C, 0xF4, 0x9A, 0x65, 0x3B, 0x2E, 0x05, + 0x8D, 0x89, 0xB8, 0xBB, 0x4F, 0xFF, 0x05, 0x56, + 0x91, 0x5D, 0x1C, 0x52, 0x9B, 0x8C, 0x5E, 0x1D, + 0x59, 0xCB, 0xBC, 0xBE, 0x08, 0x60, 0xF8, 0x11 + }, + { + 0x0E, 0x10, 0x43, 0xA3, 0xDE, 0x4F, 0x6D, 0xF4, + 0x7A, 0x6E, 0xAD, 0x32, 0x3E, 0xC4, 0x58, 0xE2, + 0x70, 0xAC, 0x92, 0xD7, 0x9E, 0xD3, 0x77, 0xAD, + 0xE6, 0x32, 0x49, 0x8E, 0x4E, 0x7F, 0xAD, 0xEF, + 0xE5, 0x1C, 0x21, 0xFA, 0xCC, 0xD5, 0xCB, 0xAA, + 0xAC, 0xA6, 0x20, 0x5E, 0x87, 0x65, 0x0B, 0x6C, + 0x9A, 0x36, 0x15, 0xC7, 0x53, 0xA0, 0xBD, 0x1A, + 0x93, 0xC2, 0xA4, 0x44, 0x8B, 0x3A, 0xCE, 0xA1 + }, + { + 0xB1, 0x5A, 0xF4, 0xC6, 0xC8, 0x07, 0x78, 0x4C, + 0xD0, 0x47, 0x76, 0x53, 0x06, 0x5F, 0xF0, 0x64, + 0x0D, 0x32, 0x2F, 0x5C, 0x44, 0x30, 0x88, 0x4E, + 0xAF, 0x31, 0x75, 0xF9, 0xE2, 0x24, 0xCC, 0x7B, + 0xEF, 0xF1, 0x6B, 0x81, 0xB5, 0x73, 0xCD, 0x31, + 0x55, 0xBD, 0x5E, 0xBB, 0x55, 0x49, 0x25, 0x54, + 0x3E, 0x4E, 0x3F, 0x30, 0x70, 0xAD, 0xD4, 0xC6, + 0x6D, 0x09, 0x3C, 0x4D, 0x0B, 0x8C, 0x39, 0x21 + }, + { + 0x48, 0xFD, 0xE4, 0xD5, 0x37, 0x1F, 0x74, 0xAE, + 0x55, 0x6C, 0x39, 0xA9, 0x41, 0x2E, 0xB6, 0x60, + 0xCB, 0xC6, 0x70, 0xBC, 0x7F, 0x31, 0xA5, 0x62, + 0x9E, 0xD7, 0xE6, 0x1D, 0x06, 0x39, 0x43, 0x73, + 0x57, 0x40, 0x91, 0x90, 0x57, 0x8F, 0x6D, 0x1B, + 0x39, 0x92, 0xB3, 0x5B, 0x58, 0xC9, 0xD2, 0x13, + 0xE2, 0x2D, 0x28, 0x5D, 0xB3, 0x02, 0xE5, 0xB4, + 0x1E, 0x52, 0xF1, 0x64, 0x4A, 0xBE, 0xBA, 0xDD + }, + { + 0xF5, 0x40, 0x3A, 0x4A, 0xE1, 0x59, 0xEE, 0x45, + 0x7A, 0x56, 0x5D, 0xAE, 0xD3, 0x9E, 0xB1, 0x27, + 0xD2, 0xFC, 0xEB, 0xDE, 0xD6, 0xE0, 0x6A, 0x4A, + 0xA1, 0x84, 0x38, 0x93, 0xA3, 0x6D, 0x78, 0xD1, + 0x19, 0x04, 0x10, 0xA5, 0xAD, 0x0A, 0x45, 0x30, + 0x1B, 0x4A, 0x5F, 0x32, 0x6D, 0xB2, 0x5C, 0xF8, + 0x88, 0x58, 0x83, 0x1A, 0x4A, 0x68, 0x04, 0x76, + 0xA4, 0xFD, 0xDB, 0xB9, 0xDE, 0x79, 0x41, 0x33 + }, + { + 0xB5, 0x05, 0xCE, 0xEE, 0xB7, 0xE1, 0x77, 0xB9, + 0xFD, 0xB5, 0x97, 0x98, 0x42, 0xD4, 0xF1, 0x1B, + 0x0C, 0xEC, 0xA0, 0xEA, 0xF7, 0x10, 0x8B, 0xDB, + 0xAA, 0xA4, 0xE5, 0xDE, 0x8B, 0xE4, 0xAF, 0x01, + 0x87, 0x5F, 0x9D, 0x5D, 0x8A, 0x1D, 0x01, 0x61, + 0x08, 0xE0, 0xCC, 0x93, 0xE4, 0x45, 0xA5, 0x8C, + 0x24, 0x98, 0x07, 0x94, 0xBB, 0x1F, 0x8B, 0x83, + 0xD5, 0xAA, 0xF7, 0xE1, 0x75, 0xE8, 0xC5, 0x26 + }, + { + 0xBF, 0x8E, 0xD9, 0x98, 0x17, 0xD6, 0xAC, 0x9C, + 0x15, 0x06, 0x1F, 0x59, 0x8C, 0xBC, 0x6F, 0x23, + 0x1D, 0x84, 0xE2, 0xEF, 0xF8, 0x81, 0x31, 0x18, + 0xBA, 0x1B, 0xA5, 0x9B, 0x9B, 0x70, 0x0B, 0x34, + 0xE6, 0x10, 0xF2, 0x07, 0x0D, 0x05, 0x17, 0x26, + 0xF7, 0x0D, 0xA8, 0x83, 0xB2, 0x80, 0xF8, 0xEE, + 0x0A, 0x06, 0x31, 0xA7, 0xCB, 0x4B, 0xF8, 0x2C, + 0x71, 0xB5, 0x4D, 0xE2, 0x8F, 0x19, 0x62, 0xB8 + }, + { + 0x14, 0x1A, 0x7F, 0x23, 0x35, 0x33, 0x42, 0xB4, + 0xF2, 0xE9, 0xF0, 0xE2, 0xD1, 0x3B, 0xF7, 0xE8, + 0x04, 0x72, 0xCC, 0xE2, 0xFC, 0x77, 0x67, 0x20, + 0xA4, 0xBE, 0x5F, 0x7C, 0xE7, 0xE7, 0x98, 0xF2, + 0x9C, 0xCE, 0x60, 0xE0, 0x04, 0xC1, 0x43, 0x70, + 0x82, 0xBE, 0x01, 0xA5, 0xA7, 0xD2, 0xA4, 0x28, + 0xA8, 0x65, 0x57, 0x37, 0x72, 0x4C, 0x62, 0x68, + 0xC8, 0x33, 0xFD, 0xCE, 0x47, 0x18, 0x1F, 0x8D + }, + { + 0x6E, 0xC9, 0x17, 0x6C, 0x07, 0xC3, 0xAB, 0xBC, + 0x23, 0xC1, 0x0D, 0x72, 0x90, 0x1D, 0xE3, 0x52, + 0xA8, 0xC5, 0xB4, 0x10, 0xB0, 0x6F, 0x94, 0x90, + 0x8A, 0x5D, 0x1F, 0x52, 0x96, 0x65, 0x88, 0xA6, + 0xF1, 0x5A, 0x78, 0xFA, 0x65, 0xB7, 0xA0, 0x86, + 0x54, 0x69, 0xB1, 0x52, 0xFF, 0x6B, 0x62, 0x6B, + 0x5D, 0x64, 0x45, 0x0B, 0x83, 0x94, 0xAB, 0xB7, + 0xF6, 0x95, 0x01, 0xE9, 0x54, 0x76, 0xB2, 0xEF + }, + { + 0x56, 0xC6, 0x53, 0x88, 0xDA, 0x93, 0x1B, 0x0E, + 0x73, 0x2D, 0xBF, 0x1D, 0x8B, 0x48, 0xF2, 0xA5, + 0x24, 0x28, 0x0B, 0xB1, 0xF4, 0x6D, 0xFE, 0x1C, + 0x6E, 0xA8, 0x1D, 0xED, 0x3C, 0x7C, 0x98, 0xE1, + 0xBE, 0xA1, 0x47, 0x42, 0x57, 0x00, 0x15, 0x4C, + 0x18, 0x72, 0x46, 0x72, 0x59, 0x38, 0x20, 0xCE, + 0x82, 0x26, 0x7A, 0xA4, 0x39, 0x83, 0x51, 0x8F, + 0xA4, 0xB5, 0xD4, 0x1F, 0x40, 0x03, 0xCD, 0x00 + }, + { + 0x06, 0xFD, 0x95, 0xF0, 0xD7, 0x88, 0x1E, 0x0A, + 0xAE, 0xD5, 0xD6, 0x0F, 0x70, 0x34, 0x30, 0x78, + 0x42, 0xBD, 0x07, 0xC4, 0x6C, 0x60, 0x4E, 0xB8, + 0x80, 0xDE, 0xC9, 0xBB, 0x89, 0xFF, 0x3F, 0xF2, + 0x0B, 0x61, 0xC5, 0x14, 0x86, 0xE9, 0x68, 0x77, + 0x25, 0x08, 0x52, 0x41, 0x4E, 0x4A, 0xAF, 0xF6, + 0x26, 0x49, 0xF9, 0x0C, 0xE9, 0x42, 0xFC, 0x6C, + 0xB7, 0x0B, 0xCE, 0x8C, 0x73, 0x40, 0x3F, 0xB7 + }, + { + 0x04, 0x64, 0x47, 0x52, 0x57, 0xA2, 0x31, 0x79, + 0xAF, 0x28, 0x5C, 0x22, 0x2E, 0xAC, 0x9D, 0xB7, + 0x9F, 0x5C, 0x2A, 0x8E, 0x41, 0x8F, 0x0E, 0x6B, + 0x4A, 0xCB, 0x63, 0xE0, 0x7E, 0xF2, 0x7D, 0x73, + 0x8A, 0x95, 0x01, 0xB1, 0x0C, 0xB4, 0x12, 0x93, + 0xAB, 0xC4, 0xFA, 0xF4, 0xF0, 0xC7, 0x78, 0x46, + 0x4C, 0xBC, 0xB0, 0x25, 0xAF, 0x81, 0x2F, 0x81, + 0x12, 0xA4, 0x60, 0xC6, 0xC6, 0x6B, 0xC1, 0xD6 + }, + { + 0x67, 0x9E, 0x4C, 0x13, 0x1A, 0x36, 0x7E, 0xC1, + 0xAD, 0x66, 0xE6, 0xBF, 0xA5, 0xB5, 0x87, 0xEC, + 0xC2, 0x25, 0xA9, 0x58, 0x48, 0x27, 0xC8, 0xB7, + 0x5E, 0x41, 0x46, 0x50, 0x99, 0xB8, 0x09, 0x55, + 0x85, 0xDE, 0x33, 0x5F, 0xD7, 0x48, 0xB8, 0xE9, + 0xB7, 0xF7, 0x7C, 0x91, 0x9B, 0x16, 0x4E, 0xF0, + 0xBF, 0xB5, 0xF4, 0xFB, 0xFA, 0xD8, 0xAC, 0x23, + 0x99, 0x3F, 0x5E, 0xD2, 0x4A, 0xDA, 0xBA, 0xFA + }, + { + 0x52, 0x17, 0x96, 0x8F, 0x46, 0x4C, 0x31, 0x81, + 0xFD, 0xC3, 0x6F, 0x3B, 0x42, 0xF6, 0xDB, 0xFD, + 0x0E, 0x18, 0xD9, 0x1C, 0x7A, 0x3F, 0x96, 0xA9, + 0xA9, 0x59, 0x97, 0x13, 0xF0, 0x74, 0xA8, 0x47, + 0xC5, 0x0B, 0x21, 0x20, 0xAD, 0x52, 0x22, 0xEE, + 0xB3, 0x6B, 0x27, 0xCD, 0x11, 0x49, 0xF2, 0x39, + 0x47, 0xA4, 0x25, 0x00, 0x0D, 0x6B, 0x41, 0x94, + 0x9A, 0x74, 0xAF, 0x7F, 0x40, 0x88, 0x00, 0x32 + }, + { + 0x97, 0xA6, 0x47, 0xA7, 0xC0, 0xB7, 0x47, 0xC0, + 0xA9, 0xC0, 0x46, 0xCE, 0xDF, 0x91, 0x99, 0xBF, + 0xE6, 0x62, 0x2F, 0xA0, 0x1C, 0xD8, 0x73, 0xD8, + 0x05, 0xDB, 0x50, 0x72, 0xF0, 0x66, 0xDE, 0x5F, + 0x5B, 0xCC, 0x5F, 0x9C, 0x77, 0x1B, 0xFB, 0xCF, + 0xCE, 0x82, 0x24, 0x62, 0x47, 0x7B, 0xD4, 0x18, + 0x5B, 0xFA, 0xC3, 0x7C, 0x01, 0x31, 0x9A, 0x4C, + 0xF4, 0x7C, 0x2F, 0xAC, 0x78, 0x78, 0xFA, 0xBE + }, + { + 0x2A, 0xA1, 0x35, 0x7C, 0x30, 0xE3, 0xB3, 0xC8, + 0xC1, 0x87, 0x65, 0x10, 0x92, 0x46, 0x8A, 0xBE, + 0x17, 0xE0, 0xCA, 0xF4, 0xC1, 0x94, 0x7C, 0x78, + 0x64, 0x15, 0xE1, 0xE5, 0xB9, 0x39, 0xCD, 0x59, + 0x81, 0x90, 0x57, 0xB4, 0xC8, 0x53, 0x89, 0x67, + 0xEE, 0x72, 0x07, 0x12, 0x21, 0x90, 0x44, 0xE2, + 0x44, 0xE0, 0xBE, 0x20, 0xAD, 0x63, 0xE9, 0xA2, + 0x07, 0x8B, 0xA7, 0x47, 0xD8, 0x2E, 0x5D, 0xF0 + }, + { + 0xF1, 0xA0, 0x23, 0xF3, 0x68, 0x48, 0x95, 0x68, + 0xC7, 0xE0, 0x48, 0x50, 0x82, 0x92, 0x03, 0x5E, + 0x7A, 0xAF, 0x7B, 0x24, 0x19, 0x15, 0xF4, 0xCE, + 0x67, 0x04, 0x42, 0x2C, 0x8B, 0xFE, 0x35, 0xE9, + 0x43, 0xCC, 0xD2, 0x4A, 0x47, 0x91, 0x3E, 0x52, + 0x02, 0x6F, 0x22, 0x92, 0x7F, 0xCD, 0xC5, 0xD3, + 0xE5, 0xFD, 0xA9, 0xF2, 0x70, 0xBB, 0xB6, 0xBA, + 0xDE, 0x27, 0xE2, 0xED, 0x99, 0x27, 0xC5, 0xFD + }, + { + 0xB4, 0xFC, 0x62, 0xAB, 0xB7, 0x65, 0xD4, 0x2A, + 0xAC, 0xC4, 0x91, 0xDC, 0x98, 0xE8, 0x82, 0x64, + 0x2D, 0xDB, 0x8C, 0x71, 0x67, 0x09, 0xF6, 0x49, + 0xE5, 0x0D, 0xAA, 0x53, 0x96, 0x91, 0x5D, 0xEB, + 0x22, 0x4C, 0xC3, 0x8B, 0x11, 0x41, 0xAD, 0x07, + 0x1E, 0x00, 0x71, 0x19, 0x9F, 0x27, 0x94, 0xFD, + 0x8D, 0x61, 0x1D, 0x22, 0x22, 0x44, 0x17, 0x5D, + 0x9D, 0x2D, 0x52, 0x46, 0x4C, 0xA6, 0xE7, 0xD7 + }, + { + 0x35, 0xBC, 0x92, 0xA1, 0xEC, 0xCD, 0xD1, 0xBB, + 0x44, 0x55, 0x62, 0xDC, 0x34, 0x85, 0x15, 0x66, + 0xFF, 0xBD, 0x4A, 0xCD, 0x89, 0x8B, 0x79, 0x52, + 0xEC, 0xC2, 0x19, 0x44, 0x50, 0xFE, 0x4B, 0x16, + 0x0A, 0x5C, 0x9E, 0x4D, 0x92, 0xA2, 0x71, 0x2B, + 0xDA, 0x72, 0x5D, 0xAF, 0x16, 0xA5, 0xE8, 0x11, + 0x31, 0xE8, 0xA3, 0xC7, 0xE5, 0x67, 0xC1, 0x66, + 0xE3, 0xE9, 0xEE, 0x34, 0x75, 0x23, 0xA5, 0x6F + }, + { + 0xE9, 0x22, 0x66, 0xB5, 0x95, 0x50, 0x84, 0x7C, + 0xA4, 0xBB, 0x14, 0x26, 0xDE, 0xFB, 0xF5, 0x54, + 0x37, 0x2F, 0x1C, 0x64, 0x0C, 0x05, 0x9B, 0x26, + 0x9F, 0xC2, 0x48, 0xDB, 0x75, 0xDF, 0x78, 0x91, + 0x10, 0x76, 0xC8, 0x15, 0x60, 0x92, 0xAB, 0xA9, + 0x1C, 0xA2, 0x57, 0x61, 0x4C, 0x1E, 0x94, 0xDB, + 0x87, 0x10, 0x55, 0xD3, 0x54, 0xEB, 0x4E, 0x80, + 0x49, 0xE2, 0x1C, 0xB4, 0xC7, 0x40, 0x0D, 0x22 + }, + { + 0xDC, 0xF2, 0x0A, 0xC4, 0x78, 0x66, 0x7A, 0x83, + 0x4C, 0x9B, 0xA7, 0xC0, 0x47, 0x26, 0x9A, 0x2B, + 0x90, 0x9B, 0x6B, 0x14, 0x8D, 0x08, 0x44, 0xD0, + 0xD5, 0x41, 0x62, 0xB6, 0x63, 0x03, 0xFF, 0x39, + 0x3B, 0x91, 0x07, 0x4B, 0xA5, 0x17, 0xAE, 0xDC, + 0xAB, 0x25, 0x5D, 0x79, 0x80, 0x41, 0x2A, 0x47, + 0x0C, 0x57, 0x6D, 0xB9, 0x59, 0xF3, 0xF9, 0x8C, + 0x09, 0x5E, 0x49, 0x64, 0xCA, 0x3D, 0x6E, 0xB0 + }, + { + 0x24, 0x8F, 0x76, 0xE4, 0x9D, 0x93, 0x6B, 0x8A, + 0x1F, 0xAA, 0x08, 0xE3, 0x31, 0x0C, 0x0E, 0x12, + 0xCC, 0xFB, 0xDF, 0xC0, 0x23, 0x27, 0x6B, 0x4A, + 0xE3, 0x66, 0x17, 0xFE, 0x5A, 0xA2, 0xE7, 0x94, + 0x3B, 0x2B, 0xDA, 0xC4, 0xF0, 0xA5, 0xD4, 0xAD, + 0xCA, 0x5A, 0x50, 0x10, 0xC0, 0x1C, 0x5B, 0xBE, + 0xBB, 0x57, 0x63, 0x62, 0x55, 0xD4, 0xF0, 0xA3, + 0xB1, 0xB6, 0x9C, 0x8A, 0x89, 0x6C, 0x29, 0x8E + }, + { + 0x7B, 0x20, 0xC6, 0x74, 0x38, 0xB6, 0xD9, 0x66, + 0x2B, 0x53, 0x5C, 0x72, 0x65, 0xAB, 0x88, 0xC5, + 0xDF, 0x61, 0xE0, 0xC5, 0xFC, 0x5E, 0x12, 0x62, + 0x13, 0x03, 0x97, 0x54, 0x1E, 0x8D, 0x89, 0xEF, + 0x89, 0x27, 0x21, 0xE6, 0x0C, 0x7E, 0x19, 0x34, + 0xD0, 0x96, 0x07, 0x6C, 0xD9, 0x12, 0x64, 0x16, + 0xCC, 0x50, 0xA1, 0xC9, 0xE4, 0x57, 0x85, 0x98, + 0x02, 0x9D, 0xB5, 0x3E, 0x1E, 0x4D, 0xD0, 0x19 + }, + { + 0x73, 0xFF, 0xE6, 0x8A, 0x52, 0x56, 0x42, 0x9D, + 0x0D, 0xB0, 0x91, 0xC9, 0x96, 0x6C, 0xF1, 0x7D, + 0x8F, 0x63, 0x97, 0x7E, 0x4D, 0x78, 0xB1, 0x5F, + 0x5D, 0x68, 0x4E, 0x5C, 0x64, 0x47, 0x7B, 0x7F, + 0x12, 0x4B, 0xDA, 0x08, 0x52, 0x54, 0xFA, 0x42, + 0x41, 0xA3, 0xB6, 0x81, 0xAA, 0x55, 0x95, 0x5C, + 0x4F, 0x60, 0x3B, 0xB7, 0x39, 0xCC, 0xE0, 0xA9, + 0xA9, 0x90, 0x87, 0xA5, 0x70, 0xC8, 0x4A, 0x8C + }, + { + 0x50, 0x70, 0x35, 0x76, 0xAF, 0xF1, 0x55, 0x03, + 0xBB, 0xC7, 0xF2, 0xE1, 0x41, 0x75, 0x00, 0xA7, + 0x9E, 0xC6, 0x08, 0x2B, 0xB2, 0x32, 0x28, 0x67, + 0x63, 0xFE, 0x86, 0x35, 0xF3, 0x47, 0x07, 0x73, + 0x65, 0xBE, 0x47, 0xA0, 0x96, 0xE5, 0xE5, 0x30, + 0xB9, 0xC2, 0xFB, 0x94, 0x97, 0xC0, 0x73, 0x40, + 0xF8, 0x51, 0x68, 0xC0, 0xC9, 0xCD, 0xEA, 0xEC, + 0x76, 0x06, 0x8E, 0x82, 0xEE, 0x90, 0x25, 0x84 + }, + { + 0x56, 0x6E, 0x09, 0x98, 0x2E, 0xAF, 0xB5, 0x80, + 0x5B, 0xD9, 0x36, 0xFA, 0x80, 0xDB, 0x78, 0x8A, + 0x3D, 0x7A, 0xB7, 0x80, 0xEA, 0x8E, 0x27, 0xD5, + 0x26, 0xA6, 0x0F, 0x5F, 0x0E, 0x49, 0x06, 0xCB, + 0x4E, 0xBB, 0x4D, 0x67, 0x14, 0x28, 0x76, 0x1F, + 0x47, 0x39, 0xCE, 0x9D, 0x2E, 0xAF, 0xF2, 0x30, + 0x8A, 0xA0, 0xBF, 0xDC, 0x36, 0x02, 0x65, 0xD0, + 0x34, 0xC8, 0x9B, 0x40, 0x53, 0xB0, 0x73, 0x05 + }, + { + 0xCA, 0x8C, 0xB1, 0x9D, 0x86, 0xD4, 0x0B, 0xBA, + 0xEC, 0x28, 0x74, 0x75, 0x7C, 0x21, 0xBA, 0x76, + 0x7A, 0xAE, 0x8A, 0xF9, 0xD7, 0xBC, 0x50, 0x3B, + 0xFE, 0xB0, 0x97, 0xCE, 0x77, 0xC8, 0x09, 0xA7, + 0xEF, 0x6F, 0xBD, 0x66, 0x89, 0xA8, 0xAC, 0xA3, + 0xB4, 0x14, 0x00, 0xA0, 0x23, 0x1A, 0x8D, 0x67, + 0xFB, 0x0D, 0x9F, 0x0A, 0x3A, 0xCC, 0x5F, 0x22, + 0x60, 0x3D, 0x56, 0x0B, 0xF1, 0x9E, 0x70, 0xF6 + }, + { + 0x24, 0x50, 0xC0, 0x36, 0x77, 0x45, 0x73, 0xF7, + 0x89, 0x52, 0x7E, 0x42, 0x55, 0xAB, 0xF9, 0x4F, + 0xC5, 0x1E, 0x19, 0x08, 0x4A, 0x97, 0x1F, 0x03, + 0xA1, 0x36, 0x8B, 0x88, 0x92, 0x60, 0x65, 0x49, + 0x6F, 0x4F, 0x81, 0x03, 0xEE, 0xD7, 0xB6, 0xCD, + 0x22, 0xEF, 0xD9, 0xDF, 0x09, 0xF4, 0x81, 0x91, + 0xB7, 0x69, 0x37, 0x7E, 0xC1, 0x57, 0x73, 0x22, + 0x62, 0x83, 0xDB, 0x16, 0xF2, 0x4C, 0x4F, 0x3B + }, + { + 0xE1, 0xC7, 0xC1, 0x00, 0x00, 0x2A, 0xB3, 0x18, + 0xDF, 0xD2, 0xF6, 0x71, 0x89, 0x57, 0x66, 0xE6, + 0xD9, 0xAE, 0xBB, 0x4C, 0xDE, 0x7D, 0x7C, 0x39, + 0xBE, 0x62, 0xE5, 0xCE, 0x70, 0x42, 0xBE, 0xCE, + 0x65, 0x88, 0x9D, 0xD8, 0xCD, 0xC1, 0x49, 0x06, + 0x6F, 0xB6, 0x77, 0x02, 0x91, 0xB9, 0xE5, 0x37, + 0xE5, 0xFB, 0xFB, 0xD9, 0x7F, 0xD0, 0x92, 0x0F, + 0xFC, 0x93, 0x27, 0x5F, 0xD6, 0xFB, 0x15, 0xCD + }, + { + 0xA5, 0x70, 0xCC, 0x25, 0xCE, 0x58, 0xA0, 0xA0, + 0xBC, 0x73, 0xFE, 0x1F, 0x56, 0xBF, 0xF8, 0x8C, + 0x6C, 0x48, 0x19, 0xCD, 0x67, 0xD8, 0x7A, 0xAB, + 0x56, 0xAF, 0xDE, 0x68, 0x41, 0x96, 0xD1, 0x15, + 0x11, 0x54, 0x9F, 0xF4, 0x2F, 0xD3, 0x87, 0xE2, + 0xBB, 0x24, 0x5F, 0xFE, 0x03, 0xEA, 0x5A, 0xE0, + 0x2E, 0x24, 0x99, 0x29, 0x46, 0x3E, 0xE2, 0xBB, + 0x8B, 0xFF, 0x93, 0x8B, 0x12, 0x14, 0x76, 0xCD + }, + { + 0xEE, 0x40, 0x57, 0x6A, 0x69, 0x4B, 0x87, 0x9E, + 0xC4, 0xC1, 0x25, 0xA2, 0xB9, 0xBA, 0xD4, 0xC0, + 0xDB, 0x64, 0xC5, 0x91, 0x2A, 0x60, 0x10, 0xE1, + 0x02, 0x02, 0x63, 0xD8, 0x6A, 0x39, 0x8C, 0xD2, + 0xA6, 0x3B, 0x80, 0xA0, 0x87, 0x21, 0xB8, 0xFE, + 0x1D, 0x9A, 0xED, 0x31, 0xE7, 0x38, 0x80, 0xE9, + 0xEA, 0x9D, 0x29, 0x49, 0x66, 0x31, 0xB5, 0x1B, + 0x0F, 0x28, 0xAE, 0xD9, 0x8E, 0x58, 0xFA, 0xF8 + }, + { + 0x94, 0x7D, 0x01, 0xE0, 0x4E, 0xE5, 0xC2, 0x93, + 0x66, 0x82, 0xCF, 0xA6, 0xF8, 0xCE, 0xB9, 0x4F, + 0x80, 0x39, 0x38, 0xE3, 0x94, 0x14, 0xD9, 0xCA, + 0x39, 0xA1, 0xC6, 0xF0, 0xB8, 0x4B, 0xE5, 0xC3, + 0xF0, 0x25, 0x9B, 0x83, 0x7D, 0x26, 0x75, 0xC7, + 0xB7, 0x3A, 0x00, 0xAF, 0x0A, 0x66, 0x29, 0x05, + 0xEA, 0x99, 0x6C, 0x4E, 0xA4, 0xBF, 0xAD, 0xCB, + 0x6F, 0xDE, 0xB3, 0x48, 0x6C, 0xD3, 0xE6, 0xB6 + }, + { + 0x78, 0x25, 0x4C, 0xE3, 0x74, 0xDC, 0xBF, 0xA1, + 0x17, 0xA1, 0x7B, 0xFB, 0x90, 0xF2, 0x7C, 0xD3, + 0xCF, 0xA1, 0x7B, 0x2A, 0x23, 0xF8, 0x31, 0x25, + 0x2D, 0x27, 0x00, 0xA7, 0xD0, 0xC4, 0x4C, 0x08, + 0x15, 0x15, 0x90, 0xDE, 0xA8, 0x14, 0xBA, 0x0D, + 0xBA, 0xC6, 0x4B, 0x8D, 0x41, 0x79, 0x31, 0x2C, + 0x5B, 0x95, 0x10, 0x92, 0x41, 0x55, 0xBF, 0x0A, + 0x13, 0x6E, 0xA3, 0xEA, 0x0E, 0xF3, 0x38, 0x7D + }, + { + 0xE5, 0x65, 0x5C, 0x2A, 0xC3, 0xE0, 0xDE, 0xEC, + 0x18, 0xEA, 0x5A, 0x50, 0xA2, 0x10, 0x8D, 0x6B, + 0x94, 0x9B, 0x8E, 0xAD, 0x65, 0xAB, 0xA8, 0xE2, + 0x8F, 0x59, 0x20, 0x6A, 0xBA, 0xBA, 0x66, 0x57, + 0x8A, 0xB4, 0xDB, 0x99, 0x04, 0xFB, 0x93, 0x36, + 0x33, 0x69, 0xED, 0x5F, 0xD3, 0x0A, 0xA6, 0x03, + 0x24, 0x24, 0x82, 0x0A, 0x2B, 0xE5, 0x50, 0x53, + 0x80, 0x30, 0x23, 0x2C, 0xEF, 0x31, 0x40, 0xB3 + }, + { + 0x43, 0xB0, 0xC9, 0xE6, 0x71, 0x3E, 0xB4, 0x95, + 0x18, 0xEF, 0xC1, 0x9B, 0xDC, 0x32, 0x47, 0xC5, + 0x9A, 0x8E, 0x2E, 0x4E, 0xB0, 0x12, 0x0B, 0x6A, + 0xB3, 0x3A, 0x73, 0xDA, 0x3E, 0x59, 0xF4, 0xCD, + 0x7B, 0x20, 0x18, 0xAD, 0x93, 0xA1, 0x83, 0xA7, + 0xBB, 0x86, 0x00, 0xAE, 0x90, 0xBB, 0x79, 0x83, + 0x1C, 0xDD, 0x9D, 0x4A, 0xCB, 0xD1, 0x84, 0x04, + 0x0C, 0x10, 0x55, 0x35, 0xCE, 0x7B, 0xA3, 0xA8 + }, + { + 0xE2, 0xE5, 0x0A, 0xC5, 0x9A, 0xFC, 0x6C, 0x2F, + 0x0F, 0x86, 0x8E, 0x1B, 0x15, 0xF5, 0xDC, 0x6C, + 0xF5, 0x6E, 0xA0, 0x7F, 0xB0, 0xE2, 0xDE, 0x94, + 0x31, 0x06, 0x8F, 0x58, 0x91, 0x54, 0x0D, 0xBB, + 0x97, 0x1B, 0xB5, 0x14, 0x84, 0xCB, 0xFC, 0xA3, + 0x4A, 0x46, 0xF2, 0x83, 0x8A, 0x53, 0x74, 0xD9, + 0x5D, 0x71, 0xDF, 0xCA, 0xF4, 0x44, 0x5D, 0x2C, + 0x69, 0xFB, 0x98, 0xA3, 0x94, 0x04, 0x38, 0x53 + }, + { + 0x50, 0x96, 0xD7, 0xAB, 0x69, 0xDC, 0xFA, 0x54, + 0x08, 0xC5, 0x6C, 0x71, 0xD3, 0x3E, 0x34, 0x28, + 0x8D, 0x3F, 0x87, 0x46, 0xB6, 0x71, 0xF3, 0x26, + 0xA5, 0x73, 0xD5, 0x61, 0xDA, 0xC3, 0xF9, 0x72, + 0x8A, 0x47, 0x6A, 0xC8, 0x57, 0x79, 0xD8, 0xC0, + 0xD3, 0x8F, 0x99, 0xA0, 0xDB, 0x09, 0xB9, 0xE4, + 0x07, 0xC3, 0x62, 0xFF, 0xBC, 0x5E, 0x8C, 0xC4, + 0x2A, 0x50, 0x97, 0x08, 0xDD, 0x3B, 0xF8, 0xB9 + }, + { + 0xC2, 0xDE, 0x2E, 0xD8, 0x1E, 0xF7, 0x8C, 0x8E, + 0x6E, 0x1B, 0xED, 0x28, 0x50, 0x9D, 0x82, 0x86, + 0x77, 0xF2, 0x92, 0xB7, 0x05, 0x55, 0xE1, 0xB6, + 0xE8, 0x82, 0x56, 0xA2, 0xA1, 0x6D, 0x82, 0x62, + 0xA1, 0xB0, 0x5B, 0xFE, 0x0B, 0x0D, 0xB0, 0x41, + 0x5F, 0x3B, 0x81, 0x11, 0x3F, 0xD9, 0x9F, 0xFD, + 0x3D, 0xA2, 0xB5, 0x63, 0xBA, 0x32, 0xF5, 0x1E, + 0x7E, 0xE6, 0xD8, 0x8F, 0xA3, 0x85, 0x9F, 0xDA + }, + { + 0x67, 0xE5, 0x7D, 0xAC, 0x9E, 0x7A, 0x70, 0x90, + 0x21, 0xDA, 0x15, 0xE7, 0xD2, 0xF5, 0x87, 0xEF, + 0x8C, 0xD7, 0x01, 0x9D, 0x94, 0xE6, 0x02, 0x38, + 0xBA, 0x0B, 0x35, 0x72, 0x03, 0x94, 0x34, 0x52, + 0xEE, 0x09, 0xBE, 0xD1, 0x1C, 0xBD, 0x56, 0xF2, + 0x37, 0xC7, 0x2A, 0xAE, 0x05, 0xEA, 0xD2, 0x68, + 0x5E, 0x8D, 0x00, 0x2C, 0xC8, 0xB8, 0x6B, 0xFD, + 0x85, 0x2E, 0x0B, 0x0F, 0x58, 0x34, 0x5B, 0x7A + }, + { + 0x06, 0xCD, 0x20, 0x0A, 0x3C, 0xAD, 0x18, 0xD3, + 0xC4, 0x82, 0x66, 0x5B, 0xCF, 0x64, 0x49, 0x78, + 0xAA, 0x4D, 0x7B, 0xCD, 0x13, 0x37, 0x09, 0x18, + 0xB9, 0x54, 0x9D, 0x42, 0x45, 0x08, 0xD3, 0xB7, + 0xFC, 0x64, 0xFF, 0x88, 0x6E, 0x32, 0xD0, 0xA5, + 0x70, 0xAE, 0x21, 0x2F, 0x8F, 0x2A, 0x67, 0x0B, + 0xBD, 0xCA, 0x47, 0x9A, 0xBA, 0x32, 0x49, 0x6D, + 0x7B, 0xB0, 0x88, 0xBD, 0x14, 0xC3, 0xAB, 0x2E + }, + { + 0x39, 0x60, 0x3B, 0xCD, 0x11, 0xEF, 0xA6, 0x28, + 0x9C, 0x3F, 0x4A, 0xD6, 0x35, 0x3C, 0xA2, 0x36, + 0x15, 0x3F, 0xB3, 0xFF, 0x8D, 0xF7, 0x9D, 0x4E, + 0x30, 0xC7, 0x91, 0xE5, 0xAF, 0x0B, 0x2F, 0x64, + 0x5D, 0x17, 0x7B, 0x1F, 0xF4, 0x8A, 0x46, 0x51, + 0x0E, 0x5F, 0x41, 0x1D, 0xF1, 0x64, 0x08, 0xBE, + 0xC8, 0x53, 0x69, 0x6F, 0x0B, 0xA0, 0x9B, 0x25, + 0x0A, 0x4E, 0xC1, 0x77, 0xAC, 0xB4, 0xFD, 0x79 + }, + { + 0xB2, 0x9D, 0xFE, 0xAE, 0x06, 0x4A, 0xF8, 0xB3, + 0x9C, 0xC4, 0x4B, 0x59, 0x57, 0x57, 0xAA, 0x3C, + 0x99, 0x86, 0x56, 0xC8, 0xBE, 0xED, 0x92, 0x58, + 0xBA, 0x0F, 0xF2, 0x2F, 0xF8, 0x9D, 0xA2, 0x60, + 0x6E, 0x57, 0x1B, 0xD6, 0x94, 0x95, 0x6F, 0x44, + 0x7C, 0xAD, 0xCB, 0x21, 0x19, 0x1C, 0x61, 0x9E, + 0x94, 0x14, 0x9F, 0x3E, 0x83, 0x3B, 0x91, 0x0F, + 0x7E, 0xC8, 0x40, 0x58, 0xD7, 0x83, 0x69, 0xF2 + }, + { + 0xAB, 0x39, 0x02, 0x1C, 0x93, 0xBB, 0x06, 0x09, + 0x82, 0xE2, 0x3D, 0x37, 0x3E, 0x35, 0x9D, 0x9C, + 0xD4, 0x28, 0x5A, 0x1F, 0xC6, 0x45, 0x58, 0x8C, + 0x50, 0x34, 0xAC, 0x93, 0xB7, 0xDD, 0xB6, 0xE8, + 0x96, 0x4A, 0x30, 0x43, 0xE9, 0xD6, 0xFB, 0x91, + 0x53, 0xA5, 0x34, 0x0A, 0x54, 0xDC, 0xB3, 0xBD, + 0xD6, 0x08, 0x91, 0xA1, 0xA9, 0xCD, 0x73, 0x57, + 0xFF, 0xB1, 0x23, 0xC4, 0x15, 0xA5, 0x14, 0x7E + }, + { + 0xCC, 0x5D, 0xE8, 0x8C, 0xCF, 0x7E, 0x2C, 0x8E, + 0x8C, 0x77, 0xAE, 0xEB, 0x04, 0x3E, 0x9D, 0xB9, + 0x37, 0xF3, 0x9A, 0x87, 0xE2, 0x2E, 0x6C, 0x58, + 0x24, 0x04, 0xC2, 0xA9, 0x48, 0x49, 0x18, 0xEB, + 0x6D, 0xC2, 0x07, 0xE9, 0xC3, 0x8B, 0xA3, 0x49, + 0x3F, 0x3B, 0xD0, 0xFF, 0xF3, 0x84, 0x3A, 0x47, + 0xD2, 0x73, 0xE8, 0x1B, 0xB4, 0x7B, 0xA7, 0xA8, + 0x69, 0xB9, 0x5F, 0x5D, 0xDC, 0x8D, 0xA6, 0xF9 + }, + { + 0xF2, 0x5A, 0x8A, 0x6A, 0x91, 0x16, 0x98, 0x3E, + 0xDE, 0xAD, 0x6C, 0x63, 0xAD, 0x9B, 0x9A, 0x5D, + 0xBC, 0x7E, 0xA9, 0x72, 0xC9, 0x3F, 0x70, 0xE3, + 0xFA, 0xDB, 0xE5, 0x27, 0x80, 0x02, 0x95, 0x3D, + 0xEC, 0x14, 0x24, 0xE9, 0xC9, 0xBD, 0x1C, 0xCA, + 0x30, 0x8E, 0xDE, 0xAE, 0x6B, 0x4D, 0xC0, 0x5D, + 0x48, 0x2B, 0x41, 0x1C, 0x19, 0x1E, 0x31, 0x72, + 0x2B, 0x12, 0x76, 0xFA, 0xF0, 0xA0, 0x35, 0xCF + }, + { + 0x27, 0x09, 0xAA, 0x30, 0xE4, 0x0D, 0xA3, 0x11, + 0xD7, 0xD9, 0xFA, 0x74, 0x78, 0x1F, 0x2E, 0xD5, + 0xA1, 0xFD, 0x7A, 0xCF, 0x43, 0xA9, 0x87, 0x7F, + 0x9A, 0x8A, 0x67, 0x1C, 0xB4, 0x1F, 0x44, 0x5E, + 0x1B, 0xED, 0xD6, 0xDB, 0x35, 0x7A, 0xBD, 0x75, + 0x57, 0xA1, 0x51, 0x22, 0x78, 0x64, 0x5E, 0xA9, + 0x77, 0x25, 0x6C, 0x95, 0xA5, 0xDE, 0xF8, 0x0C, + 0x89, 0x29, 0x8A, 0x95, 0x68, 0x2A, 0xBB, 0x79 + }, + { + 0xD5, 0x5D, 0xC7, 0x89, 0x23, 0x9E, 0xD4, 0x88, + 0xDE, 0x32, 0x2E, 0x03, 0x74, 0x44, 0x95, 0xC5, + 0xF7, 0xC4, 0x7B, 0xA6, 0x1A, 0x4A, 0x4A, 0x0A, + 0xF3, 0x4D, 0x7A, 0xF6, 0x42, 0xDC, 0xB4, 0x56, + 0xDE, 0x5D, 0xBD, 0x66, 0xAD, 0xE7, 0x1B, 0xFD, + 0x15, 0x65, 0xC4, 0x8B, 0xCA, 0x18, 0xD2, 0xA2, + 0xA9, 0x3C, 0x19, 0x17, 0xAA, 0x6E, 0x52, 0x2C, + 0x60, 0xF5, 0x2D, 0x2B, 0x56, 0x14, 0xCD, 0x15 + }, + { + 0xA6, 0x7E, 0xE2, 0xA7, 0x4D, 0xC4, 0x20, 0x7F, + 0xC9, 0x9D, 0x20, 0xF3, 0x1C, 0xD5, 0x34, 0x4C, + 0x10, 0xFE, 0x5A, 0xF5, 0xDC, 0x34, 0x30, 0x77, + 0xEB, 0x1F, 0x61, 0x89, 0x24, 0xFA, 0xC6, 0x12, + 0xD4, 0xC8, 0xB9, 0x29, 0x80, 0x08, 0x0E, 0xDF, + 0x6A, 0xEC, 0xD6, 0xD9, 0xEE, 0x1B, 0x4D, 0x23, + 0xE9, 0xD9, 0x5A, 0x46, 0x49, 0xC4, 0x47, 0x07, + 0xCA, 0x98, 0x07, 0x2D, 0xF0, 0xA5, 0x10, 0x69 + }, + { + 0xC2, 0xAB, 0x56, 0x3E, 0x48, 0x2A, 0x98, 0xFE, + 0x58, 0x2D, 0xE9, 0x7C, 0x82, 0x19, 0x9F, 0xB0, + 0x4C, 0xFE, 0x70, 0x00, 0xE5, 0xF4, 0x96, 0xD8, + 0x4D, 0xD6, 0x94, 0xC8, 0x18, 0xD3, 0xCE, 0x42, + 0x92, 0xFB, 0x59, 0x1A, 0x89, 0xBB, 0x26, 0x08, + 0x1E, 0x41, 0xC6, 0x0C, 0x2B, 0xF6, 0xA9, 0x0A, + 0x5C, 0xCA, 0x2B, 0x78, 0x7C, 0x96, 0x89, 0xB0, + 0x0D, 0xE6, 0xFA, 0xC1, 0xE0, 0x97, 0x5E, 0xFB + }, + { + 0x71, 0x22, 0x50, 0x7F, 0xB7, 0x04, 0x49, 0x2A, + 0xDB, 0x65, 0xD6, 0xFB, 0x75, 0x9A, 0x45, 0x87, + 0x8E, 0x8F, 0x2F, 0xF6, 0xEE, 0x68, 0x08, 0xEC, + 0x5E, 0x72, 0x76, 0xEF, 0xC4, 0xEF, 0x50, 0x8D, + 0xAE, 0xA3, 0x3D, 0xB3, 0xC9, 0x56, 0xC9, 0x93, + 0xD8, 0xBB, 0xA3, 0x8D, 0x79, 0x46, 0x57, 0xDC, + 0xA7, 0xA3, 0x9B, 0x3F, 0x0D, 0xF0, 0x22, 0xC0, + 0xEB, 0x22, 0x0F, 0x15, 0x61, 0x6E, 0x0C, 0xD1 + }, + { + 0x05, 0x58, 0xB2, 0x2B, 0x0B, 0xB2, 0xAF, 0x60, + 0x64, 0x09, 0x0A, 0x3E, 0x51, 0xC7, 0x5E, 0x2E, + 0x0C, 0x1D, 0x51, 0x1F, 0x30, 0xA2, 0xE7, 0xB0, + 0x9F, 0xF0, 0x86, 0x18, 0xEE, 0x06, 0xAB, 0x06, + 0xA3, 0xF8, 0x45, 0xBE, 0x3F, 0xB0, 0x8C, 0x68, + 0x1C, 0xBD, 0x12, 0x59, 0xE3, 0x35, 0x31, 0xC4, + 0xAC, 0xFF, 0xD4, 0xE4, 0x46, 0x2D, 0x7A, 0xD0, + 0x68, 0x15, 0x0C, 0xB4, 0xC7, 0x68, 0xF5, 0x97 + }, + { + 0x62, 0xAF, 0xB4, 0x87, 0x12, 0x0E, 0xBA, 0x0B, + 0xB1, 0x8C, 0xB4, 0xEF, 0x5A, 0x1A, 0x85, 0xFC, + 0x02, 0x47, 0xE1, 0xBA, 0xCF, 0xBA, 0x13, 0xD2, + 0x48, 0xCA, 0xBA, 0x41, 0x16, 0x0B, 0xB5, 0xC4, + 0xE2, 0x45, 0x53, 0x3B, 0x8D, 0x3A, 0xAA, 0xA8, + 0x7A, 0xA1, 0x5C, 0xBC, 0x0F, 0xE0, 0x0A, 0xA3, + 0x7D, 0x00, 0x96, 0x77, 0x1E, 0xA2, 0x9B, 0x67, + 0xAD, 0x6F, 0x2F, 0x49, 0x03, 0xD8, 0xC3, 0xF8 + }, + { + 0x63, 0xC6, 0x08, 0x15, 0x55, 0xEB, 0xC6, 0x9A, + 0xC4, 0x4A, 0xB5, 0x2A, 0x70, 0x8B, 0x6F, 0x2C, + 0xE7, 0x88, 0x9D, 0x93, 0x7F, 0x9F, 0xF3, 0xC5, + 0xA2, 0x7C, 0xA8, 0x8E, 0x57, 0x9E, 0xF9, 0x1D, + 0x0E, 0xF9, 0x8E, 0xE9, 0xDE, 0xD8, 0x72, 0x90, + 0x4C, 0xEA, 0x96, 0xD6, 0xD8, 0xD7, 0xD6, 0x39, + 0x30, 0x06, 0x9D, 0xDB, 0x1E, 0x1A, 0xAF, 0xFC, + 0xC3, 0xD9, 0x8F, 0xC3, 0x98, 0xC8, 0x5C, 0x95 + }, + { + 0x92, 0x71, 0x1D, 0x6C, 0x3F, 0x29, 0xC6, 0x49, + 0x72, 0x31, 0xC8, 0x75, 0xE1, 0x6A, 0xC8, 0x49, + 0x26, 0x9C, 0xC5, 0xD1, 0x4B, 0xEB, 0x74, 0x56, + 0x52, 0xC7, 0xF0, 0xD3, 0x64, 0x57, 0xEB, 0xB2, + 0xEF, 0x1A, 0xC5, 0x42, 0x04, 0xF2, 0xEE, 0xF9, + 0x3F, 0x67, 0x7F, 0x1A, 0xED, 0x78, 0x76, 0x52, + 0x9C, 0xC0, 0xB2, 0xAA, 0x16, 0xF6, 0x61, 0x25, + 0x22, 0x6E, 0xCA, 0x0A, 0xEB, 0x77, 0x02, 0x65 + }, + { + 0x62, 0xF3, 0x83, 0x49, 0xC3, 0x4C, 0x68, 0xB1, + 0xB1, 0x37, 0x3F, 0xDC, 0x59, 0x9B, 0x94, 0x10, + 0x72, 0x91, 0x71, 0x50, 0x5B, 0x65, 0xC0, 0xCD, + 0xE0, 0xC3, 0x60, 0xCE, 0xD5, 0x88, 0x7C, 0x16, + 0xFE, 0x11, 0xD6, 0x8E, 0xD8, 0x55, 0xF3, 0xA6, + 0xB2, 0xBA, 0x14, 0x19, 0x0C, 0xD6, 0x9D, 0xCB, + 0xC7, 0xEC, 0x48, 0x07, 0xF3, 0xC9, 0x9C, 0x60, + 0xD0, 0x25, 0x62, 0x9A, 0x2D, 0x74, 0x8E, 0x20 + }, + { + 0x23, 0x83, 0xF4, 0x9C, 0xAC, 0x60, 0xFE, 0x6A, + 0xC6, 0xE7, 0x8F, 0xED, 0x15, 0x89, 0xE0, 0x9E, + 0xBD, 0xCD, 0x67, 0x56, 0x88, 0xD8, 0x04, 0x3D, + 0x65, 0x08, 0xF4, 0xEC, 0x3B, 0xBE, 0x08, 0xA3, + 0x2F, 0x9E, 0xB7, 0xE2, 0x43, 0xB7, 0x33, 0xFA, + 0xD6, 0xD8, 0xE4, 0xC1, 0x57, 0x87, 0x66, 0xD1, + 0xEB, 0xA6, 0xC9, 0x96, 0x2E, 0x27, 0x28, 0xD0, + 0xFD, 0xC5, 0x37, 0x34, 0xB2, 0xD0, 0x7E, 0xC1 + }, + { + 0xDA, 0x18, 0x4A, 0xAD, 0xD3, 0x3D, 0xEF, 0x5A, + 0x31, 0x5A, 0x56, 0x89, 0x0F, 0x2A, 0x6F, 0x31, + 0xA7, 0xA2, 0xC2, 0xE4, 0x33, 0x4C, 0x5B, 0x14, + 0x82, 0xC7, 0x28, 0x31, 0xC9, 0x1A, 0x08, 0x0E, + 0xC7, 0xDF, 0x8F, 0xE7, 0x1F, 0x43, 0x49, 0xC5, + 0x99, 0xA0, 0xA2, 0x96, 0x86, 0xEB, 0xAC, 0x99, + 0x08, 0x7A, 0x6C, 0x39, 0xC0, 0xF0, 0x3F, 0xBC, + 0x10, 0x7F, 0xBA, 0xEC, 0x16, 0x74, 0x27, 0x24 + }, + { + 0x3F, 0xE6, 0x1A, 0x45, 0x72, 0xD6, 0xA4, 0xCB, + 0x30, 0x55, 0x5E, 0xE5, 0x0D, 0xDE, 0x0A, 0x5D, + 0x07, 0xCF, 0xAD, 0x02, 0x94, 0x1F, 0x7C, 0x73, + 0xF2, 0x5C, 0x1F, 0x59, 0xC2, 0x7B, 0x31, 0xB6, + 0x23, 0xCA, 0xB0, 0xB6, 0x17, 0x15, 0xB0, 0x56, + 0x91, 0xE8, 0x60, 0x31, 0x97, 0x9E, 0xE6, 0xC1, + 0x40, 0xE2, 0x68, 0x94, 0x39, 0x12, 0x06, 0xB1, + 0x0F, 0x82, 0x25, 0x83, 0x1B, 0x3F, 0x9D, 0x80 + }, + { + 0xA4, 0x9B, 0x14, 0x5A, 0x68, 0x9D, 0x59, 0x7C, + 0x18, 0x77, 0xA5, 0x25, 0x74, 0x5D, 0x60, 0x6D, + 0xEA, 0xE9, 0x6A, 0xA3, 0xF4, 0xD3, 0xDB, 0xD5, + 0xBE, 0x6E, 0x5F, 0xDD, 0x36, 0xB8, 0x57, 0x04, + 0xE3, 0x75, 0x97, 0xE0, 0x65, 0xDD, 0x8B, 0x69, + 0x2A, 0x45, 0x66, 0xB3, 0x24, 0x4B, 0xF1, 0xCD, + 0xBD, 0x68, 0x8E, 0x96, 0x5F, 0x1F, 0x8D, 0xAD, + 0xBA, 0x6E, 0x6F, 0xF2, 0x4F, 0x91, 0x6F, 0xDD + }, + { + 0x93, 0x6E, 0x34, 0xBE, 0xF8, 0xBA, 0x2A, 0x4F, + 0x03, 0xEA, 0xEA, 0xC1, 0x77, 0x8A, 0x10, 0x5C, + 0xF7, 0x37, 0x59, 0xA2, 0x0D, 0x08, 0x2A, 0x8A, + 0x3B, 0x36, 0x12, 0x15, 0xE9, 0xC3, 0x99, 0x7E, + 0x3E, 0x09, 0xF3, 0x8F, 0x35, 0x45, 0xD1, 0x55, + 0xA6, 0xE2, 0x43, 0x94, 0x97, 0x3A, 0x02, 0x0D, + 0xBF, 0xB6, 0x5F, 0x74, 0x61, 0xB4, 0xD7, 0xDA, + 0x98, 0xE1, 0xD4, 0x36, 0x08, 0x63, 0x96, 0x88 + }, + { + 0x82, 0x01, 0xEA, 0x0E, 0xEE, 0xAB, 0x7E, 0xCC, + 0x1B, 0xCA, 0x7A, 0xC6, 0xC7, 0x6E, 0x4C, 0xD7, + 0xF1, 0x56, 0x41, 0x28, 0x53, 0xFB, 0x3E, 0x35, + 0x78, 0x19, 0x6A, 0xCD, 0xF3, 0xD4, 0xD9, 0xA9, + 0x42, 0x2A, 0xB2, 0x75, 0x68, 0x65, 0xCE, 0xA6, + 0xEC, 0x14, 0x06, 0x8C, 0xED, 0xB0, 0x6E, 0xCB, + 0xBB, 0xC8, 0xCB, 0x76, 0x94, 0x82, 0xAD, 0x49, + 0x19, 0x45, 0xFC, 0x51, 0xFF, 0x91, 0xA2, 0x85 + }, + { + 0xD5, 0x84, 0x01, 0xC9, 0x0C, 0x6C, 0x94, 0xD0, + 0x25, 0xAD, 0x0B, 0x80, 0x4B, 0x8C, 0x32, 0xF2, + 0x3D, 0x4F, 0x24, 0x78, 0x56, 0x63, 0x3E, 0x67, + 0x68, 0x74, 0x30, 0xA4, 0x8F, 0xA7, 0xE5, 0x81, + 0xF6, 0x86, 0x21, 0x8B, 0x38, 0x64, 0x4B, 0x5F, + 0xD0, 0x65, 0x9C, 0xC9, 0x59, 0x5E, 0x45, 0x8E, + 0x61, 0x96, 0x31, 0xF6, 0xE5, 0x59, 0x05, 0x4C, + 0x1F, 0xDF, 0x51, 0xEA, 0x4D, 0x1C, 0xE6, 0xCF + }, + { + 0x69, 0x6C, 0x48, 0xDF, 0xC4, 0x23, 0xF1, 0x1A, + 0xAD, 0xCE, 0x5C, 0x53, 0x8B, 0x21, 0x27, 0x01, + 0x2E, 0x53, 0x01, 0x25, 0xBA, 0x6E, 0x09, 0x39, + 0x95, 0xE9, 0x0E, 0xF9, 0x43, 0x45, 0x98, 0x7F, + 0xA2, 0x4A, 0x98, 0x0E, 0x60, 0x7C, 0x3D, 0x0F, + 0x67, 0x4A, 0xE4, 0xAD, 0x4B, 0x43, 0x48, 0xD9, + 0x12, 0x0F, 0x55, 0xE8, 0x90, 0x3E, 0x0F, 0xB0, + 0x24, 0x50, 0x85, 0x05, 0x8C, 0xB1, 0xA0, 0x5C + }, + { + 0x50, 0x9A, 0xFE, 0x3F, 0xEF, 0x92, 0x58, 0xCC, + 0x51, 0x34, 0x02, 0x47, 0xDF, 0x7B, 0x75, 0xF8, + 0x0C, 0x99, 0x75, 0x2E, 0xB6, 0xA0, 0x7B, 0x00, + 0x37, 0xF5, 0x7B, 0x2F, 0x45, 0xD4, 0x58, 0x9C, + 0x1A, 0xDB, 0xAF, 0xA4, 0x3C, 0xC3, 0x6E, 0xF3, + 0x7C, 0xE9, 0xA4, 0xE7, 0x04, 0x0A, 0x55, 0xF7, + 0x87, 0x75, 0xDF, 0x7F, 0x57, 0x40, 0x27, 0x63, + 0x3B, 0x16, 0x44, 0xA0, 0xF5, 0xC5, 0x0B, 0xAF + }, + { + 0xCC, 0x3F, 0x96, 0x5A, 0x57, 0xEC, 0x2F, 0x07, + 0xD1, 0x85, 0x4E, 0xC1, 0x82, 0xE4, 0xA8, 0x39, + 0xBB, 0x63, 0x9E, 0xF3, 0x17, 0x4C, 0x6B, 0x1F, + 0x2B, 0xCA, 0x37, 0x23, 0x7D, 0x0B, 0xE2, 0xBE, + 0xEC, 0x15, 0xC6, 0xAC, 0xA5, 0x7D, 0x14, 0x6E, + 0x16, 0x17, 0xBC, 0x01, 0xCA, 0x93, 0xB7, 0xB2, + 0xDE, 0x7E, 0x58, 0x8D, 0x43, 0x92, 0x09, 0x8F, + 0x62, 0xD8, 0x13, 0x45, 0x43, 0xFD, 0xF7, 0xBC + }, + { + 0x12, 0x76, 0x4A, 0xF8, 0x46, 0xAE, 0xFA, 0x46, + 0xD5, 0x4B, 0x7D, 0xA6, 0x6B, 0x3A, 0x71, 0x06, + 0xD9, 0xB7, 0xD0, 0x58, 0xFF, 0x31, 0x91, 0x89, + 0x8A, 0xAF, 0xEE, 0x7D, 0xF3, 0xAD, 0x50, 0x4F, + 0x0E, 0xA4, 0x0B, 0x05, 0x1A, 0x65, 0x2F, 0x9D, + 0xB0, 0xDC, 0x73, 0xFE, 0x4D, 0x1E, 0x1F, 0xC7, + 0x97, 0xE1, 0x6A, 0xC6, 0x0B, 0x37, 0x51, 0x1D, + 0xC1, 0x22, 0xB0, 0xE6, 0x5F, 0x59, 0xEB, 0x3B + }, + { + 0xFF, 0xCE, 0x80, 0xC2, 0x87, 0x60, 0x00, 0x25, + 0xB9, 0xB3, 0xC2, 0x8C, 0x7A, 0x91, 0x08, 0xDC, + 0x0C, 0xAA, 0x67, 0x36, 0x2F, 0x98, 0xCB, 0xA5, + 0xDA, 0xD1, 0x93, 0x0E, 0xD7, 0x37, 0x20, 0x23, + 0x0F, 0xA8, 0x0B, 0xBF, 0xFC, 0x0C, 0x33, 0x58, + 0xFD, 0xF7, 0xFC, 0xF2, 0xF4, 0x54, 0x83, 0x3D, + 0xAC, 0x0B, 0xA7, 0xBE, 0x10, 0xAF, 0x58, 0x4C, + 0x76, 0x8A, 0xA1, 0x02, 0x6D, 0x90, 0x45, 0xDE + }, + { + 0x94, 0x5C, 0x4B, 0xA4, 0x6E, 0xE7, 0x6A, 0x8F, + 0xCA, 0x75, 0x68, 0x2C, 0x22, 0xD2, 0x42, 0xEB, + 0xA6, 0xD4, 0x0B, 0x55, 0xE7, 0xED, 0x1C, 0x4A, + 0xFB, 0x8E, 0x2C, 0xDD, 0xA5, 0x4A, 0x2D, 0xAC, + 0xD6, 0x1C, 0x2B, 0x1C, 0xF0, 0x2C, 0x76, 0x4B, + 0x9B, 0x7D, 0x33, 0x9F, 0xDA, 0x39, 0x99, 0x44, + 0x20, 0x44, 0x02, 0x32, 0x3F, 0x92, 0x32, 0x58, + 0xED, 0x1C, 0x1E, 0xEE, 0x8D, 0x66, 0x90, 0x9C + }, + { + 0x05, 0xC1, 0xE3, 0x77, 0xFE, 0xAB, 0xFF, 0x2B, + 0xF4, 0x69, 0x83, 0xF9, 0xE2, 0xF5, 0xC3, 0xCA, + 0x17, 0xFF, 0x5B, 0xD0, 0xAA, 0xB9, 0xF2, 0xD9, + 0x74, 0x14, 0x31, 0x64, 0xD9, 0x66, 0x82, 0xA6, + 0xA1, 0x69, 0x66, 0x9E, 0xE4, 0x11, 0x04, 0x62, + 0x85, 0x66, 0x8C, 0x7A, 0xFF, 0x85, 0x1A, 0x23, + 0x82, 0x25, 0xD9, 0x79, 0x2C, 0x5F, 0xC8, 0x19, + 0x12, 0x15, 0x98, 0x94, 0xBE, 0xA3, 0xD4, 0x99 + }, + { + 0x53, 0x93, 0xA6, 0x42, 0xBC, 0xBA, 0x6B, 0x11, + 0xC4, 0x37, 0x68, 0xE4, 0x8B, 0x2E, 0x0C, 0x64, + 0x9A, 0x72, 0x12, 0x2C, 0x97, 0x39, 0xC4, 0x8E, + 0x3A, 0x56, 0x1C, 0x06, 0xC6, 0xDC, 0xE6, 0x44, + 0x1E, 0x12, 0x24, 0x13, 0xFC, 0x7E, 0xF6, 0xF2, + 0x61, 0xA4, 0x93, 0x8E, 0x10, 0x66, 0xBC, 0x1A, + 0x89, 0xC6, 0x99, 0xBF, 0x01, 0xBE, 0x77, 0x65, + 0xDB, 0x71, 0x88, 0x97, 0x30, 0x0F, 0x8F, 0x8A + }, + { + 0x3E, 0x75, 0xBD, 0xAE, 0x66, 0xE7, 0x5B, 0xA6, + 0x5D, 0xA8, 0xB1, 0x5A, 0xB5, 0x34, 0x15, 0x4F, + 0x95, 0xE3, 0x69, 0x54, 0x01, 0x00, 0x12, 0xC3, + 0x5B, 0xB2, 0xE1, 0xF6, 0x7A, 0x86, 0xE7, 0x50, + 0x36, 0x29, 0x0E, 0x3C, 0x31, 0x8E, 0xAF, 0x2E, + 0xD8, 0x72, 0x51, 0x2D, 0xAF, 0x63, 0xAB, 0x78, + 0xC2, 0x8D, 0x4E, 0x5C, 0xD9, 0xC0, 0x6A, 0x9A, + 0x37, 0x1D, 0x51, 0xC8, 0x56, 0xB1, 0x8E, 0xF7 + }, + { + 0x61, 0x2E, 0x31, 0x2B, 0xDB, 0xE9, 0x7D, 0xCF, + 0x9D, 0x8D, 0x45, 0xC3, 0xA2, 0xC4, 0x0E, 0x77, + 0x29, 0xA5, 0x8C, 0xCE, 0x43, 0x61, 0x82, 0xB9, + 0x36, 0x72, 0xEE, 0xEB, 0x98, 0x81, 0x41, 0xAD, + 0xDF, 0x10, 0x6C, 0xAA, 0xB6, 0x56, 0x9D, 0x8A, + 0x4E, 0xB0, 0x07, 0xEF, 0xF9, 0xB2, 0x2E, 0x4B, + 0x63, 0x29, 0xB1, 0x7E, 0x06, 0x66, 0x01, 0x42, + 0xAC, 0x00, 0xF0, 0xD1, 0xDA, 0xC8, 0xD9, 0x34 + }, + { + 0xB7, 0x9D, 0x55, 0xE9, 0xC8, 0xA5, 0x94, 0x3B, + 0x73, 0xFC, 0xF2, 0x17, 0xD5, 0xA0, 0xD0, 0xA4, + 0xBA, 0x16, 0x74, 0x00, 0x2A, 0xAB, 0xCD, 0xA1, + 0x72, 0x56, 0x6F, 0x36, 0xBB, 0xE6, 0x47, 0x6A, + 0xA1, 0x80, 0xFD, 0x27, 0xEB, 0x71, 0x77, 0xF2, + 0x53, 0x61, 0x6F, 0x8F, 0xAD, 0xCC, 0x80, 0x3B, + 0x55, 0xDE, 0x67, 0x1C, 0x96, 0x38, 0x8F, 0xF8, + 0x7A, 0x88, 0x9E, 0xE1, 0x48, 0x0C, 0x9B, 0x30 + }, + { + 0x37, 0x34, 0x6E, 0xA9, 0x57, 0xB3, 0xBD, 0xF3, + 0xD8, 0x93, 0xD1, 0x83, 0x7F, 0x16, 0x92, 0xA0, + 0x0B, 0x9E, 0xA7, 0x5D, 0xC4, 0xB8, 0x00, 0xDE, + 0x58, 0xAF, 0xEC, 0xDD, 0x17, 0xE3, 0x0B, 0xAE, + 0x01, 0x4E, 0xA5, 0xE6, 0xBB, 0x1B, 0xE1, 0xA8, + 0x59, 0x38, 0x76, 0x04, 0xD6, 0x32, 0x5B, 0x36, + 0x41, 0x79, 0x92, 0x38, 0x08, 0x9B, 0xA3, 0xEB, + 0x60, 0x1B, 0x4F, 0x64, 0x1D, 0x50, 0x66, 0x49 + }, + { + 0x11, 0xC6, 0x4D, 0xF9, 0x12, 0x76, 0xC0, 0xAD, + 0xD3, 0x31, 0xFB, 0x5E, 0x51, 0x55, 0xF2, 0x1A, + 0xE7, 0xAE, 0x10, 0xA9, 0xB9, 0xC5, 0xAA, 0xA2, + 0x99, 0xC7, 0xB9, 0xE8, 0xBC, 0xC4, 0xF4, 0x4E, + 0x84, 0xCC, 0x6E, 0x88, 0x5C, 0x5A, 0x35, 0x28, + 0x5A, 0xAC, 0x1F, 0x78, 0xD8, 0xC9, 0xC4, 0xBB, + 0xDD, 0xFD, 0x46, 0x83, 0x2C, 0x81, 0x41, 0x28, + 0xE6, 0xDC, 0xEF, 0x7B, 0x66, 0x00, 0x5E, 0x63 + }, + { + 0x7C, 0xBD, 0x29, 0x9E, 0x2A, 0xD9, 0x49, 0x20, + 0x3F, 0xAB, 0x2E, 0xEA, 0xEC, 0x06, 0x1D, 0x5E, + 0xC7, 0x4A, 0x41, 0xC4, 0x4F, 0x6F, 0x63, 0x67, + 0x5C, 0x83, 0x43, 0x12, 0x09, 0x6D, 0x39, 0xE3, + 0xBB, 0xEF, 0x14, 0xCA, 0x86, 0x01, 0x51, 0x85, + 0x37, 0x00, 0x87, 0x31, 0x27, 0x93, 0x22, 0x3C, + 0x03, 0x91, 0x93, 0x38, 0x01, 0x46, 0x7C, 0xFF, + 0x11, 0x63, 0x70, 0x8F, 0x90, 0x2F, 0x97, 0x4D + }, + { + 0x67, 0x42, 0xA0, 0x10, 0x6A, 0x13, 0xFB, 0x6E, + 0x92, 0x3F, 0xA7, 0x5F, 0x3F, 0xF8, 0x30, 0x19, + 0x98, 0x73, 0x2E, 0xAF, 0x99, 0x2D, 0xA1, 0x22, + 0x32, 0xD4, 0x1C, 0xC5, 0xE3, 0x0D, 0xDA, 0xAC, + 0x21, 0x52, 0x98, 0xF9, 0xB2, 0xFE, 0x10, 0xFF, + 0x4E, 0x1D, 0x3C, 0xF4, 0x87, 0x5D, 0x25, 0xA1, + 0x0C, 0x93, 0x99, 0x01, 0xF4, 0x3B, 0x9C, 0x20, + 0x49, 0x4D, 0x98, 0xBE, 0x94, 0x09, 0xE3, 0xAC + }, + { + 0x18, 0xD5, 0x6A, 0xF5, 0xC6, 0xF2, 0x4E, 0x35, + 0xE2, 0x2D, 0x6B, 0xC2, 0x0D, 0x31, 0x05, 0x6F, + 0x4E, 0xDC, 0x64, 0x0E, 0xCE, 0xC8, 0xC4, 0xB2, + 0xD5, 0xFC, 0xA9, 0x80, 0x18, 0x6E, 0x08, 0xEB, + 0x97, 0x65, 0xD4, 0x11, 0x71, 0xFE, 0x70, 0x28, + 0x1D, 0xFD, 0x5D, 0xD7, 0x6C, 0x35, 0x3B, 0x03, + 0x8A, 0xAC, 0xD4, 0xE4, 0xC3, 0x36, 0x0B, 0x94, + 0x81, 0xE4, 0x28, 0x80, 0x8D, 0x8A, 0x2F, 0xF3 + }, + { + 0x0F, 0x30, 0x6E, 0x22, 0xD1, 0x43, 0x52, 0x2F, + 0x14, 0x48, 0x58, 0x21, 0x45, 0x18, 0xF1, 0x48, + 0x84, 0x69, 0x5E, 0x56, 0x15, 0x50, 0x9E, 0x5D, + 0x5F, 0x6B, 0x27, 0x51, 0xBE, 0x51, 0x52, 0x32, + 0x9A, 0x29, 0xB1, 0x88, 0x60, 0xC9, 0xFD, 0xE9, + 0x75, 0xD0, 0x66, 0xD0, 0x1C, 0x21, 0xA1, 0x3E, + 0x7A, 0x2F, 0xDF, 0x08, 0xB2, 0xD3, 0x7B, 0x18, + 0x97, 0xEE, 0xD1, 0xB1, 0xAF, 0x1F, 0x06, 0x26 + }, + { + 0x9D, 0xF4, 0xA6, 0x08, 0xEE, 0xBE, 0x35, 0x42, + 0x26, 0x4C, 0x8A, 0x8E, 0x21, 0x54, 0xE5, 0x0A, + 0x27, 0x3E, 0xE8, 0x53, 0x99, 0x36, 0xEF, 0x11, + 0x10, 0x06, 0x51, 0x0D, 0x8C, 0xFC, 0xFA, 0xF6, + 0x09, 0xE8, 0x1C, 0x09, 0xE6, 0xF7, 0x16, 0x29, + 0xEC, 0xD9, 0x41, 0x87, 0xEF, 0xE4, 0x6D, 0xA1, + 0x11, 0xEB, 0x2A, 0x1B, 0x17, 0x16, 0x75, 0xDF, + 0x02, 0x37, 0xFC, 0x01, 0xD7, 0xAF, 0x77, 0xBF + }, + { + 0xA6, 0x66, 0x5B, 0x64, 0x87, 0xEF, 0x2D, 0x40, + 0xB0, 0xF2, 0x03, 0x3A, 0x9C, 0x05, 0xA8, 0xFA, + 0xAA, 0x08, 0xA2, 0x74, 0xE1, 0x67, 0x35, 0xFE, + 0x2C, 0xD0, 0xE3, 0xCB, 0x93, 0x84, 0x9A, 0x54, + 0xA6, 0xA6, 0x26, 0xB7, 0xEE, 0x8C, 0x76, 0x10, + 0xE7, 0x96, 0xA7, 0x70, 0x6E, 0x37, 0xAD, 0x94, + 0x53, 0x97, 0x79, 0x7D, 0xD2, 0xA9, 0x66, 0xE6, + 0xCD, 0x59, 0x57, 0x3D, 0x11, 0x91, 0x0D, 0x06 + }, + { + 0x26, 0x93, 0x91, 0x10, 0xE2, 0x67, 0x8F, 0x22, + 0x66, 0x5B, 0x7A, 0x77, 0x64, 0x41, 0x30, 0x6E, + 0x26, 0xEA, 0xFB, 0x08, 0x16, 0x14, 0x52, 0x40, + 0xD0, 0x09, 0x37, 0x65, 0x26, 0xDF, 0xD4, 0x5B, + 0x49, 0x0E, 0x74, 0x22, 0x64, 0x58, 0x6B, 0x58, + 0x87, 0xDD, 0x11, 0xE6, 0xAC, 0x40, 0xF2, 0x2F, + 0xF8, 0x28, 0xA9, 0x80, 0xE9, 0x1D, 0xE0, 0x0B, + 0x82, 0x17, 0x92, 0x64, 0x43, 0xF4, 0x31, 0xD2 + }, + { + 0xA0, 0x9F, 0x6E, 0x9D, 0x6F, 0x20, 0x80, 0x17, + 0x39, 0x3F, 0x2C, 0xDA, 0x0A, 0x35, 0x12, 0x4F, + 0x7A, 0x8A, 0x0F, 0x51, 0x8D, 0xEB, 0x79, 0x72, + 0xA4, 0x24, 0x67, 0x4B, 0x1E, 0x5E, 0xB1, 0x50, + 0x1C, 0xF2, 0xA7, 0xB2, 0x43, 0x1E, 0x0C, 0xF2, + 0x62, 0xC3, 0x74, 0xEF, 0xB9, 0x90, 0x39, 0xAD, + 0x2A, 0x3D, 0x15, 0x30, 0x21, 0xDC, 0x82, 0xE4, + 0xD9, 0xDD, 0xF5, 0x16, 0xB8, 0x46, 0xEB, 0x01 + }, + { + 0xCF, 0xDC, 0x08, 0xF3, 0xDC, 0xF3, 0xD9, 0x35, + 0xC5, 0xF2, 0x4B, 0xE6, 0xBA, 0x9D, 0xEC, 0x19, + 0x66, 0xC8, 0x29, 0x7D, 0x00, 0xD5, 0x7E, 0x61, + 0x68, 0xA5, 0xC3, 0xD4, 0x3B, 0xA4, 0x85, 0xAB, + 0xD5, 0x06, 0x05, 0x1F, 0x1B, 0xF0, 0xB7, 0xEC, + 0x63, 0x44, 0x48, 0xBF, 0xCD, 0x1E, 0x34, 0xC3, + 0xFB, 0x2B, 0xF7, 0xD6, 0x86, 0xCA, 0x5E, 0xD7, + 0x01, 0xEE, 0x0F, 0x17, 0xE4, 0x27, 0x58, 0xEB + }, + { + 0x53, 0xB7, 0x0D, 0xB3, 0x97, 0xB4, 0x7B, 0xC5, + 0x87, 0x64, 0x6F, 0x54, 0x11, 0x8B, 0x47, 0xA7, + 0x6A, 0x12, 0xC4, 0x9E, 0xDA, 0xA4, 0xE3, 0x3F, + 0xF6, 0xDC, 0x5C, 0xAA, 0xF2, 0x4A, 0x29, 0x53, + 0x8F, 0x94, 0x7F, 0x92, 0x5B, 0x60, 0xA6, 0x8B, + 0x52, 0x3A, 0xF6, 0x8D, 0xDD, 0x1C, 0xA2, 0x8C, + 0x8D, 0xB7, 0xBA, 0x64, 0x99, 0x82, 0x39, 0x4E, + 0xB4, 0x90, 0xF5, 0x39, 0x32, 0xF2, 0x35, 0x7F + }, + { + 0x86, 0x59, 0xBE, 0xD7, 0x2C, 0x6C, 0xDA, 0xE6, + 0x88, 0xC8, 0x0A, 0x66, 0x1B, 0x90, 0x61, 0x7A, + 0x12, 0xFE, 0x88, 0xEA, 0xFC, 0x51, 0x3B, 0x88, + 0xDE, 0x90, 0xD1, 0xAC, 0xDA, 0x9F, 0x41, 0xF7, + 0x64, 0x13, 0x70, 0x92, 0xAB, 0xA0, 0xD2, 0xB6, + 0x5F, 0x84, 0xA9, 0x35, 0x7A, 0x19, 0x62, 0xF4, + 0xDC, 0xAA, 0xC6, 0xC3, 0x39, 0xA4, 0x2E, 0x8A, + 0x2C, 0x3E, 0xFF, 0x7D, 0x64, 0x50, 0x87, 0xFF + }, + { + 0x44, 0x2A, 0xDA, 0xA1, 0x10, 0xCE, 0x2C, 0x72, + 0x43, 0x8C, 0x35, 0xAF, 0xFE, 0x2C, 0x76, 0x59, + 0xAF, 0xBE, 0xA4, 0xE3, 0x7D, 0xB5, 0x06, 0xAB, + 0xF5, 0x2D, 0xC6, 0xBD, 0x84, 0x2D, 0xBD, 0xA6, + 0x2B, 0xBD, 0xB8, 0xD4, 0x0F, 0x6B, 0x49, 0xC9, + 0x36, 0x37, 0x8E, 0x4B, 0x7B, 0xA8, 0x3A, 0x5E, + 0xF8, 0xE1, 0x06, 0xFB, 0xFB, 0x14, 0x96, 0x48, + 0xCC, 0xF5, 0x60, 0xE8, 0xE3, 0x07, 0x1C, 0xFB + }, + { + 0x01, 0x70, 0x57, 0xBF, 0xBE, 0x21, 0x3C, 0x41, + 0xF6, 0x1F, 0x09, 0xCE, 0x01, 0xD2, 0xF8, 0xE2, + 0x61, 0x24, 0xC7, 0x1F, 0xA7, 0x88, 0xE2, 0x09, + 0xEE, 0xB8, 0xF7, 0x3E, 0xDA, 0x74, 0xD0, 0xF3, + 0x2F, 0x89, 0x27, 0x00, 0x57, 0xC9, 0xD2, 0xD2, + 0x24, 0xAE, 0x01, 0x0C, 0x48, 0x2E, 0x0F, 0xC9, + 0xB8, 0x33, 0x03, 0x0F, 0x75, 0xEB, 0x9D, 0x9B, + 0x69, 0x43, 0x13, 0xFF, 0x29, 0x9F, 0x53, 0x0C + }, + { + 0x3E, 0x75, 0x76, 0x51, 0x37, 0xE4, 0x0A, 0x0E, + 0x5D, 0xFE, 0x01, 0x7F, 0xF5, 0xC5, 0x5B, 0x27, + 0xA4, 0x85, 0x90, 0x6E, 0x13, 0xA9, 0xC3, 0x2C, + 0x54, 0xCA, 0x2B, 0x92, 0x4F, 0x23, 0x61, 0xD1, + 0xF5, 0x82, 0x91, 0x1C, 0xB1, 0xD5, 0x93, 0x65, + 0x89, 0x29, 0xFF, 0x3B, 0x64, 0x12, 0x28, 0x03, + 0x72, 0x55, 0xBB, 0x37, 0xD9, 0x90, 0xFD, 0x64, + 0x05, 0x15, 0xEE, 0x1C, 0x6C, 0xAB, 0xA4, 0x97 + }, + { + 0xBF, 0xA0, 0xFB, 0xA6, 0xF0, 0x36, 0xAE, 0x07, + 0x01, 0x7C, 0x7E, 0x23, 0x99, 0x55, 0xB7, 0x50, + 0x8D, 0x45, 0xC1, 0x20, 0xB2, 0x84, 0x11, 0xA7, + 0x86, 0x06, 0xC3, 0x96, 0x53, 0x2B, 0xF1, 0xEE, + 0xFB, 0x9B, 0xBC, 0xC6, 0x98, 0xFF, 0x46, 0x64, + 0xB9, 0xD2, 0xF8, 0xEB, 0x07, 0x4B, 0xB8, 0x0A, + 0xC9, 0x9F, 0xB1, 0xCD, 0x52, 0xCD, 0xFF, 0xA6, + 0x99, 0x15, 0x51, 0xB6, 0xB4, 0x6A, 0x03, 0x0D + }, + { + 0x40, 0xFB, 0x9A, 0x96, 0x45, 0x69, 0xCE, 0x51, + 0xCC, 0xBF, 0x9D, 0xD6, 0xFA, 0xF4, 0x11, 0x84, + 0x71, 0x8B, 0x38, 0x1A, 0xDD, 0xEA, 0x5F, 0xC1, + 0x27, 0x86, 0x8C, 0x3A, 0x4E, 0x88, 0x99, 0x45, + 0x38, 0xF7, 0x2B, 0x78, 0x41, 0x1A, 0x84, 0x29, + 0x11, 0x53, 0x56, 0xB6, 0x4F, 0xC7, 0x3A, 0xA1, + 0x5A, 0x1C, 0xD0, 0x86, 0xAC, 0x62, 0xA3, 0xB1, + 0x36, 0xD7, 0x3E, 0xF9, 0x1F, 0xC7, 0x3E, 0xFD + }, + { + 0x3E, 0x2A, 0xA9, 0xBB, 0x97, 0x4C, 0x23, 0xC8, + 0xFA, 0x8B, 0x72, 0x3C, 0x6E, 0xD7, 0x9E, 0x11, + 0xD0, 0x6A, 0xB3, 0x05, 0xA1, 0x4A, 0x9F, 0xA7, + 0x42, 0x1E, 0x00, 0xB7, 0x0F, 0x77, 0x80, 0x56, + 0xCB, 0xFF, 0x43, 0x11, 0x78, 0xC0, 0xC0, 0x16, + 0xCE, 0x5D, 0x68, 0x87, 0x19, 0x0C, 0x4E, 0xDF, + 0xE5, 0xD5, 0x0E, 0x79, 0x11, 0x8F, 0x3D, 0x25, + 0x93, 0x19, 0x84, 0x24, 0xBB, 0xD6, 0xF9, 0xE9 + }, + { + 0x19, 0x58, 0x8C, 0x7A, 0x95, 0xF9, 0x09, 0xAF, + 0xE2, 0x8C, 0x35, 0xCF, 0x97, 0x4F, 0x7D, 0xDC, + 0xD2, 0x9A, 0xA3, 0x09, 0x32, 0x2A, 0xA6, 0xB4, + 0xBE, 0xD9, 0xC4, 0x71, 0x79, 0x47, 0xF4, 0x06, + 0x66, 0xFF, 0x59, 0xF3, 0x65, 0xF9, 0x51, 0xCF, + 0xC1, 0xCA, 0xB6, 0x1B, 0x2D, 0xFF, 0xCE, 0x02, + 0xD8, 0x1C, 0xD4, 0x7A, 0x3B, 0x9C, 0xC6, 0xC5, + 0x44, 0x97, 0x04, 0xA3, 0xD9, 0x31, 0x63, 0x55 + }, + { + 0x29, 0x01, 0x48, 0xC5, 0xC9, 0xF5, 0xDC, 0x7C, + 0x23, 0x03, 0xDA, 0xFF, 0x20, 0x18, 0xCE, 0x64, + 0xBB, 0xF7, 0x0E, 0xEB, 0xC3, 0x89, 0x5D, 0x0F, + 0x61, 0x09, 0x50, 0xA4, 0xFA, 0xDB, 0x21, 0xB2, + 0xE9, 0x46, 0x10, 0xDF, 0xA4, 0x88, 0x81, 0x22, + 0x44, 0x6E, 0xB7, 0xCD, 0xA2, 0x67, 0x71, 0x3A, + 0x4A, 0xA7, 0x91, 0x88, 0xB3, 0x1A, 0x33, 0xF0, + 0xA3, 0x6F, 0x62, 0x80, 0xD5, 0xAB, 0x17, 0xDB + }, + { + 0x17, 0xE3, 0xFF, 0x47, 0x00, 0xE2, 0xF2, 0x31, + 0x0C, 0xCC, 0xF0, 0x9D, 0xA7, 0x03, 0x0C, 0x94, + 0x83, 0x2F, 0xAA, 0x37, 0x0D, 0x0E, 0xDA, 0x67, + 0x38, 0xD9, 0x3B, 0x7D, 0x20, 0xB7, 0xAD, 0x5F, + 0x36, 0xF5, 0x4F, 0x9F, 0x5E, 0x80, 0x10, 0xA2, + 0xB3, 0xE3, 0xE3, 0x94, 0xD0, 0xA6, 0xB3, 0x3A, + 0x06, 0x7A, 0xC5, 0x39, 0x6A, 0x2F, 0x18, 0x1A, + 0x0D, 0x1F, 0xFB, 0x5B, 0x76, 0x9A, 0x4D, 0x02 + }, + { + 0xC5, 0x74, 0xBE, 0x3F, 0x63, 0xDC, 0x15, 0x42, + 0x3E, 0x44, 0x30, 0x2B, 0x08, 0xB5, 0x62, 0x7D, + 0xF8, 0x6E, 0x60, 0xCC, 0x21, 0x1E, 0xC8, 0x13, + 0x22, 0x5F, 0x67, 0xA9, 0xF0, 0x71, 0x89, 0x03, + 0xED, 0xE6, 0x3F, 0x5D, 0x04, 0x94, 0xB0, 0xEF, + 0xB4, 0xA9, 0xCD, 0xB8, 0xF3, 0x8D, 0x05, 0x59, + 0x8D, 0x9C, 0xC7, 0xD3, 0x36, 0xB2, 0xCC, 0x3E, + 0xA5, 0x4D, 0xC8, 0x58, 0x7E, 0x88, 0x8D, 0xCB + }, + { + 0x5D, 0x86, 0x1D, 0xCB, 0x0F, 0x1F, 0xE9, 0x6C, + 0x73, 0xDB, 0xCA, 0x86, 0xD5, 0x1D, 0x49, 0xD2, + 0x59, 0xD3, 0xDA, 0xD4, 0x2C, 0x83, 0xCD, 0x19, + 0xCC, 0x29, 0xAB, 0x2A, 0x2D, 0xD6, 0x7F, 0x9B, + 0x56, 0x80, 0x30, 0x5E, 0xC7, 0x19, 0x4B, 0x9A, + 0x37, 0x91, 0xD0, 0x03, 0x54, 0xAE, 0xCE, 0xAA, + 0x6B, 0xC0, 0xA2, 0x90, 0x00, 0x32, 0xD7, 0x55, + 0x1B, 0xC1, 0xAD, 0xF1, 0x41, 0x7C, 0x41, 0xDF + }, + { + 0x60, 0x8C, 0xE0, 0x4C, 0xE3, 0xF4, 0xA6, 0xFE, + 0x9E, 0x41, 0x89, 0xD9, 0x4C, 0x44, 0xFA, 0x9C, + 0xEF, 0xC1, 0xDC, 0x5E, 0xEF, 0x3A, 0xEC, 0x45, + 0xC5, 0x57, 0xFA, 0x1A, 0x4E, 0x93, 0x3C, 0x70, + 0xC1, 0x7F, 0x29, 0x3D, 0x1D, 0x69, 0xDA, 0x65, + 0xCC, 0x4C, 0x32, 0x5E, 0x94, 0x79, 0xED, 0x42, + 0xB2, 0xA6, 0x4D, 0x6E, 0xB5, 0x48, 0xD6, 0x6C, + 0xA4, 0x90, 0xDC, 0x0F, 0x10, 0x54, 0x06, 0x77 + }, + { + 0x77, 0x47, 0xAA, 0x82, 0x54, 0xD7, 0x72, 0x25, + 0x42, 0x69, 0x59, 0x40, 0x73, 0x30, 0xD0, 0x4E, + 0x2D, 0xA8, 0x53, 0xF0, 0xBF, 0x67, 0xFB, 0x07, + 0x65, 0x55, 0xAF, 0xA0, 0xAA, 0xB7, 0xE2, 0x46, + 0x2E, 0x91, 0x76, 0xC4, 0x3C, 0x6A, 0x04, 0x25, + 0x09, 0xAD, 0x87, 0x67, 0x62, 0x0D, 0x39, 0x99, + 0xBC, 0xC9, 0x7C, 0x00, 0x4B, 0x18, 0xBB, 0x14, + 0x88, 0x44, 0x31, 0x3F, 0x23, 0xB6, 0xFB, 0xB1 + }, + { + 0x9B, 0x19, 0x46, 0x41, 0xAE, 0x4F, 0x33, 0x3F, + 0x69, 0xC6, 0xAB, 0x15, 0xBF, 0x7C, 0x75, 0x2E, + 0x9E, 0x94, 0x84, 0xC8, 0x1C, 0xE1, 0xAA, 0x87, + 0xAC, 0x0F, 0x6E, 0xD1, 0x5F, 0xA1, 0xD9, 0x2F, + 0xB0, 0x55, 0xEE, 0xF0, 0x3C, 0x80, 0xBC, 0xA4, + 0xD0, 0x05, 0x8F, 0x65, 0x8B, 0x97, 0xF1, 0x65, + 0xF4, 0x50, 0xB8, 0x38, 0x15, 0xAF, 0x76, 0x96, + 0x82, 0xC0, 0x2C, 0x9E, 0xA4, 0xD7, 0xE6, 0xE6 + }, + { + 0xC3, 0x1F, 0x19, 0x0F, 0xBA, 0x82, 0x57, 0x93, + 0x88, 0xB8, 0xA4, 0x40, 0xE3, 0xF5, 0xD8, 0x7A, + 0x55, 0x46, 0xBB, 0x70, 0xD0, 0xAB, 0x28, 0x01, + 0x50, 0x59, 0xFC, 0x60, 0x1C, 0x54, 0xC4, 0x96, + 0x70, 0xC3, 0xC1, 0xCE, 0xAB, 0x4E, 0x0A, 0x2C, + 0xC7, 0xFB, 0xED, 0xC9, 0x33, 0xB0, 0x41, 0xFE, + 0x6C, 0xC8, 0xAD, 0x03, 0x1B, 0xC7, 0x22, 0x3B, + 0x73, 0xCA, 0x22, 0xF6, 0xF9, 0x7C, 0x5E, 0xC0 + }, + { + 0xF6, 0x15, 0xBC, 0x25, 0xEC, 0xCD, 0x07, 0x15, + 0x25, 0xCC, 0xA3, 0xD5, 0xA3, 0x30, 0x1F, 0x99, + 0x18, 0xAD, 0xD3, 0xDD, 0x4E, 0x07, 0x75, 0xE1, + 0x32, 0xB4, 0x44, 0x05, 0xA5, 0xA0, 0xCE, 0x6B, + 0x0C, 0xFA, 0x5F, 0x65, 0x85, 0xA3, 0x29, 0x06, + 0x18, 0x01, 0x70, 0x43, 0x3F, 0xE6, 0xB5, 0xC1, + 0x87, 0x89, 0xE8, 0x15, 0x53, 0xD7, 0xEC, 0x21, + 0x8A, 0x7B, 0xBF, 0x97, 0x1B, 0xA4, 0x02, 0x56 + }, + { + 0x51, 0xA8, 0x05, 0xBD, 0x09, 0xC2, 0x65, 0x96, + 0x17, 0x2D, 0xFA, 0xAF, 0x63, 0xCC, 0xD4, 0x8A, + 0x3C, 0xB0, 0xAB, 0x01, 0xF5, 0xAD, 0x7E, 0x33, + 0xD3, 0xBC, 0x69, 0x15, 0x33, 0x72, 0x30, 0x74, + 0xB3, 0x73, 0x6E, 0x41, 0x3A, 0x57, 0x44, 0x84, + 0x74, 0x61, 0xFE, 0x3B, 0x63, 0x17, 0x69, 0x03, + 0xF3, 0x1D, 0xD8, 0x14, 0x0D, 0x2F, 0x12, 0x56, + 0xE2, 0x76, 0x6B, 0x94, 0xB9, 0x9D, 0x52, 0x59 + }, + { + 0x10, 0xD9, 0xFB, 0xB3, 0xCA, 0x74, 0x78, 0x2E, + 0x27, 0xBA, 0xD4, 0xFF, 0x85, 0x09, 0x12, 0xBD, + 0x05, 0x5D, 0x1E, 0x64, 0x65, 0x59, 0x83, 0xF4, + 0x5E, 0xD3, 0x20, 0x12, 0x92, 0xD8, 0xDD, 0xF0, + 0x1F, 0x62, 0xB0, 0xCC, 0xFF, 0xBB, 0xE0, 0xDC, + 0xE6, 0x56, 0x37, 0xBC, 0x40, 0xAF, 0x45, 0xB8, + 0x35, 0xFF, 0xBE, 0xE6, 0xC0, 0x73, 0xC0, 0x8A, + 0x89, 0x7F, 0x8C, 0x70, 0xE1, 0x68, 0x30, 0x9B + }, + { + 0x26, 0xF1, 0x4D, 0x90, 0x89, 0x20, 0x0F, 0x07, + 0x79, 0x11, 0x59, 0x22, 0xE0, 0x86, 0x0A, 0xC1, + 0x3F, 0xEC, 0x5B, 0xEA, 0x63, 0x86, 0x26, 0xAF, + 0x66, 0x23, 0x1E, 0xC4, 0x25, 0x61, 0x9B, 0x2E, + 0x2D, 0x88, 0x9D, 0x5E, 0x63, 0xBB, 0x65, 0x9D, + 0xE3, 0x56, 0x19, 0x09, 0x2D, 0x14, 0xBA, 0xC0, + 0x86, 0x3C, 0x85, 0x26, 0x16, 0x30, 0x0E, 0xF0, + 0x07, 0x66, 0x8A, 0xD4, 0x43, 0x09, 0xB3, 0xC1 + }, + { + 0x71, 0xA3, 0x5A, 0x97, 0x03, 0xA1, 0x9D, 0x36, + 0x26, 0x74, 0x61, 0x63, 0xE2, 0xCD, 0xE9, 0x91, + 0xF6, 0x71, 0xE4, 0x70, 0xF5, 0x7F, 0xFA, 0xF0, + 0xFD, 0xA1, 0xC6, 0xBF, 0xFD, 0x81, 0x02, 0xE3, + 0xF0, 0xF6, 0xAE, 0xF6, 0x51, 0x53, 0xA9, 0x4C, + 0x22, 0x54, 0xFE, 0x21, 0xC0, 0xB1, 0x88, 0xFA, + 0x30, 0xCE, 0xAA, 0xE0, 0x4E, 0xF2, 0x78, 0x25, + 0xE4, 0xF2, 0x9E, 0x17, 0xC2, 0x29, 0xDE, 0xBC + }, + { + 0x2A, 0x0F, 0x1C, 0x3C, 0xB7, 0x5F, 0x1B, 0xC0, + 0xF8, 0x14, 0x5F, 0x67, 0x74, 0xEF, 0xB3, 0x54, + 0x7A, 0xEB, 0x90, 0x10, 0x54, 0x26, 0xB0, 0xC6, + 0xB6, 0xE5, 0x47, 0x06, 0x24, 0xA8, 0x52, 0xEE, + 0x9C, 0x83, 0x05, 0xE3, 0x24, 0x38, 0x11, 0xFD, + 0x3F, 0x7A, 0x09, 0x6A, 0x96, 0x44, 0x7C, 0xFC, + 0xC5, 0xF1, 0xF7, 0xDC, 0x80, 0x5D, 0xB7, 0xED, + 0xFA, 0x7A, 0xEA, 0x40, 0x72, 0xC1, 0x0A, 0x7B + }, + { + 0x4B, 0x47, 0xDC, 0x02, 0xD5, 0xFE, 0x20, 0x8E, + 0x97, 0x75, 0xB1, 0x06, 0x85, 0x26, 0xA8, 0x3D, + 0xF6, 0xE8, 0xE1, 0x30, 0x88, 0xBA, 0xE9, 0x37, + 0x5E, 0x62, 0x9E, 0x7E, 0x6E, 0xDB, 0xC2, 0x5D, + 0xC3, 0xE4, 0x9D, 0x69, 0xD6, 0x86, 0x29, 0x66, + 0x9D, 0x65, 0xA6, 0xC2, 0xF2, 0x74, 0xD2, 0x4D, + 0xB4, 0x85, 0x31, 0x81, 0xED, 0x72, 0xCB, 0x48, + 0x16, 0x13, 0xEE, 0x74, 0x48, 0xDF, 0x8B, 0xAB + }, + { + 0xFB, 0xD7, 0x58, 0x54, 0xA0, 0xBD, 0xB7, 0x0A, + 0x81, 0x6E, 0xB3, 0xEF, 0xF0, 0x2B, 0x7A, 0xD4, + 0x76, 0xC5, 0xFB, 0xE3, 0xB7, 0xD1, 0x0C, 0x6B, + 0xC6, 0x61, 0x4C, 0x3E, 0x09, 0x96, 0x2B, 0x56, + 0x6A, 0x24, 0x30, 0x5E, 0x2D, 0x89, 0x39, 0xF4, + 0x7C, 0x38, 0x5F, 0x5D, 0x02, 0xEE, 0xA3, 0x47, + 0xEA, 0x0E, 0xA6, 0x35, 0x2B, 0x3E, 0x7E, 0x83, + 0x67, 0xC0, 0x25, 0x37, 0xBF, 0xC7, 0x64, 0xBB + }, + { + 0xFF, 0x21, 0x5B, 0x9F, 0x05, 0xE6, 0x5B, 0x72, + 0x5E, 0xA5, 0xA5, 0x52, 0x99, 0x0A, 0x24, 0x86, + 0xB4, 0x30, 0xDB, 0xE2, 0xDD, 0x03, 0x39, 0xBE, + 0x1D, 0x7E, 0x4B, 0xD5, 0xFC, 0x2F, 0xB3, 0x7F, + 0x7C, 0xEB, 0x31, 0xEF, 0xB1, 0xE8, 0x39, 0x27, + 0x50, 0x5D, 0x29, 0x67, 0xF9, 0x09, 0x20, 0x61, + 0x47, 0x30, 0x2C, 0xE4, 0x0B, 0x34, 0xEA, 0x61, + 0x87, 0x85, 0xB8, 0xDC, 0x19, 0xBB, 0xBD, 0xBA + }, + { + 0xBB, 0xDF, 0xF9, 0xC5, 0x1B, 0x23, 0x1F, 0x04, + 0x5E, 0xE7, 0xEA, 0xA2, 0x55, 0x52, 0x2D, 0x68, + 0x9B, 0x83, 0x0D, 0x86, 0x01, 0x10, 0x04, 0x72, + 0xED, 0x44, 0xA7, 0x92, 0xD6, 0x3E, 0x99, 0x36, + 0x6D, 0xF6, 0x41, 0xD8, 0x11, 0x61, 0xA2, 0x92, + 0xD7, 0x85, 0xA9, 0xE5, 0xAF, 0xCF, 0xA1, 0xBC, + 0xB0, 0x1D, 0x37, 0xFA, 0x04, 0x1C, 0xF6, 0x7D, + 0xB1, 0x98, 0x4A, 0xDA, 0x02, 0x20, 0xDB, 0x42 + }, + { + 0x6E, 0x24, 0x85, 0x80, 0x01, 0xC9, 0x03, 0xD4, + 0xA7, 0xDC, 0x1A, 0xD4, 0xAE, 0x7A, 0xA6, 0x2E, + 0x31, 0x6C, 0x45, 0xB3, 0x81, 0x73, 0x4C, 0x66, + 0xAE, 0x43, 0xC7, 0x8B, 0xB3, 0xF8, 0x9F, 0x3E, + 0xA5, 0x29, 0xBA, 0x5E, 0x6B, 0xAA, 0x8C, 0xE5, + 0x2D, 0x6B, 0x1E, 0x3D, 0xFB, 0x3D, 0x98, 0x75, + 0x80, 0x5A, 0x62, 0x83, 0x8A, 0x50, 0xD7, 0x10, + 0x46, 0xB2, 0xF6, 0x19, 0x99, 0xF1, 0x8A, 0x02 + }, + { + 0x76, 0x92, 0x53, 0x20, 0x6C, 0xE8, 0xCD, 0x72, + 0x46, 0x96, 0xB7, 0xCC, 0xB1, 0xB8, 0x1C, 0x45, + 0x14, 0xFF, 0xC0, 0x08, 0x77, 0xC1, 0xF4, 0x75, + 0xEE, 0x5E, 0x0A, 0xE3, 0x4B, 0x7B, 0x5F, 0x53, + 0xF7, 0x63, 0x91, 0x37, 0x2F, 0xD1, 0x32, 0x3C, + 0xAE, 0x6A, 0x41, 0xAA, 0x94, 0xB0, 0x79, 0x41, + 0xD9, 0xBB, 0x40, 0x64, 0x51, 0xA2, 0xBB, 0x13, + 0x21, 0x74, 0x8B, 0x14, 0xF4, 0x53, 0x19, 0xBB + }, + { + 0xC8, 0x39, 0x5D, 0x84, 0xEF, 0x18, 0x54, 0x3C, + 0x88, 0xC6, 0x2C, 0x2E, 0xCA, 0xC6, 0xA4, 0x5E, + 0xED, 0xBC, 0x4E, 0xD3, 0x74, 0x13, 0x50, 0x59, + 0x5B, 0x91, 0xF7, 0xCE, 0xFC, 0x97, 0x89, 0x22, + 0x9B, 0xEC, 0x12, 0x55, 0xBE, 0xFB, 0x0C, 0x26, + 0x17, 0x72, 0xE5, 0xDD, 0xE0, 0x4C, 0xE5, 0x3D, + 0x6C, 0x0A, 0x1F, 0x0B, 0xC5, 0x1A, 0xAF, 0x8E, + 0x9E, 0xA3, 0x0C, 0x94, 0x81, 0xCD, 0x22, 0x8E + }, + { + 0x69, 0x2B, 0x30, 0x35, 0xFE, 0x7F, 0x04, 0x62, + 0xCA, 0x62, 0xB8, 0x2D, 0x47, 0xD1, 0x6E, 0xFE, + 0xDE, 0x54, 0x90, 0x20, 0xBF, 0x10, 0x97, 0x55, + 0xF0, 0x8D, 0x3D, 0xB1, 0x2F, 0x97, 0x78, 0x09, + 0x3A, 0xDA, 0x86, 0xE2, 0x47, 0xA7, 0xAC, 0x1A, + 0xE8, 0x1C, 0x1D, 0x6C, 0x9F, 0xB7, 0x2C, 0x95, + 0x8E, 0xFE, 0xF2, 0xDD, 0xBE, 0x7B, 0xCD, 0x64, + 0xD5, 0x09, 0x9A, 0x47, 0xD1, 0x22, 0xB2, 0xFA + }, + { + 0x66, 0x8C, 0x72, 0x8A, 0x48, 0xB3, 0x8A, 0xF6, + 0x8D, 0x14, 0x05, 0xE6, 0x80, 0xA9, 0x2E, 0xE6, + 0x9E, 0x8D, 0x0B, 0x7C, 0x43, 0xAA, 0xE9, 0x92, + 0x91, 0x09, 0x03, 0x36, 0xC8, 0xAF, 0xB5, 0x09, + 0xFD, 0x15, 0xFF, 0xCA, 0xA8, 0xC7, 0x01, 0xD1, + 0x3E, 0xB8, 0x51, 0xA5, 0x8A, 0x34, 0x5A, 0x5E, + 0xE5, 0xE2, 0xBE, 0xAD, 0x39, 0x16, 0x78, 0xB4, + 0x80, 0x67, 0x70, 0xC1, 0x60, 0x80, 0xA3, 0x06 + }, + { + 0xA5, 0x8E, 0x20, 0xAF, 0x4E, 0xE8, 0x6C, 0x2A, + 0x74, 0x5A, 0x04, 0x9D, 0x2A, 0x2A, 0xDB, 0x1D, + 0xDA, 0x5E, 0xEE, 0x32, 0x87, 0xEE, 0x24, 0x07, + 0x14, 0xA6, 0x25, 0x92, 0xA6, 0x8C, 0x61, 0x08, + 0x56, 0xED, 0x10, 0xB2, 0x5F, 0xFF, 0x9B, 0x23, + 0x06, 0xC0, 0xA2, 0x78, 0xEE, 0x0A, 0xF6, 0x7B, + 0xAB, 0x36, 0x4D, 0x09, 0xCD, 0x56, 0xD5, 0x82, + 0x7B, 0x1D, 0xC6, 0x0F, 0x64, 0x37, 0x2A, 0x17 + }, + { + 0x67, 0xE0, 0xFD, 0x3B, 0x9C, 0x4B, 0xB7, 0x9E, + 0x25, 0xD6, 0xDC, 0x6E, 0x1A, 0x30, 0x99, 0xDE, + 0xA9, 0xF4, 0xDC, 0x4E, 0x22, 0x5B, 0x04, 0x96, + 0x35, 0x47, 0x91, 0xCD, 0x3D, 0x39, 0xFE, 0x2B, + 0x04, 0xFE, 0x5F, 0x2D, 0x54, 0xF5, 0xD0, 0xC7, + 0xEC, 0x7C, 0x6F, 0xEB, 0xCE, 0x64, 0xAC, 0xF8, + 0x1E, 0x0C, 0x1A, 0x50, 0x2E, 0xA6, 0x83, 0x56, + 0xD9, 0x17, 0xBE, 0x1C, 0x23, 0x71, 0x33, 0x22 + }, + { + 0xED, 0x05, 0xE8, 0x33, 0x26, 0x1F, 0xB9, 0xC7, + 0xA1, 0x03, 0x7D, 0x33, 0x8B, 0xA4, 0x80, 0x80, + 0x77, 0xDE, 0x02, 0xFF, 0x75, 0xBC, 0x46, 0x6A, + 0x7A, 0xAB, 0xBA, 0xA6, 0x18, 0x7D, 0xC3, 0x06, + 0xA2, 0x7C, 0x58, 0x48, 0xC7, 0xF0, 0x45, 0x08, + 0xCD, 0xE5, 0x24, 0x7C, 0x53, 0xCC, 0x56, 0xAB, + 0x6A, 0x44, 0x6E, 0x30, 0xB7, 0xC1, 0xF0, 0xC5, + 0x59, 0x9E, 0x42, 0x9A, 0xC3, 0x9D, 0x1C, 0xAC + }, + { + 0x87, 0xC3, 0x76, 0xA4, 0x27, 0x5A, 0x4F, 0x84, + 0xA5, 0x6A, 0xD5, 0xA7, 0x1D, 0x0F, 0x49, 0x95, + 0xD7, 0x72, 0x3C, 0xAA, 0x71, 0x53, 0xE0, 0x39, + 0xD6, 0xEF, 0x81, 0x39, 0xA8, 0xBF, 0xE5, 0xB5, + 0x19, 0x72, 0x8C, 0x9E, 0x43, 0x86, 0xDF, 0xCC, + 0xB0, 0x20, 0xF3, 0x58, 0x12, 0x63, 0xAA, 0x5C, + 0x4A, 0x93, 0xA2, 0xF7, 0x84, 0xFF, 0x04, 0x9D, + 0x34, 0x01, 0x89, 0xF4, 0xCC, 0x11, 0x8D, 0x03 + }, + { + 0xE8, 0x93, 0xEF, 0x45, 0x2D, 0xC6, 0x1A, 0xB4, + 0xB7, 0x80, 0x9F, 0xBC, 0x9E, 0x0A, 0xBE, 0x5E, + 0x43, 0x12, 0xA7, 0xF5, 0x51, 0x52, 0x18, 0x63, + 0xCD, 0xAA, 0x21, 0x13, 0xAD, 0xAC, 0x6A, 0xC1, + 0x16, 0x6F, 0xD8, 0x18, 0xB5, 0x3F, 0xF0, 0x72, + 0x0A, 0x66, 0x2F, 0x09, 0xD8, 0xD0, 0x22, 0x74, + 0x32, 0x11, 0xEF, 0xCF, 0xFF, 0xE0, 0x3F, 0xDF, + 0x66, 0x83, 0x51, 0x16, 0xF0, 0x95, 0x2F, 0x2F + }, + { + 0x1C, 0xF2, 0x4B, 0x2D, 0xA8, 0x49, 0xA5, 0x47, + 0x78, 0xBC, 0x76, 0x74, 0x24, 0x36, 0x4B, 0x3E, + 0x43, 0xC0, 0x2D, 0x79, 0x31, 0x9B, 0x50, 0x5D, + 0x80, 0x36, 0xA3, 0x9F, 0x17, 0x6E, 0x40, 0x78, + 0x3B, 0x83, 0xC7, 0x9F, 0x76, 0x53, 0xA1, 0xF0, + 0x6B, 0x00, 0x36, 0xD7, 0x69, 0xA8, 0xB0, 0xDD, + 0xDB, 0x18, 0x6F, 0xB0, 0x64, 0xA6, 0xCD, 0x22, + 0x60, 0x0C, 0x26, 0x1B, 0xD9, 0xE6, 0x1C, 0xA6 + }, + { + 0x0F, 0x3E, 0xEC, 0x26, 0x34, 0x23, 0xB5, 0x24, + 0xB2, 0xD0, 0xC5, 0xCE, 0x1E, 0xC3, 0xE1, 0xED, + 0x17, 0xEC, 0x3C, 0x90, 0x7C, 0x77, 0xBC, 0x29, + 0x1A, 0xC5, 0x05, 0x64, 0x89, 0x62, 0x6D, 0x03, + 0x40, 0x18, 0xA1, 0x63, 0x7D, 0xEF, 0xD5, 0x9A, + 0x45, 0x8F, 0x10, 0xC2, 0xB4, 0x8E, 0x8D, 0xA8, + 0x3B, 0xEF, 0x17, 0x49, 0x83, 0x30, 0xF7, 0x94, + 0xB9, 0x6E, 0xDE, 0x9E, 0x0D, 0x0A, 0xA0, 0x8D + }, + { + 0x34, 0x1A, 0xCF, 0x5B, 0xFD, 0x01, 0xD1, 0xE3, + 0x20, 0xCB, 0x5B, 0x42, 0xF3, 0xA3, 0x1B, 0x0E, + 0x25, 0xBA, 0x66, 0xE0, 0x1A, 0xBD, 0x23, 0x0B, + 0x86, 0xC3, 0x08, 0x55, 0x39, 0xC6, 0x0F, 0x9B, + 0x61, 0x13, 0xB4, 0xDB, 0x75, 0xF8, 0x7D, 0xF5, + 0x0F, 0x74, 0xD2, 0x55, 0xD8, 0xA2, 0x8B, 0x3B, + 0x9A, 0x9B, 0x04, 0x3A, 0x02, 0xE3, 0xD0, 0x02, + 0x71, 0xBB, 0xE2, 0x84, 0x44, 0x0A, 0xBA, 0xBF + }, + { + 0xAC, 0x98, 0x32, 0x0A, 0x71, 0x06, 0xCA, 0xE9, + 0x64, 0x62, 0x0D, 0xF6, 0x64, 0x3A, 0x05, 0x78, + 0x1A, 0x04, 0x75, 0x08, 0x15, 0x50, 0xB8, 0xA2, + 0xD7, 0x4B, 0x8F, 0xD5, 0xC0, 0x79, 0xAB, 0x1E, + 0x80, 0xFD, 0x02, 0xCC, 0x2E, 0xDA, 0x0B, 0x3C, + 0x5E, 0xF1, 0x86, 0xD3, 0xB7, 0x88, 0x45, 0x19, + 0xCC, 0x53, 0xB1, 0xB4, 0xA6, 0xAB, 0xD0, 0xE7, + 0xDC, 0xC3, 0x72, 0x8C, 0xB2, 0x7D, 0xB6, 0x61 + }, + { + 0x89, 0x61, 0x89, 0xD9, 0x14, 0x64, 0x6E, 0xDB, + 0x10, 0x65, 0xC9, 0xEA, 0x8A, 0x0C, 0xA2, 0x3F, + 0xBB, 0x0B, 0xA5, 0xA3, 0xD6, 0x70, 0xAC, 0x01, + 0xB1, 0x82, 0xF8, 0xBD, 0x9E, 0x31, 0x88, 0x7D, + 0xB4, 0xCE, 0xE9, 0x62, 0xA8, 0x43, 0xA8, 0xDA, + 0xA6, 0x1F, 0xEC, 0x1D, 0x9C, 0xE8, 0xE0, 0x4D, + 0xB5, 0x49, 0xF5, 0x2F, 0x23, 0xAE, 0x62, 0x3A, + 0xB3, 0x81, 0xA2, 0x96, 0x4B, 0x2D, 0x5B, 0x52 + }, + { + 0x88, 0xF3, 0xC3, 0x9A, 0xEC, 0x6E, 0x3A, 0xE7, + 0xEC, 0xC8, 0x7E, 0x00, 0x30, 0xFC, 0x52, 0xFF, + 0x85, 0x2E, 0x74, 0x87, 0x4F, 0xB8, 0x68, 0xF4, + 0x9B, 0x04, 0xFE, 0x6C, 0x63, 0xB2, 0x4A, 0x2C, + 0x96, 0x74, 0xEA, 0x31, 0x48, 0x29, 0x1E, 0xE2, + 0xE1, 0x59, 0xE7, 0xDB, 0x0D, 0xC3, 0x4B, 0xE1, + 0xBD, 0x67, 0x2C, 0xC0, 0x6D, 0x36, 0x97, 0xC8, + 0x7E, 0xB0, 0xF2, 0xD8, 0x56, 0x44, 0xB6, 0x2E + }, + { + 0x74, 0xBB, 0x80, 0xF9, 0x82, 0xC0, 0x0B, 0x89, + 0xB0, 0xFE, 0x6F, 0x1B, 0xFE, 0xC4, 0x1F, 0x4E, + 0xF5, 0xB5, 0xFA, 0x15, 0x98, 0x77, 0xA5, 0x7E, + 0x14, 0x56, 0x47, 0x3F, 0x5C, 0xC5, 0xE3, 0xEE, + 0x11, 0x2C, 0x84, 0xA5, 0x1E, 0x9E, 0x07, 0x07, + 0x89, 0xF4, 0xC4, 0xC4, 0xB5, 0xAF, 0x3E, 0xEF, + 0x05, 0x2D, 0xA0, 0xD0, 0x9E, 0xE7, 0x16, 0x2F, + 0x68, 0x9C, 0x06, 0xAC, 0x6E, 0xEE, 0x28, 0xED + }, + { + 0x8C, 0xC4, 0xE9, 0xE3, 0x90, 0xEB, 0x3B, 0x9C, + 0x62, 0x73, 0x1A, 0xA0, 0x89, 0x4A, 0x16, 0x1A, + 0xA9, 0x75, 0xEA, 0x9B, 0x11, 0x94, 0x02, 0x86, + 0xD8, 0x24, 0x1C, 0x39, 0x59, 0x62, 0xEB, 0xE8, + 0xB1, 0x04, 0x46, 0x16, 0x9C, 0x4B, 0x4E, 0xE8, + 0xFD, 0xB5, 0x74, 0x3C, 0xA0, 0x6E, 0x40, 0xE8, + 0xF0, 0x21, 0x4C, 0xBF, 0xAB, 0x75, 0x57, 0xD6, + 0xDE, 0x77, 0xFD, 0x0B, 0x1E, 0x71, 0x2F, 0xE5 + }, + { + 0xC0, 0xDE, 0xD5, 0xB3, 0xC1, 0x2A, 0x63, 0x6E, + 0x7F, 0xA7, 0x87, 0x5F, 0x8F, 0x34, 0x76, 0x2B, + 0x53, 0xD9, 0xAE, 0xAA, 0xF0, 0xB7, 0xC4, 0xB5, + 0x29, 0xC6, 0xAE, 0x81, 0x2B, 0x5F, 0xC0, 0x1D, + 0x74, 0xD1, 0x00, 0xF8, 0xED, 0x5D, 0x6A, 0xD3, + 0xBB, 0x93, 0xA0, 0xD2, 0xF1, 0xAE, 0x3A, 0x2E, + 0x0F, 0x49, 0x78, 0xAF, 0x30, 0x9F, 0xDC, 0x2E, + 0x26, 0xC2, 0xF2, 0x3A, 0xAB, 0x6E, 0x49, 0xDF + }, + { + 0x95, 0x7A, 0x54, 0x8A, 0x52, 0x7C, 0xDC, 0x96, + 0x20, 0x7C, 0xFF, 0x33, 0x4B, 0x09, 0x9A, 0x88, + 0xC3, 0x42, 0x1A, 0x6C, 0x8D, 0x3E, 0x95, 0x4B, + 0xB6, 0x40, 0x7C, 0x89, 0x0E, 0xA6, 0x7C, 0xB5, + 0x13, 0x55, 0x03, 0xB8, 0x98, 0x68, 0x1A, 0xBD, + 0x4A, 0x47, 0xF4, 0xA2, 0x22, 0x38, 0x12, 0x6C, + 0x78, 0x75, 0xF1, 0xB3, 0xC3, 0x34, 0xD9, 0xD4, + 0xE1, 0x1A, 0x92, 0x0B, 0xE9, 0xDC, 0xDC, 0x81 + }, + { + 0xB7, 0xB5, 0x58, 0x57, 0x60, 0x85, 0x4B, 0x66, + 0x43, 0x3F, 0xD3, 0x92, 0x29, 0xA7, 0xE1, 0xA8, + 0xCF, 0xA3, 0xCF, 0xE1, 0x11, 0x11, 0x7F, 0x4A, + 0x43, 0x26, 0xF9, 0xEA, 0x4B, 0x0A, 0x97, 0xF4, + 0x98, 0x8E, 0xAC, 0x70, 0x18, 0x38, 0xD9, 0x5A, + 0xBD, 0xEB, 0xF5, 0x8A, 0xA9, 0xB7, 0x3F, 0xDB, + 0xCD, 0xE8, 0x62, 0x6A, 0xE3, 0x1B, 0xE9, 0x78, + 0x57, 0xBC, 0x32, 0x3C, 0x48, 0xB7, 0x67, 0x86 + }, + { + 0x13, 0x10, 0xFD, 0xF2, 0x0F, 0xB0, 0x57, 0x36, + 0x9F, 0x0F, 0x4C, 0x61, 0x5B, 0xE4, 0x92, 0x02, + 0x15, 0x6E, 0x11, 0x50, 0x26, 0x72, 0x9A, 0x6A, + 0xC8, 0x59, 0x22, 0xFE, 0x02, 0x42, 0x8C, 0xF7, + 0xE1, 0xD9, 0x12, 0x0B, 0xA3, 0x1E, 0xDB, 0x0F, + 0xC5, 0x5A, 0xA5, 0x77, 0x17, 0xCF, 0x13, 0xEC, + 0xB7, 0xED, 0x72, 0xEB, 0xC7, 0x4A, 0xD9, 0x72, + 0x8F, 0x0B, 0xE6, 0x43, 0x1A, 0xF9, 0x50, 0xB0 + }, + { + 0xEF, 0x2F, 0xC5, 0x33, 0x1A, 0x8B, 0xCA, 0xC4, + 0xA9, 0xFA, 0xC3, 0x07, 0xB1, 0x72, 0x2D, 0xB5, + 0x13, 0x09, 0xC5, 0x04, 0x21, 0xA4, 0x62, 0xBE, + 0x58, 0xCE, 0x7B, 0xF4, 0xAF, 0xA1, 0x44, 0x33, + 0x9C, 0xC6, 0xDE, 0xD5, 0xB8, 0xF5, 0xB2, 0x0B, + 0x4D, 0x85, 0x7C, 0x83, 0x18, 0x8D, 0x4B, 0xE6, + 0xCB, 0x13, 0x8D, 0x93, 0x58, 0x3F, 0xCF, 0x98, + 0xB7, 0xF1, 0xE2, 0x89, 0x7B, 0xB3, 0xC8, 0xC5 + }, + { + 0xAC, 0xB0, 0x42, 0xEE, 0x79, 0x28, 0x41, 0x74, + 0xA1, 0xF8, 0x52, 0x70, 0x67, 0x31, 0x13, 0xE6, + 0x18, 0xFF, 0xAB, 0x0E, 0x3A, 0x32, 0xA9, 0xA6, + 0xAD, 0x53, 0x78, 0xE5, 0xF1, 0x3B, 0xA7, 0x28, + 0xA0, 0xFC, 0xF2, 0x10, 0x31, 0xC4, 0x16, 0x1C, + 0x86, 0xC0, 0x05, 0x76, 0xDE, 0x97, 0x32, 0x1A, + 0x0E, 0x5E, 0x4A, 0xFB, 0x82, 0x18, 0xAA, 0x38, + 0xEE, 0xF8, 0xFF, 0x24, 0x8E, 0x21, 0x4B, 0x45 + }, + { + 0x0E, 0x99, 0xB6, 0x28, 0xDD, 0x49, 0x89, 0x07, + 0x49, 0x2B, 0x07, 0xFE, 0xFE, 0x08, 0xDF, 0xA0, + 0x5C, 0x5C, 0xEE, 0xD7, 0x57, 0xCA, 0xC2, 0x33, + 0x6B, 0xCC, 0x34, 0xDD, 0xDB, 0xEB, 0x09, 0x86, + 0x7D, 0xEF, 0x1E, 0xFC, 0xD1, 0xB3, 0x1C, 0xD7, + 0xE2, 0xD5, 0x50, 0x9D, 0x3F, 0x93, 0x4D, 0xF7, + 0xE7, 0xD4, 0x88, 0xDE, 0xBA, 0xD4, 0x20, 0xCB, + 0x3D, 0xCF, 0x81, 0x85, 0xC3, 0x29, 0x3A, 0xC5 + }, + { + 0x2E, 0x4D, 0x98, 0x5B, 0x89, 0x5E, 0x30, 0xD9, + 0xC9, 0xE5, 0x57, 0xD8, 0xC4, 0x7E, 0x12, 0x20, + 0xB8, 0x62, 0x58, 0xC6, 0x2B, 0x5C, 0xF8, 0x1F, + 0xDA, 0x81, 0x8A, 0xD9, 0x0C, 0x32, 0x57, 0xD0, + 0x14, 0x31, 0xDB, 0xCC, 0x46, 0xB4, 0x06, 0xAA, + 0xD2, 0xB5, 0x52, 0x5C, 0x7B, 0x92, 0x25, 0xEF, + 0x3E, 0xB0, 0x0F, 0x59, 0x46, 0x93, 0xE7, 0x1D, + 0x22, 0x22, 0x7A, 0x5C, 0x46, 0x1F, 0x60, 0x2E + }, + { + 0x5D, 0x5A, 0xE5, 0xE5, 0x7F, 0x46, 0x49, 0x16, + 0x79, 0x66, 0x4D, 0xCD, 0xD5, 0xD4, 0xCC, 0x66, + 0xA1, 0xC8, 0x10, 0x89, 0xCD, 0xF2, 0x42, 0xEA, + 0xC6, 0x81, 0x38, 0x28, 0x8D, 0x5A, 0x51, 0x31, + 0x16, 0xC2, 0x49, 0x7D, 0xEC, 0x9C, 0xC5, 0xDE, + 0xDA, 0x0A, 0xF7, 0xC2, 0x47, 0xF6, 0xFC, 0xDF, + 0xAF, 0xD3, 0x79, 0x45, 0x04, 0x91, 0x8D, 0xAC, + 0x78, 0xA7, 0xF4, 0xB7, 0x8F, 0x2F, 0xDB, 0x0E + }, + { + 0xAA, 0xFE, 0x9A, 0xC9, 0x1C, 0x1C, 0x07, 0x48, + 0x4D, 0x01, 0x7A, 0xED, 0x69, 0xE8, 0x7E, 0xC0, + 0x6E, 0xBD, 0x7A, 0x9B, 0xA4, 0x30, 0xF1, 0x91, + 0xAD, 0x7D, 0xB9, 0x85, 0x50, 0x5B, 0xCD, 0x5C, + 0x0F, 0x58, 0x7D, 0xAF, 0xB9, 0x2F, 0xD8, 0x10, + 0x13, 0xA5, 0xDD, 0x5A, 0x16, 0x43, 0x7F, 0xDF, + 0xBD, 0x4B, 0x1C, 0x8C, 0x1D, 0xC6, 0x3C, 0x6B, + 0xCB, 0x4E, 0x3E, 0x59, 0x81, 0xC9, 0x26, 0x50 + }, + { + 0x48, 0xF0, 0xB2, 0xED, 0xCE, 0x4E, 0x27, 0x10, + 0x86, 0x02, 0xCA, 0xE2, 0x09, 0x7F, 0x92, 0xE6, + 0xCD, 0x26, 0x49, 0x46, 0x62, 0xAA, 0xAA, 0x99, + 0x67, 0x36, 0xB6, 0xD3, 0xEC, 0x13, 0x1B, 0x62, + 0x6E, 0x04, 0xBA, 0xFC, 0x40, 0x5D, 0x27, 0xE2, + 0x2A, 0x66, 0x07, 0x8A, 0xDF, 0x1E, 0xFF, 0x24, + 0xBB, 0x84, 0x07, 0x97, 0x11, 0xDD, 0xF8, 0x9F, + 0xA0, 0xC6, 0x60, 0x55, 0x6E, 0xBC, 0x89, 0x21 + }, + { + 0x75, 0x65, 0x72, 0x32, 0x31, 0xA3, 0x26, 0xBE, + 0xE8, 0xD5, 0xE8, 0xD4, 0x6E, 0x64, 0x0A, 0xF6, + 0x01, 0x19, 0xD3, 0x57, 0x19, 0xDA, 0x85, 0xDF, + 0xEE, 0x8F, 0xE2, 0x34, 0x1D, 0x1A, 0x29, 0xFC, + 0xDB, 0xFB, 0x0F, 0x0E, 0x44, 0x6F, 0xDD, 0x9C, + 0x0D, 0x04, 0x20, 0xA3, 0xE5, 0xE5, 0x15, 0x33, + 0x00, 0x4D, 0x4D, 0x25, 0x0F, 0xA9, 0xAE, 0x5F, + 0xDD, 0xA0, 0x7C, 0x09, 0x7A, 0x6E, 0x16, 0x4D + }, + { + 0xE2, 0xFE, 0x2B, 0x88, 0xF7, 0x99, 0x29, 0xB8, + 0xF6, 0xC6, 0x4B, 0xE3, 0x1D, 0xF7, 0x53, 0xEF, + 0x11, 0x14, 0xAD, 0x76, 0x5C, 0x2E, 0x47, 0xBF, + 0xD9, 0x4E, 0x76, 0x7A, 0xDC, 0xE7, 0x13, 0x91, + 0xA6, 0xC7, 0x96, 0x67, 0x58, 0xF9, 0xD5, 0x82, + 0xBB, 0x37, 0x7D, 0x51, 0xC0, 0x9E, 0x01, 0x0A, + 0x85, 0x8D, 0x44, 0x7A, 0xAB, 0x0C, 0x91, 0x60, + 0xAD, 0xED, 0x18, 0x0D, 0x6D, 0xDE, 0xA7, 0x08 + }, + { + 0xCE, 0xD0, 0x98, 0x48, 0x5A, 0xA4, 0x5B, 0x02, + 0x4F, 0xCE, 0x7D, 0x22, 0x2F, 0x44, 0x1F, 0xDE, + 0x73, 0xB2, 0x7B, 0xDC, 0x68, 0x0F, 0x4E, 0x14, + 0x78, 0x39, 0xEF, 0x28, 0x91, 0x1A, 0x53, 0x8D, + 0xC0, 0xB1, 0x2F, 0x3B, 0xCF, 0x83, 0xD3, 0x9F, + 0xBA, 0xD0, 0xEB, 0xFE, 0x84, 0x07, 0x1E, 0xA8, + 0xE6, 0x4C, 0x4F, 0x1F, 0x20, 0x1A, 0x67, 0x51, + 0xC0, 0xAF, 0xB1, 0xCB, 0x63, 0x59, 0x20, 0xCD + }, + { + 0xA1, 0x1F, 0xC9, 0x77, 0x88, 0xCD, 0x2B, 0x89, + 0xBE, 0xFC, 0x9A, 0x5D, 0x4E, 0xE3, 0x02, 0xBA, + 0x1D, 0xB4, 0x7C, 0x81, 0xE3, 0xC7, 0xD8, 0x44, + 0x42, 0xCE, 0xA1, 0x0A, 0x28, 0x1B, 0x29, 0x6E, + 0x41, 0x73, 0xD9, 0xDD, 0x88, 0x8B, 0xE8, 0x09, + 0x90, 0x33, 0xBD, 0x15, 0x42, 0xC9, 0xC4, 0xF2, + 0x47, 0x6F, 0x8D, 0x07, 0x38, 0xA2, 0xDC, 0xD3, + 0xE1, 0x97, 0x60, 0x14, 0x94, 0xDA, 0xDC, 0xB7 + }, + { + 0xBA, 0x18, 0xA5, 0xB9, 0x49, 0x67, 0xCF, 0xE5, + 0x53, 0xFD, 0x79, 0x05, 0x59, 0x8D, 0xE6, 0xD9, + 0x3D, 0xEB, 0xC2, 0x3F, 0xD3, 0x7E, 0x2F, 0x9F, + 0x6F, 0xA3, 0xD1, 0xBA, 0x72, 0x19, 0x7B, 0x93, + 0x15, 0xCB, 0x0D, 0xA5, 0x09, 0x2F, 0x61, 0x03, + 0xC8, 0x55, 0xEA, 0x79, 0x99, 0x38, 0xA4, 0xCA, + 0xF1, 0x92, 0xCC, 0x90, 0xFF, 0xD0, 0x1C, 0x94, + 0x7D, 0x80, 0x72, 0xD3, 0x79, 0x4E, 0x56, 0x1F + }, + { + 0x53, 0x2B, 0x34, 0x1C, 0x05, 0x2F, 0xEC, 0x87, + 0x1A, 0xDB, 0xB5, 0xB7, 0x78, 0x88, 0x25, 0x92, + 0x03, 0x88, 0xA9, 0x56, 0x17, 0x9C, 0x5E, 0xE2, + 0x4F, 0x0F, 0x1E, 0x6A, 0xAC, 0x75, 0x48, 0xCD, + 0x40, 0x5E, 0xF9, 0xBD, 0x64, 0x89, 0x3E, 0x53, + 0xAB, 0x82, 0x90, 0x48, 0xE2, 0x83, 0xF0, 0xE0, + 0x72, 0xA3, 0xE1, 0x39, 0xE8, 0x13, 0xE6, 0xB7, + 0x87, 0xE7, 0x39, 0xD1, 0x64, 0x22, 0x4C, 0x81 + }, + { + 0xC3, 0xC9, 0x6B, 0x1E, 0xEC, 0x04, 0x35, 0x14, + 0x2B, 0xE3, 0x09, 0x1C, 0xC2, 0xC2, 0xA4, 0xE3, + 0xF6, 0xC0, 0xC0, 0xED, 0xE4, 0x02, 0xF9, 0x38, + 0x0C, 0x98, 0xDD, 0x5B, 0x26, 0xAC, 0x9A, 0x7F, + 0xDA, 0xB5, 0x7C, 0x02, 0x7A, 0x7A, 0x02, 0x99, + 0xB3, 0xEB, 0x5A, 0x64, 0xF6, 0xE5, 0xBC, 0x15, + 0x28, 0xCA, 0x2C, 0x23, 0xE2, 0x3B, 0x3F, 0x4F, + 0xC4, 0xE1, 0x46, 0x50, 0x6E, 0x55, 0xFE, 0xFF + }, + { + 0xEB, 0xAA, 0xB5, 0xD5, 0x6C, 0x90, 0x08, 0x72, + 0xA3, 0xEA, 0xEE, 0xB6, 0xF5, 0x40, 0x1F, 0xA9, + 0xDB, 0xD9, 0x95, 0x80, 0x0D, 0x25, 0xCA, 0xE8, + 0x7C, 0xB1, 0xC0, 0xFE, 0x81, 0x56, 0x55, 0x2D, + 0x41, 0xA3, 0xFD, 0xDC, 0x36, 0x48, 0x8F, 0x49, + 0xAC, 0x31, 0xCA, 0x47, 0x0B, 0xB3, 0x4A, 0x33, + 0xDD, 0x34, 0xF2, 0x0A, 0xAD, 0xE3, 0x87, 0xD7, + 0xF2, 0xE6, 0xF2, 0x2D, 0x26, 0x2C, 0x1B, 0x80 + }, + { + 0x5D, 0xDE, 0x91, 0xA0, 0xC2, 0xF8, 0xFA, 0xD2, + 0x08, 0x21, 0x04, 0x6C, 0xC9, 0x7F, 0x13, 0xEB, + 0x04, 0x99, 0xB6, 0x3C, 0xE3, 0x09, 0x6C, 0x73, + 0x19, 0xCC, 0x80, 0x8F, 0xE0, 0x9D, 0x61, 0x5A, + 0x38, 0xEB, 0x62, 0xE3, 0xA1, 0x0E, 0x58, 0x00, + 0xCA, 0xB5, 0x95, 0x90, 0x4D, 0x93, 0x81, 0x53, + 0x83, 0xA8, 0xF6, 0x67, 0x82, 0x1D, 0xC2, 0x91, + 0x3D, 0xCB, 0xA4, 0x01, 0x63, 0xC7, 0x7F, 0x62 + }, + { + 0x0D, 0x73, 0x9C, 0x5C, 0x97, 0x3D, 0xCE, 0x9A, + 0xF5, 0xB0, 0xB2, 0x8A, 0x34, 0xE1, 0x8E, 0x52, + 0xA2, 0xB9, 0xCE, 0xC8, 0x08, 0xF6, 0xE0, 0xCA, + 0x58, 0xEB, 0xD5, 0x05, 0xFA, 0x8F, 0x00, 0x96, + 0x13, 0xA2, 0xBD, 0xD0, 0x85, 0x27, 0x6F, 0x29, + 0x72, 0xCF, 0x6D, 0x94, 0x60, 0xE7, 0x42, 0x34, + 0xF2, 0x5C, 0x3A, 0x77, 0xE3, 0x67, 0x36, 0x98, + 0x18, 0x46, 0xCA, 0xA4, 0xDD, 0xB4, 0xC3, 0x8E + }, + { + 0x54, 0x72, 0x5D, 0xBA, 0x88, 0xB3, 0x3F, 0x08, + 0x47, 0xC3, 0xB9, 0x95, 0x9B, 0x93, 0xDD, 0xE7, + 0x4E, 0xF4, 0x8E, 0x5A, 0xB0, 0xE2, 0x38, 0x5A, + 0x91, 0x25, 0xD8, 0x38, 0x40, 0x85, 0xD6, 0x3A, + 0xD1, 0xDA, 0xB9, 0x11, 0x2C, 0x62, 0x7F, 0x12, + 0x82, 0xE9, 0x78, 0x26, 0xAE, 0xFC, 0x87, 0x27, + 0x92, 0xD8, 0x7E, 0x37, 0x9B, 0x97, 0xFD, 0xF6, + 0xC4, 0xB6, 0xF8, 0x31, 0x5A, 0x3A, 0x46, 0xD8 + }, + { + 0xD5, 0x73, 0x76, 0xD9, 0xDF, 0x32, 0xE9, 0x38, + 0xBD, 0xD6, 0x8C, 0x7C, 0x83, 0xCA, 0xE9, 0x96, + 0x67, 0xB7, 0x77, 0xC6, 0xB7, 0x8F, 0x04, 0xF8, + 0x75, 0xC3, 0x58, 0x2C, 0x92, 0xC2, 0x11, 0xA7, + 0x20, 0x78, 0xE5, 0x6E, 0x6E, 0x4D, 0xC1, 0x95, + 0x59, 0x83, 0xFE, 0x98, 0x6D, 0xE8, 0x25, 0x1D, + 0xB9, 0x57, 0xC5, 0x3A, 0xDA, 0xA9, 0x82, 0x38, + 0xF8, 0x6B, 0xDB, 0x4C, 0x6D, 0x00, 0x43, 0x97 + }, + { + 0x2F, 0x93, 0xB4, 0xFF, 0x6F, 0xDA, 0xDD, 0x7B, + 0x5B, 0xFB, 0x0C, 0x0A, 0x45, 0xA3, 0x70, 0x70, + 0x36, 0xD7, 0x55, 0x7F, 0xD1, 0xE0, 0xB5, 0x5C, + 0x35, 0x2F, 0xBA, 0x41, 0x3A, 0x1A, 0x4D, 0x2B, + 0xC6, 0x0A, 0x47, 0xC1, 0x79, 0x15, 0x20, 0xDB, + 0x69, 0x8B, 0xB4, 0xCC, 0xEE, 0xE7, 0x11, 0x27, + 0x4D, 0xAF, 0xC1, 0x97, 0x9D, 0x0E, 0x23, 0xD3, + 0x1A, 0x6B, 0x28, 0xF4, 0xA1, 0x0C, 0xDB, 0x8C + }, + { + 0x13, 0x42, 0x4A, 0xFB, 0x67, 0x8F, 0x44, 0xA3, + 0xBE, 0x7B, 0x20, 0xF8, 0x78, 0x3E, 0xE6, 0xD4, + 0xAD, 0x1C, 0x75, 0xC1, 0x77, 0x3F, 0x3D, 0xFD, + 0x1A, 0x6F, 0x96, 0x89, 0xFD, 0x25, 0x94, 0x3E, + 0x47, 0x58, 0xF4, 0x3E, 0xE4, 0x40, 0x68, 0xF2, + 0x72, 0x8D, 0x2F, 0x91, 0x7F, 0x73, 0xF1, 0x01, + 0xBE, 0x07, 0xCC, 0xE4, 0x25, 0x24, 0x85, 0x08, + 0x69, 0x5F, 0xFA, 0xA4, 0x95, 0x23, 0x3E, 0xD3 + }, + { + 0x30, 0xCB, 0x6F, 0x63, 0x75, 0x7F, 0x99, 0xEE, + 0x39, 0xC3, 0x3D, 0x10, 0xE3, 0x41, 0xEA, 0xDD, + 0xA5, 0x96, 0x04, 0xB1, 0xAA, 0x53, 0xD1, 0x25, + 0xA6, 0x26, 0xFB, 0x82, 0xEE, 0x0A, 0xA7, 0x85, + 0xBB, 0xBB, 0x92, 0x83, 0x95, 0xDB, 0x5F, 0x9E, + 0xD8, 0xBE, 0x46, 0x40, 0x82, 0x5E, 0xBC, 0xCE, + 0xFF, 0x5B, 0xBB, 0x8F, 0xF0, 0xA2, 0x2F, 0x97, + 0x88, 0x57, 0x20, 0x40, 0xAE, 0x50, 0x67, 0x4D + }, + { + 0x20, 0x5C, 0xF7, 0xEA, 0xDA, 0x75, 0x8D, 0x08, + 0x00, 0x0D, 0x94, 0xB3, 0x0B, 0xB7, 0x7C, 0x54, + 0x08, 0x28, 0x67, 0x13, 0xAE, 0x41, 0x9D, 0xBA, + 0x39, 0xA3, 0xB9, 0xF7, 0x8B, 0xB9, 0x0D, 0x11, + 0x33, 0xC6, 0xBD, 0xB5, 0x2D, 0x5C, 0xF9, 0xBC, + 0xB7, 0x1E, 0xF9, 0x47, 0xFB, 0x06, 0xD7, 0xDF, + 0x17, 0x86, 0x23, 0xE2, 0x86, 0xFE, 0x5B, 0x1D, + 0x2C, 0x5A, 0x2D, 0xC2, 0x24, 0x58, 0x83, 0xC9 + }, + { + 0x30, 0x11, 0x48, 0x86, 0x45, 0xAD, 0x0A, 0x40, + 0x17, 0x01, 0x04, 0x8E, 0x3B, 0xA1, 0xD7, 0x8E, + 0x85, 0x49, 0xB9, 0xE9, 0xE7, 0xD7, 0x73, 0x3D, + 0x81, 0xDE, 0xFB, 0x94, 0xB4, 0x85, 0x38, 0x64, + 0xE4, 0xD2, 0x47, 0x5B, 0x21, 0x46, 0x3E, 0xE1, + 0xAF, 0x4F, 0x72, 0xF7, 0x6F, 0xDA, 0x55, 0xD8, + 0xF6, 0xAF, 0x60, 0xA1, 0xDB, 0xC5, 0x29, 0x33, + 0xCA, 0x03, 0xF8, 0xAE, 0x8F, 0x5B, 0x53, 0xC5 + }, + { + 0xD1, 0xF1, 0xB6, 0x10, 0xDA, 0x6E, 0x00, 0x5E, + 0x16, 0xB0, 0x00, 0x8D, 0xC2, 0x7B, 0xE0, 0x22, + 0xEE, 0xD4, 0xC2, 0x75, 0xC1, 0x0C, 0xCE, 0x86, + 0x89, 0x6D, 0x07, 0x74, 0x7D, 0x24, 0xF9, 0x9F, + 0x0E, 0x7E, 0x22, 0xFC, 0x82, 0x2A, 0xCB, 0xCF, + 0x1C, 0xB4, 0xA6, 0xBC, 0x34, 0xC2, 0x10, 0x01, + 0x34, 0xC8, 0x9D, 0xD1, 0x95, 0xA9, 0xC3, 0x4E, + 0xF8, 0x82, 0x20, 0x0B, 0xD5, 0xD8, 0x10, 0xB6 + }, + { + 0x28, 0x66, 0xA5, 0x2D, 0xCB, 0x1D, 0xC4, 0xE6, + 0x19, 0xAF, 0xF1, 0x28, 0xF4, 0x6E, 0x92, 0x8D, + 0xC5, 0xD1, 0x5A, 0x05, 0x8C, 0xD3, 0xB7, 0x45, + 0x0D, 0x92, 0x0A, 0x81, 0xAB, 0x4F, 0x37, 0x43, + 0x7B, 0x5D, 0x41, 0xA7, 0xEA, 0xFD, 0x84, 0x7B, + 0x01, 0x26, 0x28, 0x5A, 0x25, 0x49, 0x49, 0xB5, + 0xCE, 0xFE, 0x75, 0xC3, 0x10, 0x72, 0x50, 0x31, + 0x50, 0x2B, 0xAE, 0xF4, 0xEB, 0xD1, 0x56, 0x22 + }, + { + 0x95, 0x3F, 0x77, 0xAF, 0x3F, 0xB4, 0x31, 0xC7, + 0xD6, 0x40, 0x26, 0xB2, 0x79, 0x2B, 0xCF, 0x22, + 0xBE, 0x49, 0x85, 0x09, 0x89, 0x62, 0x78, 0x75, + 0x81, 0x8F, 0x7F, 0xFB, 0x47, 0x24, 0x6E, 0x80, + 0x38, 0x7D, 0x49, 0x26, 0x8C, 0x04, 0x06, 0x33, + 0x72, 0xE7, 0xAE, 0x63, 0x85, 0x61, 0xE6, 0x28, + 0x0D, 0x75, 0x7E, 0xF7, 0x17, 0x12, 0x7F, 0x7E, + 0x23, 0xE5, 0x85, 0x99, 0x92, 0x24, 0x20, 0x17 + }, + { + 0x8A, 0x98, 0x79, 0xE1, 0x8D, 0xA6, 0xA8, 0xFE, + 0x72, 0xE9, 0x89, 0x39, 0x5D, 0x46, 0xFF, 0xC8, + 0xC1, 0xE7, 0x7D, 0x29, 0x0F, 0x86, 0x25, 0xA3, + 0x06, 0x25, 0x67, 0x68, 0x8B, 0x0B, 0x3E, 0xC4, + 0x32, 0x10, 0x5F, 0x31, 0x1D, 0x9D, 0xA0, 0xFE, + 0x01, 0xB1, 0x76, 0x27, 0x90, 0xA2, 0x17, 0x6C, + 0xA4, 0x9C, 0xE1, 0x77, 0x27, 0xCE, 0x6F, 0xC8, + 0x4B, 0xAC, 0x85, 0xF7, 0x39, 0x09, 0x6A, 0xC8 + }, + { + 0x80, 0xB4, 0x39, 0x7D, 0xBF, 0x89, 0x92, 0x5C, + 0xC5, 0xD5, 0x0B, 0xC5, 0xB2, 0xD9, 0x7E, 0xE8, + 0x60, 0x5D, 0xF3, 0x3B, 0x7E, 0xFD, 0xDE, 0x04, + 0x63, 0xEE, 0xCA, 0xC1, 0xF5, 0x6E, 0xA0, 0x8E, + 0xFA, 0xC4, 0x09, 0xC8, 0x00, 0x5A, 0xE4, 0x3E, + 0x8D, 0xC4, 0x03, 0x67, 0xFA, 0x24, 0xD4, 0x86, + 0x7E, 0xA2, 0x49, 0xAF, 0x4A, 0x7E, 0x60, 0x72, + 0xA9, 0x26, 0x24, 0x09, 0xE0, 0xC7, 0xBD, 0x6D + }, + { + 0x52, 0x42, 0x35, 0xF5, 0x82, 0x34, 0x0A, 0xCD, + 0x34, 0x2A, 0x1A, 0x28, 0x75, 0xAF, 0xE6, 0x2A, + 0x19, 0xD1, 0x87, 0x68, 0xD1, 0xC0, 0x71, 0x65, + 0x9B, 0x28, 0xF2, 0x1C, 0x6B, 0x2B, 0xD5, 0xD1, + 0x06, 0x26, 0xE8, 0x3B, 0x54, 0xE2, 0xE5, 0xB5, + 0xB5, 0x09, 0x73, 0x28, 0xCE, 0xB1, 0x79, 0x8C, + 0x94, 0xAD, 0x0E, 0x25, 0x24, 0x0D, 0xC8, 0xB4, + 0xE7, 0xFD, 0xB6, 0x1A, 0x06, 0x9D, 0xB4, 0x28 + }, + { + 0x39, 0x20, 0xC7, 0xAD, 0xD7, 0x79, 0x88, 0x66, + 0xD7, 0xC8, 0x7F, 0xE2, 0xA2, 0xED, 0xE3, 0xEE, + 0x3D, 0x30, 0xD4, 0x99, 0x00, 0xBC, 0x5F, 0x68, + 0x99, 0x80, 0x09, 0x41, 0xA9, 0xD6, 0xB0, 0x25, + 0xEF, 0x05, 0x6E, 0xA3, 0xF6, 0x68, 0x56, 0xD5, + 0xC0, 0xAA, 0x82, 0x94, 0xC8, 0x4F, 0x8C, 0xF0, + 0xB9, 0x7D, 0xC6, 0x4C, 0xC8, 0xE0, 0x46, 0x72, + 0x04, 0x96, 0x56, 0x4D, 0x04, 0x67, 0xEC, 0x1C + }, + { + 0x1D, 0x9F, 0x1E, 0xCE, 0x49, 0xD0, 0x6F, 0x7E, + 0x97, 0x0B, 0xE1, 0x03, 0x3A, 0x5E, 0x56, 0xE0, + 0x42, 0x5B, 0x25, 0x3E, 0x32, 0xF6, 0x57, 0x92, + 0x9F, 0x29, 0x43, 0x69, 0x82, 0xA3, 0x01, 0x12, + 0xBA, 0x69, 0x8C, 0xB5, 0xDA, 0x56, 0x61, 0x17, + 0xD0, 0xDB, 0x6A, 0x90, 0x04, 0x5F, 0x8A, 0xF6, + 0x0B, 0x4F, 0xE6, 0xD8, 0xD9, 0xD7, 0x44, 0xE3, + 0x06, 0x89, 0xF8, 0x68, 0x83, 0xF6, 0x22, 0x4D + }, + { + 0xBD, 0xE7, 0x4E, 0x65, 0x58, 0xC2, 0x6E, 0x73, + 0x8E, 0x41, 0xB4, 0xFB, 0xFE, 0xFB, 0x80, 0xF3, + 0xE2, 0xBC, 0x6F, 0x12, 0xCF, 0xEC, 0xD4, 0xC8, + 0x67, 0x27, 0x1A, 0x02, 0x98, 0xFD, 0xDC, 0xB7, + 0x0D, 0x6E, 0xB6, 0xC5, 0x10, 0xD3, 0x74, 0xC7, + 0xB7, 0xAF, 0x9F, 0xB0, 0x15, 0x1C, 0x60, 0x11, + 0xA2, 0x60, 0x44, 0x7F, 0xB0, 0xC5, 0x60, 0x14, + 0xC5, 0x50, 0x3C, 0xA5, 0x5E, 0x91, 0xD0, 0xCB + }, + { + 0x6C, 0x20, 0xAE, 0x54, 0xBD, 0x52, 0x43, 0x96, + 0x3B, 0x19, 0x73, 0x09, 0x4B, 0xA0, 0xD1, 0x51, + 0xBD, 0xAF, 0x1E, 0x1F, 0xC4, 0x32, 0x77, 0xD7, + 0xDA, 0x8C, 0x6D, 0x2B, 0x86, 0xC1, 0x5A, 0x69, + 0x79, 0xB4, 0xB3, 0x02, 0x60, 0xA1, 0x58, 0xFA, + 0xA6, 0x5E, 0x3E, 0x5D, 0x03, 0xC6, 0x5B, 0x7E, + 0xD0, 0x11, 0xC8, 0xFC, 0x1E, 0xCB, 0xC6, 0xDE, + 0x88, 0x33, 0xA2, 0xB9, 0xA6, 0x8E, 0x0F, 0xA3 + }, + { + 0x3E, 0x9C, 0xDF, 0xFE, 0x9E, 0x1F, 0xF1, 0xF3, + 0x3F, 0x8D, 0xAE, 0xC6, 0x3D, 0x07, 0x4A, 0x8C, + 0x9D, 0xBD, 0x9B, 0x01, 0x2C, 0x77, 0x9A, 0x2D, + 0x75, 0x10, 0xA8, 0xF8, 0x81, 0x85, 0x26, 0xBF, + 0xEF, 0x2E, 0x7F, 0x91, 0x6B, 0x38, 0x49, 0xF1, + 0xFE, 0x1B, 0xCA, 0xDB, 0xBD, 0xEA, 0x3F, 0x59, + 0x0A, 0x14, 0xD6, 0xAF, 0xED, 0x07, 0x00, 0x66, + 0xBA, 0xCC, 0x26, 0x64, 0xA6, 0xF1, 0x3A, 0x73 + }, + { + 0x79, 0xEA, 0x1D, 0x53, 0xF4, 0xE4, 0xB7, 0x94, + 0xF3, 0x49, 0x1C, 0xCE, 0xFB, 0x7D, 0xAC, 0x28, + 0x1E, 0x7B, 0x18, 0xA7, 0xD6, 0xD9, 0x50, 0x90, + 0x0C, 0xA9, 0x0C, 0xBE, 0xC1, 0xD9, 0x85, 0x35, + 0xF6, 0xA4, 0x80, 0x7C, 0x65, 0xA2, 0x87, 0x38, + 0x04, 0x09, 0x83, 0x9F, 0x59, 0x21, 0x61, 0xDB, + 0x0A, 0x3C, 0x03, 0x2C, 0x88, 0xFD, 0xE8, 0xEC, + 0xB3, 0x17, 0xCD, 0x80, 0x32, 0x35, 0x69, 0x6C + }, + { + 0xE7, 0x90, 0xB3, 0xCF, 0x9D, 0xFB, 0x2E, 0x25, + 0xFA, 0x7E, 0x73, 0x4C, 0xFE, 0x1E, 0x69, 0xBF, + 0x1D, 0x35, 0xF3, 0xB0, 0x67, 0x87, 0x3C, 0x7F, + 0xB3, 0x3C, 0x02, 0xC1, 0x1E, 0x42, 0x58, 0xB0, + 0x41, 0x3E, 0xBD, 0x5C, 0x0F, 0xBA, 0x07, 0xDE, + 0x1F, 0xA8, 0xE1, 0xF5, 0x4D, 0xDB, 0xAC, 0x8C, + 0x21, 0x7A, 0x38, 0xE3, 0xC2, 0x5E, 0xE3, 0x27, + 0x3D, 0x53, 0xF8, 0x36, 0xA9, 0x60, 0xCA, 0xA6 + }, + { + 0x13, 0x03, 0x2B, 0xBF, 0xD2, 0xC8, 0x41, 0xBD, + 0x2D, 0x5E, 0x6B, 0x0D, 0x2F, 0x64, 0x29, 0xAC, + 0xB1, 0x3C, 0x98, 0xE8, 0x79, 0xA3, 0xEC, 0x1F, + 0xA3, 0x6C, 0xFC, 0xB5, 0x62, 0x8B, 0x3A, 0xF2, + 0x46, 0x3B, 0xD0, 0x00, 0x1D, 0xF7, 0x41, 0xC6, + 0xB8, 0x84, 0x24, 0x8B, 0x82, 0x6E, 0x31, 0x66, + 0xA3, 0x7A, 0xC3, 0xBF, 0x9B, 0xB7, 0xAB, 0x2E, + 0x11, 0xA7, 0x8A, 0x18, 0x20, 0x5E, 0xC2, 0x1A + }, + { + 0x8E, 0x1C, 0x3E, 0xCC, 0x50, 0xDF, 0x8E, 0x29, + 0xB0, 0xE9, 0x38, 0x5F, 0x27, 0xB4, 0xF8, 0xAD, + 0x15, 0xC3, 0xC3, 0x73, 0x6F, 0xF9, 0x4C, 0xDA, + 0xEE, 0xD8, 0xCE, 0xB8, 0xF1, 0x4A, 0x2F, 0x46, + 0x8E, 0xFF, 0xE8, 0x30, 0x76, 0x01, 0xED, 0xC0, + 0xC2, 0xFF, 0x62, 0xB6, 0x45, 0x67, 0xCD, 0x86, + 0x07, 0x88, 0x22, 0xAC, 0x86, 0x57, 0xF5, 0xB1, + 0x42, 0x42, 0x23, 0x1E, 0xD1, 0xDE, 0x7C, 0xF2 + }, + { + 0xD8, 0xDF, 0xD4, 0x37, 0x3F, 0x2D, 0xAC, 0x82, + 0x42, 0x96, 0xAC, 0xEF, 0xE6, 0x3B, 0xAD, 0x93, + 0x72, 0xF8, 0x6E, 0x94, 0xA8, 0x7A, 0xD2, 0x56, + 0x4C, 0x81, 0x53, 0xE0, 0x37, 0xDF, 0xA5, 0x97, + 0x99, 0xA6, 0xF2, 0x10, 0xE9, 0xDA, 0xC0, 0x6D, + 0x9C, 0x28, 0x3B, 0x46, 0xEF, 0xC2, 0x63, 0x3B, + 0x84, 0x1B, 0x69, 0x83, 0x3F, 0xD5, 0x2C, 0x49, + 0x45, 0x10, 0xDA, 0x05, 0xEB, 0xB0, 0x8B, 0x49 + }, + { + 0x2C, 0xD9, 0x95, 0xFA, 0xD1, 0x02, 0x85, 0xE6, + 0xED, 0x22, 0xDB, 0x8D, 0x3B, 0x1A, 0x70, 0x63, + 0x6A, 0xA2, 0xC4, 0xAB, 0xF6, 0x45, 0xF9, 0x0B, + 0xE0, 0x14, 0x7B, 0xAA, 0x17, 0x59, 0xAD, 0x4C, + 0x1A, 0xEE, 0x86, 0x8A, 0x17, 0xB5, 0xB9, 0xA7, + 0x73, 0xDC, 0xC9, 0xFE, 0x5C, 0x0D, 0xEE, 0xAA, + 0x45, 0xB0, 0xAE, 0xDE, 0x88, 0x81, 0xA8, 0xEB, + 0xC1, 0x77, 0xB0, 0x94, 0x81, 0xFB, 0x94, 0x5C + }, + { + 0xC2, 0xB9, 0xA5, 0xA9, 0x90, 0x49, 0x76, 0x8B, + 0xDB, 0x72, 0xB0, 0x35, 0xC8, 0x30, 0xDA, 0xCB, + 0x1C, 0x62, 0x0D, 0xF0, 0x9B, 0x88, 0x4D, 0x87, + 0xD1, 0x64, 0xE5, 0xFB, 0xFE, 0x7E, 0x7A, 0xA5, + 0x23, 0x1F, 0xBD, 0x3F, 0xC3, 0x9F, 0x6D, 0xCE, + 0x9A, 0x99, 0x99, 0x19, 0xDE, 0x0D, 0xF9, 0x7C, + 0x68, 0x31, 0x66, 0x9B, 0xA8, 0x09, 0xB9, 0xD2, + 0xA8, 0x24, 0xEB, 0x66, 0x7C, 0x4C, 0xBC, 0x39 + }, + { + 0xB2, 0x85, 0x2D, 0x46, 0xAD, 0x39, 0x16, 0xF7, + 0xE7, 0x97, 0x86, 0xAB, 0x28, 0x6B, 0x64, 0x85, + 0xEC, 0x16, 0xCF, 0x41, 0x3B, 0x8F, 0xD3, 0xA1, + 0x2F, 0xF6, 0x5B, 0xE1, 0x1F, 0x5D, 0x05, 0xBB, + 0x03, 0xED, 0x0A, 0x62, 0x9D, 0x0B, 0x1C, 0x39, + 0xB2, 0x73, 0xE0, 0xBC, 0x8B, 0xB6, 0xC7, 0x71, + 0x5D, 0xA2, 0x25, 0xF7, 0xE3, 0xC4, 0xFE, 0x0E, + 0xF5, 0x69, 0x20, 0x44, 0xDB, 0xE1, 0x20, 0x9D + }, + { + 0x2E, 0x15, 0x4B, 0x28, 0xC6, 0x01, 0x16, 0x30, + 0xF4, 0xCF, 0xB0, 0x82, 0x45, 0x03, 0xB5, 0x75, + 0x00, 0x97, 0xE3, 0x06, 0x84, 0x2B, 0xEB, 0xA9, + 0x0E, 0x25, 0xC8, 0xC5, 0x1D, 0x72, 0x9E, 0x1B, + 0x2B, 0xFC, 0x6B, 0xA0, 0x0F, 0x09, 0x0B, 0x75, + 0x0C, 0xCB, 0x60, 0xDB, 0xA8, 0x37, 0xC5, 0x91, + 0x3B, 0xCC, 0xCA, 0x40, 0xCD, 0x31, 0xEE, 0x2D, + 0x44, 0x6C, 0xF3, 0x79, 0x50, 0xFA, 0xC4, 0x05 + }, + { + 0x39, 0x39, 0x15, 0xDF, 0x4B, 0xDA, 0xEC, 0xA0, + 0xBD, 0xCE, 0x08, 0x4F, 0x8A, 0x3C, 0xF1, 0x73, + 0x1D, 0xAC, 0xD3, 0x56, 0xDA, 0x0D, 0xB9, 0x20, + 0x6C, 0xC7, 0x84, 0x10, 0x6B, 0xE7, 0x02, 0x44, + 0xAC, 0x87, 0xF4, 0x4D, 0xF5, 0xFF, 0x58, 0x8F, + 0x28, 0xE0, 0x51, 0x65, 0x4A, 0xBF, 0xCF, 0xD9, + 0x1B, 0xD7, 0xC2, 0x95, 0xD8, 0x59, 0xA1, 0xEC, + 0x0A, 0x42, 0xE9, 0x45, 0x08, 0x46, 0x01, 0x23 + }, + { + 0x3B, 0xF7, 0xA1, 0x1E, 0x28, 0xAF, 0xEB, 0xC2, + 0x14, 0x12, 0x36, 0x39, 0x98, 0x0B, 0x0F, 0xC5, + 0xA8, 0xE4, 0xD3, 0xCD, 0x30, 0xA5, 0x06, 0xE4, + 0xCF, 0x43, 0xEB, 0xCD, 0x2E, 0x64, 0x3B, 0xA0, + 0xF5, 0xD6, 0xC0, 0x39, 0x33, 0xBB, 0x64, 0x23, + 0xD3, 0x63, 0xD8, 0x47, 0x99, 0x9E, 0xFB, 0xD0, + 0xE5, 0x95, 0x03, 0x3D, 0x45, 0x05, 0x3C, 0x17, + 0xF4, 0xB7, 0x81, 0xF4, 0x7E, 0x96, 0xEC, 0x62 + }, + { + 0xAE, 0xB0, 0xE6, 0xD2, 0xA8, 0x3A, 0xFE, 0x6F, + 0x86, 0x64, 0x27, 0x5C, 0xCB, 0x6A, 0x5C, 0xD5, + 0xF0, 0x1F, 0x9C, 0x76, 0xEC, 0xCF, 0xCC, 0xC2, + 0xDD, 0x20, 0x24, 0xBB, 0x3F, 0x01, 0x89, 0x9C, + 0x48, 0xAA, 0xDE, 0x20, 0x30, 0xFB, 0xED, 0x5B, + 0xB3, 0xD8, 0x6F, 0x4D, 0xEB, 0xBF, 0x68, 0xD5, + 0xE5, 0x9B, 0x3A, 0x33, 0x3A, 0x2B, 0x16, 0x56, + 0x1E, 0xEB, 0x8B, 0x16, 0xA6, 0xA6, 0x36, 0x88 + }, + { + 0xD3, 0x74, 0xFF, 0x00, 0xFE, 0x18, 0x66, 0xC3, + 0x92, 0xF2, 0xE1, 0x86, 0xF5, 0x9D, 0x94, 0xCD, + 0xD9, 0x68, 0xD4, 0x57, 0xE2, 0x93, 0x5A, 0x72, + 0xA6, 0xE5, 0x6D, 0xC0, 0x20, 0x2F, 0xD6, 0x2C, + 0xAD, 0x7C, 0x97, 0x4F, 0x51, 0xF9, 0xFB, 0xA1, + 0x2C, 0xC0, 0xDE, 0xC1, 0x29, 0x1C, 0x76, 0x1E, + 0xAC, 0xF7, 0x35, 0x03, 0x67, 0x05, 0x35, 0x5C, + 0xF3, 0x93, 0xDD, 0x93, 0x92, 0x2F, 0x94, 0xA5 + }, + { + 0x5E, 0xF7, 0xF8, 0xB8, 0x49, 0xB3, 0x85, 0xA0, + 0x4F, 0xD7, 0xEB, 0xC5, 0x04, 0x92, 0xE9, 0xD6, + 0x90, 0xBA, 0x17, 0xD5, 0x16, 0x11, 0x77, 0x18, + 0xC3, 0xDB, 0xC0, 0x21, 0x53, 0xAB, 0x37, 0x91, + 0xCC, 0xE5, 0x75, 0x7A, 0x1E, 0x66, 0x66, 0x08, + 0x87, 0xB0, 0x12, 0xF8, 0xB8, 0x79, 0x17, 0x92, + 0x59, 0xE3, 0x3D, 0xE1, 0xD3, 0x8D, 0xCE, 0x80, + 0xE4, 0x92, 0x08, 0xEC, 0x48, 0xAA, 0x49, 0x7C + }, + { + 0x78, 0x27, 0xB8, 0xC5, 0x49, 0xD5, 0xEC, 0x84, + 0x75, 0x7E, 0x5A, 0xA7, 0x2C, 0x49, 0x0A, 0x17, + 0x84, 0xF2, 0x2C, 0xD1, 0x7B, 0xB5, 0x4B, 0xCA, + 0xE8, 0x78, 0x98, 0x99, 0x04, 0x05, 0xB4, 0xD7, + 0x01, 0xC2, 0x01, 0x9B, 0x6F, 0xAE, 0xD9, 0x3D, + 0x90, 0xB3, 0xD6, 0xF1, 0x2B, 0xAA, 0xF4, 0xFD, + 0x3E, 0xDE, 0xEE, 0x2D, 0xEF, 0xB6, 0xA3, 0xFA, + 0xAE, 0xC6, 0x81, 0xB1, 0x67, 0xE9, 0x70, 0x28 + }, + { + 0x83, 0x66, 0x5E, 0x2C, 0x73, 0x92, 0x16, 0x60, + 0xA0, 0xAF, 0x9B, 0x2B, 0x46, 0x42, 0xA8, 0x7C, + 0xEE, 0x58, 0x44, 0xDC, 0x15, 0xA7, 0xBA, 0x00, + 0xA2, 0x02, 0x38, 0x6F, 0xB5, 0x64, 0x80, 0xCD, + 0x68, 0xEE, 0x69, 0x66, 0xD5, 0x4D, 0xC1, 0xC2, + 0xD0, 0x80, 0xB9, 0x98, 0x45, 0xBE, 0x10, 0x07, + 0x68, 0x28, 0x71, 0xEF, 0x07, 0xFD, 0x85, 0x28, + 0x6E, 0x4E, 0xDE, 0xC3, 0xA0, 0x06, 0x6C, 0xAF + }, + { + 0xEB, 0x7B, 0x7B, 0xB4, 0xD5, 0x21, 0x70, 0x25, + 0x70, 0x5E, 0x94, 0x9D, 0x98, 0xDB, 0x93, 0xEE, + 0x62, 0xE6, 0x4F, 0x6F, 0xB9, 0xE6, 0xF4, 0x51, + 0x08, 0xA5, 0xF7, 0xEB, 0xE2, 0x90, 0x81, 0x61, + 0x29, 0x4B, 0x0E, 0x8C, 0x90, 0x4A, 0xFA, 0x9D, + 0x57, 0xC5, 0x06, 0xE9, 0xDA, 0x3B, 0x02, 0x80, + 0x6F, 0xD5, 0x76, 0x7A, 0xE5, 0x54, 0x98, 0xEB, + 0x3B, 0xB8, 0xCD, 0x7F, 0x09, 0x1B, 0x57, 0x2D + }, + { + 0x14, 0xBA, 0x32, 0xC1, 0xC8, 0x0B, 0xB3, 0x2C, + 0x82, 0x82, 0xAA, 0x53, 0xF3, 0x41, 0xF4, 0x5D, + 0xAA, 0xBD, 0xA1, 0x2B, 0xDA, 0x41, 0xF7, 0xAD, + 0x8E, 0xC7, 0x5B, 0xAA, 0x74, 0x3A, 0x41, 0xAD, + 0xF2, 0x37, 0x6A, 0xD3, 0xDE, 0x32, 0xFB, 0x57, + 0x6D, 0x3E, 0xFD, 0xCA, 0xDF, 0x3F, 0x59, 0xD2, + 0x5B, 0x40, 0xB9, 0x15, 0x68, 0x1C, 0xC9, 0x0D, + 0xEE, 0x3A, 0x9B, 0x2C, 0xB0, 0x20, 0x61, 0xEA + }, + { + 0x2D, 0x9A, 0xF8, 0x50, 0x3C, 0x1B, 0x10, 0x7A, + 0xEC, 0xE8, 0xEC, 0xC7, 0x3F, 0x2C, 0x2A, 0x6E, + 0xCF, 0xE3, 0xDE, 0xF9, 0x43, 0xAB, 0x27, 0x7B, + 0xB3, 0x32, 0x36, 0x43, 0xB8, 0xBB, 0xD3, 0x36, + 0x31, 0xE3, 0x4D, 0x0F, 0x09, 0x5A, 0x4A, 0xFB, + 0x01, 0x93, 0xB2, 0xD4, 0x4B, 0xCD, 0x11, 0x38, + 0x3D, 0x60, 0xAD, 0x02, 0x04, 0x72, 0xB1, 0x9F, + 0x28, 0xF3, 0xED, 0xF3, 0xDB, 0xCB, 0xDC, 0xDA + }, + { + 0xE4, 0xA6, 0xA7, 0xA3, 0x9C, 0xFD, 0xA6, 0x08, + 0x80, 0x84, 0xFD, 0x11, 0x2C, 0x2B, 0x9A, 0x83, + 0xBF, 0x9A, 0xAC, 0x50, 0x98, 0xA1, 0x98, 0x67, + 0x30, 0xB1, 0x25, 0x10, 0x68, 0x63, 0x73, 0x99, + 0xEB, 0x2A, 0xC4, 0xC8, 0xEC, 0xA0, 0xB1, 0x7C, + 0xBD, 0xDA, 0x68, 0x35, 0xAE, 0x51, 0xC1, 0x55, + 0x4A, 0xBB, 0xB1, 0xDD, 0xE7, 0xC8, 0x5B, 0x0F, + 0x63, 0x6C, 0x22, 0x47, 0xB2, 0x3F, 0x35, 0x52 + }, + { + 0x09, 0xA0, 0x81, 0xCE, 0x6C, 0x95, 0x7C, 0x72, + 0xF3, 0xF1, 0xD7, 0xFE, 0x62, 0x1D, 0x3C, 0x23, + 0x99, 0x6A, 0x41, 0x81, 0xB1, 0x2D, 0xCE, 0xE6, + 0x7F, 0x7E, 0x6C, 0x85, 0x45, 0xDC, 0x14, 0x45, + 0xA6, 0x85, 0x5F, 0x48, 0x07, 0x46, 0x8A, 0x72, + 0x25, 0x5F, 0x24, 0xB5, 0x1A, 0x29, 0x48, 0xD2, + 0xE3, 0x6D, 0x29, 0x91, 0x52, 0x0F, 0xED, 0x77, + 0xDD, 0x15, 0x7A, 0x98, 0x5F, 0x76, 0xA4, 0x52 + }, + { + 0x05, 0x59, 0x15, 0x1B, 0xAD, 0x18, 0x2B, 0x69, + 0x52, 0xE1, 0xBB, 0x0C, 0xE0, 0xAF, 0x7F, 0xA2, + 0xA2, 0xA4, 0x25, 0xF0, 0x00, 0x46, 0xB3, 0x7B, + 0x72, 0xD8, 0x2D, 0x40, 0x8E, 0xFD, 0xE7, 0x1B, + 0xC4, 0x11, 0x56, 0xFF, 0xC2, 0xFB, 0x7C, 0xE2, + 0x99, 0x9E, 0x46, 0xBA, 0x6F, 0x5B, 0xE8, 0x5B, + 0xFA, 0x29, 0xCF, 0x72, 0xA4, 0xBC, 0xD9, 0xE3, + 0x13, 0x1E, 0xB2, 0x04, 0x58, 0x57, 0x45, 0xE4 + }, + { + 0xFD, 0xF2, 0x73, 0x23, 0xAC, 0xAA, 0xA2, 0xF9, + 0x17, 0x56, 0xD0, 0xAF, 0x6C, 0x99, 0x6C, 0x38, + 0x8A, 0xD6, 0xF9, 0x04, 0x2A, 0xC9, 0xC9, 0x22, + 0xA6, 0xBC, 0x83, 0x84, 0x54, 0xE5, 0x86, 0x72, + 0x67, 0xE1, 0x3F, 0x5F, 0x44, 0xC1, 0x27, 0x82, + 0x38, 0xF5, 0x5F, 0x8A, 0xDD, 0x38, 0x5C, 0xB3, + 0x40, 0x9A, 0xD8, 0xFC, 0x42, 0x51, 0x78, 0x36, + 0x79, 0xB6, 0xD5, 0xC4, 0xEB, 0xB9, 0x87, 0x29 + }, + { + 0x9C, 0x17, 0x15, 0x40, 0xE9, 0x07, 0x01, 0xE9, + 0x21, 0x63, 0x8C, 0x15, 0x47, 0xD5, 0x43, 0x8B, + 0x45, 0x37, 0xB9, 0x61, 0xA4, 0x7D, 0xEA, 0x11, + 0xF0, 0x81, 0x73, 0x30, 0x85, 0x64, 0x71, 0x16, + 0x60, 0xA3, 0x7E, 0xF1, 0xEB, 0xBA, 0x86, 0x76, + 0xED, 0x42, 0x91, 0xED, 0x91, 0x6E, 0xD2, 0x40, + 0x46, 0xEA, 0x72, 0x44, 0x78, 0x93, 0x7C, 0x13, + 0x76, 0xED, 0x18, 0x54, 0x02, 0x3F, 0x67, 0x00 + }, + { + 0x31, 0x4F, 0x0F, 0x64, 0x5B, 0x49, 0x49, 0xEC, + 0x4C, 0xE1, 0x82, 0xE5, 0xB3, 0x6B, 0x8B, 0xAD, + 0x73, 0x25, 0x88, 0x68, 0xF6, 0x6B, 0x8E, 0x7D, + 0x24, 0x09, 0x75, 0x65, 0xFC, 0x14, 0x32, 0x5E, + 0x26, 0xD7, 0x14, 0x86, 0x9E, 0x5E, 0x94, 0x83, + 0xCB, 0x36, 0x2E, 0xC1, 0x37, 0x7D, 0xAD, 0xF2, + 0x6E, 0x1B, 0x32, 0x40, 0x80, 0x34, 0xE8, 0x62, + 0xC4, 0x9F, 0x48, 0xA5, 0x60, 0x0F, 0x75, 0x15 + }, + { + 0xB5, 0x9B, 0x25, 0x20, 0x21, 0x1F, 0xEA, 0x6B, + 0x10, 0x05, 0x69, 0x04, 0x3D, 0xB3, 0xAB, 0x07, + 0xCB, 0x20, 0x5A, 0xE1, 0x84, 0xE0, 0xFD, 0x14, + 0x70, 0xE4, 0x94, 0xCD, 0x80, 0x5C, 0xBD, 0xC8, + 0xCB, 0xD3, 0x0F, 0xFB, 0x4B, 0xBA, 0xD7, 0x92, + 0x26, 0x4F, 0xC4, 0x1C, 0xED, 0x7F, 0x8A, 0x68, + 0xC1, 0x24, 0xB4, 0x4C, 0x0C, 0x05, 0xF8, 0x83, + 0xCA, 0xDF, 0x95, 0xE1, 0xB8, 0xE6, 0x6A, 0x44 + }, + { + 0xDA, 0xF5, 0xA1, 0xD0, 0xD6, 0xEE, 0x1F, 0x2C, + 0x14, 0x70, 0x13, 0xB9, 0xBE, 0xD0, 0x2D, 0xA5, + 0x04, 0x8C, 0x57, 0x19, 0x25, 0x2D, 0xBE, 0x43, + 0xDF, 0x9C, 0x27, 0x51, 0xBF, 0x1C, 0x42, 0x83, + 0x86, 0x46, 0x3F, 0x5F, 0xD2, 0x35, 0xD7, 0x19, + 0x44, 0x8B, 0x33, 0x26, 0xAA, 0xBF, 0xE5, 0xD7, + 0x70, 0x27, 0x7A, 0xA4, 0xDB, 0xE4, 0xB6, 0x13, + 0x72, 0x54, 0xCD, 0x92, 0x61, 0x22, 0x8B, 0x16 + }, + { + 0x13, 0xAA, 0x00, 0x82, 0x60, 0x30, 0x36, 0xD3, + 0xCF, 0x8F, 0x19, 0x78, 0xD5, 0x8B, 0xAB, 0x85, + 0x80, 0x54, 0x45, 0x11, 0xC0, 0x55, 0xB6, 0xE6, + 0x5E, 0x5D, 0xC5, 0x71, 0x0E, 0x00, 0x8A, 0xB0, + 0xCA, 0x65, 0xDF, 0xE1, 0x45, 0x54, 0x8C, 0xE8, + 0x3D, 0xF6, 0x0F, 0xBE, 0xA2, 0x8B, 0x58, 0x9C, + 0xD5, 0x95, 0xFE, 0x84, 0xA4, 0x43, 0x2B, 0x91, + 0x5C, 0x31, 0x64, 0x2A, 0xB4, 0x77, 0xE2, 0x84 + }, + { + 0x65, 0xEA, 0x4E, 0x2F, 0xDD, 0x15, 0xDE, 0xCA, + 0xD4, 0x79, 0xD7, 0xB1, 0xAC, 0x42, 0xF8, 0xAD, + 0x25, 0x18, 0x2D, 0x34, 0xF7, 0x22, 0x94, 0xBF, + 0x10, 0x90, 0xA0, 0x0E, 0x70, 0x6D, 0x3D, 0x50, + 0x91, 0xE9, 0x18, 0x0F, 0xE3, 0x15, 0x4D, 0x4C, + 0x83, 0xFE, 0x35, 0xE8, 0x3D, 0xCE, 0x15, 0x62, + 0x9D, 0xD7, 0x40, 0xAF, 0x91, 0x76, 0x64, 0xB8, + 0xA2, 0x82, 0x66, 0x3F, 0xD3, 0x29, 0x91, 0x88 + }, + { + 0x9E, 0xFD, 0xE7, 0x90, 0xEC, 0x60, 0xFC, 0x2C, + 0x0D, 0xD0, 0x6C, 0xFB, 0x71, 0xF7, 0xB1, 0x0D, + 0x83, 0x78, 0x8B, 0x56, 0x42, 0x12, 0xA2, 0xEB, + 0xAC, 0x40, 0x31, 0x45, 0x88, 0xE5, 0x7A, 0x42, + 0xF5, 0x27, 0x83, 0xC3, 0xC9, 0x91, 0x79, 0xB7, + 0x1C, 0x86, 0x1B, 0xA7, 0xFE, 0x72, 0xC6, 0x6F, + 0x4A, 0x93, 0xC7, 0x3C, 0xCA, 0x16, 0x71, 0xB1, + 0xF2, 0x05, 0x4E, 0x9F, 0x17, 0xDA, 0x39, 0x68 + }, + { + 0x39, 0x67, 0xB1, 0x1D, 0x4A, 0xE9, 0x09, 0x59, + 0x5B, 0x18, 0x5A, 0x19, 0xCF, 0xE7, 0xCB, 0x68, + 0x10, 0x5D, 0xC0, 0x5A, 0x88, 0x79, 0xE9, 0xFB, + 0xE6, 0xC3, 0x00, 0xE2, 0x9A, 0x17, 0xBF, 0xFB, + 0xD0, 0x7B, 0x76, 0xD8, 0x8C, 0x28, 0xE1, 0x8F, + 0xC4, 0x6C, 0x2A, 0xA1, 0xED, 0xC0, 0xE2, 0x37, + 0x27, 0xF1, 0x74, 0x0F, 0x91, 0x6F, 0xC1, 0x16, + 0xFB, 0x59, 0xBF, 0x7E, 0xB4, 0x04, 0xF5, 0x3D + }, + { + 0xD3, 0x62, 0xD8, 0xA3, 0x9B, 0x93, 0x2F, 0x5A, + 0x28, 0x33, 0x5D, 0x65, 0xE9, 0x2B, 0x2C, 0xE0, + 0x46, 0xA0, 0xC2, 0x92, 0x09, 0x23, 0x2D, 0x7F, + 0xA9, 0xD7, 0xC4, 0x75, 0x00, 0x06, 0x97, 0x59, + 0xBE, 0x09, 0x55, 0x03, 0x94, 0xFB, 0x4B, 0xD8, + 0x64, 0xAC, 0x56, 0x53, 0xD9, 0x60, 0x68, 0x9D, + 0x2E, 0x20, 0x1A, 0x92, 0xC5, 0xE7, 0x76, 0x40, + 0x41, 0x3A, 0xF1, 0x74, 0xCA, 0xED, 0xDB, 0x47 + }, + { + 0xA1, 0x74, 0x9A, 0x95, 0x6A, 0x63, 0x17, 0x6A, + 0x80, 0xBE, 0x7D, 0x0D, 0xD2, 0x7E, 0xC0, 0xC7, + 0x8F, 0x4D, 0x0F, 0x8F, 0x5A, 0x6A, 0xDF, 0x5B, + 0xAD, 0x49, 0x24, 0x4F, 0x4A, 0xA4, 0xE3, 0x05, + 0xAE, 0x1C, 0x7F, 0x3C, 0x85, 0x15, 0xE6, 0xB0, + 0x2A, 0x97, 0xDF, 0x30, 0x46, 0xB6, 0x74, 0x14, + 0xA5, 0xD7, 0x20, 0x94, 0x67, 0xF2, 0x3A, 0x72, + 0x3F, 0x17, 0x72, 0x8D, 0x39, 0x5E, 0x77, 0xF7 + }, + { + 0x66, 0x0C, 0xAD, 0x4A, 0x79, 0x3F, 0xA8, 0xF9, + 0x68, 0xBE, 0x41, 0xF8, 0xC7, 0xBB, 0xE3, 0xC0, + 0x28, 0x57, 0x64, 0x24, 0x6B, 0x7B, 0x90, 0xBB, + 0x09, 0xC9, 0x6C, 0xE0, 0xB3, 0x71, 0x64, 0x47, + 0x88, 0x9B, 0x95, 0x2A, 0x43, 0x58, 0x24, 0x58, + 0x3B, 0x2B, 0x3E, 0x22, 0x12, 0x2F, 0x29, 0x87, + 0xCC, 0xF1, 0x21, 0xEB, 0xD3, 0xB6, 0x5F, 0xA6, + 0x08, 0xA2, 0x78, 0x57, 0xE7, 0xD6, 0x82, 0x71 + }, + { + 0x26, 0x5B, 0x1F, 0x5E, 0xFD, 0xF7, 0x9D, 0x68, + 0xA1, 0x90, 0x4F, 0xE4, 0x91, 0x6A, 0x60, 0xC5, + 0x48, 0x65, 0xD6, 0xE2, 0xA3, 0x00, 0x11, 0x33, + 0x34, 0xDD, 0x44, 0x56, 0xFE, 0x35, 0x27, 0x0D, + 0xCF, 0x83, 0x01, 0x4C, 0xDF, 0xF2, 0x99, 0x2E, + 0xB4, 0xB9, 0x8A, 0x1F, 0x08, 0x4A, 0xCD, 0xA9, + 0x63, 0xB7, 0x6C, 0x2B, 0xCB, 0x6D, 0x08, 0x53, + 0x85, 0x6B, 0x14, 0xFF, 0x12, 0xFA, 0xC6, 0x71 + }, + { + 0x79, 0x30, 0x4D, 0x59, 0x7A, 0xB7, 0xB6, 0xB0, + 0xF6, 0x7C, 0x0B, 0x80, 0xF6, 0x28, 0xA8, 0x09, + 0xB3, 0xE5, 0x93, 0x03, 0x62, 0x4F, 0xE8, 0x49, + 0x79, 0xAE, 0x26, 0x92, 0xC4, 0x0E, 0xFA, 0xD2, + 0x8F, 0xCD, 0x8F, 0x9D, 0x3C, 0xFC, 0x0F, 0xBB, + 0xD7, 0x89, 0x5D, 0x4F, 0xD7, 0x54, 0x1E, 0x79, + 0xAA, 0x4F, 0xFF, 0x2B, 0x46, 0x7B, 0xAB, 0x80, + 0x94, 0x22, 0x6C, 0x64, 0xA2, 0xA1, 0x08, 0x5B + }, + { + 0x91, 0xEB, 0x88, 0x60, 0x7E, 0x8E, 0x8A, 0x6C, + 0x29, 0x54, 0x83, 0xB9, 0x48, 0x52, 0x13, 0xBC, + 0x89, 0x25, 0x08, 0x0F, 0x06, 0xC5, 0x56, 0x10, + 0x93, 0x54, 0x0B, 0xBB, 0x3B, 0x0C, 0xC9, 0x71, + 0x06, 0x0D, 0x80, 0x8C, 0x5F, 0x3F, 0xBA, 0x8D, + 0xF4, 0x59, 0x8A, 0xC9, 0xC2, 0x3A, 0x26, 0xC7, + 0xBA, 0x80, 0xE3, 0xEB, 0x24, 0x96, 0xDF, 0x65, + 0x17, 0x4B, 0x5E, 0xB6, 0x2E, 0xEF, 0xDA, 0x78 + }, + { + 0xB7, 0x48, 0x7A, 0x6C, 0x8D, 0x3E, 0x33, 0xAE, + 0x14, 0x13, 0x53, 0x84, 0x9C, 0x40, 0x76, 0x1E, + 0x69, 0x04, 0x16, 0x31, 0x6A, 0x7B, 0x80, 0xD6, + 0x52, 0xE1, 0x0C, 0xC6, 0xE6, 0x2D, 0x36, 0xA1, + 0xA9, 0x87, 0x22, 0x4F, 0x7C, 0x42, 0xC3, 0x03, + 0xD1, 0x0A, 0x4A, 0x02, 0x12, 0x6C, 0xB1, 0x76, + 0xE8, 0xAE, 0xED, 0xD2, 0xEB, 0x34, 0x0D, 0x21, + 0xF7, 0xDF, 0xF2, 0xB9, 0xB1, 0xBD, 0x46, 0x10 + }, + { + 0x50, 0xC6, 0x58, 0x45, 0xFF, 0x77, 0x72, 0x5F, + 0x19, 0x6A, 0x25, 0x46, 0xEC, 0x1A, 0xDA, 0xED, + 0x77, 0xFE, 0x91, 0x70, 0x29, 0x0C, 0xF0, 0x2C, + 0x4A, 0x3C, 0x5F, 0x6C, 0xE0, 0x5C, 0xD6, 0xE3, + 0x7B, 0x7A, 0xE4, 0xEA, 0x86, 0x69, 0x94, 0xBE, + 0x29, 0xA2, 0xA7, 0xD9, 0x9D, 0xDF, 0x0E, 0x9C, + 0xCE, 0x08, 0xB8, 0x00, 0x59, 0x00, 0x07, 0x10, + 0x72, 0x48, 0x9C, 0xAB, 0x97, 0x17, 0x2C, 0xAE + }, + { + 0x60, 0x69, 0xE5, 0xD4, 0x6C, 0x5C, 0x0C, 0x22, + 0xE8, 0x32, 0xE7, 0x34, 0xC0, 0xBE, 0x9F, 0x2B, + 0xCE, 0x0F, 0x78, 0xC2, 0xA3, 0xBB, 0x5B, 0x68, + 0x93, 0x70, 0xDD, 0x19, 0x56, 0xDC, 0xEE, 0x7A, + 0xEE, 0xB1, 0x30, 0x56, 0x12, 0xA2, 0x10, 0xA2, + 0x5F, 0x2B, 0x01, 0x49, 0x91, 0xD8, 0xA7, 0xFD, + 0x94, 0x68, 0xA5, 0x52, 0xFD, 0xD7, 0x28, 0xEF, + 0x4B, 0x05, 0x4F, 0xAF, 0x2F, 0x4A, 0x21, 0xD0 + }, + { + 0x81, 0x04, 0xB0, 0x51, 0xD0, 0x8B, 0x19, 0x94, + 0xC6, 0xB1, 0x8D, 0x0D, 0xE1, 0x6F, 0x72, 0xAC, + 0x5B, 0xC9, 0xD1, 0x55, 0xDD, 0x51, 0x8E, 0xAD, + 0x09, 0xEB, 0x2E, 0x05, 0x97, 0x35, 0x64, 0x07, + 0xB8, 0x03, 0xDA, 0x3D, 0x2C, 0x0A, 0xAE, 0x28, + 0xD4, 0x95, 0x16, 0x40, 0x33, 0xE5, 0x32, 0x8D, + 0xF6, 0x82, 0xF8, 0xBB, 0x10, 0x48, 0x00, 0xB8, + 0x8D, 0xD3, 0xD0, 0xB7, 0x85, 0xDA, 0x24, 0xD7 + }, + { + 0xFE, 0xD5, 0x10, 0x83, 0x9F, 0xC7, 0xE7, 0x74, + 0x40, 0xAE, 0xE4, 0xD4, 0x80, 0xAA, 0xEB, 0xC2, + 0xC1, 0xE1, 0xE2, 0xB2, 0xEA, 0x9E, 0xE4, 0x5D, + 0xBF, 0xFD, 0xA1, 0xF2, 0x68, 0x9C, 0x74, 0x5B, + 0x3D, 0xD1, 0x18, 0x1D, 0x21, 0xBE, 0x97, 0x89, + 0xF9, 0xFF, 0x71, 0x2F, 0x19, 0x68, 0x62, 0x44, + 0xD9, 0x11, 0x9B, 0x26, 0x8C, 0xE5, 0x64, 0x71, + 0x10, 0xC1, 0xDB, 0x85, 0x25, 0xB2, 0x2D, 0x7C + }, + { + 0x90, 0x04, 0x63, 0xBF, 0x90, 0x99, 0x5A, 0xFE, + 0x17, 0x81, 0x6D, 0xA8, 0xB8, 0x2F, 0x8F, 0x46, + 0x7D, 0x76, 0x68, 0x5E, 0x42, 0xA4, 0x6C, 0xA0, + 0xBE, 0x91, 0x32, 0x78, 0x25, 0xAC, 0x6D, 0xE0, + 0x02, 0xFE, 0x96, 0xA0, 0x93, 0xBF, 0x9F, 0x30, + 0x00, 0xB2, 0xBD, 0xA1, 0xE0, 0x5F, 0xEE, 0x6F, + 0xA9, 0xD1, 0x4B, 0x2F, 0x0F, 0xE1, 0x8D, 0xDE, + 0xB9, 0xBB, 0x4A, 0xE1, 0x06, 0x2F, 0x2F, 0xB7 + }, + { + 0x26, 0xB1, 0x4A, 0xD7, 0x8B, 0x33, 0x70, 0x99, + 0x8D, 0xA7, 0x7F, 0x42, 0x02, 0xF6, 0xFE, 0xCB, + 0x68, 0x25, 0x78, 0x7E, 0x75, 0xE8, 0xAF, 0x55, + 0x4A, 0x86, 0x50, 0x12, 0xCA, 0x8D, 0x07, 0x91, + 0xBA, 0xE6, 0xEA, 0x59, 0x65, 0x60, 0x71, 0x76, + 0x19, 0x0A, 0xF0, 0xE6, 0x53, 0xE5, 0xEB, 0x78, + 0xEB, 0x3B, 0x92, 0x28, 0xC0, 0x11, 0xC6, 0x0C, + 0xCE, 0xDA, 0x50, 0xA2, 0xEA, 0xA2, 0x51, 0x93 + }, + { + 0x0C, 0x9A, 0x39, 0x17, 0x1C, 0x33, 0x18, 0xD1, + 0xA2, 0x6B, 0xDB, 0x96, 0x5E, 0xF6, 0xC6, 0x14, + 0x49, 0x3E, 0x3A, 0x43, 0xE3, 0xDF, 0x59, 0x56, + 0x73, 0x81, 0x47, 0xC2, 0x3C, 0xD9, 0x49, 0x87, + 0x56, 0xC6, 0xF2, 0x8A, 0x8E, 0x94, 0x5B, 0x27, + 0xFF, 0xCE, 0x9D, 0xC1, 0xFB, 0x70, 0xCF, 0xEC, + 0xE8, 0x1F, 0x0D, 0x15, 0x45, 0x68, 0x28, 0x79, + 0x16, 0xD8, 0x4D, 0xC0, 0x7D, 0x3C, 0x9C, 0x79 + }, + { + 0x9D, 0xB9, 0xB7, 0x29, 0x8B, 0xEB, 0xF0, 0x03, + 0x29, 0x4B, 0x02, 0x3D, 0x80, 0x4B, 0xB7, 0xBD, + 0xDE, 0xEE, 0x20, 0x67, 0x2C, 0x99, 0x84, 0xEB, + 0x85, 0xFD, 0x73, 0x02, 0x42, 0x29, 0xEC, 0xBF, + 0x2C, 0x60, 0x03, 0xFD, 0x5F, 0xAD, 0x6D, 0xAF, + 0x88, 0x0C, 0xEF, 0xF0, 0xAD, 0x23, 0x9B, 0x97, + 0xF7, 0x19, 0x82, 0xF5, 0xF2, 0xC6, 0x0E, 0x63, + 0xB1, 0x5F, 0x0F, 0x9A, 0xE6, 0x12, 0xC2, 0x38 + }, + { + 0xD7, 0x1E, 0xE9, 0x74, 0x9D, 0xCE, 0x4F, 0x91, + 0x76, 0x27, 0xAA, 0xEB, 0xFF, 0xEF, 0xEB, 0x4C, + 0x9E, 0x06, 0x1B, 0xD9, 0xE4, 0x42, 0x68, 0x85, + 0x24, 0x6B, 0xE7, 0xAF, 0xE8, 0x85, 0x9F, 0x2F, + 0x22, 0xEA, 0xE4, 0x5B, 0x78, 0xEB, 0xBB, 0x69, + 0x64, 0x8A, 0xDD, 0x94, 0x9D, 0x7E, 0x77, 0xCF, + 0x61, 0xD4, 0x73, 0xDB, 0x6E, 0x10, 0x36, 0xDC, + 0x71, 0x77, 0xE2, 0x0A, 0x4D, 0x6A, 0x15, 0xCF + }, + { + 0xBA, 0xAF, 0xED, 0x58, 0x5B, 0x21, 0xCD, 0xB0, + 0x6A, 0x01, 0xB4, 0xA8, 0x63, 0xE9, 0x2C, 0x1C, + 0x04, 0x56, 0xD4, 0x3F, 0xE5, 0x3F, 0x72, 0x0A, + 0xC9, 0x44, 0xE4, 0x34, 0x39, 0x43, 0x56, 0x93, + 0x43, 0x5D, 0xC9, 0x4C, 0x7F, 0xFB, 0x79, 0x6D, + 0x61, 0x96, 0x6D, 0x93, 0x7E, 0xAE, 0xE3, 0x9E, + 0x69, 0x6B, 0x57, 0x43, 0xBB, 0x10, 0xC8, 0x5F, + 0x0A, 0x19, 0xAB, 0xE7, 0xBE, 0x88, 0x27, 0x76 + }, + { + 0xCD, 0x81, 0x0E, 0x03, 0x2E, 0xEF, 0x58, 0x24, + 0xB9, 0xA3, 0x67, 0x13, 0x07, 0x06, 0x5F, 0xB7, + 0x7B, 0x78, 0x8C, 0x6C, 0xA8, 0x6D, 0x46, 0x43, + 0xE9, 0x3C, 0x99, 0xB9, 0x4B, 0xD3, 0xE6, 0x0C, + 0x03, 0x6B, 0xD2, 0x62, 0xAC, 0x0D, 0xFF, 0xF7, + 0x74, 0x2E, 0xB3, 0x27, 0xD1, 0xAC, 0xAD, 0xD1, + 0x07, 0x37, 0xC4, 0x86, 0x99, 0x2B, 0x28, 0x58, + 0xB6, 0x33, 0x68, 0xC6, 0x50, 0x47, 0x6F, 0x15 + }, + { + 0x74, 0x05, 0xA8, 0xB1, 0x58, 0x80, 0xBE, 0x24, + 0x1C, 0x9F, 0xF1, 0x77, 0xC0, 0xAB, 0x4B, 0xAB, + 0xE6, 0x27, 0x1E, 0x01, 0xD1, 0x67, 0x75, 0x32, + 0x77, 0xDC, 0x59, 0x7C, 0x9F, 0x7B, 0xAA, 0x11, + 0xA9, 0xBF, 0xAD, 0x9E, 0x71, 0xF5, 0xA2, 0x48, + 0x85, 0x7C, 0xC4, 0xCD, 0xE6, 0x19, 0x53, 0xDE, + 0xED, 0x82, 0x48, 0x98, 0x74, 0x4B, 0x63, 0x07, + 0x7E, 0xC6, 0x7D, 0xC1, 0x0F, 0x06, 0x18, 0x99 + }, + { + 0xFD, 0x7A, 0x70, 0x8F, 0xA8, 0x04, 0xE3, 0x05, + 0xE1, 0x67, 0xFB, 0x99, 0x0D, 0x3E, 0xAB, 0x1B, + 0x93, 0x34, 0x12, 0xDE, 0xF6, 0xB1, 0x84, 0xCE, + 0x72, 0xCC, 0xF4, 0x19, 0xE2, 0xBD, 0xC9, 0x46, + 0x1B, 0x21, 0x9B, 0xF9, 0x28, 0xAE, 0x05, 0x38, + 0xAD, 0x83, 0xB2, 0x88, 0x10, 0xB6, 0x2A, 0xD0, + 0xE3, 0x93, 0x82, 0xC9, 0x03, 0x86, 0x28, 0x4A, + 0x39, 0xEF, 0xB6, 0x2E, 0x89, 0x7A, 0x60, 0x4A + }, + { + 0x79, 0xFB, 0x07, 0x98, 0x8B, 0x56, 0x51, 0x0C, + 0x28, 0xFE, 0x6D, 0x7F, 0x65, 0xDB, 0xD7, 0xDF, + 0x57, 0xA1, 0xE3, 0x3E, 0x7D, 0x9F, 0xF8, 0x65, + 0x71, 0x5E, 0xDE, 0x55, 0xA7, 0x3C, 0x69, 0x7B, + 0xBA, 0xD2, 0x42, 0xA0, 0xEB, 0xCD, 0xE2, 0x2A, + 0xB6, 0x8D, 0xAD, 0x72, 0x0B, 0x6E, 0x07, 0xD4, + 0xDE, 0xF3, 0xD2, 0x5F, 0xB6, 0x30, 0x37, 0x29, + 0x56, 0xE0, 0x2F, 0x32, 0x5D, 0xC9, 0xDC, 0x5A + }, + { + 0x06, 0x84, 0xA4, 0x57, 0x7B, 0x10, 0xD0, 0x10, + 0xA7, 0x89, 0xBE, 0x9E, 0xB5, 0x17, 0xDA, 0x82, + 0x19, 0x4F, 0xE8, 0xA8, 0x4B, 0x79, 0x61, 0xBF, + 0x29, 0x1D, 0x43, 0x90, 0xE0, 0xB4, 0xD5, 0x03, + 0x6F, 0x5A, 0x89, 0x9B, 0x74, 0xE7, 0x1A, 0xC7, + 0x71, 0x22, 0x1E, 0x3A, 0x58, 0xDA, 0xC6, 0xE5, + 0xC9, 0x49, 0x78, 0xC5, 0xCD, 0x12, 0xAD, 0x50, + 0x24, 0x8B, 0x40, 0xD3, 0x78, 0x3A, 0x62, 0x92 + }, + { + 0x17, 0x23, 0x7A, 0xFF, 0x1D, 0x7E, 0xFB, 0xA7, + 0xA0, 0x04, 0xBD, 0x5F, 0xE0, 0xEB, 0xC0, 0x2C, + 0xB6, 0x56, 0x8D, 0x18, 0x71, 0x28, 0x2F, 0x32, + 0x4A, 0xA4, 0x9B, 0x82, 0xCE, 0x6E, 0x6A, 0xC3, + 0x9B, 0x4E, 0xF0, 0xA5, 0xC4, 0x6A, 0x79, 0xF9, + 0x98, 0x7A, 0xA2, 0x19, 0xA4, 0xA7, 0x67, 0xD3, + 0x6F, 0xB8, 0xF7, 0x97, 0xB6, 0x23, 0x13, 0x45, + 0x7F, 0x4D, 0xFA, 0xA5, 0x21, 0xA8, 0x63, 0x40 + }, + { + 0x1F, 0x38, 0x2D, 0x3D, 0x3E, 0x86, 0xC2, 0xDB, + 0x0D, 0xA6, 0xE4, 0xD0, 0x9F, 0xCD, 0x18, 0x30, + 0x08, 0xDC, 0x17, 0x57, 0x68, 0x2D, 0x86, 0x24, + 0x58, 0xB0, 0xCA, 0xD3, 0xFD, 0x20, 0x65, 0x8F, + 0x59, 0x6F, 0x79, 0x36, 0x17, 0xF2, 0xC8, 0x97, + 0x7C, 0x33, 0x49, 0x18, 0x8C, 0x49, 0x49, 0x55, + 0xB8, 0x63, 0xFF, 0x06, 0x2A, 0x51, 0x64, 0x2C, + 0x6C, 0x76, 0x76, 0xF2, 0x3C, 0x68, 0xF6, 0xDA + }, + { + 0xD0, 0x77, 0xA8, 0x9D, 0xF6, 0x52, 0x9F, 0xF1, + 0x07, 0x08, 0x6D, 0x38, 0xFE, 0x15, 0x1A, 0x10, + 0xE7, 0x39, 0xFF, 0x9F, 0x1D, 0xF3, 0x95, 0x9D, + 0x62, 0x23, 0xC1, 0x8B, 0xDF, 0x61, 0x95, 0x7E, + 0xBA, 0xC5, 0x0A, 0xA2, 0x7E, 0x1F, 0x2D, 0x4E, + 0x32, 0x1E, 0xDA, 0x74, 0xFE, 0xF0, 0x33, 0x4B, + 0x24, 0xAB, 0xDE, 0xAA, 0x60, 0xB3, 0x99, 0x05, + 0x6F, 0x1D, 0x55, 0xD8, 0x63, 0xD0, 0x50, 0xA9 + }, + { + 0xAC, 0xF9, 0xDB, 0x87, 0xB9, 0x2E, 0x8C, 0xD5, + 0x79, 0xF0, 0xDC, 0xF0, 0x44, 0xB3, 0xF5, 0x28, + 0x0B, 0x09, 0x12, 0xF0, 0xF7, 0x31, 0xB8, 0xFF, + 0x42, 0x06, 0x34, 0x33, 0x0D, 0xD2, 0xD6, 0x0A, + 0x9E, 0xC0, 0xA4, 0xA2, 0x9A, 0xE7, 0xA0, 0xDB, + 0x3B, 0x83, 0xE0, 0x30, 0xE8, 0xC9, 0x8B, 0xB7, + 0x6D, 0x21, 0xB9, 0x42, 0xB8, 0x9E, 0xB5, 0xB6, + 0xB9, 0xC4, 0xF8, 0x0D, 0x46, 0x9A, 0x01, 0x13 + }, + { + 0x04, 0xAC, 0x39, 0x35, 0x77, 0x62, 0x59, 0xE2, + 0xAB, 0xE0, 0x05, 0xC6, 0x4C, 0xE2, 0x70, 0xA4, + 0xAB, 0x22, 0x43, 0xC8, 0xCA, 0xBD, 0x2F, 0xDB, + 0x7F, 0x26, 0x5C, 0x43, 0xC2, 0xDE, 0x35, 0x53, + 0xCD, 0xA5, 0xFC, 0x4C, 0x61, 0x09, 0x19, 0xA2, + 0x57, 0x0B, 0x6D, 0xC9, 0x5F, 0x07, 0x09, 0x8E, + 0xCD, 0x25, 0x77, 0xCE, 0xCC, 0x2D, 0x5C, 0xED, + 0xEE, 0x6F, 0xAD, 0x06, 0xA2, 0xA6, 0xBF, 0x5B + }, + { + 0x9C, 0xA9, 0x7D, 0xEF, 0xB4, 0x07, 0x7C, 0xA0, + 0x03, 0x5C, 0x17, 0xD8, 0x07, 0xC0, 0xF4, 0xAB, + 0x89, 0x78, 0x4B, 0xBB, 0xF0, 0x25, 0x7B, 0x74, + 0xAC, 0x1B, 0xC4, 0x33, 0xC7, 0xA2, 0x51, 0x0C, + 0x5C, 0xD7, 0x54, 0x06, 0xFF, 0x44, 0xB1, 0x2E, + 0xF3, 0xC0, 0xB6, 0x4C, 0x17, 0x5A, 0x8F, 0x48, + 0xD3, 0xAB, 0x5B, 0xA0, 0x86, 0x8B, 0xEF, 0xDB, + 0xCE, 0x26, 0x15, 0xF2, 0x1A, 0xC9, 0x6F, 0xD2 + }, + { + 0xD8, 0x86, 0xDA, 0xCC, 0xE6, 0x7C, 0x7B, 0x26, + 0x5F, 0x3C, 0x99, 0x08, 0x2C, 0xAF, 0xCB, 0xC7, + 0xE3, 0x2B, 0x2F, 0xB0, 0x93, 0x69, 0xDD, 0x6A, + 0xC9, 0xD1, 0x26, 0x4E, 0xC7, 0xBF, 0xE6, 0xA4, + 0xC8, 0xBC, 0x4A, 0xDE, 0x25, 0x9B, 0x78, 0x6C, + 0x23, 0x0A, 0xC2, 0xDE, 0x89, 0xD3, 0x81, 0x21, + 0x3B, 0x8C, 0x5D, 0xA5, 0x0D, 0xDF, 0x68, 0x2F, + 0x61, 0x87, 0x60, 0x4E, 0x89, 0x14, 0x78, 0x8B + }, + { + 0x44, 0x2D, 0xE4, 0xBE, 0x5B, 0xB9, 0xC3, 0xF9, + 0xFA, 0x65, 0xAD, 0x8C, 0x69, 0x7E, 0x46, 0xEC, + 0xA0, 0x36, 0x43, 0x8E, 0xD4, 0x90, 0xE7, 0xBD, + 0x60, 0x58, 0x80, 0x24, 0x5F, 0xAA, 0x37, 0x54, + 0xDE, 0xF3, 0x64, 0xE1, 0x4B, 0x7B, 0x1D, 0xE5, + 0x3F, 0x96, 0x5C, 0xEC, 0xAD, 0x9B, 0x94, 0xEF, + 0xCA, 0x3B, 0xBD, 0xD1, 0xC0, 0x75, 0xA0, 0x13, + 0xE1, 0x50, 0xE1, 0x16, 0x99, 0xF5, 0x66, 0x2A + }, + { + 0x88, 0xAF, 0x52, 0xEA, 0x7B, 0x45, 0x46, 0x8F, + 0x47, 0x7F, 0x0B, 0x10, 0x16, 0x45, 0xB1, 0xD6, + 0x14, 0x7D, 0x90, 0x71, 0x7C, 0x0F, 0x54, 0xC7, + 0x67, 0x3E, 0xF0, 0x17, 0xF3, 0x76, 0xD9, 0xF9, + 0x1B, 0xD6, 0x09, 0x21, 0x1B, 0x87, 0x5A, 0xFF, + 0xE0, 0x09, 0x32, 0xF3, 0x3B, 0xB1, 0x0B, 0xF9, + 0xAF, 0x44, 0x5E, 0x7D, 0x49, 0x1A, 0x96, 0xB1, + 0x2A, 0x00, 0x4A, 0x9A, 0xFD, 0x41, 0x93, 0x18 + }, + { + 0x2B, 0xDF, 0x07, 0xC1, 0x6E, 0xC2, 0xD7, 0x98, + 0xC0, 0x6F, 0xE3, 0x96, 0xF9, 0xC9, 0xED, 0x6B, + 0x95, 0x3A, 0x17, 0x0D, 0xE0, 0x8D, 0xFB, 0xCD, + 0x97, 0x3E, 0xDB, 0x1D, 0xCA, 0x16, 0xCB, 0xAC, + 0xEC, 0x03, 0xCC, 0xF5, 0x27, 0x20, 0x09, 0xF0, + 0xC7, 0x43, 0x9F, 0x38, 0xD8, 0x8A, 0x1E, 0x36, + 0xA6, 0xEE, 0x1D, 0x09, 0x0E, 0x74, 0xAD, 0x83, + 0xD6, 0x52, 0x7B, 0xFB, 0xDC, 0x32, 0xF2, 0xCC + }, + { + 0x26, 0xFD, 0x68, 0xFF, 0x57, 0x0F, 0x0C, 0xCC, + 0xFF, 0xF9, 0xD9, 0x1F, 0x31, 0xC9, 0x45, 0x2C, + 0x8F, 0x40, 0x72, 0xB3, 0x5A, 0xE9, 0x8F, 0xA5, + 0x64, 0x79, 0x6E, 0x0B, 0x4F, 0xA0, 0xD5, 0x2C, + 0xCD, 0xEE, 0xED, 0x00, 0xC4, 0x6D, 0xE4, 0xA0, + 0xFA, 0xBA, 0x02, 0x41, 0x9B, 0x01, 0x12, 0x0C, + 0xC6, 0x2A, 0xBA, 0x30, 0xC6, 0x8F, 0x63, 0x77, + 0x38, 0x6A, 0x6A, 0x74, 0xF0, 0x8F, 0x37, 0x1E + }, + { + 0x40, 0xC3, 0xB3, 0x74, 0x91, 0x49, 0xBC, 0x0C, + 0xDF, 0x8B, 0x51, 0x93, 0x4D, 0x7E, 0xB3, 0x44, + 0x4E, 0x8C, 0x7B, 0x69, 0xEC, 0xFA, 0x6B, 0x9C, + 0xA4, 0x2A, 0x5B, 0x1D, 0x79, 0x92, 0x54, 0x63, + 0xE8, 0x14, 0xC2, 0xC3, 0xB8, 0x64, 0x51, 0xFC, + 0x44, 0xA3, 0xF2, 0xC8, 0x5E, 0xE8, 0x97, 0xB8, + 0xDC, 0x3B, 0xA2, 0xA8, 0x05, 0x42, 0x47, 0x1C, + 0xD5, 0xE3, 0x1E, 0xE7, 0x67, 0x62, 0x6A, 0xD6 + }, + { + 0x8E, 0x92, 0xF5, 0xF5, 0x35, 0xF7, 0x44, 0xF9, + 0x71, 0x43, 0x0A, 0xF2, 0x30, 0x7D, 0xF0, 0x4D, + 0x2E, 0xC6, 0x86, 0x3B, 0x64, 0x65, 0x72, 0x68, + 0x96, 0x85, 0xEE, 0x75, 0x19, 0x1F, 0x51, 0xD8, + 0x05, 0x84, 0x86, 0x4A, 0xD0, 0xCC, 0xEC, 0xBB, + 0x0E, 0x40, 0x7D, 0xED, 0x1D, 0x05, 0xBE, 0x7A, + 0x6D, 0x3E, 0x62, 0x16, 0x08, 0x08, 0x0B, 0xBE, + 0x35, 0x65, 0xF9, 0x94, 0x88, 0xC9, 0xCC, 0xD7 + }, + { + 0xEB, 0xCB, 0xA4, 0xE1, 0xA3, 0x53, 0x30, 0x89, + 0xC7, 0x6F, 0x88, 0xFA, 0xF8, 0x17, 0x68, 0xD9, + 0xBC, 0xEE, 0x7D, 0x15, 0x73, 0x2C, 0xF9, 0x20, + 0xF2, 0xF1, 0x1E, 0x99, 0xC4, 0xC1, 0xE6, 0x04, + 0x20, 0x1B, 0x63, 0x15, 0x85, 0x1D, 0xC6, 0xFC, + 0x8A, 0xD2, 0x09, 0x96, 0x28, 0x31, 0x84, 0xE4, + 0xBA, 0xA1, 0x43, 0x82, 0xEF, 0x51, 0xEF, 0x78, + 0xCD, 0x34, 0xDE, 0x28, 0x8C, 0x98, 0x61, 0x06 + }, + { + 0xD1, 0x94, 0x2F, 0x1C, 0xB0, 0x3D, 0x4D, 0x60, + 0xA9, 0xE5, 0x1F, 0x52, 0xCE, 0xBC, 0x99, 0x74, + 0xBE, 0xA3, 0x00, 0xCD, 0xCA, 0x20, 0xE5, 0xE3, + 0x50, 0x21, 0x36, 0x8C, 0x0D, 0x57, 0x68, 0x92, + 0x06, 0x1F, 0xAC, 0xA2, 0x3E, 0x2A, 0xBC, 0xE7, + 0x7B, 0x72, 0xCD, 0x60, 0xE2, 0x9D, 0x70, 0x3F, + 0x71, 0x5C, 0x18, 0x37, 0x58, 0xF9, 0x2E, 0xC6, + 0x84, 0x8D, 0x58, 0xD8, 0xD4, 0x6A, 0xFD, 0x12 + }, + { + 0x33, 0x36, 0x14, 0x85, 0x31, 0x36, 0x1D, 0xC5, + 0x32, 0xF5, 0xE6, 0x75, 0x65, 0x9A, 0x22, 0x42, + 0xBE, 0x95, 0xA9, 0x7E, 0xAF, 0x1F, 0x4C, 0x83, + 0x18, 0x95, 0x90, 0x6B, 0x7D, 0xDE, 0x8C, 0xFE, + 0xC3, 0x93, 0x32, 0xC2, 0x7F, 0x72, 0x4E, 0xD3, + 0x1B, 0x24, 0x31, 0xA8, 0x6F, 0x34, 0xCA, 0x71, + 0x82, 0x98, 0x9F, 0xF8, 0x49, 0xED, 0x93, 0x4C, + 0xFE, 0xAB, 0x2B, 0xF4, 0x6D, 0x9D, 0x65, 0x9E + }, + { + 0x39, 0x8E, 0x20, 0xDC, 0x44, 0xBA, 0x8F, 0xD7, + 0xD1, 0x2E, 0xE2, 0xAE, 0x40, 0x83, 0xE4, 0xFB, + 0xD9, 0xF4, 0x50, 0x02, 0xEF, 0x3A, 0x50, 0x82, + 0xCD, 0xF0, 0x4E, 0xE3, 0x69, 0x6F, 0x2B, 0x3D, + 0xD7, 0x7D, 0x8C, 0x81, 0xD3, 0xCB, 0x01, 0xE1, + 0xCD, 0x09, 0x5D, 0x5F, 0x60, 0x26, 0xB6, 0xE5, + 0xF0, 0x6B, 0xFA, 0x89, 0x56, 0x16, 0xA5, 0x46, + 0x74, 0x96, 0xB4, 0x48, 0x0C, 0x9A, 0x89, 0x6D + }, + { + 0x8D, 0xFF, 0x9B, 0x07, 0x5E, 0x14, 0x38, 0x5A, + 0x14, 0xDA, 0xD2, 0x20, 0x4F, 0x79, 0x36, 0x2D, + 0x21, 0xD8, 0x2B, 0x0B, 0x07, 0x7A, 0x28, 0xE5, + 0xC2, 0xFC, 0x60, 0x42, 0xB6, 0xE2, 0xBB, 0x0E, + 0x24, 0x4E, 0x0A, 0x7E, 0xC5, 0x6D, 0xE0, 0x22, + 0xC7, 0x47, 0xCF, 0x68, 0xE4, 0xD9, 0x54, 0x61, + 0x84, 0x72, 0x20, 0x9C, 0x8B, 0x41, 0xA2, 0xA4, + 0xDB, 0xF0, 0xB6, 0x39, 0x18, 0x95, 0xCC, 0x2D + }, + { + 0x41, 0xC2, 0xD4, 0x66, 0xCF, 0x0D, 0x04, 0xB4, + 0xB8, 0x23, 0xB1, 0x8D, 0xB8, 0x1F, 0xBC, 0x04, + 0x6B, 0xDF, 0x00, 0x61, 0x28, 0xAE, 0xA0, 0xE6, + 0x1F, 0xB5, 0xBF, 0xED, 0x17, 0xA9, 0x58, 0xEC, + 0x84, 0xBA, 0x0E, 0x53, 0x84, 0xE1, 0xDC, 0x9A, + 0x50, 0x6F, 0xE4, 0xC5, 0x5D, 0x94, 0x78, 0xD2, + 0xBF, 0xE8, 0x8B, 0x48, 0x4A, 0x30, 0x77, 0x6D, + 0x2E, 0x37, 0xBF, 0x4C, 0xDF, 0x25, 0x51, 0x68 + }, + { + 0xA9, 0x6F, 0x60, 0x1B, 0x52, 0x64, 0xB4, 0x54, + 0xC0, 0x60, 0x51, 0x7F, 0xF8, 0xAB, 0x16, 0x4B, + 0x9F, 0x06, 0xF1, 0xCD, 0x7A, 0x4C, 0x0A, 0xF9, + 0xA9, 0x9E, 0xC1, 0xC6, 0xA9, 0xE7, 0xF5, 0x39, + 0xD1, 0xB7, 0xF9, 0x75, 0xC4, 0x8B, 0xDA, 0x5C, + 0x0B, 0x6E, 0xEA, 0xF4, 0x41, 0x41, 0x26, 0x41, + 0x7D, 0x35, 0xC8, 0x11, 0x40, 0x2E, 0xC8, 0x24, + 0xEA, 0x43, 0xE6, 0x20, 0x33, 0x2F, 0x49, 0xF0 + }, + { + 0xD0, 0xF1, 0x8A, 0xE8, 0x4A, 0x49, 0xA4, 0x7C, + 0x07, 0x3C, 0x9E, 0xDB, 0x52, 0x4B, 0x91, 0x2B, + 0x5D, 0xDB, 0xC7, 0x3F, 0x6F, 0x4C, 0x76, 0x2E, + 0xFD, 0xDA, 0x30, 0x98, 0xCE, 0x35, 0x2A, 0x50, + 0xE8, 0x25, 0x36, 0x89, 0xF8, 0x6E, 0xED, 0x09, + 0x40, 0x8C, 0x75, 0xF3, 0xF8, 0xCE, 0x17, 0x4B, + 0xD8, 0x13, 0x41, 0x09, 0xE2, 0x44, 0x2D, 0x40, + 0x68, 0xF7, 0xFE, 0x37, 0x5D, 0xCC, 0x9B, 0x51 + }, + { + 0x08, 0x94, 0xEC, 0x36, 0x4A, 0x18, 0x9B, 0xD8, + 0x53, 0xA1, 0x20, 0x78, 0xCE, 0x26, 0xD2, 0xA3, + 0xF0, 0xF4, 0x71, 0x8A, 0x00, 0x6A, 0x13, 0xBD, + 0xF4, 0xAE, 0x2F, 0x25, 0xB0, 0x60, 0x8C, 0x85, + 0x85, 0x8D, 0x80, 0x5C, 0xE4, 0x4A, 0xCB, 0x07, + 0x42, 0xC2, 0x46, 0xC3, 0x80, 0xDF, 0x8C, 0x1C, + 0x5E, 0x21, 0x44, 0x6E, 0x52, 0xEA, 0x40, 0x04, + 0xB2, 0x54, 0x8E, 0x26, 0xD5, 0xF1, 0x56, 0xA8 + }, + { + 0xA9, 0x83, 0x1A, 0xC7, 0x13, 0xC1, 0x93, 0xE7, + 0x7C, 0x86, 0x18, 0xE6, 0xF9, 0xEC, 0x2D, 0xEC, + 0xF7, 0x21, 0xBE, 0xD9, 0x23, 0x4E, 0xB8, 0x80, + 0xB7, 0xA8, 0x33, 0xD3, 0xE7, 0x35, 0x15, 0x38, + 0x12, 0x13, 0x94, 0x92, 0x1F, 0xF0, 0xA9, 0xDA, + 0xE0, 0xBB, 0x89, 0x72, 0x42, 0x9F, 0x89, 0xA7, + 0xE7, 0x14, 0xAA, 0x55, 0x56, 0x20, 0x36, 0x3C, + 0xBE, 0x80, 0x31, 0x37, 0xA4, 0x90, 0x0B, 0x21 + }, + { + 0x06, 0x14, 0x5E, 0x9B, 0xA9, 0x72, 0x5B, 0x1E, + 0xF9, 0x51, 0x06, 0x64, 0xE5, 0xD4, 0x1F, 0xEA, + 0x2C, 0x88, 0xF3, 0xC5, 0xDD, 0x89, 0x7C, 0x2D, + 0xF8, 0x55, 0x03, 0x0B, 0x3E, 0xB6, 0x08, 0xDA, + 0x4A, 0xB5, 0x44, 0x13, 0x37, 0x00, 0x64, 0xD6, + 0xEB, 0x09, 0x0E, 0xE6, 0x81, 0x82, 0x16, 0x3D, + 0xF2, 0xF6, 0xB8, 0x83, 0x76, 0xDC, 0xA7, 0x42, + 0x68, 0x4C, 0xF2, 0xA5, 0xCB, 0x7F, 0xB2, 0xBB + }, + { + 0x86, 0x06, 0x0D, 0xDD, 0xBA, 0x30, 0x37, 0x39, + 0x21, 0x4F, 0x9B, 0x26, 0x49, 0x49, 0x39, 0x74, + 0x2D, 0xF5, 0x12, 0x7E, 0x7B, 0x05, 0x1A, 0x16, + 0xE9, 0xA5, 0x64, 0x24, 0x8E, 0x3A, 0xF5, 0xEF, + 0x4C, 0x8D, 0xA5, 0x27, 0x8A, 0xB4, 0xE2, 0x10, + 0x34, 0x76, 0x84, 0xA4, 0xCE, 0xFB, 0x5B, 0x97, + 0x8A, 0x95, 0xDD, 0xD9, 0xB1, 0xE1, 0x94, 0x45, + 0x66, 0x5B, 0xEA, 0xF5, 0x20, 0x3E, 0x94, 0x92 + }, + { + 0xA4, 0x78, 0xC0, 0xD4, 0x68, 0xFB, 0xB6, 0x7E, + 0x98, 0x37, 0x1F, 0x71, 0xB0, 0x51, 0x80, 0x22, + 0x31, 0x31, 0xC1, 0xA7, 0xA6, 0xE2, 0xB7, 0x81, + 0x15, 0xA2, 0x5B, 0xD7, 0x6E, 0x8A, 0x97, 0x48, + 0x2F, 0x5F, 0x1E, 0x16, 0x54, 0x75, 0xFA, 0xB7, + 0xDE, 0x91, 0x80, 0xAE, 0xDE, 0xBD, 0xE3, 0xC5, + 0xD1, 0x6D, 0x53, 0x7C, 0x07, 0x9C, 0x2E, 0x19, + 0x98, 0xDB, 0x61, 0x67, 0x4D, 0xDD, 0x0A, 0x19 + }, + { + 0xE5, 0x77, 0xB5, 0x75, 0x87, 0x38, 0xCD, 0x35, + 0x77, 0x20, 0x85, 0x17, 0xEB, 0xDA, 0x66, 0x39, + 0x3A, 0x91, 0x5E, 0x5F, 0xE6, 0xF0, 0xEA, 0xD3, + 0xCF, 0xDF, 0xF6, 0xC4, 0x1F, 0xD3, 0x7F, 0xDD, + 0x72, 0xB8, 0xCA, 0x9F, 0x12, 0xF1, 0xF3, 0xEA, + 0x1D, 0x1F, 0x34, 0x88, 0x06, 0xC2, 0x18, 0x26, + 0xC2, 0x13, 0x85, 0x31, 0x27, 0x5B, 0x99, 0x68, + 0x7D, 0x8E, 0x45, 0x1C, 0x24, 0x31, 0x41, 0x8A + }, + { + 0xEB, 0x17, 0x93, 0x19, 0xBD, 0x6D, 0x81, 0x0B, + 0x3C, 0xAC, 0x5F, 0x82, 0x6D, 0xD5, 0x8B, 0x02, + 0x23, 0x65, 0xDE, 0x63, 0x71, 0x6D, 0x75, 0xA5, + 0xA0, 0x10, 0x4A, 0x8B, 0xDC, 0xBC, 0xEC, 0x7B, + 0xE8, 0xCF, 0x12, 0xC5, 0x3B, 0x6F, 0x16, 0x82, + 0x51, 0xAD, 0x02, 0x96, 0xAE, 0x2D, 0xEC, 0x06, + 0x94, 0xB5, 0x83, 0xF1, 0xC0, 0xB2, 0xAF, 0x01, + 0x56, 0x05, 0x5C, 0x9D, 0x5E, 0x32, 0xCE, 0xBE + }, + { + 0x52, 0x0F, 0x41, 0xCF, 0x79, 0x91, 0x64, 0xF3, + 0x14, 0xAE, 0x87, 0x64, 0xB1, 0x48, 0xEF, 0xF0, + 0x04, 0xDC, 0x33, 0xDF, 0x6A, 0x4D, 0x8E, 0xF9, + 0xB9, 0xAE, 0x03, 0xE8, 0xBB, 0x04, 0x51, 0x55, + 0x4A, 0xD5, 0x4C, 0x44, 0xAC, 0x5D, 0xCC, 0xA8, + 0x29, 0x47, 0x79, 0xD0, 0xF7, 0x47, 0xB6, 0x33, + 0xF0, 0x70, 0x91, 0x45, 0x28, 0x7D, 0xA9, 0xE1, + 0xEC, 0x94, 0xC5, 0x50, 0x4C, 0x27, 0xD9, 0x85 + }, + { + 0x57, 0xC5, 0xB3, 0xB1, 0x3D, 0x24, 0x0D, 0x84, + 0x8C, 0xD3, 0x54, 0xAD, 0x1C, 0xDD, 0xB1, 0x1E, + 0xD5, 0x0D, 0xC2, 0xD6, 0x15, 0xEB, 0x4E, 0xBD, + 0xB4, 0x09, 0xCD, 0x4D, 0x44, 0xD6, 0xEF, 0xAC, + 0xC2, 0xDA, 0x07, 0x72, 0xEF, 0x64, 0x65, 0x66, + 0xA5, 0x1E, 0x44, 0x19, 0xF7, 0x04, 0xE1, 0xDF, + 0xF1, 0x9D, 0xF6, 0x82, 0xC9, 0x92, 0x6C, 0xD9, + 0x01, 0xEF, 0x2C, 0x76, 0xFC, 0x5A, 0xF4, 0x91 + }, + { + 0xD4, 0xF9, 0x01, 0xE9, 0x5F, 0x41, 0xCD, 0xCB, + 0xF1, 0x65, 0x0C, 0x29, 0x0F, 0xF1, 0x03, 0x89, + 0x2C, 0x82, 0x78, 0xAB, 0x4B, 0x8E, 0xEF, 0x38, + 0x13, 0xDC, 0x81, 0x17, 0x07, 0x03, 0x41, 0x89, + 0xD8, 0xE4, 0xD3, 0x72, 0xF9, 0xC3, 0x6B, 0x03, + 0x8E, 0xCA, 0x96, 0x7E, 0x21, 0xD2, 0xF1, 0x35, + 0x4C, 0x07, 0xFD, 0x4D, 0x57, 0xD0, 0x5A, 0xA1, + 0x4F, 0x2D, 0x3E, 0xE4, 0xAA, 0x2F, 0xDB, 0x86 + }, + { + 0xF7, 0xB6, 0xFD, 0xEC, 0xE0, 0xC3, 0xED, 0x83, + 0x17, 0xB0, 0x6F, 0xE4, 0xE9, 0x33, 0x26, 0x3D, + 0x94, 0x71, 0xB8, 0x1C, 0x93, 0x3B, 0x61, 0xED, + 0xB4, 0x9B, 0xB9, 0x95, 0xF1, 0x0E, 0xBC, 0x62, + 0x5D, 0xD2, 0x33, 0xB1, 0x52, 0x67, 0xBA, 0xE2, + 0xCA, 0xAD, 0x3E, 0x42, 0x68, 0x3B, 0x08, 0x6B, + 0x65, 0xC5, 0x81, 0xC0, 0xC0, 0x09, 0x08, 0x46, + 0x4A, 0x17, 0x49, 0x60, 0xF0, 0xCB, 0xF5, 0x7B + }, + { + 0x7B, 0x75, 0xAC, 0xBE, 0x87, 0x61, 0xF6, 0x58, + 0x9A, 0xAA, 0x23, 0x50, 0x25, 0xE9, 0xBD, 0xE9, + 0x40, 0x52, 0xDB, 0x0E, 0x05, 0x7D, 0xE2, 0x8A, + 0x3C, 0x9A, 0x22, 0xFD, 0xD2, 0xE5, 0x4B, 0xA9, + 0x68, 0xEC, 0x38, 0xEC, 0xA9, 0xD3, 0x7C, 0xE0, + 0xAE, 0x57, 0x06, 0xF7, 0x85, 0x8D, 0x7D, 0xAA, + 0xF3, 0x61, 0x27, 0x65, 0x52, 0x5D, 0x71, 0x04, + 0xAD, 0x7B, 0x20, 0x59, 0x89, 0xFC, 0x12, 0xD8 + }, + { + 0x71, 0xC0, 0xE3, 0xDC, 0x35, 0xDA, 0xB4, 0xED, + 0x59, 0x21, 0x5C, 0xE8, 0x97, 0x1C, 0xC9, 0x47, + 0xF4, 0xCD, 0x27, 0xD5, 0xEE, 0x2E, 0x95, 0x10, + 0x1E, 0x14, 0x15, 0xBF, 0x52, 0x45, 0xE4, 0xA0, + 0xFB, 0xA9, 0xFF, 0x5F, 0xFB, 0x42, 0x3A, 0x78, + 0x77, 0xC3, 0xC7, 0xDB, 0x66, 0xDF, 0x1E, 0xC1, + 0xE5, 0x4B, 0xF0, 0x12, 0x48, 0x35, 0x16, 0x84, + 0x05, 0x3F, 0xC1, 0xB0, 0xDF, 0xC6, 0xE6, 0x7B + }, + { + 0x15, 0xDC, 0x98, 0x89, 0x3E, 0x4A, 0xF4, 0xE4, + 0x9D, 0xA7, 0x02, 0xA2, 0xB5, 0x2D, 0x1D, 0xDD, + 0xAC, 0xB3, 0x0F, 0xB8, 0x0B, 0x8A, 0x44, 0x8F, + 0xC0, 0x70, 0xFF, 0x7E, 0x7A, 0x71, 0x22, 0x66, + 0x47, 0xAE, 0x66, 0xEF, 0xCF, 0x92, 0x49, 0x41, + 0x30, 0x5F, 0xA3, 0x75, 0x77, 0xE2, 0xBE, 0x5A, + 0x06, 0x1B, 0x07, 0x10, 0xF6, 0x01, 0x4B, 0xEA, + 0x91, 0x63, 0xB3, 0xCD, 0x46, 0x9D, 0x16, 0x88 + }, + { + 0xEA, 0xF9, 0x83, 0x6F, 0xA3, 0xC8, 0xE1, 0xB7, + 0xD5, 0x51, 0x7C, 0xA7, 0xD0, 0xB9, 0x32, 0x84, + 0x92, 0x2A, 0x8B, 0xF0, 0x9F, 0xF4, 0xAF, 0x70, + 0x05, 0x44, 0x4C, 0xCE, 0x48, 0xE2, 0x96, 0x9D, + 0xF4, 0x09, 0x6C, 0xA5, 0x79, 0x34, 0x5E, 0x49, + 0xAC, 0x10, 0xFA, 0x78, 0x7A, 0x19, 0x08, 0xE8, + 0x49, 0xCF, 0xA0, 0x7A, 0x65, 0xFE, 0x18, 0x87, + 0xD6, 0xCE, 0xA6, 0x65, 0xDB, 0xE1, 0x9B, 0x75 + }, + { + 0x04, 0x69, 0x0D, 0x54, 0x9F, 0x55, 0x82, 0x89, + 0x91, 0x21, 0x5B, 0xD5, 0x60, 0xB9, 0x88, 0x6E, + 0xE7, 0xC4, 0xBA, 0xF6, 0x55, 0x32, 0xD4, 0x78, + 0x6F, 0x8A, 0x50, 0xEB, 0x5C, 0x2F, 0x38, 0x10, + 0xC2, 0x85, 0xB7, 0xEA, 0x31, 0xE3, 0xBC, 0xE3, + 0x32, 0x39, 0xC8, 0x7D, 0x37, 0x4E, 0xEB, 0xCC, + 0xA1, 0xDE, 0x0F, 0x8B, 0xD7, 0x72, 0x23, 0x87, + 0x42, 0x54, 0x07, 0xDB, 0x5B, 0x62, 0x1A, 0x18 + }, + { + 0x27, 0x2F, 0x1B, 0x34, 0xAF, 0x8B, 0x45, 0xB8, + 0x23, 0xE1, 0x07, 0x3A, 0xAD, 0xD2, 0x35, 0xF5, + 0xF0, 0x2D, 0x77, 0xFC, 0x81, 0x43, 0x14, 0xEE, + 0xD8, 0x6A, 0x31, 0x9B, 0x56, 0x92, 0x02, 0xB1, + 0x91, 0x1D, 0x8E, 0xEE, 0x37, 0x85, 0xD1, 0x92, + 0x55, 0x60, 0xAF, 0x6F, 0x38, 0x6D, 0x2D, 0xE1, + 0x7C, 0xC6, 0x4A, 0x98, 0xBC, 0x24, 0x98, 0xCC, + 0x15, 0xDD, 0x74, 0xE3, 0x81, 0xDC, 0x53, 0xA4 + }, + { + 0x44, 0x9A, 0xCF, 0x45, 0x1A, 0x4D, 0x44, 0x29, + 0x56, 0xC6, 0xD6, 0x4C, 0x9B, 0x7A, 0x8C, 0x9C, + 0x5B, 0xD7, 0xEC, 0xC4, 0x95, 0xDC, 0xB7, 0x93, + 0x1B, 0x6C, 0xE4, 0xE3, 0xF5, 0x9B, 0xA5, 0x48, + 0xFC, 0xF8, 0xBD, 0xBB, 0x3B, 0x44, 0x37, 0x85, + 0xB2, 0x59, 0x37, 0xC0, 0xF7, 0x7D, 0x6E, 0x54, + 0xE0, 0xC2, 0x62, 0x29, 0xFA, 0xCE, 0xAE, 0xCF, + 0x2A, 0x3D, 0x0F, 0x17, 0x46, 0xAA, 0x5E, 0x9E + }, + { + 0x4E, 0x10, 0xF4, 0x2B, 0x18, 0xF8, 0xB7, 0xF6, + 0xF0, 0xB9, 0x03, 0x3B, 0x5D, 0x01, 0x80, 0x78, + 0xBB, 0x13, 0x06, 0x8C, 0x51, 0x8A, 0xB5, 0x9B, + 0xB7, 0x16, 0xE2, 0x8C, 0x7E, 0x9B, 0xD3, 0xC1, + 0xCA, 0xB7, 0x6A, 0x13, 0x1C, 0xB1, 0x0C, 0xAC, + 0x66, 0x3F, 0x4C, 0xCE, 0x1D, 0x50, 0xB7, 0x30, + 0x23, 0xCF, 0xA1, 0xDF, 0x3F, 0xC5, 0x84, 0x08, + 0x0E, 0x2F, 0xBB, 0x1D, 0xC6, 0x90, 0x50, 0xD5 + }, + { + 0x79, 0x6C, 0x50, 0xE2, 0x08, 0x07, 0x09, 0x6A, + 0x44, 0x9B, 0xDF, 0x77, 0x9F, 0xF8, 0x02, 0x4D, + 0x04, 0x0C, 0x9A, 0xFB, 0x6E, 0x65, 0x3E, 0x8E, + 0xC6, 0x12, 0xA0, 0xF0, 0x44, 0x6C, 0x40, 0x6E, + 0x38, 0xDC, 0x21, 0x44, 0x60, 0x48, 0x54, 0xD1, + 0x0A, 0x88, 0xCD, 0x50, 0xAB, 0x6D, 0x41, 0x0F, + 0x5B, 0x63, 0x86, 0x85, 0x2B, 0xD1, 0x3C, 0x34, + 0x1B, 0x5B, 0x7C, 0xF4, 0xDC, 0xB3, 0xAD, 0xA2 + }, + { + 0xCA, 0x3C, 0xC6, 0xE2, 0x5E, 0x90, 0x62, 0xEF, + 0xA8, 0xEC, 0xAB, 0x97, 0x7E, 0x85, 0x41, 0x79, + 0x55, 0x4F, 0x8A, 0x92, 0x5E, 0xA4, 0x53, 0xF2, + 0x75, 0x9B, 0xEA, 0x49, 0x69, 0x64, 0x10, 0x89, + 0x09, 0x3C, 0x38, 0xB6, 0x42, 0x43, 0x70, 0x7A, + 0x02, 0x78, 0xBD, 0x0F, 0x45, 0xF5, 0x04, 0x7E, + 0x5D, 0x18, 0xB0, 0x46, 0xD8, 0x5F, 0x12, 0x18, + 0x78, 0x03, 0x74, 0xBE, 0x6A, 0x66, 0x5E, 0x10 + }, + { + 0x7D, 0x8E, 0x9D, 0xE8, 0xC3, 0xC3, 0xFE, 0x51, + 0x9C, 0x9E, 0x5C, 0xCA, 0xC9, 0x30, 0x71, 0x65, + 0x59, 0x83, 0xEB, 0x92, 0x65, 0xFD, 0xE8, 0x35, + 0x1D, 0x25, 0x8F, 0x9F, 0x71, 0x94, 0x68, 0xB8, + 0xDA, 0x6B, 0x9F, 0xE0, 0x1B, 0x1D, 0xEF, 0x2C, + 0x97, 0x26, 0x1E, 0xF2, 0xB0, 0x12, 0x03, 0xD0, + 0xDE, 0xDB, 0xF3, 0xD2, 0x51, 0xE5, 0x4B, 0x2A, + 0x9B, 0x4B, 0x05, 0xAE, 0x21, 0xD1, 0x27, 0xBB + }, + { + 0x97, 0x3D, 0x8A, 0xF5, 0xDA, 0x37, 0x90, 0xD2, + 0xDD, 0x2C, 0xA4, 0x66, 0x74, 0xBD, 0x22, 0x44, + 0x3A, 0x9C, 0x3E, 0xDE, 0x81, 0xFF, 0xE6, 0x73, + 0x13, 0xD5, 0xAB, 0xA5, 0x15, 0xED, 0x43, 0x0A, + 0x35, 0x1B, 0x5E, 0x3D, 0x4B, 0x29, 0xCC, 0x8F, + 0x6F, 0x20, 0x05, 0x38, 0x28, 0x63, 0x82, 0xA1, + 0x4C, 0x2F, 0xBD, 0xAF, 0xCA, 0xFE, 0x97, 0x2E, + 0x44, 0x65, 0x65, 0x20, 0x6D, 0xF4, 0x1F, 0x00 + }, + { + 0x63, 0x67, 0xCC, 0x6B, 0xEC, 0x31, 0xDD, 0x3B, + 0x11, 0xF5, 0xA5, 0x16, 0xE3, 0x94, 0x0C, 0xFA, + 0x8E, 0x51, 0x49, 0x0B, 0x8A, 0x04, 0xAC, 0x2C, + 0x9C, 0xEF, 0x56, 0xF7, 0x94, 0x7B, 0x8E, 0x5C, + 0x4B, 0x23, 0x19, 0xE3, 0xDE, 0xF2, 0x86, 0x3C, + 0x55, 0x0E, 0x54, 0xF3, 0x82, 0x7F, 0xD1, 0x5B, + 0xE1, 0x6D, 0x4B, 0x3C, 0x1E, 0x5B, 0x50, 0x80, + 0x40, 0x4A, 0xAF, 0xC8, 0x33, 0x6E, 0x96, 0x21 + }, + { + 0xFE, 0x85, 0x11, 0x7D, 0x9D, 0xA9, 0xFB, 0x86, + 0xFB, 0xEC, 0xC1, 0x17, 0xD9, 0x36, 0x7B, 0xC3, + 0x03, 0xC0, 0x5A, 0x5E, 0x99, 0xCA, 0x92, 0x58, + 0xAD, 0x64, 0x3C, 0xFF, 0xA4, 0x06, 0x8C, 0x2A, + 0x83, 0xE3, 0x92, 0x28, 0x78, 0x71, 0xE1, 0x24, + 0x72, 0x1A, 0x2C, 0xC8, 0x7A, 0x89, 0xD6, 0x46, + 0xDF, 0x05, 0xD6, 0xF1, 0x18, 0xF9, 0x22, 0x4B, + 0x74, 0xE2, 0x14, 0x96, 0xE1, 0xA6, 0xBD, 0xF8 + }, + { + 0x82, 0x6C, 0x97, 0xDC, 0xBB, 0x75, 0x53, 0x8A, + 0x49, 0xBC, 0x91, 0x72, 0xAD, 0xAA, 0x64, 0xD7, + 0x3E, 0x51, 0x2A, 0xDE, 0x3A, 0x2A, 0x0E, 0x4E, + 0x20, 0x71, 0xDA, 0x1B, 0x89, 0x6E, 0x37, 0xB9, + 0xC7, 0xB5, 0x20, 0xE6, 0x40, 0x85, 0x59, 0xA8, + 0x15, 0x8E, 0x5E, 0xE3, 0xB4, 0xB7, 0x87, 0x15, + 0x0E, 0xA8, 0x25, 0xDE, 0xCB, 0xF9, 0xBE, 0xEF, + 0x77, 0x32, 0x05, 0xFF, 0xF5, 0xCD, 0x40, 0x41 + }, + { + 0xBA, 0x8F, 0x8F, 0xFE, 0xF2, 0xD3, 0x5C, 0x24, + 0x7C, 0x7C, 0xAA, 0x0B, 0x66, 0xDD, 0x5C, 0xA7, + 0xBA, 0xBC, 0x8F, 0x4C, 0xF2, 0x79, 0xF4, 0x37, + 0xF5, 0xA4, 0x1E, 0x65, 0x41, 0x43, 0xDC, 0x5C, + 0x13, 0x92, 0xFF, 0x67, 0x9E, 0x8D, 0xEA, 0x15, + 0xF1, 0x57, 0x03, 0x03, 0x05, 0x55, 0xC4, 0xB4, + 0xB9, 0x62, 0x0A, 0x59, 0x07, 0x3A, 0xB4, 0xF1, + 0x38, 0x71, 0xE3, 0xDB, 0x77, 0x4E, 0x89, 0xB5 + }, + { + 0xC7, 0x50, 0xB2, 0x95, 0x3B, 0xCE, 0x33, 0x47, + 0xFD, 0xD2, 0xEA, 0x86, 0x21, 0x2F, 0xA5, 0x7A, + 0x9A, 0x63, 0xC6, 0x7E, 0x94, 0xA0, 0xD4, 0xD2, + 0xAC, 0x7A, 0x36, 0xD3, 0xB9, 0x91, 0xFB, 0x42, + 0x92, 0x41, 0xD3, 0x06, 0x63, 0x0A, 0x4E, 0xA5, + 0x9E, 0xC6, 0x0C, 0xB8, 0x5B, 0x9B, 0xAB, 0x00, + 0x77, 0xFD, 0xC5, 0x0A, 0xF0, 0xFD, 0xBF, 0x88, + 0xD4, 0xCC, 0x0B, 0x9B, 0x23, 0x5B, 0x1E, 0x88 + }, + { + 0x06, 0x8A, 0xCB, 0xE4, 0x83, 0x5D, 0xC6, 0xD1, + 0x4C, 0xDA, 0x9D, 0xE4, 0xAC, 0xE8, 0x96, 0x16, + 0x37, 0x99, 0x16, 0x0A, 0x91, 0x5D, 0xC8, 0xB2, + 0xFC, 0x67, 0xA5, 0x72, 0xB8, 0x94, 0xE0, 0xDC, + 0xE7, 0x86, 0x8F, 0x94, 0x25, 0xE9, 0x04, 0x92, + 0xBC, 0xDE, 0x3E, 0x3B, 0x38, 0x81, 0xC4, 0x0A, + 0x8D, 0x04, 0x74, 0xDA, 0x9A, 0x83, 0xBE, 0x4F, + 0x80, 0xD2, 0x06, 0xA7, 0x56, 0x9A, 0xAB, 0x81 + }, + { + 0x0F, 0xFC, 0xFD, 0xEC, 0xEE, 0x01, 0x3C, 0xC1, + 0x02, 0xC0, 0x01, 0xD5, 0xDC, 0x8B, 0xDE, 0xB3, + 0x17, 0xF3, 0x83, 0x70, 0xC0, 0xA1, 0x92, 0xD6, + 0xE9, 0x77, 0x34, 0x45, 0x42, 0x0A, 0x64, 0x9A, + 0x6C, 0xD9, 0x7D, 0x9A, 0x8E, 0xE6, 0x8E, 0x9C, + 0xB0, 0x8D, 0xE0, 0xEC, 0x60, 0x8E, 0x47, 0x0D, + 0xD1, 0x5E, 0xE1, 0x7E, 0x6F, 0xEA, 0xA7, 0x9C, + 0x4D, 0xDD, 0xA4, 0xBE, 0xDC, 0x17, 0xF6, 0x19 + }, + { + 0xB9, 0x03, 0xC1, 0xC5, 0x01, 0x14, 0x97, 0xD3, + 0xDB, 0xF3, 0x9E, 0xC7, 0xA7, 0x76, 0xFC, 0x21, + 0x37, 0x76, 0x09, 0xFF, 0x23, 0x65, 0x45, 0xE1, + 0xAE, 0x2E, 0xBB, 0x40, 0xAA, 0x44, 0xCE, 0xBB, + 0x09, 0xE1, 0xD6, 0x17, 0xC0, 0x1A, 0x01, 0x90, + 0xC5, 0xCD, 0x71, 0xA6, 0x9F, 0x7B, 0xA7, 0x12, + 0xD0, 0x19, 0x1C, 0x28, 0x55, 0x18, 0xF9, 0xE5, + 0x8C, 0x7B, 0x61, 0xC7, 0x30, 0xA9, 0x12, 0xB6 + }, + { + 0x25, 0x83, 0x19, 0xB3, 0x6D, 0x67, 0x4B, 0xC3, + 0xDB, 0x5F, 0xED, 0x42, 0x6A, 0x00, 0x1B, 0xE6, + 0x7E, 0x68, 0x32, 0x65, 0xDD, 0x0B, 0x3B, 0x74, + 0xA3, 0xA7, 0x0B, 0xA8, 0x2E, 0x60, 0xF5, 0x96, + 0x10, 0x3F, 0x2D, 0x70, 0x9E, 0xA0, 0x9B, 0x84, + 0xB8, 0xEA, 0x64, 0x18, 0xB3, 0x57, 0xB8, 0xDD, + 0x3D, 0x2A, 0x8D, 0x37, 0xA7, 0xCA, 0x5E, 0x58, + 0x2C, 0xE8, 0xB2, 0x2D, 0x94, 0xC9, 0x53, 0x8F + }, + { + 0xF5, 0x29, 0xDC, 0x35, 0x59, 0xD4, 0xA5, 0x40, + 0xAE, 0xC2, 0xDE, 0xEB, 0xC2, 0xBF, 0xA9, 0x3F, + 0x3E, 0x44, 0xEA, 0x12, 0x93, 0xA9, 0xE1, 0x99, + 0xD7, 0xA7, 0xF1, 0x60, 0x0F, 0x66, 0x98, 0x2D, + 0xF4, 0x6A, 0x32, 0xF6, 0xD9, 0xEF, 0x1F, 0x22, + 0x76, 0x1F, 0xE4, 0x40, 0x4C, 0x6C, 0x5E, 0x95, + 0x00, 0x48, 0x3D, 0x31, 0xA3, 0x7D, 0x3E, 0xDA, + 0x79, 0x5A, 0x59, 0xE6, 0xC5, 0x38, 0x3E, 0x39 + }, + { + 0x6D, 0xF6, 0x20, 0x9C, 0xB1, 0xF1, 0x7F, 0xBA, + 0xCE, 0xA6, 0x9A, 0xC9, 0x8F, 0x2D, 0xBD, 0x12, + 0xB7, 0xA8, 0x5C, 0x23, 0x31, 0x92, 0x98, 0x87, + 0x34, 0x2B, 0x0D, 0x5F, 0x5D, 0xC0, 0xFA, 0x3A, + 0x55, 0x9D, 0x8B, 0xC0, 0xF4, 0xFB, 0xCA, 0xD9, + 0xAC, 0x3D, 0x9F, 0x6F, 0x02, 0x95, 0xFE, 0xDF, + 0x89, 0x61, 0x2B, 0x08, 0x8F, 0x30, 0xDE, 0xD9, + 0x46, 0x6F, 0xEF, 0x38, 0xC8, 0x30, 0x6F, 0x17 + }, + { + 0xA1, 0xEE, 0xE1, 0x9E, 0x27, 0x38, 0x05, 0x5F, + 0x08, 0x63, 0x5F, 0x32, 0xAA, 0xB4, 0xC4, 0x6B, + 0x11, 0x95, 0x62, 0xA4, 0xCD, 0x0E, 0x8B, 0x83, + 0x3D, 0x99, 0x15, 0xBB, 0x5D, 0x0F, 0xE9, 0x36, + 0xF4, 0x07, 0x5E, 0x09, 0xF8, 0x55, 0xE6, 0x9B, + 0x03, 0xD4, 0x29, 0xA3, 0x49, 0x0E, 0xC5, 0x62, + 0xB9, 0xC9, 0x8C, 0xEA, 0xA5, 0x64, 0x05, 0x2D, + 0x1E, 0x8F, 0x6F, 0x63, 0xAF, 0xE7, 0x57, 0x9D + }, + { + 0x5D, 0x83, 0x9E, 0xA8, 0xAE, 0x15, 0x2B, 0xA9, + 0xF2, 0x56, 0x82, 0x91, 0x5E, 0x47, 0x67, 0xD3, + 0xF4, 0x60, 0x3A, 0xA0, 0xBF, 0x12, 0xA1, 0x3C, + 0xF9, 0x27, 0x8A, 0xC0, 0x69, 0xA5, 0xEB, 0x6C, + 0xA1, 0x8A, 0xAE, 0x3D, 0x47, 0x87, 0x8C, 0x4C, + 0x17, 0x87, 0x21, 0xC6, 0xDA, 0xBE, 0xAE, 0x0F, + 0x3B, 0x5E, 0xEC, 0x4F, 0x15, 0xA7, 0x0B, 0xD7, + 0x21, 0x68, 0x9C, 0x88, 0xCC, 0xDD, 0x5F, 0x7C + }, + { + 0x1A, 0xF4, 0x05, 0xCD, 0x3B, 0xB7, 0xDF, 0x22, + 0xDA, 0xEE, 0x8F, 0xEF, 0x8E, 0xFE, 0x38, 0xD7, + 0xD2, 0xE2, 0x7E, 0xE2, 0xCF, 0xB0, 0xB6, 0x97, + 0x50, 0x33, 0xF3, 0x40, 0xC6, 0x4C, 0x80, 0x63, + 0xA5, 0x74, 0xBA, 0x73, 0x57, 0x7A, 0xA8, 0xAD, + 0xBB, 0xA5, 0x5E, 0xCF, 0xDD, 0xBB, 0x7E, 0x89, + 0x4E, 0x56, 0x3E, 0xB2, 0x9C, 0xFD, 0x65, 0x6C, + 0xC3, 0x94, 0xBC, 0x47, 0xE1, 0x9D, 0x99, 0x3F + }, + { + 0x79, 0xD1, 0x7C, 0x6E, 0x86, 0x63, 0x92, 0x59, + 0x46, 0xC1, 0x88, 0xC7, 0xAF, 0xE7, 0x38, 0x0F, + 0xF5, 0x7F, 0x86, 0x1E, 0x45, 0xCE, 0xFD, 0x1C, + 0x9E, 0xDE, 0x0F, 0x16, 0x51, 0xE1, 0x42, 0xC2, + 0x2D, 0xFC, 0x5E, 0x69, 0xE5, 0xD0, 0x83, 0x01, + 0xAD, 0x8B, 0x17, 0x43, 0x40, 0x28, 0x1C, 0x43, + 0x77, 0xA2, 0x9B, 0x9C, 0xE9, 0x9B, 0xDF, 0x57, + 0x68, 0xB4, 0xDB, 0xD6, 0xFB, 0x61, 0x46, 0x19 + }, + { + 0x33, 0x63, 0x71, 0x61, 0x3A, 0x59, 0x00, 0xC6, + 0x51, 0x62, 0xB5, 0xE0, 0x02, 0x96, 0xF7, 0x67, + 0x69, 0x11, 0x80, 0x4B, 0x86, 0x39, 0x79, 0xA2, + 0xA5, 0xCC, 0xAA, 0x20, 0xD0, 0x66, 0x86, 0x32, + 0xCE, 0x19, 0x82, 0xA0, 0x27, 0xCB, 0xBE, 0x04, + 0x88, 0xC5, 0x15, 0x7B, 0x65, 0x3B, 0xC3, 0xF9, + 0xB7, 0x9B, 0xD4, 0x4D, 0xBF, 0xDA, 0x47, 0xC5, + 0xE5, 0x8F, 0x85, 0xC0, 0x19, 0xEA, 0x78, 0x44 + }, + { + 0xCA, 0xAD, 0xD5, 0xAD, 0x8B, 0xAE, 0x3F, 0xD4, + 0x87, 0x22, 0x9A, 0xDA, 0xBE, 0x7C, 0x1D, 0xC8, + 0xE3, 0x32, 0xBF, 0xB9, 0x53, 0xCC, 0xC5, 0xDF, + 0xCB, 0x7D, 0x8F, 0x96, 0x85, 0xB5, 0x1F, 0xCB, + 0xBD, 0x27, 0x31, 0x5A, 0x8D, 0x8D, 0x78, 0x5A, + 0xA8, 0x90, 0x00, 0xEA, 0x88, 0x9F, 0xD2, 0xDE, + 0xAC, 0xB2, 0x28, 0xEC, 0x3D, 0x09, 0x03, 0xE4, + 0x12, 0x78, 0x43, 0x26, 0x02, 0x32, 0x31, 0x98 + }, + { + 0x38, 0xEC, 0x52, 0x40, 0xD9, 0x38, 0x8C, 0x9F, + 0x49, 0x1A, 0x9F, 0xD0, 0x8A, 0x38, 0xFD, 0x4E, + 0x51, 0xBD, 0xA1, 0xBC, 0x85, 0x67, 0x00, 0x29, + 0x3B, 0x0A, 0x8E, 0x83, 0xEF, 0xD6, 0x63, 0x47, + 0x1C, 0x81, 0x56, 0x4A, 0x95, 0x0F, 0x96, 0x82, + 0xA0, 0xFF, 0xA2, 0xA3, 0xAC, 0xB5, 0x0F, 0x4F, + 0xD0, 0x4E, 0x35, 0x22, 0x98, 0x24, 0x2A, 0xCB, + 0xFD, 0x00, 0xE2, 0x98, 0xBD, 0x30, 0x93, 0x44 + }, + { + 0x71, 0x23, 0x54, 0xFF, 0x35, 0x35, 0x74, 0x80, + 0xCA, 0xA5, 0x23, 0x63, 0x91, 0x56, 0xC1, 0x0A, + 0x55, 0xC6, 0xE9, 0x65, 0xD9, 0x49, 0xFB, 0xDB, + 0xB5, 0x08, 0xC0, 0xC4, 0xCE, 0x79, 0x57, 0xEB, + 0x86, 0xA2, 0x33, 0xF2, 0xA6, 0x98, 0x37, 0x98, + 0x16, 0x25, 0x21, 0x88, 0x23, 0xFE, 0x53, 0xCF, + 0xFA, 0x60, 0x0B, 0xF4, 0xFC, 0xB4, 0xBC, 0x61, + 0x80, 0x79, 0x1B, 0xB2, 0x5D, 0xE8, 0x93, 0x59 + }, + { + 0x25, 0x20, 0x6B, 0x20, 0xE8, 0x32, 0x7D, 0xE9, + 0xC2, 0x62, 0x34, 0x21, 0x35, 0x71, 0xC4, 0x0D, + 0x8C, 0x53, 0x28, 0x50, 0xA0, 0x1B, 0xD5, 0x42, + 0x19, 0x16, 0x24, 0xDC, 0xBA, 0xA5, 0xEB, 0xD2, + 0x11, 0x25, 0x75, 0x94, 0x28, 0x49, 0x05, 0xED, + 0xA8, 0x82, 0x2E, 0xA6, 0x0C, 0x25, 0x5F, 0x16, + 0xCB, 0x3B, 0xA2, 0x91, 0x67, 0x85, 0x44, 0x82, + 0xB5, 0xD2, 0xD9, 0x21, 0xD7, 0x6E, 0xD7, 0x3B + }, + { + 0x21, 0x10, 0x9F, 0x9A, 0x92, 0xC9, 0x60, 0xDA, + 0x07, 0x1B, 0x4B, 0xF5, 0x16, 0x76, 0x8A, 0x66, + 0x58, 0x44, 0x6F, 0x29, 0xEE, 0x27, 0x29, 0x82, + 0x67, 0x5A, 0x99, 0x08, 0xF0, 0x10, 0x56, 0xBD, + 0xB0, 0xE5, 0xAD, 0x79, 0xBB, 0x87, 0x5A, 0x78, + 0x84, 0x09, 0x88, 0x81, 0xA6, 0xA3, 0xF6, 0xA6, + 0xBC, 0x5D, 0xCC, 0x70, 0x88, 0x1E, 0xDA, 0x1B, + 0x74, 0x31, 0xD0, 0x2E, 0x3A, 0x68, 0xE8, 0x12 + }, + { + 0x51, 0xB6, 0x4A, 0x9A, 0xFC, 0x09, 0x5D, 0xA7, + 0x7A, 0xCE, 0xDD, 0xE6, 0xB4, 0x2D, 0x2C, 0xB6, + 0x24, 0xF0, 0x6E, 0x60, 0x3F, 0x82, 0xC5, 0x33, + 0xF7, 0x55, 0x0D, 0x77, 0xF7, 0xD4, 0xE5, 0x3F, + 0x08, 0xE5, 0x26, 0x74, 0xB9, 0xAE, 0xD2, 0x01, + 0x7E, 0x40, 0x7A, 0x63, 0x7A, 0x95, 0x7F, 0x6B, + 0xE5, 0x70, 0x37, 0x47, 0x22, 0xE1, 0x77, 0x4E, + 0xB6, 0x0B, 0xA9, 0x0E, 0x4C, 0xBD, 0x0C, 0x7A + }, + { + 0x56, 0xD8, 0x13, 0x42, 0x00, 0xC8, 0xD4, 0x28, + 0x9E, 0xFB, 0xD4, 0xA8, 0x01, 0xCC, 0x0A, 0x68, + 0x1B, 0x67, 0x5F, 0x22, 0xAA, 0x88, 0x53, 0x97, + 0x14, 0x71, 0x80, 0x0F, 0xBC, 0x89, 0xA6, 0x07, + 0x03, 0x99, 0x28, 0x70, 0x1E, 0xD3, 0x45, 0xC3, + 0x14, 0x91, 0x3C, 0x58, 0x14, 0x69, 0x2F, 0xA4, + 0xCF, 0x7E, 0x53, 0x33, 0xF0, 0x48, 0xFB, 0xCA, + 0x53, 0xD0, 0xC3, 0x22, 0x64, 0xEE, 0x1E, 0xE3 + }, + { + 0x60, 0x53, 0x92, 0x8D, 0xA8, 0x25, 0x47, 0x9F, + 0xDD, 0xC8, 0x94, 0x4C, 0x42, 0x8B, 0x98, 0x48, + 0x3D, 0x6C, 0x61, 0x73, 0x37, 0x21, 0xCB, 0x48, + 0x4F, 0x1B, 0x59, 0xF2, 0xED, 0x91, 0x2F, 0x39, + 0xA2, 0xDD, 0xC9, 0xC2, 0xDA, 0x7B, 0xE7, 0xCF, + 0xA8, 0x32, 0xA2, 0xD8, 0x85, 0xB5, 0xB8, 0x9A, + 0xF1, 0x69, 0xB6, 0x49, 0x1E, 0x3F, 0xE6, 0x19, + 0x00, 0xE6, 0x9E, 0xFA, 0x12, 0xC2, 0x4B, 0xAC + }, + { + 0x14, 0x70, 0x11, 0x4A, 0xFB, 0x00, 0x52, 0xCD, + 0x03, 0x5B, 0x67, 0x59, 0xC1, 0x50, 0x57, 0x4C, + 0x65, 0x9A, 0x0F, 0x7D, 0x89, 0x1D, 0x66, 0x05, + 0x0D, 0xFA, 0x29, 0x39, 0xD6, 0x52, 0x1F, 0x77, + 0x51, 0xDC, 0x47, 0xCE, 0xE2, 0x12, 0x30, 0xA1, + 0xEE, 0x42, 0x98, 0x5A, 0x61, 0x58, 0x7F, 0xE0, + 0x1E, 0xF6, 0x58, 0x26, 0xDE, 0x0F, 0xD9, 0x07, + 0xE8, 0x7B, 0x26, 0x64, 0xA9, 0xB4, 0x70, 0xBF + }, + { + 0xC7, 0x83, 0x6B, 0x01, 0x9D, 0x2F, 0x29, 0xCB, + 0xA2, 0x2A, 0x7F, 0x6B, 0x24, 0xD0, 0x28, 0x61, + 0x66, 0x86, 0xDF, 0xA5, 0xC3, 0x05, 0xF7, 0xD2, + 0x9B, 0x9F, 0x3D, 0x0E, 0x35, 0xB2, 0x7E, 0x1C, + 0xB2, 0x6C, 0x20, 0x86, 0x8B, 0x94, 0x42, 0x92, + 0x6F, 0x0A, 0xDC, 0x93, 0x93, 0x5E, 0x32, 0xC5, + 0x47, 0x52, 0x3E, 0x44, 0x8E, 0x73, 0x4E, 0xDA, + 0xB4, 0xB5, 0x10, 0xB1, 0xA3, 0xA3, 0x20, 0xF2 + }, + { + 0x4E, 0x5E, 0x1F, 0xAF, 0xFD, 0x50, 0x74, 0x3A, + 0xAC, 0x1D, 0xAD, 0xA4, 0x99, 0x13, 0xFC, 0xAB, + 0x6B, 0x87, 0xAB, 0x9C, 0x0B, 0x6F, 0xF0, 0xB9, + 0x58, 0x13, 0xD6, 0xBA, 0xAC, 0xC4, 0xFA, 0x65, + 0xAB, 0x0D, 0xEB, 0xA6, 0xE2, 0x4C, 0x96, 0x41, + 0xF2, 0xF4, 0x8F, 0x8C, 0x66, 0xC1, 0xF0, 0xA7, + 0xBD, 0x5E, 0x7A, 0x6C, 0x5D, 0xC3, 0x86, 0xCB, + 0x48, 0x3F, 0xEF, 0x55, 0x8F, 0x57, 0x8E, 0x4F + }, + { + 0xDB, 0xBC, 0x73, 0x9A, 0xC1, 0x05, 0x82, 0xEE, + 0xEC, 0x93, 0x08, 0x16, 0xB1, 0x2B, 0x64, 0xFA, + 0xA2, 0x4F, 0xA5, 0xED, 0x6B, 0x9E, 0x87, 0x6D, + 0xE1, 0x74, 0x87, 0x0B, 0xC4, 0x88, 0xDF, 0x4A, + 0xAF, 0x22, 0x32, 0xFD, 0xBB, 0x63, 0x34, 0x68, + 0x89, 0xFC, 0xF4, 0x50, 0x63, 0x81, 0x43, 0xAB, + 0x97, 0xB0, 0xFE, 0x10, 0xCE, 0xFF, 0xF2, 0x13, + 0x1E, 0xC6, 0x33, 0xF2, 0x81, 0xE7, 0x7A, 0xD0 + }, + { + 0x02, 0xD4, 0x2D, 0xA3, 0x5E, 0x2A, 0x10, 0x2E, + 0xB2, 0x07, 0x6E, 0xE8, 0xDC, 0x0D, 0x79, 0xF0, + 0x9C, 0x01, 0xF9, 0x05, 0x8C, 0xFE, 0x18, 0xEB, + 0x3D, 0x51, 0xB5, 0xAC, 0x23, 0x68, 0xDF, 0xAC, + 0x2E, 0xEF, 0xAF, 0x7D, 0x16, 0x1C, 0x12, 0x96, + 0xF5, 0x99, 0xA1, 0xF7, 0xCA, 0x5E, 0x39, 0x29, + 0xFC, 0xFB, 0x5C, 0xA1, 0xF4, 0xE5, 0x07, 0xC6, + 0x07, 0xDC, 0x68, 0x88, 0x06, 0x88, 0xCB, 0x11 + }, + { + 0xB4, 0xC3, 0x18, 0x85, 0x51, 0x57, 0x66, 0xA1, + 0x36, 0xD8, 0xA1, 0x73, 0xA6, 0x18, 0xCB, 0x3B, + 0x49, 0x02, 0xA0, 0x54, 0x49, 0xED, 0xEF, 0xCB, + 0xBC, 0x5D, 0xD6, 0xB9, 0xBD, 0x8D, 0x29, 0x54, + 0x6E, 0x1B, 0x0A, 0x9D, 0xEA, 0xDB, 0x6B, 0xDA, + 0x4D, 0xAA, 0x26, 0xA4, 0x69, 0x13, 0x5F, 0x5B, + 0x2D, 0x0B, 0x3C, 0x67, 0x9E, 0xBA, 0x51, 0x84, + 0x95, 0xF9, 0x02, 0x2A, 0x4A, 0x87, 0x7B, 0x83 + }, + { + 0x3E, 0x85, 0xC4, 0x32, 0xC6, 0xC3, 0xB4, 0x50, + 0x20, 0x07, 0x56, 0x59, 0x1E, 0x1E, 0x77, 0xD4, + 0x9E, 0x6C, 0x6E, 0x72, 0x70, 0xF4, 0xA8, 0x08, + 0x41, 0xDC, 0x42, 0x61, 0x98, 0xB8, 0xF1, 0x90, + 0x29, 0x2F, 0x7F, 0xDC, 0xE9, 0x4C, 0x9C, 0xE3, + 0x32, 0x9D, 0xF5, 0xC4, 0xE7, 0x30, 0x00, 0x52, + 0x3D, 0xFF, 0xC7, 0x3E, 0x14, 0x8A, 0x35, 0x14, + 0xC3, 0x93, 0xA7, 0x3E, 0x51, 0xA4, 0xD0, 0x0E + }, + { + 0xCB, 0xC1, 0x35, 0xEA, 0x29, 0x26, 0x63, 0xDB, + 0x00, 0x32, 0xFF, 0xEF, 0x60, 0x54, 0x52, 0x70, + 0x57, 0x86, 0xB3, 0x73, 0x8D, 0xF7, 0x10, 0x11, + 0x94, 0xA5, 0x4A, 0x3B, 0x70, 0xF1, 0xF2, 0xA1, + 0xBD, 0x75, 0x2C, 0x75, 0xAA, 0xDD, 0x8D, 0x9A, + 0x53, 0x89, 0x02, 0x33, 0x53, 0x8E, 0x79, 0xAA, + 0x83, 0xC2, 0xBA, 0xC4, 0x59, 0x87, 0xF4, 0x61, + 0x89, 0xD0, 0x15, 0x8F, 0x09, 0xE6, 0xB4, 0xE3 + }, + { + 0x65, 0x1B, 0xFA, 0x91, 0x6E, 0xD8, 0xA3, 0x4E, + 0xE5, 0x2A, 0xD6, 0xA9, 0x3C, 0xD5, 0x65, 0x5D, + 0xDE, 0x16, 0xAD, 0xF1, 0x45, 0xDC, 0xD6, 0x8C, + 0x01, 0x05, 0xA2, 0x65, 0xA4, 0x83, 0x96, 0x59, + 0xC4, 0x16, 0x63, 0x6B, 0x97, 0x58, 0xF1, 0xE3, + 0xD3, 0xA1, 0x32, 0xBC, 0x82, 0x84, 0x8B, 0x9A, + 0xBF, 0x91, 0x1F, 0x7E, 0x7A, 0x73, 0x77, 0x5C, + 0xAF, 0xD0, 0x15, 0x2F, 0x73, 0xD1, 0x4A, 0xB1 + }, + { + 0xDF, 0xC2, 0x5B, 0xC8, 0xE1, 0x9F, 0xB1, 0xF3, + 0x4F, 0xD9, 0x57, 0x5E, 0xC9, 0x66, 0x6E, 0xB4, + 0xA0, 0xF0, 0x1C, 0xEC, 0x98, 0x42, 0xE6, 0x2D, + 0xCE, 0xDF, 0x21, 0xA8, 0x5F, 0x8B, 0xD4, 0x78, + 0xA7, 0x3B, 0x84, 0x64, 0xC3, 0xAE, 0x88, 0x53, + 0x44, 0x51, 0xFF, 0x5C, 0x07, 0xC1, 0xD2, 0xE8, + 0x1C, 0x1D, 0x01, 0x18, 0x53, 0x9B, 0xF7, 0xF1, + 0x05, 0x5B, 0xB9, 0x66, 0xA6, 0xFF, 0xC3, 0x2B + }, + { + 0xCE, 0x08, 0x03, 0x76, 0xB5, 0x8E, 0x39, 0x97, + 0xEF, 0x39, 0xE9, 0x18, 0x3A, 0xF3, 0xA8, 0xDF, + 0xAD, 0x05, 0x6F, 0x11, 0xB7, 0xA9, 0x24, 0x7F, + 0xAF, 0x10, 0x35, 0xF0, 0x8F, 0x38, 0x55, 0xDC, + 0xEF, 0x87, 0xB6, 0x20, 0x70, 0xE7, 0x41, 0xB9, + 0x61, 0xD7, 0xE8, 0x87, 0xA7, 0x9F, 0x66, 0x8E, + 0x53, 0xD0, 0xD0, 0xC6, 0x5C, 0x28, 0x70, 0x63, + 0xF3, 0xC7, 0xA8, 0x0C, 0x04, 0x48, 0xD4, 0x81 + }, + { + 0x82, 0x68, 0x37, 0xC5, 0xDA, 0x1B, 0x8A, 0xA1, + 0xD9, 0x9D, 0xEB, 0xE2, 0x4E, 0x02, 0xA8, 0x6D, + 0xA4, 0x03, 0xF1, 0x79, 0x0E, 0x6F, 0x3D, 0x80, + 0x67, 0xA2, 0xFD, 0x84, 0x7C, 0xDF, 0x4E, 0x29, + 0x51, 0x02, 0x3D, 0x05, 0x85, 0x44, 0xC6, 0x68, + 0x19, 0x4B, 0xCE, 0x1E, 0xBB, 0xEB, 0xF4, 0x32, + 0x0D, 0xAD, 0xD1, 0xFF, 0x32, 0x37, 0xE1, 0x8F, + 0x65, 0xA3, 0x15, 0xD3, 0xA6, 0x00, 0x1E, 0x32 + }, + { + 0xC8, 0x56, 0x49, 0x88, 0x5C, 0x88, 0xBB, 0x22, + 0x3D, 0x1F, 0xAB, 0xFD, 0x26, 0xBB, 0x63, 0xEA, + 0xC1, 0x2B, 0x3A, 0xE2, 0xFE, 0x30, 0xF4, 0xB1, + 0x50, 0xD4, 0x90, 0xBF, 0x88, 0x68, 0x1E, 0xBC, + 0x13, 0xA4, 0x21, 0xBD, 0xD8, 0x88, 0x76, 0x38, + 0x33, 0x2A, 0xB7, 0xB8, 0x03, 0xD4, 0x9D, 0xC8, + 0x4D, 0xDB, 0x10, 0x61, 0x75, 0xE8, 0xE0, 0x0C, + 0xBF, 0xB6, 0xB3, 0x3A, 0x4D, 0x35, 0x0F, 0xA7 + }, + { + 0x14, 0x7A, 0xB8, 0xBF, 0x09, 0x08, 0xA9, 0x00, + 0xC3, 0xF3, 0xA2, 0x1D, 0x0E, 0xFA, 0x25, 0x3C, + 0x57, 0x98, 0x88, 0x6B, 0x70, 0xE5, 0x7D, 0x75, + 0xD0, 0x9C, 0x63, 0x27, 0x94, 0x97, 0xBC, 0x3F, + 0x16, 0xDA, 0xD9, 0x09, 0xC3, 0x75, 0xD8, 0x88, + 0xF9, 0xE4, 0xE4, 0xBE, 0x1B, 0x17, 0x7F, 0x57, + 0x9C, 0xF0, 0xC2, 0x96, 0x7A, 0xA4, 0xA5, 0x32, + 0x81, 0xDB, 0x7E, 0x36, 0xC1, 0xB9, 0x5D, 0x4D + }, + { + 0x4C, 0xF1, 0xB5, 0xD9, 0xDE, 0xE7, 0xC2, 0x05, + 0x4C, 0x16, 0x99, 0x15, 0x4B, 0xEF, 0xB6, 0x34, + 0xBA, 0xFA, 0xEA, 0x27, 0x4A, 0x54, 0xA5, 0xEC, + 0x9F, 0xDD, 0xC4, 0xA5, 0x13, 0xD4, 0xD7, 0x69, + 0x8E, 0x7E, 0xF1, 0x0F, 0x1C, 0xD4, 0x95, 0xB6, + 0x84, 0x95, 0x6E, 0xF4, 0xC3, 0x41, 0xF0, 0x93, + 0x2C, 0xA6, 0x4F, 0x30, 0x89, 0xC5, 0x37, 0x51, + 0x4A, 0x8E, 0x25, 0x2F, 0xAE, 0xEC, 0x9A, 0x6D + }, + { + 0x93, 0x52, 0xBB, 0x72, 0x8C, 0x34, 0x8F, 0x84, + 0x14, 0xBC, 0x90, 0xAC, 0xBE, 0x06, 0x3F, 0x03, + 0xC3, 0xE0, 0x23, 0xB1, 0x1B, 0x1C, 0xAB, 0x1A, + 0xD3, 0x5F, 0x3E, 0xE5, 0x7C, 0x4F, 0xA1, 0x79, + 0x5F, 0x4B, 0x3D, 0x24, 0xF6, 0x54, 0x22, 0xEF, + 0x80, 0x40, 0xA7, 0x7E, 0x4E, 0xC9, 0xD6, 0x0B, + 0x52, 0x6E, 0x56, 0x99, 0xC7, 0xF1, 0xA7, 0xE2, + 0xF9, 0x39, 0xA1, 0xB8, 0x80, 0x8B, 0xEE, 0xD8 + }, + { + 0xD4, 0x28, 0xBD, 0xA1, 0x76, 0xE7, 0xA0, 0x10, + 0x7A, 0xBA, 0x89, 0xDD, 0xA0, 0x36, 0xB2, 0x14, + 0x47, 0xFF, 0x73, 0x13, 0x04, 0x63, 0xD9, 0xAF, + 0xFA, 0x73, 0xA1, 0x66, 0xA1, 0x9F, 0x29, 0x9E, + 0x97, 0x9D, 0xC0, 0x24, 0x0B, 0x5C, 0xF2, 0x9C, + 0xC6, 0xE8, 0x0B, 0xE4, 0xCA, 0x05, 0x7E, 0xF8, + 0x4C, 0xEF, 0x91, 0xD2, 0x63, 0xAF, 0x36, 0x5B, + 0x1E, 0xE1, 0xFB, 0x7A, 0x58, 0xF1, 0xA5, 0xAB + }, + { + 0x08, 0xD0, 0x7B, 0x1B, 0xEC, 0xEA, 0x80, 0xBC, + 0xB1, 0xCB, 0x42, 0x2D, 0x74, 0x6C, 0xFC, 0x04, + 0x49, 0x39, 0xA4, 0xA5, 0x55, 0x89, 0xC1, 0x05, + 0x6E, 0xAE, 0x28, 0x99, 0xB5, 0xB5, 0x9F, 0xE4, + 0xD8, 0x2D, 0xD3, 0xEF, 0xB9, 0xD7, 0x64, 0xB0, + 0x48, 0x84, 0x11, 0x84, 0x64, 0x67, 0x17, 0x6D, + 0xE1, 0x3D, 0xFE, 0xA1, 0xAF, 0xF7, 0x4F, 0x46, + 0x51, 0x9B, 0x5E, 0x00, 0x88, 0xF5, 0xBF, 0x4B + }, + { + 0x0F, 0xD7, 0xAE, 0xFF, 0x11, 0x0A, 0x43, 0xBF, + 0x10, 0x12, 0x6F, 0xCA, 0x66, 0xD1, 0x0F, 0xF5, + 0x17, 0x45, 0x88, 0xE6, 0x4B, 0x4F, 0x6C, 0xC9, + 0x7B, 0x20, 0x24, 0x9D, 0xE9, 0x67, 0x8B, 0x2E, + 0x28, 0xBD, 0x27, 0x52, 0xDB, 0x06, 0xC2, 0xDA, + 0xA9, 0x45, 0x01, 0x54, 0x55, 0x90, 0x1B, 0x59, + 0xFA, 0xAE, 0xB7, 0xC0, 0x96, 0x17, 0x55, 0xE6, + 0xF6, 0xEF, 0x66, 0x87, 0x04, 0x18, 0xFF, 0xC0 + }, + { + 0xB0, 0x7C, 0xC5, 0x33, 0x38, 0x2F, 0x57, 0x80, + 0x50, 0xC1, 0x6D, 0xEE, 0xD6, 0xCD, 0xD3, 0x80, + 0x38, 0x43, 0xFD, 0xF6, 0xC2, 0x6E, 0xD4, 0x1F, + 0xAA, 0x4A, 0xC2, 0x93, 0xD3, 0x77, 0x08, 0xDD, + 0x3A, 0x9A, 0x61, 0x39, 0x6F, 0x55, 0x97, 0x70, + 0xA3, 0xBD, 0xF2, 0xC4, 0xFA, 0x53, 0x58, 0x45, + 0xA1, 0x4F, 0x0C, 0x2C, 0x92, 0xEC, 0xC3, 0x6F, + 0xEA, 0x56, 0x05, 0x9A, 0x48, 0xAD, 0x61, 0xFD + }, + { + 0x62, 0xA8, 0x7F, 0xD7, 0x2F, 0x9C, 0xCF, 0x0F, + 0xDB, 0xD6, 0xAD, 0xA4, 0x68, 0x1F, 0x97, 0x1C, + 0xFD, 0x24, 0x7F, 0x5C, 0x2F, 0xA9, 0x8D, 0x5D, + 0xF3, 0xB3, 0xAB, 0xC4, 0x13, 0xAE, 0x18, 0x2A, + 0xE9, 0xC4, 0xD2, 0x88, 0x7D, 0x6C, 0xE8, 0xDB, + 0xD0, 0x54, 0x5C, 0x6F, 0xED, 0xE6, 0x6B, 0x05, + 0xAF, 0x29, 0xED, 0xA0, 0xCD, 0xBF, 0x82, 0x2A, + 0x1B, 0xBB, 0xE2, 0x8B, 0x12, 0xD5, 0x6A, 0x5E + }, + { + 0x24, 0xEE, 0x18, 0x6D, 0x77, 0xD9, 0x3B, 0x9B, + 0xA8, 0x8F, 0x92, 0x72, 0x7C, 0x16, 0xE3, 0x75, + 0xA6, 0xF6, 0x5E, 0xE0, 0x17, 0xBD, 0x5D, 0xE1, + 0x40, 0xAF, 0xC6, 0x9D, 0x32, 0xCD, 0xD5, 0x2A, + 0xA8, 0x5A, 0xC1, 0x2E, 0xDB, 0x3A, 0x6A, 0xF7, + 0x8C, 0xA7, 0x5A, 0xBE, 0x38, 0x66, 0xBD, 0xD1, + 0x1F, 0xB4, 0x4C, 0x90, 0xC4, 0xE7, 0x63, 0xA7, + 0xBC, 0xBA, 0x82, 0x75, 0xFD, 0x8F, 0x3D, 0x29 + }, + { + 0x38, 0x4B, 0xA8, 0x61, 0x64, 0xB6, 0xA4, 0xCF, + 0x44, 0x09, 0xBC, 0x48, 0xA3, 0x40, 0xD9, 0x57, + 0xDF, 0xA6, 0xEB, 0x3D, 0xDB, 0x54, 0xF9, 0x29, + 0x5D, 0xF3, 0x56, 0x53, 0xB1, 0x52, 0x6B, 0x2C, + 0xEB, 0x4D, 0x54, 0xD1, 0xB6, 0xAA, 0x5A, 0xD1, + 0xE8, 0x02, 0x63, 0x57, 0x1E, 0xCF, 0x95, 0xD7, + 0xD7, 0x4B, 0xDE, 0x52, 0x88, 0x79, 0x54, 0xE0, + 0xA5, 0x65, 0xDD, 0xF8, 0x26, 0x4B, 0xCB, 0x95 + }, + { + 0x99, 0x41, 0x2C, 0x3B, 0x17, 0xA4, 0xC5, 0x0F, + 0xB3, 0xD1, 0xE9, 0x9C, 0xA9, 0xC8, 0x4A, 0xF5, + 0xE8, 0x38, 0x13, 0xE9, 0xA2, 0x2E, 0x9D, 0x16, + 0x7B, 0x4C, 0x89, 0x96, 0x8A, 0x85, 0xD2, 0x22, + 0xA9, 0x53, 0x4F, 0x5A, 0x73, 0x7D, 0x96, 0x20, + 0x9E, 0x6B, 0x9D, 0x92, 0x41, 0xD6, 0xEC, 0xB9, + 0x70, 0x21, 0x34, 0xBD, 0xCA, 0x93, 0x98, 0xBD, + 0x18, 0xBD, 0x30, 0x50, 0x5B, 0x6A, 0x82, 0xB3 + }, + { + 0xB2, 0x07, 0xB2, 0x4F, 0x6C, 0xDD, 0x9D, 0xA0, + 0xB0, 0x28, 0xE1, 0xAE, 0x3B, 0xC7, 0x8A, 0x3D, + 0x10, 0xB2, 0xD6, 0x4D, 0x9E, 0xF3, 0xA4, 0x8D, + 0xD6, 0xA2, 0x8D, 0xC7, 0xE1, 0xB8, 0xF3, 0x1F, + 0x8A, 0xA6, 0x06, 0xAC, 0x18, 0x06, 0xF1, 0xDA, + 0x5F, 0xE8, 0x48, 0x33, 0xBF, 0x9F, 0xC7, 0x55, + 0x5C, 0xF4, 0x58, 0x1E, 0x9D, 0xB4, 0xBE, 0xA9, + 0xD2, 0xAA, 0xE8, 0x04, 0x0C, 0x14, 0x31, 0x74 + }, + { + 0xE2, 0x5D, 0x4C, 0x29, 0xC1, 0xD6, 0x5B, 0xCE, + 0x52, 0xDB, 0x78, 0xC7, 0xE8, 0x26, 0xD6, 0x97, + 0x9F, 0x71, 0x0B, 0xC9, 0xAB, 0xDB, 0xF2, 0x79, + 0x38, 0x93, 0x2A, 0xFE, 0x9D, 0x78, 0x2B, 0x44, + 0xA0, 0x85, 0x06, 0xFC, 0xD8, 0xAA, 0xB1, 0x24, + 0x6F, 0x5C, 0x74, 0x4F, 0x66, 0x41, 0x55, 0xB6, + 0x42, 0x78, 0x86, 0x69, 0x3D, 0xDB, 0x7A, 0xDE, + 0x2A, 0x92, 0x69, 0x1A, 0x07, 0x7D, 0x5B, 0x2D + }, + { + 0xFA, 0x3A, 0x28, 0x91, 0x44, 0x51, 0x7D, 0x95, + 0x5F, 0x32, 0x70, 0x0F, 0x39, 0x0C, 0x0D, 0x3B, + 0xC4, 0xD7, 0x6D, 0xB9, 0x4B, 0x6F, 0x30, 0x10, + 0x05, 0xFA, 0xAB, 0x34, 0x72, 0x62, 0x9C, 0x74, + 0xAD, 0x48, 0x5F, 0x30, 0x28, 0xBA, 0x06, 0x7D, + 0x36, 0x11, 0x31, 0x94, 0xB3, 0x6A, 0xFE, 0x75, + 0x9D, 0x26, 0x18, 0xCB, 0xE9, 0x31, 0x4C, 0xEC, + 0x98, 0x42, 0x34, 0xB7, 0xAC, 0xAA, 0xD9, 0x71 + }, + { + 0xDE, 0x63, 0xB7, 0x04, 0xE5, 0x0D, 0xFB, 0xCD, + 0x34, 0xBE, 0x35, 0x5B, 0xA7, 0xC5, 0xF3, 0x14, + 0x13, 0x1A, 0x74, 0x65, 0xA8, 0x5E, 0x99, 0x9B, + 0xB9, 0xA1, 0xC3, 0xE5, 0x4E, 0xC4, 0x94, 0x51, + 0x6E, 0x2A, 0x59, 0x19, 0xA0, 0x17, 0x4E, 0x97, + 0xEE, 0xA7, 0x3D, 0x7E, 0xAF, 0x47, 0xB6, 0xB8, + 0xE3, 0xAE, 0x91, 0x55, 0x83, 0xA3, 0x11, 0xB6, + 0x3E, 0xAB, 0x3F, 0x4C, 0xA7, 0x0C, 0x11, 0xC5 + }, + { + 0x05, 0x09, 0x16, 0x24, 0xF4, 0x67, 0xEF, 0x7F, + 0x14, 0x45, 0x5C, 0x31, 0x1F, 0xBE, 0x77, 0x6E, + 0x5A, 0xFB, 0x41, 0x22, 0x39, 0x42, 0x3A, 0x92, + 0xAC, 0x62, 0xD2, 0x8D, 0x00, 0x5D, 0x0A, 0xBD, + 0x4F, 0xDB, 0xCB, 0x38, 0x8C, 0x99, 0xD7, 0x76, + 0x58, 0xD7, 0x79, 0x0D, 0x0B, 0xCA, 0x22, 0x3D, + 0xF8, 0xC4, 0xA2, 0xAD, 0xF3, 0x09, 0x92, 0xFF, + 0x99, 0xE5, 0x99, 0xAC, 0x62, 0xE4, 0x70, 0xD6 + }, + { + 0x70, 0x93, 0xD2, 0xFB, 0x0D, 0xF6, 0xFB, 0x23, + 0x36, 0xA5, 0x67, 0x86, 0x1B, 0x6E, 0x69, 0x4B, + 0x9A, 0x7E, 0x91, 0x6B, 0x07, 0x5E, 0xD4, 0x37, + 0x9D, 0xBC, 0x4F, 0xA7, 0x76, 0xC5, 0xA1, 0xFE, + 0xD2, 0x92, 0x02, 0x95, 0x9E, 0xFB, 0x8A, 0x50, + 0xF6, 0xC7, 0x3A, 0xB7, 0x8F, 0xE9, 0x1A, 0xB0, + 0x72, 0x6B, 0x49, 0x12, 0xAF, 0xDF, 0xF0, 0x2A, + 0x91, 0x99, 0x7B, 0x3A, 0x8C, 0x27, 0x28, 0xF0 + }, + { + 0x65, 0x60, 0x2D, 0x25, 0xEF, 0xC0, 0xA4, 0xAE, + 0x2B, 0x83, 0xB0, 0x42, 0x2F, 0x22, 0x77, 0xDC, + 0x10, 0xCF, 0x06, 0x3B, 0x94, 0x5F, 0xE1, 0x76, + 0xF7, 0x15, 0x54, 0xF8, 0xC6, 0xFF, 0x0A, 0x98, + 0x6F, 0x5C, 0xE7, 0x9C, 0xA4, 0x25, 0xA5, 0x7A, + 0xF5, 0x0F, 0xBB, 0x9F, 0xDB, 0x9B, 0xC0, 0xF4, + 0x6E, 0xB3, 0x99, 0xCF, 0x28, 0xD1, 0xEC, 0xC0, + 0x4E, 0xFA, 0xAD, 0xE3, 0xAD, 0xF3, 0xBA, 0xAC + }, + { + 0xA2, 0xD3, 0x9C, 0x2F, 0xC3, 0x8C, 0x02, 0x36, + 0x76, 0x7F, 0xE4, 0x40, 0x0B, 0xE3, 0xD6, 0xEB, + 0xE6, 0xC7, 0xCF, 0x28, 0x2D, 0x87, 0xB2, 0xEB, + 0x11, 0x59, 0x14, 0x92, 0xA1, 0x56, 0xC7, 0x23, + 0x39, 0x5F, 0xE6, 0xD5, 0xE1, 0x84, 0x21, 0x79, + 0xA5, 0xB9, 0x8D, 0x5B, 0x90, 0x26, 0x1E, 0x41, + 0x0B, 0x81, 0xEC, 0x7D, 0x9D, 0xBC, 0x38, 0x5F, + 0x2F, 0x25, 0xD7, 0x3B, 0xC8, 0xE5, 0xC1, 0x1D + }, + { + 0xC9, 0x76, 0xE6, 0x46, 0x54, 0xC6, 0xB6, 0x5A, + 0xF2, 0xF6, 0x93, 0x3A, 0x3E, 0x7D, 0xD4, 0x9C, + 0x31, 0x3F, 0x95, 0x8C, 0x26, 0x27, 0x83, 0x82, + 0xC1, 0x39, 0x76, 0xBB, 0xD8, 0x36, 0x08, 0x50, + 0x97, 0xE7, 0x5D, 0x54, 0x12, 0xF1, 0xD8, 0x04, + 0x5B, 0x47, 0xA3, 0x9B, 0xF2, 0xC8, 0x88, 0x0F, + 0x14, 0x33, 0x5A, 0x09, 0xC6, 0xE9, 0xBC, 0x64, + 0x3C, 0x4F, 0x65, 0xE7, 0x9C, 0x71, 0x95, 0x61 + }, + { + 0xE7, 0x26, 0xBA, 0xA0, 0x41, 0x44, 0xE0, 0x87, + 0xE6, 0x38, 0x00, 0x54, 0x90, 0x39, 0x50, 0x56, + 0x58, 0xB7, 0xD8, 0x7F, 0x04, 0x9D, 0x79, 0x19, + 0x53, 0x87, 0xC5, 0xC3, 0xB9, 0xE3, 0xE2, 0x6C, + 0xCC, 0x54, 0x7B, 0x04, 0x95, 0x61, 0x7E, 0xA1, + 0x9C, 0xEA, 0xEB, 0x8C, 0x2C, 0x9D, 0xD4, 0x89, + 0xEC, 0xAC, 0x17, 0xED, 0x96, 0x8B, 0x90, 0x00, + 0x23, 0xC7, 0x36, 0x96, 0xAF, 0xD6, 0x62, 0x8F + }, + { + 0x7E, 0x9D, 0x92, 0xBB, 0x7F, 0x4E, 0x4E, 0xB1, + 0xCF, 0x73, 0xFB, 0x3A, 0x1F, 0x3C, 0xAB, 0x34, + 0x5F, 0xC3, 0x10, 0x9C, 0xC6, 0xDA, 0x62, 0xE8, + 0x67, 0xDC, 0xA5, 0xB5, 0x03, 0x17, 0xE6, 0xB6, + 0xE7, 0x28, 0x62, 0xFA, 0x04, 0x69, 0xA3, 0x7C, + 0xEE, 0x30, 0x34, 0x54, 0xF6, 0x51, 0x9A, 0xE1, + 0x15, 0xA8, 0x3D, 0x56, 0x97, 0x4A, 0x12, 0xD9, + 0x49, 0xAA, 0x66, 0x2F, 0x1B, 0xAB, 0x63, 0x73 + }, + { + 0xD2, 0xD0, 0x2D, 0x45, 0x0D, 0x37, 0xAB, 0x3B, + 0x3E, 0xD6, 0x93, 0xF8, 0x1C, 0xDE, 0x7F, 0x5F, + 0x57, 0x1A, 0x2F, 0x58, 0xAF, 0xD2, 0x3F, 0xED, + 0xA0, 0xDD, 0x9C, 0xDC, 0xF2, 0x1D, 0x14, 0x48, + 0x7B, 0x3F, 0x1A, 0x08, 0xD1, 0x57, 0x32, 0xC9, + 0xE8, 0xF8, 0xBC, 0xC5, 0x4B, 0x3E, 0xED, 0x04, + 0xD1, 0x0B, 0x3B, 0x39, 0xC7, 0xF3, 0x3B, 0x09, + 0x0F, 0x6B, 0xE7, 0x6E, 0x58, 0xD4, 0xFA, 0xF4 + }, + { + 0x83, 0x96, 0x84, 0xDD, 0x6C, 0xC7, 0xC8, 0xE1, + 0x40, 0xC1, 0xBE, 0xBD, 0xAD, 0xF5, 0xC2, 0x39, + 0x9D, 0x75, 0xCE, 0x5B, 0xF2, 0xF3, 0x58, 0x4E, + 0xB3, 0x75, 0xD3, 0xD0, 0x1C, 0xDB, 0xD8, 0xDA, + 0x61, 0x87, 0x33, 0xA0, 0x0A, 0xD8, 0x13, 0xDA, + 0xA6, 0x4F, 0xF5, 0x55, 0xC4, 0xEB, 0xEA, 0x43, + 0xFF, 0x54, 0x10, 0x84, 0xAC, 0xE6, 0x5C, 0x18, + 0x4A, 0x8B, 0x5D, 0x34, 0xF6, 0x34, 0xFE, 0x17 + }, + { + 0x8D, 0x21, 0x9B, 0x82, 0x48, 0x86, 0xDF, 0x9E, + 0x1C, 0x5F, 0x3D, 0x96, 0xF1, 0xDA, 0xDC, 0xE4, + 0x1E, 0xD2, 0x75, 0xE0, 0xFB, 0x86, 0x1F, 0x13, + 0x12, 0x74, 0xDF, 0x76, 0x5D, 0x24, 0x4A, 0x21, + 0x7B, 0xDA, 0xDD, 0x0D, 0x25, 0x70, 0xAF, 0x0C, + 0x52, 0x9B, 0x39, 0x55, 0x73, 0x06, 0x6D, 0x37, + 0x5D, 0x8F, 0x0D, 0x9A, 0x45, 0x6F, 0x40, 0x1D, + 0xE2, 0x49, 0xA8, 0xA8, 0x4A, 0x42, 0x64, 0x73 + }, + { + 0xD6, 0x13, 0x96, 0x38, 0xC3, 0x8C, 0x1D, 0xA1, + 0x13, 0x5E, 0x6F, 0xF4, 0xFF, 0x45, 0x7A, 0xEE, + 0x5B, 0x45, 0x0A, 0xFC, 0x6F, 0x95, 0xB5, 0x57, + 0xA2, 0xD2, 0x05, 0x37, 0xFB, 0x47, 0x8C, 0xF3, + 0x2A, 0xD2, 0xDD, 0x36, 0xA8, 0x71, 0xD0, 0x39, + 0x94, 0x10, 0xC7, 0xBE, 0xA9, 0x92, 0xC1, 0x1B, + 0xDC, 0x27, 0xEB, 0xEE, 0x03, 0xB1, 0xFE, 0x0D, + 0xB2, 0xB0, 0x5F, 0x58, 0xAC, 0x07, 0xB0, 0x82 + }, + { + 0xCC, 0x32, 0x99, 0xFA, 0x35, 0x17, 0x0C, 0xDE, + 0x84, 0x93, 0x55, 0x68, 0x01, 0xEC, 0x90, 0x6D, + 0xCC, 0x3D, 0x5A, 0x4F, 0x17, 0xD9, 0x13, 0x41, + 0xEF, 0x0B, 0xAD, 0x05, 0x11, 0xCE, 0xA9, 0x53, + 0x5A, 0x27, 0x20, 0x8D, 0xA9, 0x3F, 0x2E, 0x49, + 0xA4, 0x38, 0x5B, 0xC7, 0xBF, 0x6A, 0x77, 0xCD, + 0xF3, 0xC6, 0x5A, 0xAB, 0xFE, 0x41, 0x4C, 0xFB, + 0x3A, 0x2F, 0x79, 0x67, 0x8E, 0x0C, 0xE0, 0xD1 + }, + { + 0x3B, 0x33, 0x21, 0x8C, 0xE2, 0xC6, 0x79, 0x1A, + 0xF6, 0xD9, 0xD6, 0x7B, 0xA3, 0xEE, 0xA2, 0x2E, + 0x80, 0x46, 0x8F, 0xC6, 0x47, 0x2F, 0x34, 0x93, + 0x2A, 0x54, 0xC6, 0xFB, 0x1C, 0xED, 0xC7, 0x10, + 0x93, 0x41, 0xA0, 0x23, 0x50, 0x9B, 0xBF, 0x28, + 0x77, 0xDF, 0x0F, 0xCD, 0xF6, 0x60, 0xA5, 0xB8, + 0x3E, 0xFB, 0x10, 0x45, 0x8F, 0xF1, 0xA1, 0x4D, + 0xFE, 0x5F, 0x4E, 0x95, 0x25, 0xB3, 0x3D, 0x6D + }, + { + 0x0B, 0x54, 0xCF, 0xC2, 0x53, 0x0C, 0xB1, 0xE9, + 0xB1, 0x40, 0x6F, 0xAA, 0xAB, 0xDE, 0x8A, 0x36, + 0x04, 0xC6, 0x85, 0xA1, 0x01, 0x0E, 0xF7, 0x9D, + 0x64, 0x9E, 0xA2, 0x3C, 0xA2, 0x70, 0xD0, 0xF5, + 0x61, 0xCB, 0x40, 0x5F, 0xF8, 0x3B, 0x3D, 0x03, + 0x71, 0xB8, 0xB1, 0xAE, 0xA0, 0xB9, 0x38, 0x70, + 0x98, 0x85, 0xC6, 0xB8, 0x4C, 0xD4, 0x36, 0x28, + 0xD2, 0xE3, 0x26, 0x82, 0x4C, 0xA0, 0xD4, 0x2D + }, + { + 0x87, 0x1F, 0xAD, 0xDF, 0x9B, 0x4C, 0xE5, 0x4C, + 0x20, 0xB5, 0x85, 0xD0, 0x2C, 0x85, 0xD9, 0x8E, + 0x64, 0xC6, 0x4C, 0xC2, 0x95, 0x4C, 0xD4, 0xEE, + 0x46, 0x39, 0xEC, 0x6E, 0x85, 0x5A, 0x01, 0x8C, + 0x2E, 0x59, 0x25, 0xF0, 0x05, 0xDA, 0xC3, 0xF5, + 0x5B, 0x03, 0x42, 0x37, 0x9D, 0x16, 0x53, 0x6F, + 0x09, 0x0C, 0xB6, 0xCD, 0x0B, 0xD7, 0x67, 0xD1, + 0xFF, 0xC4, 0xCA, 0xE2, 0xE4, 0xFE, 0x58, 0x3C + }, + { + 0x2F, 0xF6, 0x37, 0xA9, 0xE9, 0xD5, 0x69, 0x2A, + 0xC8, 0x9F, 0x74, 0xD0, 0xE5, 0xB3, 0x7D, 0xEF, + 0xA3, 0x82, 0xA4, 0xB0, 0x41, 0x18, 0xC3, 0x14, + 0xCC, 0x50, 0x99, 0xE3, 0xCE, 0x54, 0xBB, 0xB0, + 0x8C, 0xD9, 0xDC, 0xDC, 0x17, 0xB7, 0x54, 0x20, + 0xC9, 0x85, 0x3F, 0x7C, 0xC5, 0xB6, 0xF8, 0xCA, + 0x2D, 0xDD, 0x81, 0x84, 0x5C, 0x95, 0xFD, 0xF4, + 0xEB, 0xCC, 0x14, 0x7B, 0xD7, 0x57, 0x7F, 0x80 + }, + { + 0x0A, 0x54, 0x9F, 0x6A, 0x34, 0x92, 0xA9, 0x59, + 0x0C, 0x81, 0xA9, 0xF1, 0xE3, 0x29, 0x30, 0x54, + 0x33, 0x93, 0x4D, 0x9C, 0xFD, 0x94, 0x83, 0x13, + 0xE1, 0x6D, 0xD2, 0xDC, 0x68, 0x0B, 0x79, 0x3E, + 0xB0, 0x16, 0xA0, 0xF4, 0xFB, 0x7D, 0x7C, 0x83, + 0x7C, 0xF6, 0x94, 0xFD, 0x49, 0x1E, 0x48, 0xA6, + 0x09, 0xB1, 0x0E, 0xDA, 0x63, 0xE5, 0xFD, 0x1E, + 0x69, 0xD9, 0x54, 0x35, 0x27, 0xB1, 0x27, 0x4D + }, + { + 0x40, 0xD4, 0x1B, 0x59, 0x28, 0x9F, 0xE9, 0x21, + 0x94, 0x30, 0x2D, 0x3D, 0x93, 0x01, 0x23, 0xE1, + 0x25, 0xD9, 0x5F, 0x8C, 0xC5, 0x89, 0x30, 0x66, + 0x17, 0xA8, 0xC1, 0xFB, 0x06, 0x9C, 0xB3, 0x59, + 0xD6, 0xCB, 0xCA, 0xFC, 0x5F, 0xF8, 0x4D, 0x8D, + 0xD8, 0xC2, 0x17, 0xE5, 0xEE, 0x7A, 0xD9, 0x52, + 0x03, 0x81, 0x5A, 0xE4, 0x1E, 0xD3, 0x2E, 0x01, + 0xBF, 0x27, 0x11, 0xA6, 0x87, 0x71, 0x3E, 0x43 + }, + { + 0xC3, 0x2F, 0x2E, 0x20, 0x74, 0x3E, 0xAB, 0x0B, + 0x70, 0x82, 0xE8, 0x43, 0xE9, 0x25, 0x49, 0x0A, + 0x27, 0xCC, 0x5A, 0x36, 0xC6, 0xD4, 0xBC, 0x4C, + 0x18, 0x71, 0x47, 0x89, 0xAA, 0x9A, 0xB7, 0x02, + 0x69, 0x16, 0xF0, 0x1A, 0xD4, 0x5A, 0x8A, 0x59, + 0x27, 0x3E, 0x5E, 0x62, 0x93, 0x89, 0xEC, 0x9B, + 0x74, 0xBE, 0x57, 0x60, 0x94, 0x25, 0xF8, 0xE4, + 0xF8, 0x6D, 0xCC, 0x01, 0x78, 0x61, 0xEB, 0x69 + }, + { + 0xCC, 0x13, 0x25, 0xB0, 0x37, 0x2A, 0xCF, 0xF1, + 0x32, 0xC1, 0x54, 0xA5, 0xE4, 0x00, 0x8B, 0x44, + 0x0D, 0xFD, 0x9D, 0x40, 0x08, 0x70, 0x71, 0xE0, + 0xCF, 0x5F, 0x37, 0x01, 0x68, 0x45, 0x54, 0x46, + 0xEF, 0xB1, 0xF0, 0x70, 0x18, 0x18, 0xC8, 0xC4, + 0xF9, 0xE0, 0xFB, 0x58, 0xAF, 0x9F, 0xAB, 0x86, + 0x1E, 0xEB, 0x05, 0xC8, 0xE4, 0x0D, 0x20, 0xC9, + 0x99, 0x60, 0xC6, 0xDD, 0x7B, 0x1B, 0xF2, 0xDC + }, + { + 0x77, 0x54, 0x4F, 0x8B, 0xF4, 0x49, 0x75, 0x53, + 0xC2, 0xCD, 0x2C, 0xF5, 0xF1, 0xCC, 0xC5, 0xA4, + 0xAE, 0xAA, 0x7B, 0xD3, 0x69, 0xDB, 0xEF, 0x3C, + 0x6D, 0x46, 0x90, 0xBB, 0x7A, 0x2C, 0x6D, 0x5D, + 0x0D, 0xFB, 0x47, 0xD9, 0x43, 0xCE, 0xA4, 0xE9, + 0x15, 0x5F, 0xB1, 0x84, 0xCF, 0xDD, 0xA0, 0xD8, + 0x38, 0x5E, 0xD1, 0xAD, 0x7D, 0x34, 0x8A, 0xB5, + 0x2F, 0xA5, 0x64, 0x21, 0xE0, 0x31, 0x52, 0xAB + }, + { + 0xCA, 0x3C, 0x64, 0x26, 0x0A, 0xEA, 0xE4, 0x5D, + 0xC4, 0x67, 0x02, 0xA3, 0x7D, 0xB6, 0x52, 0xDB, + 0x28, 0x99, 0x1C, 0x51, 0xD2, 0x88, 0xFE, 0xAC, + 0x61, 0xA6, 0x8C, 0x7C, 0x83, 0x3F, 0x01, 0x5E, + 0x93, 0xE6, 0x53, 0x30, 0x9D, 0x0A, 0x84, 0x48, + 0xAD, 0x20, 0x78, 0xBC, 0x32, 0xBC, 0x60, 0x63, + 0xAA, 0x17, 0x85, 0x82, 0x87, 0x2A, 0x99, 0x7F, + 0xD6, 0x74, 0x0E, 0xF8, 0x82, 0xB9, 0xCC, 0x19 + }, + { + 0xD2, 0x1D, 0x72, 0x15, 0x60, 0x11, 0xCF, 0x4C, + 0xAD, 0xFB, 0x5B, 0x9B, 0xF3, 0x0F, 0x81, 0x37, + 0xA8, 0xAC, 0xB9, 0x83, 0xBE, 0x18, 0x46, 0x70, + 0x83, 0x4B, 0x37, 0x67, 0x63, 0x58, 0xAD, 0xD3, + 0x6B, 0xEC, 0x05, 0x20, 0xC4, 0xCF, 0x72, 0x2F, + 0x84, 0x32, 0xAF, 0xC3, 0x4E, 0xCC, 0x90, 0xB2, + 0x94, 0xC7, 0x6F, 0xEA, 0x19, 0xAD, 0x8D, 0x4A, + 0x7F, 0x14, 0xFA, 0xA1, 0x26, 0x8F, 0x8D, 0x63 + }, + { + 0x8A, 0x2E, 0x5D, 0xA7, 0x69, 0xD4, 0x09, 0x81, + 0x00, 0x5D, 0xD4, 0xF9, 0xDD, 0xDB, 0x9B, 0x39, + 0x3C, 0x4B, 0x32, 0xA7, 0x2C, 0xBF, 0xB0, 0x5B, + 0xDA, 0x38, 0x1E, 0x38, 0x6C, 0xE4, 0x59, 0x0A, + 0xDB, 0x19, 0x19, 0xC3, 0xA3, 0x8F, 0x8D, 0x8F, + 0x6A, 0x64, 0x2F, 0xAF, 0x8C, 0xC1, 0x5D, 0x4A, + 0x9B, 0x89, 0xFC, 0x9B, 0xF2, 0xCD, 0xEE, 0xA8, + 0xC2, 0xC4, 0xF5, 0x82, 0xBA, 0xBA, 0x97, 0x55 + }, + { + 0xC8, 0x67, 0xD8, 0xB5, 0x80, 0x78, 0xA7, 0x91, + 0x25, 0x8C, 0xCA, 0x56, 0x6A, 0x95, 0xD5, 0xAA, + 0xCE, 0x47, 0xAA, 0x0C, 0xFB, 0xD5, 0xD2, 0x57, + 0x2E, 0x27, 0xA8, 0x11, 0x46, 0xC1, 0x0F, 0x6A, + 0xE8, 0xE3, 0xC9, 0xA3, 0x38, 0x5B, 0xB6, 0x0F, + 0x78, 0x5B, 0xA0, 0xD1, 0x1F, 0x02, 0x16, 0xB9, + 0x46, 0x97, 0xD4, 0x2C, 0x32, 0x65, 0x22, 0xB7, + 0xDB, 0xF2, 0xB0, 0x46, 0x7E, 0xC5, 0x66, 0x95 + }, + { + 0x96, 0xF5, 0x6E, 0xD3, 0x56, 0xC7, 0x96, 0xCD, + 0x8D, 0x0B, 0xE3, 0x65, 0xC7, 0x5A, 0xD5, 0xB6, + 0xCF, 0x95, 0x11, 0x9A, 0x56, 0x5A, 0x1D, 0xEB, + 0x0E, 0x1C, 0x22, 0x2D, 0xC6, 0x98, 0xE2, 0x4F, + 0xF2, 0x46, 0x78, 0x14, 0xD2, 0x6C, 0xB6, 0x1D, + 0x79, 0xC6, 0x77, 0xE6, 0x98, 0xD5, 0xE8, 0x68, + 0xA2, 0x09, 0x40, 0x2E, 0x25, 0xFB, 0xBF, 0xA8, + 0xDC, 0x51, 0xE7, 0x04, 0x23, 0x31, 0x69, 0x32 + }, + { + 0x64, 0x98, 0x50, 0xF5, 0x3A, 0x0C, 0x21, 0x8A, + 0xFE, 0xE7, 0x7F, 0xC1, 0xED, 0x78, 0xF4, 0x35, + 0x96, 0xB5, 0x3E, 0x9C, 0x7D, 0x61, 0x35, 0x2E, + 0x55, 0x9C, 0x17, 0xD7, 0x10, 0x37, 0x5D, 0x6F, + 0xDF, 0x6A, 0x31, 0xDE, 0x20, 0xD5, 0x7F, 0xB2, + 0x63, 0x57, 0xC0, 0x4E, 0x89, 0x50, 0xE4, 0xFD, + 0x17, 0xEA, 0xEF, 0x84, 0x51, 0x24, 0xEA, 0xED, + 0xF3, 0xA1, 0x6E, 0xDF, 0x08, 0x86, 0xE1, 0x83 + }, + { + 0x25, 0x57, 0x9E, 0xE8, 0x24, 0xFB, 0x4D, 0xB9, + 0xBD, 0x0B, 0x48, 0xA0, 0x6C, 0x0D, 0x6E, 0x6D, + 0x40, 0x55, 0x63, 0xCD, 0xE5, 0xFD, 0xB1, 0x1C, + 0x18, 0xDA, 0x74, 0x11, 0x0B, 0x6C, 0xD3, 0x5C, + 0x59, 0x74, 0x83, 0x4C, 0xDA, 0x48, 0x46, 0x78, + 0xC6, 0x6F, 0x92, 0x4C, 0xFC, 0x5F, 0x12, 0x10, + 0x31, 0x60, 0x49, 0x84, 0x06, 0x57, 0x18, 0xA6, + 0x1E, 0xBF, 0x76, 0x9B, 0x7A, 0x90, 0x06, 0x5A + }, + { + 0xD0, 0x6C, 0x92, 0xFB, 0xBF, 0x4F, 0x3F, 0x06, + 0x8F, 0xBA, 0x7D, 0x32, 0x22, 0x3C, 0xFB, 0xE3, + 0x28, 0x99, 0x81, 0x9E, 0xD4, 0x4B, 0xB5, 0xA2, + 0x15, 0x27, 0x7B, 0x7B, 0xAD, 0xC5, 0xC0, 0xFF, + 0xE6, 0x8A, 0x83, 0xB7, 0x43, 0xBA, 0xA6, 0xC4, + 0x36, 0x24, 0x27, 0x9D, 0x40, 0x9D, 0xF3, 0xF7, + 0x9F, 0xCA, 0x0F, 0x04, 0x1C, 0x76, 0x2C, 0x0E, + 0x62, 0x4A, 0xB9, 0x0B, 0xAB, 0x66, 0x16, 0x26 + }, + { + 0x83, 0xE9, 0xE0, 0x80, 0x8E, 0x80, 0xD3, 0x49, + 0x24, 0xFF, 0x02, 0xCE, 0x80, 0x3F, 0x02, 0x18, + 0xB9, 0x3F, 0x20, 0x8D, 0x71, 0x73, 0x19, 0xF6, + 0x8D, 0xEA, 0x20, 0xDA, 0x2E, 0x91, 0x0B, 0x67, + 0x02, 0xF5, 0x81, 0x6E, 0xD9, 0xD1, 0x11, 0xFA, + 0xB2, 0x57, 0xD3, 0x2A, 0x5E, 0xF8, 0x9E, 0x70, + 0x68, 0xF4, 0xD2, 0x2D, 0xFE, 0x6F, 0x8C, 0x73, + 0x52, 0x5D, 0x93, 0x26, 0xE6, 0x76, 0xC3, 0x7A + }, + { + 0xFC, 0xDC, 0x4D, 0x30, 0x8B, 0x2A, 0xB4, 0x84, + 0x30, 0x36, 0x60, 0x74, 0x56, 0xE4, 0x2F, 0xD4, + 0x0D, 0x52, 0xF6, 0x9D, 0x88, 0xEF, 0x03, 0x31, + 0xB6, 0x59, 0xD3, 0x90, 0x20, 0xE4, 0xDE, 0x83, + 0xFB, 0xE2, 0xA1, 0xD8, 0x42, 0x91, 0x25, 0x67, + 0x29, 0x0C, 0xD7, 0x1B, 0x4E, 0x25, 0xD7, 0xB7, + 0xA6, 0xA4, 0x36, 0xA8, 0x89, 0x52, 0xBC, 0xF7, + 0x37, 0x71, 0x6A, 0x23, 0x0B, 0x93, 0xE0, 0x2A + }, + { + 0x0C, 0xD3, 0x6E, 0x93, 0x3A, 0x34, 0xC8, 0xBA, + 0xC6, 0x86, 0x92, 0x81, 0x36, 0x94, 0x0D, 0x55, + 0x9A, 0xD5, 0x78, 0x9E, 0x88, 0x70, 0xB9, 0x6D, + 0x2D, 0xD6, 0x10, 0xEB, 0xEF, 0xF0, 0xAF, 0x29, + 0xA7, 0x00, 0x59, 0xE4, 0x3A, 0x42, 0x7E, 0xAB, + 0x72, 0x11, 0x97, 0x91, 0xA5, 0x46, 0xF6, 0x86, + 0x2A, 0x4D, 0x57, 0x29, 0x4D, 0x54, 0xF4, 0x7D, + 0x0B, 0x75, 0x06, 0x79, 0x7B, 0xE3, 0xB5, 0x3D + }, + { + 0x9D, 0x8D, 0x31, 0xB1, 0xEC, 0x08, 0x41, 0x99, + 0xE5, 0x9D, 0x9E, 0x3A, 0x16, 0x30, 0xBA, 0x42, + 0x9D, 0xF8, 0x86, 0xA1, 0xAD, 0xFB, 0x66, 0x80, + 0x8B, 0xE6, 0x67, 0x42, 0xB6, 0xBC, 0x5A, 0x2E, + 0x18, 0xCE, 0xE0, 0x21, 0x0F, 0xF0, 0xB7, 0xBD, + 0x93, 0xB2, 0x68, 0x0C, 0x86, 0x46, 0xA3, 0xF9, + 0x6E, 0x96, 0x9D, 0xCB, 0x9E, 0x94, 0xCA, 0xF0, + 0x74, 0x91, 0x7F, 0x95, 0x0E, 0x81, 0x40, 0xF8 + }, + { + 0x91, 0x66, 0x54, 0x02, 0x74, 0xFE, 0xCB, 0x73, + 0x7C, 0x80, 0x59, 0xEE, 0x83, 0xCD, 0x08, 0xB7, + 0xEB, 0x2F, 0xBF, 0x3B, 0x74, 0x5F, 0x02, 0x57, + 0x54, 0x71, 0xDA, 0x9D, 0x80, 0xD6, 0x2E, 0xE3, + 0x85, 0x8B, 0xDF, 0xB3, 0x74, 0x06, 0x2C, 0xCF, + 0x55, 0xE1, 0xA9, 0xA1, 0x80, 0xEF, 0x6B, 0xE0, + 0x72, 0x6C, 0x4E, 0xB5, 0xB3, 0x14, 0xA4, 0x4A, + 0x96, 0x41, 0x9D, 0x35, 0x14, 0x6D, 0x94, 0xC1 + }, + { + 0xFE, 0xEE, 0xAC, 0x60, 0xDE, 0xA7, 0x94, 0xDC, + 0x48, 0x15, 0x40, 0xD9, 0x26, 0x6C, 0x17, 0x00, + 0x5C, 0x3F, 0x4B, 0x9E, 0xA8, 0x4C, 0xFF, 0x75, + 0xD4, 0x9C, 0xF7, 0x7E, 0xB5, 0x87, 0xD9, 0x5D, + 0x78, 0xB1, 0x05, 0xE9, 0x6E, 0x19, 0xE5, 0xDB, + 0xFF, 0x71, 0x00, 0x5A, 0x8A, 0x5A, 0x0A, 0x11, + 0xE5, 0x41, 0x15, 0xC6, 0x73, 0x9D, 0x24, 0x19, + 0x06, 0xB7, 0x38, 0x20, 0xEE, 0x1B, 0xCF, 0x03 + }, + { + 0x17, 0xC7, 0x00, 0x34, 0xD5, 0x8C, 0xCD, 0x07, + 0x65, 0xAC, 0xB0, 0x13, 0xF4, 0x10, 0xCE, 0xF3, + 0x8E, 0xA0, 0xD0, 0x5F, 0x2B, 0x7D, 0xB4, 0xB4, + 0x3B, 0xD1, 0x1F, 0xEC, 0x50, 0xA2, 0x06, 0x01, + 0x1D, 0x13, 0x3C, 0x6F, 0xEE, 0xCF, 0x7E, 0x01, + 0x8E, 0xC6, 0x9A, 0xC7, 0xEB, 0xE5, 0x8F, 0xB6, + 0x27, 0xC6, 0xA6, 0x98, 0x89, 0xD8, 0xF8, 0x34, + 0x0A, 0x5B, 0x7D, 0x07, 0x12, 0x00, 0x18, 0x23 + }, + { + 0x67, 0x8C, 0x55, 0xEC, 0x8D, 0xAE, 0xA5, 0xAA, + 0xE8, 0x01, 0xB6, 0x46, 0x1E, 0x8E, 0xE3, 0x15, + 0xBC, 0x58, 0xE6, 0xCF, 0x0F, 0x4B, 0x93, 0x29, + 0x50, 0xA5, 0x50, 0x19, 0x50, 0x7B, 0x04, 0x6B, + 0x8A, 0x4E, 0x3F, 0x54, 0xC4, 0x37, 0x7E, 0x49, + 0x1A, 0x55, 0xB0, 0x56, 0x60, 0x9C, 0xDF, 0x71, + 0xE1, 0xC4, 0x6E, 0x79, 0xAE, 0xDC, 0x4A, 0x84, + 0xE6, 0x2F, 0x21, 0x6A, 0x2F, 0x7F, 0x5A, 0xFC + }, + { + 0x00, 0x59, 0x6C, 0x1F, 0xDC, 0x1C, 0xF9, 0x7E, + 0xFC, 0x0D, 0x01, 0xE9, 0xC2, 0xD2, 0xC7, 0x42, + 0xFF, 0x1F, 0x8E, 0x37, 0x57, 0x9F, 0x65, 0xEC, + 0xEF, 0x28, 0x0E, 0x4D, 0x7C, 0x21, 0x66, 0x72, + 0xA1, 0xBE, 0x3E, 0xA7, 0xBB, 0x50, 0x70, 0x29, + 0x39, 0x40, 0xC0, 0x4C, 0x93, 0xE9, 0x0D, 0xA9, + 0xAE, 0x04, 0xCD, 0x4E, 0x3E, 0x4E, 0xDA, 0x16, + 0x90, 0x53, 0x72, 0x67, 0x10, 0xB2, 0x97, 0x68 + }, + { + 0xF7, 0x61, 0x3B, 0x2E, 0xC4, 0xC5, 0x5B, 0xF3, + 0xC1, 0x47, 0xB9, 0x04, 0x17, 0x50, 0x9D, 0x1E, + 0x41, 0xE1, 0x6E, 0x93, 0xD6, 0x80, 0x2D, 0x58, + 0xD6, 0xD1, 0x4C, 0x8D, 0x7B, 0x72, 0x88, 0xED, + 0xBA, 0x68, 0x90, 0x56, 0xB0, 0x42, 0x87, 0x3D, + 0x96, 0xD4, 0x6B, 0xAE, 0x38, 0xA6, 0x46, 0x11, + 0xF3, 0x12, 0xF3, 0xFF, 0x01, 0xB0, 0x92, 0xBA, + 0xEA, 0x77, 0x00, 0xF5, 0x7D, 0xD5, 0xD0, 0x12 + }, + { + 0x40, 0x07, 0xFB, 0x96, 0xB1, 0x1A, 0xC7, 0x6F, + 0x09, 0x31, 0x13, 0x69, 0x59, 0xC3, 0x46, 0x33, + 0xFA, 0x96, 0x98, 0xEB, 0x1C, 0x2B, 0xB5, 0x77, + 0xD8, 0x09, 0xA5, 0x58, 0x29, 0xCC, 0xD0, 0xBD, + 0x09, 0x44, 0x3C, 0xB7, 0xDC, 0xF1, 0x28, 0xE4, + 0x35, 0x5B, 0x73, 0x15, 0xC8, 0x99, 0x1C, 0xEC, + 0x35, 0xDD, 0x3E, 0x4B, 0xE1, 0xF4, 0x59, 0xEC, + 0x99, 0x5B, 0x2F, 0xB8, 0x6F, 0xAD, 0xB5, 0x74 + }, + { + 0xCC, 0x05, 0xB8, 0x4E, 0x1C, 0x80, 0x20, 0x80, + 0xB6, 0x85, 0x08, 0xFE, 0x1A, 0x59, 0xDD, 0x16, + 0xC7, 0x05, 0xC8, 0x3A, 0x1A, 0x0B, 0xF5, 0x91, + 0x74, 0xA3, 0x9A, 0x6D, 0xCB, 0x67, 0xD1, 0x7E, + 0xAB, 0x3A, 0x2C, 0xEA, 0x9C, 0xEA, 0xD3, 0xA2, + 0xDF, 0x99, 0x46, 0x16, 0xE9, 0x51, 0x84, 0x33, + 0x28, 0x4A, 0x9D, 0x3F, 0x30, 0x5C, 0xAC, 0x95, + 0x76, 0x38, 0xD6, 0x93, 0xF1, 0x15, 0xB5, 0x97 + }, + { + 0xA1, 0x2A, 0xCC, 0xA0, 0x69, 0xBD, 0x0A, 0x42, + 0xA5, 0x19, 0x5D, 0xDC, 0xA3, 0x31, 0x34, 0xC3, + 0x95, 0x72, 0x87, 0x07, 0x9E, 0x99, 0xFB, 0xA3, + 0x43, 0x11, 0x8D, 0xBF, 0x46, 0x98, 0xCE, 0x18, + 0x15, 0x76, 0x40, 0x41, 0x18, 0x0B, 0xA3, 0xC7, + 0x7E, 0x51, 0x9B, 0x89, 0xB6, 0x89, 0xF9, 0x41, + 0x89, 0x13, 0xEC, 0x31, 0x54, 0xC2, 0xDF, 0xA4, + 0x49, 0x45, 0xA5, 0x29, 0xEA, 0xB7, 0xC4, 0x68 + }, + { + 0xF2, 0x84, 0xB2, 0x72, 0xC5, 0xDC, 0xDB, 0x02, + 0xF7, 0x69, 0x0F, 0x9E, 0xA8, 0x03, 0x9F, 0x30, + 0x45, 0x7C, 0x2E, 0x1B, 0x74, 0xDB, 0x70, 0x54, + 0x63, 0x7A, 0xC7, 0xB8, 0xF3, 0x8C, 0xD5, 0x24, + 0x14, 0xBB, 0x0B, 0xDD, 0x85, 0x4D, 0x9A, 0xC8, + 0x89, 0x62, 0x56, 0xF9, 0xA3, 0xAB, 0x82, 0x9B, + 0x5A, 0x92, 0x7D, 0x6E, 0x52, 0x2B, 0xCF, 0x98, + 0xE2, 0x7D, 0x70, 0x98, 0x52, 0x75, 0x71, 0x34 + }, + { + 0x9A, 0xFF, 0x2C, 0x1B, 0xEC, 0x77, 0x42, 0xE1, + 0xF7, 0x5F, 0xF2, 0x4E, 0x5E, 0x58, 0xA6, 0x6B, + 0x26, 0xC4, 0x7A, 0x14, 0x0E, 0x51, 0x2E, 0x7B, + 0xFE, 0x16, 0xC6, 0x0C, 0x4E, 0xB2, 0x48, 0x30, + 0xF1, 0x3E, 0x36, 0xE3, 0xEA, 0x4E, 0x6E, 0x7F, + 0xA5, 0x03, 0x53, 0x91, 0x45, 0x09, 0xDB, 0x2E, + 0xE2, 0xA7, 0xED, 0x2E, 0xAD, 0xF8, 0x32, 0x8C, + 0xB0, 0x93, 0xCB, 0xA2, 0xB6, 0xF7, 0x72, 0x3D + }, + { + 0xEF, 0x4C, 0x52, 0x57, 0x7A, 0x92, 0x86, 0x04, + 0x54, 0xA2, 0x9C, 0x1C, 0x03, 0x00, 0x66, 0xB3, + 0xC1, 0x81, 0xE9, 0x4F, 0x60, 0xA9, 0x58, 0x91, + 0xF6, 0x18, 0x11, 0x29, 0x24, 0x66, 0x64, 0x64, + 0x9B, 0x1A, 0x92, 0x79, 0xA0, 0xDF, 0xDA, 0xB4, + 0xE8, 0x02, 0xCF, 0x14, 0x56, 0x58, 0x28, 0x98, + 0xD5, 0x08, 0xE3, 0x6D, 0xF5, 0x67, 0xEF, 0xB6, + 0x27, 0x2C, 0x53, 0x74, 0x16, 0x0A, 0x1A, 0xBC + }, + { + 0x2A, 0xDD, 0xC2, 0x32, 0x63, 0x65, 0x74, 0xA9, + 0xF0, 0x4F, 0x63, 0x11, 0x70, 0x34, 0x6E, 0x29, + 0xA0, 0x07, 0x49, 0xD3, 0x7C, 0x81, 0x36, 0x3E, + 0xFC, 0xA2, 0x4E, 0x68, 0xA4, 0x6D, 0xB1, 0xA4, + 0x77, 0xB9, 0xE3, 0x42, 0x41, 0x86, 0x0B, 0x92, + 0x91, 0xD0, 0xE2, 0xC9, 0x61, 0x95, 0xCA, 0x28, + 0xAE, 0x20, 0x48, 0x5A, 0x96, 0x1D, 0xBB, 0x89, + 0xA3, 0x82, 0x85, 0x39, 0x8B, 0x2B, 0x11, 0x0C + }, + { + 0xE2, 0xFD, 0xE6, 0x1A, 0x6F, 0x1A, 0xCE, 0x4E, + 0x57, 0x80, 0xE2, 0x47, 0x71, 0x70, 0xD2, 0x32, + 0xF0, 0xC0, 0x10, 0xB2, 0x1F, 0xC7, 0x34, 0x42, + 0xA3, 0x32, 0xF5, 0xDC, 0xA6, 0xC2, 0x68, 0x20, + 0x73, 0xCD, 0x3D, 0x48, 0x94, 0x84, 0xF2, 0x02, + 0x4A, 0xF9, 0x1A, 0x1B, 0xCB, 0x12, 0xC2, 0x15, + 0x95, 0x89, 0xF6, 0x29, 0x48, 0x2A, 0x04, 0x74, + 0x0E, 0x27, 0x70, 0x4F, 0x24, 0xFC, 0x9F, 0x16 + }, + { + 0x71, 0x54, 0x7A, 0xA3, 0x4B, 0xFF, 0x38, 0xF1, + 0x01, 0x30, 0xBD, 0x89, 0xDC, 0xCC, 0xFE, 0x50, + 0x7C, 0x51, 0x3F, 0x73, 0x24, 0x3C, 0x2E, 0xF6, + 0xE4, 0x46, 0xA1, 0xD0, 0x91, 0x64, 0xB4, 0x63, + 0x6D, 0x0D, 0x15, 0x98, 0x2E, 0xF3, 0x96, 0xBD, + 0xCC, 0xD3, 0x15, 0x87, 0xE8, 0x8A, 0x22, 0x9A, + 0x93, 0x8F, 0x84, 0xB7, 0x92, 0xA7, 0x22, 0x2E, + 0x04, 0x10, 0x32, 0x4B, 0xB2, 0xCC, 0xAB, 0x93 + }, + { + 0xB9, 0x06, 0x3A, 0xD0, 0xE8, 0x85, 0x21, 0x23, + 0xCD, 0x48, 0xC2, 0x61, 0xA9, 0x75, 0x85, 0xA0, + 0xD2, 0x8C, 0x14, 0x6E, 0xCE, 0x6E, 0x0C, 0x86, + 0x87, 0x46, 0xB7, 0xEF, 0xB4, 0x07, 0x29, 0x8F, + 0x6D, 0x82, 0x04, 0x03, 0xC2, 0x55, 0x38, 0xF9, + 0xF8, 0x17, 0xB6, 0xCF, 0x7A, 0x89, 0x9D, 0xF9, + 0xF8, 0x6B, 0x55, 0xFE, 0xCD, 0xCE, 0xE5, 0x6F, + 0xEF, 0x5D, 0xF7, 0x21, 0x70, 0xF4, 0xD4, 0x67 + }, + { + 0x8B, 0xBB, 0xCE, 0xDB, 0xE8, 0xFD, 0x19, 0x0A, + 0xCB, 0xBD, 0x4A, 0xBB, 0xB8, 0x7D, 0x0F, 0xAF, + 0x21, 0x3A, 0xFE, 0x46, 0x50, 0x09, 0x89, 0xAC, + 0xC2, 0x85, 0x65, 0x17, 0x72, 0xFC, 0x6F, 0x89, + 0x26, 0xC6, 0x80, 0x4D, 0x4B, 0x7A, 0x3B, 0x91, + 0x56, 0x89, 0x03, 0x61, 0x28, 0x5E, 0xD8, 0x2A, + 0x19, 0x0D, 0x64, 0x08, 0x31, 0x7E, 0x44, 0xBD, + 0x03, 0x9E, 0x08, 0x46, 0x18, 0xB9, 0xF9, 0xF8 + }, + { + 0x05, 0xA5, 0x03, 0xA8, 0x64, 0xC5, 0x38, 0x5C, + 0x2E, 0xAC, 0x34, 0x12, 0x14, 0xD1, 0xAE, 0x47, + 0x93, 0x9B, 0x62, 0xDA, 0xB9, 0x50, 0x3F, 0xA5, + 0x14, 0x53, 0xCA, 0x70, 0xF3, 0xA5, 0x05, 0x23, + 0xFC, 0xD7, 0x12, 0x5E, 0xA7, 0xD4, 0xDA, 0x34, + 0xF8, 0x8E, 0x94, 0x53, 0x45, 0x0A, 0x28, 0x68, + 0x7F, 0x5D, 0xC7, 0x41, 0xE0, 0x9E, 0x83, 0xA7, + 0xFD, 0x94, 0x40, 0x8A, 0xA6, 0x6F, 0xA0, 0xA1 + }, + { + 0xC5, 0x5D, 0x65, 0x63, 0x85, 0x75, 0x38, 0xF0, + 0x66, 0x38, 0x02, 0xEC, 0x6A, 0x1F, 0x84, 0xE2, + 0xD1, 0xE7, 0x8B, 0x2C, 0x31, 0x4F, 0x09, 0x0C, + 0xBA, 0x7F, 0x40, 0x53, 0x88, 0x60, 0x1C, 0x56, + 0x3C, 0xB5, 0xCF, 0x33, 0xA6, 0xAE, 0x0C, 0x23, + 0x90, 0x73, 0xFC, 0x76, 0xCB, 0x6C, 0x40, 0x10, + 0xF2, 0x68, 0x3E, 0xC8, 0x82, 0xB7, 0xA8, 0xAD, + 0x63, 0x18, 0x41, 0xD3, 0xE8, 0x3D, 0x0B, 0x6D + }, + { + 0x2C, 0xD7, 0xF7, 0xFB, 0x2B, 0x0D, 0xFF, 0xB7, + 0xBA, 0x43, 0x2D, 0x72, 0xD3, 0x9C, 0x2E, 0x05, + 0xBD, 0xAE, 0x07, 0xF6, 0x5A, 0x90, 0x34, 0x71, + 0x62, 0x0A, 0x8D, 0x16, 0xC8, 0xA6, 0x84, 0xB5, + 0x20, 0xCC, 0x5C, 0x8F, 0xBF, 0xC4, 0xC0, 0x30, + 0xD0, 0x2C, 0x55, 0x00, 0x53, 0x9D, 0xBD, 0x6E, + 0x44, 0x20, 0xC2, 0x69, 0x9E, 0x93, 0xBC, 0xD6, + 0x52, 0x45, 0x1E, 0xBF, 0x6F, 0x39, 0x55, 0x34 + }, + { + 0x2D, 0x61, 0xF1, 0x22, 0x9E, 0x15, 0x25, 0x26, + 0x94, 0x0F, 0x85, 0x4A, 0x76, 0x87, 0xA9, 0x18, + 0x71, 0x98, 0xEB, 0x78, 0x72, 0x1C, 0x8C, 0x0B, + 0x3B, 0x84, 0x88, 0x1B, 0x50, 0x5B, 0x43, 0x25, + 0xC2, 0x45, 0x34, 0xD6, 0x0D, 0xCC, 0x0A, 0xD1, + 0xA7, 0xF7, 0xBA, 0xA9, 0xFB, 0x0F, 0x0A, 0x6B, + 0x11, 0x22, 0xFF, 0xE7, 0xC5, 0xE6, 0xA3, 0xFA, + 0x41, 0x3B, 0x78, 0xEE, 0xA0, 0x3A, 0xB0, 0xE4 + }, + { + 0x09, 0x64, 0xFA, 0x25, 0xDF, 0x1E, 0xA9, 0x2C, + 0x58, 0x6B, 0x05, 0x9F, 0x29, 0x8F, 0x33, 0xFF, + 0xA5, 0x2E, 0x12, 0x50, 0xA4, 0x2C, 0x81, 0x50, + 0x85, 0x6D, 0x90, 0xB8, 0x70, 0xE9, 0xC4, 0x9B, + 0xED, 0xEB, 0x9D, 0x61, 0x7A, 0x29, 0x1D, 0xB2, + 0xEB, 0xEB, 0xAC, 0xE2, 0xDD, 0xF5, 0xDD, 0x29, + 0x2E, 0xF2, 0xD3, 0x31, 0x63, 0x7F, 0xCF, 0xB9, + 0xA8, 0x83, 0xC9, 0x6D, 0x7E, 0x15, 0xF7, 0x88 + }, + { + 0x15, 0x27, 0xE1, 0x8D, 0x80, 0xB6, 0x92, 0x44, + 0xF7, 0x9F, 0xD5, 0x40, 0xDF, 0xC6, 0x54, 0xBD, + 0x9E, 0x48, 0x30, 0xC0, 0x29, 0x8A, 0x87, 0x56, + 0x19, 0xAD, 0xE5, 0x8D, 0xFE, 0x63, 0x52, 0x02, + 0x4D, 0x4E, 0x50, 0xFB, 0xB0, 0xD4, 0x90, 0xE4, + 0x05, 0x33, 0x34, 0x09, 0x75, 0xE5, 0x0B, 0x46, + 0xB0, 0xFF, 0x4A, 0xBE, 0xC9, 0x1E, 0xC4, 0xE7, + 0x24, 0xFF, 0x07, 0xE9, 0xC5, 0x69, 0x93, 0x78 + }, + { + 0xD7, 0x51, 0xF8, 0xD8, 0xBE, 0x5B, 0x1A, 0xAF, + 0x8A, 0x88, 0x8C, 0xCB, 0x39, 0xFE, 0x42, 0xC4, + 0xC7, 0x0B, 0x3A, 0xDF, 0xBD, 0x80, 0xF7, 0x62, + 0x76, 0x63, 0xD9, 0xEF, 0x00, 0x5B, 0x58, 0x1B, + 0xF4, 0x58, 0x80, 0xC3, 0xE4, 0x4C, 0x3F, 0x57, + 0x02, 0x3F, 0x9D, 0x33, 0xF5, 0xC7, 0xED, 0x85, + 0xAE, 0x87, 0xF6, 0x42, 0x8E, 0x05, 0x60, 0x09, + 0x33, 0x9A, 0x7B, 0xA9, 0xC3, 0xF2, 0xB9, 0x81 + }, + { + 0xFA, 0xD6, 0xCA, 0x26, 0xD1, 0xE8, 0xA7, 0xF1, + 0xC4, 0xF9, 0x79, 0xAF, 0x6B, 0x0F, 0x00, 0xF7, + 0xB9, 0x8A, 0xE2, 0x83, 0x8C, 0x20, 0x97, 0x4F, + 0x4E, 0x88, 0x32, 0x8D, 0x52, 0xC0, 0x14, 0x6A, + 0xDE, 0x7A, 0xC4, 0xD2, 0x94, 0xD2, 0xDD, 0x98, + 0x24, 0x6B, 0x14, 0xFC, 0x28, 0xF1, 0xB0, 0xBD, + 0x5E, 0xCA, 0x82, 0x63, 0x34, 0xE8, 0x18, 0x12, + 0x3B, 0xEE, 0x21, 0xF9, 0x27, 0x18, 0xBE, 0x52 + }, + { + 0xD1, 0x5C, 0x5B, 0x9E, 0x8C, 0x3A, 0xAB, 0xD9, + 0x4C, 0x25, 0xDA, 0xFE, 0x5C, 0x20, 0x8E, 0x27, + 0x25, 0xE2, 0xB2, 0x39, 0xD7, 0x4B, 0x27, 0xB9, + 0x40, 0x3B, 0x69, 0x2E, 0xD4, 0x02, 0x7C, 0xD0, + 0xBC, 0x4C, 0x43, 0x35, 0x54, 0x6B, 0x12, 0x64, + 0xC8, 0x07, 0xCC, 0xED, 0x74, 0x7C, 0x7C, 0xBE, + 0xDC, 0x67, 0x18, 0x6A, 0xD2, 0x35, 0xC9, 0xFB, + 0xA6, 0xCF, 0x68, 0xF0, 0x5F, 0x25, 0x93, 0xF0 + }, + { + 0x75, 0xF4, 0xD4, 0x58, 0xA2, 0x15, 0xA8, 0x4B, + 0x46, 0x0E, 0xDA, 0x48, 0x61, 0x32, 0x4C, 0x7F, + 0x52, 0x8B, 0x6D, 0xE2, 0x15, 0xDA, 0x2C, 0x8C, + 0x88, 0x41, 0x43, 0x2A, 0x84, 0x8D, 0xA9, 0x8F, + 0xB1, 0xEC, 0xF6, 0xC1, 0x62, 0xCF, 0xAA, 0xAF, + 0x46, 0x53, 0x97, 0x1D, 0x5B, 0x5C, 0xDE, 0x3B, + 0xF6, 0xD1, 0x48, 0xAF, 0x4B, 0x97, 0x08, 0xEE, + 0x1D, 0x05, 0x0F, 0x3C, 0x57, 0x0C, 0x2D, 0x84 + }, + { + 0xBF, 0x73, 0x18, 0xB3, 0x7F, 0xAA, 0xF0, 0x40, + 0x4A, 0x9C, 0xD1, 0xF0, 0xFD, 0xA4, 0x86, 0x7E, + 0x40, 0x05, 0x64, 0x68, 0x3C, 0x33, 0x94, 0x34, + 0xCB, 0x5C, 0xC8, 0x35, 0xEA, 0x60, 0x9F, 0x05, + 0xB2, 0xB6, 0xBA, 0xF3, 0x32, 0x26, 0x0D, 0xAA, + 0xDA, 0xFB, 0xB4, 0x24, 0x75, 0xE0, 0x7B, 0x64, + 0xAC, 0x11, 0x56, 0x27, 0xAD, 0x2A, 0xE8, 0xB1, + 0xF6, 0x22, 0x4C, 0x52, 0xD9, 0x0F, 0x8A, 0xCF + }, + { + 0x97, 0xD0, 0xEC, 0xE9, 0x22, 0x1F, 0x71, 0x95, + 0x67, 0xEC, 0xE8, 0x68, 0x50, 0x52, 0xA1, 0xD0, + 0x84, 0x4F, 0xA1, 0xB5, 0x26, 0x34, 0x66, 0xD0, + 0x39, 0x7B, 0x63, 0xBE, 0xA5, 0x35, 0x84, 0xF2, + 0x08, 0x26, 0x86, 0xE9, 0xEA, 0x8C, 0x61, 0x54, + 0x8C, 0x41, 0x9A, 0xC6, 0x55, 0x92, 0x7D, 0x38, + 0x87, 0x78, 0x0B, 0x69, 0x9B, 0x29, 0x69, 0xC9, + 0x2E, 0xD2, 0xF9, 0x4E, 0xA8, 0x5D, 0xCD, 0x2A + }, + { + 0x40, 0x99, 0xB4, 0x5B, 0x61, 0x28, 0xED, 0x40, + 0x12, 0x88, 0xEF, 0x71, 0x51, 0xFE, 0x8A, 0x46, + 0xC7, 0xAC, 0x0A, 0x6D, 0x45, 0x4E, 0x04, 0x31, + 0x17, 0x09, 0xFF, 0x01, 0x8A, 0xF9, 0xFA, 0xD6, + 0x3C, 0x44, 0x14, 0x16, 0xF8, 0x58, 0x8F, 0x94, + 0xE2, 0x6C, 0x07, 0x43, 0xAD, 0xD1, 0xB6, 0x19, + 0x3A, 0x70, 0x75, 0x2C, 0x1F, 0x87, 0x62, 0xC8, + 0x34, 0x7D, 0x98, 0x86, 0x2C, 0xDA, 0x12, 0x36 + }, + { + 0xEB, 0x54, 0xC3, 0x54, 0x24, 0xC0, 0x86, 0xAA, + 0xA0, 0x72, 0xB3, 0x7C, 0xF1, 0x69, 0x34, 0x07, + 0xE0, 0x7E, 0x65, 0xA8, 0x9C, 0x01, 0x1F, 0x7C, + 0xCA, 0x2E, 0xB6, 0x6D, 0xEB, 0x0A, 0xE8, 0xB8, + 0x92, 0x28, 0x5F, 0x15, 0x52, 0x1D, 0xBC, 0xF3, + 0x73, 0x5F, 0x87, 0x27, 0x60, 0xED, 0xE2, 0xB9, + 0x55, 0xAA, 0x29, 0x06, 0x86, 0xDC, 0x8D, 0xD2, + 0x24, 0xDB, 0xD1, 0xE9, 0x4E, 0xFE, 0xA2, 0x5D + }, + { + 0xFD, 0xCC, 0xB9, 0x74, 0x29, 0x1C, 0x96, 0x72, + 0x54, 0x70, 0xDD, 0xA7, 0x00, 0x74, 0xE4, 0xBA, + 0x56, 0x6C, 0x0A, 0x90, 0x2B, 0x71, 0x93, 0xAB, + 0x79, 0xD7, 0xBE, 0xFB, 0x37, 0xD5, 0x2A, 0xE3, + 0xF5, 0x4A, 0xA8, 0x10, 0xC3, 0xCF, 0x67, 0x79, + 0x1A, 0x1F, 0x8B, 0x25, 0xD6, 0x56, 0x08, 0x68, + 0x4D, 0xB3, 0x6C, 0x63, 0xB9, 0x09, 0xA9, 0x09, + 0x6D, 0x50, 0x28, 0xF2, 0x1E, 0x4A, 0x04, 0xFC + }, + { + 0x94, 0x33, 0x12, 0xB7, 0x06, 0x6C, 0x99, 0x37, + 0x8C, 0x50, 0xC8, 0x41, 0x04, 0x09, 0x81, 0x12, + 0x18, 0xF7, 0xA0, 0x4C, 0x11, 0x32, 0xCD, 0xB1, + 0x5B, 0xD7, 0x83, 0xCB, 0x10, 0x86, 0x5A, 0x98, + 0xE6, 0x1E, 0xCA, 0x9E, 0x95, 0x38, 0xEF, 0x07, + 0x5E, 0x66, 0xAF, 0x44, 0xB2, 0x20, 0x7D, 0x93, + 0x7E, 0xDF, 0x56, 0xAB, 0x2B, 0xA4, 0x2A, 0x76, + 0xA6, 0xC1, 0x82, 0xDC, 0x8E, 0xA1, 0x36, 0xFF + }, + { + 0xA9, 0x85, 0x76, 0x47, 0x54, 0xF7, 0x19, 0xEF, + 0xB1, 0xCD, 0x31, 0xE6, 0x10, 0x8E, 0x6A, 0xFD, + 0x36, 0xAE, 0x30, 0x35, 0xEE, 0xFC, 0xBC, 0x2C, + 0x0E, 0xA8, 0x12, 0xB5, 0x57, 0x99, 0x89, 0xA1, + 0x91, 0x98, 0x5A, 0x05, 0xF4, 0x1C, 0x09, 0xCF, + 0xF2, 0x1A, 0xC0, 0x2B, 0x58, 0x4F, 0xFD, 0xDF, + 0xDD, 0xBE, 0x64, 0x1F, 0x7E, 0xC1, 0xB9, 0x88, + 0xA3, 0x39, 0x58, 0xCA, 0x68, 0xEF, 0xC3, 0x77 + }, + { + 0x66, 0x2E, 0x53, 0x32, 0xAE, 0x35, 0xFD, 0x2B, + 0x16, 0x96, 0xD6, 0x60, 0xFF, 0x10, 0xA1, 0xD8, + 0x26, 0x17, 0x59, 0xC9, 0x30, 0xF7, 0x1E, 0x13, + 0x4E, 0xE8, 0xB5, 0x77, 0xCE, 0x28, 0x63, 0x5F, + 0xBC, 0x98, 0x5A, 0xD6, 0xCB, 0xF1, 0x22, 0x2E, + 0x48, 0xA9, 0x16, 0xE6, 0xEA, 0xD3, 0x1F, 0xF8, + 0x12, 0x4B, 0x19, 0xF2, 0x73, 0x60, 0x9A, 0x55, + 0x00, 0xD3, 0x0D, 0xB6, 0xC9, 0x5F, 0xFC, 0x4D + }, + { + 0x9B, 0x26, 0x80, 0x3D, 0x3F, 0x39, 0xF3, 0xD2, + 0xDF, 0x85, 0x64, 0x24, 0x03, 0xA5, 0x9A, 0x26, + 0x74, 0x26, 0x18, 0x74, 0x8E, 0xC0, 0x89, 0x7E, + 0xC7, 0x30, 0x95, 0xE6, 0x31, 0x4D, 0x6F, 0x0F, + 0x71, 0xF6, 0x2C, 0x0C, 0x4A, 0x04, 0xD6, 0x41, + 0x4B, 0x79, 0x68, 0xCC, 0x75, 0xD3, 0x0A, 0xA1, + 0xF5, 0x2B, 0xEF, 0xF7, 0xFD, 0x7D, 0x95, 0x53, + 0x85, 0xEC, 0x7B, 0x4C, 0x46, 0xA7, 0xEF, 0x2B + }, + { + 0x55, 0x23, 0x66, 0xF6, 0x87, 0xEB, 0xC2, 0x2D, + 0x84, 0x21, 0xE1, 0x11, 0x2F, 0x3A, 0xBF, 0x53, + 0xA5, 0xF8, 0x79, 0x61, 0x01, 0xA2, 0x38, 0xD2, + 0x27, 0x9F, 0x77, 0x11, 0x77, 0x2D, 0x42, 0x4F, + 0x39, 0x36, 0x9E, 0x95, 0x76, 0xE8, 0x34, 0x36, + 0x03, 0xB4, 0xC2, 0x4E, 0x11, 0x55, 0x24, 0xB2, + 0x19, 0xFF, 0xEE, 0xBE, 0xE5, 0x19, 0xA5, 0x69, + 0x6F, 0x84, 0x0C, 0x88, 0x3F, 0x7D, 0xA5, 0x45 + }, + { + 0xAB, 0xFB, 0xC9, 0xA9, 0xF3, 0x4A, 0xEF, 0x25, + 0x24, 0xE3, 0xCF, 0xD8, 0xE7, 0xE9, 0xF8, 0x14, + 0xEB, 0x56, 0xAB, 0xCE, 0x00, 0xA3, 0x5E, 0x9A, + 0xF8, 0x9E, 0xDB, 0xEB, 0x1C, 0x8B, 0x2F, 0x7A, + 0xF8, 0xA2, 0x8B, 0x3F, 0x49, 0x66, 0x9C, 0xDC, + 0x5B, 0x4F, 0xB8, 0xFC, 0x34, 0x7C, 0x38, 0xC7, + 0xAD, 0x2E, 0x6E, 0x8F, 0xD2, 0x8D, 0x1C, 0xBA, + 0xC8, 0xF3, 0x47, 0xA6, 0xCF, 0xDF, 0x6A, 0xDD + }, + { + 0xE3, 0x85, 0xB3, 0x3F, 0x62, 0xBF, 0xA1, 0xE3, + 0xC1, 0xE5, 0xF3, 0x54, 0x17, 0x6E, 0x2C, 0x56, + 0xEF, 0xE8, 0xBA, 0xDC, 0x3D, 0xAD, 0x22, 0x7D, + 0x82, 0xFE, 0x27, 0x26, 0x86, 0x79, 0x73, 0x67, + 0xEC, 0x3C, 0xC2, 0x81, 0xDC, 0xF8, 0x42, 0xEE, + 0x7B, 0x4A, 0x1F, 0xE4, 0xF1, 0x3D, 0x85, 0x84, + 0x71, 0x86, 0x12, 0xD1, 0x66, 0x61, 0x1E, 0x92, + 0x65, 0x4E, 0x30, 0xDB, 0xEB, 0xFE, 0x91, 0xFD + }, + { + 0xC2, 0x0B, 0x15, 0x65, 0x09, 0x0A, 0x24, 0x94, + 0xE0, 0x9E, 0x83, 0x2B, 0xBA, 0xA3, 0x71, 0x89, + 0x25, 0x0D, 0xA1, 0xF6, 0x35, 0x51, 0xD1, 0xB1, + 0xF3, 0xEA, 0x1D, 0x5C, 0x03, 0xCE, 0xCB, 0x95, + 0x5E, 0xB7, 0x5E, 0x28, 0xA6, 0xB6, 0x1E, 0xCA, + 0x95, 0x2E, 0xA2, 0xD4, 0x64, 0xDA, 0x56, 0x75, + 0xB2, 0x37, 0x0C, 0xF8, 0xE8, 0x31, 0x5E, 0x5A, + 0xDC, 0xBA, 0xC6, 0x08, 0x6A, 0xF2, 0x98, 0x38 + }, + { + 0x0C, 0x27, 0x48, 0xF5, 0x12, 0xA6, 0x37, 0x16, + 0x91, 0xAD, 0xEC, 0xB5, 0x44, 0x53, 0x23, 0x41, + 0x27, 0xDE, 0x19, 0x65, 0xE4, 0x5D, 0x8C, 0x01, + 0x3E, 0xD7, 0x1D, 0x46, 0xA2, 0xA3, 0xFB, 0xD6, + 0xAD, 0xAE, 0x16, 0x97, 0x26, 0xE2, 0xBC, 0x40, + 0xD9, 0xFC, 0xE8, 0x7A, 0xF3, 0x20, 0xA3, 0x32, + 0x14, 0x43, 0xAB, 0x81, 0x13, 0x79, 0x98, 0x9F, + 0x9C, 0x40, 0x04, 0x3A, 0xE8, 0xB6, 0x6D, 0x8B + }, + { + 0xE4, 0xC8, 0x78, 0xFE, 0x8F, 0x8F, 0x7D, 0xAF, + 0xD2, 0x60, 0x8F, 0xA3, 0x61, 0xCC, 0x28, 0x30, + 0xCF, 0x0B, 0xA0, 0xE6, 0x4C, 0x11, 0xD0, 0xDD, + 0x19, 0xF2, 0xFA, 0xD3, 0x3A, 0x22, 0xF5, 0xD7, + 0x0C, 0x88, 0x0A, 0x1B, 0x94, 0x56, 0x1B, 0x08, + 0x29, 0x7E, 0x60, 0x3E, 0x21, 0x02, 0x28, 0x2B, + 0xF7, 0x29, 0xBB, 0x51, 0x97, 0x23, 0x90, 0x12, + 0x33, 0xD8, 0xFF, 0xFE, 0x09, 0xAE, 0x45, 0xEB + }, + { + 0xA0, 0xE3, 0x58, 0x96, 0x57, 0xD5, 0xC6, 0x14, + 0x26, 0x70, 0x71, 0xFA, 0x0A, 0x83, 0x0C, 0x53, + 0x15, 0xC6, 0xFF, 0x48, 0x10, 0x15, 0x63, 0xEB, + 0x62, 0xA5, 0xE8, 0xFC, 0x3E, 0x13, 0x5A, 0x1C, + 0x65, 0x5F, 0x42, 0x6D, 0xBC, 0x6D, 0x30, 0xDC, + 0xF9, 0x98, 0xC2, 0xE1, 0x63, 0x16, 0x97, 0x31, + 0x61, 0x98, 0x8F, 0x33, 0x08, 0x03, 0x48, 0x3A, + 0xF3, 0xD7, 0x45, 0x75, 0x03, 0x44, 0x85, 0x38 + }, + { + 0x60, 0xF8, 0xA9, 0xF6, 0x46, 0x19, 0xE3, 0x2A, + 0x7D, 0x64, 0x82, 0x76, 0xF7, 0xBA, 0x25, 0xD2, + 0xCD, 0xC8, 0x10, 0x44, 0x05, 0xBE, 0x6A, 0xFB, + 0x91, 0x9B, 0x22, 0xEA, 0x23, 0x5C, 0xFD, 0x63, + 0xC3, 0x42, 0x57, 0xAF, 0x94, 0xB1, 0x07, 0xF1, + 0x90, 0x57, 0x87, 0xCF, 0x4C, 0xE4, 0x09, 0x54, + 0x03, 0x27, 0x78, 0x85, 0x11, 0x01, 0xD7, 0xE6, + 0x42, 0x05, 0x06, 0x94, 0x3F, 0x28, 0x4C, 0x06 + }, + { + 0x53, 0xC2, 0x9F, 0xDC, 0x3D, 0x55, 0x75, 0x77, + 0xCA, 0xA3, 0x48, 0x1C, 0x6A, 0x0D, 0xE7, 0x00, + 0x5C, 0xA0, 0xEC, 0x3F, 0x19, 0xF1, 0x5D, 0x37, + 0xF1, 0xFE, 0xC1, 0x6C, 0x5E, 0x38, 0x7F, 0xA6, + 0x2B, 0x4F, 0xCD, 0x5C, 0x3D, 0x36, 0x8F, 0x9B, + 0x67, 0x2D, 0x03, 0x23, 0x5D, 0x38, 0xCF, 0x62, + 0x85, 0xE3, 0xDA, 0x02, 0x26, 0x19, 0xDD, 0x58, + 0xB5, 0x18, 0x1D, 0x42, 0xD8, 0xE6, 0x57, 0xB9 + }, + { + 0x23, 0xCA, 0x82, 0xE9, 0x3C, 0x74, 0x17, 0xFE, + 0xD0, 0xEB, 0x9B, 0x12, 0x54, 0xED, 0x39, 0x12, + 0xA7, 0x86, 0xBD, 0x6E, 0x48, 0x75, 0xDE, 0xDB, + 0x70, 0x65, 0x89, 0x9F, 0xAD, 0xF6, 0x9A, 0xF5, + 0x32, 0x16, 0x44, 0xF1, 0xF4, 0xC6, 0x4F, 0x8F, + 0xB0, 0x71, 0x94, 0xBC, 0x10, 0x9A, 0xC2, 0x09, + 0xFF, 0xA7, 0xE1, 0xC1, 0x49, 0xCC, 0x49, 0xB6, + 0xE7, 0x0D, 0x46, 0x9A, 0x93, 0x2E, 0x4D, 0x03 + }, + { + 0xEF, 0x72, 0x9C, 0xB6, 0xB9, 0x3B, 0x47, 0x1C, + 0xEC, 0xF8, 0xFB, 0xD2, 0xDB, 0xFA, 0xC3, 0x0C, + 0x8A, 0x71, 0x67, 0xD9, 0xFC, 0x40, 0x6D, 0x45, + 0xD7, 0x79, 0xBC, 0x11, 0xAF, 0x46, 0x02, 0xD9, + 0x46, 0x4D, 0xBF, 0x9E, 0x60, 0xF8, 0xF4, 0x62, + 0x30, 0x01, 0xF4, 0x74, 0x92, 0x93, 0x42, 0x31, + 0x2E, 0xDF, 0xB8, 0x74, 0x6C, 0x83, 0xB9, 0xF4, + 0xE4, 0xDE, 0xC7, 0x80, 0xB9, 0xD9, 0x48, 0xE4 + }, + { + 0x59, 0x47, 0x7B, 0x8B, 0xEC, 0x20, 0x62, 0x23, + 0xCE, 0xAE, 0x05, 0x24, 0x10, 0x49, 0x78, 0x6E, + 0x34, 0x31, 0x71, 0xB6, 0x85, 0xCA, 0xB7, 0xBA, + 0x9C, 0xF3, 0x0C, 0x4E, 0x15, 0xDB, 0x8B, 0x4D, + 0xF3, 0x14, 0xC8, 0x1C, 0xBC, 0x79, 0x08, 0xA5, + 0x78, 0x4D, 0x8C, 0xA3, 0x0E, 0x45, 0x25, 0x47, + 0x68, 0x5A, 0xBB, 0xBA, 0xD4, 0xC7, 0x0F, 0x16, + 0x03, 0x32, 0xF9, 0x5B, 0x72, 0x06, 0xE1, 0xDE + }, + { + 0xF7, 0xC4, 0xF3, 0x74, 0xAC, 0x5F, 0xE7, 0x0C, + 0xD8, 0x3A, 0x60, 0x1E, 0x42, 0xA3, 0x87, 0x64, + 0x49, 0xFF, 0xB8, 0x93, 0xB0, 0x15, 0x2B, 0x7E, + 0xB4, 0x79, 0xDF, 0x5F, 0x0B, 0x79, 0xFE, 0x59, + 0x7E, 0x7C, 0x9B, 0x98, 0x9D, 0xF6, 0x50, 0x62, + 0x8E, 0x17, 0x82, 0x9E, 0x09, 0x06, 0x7D, 0x1E, + 0x18, 0xC7, 0xAE, 0xCE, 0x95, 0x36, 0x9E, 0x9B, + 0xDD, 0x38, 0x2C, 0x4F, 0x61, 0xAD, 0xCB, 0x89 + }, + { + 0x74, 0xB3, 0x1A, 0x60, 0x9E, 0xD5, 0x90, 0x00, + 0x9E, 0x4C, 0xE7, 0x80, 0x90, 0xA1, 0x2D, 0x48, + 0xFA, 0x26, 0xBD, 0x97, 0xF4, 0x26, 0x75, 0xA9, + 0xD4, 0xFF, 0xEC, 0x7F, 0x7A, 0x7D, 0x5E, 0xE3, + 0x9F, 0x58, 0x73, 0x52, 0x73, 0x0A, 0x56, 0x48, + 0x94, 0x9D, 0xCC, 0xFA, 0xBD, 0xA2, 0x9B, 0xD5, + 0x20, 0x9C, 0x43, 0x09, 0x26, 0xD1, 0x6B, 0x2B, + 0xDE, 0x91, 0x04, 0xB0, 0xA0, 0x65, 0x3D, 0xD0 + }, + { + 0x1B, 0x49, 0x3A, 0x82, 0xD9, 0x30, 0xE2, 0xE2, + 0xFE, 0xE7, 0xF9, 0x79, 0xBA, 0x44, 0x1A, 0x81, + 0x94, 0x77, 0xE7, 0x86, 0x36, 0x69, 0x33, 0x1C, + 0x62, 0x9A, 0xD1, 0xE5, 0x3F, 0x02, 0x00, 0x5C, + 0x1E, 0xD9, 0xF5, 0x5B, 0x87, 0xA2, 0x37, 0x22, + 0x77, 0x22, 0xE4, 0xED, 0xEB, 0x64, 0x29, 0x1C, + 0xFE, 0x9C, 0x69, 0xFF, 0x92, 0x88, 0x92, 0xA2, + 0x93, 0x39, 0xF7, 0xB2, 0xAC, 0xB0, 0x9B, 0x79 + }, + { + 0x4D, 0x13, 0xC5, 0x81, 0x1A, 0x26, 0x2F, 0xFE, + 0x01, 0x31, 0x58, 0x7D, 0xDE, 0xAE, 0x04, 0xA3, + 0xF9, 0x9C, 0x5E, 0x65, 0x91, 0x92, 0xF8, 0x16, + 0x94, 0x9B, 0x71, 0x0A, 0xCD, 0x85, 0xC9, 0xB2, + 0x8F, 0xE2, 0xBE, 0xF2, 0x3F, 0x72, 0x36, 0xFD, + 0xDA, 0x33, 0x4F, 0x0B, 0xC8, 0x2A, 0xC0, 0xBE, + 0xCA, 0xAE, 0x91, 0xDD, 0x37, 0x12, 0x76, 0xBC, + 0xE0, 0x15, 0x1A, 0xF7, 0x3B, 0xE4, 0xA8, 0x46 + }, + { + 0xE2, 0x19, 0xCD, 0xBC, 0xA6, 0xAB, 0x13, 0x29, + 0xEC, 0xCD, 0xBE, 0x94, 0x55, 0xE6, 0xFC, 0x6F, + 0x6D, 0xFD, 0xC4, 0xEF, 0x7B, 0x3D, 0x3A, 0x15, + 0x18, 0xBE, 0x47, 0x28, 0xB6, 0x25, 0x50, 0x9D, + 0xE3, 0x73, 0xA4, 0xAA, 0x31, 0xDF, 0x83, 0xBF, + 0x1F, 0xE0, 0x82, 0xE1, 0x5D, 0x49, 0x6F, 0x31, + 0x5D, 0x89, 0x3B, 0x16, 0x32, 0xBF, 0xF7, 0x03, + 0xA9, 0xB2, 0xA0, 0xED, 0x0F, 0x9B, 0xE6, 0x74 + }, + { + 0x67, 0x80, 0xEB, 0x17, 0x33, 0x2D, 0x33, 0x21, + 0xE5, 0x5A, 0x2C, 0xEA, 0x4D, 0x39, 0x2D, 0xBB, + 0xC4, 0xF1, 0x46, 0x44, 0x2F, 0xE1, 0x60, 0xA5, + 0xFA, 0xC8, 0x29, 0xF0, 0x27, 0x2E, 0xB6, 0xDC, + 0xD4, 0x47, 0xC6, 0xAF, 0x9C, 0x13, 0x8F, 0x8B, + 0xB6, 0x31, 0xAA, 0x13, 0x72, 0x46, 0x14, 0xB9, + 0x3E, 0xCE, 0xA4, 0x55, 0xD4, 0x22, 0x81, 0x73, + 0x16, 0xC4, 0x71, 0x41, 0x26, 0xB0, 0xD0, 0x87 + }, + { + 0x8E, 0x36, 0x5D, 0xAB, 0x11, 0xB1, 0x6D, 0xD2, + 0xC1, 0x46, 0x9A, 0xB4, 0xE3, 0xC2, 0xA2, 0x42, + 0xD5, 0xB3, 0x04, 0x3B, 0x93, 0xB0, 0x3D, 0xB2, + 0x98, 0x77, 0x5B, 0x63, 0x46, 0x07, 0xB5, 0x1F, + 0x86, 0x06, 0x2B, 0x3A, 0x75, 0x93, 0xFB, 0x5C, + 0x2D, 0xCB, 0x49, 0xCF, 0x0E, 0x53, 0xCD, 0xDE, + 0x49, 0x5D, 0x41, 0x8E, 0x6C, 0x0A, 0xA5, 0xE7, + 0x20, 0x43, 0x2A, 0xB5, 0x6B, 0x1A, 0x9A, 0xB4 + }, + { + 0xDA, 0xDF, 0x60, 0x9C, 0xF4, 0xA0, 0xB6, 0x2C, + 0x81, 0x8F, 0x1A, 0x9A, 0x50, 0xDF, 0xC8, 0xE1, + 0xBB, 0xFF, 0xD8, 0x40, 0xF2, 0x58, 0x9B, 0xC6, + 0x05, 0xE5, 0x09, 0xF6, 0x35, 0xF8, 0x54, 0xA3, + 0xD2, 0x09, 0x85, 0x28, 0x1D, 0x2E, 0xF6, 0x92, + 0x77, 0x5D, 0x03, 0xFF, 0xF5, 0x68, 0x08, 0x83, + 0xC5, 0x3A, 0x39, 0xB6, 0x7F, 0xA9, 0x1B, 0x78, + 0x15, 0xA0, 0xC6, 0xFE, 0xA1, 0xEF, 0x36, 0xD3 + }, + { + 0x1F, 0xFD, 0x2A, 0x87, 0x75, 0xCD, 0x13, 0xD6, + 0x91, 0xD5, 0x4F, 0x17, 0x9C, 0x26, 0x94, 0xD1, + 0x36, 0xB2, 0x1A, 0x74, 0x30, 0x6A, 0xF7, 0x8A, + 0x75, 0x3D, 0xCD, 0x8B, 0x23, 0x0D, 0x7D, 0x85, + 0x9A, 0xE3, 0x30, 0xFA, 0xE1, 0x1D, 0x31, 0xD1, + 0x77, 0xA3, 0xFC, 0x3A, 0xA9, 0x01, 0xF4, 0x2A, + 0x41, 0x9A, 0x05, 0xCF, 0xF9, 0x1D, 0x6F, 0x90, + 0x1E, 0x3E, 0x6D, 0x6D, 0x5A, 0xC0, 0x5A, 0x0A + }, + { + 0x3D, 0x29, 0xE3, 0x28, 0xC7, 0x7D, 0x97, 0x64, + 0xD5, 0x62, 0x75, 0xF7, 0x3F, 0x8F, 0x9F, 0xA8, + 0xB6, 0x9A, 0x7D, 0xFC, 0x5C, 0x6D, 0xA5, 0xF2, + 0xBF, 0x25, 0x9B, 0xDA, 0xD0, 0x5D, 0x57, 0xE2, + 0xB6, 0x99, 0x1D, 0x91, 0x83, 0xAC, 0x11, 0x83, + 0x7D, 0xB9, 0xD3, 0xC1, 0x04, 0x04, 0xEA, 0x93, + 0x40, 0xF0, 0xA5, 0xDD, 0x39, 0x88, 0xF2, 0xAF, + 0xC0, 0x8A, 0x63, 0xF0, 0x59, 0xC0, 0x18, 0xF7 + }, + { + 0x4E, 0x9B, 0x3F, 0xF3, 0xAE, 0x26, 0x8C, 0xCD, + 0x64, 0x6C, 0x0F, 0xD6, 0x72, 0xA5, 0x52, 0x9D, + 0x34, 0x81, 0x27, 0xBC, 0x70, 0xB5, 0x35, 0x94, + 0x91, 0x60, 0x0E, 0x67, 0x26, 0x9B, 0x4A, 0x25, + 0xA1, 0x45, 0x7D, 0xA2, 0x97, 0x09, 0x76, 0xE1, + 0x96, 0xD8, 0xA9, 0xC8, 0x93, 0x2E, 0x3D, 0xFC, + 0x69, 0x83, 0x4A, 0xA8, 0x5F, 0x2F, 0xA1, 0xE4, + 0x64, 0x10, 0x0E, 0x48, 0xFC, 0xC8, 0x75, 0x5A + }, + { + 0x33, 0xC0, 0xDF, 0xBB, 0xBD, 0xEB, 0xD9, 0xAA, + 0xF5, 0xF4, 0xDB, 0x0A, 0xB7, 0x0A, 0x57, 0xA2, + 0xBD, 0x85, 0x90, 0x1B, 0x78, 0xA1, 0xDD, 0xB3, + 0xE8, 0x72, 0xFC, 0xDD, 0x3D, 0xD4, 0x3A, 0xA8, + 0x41, 0x97, 0x71, 0xB7, 0xAF, 0x03, 0x9A, 0x04, + 0xCF, 0xFA, 0xFC, 0xFA, 0x01, 0x89, 0x77, 0x9F, + 0x45, 0xFC, 0x2B, 0x2F, 0x07, 0x2C, 0xE1, 0x89, + 0xB9, 0x77, 0xB4, 0xBE, 0xA5, 0x30, 0xB4, 0xB1 + }, + { + 0xA9, 0x1F, 0xA0, 0x13, 0x5B, 0x24, 0xFF, 0x99, + 0x2C, 0x1A, 0x70, 0xED, 0x92, 0x4D, 0x47, 0xB6, + 0x83, 0x05, 0x73, 0xFF, 0x0B, 0x8D, 0x3C, 0x2F, + 0x69, 0xD0, 0x6C, 0xA6, 0x9F, 0x38, 0x94, 0x07, + 0x8F, 0xFA, 0x23, 0x03, 0xC5, 0x77, 0x3B, 0x98, + 0x24, 0x61, 0xA2, 0x3E, 0xB4, 0x19, 0xC8, 0xDF, + 0xD6, 0xC5, 0x03, 0xCD, 0x96, 0x69, 0x13, 0x25, + 0x68, 0x93, 0x4B, 0xC8, 0x1F, 0x40, 0xA8, 0xB8 + }, + { + 0xCE, 0x5D, 0x89, 0x36, 0x65, 0xCA, 0xF1, 0xDF, + 0x11, 0x1F, 0x1D, 0xFE, 0xA0, 0x3A, 0x2F, 0x8A, + 0xB4, 0x11, 0x5E, 0x54, 0xDE, 0x17, 0x54, 0xC6, + 0xB3, 0xD2, 0xCD, 0x51, 0xEE, 0x26, 0x60, 0x3A, + 0x67, 0x1C, 0x63, 0xF7, 0x67, 0xED, 0x50, 0xFD, + 0xB1, 0x79, 0x54, 0xB3, 0x7C, 0x73, 0x14, 0x80, + 0x83, 0x1F, 0x88, 0xC1, 0x52, 0xDD, 0x34, 0x32, + 0x58, 0xF2, 0xC7, 0xDE, 0x7E, 0xC6, 0x1F, 0x5E + }, + { + 0x20, 0xA4, 0xA3, 0xCB, 0xCC, 0x8F, 0xE6, 0x77, + 0x72, 0x1B, 0x60, 0x3C, 0x7D, 0xB7, 0xD8, 0x43, + 0xFF, 0x45, 0x19, 0x6E, 0x6B, 0x67, 0x4D, 0x6B, + 0x83, 0xC1, 0x66, 0x01, 0x40, 0xEB, 0x4C, 0x1D, + 0x59, 0xA4, 0xD2, 0x9F, 0xFE, 0x8A, 0xC5, 0x75, + 0xF9, 0x8C, 0x5C, 0x1B, 0x2F, 0x42, 0x05, 0xF1, + 0x43, 0x5E, 0xEB, 0xAF, 0x3A, 0xE3, 0x95, 0x54, + 0x34, 0xD2, 0xE5, 0x7C, 0x8E, 0xAF, 0x0B, 0xF6 + }, + { + 0x56, 0xF5, 0xD0, 0x5D, 0xCC, 0xD2, 0x7E, 0x79, + 0xFA, 0x8A, 0xC5, 0x06, 0xF7, 0xF3, 0x7C, 0x78, + 0xD0, 0xAA, 0xE7, 0x8B, 0x96, 0x1A, 0x7F, 0x45, + 0xD4, 0x83, 0x40, 0x24, 0x0A, 0xCD, 0xE2, 0x3D, + 0xB6, 0x11, 0x60, 0x89, 0x52, 0xCD, 0x50, 0x40, + 0xF3, 0x90, 0x50, 0xAE, 0x0B, 0xFD, 0xCC, 0xD0, + 0x7F, 0x2B, 0x3F, 0x49, 0x70, 0xFF, 0x8B, 0xB9, + 0xB4, 0xDA, 0xCC, 0x80, 0x8B, 0xB8, 0x56, 0x7E + }, + { + 0xDA, 0x89, 0x49, 0x05, 0x9D, 0x5A, 0x0E, 0x0C, + 0x40, 0xC0, 0xA6, 0xB4, 0xA8, 0x3D, 0xF4, 0x22, + 0x9B, 0xA2, 0x08, 0xF5, 0x3C, 0x6E, 0xCF, 0xFD, + 0x04, 0xD7, 0x47, 0xCC, 0xCD, 0x4D, 0x93, 0x2A, + 0x15, 0x3C, 0x74, 0x78, 0x17, 0x92, 0xFF, 0xA5, + 0x15, 0x64, 0xD6, 0x93, 0x4D, 0xF9, 0xB6, 0xB7, + 0x45, 0x37, 0x97, 0x8C, 0x14, 0x7B, 0x1B, 0xA6, + 0x08, 0x60, 0xAA, 0xDD, 0x15, 0xBE, 0x26, 0xF8 + }, + { + 0x71, 0x13, 0x70, 0x93, 0x11, 0xF3, 0xEC, 0x16, + 0x49, 0x87, 0x1B, 0x21, 0xCE, 0x5D, 0x87, 0xAA, + 0x9E, 0x52, 0xEC, 0x32, 0xF9, 0x48, 0x2D, 0x2F, + 0xC5, 0xA3, 0xF2, 0x14, 0xFF, 0xC4, 0xA7, 0x55, + 0x93, 0xDD, 0x49, 0x6E, 0xE5, 0x26, 0xAB, 0x57, + 0x6A, 0x65, 0x8C, 0x8C, 0x53, 0x1E, 0x33, 0xD1, + 0xB2, 0xD8, 0x79, 0xE0, 0xAA, 0x11, 0xDD, 0xA6, + 0x82, 0x94, 0xE7, 0xC3, 0x38, 0xBC, 0x30, 0x8C + }, + { + 0x57, 0x67, 0xE0, 0xAD, 0xA1, 0x63, 0xDA, 0x7F, + 0xB5, 0x1C, 0x86, 0x0E, 0xBF, 0x49, 0x9B, 0x3A, + 0x21, 0x71, 0xAE, 0x5E, 0x58, 0xDF, 0xB7, 0x7C, + 0x44, 0x47, 0xE4, 0x2A, 0x72, 0x38, 0x8A, 0x2B, + 0x37, 0x66, 0xFF, 0x97, 0x44, 0x87, 0xCA, 0x5E, + 0x04, 0x2B, 0xEF, 0x1A, 0x35, 0x0B, 0xEB, 0x56, + 0x15, 0xA2, 0x06, 0xDB, 0x66, 0xDC, 0x1C, 0x4E, + 0x30, 0x23, 0xAB, 0x18, 0x5F, 0x7D, 0xB6, 0x86 + }, + { + 0x7F, 0x4D, 0x2B, 0xC7, 0x5B, 0x09, 0x0B, 0x23, + 0xC9, 0xA0, 0x78, 0x2A, 0x58, 0x8E, 0xAD, 0x1A, + 0xF6, 0x44, 0xEF, 0x8C, 0xBE, 0x13, 0x32, 0xD6, + 0xBF, 0x11, 0x7A, 0x93, 0x1E, 0x9A, 0xBF, 0x11, + 0xE5, 0x53, 0x4F, 0xE7, 0x61, 0xEC, 0xD3, 0x30, + 0xD1, 0x7D, 0xA9, 0xB5, 0xAD, 0x03, 0xEB, 0x14, + 0x68, 0x9F, 0x1C, 0xCB, 0x4A, 0x66, 0xA8, 0x90, + 0xC1, 0xEC, 0x93, 0x3F, 0x9D, 0xD1, 0x92, 0x86 + }, + { + 0xC2, 0x1D, 0xC5, 0x58, 0x8E, 0x59, 0x9F, 0xB4, + 0x98, 0xD5, 0xD2, 0x03, 0xED, 0x2B, 0x13, 0x58, + 0x00, 0x74, 0xE4, 0xE1, 0x4C, 0x9D, 0xEA, 0x51, + 0x1F, 0x7D, 0x5F, 0x79, 0xAF, 0x57, 0xAE, 0xCC, + 0x9E, 0x67, 0xE6, 0x21, 0xE6, 0x2F, 0x79, 0x77, + 0x3A, 0xCC, 0x5F, 0x77, 0x6C, 0x2F, 0x55, 0x00, + 0xD4, 0xF3, 0xAC, 0x1A, 0x3C, 0xE7, 0x5D, 0x83, + 0xC0, 0x17, 0x58, 0x26, 0xBF, 0xB7, 0xCC, 0x9E + }, + { + 0xD4, 0x66, 0x07, 0x05, 0xDF, 0x1A, 0x1D, 0xC0, + 0xA5, 0xB8, 0xC4, 0xC3, 0x0C, 0xF4, 0xD8, 0xBA, + 0xEE, 0x21, 0x9E, 0x8C, 0x07, 0xAF, 0x0D, 0x1A, + 0xD9, 0xF2, 0x42, 0x52, 0x9B, 0x77, 0xBD, 0xC6, + 0x5A, 0xA1, 0xD0, 0xFE, 0x93, 0x10, 0x77, 0xE1, + 0xA0, 0xB7, 0x2D, 0x40, 0xA1, 0x78, 0xB1, 0x5B, + 0xA3, 0x75, 0xC0, 0xC8, 0xBD, 0x3D, 0x1E, 0x4E, + 0x56, 0x8E, 0x6C, 0x75, 0xFE, 0xFF, 0xD8, 0x1A + }, + { + 0x20, 0x26, 0x03, 0xDD, 0xE4, 0x79, 0xAC, 0x5F, + 0x3C, 0x13, 0x14, 0x47, 0xA0, 0xBD, 0x43, 0x99, + 0x44, 0xEF, 0xCF, 0x00, 0x65, 0x47, 0x03, 0x0C, + 0x74, 0x07, 0xA7, 0x04, 0x28, 0x59, 0x60, 0x78, + 0x25, 0xEA, 0x2C, 0xE0, 0x63, 0xC1, 0xBC, 0x1B, + 0xD5, 0x95, 0xAC, 0x1C, 0xAD, 0x61, 0x45, 0xC2, + 0x2B, 0x57, 0xA2, 0x55, 0x58, 0xD7, 0x56, 0x4F, + 0xF8, 0x0C, 0xB4, 0xC4, 0xD1, 0x4B, 0xBE, 0xE5 + }, + { + 0xFB, 0x2D, 0xA9, 0x8F, 0x9B, 0x6F, 0x52, 0xF2, + 0x7D, 0x04, 0x0E, 0x1B, 0x52, 0xE2, 0x4E, 0xCC, + 0x23, 0x89, 0x09, 0x80, 0x10, 0xAD, 0xAD, 0x41, + 0xE6, 0x56, 0x50, 0xA7, 0x40, 0x22, 0x75, 0xF9, + 0xA1, 0x38, 0x64, 0x30, 0x7E, 0x17, 0x3F, 0x24, + 0x4D, 0x39, 0x0F, 0xE3, 0x9D, 0x55, 0x95, 0x24, + 0x38, 0x1A, 0xBB, 0x85, 0x9A, 0x16, 0x4C, 0xC5, + 0x79, 0x60, 0x04, 0xED, 0x27, 0xCE, 0x2F, 0x07 + }, + { + 0x01, 0xCD, 0x82, 0x2C, 0xA2, 0x00, 0x2A, 0xB2, + 0x73, 0x1A, 0xDD, 0xD4, 0x82, 0x6C, 0x15, 0x0E, + 0x47, 0x72, 0x6F, 0x8C, 0xDD, 0xD2, 0x98, 0xA6, + 0xDD, 0xFC, 0x78, 0x7D, 0xD0, 0xF9, 0xE1, 0xF5, + 0xB0, 0x4C, 0x35, 0x7B, 0x92, 0x38, 0x6E, 0xED, + 0xE2, 0xBA, 0x96, 0x16, 0x35, 0x14, 0x71, 0x21, + 0xFF, 0x60, 0x83, 0x95, 0x56, 0xE0, 0x41, 0x9C, + 0xA9, 0x75, 0xA3, 0x2C, 0xD5, 0x7F, 0x9E, 0xA8 + }, + { + 0x29, 0x5E, 0x4D, 0x10, 0xE4, 0x4D, 0x79, 0x99, + 0x79, 0xE9, 0x61, 0x42, 0x72, 0xC3, 0xA0, 0x52, + 0xE3, 0xC1, 0x97, 0xC8, 0x7C, 0xBA, 0x6B, 0x7A, + 0x8D, 0x44, 0x74, 0xA7, 0xD7, 0x7B, 0x33, 0xD4, + 0x8E, 0x50, 0x0E, 0x0A, 0x78, 0x4A, 0x40, 0x13, + 0xE9, 0x48, 0x9E, 0xA7, 0x25, 0x87, 0xB1, 0x69, + 0xC1, 0x99, 0x77, 0xAD, 0x47, 0x2C, 0xB8, 0xFA, + 0xB7, 0xA6, 0x6A, 0xB6, 0xBE, 0xDC, 0x38, 0x73 + }, + { + 0xCC, 0x73, 0x53, 0x1D, 0x63, 0x10, 0x2B, 0x85, + 0x4F, 0xFB, 0x64, 0x1F, 0x65, 0x1A, 0x37, 0x97, + 0x74, 0x15, 0x24, 0x5F, 0x27, 0x04, 0xB4, 0x22, + 0xE8, 0xBF, 0x4B, 0x14, 0x32, 0x9B, 0x9F, 0x6E, + 0xBE, 0x85, 0x79, 0x8F, 0x11, 0x48, 0x0F, 0x75, + 0x36, 0xA2, 0x2F, 0x19, 0xC2, 0x1F, 0x8D, 0x68, + 0xB3, 0xBE, 0xF2, 0x7D, 0xD2, 0xEA, 0x1A, 0xDF, + 0x10, 0xA8, 0x98, 0xFD, 0x33, 0x91, 0x07, 0x8C + }, + { + 0x4C, 0xA8, 0xB6, 0x07, 0xD8, 0xCE, 0xA2, 0x91, + 0x83, 0xC8, 0x09, 0x67, 0x6C, 0x69, 0x13, 0x47, + 0xC4, 0x13, 0x30, 0x5E, 0x41, 0x03, 0x5E, 0x91, + 0x0E, 0x85, 0xF4, 0x1F, 0xBD, 0x15, 0x20, 0x6D, + 0x05, 0xF6, 0x35, 0x73, 0x4E, 0xB2, 0x23, 0x54, + 0x43, 0xBC, 0xF1, 0x51, 0xC6, 0x30, 0xAB, 0x68, + 0xBF, 0x9B, 0x36, 0xB0, 0x06, 0xC8, 0x5E, 0x04, + 0x6C, 0xC7, 0x89, 0xE5, 0x9B, 0x11, 0xEB, 0xA5 + }, + { + 0xB5, 0x11, 0x38, 0x00, 0xFF, 0x15, 0xB5, 0xD4, + 0x64, 0x5C, 0x86, 0xB6, 0x60, 0x06, 0x60, 0x01, + 0xBD, 0x0A, 0xD6, 0x24, 0xA2, 0xAA, 0x2C, 0xED, + 0x07, 0xD7, 0xB2, 0x88, 0x65, 0xB3, 0x84, 0xD8, + 0x09, 0x1E, 0x2D, 0x38, 0x85, 0xCC, 0x96, 0x66, + 0x45, 0x45, 0xFB, 0xC0, 0xF5, 0x73, 0x70, 0xC5, + 0x7D, 0x8B, 0xBC, 0x1D, 0x21, 0x21, 0x5F, 0x5D, + 0xD6, 0x84, 0x06, 0x7D, 0x2D, 0xBA, 0x95, 0x3B + }, + { + 0xF1, 0x1C, 0xFA, 0xBF, 0x12, 0x59, 0xA4, 0xF3, + 0x91, 0x22, 0xF2, 0x06, 0x53, 0xF4, 0xBD, 0x1C, + 0x97, 0x0F, 0x8D, 0x90, 0x69, 0x96, 0x2C, 0xC6, + 0x35, 0x79, 0x5B, 0x46, 0x3D, 0xE6, 0xBD, 0x8E, + 0xB2, 0x69, 0x11, 0x51, 0x76, 0x16, 0x3C, 0xED, + 0x8F, 0xFC, 0x99, 0xC6, 0x18, 0x48, 0xA6, 0x14, + 0xB6, 0xED, 0xDF, 0x95, 0x25, 0x46, 0x4D, 0x18, + 0x2C, 0xF4, 0x5A, 0x2A, 0xEC, 0xFA, 0x21, 0x07 + }, + { + 0x12, 0x7D, 0x1C, 0x45, 0x7F, 0x8C, 0x1E, 0x2C, + 0x26, 0x69, 0x62, 0x59, 0x99, 0xBB, 0x00, 0x64, + 0xCC, 0xF4, 0xA9, 0x76, 0x0D, 0x5A, 0x31, 0x9E, + 0x12, 0xCB, 0xA5, 0xC8, 0x35, 0x98, 0xA8, 0x41, + 0x07, 0x9A, 0x7F, 0x32, 0xCC, 0x07, 0x23, 0x32, + 0xE7, 0x4F, 0x78, 0x77, 0xCA, 0x83, 0x0D, 0xFE, + 0xE0, 0xD6, 0x6C, 0x76, 0x4C, 0x6D, 0x20, 0xF1, + 0xB6, 0x2F, 0x09, 0x30, 0xC1, 0x28, 0x1A, 0xCF + }, + { + 0x8C, 0x5F, 0xA9, 0x01, 0xA4, 0x17, 0x0C, 0x0C, + 0x08, 0x2C, 0x54, 0x70, 0xCA, 0x6B, 0x16, 0x20, + 0xA0, 0x0B, 0x2E, 0x22, 0x3A, 0xFE, 0xA1, 0xC5, + 0x13, 0x1F, 0x8A, 0x70, 0x21, 0x27, 0xAF, 0xC9, + 0x0F, 0x7B, 0xD1, 0xAF, 0x2D, 0xDD, 0xA1, 0x89, + 0xF9, 0x55, 0xDF, 0xF6, 0xAB, 0x39, 0x7D, 0xFD, + 0x09, 0x18, 0x86, 0x02, 0xD5, 0x0C, 0x9A, 0x25, + 0xC6, 0x27, 0x3F, 0x65, 0x2D, 0xCC, 0xA5, 0x24 + }, + { + 0xD5, 0xE7, 0x0E, 0x93, 0x88, 0x66, 0x98, 0x56, + 0x44, 0x07, 0x64, 0x35, 0x27, 0x39, 0x9C, 0x5F, + 0xB4, 0x41, 0xEE, 0x60, 0xD6, 0xC8, 0x61, 0x6E, + 0x17, 0x0B, 0xE3, 0xB9, 0xC9, 0x2B, 0xB7, 0x35, + 0x0E, 0x67, 0x0A, 0x1C, 0x20, 0xD6, 0x05, 0x97, + 0xD0, 0xAE, 0xA7, 0x9D, 0x83, 0x92, 0x7F, 0xF3, + 0x0E, 0xBE, 0xB6, 0xA2, 0xDD, 0x87, 0x75, 0x31, + 0xAC, 0x0F, 0xD0, 0xB4, 0xCC, 0x90, 0x44, 0xFB + }, + { + 0xD1, 0xE5, 0xC8, 0x9F, 0x4E, 0x7B, 0x08, 0x9C, + 0xA1, 0xE4, 0xEB, 0xC8, 0x92, 0xB2, 0xDA, 0x81, + 0x70, 0x69, 0x0B, 0x96, 0x73, 0xFB, 0xA1, 0xC0, + 0x55, 0xC1, 0x0E, 0xA0, 0xAD, 0xF6, 0xD6, 0x2B, + 0x2E, 0xCC, 0xFB, 0x4E, 0xC5, 0x5F, 0x40, 0x8A, + 0x15, 0x26, 0xE3, 0xD9, 0xB3, 0x5B, 0xEB, 0x74, + 0x7C, 0x05, 0xDF, 0x3F, 0x5D, 0xC1, 0xA6, 0x07, + 0xEC, 0x86, 0x2F, 0x82, 0xA7, 0x99, 0x6E, 0x28 + }, + { + 0xAE, 0x72, 0x38, 0x16, 0x19, 0xDB, 0x56, 0x04, + 0xC2, 0x89, 0x63, 0xDD, 0x34, 0xED, 0x61, 0x52, + 0x13, 0xBA, 0x43, 0xCF, 0x26, 0x05, 0x2F, 0x69, + 0x36, 0xF0, 0x70, 0x5D, 0x95, 0xFC, 0xF6, 0x69, + 0x3D, 0x5C, 0x57, 0x8B, 0x95, 0xA3, 0xC2, 0x88, + 0x23, 0x9E, 0xB4, 0x0B, 0x3C, 0x74, 0x9A, 0x6F, + 0x7C, 0x3D, 0x52, 0x95, 0x6D, 0xE0, 0xB0, 0x51, + 0xF2, 0x50, 0x0B, 0xCD, 0x37, 0x55, 0xF6, 0xDE + }, + { + 0xD3, 0xE4, 0x47, 0x5F, 0x89, 0x7C, 0x53, 0x38, + 0x49, 0x0E, 0xFC, 0x8D, 0x58, 0x1C, 0x9F, 0x28, + 0x13, 0x89, 0xF6, 0x2D, 0x84, 0xAF, 0xE2, 0x06, + 0xFC, 0xFC, 0x85, 0xFA, 0x78, 0x81, 0xC4, 0xAF, + 0xD9, 0x1F, 0x2F, 0xEC, 0xCD, 0x7A, 0xFC, 0x84, + 0x53, 0x85, 0x9D, 0x57, 0xD3, 0x56, 0x5F, 0x05, + 0x98, 0x26, 0x14, 0x9F, 0x71, 0xC7, 0xD5, 0x7B, + 0x9A, 0xFE, 0x4A, 0xD0, 0x84, 0x89, 0x1C, 0xBC + }, + { + 0x1F, 0x5C, 0x78, 0x13, 0x7B, 0x86, 0xA1, 0xC4, + 0xF4, 0x35, 0x06, 0xEE, 0x7E, 0xD4, 0xF4, 0x81, + 0x13, 0x58, 0x72, 0x0D, 0xD6, 0xB3, 0x54, 0xAC, + 0xCD, 0xA6, 0x5D, 0x70, 0xAB, 0x87, 0x43, 0x86, + 0xDF, 0xB2, 0x7A, 0x7C, 0x9B, 0x4F, 0xDB, 0x79, + 0x38, 0xD1, 0x51, 0x53, 0xAE, 0x73, 0xD2, 0x2E, + 0xF8, 0x09, 0xA1, 0xAB, 0xDC, 0x75, 0x8C, 0xCA, + 0x4A, 0x09, 0xD8, 0xC6, 0xBE, 0xB3, 0x3C, 0xAE + }, + { + 0x47, 0xDB, 0x08, 0xA1, 0xF7, 0xE8, 0xA9, 0x57, + 0x39, 0x30, 0xE4, 0xD9, 0x01, 0x6F, 0xB2, 0x01, + 0x74, 0x9E, 0x2C, 0xA2, 0xA4, 0x16, 0xDF, 0xD6, + 0xCC, 0xF4, 0x79, 0x53, 0x40, 0xF4, 0x2F, 0xEE, + 0x61, 0xEB, 0xB4, 0xB5, 0xC9, 0x38, 0xFB, 0x54, + 0xA1, 0xEE, 0xEB, 0x71, 0xA9, 0xC4, 0xD5, 0x36, + 0xBD, 0x1A, 0xF9, 0x3F, 0xE7, 0x7E, 0xBC, 0xB0, + 0xBE, 0x2F, 0x30, 0x94, 0xEE, 0x24, 0xCF, 0x55 + }, + { + 0xC6, 0xFA, 0x3F, 0x66, 0xA9, 0xDA, 0xBE, 0x90, + 0xFD, 0x28, 0x09, 0x5F, 0x1C, 0x3E, 0x4F, 0xA7, + 0x9F, 0xE3, 0xA3, 0x74, 0xF2, 0x00, 0x0D, 0x40, + 0x43, 0x8B, 0x98, 0x99, 0x48, 0xCC, 0x9D, 0xCA, + 0x61, 0x21, 0x17, 0x96, 0x18, 0xA7, 0x72, 0x84, + 0x53, 0xBE, 0xFF, 0x92, 0x02, 0x1A, 0xAA, 0x6E, + 0xBE, 0x63, 0xFB, 0x5F, 0xF3, 0xCC, 0xC2, 0xB4, + 0x84, 0x31, 0x65, 0xD0, 0xD1, 0xD7, 0x9B, 0x5E + }, + { + 0xDD, 0xBD, 0x1B, 0xB7, 0x32, 0x08, 0x13, 0xE7, + 0x24, 0x76, 0x14, 0xBC, 0x4E, 0x2E, 0x9A, 0xAB, + 0x74, 0xDA, 0x79, 0x38, 0x04, 0x44, 0x6D, 0x4C, + 0x28, 0xBC, 0xE0, 0xE4, 0x57, 0x96, 0xFE, 0xFE, + 0xDE, 0xC8, 0xAA, 0xF8, 0x27, 0x02, 0xDB, 0xED, + 0x65, 0x50, 0x5E, 0xE1, 0x82, 0xE1, 0x13, 0xFF, + 0x47, 0x9E, 0xC5, 0x8E, 0x2E, 0x4F, 0x29, 0xDF, + 0x03, 0x37, 0x5F, 0x9F, 0x34, 0x75, 0x29, 0x62 + }, + { + 0x86, 0xAE, 0xAD, 0x8F, 0x27, 0x29, 0xDB, 0xF5, + 0xC9, 0x0E, 0x87, 0x87, 0x2D, 0x93, 0x08, 0x67, + 0xE9, 0x4D, 0x44, 0x1A, 0x31, 0x27, 0x9E, 0x76, + 0x1B, 0xDB, 0x96, 0x8D, 0xF5, 0xEA, 0x6A, 0x7D, + 0xD4, 0x91, 0x57, 0x4B, 0xE1, 0xE3, 0xDF, 0x50, + 0xAA, 0x39, 0xC2, 0xFD, 0x3F, 0x69, 0xC1, 0xE3, + 0x87, 0x08, 0x36, 0x0B, 0xC1, 0x74, 0x36, 0x33, + 0x0E, 0x64, 0xF3, 0xB5, 0x6E, 0xD3, 0x55, 0xE8 + }, + { + 0x1A, 0xBF, 0x87, 0xB7, 0x64, 0xD2, 0x5A, 0x8F, + 0x4A, 0xE7, 0x02, 0xF4, 0xD6, 0x56, 0x84, 0xE9, + 0xDE, 0xA0, 0xF6, 0x82, 0xD2, 0x66, 0x35, 0x82, + 0x5A, 0x5E, 0x55, 0x5A, 0x81, 0x53, 0x98, 0xA0, + 0x2E, 0x4D, 0x6E, 0xC8, 0x42, 0x6B, 0x93, 0x7E, + 0x25, 0x1A, 0x4B, 0x3A, 0xE9, 0xE5, 0x40, 0x00, + 0x1B, 0xC9, 0x63, 0x83, 0x60, 0xBA, 0xC1, 0x73, + 0xCD, 0x1B, 0xF0, 0xA9, 0x0F, 0xED, 0x94, 0x04 + }, + { + 0x43, 0x4B, 0x90, 0x4E, 0x8F, 0xAD, 0x89, 0xA0, + 0x92, 0xCE, 0x88, 0x26, 0x02, 0x29, 0xE4, 0x1A, + 0x8D, 0x20, 0xBD, 0xBF, 0xBD, 0x1C, 0x34, 0x9A, + 0xF7, 0x13, 0x68, 0x07, 0xF3, 0x52, 0x69, 0x31, + 0x69, 0x5D, 0xE7, 0x06, 0xED, 0x08, 0x9D, 0xC1, + 0x03, 0xDD, 0xA0, 0x6C, 0xC8, 0xCC, 0xCC, 0xE0, + 0xAE, 0x07, 0x69, 0xAE, 0x38, 0xCA, 0xD3, 0x54, + 0x0A, 0x9E, 0x0C, 0x76, 0xB3, 0xA2, 0x9F, 0xD1 + }, + { + 0xB2, 0x09, 0xC8, 0x52, 0xF9, 0x45, 0xFD, 0x37, + 0x56, 0x30, 0x90, 0xE1, 0xF4, 0x13, 0x84, 0x8B, + 0xF1, 0xA8, 0x8B, 0xAB, 0x18, 0xE3, 0x33, 0x06, + 0x38, 0x91, 0xFC, 0x18, 0x5F, 0x24, 0xE6, 0x40, + 0x3F, 0x38, 0x15, 0xA9, 0xBF, 0xD3, 0x28, 0x03, + 0xD2, 0x15, 0x91, 0x9B, 0x3F, 0xFC, 0x2B, 0x3F, + 0x50, 0x4D, 0x93, 0xB0, 0xDE, 0xB6, 0x13, 0xBC, + 0xC6, 0x5B, 0x39, 0x05, 0xBB, 0x46, 0x77, 0x80 + }, + { + 0xA2, 0x60, 0x7E, 0xB7, 0x3E, 0x43, 0x67, 0x88, + 0xA1, 0x35, 0xDB, 0xA1, 0x75, 0x1D, 0x59, 0x5A, + 0x69, 0xE7, 0xA2, 0x56, 0xB6, 0xD2, 0xA6, 0x8D, + 0x9D, 0x51, 0x59, 0x19, 0x35, 0xC5, 0x18, 0x4C, + 0x04, 0xB8, 0x81, 0x5D, 0x93, 0x10, 0x0C, 0xC7, + 0x98, 0xFF, 0xD9, 0x7F, 0x31, 0xAF, 0x7A, 0xE9, + 0xB8, 0x0D, 0xC0, 0xF4, 0x89, 0x27, 0x4C, 0xA7, + 0x79, 0x61, 0x90, 0x69, 0xD1, 0xCC, 0xE2, 0xC4 + }, + { + 0xFC, 0x6B, 0x4A, 0x7E, 0x77, 0xB1, 0xD3, 0xDF, + 0x89, 0x8F, 0xBF, 0xEE, 0x05, 0xCE, 0x14, 0xA1, + 0xFE, 0x5A, 0xE4, 0x20, 0x0E, 0x12, 0xBF, 0x7C, + 0xD8, 0xFF, 0x6B, 0x1A, 0xBD, 0xF2, 0x46, 0x0D, + 0xD5, 0x28, 0x87, 0x8D, 0x6E, 0x50, 0xEE, 0x94, + 0xA8, 0x2B, 0xDC, 0xCF, 0xE3, 0x07, 0x30, 0x42, + 0xA3, 0xD1, 0xEF, 0xCF, 0xE7, 0x97, 0xD3, 0x66, + 0x67, 0xB2, 0x9D, 0xC2, 0x1F, 0x57, 0xB7, 0x79 + }, + { + 0x15, 0x95, 0x11, 0x00, 0x0A, 0xBB, 0x2F, 0x8D, + 0x22, 0x45, 0xA2, 0xB8, 0x26, 0x8C, 0x2D, 0x58, + 0x38, 0x03, 0x17, 0xB7, 0xBA, 0x0C, 0xC4, 0x18, + 0x8E, 0x8B, 0x5B, 0x28, 0xCF, 0xE4, 0x21, 0xE2, + 0x15, 0xD8, 0xC9, 0x73, 0x8A, 0x4B, 0x56, 0xF0, + 0x40, 0x7C, 0x18, 0xF3, 0xB4, 0x66, 0xDA, 0x15, + 0xB3, 0x23, 0x34, 0x46, 0x61, 0x9B, 0xE3, 0xCD, + 0xF7, 0x26, 0xA2, 0x29, 0x3D, 0x0E, 0x08, 0x27 + }, + { + 0xC9, 0x1D, 0x27, 0x88, 0x18, 0x37, 0xAB, 0xCC, + 0xA3, 0xAB, 0x6D, 0x07, 0x8C, 0xE4, 0x6B, 0x71, + 0xCB, 0xAC, 0x50, 0xFA, 0x38, 0x58, 0x3E, 0x09, + 0x77, 0xE6, 0xF0, 0x62, 0xB7, 0xA5, 0x58, 0x11, + 0x3D, 0x4A, 0xE4, 0xDD, 0xCB, 0x54, 0x3F, 0x13, + 0x04, 0x72, 0xC2, 0x76, 0xBE, 0x93, 0x5C, 0x24, + 0x74, 0x99, 0x4A, 0x1F, 0x6C, 0x58, 0xAB, 0xB8, + 0x58, 0xD0, 0x2B, 0xB6, 0x31, 0x56, 0x7C, 0xDD + }, + { + 0x0E, 0xC8, 0xBE, 0xDF, 0x57, 0x84, 0x96, 0xB4, + 0x77, 0xE5, 0x8B, 0x56, 0x0C, 0xBF, 0xA3, 0x79, + 0x37, 0xDD, 0x05, 0x2B, 0x9B, 0x31, 0x32, 0x87, + 0x70, 0x20, 0x3E, 0x4D, 0xD4, 0xE0, 0xFD, 0x9A, + 0x0F, 0x84, 0x82, 0xBC, 0x9C, 0xA0, 0x1B, 0xDC, + 0x71, 0x7C, 0xE4, 0xC7, 0x79, 0xEA, 0x9D, 0x66, + 0x1D, 0x7F, 0x5C, 0x08, 0x41, 0x4F, 0x14, 0xF7, + 0x1C, 0x40, 0x79, 0xE7, 0x84, 0x83, 0x4A, 0xFE + }, + { + 0x6C, 0x8D, 0x81, 0xB9, 0xFD, 0x7E, 0x0D, 0x62, + 0x0F, 0xCB, 0x38, 0x4D, 0xAD, 0xFE, 0x8E, 0x5B, + 0xF7, 0x44, 0x61, 0xBD, 0xB8, 0x5D, 0xA3, 0xB0, + 0xEC, 0x50, 0xED, 0xC4, 0x1D, 0xCF, 0xDE, 0xB4, + 0x3D, 0x9B, 0x0A, 0x8E, 0xA5, 0xE7, 0x43, 0xFE, + 0x9D, 0x09, 0x60, 0x4F, 0x18, 0x06, 0xBF, 0x56, + 0x6C, 0xE3, 0x9C, 0x9F, 0x26, 0x57, 0x70, 0x3F, + 0x07, 0x6C, 0xFE, 0xBF, 0xA5, 0xEE, 0x9E, 0x73 + }, + { + 0x98, 0xDA, 0x96, 0x08, 0xC9, 0xB4, 0x07, 0x41, + 0x6C, 0xF8, 0x4A, 0xDF, 0x88, 0x2C, 0x2C, 0x5B, + 0x3B, 0x84, 0xCD, 0xEE, 0x55, 0x76, 0x71, 0x24, + 0x6D, 0x7D, 0x7E, 0xEC, 0x60, 0x8F, 0x2F, 0x22, + 0xA1, 0xF3, 0xCB, 0x15, 0x09, 0x33, 0x44, 0x5B, + 0xC7, 0xE6, 0xF6, 0x48, 0x4A, 0x32, 0x42, 0x34, + 0x02, 0x89, 0x23, 0xFC, 0xEF, 0x83, 0x18, 0x25, + 0xBD, 0x76, 0x6C, 0xD1, 0xEA, 0xBE, 0x7C, 0xB2 + }, + { + 0x5E, 0x6D, 0xD2, 0xA1, 0x7B, 0x58, 0x22, 0x7A, + 0x3B, 0x64, 0x55, 0x32, 0x1C, 0xCD, 0x0E, 0xB5, + 0xD8, 0x5F, 0x0A, 0x63, 0xAE, 0x97, 0xC4, 0x13, + 0x8F, 0x81, 0x21, 0x06, 0x30, 0x9F, 0xB4, 0xDD, + 0x09, 0xBB, 0xBB, 0xE8, 0x18, 0x04, 0x7F, 0x65, + 0x7B, 0x92, 0x6E, 0x2B, 0x40, 0xBA, 0x5E, 0x46, + 0xEA, 0xCF, 0xF1, 0x8F, 0x4B, 0x11, 0x28, 0xA8, + 0xCB, 0x91, 0x9D, 0x56, 0x9B, 0x72, 0xF6, 0x2C + }, + { + 0x14, 0xDE, 0x6B, 0x12, 0xF6, 0x8E, 0x19, 0xB6, + 0xAD, 0x8F, 0x9E, 0x5C, 0x88, 0x82, 0x7A, 0xFF, + 0xC4, 0x10, 0xDC, 0xFF, 0xBF, 0x8F, 0xC7, 0x1E, + 0xE2, 0x01, 0xA4, 0xAF, 0x1F, 0xF2, 0x01, 0x98, + 0x70, 0x48, 0x90, 0x7A, 0x52, 0x51, 0xB7, 0x21, + 0x7C, 0x07, 0xF3, 0x00, 0xEF, 0xCD, 0xAC, 0xE0, + 0x46, 0xB1, 0x1F, 0x79, 0xCB, 0x07, 0xFA, 0xD8, + 0xEE, 0x7C, 0x4A, 0x75, 0x38, 0xD9, 0x22, 0x00 + }, + { + 0xA8, 0xC7, 0x7C, 0xCA, 0x32, 0x38, 0x06, 0x3A, + 0xB4, 0x31, 0x8E, 0x8F, 0x1C, 0x8E, 0xDC, 0x2F, + 0xE6, 0x0D, 0x8B, 0x58, 0x4D, 0xC3, 0x62, 0xEF, + 0x54, 0x06, 0x1B, 0xF6, 0x9F, 0x29, 0xFC, 0x34, + 0xAB, 0x4C, 0x6E, 0x92, 0xF9, 0x4F, 0x97, 0x01, + 0x14, 0x13, 0x51, 0x23, 0xE4, 0x8A, 0x5D, 0xFA, + 0x2A, 0x04, 0xFA, 0xCA, 0x13, 0x40, 0x86, 0xBC, + 0xBD, 0x1F, 0x09, 0x6B, 0xBF, 0x28, 0x8F, 0x38 + }, + { + 0xE4, 0x20, 0x8A, 0x3B, 0xE5, 0x20, 0x97, 0xF8, + 0x16, 0xF7, 0x3E, 0xEB, 0xFC, 0x1A, 0xCF, 0xCD, + 0x38, 0x4A, 0x8C, 0x0A, 0xD7, 0x49, 0x83, 0xAF, + 0x22, 0x76, 0xD4, 0xE8, 0x17, 0x40, 0x0D, 0x61, + 0x46, 0x1D, 0xE6, 0xF9, 0xE0, 0xEA, 0x39, 0x22, + 0x69, 0xCD, 0x79, 0xA6, 0x5A, 0x7B, 0xDA, 0xA3, + 0x82, 0x85, 0x67, 0x06, 0xEA, 0x35, 0x8B, 0xE3, + 0x9C, 0x5C, 0x08, 0x28, 0x6F, 0x59, 0xCA, 0xAD + }, + { + 0xB5, 0x6E, 0xFA, 0x98, 0xB0, 0x37, 0x68, 0x39, + 0xF9, 0xDF, 0xD8, 0x42, 0x46, 0x97, 0x7F, 0xCC, + 0x27, 0xE8, 0xC1, 0x7C, 0x55, 0x06, 0xFC, 0x9B, + 0x94, 0x84, 0xBB, 0x88, 0xD2, 0x73, 0x83, 0x52, + 0xFF, 0x84, 0x97, 0xF3, 0x87, 0x2D, 0xBF, 0xF3, + 0x72, 0x69, 0x5D, 0xCA, 0x41, 0xA4, 0x5B, 0xC1, + 0x64, 0x75, 0xFF, 0x7A, 0xCC, 0x76, 0x66, 0x50, + 0x12, 0x7C, 0x77, 0xEA, 0x45, 0x4F, 0x1D, 0x20 + }, + { + 0x1F, 0x2A, 0xB1, 0x45, 0xB5, 0xEA, 0xA3, 0xF3, + 0x17, 0x66, 0x46, 0x5E, 0x28, 0x29, 0xAE, 0x55, + 0xAE, 0xF3, 0x9A, 0xD5, 0x4F, 0x10, 0xFB, 0x4D, + 0xAE, 0xFE, 0x83, 0x96, 0x8C, 0xB0, 0x18, 0xAE, + 0xAD, 0x01, 0x57, 0xCF, 0x47, 0x0C, 0xBF, 0x54, + 0xDB, 0xB9, 0x5E, 0x85, 0x3A, 0xFF, 0x95, 0xE3, + 0x1F, 0x6E, 0x7C, 0x90, 0x1B, 0x5B, 0xD2, 0xFF, + 0xD0, 0x74, 0x2C, 0xAC, 0x36, 0x46, 0x02, 0x9E + }, + { + 0x6C, 0xD1, 0xC3, 0x11, 0x85, 0x95, 0xFE, 0xA6, + 0x02, 0xA4, 0x15, 0x41, 0x70, 0x4D, 0x12, 0x42, + 0x45, 0x93, 0x83, 0xD9, 0xB2, 0xA8, 0x7E, 0x00, + 0xE5, 0xCB, 0x4E, 0x43, 0xAC, 0x9C, 0x9A, 0xDE, + 0x19, 0xF3, 0xC4, 0x66, 0xA4, 0x00, 0x7F, 0xB7, + 0x66, 0x68, 0x62, 0xD9, 0xBA, 0x12, 0x60, 0xE5, + 0x72, 0xB1, 0xC7, 0x4F, 0x39, 0x3F, 0xBA, 0x46, + 0x75, 0x0F, 0x8B, 0x59, 0xCD, 0x0A, 0x1B, 0x2D + }, + { + 0x45, 0xB9, 0xCC, 0xE2, 0x27, 0x2E, 0x7B, 0x5A, + 0x07, 0x43, 0x62, 0x9E, 0x89, 0x31, 0x2A, 0x48, + 0x7B, 0x4B, 0x2C, 0x7F, 0x97, 0x60, 0x6F, 0x13, + 0x8F, 0x3E, 0x39, 0x21, 0x6D, 0xF7, 0x95, 0x95, + 0x48, 0x92, 0xDA, 0x10, 0x98, 0x94, 0x5A, 0x3E, + 0x5D, 0x1A, 0x3E, 0x2B, 0x69, 0xA8, 0xB6, 0x5C, + 0x2B, 0xE7, 0x8F, 0x7E, 0x75, 0x00, 0xA5, 0xEA, + 0x46, 0xE5, 0xCE, 0x88, 0xEB, 0x8D, 0xE5, 0x0E + }, + { + 0x08, 0xE0, 0x21, 0x12, 0xD5, 0xFA, 0xBE, 0x26, + 0x2A, 0x81, 0x31, 0xB2, 0x36, 0x0B, 0x8C, 0x1D, + 0xC4, 0xE7, 0x55, 0x0E, 0x90, 0x5F, 0xCF, 0x56, + 0x5E, 0x1E, 0xEE, 0x91, 0x9F, 0xB8, 0x6D, 0x9A, + 0xE9, 0xE8, 0x63, 0x71, 0xD8, 0x3D, 0xE5, 0x4E, + 0x96, 0x54, 0xED, 0x7A, 0x8D, 0xA1, 0x83, 0xEB, + 0x12, 0x93, 0x8A, 0xB1, 0x9A, 0x28, 0x2E, 0x61, + 0x15, 0xDF, 0x2E, 0xE8, 0x04, 0x18, 0x60, 0x1A + }, + { + 0x15, 0x42, 0xDE, 0x3E, 0xA5, 0xA3, 0x50, 0x77, + 0x8B, 0xFC, 0x71, 0x55, 0xEB, 0x6D, 0x09, 0x1B, + 0x02, 0xB1, 0x2D, 0x3B, 0x8A, 0xAB, 0xF9, 0xC3, + 0x02, 0xB9, 0x61, 0x81, 0x68, 0x4F, 0xA4, 0xA3, + 0x69, 0x4B, 0x48, 0x13, 0x86, 0xCC, 0xF1, 0x5C, + 0x97, 0x90, 0x6D, 0xDF, 0x3A, 0x3A, 0x93, 0x77, + 0xD6, 0x25, 0x35, 0x40, 0x31, 0xA6, 0x67, 0x7E, + 0x06, 0x7B, 0x7F, 0xB4, 0x5A, 0xFD, 0x9D, 0x7C + }, + { + 0xF6, 0x39, 0xF9, 0x8B, 0xAD, 0x74, 0x79, 0x9C, + 0x40, 0xD7, 0xCB, 0xC6, 0xC4, 0xE6, 0x3D, 0x68, + 0x09, 0x0E, 0xBC, 0x04, 0x8B, 0x1A, 0x7F, 0xE6, + 0x62, 0xB1, 0xFF, 0x65, 0x1B, 0x41, 0xA6, 0xB5, + 0xA9, 0x39, 0x61, 0x75, 0xE9, 0x38, 0xBF, 0xD9, + 0x75, 0x49, 0xDB, 0x7B, 0x0D, 0x6B, 0x2C, 0xDA, + 0x6C, 0x46, 0x7F, 0xC4, 0x5C, 0xD2, 0x3C, 0x45, + 0x77, 0x5B, 0x8A, 0x24, 0xE2, 0x11, 0xED, 0xFC + }, + { + 0xAB, 0x57, 0x87, 0x2C, 0x7C, 0xF7, 0xC5, 0x93, + 0x9A, 0xE9, 0xB4, 0x26, 0xF1, 0xB4, 0x3F, 0x9E, + 0x63, 0x03, 0x67, 0x11, 0x92, 0xC9, 0x98, 0xE5, + 0xBE, 0xB5, 0xAB, 0x9D, 0x1A, 0x27, 0xA6, 0xF7, + 0x46, 0x6B, 0x60, 0x6C, 0x32, 0xCA, 0x42, 0x9E, + 0xC5, 0x07, 0xA0, 0xA2, 0x76, 0x81, 0x56, 0x8D, + 0x71, 0x73, 0x28, 0x3B, 0x2F, 0xBE, 0x21, 0x46, + 0xFB, 0x55, 0xE8, 0x8F, 0xA6, 0x25, 0x79, 0x2B + }, + { + 0x91, 0xFE, 0xE4, 0x98, 0x6C, 0x33, 0x18, 0x8E, + 0x97, 0xB3, 0x4E, 0x7F, 0x4B, 0xFB, 0x7B, 0x25, + 0x97, 0x5C, 0x2D, 0x91, 0x99, 0x8D, 0xB2, 0x7E, + 0x29, 0xE2, 0x9A, 0x42, 0x4B, 0x87, 0x7D, 0x52, + 0x98, 0x64, 0xDC, 0x40, 0x5B, 0x2C, 0x75, 0xE8, + 0x53, 0xAD, 0xCA, 0xD8, 0xE8, 0xCB, 0x69, 0xAE, + 0x56, 0x22, 0x12, 0xE8, 0x87, 0xBE, 0xBB, 0x0D, + 0xB9, 0x8B, 0xE5, 0x9E, 0x55, 0xFC, 0xDC, 0x5F + }, + { + 0x6F, 0x17, 0x04, 0x74, 0x00, 0x27, 0xD4, 0x6A, + 0x0E, 0x9C, 0x8C, 0xC9, 0xAD, 0x16, 0x36, 0xA1, + 0x06, 0x45, 0x4C, 0x5B, 0xCB, 0x59, 0x74, 0xBA, + 0x33, 0x8B, 0xFF, 0x4D, 0x23, 0x28, 0xA8, 0xDE, + 0x1A, 0x35, 0x30, 0xB3, 0x72, 0x5D, 0x7E, 0x25, + 0x21, 0xDE, 0x61, 0x6E, 0x8B, 0xC5, 0xDE, 0x6E, + 0xEC, 0xC5, 0x3A, 0x84, 0x26, 0xB0, 0xB2, 0xE6, + 0xDA, 0xA0, 0x6C, 0xE2, 0x9A, 0x74, 0xFC, 0x81 + }, + { + 0xA8, 0x99, 0x94, 0x68, 0xD2, 0xF8, 0xE4, 0x5B, + 0x5D, 0xCC, 0x1C, 0x28, 0x2A, 0x52, 0xAB, 0xCA, + 0xA0, 0x39, 0xA6, 0xC5, 0x64, 0x15, 0x0C, 0x7E, + 0xB8, 0x33, 0x94, 0xE5, 0xE5, 0x72, 0xBE, 0x2C, + 0x01, 0xC4, 0x63, 0x69, 0x92, 0x81, 0x11, 0x9E, + 0x1B, 0x06, 0xA4, 0x5B, 0x8D, 0xBF, 0xA7, 0xF3, + 0xA3, 0xB9, 0xFC, 0x03, 0x2E, 0xE3, 0xD2, 0x9D, + 0x7C, 0x9C, 0x92, 0x21, 0x6C, 0x93, 0x93, 0x74 + }, + { + 0x7D, 0xA3, 0x7A, 0xAF, 0xBA, 0xDF, 0x34, 0xAC, + 0xDC, 0x1A, 0x3C, 0x13, 0xD7, 0x3B, 0xA0, 0x38, + 0xC3, 0x42, 0xE1, 0x6C, 0xED, 0x87, 0xE1, 0x85, + 0x51, 0x48, 0xA7, 0x72, 0x2F, 0x19, 0x8D, 0x14, + 0xB2, 0x74, 0x28, 0x1B, 0x22, 0x88, 0xAC, 0x90, + 0x34, 0x12, 0x8C, 0x17, 0x86, 0x79, 0xF0, 0xB2, + 0xEF, 0x7D, 0x7E, 0x4A, 0xFC, 0xFC, 0xA9, 0x15, + 0x90, 0x8D, 0x64, 0x8A, 0x3E, 0xF4, 0x88, 0xC4 + }, + { + 0x96, 0xB8, 0x3D, 0xD9, 0x26, 0x36, 0xB0, 0xBE, + 0x67, 0x84, 0x01, 0x1F, 0x6F, 0x75, 0x8E, 0x2B, + 0x31, 0x79, 0x06, 0x78, 0xBF, 0xDE, 0xF7, 0x7C, + 0x0A, 0x60, 0x3B, 0xA4, 0x04, 0x1E, 0x65, 0xFB, + 0x19, 0x91, 0xF7, 0x0A, 0x0D, 0xF5, 0x05, 0x1A, + 0x09, 0x45, 0x32, 0xA5, 0x97, 0x90, 0x6C, 0x8D, + 0xE9, 0x6F, 0x03, 0xE9, 0xAD, 0xF3, 0x90, 0x0F, + 0x8F, 0x72, 0x57, 0x58, 0x1F, 0x6E, 0xB2, 0xF9 + }, + { + 0x02, 0x53, 0xA9, 0x70, 0x08, 0x00, 0x10, 0x09, + 0x3E, 0x86, 0x89, 0x4C, 0x6B, 0xCB, 0xBB, 0x82, + 0x4B, 0x84, 0x04, 0xF5, 0xC2, 0x36, 0xE4, 0xF5, + 0x0D, 0xA3, 0xC8, 0x62, 0xDF, 0xF7, 0xE8, 0xD5, + 0x2A, 0x97, 0x6C, 0xCA, 0xBF, 0x7F, 0x1E, 0x3B, + 0x49, 0x11, 0x88, 0x4A, 0xB4, 0xD4, 0x68, 0x3A, + 0xC4, 0xFF, 0x11, 0xC0, 0xCB, 0xE3, 0x96, 0x18, + 0x63, 0x5A, 0x5A, 0x9E, 0x73, 0xE3, 0x85, 0xE8 + }, + { + 0x61, 0x22, 0x7F, 0xAD, 0x50, 0x45, 0x9B, 0xAE, + 0xBA, 0xD8, 0x9E, 0xD2, 0x04, 0x3F, 0x5B, 0x7E, + 0x51, 0xC5, 0x4C, 0x30, 0xD0, 0xCD, 0x69, 0xF0, + 0x39, 0x92, 0xA1, 0x11, 0xF0, 0xF1, 0x3F, 0x6B, + 0x51, 0xC4, 0x0E, 0xFD, 0x63, 0x47, 0x55, 0x94, + 0x29, 0x59, 0xA9, 0xC1, 0xCF, 0x66, 0x64, 0x36, + 0x98, 0x6B, 0xCE, 0x2C, 0xE3, 0xBC, 0x1F, 0xA8, + 0xC7, 0xE8, 0x3C, 0xC6, 0x6C, 0xD1, 0x43, 0xE3 + }, + { + 0xE7, 0xFF, 0xA0, 0x01, 0x6A, 0x8D, 0x45, 0x6E, + 0x97, 0x7C, 0x10, 0x57, 0x10, 0xF8, 0x1D, 0xA0, + 0x34, 0x37, 0xBB, 0xD9, 0x20, 0xAB, 0xEA, 0x65, + 0xAA, 0xCE, 0xDA, 0x65, 0x37, 0x20, 0xA3, 0x2A, + 0x58, 0x61, 0x99, 0x35, 0xB1, 0xEA, 0xC7, 0x6E, + 0x43, 0xAA, 0xEA, 0xB0, 0x79, 0x9A, 0x8D, 0x29, + 0x16, 0xAF, 0x97, 0x64, 0x5B, 0xF9, 0x72, 0x7A, + 0x48, 0xAB, 0x41, 0x18, 0x07, 0xDF, 0x46, 0xCA + }, + { + 0x5C, 0xBD, 0x9D, 0x66, 0xD9, 0x10, 0xAD, 0x13, + 0x95, 0xDD, 0x4B, 0xF8, 0x98, 0x75, 0x6B, 0x15, + 0x4C, 0x61, 0xD1, 0x33, 0xEB, 0x96, 0x0C, 0xCA, + 0x27, 0x9A, 0x84, 0x94, 0x57, 0x46, 0x99, 0xE2, + 0xAD, 0x2D, 0x22, 0x01, 0x16, 0x72, 0x1F, 0xAC, + 0xEC, 0xBA, 0x58, 0xAD, 0x48, 0x0A, 0xA5, 0x5B, + 0xBA, 0xD2, 0x0E, 0x6C, 0x3C, 0x06, 0xDA, 0xE3, + 0x85, 0xDC, 0x84, 0x9A, 0xEF, 0xCC, 0x1F, 0x74 + }, + { + 0x1F, 0x7B, 0x81, 0xA3, 0x08, 0xC5, 0xA1, 0x27, + 0x3D, 0xAF, 0x37, 0x4F, 0x61, 0x26, 0xD8, 0x08, + 0x6B, 0xD0, 0x01, 0x80, 0x02, 0xAB, 0x35, 0xBE, + 0xF4, 0x87, 0xCF, 0xA8, 0x0C, 0xEB, 0x04, 0x09, + 0x90, 0x38, 0x97, 0x80, 0xFD, 0x2E, 0xD0, 0x30, + 0x00, 0x50, 0x10, 0x06, 0xFB, 0xE4, 0x6E, 0xBA, + 0x84, 0x7D, 0x99, 0x90, 0x5D, 0xFF, 0x8F, 0x87, + 0x48, 0x4F, 0xF3, 0x28, 0xFF, 0xFC, 0xF0, 0xBC + }, + { + 0x95, 0x9F, 0x91, 0x54, 0xEF, 0xD3, 0x7B, 0x05, + 0x93, 0xD2, 0x6E, 0x0F, 0x03, 0x1B, 0x97, 0x2A, + 0x7C, 0x1C, 0xFE, 0xC6, 0x40, 0x17, 0x46, 0x3F, + 0x1F, 0xA9, 0x35, 0xA1, 0xAF, 0x9E, 0xEE, 0xE2, + 0x39, 0xFF, 0x23, 0x18, 0x16, 0xE2, 0x33, 0x03, + 0xA7, 0x5D, 0x55, 0x61, 0x99, 0x14, 0xE4, 0x52, + 0xF7, 0x43, 0x95, 0x8C, 0x21, 0xCD, 0x25, 0x88, + 0x3B, 0xC3, 0x09, 0x6B, 0x4F, 0x44, 0xC1, 0x29 + }, + { + 0xA6, 0xE5, 0xD8, 0x96, 0x1B, 0x98, 0xF4, 0x49, + 0xDB, 0x1F, 0xD6, 0xB6, 0xEB, 0xEB, 0x62, 0x32, + 0x60, 0x41, 0x2C, 0x1C, 0x71, 0xA3, 0xDF, 0xF4, + 0x9D, 0x4C, 0x7B, 0x25, 0xC7, 0x47, 0xD6, 0x34, + 0x91, 0x8B, 0x44, 0xE3, 0x6B, 0x83, 0xED, 0x05, + 0x92, 0x67, 0x7D, 0x71, 0x8A, 0x75, 0x3A, 0x56, + 0x2C, 0x72, 0x70, 0x50, 0x30, 0x7F, 0x1A, 0x17, + 0xD9, 0x16, 0x33, 0x3E, 0x25, 0xEE, 0x50, 0x59 + }, + { + 0xD0, 0x33, 0xC3, 0x50, 0x84, 0x82, 0x7D, 0x4A, + 0x33, 0x89, 0xDE, 0x8A, 0xA6, 0x6A, 0x23, 0x6A, + 0xB5, 0x8B, 0xCD, 0x67, 0x59, 0xD9, 0x3B, 0x65, + 0x32, 0x71, 0xCC, 0x48, 0x8E, 0xF1, 0x38, 0xEB, + 0x40, 0x75, 0x81, 0x6D, 0x49, 0xF8, 0x0B, 0x2A, + 0x23, 0xF6, 0x07, 0xEE, 0xA5, 0x09, 0xE7, 0xA8, + 0x17, 0x71, 0x9A, 0xC8, 0xED, 0x60, 0xC1, 0x97, + 0x45, 0x79, 0xA5, 0x07, 0xB7, 0x47, 0xDF, 0x40 + }, + { + 0x6A, 0x45, 0x2E, 0xF0, 0x57, 0x2E, 0x53, 0x5D, + 0x15, 0x7F, 0xA3, 0x25, 0x66, 0xE0, 0x38, 0x3F, + 0x0F, 0xA1, 0x0F, 0x57, 0xDD, 0xDA, 0x12, 0xCF, + 0x1C, 0x0E, 0xA9, 0xFE, 0xBB, 0xED, 0x93, 0x30, + 0x52, 0x98, 0x22, 0x8D, 0x26, 0x08, 0x04, 0xEE, + 0x28, 0x16, 0x1B, 0x77, 0x3A, 0x8A, 0x19, 0xD7, + 0x97, 0xC1, 0xA0, 0x1B, 0x74, 0xEF, 0xF9, 0xC0, + 0x31, 0xF7, 0x48, 0xFE, 0x6E, 0x15, 0x79, 0x13 + }, + { + 0x25, 0xA6, 0x2A, 0x29, 0xB2, 0x95, 0x55, 0x9F, + 0xF2, 0xB8, 0x4F, 0xF0, 0x48, 0x51, 0x86, 0x18, + 0xB4, 0x69, 0xAB, 0xCA, 0x8B, 0x92, 0xD3, 0x58, + 0xDA, 0x2E, 0x56, 0xF9, 0xF2, 0x8F, 0x4C, 0x0D, + 0x18, 0x2F, 0x6B, 0xBA, 0xAA, 0x19, 0x62, 0xEC, + 0xD3, 0x6E, 0xA1, 0x5F, 0x2D, 0xF2, 0x99, 0x7D, + 0x27, 0x79, 0x42, 0x05, 0x9A, 0x82, 0xF0, 0x5C, + 0xC5, 0x8F, 0xA8, 0xFB, 0xAB, 0xB3, 0xF4, 0x20 + }, + { + 0xA0, 0x57, 0x6B, 0x1E, 0x48, 0x00, 0x4F, 0xAF, + 0x81, 0x8A, 0xA4, 0x49, 0x2A, 0x19, 0x3B, 0x19, + 0xB4, 0xE4, 0x0B, 0x37, 0xE7, 0xA2, 0x6A, 0xD5, + 0x56, 0x0C, 0x25, 0xAC, 0xE4, 0x94, 0xBA, 0x57, + 0xBD, 0x14, 0x41, 0x2E, 0x6A, 0xFF, 0xB0, 0x0A, + 0xDD, 0xB3, 0xB7, 0x24, 0x46, 0x8A, 0xDF, 0x4D, + 0x70, 0xB2, 0xDB, 0x09, 0xE4, 0x63, 0x78, 0xDB, + 0x76, 0x0E, 0x55, 0x75, 0xAF, 0xB2, 0x1D, 0x83 + }, + { + 0x60, 0x25, 0xF7, 0x6D, 0xAD, 0x08, 0xF4, 0x63, + 0x9F, 0xF6, 0xD4, 0xAB, 0xC3, 0x8B, 0xE1, 0x75, + 0xB3, 0x00, 0xBA, 0x1F, 0x23, 0x42, 0xC4, 0xCB, + 0x08, 0xCF, 0x66, 0x93, 0x9A, 0x87, 0x8C, 0x0C, + 0xDB, 0x17, 0x1C, 0xDE, 0xEE, 0x02, 0x98, 0x0C, + 0x0D, 0xCC, 0xC3, 0x1A, 0x47, 0xDF, 0x47, 0xE7, + 0x6A, 0xFE, 0x4F, 0x0F, 0x0E, 0xD4, 0xBC, 0x7D, + 0x4C, 0x4A, 0xD6, 0x78, 0xB3, 0xEB, 0x44, 0x30 + }, + { + 0x20, 0xCE, 0x52, 0x9B, 0xFF, 0xB9, 0x3A, 0xBF, + 0xE6, 0x05, 0xA6, 0x96, 0xF6, 0x4A, 0x2E, 0x6F, + 0x1D, 0x31, 0x95, 0x40, 0xE7, 0x30, 0xDB, 0x53, + 0xC0, 0xBD, 0xD0, 0x63, 0xD1, 0xB2, 0x33, 0x9B, + 0x4A, 0xCD, 0x2A, 0x1B, 0x4B, 0x0A, 0x6C, 0xD5, + 0x2D, 0x88, 0x68, 0x0A, 0x95, 0xC8, 0xD9, 0xC0, + 0xB9, 0x85, 0x91, 0x31, 0x42, 0x0B, 0xB2, 0x0E, + 0xC1, 0xC1, 0xC5, 0xD3, 0xFA, 0x7C, 0x54, 0x0F + }, + { + 0xD0, 0xAE, 0xAD, 0xB3, 0x01, 0x71, 0xFE, 0xFE, + 0x6A, 0x6E, 0xA6, 0x81, 0xC4, 0x1C, 0x6E, 0x89, + 0x0E, 0xDD, 0x46, 0x39, 0xD1, 0xE0, 0xCE, 0x61, + 0x53, 0x7A, 0x2D, 0x01, 0x6A, 0xE1, 0x88, 0xC3, + 0x2A, 0xEC, 0x54, 0x21, 0x8D, 0xF0, 0x0F, 0xB6, + 0xA1, 0xF9, 0x69, 0xC3, 0x59, 0x39, 0xB0, 0xBF, + 0x90, 0xCA, 0x79, 0xFB, 0xDD, 0x45, 0x55, 0x37, + 0x6F, 0x68, 0xB8, 0x91, 0xF0, 0xFA, 0x36, 0xF8 + }, + { + 0x9E, 0xC2, 0xB1, 0x8E, 0x91, 0xB2, 0xFD, 0x32, + 0xB5, 0x4E, 0x7F, 0x94, 0x1D, 0x19, 0x23, 0xE9, + 0xE6, 0xA8, 0x3E, 0x87, 0x4B, 0x10, 0x26, 0x04, + 0x49, 0xBC, 0x95, 0x1F, 0xA5, 0xBE, 0xCC, 0xF3, + 0xFC, 0x12, 0x0B, 0x0E, 0x35, 0x24, 0x99, 0xD7, + 0xD3, 0xDD, 0x17, 0xB5, 0xDB, 0x79, 0xD2, 0x03, + 0x81, 0xC6, 0x1A, 0xC3, 0xA0, 0xD6, 0xEB, 0xBB, + 0x94, 0xEC, 0x9D, 0x53, 0xDB, 0x2C, 0xF2, 0xE7 + }, + { + 0xAE, 0x14, 0xC3, 0xC3, 0x25, 0xD0, 0x87, 0x2D, + 0x9A, 0xA8, 0xDF, 0x66, 0xE9, 0x83, 0x82, 0xCC, + 0xD3, 0x0B, 0x45, 0xCC, 0x81, 0xDA, 0xE3, 0xF7, + 0xE8, 0x62, 0x9C, 0x74, 0x3B, 0x55, 0x12, 0xB0, + 0x62, 0x0A, 0xE4, 0x75, 0x62, 0xA7, 0x50, 0x8C, + 0x0A, 0xCD, 0xC4, 0x9B, 0x25, 0x31, 0xF5, 0x81, + 0xDB, 0x2F, 0x93, 0xAF, 0x6E, 0x90, 0x2C, 0xB4, + 0x94, 0x37, 0xBA, 0x11, 0x5C, 0x8C, 0x6F, 0x5F + }, + { + 0xA6, 0x9E, 0xE9, 0x2E, 0x73, 0x18, 0x68, 0xAD, + 0x54, 0x64, 0x5A, 0xA9, 0x12, 0xC1, 0xB7, 0x88, + 0xE5, 0xE3, 0xD8, 0x97, 0x13, 0xD7, 0x8A, 0xB9, + 0x3F, 0xD2, 0x2D, 0x33, 0x13, 0xD7, 0x22, 0xD7, + 0x16, 0x6A, 0xEB, 0x7A, 0x4A, 0x00, 0x0E, 0x8A, + 0x63, 0x8E, 0x0B, 0x6F, 0x35, 0x63, 0x26, 0xDF, + 0x28, 0x48, 0xC8, 0xEC, 0x56, 0x67, 0x56, 0x64, + 0x8B, 0x74, 0xBD, 0x37, 0x39, 0xA0, 0x63, 0x9D + }, + { + 0x34, 0x39, 0x6C, 0x75, 0xFA, 0x65, 0xD5, 0xAC, + 0x25, 0xB0, 0xA9, 0x1E, 0x10, 0xE5, 0xE2, 0xE1, + 0x92, 0x3D, 0xEF, 0xE9, 0x94, 0x78, 0x62, 0x05, + 0xBA, 0x38, 0x02, 0x57, 0x4B, 0xDA, 0xDD, 0x25, + 0xF8, 0xAC, 0x8F, 0xA8, 0x9B, 0x78, 0x1E, 0x44, + 0xF7, 0x47, 0xC2, 0x1A, 0x3E, 0x5E, 0xA4, 0x1B, + 0x02, 0x1B, 0x8A, 0x45, 0x22, 0x96, 0x1A, 0x5C, + 0xC1, 0xB5, 0xDE, 0x4E, 0x18, 0xBD, 0x19, 0xBA + }, + { + 0xA3, 0x12, 0x9D, 0x87, 0xCD, 0x9F, 0xF5, 0x24, + 0xB8, 0x3F, 0x2B, 0x3F, 0x77, 0xFA, 0x4B, 0x53, + 0x62, 0x31, 0x2F, 0xD4, 0x45, 0x31, 0x40, 0xCB, + 0x8B, 0xAF, 0xD1, 0x97, 0xA7, 0x8D, 0xD1, 0xC9, + 0x62, 0x35, 0x29, 0x9B, 0x2C, 0xB7, 0x0A, 0x3E, + 0xD3, 0x15, 0x73, 0x89, 0x5E, 0x25, 0x1B, 0x2E, + 0x8A, 0xDB, 0x52, 0xD6, 0xDE, 0xBE, 0xFD, 0xC3, + 0x6C, 0xBE, 0xD6, 0x9E, 0x9D, 0xB8, 0xDC, 0xBB + }, + { + 0xD7, 0xE9, 0x96, 0xCB, 0x3C, 0xA0, 0x8A, 0x46, + 0x57, 0x20, 0xA1, 0x65, 0xD0, 0xF6, 0x9E, 0x81, + 0xE7, 0x78, 0x5D, 0xEA, 0x2A, 0xB3, 0x1B, 0x86, + 0xD1, 0xDF, 0xBA, 0x89, 0x4F, 0xE0, 0xE2, 0xDD, + 0x37, 0x3B, 0xF8, 0xD9, 0x13, 0x08, 0xCB, 0xC8, + 0x41, 0x56, 0x67, 0x05, 0xDF, 0xF2, 0x1B, 0xA8, + 0xB4, 0x80, 0x44, 0xFB, 0xF7, 0x5A, 0x52, 0x36, + 0xCB, 0x30, 0xE6, 0xD3, 0xCE, 0x7F, 0xA8, 0x91 + }, + { + 0x77, 0xF9, 0xEB, 0xC5, 0x76, 0x6C, 0x4D, 0x78, + 0x1C, 0x2A, 0x29, 0xC5, 0x7A, 0x10, 0xE4, 0x7F, + 0x7D, 0x66, 0xCF, 0xF9, 0xD4, 0x34, 0xDA, 0xCD, + 0x9F, 0x89, 0x36, 0xB5, 0x0A, 0xAB, 0x46, 0xBA, + 0x22, 0x12, 0xCC, 0x81, 0x62, 0x98, 0xEE, 0x85, + 0x95, 0xC5, 0x45, 0x12, 0x7F, 0x30, 0x9E, 0x2E, + 0x18, 0xE2, 0xAD, 0x7C, 0xBD, 0x04, 0x80, 0xAA, + 0xA6, 0x10, 0x74, 0xA7, 0xF7, 0x81, 0x12, 0x77 + }, + { + 0xD3, 0x36, 0x14, 0x95, 0x3B, 0xD6, 0x26, 0x76, + 0x58, 0xFA, 0x05, 0x66, 0x2E, 0x78, 0x63, 0xE4, + 0xF6, 0xBC, 0x87, 0x53, 0x20, 0xB8, 0x9A, 0xF1, + 0xE6, 0x03, 0xFF, 0x1F, 0xF3, 0xFB, 0x46, 0x68, + 0x17, 0xBF, 0x85, 0x2B, 0x4B, 0x37, 0xEE, 0x8E, + 0x96, 0xC1, 0x0F, 0x6B, 0x94, 0xCD, 0xAF, 0xDB, + 0x99, 0x2C, 0xF5, 0x87, 0x02, 0x14, 0xE9, 0x6B, + 0xD3, 0x11, 0x27, 0x55, 0xE3, 0x78, 0xC2, 0x8E + }, + { + 0xC4, 0x4A, 0xB4, 0x07, 0x96, 0x33, 0x5C, 0x8D, + 0x77, 0x1C, 0xCF, 0xA0, 0xF7, 0xEA, 0x4D, 0xBE, + 0xCB, 0xEF, 0x63, 0xDF, 0x0C, 0xEC, 0x52, 0xDB, + 0x10, 0xF5, 0x28, 0x49, 0xFE, 0x9E, 0xCA, 0xC0, + 0xB3, 0xF6, 0xF7, 0x2B, 0x33, 0x45, 0x00, 0x5F, + 0xA4, 0xDD, 0xC8, 0x77, 0xA7, 0x28, 0x01, 0xC7, + 0x89, 0x25, 0x9E, 0x24, 0x64, 0xA7, 0x4D, 0xAC, + 0x95, 0x2E, 0xE8, 0xBB, 0x09, 0x06, 0x48, 0xA0 + }, + { + 0x94, 0x88, 0x71, 0xF6, 0x7D, 0x63, 0x9B, 0x92, + 0xD7, 0x76, 0x62, 0xA8, 0xE0, 0xB7, 0x75, 0x95, + 0x21, 0xAB, 0xE6, 0x6E, 0x1D, 0x4C, 0xD7, 0x59, + 0xD1, 0xE9, 0x17, 0x9B, 0x4D, 0x9C, 0x8F, 0xC5, + 0x1F, 0x6D, 0x29, 0x8F, 0x77, 0xB7, 0xCE, 0xC9, + 0xDD, 0x49, 0x67, 0x45, 0xC6, 0xCB, 0xBA, 0x42, + 0x1C, 0x5D, 0x5A, 0x01, 0x3D, 0x2B, 0xDF, 0xF7, + 0x14, 0x72, 0xAC, 0xAD, 0x46, 0xE5, 0x1D, 0xC1 + }, + { + 0xA7, 0x1E, 0xB5, 0x0D, 0x87, 0x68, 0xCA, 0x97, + 0xB8, 0xEA, 0x21, 0xFD, 0xB3, 0x3C, 0x99, 0x86, + 0x90, 0x1B, 0xDF, 0x2A, 0xB6, 0xE8, 0x24, 0x88, + 0x7C, 0x3C, 0x9A, 0xBF, 0x88, 0x30, 0xBF, 0xB3, + 0xD1, 0xC2, 0x5E, 0xD4, 0x3E, 0x12, 0x2A, 0x74, + 0x2A, 0x32, 0x5C, 0x27, 0xE5, 0xA3, 0xF1, 0x7A, + 0xBC, 0xB4, 0xE0, 0x36, 0x10, 0x1F, 0x3F, 0x6B, + 0xAB, 0xBE, 0x32, 0x05, 0xB4, 0x7B, 0x9C, 0xD2 + }, + { + 0xDA, 0x2A, 0xD3, 0x42, 0x4A, 0x7A, 0x7E, 0xD4, + 0x99, 0x65, 0xDD, 0x04, 0xA2, 0x43, 0xD4, 0x17, + 0x0E, 0x68, 0x7B, 0xF6, 0xFD, 0x83, 0x19, 0x4B, + 0x52, 0xE7, 0x14, 0x67, 0x40, 0xA4, 0xE4, 0xDF, + 0xE6, 0x68, 0x8C, 0xC7, 0x88, 0xD8, 0x86, 0xC0, + 0x36, 0x9B, 0x45, 0xBB, 0xF0, 0x32, 0xB5, 0x5C, + 0xC3, 0x4A, 0x8D, 0x2E, 0x59, 0x80, 0x17, 0xE7, + 0x58, 0xE2, 0xF2, 0x00, 0xC6, 0x55, 0x07, 0xE2 + }, + { + 0x37, 0xC4, 0x5C, 0x8C, 0x7F, 0x9B, 0xFC, 0xC4, + 0xFA, 0x1D, 0x7F, 0x30, 0x43, 0x45, 0x68, 0x35, + 0xF1, 0xCD, 0x39, 0xBB, 0xC7, 0x26, 0x1D, 0x71, + 0x14, 0x73, 0x1F, 0x1D, 0x72, 0xD6, 0x0C, 0x5E, + 0x1C, 0xB0, 0x49, 0x6E, 0x36, 0x4F, 0x9B, 0x4A, + 0x30, 0x25, 0xD2, 0x63, 0x0D, 0x5D, 0x4B, 0x57, + 0x79, 0xF4, 0x06, 0x4B, 0x91, 0xC3, 0xF1, 0x38, + 0xC0, 0xEC, 0xA4, 0xAE, 0xA0, 0x0C, 0xCF, 0x50 + }, + { + 0x6E, 0xEE, 0x6D, 0xC1, 0x57, 0xD6, 0x65, 0x76, + 0xA5, 0x9A, 0x1D, 0xF6, 0xA0, 0xAB, 0xD7, 0x73, + 0x94, 0x9A, 0x4A, 0xE8, 0x0C, 0x89, 0xBE, 0x3D, + 0x83, 0x03, 0x06, 0xB5, 0x3D, 0xFB, 0x34, 0x13, + 0xE7, 0x41, 0x76, 0x2C, 0x5D, 0xFB, 0xB0, 0x25, + 0xDF, 0x46, 0x50, 0x7C, 0x81, 0xAD, 0x3B, 0x7A, + 0xD6, 0x03, 0x98, 0x2D, 0xDE, 0xA9, 0x02, 0xA0, + 0x9F, 0xC0, 0xBC, 0xE1, 0x8C, 0xB3, 0xF7, 0x94 + }, + { + 0x88, 0xBE, 0x09, 0x8B, 0xA9, 0xDC, 0x2B, 0x85, + 0x46, 0xF1, 0xE2, 0xF0, 0xD0, 0x2F, 0x02, 0xC3, + 0xB7, 0xAF, 0xB3, 0x5F, 0xB6, 0x9A, 0xB7, 0xB8, + 0x6B, 0x12, 0x5E, 0x53, 0xA8, 0xE0, 0xDD, 0x40, + 0x63, 0x4C, 0x2A, 0x40, 0x40, 0x0A, 0x57, 0x9E, + 0x02, 0x76, 0x81, 0x7B, 0x7F, 0x58, 0xD4, 0xE2, + 0xAA, 0x7E, 0xB0, 0x82, 0xBE, 0xA3, 0x88, 0x10, + 0x12, 0x67, 0x7A, 0x2A, 0xCA, 0x8F, 0x34, 0x56 + }, + { + 0x9F, 0xC6, 0x24, 0x68, 0x2B, 0xC6, 0xDF, 0x91, + 0x0D, 0x78, 0x34, 0xCA, 0x62, 0xDC, 0x96, 0x7E, + 0x0A, 0x9A, 0xB5, 0x42, 0x28, 0x69, 0x10, 0xEB, + 0xE7, 0xE2, 0x4A, 0x30, 0x38, 0x61, 0xD7, 0x43, + 0x0B, 0xA5, 0x6B, 0xFD, 0x3B, 0x20, 0x5F, 0x74, + 0xC2, 0xA0, 0xE3, 0x44, 0x13, 0xF0, 0x8E, 0x50, + 0x5C, 0x49, 0x9E, 0x05, 0x09, 0x75, 0x32, 0x47, + 0x93, 0x38, 0x8F, 0xFF, 0x59, 0x14, 0x20, 0xCE + }, + { + 0x30, 0x4E, 0xAE, 0x9F, 0xA2, 0x95, 0x66, 0xE6, + 0x89, 0x9A, 0xBD, 0x9E, 0xE2, 0xE0, 0x11, 0x9D, + 0x44, 0xAB, 0xD5, 0x5C, 0x3D, 0x14, 0x45, 0xE5, + 0x86, 0x67, 0x3E, 0x4C, 0x78, 0xCA, 0x2C, 0x2C, + 0xEC, 0x85, 0xF3, 0x49, 0x35, 0x17, 0x05, 0xA9, + 0x31, 0x7D, 0x48, 0xE6, 0x9C, 0x3E, 0x4D, 0x59, + 0x2D, 0x79, 0xC5, 0x47, 0xC9, 0xE8, 0x6B, 0xA0, + 0xD9, 0x43, 0xDE, 0xBA, 0x1E, 0x1B, 0x8D, 0xA2 + }, + { + 0xE9, 0x38, 0x80, 0x69, 0xCC, 0xB2, 0x3F, 0xB8, + 0x2E, 0x9C, 0x58, 0x6C, 0x26, 0x48, 0x79, 0x67, + 0x31, 0x2F, 0x34, 0x4A, 0x56, 0x20, 0x22, 0x95, + 0x7A, 0x0D, 0x86, 0x46, 0xC3, 0xEE, 0xAB, 0xB7, + 0x4C, 0x3B, 0x4E, 0x0F, 0x63, 0xFB, 0x20, 0xF9, + 0x57, 0xB9, 0x09, 0x09, 0x37, 0x9A, 0xE9, 0x44, + 0x45, 0xE8, 0x20, 0xF5, 0xAC, 0x4D, 0xB6, 0xE8, + 0xEF, 0xB8, 0xC5, 0xB6, 0x00, 0x77, 0xA5, 0x65 + }, + { + 0xE9, 0xAF, 0xA6, 0x88, 0x0F, 0x37, 0x8D, 0x1A, + 0xB0, 0x29, 0x34, 0xC4, 0xFA, 0x8F, 0x50, 0x27, + 0xF4, 0x7D, 0xF0, 0x71, 0x4A, 0xBC, 0xFA, 0x69, + 0xF4, 0x1B, 0x4B, 0x43, 0x7E, 0xE2, 0xE6, 0xE6, + 0x97, 0xB4, 0x99, 0x80, 0xB3, 0x0C, 0xE4, 0x2C, + 0x6B, 0xDE, 0x40, 0x79, 0xC4, 0x63, 0xBE, 0x45, + 0x0C, 0xC0, 0xA6, 0x65, 0xCE, 0x57, 0xB4, 0x41, + 0xC8, 0xC4, 0x98, 0x29, 0xC6, 0x91, 0xD9, 0x06 + }, + { + 0xDD, 0x1C, 0x1B, 0x0E, 0x31, 0x0A, 0x97, 0x54, + 0xB0, 0x86, 0x36, 0x2C, 0x46, 0xF7, 0x8F, 0x33, + 0x06, 0xEB, 0x6F, 0xDA, 0xC4, 0xA8, 0xED, 0xA2, + 0x3D, 0x81, 0x82, 0x0B, 0xA2, 0xD8, 0x60, 0xBB, + 0xFE, 0xC6, 0x10, 0x0E, 0x5C, 0xE7, 0xAB, 0x99, + 0xE8, 0xA9, 0x1F, 0x4B, 0xDB, 0x0F, 0x83, 0xB3, + 0xC6, 0xA8, 0x09, 0xFB, 0xDC, 0xCB, 0x14, 0xE4, + 0xDC, 0x14, 0xCB, 0xCB, 0x56, 0x0E, 0x28, 0xE9 + }, + { + 0x9A, 0xFB, 0x8B, 0x34, 0x7C, 0xF5, 0x5C, 0x93, + 0x59, 0x67, 0x89, 0x64, 0x00, 0xAD, 0x2B, 0x4E, + 0xBA, 0x70, 0xDE, 0x2E, 0x30, 0x6F, 0xDF, 0x6B, + 0x78, 0x02, 0x27, 0xD5, 0xD9, 0xF7, 0x0D, 0xC9, + 0xC2, 0x7C, 0xD6, 0x18, 0x99, 0x90, 0x76, 0x38, + 0x4D, 0x39, 0x1A, 0x2E, 0x14, 0x6F, 0xCB, 0xB6, + 0xF5, 0x31, 0x7E, 0x9B, 0x75, 0xA8, 0x1A, 0x5F, + 0x3F, 0x12, 0xDE, 0x11, 0xF8, 0x9D, 0x99, 0xB0 + }, + { + 0x8D, 0x73, 0x22, 0x03, 0x00, 0x32, 0xF5, 0x39, + 0xE8, 0x68, 0x9A, 0x1F, 0x8F, 0xD7, 0xBF, 0x44, + 0x19, 0xE9, 0x68, 0x8E, 0xC3, 0x56, 0xFE, 0x63, + 0x1A, 0x1A, 0x95, 0xC4, 0x7C, 0x99, 0x24, 0x8C, + 0x0C, 0x49, 0x31, 0xCC, 0x70, 0x0F, 0xCB, 0x08, + 0xDF, 0xAA, 0xA6, 0x40, 0x4F, 0x7C, 0x36, 0x12, + 0x4A, 0x9C, 0x54, 0x09, 0x80, 0x75, 0x8B, 0xB1, + 0x58, 0x44, 0x93, 0x5B, 0x56, 0xC5, 0xF9, 0x2D + }, + { + 0x7D, 0xF3, 0x29, 0x83, 0x58, 0xD6, 0x6D, 0xE5, + 0x4E, 0xB0, 0xA4, 0xEC, 0xA9, 0x51, 0x17, 0x2A, + 0x55, 0x10, 0x3F, 0x22, 0xBC, 0x5B, 0xB9, 0xA9, + 0x28, 0x5F, 0x97, 0x9F, 0x66, 0xB1, 0x18, 0x92, + 0x41, 0x0C, 0x8C, 0x5F, 0xD5, 0xF8, 0xBE, 0x88, + 0x76, 0x8A, 0x87, 0xF5, 0xC4, 0x58, 0xBA, 0x73, + 0xCC, 0xFF, 0xF6, 0xA2, 0x7A, 0x8A, 0x8F, 0xC9, + 0x4A, 0x60, 0xD2, 0x13, 0xC7, 0x75, 0x67, 0xFC + }, + { + 0x6F, 0xFA, 0xF9, 0xDB, 0x1D, 0x36, 0x8B, 0x9F, + 0x7E, 0x3C, 0x8A, 0xEA, 0x71, 0xF1, 0xB1, 0xC5, + 0xA2, 0x7A, 0x86, 0x46, 0x3C, 0x28, 0x43, 0x7D, + 0x8D, 0x8C, 0xFB, 0x71, 0xDE, 0x42, 0x31, 0x6F, + 0xE5, 0xBF, 0xD9, 0x38, 0x65, 0x86, 0x38, 0x0A, + 0x7B, 0x2F, 0xE2, 0x7E, 0xDD, 0xFF, 0x20, 0x59, + 0x05, 0xAD, 0x32, 0xA6, 0x43, 0x00, 0x16, 0x24, + 0xDB, 0x04, 0xAC, 0x14, 0xC4, 0x16, 0xAE, 0x89 + }, + { + 0x0A, 0x25, 0x58, 0x50, 0xB1, 0x9A, 0x18, 0x46, + 0x1B, 0x85, 0x7D, 0x3C, 0xCE, 0x4B, 0x4D, 0xE2, + 0x58, 0x76, 0x49, 0xBA, 0xF5, 0xF9, 0x2B, 0xA9, + 0xC6, 0xEF, 0x98, 0x41, 0x6D, 0x07, 0x7B, 0xF9, + 0x03, 0x35, 0x11, 0xF2, 0xC0, 0x41, 0x65, 0x0F, + 0xC5, 0x8E, 0x88, 0xB9, 0x4A, 0x7C, 0x24, 0xD3, + 0x72, 0x46, 0x14, 0x91, 0x6E, 0xC0, 0xE6, 0xD4, + 0x79, 0x19, 0x28, 0xEC, 0x65, 0x1F, 0xCE, 0x1A + }, + { + 0x59, 0x46, 0xEA, 0x3C, 0x66, 0x31, 0x5B, 0xE2, + 0x29, 0xEF, 0x98, 0x8A, 0xB8, 0x13, 0xC3, 0x51, + 0x2C, 0x22, 0x11, 0x16, 0x6A, 0x3C, 0x4C, 0xD0, + 0xA8, 0xC7, 0x2D, 0xA2, 0x68, 0x6E, 0x16, 0x2E, + 0x1F, 0x93, 0xE2, 0x24, 0x62, 0xDC, 0x92, 0xDD, + 0x3B, 0xCB, 0x38, 0x57, 0x23, 0x57, 0x9D, 0x8C, + 0x2F, 0xEF, 0x86, 0x8F, 0x0F, 0x9B, 0xE1, 0xF8, + 0x4B, 0x8A, 0xC1, 0x02, 0x76, 0xE5, 0x29, 0xC0 + }, + { + 0x52, 0xC9, 0x60, 0x99, 0xF9, 0xBC, 0xC9, 0x5D, + 0x50, 0xC7, 0x05, 0xD7, 0x12, 0xAF, 0x74, 0x09, + 0xC3, 0x32, 0x1E, 0x1A, 0x4D, 0x00, 0xB2, 0x13, + 0x0B, 0x10, 0xD7, 0xEE, 0xEA, 0xA4, 0xC6, 0x51, + 0x9D, 0x0A, 0x8A, 0xE7, 0xDE, 0x36, 0x9F, 0x88, + 0x8A, 0x1D, 0x16, 0xAB, 0x02, 0x86, 0x88, 0x1F, + 0x4A, 0x16, 0xC4, 0xAD, 0xB8, 0xBE, 0x71, 0x7F, + 0xA8, 0xDA, 0xDB, 0x3B, 0x3D, 0x1B, 0x4D, 0x15 + }, + { + 0x8E, 0xB2, 0x64, 0x23, 0x7B, 0xC4, 0xE1, 0xA4, + 0x40, 0x64, 0x99, 0x22, 0xA7, 0xC1, 0xC0, 0x0D, + 0x27, 0x66, 0xE1, 0x7C, 0x3E, 0xEC, 0x76, 0x73, + 0x1D, 0x12, 0x74, 0xB0, 0xD4, 0x64, 0xD3, 0x74, + 0x31, 0x59, 0xCB, 0x17, 0x76, 0xB0, 0xF0, 0xAD, + 0x43, 0x00, 0xEC, 0x01, 0x71, 0x88, 0xBD, 0x29, + 0xBB, 0x69, 0x81, 0x9F, 0x8B, 0xC6, 0xE0, 0x91, + 0x32, 0xC1, 0x8C, 0x29, 0xCA, 0x68, 0xC0, 0x47 + }, + { + 0x23, 0x7C, 0xA1, 0xCD, 0xEE, 0x7F, 0xE4, 0x6A, + 0x3D, 0xED, 0x3F, 0x07, 0x40, 0xC5, 0x44, 0x4B, + 0xD3, 0xE8, 0x9A, 0x8B, 0xA2, 0x20, 0xE3, 0xF1, + 0x38, 0x26, 0xE0, 0x3C, 0x58, 0xB7, 0x81, 0x47, + 0x8D, 0x6F, 0xA1, 0x3E, 0xD7, 0x31, 0x70, 0x00, + 0x95, 0xB9, 0x9D, 0x60, 0xFD, 0xA0, 0x13, 0x50, + 0x6A, 0xF0, 0x60, 0xCA, 0x06, 0x34, 0x8D, 0xE2, + 0xFF, 0x2E, 0x63, 0xCF, 0x5E, 0xD5, 0x2D, 0x6F + }, + { + 0x06, 0x25, 0x2D, 0xE5, 0x52, 0xD3, 0x98, 0x6B, + 0x18, 0x2E, 0x03, 0x60, 0x85, 0x18, 0x46, 0x28, + 0x0E, 0x7C, 0x38, 0xF8, 0x4E, 0x8A, 0x4F, 0xDC, + 0x35, 0xB0, 0x01, 0x7C, 0x13, 0xC0, 0x79, 0x1D, + 0x0F, 0xD8, 0x38, 0xAA, 0xDF, 0xB1, 0xFE, 0x31, + 0xBE, 0x67, 0x90, 0x47, 0x9A, 0x2E, 0xD4, 0x70, + 0xDB, 0x68, 0x1E, 0xF9, 0x3B, 0xB4, 0x94, 0x03, + 0x6E, 0x7A, 0x5E, 0xA9, 0x7C, 0xE1, 0x5F, 0xE0 + }, + { + 0x84, 0x47, 0x75, 0xF6, 0xBD, 0x4F, 0x9B, 0x7C, + 0xED, 0x0B, 0xAA, 0xBC, 0xEA, 0xE8, 0x40, 0x8E, + 0x28, 0xAB, 0xDA, 0xD3, 0xDD, 0x32, 0xBD, 0x4C, + 0x93, 0x85, 0x31, 0x27, 0x91, 0x84, 0x75, 0x6E, + 0x4F, 0x48, 0x5B, 0xD3, 0xC3, 0x4E, 0x24, 0x4A, + 0xB6, 0x83, 0x43, 0x11, 0xE2, 0xD9, 0xAE, 0xB3, + 0x83, 0x44, 0xCA, 0x4B, 0xC5, 0xF6, 0x65, 0xB5, + 0x80, 0x82, 0x0A, 0x82, 0x9C, 0x61, 0xB4, 0x30 + }, + { + 0xB7, 0xEA, 0x2D, 0xC4, 0x3C, 0x2A, 0x07, 0xA9, + 0xF6, 0xA3, 0xC4, 0x1E, 0xCF, 0x0A, 0xA3, 0xDE, + 0xBD, 0x3D, 0xB1, 0xAD, 0x16, 0xEC, 0xC6, 0xF4, + 0x83, 0x07, 0xAB, 0xBE, 0x8A, 0x24, 0x7D, 0x89, + 0xD6, 0x61, 0x5B, 0x95, 0x1C, 0xCA, 0xA7, 0x6D, + 0x71, 0xBC, 0xEB, 0xBC, 0x3F, 0x23, 0x77, 0xF6, + 0x0D, 0xB1, 0x94, 0xC5, 0x11, 0x04, 0xA5, 0x3C, + 0x1A, 0x52, 0x65, 0xDE, 0x59, 0x91, 0x26, 0xD8 + }, + { + 0x56, 0x5A, 0x4E, 0x4B, 0x7B, 0xC5, 0x5A, 0x7F, + 0xDE, 0x55, 0x2C, 0xF8, 0x3C, 0x5E, 0xB7, 0x12, + 0xC6, 0x82, 0x00, 0xB2, 0xFD, 0x8A, 0xB6, 0x9F, + 0x4E, 0x63, 0xEF, 0x0E, 0x42, 0x70, 0xAE, 0x3C, + 0xC4, 0xEF, 0x0E, 0xD3, 0xF2, 0x8C, 0x57, 0xE6, + 0xA0, 0xFC, 0x51, 0xEC, 0xA2, 0xC2, 0x37, 0x17, + 0x0A, 0xD7, 0x6A, 0x21, 0x1A, 0x10, 0x0B, 0xB2, + 0x28, 0x9B, 0x39, 0x77, 0x2B, 0x6A, 0x92, 0x74 + }, + { + 0x83, 0x3F, 0x94, 0xB9, 0x1C, 0xE3, 0xB3, 0xC4, + 0x09, 0xF9, 0x72, 0x85, 0xD7, 0xBF, 0x96, 0xD4, + 0x0F, 0xF7, 0xB3, 0x15, 0x11, 0xDF, 0x4E, 0xA9, + 0xE8, 0xB7, 0xB0, 0xAE, 0xC6, 0xF2, 0x59, 0xC6, + 0x9D, 0xC6, 0x31, 0xA2, 0x40, 0x4F, 0x51, 0x64, + 0x04, 0xDC, 0xBA, 0x01, 0xB2, 0x83, 0x27, 0x86, + 0x63, 0x98, 0x6A, 0xC8, 0xD2, 0x32, 0x4B, 0x80, + 0x7D, 0xF3, 0x56, 0xE3, 0x6A, 0x4F, 0x18, 0x9F + }, + { + 0x23, 0xE3, 0xB6, 0xDE, 0xC1, 0xDF, 0xFA, 0x24, + 0x12, 0x21, 0x32, 0x61, 0xF3, 0x25, 0xB2, 0xC2, + 0x0E, 0x41, 0x85, 0xF6, 0x73, 0x0A, 0x9D, 0x30, + 0xFC, 0x23, 0x67, 0x00, 0x04, 0x43, 0x78, 0x23, + 0x06, 0x0C, 0x1F, 0xE4, 0x6B, 0xA7, 0xC6, 0xF3, + 0xA0, 0x6C, 0x1C, 0x9A, 0xD6, 0xA0, 0x4A, 0x9B, + 0xB8, 0xA4, 0xBE, 0xE0, 0xF6, 0x3A, 0x5A, 0x2A, + 0x79, 0x29, 0x42, 0x30, 0x6B, 0xF4, 0x19, 0xD5 + }, + { + 0x88, 0xFB, 0x5D, 0xF2, 0x92, 0x6F, 0x02, 0xCD, + 0xF4, 0xF4, 0x69, 0x8D, 0xAD, 0x89, 0xB4, 0xFF, + 0x9E, 0x5E, 0xEA, 0xCC, 0x9D, 0xE9, 0xCD, 0x33, + 0xD9, 0x73, 0xC1, 0x62, 0x96, 0x53, 0x4A, 0x55, + 0xD9, 0xC5, 0x8E, 0x37, 0x06, 0x65, 0xE2, 0xC8, + 0xD5, 0x12, 0xEB, 0x37, 0x6B, 0xFA, 0x22, 0x36, + 0xB1, 0xD4, 0xF2, 0xA2, 0x41, 0x2D, 0xB4, 0x80, + 0x17, 0x2A, 0x34, 0x5C, 0x72, 0x86, 0xBB, 0x11 + }, + { + 0xDE, 0xFC, 0x86, 0xD8, 0x29, 0x33, 0x7B, 0x06, + 0x1E, 0x75, 0xAA, 0x9F, 0x76, 0x63, 0x00, 0x9A, + 0x52, 0x58, 0x61, 0x49, 0x02, 0xA2, 0xCD, 0x92, + 0xEB, 0x36, 0x89, 0x84, 0xAB, 0x4E, 0x29, 0xB1, + 0xDF, 0x57, 0x85, 0x9C, 0x4B, 0x70, 0xC3, 0x05, + 0x25, 0x40, 0x91, 0x3B, 0x92, 0xEB, 0xAA, 0xB0, + 0xDF, 0x82, 0xC0, 0x7D, 0x70, 0xE0, 0x69, 0x88, + 0xFF, 0xF7, 0xBF, 0xAA, 0x7A, 0x97, 0x4E, 0xA8 + }, + { + 0x64, 0xBD, 0xAD, 0x3E, 0x99, 0x11, 0x11, 0x00, + 0x4E, 0xDC, 0x22, 0x8C, 0x90, 0xBD, 0x72, 0xEB, + 0x5E, 0xAD, 0x48, 0xEE, 0xAB, 0xF6, 0x47, 0xEA, + 0x22, 0x27, 0x6A, 0xA8, 0x77, 0xC6, 0x14, 0xA2, + 0xE1, 0x62, 0xAC, 0x6B, 0xC8, 0x1B, 0x07, 0x78, + 0x84, 0xBE, 0x32, 0xA4, 0x64, 0x1E, 0xBD, 0x49, + 0x39, 0xB7, 0x86, 0x82, 0xEA, 0x13, 0xCF, 0x67, + 0xF3, 0xD2, 0xA4, 0x1E, 0x97, 0x30, 0xA2, 0x9D + }, + { + 0x4F, 0x46, 0x76, 0xCA, 0x5B, 0x60, 0x7D, 0x45, + 0xCC, 0x12, 0xE4, 0x3E, 0xC4, 0x8B, 0x82, 0x37, + 0x3D, 0x65, 0x69, 0xC7, 0x3A, 0x4F, 0xA8, 0xB8, + 0xDC, 0x90, 0x1F, 0xA2, 0xCD, 0x00, 0x5A, 0x73, + 0x5E, 0x08, 0x56, 0x9A, 0xD1, 0x29, 0xB3, 0x37, + 0x1C, 0x8E, 0xF9, 0xCC, 0x58, 0x20, 0xEC, 0xF0, + 0xA3, 0xF9, 0x93, 0x8D, 0x08, 0x9D, 0x76, 0xB8, + 0x40, 0xDB, 0x60, 0x07, 0x4B, 0x62, 0xA4, 0x47 + }, + { + 0xB5, 0xEE, 0x91, 0x44, 0x0E, 0x40, 0x2D, 0xAB, + 0x9A, 0x47, 0x9D, 0x47, 0x32, 0x7E, 0x82, 0xEA, + 0x0F, 0xD7, 0x37, 0x1D, 0xB2, 0xAA, 0xC2, 0x8B, + 0x0B, 0x6A, 0xA6, 0xC1, 0xFA, 0xBC, 0x72, 0x78, + 0xCA, 0x75, 0x2A, 0x6A, 0x23, 0xDB, 0xD1, 0x88, + 0xB4, 0x51, 0x3F, 0x5E, 0x01, 0xA4, 0x2F, 0x8E, + 0xED, 0x9D, 0x3A, 0xFD, 0x6B, 0x96, 0x04, 0x1A, + 0xD1, 0x2B, 0x71, 0x6E, 0xA9, 0x95, 0x71, 0xB5 + }, + { + 0xE5, 0x5F, 0xF5, 0x41, 0x42, 0xD8, 0x19, 0xCB, + 0x94, 0x8E, 0x08, 0x6B, 0x44, 0x9B, 0xEB, 0xF5, + 0x60, 0xFF, 0x03, 0x03, 0x22, 0xA5, 0x81, 0xCE, + 0x25, 0x73, 0xAE, 0xB6, 0x51, 0xDD, 0xFC, 0xC2, + 0xF5, 0x3A, 0x4F, 0xA6, 0xA8, 0x50, 0xA6, 0x8E, + 0x00, 0x7D, 0x84, 0xCE, 0x57, 0x6C, 0xB8, 0xFE, + 0x94, 0x7F, 0x25, 0x14, 0x76, 0x96, 0x34, 0x76, + 0xDE, 0xA0, 0x18, 0x02, 0xCF, 0xB8, 0x5B, 0xAE + }, + { + 0xF4, 0xED, 0x63, 0x27, 0x9A, 0xC7, 0xD0, 0xF6, + 0x41, 0x62, 0x59, 0x04, 0x53, 0x5B, 0x6C, 0x05, + 0x29, 0xB6, 0xFD, 0xF1, 0x35, 0x00, 0x4E, 0xBE, + 0x49, 0x39, 0x67, 0x59, 0x95, 0xE3, 0xF6, 0xEC, + 0xF8, 0x28, 0xEB, 0xF4, 0xDA, 0x02, 0xE0, 0x22, + 0x09, 0x1F, 0x2A, 0x1A, 0x02, 0x47, 0x03, 0x5D, + 0xC5, 0xEC, 0x07, 0xCA, 0x73, 0x5C, 0x89, 0x5D, + 0xCD, 0xC6, 0x9D, 0xA5, 0x3E, 0x0F, 0x42, 0x5B + }, + { + 0xB4, 0x1B, 0x1C, 0xEC, 0xFA, 0xA4, 0x20, 0x2E, + 0x41, 0x3D, 0xA9, 0xB8, 0x69, 0x00, 0x88, 0xE0, + 0xCD, 0x99, 0xE0, 0x22, 0xB7, 0x5B, 0xC8, 0xE5, + 0xD3, 0xE2, 0x5E, 0xB2, 0xAE, 0x64, 0x56, 0x1C, + 0x7C, 0xBB, 0x28, 0x09, 0x5A, 0xC2, 0x39, 0x2D, + 0x9E, 0x56, 0xBB, 0xD1, 0xA9, 0x70, 0xBA, 0x19, + 0xB7, 0xC6, 0xE0, 0x80, 0xC7, 0x30, 0x50, 0x50, + 0x83, 0xC0, 0x6C, 0x17, 0xCE, 0xD1, 0xF6, 0x6A + }, + { + 0xC6, 0x13, 0x59, 0xDB, 0x4E, 0x26, 0x2C, 0x50, + 0x7F, 0xC1, 0x5F, 0xD8, 0xD7, 0x8B, 0x57, 0xE8, + 0xBE, 0x8E, 0xD3, 0x58, 0x61, 0xC2, 0x0A, 0x75, + 0x99, 0xF5, 0xD2, 0x18, 0x05, 0xAD, 0x9C, 0x17, + 0x57, 0x0E, 0x2D, 0xDA, 0x97, 0x28, 0x87, 0x94, + 0x45, 0xDE, 0x52, 0x2F, 0x91, 0x63, 0x61, 0x07, + 0x7E, 0xC9, 0x5B, 0x01, 0xB6, 0x17, 0x32, 0x0A, + 0x1A, 0x65, 0x4C, 0xB2, 0x9F, 0xB2, 0x33, 0x8E + }, + { + 0x03, 0x14, 0x39, 0xA0, 0x9F, 0xE3, 0x52, 0x75, + 0xC2, 0x84, 0x60, 0x82, 0x72, 0xC7, 0x37, 0x56, + 0xE4, 0xF5, 0xD7, 0x77, 0x3F, 0xE5, 0x17, 0xA0, + 0x57, 0x47, 0xC8, 0x3E, 0x49, 0xE4, 0x74, 0x36, + 0x48, 0xDF, 0x05, 0x01, 0xC7, 0x04, 0x4E, 0x5D, + 0x1F, 0x42, 0x62, 0xE2, 0xE6, 0x87, 0x6C, 0xF0, + 0x09, 0x77, 0x13, 0x82, 0x67, 0xAA, 0xBB, 0x68, + 0x13, 0x34, 0x9F, 0x5C, 0xC2, 0x85, 0x31, 0x44 + }, + { + 0x7D, 0x9C, 0x62, 0x9E, 0xAB, 0x4D, 0x9D, 0x69, + 0xF5, 0x06, 0x54, 0x19, 0xDA, 0x4D, 0x49, 0x59, + 0x7C, 0x44, 0xB7, 0x77, 0x79, 0xCA, 0x5B, 0xD6, + 0x44, 0x24, 0x3E, 0x4F, 0xC9, 0x11, 0xCD, 0xB0, + 0x54, 0xEE, 0xED, 0xEB, 0x23, 0x25, 0x26, 0x0A, + 0xBA, 0x6D, 0x2B, 0x7B, 0x7B, 0x80, 0x4D, 0x3A, + 0x04, 0x91, 0x4D, 0xEC, 0x9A, 0xD2, 0x3E, 0x91, + 0x6D, 0x68, 0x05, 0x35, 0xD5, 0x4F, 0xE5, 0x19 + }, + { + 0xC6, 0xD0, 0x32, 0x2F, 0x27, 0xE1, 0x4F, 0xF7, + 0xAB, 0x85, 0x82, 0x09, 0x04, 0x28, 0x7C, 0xAE, + 0x2E, 0x0D, 0x8B, 0x34, 0x69, 0xD7, 0x23, 0x4E, + 0xE7, 0x9C, 0xE2, 0xCC, 0x76, 0x9A, 0xB7, 0xC4, + 0x44, 0xEF, 0x43, 0xCF, 0x8F, 0xC6, 0x37, 0x2A, + 0x08, 0xD4, 0x5F, 0x94, 0x17, 0x69, 0xB5, 0x0D, + 0x91, 0xC8, 0x1D, 0x53, 0x22, 0xE4, 0x63, 0x4C, + 0x01, 0x97, 0x87, 0x5E, 0x0E, 0x1B, 0xE7, 0x8F + }, + { + 0xF2, 0xF4, 0xD7, 0x1D, 0xF3, 0x12, 0x5B, 0xE0, + 0x8E, 0xDC, 0x66, 0xAD, 0x10, 0xD0, 0xF4, 0x4A, + 0x2C, 0x1C, 0x18, 0x68, 0x6D, 0xCE, 0x8A, 0xEF, + 0x06, 0x70, 0x46, 0x9C, 0x2A, 0xC6, 0x60, 0x8D, + 0x12, 0x53, 0xE4, 0x43, 0x57, 0x26, 0xD0, 0x2A, + 0xF9, 0xFA, 0x5B, 0xC9, 0xB2, 0x03, 0x27, 0x79, + 0xC6, 0x6D, 0x28, 0xC1, 0xF9, 0x6E, 0x44, 0x02, + 0x49, 0x98, 0x9D, 0x65, 0x64, 0x44, 0xE3, 0x32 + }, + { + 0x05, 0xFC, 0x7E, 0x22, 0x48, 0xB8, 0x83, 0xCE, + 0x55, 0xFB, 0x81, 0x96, 0x97, 0x63, 0x1E, 0xFD, + 0x0B, 0xE8, 0x8C, 0xB7, 0x61, 0xA6, 0x5B, 0xBB, + 0x2D, 0xE0, 0xEE, 0x56, 0xAF, 0xC1, 0x09, 0x80, + 0x06, 0xAD, 0xEC, 0xDB, 0x0D, 0x98, 0xC2, 0x6C, + 0x67, 0x9C, 0xE6, 0x5D, 0x85, 0x76, 0x9F, 0xE3, + 0x03, 0xC7, 0x41, 0x2A, 0x3A, 0x7A, 0x9D, 0x9B, + 0xBC, 0xDF, 0xD9, 0xC7, 0x2B, 0xC5, 0xFE, 0xE1 + }, + { + 0x45, 0x90, 0x8F, 0xE6, 0x57, 0xA5, 0xD1, 0xCA, + 0x99, 0xBC, 0x90, 0x13, 0x5F, 0x07, 0x5C, 0xD2, + 0x30, 0x6C, 0x18, 0xFF, 0x81, 0x8A, 0x10, 0x85, + 0x6E, 0x2E, 0x82, 0x92, 0xC0, 0xE2, 0x36, 0xAA, + 0x33, 0x6F, 0xDD, 0x20, 0x00, 0xEE, 0xFC, 0xDA, + 0xFC, 0xCF, 0x6A, 0xEB, 0xCB, 0x0F, 0x47, 0x26, + 0x39, 0xE3, 0xF5, 0x1F, 0xC4, 0x39, 0x68, 0x18, + 0x80, 0x4E, 0x33, 0x61, 0xBD, 0x5F, 0x1C, 0xE1 + }, + { + 0x10, 0xA8, 0xC5, 0x23, 0xEF, 0xF1, 0xBB, 0x26, + 0x04, 0x9C, 0xF7, 0x66, 0x2E, 0xD2, 0x99, 0xED, + 0xA1, 0x1F, 0x5C, 0xB0, 0xCF, 0xFA, 0x94, 0x37, + 0xD4, 0x2F, 0x61, 0xE7, 0x99, 0x2B, 0x68, 0x5C, + 0x33, 0xD2, 0x85, 0x95, 0x50, 0x82, 0x00, 0xC7, + 0x7C, 0x97, 0x44, 0xB4, 0xCC, 0xF8, 0xA3, 0x42, + 0xA2, 0xE3, 0xE0, 0xF4, 0x70, 0xC9, 0x8B, 0x4F, + 0xE6, 0x7C, 0x5C, 0x0D, 0x70, 0x9F, 0x5C, 0x11 + }, + { + 0xB0, 0x0F, 0x5D, 0xAF, 0x60, 0x79, 0x80, 0x8E, + 0xF8, 0x86, 0x5F, 0x55, 0x7C, 0x16, 0xB1, 0x78, + 0x3E, 0x1D, 0x5F, 0x7C, 0x39, 0x19, 0x72, 0xA7, + 0x3C, 0xA1, 0xC3, 0xED, 0x3B, 0xA2, 0x38, 0x3B, + 0x5A, 0xCD, 0x52, 0x1F, 0xEA, 0xD7, 0x37, 0xFD, + 0x23, 0x13, 0xDA, 0xF0, 0x0E, 0x8F, 0x41, 0x88, + 0x36, 0x56, 0x2A, 0x98, 0x73, 0x53, 0x0A, 0x0A, + 0xB7, 0x7B, 0x6F, 0x14, 0xE1, 0x5E, 0xC7, 0x6E + }, + { + 0x42, 0x51, 0x45, 0x02, 0x80, 0xA8, 0xCC, 0x1F, + 0xC4, 0xC1, 0x82, 0xB3, 0xCF, 0xF4, 0x9A, 0x13, + 0xB9, 0x6B, 0x96, 0x23, 0x29, 0xCA, 0x79, 0x5B, + 0x76, 0xC2, 0xDF, 0x2C, 0x7A, 0xE3, 0x2A, 0xC9, + 0x51, 0x2C, 0x4E, 0xCA, 0x06, 0x7F, 0xA7, 0x0A, + 0xCA, 0xFF, 0x6E, 0xC7, 0x02, 0x11, 0xFE, 0x15, + 0x77, 0x5A, 0x6C, 0x06, 0x15, 0x96, 0xCF, 0x9F, + 0x99, 0xD4, 0x01, 0x39, 0xF4, 0xF5, 0x18, 0x2F + }, + { + 0x30, 0x7A, 0x1E, 0xBD, 0x1C, 0xD7, 0xD7, 0xD7, + 0x97, 0x72, 0x73, 0xD7, 0x60, 0x2D, 0x09, 0xD1, + 0xA6, 0xBF, 0x46, 0x11, 0xA2, 0x07, 0x93, 0x4E, + 0x9A, 0xCE, 0x9D, 0x8D, 0xC9, 0x23, 0xF8, 0x29, + 0xEB, 0x4A, 0xC4, 0x6C, 0x30, 0x1B, 0xE6, 0xE1, + 0xBE, 0xCF, 0x5E, 0x13, 0xA0, 0x2C, 0xF4, 0xA8, + 0x0B, 0x5D, 0x37, 0xCB, 0x60, 0x17, 0x7A, 0xE7, + 0x04, 0x4A, 0x98, 0x98, 0x9D, 0x80, 0xAD, 0xB8 + }, + { + 0x82, 0xB7, 0x29, 0xDB, 0x8E, 0x8D, 0x4E, 0x62, + 0x5C, 0x4D, 0x1E, 0x8E, 0x21, 0x5C, 0x80, 0x80, + 0xA7, 0x37, 0x55, 0xBC, 0x13, 0x02, 0x2A, 0x86, + 0x41, 0xA8, 0x7C, 0xE7, 0xA1, 0x96, 0xCD, 0x58, + 0x63, 0xF1, 0x47, 0xFC, 0x61, 0x14, 0x93, 0x62, + 0x7C, 0xB6, 0xDF, 0x5B, 0x65, 0xF5, 0x4F, 0x15, + 0x7B, 0x6F, 0xBB, 0x68, 0x65, 0xBA, 0x41, 0x9F, + 0xDF, 0x00, 0xE6, 0x2E, 0x80, 0x23, 0xD6, 0x95 + }, + { + 0x0C, 0x31, 0xBA, 0xB6, 0xBC, 0x89, 0xED, 0x36, + 0x91, 0xB8, 0x04, 0xE6, 0x1E, 0x34, 0xBA, 0x07, + 0x95, 0xFB, 0x64, 0x59, 0x96, 0x2E, 0x0D, 0x17, + 0xBB, 0x5B, 0x72, 0x06, 0x4C, 0x3B, 0xD7, 0xC0, + 0x73, 0xE7, 0x7D, 0x2F, 0x89, 0x87, 0x93, 0xDA, + 0x32, 0xD1, 0x9F, 0x17, 0x5A, 0x9F, 0x8B, 0x66, + 0x38, 0x49, 0x82, 0xA9, 0x75, 0x91, 0xDB, 0x9C, + 0x99, 0xB8, 0x62, 0xD4, 0x9D, 0xFF, 0x6C, 0x04 + }, + { + 0xE3, 0x87, 0x7D, 0xCF, 0x12, 0x2A, 0x2E, 0x8E, + 0x3D, 0x07, 0x0D, 0x9C, 0xCA, 0x87, 0xB7, 0xB4, + 0x32, 0xB6, 0xB1, 0x67, 0xC5, 0xE9, 0x99, 0xFA, + 0x54, 0x74, 0xAD, 0x9D, 0x08, 0xE6, 0xA5, 0xE4, + 0x9D, 0x64, 0xC0, 0x3E, 0x5F, 0xB7, 0x71, 0x2D, + 0xC3, 0xD0, 0x82, 0x08, 0xE2, 0x28, 0x9C, 0x29, + 0x03, 0x98, 0xC1, 0xC7, 0xB4, 0x84, 0x7E, 0xD8, + 0xA4, 0xEE, 0xAD, 0x28, 0x8C, 0x43, 0x49, 0x08 + }, + { + 0xC7, 0x01, 0x05, 0x12, 0x9F, 0x2C, 0x9F, 0x2D, + 0x15, 0x78, 0x8D, 0xE3, 0xAC, 0x98, 0x84, 0x85, + 0x2E, 0x90, 0xCF, 0x1B, 0xF0, 0x48, 0x5B, 0x1E, + 0x36, 0x8F, 0xD4, 0xA2, 0x9B, 0xCA, 0x17, 0xC9, + 0x53, 0xD5, 0xFB, 0xB6, 0xFF, 0x69, 0xE8, 0xE0, + 0x7B, 0x7B, 0x73, 0x78, 0xD6, 0xB6, 0xF9, 0x08, + 0x26, 0xDD, 0x41, 0x86, 0x2A, 0x69, 0x3A, 0x48, + 0x36, 0x27, 0xB3, 0xD7, 0x0D, 0x4A, 0x05, 0x78 + }, + { + 0x23, 0xB2, 0xA6, 0x6F, 0x29, 0x34, 0x30, 0x89, + 0x36, 0x22, 0xA8, 0xCC, 0x01, 0x43, 0x3F, 0x47, + 0x8F, 0x3D, 0x7D, 0x1F, 0x6B, 0xED, 0xA4, 0xF2, + 0xC2, 0x2E, 0x66, 0x0E, 0x60, 0x69, 0x91, 0x97, + 0x00, 0x7F, 0x76, 0x8D, 0x48, 0x7B, 0x16, 0x12, + 0xD6, 0xA2, 0x41, 0x53, 0xD2, 0x10, 0xEE, 0x6C, + 0xFC, 0x9F, 0x9B, 0x38, 0x47, 0xDD, 0x3E, 0xA4, + 0xE1, 0x33, 0x45, 0x75, 0x2A, 0x0D, 0x1C, 0x23 + }, + { + 0xD6, 0xCC, 0x68, 0xA8, 0xE7, 0xC4, 0x03, 0x38, + 0xB3, 0x40, 0x79, 0xB0, 0xC1, 0x5E, 0xEB, 0x6F, + 0xBC, 0x12, 0xD2, 0x4E, 0x1A, 0xE5, 0x7F, 0x9E, + 0x36, 0x4E, 0x6A, 0x29, 0x2A, 0x70, 0xE6, 0x97, + 0xBE, 0xF5, 0x30, 0xDC, 0x10, 0x35, 0x38, 0x31, + 0x00, 0x2D, 0xA4, 0x06, 0x5D, 0xD3, 0x72, 0x2A, + 0x90, 0xF1, 0xEF, 0x61, 0x74, 0xA8, 0x2A, 0xA2, + 0xF5, 0x24, 0xB6, 0xDA, 0xCB, 0x5C, 0x83, 0x51 + }, + { + 0x6F, 0x58, 0x74, 0x49, 0x87, 0x11, 0xFB, 0xAA, + 0x80, 0x65, 0x57, 0x1E, 0x0E, 0x38, 0xF1, 0x71, + 0xD7, 0xCA, 0xAE, 0xC7, 0xA0, 0x1B, 0xF2, 0xAF, + 0x9C, 0xB5, 0x5E, 0x52, 0xE5, 0x7A, 0x38, 0x2C, + 0xD6, 0xCD, 0x57, 0xD7, 0x7C, 0x5C, 0xD4, 0xF6, + 0x3F, 0x6E, 0x6A, 0x96, 0xA3, 0x7D, 0x1C, 0x8D, + 0xB7, 0x2F, 0x26, 0x81, 0x7C, 0x96, 0x94, 0xF8, + 0x00, 0x25, 0xC0, 0xE6, 0x9F, 0x77, 0x91, 0xFB + }, + { + 0x27, 0x5D, 0x79, 0x69, 0x5B, 0xD1, 0xD6, 0xB8, + 0x50, 0x1D, 0xA8, 0x53, 0xAE, 0xFA, 0xD4, 0xBA, + 0xBB, 0x13, 0xD8, 0x1E, 0xFF, 0x24, 0x7A, 0x58, + 0xAB, 0x02, 0x87, 0x78, 0x06, 0xA4, 0xA1, 0xBF, + 0xDE, 0x6F, 0x90, 0x68, 0x61, 0x92, 0x87, 0x5B, + 0xB2, 0x90, 0x7E, 0xD2, 0xE9, 0x64, 0x2C, 0x15, + 0x13, 0xAB, 0x77, 0xF8, 0x47, 0xCB, 0xEB, 0x9A, + 0x6C, 0x07, 0xB8, 0xFB, 0x4D, 0xAD, 0x7A, 0x1D + }, + { + 0xA0, 0xB8, 0x67, 0x31, 0x4D, 0x7B, 0x6A, 0x4D, + 0x5D, 0x4D, 0x9A, 0x22, 0x95, 0x9D, 0x57, 0xBD, + 0x47, 0x6C, 0xF0, 0x92, 0xDE, 0x99, 0xC0, 0xCE, + 0x39, 0x50, 0x84, 0xDA, 0xD3, 0xC2, 0x82, 0xCB, + 0x6D, 0x51, 0xA6, 0x0F, 0x81, 0xBB, 0x4B, 0xFF, + 0xDC, 0x77, 0xF8, 0x00, 0x78, 0xB4, 0x81, 0xE4, + 0xA0, 0xB5, 0xB0, 0x28, 0x7E, 0xEF, 0x7C, 0xD1, + 0x3F, 0x37, 0xA8, 0xD8, 0xB8, 0x2F, 0x32, 0x7D + }, + { + 0xC6, 0x37, 0x41, 0x09, 0x1D, 0xD1, 0x99, 0x03, + 0x92, 0xB1, 0xBF, 0x2B, 0x57, 0x9D, 0x67, 0x80, + 0x57, 0xC4, 0x78, 0xD2, 0x2D, 0xE4, 0xC4, 0xA5, + 0xD2, 0xE9, 0x80, 0xD2, 0x67, 0xCA, 0x60, 0x65, + 0x8E, 0xCE, 0xF3, 0xE7, 0xA9, 0x9C, 0xF9, 0xC8, + 0x2A, 0xDF, 0x62, 0x8F, 0xBA, 0x98, 0x91, 0x04, + 0x0E, 0x35, 0xAA, 0xC3, 0x26, 0xEF, 0x63, 0x6B, + 0xBB, 0x6E, 0x11, 0x55, 0x75, 0x3F, 0x2C, 0xAA + }, + { + 0x71, 0x62, 0x02, 0x15, 0xA4, 0x2E, 0x71, 0x58, + 0xD6, 0x67, 0x59, 0x16, 0x2B, 0xBA, 0x79, 0xC9, + 0xE1, 0x37, 0x80, 0x92, 0x84, 0x70, 0x89, 0xD2, + 0xC3, 0xF2, 0x4F, 0xC6, 0x29, 0x07, 0xBB, 0x2D, + 0x98, 0xB0, 0x27, 0x75, 0xE8, 0xCE, 0x28, 0x21, + 0x09, 0x88, 0xF4, 0xFC, 0x54, 0x04, 0x3F, 0x3A, + 0x64, 0xF0, 0x06, 0xDA, 0x28, 0x0D, 0x10, 0x18, + 0x70, 0xD7, 0xBF, 0x45, 0xF6, 0x21, 0xBC, 0xBE + }, + { + 0x1D, 0xB8, 0xBB, 0x18, 0xEA, 0xE7, 0xB1, 0xED, + 0x27, 0x0E, 0x28, 0x5C, 0x08, 0x6B, 0x3E, 0x10, + 0xC3, 0xE7, 0x32, 0x4A, 0xC6, 0x00, 0x5A, 0x14, + 0x06, 0x4A, 0x92, 0x8D, 0x96, 0xEE, 0xAC, 0x29, + 0x26, 0x4A, 0xBE, 0xA3, 0x80, 0x53, 0xC3, 0xAD, + 0x71, 0xE5, 0x52, 0x2E, 0xA6, 0xC2, 0xD0, 0x6E, + 0x21, 0x2C, 0x1C, 0x6A, 0xCB, 0x0D, 0x54, 0x37, + 0xF8, 0x87, 0x30, 0x3B, 0xC7, 0x33, 0xC2, 0x2C + }, + { + 0xCE, 0x71, 0x8C, 0xB1, 0xA6, 0x0E, 0x7C, 0xC0, + 0x52, 0xF2, 0x36, 0xFF, 0xBA, 0x84, 0xE3, 0x5E, + 0x94, 0x44, 0x17, 0x86, 0x9C, 0x93, 0xB0, 0xB0, + 0x00, 0xAA, 0x04, 0x61, 0xFD, 0x7F, 0x8D, 0x29, + 0x14, 0x62, 0x99, 0x87, 0x2F, 0x9C, 0xA6, 0x18, + 0x1A, 0x31, 0x72, 0xDB, 0xF7, 0xFA, 0x50, 0xDE, + 0xF1, 0x80, 0xCF, 0xFF, 0x15, 0x1D, 0x87, 0x60, + 0x6E, 0x53, 0x0C, 0xA2, 0x5B, 0xB0, 0xD1, 0x48 + }, + { + 0x0E, 0x56, 0xA7, 0xCC, 0xE4, 0xDB, 0xA2, 0x8C, + 0x2F, 0xEA, 0x5B, 0x5C, 0xBB, 0xEB, 0x98, 0xEB, + 0x0C, 0xDE, 0x2E, 0xC9, 0x2F, 0x0E, 0xDE, 0x34, + 0x18, 0x2D, 0x21, 0x24, 0xDF, 0x8E, 0x7D, 0x35, + 0xA2, 0xE9, 0xF3, 0xD8, 0xBB, 0x59, 0x98, 0xBF, + 0x77, 0x7A, 0xA4, 0x50, 0xD8, 0xA7, 0x6C, 0xA4, + 0x31, 0x59, 0x2B, 0x13, 0x8B, 0x4A, 0x2A, 0x39, + 0x05, 0xBB, 0x3C, 0x8C, 0xEE, 0xF6, 0xCF, 0xD6 + }, + { + 0x6E, 0xB4, 0x95, 0x32, 0xD6, 0x3C, 0x16, 0x9C, + 0x4C, 0xC3, 0x47, 0xBE, 0xD8, 0x4B, 0x1D, 0x38, + 0xCC, 0x3A, 0x21, 0x3D, 0x7D, 0x3F, 0x4D, 0xEE, + 0x90, 0xD8, 0x4C, 0xA4, 0x3D, 0xE1, 0xD2, 0x00, + 0xBF, 0xAD, 0xEF, 0xF1, 0x34, 0x75, 0xA8, 0xDB, + 0xC4, 0xE8, 0x68, 0x19, 0x51, 0x7B, 0xC7, 0x06, + 0x09, 0xBB, 0xC5, 0x1E, 0x7D, 0xC7, 0xAD, 0xB7, + 0xF4, 0xF9, 0x1C, 0xFC, 0x23, 0x53, 0x75, 0x38 + }, + { + 0x10, 0xC5, 0x3F, 0x18, 0x6E, 0x65, 0x28, 0xF1, + 0x63, 0x69, 0xB6, 0x57, 0x6F, 0xE5, 0x8E, 0x4A, + 0x6E, 0x38, 0x52, 0x0F, 0x41, 0xD4, 0xD4, 0xEC, + 0xA4, 0xC7, 0x28, 0x03, 0x7F, 0xAD, 0x77, 0xD8, + 0xB9, 0x2F, 0xAE, 0x71, 0x3F, 0x99, 0xE0, 0xE9, + 0xB7, 0xC2, 0x7A, 0xD0, 0x68, 0xF3, 0xE9, 0xF0, + 0xB5, 0x7E, 0x2C, 0xEA, 0x8F, 0x2A, 0x9E, 0x3F, + 0xD2, 0xA1, 0xF8, 0xF9, 0xA7, 0xB6, 0xAE, 0xA2 + }, + { + 0xD1, 0x7C, 0x61, 0xBE, 0xE3, 0x8F, 0x15, 0x73, + 0x09, 0x2B, 0x33, 0x78, 0xAA, 0xE6, 0x18, 0xDA, + 0xF8, 0x5F, 0x2B, 0x82, 0xDA, 0x74, 0xDC, 0xDD, + 0x64, 0x31, 0xD8, 0xDE, 0x56, 0x5C, 0x82, 0x26, + 0xCE, 0x56, 0x9C, 0xF9, 0x4D, 0x1E, 0x8E, 0xCB, + 0x0A, 0x0A, 0x6E, 0x67, 0xA0, 0x27, 0x16, 0xC0, + 0x02, 0x3F, 0x85, 0xC2, 0x64, 0xE1, 0x6C, 0x4B, + 0xDF, 0xC9, 0x07, 0xA3, 0x10, 0xCD, 0x90, 0x0B + }, + { + 0xD3, 0x33, 0xB3, 0x38, 0x9A, 0xC7, 0x34, 0xC1, + 0xB0, 0xC3, 0xEF, 0xF3, 0x64, 0x48, 0x67, 0x41, + 0x2F, 0xEE, 0xED, 0xCB, 0x2C, 0xDA, 0x05, 0xB1, + 0x61, 0x47, 0x4E, 0x04, 0xEA, 0x3D, 0x3A, 0x07, + 0x0C, 0x8D, 0x64, 0xE8, 0x94, 0x88, 0xF8, 0xD6, + 0xAD, 0x21, 0x4B, 0xB5, 0x2E, 0xB4, 0xBD, 0xBF, + 0x63, 0xEC, 0x53, 0x68, 0x64, 0x1B, 0xD7, 0x98, + 0x74, 0x80, 0x73, 0x09, 0xFF, 0x68, 0x08, 0x76 + }, + { + 0xAE, 0xF5, 0x85, 0x48, 0x83, 0x79, 0x58, 0x33, + 0x9A, 0x01, 0x40, 0x41, 0x9D, 0x80, 0x88, 0x40, + 0xC6, 0x61, 0xA6, 0x8D, 0xEF, 0x03, 0x56, 0xB9, + 0x56, 0x3F, 0x64, 0xC5, 0x35, 0x36, 0xA6, 0xD5, + 0xC6, 0x14, 0xCF, 0x7B, 0x13, 0x13, 0x71, 0x75, + 0xB8, 0x30, 0x9C, 0x1C, 0x81, 0xE6, 0x48, 0x9F, + 0xAB, 0xA1, 0xAA, 0x17, 0x8F, 0x5E, 0x65, 0xCA, + 0x2D, 0x77, 0x5B, 0x52, 0x4D, 0xD1, 0xBB, 0x16 + }, + { + 0x9A, 0x28, 0xE4, 0x7A, 0x4E, 0x55, 0x27, 0x24, + 0x6C, 0x96, 0xE9, 0xC8, 0xCD, 0xEE, 0xCA, 0xE8, + 0xB4, 0xDF, 0x19, 0xA4, 0x4A, 0x12, 0x23, 0x52, + 0x93, 0x20, 0x03, 0x60, 0xF9, 0x73, 0xCA, 0x34, + 0xBB, 0xC2, 0xA9, 0xED, 0xC4, 0xF5, 0xE8, 0x39, + 0x29, 0xF8, 0x1B, 0x88, 0x1E, 0xF4, 0x6B, 0x8C, + 0x38, 0x70, 0xD0, 0x01, 0xC1, 0x88, 0xDD, 0x4F, + 0x60, 0xCB, 0x2C, 0x7C, 0x8F, 0x0F, 0x3E, 0xED + }, + { + 0xAA, 0xF6, 0xD4, 0x5A, 0x35, 0x74, 0x14, 0xCE, + 0xA3, 0xE0, 0x1B, 0x17, 0xC4, 0x3B, 0xFF, 0x01, + 0xB9, 0x6F, 0xF7, 0x22, 0xF8, 0xE2, 0x14, 0xB5, + 0x30, 0x79, 0xDE, 0x39, 0x4F, 0xF6, 0x84, 0x44, + 0xE3, 0x01, 0xEA, 0x2F, 0xA2, 0xA9, 0x28, 0x87, + 0x61, 0x2E, 0xDA, 0x8C, 0x4B, 0x23, 0xA3, 0x17, + 0xD2, 0x54, 0x02, 0x34, 0x25, 0xA4, 0x0A, 0x28, + 0x7C, 0xD0, 0x46, 0xEA, 0x01, 0x1A, 0x2B, 0x7F + }, + { + 0xF0, 0x4E, 0x38, 0xDE, 0xE2, 0xCB, 0x08, 0xB9, + 0x1A, 0xE3, 0x92, 0x20, 0xDC, 0x0A, 0x48, 0xC1, + 0xCC, 0x6E, 0x27, 0x1A, 0x99, 0x52, 0x0B, 0xE5, + 0xCB, 0x66, 0xAA, 0x83, 0xDF, 0xBF, 0x3A, 0x40, + 0x8D, 0xC8, 0x99, 0x72, 0x3C, 0x47, 0x88, 0x58, + 0x54, 0xA4, 0x09, 0xB6, 0x73, 0xC5, 0x68, 0x84, + 0xCF, 0xDF, 0x38, 0x77, 0xD4, 0xB1, 0xC8, 0x77, + 0x8D, 0x28, 0x1F, 0xFF, 0x1A, 0x28, 0x8D, 0xB8 + }, + { + 0x67, 0xFF, 0xBF, 0x44, 0x5E, 0x7A, 0xBF, 0xDC, + 0xE1, 0x63, 0x9C, 0x2B, 0xA7, 0x8F, 0x94, 0xC7, + 0x4F, 0x79, 0x23, 0x64, 0x2C, 0x93, 0x6A, 0x41, + 0x56, 0x3A, 0xDB, 0x82, 0x6A, 0x40, 0xEA, 0x2F, + 0xDE, 0xFA, 0x75, 0x3D, 0x46, 0xA5, 0xB0, 0x1B, + 0x3C, 0xA7, 0x6A, 0xE5, 0x26, 0x82, 0xDE, 0xD5, + 0x8C, 0xEE, 0xE0, 0x91, 0x5F, 0x79, 0x36, 0x1F, + 0x81, 0xBA, 0x5F, 0xB7, 0xEF, 0x6B, 0x1D, 0x49 + }, + { + 0x6E, 0xDC, 0xEB, 0xDC, 0x32, 0x5A, 0x3C, 0x50, + 0x63, 0x75, 0xED, 0x5E, 0x98, 0x7B, 0x45, 0xDA, + 0xA6, 0xB6, 0xB6, 0xBB, 0xF9, 0x6C, 0x5A, 0x73, + 0xFC, 0xA5, 0x3A, 0x37, 0x4B, 0x40, 0x9E, 0xC4, + 0x36, 0x79, 0xD6, 0x46, 0x61, 0xAD, 0x1C, 0x0D, + 0x92, 0x60, 0xDD, 0x9B, 0x8C, 0xE8, 0x79, 0x82, + 0x48, 0xCA, 0x29, 0xCE, 0x7A, 0x95, 0xE8, 0x4A, + 0x43, 0xA7, 0x06, 0x7D, 0x1F, 0xB5, 0xA8, 0x74 + }, + { + 0xEB, 0x73, 0x01, 0x49, 0xDC, 0xD6, 0xC4, 0xDB, + 0xBA, 0x73, 0x20, 0xE5, 0x08, 0x80, 0xB6, 0x7A, + 0x6B, 0xDE, 0xA0, 0x01, 0xFF, 0x5F, 0x59, 0x04, + 0x5E, 0xA4, 0x53, 0xD9, 0x4E, 0x1E, 0x64, 0x08, + 0x31, 0x33, 0x0B, 0x38, 0xCE, 0x5E, 0x2B, 0x93, + 0x3E, 0x08, 0x14, 0xC2, 0x08, 0x2D, 0xCE, 0xA8, + 0x59, 0xBF, 0x7D, 0x07, 0x56, 0xBD, 0x2F, 0x52, + 0x1E, 0x7E, 0x3A, 0x91, 0x3D, 0x19, 0x3E, 0x72 + }, + { + 0x2F, 0x27, 0xAC, 0x28, 0xB3, 0x14, 0x1D, 0x09, + 0xE9, 0x80, 0x88, 0xBC, 0xCE, 0x35, 0x63, 0x5B, + 0x0D, 0xA5, 0xD8, 0x59, 0x1D, 0x9D, 0xF0, 0xBE, + 0xDA, 0x00, 0x6A, 0x72, 0xC6, 0xAC, 0x08, 0xD3, + 0xF1, 0x2C, 0x42, 0xFB, 0x93, 0xCA, 0x76, 0x46, + 0xBE, 0xA0, 0xE9, 0x56, 0x77, 0xDA, 0xBB, 0x67, + 0x72, 0x2F, 0x01, 0x84, 0x1B, 0x95, 0xDD, 0xCA, + 0x11, 0xFD, 0x51, 0x50, 0xCF, 0xAC, 0x43, 0x23 + }, + { + 0x2C, 0x47, 0xDC, 0x09, 0x73, 0xE4, 0x90, 0xD3, + 0x95, 0x2C, 0xFF, 0x03, 0x63, 0x8A, 0x44, 0x4F, + 0x79, 0x2F, 0xE6, 0xF5, 0xFF, 0x13, 0xBB, 0x96, + 0x17, 0x03, 0x72, 0xA1, 0x45, 0xC1, 0x3A, 0xEA, + 0xF8, 0x71, 0x8F, 0x21, 0xEE, 0x97, 0xF6, 0x51, + 0x98, 0x44, 0x6A, 0x4A, 0xC0, 0xDE, 0x08, 0x2C, + 0xB7, 0x7B, 0x98, 0x56, 0x4A, 0xE9, 0xE4, 0x19, + 0x50, 0xC1, 0x04, 0x26, 0xB7, 0x85, 0x2D, 0x4C + }, + { + 0x31, 0xB1, 0x04, 0x7B, 0xC8, 0xC9, 0x45, 0x03, + 0x7D, 0x16, 0x17, 0xF6, 0x41, 0x78, 0x8C, 0xCE, + 0xDD, 0x78, 0x30, 0xDE, 0xD8, 0x1B, 0x93, 0x7F, + 0xA4, 0x84, 0xED, 0x4C, 0xEC, 0xA6, 0x46, 0xEB, + 0x4D, 0x45, 0xBF, 0xE1, 0x44, 0xFB, 0xC9, 0x5F, + 0x23, 0x60, 0x9A, 0xB0, 0x45, 0xD5, 0x02, 0x7C, + 0x6E, 0x21, 0xB8, 0x14, 0x60, 0xD1, 0x09, 0x2C, + 0xC0, 0x29, 0x6F, 0x85, 0x49, 0x83, 0x9D, 0xFF + }, + { + 0xD7, 0x88, 0x85, 0x5B, 0xF8, 0xFF, 0x3C, 0xB5, + 0x03, 0x60, 0xB7, 0x46, 0x39, 0x39, 0x95, 0x1F, + 0x53, 0x96, 0x29, 0x99, 0x94, 0xDD, 0xE1, 0xA5, + 0xBF, 0x42, 0x8B, 0x66, 0xD8, 0xD9, 0x08, 0x18, + 0x61, 0xBB, 0x6F, 0x31, 0xC1, 0x46, 0xFB, 0x4F, + 0xD5, 0x47, 0x21, 0x6C, 0x4D, 0x35, 0x7D, 0xDC, + 0x10, 0x67, 0x92, 0xD7, 0xF9, 0x70, 0xBF, 0x47, + 0x61, 0x6F, 0xF0, 0x7D, 0xCB, 0x91, 0x75, 0xC9 + }, + { + 0x45, 0x9D, 0x15, 0x9B, 0xBC, 0x1A, 0x84, 0xD8, + 0x37, 0x93, 0x77, 0x1D, 0xC9, 0x31, 0x55, 0x9C, + 0xF6, 0x4B, 0x00, 0x8C, 0x93, 0x81, 0xCD, 0x7A, + 0x06, 0x00, 0xFD, 0x11, 0x51, 0xD1, 0x44, 0x51, + 0x16, 0xD3, 0xEB, 0x2B, 0x8A, 0xA4, 0x6F, 0x87, + 0xB3, 0xEE, 0xA7, 0x2B, 0xCE, 0xE6, 0xCC, 0xC7, + 0x17, 0x00, 0x9D, 0xDF, 0x31, 0xD0, 0x21, 0xAF, + 0x40, 0x33, 0xF0, 0x0C, 0x6E, 0x86, 0xBF, 0x8F + }, + { + 0x82, 0xCD, 0x4D, 0x5C, 0xB3, 0x10, 0xA5, 0x14, + 0xD1, 0x7B, 0x0D, 0x09, 0xC3, 0x51, 0xDD, 0x5C, + 0xE1, 0x2F, 0xC8, 0x14, 0xCD, 0x67, 0x72, 0x2A, + 0x05, 0xF0, 0xE0, 0x79, 0x5C, 0x3C, 0x54, 0x99, + 0x18, 0x61, 0xF0, 0xC3, 0xB5, 0xCA, 0x54, 0x3A, + 0x1B, 0xB6, 0x82, 0xE3, 0x87, 0x69, 0x0D, 0xE3, + 0x2F, 0x24, 0x43, 0xE7, 0xFF, 0xDC, 0xBA, 0xEE, + 0x96, 0xE4, 0x4A, 0xD5, 0xF8, 0x0B, 0xA1, 0x05 + }, + { + 0xF0, 0x27, 0x19, 0x56, 0xD6, 0xD9, 0xDD, 0x26, + 0x88, 0x47, 0x2F, 0xDC, 0xEA, 0x8D, 0x31, 0xA4, + 0xC1, 0x9B, 0x5B, 0x1F, 0x9B, 0x07, 0x7C, 0xEE, + 0x33, 0x60, 0x35, 0x71, 0x48, 0x3A, 0x54, 0xAC, + 0x75, 0x2D, 0xE6, 0x3A, 0x31, 0xA8, 0xF6, 0xD0, + 0x3C, 0xDE, 0x3C, 0x9A, 0xEE, 0x6F, 0x31, 0xBF, + 0x84, 0xFB, 0x18, 0xAE, 0xF6, 0x62, 0x19, 0x9B, + 0xDA, 0xEC, 0x2A, 0x8B, 0xC3, 0x0B, 0xB0, 0xBD + }, + { + 0x98, 0x38, 0xB0, 0x40, 0x00, 0x34, 0x7A, 0x5B, + 0x48, 0xCF, 0x1F, 0x12, 0xD9, 0xF5, 0x32, 0xD1, + 0x7F, 0xBC, 0x4B, 0x95, 0xE1, 0xDB, 0xFE, 0x0F, + 0x9B, 0x76, 0x53, 0x61, 0xB4, 0x8F, 0xE8, 0xA5, + 0x4B, 0x58, 0x52, 0x5A, 0x47, 0xA0, 0xC1, 0x30, + 0xEB, 0xDA, 0x6B, 0xBE, 0x0A, 0x70, 0xAA, 0x32, + 0x8D, 0x65, 0x73, 0x4A, 0x92, 0x7B, 0x5E, 0x31, + 0x0B, 0x55, 0x9E, 0x92, 0xC2, 0xA0, 0x5C, 0x5B + }, + { + 0xCC, 0x06, 0xAA, 0x05, 0x19, 0x73, 0x97, 0x63, + 0x9C, 0x2C, 0x55, 0x29, 0xCC, 0x67, 0xFD, 0x41, + 0x36, 0x7F, 0x52, 0x93, 0xB5, 0x52, 0x99, 0xB2, + 0x94, 0x74, 0x8A, 0x27, 0x95, 0xE5, 0x1C, 0x79, + 0x9A, 0x7A, 0x07, 0x03, 0x90, 0xE2, 0x29, 0x3D, + 0x08, 0xA2, 0xF4, 0x7F, 0xF6, 0xF5, 0xD5, 0x62, + 0xFC, 0x78, 0x68, 0x71, 0x88, 0xB9, 0x90, 0x3A, + 0x4F, 0x89, 0xA3, 0xAE, 0x78, 0xB7, 0x78, 0xBC + }, + { + 0xA6, 0x47, 0xCC, 0xF8, 0x28, 0xDD, 0x0E, 0xF0, + 0x92, 0x50, 0x33, 0xE2, 0xB7, 0x38, 0x22, 0x6D, + 0x9C, 0x40, 0x57, 0x73, 0x7C, 0xA6, 0x6D, 0x43, + 0xE4, 0x99, 0x59, 0x36, 0x63, 0xB5, 0xDF, 0xCB, + 0x14, 0xE5, 0x27, 0xD3, 0x3B, 0xB2, 0x74, 0xE3, + 0x40, 0x83, 0xD6, 0xC4, 0x34, 0x73, 0xC5, 0x4D, + 0xB1, 0x16, 0x05, 0xF6, 0xBB, 0x73, 0x2B, 0x89, + 0xC2, 0xAE, 0x65, 0x95, 0xB2, 0xBD, 0x26, 0x1E + }, + { + 0x84, 0x17, 0x03, 0xA8, 0x6E, 0xCB, 0x58, 0x50, + 0x0F, 0xF2, 0xFD, 0x22, 0x6E, 0x7D, 0x78, 0x5F, + 0xE1, 0xA9, 0x85, 0xE7, 0x96, 0x6B, 0x6E, 0xBB, + 0x5E, 0x59, 0x4C, 0x2A, 0x34, 0x19, 0x0E, 0xD0, + 0x9E, 0xCB, 0x38, 0x69, 0x27, 0x61, 0xE8, 0xEA, + 0xF8, 0x78, 0xDF, 0x51, 0x7C, 0xEB, 0xC2, 0x76, + 0xCD, 0x03, 0x1E, 0x76, 0xD9, 0x53, 0xF2, 0x82, + 0x89, 0xD9, 0x0E, 0xC3, 0xDB, 0xAB, 0x12, 0x67 + }, + { + 0x55, 0xDC, 0xB9, 0x8E, 0xBE, 0x65, 0x56, 0x7E, + 0x22, 0x52, 0x6E, 0x83, 0x54, 0x16, 0xD5, 0xE4, + 0x8C, 0xF2, 0xD8, 0x4A, 0xDB, 0x73, 0x05, 0x5F, + 0x77, 0x0F, 0xDF, 0xFA, 0x6C, 0xA5, 0xC0, 0xBA, + 0x1B, 0x1E, 0x3C, 0x0B, 0x23, 0x1D, 0x52, 0xF5, + 0x39, 0x74, 0xC0, 0xDF, 0xE0, 0xF4, 0xF3, 0xAA, + 0x04, 0x46, 0x10, 0x9F, 0xD4, 0xDE, 0x14, 0xCB, + 0x3A, 0xA7, 0x37, 0x5D, 0xDE, 0xD7, 0x0A, 0x90 + }, + { + 0x2A, 0x6E, 0x81, 0x13, 0x6F, 0x18, 0x08, 0xDC, + 0xB0, 0x1D, 0x3C, 0x9E, 0xE7, 0x6B, 0x66, 0x9F, + 0xE6, 0x1A, 0xBE, 0x5F, 0xA7, 0x63, 0x1A, 0xE0, + 0xBE, 0x21, 0x87, 0x50, 0x97, 0xC2, 0x12, 0x67, + 0xF9, 0x18, 0xB5, 0x76, 0x00, 0x3A, 0x1F, 0x6B, + 0x2A, 0x41, 0xDC, 0xC3, 0x66, 0x8B, 0x1F, 0xA4, + 0x47, 0x24, 0xCA, 0x7F, 0x30, 0xAD, 0x4E, 0x90, + 0xD3, 0x46, 0xD3, 0x35, 0x05, 0x37, 0x2D, 0xFF + }, + { + 0x33, 0x9C, 0x62, 0x6E, 0x8F, 0xA3, 0x0D, 0xDF, + 0x55, 0x5B, 0xCD, 0x77, 0xB7, 0x84, 0xCB, 0x0C, + 0xDD, 0x87, 0xAA, 0x11, 0xC7, 0xB2, 0x9D, 0x7C, + 0xA3, 0xC9, 0xA4, 0x0C, 0x2F, 0xC9, 0x64, 0x21, + 0x2A, 0xA9, 0x3B, 0x2E, 0xAA, 0xC9, 0x47, 0x96, + 0x33, 0x6F, 0x64, 0xB4, 0x7E, 0x0D, 0xC9, 0x77, + 0x76, 0x93, 0x13, 0x74, 0xBA, 0x0D, 0x79, 0xAA, + 0xCB, 0x61, 0xB2, 0x78, 0x81, 0x51, 0x4D, 0xE7 + }, + { + 0xF7, 0xB3, 0xDB, 0xB4, 0xDB, 0xC9, 0x71, 0x54, + 0x81, 0x07, 0x72, 0xD5, 0x16, 0x87, 0x7C, 0x06, + 0xB7, 0x30, 0xFD, 0x00, 0xB9, 0xA5, 0x43, 0x71, + 0x61, 0x88, 0xEC, 0x12, 0x50, 0x4E, 0x03, 0xE3, + 0xD9, 0x4E, 0x59, 0x6B, 0x4C, 0x9C, 0x76, 0xE9, + 0x92, 0x3F, 0xFA, 0xFB, 0x6E, 0x11, 0x7D, 0x35, + 0xDB, 0x3E, 0x93, 0xD1, 0xEA, 0x65, 0xC6, 0x8D, + 0xFB, 0x82, 0x9E, 0x48, 0x90, 0x60, 0x0E, 0x22 + }, + { + 0x4B, 0x52, 0x4A, 0xAF, 0x04, 0xD7, 0x5A, 0xC3, + 0xE4, 0x07, 0x9F, 0x04, 0x3F, 0x95, 0x83, 0xE6, + 0x8E, 0xCD, 0x47, 0x6F, 0xE6, 0x40, 0xC5, 0xFB, + 0xAD, 0xBD, 0x5A, 0xAA, 0xDA, 0x2B, 0x56, 0xEC, + 0x2A, 0x69, 0x49, 0xF1, 0x4B, 0xCD, 0xD0, 0x95, + 0x8E, 0xAA, 0x23, 0xD6, 0x54, 0x23, 0x96, 0x01, + 0x1E, 0x54, 0x94, 0xE1, 0x5C, 0x23, 0x3F, 0x38, + 0x74, 0x35, 0xC9, 0x9E, 0x34, 0x77, 0x3C, 0x27 + }, + { + 0x7B, 0xD0, 0x28, 0x7A, 0x9F, 0x74, 0x5A, 0x62, + 0xBD, 0x63, 0x01, 0x70, 0x47, 0x53, 0x50, 0xF0, + 0x70, 0x34, 0xAF, 0x2F, 0x9B, 0x32, 0x24, 0x79, + 0x6E, 0xD6, 0xD4, 0x7E, 0x57, 0xA3, 0x68, 0x49, + 0x1B, 0xD6, 0x4F, 0xD3, 0x91, 0x2A, 0x20, 0x84, + 0xC1, 0x00, 0x2C, 0x78, 0x68, 0x40, 0x78, 0xDC, + 0xFE, 0xD3, 0xF7, 0xFA, 0x4F, 0xCE, 0x54, 0x55, + 0xF7, 0x89, 0x84, 0x08, 0xB7, 0xCB, 0xD0, 0x2E + }, + { + 0x04, 0xA2, 0xE8, 0xB3, 0x4A, 0x8C, 0x06, 0x86, + 0xB0, 0x9C, 0x44, 0xC1, 0xE0, 0x6A, 0xE6, 0x15, + 0xF6, 0x3C, 0x26, 0xE0, 0x33, 0x9A, 0x29, 0x91, + 0x28, 0x31, 0x52, 0x31, 0x52, 0xC1, 0x01, 0x54, + 0x0D, 0x13, 0x04, 0x61, 0x60, 0x1E, 0x76, 0x2E, + 0x8E, 0x80, 0x7A, 0xA5, 0x56, 0xDD, 0xC2, 0x5E, + 0x85, 0x52, 0xFD, 0x96, 0x7D, 0x5A, 0x73, 0xBF, + 0x85, 0xE8, 0x9D, 0xE3, 0x5A, 0x14, 0xB0, 0x65 + }, + { + 0x19, 0x00, 0x90, 0x19, 0x16, 0x70, 0x2A, 0x46, + 0x1B, 0xCC, 0x3A, 0x05, 0x1B, 0x14, 0x12, 0xDD, + 0x5D, 0x31, 0xA9, 0x04, 0x38, 0x44, 0x40, 0x70, + 0x2D, 0xD8, 0x97, 0xDA, 0x7A, 0xCD, 0xD8, 0xDE, + 0x73, 0xF5, 0xFD, 0x5F, 0x96, 0x8E, 0xE6, 0xEE, + 0xFE, 0x6C, 0x22, 0xC4, 0xA0, 0xB8, 0xA3, 0x72, + 0x21, 0xF4, 0x16, 0x75, 0x92, 0x01, 0x3C, 0xE5, + 0x98, 0x08, 0x15, 0x0E, 0xC6, 0x13, 0xB5, 0x61 + }, + { + 0xA7, 0xF5, 0x15, 0x52, 0x6C, 0x6D, 0x09, 0x5D, + 0x51, 0x01, 0x97, 0x86, 0x04, 0xA2, 0xA6, 0x3B, + 0xE9, 0x5E, 0xE1, 0xF1, 0x6A, 0x91, 0x8A, 0x44, + 0x75, 0xA8, 0x55, 0xB1, 0xEF, 0xC0, 0x0F, 0x32, + 0x78, 0x59, 0x0D, 0x2E, 0x6E, 0xC6, 0x19, 0x82, + 0xB2, 0x81, 0x93, 0x1E, 0x22, 0x61, 0xC2, 0xB3, + 0x98, 0x42, 0x7B, 0x10, 0x8A, 0xAC, 0xA8, 0xDC, + 0xD9, 0xC3, 0xC3, 0x36, 0x01, 0xFB, 0xCA, 0x33 + }, + { + 0xBC, 0xDE, 0xCC, 0xA6, 0xF7, 0x30, 0x2D, 0xD4, + 0x2E, 0x5F, 0x35, 0xC9, 0xD1, 0xFD, 0xFB, 0x1F, + 0xB5, 0x93, 0x0D, 0xA7, 0xA7, 0xCD, 0x7C, 0x68, + 0xB2, 0x6E, 0xEF, 0xE7, 0x3C, 0x3B, 0x06, 0x98, + 0xEE, 0x79, 0x00, 0x61, 0xA9, 0x90, 0xAA, 0x67, + 0x38, 0x3E, 0xEB, 0xE5, 0xE8, 0x1C, 0xB0, 0xBF, + 0xEA, 0xFF, 0xDD, 0x49, 0xC9, 0xEE, 0x83, 0xA6, + 0xD2, 0xED, 0xE2, 0xD7, 0xCA, 0x84, 0x08, 0x38 + }, + { + 0x2F, 0x7A, 0xAB, 0x2F, 0xC9, 0x18, 0x5C, 0xA1, + 0xFC, 0x9B, 0x46, 0xB0, 0x84, 0x75, 0x77, 0xCC, + 0xAC, 0x88, 0x8B, 0x5F, 0x52, 0xC2, 0xDA, 0xC5, + 0xEF, 0x7A, 0xC3, 0x9D, 0xAD, 0xCE, 0xC9, 0xA4, + 0xD2, 0xE5, 0x5C, 0xE1, 0x46, 0x3B, 0xE1, 0x37, + 0x44, 0x0F, 0x45, 0x7D, 0x76, 0x89, 0xF1, 0x64, + 0x20, 0x99, 0xE7, 0xD7, 0x6B, 0x3F, 0x1D, 0x02, + 0x8C, 0x20, 0x74, 0x11, 0xDB, 0x4F, 0xD3, 0x4E + }, + { + 0x4E, 0xBE, 0xE9, 0x73, 0xF7, 0x08, 0xC6, 0x4C, + 0x99, 0xBD, 0x92, 0xD1, 0x2C, 0x94, 0x2D, 0xAC, + 0x7E, 0xFD, 0x73, 0xBD, 0xFE, 0xFC, 0xFB, 0x2D, + 0xB9, 0xD7, 0x39, 0x59, 0xDC, 0xFD, 0x66, 0x62, + 0x03, 0xD8, 0x42, 0x47, 0x6C, 0x9F, 0xC8, 0xD2, + 0x5F, 0x81, 0xB2, 0x44, 0x13, 0xF1, 0x3A, 0xB3, + 0xDD, 0x2E, 0xA7, 0xB8, 0xEF, 0x35, 0x4B, 0x37, + 0xDA, 0x32, 0xCB, 0x74, 0xFC, 0x6F, 0xB2, 0xCB + }, + { + 0xD4, 0x2F, 0xF6, 0x32, 0x3A, 0x7D, 0x1D, 0xE0, + 0xFC, 0xFF, 0xB5, 0x27, 0xFD, 0x89, 0xF4, 0x48, + 0xF5, 0x28, 0x3D, 0x86, 0x3C, 0x02, 0x0E, 0x07, + 0xA5, 0x0D, 0x53, 0xED, 0xFE, 0x66, 0xDD, 0xB1, + 0x4A, 0xF6, 0xFA, 0x79, 0x81, 0x8F, 0x1F, 0x9C, + 0xB1, 0x2B, 0xE4, 0x5D, 0x4F, 0x79, 0xC6, 0x18, + 0x1B, 0x2F, 0x6A, 0xB1, 0x62, 0xF9, 0xD9, 0xE8, + 0xF4, 0x60, 0x0D, 0xFE, 0x6B, 0x97, 0x58, 0xC5 + }, + { + 0xA7, 0x25, 0x21, 0xCB, 0xAF, 0xFA, 0x99, 0x9C, + 0x39, 0x33, 0x04, 0x50, 0xF7, 0xA2, 0x3F, 0x92, + 0x9C, 0xAB, 0xEB, 0xAC, 0xE5, 0x95, 0x74, 0x3E, + 0xCF, 0x97, 0x54, 0xCF, 0x38, 0x8B, 0xA4, 0x33, + 0xF6, 0xF2, 0xD2, 0x7D, 0x6C, 0xEB, 0xB1, 0x44, + 0xA4, 0x0D, 0xDA, 0xE8, 0x7C, 0xB4, 0x0A, 0xA6, + 0xDB, 0x47, 0xAF, 0x4A, 0x41, 0xD8, 0xFA, 0x5A, + 0x3A, 0x74, 0x08, 0x57, 0xCB, 0x4A, 0x83, 0xEE + }, + { + 0x92, 0x02, 0x12, 0x85, 0x61, 0x7C, 0x45, 0x2C, + 0x6D, 0xA1, 0xAB, 0x34, 0x68, 0xD0, 0xEC, 0x3B, + 0x8D, 0x7B, 0x85, 0xB0, 0xDC, 0xA4, 0x86, 0xFD, + 0x86, 0xAE, 0x78, 0x3D, 0x52, 0xAD, 0xE9, 0x46, + 0x8A, 0xB1, 0x14, 0xDD, 0xF4, 0xE6, 0x21, 0x4A, + 0x2D, 0x2D, 0x5E, 0x86, 0x26, 0x65, 0xD4, 0x09, + 0x29, 0xCF, 0x2D, 0xE9, 0xE7, 0x18, 0x59, 0x47, + 0xD7, 0x8B, 0xEF, 0x0D, 0x41, 0x83, 0xAF, 0x0D + }, + { + 0xAE, 0x9D, 0x45, 0x33, 0x14, 0x37, 0xBE, 0xAF, + 0x54, 0xE8, 0xE7, 0x51, 0xE9, 0xDE, 0x60, 0xD9, + 0xE7, 0xC2, 0x47, 0x2C, 0x87, 0x0F, 0xE3, 0xE5, + 0x86, 0x8D, 0xE9, 0xAA, 0xEB, 0x12, 0x13, 0x13, + 0x1F, 0xD5, 0xA6, 0x1B, 0x9A, 0xBA, 0x49, 0x5D, + 0x3E, 0xD2, 0xB8, 0x77, 0xB2, 0x6E, 0x7F, 0x77, + 0xDA, 0x71, 0x43, 0xF7, 0x44, 0xF0, 0x73, 0x2B, + 0x68, 0x37, 0xCD, 0xBD, 0xB1, 0x71, 0x06, 0x30 + }, + { + 0x15, 0x3F, 0x32, 0xE9, 0x8C, 0x4F, 0xEE, 0x0A, + 0xCF, 0x3E, 0x26, 0xD8, 0x74, 0xC6, 0x6A, 0x1D, + 0x01, 0x7E, 0x08, 0x6B, 0x7D, 0x09, 0x3E, 0x7F, + 0xCA, 0xF9, 0xB1, 0xED, 0x9D, 0xE0, 0x0F, 0x8F, + 0x19, 0x43, 0x77, 0x2A, 0x24, 0xEB, 0xA0, 0x26, + 0x2F, 0xA4, 0xE4, 0xBC, 0x94, 0x1D, 0x0E, 0x6D, + 0x8D, 0x6E, 0x16, 0x8A, 0x07, 0x58, 0x8A, 0x0D, + 0xD2, 0x7A, 0x83, 0xE2, 0x69, 0x7A, 0xBC, 0xA5 + }, + { + 0x40, 0x48, 0xAE, 0x16, 0x9A, 0x21, 0xCB, 0x78, + 0xE9, 0x88, 0x89, 0x7B, 0xC4, 0x5E, 0x95, 0x86, + 0xCE, 0xC4, 0x56, 0x71, 0x46, 0x33, 0x6F, 0xD4, + 0xBB, 0x28, 0x37, 0x91, 0xB0, 0x78, 0x6F, 0x6B, + 0x96, 0xBA, 0xB9, 0x27, 0xBB, 0xD4, 0x94, 0x24, + 0x4E, 0x1B, 0x59, 0x13, 0x13, 0x46, 0x35, 0x3F, + 0xA2, 0xAD, 0x3F, 0xBC, 0x59, 0xFD, 0xF0, 0x62, + 0xFE, 0xE3, 0xF7, 0xDD, 0x66, 0x34, 0xB7, 0xD0 + }, + { + 0x35, 0xBC, 0xE2, 0xB4, 0x2E, 0xB0, 0xEB, 0x41, + 0x96, 0x1A, 0xCF, 0x71, 0x09, 0xF0, 0xF8, 0x55, + 0x64, 0x88, 0xAA, 0xD9, 0x20, 0x43, 0x81, 0x51, + 0x98, 0xBA, 0xC8, 0xC1, 0x7C, 0x5A, 0x4C, 0x37, + 0x58, 0xFE, 0x0D, 0x15, 0xA9, 0x7E, 0xDB, 0x2E, + 0x72, 0xDB, 0x11, 0xA4, 0xAC, 0x98, 0x1A, 0x2F, + 0x1E, 0xCE, 0xF8, 0xB4, 0xD6, 0xCF, 0xCF, 0xEA, + 0xD6, 0xD9, 0x36, 0x06, 0xD4, 0x7A, 0xA2, 0x2F + }, + { + 0x53, 0xC4, 0x92, 0xB6, 0xC8, 0x44, 0xE8, 0xDB, + 0xBE, 0x62, 0xFC, 0xB3, 0x35, 0xAE, 0x1E, 0xAE, + 0x8D, 0xB6, 0xA9, 0x86, 0xF8, 0xBD, 0x5A, 0x82, + 0xB6, 0x8F, 0x51, 0x28, 0xB9, 0x7A, 0xEA, 0x82, + 0x0E, 0x5B, 0x12, 0x74, 0xEA, 0x52, 0xE1, 0xA8, + 0xBC, 0xD3, 0x7A, 0xF9, 0xF9, 0x21, 0x2A, 0x7D, + 0x8A, 0xBE, 0x4C, 0x2D, 0x5A, 0x13, 0xFC, 0x94, + 0x3E, 0xA2, 0x48, 0xFE, 0xCD, 0x84, 0x9C, 0x88 + }, + { + 0xE1, 0x79, 0x20, 0x0B, 0x84, 0xF3, 0xF3, 0x3F, + 0x0A, 0xF7, 0x11, 0xF3, 0xAA, 0xB3, 0xDA, 0x59, + 0xD9, 0x15, 0x0C, 0xF8, 0xFB, 0x72, 0x63, 0x27, + 0x8A, 0xEF, 0x0A, 0x50, 0x7B, 0xF0, 0x28, 0x1A, + 0xD7, 0xD5, 0x85, 0xFF, 0xD1, 0x6B, 0xB5, 0xA3, + 0x91, 0x89, 0x08, 0xF5, 0x8E, 0x4D, 0x9D, 0xE3, + 0xC2, 0x8E, 0x73, 0x50, 0x9A, 0xB2, 0x07, 0x1C, + 0xE3, 0x73, 0x4E, 0x2F, 0x8A, 0x78, 0xC4, 0x34 + }, + { + 0xB3, 0x64, 0x3D, 0xE5, 0x7E, 0x59, 0x88, 0x36, + 0x7B, 0x25, 0xE4, 0xB3, 0xEE, 0x92, 0x80, 0xC9, + 0x46, 0x48, 0x9D, 0x3D, 0x66, 0xBC, 0x73, 0x3C, + 0xA1, 0xD0, 0xC2, 0xE2, 0x4E, 0x7D, 0xCB, 0x0B, + 0x4E, 0xC4, 0x81, 0x22, 0xDE, 0x93, 0x18, 0x4E, + 0xC0, 0xFF, 0x5F, 0x1A, 0x19, 0xA3, 0xA2, 0x39, + 0x6F, 0x2D, 0xEF, 0x8C, 0x54, 0x95, 0xA9, 0xD7, + 0x33, 0x2F, 0xBB, 0xD8, 0x1F, 0x6D, 0xF4, 0x5D + }, + { + 0x46, 0x75, 0x46, 0xF5, 0xB9, 0x9D, 0x59, 0x06, + 0xD3, 0xC5, 0x35, 0x63, 0x5F, 0x33, 0x74, 0x1A, + 0x6A, 0xE5, 0x0B, 0x43, 0xDD, 0x46, 0x34, 0x7C, + 0x60, 0x7F, 0xF9, 0x0E, 0xF8, 0xAA, 0xE2, 0x3A, + 0x3D, 0x66, 0xA5, 0x1A, 0xCE, 0x86, 0x92, 0xED, + 0x74, 0x5E, 0xD8, 0xCE, 0xC4, 0x32, 0x06, 0x16, + 0x11, 0xB9, 0x71, 0x34, 0x90, 0xE5, 0x07, 0xB5, + 0xD7, 0x52, 0x4C, 0x56, 0xB6, 0xBF, 0xF2, 0xA5 + }, + { + 0x33, 0xEF, 0xA5, 0xC2, 0x52, 0x18, 0x7D, 0x2A, + 0x81, 0x24, 0x31, 0x65, 0x0A, 0x13, 0x7D, 0xCD, + 0x4B, 0x1C, 0x82, 0x13, 0xFD, 0x66, 0x74, 0x31, + 0x6A, 0xBB, 0xFB, 0x4B, 0x8D, 0x75, 0x2F, 0xEA, + 0xEB, 0x6E, 0x9E, 0xFE, 0x70, 0x31, 0xF8, 0x01, + 0x0C, 0xE7, 0xE1, 0xC9, 0x09, 0x6F, 0x4B, 0x5A, + 0x06, 0x98, 0x90, 0x75, 0x25, 0x1B, 0x29, 0x7E, + 0x6A, 0x60, 0x8A, 0x52, 0x5E, 0xF1, 0xC8, 0xD9 + }, + { + 0x71, 0x21, 0x7B, 0x5C, 0xBF, 0x41, 0x4C, 0x17, + 0x70, 0xFA, 0x26, 0x01, 0xBF, 0xAD, 0x03, 0x04, + 0x91, 0x3C, 0x6B, 0x7A, 0x9F, 0x0E, 0x9D, 0x4C, + 0x28, 0x81, 0x9B, 0xFC, 0xE0, 0xB2, 0x94, 0x6F, + 0x79, 0x43, 0x3C, 0x32, 0xBD, 0x14, 0x32, 0x49, + 0x66, 0xBC, 0x60, 0xCF, 0x9B, 0xFB, 0x94, 0x88, + 0x3B, 0xF8, 0x9A, 0xED, 0x97, 0x49, 0xD8, 0x86, + 0x6A, 0xCD, 0x8F, 0x4A, 0x52, 0x23, 0x34, 0x4E + }, + { + 0x0F, 0xA2, 0x60, 0xBB, 0xD8, 0xCB, 0xF5, 0x52, + 0x6A, 0xEF, 0x1F, 0x6D, 0x83, 0x6E, 0x5D, 0x75, + 0xA0, 0x02, 0x03, 0xC6, 0x47, 0xA1, 0x25, 0x7F, + 0xEB, 0x0B, 0xA5, 0xEE, 0xC7, 0xE7, 0x84, 0xCC, + 0x46, 0x9A, 0xE5, 0x59, 0x25, 0x8A, 0x46, 0x5B, + 0x40, 0xED, 0x63, 0x18, 0x2A, 0x3D, 0x8D, 0x6B, + 0x2E, 0x6B, 0x2E, 0x54, 0x20, 0x0E, 0xCF, 0xA6, + 0x19, 0x25, 0x42, 0x5B, 0x1D, 0x28, 0x09, 0xFD + }, + { + 0x33, 0xEE, 0xEC, 0xFD, 0x68, 0x4B, 0x67, 0xBF, + 0x8A, 0xEE, 0x0E, 0x02, 0x85, 0x76, 0x1E, 0xA9, + 0x19, 0xDB, 0x4F, 0xE5, 0x72, 0xFC, 0x88, 0xA1, + 0xDE, 0x10, 0xCB, 0x6A, 0xA2, 0xEF, 0x51, 0x73, + 0x28, 0x90, 0xD7, 0xC5, 0x2F, 0xB9, 0xFE, 0x8C, + 0x81, 0x53, 0x2B, 0xF8, 0x01, 0x4D, 0x17, 0xC2, + 0x9F, 0x79, 0x7E, 0xD5, 0x04, 0x07, 0xDD, 0xE6, + 0xF9, 0x5B, 0x18, 0x01, 0x5D, 0x1F, 0x5B, 0xA9 + }, + { + 0x3F, 0xF3, 0xA2, 0x1A, 0x0D, 0x7D, 0xE5, 0xC8, + 0xE8, 0x86, 0x25, 0xEA, 0x9E, 0xCD, 0x71, 0xEA, + 0xBD, 0x5A, 0x3F, 0xBB, 0xB0, 0x27, 0x77, 0xA4, + 0x8F, 0x64, 0xB9, 0xF4, 0x1C, 0x96, 0x7A, 0x16, + 0x84, 0x26, 0x39, 0x92, 0x5E, 0xED, 0x2E, 0x18, + 0xD5, 0xFF, 0x6F, 0xB4, 0xC1, 0xB4, 0x72, 0xE8, + 0xAF, 0x55, 0x14, 0x82, 0xC4, 0x3E, 0x6F, 0xD1, + 0xD8, 0x24, 0x69, 0xA3, 0xA8, 0x4A, 0xDC, 0xC3 + }, + { + 0x7E, 0x1B, 0x81, 0xFA, 0xC5, 0xD6, 0x64, 0x49, + 0x9B, 0x4B, 0xB6, 0xE1, 0x44, 0xFF, 0x2D, 0x8C, + 0x3F, 0xB8, 0x63, 0xE4, 0xCC, 0x2D, 0x0F, 0x9B, + 0x72, 0xED, 0x4C, 0x29, 0xD1, 0xFA, 0x63, 0xA2, + 0x8E, 0xC4, 0x04, 0x42, 0x23, 0x22, 0x8D, 0x21, + 0xA8, 0xF2, 0xC4, 0xD5, 0xFA, 0xC6, 0xDA, 0x57, + 0xB3, 0x68, 0x7D, 0x3B, 0xD4, 0x91, 0x0E, 0xC1, + 0x50, 0xE2, 0xCB, 0xCF, 0x34, 0xDA, 0x39, 0x4F + }, + { + 0xB6, 0xBF, 0x95, 0xF0, 0xF6, 0xB9, 0xAA, 0x46, + 0x8D, 0x60, 0x35, 0xBB, 0xC5, 0x73, 0x78, 0xD7, + 0xD9, 0xA2, 0xD1, 0xD8, 0x43, 0x62, 0x6D, 0x22, + 0xC9, 0x99, 0x97, 0x21, 0xC1, 0xDD, 0xD8, 0x7D, + 0xC1, 0xA6, 0xC3, 0x73, 0x74, 0x2A, 0xA8, 0x39, + 0x6D, 0x28, 0x8F, 0xA5, 0x18, 0x4F, 0x12, 0x59, + 0x36, 0x54, 0x5D, 0x29, 0x07, 0xF1, 0xD1, 0x28, + 0xED, 0x4B, 0xFD, 0x4D, 0x66, 0xB6, 0x9F, 0x39 + }, + { + 0x4E, 0x17, 0x93, 0xDE, 0xDE, 0xEA, 0x8A, 0x54, + 0xE2, 0x60, 0x0C, 0x89, 0xBE, 0xFC, 0x9B, 0x31, + 0xAB, 0x2B, 0xC7, 0x6A, 0xD4, 0x3B, 0x05, 0x1C, + 0x44, 0xF9, 0x54, 0x38, 0x85, 0xDE, 0x1B, 0xC1, + 0x47, 0x1D, 0xB1, 0x84, 0x4C, 0x54, 0x21, 0xE1, + 0xB7, 0x50, 0xBE, 0x02, 0x6C, 0xC3, 0x03, 0xD4, + 0x26, 0xAA, 0x44, 0x71, 0xDE, 0x37, 0x53, 0x79, + 0x3A, 0x6F, 0x68, 0x61, 0xB5, 0x8E, 0x3C, 0x61 + }, + { + 0x20, 0x4F, 0xC5, 0xDC, 0xCB, 0x29, 0x79, 0xED, + 0xA7, 0x01, 0xEE, 0xE4, 0x42, 0x42, 0x62, 0x9F, + 0xDD, 0x98, 0xFD, 0xB5, 0x6C, 0x6F, 0x2F, 0x91, + 0x96, 0xAF, 0x9E, 0xF9, 0xC5, 0x9A, 0xC0, 0xB2, + 0xA8, 0xE8, 0x44, 0xA2, 0x53, 0x5B, 0xFF, 0x5D, + 0x04, 0x5B, 0x97, 0x21, 0x39, 0x72, 0x46, 0x3D, + 0x87, 0x60, 0xDD, 0x5D, 0x04, 0xA0, 0xAE, 0x80, + 0xC9, 0xE0, 0x99, 0x2E, 0xE2, 0x7B, 0x6D, 0x78 + }, + { + 0x2A, 0xAD, 0x3F, 0xB5, 0xA4, 0x4B, 0x68, 0xAE, + 0x63, 0x78, 0xFA, 0x4E, 0x94, 0xDC, 0x5B, 0xF2, + 0x16, 0x6B, 0x24, 0xE3, 0x82, 0xFE, 0x4D, 0xED, + 0x66, 0x98, 0x14, 0x80, 0x81, 0x01, 0x40, 0x48, + 0xCB, 0xF4, 0x01, 0xE1, 0x6A, 0xBF, 0xA2, 0x5E, + 0x91, 0x1B, 0xE8, 0x16, 0x00, 0x66, 0xE4, 0x12, + 0x42, 0x66, 0xFC, 0x22, 0x31, 0x32, 0xD0, 0x71, + 0x9B, 0x44, 0x0B, 0x59, 0xBB, 0x46, 0xC0, 0x3D + }, + { + 0xDC, 0x9A, 0x63, 0x1D, 0x48, 0xCF, 0x45, 0xBF, + 0x0D, 0x84, 0xC6, 0x63, 0xC5, 0x37, 0xA7, 0x59, + 0xD1, 0x3C, 0xBD, 0x66, 0x3B, 0x80, 0x00, 0x86, + 0x7A, 0xE4, 0x50, 0x55, 0x95, 0x18, 0x4B, 0xDE, + 0x3D, 0xE2, 0x99, 0x8A, 0x61, 0x37, 0x79, 0x0A, + 0x21, 0xEB, 0xDF, 0x8C, 0xE2, 0xE6, 0x49, 0x42, + 0x4E, 0xD0, 0x0F, 0x31, 0x5B, 0xFA, 0xD5, 0xFF, + 0xDD, 0x38, 0x1F, 0xEB, 0xAB, 0xEA, 0x5B, 0xE4 + }, + { + 0x4C, 0x5B, 0x84, 0xF6, 0x98, 0x06, 0x70, 0x80, + 0x6A, 0x9F, 0x8B, 0x6C, 0x23, 0xD5, 0x72, 0x06, + 0x4C, 0xE8, 0xEE, 0x63, 0x64, 0x08, 0xC4, 0x1A, + 0xF8, 0xFB, 0x97, 0x33, 0xB4, 0xDC, 0xFD, 0x17, + 0x91, 0x2A, 0xC4, 0x39, 0xD0, 0x83, 0x87, 0xE0, + 0x7B, 0x94, 0x66, 0x69, 0xEB, 0x61, 0x38, 0xA2, + 0xB1, 0x53, 0xB6, 0x6E, 0xB5, 0x02, 0xDD, 0x58, + 0xE0, 0xC4, 0x4C, 0x41, 0x5F, 0x0A, 0xA0, 0x82 + }, + { + 0x7D, 0x7E, 0x32, 0x7E, 0x63, 0x6D, 0x9C, 0xC2, + 0xE6, 0x75, 0xA9, 0xBF, 0xBA, 0xBB, 0x0E, 0x3F, + 0xD4, 0x17, 0x38, 0xD0, 0x65, 0x85, 0xA9, 0xD1, + 0xA8, 0x85, 0x42, 0x11, 0xD7, 0xF9, 0x3C, 0x7E, + 0xE0, 0x33, 0x1C, 0x68, 0xA4, 0x47, 0xED, 0xF8, + 0xB4, 0x79, 0xDD, 0xFA, 0x86, 0xC2, 0xD7, 0x18, + 0x36, 0x8D, 0x45, 0xCE, 0x1E, 0x07, 0xB0, 0xC7, + 0xF6, 0x1B, 0xC4, 0x6F, 0xDE, 0xAD, 0x6A, 0xE4 + }, + { + 0xA4, 0xF6, 0x2D, 0xBE, 0xFA, 0xB8, 0x26, 0xAC, + 0xF5, 0x54, 0x12, 0x7A, 0x32, 0xFD, 0xA7, 0xD3, + 0xE7, 0x7D, 0xC9, 0x7E, 0xFB, 0x66, 0x87, 0x4C, + 0xC4, 0xC1, 0xEA, 0xBB, 0x8E, 0x5C, 0x60, 0xC4, + 0x8F, 0xFB, 0x14, 0xBF, 0x0D, 0xEF, 0x04, 0x44, + 0xBD, 0x4A, 0xD4, 0x11, 0xBC, 0x7A, 0x14, 0xF9, + 0x79, 0x04, 0x58, 0xDC, 0x84, 0xDF, 0xE0, 0xCF, + 0x70, 0x9C, 0xD2, 0xB1, 0x0B, 0x37, 0x48, 0x88 + }, + { + 0xEF, 0x80, 0xB1, 0x22, 0x4B, 0x20, 0xE6, 0x30, + 0x2C, 0x9E, 0x2A, 0x00, 0x99, 0xFA, 0x66, 0x27, + 0xE7, 0x9E, 0x29, 0x84, 0x6E, 0xB7, 0x62, 0x7E, + 0x75, 0xA7, 0x5B, 0x84, 0x68, 0x6C, 0x20, 0x56, + 0x2C, 0xDA, 0x7E, 0x45, 0xD2, 0x51, 0xBC, 0x56, + 0xA1, 0x85, 0xAF, 0x8C, 0x60, 0xB4, 0x4F, 0x3F, + 0xDE, 0x63, 0xA2, 0x94, 0x30, 0x69, 0x99, 0xFF, + 0x62, 0x05, 0x66, 0xA5, 0x97, 0xAF, 0xE3, 0xF0 + }, + { + 0x5B, 0x68, 0xF3, 0x86, 0xCA, 0x72, 0x61, 0xD6, + 0x79, 0x94, 0x05, 0x09, 0xA0, 0x9D, 0x19, 0x8D, + 0x2E, 0xF9, 0x28, 0x82, 0x19, 0x00, 0x0D, 0xC2, + 0xBC, 0xE4, 0x37, 0x3F, 0x1E, 0xDA, 0x55, 0xA6, + 0xE8, 0x41, 0x99, 0xEF, 0x3B, 0x8F, 0xDE, 0x5A, + 0x7F, 0xF7, 0x1B, 0x41, 0x96, 0x33, 0x2C, 0xF8, + 0xD5, 0xF7, 0xF1, 0x8E, 0x85, 0x4B, 0xF7, 0x61, + 0x7C, 0x5E, 0x55, 0xDA, 0xF7, 0x8F, 0x93, 0x49 + }, + { + 0xC0, 0x0B, 0x57, 0xDE, 0x4B, 0xB1, 0xF1, 0xC5, + 0x27, 0xD3, 0x9D, 0x1F, 0x30, 0xB3, 0x8B, 0x26, + 0x0F, 0xBF, 0xEE, 0x04, 0x30, 0xEE, 0x93, 0x46, + 0xAE, 0xD6, 0xB3, 0x92, 0xA3, 0x6D, 0x66, 0x74, + 0x6C, 0xA3, 0x2A, 0xBA, 0xF9, 0x89, 0xAA, 0xEB, + 0xB1, 0x82, 0x93, 0x41, 0x77, 0x8A, 0x8F, 0xE3, + 0x50, 0xB5, 0xDD, 0x26, 0x25, 0xAC, 0x9D, 0xEF, + 0x17, 0xA6, 0xF7, 0xB8, 0x79, 0xEE, 0xB4, 0x14 + }, + { + 0xAD, 0x65, 0x21, 0x39, 0x77, 0x20, 0x69, 0xCB, + 0xFB, 0x49, 0x9D, 0xF0, 0x7F, 0x0D, 0xE7, 0xD6, + 0x9D, 0x6D, 0xE6, 0xA5, 0xDB, 0x46, 0x12, 0x31, + 0xA0, 0xF9, 0xE9, 0xD6, 0x36, 0x65, 0x0A, 0xA7, + 0xF9, 0xDB, 0x84, 0x8A, 0xF3, 0xC1, 0x41, 0x7D, + 0x84, 0x34, 0xC4, 0x4E, 0x91, 0x78, 0xA5, 0x53, + 0x7F, 0x25, 0xE0, 0x77, 0x7E, 0x26, 0xC3, 0x52, + 0xD7, 0xBC, 0x09, 0xCB, 0xE0, 0x5C, 0xF8, 0x5F + }, + { + 0xE3, 0x6B, 0x1D, 0x86, 0x70, 0x8B, 0x6A, 0x73, + 0xC6, 0x75, 0x49, 0xBD, 0x64, 0x44, 0x00, 0x9F, + 0xF4, 0x5A, 0x3D, 0x8A, 0x62, 0x35, 0xD9, 0xF5, + 0x78, 0x8B, 0x88, 0xCE, 0xE2, 0xFE, 0x28, 0x2C, + 0x08, 0x94, 0x72, 0x2B, 0x75, 0xF4, 0xE4, 0x52, + 0x0A, 0x62, 0xA7, 0xBB, 0xD8, 0xA1, 0x8A, 0x9D, + 0x3D, 0x9D, 0x47, 0x3C, 0x79, 0xA8, 0x5E, 0xAA, + 0xBC, 0x95, 0xD9, 0xD8, 0xA9, 0x31, 0x6A, 0xEB + }, + { + 0xFA, 0x8A, 0xB9, 0xA9, 0x96, 0xD0, 0xB8, 0xB8, + 0x1A, 0xE6, 0x8B, 0xB3, 0x2C, 0x90, 0x1B, 0x15, + 0x7F, 0xBD, 0x77, 0xBD, 0xB4, 0xE3, 0x60, 0xC4, + 0x7E, 0x06, 0xFB, 0x30, 0xA9, 0xF6, 0x04, 0xC2, + 0x07, 0x44, 0x75, 0x41, 0xD5, 0x7A, 0xBC, 0x58, + 0x50, 0xD1, 0xD6, 0xAA, 0x8D, 0xA5, 0x75, 0x19, + 0x73, 0xD4, 0x2B, 0x70, 0x5B, 0x06, 0x4B, 0x00, + 0xD0, 0x02, 0x3B, 0xF7, 0xB0, 0x2F, 0xD3, 0x05 + }, + { + 0x20, 0x11, 0xDA, 0x69, 0x70, 0x8A, 0x45, 0x95, + 0x87, 0xFD, 0x81, 0x6E, 0x7A, 0x65, 0xEC, 0x33, + 0xE7, 0x9D, 0x0D, 0x1D, 0xBD, 0x2C, 0x47, 0x6E, + 0xA6, 0x28, 0x6A, 0x48, 0x63, 0x7A, 0xCC, 0xE2, + 0xD5, 0xED, 0x04, 0x54, 0x49, 0xA0, 0xC8, 0x65, + 0x81, 0xF7, 0x28, 0xAB, 0x79, 0x83, 0xCC, 0x51, + 0x10, 0xBB, 0x19, 0x83, 0x9E, 0xFE, 0xA8, 0xC4, + 0xBE, 0x60, 0xF7, 0x81, 0x32, 0x58, 0x94, 0xD2 + }, + { + 0xFA, 0x93, 0xCB, 0x1B, 0x43, 0x8C, 0xB0, 0x51, + 0x88, 0xFD, 0x47, 0x83, 0x8F, 0xDF, 0x20, 0xD2, + 0x57, 0xD2, 0x1D, 0x9B, 0x4E, 0xF6, 0x29, 0xD1, + 0x45, 0xE5, 0x6E, 0x70, 0x13, 0x88, 0xE4, 0x94, + 0x4B, 0xB1, 0xE8, 0xEB, 0x17, 0x71, 0x20, 0x0F, + 0x12, 0xDC, 0x11, 0xEB, 0x39, 0xC3, 0xBB, 0x5B, + 0x8A, 0x17, 0x5D, 0xAE, 0xDC, 0x0E, 0x74, 0xB0, + 0x44, 0x2D, 0xC8, 0x04, 0xAC, 0x4C, 0x1D, 0x82 + }, + { + 0x74, 0x48, 0xF2, 0x2B, 0xD4, 0x0B, 0x62, 0x96, + 0x77, 0xCE, 0x99, 0xEB, 0xF1, 0x2E, 0x41, 0x47, + 0x39, 0x23, 0x0A, 0x27, 0x71, 0xB8, 0xED, 0xB0, + 0x7D, 0x1D, 0xE5, 0xA2, 0x31, 0xFE, 0xD4, 0xD5, + 0xBE, 0x1B, 0xB8, 0xD3, 0x73, 0x78, 0x8E, 0x30, + 0xBD, 0x37, 0xDB, 0x9F, 0x0E, 0x91, 0xF3, 0x6A, + 0xB7, 0x4D, 0x13, 0xC7, 0xDF, 0x61, 0x2C, 0x52, + 0x8F, 0x04, 0x9B, 0x04, 0xF2, 0xAD, 0xBD, 0x4A + }, + { + 0x24, 0x14, 0x8A, 0x6D, 0x73, 0x47, 0xE9, 0x90, + 0x3C, 0x25, 0x41, 0xF1, 0x5F, 0x77, 0x6B, 0x5C, + 0xF4, 0x13, 0x64, 0x03, 0xF6, 0x8F, 0x2A, 0xF6, + 0xA2, 0x88, 0x66, 0x2A, 0x4E, 0x57, 0x44, 0xAE, + 0x89, 0x84, 0x09, 0xEB, 0x9E, 0xF3, 0xD7, 0xF7, + 0x63, 0x53, 0xB4, 0x54, 0xFC, 0x66, 0xAC, 0x4D, + 0x9E, 0x24, 0x97, 0xE0, 0x50, 0x45, 0xC1, 0x13, + 0x7E, 0x7A, 0x55, 0x20, 0x87, 0x46, 0x65, 0xEF + }, + { + 0xA2, 0x7D, 0x7C, 0x23, 0xB9, 0x48, 0x63, 0x66, + 0xCC, 0x8D, 0x26, 0xE9, 0x44, 0xBE, 0x02, 0xA6, + 0xE8, 0xE4, 0xE6, 0x3F, 0x1C, 0x30, 0xB4, 0x96, + 0xED, 0x2F, 0x61, 0xAB, 0x40, 0x05, 0xDE, 0x99, + 0x98, 0x73, 0xCF, 0x03, 0x4A, 0xD7, 0x16, 0xFE, + 0x5A, 0xBB, 0x76, 0x28, 0x76, 0x42, 0x12, 0x39, + 0x6B, 0x30, 0xA0, 0x04, 0xF4, 0x97, 0x61, 0x67, + 0x92, 0x4F, 0x08, 0x4F, 0xBF, 0x85, 0xC6, 0x5E + }, + { + 0x38, 0xD2, 0x30, 0x4D, 0xBF, 0x25, 0xCD, 0x2E, + 0x89, 0x45, 0xDD, 0x5F, 0x4D, 0x84, 0x5E, 0x5D, + 0x84, 0x11, 0x0C, 0x88, 0x63, 0xCF, 0x20, 0x4F, + 0x6E, 0x60, 0x9B, 0x89, 0x1B, 0x88, 0xA5, 0x09, + 0x41, 0x52, 0x3D, 0x4B, 0xD2, 0xBB, 0xB4, 0x74, + 0x33, 0x73, 0x93, 0x93, 0x72, 0xB5, 0x68, 0xB2, + 0x44, 0x28, 0x47, 0xFD, 0x64, 0x82, 0xF8, 0x5E, + 0x84, 0xA9, 0x19, 0x13, 0xD0, 0x78, 0xF1, 0xB7 + }, + { + 0x24, 0xFD, 0x0C, 0x4D, 0xED, 0xA6, 0x84, 0xE1, + 0x1E, 0x84, 0x28, 0x43, 0x2F, 0xA5, 0x44, 0xAE, + 0xEB, 0xCC, 0xE9, 0x8F, 0xC8, 0xA3, 0x54, 0x11, + 0x46, 0xF9, 0xF9, 0xEE, 0xAB, 0x9A, 0x1D, 0xE3, + 0xC8, 0x97, 0x1A, 0xB9, 0xDF, 0x42, 0x75, 0x56, + 0x65, 0xE8, 0x6E, 0xE6, 0x99, 0xA0, 0xAD, 0x69, + 0x83, 0x84, 0x3C, 0x30, 0x54, 0x63, 0x27, 0x17, + 0x98, 0x08, 0x20, 0x77, 0xB9, 0x04, 0x48, 0xCF + }, + { + 0x89, 0x91, 0xCC, 0x57, 0xC7, 0x28, 0x0E, 0xBF, + 0x1B, 0x67, 0x78, 0x16, 0xD2, 0x67, 0xB2, 0x2C, + 0xBD, 0x0C, 0x89, 0x60, 0x5D, 0x1B, 0xCD, 0x1A, + 0xFE, 0x1E, 0xE6, 0xA5, 0x89, 0xD2, 0xA3, 0x96, + 0x8E, 0x30, 0x60, 0xD2, 0x00, 0x74, 0x4B, 0x85, + 0x75, 0x99, 0x35, 0x2B, 0xBA, 0x9A, 0x52, 0x7E, + 0x88, 0x58, 0xB7, 0xC5, 0x95, 0x37, 0xC9, 0x1B, + 0x8E, 0x25, 0xF9, 0xAE, 0x3C, 0xCF, 0xD7, 0x09 + }, + { + 0x94, 0x96, 0x45, 0x53, 0x24, 0x9D, 0x21, 0xC7, + 0x09, 0x44, 0xFF, 0x5F, 0xBF, 0x0B, 0xC5, 0xAE, + 0xFE, 0x5B, 0x03, 0x02, 0x13, 0x44, 0xA9, 0x6D, + 0x89, 0x2A, 0x08, 0xFA, 0xCF, 0xAA, 0x1C, 0x32, + 0x28, 0x1D, 0xDA, 0x4D, 0x10, 0xE8, 0xC1, 0x7D, + 0xE2, 0xEE, 0xB7, 0x0F, 0x06, 0x0E, 0x9C, 0x91, + 0xD2, 0xBD, 0x6C, 0x6F, 0xDD, 0xCB, 0x8F, 0x52, + 0x5B, 0x44, 0xD1, 0xA8, 0x93, 0x1B, 0xD8, 0x09 + }, + { + 0x60, 0x3B, 0xAA, 0x22, 0x93, 0x1D, 0x61, 0x0D, + 0xD0, 0x96, 0x6D, 0x58, 0x07, 0xA3, 0xED, 0xBB, + 0x89, 0xF7, 0x33, 0x94, 0x1F, 0x36, 0x4B, 0x92, + 0xA8, 0xBC, 0x8B, 0xF4, 0x79, 0x00, 0x48, 0x17, + 0x5B, 0x76, 0x94, 0xC8, 0x52, 0x4E, 0x76, 0x6D, + 0x54, 0x2D, 0x48, 0xA0, 0x55, 0xD9, 0xA4, 0xA0, + 0xCE, 0x67, 0x21, 0x77, 0x6D, 0x9B, 0x18, 0x81, + 0xA0, 0xCE, 0x69, 0x7C, 0xC0, 0x85, 0x8D, 0x6A + }, + { + 0xB6, 0x82, 0x42, 0x71, 0x79, 0xD6, 0x36, 0x57, + 0x00, 0xDC, 0x9C, 0x3E, 0x36, 0xEF, 0xE1, 0x57, + 0xFA, 0xC7, 0x3D, 0xDC, 0xC1, 0x71, 0x90, 0x48, + 0x72, 0x21, 0xB9, 0xDE, 0xD1, 0xE7, 0xBF, 0xCD, + 0x90, 0x9D, 0xE6, 0xAA, 0xF1, 0xD8, 0xE5, 0x63, + 0x28, 0x56, 0xE8, 0x47, 0x27, 0xCC, 0x14, 0x20, + 0xAE, 0xEB, 0xDB, 0x12, 0x76, 0x56, 0xE4, 0xC7, + 0xA1, 0x40, 0x38, 0x76, 0xFF, 0xCC, 0x59, 0xF7 + }, + { + 0xE3, 0x1D, 0x92, 0x24, 0x5C, 0xE1, 0xD5, 0x7F, + 0x83, 0x8C, 0xDF, 0x3C, 0xC3, 0x09, 0x7B, 0xBF, + 0x11, 0xD0, 0xA5, 0x9F, 0xB2, 0x40, 0xB0, 0x6B, + 0xBE, 0xEE, 0x2C, 0x35, 0x5B, 0x58, 0xAC, 0x5C, + 0xC7, 0x3F, 0x83, 0xDC, 0xC6, 0x35, 0xAF, 0x8F, + 0xE9, 0x35, 0x17, 0x00, 0xA6, 0x41, 0x91, 0xE4, + 0xAA, 0xF5, 0x18, 0xF0, 0xA6, 0x33, 0xDE, 0xDF, + 0x89, 0xBF, 0x65, 0x3E, 0xDB, 0xC8, 0xE2, 0x6B + }, + { + 0xC7, 0x3E, 0xBF, 0xA8, 0xCA, 0x15, 0xFE, 0x92, + 0xE5, 0x6F, 0xA9, 0xBD, 0x6E, 0x29, 0x71, 0xCA, + 0xCB, 0xD9, 0x84, 0x49, 0xDA, 0xEF, 0x87, 0x96, + 0xBD, 0xFD, 0x3C, 0xD0, 0x4B, 0xBD, 0x38, 0x56, + 0xB1, 0x0D, 0x0B, 0x70, 0x50, 0x0A, 0x33, 0xB8, + 0xF3, 0xBF, 0xC1, 0x35, 0x81, 0x85, 0xE8, 0x9F, + 0xE4, 0x81, 0x64, 0xFA, 0xCD, 0xEB, 0x07, 0xBB, + 0xA3, 0xF0, 0xB9, 0x94, 0x53, 0x65, 0x38, 0x0C + }, + { + 0xA0, 0x4B, 0x4A, 0xAE, 0xB3, 0x63, 0x32, 0x70, + 0xC7, 0xB5, 0xF5, 0xAC, 0xC6, 0xF7, 0x90, 0x48, + 0x7B, 0x60, 0x27, 0x3C, 0x02, 0x8B, 0xBB, 0x0B, + 0xC5, 0x5A, 0xFD, 0x68, 0x73, 0x96, 0x5B, 0x23, + 0x78, 0xF3, 0xA1, 0xCF, 0x56, 0xA7, 0xFE, 0xB3, + 0xE7, 0xCE, 0x79, 0x82, 0x2B, 0x35, 0x54, 0xF2, + 0xCC, 0xBC, 0x77, 0x8F, 0xC7, 0x0F, 0xFE, 0x5F, + 0xF9, 0xD3, 0x95, 0xDE, 0x8F, 0x28, 0x7E, 0xA1 + }, + { + 0x0B, 0x02, 0x15, 0x20, 0xF5, 0xB9, 0x36, 0xE4, + 0x67, 0xBD, 0xC8, 0x56, 0x67, 0x84, 0x49, 0xD3, + 0x1F, 0x18, 0xC5, 0xAE, 0xF7, 0xFF, 0xFB, 0x41, + 0x2A, 0xB9, 0xAD, 0x18, 0xC3, 0xDB, 0x03, 0xCA, + 0xA4, 0x4D, 0x05, 0x92, 0xAD, 0xF8, 0xDA, 0xEF, + 0x23, 0x37, 0x87, 0x75, 0x27, 0x4B, 0x75, 0xDA, + 0x00, 0x8C, 0xC0, 0xB8, 0x25, 0xB2, 0x83, 0x67, + 0x87, 0xC9, 0x99, 0x9E, 0x4B, 0xEE, 0x5A, 0xA8 + }, + { + 0xD8, 0xE9, 0x70, 0x85, 0x56, 0xF5, 0x61, 0xA9, + 0xD2, 0x5E, 0x2C, 0x5D, 0x95, 0x50, 0x42, 0x77, + 0x79, 0xC4, 0xA0, 0x51, 0x67, 0x26, 0xF9, 0xDD, + 0xBB, 0xC8, 0x32, 0x04, 0x20, 0x44, 0x77, 0x12, + 0xDA, 0x92, 0x98, 0xA0, 0x30, 0xB7, 0x26, 0x9A, + 0xC6, 0x91, 0x98, 0x1B, 0xE5, 0x4C, 0xB2, 0xB5, + 0x41, 0x52, 0xBA, 0x6B, 0x90, 0xBE, 0x17, 0x74, + 0x30, 0x48, 0x63, 0x9C, 0xE7, 0xAA, 0x3A, 0x42 + }, + { + 0xA4, 0xD9, 0x5D, 0xFD, 0x5D, 0xC4, 0x38, 0xC6, + 0x9D, 0xCF, 0x33, 0x30, 0x3E, 0xAC, 0xC2, 0xC8, + 0xC1, 0xE6, 0x67, 0xC8, 0x09, 0x21, 0xE3, 0xF5, + 0xEC, 0x3A, 0x32, 0xC1, 0x6A, 0xDF, 0xB5, 0xF9, + 0xB9, 0xD3, 0xC3, 0x8B, 0x51, 0xD0, 0x8F, 0xC4, + 0x3A, 0xFC, 0x4B, 0x2E, 0xF4, 0x37, 0x0C, 0x3A, + 0x8F, 0xCD, 0x25, 0x8A, 0x4E, 0xC1, 0xB2, 0x3A, + 0x11, 0x11, 0x0F, 0xE6, 0x5A, 0x5F, 0x5F, 0xB1 + }, + { + 0x21, 0xF0, 0x2E, 0xFB, 0xC5, 0x5F, 0xEF, 0x30, + 0xF5, 0xF2, 0x75, 0xF0, 0x9D, 0x84, 0xD9, 0x1B, + 0xCB, 0x7E, 0xA0, 0xAE, 0xBF, 0x46, 0x6E, 0xE3, + 0xE1, 0x91, 0x26, 0x1F, 0xEA, 0xBF, 0x58, 0x5C, + 0x03, 0xFB, 0xAE, 0xF0, 0xE0, 0x91, 0x8A, 0xEB, + 0x20, 0x6E, 0xCA, 0x75, 0x10, 0x1B, 0x09, 0x78, + 0x3D, 0xEC, 0x8B, 0xAE, 0xE4, 0x93, 0xED, 0x7B, + 0x8C, 0xA0, 0xA3, 0x9E, 0x87, 0x49, 0x11, 0x60 + }, + { + 0x23, 0x57, 0xFD, 0x14, 0x18, 0x94, 0x92, 0xDF, + 0x7E, 0x5E, 0x40, 0x9B, 0xD3, 0xE7, 0xD9, 0xAF, + 0x3C, 0x3A, 0x45, 0xE5, 0x4D, 0x54, 0x36, 0x16, + 0x15, 0x3F, 0x72, 0x80, 0xBE, 0x3B, 0x52, 0x92, + 0xF1, 0xC9, 0x41, 0x12, 0x91, 0x51, 0xA6, 0x9A, + 0xCF, 0x52, 0xD4, 0x9D, 0x7D, 0xF4, 0x3E, 0x84, + 0x8C, 0xE3, 0x54, 0x5A, 0xBF, 0xD7, 0xB1, 0x73, + 0xEF, 0x37, 0x68, 0x3A, 0x8C, 0x4D, 0x08, 0x1A + }, + { + 0x63, 0x70, 0x37, 0xE6, 0xCA, 0xC8, 0x60, 0x66, + 0x13, 0x44, 0x10, 0x69, 0xFE, 0x72, 0xCD, 0x56, + 0x79, 0x08, 0x3C, 0x2B, 0x90, 0x0C, 0xB1, 0x43, + 0xA4, 0x6F, 0x02, 0x76, 0xAC, 0x66, 0x6C, 0xB6, + 0xBB, 0x4F, 0x3A, 0xFB, 0x8D, 0x3E, 0x65, 0x67, + 0xF8, 0x7C, 0x4A, 0xD5, 0x8B, 0xA8, 0x01, 0x27, + 0x3C, 0x79, 0x4D, 0x86, 0x8C, 0xE0, 0xC8, 0xC9, + 0xA5, 0x5F, 0xA2, 0xA9, 0xB3, 0x06, 0x13, 0x25 + }, + { + 0x37, 0xE8, 0xEA, 0xBE, 0x23, 0x3B, 0xA3, 0x9E, + 0xAD, 0xD5, 0x31, 0x84, 0x33, 0xD6, 0x00, 0xBC, + 0xED, 0x7B, 0x8B, 0xFD, 0xE8, 0xEB, 0x80, 0xD4, + 0xE7, 0xC2, 0x7F, 0x84, 0x55, 0xB2, 0xB9, 0x7F, + 0xCF, 0xAA, 0xD5, 0x8F, 0x88, 0x3B, 0x95, 0xC5, + 0x61, 0xF9, 0x04, 0xBF, 0xB2, 0xED, 0xD7, 0xD8, + 0x03, 0xBE, 0x12, 0x82, 0xCB, 0x05, 0x65, 0x7D, + 0x17, 0x45, 0xB1, 0x96, 0x3B, 0x76, 0xF4, 0xC8 + }, + { + 0x01, 0x4B, 0xE0, 0xC7, 0x87, 0xC8, 0x04, 0xEE, + 0xA7, 0xD0, 0x91, 0x59, 0x1C, 0x2D, 0x7B, 0x9F, + 0x60, 0xAC, 0xE1, 0xCF, 0x17, 0xF2, 0xC2, 0x48, + 0x46, 0xD0, 0xE2, 0xF3, 0xA3, 0xE6, 0x50, 0xD0, + 0x96, 0x05, 0x0E, 0x34, 0x2D, 0xBE, 0xC7, 0xFE, + 0x9D, 0x5A, 0xD5, 0x37, 0xA8, 0x73, 0x60, 0x87, + 0x6C, 0x37, 0x3B, 0x85, 0x23, 0x8F, 0x43, 0x2E, + 0xE8, 0x4B, 0x41, 0x94, 0x98, 0x8F, 0xCC, 0x91 + }, + { + 0x63, 0x91, 0x98, 0xB7, 0x94, 0xEC, 0x23, 0x01, + 0x95, 0x89, 0xB9, 0x8D, 0x72, 0x4F, 0x01, 0x8E, + 0xAD, 0xC9, 0x46, 0x81, 0x78, 0x0B, 0xC0, 0x4B, + 0xBA, 0xA2, 0x45, 0x88, 0x6A, 0x52, 0x9B, 0xE8, + 0xA3, 0xFA, 0xED, 0x62, 0xD4, 0x0B, 0xE5, 0xBA, + 0x06, 0xAB, 0xED, 0x19, 0x8E, 0x9C, 0x5C, 0xA0, + 0xE3, 0xB6, 0x98, 0xE6, 0x9D, 0xE0, 0x5D, 0x8B, + 0x84, 0x74, 0x62, 0x4D, 0x44, 0x1E, 0xD1, 0x66 + }, + { + 0x07, 0xCE, 0x24, 0x1C, 0x42, 0x9B, 0xA2, 0x12, + 0xE9, 0xA4, 0x6A, 0x10, 0xE8, 0xFC, 0x71, 0x3A, + 0xD0, 0x8B, 0x46, 0x82, 0xAE, 0x84, 0xCD, 0xC7, + 0x03, 0xAA, 0xDE, 0x22, 0x72, 0x6F, 0x05, 0xDA, + 0x60, 0xB6, 0x33, 0x0A, 0xF2, 0x73, 0xDE, 0xBC, + 0x95, 0xDF, 0x84, 0x59, 0x16, 0x34, 0x09, 0x2B, + 0x3A, 0xE7, 0x72, 0x3C, 0x84, 0xDE, 0xCB, 0x4D, + 0x78, 0x5A, 0xF5, 0x98, 0x95, 0x62, 0x2A, 0xF6 + }, + { + 0x65, 0x31, 0x6C, 0xE1, 0xFD, 0x7A, 0x37, 0xFC, + 0x61, 0xCE, 0x6C, 0xB9, 0xC3, 0x44, 0x06, 0x88, + 0xE4, 0x0C, 0x04, 0xF1, 0x57, 0xE7, 0x34, 0x47, + 0x4F, 0xB6, 0xF4, 0x8C, 0xC3, 0x0C, 0x94, 0x19, + 0xE5, 0xDE, 0xC9, 0x8C, 0x4F, 0xE4, 0xC4, 0x17, + 0xE5, 0x7A, 0x08, 0xC4, 0xDB, 0x7F, 0xB8, 0x2C, + 0x0D, 0x49, 0x37, 0x24, 0xC6, 0x14, 0x9F, 0xE2, + 0x58, 0x13, 0x05, 0xA9, 0x3F, 0x43, 0x8E, 0x3C + }, + { + 0xF0, 0xB6, 0xC5, 0x87, 0x3A, 0xC3, 0x0D, 0x05, + 0xBC, 0x59, 0xB7, 0x4D, 0x00, 0x38, 0xC2, 0xEE, + 0x45, 0xDB, 0xD3, 0x4F, 0x23, 0xCB, 0xA5, 0x36, + 0xBF, 0xCD, 0x0A, 0xBB, 0x43, 0x18, 0x01, 0x3F, + 0x65, 0x16, 0xF4, 0x79, 0xB7, 0x61, 0xFC, 0xAB, + 0xDE, 0x21, 0xBE, 0x18, 0xEE, 0x6C, 0xAB, 0xD9, + 0x86, 0xE9, 0xB6, 0xC8, 0x83, 0x2D, 0x7E, 0x4F, + 0x5E, 0xE1, 0x71, 0x9C, 0xBD, 0x3E, 0xB8, 0xBB + }, + { + 0xDA, 0x2E, 0xB8, 0x70, 0xB9, 0xB6, 0x35, 0x9E, + 0x6C, 0xDF, 0x96, 0x58, 0xF7, 0xC3, 0x7F, 0x9D, + 0xEE, 0x9F, 0x5B, 0x7A, 0x62, 0x28, 0xA4, 0xB9, + 0x41, 0x5E, 0xE2, 0x5F, 0x1F, 0xE2, 0xF9, 0x6D, + 0x79, 0x1A, 0xCF, 0x9D, 0xE1, 0xC1, 0x35, 0x1F, + 0x17, 0x24, 0x21, 0xD5, 0xC4, 0xF9, 0x52, 0x74, + 0x20, 0xE4, 0xE3, 0xC8, 0xCC, 0xD2, 0x4F, 0x0E, + 0xFE, 0xC8, 0x78, 0x5F, 0xE3, 0xD2, 0x5C, 0x24 + }, + { + 0x29, 0x6F, 0x1B, 0x75, 0xD7, 0x14, 0x86, 0x2F, + 0xBA, 0x54, 0x89, 0x5F, 0x8C, 0x5D, 0x99, 0xDA, + 0x0A, 0xA8, 0xA9, 0x28, 0x98, 0xE5, 0x0A, 0x75, + 0x73, 0x50, 0x26, 0xB9, 0xCA, 0x2A, 0x0E, 0xA5, + 0x64, 0xCA, 0xE6, 0x52, 0xC8, 0x0E, 0xED, 0x14, + 0xF8, 0xEB, 0x39, 0xDB, 0xAC, 0xDF, 0x24, 0xD3, + 0xE5, 0xE6, 0xAD, 0x11, 0x0A, 0x0B, 0xFD, 0xFB, + 0x8C, 0xBB, 0x58, 0x13, 0x91, 0x6A, 0xB6, 0xA1 + }, + { + 0xE3, 0x04, 0xA6, 0xFD, 0x73, 0x38, 0xC1, 0xB0, + 0x37, 0xD4, 0xBA, 0xF4, 0x7C, 0xB7, 0xBA, 0x92, + 0x09, 0x87, 0x6A, 0xA9, 0xCD, 0x90, 0x2A, 0x39, + 0x9F, 0x2C, 0x39, 0x60, 0xAB, 0x0D, 0xCB, 0x54, + 0xF6, 0xEF, 0xA0, 0x81, 0x97, 0xDF, 0x7B, 0xED, + 0x1B, 0xB3, 0x43, 0xD3, 0x4D, 0xFA, 0x07, 0xB3, + 0xB2, 0xD9, 0xAF, 0xD7, 0xC0, 0xF5, 0x6A, 0x9C, + 0x48, 0x11, 0x46, 0xED, 0x91, 0x11, 0xB5, 0x12 + }, + { + 0xE5, 0x39, 0xFB, 0x65, 0x69, 0x2D, 0xC8, 0x96, + 0x62, 0xC6, 0x5A, 0xC5, 0xFF, 0xC8, 0x45, 0xC2, + 0x9E, 0xD1, 0x05, 0xAB, 0x28, 0x88, 0x16, 0x3B, + 0x22, 0x95, 0x18, 0x63, 0x69, 0x18, 0x32, 0x0F, + 0xF4, 0xD4, 0xC6, 0x4B, 0x7D, 0x47, 0x84, 0xDE, + 0x13, 0xAB, 0x85, 0x8E, 0x51, 0xC8, 0x9D, 0xCB, + 0x7A, 0x8F, 0xDF, 0x42, 0xD8, 0x76, 0xFB, 0x11, + 0xCD, 0xE2, 0xFA, 0x3D, 0xBB, 0x05, 0x5B, 0x24 + }, + { + 0xDF, 0x08, 0xB9, 0x86, 0xD0, 0x6A, 0xA7, 0xC3, + 0x40, 0x03, 0xDC, 0x55, 0x4C, 0xAD, 0xA2, 0xA2, + 0xC2, 0x96, 0xC3, 0xCE, 0xA5, 0x4E, 0xC8, 0xB8, + 0xDD, 0xFD, 0x1C, 0x98, 0x88, 0x37, 0xBD, 0xF0, + 0xF3, 0x34, 0x32, 0x19, 0xE6, 0x27, 0x19, 0x34, + 0x52, 0xED, 0xEF, 0x2C, 0x8C, 0x03, 0xBB, 0x24, + 0x4E, 0xE3, 0x42, 0x47, 0x11, 0x99, 0x55, 0x05, + 0xBD, 0xBE, 0x66, 0x1B, 0x6F, 0xB9, 0xDE, 0x4E + }, + { + 0x27, 0x34, 0xB0, 0xC1, 0x75, 0x15, 0xA7, 0x5B, + 0x32, 0xF4, 0x19, 0x76, 0x12, 0x6D, 0xBC, 0x43, + 0x8D, 0xEC, 0x26, 0x84, 0xC0, 0xDB, 0xDE, 0xB6, + 0x06, 0xF7, 0xB5, 0x3F, 0x64, 0xB0, 0x03, 0x61, + 0xE0, 0x82, 0xBC, 0x99, 0x0A, 0x61, 0x90, 0x78, + 0x0C, 0x67, 0x3C, 0x74, 0xDE, 0x34, 0xDC, 0xFC, + 0x2A, 0xB7, 0xC3, 0x99, 0x16, 0x62, 0x97, 0x1C, + 0xB8, 0x06, 0x6F, 0x24, 0x8F, 0xE1, 0x02, 0x2B + }, + { + 0x9D, 0xB5, 0xC5, 0xEC, 0xA5, 0x19, 0x7E, 0xDA, + 0xCC, 0x3F, 0x61, 0x64, 0xDB, 0xB9, 0xF9, 0x49, + 0x1B, 0xB9, 0xC2, 0x7A, 0xE0, 0xC8, 0xBA, 0x22, + 0x96, 0x60, 0x45, 0xEC, 0xB9, 0xEB, 0xD2, 0xC5, + 0x21, 0xF4, 0xA3, 0xFB, 0xB3, 0x1C, 0x6C, 0x7B, + 0xF3, 0x46, 0x61, 0xFA, 0xC0, 0x38, 0xE4, 0x20, + 0xDE, 0xF1, 0xB6, 0x8F, 0x3D, 0x21, 0xDA, 0x65, + 0x61, 0x9E, 0x1B, 0x76, 0x59, 0x67, 0xA5, 0x47 + }, + { + 0xB5, 0x45, 0xDA, 0x51, 0xCA, 0xDA, 0x37, 0x3D, + 0xA5, 0xFB, 0xBB, 0x00, 0xF9, 0xF8, 0x23, 0x63, + 0xB6, 0x1C, 0x0D, 0x6D, 0x0C, 0x9C, 0xF0, 0x7F, + 0xAE, 0xEA, 0x4B, 0xA3, 0xB9, 0x15, 0x14, 0xE0, + 0xD0, 0x13, 0x72, 0x5B, 0x2B, 0x34, 0x7C, 0x91, + 0xC8, 0xEA, 0xAB, 0x82, 0xCE, 0xEE, 0x8F, 0xB1, + 0x0F, 0xCB, 0x73, 0x61, 0xDE, 0xC0, 0xF6, 0xA3, + 0x1C, 0x68, 0x62, 0x9E, 0x83, 0x9D, 0x3F, 0x8D + }, + { + 0xE7, 0xF9, 0xCC, 0x98, 0x45, 0x86, 0x9A, 0xFB, + 0x64, 0x12, 0x30, 0x5E, 0x73, 0x49, 0x94, 0x54, + 0xCA, 0x63, 0x9B, 0xC2, 0x9A, 0x15, 0xEC, 0x9A, + 0xBE, 0x18, 0xDD, 0xF4, 0x75, 0x74, 0xC3, 0x71, + 0x32, 0x07, 0x0C, 0x1C, 0x51, 0x44, 0xA9, 0x9E, + 0xBD, 0x93, 0x07, 0x1F, 0x82, 0x01, 0xB0, 0xA7, + 0x11, 0x6C, 0x76, 0x1C, 0x5D, 0x5C, 0xF4, 0x0F, + 0x57, 0x00, 0x5A, 0xC5, 0xC6, 0x73, 0x98, 0x69 + }, + { + 0xDD, 0x29, 0x8D, 0xAF, 0x44, 0x41, 0x35, 0x23, + 0x04, 0x83, 0x32, 0x5B, 0xB7, 0xA4, 0x4A, 0x42, + 0x9F, 0xED, 0x42, 0x32, 0xE5, 0x40, 0x2C, 0xA3, + 0xFF, 0xBF, 0x2B, 0xFE, 0x17, 0xA5, 0xED, 0x07, + 0xEE, 0x63, 0x07, 0xE3, 0xA3, 0xC1, 0xF8, 0xF9, + 0xE1, 0x76, 0xD8, 0xAF, 0xA8, 0xA1, 0x31, 0xB4, + 0xFC, 0xA9, 0xBB, 0xD6, 0x6F, 0x09, 0xEB, 0x9A, + 0xD9, 0xF5, 0xDB, 0xAC, 0x0B, 0xD9, 0xBC, 0x0A + }, + { + 0x68, 0x5F, 0x7F, 0xA6, 0x31, 0x9E, 0x0A, 0x45, + 0xA3, 0xCA, 0xAD, 0xD8, 0x42, 0xC0, 0x42, 0x50, + 0x77, 0xB5, 0x5E, 0xE6, 0x52, 0x03, 0x8E, 0xFC, + 0xA6, 0xB5, 0x85, 0xEF, 0xC0, 0x12, 0xD7, 0x51, + 0x14, 0x0A, 0xDA, 0xBE, 0xC9, 0xEA, 0x5F, 0x5C, + 0x5C, 0x9F, 0x9D, 0x29, 0x0F, 0x53, 0xDC, 0xEF, + 0x7A, 0xA6, 0x48, 0x98, 0x39, 0xA4, 0xBE, 0xD0, + 0x8D, 0x38, 0xA6, 0x40, 0x13, 0xCB, 0xC8, 0xF6 + }, + { + 0x7D, 0xB2, 0xDA, 0x03, 0xB7, 0x70, 0x24, 0xEE, + 0x0B, 0xE4, 0xC4, 0x44, 0x4F, 0x72, 0x47, 0x73, + 0x10, 0x1A, 0x11, 0xE3, 0x79, 0x6F, 0x79, 0xE2, + 0x65, 0xAC, 0xF4, 0xC8, 0x3C, 0xAE, 0x21, 0xDA, + 0x0E, 0xC0, 0xC5, 0x97, 0xC8, 0xDA, 0x37, 0xA0, + 0xD9, 0x1B, 0x85, 0x5E, 0x13, 0x75, 0x3B, 0xAA, + 0x62, 0x61, 0xA4, 0x3E, 0x7A, 0x78, 0xF8, 0xD8, + 0xBA, 0x90, 0x7B, 0x3F, 0x88, 0x0C, 0x15, 0x9E + }, + { + 0xF5, 0x1A, 0x25, 0xE6, 0x7E, 0x32, 0xBB, 0xC0, + 0xB6, 0x0F, 0xD5, 0xB3, 0x37, 0xFC, 0x6E, 0xBF, + 0x31, 0x5F, 0x8D, 0x51, 0x72, 0x29, 0x8B, 0xE2, + 0xBE, 0xE6, 0x47, 0xA2, 0x6B, 0xE5, 0x68, 0xD8, + 0xCF, 0x49, 0x53, 0x58, 0xD0, 0xE5, 0x74, 0xD5, + 0x89, 0x7F, 0xED, 0xCC, 0x0F, 0x5F, 0x49, 0xA8, + 0xCB, 0x15, 0x2B, 0xCC, 0x4F, 0x69, 0x29, 0xDA, + 0x1D, 0xCF, 0x87, 0x8D, 0x44, 0x69, 0x49, 0x11 + }, + { + 0x8A, 0xBA, 0xF0, 0x8E, 0x30, 0x45, 0x9D, 0x16, + 0xE0, 0xD4, 0xA5, 0x2B, 0xDD, 0xCD, 0x0E, 0xA6, + 0x75, 0x46, 0x12, 0x0D, 0x87, 0xFC, 0x67, 0xF4, + 0xAA, 0xB0, 0x89, 0x56, 0xCB, 0x7A, 0x38, 0x16, + 0x2F, 0x75, 0x8D, 0xC7, 0x18, 0x63, 0xA0, 0x93, + 0x92, 0xE0, 0xC7, 0x4D, 0xC5, 0xAD, 0x73, 0xC4, + 0xF3, 0xFC, 0xB1, 0x9F, 0x71, 0xC7, 0x30, 0xFD, + 0x9D, 0x17, 0xBD, 0xDB, 0x97, 0x0A, 0xBA, 0x7F + }, + { + 0xB5, 0x0C, 0x06, 0x86, 0x84, 0xDC, 0xDE, 0x97, + 0xAC, 0xD4, 0x25, 0xE6, 0x9F, 0x76, 0x34, 0x85, + 0x1D, 0x8B, 0xD6, 0x19, 0x2F, 0x08, 0x57, 0x18, + 0x13, 0x24, 0xEC, 0x2C, 0x7F, 0x5A, 0x6E, 0x72, + 0xDC, 0x0B, 0xB8, 0x8C, 0xD3, 0xEA, 0x3F, 0x4E, + 0xFD, 0x30, 0x01, 0x5A, 0x61, 0x1B, 0xCF, 0x4C, + 0x0E, 0xE6, 0xF7, 0x33, 0x6F, 0xF4, 0x4C, 0xBB, + 0x01, 0x1A, 0x46, 0xB0, 0xB8, 0xBE, 0xB9, 0xB6 + }, + { + 0x54, 0x99, 0xE0, 0x52, 0x6C, 0xF0, 0x15, 0x06, + 0xAA, 0xBE, 0xB0, 0x88, 0xE8, 0xB0, 0x76, 0x7A, + 0x54, 0x5C, 0x74, 0x30, 0x01, 0x03, 0xD5, 0xCA, + 0x33, 0x97, 0x15, 0x61, 0xB9, 0xB7, 0x7A, 0x1D, + 0xE2, 0xB7, 0x21, 0xB9, 0x0F, 0x9F, 0x06, 0x41, + 0xD8, 0x9F, 0x45, 0x3E, 0xE6, 0xAF, 0x4D, 0x45, + 0x3C, 0x76, 0x52, 0xE7, 0x16, 0x74, 0xE9, 0x87, + 0x64, 0x59, 0x60, 0x24, 0x8D, 0x00, 0x60, 0xD1 + }, + { + 0xBC, 0xEC, 0x6E, 0xE0, 0x3C, 0x4A, 0xA0, 0x2D, + 0x97, 0x28, 0x3E, 0xA7, 0x4A, 0xE3, 0xBA, 0xBD, + 0x6A, 0x81, 0xFB, 0x7C, 0x4F, 0x66, 0x6F, 0xC6, + 0x0E, 0xC9, 0xFF, 0xE5, 0x38, 0xAA, 0x76, 0xC7, + 0xE3, 0xD3, 0x32, 0x77, 0xAA, 0x70, 0x23, 0x0E, + 0xB0, 0x3C, 0xD6, 0xDA, 0x22, 0xA2, 0x59, 0xE4, + 0x4F, 0x25, 0x23, 0x49, 0xB5, 0xDA, 0x06, 0x59, + 0x27, 0x88, 0x90, 0xD4, 0x39, 0x90, 0xE6, 0xA0 + }, + { + 0x03, 0x34, 0x68, 0x5D, 0x0E, 0xDB, 0xE5, 0xDD, + 0x71, 0xCF, 0x48, 0x02, 0x40, 0xB9, 0xFB, 0xCF, + 0x8F, 0x29, 0x60, 0x64, 0xE0, 0xB1, 0x05, 0x4A, + 0xAC, 0xB7, 0xE1, 0x5E, 0xAE, 0x2C, 0x9A, 0x1E, + 0x11, 0x56, 0xBB, 0x2A, 0x13, 0xF5, 0xF8, 0xBF, + 0x07, 0x9F, 0x79, 0x4C, 0xB4, 0xC6, 0xF4, 0x17, + 0xE6, 0xA9, 0xB4, 0xC7, 0x53, 0xD7, 0x5C, 0x98, + 0x76, 0x32, 0xF3, 0xEC, 0xA1, 0xA1, 0xEE, 0xDC + }, + { + 0x83, 0x59, 0x0B, 0x2F, 0x8F, 0xF8, 0xD8, 0xD8, + 0xA7, 0x08, 0x20, 0x58, 0x1A, 0xF7, 0x81, 0x10, + 0x38, 0xFF, 0x55, 0xE7, 0xE3, 0x11, 0x75, 0xD3, + 0x78, 0xA9, 0x79, 0xFB, 0xBE, 0xED, 0x06, 0x11, + 0x32, 0x4F, 0xEC, 0x8F, 0x0F, 0xEB, 0x27, 0x26, + 0xD3, 0x82, 0x54, 0x64, 0x88, 0x8D, 0x82, 0x9B, + 0xBC, 0x63, 0x72, 0x76, 0x96, 0x0A, 0x65, 0xFB, + 0x4C, 0x5F, 0x10, 0xC9, 0xDB, 0x72, 0x11, 0x06 + }, + { + 0x96, 0xE4, 0x91, 0x96, 0xA9, 0x90, 0x80, 0x38, + 0x5B, 0x8C, 0xE9, 0x12, 0x15, 0x24, 0xDD, 0x0C, + 0xB2, 0x15, 0x47, 0x01, 0x42, 0xE7, 0xFF, 0x1B, + 0x0D, 0x38, 0xAB, 0xA0, 0xC7, 0x56, 0x42, 0x4B, + 0x88, 0xEC, 0xD4, 0x16, 0x4E, 0x7C, 0x93, 0x1E, + 0x3A, 0x58, 0xC9, 0xAE, 0x6D, 0x31, 0x89, 0xFE, + 0x98, 0xA6, 0x96, 0xBF, 0x78, 0xAB, 0x8D, 0x25, + 0xE5, 0x5E, 0xD7, 0x2E, 0xEC, 0xBA, 0x0F, 0xC5 + }, + { + 0x30, 0x73, 0xFB, 0xEB, 0x5D, 0xE3, 0x1A, 0xB0, + 0x42, 0xF3, 0xD7, 0xAC, 0x3E, 0xE6, 0x36, 0x28, + 0x7A, 0x88, 0xB7, 0xD4, 0x94, 0xD3, 0x18, 0xBB, + 0x83, 0xF1, 0x6A, 0xEF, 0x2B, 0x8B, 0x6E, 0x3D, + 0xD9, 0xC6, 0xEF, 0xB1, 0xA7, 0xA0, 0xC8, 0x00, + 0xCF, 0xD6, 0xB2, 0xBB, 0x57, 0x75, 0xD3, 0xF4, + 0x53, 0x73, 0x6B, 0xE9, 0x44, 0xD1, 0x81, 0x08, + 0x2F, 0x76, 0x4B, 0xED, 0xEB, 0xA2, 0xD2, 0xBA + }, + { + 0xDA, 0x44, 0x51, 0x75, 0x6D, 0x75, 0x90, 0x56, + 0xE0, 0x41, 0x4B, 0xCC, 0x18, 0x14, 0xE2, 0x4C, + 0x56, 0xCA, 0x20, 0x09, 0x20, 0x0D, 0x27, 0x8D, + 0x0B, 0xC2, 0x13, 0xCC, 0xAF, 0x92, 0x88, 0x09, + 0xBE, 0x58, 0x6B, 0xE2, 0xD0, 0x82, 0xF8, 0xC6, + 0x53, 0x51, 0x4B, 0x89, 0x8A, 0x69, 0xA7, 0x5E, + 0xCF, 0x29, 0x42, 0x83, 0x12, 0xF0, 0xCF, 0x9F, + 0x91, 0x17, 0x35, 0x72, 0xC1, 0x62, 0x24, 0x4E + }, + { + 0xCA, 0x5D, 0x2D, 0x71, 0x30, 0x19, 0x7F, 0xF9, + 0xAB, 0xE7, 0xA9, 0x11, 0x87, 0xE0, 0xAF, 0x40, + 0xBE, 0x49, 0x64, 0xD7, 0xB4, 0xC2, 0x7A, 0xC5, + 0x21, 0x37, 0x8B, 0xCA, 0x8D, 0x53, 0xBE, 0xDA, + 0xE0, 0x5E, 0xF9, 0xBE, 0x1C, 0xE6, 0x8A, 0x61, + 0x46, 0x5E, 0xF2, 0x9E, 0x70, 0x7E, 0x3F, 0xB5, + 0xDD, 0x20, 0x7F, 0xBD, 0xD7, 0x86, 0x9B, 0x3A, + 0x19, 0x9C, 0xE9, 0x0B, 0xA9, 0x9E, 0x35, 0x99 + }, + { + 0x97, 0x76, 0x56, 0xA8, 0x82, 0x3F, 0x37, 0x46, + 0xEF, 0x57, 0x34, 0x72, 0x63, 0xBB, 0x3F, 0x5E, + 0x51, 0x3B, 0x48, 0x10, 0xE1, 0x20, 0x97, 0xF2, + 0xC1, 0xBA, 0xF0, 0x39, 0x76, 0x10, 0x52, 0x56, + 0xF2, 0x2B, 0x1B, 0xE7, 0x99, 0x85, 0x2F, 0x38, + 0x4F, 0x30, 0xE4, 0xD2, 0xA6, 0xBE, 0x61, 0xB9, + 0x44, 0x75, 0xEA, 0x92, 0xE0, 0x01, 0x0F, 0x39, + 0xE6, 0x5E, 0x5C, 0x17, 0x32, 0xD2, 0x29, 0xC6 + }, + { + 0xF0, 0x05, 0xD5, 0x48, 0x1A, 0x73, 0x75, 0xD2, + 0xAB, 0xA7, 0x0C, 0x75, 0x19, 0x32, 0xE4, 0x29, + 0x11, 0x49, 0xC7, 0x06, 0x79, 0x71, 0x3F, 0xFC, + 0xBC, 0xD0, 0xA4, 0x61, 0x17, 0x00, 0x2B, 0x9C, + 0xF7, 0x7F, 0xBE, 0xB9, 0x58, 0xCF, 0x2F, 0x30, + 0x16, 0xC9, 0xA1, 0xDA, 0x93, 0x30, 0x76, 0x35, + 0x52, 0x11, 0x1C, 0xD3, 0x8C, 0xD1, 0x7B, 0xA9, + 0xDE, 0xAF, 0x37, 0x44, 0x67, 0xB6, 0x92, 0x3F + }, + { + 0xAC, 0x89, 0x06, 0x17, 0xBE, 0x06, 0x18, 0xC6, + 0x0D, 0xFE, 0x84, 0xB8, 0x25, 0x0D, 0x02, 0x85, + 0x12, 0xF5, 0x94, 0xB4, 0xB5, 0xB7, 0x23, 0x2D, + 0x2E, 0x82, 0x38, 0x6E, 0x6D, 0x85, 0x82, 0x1B, + 0x77, 0x96, 0x70, 0xBE, 0x18, 0x9C, 0xC9, 0x38, + 0x78, 0x6B, 0xBC, 0x96, 0x69, 0xA8, 0x34, 0x22, + 0xDB, 0xDA, 0x94, 0x9F, 0xAA, 0xB2, 0x45, 0x04, + 0xB0, 0xDC, 0xB2, 0x6F, 0xFE, 0xFF, 0x4F, 0x0B + }, + { + 0x56, 0x55, 0x2A, 0xBC, 0x55, 0x66, 0xC7, 0x58, + 0x9B, 0xD3, 0x57, 0x15, 0x3D, 0x28, 0x4C, 0xCC, + 0x30, 0xDF, 0x75, 0x3A, 0x0E, 0x36, 0x9F, 0xAA, + 0xFC, 0x47, 0xAB, 0x53, 0x89, 0x28, 0xEE, 0xDE, + 0x7C, 0x84, 0x47, 0xAD, 0x68, 0xE1, 0xCD, 0xC4, + 0x78, 0x24, 0xBD, 0xC1, 0xB8, 0x3D, 0xBD, 0x9A, + 0x43, 0x81, 0x38, 0x50, 0x48, 0x4C, 0x65, 0xF3, + 0x6E, 0x48, 0xE6, 0xE6, 0x09, 0xDC, 0x1C, 0xC9 + }, + { + 0x2E, 0xFC, 0xC7, 0x23, 0x92, 0x1D, 0x5D, 0x23, + 0xC0, 0xDC, 0x7A, 0x21, 0x7C, 0x6C, 0xCA, 0x00, + 0x64, 0x25, 0x7C, 0xD3, 0x7C, 0xC6, 0xA3, 0xC8, + 0xEC, 0x42, 0xF0, 0x19, 0x8A, 0x1A, 0xDD, 0x86, + 0x3E, 0xF5, 0xAA, 0xCD, 0x7F, 0xC8, 0x55, 0x16, + 0x64, 0xA8, 0xCD, 0x6A, 0xA6, 0x5F, 0xB7, 0x45, + 0xD5, 0xF5, 0x1F, 0x94, 0x3F, 0xD9, 0xFD, 0x9A, + 0x97, 0xE1, 0x4B, 0x42, 0x6E, 0x62, 0xB3, 0x9C + }, + { + 0xED, 0xA9, 0x6A, 0xB4, 0x16, 0xD1, 0x8C, 0xA6, + 0xAE, 0x4C, 0x85, 0xFC, 0x7B, 0x09, 0x69, 0x77, + 0xDA, 0xA9, 0x3F, 0x29, 0xE0, 0xA5, 0x05, 0x7F, + 0x97, 0xD2, 0x0E, 0x85, 0xE7, 0xCD, 0x62, 0x3C, + 0xF6, 0x3B, 0x94, 0x4F, 0x07, 0xBE, 0xDB, 0x63, + 0x72, 0x20, 0x4B, 0x4B, 0x06, 0xFD, 0x6A, 0x1D, + 0x9C, 0x42, 0x41, 0xC7, 0x23, 0x3D, 0xBE, 0x1B, + 0x14, 0xE7, 0x92, 0x13, 0x9E, 0x8F, 0x17, 0x3A + }, + { + 0xFB, 0xD0, 0xB5, 0xDA, 0x05, 0xC3, 0x6A, 0xF1, + 0xDB, 0xEB, 0x9F, 0x69, 0xF1, 0x1E, 0xEA, 0xC5, + 0xC5, 0xCF, 0xC5, 0x9A, 0x05, 0xFB, 0x41, 0xFE, + 0x19, 0xFB, 0x07, 0x70, 0x1F, 0xC2, 0x52, 0x66, + 0x8D, 0xFB, 0xD8, 0xB3, 0xC3, 0x22, 0xE0, 0x56, + 0xA5, 0xDB, 0x85, 0xC6, 0xE1, 0x45, 0xBC, 0x07, + 0x6D, 0x70, 0x4B, 0x8E, 0xBC, 0x54, 0x19, 0x80, + 0x61, 0x14, 0xD4, 0x9E, 0xA6, 0x6B, 0x08, 0x37 + }, + { + 0x7E, 0x2B, 0x26, 0x0E, 0x8F, 0x40, 0x4B, 0x8C, + 0x06, 0x28, 0x9C, 0x0F, 0x31, 0x35, 0x00, 0x65, + 0xF8, 0xD2, 0x5E, 0xC3, 0x40, 0xAF, 0x49, 0xBD, + 0xF2, 0x07, 0x33, 0xB3, 0xCD, 0x8A, 0xFA, 0x4A, + 0x65, 0x1F, 0x78, 0x83, 0x98, 0xD0, 0x64, 0x49, + 0x0B, 0x99, 0xD6, 0xEC, 0xF3, 0x98, 0x79, 0x42, + 0x20, 0xA6, 0xC3, 0xD8, 0x83, 0x9B, 0xFE, 0x68, + 0x17, 0x24, 0xB8, 0x1E, 0xE4, 0x39, 0xAD, 0x39 + }, + { + 0x99, 0x77, 0x59, 0x84, 0x6B, 0x2C, 0xF9, 0x10, + 0x86, 0xC4, 0x67, 0xFE, 0x24, 0x0A, 0xA0, 0xFF, + 0x92, 0xFF, 0x0D, 0x72, 0x48, 0x03, 0xFF, 0xB3, + 0x16, 0x7E, 0x3B, 0x8D, 0xBC, 0xA3, 0x7D, 0x3C, + 0xB6, 0x1F, 0x1C, 0x6E, 0xCC, 0x41, 0x09, 0x42, + 0xE7, 0xE3, 0xB8, 0xE3, 0xCF, 0xB5, 0x5F, 0x77, + 0x93, 0xE4, 0x0B, 0x91, 0x3A, 0x4F, 0x85, 0xCA, + 0x4A, 0x2D, 0x49, 0x7E, 0x14, 0xE2, 0x2B, 0x9D + }, + { + 0xF4, 0xAF, 0x9C, 0x6E, 0x93, 0x6F, 0x2D, 0x18, + 0x97, 0x43, 0x36, 0x51, 0x17, 0x88, 0x55, 0x5B, + 0x89, 0x7A, 0x30, 0xC4, 0x8A, 0xF4, 0x7E, 0x41, + 0x64, 0xCE, 0x29, 0x14, 0x41, 0xD6, 0xE6, 0xE0, + 0x9E, 0xDD, 0xFC, 0xCB, 0xC8, 0x04, 0x0E, 0x25, + 0x76, 0xE3, 0x5B, 0x4D, 0x75, 0xA7, 0xC9, 0x71, + 0x77, 0x88, 0x84, 0x52, 0xDB, 0xD6, 0x52, 0xC0, + 0x27, 0x76, 0xF8, 0x1F, 0x7E, 0xC9, 0x10, 0x0C + }, + { + 0x87, 0xD4, 0x3C, 0x6F, 0x90, 0x4F, 0x80, 0x82, + 0xA8, 0x33, 0xB7, 0xC2, 0x83, 0x18, 0x31, 0x80, + 0x87, 0xC0, 0x19, 0x13, 0x7E, 0x72, 0x4A, 0x1B, + 0x9A, 0xF9, 0xCF, 0xE5, 0x86, 0x95, 0x92, 0xEF, + 0x56, 0x63, 0xB8, 0x07, 0xF2, 0x23, 0x52, 0xA6, + 0xAA, 0xD4, 0x94, 0xC6, 0xEB, 0xA0, 0xB7, 0x19, + 0x4F, 0x6F, 0x42, 0xD0, 0x59, 0xFA, 0x4E, 0x8A, + 0x97, 0xD0, 0x84, 0x7D, 0x89, 0x48, 0x33, 0xD9 + }, + { + 0x10, 0xE1, 0x19, 0x19, 0x1D, 0xA5, 0x96, 0x4A, + 0xFD, 0xBF, 0x01, 0x71, 0xF5, 0xE0, 0x62, 0xD4, + 0x12, 0x3E, 0x6C, 0x97, 0xE7, 0x59, 0xD2, 0x0D, + 0x03, 0x82, 0x5B, 0xE2, 0x2D, 0xEB, 0xC6, 0x94, + 0x7E, 0xF6, 0xC0, 0x1F, 0x5F, 0xDA, 0xC9, 0xEB, + 0x36, 0xE3, 0xB0, 0x39, 0x55, 0xFF, 0x28, 0xD6, + 0x47, 0xCA, 0xF5, 0x64, 0xF2, 0xCB, 0x2F, 0x20, + 0x3A, 0x0C, 0xBC, 0x90, 0xE0, 0xDD, 0x4D, 0xC3 + }, + { + 0x37, 0x64, 0xEE, 0x77, 0xC9, 0xDC, 0xBB, 0x28, + 0x16, 0xDA, 0xB8, 0xE6, 0xB7, 0xFB, 0xAE, 0x1C, + 0xA1, 0xA2, 0xEA, 0x38, 0xC9, 0xDC, 0x29, 0x48, + 0xC3, 0x28, 0xD9, 0xF9, 0x96, 0x5B, 0x30, 0xED, + 0x07, 0x23, 0x79, 0x05, 0x6C, 0x4F, 0xBC, 0x80, + 0x82, 0x42, 0x7F, 0x11, 0x0F, 0xDF, 0xBC, 0x46, + 0xDC, 0x88, 0x41, 0x56, 0xF6, 0xCF, 0xE4, 0x15, + 0x33, 0xB1, 0x34, 0x8B, 0xE8, 0x97, 0xE5, 0x5E + }, + { + 0xFD, 0x13, 0xD4, 0xEE, 0x69, 0xD9, 0x90, 0xE5, + 0x65, 0xCC, 0xAF, 0xAD, 0xE1, 0x18, 0xF8, 0xF3, + 0xA5, 0x07, 0x3B, 0xAD, 0x3C, 0xAE, 0xFE, 0x17, + 0xBE, 0xB1, 0xAB, 0xF2, 0x93, 0xA8, 0x5C, 0x3B, + 0x21, 0x2E, 0xDE, 0x41, 0xAD, 0xE9, 0xBD, 0xC2, + 0x2A, 0x88, 0xFC, 0x84, 0xDF, 0xDF, 0x6A, 0x66, + 0x7D, 0xE1, 0xBB, 0x01, 0xE4, 0x6C, 0x1F, 0x96, + 0x18, 0xAB, 0x74, 0x36, 0x36, 0x4F, 0x47, 0xCF + }, + { + 0xEC, 0x80, 0x50, 0x77, 0x62, 0x45, 0xCB, 0x21, + 0x02, 0xDE, 0x32, 0xDF, 0xCF, 0xF7, 0xA8, 0x0A, + 0x2A, 0x51, 0xF5, 0xD2, 0x41, 0x16, 0x25, 0x4E, + 0x2F, 0x08, 0x76, 0xEE, 0x8C, 0xD3, 0x38, 0x00, + 0x2D, 0x5D, 0xC2, 0x08, 0x0A, 0x49, 0xCA, 0xB2, + 0x63, 0xED, 0x53, 0x80, 0x6F, 0x22, 0x77, 0x8E, + 0xD0, 0x78, 0x30, 0x73, 0x66, 0x15, 0x1F, 0xDD, + 0x53, 0x35, 0x2C, 0xA4, 0xE8, 0x95, 0x56, 0x3C + }, + { + 0x33, 0x2D, 0x2B, 0xE0, 0x2D, 0x21, 0xA2, 0xFE, + 0x66, 0xDC, 0x40, 0x07, 0x69, 0x38, 0x4D, 0x00, + 0xBA, 0x7F, 0x59, 0x51, 0x54, 0x0B, 0xAD, 0xD1, + 0xCC, 0x44, 0x8C, 0x13, 0x19, 0xB7, 0xAB, 0x81, + 0x2C, 0x26, 0xAE, 0x37, 0x3E, 0x8B, 0xF6, 0x5C, + 0xE8, 0xBF, 0xC4, 0x64, 0x25, 0xDC, 0xB5, 0x7D, + 0xC5, 0x55, 0x3E, 0x97, 0xD6, 0xCF, 0xE2, 0x51, + 0xCD, 0x79, 0x09, 0xB9, 0x2A, 0x78, 0x05, 0x49 + }, + { + 0x01, 0x47, 0x4B, 0x35, 0x6B, 0x94, 0xF5, 0x89, + 0xB0, 0x54, 0xE8, 0x26, 0x5B, 0x0D, 0x39, 0x76, + 0x44, 0xC3, 0x77, 0x9A, 0xD2, 0x2D, 0x4E, 0xB9, + 0xC5, 0xC5, 0x2F, 0x3B, 0x9F, 0xD1, 0x0E, 0xE4, + 0xDE, 0xBF, 0x8A, 0xF8, 0x27, 0x9C, 0xF0, 0x04, + 0x82, 0x3A, 0xE0, 0x89, 0x29, 0x24, 0x31, 0xB9, + 0x9B, 0x23, 0xFA, 0x0E, 0xB3, 0x8B, 0x38, 0x96, + 0x71, 0xC9, 0x38, 0x8B, 0x7E, 0xF7, 0x68, 0x3A + }, + { + 0xA6, 0x23, 0x18, 0xBB, 0x95, 0x10, 0xDB, 0x50, + 0x09, 0xAC, 0x56, 0x43, 0x8A, 0xB9, 0x4E, 0x66, + 0xF7, 0x9D, 0x47, 0xE0, 0xB6, 0x4C, 0x13, 0xEE, + 0xC0, 0x54, 0x6C, 0x3E, 0x07, 0x08, 0xE9, 0x9E, + 0x00, 0xFA, 0x35, 0x1C, 0x52, 0x9C, 0x02, 0xC9, + 0xBF, 0x01, 0x7C, 0x93, 0x26, 0x9B, 0x1C, 0x69, + 0x2D, 0xC2, 0xB7, 0xA1, 0x7B, 0x05, 0xEB, 0x38, + 0x86, 0x37, 0x42, 0x51, 0x86, 0x01, 0x12, 0x88 + }, + { + 0xFC, 0x9B, 0x6F, 0x09, 0x54, 0xBA, 0x8A, 0xB8, + 0x33, 0x1B, 0x15, 0x99, 0x18, 0xA6, 0xD2, 0x6C, + 0x56, 0x83, 0x25, 0x2D, 0x3A, 0x4D, 0xA3, 0xD6, + 0xB6, 0x63, 0x09, 0xD8, 0x65, 0x67, 0xB4, 0x18, + 0x70, 0x1E, 0xB5, 0x7D, 0xF1, 0xA8, 0x8C, 0x1C, + 0xDE, 0x6B, 0x21, 0xEA, 0x64, 0x49, 0xB0, 0xC6, + 0x13, 0x2D, 0xCF, 0x16, 0x01, 0x60, 0x2E, 0x6C, + 0x7D, 0x75, 0x4C, 0x4C, 0xDF, 0xF6, 0x24, 0x0C + }, + { + 0x4E, 0x5C, 0x11, 0xEC, 0x32, 0x6F, 0x36, 0x99, + 0x9E, 0x88, 0x23, 0xAA, 0x73, 0x94, 0x5C, 0xDF, + 0x85, 0x32, 0xCE, 0x62, 0xDC, 0x0A, 0xD7, 0xCA, + 0xB9, 0x22, 0x5B, 0x72, 0xD9, 0x1B, 0x95, 0xC0, + 0xEA, 0x11, 0x40, 0x52, 0xFF, 0xEB, 0x7D, 0xF3, + 0xE9, 0x6F, 0xC0, 0x78, 0xF4, 0xFD, 0xB4, 0x88, + 0x41, 0xE5, 0x9E, 0xBF, 0x36, 0x4F, 0xCF, 0xC1, + 0xA2, 0xCA, 0x28, 0x5F, 0xB3, 0x0C, 0xB6, 0x63 + }, + { + 0xFF, 0x1A, 0x48, 0x7C, 0xBD, 0x15, 0x52, 0xD9, + 0x58, 0x36, 0x8F, 0x69, 0x45, 0x8C, 0x78, 0xE2, + 0x7E, 0x2C, 0x1F, 0xBA, 0x05, 0xA6, 0x5C, 0x02, + 0xD0, 0xB7, 0xDF, 0x54, 0xCB, 0x3F, 0xF7, 0xB7, + 0xE8, 0xF5, 0x5D, 0x67, 0xD2, 0x2E, 0x4A, 0x68, + 0xD2, 0xF4, 0x03, 0xB3, 0x9D, 0xC6, 0xF7, 0x12, + 0x3C, 0xAF, 0x4A, 0x59, 0xBF, 0xFB, 0x6F, 0x6D, + 0x25, 0x38, 0xE3, 0x8D, 0xF0, 0x85, 0x72, 0x02 + }, + { + 0x99, 0x8F, 0x58, 0x6D, 0x56, 0xFC, 0x66, 0x13, + 0x8F, 0x53, 0xF1, 0x57, 0xDB, 0x3D, 0xE2, 0xC4, + 0xDC, 0xAA, 0x0C, 0xE5, 0x6D, 0x7C, 0x38, 0x53, + 0x22, 0xA1, 0x26, 0x4E, 0x5A, 0xA4, 0x5F, 0xD0, + 0x1A, 0x2D, 0x22, 0xD9, 0xB5, 0xD2, 0xA9, 0xB4, + 0x91, 0x10, 0x55, 0xC9, 0xD3, 0x87, 0x6E, 0x20, + 0x2F, 0x48, 0x3D, 0x08, 0xAF, 0xD7, 0xFB, 0xB2, + 0x15, 0xA2, 0x04, 0xD0, 0xCC, 0xBC, 0xDA, 0xD1 + }, + { + 0xD7, 0xC0, 0x7B, 0xD0, 0xAB, 0xA8, 0x23, 0xB7, + 0x45, 0x98, 0xA9, 0xEE, 0x68, 0x89, 0xA5, 0xA5, + 0xBF, 0x0A, 0x40, 0x07, 0x28, 0x12, 0x22, 0x0B, + 0xF3, 0xEA, 0x00, 0xEC, 0x18, 0x59, 0xD9, 0xC2, + 0x63, 0x2F, 0x9C, 0x5E, 0xB2, 0xB9, 0xC1, 0x48, + 0x8D, 0x02, 0x17, 0x68, 0x94, 0x85, 0xFD, 0xFB, + 0x94, 0x38, 0x31, 0x90, 0xF1, 0xED, 0x5A, 0x85, + 0x8E, 0x6E, 0x10, 0xA9, 0xE6, 0xB0, 0x2F, 0x2D + }, + { + 0xA1, 0xC6, 0x37, 0x31, 0xF8, 0x89, 0x07, 0xA4, + 0x1C, 0xAF, 0x23, 0x1B, 0xCC, 0xA7, 0x59, 0x52, + 0x2F, 0xAA, 0xB7, 0xCF, 0xD0, 0x59, 0x02, 0x1A, + 0x56, 0xF9, 0x81, 0x3F, 0x81, 0x30, 0x77, 0x75, + 0x1E, 0x45, 0xCD, 0x25, 0xDC, 0xFB, 0x34, 0xFF, + 0xAC, 0x99, 0x4B, 0x38, 0x68, 0xF0, 0x93, 0xE6, + 0x90, 0x88, 0xE6, 0xDC, 0x71, 0xCB, 0x67, 0xE1, + 0x93, 0x4A, 0xF1, 0x05, 0xF7, 0xD8, 0x9C, 0x02 + }, + { + 0x7B, 0x87, 0x60, 0x12, 0xE0, 0xCE, 0xC4, 0x88, + 0xFE, 0x48, 0xBC, 0x7F, 0xAE, 0x0D, 0xBB, 0x1E, + 0xDD, 0x7C, 0xAF, 0x0A, 0x87, 0x27, 0x49, 0x79, + 0xF7, 0x9F, 0x07, 0x77, 0x91, 0x26, 0xAC, 0x9A, + 0x6E, 0x16, 0xC1, 0x6A, 0x60, 0x3C, 0xE5, 0x52, + 0x42, 0xD0, 0x4D, 0xEC, 0x01, 0xFB, 0x71, 0xA2, + 0x62, 0x0E, 0x18, 0x06, 0xD7, 0xE6, 0x36, 0x94, + 0x65, 0xE8, 0x8D, 0x17, 0x15, 0x24, 0x26, 0xF8 + }, + { + 0x58, 0x58, 0x20, 0xEB, 0x03, 0xD1, 0x3E, 0xE2, + 0x68, 0x95, 0x44, 0xB2, 0x29, 0xEB, 0x67, 0x59, + 0xBC, 0x2E, 0x5B, 0xF7, 0x32, 0xDE, 0x8B, 0x5B, + 0x35, 0xD3, 0xB8, 0xB8, 0x95, 0xB4, 0x98, 0xBC, + 0x14, 0x98, 0x4E, 0xEB, 0x89, 0x6C, 0xD8, 0x5F, + 0xFB, 0x2A, 0xCD, 0xDF, 0x65, 0xB3, 0xD8, 0x60, + 0x81, 0xE6, 0x63, 0x5B, 0x4A, 0x0A, 0xD1, 0x27, + 0xAF, 0x82, 0x7A, 0x9F, 0xF7, 0x09, 0x3B, 0x39 + }, + { + 0xA5, 0x1A, 0x07, 0x32, 0x7E, 0x93, 0x70, 0x89, + 0x29, 0x35, 0xCA, 0xA2, 0x6C, 0xF5, 0xD3, 0xBD, + 0x4E, 0x3C, 0xCE, 0xB1, 0x87, 0xCF, 0xD1, 0x02, + 0xFA, 0x52, 0x47, 0x71, 0xC0, 0x76, 0x91, 0x5B, + 0x48, 0x3F, 0xFB, 0xCF, 0x71, 0x02, 0x76, 0xCB, + 0x1D, 0xAE, 0xD8, 0x54, 0xA9, 0xD6, 0xFB, 0x69, + 0x99, 0x6E, 0x56, 0xCB, 0xC3, 0x31, 0x76, 0xD3, + 0x87, 0x04, 0xD8, 0x00, 0x3D, 0x82, 0x23, 0xA6 + }, + { + 0xA4, 0xC7, 0xD9, 0xC2, 0x29, 0x3B, 0x76, 0x24, + 0x4A, 0xBD, 0xA5, 0x20, 0x41, 0xC5, 0xCD, 0xEC, + 0x93, 0x34, 0x25, 0xB1, 0xF7, 0x1F, 0xF2, 0x48, + 0xB6, 0x82, 0xCB, 0xC7, 0x23, 0xA1, 0xC2, 0x3E, + 0xF7, 0x84, 0xF0, 0x17, 0x4E, 0x15, 0x8E, 0x61, + 0x36, 0xDE, 0x84, 0x53, 0x1B, 0x09, 0x59, 0x9A, + 0x54, 0xBA, 0xEE, 0x02, 0xFB, 0xC5, 0xA6, 0xDC, + 0xE2, 0x62, 0xF6, 0xA7, 0xFE, 0xDA, 0x91, 0x2A + }, + { + 0xD5, 0xCB, 0xA8, 0x5F, 0x36, 0xA8, 0x3E, 0x0D, + 0xFF, 0x49, 0xBE, 0x67, 0xF5, 0x2E, 0x08, 0xA1, + 0xCA, 0xF6, 0x42, 0xC2, 0x07, 0xFC, 0x8E, 0xDE, + 0xD2, 0x1B, 0x19, 0x97, 0x3A, 0xB0, 0xA1, 0x62, + 0x46, 0x7E, 0xDB, 0x77, 0xCC, 0x80, 0x3F, 0xA4, + 0x89, 0xF5, 0x56, 0x21, 0x69, 0xBB, 0x91, 0x54, + 0xE4, 0xBC, 0x5E, 0x45, 0xD0, 0x98, 0x1B, 0x0B, + 0xDF, 0x98, 0x99, 0x46, 0x14, 0x5D, 0x82, 0x7C + }, + { + 0x25, 0xE7, 0x72, 0xE9, 0xDA, 0x1A, 0xA6, 0xCD, + 0x7F, 0x19, 0xEF, 0x3A, 0x84, 0x79, 0xAB, 0x5F, + 0xDE, 0xC4, 0xBA, 0xA2, 0x5D, 0x4B, 0x3B, 0x53, + 0x2B, 0x92, 0x95, 0xD7, 0xAB, 0x7F, 0xC7, 0x63, + 0x6B, 0x7E, 0x85, 0x3D, 0x01, 0x12, 0xB2, 0x1E, + 0x99, 0xFA, 0xE4, 0xFD, 0x85, 0xF6, 0x51, 0x8F, + 0xD7, 0xA4, 0x8B, 0x4E, 0x11, 0xA3, 0x3D, 0x7D, + 0xC4, 0x60, 0x7C, 0x5C, 0x6A, 0x05, 0x13, 0xEF + }, + { + 0xA5, 0xDB, 0x7D, 0x38, 0xEA, 0xA3, 0x5A, 0x8C, + 0x49, 0xD5, 0xB1, 0x40, 0x0D, 0x02, 0xCB, 0x76, + 0xB9, 0x18, 0xCB, 0xEE, 0xAF, 0xAB, 0xA6, 0xBC, + 0xAA, 0x8A, 0x7E, 0x3C, 0xCC, 0xA1, 0xC0, 0x04, + 0x88, 0x60, 0xE7, 0x1A, 0x13, 0x29, 0x5B, 0xCB, + 0xF2, 0x30, 0x68, 0xB6, 0x31, 0xBE, 0x1C, 0xD5, + 0x01, 0xA3, 0xBF, 0xE1, 0x69, 0x9D, 0xF6, 0xA6, + 0x56, 0x43, 0x1F, 0x80, 0x37, 0x14, 0xE1, 0x87 + }, + { + 0xB7, 0x20, 0x51, 0xDE, 0xD0, 0x29, 0x78, 0xDE, + 0x48, 0x87, 0xA9, 0xE5, 0xF7, 0xAF, 0xF8, 0x0E, + 0x08, 0x76, 0xEC, 0x20, 0x2E, 0xAF, 0x3F, 0xDA, + 0x2A, 0x1D, 0x1F, 0x14, 0xA3, 0x86, 0x90, 0x7B, + 0x9E, 0x49, 0x63, 0x93, 0xA1, 0xB7, 0xE4, 0x47, + 0xE8, 0x6F, 0x2F, 0x09, 0x6F, 0x5C, 0x15, 0x9F, + 0x5F, 0x33, 0x70, 0x11, 0x23, 0x2B, 0xC1, 0x0D, + 0x02, 0x7C, 0x13, 0x31, 0xAA, 0x23, 0x9F, 0x53 + }, + { + 0x61, 0xDF, 0x4E, 0x85, 0xE9, 0x9B, 0x17, 0x0C, + 0xA0, 0x96, 0xC7, 0x9D, 0xB2, 0x04, 0x2D, 0xDE, + 0xF1, 0xBE, 0x26, 0x49, 0x3B, 0x52, 0x81, 0x27, + 0xE4, 0x78, 0x0A, 0x14, 0xDA, 0x6E, 0x3E, 0x28, + 0x6A, 0xF0, 0xD4, 0x8D, 0xAF, 0xCC, 0x35, 0xB9, + 0x1D, 0x74, 0xCD, 0x43, 0xCE, 0x56, 0x06, 0x2F, + 0x6A, 0x7A, 0x51, 0xEF, 0xB5, 0xA1, 0xC1, 0x0A, + 0xF8, 0x07, 0xC3, 0x51, 0x2A, 0x11, 0x79, 0x79 + }, + { + 0x6C, 0x1A, 0x28, 0xDD, 0xDD, 0x92, 0xC9, 0x9C, + 0x92, 0x5C, 0x93, 0x54, 0x74, 0x9E, 0x6F, 0x49, + 0x2C, 0x13, 0x1E, 0x87, 0x1D, 0xEF, 0xE5, 0x00, + 0x2E, 0xD8, 0xB1, 0xD6, 0xFC, 0x81, 0xE9, 0x99, + 0x67, 0x16, 0xA2, 0x3A, 0x67, 0x5F, 0x06, 0x1E, + 0x09, 0xCD, 0xF8, 0x4D, 0x01, 0x7D, 0xFD, 0x92, + 0xB2, 0x93, 0x93, 0xF2, 0xDD, 0x06, 0x9C, 0x23, + 0x44, 0x35, 0x9D, 0xFF, 0x84, 0xA5, 0xF8, 0x68 + }, + { + 0xF8, 0x90, 0x25, 0x62, 0x40, 0x0A, 0xF0, 0xA1, + 0x68, 0x74, 0xE0, 0xAB, 0x43, 0x2D, 0x54, 0x42, + 0xDF, 0xA8, 0x24, 0x39, 0xA2, 0x20, 0xF9, 0x27, + 0xC8, 0xC6, 0x54, 0x07, 0x6C, 0xDB, 0x1F, 0xD8, + 0x4B, 0x6F, 0x60, 0xA1, 0x70, 0xDA, 0x9E, 0x81, + 0xE4, 0xEB, 0x03, 0xA0, 0xE8, 0x2A, 0x66, 0xED, + 0xC3, 0x9A, 0x3F, 0xCA, 0xFF, 0x3B, 0x8C, 0xBB, + 0x53, 0x8E, 0x87, 0x73, 0x89, 0x50, 0x24, 0x65 + }, + { + 0x86, 0x8A, 0x4B, 0xE4, 0x29, 0xBF, 0xE1, 0x26, + 0x79, 0x6F, 0x52, 0x80, 0x04, 0xB9, 0x9B, 0xB7, + 0x9B, 0x3C, 0xB1, 0x49, 0x77, 0x1E, 0x8D, 0x9F, + 0x0D, 0x96, 0x2E, 0x39, 0xD5, 0x8D, 0xB1, 0xC2, + 0x8D, 0x42, 0xDC, 0xF2, 0x3E, 0xAE, 0xD7, 0x36, + 0x1F, 0xE1, 0xAE, 0x8B, 0xC1, 0x82, 0xA7, 0xE0, + 0x36, 0x35, 0x2B, 0xF5, 0x71, 0x97, 0x6D, 0x2B, + 0xFD, 0x63, 0xE9, 0x2D, 0x92, 0x0B, 0xB4, 0x9A + }, + { + 0xB1, 0x04, 0x2A, 0xED, 0xDF, 0x0F, 0x6E, 0x6F, + 0xD7, 0x44, 0x9C, 0x74, 0x23, 0x58, 0x7E, 0xAD, + 0xF4, 0x41, 0xEB, 0x36, 0xF7, 0x92, 0x82, 0x6A, + 0x94, 0xA4, 0xD3, 0x47, 0xCD, 0x5D, 0x78, 0xD6, + 0xE0, 0x08, 0x74, 0x07, 0x7C, 0x3C, 0x05, 0x58, + 0x30, 0x8F, 0x36, 0xE5, 0x3F, 0xBE, 0x9E, 0x66, + 0xC8, 0xB0, 0x80, 0xEA, 0xCB, 0x14, 0x4D, 0xF1, + 0x56, 0xE6, 0xA8, 0xA5, 0xFB, 0x09, 0x45, 0xD6 + }, + { + 0xD6, 0xA3, 0xE8, 0xCD, 0xFB, 0x8E, 0xB5, 0xCF, + 0x66, 0xDB, 0x73, 0x80, 0xE1, 0xCD, 0x3D, 0x27, + 0x98, 0x60, 0xAA, 0xF8, 0xB5, 0x33, 0xBF, 0x19, + 0xFA, 0xEA, 0x4A, 0xA5, 0xF9, 0xB8, 0x82, 0x72, + 0xD0, 0xB9, 0x9A, 0x67, 0x1C, 0xC7, 0x34, 0x14, + 0xB8, 0x51, 0xC5, 0x80, 0x03, 0xD1, 0x8A, 0x61, + 0x11, 0xD9, 0x15, 0x75, 0x05, 0x71, 0xE8, 0xE4, + 0xFC, 0xF7, 0xB7, 0xAD, 0x33, 0xAC, 0x5F, 0x6A + }, + { + 0xC7, 0x6E, 0xE5, 0x3F, 0x7E, 0xA7, 0x17, 0x17, + 0xFD, 0x4F, 0xA0, 0x77, 0x44, 0x51, 0xF0, 0xFA, + 0xB1, 0x32, 0x89, 0x74, 0xC7, 0x17, 0xA7, 0xED, + 0x5C, 0xD2, 0xD9, 0xE1, 0x86, 0xBE, 0x38, 0x25, + 0x49, 0x45, 0xD9, 0x00, 0x75, 0x06, 0x8D, 0xDE, + 0xEB, 0x39, 0xD4, 0x1D, 0xF0, 0xDD, 0x0B, 0x95, + 0xF1, 0x1F, 0xAD, 0x18, 0x41, 0x1F, 0xAF, 0xF0, + 0xAA, 0x52, 0xD1, 0x99, 0xCF, 0x80, 0xA1, 0x2B + }, + { + 0x71, 0x48, 0x73, 0x28, 0xB3, 0xD4, 0x23, 0xC4, + 0xD0, 0xD8, 0x27, 0xE3, 0xE6, 0xAC, 0x94, 0xE8, + 0xAE, 0x0A, 0x80, 0x19, 0xF7, 0x4E, 0xCA, 0x57, + 0x69, 0x99, 0x58, 0x7F, 0x93, 0xD6, 0x09, 0x3B, + 0x8B, 0xC6, 0xB8, 0x34, 0xA4, 0xDC, 0xE8, 0x1F, + 0x65, 0x5A, 0x79, 0x60, 0xD4, 0xBE, 0x92, 0x16, + 0xD1, 0xEB, 0x1A, 0xC6, 0x9F, 0x10, 0xF2, 0xB8, + 0x27, 0x3F, 0x40, 0xC5, 0x92, 0xD2, 0x9F, 0xA2 + }, + { + 0x5F, 0xA7, 0xAC, 0x3B, 0x33, 0x7D, 0xDD, 0xCC, + 0xCE, 0x0C, 0x29, 0x46, 0x74, 0xF4, 0x62, 0xA9, + 0x1E, 0x1D, 0x87, 0x40, 0x5F, 0xCF, 0xB4, 0xED, + 0xA4, 0xD4, 0xA8, 0x2A, 0xE1, 0xB4, 0x41, 0x15, + 0x67, 0x5B, 0xCD, 0x69, 0x5A, 0x8E, 0x5D, 0x2F, + 0xD4, 0x82, 0x1E, 0x22, 0xB4, 0x2A, 0x6D, 0x2A, + 0x2A, 0x63, 0x99, 0x28, 0x42, 0xFC, 0xF2, 0x28, + 0x4E, 0xFE, 0x33, 0xA9, 0xED, 0x36, 0x21, 0x4E + }, + { + 0xC7, 0x93, 0x3F, 0x1F, 0x19, 0x9A, 0xF8, 0xBF, + 0xDE, 0xB0, 0xE1, 0x65, 0x81, 0xD4, 0xB2, 0x3E, + 0x7E, 0x55, 0x64, 0xC3, 0x72, 0xEE, 0x2F, 0xBF, + 0xDF, 0xC5, 0xAE, 0x4B, 0xFE, 0xA0, 0x55, 0xA9, + 0x7D, 0x90, 0xC9, 0x40, 0x82, 0x47, 0x0C, 0x3A, + 0xD9, 0x1A, 0x16, 0x25, 0x25, 0xC6, 0x94, 0x03, + 0x1B, 0x74, 0x86, 0xA4, 0x63, 0x86, 0x84, 0xFB, + 0x37, 0x7C, 0xD8, 0xA5, 0x2E, 0x69, 0x36, 0x16 + }, + { + 0x28, 0x4E, 0xD0, 0x10, 0xC2, 0xCE, 0x39, 0x28, + 0x82, 0x9B, 0x0F, 0xA1, 0x04, 0x8B, 0xED, 0xC7, + 0x38, 0x11, 0xF2, 0x5C, 0x6A, 0x2C, 0xBE, 0x13, + 0x14, 0xA3, 0x89, 0x69, 0xED, 0x30, 0x0E, 0x4C, + 0xCD, 0xB7, 0x65, 0x2B, 0x0A, 0xBB, 0xBF, 0x83, + 0x22, 0xE3, 0x3D, 0xCF, 0x7B, 0xEE, 0x98, 0xB8, + 0x53, 0x13, 0x07, 0x00, 0x80, 0x35, 0x9B, 0xDB, + 0x88, 0x01, 0x4C, 0x4C, 0x42, 0xF1, 0xEB, 0x07 + }, + { + 0xE5, 0x2E, 0x41, 0x0E, 0xEE, 0x69, 0x3E, 0x46, + 0xE9, 0x9E, 0xE8, 0x18, 0x86, 0xF0, 0x10, 0xBA, + 0xA0, 0x48, 0xA4, 0x8D, 0x2F, 0x11, 0x8E, 0xE7, + 0x29, 0x44, 0xDB, 0xA1, 0x97, 0x49, 0x98, 0xC8, + 0xD3, 0xFA, 0xEC, 0x9B, 0xB3, 0x15, 0x8C, 0x42, + 0x0F, 0xE0, 0x20, 0x75, 0xDE, 0x8E, 0xAE, 0x4F, + 0x27, 0x30, 0xC5, 0x1A, 0x6A, 0x4C, 0xCE, 0x46, + 0xE4, 0x15, 0xDD, 0xFC, 0xE6, 0x3B, 0xAE, 0xA3 + }, + { + 0xB2, 0x77, 0xF5, 0xB6, 0x1F, 0x4E, 0x16, 0x45, + 0x8F, 0xE2, 0x9E, 0x9C, 0xA4, 0xF0, 0xCE, 0x1A, + 0xAE, 0x28, 0x44, 0x2A, 0xC4, 0x41, 0xBD, 0x7F, + 0xA1, 0xD6, 0x3A, 0xD5, 0x0D, 0x4F, 0x78, 0x76, + 0x35, 0xCF, 0xA4, 0x20, 0x4B, 0x6E, 0xAC, 0x17, + 0xBE, 0x08, 0xE0, 0xFA, 0x26, 0x16, 0x17, 0x44, + 0xFC, 0xBD, 0x69, 0x4B, 0xBE, 0x8B, 0x34, 0x24, + 0xEC, 0x89, 0x4A, 0xC8, 0xCF, 0x22, 0xA2, 0x12 + }, + { + 0x8D, 0xC2, 0xFF, 0xEA, 0xAF, 0xE0, 0x5C, 0x58, + 0xAE, 0xD4, 0x4A, 0xAA, 0xD9, 0x5B, 0xD8, 0xD6, + 0x8E, 0x80, 0x77, 0x24, 0xFC, 0x31, 0x54, 0x16, + 0x7A, 0xA3, 0x70, 0x55, 0x7D, 0x46, 0x75, 0xA1, + 0x7B, 0x7B, 0x42, 0xB5, 0x3C, 0x7F, 0xE0, 0x98, + 0x19, 0xAC, 0xEE, 0xEB, 0x4D, 0xCC, 0xB5, 0xF8, + 0xED, 0xA6, 0xDC, 0xFB, 0xF6, 0xC3, 0x62, 0xB2, + 0x85, 0x2D, 0xAC, 0x80, 0x45, 0xF7, 0xBA, 0xCE + }, + { + 0x19, 0xD8, 0x6C, 0xBF, 0x21, 0xA2, 0xEA, 0x15, + 0x6A, 0x98, 0xC8, 0x53, 0x0D, 0xB2, 0x65, 0x87, + 0xDC, 0x9B, 0x1C, 0x26, 0x85, 0x8D, 0xA3, 0x29, + 0x3A, 0x90, 0x32, 0x4D, 0xC2, 0x30, 0x57, 0x7A, + 0x95, 0x33, 0xE1, 0xDF, 0x11, 0x61, 0x4E, 0x4F, + 0xA4, 0x85, 0x19, 0xBB, 0xCD, 0x84, 0xB8, 0xB7, + 0x1E, 0xE7, 0x4D, 0xD9, 0xCB, 0x90, 0x17, 0xD7, + 0x53, 0x2D, 0xE5, 0xC4, 0xDF, 0x5E, 0xA1, 0xA1 + }, + { + 0xED, 0x45, 0x7A, 0x5A, 0x52, 0xB8, 0xC6, 0xB3, + 0x09, 0x77, 0xFC, 0x52, 0x61, 0xB8, 0x77, 0xA5, + 0x18, 0x7A, 0xEE, 0x13, 0xD2, 0xC3, 0x96, 0xDB, + 0xB5, 0x0A, 0x54, 0x79, 0x94, 0xFA, 0x6A, 0xD5, + 0x49, 0x81, 0xD7, 0x24, 0x25, 0xD1, 0xC8, 0xA1, + 0xE8, 0x5F, 0x2F, 0xBE, 0x97, 0x37, 0x90, 0x1F, + 0x08, 0xD3, 0xDA, 0x6C, 0x04, 0x9B, 0xBD, 0x92, + 0x72, 0xFA, 0x9D, 0xF6, 0x52, 0x2A, 0x22, 0x75 + }, + { + 0xFD, 0xA7, 0x89, 0xDA, 0xC0, 0xAA, 0xB2, 0xE5, + 0x97, 0x40, 0xCB, 0x90, 0x11, 0xEC, 0x5B, 0xF4, + 0x81, 0x79, 0xEF, 0xAB, 0xF5, 0xE9, 0x8D, 0x38, + 0xED, 0xC4, 0xB0, 0x5B, 0x7A, 0xA6, 0xDC, 0x18, + 0xA6, 0xEF, 0x54, 0xC3, 0xC2, 0x27, 0xE4, 0x78, + 0x81, 0x35, 0xBD, 0x74, 0xB5, 0x0F, 0xEE, 0x27, + 0x49, 0x8D, 0x15, 0x25, 0x39, 0x16, 0xA5, 0x4A, + 0xBC, 0xCA, 0x23, 0x02, 0x96, 0x4A, 0xF2, 0x2B + }, + { + 0x9B, 0x61, 0x55, 0x08, 0xBA, 0x28, 0x4B, 0x14, + 0x26, 0x29, 0x51, 0x5C, 0xA8, 0x2F, 0xD9, 0x7F, + 0x52, 0x49, 0xC7, 0x75, 0xA9, 0x46, 0x3C, 0x3B, + 0x93, 0xB8, 0x54, 0x66, 0x54, 0xE7, 0xAB, 0x2F, + 0xE3, 0xD8, 0xD3, 0xF2, 0x5E, 0xA4, 0x66, 0xAD, + 0x87, 0x2F, 0x94, 0x07, 0x97, 0xFC, 0x35, 0x28, + 0xC8, 0x96, 0x31, 0x4B, 0xF9, 0xDB, 0x81, 0x59, + 0x96, 0x68, 0x5A, 0x10, 0x46, 0x3F, 0x4B, 0x62 + }, + { + 0xE2, 0x00, 0x8C, 0x62, 0x7C, 0x1E, 0xD5, 0x43, + 0xD9, 0x1A, 0xA8, 0x47, 0xAB, 0xCB, 0x2A, 0x60, + 0xBB, 0xA4, 0x00, 0x2B, 0x81, 0xB8, 0xE3, 0xED, + 0xB8, 0x81, 0x3F, 0x32, 0x8C, 0x70, 0x6F, 0x56, + 0x41, 0x0B, 0x9D, 0x50, 0xA6, 0x8B, 0x33, 0x7B, + 0x30, 0xE5, 0xAF, 0x7C, 0xD3, 0x0C, 0x67, 0xC3, + 0x99, 0x23, 0x17, 0xF0, 0xF3, 0x54, 0xA9, 0x5B, + 0xDF, 0x56, 0xB2, 0x2C, 0xEB, 0x04, 0x0F, 0x60 + }, + { + 0xC5, 0x43, 0x13, 0x8F, 0x35, 0xC0, 0xCF, 0x58, + 0x52, 0x6F, 0x96, 0xC5, 0x43, 0x6E, 0x4B, 0x88, + 0x0D, 0x31, 0x8B, 0x44, 0x1E, 0x11, 0x61, 0xBC, + 0xC3, 0xDD, 0x91, 0x23, 0x6E, 0xDD, 0x55, 0x35, + 0xF1, 0xF3, 0x8E, 0xBA, 0xFA, 0x20, 0xEC, 0x48, + 0x1E, 0xA5, 0xCF, 0x3F, 0xD3, 0x85, 0x1C, 0x39, + 0x05, 0xDA, 0xAA, 0xA1, 0x60, 0x60, 0x07, 0x2D, + 0x80, 0x19, 0xB0, 0x9C, 0x9B, 0x69, 0x32, 0xFF + }, + { + 0xDE, 0x03, 0xA3, 0xA4, 0x61, 0x12, 0xD9, 0x4F, + 0x7F, 0x60, 0xE8, 0xC1, 0xF3, 0x6E, 0x3B, 0x46, + 0x5C, 0xF3, 0xD8, 0x8B, 0xA0, 0xA6, 0x37, 0xC9, + 0x32, 0x89, 0xE5, 0x70, 0x9D, 0x90, 0xF2, 0x20, + 0xD6, 0xF5, 0xB0, 0x19, 0xC6, 0x09, 0xD1, 0x58, + 0xE8, 0x92, 0xE5, 0x96, 0xF3, 0xDA, 0xA4, 0x8E, + 0x0B, 0x8D, 0x0A, 0x57, 0xCB, 0x79, 0x1B, 0xF7, + 0xC9, 0x59, 0x2E, 0x40, 0xE4, 0xBD, 0x75, 0x7D + }, + { + 0xAF, 0x40, 0xF0, 0x73, 0x24, 0x34, 0xE8, 0xC1, + 0x6C, 0x9E, 0xF9, 0xF6, 0x69, 0x63, 0x54, 0x99, + 0x43, 0x9A, 0x69, 0x69, 0x2A, 0x95, 0x90, 0x44, + 0x96, 0xCB, 0x46, 0x59, 0x43, 0x01, 0xA9, 0x14, + 0xD3, 0xA1, 0x05, 0x55, 0x4B, 0xAA, 0x69, 0x43, + 0xBC, 0xDA, 0x1B, 0x41, 0xC9, 0xD0, 0x19, 0x41, + 0xAA, 0x6D, 0xD0, 0x79, 0x48, 0x63, 0x37, 0x40, + 0xA1, 0xFB, 0x0F, 0x08, 0x4B, 0xDA, 0xAF, 0xB9 + }, + { + 0x0B, 0x07, 0x21, 0x66, 0x45, 0xD2, 0x17, 0x5F, + 0x0B, 0x5E, 0x41, 0x2B, 0x67, 0xA5, 0x34, 0x7E, + 0xD0, 0x61, 0xC3, 0x26, 0xB5, 0x5A, 0x5D, 0xDB, + 0x3E, 0x90, 0x8F, 0x49, 0x4D, 0x3C, 0xEA, 0x2F, + 0x40, 0x82, 0x22, 0xD0, 0x8A, 0x68, 0x57, 0x1F, + 0xEE, 0xCB, 0xF1, 0x7B, 0xED, 0xE6, 0x8A, 0x79, + 0xCD, 0x66, 0x96, 0x81, 0x61, 0x46, 0x8A, 0x88, + 0x18, 0xC6, 0xC0, 0x61, 0x53, 0xE0, 0xE9, 0x89 + }, + { + 0x7C, 0x54, 0x90, 0x14, 0xA1, 0xD9, 0x2E, 0x89, + 0x6E, 0x21, 0xA3, 0x39, 0xED, 0x77, 0xAC, 0x70, + 0x30, 0x5C, 0x26, 0x5E, 0x8D, 0x4A, 0x0A, 0xAE, + 0x06, 0x0E, 0x8A, 0x4F, 0xDF, 0x4B, 0x42, 0xF3, + 0xDA, 0x8D, 0x6F, 0x1C, 0x4C, 0xCF, 0x6C, 0x7E, + 0x34, 0x4E, 0x5E, 0xF8, 0x9B, 0xDE, 0x87, 0x9F, + 0x9B, 0xE6, 0x65, 0xD3, 0xE5, 0xB3, 0x0A, 0x06, + 0x66, 0x14, 0xD8, 0x78, 0xB5, 0xF2, 0x4A, 0xB7 + }, + { + 0xCD, 0xA8, 0x03, 0xAC, 0x24, 0xB6, 0xDE, 0x3E, + 0x95, 0x7C, 0x57, 0x56, 0x62, 0x69, 0x83, 0x05, + 0x46, 0x6A, 0xCA, 0xCF, 0xF2, 0xEE, 0x81, 0xC8, + 0xF4, 0xFB, 0x4D, 0xEC, 0xD1, 0xDF, 0xC2, 0x7C, + 0xD6, 0x12, 0xC7, 0x0C, 0x1B, 0x42, 0x0F, 0x7E, + 0x19, 0xA4, 0x02, 0x12, 0x9B, 0x5A, 0x27, 0x86, + 0x8A, 0x4F, 0xA8, 0xB7, 0x75, 0x57, 0xF5, 0xC0, + 0x8C, 0x1C, 0x26, 0xDF, 0xDA, 0x13, 0xCB, 0x27 + }, + { + 0x25, 0x65, 0x3F, 0xB0, 0x18, 0xA2, 0xD0, 0x08, + 0x19, 0xF7, 0x07, 0x4C, 0x5F, 0x66, 0xDC, 0x83, + 0x8C, 0xC3, 0xFC, 0xB8, 0xF0, 0x94, 0xC0, 0xBF, + 0x24, 0x9B, 0xBD, 0xA1, 0x27, 0x8F, 0x80, 0x7A, + 0x5C, 0xA8, 0x14, 0xDF, 0xD2, 0xAF, 0x45, 0xE7, + 0x69, 0xDB, 0xEA, 0x60, 0x8E, 0x85, 0xDB, 0x85, + 0xDF, 0x62, 0xDF, 0x94, 0xC1, 0xAE, 0x69, 0xE4, + 0x8A, 0x92, 0x13, 0x57, 0xA2, 0x78, 0x20, 0xD3 + }, + { + 0x22, 0x9C, 0x18, 0x39, 0xA9, 0x24, 0x31, 0x1E, + 0x8E, 0x0F, 0x97, 0x28, 0xC3, 0xC9, 0x7A, 0xA4, + 0x4B, 0xF7, 0x54, 0x87, 0xF2, 0x24, 0xC0, 0xB7, + 0x35, 0x0B, 0x32, 0x8D, 0x2F, 0x7D, 0x25, 0x22, + 0xBD, 0xC9, 0x26, 0x8B, 0xEA, 0xA5, 0xBD, 0xD2, + 0x98, 0x12, 0x0D, 0x73, 0x13, 0xA3, 0x89, 0x59, + 0x9E, 0x08, 0x8D, 0x70, 0x0D, 0xFE, 0xA2, 0x21, + 0x13, 0x30, 0x70, 0xDE, 0xDA, 0x92, 0x53, 0xB0 + }, + { + 0xE1, 0x5B, 0x77, 0x26, 0xD5, 0xFE, 0xCF, 0x3B, + 0x95, 0x96, 0xBB, 0x82, 0xA8, 0xEA, 0xFB, 0xFA, + 0x8B, 0x0C, 0x7E, 0x92, 0xCA, 0x09, 0x6B, 0xFA, + 0x92, 0x16, 0x29, 0x22, 0xC4, 0xD5, 0xC8, 0x40, + 0x13, 0xB1, 0x4D, 0x30, 0x32, 0x96, 0x05, 0x18, + 0xA4, 0xE0, 0x12, 0x2B, 0xF3, 0xF0, 0xFF, 0xBD, + 0xBC, 0xC9, 0xDD, 0x8E, 0xA0, 0xDF, 0xFC, 0x5D, + 0x29, 0x09, 0x28, 0xA5, 0xC2, 0xEE, 0x6A, 0x96 + }, + { + 0x5C, 0x4C, 0xE9, 0x8F, 0xBA, 0x22, 0x52, 0x5A, + 0xF3, 0x6D, 0x4C, 0xBB, 0x31, 0x9B, 0x79, 0xF8, + 0xA8, 0x15, 0x77, 0x68, 0xF5, 0xB1, 0x9C, 0x1A, + 0xCA, 0x8E, 0x03, 0x7A, 0x65, 0x67, 0x2E, 0x50, + 0x3A, 0x78, 0x23, 0x92, 0x8E, 0xA5, 0x03, 0x74, + 0xE3, 0x26, 0xD2, 0x2A, 0xD4, 0x07, 0x30, 0x91, + 0x8C, 0x6B, 0x71, 0xF2, 0xF9, 0xF7, 0xCA, 0x34, + 0xD4, 0x78, 0x44, 0x68, 0xD3, 0xA6, 0xCA, 0x6F + }, + { + 0xEC, 0xBC, 0x21, 0x84, 0x56, 0xCE, 0xED, 0x2A, + 0x19, 0x17, 0xFF, 0xB6, 0xC1, 0x37, 0xDB, 0x19, + 0x87, 0xDD, 0x4C, 0xD7, 0xB2, 0x10, 0xA9, 0xA2, + 0xC6, 0x33, 0xA9, 0x79, 0x64, 0xEA, 0x08, 0x0B, + 0x8F, 0xE0, 0x0D, 0x7A, 0x87, 0x72, 0x40, 0xB6, + 0xFD, 0xB9, 0x86, 0x2E, 0x95, 0x8C, 0x73, 0x14, + 0x7D, 0x6A, 0x38, 0xA8, 0x0D, 0x7C, 0x45, 0x52, + 0x31, 0x97, 0x4B, 0x43, 0x00, 0xEA, 0x7C, 0xC6 + }, + { + 0x17, 0xF6, 0xF9, 0x28, 0x92, 0x47, 0x88, 0xE6, + 0x87, 0xDF, 0x1A, 0x0A, 0x09, 0xB7, 0xF6, 0xA2, + 0xEF, 0xB4, 0xC4, 0xA0, 0xEC, 0xEF, 0x9F, 0x6C, + 0x91, 0x18, 0xAC, 0x16, 0xF7, 0x7F, 0x84, 0x20, + 0xCB, 0xDC, 0xBD, 0x90, 0x36, 0xBD, 0xC5, 0x57, + 0x20, 0xBC, 0x0C, 0xD6, 0x6E, 0xDF, 0x08, 0xE6, + 0xBF, 0xB5, 0x7B, 0x5B, 0x58, 0x0E, 0xEA, 0xA9, + 0xA8, 0x08, 0xC1, 0x54, 0x3A, 0x06, 0x70, 0xA0 + }, + { + 0x5E, 0x46, 0x85, 0x1E, 0x17, 0x03, 0xC4, 0xD7, + 0x84, 0xE4, 0x22, 0xAB, 0xBA, 0x35, 0xB1, 0x9F, + 0xB9, 0xD3, 0x33, 0xE8, 0xC4, 0x6B, 0x6E, 0xA2, + 0xFD, 0xE7, 0x95, 0x46, 0x75, 0xEA, 0xD0, 0x74, + 0xF0, 0xCD, 0x78, 0x2B, 0x11, 0x59, 0x6D, 0x80, + 0xE8, 0x49, 0xF7, 0xA0, 0x51, 0xF5, 0x64, 0x84, + 0x8B, 0x80, 0x43, 0x3B, 0xED, 0x7B, 0xF9, 0xB5, + 0x80, 0x0C, 0x6F, 0x8F, 0x5A, 0x2C, 0xF9, 0x38 + }, + { + 0xDD, 0xAF, 0xC6, 0xF1, 0x11, 0x4D, 0x71, 0xE9, + 0xB3, 0xAC, 0x2A, 0x61, 0xE0, 0x48, 0xAE, 0x5E, + 0xDF, 0x9B, 0x35, 0x43, 0x5F, 0xD3, 0x94, 0x08, + 0x54, 0x39, 0x83, 0x65, 0xD0, 0xAE, 0x96, 0x61, + 0x4D, 0x6F, 0xA5, 0x39, 0x98, 0xE8, 0x25, 0x9A, + 0x7E, 0x44, 0x06, 0x17, 0x23, 0xB5, 0x44, 0x22, + 0xB2, 0xC9, 0x21, 0x75, 0x53, 0x9D, 0xA4, 0xD2, + 0xFF, 0x59, 0x12, 0xB2, 0xA2, 0xA2, 0x99, 0x93 + }, + { + 0x54, 0x82, 0x1A, 0x23, 0x06, 0xA1, 0x46, 0x7F, + 0x4A, 0x67, 0xAE, 0x63, 0x9E, 0xE9, 0xAB, 0xB7, + 0x4C, 0x3C, 0xCA, 0xDF, 0x0C, 0xAA, 0xB6, 0x49, + 0x09, 0x37, 0x50, 0xA9, 0x56, 0x17, 0x99, 0x37, + 0xC9, 0xE6, 0xAA, 0xA8, 0xE2, 0x51, 0x94, 0x1E, + 0x8B, 0x83, 0x57, 0xF3, 0x79, 0xBF, 0xE6, 0x3C, + 0x84, 0x07, 0xAC, 0xC2, 0xFC, 0x89, 0x86, 0xD6, + 0x43, 0xFF, 0xE0, 0x61, 0x70, 0x83, 0x40, 0xB5 + }, + { + 0xAE, 0x42, 0xBA, 0xFD, 0x95, 0x8B, 0x9F, 0xF1, + 0x08, 0x31, 0x0F, 0xAC, 0x29, 0x94, 0xD0, 0x12, + 0x4B, 0xFA, 0x56, 0x12, 0xC8, 0x63, 0x54, 0x05, + 0x2C, 0x73, 0x48, 0x28, 0x7C, 0x26, 0x9C, 0x19, + 0xF6, 0x2A, 0x1A, 0xB4, 0xD2, 0xB9, 0x41, 0x2B, + 0x57, 0xE8, 0xD5, 0x46, 0x3F, 0x35, 0x0E, 0x05, + 0x67, 0x55, 0x13, 0xCA, 0xD1, 0x59, 0x19, 0xF5, + 0xF2, 0x3B, 0x78, 0xF1, 0x66, 0x77, 0x88, 0xB0 + }, + { + 0x70, 0x2C, 0xBE, 0xFA, 0x37, 0x35, 0x41, 0x82, + 0x0D, 0x5B, 0x98, 0xA5, 0x43, 0xBA, 0xD0, 0x38, + 0xBD, 0xC4, 0xC2, 0xBE, 0xCD, 0xCE, 0xF6, 0x50, + 0x7F, 0xD8, 0x44, 0x33, 0xC6, 0x03, 0x36, 0x99, + 0xB6, 0xF2, 0x98, 0xC8, 0x02, 0x0E, 0xB4, 0x4F, + 0x12, 0x27, 0xB1, 0xC0, 0x29, 0xAC, 0xE3, 0xFA, + 0xE5, 0x77, 0xE5, 0x40, 0x0C, 0xD5, 0x44, 0xCF, + 0xA0, 0x6C, 0x35, 0x33, 0xEC, 0xD5, 0x8F, 0xFF + }, + { + 0x68, 0xF4, 0xF1, 0xB8, 0xE9, 0x08, 0x88, 0x37, + 0x75, 0x78, 0x92, 0xC0, 0x07, 0x38, 0x48, 0xD3, + 0x5F, 0xAC, 0xB2, 0x90, 0xD5, 0xE4, 0xA8, 0xD9, + 0x1B, 0x30, 0x99, 0xC1, 0xC9, 0xC4, 0xC1, 0xD6, + 0x33, 0x3E, 0x94, 0x1D, 0x6A, 0x57, 0x62, 0x57, + 0x06, 0x9D, 0xC8, 0x03, 0x86, 0xBE, 0x51, 0xF8, + 0x3F, 0x5F, 0xC6, 0x7E, 0x4F, 0xAE, 0xF5, 0xED, + 0x3F, 0x0E, 0xC5, 0xA1, 0x99, 0x70, 0x2A, 0xFF + }, + { + 0xCF, 0x86, 0xB5, 0xB1, 0xF8, 0x08, 0xBB, 0x95, + 0x7C, 0xF8, 0x56, 0xD4, 0x52, 0xC2, 0x6C, 0x2A, + 0xED, 0xFE, 0xAC, 0x76, 0xC4, 0x2A, 0x64, 0x59, + 0x34, 0xF1, 0xD4, 0x03, 0xA1, 0x64, 0x6F, 0xF5, + 0x81, 0xCD, 0x23, 0x82, 0x58, 0x4E, 0x86, 0x9A, + 0xB1, 0x4D, 0xB7, 0x2D, 0x05, 0x92, 0x75, 0x26, + 0xAD, 0xD2, 0xDF, 0xED, 0x8C, 0x5F, 0xF7, 0xB9, + 0x35, 0x98, 0x01, 0x28, 0xD5, 0x2A, 0x13, 0x5D + }, + { + 0x75, 0xF3, 0x14, 0xDD, 0xC2, 0x72, 0x43, 0xCD, + 0x28, 0xB2, 0x33, 0xE8, 0x93, 0x80, 0xF6, 0xBB, + 0xA6, 0x74, 0x95, 0xBB, 0x8B, 0xAB, 0xB9, 0x41, + 0x4E, 0xBE, 0xF5, 0x73, 0xC9, 0x07, 0xCA, 0xAD, + 0x08, 0x9D, 0x7E, 0xC6, 0x35, 0xCE, 0x1D, 0x96, + 0x66, 0x41, 0x56, 0xB4, 0x4F, 0x1A, 0x93, 0x3E, + 0x20, 0x14, 0x88, 0x96, 0x39, 0x2D, 0x70, 0x5C, + 0xA8, 0xAA, 0x62, 0x85, 0xD2, 0x15, 0x7E, 0x7B + }, + { + 0x11, 0x6D, 0x50, 0x39, 0xC9, 0xC4, 0x09, 0xE6, + 0x75, 0xD1, 0xF2, 0x7C, 0xEF, 0x39, 0x9E, 0xD8, + 0xC5, 0x79, 0x53, 0x9D, 0x86, 0x2C, 0x52, 0xE4, + 0x47, 0x69, 0x31, 0x78, 0x94, 0x3B, 0xCC, 0xE4, + 0x71, 0x94, 0x67, 0xA1, 0x83, 0x38, 0xF8, 0xA2, + 0x9D, 0xD3, 0xBA, 0xD3, 0xE2, 0x5D, 0x87, 0xD2, + 0x5B, 0x1D, 0x8C, 0x6A, 0x6B, 0x6A, 0xA2, 0x20, + 0xDD, 0x7B, 0x3D, 0x6E, 0xC1, 0xC7, 0x80, 0x6E + }, + { + 0x3E, 0xD7, 0x4F, 0x43, 0x04, 0xF8, 0x69, 0xDE, + 0x43, 0xA4, 0xCA, 0xF5, 0x3D, 0xC0, 0xD5, 0x0F, + 0x81, 0xFA, 0xBE, 0x94, 0x09, 0xE8, 0xEC, 0xFF, + 0xF2, 0xDC, 0x27, 0x77, 0x7F, 0x2B, 0x75, 0x41, + 0x07, 0x5A, 0x76, 0x42, 0x0F, 0x6C, 0x7D, 0x47, + 0x20, 0x2E, 0xFC, 0x25, 0x98, 0x79, 0xDA, 0xDE, + 0xEC, 0x9C, 0xCA, 0x89, 0x14, 0x10, 0x60, 0x9D, + 0x6A, 0x4B, 0x72, 0x89, 0x5F, 0x11, 0xFA, 0x4B + }, + { + 0x48, 0xC7, 0xF2, 0x2C, 0x71, 0x66, 0x33, 0xD5, + 0x0D, 0x85, 0xA2, 0x22, 0xA8, 0x5B, 0x58, 0x97, + 0xB1, 0xCF, 0x64, 0xD5, 0x85, 0x5D, 0xA4, 0xDD, + 0x47, 0x65, 0xF1, 0xBE, 0xA8, 0x59, 0x16, 0x4B, + 0xCD, 0x20, 0x2F, 0x05, 0xE6, 0xF9, 0x71, 0x7E, + 0xAB, 0xFF, 0x5E, 0x09, 0xD2, 0x11, 0x05, 0xEF, + 0xE1, 0x9B, 0x27, 0x82, 0x9F, 0x37, 0xA0, 0x14, + 0xBD, 0xC1, 0x4B, 0xB2, 0xCF, 0x8F, 0x71, 0xD1 + }, + { + 0x39, 0x33, 0xB7, 0xF2, 0x93, 0xDD, 0x0F, 0x0E, + 0x0C, 0x6B, 0x9D, 0x7D, 0xB0, 0x5D, 0x89, 0xA7, + 0xF2, 0xAA, 0x4E, 0x85, 0x56, 0x43, 0x9E, 0x47, + 0xAA, 0xC3, 0x49, 0xDA, 0xF2, 0x35, 0xDA, 0x32, + 0x3B, 0xA6, 0x78, 0xBF, 0x59, 0x9E, 0x94, 0xA5, + 0x02, 0xF0, 0xA4, 0x95, 0x84, 0xDA, 0x15, 0x54, + 0xC3, 0x0F, 0xA1, 0x22, 0x3A, 0xEF, 0x71, 0xBE, + 0x3F, 0x5E, 0x1B, 0xB9, 0xE2, 0xF9, 0x0A, 0x99 + }, + { + 0x6E, 0x81, 0xF8, 0x07, 0xAB, 0x0E, 0x79, 0x3D, + 0x37, 0x5F, 0xEF, 0x2C, 0x8F, 0xBB, 0x98, 0x49, + 0x01, 0x0E, 0x22, 0x03, 0xAD, 0xD3, 0xEA, 0x7F, + 0x00, 0xC2, 0x2D, 0x1B, 0xD8, 0xF0, 0xB6, 0x17, + 0x03, 0x11, 0xD5, 0xD5, 0x93, 0x37, 0xB8, 0x4D, + 0xBD, 0x4A, 0xA6, 0x7A, 0x4C, 0x85, 0xEA, 0xC8, + 0x24, 0x30, 0x02, 0x3B, 0x27, 0x56, 0xC9, 0xB4, + 0x56, 0x27, 0x58, 0x20, 0x01, 0x50, 0x7F, 0x92 + }, + { + 0xBF, 0x4A, 0x8A, 0xCA, 0x03, 0xAB, 0xBD, 0xFB, + 0xE4, 0xB5, 0xC4, 0xB5, 0x78, 0xF9, 0xA7, 0x2D, + 0x8C, 0x2A, 0xF1, 0xFC, 0x92, 0x8E, 0x60, 0xED, + 0xF4, 0xD9, 0xFE, 0xF8, 0xBD, 0x1B, 0x08, 0x81, + 0x2B, 0x28, 0x48, 0x6E, 0x6E, 0x0A, 0xC1, 0x10, + 0x21, 0x0C, 0x56, 0x10, 0xA6, 0x5B, 0x6E, 0xF5, + 0x1E, 0xB4, 0x20, 0x1D, 0x84, 0xC4, 0x09, 0x54, + 0x8B, 0x00, 0xD1, 0xA0, 0x1D, 0xD5, 0xCE, 0x30 + }, + { + 0x83, 0x14, 0xDB, 0x16, 0x98, 0xB7, 0x69, 0x0C, + 0x0C, 0xD1, 0x7A, 0xFF, 0x03, 0xFA, 0x5E, 0x95, + 0xC5, 0xE1, 0x82, 0x6E, 0x52, 0xD1, 0x41, 0x09, + 0xF4, 0x43, 0xA2, 0xE3, 0x0C, 0x67, 0xDA, 0x06, + 0x27, 0xB7, 0x04, 0x18, 0xFB, 0x24, 0xE3, 0x7A, + 0x30, 0xBD, 0x64, 0xAD, 0x5A, 0x38, 0x4E, 0x5F, + 0x94, 0x37, 0x58, 0xCF, 0x2C, 0x5B, 0xFA, 0x90, + 0x9F, 0xA8, 0x06, 0xC7, 0xBA, 0xE2, 0xDE, 0xA7 + }, + { + 0x8D, 0x17, 0x18, 0x33, 0xCF, 0xBA, 0x82, 0x78, + 0x52, 0x90, 0x7E, 0xAB, 0x91, 0x49, 0x2E, 0x77, + 0x9F, 0xC9, 0x98, 0x79, 0x69, 0x17, 0xDF, 0xC8, + 0xBD, 0x89, 0x91, 0x0A, 0x8F, 0x28, 0x5A, 0x2A, + 0xEA, 0x66, 0x47, 0xEA, 0x2C, 0x7F, 0xD7, 0x6F, + 0xDE, 0xC1, 0x17, 0x7D, 0xFD, 0x98, 0x7F, 0x30, + 0x13, 0x26, 0xB5, 0x31, 0x1A, 0x41, 0x7D, 0xA3, + 0xA2, 0x62, 0xAC, 0xFC, 0x1C, 0x43, 0xF3, 0xCC + }, + { + 0xB3, 0x84, 0x58, 0xA4, 0xD8, 0x54, 0x81, 0x7D, + 0x4B, 0x9C, 0x07, 0xEB, 0xB5, 0xFB, 0xFF, 0x5A, + 0x03, 0xC9, 0xC6, 0xE1, 0xDC, 0x16, 0x39, 0x1C, + 0x8C, 0x65, 0x81, 0x7A, 0xC0, 0xA1, 0x5B, 0xF4, + 0x6E, 0x24, 0x32, 0xB2, 0xB7, 0x29, 0x6F, 0x0F, + 0x34, 0xA2, 0x4C, 0x17, 0xD1, 0xE0, 0xDA, 0xD9, + 0xA4, 0x14, 0xAB, 0xB4, 0x26, 0xD4, 0xCD, 0xBA, + 0xAE, 0xFE, 0x8B, 0xCD, 0x45, 0x68, 0xA7, 0x5E + }, + { + 0xD4, 0xFE, 0x44, 0x51, 0x67, 0xE3, 0x44, 0x88, + 0xA7, 0xF3, 0x78, 0x05, 0x2C, 0x5E, 0x32, 0xDB, + 0x62, 0xD4, 0x28, 0x6A, 0x0E, 0xC4, 0xE8, 0x06, + 0xAD, 0x41, 0x7A, 0x11, 0xB3, 0xF6, 0xAC, 0xF7, + 0x17, 0x17, 0x7A, 0x2B, 0xE5, 0x4B, 0x77, 0xA4, + 0x90, 0xDC, 0x17, 0x71, 0x16, 0x60, 0x2B, 0xA9, + 0xDB, 0x9B, 0x8F, 0xD1, 0x89, 0xE2, 0x70, 0x3F, + 0x91, 0x27, 0x40, 0x97, 0x03, 0x04, 0x22, 0x0E + }, + { + 0x33, 0x6B, 0x93, 0x76, 0xE8, 0xF4, 0xA9, 0x1B, + 0x5F, 0xC0, 0xB9, 0x02, 0x2B, 0xAE, 0x5E, 0x80, + 0x7C, 0x6B, 0xD5, 0xBE, 0x86, 0x13, 0xCD, 0xD9, + 0x7E, 0xC6, 0xA0, 0x90, 0x0A, 0x12, 0xE5, 0xEB, + 0x21, 0x34, 0x34, 0xFE, 0x2B, 0x06, 0x11, 0x8C, + 0xA5, 0x48, 0x3B, 0xE6, 0xCE, 0x93, 0x45, 0x0F, + 0x40, 0x03, 0x37, 0x9C, 0x13, 0xBF, 0xEC, 0xD1, + 0x22, 0x2D, 0xD0, 0x21, 0x60, 0x30, 0xAD, 0xAD + }, + { + 0x7B, 0x8D, 0xD2, 0x1F, 0xAA, 0x52, 0xBB, 0xDD, + 0x1A, 0x5F, 0x6D, 0x5E, 0xB2, 0x41, 0xD8, 0xB5, + 0xE1, 0x98, 0x08, 0xF9, 0x7A, 0xA7, 0xA0, 0x1B, + 0xEE, 0x62, 0x1C, 0x0D, 0x62, 0x41, 0xB4, 0xE9, + 0x20, 0xAB, 0x92, 0x0E, 0x57, 0xDE, 0xAE, 0xBE, + 0x14, 0xD3, 0xD4, 0xCF, 0x88, 0x3A, 0xD8, 0x87, + 0x0A, 0xD1, 0x32, 0xA6, 0x00, 0x31, 0x77, 0x7C, + 0xEF, 0x97, 0xED, 0xCA, 0x16, 0xEE, 0xD0, 0xD2 + }, + { + 0x81, 0x77, 0x25, 0x17, 0xBC, 0xC1, 0xA6, 0x6B, + 0x68, 0xEA, 0x7A, 0x38, 0xB3, 0x9A, 0xD6, 0x6C, + 0x38, 0xC9, 0x0C, 0x01, 0x43, 0x8D, 0xB6, 0xF9, + 0x95, 0xFF, 0xEC, 0x9B, 0xED, 0x24, 0x72, 0x7F, + 0xF1, 0x37, 0xC6, 0xA1, 0xB4, 0x92, 0xAA, 0x08, + 0x48, 0xF5, 0xD6, 0x97, 0x91, 0xCF, 0xE2, 0xAB, + 0x0B, 0xEC, 0x86, 0xA8, 0xB0, 0x44, 0xEC, 0x64, + 0xB1, 0xDA, 0xAA, 0x9C, 0x12, 0x16, 0xAB, 0x7C + }, + { + 0x48, 0x7E, 0x41, 0x4A, 0x0F, 0xC8, 0xBC, 0xB7, + 0x79, 0xC5, 0x91, 0xC5, 0x26, 0x1F, 0xA5, 0x0A, + 0xC2, 0x65, 0x23, 0x42, 0xA5, 0xDB, 0xDE, 0x5E, + 0x0D, 0x9E, 0xA4, 0xEB, 0xF3, 0xF9, 0x68, 0x07, + 0x3F, 0x90, 0x61, 0xA1, 0xA0, 0x46, 0x83, 0x2E, + 0x29, 0x85, 0xFF, 0x0A, 0xEE, 0xDF, 0x1D, 0xD4, + 0x0D, 0x75, 0x80, 0xA2, 0xCF, 0x6A, 0x47, 0xE3, + 0x67, 0x10, 0x5F, 0x2D, 0x0C, 0x63, 0xA9, 0xD6 + }, + { + 0x9B, 0x90, 0x4F, 0x2A, 0xE2, 0x36, 0x25, 0x0E, + 0x87, 0x1C, 0x2B, 0xBB, 0x02, 0x58, 0xA0, 0x61, + 0x04, 0x0A, 0x11, 0x2B, 0x40, 0x20, 0x63, 0x2D, + 0xCF, 0xCD, 0xEC, 0xE0, 0xD3, 0x20, 0x7F, 0xA3, + 0x73, 0xE1, 0x4D, 0xD3, 0x41, 0x50, 0x16, 0x89, + 0x87, 0x50, 0x5B, 0x60, 0x02, 0x1B, 0x2C, 0x66, + 0xD8, 0x71, 0xF1, 0x49, 0xD8, 0x15, 0x40, 0xB9, + 0x82, 0x01, 0x77, 0x0B, 0xF5, 0xD4, 0x1C, 0x79 + }, + { + 0x31, 0x3E, 0x4E, 0x64, 0xF4, 0xDC, 0xA8, 0x14, + 0x91, 0x3E, 0xC7, 0x87, 0xF2, 0x48, 0xE5, 0x99, + 0x4F, 0xBB, 0x47, 0x85, 0xAF, 0x8C, 0x65, 0xBB, + 0xD7, 0x15, 0x65, 0xFE, 0x34, 0x42, 0x46, 0x19, + 0xB4, 0xB4, 0x84, 0xA2, 0xB3, 0x11, 0xAC, 0x0C, + 0x51, 0xCC, 0xCC, 0x44, 0xFE, 0x0E, 0x37, 0x7A, + 0x6E, 0x6E, 0x5A, 0x72, 0x8A, 0x3F, 0xB0, 0x2C, + 0x0B, 0x84, 0x8B, 0x2A, 0x9C, 0x7C, 0xA7, 0xDC + }, + { + 0x32, 0xC1, 0xFA, 0xCD, 0xAB, 0xD1, 0x8B, 0xEF, + 0xEE, 0x0F, 0x08, 0x00, 0x12, 0xA4, 0xA1, 0xBD, + 0xF0, 0x0B, 0x1B, 0x90, 0x31, 0xE0, 0x91, 0x07, + 0x2B, 0x95, 0x3D, 0xA4, 0xCD, 0x17, 0xC8, 0x18, + 0xD4, 0x63, 0x43, 0xFD, 0xD6, 0xD3, 0x62, 0x34, + 0x7E, 0x9A, 0xE7, 0x1E, 0xD8, 0x03, 0x34, 0x20, + 0x46, 0x8D, 0xD9, 0x42, 0xC4, 0x77, 0x5C, 0xB4, + 0x4D, 0x64, 0xA2, 0x92, 0xA9, 0x4D, 0xF1, 0xF6 + }, + { + 0x92, 0x6A, 0x1B, 0x1F, 0x06, 0xBE, 0x45, 0x21, + 0xCC, 0x8D, 0x18, 0xF5, 0x50, 0xC5, 0xDD, 0xA5, + 0x90, 0x8A, 0x78, 0x56, 0x6F, 0x57, 0xFA, 0x34, + 0x19, 0x0F, 0xB8, 0x32, 0x16, 0x8E, 0x78, 0x1F, + 0x8E, 0x4D, 0x1E, 0x7B, 0x03, 0x51, 0xFD, 0xCA, + 0xB9, 0x2F, 0x4C, 0xF3, 0xA3, 0x4B, 0x05, 0x86, + 0x49, 0xD1, 0xF0, 0x76, 0xF8, 0x0B, 0x17, 0xF4, + 0x96, 0xA2, 0xCF, 0x9F, 0x7E, 0xAB, 0x34, 0x8F + }, + { + 0xC3, 0x74, 0x6A, 0x65, 0xB1, 0x76, 0xCF, 0x68, + 0x87, 0x63, 0x3A, 0x81, 0x9E, 0xE5, 0x51, 0x77, + 0xA3, 0xA1, 0x9E, 0x61, 0x2D, 0x82, 0xE5, 0xE5, + 0x1E, 0xCB, 0x4C, 0x7A, 0x8E, 0x6A, 0x80, 0x5A, + 0x6B, 0x13, 0x9B, 0x87, 0x84, 0xEC, 0x97, 0x02, + 0xBF, 0xE5, 0x0E, 0x4E, 0xD0, 0x42, 0x4A, 0xE0, + 0x61, 0x94, 0xBD, 0x09, 0x94, 0xFA, 0x86, 0x76, + 0x79, 0xD7, 0xB2, 0xEF, 0x42, 0xD3, 0x27, 0x4A + }, + { + 0xAC, 0x8D, 0x5B, 0x38, 0xA3, 0x7A, 0x08, 0x99, + 0x1C, 0x4C, 0x0A, 0x80, 0x93, 0x47, 0xA7, 0x7E, + 0xB0, 0x38, 0xE4, 0xAB, 0xA5, 0x18, 0xCE, 0x97, + 0xE7, 0x94, 0x17, 0xE6, 0xCA, 0x7F, 0xD5, 0xB3, + 0x6F, 0x5B, 0xED, 0xF6, 0x02, 0x30, 0xBC, 0x03, + 0x6A, 0x5D, 0xBE, 0x89, 0x2F, 0xE2, 0x07, 0x51, + 0x82, 0x79, 0x07, 0xBA, 0x56, 0x62, 0xAF, 0xC6, + 0xB7, 0xB1, 0x7A, 0x38, 0xF1, 0xDC, 0x18, 0xEC + }, + { + 0x73, 0x06, 0x6A, 0x68, 0xA9, 0x5E, 0x1F, 0x41, + 0x67, 0xAE, 0xDC, 0xA1, 0xC0, 0x4E, 0x36, 0xB7, + 0xBD, 0x24, 0xBF, 0x62, 0x1C, 0xB5, 0xC9, 0xBE, + 0x6F, 0x63, 0xD3, 0x9E, 0x4E, 0xCD, 0x8C, 0xF3, + 0x30, 0x16, 0x92, 0xEF, 0xCF, 0x74, 0x04, 0x08, + 0x18, 0x80, 0x3F, 0xBA, 0x9E, 0x8D, 0xE3, 0x66, + 0xCA, 0x5F, 0xC8, 0xF0, 0xB2, 0x84, 0x75, 0x48, + 0x31, 0x66, 0xC6, 0xB1, 0x28, 0x6C, 0x74, 0x9A + }, + { + 0x74, 0xE5, 0x97, 0x3A, 0xFC, 0xCF, 0x97, 0x68, + 0xE6, 0xB3, 0xB9, 0xB3, 0x9F, 0xEF, 0x6E, 0xC3, + 0xFA, 0xA8, 0x43, 0x3E, 0x3E, 0x1B, 0x64, 0xBF, + 0x51, 0x13, 0x8A, 0x6A, 0x2C, 0x88, 0x9E, 0x22, + 0xF4, 0x04, 0x17, 0x88, 0x67, 0x7A, 0xB0, 0x27, + 0x43, 0xC9, 0xC5, 0x85, 0x5C, 0x80, 0x1F, 0xB9, + 0x5C, 0x2C, 0x1F, 0x4D, 0x18, 0x96, 0xF7, 0xAD, + 0x23, 0x92, 0x71, 0xB6, 0xCD, 0x03, 0x6B, 0x3F + }, + { + 0x5F, 0x70, 0x9F, 0xEF, 0x9B, 0x38, 0x46, 0x3D, + 0x61, 0xE6, 0x82, 0x74, 0x0D, 0x14, 0x3D, 0x5F, + 0x4E, 0xC1, 0xC8, 0x22, 0x32, 0x28, 0x44, 0x4F, + 0x28, 0xEC, 0xF5, 0x53, 0x07, 0xAE, 0xA1, 0xA4, + 0xD0, 0x45, 0xAC, 0xF9, 0x75, 0x61, 0x62, 0x79, + 0x97, 0x07, 0xE5, 0x10, 0x50, 0x08, 0x1C, 0x47, + 0x23, 0x7B, 0x83, 0xDE, 0xBF, 0x14, 0x92, 0x42, + 0x5A, 0x84, 0x24, 0x9A, 0xFE, 0x5A, 0xD2, 0x18 + }, + { + 0xE8, 0x2B, 0x16, 0x76, 0xFD, 0x5A, 0x4E, 0x11, + 0x98, 0x1E, 0x2A, 0x9B, 0xAC, 0x63, 0x61, 0xB4, + 0x4F, 0x13, 0xF6, 0x0F, 0xD0, 0xE8, 0xA8, 0x4C, + 0x70, 0x4A, 0xE5, 0x28, 0x2C, 0xC1, 0x96, 0x65, + 0x56, 0x9C, 0xA7, 0x88, 0x02, 0xFE, 0x45, 0x56, + 0xF4, 0x1A, 0x92, 0x89, 0x75, 0x45, 0xCA, 0x26, + 0x34, 0x85, 0x9E, 0xDA, 0xAC, 0xF4, 0x68, 0x97, + 0x77, 0x06, 0x59, 0xAD, 0x29, 0x29, 0x1E, 0xF6 + }, + { + 0x81, 0x7D, 0x97, 0xC7, 0xE8, 0x02, 0x5E, 0xBF, + 0xD0, 0x92, 0xFF, 0x02, 0xFE, 0x90, 0xB8, 0x4C, + 0xBC, 0x2C, 0x08, 0xB8, 0xB8, 0x34, 0xF4, 0xA4, + 0xC0, 0xE0, 0x27, 0xEA, 0x86, 0x72, 0x1D, 0x5C, + 0x4E, 0x38, 0xBD, 0xD6, 0x61, 0x37, 0x7A, 0x33, + 0x41, 0x45, 0x51, 0xAF, 0xFB, 0x2A, 0x21, 0x86, + 0xCF, 0xF5, 0xFD, 0xA6, 0x17, 0xB9, 0x51, 0xA9, + 0x7D, 0x2E, 0x59, 0x95, 0x93, 0xEF, 0x9C, 0x38 + }, + { + 0x26, 0x22, 0xF6, 0xF7, 0xBF, 0x16, 0x35, 0xBC, + 0x5D, 0xE1, 0x98, 0x84, 0x62, 0x38, 0x72, 0x64, + 0xC0, 0x11, 0x43, 0x8A, 0x6B, 0x75, 0xAA, 0xE7, + 0x6E, 0x58, 0x0C, 0x44, 0x75, 0x55, 0x79, 0x9D, + 0xD3, 0xCE, 0xCA, 0xBB, 0x39, 0x5C, 0xAA, 0x40, + 0x46, 0x91, 0x1C, 0x2E, 0x71, 0x35, 0x40, 0xE8, + 0x84, 0xCA, 0x50, 0x41, 0xF9, 0xAB, 0x97, 0xCF, + 0xB4, 0xF4, 0xA4, 0x5A, 0x28, 0x83, 0x33, 0x8A + }, + { + 0xA9, 0x61, 0x21, 0x35, 0x7C, 0xF9, 0xB0, 0x52, + 0x83, 0xB7, 0x07, 0x1D, 0x53, 0xAC, 0x9A, 0x28, + 0x6B, 0xEC, 0x1D, 0xC1, 0x27, 0xF1, 0x6F, 0x5A, + 0x88, 0x5F, 0x77, 0x5B, 0x2D, 0x52, 0x7D, 0x07, + 0xF0, 0xA1, 0x9E, 0xB4, 0x5A, 0x7E, 0x71, 0xE3, + 0xFD, 0x0E, 0x70, 0x15, 0x5E, 0xED, 0x02, 0x87, + 0x7C, 0xB9, 0x01, 0xAB, 0x2C, 0xA5, 0x6A, 0x15, + 0xBE, 0x43, 0x47, 0x69, 0x05, 0xB7, 0x6F, 0x2E + }, + { + 0x39, 0x18, 0x44, 0x7F, 0x2B, 0x92, 0x72, 0x38, + 0x3F, 0x3E, 0x6B, 0x27, 0x44, 0x45, 0x2B, 0x3A, + 0x3C, 0xBA, 0xA0, 0xE6, 0x7D, 0x7E, 0xC5, 0xBF, + 0xE9, 0x74, 0x96, 0xB8, 0xAD, 0xE1, 0x7A, 0x96, + 0xDF, 0x58, 0xE1, 0x2E, 0xDF, 0x46, 0x95, 0x79, + 0xBD, 0x9C, 0x5C, 0xBB, 0x5B, 0xAD, 0xF4, 0x15, + 0x4F, 0x0A, 0xA5, 0x07, 0xDB, 0xBA, 0x17, 0xE7, + 0x98, 0xE2, 0x4A, 0xC6, 0x66, 0xE6, 0xC9, 0x03 + }, + { + 0x28, 0xD7, 0xA1, 0x82, 0xFA, 0xAD, 0x0F, 0xF7, + 0xFB, 0x3E, 0x81, 0x8C, 0xC2, 0x94, 0xA4, 0xB0, + 0x6D, 0x9F, 0x88, 0x2B, 0xB6, 0x51, 0x82, 0x40, + 0xA0, 0x2A, 0x4F, 0x2A, 0x0F, 0xBA, 0x82, 0xD2, + 0x54, 0x6D, 0xAF, 0x23, 0xF7, 0x44, 0x6B, 0x06, + 0x33, 0x4D, 0x04, 0xFF, 0xD3, 0xCB, 0xB8, 0xB8, + 0x32, 0xD8, 0x49, 0xB1, 0x04, 0xAC, 0x77, 0xF4, + 0x04, 0x03, 0x17, 0x4E, 0xBE, 0x96, 0x50, 0xB2 + }, + { + 0xA3, 0x56, 0x13, 0x50, 0x31, 0x04, 0xF7, 0x4C, + 0xE2, 0x37, 0x3C, 0xE4, 0xDE, 0x66, 0xFB, 0xC3, + 0xEA, 0x45, 0x03, 0x0B, 0x7B, 0x4F, 0x5B, 0x89, + 0x91, 0x37, 0x60, 0x14, 0x92, 0x7D, 0xEA, 0x68, + 0x0C, 0x9F, 0xC4, 0x47, 0xDB, 0x0B, 0x84, 0x88, + 0x92, 0x94, 0xE1, 0x8C, 0x67, 0x41, 0xC5, 0xC0, + 0xB9, 0x37, 0xA3, 0xB8, 0x80, 0x86, 0x59, 0x55, + 0xC7, 0x2E, 0x64, 0x03, 0x44, 0x11, 0x2E, 0x6F + }, + { + 0xCF, 0xC0, 0xFB, 0xA0, 0x3E, 0x76, 0x9E, 0xEF, + 0x98, 0x93, 0x56, 0x83, 0x10, 0x86, 0x28, 0xE5, + 0x08, 0xEF, 0xE9, 0x4E, 0x8B, 0xA0, 0x5B, 0x73, + 0x09, 0xE0, 0x37, 0xDF, 0x28, 0x53, 0xBA, 0xAE, + 0x13, 0xE0, 0x46, 0x82, 0x37, 0xEB, 0x16, 0x6C, + 0xC5, 0x9F, 0x45, 0xBB, 0x92, 0x1F, 0x6E, 0x67, + 0xDF, 0x2B, 0x93, 0xB9, 0x14, 0x9B, 0x44, 0x78, + 0x2A, 0x0A, 0x72, 0xC0, 0xAC, 0xB1, 0x3C, 0xFF + }, + { + 0x24, 0xEA, 0xA7, 0x5A, 0xAC, 0x27, 0xC8, 0xD3, + 0x38, 0x54, 0x9B, 0xFA, 0xEF, 0x10, 0x5F, 0x80, + 0xE0, 0xD6, 0x69, 0x1B, 0x9A, 0xD1, 0xBE, 0x97, + 0x83, 0xB0, 0xD5, 0xD0, 0x33, 0xC4, 0x99, 0xB0, + 0xAF, 0xB9, 0x6B, 0x77, 0x45, 0x42, 0x04, 0x5B, + 0xF3, 0xE2, 0x2F, 0x21, 0xB5, 0x68, 0x36, 0x2E, + 0x6E, 0xF7, 0xB1, 0xD4, 0xEA, 0xF9, 0x77, 0x2D, + 0x76, 0x5D, 0x72, 0xB5, 0x33, 0xFC, 0xF0, 0xEB + }, + { + 0x3B, 0x27, 0xF8, 0x67, 0xD8, 0x0E, 0x9F, 0x7C, + 0x9F, 0x16, 0x24, 0x41, 0xB4, 0x31, 0x72, 0x57, + 0x87, 0xF6, 0x89, 0xE8, 0x0F, 0xE7, 0x61, 0xA3, + 0x93, 0x3D, 0x15, 0xA7, 0x70, 0x50, 0xE7, 0xB2, + 0xF1, 0x8C, 0x28, 0x91, 0x98, 0x32, 0xF2, 0xBA, + 0x43, 0xF1, 0x05, 0x1B, 0xE3, 0xAB, 0xFD, 0x69, + 0xD4, 0x6B, 0xBC, 0x3B, 0x67, 0x97, 0x1F, 0x9D, + 0xA5, 0x02, 0x5C, 0x88, 0x97, 0x6C, 0x87, 0xFF + }, + { + 0xAF, 0x5D, 0x64, 0x12, 0xE4, 0x2A, 0x58, 0x49, + 0x40, 0x9D, 0x1F, 0xD7, 0x9E, 0xA1, 0x0A, 0xED, + 0xAD, 0x2C, 0x53, 0xFE, 0x8F, 0x11, 0xA5, 0x31, + 0xE7, 0x9F, 0xD7, 0x2E, 0x43, 0xCD, 0x58, 0xF3, + 0x68, 0x2F, 0x35, 0xF9, 0x20, 0x5A, 0xD0, 0xE6, + 0x81, 0x2A, 0x59, 0x8E, 0x3B, 0x78, 0x01, 0x3C, + 0xE0, 0x44, 0xD4, 0xBF, 0x82, 0x6E, 0x8A, 0xC1, + 0x66, 0xDC, 0x44, 0x1C, 0xC4, 0x08, 0x65, 0x09 + }, + { + 0x3A, 0xE6, 0x47, 0x32, 0x92, 0x59, 0x6F, 0x88, + 0x28, 0xD3, 0xF9, 0x4D, 0x18, 0x97, 0xA7, 0x5F, + 0xB5, 0x32, 0x43, 0x15, 0x5A, 0x74, 0x45, 0xBA, + 0x43, 0xA1, 0x07, 0x0E, 0xF5, 0x2F, 0x15, 0xE5, + 0x62, 0x56, 0xFA, 0x00, 0x2F, 0xA6, 0x4F, 0x20, + 0x62, 0x75, 0xB1, 0xAF, 0x45, 0x83, 0xC3, 0x37, + 0xDB, 0xAA, 0xD0, 0x79, 0xAC, 0x0E, 0xBA, 0x32, + 0x13, 0x81, 0x8A, 0xEF, 0xED, 0xE2, 0x61, 0x9B + }, + { + 0xE4, 0xE0, 0xEC, 0x15, 0x53, 0xCF, 0x7A, 0xB8, + 0xF0, 0xF5, 0x45, 0xCB, 0xEE, 0xE8, 0xFC, 0x0C, + 0xB6, 0x86, 0x45, 0x2D, 0x8E, 0xB2, 0xFD, 0x0C, + 0x6E, 0xE7, 0x7A, 0x11, 0x77, 0x1C, 0xC5, 0x6E, + 0xBD, 0x90, 0x66, 0x65, 0x0D, 0xDC, 0x8A, 0x2C, + 0x1E, 0x13, 0x43, 0x9F, 0xC2, 0xB6, 0xB7, 0xF3, + 0x78, 0x18, 0xBD, 0xA2, 0xD1, 0xDE, 0x8E, 0x8C, + 0x13, 0x3C, 0x92, 0x5F, 0x7C, 0x35, 0x4B, 0x4A + }, + { + 0x3F, 0x20, 0xFF, 0xDA, 0x3D, 0x0D, 0x9D, 0xCB, + 0x4D, 0xEA, 0xFC, 0xA9, 0xE4, 0x74, 0x74, 0x40, + 0x50, 0x14, 0xEC, 0x14, 0x58, 0x4D, 0x92, 0x56, + 0xB7, 0xFF, 0xB0, 0xC8, 0x12, 0x36, 0x4B, 0xE7, + 0x82, 0x4D, 0xE5, 0xDC, 0xAA, 0x45, 0xE3, 0xE1, + 0x73, 0x1A, 0x86, 0xA7, 0x37, 0x8F, 0x45, 0x99, + 0x91, 0x47, 0x1E, 0xC1, 0xB1, 0xAC, 0xDF, 0x50, + 0xA8, 0xF4, 0x21, 0x8D, 0xF2, 0x37, 0x4C, 0xE5 + }, + { + 0x40, 0x45, 0xA3, 0x40, 0x68, 0xB2, 0x3D, 0xD1, + 0xD1, 0x82, 0x88, 0x75, 0xAE, 0xA1, 0x2B, 0x61, + 0xAD, 0x1F, 0x4E, 0x0D, 0x52, 0xAF, 0x8C, 0x35, + 0xF2, 0xF8, 0x15, 0x92, 0x0E, 0x81, 0x88, 0xBA, + 0xAD, 0xAE, 0x7A, 0x60, 0xF4, 0x54, 0x91, 0x2E, + 0x0E, 0x8A, 0x85, 0x69, 0x86, 0x4D, 0x47, 0x5C, + 0xED, 0x47, 0xAF, 0x89, 0xDE, 0xAF, 0x5A, 0x1B, + 0x6C, 0xF5, 0x04, 0x4F, 0x12, 0xA7, 0x7B, 0x25 + }, + { + 0xA7, 0x86, 0xE0, 0x17, 0x34, 0x67, 0x39, 0xEB, + 0xB5, 0x4E, 0x48, 0x82, 0x86, 0x8C, 0xDB, 0x72, + 0x63, 0x58, 0x64, 0x6D, 0x66, 0xB1, 0xDA, 0xA7, + 0x1A, 0xB1, 0xE1, 0x18, 0x26, 0xD3, 0x12, 0xB3, + 0xB4, 0x5B, 0xA6, 0xFA, 0x47, 0x50, 0xF7, 0xA0, + 0x3B, 0xCF, 0x0B, 0xDE, 0x1E, 0x77, 0x39, 0xD6, + 0x14, 0x10, 0x9A, 0x67, 0x51, 0x2B, 0xA7, 0x1F, + 0x70, 0x16, 0xA7, 0x8A, 0xA4, 0xF2, 0x58, 0x8A + }, + { + 0x49, 0xDF, 0x23, 0x1A, 0x45, 0xEF, 0x80, 0x69, + 0x7C, 0x08, 0x6C, 0xD4, 0x70, 0xE8, 0x29, 0x8C, + 0xEE, 0x0E, 0xBA, 0x4F, 0x46, 0x21, 0x4A, 0xA2, + 0xEC, 0x38, 0xF5, 0x3B, 0xAC, 0x52, 0x7F, 0x74, + 0xDF, 0x4F, 0xC5, 0x30, 0x92, 0xD1, 0xB1, 0x11, + 0x0E, 0x18, 0x7C, 0x82, 0xAC, 0x88, 0x93, 0x63, + 0xE0, 0x1C, 0xFF, 0xF0, 0x0B, 0x9B, 0x2F, 0xBC, + 0xA0, 0x1F, 0x04, 0x25, 0xC5, 0x78, 0x57, 0x7D + }, + { + 0x4F, 0x62, 0x52, 0xF7, 0x86, 0x29, 0x19, 0x15, + 0xE7, 0x43, 0x63, 0x94, 0x39, 0x45, 0x07, 0x37, + 0xAB, 0xFC, 0xE3, 0xAA, 0x13, 0xD7, 0x3C, 0x32, + 0xA3, 0x43, 0x8C, 0x6E, 0x91, 0xF4, 0xE4, 0xC3, + 0x9F, 0xD3, 0x43, 0x5A, 0x7A, 0x45, 0xA2, 0x54, + 0x31, 0x10, 0x70, 0x15, 0x25, 0xE5, 0x58, 0x7D, + 0xFB, 0x77, 0x16, 0x39, 0x74, 0x07, 0xEB, 0xDF, + 0xDA, 0xA6, 0x07, 0xE5, 0x4C, 0xF5, 0xBD, 0x30 + }, + { + 0xC6, 0x92, 0xF3, 0x98, 0x6D, 0x87, 0x0C, 0xA4, + 0x14, 0xD7, 0xF5, 0xB7, 0xC3, 0xF7, 0xBB, 0x15, + 0xDF, 0xAE, 0x63, 0x5B, 0x26, 0x36, 0xA5, 0xFC, + 0x42, 0x2D, 0xF3, 0x69, 0xEB, 0x76, 0x1F, 0xFC, + 0x71, 0x3E, 0xB3, 0x7F, 0xF8, 0xD3, 0xFD, 0x68, + 0x76, 0x17, 0x27, 0xF9, 0x96, 0x2F, 0xB0, 0x1A, + 0xA2, 0x42, 0xA4, 0x24, 0x6C, 0x86, 0xA3, 0x5D, + 0xA4, 0xED, 0x20, 0x68, 0x70, 0x02, 0x1A, 0x02 + }, + { + 0xCA, 0x80, 0x7A, 0x42, 0x7A, 0x5B, 0x2A, 0xA2, + 0x9A, 0x08, 0x8F, 0x26, 0xCA, 0x19, 0x71, 0x54, + 0xA5, 0x34, 0x5A, 0x07, 0x3A, 0x01, 0x8D, 0xEA, + 0x96, 0xB8, 0x99, 0x60, 0x76, 0xBF, 0x65, 0xAA, + 0xB3, 0xFF, 0xFD, 0xFB, 0x72, 0xB4, 0x80, 0xEC, + 0x6E, 0x7D, 0xF4, 0x20, 0x37, 0x1E, 0xF3, 0xD1, + 0xDC, 0x00, 0x5F, 0x66, 0x44, 0x2A, 0x63, 0x5E, + 0x8B, 0xA2, 0xEE, 0x22, 0xC1, 0x78, 0x82, 0xEA + }, + { + 0x43, 0xA2, 0xA8, 0x81, 0x5E, 0xB3, 0xBC, 0xBC, + 0xF2, 0xBB, 0x26, 0xEA, 0xB0, 0x5F, 0xE4, 0xF3, + 0x95, 0x35, 0xB4, 0x4B, 0x3F, 0xAF, 0x1F, 0x54, + 0x55, 0x38, 0xC5, 0xF1, 0x97, 0xDC, 0x79, 0x64, + 0x11, 0x98, 0xE3, 0xA7, 0x8F, 0x99, 0x49, 0x56, + 0x2E, 0x2A, 0x81, 0xE6, 0x3B, 0xF4, 0x36, 0xE5, + 0xC8, 0xD1, 0x0C, 0x86, 0x7F, 0x7E, 0x37, 0xE6, + 0x03, 0x57, 0x73, 0xBB, 0xEB, 0xD8, 0x0A, 0x19 + }, + { + 0x63, 0x39, 0x3D, 0x8E, 0x6C, 0x53, 0x22, 0x75, + 0x44, 0x46, 0xA1, 0x4C, 0xB8, 0x08, 0x13, 0x02, + 0x67, 0xB4, 0x97, 0x29, 0x13, 0xA1, 0xC9, 0x9C, + 0x75, 0xC6, 0x2C, 0x8E, 0xF0, 0xA4, 0x16, 0xEC, + 0xE2, 0x3C, 0xD7, 0x91, 0xC2, 0x5C, 0xCB, 0xF6, + 0xF6, 0x7B, 0x1C, 0x2F, 0x1B, 0x41, 0x74, 0xCA, + 0xD8, 0x87, 0xDF, 0x1E, 0xA1, 0xEA, 0x28, 0x3D, + 0x07, 0x50, 0x68, 0x24, 0x91, 0x28, 0xDD, 0xF0 + }, + { + 0x49, 0xFB, 0x50, 0x6B, 0x90, 0xBA, 0xC5, 0x3F, + 0x39, 0xEF, 0x19, 0xBD, 0x17, 0x32, 0xDD, 0xE1, + 0x25, 0xE8, 0x40, 0xEE, 0x39, 0x5E, 0xAB, 0xC8, + 0xA1, 0x8D, 0x47, 0x37, 0xD1, 0x3C, 0x07, 0xAC, + 0xBD, 0x40, 0x3E, 0xEF, 0x2B, 0x4B, 0x2D, 0xA6, + 0x15, 0x5D, 0x6A, 0xD0, 0x6A, 0xC9, 0xA0, 0x03, + 0x3B, 0xFA, 0xC0, 0xB0, 0x51, 0x10, 0x67, 0x83, + 0x97, 0x5C, 0xF9, 0x63, 0x56, 0x79, 0x11, 0x40 + }, + { + 0x06, 0x26, 0xB0, 0x3F, 0xA9, 0x4D, 0xA1, 0x6A, + 0x5D, 0xFE, 0x02, 0xBB, 0xF7, 0xB1, 0x44, 0x5B, + 0x22, 0x60, 0x5C, 0xEF, 0x75, 0x30, 0xE3, 0xB8, + 0xCF, 0x0F, 0xE3, 0x58, 0x06, 0x2E, 0xAA, 0x44, + 0xEE, 0x08, 0x4F, 0x87, 0x88, 0x16, 0xEE, 0xF3, + 0x4A, 0x97, 0xFF, 0x9C, 0xD3, 0x30, 0xF4, 0x44, + 0xC9, 0x04, 0xD4, 0xA2, 0x06, 0x42, 0x78, 0x13, + 0x79, 0xB8, 0xEA, 0xE0, 0xB7, 0x60, 0x00, 0x62 + }, + { + 0xDE, 0xE3, 0x03, 0x5D, 0xE5, 0x1A, 0x90, 0x44, + 0x35, 0x14, 0x20, 0x30, 0xBF, 0x14, 0x58, 0xE4, + 0x47, 0xC8, 0x51, 0xF5, 0x56, 0xF6, 0x47, 0x04, + 0x8D, 0x52, 0xAB, 0xE2, 0x3C, 0xD7, 0xC7, 0x92, + 0xA8, 0xA1, 0x30, 0x10, 0x53, 0xAB, 0xEA, 0x2E, + 0xA9, 0xEF, 0x9A, 0xBB, 0x1B, 0x79, 0x18, 0x29, + 0xD4, 0x43, 0x83, 0x6A, 0x71, 0x6E, 0x64, 0xDB, + 0x61, 0xF5, 0x58, 0x12, 0x3E, 0x24, 0xE1, 0xC7 + }, + { + 0x9A, 0x6C, 0x75, 0xA6, 0x51, 0x47, 0x7B, 0xE4, + 0xA2, 0xA9, 0xD6, 0x4F, 0x15, 0xD5, 0xDF, 0x68, + 0x01, 0x93, 0xBB, 0xD2, 0x47, 0x1D, 0x4E, 0x39, + 0x70, 0xF1, 0x9F, 0x6A, 0x9F, 0x8B, 0xD2, 0x0B, + 0x10, 0xF7, 0x38, 0x03, 0xC8, 0x1B, 0xAE, 0xB8, + 0x8B, 0x82, 0xB8, 0x80, 0x93, 0x4D, 0xE2, 0x82, + 0x35, 0x8F, 0x78, 0x45, 0x23, 0x35, 0x37, 0xD6, + 0x6F, 0xC0, 0xD0, 0xE0, 0xC9, 0xAB, 0xBD, 0x5A + }, + { + 0x0A, 0xFA, 0x08, 0x23, 0x5A, 0x8E, 0x06, 0x57, + 0xD8, 0x6D, 0xFE, 0x4E, 0xC5, 0x8A, 0xB2, 0x6C, + 0xB8, 0xEC, 0x85, 0x30, 0x6A, 0x54, 0xE6, 0xC4, + 0x7A, 0xD7, 0x98, 0xFC, 0x91, 0xEC, 0xA2, 0xC6, + 0x8B, 0x53, 0x14, 0xD5, 0x07, 0x5E, 0x4F, 0x06, + 0xBD, 0xD1, 0x7B, 0x24, 0xE5, 0xA3, 0x08, 0xA4, + 0xF0, 0x10, 0xD3, 0x3C, 0xAE, 0x43, 0x91, 0xE5, + 0x3C, 0x90, 0xF4, 0xAE, 0x85, 0xE2, 0x98, 0x60 + }, + { + 0x95, 0xB4, 0x9F, 0xBA, 0xF9, 0x85, 0xA3, 0x11, + 0x3A, 0xEB, 0x29, 0x1E, 0x90, 0x31, 0x16, 0xF4, + 0x6E, 0x2F, 0x27, 0xF9, 0x38, 0x1B, 0xDB, 0xAC, + 0x47, 0x64, 0xAB, 0xE0, 0xA9, 0xBA, 0x62, 0x6C, + 0x25, 0xBB, 0x6C, 0xF4, 0xAE, 0xB3, 0xBB, 0xB3, + 0x19, 0x19, 0x44, 0x61, 0x59, 0x06, 0x3C, 0xE1, + 0x3D, 0x03, 0xC9, 0xA4, 0x4D, 0xC6, 0x02, 0x3D, + 0x3D, 0xAD, 0x28, 0x27, 0x6F, 0xFA, 0x34, 0x27 + }, + { + 0xFC, 0x2A, 0x1A, 0xAD, 0x9F, 0x1E, 0x11, 0x50, + 0xE6, 0x39, 0xD2, 0x0F, 0x1B, 0x7D, 0x7D, 0x3E, + 0x12, 0x6D, 0x30, 0x9C, 0x86, 0x14, 0x3B, 0xBD, + 0x82, 0xAB, 0xCD, 0x5C, 0x82, 0xBE, 0x2F, 0xB8, + 0xA1, 0xBE, 0x39, 0x71, 0xCB, 0x9E, 0xF8, 0x6D, + 0x35, 0x4E, 0x50, 0x6C, 0x9E, 0x32, 0x67, 0xE2, + 0x97, 0xED, 0xB5, 0x92, 0x7E, 0x71, 0x2E, 0x23, + 0x54, 0x44, 0x5E, 0x11, 0x1B, 0x46, 0x31, 0xD8 + }, + { + 0xFA, 0x52, 0xAE, 0x02, 0x98, 0xC3, 0xAF, 0x0F, + 0x74, 0x45, 0xC5, 0xDD, 0x0F, 0xBA, 0xE5, 0x76, + 0x39, 0x24, 0xD0, 0xD5, 0x2B, 0x72, 0x4D, 0x61, + 0x02, 0x96, 0xF8, 0x12, 0x73, 0x2F, 0x49, 0x2B, + 0x32, 0xF9, 0x61, 0xC7, 0x4D, 0x03, 0x73, 0xA0, + 0x34, 0x60, 0xA4, 0xB4, 0x8C, 0x15, 0x4D, 0x53, + 0xD8, 0x01, 0xE0, 0x9F, 0x82, 0x7C, 0xAD, 0x68, + 0x73, 0x2C, 0x4E, 0x5E, 0x02, 0x9F, 0xFC, 0x6F + }, + { + 0x11, 0xF4, 0xE7, 0x52, 0x66, 0x1A, 0xEB, 0xA6, + 0xE7, 0x15, 0x83, 0xA5, 0xDF, 0x92, 0xB6, 0xB3, + 0x20, 0xC4, 0x6B, 0x00, 0x2F, 0xDC, 0x1A, 0xF7, + 0xAF, 0xF7, 0x6E, 0x59, 0x05, 0xC4, 0xEA, 0x4F, + 0x94, 0xDC, 0x50, 0x9A, 0xFC, 0xE9, 0x52, 0xFC, + 0xA7, 0xD8, 0x5F, 0xE9, 0x55, 0x93, 0xC6, 0x8F, + 0x27, 0xFF, 0x57, 0x76, 0xF5, 0xE1, 0x96, 0x15, + 0xC0, 0x36, 0x81, 0xCF, 0x5F, 0x97, 0xBF, 0xAB + }, + { + 0xF0, 0xBC, 0x32, 0x31, 0x7F, 0xFC, 0x28, 0xD6, + 0x1F, 0xDD, 0x4F, 0xFC, 0xA1, 0x26, 0x8E, 0xD1, + 0x3B, 0x35, 0xA0, 0x29, 0x99, 0x74, 0xA8, 0x7F, + 0x6A, 0xAB, 0x85, 0xE7, 0xC7, 0xC5, 0x36, 0x2A, + 0xD6, 0x01, 0x85, 0xCA, 0xEF, 0x6E, 0x2F, 0x96, + 0x38, 0xFD, 0x21, 0x2D, 0x1C, 0x26, 0x6F, 0xC3, + 0xAC, 0x46, 0x83, 0x28, 0x12, 0xBC, 0xB3, 0xEC, + 0x02, 0x70, 0xA3, 0x2B, 0x1E, 0x5C, 0xE7, 0x0E + }, + { + 0xA7, 0xB9, 0x3E, 0x7E, 0x6B, 0xC1, 0xAC, 0xF0, + 0x31, 0x5E, 0x8C, 0x63, 0x9C, 0x93, 0x70, 0x21, + 0x43, 0x42, 0x9C, 0x25, 0x81, 0x97, 0x4D, 0x7F, + 0x97, 0xD5, 0x7E, 0x68, 0xD1, 0x54, 0x21, 0xDB, + 0xDB, 0x2C, 0xBB, 0x15, 0x76, 0x04, 0x8D, 0xC2, + 0xF3, 0x7C, 0xD0, 0x0C, 0xBD, 0x98, 0x33, 0xBF, + 0xF4, 0xD7, 0x98, 0x06, 0xC8, 0xBD, 0x85, 0x90, + 0xB7, 0x8F, 0x2C, 0x74, 0x40, 0xA0, 0x64, 0xE4 + }, + { + 0x56, 0x2D, 0xB3, 0xBB, 0xCA, 0xC3, 0x75, 0x08, + 0x6B, 0x2B, 0x16, 0x49, 0x63, 0x67, 0x8B, 0xED, + 0x15, 0x5A, 0x47, 0x2D, 0xD8, 0xD6, 0xB3, 0x6E, + 0xB0, 0xF5, 0x95, 0x60, 0xD6, 0x8C, 0x68, 0xEC, + 0x2E, 0xDE, 0xF0, 0x44, 0x57, 0xD3, 0xA8, 0x9D, + 0xBD, 0x4E, 0x0B, 0x25, 0x56, 0x1A, 0xE4, 0x18, + 0x45, 0x9F, 0x2C, 0xAA, 0xBF, 0xC0, 0xBF, 0xC1, + 0x69, 0x2B, 0xA8, 0xA4, 0x27, 0x26, 0x3E, 0xD7 + }, + { + 0x13, 0x4C, 0x5F, 0x6C, 0x46, 0x04, 0x90, 0x1E, + 0x4A, 0x33, 0xE3, 0x31, 0xF7, 0x46, 0xC4, 0xCF, + 0x5D, 0x80, 0x62, 0x7A, 0x51, 0xD4, 0xB5, 0xF5, + 0xD4, 0x45, 0x0A, 0x73, 0x09, 0xA6, 0x3B, 0xFE, + 0xAE, 0x58, 0xD7, 0x34, 0xA7, 0xCA, 0xC0, 0xC2, + 0xD1, 0x55, 0xA5, 0xB4, 0x7C, 0x05, 0x6B, 0xB8, + 0x11, 0x88, 0x0A, 0xB4, 0x5F, 0x27, 0xFD, 0x3B, + 0x83, 0x35, 0x7E, 0x7E, 0x06, 0x45, 0xAB, 0x92 + }, + { + 0xE1, 0xF0, 0xD6, 0xA1, 0xB8, 0x91, 0xC5, 0x8E, + 0x69, 0xB6, 0xA6, 0x3D, 0x65, 0xE5, 0xF3, 0xE8, + 0x5E, 0xC6, 0x2F, 0x22, 0x5D, 0xA0, 0x23, 0x9D, + 0xD9, 0x27, 0xBB, 0x19, 0xFF, 0x38, 0x9A, 0xD8, + 0x73, 0x06, 0xC7, 0xDD, 0xE2, 0x8C, 0xA6, 0x01, + 0x97, 0xD5, 0xB2, 0xF5, 0xC0, 0x26, 0xA5, 0x42, + 0xC1, 0xC4, 0x52, 0x8E, 0xBB, 0x7E, 0x28, 0x2B, + 0x97, 0x7C, 0xF0, 0x14, 0x2F, 0x53, 0x30, 0x54 + }, + { + 0x96, 0x1A, 0x65, 0x1F, 0xF9, 0x26, 0x71, 0x2A, + 0xE3, 0x89, 0xFB, 0xFF, 0x0D, 0x13, 0xF2, 0x65, + 0x67, 0xFC, 0x8E, 0xE9, 0x51, 0x9D, 0x8E, 0x70, + 0x91, 0xEA, 0xC1, 0x20, 0x7D, 0x70, 0x01, 0x55, + 0x19, 0x2B, 0x48, 0xF0, 0x4D, 0x3C, 0x8A, 0x01, + 0x4B, 0x39, 0x87, 0x67, 0xB2, 0x43, 0x5C, 0x26, + 0x51, 0x1C, 0xB2, 0x45, 0x91, 0x20, 0xAE, 0x22, + 0x33, 0x9D, 0x3B, 0xCE, 0xB5, 0x75, 0xFC, 0xA1 + }, + { + 0x7F, 0xDC, 0x6D, 0x92, 0xB8, 0xC6, 0x79, 0x38, + 0x69, 0x3C, 0x66, 0xE0, 0xEA, 0x78, 0x53, 0xB7, + 0xCF, 0x24, 0xE1, 0x22, 0xED, 0xE0, 0x0F, 0xFD, + 0xD0, 0x5B, 0xC5, 0xFC, 0x59, 0xD3, 0xB9, 0x28, + 0xB3, 0xA4, 0x81, 0x5D, 0x17, 0x24, 0x02, 0xF4, + 0x92, 0x84, 0x61, 0x52, 0xFB, 0x3C, 0xAC, 0xCB, + 0x24, 0x08, 0xEC, 0xCD, 0xDA, 0x9B, 0x7F, 0x00, + 0x61, 0xFE, 0x79, 0x2F, 0xC5, 0x40, 0x59, 0x91 + }, + { + 0xAC, 0x5A, 0xF1, 0x82, 0x54, 0x7A, 0x9E, 0xB6, + 0x71, 0x3C, 0x57, 0x4C, 0x86, 0xF0, 0xBE, 0xC4, + 0x2F, 0x37, 0x28, 0xFC, 0x2F, 0x5F, 0xCD, 0x8D, + 0x95, 0x8D, 0xC5, 0x6C, 0xF0, 0xD5, 0x39, 0x87, + 0x40, 0x35, 0x48, 0xF9, 0x55, 0xDB, 0x28, 0x41, + 0xE1, 0xB2, 0x32, 0x75, 0x5B, 0x30, 0xAA, 0x23, + 0x63, 0x59, 0xB7, 0xA0, 0x7F, 0x5F, 0xA4, 0x4D, + 0x20, 0xCC, 0x21, 0x89, 0x71, 0x70, 0x54, 0xBA + }, + { + 0x30, 0x1E, 0x28, 0xC1, 0x53, 0x5E, 0x66, 0x73, + 0x15, 0x46, 0xAE, 0xD6, 0x70, 0xD4, 0xDC, 0xF8, + 0x5A, 0xC6, 0xE2, 0xAC, 0xA9, 0x3B, 0xA9, 0x10, + 0xEB, 0x23, 0x4F, 0x0B, 0x9E, 0xF4, 0x03, 0x40, + 0xC5, 0xA4, 0xBE, 0x0C, 0x72, 0xA0, 0x40, 0x68, + 0x09, 0x4D, 0x7E, 0x5A, 0x50, 0xE3, 0x93, 0x49, + 0x8F, 0x96, 0x8A, 0x12, 0x1D, 0xDA, 0xDE, 0xCC, + 0x39, 0x41, 0x35, 0x45, 0x6F, 0x4B, 0x7A, 0x12 + }, + { + 0xC0, 0xC2, 0x69, 0x3C, 0x20, 0x75, 0x1A, 0xC2, + 0xCE, 0xA2, 0x4A, 0x4B, 0x85, 0x66, 0xFA, 0x2C, + 0x79, 0x6A, 0x7F, 0xFE, 0x96, 0x3C, 0xEC, 0xAF, + 0x82, 0x80, 0x90, 0xFF, 0x0B, 0x24, 0x7C, 0xB8, + 0x4A, 0x51, 0xAC, 0xE2, 0x30, 0x6A, 0xDC, 0x3F, + 0x87, 0x17, 0xF1, 0x49, 0x09, 0xB7, 0x2D, 0xB8, + 0x70, 0xCB, 0x08, 0x6B, 0xF7, 0x16, 0xE2, 0x58, + 0x6A, 0xB1, 0x01, 0xE1, 0xAB, 0xBE, 0x4D, 0xDD + }, + { + 0x2F, 0x73, 0xF8, 0x63, 0x7C, 0xFA, 0xB0, 0xBF, + 0x15, 0xDA, 0x6C, 0x72, 0x81, 0xDB, 0xC7, 0x44, + 0x6D, 0x01, 0xC0, 0x97, 0xAA, 0xD3, 0x3B, 0x94, + 0x26, 0x62, 0xB8, 0x95, 0xAF, 0x20, 0xCA, 0xCD, + 0x84, 0x55, 0xDF, 0x1A, 0xF5, 0xF2, 0x86, 0x8C, + 0x7A, 0xF9, 0x32, 0xF4, 0x6A, 0xE5, 0x20, 0x33, + 0x95, 0xA7, 0x72, 0x86, 0xA3, 0xC8, 0x73, 0xF0, + 0x71, 0xA7, 0x60, 0xD8, 0xB3, 0xC8, 0x61, 0x50 + }, + { + 0x4B, 0x0F, 0xAE, 0xB8, 0x44, 0xA6, 0x92, 0x00, + 0x21, 0x80, 0xFC, 0x40, 0x06, 0x02, 0xDA, 0x9F, + 0xD6, 0x65, 0x18, 0xC0, 0xC6, 0x7A, 0x4D, 0x4F, + 0xA2, 0xAA, 0xE3, 0xDB, 0xA6, 0x26, 0x36, 0x21, + 0x32, 0x13, 0x31, 0x42, 0xE5, 0xC7, 0x29, 0xBE, + 0x6B, 0xB7, 0xBE, 0x2F, 0x0D, 0xE6, 0xD5, 0x10, + 0x18, 0x44, 0xD1, 0xFC, 0x5F, 0xB3, 0x2C, 0xEB, + 0xD1, 0x1C, 0x56, 0xFD, 0x78, 0x3C, 0x57, 0x9E + }, + { + 0x95, 0xBD, 0x04, 0x5E, 0x2D, 0x3A, 0xA0, 0xB4, + 0x3D, 0x95, 0x23, 0x92, 0xD0, 0x5A, 0x05, 0x5C, + 0xD1, 0x09, 0xA0, 0x2B, 0x44, 0xA2, 0xEE, 0x45, + 0x8C, 0x39, 0x48, 0x33, 0xCB, 0xED, 0x3E, 0xBB, + 0x36, 0x28, 0xD2, 0xA5, 0xAB, 0x94, 0xB5, 0xB0, + 0x5F, 0xDB, 0x85, 0xC4, 0x3A, 0x8A, 0xE3, 0xEE, + 0xEE, 0xCD, 0xB3, 0xD6, 0x2F, 0xAE, 0x6A, 0x10, + 0x0F, 0xCD, 0xDA, 0x6A, 0xCC, 0x5D, 0xEE, 0xDF + }, + { + 0xD1, 0x7F, 0x0C, 0x6D, 0x64, 0x33, 0x84, 0xE0, + 0x0C, 0x75, 0xCD, 0x95, 0x47, 0x19, 0xA6, 0xF2, + 0xE3, 0xBB, 0x82, 0x71, 0x4B, 0x5A, 0xCC, 0x3D, + 0x29, 0xA5, 0x92, 0x83, 0x5A, 0xDF, 0xFE, 0x3D, + 0x96, 0x78, 0x60, 0x12, 0x64, 0xAC, 0xB5, 0xCD, + 0x31, 0x26, 0xBE, 0xC5, 0xAE, 0x27, 0xA6, 0x9B, + 0x82, 0x58, 0x13, 0xCE, 0xE3, 0xC8, 0xA0, 0xAE, + 0x88, 0x56, 0xE4, 0x93, 0xC1, 0x56, 0x57, 0x92 + }, + { + 0xEE, 0x61, 0xEE, 0x6D, 0x1B, 0x0B, 0xD9, 0x04, + 0x63, 0x33, 0xAD, 0xD5, 0x1B, 0x6C, 0x45, 0xF7, + 0xB9, 0x73, 0x69, 0xDC, 0xBD, 0x1C, 0x96, 0xB9, + 0x26, 0x28, 0xEE, 0xBF, 0xC9, 0xAA, 0x95, 0xC0, + 0x9A, 0xE5, 0x05, 0x39, 0x4E, 0x83, 0x1F, 0xB4, + 0xBC, 0x1E, 0xA8, 0x64, 0xAD, 0x54, 0x7E, 0x92, + 0x7F, 0xDB, 0x35, 0xC2, 0x4A, 0x77, 0xD2, 0x5B, + 0x86, 0x9C, 0x02, 0xF2, 0x6F, 0x8B, 0xDC, 0x30 + }, + { + 0x02, 0x29, 0xDC, 0xB3, 0x98, 0xE5, 0x3A, 0x99, + 0x34, 0x03, 0x8B, 0xE2, 0xB0, 0xD4, 0x75, 0x38, + 0x58, 0x3C, 0xC1, 0x77, 0x7E, 0xCE, 0x32, 0xCB, + 0x0B, 0xCA, 0xE1, 0x16, 0x3C, 0x7C, 0x19, 0x60, + 0xDE, 0x2C, 0x94, 0x16, 0xF5, 0x05, 0x22, 0xA8, + 0xAF, 0x64, 0x5B, 0xE2, 0x54, 0x54, 0xE5, 0x26, + 0xAB, 0x11, 0xF8, 0xD8, 0xC2, 0x3B, 0x34, 0xC3, + 0x38, 0x68, 0xDF, 0x02, 0x46, 0xCB, 0x3F, 0xF0 + }, + { + 0x3C, 0x5F, 0xE4, 0x19, 0x9C, 0xED, 0xA4, 0x96, + 0xBA, 0x1D, 0x52, 0xF0, 0x3F, 0xDA, 0x3E, 0x46, + 0x7D, 0x90, 0x44, 0x22, 0xA8, 0x38, 0x1C, 0x1F, + 0x41, 0xF6, 0x36, 0x8F, 0xF5, 0x81, 0x82, 0x79, + 0x97, 0x3D, 0xED, 0x93, 0x82, 0xE8, 0xCD, 0x26, + 0x9B, 0x38, 0x82, 0x76, 0x5E, 0x70, 0x33, 0x7A, + 0x91, 0x59, 0x9A, 0xDE, 0x57, 0x68, 0x88, 0x37, + 0xDB, 0xA2, 0x30, 0x73, 0xBC, 0x04, 0xE3, 0x27 + }, + { + 0x1C, 0xDA, 0x13, 0x41, 0xBB, 0x72, 0xF5, 0xB0, + 0xD5, 0x51, 0xDD, 0x88, 0xEA, 0xC9, 0x18, 0xDE, + 0xCB, 0x73, 0xE6, 0xF3, 0x71, 0xFD, 0x5D, 0x99, + 0x6E, 0xA6, 0x21, 0x91, 0x09, 0x53, 0x7B, 0x3E, + 0x2C, 0xD5, 0x6D, 0xD9, 0x2F, 0x1E, 0x5A, 0xE4, + 0x63, 0xC6, 0xE3, 0xFC, 0x14, 0xCC, 0xBC, 0xA5, + 0xCE, 0xC2, 0xDF, 0x0F, 0xEB, 0xBF, 0x65, 0x5A, + 0xBF, 0x4C, 0x81, 0xE4, 0x4C, 0x2F, 0xA6, 0x79 + }, + { + 0x9F, 0x3E, 0x29, 0xE5, 0x24, 0x42, 0x28, 0xBB, + 0xD9, 0x77, 0x7C, 0x2A, 0xF7, 0xB2, 0xA3, 0xE7, + 0xD4, 0x8D, 0xAE, 0xEF, 0x7B, 0x0E, 0xD3, 0xBA, + 0x11, 0x87, 0xF6, 0x7D, 0x3A, 0x39, 0xEF, 0xBC, + 0xBB, 0xA9, 0xD4, 0x18, 0x12, 0x72, 0xED, 0x25, + 0x6C, 0xFB, 0xA4, 0xF6, 0x2D, 0x69, 0x8D, 0x2B, + 0x63, 0xCE, 0x53, 0xBE, 0x92, 0xDC, 0x07, 0x83, + 0xD0, 0x00, 0x7E, 0x3E, 0x8B, 0x83, 0x27, 0x48 + }, + { + 0x1B, 0xBE, 0xC6, 0x39, 0xEE, 0x6D, 0xED, 0x54, + 0x29, 0x1A, 0x24, 0x72, 0x7D, 0x60, 0xAE, 0x1D, + 0xB1, 0x07, 0x78, 0xE2, 0x01, 0x61, 0x44, 0xC8, + 0x35, 0x8E, 0x69, 0xDB, 0x22, 0x34, 0xE2, 0x79, + 0x6E, 0x81, 0xA4, 0xB5, 0x91, 0xDC, 0x21, 0x50, + 0xC3, 0xE2, 0xCE, 0xE9, 0x3C, 0xCD, 0x54, 0x56, + 0xEF, 0xD6, 0x64, 0x70, 0x1B, 0xAA, 0x10, 0xCE, + 0x9C, 0x69, 0xB5, 0x70, 0x6F, 0xC8, 0xCE, 0xC3 + }, + { + 0x8B, 0x40, 0x35, 0x03, 0xE4, 0x85, 0x8A, 0xF8, + 0x99, 0x5A, 0xF7, 0xAE, 0xFA, 0x9D, 0x37, 0x2B, + 0x81, 0x70, 0x89, 0xCF, 0x54, 0x61, 0x3C, 0xEA, + 0x70, 0xA0, 0xEB, 0xDA, 0xAC, 0x18, 0x17, 0x4B, + 0xCA, 0x50, 0x9F, 0xAE, 0xDA, 0xB1, 0x34, 0x45, + 0x59, 0x56, 0x5D, 0xAC, 0xB7, 0xDC, 0x77, 0xE4, + 0xAF, 0x70, 0x1A, 0x0A, 0x05, 0xB2, 0x19, 0x4A, + 0x6D, 0x6B, 0x14, 0x03, 0xE8, 0x42, 0x28, 0x9D + }, + { + 0xE4, 0x1C, 0x3D, 0xB6, 0xD8, 0x8E, 0x9B, 0xC5, + 0x7C, 0x6B, 0xDC, 0xBD, 0x6E, 0x95, 0x5A, 0x84, + 0x22, 0xE4, 0x81, 0x4A, 0x87, 0x97, 0x2F, 0xDE, + 0xDC, 0xBE, 0xC4, 0xA4, 0xCD, 0x3B, 0xA2, 0xF7, + 0x95, 0x71, 0xF4, 0x20, 0x39, 0x5F, 0x3D, 0x36, + 0x0A, 0x2D, 0xD2, 0x0E, 0x1A, 0x14, 0xBF, 0xCF, + 0x58, 0xA9, 0x48, 0xD5, 0x62, 0x3D, 0x39, 0x6E, + 0x4D, 0xBA, 0x76, 0x45, 0xD7, 0x3C, 0x92, 0x95 + }, + { + 0x36, 0x5B, 0x07, 0x2D, 0x83, 0x52, 0xB1, 0x8E, + 0xE5, 0xED, 0xC0, 0x40, 0xEE, 0x67, 0xDE, 0x18, + 0x3A, 0xFF, 0xF7, 0xA6, 0x0A, 0x20, 0x8D, 0xC4, + 0x9D, 0xF5, 0xB1, 0xC4, 0x3D, 0xA7, 0xEF, 0x4A, + 0xB4, 0xFA, 0x26, 0x92, 0x72, 0x06, 0x70, 0xF1, + 0x37, 0x0E, 0x6D, 0x11, 0x6D, 0x82, 0x27, 0x0D, + 0x98, 0x8A, 0xC8, 0x06, 0x90, 0x71, 0xD3, 0xC1, + 0x8C, 0x0F, 0x41, 0x33, 0xDE, 0xD6, 0x43, 0x81 + }, + { + 0xD9, 0x43, 0xF7, 0x76, 0xCC, 0xF9, 0xFE, 0x28, + 0x1D, 0x7E, 0x46, 0x58, 0x9E, 0xFF, 0x22, 0x54, + 0xCC, 0xCF, 0xE3, 0xC7, 0xD1, 0x47, 0xBD, 0x82, + 0xD8, 0x34, 0x67, 0x01, 0xD9, 0x9D, 0xED, 0xAA, + 0xB5, 0xAD, 0x3C, 0x77, 0x2E, 0x0A, 0xBE, 0x5A, + 0x3D, 0x5D, 0xB0, 0x81, 0x2B, 0xCA, 0x10, 0xC7, + 0x53, 0xB8, 0x1A, 0xCA, 0xDC, 0x10, 0xAC, 0x76, + 0xF7, 0xA8, 0x69, 0xF0, 0xDB, 0x5F, 0x9D, 0xC6 + }, + { + 0x9F, 0xC3, 0x90, 0x34, 0xF5, 0x55, 0xB2, 0x4B, + 0xA4, 0xF9, 0x5C, 0x70, 0x35, 0x09, 0xC3, 0x6F, + 0xB1, 0x31, 0xC6, 0xA7, 0xEF, 0x3F, 0x34, 0x7E, + 0xE1, 0x1C, 0x60, 0xCA, 0x57, 0x71, 0x6D, 0x6A, + 0x40, 0x67, 0xC9, 0xA3, 0x63, 0x1C, 0x73, 0xA1, + 0x2F, 0x6F, 0x40, 0x6E, 0x06, 0xF8, 0xDD, 0x37, + 0x49, 0xE1, 0xB7, 0xD5, 0x6D, 0xE9, 0xCC, 0x00, + 0x29, 0xFD, 0x34, 0x9C, 0xCB, 0xBB, 0x66, 0x3E + }, + { + 0x3F, 0x9D, 0x66, 0xA2, 0x89, 0x6A, 0x2C, 0xD2, + 0x52, 0x88, 0x35, 0xE4, 0x78, 0xAB, 0xED, 0xCC, + 0xE4, 0x3C, 0x62, 0xB7, 0x2A, 0x14, 0x7B, 0xB0, + 0xB4, 0xEA, 0xD9, 0x9B, 0x9B, 0x64, 0x39, 0x0B, + 0x4E, 0xF8, 0x47, 0x02, 0x90, 0xE1, 0x50, 0xF4, + 0x7B, 0x48, 0x7E, 0x35, 0x9B, 0x2A, 0x98, 0x9E, + 0x15, 0x6C, 0x5D, 0x69, 0x7C, 0xEA, 0x7B, 0xBE, + 0x5F, 0x8F, 0x48, 0x45, 0x2C, 0x0E, 0xCD, 0x4B + }, + { + 0x11, 0xDF, 0x8D, 0xE5, 0x65, 0x97, 0x04, 0x10, + 0x15, 0x46, 0xDD, 0x13, 0x8F, 0x4A, 0x07, 0x25, + 0xF9, 0x71, 0x22, 0x5C, 0x2E, 0xEE, 0xB9, 0x40, + 0xFA, 0x2F, 0x18, 0xD8, 0x01, 0xAB, 0xB9, 0xA3, + 0xE9, 0x33, 0x3F, 0x8B, 0x8C, 0x0B, 0xB7, 0xA6, + 0x3E, 0x5D, 0x4B, 0xDE, 0x79, 0x20, 0x7C, 0x0B, + 0x74, 0xD4, 0xA8, 0x25, 0x5B, 0x56, 0x0A, 0x1F, + 0xD9, 0xE1, 0xB0, 0xBE, 0x9F, 0x82, 0x3C, 0x1E + }, + { + 0x07, 0xD0, 0xB8, 0xA8, 0x33, 0xCC, 0xE2, 0x1C, + 0x6B, 0x5B, 0xDF, 0x3C, 0xCF, 0x6E, 0xF4, 0x99, + 0x56, 0xBC, 0xC2, 0x72, 0x09, 0x27, 0x75, 0xC9, + 0xAA, 0x28, 0xF8, 0x73, 0x78, 0x4C, 0x54, 0xEF, + 0xE8, 0xDB, 0x5A, 0x5B, 0xC1, 0xDC, 0xC2, 0x86, + 0xE4, 0x4D, 0xE5, 0xCE, 0x87, 0xDE, 0xDA, 0x27, + 0x55, 0xA7, 0x89, 0xC2, 0x77, 0x49, 0x7A, 0xE5, + 0xA3, 0xA8, 0x0A, 0x42, 0x75, 0x9B, 0xA8, 0x84 + }, + { + 0x79, 0x7E, 0x78, 0x07, 0x82, 0x6A, 0x7A, 0xFF, + 0xBC, 0xBA, 0x17, 0x57, 0x8F, 0xEC, 0x3A, 0xC4, + 0x74, 0x27, 0x25, 0x7E, 0x97, 0x6B, 0x50, 0x65, + 0x02, 0xE6, 0x5A, 0x5F, 0x29, 0x20, 0xBC, 0x32, + 0x67, 0x2F, 0xC3, 0x2B, 0xB9, 0xD8, 0x35, 0x74, + 0xF8, 0x62, 0xF2, 0x32, 0xEA, 0x2B, 0xDB, 0xFA, + 0x46, 0xB9, 0xBA, 0x5A, 0x67, 0x76, 0xFF, 0xD2, + 0x7B, 0xFC, 0x40, 0x21, 0x91, 0x7D, 0x5A, 0x7F + }, + { + 0xBA, 0x3D, 0xE7, 0x35, 0x53, 0xF7, 0xB3, 0xB5, + 0xE6, 0x2A, 0x4D, 0x2B, 0xE2, 0x09, 0x9E, 0x08, + 0x5A, 0x6E, 0x8F, 0x48, 0x9A, 0xF4, 0xA0, 0x9D, + 0xFB, 0xC5, 0x39, 0xD0, 0xE2, 0x37, 0x13, 0x04, + 0x62, 0x17, 0x1E, 0xD2, 0xBB, 0x05, 0x11, 0xC3, + 0x78, 0x3B, 0x45, 0x02, 0x53, 0x13, 0xBD, 0xDA, + 0xB7, 0xB6, 0x1D, 0x9E, 0xC7, 0x27, 0xFF, 0xA2, + 0x68, 0x8C, 0x81, 0xEC, 0xDE, 0xC8, 0xBC, 0xEF + }, + { + 0x02, 0x7D, 0x9C, 0x19, 0x9E, 0x97, 0x33, 0x2D, + 0x4D, 0x0F, 0x95, 0x7F, 0xA3, 0x96, 0x93, 0xA9, + 0x94, 0x8D, 0x25, 0xA9, 0x2A, 0x24, 0xA9, 0x39, + 0xE0, 0x86, 0xD2, 0x95, 0xFF, 0x3B, 0xE6, 0x7F, + 0x5B, 0xB5, 0x09, 0xB6, 0x95, 0xC7, 0x38, 0x5C, + 0x53, 0xF2, 0xAF, 0xFE, 0x57, 0xBD, 0xAE, 0x1E, + 0x32, 0xAC, 0x4B, 0xBD, 0x23, 0x1D, 0xF8, 0xDD, + 0x6F, 0x97, 0xAB, 0x37, 0xC7, 0x57, 0x17, 0x3A + }, + { + 0xB8, 0xFD, 0x01, 0xC4, 0x08, 0xB2, 0x2A, 0xC4, + 0x7A, 0x6B, 0xB2, 0xC0, 0xD2, 0x00, 0x55, 0x98, + 0xA5, 0x45, 0xF3, 0x41, 0x00, 0x60, 0x7C, 0x68, + 0x73, 0x40, 0x1E, 0xE1, 0x66, 0xF6, 0x0B, 0x57, + 0x7E, 0x7E, 0x3A, 0xF1, 0xAA, 0x2A, 0x24, 0xA5, + 0xDF, 0xAB, 0xB8, 0x38, 0x5F, 0xCE, 0xD0, 0xA0, + 0x7C, 0x6B, 0xE0, 0x06, 0xA6, 0x93, 0x7D, 0xC6, + 0x86, 0x20, 0x67, 0x8B, 0x62, 0x58, 0x35, 0x2E + }, + { + 0xBD, 0xE7, 0x24, 0x11, 0xDE, 0xEB, 0x85, 0xC6, + 0xEA, 0xAF, 0xB0, 0xBB, 0xA6, 0xF0, 0x99, 0xC9, + 0x5B, 0x4C, 0xAD, 0x68, 0x21, 0x43, 0x8A, 0x69, + 0xBA, 0xB5, 0x59, 0xB5, 0x65, 0x41, 0x4B, 0x0F, + 0x82, 0x69, 0x40, 0x02, 0x67, 0x3A, 0xAC, 0x14, + 0x7D, 0x71, 0x48, 0x5B, 0x61, 0xD9, 0xD5, 0x5E, + 0xF8, 0xB3, 0x28, 0xAB, 0x1C, 0x78, 0xC0, 0x60, + 0xFD, 0x12, 0x07, 0x28, 0xA7, 0xBD, 0x12, 0xB7 + }, + { + 0x07, 0x78, 0x79, 0x0E, 0x25, 0xE7, 0xEE, 0xC5, + 0x03, 0x53, 0xBE, 0xA6, 0xE3, 0xFC, 0xBF, 0x2F, + 0x13, 0x8F, 0x4F, 0xF3, 0xC5, 0x3C, 0xDD, 0x55, + 0x68, 0x6E, 0xF1, 0xB0, 0xD5, 0xEE, 0x7E, 0xA7, + 0x4D, 0x37, 0xC9, 0x93, 0x41, 0x4E, 0x46, 0x6B, + 0x17, 0x3D, 0x99, 0xEC, 0x5A, 0xFC, 0x7B, 0x07, + 0xAF, 0x44, 0xE2, 0xE7, 0x6B, 0x90, 0x45, 0x6A, + 0x47, 0x30, 0xCB, 0x15, 0xB1, 0x50, 0xC5, 0xF2 + }, + { + 0x0B, 0x7C, 0x3A, 0xB9, 0xE4, 0x48, 0x0B, 0x97, + 0xCA, 0x61, 0x06, 0x5D, 0xAB, 0x07, 0x39, 0x65, + 0xBE, 0x1D, 0xE2, 0x6D, 0xA4, 0x6C, 0x6E, 0x87, + 0xB0, 0x2E, 0x8A, 0x34, 0x3B, 0xC2, 0x44, 0xB7, + 0xDA, 0xDD, 0xC5, 0x27, 0xDF, 0x37, 0x60, 0x8E, + 0xAD, 0x84, 0xA6, 0x9A, 0x98, 0x9C, 0x18, 0x26, + 0x8E, 0x76, 0x49, 0x7F, 0xAF, 0x17, 0x42, 0x64, + 0x48, 0xBD, 0x6C, 0x65, 0x85, 0x61, 0xE5, 0x99 + }, + { + 0x60, 0x08, 0x3A, 0xA8, 0xEB, 0x13, 0x5B, 0x38, + 0x4F, 0x13, 0x3D, 0x74, 0x67, 0x8B, 0xE1, 0x04, + 0x71, 0xEE, 0xA4, 0x51, 0xA7, 0x0D, 0x43, 0x83, + 0xF2, 0x87, 0x82, 0x42, 0xE0, 0x1E, 0xBE, 0x88, + 0xA9, 0x48, 0xC1, 0xB0, 0x2D, 0x50, 0xC6, 0x17, + 0xCC, 0x00, 0x29, 0xE6, 0x98, 0x2C, 0x84, 0x99, + 0x07, 0x6F, 0xE6, 0x4F, 0x17, 0x69, 0xAC, 0xFE, + 0xD0, 0xA3, 0x47, 0x61, 0xF1, 0x38, 0xB5, 0xFD + }, + { + 0xCB, 0xB4, 0xF7, 0x67, 0x59, 0xA9, 0x65, 0xE2, + 0x92, 0x35, 0x60, 0xD4, 0x1F, 0xB7, 0x64, 0xB1, + 0x53, 0xBE, 0x48, 0x13, 0x00, 0x03, 0x34, 0xF9, + 0x55, 0x0E, 0x58, 0x8E, 0x12, 0x23, 0xE2, 0x98, + 0x8B, 0x26, 0xBE, 0x3B, 0xC1, 0x99, 0x07, 0xED, + 0x96, 0x4F, 0xF2, 0xDF, 0xC3, 0x31, 0x73, 0xEB, + 0x6B, 0x87, 0x72, 0xCD, 0x6B, 0xAB, 0x4D, 0x79, + 0x5D, 0xFA, 0x80, 0x7A, 0xE0, 0xF8, 0x13, 0x67 + }, + { + 0x55, 0x99, 0x87, 0xC2, 0x62, 0x3D, 0xEE, 0x40, + 0x7B, 0x08, 0x06, 0x1E, 0xD5, 0x5B, 0x5D, 0xEB, + 0x41, 0x74, 0x83, 0x3E, 0x75, 0xF8, 0x02, 0xD2, + 0x7F, 0xA6, 0x4E, 0x05, 0x4C, 0x18, 0x28, 0xFC, + 0x0D, 0x3B, 0xA6, 0xF6, 0x1A, 0x9A, 0xA2, 0xD8, + 0x04, 0x7C, 0xCE, 0xC4, 0x58, 0xB4, 0x8B, 0xBB, + 0xFE, 0x47, 0x27, 0xCC, 0x7F, 0xF0, 0x81, 0x65, + 0x4A, 0x8E, 0x0A, 0x49, 0xE7, 0x6C, 0xA4, 0xA2 + }, + { + 0x9F, 0xB8, 0xF5, 0xA2, 0xE0, 0x14, 0xD0, 0xAF, + 0xAA, 0xB4, 0x8B, 0x49, 0xD0, 0xFC, 0xA7, 0x59, + 0xC7, 0x2E, 0xBC, 0x66, 0x94, 0xA2, 0x02, 0xC8, + 0xC4, 0x6C, 0x78, 0xA9, 0x42, 0x8E, 0xD5, 0x51, + 0xFF, 0xDF, 0x69, 0x96, 0x63, 0x02, 0x96, 0x9A, + 0x54, 0x53, 0xEA, 0xC3, 0x68, 0xF8, 0x1C, 0xCA, + 0xAC, 0xD6, 0x41, 0xCC, 0xF5, 0xE0, 0x79, 0x36, + 0xD3, 0x9A, 0x4A, 0x08, 0xED, 0xD8, 0xA5, 0xFF + }, + { + 0xE7, 0xDB, 0xD3, 0x85, 0x8F, 0x6B, 0xC8, 0x05, + 0xCA, 0x2B, 0xA9, 0x15, 0xC6, 0x43, 0x61, 0xEC, + 0xCB, 0x97, 0xE0, 0x89, 0xBB, 0xCC, 0x0F, 0xB9, + 0xA9, 0xF2, 0x54, 0x18, 0x31, 0xDF, 0xBC, 0x4E, + 0x5A, 0x83, 0xDD, 0x28, 0xA3, 0x9A, 0x95, 0x1F, + 0x64, 0x7B, 0x8B, 0xB9, 0x45, 0x37, 0x9D, 0xA5, + 0xDA, 0xDE, 0xFA, 0xED, 0x78, 0x75, 0x7A, 0xFA, + 0x2F, 0x5C, 0x59, 0x2C, 0x2E, 0x09, 0xC7, 0xC3 + }, + { + 0x8F, 0x18, 0x7D, 0x77, 0x77, 0x56, 0xEA, 0x86, + 0xB3, 0x80, 0x0A, 0xDD, 0x46, 0x1F, 0x6B, 0x9F, + 0x7E, 0xAC, 0x29, 0x81, 0x85, 0xE1, 0x06, 0x1E, + 0x8B, 0x1E, 0x7E, 0x11, 0xEC, 0x52, 0x7E, 0x25, + 0x42, 0x9F, 0x54, 0xB2, 0x86, 0xD5, 0xF2, 0x34, + 0x15, 0xD1, 0xFB, 0x2C, 0x20, 0xDC, 0x64, 0x57, + 0x7B, 0x66, 0x41, 0x1A, 0x03, 0x4C, 0x9D, 0x5C, + 0x4C, 0x2B, 0x9F, 0x21, 0xC4, 0x5D, 0xDB, 0x4E + }, + { + 0xD3, 0xD5, 0xB4, 0xCA, 0xF1, 0x7F, 0xC9, 0x3D, + 0xA6, 0xA9, 0x19, 0x3A, 0x31, 0xD3, 0xDF, 0xC5, + 0xB7, 0x99, 0xF4, 0xC6, 0x0A, 0xF0, 0x30, 0x21, + 0x79, 0x85, 0x85, 0x3B, 0x8B, 0x30, 0x01, 0xEE, + 0xD9, 0xC2, 0x06, 0xAF, 0x7B, 0xA2, 0x55, 0x05, + 0x94, 0xA9, 0xDB, 0x81, 0x32, 0x28, 0xB8, 0xFC, + 0xEE, 0x27, 0x77, 0xE7, 0x9E, 0x3D, 0xE8, 0x5B, + 0xBA, 0xC8, 0x1F, 0x92, 0xFA, 0x3A, 0x19, 0x6A + }, + { + 0x52, 0x94, 0x52, 0x24, 0x85, 0x1D, 0x8F, 0x6D, + 0xE4, 0xB6, 0x67, 0x38, 0x74, 0x04, 0x44, 0x30, + 0xF5, 0x83, 0xBF, 0x2B, 0x89, 0x00, 0xBE, 0x4E, + 0xB3, 0x51, 0xBD, 0x64, 0x98, 0x9B, 0x1B, 0x95, + 0xB0, 0xE0, 0x19, 0xCD, 0x3B, 0xFE, 0xF3, 0x9F, + 0x04, 0xD7, 0x85, 0x42, 0x03, 0x49, 0x09, 0xEB, + 0x83, 0x56, 0x68, 0xB8, 0x47, 0xC6, 0xD6, 0x32, + 0x31, 0x29, 0x8E, 0x50, 0x20, 0xB6, 0x98, 0x35 + }, + { + 0xA0, 0x9E, 0x27, 0x64, 0xC6, 0xA6, 0xCD, 0x94, + 0x89, 0xA5, 0x4F, 0x2C, 0xBE, 0x6E, 0xD2, 0x3F, + 0x2C, 0xEA, 0xFF, 0x3B, 0x97, 0xA9, 0xD4, 0xAF, + 0xC2, 0x98, 0xE0, 0xDE, 0x5E, 0xE2, 0x1A, 0x15, + 0xF2, 0xCC, 0x08, 0x62, 0x39, 0x09, 0xCA, 0x31, + 0x59, 0x78, 0x66, 0x47, 0x41, 0xBE, 0xF3, 0x66, + 0x78, 0x88, 0x3C, 0x4A, 0xEB, 0xCE, 0x9A, 0xD7, + 0xF4, 0xF0, 0xD2, 0x74, 0x20, 0x48, 0x5D, 0x64 + }, + { + 0x25, 0x85, 0xCA, 0x64, 0xFD, 0x7D, 0xC4, 0x54, + 0xF6, 0x6B, 0x23, 0xB1, 0x9E, 0x7B, 0x3F, 0xD5, + 0xE2, 0xD7, 0x42, 0x00, 0x26, 0x6E, 0x23, 0xE1, + 0x03, 0x0F, 0xBF, 0xE4, 0x09, 0xDE, 0x30, 0x22, + 0xF1, 0xF1, 0xD2, 0xCD, 0xDB, 0xAF, 0xC7, 0x10, + 0x04, 0xAB, 0x0C, 0x24, 0xBD, 0xBF, 0x70, 0x6A, + 0xFE, 0x63, 0x65, 0xF2, 0x2B, 0x75, 0x49, 0x4B, + 0x53, 0xE4, 0x60, 0x88, 0x20, 0x1D, 0xFB, 0x3F + }, + { + 0x1D, 0x44, 0x9F, 0x8B, 0x53, 0x99, 0xE1, 0xA1, + 0x78, 0x7B, 0x67, 0x90, 0xBF, 0x39, 0xDF, 0x68, + 0x5D, 0x56, 0x3F, 0x4F, 0xE9, 0x4A, 0x7C, 0x75, + 0x29, 0x8C, 0xBA, 0x1E, 0x92, 0x07, 0x5C, 0x7E, + 0x0A, 0xF5, 0x9D, 0x41, 0x71, 0x6F, 0xEE, 0xB3, + 0x6A, 0x47, 0x3A, 0x7E, 0x76, 0xE3, 0x39, 0x11, + 0xAE, 0x3E, 0xD9, 0xBD, 0x85, 0x7A, 0x3D, 0x69, + 0x91, 0xB3, 0x41, 0xD1, 0x22, 0xEB, 0x21, 0x87 + }, + { + 0xF2, 0x9D, 0x9A, 0xB0, 0xA0, 0x16, 0xB9, 0x8C, + 0x5C, 0x5E, 0xDE, 0x68, 0x35, 0xAA, 0x7D, 0x6C, + 0x73, 0xF9, 0x48, 0x8E, 0xB5, 0x64, 0xAE, 0x5C, + 0x73, 0x70, 0x1F, 0x62, 0x52, 0xE7, 0x31, 0x9A, + 0xEA, 0xAA, 0x98, 0x49, 0xBC, 0x6C, 0xC8, 0x1D, + 0xE8, 0xE2, 0x8E, 0x50, 0x67, 0xA8, 0xD8, 0xFF, + 0x8B, 0x26, 0x10, 0x43, 0xBC, 0x86, 0xAE, 0xF5, + 0x69, 0xF4, 0x81, 0x4E, 0x22, 0xE1, 0xA5, 0xBA + }, + { + 0x1F, 0x86, 0xE0, 0x1E, 0x71, 0xF5, 0xFE, 0x27, + 0xCA, 0xE9, 0x8C, 0x6A, 0xF5, 0x43, 0x61, 0xD9, + 0x92, 0x7B, 0xE9, 0xD9, 0xB9, 0xF6, 0x93, 0x7C, + 0xA2, 0xA9, 0x46, 0x1A, 0x0D, 0xC9, 0x01, 0x7A, + 0x58, 0xA9, 0xFD, 0x17, 0x20, 0xDB, 0x14, 0x71, + 0xF2, 0xA6, 0x91, 0xA3, 0xF0, 0x60, 0x4F, 0x5F, + 0x44, 0x2D, 0xA1, 0x95, 0x18, 0xE7, 0x2D, 0x76, + 0x1D, 0x53, 0x9A, 0xDA, 0xC0, 0x9C, 0xAC, 0xBC + }, + { + 0x00, 0x73, 0x58, 0xB2, 0xAC, 0xD9, 0xE4, 0x9E, + 0x22, 0x1B, 0x87, 0x1E, 0xF3, 0xC1, 0xF7, 0xBD, + 0x4D, 0x18, 0x76, 0x87, 0xD6, 0x4F, 0x07, 0x1B, + 0xD8, 0x2B, 0x99, 0x8F, 0xDF, 0x7A, 0xDE, 0x62, + 0x03, 0x44, 0x98, 0xE3, 0x9B, 0xEE, 0xA5, 0x49, + 0xE1, 0x8C, 0x1A, 0x8B, 0x6C, 0x5F, 0x7F, 0xDA, + 0xBD, 0x3D, 0x30, 0xAC, 0x2C, 0x50, 0x33, 0x1B, + 0x4B, 0x96, 0x66, 0x61, 0xFE, 0x49, 0x31, 0x36 + }, + { + 0x88, 0xDD, 0x12, 0x91, 0x19, 0x3F, 0xBB, 0xC1, + 0x31, 0x2F, 0x41, 0xD4, 0xB9, 0x07, 0xAC, 0x46, + 0x2F, 0xFC, 0x8F, 0x0B, 0x39, 0x30, 0x82, 0xF1, + 0xAB, 0xE6, 0x30, 0x68, 0xE0, 0x74, 0x98, 0x72, + 0x34, 0x2E, 0x4B, 0x46, 0x34, 0xC5, 0x50, 0x97, + 0x72, 0x02, 0x01, 0x46, 0x3D, 0xE8, 0x18, 0xAA, + 0x65, 0xE4, 0x4A, 0xB5, 0x1C, 0x7E, 0x53, 0x86, + 0x8A, 0x3C, 0x06, 0x1B, 0x37, 0x08, 0x67, 0x4D + }, + { + 0xF7, 0xDE, 0xE2, 0x7A, 0x41, 0xD5, 0x86, 0xEE, + 0x79, 0x0E, 0x04, 0xF4, 0x9F, 0xE6, 0x1F, 0xED, + 0x44, 0x7A, 0x2B, 0x43, 0x78, 0x94, 0x6B, 0xA3, + 0xE2, 0xAD, 0xC7, 0xB6, 0x36, 0x82, 0xE7, 0xC8, + 0xD3, 0x82, 0x0A, 0xE9, 0x4A, 0xCF, 0x11, 0xF9, + 0xAF, 0x63, 0x5F, 0x3D, 0x65, 0x57, 0x3A, 0x8E, + 0x05, 0x8B, 0x29, 0xA6, 0x5C, 0xD6, 0x0E, 0x84, + 0xF1, 0xE2, 0xAD, 0xC1, 0xDB, 0xB6, 0xB4, 0x37 + }, + { + 0xB0, 0x3E, 0x8D, 0x6F, 0x2C, 0x28, 0x71, 0x89, + 0xE5, 0x99, 0x4F, 0x34, 0xF4, 0x77, 0x9E, 0x90, + 0x33, 0x16, 0x95, 0xEC, 0x0F, 0xA4, 0xCD, 0x78, + 0xFD, 0xB7, 0x21, 0x0A, 0x45, 0xB5, 0xF6, 0xA4, + 0x6F, 0x46, 0x46, 0xC1, 0x81, 0x0A, 0xED, 0x74, + 0x00, 0xD8, 0x90, 0xBE, 0xFB, 0x43, 0x0E, 0xA0, + 0x84, 0xBC, 0x21, 0xD7, 0x2E, 0x72, 0xD1, 0x30, + 0xF8, 0x6F, 0x3C, 0xE5, 0x6E, 0x75, 0x08, 0x2C + }, + { + 0xCC, 0x76, 0xE3, 0x8D, 0xA7, 0x98, 0xA8, 0xC0, + 0xE9, 0x60, 0x8F, 0xA2, 0xA4, 0xCB, 0x03, 0xE6, + 0xEC, 0x98, 0x00, 0xB8, 0x52, 0xA2, 0xAA, 0x0B, + 0x22, 0xA0, 0x09, 0xD7, 0x7C, 0xDB, 0xC3, 0xD3, + 0x77, 0x8F, 0xC8, 0xE8, 0x4B, 0x9F, 0xEA, 0x72, + 0x39, 0x50, 0x3A, 0x31, 0x6A, 0x36, 0xEE, 0x0C, + 0x1D, 0x08, 0x62, 0x92, 0x2A, 0x48, 0x3C, 0x71, + 0x7E, 0x84, 0xA8, 0x73, 0xC9, 0xE2, 0x92, 0xA9 + }, + { + 0x37, 0xA0, 0x25, 0xBB, 0xEF, 0xBB, 0x4C, 0xB8, + 0x16, 0xEF, 0x00, 0x78, 0x47, 0x40, 0xA5, 0x62, + 0x58, 0xB0, 0x56, 0x5C, 0x3F, 0xA4, 0x71, 0x36, + 0xEC, 0x0A, 0x6E, 0xD8, 0x07, 0xC9, 0xCA, 0x4A, + 0xDE, 0xD0, 0xFD, 0xEF, 0x05, 0xDD, 0x8A, 0xE9, + 0xBB, 0xBF, 0x13, 0x97, 0x47, 0xDB, 0x3E, 0xE9, + 0xB1, 0x97, 0xBA, 0x69, 0x42, 0xBE, 0x29, 0x5B, + 0xB5, 0x32, 0x3A, 0x26, 0xD4, 0x28, 0x0F, 0xEE + }, + { + 0x3D, 0xB2, 0x28, 0xBA, 0xF8, 0xED, 0xCB, 0x0B, + 0xD7, 0xD2, 0x5E, 0xE9, 0x7E, 0xA3, 0xE4, 0x9D, + 0xB2, 0x0E, 0xBB, 0x7B, 0xDE, 0x02, 0x56, 0x7A, + 0xA8, 0xFC, 0xC0, 0xD6, 0x1F, 0x7B, 0x89, 0xF5, + 0x39, 0x19, 0x7B, 0xE8, 0xC2, 0xAB, 0xD4, 0x27, + 0xD8, 0x0A, 0xCA, 0x78, 0x55, 0x75, 0xC4, 0x7A, + 0x40, 0x5C, 0x2E, 0x7E, 0x9D, 0x90, 0xE4, 0xE8, + 0x7C, 0xC0, 0x3C, 0x80, 0x14, 0x2F, 0xF1, 0xDC + }, + { + 0x75, 0x1B, 0xA0, 0xA4, 0x52, 0x6B, 0x47, 0x54, + 0x26, 0x97, 0x20, 0x39, 0x92, 0x71, 0x58, 0x74, + 0xD9, 0x29, 0x25, 0xDB, 0xBC, 0x1A, 0xB9, 0x61, + 0xB9, 0x52, 0xFA, 0x82, 0xB7, 0x18, 0x51, 0xDA, + 0xCE, 0xCE, 0xCE, 0x66, 0x68, 0x73, 0x38, 0x46, + 0x62, 0x57, 0xCD, 0x5C, 0xBE, 0x3D, 0xEB, 0xF2, + 0x79, 0x2C, 0xAE, 0x9E, 0x54, 0x09, 0xC0, 0xDA, + 0x1B, 0x95, 0xF5, 0xBE, 0xEC, 0x0C, 0x21, 0x5D + }, + { + 0xD0, 0x1E, 0xE8, 0xC4, 0x5C, 0xF4, 0xDD, 0x0B, + 0xE6, 0x1E, 0x45, 0xC9, 0x9C, 0x60, 0xDC, 0xEB, + 0x6A, 0xCC, 0x48, 0x58, 0x75, 0xD7, 0x34, 0x7A, + 0x6A, 0xAA, 0xC1, 0x5B, 0x0E, 0xE6, 0x80, 0x29, + 0x49, 0xC2, 0x2D, 0x7B, 0xB5, 0x0B, 0x1A, 0x78, + 0xF7, 0xB5, 0x3E, 0xE7, 0x5F, 0x2C, 0x50, 0x73, + 0x2D, 0xE3, 0x0E, 0xD6, 0xA1, 0x3C, 0xBF, 0x61, + 0x44, 0x43, 0xDE, 0x7E, 0xB8, 0x62, 0x40, 0x98 + }, + { + 0x73, 0xF8, 0x03, 0x41, 0x11, 0x9A, 0xF5, 0xD1, + 0xB8, 0xAB, 0xA6, 0xDF, 0x0C, 0xC3, 0x2D, 0x8F, + 0x46, 0xF4, 0xA1, 0x14, 0x3C, 0xBC, 0xDA, 0x65, + 0xE1, 0x19, 0x03, 0xF5, 0x70, 0xB1, 0x77, 0xFF, + 0x57, 0x24, 0xA9, 0xFD, 0xA5, 0x1D, 0xB6, 0x50, + 0x14, 0x52, 0x39, 0xD3, 0x91, 0xE1, 0x5E, 0x99, + 0xF1, 0x57, 0xBC, 0x09, 0xD6, 0x83, 0x93, 0x08, + 0xDF, 0x13, 0xDB, 0x9C, 0xB2, 0xB6, 0x5D, 0x73 + }, + { + 0x6F, 0xC1, 0xBA, 0x35, 0x80, 0xDD, 0x53, 0x6A, + 0xB0, 0x98, 0x42, 0xAD, 0x1F, 0x83, 0x96, 0x22, + 0x33, 0x1B, 0x07, 0x9C, 0x5A, 0x7B, 0x45, 0xD8, + 0x6D, 0x0E, 0x68, 0x16, 0x7D, 0x29, 0xB6, 0x95, + 0xF3, 0x45, 0x83, 0x0D, 0x5E, 0x90, 0xC4, 0xA6, + 0xB0, 0xBB, 0x12, 0x19, 0x84, 0x9F, 0xF0, 0x26, + 0x14, 0xC7, 0xB6, 0xAB, 0x69, 0x03, 0x49, 0x40, + 0x44, 0x89, 0xF1, 0x23, 0xC1, 0x36, 0xC2, 0x9C + }, + { + 0xE5, 0xA8, 0xF4, 0x26, 0x07, 0xEB, 0xED, 0xF4, + 0xCE, 0x71, 0x81, 0x48, 0x78, 0xEA, 0x57, 0x97, + 0xE0, 0x9B, 0x03, 0xEF, 0xA8, 0x91, 0xF2, 0x4F, + 0x6E, 0x95, 0x12, 0x15, 0xAF, 0xB6, 0xD8, 0x3F, + 0x10, 0x50, 0x2E, 0xF3, 0x6F, 0x28, 0xCE, 0x20, + 0x16, 0x05, 0xEA, 0x02, 0x0B, 0x13, 0x5E, 0x7C, + 0xE3, 0x21, 0x02, 0xED, 0x9F, 0xE7, 0xE0, 0xBA, + 0xAB, 0xA5, 0xBE, 0x2A, 0x89, 0xF5, 0x40, 0x33 + }, + { + 0x42, 0x03, 0xC9, 0xD5, 0x8A, 0x1A, 0xD0, 0x09, + 0xEC, 0xCE, 0x92, 0xCC, 0x04, 0x4B, 0xEB, 0x04, + 0x1A, 0x76, 0x0C, 0x8E, 0x58, 0x9F, 0xFE, 0x20, + 0x74, 0x09, 0xC7, 0x3B, 0xDF, 0x34, 0x29, 0xDB, + 0x4E, 0xEB, 0x28, 0x1B, 0x7B, 0x43, 0x4E, 0xF2, + 0x46, 0x73, 0x90, 0x7B, 0x59, 0x3D, 0x2C, 0x13, + 0x5D, 0x5A, 0xE8, 0x48, 0x7D, 0xCD, 0x28, 0x45, + 0xAC, 0xF1, 0x90, 0x69, 0x3C, 0x6D, 0xC0, 0x43 + }, + { + 0xD4, 0x98, 0x6C, 0xA7, 0x0D, 0x55, 0x41, 0x5F, + 0x8E, 0x81, 0x63, 0x00, 0x4D, 0xDC, 0xB3, 0x2A, + 0x73, 0xDB, 0x75, 0x4D, 0x49, 0xFA, 0x6A, 0x5C, + 0x9A, 0xB7, 0x58, 0x31, 0x47, 0xDE, 0xE2, 0x78, + 0x32, 0x06, 0x89, 0x0C, 0xE3, 0x79, 0x17, 0x84, + 0x06, 0xAC, 0x86, 0x9D, 0xE0, 0x73, 0x8F, 0x28, + 0xF5, 0xE5, 0x81, 0x0B, 0xEE, 0x0A, 0xA0, 0xD8, + 0xD2, 0x87, 0x8B, 0x29, 0xB1, 0x49, 0x75, 0xB9 + }, + { + 0x4B, 0x1E, 0x5E, 0x1E, 0x6C, 0x62, 0xFA, 0xB5, + 0x14, 0x03, 0xB2, 0xE0, 0x46, 0xC3, 0xE7, 0x0C, + 0xBA, 0x02, 0xCB, 0x18, 0x93, 0x0F, 0x50, 0xE0, + 0xAD, 0xDB, 0x2E, 0xDA, 0xC4, 0xD2, 0x10, 0x90, + 0xA8, 0x4E, 0x2F, 0xD3, 0xB0, 0x7F, 0x43, 0x33, + 0xC7, 0xA4, 0x66, 0x07, 0xB7, 0x54, 0x8E, 0x71, + 0xE7, 0x70, 0xE2, 0x12, 0x26, 0x8D, 0xAD, 0x14, + 0x4C, 0xCD, 0xF2, 0xE8, 0x95, 0x97, 0x9C, 0xF1 + }, + { + 0x54, 0x96, 0xF3, 0xB0, 0x80, 0x3C, 0x1B, 0x43, + 0xE2, 0x72, 0x82, 0x95, 0x19, 0xD9, 0x82, 0x69, + 0xE0, 0xCA, 0xBB, 0xD4, 0xC4, 0x7C, 0x7B, 0xBE, + 0x4E, 0xEA, 0x4B, 0xAA, 0x87, 0xF6, 0xB8, 0x3E, + 0xDB, 0x5F, 0x31, 0x2C, 0x75, 0xC8, 0x2A, 0xBE, + 0x85, 0xE3, 0x7B, 0xB3, 0xE7, 0x86, 0x47, 0xF9, + 0x30, 0xF4, 0x87, 0x65, 0x49, 0x78, 0xE1, 0xC8, + 0xD4, 0x97, 0x62, 0xB4, 0x9E, 0x7B, 0x1D, 0x00 + }, + { + 0xBF, 0xA0, 0xA2, 0xA5, 0x6C, 0x88, 0x0C, 0x2B, + 0x71, 0x04, 0x95, 0x5C, 0x83, 0x9C, 0xE7, 0x8B, + 0x5A, 0xFE, 0xA6, 0x08, 0xBD, 0xD0, 0x32, 0xE6, + 0x5C, 0xA4, 0x31, 0xA3, 0x28, 0xC7, 0x51, 0x7A, + 0x0F, 0x76, 0x73, 0x82, 0x75, 0x32, 0xF1, 0x63, + 0xE3, 0xC7, 0xB5, 0x5E, 0x1E, 0x78, 0xA7, 0x25, + 0x1B, 0xCA, 0xB0, 0x34, 0x0E, 0x3D, 0x4D, 0xDC, + 0x99, 0xD1, 0x24, 0x58, 0xB0, 0x8D, 0xE0, 0xEF + }, + { + 0x07, 0x1A, 0x6D, 0x22, 0xAB, 0x54, 0x35, 0x7F, + 0x6A, 0x2B, 0x50, 0x70, 0xC3, 0x36, 0xAA, 0x45, + 0x02, 0xC3, 0x9C, 0x5D, 0x67, 0xC8, 0x71, 0x71, + 0x68, 0x9F, 0x53, 0xD4, 0x55, 0x2E, 0x4C, 0xB0, + 0xC6, 0x8A, 0xDA, 0x09, 0xEF, 0x98, 0x4E, 0xD7, + 0xAF, 0x0B, 0x8E, 0x18, 0x75, 0xC1, 0xBD, 0xA5, + 0x43, 0x2E, 0x08, 0x2D, 0xEA, 0x26, 0xF4, 0x17, + 0x0E, 0x3E, 0xA0, 0xD9, 0x99, 0xDF, 0x3C, 0xCF + }, + { + 0xDA, 0x7F, 0x6E, 0x68, 0x01, 0x10, 0x84, 0xB8, + 0x5B, 0xB4, 0x53, 0x70, 0x8E, 0xF3, 0xA2, 0xA1, + 0xA3, 0x08, 0xD8, 0x60, 0x4A, 0xCA, 0x22, 0x42, + 0xB9, 0xD8, 0xD7, 0x59, 0x88, 0x49, 0x69, 0x14, + 0xF0, 0x29, 0x82, 0x68, 0xB2, 0x54, 0x33, 0xE8, + 0xE7, 0x8C, 0x6A, 0xE4, 0x79, 0x0F, 0x49, 0x85, + 0xCB, 0x0A, 0xD8, 0x22, 0x8E, 0x7E, 0x1E, 0x0F, + 0x01, 0xD3, 0x3C, 0x09, 0x41, 0x91, 0x70, 0xF1 + }, + { + 0xA7, 0xA0, 0xD2, 0xF2, 0x71, 0x66, 0x24, 0x4D, + 0xD8, 0x63, 0xD5, 0x32, 0x5D, 0x11, 0xDD, 0xDC, + 0xAC, 0xF9, 0xE0, 0xE7, 0xDD, 0x3B, 0x3E, 0xAC, + 0x78, 0xD7, 0xB3, 0x2E, 0xDC, 0xFB, 0x8D, 0x2F, + 0xED, 0xAA, 0xC6, 0x66, 0xDD, 0x9A, 0x68, 0x26, + 0xC7, 0xF6, 0x89, 0x8D, 0x61, 0x98, 0xDB, 0xD5, + 0xFC, 0xF4, 0x74, 0x62, 0xDA, 0x95, 0x5A, 0xAE, + 0x48, 0x1A, 0x9C, 0x51, 0xA7, 0x7A, 0x3F, 0x75 + }, + { + 0x36, 0xB0, 0xF5, 0x69, 0x9F, 0x03, 0x79, 0xBF, + 0x8D, 0x77, 0x2E, 0x96, 0xDA, 0x9A, 0x19, 0xED, + 0x29, 0x87, 0x06, 0x6C, 0x80, 0x1E, 0x0B, 0x28, + 0x1C, 0xA7, 0x7A, 0x77, 0x8E, 0x6A, 0xE5, 0x1B, + 0x2D, 0x5E, 0x04, 0xA8, 0xEF, 0xC4, 0xE0, 0x2C, + 0x85, 0x39, 0x62, 0xCC, 0x6B, 0x15, 0x56, 0xB3, + 0x27, 0xBF, 0x04, 0x79, 0xFE, 0xFE, 0xAA, 0xDF, + 0xDC, 0x5D, 0xD3, 0xB8, 0x23, 0x79, 0xDC, 0xC4 + }, + { + 0xA8, 0x09, 0xA4, 0x11, 0x47, 0x8C, 0xFF, 0x8F, + 0x9E, 0x57, 0x14, 0xFC, 0x02, 0xF5, 0x8C, 0xA8, + 0x56, 0x82, 0xE5, 0xB1, 0x12, 0x80, 0x5E, 0x47, + 0xD7, 0xCF, 0x6D, 0x04, 0x8A, 0x6C, 0x03, 0xA8, + 0x0C, 0x91, 0xEF, 0xA6, 0xDE, 0xF7, 0x5A, 0x12, + 0xB4, 0x16, 0xA8, 0x97, 0x6B, 0x85, 0x35, 0x4D, + 0x96, 0xB9, 0x6B, 0x7C, 0x0B, 0x50, 0x17, 0x2F, + 0x66, 0x50, 0x58, 0xE9, 0xEB, 0xFD, 0xB4, 0x35 + }, + { + 0x84, 0x82, 0xB5, 0xE8, 0x18, 0x4B, 0x05, 0x81, + 0xC3, 0xE7, 0xE3, 0x06, 0xB4, 0x9F, 0x55, 0x3A, + 0x5B, 0x69, 0x97, 0x68, 0x18, 0x5D, 0x62, 0x62, + 0x9D, 0xDB, 0xB7, 0x26, 0x36, 0xBB, 0x89, 0x72, + 0xA9, 0x12, 0x55, 0xE6, 0x3C, 0xA5, 0x9F, 0x64, + 0xBB, 0x79, 0xFA, 0x9E, 0x92, 0x69, 0x16, 0xEE, + 0x59, 0x54, 0xD0, 0xB7, 0xD2, 0x35, 0x06, 0x07, + 0x1F, 0xB8, 0x89, 0x00, 0x65, 0x0C, 0xBE, 0x47 + }, + { + 0x25, 0x1F, 0xA0, 0xB4, 0xCA, 0x9F, 0x63, 0x60, + 0xC9, 0xE4, 0x94, 0x6E, 0xB1, 0x73, 0x77, 0x4E, + 0xB9, 0xCC, 0x06, 0x1C, 0xF3, 0x20, 0x44, 0x1F, + 0x5C, 0x3B, 0x2B, 0xAE, 0xFE, 0xA5, 0x57, 0xAA, + 0x53, 0x63, 0x8D, 0xF1, 0x27, 0x77, 0x01, 0x5A, + 0xB7, 0x41, 0x32, 0x2C, 0xC8, 0x5A, 0xD1, 0xE8, + 0x5A, 0x6A, 0x99, 0xF4, 0x7E, 0x96, 0x98, 0x7F, + 0xE3, 0xC2, 0x2C, 0x1E, 0x19, 0xBF, 0xB8, 0x85 + }, + { + 0x2A, 0x6A, 0xD7, 0xC9, 0x4B, 0x96, 0x64, 0xFE, + 0x43, 0x7F, 0x8B, 0xB6, 0x63, 0x07, 0x47, 0xA2, + 0x8B, 0xB8, 0x09, 0xAD, 0xE8, 0xF8, 0x68, 0x41, + 0x9D, 0xE0, 0x0C, 0x02, 0x2C, 0x5E, 0xA2, 0xC3, + 0x21, 0x15, 0xB3, 0x29, 0xE7, 0x17, 0xA3, 0x69, + 0x19, 0xFC, 0xA5, 0x1A, 0x90, 0x99, 0x53, 0x47, + 0x41, 0xBC, 0xBA, 0x72, 0x20, 0x70, 0x06, 0xCC, + 0x3E, 0x34, 0xBA, 0xFD, 0x39, 0x02, 0xC9, 0x0F + }, + { + 0xBC, 0x2D, 0x03, 0xDB, 0x1C, 0x00, 0x42, 0x32, + 0xFC, 0x13, 0x5D, 0x1F, 0x89, 0xFA, 0x2C, 0x6A, + 0x2F, 0x4E, 0x3B, 0x94, 0x1B, 0x17, 0xA4, 0x29, + 0xD4, 0x63, 0x4A, 0x0C, 0x1F, 0x31, 0xB6, 0x49, + 0xD4, 0xC9, 0x14, 0x89, 0xD2, 0x6D, 0x66, 0x2C, + 0x1D, 0xA1, 0xF8, 0xF1, 0xE1, 0xB6, 0x76, 0xA7, + 0x87, 0xDE, 0x27, 0xFB, 0x1A, 0xE8, 0x1D, 0x76, + 0x6D, 0x3B, 0xB6, 0xE4, 0x67, 0x6D, 0x49, 0x85 + }, + { + 0xBB, 0x7E, 0xFA, 0x4E, 0xAD, 0x11, 0xEA, 0xB7, + 0x52, 0x54, 0x45, 0xD8, 0x02, 0x1B, 0x41, 0x44, + 0x9A, 0xCC, 0xC3, 0x6F, 0xFB, 0x33, 0xBE, 0x79, + 0xB6, 0x67, 0xCE, 0x56, 0xE6, 0x65, 0x93, 0x33, + 0x72, 0x61, 0x01, 0x5F, 0x68, 0x1E, 0xB8, 0x47, + 0xD4, 0xBA, 0x1F, 0x32, 0x65, 0x34, 0x6B, 0xF2, + 0x03, 0xE7, 0x56, 0x6E, 0xB0, 0xE2, 0xEB, 0x4C, + 0x6F, 0x7A, 0x13, 0xB2, 0x66, 0xDA, 0x06, 0xE6 + }, + { + 0xE7, 0x56, 0xC5, 0x2E, 0x8D, 0x75, 0x4A, 0x2F, + 0x55, 0xA3, 0x59, 0x9E, 0x1A, 0x74, 0xA6, 0x7A, + 0xE6, 0xAB, 0xC8, 0xAA, 0xC4, 0x73, 0x69, 0x67, + 0x85, 0x84, 0x39, 0xA0, 0x7C, 0x37, 0x7E, 0xF9, + 0x9A, 0x67, 0x1F, 0xFC, 0xBD, 0x0B, 0xC4, 0x2C, + 0x9A, 0x28, 0x56, 0x07, 0xE9, 0xAB, 0x2F, 0xEE, + 0x8F, 0x20, 0x6D, 0x78, 0xE6, 0x0F, 0x3D, 0x8F, + 0x74, 0x5A, 0xE5, 0x5C, 0x0D, 0x97, 0x03, 0x3B + }, + { + 0xB7, 0xDD, 0xA7, 0xCA, 0xA7, 0x53, 0x06, 0x6F, + 0xD5, 0x9A, 0xBB, 0x8B, 0x46, 0x40, 0x7B, 0x91, + 0x67, 0xA3, 0x35, 0xA2, 0x23, 0x8E, 0x26, 0xAF, + 0x64, 0xED, 0xB7, 0xB1, 0xAA, 0x2F, 0xD7, 0x74, + 0xFF, 0xA2, 0x5F, 0x19, 0xF6, 0xB7, 0x50, 0x9C, + 0xF4, 0xB5, 0xFF, 0x82, 0x3B, 0x86, 0x2A, 0x90, + 0x98, 0x7F, 0x7A, 0x3B, 0x6D, 0xF9, 0xD2, 0x10, + 0x60, 0x95, 0x8B, 0x34, 0x0A, 0x04, 0xEC, 0x62 + }, + { + 0x9D, 0xD3, 0x0D, 0xBB, 0x9E, 0x1C, 0x41, 0xE1, + 0xE6, 0xB4, 0x04, 0xD6, 0xF3, 0xA1, 0x49, 0xFF, + 0xDA, 0x11, 0x9E, 0x6D, 0xE3, 0x06, 0xF2, 0x47, + 0x79, 0x0F, 0x5F, 0xB2, 0xF3, 0xAF, 0x4C, 0x86, + 0x8B, 0x3F, 0xB3, 0x02, 0x94, 0x8D, 0x9D, 0x57, + 0xC9, 0xBD, 0x34, 0xD6, 0x13, 0x95, 0x38, 0xCA, + 0x58, 0x70, 0x91, 0x77, 0xDC, 0x96, 0x19, 0x0E, + 0x98, 0xCC, 0x26, 0x89, 0xF9, 0xFE, 0xC3, 0xEF + }, + { + 0x74, 0xCB, 0xA5, 0x14, 0xDF, 0xBF, 0xE1, 0x19, + 0x4F, 0xBE, 0x3D, 0x7B, 0x51, 0x03, 0xCA, 0x6A, + 0x5E, 0x6C, 0x98, 0xE0, 0x51, 0x3D, 0x72, 0x98, + 0x6D, 0x21, 0xE1, 0x85, 0x9A, 0x03, 0xEF, 0x5F, + 0x56, 0xBA, 0xC3, 0x07, 0xCE, 0x8E, 0x76, 0xFF, + 0x56, 0x96, 0x29, 0x16, 0x22, 0x79, 0x4A, 0xBB, + 0x3F, 0xBF, 0x2A, 0x4E, 0x81, 0x02, 0x07, 0x9C, + 0x39, 0x88, 0xA3, 0x38, 0xE6, 0xB8, 0x52, 0xE3 + }, + { + 0x9C, 0xBB, 0x97, 0xEA, 0x5D, 0xD1, 0xB2, 0xF3, + 0x2C, 0x18, 0x71, 0xE1, 0xBA, 0x50, 0x0F, 0xB6, + 0x49, 0x4A, 0x4E, 0x12, 0xD7, 0x6A, 0x13, 0x2E, + 0xFE, 0x58, 0xB4, 0xB4, 0x0D, 0x97, 0x32, 0xE6, + 0x77, 0x6E, 0x22, 0x41, 0x5A, 0x79, 0xFC, 0x41, + 0xEA, 0x48, 0x64, 0x5B, 0xC9, 0xF4, 0x51, 0x49, + 0xB4, 0xD6, 0x17, 0x50, 0xDD, 0xED, 0x6E, 0x95, + 0x11, 0x95, 0xF9, 0x4B, 0x7C, 0x4E, 0xC0, 0x1D + }, + { + 0x52, 0xE9, 0xB9, 0x77, 0x13, 0xC8, 0x6C, 0xA3, + 0x43, 0x1F, 0x73, 0x57, 0x3F, 0x26, 0x7C, 0xED, + 0x03, 0xB9, 0x20, 0x61, 0xA0, 0x9D, 0x8A, 0x10, + 0x51, 0xFE, 0x08, 0x3C, 0xBA, 0x0F, 0x5F, 0xF4, + 0x8A, 0x29, 0xBE, 0x16, 0x57, 0x1E, 0x5B, 0xC6, + 0x50, 0x76, 0x84, 0xC3, 0x5D, 0xD6, 0x3D, 0x90, + 0xBF, 0x38, 0x17, 0x98, 0xA8, 0xF3, 0xF5, 0x44, + 0xD9, 0xCB, 0x1E, 0x7B, 0x07, 0x77, 0xF9, 0x84 + }, + { + 0x3C, 0x92, 0x20, 0x1C, 0xFA, 0x16, 0xCA, 0x85, + 0xAE, 0xB1, 0x9F, 0x31, 0x19, 0xB5, 0x37, 0xA7, + 0xB3, 0x97, 0xE0, 0x50, 0x58, 0x44, 0x8B, 0x79, + 0x98, 0x1C, 0xF0, 0x2B, 0xED, 0x32, 0x98, 0x9B, + 0x4C, 0x53, 0xA7, 0xDA, 0x43, 0x19, 0x94, 0x68, + 0xC9, 0xEF, 0x37, 0x0D, 0x29, 0x2E, 0xA9, 0xAF, + 0x09, 0xCF, 0x99, 0x12, 0xAA, 0x23, 0x34, 0x16, + 0x34, 0xED, 0x82, 0xE9, 0xD2, 0xF4, 0xBF, 0x96 + }, + { + 0x8A, 0xC9, 0xF2, 0xD3, 0x93, 0xB4, 0xF3, 0xF6, + 0xCF, 0x46, 0xBC, 0xAE, 0x5D, 0xA1, 0xBE, 0x8A, + 0x52, 0x99, 0x0A, 0xCC, 0xFA, 0x56, 0xA8, 0x6A, + 0xB4, 0xB8, 0x1E, 0xD3, 0x9D, 0xE7, 0x17, 0x59, + 0xA5, 0xD1, 0x8B, 0x65, 0x33, 0x92, 0x72, 0x6B, + 0x13, 0x4D, 0x52, 0xE6, 0x80, 0x69, 0x31, 0x8D, + 0xBB, 0xDF, 0xEA, 0x0A, 0x9D, 0x2E, 0xFF, 0x25, + 0x01, 0x81, 0x5B, 0x48, 0xCA, 0x04, 0xDA, 0x7C + }, + { + 0x23, 0xD5, 0x05, 0xE5, 0x24, 0x66, 0xDE, 0x60, + 0xA1, 0x66, 0xD1, 0x39, 0x7E, 0x84, 0x56, 0x1D, + 0xBD, 0x3B, 0x19, 0x2D, 0x9F, 0x7E, 0x02, 0x81, + 0xDD, 0x29, 0xC5, 0x79, 0xC0, 0xED, 0xF1, 0x9F, + 0x84, 0x69, 0x62, 0xC7, 0x2B, 0xAA, 0xCF, 0x5D, + 0x38, 0x98, 0x70, 0x8F, 0xCD, 0xFD, 0x95, 0xD6, + 0xFE, 0x9A, 0x48, 0xCC, 0xBE, 0xC8, 0x80, 0x8A, + 0x89, 0xAC, 0x29, 0xC0, 0xD6, 0x9B, 0xDE, 0x91 + }, + { + 0x20, 0xCA, 0x4C, 0x55, 0x2B, 0xA8, 0xAE, 0xD2, + 0x63, 0x13, 0x21, 0xEC, 0xD1, 0xFD, 0x96, 0x20, + 0xB0, 0x5F, 0x9B, 0x54, 0x1A, 0xAB, 0x45, 0x7F, + 0x04, 0x43, 0x6D, 0x6E, 0x2E, 0xA0, 0xE9, 0xDF, + 0x9E, 0xE4, 0xA9, 0xD5, 0x7C, 0x34, 0x77, 0x15, + 0xD2, 0xC6, 0xD5, 0x53, 0x22, 0xA0, 0x55, 0x4A, + 0x09, 0x35, 0x8E, 0xA8, 0x67, 0x39, 0xCB, 0x9D, + 0x93, 0x9B, 0xC4, 0x5C, 0x12, 0x00, 0x48, 0x38 + }, + { + 0xD4, 0x24, 0x35, 0xAC, 0x8F, 0xE8, 0x49, 0x6D, + 0x2C, 0x28, 0x80, 0xDA, 0xCD, 0x2E, 0x07, 0x56, + 0xB5, 0xE9, 0xC0, 0xAC, 0x85, 0xE1, 0x6E, 0x66, + 0x02, 0xA7, 0x5B, 0xB3, 0x06, 0xFD, 0x69, 0xE4, + 0x06, 0x73, 0xDB, 0x54, 0x84, 0x38, 0x2E, 0x7D, + 0xD0, 0x44, 0x40, 0x4C, 0xAD, 0x4F, 0x86, 0x7E, + 0x57, 0x92, 0xBF, 0x6D, 0x4A, 0x50, 0x51, 0xB3, + 0x59, 0x8A, 0x12, 0x67, 0x7F, 0x82, 0x81, 0x84 + }, + { + 0x44, 0x28, 0x01, 0x43, 0x15, 0x03, 0x6F, 0xC7, + 0x7A, 0x90, 0x2E, 0xB5, 0x70, 0x36, 0x0E, 0x72, + 0x75, 0x0D, 0x14, 0xDA, 0xDA, 0x84, 0x12, 0x27, + 0x86, 0x91, 0xEB, 0xA1, 0x36, 0x64, 0xD6, 0x44, + 0x8B, 0x70, 0x71, 0xD6, 0x26, 0xEB, 0xF8, 0x37, + 0xE7, 0xE6, 0x15, 0x83, 0x9A, 0x76, 0x88, 0x60, + 0x63, 0x31, 0xB2, 0xDB, 0x3F, 0x17, 0x6D, 0xB8, + 0xE9, 0xFE, 0x8D, 0xF1, 0x35, 0x9B, 0xEC, 0x96 + }, + { + 0xCB, 0xAF, 0xBD, 0x7A, 0x76, 0x73, 0x2E, 0x80, + 0x42, 0x80, 0x70, 0xDB, 0xA7, 0x22, 0xE3, 0x2A, + 0xE9, 0x00, 0xA1, 0x53, 0x11, 0x4F, 0x41, 0x45, + 0xC4, 0x18, 0x70, 0x3A, 0x53, 0x61, 0xF6, 0x08, + 0x53, 0x28, 0xDA, 0xA2, 0xA4, 0xD0, 0x1A, 0x7D, + 0x9F, 0xAF, 0xDF, 0xBF, 0xB6, 0xC1, 0xF1, 0x3F, + 0x77, 0x90, 0x0E, 0xAC, 0x3A, 0xCD, 0x48, 0xA4, + 0xE9, 0x9E, 0xAD, 0xBA, 0x5D, 0x59, 0xA5, 0x27 + }, + { + 0xEC, 0x12, 0xD0, 0x0B, 0x15, 0xB6, 0xFE, 0x9A, + 0xA5, 0x4D, 0xB3, 0xF6, 0x8C, 0x8F, 0xF2, 0x38, + 0x63, 0x08, 0x17, 0x0E, 0x77, 0x64, 0xD8, 0x60, + 0x45, 0x74, 0x83, 0x0C, 0x5C, 0xD3, 0xC3, 0xC0, + 0x05, 0xEB, 0x06, 0x12, 0xD2, 0xFE, 0xC4, 0xF0, + 0xBF, 0xEE, 0x4F, 0x0E, 0x19, 0x3A, 0x4E, 0x09, + 0x32, 0x04, 0x84, 0x4D, 0x10, 0x6A, 0x61, 0xFB, + 0xCA, 0x15, 0x60, 0xBF, 0xE3, 0xE3, 0xC9, 0x1C + }, + { + 0xEC, 0xF7, 0xA9, 0x56, 0xDC, 0x3F, 0xCD, 0x3B, + 0xF7, 0x4F, 0x64, 0xFC, 0x74, 0x18, 0xFD, 0xF9, + 0x68, 0x7C, 0x4F, 0xCC, 0x29, 0xB9, 0x53, 0x8D, + 0xB5, 0x03, 0x82, 0x27, 0xF3, 0x1B, 0x5E, 0xDC, + 0x52, 0x4E, 0xA6, 0x77, 0x2E, 0x12, 0x10, 0x04, + 0x0F, 0x4B, 0xD7, 0x82, 0xB1, 0xD3, 0x60, 0x79, + 0x76, 0xD1, 0x96, 0x8B, 0x54, 0x1D, 0xDB, 0x9A, + 0xF8, 0xED, 0xE4, 0x69, 0x71, 0x63, 0x69, 0xDF + }, + { + 0x92, 0x96, 0x94, 0x32, 0x14, 0x9A, 0x65, 0xA9, + 0x4B, 0x40, 0x17, 0xD3, 0x9E, 0x75, 0x3A, 0x0A, + 0xD0, 0x75, 0x46, 0xCB, 0x55, 0xA2, 0xE7, 0xAA, + 0x2D, 0x40, 0x29, 0x51, 0x95, 0x60, 0x67, 0xEC, + 0x6C, 0x46, 0xF8, 0x68, 0xAC, 0x65, 0xCA, 0x40, + 0x0A, 0xA0, 0xDF, 0x45, 0xFB, 0x62, 0xB5, 0xC3, + 0x1C, 0x35, 0x77, 0x87, 0xC3, 0x51, 0x45, 0x61, + 0xA7, 0x68, 0xD0, 0x8E, 0xBD, 0xE7, 0xD3, 0xAD + }, + { + 0x91, 0x4E, 0x9C, 0xE2, 0x7C, 0xF9, 0xB6, 0x73, + 0xCC, 0x5B, 0x32, 0x8B, 0xA2, 0x9E, 0x44, 0xEF, + 0x04, 0x73, 0x64, 0xBA, 0x86, 0x83, 0xB0, 0x70, + 0xF4, 0x9A, 0x28, 0xB3, 0x5A, 0xCB, 0xA7, 0xFF, + 0xB2, 0x86, 0x87, 0xBD, 0x65, 0x4F, 0x58, 0x16, + 0x81, 0xE7, 0x14, 0x43, 0x3B, 0x5D, 0x22, 0xC1, + 0x8E, 0xA6, 0xBC, 0x7C, 0xFB, 0xF1, 0xCC, 0xF2, + 0x5A, 0x7D, 0x14, 0xE7, 0xF3, 0x35, 0xB7, 0xFD + }, + { + 0x2B, 0xC2, 0xDB, 0xDC, 0xB6, 0xC7, 0xB2, 0xA7, + 0x86, 0x91, 0xF5, 0xD6, 0xDC, 0xF1, 0x8C, 0x45, + 0x81, 0x2B, 0x9F, 0x31, 0x0E, 0x05, 0xD3, 0xEC, + 0x94, 0x2B, 0x1B, 0x71, 0x25, 0xFF, 0x88, 0x08, + 0xC5, 0x9F, 0x23, 0x26, 0xA0, 0x0C, 0x06, 0xF9, + 0x0E, 0x8A, 0x8C, 0x0E, 0xD4, 0x8E, 0xAD, 0x33, + 0x0A, 0x9C, 0x21, 0xE5, 0x02, 0x5E, 0x51, 0xF7, + 0x84, 0x55, 0xB8, 0x7F, 0x21, 0x6B, 0xD8, 0x53 + }, + { + 0xCC, 0x84, 0xB6, 0xDE, 0x11, 0xEA, 0x6E, 0xC7, + 0x2F, 0x0E, 0xF6, 0x81, 0xCB, 0x4A, 0xF3, 0x4B, + 0x3C, 0x19, 0x63, 0xA9, 0x9E, 0x4A, 0xD5, 0x04, + 0x49, 0x71, 0x5F, 0x82, 0xA7, 0xD0, 0x72, 0xDD, + 0xCD, 0x11, 0x55, 0x0D, 0x6F, 0x8C, 0x73, 0x02, + 0x61, 0x23, 0x04, 0x34, 0x18, 0xC9, 0x00, 0x25, + 0x4E, 0x8A, 0xD6, 0x59, 0x75, 0x9B, 0x56, 0x6C, + 0xFB, 0x56, 0xD2, 0x4F, 0x0F, 0xBC, 0x12, 0xBA + }, + { + 0x6B, 0x26, 0xF0, 0xF3, 0xA5, 0xAD, 0xA6, 0x12, + 0xDF, 0x96, 0x75, 0x3A, 0xF5, 0xDE, 0xDA, 0x5F, + 0xF4, 0xE0, 0x11, 0x93, 0xA3, 0x26, 0x80, 0x5B, + 0xD0, 0xD5, 0x46, 0xB0, 0xEC, 0xA4, 0xC3, 0x7C, + 0xCD, 0xB5, 0x9E, 0x22, 0xD2, 0x94, 0x22, 0x4F, + 0xE5, 0x5C, 0x4A, 0xBD, 0xB1, 0x8C, 0x12, 0x0D, + 0xD9, 0xD1, 0x0B, 0x8F, 0x0F, 0xF5, 0xC6, 0xAA, + 0xBA, 0x7A, 0x2B, 0x01, 0x16, 0xBB, 0x3B, 0xB8 + }, + { + 0x5C, 0xC7, 0xF3, 0x0F, 0x6E, 0xDE, 0xA7, 0x18, + 0x08, 0xA9, 0xB5, 0x31, 0x89, 0xD6, 0xFD, 0x3F, + 0xBF, 0x70, 0xFA, 0xB7, 0xEC, 0x0C, 0x8F, 0xCB, + 0xEF, 0xE7, 0x15, 0x0E, 0xB2, 0x84, 0xC4, 0xA3, + 0x1C, 0xE0, 0xA3, 0x3F, 0x7E, 0x7B, 0x49, 0xB2, + 0xC1, 0x84, 0x4B, 0x3F, 0xD1, 0x81, 0xB8, 0xC0, + 0xED, 0x85, 0xD6, 0xC7, 0xF3, 0x44, 0xEE, 0xCB, + 0x61, 0x99, 0x87, 0x3F, 0x53, 0xDB, 0x27, 0x60 + }, + { + 0x3D, 0x61, 0x27, 0xA4, 0x4B, 0xFB, 0xA0, 0x9F, + 0x25, 0x0C, 0xB8, 0xC1, 0xA0, 0x90, 0x55, 0x37, + 0x84, 0x91, 0x2B, 0xB6, 0x84, 0xFB, 0x8E, 0x8B, + 0xEC, 0xC9, 0xB5, 0x37, 0xDC, 0xEA, 0x0F, 0x30, + 0x9A, 0xEE, 0xF5, 0x80, 0xF7, 0x3D, 0xE2, 0x88, + 0xC9, 0xE2, 0xAD, 0x48, 0xF8, 0x05, 0xEF, 0xF4, + 0x0E, 0xFE, 0x7B, 0xCD, 0xD1, 0x23, 0x58, 0x55, + 0x81, 0xC9, 0x5B, 0x1A, 0x2D, 0x2C, 0xF5, 0xDB + }, + { + 0xAA, 0x81, 0x59, 0xFF, 0xAA, 0x7A, 0xED, 0xB8, + 0xF9, 0xEB, 0x90, 0xEE, 0xBA, 0xCD, 0xE5, 0x2D, + 0x39, 0x31, 0x90, 0x97, 0x7F, 0x7B, 0x1E, 0x67, + 0xE0, 0xB3, 0x72, 0x34, 0x44, 0xC2, 0x46, 0x55, + 0xA5, 0x98, 0xAA, 0x5E, 0xBA, 0x9B, 0xB9, 0x34, + 0xA6, 0x25, 0x0D, 0x09, 0xA4, 0xB7, 0x70, 0x42, + 0x3C, 0x5E, 0x5D, 0xF0, 0xBF, 0x85, 0xC3, 0xD7, + 0xE6, 0xBF, 0x76, 0x96, 0x37, 0x60, 0xAF, 0x15 + }, + { + 0xB6, 0xC3, 0x3B, 0x2E, 0xE6, 0x1F, 0xAE, 0xFC, + 0x5C, 0x16, 0x94, 0x94, 0xFF, 0x06, 0x9D, 0x4F, + 0x46, 0xB0, 0x6E, 0x23, 0xA3, 0x79, 0xB3, 0x79, + 0x7A, 0x04, 0xDE, 0xE3, 0x7D, 0x72, 0xFB, 0x0C, + 0x62, 0x39, 0x67, 0x73, 0x04, 0xB4, 0xCE, 0xC6, + 0xB0, 0x06, 0xB9, 0xDE, 0xD5, 0x1F, 0xCB, 0xC9, + 0xCF, 0x84, 0xDB, 0xE2, 0x5A, 0xF3, 0x8C, 0x76, + 0x74, 0xE7, 0x5F, 0x3D, 0x9E, 0x0F, 0xB6, 0x79 + }, + { + 0x8F, 0xA9, 0xC8, 0x10, 0xFE, 0xFF, 0x2F, 0xEF, + 0x6D, 0x9B, 0x6E, 0x2F, 0x06, 0x58, 0xD2, 0xF5, + 0xF4, 0xDD, 0x75, 0xFC, 0x08, 0xEC, 0x14, 0x62, + 0x12, 0xAF, 0x61, 0x49, 0x96, 0xBC, 0x6A, 0x90, + 0x8C, 0xDB, 0xBE, 0xF1, 0x39, 0xE5, 0xC9, 0x38, + 0xE4, 0x9C, 0x10, 0xD2, 0xA0, 0xFA, 0xBE, 0x66, + 0xA6, 0xDD, 0x7A, 0x70, 0x53, 0x4C, 0x23, 0xD7, + 0xCC, 0x00, 0x1B, 0x03, 0x6D, 0x9C, 0xA9, 0x7E + }, + { + 0x0E, 0xE5, 0xB9, 0x74, 0x9D, 0x2F, 0xDA, 0x10, + 0x32, 0x7F, 0xA9, 0x96, 0x31, 0x71, 0x2C, 0x62, + 0x9E, 0xA4, 0x4B, 0xBB, 0x77, 0xF3, 0x4E, 0xF1, + 0x1E, 0xD5, 0x46, 0x85, 0xE1, 0xA9, 0xCB, 0x0E, + 0xD3, 0x03, 0x89, 0xB7, 0xF1, 0x16, 0x45, 0x45, + 0xFA, 0x70, 0x22, 0xC8, 0x23, 0xD4, 0x2C, 0x8D, + 0x1D, 0xE9, 0x72, 0xCD, 0xAB, 0x99, 0xA7, 0xB6, + 0x81, 0x5F, 0x10, 0x9B, 0x49, 0xCB, 0xBA, 0x87 + }, + { + 0x6B, 0x8A, 0xA3, 0xB3, 0xFE, 0x82, 0x46, 0x16, + 0xE1, 0x9C, 0xAB, 0xC5, 0xB9, 0xC4, 0x19, 0x45, + 0x70, 0x7C, 0x41, 0xFF, 0xD1, 0x5B, 0x17, 0x0A, + 0x2E, 0xC7, 0x25, 0x80, 0x44, 0x0D, 0xBA, 0x77, + 0x2F, 0x57, 0xE0, 0x70, 0x2F, 0x45, 0x01, 0x99, + 0xCD, 0xBD, 0x97, 0xBD, 0xA5, 0xD0, 0xEF, 0xF1, + 0x15, 0x4E, 0xC8, 0x08, 0x33, 0x71, 0x7F, 0x57, + 0x23, 0x33, 0xD4, 0xD7, 0xF9, 0x8B, 0x48, 0xCC + }, + { + 0xA9, 0x65, 0x90, 0x2B, 0xFC, 0xD4, 0x1F, 0x7A, + 0x7C, 0x16, 0xC1, 0xFE, 0x51, 0x4E, 0xAF, 0x52, + 0x3F, 0x0E, 0xD1, 0xAF, 0x12, 0x37, 0x05, 0xF9, + 0x89, 0xBE, 0x87, 0xCB, 0x22, 0xE8, 0x35, 0xC7, + 0x52, 0x72, 0x22, 0xAE, 0x56, 0x1F, 0xBB, 0x34, + 0x22, 0x99, 0xF3, 0x3F, 0x70, 0xBE, 0x3F, 0x6A, + 0xB2, 0x93, 0xBA, 0x86, 0x52, 0x51, 0x8C, 0xE3, + 0xFC, 0x95, 0x6C, 0x8C, 0xE3, 0x8D, 0x2F, 0x82 + }, + { + 0x73, 0x57, 0xBC, 0x22, 0xC1, 0x6A, 0xAF, 0xF1, + 0x70, 0x06, 0xD8, 0x00, 0xE3, 0xC1, 0x25, 0x50, + 0xB0, 0x3A, 0x78, 0xE8, 0xF0, 0x32, 0x28, 0x62, + 0x71, 0xE1, 0x70, 0x4D, 0xE7, 0x97, 0x20, 0x28, + 0xA8, 0xCF, 0x47, 0xEB, 0x9A, 0xF5, 0x34, 0x6A, + 0x80, 0x39, 0xF3, 0x4B, 0xE4, 0x6E, 0x83, 0xE4, + 0xAB, 0xAA, 0x23, 0x6F, 0x11, 0x9C, 0xD3, 0x70, + 0x56, 0x4A, 0x14, 0x16, 0xBB, 0x79, 0x51, 0x89 + }, + { + 0x7C, 0x15, 0x9C, 0xA9, 0x2E, 0xF1, 0xEB, 0x03, + 0xCA, 0x38, 0x52, 0xAF, 0x92, 0xF7, 0x7A, 0xA4, + 0xA4, 0x0F, 0x5F, 0xCD, 0x31, 0x1B, 0x90, 0x21, + 0x91, 0x9C, 0x06, 0x70, 0xEB, 0x20, 0x82, 0x8D, + 0xC4, 0xF2, 0x45, 0x7B, 0xA7, 0xA3, 0xD6, 0x8A, + 0x29, 0x7D, 0x63, 0x1A, 0xDF, 0xAC, 0x8C, 0xA0, + 0x36, 0x96, 0x7B, 0x41, 0xFF, 0xDB, 0xFC, 0x68, + 0x1C, 0xB7, 0x44, 0x68, 0x68, 0x5F, 0xFB, 0x1F + }, + { + 0x36, 0x86, 0xD5, 0x4A, 0x63, 0x0B, 0xB5, 0xBA, + 0xE2, 0xC1, 0x3C, 0x81, 0xAB, 0x8F, 0xF3, 0x2C, + 0x65, 0x8A, 0x8E, 0x88, 0x25, 0x91, 0x0D, 0xC7, + 0xED, 0x97, 0x37, 0x62, 0xE7, 0xEA, 0x38, 0x6C, + 0x6B, 0x61, 0xEE, 0xE1, 0x6A, 0xEE, 0x16, 0x87, + 0x18, 0x5C, 0x0A, 0xA8, 0xE2, 0x33, 0xAB, 0x7A, + 0xBC, 0xB4, 0x8F, 0x61, 0xEF, 0x91, 0xE0, 0xF1, + 0x48, 0xD1, 0x96, 0x51, 0xD4, 0xAF, 0x89, 0xFB + }, + { + 0x32, 0x53, 0x27, 0xB4, 0xC0, 0x5D, 0xA7, 0xF8, + 0xC4, 0x6D, 0x04, 0x5A, 0x92, 0xDA, 0xD4, 0xAD, + 0x1C, 0x8A, 0x5E, 0x69, 0x7F, 0xE6, 0x26, 0xF0, + 0x05, 0x6C, 0x09, 0xD0, 0xB4, 0x88, 0x66, 0x1C, + 0x94, 0x25, 0xA1, 0xC8, 0xDE, 0x5E, 0x8D, 0xDE, + 0x92, 0x04, 0x28, 0x27, 0xC1, 0x3E, 0xB9, 0x67, + 0xF9, 0xD7, 0xBA, 0x5D, 0xE4, 0xC6, 0x9F, 0xD5, + 0x75, 0xCE, 0x43, 0xCD, 0x94, 0xDC, 0x7D, 0x80 + }, + { + 0x0C, 0xB2, 0x5D, 0x17, 0x55, 0x4D, 0xDB, 0xC2, + 0x02, 0x5D, 0x5D, 0xD9, 0xE3, 0xAF, 0x41, 0x93, + 0xE0, 0x32, 0x41, 0x68, 0x86, 0x99, 0x13, 0x12, + 0xC0, 0x3E, 0xAE, 0x2E, 0xF0, 0x82, 0xC1, 0x53, + 0xF3, 0x85, 0x42, 0xC1, 0x9E, 0xF2, 0xB2, 0xD6, + 0xFC, 0xA5, 0xA4, 0xB2, 0xC9, 0x85, 0x9D, 0x59, + 0x17, 0xCA, 0xD0, 0xED, 0x22, 0xFB, 0x24, 0x1D, + 0x74, 0x32, 0x8B, 0xEB, 0xCC, 0x5A, 0xE4, 0x51 + }, + { + 0x58, 0xFA, 0x68, 0x36, 0x3F, 0x70, 0xF5, 0x36, + 0x8A, 0x24, 0x12, 0x44, 0x38, 0x2D, 0x51, 0xBA, + 0xAB, 0x8D, 0x93, 0x2A, 0x09, 0x9B, 0x6A, 0x22, + 0xA1, 0x07, 0xF8, 0xA3, 0x5E, 0x05, 0x67, 0x60, + 0xA0, 0x73, 0x0D, 0xF3, 0x5B, 0x0F, 0xD3, 0xAE, + 0x86, 0xDB, 0xBF, 0x47, 0x09, 0x26, 0xA3, 0x9D, + 0x3F, 0xE5, 0x93, 0xF2, 0x87, 0x6B, 0xF0, 0xA5, + 0x77, 0xDF, 0x6B, 0xDE, 0xA9, 0xAF, 0x8C, 0x22 + }, + { + 0xFD, 0x3B, 0xCB, 0x63, 0x32, 0x41, 0xD9, 0xB0, + 0x3B, 0xCE, 0x39, 0xBD, 0x02, 0x80, 0x6F, 0x75, + 0x63, 0x59, 0x03, 0xCA, 0x22, 0xFE, 0x89, 0x96, + 0x2C, 0xAF, 0xA3, 0xB5, 0xE9, 0xC2, 0xE3, 0x5B, + 0x75, 0xA8, 0x73, 0xA0, 0x7E, 0xDE, 0x8D, 0xA1, + 0xFC, 0x3E, 0x41, 0xB6, 0x90, 0xE8, 0xFE, 0xF7, + 0x76, 0x0B, 0xA8, 0x39, 0x87, 0x40, 0x99, 0x1D, + 0x9E, 0xFE, 0xE1, 0x61, 0x09, 0x1C, 0x5E, 0x13 + }, + { + 0x64, 0xB5, 0x68, 0x10, 0x02, 0x15, 0x32, 0xAD, + 0x12, 0x7A, 0x32, 0x8A, 0x4B, 0xED, 0x23, 0x17, + 0x54, 0xCA, 0xB2, 0x79, 0xE4, 0xE3, 0x08, 0x52, + 0xA2, 0x8D, 0x2A, 0xB0, 0xAC, 0xF0, 0x7B, 0xAF, + 0xF0, 0x8E, 0x2B, 0xDD, 0xE5, 0xF4, 0x46, 0x13, + 0xA8, 0xB1, 0x20, 0x42, 0x8B, 0x78, 0x92, 0xC1, + 0x7E, 0xEF, 0x45, 0x9F, 0x43, 0x73, 0xBE, 0x29, + 0xDC, 0x64, 0x3D, 0xF6, 0xE4, 0x74, 0xFF, 0x50 + }, + { + 0xFD, 0x19, 0x94, 0xC9, 0x40, 0x5C, 0x9A, 0xFA, + 0x75, 0xA5, 0xF4, 0x24, 0xBC, 0xE0, 0xEB, 0x7B, + 0xF0, 0xD4, 0x42, 0x43, 0xE6, 0xFF, 0x51, 0xD4, + 0xF7, 0x0E, 0x7D, 0x2C, 0xEF, 0xAF, 0x3C, 0xB6, + 0x31, 0xDB, 0x80, 0xE4, 0x0F, 0x7F, 0xD6, 0x55, + 0x09, 0x2C, 0xAD, 0xA7, 0x2D, 0xBF, 0x26, 0x4D, + 0xC7, 0x37, 0x27, 0x06, 0x03, 0xFB, 0x4D, 0xF3, + 0xE9, 0x8E, 0x8E, 0xBE, 0x2C, 0x85, 0xC7, 0x41 + }, + { + 0x12, 0xFA, 0x3C, 0xF0, 0x25, 0x3A, 0x2C, 0xFA, + 0xD5, 0xCF, 0x40, 0xC6, 0x25, 0x49, 0xCA, 0x6E, + 0x8F, 0xD4, 0xA5, 0xBA, 0x1A, 0x56, 0x29, 0xC9, + 0x3D, 0x94, 0x48, 0x7D, 0xE3, 0x05, 0x0B, 0xCD, + 0xCA, 0x4B, 0xA9, 0x52, 0x61, 0x27, 0x5F, 0xA1, + 0x05, 0xDE, 0x08, 0xB2, 0x08, 0x5B, 0xBA, 0x65, + 0xAD, 0x37, 0x51, 0xEC, 0xB2, 0x75, 0xA4, 0x86, + 0xAC, 0x3C, 0xA8, 0x2D, 0x42, 0x0C, 0xF3, 0xF9 + }, + { + 0x8F, 0x03, 0xD1, 0xB9, 0x8E, 0x9C, 0xA0, 0x8B, + 0xE2, 0x3F, 0xF1, 0x1C, 0x55, 0x65, 0x81, 0x80, + 0xBD, 0xD7, 0xEA, 0x51, 0x90, 0x00, 0x90, 0xD3, + 0xBA, 0x71, 0x16, 0x92, 0x2B, 0xC3, 0x5E, 0xD1, + 0x71, 0x6F, 0xFE, 0x28, 0xCB, 0x53, 0x15, 0x56, + 0x36, 0x85, 0x85, 0x72, 0x77, 0x6A, 0xA3, 0x6D, + 0x97, 0x2C, 0x09, 0x4B, 0x89, 0x6F, 0xBA, 0x3B, + 0xB2, 0x14, 0x96, 0xD7, 0xAD, 0x16, 0x90, 0x85 + }, + { + 0xD8, 0xC2, 0x68, 0xCA, 0x5C, 0x1D, 0xDA, 0x0F, + 0xA0, 0x0C, 0xA5, 0x63, 0x25, 0xC0, 0x0C, 0xF3, + 0x94, 0x15, 0xF3, 0xC3, 0xCA, 0xC6, 0x3E, 0x2C, + 0xE7, 0x6C, 0xD0, 0xFE, 0xCE, 0xE5, 0xC9, 0x58, + 0x1D, 0xEF, 0x34, 0x6F, 0x3C, 0x64, 0x77, 0x48, + 0xE8, 0xB1, 0xC1, 0xA4, 0x8E, 0x31, 0xE7, 0x48, + 0xF7, 0xC2, 0xF2, 0x92, 0x0D, 0x0B, 0xAB, 0xE9, + 0x05, 0x9C, 0xD0, 0xA7, 0xD8, 0x2D, 0x1D, 0x55 + }, + { + 0x25, 0x83, 0xB9, 0x05, 0x3C, 0x95, 0xFC, 0x96, + 0x09, 0xF7, 0xC3, 0x69, 0x77, 0x06, 0x8D, 0xBE, + 0xFC, 0x75, 0x7B, 0x4E, 0xAF, 0x02, 0x54, 0x59, + 0x96, 0x9B, 0xD5, 0x70, 0x49, 0x64, 0xE2, 0xD0, + 0x90, 0xAA, 0x13, 0xA4, 0x04, 0x74, 0x64, 0x82, + 0xF9, 0x45, 0xD1, 0x46, 0x4A, 0x85, 0xF3, 0x2C, + 0x00, 0x96, 0x7D, 0xC6, 0x3E, 0x4E, 0xBA, 0x25, + 0xC1, 0x78, 0x1C, 0x5B, 0xF8, 0x99, 0x29, 0x8C + }, + { + 0x82, 0xDD, 0x19, 0x7A, 0xC4, 0x45, 0x42, 0x0E, + 0xEF, 0x65, 0x0B, 0x0C, 0x83, 0x9E, 0x50, 0xE6, + 0x19, 0x25, 0xC4, 0xC2, 0xAD, 0x14, 0x52, 0xA1, + 0x4A, 0xCD, 0x76, 0xD7, 0x21, 0x6D, 0x21, 0x89, + 0xB2, 0xD3, 0x01, 0xD3, 0x07, 0x53, 0x05, 0x12, + 0x75, 0x8C, 0x26, 0xFD, 0x78, 0xE1, 0x54, 0x35, + 0x88, 0x1F, 0xB4, 0x35, 0x91, 0x13, 0xB7, 0xEB, + 0xB6, 0xB5, 0xC0, 0x7A, 0x5D, 0x8F, 0xE0, 0xF6 + }, + { + 0x80, 0x01, 0x80, 0x6A, 0x8F, 0xC1, 0xE0, 0x76, + 0xBF, 0x62, 0xAE, 0x9E, 0x2C, 0xF8, 0x1F, 0x91, + 0xA3, 0xC9, 0xBD, 0xC6, 0x77, 0x29, 0xC8, 0x40, + 0x5C, 0x19, 0xD8, 0xF2, 0xAC, 0x86, 0x2B, 0x04, + 0xB8, 0x41, 0xAC, 0x01, 0x86, 0x6E, 0x8D, 0x96, + 0xF9, 0x0C, 0x91, 0xC9, 0xB2, 0x59, 0x81, 0x37, + 0x59, 0x55, 0x54, 0x82, 0x29, 0x98, 0x91, 0xB6, + 0xBE, 0x50, 0x06, 0xB1, 0x9B, 0x91, 0xA5, 0x3E + }, + { + 0x85, 0xD2, 0xAC, 0xCD, 0xBE, 0x92, 0x06, 0x1F, + 0x95, 0xE2, 0xB6, 0xC8, 0x77, 0x7B, 0xD3, 0xE8, + 0xCC, 0x7E, 0xF2, 0xEA, 0x45, 0x93, 0x21, 0x6C, + 0x4B, 0xD0, 0x3B, 0xB1, 0xBA, 0x67, 0xB6, 0x26, + 0x79, 0x09, 0x6E, 0x14, 0xA9, 0x86, 0x90, 0xCF, + 0x1A, 0x73, 0xF4, 0x7E, 0xF1, 0x3F, 0xBF, 0xF2, + 0x2E, 0x42, 0xFD, 0x7C, 0x0C, 0x8D, 0xCF, 0x8D, + 0x71, 0x8C, 0xD8, 0xFC, 0x7A, 0xF2, 0xFF, 0x8B + }, + { + 0x8B, 0xFE, 0xA7, 0xBD, 0xF7, 0x6C, 0xB8, 0x36, + 0xDA, 0x24, 0x1F, 0x16, 0x01, 0x69, 0x27, 0x75, + 0xA9, 0x27, 0x3B, 0xC5, 0x09, 0xCE, 0xD1, 0x71, + 0x0F, 0x1F, 0xDF, 0xD7, 0xC4, 0x16, 0x7B, 0xC4, + 0x89, 0x21, 0xF4, 0xCF, 0x39, 0x64, 0x53, 0x86, + 0x90, 0xB2, 0x64, 0x4D, 0x54, 0xE4, 0xAC, 0x2D, + 0xA6, 0xC9, 0x25, 0xBD, 0xFA, 0x47, 0x68, 0xDC, + 0xFD, 0xA9, 0x22, 0xF0, 0x78, 0xCC, 0x7A, 0x32 + }, + { + 0x1D, 0x30, 0x54, 0x33, 0xC1, 0x56, 0xA1, 0x54, + 0x2D, 0x1D, 0xAD, 0x18, 0x87, 0xD3, 0x7D, 0x30, + 0x4B, 0xD2, 0xA8, 0x8A, 0x53, 0x3A, 0xF7, 0xE3, + 0xEF, 0xA2, 0x2F, 0x72, 0xB4, 0x2A, 0x1A, 0x51, + 0xC6, 0xDF, 0xE7, 0xBA, 0xEB, 0xB7, 0xCB, 0xE9, + 0x9A, 0xE6, 0x37, 0x91, 0x5C, 0x80, 0x17, 0x94, + 0xCA, 0x8C, 0xF5, 0x7E, 0x48, 0xA1, 0xA3, 0xFC, + 0x8D, 0x9C, 0xB6, 0x88, 0x23, 0x71, 0x24, 0x81 + }, + { + 0xEF, 0x5D, 0x2E, 0x2D, 0x29, 0xDB, 0x8D, 0x64, + 0x98, 0x91, 0xFD, 0xDE, 0x5F, 0x5E, 0x47, 0x21, + 0xCA, 0x1F, 0x5D, 0xC7, 0x5A, 0x57, 0x85, 0x83, + 0xF4, 0x39, 0x85, 0xB1, 0x4B, 0x0A, 0x1E, 0xE8, + 0x79, 0x44, 0xD5, 0xFB, 0xC6, 0x39, 0xB1, 0xFD, + 0x70, 0x27, 0x56, 0x3E, 0xFD, 0x29, 0x02, 0x5E, + 0x9F, 0x21, 0x66, 0xD2, 0xE4, 0xF9, 0xBD, 0xDC, + 0xD7, 0x98, 0xF0, 0x35, 0x3E, 0xF3, 0x8C, 0x51 + }, + { + 0xED, 0x8D, 0xC9, 0x3F, 0x0B, 0x46, 0x9B, 0x1B, + 0x24, 0xCE, 0x5F, 0xCE, 0xA0, 0xD6, 0x16, 0x35, + 0x98, 0x6E, 0x93, 0xB0, 0x1F, 0x11, 0xE6, 0xE0, + 0xBF, 0x0B, 0x1A, 0xD9, 0x88, 0xA2, 0xF3, 0x02, + 0xB6, 0x9A, 0xF9, 0x4B, 0xBD, 0x80, 0x85, 0xB8, + 0x6C, 0xBD, 0xE8, 0x4E, 0x10, 0xC3, 0x17, 0x65, + 0xBF, 0xEC, 0x82, 0x86, 0x4F, 0x8C, 0x1D, 0x4E, + 0xC5, 0x43, 0x7E, 0x73, 0xDB, 0xB7, 0x03, 0x23 + }, + { + 0xE1, 0x02, 0xDD, 0x16, 0xA9, 0x05, 0x80, 0x6E, + 0x7E, 0xA5, 0x78, 0xA2, 0xE8, 0xB4, 0x98, 0xA7, + 0xF7, 0x07, 0xFA, 0x20, 0x12, 0x54, 0x50, 0xFF, + 0x00, 0x49, 0xF2, 0x3A, 0xE9, 0xBC, 0x98, 0x26, + 0x61, 0x56, 0xA9, 0xA2, 0x2B, 0x1F, 0xAF, 0x36, + 0xD3, 0x81, 0xCD, 0x75, 0x6F, 0xE0, 0x27, 0xED, + 0xB1, 0xD3, 0x3A, 0xC5, 0xE2, 0xD8, 0x88, 0xDB, + 0xAB, 0xF5, 0xA1, 0x9F, 0x43, 0xE3, 0xDC, 0xCC + }, + { + 0xA8, 0x4D, 0x6D, 0xAF, 0x25, 0x6F, 0xE9, 0x5D, + 0xA5, 0xA2, 0x5F, 0xDB, 0x99, 0x93, 0xA2, 0x37, + 0xF3, 0x33, 0x6B, 0x19, 0x00, 0x9D, 0xAA, 0x12, + 0x3D, 0x45, 0x53, 0x35, 0x72, 0x93, 0x14, 0x92, + 0xA1, 0xC8, 0x96, 0x0C, 0xC5, 0x94, 0x96, 0xC0, + 0x8B, 0xF0, 0x3A, 0xB4, 0x8D, 0xCF, 0x9A, 0x5E, + 0x83, 0x9A, 0xED, 0x6D, 0xEA, 0xC6, 0xDA, 0x07, + 0xB4, 0xC1, 0x70, 0x6A, 0x6B, 0xC0, 0x68, 0x40 + }, + { + 0x40, 0xB2, 0x76, 0x6B, 0x56, 0xF5, 0x81, 0xF2, + 0xC1, 0x1C, 0xEC, 0x75, 0xE4, 0x73, 0x84, 0x2B, + 0xE6, 0x9F, 0x73, 0x65, 0xEC, 0x88, 0x00, 0x91, + 0x15, 0x32, 0xDE, 0x74, 0xB2, 0x2A, 0x27, 0x09, + 0x27, 0x81, 0xB0, 0xD4, 0x99, 0x75, 0x8A, 0x17, + 0x58, 0xA6, 0x89, 0x91, 0x12, 0x9E, 0x3C, 0xBD, + 0x7D, 0x60, 0x05, 0x8A, 0x6E, 0x53, 0xFE, 0xAB, + 0xD0, 0x64, 0x54, 0xED, 0x1A, 0x8C, 0x8A, 0x3B + }, + { + 0x5E, 0x2B, 0xCA, 0x71, 0xF7, 0x23, 0x1B, 0x80, + 0x94, 0xB9, 0xE5, 0xF2, 0x49, 0x21, 0x6B, 0x63, + 0x62, 0xFE, 0x8F, 0x53, 0x9D, 0xF6, 0xDD, 0xFC, + 0x41, 0x62, 0x94, 0xAF, 0x88, 0x47, 0xC1, 0xC7, + 0x5C, 0xFC, 0xD1, 0x4B, 0x5C, 0x93, 0xDA, 0xD3, + 0x2F, 0x44, 0xFF, 0x9E, 0xF9, 0x07, 0x4B, 0xCC, + 0x69, 0xB1, 0x62, 0x20, 0xB3, 0x0F, 0x2F, 0x7D, + 0xF1, 0x74, 0x16, 0xAD, 0x2A, 0x9A, 0xC3, 0x29 + }, + { + 0x1C, 0x0A, 0x24, 0x63, 0x39, 0x7B, 0x89, 0x42, + 0x6E, 0x55, 0x42, 0x60, 0xB5, 0x58, 0x03, 0x1A, + 0x23, 0x92, 0x23, 0xC2, 0xCC, 0x93, 0xB5, 0xD3, + 0x04, 0x99, 0x11, 0xCD, 0x50, 0x25, 0x4E, 0x76, + 0x51, 0xF1, 0x6C, 0x35, 0x31, 0x80, 0x17, 0x86, + 0x9A, 0xAA, 0x31, 0x57, 0x72, 0x6A, 0x10, 0x01, + 0x94, 0xD4, 0x6E, 0x2A, 0x7B, 0x8C, 0x46, 0xE0, + 0xD1, 0xCE, 0x4D, 0x62, 0x35, 0xBE, 0x27, 0xA5 + }, + { + 0x8D, 0xE3, 0xAB, 0x95, 0xA9, 0x56, 0xAA, 0x6A, + 0x15, 0x1B, 0xFA, 0x20, 0xAF, 0x95, 0x3E, 0x91, + 0x3D, 0x69, 0xA3, 0x9E, 0x73, 0x11, 0x04, 0x92, + 0xC2, 0xFA, 0x81, 0x60, 0x06, 0x03, 0xDC, 0x33, + 0x53, 0x46, 0xA0, 0xDC, 0x93, 0xFA, 0x32, 0xBE, + 0xC2, 0xF3, 0xC8, 0x54, 0x30, 0xBC, 0x00, 0xAB, + 0x1B, 0xE4, 0x6B, 0x71, 0xDF, 0x24, 0x77, 0x9C, + 0x62, 0x74, 0xD2, 0x84, 0x4A, 0x9B, 0x40, 0x0A + }, + { + 0xFF, 0x35, 0xC3, 0x67, 0xCE, 0x83, 0x41, 0x6E, + 0x21, 0x00, 0x57, 0x3C, 0xE0, 0x09, 0xCA, 0xF9, + 0xB9, 0x64, 0xBA, 0x25, 0x02, 0x07, 0x21, 0xC9, + 0x18, 0x4F, 0x35, 0xB0, 0xEB, 0xB3, 0xA1, 0x74, + 0x2A, 0x32, 0x34, 0x86, 0x8F, 0xB3, 0x1C, 0x8B, + 0x1F, 0xE2, 0x8A, 0x59, 0xD9, 0x41, 0xFF, 0xD6, + 0x99, 0x4C, 0x5C, 0x14, 0x00, 0x07, 0x83, 0xDE, + 0xC7, 0x86, 0x99, 0xD0, 0xC6, 0xCF, 0xB8, 0x42 + }, + { + 0x13, 0x71, 0x53, 0x2E, 0x51, 0x8C, 0x9E, 0xBE, + 0x4A, 0xD1, 0x03, 0xD0, 0xF1, 0x07, 0x7D, 0x35, + 0xD1, 0x27, 0x43, 0x9B, 0xDA, 0xCE, 0x3E, 0xAA, + 0xC1, 0xEB, 0xA1, 0xCA, 0xCA, 0x70, 0x90, 0x0D, + 0x50, 0x19, 0xD5, 0xF8, 0xB6, 0x48, 0xA7, 0xBE, + 0xB6, 0x51, 0x0D, 0x1D, 0xB0, 0xEE, 0xB9, 0x89, + 0x7B, 0x43, 0x59, 0xAA, 0xBE, 0x92, 0x79, 0xA3, + 0xB1, 0x26, 0x00, 0x51, 0x0F, 0x15, 0xD1, 0xC2 + }, + { + 0xEF, 0xB2, 0x46, 0x5A, 0xB4, 0xD0, 0xE0, 0x1D, + 0xB9, 0x91, 0xAE, 0x3A, 0xD4, 0x13, 0xFD, 0xF2, + 0x77, 0x09, 0xBF, 0x6A, 0x7C, 0x63, 0x28, 0xC3, + 0x74, 0x3C, 0x25, 0x01, 0xCF, 0xBD, 0xDE, 0xDF, + 0xB0, 0x09, 0x46, 0xF5, 0x14, 0x60, 0x95, 0x5F, + 0x4B, 0x49, 0x4A, 0x10, 0xF7, 0x1A, 0xAD, 0x33, + 0x23, 0x2B, 0x39, 0x35, 0x72, 0x87, 0x57, 0x58, + 0x1D, 0xC5, 0x49, 0x6F, 0xE4, 0x9F, 0xC9, 0x3E + }, + { + 0xDB, 0xA2, 0x2E, 0xD8, 0x73, 0x38, 0x2D, 0x0B, + 0x81, 0x55, 0x58, 0x9C, 0xCF, 0x3E, 0x91, 0x7F, + 0xFF, 0x65, 0x03, 0x92, 0x7A, 0x68, 0x69, 0x97, + 0xE2, 0x69, 0x98, 0xBD, 0x2C, 0x9D, 0xCB, 0x44, + 0x39, 0xCA, 0xFD, 0x61, 0xE0, 0xF3, 0xCB, 0xDC, + 0x96, 0xA7, 0x1A, 0x49, 0x5F, 0xA1, 0x14, 0x4C, + 0xB1, 0x46, 0x8E, 0x5E, 0x6C, 0xBF, 0x1F, 0x0D, + 0xC0, 0x8C, 0x20, 0x14, 0xD3, 0xFA, 0x5A, 0x3D + }, + { + 0x10, 0xAF, 0x38, 0x76, 0x63, 0x46, 0x8E, 0x11, + 0x92, 0x7C, 0xE2, 0xF1, 0xAC, 0x88, 0xB9, 0xE1, + 0x48, 0x25, 0xC1, 0x8D, 0x5F, 0x72, 0x64, 0x6B, + 0x7A, 0x37, 0x16, 0x62, 0xFA, 0xDA, 0x3F, 0x21, + 0x1D, 0xFB, 0xEA, 0x7F, 0x6F, 0x16, 0x31, 0x58, + 0xD7, 0x12, 0xC1, 0x31, 0x73, 0xB5, 0x62, 0x70, + 0x1A, 0x49, 0x81, 0xAB, 0x79, 0x06, 0xDC, 0xD2, + 0x5F, 0x03, 0xE4, 0x42, 0x49, 0x25, 0xB7, 0x43 + }, + { + 0x1E, 0xD0, 0x0F, 0xF2, 0x82, 0xDB, 0xB5, 0x61, + 0x78, 0x51, 0x9A, 0x9C, 0x6E, 0x5D, 0x8F, 0x91, + 0x48, 0x86, 0x6F, 0x45, 0x42, 0x29, 0x50, 0x60, + 0xFF, 0x08, 0x75, 0x50, 0xAA, 0x3C, 0x4D, 0x88, + 0xA7, 0x42, 0xE9, 0xBE, 0xE6, 0x0B, 0x6F, 0xAC, + 0xDF, 0xAE, 0x2B, 0xA3, 0xFA, 0xB5, 0xEC, 0x49, + 0xEB, 0x0D, 0xF4, 0xF2, 0x93, 0x17, 0xFB, 0xEC, + 0x33, 0xA0, 0x72, 0x31, 0x4B, 0x69, 0x16, 0x25 + }, + { + 0x64, 0x46, 0x2B, 0xE4, 0x1A, 0x5A, 0x22, 0x9C, + 0xE7, 0xBF, 0x94, 0x3E, 0xC3, 0xA3, 0xB5, 0x77, + 0x99, 0x85, 0xEC, 0x02, 0xDD, 0x88, 0x1B, 0x9C, + 0xB4, 0x7B, 0xBE, 0x42, 0xB5, 0xCC, 0x8B, 0x41, + 0x92, 0x4D, 0x0F, 0x0A, 0xDF, 0xFF, 0xAB, 0x87, + 0x7B, 0x06, 0x31, 0xF9, 0x1E, 0xF7, 0x60, 0xCD, + 0x1D, 0x80, 0x7E, 0x8F, 0xCF, 0xA4, 0xA0, 0xED, + 0xE4, 0x5E, 0x5C, 0x13, 0x82, 0x51, 0x1C, 0xAE + }, + { + 0xBE, 0xB7, 0x2B, 0xCF, 0xFB, 0xDB, 0x52, 0x99, + 0x4D, 0x1F, 0x04, 0x1A, 0x99, 0xBB, 0x15, 0x34, + 0x30, 0x0A, 0xED, 0x4C, 0xBA, 0xA7, 0x62, 0x21, + 0xF1, 0x74, 0xB5, 0x2B, 0xBE, 0xFE, 0x95, 0xA7, + 0xBC, 0xDD, 0x0A, 0x97, 0x93, 0xF0, 0x8E, 0xF4, + 0x02, 0xC4, 0xF6, 0x7E, 0x0F, 0x10, 0xB4, 0xA7, + 0x0C, 0x35, 0xF1, 0x5A, 0xFD, 0x6B, 0x3F, 0xB3, + 0x22, 0xA7, 0x6F, 0xD8, 0x8A, 0x25, 0x52, 0x8F + }, + { + 0xBD, 0x50, 0x26, 0xAE, 0xA0, 0x5C, 0x7E, 0x0E, + 0x32, 0xCA, 0x80, 0xA3, 0x98, 0x77, 0x94, 0x01, + 0xF7, 0x39, 0x42, 0x85, 0xB4, 0x35, 0xC1, 0x72, + 0x24, 0xA8, 0x47, 0x1A, 0x58, 0x2B, 0x97, 0x61, + 0xAB, 0xF3, 0x06, 0x55, 0x1B, 0x59, 0x22, 0xFB, + 0x3F, 0x68, 0x39, 0x17, 0x27, 0x9E, 0x39, 0xA0, + 0x88, 0x91, 0xC5, 0x40, 0x4B, 0x15, 0x87, 0xEA, + 0x1F, 0x09, 0x26, 0x54, 0x7E, 0xE7, 0xF7, 0x57 + }, + { + 0xA3, 0x33, 0xB7, 0x43, 0xA5, 0x4A, 0xDD, 0x58, + 0x47, 0x96, 0xF4, 0x30, 0x0A, 0x83, 0xE2, 0x51, + 0x5A, 0x5D, 0x9D, 0x13, 0xB0, 0x71, 0x56, 0xF1, + 0xE8, 0x77, 0xDF, 0x32, 0x67, 0x18, 0xDF, 0x53, + 0x06, 0x6C, 0xD2, 0xC0, 0xD4, 0x4D, 0x11, 0xEC, + 0xD0, 0xE0, 0xFA, 0x24, 0x2C, 0x75, 0x80, 0x99, + 0xD4, 0x30, 0x6E, 0x1B, 0xF4, 0xA2, 0xFF, 0x6F, + 0x20, 0x49, 0xA6, 0x79, 0xCE, 0xC3, 0xB9, 0x59 + }, + { + 0xC7, 0x87, 0x37, 0x35, 0xD3, 0xA2, 0xF0, 0x7B, + 0x9D, 0x68, 0x92, 0x32, 0x65, 0x21, 0xE2, 0x2C, + 0x50, 0xD7, 0x0F, 0xBE, 0x94, 0x90, 0x02, 0x7A, + 0xC7, 0x9E, 0x2C, 0x5B, 0x36, 0x59, 0x38, 0xFF, + 0x45, 0x79, 0x91, 0x5D, 0x49, 0x09, 0x74, 0x35, + 0x0F, 0x97, 0xCD, 0x12, 0x8D, 0xED, 0xAF, 0xF3, + 0x12, 0x30, 0xD8, 0x38, 0x1C, 0xE6, 0x36, 0x27, + 0x93, 0x28, 0xD3, 0xCB, 0x76, 0xC3, 0x69, 0xEE + }, + { + 0x68, 0x9E, 0x20, 0xBE, 0x07, 0x70, 0x46, 0xE4, + 0xD6, 0x8B, 0xC8, 0xFA, 0xEE, 0x9F, 0x57, 0x4A, + 0x79, 0xD6, 0x72, 0xDF, 0x16, 0x86, 0xBA, 0x15, + 0xFA, 0xB9, 0x82, 0xA0, 0xCA, 0xDB, 0x92, 0xF8, + 0x81, 0xAE, 0x22, 0xA3, 0x0E, 0x1B, 0xCC, 0xF6, + 0x87, 0x41, 0xAC, 0x92, 0xEA, 0x67, 0x29, 0x74, + 0x8C, 0x45, 0xAA, 0x1D, 0x78, 0xA7, 0x61, 0xD1, + 0x83, 0x6B, 0x94, 0xDA, 0xA7, 0x17, 0x62, 0xF0 + }, + { + 0xA7, 0x83, 0x8E, 0x75, 0xDA, 0xF5, 0xF4, 0xA8, + 0x2A, 0xD0, 0x1F, 0x17, 0x18, 0x39, 0x58, 0xE3, + 0x74, 0x75, 0x69, 0x84, 0x9A, 0xAB, 0x0B, 0x05, + 0x2F, 0xFC, 0xB7, 0xA1, 0xDB, 0xA9, 0x07, 0xE4, + 0x72, 0x14, 0xD2, 0x99, 0x1F, 0x64, 0xB4, 0x20, + 0x0A, 0x64, 0x9B, 0xC8, 0x6D, 0x68, 0x77, 0xB2, + 0x67, 0xE4, 0x03, 0xA8, 0xAF, 0xE4, 0xAC, 0x0A, + 0x46, 0x51, 0x89, 0x6C, 0xFD, 0x64, 0x4D, 0x4A + }, + { + 0x98, 0xFB, 0xE5, 0xAD, 0x0E, 0x63, 0x95, 0x2E, + 0x4C, 0x31, 0xEE, 0x45, 0x80, 0xAC, 0x9B, 0x21, + 0xA7, 0x04, 0xF1, 0x03, 0x01, 0x9C, 0x5C, 0x4E, + 0x98, 0x4D, 0x7C, 0xB6, 0xF8, 0x0E, 0x22, 0x08, + 0x03, 0x73, 0x3A, 0x71, 0x61, 0x49, 0x40, 0x5C, + 0xA3, 0x22, 0xE6, 0xD0, 0x70, 0xFB, 0xF1, 0x5E, + 0xDB, 0x90, 0xCD, 0xEE, 0xFF, 0xB8, 0x22, 0x72, + 0x87, 0xE4, 0x3A, 0xE0, 0xE2, 0x45, 0x09, 0x64 + }, + { + 0xC8, 0x03, 0xC3, 0x8B, 0xBF, 0xEB, 0xCA, 0x0D, + 0xA4, 0x3C, 0xC8, 0xE3, 0x25, 0x96, 0xFB, 0x8D, + 0x42, 0xDB, 0x4D, 0x2A, 0x82, 0x17, 0x4D, 0x61, + 0xCE, 0x7F, 0x0C, 0xE4, 0x38, 0x87, 0xE8, 0x6C, + 0x1D, 0xDF, 0x8D, 0xE1, 0xB9, 0xD7, 0x00, 0xBC, + 0xB0, 0xA7, 0x47, 0xB5, 0x3A, 0x5E, 0x71, 0x81, + 0x44, 0x0B, 0x5E, 0xC6, 0x9F, 0x34, 0x55, 0x27, + 0xB2, 0xBE, 0xB2, 0x2D, 0xC2, 0x95, 0xF8, 0xDB + }, + { + 0x01, 0xF7, 0x07, 0x6E, 0x87, 0x05, 0x87, 0xB2, + 0x56, 0x37, 0x6D, 0x8B, 0x28, 0xD4, 0xBE, 0x82, + 0x9B, 0xA0, 0x69, 0x46, 0x46, 0xC3, 0xC8, 0x26, + 0xC6, 0x3B, 0x94, 0x3C, 0x23, 0x58, 0x4D, 0x81, + 0xEF, 0x9F, 0x2D, 0xAA, 0x40, 0x15, 0x38, 0x60, + 0x2C, 0xB8, 0x4C, 0x79, 0xC3, 0x4D, 0x21, 0x50, + 0x5C, 0xC9, 0xD0, 0xCB, 0xE7, 0xB9, 0x97, 0x57, + 0x9E, 0x42, 0x4F, 0x05, 0x76, 0xFF, 0x95, 0xF7 + }, + { + 0x44, 0x77, 0x67, 0xC0, 0xBA, 0xE2, 0x49, 0x5F, + 0x69, 0x22, 0x55, 0x5A, 0xFC, 0xC4, 0xBD, 0xF9, + 0x01, 0x0F, 0xE7, 0xBB, 0x59, 0x1D, 0xDE, 0x95, + 0xA4, 0xC3, 0xAA, 0x18, 0x3D, 0xF0, 0xBA, 0xB2, + 0x1A, 0x30, 0x27, 0x7A, 0x19, 0xE1, 0x1E, 0xA2, + 0xE7, 0xB3, 0x63, 0x86, 0xE0, 0x68, 0xF4, 0xA2, + 0xFA, 0x1B, 0x5E, 0xD1, 0xB7, 0x84, 0xF1, 0x4D, + 0xBB, 0x36, 0x8F, 0x48, 0x99, 0xCF, 0xDC, 0x2B + }, + { + 0x6E, 0x79, 0xCB, 0x01, 0xE6, 0x78, 0x3A, 0x12, + 0x65, 0xC7, 0xE2, 0x79, 0x3C, 0xA3, 0x33, 0x54, + 0x9B, 0x03, 0xB7, 0x20, 0x4F, 0xA1, 0x48, 0xD7, + 0x6E, 0xFF, 0xF3, 0x0C, 0xDE, 0xEC, 0x5F, 0x74, + 0xDA, 0xC7, 0xE6, 0x3E, 0xF0, 0xC9, 0x98, 0x60, + 0x3D, 0x51, 0xA5, 0xB0, 0x20, 0x16, 0xD2, 0x15, + 0xDE, 0x6B, 0x87, 0xE1, 0x36, 0x3B, 0x63, 0x81, + 0x6D, 0xF7, 0x6B, 0x18, 0xF8, 0x74, 0x8F, 0xC9 + }, + { + 0xD8, 0xD9, 0x01, 0xE2, 0x7F, 0xA9, 0x5D, 0x5F, + 0x50, 0x91, 0x8B, 0x0C, 0xF7, 0x8A, 0xC3, 0xA7, + 0x82, 0xEF, 0x76, 0xBE, 0xEE, 0x4C, 0x25, 0xF3, + 0x9F, 0xE6, 0x45, 0x06, 0xB7, 0x82, 0x25, 0x74, + 0xE1, 0x76, 0x8D, 0x86, 0x2F, 0xAD, 0x6C, 0x6B, + 0x60, 0x07, 0xC6, 0xBF, 0xAD, 0xB1, 0x12, 0x62, + 0xBE, 0x2B, 0x4E, 0x9E, 0x05, 0xE3, 0xD0, 0x32, + 0x94, 0x05, 0xD3, 0x7A, 0x0F, 0x3E, 0x78, 0x67 + }, + { + 0xEC, 0xFC, 0x18, 0xC6, 0xC6, 0x96, 0x18, 0x66, + 0x5D, 0x35, 0xA4, 0xC8, 0xF6, 0x2B, 0x9B, 0xF1, + 0xB3, 0xF1, 0x8C, 0x5C, 0xDC, 0x75, 0x52, 0x7A, + 0x48, 0xEA, 0x25, 0xE5, 0xF0, 0x9D, 0xBC, 0x2C, + 0x24, 0xD2, 0x29, 0xF0, 0x99, 0x5F, 0xDB, 0xB6, + 0x52, 0x42, 0x8F, 0x76, 0x98, 0xE5, 0xDE, 0x09, + 0xD0, 0xD4, 0x0C, 0x77, 0xE3, 0x42, 0xFF, 0x5D, + 0xAB, 0xCD, 0xA6, 0x25, 0x88, 0x14, 0x62, 0x17 + }, + { + 0xF7, 0x42, 0xF7, 0x53, 0x96, 0xA0, 0x7A, 0x98, + 0xBD, 0x2D, 0xC2, 0xF3, 0x5F, 0xCC, 0xCE, 0x39, + 0x68, 0xEC, 0x6B, 0xAA, 0x28, 0x11, 0x2B, 0x66, + 0xCC, 0x78, 0xB9, 0xB5, 0xBC, 0x13, 0xD2, 0x23, + 0x14, 0xD0, 0x52, 0x3F, 0x2F, 0x6F, 0xEA, 0x07, + 0x18, 0x25, 0x5C, 0x37, 0x9B, 0xB1, 0xDD, 0xA6, + 0x70, 0xA2, 0x72, 0x5E, 0xA3, 0xA7, 0x63, 0x30, + 0x94, 0xDD, 0xF5, 0x74, 0x61, 0xCF, 0xF6, 0x0C + }, + { + 0x30, 0x30, 0x31, 0xC2, 0x41, 0x80, 0x11, 0x7C, + 0x42, 0x62, 0xFF, 0x81, 0xF8, 0xE5, 0x92, 0xAD, + 0x1E, 0xD3, 0x50, 0x3F, 0x21, 0x8A, 0xF0, 0x63, + 0x00, 0x96, 0xE8, 0x1C, 0xE1, 0xDD, 0x58, 0x0D, + 0xCC, 0x82, 0x7C, 0xB9, 0x99, 0x83, 0x9A, 0x9A, + 0xC6, 0x0B, 0x52, 0x48, 0x43, 0xED, 0x30, 0xF5, + 0xB4, 0x3E, 0xAD, 0x40, 0x98, 0x18, 0xAC, 0x0A, + 0x5A, 0xCA, 0xAB, 0x41, 0x7E, 0x42, 0x33, 0x68 + }, + { + 0xB7, 0x1E, 0xB7, 0xA5, 0x7B, 0x00, 0xFE, 0x91, + 0x3F, 0xD7, 0xF2, 0xF6, 0x45, 0x6E, 0xE1, 0xD8, + 0x26, 0xE2, 0x5C, 0x1C, 0xD9, 0x7C, 0x24, 0x4B, + 0xB3, 0x93, 0xF5, 0x8C, 0xF1, 0xD0, 0xE4, 0xA6, + 0x17, 0x73, 0x6D, 0x63, 0xA3, 0x46, 0xCF, 0x5F, + 0xA8, 0x99, 0x75, 0x0B, 0xF0, 0x72, 0xF0, 0x5B, + 0xD7, 0x60, 0x57, 0xBF, 0xA7, 0x72, 0x38, 0x3F, + 0x1F, 0xEE, 0x06, 0x62, 0xD7, 0x44, 0x58, 0x8F + }, + { + 0x3A, 0x23, 0x5A, 0xF0, 0xC1, 0x5B, 0x55, 0xBB, + 0x30, 0xAD, 0xAD, 0x5C, 0x61, 0x1B, 0x59, 0x83, + 0x74, 0x0E, 0xC5, 0x30, 0x4C, 0xFC, 0x98, 0x57, + 0xDA, 0x72, 0x7C, 0xC3, 0xC9, 0x31, 0x04, 0xC1, + 0xBC, 0xA4, 0xBC, 0xA2, 0x0E, 0x40, 0x83, 0x60, + 0xCE, 0xAC, 0x4E, 0xE3, 0x53, 0x23, 0x7A, 0xD1, + 0xA0, 0xFA, 0x51, 0x5D, 0xD4, 0x1F, 0x5D, 0xE2, + 0xA9, 0x95, 0xF7, 0x2E, 0x3C, 0x8D, 0x65, 0x48 + }, + { + 0x98, 0x86, 0xCA, 0x11, 0x64, 0x65, 0xED, 0x99, + 0x8B, 0xB0, 0x2B, 0x2D, 0x86, 0x8A, 0x0D, 0x41, + 0xFE, 0xB3, 0xF1, 0x9A, 0x71, 0x7F, 0x13, 0x16, + 0x53, 0x1F, 0x0E, 0xE3, 0x63, 0x4C, 0x7D, 0x8C, + 0x4D, 0x30, 0x9F, 0x78, 0xC8, 0x71, 0xA4, 0x1A, + 0x07, 0xC2, 0x83, 0x71, 0x9D, 0xF8, 0x45, 0xF0, + 0xF1, 0x1C, 0xB5, 0x7C, 0xF4, 0x80, 0xFC, 0x49, + 0xEE, 0x02, 0x0E, 0x0C, 0xA3, 0x2A, 0x84, 0x0E + }, + { + 0x08, 0xE9, 0x22, 0x9D, 0x06, 0x43, 0x83, 0x45, + 0x5D, 0xE2, 0x41, 0xE0, 0xFE, 0x8D, 0x5B, 0xF3, + 0x86, 0x22, 0xA8, 0x06, 0x13, 0x43, 0x15, 0x0C, + 0x11, 0x06, 0x07, 0x5B, 0x41, 0xA9, 0x83, 0xAD, + 0x0E, 0x67, 0x10, 0x31, 0xA6, 0x8A, 0xB3, 0x0A, + 0xE3, 0x96, 0x9D, 0x1E, 0x5A, 0xA2, 0x60, 0xF3, + 0x59, 0xB6, 0xD7, 0x9D, 0x63, 0xC2, 0xF0, 0xD8, + 0xE8, 0xEC, 0x83, 0xA1, 0x2A, 0xF0, 0xA3, 0x81 + }, + { + 0xF0, 0x97, 0xB2, 0x5A, 0x62, 0x9A, 0x48, 0xA7, + 0x6C, 0xEA, 0x36, 0x80, 0xDB, 0x07, 0x59, 0x5F, + 0xC6, 0x9D, 0x92, 0xE2, 0x9D, 0x6E, 0x88, 0x38, + 0xCF, 0x7F, 0xA9, 0xA1, 0xFC, 0x4A, 0xA4, 0x86, + 0x36, 0x78, 0x9F, 0x8C, 0xE8, 0x92, 0xB4, 0x7A, + 0xAE, 0x63, 0xB5, 0x50, 0x38, 0xD2, 0x4B, 0x63, + 0x39, 0x27, 0x0E, 0xCF, 0x3B, 0x3B, 0xC3, 0x1F, + 0x26, 0x81, 0xD9, 0xF9, 0xB2, 0x8E, 0xD8, 0xBF + }, + { + 0x5D, 0x82, 0xA8, 0x8C, 0x21, 0x89, 0xE2, 0x1B, + 0x99, 0xB9, 0xF1, 0xDC, 0x5E, 0x1A, 0xA2, 0x5C, + 0xB1, 0x25, 0x51, 0xC8, 0xCC, 0xAE, 0x5D, 0x54, + 0xFD, 0xFA, 0xCA, 0x1F, 0x13, 0x61, 0xBF, 0x45, + 0x6B, 0xD1, 0xE3, 0xC3, 0x39, 0xE2, 0xCE, 0xDD, + 0xF1, 0x05, 0xD0, 0x97, 0xAD, 0xF5, 0x93, 0x11, + 0x72, 0x68, 0x72, 0xB1, 0x93, 0xE4, 0xAB, 0xF4, + 0x8C, 0xBD, 0x2E, 0xFF, 0x4E, 0xC9, 0xC4, 0x6C + }, + { + 0xF0, 0xFD, 0xC5, 0x1F, 0xB4, 0x07, 0xBC, 0xC7, + 0x26, 0x02, 0x39, 0x84, 0xDB, 0xBE, 0xA0, 0x5E, + 0x60, 0xBD, 0x58, 0xC8, 0xC7, 0xF5, 0xE6, 0xAD, + 0xED, 0x1F, 0x77, 0x74, 0x08, 0x05, 0x9F, 0x25, + 0x53, 0xF6, 0x79, 0xDA, 0x1A, 0xA7, 0xD7, 0xC3, + 0xFC, 0x9F, 0xAE, 0x72, 0x2A, 0x66, 0x7C, 0x23, + 0xC8, 0xA8, 0xD0, 0xB2, 0x47, 0xAA, 0x87, 0x2A, + 0x1C, 0x55, 0x1D, 0xE4, 0xD1, 0xB8, 0xF3, 0x6D + }, + { + 0x1A, 0x65, 0xD2, 0x10, 0xE1, 0xEA, 0x1B, 0x63, + 0x0F, 0x44, 0x51, 0x5E, 0x3F, 0xC6, 0xCC, 0x78, + 0x1F, 0x7E, 0x9A, 0xDA, 0xCB, 0xC2, 0x74, 0x6E, + 0xCE, 0x2C, 0x4D, 0x08, 0xA2, 0x0F, 0xC6, 0x53, + 0x7C, 0x86, 0xEE, 0x60, 0xC4, 0x60, 0x11, 0x49, + 0xD4, 0xF3, 0xC3, 0x4F, 0xD3, 0x09, 0xCA, 0xA7, + 0xA5, 0x83, 0x1A, 0x67, 0xC1, 0x3C, 0x62, 0x26, + 0x8D, 0x4F, 0x0B, 0x31, 0xD3, 0x92, 0x2F, 0x82 + }, + { + 0x8B, 0x27, 0x13, 0x1F, 0x2F, 0xB0, 0xB0, 0x96, + 0x20, 0xA2, 0xB8, 0x45, 0x58, 0x51, 0xF4, 0x53, + 0xE1, 0xB9, 0x4F, 0x7C, 0x16, 0xE9, 0x78, 0xA6, + 0x85, 0x8F, 0x11, 0x77, 0x1A, 0x31, 0x35, 0x7E, + 0x27, 0x43, 0x2E, 0xA1, 0x60, 0xBF, 0xB7, 0xD3, + 0x82, 0xE5, 0x19, 0x67, 0xAA, 0x2D, 0x4A, 0x9A, + 0x8D, 0xA2, 0xD7, 0x2E, 0xEA, 0xB3, 0x5B, 0x9A, + 0xDE, 0x52, 0x60, 0x88, 0xA0, 0xF1, 0x4A, 0xCD + }, + { + 0x13, 0x49, 0x68, 0xD8, 0xEF, 0x6D, 0x6A, 0x6E, + 0x32, 0x7B, 0x59, 0x5D, 0xAD, 0x7E, 0xBE, 0x13, + 0x0A, 0x09, 0x7B, 0x46, 0xB0, 0x1A, 0x93, 0xEC, + 0x0D, 0x1B, 0x57, 0x5A, 0x90, 0x9F, 0xEB, 0xAB, + 0x51, 0x55, 0xA8, 0x53, 0x7A, 0xF8, 0x4F, 0x02, + 0x86, 0xC2, 0xBD, 0x7A, 0xA1, 0x85, 0x23, 0x79, + 0xFB, 0x53, 0x90, 0xB3, 0xDA, 0x43, 0x7E, 0x06, + 0x56, 0x7E, 0x6E, 0xC6, 0x59, 0x24, 0x29, 0x04 + }, + { + 0x7A, 0xF3, 0x43, 0xF0, 0x87, 0x41, 0xB4, 0x8A, + 0x3E, 0x8C, 0x55, 0xCE, 0x5D, 0xCF, 0xC2, 0x29, + 0xFC, 0x9C, 0x9F, 0x46, 0xF3, 0x3F, 0xBE, 0x4F, + 0x99, 0x40, 0x1C, 0x83, 0xCC, 0x4F, 0xC5, 0x3A, + 0x5F, 0x24, 0x78, 0xD9, 0xE8, 0x80, 0x80, 0x39, + 0x4D, 0xD2, 0xBB, 0x62, 0xA9, 0x57, 0x82, 0xD7, + 0x97, 0xD8, 0xE9, 0x1E, 0x12, 0x26, 0x3C, 0x2B, + 0x59, 0xF7, 0xB5, 0x08, 0x1C, 0x4D, 0xE9, 0xC3 + }, + { + 0xCA, 0x5B, 0x18, 0xB5, 0x6B, 0xEB, 0x38, 0x05, + 0xED, 0xA0, 0xC4, 0x9E, 0x82, 0xAA, 0xAC, 0x63, + 0xF9, 0x91, 0xCF, 0xD7, 0x97, 0x6B, 0xDD, 0x95, + 0x83, 0xFE, 0xB3, 0x79, 0xBD, 0xE6, 0x02, 0x2A, + 0xC9, 0x92, 0x3B, 0xBA, 0x67, 0x8C, 0x69, 0xDB, + 0x96, 0x30, 0xDF, 0x06, 0xD0, 0xC0, 0x7B, 0x74, + 0x7F, 0x7C, 0x21, 0xF2, 0xDE, 0xBA, 0xBA, 0x5C, + 0x23, 0x70, 0xEC, 0xDA, 0x20, 0x69, 0xB2, 0x99 + }, + { + 0x4F, 0xBA, 0x5D, 0xB7, 0xE3, 0x41, 0x40, 0x58, + 0x00, 0x2B, 0xC9, 0x71, 0xA0, 0xCE, 0x4F, 0xEF, + 0xFA, 0xAC, 0x25, 0xAD, 0x91, 0x1C, 0x57, 0x04, + 0xF5, 0x98, 0x95, 0x42, 0xC7, 0xEB, 0xE4, 0x97, + 0x81, 0xEF, 0x4C, 0xB2, 0xE7, 0x87, 0xAF, 0x2E, + 0x8D, 0xF6, 0xEC, 0x87, 0xE6, 0xC9, 0x49, 0x2E, + 0x58, 0x45, 0x86, 0x26, 0x99, 0x57, 0x4D, 0xBF, + 0x06, 0x07, 0xCA, 0x2E, 0x9C, 0x28, 0xB8, 0xF3 + }, + { + 0xCC, 0xD1, 0x23, 0x0C, 0xE0, 0x59, 0xFD, 0x66, + 0x6C, 0x52, 0xE0, 0x3E, 0xC3, 0x0E, 0xF3, 0x5F, + 0x5E, 0x77, 0xD8, 0xAB, 0x69, 0x21, 0x8B, 0x69, + 0xFD, 0x62, 0x2C, 0xF2, 0x2B, 0xF8, 0xFA, 0x64, + 0x47, 0xC8, 0x7E, 0xE2, 0x0C, 0x7A, 0x33, 0x77, + 0x82, 0x85, 0x70, 0x9F, 0xCC, 0xA2, 0x18, 0xB3, + 0xD3, 0x26, 0xA9, 0xC4, 0x44, 0x65, 0xB5, 0xA5, + 0x98, 0xFD, 0x9E, 0x52, 0x18, 0x11, 0x93, 0xB2 + }, + { + 0x2C, 0xA2, 0xF6, 0x47, 0x4F, 0x3E, 0x4F, 0xE5, + 0x0D, 0xBF, 0x7A, 0xAC, 0x33, 0x07, 0x7F, 0xCE, + 0x5D, 0x41, 0xD8, 0xC9, 0x5D, 0x1E, 0xEF, 0x27, + 0x05, 0x38, 0x74, 0x2A, 0xE9, 0xAD, 0x47, 0x1C, + 0xC8, 0x66, 0xFD, 0x43, 0xDA, 0x13, 0xDE, 0x4E, + 0xE7, 0x71, 0xD8, 0xE9, 0xB7, 0x9E, 0x64, 0x3D, + 0x30, 0xFB, 0x23, 0x1C, 0xD3, 0xC4, 0x3A, 0x66, + 0x00, 0x51, 0xC6, 0xC0, 0xF1, 0x46, 0x1D, 0x40 + }, + { + 0x43, 0x46, 0x84, 0xDB, 0x2C, 0xA1, 0x1C, 0x82, + 0x43, 0x28, 0xFB, 0x6A, 0x07, 0x18, 0x13, 0x17, + 0x21, 0x53, 0x42, 0x3C, 0x71, 0xC3, 0x65, 0x56, + 0x1C, 0x3A, 0x29, 0x92, 0x56, 0xD6, 0xBB, 0x6E, + 0x07, 0xCE, 0x2D, 0x26, 0x01, 0xD9, 0x62, 0x20, + 0x89, 0x0C, 0x65, 0x06, 0x7F, 0x10, 0xC0, 0x07, + 0x13, 0x03, 0x27, 0xE7, 0xB9, 0x58, 0xDD, 0x8D, + 0xE5, 0x53, 0x2A, 0xCE, 0xC8, 0x23, 0x2C, 0x72 + }, + { + 0xE0, 0x29, 0x42, 0xB6, 0x13, 0x29, 0x86, 0x21, + 0x02, 0xCF, 0x2D, 0xEB, 0x1D, 0x90, 0x1E, 0xB8, + 0x1D, 0xCA, 0x13, 0xD4, 0x17, 0xE1, 0x55, 0xD3, + 0xD1, 0xE5, 0xCB, 0xAE, 0xEA, 0x8D, 0x1B, 0x79, + 0xF1, 0x56, 0xE3, 0xDB, 0x87, 0xE4, 0xB7, 0xEF, + 0x1F, 0x02, 0xF4, 0xD8, 0xCD, 0x98, 0xBB, 0x12, + 0xBA, 0x6F, 0xC4, 0x7A, 0x73, 0x3B, 0xDC, 0x62, + 0xB5, 0x1A, 0xE9, 0x26, 0x10, 0x7F, 0xDA, 0x96 + }, + { + 0xEA, 0x32, 0x3A, 0x03, 0x7B, 0x84, 0x83, 0x78, + 0xAE, 0x58, 0xC8, 0xF8, 0x3F, 0x30, 0xB6, 0x90, + 0x64, 0x4C, 0x86, 0xD3, 0x5D, 0xF3, 0xA3, 0x00, + 0x5D, 0xEE, 0x6B, 0x14, 0xBD, 0xB4, 0xFA, 0x7A, + 0x59, 0xC7, 0xED, 0x12, 0x57, 0x2C, 0x2C, 0x40, + 0xD0, 0xE8, 0x0A, 0x60, 0xC5, 0xC2, 0xC1, 0x1C, + 0x72, 0xCE, 0x02, 0xE3, 0x8D, 0x77, 0x9E, 0x1F, + 0xD7, 0xC7, 0x90, 0x9B, 0x06, 0x71, 0x40, 0x18 + }, + { + 0x74, 0x20, 0x31, 0xD4, 0xBF, 0xC8, 0x7A, 0x26, + 0x0F, 0xDC, 0xB3, 0x31, 0xF4, 0x3F, 0x0C, 0x60, + 0xB0, 0x7D, 0xDF, 0xF8, 0x1F, 0x5F, 0x06, 0xA0, + 0x57, 0x13, 0x70, 0xB2, 0x65, 0x93, 0x0C, 0x23, + 0xA3, 0x42, 0x79, 0x01, 0xEB, 0xD0, 0x88, 0x18, + 0x04, 0x36, 0x50, 0x16, 0x0B, 0xF1, 0xE3, 0x0C, + 0x8D, 0x48, 0xFF, 0x81, 0x70, 0x9C, 0xF8, 0xDE, + 0x98, 0x99, 0x01, 0x31, 0x3C, 0x45, 0x11, 0xDD + }, + { + 0x76, 0x4E, 0xEF, 0xC6, 0xC5, 0x50, 0x6A, 0x0E, + 0x47, 0xB8, 0xD4, 0x24, 0x43, 0x78, 0xBD, 0x14, + 0x22, 0x08, 0x48, 0x0F, 0xC0, 0xAB, 0x27, 0xEA, + 0x27, 0x5F, 0xD9, 0xFA, 0xCD, 0x19, 0x9E, 0x66, + 0x8E, 0x0B, 0x99, 0x56, 0x6E, 0x0B, 0x28, 0x44, + 0x23, 0xFE, 0x1D, 0x57, 0x18, 0x8F, 0x57, 0x5F, + 0xB5, 0xC0, 0x4F, 0x51, 0x59, 0x36, 0x23, 0x78, + 0xD2, 0xAB, 0x66, 0x39, 0xD4, 0xA3, 0x74, 0x98 + }, + { + 0x49, 0x71, 0x1E, 0xE1, 0xC7, 0xC3, 0xB8, 0x19, + 0x31, 0x16, 0xD4, 0xBD, 0xE6, 0x14, 0xDA, 0xC2, + 0xCF, 0x1B, 0x29, 0x79, 0xE3, 0x11, 0x28, 0xF2, + 0xC6, 0x78, 0x92, 0x63, 0x36, 0xD9, 0xA6, 0x79, + 0x86, 0xEB, 0xAB, 0x28, 0x96, 0x35, 0xB8, 0x31, + 0x2E, 0xC9, 0xA1, 0x2F, 0xF7, 0x86, 0xD1, 0x66, + 0x92, 0x51, 0xED, 0x0A, 0xC2, 0x58, 0x91, 0x0D, + 0x2B, 0xAE, 0xB7, 0x59, 0xDB, 0x67, 0x04, 0x74 + }, + { + 0x3B, 0xC9, 0xB3, 0xCF, 0x39, 0xEB, 0x87, 0x88, + 0x2A, 0x41, 0x14, 0xA5, 0xD0, 0xE1, 0xB2, 0xCE, + 0xB9, 0xA6, 0xA7, 0x45, 0x8C, 0x6F, 0x69, 0x87, + 0xBE, 0xBF, 0x46, 0xCB, 0xFF, 0xD0, 0xBD, 0x6E, + 0xCA, 0x3D, 0x50, 0xCF, 0x8D, 0xA9, 0xBF, 0xE3, + 0x64, 0x3F, 0x45, 0xE3, 0xC6, 0x17, 0xF2, 0xD1, + 0x62, 0x43, 0xB9, 0x47, 0x8D, 0xD2, 0xED, 0x1F, + 0x34, 0x34, 0xB6, 0x51, 0xA5, 0xF2, 0x9E, 0xCE + }, + { + 0x3C, 0xF9, 0x52, 0x20, 0x36, 0x16, 0xF4, 0xF4, + 0xBA, 0x5C, 0xE8, 0xB5, 0x24, 0xAF, 0x6A, 0x3B, + 0xA9, 0xE8, 0xE8, 0x09, 0xDB, 0x09, 0x92, 0xA3, + 0xB4, 0x1C, 0xB5, 0xB9, 0x8C, 0x3F, 0x45, 0xC4, + 0x32, 0xFB, 0x73, 0x0C, 0xFC, 0xB3, 0x7D, 0xFB, + 0x08, 0xEA, 0x30, 0x8B, 0xAD, 0x6E, 0x5E, 0xC2, + 0x1E, 0x49, 0x99, 0x27, 0x40, 0xEF, 0xC1, 0x85, + 0x13, 0x8C, 0xD8, 0x54, 0xF9, 0x2F, 0x83, 0xF8 + }, + { + 0xBA, 0xC9, 0x22, 0x66, 0x75, 0x4D, 0xF4, 0x74, + 0xB8, 0x74, 0xE2, 0x07, 0x7F, 0xF6, 0x4C, 0xE6, + 0x59, 0x41, 0x90, 0x90, 0x2A, 0x45, 0x82, 0x56, + 0xEE, 0xC0, 0x91, 0x93, 0xC2, 0x3C, 0x25, 0x3B, + 0x6E, 0x26, 0x66, 0x4D, 0x04, 0x8D, 0xB6, 0xFD, + 0x70, 0x26, 0xD0, 0x2F, 0x07, 0xA4, 0xDD, 0x52, + 0xCD, 0x01, 0x0D, 0x8A, 0x87, 0x63, 0x98, 0x90, + 0xA1, 0x7F, 0xFF, 0x8B, 0x50, 0x55, 0x07, 0xFB + }, + { + 0x5D, 0x03, 0xCB, 0x16, 0x9B, 0x7C, 0xF7, 0xFA, + 0x83, 0x1A, 0x96, 0x50, 0x72, 0x6E, 0x2B, 0x5B, + 0x36, 0x71, 0xAA, 0xDA, 0xFE, 0x17, 0x63, 0x0B, + 0x7D, 0xB3, 0x54, 0x83, 0xDD, 0x3D, 0x7E, 0x4C, + 0x4E, 0xF0, 0x51, 0xDA, 0x5B, 0x82, 0x82, 0x99, + 0xF9, 0xD6, 0x4F, 0xD2, 0x4F, 0xDF, 0xCE, 0xAB, + 0xE6, 0x2C, 0x0C, 0x01, 0x38, 0x5F, 0x17, 0x54, + 0x29, 0x4D, 0xEB, 0xFA, 0x8C, 0xB0, 0x74, 0x96 + }, + { + 0x3D, 0xBD, 0x72, 0x21, 0x77, 0x73, 0xE8, 0x4C, + 0x0D, 0x5C, 0xB0, 0xBA, 0xD6, 0xB9, 0xC4, 0xAA, + 0x05, 0x1C, 0x55, 0x41, 0x16, 0x8E, 0x7F, 0xD2, + 0x7F, 0x47, 0xB3, 0x82, 0x50, 0x96, 0x48, 0xEE, + 0x64, 0x40, 0x5D, 0x69, 0xBD, 0x17, 0x14, 0x08, + 0x36, 0x96, 0x30, 0x36, 0xD4, 0xB8, 0xE3, 0xB9, + 0xBB, 0x6B, 0xF0, 0xFA, 0x61, 0x25, 0xE7, 0x92, + 0xF7, 0x5E, 0xA2, 0x99, 0x64, 0x5C, 0xE7, 0x85 + }, + { + 0xF7, 0x43, 0x9F, 0x67, 0x29, 0xB0, 0xCD, 0x4D, + 0xC6, 0x9C, 0xE6, 0x8A, 0x5E, 0x11, 0x8A, 0x60, + 0xE6, 0x87, 0x4D, 0x56, 0x80, 0x47, 0x94, 0x69, + 0x12, 0x57, 0x16, 0x0B, 0x38, 0x43, 0xE6, 0x75, + 0x1F, 0xA1, 0x9B, 0x87, 0x77, 0x5D, 0x9B, 0x85, + 0xA0, 0x5D, 0xC1, 0x20, 0xDD, 0xBB, 0x54, 0x7E, + 0xA7, 0xC2, 0x05, 0x1B, 0xD3, 0xE6, 0xC1, 0x0D, + 0x52, 0x2C, 0x77, 0x81, 0xFA, 0xA1, 0x04, 0x13 + }, + { + 0xA8, 0xF0, 0xDC, 0x3E, 0xE1, 0x69, 0xE6, 0x06, + 0xA5, 0x8D, 0x28, 0xC6, 0x0F, 0xA6, 0x25, 0x36, + 0xD6, 0xDA, 0xC6, 0xE1, 0x53, 0x9D, 0x42, 0x62, + 0x2C, 0x97, 0x61, 0x85, 0x18, 0x9D, 0xBC, 0xFC, + 0x21, 0xD9, 0x0D, 0x61, 0xFF, 0xB2, 0x57, 0xA1, + 0x66, 0x13, 0x64, 0x21, 0x57, 0x2F, 0x54, 0x17, + 0x14, 0x8E, 0x44, 0x03, 0x4E, 0xA0, 0xAA, 0xA2, + 0x1A, 0xE9, 0x1A, 0x82, 0xF3, 0x70, 0xFD, 0x9F + }, + { + 0x19, 0xD6, 0x0A, 0x20, 0x8A, 0x4F, 0x85, 0x98, + 0x46, 0x03, 0x01, 0xF2, 0x0B, 0x59, 0xE3, 0xE5, + 0xA6, 0xCC, 0x70, 0xEE, 0x7A, 0x39, 0x44, 0xB1, + 0x99, 0x76, 0xA8, 0xF8, 0xA2, 0xC6, 0x00, 0x3F, + 0xCE, 0xC4, 0x87, 0x02, 0xD9, 0xAB, 0xEC, 0x67, + 0x80, 0xF1, 0x3D, 0x2E, 0x66, 0xB7, 0x70, 0x5E, + 0xF4, 0x54, 0x6F, 0xE7, 0xF5, 0x4D, 0xA0, 0xC6, + 0x2E, 0x7A, 0xDD, 0xA3, 0x8F, 0xB3, 0xCA, 0x0C + }, + { + 0x90, 0xAE, 0x03, 0x4C, 0x57, 0xA4, 0xE2, 0x0C, + 0x57, 0x25, 0x96, 0x01, 0xE1, 0xED, 0xE9, 0x40, + 0xE6, 0x20, 0x29, 0x5A, 0xAD, 0xE2, 0x41, 0x47, + 0x90, 0x85, 0x8D, 0x90, 0x47, 0x37, 0x13, 0x0B, + 0x5D, 0x62, 0x34, 0x17, 0x72, 0xB2, 0x69, 0x57, + 0x20, 0x72, 0xB7, 0xFD, 0xC3, 0x4B, 0xB0, 0xC6, + 0xFA, 0x9F, 0x8E, 0xD7, 0xA4, 0x3D, 0x3D, 0xD0, + 0x0C, 0x34, 0xB2, 0x3C, 0x37, 0x78, 0x8D, 0x35 + }, + { + 0xD0, 0x72, 0x4B, 0x76, 0x41, 0x9F, 0x4A, 0x14, + 0xB3, 0xB1, 0xB0, 0xCE, 0x4B, 0x7B, 0x4D, 0x3B, + 0x5D, 0x06, 0x09, 0x29, 0x03, 0x1B, 0xA5, 0x89, + 0x42, 0xCF, 0x99, 0xE1, 0xF8, 0xBC, 0x67, 0x66, + 0x5A, 0x08, 0xAB, 0x97, 0xA9, 0x5F, 0xC9, 0xCB, + 0xE8, 0x72, 0x53, 0x71, 0x18, 0x6A, 0x8C, 0x74, + 0xCC, 0x03, 0x93, 0x13, 0x3A, 0x0F, 0xFA, 0x04, + 0x26, 0x0D, 0xC3, 0xF3, 0xFE, 0xA9, 0x48, 0x91 + }, + { + 0x62, 0xDD, 0xB5, 0x21, 0x87, 0xBD, 0x4A, 0x23, + 0x96, 0x62, 0xF0, 0x5D, 0x53, 0xE7, 0x06, 0xB9, + 0xB5, 0xCB, 0x8F, 0xA4, 0x56, 0xDC, 0x81, 0x5D, + 0x67, 0x07, 0xC7, 0x4D, 0x16, 0x9A, 0x81, 0x12, + 0x4C, 0x90, 0x7C, 0xD4, 0xD1, 0xC0, 0xEE, 0x51, + 0xCD, 0x6B, 0x33, 0xE0, 0x4E, 0xF0, 0x47, 0xD6, + 0x74, 0x73, 0x3A, 0x96, 0x95, 0x55, 0xBD, 0x32, + 0x8C, 0xA8, 0xF7, 0xAB, 0x40, 0xD6, 0xD1, 0x4C + }, + { + 0x0C, 0x3A, 0x27, 0x80, 0xFE, 0x95, 0xD7, 0xE1, + 0x0B, 0xC9, 0x61, 0xFC, 0x7C, 0xC3, 0xDC, 0xB4, + 0x73, 0x2D, 0x25, 0xDC, 0xFA, 0xCF, 0xAF, 0xC3, + 0xB7, 0x55, 0xCA, 0xF7, 0x0E, 0xBE, 0xB9, 0xF1, + 0x03, 0x01, 0xCF, 0x03, 0x03, 0xEC, 0x22, 0x72, + 0x03, 0x98, 0x5E, 0x17, 0xF8, 0x38, 0x77, 0x17, + 0x3C, 0x7E, 0xED, 0xBC, 0xC8, 0x74, 0x7A, 0xAF, + 0xDD, 0x4E, 0xCA, 0x67, 0x36, 0x46, 0x18, 0x78 + }, + { + 0xD3, 0xE4, 0x3B, 0x52, 0x68, 0x62, 0x26, 0xFB, + 0x15, 0x03, 0x57, 0xE6, 0x19, 0x94, 0x4E, 0x55, + 0x2C, 0x73, 0xEE, 0x44, 0xBB, 0xAB, 0xBE, 0x11, + 0x75, 0xF0, 0x75, 0x8A, 0x1F, 0x8E, 0x7E, 0xEA, + 0x29, 0xF5, 0x70, 0x14, 0xF1, 0xDD, 0xD0, 0xC9, + 0x1C, 0xE9, 0x74, 0x02, 0x8B, 0xC4, 0x50, 0x0F, + 0x3F, 0x00, 0x05, 0xC1, 0x78, 0x68, 0x37, 0x2D, + 0x64, 0x42, 0xFF, 0x39, 0x91, 0xB3, 0x3C, 0x76 + }, + { + 0x14, 0xFA, 0x7E, 0xE2, 0x38, 0xE9, 0x89, 0x96, + 0x86, 0x5A, 0xB9, 0x39, 0xB5, 0x67, 0x0B, 0x0E, + 0x9B, 0x90, 0xF9, 0x73, 0xC4, 0xF9, 0xC0, 0xE7, + 0xF5, 0x81, 0xAB, 0x93, 0xD2, 0xB2, 0xC2, 0xFA, + 0x8C, 0x2B, 0x10, 0x20, 0x41, 0x5A, 0x31, 0x4B, + 0x9C, 0xFC, 0x46, 0xAC, 0xB4, 0xB1, 0xDE, 0x4F, + 0x76, 0x17, 0xDA, 0xD8, 0x25, 0x4A, 0x0A, 0x50, + 0x91, 0x9F, 0x55, 0xBC, 0x92, 0xE2, 0x5D, 0x2B + }, + { + 0x39, 0x5B, 0x7F, 0x02, 0xC4, 0xF7, 0x51, 0xB4, + 0xDF, 0x97, 0x2C, 0x3B, 0x95, 0xC4, 0x62, 0x4F, + 0x39, 0xE2, 0x0E, 0x11, 0x9E, 0x59, 0xE4, 0xE6, + 0x21, 0x77, 0x46, 0x6F, 0x55, 0xCE, 0x86, 0xEC, + 0x7F, 0x04, 0x2F, 0x41, 0x53, 0x22, 0x11, 0xF5, + 0x12, 0xE9, 0xC5, 0xDE, 0xE6, 0xEF, 0x2D, 0x3D, + 0x4D, 0xAF, 0x7D, 0x24, 0x7D, 0x11, 0x5E, 0x79, + 0x32, 0x36, 0x6A, 0x9B, 0xC3, 0x8E, 0x25, 0x7E + }, + { + 0x1E, 0xA3, 0xC9, 0xF2, 0xCC, 0x82, 0x8D, 0x6D, + 0xCD, 0x0B, 0x0A, 0xD6, 0xE9, 0x10, 0x57, 0xD0, + 0x7E, 0x9D, 0x7C, 0x39, 0x29, 0x20, 0xA7, 0x43, + 0x0E, 0xD3, 0xE2, 0xD1, 0xEC, 0x59, 0x97, 0xA2, + 0xFF, 0x18, 0xD2, 0xFD, 0xDF, 0xF1, 0x65, 0xC2, + 0x71, 0xD4, 0x60, 0xAA, 0x3C, 0xDD, 0xB4, 0x1B, + 0x58, 0x08, 0xE7, 0xF9, 0x4D, 0x4A, 0x7D, 0xC1, + 0x10, 0x28, 0x74, 0xF8, 0x4D, 0x63, 0x6F, 0x2F + }, + { + 0xE0, 0x83, 0xFC, 0xDF, 0x4E, 0x02, 0x0A, 0xB0, + 0xBB, 0x6E, 0xA1, 0x0E, 0xDF, 0x9A, 0x5D, 0xEB, + 0xC7, 0xAD, 0x78, 0x9F, 0x65, 0x54, 0xEA, 0x24, + 0xD1, 0x9B, 0xE8, 0x7F, 0x7D, 0xC0, 0x91, 0x19, + 0x2B, 0x6C, 0x2B, 0x83, 0x54, 0x66, 0x46, 0x18, + 0x92, 0x9A, 0x5F, 0x0C, 0xBA, 0xE3, 0x09, 0x4C, + 0xA3, 0x61, 0xFA, 0x81, 0xB5, 0x21, 0x30, 0xBD, + 0x78, 0xC3, 0x48, 0xA0, 0x86, 0xCF, 0x85, 0xC7 + }, + { + 0xB8, 0x26, 0x84, 0x25, 0xFA, 0x6C, 0x6B, 0xAA, + 0x32, 0x7D, 0xA5, 0x36, 0x9E, 0xAD, 0x6E, 0x7F, + 0x84, 0x7A, 0xF9, 0x1B, 0xCE, 0x51, 0xBC, 0x6C, + 0xB2, 0x06, 0x67, 0x36, 0x34, 0xA7, 0xF4, 0x45, + 0xF4, 0x19, 0x8B, 0xF2, 0x4B, 0xB9, 0x7D, 0x33, + 0x66, 0x8D, 0xC9, 0x31, 0x1D, 0x41, 0x15, 0x04, + 0x65, 0x6F, 0x21, 0x1E, 0x57, 0x6F, 0x2B, 0x02, + 0x9D, 0x1F, 0x77, 0xEE, 0x6A, 0x82, 0x7C, 0xB0 + }, + { + 0x63, 0x1B, 0x66, 0x2B, 0xBF, 0x00, 0x38, 0xE0, + 0xF6, 0x17, 0xEC, 0xDA, 0xFE, 0x82, 0x8D, 0x75, + 0x2B, 0x8E, 0x5A, 0x95, 0x76, 0x3C, 0x13, 0xC2, + 0x1A, 0xCA, 0x06, 0xAD, 0xB1, 0x2E, 0x89, 0x6B, + 0x5F, 0x48, 0x58, 0xA2, 0x3A, 0x38, 0x05, 0x29, + 0x5C, 0xC8, 0x63, 0xE9, 0xDE, 0xFB, 0x3E, 0x29, + 0xCB, 0xC8, 0x22, 0x5B, 0x3D, 0x87, 0x67, 0xCF, + 0x10, 0xB4, 0xC9, 0x7E, 0x58, 0x0A, 0xB0, 0x83 + }, + { + 0xB5, 0xFB, 0xC9, 0xC2, 0x15, 0x8E, 0x14, 0x7D, + 0x03, 0x56, 0xA9, 0xD6, 0x54, 0xDB, 0xC2, 0x11, + 0x9A, 0xD2, 0x27, 0xEF, 0x11, 0x62, 0xC0, 0xAA, + 0xF5, 0x8C, 0x45, 0x9C, 0x9D, 0x64, 0xFD, 0x3D, + 0x55, 0x9D, 0xA8, 0x40, 0xB5, 0x0D, 0x1E, 0x75, + 0xBD, 0xBC, 0x92, 0xF1, 0x6A, 0xD0, 0x2D, 0x8C, + 0xF9, 0x0C, 0x84, 0x61, 0x24, 0xF4, 0x89, 0x13, + 0x7C, 0x92, 0xE2, 0x45, 0xA0, 0x47, 0xE7, 0x39 + }, + { + 0x5A, 0x2D, 0x19, 0xD2, 0x36, 0x8C, 0x2E, 0x70, + 0xDB, 0x57, 0xF6, 0x93, 0xD2, 0xE6, 0x66, 0x98, + 0x00, 0xD7, 0x38, 0x96, 0x7F, 0x68, 0xA2, 0x67, + 0xC9, 0x8F, 0x2A, 0x88, 0x13, 0xE4, 0x9D, 0x54, + 0x4E, 0x13, 0xAD, 0x12, 0x82, 0xF7, 0x2A, 0x51, + 0x2D, 0xB7, 0x4E, 0xD2, 0x63, 0x7F, 0x34, 0x75, + 0x87, 0x39, 0xB5, 0x6D, 0x78, 0xE5, 0xD7, 0x00, + 0x8C, 0x9A, 0xF4, 0xB5, 0x9C, 0x48, 0x59, 0xA5 + }, + { + 0x1A, 0x6C, 0x19, 0x87, 0xC4, 0x5A, 0x51, 0xF6, + 0x99, 0xCD, 0xEC, 0x9A, 0xB7, 0x1E, 0xC8, 0x7B, + 0x71, 0x82, 0x7F, 0x94, 0x7B, 0xB8, 0x67, 0x87, + 0x86, 0xCC, 0xE1, 0x54, 0x38, 0x3A, 0x6A, 0x68, + 0x96, 0xCC, 0x0C, 0x52, 0x50, 0x62, 0xB3, 0x55, + 0x4F, 0x82, 0xE1, 0x21, 0x0F, 0x34, 0x14, 0xCE, + 0x37, 0x38, 0xDF, 0x48, 0x4E, 0x5E, 0x70, 0x38, + 0x5E, 0x80, 0x79, 0xA9, 0x28, 0xC5, 0x42, 0x49 + }, + { + 0x85, 0x93, 0x86, 0x35, 0x15, 0x51, 0xA7, 0x25, + 0x4C, 0xFC, 0xEF, 0xA8, 0x71, 0xCA, 0xD8, 0xF8, + 0x5D, 0xCA, 0x12, 0x29, 0xCD, 0xC1, 0x7B, 0xEE, + 0xB1, 0x01, 0xEF, 0x45, 0xEA, 0xFC, 0x9E, 0xD7, + 0x09, 0x7C, 0x42, 0x89, 0x67, 0xA6, 0xE1, 0x1C, + 0xEA, 0xF8, 0x52, 0xE9, 0x51, 0x58, 0x1C, 0x4F, + 0xE2, 0xF8, 0x7E, 0x27, 0xFB, 0x37, 0x3E, 0xB4, + 0xB8, 0x6D, 0x75, 0x96, 0xCB, 0xEB, 0x7F, 0xE2 + }, + { + 0x93, 0xB5, 0xCF, 0x84, 0x25, 0x4C, 0xE7, 0xA3, + 0x24, 0xF9, 0x92, 0x9D, 0x55, 0x9A, 0xF4, 0x1E, + 0xC2, 0x1D, 0x39, 0x15, 0x0A, 0xDE, 0x59, 0x81, + 0xF0, 0xCB, 0xE5, 0x67, 0x8D, 0x31, 0x3C, 0x18, + 0xF7, 0x59, 0x70, 0x84, 0xF9, 0x36, 0x43, 0x3D, + 0xEC, 0xDA, 0x6E, 0xA3, 0xA8, 0x77, 0x17, 0x0C, + 0xFD, 0x6C, 0xA6, 0xFE, 0xC8, 0x23, 0x44, 0x92, + 0x3E, 0x6A, 0xAF, 0x73, 0xCD, 0xE5, 0x86, 0x86 + }, + { + 0x72, 0x06, 0x6C, 0x30, 0xE2, 0x7D, 0xCC, 0x8A, + 0xCE, 0x3A, 0xF4, 0x86, 0x11, 0xB9, 0xC8, 0x12, + 0x20, 0xAF, 0xF4, 0xE7, 0x41, 0x92, 0x6E, 0x1A, + 0x33, 0x44, 0x6F, 0xEA, 0x1D, 0xFF, 0xCA, 0x9F, + 0x3F, 0x1B, 0xBF, 0x3D, 0x5D, 0x62, 0x2C, 0xBF, + 0x32, 0x73, 0x60, 0x34, 0x8A, 0x29, 0x1E, 0xE7, + 0x0B, 0xF8, 0x6A, 0x83, 0xDB, 0xB0, 0x93, 0xEE, + 0x06, 0x08, 0xD0, 0x87, 0xF1, 0x2D, 0x7E, 0xDD + }, + { + 0x4E, 0x83, 0x82, 0x97, 0x39, 0x57, 0x24, 0xD5, + 0xF6, 0xF3, 0xA8, 0x67, 0x29, 0xBB, 0x9A, 0x80, + 0x96, 0x78, 0xCF, 0xBE, 0x10, 0x9A, 0x34, 0x86, + 0xC9, 0xB3, 0xD7, 0x36, 0xEC, 0xEE, 0xCA, 0xA1, + 0x95, 0x28, 0xA7, 0x09, 0x46, 0xD0, 0x60, 0xF1, + 0xDB, 0xB1, 0x62, 0x5D, 0x24, 0x09, 0x00, 0x6C, + 0x86, 0xF0, 0xC0, 0xBA, 0xFE, 0x61, 0x50, 0x28, + 0xC0, 0x5C, 0x61, 0x4C, 0xF5, 0x1E, 0xDC, 0xEB + }, + { + 0x1E, 0x30, 0xA5, 0x4F, 0x78, 0x25, 0xA3, 0xE3, + 0x94, 0x94, 0x30, 0xE8, 0x20, 0x58, 0xD8, 0x03, + 0x16, 0x99, 0x69, 0x42, 0xB7, 0xB6, 0xC2, 0x3D, + 0x2B, 0x68, 0x4F, 0xA3, 0x71, 0x26, 0x42, 0xC6, + 0x70, 0x81, 0x32, 0x5A, 0xA5, 0x1D, 0xE2, 0x10, + 0xB7, 0x5A, 0x9F, 0xFB, 0xF7, 0xB6, 0xAF, 0x2F, + 0xEC, 0x80, 0xA2, 0x87, 0xD0, 0x04, 0x9D, 0x7E, + 0x9E, 0xBF, 0x0E, 0xD8, 0x6D, 0x24, 0x2A, 0x25 + }, + { + 0x46, 0x88, 0xEE, 0x55, 0xC9, 0x25, 0xC7, 0xD5, + 0x01, 0x64, 0x61, 0xE7, 0xEA, 0xDB, 0x4E, 0x8B, + 0xDC, 0x32, 0x1A, 0x8E, 0x06, 0x8E, 0x0C, 0xD6, + 0xA9, 0x78, 0x5A, 0xBA, 0x68, 0x48, 0x2F, 0x6B, + 0x68, 0x89, 0x8F, 0x70, 0x38, 0x68, 0xE4, 0x50, + 0xB8, 0xA0, 0xCC, 0x57, 0x25, 0xE7, 0xD2, 0xAC, + 0x30, 0x04, 0x10, 0x93, 0x63, 0xA0, 0xC0, 0xAA, + 0xD4, 0xA5, 0x5B, 0xD1, 0xD1, 0xA4, 0xEF, 0xAC + }, + { + 0xC6, 0x91, 0x4C, 0x2C, 0x46, 0x83, 0x9A, 0xDF, + 0x9C, 0xF9, 0xE1, 0xFF, 0x92, 0xBE, 0x62, 0x0E, + 0x67, 0x59, 0xAB, 0xF6, 0xED, 0x60, 0x18, 0x21, + 0xC1, 0xC6, 0x95, 0x7D, 0xAD, 0x1F, 0x52, 0x75, + 0x38, 0xD2, 0xE8, 0x79, 0x62, 0x14, 0x2D, 0xA7, + 0x62, 0xD0, 0x36, 0xFF, 0x90, 0x0B, 0xD1, 0x84, + 0x87, 0xEB, 0x08, 0x8C, 0x60, 0x46, 0x82, 0xAE, + 0x1D, 0x7A, 0x6D, 0x78, 0xAE, 0x14, 0x5C, 0x3E + }, + { + 0x7C, 0xFE, 0x4B, 0x8B, 0xF1, 0x6D, 0xA2, 0x95, + 0x22, 0x00, 0x6B, 0x43, 0x63, 0x1F, 0x85, 0x88, + 0x0B, 0xAC, 0xE7, 0x45, 0xBA, 0x74, 0x82, 0xDD, + 0x6F, 0x82, 0x2F, 0x17, 0x6E, 0x58, 0xFA, 0x66, + 0x1D, 0x9F, 0x5B, 0x08, 0xBE, 0x51, 0x35, 0x85, + 0x16, 0xB0, 0x97, 0x80, 0x3C, 0x6D, 0xB7, 0x50, + 0xE8, 0x97, 0xD4, 0x50, 0x5D, 0x0F, 0xC2, 0x68, + 0x12, 0xC3, 0xA1, 0x4E, 0x8C, 0x4C, 0x8B, 0xF0 + }, + { + 0xE8, 0xDC, 0xAE, 0x93, 0x88, 0xF5, 0x76, 0xC5, + 0x07, 0x89, 0x21, 0x89, 0xC3, 0x76, 0x27, 0xE7, + 0xE8, 0xEB, 0x33, 0xB3, 0xF9, 0x62, 0x7E, 0x0E, + 0x86, 0x05, 0x94, 0xB9, 0x38, 0xD7, 0xF2, 0x14, + 0xC2, 0xEA, 0xEE, 0xAA, 0x17, 0xBF, 0x11, 0xBA, + 0x2B, 0xDF, 0x35, 0xED, 0xE7, 0x35, 0x3E, 0x45, + 0x3B, 0x12, 0x87, 0xD2, 0x98, 0xC3, 0x90, 0xE0, + 0xA5, 0x4B, 0x87, 0x81, 0x0A, 0x67, 0x17, 0xEE + }, + { + 0xF7, 0xC7, 0xDC, 0xC8, 0x48, 0x73, 0xAB, 0x4B, + 0xBF, 0x57, 0xD3, 0x47, 0x1B, 0x95, 0xED, 0x62, + 0x72, 0x3E, 0x77, 0x35, 0xB3, 0xD1, 0x81, 0x35, + 0x0F, 0x35, 0xDD, 0x38, 0xAC, 0x80, 0x92, 0x49, + 0x1B, 0x81, 0x4D, 0x03, 0x31, 0xA2, 0x07, 0xCD, + 0x07, 0x3A, 0x0A, 0x26, 0xAF, 0x0E, 0x26, 0xD6, + 0x05, 0xB1, 0x21, 0xB9, 0x98, 0x04, 0x54, 0x97, + 0x58, 0x77, 0x0D, 0xC1, 0x3D, 0x46, 0xB2, 0x91 + }, + { + 0x9B, 0x42, 0x11, 0x7D, 0xC3, 0x26, 0x57, 0x7D, + 0xFF, 0x59, 0xD9, 0x4F, 0x55, 0x72, 0xB6, 0x57, + 0x16, 0x90, 0x45, 0x3D, 0x79, 0x32, 0xF1, 0x93, + 0x0B, 0x1B, 0x39, 0xCF, 0xD2, 0x40, 0xCD, 0xCA, + 0x9A, 0xBD, 0x59, 0x3B, 0x42, 0xB2, 0x21, 0xB1, + 0x8A, 0xB6, 0x27, 0xB1, 0x78, 0x5B, 0x7A, 0x2F, + 0x57, 0x82, 0x24, 0x7C, 0x9E, 0x1E, 0x5A, 0xB5, + 0xBA, 0x92, 0xFC, 0x3C, 0x61, 0x21, 0xD3, 0xB2 + }, + { + 0x3B, 0x76, 0x44, 0x87, 0x28, 0xFE, 0x61, 0x29, + 0x01, 0x01, 0x3F, 0x32, 0x86, 0xA9, 0xF8, 0xB7, + 0x84, 0xFA, 0xB0, 0x9E, 0x56, 0x04, 0x34, 0xAC, + 0xFE, 0x72, 0x63, 0xF2, 0x0F, 0xA5, 0x50, 0x85, + 0xC2, 0x7E, 0xE8, 0xB8, 0x82, 0x8C, 0x0E, 0x61, + 0x8B, 0x61, 0xFF, 0xDC, 0xC5, 0x9E, 0x09, 0xC3, + 0x2E, 0x2D, 0xE3, 0x89, 0x0B, 0xA2, 0xDA, 0x33, + 0x65, 0x28, 0x51, 0xEA, 0x8A, 0x82, 0xEE, 0x4C + }, + { + 0x58, 0xC0, 0x79, 0xCB, 0x8A, 0x20, 0xDA, 0xEF, + 0x2F, 0x29, 0xFC, 0x9F, 0x98, 0x9D, 0xE7, 0xA0, + 0x8E, 0x64, 0xD4, 0x15, 0xF0, 0x96, 0x67, 0x52, + 0x6B, 0x2C, 0xBA, 0x6A, 0xAE, 0xC8, 0x09, 0xE6, + 0x45, 0x06, 0x67, 0xC9, 0x7E, 0xE9, 0x40, 0xDA, + 0xCE, 0x94, 0x98, 0xBF, 0x7E, 0x49, 0x23, 0xDA, + 0x69, 0x17, 0x1A, 0x86, 0xCB, 0x79, 0xC7, 0x1D, + 0xB0, 0x35, 0xCD, 0xE7, 0x91, 0xB0, 0x1B, 0x53 + }, + { + 0x02, 0x5B, 0x72, 0xD7, 0x02, 0x57, 0xA7, 0x9B, + 0x99, 0xE0, 0x43, 0xAE, 0x16, 0x37, 0x28, 0xF3, + 0x66, 0x7E, 0x89, 0x4A, 0x48, 0x92, 0x88, 0xFE, + 0x1E, 0x01, 0xC4, 0xBB, 0x4D, 0x93, 0xC4, 0x1B, + 0x36, 0x6B, 0x51, 0xFB, 0x01, 0x62, 0xBF, 0xCF, + 0xC0, 0x43, 0xBD, 0xB3, 0x6B, 0xBD, 0x26, 0xF0, + 0x77, 0xEC, 0x8B, 0x9B, 0xA9, 0xA1, 0x31, 0x6E, + 0x4D, 0xB4, 0xD4, 0xD1, 0xD8, 0x8C, 0x9E, 0xEB + }, + { + 0x90, 0x9D, 0x57, 0xFA, 0xAA, 0xEF, 0x4A, 0x7F, + 0xF8, 0x72, 0x29, 0xB9, 0xEC, 0xDF, 0xA7, 0x3B, + 0xC2, 0x7F, 0xEA, 0x1D, 0xD1, 0x72, 0xB1, 0x11, + 0x0D, 0xB1, 0x1D, 0x29, 0x26, 0x68, 0x97, 0x7F, + 0x61, 0x3A, 0xD7, 0xEB, 0xB9, 0xA2, 0x89, 0xF6, + 0x72, 0x2A, 0x46, 0x56, 0x39, 0xB3, 0xB6, 0xFC, + 0x22, 0x7D, 0x5C, 0xDA, 0x2D, 0xDF, 0x5B, 0x6A, + 0x31, 0x5C, 0x55, 0x7C, 0x8A, 0xD5, 0x10, 0x3D + }, + { + 0xAD, 0xCD, 0x52, 0x31, 0x81, 0x3E, 0xDC, 0xC5, + 0x2A, 0xB2, 0x61, 0xFD, 0x70, 0xC5, 0xBC, 0xD9, + 0x1D, 0xB0, 0xB2, 0x8D, 0xF2, 0x8A, 0x34, 0x0F, + 0xDA, 0xFD, 0x88, 0x01, 0xD8, 0xBA, 0x0C, 0xD7, + 0xF9, 0x7A, 0xF6, 0x27, 0x07, 0xFC, 0x02, 0x8B, + 0xD7, 0x2B, 0x2B, 0x86, 0x1D, 0xF9, 0xB9, 0x9B, + 0xD7, 0xA6, 0x96, 0xA6, 0x0E, 0xFD, 0xBA, 0xB1, + 0xDB, 0xA5, 0xB4, 0x16, 0xD8, 0x3E, 0x64, 0xC4 + }, + { + 0x10, 0x6F, 0x50, 0x5C, 0x47, 0x4E, 0x3F, 0xD0, + 0xD3, 0x26, 0xF1, 0x1C, 0xFB, 0xAB, 0x64, 0x83, + 0x8C, 0x74, 0xED, 0x57, 0x9C, 0xD7, 0x44, 0x12, + 0x4D, 0xA1, 0x58, 0x56, 0x25, 0xD3, 0x8C, 0x2C, + 0x78, 0x5C, 0x2E, 0x5F, 0xF5, 0x31, 0xFF, 0xB9, + 0x19, 0x1F, 0xEA, 0xE5, 0xB1, 0x2D, 0xF1, 0x3F, + 0x94, 0xF3, 0xAC, 0x53, 0xDB, 0xFF, 0x40, 0x26, + 0xF6, 0xCC, 0x19, 0xDB, 0x02, 0x06, 0xDD, 0xF1 + }, + { + 0x24, 0x28, 0x3B, 0xA6, 0x5C, 0xD8, 0x70, 0xF2, + 0x4D, 0xA0, 0x7F, 0x3A, 0x7C, 0x9C, 0x6A, 0x49, + 0x12, 0xC8, 0x0A, 0xA5, 0xEB, 0x85, 0x4D, 0x4C, + 0xB2, 0x00, 0x1E, 0x4D, 0xC0, 0x6E, 0x9B, 0xA0, + 0xCB, 0x6F, 0x27, 0xCB, 0xF6, 0xFC, 0x6D, 0xE7, + 0xC6, 0x66, 0x7D, 0x3B, 0x98, 0x96, 0x6E, 0xAA, + 0xFB, 0x27, 0xF2, 0x7E, 0xE9, 0x35, 0x2C, 0xE8, + 0x22, 0xDA, 0xB4, 0x9A, 0xCD, 0xAE, 0x09, 0x9A + }, + { + 0x90, 0x2A, 0x08, 0x1F, 0xF4, 0x58, 0xB4, 0x26, + 0x26, 0x68, 0x3E, 0x45, 0x72, 0x2E, 0xE1, 0x28, + 0x79, 0xF6, 0xA7, 0xAA, 0xE1, 0x0B, 0xEC, 0xF4, + 0xC7, 0x9D, 0x1D, 0xD6, 0x2E, 0xF7, 0x37, 0x24, + 0x7E, 0x31, 0x32, 0x31, 0x34, 0xEB, 0x9B, 0xE3, + 0x47, 0x64, 0x77, 0x24, 0x3C, 0x80, 0x5D, 0x89, + 0x3A, 0x56, 0xD0, 0x2C, 0xE2, 0xD8, 0x94, 0xE1, + 0x51, 0x89, 0x02, 0x47, 0x69, 0x8A, 0x2B, 0xEA + }, + { + 0x85, 0x1E, 0x0C, 0x97, 0xD7, 0xAB, 0x6D, 0x15, + 0x5B, 0x07, 0xD9, 0x89, 0xA8, 0x33, 0x6F, 0xA6, + 0x46, 0x80, 0xC5, 0x16, 0x5C, 0x14, 0xB1, 0xE7, + 0xCA, 0xFD, 0xFC, 0x7F, 0xE3, 0xD9, 0xAD, 0xDA, + 0x21, 0x00, 0x9A, 0x6D, 0x83, 0xAE, 0xCA, 0x6D, + 0x87, 0xDE, 0x45, 0x48, 0x7F, 0x43, 0xE9, 0x6B, + 0xD7, 0x17, 0xD7, 0xEA, 0x69, 0xF9, 0x0E, 0x06, + 0x93, 0x22, 0xC1, 0x56, 0x7E, 0xEB, 0x0E, 0xFB + }, + { + 0xED, 0xC2, 0x69, 0x2A, 0x55, 0x74, 0xED, 0x07, + 0x8C, 0x5F, 0xD1, 0xF0, 0x8D, 0xEF, 0x02, 0xAE, + 0x52, 0xD4, 0x4F, 0x90, 0x42, 0xE8, 0x41, 0xAF, + 0x09, 0x98, 0x60, 0xBB, 0x2D, 0xF4, 0x53, 0xDC, + 0x34, 0xB5, 0x33, 0x8C, 0x74, 0xE7, 0xC1, 0x7D, + 0x0D, 0xD3, 0xFC, 0x28, 0x42, 0x8C, 0x84, 0x39, + 0xD1, 0x67, 0x5C, 0x66, 0x83, 0xAD, 0x49, 0xC3, + 0x41, 0x73, 0x78, 0xA7, 0x62, 0x24, 0x3A, 0xD3 + }, + { + 0x64, 0x58, 0xFC, 0xA4, 0x30, 0x21, 0x37, 0x6D, + 0x14, 0x18, 0xA9, 0x73, 0x22, 0x57, 0x97, 0xE0, + 0xA1, 0xFD, 0x8E, 0x0E, 0xD3, 0x78, 0xEC, 0x78, + 0xB4, 0x46, 0x19, 0xB5, 0xD0, 0x9C, 0x15, 0x42, + 0x3A, 0x1A, 0x43, 0xDD, 0x92, 0x35, 0x5B, 0x5D, + 0x5C, 0x27, 0x6E, 0xCF, 0x5F, 0xE2, 0x15, 0xDE, + 0xAC, 0x0F, 0x2F, 0x0B, 0x3B, 0x0D, 0x39, 0x9D, + 0x32, 0xD8, 0xD9, 0x35, 0xCE, 0x26, 0x10, 0x21 + }, + { + 0x5B, 0x3A, 0xC1, 0x90, 0x77, 0xF3, 0x79, 0xEF, + 0x05, 0xB1, 0x1A, 0x38, 0x84, 0x9D, 0x6F, 0xF9, + 0xDE, 0x33, 0xB1, 0xD1, 0xB4, 0xBF, 0x71, 0x67, + 0x4E, 0x3A, 0xB5, 0x89, 0x4E, 0xC1, 0x91, 0x45, + 0x58, 0x3B, 0x0A, 0x9A, 0x95, 0x86, 0xB6, 0xF0, + 0xF9, 0x2C, 0x84, 0x8A, 0xEF, 0x95, 0x59, 0x4D, + 0x68, 0x43, 0x0B, 0x7C, 0x5D, 0x10, 0xCB, 0x4F, + 0xEE, 0x70, 0xA4, 0x73, 0x67, 0xC6, 0x60, 0x47 + }, + { + 0x57, 0x91, 0xAA, 0x20, 0x5E, 0x17, 0xA2, 0x63, + 0xE9, 0xBC, 0xA5, 0x40, 0x30, 0x26, 0xB8, 0x2D, + 0x40, 0x8C, 0x10, 0xA2, 0x1D, 0xA0, 0x77, 0x16, + 0x7E, 0x25, 0xF5, 0x8A, 0x6E, 0x8F, 0xCA, 0x34, + 0x0B, 0xBB, 0x13, 0x3D, 0x1E, 0xF0, 0x08, 0xC8, + 0x76, 0x50, 0x0D, 0x3F, 0x8A, 0x05, 0xA1, 0xED, + 0x83, 0xDC, 0x39, 0xD7, 0x48, 0x34, 0x47, 0x91, + 0x2A, 0xFD, 0x07, 0xA5, 0x9B, 0x23, 0x45, 0xE0 + }, + { + 0xA6, 0x6E, 0x66, 0x40, 0x4C, 0x55, 0x61, 0x06, + 0x4A, 0xFC, 0xA0, 0x9F, 0x8D, 0xA2, 0x54, 0x78, + 0x75, 0x7B, 0xE4, 0x4B, 0xD0, 0xBB, 0x85, 0x45, + 0xE1, 0x77, 0x8A, 0x82, 0xC5, 0x6D, 0x47, 0xA0, + 0x35, 0x95, 0xBC, 0xB8, 0x56, 0x2D, 0x3E, 0x37, + 0x4D, 0x5F, 0x14, 0xCF, 0x59, 0x77, 0x9C, 0xA8, + 0xF7, 0xDB, 0x61, 0xAB, 0x2F, 0x5D, 0x6C, 0x5E, + 0xBE, 0xA8, 0xE0, 0x8D, 0xC5, 0x9E, 0x9A, 0x29 + }, + { + 0xFE, 0x9E, 0xD5, 0x53, 0x92, 0x57, 0xF6, 0x7D, + 0xEE, 0x17, 0x32, 0xE7, 0x84, 0xD4, 0xF1, 0xBE, + 0xE2, 0x3D, 0x56, 0x50, 0x3B, 0xAC, 0xDD, 0x38, + 0xAA, 0x24, 0xD3, 0xFB, 0xB5, 0x28, 0x45, 0xA9, + 0x57, 0x81, 0x6F, 0x0C, 0xBB, 0xA5, 0xA5, 0x70, + 0xEC, 0x71, 0xE4, 0x47, 0xBD, 0x44, 0x92, 0x01, + 0x90, 0xBC, 0xFA, 0x33, 0x06, 0x93, 0x24, 0xFC, + 0x73, 0x5B, 0x9C, 0xCB, 0x49, 0xD5, 0x89, 0x65 + }, + { + 0x71, 0x98, 0xED, 0x1A, 0x3E, 0x6C, 0x18, 0x2D, + 0x78, 0x80, 0x43, 0x7C, 0x66, 0x4B, 0x0E, 0xC0, + 0x2C, 0x87, 0x66, 0x0F, 0x37, 0x29, 0xE0, 0x93, + 0x93, 0x70, 0xFE, 0x8C, 0xD4, 0x28, 0xFA, 0x69, + 0x55, 0x0A, 0xB6, 0x93, 0xD8, 0xCB, 0x74, 0x90, + 0x68, 0x43, 0xDA, 0xDC, 0xA6, 0x3F, 0x67, 0x72, + 0xA9, 0x97, 0xD7, 0xDA, 0x80, 0x39, 0xB5, 0xB7, + 0xEA, 0x8D, 0xD9, 0xD3, 0x85, 0x82, 0xDE, 0xDC + }, + { + 0x1D, 0x53, 0x16, 0x73, 0x75, 0x54, 0xFB, 0x85, + 0x68, 0xAB, 0xE7, 0x5E, 0xF6, 0x46, 0x63, 0x4A, + 0x09, 0x3E, 0xA3, 0xD8, 0x36, 0xAC, 0x9F, 0xDA, + 0x31, 0xFC, 0x36, 0x31, 0x1D, 0x64, 0x2B, 0xBA, + 0x12, 0xC5, 0x46, 0xCF, 0x62, 0x45, 0x2D, 0xCC, + 0x40, 0xD0, 0xEA, 0xF3, 0x5F, 0x77, 0x98, 0x70, + 0x5A, 0x2D, 0xB2, 0xFB, 0xD6, 0xF4, 0xFF, 0x2F, + 0xCB, 0x92, 0x0B, 0xE4, 0x40, 0x93, 0x31, 0xB0 + }, + { + 0x47, 0xEE, 0xDC, 0x26, 0x23, 0xC9, 0x98, 0xB2, + 0xEF, 0xF6, 0x85, 0x7A, 0x97, 0x0F, 0x94, 0xC0, + 0x76, 0x9C, 0x18, 0xDB, 0x85, 0x90, 0xDD, 0xDC, + 0x89, 0x85, 0x85, 0x35, 0x0D, 0xEE, 0xDC, 0x10, + 0x68, 0xA2, 0xA7, 0x9A, 0xA5, 0xF5, 0x14, 0x5C, + 0x4F, 0xA5, 0xF5, 0x1D, 0xDD, 0xFC, 0x4F, 0x1E, + 0xBB, 0x62, 0xF3, 0x10, 0x64, 0x5C, 0xAF, 0x96, + 0x3C, 0x91, 0x9D, 0xAB, 0xA9, 0x15, 0xD0, 0x03 + }, + { + 0x65, 0x8F, 0x42, 0xF0, 0x10, 0xF0, 0xD9, 0x42, + 0x1C, 0x25, 0x72, 0x5B, 0x7C, 0x47, 0xBA, 0x87, + 0xEF, 0xC6, 0xA0, 0xDD, 0x31, 0xE4, 0x6A, 0xCC, + 0x6D, 0xA9, 0x6E, 0x0F, 0xCB, 0x1E, 0x42, 0xA3, + 0x0C, 0x7C, 0x22, 0x0C, 0x8A, 0xD7, 0x97, 0xE0, + 0xE6, 0x6D, 0x07, 0x8C, 0xFC, 0x7C, 0x86, 0x17, + 0x27, 0x12, 0x58, 0xA0, 0x00, 0x63, 0xB8, 0xBC, + 0x3C, 0xA4, 0xCC, 0xD8, 0xFB, 0x02, 0xE2, 0x11 + }, + { + 0x8D, 0x15, 0xEF, 0x32, 0xC0, 0x15, 0xD8, 0xFE, + 0x70, 0x18, 0x80, 0x13, 0x3B, 0x4F, 0x8F, 0x7D, + 0x3C, 0x3B, 0xB6, 0x0D, 0x14, 0xEA, 0x41, 0x74, + 0xF5, 0xE3, 0x5F, 0x91, 0xDF, 0x00, 0x98, 0x00, + 0x00, 0xAB, 0xBF, 0x4B, 0x48, 0x3E, 0x98, 0x3F, + 0x08, 0x4F, 0x7F, 0x90, 0x63, 0xCD, 0xBC, 0x65, + 0x54, 0x98, 0x09, 0xCD, 0x76, 0x4D, 0xE8, 0x1B, + 0x7E, 0x33, 0x4A, 0x14, 0xA5, 0x58, 0x8B, 0xDE + }, + { + 0x72, 0x66, 0x21, 0xF0, 0x2B, 0xA2, 0x6E, 0xD7, + 0xA5, 0x07, 0x27, 0x4C, 0x31, 0x53, 0xC9, 0xBF, + 0x0F, 0x49, 0xDA, 0x9D, 0xC9, 0x50, 0x7E, 0x0A, + 0xB4, 0xE7, 0x67, 0xEA, 0xB4, 0x62, 0x0B, 0xF8, + 0xF6, 0xFE, 0x85, 0x38, 0x2E, 0x8B, 0x74, 0xB1, + 0xFD, 0xAA, 0xB1, 0x1C, 0xB6, 0x63, 0xAD, 0x6C, + 0xC8, 0x9F, 0xD6, 0x54, 0x3A, 0xDA, 0xDB, 0x28, + 0x9F, 0x65, 0x32, 0x66, 0xE7, 0x73, 0xEE, 0x02 + }, + { + 0x02, 0x08, 0xD8, 0x07, 0x9D, 0x4B, 0xFB, 0x2B, + 0xE6, 0x0B, 0xDB, 0x6B, 0x64, 0xED, 0xC6, 0xF8, + 0x36, 0x7B, 0x10, 0x61, 0x4A, 0x1A, 0x2B, 0xFE, + 0x6D, 0x6E, 0x68, 0x8F, 0x74, 0x6C, 0x7A, 0x34, + 0xBF, 0x84, 0x3D, 0xEA, 0x91, 0xF4, 0x41, 0x62, + 0x7F, 0x67, 0xB1, 0x05, 0x9E, 0x4C, 0x9D, 0x4E, + 0xBA, 0x09, 0xC0, 0x7A, 0x0A, 0x0A, 0x14, 0x11, + 0x5F, 0x3E, 0x5A, 0xFB, 0x5D, 0xAF, 0x05, 0xB9 + }, + { + 0x8F, 0x8E, 0xDA, 0x5E, 0x2D, 0x3B, 0x0A, 0xA8, + 0xA1, 0x4A, 0xA0, 0xA9, 0xC3, 0x9D, 0x9F, 0xF8, + 0xDD, 0xA5, 0x79, 0x0D, 0x9F, 0x61, 0xFB, 0x14, + 0x90, 0x0C, 0xE4, 0x74, 0x50, 0xA3, 0xCC, 0xA5, + 0x19, 0x3A, 0x25, 0x59, 0x58, 0xC3, 0x4D, 0x5C, + 0xFF, 0x2E, 0x96, 0xC1, 0x3E, 0xD0, 0x07, 0xC9, + 0x5C, 0xB5, 0x22, 0xC4, 0x29, 0x3D, 0xCE, 0x2B, + 0x9D, 0x22, 0xF3, 0x49, 0x3B, 0x30, 0x73, 0x69 + }, + { + 0x67, 0x6B, 0x6C, 0xC7, 0x45, 0x08, 0x8B, 0xF5, + 0x89, 0x93, 0x8F, 0xB0, 0x97, 0x93, 0x39, 0xE3, + 0x39, 0x9A, 0x91, 0x40, 0x54, 0x67, 0x8F, 0x58, + 0x44, 0x06, 0x53, 0x46, 0x61, 0xB9, 0x7E, 0x11, + 0x64, 0x10, 0x96, 0x33, 0x5E, 0xFC, 0x67, 0x6E, + 0x49, 0x3C, 0x8D, 0xAE, 0xDF, 0x03, 0x09, 0x52, + 0xEA, 0xCE, 0xDC, 0x57, 0x78, 0xD7, 0xA6, 0xA4, + 0x6E, 0xFB, 0x07, 0x7C, 0x29, 0xF1, 0xEE, 0xC9 + }, + { + 0x36, 0xCA, 0x11, 0x8D, 0x78, 0x7D, 0xA3, 0x5D, + 0x41, 0x4F, 0x8A, 0x53, 0x71, 0xBE, 0x3E, 0xD6, + 0x09, 0xAD, 0xCC, 0x74, 0x6B, 0x09, 0x39, 0x3D, + 0xE4, 0xF2, 0x17, 0xF9, 0x30, 0x9D, 0xDF, 0x46, + 0x02, 0x24, 0x89, 0x8C, 0x5E, 0x2B, 0xBE, 0xDF, + 0x7B, 0xF6, 0xEE, 0x36, 0xCA, 0x4A, 0xD6, 0x1C, + 0x91, 0x5F, 0x99, 0x07, 0xFD, 0x33, 0x91, 0x96, + 0x3B, 0x36, 0x1F, 0x93, 0x89, 0xCC, 0x70, 0x66 + }, + { + 0xE4, 0x10, 0x1D, 0xBE, 0xD1, 0xA9, 0xFD, 0xC3, + 0x6F, 0xF0, 0xCF, 0xBE, 0xC6, 0x52, 0xC6, 0x68, + 0x5B, 0x3D, 0x8F, 0x1C, 0x8B, 0x3B, 0x72, 0xB5, + 0x10, 0x38, 0xCD, 0xE6, 0x05, 0x2A, 0x0A, 0xEA, + 0x23, 0xA4, 0x05, 0xA5, 0xBA, 0xA8, 0x31, 0x1E, + 0x88, 0x7E, 0x19, 0xDA, 0xE3, 0x76, 0xA5, 0x37, + 0x1D, 0xD0, 0xDC, 0x70, 0x91, 0x17, 0xD7, 0x75, + 0x66, 0x51, 0x0B, 0x7C, 0x09, 0x54, 0x81, 0x1C + }, + { + 0xCB, 0xEC, 0x67, 0x54, 0xB4, 0xB1, 0xDC, 0xF8, + 0xBC, 0xAD, 0xC9, 0x7D, 0x97, 0xD2, 0xDB, 0xD9, + 0xEC, 0x3F, 0x0E, 0x3B, 0x0E, 0x31, 0xE2, 0xFE, + 0xC3, 0x1F, 0x0F, 0x46, 0x23, 0x19, 0x5A, 0x94, + 0xF0, 0x05, 0xCF, 0xC3, 0xFA, 0x9F, 0x64, 0x20, + 0x77, 0x29, 0x6D, 0x2F, 0x9A, 0x83, 0xD1, 0xF6, + 0x3E, 0x6F, 0x2E, 0x65, 0x4E, 0xEE, 0x9E, 0xB5, + 0xE9, 0x58, 0xB0, 0xA5, 0x0C, 0x8D, 0x4E, 0x1A + }, + { + 0x48, 0xD1, 0x26, 0x13, 0xE8, 0x08, 0xD2, 0xCE, + 0xBF, 0x92, 0xFF, 0x3B, 0xD0, 0x37, 0xC9, 0x0C, + 0xC3, 0xB2, 0x4A, 0x76, 0x1B, 0x6F, 0xC5, 0x48, + 0xEA, 0xC2, 0x7C, 0xDF, 0xEF, 0xF0, 0xD1, 0xD4, + 0x02, 0x77, 0x75, 0x05, 0x92, 0xC4, 0x3C, 0x7D, + 0xE2, 0x32, 0x67, 0x8F, 0xBC, 0xC4, 0x14, 0x02, + 0xA5, 0x24, 0x80, 0x21, 0xE6, 0x65, 0xF0, 0xFB, + 0x13, 0x3C, 0x7A, 0xF2, 0xCB, 0x8C, 0x29, 0x5E + }, + { + 0x9C, 0x63, 0x8D, 0x58, 0xDE, 0xF5, 0x7A, 0x67, + 0x20, 0xE4, 0x9C, 0x71, 0x6C, 0x3E, 0xC7, 0x02, + 0x76, 0x83, 0x35, 0x9C, 0x2E, 0x3A, 0x2E, 0x22, + 0x8C, 0x86, 0xC6, 0x20, 0x71, 0x83, 0xE6, 0xD5, + 0x35, 0x3A, 0x3C, 0x98, 0x17, 0x82, 0x7A, 0x66, + 0x9F, 0xC3, 0x5F, 0x70, 0x66, 0x7D, 0xE2, 0xEC, + 0x3C, 0x32, 0x47, 0xCA, 0x11, 0xBF, 0x7E, 0x62, + 0xF4, 0x56, 0xE5, 0x3E, 0xF8, 0x08, 0x7C, 0xF9 + }, + { + 0x0D, 0x30, 0x21, 0xD3, 0x69, 0x50, 0x03, 0x4A, + 0x3A, 0x6F, 0xFF, 0xD6, 0x99, 0x86, 0x46, 0x4C, + 0x4A, 0x97, 0x40, 0xFD, 0x08, 0xB4, 0xEB, 0x33, + 0xAC, 0x8E, 0xEE, 0xCF, 0x0A, 0x4F, 0x02, 0x0E, + 0x16, 0xD9, 0x58, 0x2E, 0xFD, 0xD8, 0xEF, 0x05, + 0xA7, 0xE8, 0x42, 0xEF, 0x1B, 0xF0, 0xE6, 0x98, + 0xAD, 0x8B, 0xB2, 0xB1, 0xD3, 0x6A, 0x62, 0xA1, + 0x63, 0xC4, 0x2F, 0x92, 0x6B, 0x2F, 0x2A, 0x77 + }, + { + 0xFF, 0x62, 0x78, 0x10, 0x82, 0xDB, 0x90, 0xE5, + 0xE9, 0x12, 0x30, 0xCD, 0x62, 0x6C, 0x6B, 0x76, + 0xD6, 0x73, 0x57, 0x72, 0x92, 0xC8, 0x25, 0x6D, + 0xA3, 0x30, 0xA1, 0xCD, 0x00, 0x0D, 0xA7, 0x8E, + 0x56, 0x8B, 0xD8, 0xAF, 0x2E, 0x56, 0x8A, 0xFA, + 0x08, 0xC2, 0x0C, 0xFB, 0xB4, 0x69, 0x8C, 0x9D, + 0x81, 0xAB, 0x99, 0x0F, 0x49, 0xC2, 0xF3, 0x43, + 0xC6, 0x64, 0xE4, 0x1D, 0x54, 0x47, 0xA0, 0x0E + }, + { + 0x6C, 0xDD, 0x8F, 0x8C, 0xF3, 0x7B, 0x7D, 0x4D, + 0x18, 0xE4, 0x53, 0x5B, 0x92, 0xB3, 0x04, 0xA6, + 0xAC, 0x46, 0x16, 0xAB, 0x63, 0x21, 0x72, 0x3F, + 0x86, 0x2B, 0xEC, 0xB4, 0xE7, 0xCE, 0xBE, 0xE8, + 0x1D, 0x1A, 0x9C, 0xF6, 0xB6, 0x6B, 0x30, 0x01, + 0xCD, 0x1C, 0xF8, 0xF7, 0x5C, 0x1E, 0xF1, 0x77, + 0xF9, 0xE9, 0xB2, 0x0B, 0x66, 0x68, 0xBC, 0xA4, + 0x63, 0xA7, 0x8F, 0x1E, 0xFF, 0x95, 0xBC, 0xEC + }, + { + 0x24, 0x86, 0x9A, 0x80, 0x7D, 0x0C, 0xC9, 0xC9, + 0x78, 0x8A, 0x48, 0x7B, 0x59, 0xD4, 0x26, 0xAF, + 0x22, 0xD6, 0xD1, 0xA8, 0xD5, 0x6E, 0x5F, 0x10, + 0x8F, 0x66, 0xDD, 0x0A, 0xE8, 0xA1, 0x57, 0x29, + 0x50, 0x31, 0xB0, 0x6E, 0x83, 0x05, 0xA1, 0x12, + 0x53, 0x68, 0xFC, 0xE8, 0x8D, 0xC6, 0xEC, 0x40, + 0xEA, 0x43, 0xF2, 0x51, 0x7C, 0x01, 0xEB, 0x5E, + 0x15, 0x07, 0xE6, 0x6A, 0x67, 0x42, 0xD0, 0xDE + }, + { + 0xF1, 0x73, 0x6F, 0x9A, 0xD5, 0x58, 0x52, 0xBE, + 0xF0, 0x5B, 0x45, 0xF8, 0x09, 0xE7, 0xDF, 0xED, + 0x89, 0xEE, 0x87, 0x23, 0x0C, 0xD7, 0xD4, 0x3E, + 0x5A, 0xA7, 0x16, 0xE1, 0x8A, 0xAC, 0xE3, 0xCE, + 0xE0, 0xDD, 0xFD, 0x89, 0x09, 0xBF, 0x37, 0x0E, + 0x21, 0x29, 0x5E, 0xC4, 0x59, 0xD7, 0x80, 0x92, + 0xCA, 0xC7, 0xE3, 0xD9, 0x8D, 0xDD, 0x2F, 0xAA, + 0x0C, 0xAE, 0xD3, 0x0D, 0x72, 0x2F, 0x88, 0xD5 + }, + { + 0x39, 0xCD, 0xCE, 0x27, 0xA8, 0x92, 0x99, 0xB6, + 0xD6, 0x64, 0x2D, 0x11, 0xB4, 0x7A, 0x12, 0x36, + 0x1E, 0xD7, 0x0F, 0x08, 0xB8, 0xFD, 0x71, 0xE2, + 0xB7, 0x6D, 0x91, 0x6A, 0xEB, 0x3A, 0xA9, 0x31, + 0xA2, 0x13, 0x16, 0x3D, 0x5F, 0x9D, 0x62, 0xB1, + 0x15, 0xF8, 0xA6, 0xE9, 0x99, 0x7E, 0x30, 0x3E, + 0xA9, 0x7C, 0x49, 0xE1, 0x10, 0x61, 0x20, 0x56, + 0x43, 0x34, 0xE8, 0x74, 0xB5, 0xD9, 0x59, 0x66 + }, + { + 0x3D, 0x0E, 0x32, 0x0C, 0xD6, 0xA1, 0xD5, 0x78, + 0x36, 0xFF, 0x49, 0xAB, 0xDE, 0x68, 0xFF, 0xC4, + 0x86, 0xCD, 0x42, 0x25, 0xA6, 0x66, 0x26, 0xCC, + 0xD8, 0xFC, 0x3D, 0x0F, 0x8B, 0x41, 0xCC, 0xCC, + 0x66, 0xF3, 0xBE, 0x78, 0x4A, 0x84, 0x6D, 0x2B, + 0x61, 0x0E, 0xBD, 0x3B, 0xE6, 0x8D, 0x90, 0x6E, + 0xBC, 0xF8, 0x64, 0x10, 0x27, 0xCF, 0x5D, 0x13, + 0x01, 0x8B, 0xAD, 0xAD, 0x13, 0x28, 0x45, 0x16 + }, + { + 0x56, 0x79, 0x75, 0x1A, 0x3D, 0xF5, 0x77, 0xA0, + 0x81, 0x80, 0x34, 0x44, 0x3C, 0x07, 0x72, 0xA7, + 0xA5, 0xC3, 0xD4, 0xF8, 0x60, 0x44, 0xDB, 0x79, + 0x4D, 0xD3, 0x36, 0x8D, 0xF1, 0xCB, 0x68, 0x91, + 0x42, 0xAF, 0x38, 0xA9, 0x16, 0x70, 0xDC, 0x07, + 0xAB, 0x44, 0xE1, 0xDB, 0x2C, 0xCC, 0x43, 0x23, + 0xA7, 0x62, 0xA7, 0x08, 0xC9, 0x33, 0xE5, 0x91, + 0x74, 0x12, 0x47, 0x0A, 0x25, 0xD9, 0x0D, 0xE3 + }, + { + 0x04, 0x5E, 0x6B, 0x0E, 0x1B, 0x91, 0x75, 0x7B, + 0xF5, 0x4F, 0x68, 0x49, 0x13, 0xF7, 0x18, 0x4B, + 0x6E, 0xDB, 0xEE, 0xC9, 0xFE, 0xB0, 0x40, 0x78, + 0xAF, 0x99, 0xC5, 0x02, 0xB0, 0x68, 0x77, 0xEF, + 0x19, 0xFA, 0x5F, 0x19, 0x9C, 0x11, 0xFB, 0xD8, + 0xCC, 0x15, 0xC3, 0xB6, 0xB3, 0x05, 0x23, 0xCB, + 0x9C, 0xAF, 0x61, 0x0F, 0xE9, 0x08, 0x41, 0x97, + 0xF9, 0x5F, 0x83, 0x79, 0x3A, 0x1B, 0xDA, 0x5C + }, + { + 0x0C, 0x35, 0x5B, 0xE2, 0xA3, 0x0D, 0xBA, 0x11, + 0x63, 0x96, 0xA6, 0xF8, 0xE2, 0xF7, 0xE8, 0xB0, + 0xCA, 0xCE, 0x8A, 0xA4, 0x80, 0x3A, 0xB9, 0xB7, + 0x95, 0x7D, 0xD5, 0x0B, 0x05, 0x6E, 0x41, 0xF0, + 0xA5, 0xEA, 0x8C, 0x43, 0x06, 0x26, 0xAD, 0xE3, + 0x3C, 0x04, 0x5A, 0xD6, 0x42, 0x60, 0x4C, 0xCF, + 0x74, 0x4D, 0xC2, 0x31, 0xC9, 0x8D, 0xB0, 0x12, + 0xE1, 0xD4, 0x99, 0x15, 0x83, 0xD0, 0x4F, 0x81 + }, + { + 0xAC, 0xD6, 0xA9, 0x30, 0x26, 0x4C, 0x11, 0xA9, + 0x1F, 0x11, 0x95, 0xA9, 0x9C, 0x67, 0x43, 0x79, + 0x23, 0xE5, 0x67, 0x73, 0x81, 0xB2, 0x74, 0x09, + 0x8E, 0xF2, 0xBA, 0x6C, 0x25, 0xFF, 0x7C, 0x4D, + 0x91, 0x9D, 0xFC, 0xC8, 0x06, 0x99, 0x21, 0xA4, + 0xAF, 0xF0, 0xBB, 0xE0, 0xE7, 0xEB, 0xE2, 0x58, + 0x6D, 0x3D, 0x95, 0xF1, 0x8E, 0x4D, 0x09, 0x54, + 0xE6, 0xC4, 0x88, 0x1F, 0x56, 0x02, 0xF1, 0x32 + }, + { + 0xB3, 0xA1, 0xDD, 0x1D, 0x46, 0x3F, 0x94, 0x35, + 0x07, 0x57, 0xF9, 0xA8, 0xB6, 0x05, 0x2B, 0x64, + 0xEE, 0x6F, 0xE0, 0xC1, 0xD9, 0xBB, 0x1A, 0x03, + 0xBC, 0x1C, 0x37, 0x97, 0xBA, 0xF2, 0x2E, 0x68, + 0x52, 0xFE, 0xEC, 0x4A, 0xD9, 0x28, 0x9A, 0xAF, + 0xE0, 0xC9, 0x6C, 0x48, 0x32, 0x57, 0x85, 0x0A, + 0x95, 0xCE, 0x6E, 0xD2, 0x3B, 0xAE, 0x30, 0xF0, + 0xCB, 0x09, 0x14, 0x75, 0x67, 0x16, 0x61, 0xE8 + }, + { + 0x1A, 0x18, 0xDC, 0xBF, 0x2C, 0x75, 0xF3, 0xA5, + 0xEA, 0x8E, 0x20, 0x0B, 0x11, 0xF6, 0x3F, 0x6F, + 0x61, 0x5D, 0x8B, 0x50, 0x1F, 0x9C, 0x24, 0x1F, + 0x77, 0x84, 0xDF, 0x8C, 0xB5, 0x3F, 0x46, 0x3B, + 0xD6, 0xDA, 0x90, 0x14, 0x49, 0x26, 0xE3, 0x65, + 0x0F, 0x3A, 0xBF, 0xCC, 0x4A, 0x29, 0x92, 0xEC, + 0x04, 0xBE, 0xF5, 0xB0, 0xA2, 0x36, 0x6F, 0x16, + 0xF7, 0xAA, 0x3D, 0x8D, 0xC8, 0x51, 0xEB, 0x3A + }, + { + 0xDC, 0x0D, 0x73, 0x19, 0xF7, 0x34, 0xEE, 0xF8, + 0x7E, 0x70, 0x5E, 0x0F, 0x02, 0x74, 0xCE, 0x67, + 0x3B, 0xF7, 0x6D, 0xD7, 0x5E, 0xBD, 0xA6, 0xE8, + 0xA8, 0x5B, 0xEB, 0xCD, 0x0A, 0xFA, 0x62, 0x70, + 0xCC, 0x21, 0xCA, 0xD8, 0x6A, 0x65, 0xED, 0x8E, + 0xDB, 0x22, 0xB0, 0x04, 0x56, 0x9B, 0x6C, 0xEF, + 0x17, 0x59, 0xAA, 0x16, 0x21, 0x52, 0x4E, 0x50, + 0x8D, 0xDB, 0x0D, 0xE6, 0x07, 0x43, 0xD3, 0xA0 + }, + { + 0x6A, 0x2C, 0x1F, 0xE1, 0x4A, 0x28, 0x68, 0xD7, + 0x42, 0xBB, 0xA2, 0x35, 0x3D, 0x8B, 0x9A, 0xBE, + 0xF7, 0xBE, 0x2A, 0xEF, 0x5B, 0x92, 0x95, 0xA8, + 0xA5, 0xD1, 0xC8, 0x7F, 0xD8, 0x3F, 0xED, 0x86, + 0x43, 0xE6, 0x93, 0xCB, 0x1D, 0x38, 0xE8, 0x4E, + 0x97, 0x04, 0x5A, 0x83, 0x9E, 0xD3, 0x7F, 0x45, + 0x35, 0xE6, 0x0B, 0x8A, 0xC0, 0xDB, 0x4A, 0xF8, + 0x4F, 0x5F, 0x3B, 0x5B, 0x70, 0xEF, 0x75, 0x99 + }, + { + 0x56, 0x50, 0x2C, 0xED, 0x55, 0x63, 0x0F, 0xB8, + 0x26, 0x5D, 0x14, 0x58, 0x7D, 0x8D, 0x3C, 0x2C, + 0xBE, 0x65, 0x50, 0x2F, 0x81, 0x73, 0xE7, 0xBE, + 0x94, 0xFB, 0xB0, 0x98, 0xE8, 0x96, 0xCB, 0x62, + 0x9B, 0xC7, 0x2A, 0xFF, 0x47, 0x96, 0xE8, 0xB4, + 0xBE, 0x98, 0xBC, 0x66, 0x57, 0x05, 0x4D, 0xEE, + 0x77, 0xDE, 0xD5, 0x84, 0x1D, 0xAB, 0x59, 0x56, + 0x1B, 0x38, 0x1D, 0x00, 0xFB, 0x05, 0x35, 0x02 + }, + { + 0xC1, 0xAC, 0x76, 0x20, 0xA7, 0xB4, 0x70, 0x6B, + 0x8F, 0x1E, 0x35, 0x94, 0x9D, 0x91, 0xF6, 0xEC, + 0x8C, 0x9A, 0xE0, 0x8F, 0xFE, 0x3E, 0x2B, 0x30, + 0xFE, 0x8C, 0x7A, 0x06, 0xED, 0x57, 0x41, 0x12, + 0x1C, 0x87, 0x36, 0x64, 0xB0, 0xF4, 0xF6, 0x3E, + 0xEE, 0xCC, 0x0B, 0x47, 0x57, 0xCC, 0xDD, 0x79, + 0x17, 0xD7, 0x58, 0x4C, 0x7B, 0x16, 0x22, 0xF8, + 0xDB, 0x87, 0x9D, 0x4F, 0xF5, 0x10, 0xB3, 0x9A + }, + { + 0x85, 0x6E, 0xF7, 0xB6, 0xB5, 0x0E, 0x85, 0x3B, + 0x8C, 0x19, 0x2F, 0x38, 0x48, 0xA5, 0xE3, 0xAD, + 0xED, 0x3D, 0x89, 0x10, 0x08, 0xF0, 0x8C, 0x9A, + 0x28, 0x1E, 0x83, 0x16, 0x38, 0xE1, 0xA5, 0x2C, + 0xCC, 0xEC, 0x1A, 0x65, 0x2F, 0x48, 0x72, 0x6A, + 0x52, 0x36, 0xC3, 0xE7, 0x99, 0x13, 0xC3, 0x12, + 0xAB, 0xBB, 0xC7, 0x71, 0xE9, 0xCA, 0x64, 0xA1, + 0x01, 0x30, 0x2D, 0xB2, 0xBB, 0x9F, 0xE0, 0x61 + }, + { + 0xD9, 0xC3, 0xCB, 0x74, 0x65, 0x87, 0xBF, 0xDC, + 0x30, 0x37, 0x8B, 0x88, 0x75, 0xA1, 0x8A, 0xFA, + 0x3A, 0x39, 0x86, 0x43, 0xFE, 0x2C, 0x73, 0xD7, + 0x10, 0xA4, 0x21, 0x1F, 0xE4, 0x9F, 0x0D, 0x53, + 0x1B, 0x85, 0x16, 0x99, 0x25, 0xDD, 0x0A, 0x46, + 0xE2, 0x9F, 0x55, 0x0E, 0xEC, 0x62, 0x20, 0x2C, + 0x04, 0xB3, 0xF5, 0xA5, 0xB3, 0x8E, 0xC1, 0x59, + 0x07, 0xC9, 0x8C, 0xD7, 0x62, 0xDF, 0x19, 0x09 + }, + { + 0x7B, 0x2E, 0x0C, 0x9C, 0x71, 0x2A, 0x2D, 0xDD, + 0xDD, 0x8C, 0x74, 0x0E, 0x9E, 0x80, 0x93, 0x62, + 0xB5, 0xD0, 0x63, 0x25, 0xF7, 0x89, 0x00, 0x34, + 0x48, 0x1E, 0x6B, 0xBE, 0xF6, 0x7D, 0x82, 0x42, + 0x3A, 0x87, 0x40, 0xC5, 0xEA, 0xA4, 0x7B, 0xF6, + 0xA0, 0xB2, 0xCD, 0x0B, 0x4C, 0xBD, 0x53, 0x92, + 0x6D, 0x66, 0x38, 0x40, 0x70, 0xE7, 0xEF, 0xFF, + 0xBA, 0x4D, 0xEB, 0x7E, 0x1F, 0x89, 0x97, 0x00 + }, + { + 0xED, 0xE5, 0x28, 0x68, 0xDB, 0x71, 0x8D, 0xA0, + 0x5A, 0x7C, 0x1F, 0x54, 0xC6, 0x2A, 0xD4, 0x23, + 0x0C, 0x5D, 0xE2, 0xC8, 0xCE, 0x82, 0x18, 0x21, + 0xF3, 0x65, 0x4B, 0x9D, 0x21, 0x34, 0x1A, 0xE2, + 0x4B, 0x79, 0xE3, 0x9B, 0xF1, 0x45, 0xBC, 0x9B, + 0x27, 0x06, 0x17, 0x2B, 0x20, 0x6C, 0x62, 0x80, + 0x52, 0x1E, 0xD2, 0xFD, 0x69, 0x7E, 0x9F, 0x25, + 0x1F, 0x06, 0x0A, 0x09, 0xE7, 0x4A, 0x36, 0xD6 + }, + { + 0xED, 0xDD, 0xCC, 0x82, 0xDD, 0x66, 0xEC, 0x66, + 0xC3, 0x6A, 0xB8, 0x82, 0x3B, 0x0F, 0xC6, 0xB8, + 0xED, 0x9B, 0x41, 0x19, 0xCC, 0x9D, 0xAF, 0x07, + 0x73, 0xF3, 0x28, 0xF1, 0xFE, 0x13, 0x0D, 0x10, + 0x44, 0xF2, 0x41, 0x2A, 0x58, 0x1A, 0xBC, 0x1D, + 0xE1, 0x2F, 0x00, 0x79, 0x3D, 0x26, 0xC7, 0xA2, + 0xBD, 0x7B, 0x93, 0xE6, 0xEA, 0x87, 0xAC, 0xD9, + 0xE8, 0x9C, 0xF0, 0xF8, 0x3C, 0x15, 0x72, 0x4D + }, + { + 0x89, 0x4C, 0xD1, 0xCB, 0x6C, 0x5F, 0x3C, 0x0B, + 0xF3, 0xD6, 0xC5, 0xD0, 0x66, 0x26, 0x6D, 0x3B, + 0x85, 0xF9, 0x1E, 0x0D, 0x81, 0xE5, 0xCF, 0x17, + 0x90, 0x5B, 0xA0, 0x9F, 0xB6, 0x56, 0x06, 0xCF, + 0xEE, 0x71, 0x78, 0x18, 0xB7, 0xF6, 0x3E, 0xCC, + 0x4E, 0xB9, 0x52, 0x93, 0x91, 0xC9, 0x88, 0xC0, + 0x22, 0x7F, 0xE0, 0x06, 0xA6, 0xBD, 0x60, 0x19, + 0x13, 0x5F, 0x2D, 0x0F, 0xAA, 0x9A, 0xAF, 0x11 + }, + { + 0x21, 0xDA, 0xE8, 0xB1, 0x3B, 0x02, 0xAC, 0xA7, + 0x72, 0x6E, 0x90, 0x26, 0x1E, 0x6D, 0x2C, 0x2E, + 0x1B, 0xEA, 0x33, 0xC1, 0x26, 0xBD, 0x30, 0x94, + 0xF0, 0xE6, 0x9A, 0x1B, 0xE4, 0x1F, 0x6B, 0xB0, + 0xF3, 0xA6, 0x07, 0x94, 0xFF, 0x4E, 0x85, 0x91, + 0xC3, 0xFB, 0xEA, 0xAA, 0x27, 0xFC, 0x7C, 0xEB, + 0x58, 0x4E, 0x77, 0x65, 0x32, 0xCD, 0xBD, 0x6C, + 0xA7, 0xA4, 0xC8, 0xBA, 0x46, 0x12, 0xED, 0x5E + }, + { + 0xE9, 0x5F, 0xA2, 0xD9, 0x8B, 0x94, 0xFA, 0xFF, + 0x3B, 0xA1, 0xB5, 0x9B, 0x2C, 0x0D, 0xF3, 0xE3, + 0xF9, 0x01, 0xF0, 0x91, 0x0E, 0x22, 0x37, 0xCC, + 0x30, 0xCB, 0x7E, 0x83, 0x47, 0xC2, 0x3D, 0xAB, + 0x1D, 0x79, 0xBF, 0x76, 0xB2, 0xFE, 0x1A, 0x96, + 0x80, 0x35, 0x8F, 0xFA, 0x1A, 0xCD, 0x45, 0x2A, + 0x35, 0x94, 0x96, 0x13, 0x40, 0xFA, 0x68, 0x7C, + 0x7F, 0xFE, 0x23, 0xF6, 0x8B, 0x74, 0x13, 0x4A + }, + { + 0x02, 0x03, 0xC1, 0xB2, 0xA7, 0xB8, 0x81, 0x3D, + 0x07, 0x28, 0x94, 0xA1, 0xB0, 0x05, 0x28, 0x0F, + 0xA3, 0x1A, 0xF6, 0xFF, 0x0D, 0xCB, 0x0D, 0x25, + 0x61, 0xF8, 0xE5, 0x68, 0xAB, 0xF5, 0xDB, 0xF3, + 0x02, 0x67, 0x37, 0x05, 0xBB, 0x3F, 0x96, 0xE3, + 0xE1, 0xFB, 0xEA, 0x25, 0x07, 0xF9, 0x33, 0xA7, + 0x1D, 0x85, 0x0F, 0x38, 0x8F, 0xC1, 0x20, 0x4B, + 0x2D, 0xFF, 0x24, 0xB8, 0x7E, 0x75, 0x92, 0x83 + }, + { + 0xDE, 0x22, 0x79, 0x3D, 0x0C, 0x53, 0xFF, 0xA5, + 0x3A, 0xDC, 0x9E, 0x85, 0x77, 0x41, 0xEE, 0x8B, + 0xAF, 0x55, 0x0B, 0x8C, 0x10, 0x0B, 0x03, 0xB8, + 0xFB, 0xAE, 0xE4, 0x91, 0xF8, 0x4A, 0x27, 0x9A, + 0xA4, 0x06, 0xC8, 0x54, 0xAF, 0x43, 0x69, 0x81, + 0xCA, 0x88, 0x11, 0x28, 0x1F, 0x6A, 0xAE, 0x2B, + 0x25, 0x5F, 0x78, 0x04, 0xF6, 0x23, 0x15, 0x5E, + 0xF5, 0x7A, 0x11, 0x23, 0x2E, 0xDB, 0xF5, 0xF3 + }, + { + 0x2B, 0x13, 0x5F, 0x45, 0x26, 0x6A, 0xF9, 0x9C, + 0x78, 0xDF, 0x30, 0x29, 0xE5, 0xD3, 0xCA, 0xFD, + 0x2B, 0xF7, 0xA1, 0xC1, 0x5B, 0x8F, 0x75, 0xAF, + 0xBC, 0x28, 0x8D, 0x1D, 0x1D, 0x5E, 0xF4, 0x60, + 0x7D, 0xFB, 0x62, 0x4C, 0x74, 0xF4, 0x51, 0xF6, + 0x00, 0x9D, 0xD3, 0x48, 0x8C, 0x1A, 0x46, 0x5C, + 0x55, 0xAA, 0x51, 0x75, 0xB7, 0x6B, 0xA3, 0xA9, + 0xA2, 0xD3, 0x6B, 0x94, 0xAE, 0x29, 0x3C, 0x0D + }, + { + 0x8E, 0x24, 0x62, 0x64, 0x97, 0xCD, 0x2E, 0xE3, + 0x77, 0x4C, 0xE2, 0x28, 0x55, 0xB9, 0x47, 0x78, + 0x6F, 0x9D, 0x75, 0xF0, 0xE3, 0x8B, 0x58, 0xAC, + 0xCE, 0xF1, 0x27, 0x2B, 0x09, 0x52, 0x73, 0x9F, + 0x72, 0x10, 0xBF, 0x0C, 0x17, 0xB9, 0xC7, 0x08, + 0x40, 0x69, 0x51, 0x85, 0x86, 0xE8, 0x14, 0x11, + 0x1A, 0x2C, 0x43, 0x95, 0xCE, 0xE6, 0x14, 0xFB, + 0x4F, 0x1A, 0x5F, 0xA8, 0x39, 0x01, 0x8F, 0x4C + }, + { + 0xF3, 0x63, 0xE1, 0x5B, 0x5A, 0xB7, 0xD7, 0x8E, + 0xC1, 0xF4, 0x00, 0x07, 0xE6, 0x5B, 0xD3, 0xFF, + 0xAA, 0x20, 0xF5, 0x0E, 0x8F, 0x0C, 0x2D, 0x7E, + 0x32, 0x80, 0xCD, 0x34, 0x7E, 0x5B, 0xC8, 0x50, + 0x28, 0x7E, 0x64, 0xFA, 0x3B, 0x7D, 0x73, 0x16, + 0x53, 0xCC, 0xA2, 0x2F, 0x0B, 0x08, 0x08, 0x99, + 0x82, 0x76, 0x09, 0x4A, 0x4B, 0x06, 0xC6, 0x86, + 0xDE, 0x88, 0x2D, 0x49, 0x86, 0xB1, 0x54, 0x09 + }, + { + 0xAF, 0x79, 0x98, 0x20, 0xA3, 0x17, 0x68, 0xF7, + 0x1D, 0xB0, 0x0A, 0x3B, 0xEC, 0x33, 0x6D, 0xC1, + 0x6D, 0xD8, 0x52, 0xD4, 0x15, 0xEF, 0x65, 0xDE, + 0xA8, 0x71, 0x16, 0x16, 0x79, 0xA5, 0x83, 0xF2, + 0x0D, 0x7A, 0x11, 0x75, 0xA2, 0x3E, 0x40, 0x6D, + 0xCB, 0xA1, 0x15, 0x5F, 0xD1, 0xA7, 0x7F, 0x45, + 0x9F, 0x82, 0xD7, 0x35, 0x36, 0xAF, 0x4C, 0xCA, + 0x08, 0xDF, 0x7B, 0x1A, 0x37, 0x2A, 0x95, 0xEB + }, + { + 0x4D, 0x31, 0xA1, 0x7F, 0x4E, 0xB7, 0x0F, 0x46, + 0xD8, 0xE4, 0xA4, 0xB7, 0x69, 0x7F, 0x83, 0x44, + 0x7D, 0xF8, 0xB1, 0xAE, 0x36, 0xF9, 0xEB, 0x84, + 0x67, 0x5B, 0xA8, 0xFC, 0x63, 0xB2, 0x70, 0x7F, + 0x2B, 0xAB, 0xCF, 0xD7, 0x11, 0x8D, 0x11, 0x03, + 0x0B, 0xD9, 0xDA, 0x94, 0xE7, 0xDF, 0x2B, 0x1F, + 0x0F, 0x45, 0xA7, 0x90, 0xA8, 0x62, 0x60, 0xEE, + 0xFA, 0x8D, 0x82, 0x8C, 0x5C, 0x4B, 0xAF, 0x82 + }, + { + 0xE4, 0xEF, 0xA2, 0xF0, 0x08, 0x55, 0xB1, 0x7E, + 0x2E, 0xD1, 0x2F, 0x11, 0x37, 0x0D, 0x09, 0x66, + 0x08, 0x24, 0x24, 0x7C, 0x02, 0xF3, 0x5C, 0xAA, + 0xBB, 0x7D, 0xD8, 0x83, 0x21, 0x08, 0x2C, 0x17, + 0x72, 0x57, 0xC8, 0xE6, 0x99, 0x58, 0x38, 0xD8, + 0xA9, 0xD7, 0xD8, 0x6E, 0xCB, 0xBB, 0x6A, 0xA2, + 0x9F, 0x6B, 0x85, 0x5A, 0x63, 0x78, 0x92, 0xBF, + 0xCA, 0x5D, 0xEE, 0x59, 0x80, 0x95, 0x58, 0x74 + }, + { + 0x08, 0x28, 0x49, 0x00, 0x6E, 0xEF, 0x8A, 0xAA, + 0x1D, 0x23, 0x3D, 0xF1, 0xEB, 0x6B, 0x42, 0x56, + 0x7C, 0xFF, 0x38, 0x6F, 0xC2, 0x1A, 0xF4, 0xDC, + 0xE7, 0x80, 0xC0, 0x7C, 0x83, 0x4A, 0xFD, 0x98, + 0xB6, 0x72, 0xE4, 0xA8, 0xE4, 0x69, 0x49, 0x8A, + 0x23, 0x62, 0x06, 0x33, 0x91, 0x52, 0x46, 0x91, + 0xA3, 0x54, 0x1B, 0x52, 0xCF, 0x09, 0xB0, 0x22, + 0x3E, 0x79, 0xA4, 0xE6, 0x1F, 0x3C, 0x44, 0x8F + }, + { + 0x54, 0xCB, 0x88, 0xB9, 0x98, 0x84, 0x61, 0x0C, + 0xAC, 0xC1, 0xF7, 0x1F, 0x47, 0x4C, 0x05, 0xF5, + 0x9A, 0xDF, 0x63, 0x84, 0x25, 0x97, 0x55, 0x13, + 0x0B, 0x22, 0xEC, 0x7D, 0xB0, 0x26, 0x7B, 0x27, + 0x82, 0xAD, 0x89, 0x84, 0x31, 0xB9, 0x87, 0x38, + 0x91, 0x89, 0x48, 0x1D, 0x36, 0x8E, 0xEC, 0x03, + 0x3D, 0xAD, 0xC4, 0x55, 0x1B, 0xBB, 0x98, 0xBD, + 0xE4, 0x36, 0x68, 0xF4, 0xAD, 0xF6, 0xC0, 0xAE + }, + { + 0x1A, 0xBE, 0xD5, 0xE7, 0x1A, 0x89, 0x28, 0xE2, + 0x87, 0x9E, 0x20, 0x47, 0x03, 0xC1, 0xC7, 0x2E, + 0xA1, 0xEA, 0xE2, 0x22, 0xC5, 0x4E, 0x48, 0x51, + 0x70, 0x4E, 0x16, 0xF5, 0xB4, 0x5A, 0x32, 0xC6, + 0x0C, 0xCE, 0x38, 0x40, 0x0B, 0x40, 0x3E, 0xFA, + 0x89, 0xF3, 0x9D, 0xE8, 0x64, 0x4A, 0x7D, 0x59, + 0xEC, 0xAB, 0x34, 0xC4, 0xD7, 0xD0, 0x0D, 0x61, + 0x19, 0x9E, 0x0C, 0x94, 0x43, 0xD1, 0x81, 0xFE + }, + { + 0xFC, 0xEE, 0x03, 0x66, 0x14, 0x5A, 0xFC, 0x7F, + 0xB0, 0xD4, 0xC0, 0x89, 0xE5, 0x2E, 0x4F, 0xD6, + 0x76, 0x0E, 0x01, 0x0B, 0xB9, 0xAD, 0xEB, 0x4A, + 0x39, 0x02, 0x43, 0xB4, 0x09, 0xD9, 0x35, 0x92, + 0x22, 0xF3, 0x35, 0x66, 0x25, 0xCF, 0xE3, 0x6A, + 0x30, 0xD2, 0x80, 0x2C, 0x83, 0xD7, 0x6C, 0x8F, + 0xC9, 0xF3, 0xEC, 0x88, 0x95, 0xA5, 0x41, 0xF5, + 0x59, 0xC9, 0x27, 0x30, 0x2A, 0xFB, 0x20, 0xE9 + }, + { + 0xFD, 0x6D, 0x4C, 0xA0, 0x36, 0x47, 0x5C, 0xDE, + 0xA0, 0xA5, 0x75, 0x97, 0xC0, 0xEF, 0x25, 0x76, + 0xC7, 0xD4, 0x8E, 0x46, 0x18, 0x4B, 0x1F, 0x5F, + 0x3D, 0xC7, 0xDE, 0x2E, 0x8A, 0x8B, 0xD6, 0x7B, + 0x4A, 0xC8, 0xAE, 0x74, 0x72, 0x61, 0x8F, 0xFC, + 0x14, 0x31, 0x12, 0x69, 0x2F, 0xA6, 0xD8, 0xDF, + 0x21, 0x8F, 0xDC, 0x7C, 0x32, 0x32, 0x63, 0x97, + 0x53, 0xFD, 0x0B, 0x04, 0xF4, 0x12, 0x8B, 0x7E + }, + { + 0xDA, 0x47, 0x99, 0x8C, 0x40, 0xD9, 0x17, 0xBC, + 0x8B, 0x7D, 0xBA, 0xB7, 0x53, 0x86, 0x27, 0x63, + 0x2D, 0x31, 0x71, 0x1E, 0xA6, 0xD6, 0xE3, 0xA2, + 0x4B, 0xC8, 0x94, 0xAA, 0x2A, 0xA3, 0x70, 0x63, + 0xD0, 0xA3, 0x08, 0x51, 0x9B, 0xC3, 0x7E, 0x98, + 0x3A, 0x91, 0x25, 0x37, 0xD2, 0x81, 0x2E, 0x87, + 0xF2, 0xBC, 0x8E, 0xEE, 0x2A, 0xB9, 0xF1, 0x57, + 0xA8, 0xD7, 0x20, 0x5D, 0x71, 0x9A, 0x3C, 0x09 + }, + { + 0xA8, 0x75, 0x0E, 0x9C, 0x8A, 0x65, 0xFB, 0x8C, + 0xE5, 0x6E, 0x40, 0x95, 0xF4, 0xE9, 0x6E, 0x66, + 0x8E, 0x84, 0x46, 0x31, 0x60, 0xDF, 0xD5, 0x2D, + 0x9C, 0x86, 0xF7, 0x45, 0xED, 0xED, 0x78, 0x86, + 0xCB, 0xFF, 0x4D, 0xFA, 0x1D, 0xB2, 0xCB, 0x9A, + 0xEB, 0xC4, 0xA3, 0x6D, 0xE8, 0xD6, 0x70, 0x05, + 0x79, 0x2D, 0xA7, 0x9E, 0xB2, 0x1D, 0x30, 0xFE, + 0x41, 0x73, 0x2D, 0xAB, 0xF7, 0xB6, 0x67, 0x36 + }, + { + 0x41, 0xBE, 0xB6, 0xE3, 0xE5, 0x93, 0xDF, 0xB7, + 0xD8, 0x76, 0xD3, 0xFE, 0xF8, 0x65, 0x7C, 0xE7, + 0x6B, 0xFA, 0xA8, 0x0C, 0x6E, 0xA3, 0x76, 0xC2, + 0x32, 0xBD, 0x0A, 0xB5, 0xC4, 0xF3, 0x30, 0x89, + 0x20, 0x60, 0xB3, 0xC6, 0x08, 0xB8, 0x30, 0xF7, + 0xD4, 0x14, 0xCF, 0x50, 0x3B, 0x9B, 0xB3, 0xF6, + 0xEE, 0x44, 0xB3, 0x9B, 0x12, 0xCE, 0x91, 0xD6, + 0xDA, 0x9B, 0x2E, 0xDC, 0xC5, 0x3A, 0x85, 0x2C + }, + { + 0x0B, 0x1E, 0x3C, 0xF7, 0x79, 0x18, 0x23, 0x78, + 0x92, 0x03, 0x7C, 0xB2, 0x47, 0xE1, 0x59, 0x64, + 0x46, 0x11, 0x2E, 0xD4, 0xB3, 0x9D, 0xF1, 0xF2, + 0x10, 0xB3, 0xCF, 0x86, 0x6B, 0xA2, 0xFB, 0x4C, + 0xC4, 0x19, 0x51, 0x4D, 0xFE, 0xAF, 0xAF, 0x31, + 0xC1, 0x3C, 0xB2, 0x54, 0xD1, 0x4D, 0x09, 0x62, + 0xF4, 0x15, 0x58, 0x70, 0x59, 0xC9, 0xF3, 0xA0, + 0x45, 0xE4, 0xF4, 0x03, 0x31, 0x52, 0x15, 0x7A + }, + { + 0x3E, 0x4A, 0x50, 0x8F, 0xEB, 0x70, 0x14, 0xBA, + 0xB6, 0x9B, 0x32, 0x4F, 0x7C, 0x07, 0xCB, 0x29, + 0xDF, 0x1D, 0x0E, 0xB4, 0x69, 0x3A, 0xE9, 0x40, + 0x54, 0xFB, 0x93, 0xC2, 0x70, 0xCC, 0xBC, 0xF1, + 0x75, 0x36, 0xC3, 0xDC, 0x65, 0x5B, 0x6C, 0x5C, + 0x63, 0xAC, 0xAE, 0x18, 0x73, 0x4A, 0xB7, 0x5C, + 0x5C, 0x43, 0x39, 0x43, 0xA4, 0x49, 0xBB, 0x9E, + 0xF9, 0x90, 0xA3, 0x3D, 0x60, 0xC2, 0x58, 0xEC + }, + { + 0x63, 0x6D, 0x68, 0x43, 0x38, 0x03, 0xF3, 0x3C, + 0x41, 0xBA, 0x7F, 0x81, 0x6E, 0x2D, 0xB8, 0x90, + 0x1A, 0xAB, 0xA4, 0xC6, 0x06, 0xE6, 0x86, 0xAC, + 0x4C, 0x0E, 0xB6, 0xFA, 0x47, 0x99, 0x49, 0x9D, + 0xBF, 0x63, 0xD4, 0x9C, 0xF6, 0x4F, 0x6B, 0xAE, + 0x58, 0x1D, 0xC0, 0x29, 0x56, 0x85, 0x4E, 0x33, + 0xD6, 0xB5, 0xA8, 0xB6, 0x4A, 0xE7, 0x05, 0x1A, + 0xFE, 0x2F, 0x32, 0xFE, 0x9D, 0x0E, 0x2C, 0xE1 + }, + { + 0x5A, 0xC8, 0x6F, 0x98, 0x82, 0x7E, 0x33, 0x4D, + 0x64, 0x90, 0x7D, 0x1B, 0x57, 0x5F, 0x0C, 0x85, + 0x61, 0x06, 0x8F, 0xD6, 0x01, 0xCF, 0xDA, 0xB9, + 0x84, 0x03, 0x2C, 0x82, 0xF0, 0x5A, 0x21, 0x6F, + 0xD3, 0x8A, 0x14, 0x6C, 0xDC, 0x3F, 0x2C, 0xDA, + 0x54, 0xD4, 0x8D, 0x1E, 0xED, 0x85, 0x23, 0x77, + 0x4A, 0x68, 0x19, 0xE6, 0x8B, 0xAC, 0xFE, 0x59, + 0x72, 0x85, 0x5D, 0x65, 0xF0, 0xF6, 0x9F, 0x35 + }, + { + 0xEB, 0x5B, 0x3B, 0xC4, 0xA9, 0x07, 0x47, 0xDB, + 0x41, 0x04, 0xA6, 0xD6, 0x22, 0x08, 0x83, 0x5A, + 0xDA, 0x89, 0x45, 0xA6, 0x75, 0x3E, 0xB3, 0xAD, + 0x18, 0xA3, 0xFA, 0x05, 0xF5, 0x4A, 0x7C, 0x01, + 0x62, 0x11, 0xA7, 0xC1, 0x7D, 0x47, 0x88, 0xEA, + 0xB9, 0xA1, 0x9C, 0xAA, 0x87, 0xBE, 0x11, 0xC0, + 0x4F, 0x15, 0x58, 0x00, 0xDF, 0x5D, 0xFF, 0xA5, + 0xCF, 0xE6, 0xC3, 0x61, 0x4F, 0x5C, 0x9A, 0xE4 + }, + { + 0x22, 0xEB, 0xD9, 0x2B, 0xA1, 0x67, 0xE0, 0xB0, + 0x5D, 0xDD, 0x64, 0x7E, 0x60, 0xCE, 0x84, 0x64, + 0x9B, 0xAB, 0x2A, 0xC7, 0xFD, 0x15, 0x4E, 0xCC, + 0x4F, 0x99, 0xDA, 0x82, 0x07, 0xD7, 0xBA, 0x6D, + 0x07, 0xC2, 0x04, 0x5F, 0x94, 0x21, 0x95, 0xAD, + 0x75, 0x9C, 0x01, 0x64, 0x40, 0x16, 0x96, 0x4C, + 0x62, 0xC6, 0x02, 0x17, 0xCD, 0xF6, 0x3E, 0x8E, + 0x5C, 0xBA, 0x45, 0x91, 0xA0, 0xCB, 0xFE, 0x6D + }, + { + 0x23, 0x63, 0x02, 0x13, 0x4F, 0x66, 0x31, 0xC0, + 0xD8, 0xC6, 0x7F, 0x9D, 0xE8, 0xB1, 0x58, 0x09, + 0xD6, 0xCA, 0xE1, 0xB0, 0x4C, 0xE4, 0xC6, 0x4B, + 0xF6, 0x7B, 0x01, 0xFC, 0xFB, 0x77, 0xDC, 0xEB, + 0x27, 0xB0, 0x7E, 0x71, 0x42, 0x28, 0x8D, 0x7A, + 0x90, 0x4D, 0xBB, 0xEA, 0xC5, 0x32, 0xAE, 0x5D, + 0x9B, 0xEC, 0xF9, 0x8B, 0x8A, 0x24, 0x43, 0x7D, + 0x0F, 0x2F, 0x1A, 0xD7, 0xBB, 0x39, 0x6E, 0x14 + }, + { + 0x81, 0x15, 0x66, 0xB9, 0x53, 0x9C, 0xAF, 0x1F, + 0xA6, 0xDE, 0x85, 0xBD, 0xB0, 0xFD, 0x78, 0xDC, + 0x39, 0x08, 0x35, 0x35, 0xB1, 0x70, 0x31, 0x4D, + 0x16, 0x7A, 0x5C, 0x37, 0x56, 0x69, 0x4D, 0x4A, + 0xE9, 0xE3, 0x51, 0xD2, 0x04, 0x94, 0xAB, 0xBC, + 0x6F, 0x19, 0x1A, 0x4A, 0x51, 0x57, 0x76, 0x3F, + 0x4C, 0xCE, 0x06, 0x0A, 0xF4, 0x90, 0x30, 0x1D, + 0x65, 0x2B, 0xA8, 0x2B, 0x40, 0x68, 0x2A, 0x9B + }, + { + 0xFE, 0x48, 0x87, 0x64, 0xF7, 0x21, 0xF9, 0x34, + 0x90, 0x0A, 0xCA, 0x67, 0x02, 0xC2, 0xB4, 0xD2, + 0x20, 0x2B, 0xB6, 0xC6, 0x7E, 0x26, 0xD8, 0x92, + 0xE5, 0x30, 0x4B, 0x2E, 0x31, 0x98, 0x61, 0xA3, + 0xC0, 0xA7, 0x36, 0xCC, 0x14, 0xD0, 0x02, 0xD8, + 0x48, 0xEA, 0xB3, 0xCF, 0xBD, 0xA2, 0x10, 0x65, + 0xCA, 0x62, 0x4B, 0x7F, 0x20, 0x13, 0x58, 0x2E, + 0xD7, 0xF1, 0xB6, 0xCC, 0xBE, 0xCC, 0xFB, 0xEC + }, + { + 0x73, 0x8C, 0xBE, 0xDD, 0x01, 0xA1, 0x76, 0x2B, + 0xAD, 0x27, 0x4B, 0x4C, 0x6D, 0x0A, 0x4A, 0xE9, + 0xCC, 0x1A, 0xB6, 0xBD, 0xC1, 0x5F, 0x52, 0x57, + 0x00, 0x34, 0xE3, 0x24, 0x09, 0x6C, 0x3A, 0x8C, + 0x2D, 0x6E, 0x1C, 0x66, 0xDE, 0x3E, 0xE2, 0x6E, + 0x1A, 0xDE, 0x53, 0x71, 0xFD, 0xD9, 0xC1, 0x49, + 0x80, 0xCC, 0x99, 0xBE, 0x0D, 0x65, 0x70, 0x6D, + 0xFA, 0x40, 0x51, 0xE3, 0xCA, 0xF4, 0xB2, 0x76 + }, + { + 0x7B, 0x9C, 0x71, 0xCB, 0x61, 0x91, 0x94, 0x70, + 0x30, 0xEC, 0xA8, 0xDD, 0xC3, 0x42, 0x6D, 0x26, + 0x8B, 0x55, 0xF0, 0x07, 0x88, 0x23, 0x32, 0xA2, + 0x72, 0xB5, 0xEB, 0x00, 0xF8, 0x8C, 0xC6, 0xB2, + 0xBA, 0x0F, 0x88, 0x57, 0x52, 0xCC, 0x47, 0xD0, + 0x62, 0x9F, 0x1F, 0xDC, 0x65, 0xC8, 0x4D, 0x75, + 0x27, 0x8D, 0xA7, 0x52, 0x1E, 0x26, 0x81, 0x3A, + 0xF8, 0xFE, 0x71, 0xBF, 0xB0, 0x25, 0x99, 0xB0 + }, + { + 0x21, 0xEC, 0xB4, 0xB1, 0x55, 0x8A, 0x20, 0x84, + 0x25, 0x69, 0xF7, 0xAC, 0xDA, 0x77, 0x46, 0xFF, + 0x8A, 0xE2, 0xE1, 0x6A, 0x9F, 0x70, 0x3B, 0xBD, + 0xF2, 0xA4, 0x45, 0xBE, 0x75, 0xC9, 0x53, 0xA4, + 0xB9, 0x13, 0x16, 0x6D, 0xC5, 0x96, 0xBD, 0x3D, + 0xF5, 0x4F, 0x8F, 0x51, 0x98, 0x9C, 0x52, 0xA5, + 0xE0, 0xAE, 0xB5, 0xBC, 0x67, 0xA8, 0x57, 0xA8, + 0x79, 0x1F, 0x96, 0xF0, 0xFD, 0x13, 0x98, 0xA6 + }, + { + 0xCC, 0x1C, 0xEB, 0x5E, 0x58, 0x04, 0x75, 0x99, + 0xC7, 0x28, 0x50, 0x5A, 0x61, 0xAD, 0xEF, 0xE4, + 0xDE, 0x17, 0x7A, 0x89, 0xC1, 0xA6, 0x55, 0xB9, + 0x77, 0x38, 0x3D, 0x5D, 0x60, 0x9A, 0x73, 0xBA, + 0x3D, 0x6F, 0xF7, 0xCC, 0x32, 0x1C, 0xB5, 0x44, + 0xAD, 0x5F, 0x93, 0x8E, 0xD9, 0x01, 0x19, 0x8B, + 0xFD, 0xCF, 0x4E, 0xA1, 0x05, 0xAC, 0x45, 0xA2, + 0x53, 0x61, 0x14, 0x5A, 0x6E, 0x92, 0x57, 0xDC + }, + { + 0x73, 0xC2, 0xE1, 0x69, 0x51, 0xCB, 0x29, 0xC5, + 0xE4, 0xD8, 0x74, 0x7E, 0x85, 0x18, 0x1B, 0x9F, + 0x2B, 0x17, 0xCD, 0x1C, 0x7E, 0xBB, 0xB2, 0xD6, + 0x02, 0x67, 0x5D, 0xAE, 0x71, 0xF3, 0x45, 0xCE, + 0x73, 0x59, 0x2C, 0xE4, 0xA3, 0x4B, 0x41, 0xEE, + 0x34, 0x4D, 0xB6, 0x0C, 0x44, 0x55, 0x10, 0x11, + 0xD7, 0x66, 0x32, 0x55, 0xCD, 0xA2, 0xA2, 0x49, + 0xDC, 0xF5, 0x68, 0xFF, 0xDB, 0x0F, 0xF4, 0xF5 + }, + { + 0xFE, 0x22, 0xC0, 0xF3, 0xC2, 0x3A, 0x12, 0x9C, + 0x38, 0xAB, 0x3C, 0x63, 0x3F, 0x17, 0x48, 0x51, + 0x61, 0xD9, 0x64, 0x19, 0xF8, 0xA2, 0x83, 0xB7, + 0xEC, 0xD4, 0xED, 0xB1, 0x64, 0x0A, 0x34, 0x2D, + 0x7D, 0xCB, 0xF2, 0xAF, 0xC9, 0x35, 0xA1, 0xD1, + 0x4B, 0x07, 0xC5, 0x12, 0x37, 0x65, 0x94, 0x7A, + 0xCD, 0xDA, 0x28, 0x53, 0xE6, 0x6B, 0x96, 0x62, + 0x53, 0xA5, 0xC5, 0x8F, 0x07, 0x54, 0xC9, 0xCA + }, + { + 0x78, 0x80, 0xFD, 0xE0, 0x77, 0xA4, 0x81, 0x86, + 0x9F, 0xAB, 0x01, 0x4D, 0x07, 0x79, 0x8A, 0xDD, + 0x4D, 0x5C, 0xEB, 0x5D, 0xEC, 0xEB, 0x5E, 0xC0, + 0x0D, 0xD8, 0xDA, 0x05, 0xB7, 0xB3, 0xEF, 0xEB, + 0xB4, 0xD6, 0x3A, 0xA6, 0xFB, 0xE4, 0xB0, 0x54, + 0x0A, 0x7F, 0xF8, 0x1F, 0xFA, 0xD9, 0x1D, 0xD3, + 0x32, 0xCF, 0x4F, 0x8A, 0xCA, 0x6C, 0x09, 0xD6, + 0x0B, 0x7F, 0xAE, 0x0D, 0x81, 0xD1, 0xB5, 0xF9 + }, + { + 0x5D, 0x36, 0x21, 0x89, 0x66, 0xD5, 0x38, 0xFF, + 0xB1, 0x51, 0xF6, 0xCB, 0x23, 0x08, 0x14, 0x00, + 0x51, 0x5F, 0xCC, 0x1E, 0x1D, 0xCC, 0xA0, 0x3C, + 0x48, 0xDB, 0x1E, 0x62, 0x5C, 0xCE, 0x90, 0x2F, + 0x9E, 0x0C, 0x4C, 0xA1, 0x93, 0x32, 0x7A, 0x4F, + 0xD0, 0xC1, 0x98, 0x33, 0x24, 0x6B, 0x9E, 0x1F, + 0x5D, 0xDD, 0xDE, 0xF3, 0x6C, 0xA7, 0xF2, 0xC2, + 0xB8, 0x86, 0x6B, 0xFD, 0x2B, 0x86, 0x19, 0xAF + }, + { + 0xE0, 0xBF, 0x47, 0xD5, 0x54, 0x6D, 0x3E, 0xC6, + 0x6D, 0xB8, 0x49, 0xD2, 0xCD, 0x7A, 0xF9, 0xE5, + 0x1B, 0x2C, 0x10, 0x8C, 0xAD, 0x9A, 0xB1, 0x60, + 0x71, 0x7E, 0x90, 0xA3, 0xA0, 0xE9, 0x7A, 0x11, + 0x9A, 0xB4, 0x76, 0x0C, 0xDF, 0x4B, 0xF9, 0xE8, + 0x03, 0x45, 0xB6, 0x79, 0xE2, 0x5A, 0x25, 0xC9, + 0x6B, 0xD1, 0x08, 0x22, 0xC6, 0xC0, 0x82, 0x8C, + 0xD0, 0xFE, 0xF6, 0x23, 0x9E, 0x5A, 0xE5, 0x1F + }, + { + 0x56, 0xC2, 0x9F, 0x81, 0xFE, 0x42, 0x46, 0xAA, + 0x9F, 0x3C, 0xB0, 0x28, 0x5D, 0x08, 0xF1, 0x83, + 0x9C, 0xC3, 0xD5, 0xB1, 0x21, 0x19, 0x17, 0x58, + 0x3C, 0x1F, 0xE3, 0xC4, 0x46, 0xEC, 0x74, 0xFD, + 0xE4, 0xC8, 0xA2, 0xA8, 0x85, 0x2E, 0xCC, 0xBB, + 0x07, 0x95, 0x35, 0x32, 0xD4, 0x8D, 0x22, 0x43, + 0x78, 0x96, 0xD9, 0x92, 0x56, 0x37, 0x41, 0xB0, + 0xD4, 0x41, 0x14, 0xE3, 0x85, 0x18, 0xFC, 0xAE + }, + { + 0x63, 0xDF, 0xFB, 0x1E, 0x18, 0x66, 0xFF, 0x27, + 0xC4, 0x41, 0xA1, 0xAA, 0x87, 0xCF, 0x8B, 0x4A, + 0xD1, 0xA0, 0x45, 0xBE, 0xAC, 0x48, 0x91, 0x48, + 0x05, 0xD6, 0x54, 0x1A, 0x5A, 0x92, 0x15, 0x56, + 0xF1, 0x58, 0xC8, 0x60, 0x1D, 0x77, 0x8D, 0xC8, + 0x05, 0xB9, 0x5F, 0x60, 0xB8, 0xC5, 0x59, 0xB9, + 0x81, 0x7B, 0x54, 0x09, 0xDC, 0x9E, 0x77, 0x6C, + 0xF1, 0x93, 0xC7, 0x0C, 0xFA, 0x20, 0x0C, 0x4E + }, + { + 0x1E, 0xC2, 0x58, 0xE7, 0x28, 0x09, 0x47, 0x59, + 0x7B, 0x90, 0x0D, 0xDC, 0x6B, 0xDE, 0xF8, 0xF7, + 0x84, 0xA9, 0xFF, 0x7C, 0xDB, 0x8D, 0xD7, 0x48, + 0x89, 0xC0, 0xDC, 0xD5, 0x64, 0xD9, 0x6D, 0x22, + 0x14, 0x64, 0x47, 0x66, 0x12, 0xA6, 0x6B, 0x8B, + 0x47, 0x48, 0xE9, 0x5D, 0x29, 0x90, 0x0C, 0xB2, + 0xF0, 0xA7, 0x1B, 0x0E, 0xBE, 0xE6, 0x92, 0xBD, + 0x2D, 0x57, 0x2F, 0xDE, 0xA2, 0xFB, 0xB8, 0x6F + }, + { + 0xD9, 0x2D, 0x29, 0x23, 0xA0, 0xCB, 0x74, 0xF9, + 0x7E, 0x35, 0xDE, 0x8F, 0x16, 0x6A, 0xED, 0x46, + 0xC8, 0xC9, 0x7A, 0x33, 0x42, 0x45, 0x29, 0xE9, + 0x6D, 0x83, 0x3A, 0x1F, 0x17, 0x6C, 0x03, 0x1E, + 0x19, 0xB1, 0xA0, 0xCC, 0x39, 0xCB, 0xAF, 0x05, + 0xC7, 0x92, 0xC7, 0x35, 0xF0, 0xCC, 0x0C, 0xDF, + 0xB5, 0x21, 0x70, 0x5B, 0xD5, 0xDD, 0xB8, 0x11, + 0xBB, 0x55, 0x12, 0xCD, 0x02, 0x29, 0x16, 0xA1 + }, + { + 0x3D, 0x0D, 0x74, 0x4E, 0xE2, 0x00, 0x43, 0x3B, + 0x8F, 0xA5, 0x93, 0xA9, 0xC8, 0x7B, 0x79, 0x85, + 0x63, 0xCD, 0x94, 0x5F, 0x64, 0x5E, 0x52, 0xE5, + 0xAB, 0x9F, 0x51, 0x8E, 0x81, 0x06, 0x31, 0x3B, + 0xD7, 0xB4, 0x12, 0x13, 0xEE, 0xBE, 0x47, 0xE5, + 0x79, 0x89, 0x61, 0x22, 0xA5, 0xCD, 0x25, 0x4A, + 0x66, 0x0A, 0x95, 0xCB, 0x79, 0xE5, 0x2D, 0x9B, + 0x96, 0x47, 0x74, 0x17, 0xFE, 0xDB, 0x6B, 0x38 + }, + { + 0x94, 0x68, 0x7B, 0xF4, 0xE5, 0x7F, 0x8F, 0x45, + 0x1D, 0xC4, 0xD5, 0xF4, 0xCF, 0x9C, 0xB0, 0x17, + 0x87, 0xCF, 0xB8, 0x60, 0xF4, 0x35, 0x54, 0x51, + 0xC7, 0x45, 0x18, 0x73, 0x6A, 0xAE, 0xD0, 0x98, + 0x2D, 0x27, 0x8C, 0xB4, 0x8B, 0xBE, 0x14, 0xD8, + 0x4B, 0x2A, 0x6A, 0xD0, 0xB6, 0x16, 0x16, 0x6C, + 0x8B, 0xE3, 0x53, 0xE1, 0x43, 0x37, 0x93, 0x56, + 0x25, 0x92, 0x05, 0x3C, 0x1B, 0xB7, 0x19, 0x73 + }, + { + 0x37, 0x24, 0x18, 0xC9, 0xE3, 0xA6, 0xC5, 0x14, + 0xDA, 0x2B, 0x75, 0xDF, 0x71, 0x67, 0x05, 0x01, + 0xCE, 0x38, 0x7A, 0xF4, 0xF5, 0xD9, 0x7D, 0xAC, + 0xAD, 0x5B, 0xDF, 0x7B, 0x3D, 0x5F, 0xE9, 0xF5, + 0x69, 0x04, 0x68, 0xE2, 0xF9, 0xBA, 0xB3, 0xA0, + 0xB5, 0x8A, 0xC0, 0x30, 0x0C, 0x5F, 0xA5, 0x6C, + 0x25, 0x8C, 0xB8, 0xEC, 0xBD, 0x8F, 0x01, 0x06, + 0xD3, 0xB9, 0xFB, 0x9D, 0xF2, 0x6D, 0xD6, 0x07 + }, + { + 0x58, 0xD8, 0x4C, 0x48, 0x77, 0x21, 0x83, 0xE0, + 0x9C, 0xC5, 0x84, 0x43, 0x2C, 0x33, 0xC5, 0xF0, + 0x95, 0x22, 0xAF, 0xD2, 0x47, 0x56, 0xEA, 0xAF, + 0x64, 0x4F, 0x4B, 0xEC, 0x86, 0x1F, 0xE2, 0x35, + 0x19, 0xF4, 0x72, 0x4B, 0x1A, 0x6C, 0xD6, 0x9A, + 0xAB, 0x04, 0xB3, 0x41, 0xA6, 0x2C, 0x9B, 0xA7, + 0x64, 0x10, 0x52, 0x36, 0xB0, 0xC1, 0xF9, 0xA1, + 0x48, 0x3D, 0xA3, 0xD6, 0xAE, 0xCC, 0x62, 0xBA + }, + { + 0x50, 0x85, 0xC1, 0x6E, 0xF3, 0x9E, 0xD8, 0x8C, + 0x5B, 0xEA, 0xA0, 0x4A, 0x80, 0xE7, 0x27, 0x19, + 0xEB, 0x0F, 0x16, 0xF3, 0xF3, 0xDC, 0x48, 0x05, + 0x6A, 0x1A, 0xA1, 0x05, 0x84, 0xF6, 0x50, 0x8B, + 0x09, 0x70, 0x65, 0xFF, 0x3E, 0x4B, 0x41, 0x49, + 0xD7, 0xCC, 0xBC, 0x09, 0x5D, 0x9B, 0x78, 0x62, + 0xDC, 0x74, 0xEB, 0xB7, 0xC9, 0x6A, 0x6D, 0x56, + 0xDB, 0x65, 0x66, 0x4A, 0x28, 0x06, 0x64, 0x7A + }, + { + 0xA6, 0xC7, 0xD2, 0xC9, 0x0D, 0x39, 0x6B, 0xFB, + 0xC2, 0x8C, 0x68, 0x50, 0x88, 0x4A, 0x1D, 0x0F, + 0x9E, 0x26, 0x50, 0xD4, 0x59, 0xE0, 0x65, 0x7C, + 0xAB, 0x5F, 0x1D, 0xFD, 0xE9, 0xA2, 0xA3, 0xB9, + 0xE5, 0x67, 0x33, 0x8B, 0xD3, 0x4C, 0xC9, 0xDA, + 0x04, 0x2E, 0xD1, 0xF4, 0xAA, 0xE0, 0xE4, 0x81, + 0xC8, 0x74, 0xF5, 0x7E, 0x66, 0xCB, 0xFC, 0xD9, + 0xD1, 0xC6, 0x34, 0x27, 0xE6, 0xD9, 0x38, 0xC6 + }, + { + 0x9A, 0x26, 0xA7, 0x19, 0x23, 0xA3, 0x57, 0x6E, + 0x44, 0x44, 0x8A, 0x50, 0x98, 0xE9, 0xC0, 0x91, + 0x05, 0xFC, 0xEE, 0xA0, 0x2A, 0x97, 0xFD, 0x5B, + 0x83, 0xBD, 0x14, 0x00, 0xBB, 0xA3, 0x2A, 0xAE, + 0x2F, 0x91, 0x7A, 0xF1, 0x15, 0xFA, 0xF7, 0x84, + 0x60, 0x67, 0xF9, 0x5E, 0x8A, 0x8F, 0x84, 0xE5, + 0x8C, 0xF4, 0x61, 0xB9, 0xBF, 0x41, 0x22, 0x9D, + 0xF2, 0x4E, 0xAE, 0x63, 0xC4, 0x61, 0x8A, 0x00 + }, + { + 0x40, 0x13, 0xF6, 0xC6, 0x51, 0xE5, 0x20, 0xE8, + 0x6D, 0x51, 0x50, 0x1B, 0xC1, 0x50, 0xC1, 0x3D, + 0xAB, 0xB8, 0x8B, 0x06, 0xE2, 0x00, 0xF3, 0x2C, + 0x87, 0x9B, 0x50, 0xA9, 0xEB, 0x6E, 0x60, 0xE8, + 0xA5, 0xC2, 0x9E, 0xFF, 0xC7, 0xFB, 0x1D, 0x4C, + 0xA1, 0x20, 0x5A, 0x40, 0xE8, 0xC4, 0xD0, 0x5A, + 0x4C, 0x5A, 0xB8, 0x78, 0x7B, 0x03, 0xC2, 0xA1, + 0xAB, 0x81, 0x34, 0x64, 0xE9, 0xF2, 0x47, 0x77 + }, + { + 0xE6, 0xCC, 0x28, 0xF1, 0x64, 0x2A, 0x78, 0xB8, + 0xCC, 0x67, 0x36, 0x80, 0xB3, 0x8D, 0x11, 0xD2, + 0x6B, 0x5C, 0x38, 0x13, 0x13, 0x0E, 0x2F, 0x33, + 0xC3, 0xA1, 0xF1, 0xF3, 0xC5, 0x34, 0xF5, 0x7F, + 0xD0, 0x58, 0xEC, 0x5D, 0x29, 0x62, 0x8A, 0x9D, + 0xEB, 0x9F, 0x0A, 0xDD, 0x2B, 0xB1, 0xBA, 0x2C, + 0x36, 0xEB, 0x31, 0x65, 0x52, 0x8E, 0xEB, 0xC4, + 0x48, 0x43, 0xC9, 0xFD, 0x08, 0x87, 0x07, 0x06 + }, + { + 0xAE, 0xB9, 0x57, 0xD6, 0x5F, 0x12, 0x48, 0x12, + 0x75, 0xD8, 0xBF, 0x81, 0x91, 0x35, 0x13, 0x2B, + 0xF3, 0x2F, 0x2D, 0xC7, 0x2A, 0x15, 0x8A, 0xA3, + 0x39, 0x7B, 0x3B, 0x95, 0x10, 0xE3, 0x0F, 0xF2, + 0x9A, 0xF2, 0x97, 0xE6, 0x32, 0x91, 0x63, 0xA1, + 0x49, 0x8C, 0xF4, 0xD1, 0x36, 0xB6, 0x68, 0xC1, + 0x28, 0xD1, 0x97, 0x84, 0xC4, 0xBF, 0x20, 0x19, + 0x4F, 0xE7, 0xC4, 0x67, 0xD5, 0xF2, 0x8A, 0x12 + }, + { + 0x4D, 0x15, 0x30, 0xC9, 0x6D, 0x96, 0x80, 0xD5, + 0x78, 0xB2, 0x09, 0x2B, 0x40, 0xBF, 0xD7, 0xCA, + 0xE0, 0x66, 0xA1, 0x26, 0x80, 0x84, 0x10, 0xA1, + 0x28, 0x8F, 0x0F, 0xA4, 0x0A, 0xDE, 0x41, 0xA3, + 0xCE, 0x4A, 0x15, 0xF9, 0xDD, 0xDB, 0xF8, 0xE3, + 0x12, 0x72, 0xC3, 0x6D, 0xEF, 0x19, 0xEC, 0x49, + 0x88, 0xF4, 0x4C, 0x4C, 0x7B, 0xD0, 0x31, 0xD8, + 0xEC, 0x2D, 0xC7, 0x97, 0xB7, 0xEB, 0xD7, 0x6E + }, + { + 0x17, 0xDB, 0x04, 0x7F, 0x73, 0xBF, 0x02, 0xD6, + 0x20, 0x9A, 0x41, 0x32, 0x6D, 0x79, 0x2E, 0x54, + 0x45, 0x29, 0x8F, 0x4A, 0xD7, 0x11, 0x03, 0x03, + 0x27, 0xD5, 0x37, 0x1D, 0xF4, 0xB0, 0x78, 0x58, + 0xE7, 0xB0, 0x72, 0x51, 0xDF, 0x4C, 0x0C, 0xBA, + 0xA0, 0x9D, 0xE4, 0xB9, 0x73, 0xC5, 0x44, 0xD8, + 0x2C, 0x48, 0xD0, 0xE1, 0xBF, 0x52, 0x0E, 0x1D, + 0x9C, 0xC4, 0xDD, 0xA0, 0xC5, 0xF6, 0xB6, 0x5A + }, + { + 0x25, 0x72, 0x39, 0x6B, 0x71, 0x9B, 0x19, 0x43, + 0x26, 0xE3, 0xD2, 0x49, 0xDC, 0xDA, 0xCD, 0x62, + 0x83, 0xB3, 0x0D, 0x29, 0x3E, 0x90, 0xA6, 0x39, + 0x26, 0x8D, 0xD4, 0x81, 0x0D, 0xF0, 0x78, 0x93, + 0x6C, 0xE9, 0xD2, 0xF1, 0x22, 0xB0, 0xF2, 0x68, + 0xFA, 0x2E, 0x9D, 0xA8, 0x36, 0x94, 0x15, 0xE2, + 0xF6, 0xCF, 0xB7, 0x48, 0x95, 0x64, 0x2F, 0x84, + 0xE8, 0x2A, 0x4E, 0xD9, 0xA4, 0x4A, 0xE7, 0x41 + }, + { + 0x2F, 0x22, 0x67, 0x34, 0x29, 0x1C, 0xA2, 0xF6, + 0xDA, 0xEC, 0xBE, 0x1B, 0x36, 0x31, 0x3E, 0x03, + 0xF5, 0x7F, 0x14, 0xE1, 0x9E, 0xF4, 0x79, 0xD9, + 0x95, 0xC2, 0x72, 0x9A, 0x95, 0x4A, 0x0B, 0x90, + 0xAC, 0x58, 0xA2, 0x9C, 0xA5, 0x6E, 0x7B, 0x74, + 0x3B, 0xB2, 0x66, 0x78, 0xFA, 0x16, 0xB6, 0xD1, + 0xBB, 0x62, 0x9D, 0x0A, 0xAD, 0xF5, 0xFD, 0x4C, + 0x1F, 0x0A, 0xDB, 0x88, 0xE9, 0xDD, 0x7E, 0x0D + }, + { + 0xA5, 0x9F, 0xD9, 0x7D, 0x12, 0x10, 0x5F, 0x59, + 0x59, 0x4E, 0x12, 0x37, 0x3B, 0x57, 0x88, 0x5B, + 0xE7, 0xC4, 0x35, 0x6D, 0xBC, 0x4E, 0x1E, 0x1C, + 0x29, 0x10, 0xBD, 0x95, 0x94, 0x0B, 0x5B, 0xCA, + 0xA9, 0x40, 0xAD, 0x4B, 0xF5, 0x79, 0xCE, 0xF6, + 0x15, 0x8C, 0xEC, 0xCF, 0xB7, 0x94, 0xBA, 0xE0, + 0xAF, 0x52, 0x0A, 0x48, 0x79, 0x43, 0x89, 0xEB, + 0x4F, 0x7F, 0x27, 0xBB, 0x04, 0x8D, 0xF9, 0x1E + }, + { + 0xC9, 0xBF, 0x14, 0x3A, 0xAF, 0x70, 0xB7, 0x6C, + 0x53, 0x46, 0x45, 0xAD, 0x96, 0x73, 0xBB, 0x9D, + 0x5A, 0x68, 0xCF, 0xBE, 0xDB, 0x62, 0xB4, 0x3B, + 0xDD, 0xD5, 0xED, 0x13, 0xAD, 0xD4, 0x17, 0x6F, + 0x8A, 0xDB, 0x8D, 0x43, 0xFE, 0x13, 0xA2, 0x7E, + 0xB1, 0x19, 0xD5, 0xDA, 0x74, 0x71, 0x73, 0xE9, + 0x39, 0xBC, 0x91, 0x9D, 0x35, 0xF3, 0xE5, 0x0C, + 0x5C, 0xA1, 0xF3, 0x97, 0x50, 0x6B, 0xA7, 0xBE + }, + { + 0x1A, 0x66, 0x4B, 0x02, 0x55, 0xB9, 0xE3, 0x1E, + 0x74, 0x04, 0x1F, 0x4C, 0x70, 0x93, 0x00, 0x28, + 0x7D, 0x82, 0xE9, 0x5A, 0x62, 0xDA, 0x39, 0xAF, + 0x2D, 0x9C, 0xC1, 0xB9, 0xB7, 0xCB, 0xF5, 0x58, + 0x0E, 0x70, 0x34, 0x95, 0x79, 0xED, 0x7E, 0xC5, + 0xD1, 0xB2, 0x1E, 0x20, 0xCD, 0xB0, 0xA5, 0xF2, + 0x26, 0xD5, 0xCD, 0x86, 0x94, 0x3E, 0x9C, 0x16, + 0x4A, 0x84, 0xAD, 0xAC, 0xC2, 0x15, 0x18, 0xF8 + }, + { + 0x6E, 0x54, 0xF5, 0xF0, 0xAC, 0xB3, 0xB3, 0x43, + 0x3A, 0x92, 0x6D, 0xBC, 0x21, 0x55, 0x9D, 0xEB, + 0xCB, 0x1B, 0x64, 0x81, 0x9D, 0x85, 0x6E, 0xC9, + 0x36, 0x33, 0x40, 0x67, 0x21, 0xCA, 0x94, 0x59, + 0x0E, 0xC5, 0x17, 0x46, 0x84, 0xE5, 0x97, 0x8B, + 0x71, 0xD4, 0x4E, 0x6C, 0xE3, 0x24, 0x56, 0x89, + 0x54, 0x4F, 0x0C, 0x22, 0x1D, 0x8C, 0x5F, 0x1A, + 0x5B, 0x17, 0xD5, 0x28, 0xB2, 0x95, 0xEB, 0x72 + }, + { + 0xEB, 0x36, 0xFE, 0x6A, 0x34, 0x1D, 0x71, 0xFA, + 0xAC, 0x22, 0xA4, 0xA8, 0x48, 0x17, 0xA5, 0xE5, + 0x90, 0xD8, 0x84, 0xAE, 0x12, 0x58, 0xBE, 0xEF, + 0x61, 0x16, 0xD6, 0x53, 0xB2, 0xA2, 0x51, 0xCE, + 0x42, 0x2E, 0x1C, 0x3A, 0x95, 0x78, 0xB9, 0x52, + 0x64, 0xE9, 0x7B, 0x18, 0x6C, 0xE4, 0xE1, 0xCB, + 0x6D, 0xB5, 0xCC, 0x30, 0x47, 0x62, 0xD9, 0xD5, + 0x78, 0x4D, 0x12, 0xA9, 0x73, 0xB2, 0xEF, 0xDA + }, + { + 0xAF, 0x60, 0x86, 0x86, 0xCA, 0x5D, 0xE1, 0xB8, + 0x6B, 0x9C, 0xF1, 0x01, 0x46, 0x95, 0xB2, 0xC5, + 0x47, 0x63, 0x93, 0x76, 0xAB, 0xEF, 0xDC, 0xDE, + 0x0F, 0x0A, 0x96, 0xFF, 0x22, 0xEF, 0xB3, 0xCB, + 0x5D, 0xF6, 0x10, 0x90, 0x3F, 0x65, 0x0C, 0x8A, + 0x22, 0x12, 0xAA, 0x46, 0x7D, 0x14, 0x61, 0xDE, + 0xD5, 0x1D, 0xA9, 0x0C, 0xB8, 0xD1, 0x72, 0x81, + 0xC9, 0x69, 0x81, 0x83, 0x64, 0x33, 0xE6, 0x9B + }, + { + 0xFA, 0x01, 0xCF, 0x9A, 0xEB, 0x61, 0x19, 0x61, + 0x3B, 0xCB, 0x8C, 0x41, 0x4E, 0x49, 0x45, 0x96, + 0x07, 0xC0, 0x31, 0x52, 0x98, 0x80, 0xE4, 0x9B, + 0x28, 0x96, 0x05, 0x2E, 0xD9, 0x85, 0x08, 0x72, + 0x0D, 0x8C, 0x80, 0xE4, 0xF1, 0xC4, 0x37, 0xD1, + 0x0C, 0x66, 0xD7, 0x4E, 0x32, 0xA8, 0xD1, 0xCA, + 0xCA, 0xCD, 0x33, 0xE8, 0x3D, 0xA7, 0x10, 0xE3, + 0xC3, 0xDE, 0x08, 0xF5, 0x12, 0xF5, 0x45, 0xEE + }, + { + 0xA9, 0x8F, 0x16, 0x81, 0xB4, 0x75, 0x7A, 0x3A, + 0x76, 0x20, 0xDB, 0x24, 0x4D, 0xE5, 0x44, 0xBD, + 0x3D, 0xA3, 0xBA, 0x9D, 0xC8, 0xBC, 0xEE, 0x7C, + 0xAB, 0xD5, 0x54, 0x06, 0x22, 0x12, 0x31, 0xF7, + 0x58, 0xC8, 0xBE, 0x29, 0xC0, 0xC0, 0x17, 0x12, + 0xB3, 0x38, 0xD7, 0x23, 0xA2, 0x0F, 0x34, 0xED, + 0xFD, 0x07, 0x96, 0x03, 0xC4, 0xB3, 0xB4, 0xAF, + 0x05, 0x31, 0x7B, 0x03, 0x20, 0x6C, 0xC4, 0xAE + }, + { + 0x4D, 0x01, 0xA3, 0x45, 0xE8, 0xB9, 0x61, 0xA8, + 0xB8, 0xB6, 0x52, 0x9D, 0xFD, 0x12, 0x1B, 0x98, + 0x75, 0xAC, 0xED, 0x9C, 0xD4, 0x3B, 0x3A, 0x5D, + 0xDD, 0x13, 0xDD, 0xEC, 0xA0, 0x4F, 0x36, 0x26, + 0xE9, 0xBC, 0x4C, 0xCF, 0x39, 0xB5, 0x01, 0x7D, + 0x44, 0xA4, 0x3B, 0x49, 0x53, 0x4F, 0x76, 0x3C, + 0x65, 0x23, 0xFB, 0xB0, 0x31, 0x21, 0x87, 0x12, + 0x8D, 0x7B, 0x61, 0xA7, 0xFC, 0xC8, 0x48, 0x20 + }, + { + 0x00, 0x78, 0x93, 0x5C, 0x99, 0xA6, 0xE8, 0x01, + 0x22, 0xA0, 0xF3, 0xD4, 0x06, 0xE8, 0x7B, 0xDC, + 0x20, 0x07, 0x0D, 0x49, 0x29, 0x0F, 0x11, 0x36, + 0x64, 0x6F, 0x6B, 0x60, 0xC1, 0xF1, 0x43, 0xAB, + 0xC0, 0xA8, 0x2A, 0x23, 0x5C, 0xCA, 0x81, 0x4C, + 0x3F, 0x0E, 0x3F, 0x03, 0x5D, 0x97, 0x69, 0x57, + 0x71, 0xD6, 0x93, 0x0D, 0xE2, 0x04, 0x7F, 0x04, + 0x12, 0xD2, 0x45, 0xF9, 0x3E, 0xD5, 0x03, 0x85 + }, + { + 0x7F, 0x26, 0xA4, 0x8A, 0x68, 0x8A, 0xAB, 0x2E, + 0x1B, 0x66, 0xE5, 0xD4, 0x0E, 0xD7, 0x85, 0xD2, + 0x77, 0xE5, 0x69, 0xFB, 0xCB, 0xA1, 0x14, 0xFB, + 0x14, 0x8F, 0xE5, 0x8A, 0xC4, 0xEA, 0x74, 0x4B, + 0x90, 0x8A, 0x36, 0xE1, 0x18, 0x84, 0xE3, 0xFD, + 0xBF, 0x6D, 0x2D, 0x38, 0xBE, 0xE5, 0xC2, 0x5E, + 0xB1, 0x14, 0xD5, 0x93, 0xD2, 0xB1, 0x35, 0x4C, + 0xBB, 0x83, 0x16, 0x9A, 0x34, 0xCF, 0x5D, 0xA9 + }, + { + 0xA2, 0x7A, 0xDA, 0x05, 0x49, 0xFE, 0x86, 0x8A, + 0x11, 0x9B, 0xA5, 0xEF, 0x9F, 0xB9, 0x9B, 0xC1, + 0xA1, 0x50, 0xBD, 0x39, 0x91, 0x2B, 0x10, 0xB4, + 0xA4, 0xA0, 0xAA, 0xBA, 0x62, 0xC2, 0xE0, 0xCC, + 0xEA, 0x37, 0x5A, 0xA9, 0x59, 0x19, 0x76, 0xA4, + 0xAA, 0x07, 0x11, 0xC4, 0xA5, 0x65, 0xCE, 0x5F, + 0x61, 0x48, 0xAA, 0x95, 0xA3, 0x2F, 0x4A, 0x80, + 0x3C, 0x6C, 0x7B, 0xB8, 0xD7, 0x99, 0x54, 0x63 + }, + { + 0x80, 0x4E, 0xC1, 0x0F, 0x18, 0xB5, 0x5A, 0x9A, + 0xF0, 0xEB, 0x90, 0x9B, 0x77, 0xEF, 0x15, 0xDA, + 0x8A, 0xF1, 0xDE, 0xE9, 0x71, 0xC2, 0x7C, 0xDE, + 0x96, 0x28, 0xE6, 0x7D, 0x2D, 0xDE, 0x9A, 0x22, + 0x9D, 0xA4, 0x2D, 0x3C, 0x7E, 0x9F, 0x70, 0x5A, + 0xC0, 0x07, 0x73, 0xD7, 0x92, 0xBA, 0x9C, 0x61, + 0x55, 0x02, 0x20, 0x27, 0x21, 0x50, 0xCF, 0xB2, + 0xB7, 0x80, 0x2A, 0x00, 0x74, 0xD9, 0x71, 0x2B + }, + { + 0xAD, 0x02, 0x8A, 0xB2, 0xCF, 0x28, 0x17, 0x23, + 0xF0, 0x7C, 0x73, 0x3B, 0xC3, 0xDD, 0xC9, 0x37, + 0xA8, 0xF9, 0xDA, 0xEC, 0x75, 0x82, 0x02, 0xA7, + 0x59, 0xEA, 0xF0, 0x4C, 0xC6, 0xA3, 0xCF, 0x67, + 0x51, 0xB8, 0x6C, 0x5C, 0x0B, 0x56, 0x26, 0xC4, + 0xC4, 0x12, 0x3A, 0xFE, 0xCD, 0x00, 0xCA, 0xF6, + 0xE2, 0x79, 0xEF, 0xCB, 0x12, 0x91, 0xDF, 0x6E, + 0x76, 0x79, 0xF4, 0xA4, 0x80, 0x92, 0xF3, 0xF3 + }, + { + 0xD0, 0x3F, 0x83, 0x85, 0x5B, 0xEA, 0xB8, 0x5E, + 0x95, 0x24, 0xBA, 0xAF, 0x05, 0x31, 0x27, 0x9C, + 0x23, 0x96, 0x9B, 0xC6, 0xE6, 0x9F, 0x16, 0xCF, + 0x82, 0x5F, 0x55, 0x31, 0x6A, 0x5E, 0x92, 0x66, + 0xE1, 0x62, 0xF7, 0x22, 0x23, 0xF1, 0x06, 0x70, + 0x14, 0xF5, 0xB9, 0x3E, 0x39, 0x2A, 0xBF, 0x76, + 0x93, 0x9A, 0x98, 0x7F, 0x80, 0x2B, 0xA2, 0x5E, + 0xE9, 0x53, 0x4D, 0xB8, 0x90, 0x2E, 0x33, 0xDA + }, + { + 0x77, 0x85, 0x92, 0xE4, 0xA9, 0x54, 0x3B, 0x52, + 0xF9, 0x86, 0xFE, 0xF2, 0xC8, 0x54, 0x55, 0x2C, + 0xD8, 0x67, 0xD7, 0x43, 0x46, 0x4E, 0x87, 0x58, + 0x28, 0xCF, 0xD4, 0xAE, 0x91, 0x26, 0x5B, 0x55, + 0xFE, 0x87, 0x99, 0x91, 0x13, 0x45, 0xAA, 0x5D, + 0x3A, 0x6D, 0xD0, 0x49, 0x20, 0x13, 0x2A, 0x98, + 0xD3, 0xBC, 0x1B, 0x8B, 0xEE, 0x00, 0x54, 0xF0, + 0x74, 0x43, 0xD5, 0xB2, 0x91, 0x40, 0xCC, 0x9E + }, + { + 0x82, 0xDA, 0xCE, 0xBD, 0xD0, 0xAA, 0x19, 0xA0, + 0xFC, 0x58, 0xE1, 0xFB, 0xAE, 0xE0, 0x9E, 0xA8, + 0xC3, 0x0C, 0xCB, 0x90, 0x2F, 0xE6, 0xB0, 0xF4, + 0x00, 0xDC, 0x17, 0x9D, 0x9C, 0xEF, 0xC9, 0xFA, + 0x0B, 0xBE, 0x7D, 0xA1, 0xF1, 0x9E, 0xAD, 0x73, + 0xE8, 0xA7, 0x41, 0x0C, 0xD0, 0x19, 0x24, 0x96, + 0xB4, 0x5E, 0xA2, 0xB9, 0x7C, 0x6B, 0x6D, 0x69, + 0xD8, 0x48, 0xA1, 0x8E, 0x3E, 0x53, 0x31, 0xDB + }, + { + 0x09, 0x9D, 0x1B, 0x08, 0xFE, 0x49, 0xD0, 0x89, + 0x6D, 0x26, 0x1F, 0xAC, 0xBF, 0xFC, 0x2B, 0xE6, + 0xA5, 0xC5, 0x74, 0xA7, 0x6A, 0x11, 0x9B, 0x5D, + 0xC0, 0x27, 0x48, 0x3A, 0x65, 0xF5, 0x33, 0xAC, + 0x70, 0x41, 0xB0, 0x17, 0x5A, 0xC8, 0x4D, 0x50, + 0x62, 0xA9, 0x6D, 0x52, 0x13, 0xFF, 0xAB, 0x5F, + 0x2E, 0x91, 0xAD, 0xD8, 0x60, 0xF9, 0x70, 0x60, + 0xE4, 0x6A, 0x05, 0xF1, 0xE1, 0xB8, 0x9E, 0xCD + }, + { + 0xD8, 0xFE, 0x29, 0x7E, 0xC4, 0xFC, 0xB0, 0x5E, + 0xE1, 0xA6, 0x72, 0xA2, 0xE6, 0x2E, 0x27, 0x3F, + 0x2F, 0xBE, 0x70, 0xA3, 0x0B, 0x96, 0x39, 0x41, + 0x62, 0x66, 0xCD, 0xFE, 0x3A, 0xD0, 0x15, 0xC7, + 0xFB, 0xD7, 0x32, 0xD2, 0x8B, 0x4D, 0xD0, 0x76, + 0x60, 0x33, 0x65, 0xCD, 0x8E, 0x31, 0x40, 0xF3, + 0xCE, 0xF8, 0x7A, 0xF2, 0x11, 0x49, 0x67, 0x29, + 0x4A, 0xF2, 0x32, 0xFB, 0x0F, 0x18, 0x50, 0xED + }, + { + 0xF6, 0x14, 0x4A, 0x9F, 0x57, 0xBE, 0x51, 0xD9, + 0x8F, 0x0E, 0x66, 0x09, 0xE1, 0x6F, 0xED, 0x65, + 0x10, 0x95, 0xAE, 0xD7, 0xB2, 0x6B, 0x6A, 0x54, + 0x16, 0xB4, 0x18, 0x23, 0x84, 0x9F, 0xF6, 0x70, + 0x12, 0x38, 0x93, 0x2B, 0x64, 0xA4, 0x66, 0x9B, + 0x5A, 0xF8, 0xD8, 0x43, 0x38, 0xCC, 0xB4, 0x99, + 0x8B, 0x7E, 0x7C, 0xB6, 0x20, 0xBA, 0xD7, 0x63, + 0xB8, 0x4F, 0x97, 0xE0, 0xE9, 0xEE, 0x4A, 0xA0 + }, + { + 0x25, 0x38, 0x44, 0x78, 0x63, 0xCC, 0x33, 0x87, + 0xBA, 0x6A, 0xF8, 0x3E, 0x8D, 0x07, 0xB5, 0x6C, + 0xB2, 0x2D, 0x67, 0xD1, 0x55, 0x2A, 0x68, 0x7A, + 0x85, 0x62, 0x03, 0xA3, 0x4A, 0xA6, 0xEA, 0x73, + 0x77, 0xCB, 0x0B, 0xD7, 0x0F, 0x88, 0x65, 0xE6, + 0xB3, 0xE3, 0x2E, 0xC0, 0x81, 0x15, 0x5C, 0xB9, + 0x20, 0x44, 0x37, 0x1A, 0xE0, 0x94, 0xD0, 0xD4, + 0x4C, 0xCD, 0xE6, 0xE1, 0xDA, 0xFD, 0xDA, 0xD3 + }, + { + 0xCD, 0x68, 0x3C, 0x8A, 0x1B, 0x97, 0x66, 0x66, + 0x89, 0x64, 0x4A, 0xD1, 0x74, 0x8C, 0xE8, 0x47, + 0x11, 0xEF, 0x90, 0x77, 0xA1, 0xCB, 0x25, 0x29, + 0xED, 0xF5, 0xE4, 0xD8, 0xF8, 0xDA, 0x7E, 0xC3, + 0xCB, 0x06, 0xC5, 0x60, 0x0E, 0xBD, 0xAB, 0x05, + 0xD2, 0x7D, 0xA9, 0x42, 0x68, 0xA7, 0x23, 0x81, + 0x82, 0x59, 0x4B, 0xD8, 0x61, 0xE4, 0x1E, 0x8A, + 0x4D, 0x80, 0xF0, 0x40, 0xB9, 0x16, 0x3E, 0x2B + }, + { + 0xE6, 0xC4, 0x89, 0xAB, 0x38, 0x8B, 0x2A, 0xBD, + 0xAA, 0xC9, 0xF8, 0x97, 0xF7, 0x67, 0x7D, 0xCB, + 0x83, 0x8A, 0x9D, 0x10, 0xDC, 0x84, 0x0C, 0x53, + 0xDE, 0xB3, 0xD9, 0x9B, 0x71, 0x42, 0xCF, 0x1B, + 0x81, 0x0E, 0xB7, 0x56, 0x01, 0xFD, 0xB8, 0x83, + 0x2D, 0x6B, 0x24, 0xB9, 0x4F, 0x72, 0x70, 0x8A, + 0xA6, 0x20, 0xED, 0x35, 0x45, 0x29, 0xD0, 0xBA, + 0x90, 0x66, 0xBC, 0x63, 0x3D, 0xF0, 0x39, 0x97 + }, + { + 0x93, 0x38, 0xE0, 0x61, 0x3D, 0x4B, 0x57, 0x89, + 0x67, 0x7A, 0x30, 0xF3, 0x81, 0x48, 0x89, 0x0B, + 0xF1, 0xE0, 0x4C, 0x67, 0x07, 0xB5, 0xEC, 0xCA, + 0x0A, 0x45, 0x73, 0x56, 0x34, 0xFE, 0xCB, 0x60, + 0x8F, 0x5B, 0x45, 0xB0, 0xC4, 0x63, 0xD7, 0x71, + 0x68, 0x8D, 0xD7, 0xFC, 0xA8, 0x97, 0x1B, 0x30, + 0x1A, 0x86, 0x6D, 0xF8, 0xC2, 0x54, 0x1E, 0x28, + 0x78, 0xDB, 0x6A, 0xC9, 0x1E, 0xE5, 0x05, 0xEA + }, + { + 0x80, 0x0C, 0x0D, 0x64, 0x40, 0xEF, 0x90, 0x32, + 0x85, 0x4D, 0x81, 0x4F, 0x28, 0x82, 0x6C, 0x94, + 0x99, 0x86, 0x3A, 0x46, 0x84, 0xCC, 0x7F, 0x3A, + 0x1F, 0x2E, 0x5A, 0x90, 0x16, 0x10, 0xB8, 0xB0, + 0x00, 0xFB, 0xE0, 0xEE, 0xFE, 0x0F, 0x37, 0x2E, + 0x5E, 0x7A, 0x1A, 0xC0, 0x0E, 0x9B, 0x0D, 0x7E, + 0xD7, 0xE6, 0x06, 0x9C, 0x0C, 0x9E, 0x90, 0x8E, + 0x4C, 0xDF, 0xCF, 0x2F, 0x44, 0x03, 0x43, 0x7A + }, + { + 0xB5, 0x2E, 0xC1, 0x6A, 0x52, 0xA0, 0x43, 0xF3, + 0x3E, 0xF6, 0x7E, 0x9D, 0x23, 0x71, 0x7C, 0xB8, + 0xCC, 0xF6, 0xA0, 0x62, 0x7B, 0xFD, 0x84, 0x78, + 0x8E, 0xD4, 0x9D, 0xC2, 0x14, 0x8C, 0x9C, 0xDA, + 0x7E, 0xF0, 0x96, 0x4E, 0xB7, 0x2D, 0x15, 0xA4, + 0x91, 0x05, 0xB4, 0x04, 0x70, 0xDB, 0xE7, 0x4B, + 0x3F, 0x49, 0xD8, 0x71, 0x29, 0x30, 0x4C, 0x1F, + 0x49, 0xFF, 0xB8, 0xF2, 0x2C, 0xC5, 0xAA, 0xDF + }, + { + 0x5D, 0xCD, 0x96, 0x09, 0x0C, 0x0D, 0x3D, 0x15, + 0x1C, 0xBF, 0x1A, 0x14, 0xBB, 0xE7, 0xD7, 0xAF, + 0x0C, 0xF5, 0x37, 0xC2, 0x83, 0x0B, 0x15, 0xF8, + 0x1C, 0x24, 0x86, 0xD5, 0x71, 0x68, 0x35, 0x72, + 0x7C, 0x66, 0x0F, 0x42, 0x05, 0x89, 0x57, 0x54, + 0x56, 0xA2, 0xBB, 0x05, 0x92, 0x82, 0x49, 0x3E, + 0xC5, 0x37, 0x4E, 0x10, 0x22, 0x65, 0xB2, 0xEE, + 0x2F, 0xC7, 0x33, 0x86, 0x39, 0xB1, 0xA6, 0xCF + }, + { + 0x1A, 0xF7, 0xBD, 0x94, 0x52, 0x66, 0x23, 0xA5, + 0xF9, 0xF2, 0xC2, 0x01, 0xFE, 0x35, 0xD3, 0x75, + 0x23, 0xFC, 0x6E, 0x73, 0x4B, 0x38, 0x5C, 0x8C, + 0x7B, 0x97, 0xE9, 0xE3, 0x43, 0xC3, 0x0B, 0x5B, + 0x06, 0x1C, 0xC2, 0x98, 0xD7, 0x68, 0x12, 0x30, + 0xAC, 0xAE, 0x22, 0x15, 0xB1, 0xF3, 0xBA, 0x1F, + 0x3A, 0xB9, 0x1F, 0x92, 0x26, 0x21, 0x29, 0x46, + 0x13, 0x8F, 0xA1, 0x7D, 0x16, 0xD0, 0x7A, 0xF5 + }, + { + 0x18, 0x81, 0xE0, 0xE4, 0xCF, 0x8A, 0x72, 0x37, + 0xD9, 0x19, 0x51, 0x71, 0xCE, 0xD0, 0x3F, 0x30, + 0xAE, 0x28, 0x73, 0x50, 0xB6, 0x6D, 0x01, 0x63, + 0x13, 0xB1, 0x93, 0x2C, 0xFE, 0x56, 0xF0, 0x2A, + 0x6E, 0xEB, 0x35, 0x7E, 0x0C, 0xD3, 0xA0, 0xAD, + 0xC2, 0xBA, 0xE4, 0x35, 0x31, 0x25, 0xC0, 0x55, + 0x48, 0x06, 0x1A, 0x5C, 0xA7, 0xE5, 0x66, 0xD8, + 0xF3, 0x9F, 0xEC, 0xB6, 0x83, 0xEF, 0x24, 0xAC + }, + { + 0x19, 0x16, 0xFB, 0x25, 0x61, 0x20, 0x88, 0x05, + 0x36, 0x08, 0x75, 0xB6, 0x40, 0xF2, 0xA9, 0xAE, + 0xEE, 0x4B, 0xF3, 0xCA, 0x9A, 0x33, 0xAD, 0xDB, + 0x62, 0x9E, 0x7C, 0x49, 0x2F, 0x46, 0x4E, 0x49, + 0x02, 0x1B, 0x30, 0x62, 0x99, 0xDB, 0x22, 0x65, + 0x02, 0x63, 0xA7, 0xE6, 0xCA, 0x9C, 0xF5, 0x18, + 0x71, 0xC0, 0x98, 0xC0, 0xCE, 0x5C, 0xC8, 0xD2, + 0xDF, 0x49, 0x52, 0xDF, 0x4A, 0xCE, 0x51, 0xB5 + }, + { + 0xB9, 0x5D, 0x17, 0x3F, 0x4C, 0xB6, 0x3A, 0x33, + 0xFB, 0x1E, 0x41, 0x43, 0xCE, 0x54, 0xCF, 0xA5, + 0xAA, 0xD7, 0x84, 0x25, 0xA3, 0x96, 0xB2, 0x26, + 0x78, 0x46, 0x4E, 0x2C, 0x4D, 0x18, 0x40, 0x4F, + 0xEC, 0xF1, 0x09, 0xB4, 0x8C, 0xDB, 0x2E, 0x46, + 0xBE, 0xB7, 0xC1, 0x55, 0xEA, 0x04, 0x79, 0x5B, + 0xFC, 0xA8, 0xED, 0x94, 0xD8, 0xB8, 0xBF, 0x91, + 0x40, 0xB5, 0x55, 0x03, 0x05, 0xB6, 0xC4, 0xFB + }, + { + 0xCD, 0x81, 0x94, 0x52, 0xEE, 0x7B, 0xC7, 0xE4, + 0x59, 0xBC, 0xBD, 0xD5, 0xCB, 0x70, 0x24, 0xE7, + 0x5F, 0x17, 0x6C, 0x02, 0xC1, 0x0D, 0xEB, 0xAF, + 0x6B, 0x83, 0x0A, 0xD4, 0xFE, 0x16, 0xCE, 0x27, + 0x08, 0xCB, 0xFF, 0xDF, 0x84, 0x8C, 0x3E, 0x4E, + 0x15, 0x56, 0x12, 0x2A, 0x91, 0x14, 0x5F, 0x3A, + 0xD5, 0x91, 0x2C, 0xC6, 0x6D, 0xFB, 0x12, 0x07, + 0x96, 0x70, 0x28, 0x6A, 0x31, 0x42, 0x86, 0x21 + }, + { + 0x76, 0x01, 0xE2, 0xBC, 0x61, 0x3B, 0x56, 0x38, + 0x91, 0xB7, 0xC7, 0x17, 0x93, 0xE7, 0xC3, 0x62, + 0xEA, 0x61, 0x7D, 0xDC, 0x22, 0x54, 0x62, 0x74, + 0x8E, 0xD3, 0x43, 0x99, 0x8A, 0xE1, 0x5F, 0x61, + 0xB8, 0x27, 0x2A, 0x7F, 0xC7, 0xEC, 0x57, 0xC8, + 0x13, 0x75, 0x53, 0x8F, 0x92, 0xCA, 0xE9, 0xA7, + 0x87, 0xE0, 0x4F, 0x7D, 0x59, 0x2C, 0x04, 0x1B, + 0x76, 0x87, 0xE9, 0x62, 0xB4, 0x2C, 0xBF, 0x8F + }, + { + 0x0B, 0x10, 0x00, 0xE2, 0x80, 0x02, 0x29, 0xB5, + 0xFC, 0x29, 0x90, 0x8B, 0x97, 0x12, 0xE3, 0x25, + 0xFB, 0x6F, 0xA0, 0xD9, 0xDC, 0xEA, 0x41, 0x37, + 0x39, 0x52, 0xBB, 0xA1, 0x4C, 0x42, 0x4A, 0x1F, + 0x47, 0x91, 0xDB, 0x8E, 0xB3, 0x39, 0x68, 0xF9, + 0xD1, 0x7B, 0x33, 0x96, 0xF9, 0x5C, 0x48, 0x1D, + 0xE0, 0x89, 0x54, 0x0F, 0xAB, 0xAC, 0x56, 0xE5, + 0x8C, 0xFC, 0x7A, 0xCA, 0xA3, 0x18, 0x0A, 0xA4 + }, + { + 0x1C, 0x21, 0xBD, 0x7B, 0xAF, 0x43, 0xF2, 0x37, + 0x43, 0xE1, 0x36, 0xB2, 0xA6, 0x17, 0x7B, 0x0E, + 0x63, 0xD4, 0x6D, 0xED, 0x29, 0x64, 0xE7, 0xE8, + 0xE9, 0xB7, 0x7D, 0x0D, 0xBD, 0x50, 0x88, 0x17, + 0xF5, 0xD6, 0x9E, 0xDC, 0x6E, 0xA9, 0x5F, 0x0F, + 0x65, 0x49, 0x83, 0xFA, 0x07, 0x81, 0xD2, 0x0D, + 0x5B, 0x5C, 0x05, 0x16, 0x24, 0x26, 0x50, 0x2C, + 0xA8, 0x52, 0x2E, 0xD4, 0x63, 0xAF, 0xAB, 0xC7 + }, + { + 0x84, 0xCB, 0x3C, 0xCF, 0xB9, 0xDB, 0x95, 0xF5, + 0xD3, 0xDF, 0xF5, 0x90, 0x66, 0xF9, 0x62, 0xD8, + 0xC8, 0xB4, 0x81, 0x35, 0xF4, 0xF0, 0xAE, 0x6A, + 0x8A, 0xE0, 0x4A, 0xBB, 0x51, 0x54, 0x99, 0xC8, + 0xC2, 0xB9, 0x28, 0x63, 0x77, 0xBD, 0xD2, 0xCA, + 0x0B, 0x8C, 0xA3, 0x77, 0x66, 0x35, 0x57, 0x35, + 0x04, 0xD2, 0x5B, 0x01, 0x43, 0xC8, 0xE3, 0x3F, + 0xAE, 0x9A, 0x64, 0x06, 0x92, 0x5C, 0xA8, 0x91 + }, + { + 0x89, 0x05, 0xF2, 0x23, 0xFD, 0xC1, 0x7A, 0x4B, + 0xB5, 0x2D, 0x62, 0x6D, 0x91, 0xA5, 0xF1, 0xF1, + 0x18, 0x1C, 0x51, 0x75, 0x54, 0xEE, 0x1E, 0x24, + 0xBE, 0x5A, 0xF8, 0x52, 0x20, 0xAA, 0xA7, 0x53, + 0x0C, 0x6C, 0x5A, 0xEB, 0xE6, 0xE0, 0x3E, 0x3C, + 0x3A, 0x03, 0xFA, 0xE2, 0x32, 0x9F, 0x04, 0x72, + 0xE3, 0x0C, 0x55, 0x2D, 0x18, 0x37, 0xED, 0x91, + 0x8A, 0xC8, 0xBC, 0x6E, 0x0E, 0xCB, 0xDF, 0x62 + }, + { + 0xEF, 0x60, 0xE2, 0xA5, 0xDC, 0x95, 0xF7, 0x72, + 0x2A, 0x01, 0x19, 0xF7, 0xFC, 0x24, 0xE3, 0xEC, + 0xAB, 0x0B, 0xC8, 0x52, 0x9F, 0x6D, 0x80, 0x1A, + 0xC5, 0xA6, 0xD3, 0x74, 0x53, 0x43, 0xBE, 0x35, + 0x8A, 0xCC, 0x4F, 0xAE, 0x36, 0xAF, 0x71, 0x5B, + 0xF2, 0xAC, 0x3D, 0xC3, 0x54, 0xB0, 0x01, 0x85, + 0x70, 0x59, 0x66, 0xB7, 0x65, 0x79, 0x92, 0x7F, + 0x71, 0xD7, 0xBD, 0xF1, 0xEA, 0xBF, 0xFA, 0x37 + }, + { + 0x21, 0xE4, 0x24, 0xAB, 0x34, 0x6D, 0x4C, 0x28, + 0x70, 0x4C, 0xE4, 0x27, 0xD6, 0x2F, 0xF9, 0xB5, + 0x84, 0x45, 0x66, 0xF9, 0x70, 0x0C, 0xC0, 0x3D, + 0x48, 0x81, 0x40, 0xC3, 0x2F, 0xEA, 0xE8, 0xC2, + 0x32, 0xDD, 0x53, 0x44, 0x9E, 0x8F, 0x79, 0x40, + 0x7F, 0xBA, 0x40, 0x63, 0xFC, 0xFE, 0x49, 0xC2, + 0xF3, 0x55, 0x84, 0xED, 0x26, 0xA5, 0x4C, 0x48, + 0x90, 0x7C, 0xCB, 0x10, 0x00, 0xF0, 0x1C, 0x5E + }, + { + 0x1E, 0xA0, 0x5D, 0x1A, 0x79, 0x4E, 0x10, 0x5F, + 0xEE, 0x46, 0x20, 0x16, 0x6D, 0x10, 0x5F, 0xF9, + 0x2C, 0x9E, 0x28, 0x76, 0x7D, 0x83, 0x01, 0xAD, + 0xC4, 0x46, 0xF8, 0xEF, 0x9A, 0xFD, 0x42, 0xEB, + 0xBA, 0xD9, 0x0D, 0xCE, 0x9E, 0x7A, 0x2C, 0x74, + 0x8E, 0xEB, 0x9D, 0x71, 0x5D, 0xED, 0x3E, 0x0D, + 0x3C, 0x69, 0xAA, 0xC9, 0xEE, 0x04, 0xEC, 0xDD, + 0x28, 0xF7, 0xE5, 0xE4, 0x7B, 0xC1, 0xB8, 0x40 + }, + { + 0xB5, 0x4B, 0x22, 0xE9, 0x58, 0xC2, 0xD0, 0xCB, + 0x42, 0x3B, 0x99, 0xEB, 0x82, 0x6D, 0xE4, 0x18, + 0x0E, 0x3B, 0xB3, 0x8F, 0x29, 0x89, 0xE2, 0x0C, + 0x03, 0x9A, 0x07, 0xE0, 0xFD, 0xD7, 0x3B, 0x4D, + 0xDB, 0xD1, 0xDB, 0xA7, 0x00, 0x6D, 0x7E, 0x68, + 0x44, 0x82, 0x18, 0xD9, 0x81, 0x2F, 0xC0, 0xBE, + 0xFD, 0xE8, 0xF2, 0x3F, 0xD8, 0x93, 0xB9, 0x27, + 0x1E, 0x1D, 0xC9, 0x13, 0xF0, 0x34, 0xF5, 0x2A + }, + { + 0x09, 0x42, 0x84, 0xFD, 0xD3, 0xE6, 0x7B, 0xB0, + 0xF9, 0x72, 0x06, 0x9E, 0x0E, 0x93, 0x53, 0x07, + 0xB2, 0x87, 0xA1, 0x6F, 0x92, 0x2B, 0x55, 0xDA, + 0xB7, 0x3E, 0x4D, 0x4C, 0xE2, 0xC5, 0x36, 0xA7, + 0x63, 0xDB, 0x79, 0xE9, 0x1D, 0x5E, 0x38, 0xD0, + 0xDA, 0x34, 0x3D, 0xD9, 0x55, 0xA4, 0x6B, 0xFF, + 0xBC, 0xEE, 0xC1, 0xE3, 0x9B, 0x1C, 0x93, 0x8A, + 0x47, 0xE9, 0x93, 0xA7, 0x2A, 0xA7, 0x32, 0x32 + }, + { + 0xDB, 0x84, 0x51, 0x1A, 0x34, 0x93, 0x0E, 0x81, + 0x2A, 0x6C, 0xE4, 0x79, 0x9E, 0x3F, 0x2F, 0x6A, + 0x2A, 0xA4, 0xB0, 0x74, 0xBE, 0xF5, 0x5C, 0x93, + 0x32, 0xAF, 0x1C, 0x25, 0xE0, 0x65, 0xF6, 0x63, + 0xB5, 0x0D, 0x9F, 0x27, 0x98, 0xB5, 0xAA, 0xAF, + 0x0E, 0xB0, 0xAC, 0x0D, 0xFE, 0x7D, 0x4B, 0x72, + 0x69, 0x2C, 0x54, 0xED, 0x87, 0x78, 0xE6, 0x30, + 0x47, 0x9E, 0x2B, 0xEF, 0x6D, 0x6E, 0xD1, 0x39 + }, + { + 0x4D, 0xD2, 0x8C, 0x83, 0x7F, 0x20, 0xB9, 0x88, + 0xB7, 0x5B, 0x0E, 0x52, 0x5E, 0xDA, 0x2C, 0xED, + 0x7C, 0x30, 0x14, 0x72, 0x2D, 0x31, 0x99, 0xC3, + 0xF2, 0xA7, 0x25, 0x82, 0xB3, 0x46, 0x39, 0xB9, + 0x3F, 0x15, 0x60, 0x1C, 0x14, 0x7E, 0xEE, 0x1D, + 0x0F, 0x52, 0x29, 0xEE, 0x7D, 0x6B, 0x9A, 0x6A, + 0xF7, 0x8D, 0x20, 0x5A, 0xE3, 0xB8, 0x1E, 0x97, + 0x8F, 0xEE, 0x46, 0x13, 0x4B, 0xDD, 0xE7, 0x4A + }, + { + 0x69, 0x9F, 0xC0, 0x24, 0x92, 0xB4, 0xA5, 0x47, + 0x4E, 0xE6, 0x81, 0xC9, 0xDB, 0x2F, 0x56, 0x1C, + 0xB0, 0x19, 0x01, 0xD1, 0x8A, 0xEB, 0xCA, 0xB8, + 0x9A, 0xC2, 0x0F, 0x04, 0x8E, 0x63, 0x61, 0xE9, + 0xEB, 0x2F, 0xB0, 0x4E, 0x40, 0x9C, 0x7E, 0xE7, + 0x4E, 0xCE, 0x16, 0x0D, 0xF8, 0x99, 0xD2, 0x28, + 0x89, 0xC1, 0xA0, 0xA5, 0x77, 0x87, 0xA2, 0xE4, + 0x7D, 0x56, 0x2D, 0xB4, 0x0D, 0x96, 0xB9, 0xBF + }, + { + 0xFF, 0xE8, 0x72, 0xFC, 0xFF, 0xE7, 0x8D, 0x7D, + 0x95, 0xE7, 0x0A, 0xBB, 0x8A, 0x5E, 0x62, 0x66, + 0xEA, 0x9F, 0xEE, 0xC5, 0x50, 0x34, 0xC7, 0x6F, + 0x8B, 0x25, 0x17, 0x6F, 0x5B, 0xD4, 0xEB, 0xDB, + 0xFE, 0xCA, 0x08, 0x68, 0x09, 0xE1, 0x15, 0x52, + 0xFF, 0xC8, 0x6C, 0x1F, 0x2B, 0x90, 0xBE, 0x65, + 0x12, 0x26, 0xB7, 0xF1, 0x8F, 0x38, 0xF9, 0x84, + 0x64, 0x68, 0x50, 0x97, 0xDF, 0x2D, 0x16, 0xC1 + }, + { + 0xC5, 0xAA, 0xB2, 0xD8, 0x72, 0x32, 0x95, 0x19, + 0x01, 0x1B, 0x08, 0x66, 0x4C, 0xA1, 0x69, 0xB6, + 0xCB, 0x54, 0x0E, 0xDE, 0x39, 0x68, 0x02, 0xAC, + 0xDA, 0x89, 0x8E, 0x6A, 0x53, 0x96, 0xE7, 0x48, + 0x9B, 0x4E, 0x6E, 0xD0, 0xBF, 0x6E, 0xD0, 0x6B, + 0xFD, 0xC8, 0x30, 0x44, 0x23, 0xD9, 0xA7, 0xBB, + 0x33, 0xF1, 0x02, 0x45, 0x43, 0x5F, 0x9C, 0x4B, + 0xE6, 0x08, 0x28, 0x8C, 0xDC, 0xD4, 0x34, 0xB7 + }, + { + 0x7C, 0x11, 0xCD, 0xE0, 0x03, 0x53, 0x83, 0x75, + 0xB8, 0x24, 0xD7, 0xB8, 0x9A, 0x3D, 0x19, 0xAD, + 0x85, 0x7A, 0x6E, 0x07, 0x41, 0xB8, 0x08, 0x77, + 0xCE, 0xF8, 0xD8, 0x6B, 0x28, 0xD2, 0x23, 0x25, + 0xD8, 0x5E, 0xE3, 0x4B, 0x3D, 0x63, 0xB7, 0xAF, + 0xEE, 0xBB, 0xE4, 0x81, 0xB4, 0x41, 0x6C, 0x84, + 0xC4, 0xA2, 0x6E, 0x1B, 0x75, 0xC4, 0xD9, 0x54, + 0xE5, 0x6F, 0xAB, 0x9B, 0x95, 0xDA, 0x0C, 0x0E + }, + { + 0x88, 0x85, 0xCA, 0x59, 0x01, 0x9D, 0xF9, 0x25, + 0x9D, 0x60, 0xFF, 0xC7, 0x2A, 0x8C, 0x8B, 0x37, + 0x53, 0x79, 0xFF, 0x4D, 0xF8, 0x2B, 0xF5, 0x6B, + 0xC0, 0x47, 0xE5, 0xB6, 0x1F, 0x8A, 0x16, 0x95, + 0x29, 0x11, 0xC0, 0x91, 0xD0, 0xF8, 0xF3, 0x38, + 0xC0, 0xE4, 0x24, 0xA7, 0x9D, 0xCA, 0xEC, 0x58, + 0xEE, 0x5E, 0x6C, 0x59, 0x21, 0xD5, 0x72, 0x2A, + 0x77, 0x33, 0xA0, 0xCF, 0xE5, 0xDF, 0xA3, 0xAE + }, + { + 0xBE, 0xED, 0x85, 0x82, 0xE2, 0xE0, 0x63, 0xF8, + 0xA7, 0xED, 0xD4, 0xC7, 0x66, 0xCE, 0x38, 0x31, + 0xDC, 0xA3, 0x51, 0xA4, 0xF9, 0xB5, 0x75, 0x94, + 0xCA, 0x43, 0xD1, 0x3B, 0x2E, 0x7D, 0x3A, 0xFB, + 0x6C, 0x18, 0x5E, 0x17, 0x9B, 0xB0, 0xFC, 0x7B, + 0xE1, 0xB0, 0x23, 0x66, 0x94, 0xC4, 0xA4, 0x26, + 0x18, 0xAF, 0x2E, 0x72, 0x16, 0xF3, 0x41, 0x7D, + 0x32, 0x63, 0xB2, 0xDF, 0x7D, 0x9A, 0xA4, 0xBA + }, + { + 0x8D, 0x19, 0xCB, 0xCC, 0x19, 0xEC, 0x53, 0x2D, + 0xDD, 0xCB, 0x00, 0xEA, 0x22, 0x96, 0xC2, 0x2A, + 0x3E, 0x4B, 0xEA, 0x3D, 0xF5, 0xA3, 0x4D, 0xD9, + 0x36, 0x2E, 0x93, 0x05, 0x7F, 0x68, 0xD6, 0x8A, + 0x7A, 0xD2, 0xC9, 0xEE, 0xEF, 0x6C, 0x2B, 0x6B, + 0x27, 0xEC, 0x66, 0x7F, 0xAB, 0x78, 0xEA, 0x2B, + 0xFC, 0x1E, 0x67, 0xA3, 0x90, 0x05, 0x59, 0x75, + 0xAA, 0x5B, 0x97, 0x06, 0xE9, 0x76, 0x35, 0x33 + }, + { + 0x25, 0x62, 0xAC, 0x79, 0x32, 0x90, 0x3F, 0xC9, + 0x51, 0xFC, 0x45, 0xF3, 0xBC, 0x23, 0xCE, 0xF2, + 0x37, 0x9F, 0x87, 0xA3, 0x9D, 0xB4, 0xFF, 0xC1, + 0x7E, 0x65, 0x5A, 0x81, 0x15, 0x7E, 0x93, 0x9E, + 0xEA, 0xED, 0x92, 0xBF, 0x75, 0x05, 0x4C, 0x71, + 0xDA, 0x29, 0x39, 0x46, 0x84, 0x76, 0x95, 0xA4, + 0x95, 0x43, 0x08, 0x42, 0x0D, 0xE8, 0x46, 0xCA, + 0xCB, 0x41, 0x85, 0x8A, 0x4B, 0x6A, 0x3F, 0xFA + }, + { + 0xEF, 0x23, 0x24, 0x5D, 0x92, 0xF9, 0xF2, 0xE3, + 0xB6, 0x91, 0x31, 0x4F, 0x87, 0x1F, 0x4F, 0x4E, + 0xC4, 0x05, 0x7E, 0xF3, 0xD0, 0xD2, 0xFB, 0x2A, + 0xBE, 0x95, 0x9C, 0x7A, 0x3B, 0x06, 0xF3, 0x49, + 0x5B, 0x12, 0xF3, 0x15, 0xB0, 0x91, 0xEE, 0xBC, + 0x6A, 0x7A, 0xA9, 0x3C, 0x84, 0xA1, 0x2F, 0x58, + 0x31, 0x36, 0x4E, 0x00, 0xB5, 0x58, 0x11, 0xB8, + 0xBA, 0x78, 0x4F, 0xC5, 0xED, 0xF1, 0x09, 0x8D + }, + { + 0x7F, 0xCC, 0xD2, 0x3E, 0xF8, 0xF9, 0xD6, 0x38, + 0xD5, 0x8A, 0x91, 0xE0, 0xAE, 0xA7, 0x28, 0x4B, + 0x36, 0xFA, 0xF7, 0x2D, 0x2B, 0x83, 0x45, 0xC2, + 0x3E, 0x7A, 0xAE, 0x72, 0x72, 0x36, 0x48, 0x7B, + 0xE0, 0xF6, 0xAE, 0x39, 0xDA, 0x91, 0xFF, 0xF4, + 0x2C, 0x08, 0x4F, 0xA5, 0x29, 0xC1, 0x13, 0x9D, + 0x5B, 0x40, 0xE3, 0x7C, 0x52, 0x25, 0x66, 0x4A, + 0x21, 0x85, 0xC5, 0x11, 0x26, 0x03, 0x77, 0x10 + }, + { + 0x3F, 0xC8, 0x32, 0x73, 0x78, 0xA4, 0x29, 0x6F, + 0x22, 0x62, 0x65, 0x3F, 0xB8, 0x41, 0x7E, 0x82, + 0x03, 0x7A, 0xA8, 0x68, 0x54, 0xE7, 0xBE, 0x0F, + 0xFC, 0x89, 0x55, 0x4A, 0x80, 0xF7, 0x7D, 0x16, + 0x76, 0xB1, 0x8C, 0x7E, 0xE5, 0x35, 0x1F, 0x41, + 0x65, 0xC6, 0x67, 0x60, 0xBF, 0x5C, 0x8D, 0xBD, + 0x11, 0xBB, 0x5E, 0xB7, 0x1A, 0xDE, 0x40, 0x61, + 0xBF, 0xF3, 0x49, 0x71, 0x64, 0xDE, 0x5E, 0xE4 + }, + { + 0xC4, 0x99, 0x0E, 0x98, 0x3C, 0x59, 0x54, 0xB7, + 0x4C, 0xA0, 0xFE, 0xC3, 0x0C, 0x45, 0x06, 0xA0, + 0x7F, 0x7F, 0x61, 0xC5, 0xBB, 0xB4, 0x2A, 0x2F, + 0x9A, 0x00, 0xAD, 0xE3, 0x8A, 0x0C, 0x46, 0x80, + 0x10, 0xC3, 0xF5, 0xDE, 0x3A, 0xE3, 0xE4, 0x0E, + 0x17, 0x20, 0x62, 0x42, 0x46, 0xF0, 0xFF, 0x34, + 0x27, 0xC2, 0x11, 0xD9, 0xF0, 0x0B, 0x47, 0x2E, + 0xBC, 0x40, 0xAA, 0x0C, 0x5F, 0x34, 0xD4, 0x69 + }, + { + 0xDC, 0x07, 0x25, 0x8D, 0xD7, 0x99, 0xFF, 0xC6, + 0x2C, 0xDD, 0x8F, 0x86, 0xCD, 0xAC, 0x87, 0xF8, + 0xAD, 0x38, 0x3E, 0xDF, 0x3D, 0xC5, 0x5A, 0x35, + 0xB6, 0xDC, 0x73, 0xA0, 0xBA, 0x3D, 0xE8, 0x64, + 0x16, 0x6B, 0xBB, 0x8A, 0x67, 0x42, 0xBD, 0x72, + 0x10, 0xE1, 0x9A, 0xF8, 0xB8, 0x9D, 0x89, 0x5F, + 0x3A, 0x2B, 0xEA, 0xC4, 0xDC, 0xB8, 0x1C, 0xFB, + 0x1B, 0x03, 0xD7, 0x33, 0xCF, 0x7C, 0x29, 0x07 + }, + { + 0x49, 0x21, 0xB5, 0xCA, 0xFA, 0x3E, 0x60, 0x57, + 0xD7, 0xE9, 0x6D, 0x52, 0x7C, 0x1C, 0xFB, 0x37, + 0x8F, 0xB0, 0x1F, 0x72, 0x1B, 0xA1, 0x01, 0xA2, + 0xF3, 0xE2, 0x75, 0xE8, 0xC2, 0x89, 0xB4, 0x48, + 0x6A, 0xE3, 0xA2, 0x35, 0xB5, 0x1A, 0x2D, 0x29, + 0xC9, 0x7B, 0x47, 0xDE, 0xAC, 0x74, 0x82, 0xBB, + 0xDC, 0x96, 0x2F, 0x81, 0x31, 0xEE, 0xD5, 0xC8, + 0xFE, 0xF1, 0x53, 0xD7, 0xAA, 0x4A, 0xC2, 0xCD + }, + { + 0x1A, 0xA7, 0x75, 0x6B, 0x7B, 0xBE, 0x4E, 0xBB, + 0xDB, 0x83, 0x16, 0x04, 0x59, 0x46, 0x3F, 0xAE, + 0x00, 0xBC, 0xE1, 0xC9, 0xE3, 0x44, 0xFC, 0xBF, + 0x27, 0x6F, 0x98, 0x8B, 0x78, 0x23, 0x53, 0xA2, + 0x3A, 0x3E, 0x7B, 0xD7, 0xFF, 0xDF, 0xFC, 0x1F, + 0x7B, 0xB7, 0xA8, 0xC6, 0xAC, 0x4A, 0x0F, 0xE7, + 0x51, 0xD0, 0x23, 0x7B, 0x1D, 0xA6, 0xCF, 0x70, + 0xF3, 0x12, 0x35, 0xC0, 0x50, 0x15, 0x6C, 0x16 + }, + { + 0xEA, 0xD8, 0xB8, 0x6F, 0xCB, 0x02, 0x4A, 0xA1, + 0x79, 0x12, 0x0E, 0x48, 0x40, 0x5F, 0xC3, 0xE0, + 0x51, 0xBA, 0x93, 0x2E, 0xD7, 0x4C, 0xF7, 0xE5, + 0x33, 0x11, 0x52, 0x26, 0x5F, 0x2D, 0xE4, 0xDD, + 0xF7, 0xF6, 0xAB, 0xCC, 0x3F, 0xF4, 0x61, 0x80, + 0xA9, 0x38, 0x94, 0xE6, 0x65, 0xED, 0xC1, 0x79, + 0xC6, 0xA8, 0x00, 0xAC, 0xC7, 0xE4, 0xD0, 0x09, + 0xA5, 0x25, 0x58, 0x9E, 0x32, 0x5D, 0x01, 0xE4 + }, + { + 0xAC, 0xF4, 0xF8, 0x33, 0x14, 0x4D, 0x2A, 0xAC, + 0x08, 0xF4, 0x0F, 0xE8, 0xFC, 0xFF, 0xE7, 0xD9, + 0xF4, 0xF0, 0x74, 0x73, 0x7B, 0x2A, 0x77, 0x20, + 0x66, 0xA7, 0xFD, 0x67, 0xB1, 0x79, 0x5C, 0x4D, + 0x75, 0x10, 0xC2, 0xB3, 0xEB, 0xD5, 0x1D, 0xCE, + 0xE3, 0xED, 0x8D, 0x4B, 0x56, 0x15, 0x1A, 0x39, + 0xB4, 0x0D, 0x02, 0x28, 0x0B, 0xD2, 0xA8, 0x47, + 0xA4, 0x2D, 0x28, 0x99, 0x85, 0x08, 0x62, 0x92 + }, + { + 0xE5, 0x05, 0x2B, 0x35, 0x8D, 0xA6, 0x15, 0xF8, + 0xBA, 0x01, 0xD2, 0xC1, 0xC7, 0xA3, 0xF1, 0x0F, + 0x8A, 0x62, 0x02, 0x71, 0x2B, 0x2D, 0xD3, 0x34, + 0xB2, 0x76, 0x62, 0x6B, 0xDA, 0x0B, 0x6B, 0x71, + 0x0A, 0x58, 0x3A, 0xF1, 0xB1, 0x94, 0x6C, 0xFA, + 0x99, 0x53, 0x65, 0xDE, 0xEE, 0x75, 0x96, 0xF9, + 0xD6, 0x9B, 0xA2, 0xD7, 0x38, 0xB3, 0xD4, 0x01, + 0xF7, 0xE4, 0xDE, 0x3A, 0x51, 0x48, 0x7B, 0x4F + }, + { + 0x63, 0x35, 0xD5, 0x40, 0xED, 0x38, 0x4B, 0x20, + 0xDA, 0x7D, 0xF0, 0xD1, 0x07, 0xAD, 0xD0, 0x43, + 0x0E, 0xC9, 0xBE, 0xC4, 0x21, 0x92, 0xBD, 0x15, + 0xE2, 0xB5, 0xEA, 0x75, 0xE5, 0x4B, 0xA8, 0xB5, + 0xA3, 0xA4, 0x08, 0x46, 0x3A, 0x6B, 0x57, 0x03, + 0xA8, 0xA3, 0x63, 0x49, 0xD0, 0xA3, 0xFE, 0x9E, + 0x8E, 0x81, 0x46, 0xC8, 0x82, 0x72, 0x31, 0x57, + 0xEB, 0x52, 0x75, 0x7A, 0xEB, 0x64, 0xA8, 0x54 + }, + { + 0x5B, 0x08, 0x20, 0x88, 0x90, 0x5D, 0x01, 0x8C, + 0x98, 0xA5, 0x6B, 0x9D, 0x74, 0x11, 0xEA, 0xCF, + 0xE0, 0xAD, 0x0B, 0x04, 0x44, 0x70, 0x11, 0x25, + 0xDB, 0x2E, 0x8F, 0x85, 0x4F, 0xE2, 0xB2, 0x92, + 0x5B, 0xD8, 0xE4, 0x2F, 0x7F, 0x73, 0x84, 0x1D, + 0x42, 0x9C, 0x56, 0x62, 0xB6, 0xC2, 0xBA, 0x82, + 0x56, 0x0D, 0xF1, 0xA5, 0xDF, 0xA9, 0x32, 0xCB, + 0x23, 0x00, 0xD2, 0x78, 0x85, 0xD5, 0x18, 0x97 + }, + { + 0xF1, 0xF1, 0xA8, 0xF8, 0x09, 0x00, 0xA9, 0xC8, + 0x17, 0x93, 0x4E, 0xC4, 0x56, 0xB5, 0xE2, 0x96, + 0xC6, 0x4E, 0xC3, 0x6C, 0xE8, 0x6F, 0xE3, 0xB1, + 0x9D, 0xC7, 0x7B, 0x62, 0xD1, 0xDA, 0xB0, 0x21, + 0x83, 0xBA, 0x9F, 0x89, 0x4E, 0xE0, 0x41, 0x56, + 0x80, 0x8B, 0x88, 0xD7, 0x24, 0x0E, 0xAD, 0x1A, + 0x4E, 0x42, 0x19, 0x13, 0x8B, 0x70, 0x94, 0x47, + 0x05, 0x80, 0x7D, 0x34, 0xDB, 0x0F, 0xD7, 0xA1 + }, + { + 0xE3, 0xF0, 0xB3, 0x36, 0x67, 0x9C, 0x54, 0xB6, + 0xCC, 0xF6, 0xCC, 0x8A, 0x55, 0xFF, 0x4D, 0x08, + 0x7D, 0x8C, 0xE6, 0xF7, 0x8C, 0x7E, 0xA6, 0xEF, + 0x25, 0xA3, 0x75, 0x7C, 0xA0, 0x04, 0x5D, 0xBA, + 0xFE, 0xC2, 0x4B, 0x3E, 0x6A, 0x6F, 0xE0, 0xAB, + 0xEB, 0xF3, 0x29, 0xA1, 0xB2, 0x94, 0x87, 0x96, + 0xE4, 0x01, 0x42, 0x01, 0xE9, 0x03, 0x46, 0xAE, + 0xC7, 0x19, 0xEC, 0xCF, 0x17, 0x5E, 0x7B, 0xDB + }, + { + 0xAE, 0x87, 0xE8, 0xE5, 0x73, 0x86, 0x6B, 0x8B, + 0xFA, 0x91, 0xB8, 0x6B, 0x3C, 0xCC, 0xA3, 0xA8, + 0x3E, 0x07, 0xC9, 0x05, 0x12, 0xDE, 0x6B, 0x38, + 0xCB, 0xE0, 0x99, 0xD4, 0x04, 0xC9, 0x77, 0x2D, + 0x09, 0xCF, 0x04, 0x86, 0x15, 0x43, 0x2D, 0x7F, + 0x19, 0x08, 0xD4, 0xC7, 0xA6, 0x2A, 0x69, 0x28, + 0xFD, 0xD0, 0x7D, 0x36, 0xB5, 0x0B, 0xEA, 0x37, + 0x2B, 0x89, 0x26, 0xBA, 0x00, 0xD2, 0x76, 0x7B + }, + { + 0x1F, 0x5A, 0x00, 0xD7, 0xC5, 0x57, 0xBA, 0x3D, + 0xC1, 0xF0, 0x65, 0xAA, 0x23, 0x94, 0xBC, 0x58, + 0x04, 0xFC, 0x24, 0xB3, 0xB6, 0xCC, 0xF6, 0x19, + 0x07, 0xD5, 0x38, 0xC1, 0x0F, 0x54, 0x4D, 0xA4, + 0x3E, 0x34, 0xD7, 0x1A, 0xD5, 0xE9, 0x35, 0x90, + 0xDB, 0xFA, 0x02, 0x24, 0x2E, 0xD2, 0xE7, 0x93, + 0xDF, 0x8D, 0x17, 0x4C, 0x60, 0x65, 0xED, 0x30, + 0x89, 0x86, 0xED, 0x92, 0xFC, 0xC7, 0x3E, 0x22 + }, + { + 0x27, 0x87, 0x88, 0x8A, 0xD3, 0x28, 0xEC, 0x1F, + 0x72, 0x80, 0x86, 0xFF, 0x94, 0x43, 0x73, 0xFD, + 0x74, 0xE0, 0x55, 0x50, 0xE9, 0x97, 0xDC, 0x1E, + 0xD9, 0x24, 0xB1, 0x0E, 0x69, 0xBE, 0xAD, 0x3E, + 0x8F, 0xAC, 0x70, 0x60, 0xBE, 0xF0, 0xB5, 0xE7, + 0xFF, 0xD0, 0x3B, 0xE2, 0x8A, 0xBE, 0xC4, 0x97, + 0x09, 0x0D, 0xB5, 0x61, 0x1F, 0x17, 0x52, 0xEB, + 0x19, 0x28, 0x4A, 0x71, 0x3B, 0x11, 0x1D, 0x95 + }, + { + 0x8B, 0xAA, 0xC0, 0xE4, 0x2E, 0x66, 0x0F, 0x65, + 0x0C, 0x3C, 0x9A, 0xE5, 0x0E, 0x42, 0x52, 0xC4, + 0xA8, 0x4D, 0x62, 0xC5, 0x9B, 0x25, 0xF2, 0x3A, + 0x42, 0x95, 0xD0, 0x28, 0xCA, 0x7D, 0x75, 0xBE, + 0xF4, 0xCA, 0x98, 0x63, 0x12, 0x37, 0x23, 0x58, + 0x3A, 0xB3, 0x5C, 0xA1, 0x45, 0x62, 0xB9, 0x02, + 0x22, 0x46, 0x77, 0x25, 0x19, 0xA2, 0xD6, 0x52, + 0xAF, 0x45, 0x41, 0xCC, 0xC0, 0xD6, 0xAD, 0x91 + }, + { + 0x43, 0x32, 0xC4, 0x0C, 0x4D, 0x77, 0x07, 0x49, + 0xA6, 0xAA, 0x70, 0x0A, 0x16, 0x97, 0xAE, 0xDB, + 0x5A, 0xAB, 0x85, 0x85, 0x94, 0xA2, 0xC6, 0x3C, + 0x65, 0x99, 0xFB, 0x8E, 0xF8, 0x95, 0x4A, 0x11, + 0xF5, 0x8D, 0xA1, 0xAB, 0x8D, 0xEE, 0xEF, 0x2E, + 0x83, 0x35, 0xDB, 0x33, 0x4D, 0x1B, 0x7D, 0x42, + 0x7D, 0x3C, 0xFF, 0xFC, 0x76, 0x58, 0xC4, 0x15, + 0x75, 0x25, 0xB9, 0xBD, 0x1D, 0x42, 0x36, 0x28 + }, + { + 0xF9, 0x2F, 0x5C, 0x22, 0xEC, 0x8A, 0xDF, 0xA1, + 0xA1, 0xA6, 0x3D, 0x53, 0xFA, 0x08, 0x50, 0xC3, + 0xD7, 0x29, 0x6C, 0xF0, 0x90, 0xC5, 0x76, 0x2D, + 0x36, 0x08, 0xFA, 0xAD, 0xBA, 0x9A, 0xE7, 0x34, + 0xAC, 0x68, 0x15, 0xD9, 0x8F, 0x6E, 0xD8, 0x98, + 0x91, 0x9B, 0x19, 0x24, 0xB8, 0x32, 0x33, 0x8A, + 0xB5, 0xE4, 0xB1, 0x0F, 0x9E, 0xC7, 0xBF, 0x23, + 0x92, 0xBC, 0x92, 0x94, 0xDA, 0xBC, 0x84, 0x10 + }, + { + 0x10, 0x6F, 0x74, 0x82, 0xCD, 0x4E, 0x5C, 0xAC, + 0x1F, 0x37, 0x40, 0x06, 0xA3, 0x1E, 0x8F, 0x02, + 0xD8, 0x91, 0x6E, 0x04, 0x92, 0xF4, 0x52, 0xED, + 0xE7, 0x91, 0x01, 0x41, 0x49, 0xB4, 0x9F, 0x16, + 0x63, 0xEA, 0xF2, 0xF5, 0xAB, 0x2A, 0x79, 0xF1, + 0xA1, 0xBB, 0xC3, 0x2C, 0xAD, 0x40, 0xC5, 0xF9, + 0xA6, 0x0E, 0xC4, 0xCB, 0x3F, 0x25, 0x2A, 0x0C, + 0xC9, 0x2F, 0x0D, 0x14, 0x91, 0xBA, 0x68, 0xCE + }, + { + 0xDA, 0x7C, 0x54, 0x46, 0x29, 0x89, 0xA5, 0xA8, + 0x3A, 0x25, 0xBE, 0x6D, 0x94, 0xD1, 0xF1, 0x5C, + 0xD5, 0x9F, 0x3A, 0x78, 0x5D, 0x00, 0x0B, 0x6D, + 0xAB, 0xB4, 0x10, 0xE8, 0x71, 0xA4, 0x16, 0xA1, + 0xB7, 0xA1, 0x94, 0x5B, 0x4D, 0x80, 0x98, 0x59, + 0xA8, 0x8F, 0x1F, 0x5F, 0x9E, 0xA1, 0xDB, 0x72, + 0xFD, 0x3A, 0x86, 0x56, 0x61, 0x42, 0x38, 0xF7, + 0xC7, 0x1B, 0xAB, 0xA7, 0xA1, 0xE1, 0x68, 0x2A + }, + { + 0x15, 0xD3, 0x98, 0x21, 0x93, 0xAB, 0x5A, 0xB9, + 0x78, 0x39, 0x00, 0xD7, 0x52, 0x22, 0x95, 0xB2, + 0xF7, 0xBA, 0xE8, 0x3B, 0x68, 0x2F, 0xB8, 0x10, + 0x2F, 0x32, 0xED, 0x5C, 0x27, 0xCB, 0x24, 0x16, + 0x0C, 0xAF, 0xED, 0xB8, 0xD2, 0x55, 0x88, 0x72, + 0xC4, 0x3D, 0x70, 0xB5, 0x24, 0x85, 0xF0, 0x71, + 0x0D, 0x33, 0xF3, 0xEC, 0xC0, 0xFB, 0x4E, 0x63, + 0x05, 0xF9, 0xC5, 0x7C, 0x02, 0xC5, 0x68, 0xCF + }, + { + 0xCB, 0xEC, 0x29, 0xE0, 0x07, 0x57, 0x44, 0x8C, + 0x5D, 0x6E, 0x66, 0xAC, 0xA7, 0x4E, 0x30, 0x53, + 0xD4, 0x5A, 0x5C, 0xBD, 0x2D, 0xC8, 0xF7, 0x13, + 0x8E, 0x63, 0xF3, 0x45, 0x66, 0x23, 0x7D, 0xC5, + 0xAE, 0xF8, 0xD9, 0x26, 0x75, 0xE4, 0xBC, 0xD5, + 0x36, 0xE5, 0xD5, 0xEA, 0xF5, 0x0A, 0x95, 0x5D, + 0x3B, 0xC0, 0x84, 0x51, 0xBA, 0x27, 0x88, 0xDD, + 0xA0, 0x9D, 0x82, 0xB1, 0x25, 0xED, 0x97, 0xFB + }, + { + 0xC3, 0x9A, 0x48, 0x41, 0x60, 0xE3, 0xAE, 0x1F, + 0x63, 0x90, 0x66, 0x2F, 0xCF, 0x28, 0x09, 0x25, + 0x9A, 0xAE, 0x09, 0xF6, 0x68, 0x4F, 0xF8, 0xA8, + 0x7D, 0xEB, 0x5D, 0x64, 0x9A, 0xAB, 0x18, 0x0E, + 0x82, 0x72, 0x96, 0xAF, 0xBC, 0x48, 0x7E, 0x08, + 0x3C, 0xC9, 0x57, 0xE1, 0x46, 0x7E, 0xD0, 0xF4, + 0xEC, 0x38, 0x4A, 0x99, 0x4D, 0x0A, 0x8A, 0xCD, + 0x72, 0xB0, 0xB9, 0x45, 0xF1, 0xD2, 0x79, 0xB4 + }, + { + 0xD6, 0x8E, 0xC1, 0x12, 0x00, 0x4A, 0x7D, 0xFA, + 0x9B, 0x13, 0x53, 0xE8, 0xBC, 0x40, 0x60, 0x43, + 0x11, 0xE3, 0xD4, 0x2B, 0x4A, 0x70, 0x44, 0xED, + 0x44, 0x5E, 0x3F, 0x47, 0x1A, 0x92, 0xF7, 0x9A, + 0x94, 0x31, 0xC5, 0x31, 0xF6, 0x20, 0x07, 0x9E, + 0x45, 0x4B, 0x7C, 0x75, 0x82, 0xD3, 0x24, 0x54, + 0x4F, 0xDD, 0x8C, 0x93, 0x0C, 0x67, 0x6B, 0xB3, + 0xB5, 0x7C, 0x71, 0xB5, 0x51, 0xEA, 0xAC, 0x1C + }, + { + 0x7C, 0xCA, 0x1F, 0xE5, 0xE9, 0xDE, 0xA1, 0x35, + 0xC1, 0x7A, 0x25, 0x63, 0x3F, 0xAD, 0x54, 0xF8, + 0xC6, 0x82, 0x8D, 0x27, 0x15, 0xC6, 0x89, 0xA6, + 0xAC, 0xEE, 0x12, 0xFC, 0x51, 0x06, 0x14, 0x45, + 0x9E, 0xC3, 0x3B, 0x49, 0xF3, 0x79, 0x34, 0xD1, + 0x4F, 0x76, 0xDE, 0xEB, 0xF4, 0xB7, 0xC9, 0xC9, + 0x11, 0xEA, 0x09, 0x39, 0x75, 0x15, 0x1C, 0xB2, + 0xE9, 0xE6, 0xAC, 0x2D, 0xE9, 0x8C, 0xFF, 0x81 + }, + { + 0xAF, 0xBD, 0x3F, 0xB3, 0xAA, 0x9A, 0xF2, 0xDC, + 0x5F, 0xFB, 0x90, 0xCD, 0xDA, 0x29, 0x2F, 0x41, + 0x4E, 0xCC, 0x45, 0x7E, 0xAD, 0xA4, 0x64, 0x4D, + 0xFC, 0x5A, 0x47, 0x73, 0xEB, 0x97, 0x98, 0x71, + 0x18, 0x38, 0x32, 0x7B, 0x55, 0x5B, 0xCD, 0x52, + 0xE3, 0x34, 0xDA, 0x5B, 0x35, 0xB3, 0xC3, 0x1A, + 0x16, 0xCA, 0x15, 0x15, 0x22, 0xE5, 0x0D, 0x97, + 0x32, 0x90, 0x31, 0xE7, 0x5D, 0x4B, 0xD1, 0x40 + }, + { + 0x04, 0xDE, 0x37, 0xF9, 0x3F, 0xF3, 0x9F, 0x27, + 0x31, 0x39, 0x69, 0xAD, 0xAD, 0xA1, 0x35, 0x06, + 0xEA, 0xBB, 0x10, 0x69, 0xF5, 0xFA, 0x23, 0x96, + 0x18, 0x16, 0xBF, 0x00, 0x61, 0x7C, 0x9D, 0x10, + 0xC5, 0xFF, 0x8D, 0x95, 0x82, 0xB4, 0xD4, 0xCB, + 0xB1, 0x12, 0x17, 0x4B, 0x67, 0x8B, 0x36, 0x9D, + 0x1B, 0xFE, 0x8B, 0x3B, 0xBA, 0xA2, 0x39, 0xC7, + 0xDA, 0x0F, 0x16, 0x7F, 0x60, 0x90, 0x09, 0x46 + }, + { + 0xD2, 0xD1, 0x02, 0x4B, 0xF5, 0xF4, 0xA0, 0x92, + 0x70, 0x6D, 0x5A, 0x3B, 0xE4, 0xEA, 0xD0, 0xDC, + 0x68, 0x65, 0x6D, 0xC9, 0x13, 0xD8, 0x0A, 0x55, + 0x4D, 0x72, 0xEE, 0x17, 0xA7, 0x72, 0x59, 0xFA, + 0xA6, 0xEF, 0x84, 0x31, 0x31, 0x1A, 0x52, 0x21, + 0x42, 0x3D, 0xB5, 0x0C, 0xAE, 0xFD, 0xFA, 0xC0, + 0x22, 0x6F, 0xDE, 0x49, 0xB4, 0xD0, 0xCB, 0x72, + 0x9D, 0x7C, 0xDC, 0x5C, 0x0D, 0x1E, 0xF7, 0x86 + }, + { + 0x89, 0xCF, 0xE5, 0x0E, 0xAE, 0x04, 0x4F, 0xF5, + 0x27, 0x5F, 0xCD, 0x80, 0xCA, 0xB0, 0x93, 0x0A, + 0x5B, 0xFC, 0xC6, 0x8D, 0xB3, 0xFA, 0x74, 0x94, + 0x93, 0xB2, 0xC0, 0x65, 0x3D, 0x73, 0xA4, 0xDC, + 0x4C, 0x41, 0x8C, 0x5A, 0x75, 0x27, 0x3F, 0x8F, + 0xE8, 0x5A, 0xDB, 0x2E, 0x56, 0xCC, 0xC3, 0x42, + 0x53, 0xBE, 0xB6, 0x28, 0x05, 0x71, 0x01, 0xA2, + 0x28, 0xF1, 0x02, 0x04, 0x99, 0x0F, 0xFA, 0xF3 + }, + { + 0xB2, 0x5E, 0xBB, 0x1C, 0xB2, 0x54, 0xA3, 0x21, + 0xE8, 0x34, 0xD2, 0x84, 0x9D, 0xE5, 0x2A, 0x6A, + 0x55, 0x30, 0x49, 0x9B, 0x76, 0x19, 0x99, 0x06, + 0xF5, 0xD8, 0x96, 0x21, 0xC3, 0x92, 0x2E, 0x23, + 0x6C, 0xED, 0x62, 0x2F, 0xC2, 0x3C, 0xFB, 0x9A, + 0x12, 0x4A, 0xEA, 0x4C, 0x82, 0x77, 0x7E, 0x08, + 0xC5, 0x53, 0x5D, 0xD9, 0xC0, 0x5F, 0x44, 0xC5, + 0xB1, 0x32, 0x24, 0x1E, 0xF5, 0xAE, 0x51, 0xAC + }, + { + 0x1D, 0xCF, 0x74, 0xB4, 0x75, 0x2A, 0x77, 0x30, + 0xB9, 0x98, 0x14, 0x4A, 0x1B, 0xE2, 0x55, 0x70, + 0xDF, 0xA7, 0xA9, 0x03, 0x09, 0xD1, 0xD8, 0x04, + 0x5F, 0x0C, 0x35, 0x8D, 0x31, 0x6F, 0x95, 0x2F, + 0x9D, 0xD7, 0x89, 0x85, 0xCB, 0x50, 0x30, 0xBC, + 0x5B, 0xEF, 0x2A, 0x1F, 0x83, 0x2F, 0xFE, 0x19, + 0xED, 0x23, 0xDF, 0x2B, 0x84, 0x72, 0xB0, 0x05, + 0xED, 0x9F, 0xF4, 0xB0, 0xF1, 0x79, 0x21, 0x38 + }, + { + 0x74, 0x43, 0x73, 0xA9, 0xFC, 0x21, 0x1C, 0x1E, + 0xC0, 0xB8, 0x98, 0x79, 0xC6, 0x08, 0xEC, 0xB5, + 0x96, 0xD1, 0x6A, 0x94, 0xB2, 0xC7, 0xB1, 0x57, + 0xD4, 0xC6, 0x78, 0x78, 0x6C, 0xDB, 0x75, 0x1B, + 0x27, 0x3E, 0x0E, 0x7B, 0x9C, 0x3B, 0xB3, 0x46, + 0x66, 0xBB, 0xBE, 0x93, 0xDB, 0xE4, 0x2D, 0x09, + 0xC1, 0x3D, 0x1D, 0xB6, 0x25, 0x8F, 0xA1, 0x8D, + 0x2D, 0xCD, 0x53, 0xB0, 0x8E, 0x98, 0xB9, 0x9B + }, + { + 0x84, 0x3D, 0xC7, 0xAF, 0x1B, 0xAA, 0xBF, 0xE6, + 0x88, 0xD6, 0xDC, 0x43, 0xBF, 0x18, 0x69, 0x54, + 0xF5, 0x6F, 0xDF, 0x58, 0x29, 0x3D, 0xE5, 0xB5, + 0x70, 0x3B, 0x04, 0x84, 0xAE, 0x2A, 0x57, 0x50, + 0x55, 0xAF, 0xEF, 0xFC, 0xEC, 0x5B, 0x47, 0x89, + 0xE1, 0x09, 0xB7, 0xE9, 0x22, 0xAA, 0x69, 0x02, + 0xBC, 0x04, 0x2F, 0x1A, 0x43, 0xA8, 0x6F, 0x02, + 0xD8, 0x05, 0x16, 0x54, 0x4E, 0xCB, 0x5B, 0x90 + }, + { + 0x09, 0x3E, 0x4C, 0x91, 0x70, 0x15, 0xF8, 0x5B, + 0x6A, 0x66, 0x4A, 0x9E, 0x0C, 0x26, 0xBA, 0x1F, + 0xB8, 0xBA, 0x1C, 0xEC, 0x90, 0x19, 0xED, 0x4C, + 0xEB, 0xEB, 0x4F, 0x1C, 0x37, 0x32, 0xEC, 0xE5, + 0x53, 0x48, 0xC6, 0x5A, 0x03, 0x0C, 0x70, 0x64, + 0x8C, 0xB3, 0x01, 0x49, 0xC3, 0x2C, 0x7D, 0xFA, + 0x01, 0xFC, 0x21, 0x30, 0x7C, 0xBD, 0xEE, 0xEB, + 0x66, 0x38, 0x9C, 0x6B, 0x0D, 0x78, 0xEA, 0x71 + }, + { + 0xEC, 0x9C, 0xAA, 0x88, 0x28, 0xE3, 0x3E, 0xFF, + 0x89, 0x5C, 0xFF, 0x53, 0x2E, 0x0F, 0x51, 0xBE, + 0xC6, 0x9D, 0xEC, 0x23, 0x2F, 0xC5, 0xAA, 0xC2, + 0x72, 0x07, 0xAA, 0x1D, 0xC4, 0xA4, 0xA6, 0x24, + 0xE9, 0x3F, 0xA2, 0xD5, 0xCF, 0x51, 0xB6, 0x3C, + 0x1E, 0xF1, 0x95, 0xD4, 0xE4, 0xB4, 0x8B, 0xCF, + 0x99, 0xED, 0xA5, 0x86, 0x6B, 0x9D, 0xE3, 0x8B, + 0x76, 0x76, 0x2B, 0xE9, 0x80, 0x2F, 0x8E, 0xE4 + }, + { + 0x83, 0x84, 0x2A, 0x74, 0x1E, 0xAB, 0x84, 0x66, + 0xDC, 0xA1, 0x69, 0xD6, 0xD0, 0xE1, 0x8D, 0x9D, + 0x69, 0x38, 0x29, 0xC4, 0xB8, 0x2A, 0x6F, 0x41, + 0xEB, 0x7C, 0x71, 0x97, 0xB6, 0x57, 0x6F, 0x1C, + 0x00, 0x2F, 0xDD, 0x1F, 0xD4, 0x23, 0x5F, 0xFA, + 0x4E, 0x87, 0x56, 0xD8, 0x7B, 0xAB, 0x75, 0x9D, + 0x93, 0x95, 0x97, 0xB8, 0x45, 0x5C, 0xE3, 0xDA, + 0xC6, 0xE0, 0xD6, 0xE8, 0xB6, 0xE5, 0x7E, 0x72 + }, + { + 0xB2, 0x9C, 0xE0, 0xF0, 0x2B, 0x2C, 0xE9, 0xD2, + 0x00, 0x8A, 0xCB, 0x82, 0x4F, 0xC9, 0x88, 0x88, + 0xB1, 0xBB, 0x6E, 0x68, 0x46, 0x07, 0x92, 0xC1, + 0x39, 0xC6, 0x38, 0xD9, 0x59, 0x8D, 0x51, 0x39, + 0xF2, 0xB5, 0xC3, 0xB2, 0x7F, 0x86, 0xEA, 0x39, + 0x35, 0xB2, 0xE1, 0x5F, 0x75, 0x7F, 0x65, 0x80, + 0x86, 0x9E, 0x73, 0xD1, 0x4A, 0x3C, 0x9C, 0x72, + 0xEF, 0xC4, 0xFD, 0xD1, 0x5A, 0x95, 0xC9, 0x6E + }, + { + 0x39, 0x03, 0x48, 0x43, 0x51, 0xDB, 0x09, 0x1F, + 0x6D, 0xF1, 0xAB, 0xE0, 0x91, 0x02, 0x95, 0x6C, + 0xC0, 0x69, 0x2E, 0x03, 0xD5, 0xE3, 0x9A, 0x1E, + 0xDC, 0xAD, 0x1C, 0xE7, 0x86, 0xF9, 0x62, 0x5B, + 0x2F, 0xC7, 0x79, 0x3B, 0x68, 0x7D, 0x15, 0x7E, + 0xAF, 0xC0, 0xB7, 0xB3, 0x36, 0x85, 0x77, 0xB6, + 0x53, 0x99, 0x2C, 0xB6, 0x6B, 0xDB, 0x7E, 0xAA, + 0x18, 0xA9, 0xB4, 0x69, 0x25, 0xDA, 0x83, 0x20 + }, + { + 0x7E, 0xA0, 0x8B, 0xD1, 0x09, 0x56, 0x23, 0xB1, + 0x85, 0xFA, 0x96, 0xFF, 0x95, 0x8F, 0x4D, 0x5E, + 0x15, 0x4D, 0xA8, 0x73, 0x9E, 0xA6, 0xF2, 0xBA, + 0x89, 0xA0, 0x33, 0x66, 0xD6, 0x84, 0xF5, 0xFF, + 0x1B, 0x52, 0x91, 0x9A, 0x5D, 0x97, 0x41, 0x98, + 0x2A, 0x05, 0xFB, 0x51, 0x71, 0x49, 0xD9, 0x99, + 0xFC, 0xF3, 0xC6, 0xAA, 0x9F, 0x60, 0x6B, 0xE7, + 0x88, 0xCF, 0x0C, 0xE2, 0xD7, 0x8E, 0x73, 0xBD + }, + { + 0x0B, 0x11, 0x96, 0x2A, 0xC5, 0xB2, 0xC0, 0x85, + 0xAF, 0x78, 0x79, 0xC0, 0x4E, 0x61, 0x38, 0xB8, + 0x43, 0x6D, 0xCF, 0x48, 0xDA, 0xB0, 0x9F, 0xBC, + 0x65, 0xB3, 0x8D, 0x5E, 0x4A, 0xBB, 0x29, 0xC9, + 0x1E, 0x41, 0x42, 0x16, 0xF3, 0x3C, 0x63, 0x0E, + 0x79, 0xC1, 0xF0, 0xBE, 0xCE, 0x54, 0x51, 0x6D, + 0x0D, 0x95, 0x27, 0xA5, 0x82, 0x10, 0xF5, 0x96, + 0xC6, 0x60, 0x05, 0xD4, 0x6F, 0x07, 0x87, 0x77 + }, + { + 0xA4, 0x01, 0x22, 0xA5, 0xC0, 0x55, 0xB2, 0x5C, + 0xBA, 0x00, 0xE8, 0xD6, 0x93, 0xAE, 0xF1, 0xD9, + 0x0B, 0x34, 0x5D, 0xD6, 0x66, 0x4F, 0x19, 0xB0, + 0xB0, 0xBC, 0x4E, 0x06, 0x47, 0x81, 0x4B, 0x20, + 0x8E, 0x7F, 0x35, 0x05, 0x68, 0x19, 0x85, 0x30, + 0x17, 0xBE, 0x7D, 0x69, 0x06, 0xD9, 0xFC, 0xC1, + 0xF0, 0x86, 0x85, 0x6F, 0xAF, 0xD5, 0xE9, 0x6D, + 0x51, 0x95, 0xDA, 0x59, 0x56, 0x1F, 0x76, 0xC7 + }, + { + 0xCD, 0x47, 0x79, 0x71, 0xE1, 0x5C, 0x81, 0x18, + 0x24, 0x9C, 0x3E, 0x22, 0x37, 0xAA, 0x4B, 0xC3, + 0x81, 0x93, 0x53, 0xE1, 0x3C, 0xDC, 0x7E, 0x69, + 0x8E, 0x5F, 0x72, 0xC1, 0x0A, 0x16, 0xC9, 0xE5, + 0x48, 0xA1, 0x7F, 0x8A, 0xB3, 0xF5, 0x1D, 0xE5, + 0x7B, 0x5C, 0x71, 0x9C, 0xDF, 0x4E, 0x3A, 0x1F, + 0x25, 0xD0, 0x9A, 0xA5, 0x2C, 0x68, 0x83, 0x6A, + 0x9F, 0xE9, 0xCA, 0x49, 0xCC, 0xDA, 0xDD, 0xEB + }, + { + 0x86, 0xF7, 0x3D, 0x76, 0x3C, 0x82, 0x90, 0xE4, + 0xCD, 0xB9, 0x35, 0x15, 0x2A, 0x49, 0x3E, 0xAE, + 0x56, 0x80, 0xE8, 0x9A, 0x99, 0xC9, 0x30, 0x62, + 0xCE, 0xAF, 0x8B, 0xC0, 0xA6, 0x72, 0x34, 0x77, + 0x4E, 0xDE, 0xA5, 0x96, 0xD2, 0x56, 0x46, 0x61, + 0xCD, 0xC7, 0x3E, 0x58, 0x87, 0x5B, 0x23, 0x3A, + 0x58, 0x8B, 0xF7, 0x2E, 0xDA, 0x08, 0x0F, 0xD0, + 0xD5, 0x9D, 0x29, 0xF1, 0xCB, 0x3A, 0xE8, 0x83 + }, + { + 0x89, 0x3D, 0x2D, 0x60, 0x98, 0x0C, 0xCB, 0x30, + 0x0E, 0x6C, 0x57, 0x6C, 0xA7, 0x03, 0x53, 0xF3, + 0x27, 0x9D, 0x24, 0x15, 0x2B, 0x68, 0xD0, 0x1A, + 0x9A, 0x43, 0x87, 0x0A, 0xA5, 0x98, 0x66, 0x62, + 0xD5, 0xA2, 0xAB, 0xFE, 0x47, 0x41, 0x77, 0x90, + 0x55, 0x6A, 0x77, 0x4D, 0x69, 0x2A, 0xD4, 0x94, + 0xC3, 0xF8, 0xBF, 0xAF, 0x44, 0xEC, 0xEF, 0x2E, + 0x06, 0x62, 0x8F, 0x9E, 0x8F, 0xCA, 0xD0, 0x4B + }, + { + 0x41, 0x19, 0x8B, 0x30, 0x02, 0xD1, 0x44, 0xEB, + 0x84, 0x3D, 0x37, 0xAD, 0x22, 0x5E, 0x9E, 0xE1, + 0xE5, 0xDD, 0xE7, 0xDD, 0x62, 0xA4, 0x26, 0xE2, + 0xA5, 0xB5, 0xEF, 0xD7, 0xEE, 0x3A, 0x28, 0x5F, + 0x74, 0x0B, 0xCD, 0x95, 0xE9, 0x0F, 0xE4, 0xCB, + 0x6D, 0xBA, 0x34, 0xBB, 0x21, 0x55, 0x11, 0x30, + 0x18, 0x3C, 0xF7, 0x4F, 0x4F, 0xCB, 0x47, 0x95, + 0x79, 0x78, 0x31, 0x2D, 0x6A, 0x05, 0x70, 0x8C + }, + { + 0x94, 0x8D, 0x09, 0x6D, 0x4B, 0x55, 0x09, 0xFC, + 0x0B, 0x4D, 0xD0, 0xFC, 0x8A, 0x5D, 0x2C, 0x65, + 0x11, 0x69, 0x74, 0x3B, 0x24, 0x55, 0x50, 0x8A, + 0xAF, 0xCA, 0x79, 0x85, 0xE5, 0x2A, 0x60, 0xA3, + 0x3D, 0x18, 0xB0, 0xBE, 0xDD, 0x4C, 0x7A, 0xE9, + 0x5E, 0x55, 0x9A, 0x3A, 0xB6, 0xD3, 0xCC, 0x62, + 0x76, 0xF8, 0x11, 0x56, 0xF5, 0xC9, 0x0B, 0x5F, + 0xF6, 0xC1, 0x9A, 0x10, 0xE1, 0x2B, 0xF6, 0x57 + }, + { + 0xE6, 0x70, 0xDB, 0x4D, 0x44, 0x1B, 0x53, 0x5C, + 0xE2, 0x8B, 0xBE, 0xC4, 0x7A, 0xD8, 0x58, 0x41, + 0xBC, 0xEF, 0x71, 0x0A, 0xA4, 0xA1, 0x55, 0x5C, + 0x35, 0x8E, 0x5E, 0x15, 0xF3, 0x48, 0xAD, 0x91, + 0x8C, 0xFE, 0xEB, 0xD4, 0x40, 0x2E, 0x7C, 0xA4, + 0xAD, 0x27, 0x58, 0x4E, 0xA5, 0x82, 0x1C, 0x64, + 0x18, 0x09, 0x0D, 0x7D, 0xD6, 0x08, 0x5E, 0xF7, + 0x0D, 0xFF, 0x0E, 0xC8, 0x1F, 0x0D, 0xBF, 0xA9 + }, + { + 0x81, 0xF2, 0x2B, 0x34, 0xB5, 0x40, 0xDB, 0xF2, + 0x6E, 0x2E, 0xF5, 0xBD, 0xE1, 0x58, 0x1B, 0xDC, + 0x48, 0x1B, 0x73, 0xC4, 0x44, 0xB2, 0x30, 0x9B, + 0xAA, 0x28, 0x2E, 0x59, 0x52, 0x0A, 0x07, 0xB9, + 0xA6, 0x4E, 0x1B, 0xCB, 0x73, 0x49, 0x79, 0x52, + 0x51, 0x5D, 0xED, 0xD6, 0x06, 0x63, 0x1D, 0xC4, + 0x20, 0x6E, 0x09, 0x81, 0xEC, 0xC1, 0xB6, 0x98, + 0x06, 0xE5, 0xE7, 0x01, 0x61, 0x33, 0xB0, 0x46 + }, + { + 0x41, 0x77, 0xFC, 0xF5, 0xA4, 0xF2, 0x04, 0x3E, + 0xF9, 0x87, 0x39, 0x26, 0xB6, 0x52, 0xD5, 0xCE, + 0x49, 0xB0, 0x09, 0xFE, 0xF5, 0x95, 0x24, 0x4D, + 0xBF, 0xDE, 0x97, 0x65, 0x68, 0xAB, 0x43, 0xED, + 0x87, 0xE3, 0x0E, 0xDD, 0x9B, 0x11, 0x8E, 0xF7, + 0xE2, 0xB9, 0x3A, 0x07, 0xBB, 0xFC, 0x36, 0x58, + 0x4B, 0x6B, 0xED, 0x0D, 0x5B, 0xDF, 0x37, 0xB4, + 0x6E, 0x26, 0xE7, 0x97, 0x23, 0x83, 0x0A, 0xFF + }, + { + 0x7F, 0x67, 0x6F, 0xB2, 0xA1, 0x36, 0x6C, 0xEA, + 0x6B, 0xFA, 0x1A, 0x62, 0x41, 0xDB, 0x7A, 0x61, + 0xE9, 0x42, 0x67, 0x91, 0xDE, 0x22, 0x7C, 0x36, + 0x02, 0x5B, 0x5B, 0x47, 0x6D, 0x50, 0xBB, 0x26, + 0x94, 0xDD, 0x1A, 0x68, 0x58, 0x77, 0x1B, 0x21, + 0x40, 0x47, 0xFC, 0xA9, 0x24, 0x76, 0x2F, 0x1B, + 0x62, 0xD5, 0x23, 0x3B, 0xB8, 0x4A, 0x4E, 0x10, + 0xFF, 0xF3, 0x40, 0xD3, 0x03, 0xBD, 0x29, 0x8F + }, + { + 0x4D, 0x57, 0xEA, 0x6D, 0x94, 0xCC, 0xCD, 0x61, + 0x56, 0x9C, 0x0D, 0x09, 0x7C, 0x02, 0xDE, 0x84, + 0xB9, 0x46, 0x57, 0xA9, 0xF1, 0x2B, 0xEC, 0x75, + 0xD8, 0x5B, 0x73, 0xA8, 0x14, 0xF9, 0x6E, 0xD8, + 0x45, 0x6C, 0xA3, 0xAE, 0x63, 0x8B, 0xBC, 0x53, + 0x49, 0x01, 0x8A, 0xCB, 0x82, 0x39, 0x42, 0x8F, + 0x2A, 0x78, 0xEE, 0x34, 0xD7, 0x4C, 0x30, 0x07, + 0x7A, 0x80, 0xB9, 0x04, 0xA1, 0x75, 0x28, 0xC5 + }, + { + 0x5D, 0xB8, 0xF0, 0xDA, 0x89, 0x04, 0x6A, 0xB8, + 0x38, 0x47, 0xC1, 0xBE, 0x9B, 0xC0, 0xE2, 0xDA, + 0xAB, 0x86, 0x58, 0x67, 0xE2, 0x69, 0xEB, 0x5D, + 0x6A, 0x2A, 0xA6, 0xA5, 0x0F, 0xC5, 0x37, 0xB7, + 0x16, 0x1C, 0xDB, 0x37, 0x9E, 0x4F, 0xB2, 0xDD, + 0xDA, 0x6B, 0x8F, 0x57, 0x7F, 0xDB, 0x81, 0xEA, + 0xE7, 0xFE, 0x96, 0x5A, 0xEF, 0x64, 0x6C, 0x56, + 0x2B, 0xC1, 0x75, 0xB3, 0xF7, 0xF2, 0xCA, 0xD4 + }, + { + 0x1E, 0x6B, 0x47, 0x06, 0x9A, 0xF7, 0x69, 0xAC, + 0x55, 0xBA, 0xF2, 0xE7, 0x6F, 0x72, 0x19, 0x33, + 0x8C, 0x21, 0xC2, 0x7C, 0x1A, 0x02, 0xA1, 0xB6, + 0x69, 0xC9, 0x7E, 0x11, 0xCD, 0x21, 0xE7, 0x76, + 0x25, 0x74, 0xA0, 0xAE, 0x32, 0xC4, 0x54, 0x40, + 0x6E, 0x15, 0x4F, 0x96, 0x8E, 0x26, 0x91, 0xCF, + 0xA7, 0xCE, 0xFC, 0xD1, 0x6B, 0x34, 0x7F, 0xB2, + 0x4E, 0xB7, 0xB6, 0x38, 0x9A, 0xF1, 0xE7, 0xF1 + }, + { + 0xE0, 0x54, 0x2E, 0x65, 0x3E, 0x02, 0x63, 0x9F, + 0x08, 0xAB, 0x62, 0xD6, 0x96, 0x4C, 0xED, 0x7D, + 0x8E, 0x85, 0x52, 0x71, 0x56, 0xA3, 0xDC, 0xCE, + 0x54, 0x34, 0xDD, 0x10, 0xB3, 0xD3, 0xDA, 0x4B, + 0xB6, 0x4F, 0x2E, 0x3D, 0x87, 0x88, 0x56, 0xB0, + 0x53, 0xF2, 0x62, 0x0B, 0x51, 0x54, 0xA6, 0xED, + 0x74, 0x75, 0x79, 0x21, 0xEB, 0x5D, 0x2C, 0x6E, + 0x6F, 0xBF, 0x15, 0x29, 0x47, 0xF3, 0x0D, 0x9A + }, + { + 0x3E, 0x56, 0x09, 0x8A, 0x8C, 0x47, 0x87, 0x65, + 0xED, 0x09, 0x2E, 0xCF, 0x27, 0xC5, 0x20, 0xF8, + 0xCB, 0x2F, 0xBF, 0x29, 0xE2, 0xF9, 0x49, 0xFF, + 0xEA, 0x82, 0xEC, 0xE5, 0x4A, 0x59, 0xE7, 0xF1, + 0xE9, 0x26, 0x8C, 0x99, 0x23, 0xF4, 0x81, 0x4F, + 0xD8, 0x53, 0x07, 0x52, 0x91, 0xB6, 0x97, 0x61, + 0x89, 0xA2, 0x80, 0xDF, 0xDA, 0xAA, 0xE7, 0x7A, + 0xD6, 0xE4, 0x5D, 0x3E, 0x6F, 0xBA, 0x45, 0xF3 + }, + { + 0x29, 0x77, 0xC8, 0x77, 0x01, 0x17, 0x8F, 0x0D, + 0x9B, 0x88, 0x81, 0x27, 0x95, 0x04, 0xDE, 0x6E, + 0xFD, 0xEC, 0xC5, 0xF7, 0xBE, 0x59, 0xDE, 0x6B, + 0xE5, 0x84, 0xCB, 0x13, 0xD7, 0xA8, 0x3D, 0x31, + 0x94, 0x6E, 0xBC, 0xB0, 0xB3, 0x5A, 0x2F, 0xFF, + 0xD4, 0x6A, 0xF8, 0x8B, 0xCB, 0xBA, 0x79, 0xE8, + 0xE5, 0x9D, 0x9D, 0xCB, 0x64, 0x61, 0xF7, 0xD5, + 0x29, 0x06, 0x72, 0xB0, 0x60, 0x51, 0x65, 0x4E + }, + { + 0xB0, 0x7C, 0x1D, 0x76, 0x8D, 0xD6, 0x07, 0x1D, + 0xFC, 0x8E, 0xE6, 0x94, 0x66, 0xD2, 0xDC, 0x0F, + 0xFA, 0xB0, 0x8F, 0xB2, 0x05, 0x15, 0xD4, 0xAB, + 0xCE, 0x12, 0x54, 0x14, 0xB0, 0xA6, 0x9B, 0x05, + 0x37, 0x0F, 0xA5, 0x48, 0xCB, 0xBF, 0xBF, 0x40, + 0x01, 0x3B, 0x99, 0x4A, 0xFB, 0x58, 0xCF, 0xF8, + 0x98, 0x23, 0x1E, 0x1A, 0xDD, 0x9A, 0x14, 0x74, + 0xBE, 0xA9, 0xF0, 0x6E, 0xAE, 0xC5, 0x4A, 0xC7 + }, + { + 0x32, 0x66, 0xED, 0x39, 0xDF, 0x7F, 0x64, 0x5E, + 0x6B, 0x26, 0x68, 0x40, 0x96, 0xE0, 0xA2, 0xA6, + 0x36, 0x7F, 0xD1, 0x9D, 0x77, 0x4D, 0xA3, 0x2A, + 0xC1, 0x17, 0x34, 0xEE, 0x19, 0xF7, 0x61, 0x0A, + 0x47, 0xB8, 0x6B, 0x33, 0xC0, 0xAB, 0xEF, 0x8A, + 0x83, 0x55, 0xF0, 0x1B, 0x2B, 0xCE, 0x6B, 0xC0, + 0x8E, 0xF3, 0x25, 0xBA, 0xC8, 0xC3, 0x4A, 0x17, + 0x7E, 0x60, 0xEF, 0x90, 0x50, 0xCB, 0x41, 0x6F + }, + { + 0x40, 0xEB, 0x51, 0xC5, 0x1C, 0xC1, 0x99, 0x96, + 0xB1, 0xC9, 0xD8, 0x8F, 0x07, 0x26, 0x1E, 0xB5, + 0xA6, 0xE4, 0xEE, 0x49, 0xFC, 0x65, 0x39, 0xAA, + 0x3E, 0xB6, 0xA3, 0x30, 0xC2, 0x8E, 0x8C, 0x44, + 0x4D, 0x93, 0xCA, 0xEE, 0xDD, 0xEC, 0x3B, 0xC2, + 0x55, 0x6F, 0xA4, 0x34, 0x1D, 0x53, 0x3E, 0x17, + 0x18, 0x67, 0xA1, 0x3C, 0xFF, 0x95, 0x2A, 0xA6, + 0x9A, 0x2B, 0x5D, 0x8E, 0xD6, 0xE1, 0xB9, 0x51 + }, + { + 0x02, 0xB4, 0x87, 0x0D, 0x63, 0x56, 0x93, 0x79, + 0xDB, 0x46, 0x28, 0xEE, 0xC2, 0x06, 0x21, 0x28, + 0xA8, 0x84, 0xC4, 0xB3, 0x16, 0xFE, 0xF2, 0x34, + 0x40, 0x5E, 0x64, 0x89, 0xEF, 0x43, 0x41, 0x8C, + 0xF3, 0x76, 0x80, 0x5A, 0x6D, 0xAD, 0x1D, 0x0D, + 0x50, 0xA5, 0x87, 0x8F, 0x8F, 0x87, 0xA8, 0xD9, + 0xEC, 0x55, 0x6E, 0x47, 0x28, 0xC2, 0x48, 0x11, + 0x9D, 0xFA, 0xDA, 0xB6, 0x84, 0x21, 0xE0, 0xD7 + }, + { + 0xAF, 0xD9, 0x61, 0xF3, 0x74, 0x53, 0x23, 0x0C, + 0x55, 0xFA, 0x15, 0x94, 0xE8, 0x7B, 0x63, 0xBD, + 0x62, 0x07, 0x3B, 0xD9, 0x0D, 0x9B, 0x0B, 0x37, + 0xCF, 0x3F, 0xE8, 0x06, 0x20, 0x68, 0x97, 0x80, + 0x83, 0x9D, 0xA4, 0x0E, 0x08, 0x80, 0x30, 0x59, + 0x8B, 0x8A, 0xA3, 0x4F, 0x4A, 0x73, 0x3C, 0x6A, + 0x63, 0x93, 0xE0, 0xAF, 0x6A, 0xCF, 0x44, 0xAB, + 0xB7, 0xE8, 0xF6, 0xF1, 0x20, 0xE8, 0xDC, 0xC5 + }, + { + 0x38, 0x89, 0x44, 0xB8, 0x72, 0xAF, 0x01, 0x67, + 0xE7, 0x0B, 0x91, 0x06, 0x74, 0x4F, 0xE1, 0xF8, + 0xAC, 0x9B, 0x35, 0x83, 0x42, 0x21, 0x3B, 0x45, + 0xA1, 0xBA, 0xAC, 0xA6, 0xC1, 0x5B, 0xAE, 0x87, + 0x74, 0x7D, 0xDB, 0x56, 0x6D, 0x9A, 0xAD, 0xDE, + 0x13, 0x64, 0x36, 0x17, 0x58, 0xAD, 0x71, 0xAC, + 0x80, 0x65, 0x9B, 0x52, 0xA8, 0x67, 0xA9, 0x04, + 0x9C, 0x18, 0xC2, 0x43, 0xC8, 0x6A, 0x99, 0x97 + }, + { + 0x6E, 0x86, 0xC1, 0x3D, 0x62, 0x01, 0x72, 0x2F, + 0xC6, 0xA1, 0xBF, 0x73, 0x69, 0x33, 0xF1, 0xCE, + 0x1B, 0x38, 0x34, 0x4B, 0xD4, 0x2B, 0x68, 0xE4, + 0xCC, 0xC8, 0xA8, 0xD9, 0x78, 0xD8, 0xAD, 0x85, + 0x4E, 0x03, 0x65, 0x1C, 0x1A, 0x02, 0xB4, 0x86, + 0x27, 0x8E, 0x5C, 0xD1, 0xCE, 0x0E, 0xC7, 0xE6, + 0x76, 0x6A, 0xB2, 0xE7, 0x87, 0xB5, 0x33, 0x6A, + 0x49, 0xA4, 0xA0, 0x5E, 0x84, 0x5B, 0xDB, 0x6B + }, + { + 0x05, 0x94, 0x13, 0x19, 0x78, 0xC5, 0x4F, 0x8B, + 0xD8, 0xDE, 0x0E, 0xD3, 0xB2, 0x13, 0xE7, 0x8E, + 0x9D, 0x22, 0x8B, 0xD5, 0x1C, 0x5D, 0xE5, 0x45, + 0x41, 0x57, 0x7E, 0xED, 0x5A, 0x6D, 0xD9, 0xF7, + 0xBB, 0x10, 0x3B, 0xE9, 0xB2, 0x7E, 0xA3, 0x09, + 0x72, 0xB3, 0x08, 0xB5, 0x53, 0xCC, 0xE7, 0xE2, + 0xFC, 0x9F, 0x42, 0x63, 0x6F, 0x72, 0xCF, 0x5D, + 0x6A, 0xA0, 0x2B, 0xE4, 0x0E, 0xC7, 0x51, 0xE6 + }, + { + 0xF9, 0x1E, 0xB8, 0xF0, 0x66, 0xDF, 0xAC, 0xB2, + 0x51, 0x24, 0x6B, 0x03, 0x72, 0x94, 0xEF, 0x45, + 0x03, 0x2D, 0x9E, 0xDC, 0x60, 0x7A, 0x03, 0x4D, + 0xED, 0xD5, 0x00, 0x82, 0xC4, 0x28, 0xF9, 0xF5, + 0x4D, 0x56, 0x80, 0x6A, 0xCD, 0xDA, 0xD3, 0x51, + 0x4C, 0xF7, 0x3D, 0xCA, 0xE3, 0x50, 0x5B, 0x94, + 0x93, 0x62, 0x6C, 0x33, 0x15, 0xE5, 0x8C, 0x64, + 0x01, 0xFE, 0xC5, 0x4A, 0xCA, 0x16, 0xAF, 0x74 + }, + { + 0x89, 0xAE, 0x71, 0x09, 0x93, 0xF9, 0xB8, 0x05, + 0xCF, 0x7E, 0xC9, 0x85, 0xB9, 0xD4, 0x5A, 0x82, + 0xFC, 0xC0, 0x68, 0x8B, 0xEF, 0x70, 0x29, 0xA8, + 0x55, 0x4B, 0x60, 0x8A, 0x0C, 0x3D, 0xA7, 0x18, + 0xD9, 0x8A, 0xF8, 0xC4, 0xFC, 0xED, 0xFF, 0x73, + 0xF1, 0x01, 0xE2, 0xA3, 0x03, 0x9B, 0xA7, 0x51, + 0x5D, 0x9E, 0x1A, 0x92, 0xBF, 0x0F, 0x06, 0xF8, + 0x66, 0xF7, 0xB7, 0x5E, 0x96, 0x09, 0x0F, 0x19 + }, + { + 0x3E, 0x51, 0x03, 0x5A, 0x7F, 0xD6, 0x53, 0xEE, + 0x79, 0xF7, 0x1A, 0x64, 0xAD, 0xD3, 0x72, 0x25, + 0x2B, 0x5C, 0x19, 0x0D, 0x61, 0x8E, 0xE1, 0xCD, + 0x4D, 0x17, 0x9B, 0xD5, 0x36, 0x93, 0x44, 0xFB, + 0xE2, 0x16, 0x5C, 0x26, 0xDF, 0x0C, 0x4B, 0xED, + 0x7B, 0x5F, 0x30, 0xC9, 0xE2, 0xEE, 0xBB, 0x65, + 0xFF, 0xFB, 0xE7, 0x54, 0x9C, 0x09, 0xB9, 0xBA, + 0xEC, 0xEF, 0xB0, 0x36, 0xF8, 0x5F, 0x20, 0x28 + }, + { + 0xBC, 0x7B, 0xD1, 0x1A, 0xE4, 0xBE, 0x61, 0xEA, + 0xC3, 0xFF, 0x75, 0xE7, 0x9C, 0xFF, 0x5D, 0x1B, + 0x3C, 0xAD, 0xEB, 0xD7, 0xDA, 0x31, 0x04, 0xED, + 0x53, 0x15, 0x3D, 0xA7, 0x7C, 0x4B, 0x1D, 0x05, + 0xE9, 0xF5, 0x4C, 0x48, 0xA6, 0xD5, 0x23, 0xBA, + 0x30, 0x96, 0x77, 0x34, 0xB8, 0x41, 0x29, 0x19, + 0xCF, 0x17, 0x12, 0x93, 0x4D, 0xF9, 0xA1, 0xC1, + 0xBB, 0x39, 0xBE, 0x87, 0x26, 0xEF, 0xF1, 0x43 + }, + { + 0x68, 0xC8, 0x13, 0x0E, 0x83, 0x2B, 0x9E, 0x5D, + 0x75, 0xBE, 0xFC, 0x3E, 0xFC, 0x58, 0xF8, 0x7C, + 0xCA, 0xBA, 0x30, 0x36, 0x54, 0x15, 0xE4, 0x42, + 0xE4, 0x9A, 0xE6, 0x82, 0x90, 0x59, 0x08, 0xA5, + 0x23, 0x82, 0x4B, 0xCA, 0x28, 0x30, 0xE9, 0xE3, + 0xA4, 0xF0, 0xBF, 0x37, 0x73, 0x6D, 0x1D, 0xBA, + 0x54, 0xB5, 0x41, 0x0D, 0x74, 0x41, 0xB0, 0x66, + 0xF5, 0x46, 0x43, 0x54, 0x30, 0xB1, 0xC6, 0xE8 + }, + { + 0x09, 0x83, 0x5B, 0xF6, 0x41, 0x1D, 0xDF, 0x87, + 0x25, 0x79, 0x00, 0xD2, 0x08, 0xF1, 0x45, 0x93, + 0x74, 0x74, 0x99, 0xA4, 0x09, 0x34, 0x9C, 0xEB, + 0xB6, 0xC4, 0x2C, 0x6C, 0x53, 0xD4, 0x39, 0x3E, + 0x88, 0x63, 0x19, 0x85, 0xA7, 0x84, 0x7A, 0x62, + 0x21, 0x4F, 0x00, 0x38, 0x49, 0x94, 0xBD, 0x81, + 0x4B, 0xA9, 0x06, 0xF4, 0x17, 0x15, 0x49, 0x0A, + 0x15, 0xC5, 0xB0, 0x26, 0xC0, 0xDE, 0x48, 0x1E + }, + { + 0x16, 0x6D, 0x82, 0x40, 0x0B, 0x96, 0x1A, 0x2E, + 0xF9, 0x5C, 0xDA, 0x9F, 0x81, 0x9C, 0xE0, 0x68, + 0xF6, 0xD5, 0x6F, 0xF8, 0x83, 0xBA, 0x76, 0x94, + 0x86, 0x9C, 0x04, 0x47, 0x11, 0x82, 0x44, 0xB9, + 0x71, 0x9B, 0x11, 0x27, 0x81, 0xB9, 0x51, 0x28, + 0xFE, 0x80, 0x9C, 0x29, 0xDF, 0x4B, 0x1E, 0x49, + 0xFC, 0x0A, 0x46, 0xBC, 0x86, 0x59, 0x67, 0xE9, + 0xFB, 0x1D, 0x45, 0x61, 0xB1, 0x9C, 0x25, 0x7C + }, + { + 0x6F, 0x78, 0x6C, 0xA7, 0x80, 0x3B, 0x7C, 0x18, + 0x33, 0x00, 0x9A, 0x62, 0x39, 0x95, 0xE5, 0xDB, + 0x08, 0x79, 0x1C, 0x91, 0x2B, 0xE3, 0xA5, 0xF2, + 0x19, 0xD2, 0x9B, 0xC6, 0xE7, 0xC7, 0xDD, 0x43, + 0x01, 0xFF, 0x7A, 0x00, 0xE9, 0x85, 0x2E, 0x44, + 0x05, 0x63, 0xCE, 0xF5, 0x2E, 0x89, 0x45, 0xDD, + 0xCB, 0x5E, 0x57, 0xE8, 0x16, 0x93, 0x1B, 0x54, + 0xDB, 0xD6, 0x55, 0xDC, 0xF6, 0x69, 0x50, 0x0E + }, + { + 0x66, 0x77, 0x2B, 0xCA, 0x74, 0x3E, 0xEA, 0x0F, + 0xCF, 0xF0, 0x02, 0x32, 0x62, 0x73, 0x16, 0x2C, + 0x8B, 0x83, 0xD8, 0xEE, 0x8E, 0xBC, 0x84, 0x62, + 0x90, 0xAB, 0xC2, 0x3F, 0xDC, 0xC0, 0xE4, 0xD1, + 0xA0, 0xE9, 0xC2, 0x4D, 0x2D, 0x80, 0x4B, 0x0D, + 0xC0, 0x3A, 0x56, 0xB0, 0xE6, 0x17, 0x10, 0x2F, + 0x03, 0x44, 0x75, 0xE3, 0x9E, 0xB8, 0x77, 0xEE, + 0x90, 0x81, 0x75, 0xFF, 0x6A, 0x4F, 0xE3, 0xFB + }, + { + 0x48, 0x6F, 0x5B, 0x76, 0x68, 0xC9, 0x7D, 0xC7, + 0x0E, 0xA6, 0x05, 0x1B, 0xED, 0xBF, 0x1D, 0xAF, + 0x6E, 0x49, 0x78, 0x96, 0x63, 0xA2, 0xD5, 0x80, + 0xFD, 0x9A, 0x4C, 0x1C, 0xA0, 0xF5, 0x6D, 0x1F, + 0xF6, 0xF7, 0x2B, 0xE3, 0x86, 0x49, 0xFA, 0xE2, + 0xDC, 0xB6, 0x3B, 0x17, 0x2F, 0xB1, 0x5B, 0x92, + 0xBE, 0xEF, 0x49, 0xB2, 0x2E, 0x68, 0xC7, 0x4D, + 0x01, 0xF6, 0xF2, 0x3F, 0x84, 0x72, 0x04, 0xFB + }, + { + 0x05, 0x4E, 0x3A, 0x34, 0x94, 0xAE, 0x06, 0x67, + 0x52, 0x34, 0x05, 0x22, 0x7F, 0xBE, 0xD5, 0x2B, + 0x65, 0xE3, 0xFC, 0x23, 0xCE, 0x75, 0x1B, 0x55, + 0x31, 0xA4, 0xE6, 0xF6, 0xD0, 0xB1, 0x15, 0x45, + 0x05, 0xFA, 0xCE, 0x6D, 0xBC, 0x71, 0x18, 0xA4, + 0xDE, 0xA3, 0x50, 0xAD, 0x32, 0x44, 0xCC, 0x89, + 0x52, 0x68, 0x55, 0x25, 0x9F, 0xBA, 0xB5, 0x68, + 0x94, 0x4F, 0xAB, 0xD3, 0x05, 0x8E, 0x1E, 0x4E + }, + { + 0xD3, 0xD7, 0x80, 0x88, 0x8C, 0x17, 0x06, 0x8B, + 0x90, 0x81, 0x35, 0xFB, 0x4D, 0x11, 0x68, 0x90, + 0x2F, 0x54, 0x76, 0xCD, 0x1D, 0x32, 0xF6, 0x27, + 0xB4, 0xA8, 0x04, 0x72, 0x59, 0xFE, 0x20, 0x9D, + 0xD1, 0x15, 0x11, 0xBF, 0x25, 0xB2, 0x90, 0xCB, + 0xF0, 0x69, 0x2F, 0x13, 0xE8, 0xF2, 0xC5, 0xE7, + 0x7A, 0x44, 0xA5, 0xFC, 0x72, 0x73, 0xF7, 0x35, + 0x57, 0x6E, 0x93, 0xF8, 0x33, 0xD1, 0x48, 0x4B + }, + { + 0x59, 0xAF, 0x38, 0x6B, 0xFC, 0xB1, 0xF5, 0x56, + 0x65, 0x2B, 0x5F, 0x07, 0x52, 0x66, 0xDB, 0x14, + 0xB8, 0x2E, 0xF0, 0xDA, 0xDC, 0xCC, 0x96, 0xD6, + 0xD1, 0x31, 0xDB, 0xEE, 0x8E, 0x8B, 0x6E, 0x28, + 0x32, 0x84, 0x4E, 0x77, 0x7B, 0xE4, 0xDF, 0xE4, + 0xAF, 0xED, 0x2D, 0x88, 0x4C, 0xAE, 0xC9, 0xD4, + 0xDB, 0x39, 0x31, 0x50, 0xDA, 0x96, 0xD5, 0xB7, + 0x57, 0x41, 0xB2, 0xE2, 0x1D, 0xA7, 0xEE, 0x49 + }, + { + 0x17, 0xB1, 0x81, 0x26, 0x86, 0xA0, 0x3E, 0xED, + 0x39, 0xDD, 0x57, 0xFE, 0xE9, 0x27, 0x89, 0x0C, + 0x9F, 0x28, 0x18, 0xE6, 0x1A, 0xA9, 0x37, 0xEF, + 0xAF, 0xFF, 0x76, 0x79, 0x9C, 0x1B, 0x63, 0x77, + 0x33, 0xBA, 0x9F, 0xC9, 0x8C, 0x84, 0xB2, 0x2D, + 0x46, 0xD4, 0x1C, 0xEB, 0xEF, 0xAF, 0x36, 0x34, + 0x02, 0x09, 0x79, 0x22, 0xB5, 0x62, 0xA1, 0x18, + 0x17, 0xDD, 0xCC, 0xD6, 0xA4, 0x0C, 0x63, 0x1A + }, + { + 0x7A, 0xDA, 0xA0, 0xC8, 0x04, 0x31, 0x85, 0x9F, + 0x09, 0x0F, 0x5F, 0xF5, 0x5F, 0x6A, 0x88, 0x3F, + 0x99, 0x06, 0x3A, 0xE6, 0x84, 0xC5, 0x6B, 0x86, + 0x6B, 0xA9, 0xAC, 0xC2, 0x83, 0xBD, 0x9E, 0x93, + 0x8E, 0x39, 0xB8, 0x18, 0xCD, 0xF6, 0x5F, 0x22, + 0xD3, 0x10, 0x1E, 0x94, 0xC7, 0x42, 0x71, 0x2F, + 0x13, 0xC0, 0x93, 0x16, 0x2A, 0xB7, 0x7F, 0x35, + 0x48, 0xC5, 0xFC, 0xD4, 0x5A, 0x85, 0xF5, 0xB6 + }, + { + 0x87, 0x81, 0x09, 0x5A, 0x3C, 0x1A, 0x4D, 0x2B, + 0xB5, 0x29, 0x31, 0x96, 0xDB, 0x98, 0x68, 0xBB, + 0x84, 0xA7, 0x2B, 0x59, 0x1B, 0x8A, 0xA1, 0xB8, + 0x90, 0x10, 0x3F, 0xA4, 0x11, 0xAA, 0xC4, 0x88, + 0x60, 0x80, 0xDE, 0x48, 0xA6, 0x9A, 0x43, 0x0F, + 0xFA, 0x41, 0x18, 0xB9, 0x57, 0x25, 0xEB, 0xBE, + 0xFA, 0x21, 0xCD, 0xCD, 0xB1, 0x88, 0xB2, 0x15, + 0x6E, 0xF4, 0x26, 0xC8, 0x32, 0x6D, 0x78, 0x7E + }, + { + 0x5B, 0xE7, 0xC0, 0x23, 0xEB, 0x1C, 0x57, 0x17, + 0x0B, 0x90, 0x30, 0x65, 0x57, 0x5D, 0x52, 0x2E, + 0xAC, 0xED, 0x00, 0xB2, 0x08, 0x6E, 0x5D, 0xA6, + 0x1C, 0x12, 0xA2, 0xF3, 0x63, 0x82, 0x50, 0x34, + 0x5D, 0xEB, 0x65, 0x0B, 0x84, 0x1E, 0x51, 0x30, + 0x7C, 0xBD, 0xEB, 0x54, 0x97, 0x45, 0x46, 0xBB, + 0xA0, 0x35, 0xF0, 0x82, 0x74, 0x68, 0x5F, 0x63, + 0x72, 0xEA, 0x55, 0xD5, 0x36, 0x40, 0xC4, 0x77 + }, + { + 0xD9, 0xC4, 0x98, 0xF2, 0x3A, 0x95, 0x38, 0x62, + 0x44, 0x82, 0xD0, 0x09, 0x1F, 0x69, 0x3C, 0x06, + 0x59, 0xDF, 0xB6, 0xF7, 0xFE, 0x9E, 0xD7, 0x44, + 0x6F, 0x6E, 0x2E, 0x83, 0x68, 0x77, 0xF4, 0x66, + 0xC0, 0x95, 0x0B, 0x05, 0x4F, 0x98, 0x34, 0xA7, + 0x9E, 0x8D, 0x42, 0x75, 0xDC, 0xCB, 0xF0, 0x83, + 0x49, 0x07, 0x36, 0x7B, 0xCE, 0x96, 0x20, 0xED, + 0x02, 0xF7, 0x75, 0x31, 0x01, 0x70, 0xB5, 0xD4 + }, + { + 0x31, 0xD8, 0x62, 0x1C, 0x05, 0x39, 0xF2, 0x62, + 0xC6, 0x33, 0xFD, 0x58, 0xBE, 0x24, 0x7E, 0x6A, + 0x0A, 0xF1, 0x88, 0x12, 0x15, 0xCB, 0x30, 0x9F, + 0x1F, 0xEE, 0x4A, 0x1F, 0x7A, 0x3A, 0x08, 0xD9, + 0xB1, 0xC8, 0x55, 0x0D, 0x1D, 0x54, 0x8E, 0xFC, + 0x26, 0xFE, 0x49, 0x3A, 0x72, 0x15, 0x91, 0x17, + 0x06, 0xED, 0xFC, 0x36, 0x10, 0x20, 0x6E, 0x18, + 0x02, 0x33, 0x5D, 0x3C, 0xB6, 0x87, 0x99, 0xA3 + }, + { + 0x01, 0xE2, 0xC9, 0x0F, 0xF6, 0x26, 0x34, 0xFB, + 0x46, 0x52, 0xCE, 0x8B, 0x4E, 0x8E, 0x3C, 0xD6, + 0xD6, 0xE3, 0xB8, 0x7B, 0xCF, 0xF9, 0xCE, 0x18, + 0x66, 0x25, 0x9E, 0x41, 0xB6, 0x54, 0xAF, 0xD3, + 0x51, 0x03, 0x33, 0x96, 0x3F, 0x95, 0xCF, 0xCA, + 0xAD, 0x9F, 0x65, 0x03, 0x38, 0x21, 0xE4, 0x35, + 0xC9, 0xC4, 0x5F, 0xF2, 0xB8, 0x02, 0xDC, 0x80, + 0x69, 0xA6, 0x31, 0x00, 0x57, 0x76, 0x85, 0xC4 + }, + { + 0x6E, 0xC7, 0x19, 0x14, 0x9D, 0x4F, 0x00, 0x8C, + 0xE0, 0x0A, 0x24, 0x64, 0xF9, 0x63, 0x48, 0xD1, + 0x2F, 0xED, 0x22, 0x0F, 0x13, 0x42, 0xA6, 0x8E, + 0x6E, 0xEF, 0x87, 0x0E, 0xA2, 0x85, 0x7B, 0xD0, + 0xA0, 0xED, 0xC0, 0x96, 0x4C, 0xD6, 0x59, 0x75, + 0x3E, 0x16, 0x87, 0xFD, 0x6E, 0xD7, 0xE2, 0x1D, + 0x5D, 0xF9, 0x21, 0x60, 0xE5, 0xF2, 0xE5, 0x49, + 0x34, 0xF1, 0xA9, 0x6F, 0x9F, 0xBA, 0xD0, 0xFF + }, + { + 0x1B, 0x4D, 0x01, 0x14, 0xF6, 0x8F, 0x9B, 0x7D, + 0xB4, 0x21, 0xFE, 0x9B, 0x4A, 0x68, 0x4A, 0x6C, + 0xFF, 0x19, 0xBA, 0x8C, 0x58, 0xA6, 0xBB, 0x89, + 0x68, 0x6B, 0xD4, 0x62, 0xC9, 0xA6, 0x75, 0x99, + 0x16, 0x1D, 0x6E, 0x94, 0x2A, 0x2E, 0x7E, 0x0E, + 0x16, 0x9C, 0xEE, 0xBD, 0xFF, 0x14, 0xBF, 0xAF, + 0xCE, 0x13, 0x10, 0x44, 0xE1, 0x38, 0x0F, 0x80, + 0x7B, 0xF4, 0xC6, 0xEC, 0x89, 0xB4, 0x65, 0xD9 + }, + { + 0xDC, 0xFA, 0xEF, 0x35, 0x47, 0xF1, 0x19, 0x63, + 0x41, 0x20, 0x87, 0x79, 0xA4, 0x39, 0x5F, 0x0B, + 0x8D, 0xF2, 0x2F, 0x62, 0x17, 0x34, 0xE2, 0x46, + 0x7E, 0xAB, 0x63, 0x03, 0xA4, 0x92, 0xFB, 0xDF, + 0x5A, 0x6C, 0x35, 0x7C, 0x87, 0x2B, 0xDA, 0x25, + 0xCE, 0xD2, 0xC6, 0xC2, 0x7E, 0x3E, 0x22, 0x56, + 0x71, 0x3E, 0x39, 0x0D, 0x15, 0x43, 0xD7, 0xEA, + 0xFE, 0xC7, 0x4D, 0x2C, 0xB6, 0x47, 0x58, 0x6D + }, + { + 0x50, 0x81, 0x5D, 0xA5, 0x92, 0x06, 0xD8, 0x51, + 0x7E, 0xAC, 0xAB, 0xA9, 0x2B, 0x03, 0xBD, 0x58, + 0xA3, 0x23, 0x82, 0x1F, 0xDA, 0xAA, 0x32, 0x63, + 0x1B, 0xFD, 0x89, 0x46, 0x46, 0x06, 0x90, 0xBE, + 0x94, 0xC8, 0xD4, 0xE1, 0xD3, 0x7B, 0xC8, 0xAC, + 0x56, 0x5B, 0x71, 0xC9, 0x6F, 0x4C, 0xAC, 0x96, + 0xF6, 0x1F, 0xD2, 0x3B, 0x88, 0x42, 0x2A, 0x96, + 0x99, 0x56, 0x01, 0xB9, 0x7E, 0x4A, 0xFE, 0xB4 + }, + { + 0x04, 0x2E, 0x50, 0x61, 0xEC, 0x26, 0x88, 0x95, + 0x7A, 0x65, 0x3E, 0x80, 0xF1, 0xF5, 0x30, 0xF9, + 0xF1, 0x50, 0xA7, 0xF8, 0x7A, 0x68, 0x61, 0xB4, + 0x5E, 0x94, 0x83, 0x8A, 0x7B, 0x51, 0x86, 0x27, + 0xD7, 0xD4, 0xC3, 0x37, 0x08, 0x9B, 0xDC, 0x28, + 0xE0, 0xD1, 0x65, 0x88, 0x47, 0xD6, 0x25, 0x00, + 0xCD, 0x44, 0x0C, 0xDB, 0x90, 0x1C, 0x57, 0xCB, + 0x94, 0x04, 0xF4, 0xFD, 0xFA, 0xB9, 0xB6, 0x7A + }, + { + 0x6C, 0xAE, 0x85, 0x95, 0x2A, 0x4F, 0xE8, 0xFA, + 0xB7, 0x4A, 0x0E, 0x49, 0x18, 0xDE, 0xF5, 0x2A, + 0x3D, 0x60, 0x45, 0x15, 0x55, 0x0B, 0x40, 0x2B, + 0x15, 0x9E, 0x87, 0x21, 0x1C, 0x8D, 0xDA, 0x8C, + 0x7D, 0x63, 0x56, 0x43, 0xBC, 0x07, 0xFC, 0xA0, + 0x9C, 0x84, 0x21, 0x3D, 0xDC, 0xDD, 0xF1, 0xEA, + 0xDB, 0x1F, 0x74, 0x51, 0x62, 0xE0, 0x1C, 0xD4, + 0xE1, 0x00, 0xF5, 0x56, 0xBB, 0xC8, 0x58, 0xB4 + }, + { + 0x23, 0xF5, 0xBB, 0x51, 0x41, 0xCF, 0x50, 0xE1, + 0x2B, 0x8F, 0x54, 0xBC, 0xFF, 0x94, 0xA7, 0xC5, + 0xFE, 0x8E, 0x3C, 0x98, 0xE1, 0x13, 0x55, 0x5B, + 0x07, 0x86, 0x48, 0x54, 0x78, 0xD1, 0xC1, 0xE1, + 0xF5, 0x45, 0x93, 0x25, 0xE1, 0x10, 0xFD, 0xD9, + 0xCF, 0x98, 0x15, 0xD8, 0xFE, 0xF9, 0x67, 0xF8, + 0x8C, 0xC7, 0x53, 0xCE, 0xF0, 0xA7, 0x54, 0x0B, + 0x24, 0x83, 0x71, 0x66, 0x79, 0x1F, 0x2A, 0xE8 + }, + { + 0xF3, 0xBF, 0xD4, 0x6B, 0xE4, 0x65, 0xC8, 0x28, + 0x64, 0x0D, 0x13, 0x1C, 0x28, 0x58, 0x0F, 0x6F, + 0x1F, 0xD6, 0x75, 0x04, 0x7D, 0xA9, 0x3F, 0xD2, + 0xBC, 0x25, 0xE4, 0x7D, 0x34, 0x0C, 0xCC, 0x0E, + 0x88, 0x90, 0x8D, 0x9D, 0x45, 0x9C, 0xE1, 0x7A, + 0xA5, 0xB4, 0x86, 0x84, 0x8B, 0x82, 0xEB, 0x8E, + 0x92, 0xB1, 0x7A, 0xF0, 0x2A, 0x9A, 0x55, 0x0E, + 0x22, 0x1E, 0x3F, 0xE6, 0xD8, 0x86, 0x13, 0xFE + }, + { + 0x0B, 0x06, 0x94, 0x01, 0x43, 0x8E, 0x2E, 0xEA, + 0x9D, 0x53, 0xE1, 0xB6, 0x58, 0xA5, 0x1E, 0x34, + 0x3C, 0x4F, 0x93, 0x2F, 0x0D, 0x5D, 0x8D, 0xC6, + 0xF7, 0x87, 0x20, 0x61, 0xE6, 0xB7, 0x1A, 0x35, + 0x50, 0x6C, 0x79, 0x5B, 0xCE, 0xD4, 0x90, 0xD3, + 0x44, 0x8D, 0xE9, 0x24, 0xC6, 0xEF, 0xE0, 0x60, + 0x3D, 0xC1, 0x68, 0xF9, 0x95, 0x72, 0xC7, 0xBC, + 0x87, 0x01, 0x66, 0xF4, 0xE0, 0x9E, 0xB5, 0xB9 + }, + { + 0x2C, 0x08, 0xD3, 0xC9, 0xFB, 0xFF, 0x10, 0xB0, + 0x6E, 0xFB, 0x86, 0x61, 0x9C, 0x65, 0x76, 0xCD, + 0x8D, 0xD4, 0x1A, 0x77, 0xF9, 0x38, 0x9F, 0xD7, + 0x04, 0x30, 0xD8, 0xC0, 0x83, 0xF0, 0x5F, 0xCD, + 0xA5, 0x69, 0xC6, 0x3C, 0x29, 0x32, 0x54, 0xBE, + 0x04, 0x31, 0xB6, 0x46, 0x70, 0x7F, 0x3C, 0x40, + 0x74, 0x1C, 0x6A, 0x60, 0x53, 0x1D, 0x73, 0x5A, + 0x8C, 0x9D, 0xCD, 0x99, 0xD1, 0x66, 0xD9, 0x53 + }, + { + 0x8D, 0xFB, 0xE6, 0x35, 0x4E, 0xB5, 0x0A, 0x06, + 0x9C, 0xC1, 0x26, 0x69, 0x81, 0x82, 0x27, 0x82, + 0x0F, 0xC2, 0x07, 0x1D, 0xDF, 0xFE, 0x0D, 0xCC, + 0x4C, 0xF6, 0xEB, 0xDB, 0x05, 0xAD, 0x10, 0x97, + 0x74, 0x1C, 0xCA, 0x65, 0xB0, 0xBD, 0x85, 0x12, + 0x36, 0x7A, 0xC0, 0x62, 0x88, 0xC7, 0x1D, 0xDB, + 0x68, 0x10, 0xD6, 0xDE, 0x21, 0x5D, 0x50, 0x4F, + 0x2F, 0x0D, 0x52, 0x45, 0x9B, 0xC0, 0xCC, 0x91 + }, + { + 0x0B, 0xC4, 0xC1, 0x9A, 0x2D, 0xF4, 0xFE, 0x0D, + 0x72, 0xAC, 0xD3, 0xC3, 0x43, 0x8B, 0x4B, 0x45, + 0x02, 0x97, 0xA0, 0x6F, 0x49, 0x86, 0x13, 0x78, + 0xEC, 0x6A, 0x3E, 0x75, 0x7D, 0xCE, 0xA5, 0x09, + 0xFD, 0xB3, 0x42, 0x96, 0x3F, 0x23, 0x9A, 0xDA, + 0x2E, 0xCA, 0x9C, 0xE1, 0x1E, 0x23, 0x6A, 0xFC, + 0x3B, 0x12, 0x19, 0xFE, 0x40, 0x6E, 0xFC, 0xCC, + 0x5E, 0x51, 0xBC, 0x8E, 0x59, 0xFA, 0x81, 0x3D + }, + { + 0x18, 0x06, 0x40, 0xCA, 0xCD, 0x7C, 0x28, 0x19, + 0x15, 0x2C, 0x97, 0xB3, 0xE9, 0xD9, 0x0E, 0x40, + 0xC8, 0x11, 0x34, 0x0C, 0x89, 0x54, 0x1C, 0x12, + 0x0D, 0xB2, 0x99, 0xF3, 0x2D, 0xB1, 0xDC, 0xF9, + 0xEA, 0x30, 0xE6, 0xBA, 0x80, 0x54, 0x0F, 0x33, + 0x5B, 0xC2, 0xD6, 0xFC, 0xFA, 0x57, 0x01, 0x78, + 0xED, 0x19, 0x09, 0x92, 0xAC, 0xBC, 0xBD, 0x95, + 0xB5, 0xEF, 0x08, 0xE4, 0x05, 0xEF, 0xEA, 0x6A + }, + { + 0x1B, 0x7E, 0xBF, 0xF9, 0x56, 0x3D, 0xCB, 0xA2, + 0x17, 0xF2, 0x3E, 0xDD, 0xF9, 0xC7, 0xEE, 0x6F, + 0xAE, 0xBA, 0xED, 0x10, 0x7F, 0x04, 0x0F, 0xDA, + 0xBC, 0xBE, 0x2E, 0x18, 0x55, 0xC0, 0x03, 0x09, + 0xFC, 0xB9, 0xAA, 0x1C, 0xB2, 0x8D, 0x2A, 0x84, + 0xD6, 0xFF, 0xA4, 0xF9, 0x16, 0x7F, 0xBC, 0x3F, + 0xCB, 0xFE, 0xA3, 0xAD, 0x61, 0xAE, 0x0C, 0x2A, + 0x35, 0x75, 0x28, 0x8F, 0x55, 0xAA, 0x52, 0x8B + }, + { + 0xE5, 0x77, 0xBD, 0x22, 0x24, 0x8D, 0x48, 0x63, + 0xF9, 0x29, 0x2A, 0x7E, 0x0D, 0x1B, 0x66, 0xD7, + 0x7D, 0x28, 0xD7, 0x0B, 0x27, 0xD9, 0x74, 0xD7, + 0x80, 0x8A, 0xED, 0x0D, 0xE5, 0x96, 0x6F, 0x7F, + 0x6D, 0x6A, 0x03, 0x37, 0x43, 0x88, 0x90, 0x41, + 0x70, 0x48, 0x44, 0x68, 0x3B, 0x8F, 0x5D, 0x06, + 0xE5, 0x64, 0xC2, 0x8C, 0xCA, 0x8E, 0xF4, 0xD7, + 0x25, 0xE7, 0x5D, 0xB3, 0x31, 0x3E, 0x7A, 0x08 + }, + { + 0xC4, 0x83, 0xBC, 0x27, 0x54, 0xF0, 0x67, 0xA0, + 0x26, 0x13, 0x8C, 0x7D, 0xE4, 0xCF, 0x5E, 0x45, + 0xC5, 0x51, 0x7B, 0x64, 0xA8, 0x6F, 0x2C, 0x61, + 0x1C, 0xE8, 0x4A, 0xCE, 0x4C, 0xAE, 0x7D, 0xDA, + 0x2B, 0xBC, 0xFE, 0x0A, 0x11, 0xF1, 0xD8, 0x68, + 0x05, 0x87, 0x66, 0x99, 0xC2, 0xE3, 0x0D, 0xEC, + 0x1F, 0xF0, 0xAC, 0x71, 0x65, 0xD9, 0x45, 0xF5, + 0x30, 0xD5, 0xFF, 0xCD, 0x7C, 0x94, 0x3B, 0x2C + }, + { + 0xBC, 0xFF, 0x36, 0xA5, 0x0D, 0x76, 0x09, 0xE8, + 0xFC, 0x69, 0x91, 0x95, 0x48, 0xFB, 0x02, 0x37, + 0x5A, 0xF6, 0x76, 0xB1, 0xA0, 0x89, 0x38, 0xA0, + 0x05, 0x05, 0x6C, 0x16, 0x33, 0x19, 0x9B, 0x5C, + 0x06, 0x69, 0xF9, 0xF9, 0xF8, 0x0A, 0x5B, 0x1B, + 0x4D, 0x1B, 0xCC, 0xDF, 0xEF, 0xDB, 0xE2, 0xD8, + 0x28, 0xAB, 0x2A, 0x12, 0xA6, 0xAC, 0xDB, 0xC8, + 0x3C, 0x1E, 0x8F, 0x7B, 0x3A, 0x9F, 0x6F, 0xA0 + }, + { + 0xFC, 0x61, 0xE4, 0x03, 0x27, 0xCE, 0xA6, 0x5C, + 0xED, 0x2F, 0x52, 0x8C, 0x7E, 0x0A, 0x01, 0x00, + 0x5B, 0x7A, 0x17, 0x0E, 0xEF, 0x76, 0x7C, 0xE9, + 0x6B, 0x94, 0xD8, 0x96, 0xDE, 0x3C, 0xE4, 0xDE, + 0xF3, 0xB1, 0x52, 0x3F, 0xDB, 0xDC, 0xE3, 0xB3, + 0x64, 0x0F, 0x0C, 0xEC, 0xD7, 0x70, 0x5C, 0x0F, + 0x47, 0x22, 0x53, 0x07, 0x58, 0x17, 0x4A, 0x05, + 0x15, 0x29, 0xC8, 0x4C, 0x25, 0xB1, 0xAE, 0xD9 + }, + { + 0x57, 0xB7, 0xDE, 0xE1, 0x21, 0x98, 0x7E, 0xB9, + 0x53, 0x6C, 0x4C, 0x7C, 0xA1, 0xCE, 0xAC, 0x1E, + 0xDA, 0x7A, 0xEC, 0xED, 0x92, 0x73, 0x0D, 0xBC, + 0x98, 0xAB, 0x43, 0x25, 0xA8, 0x51, 0xF6, 0x9E, + 0x91, 0x1C, 0x1B, 0x75, 0x3C, 0x3A, 0x64, 0x18, + 0x06, 0x43, 0x96, 0x5E, 0xF4, 0x76, 0xFE, 0x3F, + 0x83, 0x81, 0xC6, 0x74, 0x82, 0xBB, 0x59, 0x7E, + 0x99, 0x6D, 0x8D, 0x69, 0x62, 0xF2, 0x8B, 0x51 + }, + { + 0x01, 0xFE, 0x4F, 0x7A, 0xC0, 0x55, 0x31, 0x9C, + 0x79, 0x4D, 0x9D, 0x14, 0x81, 0x28, 0x4B, 0x3A, + 0x3C, 0xC8, 0xD2, 0x42, 0xAA, 0x39, 0xBD, 0x40, + 0xC5, 0xDD, 0x80, 0xBD, 0x87, 0x82, 0x2D, 0xD1, + 0xE5, 0x87, 0x80, 0x5F, 0xDF, 0xB0, 0xC0, 0xF9, + 0xF5, 0xA3, 0x18, 0xBD, 0x86, 0xCD, 0x84, 0x62, + 0xE3, 0x68, 0x09, 0xB3, 0xA9, 0x2A, 0x06, 0x35, + 0xA0, 0x55, 0xB6, 0x8B, 0xA7, 0x68, 0xFA, 0x0C + }, + { + 0x01, 0x96, 0x46, 0xC2, 0x42, 0x3B, 0xFA, 0xF3, + 0xB8, 0x50, 0x1C, 0x02, 0xC3, 0x95, 0xA0, 0x2A, + 0xA9, 0x75, 0x8F, 0xC4, 0x1E, 0xD4, 0xCF, 0x1C, + 0x7D, 0x10, 0xCE, 0x61, 0xD0, 0x89, 0x55, 0xD9, + 0x6C, 0xE5, 0x86, 0xC7, 0x79, 0x94, 0x0A, 0x19, + 0x6D, 0x4E, 0x47, 0x37, 0xA1, 0x40, 0x57, 0x6E, + 0xDB, 0x4F, 0x59, 0xC9, 0x6A, 0xFB, 0x65, 0x72, + 0x2A, 0x5F, 0x7A, 0x0C, 0x5C, 0x5D, 0x89, 0x25 + }, + { + 0x98, 0x3F, 0x65, 0x8A, 0xB6, 0x33, 0x50, 0x89, + 0x2D, 0xA7, 0x7D, 0xE6, 0x1D, 0xE5, 0x45, 0x8A, + 0x7D, 0x6D, 0xB0, 0x85, 0xDA, 0x35, 0x3C, 0xEF, + 0x31, 0x80, 0x06, 0x98, 0x31, 0x2D, 0x2D, 0xBF, + 0x52, 0xC7, 0xB7, 0x29, 0x04, 0xDF, 0x5E, 0x03, + 0xD6, 0xB5, 0x6B, 0x07, 0x15, 0xFF, 0x5A, 0x24, + 0x52, 0x9B, 0xC1, 0x68, 0x38, 0x4E, 0xAB, 0x07, + 0x78, 0x1F, 0x50, 0xDB, 0xFC, 0x1E, 0xF5, 0x78 + }, + { + 0x24, 0xCB, 0x89, 0x6A, 0x09, 0x11, 0x3D, 0xA7, + 0xCA, 0x7F, 0x1D, 0xE7, 0xFD, 0xDD, 0x57, 0x99, + 0x77, 0xF2, 0x1A, 0x6C, 0x39, 0x60, 0x15, 0x7C, + 0xDF, 0x5A, 0xA7, 0x50, 0x3A, 0x24, 0x39, 0x85, + 0x24, 0xE1, 0x65, 0x58, 0x63, 0x7E, 0x3F, 0x19, + 0xED, 0xB1, 0xB6, 0xFC, 0x31, 0xB6, 0x86, 0xC5, + 0x76, 0xCA, 0xA2, 0x73, 0xC8, 0xE9, 0xD0, 0xFF, + 0x61, 0x4B, 0x2D, 0x89, 0x12, 0x5F, 0x85, 0x86 + }, + { + 0x8E, 0x19, 0x3D, 0xA7, 0xAE, 0x99, 0x41, 0x8B, + 0xCF, 0xB1, 0xA2, 0x8E, 0x56, 0x50, 0x31, 0xFF, + 0x2B, 0xEB, 0x70, 0x9B, 0xC2, 0x0F, 0x43, 0x7A, + 0x40, 0xCE, 0xB5, 0xEB, 0x63, 0xAE, 0x59, 0x35, + 0x50, 0x12, 0xFF, 0x48, 0x4B, 0xD0, 0x5C, 0x4B, + 0x7B, 0xE8, 0x24, 0xB0, 0x44, 0xEB, 0x93, 0x57, + 0x73, 0xA7, 0xB6, 0x4E, 0xD8, 0x01, 0xBD, 0x28, + 0xA9, 0x6A, 0xBB, 0x91, 0xF1, 0x29, 0x2D, 0x81 + }, + { + 0x14, 0xFE, 0x0C, 0xDD, 0xB0, 0x1B, 0x7A, 0x79, + 0x55, 0xE4, 0x35, 0x3D, 0x97, 0x0A, 0x4F, 0x19, + 0x61, 0x54, 0x42, 0x0E, 0x45, 0x1E, 0x1A, 0x06, + 0x1F, 0x9D, 0x6C, 0x80, 0x87, 0xEC, 0x8F, 0x1E, + 0x4D, 0xD0, 0xD9, 0x72, 0xFA, 0x5C, 0x0E, 0x65, + 0x23, 0x71, 0x68, 0xB9, 0x32, 0x8D, 0x32, 0xE2, + 0x96, 0x38, 0x17, 0x4C, 0xD4, 0x24, 0x72, 0x3E, + 0x93, 0x08, 0xD5, 0x11, 0xFF, 0xD7, 0xAD, 0xA7 + }, + { + 0xEB, 0x33, 0x20, 0x4A, 0x79, 0xDD, 0xE6, 0xB0, + 0x41, 0x10, 0x63, 0x71, 0xF8, 0x0A, 0xED, 0xD8, + 0x9E, 0xAD, 0x80, 0xC2, 0x77, 0xF2, 0xC7, 0xF1, + 0xDD, 0x0F, 0x02, 0x73, 0xD7, 0x0F, 0x8C, 0x18, + 0x75, 0xF0, 0x43, 0xEA, 0xA6, 0x61, 0x66, 0x38, + 0x35, 0x2B, 0x83, 0x55, 0xC7, 0xBC, 0x1D, 0x23, + 0x80, 0x19, 0xB0, 0x67, 0x51, 0x66, 0x19, 0x50, + 0x85, 0x2A, 0xEA, 0x16, 0x69, 0xF0, 0x6B, 0xC6 + }, + { + 0x9A, 0x01, 0x88, 0xF3, 0xE3, 0xA1, 0x2B, 0xB4, + 0x22, 0x2F, 0x37, 0x7F, 0xA2, 0xFD, 0x01, 0xFB, + 0x56, 0x41, 0xD1, 0x22, 0xDC, 0xC1, 0xD5, 0xC4, + 0x55, 0x95, 0xD3, 0x1C, 0x01, 0xD1, 0xD8, 0xFD, + 0xE5, 0xE6, 0xFB, 0x06, 0xE7, 0xCA, 0xED, 0x28, + 0x40, 0x0C, 0x62, 0x95, 0x4D, 0x8C, 0xDE, 0x9A, + 0xA5, 0xBA, 0xC4, 0x4B, 0x7F, 0x5E, 0xCC, 0x29, + 0x03, 0x61, 0xD4, 0xAF, 0xBA, 0x16, 0x2F, 0xA1 + }, + { + 0xA3, 0xE1, 0xA1, 0x4F, 0x43, 0x63, 0x79, 0x4E, + 0x30, 0x46, 0x91, 0x81, 0xC3, 0x6B, 0x71, 0x5C, + 0xE6, 0x1F, 0x68, 0xA5, 0xCE, 0x75, 0xEA, 0x28, + 0xD8, 0xCD, 0x19, 0x2D, 0x59, 0xBB, 0xDF, 0x07, + 0x31, 0x14, 0x06, 0xFF, 0x68, 0x94, 0xF0, 0x55, + 0x7F, 0x04, 0xAC, 0x97, 0xA0, 0xF1, 0xF5, 0x0B, + 0x1A, 0xDA, 0x23, 0xE1, 0xBE, 0x70, 0x7C, 0x77, + 0x6C, 0xED, 0x6F, 0x92, 0x55, 0x25, 0xC2, 0x04 + }, + { + 0x70, 0x04, 0x9C, 0x26, 0xAB, 0x89, 0x7B, 0xF8, + 0xC8, 0x96, 0x85, 0xE3, 0xD8, 0x48, 0x2F, 0x84, + 0xEA, 0x76, 0x0D, 0x77, 0x9E, 0xE1, 0x77, 0x02, + 0x73, 0xAB, 0x62, 0x4B, 0xC4, 0xB0, 0x8F, 0x1C, + 0xD6, 0x12, 0x26, 0x96, 0x00, 0xE2, 0xD9, 0xB8, + 0x40, 0xBC, 0x48, 0x42, 0x16, 0x4F, 0x6A, 0x2B, + 0x0E, 0x23, 0x0E, 0x08, 0x1A, 0x8B, 0x49, 0x21, + 0xEB, 0x99, 0x21, 0x8C, 0xD1, 0x9A, 0x80, 0x16 + }, + { + 0xE0, 0xA4, 0xED, 0xAB, 0x2B, 0xFD, 0x08, 0x4A, + 0x58, 0x40, 0xB2, 0xC6, 0x43, 0xF6, 0xF3, 0xDC, + 0xB1, 0xFD, 0xA6, 0xAE, 0x88, 0xED, 0x02, 0x12, + 0xDC, 0x8D, 0xC5, 0xE4, 0xDF, 0xB2, 0x0E, 0xD3, + 0x98, 0x1C, 0x55, 0xD7, 0x37, 0x1A, 0xFC, 0x95, + 0xBA, 0x0E, 0x91, 0x15, 0xAF, 0x66, 0x03, 0x0E, + 0x5E, 0x86, 0x2F, 0xEA, 0x95, 0xF5, 0x87, 0xD6, + 0xB0, 0xDF, 0xA1, 0x85, 0x37, 0x83, 0x25, 0x62 + }, + { + 0x0D, 0x45, 0x8C, 0xF3, 0x98, 0x1A, 0x49, 0x65, + 0x61, 0x92, 0xA5, 0x6F, 0x58, 0xEA, 0x9C, 0x4C, + 0x91, 0x26, 0xAB, 0xDC, 0x86, 0x5A, 0x24, 0x11, + 0x84, 0x1A, 0xE7, 0xC6, 0x18, 0xB5, 0x91, 0xBC, + 0x7F, 0xE1, 0xE3, 0x71, 0x42, 0xD7, 0x96, 0xF1, + 0xA1, 0xED, 0x76, 0xA5, 0x59, 0xDE, 0x50, 0xB6, + 0xFF, 0x20, 0x02, 0x7E, 0x44, 0x09, 0xA1, 0x93, + 0x66, 0x5A, 0xB3, 0x49, 0xDD, 0x9A, 0x8E, 0xB3 + }, + { + 0xB8, 0x29, 0x2F, 0x24, 0x63, 0x7A, 0x30, 0x2D, + 0xD4, 0x6E, 0xC8, 0xEF, 0x5D, 0x3F, 0x01, 0x8F, + 0xDE, 0x9A, 0x62, 0xD8, 0x44, 0x10, 0xD9, 0xD3, + 0x50, 0x5E, 0x1A, 0x7F, 0x1A, 0xA7, 0xF6, 0xFF, + 0x1E, 0xFC, 0x81, 0xB5, 0xBB, 0xC0, 0xAA, 0xDF, + 0x09, 0x91, 0x1D, 0x59, 0x81, 0x7E, 0x9F, 0xF8, + 0x8C, 0xDB, 0x74, 0xAF, 0xB0, 0x11, 0xDB, 0xC4, + 0x94, 0x3B, 0x11, 0xB7, 0x24, 0xA1, 0xA3, 0xE4 + }, + { + 0x6C, 0xF2, 0xE6, 0xF8, 0xE6, 0xEA, 0xF4, 0xE1, + 0xB6, 0x47, 0x69, 0x12, 0x15, 0xCD, 0xCC, 0xE1, + 0x74, 0xE4, 0x2A, 0x34, 0x09, 0x72, 0x6A, 0x7B, + 0xC8, 0x41, 0x2E, 0x28, 0xBD, 0x57, 0x45, 0xCD, + 0x84, 0x89, 0xD7, 0x08, 0x58, 0xA3, 0xFF, 0x58, + 0x88, 0xFB, 0x55, 0x91, 0x20, 0x58, 0x48, 0x11, + 0x7F, 0x34, 0x73, 0xA2, 0xD4, 0x71, 0xAE, 0xF8, + 0x0C, 0xD4, 0xAC, 0xC8, 0x3F, 0xB4, 0x05, 0xE2 + }, + { + 0x30, 0x04, 0xD0, 0x16, 0xCC, 0x89, 0x1A, 0xA2, + 0x56, 0x40, 0x71, 0xB6, 0xFF, 0xB8, 0x35, 0x40, + 0xD7, 0x73, 0xE2, 0x53, 0x0F, 0x59, 0xC6, 0xCC, + 0x67, 0xEA, 0xFA, 0x8E, 0x23, 0x62, 0x4C, 0xDC, + 0x3C, 0xBA, 0x92, 0x9A, 0x72, 0x0E, 0xF6, 0xD4, + 0x67, 0x53, 0x77, 0x94, 0x9F, 0x75, 0xEA, 0xF0, + 0x3D, 0x15, 0x67, 0x09, 0xF1, 0x7B, 0x57, 0x6F, + 0x1B, 0xA0, 0x8D, 0x49, 0xA7, 0x59, 0x4C, 0x77 + }, + { + 0x73, 0x24, 0xD0, 0x99, 0xFA, 0x38, 0x0D, 0xD0, + 0xE8, 0x11, 0x4C, 0x91, 0xE4, 0xBC, 0xD3, 0x81, + 0x20, 0x0B, 0xDF, 0x5D, 0x5A, 0x68, 0x52, 0x14, + 0x7E, 0x21, 0x98, 0xFB, 0xDD, 0xD2, 0x2D, 0x18, + 0xCA, 0xFD, 0x0C, 0xEB, 0xA5, 0x44, 0xB0, 0x41, + 0x13, 0x5F, 0x4D, 0x5F, 0x52, 0x29, 0x12, 0xE6, + 0xDD, 0x17, 0xF9, 0xB7, 0xCB, 0x84, 0x4D, 0xB2, + 0x3B, 0x88, 0xFB, 0xA6, 0x0B, 0x41, 0x84, 0x10 + }, + { + 0xAC, 0x59, 0xEA, 0xA1, 0x86, 0xD1, 0x8F, 0x0A, + 0x3B, 0x81, 0x52, 0x0E, 0x86, 0x76, 0x2C, 0x08, + 0xAE, 0x55, 0x3B, 0xFE, 0x71, 0x6B, 0x78, 0x67, + 0x75, 0x6A, 0x70, 0x70, 0x6C, 0xF2, 0x48, 0x0C, + 0xB8, 0xED, 0x7E, 0xC6, 0x70, 0xE1, 0x15, 0xB4, + 0x18, 0x66, 0xBC, 0x2C, 0xD5, 0x82, 0x04, 0x65, + 0x6E, 0x2F, 0x77, 0x6C, 0xDD, 0x51, 0x0B, 0x54, + 0xCF, 0x58, 0xA0, 0xBC, 0xF1, 0x65, 0x17, 0x40 + }, + { + 0xCC, 0xE8, 0x77, 0xED, 0x9C, 0x81, 0x8C, 0xF1, + 0x87, 0x70, 0xA6, 0xEB, 0x54, 0xC7, 0xFB, 0x48, + 0x6B, 0xFD, 0xB0, 0x73, 0x56, 0x26, 0x5F, 0x4A, + 0xF0, 0x9F, 0xC5, 0x40, 0xDF, 0x29, 0xBC, 0x74, + 0xC8, 0xF9, 0x21, 0x79, 0xC6, 0x49, 0xE6, 0xB9, + 0xF5, 0x78, 0x9B, 0x61, 0xEA, 0x7D, 0xE9, 0x71, + 0x66, 0xEE, 0xEE, 0xD4, 0xD5, 0x20, 0xFE, 0xCF, + 0x8C, 0xBE, 0xEC, 0xA6, 0xC7, 0x85, 0x36, 0x3E + }, + { + 0xFE, 0x6C, 0x56, 0x52, 0xA2, 0x21, 0xDE, 0xD0, + 0x5C, 0x00, 0xAC, 0x60, 0x8B, 0x44, 0xD4, 0x81, + 0x7D, 0xDE, 0x7A, 0x72, 0x45, 0x42, 0x9C, 0x54, + 0x66, 0xC8, 0xDC, 0x0A, 0x46, 0x04, 0x23, 0xCF, + 0xEE, 0x9C, 0xE8, 0x4B, 0xE4, 0x3A, 0xD9, 0x87, + 0x25, 0x47, 0xC0, 0x7A, 0xE1, 0xB3, 0x31, 0x02, + 0xDF, 0x31, 0x9E, 0x5E, 0xC5, 0xF5, 0x55, 0x48, + 0x4E, 0x8C, 0x5C, 0xDD, 0xDE, 0x0E, 0x23, 0xC7 + }, + { + 0xA8, 0x3C, 0x9F, 0x37, 0x16, 0x1C, 0x47, 0x19, + 0x4C, 0x40, 0x54, 0x86, 0x5D, 0x07, 0x04, 0xAB, + 0x79, 0xD9, 0xFF, 0x02, 0xC9, 0x20, 0x81, 0xFB, + 0xC3, 0xC4, 0x84, 0x23, 0x33, 0x79, 0xCA, 0x4D, + 0xC3, 0x12, 0x12, 0x3A, 0xAD, 0xB3, 0x6C, 0x97, + 0xAF, 0x13, 0x99, 0x6B, 0xDC, 0x6A, 0x67, 0xDA, + 0x27, 0xB0, 0x84, 0x8F, 0xFE, 0x10, 0xA1, 0xEE, + 0xF0, 0x6F, 0x4E, 0x76, 0xCC, 0xAA, 0x1A, 0x07 + }, + { + 0xBA, 0xF4, 0xFF, 0x21, 0x3A, 0xDC, 0x87, 0x11, + 0xCB, 0x75, 0x82, 0x5A, 0x05, 0xF4, 0xD8, 0x2F, + 0x0F, 0x77, 0x8C, 0x4E, 0x84, 0x21, 0x65, 0x9A, + 0x79, 0x6B, 0xAC, 0x59, 0x0E, 0x4B, 0x86, 0x1F, + 0x69, 0x6B, 0xAB, 0xBE, 0x51, 0x7C, 0xF8, 0xA5, + 0x34, 0x62, 0x1E, 0xF7, 0x11, 0x51, 0x6A, 0x79, + 0x89, 0x67, 0xC3, 0x66, 0x47, 0xE5, 0xB7, 0xBC, + 0xE9, 0x14, 0x29, 0x5C, 0xA4, 0xAE, 0xA7, 0x8D + }, + { + 0x21, 0x59, 0x93, 0x04, 0xE6, 0x9D, 0x82, 0x0A, + 0xD6, 0xF0, 0xF9, 0x01, 0x08, 0x99, 0x87, 0x1E, + 0xB4, 0x0A, 0xA5, 0xFB, 0x62, 0xA6, 0xED, 0x4C, + 0x4A, 0x67, 0x2C, 0x11, 0xC1, 0x93, 0x29, 0xEF, + 0x83, 0xAD, 0x50, 0xC7, 0xD3, 0x69, 0xCB, 0x37, + 0x6B, 0xE7, 0xCF, 0xC5, 0xD3, 0x4A, 0x6D, 0x21, + 0xAD, 0xA1, 0xC1, 0x5E, 0x57, 0xE4, 0xEB, 0x23, + 0xA8, 0x9C, 0x4A, 0x5A, 0xC7, 0x5D, 0xDB, 0x01 + }, + { + 0xF0, 0xE3, 0xC6, 0x8E, 0x86, 0x80, 0x6D, 0x3F, + 0x79, 0x39, 0xED, 0x12, 0x25, 0x36, 0x06, 0x67, + 0x59, 0xC8, 0xAE, 0x21, 0x41, 0x70, 0x15, 0x35, + 0xC6, 0x9D, 0x42, 0xEC, 0xFB, 0x37, 0x72, 0xCF, + 0xAC, 0x23, 0xBC, 0x24, 0xDC, 0xB6, 0x51, 0x3C, + 0xD1, 0xFB, 0x5B, 0xFC, 0xFE, 0x18, 0xC5, 0x0B, + 0x9C, 0x06, 0x8A, 0xE9, 0xF0, 0x6F, 0xF8, 0xC3, + 0x76, 0x0A, 0x22, 0xBF, 0x38, 0xD0, 0x59, 0x63 + }, + { + 0x1F, 0x25, 0xCE, 0xA2, 0xB1, 0x3D, 0x91, 0x83, + 0xFE, 0x06, 0xC6, 0x91, 0x42, 0x36, 0x6C, 0x37, + 0xC6, 0xCA, 0x53, 0x1B, 0xAC, 0x75, 0xBB, 0x03, + 0x86, 0x8F, 0x19, 0x81, 0xED, 0x28, 0x56, 0xE1, + 0x66, 0x50, 0x9F, 0x90, 0x5C, 0xC9, 0x63, 0x21, + 0x93, 0xDE, 0xF2, 0x2C, 0x21, 0x3F, 0x5E, 0xEB, + 0x54, 0x4F, 0xD9, 0xBE, 0x3F, 0x80, 0x92, 0xB7, + 0x42, 0x53, 0xCC, 0x69, 0xBB, 0x8A, 0x96, 0xAA + }, + { + 0x2C, 0x51, 0x67, 0x89, 0x28, 0xA5, 0x01, 0xC5, + 0xFA, 0xEC, 0x97, 0xAC, 0x0A, 0x47, 0xE7, 0x65, + 0x0B, 0x40, 0x1B, 0xFC, 0xB6, 0xC7, 0xA7, 0x9C, + 0x63, 0xB4, 0x6B, 0x6B, 0x13, 0xEC, 0xC3, 0x0C, + 0xEF, 0x7A, 0x84, 0xD1, 0x49, 0xC0, 0x55, 0xAA, + 0x6C, 0xD0, 0x7D, 0xCE, 0x9F, 0x6D, 0x43, 0x9B, + 0x7D, 0xE1, 0xD5, 0x7C, 0x42, 0x54, 0x00, 0x37, + 0x1C, 0xA0, 0x02, 0x23, 0x05, 0x35, 0x70, 0x4F + }, + { + 0x84, 0x86, 0x78, 0xB3, 0xF6, 0x23, 0xC5, 0x40, + 0x94, 0x19, 0xD7, 0xC0, 0xFD, 0xC7, 0xB8, 0x60, + 0x69, 0xA8, 0xE7, 0xAA, 0x32, 0x65, 0x89, 0xD0, + 0x01, 0xE3, 0x16, 0x68, 0xD1, 0xD5, 0x8E, 0x86, + 0x3B, 0xD8, 0x33, 0xCB, 0x62, 0xE6, 0x5E, 0xC7, + 0xD9, 0x37, 0x39, 0x20, 0xEC, 0x43, 0xE2, 0xDA, + 0xF7, 0xD2, 0xE8, 0xAA, 0x7E, 0x66, 0xCC, 0x0D, + 0x57, 0xCF, 0xE2, 0x0C, 0xDA, 0x9D, 0xA4, 0x12 + }, + { + 0xEE, 0x75, 0x9D, 0xA9, 0x19, 0x67, 0xD0, 0x6E, + 0xEE, 0x81, 0xDB, 0xCD, 0x48, 0x7C, 0xA4, 0x33, + 0x2B, 0x21, 0xE2, 0x64, 0xF2, 0x1F, 0xEB, 0x8E, + 0x28, 0xFC, 0x6C, 0xA9, 0x56, 0xD8, 0x81, 0xAE, + 0x1E, 0x7B, 0x26, 0x61, 0x2B, 0xAD, 0xB4, 0x9C, + 0x75, 0x7F, 0xC3, 0xB8, 0x53, 0x2A, 0x2B, 0x46, + 0x07, 0x81, 0x05, 0x76, 0xF5, 0x9D, 0x2E, 0x9B, + 0xAF, 0xD0, 0xEA, 0xC4, 0x98, 0x15, 0x54, 0xB3 + }, + { + 0x36, 0x44, 0x02, 0xA3, 0xFA, 0x5B, 0xA1, 0x18, + 0xA3, 0x2F, 0xE0, 0x41, 0xA3, 0x23, 0x8E, 0x4E, + 0x66, 0xFE, 0x55, 0xB2, 0x83, 0x43, 0x88, 0x02, + 0xCE, 0x3C, 0x46, 0xE4, 0x46, 0x9B, 0x82, 0x05, + 0xC4, 0x68, 0xFD, 0x64, 0xD6, 0x0E, 0xDB, 0xBE, + 0xBE, 0x82, 0x33, 0x04, 0x24, 0xA4, 0x53, 0xFA, + 0x2D, 0x12, 0x17, 0x49, 0xDD, 0xA4, 0x11, 0x15, + 0x76, 0xF0, 0x05, 0xFD, 0x6D, 0x8D, 0x25, 0x46 + }, + { + 0x6F, 0xBC, 0x4F, 0x21, 0x1C, 0x3D, 0xBD, 0x6E, + 0x84, 0x7F, 0x62, 0x7B, 0xD2, 0x40, 0xCA, 0xCE, + 0x95, 0xC8, 0xAC, 0xE5, 0x19, 0x50, 0x04, 0xD5, + 0xA8, 0xCE, 0xD9, 0xAB, 0x1B, 0x21, 0xBA, 0xC6, + 0x41, 0x2D, 0xFE, 0xBD, 0x13, 0xA7, 0xFB, 0xA9, + 0xB6, 0x3D, 0xD0, 0x86, 0x13, 0x16, 0xC1, 0x82, + 0xC6, 0x69, 0x2B, 0xD2, 0x54, 0x48, 0x4C, 0xD8, + 0xA9, 0x88, 0x87, 0x8F, 0x2A, 0x90, 0x91, 0x53 + }, + { + 0x7E, 0xA3, 0xE0, 0x73, 0xC0, 0xB8, 0x46, 0xD8, + 0x2C, 0x8B, 0xE6, 0xDF, 0x67, 0x41, 0xCE, 0xE0, + 0x70, 0x93, 0x3D, 0xF9, 0xEC, 0x0C, 0x7C, 0xAB, + 0x49, 0x59, 0x13, 0x6C, 0x1D, 0xC9, 0x1C, 0x48, + 0x00, 0x7E, 0x64, 0xDE, 0x1D, 0x3B, 0x4D, 0xB3, + 0xB0, 0x11, 0xDE, 0x9A, 0x4A, 0xDA, 0x06, 0x67, + 0xD2, 0xA4, 0x1A, 0x52, 0x3A, 0xC7, 0xE4, 0x68, + 0xE6, 0xC6, 0x40, 0xEB, 0xF2, 0x6D, 0xF7, 0x74 + }, + { + 0x5B, 0x24, 0x7D, 0xB6, 0x4B, 0x16, 0x7D, 0x01, + 0xCF, 0x11, 0x7D, 0x86, 0x89, 0x62, 0x33, 0x11, + 0x47, 0x60, 0x3D, 0x48, 0x5D, 0x93, 0x83, 0xB8, + 0xC6, 0x00, 0xBB, 0x3C, 0x95, 0xF7, 0x2D, 0xB3, + 0xEF, 0xEE, 0x2F, 0x03, 0xDD, 0x99, 0x17, 0x82, + 0xD4, 0x3F, 0x43, 0xFF, 0xD2, 0xA6, 0x0E, 0x68, + 0xC9, 0x9D, 0x41, 0x10, 0x41, 0x5C, 0x76, 0xFE, + 0xEE, 0x3C, 0x95, 0x23, 0x39, 0x34, 0xCA, 0x81 + }, + { + 0x8D, 0xD9, 0xE6, 0x4C, 0x1E, 0xC8, 0xE2, 0x05, + 0xAF, 0xA7, 0xC8, 0xA7, 0xB0, 0x9E, 0x5F, 0x36, + 0xC6, 0x07, 0xE7, 0x99, 0x00, 0x4B, 0x67, 0xC4, + 0x6C, 0x43, 0xF8, 0x8E, 0xB8, 0x3E, 0x35, 0xD4, + 0x1C, 0xFD, 0xC9, 0xB4, 0xBE, 0xD0, 0x3F, 0xA2, + 0xFD, 0xB5, 0xA2, 0x1C, 0x34, 0xBB, 0x80, 0xC9, + 0xE6, 0x48, 0x6A, 0xBE, 0x90, 0xB8, 0x52, 0x42, + 0x66, 0xD1, 0xAC, 0xEE, 0xCC, 0xC0, 0xAC, 0x8C + }, + { + 0x50, 0xED, 0x55, 0x89, 0xA1, 0x17, 0xF6, 0x8C, + 0x14, 0x9A, 0xAF, 0x3C, 0x32, 0xFA, 0xE6, 0xB7, + 0x93, 0xD9, 0xAA, 0x9B, 0x34, 0x6A, 0xEA, 0x6D, + 0xE9, 0xAD, 0x92, 0x9F, 0x0D, 0xD8, 0xA5, 0xA1, + 0xF4, 0x58, 0x5F, 0x37, 0x1B, 0xC5, 0x5B, 0xE2, + 0x41, 0x05, 0x24, 0xB9, 0x90, 0x2B, 0xC1, 0x35, + 0xA3, 0xFE, 0xD5, 0x0D, 0xC1, 0x98, 0x40, 0x93, + 0x20, 0x71, 0x81, 0xAC, 0x39, 0x3E, 0x4A, 0xE5 + }, + { + 0x92, 0x05, 0x15, 0xCC, 0x95, 0x8D, 0x72, 0x3B, + 0x73, 0x0A, 0x31, 0x00, 0xFB, 0x1B, 0xB0, 0x9F, + 0x3B, 0x7F, 0x6E, 0xAF, 0x04, 0x0C, 0xA5, 0xA8, + 0x8E, 0x87, 0x35, 0x9B, 0x82, 0x9B, 0x46, 0xE8, + 0x99, 0xFE, 0x7F, 0x01, 0xF7, 0xD4, 0xCD, 0xF2, + 0x8E, 0x2A, 0x49, 0x11, 0x53, 0xA8, 0xCE, 0xFA, + 0xD9, 0x6A, 0x40, 0x8C, 0xF7, 0x5F, 0x6D, 0x23, + 0xF1, 0x0F, 0x7F, 0xDC, 0x8D, 0x9A, 0xE1, 0xEA + }, + { + 0xD5, 0x85, 0x7B, 0x33, 0xD5, 0x57, 0x11, 0x35, + 0xC5, 0x1A, 0x4C, 0xA7, 0xD4, 0x67, 0xB0, 0x44, + 0xF2, 0xD7, 0x72, 0x8A, 0x3B, 0x38, 0x64, 0x0E, + 0xEB, 0xC7, 0x6E, 0x72, 0x66, 0x8D, 0x99, 0xEF, + 0x2C, 0xE1, 0xAE, 0x3D, 0x04, 0x80, 0x48, 0xBE, + 0x3E, 0xAC, 0x3E, 0x78, 0x77, 0x89, 0x74, 0x4A, + 0x3D, 0x1C, 0xBB, 0x57, 0x28, 0xC0, 0xFB, 0x7A, + 0xE9, 0xD5, 0x68, 0x90, 0x15, 0x04, 0xC3, 0xF6 + }, + { + 0x87, 0x75, 0xD8, 0xA4, 0x27, 0xC1, 0xF7, 0x78, + 0xC4, 0x4D, 0xCB, 0x98, 0xF5, 0x6E, 0x11, 0x21, + 0xE9, 0xD3, 0xC8, 0x97, 0x43, 0x71, 0x62, 0x44, + 0xC6, 0x0B, 0xE6, 0x4B, 0x6C, 0x80, 0x1A, 0xC9, + 0xB5, 0x28, 0x4C, 0x0D, 0x61, 0x08, 0x1B, 0x03, + 0xED, 0x1A, 0xE3, 0xA0, 0x60, 0x1B, 0xAF, 0x29, + 0x20, 0x37, 0x66, 0xD3, 0x2F, 0x2B, 0xB1, 0xDE, + 0x52, 0x74, 0xCA, 0x5F, 0x76, 0x7A, 0xDB, 0x21 + }, + { + 0x52, 0xF8, 0x58, 0x4B, 0x78, 0xBE, 0xC7, 0xE7, + 0x0F, 0xCF, 0xBF, 0xEB, 0x0E, 0xEE, 0xC3, 0xA9, + 0xA8, 0x8F, 0xE9, 0xD7, 0xCB, 0xD6, 0xAC, 0x06, + 0x5D, 0x95, 0x48, 0x35, 0x67, 0xC9, 0x2E, 0xAF, + 0x39, 0x88, 0x44, 0xAC, 0xD0, 0x00, 0xDD, 0xBF, + 0x13, 0xCB, 0x18, 0xDD, 0x95, 0x42, 0xCF, 0xDC, + 0x38, 0xB4, 0x58, 0xB6, 0xEC, 0x19, 0xA7, 0x4A, + 0x25, 0xE4, 0x44, 0x54, 0x0E, 0xC8, 0x55, 0xCF + }, + { + 0xB2, 0x3A, 0xAA, 0xDA, 0x85, 0x9E, 0x7A, 0xF2, + 0x48, 0xAB, 0x99, 0x6F, 0x64, 0x3B, 0xD7, 0x9A, + 0x0C, 0xF0, 0x8B, 0x81, 0xBA, 0x5D, 0xC6, 0x94, + 0x34, 0x19, 0xD9, 0x40, 0x9F, 0x77, 0xD1, 0x3E, + 0x2A, 0x00, 0x92, 0x44, 0x52, 0xEA, 0xB2, 0x61, + 0x32, 0x6B, 0x04, 0x13, 0xFA, 0x35, 0x6F, 0xA0, + 0x05, 0x3A, 0x38, 0xCE, 0xE1, 0xCE, 0x3B, 0x28, + 0x38, 0xF7, 0x1F, 0xE2, 0xFB, 0x16, 0x49, 0xBC + }, + { + 0x82, 0x96, 0x60, 0x93, 0xEF, 0x67, 0xC9, 0x87, + 0xC2, 0x10, 0x5D, 0x62, 0x5E, 0xD0, 0xA5, 0x36, + 0x59, 0x35, 0xEF, 0x7D, 0xE0, 0xD6, 0x47, 0xC1, + 0x6E, 0x52, 0x42, 0xB7, 0x89, 0x8F, 0xC9, 0xBF, + 0xBA, 0x49, 0xCF, 0xA9, 0x37, 0xD1, 0x9E, 0xA0, + 0x44, 0xBE, 0x00, 0xC4, 0x9D, 0x19, 0x2D, 0x02, + 0xE4, 0xB4, 0x5A, 0xC6, 0xF8, 0xBA, 0xCE, 0xFC, + 0x75, 0xD5, 0x23, 0xBC, 0xD2, 0x59, 0x45, 0x9D + }, + { + 0xE1, 0xC5, 0x79, 0x06, 0xE5, 0xC4, 0x46, 0x4E, + 0x3B, 0x3C, 0xAE, 0x07, 0x3B, 0x15, 0x15, 0x8F, + 0xD4, 0x89, 0xF1, 0xE0, 0x9C, 0x7A, 0x6E, 0x6A, + 0x18, 0x89, 0x5B, 0x45, 0x26, 0xAF, 0xF5, 0x05, + 0x86, 0x33, 0x47, 0x4F, 0x5F, 0xB4, 0x0E, 0xA1, + 0xA9, 0x1C, 0x9D, 0xD6, 0x96, 0x77, 0x8F, 0x4C, + 0x75, 0x77, 0x43, 0xA2, 0x60, 0xA2, 0xC7, 0x58, + 0x63, 0x73, 0x8F, 0x4E, 0xAC, 0xF2, 0x7E, 0x53 + }, + { + 0x0B, 0x6A, 0xA3, 0x39, 0x72, 0xF4, 0x9A, 0xDA, + 0xF6, 0x04, 0xB6, 0x0A, 0xC1, 0x01, 0x1D, 0x69, + 0x41, 0xC8, 0x4B, 0x89, 0x16, 0x44, 0x0E, 0xF8, + 0xF1, 0x73, 0x55, 0x86, 0xC0, 0x13, 0xE3, 0x05, + 0x55, 0x5B, 0x9A, 0x80, 0xAB, 0xB3, 0x59, 0xE5, + 0xCA, 0x21, 0xC8, 0xBB, 0x1B, 0x47, 0xAE, 0x1C, + 0xA3, 0x9C, 0x37, 0x96, 0x11, 0x0B, 0x7B, 0x35, + 0x4F, 0x85, 0xC5, 0x61, 0x9B, 0xFD, 0xC8, 0x7B + }, + { + 0xD4, 0x6E, 0x80, 0xCA, 0xA9, 0xDC, 0xF0, 0x55, + 0xF0, 0xFE, 0xD6, 0x1B, 0x2D, 0x34, 0x6D, 0xCA, + 0xDA, 0x7D, 0x2C, 0x66, 0x6A, 0xCA, 0x3F, 0xEA, + 0x7B, 0x3C, 0x9B, 0xDD, 0xF6, 0x26, 0x28, 0xEC, + 0x7A, 0x49, 0xA7, 0xF5, 0x64, 0xBF, 0x36, 0xB2, + 0x07, 0x43, 0x36, 0x41, 0x9E, 0x6E, 0xE1, 0xD9, + 0x5F, 0xFB, 0xD1, 0xA7, 0xFA, 0xD7, 0xE1, 0x26, + 0x37, 0x36, 0xCA, 0x19, 0x88, 0xD3, 0x48, 0x31 + }, + { + 0xAA, 0x10, 0x47, 0xC7, 0x75, 0xB8, 0xE9, 0x59, + 0x7C, 0x4A, 0xE9, 0x99, 0x52, 0x4A, 0xE9, 0xC0, + 0x93, 0xD2, 0x34, 0xE2, 0xAF, 0x02, 0x81, 0x22, + 0x7B, 0x9E, 0x12, 0x9A, 0x61, 0x36, 0x6B, 0x68, + 0x26, 0x2F, 0x70, 0x65, 0x4D, 0xD0, 0x6A, 0xB2, + 0x77, 0x4D, 0xC6, 0x6C, 0x30, 0xA5, 0xC6, 0x03, + 0xB5, 0xB6, 0x4D, 0x92, 0xA5, 0x4A, 0x26, 0x8D, + 0xCF, 0xD0, 0x01, 0x83, 0xE7, 0x8E, 0xAD, 0x4D + }, + { + 0x4C, 0x5A, 0x7D, 0x23, 0x19, 0xEE, 0xD1, 0x7B, + 0x6E, 0x35, 0x0B, 0xF1, 0xF3, 0x26, 0x2B, 0x16, + 0x22, 0x71, 0x87, 0x53, 0x66, 0xD9, 0x41, 0xEA, + 0xB1, 0x7B, 0x26, 0x3C, 0x7B, 0xA9, 0x29, 0xAE, + 0xF8, 0xC3, 0xD4, 0x95, 0x94, 0xB4, 0x7D, 0xE1, + 0xB3, 0xD3, 0x36, 0xE0, 0x8A, 0xBD, 0x42, 0x51, + 0xFC, 0x98, 0xFB, 0xCC, 0x81, 0x69, 0xDE, 0x61, + 0x90, 0x27, 0xBB, 0x2F, 0x83, 0x95, 0x68, 0xD6 + }, + { + 0x0C, 0xAE, 0xD1, 0x67, 0x9F, 0xA9, 0x0E, 0xCB, + 0xC1, 0xD1, 0x0A, 0x8A, 0x5D, 0x28, 0xE2, 0x15, + 0xF5, 0x72, 0xA5, 0xB7, 0x03, 0x53, 0xAC, 0x10, + 0xBC, 0xFD, 0x8F, 0x9A, 0x1F, 0x3B, 0xAF, 0x78, + 0x0D, 0x7F, 0xE4, 0x78, 0x7B, 0x83, 0xDD, 0xFC, + 0x8E, 0x19, 0xCB, 0x9C, 0x37, 0x86, 0xD4, 0xF0, + 0x95, 0x25, 0x9B, 0x78, 0xCA, 0x67, 0xA6, 0x40, + 0x69, 0x9C, 0x53, 0xDC, 0xC4, 0x48, 0x8B, 0x58 + }, + { + 0xA8, 0x14, 0x36, 0x46, 0xE7, 0x73, 0x30, 0xEB, + 0xE0, 0xE4, 0xEE, 0x6B, 0x03, 0x85, 0x36, 0xEF, + 0x55, 0x16, 0xD8, 0xAA, 0xB0, 0x20, 0x72, 0xF4, + 0xBE, 0xEA, 0x43, 0x5F, 0x7A, 0x87, 0xBB, 0x69, + 0xD6, 0x31, 0xE2, 0xCA, 0x67, 0xF7, 0x5D, 0x32, + 0xE7, 0x70, 0x3D, 0x4D, 0xB1, 0x24, 0x6D, 0x3B, + 0x7B, 0xFF, 0x43, 0xE1, 0xAC, 0x9F, 0xDF, 0xC9, + 0xFD, 0xF2, 0x9E, 0x40, 0x23, 0xFC, 0x34, 0x0D + }, + { + 0x5D, 0x27, 0x52, 0xD2, 0xBD, 0x51, 0xC3, 0x79, + 0xC0, 0xDF, 0x2B, 0xF3, 0x6F, 0x43, 0x67, 0x25, + 0xE5, 0x64, 0x43, 0x83, 0x55, 0x0B, 0x02, 0x5D, + 0x02, 0x02, 0xB4, 0x68, 0x14, 0xEC, 0x17, 0xB4, + 0x1E, 0xF0, 0xA8, 0x16, 0x92, 0x7B, 0xFC, 0x9C, + 0x87, 0x80, 0xCA, 0xAB, 0xE0, 0x85, 0xAF, 0x97, + 0x4C, 0xB7, 0x2E, 0x21, 0xEA, 0x79, 0xC7, 0x58, + 0x77, 0x0F, 0x47, 0x21, 0xDB, 0xED, 0x45, 0xE9 + }, + { + 0xED, 0x1C, 0x83, 0xF4, 0x1B, 0xC8, 0xB2, 0xEC, + 0x44, 0x7D, 0xD4, 0x2A, 0x98, 0x5F, 0x9D, 0xFD, + 0x5D, 0x43, 0x9E, 0xF6, 0x03, 0x0D, 0x1F, 0x56, + 0xF2, 0x11, 0xE8, 0x50, 0xC0, 0x17, 0x5D, 0x36, + 0x50, 0xE7, 0x37, 0x8F, 0xF7, 0x32, 0x29, 0xFF, + 0x22, 0x01, 0x80, 0x72, 0xAA, 0x00, 0xB5, 0x86, + 0xC5, 0x5D, 0x08, 0xA4, 0xB0, 0x53, 0x80, 0xCA, + 0xB5, 0x3A, 0x14, 0x7A, 0x00, 0xF7, 0x65, 0xB7 + }, + { + 0xE9, 0x1B, 0x63, 0x79, 0xAB, 0x2A, 0xCE, 0x91, + 0xE2, 0x5B, 0xF7, 0xC5, 0x20, 0xB8, 0x76, 0x50, + 0x65, 0x41, 0x0F, 0x73, 0x65, 0x1E, 0x71, 0xFB, + 0x78, 0xBD, 0x11, 0xC8, 0x81, 0x36, 0x4E, 0x26, + 0x3F, 0xDA, 0xC9, 0x5D, 0xFE, 0xDF, 0xD9, 0x77, + 0x75, 0x97, 0xC8, 0xCE, 0xF7, 0x5C, 0x83, 0xDC, + 0xDE, 0xEA, 0x21, 0xB1, 0x2D, 0xB4, 0x3A, 0x9B, + 0x80, 0x51, 0xA4, 0xF6, 0xA4, 0x24, 0x78, 0x41 + }, + { + 0xC3, 0x9C, 0x0E, 0xF0, 0xFE, 0x9A, 0x50, 0xBD, + 0xA4, 0x5F, 0xAD, 0x91, 0xCA, 0x14, 0x52, 0xCC, + 0xDC, 0xD7, 0x06, 0xC5, 0x68, 0x44, 0xFE, 0x56, + 0x58, 0xDA, 0x6C, 0x5A, 0xDC, 0x2F, 0xC4, 0x06, + 0x3C, 0x92, 0x53, 0x78, 0xA7, 0x63, 0x49, 0x9A, + 0x10, 0xF6, 0x3A, 0x6D, 0xC1, 0x06, 0x0A, 0xBB, + 0xCF, 0xC5, 0xB1, 0xBB, 0xD1, 0x97, 0x2B, 0xF0, + 0x36, 0xE0, 0x0C, 0x81, 0x0A, 0xDD, 0x0A, 0x42 + }, + { + 0xA5, 0x52, 0x1A, 0x98, 0xAD, 0xBC, 0x97, 0x29, + 0x28, 0x4F, 0x6D, 0xC8, 0x0A, 0x8B, 0x1A, 0xAA, + 0xC7, 0x6A, 0x72, 0xFE, 0x85, 0x62, 0x5F, 0xB0, + 0x65, 0x07, 0x67, 0x45, 0x90, 0x45, 0x1D, 0x4E, + 0x04, 0x5B, 0x79, 0x90, 0x22, 0x65, 0x4B, 0xAC, + 0xC9, 0xAD, 0x31, 0xC5, 0x44, 0x22, 0x5C, 0xCE, + 0x1B, 0xB6, 0x1D, 0x13, 0xDD, 0x27, 0x18, 0x39, + 0xC5, 0xC2, 0x6E, 0xCE, 0x03, 0xEC, 0x80, 0x0F + }, + { + 0xB7, 0xBB, 0x9E, 0x4B, 0xC5, 0x86, 0x9D, 0x5C, + 0x88, 0x3D, 0x15, 0x79, 0x9C, 0x38, 0xFC, 0x6C, + 0xB5, 0x00, 0x41, 0x18, 0x7D, 0xA9, 0x1E, 0xD9, + 0x06, 0x9D, 0x72, 0x2F, 0xF0, 0xEB, 0x3A, 0x8A, + 0x8B, 0xD6, 0x31, 0x78, 0x20, 0x4B, 0xA8, 0x72, + 0x8B, 0xC3, 0xAE, 0xB7, 0x64, 0xED, 0x20, 0xBA, + 0x4C, 0xF4, 0xAD, 0x24, 0x0E, 0x86, 0xD6, 0x66, + 0x5B, 0x6F, 0x8A, 0xCD, 0xA0, 0x03, 0x73, 0x5B + }, + { + 0x45, 0x72, 0x8A, 0xE5, 0x02, 0x9F, 0xFD, 0xF8, + 0xC4, 0x58, 0x61, 0xFB, 0x25, 0x31, 0xAC, 0x1D, + 0xD5, 0xBF, 0x54, 0x71, 0xAE, 0x90, 0xA7, 0x46, + 0x28, 0x03, 0x9B, 0x1E, 0x02, 0xA0, 0xD6, 0x4C, + 0xCC, 0xFB, 0xF2, 0x71, 0x94, 0x35, 0x4F, 0x0C, + 0xF4, 0x08, 0x46, 0xD2, 0xAC, 0x83, 0x09, 0x05, + 0x98, 0xF8, 0xD9, 0x92, 0x4B, 0x0A, 0x9E, 0xE9, + 0xF0, 0x6D, 0x12, 0xAC, 0xB8, 0x47, 0xE6, 0xF9 + }, + { + 0xFC, 0x4D, 0x30, 0x67, 0x11, 0x65, 0x74, 0xE4, + 0x25, 0x38, 0x01, 0x39, 0xEE, 0x7B, 0xCD, 0xED, + 0x36, 0x98, 0x4A, 0x71, 0xC6, 0xB3, 0x2B, 0x4C, + 0xA5, 0x5F, 0x7B, 0x64, 0x04, 0x53, 0x1B, 0xD9, + 0xEF, 0xAE, 0x3D, 0x75, 0x45, 0x14, 0xB5, 0x96, + 0xFE, 0x16, 0xC0, 0x34, 0xEA, 0xC1, 0x80, 0x3D, + 0x6D, 0xBF, 0x19, 0xE4, 0x67, 0xDB, 0xA1, 0x63, + 0x8F, 0x46, 0x64, 0x25, 0x1D, 0xC6, 0x6A, 0x0D + }, + { + 0xAF, 0xD8, 0x5F, 0xAD, 0xE4, 0x5E, 0x92, 0xDA, + 0x78, 0x57, 0x0C, 0x16, 0x7D, 0x67, 0xD0, 0xB5, + 0x09, 0xF9, 0xAA, 0x12, 0x1B, 0x86, 0x80, 0x1F, + 0x5B, 0xFD, 0x7B, 0x8B, 0x52, 0x0F, 0x45, 0xB9, + 0xFD, 0xCE, 0xF6, 0x5B, 0x95, 0xA8, 0x64, 0x20, + 0xBF, 0xE1, 0x0E, 0xC3, 0xB9, 0xD8, 0x30, 0x7A, + 0x91, 0xC4, 0x60, 0x4D, 0x38, 0x7F, 0x5D, 0x1E, + 0x3A, 0x61, 0xD5, 0x84, 0x3A, 0x53, 0x93, 0x30 + }, + { + 0x55, 0xF7, 0x80, 0x98, 0x4F, 0x83, 0xF3, 0x4E, + 0x7D, 0x08, 0x37, 0xA3, 0x19, 0x0C, 0xB5, 0x41, + 0x28, 0x4F, 0x38, 0xB6, 0x0A, 0x1A, 0xD3, 0x3F, + 0x1A, 0xCE, 0xF5, 0xF1, 0x17, 0x75, 0x68, 0xAD, + 0x80, 0xD4, 0x2B, 0x47, 0x64, 0xDD, 0x22, 0x95, + 0xEB, 0x6C, 0xAE, 0x20, 0x92, 0xB1, 0x94, 0x3A, + 0xA2, 0xB6, 0x15, 0xCC, 0xC7, 0x92, 0xD6, 0x59, + 0x91, 0xCA, 0x17, 0xCE, 0xBB, 0x5E, 0x43, 0xB5 + }, + { + 0x2A, 0x4F, 0xD7, 0xB5, 0x13, 0x00, 0x1E, 0x31, + 0xFB, 0x49, 0xC8, 0x3D, 0xB7, 0x1F, 0x7D, 0x8C, + 0x26, 0x7D, 0x66, 0xA9, 0xA9, 0xB3, 0x97, 0x08, + 0x44, 0xCA, 0x16, 0x96, 0xEC, 0xAB, 0x72, 0x99, + 0xE4, 0x79, 0xFE, 0x07, 0x3E, 0xF9, 0xC7, 0x5C, + 0x24, 0xA9, 0x2D, 0xD3, 0x6D, 0xEE, 0x36, 0x59, + 0x42, 0x1A, 0xB4, 0x42, 0x33, 0xA2, 0x20, 0x59, + 0xEE, 0x47, 0x50, 0x16, 0x34, 0x06, 0xD4, 0x82 + }, + { + 0xE7, 0xD5, 0xA3, 0xC5, 0x4E, 0x7D, 0xD8, 0x0D, + 0xBF, 0xCD, 0xD6, 0x70, 0x31, 0x29, 0xEC, 0xB1, + 0xF6, 0x1E, 0x52, 0xBD, 0xB0, 0x17, 0xFD, 0x1A, + 0x87, 0xAA, 0x71, 0x94, 0x40, 0xD7, 0x06, 0xB5, + 0x4A, 0x62, 0xD9, 0x2A, 0x4F, 0x77, 0x67, 0x91, + 0x02, 0xF2, 0xDB, 0x37, 0x28, 0x77, 0x93, 0xC0, + 0x30, 0x8B, 0x20, 0x0B, 0x60, 0xAB, 0x2A, 0x35, + 0x19, 0x63, 0x03, 0x39, 0x69, 0x36, 0xA8, 0xE9 + }, + { + 0x2B, 0x79, 0x8F, 0x34, 0xC3, 0x33, 0x50, 0x43, + 0x86, 0xBD, 0x96, 0x1A, 0x14, 0x84, 0xEA, 0x0A, + 0xED, 0x86, 0x7D, 0x8A, 0x26, 0xB1, 0xB6, 0xC9, + 0x44, 0x35, 0x5E, 0x39, 0x7A, 0x86, 0x3D, 0xD2, + 0x18, 0xD4, 0x09, 0x1B, 0x11, 0xB1, 0x26, 0x00, + 0x68, 0xB0, 0x15, 0xE2, 0xD3, 0x13, 0xA1, 0xE2, + 0x00, 0x26, 0x2F, 0x80, 0xB5, 0xB0, 0xFD, 0x7B, + 0xA7, 0xF0, 0x77, 0xF7, 0xDF, 0x60, 0x9A, 0xD0 + }, + { + 0x2A, 0xEE, 0x6B, 0x83, 0xF1, 0x40, 0xE4, 0x21, + 0x89, 0xF6, 0x6F, 0x9F, 0x55, 0x56, 0x38, 0x30, + 0x59, 0x5D, 0x13, 0x28, 0x4E, 0x46, 0x9D, 0x59, + 0xDB, 0x16, 0x48, 0xB4, 0xF8, 0x18, 0x86, 0xA4, + 0x00, 0x9F, 0x0A, 0x4C, 0x52, 0xDE, 0xC2, 0x72, + 0xB8, 0x9D, 0x0F, 0x35, 0x84, 0x7A, 0x13, 0x27, + 0xB9, 0x21, 0x9E, 0x4D, 0x86, 0xB2, 0x1D, 0x9D, + 0x2E, 0x99, 0xC9, 0x9D, 0x6C, 0x00, 0xAE, 0x62 + }, + { + 0x18, 0x91, 0xB8, 0xEF, 0x23, 0x7A, 0x88, 0xFE, + 0x65, 0xF5, 0x8A, 0xEA, 0xD1, 0x6D, 0xA7, 0xBD, + 0x38, 0x34, 0xDE, 0xEA, 0x49, 0x27, 0x6D, 0x43, + 0x9B, 0xB7, 0xF1, 0xD3, 0x79, 0x6F, 0xAB, 0x41, + 0x6D, 0x64, 0x62, 0x73, 0xFD, 0x24, 0xC5, 0x1F, + 0x30, 0xBF, 0x02, 0x24, 0x6A, 0xA6, 0x7D, 0x5C, + 0x59, 0x10, 0x70, 0x65, 0x86, 0xB6, 0x74, 0x3B, + 0x50, 0x82, 0xFF, 0x13, 0xA8, 0x07, 0xBA, 0xFA + }, + { + 0x6D, 0xC3, 0xC3, 0x7B, 0x8C, 0xD2, 0x4F, 0x47, + 0x39, 0x45, 0xE3, 0x0A, 0x58, 0x02, 0xC7, 0x1A, + 0xFA, 0xC9, 0xCB, 0x5C, 0x62, 0xDD, 0x1D, 0xAD, + 0xDF, 0x7A, 0xFE, 0x49, 0x28, 0xEB, 0xBA, 0xA1, + 0x61, 0x27, 0x63, 0x4C, 0xC0, 0x4A, 0x50, 0xC6, + 0x1D, 0xED, 0xE4, 0x0B, 0xE5, 0xF5, 0x52, 0x82, + 0x3D, 0x40, 0x35, 0x41, 0xB1, 0xBB, 0x4F, 0x7C, + 0xB0, 0x95, 0xFB, 0x3A, 0xF9, 0xB7, 0x5E, 0xD8 + }, + { + 0x67, 0xE8, 0x11, 0xDC, 0x16, 0xED, 0x1E, 0xE9, + 0x02, 0x6E, 0xAF, 0x4D, 0x90, 0x28, 0x2F, 0xCE, + 0xCC, 0x12, 0xF4, 0xEA, 0x8D, 0xA9, 0xE9, 0xC9, + 0x25, 0xDC, 0xBC, 0x2B, 0x96, 0x29, 0xEA, 0x09, + 0x35, 0xF6, 0xB0, 0x92, 0xC0, 0xA8, 0x78, 0x2C, + 0x2F, 0x0D, 0x7D, 0xFA, 0xF0, 0xF4, 0xC4, 0x7B, + 0xE0, 0xDC, 0xEF, 0xA7, 0xEF, 0xA5, 0xC6, 0xC2, + 0x03, 0xB4, 0xC9, 0x4F, 0xFC, 0x97, 0x52, 0x64 + }, + { + 0x5E, 0xC5, 0x15, 0xFB, 0x3E, 0x38, 0x70, 0x63, + 0x71, 0xE0, 0x76, 0xF9, 0x29, 0x26, 0x6D, 0x51, + 0xFE, 0xFE, 0x5C, 0xC6, 0x1B, 0xC5, 0x61, 0x9E, + 0x50, 0xA7, 0x79, 0xD9, 0xF0, 0xF2, 0xF6, 0xDB, + 0xFC, 0x45, 0xA9, 0x3B, 0xA3, 0xB8, 0x69, 0x1C, + 0x1B, 0x47, 0xBD, 0x9A, 0xC0, 0xC5, 0x48, 0xAF, + 0xD6, 0x1B, 0x53, 0x4F, 0x22, 0x8F, 0xAF, 0xD4, + 0x3B, 0x85, 0x78, 0xDD, 0x49, 0xAF, 0x26, 0xCC + }, + { + 0xDB, 0x29, 0x85, 0x06, 0x16, 0xBA, 0x95, 0x89, + 0xE3, 0x95, 0xE7, 0x71, 0x3A, 0xC4, 0x89, 0x92, + 0x45, 0xB2, 0x91, 0x01, 0xB6, 0x49, 0xE7, 0x99, + 0x10, 0x15, 0x4B, 0xB8, 0x23, 0x2E, 0x09, 0xB6, + 0xE6, 0xCC, 0x7B, 0x64, 0xB0, 0x64, 0xFE, 0x98, + 0x16, 0x7C, 0x64, 0xA7, 0x6D, 0x96, 0x77, 0xA9, + 0xD5, 0xDC, 0x65, 0x5B, 0x58, 0xB2, 0xD1, 0xE5, + 0xA3, 0x9D, 0xDA, 0x1C, 0xA1, 0x61, 0xE8, 0x49 + }, + { + 0xCC, 0x72, 0x94, 0x17, 0xC3, 0x45, 0xCB, 0xCD, + 0x38, 0x08, 0x80, 0x4D, 0xE5, 0x18, 0xF1, 0x37, + 0x5B, 0xF7, 0xBC, 0x26, 0x72, 0xB0, 0x79, 0x2C, + 0xFE, 0x6E, 0x11, 0x78, 0xAF, 0xC8, 0x78, 0x33, + 0x20, 0x03, 0xDD, 0xA1, 0x05, 0x85, 0x97, 0xE1, + 0x34, 0x54, 0x40, 0x37, 0xD1, 0x3C, 0xA6, 0x7F, + 0x95, 0x08, 0x28, 0x2A, 0x28, 0x86, 0x9A, 0x39, + 0x7D, 0xBE, 0x9F, 0x8D, 0xF3, 0x65, 0x6C, 0xFE + }, + { + 0xAA, 0x17, 0xCB, 0x4E, 0x1E, 0x70, 0x79, 0xD2, + 0x55, 0xD9, 0x59, 0xF5, 0x86, 0xDE, 0x59, 0xE5, + 0x07, 0xB3, 0xE1, 0x90, 0xB8, 0xBE, 0x63, 0x11, + 0xBA, 0xC0, 0x34, 0xD6, 0x5D, 0x13, 0x65, 0x98, + 0xA6, 0x05, 0x78, 0x8A, 0xF7, 0x1B, 0xEA, 0x4C, + 0x01, 0x7E, 0x7C, 0x73, 0x17, 0x1D, 0xE5, 0xCD, + 0x65, 0x6E, 0x2D, 0x3D, 0x1F, 0x5C, 0x78, 0x48, + 0xC2, 0x68, 0x3B, 0x8A, 0xE5, 0x79, 0x5E, 0x8D + }, + { + 0x59, 0xFD, 0x3B, 0x2F, 0xD3, 0x8F, 0x9F, 0x95, + 0x58, 0x63, 0xE6, 0x87, 0xC8, 0x56, 0x11, 0x69, + 0xD2, 0x8F, 0xD4, 0x1D, 0x64, 0x71, 0x33, 0x95, + 0x13, 0xE3, 0xCF, 0xB4, 0x85, 0x58, 0xA9, 0x40, + 0x98, 0xE0, 0x1E, 0x89, 0xEC, 0x06, 0x5A, 0x93, + 0x32, 0x84, 0x3C, 0xA9, 0x26, 0x38, 0x0F, 0x88, + 0x8F, 0xF8, 0xA6, 0x30, 0x04, 0x88, 0xD1, 0xA4, + 0x67, 0x39, 0x73, 0xF3, 0x45, 0x96, 0xAD, 0xF6 + }, + { + 0x87, 0xB6, 0x37, 0x9D, 0x88, 0x07, 0x9F, 0x07, + 0x2C, 0x34, 0xB1, 0xA4, 0x63, 0xEC, 0x5D, 0xE1, + 0x1A, 0xC0, 0xC1, 0xB9, 0x83, 0x95, 0xF7, 0x48, + 0xE9, 0xB2, 0x9B, 0xA4, 0x86, 0x71, 0x36, 0x8E, + 0x07, 0x73, 0x64, 0x4B, 0x85, 0x1F, 0x44, 0xE4, + 0x0B, 0xDD, 0x36, 0xF8, 0xAA, 0xA0, 0x4C, 0xE0, + 0x97, 0x45, 0xD0, 0x47, 0xD1, 0x52, 0x85, 0x21, + 0x5F, 0x0B, 0x01, 0x1D, 0x1F, 0x8D, 0xE2, 0x33 + }, + { + 0x54, 0x07, 0xC3, 0x86, 0xA0, 0xF6, 0xAA, 0xE7, + 0xA8, 0x23, 0x03, 0x81, 0x41, 0x3D, 0xCB, 0x7F, + 0x27, 0x71, 0x2C, 0x58, 0x2D, 0xE3, 0x6B, 0xD2, + 0xA4, 0x52, 0xB4, 0xF0, 0xCA, 0x72, 0xBE, 0xF7, + 0x47, 0xF7, 0x84, 0x6F, 0x1D, 0x7A, 0x31, 0x17, + 0x7E, 0xB6, 0x25, 0x1B, 0x1C, 0xF4, 0x86, 0x4C, + 0xEC, 0x87, 0x6B, 0x55, 0x0B, 0x11, 0x71, 0xF0, + 0xCC, 0x1A, 0xD8, 0x41, 0x69, 0x6C, 0x14, 0xDA + }, + { + 0xDE, 0xD7, 0xB0, 0x0C, 0xB5, 0xF8, 0x47, 0xB7, + 0x5B, 0xCC, 0x31, 0xDA, 0x58, 0x79, 0x6F, 0x13, + 0x1B, 0xDB, 0x34, 0xA8, 0xAB, 0xAA, 0x2E, 0x56, + 0xAB, 0xA3, 0x26, 0xDC, 0x03, 0xCA, 0xEE, 0xE2, + 0xF6, 0xF3, 0x52, 0x36, 0xF4, 0xF0, 0x68, 0xE3, + 0xF4, 0xA1, 0xA7, 0x01, 0x10, 0x72, 0xD4, 0x27, + 0x0F, 0xEF, 0x4C, 0x99, 0x1D, 0x2E, 0xA6, 0xB8, + 0x7B, 0xF2, 0x9E, 0x84, 0x4A, 0x19, 0xF2, 0x41 + }, + { + 0xE4, 0x1D, 0x81, 0x04, 0x87, 0x3C, 0xF2, 0x85, + 0xA0, 0x71, 0x52, 0xC7, 0x5B, 0x4C, 0x92, 0x64, + 0xFD, 0xA0, 0xD2, 0x6A, 0xA6, 0x2F, 0x0D, 0x53, + 0x7C, 0x1A, 0x29, 0xCB, 0xE2, 0xD3, 0x6D, 0x67, + 0xC7, 0x75, 0x98, 0xF1, 0x31, 0x9D, 0xE7, 0x2E, + 0x09, 0x90, 0x4F, 0x84, 0xCD, 0x92, 0x63, 0x6F, + 0x55, 0x8B, 0x60, 0x1B, 0xBA, 0x9C, 0x55, 0xC7, + 0x0C, 0x66, 0x6F, 0x89, 0x52, 0x11, 0x52, 0xC4 + }, + { + 0x32, 0x63, 0x27, 0x4A, 0x58, 0xBE, 0x6A, 0x74, + 0x4C, 0xE0, 0x57, 0x31, 0x31, 0x88, 0xF1, 0x65, + 0x38, 0xB0, 0xB6, 0x39, 0xAF, 0xA5, 0xB6, 0xFB, + 0x0E, 0xCF, 0x5D, 0xA8, 0x4C, 0xC2, 0xA3, 0x9A, + 0x4F, 0xA7, 0x6D, 0x84, 0x0E, 0x48, 0x21, 0x3B, + 0x6F, 0x79, 0x11, 0x27, 0xD7, 0x60, 0x23, 0xE3, + 0xC5, 0x7E, 0x1A, 0xCC, 0x3E, 0x21, 0x08, 0xE8, + 0x27, 0x6C, 0xAD, 0x76, 0xED, 0xDA, 0x4E, 0xD2 + }, + { + 0x30, 0x99, 0x58, 0x26, 0x55, 0x11, 0x00, 0x6D, + 0xF2, 0x93, 0xFE, 0x38, 0x2A, 0x93, 0x2F, 0x2E, + 0x17, 0x14, 0xD1, 0x16, 0xCA, 0x8D, 0x7F, 0x29, + 0xD4, 0x90, 0x74, 0xF0, 0x3E, 0x92, 0x39, 0x1C, + 0xF8, 0xD8, 0x4E, 0x79, 0x8A, 0x69, 0x66, 0xC8, + 0x3A, 0x70, 0x36, 0xD6, 0xC9, 0x85, 0x7B, 0xAE, + 0xBF, 0xE1, 0x00, 0xB6, 0x20, 0x0A, 0xD0, 0xC5, + 0x5B, 0x26, 0x5D, 0x06, 0x42, 0x48, 0x4D, 0xA5 + }, + { + 0xCB, 0x56, 0xA1, 0xC2, 0x77, 0xC7, 0x7E, 0x4A, + 0x1E, 0x45, 0xE8, 0x96, 0x5A, 0xE0, 0xA7, 0x6B, + 0xD1, 0x45, 0x8F, 0x3E, 0x51, 0x70, 0xCD, 0xA5, + 0x20, 0x1E, 0xEB, 0x5D, 0xF7, 0x55, 0xE6, 0x79, + 0x96, 0xAD, 0xD1, 0x6B, 0x32, 0xF5, 0x56, 0x91, + 0x4F, 0x23, 0xAD, 0x7B, 0xAD, 0xA1, 0xB7, 0x02, + 0x98, 0xCB, 0x7F, 0xFF, 0xD8, 0xE6, 0x86, 0x09, + 0x51, 0xBA, 0xF7, 0x97, 0x2D, 0x33, 0x20, 0x7A + }, + { + 0x15, 0xAC, 0xEE, 0x8E, 0x0A, 0x0C, 0xF6, 0x1A, + 0x92, 0x9B, 0x50, 0xC1, 0x05, 0x4B, 0xAA, 0xFA, + 0xE1, 0xE7, 0x0F, 0x26, 0xA3, 0x8E, 0x0F, 0xAA, + 0x40, 0xCD, 0x1E, 0xF1, 0x5F, 0x5B, 0x92, 0x8D, + 0x45, 0xD9, 0x4C, 0x5E, 0x54, 0x0C, 0xF6, 0x41, + 0x0A, 0x5C, 0x2E, 0x2D, 0xAF, 0x94, 0x2D, 0x2F, + 0x32, 0x54, 0x5F, 0xAC, 0x89, 0xB0, 0x90, 0xD0, + 0x91, 0x41, 0xB9, 0x41, 0x11, 0x92, 0x20, 0x4C + }, + { + 0xBD, 0xCC, 0x35, 0x53, 0xF3, 0x10, 0x85, 0x6C, + 0xAC, 0x22, 0x0D, 0xD4, 0x0A, 0x92, 0x76, 0x5D, + 0xDB, 0xFC, 0xD3, 0xA9, 0x84, 0xA1, 0x9E, 0x72, + 0x0F, 0x29, 0x61, 0xCD, 0xC6, 0x50, 0x75, 0x09, + 0xDB, 0xD7, 0x19, 0x9F, 0x95, 0xAB, 0x51, 0xC4, + 0x9D, 0xE2, 0x9E, 0xEF, 0xC1, 0x96, 0x53, 0x0E, + 0xDD, 0x2F, 0xA7, 0x38, 0xBF, 0xA9, 0xFB, 0xA9, + 0xA3, 0xA0, 0x26, 0xA0, 0x1F, 0x2F, 0xA0, 0xEF + }, + { + 0x86, 0xB0, 0x57, 0x11, 0x1F, 0xDF, 0x08, 0x13, + 0x41, 0xCA, 0x21, 0x8E, 0xAB, 0x6C, 0x31, 0x40, + 0x75, 0xD1, 0x89, 0xD8, 0x1D, 0x19, 0xF9, 0x69, + 0xD5, 0xE0, 0x63, 0xE2, 0x79, 0xB9, 0x46, 0x65, + 0x7A, 0x1A, 0xE0, 0xFA, 0xB7, 0xB6, 0xF2, 0x9B, + 0x0C, 0xB6, 0xF8, 0xAD, 0xA1, 0x7E, 0xB3, 0xFB, + 0x1C, 0x52, 0x7D, 0xB0, 0x5C, 0xA9, 0x4C, 0x36, + 0xAD, 0xA8, 0x4C, 0x30, 0x6A, 0x88, 0x60, 0x52 + }, + { + 0xF5, 0x70, 0xA6, 0xCF, 0x77, 0x2F, 0xF9, 0x0B, + 0x07, 0x95, 0xE5, 0x52, 0x02, 0x95, 0x4B, 0x34, + 0xFA, 0x6A, 0x49, 0x66, 0xFC, 0x91, 0x76, 0x78, + 0x8C, 0xF0, 0x6F, 0xF2, 0xEA, 0xC1, 0xC4, 0xD7, + 0x45, 0x7F, 0xC4, 0x94, 0x21, 0x40, 0xA6, 0x01, + 0x25, 0x53, 0x43, 0x33, 0x7C, 0xA1, 0x13, 0xEB, + 0x52, 0xB7, 0xF7, 0xA0, 0x82, 0x62, 0x2A, 0xEE, + 0xDE, 0x32, 0xB1, 0x9A, 0x21, 0x14, 0x96, 0x46 + }, + { + 0x18, 0x1B, 0x81, 0x4D, 0x20, 0x68, 0x87, 0x29, + 0x7B, 0x81, 0x78, 0xF0, 0x35, 0x41, 0xD8, 0xBC, + 0x3E, 0xAB, 0x58, 0x46, 0xC2, 0x8C, 0xF9, 0x47, + 0x52, 0x78, 0x8A, 0x2A, 0xE1, 0x09, 0xB2, 0x2E, + 0x27, 0xBD, 0xE2, 0xDF, 0xFC, 0xFF, 0x47, 0x44, + 0xD9, 0x88, 0xD7, 0xD8, 0x8E, 0xA1, 0xFB, 0x99, + 0x14, 0xB4, 0x45, 0x0B, 0xFC, 0xA0, 0x11, 0x56, + 0x53, 0xDB, 0x3D, 0xCE, 0x4E, 0x38, 0x30, 0x54 + }, + { + 0xAC, 0xB7, 0x14, 0x34, 0x42, 0x09, 0x79, 0xB4, + 0x64, 0x5B, 0x8B, 0x95, 0xE1, 0x82, 0x36, 0x6B, + 0xA2, 0x49, 0xA5, 0xA6, 0x48, 0xEF, 0x50, 0x1C, + 0x62, 0xDD, 0xED, 0x12, 0xAD, 0xD7, 0x52, 0x0B, + 0xD9, 0x8B, 0x93, 0xC1, 0x51, 0x37, 0xE6, 0x2A, + 0xC8, 0x4F, 0x91, 0x7C, 0x64, 0xFF, 0x30, 0xF7, + 0x19, 0x8A, 0xC9, 0x04, 0xBF, 0x39, 0xBC, 0x0B, + 0xEE, 0x38, 0x2D, 0x53, 0x03, 0x0E, 0xAB, 0xD8 + }, + { + 0xD8, 0x9F, 0x82, 0xDD, 0x60, 0x7C, 0xA8, 0x45, + 0xC9, 0x9E, 0xC2, 0xFF, 0xCD, 0xDB, 0xC5, 0x74, + 0x55, 0x02, 0x58, 0x49, 0x3E, 0xC5, 0x71, 0xD9, + 0x25, 0xF6, 0x2A, 0x11, 0x3D, 0x7B, 0x38, 0xC6, + 0xF9, 0x1D, 0xB6, 0xBF, 0x61, 0x51, 0xA7, 0x82, + 0x74, 0xBA, 0x30, 0x56, 0xCA, 0x33, 0x42, 0xE4, + 0x0C, 0xF4, 0xC5, 0x8D, 0x6C, 0x80, 0x5F, 0x97, + 0x99, 0x9B, 0x95, 0x66, 0x7E, 0x60, 0xD0, 0x9B + }, + { + 0x5E, 0x05, 0x38, 0x95, 0x8D, 0x06, 0x02, 0x83, + 0x02, 0x8D, 0xF5, 0xF5, 0xED, 0x71, 0xF9, 0x14, + 0x25, 0x44, 0xB2, 0x3C, 0x43, 0x7B, 0xC4, 0x3E, + 0xD1, 0x11, 0xA8, 0xAB, 0xB3, 0xD0, 0x09, 0xE1, + 0x3B, 0x13, 0x35, 0xE4, 0xEF, 0x08, 0xD3, 0xB6, + 0xF5, 0x96, 0xCE, 0xC0, 0x5A, 0x1A, 0xD6, 0xE1, + 0x45, 0x96, 0x4B, 0x72, 0x63, 0x0F, 0x0C, 0x78, + 0x99, 0x99, 0x86, 0xBB, 0xEA, 0x8F, 0xD0, 0x65 + }, + { + 0x46, 0x3A, 0xA9, 0xB9, 0x76, 0x98, 0x11, 0x3C, + 0xC4, 0xF3, 0xC4, 0x30, 0xE9, 0x1F, 0x4E, 0x9D, + 0x94, 0x68, 0x72, 0x75, 0xA2, 0x57, 0x15, 0x83, + 0x23, 0xAE, 0x4E, 0x93, 0xC3, 0x7C, 0x4D, 0x57, + 0xFC, 0xBC, 0xD1, 0x1F, 0xB2, 0x5F, 0x0D, 0x5D, + 0xAA, 0x17, 0x12, 0xF2, 0xA5, 0x0F, 0x1C, 0xD5, + 0x37, 0xD1, 0x35, 0x6A, 0x33, 0xA7, 0x5D, 0x38, + 0xA5, 0xBD, 0x71, 0x96, 0xE2, 0xBD, 0x64, 0xDB + }, + { + 0xC0, 0x2C, 0x74, 0xA1, 0x09, 0x35, 0x77, 0x08, + 0x2A, 0x06, 0xAE, 0x39, 0x86, 0x61, 0x23, 0x81, + 0xFF, 0x92, 0x9B, 0xE0, 0x73, 0xE8, 0x8B, 0x78, + 0x43, 0x9F, 0x21, 0x16, 0x6A, 0x0C, 0xF7, 0x4B, + 0xA0, 0x89, 0x28, 0xCB, 0x06, 0xA2, 0x83, 0x7F, + 0x72, 0x5D, 0x47, 0xFA, 0x80, 0x4E, 0x45, 0x8F, + 0x42, 0xA5, 0x09, 0x03, 0x4C, 0x5B, 0xB4, 0x3C, + 0x0F, 0x28, 0x63, 0xA0, 0xE7, 0x6D, 0x0A, 0xC3 + }, + { + 0x4F, 0xE6, 0x23, 0x3B, 0x74, 0x9B, 0x8A, 0x16, + 0x8C, 0x9E, 0x86, 0x36, 0x11, 0x7B, 0x6B, 0xF2, + 0x34, 0x2F, 0x2F, 0x41, 0x85, 0x03, 0x8F, 0x01, + 0xF1, 0x25, 0x25, 0x3E, 0x98, 0xFD, 0xB3, 0x94, + 0x4C, 0x65, 0xB2, 0xB9, 0xFE, 0x0A, 0x7C, 0xAD, + 0xFA, 0x35, 0x05, 0x1A, 0x7E, 0x38, 0x70, 0x19, + 0x2E, 0x55, 0x24, 0x7E, 0xB7, 0x69, 0x93, 0x77, + 0x71, 0xE5, 0xCC, 0x07, 0x0A, 0x32, 0xA0, 0x8F + }, + { + 0x31, 0xED, 0xD7, 0x20, 0xC7, 0x50, 0x94, 0x78, + 0xBC, 0x58, 0x13, 0xC4, 0x88, 0x42, 0x61, 0x7B, + 0x9D, 0x80, 0x6A, 0x57, 0x6A, 0x7E, 0xC3, 0x1C, + 0x50, 0x14, 0x72, 0xD9, 0x37, 0xA5, 0xC7, 0x62, + 0xFB, 0xD3, 0x4F, 0xBB, 0x40, 0xD2, 0x92, 0xB3, + 0x3E, 0x6D, 0x12, 0x18, 0x98, 0xE4, 0x64, 0x82, + 0x8F, 0xF3, 0xE0, 0xC0, 0xF5, 0x4D, 0x3C, 0xEB, + 0xF0, 0x17, 0x20, 0x8B, 0xB7, 0x82, 0xC2, 0xB5 + }, + { + 0x79, 0x40, 0x57, 0xEA, 0x76, 0x80, 0xCE, 0x6E, + 0x85, 0x89, 0x87, 0xC5, 0x10, 0x7F, 0x9B, 0x69, + 0xFB, 0x81, 0x48, 0x63, 0xD0, 0x4C, 0x2C, 0x78, + 0xF5, 0xF7, 0x8A, 0x76, 0xC0, 0x25, 0xEA, 0x22, + 0xDD, 0x91, 0x17, 0xA0, 0x76, 0xB4, 0x85, 0x8F, + 0xE5, 0x0A, 0x14, 0x8A, 0x51, 0x40, 0x4C, 0x9A, + 0xE6, 0x4F, 0xE1, 0x4B, 0x02, 0xC1, 0x81, 0xF2, + 0x92, 0x06, 0x59, 0xEE, 0xD8, 0x85, 0xA2, 0x6A + }, + { + 0xFD, 0xC7, 0x7A, 0x17, 0x6E, 0xDC, 0x8F, 0xE2, + 0x32, 0x79, 0x70, 0xB0, 0xB5, 0x58, 0x21, 0xA0, + 0xAF, 0xE4, 0x6B, 0xDA, 0x14, 0x40, 0x2C, 0x57, + 0x5D, 0xC6, 0xE9, 0x89, 0xFB, 0xED, 0xA6, 0x0F, + 0x2F, 0x2A, 0x5B, 0xCF, 0x10, 0xDF, 0xDE, 0xAD, + 0x8B, 0x8E, 0x20, 0x4A, 0x50, 0xE9, 0x58, 0x24, + 0x40, 0x9A, 0x4A, 0x70, 0xFB, 0x84, 0x26, 0x37, + 0xF7, 0x8A, 0x81, 0x03, 0x02, 0x40, 0x62, 0xE1 + }, + { + 0xB8, 0x3E, 0xA4, 0x7B, 0x3B, 0x15, 0x60, 0x15, + 0x45, 0x02, 0xE5, 0x06, 0xD8, 0x68, 0x84, 0x43, + 0x99, 0xDA, 0x9C, 0xC2, 0xF4, 0xF3, 0x07, 0xBD, + 0x0F, 0x15, 0xDC, 0x24, 0x1E, 0x29, 0x21, 0x75, + 0x94, 0x12, 0x44, 0x64, 0xAB, 0x8E, 0x9C, 0x01, + 0x7E, 0xAB, 0xE6, 0x83, 0x8C, 0x45, 0x71, 0xF6, + 0x7A, 0x5F, 0xCA, 0xD4, 0x77, 0xD2, 0xB3, 0xF4, + 0xBD, 0xFF, 0xD4, 0x4C, 0x2F, 0xB0, 0xAF, 0x2B + }, + { + 0x42, 0x31, 0xE9, 0x37, 0xAC, 0x2C, 0xDC, 0x2B, + 0xFB, 0xBF, 0xE2, 0xAC, 0x7A, 0x41, 0x0E, 0x82, + 0x8A, 0xF6, 0x6D, 0x6E, 0x5F, 0xD4, 0xA7, 0xEC, + 0xDA, 0xE8, 0xF9, 0x38, 0x2A, 0x42, 0x3E, 0xAD, + 0xC5, 0xA8, 0x11, 0x10, 0xD6, 0x3A, 0x2C, 0x3A, + 0xF0, 0xD3, 0xDD, 0x5B, 0x42, 0x59, 0x89, 0x9B, + 0x99, 0x00, 0xD4, 0xF8, 0x46, 0xE6, 0x48, 0xE8, + 0x89, 0xE4, 0x4C, 0xB4, 0x45, 0x50, 0xD4, 0x60 + }, + { + 0xD7, 0xBD, 0x01, 0x00, 0x92, 0xB4, 0x25, 0x4A, + 0xD0, 0xDA, 0xF4, 0xA3, 0x3A, 0x35, 0x3E, 0x13, + 0x49, 0x37, 0x5D, 0xB2, 0x4D, 0x87, 0x3D, 0xD5, + 0x22, 0x42, 0x07, 0x1C, 0x65, 0x10, 0x61, 0xCF, + 0x3C, 0xE7, 0xB5, 0x53, 0x35, 0xEB, 0x8F, 0x16, + 0x2D, 0x7C, 0xF4, 0x67, 0x4C, 0x1B, 0xBC, 0xA6, + 0xE6, 0x3E, 0x6E, 0xDC, 0x18, 0x1C, 0xBE, 0xD7, + 0xFB, 0x85, 0xBA, 0x06, 0x21, 0xED, 0xF0, 0x5F + }, + { + 0x18, 0xA8, 0x36, 0x3A, 0xDE, 0xB1, 0xD6, 0xC7, + 0x9A, 0xD4, 0x16, 0x2D, 0x05, 0x14, 0xBC, 0xCF, + 0xA2, 0xA4, 0x3F, 0x2E, 0x2C, 0xE5, 0x61, 0xA1, + 0x7F, 0x8B, 0x4A, 0x3A, 0xC2, 0x9E, 0xAE, 0x7C, + 0x36, 0x34, 0x72, 0x81, 0xAE, 0x51, 0x95, 0x0E, + 0x9A, 0x86, 0x9A, 0x4D, 0x05, 0xB4, 0x53, 0x7B, + 0x4B, 0x10, 0x54, 0xBF, 0x46, 0x44, 0xB7, 0xBF, + 0x8F, 0x0A, 0xC9, 0xF0, 0xA7, 0xD6, 0xD8, 0xFD + }, + { + 0x9B, 0x23, 0x37, 0x37, 0x77, 0x44, 0xAC, 0xD9, + 0x9A, 0x3D, 0x94, 0xED, 0xCF, 0x4E, 0xA9, 0xD2, + 0x48, 0xAE, 0xB5, 0xB3, 0x6A, 0xE1, 0x61, 0xEE, + 0xA3, 0xDF, 0x5C, 0x5D, 0xF9, 0x0E, 0xF6, 0xF9, + 0x66, 0x1A, 0x54, 0xF0, 0x05, 0x6F, 0x9E, 0x7B, + 0x0B, 0x96, 0x11, 0x67, 0xB9, 0xC4, 0x85, 0x4C, + 0x31, 0xE4, 0xFC, 0xAE, 0x33, 0xDA, 0x89, 0x3B, + 0x64, 0xE2, 0x4D, 0x3A, 0xCB, 0x15, 0x3A, 0xC7 + }, + { + 0xF0, 0x10, 0x85, 0x16, 0xED, 0x5A, 0xF5, 0x4A, + 0x6C, 0x43, 0xA1, 0x9E, 0x17, 0x0C, 0x83, 0x8E, + 0xED, 0x70, 0xB4, 0x7E, 0x5F, 0x23, 0x86, 0xE9, + 0xCF, 0x6F, 0xC0, 0x4E, 0xAB, 0x3A, 0x85, 0x65, + 0x38, 0x2F, 0xB1, 0x2C, 0x6D, 0x4D, 0xBB, 0x9D, + 0x37, 0xDE, 0xA1, 0xC1, 0x88, 0x80, 0x15, 0x66, + 0x16, 0x3F, 0xEB, 0xB2, 0xF3, 0x2E, 0xA7, 0x2B, + 0x15, 0xB5, 0xC4, 0xA0, 0x32, 0xE7, 0xFC, 0xE4 + }, + { + 0xFF, 0x5B, 0xB5, 0xF5, 0xC4, 0x18, 0x7A, 0x2A, + 0xAF, 0x3A, 0x2F, 0xE9, 0x9C, 0xF7, 0x68, 0x8B, + 0x75, 0x63, 0x3C, 0x79, 0x19, 0xD5, 0x6E, 0xDF, + 0xEC, 0xEA, 0x8D, 0x72, 0x53, 0x12, 0xA1, 0x81, + 0xD2, 0x83, 0xDD, 0x84, 0x9C, 0x1F, 0x3C, 0xBA, + 0x22, 0xBA, 0xCB, 0xD2, 0x2E, 0x3E, 0xB6, 0x88, + 0xE1, 0xEA, 0xFA, 0xC8, 0x55, 0xC2, 0x4A, 0x00, + 0xE3, 0x74, 0x40, 0x46, 0x2B, 0x93, 0x42, 0x11 + }, + { + 0x29, 0x29, 0x88, 0x2D, 0x67, 0x0C, 0x01, 0x8B, + 0xD9, 0x12, 0x9B, 0xB3, 0xC8, 0xA8, 0x4D, 0xA6, + 0x19, 0xC4, 0x67, 0x3B, 0x83, 0x59, 0xDD, 0x4E, + 0x0D, 0xB1, 0x9E, 0x15, 0x83, 0x40, 0x50, 0x41, + 0x24, 0xE5, 0x3C, 0x9C, 0xD5, 0xA8, 0xA1, 0xE8, + 0x2D, 0x1A, 0x44, 0xD5, 0xEE, 0xF4, 0x55, 0xB5, + 0x59, 0x42, 0xBD, 0x6E, 0x65, 0xC9, 0x21, 0xCE, + 0x09, 0xE8, 0x59, 0xEA, 0x4A, 0x71, 0x1D, 0xCE + }, + { + 0xFC, 0x01, 0x9B, 0x21, 0xA1, 0x27, 0xB8, 0x2D, + 0xAC, 0xB4, 0xE4, 0xCF, 0x90, 0xA7, 0x63, 0xDC, + 0x00, 0x6B, 0x11, 0xE3, 0x25, 0x06, 0x64, 0x20, + 0xB6, 0x33, 0x77, 0x86, 0x64, 0x03, 0xCD, 0xA5, + 0x39, 0x53, 0x55, 0x5E, 0x13, 0x0C, 0xC5, 0x49, + 0x4E, 0xA5, 0x99, 0xFF, 0xC4, 0x54, 0xD2, 0x66, + 0x0A, 0xEB, 0xBC, 0x2D, 0x3A, 0xE8, 0x04, 0x39, + 0x78, 0x86, 0x6A, 0xEC, 0x3A, 0x80, 0x2A, 0x88 + }, + { + 0x22, 0xF2, 0x2F, 0xBA, 0xBE, 0x70, 0xFC, 0xA2, + 0x95, 0x6E, 0xF3, 0x15, 0x87, 0x3B, 0x7E, 0x91, + 0x93, 0x17, 0x28, 0x90, 0x30, 0xF6, 0x10, 0xCD, + 0x88, 0x72, 0x02, 0x2C, 0x2A, 0xF8, 0x31, 0x95, + 0x11, 0x15, 0x10, 0x0E, 0x18, 0x23, 0xFB, 0x8B, + 0x99, 0xF7, 0xBC, 0x4D, 0x7D, 0x60, 0x2F, 0xBF, + 0x64, 0xF0, 0x8A, 0xAF, 0x40, 0x06, 0x37, 0x63, + 0xD3, 0x1C, 0xA1, 0xA7, 0xC9, 0x05, 0x15, 0x2E + }, + { + 0x15, 0x40, 0x23, 0xBB, 0x94, 0x20, 0x8D, 0xAD, + 0x73, 0x29, 0x8E, 0x90, 0x3A, 0x76, 0x14, 0x1B, + 0x73, 0x77, 0x84, 0xBF, 0x78, 0x61, 0xFC, 0xAE, + 0x90, 0xC8, 0x6E, 0x0C, 0xF1, 0x4C, 0xAE, 0x80, + 0xEA, 0x75, 0x22, 0x2F, 0x5B, 0x02, 0x78, 0x4C, + 0x95, 0xF6, 0x7A, 0x17, 0x19, 0x72, 0x4A, 0x88, + 0x24, 0x6E, 0x40, 0xEF, 0xD2, 0x91, 0xAE, 0x7E, + 0x07, 0x3D, 0x38, 0xFB, 0x18, 0x51, 0x79, 0x43 + }, + { + 0x61, 0x5D, 0x07, 0xA6, 0xCC, 0x1C, 0xE7, 0x54, + 0xDD, 0x2F, 0xA3, 0xFA, 0x4B, 0x38, 0x54, 0xDB, + 0x1D, 0x1C, 0x24, 0xB3, 0x34, 0x11, 0x95, 0x7B, + 0x4F, 0x17, 0xE0, 0x09, 0x59, 0xB5, 0xE8, 0xF0, + 0xCF, 0x7B, 0xBA, 0x00, 0x07, 0xA4, 0x9A, 0xE4, + 0x9D, 0x78, 0x2D, 0xFF, 0xA1, 0x7E, 0xB1, 0xB2, + 0x72, 0x07, 0xD2, 0xAA, 0x77, 0x13, 0xF4, 0x54, + 0xBE, 0xA8, 0xBF, 0xF2, 0x79, 0x06, 0x61, 0x13 + }, + { + 0x93, 0xC8, 0x66, 0x5F, 0x4B, 0xD6, 0xF7, 0xA6, + 0x87, 0xC4, 0xCA, 0x5D, 0x5A, 0xBF, 0x7C, 0xBE, + 0xA6, 0x0B, 0x3B, 0x05, 0x38, 0xD4, 0x71, 0xE9, + 0x6C, 0x7C, 0xC2, 0x1C, 0xB0, 0x5D, 0x18, 0x38, + 0x7D, 0x02, 0xEF, 0xFB, 0xC9, 0x3E, 0x19, 0x4C, + 0x60, 0xBF, 0x4D, 0x44, 0x5F, 0xDA, 0x48, 0x0D, + 0xA9, 0xE1, 0x2A, 0x93, 0xA3, 0xC7, 0x10, 0xD1, + 0x3F, 0x21, 0xB8, 0x3A, 0x63, 0xBD, 0x47, 0x87 + }, + { + 0x6C, 0x60, 0xF7, 0x74, 0x72, 0x4E, 0x4E, 0xBE, + 0xDB, 0xF2, 0x6F, 0x95, 0xBE, 0x54, 0xAD, 0x2D, + 0xED, 0xB6, 0x93, 0x05, 0xF8, 0xEE, 0x8D, 0xC8, + 0x38, 0x82, 0x87, 0xE8, 0x86, 0x93, 0x29, 0x58, + 0x01, 0xDD, 0x77, 0xC8, 0x97, 0x15, 0x00, 0x04, + 0xCB, 0xC4, 0x61, 0xAC, 0xA6, 0x46, 0x75, 0x2B, + 0x4B, 0x09, 0x98, 0xDF, 0x4B, 0xD6, 0x1B, 0x55, + 0x33, 0x74, 0x27, 0xA4, 0x1C, 0xD7, 0xE8, 0xFD + }, + { + 0x5D, 0x49, 0xA1, 0xAC, 0x38, 0xBD, 0x1B, 0x90, + 0x88, 0xEA, 0xDA, 0xC8, 0x50, 0xBD, 0x1A, 0xB5, + 0x78, 0x1E, 0x04, 0x9C, 0x2D, 0xFD, 0xC8, 0x3C, + 0x4B, 0x7E, 0x1B, 0xF6, 0xAD, 0x3D, 0xF5, 0x5F, + 0xED, 0xA2, 0x53, 0xEB, 0xB7, 0xFA, 0xD3, 0x88, + 0xB0, 0x19, 0xB0, 0xB3, 0x17, 0x32, 0x97, 0xBD, + 0xD2, 0x45, 0x85, 0x7C, 0x86, 0x5B, 0xE6, 0x58, + 0x36, 0x30, 0xD4, 0x82, 0x21, 0x3B, 0x8D, 0xDD + }, + { + 0x8E, 0xC2, 0x6F, 0x9B, 0x26, 0x28, 0x33, 0xFF, + 0xFF, 0x4C, 0x86, 0x9B, 0x84, 0x86, 0x43, 0x03, + 0xCA, 0x58, 0x92, 0x4F, 0xC8, 0x71, 0xC6, 0x98, + 0xAD, 0x07, 0xCB, 0x3D, 0x42, 0xF4, 0xAC, 0x14, + 0xF4, 0x12, 0xC0, 0x3B, 0xE7, 0xEE, 0x99, 0x04, + 0x5F, 0xD7, 0xEA, 0x44, 0x88, 0x4B, 0xBE, 0xF1, + 0xF7, 0x6E, 0xB6, 0x39, 0xAD, 0x60, 0x36, 0x4B, + 0x9C, 0x5C, 0xEA, 0x8E, 0x16, 0xC1, 0x6D, 0x7C + }, + { + 0x36, 0x58, 0x66, 0x24, 0x39, 0x98, 0xF3, 0x3F, + 0x54, 0x9E, 0x3D, 0xE8, 0xC9, 0x40, 0x3D, 0x07, + 0xFA, 0x46, 0x71, 0xC6, 0x90, 0xC3, 0x35, 0x41, + 0x27, 0xF3, 0x6C, 0x0E, 0x27, 0x5C, 0xCE, 0xC2, + 0x6F, 0x01, 0x7E, 0xBD, 0x5B, 0xA8, 0x60, 0x04, + 0xC0, 0x26, 0x07, 0x8A, 0x24, 0xE7, 0x62, 0x74, + 0x77, 0xB3, 0x7B, 0x3F, 0xFF, 0x1F, 0x78, 0xA9, + 0x1B, 0xF8, 0xF6, 0x3B, 0x36, 0xF7, 0x83, 0x30 + }, + { + 0x47, 0x69, 0x11, 0x76, 0x21, 0x36, 0xB7, 0xD1, + 0x3E, 0x80, 0xA3, 0xCC, 0xEB, 0x58, 0x27, 0x68, + 0xDD, 0xB3, 0xEF, 0xF5, 0x3E, 0xED, 0xF6, 0xC7, + 0xE1, 0xFE, 0x53, 0x58, 0x79, 0x9C, 0xB8, 0xCF, + 0x4D, 0x95, 0x80, 0xE4, 0xE6, 0xBC, 0xB7, 0x10, + 0x95, 0x50, 0x9A, 0x1E, 0x7F, 0x8D, 0x67, 0xB1, + 0xBD, 0xDE, 0xA2, 0xA2, 0x91, 0xC0, 0x42, 0x98, + 0xF6, 0xDC, 0xEB, 0x37, 0xD3, 0x0C, 0x6A, 0x06 + }, + { + 0x17, 0x50, 0xF9, 0xE8, 0x79, 0x9E, 0xBE, 0xAB, + 0x04, 0xEA, 0x5D, 0x60, 0x5F, 0x45, 0xC9, 0x89, + 0xA2, 0x73, 0x93, 0x67, 0x9B, 0x81, 0xAB, 0xE1, + 0x3C, 0xA5, 0x7F, 0x21, 0xA9, 0x40, 0x41, 0x9C, + 0x50, 0x20, 0xD5, 0xC6, 0x11, 0x6E, 0xAE, 0xB6, + 0x09, 0x30, 0xDC, 0xC3, 0xAF, 0x7E, 0x54, 0x2F, + 0xB2, 0xF4, 0xAD, 0xD9, 0x77, 0xCC, 0xCC, 0x7E, + 0x69, 0x49, 0xDA, 0xAF, 0xD7, 0x7F, 0x0D, 0xE7 + }, + { + 0x9F, 0x56, 0xA4, 0x4A, 0x0B, 0x5B, 0xB5, 0x2D, + 0x9A, 0xF4, 0x1A, 0x7B, 0xA2, 0xDF, 0x8D, 0x85, + 0x33, 0xB9, 0xA5, 0x0A, 0x89, 0xD1, 0x43, 0x37, + 0xAA, 0xA7, 0x3E, 0xB5, 0x14, 0x94, 0x01, 0x01, + 0xF3, 0x8A, 0xF4, 0xE7, 0xAE, 0xC3, 0xE9, 0xC3, + 0x1C, 0x1E, 0x4C, 0xDB, 0x5F, 0xD9, 0x8B, 0x7F, + 0x5E, 0xC1, 0x27, 0xD8, 0xF7, 0x67, 0x28, 0x1F, + 0xEC, 0x6F, 0x7A, 0x6F, 0x74, 0xAF, 0x25, 0x57 + }, + { + 0x11, 0x0C, 0x2D, 0xF2, 0x21, 0xF6, 0xED, 0x36, + 0x8A, 0x32, 0x33, 0x87, 0x4B, 0x35, 0x7F, 0x1C, + 0x10, 0x78, 0x1D, 0x4A, 0x57, 0xEA, 0x46, 0x2A, + 0x0D, 0xED, 0x9A, 0x34, 0xA9, 0xAA, 0xC7, 0xCF, + 0xA8, 0xA2, 0x0F, 0x94, 0xBF, 0xA0, 0x32, 0x57, + 0x14, 0x34, 0x0C, 0x87, 0xF4, 0x18, 0xAB, 0x51, + 0x6D, 0x03, 0x02, 0x76, 0xE1, 0x62, 0xBC, 0xE2, + 0xA5, 0xF4, 0x31, 0xC2, 0x22, 0x74, 0x5B, 0xA4 + }, + { + 0x59, 0x25, 0xB8, 0x32, 0x44, 0x44, 0xF8, 0x47, + 0x8F, 0xFC, 0xCF, 0x12, 0xD5, 0xA6, 0x42, 0x34, + 0x97, 0x29, 0xE9, 0x88, 0xA5, 0xF3, 0x2E, 0xB0, + 0xF9, 0x19, 0x52, 0x22, 0x6A, 0x8D, 0xF4, 0xEB, + 0xAE, 0x91, 0x57, 0xE2, 0xE4, 0x12, 0x2E, 0x02, + 0x10, 0x78, 0x33, 0x39, 0x10, 0x30, 0xDB, 0xDA, + 0x15, 0x75, 0x89, 0x11, 0xF6, 0x88, 0x23, 0x50, + 0x40, 0x3D, 0x22, 0xB9, 0xC0, 0xCB, 0xCE, 0x36 + }, + { + 0x84, 0x65, 0xAF, 0x2E, 0xB3, 0xB8, 0xE1, 0xB4, + 0xE2, 0xA9, 0xB8, 0x4D, 0xCB, 0xF2, 0x90, 0xE7, + 0xDA, 0xCB, 0xF7, 0xE0, 0xC7, 0xB9, 0x28, 0x39, + 0x6F, 0xBD, 0x7B, 0xA9, 0x06, 0xD7, 0xA1, 0xF2, + 0x9B, 0x38, 0xB1, 0x0E, 0xCE, 0xAB, 0xBF, 0x60, + 0x80, 0x3D, 0x59, 0xE9, 0x12, 0x8C, 0xF8, 0x58, + 0xF3, 0xF8, 0xBF, 0xF2, 0xD9, 0x85, 0xCA, 0x81, + 0x4A, 0x15, 0xCB, 0x45, 0x2C, 0x94, 0x61, 0x7B + }, + { + 0xD4, 0xA8, 0x42, 0xCF, 0x19, 0x44, 0xDA, 0x8A, + 0x96, 0x3B, 0xC9, 0x97, 0x8C, 0x8A, 0x89, 0x0D, + 0x36, 0xC9, 0x6F, 0x15, 0x24, 0xCD, 0x12, 0xC7, + 0x6B, 0x2B, 0x73, 0x9D, 0x60, 0x62, 0x98, 0x5F, + 0x64, 0xF3, 0xC7, 0x3F, 0x9F, 0x0C, 0x52, 0x23, + 0x51, 0x39, 0x49, 0x20, 0x3A, 0xA5, 0xB3, 0x9E, + 0x6D, 0xA3, 0xFD, 0xB0, 0x46, 0x42, 0xC3, 0x14, + 0x2E, 0xEB, 0x6B, 0x73, 0x7E, 0x07, 0x4B, 0xC9 + }, + { + 0x55, 0xC3, 0xBF, 0xC5, 0x63, 0x12, 0x59, 0x38, + 0xD9, 0x1F, 0xEF, 0xD1, 0x41, 0xB1, 0xE0, 0x94, + 0x30, 0x6A, 0xE8, 0x95, 0xDB, 0x2E, 0x09, 0xA0, + 0x35, 0x5C, 0x9F, 0xB0, 0xAA, 0xCE, 0x59, 0xCA, + 0x61, 0x99, 0x29, 0x50, 0xA5, 0x03, 0x55, 0xAE, + 0xBD, 0xAD, 0x8C, 0xED, 0x95, 0xF4, 0xD9, 0x9A, + 0xDA, 0xD9, 0xA7, 0xBB, 0x6F, 0xF7, 0xB1, 0x19, + 0xDF, 0x17, 0x7E, 0xE0, 0x10, 0x46, 0x38, 0xBE + }, + { + 0xE5, 0xCE, 0xDC, 0xD4, 0x4C, 0x23, 0x5B, 0xF3, + 0x50, 0xC9, 0x94, 0x75, 0xB1, 0x89, 0x52, 0x9E, + 0xD3, 0x73, 0xD3, 0xE7, 0xE5, 0xB7, 0x53, 0x47, + 0xB2, 0x6E, 0x41, 0x70, 0xD1, 0x3C, 0x67, 0x99, + 0x3F, 0x6D, 0x51, 0x2F, 0x8E, 0x8D, 0x3A, 0x79, + 0xFC, 0xE9, 0xF7, 0x47, 0x9D, 0xE5, 0x91, 0x00, + 0x2E, 0x18, 0xBD, 0x96, 0xFD, 0xFF, 0x33, 0x3B, + 0x90, 0x56, 0xDE, 0x77, 0x63, 0xA6, 0x30, 0xC3 + }, + { + 0x86, 0x9B, 0x54, 0xC2, 0x1D, 0xFD, 0xB0, 0xFF, + 0xCD, 0x39, 0x63, 0xDD, 0x35, 0x7C, 0x36, 0xF2, + 0xE4, 0x71, 0x8F, 0x4F, 0xAB, 0x4E, 0xA1, 0x28, + 0x21, 0x27, 0x37, 0x27, 0x65, 0x56, 0x94, 0x32, + 0x41, 0xB4, 0x88, 0x79, 0x5F, 0x74, 0xAE, 0xD5, + 0xCD, 0x60, 0x3A, 0x20, 0xF8, 0xD8, 0x8C, 0x60, + 0xAB, 0xAD, 0xBA, 0xF6, 0xD9, 0xE1, 0x38, 0x2F, + 0xB5, 0x6F, 0x92, 0xC5, 0x17, 0xA3, 0xBC, 0x3B + }, + { + 0x29, 0xC0, 0x9F, 0x4B, 0xBE, 0x6E, 0x6D, 0xA2, + 0x99, 0x6C, 0x4D, 0x2F, 0xBA, 0x0A, 0xE0, 0x8C, + 0xF2, 0xA5, 0x0E, 0x1E, 0x79, 0x72, 0x16, 0xBA, + 0x6B, 0xD2, 0x46, 0x32, 0xF2, 0x41, 0xE6, 0x7B, + 0x2D, 0xFB, 0xA6, 0xB0, 0xA2, 0x6A, 0xDF, 0x6C, + 0xAC, 0xA8, 0x02, 0x6A, 0x66, 0xCC, 0xC6, 0x6B, + 0x39, 0x8D, 0x63, 0x34, 0x91, 0xED, 0x6B, 0xCE, + 0xC6, 0xF6, 0x3C, 0x4F, 0x7A, 0x92, 0x04, 0x1C + }, + { + 0x93, 0x49, 0xC0, 0x4B, 0x66, 0xAC, 0xB9, 0x9D, + 0xAA, 0x24, 0xD6, 0x92, 0x31, 0x6F, 0xFF, 0xF8, + 0x32, 0x77, 0x91, 0x4F, 0xD7, 0x91, 0x3A, 0xEA, + 0xB3, 0x0B, 0x12, 0xC9, 0xE0, 0x60, 0xBB, 0xCE, + 0x51, 0x5B, 0x31, 0x2C, 0xDC, 0x54, 0x59, 0x29, + 0xAA, 0xB4, 0xA2, 0x16, 0x79, 0x58, 0x72, 0x90, + 0xB9, 0xDD, 0x57, 0x0C, 0x98, 0x3C, 0x62, 0xA1, + 0xDA, 0x87, 0x41, 0x79, 0x35, 0x17, 0x06, 0x33 + }, + { + 0xDD, 0x85, 0xD3, 0x30, 0xE8, 0x7F, 0x79, 0x46, + 0xA3, 0xD1, 0x7E, 0x68, 0x63, 0xBB, 0x17, 0x22, + 0xBD, 0x5C, 0xD3, 0x81, 0x7C, 0xE0, 0x4A, 0x59, + 0xC6, 0xC2, 0x8A, 0x59, 0xEC, 0xE9, 0xF1, 0x31, + 0xF6, 0x2C, 0x60, 0x68, 0xD0, 0xF4, 0x3C, 0x64, + 0x88, 0x63, 0x3F, 0x17, 0xFB, 0x08, 0x81, 0x3C, + 0xF2, 0xA9, 0xAF, 0xCB, 0x82, 0x8F, 0x98, 0x15, + 0x99, 0xD0, 0x0F, 0x3D, 0xE1, 0x6C, 0xB1, 0xB4 + }, + { + 0x27, 0xFE, 0x27, 0xE4, 0x8E, 0xCB, 0x37, 0x0C, + 0x75, 0x5D, 0x48, 0xCC, 0xB9, 0xD6, 0x1E, 0xEA, + 0x42, 0x55, 0xBE, 0xFE, 0x27, 0x05, 0x89, 0x75, + 0x93, 0xC6, 0x7D, 0xE8, 0xFF, 0xE6, 0x42, 0x79, + 0x8B, 0xE9, 0xAF, 0xDD, 0xF6, 0xB9, 0xC7, 0x1E, + 0x4F, 0x71, 0xC7, 0x80, 0xDC, 0xE2, 0x13, 0x6A, + 0x83, 0x12, 0x99, 0xD6, 0xE9, 0x38, 0x8A, 0x5A, + 0xBE, 0x2F, 0xD1, 0x45, 0xFD, 0x68, 0x99, 0x53 + }, + { + 0x0A, 0xBC, 0x9F, 0xE8, 0xC6, 0x59, 0x40, 0x2D, + 0x4E, 0x53, 0xB2, 0xF3, 0x99, 0x6B, 0xDE, 0x07, + 0x09, 0x27, 0xA3, 0x54, 0x0E, 0x7B, 0x2A, 0x7B, + 0xCB, 0x87, 0xF4, 0xA7, 0x97, 0x93, 0x41, 0xAF, + 0xA8, 0x1B, 0xE5, 0xD1, 0xA8, 0x61, 0x94, 0xD2, + 0x03, 0x41, 0xBF, 0xE4, 0x93, 0xFF, 0x0D, 0xD0, + 0xA4, 0x00, 0x4E, 0x89, 0xA5, 0x83, 0x2D, 0x45, + 0x9A, 0x6F, 0xBC, 0xB4, 0xAF, 0x18, 0x36, 0x59 + }, + { + 0xF0, 0x01, 0xEE, 0x5C, 0x6E, 0x87, 0xAB, 0x74, + 0xEC, 0x94, 0x26, 0xFE, 0x3B, 0xF0, 0x8B, 0x16, + 0xB6, 0x6F, 0x31, 0x4F, 0x64, 0x8E, 0x63, 0x6B, + 0x33, 0x5C, 0x0A, 0xC7, 0x6A, 0xC7, 0x20, 0xFD, + 0x92, 0x3B, 0xCB, 0x61, 0x59, 0x80, 0x30, 0x31, + 0xFC, 0xBB, 0x58, 0x08, 0x04, 0x9E, 0x6D, 0x66, + 0xBE, 0x91, 0x28, 0xF9, 0xC0, 0xAE, 0x2D, 0x7D, + 0xA5, 0x32, 0xF4, 0x3C, 0x76, 0x24, 0x74, 0x39 + }, + { + 0xE0, 0x10, 0xB7, 0x56, 0x06, 0x82, 0x0A, 0x72, + 0xE2, 0x3F, 0xED, 0xC3, 0x87, 0x1E, 0x02, 0xAE, + 0x40, 0x23, 0xC3, 0x4C, 0xF9, 0x70, 0xC4, 0xAA, + 0xB8, 0xDB, 0x4B, 0xE2, 0xB3, 0x7D, 0x2B, 0x49, + 0x6F, 0x8F, 0x4F, 0x2B, 0xBC, 0x44, 0x81, 0xE7, + 0x79, 0x5D, 0xB7, 0x15, 0xA4, 0xB7, 0x18, 0xDD, + 0x18, 0x9A, 0x0F, 0xF3, 0x7B, 0x38, 0x89, 0x89, + 0xCB, 0x76, 0x47, 0x6C, 0x19, 0xB4, 0x34, 0x1B + }, + { + 0x75, 0x50, 0x8D, 0x23, 0xAB, 0x8B, 0xAB, 0xBB, + 0xE8, 0x61, 0xB8, 0x27, 0xB9, 0x6E, 0x42, 0xE9, + 0x22, 0xDB, 0xB3, 0xA1, 0x78, 0xC9, 0x52, 0xD4, + 0x46, 0x56, 0x31, 0x8A, 0xEE, 0xD3, 0x92, 0x36, + 0x51, 0x22, 0x6A, 0xA7, 0x6C, 0xAB, 0x91, 0xF1, + 0x2B, 0x13, 0x78, 0x60, 0x6E, 0x36, 0xBA, 0x27, + 0x0C, 0xF8, 0x35, 0x97, 0xBD, 0x46, 0x5C, 0x75, + 0x62, 0x90, 0xFA, 0x0D, 0xA1, 0xA0, 0x2B, 0x6C + }, + { + 0x18, 0x9F, 0xD7, 0x9E, 0x2E, 0x84, 0x67, 0x02, + 0x54, 0x3B, 0x1F, 0x97, 0x5F, 0x2F, 0x5C, 0x1D, + 0x3F, 0xA8, 0x5E, 0x02, 0x2A, 0x9F, 0x24, 0x35, + 0x68, 0x87, 0x04, 0x8B, 0xE8, 0xEA, 0x1E, 0xDC, + 0x95, 0xD8, 0x96, 0x20, 0x7D, 0x0C, 0x13, 0xFD, + 0x5E, 0x1D, 0xCA, 0x8C, 0x2C, 0xDB, 0xF6, 0x16, + 0xC2, 0x03, 0xFF, 0x91, 0x1D, 0xF0, 0x9E, 0xC3, + 0x22, 0x4F, 0xA3, 0x18, 0x7D, 0x2A, 0x87, 0x15 + }, + { + 0x42, 0x6F, 0x57, 0x06, 0x04, 0x28, 0xF1, 0x99, + 0x73, 0x86, 0x3A, 0x6D, 0xE8, 0x59, 0x72, 0x78, + 0xDA, 0xAB, 0xCB, 0x99, 0xF0, 0xE0, 0xF5, 0x42, + 0x4F, 0xB5, 0x3C, 0xED, 0x3C, 0x3C, 0xCF, 0x9C, + 0x82, 0x1A, 0xBF, 0x71, 0x54, 0xC0, 0xF8, 0x15, + 0x5D, 0xC4, 0x15, 0x73, 0xE2, 0x08, 0x68, 0xB0, + 0x5F, 0xA2, 0x11, 0xB3, 0x46, 0x62, 0x08, 0x53, + 0x22, 0xEA, 0xCB, 0x87, 0xBB, 0x0C, 0xAF, 0x6E + }, + { + 0xA0, 0xA8, 0x43, 0x89, 0x07, 0x76, 0x0C, 0x78, + 0xE5, 0xDD, 0xFC, 0xB2, 0x17, 0x74, 0x66, 0x3F, + 0x4D, 0x9C, 0x3B, 0x66, 0x7B, 0x2D, 0x79, 0x55, + 0x4E, 0xC0, 0x92, 0xA0, 0xB9, 0x27, 0xD9, 0x79, + 0xF1, 0x80, 0x56, 0xAE, 0x12, 0xE7, 0xCC, 0xD4, + 0x92, 0x75, 0x4C, 0xD4, 0x8B, 0xA8, 0xC7, 0x21, + 0x4C, 0x86, 0xCF, 0xAD, 0x40, 0x0E, 0x50, 0xC7, + 0x3B, 0xCF, 0xCF, 0x8A, 0xFB, 0x4D, 0x9D, 0x76 + }, + { + 0xC0, 0x24, 0x80, 0xE4, 0x3F, 0xCB, 0xB5, 0x16, + 0xF4, 0x01, 0x11, 0x1E, 0x84, 0x74, 0x7F, 0xDB, + 0x53, 0xC1, 0xB3, 0xE2, 0x44, 0xDD, 0x46, 0x90, + 0x9B, 0x88, 0x34, 0xBB, 0x65, 0x23, 0x55, 0x3A, + 0x43, 0xFB, 0x07, 0xA0, 0xEB, 0x94, 0xB5, 0xF6, + 0x1C, 0xE4, 0x67, 0x15, 0xD0, 0x66, 0x98, 0x92, + 0xD6, 0xD4, 0x9C, 0x9C, 0x11, 0xBE, 0x7F, 0x66, + 0xCB, 0xE8, 0xB1, 0x53, 0xC4, 0x7B, 0x10, 0xE3 + }, + { + 0xBC, 0xB1, 0xFD, 0x96, 0x9E, 0x2D, 0x44, 0xE5, + 0xB7, 0xDC, 0x27, 0x24, 0xFB, 0xC0, 0xA3, 0xA3, + 0x00, 0xBD, 0xFA, 0x6F, 0xF1, 0x3E, 0x42, 0xEE, + 0x0B, 0xE8, 0xE6, 0x41, 0xF0, 0xCF, 0x05, 0x2D, + 0xCA, 0x81, 0x45, 0xD3, 0x70, 0xF7, 0x25, 0x0B, + 0x24, 0x36, 0x1B, 0x8E, 0x1D, 0xE9, 0x60, 0xA8, + 0xA9, 0xF2, 0xA6, 0x49, 0x39, 0x06, 0x5C, 0xB2, + 0xB6, 0xAB, 0x0E, 0x64, 0xA9, 0x55, 0x7F, 0x33 + }, + { + 0x72, 0x59, 0x9A, 0x9D, 0x31, 0xF1, 0x31, 0xA0, + 0xBB, 0x24, 0xC8, 0xB8, 0x4E, 0xB8, 0x50, 0x49, + 0xB9, 0x37, 0x45, 0x90, 0x4B, 0xA0, 0xDA, 0x97, + 0x89, 0xC5, 0x5F, 0x32, 0xDF, 0xE8, 0x6D, 0x1E, + 0xF1, 0x87, 0x51, 0x26, 0x4B, 0x47, 0x54, 0xE2, + 0x66, 0x54, 0x41, 0x30, 0x2E, 0xE0, 0x7A, 0x5C, + 0x44, 0xAF, 0xF2, 0xA0, 0x08, 0xEB, 0x53, 0x9F, + 0x87, 0xE5, 0x75, 0x25, 0xBA, 0x62, 0x42, 0x27 + }, + { + 0x53, 0x85, 0x7B, 0xF3, 0x19, 0x96, 0x99, 0x4E, + 0x4B, 0xDD, 0x12, 0x72, 0xB9, 0x7C, 0x8B, 0x95, + 0x1A, 0x71, 0x22, 0xA9, 0xD7, 0xC9, 0x1B, 0x01, + 0x7C, 0xA9, 0x11, 0x0B, 0xF6, 0x7F, 0x30, 0x97, + 0x05, 0x7C, 0x74, 0xEE, 0x47, 0xA3, 0x13, 0x2F, + 0x26, 0xDF, 0x4B, 0x7B, 0x81, 0xCE, 0x30, 0x40, + 0xDD, 0x43, 0x2D, 0x67, 0x8F, 0x9D, 0xCF, 0xB3, + 0xBA, 0x06, 0x75, 0x1D, 0x41, 0xA5, 0xE0, 0x02 + }, + { + 0x86, 0x1D, 0x8F, 0xFD, 0xF5, 0x4B, 0x80, 0x12, + 0xA5, 0x3E, 0x1F, 0xF8, 0xB4, 0xC3, 0xCE, 0x42, + 0xDA, 0x81, 0x22, 0xC8, 0x64, 0xCD, 0x2D, 0xDD, + 0x48, 0xDB, 0x01, 0xA3, 0xA1, 0xAC, 0x7D, 0x23, + 0x16, 0x68, 0x65, 0xB6, 0xB0, 0x01, 0xAF, 0x2F, + 0x5C, 0x0E, 0x05, 0x25, 0x47, 0x38, 0x64, 0xA0, + 0x10, 0xCA, 0xA3, 0x68, 0x76, 0x9D, 0x49, 0xF1, + 0x9E, 0x38, 0x52, 0x81, 0x06, 0xBF, 0xDE, 0x5B + }, + { + 0x9E, 0xD9, 0x5B, 0x72, 0x46, 0x62, 0x8B, 0xFE, + 0x71, 0xF4, 0x73, 0xF1, 0x93, 0x0C, 0x6A, 0xEB, + 0xA1, 0x1A, 0x59, 0xA9, 0x39, 0x97, 0x10, 0xCB, + 0xC6, 0x85, 0x1F, 0xA9, 0x54, 0x69, 0x7D, 0x68, + 0x86, 0x5B, 0x9A, 0x06, 0x9C, 0x40, 0x9F, 0xF4, + 0x02, 0xA2, 0x94, 0x08, 0x44, 0x56, 0xA4, 0x32, + 0x56, 0xEC, 0x41, 0x1E, 0x82, 0xF5, 0xB5, 0x51, + 0x2C, 0x0B, 0x5E, 0x30, 0xFD, 0x9E, 0xFA, 0x87 + }, + { + 0xF1, 0x2E, 0x99, 0xDE, 0x76, 0x5D, 0x5C, 0x88, + 0x4A, 0xC6, 0x19, 0x94, 0x25, 0xC3, 0x8D, 0xF9, + 0xEB, 0xC5, 0xAA, 0x59, 0x12, 0xED, 0x92, 0x49, + 0xEB, 0x08, 0xBB, 0xA5, 0x2D, 0x95, 0xC0, 0x91, + 0x4A, 0x13, 0x03, 0x12, 0xB8, 0x44, 0x9B, 0x40, + 0x81, 0xB5, 0x68, 0xC4, 0xA3, 0x90, 0x98, 0x06, + 0x4C, 0x93, 0xEE, 0xFC, 0x62, 0xAD, 0xF8, 0xB6, + 0x8F, 0xA7, 0x30, 0x83, 0x6D, 0x38, 0x63, 0xC1 + }, + { + 0x8C, 0x7F, 0x8A, 0xB8, 0xAD, 0x10, 0xF9, 0x71, + 0x54, 0x9C, 0xAE, 0xCA, 0x31, 0x3E, 0x54, 0x0D, + 0x24, 0x95, 0xBE, 0x79, 0xE4, 0xAB, 0x9D, 0x9A, + 0xC1, 0xE4, 0x52, 0xD3, 0x16, 0x63, 0x00, 0x98, + 0x08, 0x3E, 0x79, 0x34, 0x61, 0x8C, 0xDE, 0x2F, + 0x55, 0x4D, 0xFD, 0xB2, 0x15, 0xED, 0x0F, 0xDE, + 0x78, 0x8D, 0x21, 0x8C, 0x89, 0xB9, 0xAB, 0xDE, + 0x22, 0xAD, 0x16, 0x0A, 0x5C, 0xC2, 0xB5, 0xCA + }, + { + 0x5F, 0x0D, 0xD4, 0xF0, 0x2D, 0x52, 0xF3, 0xC6, + 0xCA, 0xF9, 0xB9, 0xF9, 0xF7, 0x99, 0xFA, 0x5E, + 0x9B, 0xD8, 0xEB, 0x2A, 0xCC, 0xE5, 0xFC, 0xD9, + 0x28, 0x1B, 0xA9, 0x37, 0x1A, 0x5B, 0x55, 0x7F, + 0x8A, 0xCC, 0xE9, 0xBA, 0xE6, 0xE0, 0xF0, 0x48, + 0xA8, 0x70, 0xF4, 0xBA, 0x9D, 0x0D, 0x88, 0xB6, + 0x5A, 0x95, 0xCB, 0xF6, 0x94, 0x2C, 0xBF, 0x62, + 0x91, 0x9B, 0xCD, 0xB3, 0xD8, 0x11, 0xC7, 0x98 + }, + { + 0x88, 0x0D, 0x70, 0x59, 0xAC, 0xAF, 0xB1, 0xAA, + 0x8B, 0x5E, 0xFA, 0x26, 0x74, 0xC7, 0x64, 0x30, + 0x58, 0x9B, 0xD2, 0xEB, 0x2E, 0xBB, 0x01, 0xE6, + 0x1A, 0x56, 0xCD, 0x32, 0x5B, 0xBA, 0xF4, 0xEE, + 0x3E, 0xF2, 0xDE, 0x58, 0x7F, 0xD9, 0xB4, 0xE4, + 0xF7, 0xA8, 0xFF, 0x69, 0xF7, 0x67, 0xB6, 0x4D, + 0x52, 0xFB, 0x29, 0xA7, 0xA5, 0x5D, 0xAB, 0x8F, + 0x05, 0x55, 0x49, 0xF3, 0xD3, 0x11, 0x54, 0x96 + }, + { + 0x9D, 0x0D, 0xAF, 0x06, 0x2A, 0xF6, 0x01, 0xB9, + 0x26, 0x8C, 0x1E, 0xFA, 0xBE, 0x93, 0x66, 0x1A, + 0x68, 0x1D, 0xDD, 0x44, 0x60, 0x32, 0x28, 0xBA, + 0xB5, 0x88, 0x25, 0x19, 0x37, 0x72, 0x3B, 0x0B, + 0x8A, 0x26, 0xB0, 0xB1, 0x7B, 0xCC, 0x00, 0xDD, + 0x00, 0xF4, 0x25, 0x87, 0x99, 0x00, 0x7E, 0x15, + 0xC9, 0x3E, 0x94, 0x2C, 0x67, 0x7D, 0x1C, 0x58, + 0xBA, 0x43, 0x80, 0x5B, 0xDE, 0x4D, 0x5F, 0x9B + }, + { + 0xC6, 0x2A, 0x9B, 0x69, 0x40, 0xED, 0xEB, 0xDA, + 0x7D, 0x84, 0x16, 0x9D, 0xB3, 0x5E, 0x12, 0xB7, + 0x2D, 0xCE, 0x9F, 0xAB, 0x19, 0x6A, 0x78, 0x5C, + 0x22, 0xE4, 0x50, 0x3B, 0xD6, 0x99, 0xFD, 0x00, + 0x9E, 0x22, 0x63, 0x53, 0xE1, 0x79, 0x15, 0xC8, + 0xFE, 0x6F, 0xAA, 0x75, 0xF7, 0xC8, 0xD1, 0x27, + 0xB2, 0x33, 0xCC, 0x06, 0x16, 0x7E, 0x9C, 0x99, + 0xAA, 0x5A, 0x8A, 0xCB, 0x1E, 0x5E, 0x6D, 0x40 + }, + { + 0x57, 0x76, 0x09, 0xCC, 0xD3, 0xB1, 0x8B, 0x6F, + 0xB9, 0xDF, 0x50, 0x74, 0xB0, 0x1D, 0xC0, 0x28, + 0x91, 0xBB, 0x64, 0x4F, 0xF9, 0x3E, 0x9D, 0x7D, + 0x11, 0xA7, 0x84, 0xF2, 0x8C, 0xA3, 0xAA, 0xE3, + 0x8C, 0x57, 0x75, 0x50, 0xB8, 0x44, 0x6D, 0xFD, + 0xBD, 0x53, 0xA8, 0x1C, 0xEA, 0xED, 0xF4, 0x33, + 0xA4, 0x58, 0x22, 0x7A, 0x43, 0x99, 0x2B, 0xD4, + 0x4A, 0x99, 0x50, 0x1C, 0x4F, 0xBC, 0x85, 0x31 + }, + { + 0x51, 0xD8, 0x4A, 0xA0, 0x36, 0xF8, 0x21, 0x69, + 0x07, 0x54, 0xD7, 0x60, 0xF8, 0x05, 0xAC, 0x2A, + 0xE0, 0xF7, 0x83, 0xFE, 0x8E, 0xF4, 0xE8, 0xFC, + 0x06, 0xF5, 0xA5, 0x10, 0xC1, 0xAC, 0x6F, 0x2F, + 0x07, 0x74, 0xF1, 0x3D, 0x97, 0x71, 0xA7, 0x0E, + 0xE3, 0x77, 0xD8, 0x6A, 0x32, 0xE3, 0x7A, 0x41, + 0x70, 0xE6, 0x32, 0xEB, 0xD1, 0xA9, 0x5D, 0xDC, + 0x06, 0x3B, 0xF5, 0xF5, 0xBF, 0xB5, 0x2E, 0xEB + }, + { + 0x51, 0xDF, 0xE3, 0x7F, 0x4E, 0xE2, 0x27, 0xD2, + 0x1E, 0xE3, 0x78, 0xA9, 0x80, 0x9E, 0x9A, 0xCD, + 0x4E, 0xE5, 0xC2, 0x76, 0x45, 0xFE, 0x87, 0xAE, + 0x43, 0xDC, 0x9F, 0xAF, 0x55, 0xCE, 0xAA, 0x93, + 0xC2, 0x43, 0x94, 0x64, 0xD8, 0x49, 0x68, 0xB2, + 0x4F, 0xB7, 0xE5, 0x5E, 0x78, 0x6A, 0x28, 0x57, + 0x1C, 0x85, 0xBF, 0x64, 0x11, 0x76, 0xAE, 0xCE, + 0x7E, 0x0A, 0xA1, 0x92, 0x62, 0x47, 0xA6, 0x93 + }, + { + 0x6D, 0x24, 0x79, 0x40, 0xCE, 0x1A, 0x64, 0x58, + 0x0B, 0xD9, 0x43, 0x86, 0x5A, 0x88, 0xE2, 0x08, + 0x44, 0xC3, 0x79, 0x98, 0xC0, 0xA2, 0x5F, 0xD3, + 0xF5, 0x43, 0x1E, 0x00, 0x1A, 0xA7, 0x1E, 0x5F, + 0x2E, 0xC1, 0xD6, 0x17, 0x94, 0x30, 0xAC, 0x3C, + 0x41, 0x96, 0xDC, 0xA5, 0xBA, 0x9F, 0xF5, 0xA3, + 0x2B, 0xF9, 0xD8, 0x52, 0x11, 0x2B, 0xAC, 0x51, + 0x54, 0xEA, 0x4B, 0x52, 0xBF, 0x31, 0xCB, 0x00 + }, + { + 0xC1, 0xAF, 0xF3, 0x2E, 0x63, 0x63, 0xDE, 0xA2, + 0x28, 0xDB, 0xF0, 0x31, 0x7D, 0x06, 0x5A, 0x85, + 0x39, 0xE0, 0x09, 0xA8, 0x79, 0xC7, 0xD2, 0xF4, + 0x91, 0xD0, 0x46, 0x3B, 0xAD, 0x29, 0x62, 0xF6, + 0x0D, 0x23, 0xE6, 0x7A, 0x34, 0xEB, 0xED, 0xC3, + 0xEC, 0xF3, 0x98, 0x22, 0x59, 0xEA, 0x8E, 0xB7, + 0x45, 0xE9, 0xED, 0x10, 0x73, 0xBE, 0x5E, 0xA6, + 0x97, 0x32, 0xE0, 0xD9, 0xF1, 0xB5, 0x8A, 0x9E + }, + { + 0xEB, 0x75, 0xB5, 0x2F, 0x09, 0xFB, 0x56, 0x51, + 0xA3, 0x18, 0x30, 0x42, 0x64, 0x08, 0x1E, 0x15, + 0xA1, 0x2A, 0x94, 0xE4, 0x60, 0x27, 0x49, 0x9D, + 0x81, 0x71, 0xE9, 0x13, 0x0B, 0x40, 0x50, 0x54, + 0xA6, 0xB3, 0x19, 0x9B, 0xCF, 0x77, 0x67, 0x17, + 0x37, 0xEE, 0x8E, 0xBD, 0x25, 0x94, 0xD6, 0x30, + 0xB3, 0x91, 0xFC, 0x93, 0x2B, 0xE4, 0x62, 0xEA, + 0xAD, 0xB1, 0xC3, 0x5D, 0x3D, 0x5D, 0x32, 0xDA + }, + { + 0x7B, 0xA5, 0xC6, 0x44, 0x52, 0xC1, 0x44, 0x64, + 0x34, 0xA0, 0x46, 0x4D, 0xFA, 0x29, 0x7E, 0x28, + 0x24, 0x23, 0x53, 0x67, 0x8F, 0xD0, 0xBF, 0xC0, + 0x6E, 0x4D, 0x41, 0x98, 0x3F, 0xFF, 0xBD, 0xF2, + 0x8A, 0x97, 0xCA, 0x5F, 0xB6, 0x71, 0x4C, 0x07, + 0x51, 0xE6, 0x4B, 0x98, 0xCA, 0x3C, 0xD6, 0xA3, + 0x16, 0xE8, 0x0C, 0x2D, 0x72, 0x77, 0x17, 0xC1, + 0x71, 0x9B, 0xD6, 0x90, 0xE1, 0xC9, 0x6E, 0xA2 + }, + { + 0x4F, 0x06, 0xD9, 0x54, 0x34, 0x92, 0x0B, 0xCD, + 0xAE, 0x5F, 0xA6, 0x6E, 0x71, 0x6A, 0x6F, 0xAD, + 0x0E, 0x02, 0xE4, 0x39, 0x0F, 0x83, 0xF1, 0x60, + 0x47, 0x68, 0xF2, 0xCE, 0x1E, 0x95, 0x3A, 0x72, + 0x55, 0xCE, 0xDC, 0xED, 0x17, 0x29, 0x02, 0xB8, + 0xF0, 0xE1, 0xDA, 0xC6, 0x80, 0x53, 0x7F, 0xAD, + 0x4C, 0x96, 0xB4, 0x48, 0x40, 0x65, 0x65, 0x5E, + 0x21, 0x7B, 0x35, 0xB9, 0xBC, 0xDF, 0xEF, 0x9A + }, + { + 0xEE, 0x8F, 0x1C, 0xEF, 0x8D, 0x14, 0x8D, 0xBA, + 0x29, 0xD1, 0x4A, 0x2C, 0x9A, 0x7B, 0x9A, 0xEE, + 0x26, 0x45, 0xA2, 0x7B, 0xA0, 0xAD, 0xD2, 0x61, + 0xB7, 0x59, 0xC8, 0xB8, 0xC9, 0x31, 0x81, 0xA8, + 0x12, 0xD5, 0x07, 0x05, 0x92, 0x5F, 0x2E, 0xB3, + 0xEE, 0xD6, 0x32, 0x4A, 0x71, 0xF4, 0x4A, 0x59, + 0xBC, 0x46, 0xD8, 0xCD, 0xFD, 0x25, 0x8B, 0xD5, + 0xDD, 0xC4, 0x0C, 0x51, 0x1D, 0x70, 0x31, 0xC5 + }, + { + 0x48, 0xDE, 0xF6, 0x41, 0xB4, 0x45, 0x1B, 0x1D, + 0x7C, 0x71, 0x3F, 0xCA, 0x02, 0x0E, 0x04, 0x15, + 0x44, 0x1B, 0xDF, 0x00, 0xB5, 0x73, 0x51, 0xCF, + 0xB8, 0x58, 0x9F, 0x6D, 0x34, 0xF1, 0x75, 0x6A, + 0xFA, 0x0D, 0x38, 0x6E, 0x20, 0x70, 0x03, 0xE9, + 0x10, 0xFA, 0xFC, 0x74, 0xC2, 0x84, 0xBC, 0x37, + 0xC8, 0x12, 0x18, 0xA8, 0xA7, 0x20, 0xA6, 0xFE, + 0x9C, 0xD2, 0x30, 0x7D, 0x44, 0x63, 0x28, 0x46 + }, + { + 0x45, 0x01, 0xA0, 0x34, 0xE7, 0xAF, 0xAF, 0x89, + 0x98, 0x41, 0xE5, 0x4A, 0xE2, 0xBA, 0xD1, 0xF9, + 0xDD, 0xC3, 0x98, 0xC9, 0xCE, 0xFB, 0x46, 0x6C, + 0x4A, 0x2D, 0xA8, 0x32, 0x8A, 0xEA, 0x84, 0x63, + 0x7B, 0x41, 0x9E, 0x03, 0x16, 0xEB, 0x53, 0x7E, + 0x78, 0xD8, 0x5B, 0x1F, 0x32, 0x57, 0xCD, 0x93, + 0x36, 0x2A, 0x7F, 0x07, 0x7B, 0x5B, 0xA6, 0xE8, + 0xE2, 0x62, 0x12, 0xD0, 0x7C, 0x54, 0x09, 0x9E + }, + { + 0xC2, 0x95, 0xE1, 0x40, 0x25, 0x2F, 0xDF, 0x64, + 0x6D, 0x41, 0xA4, 0xA9, 0xCF, 0x9D, 0x72, 0x58, + 0x21, 0xAD, 0xB9, 0x1D, 0xE3, 0xD3, 0xCA, 0xE3, + 0xF5, 0xD6, 0xB1, 0x9B, 0x70, 0xAF, 0x28, 0x84, + 0xBE, 0xC4, 0x87, 0x36, 0xC2, 0x7A, 0x47, 0xE4, + 0x30, 0x40, 0xFC, 0x48, 0xE8, 0x87, 0x4A, 0x65, + 0xDD, 0xBF, 0xD9, 0xBD, 0xA2, 0x35, 0xF7, 0x9A, + 0xCC, 0x51, 0x63, 0x39, 0x53, 0x34, 0xE9, 0x8B + }, + { + 0x71, 0x7B, 0xAF, 0x7B, 0xC5, 0x91, 0x2A, 0x23, + 0x4D, 0x49, 0x2F, 0xC6, 0xAB, 0x7F, 0x39, 0x70, + 0x39, 0xFF, 0x94, 0xAC, 0x95, 0xC8, 0x49, 0x13, + 0x2F, 0x83, 0xB8, 0x65, 0x61, 0x3B, 0x3E, 0x0D, + 0x18, 0xB9, 0xBD, 0x04, 0x9E, 0xC5, 0x61, 0x38, + 0xEF, 0x7D, 0x8D, 0x98, 0x5A, 0xFD, 0x02, 0xBF, + 0x9F, 0x36, 0x51, 0x74, 0x37, 0x2A, 0x74, 0xB2, + 0xF9, 0x9E, 0x61, 0xFF, 0xC0, 0x36, 0xFE, 0x9D + }, + { + 0x66, 0x22, 0xA6, 0xB6, 0xB6, 0x0E, 0x96, 0x0F, + 0xB2, 0xF2, 0x93, 0x32, 0xBD, 0x96, 0x09, 0xA2, + 0x14, 0xF7, 0xAE, 0x70, 0x15, 0x42, 0xBB, 0x06, + 0xBE, 0x02, 0x22, 0x57, 0xF3, 0xF7, 0x8F, 0x0E, + 0xA5, 0x20, 0xB8, 0x50, 0x5D, 0x2C, 0x05, 0x7E, + 0x6D, 0xCA, 0x86, 0x9A, 0x9A, 0x39, 0x7E, 0x17, + 0x60, 0x58, 0x09, 0x10, 0x2F, 0x5C, 0x47, 0xCA, + 0xF5, 0x4B, 0xF7, 0xF8, 0x88, 0xF4, 0x11, 0xED + }, + { + 0x7A, 0x4F, 0x39, 0x51, 0x76, 0x9B, 0xF9, 0x3E, + 0xCD, 0x6A, 0x68, 0xD1, 0x26, 0xFC, 0x5D, 0x04, + 0x23, 0x63, 0x4F, 0x07, 0x75, 0x8A, 0xBE, 0x09, + 0xF1, 0xB6, 0xBF, 0x8E, 0xBF, 0x89, 0x54, 0xF8, + 0xB9, 0x57, 0xE1, 0x4B, 0xD8, 0xBC, 0x98, 0xD2, + 0xB7, 0x23, 0xD8, 0x22, 0x87, 0x36, 0x2E, 0x90, + 0xE8, 0x40, 0x26, 0x82, 0xEE, 0x6F, 0xEF, 0x2A, + 0x93, 0x52, 0xBB, 0xF0, 0x0C, 0xE6, 0x6D, 0x86 + }, + { + 0x0A, 0xE6, 0xC7, 0xC0, 0x41, 0x91, 0x6C, 0x5D, + 0xDC, 0x31, 0x08, 0x13, 0x82, 0xB8, 0xF3, 0x9B, + 0x2E, 0x5D, 0x08, 0x36, 0x7E, 0xE4, 0xF8, 0xAF, + 0x53, 0x6F, 0x81, 0x82, 0x46, 0xD6, 0xA4, 0x63, + 0x4F, 0xD5, 0x63, 0x50, 0xE5, 0x4F, 0xA8, 0x07, + 0xAC, 0x46, 0x14, 0xA1, 0x68, 0x3F, 0xF5, 0x6D, + 0x8E, 0xC5, 0xF1, 0x39, 0x0B, 0x21, 0x7E, 0x85, + 0x5D, 0xDD, 0x98, 0xA2, 0x8F, 0x1F, 0xAC, 0x4E + }, + { + 0x8E, 0x0E, 0xA0, 0x19, 0xE6, 0x7A, 0x41, 0x27, + 0xB4, 0xC6, 0xE3, 0x61, 0xF5, 0x44, 0x4B, 0xBF, + 0xAA, 0xCD, 0x0C, 0xC3, 0xF5, 0x19, 0xC9, 0x32, + 0xB9, 0xFC, 0x31, 0x91, 0x0D, 0xA8, 0x4F, 0x24, + 0x81, 0x15, 0x97, 0x14, 0x89, 0x0F, 0x30, 0x3E, + 0xBA, 0xDA, 0x90, 0x96, 0xF8, 0xB3, 0xE2, 0x0E, + 0x7E, 0xDA, 0xE7, 0x6F, 0x5A, 0x0A, 0xA8, 0xDF, + 0x04, 0x77, 0x85, 0x32, 0x10, 0x7C, 0xA1, 0x23 + }, + { + 0xE8, 0xE7, 0xC6, 0x8F, 0x2B, 0x1C, 0xA8, 0xC1, + 0xC5, 0xA9, 0x1E, 0x0E, 0x0F, 0x5A, 0x50, 0x52, + 0x3C, 0xDC, 0xF0, 0x7D, 0xC0, 0x41, 0xFD, 0x7F, + 0x20, 0x75, 0x67, 0xFC, 0xDC, 0x2E, 0xFC, 0x93, + 0x78, 0xA2, 0x1C, 0x84, 0x50, 0xEB, 0x21, 0x19, + 0xD0, 0xC5, 0x8F, 0x53, 0x05, 0xEA, 0xE1, 0xB6, + 0x57, 0xDE, 0xC0, 0x10, 0xDC, 0xA5, 0xA3, 0x69, + 0xD4, 0xBB, 0x36, 0x45, 0x93, 0x8F, 0xB3, 0xBB + }, + { + 0x80, 0x69, 0x28, 0x97, 0x90, 0x44, 0xE0, 0xD0, + 0x12, 0x36, 0xC5, 0x84, 0xD7, 0xAE, 0x98, 0x90, + 0x9A, 0x67, 0x25, 0x30, 0x85, 0x7D, 0x54, 0xA4, + 0xC7, 0x35, 0xB8, 0x2B, 0xDE, 0xD5, 0x22, 0xF1, + 0xFF, 0x9D, 0xE0, 0x07, 0x83, 0x49, 0x44, 0xD0, + 0xF1, 0x9B, 0x7F, 0x5E, 0xA4, 0x5E, 0x16, 0xC0, + 0xD4, 0x40, 0x24, 0xCE, 0x9C, 0x1B, 0xF1, 0x0E, + 0x76, 0xCA, 0xBF, 0x95, 0x97, 0x87, 0x6E, 0xFB + }, + { + 0x6C, 0xEE, 0x47, 0x23, 0x03, 0x83, 0x77, 0x4A, + 0x07, 0xBF, 0x82, 0xA9, 0xAF, 0xAC, 0xBF, 0x7D, + 0xCE, 0x39, 0xC8, 0xD4, 0x5E, 0xAF, 0xC7, 0x4C, + 0x51, 0x50, 0x3E, 0x01, 0x92, 0x22, 0xD2, 0x52, + 0x7F, 0xD5, 0x1E, 0xE1, 0x25, 0xFA, 0x2B, 0x71, + 0x8E, 0xA3, 0xA1, 0x9E, 0x4E, 0x7C, 0x4F, 0x12, + 0x9A, 0xFC, 0x49, 0xA4, 0xDD, 0x2A, 0x70, 0x62, + 0x3C, 0xA3, 0x65, 0x41, 0xB2, 0xD0, 0x63, 0xA3 + }, + { + 0x84, 0x54, 0xCA, 0x13, 0xBC, 0x99, 0x93, 0xDE, + 0x48, 0x6F, 0x42, 0x3E, 0x41, 0xC4, 0x44, 0xE5, + 0x48, 0x1F, 0x86, 0x12, 0x40, 0x81, 0xE9, 0x9D, + 0xAB, 0xB9, 0xB8, 0xAC, 0x21, 0x52, 0x3A, 0x4A, + 0xB8, 0x84, 0xEB, 0x4C, 0x40, 0x2B, 0x01, 0xAF, + 0xB9, 0x7C, 0x25, 0x6C, 0x94, 0xBF, 0x84, 0x3C, + 0x5F, 0x72, 0x7E, 0xA7, 0xDC, 0x26, 0x62, 0xBE, + 0xE3, 0xCD, 0xF4, 0x71, 0xE2, 0x76, 0x38, 0xE3 + }, + { + 0x47, 0x6F, 0x13, 0xD1, 0x6A, 0xE0, 0x25, 0x46, + 0xF3, 0xDA, 0xF0, 0xF8, 0xFB, 0xD2, 0xA7, 0xC0, + 0x29, 0x95, 0x94, 0x5A, 0xCE, 0x00, 0xBB, 0xF4, + 0x87, 0x04, 0x79, 0x4D, 0xBC, 0x2B, 0x93, 0xEF, + 0x2B, 0xB9, 0xE7, 0x18, 0x4D, 0xB2, 0x17, 0x2D, + 0x55, 0x8B, 0x6A, 0x73, 0x18, 0x81, 0x9E, 0xA7, + 0xD7, 0xDE, 0xA8, 0xBA, 0xF0, 0x70, 0x99, 0x2D, + 0xEF, 0xB1, 0x85, 0x7E, 0xEC, 0x14, 0xE4, 0x78 + }, + { + 0x5F, 0x37, 0xCB, 0x92, 0x16, 0xD5, 0xF7, 0x4F, + 0xAE, 0xF3, 0x1D, 0x01, 0x1E, 0x9C, 0x8E, 0x44, + 0xD2, 0x31, 0xDD, 0x21, 0x61, 0xD4, 0x2E, 0xF2, + 0xFA, 0x34, 0xC7, 0x15, 0x73, 0x27, 0x96, 0x55, + 0xB0, 0x1E, 0x33, 0xD4, 0x3A, 0xB6, 0x81, 0x93, + 0x54, 0x0E, 0xDA, 0xA4, 0x9B, 0xBC, 0xE5, 0x25, + 0xE9, 0xEE, 0xFE, 0xB4, 0xE0, 0xB6, 0xF8, 0xC0, + 0xB7, 0x9E, 0xC9, 0xF2, 0x97, 0x49, 0x23, 0xDA + }, + { + 0xA0, 0xA6, 0xB6, 0xDC, 0xB2, 0xA1, 0x0D, 0x4C, + 0x72, 0xDB, 0x39, 0x4A, 0xE6, 0x71, 0x6A, 0x10, + 0x0C, 0x5C, 0x88, 0x9E, 0xB9, 0x45, 0xD6, 0x56, + 0x7D, 0x14, 0x9F, 0x73, 0x51, 0x31, 0x8D, 0xA0, + 0xC8, 0x37, 0x2B, 0xCE, 0x1F, 0x20, 0xCE, 0xB5, + 0xC6, 0xB9, 0x9F, 0x8E, 0x24, 0xB1, 0x6C, 0x9B, + 0x96, 0xF3, 0x1D, 0xD0, 0x78, 0x0E, 0xFD, 0x11, + 0xF0, 0x00, 0xC4, 0xE2, 0x52, 0xEA, 0x85, 0x7A + }, + { + 0xC4, 0x23, 0xF4, 0xE0, 0x2B, 0xA7, 0xC8, 0xD6, + 0xBC, 0xE4, 0x54, 0xA5, 0x52, 0x8F, 0x81, 0x07, + 0x20, 0x1E, 0xD3, 0x0C, 0x48, 0x97, 0x00, 0x3A, + 0x84, 0xFB, 0xAE, 0x76, 0xE6, 0x18, 0x25, 0x80, + 0xA3, 0xCD, 0x43, 0x88, 0x4D, 0xE4, 0xA8, 0x47, + 0x7A, 0xAB, 0x21, 0x14, 0xDD, 0x73, 0x33, 0x3F, + 0x64, 0x98, 0xF7, 0x42, 0xAA, 0x51, 0x92, 0x3E, + 0x74, 0x8F, 0xAF, 0x76, 0x46, 0x36, 0x14, 0x74 + }, + { + 0x9C, 0xFD, 0x57, 0xD9, 0xFA, 0x7D, 0xBD, 0x86, + 0x42, 0x00, 0x08, 0x15, 0x72, 0xC1, 0x81, 0xB1, + 0x87, 0x1F, 0x0B, 0x8F, 0x6D, 0x0A, 0x73, 0x3C, + 0x77, 0xF3, 0xB3, 0xB6, 0x30, 0x9A, 0x59, 0x66, + 0x54, 0x63, 0xF0, 0x3F, 0x35, 0x45, 0x35, 0x29, + 0x91, 0xA1, 0x7A, 0x1B, 0x9A, 0xF6, 0xE4, 0x41, + 0x31, 0xB9, 0x80, 0x91, 0xCA, 0x1D, 0x26, 0xD9, + 0xE2, 0xD1, 0x6D, 0x40, 0x9B, 0x97, 0x43, 0xAA + }, + { + 0x64, 0xB8, 0x0E, 0x76, 0x3B, 0xF5, 0x84, 0xD0, + 0xB6, 0x6D, 0x9B, 0x24, 0xFE, 0x2D, 0x40, 0xA8, + 0xB4, 0x99, 0xF6, 0xE1, 0xF7, 0x41, 0x4B, 0xC7, + 0x02, 0xD7, 0x99, 0xE3, 0x60, 0x54, 0x0A, 0x5A, + 0xF7, 0x11, 0x46, 0x16, 0xE5, 0x3C, 0xBA, 0x2E, + 0xFA, 0x1B, 0x0F, 0x0F, 0xB3, 0x68, 0x39, 0xDF, + 0x6D, 0x0F, 0xD6, 0xA8, 0x23, 0xF7, 0x72, 0x47, + 0x1B, 0x6D, 0x13, 0xC9, 0xFB, 0x94, 0xA8, 0xB3 + }, + { + 0x07, 0xBE, 0x6F, 0x74, 0x10, 0x5D, 0x33, 0x6E, + 0xE0, 0x47, 0xA9, 0x86, 0xC4, 0x4B, 0xEA, 0x77, + 0x76, 0x04, 0x93, 0x31, 0x05, 0xC6, 0xF4, 0x3E, + 0x2C, 0xA6, 0xF2, 0x11, 0x3C, 0xD3, 0x2A, 0x6C, + 0x46, 0x47, 0xC7, 0x48, 0x22, 0xAE, 0x57, 0xA9, + 0xF1, 0x72, 0x4C, 0x73, 0x99, 0x3E, 0x4F, 0x8B, + 0x25, 0xCF, 0xBC, 0xD3, 0x7D, 0xD5, 0xE6, 0x86, + 0xDA, 0x30, 0xFD, 0x79, 0xE7, 0x08, 0x8C, 0xF5 + }, + { + 0xFB, 0x40, 0xEE, 0x3A, 0xBC, 0x58, 0xC8, 0x57, + 0xF3, 0x41, 0xF0, 0xCF, 0x7E, 0xBE, 0x41, 0xF1, + 0xB8, 0x84, 0x43, 0xAD, 0x05, 0x27, 0x24, 0x8A, + 0x7C, 0xF5, 0xF9, 0x93, 0x34, 0x16, 0xBB, 0xD1, + 0x04, 0x9C, 0x8A, 0x99, 0x5A, 0x30, 0xE0, 0x0C, + 0x7E, 0xF4, 0x90, 0x32, 0x92, 0x96, 0xB7, 0xD5, + 0x37, 0x24, 0x63, 0x63, 0x0C, 0xAB, 0x35, 0x4C, + 0x82, 0x39, 0x62, 0x7B, 0x85, 0x10, 0xD4, 0xFD + }, + { + 0xF9, 0x66, 0xA4, 0xA2, 0xAC, 0x77, 0x86, 0xEE, + 0x8E, 0x22, 0x3F, 0xF9, 0x1D, 0x0D, 0x5A, 0x03, + 0x04, 0x9C, 0xF1, 0xB0, 0xC2, 0x1E, 0x52, 0x16, + 0x60, 0x9F, 0xF2, 0x7F, 0xD1, 0xEB, 0xDA, 0x45, + 0x56, 0xC4, 0x40, 0xE6, 0xD2, 0x3B, 0x26, 0x3E, + 0xE5, 0xB5, 0x71, 0x82, 0x51, 0xE3, 0x28, 0x36, + 0x5E, 0x3D, 0x45, 0xC7, 0x13, 0x43, 0xB7, 0x09, + 0x2E, 0xDC, 0x10, 0x29, 0xE9, 0xEF, 0x67, 0x0E + }, + { + 0x33, 0x4C, 0xBA, 0xEB, 0xB2, 0x41, 0x48, 0xB4, + 0xCF, 0xF7, 0x37, 0x1A, 0x88, 0x94, 0x30, 0x16, + 0xAC, 0x18, 0xC0, 0xA0, 0x77, 0xDB, 0xF5, 0x0F, + 0x2C, 0x57, 0x22, 0x7C, 0x21, 0xA3, 0x04, 0x76, + 0x88, 0xE5, 0xEF, 0x03, 0xF1, 0xD3, 0x3B, 0x3A, + 0xA6, 0xA7, 0x9A, 0x4C, 0x57, 0x69, 0x39, 0xB1, + 0x5D, 0x68, 0x1B, 0x12, 0xF0, 0xBB, 0xBB, 0xBD, + 0xF8, 0x11, 0x48, 0x32, 0x45, 0x25, 0x30, 0xCE + }, + { + 0xFD, 0xAA, 0xDB, 0xAC, 0x1F, 0xDC, 0x3B, 0x46, + 0xDE, 0xBA, 0x2C, 0xFE, 0xD2, 0x26, 0x9E, 0xE1, + 0x5D, 0xB5, 0xFC, 0xF9, 0x7A, 0x29, 0xC4, 0x02, + 0x5E, 0x2A, 0x51, 0xDD, 0x12, 0xA2, 0xF9, 0x24, + 0x0C, 0x5B, 0x80, 0xBC, 0x1B, 0x03, 0xA7, 0x40, + 0xBF, 0xC4, 0xC2, 0x9E, 0x12, 0x26, 0x3F, 0xC2, + 0x5D, 0x29, 0x86, 0x3B, 0x19, 0x60, 0x4D, 0x47, + 0x87, 0x06, 0xEE, 0x46, 0x47, 0x99, 0x90, 0x9F + }, + { + 0x25, 0x6E, 0x8B, 0x91, 0x63, 0xD7, 0xEA, 0xB0, + 0x3B, 0x91, 0xD3, 0x79, 0x2D, 0x3C, 0xFA, 0x23, + 0x5D, 0x61, 0xED, 0xDD, 0x34, 0xD7, 0xD6, 0x8A, + 0x1D, 0xC7, 0x6D, 0xC9, 0x23, 0x40, 0x73, 0x4B, + 0xFC, 0xA8, 0x03, 0x24, 0xC5, 0x22, 0x78, 0x01, + 0x1E, 0x42, 0x4C, 0xB5, 0xC7, 0x24, 0x16, 0x14, + 0xB0, 0xE5, 0xBE, 0x4F, 0x80, 0x89, 0x4D, 0x79, + 0xA1, 0x48, 0xEF, 0x96, 0x30, 0x64, 0x2C, 0xF8 + }, + { + 0x5A, 0xFA, 0x95, 0xD9, 0x5F, 0xE5, 0xE8, 0xBE, + 0x95, 0xDC, 0xD5, 0x5E, 0xF6, 0xFE, 0xD6, 0x19, + 0xEA, 0xFA, 0x55, 0x78, 0x30, 0x6C, 0xFB, 0x4A, + 0x4E, 0xB8, 0x35, 0x6D, 0x64, 0x52, 0x8B, 0xDE, + 0x3E, 0x41, 0x50, 0xC3, 0x16, 0x84, 0x18, 0x0C, + 0x7C, 0xE3, 0x0B, 0x3A, 0x22, 0x17, 0xD7, 0xC8, + 0xD4, 0xE4, 0xE8, 0x2F, 0x21, 0xB8, 0x10, 0xAD, + 0x4D, 0x46, 0x4A, 0xB6, 0x39, 0x9D, 0x9F, 0xDC + }, + { + 0x5F, 0x26, 0x32, 0xCC, 0x14, 0x3A, 0xBB, 0x67, + 0x5C, 0x4E, 0xCB, 0xB5, 0xA8, 0x8F, 0x89, 0x7B, + 0xF2, 0x87, 0x3E, 0x99, 0xCD, 0xD0, 0x7B, 0xB7, + 0xAF, 0x22, 0xAE, 0x7D, 0x32, 0x42, 0x54, 0xA7, + 0x20, 0x18, 0xF6, 0x25, 0xFC, 0x20, 0xDF, 0x38, + 0x3F, 0xFE, 0x9D, 0x44, 0x22, 0xA2, 0xD8, 0x7A, + 0x39, 0xFB, 0x2F, 0x1A, 0xC1, 0xAC, 0x10, 0xCA, + 0x2B, 0xA9, 0x86, 0x8E, 0x9B, 0x56, 0xCE, 0x9C + }, + { + 0x2F, 0x0C, 0xBD, 0x54, 0xE5, 0xA5, 0xF1, 0xF4, + 0x66, 0x71, 0xD5, 0xFB, 0x3F, 0x65, 0x99, 0x42, + 0x48, 0x5F, 0x00, 0x03, 0xA0, 0xE3, 0xB8, 0x88, + 0xA0, 0x9D, 0x63, 0xFB, 0x03, 0xEF, 0xAD, 0xC1, + 0xB6, 0x10, 0x99, 0x3B, 0x62, 0x39, 0x27, 0xE8, + 0x4D, 0xB2, 0x99, 0x23, 0x5B, 0x83, 0x86, 0xA6, + 0xBB, 0x04, 0x4B, 0x2C, 0xE3, 0x2A, 0xCE, 0xCF, + 0x9A, 0x45, 0x03, 0x40, 0x22, 0xC4, 0xA1, 0x74 + }, + { + 0x7A, 0xF1, 0x8C, 0x79, 0xDA, 0xD9, 0xA4, 0x7E, + 0xFB, 0xF1, 0x8A, 0x41, 0xBE, 0xE5, 0xD7, 0xF3, + 0x55, 0x05, 0x32, 0xD7, 0xFF, 0xBD, 0xF9, 0x33, + 0xDD, 0x0B, 0x4B, 0x0F, 0x20, 0x21, 0xF8, 0xC3, + 0xB5, 0x18, 0x95, 0x3E, 0xE0, 0x3C, 0x87, 0x4D, + 0x38, 0xAE, 0x89, 0x1B, 0x4D, 0xEE, 0x1E, 0x04, + 0xB0, 0x87, 0xFE, 0xB3, 0x33, 0x74, 0x80, 0x0D, + 0x07, 0x2A, 0x7F, 0xCD, 0x0D, 0xDA, 0x42, 0x20 + }, + { + 0xE7, 0xE5, 0x2D, 0x78, 0xD9, 0xFA, 0xA5, 0x89, + 0xF1, 0xFE, 0x37, 0x4A, 0xDD, 0x43, 0x9F, 0xC9, + 0x76, 0x10, 0xB5, 0x12, 0x93, 0x34, 0xA2, 0x0E, + 0xE7, 0x03, 0x92, 0xA0, 0x46, 0xA1, 0x13, 0xAA, + 0xCC, 0xA8, 0x43, 0x5C, 0x95, 0xE4, 0xD6, 0x9D, + 0x01, 0x1C, 0x5B, 0xDE, 0xC5, 0xEB, 0x60, 0xDE, + 0x68, 0x35, 0x35, 0x1C, 0x88, 0x1F, 0x20, 0x67, + 0x6A, 0xAC, 0xEC, 0x2C, 0xE6, 0x44, 0x31, 0x20 + }, + { + 0xC2, 0x07, 0xFF, 0x1B, 0xA1, 0x52, 0x2E, 0xAD, + 0x25, 0x6E, 0x10, 0x06, 0x8E, 0x46, 0x0F, 0xD0, + 0x93, 0x0A, 0x7B, 0x67, 0x78, 0xE5, 0x42, 0x95, + 0x0E, 0x87, 0xCB, 0x02, 0x48, 0x24, 0x8E, 0x9E, + 0x0C, 0x3F, 0xCF, 0x24, 0x81, 0x10, 0x35, 0xD4, + 0x9C, 0x3F, 0x6A, 0xE2, 0xA5, 0x03, 0x31, 0x5D, + 0xD1, 0xEE, 0xAA, 0xF1, 0xD5, 0x7E, 0xCA, 0xF3, + 0xF3, 0x4F, 0xD6, 0x81, 0xEE, 0x62, 0xB1, 0x82 + }, + { + 0x97, 0xD1, 0x34, 0xA2, 0x48, 0xB7, 0xD1, 0x53, + 0xA3, 0xF9, 0xC8, 0x78, 0xCC, 0x6C, 0x1C, 0xB8, + 0xE6, 0x7C, 0xF3, 0xDF, 0x5E, 0xB4, 0x03, 0x26, + 0x42, 0x6A, 0x55, 0xE5, 0x56, 0xBC, 0xCD, 0xE9, + 0x71, 0x1A, 0xF6, 0xD3, 0x61, 0xD8, 0x99, 0x51, + 0xB1, 0xB0, 0xC1, 0xDC, 0x09, 0x26, 0xBB, 0xC8, + 0xAC, 0x67, 0xEB, 0x49, 0x73, 0xEE, 0x5E, 0x20, + 0xC9, 0x08, 0xF5, 0xC4, 0x16, 0xAC, 0x1E, 0x3D + }, + { + 0x2F, 0xE2, 0x1F, 0x6C, 0xF2, 0xE9, 0xFB, 0x92, + 0x0D, 0x02, 0x66, 0x86, 0xAF, 0x62, 0x93, 0x51, + 0x9E, 0xEA, 0xA0, 0x88, 0x3A, 0xC2, 0x39, 0x21, + 0x23, 0x58, 0x64, 0x57, 0xE1, 0xCE, 0xDC, 0x67, + 0x7A, 0x24, 0xFD, 0x0A, 0x68, 0x4D, 0xEE, 0x4E, + 0x2B, 0x3A, 0x16, 0x2E, 0xB5, 0xE1, 0x2B, 0xD6, + 0x16, 0x77, 0x63, 0x96, 0xBB, 0x5C, 0xEC, 0xF0, + 0xE3, 0x7E, 0xE5, 0xEB, 0xE7, 0xC2, 0x27, 0xCD + }, + { + 0x75, 0xD6, 0xF6, 0x85, 0x5F, 0x3D, 0x90, 0x1F, + 0xD3, 0xBA, 0x82, 0xFF, 0x77, 0xC5, 0x68, 0x17, + 0x75, 0xBF, 0x96, 0xF3, 0x90, 0x15, 0x49, 0x09, + 0x3F, 0x11, 0x02, 0xCB, 0x7D, 0x03, 0xAB, 0x92, + 0xDB, 0xCA, 0xD2, 0x95, 0x76, 0x93, 0x65, 0x95, + 0x0D, 0x0C, 0x55, 0x64, 0xC0, 0xEE, 0xC9, 0x99, + 0xFF, 0xD6, 0x3B, 0x86, 0x06, 0x7E, 0x91, 0xC0, + 0xB4, 0x75, 0x64, 0x18, 0x0A, 0x05, 0xA2, 0x75 + }, + { + 0x48, 0xD9, 0xBB, 0x1D, 0x9C, 0x39, 0x54, 0xFB, + 0xC2, 0x6C, 0x72, 0x2D, 0xB2, 0x5F, 0xB6, 0x5D, + 0xD7, 0x06, 0x09, 0x27, 0x86, 0xC0, 0x00, 0x99, + 0x4C, 0x33, 0xDA, 0x79, 0x66, 0x6B, 0x03, 0x6B, + 0x12, 0xCA, 0x7E, 0x00, 0x96, 0xEA, 0x83, 0xD0, + 0xCD, 0x06, 0x8D, 0x29, 0xE8, 0x06, 0x18, 0xDB, + 0x25, 0xD9, 0x62, 0xFB, 0xED, 0xAC, 0x43, 0x6E, + 0xC9, 0xEE, 0xFB, 0xB5, 0x86, 0xF2, 0x41, 0x14 + }, + { + 0x81, 0xFA, 0x5B, 0xEA, 0x7B, 0xDE, 0x39, 0xDA, + 0xC3, 0x00, 0xE5, 0x80, 0x4C, 0x69, 0x22, 0x3F, + 0xB5, 0xA1, 0x79, 0x55, 0xC3, 0xD7, 0xAC, 0x0E, + 0xFC, 0xF6, 0x8F, 0x50, 0x3A, 0xB3, 0x39, 0xF4, + 0xCA, 0xE4, 0xBB, 0x35, 0xDC, 0x9B, 0xC2, 0x2A, + 0xFF, 0xB3, 0x11, 0xE5, 0xA3, 0x94, 0x8B, 0x73, + 0x7D, 0x23, 0x06, 0xE2, 0x9D, 0x52, 0xBF, 0xA4, + 0xD1, 0x66, 0xBA, 0x0C, 0x79, 0x0D, 0xF6, 0x86 + }, + { + 0xDF, 0x60, 0x24, 0x88, 0xA2, 0x94, 0x3A, 0x5C, + 0x37, 0x1B, 0x7F, 0x64, 0x52, 0xB1, 0x23, 0x3E, + 0xA5, 0xA8, 0xC3, 0x22, 0x4A, 0x15, 0x7F, 0x7A, + 0x5C, 0x39, 0x98, 0x31, 0xD8, 0x46, 0x7D, 0x41, + 0xD5, 0xC8, 0xF6, 0x12, 0x9A, 0xFC, 0x9B, 0xDE, + 0x31, 0x81, 0x16, 0x3B, 0x56, 0x10, 0xC9, 0xBF, + 0x4A, 0xBB, 0x8C, 0x9F, 0x2C, 0x24, 0xF9, 0x4A, + 0x26, 0xC5, 0xDF, 0x55, 0xB7, 0xE0, 0x38, 0x78 + }, + { + 0x56, 0xF2, 0x4C, 0x31, 0xFF, 0x96, 0x1D, 0x69, + 0xE8, 0xC9, 0x18, 0xFB, 0x94, 0x64, 0x33, 0x11, + 0x2E, 0x09, 0x97, 0x0B, 0xC8, 0xF3, 0xBB, 0xC3, + 0x40, 0xB8, 0xEB, 0xEC, 0xEF, 0x3B, 0x83, 0x5D, + 0xE8, 0x1C, 0x8A, 0xD9, 0x9F, 0xF8, 0x26, 0x7D, + 0x46, 0x3A, 0xC6, 0xB7, 0x22, 0xCB, 0x5E, 0x41, + 0xB8, 0x2D, 0x38, 0x8B, 0x68, 0xE9, 0xD1, 0xD2, + 0xD5, 0x8A, 0x58, 0x70, 0x92, 0xC0, 0xA1, 0x8F + }, + { + 0xF3, 0xBB, 0x23, 0xA8, 0x0E, 0x88, 0x4C, 0xDA, + 0x8E, 0x9A, 0x8D, 0x1B, 0x44, 0x88, 0xE2, 0xAB, + 0x4B, 0xCC, 0x2C, 0x1F, 0x86, 0x5B, 0x32, 0x40, + 0x74, 0x06, 0xB7, 0x81, 0x3F, 0xB8, 0xDA, 0xC2, + 0x53, 0xDE, 0x18, 0xF6, 0x04, 0x31, 0x7B, 0x05, + 0xCD, 0xF6, 0x19, 0xF1, 0x28, 0x32, 0xC1, 0x1D, + 0xC9, 0x02, 0x34, 0x3A, 0x64, 0xBC, 0x4C, 0xEE, + 0x6C, 0xEA, 0xAB, 0x12, 0x12, 0x6F, 0x6E, 0x81 + }, + { + 0xE2, 0x22, 0x2C, 0x75, 0x8A, 0x9B, 0x4C, 0x26, + 0x90, 0x7E, 0x67, 0xC3, 0xE7, 0x8B, 0xC3, 0x4F, + 0xD5, 0x26, 0x04, 0x1F, 0xCA, 0xE7, 0xC6, 0x9D, + 0xCE, 0xF9, 0xB6, 0x9A, 0x58, 0xC2, 0x34, 0xB0, + 0x60, 0xA3, 0x43, 0x5B, 0xF1, 0x8B, 0xB0, 0xEF, + 0x38, 0xE5, 0x41, 0xBE, 0x3A, 0x17, 0x5A, 0xF9, + 0xD7, 0xDB, 0xA0, 0x7F, 0xE6, 0x8B, 0xE3, 0xB8, + 0x5D, 0xAC, 0xDC, 0xA4, 0xF9, 0xE4, 0xEF, 0x31 + }, + { + 0x5D, 0xC8, 0xD7, 0xE2, 0x72, 0x45, 0x2F, 0x05, + 0x5A, 0xFE, 0x61, 0x1B, 0xA6, 0xE8, 0x5D, 0xA1, + 0x70, 0x58, 0xA5, 0xB9, 0xB6, 0x8E, 0x54, 0xDA, + 0x32, 0x37, 0x41, 0x87, 0x98, 0x40, 0x5B, 0x43, + 0x13, 0x9D, 0xF4, 0xAD, 0xF7, 0x76, 0x00, 0xDC, + 0xB8, 0xBB, 0xA9, 0xA0, 0x00, 0xCB, 0xFD, 0xCD, + 0x5A, 0x16, 0xD1, 0xC9, 0xFC, 0xE3, 0xF3, 0x9B, + 0xBB, 0xA2, 0x02, 0xE9, 0x84, 0x9F, 0x6C, 0x78 + }, + { + 0x2E, 0x40, 0x45, 0xD9, 0xD6, 0x79, 0x96, 0x59, + 0x6A, 0xD4, 0x6B, 0x2C, 0x64, 0xA2, 0x5E, 0xD6, + 0x23, 0x27, 0xC4, 0x58, 0x27, 0xE2, 0x97, 0xA0, + 0xAD, 0xF9, 0x1E, 0x0E, 0xEA, 0xC2, 0x9F, 0x83, + 0x26, 0xC6, 0x19, 0x73, 0x45, 0xD7, 0xEC, 0xE2, + 0x77, 0x5B, 0xC3, 0x66, 0x3D, 0xD2, 0x76, 0x52, + 0x33, 0x35, 0x43, 0xEE, 0xB1, 0xA8, 0x68, 0x94, + 0x14, 0x8C, 0x6A, 0x73, 0xA1, 0x25, 0x2A, 0x0F + }, + { + 0x54, 0x49, 0x01, 0x77, 0x7C, 0x26, 0x8B, 0x97, + 0xAC, 0x42, 0x0D, 0x23, 0x18, 0x55, 0x1B, 0x1C, + 0xFD, 0xAF, 0xB1, 0xA2, 0xBD, 0x50, 0x47, 0x04, + 0x63, 0xAB, 0x25, 0x1B, 0x6A, 0x26, 0xD2, 0xA7, + 0x56, 0xD2, 0xE5, 0x0B, 0x39, 0x5B, 0x15, 0xDE, + 0x7A, 0x18, 0x9E, 0xA8, 0x4E, 0x5F, 0xBC, 0xF6, + 0x93, 0x36, 0x5E, 0xD7, 0x11, 0x34, 0xC5, 0x58, + 0x04, 0x79, 0xE5, 0xDA, 0x1A, 0xD4, 0x4D, 0xDD + }, + { + 0x88, 0x14, 0xCE, 0x21, 0xC7, 0x32, 0x7D, 0x96, + 0xBE, 0xE4, 0x74, 0xFB, 0x90, 0x86, 0xBE, 0x2E, + 0x03, 0x26, 0xFA, 0x58, 0xF8, 0x1A, 0xBF, 0xFE, + 0xCC, 0x40, 0xC3, 0x5F, 0xAC, 0x53, 0x86, 0x54, + 0xFD, 0x59, 0x9D, 0xD2, 0xEC, 0x23, 0x48, 0x56, + 0x0C, 0xDE, 0x2D, 0xB3, 0x71, 0x66, 0x3A, 0xA9, + 0x97, 0xF5, 0x50, 0xCD, 0x1B, 0xCE, 0x17, 0x5F, + 0xD8, 0x83, 0x94, 0xC8, 0xFD, 0xD8, 0x78, 0xDB + }, + { + 0xD2, 0x0A, 0xC8, 0x47, 0x4E, 0xCA, 0xBB, 0xF4, + 0x59, 0x14, 0x22, 0x83, 0xE1, 0x47, 0x23, 0x46, + 0xAE, 0x64, 0xD3, 0xDF, 0x0C, 0x1B, 0x02, 0x29, + 0x27, 0x7E, 0xFF, 0xA8, 0x38, 0xE3, 0x7E, 0x49, + 0x90, 0x89, 0xC9, 0x9E, 0xD1, 0x78, 0x0F, 0x95, + 0x3A, 0x10, 0xB1, 0x05, 0x1F, 0xC3, 0xC6, 0x69, + 0x41, 0x89, 0x8D, 0x74, 0xB9, 0xBB, 0x66, 0x95, + 0x9F, 0x29, 0x67, 0x42, 0xCC, 0xD5, 0xB3, 0x54 + }, + { + 0x75, 0xF0, 0x20, 0x97, 0x3E, 0x4B, 0xF7, 0x38, + 0xA7, 0xCA, 0xCD, 0x7B, 0xD9, 0x66, 0xED, 0x1C, + 0xBF, 0x06, 0x5C, 0xD3, 0x57, 0x79, 0xF9, 0xD1, + 0x9E, 0x73, 0xE0, 0xE3, 0x2B, 0xEE, 0xB8, 0xEE, + 0x1B, 0xEF, 0x58, 0xEB, 0xAF, 0xB8, 0xA1, 0x62, + 0x12, 0x05, 0x5E, 0x6F, 0x5F, 0x02, 0xD5, 0x84, + 0xA5, 0x76, 0xD3, 0x16, 0x7B, 0x72, 0x04, 0x79, + 0x0A, 0x65, 0x55, 0x28, 0x3B, 0x3A, 0x1F, 0x0F + }, + { + 0x98, 0x07, 0x9B, 0xB8, 0x08, 0x6E, 0x69, 0x24, + 0x31, 0x2A, 0x9D, 0xBD, 0x1B, 0xF3, 0xCC, 0x7D, + 0x72, 0xB5, 0x44, 0xBE, 0xFC, 0x0B, 0xF7, 0x71, + 0x76, 0xCD, 0xF6, 0xD2, 0x1B, 0x8F, 0x8D, 0xFE, + 0xEE, 0xAB, 0xBF, 0xFF, 0x82, 0xF4, 0x95, 0x72, + 0x60, 0xAD, 0xC0, 0x04, 0x1E, 0xC5, 0xA2, 0xA5, + 0xA4, 0xA6, 0x35, 0x12, 0xC8, 0x58, 0x22, 0xEF, + 0xDC, 0xB7, 0xE7, 0xBB, 0x05, 0xBC, 0xE8, 0xA4 + }, + { + 0xBE, 0x19, 0x02, 0xA6, 0x54, 0xEB, 0xE5, 0x7F, + 0x7F, 0x5A, 0x50, 0x9A, 0x1F, 0xFA, 0x16, 0xB8, + 0xF0, 0x10, 0x2D, 0x1A, 0xB8, 0xF4, 0x35, 0x53, + 0xA9, 0x08, 0x25, 0x9B, 0x81, 0x49, 0x6B, 0xA0, + 0x65, 0xD1, 0xAD, 0x2F, 0xAF, 0xD6, 0x0A, 0x63, + 0xAE, 0x48, 0xBA, 0xD1, 0x07, 0x21, 0x90, 0xA4, + 0xC4, 0x80, 0x3E, 0xD1, 0xFE, 0xCB, 0x6A, 0xBF, + 0x05, 0x41, 0xF2, 0xD8, 0xFF, 0x25, 0x66, 0xF2 + }, + { + 0xA7, 0xDF, 0xAA, 0xE9, 0xC7, 0x35, 0x46, 0x5F, + 0x58, 0x9C, 0x29, 0x2A, 0x48, 0xEF, 0xFF, 0x1A, + 0xE4, 0x64, 0xE1, 0x0F, 0x31, 0x18, 0x47, 0x81, + 0x04, 0x88, 0xD1, 0x46, 0x14, 0x72, 0x0F, 0x5D, + 0xCA, 0x74, 0x50, 0x71, 0xDB, 0x49, 0x8D, 0x19, + 0x78, 0x9B, 0x42, 0x77, 0x47, 0x9D, 0x68, 0x09, + 0x07, 0xAE, 0x1C, 0xDA, 0xA8, 0xA2, 0x92, 0xC3, + 0x35, 0x06, 0xEF, 0x03, 0xBB, 0xE2, 0x70, 0x8C + }, + { + 0x49, 0xFE, 0xCD, 0x27, 0x47, 0x2B, 0x1A, 0xCE, + 0xCF, 0xE5, 0x38, 0x91, 0x1A, 0x5A, 0x77, 0x23, + 0x0D, 0x77, 0x07, 0xAC, 0xB1, 0xCD, 0x1E, 0xBB, + 0x6B, 0xFC, 0xD0, 0x4A, 0x68, 0x51, 0xE9, 0x30, + 0xFE, 0xBB, 0x74, 0xE8, 0x42, 0xA8, 0xFB, 0xA4, + 0x4C, 0x57, 0x2A, 0xC9, 0xA0, 0xE3, 0x49, 0x24, + 0x3C, 0x2A, 0x67, 0x6F, 0x20, 0xC5, 0xF4, 0xA4, + 0x6E, 0x38, 0x25, 0xF3, 0xF6, 0x57, 0x32, 0x28 + }, + { + 0xCF, 0x69, 0x84, 0xF4, 0x14, 0xA5, 0x2C, 0xEE, + 0x82, 0xA4, 0xF9, 0x59, 0x27, 0xD5, 0xEF, 0x4F, + 0xEE, 0xB9, 0xCA, 0xF7, 0x83, 0x0F, 0x25, 0x52, + 0x58, 0x9E, 0xB1, 0x30, 0x4D, 0x2F, 0x81, 0xCF, + 0x4B, 0xF1, 0x7E, 0x02, 0x80, 0x02, 0xF5, 0xC5, + 0xE1, 0xFB, 0xAE, 0xC3, 0x99, 0x66, 0x20, 0x14, + 0x2F, 0x8A, 0x5E, 0xFE, 0x8C, 0x24, 0xDC, 0x5D, + 0x15, 0x16, 0x67, 0x20, 0xFE, 0xC3, 0x4A, 0x69 + }, + { + 0xE6, 0x1A, 0x93, 0x12, 0x5C, 0x08, 0x01, 0x5A, + 0xCD, 0xCE, 0xFC, 0xD1, 0x63, 0xDA, 0xAB, 0xBD, + 0x7A, 0xF0, 0xEF, 0xA8, 0xD1, 0x52, 0xAE, 0x5E, + 0x93, 0x01, 0xDF, 0x90, 0x44, 0x6E, 0x72, 0x7C, + 0x88, 0x44, 0x0D, 0xD3, 0x08, 0x26, 0xE2, 0x9A, + 0x95, 0x34, 0x4A, 0xAC, 0xF7, 0xC8, 0xEE, 0x86, + 0xC9, 0x6A, 0x16, 0xBE, 0x30, 0x1E, 0x91, 0x52, + 0xBD, 0x2B, 0x24, 0x4B, 0xBD, 0x3E, 0x4E, 0xE1 + }, + { + 0x59, 0x2D, 0xC1, 0x88, 0xE4, 0x09, 0x43, 0x16, + 0x63, 0x3A, 0xA7, 0x83, 0x14, 0x03, 0x3C, 0xFE, + 0xC5, 0xEB, 0xF4, 0x72, 0xD8, 0xCA, 0x0A, 0xAA, + 0x95, 0xB5, 0x00, 0xE2, 0x3F, 0xDF, 0x55, 0x3A, + 0x26, 0xEC, 0x7C, 0x60, 0x08, 0x96, 0x5D, 0x85, + 0x40, 0xC6, 0x24, 0x30, 0xAA, 0x9B, 0xD2, 0x4E, + 0x35, 0x15, 0xD4, 0x0F, 0xA7, 0x51, 0x8A, 0x21, + 0xE7, 0x73, 0x73, 0x25, 0xF7, 0xB0, 0xD4, 0xB2 + }, + { + 0x5E, 0x57, 0x0A, 0xEF, 0xAD, 0x67, 0x96, 0x8B, + 0xD8, 0x74, 0xD9, 0xCA, 0x9D, 0x94, 0x47, 0x71, + 0x85, 0xBB, 0xA9, 0x22, 0x9C, 0x87, 0x81, 0xC8, + 0x42, 0x63, 0x5B, 0xE5, 0x87, 0x77, 0x1D, 0x4E, + 0xBF, 0x92, 0xA3, 0x49, 0x60, 0xE3, 0xFD, 0xBF, + 0xCD, 0xE6, 0x27, 0xF0, 0x43, 0x53, 0x4F, 0x0F, + 0x67, 0xE3, 0x29, 0xBE, 0xE9, 0xC8, 0x01, 0x18, + 0x4F, 0xE4, 0x08, 0x05, 0x83, 0xE5, 0xCC, 0xC9 + }, + { + 0xD3, 0x91, 0x1C, 0x8F, 0xB3, 0x8B, 0xBC, 0xB1, + 0x80, 0x0C, 0xB9, 0x20, 0x92, 0x85, 0xE4, 0x86, + 0xB7, 0xC2, 0x70, 0x63, 0x5C, 0x44, 0x55, 0x16, + 0x98, 0x01, 0xCD, 0x02, 0xBE, 0xE2, 0x00, 0x7E, + 0x56, 0x38, 0xB2, 0x42, 0xA5, 0xB6, 0x9B, 0x7A, + 0xFE, 0x8F, 0x30, 0x17, 0x7B, 0x64, 0x71, 0x88, + 0x9D, 0x27, 0xC6, 0xF5, 0xA8, 0xA9, 0xB2, 0x5F, + 0x11, 0x34, 0x6F, 0x37, 0x82, 0x19, 0xE7, 0x95 + }, + { + 0x3D, 0x71, 0x1C, 0x5D, 0x1F, 0xCB, 0x5B, 0x54, + 0x54, 0xBC, 0xF7, 0x3C, 0xE8, 0x33, 0xA2, 0xE3, + 0x26, 0x70, 0xF7, 0xC6, 0x01, 0x5D, 0x09, 0x0E, + 0x50, 0xA1, 0x11, 0x17, 0x99, 0xE7, 0xCF, 0x0F, + 0x71, 0x33, 0x47, 0x85, 0x27, 0x90, 0x88, 0x0B, + 0xB5, 0x0D, 0x7E, 0x67, 0x94, 0x37, 0xED, 0x53, + 0x51, 0x41, 0x7E, 0xD2, 0x32, 0x85, 0x40, 0xBA, + 0x60, 0x43, 0x3A, 0x84, 0x0F, 0x80, 0x7E, 0x06 + }, + { + 0x4A, 0x35, 0x08, 0x62, 0xBF, 0x24, 0x0E, 0xAC, + 0x19, 0x17, 0x67, 0xB2, 0xCE, 0xD0, 0x95, 0x3D, + 0x0E, 0xCF, 0x99, 0x0D, 0xB5, 0x4E, 0xEE, 0x55, + 0xEA, 0x53, 0x55, 0x9B, 0xC6, 0x7F, 0x14, 0xF5, + 0x14, 0x8A, 0xA5, 0xD4, 0xF1, 0xA7, 0x06, 0x2E, + 0x47, 0x29, 0x19, 0x5F, 0x4A, 0xBA, 0x09, 0x7A, + 0x94, 0xAD, 0x49, 0x21, 0xA8, 0x94, 0xAF, 0xC5, + 0xD9, 0xA6, 0x96, 0x65, 0x57, 0x24, 0x84, 0xE0 + }, + { + 0x4E, 0x53, 0x9E, 0x0D, 0x29, 0x42, 0x3B, 0x54, + 0x94, 0x13, 0x71, 0xE7, 0xE3, 0x9F, 0x00, 0x64, + 0xAF, 0x4B, 0xF6, 0x98, 0x59, 0x19, 0xCD, 0xBA, + 0x1B, 0x67, 0x96, 0x20, 0xA9, 0xF0, 0x0A, 0x6D, + 0x86, 0xE9, 0xAB, 0x2F, 0xD9, 0x3C, 0xC3, 0x36, + 0xB3, 0x57, 0x88, 0x77, 0x9A, 0xB0, 0x2A, 0x63, + 0x76, 0xCC, 0x8E, 0x01, 0xC8, 0xEB, 0x46, 0xB8, + 0x34, 0xD5, 0x8A, 0x71, 0xA1, 0xF1, 0x82, 0x38 + }, + { + 0xF4, 0x07, 0x60, 0x5F, 0x35, 0x5E, 0x33, 0xB1, + 0x73, 0x05, 0xCB, 0x86, 0xF0, 0xD5, 0xBD, 0xAC, + 0xEE, 0x1E, 0x39, 0x3D, 0x71, 0xB6, 0x55, 0xCF, + 0x0E, 0xD6, 0xBA, 0x8E, 0x79, 0xBF, 0x41, 0x9D, + 0x63, 0x39, 0x8B, 0x60, 0xAE, 0xE8, 0xE2, 0x92, + 0xD2, 0x96, 0xC6, 0x03, 0x64, 0x8C, 0x41, 0x07, + 0x51, 0x91, 0xEA, 0xD7, 0xE7, 0xA9, 0xFD, 0x58, + 0xAC, 0x0E, 0x96, 0x73, 0x72, 0xDD, 0xBC, 0xDB + }, + { + 0xF2, 0x43, 0x20, 0x39, 0x75, 0x9D, 0xF0, 0x40, + 0xDA, 0x88, 0x8D, 0xDF, 0x6B, 0xAA, 0xE1, 0x6D, + 0x38, 0xC3, 0x32, 0x13, 0x0B, 0x1A, 0x1C, 0x18, + 0xA8, 0x62, 0x4A, 0x06, 0xE4, 0x44, 0x8B, 0xE5, + 0xEA, 0x40, 0xBB, 0x13, 0xEF, 0xF3, 0x41, 0x01, + 0x49, 0xAC, 0x50, 0x7E, 0xB6, 0x6C, 0xE8, 0x6E, + 0xDF, 0xA0, 0x19, 0x7F, 0xDB, 0x42, 0x8C, 0x77, + 0x63, 0x22, 0x49, 0xD7, 0x94, 0xEE, 0xF1, 0x77 + }, + { + 0x1D, 0xB6, 0x68, 0x12, 0x7B, 0xA7, 0xDC, 0x2A, + 0x62, 0x2E, 0xC6, 0x0C, 0x14, 0x30, 0xF1, 0xE4, + 0x6F, 0x07, 0x50, 0x71, 0x9D, 0x31, 0xA4, 0x5F, + 0x9F, 0x88, 0x2F, 0x29, 0x99, 0xDA, 0x92, 0x0C, + 0xBF, 0xDD, 0xA3, 0x5D, 0x44, 0x44, 0x5D, 0x65, + 0x94, 0x8A, 0x0F, 0x14, 0x98, 0xF1, 0xEC, 0xA6, + 0x5E, 0x20, 0xE2, 0x6C, 0xA4, 0xD2, 0x36, 0xE3, + 0x60, 0xF2, 0x62, 0xAE, 0x76, 0x06, 0x20, 0xD9 + }, + { + 0x8F, 0x0D, 0xCB, 0xEA, 0x03, 0x96, 0x45, 0x51, + 0x9C, 0xB7, 0xD7, 0x8A, 0x0F, 0xF8, 0xC3, 0xBF, + 0x9A, 0x27, 0xA4, 0x3C, 0x6F, 0x59, 0x61, 0x0F, + 0xD9, 0x7D, 0xDC, 0x91, 0xC4, 0x8A, 0x60, 0xED, + 0x47, 0x25, 0xDD, 0xEC, 0x3D, 0x37, 0xA0, 0x96, + 0x09, 0x14, 0x59, 0x3D, 0x77, 0xE1, 0x7D, 0x36, + 0xC9, 0xC2, 0x08, 0xE9, 0xBF, 0x9F, 0xB0, 0x30, + 0x1C, 0x9B, 0x7C, 0xA4, 0x51, 0xD3, 0x7B, 0x9E + }, + { + 0x84, 0x59, 0xFB, 0xCF, 0xB7, 0x27, 0x64, 0xEA, + 0xA6, 0xA5, 0x4C, 0x03, 0x76, 0x02, 0xFF, 0x77, + 0x89, 0x58, 0xA0, 0x15, 0x0B, 0xB9, 0x6D, 0xD3, + 0xEC, 0xAC, 0x46, 0x6B, 0xF3, 0x26, 0x57, 0xA1, + 0xE3, 0xA7, 0xEE, 0xEA, 0xAA, 0x39, 0x97, 0x56, + 0x81, 0x1C, 0x0E, 0x24, 0x54, 0xEE, 0x60, 0x63, + 0x40, 0x84, 0x34, 0xE4, 0x44, 0x57, 0x55, 0xCB, + 0xF9, 0xF1, 0x18, 0xB8, 0xBB, 0x89, 0x64, 0x65 + }, + { + 0x61, 0x07, 0x92, 0xA4, 0x6A, 0xF2, 0x38, 0x5E, + 0x6E, 0xBB, 0x88, 0x2B, 0x7A, 0xF7, 0xEC, 0x50, + 0x7A, 0x55, 0xC3, 0x2C, 0x34, 0xE0, 0x52, 0xCF, + 0x2A, 0xE2, 0xF6, 0xF9, 0xA0, 0x84, 0x95, 0x78, + 0x4E, 0x70, 0xCE, 0xAE, 0x55, 0x6D, 0x95, 0x86, + 0xE3, 0xFF, 0x2A, 0x39, 0xBD, 0x73, 0x57, 0xC2, + 0x3D, 0x4E, 0x63, 0xD0, 0x32, 0x3C, 0x6E, 0xEB, + 0x3C, 0xCB, 0x6B, 0xE6, 0xF4, 0x14, 0xF1, 0x61 + }, + { + 0x86, 0x44, 0xFE, 0x5B, 0x19, 0x4A, 0x17, 0x94, + 0xEC, 0xB4, 0x65, 0x4B, 0xC4, 0x60, 0x49, 0xD7, + 0xE3, 0x25, 0x77, 0x09, 0xE0, 0xD4, 0xA5, 0x7B, + 0xFD, 0xA2, 0xAD, 0x8B, 0xD9, 0xB3, 0xC1, 0xDA, + 0xFF, 0x69, 0x81, 0xFC, 0x1F, 0x1A, 0xB0, 0x8D, + 0xD1, 0x89, 0x8B, 0x15, 0x3A, 0x44, 0xAB, 0xE2, + 0x0C, 0x18, 0x44, 0xCA, 0x95, 0x3F, 0xC4, 0xC1, + 0x4F, 0x5B, 0xD1, 0x4D, 0xD9, 0xC1, 0x8C, 0xC4 + }, + { + 0x53, 0x2B, 0x00, 0xAF, 0x69, 0x91, 0xC0, 0xF1, + 0x24, 0x60, 0xB9, 0x38, 0xE0, 0x83, 0xFB, 0xC5, + 0xD5, 0x0C, 0x48, 0xEE, 0x37, 0xFD, 0xCC, 0xD1, + 0xBA, 0xD5, 0x82, 0xFE, 0x69, 0x12, 0x90, 0x15, + 0x9F, 0x37, 0x4F, 0xF9, 0x59, 0xDB, 0x5A, 0x16, + 0x3E, 0x20, 0x55, 0x36, 0x44, 0x34, 0xB6, 0x9B, + 0x39, 0x87, 0xC6, 0x10, 0x6B, 0xA1, 0x33, 0x97, + 0x1E, 0xD4, 0x0C, 0x02, 0x82, 0x04, 0x45, 0x1B + }, + { + 0xE8, 0x8F, 0x37, 0x6E, 0x3A, 0xA3, 0xD3, 0x8B, + 0xD6, 0xA4, 0x65, 0x99, 0x59, 0x4B, 0x26, 0xC7, + 0xCB, 0xAC, 0xC1, 0xC2, 0x78, 0xDF, 0x71, 0x4B, + 0x1B, 0xF6, 0x23, 0x97, 0x56, 0x3D, 0x85, 0x85, + 0x4F, 0x93, 0xE0, 0x72, 0x52, 0xBE, 0x5B, 0xE9, + 0xD8, 0x6A, 0xDA, 0x85, 0xDC, 0x06, 0x6E, 0x31, + 0x3F, 0xE9, 0xDB, 0x9F, 0x08, 0xF6, 0x3D, 0x16, + 0xFF, 0xA9, 0xF8, 0x05, 0xCA, 0x1D, 0xBA, 0x3E + }, + { + 0xE1, 0x72, 0x73, 0x88, 0x3A, 0xDD, 0x4F, 0x19, + 0x24, 0xE0, 0x78, 0xB6, 0x1D, 0x35, 0x23, 0x20, + 0xE4, 0xD7, 0x1D, 0x02, 0x84, 0x16, 0x76, 0x23, + 0x97, 0xF2, 0x0B, 0x6C, 0x1A, 0x7B, 0x42, 0x91, + 0xD7, 0xF7, 0x46, 0x34, 0x55, 0xF5, 0x1B, 0xC5, + 0xF6, 0x64, 0x83, 0x22, 0xCD, 0x5B, 0x43, 0x45, + 0x47, 0x92, 0x59, 0xAD, 0xDE, 0xB9, 0x03, 0xEC, + 0xD6, 0x48, 0x3D, 0x6A, 0x7E, 0xEE, 0xC1, 0xB6 + }, + { + 0x6B, 0xA3, 0x3C, 0xED, 0xDE, 0x8D, 0x27, 0xC9, + 0xB2, 0x1D, 0x2A, 0x09, 0xB7, 0xFB, 0x74, 0xF0, + 0x62, 0x28, 0x19, 0xBC, 0x93, 0x73, 0x31, 0x83, + 0x5C, 0x38, 0x99, 0xA3, 0x05, 0xF6, 0xE3, 0x1B, + 0xA7, 0x62, 0x67, 0x7F, 0x29, 0x17, 0xF5, 0x0F, + 0x0F, 0xE1, 0xAB, 0x3B, 0x50, 0x42, 0xD9, 0x45, + 0x72, 0xB1, 0xFC, 0xCA, 0x34, 0xFD, 0xB7, 0xC6, + 0x1C, 0x54, 0xE9, 0x0B, 0xC4, 0x37, 0x4B, 0xD0 + }, + { + 0x5E, 0xD4, 0x3E, 0x77, 0x92, 0x5D, 0x56, 0x9A, + 0x02, 0x47, 0xAB, 0x67, 0x5F, 0xCC, 0x39, 0xDE, + 0xFD, 0x33, 0xBF, 0x3C, 0xD9, 0x31, 0x0F, 0xB7, + 0xA1, 0xE3, 0x58, 0x99, 0x7D, 0x2E, 0xF7, 0x96, + 0x38, 0xE4, 0x9C, 0x36, 0x32, 0x93, 0x9A, 0x7F, + 0x28, 0x3C, 0x51, 0xBE, 0xB4, 0xB6, 0xD5, 0x00, + 0xE8, 0xDC, 0x9E, 0xEC, 0x27, 0x0C, 0x63, 0x8E, + 0xDB, 0x24, 0x52, 0x0B, 0x93, 0xF4, 0xA8, 0x63 + }, + { + 0x7A, 0x50, 0xF5, 0x79, 0xD6, 0x88, 0x37, 0x5D, + 0xCB, 0xCE, 0x42, 0x43, 0x6B, 0xD6, 0x11, 0x65, + 0x0E, 0xB4, 0x4C, 0x45, 0xDF, 0x20, 0xFC, 0x91, + 0x6E, 0x62, 0xBB, 0x77, 0xBA, 0x67, 0x94, 0xEF, + 0x9B, 0x4C, 0x83, 0x1D, 0x5C, 0x51, 0xAD, 0x6D, + 0x9B, 0xB9, 0x20, 0xB6, 0x7E, 0x44, 0xF4, 0xFE, + 0xEA, 0x2B, 0xAE, 0x05, 0x3E, 0x83, 0x95, 0x0D, + 0xAE, 0x29, 0x87, 0xEB, 0xCF, 0x60, 0x5A, 0x24 + }, + { + 0x1C, 0x1A, 0x4E, 0xC3, 0x3F, 0x2C, 0x1E, 0x87, + 0x38, 0x32, 0xD7, 0x43, 0xA8, 0x1B, 0x65, 0x5D, + 0x40, 0x15, 0x0A, 0xC9, 0x69, 0xD7, 0x7C, 0xFF, + 0xF2, 0xF9, 0x99, 0x4A, 0xA0, 0xF2, 0xF0, 0x6D, + 0x1F, 0xD9, 0x1B, 0xB8, 0x94, 0x1F, 0xE8, 0x12, + 0x10, 0xF6, 0x79, 0xC3, 0xCE, 0x41, 0xDD, 0xE5, + 0x51, 0xD0, 0xB7, 0x62, 0xA4, 0xF5, 0x30, 0x96, + 0xED, 0x31, 0xB1, 0x35, 0x7E, 0x1E, 0xBB, 0xAF + }, + { + 0x32, 0xCD, 0x2C, 0xC3, 0x43, 0xC2, 0xFD, 0xC3, + 0xB7, 0x30, 0xCF, 0x76, 0x03, 0xA6, 0x61, 0x36, + 0x26, 0xC2, 0x94, 0xA1, 0x32, 0x00, 0x4D, 0x4F, + 0x99, 0x95, 0x39, 0x05, 0xE9, 0x15, 0xF1, 0xD0, + 0xE0, 0xD6, 0xA7, 0x1F, 0x26, 0x5B, 0x9B, 0x2C, + 0xC1, 0x59, 0xF4, 0x45, 0x3D, 0xCF, 0x3A, 0x23, + 0xF2, 0x78, 0xB0, 0x3D, 0xE4, 0x6E, 0x28, 0xA5, + 0x94, 0x39, 0xC4, 0x2C, 0x90, 0xD1, 0x96, 0x93 + }, + { + 0x54, 0x3B, 0xBD, 0x2A, 0x46, 0x5D, 0x80, 0xBD, + 0xCB, 0x41, 0xAF, 0x9B, 0x3C, 0xEB, 0x73, 0xD3, + 0xCA, 0x4B, 0x12, 0xCD, 0xCC, 0xF6, 0x9C, 0x2E, + 0xA7, 0xF6, 0xF7, 0xAD, 0x75, 0x81, 0x3D, 0x0C, + 0x35, 0xC6, 0x3A, 0x94, 0x8C, 0x3E, 0x67, 0xB3, + 0xC1, 0xC6, 0x42, 0x90, 0x3D, 0xF1, 0xFA, 0x5F, + 0x1A, 0x37, 0x2C, 0x06, 0x07, 0x70, 0x41, 0x46, + 0x00, 0xBF, 0xDF, 0xEC, 0x4F, 0xC5, 0x34, 0x28 + }, + { + 0x43, 0x05, 0xF6, 0xD7, 0xBC, 0x51, 0x2C, 0xB8, + 0xD5, 0x09, 0x4B, 0xF1, 0x2E, 0xB8, 0xF1, 0x74, + 0xC5, 0x98, 0x0B, 0x38, 0x15, 0x71, 0xCF, 0xD9, + 0x8B, 0x40, 0x14, 0xE6, 0x64, 0x99, 0x8A, 0x7A, + 0x29, 0xE5, 0xB7, 0x20, 0x4D, 0x30, 0xBF, 0x76, + 0xEF, 0x13, 0x8C, 0xAB, 0xC5, 0x95, 0xDC, 0x50, + 0x4E, 0x32, 0x11, 0x0D, 0xE6, 0x94, 0x8D, 0xED, + 0x13, 0xC3, 0xBE, 0xAF, 0x73, 0xE9, 0xA4, 0xFF + }, + { + 0x60, 0xAB, 0xFD, 0x76, 0xC8, 0xA4, 0x82, 0x28, + 0xE7, 0x09, 0x57, 0xAD, 0xAF, 0xEA, 0xB4, 0xA3, + 0xF1, 0xD8, 0x9D, 0xFB, 0x54, 0x55, 0x85, 0x17, + 0x9A, 0x96, 0x77, 0xE9, 0xDE, 0x75, 0xB3, 0xF1, + 0x27, 0x7E, 0x0E, 0xE3, 0xAD, 0x13, 0xCD, 0x3F, + 0x11, 0xB3, 0x89, 0xF0, 0xF6, 0x04, 0x0D, 0x5D, + 0x28, 0xF5, 0xA7, 0x3B, 0xA1, 0x9F, 0x07, 0xA3, + 0x4E, 0x06, 0x4D, 0x00, 0x1D, 0x9F, 0x6F, 0x5E + }, + { + 0xAE, 0xF8, 0x0E, 0xC2, 0x79, 0xFF, 0xF8, 0x3A, + 0x85, 0x0D, 0x70, 0xC0, 0x22, 0x66, 0xD1, 0x72, + 0x4A, 0x30, 0xE6, 0x10, 0xAF, 0xEB, 0xF9, 0xAB, + 0x1D, 0x84, 0x7B, 0x75, 0x4F, 0x37, 0x54, 0x33, + 0x48, 0x17, 0x63, 0xB0, 0xF1, 0x66, 0x6D, 0x18, + 0xCA, 0x67, 0x3E, 0x0D, 0xF7, 0x4C, 0x73, 0xEA, + 0xE6, 0x65, 0x07, 0x33, 0xC3, 0x23, 0xBF, 0x5C, + 0x0E, 0x8D, 0x2F, 0x84, 0x65, 0x82, 0x4B, 0x9C + }, + { + 0x66, 0x2C, 0x85, 0x6A, 0xF7, 0x45, 0xC2, 0x52, + 0xE2, 0xBD, 0xDB, 0xE3, 0x9B, 0x40, 0x74, 0xA2, + 0xA7, 0x92, 0x71, 0xA1, 0x62, 0x46, 0xE2, 0x8B, + 0xF6, 0x73, 0xAC, 0x51, 0xB1, 0xF6, 0xD4, 0xB4, + 0xB4, 0xFE, 0xC7, 0x36, 0x47, 0xDF, 0xF8, 0x75, + 0x01, 0x77, 0x91, 0xF7, 0x8F, 0xC2, 0x85, 0xAD, + 0x06, 0x76, 0xED, 0x1C, 0xB0, 0xB8, 0x61, 0xD8, + 0xEC, 0xAD, 0x41, 0x1F, 0x24, 0x0F, 0x77, 0xEA + }, + { + 0x75, 0x47, 0x5B, 0x98, 0x1E, 0xCB, 0x73, 0x36, + 0xC7, 0x8F, 0xE5, 0xAB, 0xB0, 0xE1, 0x74, 0xA1, + 0x65, 0xCE, 0xF5, 0x0D, 0xD0, 0x85, 0x50, 0xA1, + 0xFF, 0x67, 0x81, 0x29, 0x40, 0x3E, 0xF5, 0xEF, + 0x80, 0xE6, 0x81, 0x7D, 0x1E, 0x8D, 0x3B, 0xCB, + 0x1E, 0x09, 0xE5, 0x4C, 0xFF, 0xC5, 0x85, 0x50, + 0x37, 0x48, 0x7E, 0xD0, 0x72, 0x9B, 0xA7, 0x37, + 0x0E, 0x56, 0xB9, 0x13, 0xD0, 0x7E, 0x10, 0x7B + }, + { + 0xC3, 0x6D, 0xED, 0x05, 0xA6, 0x7D, 0x4F, 0x71, + 0x54, 0xC5, 0xAD, 0x98, 0xE9, 0x52, 0x7D, 0xB9, + 0x4C, 0x0D, 0x35, 0x7F, 0x9D, 0xFC, 0x51, 0x74, + 0x82, 0x3E, 0x9C, 0xD9, 0xCE, 0x52, 0x79, 0xF7, + 0x8B, 0x95, 0x82, 0x5E, 0xD9, 0xF9, 0xFE, 0xB4, + 0xD1, 0x67, 0x40, 0xF4, 0x27, 0x5D, 0xA6, 0x66, + 0x08, 0xCB, 0x90, 0x00, 0x29, 0xEC, 0xBA, 0x19, + 0xDD, 0xDE, 0x63, 0xCE, 0xF5, 0x84, 0x75, 0x02 + }, + { + 0x83, 0x63, 0x9B, 0xB6, 0x0C, 0x60, 0x68, 0x3F, + 0xE9, 0xAC, 0xE0, 0x87, 0x60, 0xFA, 0x49, 0x5D, + 0x4F, 0xF7, 0x77, 0x4A, 0xAF, 0x58, 0x6F, 0x95, + 0x18, 0xF1, 0x41, 0xEE, 0x78, 0x3E, 0x13, 0xB1, + 0x4C, 0x3D, 0x56, 0x79, 0x3C, 0xF2, 0x86, 0x09, + 0x8A, 0xFA, 0x0C, 0xAB, 0xF3, 0x24, 0x4C, 0x09, + 0xDD, 0x0A, 0xA9, 0xFA, 0x7D, 0x3F, 0x35, 0xC9, + 0x0B, 0xB6, 0x97, 0x34, 0xA8, 0x73, 0x37, 0x75 + }, + { + 0x1C, 0x54, 0x90, 0x89, 0x46, 0x89, 0x9E, 0xED, + 0x66, 0x54, 0x57, 0xE2, 0x08, 0x69, 0x9D, 0x63, + 0xC2, 0x2B, 0xDC, 0x23, 0xCE, 0x46, 0x5A, 0x8D, + 0x8D, 0xD7, 0x24, 0xA5, 0x7A, 0x67, 0xFB, 0x87, + 0xC9, 0xE0, 0xA5, 0x4F, 0xA2, 0x0D, 0xA9, 0xB8, + 0x59, 0xD4, 0xC0, 0x7C, 0x14, 0x78, 0x54, 0xD9, + 0x54, 0x2F, 0x46, 0x83, 0xFA, 0x40, 0xCB, 0x92, + 0x63, 0xB7, 0xD4, 0x2D, 0xC6, 0x1E, 0x2E, 0x0C + }, + { + 0x8B, 0x90, 0x1C, 0x3A, 0x2C, 0x34, 0x23, 0xD3, + 0xDE, 0x32, 0x00, 0x9E, 0x44, 0xF9, 0x07, 0x8C, + 0xD5, 0x3B, 0xA7, 0xCA, 0xA6, 0x54, 0xBF, 0xA9, + 0xFE, 0x68, 0xBF, 0x36, 0x6C, 0x2F, 0x7D, 0xF3, + 0x96, 0x32, 0x71, 0x13, 0x03, 0x6C, 0xC8, 0xBD, + 0x1A, 0x2B, 0xDC, 0xEA, 0xCF, 0x97, 0xE0, 0x73, + 0xAD, 0xDB, 0x1E, 0x86, 0x9D, 0x7B, 0xB9, 0xDB, + 0xC6, 0x39, 0x77, 0xC4, 0x69, 0xB3, 0xEF, 0x05 + }, + { + 0x64, 0x8B, 0x65, 0x70, 0xE0, 0xFD, 0x90, 0xDE, + 0xA0, 0x26, 0x41, 0xE4, 0x90, 0xF0, 0x9B, 0x92, + 0x49, 0xA7, 0x31, 0x70, 0x30, 0x93, 0x4C, 0x8A, + 0x6C, 0x4B, 0x6A, 0xE7, 0x0C, 0xAA, 0x11, 0xA3, + 0xFB, 0xC2, 0x68, 0xF7, 0xB8, 0x7C, 0x51, 0xCC, + 0xCE, 0x82, 0xDA, 0xF8, 0xC9, 0x4B, 0x4B, 0x9E, + 0xBF, 0x48, 0xA7, 0x3A, 0xC5, 0x59, 0xFC, 0xDA, + 0x35, 0xE1, 0xCE, 0xEE, 0xEE, 0x20, 0xE1, 0xBD + }, + { + 0x26, 0x0C, 0x91, 0x45, 0x2B, 0x5B, 0x33, 0x85, + 0xBD, 0xFD, 0x1D, 0xED, 0xB9, 0xA5, 0x43, 0xDF, + 0x58, 0xEA, 0x06, 0xC9, 0xD3, 0x69, 0x01, 0x55, + 0x1C, 0xA2, 0x4D, 0x5D, 0x00, 0x07, 0x92, 0x59, + 0x2A, 0x00, 0xD8, 0x58, 0xDA, 0xDC, 0x49, 0x1B, + 0xD9, 0xB6, 0x6A, 0xEA, 0x7C, 0x29, 0xDA, 0x66, + 0x07, 0xAE, 0x46, 0xE7, 0xF4, 0x77, 0xB1, 0x4E, + 0xA6, 0xD4, 0x62, 0xE2, 0x99, 0xA2, 0xDB, 0x3A + }, + { + 0x8A, 0xF7, 0x24, 0xF0, 0x34, 0xE7, 0x57, 0x55, + 0xFC, 0xF9, 0x68, 0xE0, 0x0B, 0x5F, 0x98, 0xBE, + 0xBE, 0xCE, 0xC9, 0xCB, 0x92, 0x41, 0xB0, 0x61, + 0xBA, 0x3E, 0xB6, 0x14, 0x41, 0xFB, 0xC6, 0x35, + 0xFC, 0xD3, 0xA6, 0x65, 0xB8, 0xD2, 0x72, 0xC6, + 0x91, 0x13, 0x72, 0xB4, 0x30, 0x82, 0xC8, 0x82, + 0xBF, 0x7E, 0xD9, 0x06, 0x45, 0x52, 0xD3, 0xEC, + 0xD9, 0x3F, 0xAF, 0x41, 0x17, 0x5E, 0x27, 0x04 + }, + { + 0x0C, 0xF9, 0xB5, 0x2D, 0xFF, 0xF9, 0xAC, 0xB0, + 0xA0, 0x30, 0xF9, 0xB9, 0xE2, 0xAB, 0x77, 0x54, + 0xA7, 0x36, 0x4E, 0x01, 0xFD, 0xAA, 0xE0, 0x2C, + 0x0A, 0x9D, 0x3D, 0xD0, 0xFD, 0x14, 0x2D, 0xED, + 0x6C, 0x63, 0xB8, 0x53, 0x27, 0xC8, 0x13, 0xE9, + 0x8E, 0x2E, 0x93, 0x39, 0x94, 0xF6, 0xCB, 0xCC, + 0x66, 0x8B, 0x44, 0x9E, 0x70, 0xF2, 0xE0, 0x58, + 0x58, 0x79, 0x8B, 0x33, 0x24, 0x99, 0x97, 0x2E + }, + { + 0xB6, 0x72, 0x31, 0x5B, 0x1A, 0x39, 0x79, 0x59, + 0x74, 0xB2, 0xC4, 0xF7, 0x92, 0x8B, 0xD1, 0x4B, + 0xE4, 0xC9, 0x73, 0x99, 0x1C, 0x10, 0x5F, 0x27, + 0xD6, 0xA2, 0xD8, 0xED, 0x22, 0x3D, 0x47, 0xDA, + 0xF1, 0x1E, 0x54, 0xA1, 0x8B, 0xF6, 0x39, 0x41, + 0xBC, 0x69, 0x24, 0xC7, 0x79, 0x4E, 0x80, 0xE1, + 0xD1, 0x2D, 0x95, 0x1D, 0x24, 0x38, 0x2B, 0xDD, + 0x0E, 0xEC, 0xA2, 0x04, 0x05, 0xD2, 0x62, 0x9C + }, + { + 0xD3, 0xC5, 0x7B, 0x08, 0x0C, 0x7E, 0x79, 0x63, + 0xAC, 0x0A, 0xF8, 0x07, 0x1C, 0x61, 0x48, 0x8B, + 0x50, 0xBD, 0x29, 0x29, 0x50, 0x82, 0xA8, 0x5B, + 0xC4, 0x39, 0x65, 0x5F, 0x8C, 0x34, 0x39, 0xDF, + 0xF0, 0xD7, 0x84, 0x9F, 0x13, 0x75, 0x76, 0xD9, + 0x5D, 0x2B, 0xAE, 0xC4, 0x8D, 0x7F, 0xC9, 0xB8, + 0x99, 0xD6, 0xC4, 0xEE, 0xCF, 0x84, 0x8D, 0x04, + 0xF2, 0x3E, 0x6D, 0x1C, 0x6F, 0x00, 0x1A, 0x79 + }, + { + 0xDD, 0xDA, 0x9B, 0x79, 0x65, 0x6A, 0xE3, 0xC4, + 0xA5, 0x87, 0xB5, 0x85, 0x83, 0xCE, 0xA7, 0x62, + 0xC3, 0x2A, 0xC5, 0x1F, 0x70, 0xA2, 0xDF, 0x7B, + 0xC5, 0xB5, 0xE0, 0x16, 0xF1, 0x31, 0xF2, 0xB1, + 0x69, 0x57, 0xB6, 0xAB, 0x6B, 0x2F, 0x2F, 0xA5, + 0x8E, 0xA5, 0xAD, 0x8E, 0x9E, 0x38, 0x1B, 0x2B, + 0xB1, 0x00, 0xBF, 0x0C, 0x43, 0x3C, 0xAF, 0x87, + 0x4D, 0xCC, 0x0F, 0x78, 0xAA, 0xB2, 0x8F, 0xA8 + }, + { + 0xCE, 0xD6, 0x10, 0x35, 0x6E, 0x69, 0x70, 0x17, + 0x84, 0x9C, 0x82, 0x08, 0x3E, 0x4A, 0xC0, 0xD5, + 0xEB, 0xF7, 0x9E, 0x17, 0xBC, 0x1E, 0xEF, 0x22, + 0x30, 0x34, 0x04, 0x20, 0xB3, 0x5B, 0x86, 0x22, + 0x83, 0xB0, 0xC0, 0xB2, 0xC3, 0x45, 0x65, 0xAA, + 0x00, 0x56, 0xE1, 0xAF, 0xE3, 0x9D, 0x7C, 0x3B, + 0x22, 0x98, 0x09, 0x7B, 0xD1, 0xA5, 0x3A, 0xC6, + 0x59, 0xCA, 0xD7, 0x16, 0xA3, 0x41, 0xEE, 0x08 + }, + { + 0x5C, 0x19, 0x53, 0x09, 0x1B, 0x1B, 0x6B, 0x11, + 0xE3, 0xEE, 0x15, 0x51, 0x6C, 0x1B, 0x4E, 0xD1, + 0x2E, 0x82, 0x3D, 0x31, 0x72, 0x8E, 0x2B, 0x07, + 0x89, 0x5A, 0x82, 0x5B, 0x5E, 0x94, 0x8B, 0x98, + 0xA5, 0x14, 0x01, 0xC0, 0x0D, 0x6E, 0x0B, 0x6E, + 0x08, 0xAF, 0x8E, 0xDB, 0x76, 0x9E, 0x95, 0x95, + 0x1C, 0x8C, 0xA5, 0xCE, 0x8A, 0x88, 0x15, 0x04, + 0xE0, 0xA2, 0xA0, 0x0A, 0x70, 0x3D, 0x5D, 0x9D + }, + { + 0xCE, 0xA4, 0xB3, 0x0A, 0xAB, 0xEC, 0x36, 0x89, + 0xC4, 0x97, 0xC1, 0xAD, 0x4E, 0x00, 0x63, 0x1C, + 0x76, 0x69, 0xB7, 0x0E, 0x6E, 0xEF, 0xC3, 0x0E, + 0xE3, 0xAB, 0x21, 0xA2, 0x52, 0x01, 0x24, 0xFF, + 0xEA, 0xCE, 0xEA, 0xBA, 0xF7, 0xDA, 0x71, 0x88, + 0xEA, 0xDF, 0x7C, 0xE5, 0x4E, 0xE2, 0x32, 0xD8, + 0x8F, 0xBB, 0x69, 0x54, 0xFB, 0x5D, 0xBF, 0x54, + 0xB2, 0x69, 0x19, 0xF2, 0xB8, 0xF9, 0x5D, 0xE7 + }, + { + 0xFE, 0xD1, 0x6B, 0xC3, 0x8D, 0xB7, 0xA8, 0x2C, + 0x49, 0xE4, 0xAD, 0x11, 0xC0, 0xCF, 0xFD, 0x4E, + 0x0B, 0x7E, 0x9F, 0x65, 0xA5, 0x6C, 0xF3, 0x66, + 0x4D, 0x09, 0xB1, 0x1F, 0xB3, 0xB8, 0x45, 0x0C, + 0x3F, 0xCC, 0x3B, 0x88, 0x68, 0xC3, 0x8F, 0xD3, + 0xA2, 0x01, 0x32, 0x4B, 0xEA, 0x63, 0x7C, 0x95, + 0x2E, 0xE3, 0x2C, 0xDE, 0xFC, 0x64, 0xDC, 0x8A, + 0x7C, 0x10, 0x92, 0xC5, 0xC1, 0x78, 0xCB, 0x85 + }, + { + 0xC7, 0xDD, 0x00, 0x97, 0x47, 0x69, 0x27, 0xE0, + 0x6E, 0xD7, 0xA1, 0xE8, 0xA2, 0x38, 0x80, 0xA4, + 0x00, 0xDD, 0xB0, 0x20, 0xCE, 0x1D, 0x8C, 0xA0, + 0xA0, 0x61, 0x23, 0x3A, 0xD3, 0x8F, 0xB7, 0xC9, + 0xAA, 0x65, 0xD5, 0xD8, 0xD7, 0x33, 0xFA, 0xFC, + 0x55, 0x3B, 0x44, 0x9F, 0xBB, 0x29, 0x53, 0xFB, + 0x0F, 0x59, 0x51, 0x30, 0xDB, 0xBD, 0xFC, 0x0C, + 0x70, 0x43, 0x02, 0xBA, 0xA5, 0x00, 0x83, 0xA9 + }, + { + 0xB7, 0x5D, 0x52, 0x11, 0x37, 0xEB, 0x12, 0xEA, + 0x49, 0x3E, 0xF5, 0x48, 0x8B, 0xFA, 0xFA, 0x6B, + 0x1B, 0xC3, 0x9F, 0x0D, 0xDA, 0x2C, 0x8E, 0x5E, + 0x05, 0x4F, 0xC1, 0xB7, 0xAC, 0xEA, 0x08, 0x1C, + 0x9E, 0x57, 0x80, 0x14, 0x73, 0x64, 0x75, 0x3B, + 0x19, 0x1D, 0x4E, 0xF2, 0xEC, 0x9C, 0x69, 0xE3, + 0x76, 0xE1, 0xFB, 0x6B, 0x50, 0x48, 0x42, 0xAF, + 0x54, 0x78, 0x36, 0xF2, 0x7E, 0x4C, 0x1E, 0x7F + }, + { + 0xFD, 0x77, 0xE5, 0x96, 0x63, 0x81, 0x5E, 0xAC, + 0xEB, 0x84, 0x97, 0x7B, 0x9E, 0x55, 0x59, 0x92, + 0xC2, 0xCB, 0x5F, 0xC0, 0x06, 0x38, 0xF6, 0xE9, + 0xC7, 0xE8, 0x02, 0xD9, 0x66, 0x66, 0xEF, 0x6E, + 0x71, 0x6D, 0x26, 0xC5, 0x97, 0x8C, 0xCE, 0x92, + 0x6F, 0x09, 0x5C, 0x28, 0xC7, 0x6A, 0xE9, 0xC6, + 0xAF, 0x1F, 0x16, 0xEB, 0xA2, 0x29, 0x8D, 0x9F, + 0xB1, 0x8A, 0x84, 0x5E, 0xFD, 0x03, 0xA6, 0xA4 + }, + { + 0x3C, 0x0C, 0x37, 0x45, 0x0F, 0x23, 0x8D, 0x89, + 0x9E, 0xC3, 0x71, 0x63, 0x7E, 0x69, 0xB3, 0x2B, + 0x20, 0x15, 0x90, 0xEA, 0x6F, 0xA9, 0x2E, 0x7F, + 0xB5, 0xF0, 0x8D, 0xC9, 0x4B, 0x9C, 0x00, 0x1D, + 0x82, 0x62, 0x23, 0x3A, 0xE9, 0x1F, 0x45, 0x63, + 0x97, 0x11, 0x03, 0x8A, 0xB1, 0x15, 0x4E, 0x43, + 0xD4, 0xB7, 0xD7, 0x25, 0x96, 0x0C, 0x6B, 0xA5, + 0x05, 0x7E, 0x9E, 0x88, 0xA5, 0x56, 0x31, 0x26 + }, + { + 0x20, 0x74, 0x36, 0x1B, 0x50, 0x90, 0xCA, 0x79, + 0x15, 0xC5, 0x06, 0x91, 0xCC, 0xBA, 0x1D, 0x97, + 0x7E, 0xEE, 0xEB, 0x84, 0x12, 0xBF, 0xF1, 0x02, + 0xD2, 0x8B, 0x71, 0x7A, 0x6C, 0x15, 0x9B, 0x94, + 0x4F, 0x09, 0x35, 0x45, 0x6C, 0x06, 0x11, 0xDD, + 0x90, 0x23, 0xA4, 0x33, 0x2C, 0x29, 0xEE, 0xB3, + 0xFB, 0x2B, 0x40, 0x78, 0x54, 0x14, 0x7A, 0xFF, + 0x4A, 0x54, 0xED, 0xCA, 0x14, 0x4B, 0x01, 0x34 + }, + { + 0x31, 0xF6, 0x30, 0x4C, 0x4C, 0x9B, 0x98, 0xDA, + 0x49, 0xEF, 0x93, 0xE5, 0x9E, 0xB7, 0x8C, 0xEF, + 0x84, 0xA6, 0x91, 0xE8, 0x2E, 0xDD, 0x05, 0x18, + 0x49, 0xAC, 0x0E, 0x7A, 0xB1, 0x2D, 0x2B, 0xE5, + 0xD2, 0x62, 0xB5, 0xB5, 0x8A, 0xB5, 0x87, 0x94, + 0x9C, 0xCD, 0xBF, 0x2C, 0x32, 0x20, 0xE1, 0x64, + 0xAC, 0x0B, 0xDD, 0x87, 0x03, 0xC1, 0xB0, 0xF9, + 0x3C, 0xC2, 0x60, 0xBC, 0x5F, 0x5B, 0xB6, 0x64 + }, + { + 0x3B, 0x3D, 0x52, 0xC9, 0x5E, 0x76, 0x5F, 0x0D, + 0x09, 0xEE, 0xB1, 0xF4, 0xE0, 0xF4, 0x7F, 0x9B, + 0x3E, 0x5F, 0xF8, 0x00, 0x9F, 0xBD, 0xC0, 0x71, + 0x9F, 0x73, 0x34, 0x14, 0xA2, 0x7A, 0x32, 0x80, + 0x80, 0xBA, 0xC3, 0xE5, 0x08, 0x01, 0x9F, 0x26, + 0xC1, 0x2C, 0x81, 0xB9, 0x4E, 0x27, 0xF5, 0xDE, + 0x2C, 0x82, 0x0D, 0x7F, 0xCA, 0xB7, 0x2E, 0xB9, + 0x73, 0x2A, 0xFD, 0x47, 0x2C, 0x3C, 0x6E, 0xA1 + }, + { + 0x34, 0x54, 0x9D, 0xA9, 0x8A, 0xE6, 0xC8, 0x1D, + 0xF3, 0x29, 0x48, 0xC0, 0x89, 0xC9, 0x73, 0x1D, + 0xA1, 0x48, 0x81, 0x41, 0x03, 0xCA, 0xB8, 0x7B, + 0xE2, 0x3B, 0x0E, 0xB7, 0xFE, 0xA2, 0xDE, 0x85, + 0x56, 0xFA, 0xEB, 0xC5, 0x0A, 0xFB, 0x7B, 0x65, + 0x07, 0x20, 0xC0, 0x70, 0xFA, 0x92, 0x3F, 0xC4, + 0x61, 0x82, 0x7C, 0x9A, 0x9A, 0x8F, 0x71, 0x4C, + 0x87, 0x9D, 0x6E, 0x40, 0x5C, 0x1E, 0x1E, 0xDA + }, + { + 0x2D, 0x58, 0x3C, 0xB7, 0x17, 0x20, 0x57, 0x80, + 0x72, 0x13, 0x99, 0xD6, 0x46, 0xFD, 0x4C, 0x80, + 0xED, 0xAA, 0xA7, 0xD0, 0x1D, 0x8D, 0x27, 0xB0, + 0x69, 0x92, 0x30, 0x81, 0x47, 0x52, 0x23, 0xB1, + 0x61, 0xBC, 0x0A, 0x2F, 0xAC, 0xAB, 0x64, 0xF3, + 0x8F, 0xE0, 0xF9, 0x7C, 0x54, 0xD6, 0x9C, 0x6A, + 0x63, 0x1B, 0x47, 0x53, 0x1A, 0x36, 0x59, 0x0A, + 0x8E, 0x2A, 0xFC, 0xD9, 0xA1, 0xAA, 0xE4, 0x2E + }, + { + 0x58, 0xBA, 0x67, 0xA2, 0xE9, 0x81, 0x26, 0x55, + 0xC7, 0x74, 0xE6, 0xC1, 0xE6, 0xA8, 0x71, 0x00, + 0x9A, 0x20, 0x05, 0x4F, 0x55, 0x4E, 0x6B, 0x25, + 0xA2, 0x57, 0x25, 0x86, 0x69, 0x96, 0x87, 0x8B, + 0xC8, 0xB0, 0xB1, 0xE6, 0xD6, 0x90, 0x63, 0x18, + 0x77, 0x5E, 0x5E, 0xC5, 0x0E, 0xEC, 0x78, 0x09, + 0x52, 0xBA, 0x75, 0xCA, 0x59, 0x95, 0xB9, 0xFC, + 0x7A, 0x6A, 0xB7, 0xC8, 0xF4, 0x74, 0xF8, 0xE5 + }, + { + 0xCA, 0x16, 0x74, 0xAC, 0x38, 0x42, 0x98, 0xB8, + 0x25, 0x81, 0x83, 0x7E, 0x55, 0x25, 0x05, 0x8B, + 0xA4, 0x51, 0x4A, 0xDC, 0xBC, 0xA1, 0xE2, 0x5B, + 0xB8, 0x5A, 0x7A, 0x76, 0x40, 0x27, 0xF3, 0xDD, + 0xFF, 0x5C, 0xC8, 0x83, 0xC6, 0xC7, 0x22, 0x56, + 0xFF, 0x82, 0xC1, 0x38, 0xF2, 0x10, 0xA5, 0xA5, + 0x7F, 0x32, 0xA9, 0x72, 0x5D, 0x35, 0xC6, 0x99, + 0x25, 0x6B, 0xAA, 0xBD, 0x64, 0x80, 0x27, 0x53 + }, + { + 0x19, 0x72, 0x0B, 0x63, 0xBB, 0x45, 0x1C, 0x59, + 0x82, 0x07, 0x38, 0xCE, 0xF4, 0x8A, 0x18, 0xC0, + 0xE0, 0x76, 0x12, 0x01, 0x37, 0x83, 0x3C, 0xB0, + 0x0B, 0x0C, 0x08, 0x12, 0x59, 0x67, 0x0D, 0xB2, + 0xB4, 0x6C, 0x4D, 0x49, 0x22, 0x6A, 0x00, 0x24, + 0x58, 0x30, 0x7D, 0x7F, 0xC7, 0x33, 0x3E, 0x8D, + 0xBB, 0x89, 0xF6, 0xCD, 0x4F, 0xE9, 0x78, 0x1D, + 0xAA, 0x25, 0x69, 0x6F, 0x15, 0x05, 0x83, 0x9D + }, + { + 0x9F, 0x8A, 0x17, 0x69, 0x13, 0x6B, 0x8F, 0x2B, + 0x7B, 0x63, 0xAC, 0x04, 0x5F, 0xD7, 0x4C, 0x8B, + 0x4F, 0xC6, 0x6A, 0xAD, 0xA5, 0xD7, 0x05, 0xBB, + 0xAE, 0x50, 0xDA, 0xBF, 0x38, 0x27, 0x69, 0x5A, + 0x8F, 0x4E, 0xC1, 0xC4, 0x3F, 0x27, 0x47, 0x3F, + 0xD5, 0xBD, 0xFA, 0x64, 0x7E, 0x1D, 0x15, 0x72, + 0x14, 0x30, 0xC2, 0x6B, 0xBC, 0x07, 0x9D, 0x01, + 0x16, 0x44, 0x12, 0x0D, 0x08, 0x8C, 0x7B, 0xDE + }, + { + 0x07, 0xAC, 0x0F, 0x95, 0x7B, 0x9E, 0x65, 0x27, + 0x13, 0x57, 0x97, 0xBF, 0x6F, 0x73, 0x21, 0x72, + 0xD4, 0x40, 0xC8, 0x51, 0xA0, 0x37, 0x2E, 0xA9, + 0x24, 0xFA, 0xD5, 0x15, 0x27, 0xCA, 0xE0, 0x3F, + 0x8C, 0xEE, 0x18, 0xB0, 0x72, 0xF8, 0x3D, 0xC6, + 0x28, 0x92, 0xE3, 0x40, 0xD1, 0xA4, 0xDB, 0x5D, + 0xC5, 0x8C, 0xE3, 0x5E, 0x10, 0xF0, 0xB7, 0xA5, + 0x13, 0x65, 0xB6, 0x46, 0xD6, 0x99, 0x84, 0xC2 + }, + { + 0x58, 0x3F, 0xA2, 0x84, 0x75, 0x2F, 0xD9, 0xE2, + 0xD8, 0xBF, 0xB8, 0x17, 0xBB, 0xF6, 0x7F, 0x1C, + 0xC1, 0x02, 0x8F, 0x85, 0xFF, 0x48, 0x6F, 0x66, + 0x40, 0x0F, 0x65, 0xB5, 0x63, 0x19, 0xE6, 0xDB, + 0xAA, 0x37, 0x90, 0x14, 0xDA, 0x70, 0xA1, 0x95, + 0xFF, 0xD9, 0x58, 0x31, 0x41, 0xB5, 0x42, 0x96, + 0x62, 0x51, 0xE1, 0x95, 0x27, 0x70, 0xFD, 0x40, + 0x1D, 0x30, 0x5E, 0xD7, 0xF8, 0x01, 0x6F, 0x14 + }, + { + 0x1C, 0x90, 0x23, 0x33, 0x28, 0x47, 0x23, 0x7F, + 0x92, 0xE5, 0xA5, 0xC9, 0x9A, 0x4D, 0x6C, 0x0A, + 0x19, 0xD6, 0xCB, 0x07, 0x10, 0xFB, 0xAF, 0x82, + 0xE0, 0x45, 0x12, 0xB3, 0x98, 0x4F, 0xA9, 0x32, + 0x11, 0x19, 0xAC, 0x7D, 0x56, 0x61, 0x44, 0x1E, + 0x37, 0x4B, 0x35, 0x04, 0x78, 0x51, 0x7A, 0x46, + 0x3C, 0xC1, 0xAB, 0xA9, 0xDA, 0x8A, 0x90, 0xE1, + 0x1C, 0xA2, 0xF7, 0xFB, 0xC8, 0xC6, 0x00, 0x31 + }, + { + 0x0A, 0x6D, 0xF3, 0x22, 0x69, 0xA0, 0x34, 0xEA, + 0x3D, 0x80, 0x09, 0xCF, 0xBF, 0x1D, 0x93, 0x29, + 0x31, 0x45, 0xAD, 0xC3, 0x6D, 0x59, 0xD5, 0x3E, + 0x4A, 0x95, 0x7C, 0x61, 0xFD, 0xB4, 0x6D, 0xA7, + 0x6D, 0x6A, 0x0B, 0xB4, 0x75, 0xE8, 0x2B, 0x7A, + 0x8D, 0x6E, 0xBA, 0x67, 0x7D, 0xED, 0x7C, 0x5A, + 0x8B, 0xBF, 0x80, 0xC6, 0x38, 0x49, 0x29, 0xA8, + 0x26, 0xD8, 0x49, 0x7D, 0x2F, 0x4C, 0x9C, 0x59 + }, + { + 0x60, 0xEF, 0x91, 0xB7, 0xF0, 0x87, 0xC5, 0x85, + 0x23, 0x19, 0xC9, 0x84, 0x27, 0x9E, 0x0B, 0x1A, + 0xDF, 0xC3, 0x9B, 0x67, 0x5C, 0xD1, 0x99, 0xF0, + 0x55, 0xC5, 0x17, 0x83, 0x9D, 0x18, 0x70, 0xB5, + 0x2E, 0xBE, 0x6F, 0x43, 0x8B, 0xD7, 0xBC, 0x5C, + 0x9F, 0x73, 0xA3, 0x49, 0x33, 0x8B, 0xA3, 0x1A, + 0x51, 0xA5, 0xF4, 0xD7, 0x0C, 0xCC, 0x4C, 0x15, + 0x24, 0x3F, 0x68, 0x06, 0xE5, 0xA3, 0xEE, 0xAA + }, + { + 0x8C, 0x2F, 0x96, 0xE8, 0x50, 0xBC, 0xBC, 0xC6, + 0x62, 0x7B, 0xE2, 0xCE, 0x3B, 0x23, 0x26, 0x33, + 0xA6, 0xD6, 0x99, 0x75, 0x28, 0xF7, 0x71, 0x00, + 0xEB, 0x85, 0x7F, 0x22, 0x00, 0x90, 0xD1, 0xDD, + 0x54, 0xBE, 0x76, 0xDC, 0xBB, 0xF8, 0x53, 0x56, + 0x83, 0x52, 0xE4, 0xD2, 0x60, 0x9B, 0xD4, 0x6C, + 0xAC, 0x05, 0x20, 0x95, 0xB2, 0xB8, 0xE0, 0x00, + 0xC9, 0xB2, 0x72, 0x28, 0xCE, 0x02, 0x3A, 0x6A + }, + { + 0xF3, 0x4D, 0xC1, 0x9B, 0x46, 0x96, 0xF4, 0x16, + 0x73, 0xEE, 0xAB, 0x57, 0xE0, 0x1E, 0x40, 0xB7, + 0xDE, 0x72, 0xA2, 0xBF, 0xE1, 0xC5, 0x1F, 0x8A, + 0xFF, 0x6C, 0x3A, 0xA3, 0xCE, 0x7E, 0x60, 0x9A, + 0x08, 0xB9, 0x8D, 0xD2, 0xBA, 0xAC, 0xD7, 0x62, + 0x29, 0x5B, 0xE9, 0x1B, 0xB3, 0x61, 0xE0, 0xE9, + 0x8B, 0xD1, 0x2F, 0x6B, 0x26, 0x84, 0xC3, 0xF2, + 0xE6, 0xB4, 0x13, 0x66, 0xEF, 0x3A, 0xC4, 0x5E + }, + { + 0xC7, 0x81, 0x9E, 0x75, 0xF4, 0x26, 0xDC, 0x74, + 0xCD, 0xAB, 0xF4, 0x3C, 0x09, 0x78, 0x23, 0x02, + 0x0F, 0x13, 0x95, 0x69, 0xC3, 0xA3, 0x04, 0xB7, + 0x62, 0x57, 0x65, 0xA2, 0xD0, 0xC0, 0x97, 0x3D, + 0x0C, 0xD9, 0xBA, 0x18, 0xD0, 0xB7, 0x8A, 0x50, + 0x00, 0x22, 0xA8, 0xB5, 0x3D, 0xC0, 0xF3, 0x6A, + 0x2B, 0x11, 0xB2, 0x33, 0x72, 0x0F, 0xD7, 0x1C, + 0xA7, 0x58, 0x38, 0x6C, 0xEF, 0xDB, 0xD0, 0xF5 + }, + { + 0x3E, 0x73, 0x85, 0x4F, 0xB9, 0xFF, 0xE1, 0xC3, + 0x75, 0xB3, 0x4B, 0x6A, 0xB7, 0x8E, 0x27, 0x08, + 0xA1, 0xAC, 0xFB, 0xB4, 0x3C, 0x29, 0xEF, 0x86, + 0xF1, 0x3C, 0xD1, 0xFE, 0xEF, 0x62, 0x74, 0x16, + 0x56, 0x7C, 0xD9, 0x65, 0x35, 0x02, 0x54, 0xCC, + 0xB4, 0xFD, 0x04, 0x25, 0xE2, 0xAD, 0x1E, 0xD6, + 0x9F, 0xA9, 0x7C, 0xBB, 0xEE, 0x4B, 0xEE, 0x18, + 0x56, 0xE6, 0x37, 0x51, 0x1A, 0xB1, 0xA1, 0xB0 + }, + { + 0xEF, 0xFB, 0x95, 0x5E, 0x53, 0x26, 0x9E, 0x77, + 0xAC, 0x37, 0x58, 0x20, 0x20, 0x37, 0x39, 0xE6, + 0x24, 0xE7, 0xA6, 0x28, 0x8D, 0x75, 0x83, 0xA4, + 0x95, 0x2C, 0x76, 0x92, 0x51, 0xDA, 0x83, 0xA3, + 0x86, 0x34, 0xCD, 0x56, 0x6D, 0x57, 0xB9, 0x8F, + 0xE7, 0xBE, 0xF9, 0x78, 0xAB, 0x43, 0x6E, 0x19, + 0x7A, 0x77, 0x50, 0x42, 0x1E, 0x30, 0x4E, 0x13, + 0xBD, 0x36, 0x74, 0xFC, 0xC2, 0x48, 0x75, 0x0A + }, + { + 0x2D, 0x90, 0xA2, 0xBC, 0x41, 0x51, 0x93, 0x67, + 0xA5, 0xE4, 0xED, 0xEB, 0xB4, 0x8E, 0xC6, 0x5A, + 0x0A, 0x9B, 0xEF, 0x78, 0xC4, 0x53, 0x72, 0xDB, + 0x7B, 0xB0, 0xC5, 0x3A, 0x50, 0x85, 0x76, 0xEE, + 0xE6, 0x31, 0xF4, 0x55, 0x39, 0xCB, 0x16, 0xAD, + 0x9E, 0x26, 0xBF, 0x8D, 0x49, 0x0B, 0x2D, 0x6B, + 0x74, 0xE1, 0x84, 0x57, 0x5B, 0xA2, 0x84, 0x5F, + 0x70, 0x38, 0xA4, 0xB6, 0x6C, 0x36, 0x9B, 0x86 + }, + { + 0x10, 0x80, 0x37, 0x55, 0xE6, 0xCD, 0xC0, 0x58, + 0xFF, 0x2F, 0x92, 0x5C, 0x84, 0x6B, 0x56, 0x22, + 0x91, 0x72, 0xF4, 0x41, 0x00, 0xC5, 0xD1, 0x93, + 0xDA, 0x68, 0x78, 0x36, 0x7B, 0x63, 0x36, 0x07, + 0x8E, 0x48, 0xCB, 0x84, 0x22, 0x4A, 0x76, 0xE6, + 0x4A, 0xA3, 0x0B, 0x31, 0x56, 0x30, 0x9D, 0x89, + 0x51, 0xC8, 0x38, 0x1D, 0x94, 0xA3, 0xCE, 0xDC, + 0x8A, 0xEF, 0xB8, 0x7D, 0x22, 0xD4, 0x30, 0x55 + }, + { + 0xFE, 0x3D, 0xC4, 0xA7, 0x28, 0x27, 0xD1, 0xD7, + 0xBC, 0x1E, 0xCC, 0xED, 0xCD, 0xF3, 0x30, 0x09, + 0x6B, 0xC1, 0x90, 0xAE, 0xD6, 0x9C, 0x53, 0xFB, + 0xF3, 0x69, 0x86, 0x69, 0x5B, 0xC7, 0xB1, 0xF4, + 0x32, 0x96, 0x4E, 0x88, 0xBB, 0xBB, 0x2A, 0x02, + 0x3B, 0xB8, 0x15, 0xCC, 0xF1, 0x72, 0xB2, 0xBA, + 0x14, 0xD2, 0x86, 0x26, 0xC8, 0x4B, 0xBB, 0xC6, + 0xD4, 0x76, 0xAD, 0xBD, 0x97, 0x16, 0xF7, 0x08 + }, + { + 0x6F, 0x6F, 0x54, 0x34, 0x89, 0xF6, 0x71, 0xA7, + 0xCF, 0x4C, 0x06, 0xDE, 0x0F, 0x48, 0xF8, 0xDD, + 0xF0, 0xCD, 0x6E, 0x4B, 0x78, 0x2F, 0x3E, 0xCD, + 0x60, 0x54, 0xA7, 0x1E, 0xCF, 0xD5, 0x97, 0x6A, + 0xD2, 0x1D, 0x12, 0x28, 0x14, 0x3B, 0x97, 0xBC, + 0x32, 0x36, 0x4B, 0x98, 0xB9, 0x08, 0x17, 0xDB, + 0x6C, 0x7B, 0x7E, 0x60, 0xCE, 0x5B, 0xAA, 0x39, + 0x56, 0x04, 0xAC, 0x3F, 0x09, 0x49, 0x3A, 0xE7 + }, + { + 0x32, 0xFA, 0x13, 0x97, 0x17, 0x27, 0x71, 0x74, + 0xC3, 0xDD, 0x3C, 0xAE, 0xD8, 0x64, 0x00, 0x92, + 0x86, 0x41, 0x4D, 0x27, 0x1D, 0xA5, 0x55, 0x97, + 0x76, 0x03, 0xF1, 0x69, 0x75, 0x6C, 0xBD, 0xB0, + 0xBC, 0xB5, 0x1F, 0xE6, 0x3C, 0x2E, 0x07, 0xED, + 0xB8, 0x42, 0xEC, 0x75, 0x5C, 0x47, 0xBF, 0x58, + 0x18, 0x49, 0x2B, 0xFF, 0x3C, 0xE8, 0x77, 0xFE, + 0x71, 0x10, 0x4A, 0xCC, 0xCF, 0xA7, 0xE3, 0xBA + }, + { + 0xD3, 0xC2, 0x83, 0x45, 0xE3, 0x52, 0xDB, 0xA8, + 0xFC, 0x78, 0x4F, 0x52, 0xA2, 0x43, 0x0F, 0xD7, + 0x6C, 0xF6, 0xC4, 0xAD, 0x31, 0xFB, 0x56, 0x8A, + 0xA4, 0xB0, 0xB7, 0x9F, 0xEC, 0x44, 0x56, 0xEF, + 0x5F, 0x15, 0x34, 0x0C, 0x51, 0x64, 0x84, 0xAC, + 0x68, 0x22, 0x3C, 0x5D, 0x4A, 0xA2, 0x10, 0x24, + 0x6C, 0xA2, 0xE3, 0xC5, 0xC4, 0x0D, 0x2F, 0xCE, + 0x5D, 0x13, 0xFE, 0x03, 0x1C, 0x9B, 0x63, 0x47 + }, + { + 0xAB, 0xBA, 0x4E, 0x15, 0xC2, 0xEF, 0xFD, 0xEC, + 0x96, 0xC6, 0xE9, 0x9C, 0x57, 0x0B, 0x9C, 0x60, + 0xED, 0x58, 0x7D, 0xF1, 0x81, 0x51, 0x3E, 0xF4, + 0x6A, 0x47, 0x49, 0x12, 0x3A, 0x4A, 0x39, 0xE7, + 0x71, 0xF5, 0xD6, 0xC3, 0x6D, 0xCB, 0x40, 0x61, + 0xA0, 0x7D, 0x44, 0x76, 0xC3, 0xF2, 0x33, 0x6D, + 0xF7, 0xDB, 0xC8, 0x90, 0x22, 0x7A, 0x6E, 0x72, + 0x05, 0xC7, 0x3B, 0x03, 0xF2, 0x8A, 0xC4, 0xB4 + }, + { + 0x69, 0xF5, 0x3E, 0x12, 0x45, 0x3C, 0x58, 0xD0, + 0x45, 0x9F, 0x38, 0x2F, 0x94, 0x29, 0x60, 0x8B, + 0xB1, 0xD4, 0x5B, 0xE5, 0x94, 0xF5, 0xD7, 0xC2, + 0xD1, 0xF0, 0xA7, 0xB8, 0xF6, 0x5E, 0xC3, 0xA5, + 0xDD, 0x2B, 0xDD, 0x29, 0x3F, 0xB0, 0x28, 0x38, + 0xAA, 0x82, 0xAC, 0x4A, 0xC8, 0xC7, 0xD6, 0x2B, + 0x35, 0x12, 0x72, 0xB3, 0x63, 0x62, 0x19, 0x5A, + 0x11, 0x1D, 0xF5, 0x73, 0xDB, 0xB7, 0x1B, 0x87 + }, + { + 0x90, 0xA8, 0xB4, 0x91, 0xB3, 0x3C, 0xB9, 0x55, + 0xD2, 0x65, 0xAB, 0xF4, 0x62, 0x40, 0x3A, 0xC9, + 0xC1, 0x11, 0x23, 0xC7, 0x2F, 0x58, 0x69, 0xF9, + 0xE5, 0xCB, 0x1F, 0x46, 0xC4, 0xD3, 0x7C, 0xB3, + 0x20, 0x02, 0xD5, 0x27, 0x9E, 0x41, 0x0E, 0x78, + 0x63, 0xBC, 0x9E, 0xA2, 0x9E, 0x78, 0xDE, 0x04, + 0xA8, 0xFB, 0xDD, 0x95, 0x0C, 0xA1, 0x8B, 0xA8, + 0x5E, 0x5A, 0xE9, 0x25, 0x92, 0xEB, 0xA3, 0xA1 + }, + { + 0x9E, 0x01, 0x94, 0x5C, 0x20, 0xC8, 0xCB, 0xF0, + 0xF9, 0x97, 0xCD, 0xC6, 0x0D, 0x1B, 0x03, 0x06, + 0x35, 0x44, 0x15, 0x47, 0xDA, 0xB3, 0xAF, 0x79, + 0xEB, 0x34, 0xD6, 0x76, 0x96, 0xC6, 0xA5, 0xE0, + 0xEF, 0x3D, 0x0C, 0x84, 0x3B, 0xCC, 0x36, 0x9A, + 0xB7, 0xD5, 0x19, 0xC2, 0xC7, 0x0A, 0x34, 0x3D, + 0x94, 0x72, 0x59, 0xA1, 0x85, 0x7C, 0x22, 0x47, + 0x97, 0xEF, 0x85, 0x18, 0xB6, 0xF0, 0x31, 0x6A + }, + { + 0x40, 0xB2, 0x8A, 0x09, 0xB1, 0xAC, 0xFB, 0x33, + 0xB3, 0xE2, 0x37, 0xA5, 0x6F, 0x82, 0xD3, 0xB4, + 0xEC, 0xC1, 0xAD, 0xBC, 0xB9, 0xFF, 0x28, 0x64, + 0xAF, 0x26, 0x34, 0x1B, 0x54, 0x45, 0xCB, 0xBF, + 0x1B, 0x7E, 0xE9, 0x57, 0x1A, 0xBF, 0x76, 0xF7, + 0xDB, 0x2B, 0xCA, 0x2D, 0x27, 0x69, 0x94, 0xCC, + 0x79, 0x5A, 0x61, 0xB9, 0xC1, 0x72, 0xE1, 0xA4, + 0x0B, 0xF5, 0x22, 0xBF, 0x89, 0xEF, 0xBF, 0x3B + }, + { + 0xC5, 0x10, 0xE9, 0x34, 0xC8, 0x9A, 0xE2, 0xC3, + 0xFB, 0x71, 0xB1, 0xAA, 0xD4, 0x85, 0x02, 0x59, + 0x93, 0x71, 0x19, 0xDD, 0x37, 0x85, 0x45, 0x61, + 0x4F, 0x1D, 0xBC, 0xAC, 0xD9, 0xD0, 0xA7, 0xE8, + 0x64, 0xE8, 0x21, 0x0B, 0x53, 0x5D, 0xF3, 0x0C, + 0x40, 0x9B, 0x01, 0x56, 0x07, 0x8B, 0x50, 0xE7, + 0xFC, 0xBF, 0x5B, 0x6F, 0x30, 0xA0, 0x8C, 0xAF, + 0x1E, 0x8C, 0x9F, 0xD4, 0xBA, 0x04, 0x09, 0xDA + }, + { + 0xC1, 0x35, 0xD4, 0x83, 0x9B, 0x58, 0x75, 0x94, + 0x5B, 0x52, 0xE8, 0x53, 0xB6, 0x0A, 0xEE, 0x0E, + 0xDC, 0x5A, 0x67, 0x15, 0x51, 0x87, 0xD8, 0xAF, + 0x4C, 0x19, 0xBF, 0x28, 0xA2, 0x90, 0x26, 0xDD, + 0xEB, 0x50, 0xDB, 0xEA, 0x89, 0xE4, 0x46, 0xB5, + 0x55, 0x61, 0x64, 0x12, 0x7B, 0x7F, 0xE9, 0xC7, + 0x3D, 0xDE, 0xCB, 0x24, 0xAC, 0x33, 0xB6, 0x89, + 0x5C, 0xEF, 0xC8, 0xBF, 0xBA, 0x2D, 0xE1, 0x6F + }, + { + 0x0A, 0xA8, 0x1A, 0x40, 0xCD, 0xEB, 0x8B, 0x26, + 0x3D, 0x1C, 0x6E, 0xBB, 0x76, 0x52, 0xC7, 0x82, + 0x69, 0x3D, 0x20, 0x36, 0x2A, 0x70, 0x1C, 0x0C, + 0x37, 0x4B, 0x7F, 0x00, 0xE6, 0x11, 0x7C, 0x58, + 0xC9, 0xAB, 0x39, 0x2C, 0x4C, 0x4F, 0x92, 0x3D, + 0xF0, 0x65, 0x72, 0xAC, 0x9E, 0x23, 0x54, 0x9E, + 0x25, 0x7C, 0xE5, 0x19, 0x12, 0x6D, 0x4E, 0x24, + 0xB0, 0x41, 0xA0, 0xEC, 0xA8, 0x89, 0x92, 0xDC + }, + { + 0xAC, 0x1D, 0x7D, 0xEA, 0x3B, 0x73, 0xDC, 0x41, + 0x02, 0xE6, 0xE8, 0x91, 0xCE, 0x26, 0xEF, 0xEF, + 0x52, 0xC5, 0xDD, 0x9C, 0xB0, 0x37, 0xE5, 0x30, + 0xC4, 0x8A, 0x64, 0x13, 0xD4, 0xB3, 0x2C, 0x97, + 0xAB, 0x29, 0x0E, 0xE8, 0xA7, 0x69, 0x71, 0xEB, + 0x1F, 0x3C, 0xF0, 0xA4, 0x70, 0xCF, 0x32, 0x61, + 0xFC, 0xF3, 0xF2, 0x7C, 0x56, 0x02, 0xC9, 0x2D, + 0x50, 0x3D, 0xA1, 0x00, 0x2B, 0xD4, 0x70, 0x51 + }, + { + 0xE2, 0xC3, 0x0C, 0x75, 0xC2, 0x96, 0x63, 0x37, + 0x20, 0x0B, 0xA4, 0xF5, 0xD4, 0xE8, 0x09, 0x34, + 0x26, 0xA2, 0x9D, 0x0A, 0xD5, 0x38, 0x82, 0xF6, + 0x15, 0x97, 0xEF, 0x95, 0xAB, 0x6A, 0xEF, 0x8F, + 0xC8, 0xED, 0x3A, 0x4C, 0x83, 0x0F, 0xC6, 0xAE, + 0x13, 0x71, 0x62, 0x02, 0x18, 0xE9, 0x96, 0x0F, + 0x0F, 0x3E, 0x57, 0x08, 0x5B, 0x82, 0x80, 0x53, + 0xFD, 0x2B, 0x09, 0x3D, 0x63, 0xEB, 0x98, 0x0A + }, + { + 0xAD, 0xE5, 0x59, 0x25, 0xA2, 0xF8, 0xC2, 0x61, + 0xC4, 0xF2, 0xF1, 0xC7, 0xD3, 0x39, 0xB6, 0x76, + 0x55, 0x59, 0x04, 0xBA, 0xE3, 0xC7, 0xC2, 0xCA, + 0x04, 0x73, 0xC9, 0x1E, 0x7F, 0x17, 0xA6, 0xE7, + 0xCD, 0xBC, 0xFD, 0x6C, 0xA2, 0x9E, 0xAA, 0x5F, + 0xCB, 0x58, 0xF0, 0x6A, 0x1D, 0x5E, 0x05, 0x2E, + 0xD3, 0xAE, 0x5A, 0x82, 0xEF, 0x71, 0x69, 0xD7, + 0xA1, 0x7C, 0xE2, 0xE7, 0x89, 0x3D, 0x4B, 0x89 + }, + { + 0x2A, 0xD6, 0x4D, 0x52, 0x01, 0xBD, 0x08, 0x22, + 0xD8, 0xE5, 0x1A, 0x1A, 0x83, 0x34, 0xB3, 0x44, + 0x74, 0xBD, 0xFD, 0x3B, 0xE0, 0x76, 0xC4, 0x02, + 0x75, 0x2F, 0x31, 0xC4, 0x14, 0x15, 0x2C, 0xC1, + 0x2F, 0xF4, 0x37, 0xEC, 0xAF, 0xF7, 0xFC, 0x50, + 0xD3, 0x06, 0x09, 0x31, 0x54, 0xEF, 0xF6, 0xAC, + 0x69, 0x5B, 0xD1, 0x08, 0xA8, 0xB7, 0x77, 0x46, + 0x24, 0xFC, 0x8B, 0x4E, 0x78, 0x18, 0x0C, 0x00 + }, + { + 0x41, 0x94, 0xAB, 0x30, 0xE0, 0x8D, 0x7A, 0xD3, + 0x61, 0x94, 0xB1, 0xB6, 0x2D, 0x15, 0x9C, 0x5B, + 0x3B, 0x30, 0xF4, 0xB6, 0x80, 0x9E, 0x3C, 0x96, + 0x73, 0xB3, 0x3F, 0x83, 0xEE, 0x83, 0x73, 0xCE, + 0x3D, 0x0A, 0x6E, 0xF7, 0x3C, 0xF8, 0xE3, 0xFD, + 0x33, 0x0B, 0x74, 0x40, 0xAA, 0xE7, 0x34, 0x65, + 0x13, 0x88, 0x32, 0x52, 0x6F, 0xCC, 0x77, 0xDF, + 0x66, 0xE7, 0xED, 0xA3, 0x57, 0x04, 0xA4, 0xD4 + }, + { + 0xB4, 0x48, 0x7B, 0xB0, 0x05, 0xF6, 0x75, 0xFF, + 0xC3, 0x8D, 0x09, 0x6C, 0x07, 0x56, 0x51, 0xBC, + 0xAB, 0x83, 0x62, 0xEE, 0x48, 0xA6, 0xD7, 0x26, + 0xA0, 0x98, 0x68, 0xF1, 0x42, 0x6B, 0xA7, 0x09, + 0x9E, 0x17, 0x95, 0x7B, 0x39, 0x71, 0xAC, 0xFD, + 0x02, 0xF0, 0x24, 0xFC, 0xFB, 0x54, 0x0F, 0x86, + 0x96, 0xE0, 0xFA, 0xA6, 0x0B, 0x38, 0x5B, 0xF6, + 0xF6, 0x2B, 0xF0, 0x99, 0xED, 0x1B, 0x75, 0xC7 + }, + { + 0x1B, 0xE2, 0x28, 0x92, 0x28, 0xB8, 0x22, 0xA1, + 0xDB, 0x0A, 0xF5, 0xB6, 0xFD, 0xF3, 0x4D, 0xB8, + 0xF9, 0xAA, 0xB7, 0xED, 0x6B, 0xAA, 0x21, 0xAB, + 0xF0, 0xDE, 0xBC, 0xE8, 0xDF, 0xD2, 0xB5, 0x3C, + 0x55, 0x91, 0x94, 0x0B, 0xF5, 0xD0, 0xC1, 0x1F, + 0xAE, 0x66, 0xF3, 0xCE, 0xA2, 0x61, 0x01, 0x49, + 0xCB, 0x8E, 0x9D, 0x36, 0x31, 0xBC, 0xF3, 0x84, + 0x54, 0x94, 0xCE, 0x4D, 0x3E, 0x0E, 0x49, 0x47 + }, + { + 0x38, 0xA9, 0x6C, 0xCC, 0x1F, 0x8E, 0x5A, 0xA6, + 0x27, 0x22, 0x4D, 0xB7, 0xE3, 0x40, 0x5B, 0xFC, + 0xA0, 0xA7, 0x75, 0xC9, 0x46, 0xBD, 0xFB, 0xEE, + 0xD4, 0xEF, 0x38, 0xD6, 0xB5, 0x9B, 0x65, 0xFB, + 0x69, 0x93, 0xDA, 0xA8, 0xA2, 0x1F, 0x59, 0xF1, + 0x3A, 0xCA, 0x36, 0x0C, 0x84, 0x8E, 0x97, 0xCD, + 0xDF, 0x8D, 0xE1, 0xCD, 0xEC, 0x07, 0xBF, 0xBE, + 0x06, 0x6C, 0x91, 0x5A, 0xBF, 0x40, 0xEF, 0x18 + }, + { + 0x26, 0x03, 0x7C, 0x4D, 0x6F, 0x57, 0x40, 0x21, + 0x3C, 0x46, 0xED, 0x3E, 0x3C, 0x68, 0xCA, 0xC2, + 0x20, 0x64, 0xAB, 0x29, 0x29, 0x40, 0x52, 0x12, + 0x97, 0x48, 0xA3, 0xED, 0x51, 0xE0, 0xD8, 0x4B, + 0x27, 0x01, 0x4C, 0xC2, 0xCE, 0x07, 0xD0, 0xF6, + 0xE0, 0x47, 0x90, 0x82, 0x2A, 0x7A, 0xBB, 0xFE, + 0xBB, 0xF6, 0x19, 0xE5, 0x2F, 0x22, 0x9A, 0x8D, + 0xCB, 0x0F, 0xB6, 0xCD, 0x4E, 0x78, 0xEE, 0x72 + }, + { + 0x42, 0x0D, 0x8B, 0x8F, 0xB6, 0xC2, 0x62, 0x8B, + 0xBB, 0xE5, 0x14, 0xF2, 0x2C, 0xB9, 0x2F, 0x3E, + 0xF7, 0x8E, 0xB8, 0xE8, 0xCD, 0xA5, 0x1B, 0x82, + 0x3A, 0xF6, 0x16, 0xF7, 0x67, 0xDF, 0xEA, 0x17, + 0xBD, 0x33, 0xA4, 0x31, 0x74, 0xEA, 0x03, 0xF4, + 0x15, 0xFC, 0xCC, 0x65, 0xCD, 0xBD, 0x2D, 0xB9, + 0xC3, 0xFC, 0x02, 0x16, 0x8E, 0x28, 0xBC, 0x85, + 0x4B, 0xCC, 0x8C, 0x7A, 0x32, 0x93, 0xCA, 0x4F + }, + { + 0xC8, 0x3C, 0xF5, 0xF7, 0x45, 0xCF, 0xF6, 0xCB, + 0x82, 0x74, 0xE6, 0x70, 0xD5, 0xF6, 0x57, 0x09, + 0x8F, 0x07, 0xB3, 0xE5, 0x58, 0x44, 0xFC, 0xC7, + 0x88, 0x4A, 0xE8, 0x12, 0x25, 0xAB, 0x3E, 0x9D, + 0xF8, 0xA9, 0x7F, 0xCD, 0xB5, 0xD2, 0x58, 0xC2, + 0x60, 0x1F, 0xF2, 0xAB, 0x88, 0x42, 0x72, 0x0D, + 0x72, 0x11, 0x8B, 0x07, 0x21, 0x2E, 0x15, 0xDA, + 0xFF, 0xEF, 0xB2, 0x75, 0x99, 0x39, 0x07, 0x21 + }, + { + 0x60, 0xAF, 0xEC, 0xCD, 0x80, 0xDC, 0x97, 0xC1, + 0xB4, 0xEF, 0x0F, 0x4C, 0xF8, 0x47, 0xB0, 0xDB, + 0x64, 0x28, 0x6D, 0xF9, 0x72, 0x74, 0xE7, 0x8E, + 0x69, 0xC8, 0x6C, 0xFA, 0x0F, 0xEB, 0xFC, 0x17, + 0x8A, 0xE7, 0x08, 0x65, 0x18, 0x48, 0x42, 0xDA, + 0xD5, 0x9C, 0xFA, 0x33, 0x65, 0xBC, 0xFA, 0xD6, + 0xBF, 0x1A, 0x99, 0x5B, 0x49, 0x2B, 0x89, 0x8B, + 0x9B, 0x17, 0x77, 0xA2, 0x47, 0x63, 0x7A, 0x66 + }, + { + 0xAD, 0x7A, 0x82, 0xF9, 0xB6, 0x3F, 0x9E, 0x0B, + 0x46, 0x4C, 0xCF, 0x55, 0xFA, 0x25, 0x82, 0x2E, + 0x1B, 0x84, 0xB4, 0xA1, 0x67, 0x52, 0xC0, 0x3A, + 0x3D, 0xC8, 0xA7, 0xB3, 0x94, 0xE3, 0x61, 0x96, + 0x5D, 0x47, 0x5A, 0x46, 0x85, 0x00, 0x6D, 0xBA, + 0x32, 0x0D, 0xA3, 0xD3, 0x3A, 0xAD, 0x20, 0x06, + 0x66, 0xFE, 0xEC, 0x78, 0x3A, 0x35, 0x10, 0x18, + 0x5B, 0xF3, 0xA6, 0x32, 0xE8, 0x82, 0x3B, 0x24 + }, + { + 0x7D, 0x11, 0x3A, 0xC7, 0xC1, 0xE0, 0x98, 0xD1, + 0x04, 0xC7, 0x8E, 0x82, 0xD5, 0x08, 0x36, 0x61, + 0x14, 0xA4, 0x19, 0x70, 0x41, 0xE0, 0xA4, 0xCA, + 0x05, 0x22, 0xCB, 0x94, 0x23, 0xD4, 0xE1, 0xBF, + 0xE7, 0x3C, 0xB0, 0x0C, 0x9C, 0x71, 0x8E, 0x77, + 0xF0, 0xE3, 0x8F, 0x17, 0x79, 0xE0, 0x90, 0x57, + 0x1C, 0x39, 0x0A, 0x0B, 0xA4, 0xB5, 0xFE, 0xD9, + 0x45, 0x08, 0x2B, 0xDB, 0xD3, 0x50, 0x87, 0x14 + }, + { + 0xC6, 0x2A, 0xDA, 0x7E, 0xDE, 0x2D, 0xD4, 0x0B, + 0x61, 0x1A, 0x73, 0x9E, 0x1E, 0x49, 0x8E, 0xE5, + 0x51, 0x6A, 0x2A, 0xDD, 0xB8, 0xD7, 0x2E, 0xC7, + 0x21, 0x30, 0x7B, 0xA6, 0xFA, 0x6D, 0x9A, 0x1E, + 0x86, 0x52, 0x11, 0x8A, 0xC7, 0xA2, 0x47, 0x6F, + 0x04, 0xE7, 0x58, 0xDD, 0xC5, 0x76, 0xE0, 0xE5, + 0xD5, 0x40, 0x0A, 0xDF, 0x7F, 0x7C, 0xC1, 0x88, + 0xE5, 0x1D, 0x1D, 0x82, 0xE7, 0x0A, 0x01, 0x12 + }, + { + 0x88, 0x18, 0x14, 0x27, 0xF3, 0xF0, 0x00, 0xAA, + 0x65, 0x03, 0x2C, 0xA1, 0x7E, 0xBD, 0x26, 0x0C, + 0xA8, 0x69, 0x5E, 0xEC, 0x57, 0x9B, 0x67, 0xE5, + 0x5D, 0x3D, 0x29, 0xB2, 0x0C, 0xC9, 0x96, 0x5E, + 0xEA, 0xEB, 0x23, 0x7F, 0x7C, 0x47, 0xCB, 0xD2, + 0xEC, 0xE4, 0x24, 0x48, 0x27, 0x4D, 0x4C, 0x1E, + 0x3A, 0x6D, 0x7C, 0x8D, 0xB1, 0x75, 0xE1, 0x74, + 0x7B, 0xC6, 0x88, 0xF5, 0xCB, 0xCC, 0x1D, 0x81 + }, + { + 0x9E, 0x8D, 0xCC, 0xF2, 0x16, 0xDC, 0xE5, 0xA4, + 0xDA, 0xC3, 0x6C, 0xB9, 0x29, 0xD1, 0x6D, 0x1F, + 0xF3, 0xEE, 0x34, 0x3E, 0x1B, 0xB0, 0x23, 0x43, + 0x1C, 0x20, 0x0C, 0xB5, 0xC9, 0xF3, 0xFA, 0xDB, + 0x0F, 0xFD, 0xB1, 0xA1, 0xA9, 0x51, 0x42, 0x41, + 0x87, 0xB4, 0x81, 0x03, 0x46, 0x85, 0x61, 0x31, + 0x03, 0x8A, 0x38, 0x13, 0x46, 0x26, 0xDC, 0x36, + 0x84, 0xF6, 0x61, 0x96, 0x16, 0xFB, 0x19, 0xF3 + }, + { + 0x35, 0xDB, 0x69, 0x86, 0x23, 0x74, 0xED, 0xB3, + 0x22, 0xED, 0x74, 0xFD, 0x2B, 0x23, 0xA7, 0x86, + 0xDC, 0x4C, 0xC1, 0x2E, 0x0C, 0x55, 0x84, 0xD8, + 0x24, 0xD6, 0xE7, 0x8F, 0x37, 0xD9, 0xB6, 0x00, + 0xE3, 0x7B, 0x38, 0xB4, 0x2B, 0x95, 0xB7, 0xC3, + 0x83, 0x0D, 0x0D, 0xA3, 0xD6, 0xC9, 0xB3, 0xC7, + 0x8D, 0x3B, 0x66, 0x48, 0xA3, 0x93, 0xEE, 0x2F, + 0xB1, 0x89, 0x06, 0x7F, 0x9C, 0x49, 0x12, 0x56 + }, + { + 0x33, 0x48, 0xE5, 0x68, 0x59, 0x80, 0xD4, 0xD1, + 0x33, 0xF1, 0x32, 0xEE, 0xDA, 0x67, 0x2C, 0x2D, + 0xA3, 0x94, 0x81, 0x1D, 0xFE, 0x50, 0x00, 0xC5, + 0x2C, 0x4D, 0x80, 0xA0, 0x4F, 0xD3, 0xB4, 0x1B, + 0xF8, 0x89, 0xF1, 0xF2, 0x34, 0x57, 0xC4, 0xE7, + 0xF3, 0x6B, 0xC0, 0x1A, 0x09, 0x38, 0x81, 0x6E, + 0x99, 0x75, 0xA3, 0xCF, 0x89, 0x8C, 0x8F, 0x2C, + 0xA7, 0xFA, 0x03, 0x19, 0x19, 0x0D, 0x84, 0x00 + }, + { + 0x3A, 0xCF, 0x70, 0x7B, 0x5E, 0x07, 0xAC, 0x7D, + 0xD3, 0x28, 0x1A, 0x7B, 0xFA, 0x8A, 0x20, 0xA7, + 0x13, 0x61, 0x58, 0xBE, 0x5C, 0xB8, 0x66, 0xF0, + 0xF1, 0x7D, 0xE0, 0xEA, 0x0B, 0x3C, 0x0A, 0x04, + 0xF3, 0x4C, 0x6C, 0x93, 0x77, 0xE1, 0xEC, 0x45, + 0x84, 0x5F, 0xBA, 0x8C, 0x7D, 0xD3, 0xD4, 0x41, + 0x93, 0x96, 0xF5, 0xEC, 0xCF, 0x95, 0x36, 0x10, + 0x5E, 0xF7, 0xD3, 0xD8, 0x56, 0x49, 0x69, 0xDF + }, + { + 0x0E, 0x93, 0x08, 0x13, 0xAD, 0xD6, 0x4B, 0x14, + 0x45, 0x5C, 0x08, 0xA4, 0xC9, 0xC2, 0x3A, 0x33, + 0x19, 0x8A, 0x0F, 0xF8, 0x08, 0x96, 0xE1, 0x9A, + 0xF5, 0xDD, 0xB4, 0x5A, 0x75, 0x76, 0x79, 0xC8, + 0x8D, 0x0D, 0xD4, 0xCE, 0x2F, 0x81, 0xF8, 0x1A, + 0x27, 0xCA, 0xEB, 0xC2, 0xAE, 0xC2, 0x91, 0x04, + 0x23, 0x2A, 0xE5, 0x68, 0x4C, 0xE2, 0x2B, 0xC5, + 0xD6, 0xF0, 0xAF, 0x76, 0x02, 0x9F, 0xFE, 0x0F + }, + { + 0x85, 0xD2, 0x0C, 0xB2, 0x4F, 0x9F, 0xA7, 0x13, + 0xF1, 0x02, 0x00, 0x5E, 0xBE, 0x88, 0x91, 0x92, + 0x47, 0x67, 0x46, 0xC7, 0x02, 0xC3, 0x72, 0x36, + 0x58, 0xE8, 0x4A, 0x0B, 0xCC, 0x84, 0x4C, 0xE6, + 0x37, 0x95, 0x30, 0x47, 0xEE, 0x6B, 0xCF, 0x28, + 0x17, 0x97, 0xD4, 0xAC, 0x44, 0x74, 0xF8, 0x19, + 0x34, 0x02, 0x3F, 0xC4, 0xC0, 0xF5, 0xA4, 0x93, + 0xDC, 0xAE, 0x15, 0xF5, 0x20, 0xB4, 0x94, 0x07 + }, + { + 0x58, 0x5C, 0x32, 0x3B, 0x42, 0xFF, 0x57, 0xE1, + 0x70, 0x20, 0x2B, 0xBF, 0x74, 0x6F, 0x2C, 0x31, + 0xED, 0xD2, 0x6A, 0xD5, 0x06, 0x81, 0x39, 0xB0, + 0x98, 0x27, 0x6A, 0x6F, 0xF0, 0xBA, 0x9D, 0xCE, + 0xBC, 0x30, 0xDA, 0x48, 0x79, 0xA8, 0xED, 0xE5, + 0x4B, 0x91, 0xD1, 0xC0, 0x7B, 0xE3, 0x13, 0xB9, + 0xA2, 0x97, 0xD8, 0xD9, 0x72, 0x48, 0xAA, 0x21, + 0x62, 0x95, 0x07, 0xE3, 0xE4, 0x4D, 0xEF, 0x29 + }, + { + 0xE1, 0xA5, 0xB4, 0xEC, 0x20, 0x80, 0x1C, 0x5C, + 0x78, 0x4A, 0xA7, 0x1C, 0xE0, 0x06, 0xA3, 0xFA, + 0xAB, 0xD7, 0x84, 0x10, 0x54, 0xBF, 0x02, 0x1F, + 0x7C, 0xA4, 0xE3, 0x2D, 0xAB, 0x4A, 0x7D, 0xB0, + 0x50, 0x3A, 0xEF, 0xBB, 0x4A, 0x1B, 0x0D, 0x33, + 0xEE, 0xBC, 0x11, 0x5D, 0xA2, 0x82, 0x98, 0x81, + 0x60, 0xB6, 0xA0, 0x6D, 0xF9, 0x8C, 0x4E, 0x96, + 0x98, 0x7A, 0x1F, 0xD1, 0x6B, 0x6D, 0xFB, 0x69 + }, + { + 0xC5, 0x93, 0xD7, 0xE4, 0x52, 0x78, 0x56, 0x69, + 0xFE, 0x96, 0xF0, 0x32, 0xB0, 0x39, 0x5D, 0x2D, + 0xC7, 0xCC, 0xC3, 0x45, 0x6D, 0x8E, 0x6D, 0x0F, + 0x47, 0x19, 0xF6, 0x54, 0xBE, 0xC5, 0xCF, 0xA2, + 0xA5, 0x26, 0x29, 0xC2, 0x39, 0x55, 0x3B, 0xE3, + 0x9D, 0xFE, 0x51, 0x29, 0x1D, 0xF7, 0x73, 0xD9, + 0x98, 0x0C, 0x47, 0x20, 0x43, 0xDE, 0x7D, 0x7A, + 0x6D, 0x34, 0x5E, 0x62, 0xED, 0xA6, 0xDB, 0xEE + }, + { + 0xB3, 0xD7, 0x52, 0x14, 0x38, 0x6A, 0x4C, 0x27, + 0xDA, 0x0E, 0xAC, 0xBD, 0x12, 0x39, 0xF2, 0x40, + 0xDB, 0x80, 0x9F, 0x31, 0xCE, 0xC2, 0xF9, 0x0D, + 0xCA, 0xF1, 0xBD, 0x8C, 0xEC, 0x3B, 0x40, 0x55, + 0x2F, 0x48, 0x9A, 0x25, 0x5A, 0x85, 0xA6, 0xFF, + 0xCD, 0x89, 0x39, 0xDD, 0xF3, 0x85, 0x70, 0x80, + 0xD4, 0x61, 0xCC, 0x16, 0xD2, 0x09, 0xA5, 0x43, + 0x48, 0x88, 0x4F, 0x53, 0x38, 0x31, 0x76, 0xD1 + }, + { + 0x5B, 0x3F, 0xFE, 0x81, 0x2A, 0xF0, 0x71, 0xD4, + 0xDC, 0xE0, 0xBF, 0xCE, 0xFF, 0x65, 0x03, 0x5C, + 0x8D, 0x1A, 0x06, 0x3F, 0x85, 0xB5, 0x53, 0x20, + 0x58, 0xEC, 0x54, 0xB6, 0xC3, 0xDF, 0xB5, 0x79, + 0x7A, 0x17, 0x8C, 0xC3, 0xFD, 0x53, 0xBC, 0xE9, + 0xEA, 0x54, 0xC1, 0x07, 0xD2, 0xE7, 0x6E, 0xE5, + 0x43, 0xFF, 0x98, 0xB2, 0xE8, 0xA4, 0xB3, 0x12, + 0x51, 0x1A, 0x78, 0x50, 0x8E, 0x4D, 0xFA, 0xF8 + }, + { + 0xBB, 0x1C, 0x63, 0x7E, 0x9F, 0x50, 0x28, 0xF9, + 0xE0, 0xD5, 0x2E, 0x3B, 0xC0, 0xA7, 0x80, 0xEF, + 0x37, 0x18, 0x1E, 0x11, 0x97, 0x41, 0xA1, 0x56, + 0xED, 0x9A, 0xA7, 0x9F, 0x1C, 0x5D, 0x2C, 0x3C, + 0x6C, 0x0F, 0xD8, 0xD2, 0xA0, 0x7B, 0xC8, 0x09, + 0xF0, 0x85, 0xE4, 0x0B, 0x8E, 0xBF, 0x8D, 0x87, + 0x68, 0x8E, 0x72, 0xDE, 0xE0, 0xFA, 0xD5, 0x84, + 0xAC, 0x6C, 0x25, 0xB5, 0xD6, 0x7A, 0x75, 0xE4 + }, + { + 0xBE, 0xB0, 0x01, 0x1C, 0xD4, 0x84, 0xD0, 0x85, + 0x8C, 0xCF, 0xC6, 0xFC, 0x5D, 0x72, 0xD8, 0x05, + 0xCC, 0xB3, 0xC3, 0x72, 0x9D, 0xAF, 0x72, 0xA5, + 0xA3, 0x5B, 0xDC, 0x4B, 0xEB, 0x5F, 0x3F, 0xCC, + 0x3D, 0x13, 0xBC, 0xF1, 0x39, 0x86, 0x81, 0x51, + 0x2E, 0xDA, 0xEE, 0x93, 0x53, 0x88, 0x42, 0x1E, + 0xF6, 0x1B, 0x38, 0xD6, 0x7E, 0xFC, 0x52, 0x7A, + 0x25, 0x15, 0x4D, 0x04, 0xF4, 0xC5, 0x62, 0xA4 + }, + { + 0xA7, 0x59, 0xC2, 0x73, 0xC4, 0xCA, 0xD5, 0xAF, + 0x6B, 0x68, 0xB3, 0xD8, 0x3D, 0x22, 0xBD, 0xC5, + 0x8F, 0x93, 0x0F, 0x58, 0x3E, 0x3A, 0xE5, 0x60, + 0xFE, 0x40, 0xF4, 0x74, 0x40, 0xE9, 0x42, 0x27, + 0x2D, 0x8C, 0x6F, 0xC2, 0xEC, 0xB7, 0xD9, 0xB1, + 0x07, 0x98, 0x02, 0x12, 0xF2, 0x7F, 0xC8, 0xB1, + 0x0D, 0x36, 0x99, 0x9C, 0xCC, 0x79, 0xAB, 0x5F, + 0xBD, 0xFA, 0x2D, 0xF6, 0x86, 0x1F, 0xF5, 0x63 + }, + { + 0xC7, 0x5F, 0x9A, 0xF4, 0xD9, 0x56, 0xD3, 0x05, + 0xD6, 0x74, 0xF8, 0x7F, 0xC6, 0x84, 0x3F, 0xAC, + 0xF4, 0x1F, 0xD0, 0x16, 0x79, 0x74, 0xFF, 0x5F, + 0x3D, 0x0A, 0x6D, 0x51, 0xB0, 0xCC, 0x3B, 0xA2, + 0x60, 0x57, 0xDF, 0x6C, 0x53, 0xA1, 0x49, 0x64, + 0x02, 0xB8, 0xF5, 0xBA, 0xF5, 0x27, 0x6F, 0x42, + 0x3F, 0xAD, 0xFC, 0x3D, 0x31, 0xF4, 0x13, 0x7E, + 0xD9, 0xB1, 0x8C, 0x87, 0x58, 0x51, 0x5F, 0x73 + }, + { + 0xD3, 0xE7, 0x48, 0x90, 0x91, 0x40, 0x67, 0x55, + 0xF5, 0xC2, 0x6B, 0xF3, 0x84, 0xD7, 0x12, 0x6E, + 0x4A, 0x26, 0x7C, 0x74, 0xF9, 0x8C, 0x05, 0x44, + 0x9D, 0x33, 0x39, 0xC5, 0x06, 0xB3, 0xCF, 0x3D, + 0x5B, 0xE2, 0xF6, 0x37, 0xF0, 0x64, 0x3D, 0x5D, + 0xD8, 0x7D, 0x09, 0x39, 0xC6, 0x04, 0x8A, 0x4F, + 0x0A, 0x72, 0x26, 0x36, 0xDB, 0x55, 0x05, 0xA5, + 0x4A, 0x90, 0xB0, 0x50, 0x0B, 0x28, 0xAC, 0xA1 + }, + { + 0x80, 0x7B, 0x3D, 0xB2, 0x5B, 0xEA, 0x7E, 0x6E, + 0x2F, 0xB2, 0x0B, 0xB1, 0xB8, 0x31, 0xF4, 0x23, + 0x98, 0xBC, 0x66, 0x36, 0xCD, 0x9A, 0xD8, 0x96, + 0x5E, 0xB7, 0x8B, 0xFF, 0x3E, 0xF8, 0x03, 0x60, + 0x43, 0xB7, 0xFA, 0x92, 0xCB, 0x49, 0x9A, 0x1E, + 0x98, 0x59, 0x9A, 0xE9, 0x18, 0x7A, 0xB5, 0x38, + 0x48, 0xDD, 0x85, 0xE6, 0xBF, 0x07, 0x94, 0xFB, + 0xB5, 0x7F, 0x3F, 0x0E, 0x72, 0xFE, 0xC1, 0xBC + }, + { + 0x26, 0x43, 0xE9, 0x19, 0xD2, 0x61, 0x1C, 0x0E, + 0x24, 0x82, 0x53, 0xBC, 0x0B, 0xB3, 0xF4, 0x44, + 0xD6, 0xE8, 0xD4, 0xC2, 0xB6, 0x9C, 0xD5, 0xAB, + 0xD9, 0x6D, 0xA9, 0xE8, 0x8C, 0x4C, 0xD4, 0x23, + 0x5A, 0x99, 0x66, 0x98, 0x73, 0x31, 0xCE, 0x83, + 0x92, 0x7D, 0x39, 0x86, 0x56, 0xFA, 0x74, 0x6C, + 0xEC, 0x97, 0x64, 0x3F, 0x15, 0x3F, 0xF6, 0xE1, + 0xAD, 0xDA, 0xB3, 0xA5, 0xD9, 0xBE, 0x04, 0x49 + }, + { + 0x14, 0xB6, 0x2B, 0xFA, 0xAF, 0xB4, 0x97, 0x02, + 0xC8, 0xF3, 0x0D, 0x29, 0xCD, 0x9B, 0x30, 0xFA, + 0x21, 0x19, 0xD7, 0x6A, 0x7A, 0x6C, 0xE3, 0xD0, + 0xCD, 0x84, 0x19, 0x4B, 0x9D, 0x24, 0xB3, 0xC2, + 0x67, 0xBC, 0x46, 0xEF, 0x42, 0xAD, 0xB1, 0xF4, + 0x5A, 0x77, 0x3C, 0x84, 0x70, 0xBF, 0x77, 0x61, + 0x4B, 0x10, 0xD4, 0x6B, 0x6E, 0x52, 0xAB, 0x20, + 0x14, 0x1E, 0x6B, 0x1B, 0x9F, 0x7B, 0x19, 0x74 + }, + { + 0x1F, 0x2D, 0x2F, 0x81, 0xDC, 0x72, 0x06, 0x11, + 0x5E, 0x82, 0x3C, 0x1C, 0x8A, 0x35, 0x86, 0x6A, + 0xB4, 0x38, 0x9F, 0x50, 0x36, 0xA0, 0x0F, 0x79, + 0x40, 0x4A, 0x73, 0x08, 0x04, 0xE5, 0xBB, 0x7B, + 0xE8, 0x97, 0x41, 0x47, 0xD5, 0x4E, 0x3F, 0x66, + 0xFE, 0xC6, 0x0C, 0x63, 0x8C, 0x6F, 0x50, 0xD0, + 0x84, 0x05, 0x16, 0x8E, 0xC2, 0x24, 0x7F, 0x42, + 0x6C, 0x0F, 0xE4, 0xCA, 0xDC, 0x2B, 0xD5, 0x33 + }, + { + 0xED, 0x69, 0x88, 0x13, 0xFB, 0x67, 0x87, 0x63, + 0x4F, 0xB8, 0x20, 0x0B, 0x8D, 0x08, 0x19, 0xA2, + 0x02, 0xEE, 0x01, 0x0F, 0x69, 0x63, 0x19, 0x29, + 0xE9, 0x10, 0xAE, 0x1C, 0x59, 0xF8, 0xA1, 0xB1, + 0xB9, 0x23, 0xB8, 0x79, 0xA4, 0x49, 0x4A, 0xF3, + 0x29, 0x16, 0x17, 0xE4, 0xC9, 0x6E, 0x85, 0x70, + 0x03, 0x95, 0xED, 0x40, 0x53, 0x86, 0x09, 0xC9, + 0xCC, 0x68, 0x7F, 0x0A, 0x3F, 0x18, 0x45, 0xAC + }, + { + 0x84, 0xC1, 0x78, 0xE6, 0x5F, 0x80, 0x97, 0x55, + 0xD4, 0x2A, 0x12, 0xC9, 0x7E, 0x81, 0x8B, 0xE0, + 0x7F, 0xA5, 0xD5, 0xF7, 0x89, 0xC8, 0x93, 0x0B, + 0xBD, 0xCB, 0xFB, 0x37, 0x74, 0xD8, 0xF7, 0x69, + 0xC8, 0x67, 0xF8, 0x9C, 0x9C, 0x05, 0x9C, 0x82, + 0xBB, 0x49, 0xED, 0x79, 0xF0, 0x84, 0xDE, 0xE4, + 0xBB, 0xCD, 0x03, 0xC0, 0xA1, 0xC7, 0x25, 0x7F, + 0x6A, 0x35, 0x02, 0x24, 0x2A, 0x46, 0x1F, 0x07 + }, + { + 0xA6, 0x92, 0x2D, 0xF8, 0x4E, 0xF3, 0x50, 0x2A, + 0xB6, 0x7D, 0xC3, 0x20, 0x13, 0x1C, 0xEA, 0x44, + 0x35, 0xC1, 0x65, 0x10, 0xDE, 0xBA, 0x21, 0xB1, + 0x52, 0xBE, 0x3F, 0x32, 0x59, 0x24, 0x4F, 0x36, + 0x95, 0xE9, 0x8B, 0xF7, 0xE9, 0x0C, 0x23, 0x5B, + 0xE6, 0x8C, 0x41, 0x3E, 0xCC, 0xB9, 0x56, 0x6F, + 0x3C, 0x1D, 0x87, 0x9C, 0x75, 0x21, 0x93, 0xBE, + 0x36, 0x6B, 0xB8, 0xA9, 0x6F, 0x44, 0xAA, 0x1A + }, + { + 0xB5, 0xBD, 0x34, 0xB0, 0x6F, 0x66, 0x1B, 0x5E, + 0xFC, 0x6E, 0x3F, 0xD7, 0x32, 0x68, 0x99, 0x06, + 0xED, 0x82, 0x92, 0x70, 0xB2, 0x00, 0x55, 0x60, + 0x58, 0xA4, 0x7C, 0x03, 0x3C, 0xCE, 0xE5, 0xFA, + 0xE7, 0x88, 0x20, 0xDD, 0x54, 0xC9, 0x4C, 0xCC, + 0x8A, 0x84, 0x26, 0xF5, 0x46, 0xD8, 0x73, 0x1D, + 0x25, 0xB8, 0x3F, 0x93, 0x4E, 0x53, 0xAF, 0x08, + 0x85, 0x72, 0x0A, 0x6C, 0x22, 0xFE, 0x63, 0xAC + }, + { + 0x03, 0xDD, 0xD1, 0x1A, 0x95, 0xD5, 0x91, 0x31, + 0x11, 0xA4, 0xBB, 0x24, 0x52, 0xDB, 0x1A, 0xDB, + 0x48, 0x53, 0xE2, 0xE2, 0x9B, 0x65, 0x20, 0x37, + 0xB2, 0x64, 0x62, 0x3E, 0xB2, 0x97, 0x87, 0xC6, + 0xAE, 0xED, 0xC9, 0x95, 0x49, 0xE0, 0xD3, 0x3C, + 0x96, 0xE1, 0x58, 0x32, 0xAA, 0xB2, 0xB9, 0x32, + 0xF1, 0xE5, 0x92, 0xC5, 0x34, 0xB0, 0x9E, 0x02, + 0x26, 0xD0, 0x12, 0x1C, 0xDD, 0xF2, 0xDC, 0x0A + }, + { + 0x2A, 0x26, 0xF3, 0x7B, 0xE3, 0x07, 0x18, 0x82, + 0x6A, 0x9B, 0x7F, 0xBA, 0xE3, 0x0C, 0x99, 0xE6, + 0x32, 0x70, 0x54, 0xFC, 0x42, 0x5B, 0x4D, 0x6A, + 0xB7, 0xF3, 0xFA, 0x17, 0xE4, 0x7E, 0xAB, 0x59, + 0xC6, 0xDF, 0xAC, 0xBA, 0xA9, 0x25, 0x81, 0x59, + 0xE1, 0x32, 0x85, 0xDF, 0x19, 0xF7, 0x24, 0x55, + 0xAA, 0x04, 0xBB, 0xF1, 0x95, 0x5F, 0xAF, 0x82, + 0xB0, 0xF6, 0x5D, 0x00, 0x6D, 0xB0, 0x56, 0xAF + }, + { + 0x8F, 0x79, 0xBD, 0x5B, 0xF3, 0x1A, 0x6F, 0x29, + 0x8B, 0x28, 0x3B, 0x5E, 0xB0, 0xFE, 0xA1, 0xD8, + 0xB1, 0x8E, 0xA2, 0x45, 0x75, 0x8C, 0x41, 0x54, + 0xC2, 0xBE, 0x1A, 0xA5, 0x5E, 0x0A, 0xE3, 0x7F, + 0x47, 0xD6, 0x42, 0x24, 0xAE, 0x9C, 0xA9, 0x66, + 0xE0, 0x82, 0x5E, 0x09, 0x4E, 0x3A, 0xD4, 0xEB, + 0xCB, 0xA7, 0x28, 0x3E, 0x03, 0x31, 0x42, 0x8C, + 0xCE, 0x7D, 0x6E, 0x12, 0xE3, 0x21, 0xA1, 0x5B + }, + { + 0xEF, 0x8E, 0xCA, 0x85, 0xD7, 0x6D, 0xF6, 0xBA, + 0xC3, 0x27, 0xC8, 0xFF, 0x4E, 0x2F, 0x30, 0x7E, + 0xC4, 0xA5, 0x5A, 0x1C, 0xD4, 0x8E, 0x4F, 0xE6, + 0xB0, 0xC5, 0x2E, 0xFB, 0xE1, 0x91, 0xFD, 0xBB, + 0xF9, 0x53, 0x2F, 0x15, 0x1A, 0xDB, 0xA4, 0x2C, + 0x6D, 0xA9, 0xB3, 0xDA, 0x17, 0x48, 0xC6, 0x89, + 0x0F, 0x49, 0xF4, 0x4F, 0x1B, 0xD3, 0x33, 0xBC, + 0x5F, 0x96, 0xFF, 0xC0, 0x34, 0x4A, 0x3B, 0xFF + }, + { + 0x13, 0xED, 0x27, 0x69, 0x4E, 0x26, 0x5D, 0x35, + 0x09, 0x33, 0x9A, 0xE2, 0x13, 0xA3, 0xED, 0xA3, + 0x26, 0x2F, 0x73, 0x52, 0x64, 0x42, 0x91, 0xD1, + 0x2A, 0xDF, 0x00, 0x13, 0x6A, 0x25, 0x77, 0x87, + 0x8E, 0x64, 0x46, 0x01, 0xD0, 0x0B, 0x82, 0x06, + 0xD8, 0x95, 0x7B, 0xCA, 0x43, 0xBF, 0x82, 0x96, + 0xDB, 0x0E, 0x6E, 0x29, 0x5B, 0xCC, 0x5B, 0x13, + 0xD3, 0xDF, 0xC2, 0x1A, 0x7D, 0xB8, 0x09, 0x5B + }, + { + 0x0F, 0xB3, 0x5B, 0x81, 0x4B, 0xEA, 0x3E, 0x3C, + 0x83, 0x60, 0xDD, 0x6D, 0x41, 0x17, 0x6B, 0x0A, + 0x4A, 0xCC, 0xC8, 0x12, 0xCB, 0xB8, 0xBB, 0xBB, + 0x35, 0xC1, 0xB6, 0x51, 0x42, 0xDA, 0x3D, 0xDE, + 0xC5, 0xCF, 0xAA, 0x05, 0x62, 0xE8, 0x7E, 0xFF, + 0x4E, 0xF4, 0x1C, 0xFE, 0xC0, 0xAE, 0xEB, 0x6F, + 0x76, 0x1B, 0x4F, 0x02, 0x85, 0x4C, 0x9C, 0x10, + 0xAC, 0xE4, 0x41, 0xF4, 0x79, 0x06, 0x8F, 0xA2 + }, + { + 0x04, 0xE0, 0x6D, 0x19, 0x94, 0xC2, 0x43, 0xB1, + 0x0D, 0xD6, 0xC1, 0x2F, 0xDD, 0xCE, 0x35, 0xEC, + 0xF7, 0x74, 0xFD, 0x50, 0x7C, 0x88, 0x6D, 0xF3, + 0x4E, 0xE7, 0xE9, 0xE4, 0x39, 0x06, 0x74, 0xC7, + 0xD2, 0x5B, 0x6A, 0x52, 0xDC, 0x52, 0x23, 0xA8, + 0xDA, 0x59, 0x3E, 0x34, 0xC7, 0x3F, 0x01, 0x2C, + 0xD8, 0x98, 0x73, 0x06, 0x05, 0x1E, 0xBC, 0x75, + 0x42, 0x23, 0x29, 0x94, 0xEE, 0xBB, 0xDF, 0xFE + }, + { + 0x3B, 0x5B, 0x11, 0xED, 0x6D, 0xB7, 0x53, 0xDF, + 0xF5, 0x6E, 0x48, 0xD1, 0xE9, 0x94, 0x80, 0xFE, + 0x89, 0x89, 0x0C, 0xBD, 0xF6, 0x43, 0xA9, 0x6E, + 0x9E, 0xB9, 0x38, 0xEA, 0xE3, 0xBA, 0xAC, 0x6E, + 0xA2, 0x3D, 0xE6, 0x80, 0x6D, 0x28, 0x13, 0xA8, + 0xB5, 0x20, 0x9A, 0x1C, 0x7F, 0x84, 0x56, 0x80, + 0xCB, 0xD6, 0x33, 0x18, 0x72, 0x46, 0x78, 0xF2, + 0x65, 0xCA, 0x14, 0x26, 0xC5, 0x66, 0x29, 0xE2 + }, + { + 0x82, 0x00, 0xB1, 0x08, 0x0E, 0x9D, 0xC4, 0xEE, + 0x92, 0x29, 0x1D, 0x77, 0xE4, 0x05, 0xD5, 0x21, + 0xF6, 0x43, 0x34, 0x23, 0x70, 0x57, 0x82, 0xB5, + 0x96, 0x76, 0x10, 0x6E, 0x18, 0xB4, 0x81, 0xE3, + 0x2C, 0xC5, 0x19, 0xBC, 0x5C, 0xB2, 0xBD, 0x30, + 0xCC, 0x9B, 0xAA, 0xA6, 0xB5, 0xFF, 0xF5, 0x9F, + 0x7C, 0xE3, 0x5C, 0x17, 0x80, 0xFB, 0xCA, 0xC2, + 0x8D, 0xAD, 0x20, 0xE5, 0x38, 0x02, 0xE1, 0x32 + }, + { + 0x03, 0xB1, 0xFE, 0xB3, 0x8C, 0xF2, 0x7D, 0x13, + 0xCF, 0x06, 0x76, 0xDF, 0x09, 0x5E, 0x83, 0x79, + 0x8E, 0x46, 0xAA, 0x44, 0x17, 0x67, 0x54, 0x6B, + 0x04, 0x73, 0xA8, 0xFA, 0xD8, 0x51, 0x17, 0x44, + 0xBE, 0x9D, 0x61, 0xA9, 0x12, 0x4D, 0x7F, 0xA5, + 0xF1, 0x14, 0xD6, 0xA8, 0x1E, 0x3A, 0x42, 0x44, + 0x68, 0x24, 0xBD, 0x80, 0x71, 0x10, 0xB4, 0x62, + 0xB3, 0xD7, 0x9A, 0x9F, 0x4A, 0xCD, 0x0B, 0xCF + }, + { + 0xA6, 0xD1, 0xB9, 0xE3, 0x9F, 0xCA, 0xC3, 0x1D, + 0x88, 0x98, 0x13, 0x3D, 0x6C, 0xE3, 0x80, 0x05, + 0x26, 0xB6, 0x34, 0x10, 0x71, 0x96, 0x14, 0x45, + 0x0D, 0x8D, 0x86, 0xF2, 0x00, 0xD2, 0x08, 0xFD, + 0x7E, 0x03, 0x4A, 0x0B, 0x0F, 0x62, 0xB5, 0xE6, + 0x04, 0x89, 0x57, 0xDB, 0xEE, 0x79, 0x41, 0xA0, + 0x50, 0xF4, 0xCC, 0x88, 0x1F, 0x00, 0xB4, 0x59, + 0x55, 0x31, 0xA4, 0x6D, 0xAD, 0x2B, 0xE3, 0xFD + }, + { + 0x75, 0xCC, 0x48, 0xB7, 0x1A, 0xE9, 0x9D, 0x1C, + 0x9B, 0xFC, 0xF4, 0xA4, 0x15, 0x31, 0x87, 0x75, + 0xB5, 0x87, 0xD2, 0x2C, 0x25, 0x0F, 0xFC, 0x13, + 0xE1, 0x95, 0x44, 0x49, 0x8C, 0xC0, 0xC8, 0xC1, + 0xFD, 0x4F, 0x57, 0x2C, 0x15, 0x58, 0x2E, 0xCF, + 0x78, 0x2A, 0x2B, 0x62, 0x30, 0x4C, 0xC3, 0x42, + 0x98, 0x7E, 0xBF, 0xDE, 0x56, 0xF7, 0xCE, 0x8D, + 0xB7, 0xD8, 0xC5, 0x96, 0xEE, 0x46, 0xAC, 0x40 + }, + { + 0x21, 0x32, 0x91, 0xA2, 0xAD, 0xED, 0xEF, 0x87, + 0x22, 0x79, 0x2C, 0x26, 0x72, 0x93, 0x34, 0x3F, + 0x98, 0xB5, 0x09, 0x5B, 0x39, 0xBF, 0x0C, 0xB5, + 0x4E, 0x43, 0x3E, 0x80, 0x72, 0xB1, 0xF4, 0xD2, + 0xD1, 0xB1, 0x85, 0x8D, 0x0C, 0x97, 0xA1, 0x9E, + 0x7B, 0xA9, 0x53, 0xCF, 0xC5, 0x4C, 0x29, 0x29, + 0xEB, 0x4E, 0x82, 0x07, 0xB8, 0xFC, 0xEA, 0x04, + 0x91, 0x66, 0x5A, 0x32, 0x3C, 0x78, 0xA3, 0x76 + }, + { + 0xA8, 0xA4, 0x62, 0xFA, 0x4C, 0xE1, 0x09, 0xA0, + 0x7D, 0xCA, 0x72, 0x9C, 0xE0, 0xBD, 0x13, 0x6E, + 0x06, 0x2C, 0xFA, 0xB3, 0x53, 0xE1, 0xC3, 0xC1, + 0x15, 0xAE, 0xED, 0x51, 0xBD, 0x1D, 0x68, 0xE3, + 0xFE, 0x82, 0xBE, 0xAB, 0x1B, 0xF3, 0x5D, 0x92, + 0x56, 0xD7, 0x64, 0x6A, 0x80, 0xB0, 0xB0, 0xA0, + 0x54, 0x47, 0xCD, 0x25, 0xC8, 0xEC, 0x57, 0x31, + 0xCE, 0xB4, 0xA7, 0x24, 0xCD, 0xDE, 0x1D, 0x87 + }, + { + 0x15, 0xC6, 0xAF, 0x75, 0x58, 0xB5, 0x76, 0xDC, + 0x91, 0xA2, 0xD1, 0xAC, 0x07, 0xC9, 0x8A, 0xE1, + 0x51, 0xB5, 0xAA, 0x6C, 0xDC, 0xFC, 0x73, 0x3B, + 0xB1, 0xF6, 0x59, 0x55, 0xAF, 0xFA, 0x76, 0x56, + 0xCD, 0x29, 0x0E, 0xD1, 0xF3, 0x2D, 0x3B, 0x33, + 0x67, 0x69, 0xCE, 0x47, 0xE3, 0xC2, 0x12, 0xB2, + 0x6C, 0x1D, 0x3F, 0x4F, 0x70, 0x1D, 0x72, 0x39, + 0x14, 0xAC, 0x8F, 0x72, 0xCE, 0x71, 0x6E, 0x40 + }, + { + 0xA5, 0x26, 0xFE, 0xB3, 0x05, 0x1D, 0xCE, 0x03, + 0xB1, 0x4D, 0x3A, 0xD6, 0x21, 0x3D, 0x0E, 0xFA, + 0x36, 0xEE, 0xEC, 0x1E, 0x74, 0x64, 0x9E, 0x4C, + 0xA7, 0xDD, 0x13, 0x41, 0x8F, 0x03, 0x30, 0x27, + 0x05, 0xD3, 0x69, 0xEF, 0x27, 0x7F, 0x94, 0x89, + 0xFA, 0x8F, 0xF8, 0x85, 0xB5, 0xAE, 0x29, 0xA2, + 0xFF, 0x08, 0x2C, 0x29, 0x33, 0xC7, 0x6D, 0x07, + 0xBB, 0x63, 0xA5, 0xF1, 0x55, 0x4B, 0x26, 0xC7 + }, + { + 0x10, 0xE8, 0xA4, 0x0C, 0x9F, 0x51, 0xF0, 0xFE, + 0xE6, 0x36, 0x04, 0x22, 0x03, 0x9B, 0xBD, 0x21, + 0x1C, 0x1A, 0x2F, 0x23, 0xDE, 0x5B, 0x7B, 0xAD, + 0x7D, 0x2B, 0xBC, 0x0B, 0xA4, 0x6A, 0x0D, 0xD5, + 0xB0, 0xF3, 0xE8, 0x2E, 0x20, 0x61, 0xAD, 0xA4, + 0x52, 0x32, 0x29, 0x21, 0x5A, 0x3E, 0x7E, 0xFC, + 0x1D, 0x56, 0xE0, 0x70, 0xA1, 0x7E, 0x52, 0xDF, + 0x6A, 0x1C, 0x42, 0x80, 0x11, 0x32, 0x4F, 0xD3 + }, + { + 0xD0, 0x92, 0xCE, 0xEC, 0x1B, 0x1F, 0x18, 0x7E, + 0x0D, 0x3F, 0x3D, 0x4D, 0x85, 0x7C, 0x8C, 0x25, + 0x4F, 0x47, 0x60, 0x08, 0x69, 0x00, 0xE0, 0x16, + 0xBF, 0x2D, 0xD0, 0xCF, 0x55, 0xA3, 0xD6, 0xEB, + 0x1B, 0x73, 0x6C, 0xF9, 0x38, 0xB5, 0xCD, 0x38, + 0xAB, 0x1B, 0x18, 0x4D, 0x95, 0xF6, 0xD0, 0xA6, + 0x62, 0xC3, 0xED, 0x46, 0x79, 0x80, 0xF7, 0x2D, + 0xF2, 0x4E, 0x90, 0x2A, 0xD9, 0xA9, 0x10, 0xFC + }, + { + 0xCF, 0x2C, 0xFF, 0x83, 0x57, 0xE8, 0x68, 0x19, + 0x55, 0x08, 0x68, 0xCB, 0x38, 0x23, 0xAB, 0x1C, + 0xC9, 0x4F, 0x90, 0x55, 0x92, 0x26, 0x02, 0xE3, + 0x37, 0x0A, 0x54, 0xE3, 0x58, 0xC0, 0xB6, 0xE1, + 0xA8, 0x56, 0xA7, 0xF0, 0x1E, 0x33, 0xA6, 0xBB, + 0x64, 0xA1, 0x24, 0x8F, 0x3E, 0x4B, 0xAD, 0xE3, + 0x66, 0x3D, 0x72, 0x72, 0x28, 0x2E, 0x4D, 0xEA, + 0x34, 0x71, 0xBB, 0x8D, 0x1E, 0x1F, 0x42, 0x7B + }, + { + 0x2D, 0x56, 0x3B, 0x48, 0x9F, 0x75, 0xE2, 0x86, + 0xC5, 0x90, 0x6D, 0xCF, 0x05, 0x09, 0x14, 0x12, + 0xA0, 0xD9, 0x4F, 0x2D, 0x17, 0xFB, 0xEF, 0x2C, + 0x17, 0xF2, 0xD8, 0xD7, 0x57, 0xDB, 0x76, 0x5C, + 0xE7, 0x55, 0x1B, 0x18, 0x82, 0x4F, 0x97, 0xB6, + 0xBA, 0x18, 0x47, 0xB2, 0x32, 0xFC, 0x72, 0xB7, + 0xB6, 0x55, 0xC9, 0xB8, 0x5E, 0x88, 0x1D, 0x54, + 0x84, 0xC7, 0x53, 0x1F, 0x69, 0x03, 0x5E, 0x33 + }, + { + 0xA4, 0x92, 0xBF, 0x76, 0xC7, 0x71, 0x89, 0x8C, + 0xDF, 0x03, 0x99, 0x23, 0xCB, 0x7B, 0x56, 0x2E, + 0x04, 0x47, 0x50, 0x30, 0x1D, 0xD2, 0x21, 0x6F, + 0x89, 0x60, 0xE2, 0x39, 0x60, 0xE0, 0xA8, 0x72, + 0x1F, 0xEC, 0x07, 0xA7, 0xC6, 0x93, 0xD5, 0x19, + 0xF0, 0x1D, 0x25, 0x85, 0x25, 0x7D, 0x9D, 0x65, + 0x74, 0xC5, 0xC8, 0x78, 0xFD, 0x2D, 0xF2, 0x45, + 0xF7, 0xF9, 0xE6, 0x0F, 0x7F, 0xB3, 0xD6, 0x3F + }, + { + 0xB3, 0x64, 0x68, 0xAA, 0xC9, 0x1E, 0xB4, 0x43, + 0xE7, 0xA5, 0xBD, 0xD2, 0xF1, 0xE3, 0x4C, 0x2F, + 0xC0, 0x92, 0xD3, 0x6F, 0xC0, 0x3B, 0x45, 0xEE, + 0x08, 0xD3, 0x01, 0x2D, 0x48, 0x2E, 0x69, 0x87, + 0x65, 0x0E, 0xC1, 0xCF, 0x32, 0xF6, 0x20, 0xAD, + 0xEF, 0x2B, 0xB9, 0xA2, 0xAF, 0x30, 0x09, 0xE0, + 0x4E, 0xD7, 0x2E, 0x30, 0x0D, 0xDC, 0xAC, 0xA6, + 0x48, 0xD8, 0xC2, 0xC7, 0x80, 0xF2, 0x08, 0x2D + }, + { + 0x7A, 0xC6, 0xF2, 0x7D, 0x0C, 0xFF, 0x77, 0xE8, + 0x59, 0x87, 0x6B, 0x68, 0x80, 0x8A, 0xF2, 0x30, + 0x4B, 0x4F, 0x46, 0x8A, 0x43, 0xDA, 0x92, 0xDB, + 0xDE, 0x4C, 0x16, 0x9E, 0x2F, 0x8B, 0x76, 0x5F, + 0x94, 0xB1, 0xDB, 0xC8, 0xA0, 0x16, 0xC0, 0x51, + 0xAA, 0x77, 0xE3, 0xCD, 0x58, 0xC0, 0x7C, 0xEB, + 0x9A, 0xE7, 0x29, 0x34, 0x3E, 0x92, 0x8C, 0x20, + 0xFE, 0xD1, 0xDA, 0x35, 0xA2, 0x8C, 0x2C, 0x05 + }, + { + 0x7B, 0x9B, 0xB3, 0x2E, 0xAB, 0x51, 0xE4, 0x09, + 0x9F, 0x6A, 0x80, 0xF3, 0x40, 0x77, 0xE9, 0xA6, + 0x9D, 0xBC, 0xC7, 0xBC, 0x5A, 0x2E, 0x98, 0x28, + 0x69, 0x83, 0x67, 0x85, 0x1A, 0xB8, 0xD8, 0xDA, + 0x75, 0x4D, 0xBC, 0xF2, 0x71, 0x7C, 0xE2, 0x44, + 0x2B, 0x81, 0x78, 0x09, 0xD5, 0xE2, 0xC5, 0x41, + 0xFC, 0xBF, 0x68, 0x82, 0x71, 0x6B, 0xFC, 0xCA, + 0x95, 0xB9, 0x37, 0x34, 0x26, 0x4C, 0x30, 0x7C + }, + { + 0x6D, 0xAA, 0x59, 0x4C, 0x6C, 0xCB, 0xBA, 0x84, + 0x02, 0x85, 0xA1, 0x2A, 0x32, 0x71, 0xF8, 0x7D, + 0xF6, 0xD0, 0xE3, 0x8E, 0x83, 0xB5, 0x9A, 0x09, + 0xB2, 0xAF, 0x49, 0x13, 0x9E, 0xBD, 0x57, 0xBB, + 0x8F, 0x0C, 0x59, 0x8A, 0x5C, 0x79, 0xFB, 0x5E, + 0x3E, 0xB8, 0xE0, 0xB2, 0x42, 0xFA, 0x11, 0x02, + 0x27, 0x33, 0x22, 0x03, 0xC5, 0xB2, 0xFF, 0x0F, + 0x4B, 0x82, 0x16, 0x1A, 0xD6, 0x56, 0x6B, 0x09 + }, + { + 0x8C, 0xB5, 0x95, 0x94, 0x34, 0xD8, 0x5F, 0x96, + 0x35, 0x6D, 0xBE, 0x76, 0xBA, 0x09, 0xCF, 0xFF, + 0xFD, 0xF7, 0xD9, 0x68, 0xF3, 0x15, 0x19, 0x53, + 0x7E, 0x5E, 0x58, 0x98, 0x61, 0x72, 0xE4, 0xA6, + 0x97, 0x09, 0x46, 0xA3, 0xF3, 0x5F, 0x38, 0x9C, + 0xE6, 0x62, 0x91, 0x5A, 0x46, 0x0B, 0xAD, 0x3B, + 0x61, 0x17, 0xDF, 0x72, 0xC3, 0x82, 0x9D, 0x2C, + 0x35, 0x6A, 0xEC, 0xE9, 0x5E, 0x9F, 0x10, 0x0C + }, + { + 0x2C, 0xC9, 0x38, 0x57, 0xBD, 0x9C, 0x0E, 0x1C, + 0xC3, 0xE5, 0xA4, 0x3E, 0xF8, 0x25, 0x10, 0xB9, + 0xF4, 0x48, 0x36, 0xD8, 0x73, 0x25, 0xC2, 0x49, + 0xF7, 0x5B, 0xFD, 0xFD, 0x84, 0x4E, 0xE8, 0x51, + 0xD0, 0x57, 0xCB, 0x50, 0xA2, 0x0E, 0x58, 0xB9, + 0x81, 0x53, 0x58, 0x63, 0xF6, 0x80, 0x62, 0x84, + 0x18, 0x1C, 0xC7, 0xC2, 0xF2, 0xD7, 0xD2, 0xCF, + 0x13, 0xCA, 0x74, 0xC6, 0x43, 0xDE, 0xE2, 0xD1 + }, + { + 0xF2, 0x20, 0xA9, 0xA7, 0xC3, 0x94, 0x3B, 0x8F, + 0x69, 0x60, 0x70, 0x7C, 0x87, 0x7E, 0x5A, 0xA3, + 0x74, 0x6F, 0xBA, 0xAC, 0x12, 0xFB, 0x7C, 0xBD, + 0x02, 0xAC, 0x4D, 0x54, 0x3B, 0x93, 0x9C, 0x20, + 0xE6, 0xC3, 0x20, 0x32, 0x16, 0x79, 0x3F, 0x48, + 0x18, 0x16, 0xE2, 0x4B, 0x84, 0x01, 0x30, 0xC7, + 0x6E, 0x50, 0xBC, 0xB3, 0x4C, 0xD5, 0xB6, 0xFA, + 0x57, 0x6F, 0x5E, 0x6D, 0x30, 0x53, 0x39, 0x14 + }, + { + 0xBF, 0x2C, 0x9A, 0xF7, 0xC5, 0x17, 0xF4, 0x6B, + 0x4E, 0x6A, 0x66, 0x11, 0xC7, 0x69, 0x04, 0x93, + 0x2C, 0x02, 0x82, 0x65, 0x34, 0x9C, 0xDA, 0x0B, + 0x03, 0x3E, 0x4D, 0x6D, 0x39, 0x5E, 0x43, 0x30, + 0xF4, 0x6E, 0x3A, 0xED, 0x37, 0x1E, 0x28, 0x47, + 0xD5, 0x40, 0xB1, 0x4E, 0x7A, 0x18, 0x34, 0x81, + 0x2C, 0xAF, 0x65, 0xE6, 0xC6, 0xCC, 0xD3, 0xFE, + 0xB1, 0xDF, 0xAC, 0xCB, 0xF2, 0x3A, 0xD1, 0xD2 + }, + { + 0x0B, 0x45, 0xCE, 0xB5, 0xE7, 0xD0, 0x5F, 0x3B, + 0x9F, 0x35, 0xF7, 0x19, 0x71, 0x47, 0x35, 0x14, + 0x84, 0x0D, 0x61, 0x7C, 0x19, 0x8C, 0xBC, 0x27, + 0xAB, 0x50, 0x29, 0xA0, 0x25, 0x08, 0xB6, 0x6D, + 0xF6, 0xD0, 0x17, 0xF2, 0xC9, 0x82, 0x5F, 0x18, + 0xDD, 0x04, 0x43, 0x60, 0x07, 0x87, 0x02, 0xCF, + 0xBD, 0xED, 0x7F, 0xAC, 0x53, 0x38, 0x4B, 0xC6, + 0x1D, 0x0B, 0x54, 0x35, 0xD9, 0x06, 0xEB, 0xFD + }, + { + 0x61, 0x1E, 0x23, 0xE3, 0x2F, 0x47, 0x15, 0x22, + 0x07, 0xF9, 0x68, 0x4E, 0xB9, 0x52, 0xEF, 0x12, + 0x9F, 0x48, 0xB4, 0xC3, 0x1D, 0x42, 0xD5, 0x62, + 0xEE, 0x0F, 0x7C, 0x9C, 0x15, 0xC0, 0x9F, 0xAB, + 0x35, 0xA7, 0x22, 0xBA, 0x16, 0x36, 0x89, 0x8A, + 0xA2, 0xBD, 0x6E, 0x02, 0x54, 0x08, 0x37, 0xD4, + 0x63, 0xFB, 0x0E, 0xC0, 0x1F, 0x9A, 0x77, 0x42, + 0x3B, 0x4B, 0x2D, 0x6A, 0x02, 0x02, 0x3C, 0xCD + }, + { + 0xD5, 0x46, 0xFF, 0x9C, 0x41, 0x2B, 0x31, 0xA4, + 0xEF, 0x97, 0x33, 0xBA, 0x3B, 0x38, 0xC1, 0xD8, + 0x5C, 0xAA, 0x22, 0x05, 0x16, 0xC5, 0x2B, 0x1D, + 0x70, 0xA1, 0xB3, 0x58, 0x4F, 0x76, 0xE9, 0x8E, + 0xA4, 0x52, 0x19, 0x4F, 0xE1, 0x9A, 0x2D, 0xB1, + 0xB9, 0xD0, 0x75, 0xC2, 0x61, 0xBC, 0xF1, 0x97, + 0xE6, 0x50, 0xC6, 0x1F, 0x33, 0xEB, 0x2F, 0x4E, + 0x0F, 0xD6, 0x97, 0xE0, 0xD6, 0xA6, 0x1D, 0x8F + }, + { + 0xD7, 0x0D, 0x99, 0x96, 0x7C, 0xBC, 0x27, 0xF5, + 0xB5, 0xF4, 0x5F, 0x74, 0x7F, 0xA4, 0x1D, 0xDB, + 0xAE, 0xBE, 0xB3, 0xCD, 0x71, 0x98, 0x7C, 0xB5, + 0xC9, 0x47, 0x19, 0x14, 0x88, 0x5B, 0x94, 0xFB, + 0xD1, 0xC0, 0xD1, 0x25, 0x5B, 0x6D, 0x5D, 0xB4, + 0x96, 0xDD, 0x7A, 0xD0, 0x4F, 0x39, 0xF6, 0xAD, + 0x22, 0xD5, 0xC9, 0xD1, 0x57, 0x84, 0xAF, 0xED, + 0xB0, 0xAA, 0x4C, 0x10, 0x3F, 0xE7, 0x8C, 0x1A + }, + { + 0x02, 0xD2, 0xCB, 0x6C, 0xE8, 0xFB, 0x70, 0x25, + 0xBE, 0xA7, 0xF4, 0xBA, 0x75, 0x70, 0xF9, 0x96, + 0x06, 0x18, 0x83, 0xB7, 0xBB, 0xCF, 0x1C, 0xC0, + 0x37, 0x7F, 0xA2, 0xA6, 0x6B, 0x5B, 0x52, 0x14, + 0x7E, 0x48, 0x6E, 0x45, 0xA7, 0x57, 0xE4, 0x77, + 0xDB, 0x6F, 0x1A, 0xDF, 0xBE, 0x7E, 0xBD, 0xB2, + 0x51, 0xE2, 0xA0, 0x9F, 0x5A, 0xB6, 0xEF, 0xB0, + 0x42, 0xA0, 0xC7, 0x58, 0xDE, 0x49, 0x75, 0xC2 + }, + { + 0xA9, 0x1C, 0x0E, 0xAF, 0xF3, 0xCC, 0x35, 0x80, + 0xB6, 0xCF, 0x98, 0x7C, 0x53, 0x10, 0x78, 0x34, + 0xB6, 0xA6, 0x21, 0x59, 0xD1, 0x61, 0x46, 0x94, + 0x0A, 0xEC, 0xBF, 0x00, 0x2F, 0x3B, 0x36, 0xA6, + 0x2C, 0x64, 0x97, 0x49, 0x70, 0x52, 0x9D, 0xBE, + 0x3A, 0x9B, 0x3E, 0xD7, 0x2A, 0x7C, 0x48, 0x63, + 0xD4, 0x02, 0x9B, 0x56, 0x28, 0x01, 0x39, 0x3F, + 0xCC, 0xAB, 0x55, 0xCC, 0x2B, 0x2E, 0xB5, 0xF1 + }, + { + 0x37, 0xF6, 0x95, 0x66, 0x65, 0xED, 0x33, 0xC8, + 0x83, 0x37, 0xCA, 0x5D, 0x88, 0xAB, 0xFF, 0x23, + 0x33, 0x21, 0x2B, 0x56, 0xF1, 0x79, 0xEF, 0xC7, + 0x9B, 0xA4, 0xFB, 0x99, 0x71, 0xA1, 0x73, 0x31, + 0x3C, 0xCD, 0x08, 0x6E, 0x9B, 0xCC, 0xAC, 0xC0, + 0x00, 0x0D, 0x01, 0xE0, 0x49, 0x49, 0xCA, 0x5D, + 0x11, 0xB5, 0x8B, 0xF4, 0x07, 0x03, 0xD6, 0x4D, + 0x0C, 0x08, 0x76, 0x7C, 0xEE, 0x82, 0x58, 0xD5 + }, + { + 0x21, 0x42, 0x11, 0x10, 0x66, 0x04, 0xB5, 0x29, + 0x32, 0x75, 0xC4, 0xB7, 0xC1, 0x5D, 0x8F, 0x12, + 0x70, 0x4B, 0xC5, 0x1A, 0x28, 0x38, 0x7F, 0xB4, + 0x64, 0x1B, 0xD3, 0x49, 0xF0, 0x10, 0x13, 0xD3, + 0x4D, 0xCD, 0x9F, 0x1E, 0x16, 0x01, 0x62, 0xBE, + 0x29, 0xAE, 0x8B, 0x58, 0x2F, 0x2D, 0xD9, 0x0B, + 0xBA, 0x7C, 0x48, 0x31, 0x53, 0xE3, 0x2A, 0x48, + 0x7B, 0xFB, 0x73, 0x82, 0x1E, 0x93, 0x1C, 0x89 + }, + { + 0x98, 0xD9, 0xC4, 0xC6, 0xC8, 0x4E, 0x94, 0x03, + 0x49, 0x57, 0x6D, 0x24, 0xE3, 0xAA, 0x20, 0x22, + 0x09, 0x35, 0x41, 0xFD, 0xD6, 0xA4, 0xB8, 0x47, + 0x4F, 0x53, 0xE8, 0x8A, 0x13, 0x57, 0xEA, 0x06, + 0x87, 0x4A, 0xED, 0x65, 0xAB, 0x2F, 0x69, 0x21, + 0x15, 0x6B, 0x08, 0x47, 0x98, 0x96, 0x8B, 0xB5, + 0x69, 0x03, 0x18, 0x90, 0x2A, 0x41, 0x32, 0xA5, + 0x35, 0x77, 0x34, 0xB2, 0x22, 0x3F, 0x5E, 0x53 + }, + { + 0x87, 0x2B, 0x40, 0xA3, 0x55, 0x93, 0x31, 0xA5, + 0xF9, 0xCF, 0xFE, 0x11, 0xF8, 0xB5, 0x66, 0x46, + 0x40, 0x96, 0xEF, 0x68, 0xBE, 0x43, 0x14, 0xC0, + 0xBD, 0x7F, 0x43, 0x89, 0xB1, 0xA9, 0xDA, 0x98, + 0xFB, 0xC8, 0x9A, 0x1A, 0xDC, 0x28, 0xF2, 0x03, + 0xB4, 0xE5, 0xE5, 0xC7, 0x8F, 0x12, 0xFC, 0x65, + 0x21, 0x5C, 0xAD, 0x0D, 0xD2, 0x90, 0xF3, 0x53, + 0xA7, 0xF8, 0xF1, 0xD6, 0x2E, 0x26, 0xC6, 0x6F + }, + { + 0x8C, 0x09, 0x40, 0x1F, 0x69, 0xAE, 0x92, 0xF9, + 0x83, 0x6E, 0x38, 0xF1, 0x49, 0x5A, 0x8F, 0x4A, + 0x53, 0x5C, 0x75, 0xB5, 0xB2, 0x32, 0x28, 0x63, + 0x29, 0x6C, 0x20, 0xA7, 0x62, 0x9A, 0xE8, 0x6C, + 0x5D, 0x4A, 0xCF, 0x28, 0x85, 0x24, 0x71, 0x51, + 0x7F, 0xDD, 0xF5, 0x35, 0x2C, 0x66, 0x70, 0x32, + 0x69, 0x00, 0x58, 0xAD, 0x0A, 0xED, 0x0E, 0x24, + 0x9F, 0x21, 0x43, 0xC3, 0xCF, 0x9E, 0xC2, 0x28 + }, + { + 0xAD, 0x7B, 0xC0, 0xE3, 0xCA, 0x0E, 0xFD, 0xAB, + 0xC3, 0xD3, 0x24, 0x8A, 0x13, 0x40, 0x93, 0x45, + 0xA9, 0x03, 0x34, 0xDA, 0xE9, 0x63, 0x3C, 0xF2, + 0x58, 0x2D, 0xB5, 0x61, 0x7F, 0xF3, 0x5E, 0xD4, + 0xCD, 0x0E, 0x34, 0x79, 0x30, 0x02, 0xD4, 0xFF, + 0x60, 0x3C, 0x12, 0x49, 0x5B, 0xF2, 0xE3, 0xB3, + 0xEB, 0xE4, 0x67, 0x45, 0xDC, 0xCD, 0x58, 0x74, + 0x99, 0x79, 0x70, 0x90, 0x73, 0x21, 0x66, 0xF0 + }, + { + 0x50, 0xE8, 0x27, 0xB8, 0x98, 0xA2, 0xCB, 0xE4, + 0x46, 0x97, 0x99, 0x6B, 0xA9, 0x5E, 0x10, 0x15, + 0xE8, 0xC3, 0xDB, 0xAF, 0xCE, 0x99, 0xB2, 0x2E, + 0xD8, 0x9D, 0xB4, 0xB3, 0x36, 0x3A, 0x34, 0x64, + 0x69, 0xC2, 0x54, 0x7D, 0xB5, 0xB5, 0x41, 0xA5, + 0xB6, 0xEF, 0x82, 0xF0, 0x93, 0xA6, 0x97, 0x02, + 0x04, 0x84, 0x57, 0xE6, 0x1F, 0xFE, 0x75, 0x99, + 0x7A, 0xAD, 0x18, 0x0F, 0xAB, 0x5B, 0xD1, 0x08 + }, + { + 0x66, 0x53, 0x89, 0x48, 0x31, 0x97, 0x2C, 0xA3, + 0xF8, 0x31, 0x1C, 0x90, 0xAE, 0xC4, 0x5E, 0x82, + 0xAF, 0xC4, 0x76, 0xD0, 0x86, 0x89, 0xA9, 0xE5, + 0xEF, 0x04, 0x14, 0x62, 0x68, 0x24, 0x71, 0xDE, + 0x62, 0x4E, 0xF9, 0x57, 0xB5, 0xFD, 0x34, 0x1B, + 0x2D, 0x1B, 0x37, 0x26, 0xAD, 0x57, 0xFE, 0x01, + 0x4F, 0x71, 0xFA, 0xD3, 0x18, 0xDE, 0x9B, 0x67, + 0xE9, 0x2B, 0x55, 0x85, 0x1A, 0x90, 0x7D, 0xF4 + }, + { + 0x3A, 0x49, 0x2E, 0x85, 0xBF, 0xDB, 0xF5, 0x74, + 0x9E, 0x67, 0xA8, 0x80, 0x1E, 0xFC, 0x74, 0x4C, + 0x29, 0x48, 0xE4, 0x1E, 0xC3, 0x73, 0xB3, 0x36, + 0x77, 0x2D, 0x3B, 0x00, 0x28, 0xD9, 0x75, 0x3E, + 0x71, 0x53, 0x19, 0x0C, 0x77, 0x8C, 0x25, 0x99, + 0x2B, 0x0A, 0x9F, 0x04, 0xFA, 0x50, 0xF0, 0xDB, + 0x77, 0x87, 0xC8, 0x4C, 0xE6, 0xF7, 0x19, 0xEE, + 0x51, 0x1E, 0x53, 0x5E, 0x7D, 0x1B, 0xA1, 0x8B + }, + { + 0xB3, 0x35, 0x90, 0xC2, 0x99, 0x57, 0xF3, 0x60, + 0xD9, 0x95, 0x34, 0xAD, 0x97, 0x7B, 0xBB, 0xA2, + 0xF0, 0xF0, 0x40, 0x65, 0x6C, 0x8A, 0xAB, 0xAF, + 0x92, 0x83, 0x73, 0x55, 0x2D, 0x38, 0x1D, 0xA8, + 0x10, 0x7D, 0x3B, 0x60, 0xE8, 0xD4, 0xA1, 0xC4, + 0x6B, 0xE8, 0xBA, 0x80, 0x5A, 0xCE, 0x1A, 0x00, + 0x84, 0x27, 0xD2, 0x51, 0x0D, 0x3F, 0x53, 0x74, + 0x79, 0x3B, 0x9D, 0x4C, 0x4B, 0x92, 0x0F, 0xA5 + }, + { + 0x5D, 0x80, 0x74, 0xF1, 0x57, 0xBD, 0x48, 0x9F, + 0xEF, 0x6F, 0xD7, 0xE9, 0xAB, 0x74, 0x4A, 0x54, + 0xD5, 0x73, 0xE5, 0x87, 0x76, 0xAB, 0x2A, 0x6E, + 0x36, 0x4E, 0x92, 0x4E, 0xD2, 0xF7, 0xB6, 0xDF, + 0x26, 0x42, 0xF1, 0x67, 0xEB, 0x05, 0x4A, 0x5A, + 0x11, 0x99, 0x22, 0x87, 0x5F, 0x06, 0x7E, 0x69, + 0x42, 0xF4, 0xC1, 0xFA, 0x9D, 0xA4, 0x56, 0xA8, + 0x82, 0x7E, 0x5B, 0x58, 0xAF, 0x9E, 0x4A, 0x44 + }, + { + 0xE7, 0x6D, 0xD9, 0xC3, 0x97, 0x01, 0x2B, 0x10, + 0x76, 0x61, 0x41, 0xB9, 0x71, 0x1C, 0x2A, 0x26, + 0x28, 0xD0, 0x4D, 0x00, 0xBB, 0xFA, 0x83, 0xE3, + 0xC8, 0x83, 0xB5, 0x9B, 0x21, 0xEB, 0xE0, 0x18, + 0x07, 0x97, 0x45, 0x32, 0xED, 0x42, 0x3B, 0xF8, + 0xC0, 0x0A, 0x12, 0x22, 0x11, 0xC5, 0xC7, 0x46, + 0xE8, 0x8D, 0x2B, 0xE8, 0x7F, 0x90, 0x43, 0xE7, + 0x60, 0x8E, 0xA4, 0xE1, 0x55, 0x00, 0xD7, 0x98 + }, + { + 0xC1, 0xC9, 0x70, 0x1D, 0x2D, 0xAF, 0x8C, 0xEB, + 0x66, 0x69, 0x57, 0x34, 0x03, 0xE1, 0xBD, 0xF9, + 0x04, 0x63, 0x26, 0x61, 0x7C, 0x08, 0xCE, 0x4D, + 0x7C, 0xE4, 0x4E, 0xF0, 0x57, 0xA2, 0xE8, 0x7C, + 0x09, 0xC1, 0xC3, 0x7B, 0x49, 0x3E, 0x35, 0x41, + 0xAB, 0x85, 0xC9, 0x1F, 0x83, 0xCD, 0x09, 0xFD, + 0x77, 0xD4, 0x26, 0xE4, 0x14, 0xB5, 0x59, 0xAC, + 0xD3, 0xBA, 0xBD, 0x9A, 0xD6, 0x41, 0x5A, 0x2E + }, + { + 0xD7, 0x4E, 0x97, 0x52, 0xAB, 0xF1, 0xC2, 0x33, + 0x5F, 0x3A, 0x1B, 0x74, 0x4F, 0xF2, 0xBC, 0x54, + 0xAB, 0x09, 0xB8, 0xCC, 0x0C, 0x9A, 0xBB, 0x0F, + 0xC8, 0x9A, 0xBA, 0x17, 0x85, 0x96, 0xC8, 0x55, + 0x08, 0x0C, 0xEA, 0x01, 0xBB, 0xA4, 0xF6, 0x45, + 0x2B, 0x3B, 0x6D, 0x47, 0x7E, 0x65, 0x5F, 0xC4, + 0x97, 0x0F, 0xBC, 0x41, 0x75, 0xA8, 0x39, 0x9B, + 0xDB, 0x92, 0x20, 0x54, 0x57, 0x14, 0x44, 0x15 + }, + { + 0xD9, 0x4A, 0x24, 0xE0, 0xB7, 0xC1, 0xD9, 0x4F, + 0x9A, 0x66, 0x17, 0x41, 0xFB, 0x56, 0x1F, 0x8D, + 0xF3, 0x0C, 0x4F, 0x33, 0x93, 0x21, 0x4B, 0xE1, + 0x52, 0x36, 0xC6, 0x95, 0x48, 0x48, 0xEA, 0xD4, + 0xC1, 0x2E, 0xF2, 0xCA, 0x88, 0x16, 0x64, 0xF2, + 0x10, 0x2E, 0xCB, 0xA4, 0x91, 0xFB, 0x07, 0x20, + 0xD2, 0xD7, 0xFC, 0xB3, 0xE3, 0x9D, 0x41, 0x96, + 0xC0, 0x17, 0x40, 0xFA, 0xE3, 0x41, 0xEE, 0x7E + }, + { + 0xF6, 0xED, 0xE6, 0xAB, 0x2D, 0x5E, 0xF4, 0x82, + 0x0F, 0xB5, 0x96, 0x67, 0x21, 0x8B, 0xAE, 0xC4, + 0x51, 0x84, 0x51, 0xFD, 0x12, 0xF4, 0x6B, 0x2A, + 0x5D, 0x5A, 0x8A, 0x59, 0x1C, 0x7F, 0x94, 0x39, + 0x97, 0x4B, 0x96, 0xA7, 0xC4, 0x95, 0xD7, 0xA8, + 0xBD, 0xB1, 0x60, 0x32, 0x26, 0xAF, 0xEA, 0x90, + 0x49, 0x9E, 0xA6, 0x21, 0xD3, 0x24, 0xA1, 0xA1, + 0xBB, 0x9E, 0x42, 0x54, 0x9C, 0x57, 0x5E, 0x9B + }, + { + 0xDF, 0xA8, 0xEE, 0x62, 0xEE, 0x60, 0xE5, 0x7D, + 0x8C, 0xA2, 0x62, 0xAB, 0x11, 0x51, 0xF0, 0x2B, + 0xB0, 0x70, 0x42, 0xEF, 0x95, 0x4D, 0xDC, 0xD6, + 0xDA, 0x81, 0x98, 0x7F, 0xB8, 0x80, 0xB6, 0x3C, + 0x9A, 0x72, 0xD9, 0x93, 0x02, 0x3B, 0x5C, 0x0F, + 0x39, 0x10, 0x5B, 0x84, 0x6B, 0x1C, 0x62, 0x81, + 0x4A, 0x6E, 0x48, 0xE9, 0x17, 0xFA, 0xB7, 0x31, + 0x7B, 0x6C, 0xE8, 0x0D, 0x84, 0x1C, 0x36, 0x48 + }, + { + 0xC8, 0xED, 0x9C, 0x48, 0xA4, 0x71, 0xA4, 0x83, + 0xED, 0xE3, 0x37, 0x54, 0xB2, 0xC5, 0x5A, 0xE6, + 0x6F, 0x28, 0x3F, 0x23, 0x9F, 0xFE, 0x03, 0xBE, + 0xEE, 0x4D, 0x98, 0x7E, 0x95, 0xB4, 0x56, 0xE9, + 0x39, 0xB5, 0x05, 0xCA, 0xBE, 0x4A, 0x18, 0x10, + 0x1D, 0x1A, 0xFC, 0xD0, 0xC4, 0x32, 0x62, 0x10, + 0x50, 0xF5, 0x7B, 0xD4, 0xBF, 0xDF, 0xF2, 0x86, + 0xD7, 0x63, 0xB3, 0x03, 0x8B, 0x66, 0x43, 0x50 + }, + { + 0x40, 0xA8, 0xEE, 0x6C, 0x9D, 0xED, 0x5B, 0x1C, + 0xAA, 0x3D, 0xEB, 0xF2, 0x48, 0x27, 0xE7, 0xD9, + 0x72, 0x30, 0x02, 0x91, 0x73, 0x78, 0x52, 0x29, + 0x3C, 0xC0, 0x6D, 0xC1, 0xC3, 0x09, 0xFC, 0x6A, + 0xF3, 0x35, 0x6E, 0x2B, 0x22, 0x83, 0x67, 0x35, + 0x48, 0x84, 0x47, 0x4F, 0xFD, 0xCA, 0xF5, 0xD9, + 0xAF, 0x67, 0x04, 0x8B, 0x4C, 0x88, 0x38, 0xEB, + 0xF5, 0xD3, 0xE2, 0x58, 0x4B, 0x12, 0x99, 0x17 + }, + { + 0xC2, 0xE9, 0xC6, 0xD4, 0x8B, 0xA0, 0x97, 0xA0, + 0x76, 0xFE, 0xE9, 0xE4, 0xEC, 0x1A, 0x43, 0xC1, + 0x55, 0x0E, 0xEF, 0x4B, 0x85, 0xD2, 0x27, 0xB9, + 0x70, 0x6E, 0x8D, 0xF6, 0x79, 0x5B, 0xCE, 0x70, + 0xC3, 0x4F, 0x28, 0x45, 0x9F, 0x04, 0xB0, 0x0E, + 0x00, 0x28, 0x9C, 0x7F, 0x02, 0x9D, 0xF4, 0xFE, + 0x9F, 0xE3, 0x15, 0x6E, 0x97, 0x7D, 0xA3, 0x3F, + 0x9D, 0x9C, 0xC3, 0x0A, 0x0A, 0x74, 0xF3, 0xC2 + }, + { + 0x8D, 0x4E, 0x1D, 0x82, 0x1C, 0xA6, 0xE9, 0xDA, + 0x85, 0x87, 0x8B, 0x17, 0xB8, 0x33, 0x67, 0x4F, + 0x25, 0xCC, 0x5C, 0x79, 0xC1, 0x6C, 0x9A, 0x2B, + 0x1D, 0x0A, 0x1C, 0x89, 0x6A, 0x06, 0x1B, 0x29, + 0xBB, 0x75, 0x75, 0x85, 0xC6, 0x7D, 0x33, 0xA9, + 0x14, 0xC2, 0xB9, 0x29, 0x4B, 0x0A, 0x0A, 0xD5, + 0x3A, 0x51, 0x5D, 0x15, 0xCD, 0x7B, 0xFC, 0x82, + 0xE0, 0xEB, 0x5B, 0x95, 0x9F, 0xFB, 0xF6, 0x2A + }, + { + 0xC1, 0xA3, 0x4A, 0x09, 0x17, 0xC5, 0xC1, 0xC2, + 0xF7, 0x9F, 0xAA, 0x50, 0xBD, 0x1A, 0x33, 0x7D, + 0x44, 0x8B, 0xBF, 0x54, 0xB2, 0x40, 0x50, 0x69, + 0x3E, 0x30, 0xDF, 0xA0, 0xB6, 0x00, 0x2F, 0xBB, + 0x00, 0x82, 0x63, 0x06, 0xAA, 0xE8, 0xAA, 0x95, + 0xE7, 0x92, 0x11, 0x4E, 0x5A, 0x58, 0x87, 0x86, + 0xEA, 0x90, 0xC9, 0x2E, 0x72, 0x7B, 0x14, 0xFD, + 0xC9, 0xBD, 0x49, 0xF2, 0x3D, 0xBB, 0xCC, 0x74 + }, + { + 0xBC, 0x8C, 0xAB, 0x81, 0xC3, 0x01, 0xA0, 0xE2, + 0x81, 0x74, 0xEC, 0xEC, 0x44, 0x16, 0x00, 0x74, + 0xA9, 0x2B, 0xB7, 0x7D, 0xE4, 0x16, 0xAE, 0xC8, + 0x8B, 0x92, 0x03, 0xF3, 0x32, 0x1B, 0x64, 0x9B, + 0x56, 0xAE, 0xAE, 0x0A, 0x2B, 0xF8, 0x42, 0xA8, + 0x3B, 0x59, 0x44, 0xE4, 0x6A, 0xAF, 0x1E, 0x2C, + 0x56, 0xCF, 0xBD, 0xCF, 0xC6, 0x92, 0x7A, 0x81, + 0xD8, 0xB6, 0xB5, 0x1B, 0xED, 0x61, 0xDA, 0x71 + }, + { + 0xBE, 0xC9, 0xD9, 0x39, 0xF3, 0x7F, 0xDE, 0x38, + 0xC1, 0x7F, 0x35, 0x7D, 0x24, 0x5F, 0xEF, 0xDE, + 0x23, 0x64, 0x31, 0x46, 0x27, 0x45, 0x31, 0x5B, + 0xD5, 0xE4, 0xC1, 0x62, 0xC1, 0x80, 0xD7, 0x12, + 0x5E, 0xB4, 0xD6, 0xDF, 0x95, 0xE2, 0x8A, 0xAB, + 0x92, 0x70, 0x54, 0x00, 0xB4, 0xB0, 0x66, 0x91, + 0xBC, 0x55, 0x35, 0x52, 0x42, 0x28, 0x5C, 0x51, + 0xB7, 0x28, 0xD8, 0x55, 0x95, 0x2E, 0x63, 0xF2 + }, + { + 0x42, 0xC7, 0x2A, 0x64, 0x12, 0x24, 0x5A, 0x73, + 0xDA, 0x0F, 0xAE, 0xBD, 0x7D, 0xA5, 0x88, 0xE2, + 0xE5, 0xD9, 0x05, 0xA8, 0x30, 0xFE, 0x16, 0xC3, + 0xA3, 0xB0, 0xFC, 0xFE, 0x1D, 0x4A, 0xB8, 0xA2, + 0xE0, 0x43, 0xA6, 0x14, 0x42, 0x33, 0x3E, 0x95, + 0x0A, 0x82, 0xAC, 0xBE, 0x4C, 0xF9, 0x46, 0x93, + 0xDD, 0x8F, 0x2D, 0xD9, 0x35, 0x85, 0xCB, 0x7E, + 0x53, 0x1F, 0x75, 0x2C, 0x58, 0x5E, 0x5C, 0xD1 + }, + { + 0x1E, 0xA3, 0x29, 0x9D, 0x5D, 0x66, 0x7C, 0x37, + 0x95, 0xF1, 0x1A, 0xE7, 0x0C, 0xCA, 0x73, 0x30, + 0xC8, 0xEC, 0x54, 0x40, 0x91, 0xB2, 0x44, 0xCA, + 0x9C, 0x26, 0x8D, 0xC5, 0x25, 0x6E, 0xBF, 0x9F, + 0x1E, 0x25, 0x9E, 0xBA, 0x4B, 0x2F, 0xB9, 0x46, + 0x24, 0x36, 0x22, 0x41, 0xEE, 0x80, 0x3E, 0xF7, + 0x6A, 0xEC, 0xA0, 0x9B, 0xC6, 0x28, 0x64, 0x4E, + 0x81, 0x41, 0xA2, 0xF0, 0xC6, 0xFB, 0x56, 0x58 + }, + { + 0x4C, 0x05, 0x90, 0xD0, 0x3C, 0x45, 0xAA, 0x12, + 0xC8, 0x81, 0xC9, 0x17, 0x95, 0x37, 0x3A, 0x06, + 0xC2, 0x9B, 0x1B, 0x55, 0x52, 0x67, 0x1D, 0x83, + 0x59, 0x8C, 0x2B, 0xFC, 0x5B, 0x87, 0xA5, 0x7C, + 0xD7, 0x55, 0xCF, 0xC0, 0x43, 0x65, 0x6A, 0x83, + 0x87, 0xD1, 0xD5, 0x1C, 0x1A, 0x42, 0x53, 0x59, + 0xD1, 0x88, 0x6A, 0x4B, 0xFF, 0x91, 0xA7, 0x7E, + 0x0E, 0xB4, 0x41, 0xD4, 0xDC, 0x5F, 0x15, 0x56 + }, + { + 0x21, 0xD0, 0x0D, 0x77, 0x1C, 0xBF, 0x57, 0xA4, + 0xAD, 0xF3, 0xEE, 0x5F, 0xFB, 0xC9, 0xB6, 0x05, + 0xED, 0x4B, 0x06, 0xE6, 0xB3, 0x4A, 0x96, 0x56, + 0xC0, 0xFB, 0xE6, 0xB0, 0xAC, 0x09, 0x08, 0x87, + 0xA5, 0x23, 0xD2, 0x73, 0x7D, 0xAB, 0xA7, 0x6D, + 0xD3, 0x46, 0x77, 0x27, 0x46, 0x4F, 0xF0, 0x06, + 0xD3, 0x47, 0x03, 0x46, 0xD3, 0xDE, 0x9D, 0x28, + 0x11, 0x4F, 0x57, 0x41, 0x89, 0xB1, 0x7C, 0xBC + }, + { + 0x8C, 0x66, 0xEB, 0x04, 0x8D, 0x65, 0x2E, 0x03, + 0x4E, 0xAA, 0x35, 0xDC, 0xF8, 0xE5, 0x14, 0x84, + 0x3E, 0x9C, 0x28, 0x9C, 0x7C, 0xF4, 0xAE, 0xEA, + 0xA8, 0x34, 0xA7, 0xB3, 0x8E, 0xBD, 0x23, 0xA9, + 0xED, 0xF7, 0x39, 0x29, 0xC1, 0xA2, 0x9B, 0xC7, + 0x97, 0x9C, 0x39, 0x45, 0x02, 0x3F, 0x01, 0xE0, + 0x59, 0x12, 0x84, 0xE0, 0x86, 0x00, 0xF2, 0x95, + 0x25, 0xE0, 0x09, 0x4A, 0xE2, 0x4A, 0xA4, 0x94 + }, + { + 0x7B, 0x59, 0xB0, 0xA8, 0x62, 0x5C, 0x39, 0xE2, + 0x3B, 0xB4, 0x71, 0x7C, 0xC4, 0xCB, 0xCD, 0xB7, + 0xD8, 0x65, 0x8E, 0xE5, 0xF7, 0x65, 0xB8, 0x9E, + 0xCB, 0xA2, 0xF7, 0xF8, 0x1E, 0x40, 0x90, 0xB7, + 0x88, 0x1D, 0xE4, 0x1A, 0xB9, 0x68, 0x36, 0x04, + 0x07, 0x79, 0x5E, 0x35, 0xBA, 0x0A, 0x8B, 0xD6, + 0xD3, 0xEF, 0x3E, 0x84, 0x90, 0x46, 0x5A, 0x6D, + 0xA0, 0x66, 0x0F, 0x65, 0xD8, 0xAC, 0x88, 0x69 + }, + { + 0x5A, 0xC6, 0x11, 0x60, 0x92, 0x5F, 0xF3, 0x10, + 0x7F, 0x7E, 0xB5, 0xE6, 0xB9, 0xFB, 0x3F, 0x80, + 0x79, 0x8E, 0x17, 0x45, 0xE9, 0x6E, 0xFB, 0xC7, + 0x72, 0x38, 0x56, 0x77, 0x94, 0x37, 0xC0, 0x56, + 0xD5, 0x0C, 0x21, 0xF4, 0xEB, 0x4A, 0x16, 0x18, + 0x3B, 0x6F, 0xB4, 0x0B, 0x20, 0xD6, 0x72, 0xCA, + 0xA4, 0x4E, 0x31, 0x31, 0x31, 0xA8, 0xA7, 0x9D, + 0xD2, 0x60, 0x87, 0x80, 0x02, 0xF4, 0xEF, 0x5C + }, + { + 0x32, 0x0B, 0xC3, 0x28, 0xD8, 0xFB, 0x3E, 0xC9, + 0xF5, 0x80, 0x0C, 0x25, 0x29, 0x66, 0x3D, 0x6A, + 0x21, 0x96, 0x4D, 0xEC, 0x52, 0x22, 0x86, 0x3A, + 0x73, 0x95, 0x71, 0x0C, 0x64, 0x65, 0xD8, 0x97, + 0x17, 0x56, 0x10, 0xCB, 0x29, 0x11, 0x83, 0xA0, + 0x60, 0x6D, 0x00, 0x41, 0x7A, 0x96, 0xA5, 0x67, + 0xF3, 0xD1, 0x63, 0x04, 0x4B, 0x72, 0x77, 0xF1, + 0xF0, 0xFC, 0x18, 0xC8, 0xAE, 0x35, 0x82, 0x46 + }, + { + 0x7A, 0x02, 0xFA, 0xC5, 0x94, 0x19, 0x58, 0x3D, + 0x86, 0xA8, 0x2C, 0x3B, 0x55, 0x9B, 0xC8, 0x1E, + 0xBA, 0x11, 0x82, 0x9B, 0x03, 0x80, 0xF5, 0x11, + 0x3E, 0x4A, 0xFD, 0x3C, 0xB9, 0xFF, 0x11, 0xC3, + 0x27, 0x2B, 0x57, 0xF9, 0x5A, 0x9D, 0x1B, 0xBB, + 0x96, 0x0A, 0x5D, 0x67, 0x16, 0xA5, 0x09, 0xEB, + 0xB9, 0x4A, 0x0B, 0x80, 0x12, 0x59, 0x63, 0x1A, + 0xC9, 0x81, 0x9C, 0xC2, 0x62, 0xE5, 0x81, 0x4B + }, + { + 0x3B, 0xA4, 0x4A, 0x89, 0x22, 0x2F, 0x41, 0x0E, + 0x61, 0x27, 0x9E, 0xA2, 0xF5, 0xC7, 0xDF, 0xD4, + 0xED, 0x7F, 0x15, 0xD6, 0xEB, 0xBC, 0xFA, 0x6C, + 0x18, 0x64, 0x5E, 0xF6, 0x16, 0x0E, 0x58, 0xB1, + 0x6C, 0xC9, 0x84, 0x9E, 0x0B, 0xE7, 0xCF, 0x5D, + 0x4F, 0xED, 0x29, 0x0E, 0x35, 0x64, 0xA5, 0xE6, + 0x46, 0x93, 0xF4, 0xFD, 0x99, 0xEB, 0x54, 0xA0, + 0xFE, 0x35, 0xEB, 0xE4, 0x9C, 0x8B, 0xDA, 0x39 + }, + { + 0xD3, 0xD4, 0xFA, 0x7C, 0x3D, 0x78, 0x4E, 0x1C, + 0x2B, 0x06, 0xFC, 0x7E, 0xF3, 0xBD, 0x2E, 0xAB, + 0x94, 0xC5, 0xC3, 0x1A, 0xDB, 0x41, 0xDB, 0x32, + 0xFD, 0x5F, 0x37, 0x87, 0x76, 0x3B, 0xB2, 0x25, + 0x92, 0xDC, 0x7B, 0x10, 0x3B, 0x5B, 0x25, 0x6E, + 0x7A, 0xCB, 0xF3, 0xFB, 0x19, 0x3D, 0xE3, 0xA5, + 0xF9, 0xB8, 0xED, 0x1F, 0xAE, 0x90, 0xE9, 0xAD, + 0x58, 0x08, 0x9C, 0x11, 0x91, 0x35, 0x0F, 0xD9 + }, + { + 0x8E, 0x95, 0x11, 0x3D, 0xD6, 0xB2, 0x0B, 0xB4, + 0x86, 0xE0, 0x41, 0x72, 0x2C, 0xAF, 0xE3, 0x3F, + 0x12, 0x53, 0x8B, 0x21, 0x01, 0xAC, 0xE0, 0x88, + 0xF2, 0xB9, 0xEC, 0x7B, 0x3E, 0x27, 0xCA, 0xD2, + 0xD5, 0x90, 0xBB, 0x2C, 0xD8, 0x58, 0x20, 0xFA, + 0xE6, 0xBC, 0x8D, 0x83, 0xAB, 0x98, 0x4D, 0xC7, + 0xF5, 0x64, 0x63, 0x3E, 0x66, 0x32, 0x8D, 0x9E, + 0x15, 0x0D, 0x11, 0x49, 0xE3, 0x2D, 0x16, 0x25 + }, + { + 0xBF, 0x5E, 0xBD, 0xEE, 0x2F, 0xDE, 0xE5, 0x3A, + 0x38, 0x7B, 0xAF, 0x48, 0x7E, 0x7C, 0xBF, 0x68, + 0x37, 0xF5, 0xB2, 0x1E, 0xD4, 0xCE, 0x41, 0x2D, + 0xE2, 0xFC, 0x22, 0x94, 0xB0, 0xDF, 0xB2, 0x14, + 0x96, 0x99, 0x74, 0x1E, 0xE9, 0xCE, 0x83, 0xF6, + 0x33, 0xD7, 0x72, 0x66, 0xF8, 0x2D, 0x8C, 0x73, + 0xC1, 0x31, 0x7D, 0x39, 0x64, 0xFD, 0x45, 0x39, + 0xAD, 0x38, 0x1A, 0xAB, 0x0E, 0xBD, 0xA1, 0xC1 + }, + { + 0x60, 0x53, 0xE1, 0xB9, 0xDC, 0x85, 0xB0, 0xC7, + 0x4C, 0x4E, 0x54, 0xE0, 0xAF, 0x4F, 0xE5, 0xF3, + 0xB3, 0x7D, 0x0E, 0x75, 0x21, 0xF5, 0xD8, 0x99, + 0xF4, 0x66, 0xEF, 0x4A, 0x6F, 0x68, 0x86, 0x01, + 0x69, 0x67, 0x9D, 0x34, 0x76, 0x60, 0x49, 0x95, + 0x00, 0x7F, 0x92, 0x72, 0x15, 0x74, 0xFC, 0x9C, + 0xA6, 0x9D, 0xE0, 0x00, 0x62, 0x63, 0xEA, 0xF5, + 0xE4, 0x17, 0x08, 0x2E, 0x3C, 0x82, 0x20, 0xD1 + }, + { + 0x38, 0x05, 0xB6, 0x6F, 0xCF, 0x9C, 0x6D, 0xE5, + 0x7A, 0x43, 0x58, 0xCE, 0x8A, 0x3B, 0xEF, 0x8D, + 0x2A, 0x35, 0xD7, 0x74, 0xE3, 0x1A, 0xBC, 0x2E, + 0x55, 0xDF, 0x6A, 0x2F, 0x62, 0xFF, 0x63, 0x73, + 0xA2, 0x9C, 0x22, 0x00, 0x70, 0x08, 0xA4, 0x36, + 0x61, 0xE7, 0x24, 0xD5, 0xDD, 0x41, 0xD1, 0xE8, + 0xA7, 0x7E, 0xAE, 0x53, 0x63, 0xEA, 0xEF, 0x41, + 0xD9, 0x36, 0x18, 0x7E, 0xF9, 0x55, 0x7D, 0x80 + }, + { + 0xA3, 0x5A, 0xF9, 0x46, 0x31, 0xB4, 0xD1, 0x27, + 0xEA, 0x5A, 0xD9, 0x9C, 0x3E, 0xF4, 0xBD, 0xB4, + 0xB7, 0x86, 0x78, 0xC1, 0x47, 0xA6, 0xF0, 0x23, + 0x40, 0x86, 0x79, 0x99, 0x27, 0x68, 0x16, 0x61, + 0x97, 0xB7, 0xE7, 0xAA, 0x64, 0x20, 0x1D, 0x08, + 0xE3, 0x4B, 0x52, 0x6E, 0xA9, 0x50, 0x11, 0x08, + 0x9E, 0xC6, 0x76, 0x89, 0x3B, 0x9F, 0xEB, 0xB2, + 0x62, 0x3B, 0xC5, 0xEB, 0xFF, 0x11, 0x08, 0x39 + }, + { + 0x2F, 0x37, 0xD5, 0x50, 0x46, 0x84, 0x2B, 0x68, + 0x47, 0x02, 0xFC, 0x45, 0x04, 0xCC, 0x8C, 0x69, + 0xE1, 0x03, 0xA2, 0xCE, 0xEB, 0x43, 0x19, 0xCE, + 0xEA, 0xB4, 0x37, 0xEB, 0x9A, 0x4C, 0xB5, 0x9D, + 0xD0, 0x84, 0x3F, 0xA7, 0x55, 0xC1, 0x35, 0x78, + 0xA5, 0x96, 0x9A, 0x67, 0x7A, 0x88, 0x2B, 0x28, + 0x8E, 0x76, 0x7D, 0xBB, 0x50, 0x55, 0xB9, 0x39, + 0x8E, 0x7A, 0xF9, 0x5D, 0xD4, 0x4F, 0x77, 0xD6 + }, + { + 0x98, 0x8C, 0x46, 0xE5, 0x4F, 0x37, 0xCC, 0x8E, + 0xC6, 0x4B, 0x9A, 0x1C, 0x94, 0x5D, 0xBA, 0xD0, + 0x14, 0x4D, 0x90, 0x1B, 0xA5, 0x0A, 0x85, 0x49, + 0x56, 0xD4, 0x3B, 0x95, 0xF4, 0xFB, 0x2E, 0x46, + 0xF6, 0x7F, 0x1C, 0xC6, 0x64, 0x35, 0x3F, 0x76, + 0x46, 0xDA, 0x48, 0xAE, 0xC9, 0x6A, 0xBA, 0x98, + 0x3F, 0x09, 0x67, 0x3A, 0xF8, 0xB7, 0x94, 0x3D, + 0x5F, 0x42, 0xE8, 0x4D, 0xB0, 0xCF, 0x34, 0xD3 + }, + { + 0x14, 0xA0, 0x98, 0x44, 0x0A, 0xBF, 0x9B, 0x88, + 0x5A, 0x40, 0x23, 0x57, 0x33, 0x4A, 0xDC, 0xE1, + 0xFA, 0xF5, 0x1A, 0x20, 0x30, 0x13, 0x7A, 0xE3, + 0x88, 0xE9, 0xDD, 0x10, 0x2F, 0x87, 0x85, 0xE3, + 0x19, 0x07, 0x90, 0xC3, 0x40, 0x83, 0xC4, 0x77, + 0xA7, 0x32, 0x55, 0xD6, 0x55, 0xE2, 0xF0, 0x23, + 0x20, 0x50, 0xD2, 0x20, 0xD9, 0x87, 0x49, 0x18, + 0xA3, 0xB6, 0x2F, 0xAD, 0xDB, 0x7B, 0x8D, 0x6C + }, + { + 0x4B, 0x9C, 0x36, 0x71, 0x70, 0xE3, 0x78, 0xFA, + 0x2C, 0x55, 0xAB, 0x4A, 0xF7, 0x9E, 0xEC, 0x37, + 0x99, 0x15, 0x04, 0x9E, 0x18, 0xC8, 0xC1, 0xDF, + 0x2E, 0xB9, 0xFD, 0x46, 0x8B, 0xD3, 0xD6, 0x00, + 0xA0, 0x58, 0x21, 0xF0, 0x73, 0x6E, 0x58, 0x17, + 0x5C, 0x07, 0x6F, 0xAE, 0x93, 0x76, 0x9F, 0x8C, + 0x2A, 0x46, 0x3D, 0x43, 0x6C, 0x50, 0x72, 0x4E, + 0x9B, 0x50, 0xB5, 0xC1, 0x99, 0x45, 0x70, 0xF9 + }, + { + 0xFB, 0xE2, 0x0E, 0x72, 0x0A, 0x73, 0xF7, 0xE1, + 0x6E, 0x56, 0x0E, 0x14, 0xEB, 0x43, 0x89, 0x76, + 0xE9, 0xDE, 0x36, 0x72, 0x2E, 0xE6, 0x02, 0x65, + 0x12, 0x3B, 0x46, 0x98, 0xC6, 0xE2, 0x6A, 0x18, + 0xB0, 0x97, 0xBD, 0xD7, 0x2A, 0x5F, 0x0A, 0x41, + 0x3D, 0x6C, 0xB1, 0x87, 0xCA, 0x5D, 0xC2, 0x44, + 0x98, 0x6B, 0x44, 0x76, 0xCB, 0xD3, 0xE4, 0x53, + 0x98, 0x6A, 0xF3, 0x21, 0xE5, 0x4C, 0xEE, 0xD3 + }, + { + 0xEB, 0xCB, 0x33, 0x7A, 0x39, 0x23, 0x44, 0xB9, + 0xE8, 0xD3, 0x20, 0x7B, 0xF2, 0x65, 0xCF, 0x4E, + 0x0A, 0x47, 0xA9, 0xA7, 0x08, 0x4B, 0x89, 0x70, + 0xD8, 0x76, 0xF2, 0x11, 0x30, 0xC4, 0x6F, 0x2B, + 0x47, 0x54, 0x82, 0x85, 0x40, 0xA4, 0x5E, 0xF6, + 0x9C, 0xAA, 0xCA, 0x7D, 0xA0, 0x89, 0xBD, 0xFE, + 0xE5, 0xE1, 0x34, 0x5A, 0x6D, 0xCF, 0x19, 0x91, + 0x66, 0xF4, 0x56, 0x3F, 0xA8, 0xE1, 0x07, 0xC8 + }, + { + 0xFD, 0x9D, 0x83, 0xE5, 0xD0, 0x89, 0x35, 0xB7, + 0x29, 0x65, 0xB4, 0x1B, 0xE9, 0xED, 0x68, 0x7F, + 0x32, 0xBA, 0x39, 0x62, 0x3B, 0xD5, 0xE7, 0x90, + 0xCF, 0xDC, 0x3F, 0x0D, 0x45, 0xAD, 0x9C, 0xC9, + 0x8A, 0x8C, 0x71, 0x57, 0x71, 0xE9, 0x7F, 0xB6, + 0x8B, 0xF9, 0xA1, 0xD9, 0x4A, 0xDB, 0x9F, 0x54, + 0xEB, 0xE0, 0x81, 0xC1, 0xF2, 0x30, 0xDB, 0xAD, + 0x88, 0x88, 0x9D, 0x67, 0xFC, 0xE5, 0x48, 0xA2 + }, + { + 0x0B, 0xAB, 0xF7, 0x26, 0x01, 0x9A, 0x3D, 0x04, + 0xC1, 0x6D, 0xD0, 0xA4, 0x1E, 0x43, 0x22, 0x29, + 0x05, 0xE0, 0xF8, 0x41, 0xD8, 0xB3, 0xE2, 0xF8, + 0x73, 0x77, 0x68, 0x83, 0x80, 0xE8, 0x7E, 0xF5, + 0x37, 0xB1, 0xD3, 0x69, 0xD0, 0x01, 0x4A, 0xEA, + 0xEC, 0x47, 0x26, 0xF2, 0xC5, 0x0E, 0x36, 0x46, + 0xDD, 0xB5, 0x5E, 0x5E, 0xA0, 0xFD, 0xE1, 0xFA, + 0x06, 0x7D, 0x14, 0x5C, 0x30, 0x3B, 0x39, 0x77 + }, + { + 0x6F, 0xF1, 0x28, 0x42, 0x8C, 0x09, 0x4F, 0xE1, + 0xA0, 0xA4, 0x96, 0x2F, 0xDE, 0xFD, 0x30, 0xF9, + 0xC7, 0x29, 0x09, 0x12, 0x98, 0xE0, 0x59, 0xF6, + 0xDA, 0x18, 0xBA, 0x05, 0x7D, 0xBB, 0x61, 0x8E, + 0x1E, 0xBE, 0x66, 0x99, 0x3B, 0xE9, 0x80, 0x2C, + 0x0F, 0xA7, 0x64, 0xB8, 0x39, 0x89, 0xD1, 0xE5, + 0x33, 0xDE, 0xB5, 0xB4, 0x6B, 0x20, 0x1A, 0x4D, + 0x25, 0x55, 0x99, 0xBD, 0x61, 0xC7, 0x70, 0x6A + }, + { + 0x89, 0x3A, 0x9E, 0x2F, 0x43, 0x49, 0xCC, 0x60, + 0x28, 0x32, 0x24, 0x5D, 0x0A, 0x30, 0x27, 0xEB, + 0xE0, 0x47, 0x90, 0xF2, 0xA7, 0x8B, 0x03, 0x99, + 0x5F, 0x94, 0x83, 0x46, 0x71, 0xF3, 0x66, 0x92, + 0xAB, 0xC1, 0xEE, 0xEB, 0xC9, 0xBE, 0xB2, 0x7B, + 0x86, 0x15, 0xB6, 0x1E, 0x39, 0xDC, 0x23, 0x4F, + 0xC7, 0x31, 0x0C, 0x2D, 0x8C, 0x72, 0x1A, 0xB4, + 0xCA, 0xA2, 0x02, 0xF9, 0xF2, 0x93, 0x09, 0xE4 + }, + { + 0x04, 0xF8, 0xAD, 0xE7, 0x1F, 0xB4, 0xD8, 0x30, + 0x5A, 0xD9, 0xC1, 0xCD, 0x07, 0xAC, 0xCB, 0x70, + 0x32, 0x02, 0x31, 0x6F, 0xEA, 0xBA, 0xF5, 0x45, + 0xFC, 0xE4, 0xD8, 0xF3, 0x6B, 0xE9, 0x85, 0xB3, + 0x28, 0xA4, 0x33, 0xE2, 0x36, 0x1A, 0x55, 0xEF, + 0x08, 0x30, 0x2D, 0x89, 0x05, 0x0D, 0xA7, 0xEF, + 0x9F, 0xC8, 0xAF, 0x8A, 0x14, 0xA5, 0x80, 0x4F, + 0x3F, 0x1F, 0x35, 0x83, 0xEE, 0xCA, 0x3A, 0x0D + }, + { + 0xC1, 0x9C, 0xB0, 0x4A, 0x01, 0x86, 0xDE, 0xDF, + 0x8E, 0xA6, 0x64, 0xE8, 0xE6, 0x0C, 0x25, 0xEF, + 0x82, 0x2C, 0xC7, 0xAB, 0x11, 0x88, 0x71, 0xF3, + 0x60, 0x9F, 0x47, 0x2C, 0x31, 0xB5, 0xBE, 0x8F, + 0x20, 0x13, 0x5B, 0x14, 0x0A, 0x3A, 0xC9, 0xD2, + 0xA3, 0x3F, 0xD6, 0x4A, 0xEA, 0x12, 0xF0, 0x79, + 0x90, 0x26, 0x0C, 0x14, 0x62, 0x5D, 0x7E, 0x24, + 0x06, 0xCA, 0x27, 0x4A, 0xEC, 0xCB, 0x42, 0x4E + }, + { + 0x66, 0x46, 0x3A, 0x8F, 0xC5, 0x4B, 0x96, 0x86, + 0x1B, 0x40, 0x2D, 0x0B, 0x20, 0x74, 0x45, 0x7E, + 0x65, 0x1B, 0x92, 0xA9, 0xB9, 0xE8, 0x5D, 0xCF, + 0xE3, 0xFF, 0xD8, 0x31, 0x98, 0xD7, 0x05, 0xC5, + 0x96, 0x5E, 0xEF, 0x58, 0x9E, 0x20, 0x2C, 0xD3, + 0x64, 0x6E, 0xE2, 0xEE, 0x86, 0x12, 0xBE, 0xE0, + 0xC8, 0xEA, 0x7D, 0xAA, 0x63, 0xED, 0x97, 0xAE, + 0xBF, 0xB9, 0xAA, 0xCC, 0x82, 0xAB, 0x81, 0xAA + }, + { + 0x23, 0x47, 0x4A, 0x99, 0x3F, 0x64, 0x1F, 0x09, + 0x0B, 0xB7, 0x50, 0x25, 0x99, 0x74, 0xD0, 0x27, + 0x60, 0x8D, 0xA6, 0xCE, 0x84, 0xC2, 0xC3, 0xF5, + 0x84, 0x5C, 0xFD, 0x7E, 0x1E, 0x2D, 0x8A, 0x81, + 0x63, 0x7F, 0x82, 0x3B, 0x5B, 0x75, 0x5A, 0xE6, + 0x38, 0x41, 0x0A, 0x88, 0xD5, 0x1E, 0x7B, 0x29, + 0xA1, 0x44, 0xB9, 0xB6, 0x6A, 0xB7, 0x9D, 0x81, + 0xE8, 0xC2, 0x49, 0x5C, 0x4E, 0xB4, 0xB3, 0xC0 + }, + { + 0x8D, 0x58, 0x21, 0x48, 0xA4, 0x3B, 0xDD, 0x23, + 0xBF, 0x83, 0x7D, 0x69, 0x6D, 0xBC, 0x8F, 0x73, + 0x2A, 0x40, 0xF8, 0x06, 0x6D, 0x8E, 0x7E, 0x9A, + 0x7E, 0xE7, 0x04, 0xBC, 0x81, 0x82, 0x44, 0xFC, + 0xE4, 0x90, 0xB2, 0xC6, 0x8F, 0x37, 0x44, 0x55, + 0x03, 0xEC, 0x1C, 0x6F, 0xA5, 0xE5, 0xE7, 0x0A, + 0x07, 0x1D, 0xF4, 0xF9, 0x4D, 0xB0, 0xCE, 0xF0, + 0x86, 0x25, 0x0C, 0x05, 0x6E, 0x90, 0x1A, 0x8C + }, + { + 0xEA, 0x03, 0xB6, 0x51, 0xC5, 0x2C, 0x84, 0x0B, + 0xC5, 0x1B, 0xD4, 0xC4, 0x1E, 0x40, 0x1B, 0xA2, + 0x7D, 0x37, 0x9B, 0xA3, 0x1E, 0x00, 0x3F, 0x08, + 0x2A, 0x3F, 0x8D, 0x24, 0x1B, 0xC6, 0xC5, 0xEA, + 0x1B, 0x23, 0xEC, 0xCA, 0x38, 0x77, 0x87, 0x4A, + 0x18, 0xCC, 0x66, 0x8F, 0x39, 0x73, 0x62, 0xB8, + 0x91, 0xDD, 0x4E, 0x13, 0x90, 0x18, 0xBF, 0xD8, + 0xDE, 0x25, 0xA4, 0x5E, 0x32, 0x10, 0xA0, 0x41 + }, + { + 0x0E, 0x80, 0xD3, 0x4F, 0xA5, 0xE1, 0xE4, 0xA6, + 0x2D, 0xDB, 0x1D, 0x86, 0xB7, 0x69, 0x18, 0x61, + 0x32, 0xA1, 0xB8, 0x5C, 0xF1, 0x38, 0x48, 0x6A, + 0xF5, 0x9F, 0x6E, 0xFC, 0x66, 0xAE, 0xED, 0x8A, + 0x55, 0xF2, 0x92, 0xD0, 0x4D, 0x88, 0x66, 0x38, + 0xFF, 0xBD, 0xFB, 0x5C, 0x83, 0xD2, 0x4F, 0xC7, + 0x4C, 0xBE, 0x58, 0xA0, 0xCE, 0xC1, 0x29, 0xF1, + 0x2A, 0x3D, 0xC8, 0x33, 0x4E, 0xC4, 0xFA, 0x1D + }, + { + 0xFB, 0xAF, 0xEB, 0x4C, 0xF7, 0xFC, 0xAE, 0x2F, + 0x2C, 0xDC, 0x66, 0x8D, 0xD3, 0x3E, 0xE1, 0x2F, + 0x19, 0x21, 0x12, 0xBD, 0xEB, 0x39, 0xFE, 0xAA, + 0x1D, 0x8F, 0xF3, 0x4B, 0x94, 0x8A, 0x57, 0x2A, + 0x05, 0x44, 0xD0, 0xC2, 0xD1, 0x83, 0xCB, 0x2B, + 0xCE, 0x82, 0xB1, 0x24, 0xD1, 0x19, 0x04, 0x8E, + 0x17, 0x7E, 0x99, 0x61, 0xC2, 0x2A, 0xC1, 0x87, + 0xCC, 0xD3, 0x93, 0x42, 0xFF, 0x8F, 0x0E, 0xC9 + }, + { + 0xE9, 0x50, 0x6B, 0x19, 0xC6, 0x97, 0xDA, 0x6B, + 0xAE, 0x8F, 0x87, 0x8F, 0xE0, 0x4C, 0xC8, 0xC2, + 0x32, 0x8F, 0xDD, 0x0B, 0x40, 0xBB, 0xD9, 0x2C, + 0x40, 0x7D, 0x62, 0xB0, 0x76, 0xF8, 0x26, 0x7E, + 0x15, 0x04, 0xDF, 0x30, 0x33, 0x32, 0x03, 0x47, + 0xE4, 0x2F, 0x04, 0xCF, 0xB4, 0x78, 0xC7, 0x3F, + 0x63, 0x86, 0x1B, 0xA7, 0x60, 0xF1, 0x40, 0xD6, + 0x04, 0xF0, 0x64, 0x10, 0x6B, 0x22, 0x19, 0x6A + }, + { + 0xB2, 0x46, 0xDB, 0x79, 0x03, 0xAF, 0x41, 0x9C, + 0x86, 0xB0, 0xDD, 0x11, 0x66, 0x20, 0xF6, 0xB8, + 0x3B, 0x2B, 0xCA, 0x3C, 0x9A, 0x9E, 0x54, 0x95, + 0x36, 0x38, 0x4F, 0x21, 0x3C, 0x86, 0x05, 0x89, + 0xCC, 0x10, 0x63, 0xF1, 0x15, 0xBB, 0xD3, 0xED, + 0xD8, 0xB0, 0xA2, 0x27, 0x39, 0xB1, 0x8F, 0x3D, + 0x13, 0xD8, 0x81, 0x0B, 0xC6, 0xB7, 0x35, 0xD6, + 0xF5, 0xB6, 0xBF, 0x2E, 0x8F, 0x5D, 0x57, 0xA6 + }, + { + 0x79, 0x7B, 0x18, 0x60, 0x3A, 0x6B, 0x98, 0x61, + 0xAE, 0x69, 0x58, 0x60, 0xCD, 0xF1, 0x7E, 0xE2, + 0x64, 0x1D, 0x34, 0x3E, 0x3C, 0x51, 0x43, 0xE3, + 0xDC, 0x34, 0x50, 0xFE, 0x8C, 0xF4, 0x85, 0x6E, + 0xDC, 0x15, 0xA0, 0xD6, 0xF3, 0xFD, 0x31, 0x6E, + 0x4E, 0x43, 0x4F, 0x0B, 0x32, 0xA1, 0x1A, 0xC9, + 0xFD, 0x90, 0xBE, 0x89, 0x06, 0x31, 0x64, 0x0D, + 0xF5, 0x90, 0x9B, 0x29, 0xA9, 0x36, 0xC5, 0xE5 + }, + { + 0x16, 0xB8, 0xFB, 0x03, 0x5D, 0x3E, 0x3E, 0xBE, + 0x4F, 0x0F, 0xCB, 0xA8, 0xD5, 0x6C, 0xD5, 0x0A, + 0x08, 0xCC, 0x6F, 0x30, 0x28, 0xE8, 0x34, 0x30, + 0xC6, 0x5E, 0x60, 0x00, 0x33, 0x43, 0x76, 0x6A, + 0x0F, 0x4A, 0x99, 0x79, 0x15, 0x20, 0x18, 0x2D, + 0x59, 0xB3, 0xC3, 0x75, 0x38, 0xCA, 0xF9, 0x2C, + 0x5A, 0x6C, 0x40, 0xE1, 0xA6, 0xD7, 0xBB, 0xCB, + 0xFB, 0x84, 0xD2, 0x5D, 0xDF, 0xF6, 0x0C, 0x75 + }, + { + 0xF5, 0xCD, 0x4F, 0x4A, 0x95, 0x37, 0x59, 0xFA, + 0x75, 0x8C, 0xA1, 0x04, 0x12, 0x08, 0x4F, 0xF7, + 0x58, 0xFF, 0x66, 0xD0, 0x41, 0x6B, 0x1D, 0x4B, + 0x45, 0x1A, 0x67, 0x17, 0xB3, 0x07, 0x5C, 0xBD, + 0xEE, 0x42, 0x93, 0x81, 0x09, 0x32, 0xBB, 0x29, + 0x4A, 0x07, 0xE6, 0xD5, 0xD3, 0x1C, 0x13, 0x4F, + 0x5F, 0xFA, 0xC4, 0xAF, 0x8C, 0x80, 0x18, 0x18, + 0x60, 0x51, 0xA0, 0xE5, 0x79, 0x8A, 0x62, 0xCD + }, + { + 0x72, 0xB0, 0x6B, 0xE4, 0xBF, 0xB8, 0x28, 0x42, + 0xCB, 0xDD, 0xD7, 0xCC, 0x3B, 0x68, 0x73, 0x36, + 0x5D, 0xE1, 0xA1, 0x8B, 0x9F, 0x50, 0x6C, 0xAE, + 0x79, 0x11, 0x38, 0x7B, 0x1F, 0x4E, 0x31, 0x29, + 0xAE, 0x46, 0x06, 0x22, 0x48, 0xD6, 0x25, 0xAD, + 0x52, 0xF2, 0x41, 0x67, 0x7A, 0x85, 0x22, 0x52, + 0x2E, 0x26, 0x18, 0xD7, 0x1A, 0x5B, 0x16, 0xC9, + 0x1D, 0x38, 0xC0, 0xA0, 0x39, 0x1B, 0x2B, 0x92 + }, + { + 0x3F, 0xFC, 0x87, 0xC4, 0x0A, 0x5F, 0x84, 0xE6, + 0x67, 0xE1, 0x49, 0x4B, 0xAD, 0xFE, 0xC7, 0x9D, + 0xF5, 0x61, 0x18, 0x25, 0xAE, 0x1D, 0xC3, 0x84, + 0x6A, 0x4A, 0xC0, 0x79, 0xAE, 0x5F, 0x65, 0x14, + 0x67, 0xE8, 0x06, 0x3A, 0x8F, 0xFB, 0x25, 0x13, + 0x89, 0x32, 0x9C, 0x32, 0xB4, 0x2C, 0x46, 0xEF, + 0xD3, 0xAE, 0x2D, 0x66, 0x05, 0x61, 0xF7, 0x6E, + 0x93, 0xAE, 0xE6, 0x25, 0x3A, 0x05, 0x8F, 0x73 + }, + { + 0x4B, 0xE4, 0x61, 0xFE, 0xC4, 0x20, 0x9A, 0x03, + 0xAF, 0xDE, 0x28, 0x6A, 0xC2, 0x05, 0xCA, 0x10, + 0x8F, 0xAB, 0xFD, 0xB7, 0xAE, 0x86, 0xB9, 0xF9, + 0xE1, 0xD0, 0x1B, 0xFB, 0x00, 0x51, 0xCE, 0x93, + 0xE1, 0xD6, 0xFC, 0x1E, 0x20, 0x05, 0xB6, 0xD4, + 0xA1, 0x96, 0x90, 0xCF, 0x0A, 0x94, 0xCD, 0x10, + 0x50, 0x3A, 0xC5, 0x94, 0x5D, 0xF9, 0x0D, 0x6F, + 0x8D, 0x81, 0x82, 0xDF, 0x3D, 0x61, 0x7B, 0x2D + }, + { + 0x80, 0x82, 0xB6, 0xF4, 0x37, 0x2B, 0x7A, 0xC0, + 0xF4, 0xF7, 0x03, 0x86, 0xF0, 0x76, 0xA7, 0x2A, + 0xEC, 0x8F, 0xDC, 0x04, 0x35, 0x7B, 0x7C, 0xB2, + 0xBB, 0xDA, 0xB3, 0x9B, 0xF0, 0xDD, 0x01, 0x94, + 0x6E, 0xD3, 0x0C, 0x9D, 0x70, 0x0A, 0xCE, 0x47, + 0x36, 0x67, 0xA6, 0x7F, 0x12, 0x72, 0x15, 0x05, + 0x70, 0x08, 0x63, 0x70, 0xEC, 0x54, 0xCB, 0xD6, + 0x35, 0xFB, 0x36, 0x6D, 0xC2, 0x0C, 0x9B, 0xF9 + }, + { + 0x8A, 0x90, 0xBE, 0x65, 0xA7, 0x78, 0xA4, 0xCE, + 0xC4, 0xFE, 0xE1, 0xB0, 0xAB, 0x00, 0x6B, 0x0D, + 0x4C, 0x46, 0x0E, 0x42, 0xC1, 0xD1, 0x52, 0x63, + 0xA4, 0xE7, 0x8F, 0x5D, 0x19, 0x2F, 0x6E, 0xEA, + 0xC4, 0x07, 0xF1, 0x68, 0x17, 0x57, 0xB2, 0xC1, + 0x10, 0x9A, 0xDB, 0xF6, 0x43, 0x86, 0xD2, 0x66, + 0x5B, 0x54, 0x55, 0x63, 0x06, 0x93, 0x4C, 0x4C, + 0x82, 0x11, 0x56, 0x9A, 0x06, 0x30, 0xB1, 0x95 + }, + { + 0x77, 0x5F, 0x9A, 0x0B, 0x68, 0x24, 0x98, 0x0B, + 0xA1, 0x0C, 0xC5, 0xA6, 0x8A, 0xED, 0x0E, 0x6C, + 0x1A, 0xA8, 0x03, 0x8C, 0x1A, 0x94, 0x41, 0x93, + 0x08, 0x19, 0x63, 0xCF, 0x5C, 0x05, 0x8B, 0x6A, + 0x90, 0xA3, 0xF5, 0xF6, 0xC8, 0x97, 0x56, 0xC9, + 0xC8, 0x80, 0x93, 0x73, 0x5F, 0xB9, 0xB5, 0x30, + 0xFE, 0x9F, 0xD8, 0xC0, 0xC6, 0x0F, 0xBD, 0x0F, + 0xB1, 0xA1, 0xA0, 0x62, 0xF5, 0xD2, 0xD2, 0x23 + }, + { + 0x5C, 0x30, 0xD1, 0x24, 0xDA, 0x78, 0xBC, 0x8C, + 0x22, 0xA4, 0x2D, 0xCA, 0xF6, 0xBE, 0x96, 0xD4, + 0xBB, 0xDA, 0x5C, 0xCD, 0x43, 0x92, 0xFE, 0x46, + 0x19, 0xDC, 0x02, 0x66, 0xA4, 0x0E, 0xB9, 0x80, + 0x5C, 0x36, 0x9D, 0x33, 0xF5, 0x7F, 0x72, 0xC3, + 0xA0, 0x3B, 0xC9, 0x53, 0xA5, 0x7B, 0x10, 0x8E, + 0xA5, 0x40, 0x1D, 0x22, 0x90, 0x05, 0x22, 0x37, + 0xEE, 0x68, 0x75, 0x71, 0x62, 0xA3, 0x94, 0xF2 + }, + { + 0x18, 0x32, 0x02, 0x27, 0x95, 0xBE, 0x5A, 0xBC, + 0xDF, 0xEE, 0x2B, 0x77, 0x7E, 0xDD, 0x0E, 0xBC, + 0x15, 0xDA, 0x77, 0xF4, 0xB8, 0x45, 0xDB, 0x42, + 0x61, 0xEC, 0x22, 0x56, 0x6C, 0x6B, 0x49, 0x12, + 0xA6, 0xD1, 0xC8, 0xE8, 0x03, 0x4B, 0x12, 0x7C, + 0x8D, 0x09, 0xED, 0xAC, 0x17, 0x44, 0x93, 0x55, + 0x0B, 0x2A, 0x3B, 0xB5, 0x8D, 0x61, 0x7B, 0x5A, + 0x9D, 0x7B, 0xBE, 0x4E, 0xAB, 0x07, 0x73, 0x95 + }, + { + 0x6C, 0x48, 0x9F, 0x82, 0xC6, 0xA3, 0xE3, 0xDB, + 0x7F, 0xB5, 0xF8, 0xBD, 0xBF, 0x78, 0x0C, 0xFF, + 0x29, 0x5D, 0x45, 0x51, 0x9F, 0xED, 0x06, 0xEC, + 0x1C, 0x11, 0x49, 0x58, 0x44, 0x80, 0xE4, 0x9F, + 0xA1, 0x12, 0xD6, 0x53, 0x38, 0xD4, 0x77, 0x71, + 0xC7, 0xDD, 0x96, 0x84, 0xFF, 0xC8, 0xA8, 0xD5, + 0xAB, 0xA7, 0x51, 0x56, 0x5C, 0x1B, 0xBF, 0xD8, + 0x5B, 0x92, 0xCF, 0xE6, 0x90, 0x84, 0xC0, 0x8E + }, + { + 0x2F, 0x28, 0x02, 0xE0, 0x54, 0xAF, 0x77, 0xF2, + 0x93, 0x25, 0x13, 0xA8, 0x9B, 0xD1, 0x9C, 0xB8, + 0x1B, 0xB0, 0x63, 0x49, 0x4E, 0x65, 0xAB, 0x20, + 0xBE, 0xEA, 0x6A, 0xC0, 0x99, 0xEB, 0x00, 0x8A, + 0xEF, 0x91, 0xEB, 0xC9, 0xB6, 0xFF, 0x60, 0x88, + 0xB2, 0xE1, 0x6C, 0x9D, 0x73, 0xAE, 0xE8, 0x4D, + 0xEA, 0x04, 0xBF, 0xF6, 0x49, 0xC3, 0x33, 0x20, + 0x0B, 0xB8, 0xDB, 0xCF, 0xF9, 0xA0, 0x73, 0x50 + }, + { + 0x47, 0x4C, 0x87, 0x65, 0xE7, 0x0A, 0x8D, 0x1B, + 0x0A, 0x5D, 0x5D, 0xC2, 0xB5, 0xD2, 0xC5, 0xF2, + 0xBF, 0x56, 0x61, 0x65, 0xED, 0xAB, 0xE3, 0xB6, + 0x1F, 0x8E, 0x6B, 0x3D, 0xA7, 0xDF, 0x25, 0xE5, + 0x97, 0x3D, 0x4C, 0x55, 0x73, 0x2F, 0xCE, 0xF5, + 0x84, 0x76, 0x6C, 0x88, 0x55, 0x8A, 0xD1, 0x5B, + 0x98, 0x92, 0x35, 0x09, 0xED, 0x2B, 0xC9, 0xFD, + 0xBB, 0x42, 0x76, 0x53, 0xB0, 0x97, 0x01, 0x8C + }, + { + 0xCD, 0x56, 0xDE, 0xB7, 0x72, 0xB0, 0x80, 0x5C, + 0x42, 0x3B, 0x3C, 0xC9, 0x04, 0x1C, 0x81, 0xA4, + 0xA2, 0x0F, 0x87, 0x82, 0xE2, 0x1C, 0xFA, 0xE1, + 0x4A, 0xDD, 0x28, 0x37, 0x86, 0x58, 0xD6, 0x4F, + 0x2B, 0x30, 0x8D, 0xB6, 0x55, 0x7E, 0xC2, 0x97, + 0xB9, 0x7F, 0x1E, 0xE3, 0xA3, 0xDD, 0x9C, 0xF7, + 0x93, 0x9F, 0x47, 0x62, 0x15, 0xDB, 0x00, 0x20, + 0xFF, 0x96, 0x49, 0x17, 0x50, 0x03, 0xB9, 0x1C + }, + { + 0x2D, 0x58, 0xE1, 0x5E, 0xF0, 0x26, 0x48, 0x6D, + 0xC2, 0xC9, 0x25, 0x35, 0x88, 0x8B, 0x72, 0xBD, + 0x83, 0x33, 0x14, 0x56, 0xF4, 0x05, 0x55, 0xF2, + 0x60, 0xB8, 0xEB, 0xAC, 0x8D, 0x4B, 0xA6, 0x7A, + 0x10, 0x28, 0x17, 0xDF, 0x7F, 0xE2, 0xA6, 0x52, + 0x7D, 0xF1, 0x0C, 0xDE, 0x7E, 0xA1, 0xF9, 0x5A, + 0x0E, 0x0F, 0x09, 0x36, 0x25, 0x8D, 0x4B, 0x2A, + 0xCB, 0xBC, 0xF6, 0x17, 0xDB, 0xF1, 0xE8, 0x06 + }, + { + 0xBC, 0x5A, 0x07, 0x7E, 0x14, 0x38, 0x93, 0xDA, + 0xC5, 0x90, 0x6B, 0xF4, 0x47, 0x3F, 0x57, 0xFB, + 0xA5, 0xB8, 0x37, 0x44, 0x90, 0x63, 0x5F, 0xB5, + 0x03, 0xF6, 0x9F, 0x81, 0xE7, 0x00, 0x9D, 0x12, + 0xCF, 0xA1, 0xEF, 0xC9, 0x6E, 0x22, 0x84, 0xDF, + 0xDE, 0xB4, 0x1E, 0x5F, 0x11, 0x64, 0x68, 0xE4, + 0x50, 0x39, 0x67, 0xE6, 0x24, 0x10, 0xDB, 0x47, + 0x3F, 0x99, 0xC7, 0xAC, 0xEF, 0x1A, 0x71, 0xED + }, + { + 0xC8, 0x06, 0x4C, 0x2B, 0x36, 0xC6, 0xF4, 0x59, + 0x57, 0x1E, 0xCD, 0x3F, 0x11, 0x5F, 0x68, 0x08, + 0x6C, 0x50, 0x10, 0xD1, 0x32, 0x98, 0xC2, 0xFB, + 0x53, 0x46, 0x9D, 0xA0, 0xCC, 0xA5, 0x51, 0x66, + 0x50, 0x8A, 0xEC, 0x51, 0x9A, 0x56, 0x59, 0x94, + 0x6B, 0x16, 0x9F, 0xEE, 0x67, 0x12, 0xE8, 0x8B, + 0xF2, 0xF0, 0x7D, 0x6C, 0x72, 0xD5, 0xF8, 0x82, + 0x1F, 0x57, 0x86, 0x27, 0xE5, 0x42, 0x08, 0xAE + }, + { + 0x35, 0xFC, 0x67, 0x62, 0xDD, 0x4C, 0x66, 0x7A, + 0x80, 0x52, 0x21, 0xBD, 0xD7, 0x03, 0x66, 0x32, + 0x8F, 0x30, 0xA2, 0xF6, 0xE2, 0xFF, 0x1B, 0x2D, + 0x10, 0x7B, 0x14, 0x79, 0xD2, 0xA5, 0x06, 0xA3, + 0x9C, 0x4C, 0x98, 0x9F, 0xCC, 0x07, 0x3C, 0x7A, + 0x51, 0x27, 0xD4, 0x53, 0xF1, 0x11, 0xB1, 0x9E, + 0x8C, 0xD3, 0xC6, 0x09, 0xA9, 0xC5, 0x33, 0x0F, + 0x7C, 0xD2, 0x1E, 0x2D, 0x2A, 0x39, 0xD8, 0x6C + }, + { + 0x23, 0xBB, 0xC0, 0x24, 0x85, 0x34, 0xE8, 0x3C, + 0xCB, 0x8C, 0x04, 0x26, 0xF3, 0x9D, 0x51, 0xBB, + 0x6A, 0x91, 0x7F, 0x38, 0xFA, 0x90, 0x26, 0x43, + 0xC6, 0x76, 0xD9, 0x04, 0x9F, 0x0C, 0x83, 0x39, + 0x77, 0x52, 0xCD, 0x34, 0xD8, 0xC6, 0x72, 0x97, + 0x09, 0xC3, 0x57, 0xFC, 0x78, 0x38, 0x06, 0x45, + 0xE1, 0x8C, 0xBB, 0xB9, 0x0E, 0x5D, 0x31, 0xA8, + 0x1E, 0x01, 0xB4, 0x4B, 0x31, 0x0F, 0x30, 0xF2 + }, + { + 0x51, 0x27, 0x7D, 0x89, 0xB7, 0x0F, 0xE6, 0x9F, + 0x5F, 0x14, 0x32, 0x0B, 0xE6, 0xF1, 0xC8, 0x89, + 0xD6, 0xE0, 0x92, 0xE3, 0xF7, 0x7D, 0xC1, 0x8A, + 0xE1, 0x84, 0x7F, 0xA0, 0xAA, 0x4E, 0x15, 0x30, + 0x02, 0xD8, 0xF0, 0x05, 0x6C, 0xEF, 0x39, 0xC9, + 0x07, 0xAD, 0xF1, 0x2E, 0x3A, 0xD6, 0x4E, 0xFB, + 0x43, 0x56, 0xE2, 0x04, 0x7E, 0x18, 0xFE, 0x26, + 0x9E, 0xA8, 0xB5, 0x7A, 0x14, 0xB9, 0xF9, 0x63 + }, + { + 0x9C, 0x18, 0xAA, 0xB4, 0x32, 0xE4, 0xEA, 0x88, + 0x62, 0xE5, 0xB8, 0xA2, 0xF7, 0x7D, 0x18, 0xDA, + 0x46, 0x17, 0x25, 0x88, 0x91, 0x7E, 0xE4, 0x24, + 0xFC, 0x4E, 0x33, 0x91, 0x1B, 0x32, 0x13, 0xC9, + 0x46, 0xDB, 0x39, 0x46, 0x30, 0x94, 0x61, 0x9B, + 0x7D, 0xBF, 0x04, 0x46, 0x3D, 0xF1, 0xEF, 0x8F, + 0x92, 0x76, 0xB4, 0xF1, 0x5B, 0x18, 0x04, 0x2C, + 0x07, 0x58, 0xDA, 0x73, 0x09, 0x37, 0x76, 0x80 + }, + { + 0x0B, 0xD7, 0x2F, 0xF6, 0xE1, 0xE2, 0x96, 0x25, + 0x5C, 0x71, 0x79, 0xAD, 0x11, 0x9A, 0x8C, 0x9D, + 0xD7, 0x93, 0x8B, 0x22, 0xC7, 0x4A, 0x9F, 0x8A, + 0x68, 0xCC, 0xB0, 0x9F, 0x57, 0xF2, 0x85, 0x3C, + 0x4C, 0x0F, 0xEC, 0x46, 0xF2, 0xB4, 0xE9, 0xD8, + 0x57, 0x64, 0xFF, 0x93, 0x02, 0x20, 0x40, 0xAC, + 0xF5, 0x8D, 0xC1, 0xF5, 0xA3, 0xC9, 0xBA, 0x40, + 0x9D, 0x1E, 0xC6, 0xF3, 0x6B, 0x46, 0xEE, 0xB8 + }, + { + 0x65, 0x81, 0xF7, 0xAA, 0x70, 0x42, 0x03, 0x27, + 0x29, 0xF7, 0x42, 0x01, 0x16, 0xC5, 0xF0, 0xA2, + 0xC8, 0xC2, 0x70, 0x40, 0xB1, 0xA7, 0xF1, 0xBD, + 0x8E, 0xD1, 0x3C, 0x4B, 0x1C, 0x34, 0xB8, 0x8F, + 0x30, 0xA9, 0xF9, 0x1F, 0x14, 0xDA, 0x2C, 0x37, + 0x2C, 0x9B, 0x2E, 0xC7, 0x22, 0xCE, 0x30, 0x74, + 0xE9, 0x4F, 0x83, 0xF2, 0x1B, 0xAE, 0x11, 0x86, + 0x83, 0xC7, 0x5E, 0x76, 0x7A, 0x67, 0x50, 0xF2 + }, + { + 0xC4, 0x54, 0x14, 0x06, 0x09, 0x8F, 0xF5, 0x02, + 0xD0, 0x63, 0x47, 0xF7, 0x2B, 0x8D, 0xEB, 0x45, + 0xC9, 0x43, 0xF2, 0xC1, 0xC8, 0x53, 0x03, 0xC0, + 0x35, 0x3F, 0x8A, 0xD3, 0xEC, 0x89, 0x65, 0xBC, + 0x02, 0xE6, 0x2E, 0x33, 0x38, 0xB1, 0xFE, 0x5E, + 0xC0, 0x58, 0x96, 0x13, 0xDE, 0x6B, 0xBD, 0xD1, + 0x2E, 0xB0, 0xC5, 0xB2, 0x13, 0xB1, 0x28, 0x2A, + 0xE3, 0x36, 0x99, 0xEF, 0xAE, 0x07, 0xDF, 0xCA + }, + { + 0x1F, 0x95, 0xB1, 0x86, 0xFA, 0x17, 0xDB, 0x9E, + 0x46, 0xF3, 0x37, 0x6A, 0x64, 0x3F, 0x4A, 0xF9, + 0xA6, 0x6C, 0xB0, 0x75, 0xDD, 0x55, 0x44, 0xC1, + 0x40, 0xF9, 0xC6, 0xC7, 0xC0, 0xF6, 0x1C, 0x98, + 0x8F, 0xE5, 0xA8, 0x05, 0x12, 0x87, 0x34, 0x0F, + 0x6E, 0x66, 0x87, 0xC6, 0xEF, 0x0F, 0xA1, 0xC3, + 0xCD, 0x90, 0x67, 0x6F, 0x1C, 0x18, 0x27, 0xD8, + 0xDC, 0xAB, 0x3B, 0xCE, 0x5B, 0xA8, 0x4F, 0x7E + }, + { + 0xA2, 0x15, 0x11, 0x7B, 0xB5, 0x19, 0x45, 0x92, + 0xA7, 0x58, 0x11, 0x69, 0x42, 0x51, 0xDB, 0x93, + 0x16, 0xBA, 0xCB, 0x96, 0x92, 0xF8, 0x4C, 0x52, + 0x03, 0x4F, 0x65, 0x7D, 0x6C, 0x15, 0x78, 0xE3, + 0x95, 0x82, 0xE9, 0x63, 0x93, 0x2F, 0x14, 0xDD, + 0x9D, 0x74, 0x12, 0xAB, 0x64, 0xA4, 0xF5, 0x09, + 0xF5, 0xEC, 0xC4, 0xA2, 0xE6, 0x28, 0x91, 0xBB, + 0x41, 0xB6, 0x81, 0xDC, 0xDF, 0xBC, 0xEC, 0x18 + }, + { + 0x0C, 0xE6, 0x4F, 0x00, 0x3C, 0x68, 0x3D, 0x0C, + 0x42, 0x68, 0x0B, 0x60, 0x68, 0x90, 0xDD, 0x4B, + 0xB0, 0x45, 0x4B, 0x7F, 0x77, 0xC8, 0x3B, 0xCA, + 0x37, 0x19, 0x56, 0x21, 0x9F, 0xB4, 0x66, 0xD9, + 0x18, 0xDF, 0x00, 0x94, 0x24, 0x30, 0x86, 0x63, + 0x0B, 0xEE, 0x6A, 0xA0, 0xDA, 0xE9, 0x99, 0x0A, + 0x74, 0xBE, 0x21, 0x2E, 0xFF, 0xFB, 0x4E, 0x70, + 0x58, 0x5D, 0xBA, 0xE4, 0xFE, 0x2E, 0xC7, 0x23 + }, + { + 0xF3, 0xCB, 0xDE, 0x71, 0x99, 0xA9, 0x28, 0x87, + 0xF2, 0x2C, 0x59, 0xC5, 0x74, 0xD0, 0x1E, 0xBA, + 0x29, 0x17, 0x45, 0x63, 0xB8, 0x53, 0x40, 0xF3, + 0x77, 0x42, 0x27, 0x84, 0xD5, 0xEC, 0x23, 0x27, + 0xEA, 0xAF, 0x94, 0xFA, 0xFA, 0xD9, 0x98, 0x82, + 0x8A, 0xB5, 0x57, 0xEA, 0xB7, 0x33, 0xA2, 0x7C, + 0xDC, 0xB6, 0x90, 0x8B, 0x58, 0x34, 0xC6, 0xBE, + 0x9D, 0x2E, 0xC2, 0xB3, 0x8A, 0x48, 0xA5, 0xA7 + }, + { + 0x6F, 0xF6, 0x14, 0x1B, 0x54, 0xDC, 0xEC, 0xC2, + 0x24, 0x50, 0x4D, 0x37, 0xCC, 0x80, 0xCC, 0x1F, + 0xA8, 0x51, 0x49, 0xF3, 0x01, 0xAB, 0x09, 0x09, + 0x39, 0x87, 0x37, 0xEC, 0x58, 0x4B, 0xAC, 0x45, + 0x10, 0xA2, 0x40, 0x5E, 0x99, 0xCC, 0xED, 0x2B, + 0x1A, 0xBF, 0x35, 0xC3, 0x63, 0xD7, 0x02, 0x2B, + 0x4A, 0x29, 0x4A, 0x7E, 0xBF, 0x04, 0xD9, 0x32, + 0x86, 0x11, 0xAF, 0x6D, 0xC0, 0xA8, 0xEE, 0x10 + }, + { + 0x38, 0x4F, 0xA0, 0x6F, 0x1B, 0x72, 0x42, 0x28, + 0x32, 0x77, 0x1B, 0x67, 0x62, 0x4A, 0x1A, 0xD6, + 0xF8, 0x6A, 0x1E, 0x77, 0x84, 0xDE, 0xCB, 0x74, + 0x8A, 0xFF, 0x34, 0xA8, 0xA2, 0x33, 0x5B, 0x8D, + 0xBB, 0x34, 0x80, 0x13, 0x41, 0x5C, 0xE3, 0x9D, + 0x8D, 0x83, 0xEF, 0x85, 0x25, 0xC6, 0x47, 0x32, + 0x25, 0x75, 0x13, 0xD2, 0x10, 0x34, 0x6D, 0x62, + 0x3C, 0x9E, 0xF6, 0x98, 0xDD, 0xE5, 0xF1, 0x8A + }, + { + 0x13, 0xE0, 0x72, 0x72, 0x8D, 0x1D, 0xCA, 0x69, + 0xE7, 0x9D, 0x82, 0x2C, 0xBF, 0x25, 0x3C, 0x79, + 0x55, 0x99, 0xAB, 0x6B, 0x83, 0x9F, 0x84, 0x1A, + 0x56, 0x4E, 0xD1, 0x5B, 0x07, 0xE7, 0xA0, 0x61, + 0xFC, 0xD3, 0xCD, 0x75, 0xF1, 0x25, 0xFD, 0x95, + 0x74, 0x9A, 0xA9, 0xF3, 0x7D, 0x8E, 0x04, 0x3A, + 0xAA, 0x60, 0x3B, 0xD6, 0x46, 0x5E, 0x08, 0x6F, + 0x6C, 0x7F, 0x2C, 0xFB, 0x43, 0xC5, 0x39, 0x7B + }, + { + 0x8F, 0x66, 0x2C, 0x53, 0xEC, 0x04, 0x07, 0x22, + 0x67, 0x59, 0xA5, 0x37, 0x23, 0x9B, 0xFE, 0x0D, + 0xEF, 0xB9, 0x07, 0xCE, 0x55, 0x6D, 0x7A, 0xD2, + 0x1F, 0xEB, 0x63, 0xA8, 0xCF, 0x84, 0x89, 0x29, + 0x3E, 0xE9, 0x20, 0x41, 0xFE, 0xA5, 0xCC, 0x13, + 0x59, 0x27, 0xA9, 0xA6, 0x84, 0x00, 0x2D, 0xAB, + 0x5B, 0xB4, 0xEC, 0x3A, 0x02, 0x55, 0x39, 0xB7, + 0x7A, 0x2A, 0xCE, 0x5B, 0xF4, 0x5E, 0x34, 0xDD + }, + { + 0xC2, 0x36, 0x12, 0x37, 0xCF, 0xED, 0xDF, 0x8F, + 0x95, 0xB0, 0xA0, 0xA3, 0x1C, 0xDA, 0x3E, 0x8D, + 0x34, 0x80, 0x2F, 0x72, 0xF4, 0xFD, 0x82, 0x06, + 0x2E, 0xF1, 0x83, 0x17, 0x84, 0x6F, 0xD5, 0xA7, + 0x24, 0x66, 0x6A, 0xF3, 0xAD, 0xBF, 0x9F, 0xBF, + 0x4A, 0x63, 0x4F, 0xE3, 0x60, 0x6B, 0x7D, 0x6C, + 0xE5, 0xD4, 0x32, 0xA6, 0x31, 0xF1, 0xC9, 0x67, + 0xCE, 0x48, 0x32, 0x00, 0x4B, 0xE4, 0xBF, 0xD0 + }, + { + 0x2D, 0x60, 0xE8, 0xAD, 0x55, 0x8E, 0x85, 0x8C, + 0x05, 0x7C, 0xC9, 0xC6, 0x51, 0xE9, 0xA9, 0x96, + 0x9E, 0x6A, 0x33, 0x68, 0x4A, 0x1E, 0x92, 0x24, + 0x9B, 0x62, 0x0F, 0x74, 0x3D, 0x56, 0x2D, 0xCC, + 0x8A, 0x48, 0x4E, 0xB0, 0x89, 0x4C, 0xD5, 0xAA, + 0xE5, 0xA7, 0x21, 0x38, 0xAC, 0xFB, 0x2D, 0x06, + 0x09, 0x55, 0x42, 0xEF, 0xAD, 0xAA, 0x78, 0x99, + 0xB0, 0x70, 0xC5, 0xFC, 0x94, 0x3C, 0x3C, 0x52 + }, + { + 0x7D, 0xDB, 0x65, 0xDF, 0x66, 0xA9, 0xD9, 0xDD, + 0xE8, 0xCA, 0x2F, 0xC2, 0x0E, 0x73, 0x05, 0xF5, + 0x44, 0x29, 0x85, 0xAA, 0xAC, 0x02, 0x7F, 0xD8, + 0x3D, 0xA6, 0x8D, 0xC1, 0x4C, 0xAC, 0xA2, 0x07, + 0xC8, 0x8A, 0xCF, 0xD0, 0x51, 0xB2, 0x2D, 0x18, + 0xCF, 0xFE, 0x19, 0x8C, 0x21, 0x13, 0x7D, 0x4B, + 0x3B, 0x2B, 0x84, 0xF2, 0x93, 0x82, 0x54, 0xAF, + 0x77, 0x42, 0xBC, 0xF1, 0x18, 0xCF, 0xF2, 0x00 + }, + { + 0x95, 0x68, 0x69, 0x18, 0xDC, 0xC6, 0x0C, 0x14, + 0x08, 0xE7, 0x45, 0xD7, 0xB1, 0x7A, 0xBE, 0x32, + 0x42, 0xF7, 0x25, 0x07, 0xB3, 0x4F, 0xF7, 0x96, + 0xA5, 0x21, 0xF4, 0x30, 0x6E, 0xED, 0xEE, 0xF2, + 0x22, 0xA2, 0xAC, 0x43, 0x17, 0x59, 0x3A, 0x62, + 0xE4, 0x92, 0x4C, 0x56, 0x35, 0x76, 0x10, 0x90, + 0x54, 0x98, 0xE2, 0x7A, 0x33, 0xA5, 0x47, 0xC0, + 0x88, 0xD6, 0x93, 0x9A, 0xD5, 0x15, 0x2F, 0x8B + }, + { + 0xBF, 0xFF, 0xF7, 0xB4, 0xC6, 0x45, 0x99, 0x70, + 0x62, 0x60, 0xB3, 0x59, 0x39, 0x07, 0xBE, 0x95, + 0x09, 0x58, 0x8F, 0xED, 0x28, 0xB7, 0xA7, 0x63, + 0xCD, 0x65, 0xD2, 0x7F, 0x1B, 0xDC, 0xEA, 0x99, + 0xAC, 0x85, 0x96, 0xBD, 0x10, 0x08, 0x67, 0x4E, + 0x8A, 0x77, 0xAC, 0x77, 0x9A, 0xD9, 0xC7, 0x75, + 0x31, 0x96, 0x14, 0xAD, 0x8D, 0x04, 0x58, 0x83, + 0xAE, 0xA3, 0xF8, 0xD0, 0x85, 0xE4, 0xCB, 0x34 + }, + { + 0xC6, 0x94, 0xAC, 0x8F, 0x05, 0xBB, 0xB5, 0x8E, + 0x37, 0x4B, 0xD4, 0xE5, 0x3C, 0xDF, 0x83, 0x69, + 0x31, 0x7F, 0x28, 0x06, 0x5F, 0x8E, 0x65, 0x8A, + 0xA2, 0xE0, 0x09, 0x05, 0x3C, 0x3C, 0x7C, 0x79, + 0x01, 0x2C, 0x08, 0x3F, 0x42, 0x53, 0x22, 0x25, + 0x4A, 0x4C, 0xE5, 0x5C, 0x3B, 0x26, 0xDA, 0xF5, + 0x3A, 0x6E, 0x47, 0xA5, 0x2F, 0x84, 0xDC, 0x5F, + 0xDD, 0x8D, 0xF7, 0xB7, 0xA8, 0x5D, 0xC0, 0xA4 + }, + { + 0x31, 0x4F, 0x45, 0xFC, 0xA9, 0xE5, 0x51, 0xD6, + 0xFD, 0x58, 0xF6, 0x3A, 0x84, 0x18, 0x6B, 0xC9, + 0x38, 0x4C, 0xD2, 0x59, 0x2C, 0x62, 0x80, 0xAE, + 0x52, 0xD9, 0xA8, 0x7A, 0xA1, 0x59, 0x3F, 0x9B, + 0xDD, 0x7F, 0x30, 0x3C, 0x9D, 0xC0, 0x75, 0x9B, + 0x4D, 0x48, 0x76, 0xB3, 0xB6, 0x81, 0x70, 0x6D, + 0x90, 0x96, 0xC2, 0xC8, 0xEE, 0x98, 0x6D, 0x9C, + 0x1F, 0x60, 0x8B, 0x34, 0xDA, 0xCD, 0xE5, 0xC4 + }, + { + 0xE3, 0x95, 0x95, 0x8F, 0x1F, 0x29, 0xFC, 0xC1, + 0xE9, 0x13, 0x96, 0x7A, 0x7C, 0x0F, 0x88, 0xF6, + 0x56, 0xBB, 0x00, 0x60, 0xC4, 0xFC, 0x7F, 0x53, + 0x58, 0x52, 0x0B, 0xF3, 0x22, 0xA5, 0x61, 0xE7, + 0x16, 0x57, 0xC5, 0x80, 0x0A, 0xC1, 0x16, 0x56, + 0x69, 0x6C, 0xBB, 0x42, 0x19, 0x83, 0x1C, 0x75, + 0x33, 0xF6, 0x89, 0x8C, 0x7A, 0x16, 0x09, 0xFB, + 0xCF, 0xA3, 0xC0, 0x3A, 0x9B, 0x79, 0xE8, 0x5A + }, + { + 0x59, 0xA3, 0x39, 0xD2, 0x0C, 0xC3, 0x8F, 0xB0, + 0xA6, 0x3A, 0xAA, 0x43, 0x39, 0xFE, 0x22, 0x87, + 0xAC, 0x8A, 0x53, 0x16, 0x20, 0x45, 0xB9, 0xBB, + 0x04, 0xC5, 0xC4, 0xD7, 0x8A, 0x0A, 0xA0, 0x2D, + 0x4A, 0xC9, 0x26, 0x3C, 0x7B, 0x7D, 0x28, 0x76, + 0x43, 0x93, 0x5F, 0xB1, 0x39, 0x64, 0xBA, 0xF0, + 0x77, 0xD3, 0xC6, 0xA2, 0xA7, 0x01, 0xBC, 0x3C, + 0x6D, 0x9C, 0xFA, 0x00, 0x78, 0x39, 0x0D, 0x6E + }, + { + 0x59, 0xDE, 0x58, 0x6B, 0xBD, 0x11, 0xFA, 0x46, + 0x6E, 0xA1, 0xD9, 0xB1, 0x96, 0x5F, 0x19, 0x6F, + 0xC9, 0x47, 0x20, 0x02, 0x14, 0x9D, 0x1E, 0x06, + 0xC2, 0x50, 0x29, 0xC7, 0xED, 0xF6, 0x9C, 0xA6, + 0xDF, 0xBA, 0x9C, 0xF2, 0xDA, 0x75, 0x76, 0x05, + 0x4B, 0x23, 0x4A, 0xF2, 0x67, 0xEA, 0x08, 0xCB, + 0x58, 0x45, 0xAD, 0x46, 0x74, 0x7E, 0x5A, 0x68, + 0x77, 0xE7, 0xD9, 0xF8, 0x72, 0xF0, 0xF7, 0x5A + }, + { + 0x0A, 0x72, 0x73, 0x1A, 0x07, 0x65, 0x4E, 0x38, + 0xEB, 0x58, 0x4A, 0x04, 0x83, 0x27, 0xF7, 0xCF, + 0x0D, 0x0F, 0x5E, 0xD2, 0xBB, 0x78, 0x54, 0xAC, + 0x52, 0x01, 0xB9, 0xB4, 0xEC, 0xD2, 0xFF, 0x59, + 0x47, 0x50, 0x63, 0xD9, 0x17, 0x88, 0xC6, 0x47, + 0x77, 0xFB, 0x11, 0xBD, 0x68, 0x6A, 0xE2, 0x1D, + 0x16, 0xA9, 0x78, 0x27, 0x5E, 0x4B, 0x7D, 0x87, + 0xFF, 0x82, 0x0F, 0xF4, 0x3E, 0x73, 0x5E, 0x37 + }, + { + 0xFE, 0x96, 0x0F, 0x8E, 0xC6, 0xCE, 0x04, 0x9F, + 0x14, 0x97, 0xAC, 0x1A, 0x54, 0xC8, 0xF7, 0xF8, + 0x77, 0xEC, 0x0A, 0xEA, 0x9C, 0xAF, 0x62, 0xE8, + 0x94, 0xE5, 0x81, 0x0A, 0xDC, 0x04, 0x4C, 0x0D, + 0x46, 0x63, 0x22, 0xF8, 0x72, 0x16, 0x82, 0x02, + 0xBF, 0x80, 0x4F, 0x68, 0x96, 0x22, 0x18, 0x45, + 0xD0, 0xDB, 0xBC, 0x4B, 0x90, 0x49, 0xB4, 0x31, + 0x70, 0xC8, 0x74, 0xAD, 0x81, 0x5E, 0xA0, 0xF7 + }, + { + 0xC9, 0x78, 0x1F, 0x49, 0xCF, 0x4E, 0xD0, 0xF4, + 0xB1, 0xCA, 0x4E, 0xE9, 0x47, 0x94, 0xE8, 0xD8, + 0xBB, 0x39, 0xB4, 0xA2, 0x94, 0x73, 0x82, 0x29, + 0xAD, 0x96, 0x76, 0xAA, 0x2B, 0xB9, 0xA3, 0x65, + 0x57, 0x9E, 0x62, 0x27, 0x64, 0x02, 0xD2, 0xA3, + 0xA0, 0x5C, 0x85, 0x4D, 0xDF, 0x8E, 0xA8, 0xD8, + 0x6D, 0xEE, 0x63, 0x84, 0x0E, 0x2C, 0x8B, 0xF1, + 0x49, 0x43, 0x56, 0xB9, 0xB2, 0x8C, 0xCD, 0x2D + }, + { + 0x86, 0xBA, 0x5C, 0x9E, 0x7A, 0x32, 0x6D, 0x3A, + 0xA6, 0x50, 0xB1, 0x5C, 0x78, 0xD2, 0x18, 0x1E, + 0xE3, 0x41, 0x9D, 0xD7, 0x64, 0x2D, 0x2F, 0x2B, + 0x40, 0xB3, 0xA7, 0x46, 0x64, 0xC4, 0x3A, 0x2B, + 0xC1, 0xC3, 0xFD, 0xEA, 0x2B, 0x4B, 0x5B, 0x1C, + 0x85, 0x56, 0x9A, 0xCF, 0xE4, 0x24, 0x36, 0x9B, + 0xD0, 0xBE, 0xCB, 0x97, 0xF6, 0xBC, 0x75, 0x0B, + 0x01, 0x9D, 0xC2, 0x1E, 0x92, 0x03, 0x81, 0x84 + }, + { + 0x54, 0xFF, 0x0D, 0x56, 0x0E, 0x51, 0xE6, 0xA3, + 0x45, 0x88, 0xFA, 0x1B, 0xD8, 0xF4, 0x5C, 0xCD, + 0xFA, 0xC1, 0x79, 0x4F, 0x7D, 0xF7, 0xAF, 0x40, + 0x08, 0xE5, 0x78, 0x33, 0x11, 0xAE, 0x6A, 0xAE, + 0x49, 0x6E, 0x38, 0x87, 0x6A, 0xC4, 0xE4, 0xFF, + 0xA2, 0x3D, 0x5D, 0x48, 0xA6, 0x1A, 0x72, 0xBB, + 0xF9, 0xB4, 0xBD, 0xEB, 0x69, 0x39, 0xBD, 0xED, + 0x99, 0x16, 0xA7, 0x66, 0x0B, 0xFA, 0x7A, 0x62 + }, + { + 0x3D, 0x06, 0x77, 0x1A, 0xA4, 0xCF, 0x4E, 0xC7, + 0xF9, 0x8D, 0xAE, 0x6E, 0x16, 0xF0, 0x09, 0x2B, + 0xF8, 0xD8, 0xF3, 0xC1, 0xDD, 0x82, 0xCF, 0xBF, + 0x57, 0x98, 0x71, 0xE7, 0x8C, 0x08, 0x95, 0xAA, + 0xB8, 0x59, 0xA0, 0xDD, 0x7D, 0x2E, 0xBC, 0xAA, + 0x2D, 0x2E, 0x93, 0x42, 0xA8, 0xCD, 0x67, 0xBE, + 0x86, 0x5B, 0x53, 0x9D, 0xF7, 0x2B, 0x4A, 0xB3, + 0x15, 0xB5, 0x7E, 0x75, 0x20, 0x37, 0x72, 0xEA + }, + { + 0xC9, 0xE5, 0x09, 0x22, 0x13, 0xDE, 0x19, 0x1C, + 0x43, 0xA8, 0x61, 0x16, 0x4E, 0x99, 0x9D, 0xDC, + 0x10, 0x34, 0x17, 0xFD, 0x85, 0x5F, 0x2E, 0x90, + 0x9F, 0xA8, 0x55, 0x4C, 0x9E, 0xCC, 0x01, 0x25, + 0x22, 0x0C, 0x17, 0x9B, 0xDE, 0x3D, 0xFD, 0x7A, + 0xBE, 0x77, 0x7B, 0xDB, 0xE5, 0x05, 0xC5, 0xD7, + 0x96, 0xF6, 0xC0, 0x9C, 0x85, 0x12, 0xFF, 0x00, + 0xBB, 0x16, 0x7C, 0x60, 0x5A, 0xAB, 0x18, 0xAD + }, + { + 0x97, 0x21, 0xD3, 0x11, 0xAD, 0x71, 0xAD, 0x09, + 0x55, 0xA5, 0xCD, 0x46, 0x24, 0xD8, 0x2E, 0xEF, + 0x67, 0xE3, 0x26, 0xA1, 0xD9, 0xF3, 0x45, 0x44, + 0x0D, 0x3C, 0x8F, 0xDB, 0x25, 0x40, 0xAF, 0xEE, + 0xCE, 0x66, 0x9D, 0x7F, 0xDB, 0x0E, 0x2C, 0x3F, + 0x7C, 0x36, 0xC2, 0x2F, 0x78, 0x05, 0x34, 0x38, + 0x33, 0xD0, 0x4E, 0xC4, 0x6D, 0x9A, 0xBF, 0xDA, + 0x59, 0x50, 0x13, 0xE6, 0x65, 0xB4, 0x9C, 0x49 + }, + { + 0xCA, 0x35, 0x7E, 0xCD, 0xF7, 0x45, 0x9A, 0x46, + 0x9E, 0xFC, 0x1A, 0x34, 0x9B, 0xB9, 0xA6, 0x73, + 0x0E, 0x93, 0xAB, 0x81, 0xF5, 0x9E, 0x0C, 0x52, + 0x56, 0x72, 0x7B, 0xB7, 0x6B, 0x87, 0x95, 0xF8, + 0x6E, 0x2A, 0x24, 0x71, 0x90, 0x66, 0x86, 0xB0, + 0x27, 0x69, 0x39, 0xE0, 0x2C, 0xCF, 0xA2, 0x3F, + 0x87, 0xB4, 0x2A, 0x03, 0x47, 0x81, 0x53, 0x1D, + 0x30, 0x0C, 0x2F, 0x61, 0x43, 0x0E, 0x30, 0xAF + }, + { + 0x62, 0x99, 0xDB, 0xE0, 0xF1, 0x0D, 0xDA, 0xCD, + 0x95, 0xD8, 0x79, 0x92, 0x49, 0x76, 0xDB, 0xCF, + 0x88, 0x63, 0xAA, 0xC5, 0xF3, 0xFC, 0xB8, 0x73, + 0xAC, 0x7A, 0xB2, 0x39, 0x7C, 0xB8, 0x09, 0xCB, + 0x66, 0xD6, 0x66, 0xC3, 0x31, 0x67, 0xA2, 0xC6, + 0x1F, 0x24, 0xA6, 0xA9, 0xDA, 0x17, 0x78, 0x26, + 0x9E, 0x44, 0xDD, 0xE1, 0x52, 0xD1, 0x75, 0xA9, + 0x6D, 0x3F, 0xB7, 0xBB, 0xAF, 0x79, 0xB8, 0xBC + }, +}; + + + + +#endif + diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2.h new file mode 100644 index 000000000..a1ea671f2 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2.h @@ -0,0 +1,38 @@ +#ifndef BLAKE2_AVX2_BLAKE2_H +#define BLAKE2_AVX2_BLAKE2_H + +#if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L) + #if defined(_MSC_VER) + #define INLINE __inline + #elif defined(__GNUC__) + #define INLINE __inline__ + #else + #define INLINE + #endif +#else + #define INLINE inline +#endif + +#if defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#else +#define ALIGN(x) __attribute__((aligned(x))) +#endif + +enum blake2s_constant { + BLAKE2S_BLOCKBYTES = 64, + BLAKE2S_OUTBYTES = 32, + BLAKE2S_KEYBYTES = 32, + BLAKE2S_SALTBYTES = 8, + BLAKE2S_PERSONALBYTES = 8 +}; + +enum blake2b_constant { + BLAKE2B_BLOCKBYTES = 128, + BLAKE2B_OUTBYTES = 64, + BLAKE2B_KEYBYTES = 64, + BLAKE2B_SALTBYTES = 16, + BLAKE2B_PERSONALBYTES = 16 +}; + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-common.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-common.h new file mode 100644 index 000000000..f9803ee23 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-common.h @@ -0,0 +1,48 @@ +#ifndef BLAKE2_AVX2_BLAKE2B_COMMON_H +#define BLAKE2_AVX2_BLAKE2B_COMMON_H + +#include +#include +#include + +#include + +#include "blake2.h" + +#define LOAD128(p) _mm_load_si128( (__m128i *)(p) ) +#define STORE128(p,r) _mm_store_si128((__m128i *)(p), r) + +#define LOADU128(p) _mm_loadu_si128( (__m128i *)(p) ) +#define STOREU128(p,r) _mm_storeu_si128((__m128i *)(p), r) + +#define LOAD(p) _mm256_load_si256( (__m256i *)(p) ) +#define STORE(p,r) _mm256_store_si256((__m256i *)(p), r) + +#define LOADU(p) _mm256_loadu_si256( (__m256i *)(p) ) +#define STOREU(p,r) _mm256_storeu_si256((__m256i *)(p), r) + +static INLINE uint64_t LOADU64(void const * p) { + uint64_t v; + memcpy(&v, p, sizeof v); + return v; +} + +#define ROTATE16 _mm256_setr_epi8( 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, \ + 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9 ) + +#define ROTATE24 _mm256_setr_epi8( 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, \ + 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10 ) + +#define ADD(a, b) _mm256_add_epi64(a, b) +#define SUB(a, b) _mm256_sub_epi64(a, b) + +#define XOR(a, b) _mm256_xor_si256(a, b) +#define AND(a, b) _mm256_and_si256(a, b) +#define OR(a, b) _mm256_or_si256(a, b) + +#define ROT32(x) _mm256_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1)) +#define ROT24(x) _mm256_shuffle_epi8((x), ROTATE24) +#define ROT16(x) _mm256_shuffle_epi8((x), ROTATE16) +#define ROT63(x) _mm256_or_si256(_mm256_srli_epi64((x), 63), ADD((x), (x))) + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2-simple.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2-simple.h new file mode 100644 index 000000000..1c29c23d6 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2-simple.h @@ -0,0 +1,54 @@ +#ifndef BLAKE2_AVX2_BLAKE2B_LOAD_AVX2_SIMPLE_H +#define BLAKE2_AVX2_BLAKE2B_LOAD_AVX2_SIMPLE_H + +#define BLAKE2B_LOAD_MSG_0_1(b0) b0 = _mm256_set_epi64x(m6, m4, m2, m0); +#define BLAKE2B_LOAD_MSG_0_2(b0) b0 = _mm256_set_epi64x(m7, m5, m3, m1); +#define BLAKE2B_LOAD_MSG_0_3(b0) b0 = _mm256_set_epi64x(m12, m10, m8, m14); +#define BLAKE2B_LOAD_MSG_0_4(b0) b0 = _mm256_set_epi64x(m13, m11, m9, m15); +#define BLAKE2B_LOAD_MSG_1_1(b0) b0 = _mm256_set_epi64x(m13, m9, m4, m14); +#define BLAKE2B_LOAD_MSG_1_2(b0) b0 = _mm256_set_epi64x(m6, m15, m8, m10); +#define BLAKE2B_LOAD_MSG_1_3(b0) b0 = _mm256_set_epi64x(m11, m0, m1, m5); +#define BLAKE2B_LOAD_MSG_1_4(b0) b0 = _mm256_set_epi64x(m7, m2, m12, m3); +#define BLAKE2B_LOAD_MSG_2_1(b0) b0 = _mm256_set_epi64x(m15, m5, m12, m11); +#define BLAKE2B_LOAD_MSG_2_2(b0) b0 = _mm256_set_epi64x(m13, m2, m0, m8); +#define BLAKE2B_LOAD_MSG_2_3(b0) b0 = _mm256_set_epi64x(m7, m3, m10, m9); +#define BLAKE2B_LOAD_MSG_2_4(b0) b0 = _mm256_set_epi64x(m1, m6, m14, m4); +#define BLAKE2B_LOAD_MSG_3_1(b0) b0 = _mm256_set_epi64x(m11, m13, m3, m7); +#define BLAKE2B_LOAD_MSG_3_2(b0) b0 = _mm256_set_epi64x(m14, m12, m1, m9); +#define BLAKE2B_LOAD_MSG_3_3(b0) b0 = _mm256_set_epi64x(m4, m5, m2, m15); +#define BLAKE2B_LOAD_MSG_3_4(b0) b0 = _mm256_set_epi64x(m0, m10, m6, m8); +#define BLAKE2B_LOAD_MSG_4_1(b0) b0 = _mm256_set_epi64x(m10, m2, m5, m9); +#define BLAKE2B_LOAD_MSG_4_2(b0) b0 = _mm256_set_epi64x(m15, m4, m7, m0); +#define BLAKE2B_LOAD_MSG_4_3(b0) b0 = _mm256_set_epi64x(m6, m11, m14, m3); +#define BLAKE2B_LOAD_MSG_4_4(b0) b0 = _mm256_set_epi64x(m8, m12, m1, m13); +#define BLAKE2B_LOAD_MSG_5_1(b0) b0 = _mm256_set_epi64x(m8, m0, m6, m2); +#define BLAKE2B_LOAD_MSG_5_2(b0) b0 = _mm256_set_epi64x(m3, m11, m10, m12); +#define BLAKE2B_LOAD_MSG_5_3(b0) b0 = _mm256_set_epi64x(m15, m7, m4, m1); +#define BLAKE2B_LOAD_MSG_5_4(b0) b0 = _mm256_set_epi64x(m14, m5, m13, m9); +#define BLAKE2B_LOAD_MSG_6_1(b0) b0 = _mm256_set_epi64x(m4, m14, m1, m12); +#define BLAKE2B_LOAD_MSG_6_2(b0) b0 = _mm256_set_epi64x(m10, m13, m15, m5); +#define BLAKE2B_LOAD_MSG_6_3(b0) b0 = _mm256_set_epi64x(m9, m6, m0, m8); +#define BLAKE2B_LOAD_MSG_6_4(b0) b0 = _mm256_set_epi64x(m2, m3, m7, m11); +#define BLAKE2B_LOAD_MSG_7_1(b0) b0 = _mm256_set_epi64x(m3, m12, m7, m13); +#define BLAKE2B_LOAD_MSG_7_2(b0) b0 = _mm256_set_epi64x(m9, m1, m14, m11); +#define BLAKE2B_LOAD_MSG_7_3(b0) b0 = _mm256_set_epi64x(m8, m15, m5, m2); +#define BLAKE2B_LOAD_MSG_7_4(b0) b0 = _mm256_set_epi64x(m6, m4, m0, m10); +#define BLAKE2B_LOAD_MSG_8_1(b0) b0 = _mm256_set_epi64x(m0, m11, m14, m6); +#define BLAKE2B_LOAD_MSG_8_2(b0) b0 = _mm256_set_epi64x(m8, m3, m9, m15); +#define BLAKE2B_LOAD_MSG_8_3(b0) b0 = _mm256_set_epi64x(m1, m13, m12, m10); +#define BLAKE2B_LOAD_MSG_8_4(b0) b0 = _mm256_set_epi64x(m4, m7, m2, m5); +#define BLAKE2B_LOAD_MSG_9_1(b0) b0 = _mm256_set_epi64x(m1, m7, m8, m10); +#define BLAKE2B_LOAD_MSG_9_2(b0) b0 = _mm256_set_epi64x(m5, m6, m4, m2); +#define BLAKE2B_LOAD_MSG_9_3(b0) b0 = _mm256_set_epi64x(m3, m9, m15, m13); +#define BLAKE2B_LOAD_MSG_9_4(b0) b0 = _mm256_set_epi64x(m12, m14, m11, m0); +#define BLAKE2B_LOAD_MSG_10_1(b0) b0 = _mm256_set_epi64x(m6, m4, m2, m0); +#define BLAKE2B_LOAD_MSG_10_2(b0) b0 = _mm256_set_epi64x(m7, m5, m3, m1); +#define BLAKE2B_LOAD_MSG_10_3(b0) b0 = _mm256_set_epi64x(m12, m10, m8, m14); +#define BLAKE2B_LOAD_MSG_10_4(b0) b0 = _mm256_set_epi64x(m13, m11, m9, m15); +#define BLAKE2B_LOAD_MSG_11_1(b0) b0 = _mm256_set_epi64x(m13, m9, m4, m14); +#define BLAKE2B_LOAD_MSG_11_2(b0) b0 = _mm256_set_epi64x(m6, m15, m8, m10); +#define BLAKE2B_LOAD_MSG_11_3(b0) b0 = _mm256_set_epi64x(m11, m0, m1, m5); +#define BLAKE2B_LOAD_MSG_11_4(b0) b0 = _mm256_set_epi64x(m7, m2, m12, m3); + +#endif + diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2.h new file mode 100644 index 000000000..28278f408 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b-load-avx2.h @@ -0,0 +1,340 @@ +#ifndef BLAKE2_AVX2_BLAKE2B_LOAD_AVX2_H +#define BLAKE2_AVX2_BLAKE2B_LOAD_AVX2_H + +#define BLAKE2B_LOAD_MSG_0_1(b0) do { \ + t0 = _mm256_unpacklo_epi64(m0, m1); \ + t1 = _mm256_unpacklo_epi64(m2, m3); \ + b0 = _mm256_blend_epi32(t0, t1, 0xF0); \ +} while(0) + +#define BLAKE2B_LOAD_MSG_0_2(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m0, m1);\ +t1 = _mm256_unpackhi_epi64(m2, m3);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_0_3(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m7, m4);\ +t1 = _mm256_unpacklo_epi64(m5, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_0_4(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m7, m4);\ +t1 = _mm256_unpackhi_epi64(m5, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_1_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m7, m2);\ +t1 = _mm256_unpackhi_epi64(m4, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_1_2(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m5, m4);\ +t1 = _mm256_alignr_epi8(m3, m7, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_1_3(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m2, m0);\ +t1 = _mm256_blend_epi32(m5, m0, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_1_4(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m6, m1, 8);\ +t1 = _mm256_blend_epi32(m3, m1, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_2_1(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m6, m5, 8);\ +t1 = _mm256_unpackhi_epi64(m2, m7);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_2_2(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m4, m0);\ +t1 = _mm256_blend_epi32(m6, m1, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_2_3(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m5, m4, 8);\ +t1 = _mm256_unpackhi_epi64(m1, m3);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_2_4(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m2, m7);\ +t1 = _mm256_blend_epi32(m0, m3, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_3_1(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m3, m1);\ +t1 = _mm256_unpackhi_epi64(m6, m5);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_3_2(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m4, m0);\ +t1 = _mm256_unpacklo_epi64(m6, m7);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_3_3(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m1, m7, 8);\ +t1 = _mm256_shuffle_epi32(m2, _MM_SHUFFLE(1,0,3,2));\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_3_4(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m4, m3);\ +t1 = _mm256_unpacklo_epi64(m5, m0);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_4_1(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m4, m2);\ +t1 = _mm256_unpacklo_epi64(m1, m5);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_4_2(b0) \ +do { \ +t0 = _mm256_blend_epi32(m3, m0, 0x33);\ +t1 = _mm256_blend_epi32(m7, m2, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_4_3(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m7, m1, 8);\ +t1 = _mm256_alignr_epi8(m3, m5, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_4_4(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m6, m0);\ +t1 = _mm256_unpacklo_epi64(m6, m4);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_5_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m1, m3);\ +t1 = _mm256_unpacklo_epi64(m0, m4);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_5_2(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m6, m5);\ +t1 = _mm256_unpackhi_epi64(m5, m1);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_5_3(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m2, m0, 8);\ +t1 = _mm256_unpackhi_epi64(m3, m7);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_5_4(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m4, m6);\ +t1 = _mm256_alignr_epi8(m7, m2, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_6_1(b0) \ +do { \ +t0 = _mm256_blend_epi32(m0, m6, 0x33);\ +t1 = _mm256_unpacklo_epi64(m7, m2);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_6_2(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m2, m7);\ +t1 = _mm256_alignr_epi8(m5, m6, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_6_3(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m4, m0);\ +t1 = _mm256_blend_epi32(m4, m3, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_6_4(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m5, m3);\ +t1 = _mm256_shuffle_epi32(m1, _MM_SHUFFLE(1,0,3,2));\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_7_1(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m6, m3);\ +t1 = _mm256_blend_epi32(m1, m6, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_7_2(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m7, m5, 8);\ +t1 = _mm256_unpackhi_epi64(m0, m4);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_7_3(b0) \ +do { \ +t0 = _mm256_blend_epi32(m2, m1, 0x33);\ +t1 = _mm256_alignr_epi8(m4, m7, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_7_4(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m5, m0);\ +t1 = _mm256_unpacklo_epi64(m2, m3);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_8_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m3, m7);\ +t1 = _mm256_alignr_epi8(m0, m5, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_8_2(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m7, m4);\ +t1 = _mm256_alignr_epi8(m4, m1, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_8_3(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m5, m6);\ +t1 = _mm256_unpackhi_epi64(m6, m0);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_8_4(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m1, m2, 8);\ +t1 = _mm256_alignr_epi8(m2, m3, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_9_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m5, m4);\ +t1 = _mm256_unpackhi_epi64(m3, m0);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_9_2(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m1, m2);\ +t1 = _mm256_blend_epi32(m2, m3, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_9_3(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m6, m7);\ +t1 = _mm256_unpackhi_epi64(m4, m1);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_9_4(b0) \ +do { \ +t0 = _mm256_blend_epi32(m5, m0, 0x33);\ +t1 = _mm256_unpacklo_epi64(m7, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_10_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m0, m1);\ +t1 = _mm256_unpacklo_epi64(m2, m3);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_10_2(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m0, m1);\ +t1 = _mm256_unpackhi_epi64(m2, m3);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_10_3(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m7, m4);\ +t1 = _mm256_unpacklo_epi64(m5, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_10_4(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m7, m4);\ +t1 = _mm256_unpackhi_epi64(m5, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_11_1(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m7, m2);\ +t1 = _mm256_unpackhi_epi64(m4, m6);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_11_2(b0) \ +do { \ +t0 = _mm256_unpacklo_epi64(m5, m4);\ +t1 = _mm256_alignr_epi8(m3, m7, 8);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_11_3(b0) \ +do { \ +t0 = _mm256_unpackhi_epi64(m2, m0);\ +t1 = _mm256_blend_epi32(m5, m0, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#define BLAKE2B_LOAD_MSG_11_4(b0) \ +do { \ +t0 = _mm256_alignr_epi8(m6, m1, 8);\ +t1 = _mm256_blend_epi32(m3, m1, 0x33);\ +b0 = _mm256_blend_epi32(t0, t1, 0xF0);\ +} while(0) + +#endif + diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.c b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.c new file mode 100644 index 000000000..d75389e94 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.c @@ -0,0 +1,221 @@ +#include +#include +#include +#include + +#include "blake2.h" +#include "blake2b.h" +#include "blake2b-common.h" + +ALIGN(64) static const uint64_t blake2b_IV[8] = { + UINT64_C(0x6A09E667F3BCC908), UINT64_C(0xBB67AE8584CAA73B), + UINT64_C(0x3C6EF372FE94F82B), UINT64_C(0xA54FF53A5F1D36F1), + UINT64_C(0x510E527FADE682D1), UINT64_C(0x9B05688C2B3E6C1F), + UINT64_C(0x1F83D9ABFB41BD6B), UINT64_C(0x5BE0CD19137E2179), +}; + +#define BLAKE2B_G1_V1(a, b, c, d, m) do { \ + a = ADD(a, m); \ + a = ADD(a, b); d = XOR(d, a); d = ROT32(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT24(b); \ +} while(0) + +#define BLAKE2B_G2_V1(a, b, c, d, m) do { \ + a = ADD(a, m); \ + a = ADD(a, b); d = XOR(d, a); d = ROT16(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT63(b); \ +} while(0) + +#define BLAKE2B_DIAG_V1(a, b, c, d) do { \ + a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(2,1,0,3)); \ + d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1,0,3,2)); \ + c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(0,3,2,1)); \ +} while(0) + +#define BLAKE2B_UNDIAG_V1(a, b, c, d) do { \ + a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(0,3,2,1)); \ + d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1,0,3,2)); \ + c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(2,1,0,3)); \ +} while(0) + +#if defined(PERMUTE_WITH_SHUFFLES) + #include "blake2b-load-avx2.h" +#elif defined(PERMUTE_WITH_GATHER) +#else + #include "blake2b-load-avx2-simple.h" +#endif + +#if defined(PERMUTE_WITH_GATHER) +ALIGN(64) static const uint32_t indices[12][16] = { + { 0, 2, 4, 6, 1, 3, 5, 7, 14, 8, 10, 12, 15, 9, 11, 13}, + {14, 4, 9, 13, 10, 8, 15, 6, 5, 1, 0, 11, 3, 12, 2, 7}, + {11, 12, 5, 15, 8, 0, 2, 13, 9, 10, 3, 7, 4, 14, 6, 1}, + { 7, 3, 13, 11, 9, 1, 12, 14, 15, 2, 5, 4, 8, 6, 10, 0}, + { 9, 5, 2, 10, 0, 7, 4, 15, 3, 14, 11, 6, 13, 1, 12, 8}, + { 2, 6, 0, 8, 12, 10, 11, 3, 1, 4, 7, 15, 9, 13, 5, 14}, + {12, 1, 14, 4, 5, 15, 13, 10, 8, 0, 6, 9, 11, 7, 3, 2}, + {13, 7, 12, 3, 11, 14, 1, 9, 2, 5, 15, 8, 10, 0, 4, 6}, + { 6, 14, 11, 0, 15, 9, 3, 8, 10, 12, 13, 1, 5, 2, 7, 4}, + {10, 8, 7, 1, 2, 4, 6, 5, 13, 15, 9, 3, 0, 11, 14, 12}, + { 0, 2, 4, 6, 1, 3, 5, 7, 14, 8, 10, 12, 15, 9, 11, 13}, + {14, 4, 9, 13, 10, 8, 15, 6, 5, 1, 0, 11, 3, 12, 2, 7}, +}; + +#define BLAKE2B_ROUND_V1(a, b, c, d, r, m) do { \ + __m256i b0; \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 0]), 8); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 4]), 8); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_DIAG_V1(a, b, c, d); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 8]), 8); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][12]), 8); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2B_ROUNDS_V1(a, b, c, d, m) do { \ + int i; \ + for(i = 0; i < 12; ++i) { \ + BLAKE2B_ROUND_V1(a, b, c, d, i, m); \ + } \ +} while(0) +#else /* !PERMUTE_WITH_GATHER */ +#define BLAKE2B_ROUND_V1(a, b, c, d, r, m) do { \ + __m256i b0; \ + BLAKE2B_LOAD_MSG_ ##r ##_1(b0); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + BLAKE2B_LOAD_MSG_ ##r ##_2(b0); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_DIAG_V1(a, b, c, d); \ + BLAKE2B_LOAD_MSG_ ##r ##_3(b0); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + BLAKE2B_LOAD_MSG_ ##r ##_4(b0); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2B_ROUNDS_V1(a, b, c, d, m) do { \ + BLAKE2B_ROUND_V1(a, b, c, d, 0, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 1, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 2, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 3, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 4, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 5, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 6, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 7, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 8, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 9, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 10, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 11, (m)); \ +} while(0) +#endif + +#if defined(PERMUTE_WITH_GATHER) +#define DECLARE_MESSAGE_WORDS(m) +#elif defined(PERMUTE_WITH_SHUFFLES) +#define DECLARE_MESSAGE_WORDS(m) \ + const __m256i m0 = _mm256_broadcastsi128_si256(LOADU128((m) + 0)); \ + const __m256i m1 = _mm256_broadcastsi128_si256(LOADU128((m) + 16)); \ + const __m256i m2 = _mm256_broadcastsi128_si256(LOADU128((m) + 32)); \ + const __m256i m3 = _mm256_broadcastsi128_si256(LOADU128((m) + 48)); \ + const __m256i m4 = _mm256_broadcastsi128_si256(LOADU128((m) + 64)); \ + const __m256i m5 = _mm256_broadcastsi128_si256(LOADU128((m) + 80)); \ + const __m256i m6 = _mm256_broadcastsi128_si256(LOADU128((m) + 96)); \ + const __m256i m7 = _mm256_broadcastsi128_si256(LOADU128((m) + 112)); \ + __m256i t0, t1; +#else +#define DECLARE_MESSAGE_WORDS(m) \ + const uint64_t m0 = LOADU64((m) + 0); \ + const uint64_t m1 = LOADU64((m) + 8); \ + const uint64_t m2 = LOADU64((m) + 16); \ + const uint64_t m3 = LOADU64((m) + 24); \ + const uint64_t m4 = LOADU64((m) + 32); \ + const uint64_t m5 = LOADU64((m) + 40); \ + const uint64_t m6 = LOADU64((m) + 48); \ + const uint64_t m7 = LOADU64((m) + 56); \ + const uint64_t m8 = LOADU64((m) + 64); \ + const uint64_t m9 = LOADU64((m) + 72); \ + const uint64_t m10 = LOADU64((m) + 80); \ + const uint64_t m11 = LOADU64((m) + 88); \ + const uint64_t m12 = LOADU64((m) + 96); \ + const uint64_t m13 = LOADU64((m) + 104); \ + const uint64_t m14 = LOADU64((m) + 112); \ + const uint64_t m15 = LOADU64((m) + 120); +#endif + +#define BLAKE2B_COMPRESS_V1(a, b, m, t0, t1, f0, f1) do { \ + DECLARE_MESSAGE_WORDS(m) \ + const __m256i iv0 = a; \ + const __m256i iv1 = b; \ + __m256i c = LOAD(&blake2b_IV[0]); \ + __m256i d = XOR( \ + LOAD(&blake2b_IV[4]), \ + _mm256_set_epi64x(f1, f0, t1, t0) \ + ); \ + BLAKE2B_ROUNDS_V1(a, b, c, d, m); \ + a = XOR(a, c); \ + b = XOR(b, d); \ + a = XOR(a, iv0); \ + b = XOR(b, iv1); \ +} while(0) + +int blake2b(uint8_t * out, const uint8_t * in, size_t inlen) { + const __m256i parameter_block = _mm256_set_epi64x(0, 0, 0, 0x01010040UL); + ALIGN(64) uint8_t buffer[BLAKE2B_BLOCKBYTES]; + __m256i a = XOR(LOAD(&blake2b_IV[0]), parameter_block); + __m256i b = LOAD(&blake2b_IV[4]); + uint64_t counter = 0; + do { + const uint64_t flag = (inlen <= BLAKE2B_BLOCKBYTES) ? -1 : 0; + size_t block_size = BLAKE2B_BLOCKBYTES; + if(inlen < BLAKE2B_BLOCKBYTES) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, BLAKE2B_BLOCKBYTES - inlen); + block_size = inlen; + in = buffer; + } + counter += block_size; + BLAKE2B_COMPRESS_V1(a, b, in, counter, 0, flag, 0); + inlen -= block_size; + in += block_size; + } while(inlen > 0); + + STOREU(out + 0, a); + STOREU(out + 32, b); + return 0; +} + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen) { + return blake2b(out, in, (size_t)inlen); +} +#endif + + +#if defined(BLAKE2B_SELFTEST) +#include "blake2-kat.h" +#include +int main(void) { + uint8_t buf[BLAKE2_KAT_LENGTH]; + unsigned long i; + + for(i = 0; i < BLAKE2_KAT_LENGTH; ++i) { + buf[i] = i; + } + + for(i = 0; i < BLAKE2_KAT_LENGTH; ++i) { + uint8_t hash[BLAKE2B_OUTBYTES]; + blake2b( hash, buf, i ); + + if(0 != memcmp( hash, blake2b_kat[i], BLAKE2B_OUTBYTES )) { + printf( "error at %lu", i ); + return -1; + } + } + + puts( "ok" ); + return 0; +} +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.h new file mode 100644 index 000000000..009d3118b --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2b.h @@ -0,0 +1,12 @@ +#ifndef BLAKE2_AVX2_BLAKE2B_H +#define BLAKE2_AVX2_BLAKE2B_H + +#include + +int blake2b(unsigned char * out, const unsigned char * in, size_t inlen); + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen); +#endif + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.c b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.c new file mode 100644 index 000000000..01c01cfff --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.c @@ -0,0 +1,533 @@ +#include +#include +#include +#include + +#include "blake2.h" +#include "blake2bp.h" +#include "blake2b-common.h" + +ALIGN(64) static const uint64_t blake2b_IV[8] = { + UINT64_C(0x6A09E667F3BCC908), UINT64_C(0xBB67AE8584CAA73B), + UINT64_C(0x3C6EF372FE94F82B), UINT64_C(0xA54FF53A5F1D36F1), + UINT64_C(0x510E527FADE682D1), UINT64_C(0x9B05688C2B3E6C1F), + UINT64_C(0x1F83D9ABFB41BD6B), UINT64_C(0x5BE0CD19137E2179), +}; + +ALIGN(64) static const uint32_t blake2b_sigma[12][16] = { + { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480}, + {448, 320, 128, 256, 288, 480, 416, 192, 32, 384, 0, 64, 352, 224, 160, 96}, + {352, 256, 384, 0, 160, 64, 480, 416, 320, 448, 96, 192, 224, 32, 288, 128}, + {224, 288, 96, 32, 416, 384, 352, 448, 64, 192, 160, 320, 128, 0, 480, 256}, + {288, 0, 160, 224, 64, 128, 320, 480, 448, 32, 352, 384, 192, 256, 96, 416}, + { 64, 384, 192, 320, 0, 352, 256, 96, 128, 416, 224, 160, 480, 448, 32, 288}, + {384, 160, 32, 480, 448, 416, 128, 320, 0, 224, 192, 96, 288, 64, 256, 352}, + {416, 352, 224, 448, 384, 32, 96, 288, 160, 0, 480, 128, 256, 192, 64, 320}, + {192, 480, 448, 288, 352, 96, 0, 256, 384, 64, 416, 224, 32, 128, 320, 160}, + {320, 64, 256, 128, 224, 192, 32, 160, 480, 352, 288, 448, 96, 384, 416, 0}, + { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480}, + {448, 320, 128, 256, 288, 480, 416, 192, 32, 384, 0, 64, 352, 224, 160, 96}, +}; + +#define BLAKE2B_G1_V1(a, b, c, d, m) do { \ + a = ADD(a, m); \ + a = ADD(a, b); d = XOR(d, a); d = ROT32(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT24(b); \ +} while(0) + +#define BLAKE2B_G2_V1(a, b, c, d, m) do { \ + a = ADD(a, m); \ + a = ADD(a, b); d = XOR(d, a); d = ROT16(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT63(b); \ +} while(0) + +#define BLAKE2B_DIAG_V1(a, b, c, d) do { \ + a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(2,1,0,3)); \ + d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1,0,3,2)); \ + c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(0,3,2,1)); \ +} while(0) + +#define BLAKE2B_UNDIAG_V1(a, b, c, d) do { \ + a = _mm256_permute4x64_epi64(a, _MM_SHUFFLE(0,3,2,1)); \ + d = _mm256_permute4x64_epi64(d, _MM_SHUFFLE(1,0,3,2)); \ + c = _mm256_permute4x64_epi64(c, _MM_SHUFFLE(2,1,0,3)); \ +} while(0) + +#if defined(PERMUTE_WITH_SHUFFLES) + #include "blake2b-load-avx2.h" +#elif defined(PERMUTE_WITH_GATHER) +#else + #include "blake2b-load-avx2-simple.h" +#endif + +#if defined(PERMUTE_WITH_GATHER) +ALIGN(64) static const uint32_t indices[12][16] = { + { 0, 2, 4, 6, 1, 3, 5, 7, 14, 8, 10, 12, 15, 9, 11, 13}, + {14, 4, 9, 13, 10, 8, 15, 6, 5, 1, 0, 11, 3, 12, 2, 7}, + {11, 12, 5, 15, 8, 0, 2, 13, 9, 10, 3, 7, 4, 14, 6, 1}, + { 7, 3, 13, 11, 9, 1, 12, 14, 15, 2, 5, 4, 8, 6, 10, 0}, + { 9, 5, 2, 10, 0, 7, 4, 15, 3, 14, 11, 6, 13, 1, 12, 8}, + { 2, 6, 0, 8, 12, 10, 11, 3, 1, 4, 7, 15, 9, 13, 5, 14}, + {12, 1, 14, 4, 5, 15, 13, 10, 8, 0, 6, 9, 11, 7, 3, 2}, + {13, 7, 12, 3, 11, 14, 1, 9, 2, 5, 15, 8, 10, 0, 4, 6}, + { 6, 14, 11, 0, 15, 9, 3, 8, 10, 12, 13, 1, 5, 2, 7, 4}, + {10, 8, 7, 1, 2, 4, 6, 5, 13, 15, 9, 3, 0, 11, 14, 12}, + { 0, 2, 4, 6, 1, 3, 5, 7, 14, 8, 10, 12, 15, 9, 11, 13}, + {14, 4, 9, 13, 10, 8, 15, 6, 5, 1, 0, 11, 3, 12, 2, 7}, +}; + +#define BLAKE2B_ROUND_V1(a, b, c, d, r, m) do { \ + __m256i b0; \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 0]), 8); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 4]), 8); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_DIAG_V1(a, b, c, d); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][ 8]), 8); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + b0 = _mm256_i32gather_epi64((void *)(m), LOAD128(&indices[r][12]), 8); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2B_ROUNDS_V1(a, b, c, d, m) do { \ + int i; \ + for(i = 0; i < 12; ++i) { \ + BLAKE2B_ROUND_V1(a, b, c, d, i, m); \ + } \ +} while(0) +#else /* !PERMUTE_WITH_GATHER */ +#define BLAKE2B_ROUND_V1(a, b, c, d, r, m) do { \ + __m256i b0; \ + BLAKE2B_LOAD_MSG_ ##r ##_1(b0); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + BLAKE2B_LOAD_MSG_ ##r ##_2(b0); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_DIAG_V1(a, b, c, d); \ + BLAKE2B_LOAD_MSG_ ##r ##_3(b0); \ + BLAKE2B_G1_V1(a, b, c, d, b0); \ + BLAKE2B_LOAD_MSG_ ##r ##_4(b0); \ + BLAKE2B_G2_V1(a, b, c, d, b0); \ + BLAKE2B_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2B_ROUNDS_V1(a, b, c, d, m) do { \ + BLAKE2B_ROUND_V1(a, b, c, d, 0, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 1, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 2, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 3, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 4, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 5, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 6, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 7, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 8, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 9, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 10, (m)); \ + BLAKE2B_ROUND_V1(a, b, c, d, 11, (m)); \ +} while(0) +#endif + +#if defined(PERMUTE_WITH_GATHER) +#define DECLARE_MESSAGE_WORDS(m) +#elif defined(PERMUTE_WITH_SHUFFLES) +#define DECLARE_MESSAGE_WORDS(m) \ + const __m256i m0 = _mm256_broadcastsi128_si256(LOADU128((m) + 0)); \ + const __m256i m1 = _mm256_broadcastsi128_si256(LOADU128((m) + 16)); \ + const __m256i m2 = _mm256_broadcastsi128_si256(LOADU128((m) + 32)); \ + const __m256i m3 = _mm256_broadcastsi128_si256(LOADU128((m) + 48)); \ + const __m256i m4 = _mm256_broadcastsi128_si256(LOADU128((m) + 64)); \ + const __m256i m5 = _mm256_broadcastsi128_si256(LOADU128((m) + 80)); \ + const __m256i m6 = _mm256_broadcastsi128_si256(LOADU128((m) + 96)); \ + const __m256i m7 = _mm256_broadcastsi128_si256(LOADU128((m) + 112)); \ + __m256i t0, t1; +#else +#define DECLARE_MESSAGE_WORDS(m) \ + const uint64_t m0 = LOADU64((m) + 0); \ + const uint64_t m1 = LOADU64((m) + 8); \ + const uint64_t m2 = LOADU64((m) + 16); \ + const uint64_t m3 = LOADU64((m) + 24); \ + const uint64_t m4 = LOADU64((m) + 32); \ + const uint64_t m5 = LOADU64((m) + 40); \ + const uint64_t m6 = LOADU64((m) + 48); \ + const uint64_t m7 = LOADU64((m) + 56); \ + const uint64_t m8 = LOADU64((m) + 64); \ + const uint64_t m9 = LOADU64((m) + 72); \ + const uint64_t m10 = LOADU64((m) + 80); \ + const uint64_t m11 = LOADU64((m) + 88); \ + const uint64_t m12 = LOADU64((m) + 96); \ + const uint64_t m13 = LOADU64((m) + 104); \ + const uint64_t m14 = LOADU64((m) + 112); \ + const uint64_t m15 = LOADU64((m) + 120); +#endif + +#define BLAKE2B_COMPRESS_V1(a, b, m, t0, t1, f0, f1) do { \ + DECLARE_MESSAGE_WORDS(m) \ + const __m256i iv0 = a; \ + const __m256i iv1 = b; \ + __m256i c = LOAD(&blake2b_IV[0]); \ + __m256i d = XOR( \ + LOAD(&blake2b_IV[4]), \ + _mm256_set_epi64x(f1, f0, t1, t0) \ + ); \ + BLAKE2B_ROUNDS_V1(a, b, c, d, m); \ + a = XOR(a, c); \ + b = XOR(b, d); \ + a = XOR(a, iv0); \ + b = XOR(b, iv1); \ +} while(0) + +/* Compute root node hash; exactly 2 compressions */ +static int blake2b_root(uint8_t * out, const uint8_t in[4 * BLAKE2B_OUTBYTES]) { + const __m256i parameter_block = _mm256_set_epi64x(0, 0x00004001UL, 0, 0x02040040UL); + __m256i a = XOR(LOAD(&blake2b_IV[0]), parameter_block); + __m256i b = LOAD(&blake2b_IV[4]); + + BLAKE2B_COMPRESS_V1(a, b, in + 0, 128, 0, 0, 0); + BLAKE2B_COMPRESS_V1(a, b, in + 128, 256, 0, -1, -1); + + STOREU(out + 0, a); + STOREU(out + 32, b); + return 0; +} + +#if 0 +#define BLAKE2B_G_V4(m, r, i, a, b, c, d) do { \ + a = ADD(a, LOAD((uint8_t const *)(m) + blake2b_sigma[r][2*i+0])); \ + a = ADD(a, b); d = XOR(d, a); d = ROT32(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT24(b); \ + a = ADD(a, LOAD((uint8_t const *)(m) + blake2b_sigma[r][2*i+1])); \ + a = ADD(a, b); d = XOR(d, a); d = ROT16(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT63(b); \ +} while(0) + +#define BLAKE2B_ROUND_V4(v, m, r) do { \ + BLAKE2B_G_V4(m, r, 0, v[ 0], v[ 4], v[ 8], v[12]); \ + BLAKE2B_G_V4(m, r, 1, v[ 1], v[ 5], v[ 9], v[13]); \ + BLAKE2B_G_V4(m, r, 2, v[ 2], v[ 6], v[10], v[14]); \ + BLAKE2B_G_V4(m, r, 3, v[ 3], v[ 7], v[11], v[15]); \ + BLAKE2B_G_V4(m, r, 4, v[ 0], v[ 5], v[10], v[15]); \ + BLAKE2B_G_V4(m, r, 5, v[ 1], v[ 6], v[11], v[12]); \ + BLAKE2B_G_V4(m, r, 6, v[ 2], v[ 7], v[ 8], v[13]); \ + BLAKE2B_G_V4(m, r, 7, v[ 3], v[ 4], v[ 9], v[14]); \ +} while(0) +#else +#define BLAKE2B_ROUND_V4(v, m, r) do { \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 0 + 0])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 1 + 0])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 2 + 0])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 3 + 0])); \ + v[0] = ADD(v[0], v[4]); \ + v[1] = ADD(v[1], v[5]); \ + v[2] = ADD(v[2], v[6]); \ + v[3] = ADD(v[3], v[7]); \ + v[12] = XOR(v[12], v[0]); \ + v[13] = XOR(v[13], v[1]); \ + v[14] = XOR(v[14], v[2]); \ + v[15] = XOR(v[15], v[3]); \ + v[12] = ROT32(v[12]); \ + v[13] = ROT32(v[13]); \ + v[14] = ROT32(v[14]); \ + v[15] = ROT32(v[15]); \ + v[8] = ADD(v[8], v[12]); \ + v[9] = ADD(v[9], v[13]); \ + v[10] = ADD(v[10], v[14]); \ + v[11] = ADD(v[11], v[15]); \ + v[4] = XOR(v[4], v[8]); \ + v[5] = XOR(v[5], v[9]); \ + v[6] = XOR(v[6], v[10]); \ + v[7] = XOR(v[7], v[11]); \ + v[4] = ROT24(v[4]); \ + v[5] = ROT24(v[5]); \ + v[6] = ROT24(v[6]); \ + v[7] = ROT24(v[7]); \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 0 + 1])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 1 + 1])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 2 + 1])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 3 + 1])); \ + v[0] = ADD(v[0], v[4]); \ + v[1] = ADD(v[1], v[5]); \ + v[2] = ADD(v[2], v[6]); \ + v[3] = ADD(v[3], v[7]); \ + v[12] = XOR(v[12], v[0]); \ + v[13] = XOR(v[13], v[1]); \ + v[14] = XOR(v[14], v[2]); \ + v[15] = XOR(v[15], v[3]); \ + v[12] = ROT16(v[12]); \ + v[13] = ROT16(v[13]); \ + v[14] = ROT16(v[14]); \ + v[15] = ROT16(v[15]); \ + v[8] = ADD(v[8], v[12]); \ + v[9] = ADD(v[9], v[13]); \ + v[10] = ADD(v[10], v[14]); \ + v[11] = ADD(v[11], v[15]); \ + v[4] = XOR(v[4], v[8]); \ + v[5] = XOR(v[5], v[9]); \ + v[6] = XOR(v[6], v[10]); \ + v[7] = XOR(v[7], v[11]); \ + v[4] = ROT63(v[4]); \ + v[5] = ROT63(v[5]); \ + v[6] = ROT63(v[6]); \ + v[7] = ROT63(v[7]); \ + \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 4 + 0])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 5 + 0])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 6 + 0])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 7 + 0])); \ + v[0] = ADD(v[0], v[5]); \ + v[1] = ADD(v[1], v[6]); \ + v[2] = ADD(v[2], v[7]); \ + v[3] = ADD(v[3], v[4]); \ + v[15] = XOR(v[15], v[0]); \ + v[12] = XOR(v[12], v[1]); \ + v[13] = XOR(v[13], v[2]); \ + v[14] = XOR(v[14], v[3]); \ + v[15] = ROT32(v[15]); \ + v[12] = ROT32(v[12]); \ + v[13] = ROT32(v[13]); \ + v[14] = ROT32(v[14]); \ + v[10] = ADD(v[10], v[15]); \ + v[11] = ADD(v[11], v[12]); \ + v[8] = ADD(v[8], v[13]); \ + v[9] = ADD(v[9], v[14]); \ + v[5] = XOR(v[5], v[10]); \ + v[6] = XOR(v[6], v[11]); \ + v[7] = XOR(v[7], v[8]); \ + v[4] = XOR(v[4], v[9]); \ + v[5] = ROT24(v[5]); \ + v[6] = ROT24(v[6]); \ + v[7] = ROT24(v[7]); \ + v[4] = ROT24(v[4]); \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 4 + 1])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 5 + 1])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 6 + 1])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2b_sigma[r][2 * 7 + 1])); \ + v[0] = ADD(v[0], v[5]); \ + v[1] = ADD(v[1], v[6]); \ + v[2] = ADD(v[2], v[7]); \ + v[3] = ADD(v[3], v[4]); \ + v[15] = XOR(v[15], v[0]); \ + v[12] = XOR(v[12], v[1]); \ + v[13] = XOR(v[13], v[2]); \ + v[14] = XOR(v[14], v[3]); \ + v[15] = ROT16(v[15]); \ + v[12] = ROT16(v[12]); \ + v[13] = ROT16(v[13]); \ + v[14] = ROT16(v[14]); \ + v[10] = ADD(v[10], v[15]); \ + v[11] = ADD(v[11], v[12]); \ + v[8] = ADD(v[8], v[13]); \ + v[9] = ADD(v[9], v[14]); \ + v[5] = XOR(v[5], v[10]); \ + v[6] = XOR(v[6], v[11]); \ + v[7] = XOR(v[7], v[8]); \ + v[4] = XOR(v[4], v[9]); \ + v[5] = ROT63(v[5]); \ + v[6] = ROT63(v[6]); \ + v[7] = ROT63(v[7]); \ + v[4] = ROT63(v[4]); \ +} while (0) +#endif + +#if defined(PERMUTE_WITH_GATHER) +#define BLAKE2B_LOADMSG_V4(w, m) do { \ + int i; \ + for(i = 0; i < 16; ++i) { \ + w[i] = _mm256_i32gather_epi64( \ + (const void *)((m) + i * sizeof(uint64_t)), \ + _mm_set_epi32(48, 32, 16, 0), \ + sizeof(uint64_t) \ + ); \ + } \ +} while(0) +#else +#define BLAKE2B_PACK_MSG_V4(w, m) do { \ + __m256i t0, t1, t2, t3; \ + t0 = _mm256_unpacklo_epi64(m[ 0], m[ 4]); \ + t1 = _mm256_unpackhi_epi64(m[ 0], m[ 4]); \ + t2 = _mm256_unpacklo_epi64(m[ 8], m[12]); \ + t3 = _mm256_unpackhi_epi64(m[ 8], m[12]); \ + w[ 0] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + w[ 2] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + w[ 1] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + w[ 3] = _mm256_permute2x128_si256(t1, t3, 0x31); \ + t0 = _mm256_unpacklo_epi64(m[ 1], m[ 5]); \ + t1 = _mm256_unpackhi_epi64(m[ 1], m[ 5]); \ + t2 = _mm256_unpacklo_epi64(m[ 9], m[13]); \ + t3 = _mm256_unpackhi_epi64(m[ 9], m[13]); \ + w[ 4] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + w[ 6] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + w[ 5] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + w[ 7] = _mm256_permute2x128_si256(t1, t3, 0x31); \ + t0 = _mm256_unpacklo_epi64(m[ 2], m[ 6]); \ + t1 = _mm256_unpackhi_epi64(m[ 2], m[ 6]); \ + t2 = _mm256_unpacklo_epi64(m[10], m[14]); \ + t3 = _mm256_unpackhi_epi64(m[10], m[14]); \ + w[ 8] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + w[10] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + w[ 9] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + w[11] = _mm256_permute2x128_si256(t1, t3, 0x31); \ + t0 = _mm256_unpacklo_epi64(m[ 3], m[ 7]); \ + t1 = _mm256_unpackhi_epi64(m[ 3], m[ 7]); \ + t2 = _mm256_unpacklo_epi64(m[11], m[15]); \ + t3 = _mm256_unpackhi_epi64(m[11], m[15]); \ + w[12] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + w[14] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + w[13] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + w[15] = _mm256_permute2x128_si256(t1, t3, 0x31); \ +} while(0) + +#define BLAKE2B_LOADMSG_V4(w, m) do { \ + __m256i t[16]; \ + int i; \ + for(i = 0; i < 16; ++i) { \ + t[i] = LOADU((m) + i * 32); \ + } \ + BLAKE2B_PACK_MSG_V4(w, t); \ +} while(0) +#endif + +#define BLAKE2B_UNPACK_STATE_V4(u, v) do { \ + __m256i t0, t1, t2, t3; \ + t0 = _mm256_unpacklo_epi64(v[0], v[1]); \ + t1 = _mm256_unpackhi_epi64(v[0], v[1]); \ + t2 = _mm256_unpacklo_epi64(v[2], v[3]); \ + t3 = _mm256_unpackhi_epi64(v[2], v[3]); \ + u[0] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + u[2] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + u[4] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + u[6] = _mm256_permute2x128_si256(t1, t3, 0x31); \ + t0 = _mm256_unpacklo_epi64(v[4], v[5]); \ + t1 = _mm256_unpackhi_epi64(v[4], v[5]); \ + t2 = _mm256_unpacklo_epi64(v[6], v[7]); \ + t3 = _mm256_unpackhi_epi64(v[6], v[7]); \ + u[1] = _mm256_permute2x128_si256(t0, t2, 0x20); \ + u[3] = _mm256_permute2x128_si256(t1, t3, 0x20); \ + u[5] = _mm256_permute2x128_si256(t0, t2, 0x31); \ + u[7] = _mm256_permute2x128_si256(t1, t3, 0x31); \ +} while(0) + +#define BLAKE2B_COMPRESS_V4(v, m, counter, flag) do { \ + const __m256i flag_mask = _mm256_set_epi64x(-1, 0, 0, 0); \ + __m256i iv[8], w[16]; \ + int i, r; \ + for(i = 0; i < 8; ++i) { \ + iv[i] = v[i]; \ + } \ + v[ 8] = _mm256_set1_epi64x(blake2b_IV[0]); \ + v[ 9] = _mm256_set1_epi64x(blake2b_IV[1]); \ + v[10] = _mm256_set1_epi64x(blake2b_IV[2]); \ + v[11] = _mm256_set1_epi64x(blake2b_IV[3]); \ + v[12] = XOR(_mm256_set1_epi64x(blake2b_IV[4]), counter); \ + v[13] = _mm256_set1_epi64x(blake2b_IV[5]); \ + v[14] = XOR(_mm256_set1_epi64x(blake2b_IV[6]), flag); \ + v[15] = XOR(_mm256_set1_epi64x(blake2b_IV[7]), AND(flag, flag_mask)); \ + BLAKE2B_LOADMSG_V4(w, m); \ + for(r = 0; r < 12; ++r) { \ + BLAKE2B_ROUND_V4(v, w, r); \ + } \ + for(i = 0; i < 8; ++i) { \ + v[i] = XOR(XOR(v[i], v[i+8]), iv[i]); \ + } \ +} while(0) + + +int blake2bp(uint8_t * out, const uint8_t * in, size_t inlen) { + ALIGN(64) uint8_t buffer[4 * BLAKE2B_BLOCKBYTES]; + __m256i v[16], s[8]; + union { + __m256i v; + uint64_t w[4]; + } counter; + int i, lane; + + for(i = 0; i < 8; ++i) { + v[i] = _mm256_set1_epi64x(blake2b_IV[i]); + } + + v[0] = XOR(v[0], _mm256_set1_epi64x(0x02040040UL)); + v[1] = XOR(v[1], _mm256_set_epi64x(3, 2, 1, 0)); + v[2] = XOR(v[2], _mm256_set1_epi64x(0x00004000UL)); + + counter.v = _mm256_setzero_si256(); + do { + size_t block_size = 4 * BLAKE2B_BLOCKBYTES; + const uint8_t * ptr = in; + __m256i x0, x1, x2, x3, x4, f0; + + const __m256i c0 = _mm256_set_epi64x(384, 256, 128, 0); + const __m256i c1 = _mm256_set_epi64x(512+384+1, 512+256+1, 512+128+1, 512+1); + const __m256i c2 = _mm256_setzero_si256(); + const __m256i c3 = _mm256_set1_epi64x(128); + + if(inlen < block_size) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, 4 * BLAKE2B_BLOCKBYTES - inlen); + block_size = inlen; + ptr = buffer; + } + + x0 = _mm256_set1_epi64x(inlen); + x1 = _mm256_cmpgt_epi64(x0, c0); + x2 = _mm256_blendv_epi8(c2, _mm256_sub_epi64(x0, c0), x1); + x3 = _mm256_cmpgt_epi64(x2, c3); + x4 = _mm256_blendv_epi8(x2, c3, x3); + f0 = _mm256_cmpgt_epi64(c1, x0); + + counter.v = _mm256_add_epi64(counter.v, x4); + + BLAKE2B_COMPRESS_V4(v, ptr, counter.v, f0); + in += block_size; + inlen -= block_size; + } while(inlen >= 4 * BLAKE2B_BLOCKBYTES); + + BLAKE2B_UNPACK_STATE_V4(s, v); + + for(lane = 0; lane < 4; ++lane) { + size_t block_size = BLAKE2B_BLOCKBYTES; + const uint8_t * ptr = in; + if(!inlen) break; + if(inlen < block_size) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, BLAKE2B_BLOCKBYTES - inlen); + block_size = inlen; + ptr = buffer; + } + counter.w[lane] += block_size; + BLAKE2B_COMPRESS_V1(s[lane*2+0], s[lane*2+1], ptr, counter.w[lane], 0, -1, -(lane == 3)); + in += block_size; + inlen -= block_size; + } + return blake2b_root(out, (void *)s); +} + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen) { + return blake2bp(out, in, (size_t)inlen); +} +#endif + +#if defined(BLAKE2BP_SELFTEST) +#include "blake2-kat.h" +#include +int main(void) { + uint8_t buf[BLAKE2_KAT_LENGTH]; + unsigned long i; + + for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) { + buf[i] = i; + } + + for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) { + uint8_t hash[BLAKE2B_OUTBYTES]; + blake2bp( hash, buf, i ); + + if( 0 != memcmp( hash, blake2bp_kat[i], BLAKE2B_OUTBYTES ) ) { + printf( "error at %lu", i ); + return -1; + } + } + + puts( "ok" ); + return 0; +} +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.h new file mode 100644 index 000000000..b33a749e3 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2bp.h @@ -0,0 +1,12 @@ +#ifndef BLAKE2_AVX2_BLAKE2BP_H +#define BLAKE2_AVX2_BLAKE2BP_H + +#include + +int blake2bp(unsigned char * out, const unsigned char * in, size_t inlen); + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen); +#endif + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-common.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-common.h new file mode 100644 index 000000000..9ec2a37d9 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-common.h @@ -0,0 +1,68 @@ +#ifndef BLAKE2_AVX2_BLAKE2S_COMMON_H +#define BLAKE2_AVX2_BLAKE2S_COMMON_H + +#include +#include +#include + +#include + +#include "blake2.h" + +#define LOAD128(p) _mm_load_si128( (__m128i *)(p) ) +#define STORE128(p,r) _mm_store_si128((__m128i *)(p), r) + +#define LOADU128(p) _mm_loadu_si128( (__m128i *)(p) ) +#define STOREU128(p,r) _mm_storeu_si128((__m128i *)(p), r) + +static INLINE uint32_t LOADU32(void const * p) { + uint32_t v; + memcpy(&v, p, sizeof v); + return v; +} + +#define TOF(reg) _mm_castsi128_ps((reg)) +#define TOI(reg) _mm_castps_si128((reg)) + +#define ROTATE8128 _mm_set_epi8(12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1) + +#define ROTATE16128 _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2) + + +#define ADD128(a, b) _mm_add_epi32(a, b) +#define SUB128(a, b) _mm_sub_epi32(a, b) + +#define XOR128(a, b) _mm_xor_si128(a, b) +#define AND128(a, b) _mm_and_si128(a, b) +#define OR128(a, b) _mm_or_si128(a, b) + +#define ROT16128(x) _mm_shuffle_epi8((x), ROTATE16128) +#define ROT12128(x) OR128(_mm_srli_epi32((x), 12), _mm_slli_epi32((x), 20)) +#define ROT8128(x) _mm_shuffle_epi8((x), ROTATE8128) +#define ROT7128(x) OR128(_mm_srli_epi32((x), 7), _mm_slli_epi32((x), 25)) + +#define LOAD(p) _mm256_load_si256( (__m256i *)(p) ) +#define STORE(p,r) _mm256_store_si256((__m256i *)(p), r) + +#define LOADU(p) _mm256_loadu_si256( (__m256i *)(p) ) +#define STOREU(p,r) _mm256_storeu_si256((__m256i *)(p), r) + +#define ROTATE8 _mm256_set_epi8(12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1, \ + 12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1) + +#define ROTATE16 _mm256_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2, \ + 13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2) + +#define ADD(a, b) _mm256_add_epi32(a, b) +#define SUB(a, b) _mm256_sub_epi32(a, b) + +#define XOR(a, b) _mm256_xor_si256(a, b) +#define AND(a, b) _mm256_and_si256(a, b) +#define OR(a, b) _mm256_or_si256(a, b) + +#define ROT16(x) _mm256_shuffle_epi8((x), ROTATE16) +#define ROT12(x) _mm256_or_si256(_mm256_srli_epi32((x), 12), _mm256_slli_epi32((x), 20)) +#define ROT8(x) _mm256_shuffle_epi8((x), ROTATE8) +#define ROT7(x) _mm256_or_si256(_mm256_srli_epi32((x), 7), _mm256_slli_epi32((x), 25)) + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse2.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse2.h new file mode 100644 index 000000000..0718a5fc3 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse2.h @@ -0,0 +1,46 @@ +#ifndef BLAKE2_AVX2_BLAKE2S_LOAD_SSE2_H +#define BLAKE2_AVX2_BLAKE2S_LOAD_SSE2_H + +#define BLAKE2S_LOAD_MSG_0_1(buf) buf = _mm_set_epi32(m6,m4,m2,m0) +#define BLAKE2S_LOAD_MSG_0_2(buf) buf = _mm_set_epi32(m7,m5,m3,m1) +#define BLAKE2S_LOAD_MSG_0_3(buf) buf = _mm_set_epi32(m14,m12,m10,m8) +#define BLAKE2S_LOAD_MSG_0_4(buf) buf = _mm_set_epi32(m15,m13,m11,m9) +#define BLAKE2S_LOAD_MSG_1_1(buf) buf = _mm_set_epi32(m13,m9,m4,m14) +#define BLAKE2S_LOAD_MSG_1_2(buf) buf = _mm_set_epi32(m6,m15,m8,m10) +#define BLAKE2S_LOAD_MSG_1_3(buf) buf = _mm_set_epi32(m5,m11,m0,m1) +#define BLAKE2S_LOAD_MSG_1_4(buf) buf = _mm_set_epi32(m3,m7,m2,m12) +#define BLAKE2S_LOAD_MSG_2_1(buf) buf = _mm_set_epi32(m15,m5,m12,m11) +#define BLAKE2S_LOAD_MSG_2_2(buf) buf = _mm_set_epi32(m13,m2,m0,m8) +#define BLAKE2S_LOAD_MSG_2_3(buf) buf = _mm_set_epi32(m9,m7,m3,m10) +#define BLAKE2S_LOAD_MSG_2_4(buf) buf = _mm_set_epi32(m4,m1,m6,m14) +#define BLAKE2S_LOAD_MSG_3_1(buf) buf = _mm_set_epi32(m11,m13,m3,m7) +#define BLAKE2S_LOAD_MSG_3_2(buf) buf = _mm_set_epi32(m14,m12,m1,m9) +#define BLAKE2S_LOAD_MSG_3_3(buf) buf = _mm_set_epi32(m15,m4,m5,m2) +#define BLAKE2S_LOAD_MSG_3_4(buf) buf = _mm_set_epi32(m8,m0,m10,m6) +#define BLAKE2S_LOAD_MSG_4_1(buf) buf = _mm_set_epi32(m10,m2,m5,m9) +#define BLAKE2S_LOAD_MSG_4_2(buf) buf = _mm_set_epi32(m15,m4,m7,m0) +#define BLAKE2S_LOAD_MSG_4_3(buf) buf = _mm_set_epi32(m3,m6,m11,m14) +#define BLAKE2S_LOAD_MSG_4_4(buf) buf = _mm_set_epi32(m13,m8,m12,m1) +#define BLAKE2S_LOAD_MSG_5_1(buf) buf = _mm_set_epi32(m8,m0,m6,m2) +#define BLAKE2S_LOAD_MSG_5_2(buf) buf = _mm_set_epi32(m3,m11,m10,m12) +#define BLAKE2S_LOAD_MSG_5_3(buf) buf = _mm_set_epi32(m1,m15,m7,m4) +#define BLAKE2S_LOAD_MSG_5_4(buf) buf = _mm_set_epi32(m9,m14,m5,m13) +#define BLAKE2S_LOAD_MSG_6_1(buf) buf = _mm_set_epi32(m4,m14,m1,m12) +#define BLAKE2S_LOAD_MSG_6_2(buf) buf = _mm_set_epi32(m10,m13,m15,m5) +#define BLAKE2S_LOAD_MSG_6_3(buf) buf = _mm_set_epi32(m8,m9,m6,m0) +#define BLAKE2S_LOAD_MSG_6_4(buf) buf = _mm_set_epi32(m11,m2,m3,m7) +#define BLAKE2S_LOAD_MSG_7_1(buf) buf = _mm_set_epi32(m3,m12,m7,m13) +#define BLAKE2S_LOAD_MSG_7_2(buf) buf = _mm_set_epi32(m9,m1,m14,m11) +#define BLAKE2S_LOAD_MSG_7_3(buf) buf = _mm_set_epi32(m2,m8,m15,m5) +#define BLAKE2S_LOAD_MSG_7_4(buf) buf = _mm_set_epi32(m10,m6,m4,m0) +#define BLAKE2S_LOAD_MSG_8_1(buf) buf = _mm_set_epi32(m0,m11,m14,m6) +#define BLAKE2S_LOAD_MSG_8_2(buf) buf = _mm_set_epi32(m8,m3,m9,m15) +#define BLAKE2S_LOAD_MSG_8_3(buf) buf = _mm_set_epi32(m10,m1,m13,m12) +#define BLAKE2S_LOAD_MSG_8_4(buf) buf = _mm_set_epi32(m5,m4,m7,m2) +#define BLAKE2S_LOAD_MSG_9_1(buf) buf = _mm_set_epi32(m1,m7,m8,m10) +#define BLAKE2S_LOAD_MSG_9_2(buf) buf = _mm_set_epi32(m5,m6,m4,m2) +#define BLAKE2S_LOAD_MSG_9_3(buf) buf = _mm_set_epi32(m13,m3,m9,m15) +#define BLAKE2S_LOAD_MSG_9_4(buf) buf = _mm_set_epi32(m0,m12,m14,m11) + + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse41.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse41.h new file mode 100644 index 000000000..4f818553b --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2s-load-sse41.h @@ -0,0 +1,216 @@ +#ifndef BLAKE2_AVX2_BLAKE2S_LOAD_SSE41_H +#define BLAKE2_AVX2_BLAKE2S_LOAD_SSE41_H + +#define BLAKE2S_LOAD_MSG_0_1(buf) \ +buf = TOI(_mm_shuffle_ps(TOF(m0), TOF(m1), _MM_SHUFFLE(2,0,2,0))); + +#define BLAKE2S_LOAD_MSG_0_2(buf) \ +buf = TOI(_mm_shuffle_ps(TOF(m0), TOF(m1), _MM_SHUFFLE(3,1,3,1))); + +#define BLAKE2S_LOAD_MSG_0_3(buf) \ +buf = TOI(_mm_shuffle_ps(TOF(m2), TOF(m3), _MM_SHUFFLE(2,0,2,0))); + +#define BLAKE2S_LOAD_MSG_0_4(buf) \ +buf = TOI(_mm_shuffle_ps(TOF(m2), TOF(m3), _MM_SHUFFLE(3,1,3,1))); + +#define BLAKE2S_LOAD_MSG_1_1(buf) \ +t0 = _mm_blend_epi16(m1, m2, 0x0C); \ +t1 = _mm_slli_si128(m3, 4); \ +t2 = _mm_blend_epi16(t0, t1, 0xF0); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,1,0,3)); + +#define BLAKE2S_LOAD_MSG_1_2(buf) \ +t0 = _mm_shuffle_epi32(m2,_MM_SHUFFLE(0,0,2,0)); \ +t1 = _mm_blend_epi16(m1,m3,0xC0); \ +t2 = _mm_blend_epi16(t0, t1, 0xF0); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,3,0,1)); + +#define BLAKE2S_LOAD_MSG_1_3(buf) \ +t0 = _mm_slli_si128(m1, 4); \ +t1 = _mm_blend_epi16(m2, t0, 0x30); \ +t2 = _mm_blend_epi16(m0, t1, 0xF0); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,3,0,1)); + +#define BLAKE2S_LOAD_MSG_1_4(buf) \ +t0 = _mm_unpackhi_epi32(m0,m1); \ +t1 = _mm_slli_si128(m3, 4); \ +t2 = _mm_blend_epi16(t0, t1, 0x0C); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,3,0,1)); + +#define BLAKE2S_LOAD_MSG_2_1(buf) \ +t0 = _mm_unpackhi_epi32(m2,m3); \ +t1 = _mm_blend_epi16(m3,m1,0x0C); \ +t2 = _mm_blend_epi16(t0, t1, 0x0F); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(3,1,0,2)); + +#define BLAKE2S_LOAD_MSG_2_2(buf) \ +t0 = _mm_unpacklo_epi32(m2,m0); \ +t1 = _mm_blend_epi16(t0, m0, 0xF0); \ +t2 = _mm_slli_si128(m3, 8); \ +buf = _mm_blend_epi16(t1, t2, 0xC0); + +#define BLAKE2S_LOAD_MSG_2_3(buf) \ +t0 = _mm_blend_epi16(m0, m2, 0x3C); \ +t1 = _mm_srli_si128(m1, 12); \ +t2 = _mm_blend_epi16(t0,t1,0x03); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(1,0,3,2)); + +#define BLAKE2S_LOAD_MSG_2_4(buf) \ +t0 = _mm_slli_si128(m3, 4); \ +t1 = _mm_blend_epi16(m0, m1, 0x33); \ +t2 = _mm_blend_epi16(t1, t0, 0xC0); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(0,1,2,3)); + +#define BLAKE2S_LOAD_MSG_3_1(buf) \ +t0 = _mm_unpackhi_epi32(m0,m1); \ +t1 = _mm_unpackhi_epi32(t0, m2); \ +t2 = _mm_blend_epi16(t1, m3, 0x0C); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(3,1,0,2)); + +#define BLAKE2S_LOAD_MSG_3_2(buf) \ +t0 = _mm_slli_si128(m2, 8); \ +t1 = _mm_blend_epi16(m3,m0,0x0C); \ +t2 = _mm_blend_epi16(t1, t0, 0xC0); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,0,1,3)); + +#define BLAKE2S_LOAD_MSG_3_3(buf) \ +t0 = _mm_blend_epi16(m0,m1,0x0F); \ +t1 = _mm_blend_epi16(t0, m3, 0xC0); \ +buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE(3,0,1,2)); + +#define BLAKE2S_LOAD_MSG_3_4(buf) \ +t0 = _mm_unpacklo_epi32(m0,m2); \ +t1 = _mm_unpackhi_epi32(m1,m2); \ +buf = _mm_unpacklo_epi64(t1,t0); + +#define BLAKE2S_LOAD_MSG_4_1(buf) \ +t0 = _mm_unpacklo_epi64(m1,m2); \ +t1 = _mm_unpackhi_epi64(m0,m2); \ +t2 = _mm_blend_epi16(t0,t1,0x33); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,0,1,3)); + +#define BLAKE2S_LOAD_MSG_4_2(buf) \ +t0 = _mm_unpackhi_epi64(m1,m3); \ +t1 = _mm_unpacklo_epi64(m0,m1); \ +buf = _mm_blend_epi16(t0,t1,0x33); + +#define BLAKE2S_LOAD_MSG_4_3(buf) \ +t0 = _mm_unpackhi_epi64(m3,m1); \ +t1 = _mm_unpackhi_epi64(m2,m0); \ +buf = _mm_blend_epi16(t1,t0,0x33); + +#define BLAKE2S_LOAD_MSG_4_4(buf) \ +t0 = _mm_blend_epi16(m0,m2,0x03); \ +t1 = _mm_slli_si128(t0, 8); \ +t2 = _mm_blend_epi16(t1,m3,0x0F); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(1,2,0,3)); + +#define BLAKE2S_LOAD_MSG_5_1(buf) \ +t0 = _mm_unpackhi_epi32(m0,m1); \ +t1 = _mm_unpacklo_epi32(m0,m2); \ +buf = _mm_unpacklo_epi64(t0,t1); + +#define BLAKE2S_LOAD_MSG_5_2(buf) \ +t0 = _mm_srli_si128(m2, 4); \ +t1 = _mm_blend_epi16(m0,m3,0x03); \ +buf = _mm_blend_epi16(t1,t0,0x3C); + +#define BLAKE2S_LOAD_MSG_5_3(buf) \ +t0 = _mm_blend_epi16(m1,m0,0x0C); \ +t1 = _mm_srli_si128(m3, 4); \ +t2 = _mm_blend_epi16(t0,t1,0x30); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(1,2,3,0)); + +#define BLAKE2S_LOAD_MSG_5_4(buf) \ +t0 = _mm_unpacklo_epi64(m1,m2); \ +t1= _mm_shuffle_epi32(m3, _MM_SHUFFLE(0,2,0,1)); \ +buf = _mm_blend_epi16(t0,t1,0x33); + +#define BLAKE2S_LOAD_MSG_6_1(buf) \ +t0 = _mm_slli_si128(m1, 12); \ +t1 = _mm_blend_epi16(m0,m3,0x33); \ +buf = _mm_blend_epi16(t1,t0,0xC0); + +#define BLAKE2S_LOAD_MSG_6_2(buf) \ +t0 = _mm_blend_epi16(m3,m2,0x30); \ +t1 = _mm_srli_si128(m1, 4); \ +t2 = _mm_blend_epi16(t0,t1,0x03); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2,1,3,0)); + +#define BLAKE2S_LOAD_MSG_6_3(buf) \ +t0 = _mm_unpacklo_epi64(m0,m2); \ +t1 = _mm_srli_si128(m1, 4); \ +buf = _mm_shuffle_epi32(_mm_blend_epi16(t0,t1,0x0C), _MM_SHUFFLE(2,3,1,0)); + +#define BLAKE2S_LOAD_MSG_6_4(buf) \ +t0 = _mm_unpackhi_epi32(m1,m2); \ +t1 = _mm_unpackhi_epi64(m0,t0); \ +buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE(3,0,1,2)); + +#define BLAKE2S_LOAD_MSG_7_1(buf) \ +t0 = _mm_unpackhi_epi32(m0,m1); \ +t1 = _mm_blend_epi16(t0,m3,0x0F); \ +buf = _mm_shuffle_epi32(t1,_MM_SHUFFLE(2,0,3,1)); + +#define BLAKE2S_LOAD_MSG_7_2(buf) \ +t0 = _mm_blend_epi16(m2,m3,0x30); \ +t1 = _mm_srli_si128(m0,4); \ +t2 = _mm_blend_epi16(t0,t1,0x03); \ +buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE(1,0,2,3)); + +#define BLAKE2S_LOAD_MSG_7_3(buf) \ +t0 = _mm_unpackhi_epi64(m0,m3); \ +t1 = _mm_unpacklo_epi64(m1,m2); \ +t2 = _mm_blend_epi16(t0,t1,0x3C); \ +buf = _mm_shuffle_epi32(t2,_MM_SHUFFLE(0,2,3,1)); + +#define BLAKE2S_LOAD_MSG_7_4(buf) \ +t0 = _mm_unpacklo_epi32(m0,m1); \ +t1 = _mm_unpackhi_epi32(m1,m2); \ +buf = _mm_unpacklo_epi64(t0,t1); + +#define BLAKE2S_LOAD_MSG_8_1(buf) \ +t0 = _mm_unpackhi_epi32(m1,m3); \ +t1 = _mm_unpacklo_epi64(t0,m0); \ +t2 = _mm_blend_epi16(t1,m2,0xC0); \ +buf = _mm_shufflehi_epi16(t2,_MM_SHUFFLE(1,0,3,2)); + +#define BLAKE2S_LOAD_MSG_8_2(buf) \ +t0 = _mm_unpackhi_epi32(m0,m3); \ +t1 = _mm_blend_epi16(m2,t0,0xF0); \ +buf = _mm_shuffle_epi32(t1,_MM_SHUFFLE(0,2,1,3)); + +#define BLAKE2S_LOAD_MSG_8_3(buf) \ +t0 = _mm_blend_epi16(m2,m0,0x0C); \ +t1 = _mm_slli_si128(t0,4); \ +buf = _mm_blend_epi16(t1,m3,0x0F); + +#define BLAKE2S_LOAD_MSG_8_4(buf) \ +t0 = _mm_blend_epi16(m1,m0,0x30); \ +buf = _mm_shuffle_epi32(t0,_MM_SHUFFLE(1,0,3,2)); + +#define BLAKE2S_LOAD_MSG_9_1(buf) \ +t0 = _mm_blend_epi16(m0,m2,0x03); \ +t1 = _mm_blend_epi16(m1,m2,0x30); \ +t2 = _mm_blend_epi16(t1,t0,0x0F); \ +buf = _mm_shuffle_epi32(t2,_MM_SHUFFLE(1,3,0,2)); + +#define BLAKE2S_LOAD_MSG_9_2(buf) \ +t0 = _mm_slli_si128(m0,4); \ +t1 = _mm_blend_epi16(m1,t0,0xC0); \ +buf = _mm_shuffle_epi32(t1,_MM_SHUFFLE(1,2,0,3)); + +#define BLAKE2S_LOAD_MSG_9_3(buf) \ +t0 = _mm_unpackhi_epi32(m0,m3); \ +t1 = _mm_unpacklo_epi32(m2,m3); \ +t2 = _mm_unpackhi_epi64(t0,t1); \ +buf = _mm_shuffle_epi32(t2,_MM_SHUFFLE(3,0,2,1)); + +#define BLAKE2S_LOAD_MSG_9_4(buf) \ +t0 = _mm_blend_epi16(m3,m2,0xC0); \ +t1 = _mm_unpacklo_epi32(m0,m3); \ +t2 = _mm_blend_epi16(t0,t1,0x0F); \ +buf = _mm_shuffle_epi32(t2,_MM_SHUFFLE(0,1,2,3)); + +#endif + diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.c b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.c new file mode 100644 index 000000000..87a7fea2f --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.c @@ -0,0 +1,617 @@ +#include +#include +#include +#include +#include + +#include "blake2.h" +#include "blake2sp.h" +#include "blake2s-common.h" + +#include + +ALIGN(64) static const uint32_t blake2s_IV[8] = { + UINT32_C(0x6A09E667), UINT32_C(0xBB67AE85), + UINT32_C(0x3C6EF372), UINT32_C(0xA54FF53A), + UINT32_C(0x510E527F), UINT32_C(0x9B05688C), + UINT32_C(0x1F83D9AB), UINT32_C(0x5BE0CD19) +}; + +ALIGN(64) static const uint32_t blake2s_sigma[10][16] = { + { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480}, + {448, 320, 128, 256, 288, 480, 416, 192, 32, 384, 0, 64, 352, 224, 160, 96}, + {352, 256, 384, 0, 160, 64, 480, 416, 320, 448, 96, 192, 224, 32, 288, 128}, + {224, 288, 96, 32, 416, 384, 352, 448, 64, 192, 160, 320, 128, 0, 480, 256}, + {288, 0, 160, 224, 64, 128, 320, 480, 448, 32, 352, 384, 192, 256, 96, 416}, + { 64, 384, 192, 320, 0, 352, 256, 96, 128, 416, 224, 160, 480, 448, 32, 288}, + {384, 160, 32, 480, 448, 416, 128, 320, 0, 224, 192, 96, 288, 64, 256, 352}, + {416, 352, 224, 448, 384, 32, 96, 288, 160, 0, 480, 128, 256, 192, 64, 320}, + {192, 480, 448, 288, 352, 96, 0, 256, 384, 64, 416, 224, 32, 128, 320, 160}, + {320, 64, 256, 128, 224, 192, 32, 160, 480, 352, 288, 448, 96, 384, 416, 0}, +}; + +#define BLAKE2S_G1_V1(a, b, c, d, m) do { \ + a = ADD128(a, m); \ + a = ADD128(a, b); d = XOR128(d, a); d = ROT16128(d); \ + c = ADD128(c, d); b = XOR128(b, c); b = ROT12128(b); \ +} while(0) + +#define BLAKE2S_G2_V1(a, b, c, d, m) do { \ + a = ADD128(a, m); \ + a = ADD128(a, b); d = XOR128(d, a); d = ROT8128(d); \ + c = ADD128(c, d); b = XOR128(b, c); b = ROT7128(b); \ +} while(0) + +#define BLAKE2S_DIAG_V1(a, b, c, d) do { \ + d = _mm_shuffle_epi32(d, _MM_SHUFFLE(2,1,0,3)); \ + c = _mm_shuffle_epi32(c, _MM_SHUFFLE(1,0,3,2)); \ + b = _mm_shuffle_epi32(b, _MM_SHUFFLE(0,3,2,1)); \ +} while(0) + +#define BLAKE2S_UNDIAG_V1(a, b, c, d) do { \ + d = _mm_shuffle_epi32(d, _MM_SHUFFLE(0,3,2,1)); \ + c = _mm_shuffle_epi32(c, _MM_SHUFFLE(1,0,3,2)); \ + b = _mm_shuffle_epi32(b, _MM_SHUFFLE(2,1,0,3)); \ +} while(0) + +#if defined(PERMUTE_WITH_SHUFFLES) + #include "blake2s-load-sse41.h" +#elif defined(PERMUTE_WITH_GATHER) +#else + #include "blake2s-load-sse2.h" +#endif + +#if defined(PERMUTE_WITH_GATHER) +ALIGN(64) static const uint32_t indices[12][16] = { + { 0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15}, + {14, 4, 9, 13,10, 8, 15, 6, 1, 0, 11, 5,12, 2, 7, 3}, + {11, 12, 5, 15, 8, 0, 2, 13,10, 3, 7, 9,14, 6, 1, 4}, + { 7, 3, 13, 11, 9, 1, 12, 14, 2, 5, 4, 15, 6, 10, 0, 8}, + { 9, 5, 2, 10, 0, 7, 4, 15,14, 11, 6, 3, 1, 12, 8, 13}, + { 2, 6, 0, 8,12, 10, 11, 3, 4, 7, 15, 1,13, 5, 14, 9}, + {12, 1, 14, 4, 5, 15, 13, 10, 0, 6, 9, 8, 7, 3, 2, 11}, + {13, 7, 12, 3,11, 14, 1, 9, 5, 15, 8, 2, 0, 4, 6, 10}, + { 6, 14, 11, 0,15, 9, 3, 8,12, 13, 1, 10, 2, 7, 4, 5}, + {10, 8, 7, 1, 2, 4, 6, 5,15, 9, 3, 13,11, 14, 12, 0}, + { 0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15}, + {14, 4, 9, 13,10, 8, 15, 6, 1, 0, 11, 5,12, 2, 7, 3}, +}; + +#define BLAKE2S_ROUND_V1(a, b, c, d, r, m) do { \ + __m128i b0; \ + b0 = _mm_i32gather_epi32((void *)(m), LOAD128(&indices[r][ 0]), 4); \ + BLAKE2S_G1_V1(a, b, c, d, b0); \ + b0 = _mm_i32gather_epi32((void *)(m), LOAD128(&indices[r][ 4]), 4); \ + BLAKE2S_G2_V1(a, b, c, d, b0); \ + BLAKE2S_DIAG_V1(a, b, c, d); \ + b0 = _mm_i32gather_epi32((void *)(m), LOAD128(&indices[r][ 8]), 4); \ + BLAKE2S_G1_V1(a, b, c, d, b0); \ + b0 = _mm_i32gather_epi32((void *)(m), LOAD128(&indices[r][12]), 4); \ + BLAKE2S_G2_V1(a, b, c, d, b0); \ + BLAKE2S_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2S_ROUNDS_V1(a, b, c, d, m) do { \ + int i; \ + for(i = 0; i < 10; ++i) { \ + BLAKE2S_ROUND_V1(a, b, c, d, i, m); \ + } \ +} while(0) +#else /* !PERMUTE_WITH_GATHER */ +#define BLAKE2S_ROUND_V1(a, b, c, d, r, m) do { \ + __m128i b0; \ + BLAKE2S_LOAD_MSG_ ##r ##_1(b0); \ + BLAKE2S_G1_V1(a, b, c, d, b0); \ + BLAKE2S_LOAD_MSG_ ##r ##_2(b0); \ + BLAKE2S_G2_V1(a, b, c, d, b0); \ + BLAKE2S_DIAG_V1(a, b, c, d); \ + BLAKE2S_LOAD_MSG_ ##r ##_3(b0); \ + BLAKE2S_G1_V1(a, b, c, d, b0); \ + BLAKE2S_LOAD_MSG_ ##r ##_4(b0); \ + BLAKE2S_G2_V1(a, b, c, d, b0); \ + BLAKE2S_UNDIAG_V1(a, b, c, d); \ +} while(0) + +#define BLAKE2S_ROUNDS_V1(a, b, c, d, m) do { \ + BLAKE2S_ROUND_V1(a, b, c, d, 0, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 1, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 2, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 3, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 4, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 5, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 6, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 7, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 8, (m)); \ + BLAKE2S_ROUND_V1(a, b, c, d, 9, (m)); \ +} while(0) +#endif + +#if defined(PERMUTE_WITH_GATHER) +#define DECLARE_MESSAGE_WORDS(m) +#elif defined(PERMUTE_WITH_SHUFFLES) +#define DECLARE_MESSAGE_WORDS(m) \ + const __m128i m0 = LOADU128( (m) + 00 ); \ + const __m128i m1 = LOADU128( (m) + 16 ); \ + const __m128i m2 = LOADU128( (m) + 32 ); \ + const __m128i m3 = LOADU128( (m) + 48 ); \ + __m128i t0, t1, t2; +#else +#define DECLARE_MESSAGE_WORDS(m) \ + const uint32_t m0 = LOADU32((m) + 0); \ + const uint32_t m1 = LOADU32((m) + 4); \ + const uint32_t m2 = LOADU32((m) + 8); \ + const uint32_t m3 = LOADU32((m) + 12); \ + const uint32_t m4 = LOADU32((m) + 16); \ + const uint32_t m5 = LOADU32((m) + 20); \ + const uint32_t m6 = LOADU32((m) + 24); \ + const uint32_t m7 = LOADU32((m) + 28); \ + const uint32_t m8 = LOADU32((m) + 32); \ + const uint32_t m9 = LOADU32((m) + 36); \ + const uint32_t m10 = LOADU32((m) + 40); \ + const uint32_t m11 = LOADU32((m) + 44); \ + const uint32_t m12 = LOADU32((m) + 48); \ + const uint32_t m13 = LOADU32((m) + 52); \ + const uint32_t m14 = LOADU32((m) + 56); \ + const uint32_t m15 = LOADU32((m) + 60); +#endif + +#define BLAKE2S_COMPRESS_V1(a, b, m, t0, t1, f0, f1) do { \ + DECLARE_MESSAGE_WORDS(m) \ + const __m128i iv0 = a; \ + const __m128i iv1 = b; \ + __m128i c = LOAD128(&blake2s_IV[0]); \ + __m128i d = XOR128( \ + LOAD128(&blake2s_IV[4]), \ + _mm_set_epi32(f1, f0, t1, t0) \ + ); \ + BLAKE2S_ROUNDS_V1(a, b, c, d, m); \ + a = XOR128(a, c); \ + b = XOR128(b, d); \ + a = XOR128(a, iv0); \ + b = XOR128(b, iv1); \ +} while(0) + +/* +static int blake2s(uint8_t * out, const uint8_t * in, size_t inlen) { + const __m128i parameter_block = _mm_set_epi32(0, 0, 0, 0x01010020UL); + ALIGN(64) uint8_t buffer[BLAKE2S_BLOCKBYTES]; + __m128i a = XOR128(LOAD128(&blake2s_IV[0]), parameter_block); + __m128i b = LOAD128(&blake2s_IV[4]); + + uint64_t counter = 0; + do { + const uint64_t flag = (inlen <= BLAKE2S_BLOCKBYTES) ? -1 : 0; + size_t block_size = BLAKE2S_BLOCKBYTES; + if(inlen < BLAKE2S_BLOCKBYTES) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, BLAKE2S_BLOCKBYTES - inlen); + block_size = inlen; + in = buffer; + } + counter += block_size; + BLAKE2S_COMPRESS_V1(a, b, in, (counter & 0xFFFFFFFF), (counter >> 32), flag, 0); + inlen -= block_size; + in += block_size; + } while(inlen > 0); + + STOREU128(out + 0, a); + STOREU128(out + 16, b); + return 0; +} +*/ + +/* Compute root node hash; exactly 4 compressions */ +static int blake2s_root(uint8_t * out, const uint8_t in[8 * BLAKE2S_OUTBYTES]) { + const __m128i parameter_block = _mm_set_epi32(0x20010000, 0, 0, 0x02080020UL); + __m128i a = XOR128(LOAD128(&blake2s_IV[0]), parameter_block); + __m128i b = LOAD128(&blake2s_IV[4]); + int i; + for(i = 0; i < 4; ++i) { + const uint64_t counter = BLAKE2S_BLOCKBYTES * (i + 1); + const uint32_t flag = (i == 3) ? -1 : 0; + BLAKE2S_COMPRESS_V1(a, b, in, (counter & 0xFFFFFFFF), (counter >> 32), flag, flag); + in += BLAKE2S_BLOCKBYTES; + } + STOREU128(out + 0, a); + STOREU128(out + 16, b); + return 0; +} + +#if 0 +#define BLAKE2S_G_V8(m, r, i, a, b, c, d) do { \ + a = ADD(a, LOAD((uint8_t const *)(m) + blake2s_sigma[r][2*i+0])); \ + a = ADD(a, b); d = XOR(d, a); d = ROT16(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT12(b); \ + a = ADD(a, LOAD((uint8_t const *)(m) + blake2s_sigma[r][2*i+1])); \ + a = ADD(a, b); d = XOR(d, a); d = ROT8(d); \ + c = ADD(c, d); b = XOR(b, c); b = ROT7(b); \ +} while(0) + +#define BLAKE2S_ROUND_V8(v, m, r) do { \ + BLAKE2S_G_V8(m, r, 0, v[ 0], v[ 4], v[ 8], v[12]); \ + BLAKE2S_G_V8(m, r, 1, v[ 1], v[ 5], v[ 9], v[13]); \ + BLAKE2S_G_V8(m, r, 2, v[ 2], v[ 6], v[10], v[14]); \ + BLAKE2S_G_V8(m, r, 3, v[ 3], v[ 7], v[11], v[15]); \ + BLAKE2S_G_V8(m, r, 4, v[ 0], v[ 5], v[10], v[15]); \ + BLAKE2S_G_V8(m, r, 5, v[ 1], v[ 6], v[11], v[12]); \ + BLAKE2S_G_V8(m, r, 6, v[ 2], v[ 7], v[ 8], v[13]); \ + BLAKE2S_G_V8(m, r, 7, v[ 3], v[ 4], v[ 9], v[14]); \ +} while(0) +#else +#define BLAKE2S_ROUND_V8(v, m, r) do { \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 0 + 0])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 1 + 0])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 2 + 0])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 3 + 0])); \ + v[0] = ADD(v[0], v[4]); \ + v[1] = ADD(v[1], v[5]); \ + v[2] = ADD(v[2], v[6]); \ + v[3] = ADD(v[3], v[7]); \ + v[12] = XOR(v[12], v[0]); \ + v[13] = XOR(v[13], v[1]); \ + v[14] = XOR(v[14], v[2]); \ + v[15] = XOR(v[15], v[3]); \ + v[12] = ROT16(v[12]); \ + v[13] = ROT16(v[13]); \ + v[14] = ROT16(v[14]); \ + v[15] = ROT16(v[15]); \ + v[8] = ADD(v[8], v[12]); \ + v[9] = ADD(v[9], v[13]); \ + v[10] = ADD(v[10], v[14]); \ + v[11] = ADD(v[11], v[15]); \ + v[4] = XOR(v[4], v[8]); \ + v[5] = XOR(v[5], v[9]); \ + v[6] = XOR(v[6], v[10]); \ + v[7] = XOR(v[7], v[11]); \ + v[4] = ROT12(v[4]); \ + v[5] = ROT12(v[5]); \ + v[6] = ROT12(v[6]); \ + v[7] = ROT12(v[7]); \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 0 + 1])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 1 + 1])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 2 + 1])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 3 + 1])); \ + v[0] = ADD(v[0], v[4]); \ + v[1] = ADD(v[1], v[5]); \ + v[2] = ADD(v[2], v[6]); \ + v[3] = ADD(v[3], v[7]); \ + v[12] = XOR(v[12], v[0]); \ + v[13] = XOR(v[13], v[1]); \ + v[14] = XOR(v[14], v[2]); \ + v[15] = XOR(v[15], v[3]); \ + v[12] = ROT8(v[12]); \ + v[13] = ROT8(v[13]); \ + v[14] = ROT8(v[14]); \ + v[15] = ROT8(v[15]); \ + v[8] = ADD(v[8], v[12]); \ + v[9] = ADD(v[9], v[13]); \ + v[10] = ADD(v[10], v[14]); \ + v[11] = ADD(v[11], v[15]); \ + v[4] = XOR(v[4], v[8]); \ + v[5] = XOR(v[5], v[9]); \ + v[6] = XOR(v[6], v[10]); \ + v[7] = XOR(v[7], v[11]); \ + v[4] = ROT7(v[4]); \ + v[5] = ROT7(v[5]); \ + v[6] = ROT7(v[6]); \ + v[7] = ROT7(v[7]); \ + \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 4 + 0])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 5 + 0])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 6 + 0])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 7 + 0])); \ + v[0] = ADD(v[0], v[5]); \ + v[1] = ADD(v[1], v[6]); \ + v[2] = ADD(v[2], v[7]); \ + v[3] = ADD(v[3], v[4]); \ + v[15] = XOR(v[15], v[0]); \ + v[12] = XOR(v[12], v[1]); \ + v[13] = XOR(v[13], v[2]); \ + v[14] = XOR(v[14], v[3]); \ + v[15] = ROT16(v[15]); \ + v[12] = ROT16(v[12]); \ + v[13] = ROT16(v[13]); \ + v[14] = ROT16(v[14]); \ + v[10] = ADD(v[10], v[15]); \ + v[11] = ADD(v[11], v[12]); \ + v[8] = ADD(v[8], v[13]); \ + v[9] = ADD(v[9], v[14]); \ + v[5] = XOR(v[5], v[10]); \ + v[6] = XOR(v[6], v[11]); \ + v[7] = XOR(v[7], v[8]); \ + v[4] = XOR(v[4], v[9]); \ + v[5] = ROT12(v[5]); \ + v[6] = ROT12(v[6]); \ + v[7] = ROT12(v[7]); \ + v[4] = ROT12(v[4]); \ + v[0] = ADD(v[0], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 4 + 1])); \ + v[1] = ADD(v[1], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 5 + 1])); \ + v[2] = ADD(v[2], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 6 + 1])); \ + v[3] = ADD(v[3], LOAD((uint8_t const *)(m) + blake2s_sigma[r][2 * 7 + 1])); \ + v[0] = ADD(v[0], v[5]); \ + v[1] = ADD(v[1], v[6]); \ + v[2] = ADD(v[2], v[7]); \ + v[3] = ADD(v[3], v[4]); \ + v[15] = XOR(v[15], v[0]); \ + v[12] = XOR(v[12], v[1]); \ + v[13] = XOR(v[13], v[2]); \ + v[14] = XOR(v[14], v[3]); \ + v[15] = ROT8(v[15]); \ + v[12] = ROT8(v[12]); \ + v[13] = ROT8(v[13]); \ + v[14] = ROT8(v[14]); \ + v[10] = ADD(v[10], v[15]); \ + v[11] = ADD(v[11], v[12]); \ + v[8] = ADD(v[8], v[13]); \ + v[9] = ADD(v[9], v[14]); \ + v[5] = XOR(v[5], v[10]); \ + v[6] = XOR(v[6], v[11]); \ + v[7] = XOR(v[7], v[8]); \ + v[4] = XOR(v[4], v[9]); \ + v[5] = ROT7(v[5]); \ + v[6] = ROT7(v[6]); \ + v[7] = ROT7(v[7]); \ + v[4] = ROT7(v[4]); \ +} while (0) +#endif + +#if defined(PERMUTE_WITH_GATHER) +#define BLAKE2S_LOADMSG_V8(w, m) do { \ + int i; \ + for(i = 0; i < 16; ++i) { \ + w[i] = _mm256_i32gather_epi32( \ + (const void *)((m) + i * sizeof(uint32_t)), \ + _mm256_set_epi32(112, 96, 80, 64, 48, 32, 16, 0), \ + sizeof(uint32_t) \ + ); \ + } \ +} while(0) +#else + +#define BLAKE2S_PACK_MSG_V8(w, m) do { \ + __m256i t0, t1, t2, t3, t4, t5, t6, t7; \ + __m256i s0, s1, s2, s3; \ + \ + t0 = _mm256_unpacklo_epi32(m[ 0], m[ 2]); \ + t1 = _mm256_unpackhi_epi32(m[ 0], m[ 2]); \ + t2 = _mm256_unpacklo_epi32(m[ 4], m[ 6]); \ + t3 = _mm256_unpackhi_epi32(m[ 4], m[ 6]); \ + t4 = _mm256_unpacklo_epi32(m[ 8], m[10]); \ + t5 = _mm256_unpackhi_epi32(m[ 8], m[10]); \ + t6 = _mm256_unpacklo_epi32(m[12], m[14]); \ + t7 = _mm256_unpackhi_epi32(m[12], m[14]); \ + \ + s0 = _mm256_unpacklo_epi64(t0, t2); \ + s1 = _mm256_unpackhi_epi64(t0, t2); \ + s2 = _mm256_unpacklo_epi64(t4, t6); \ + s3 = _mm256_unpackhi_epi64(t4, t6); \ + \ + w[0] = _mm256_permute2x128_si256(s0, s2, 0x20); \ + w[4] = _mm256_permute2x128_si256(s0, s2, 0x31); \ + w[1] = _mm256_permute2x128_si256(s1, s3, 0x20); \ + w[5] = _mm256_permute2x128_si256(s1, s3, 0x31); \ + \ + s0 = _mm256_unpacklo_epi64(t1, t3); \ + s1 = _mm256_unpackhi_epi64(t1, t3); \ + s2 = _mm256_unpacklo_epi64(t5, t7); \ + s3 = _mm256_unpackhi_epi64(t5, t7); \ + \ + w[2] = _mm256_permute2x128_si256(s0, s2, 0x20); \ + w[6] = _mm256_permute2x128_si256(s0, s2, 0x31); \ + w[3] = _mm256_permute2x128_si256(s1, s3, 0x20); \ + w[7] = _mm256_permute2x128_si256(s1, s3, 0x31); \ + \ + t0 = _mm256_unpacklo_epi32(m[ 1], m[ 3]); \ + t1 = _mm256_unpackhi_epi32(m[ 1], m[ 3]); \ + t2 = _mm256_unpacklo_epi32(m[ 5], m[ 7]); \ + t3 = _mm256_unpackhi_epi32(m[ 5], m[ 7]); \ + t4 = _mm256_unpacklo_epi32(m[ 9], m[11]); \ + t5 = _mm256_unpackhi_epi32(m[ 9], m[11]); \ + t6 = _mm256_unpacklo_epi32(m[13], m[15]); \ + t7 = _mm256_unpackhi_epi32(m[13], m[15]); \ + \ + s0 = _mm256_unpacklo_epi64(t0, t2); \ + s1 = _mm256_unpackhi_epi64(t0, t2); \ + s2 = _mm256_unpacklo_epi64(t4, t6); \ + s3 = _mm256_unpackhi_epi64(t4, t6); \ + \ + w[ 8] = _mm256_permute2x128_si256(s0, s2, 0x20); \ + w[12] = _mm256_permute2x128_si256(s0, s2, 0x31); \ + w[ 9] = _mm256_permute2x128_si256(s1, s3, 0x20); \ + w[13] = _mm256_permute2x128_si256(s1, s3, 0x31); \ + \ + s0 = _mm256_unpacklo_epi64(t1, t3); \ + s1 = _mm256_unpackhi_epi64(t1, t3); \ + s2 = _mm256_unpacklo_epi64(t5, t7); \ + s3 = _mm256_unpackhi_epi64(t5, t7); \ + \ + w[10] = _mm256_permute2x128_si256(s0, s2, 0x20); \ + w[14] = _mm256_permute2x128_si256(s0, s2, 0x31); \ + w[11] = _mm256_permute2x128_si256(s1, s3, 0x20); \ + w[15] = _mm256_permute2x128_si256(s1, s3, 0x31); \ +} while(0) + +#define BLAKE2S_LOADMSG_V8(w, m) do { \ + __m256i t[16]; \ + int i; \ + for(i = 0; i < 16; ++i) { \ + t[i] = LOADU((m) + i * 32); \ + } \ + BLAKE2S_PACK_MSG_V8(w, t); \ +} while(0) +#endif + +#define BLAKE2S_UNPACK_STATE_V8(u, v) do { \ + __m256i t0, t1, t2, t3, t4, t5, t6, t7; \ + __m256i s0, s1, s2, s3, s4, s5, s6, s7; \ + t0 = _mm256_unpacklo_epi32(v[0], v[1]); \ + t1 = _mm256_unpackhi_epi32(v[0], v[1]); \ + t2 = _mm256_unpacklo_epi32(v[2], v[3]); \ + t3 = _mm256_unpackhi_epi32(v[2], v[3]); \ + t4 = _mm256_unpacklo_epi32(v[4], v[5]); \ + t5 = _mm256_unpackhi_epi32(v[4], v[5]); \ + t6 = _mm256_unpacklo_epi32(v[6], v[7]); \ + t7 = _mm256_unpackhi_epi32(v[6], v[7]); \ + \ + s0 = _mm256_unpacklo_epi64(t0, t2); \ + s1 = _mm256_unpackhi_epi64(t0, t2); \ + s2 = _mm256_unpacklo_epi64(t1, t3); \ + s3 = _mm256_unpackhi_epi64(t1, t3); \ + s4 = _mm256_unpacklo_epi64(t4, t6); \ + s5 = _mm256_unpackhi_epi64(t4, t6); \ + s6 = _mm256_unpacklo_epi64(t5, t7); \ + s7 = _mm256_unpackhi_epi64(t5, t7); \ + \ + u[0] = _mm256_permute2x128_si256(s0, s4, 0x20); \ + u[1] = _mm256_permute2x128_si256(s1, s5, 0x20); \ + u[2] = _mm256_permute2x128_si256(s2, s6, 0x20); \ + u[3] = _mm256_permute2x128_si256(s3, s7, 0x20); \ + u[4] = _mm256_permute2x128_si256(s0, s4, 0x31); \ + u[5] = _mm256_permute2x128_si256(s1, s5, 0x31); \ + u[6] = _mm256_permute2x128_si256(s2, s6, 0x31); \ + u[7] = _mm256_permute2x128_si256(s3, s7, 0x31); \ +} while(0) + +#define BLAKE2S_COMPRESS_V8(v, m, t0, t1, f0) do { \ + const __m256i flag_mask = _mm256_set_epi32(-1, 0, 0, 0, 0, 0, 0, 0); \ + __m256i iv[8], w[16]; \ + int i, r; \ + for(i = 0; i < 8; ++i) { \ + iv[i] = v[i]; \ + } \ + v[ 8] = _mm256_set1_epi32(blake2s_IV[0]); \ + v[ 9] = _mm256_set1_epi32(blake2s_IV[1]); \ + v[10] = _mm256_set1_epi32(blake2s_IV[2]); \ + v[11] = _mm256_set1_epi32(blake2s_IV[3]); \ + v[12] = XOR(_mm256_set1_epi32(blake2s_IV[4]), t0); \ + v[13] = XOR(_mm256_set1_epi32(blake2s_IV[5]), t1); \ + v[14] = XOR(_mm256_set1_epi32(blake2s_IV[6]), f0); \ + v[15] = XOR(_mm256_set1_epi32(blake2s_IV[7]), AND(f0, flag_mask)); \ + BLAKE2S_LOADMSG_V8(w, m); \ + for(r = 0; r < 10; ++r) { \ + BLAKE2S_ROUND_V8(v, w, r); \ + } \ + for(i = 0; i < 8; ++i) { \ + v[i] = XOR(XOR(v[i], v[i+8]), iv[i]); \ + } \ +} while(0) + + +int blake2sp(uint8_t * out, const uint8_t * in, size_t inlen) { + ALIGN(64) uint8_t buffer[8 * BLAKE2S_BLOCKBYTES]; + __m256i v[16]; + union { + __m256i t[8]; + __m128i s[2*8]; + } lanes; + union { + __m256i v; + uint32_t w[8]; + } counterl = { 0 }, counterh = { 0 }; + int i, lane; + + for(i = 0; i < 8; ++i) { + v[i] = _mm256_set1_epi32(blake2s_IV[i]); + } + + v[0] = XOR(v[0], _mm256_set1_epi32(0x02080020U)); + v[2] = XOR(v[2], _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0)); + v[3] = XOR(v[3], _mm256_set1_epi32(0x20000000U)); + + do { + size_t block_size = 8 * BLAKE2S_BLOCKBYTES; + const uint8_t * ptr = in; + __m256i x0, x1, x2, x3, x4, x5, f0; + + if(inlen < block_size) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, 8 * BLAKE2S_BLOCKBYTES - inlen); + block_size = inlen; + ptr = buffer; + } + + /* Some adhoc unsigned comparisons */ +#define _mm256_not_si256(x) _mm256_xor_si256((x), _mm256_set1_epi32(-1)) +#define _mm256_cmpge_epu32(x, y) _mm256_cmpeq_epi32((x), _mm256_max_epu32((x), (y))) +#define _mm256_cmple_epu32(x, y) _mm256_cmpge_epu32((y), (x)) +#define _mm256_cmpgt_epu32(x, y) _mm256_not_si256(_mm256_cmple_epu32((x), (y))) +#define _mm256_cmplt_epu32(x, y) _mm256_cmpgt_epu32((y), (x)) + + x0 = _mm256_set1_epi32(inlen & 0xFFFFFFFFUL); + x1 = _mm256_set1_epi32(inlen / (1ULL << 32)); + /* x2 = inlen < 2^32 ? -1 : 0 */ + x2 = _mm256_cmpeq_epi32(x1, _mm256_setzero_si256()); + /* x3 = inlen > {448, ..., 0} ? -1 : 0 */ + x3 = _mm256_cmpge_epu32(x0, _mm256_set_epi32(448+1, 384+1, 320+1, 256+1, 192+1, 128+1, 64+1, 0+1)); + /* if inlen > {448, ..., 0}, inlen - {448, ..., 0} */ + /* otherwise 0 */ + x4 = _mm256_and_si256(x3, _mm256_sub_epi32(x0, _mm256_set_epi32(448, 384, 320, 256, 192, 128, 64, 0))); + /* if inlen >= 2^32, we want 64 no matter what */ + /* if inlen < 2^32, we want min(x3, 64) */ + x5 = _mm256_xor_si256(_mm256_and_si256(x2, _mm256_min_epu32(x4, _mm256_set1_epi32(64))), + _mm256_andnot_si256(x2, _mm256_set1_epi32(64))); + + /* if inlen >= 2^32, we want 0 */ + /* if inlen < 2^32, we want the comparison */ + f0 = _mm256_cmpge_epu32(_mm256_set_epi32(512+448, 512+384, 512+320, 512+256, 512+192, 512+128, 512+64, 512+0), x0); + f0 = _mm256_and_si256(f0, x2); + + counterl.v = _mm256_add_epi32(counterl.v, x5); + counterh.v = _mm256_sub_epi32(counterh.v, _mm256_cmplt_epu32(counterl.v, x5)); /* ch -= cl < x5 ? -1 : 0 */ + BLAKE2S_COMPRESS_V8(v, ptr, counterl.v, counterh.v, f0); + in += block_size; + inlen -= block_size; + } while(inlen >= 8 * BLAKE2S_BLOCKBYTES); + + BLAKE2S_UNPACK_STATE_V8(lanes.t, v); + + for(lane = 0; lane < 8; ++lane) { + size_t block_size = BLAKE2S_BLOCKBYTES; + const uint8_t * ptr = in; + if(!inlen) break; + if(inlen < block_size) { + memcpy(buffer, in, inlen); + memset(buffer + inlen, 0, BLAKE2S_BLOCKBYTES - inlen); + block_size = inlen; + ptr = buffer; + } + counterl.w[lane] += block_size; + counterh.w[lane] += counterl.w[lane] < block_size; + BLAKE2S_COMPRESS_V1(lanes.s[lane*2+0], lanes.s[lane*2+1], ptr, counterl.w[lane], counterh.w[lane], -1, -(lane == 7)); + in += block_size; + inlen -= block_size; + } + return blake2s_root(out, (void *)lanes.s); +} + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen) { + return blake2sp(out, in, (size_t)inlen); +} +#endif + +#if defined(BLAKE2SP_SELFTEST) +#include "blake2-kat.h" +#include +int main(void) { + uint8_t buf[BLAKE2_KAT_LENGTH]; + unsigned long i; + + for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) { + buf[i] = i; + } + + for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) { + uint8_t hash[BLAKE2S_OUTBYTES]; + blake2sp( hash, buf, i ); + + if( 0 != memcmp( hash, blake2sp_kat[i], BLAKE2S_OUTBYTES ) ) { + printf( "error at %lu", i ); + return -1; + } + } + + puts( "ok" ); + return 0; +} +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.h b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.h new file mode 100644 index 000000000..709df2b48 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/blake2-avx2/blake2sp.h @@ -0,0 +1,12 @@ +#ifndef BLAKE2_AVX2_BLAKE2SP_H +#define BLAKE2_AVX2_BLAKE2SP_H + +#include + +int blake2sp(unsigned char * out, const unsigned char * in, size_t inlen); + +#if defined(SUPERCOP) +int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen); +#endif + +#endif diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/build.rs b/src/plonk/blake2_const/benches/blake2-avx2-sneves/build.rs new file mode 100644 index 000000000..39793f6f2 --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/build.rs @@ -0,0 +1,20 @@ +fn main() { + // GCC vs Clang and -mavx2 vs -march=native both have big effects on + // performance. We hardcode `clang -mavx2` here for an apples-to-apples + // comparison with rustc and #[target_feature(enable = "avx2")]. + std::env::set_var("CC", "clang"); + cc::Build::new() + .file("./blake2-avx2/blake2b.c") + .file("./blake2-avx2/blake2bp.c") + .file("./blake2-avx2/blake2sp.c") + // The implementation includes two other input loading strategies. + // In my testing, shuffles are the fastest. + // .define("PERMUTE_WITH_NONE", "1") + // .define("PERMUTE_WITH_GATHER", "1") + .define("PERMUTE_WITH_SHUFFLES", "1") + // Enable AVX2 for GCC and Clang. + .flag_if_supported("-mavx2") + // Enable AVX2 for MSVC + .flag_if_supported("/arch:AVX2") + .compile("blake2-avx2"); +} diff --git a/src/plonk/blake2_const/benches/blake2-avx2-sneves/src/lib.rs b/src/plonk/blake2_const/benches/blake2-avx2-sneves/src/lib.rs new file mode 100644 index 000000000..ae609e36b --- /dev/null +++ b/src/plonk/blake2_const/benches/blake2-avx2-sneves/src/lib.rs @@ -0,0 +1,98 @@ +pub fn blake2b(input: &[u8]) -> [u8; 64] { + check_avx2(); + let mut hash = [0u8; 64]; + unsafe { + sys::blake2b(hash.as_mut_ptr(), input.as_ptr(), input.len()); + } + hash +} + +pub fn blake2bp(input: &[u8]) -> [u8; 64] { + check_avx2(); + let mut hash = [0u8; 64]; + unsafe { + sys::blake2bp(hash.as_mut_ptr(), input.as_ptr(), input.len()); + } + hash +} + +pub fn blake2sp(input: &[u8]) -> [u8; 32] { + check_avx2(); + let mut hash = [0u8; 32]; + unsafe { + sys::blake2sp(hash.as_mut_ptr(), input.as_ptr(), input.len()); + } + hash +} + +fn check_avx2() { + if !is_x86_feature_detected!("avx2") { + panic!("AVX2 support is missing") + } +} + +mod sys { + extern "C" { + pub fn blake2b( + out: *mut ::std::os::raw::c_uchar, + in_: *const ::std::os::raw::c_uchar, + inlen: usize, + ) -> ::std::os::raw::c_int; + + pub fn blake2bp( + out: *mut ::std::os::raw::c_uchar, + in_: *const ::std::os::raw::c_uchar, + inlen: usize, + ) -> ::std::os::raw::c_int; + + pub fn blake2sp( + out: *mut ::std::os::raw::c_uchar, + in_: *const ::std::os::raw::c_uchar, + inlen: usize, + ) -> ::std::os::raw::c_int; + } +} + +#[cfg(test)] +mod test { + use super::*; + use serde::{Deserialize, Serialize}; + + #[derive(Debug, Serialize, Deserialize)] + struct TestCase { + hash: String, + #[serde(rename = "in")] + in_: String, + key: String, + out: String, + } + + #[test] + fn test_vectors() { + let test_cases: Vec = + serde_json::from_str(include_str!("../../../tests/blake2-kat.json")).unwrap(); + let mut num = 0; + for case in &test_cases { + let input = hex::decode(&case.in_).unwrap(); + let output = hex::decode(&case.out).unwrap(); + if !case.key.is_empty() { + // These implementations don't have a key parameter. + continue; + } + let mut found = Vec::new(); + match case.hash.as_str() { + "blake2b" => found.extend_from_slice(&blake2b(&input)), + "blake2bp" => found.extend_from_slice(&blake2bp(&input)), + "blake2sp" => found.extend_from_slice(&blake2sp(&input)), + _ => continue, // other hashes not implemented + }; + dbg!(case); + assert_eq!(output, found); + num += 1; + } + assert_eq!( + 768, num, + "make sure we don't accidentally stop running tests" + ); + } +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/.gitignore b/src/plonk/blake2_const/benches/kangarootwelve/.gitignore new file mode 100644 index 000000000..e60994281 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/.gitignore @@ -0,0 +1,4 @@ +/target +**/*.rs.bk +Cargo.lock +K12/bin diff --git a/src/plonk/blake2_const/benches/kangarootwelve/Cargo.toml b/src/plonk/blake2_const/benches/kangarootwelve/Cargo.toml new file mode 100644 index 000000000..b5101f62f --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "kangarootwelve" +version = "0.0.0" +authors = ["Jack O'Connor "] +edition = "2018" + +[dependencies] + +[build-dependencies] + +[dev-dependencies] +hex = "0.3.2" diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile b/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile new file mode 100644 index 000000000..dbf11de8d --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile @@ -0,0 +1,15 @@ +_list: Makefile.build support/Build/ToGlobalMakefile.xsl + +bin/.build/Makefile: bin/.build/Makefile.expanded + mkdir -p $(dir $@) + xsltproc --xinclude -o $@ support/Build/ToGlobalMakefile.xsl $< + +bin/.build/Makefile.expanded: Makefile.build + mkdir -p $(dir $@) + xsltproc --xinclude -o $@ support/Build/ExpandProducts.xsl $< + +-include bin/.build/Makefile + +.PHONY: clean +clean: + rm -rf bin/ diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile.build b/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile.build new file mode 100644 index 000000000..ef60e1192 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/Makefile.build @@ -0,0 +1,102 @@ + + + + + + -fomit-frame-pointer + -O2 + -g0 + -march=native + -mtune=native + + + + + + lib/Inplace32BI/KeccakP-1600-inplace32BI.c + lib/Inplace32BI/KeccakP-1600-SnP.h + + + + lib/Optimized64/KeccakP-1600-opt64.c + lib/Optimized64/KeccakP-1600-config.h + lib/Optimized64/KeccakP-1600-SnP.h + -m64 + + + + lib/OptimizedAVX2/KeccakP-1600-AVX2.s + lib/OptimizedAVX2/KeccakP-1600-config.h + lib/OptimizedAVX2/KeccakP-1600-SnP.h + lib/OptimizedAVX2/KeccakP-1600-times2-SIMD128.c + lib/OptimizedAVX2/KeccakP-1600-times4-SIMD256.c + + + + lib/OptimizedAVX512/KeccakP-1600-AVX512.s + lib/OptimizedAVX512/KeccakP-1600-config.h + lib/OptimizedAVX512/KeccakP-1600-SnP.h + lib/OptimizedAVX512/KeccakP-1600-times2-SIMD512.c + lib/OptimizedAVX512/KeccakP-1600-times4-SIMD512.c + lib/OptimizedAVX512/KeccakP-1600-times8-SIMD512.c + + + + + + lib/KangarooTwelve.c + lib/KangarooTwelve.h + + + + + + lib/brg_endian.h + + + + + tests/main.c + tests/testPerformance.c + tests/timing.h + tests/testPerformance.h + tests/testKangarooTwelve.c + tests/testKangarooTwelve.h + -lm + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/README.markdown b/src/plonk/blake2_const/benches/kangarootwelve/K12/README.markdown new file mode 100644 index 000000000..6f77de3b7 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/README.markdown @@ -0,0 +1,58 @@ +# What is KangarooTwelve ? + +[**KangarooTwelve**][k12] (or **K12**) is a fast and secure extendable-output function (XOF), the generalization of hash functions to arbitrary output lengths. +Derived from Keccak, it aims at higher speeds than FIPS 202's SHA-3 and SHAKE functions, while retaining their flexibility and basis of security. + +On high-end platforms, it can exploit a high degree of parallelism, whether using multiple cores or the single-instruction multiple-data (SIMD) instruction set of modern processors. +On Intel's® Haswell and Skylake architectures, KangarooTwelve tops at less than 1.5 cycles/byte for long messages on a single core, and at 0.55 cycles/byte on the SkylakeX architecture. +On low-end platforms, as well as for short messages, it also benefits from about a factor two speed-up compared to the fastest FIPS 202 instance SHAKE128. + +More details can be found in our [ACNS Paper][eprint]. + +# What can I find here? + +This repository contains source code that implements the extandable output (or hash) function [**KangarooTwelve**][k12] (or **K12**). +Its purpose is to offer optimized implementations of K12 and nothing else. + +The code comes from the [**eXtended Keccak Code Package**][xkcp] (or **XKCP**), after much trimming to keep only what is needed for K12. +It is still structured like the XKCP in two layers. The lower layer implements the permutation Keccak-_p_[1600, 12] and possibly parallel versions thereof, whereas the higher layer implements the sponge construction and the K12 tree hash mode. +Also, some sources have been merged to reduce the file count. + +* For the higher layer, we kept only the code needed for K12. +* For the lower layer, we removed all the functions that are not needed for K12. The lower layer therefore implements a subset of the SnP and PlSnP interfaces. + +For Keccak or Xoodoo-based functions other than K12 only, it is recommended to use the XKCP itself instead and not to mix both this repository and the XKCP. + + +# How can I build this K12 code? + +This repository uses the same build system as that of the XKCP. +To build, the following tools are needed: + +* *GCC* +* *GNU make* +* *xsltproc* + +The different targets are defined in [`Makefile.build`](Makefile.build). This file is expanded into a regular makefile using *xsltproc*. To use it, simply type, e.g., + +``` +make generic64/K12Tests +``` + +to build K12Tests generically optimized for 64-bit platforms. The name before the slash indicates the platform, while the part after the slash is the executable to build. As another example, the static (resp. dynamic) library is built by typing `make generic64/libK12.a` (resp. `.so`) or similarly with `generic64` replaced with the appropriate platform name. An alternate C compiler can be specified via the `CC` environment variable. + +Instead of building an executable with *GCC*, one can choose to select the files needed and make a package. For this, simply append `.pack` to the target name, e.g., + +``` +make generic64/K12Tests.pack +``` + +This creates a `.tar.gz` archive with all the necessary files to build the given target. + +The list of targets can be found at the end of [`Makefile.build`](Makefile.build) or by running `make` without parameters. + +For Microsoft Visual Studio support and other details, please refer to the [XKCP][xkcp]. + +[k12]: https://keccak.team/kangarootwelve.html +[xkcp]: https://github.com/XKCP/XKCP +[eprint]: https://eprint.iacr.org/2016/770.pdf diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-SnP.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-SnP.h new file mode 100644 index 000000000..5fc26a3bd --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-SnP.h @@ -0,0 +1,30 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#ifndef _KeccakP_1600_SnP_h_ +#define _KeccakP_1600_SnP_h_ + +#define KeccakP1600_implementation "in-place 32-bit optimized implementation" +#define KeccakP1600_stateSizeInBytes 200 +#define KeccakP1600_stateAlignment 8 + +#define KeccakP1600_StaticInitialize() +void KeccakP1600_Initialize(void *state); +void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset); +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600_Permute_12rounds(void *state); +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-inplace32BI.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-inplace32BI.c new file mode 100644 index 000000000..54a2913a3 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Inplace32BI/KeccakP-1600-inplace32BI.c @@ -0,0 +1,1061 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include "brg_endian.h" +#include "KeccakP-1600-SnP.h" + +typedef unsigned char UINT8; +typedef unsigned int UINT32; +/* WARNING: on 8-bit and 16-bit platforms, this should be replaced by: */ +/* typedef unsigned long UINT32; */ + +#define ROL32(a, offset) ((((UINT32)a) << (offset)) ^ (((UINT32)a) >> (32-(offset)))) + +/* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 */ +#define prepareToBitInterleaving(low, high, temp, temp0, temp1) \ + temp0 = (low); \ + temp = (temp0 ^ (temp0 >> 1)) & 0x22222222UL; temp0 = temp0 ^ temp ^ (temp << 1); \ + temp = (temp0 ^ (temp0 >> 2)) & 0x0C0C0C0CUL; temp0 = temp0 ^ temp ^ (temp << 2); \ + temp = (temp0 ^ (temp0 >> 4)) & 0x00F000F0UL; temp0 = temp0 ^ temp ^ (temp << 4); \ + temp = (temp0 ^ (temp0 >> 8)) & 0x0000FF00UL; temp0 = temp0 ^ temp ^ (temp << 8); \ + temp1 = (high); \ + temp = (temp1 ^ (temp1 >> 1)) & 0x22222222UL; temp1 = temp1 ^ temp ^ (temp << 1); \ + temp = (temp1 ^ (temp1 >> 2)) & 0x0C0C0C0CUL; temp1 = temp1 ^ temp ^ (temp << 2); \ + temp = (temp1 ^ (temp1 >> 4)) & 0x00F000F0UL; temp1 = temp1 ^ temp ^ (temp << 4); \ + temp = (temp1 ^ (temp1 >> 8)) & 0x0000FF00UL; temp1 = temp1 ^ temp ^ (temp << 8); + +#define toBitInterleavingAndXOR(low, high, even, odd, temp, temp0, temp1) \ + prepareToBitInterleaving(low, high, temp, temp0, temp1) \ + even ^= (temp0 & 0x0000FFFF) | (temp1 << 16); \ + odd ^= (temp0 >> 16) | (temp1 & 0xFFFF0000); + +#define toBitInterleavingAndAND(low, high, even, odd, temp, temp0, temp1) \ + prepareToBitInterleaving(low, high, temp, temp0, temp1) \ + even &= (temp0 & 0x0000FFFF) | (temp1 << 16); \ + odd &= (temp0 >> 16) | (temp1 & 0xFFFF0000); + +#define toBitInterleavingAndSet(low, high, even, odd, temp, temp0, temp1) \ + prepareToBitInterleaving(low, high, temp, temp0, temp1) \ + even = (temp0 & 0x0000FFFF) | (temp1 << 16); \ + odd = (temp0 >> 16) | (temp1 & 0xFFFF0000); + +/* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 */ +#define prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \ + temp0 = (even); \ + temp1 = (odd); \ + temp = (temp0 & 0x0000FFFF) | (temp1 << 16); \ + temp1 = (temp0 >> 16) | (temp1 & 0xFFFF0000); \ + temp0 = temp; \ + temp = (temp0 ^ (temp0 >> 8)) & 0x0000FF00UL; temp0 = temp0 ^ temp ^ (temp << 8); \ + temp = (temp0 ^ (temp0 >> 4)) & 0x00F000F0UL; temp0 = temp0 ^ temp ^ (temp << 4); \ + temp = (temp0 ^ (temp0 >> 2)) & 0x0C0C0C0CUL; temp0 = temp0 ^ temp ^ (temp << 2); \ + temp = (temp0 ^ (temp0 >> 1)) & 0x22222222UL; temp0 = temp0 ^ temp ^ (temp << 1); \ + temp = (temp1 ^ (temp1 >> 8)) & 0x0000FF00UL; temp1 = temp1 ^ temp ^ (temp << 8); \ + temp = (temp1 ^ (temp1 >> 4)) & 0x00F000F0UL; temp1 = temp1 ^ temp ^ (temp << 4); \ + temp = (temp1 ^ (temp1 >> 2)) & 0x0C0C0C0CUL; temp1 = temp1 ^ temp ^ (temp << 2); \ + temp = (temp1 ^ (temp1 >> 1)) & 0x22222222UL; temp1 = temp1 ^ temp ^ (temp << 1); + +#define fromBitInterleaving(even, odd, low, high, temp, temp0, temp1) \ + prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \ + low = temp0; \ + high = temp1; + +#define fromBitInterleavingAndXOR(even, odd, lowIn, highIn, lowOut, highOut, temp, temp0, temp1) \ + prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \ + lowOut = lowIn ^ temp0; \ + highOut = highIn ^ temp1; + +void KeccakP1600_SetBytesInLaneToZero(void *state, unsigned int lanePosition, unsigned int offset, unsigned int length) +{ + UINT8 laneAsBytes[8]; + UINT32 low, high; + UINT32 temp, temp0, temp1; + UINT32 *stateAsHalfLanes = (UINT32*)state; + + memset(laneAsBytes, 0xFF, offset); + memset(laneAsBytes+offset, 0x00, length); + memset(laneAsBytes+offset+length, 0xFF, 8-offset-length); +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + low = *((UINT32*)(laneAsBytes+0)); + high = *((UINT32*)(laneAsBytes+4)); +#else + low = laneAsBytes[0] + | ((UINT32)(laneAsBytes[1]) << 8) + | ((UINT32)(laneAsBytes[2]) << 16) + | ((UINT32)(laneAsBytes[3]) << 24); + high = laneAsBytes[4] + | ((UINT32)(laneAsBytes[5]) << 8) + | ((UINT32)(laneAsBytes[6]) << 16) + | ((UINT32)(laneAsBytes[7]) << 24); +#endif + toBitInterleavingAndAND(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_Initialize(void *state) +{ + memset(state, 0, 200); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset) +{ + unsigned int lanePosition = offset/8; + unsigned int offsetInLane = offset%8; + UINT32 low, high; + UINT32 temp, temp0, temp1; + UINT32 *stateAsHalfLanes = (UINT32*)state; + + if (offsetInLane < 4) { + low = (UINT32)byte << (offsetInLane*8); + high = 0; + } + else { + low = 0; + high = (UINT32)byte << ((offsetInLane-4)*8); + } + toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length) +{ + UINT8 laneAsBytes[8]; + UINT32 low, high; + UINT32 temp, temp0, temp1; + UINT32 *stateAsHalfLanes = (UINT32*)state; + + memset(laneAsBytes, 0, 8); + memcpy(laneAsBytes+offset, data, length); +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + low = *((UINT32*)(laneAsBytes+0)); + high = *((UINT32*)(laneAsBytes+4)); +#else + low = laneAsBytes[0] + | ((UINT32)(laneAsBytes[1]) << 8) + | ((UINT32)(laneAsBytes[2]) << 16) + | ((UINT32)(laneAsBytes[3]) << 24); + high = laneAsBytes[4] + | ((UINT32)(laneAsBytes[5]) << 8) + | ((UINT32)(laneAsBytes[6]) << 16) + | ((UINT32)(laneAsBytes[7]) << 24); +#endif + toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount) +{ +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + const UINT32 * pI = (const UINT32 *)data; + UINT32 * pS = (UINT32*)state; + UINT32 t, x0, x1; + int i; + for (i = laneCount-1; i >= 0; --i) { +#ifdef NO_MISALIGNED_ACCESSES + UINT32 low; + UINT32 high; + memcpy(&low, pI++, 4); + memcpy(&high, pI++, 4); + toBitInterleavingAndXOR(low, high, *(pS++), *(pS++), t, x0, x1); +#else + toBitInterleavingAndXOR(*(pI++), *(pI++), *(pS++), *(pS++), t, x0, x1) +#endif + } +#else + unsigned int lanePosition; + for(lanePosition=0; lanePosition 0) { \ + unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \ + if (_bytesInLane > _sizeLeft) \ + _bytesInLane = _sizeLeft; \ + SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \ + _sizeLeft -= _bytesInLane; \ + _lanePosition++; \ + _offsetInLane = 0; \ + _curData += _bytesInLane; \ + } \ + } \ + } + +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length) +{ + SnP_AddBytes(state, data, offset, length, KeccakP1600_AddLanes, KeccakP1600_AddBytesInLane, 8); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length) +{ + UINT32 *stateAsHalfLanes = (UINT32*)state; + UINT32 low, high, temp, temp0, temp1; + UINT8 laneAsBytes[8]; + + fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1); +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + *((UINT32*)(laneAsBytes+0)) = low; + *((UINT32*)(laneAsBytes+4)) = high; +#else + laneAsBytes[0] = low & 0xFF; + laneAsBytes[1] = (low >> 8) & 0xFF; + laneAsBytes[2] = (low >> 16) & 0xFF; + laneAsBytes[3] = (low >> 24) & 0xFF; + laneAsBytes[4] = high & 0xFF; + laneAsBytes[5] = (high >> 8) & 0xFF; + laneAsBytes[6] = (high >> 16) & 0xFF; + laneAsBytes[7] = (high >> 24) & 0xFF; +#endif + memcpy(data, laneAsBytes+offset, length); +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount) +{ +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + UINT32 * pI = (UINT32 *)data; + const UINT32 * pS = ( const UINT32 *)state; + UINT32 t, x0, x1; + int i; + for (i = laneCount-1; i >= 0; --i) { +#ifdef NO_MISALIGNED_ACCESSES + UINT32 low; + UINT32 high; + fromBitInterleaving(*(pS++), *(pS++), low, high, t, x0, x1); + memcpy(pI++, &low, 4); + memcpy(pI++, &high, 4); +#else + fromBitInterleaving(*(pS++), *(pS++), *(pI++), *(pI++), t, x0, x1) +#endif + } +#else + unsigned int lanePosition; + for(lanePosition=0; lanePosition> 8) & 0xFF; + laneAsBytes[2] = (low >> 16) & 0xFF; + laneAsBytes[3] = (low >> 24) & 0xFF; + laneAsBytes[4] = high & 0xFF; + laneAsBytes[5] = (high >> 8) & 0xFF; + laneAsBytes[6] = (high >> 16) & 0xFF; + laneAsBytes[7] = (high >> 24) & 0xFF; + memcpy(data+lanePosition*8, laneAsBytes, 8); + } +#endif +} + +/* ---------------------------------------------------------------- */ + +#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \ + { \ + if ((offset) == 0) { \ + SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \ + SnP_ExtractBytesInLane(state, \ + (length)/SnP_laneLengthInBytes, \ + (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \ + 0, \ + (length)%SnP_laneLengthInBytes); \ + } \ + else { \ + unsigned int _sizeLeft = (length); \ + unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \ + unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \ + unsigned char *_curData = (data); \ + while(_sizeLeft > 0) { \ + unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \ + if (_bytesInLane > _sizeLeft) \ + _bytesInLane = _sizeLeft; \ + SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \ + _sizeLeft -= _bytesInLane; \ + _lanePosition++; \ + _offsetInLane = 0; \ + _curData += _bytesInLane; \ + } \ + } \ + } + +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length) +{ + SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8); +} + +/* ---------------------------------------------------------------- */ + +static const UINT32 KeccakF1600RoundConstants_int2[2*24+1] = +{ + 0x00000001UL, 0x00000000UL, + 0x00000000UL, 0x00000089UL, + 0x00000000UL, 0x8000008bUL, + 0x00000000UL, 0x80008080UL, + 0x00000001UL, 0x0000008bUL, + 0x00000001UL, 0x00008000UL, + 0x00000001UL, 0x80008088UL, + 0x00000001UL, 0x80000082UL, + 0x00000000UL, 0x0000000bUL, + 0x00000000UL, 0x0000000aUL, + 0x00000001UL, 0x00008082UL, + 0x00000000UL, 0x00008003UL, + 0x00000001UL, 0x0000808bUL, + 0x00000001UL, 0x8000000bUL, + 0x00000001UL, 0x8000008aUL, + 0x00000001UL, 0x80000081UL, + 0x00000000UL, 0x80000081UL, + 0x00000000UL, 0x80000008UL, + 0x00000000UL, 0x00000083UL, + 0x00000000UL, 0x80008003UL, + 0x00000001UL, 0x80008088UL, + 0x00000000UL, 0x80000088UL, + 0x00000001UL, 0x00008000UL, + 0x00000000UL, 0x80008082UL, + 0x000000FFUL +}; + +#define KeccakRound0() \ + Cx = Abu0^Agu0^Aku0^Amu0^Asu0; \ + Du1 = Abe1^Age1^Ake1^Ame1^Ase1; \ + Da0 = Cx^ROL32(Du1, 1); \ + Cz = Abu1^Agu1^Aku1^Amu1^Asu1; \ + Du0 = Abe0^Age0^Ake0^Ame0^Ase0; \ + Da1 = Cz^Du0; \ + Cw = Abi0^Agi0^Aki0^Ami0^Asi0; \ + Do0 = Cw^ROL32(Cz, 1); \ + Cy = Abi1^Agi1^Aki1^Ami1^Asi1; \ + Do1 = Cy^Cx; \ + Cx = Aba0^Aga0^Aka0^Ama0^Asa0; \ + De0 = Cx^ROL32(Cy, 1); \ + Cz = Aba1^Aga1^Aka1^Ama1^Asa1; \ + De1 = Cz^Cw; \ + Cy = Abo1^Ago1^Ako1^Amo1^Aso1; \ + Di0 = Du0^ROL32(Cy, 1); \ + Cw = Abo0^Ago0^Ako0^Amo0^Aso0; \ + Di1 = Du1^Cw; \ + Du0 = Cw^ROL32(Cz, 1); \ + Du1 = Cy^Cx; \ +\ + Ba = (Aba0^Da0); \ + Be = ROL32((Age0^De0), 22); \ + Bi = ROL32((Aki1^Di1), 22); \ + Bo = ROL32((Amo1^Do1), 11); \ + Bu = ROL32((Asu0^Du0), 7); \ + Aba0 = Ba ^((~Be)& Bi ); \ + Aba0 ^= *(pRoundConstants++); \ + Age0 = Be ^((~Bi)& Bo ); \ + Aki1 = Bi ^((~Bo)& Bu ); \ + Amo1 = Bo ^((~Bu)& Ba ); \ + Asu0 = Bu ^((~Ba)& Be ); \ + Ba = (Aba1^Da1); \ + Be = ROL32((Age1^De1), 22); \ + Bi = ROL32((Aki0^Di0), 21); \ + Bo = ROL32((Amo0^Do0), 10); \ + Bu = ROL32((Asu1^Du1), 7); \ + Aba1 = Ba ^((~Be)& Bi ); \ + Aba1 ^= *(pRoundConstants++); \ + Age1 = Be ^((~Bi)& Bo ); \ + Aki0 = Bi ^((~Bo)& Bu ); \ + Amo0 = Bo ^((~Bu)& Ba ); \ + Asu1 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Aka1^Da1), 2); \ + Bo = ROL32((Ame1^De1), 23); \ + Bu = ROL32((Asi1^Di1), 31); \ + Ba = ROL32((Abo0^Do0), 14); \ + Be = ROL32((Agu0^Du0), 10); \ + Aka1 = Ba ^((~Be)& Bi ); \ + Ame1 = Be ^((~Bi)& Bo ); \ + Asi1 = Bi ^((~Bo)& Bu ); \ + Abo0 = Bo ^((~Bu)& Ba ); \ + Agu0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Aka0^Da0), 1); \ + Bo = ROL32((Ame0^De0), 22); \ + Bu = ROL32((Asi0^Di0), 30); \ + Ba = ROL32((Abo1^Do1), 14); \ + Be = ROL32((Agu1^Du1), 10); \ + Aka0 = Ba ^((~Be)& Bi ); \ + Ame0 = Be ^((~Bi)& Bo ); \ + Asi0 = Bi ^((~Bo)& Bu ); \ + Abo1 = Bo ^((~Bu)& Ba ); \ + Agu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Asa0^Da0), 9); \ + Ba = ROL32((Abe1^De1), 1); \ + Be = ROL32((Agi0^Di0), 3); \ + Bi = ROL32((Ako1^Do1), 13); \ + Bo = ROL32((Amu0^Du0), 4); \ + Asa0 = Ba ^((~Be)& Bi ); \ + Abe1 = Be ^((~Bi)& Bo ); \ + Agi0 = Bi ^((~Bo)& Bu ); \ + Ako1 = Bo ^((~Bu)& Ba ); \ + Amu0 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Asa1^Da1), 9); \ + Ba = (Abe0^De0); \ + Be = ROL32((Agi1^Di1), 3); \ + Bi = ROL32((Ako0^Do0), 12); \ + Bo = ROL32((Amu1^Du1), 4); \ + Asa1 = Ba ^((~Be)& Bi ); \ + Abe0 = Be ^((~Bi)& Bo ); \ + Agi1 = Bi ^((~Bo)& Bu ); \ + Ako0 = Bo ^((~Bu)& Ba ); \ + Amu1 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Aga0^Da0), 18); \ + Bi = ROL32((Ake0^De0), 5); \ + Bo = ROL32((Ami1^Di1), 8); \ + Bu = ROL32((Aso0^Do0), 28); \ + Ba = ROL32((Abu1^Du1), 14); \ + Aga0 = Ba ^((~Be)& Bi ); \ + Ake0 = Be ^((~Bi)& Bo ); \ + Ami1 = Bi ^((~Bo)& Bu ); \ + Aso0 = Bo ^((~Bu)& Ba ); \ + Abu1 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Aga1^Da1), 18); \ + Bi = ROL32((Ake1^De1), 5); \ + Bo = ROL32((Ami0^Di0), 7); \ + Bu = ROL32((Aso1^Do1), 28); \ + Ba = ROL32((Abu0^Du0), 13); \ + Aga1 = Ba ^((~Be)& Bi ); \ + Ake1 = Be ^((~Bi)& Bo ); \ + Ami0 = Bi ^((~Bo)& Bu ); \ + Aso1 = Bo ^((~Bu)& Ba ); \ + Abu0 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Ama1^Da1), 21); \ + Bu = ROL32((Ase0^De0), 1); \ + Ba = ROL32((Abi0^Di0), 31); \ + Be = ROL32((Ago1^Do1), 28); \ + Bi = ROL32((Aku1^Du1), 20); \ + Ama1 = Ba ^((~Be)& Bi ); \ + Ase0 = Be ^((~Bi)& Bo ); \ + Abi0 = Bi ^((~Bo)& Bu ); \ + Ago1 = Bo ^((~Bu)& Ba ); \ + Aku1 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Ama0^Da0), 20); \ + Bu = ROL32((Ase1^De1), 1); \ + Ba = ROL32((Abi1^Di1), 31); \ + Be = ROL32((Ago0^Do0), 27); \ + Bi = ROL32((Aku0^Du0), 19); \ + Ama0 = Ba ^((~Be)& Bi ); \ + Ase1 = Be ^((~Bi)& Bo ); \ + Abi1 = Bi ^((~Bo)& Bu ); \ + Ago0 = Bo ^((~Bu)& Ba ); \ + Aku0 = Bu ^((~Ba)& Be ) + +#define KeccakRound1() \ + Cx = Asu0^Agu0^Amu0^Abu1^Aku1; \ + Du1 = Age1^Ame0^Abe0^Ake1^Ase1; \ + Da0 = Cx^ROL32(Du1, 1); \ + Cz = Asu1^Agu1^Amu1^Abu0^Aku0; \ + Du0 = Age0^Ame1^Abe1^Ake0^Ase0; \ + Da1 = Cz^Du0; \ + Cw = Aki1^Asi1^Agi0^Ami1^Abi0; \ + Do0 = Cw^ROL32(Cz, 1); \ + Cy = Aki0^Asi0^Agi1^Ami0^Abi1; \ + Do1 = Cy^Cx; \ + Cx = Aba0^Aka1^Asa0^Aga0^Ama1; \ + De0 = Cx^ROL32(Cy, 1); \ + Cz = Aba1^Aka0^Asa1^Aga1^Ama0; \ + De1 = Cz^Cw; \ + Cy = Amo0^Abo1^Ako0^Aso1^Ago0; \ + Di0 = Du0^ROL32(Cy, 1); \ + Cw = Amo1^Abo0^Ako1^Aso0^Ago1; \ + Di1 = Du1^Cw; \ + Du0 = Cw^ROL32(Cz, 1); \ + Du1 = Cy^Cx; \ +\ + Ba = (Aba0^Da0); \ + Be = ROL32((Ame1^De0), 22); \ + Bi = ROL32((Agi1^Di1), 22); \ + Bo = ROL32((Aso1^Do1), 11); \ + Bu = ROL32((Aku1^Du0), 7); \ + Aba0 = Ba ^((~Be)& Bi ); \ + Aba0 ^= *(pRoundConstants++); \ + Ame1 = Be ^((~Bi)& Bo ); \ + Agi1 = Bi ^((~Bo)& Bu ); \ + Aso1 = Bo ^((~Bu)& Ba ); \ + Aku1 = Bu ^((~Ba)& Be ); \ + Ba = (Aba1^Da1); \ + Be = ROL32((Ame0^De1), 22); \ + Bi = ROL32((Agi0^Di0), 21); \ + Bo = ROL32((Aso0^Do0), 10); \ + Bu = ROL32((Aku0^Du1), 7); \ + Aba1 = Ba ^((~Be)& Bi ); \ + Aba1 ^= *(pRoundConstants++); \ + Ame0 = Be ^((~Bi)& Bo ); \ + Agi0 = Bi ^((~Bo)& Bu ); \ + Aso0 = Bo ^((~Bu)& Ba ); \ + Aku0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Asa1^Da1), 2); \ + Bo = ROL32((Ake1^De1), 23); \ + Bu = ROL32((Abi1^Di1), 31); \ + Ba = ROL32((Amo1^Do0), 14); \ + Be = ROL32((Agu0^Du0), 10); \ + Asa1 = Ba ^((~Be)& Bi ); \ + Ake1 = Be ^((~Bi)& Bo ); \ + Abi1 = Bi ^((~Bo)& Bu ); \ + Amo1 = Bo ^((~Bu)& Ba ); \ + Agu0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Asa0^Da0), 1); \ + Bo = ROL32((Ake0^De0), 22); \ + Bu = ROL32((Abi0^Di0), 30); \ + Ba = ROL32((Amo0^Do1), 14); \ + Be = ROL32((Agu1^Du1), 10); \ + Asa0 = Ba ^((~Be)& Bi ); \ + Ake0 = Be ^((~Bi)& Bo ); \ + Abi0 = Bi ^((~Bo)& Bu ); \ + Amo0 = Bo ^((~Bu)& Ba ); \ + Agu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Ama1^Da0), 9); \ + Ba = ROL32((Age1^De1), 1); \ + Be = ROL32((Asi1^Di0), 3); \ + Bi = ROL32((Ako0^Do1), 13); \ + Bo = ROL32((Abu1^Du0), 4); \ + Ama1 = Ba ^((~Be)& Bi ); \ + Age1 = Be ^((~Bi)& Bo ); \ + Asi1 = Bi ^((~Bo)& Bu ); \ + Ako0 = Bo ^((~Bu)& Ba ); \ + Abu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Ama0^Da1), 9); \ + Ba = (Age0^De0); \ + Be = ROL32((Asi0^Di1), 3); \ + Bi = ROL32((Ako1^Do0), 12); \ + Bo = ROL32((Abu0^Du1), 4); \ + Ama0 = Ba ^((~Be)& Bi ); \ + Age0 = Be ^((~Bi)& Bo ); \ + Asi0 = Bi ^((~Bo)& Bu ); \ + Ako1 = Bo ^((~Bu)& Ba ); \ + Abu0 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Aka1^Da0), 18); \ + Bi = ROL32((Abe1^De0), 5); \ + Bo = ROL32((Ami0^Di1), 8); \ + Bu = ROL32((Ago1^Do0), 28); \ + Ba = ROL32((Asu1^Du1), 14); \ + Aka1 = Ba ^((~Be)& Bi ); \ + Abe1 = Be ^((~Bi)& Bo ); \ + Ami0 = Bi ^((~Bo)& Bu ); \ + Ago1 = Bo ^((~Bu)& Ba ); \ + Asu1 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Aka0^Da1), 18); \ + Bi = ROL32((Abe0^De1), 5); \ + Bo = ROL32((Ami1^Di0), 7); \ + Bu = ROL32((Ago0^Do1), 28); \ + Ba = ROL32((Asu0^Du0), 13); \ + Aka0 = Ba ^((~Be)& Bi ); \ + Abe0 = Be ^((~Bi)& Bo ); \ + Ami1 = Bi ^((~Bo)& Bu ); \ + Ago0 = Bo ^((~Bu)& Ba ); \ + Asu0 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Aga1^Da1), 21); \ + Bu = ROL32((Ase0^De0), 1); \ + Ba = ROL32((Aki1^Di0), 31); \ + Be = ROL32((Abo1^Do1), 28); \ + Bi = ROL32((Amu1^Du1), 20); \ + Aga1 = Ba ^((~Be)& Bi ); \ + Ase0 = Be ^((~Bi)& Bo ); \ + Aki1 = Bi ^((~Bo)& Bu ); \ + Abo1 = Bo ^((~Bu)& Ba ); \ + Amu1 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Aga0^Da0), 20); \ + Bu = ROL32((Ase1^De1), 1); \ + Ba = ROL32((Aki0^Di1), 31); \ + Be = ROL32((Abo0^Do0), 27); \ + Bi = ROL32((Amu0^Du0), 19); \ + Aga0 = Ba ^((~Be)& Bi ); \ + Ase1 = Be ^((~Bi)& Bo ); \ + Aki0 = Bi ^((~Bo)& Bu ); \ + Abo0 = Bo ^((~Bu)& Ba ); \ + Amu0 = Bu ^((~Ba)& Be ); + +#define KeccakRound2() \ + Cx = Aku1^Agu0^Abu1^Asu1^Amu1; \ + Du1 = Ame0^Ake0^Age0^Abe0^Ase1; \ + Da0 = Cx^ROL32(Du1, 1); \ + Cz = Aku0^Agu1^Abu0^Asu0^Amu0; \ + Du0 = Ame1^Ake1^Age1^Abe1^Ase0; \ + Da1 = Cz^Du0; \ + Cw = Agi1^Abi1^Asi1^Ami0^Aki1; \ + Do0 = Cw^ROL32(Cz, 1); \ + Cy = Agi0^Abi0^Asi0^Ami1^Aki0; \ + Do1 = Cy^Cx; \ + Cx = Aba0^Asa1^Ama1^Aka1^Aga1; \ + De0 = Cx^ROL32(Cy, 1); \ + Cz = Aba1^Asa0^Ama0^Aka0^Aga0; \ + De1 = Cz^Cw; \ + Cy = Aso0^Amo0^Ako1^Ago0^Abo0; \ + Di0 = Du0^ROL32(Cy, 1); \ + Cw = Aso1^Amo1^Ako0^Ago1^Abo1; \ + Di1 = Du1^Cw; \ + Du0 = Cw^ROL32(Cz, 1); \ + Du1 = Cy^Cx; \ +\ + Ba = (Aba0^Da0); \ + Be = ROL32((Ake1^De0), 22); \ + Bi = ROL32((Asi0^Di1), 22); \ + Bo = ROL32((Ago0^Do1), 11); \ + Bu = ROL32((Amu1^Du0), 7); \ + Aba0 = Ba ^((~Be)& Bi ); \ + Aba0 ^= *(pRoundConstants++); \ + Ake1 = Be ^((~Bi)& Bo ); \ + Asi0 = Bi ^((~Bo)& Bu ); \ + Ago0 = Bo ^((~Bu)& Ba ); \ + Amu1 = Bu ^((~Ba)& Be ); \ + Ba = (Aba1^Da1); \ + Be = ROL32((Ake0^De1), 22); \ + Bi = ROL32((Asi1^Di0), 21); \ + Bo = ROL32((Ago1^Do0), 10); \ + Bu = ROL32((Amu0^Du1), 7); \ + Aba1 = Ba ^((~Be)& Bi ); \ + Aba1 ^= *(pRoundConstants++); \ + Ake0 = Be ^((~Bi)& Bo ); \ + Asi1 = Bi ^((~Bo)& Bu ); \ + Ago1 = Bo ^((~Bu)& Ba ); \ + Amu0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Ama0^Da1), 2); \ + Bo = ROL32((Abe0^De1), 23); \ + Bu = ROL32((Aki0^Di1), 31); \ + Ba = ROL32((Aso1^Do0), 14); \ + Be = ROL32((Agu0^Du0), 10); \ + Ama0 = Ba ^((~Be)& Bi ); \ + Abe0 = Be ^((~Bi)& Bo ); \ + Aki0 = Bi ^((~Bo)& Bu ); \ + Aso1 = Bo ^((~Bu)& Ba ); \ + Agu0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Ama1^Da0), 1); \ + Bo = ROL32((Abe1^De0), 22); \ + Bu = ROL32((Aki1^Di0), 30); \ + Ba = ROL32((Aso0^Do1), 14); \ + Be = ROL32((Agu1^Du1), 10); \ + Ama1 = Ba ^((~Be)& Bi ); \ + Abe1 = Be ^((~Bi)& Bo ); \ + Aki1 = Bi ^((~Bo)& Bu ); \ + Aso0 = Bo ^((~Bu)& Ba ); \ + Agu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Aga1^Da0), 9); \ + Ba = ROL32((Ame0^De1), 1); \ + Be = ROL32((Abi1^Di0), 3); \ + Bi = ROL32((Ako1^Do1), 13); \ + Bo = ROL32((Asu1^Du0), 4); \ + Aga1 = Ba ^((~Be)& Bi ); \ + Ame0 = Be ^((~Bi)& Bo ); \ + Abi1 = Bi ^((~Bo)& Bu ); \ + Ako1 = Bo ^((~Bu)& Ba ); \ + Asu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Aga0^Da1), 9); \ + Ba = (Ame1^De0); \ + Be = ROL32((Abi0^Di1), 3); \ + Bi = ROL32((Ako0^Do0), 12); \ + Bo = ROL32((Asu0^Du1), 4); \ + Aga0 = Ba ^((~Be)& Bi ); \ + Ame1 = Be ^((~Bi)& Bo ); \ + Abi0 = Bi ^((~Bo)& Bu ); \ + Ako0 = Bo ^((~Bu)& Ba ); \ + Asu0 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Asa1^Da0), 18); \ + Bi = ROL32((Age1^De0), 5); \ + Bo = ROL32((Ami1^Di1), 8); \ + Bu = ROL32((Abo1^Do0), 28); \ + Ba = ROL32((Aku0^Du1), 14); \ + Asa1 = Ba ^((~Be)& Bi ); \ + Age1 = Be ^((~Bi)& Bo ); \ + Ami1 = Bi ^((~Bo)& Bu ); \ + Abo1 = Bo ^((~Bu)& Ba ); \ + Aku0 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Asa0^Da1), 18); \ + Bi = ROL32((Age0^De1), 5); \ + Bo = ROL32((Ami0^Di0), 7); \ + Bu = ROL32((Abo0^Do1), 28); \ + Ba = ROL32((Aku1^Du0), 13); \ + Asa0 = Ba ^((~Be)& Bi ); \ + Age0 = Be ^((~Bi)& Bo ); \ + Ami0 = Bi ^((~Bo)& Bu ); \ + Abo0 = Bo ^((~Bu)& Ba ); \ + Aku1 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Aka0^Da1), 21); \ + Bu = ROL32((Ase0^De0), 1); \ + Ba = ROL32((Agi1^Di0), 31); \ + Be = ROL32((Amo0^Do1), 28); \ + Bi = ROL32((Abu0^Du1), 20); \ + Aka0 = Ba ^((~Be)& Bi ); \ + Ase0 = Be ^((~Bi)& Bo ); \ + Agi1 = Bi ^((~Bo)& Bu ); \ + Amo0 = Bo ^((~Bu)& Ba ); \ + Abu0 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Aka1^Da0), 20); \ + Bu = ROL32((Ase1^De1), 1); \ + Ba = ROL32((Agi0^Di1), 31); \ + Be = ROL32((Amo1^Do0), 27); \ + Bi = ROL32((Abu1^Du0), 19); \ + Aka1 = Ba ^((~Be)& Bi ); \ + Ase1 = Be ^((~Bi)& Bo ); \ + Agi0 = Bi ^((~Bo)& Bu ); \ + Amo1 = Bo ^((~Bu)& Ba ); \ + Abu1 = Bu ^((~Ba)& Be ); + +#define KeccakRound3() \ + Cx = Amu1^Agu0^Asu1^Aku0^Abu0; \ + Du1 = Ake0^Abe1^Ame1^Age0^Ase1; \ + Da0 = Cx^ROL32(Du1, 1); \ + Cz = Amu0^Agu1^Asu0^Aku1^Abu1; \ + Du0 = Ake1^Abe0^Ame0^Age1^Ase0; \ + Da1 = Cz^Du0; \ + Cw = Asi0^Aki0^Abi1^Ami1^Agi1; \ + Do0 = Cw^ROL32(Cz, 1); \ + Cy = Asi1^Aki1^Abi0^Ami0^Agi0; \ + Do1 = Cy^Cx; \ + Cx = Aba0^Ama0^Aga1^Asa1^Aka0; \ + De0 = Cx^ROL32(Cy, 1); \ + Cz = Aba1^Ama1^Aga0^Asa0^Aka1; \ + De1 = Cz^Cw; \ + Cy = Ago1^Aso0^Ako0^Abo0^Amo1; \ + Di0 = Du0^ROL32(Cy, 1); \ + Cw = Ago0^Aso1^Ako1^Abo1^Amo0; \ + Di1 = Du1^Cw; \ + Du0 = Cw^ROL32(Cz, 1); \ + Du1 = Cy^Cx; \ +\ + Ba = (Aba0^Da0); \ + Be = ROL32((Abe0^De0), 22); \ + Bi = ROL32((Abi0^Di1), 22); \ + Bo = ROL32((Abo0^Do1), 11); \ + Bu = ROL32((Abu0^Du0), 7); \ + Aba0 = Ba ^((~Be)& Bi ); \ + Aba0 ^= *(pRoundConstants++); \ + Abe0 = Be ^((~Bi)& Bo ); \ + Abi0 = Bi ^((~Bo)& Bu ); \ + Abo0 = Bo ^((~Bu)& Ba ); \ + Abu0 = Bu ^((~Ba)& Be ); \ + Ba = (Aba1^Da1); \ + Be = ROL32((Abe1^De1), 22); \ + Bi = ROL32((Abi1^Di0), 21); \ + Bo = ROL32((Abo1^Do0), 10); \ + Bu = ROL32((Abu1^Du1), 7); \ + Aba1 = Ba ^((~Be)& Bi ); \ + Aba1 ^= *(pRoundConstants++); \ + Abe1 = Be ^((~Bi)& Bo ); \ + Abi1 = Bi ^((~Bo)& Bu ); \ + Abo1 = Bo ^((~Bu)& Ba ); \ + Abu1 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Aga0^Da1), 2); \ + Bo = ROL32((Age0^De1), 23); \ + Bu = ROL32((Agi0^Di1), 31); \ + Ba = ROL32((Ago0^Do0), 14); \ + Be = ROL32((Agu0^Du0), 10); \ + Aga0 = Ba ^((~Be)& Bi ); \ + Age0 = Be ^((~Bi)& Bo ); \ + Agi0 = Bi ^((~Bo)& Bu ); \ + Ago0 = Bo ^((~Bu)& Ba ); \ + Agu0 = Bu ^((~Ba)& Be ); \ + Bi = ROL32((Aga1^Da0), 1); \ + Bo = ROL32((Age1^De0), 22); \ + Bu = ROL32((Agi1^Di0), 30); \ + Ba = ROL32((Ago1^Do1), 14); \ + Be = ROL32((Agu1^Du1), 10); \ + Aga1 = Ba ^((~Be)& Bi ); \ + Age1 = Be ^((~Bi)& Bo ); \ + Agi1 = Bi ^((~Bo)& Bu ); \ + Ago1 = Bo ^((~Bu)& Ba ); \ + Agu1 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Aka0^Da0), 9); \ + Ba = ROL32((Ake0^De1), 1); \ + Be = ROL32((Aki0^Di0), 3); \ + Bi = ROL32((Ako0^Do1), 13); \ + Bo = ROL32((Aku0^Du0), 4); \ + Aka0 = Ba ^((~Be)& Bi ); \ + Ake0 = Be ^((~Bi)& Bo ); \ + Aki0 = Bi ^((~Bo)& Bu ); \ + Ako0 = Bo ^((~Bu)& Ba ); \ + Aku0 = Bu ^((~Ba)& Be ); \ + Bu = ROL32((Aka1^Da1), 9); \ + Ba = (Ake1^De0); \ + Be = ROL32((Aki1^Di1), 3); \ + Bi = ROL32((Ako1^Do0), 12); \ + Bo = ROL32((Aku1^Du1), 4); \ + Aka1 = Ba ^((~Be)& Bi ); \ + Ake1 = Be ^((~Bi)& Bo ); \ + Aki1 = Bi ^((~Bo)& Bu ); \ + Ako1 = Bo ^((~Bu)& Ba ); \ + Aku1 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Ama0^Da0), 18); \ + Bi = ROL32((Ame0^De0), 5); \ + Bo = ROL32((Ami0^Di1), 8); \ + Bu = ROL32((Amo0^Do0), 28); \ + Ba = ROL32((Amu0^Du1), 14); \ + Ama0 = Ba ^((~Be)& Bi ); \ + Ame0 = Be ^((~Bi)& Bo ); \ + Ami0 = Bi ^((~Bo)& Bu ); \ + Amo0 = Bo ^((~Bu)& Ba ); \ + Amu0 = Bu ^((~Ba)& Be ); \ + Be = ROL32((Ama1^Da1), 18); \ + Bi = ROL32((Ame1^De1), 5); \ + Bo = ROL32((Ami1^Di0), 7); \ + Bu = ROL32((Amo1^Do1), 28); \ + Ba = ROL32((Amu1^Du0), 13); \ + Ama1 = Ba ^((~Be)& Bi ); \ + Ame1 = Be ^((~Bi)& Bo ); \ + Ami1 = Bi ^((~Bo)& Bu ); \ + Amo1 = Bo ^((~Bu)& Ba ); \ + Amu1 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Asa0^Da1), 21); \ + Bu = ROL32((Ase0^De0), 1); \ + Ba = ROL32((Asi0^Di0), 31); \ + Be = ROL32((Aso0^Do1), 28); \ + Bi = ROL32((Asu0^Du1), 20); \ + Asa0 = Ba ^((~Be)& Bi ); \ + Ase0 = Be ^((~Bi)& Bo ); \ + Asi0 = Bi ^((~Bo)& Bu ); \ + Aso0 = Bo ^((~Bu)& Ba ); \ + Asu0 = Bu ^((~Ba)& Be ); \ + Bo = ROL32((Asa1^Da0), 20); \ + Bu = ROL32((Ase1^De1), 1); \ + Ba = ROL32((Asi1^Di1), 31); \ + Be = ROL32((Aso1^Do0), 27); \ + Bi = ROL32((Asu1^Du0), 19); \ + Asa1 = Ba ^((~Be)& Bi ); \ + Ase1 = Be ^((~Bi)& Bo ); \ + Asi1 = Bi ^((~Bo)& Bu ); \ + Aso1 = Bo ^((~Bu)& Ba ); \ + Asu1 = Bu ^((~Ba)& Be ); + +void KeccakP1600_Permute_Nrounds(void *state, unsigned int nRounds) +{ + UINT32 Da0, De0, Di0, Do0, Du0; + UINT32 Da1, De1, Di1, Do1, Du1; + UINT32 Ba, Be, Bi, Bo, Bu; + UINT32 Cx, Cy, Cz, Cw; + const UINT32 *pRoundConstants = KeccakF1600RoundConstants_int2+(24-nRounds)*2; + UINT32 *stateAsHalfLanes = (UINT32*)state; + #define Aba0 stateAsHalfLanes[ 0] + #define Aba1 stateAsHalfLanes[ 1] + #define Abe0 stateAsHalfLanes[ 2] + #define Abe1 stateAsHalfLanes[ 3] + #define Abi0 stateAsHalfLanes[ 4] + #define Abi1 stateAsHalfLanes[ 5] + #define Abo0 stateAsHalfLanes[ 6] + #define Abo1 stateAsHalfLanes[ 7] + #define Abu0 stateAsHalfLanes[ 8] + #define Abu1 stateAsHalfLanes[ 9] + #define Aga0 stateAsHalfLanes[10] + #define Aga1 stateAsHalfLanes[11] + #define Age0 stateAsHalfLanes[12] + #define Age1 stateAsHalfLanes[13] + #define Agi0 stateAsHalfLanes[14] + #define Agi1 stateAsHalfLanes[15] + #define Ago0 stateAsHalfLanes[16] + #define Ago1 stateAsHalfLanes[17] + #define Agu0 stateAsHalfLanes[18] + #define Agu1 stateAsHalfLanes[19] + #define Aka0 stateAsHalfLanes[20] + #define Aka1 stateAsHalfLanes[21] + #define Ake0 stateAsHalfLanes[22] + #define Ake1 stateAsHalfLanes[23] + #define Aki0 stateAsHalfLanes[24] + #define Aki1 stateAsHalfLanes[25] + #define Ako0 stateAsHalfLanes[26] + #define Ako1 stateAsHalfLanes[27] + #define Aku0 stateAsHalfLanes[28] + #define Aku1 stateAsHalfLanes[29] + #define Ama0 stateAsHalfLanes[30] + #define Ama1 stateAsHalfLanes[31] + #define Ame0 stateAsHalfLanes[32] + #define Ame1 stateAsHalfLanes[33] + #define Ami0 stateAsHalfLanes[34] + #define Ami1 stateAsHalfLanes[35] + #define Amo0 stateAsHalfLanes[36] + #define Amo1 stateAsHalfLanes[37] + #define Amu0 stateAsHalfLanes[38] + #define Amu1 stateAsHalfLanes[39] + #define Asa0 stateAsHalfLanes[40] + #define Asa1 stateAsHalfLanes[41] + #define Ase0 stateAsHalfLanes[42] + #define Ase1 stateAsHalfLanes[43] + #define Asi0 stateAsHalfLanes[44] + #define Asi1 stateAsHalfLanes[45] + #define Aso0 stateAsHalfLanes[46] + #define Aso1 stateAsHalfLanes[47] + #define Asu0 stateAsHalfLanes[48] + #define Asu1 stateAsHalfLanes[49] + + nRounds &= 3; + switch ( nRounds ) + { + #define I0 Ba + #define I1 Be + #define T0 Bi + #define T1 Bo + #define SwapPI13( in0,in1,in2,in3,eo0,eo1,eo2,eo3 ) \ + I0 = (in0)[0]; I1 = (in0)[1]; \ + T0 = (in1)[0]; T1 = (in1)[1]; \ + (in0)[eo0] = T0; (in0)[eo0^1] = T1; \ + T0 = (in2)[0]; T1 = (in2)[1]; \ + (in1)[eo1] = T0; (in1)[eo1^1] = T1; \ + T0 = (in3)[0]; T1 = (in3)[1]; \ + (in2)[eo2] = T0; (in2)[eo2^1] = T1; \ + (in3)[eo3] = I0; (in3)[eo3^1] = I1 + #define SwapPI2( in0,in1,in2,in3 ) \ + I0 = (in0)[0]; I1 = (in0)[1]; \ + T0 = (in1)[0]; T1 = (in1)[1]; \ + (in0)[1] = T0; (in0)[0] = T1; \ + (in1)[1] = I0; (in1)[0] = I1; \ + I0 = (in2)[0]; I1 = (in2)[1]; \ + T0 = (in3)[0]; T1 = (in3)[1]; \ + (in2)[1] = T0; (in2)[0] = T1; \ + (in3)[1] = I0; (in3)[0] = I1 + #define SwapEO( even,odd ) T0 = even; even = odd; odd = T0 + + case 1: + SwapPI13( &Aga0, &Aka0, &Asa0, &Ama0, 1, 0, 1, 0 ); + SwapPI13( &Abe0, &Age0, &Ame0, &Ake0, 0, 1, 0, 1 ); + SwapPI13( &Abi0, &Aki0, &Agi0, &Asi0, 1, 0, 1, 0 ); + SwapEO( Ami0, Ami1 ); + SwapPI13( &Abo0, &Amo0, &Aso0, &Ago0, 1, 0, 1, 0 ); + SwapEO( Ako0, Ako1 ); + SwapPI13( &Abu0, &Asu0, &Aku0, &Amu0, 0, 1, 0, 1 ); + break; + + case 2: + SwapPI2( &Aga0, &Asa0, &Aka0, &Ama0 ); + SwapPI2( &Abe0, &Ame0, &Age0, &Ake0 ); + SwapPI2( &Abi0, &Agi0, &Aki0, &Asi0 ); + SwapPI2( &Abo0, &Aso0, &Ago0, &Amo0 ); + SwapPI2( &Abu0, &Aku0, &Amu0, &Asu0 ); + break; + + case 3: + SwapPI13( &Aga0, &Ama0, &Asa0, &Aka0, 0, 1, 0, 1 ); + SwapPI13( &Abe0, &Ake0, &Ame0, &Age0, 1, 0, 1, 0 ); + SwapPI13( &Abi0, &Asi0, &Agi0, &Aki0, 0, 1, 0, 1 ); + SwapEO( Ami0, Ami1 ); + SwapPI13( &Abo0, &Ago0, &Aso0, &Amo0, 0, 1, 0, 1 ); + SwapEO( Ako0, Ako1 ); + SwapPI13( &Abu0, &Amu0, &Aku0, &Asu0, 1, 0, 1, 0 ); + break; + #undef I0 + #undef I1 + #undef T0 + #undef T1 + #undef SwapPI13 + #undef SwapPI2 + #undef SwapEO + } + + do + { + /* Code for 4 rounds, using factor 2 interleaving, 64-bit lanes mapped to 32-bit words */ + switch ( nRounds ) + { + case 0: KeccakRound0(); /* fall through */ + case 3: KeccakRound1(); + case 2: KeccakRound2(); + case 1: KeccakRound3(); + } + nRounds = 0; + } + while ( *pRoundConstants != 0xFF ); + + #undef Aba0 + #undef Aba1 + #undef Abe0 + #undef Abe1 + #undef Abi0 + #undef Abi1 + #undef Abo0 + #undef Abo1 + #undef Abu0 + #undef Abu1 + #undef Aga0 + #undef Aga1 + #undef Age0 + #undef Age1 + #undef Agi0 + #undef Agi1 + #undef Ago0 + #undef Ago1 + #undef Agu0 + #undef Agu1 + #undef Aka0 + #undef Aka1 + #undef Ake0 + #undef Ake1 + #undef Aki0 + #undef Aki1 + #undef Ako0 + #undef Ako1 + #undef Aku0 + #undef Aku1 + #undef Ama0 + #undef Ama1 + #undef Ame0 + #undef Ame1 + #undef Ami0 + #undef Ami1 + #undef Amo0 + #undef Amo1 + #undef Amu0 + #undef Amu1 + #undef Asa0 + #undef Asa1 + #undef Ase0 + #undef Ase1 + #undef Asi0 + #undef Asi1 + #undef Aso0 + #undef Aso1 + #undef Asu0 + #undef Asu1 +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_Permute_12rounds(void *state) +{ + KeccakP1600_Permute_Nrounds(state, 12); +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.c new file mode 100644 index 000000000..90a73f275 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.c @@ -0,0 +1,409 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ +*/ + +#include +#include "KangarooTwelve.h" + +int KeccakWidth1600_12rounds_SpongeInitialize(KeccakWidth1600_12rounds_SpongeInstance *spongeInstance, unsigned int rate, unsigned int capacity); +int KeccakWidth1600_12rounds_SpongeAbsorb(KeccakWidth1600_12rounds_SpongeInstance *spongeInstance, const unsigned char *data, size_t dataByteLen); +int KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(KeccakWidth1600_12rounds_SpongeInstance *spongeInstance, unsigned char delimitedData); +int KeccakWidth1600_12rounds_SpongeSqueeze(KeccakWidth1600_12rounds_SpongeInstance *spongeInstance, unsigned char *data, size_t dataByteLen); + +int KeccakWidth1600_12rounds_SpongeInitialize(KeccakWidth1600_12rounds_SpongeInstance *instance, unsigned int rate, unsigned int capacity) +{ + if (rate+capacity != 1600) + return 1; + if ((rate <= 0) || (rate > 1600) || ((rate % 8) != 0)) + return 1; + KeccakP1600_StaticInitialize(); + KeccakP1600_Initialize(instance->state); + instance->rate = rate; + instance->byteIOIndex = 0; + instance->squeezing = 0; + + return 0; +} + +/* ---------------------------------------------------------------- */ + +int KeccakWidth1600_12rounds_SpongeAbsorb(KeccakWidth1600_12rounds_SpongeInstance *instance, const unsigned char *data, size_t dataByteLen) +{ + size_t i, j; + unsigned int partialBlock; + const unsigned char *curData; + unsigned int rateInBytes = instance->rate/8; + + if (instance->squeezing) + return 1; /* Too late for additional input */ + + i = 0; + curData = data; + while(i < dataByteLen) { + if ((instance->byteIOIndex == 0) && (dataByteLen >= (i + rateInBytes))) { +#ifdef KeccakP1600_12rounds_FastLoop_supported + /* processing full blocks first */ + if ((rateInBytes % (1600/200)) == 0) { + /* fast lane: whole lane rate */ + j = KeccakP1600_12rounds_FastLoop_Absorb(instance->state, rateInBytes/(1600/200), curData, dataByteLen - i); + i += j; + curData += j; + } + else { +#endif + for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) { + KeccakP1600_AddBytes(instance->state, curData, 0, rateInBytes); + KeccakP1600_Permute_12rounds(instance->state); + curData+=rateInBytes; + } + i = dataByteLen - j; +#ifdef KeccakP1600_12rounds_FastLoop_supported + } +#endif + } + else { + /* normal lane: using the message queue */ + partialBlock = (unsigned int)(dataByteLen - i); + if (partialBlock+instance->byteIOIndex > rateInBytes) + partialBlock = rateInBytes-instance->byteIOIndex; + i += partialBlock; + + KeccakP1600_AddBytes(instance->state, curData, instance->byteIOIndex, partialBlock); + curData += partialBlock; + instance->byteIOIndex += partialBlock; + if (instance->byteIOIndex == rateInBytes) { + KeccakP1600_Permute_12rounds(instance->state); + instance->byteIOIndex = 0; + } + } + } + return 0; +} + +/* ---------------------------------------------------------------- */ + +int KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(KeccakWidth1600_12rounds_SpongeInstance *instance, unsigned char delimitedData) +{ + unsigned int rateInBytes = instance->rate/8; + + if (delimitedData == 0) + return 1; + if (instance->squeezing) + return 1; /* Too late for additional input */ + + /* Last few bits, whose delimiter coincides with first bit of padding */ + KeccakP1600_AddByte(instance->state, delimitedData, instance->byteIOIndex); + /* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */ + if ((delimitedData >= 0x80) && (instance->byteIOIndex == (rateInBytes-1))) + KeccakP1600_Permute_12rounds(instance->state); + /* Second bit of padding */ + KeccakP1600_AddByte(instance->state, 0x80, rateInBytes-1); + KeccakP1600_Permute_12rounds(instance->state); + instance->byteIOIndex = 0; + instance->squeezing = 1; + return 0; +} + +/* ---------------------------------------------------------------- */ + +int KeccakWidth1600_12rounds_SpongeSqueeze(KeccakWidth1600_12rounds_SpongeInstance *instance, unsigned char *data, size_t dataByteLen) +{ + size_t i, j; + unsigned int partialBlock; + unsigned int rateInBytes = instance->rate/8; + unsigned char *curData; + + if (!instance->squeezing) + KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(instance, 0x01); + + i = 0; + curData = data; + while(i < dataByteLen) { + if ((instance->byteIOIndex == rateInBytes) && (dataByteLen >= (i + rateInBytes))) { + for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) { + KeccakP1600_Permute_12rounds(instance->state); + KeccakP1600_ExtractBytes(instance->state, curData, 0, rateInBytes); + curData+=rateInBytes; + } + i = dataByteLen - j; + } + else { + /* normal lane: using the message queue */ + if (instance->byteIOIndex == rateInBytes) { + KeccakP1600_Permute_12rounds(instance->state); + instance->byteIOIndex = 0; + } + partialBlock = (unsigned int)(dataByteLen - i); + if (partialBlock+instance->byteIOIndex > rateInBytes) + partialBlock = rateInBytes-instance->byteIOIndex; + i += partialBlock; + + KeccakP1600_ExtractBytes(instance->state, curData, instance->byteIOIndex, partialBlock); + curData += partialBlock; + instance->byteIOIndex += partialBlock; + } + } + return 0; +} + +/* ---------------------------------------------------------------- */ + +#define chunkSize 8192 +#define laneSize 8 +#define suffixLeaf 0x0B /* '110': message hop, simple padding, inner node */ + +#define security 128 +#define capacity (2*security) +#define capacityInBytes (capacity/8) +#define capacityInLanes (capacityInBytes/laneSize) +#define rate (1600-capacity) +#define rateInBytes (rate/8) +#define rateInLanes (rateInBytes/laneSize) + +#define ParallelSpongeFastLoop( Parallellism ) \ + while ( inLen >= Parallellism * chunkSize ) { \ + ALIGN(KeccakP1600times##Parallellism##_statesAlignment) unsigned char states[KeccakP1600times##Parallellism##_statesSizeInBytes]; \ + unsigned char intermediate[Parallellism*capacityInBytes]; \ + unsigned int localBlockLen = chunkSize; \ + const unsigned char * localInput = input; \ + unsigned int i; \ + unsigned int fastLoopOffset; \ + \ + KeccakP1600times##Parallellism##_StaticInitialize(); \ + KeccakP1600times##Parallellism##_InitializeAll(states); \ + fastLoopOffset = KeccakP1600times##Parallellism##_12rounds_FastLoop_Absorb(states, rateInLanes, chunkSize / laneSize, rateInLanes, localInput, Parallellism * chunkSize); \ + localBlockLen -= fastLoopOffset; \ + localInput += fastLoopOffset; \ + for ( i = 0; i < Parallellism; ++i, localInput += chunkSize ) { \ + KeccakP1600times##Parallellism##_AddBytes(states, i, localInput, 0, localBlockLen); \ + KeccakP1600times##Parallellism##_AddByte(states, i, suffixLeaf, localBlockLen); \ + KeccakP1600times##Parallellism##_AddByte(states, i, 0x80, rateInBytes-1); \ + } \ + KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \ + input += Parallellism * chunkSize; \ + inLen -= Parallellism * chunkSize; \ + ktInstance->blockNumber += Parallellism; \ + KeccakP1600times##Parallellism##_ExtractLanesAll(states, intermediate, capacityInLanes, capacityInLanes ); \ + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, Parallellism * capacityInBytes) != 0) return 1; \ + } + +#define ParallelSpongeLoop( Parallellism ) \ + while ( inLen >= Parallellism * chunkSize ) { \ + ALIGN(KeccakP1600times##Parallellism##_statesAlignment) unsigned char states[KeccakP1600times##Parallellism##_statesSizeInBytes]; \ + unsigned char intermediate[Parallellism*capacityInBytes]; \ + unsigned int localBlockLen = chunkSize; \ + const unsigned char * localInput = input; \ + unsigned int i; \ + \ + KeccakP1600times##Parallellism##_StaticInitialize(); \ + KeccakP1600times##Parallellism##_InitializeAll(states); \ + while(localBlockLen >= rateInBytes) { \ + KeccakP1600times##Parallellism##_AddLanesAll(states, localInput, rateInLanes, chunkSize / laneSize); \ + KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \ + localBlockLen -= rateInBytes; \ + localInput += rateInBytes; \ + } \ + for ( i = 0; i < Parallellism; ++i, localInput += chunkSize ) { \ + KeccakP1600times##Parallellism##_AddBytes(states, i, localInput, 0, localBlockLen); \ + KeccakP1600times##Parallellism##_AddByte(states, i, suffixLeaf, localBlockLen); \ + KeccakP1600times##Parallellism##_AddByte(states, i, 0x80, rateInBytes-1); \ + } \ + KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \ + input += Parallellism * chunkSize; \ + inLen -= Parallellism * chunkSize; \ + ktInstance->blockNumber += Parallellism; \ + KeccakP1600times##Parallellism##_ExtractLanesAll(states, intermediate, capacityInLanes, capacityInLanes ); \ + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, Parallellism * capacityInBytes) != 0) return 1; \ + } + +static unsigned int right_encode( unsigned char * encbuf, size_t value ) +{ + unsigned int n, i; + size_t v; + + for ( v = value, n = 0; v && (n < sizeof(size_t)); ++n, v >>= 8 ) + ; /* empty */ + for ( i = 1; i <= n; ++i ) + encbuf[i-1] = (unsigned char)(value >> (8 * (n-i))); + encbuf[n] = (unsigned char)n; + return n + 1; +} + +int KangarooTwelve_Initialize(KangarooTwelve_Instance *ktInstance, size_t outputLen) +{ + ktInstance->fixedOutputLength = outputLen; + ktInstance->queueAbsorbedLen = 0; + ktInstance->blockNumber = 0; + ktInstance->phase = ABSORBING; + return KeccakWidth1600_12rounds_SpongeInitialize(&ktInstance->finalNode, rate, capacity); +} + +int KangarooTwelve_Update(KangarooTwelve_Instance *ktInstance, const unsigned char *input, size_t inLen) +{ + if (ktInstance->phase != ABSORBING) + return 1; + + if ( ktInstance->blockNumber == 0 ) { + /* First block, absorb in final node */ + unsigned int len = (inLen < (chunkSize - ktInstance->queueAbsorbedLen)) ? inLen : (chunkSize - ktInstance->queueAbsorbedLen); + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, input, len) != 0) + return 1; + input += len; + inLen -= len; + ktInstance->queueAbsorbedLen += len; + if ( (ktInstance->queueAbsorbedLen == chunkSize) && (inLen != 0) ) { + /* First block complete and more input data available, finalize it */ + const unsigned char padding = 0x03; /* '110^6': message hop, simple padding */ + ktInstance->queueAbsorbedLen = 0; + ktInstance->blockNumber = 1; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, &padding, 1) != 0) + return 1; + ktInstance->finalNode.byteIOIndex = (ktInstance->finalNode.byteIOIndex + 7) & ~7; /* Zero padding up to 64 bits */ + } + } + else if ( ktInstance->queueAbsorbedLen != 0 ) { + /* There is data in the queue, absorb further in queue until block complete */ + unsigned int len = (inLen < (chunkSize - ktInstance->queueAbsorbedLen)) ? inLen : (chunkSize - ktInstance->queueAbsorbedLen); + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->queueNode, input, len) != 0) + return 1; + input += len; + inLen -= len; + ktInstance->queueAbsorbedLen += len; + if ( ktInstance->queueAbsorbedLen == chunkSize ) { + unsigned char intermediate[capacityInBytes]; + ktInstance->queueAbsorbedLen = 0; + ++ktInstance->blockNumber; + if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0) + return 1; + } + } + + #if defined(KeccakP1600times8_implementation) && !defined(KeccakP1600times8_isFallback) + #if defined(KeccakP1600times8_12rounds_FastLoop_supported) + ParallelSpongeFastLoop( 8 ) + #else + ParallelSpongeLoop( 8 ) + #endif + #endif + + #if defined(KeccakP1600times4_implementation) && !defined(KeccakP1600times4_isFallback) + #if defined(KeccakP1600times4_12rounds_FastLoop_supported) + ParallelSpongeFastLoop( 4 ) + #else + ParallelSpongeLoop( 4 ) + #endif + #endif + + #if defined(KeccakP1600times2_implementation) && !defined(KeccakP1600times2_isFallback) + #if defined(KeccakP1600times2_12rounds_FastLoop_supported) + ParallelSpongeFastLoop( 2 ) + #else + ParallelSpongeLoop( 2 ) + #endif + #endif + + while ( inLen > 0 ) { + unsigned int len = (inLen < chunkSize) ? inLen : chunkSize; + if (KeccakWidth1600_12rounds_SpongeInitialize(&ktInstance->queueNode, rate, capacity) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->queueNode, input, len) != 0) + return 1; + input += len; + inLen -= len; + if ( len == chunkSize ) { + unsigned char intermediate[capacityInBytes]; + ++ktInstance->blockNumber; + if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0) + return 1; + } + else + ktInstance->queueAbsorbedLen = len; + } + + return 0; +} + +int KangarooTwelve_Final(KangarooTwelve_Instance *ktInstance, unsigned char * output, const unsigned char * customization, size_t customLen) +{ + unsigned char encbuf[sizeof(size_t)+1+2]; + unsigned char padding; + + if (ktInstance->phase != ABSORBING) + return 1; + + /* Absorb customization | right_encode(customLen) */ + if ((customLen != 0) && (KangarooTwelve_Update(ktInstance, customization, customLen) != 0)) + return 1; + if (KangarooTwelve_Update(ktInstance, encbuf, right_encode(encbuf, customLen)) != 0) + return 1; + + if ( ktInstance->blockNumber == 0 ) { + /* Non complete first block in final node, pad it */ + padding = 0x07; /* '11': message hop, final node */ + } + else { + unsigned int n; + + if ( ktInstance->queueAbsorbedLen != 0 ) { + /* There is data in the queue node */ + unsigned char intermediate[capacityInBytes]; + ++ktInstance->blockNumber; + if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0) + return 1; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0) + return 1; + } + --ktInstance->blockNumber; /* Absorb right_encode(number of Chaining Values) || 0xFF || 0xFF */ + n = right_encode(encbuf, ktInstance->blockNumber); + encbuf[n++] = 0xFF; + encbuf[n++] = 0xFF; + if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, encbuf, n) != 0) + return 1; + padding = 0x06; /* '01': chaining hop, final node */ + } + if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->finalNode, padding) != 0) + return 1; + if ( ktInstance->fixedOutputLength != 0 ) { + ktInstance->phase = FINAL; + return KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->finalNode, output, ktInstance->fixedOutputLength); + } + ktInstance->phase = SQUEEZING; + return 0; +} + +int KangarooTwelve_Squeeze(KangarooTwelve_Instance *ktInstance, unsigned char * output, size_t outputLen) +{ + if (ktInstance->phase != SQUEEZING) + return 1; + return KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->finalNode, output, outputLen); +} + +int KangarooTwelve( const unsigned char * input, size_t inLen, unsigned char * output, size_t outLen, const unsigned char * customization, size_t customLen ) +{ + KangarooTwelve_Instance ktInstance; + + if (outLen == 0) + return 1; + if (KangarooTwelve_Initialize(&ktInstance, outLen) != 0) + return 1; + if (KangarooTwelve_Update(&ktInstance, input, inLen) != 0) + return 1; + return KangarooTwelve_Final(&ktInstance, output, customization, customLen); +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.h new file mode 100644 index 000000000..6b9edfa55 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/KangarooTwelve.h @@ -0,0 +1,110 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ +*/ + +#ifndef _KangarooTwelve_h_ +#define _KangarooTwelve_h_ + +#include +#include "KeccakP-1600-SnP.h" + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +ALIGN(KeccakP1600_stateAlignment) typedef struct KeccakWidth1600_12rounds_SpongeInstanceStruct { + unsigned char state[KeccakP1600_stateSizeInBytes]; + unsigned int rate; + unsigned int byteIOIndex; + int squeezing; +} KeccakWidth1600_12rounds_SpongeInstance; + +typedef enum { + NOT_INITIALIZED, + ABSORBING, + FINAL, + SQUEEZING +} KCP_Phases; +typedef KCP_Phases KangarooTwelve_Phases; + +typedef struct { + KeccakWidth1600_12rounds_SpongeInstance queueNode; + KeccakWidth1600_12rounds_SpongeInstance finalNode; + size_t fixedOutputLength; + size_t blockNumber; + unsigned int queueAbsorbedLen; + KangarooTwelve_Phases phase; +} KangarooTwelve_Instance; + +/** Extendable ouput function KangarooTwelve. + * @param input Pointer to the input message (M). + * @param inputByteLen The length of the input message in bytes. + * @param output Pointer to the output buffer. + * @param outputByteLen The desired number of output bytes. + * @param customization Pointer to the customization string (C). + * @param customByteLen The length of the customization string in bytes. + * @return 0 if successful, 1 otherwise. + */ +int KangarooTwelve(const unsigned char *input, size_t inputByteLen, unsigned char *output, size_t outputByteLen, const unsigned char *customization, size_t customByteLen ); + +/** + * Function to initialize a KangarooTwelve instance. + * @param ktInstance Pointer to the instance to be initialized. + * @param outputByteLen The desired number of output bytes, + * or 0 for an arbitrarily-long output. + * @return 0 if successful, 1 otherwise. + */ +int KangarooTwelve_Initialize(KangarooTwelve_Instance *ktInstance, size_t outputByteLen); + +/** + * Function to give input data to be absorbed. + * @param ktInstance Pointer to the instance initialized by KangarooTwelve_Initialize(). + * @param input Pointer to the input message data (M). + * @param inputByteLen The number of bytes provided in the input message data. + * @return 0 if successful, 1 otherwise. + */ +int KangarooTwelve_Update(KangarooTwelve_Instance *ktInstance, const unsigned char *input, size_t inputByteLen); + +/** + * Function to call after all the input message has been input, and to get + * output bytes if the length was specified when calling KangarooTwelve_Initialize(). + * @param ktInstance Pointer to the hash instance initialized by KangarooTwelve_Initialize(). + * If @a outputByteLen was not 0 in the call to KangarooTwelve_Initialize(), the number of + * output bytes is equal to @a outputByteLen. + * If @a outputByteLen was 0 in the call to KangarooTwelve_Initialize(), the output bytes + * must be extracted using the KangarooTwelve_Squeeze() function. + * @param output Pointer to the buffer where to store the output data. + * @param customization Pointer to the customization string (C). + * @param customByteLen The length of the customization string in bytes. + * @return 0 if successful, 1 otherwise. + */ +int KangarooTwelve_Final(KangarooTwelve_Instance *ktInstance, unsigned char *output, const unsigned char *customization, size_t customByteLen); + +/** + * Function to squeeze output data. + * @param ktInstance Pointer to the hash instance initialized by KangarooTwelve_Initialize(). + * @param data Pointer to the buffer where to store the output data. + * @param outputByteLen The number of output bytes desired. + * @pre KangarooTwelve_Final() must have been already called. + * @return 0 if successful, 1 otherwise. + */ +int KangarooTwelve_Squeeze(KangarooTwelve_Instance *ktInstance, unsigned char *output, size_t outputByteLen); + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-SnP.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-SnP.h new file mode 100644 index 000000000..a5f5b640f --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-SnP.h @@ -0,0 +1,45 @@ +/* +Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen, +Michaël Peeters, Gilles Van Assche and Ronny Van Keer, +hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#ifndef _KeccakP_1600_SnP_h_ +#define _KeccakP_1600_SnP_h_ + +#include "brg_endian.h" +#include "KeccakP-1600-config.h" + +#define KeccakP1600_implementation "generic 64-bit optimized implementation (" KeccakP1600_implementation_config ")" +#define KeccakP1600_stateSizeInBytes 200 +#define KeccakP1600_stateAlignment 8 +#define KeccakF1600_FastLoop_supported +#define KeccakP1600_12rounds_FastLoop_supported + +#include + +#define KeccakP1600_StaticInitialize() +void KeccakP1600_Initialize(void *state); +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) +#define KeccakP1600_AddByte(state, byte, offset) \ + ((unsigned char*)(state))[(offset)] ^= (byte) +#else +void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset); +#endif +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600_Permute_12rounds(void *state); +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); +size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen); + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-config.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-config.h new file mode 100644 index 000000000..ec3d0f790 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-config.h @@ -0,0 +1,30 @@ +#define KeccakP1600_implementation_config "all rounds unrolled" +#define KeccakP1600_fullUnrolling + +/* Or */ +/* +#define KeccakP1600_implementation_config "6 rounds unrolled" +#define KeccakP1600_unrolling 6 +*/ + +/* Or */ +/* +#define KeccakP1600_implementation_config "lane complementing, 6 rounds unrolled" +#define KeccakP1600_unrolling 6 +#define KeccakP1600_useLaneComplementing +*/ + +/* Or */ +/* +#define KeccakP1600_implementation_config "lane complementing, all rounds unrolled" +#define KeccakP1600_fullUnrolling +#define KeccakP1600_useLaneComplementing +*/ + +/* Or */ +/* +#define KeccakP1600_implementation_config "lane complementing, all rounds unrolled, using SHLD for rotations" +#define KeccakP1600_fullUnrolling +#define KeccakP1600_useLaneComplementing +#define KeccakP1600_useSHLD +*/ diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-opt64.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-opt64.c new file mode 100644 index 000000000..b1ac3b256 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/Optimized64/KeccakP-1600-opt64.c @@ -0,0 +1,1159 @@ +/* +Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen, +Michaël Peeters, Gilles Van Assche and Ronny Van Keer, +hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include +#include "brg_endian.h" +#include "KeccakP-1600-config.h" + +typedef unsigned char UINT8; +typedef unsigned long long int UINT64; + +#if defined(KeccakP1600_useLaneComplementing) +#define UseBebigokimisa +#endif + +#if defined(_MSC_VER) +#define ROL64(a, offset) _rotl64(a, offset) +#elif defined(KeccakP1600_useSHLD) + #define ROL64(x,N) ({ \ + register UINT64 __out; \ + register UINT64 __in = x; \ + __asm__ ("shld %2,%0,%0" : "=r"(__out) : "0"(__in), "i"(N)); \ + __out; \ + }) +#else +#define ROL64(a, offset) ((((UINT64)a) << offset) ^ (((UINT64)a) >> (64-offset))) +#endif + +#ifdef KeccakP1600_fullUnrolling +#define FullUnrolling +#else +#define Unrolling KeccakP1600_unrolling +#endif + +static const UINT64 KeccakF1600RoundConstants[24] = { + 0x0000000000000001ULL, + 0x0000000000008082ULL, + 0x800000000000808aULL, + 0x8000000080008000ULL, + 0x000000000000808bULL, + 0x0000000080000001ULL, + 0x8000000080008081ULL, + 0x8000000000008009ULL, + 0x000000000000008aULL, + 0x0000000000000088ULL, + 0x0000000080008009ULL, + 0x000000008000000aULL, + 0x000000008000808bULL, + 0x800000000000008bULL, + 0x8000000000008089ULL, + 0x8000000000008003ULL, + 0x8000000000008002ULL, + 0x8000000000000080ULL, + 0x000000000000800aULL, + 0x800000008000000aULL, + 0x8000000080008081ULL, + 0x8000000000008080ULL, + 0x0000000080000001ULL, + 0x8000000080008008ULL }; + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_Initialize(void *state) +{ + memset(state, 0, 200); +#ifdef KeccakP1600_useLaneComplementing + ((UINT64*)state)[ 1] = ~(UINT64)0; + ((UINT64*)state)[ 2] = ~(UINT64)0; + ((UINT64*)state)[ 8] = ~(UINT64)0; + ((UINT64*)state)[12] = ~(UINT64)0; + ((UINT64*)state)[17] = ~(UINT64)0; + ((UINT64*)state)[20] = ~(UINT64)0; +#endif +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length) +{ +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + UINT64 lane; + if (length == 0) + return; + if (length == 1) + lane = data[0]; + else { + lane = 0; + memcpy(&lane, data, length); + } + lane <<= offset*8; +#else + UINT64 lane = 0; + unsigned int i; + for(i=0; i 0) { \ + unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \ + if (_bytesInLane > _sizeLeft) \ + _bytesInLane = _sizeLeft; \ + SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \ + _sizeLeft -= _bytesInLane; \ + _lanePosition++; \ + _offsetInLane = 0; \ + _curData += _bytesInLane; \ + } \ + } \ + } + +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length) +{ + SnP_AddBytes(state, data, offset, length, KeccakP1600_AddLanes, KeccakP1600_AddBytesInLane, 8); +} + +/* ---------------------------------------------------------------- */ + +#define declareABCDE \ + UINT64 Aba, Abe, Abi, Abo, Abu; \ + UINT64 Aga, Age, Agi, Ago, Agu; \ + UINT64 Aka, Ake, Aki, Ako, Aku; \ + UINT64 Ama, Ame, Ami, Amo, Amu; \ + UINT64 Asa, Ase, Asi, Aso, Asu; \ + UINT64 Bba, Bbe, Bbi, Bbo, Bbu; \ + UINT64 Bga, Bge, Bgi, Bgo, Bgu; \ + UINT64 Bka, Bke, Bki, Bko, Bku; \ + UINT64 Bma, Bme, Bmi, Bmo, Bmu; \ + UINT64 Bsa, Bse, Bsi, Bso, Bsu; \ + UINT64 Ca, Ce, Ci, Co, Cu; \ + UINT64 Da, De, Di, Do, Du; \ + UINT64 Eba, Ebe, Ebi, Ebo, Ebu; \ + UINT64 Ega, Ege, Egi, Ego, Egu; \ + UINT64 Eka, Eke, Eki, Eko, Eku; \ + UINT64 Ema, Eme, Emi, Emo, Emu; \ + UINT64 Esa, Ese, Esi, Eso, Esu; \ + +#define prepareTheta \ + Ca = Aba^Aga^Aka^Ama^Asa; \ + Ce = Abe^Age^Ake^Ame^Ase; \ + Ci = Abi^Agi^Aki^Ami^Asi; \ + Co = Abo^Ago^Ako^Amo^Aso; \ + Cu = Abu^Agu^Aku^Amu^Asu; \ + +#ifdef UseBebigokimisa +/* --- Code for round, with prepare-theta (lane complementing pattern 'bebigokimisa') */ +/* --- 64-bit lanes mapped to 64-bit words */ +#define thetaRhoPiChiIotaPrepareTheta(i, A, E) \ + Da = Cu^ROL64(Ce, 1); \ + De = Ca^ROL64(Ci, 1); \ + Di = Ce^ROL64(Co, 1); \ + Do = Ci^ROL64(Cu, 1); \ + Du = Co^ROL64(Ca, 1); \ +\ + A##ba ^= Da; \ + Bba = A##ba; \ + A##ge ^= De; \ + Bbe = ROL64(A##ge, 44); \ + A##ki ^= Di; \ + Bbi = ROL64(A##ki, 43); \ + A##mo ^= Do; \ + Bbo = ROL64(A##mo, 21); \ + A##su ^= Du; \ + Bbu = ROL64(A##su, 14); \ + E##ba = Bba ^( Bbe | Bbi ); \ + E##ba ^= KeccakF1600RoundConstants[i]; \ + Ca = E##ba; \ + E##be = Bbe ^((~Bbi)| Bbo ); \ + Ce = E##be; \ + E##bi = Bbi ^( Bbo & Bbu ); \ + Ci = E##bi; \ + E##bo = Bbo ^( Bbu | Bba ); \ + Co = E##bo; \ + E##bu = Bbu ^( Bba & Bbe ); \ + Cu = E##bu; \ +\ + A##bo ^= Do; \ + Bga = ROL64(A##bo, 28); \ + A##gu ^= Du; \ + Bge = ROL64(A##gu, 20); \ + A##ka ^= Da; \ + Bgi = ROL64(A##ka, 3); \ + A##me ^= De; \ + Bgo = ROL64(A##me, 45); \ + A##si ^= Di; \ + Bgu = ROL64(A##si, 61); \ + E##ga = Bga ^( Bge | Bgi ); \ + Ca ^= E##ga; \ + E##ge = Bge ^( Bgi & Bgo ); \ + Ce ^= E##ge; \ + E##gi = Bgi ^( Bgo |(~Bgu)); \ + Ci ^= E##gi; \ + E##go = Bgo ^( Bgu | Bga ); \ + Co ^= E##go; \ + E##gu = Bgu ^( Bga & Bge ); \ + Cu ^= E##gu; \ +\ + A##be ^= De; \ + Bka = ROL64(A##be, 1); \ + A##gi ^= Di; \ + Bke = ROL64(A##gi, 6); \ + A##ko ^= Do; \ + Bki = ROL64(A##ko, 25); \ + A##mu ^= Du; \ + Bko = ROL64(A##mu, 8); \ + A##sa ^= Da; \ + Bku = ROL64(A##sa, 18); \ + E##ka = Bka ^( Bke | Bki ); \ + Ca ^= E##ka; \ + E##ke = Bke ^( Bki & Bko ); \ + Ce ^= E##ke; \ + E##ki = Bki ^((~Bko)& Bku ); \ + Ci ^= E##ki; \ + E##ko = (~Bko)^( Bku | Bka ); \ + Co ^= E##ko; \ + E##ku = Bku ^( Bka & Bke ); \ + Cu ^= E##ku; \ +\ + A##bu ^= Du; \ + Bma = ROL64(A##bu, 27); \ + A##ga ^= Da; \ + Bme = ROL64(A##ga, 36); \ + A##ke ^= De; \ + Bmi = ROL64(A##ke, 10); \ + A##mi ^= Di; \ + Bmo = ROL64(A##mi, 15); \ + A##so ^= Do; \ + Bmu = ROL64(A##so, 56); \ + E##ma = Bma ^( Bme & Bmi ); \ + Ca ^= E##ma; \ + E##me = Bme ^( Bmi | Bmo ); \ + Ce ^= E##me; \ + E##mi = Bmi ^((~Bmo)| Bmu ); \ + Ci ^= E##mi; \ + E##mo = (~Bmo)^( Bmu & Bma ); \ + Co ^= E##mo; \ + E##mu = Bmu ^( Bma | Bme ); \ + Cu ^= E##mu; \ +\ + A##bi ^= Di; \ + Bsa = ROL64(A##bi, 62); \ + A##go ^= Do; \ + Bse = ROL64(A##go, 55); \ + A##ku ^= Du; \ + Bsi = ROL64(A##ku, 39); \ + A##ma ^= Da; \ + Bso = ROL64(A##ma, 41); \ + A##se ^= De; \ + Bsu = ROL64(A##se, 2); \ + E##sa = Bsa ^((~Bse)& Bsi ); \ + Ca ^= E##sa; \ + E##se = (~Bse)^( Bsi | Bso ); \ + Ce ^= E##se; \ + E##si = Bsi ^( Bso & Bsu ); \ + Ci ^= E##si; \ + E##so = Bso ^( Bsu | Bsa ); \ + Co ^= E##so; \ + E##su = Bsu ^( Bsa & Bse ); \ + Cu ^= E##su; \ +\ + +/* --- Code for round (lane complementing pattern 'bebigokimisa') */ +/* --- 64-bit lanes mapped to 64-bit words */ +#define thetaRhoPiChiIota(i, A, E) \ + Da = Cu^ROL64(Ce, 1); \ + De = Ca^ROL64(Ci, 1); \ + Di = Ce^ROL64(Co, 1); \ + Do = Ci^ROL64(Cu, 1); \ + Du = Co^ROL64(Ca, 1); \ +\ + A##ba ^= Da; \ + Bba = A##ba; \ + A##ge ^= De; \ + Bbe = ROL64(A##ge, 44); \ + A##ki ^= Di; \ + Bbi = ROL64(A##ki, 43); \ + A##mo ^= Do; \ + Bbo = ROL64(A##mo, 21); \ + A##su ^= Du; \ + Bbu = ROL64(A##su, 14); \ + E##ba = Bba ^( Bbe | Bbi ); \ + E##ba ^= KeccakF1600RoundConstants[i]; \ + E##be = Bbe ^((~Bbi)| Bbo ); \ + E##bi = Bbi ^( Bbo & Bbu ); \ + E##bo = Bbo ^( Bbu | Bba ); \ + E##bu = Bbu ^( Bba & Bbe ); \ +\ + A##bo ^= Do; \ + Bga = ROL64(A##bo, 28); \ + A##gu ^= Du; \ + Bge = ROL64(A##gu, 20); \ + A##ka ^= Da; \ + Bgi = ROL64(A##ka, 3); \ + A##me ^= De; \ + Bgo = ROL64(A##me, 45); \ + A##si ^= Di; \ + Bgu = ROL64(A##si, 61); \ + E##ga = Bga ^( Bge | Bgi ); \ + E##ge = Bge ^( Bgi & Bgo ); \ + E##gi = Bgi ^( Bgo |(~Bgu)); \ + E##go = Bgo ^( Bgu | Bga ); \ + E##gu = Bgu ^( Bga & Bge ); \ +\ + A##be ^= De; \ + Bka = ROL64(A##be, 1); \ + A##gi ^= Di; \ + Bke = ROL64(A##gi, 6); \ + A##ko ^= Do; \ + Bki = ROL64(A##ko, 25); \ + A##mu ^= Du; \ + Bko = ROL64(A##mu, 8); \ + A##sa ^= Da; \ + Bku = ROL64(A##sa, 18); \ + E##ka = Bka ^( Bke | Bki ); \ + E##ke = Bke ^( Bki & Bko ); \ + E##ki = Bki ^((~Bko)& Bku ); \ + E##ko = (~Bko)^( Bku | Bka ); \ + E##ku = Bku ^( Bka & Bke ); \ +\ + A##bu ^= Du; \ + Bma = ROL64(A##bu, 27); \ + A##ga ^= Da; \ + Bme = ROL64(A##ga, 36); \ + A##ke ^= De; \ + Bmi = ROL64(A##ke, 10); \ + A##mi ^= Di; \ + Bmo = ROL64(A##mi, 15); \ + A##so ^= Do; \ + Bmu = ROL64(A##so, 56); \ + E##ma = Bma ^( Bme & Bmi ); \ + E##me = Bme ^( Bmi | Bmo ); \ + E##mi = Bmi ^((~Bmo)| Bmu ); \ + E##mo = (~Bmo)^( Bmu & Bma ); \ + E##mu = Bmu ^( Bma | Bme ); \ +\ + A##bi ^= Di; \ + Bsa = ROL64(A##bi, 62); \ + A##go ^= Do; \ + Bse = ROL64(A##go, 55); \ + A##ku ^= Du; \ + Bsi = ROL64(A##ku, 39); \ + A##ma ^= Da; \ + Bso = ROL64(A##ma, 41); \ + A##se ^= De; \ + Bsu = ROL64(A##se, 2); \ + E##sa = Bsa ^((~Bse)& Bsi ); \ + E##se = (~Bse)^( Bsi | Bso ); \ + E##si = Bsi ^( Bso & Bsu ); \ + E##so = Bso ^( Bsu | Bsa ); \ + E##su = Bsu ^( Bsa & Bse ); \ +\ + +#else /* UseBebigokimisa */ +/* --- Code for round, with prepare-theta */ +/* --- 64-bit lanes mapped to 64-bit words */ +#define thetaRhoPiChiIotaPrepareTheta(i, A, E) \ + Da = Cu^ROL64(Ce, 1); \ + De = Ca^ROL64(Ci, 1); \ + Di = Ce^ROL64(Co, 1); \ + Do = Ci^ROL64(Cu, 1); \ + Du = Co^ROL64(Ca, 1); \ +\ + A##ba ^= Da; \ + Bba = A##ba; \ + A##ge ^= De; \ + Bbe = ROL64(A##ge, 44); \ + A##ki ^= Di; \ + Bbi = ROL64(A##ki, 43); \ + A##mo ^= Do; \ + Bbo = ROL64(A##mo, 21); \ + A##su ^= Du; \ + Bbu = ROL64(A##su, 14); \ + E##ba = Bba ^((~Bbe)& Bbi ); \ + E##ba ^= KeccakF1600RoundConstants[i]; \ + Ca = E##ba; \ + E##be = Bbe ^((~Bbi)& Bbo ); \ + Ce = E##be; \ + E##bi = Bbi ^((~Bbo)& Bbu ); \ + Ci = E##bi; \ + E##bo = Bbo ^((~Bbu)& Bba ); \ + Co = E##bo; \ + E##bu = Bbu ^((~Bba)& Bbe ); \ + Cu = E##bu; \ +\ + A##bo ^= Do; \ + Bga = ROL64(A##bo, 28); \ + A##gu ^= Du; \ + Bge = ROL64(A##gu, 20); \ + A##ka ^= Da; \ + Bgi = ROL64(A##ka, 3); \ + A##me ^= De; \ + Bgo = ROL64(A##me, 45); \ + A##si ^= Di; \ + Bgu = ROL64(A##si, 61); \ + E##ga = Bga ^((~Bge)& Bgi ); \ + Ca ^= E##ga; \ + E##ge = Bge ^((~Bgi)& Bgo ); \ + Ce ^= E##ge; \ + E##gi = Bgi ^((~Bgo)& Bgu ); \ + Ci ^= E##gi; \ + E##go = Bgo ^((~Bgu)& Bga ); \ + Co ^= E##go; \ + E##gu = Bgu ^((~Bga)& Bge ); \ + Cu ^= E##gu; \ +\ + A##be ^= De; \ + Bka = ROL64(A##be, 1); \ + A##gi ^= Di; \ + Bke = ROL64(A##gi, 6); \ + A##ko ^= Do; \ + Bki = ROL64(A##ko, 25); \ + A##mu ^= Du; \ + Bko = ROL64(A##mu, 8); \ + A##sa ^= Da; \ + Bku = ROL64(A##sa, 18); \ + E##ka = Bka ^((~Bke)& Bki ); \ + Ca ^= E##ka; \ + E##ke = Bke ^((~Bki)& Bko ); \ + Ce ^= E##ke; \ + E##ki = Bki ^((~Bko)& Bku ); \ + Ci ^= E##ki; \ + E##ko = Bko ^((~Bku)& Bka ); \ + Co ^= E##ko; \ + E##ku = Bku ^((~Bka)& Bke ); \ + Cu ^= E##ku; \ +\ + A##bu ^= Du; \ + Bma = ROL64(A##bu, 27); \ + A##ga ^= Da; \ + Bme = ROL64(A##ga, 36); \ + A##ke ^= De; \ + Bmi = ROL64(A##ke, 10); \ + A##mi ^= Di; \ + Bmo = ROL64(A##mi, 15); \ + A##so ^= Do; \ + Bmu = ROL64(A##so, 56); \ + E##ma = Bma ^((~Bme)& Bmi ); \ + Ca ^= E##ma; \ + E##me = Bme ^((~Bmi)& Bmo ); \ + Ce ^= E##me; \ + E##mi = Bmi ^((~Bmo)& Bmu ); \ + Ci ^= E##mi; \ + E##mo = Bmo ^((~Bmu)& Bma ); \ + Co ^= E##mo; \ + E##mu = Bmu ^((~Bma)& Bme ); \ + Cu ^= E##mu; \ +\ + A##bi ^= Di; \ + Bsa = ROL64(A##bi, 62); \ + A##go ^= Do; \ + Bse = ROL64(A##go, 55); \ + A##ku ^= Du; \ + Bsi = ROL64(A##ku, 39); \ + A##ma ^= Da; \ + Bso = ROL64(A##ma, 41); \ + A##se ^= De; \ + Bsu = ROL64(A##se, 2); \ + E##sa = Bsa ^((~Bse)& Bsi ); \ + Ca ^= E##sa; \ + E##se = Bse ^((~Bsi)& Bso ); \ + Ce ^= E##se; \ + E##si = Bsi ^((~Bso)& Bsu ); \ + Ci ^= E##si; \ + E##so = Bso ^((~Bsu)& Bsa ); \ + Co ^= E##so; \ + E##su = Bsu ^((~Bsa)& Bse ); \ + Cu ^= E##su; \ +\ + +/* --- Code for round */ +/* --- 64-bit lanes mapped to 64-bit words */ +#define thetaRhoPiChiIota(i, A, E) \ + Da = Cu^ROL64(Ce, 1); \ + De = Ca^ROL64(Ci, 1); \ + Di = Ce^ROL64(Co, 1); \ + Do = Ci^ROL64(Cu, 1); \ + Du = Co^ROL64(Ca, 1); \ +\ + A##ba ^= Da; \ + Bba = A##ba; \ + A##ge ^= De; \ + Bbe = ROL64(A##ge, 44); \ + A##ki ^= Di; \ + Bbi = ROL64(A##ki, 43); \ + A##mo ^= Do; \ + Bbo = ROL64(A##mo, 21); \ + A##su ^= Du; \ + Bbu = ROL64(A##su, 14); \ + E##ba = Bba ^((~Bbe)& Bbi ); \ + E##ba ^= KeccakF1600RoundConstants[i]; \ + E##be = Bbe ^((~Bbi)& Bbo ); \ + E##bi = Bbi ^((~Bbo)& Bbu ); \ + E##bo = Bbo ^((~Bbu)& Bba ); \ + E##bu = Bbu ^((~Bba)& Bbe ); \ +\ + A##bo ^= Do; \ + Bga = ROL64(A##bo, 28); \ + A##gu ^= Du; \ + Bge = ROL64(A##gu, 20); \ + A##ka ^= Da; \ + Bgi = ROL64(A##ka, 3); \ + A##me ^= De; \ + Bgo = ROL64(A##me, 45); \ + A##si ^= Di; \ + Bgu = ROL64(A##si, 61); \ + E##ga = Bga ^((~Bge)& Bgi ); \ + E##ge = Bge ^((~Bgi)& Bgo ); \ + E##gi = Bgi ^((~Bgo)& Bgu ); \ + E##go = Bgo ^((~Bgu)& Bga ); \ + E##gu = Bgu ^((~Bga)& Bge ); \ +\ + A##be ^= De; \ + Bka = ROL64(A##be, 1); \ + A##gi ^= Di; \ + Bke = ROL64(A##gi, 6); \ + A##ko ^= Do; \ + Bki = ROL64(A##ko, 25); \ + A##mu ^= Du; \ + Bko = ROL64(A##mu, 8); \ + A##sa ^= Da; \ + Bku = ROL64(A##sa, 18); \ + E##ka = Bka ^((~Bke)& Bki ); \ + E##ke = Bke ^((~Bki)& Bko ); \ + E##ki = Bki ^((~Bko)& Bku ); \ + E##ko = Bko ^((~Bku)& Bka ); \ + E##ku = Bku ^((~Bka)& Bke ); \ +\ + A##bu ^= Du; \ + Bma = ROL64(A##bu, 27); \ + A##ga ^= Da; \ + Bme = ROL64(A##ga, 36); \ + A##ke ^= De; \ + Bmi = ROL64(A##ke, 10); \ + A##mi ^= Di; \ + Bmo = ROL64(A##mi, 15); \ + A##so ^= Do; \ + Bmu = ROL64(A##so, 56); \ + E##ma = Bma ^((~Bme)& Bmi ); \ + E##me = Bme ^((~Bmi)& Bmo ); \ + E##mi = Bmi ^((~Bmo)& Bmu ); \ + E##mo = Bmo ^((~Bmu)& Bma ); \ + E##mu = Bmu ^((~Bma)& Bme ); \ +\ + A##bi ^= Di; \ + Bsa = ROL64(A##bi, 62); \ + A##go ^= Do; \ + Bse = ROL64(A##go, 55); \ + A##ku ^= Du; \ + Bsi = ROL64(A##ku, 39); \ + A##ma ^= Da; \ + Bso = ROL64(A##ma, 41); \ + A##se ^= De; \ + Bsu = ROL64(A##se, 2); \ + E##sa = Bsa ^((~Bse)& Bsi ); \ + E##se = Bse ^((~Bsi)& Bso ); \ + E##si = Bsi ^((~Bso)& Bsu ); \ + E##so = Bso ^((~Bsu)& Bsa ); \ + E##su = Bsu ^((~Bsa)& Bse ); \ +\ + +#endif /* UseBebigokimisa */ + +#define copyFromState(X, state) \ + X##ba = state[ 0]; \ + X##be = state[ 1]; \ + X##bi = state[ 2]; \ + X##bo = state[ 3]; \ + X##bu = state[ 4]; \ + X##ga = state[ 5]; \ + X##ge = state[ 6]; \ + X##gi = state[ 7]; \ + X##go = state[ 8]; \ + X##gu = state[ 9]; \ + X##ka = state[10]; \ + X##ke = state[11]; \ + X##ki = state[12]; \ + X##ko = state[13]; \ + X##ku = state[14]; \ + X##ma = state[15]; \ + X##me = state[16]; \ + X##mi = state[17]; \ + X##mo = state[18]; \ + X##mu = state[19]; \ + X##sa = state[20]; \ + X##se = state[21]; \ + X##si = state[22]; \ + X##so = state[23]; \ + X##su = state[24]; \ + +#define copyToState(state, X) \ + state[ 0] = X##ba; \ + state[ 1] = X##be; \ + state[ 2] = X##bi; \ + state[ 3] = X##bo; \ + state[ 4] = X##bu; \ + state[ 5] = X##ga; \ + state[ 6] = X##ge; \ + state[ 7] = X##gi; \ + state[ 8] = X##go; \ + state[ 9] = X##gu; \ + state[10] = X##ka; \ + state[11] = X##ke; \ + state[12] = X##ki; \ + state[13] = X##ko; \ + state[14] = X##ku; \ + state[15] = X##ma; \ + state[16] = X##me; \ + state[17] = X##mi; \ + state[18] = X##mo; \ + state[19] = X##mu; \ + state[20] = X##sa; \ + state[21] = X##se; \ + state[22] = X##si; \ + state[23] = X##so; \ + state[24] = X##su; \ + +#define copyStateVariables(X, Y) \ + X##ba = Y##ba; \ + X##be = Y##be; \ + X##bi = Y##bi; \ + X##bo = Y##bo; \ + X##bu = Y##bu; \ + X##ga = Y##ga; \ + X##ge = Y##ge; \ + X##gi = Y##gi; \ + X##go = Y##go; \ + X##gu = Y##gu; \ + X##ka = Y##ka; \ + X##ke = Y##ke; \ + X##ki = Y##ki; \ + X##ko = Y##ko; \ + X##ku = Y##ku; \ + X##ma = Y##ma; \ + X##me = Y##me; \ + X##mi = Y##mi; \ + X##mo = Y##mo; \ + X##mu = Y##mu; \ + X##sa = Y##sa; \ + X##se = Y##se; \ + X##si = Y##si; \ + X##so = Y##so; \ + X##su = Y##su; \ + +#if ((defined(FullUnrolling)) || (Unrolling == 12)) +#define rounds12 \ + prepareTheta \ + thetaRhoPiChiIotaPrepareTheta(12, A, E) \ + thetaRhoPiChiIotaPrepareTheta(13, E, A) \ + thetaRhoPiChiIotaPrepareTheta(14, A, E) \ + thetaRhoPiChiIotaPrepareTheta(15, E, A) \ + thetaRhoPiChiIotaPrepareTheta(16, A, E) \ + thetaRhoPiChiIotaPrepareTheta(17, E, A) \ + thetaRhoPiChiIotaPrepareTheta(18, A, E) \ + thetaRhoPiChiIotaPrepareTheta(19, E, A) \ + thetaRhoPiChiIotaPrepareTheta(20, A, E) \ + thetaRhoPiChiIotaPrepareTheta(21, E, A) \ + thetaRhoPiChiIotaPrepareTheta(22, A, E) \ + thetaRhoPiChiIota(23, E, A) \ + +#elif (Unrolling == 6) +#define rounds12 \ + prepareTheta \ + for(i=12; i<24; i+=6) { \ + thetaRhoPiChiIotaPrepareTheta(i , A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \ + thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \ + thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \ + } \ + +#elif (Unrolling == 4) +#define rounds12 \ + prepareTheta \ + for(i=12; i<24; i+=4) { \ + thetaRhoPiChiIotaPrepareTheta(i , A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \ + thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \ + } \ + +#elif (Unrolling == 3) +#define rounds12 \ + prepareTheta \ + for(i=12; i<24; i+=3) { \ + thetaRhoPiChiIotaPrepareTheta(i , A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \ + thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \ + copyStateVariables(A, E) \ + } \ + +#elif (Unrolling == 2) +#define rounds12 \ + prepareTheta \ + for(i=12; i<24; i+=2) { \ + thetaRhoPiChiIotaPrepareTheta(i , A, E) \ + thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \ + } \ + +#elif (Unrolling == 1) +#define rounds12 \ + prepareTheta \ + for(i=12; i<24; i++) { \ + thetaRhoPiChiIotaPrepareTheta(i , A, E) \ + copyStateVariables(A, E) \ + } \ + +#else +#error "Unrolling is not correctly specified!" +#endif + +void KeccakP1600_Permute_12rounds(void *state) +{ + declareABCDE + #ifndef KeccakP1600_fullUnrolling + unsigned int i; + #endif + UINT64 *stateAsLanes = (UINT64*)state; + + copyFromState(A, stateAsLanes) + rounds12 + copyToState(stateAsLanes, A) +} + +/* ---------------------------------------------------------------- */ + +void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length) +{ + UINT64 lane = ((UINT64*)state)[lanePosition]; +#ifdef KeccakP1600_useLaneComplementing + if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20)) + lane = ~lane; +#endif +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + { + UINT64 lane1[1]; + lane1[0] = lane; + memcpy(data, (UINT8*)lane1+offset, length); + } +#else + unsigned int i; + lane >>= offset*8; + for(i=0; i>= 8; + } +#endif +} + +/* ---------------------------------------------------------------- */ + +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +static void fromWordToBytes(UINT8 *bytes, const UINT64 word) +{ + unsigned int i; + + for(i=0; i<(64/8); i++) + bytes[i] = (word >> (8*i)) & 0xFF; +} +#endif + +void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount) +{ +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) + memcpy(data, state, laneCount*8); +#else + unsigned int i; + + for(i=0; i 1) { + ((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1]; + if (laneCount > 2) { + ((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2]; + if (laneCount > 8) { + ((UINT64*)data)[ 8] = ~((UINT64*)data)[ 8]; + if (laneCount > 12) { + ((UINT64*)data)[12] = ~((UINT64*)data)[12]; + if (laneCount > 17) { + ((UINT64*)data)[17] = ~((UINT64*)data)[17]; + if (laneCount > 20) { + ((UINT64*)data)[20] = ~((UINT64*)data)[20]; + } + } + } + } + } + } +#endif +} + +/* ---------------------------------------------------------------- */ + +#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \ + { \ + if ((offset) == 0) { \ + SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \ + SnP_ExtractBytesInLane(state, \ + (length)/SnP_laneLengthInBytes, \ + (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \ + 0, \ + (length)%SnP_laneLengthInBytes); \ + } \ + else { \ + unsigned int _sizeLeft = (length); \ + unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \ + unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \ + unsigned char *_curData = (data); \ + while(_sizeLeft > 0) { \ + unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \ + if (_bytesInLane > _sizeLeft) \ + _bytesInLane = _sizeLeft; \ + SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \ + _sizeLeft -= _bytesInLane; \ + _lanePosition++; \ + _offsetInLane = 0; \ + _curData += _bytesInLane; \ + } \ + } \ + } + +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length) +{ + SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8); +} + +/* ---------------------------------------------------------------- */ + +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) +#define HTOLE64(x) (x) +#else +#define HTOLE64(x) (\ + ((x & 0xff00000000000000ull) >> 56) | \ + ((x & 0x00ff000000000000ull) >> 40) | \ + ((x & 0x0000ff0000000000ull) >> 24) | \ + ((x & 0x000000ff00000000ull) >> 8) | \ + ((x & 0x00000000ff000000ull) << 8) | \ + ((x & 0x0000000000ff0000ull) << 24) | \ + ((x & 0x000000000000ff00ull) << 40) | \ + ((x & 0x00000000000000ffull) << 56)) +#endif + +#define addInput(X, input, laneCount) \ + if (laneCount == 21) { \ + X##ba ^= HTOLE64(input[ 0]); \ + X##be ^= HTOLE64(input[ 1]); \ + X##bi ^= HTOLE64(input[ 2]); \ + X##bo ^= HTOLE64(input[ 3]); \ + X##bu ^= HTOLE64(input[ 4]); \ + X##ga ^= HTOLE64(input[ 5]); \ + X##ge ^= HTOLE64(input[ 6]); \ + X##gi ^= HTOLE64(input[ 7]); \ + X##go ^= HTOLE64(input[ 8]); \ + X##gu ^= HTOLE64(input[ 9]); \ + X##ka ^= HTOLE64(input[10]); \ + X##ke ^= HTOLE64(input[11]); \ + X##ki ^= HTOLE64(input[12]); \ + X##ko ^= HTOLE64(input[13]); \ + X##ku ^= HTOLE64(input[14]); \ + X##ma ^= HTOLE64(input[15]); \ + X##me ^= HTOLE64(input[16]); \ + X##mi ^= HTOLE64(input[17]); \ + X##mo ^= HTOLE64(input[18]); \ + X##mu ^= HTOLE64(input[19]); \ + X##sa ^= HTOLE64(input[20]); \ + } \ + else if (laneCount < 16) { \ + if (laneCount < 8) { \ + if (laneCount < 4) { \ + if (laneCount < 2) { \ + if (laneCount < 1) { \ + } \ + else { \ + X##ba ^= HTOLE64(input[ 0]); \ + } \ + } \ + else { \ + X##ba ^= HTOLE64(input[ 0]); \ + X##be ^= HTOLE64(input[ 1]); \ + if (laneCount < 3) { \ + } \ + else { \ + X##bi ^= HTOLE64(input[ 2]); \ + } \ + } \ + } \ + else { \ + X##ba ^= HTOLE64(input[ 0]); \ + X##be ^= HTOLE64(input[ 1]); \ + X##bi ^= HTOLE64(input[ 2]); \ + X##bo ^= HTOLE64(input[ 3]); \ + if (laneCount < 6) { \ + if (laneCount < 5) { \ + } \ + else { \ + X##bu ^= HTOLE64(input[ 4]); \ + } \ + } \ + else { \ + X##bu ^= HTOLE64(input[ 4]); \ + X##ga ^= HTOLE64(input[ 5]); \ + if (laneCount < 7) { \ + } \ + else { \ + X##ge ^= HTOLE64(input[ 6]); \ + } \ + } \ + } \ + } \ + else { \ + X##ba ^= HTOLE64(input[ 0]); \ + X##be ^= HTOLE64(input[ 1]); \ + X##bi ^= HTOLE64(input[ 2]); \ + X##bo ^= HTOLE64(input[ 3]); \ + X##bu ^= HTOLE64(input[ 4]); \ + X##ga ^= HTOLE64(input[ 5]); \ + X##ge ^= HTOLE64(input[ 6]); \ + X##gi ^= HTOLE64(input[ 7]); \ + if (laneCount < 12) { \ + if (laneCount < 10) { \ + if (laneCount < 9) { \ + } \ + else { \ + X##go ^= HTOLE64(input[ 8]); \ + } \ + } \ + else { \ + X##go ^= HTOLE64(input[ 8]); \ + X##gu ^= HTOLE64(input[ 9]); \ + if (laneCount < 11) { \ + } \ + else { \ + X##ka ^= HTOLE64(input[10]); \ + } \ + } \ + } \ + else { \ + X##go ^= HTOLE64(input[ 8]); \ + X##gu ^= HTOLE64(input[ 9]); \ + X##ka ^= HTOLE64(input[10]); \ + X##ke ^= HTOLE64(input[11]); \ + if (laneCount < 14) { \ + if (laneCount < 13) { \ + } \ + else { \ + X##ki ^= HTOLE64(input[12]); \ + } \ + } \ + else { \ + X##ki ^= HTOLE64(input[12]); \ + X##ko ^= HTOLE64(input[13]); \ + if (laneCount < 15) { \ + } \ + else { \ + X##ku ^= HTOLE64(input[14]); \ + } \ + } \ + } \ + } \ + } \ + else { \ + X##ba ^= HTOLE64(input[ 0]); \ + X##be ^= HTOLE64(input[ 1]); \ + X##bi ^= HTOLE64(input[ 2]); \ + X##bo ^= HTOLE64(input[ 3]); \ + X##bu ^= HTOLE64(input[ 4]); \ + X##ga ^= HTOLE64(input[ 5]); \ + X##ge ^= HTOLE64(input[ 6]); \ + X##gi ^= HTOLE64(input[ 7]); \ + X##go ^= HTOLE64(input[ 8]); \ + X##gu ^= HTOLE64(input[ 9]); \ + X##ka ^= HTOLE64(input[10]); \ + X##ke ^= HTOLE64(input[11]); \ + X##ki ^= HTOLE64(input[12]); \ + X##ko ^= HTOLE64(input[13]); \ + X##ku ^= HTOLE64(input[14]); \ + X##ma ^= HTOLE64(input[15]); \ + if (laneCount < 24) { \ + if (laneCount < 20) { \ + if (laneCount < 18) { \ + if (laneCount < 17) { \ + } \ + else { \ + X##me ^= HTOLE64(input[16]); \ + } \ + } \ + else { \ + X##me ^= HTOLE64(input[16]); \ + X##mi ^= HTOLE64(input[17]); \ + if (laneCount < 19) { \ + } \ + else { \ + X##mo ^= HTOLE64(input[18]); \ + } \ + } \ + } \ + else { \ + X##me ^= HTOLE64(input[16]); \ + X##mi ^= HTOLE64(input[17]); \ + X##mo ^= HTOLE64(input[18]); \ + X##mu ^= HTOLE64(input[19]); \ + if (laneCount < 22) { \ + if (laneCount < 21) { \ + } \ + else { \ + X##sa ^= HTOLE64(input[20]); \ + } \ + } \ + else { \ + X##sa ^= HTOLE64(input[20]); \ + X##se ^= HTOLE64(input[21]); \ + if (laneCount < 23) { \ + } \ + else { \ + X##si ^= HTOLE64(input[22]); \ + } \ + } \ + } \ + } \ + else { \ + X##me ^= HTOLE64(input[16]); \ + X##mi ^= HTOLE64(input[17]); \ + X##mo ^= HTOLE64(input[18]); \ + X##mu ^= HTOLE64(input[19]); \ + X##sa ^= HTOLE64(input[20]); \ + X##se ^= HTOLE64(input[21]); \ + X##si ^= HTOLE64(input[22]); \ + X##so ^= HTOLE64(input[23]); \ + if (laneCount < 25) { \ + } \ + else { \ + X##su ^= HTOLE64(input[24]); \ + } \ + } \ + } + +size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen) +{ + size_t originalDataByteLen = dataByteLen; + declareABCDE + #ifndef KeccakP1600_fullUnrolling + unsigned int i; + #endif + UINT64 *stateAsLanes = (UINT64*)state; + UINT64 *inDataAsLanes = (UINT64*)data; + + copyFromState(A, stateAsLanes) + while(dataByteLen >= laneCount*8) { + addInput(A, inDataAsLanes, laneCount) + rounds12 + inDataAsLanes += laneCount; + dataByteLen -= laneCount*8; + } + copyToState(stateAsLanes, A) + return originalDataByteLen - dataByteLen; +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-AVX2.s b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-AVX2.s new file mode 100644 index 000000000..7085d0fde --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-AVX2.s @@ -0,0 +1,605 @@ +# Copyright (c) 2006-2017, CRYPTOGAMS by +# Copyright (c) 2017 Ronny Van Keer +# All rights reserved. +# +# The source code in this file is licensed under the CRYPTOGAMS license. +# For further details see http://www.openssl.org/~appro/cryptogams/. +# +# Notes: +# The code for the permutation (__KeccakF1600) was generated with +# Andy Polyakov's keccak1600-avx2.pl from the CRYPTOGAMS project +# (https://github.com/dot-asm/cryptogams/blob/master/x86_64/keccak1600-avx2.pl). +# The rest of the code was written by Ronny Van Keer. + +.text + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_Initialize(void *state); +# +.globl KeccakP1600_Initialize +.type KeccakP1600_Initialize,@function +.align 32 +KeccakP1600_Initialize: + vpxor %ymm0,%ymm0,%ymm0 + vmovdqa %ymm0,0*32(%rdi) + vmovdqa %ymm0,1*32(%rdi) + vmovdqa %ymm0,2*32(%rdi) + vmovdqa %ymm0,3*32(%rdi) + vmovdqa %ymm0,4*32(%rdi) + vmovdqa %ymm0,5*32(%rdi) + movq $0,6*32(%rdi) + ret +.size KeccakP1600_Initialize,.-KeccakP1600_Initialize + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset); +# %rdi %rsi %rdx +# +.globl KeccakP1600_AddByte +.type KeccakP1600_AddByte,@function +.align 32 +KeccakP1600_AddByte: + mov %rdx, %rax + and $7, %rax + and $0xFFFFFFF8, %edx + lea mapState(%rip), %r9 + mov (%r9, %rdx), %rdx + add %rdx, %rdi + add %rax, %rdi + xorb %sil, (%rdi) + ret +.size KeccakP1600_AddByte,.-KeccakP1600_AddByte + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_AddBytes +.type KeccakP1600_AddBytes,@function +.align 32 +KeccakP1600_AddBytes: + cmp $0, %rcx + jz KeccakP1600_AddBytes_Exit + mov %rdx, %rax # rax offset in lane + and $0xFFFFFFF8, %edx # rdx pointer into state index mapper + lea mapState(%rip), %r9 + add %r9, %rdx + and $7, %rax + jz KeccakP1600_AddBytes_LaneAlignedCheck + mov $8, %r9 # r9 is (max) length of incomplete lane + sub %rax, %r9 + cmp %rcx, %r9 + cmovae %rcx, %r9 + sub %r9, %rcx # length -= length of incomplete lane + add (%rdx), %rax # rax = pointer to state lane + add $8, %rdx + add %rdi, %rax +KeccakP1600_AddBytes_NotAlignedLoop: + mov (%rsi), %r8b + inc %rsi + xorb %r8b, (%rax) + inc %rax + dec %r9 + jnz KeccakP1600_AddBytes_NotAlignedLoop + jmp KeccakP1600_AddBytes_LaneAlignedCheck +KeccakP1600_AddBytes_LaneAlignedLoop: + mov (%rsi), %r8 + add $8, %rsi + mov (%rdx), %rax + add $8, %rdx + add %rdi, %rax + xor %r8, (%rax) +KeccakP1600_AddBytes_LaneAlignedCheck: + sub $8, %rcx + jnc KeccakP1600_AddBytes_LaneAlignedLoop +KeccakP1600_AddBytes_LastIncompleteLane: + add $8, %rcx + jz KeccakP1600_AddBytes_Exit + mov (%rdx), %rax + add %rdi, %rax +KeccakP1600_AddBytes_LastIncompleteLaneLoop: + mov (%rsi), %r8b + inc %rsi + xor %r8b, (%rax) + inc %rax + dec %rcx + jnz KeccakP1600_AddBytes_LastIncompleteLaneLoop +KeccakP1600_AddBytes_Exit: + ret +.size KeccakP1600_AddBytes,.-KeccakP1600_AddBytes + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_ExtractBytes +.type KeccakP1600_ExtractBytes,@function +.align 32 +KeccakP1600_ExtractBytes: + push %rbx + cmp $0, %rcx + jz KeccakP1600_ExtractBytes_Exit + mov %rdx, %rax # rax offset in lane + and $0xFFFFFFF8, %edx # rdx pointer into state index mapper + lea mapState(%rip), %r9 + add %r9, %rdx + and $7, %rax + jz KeccakP1600_ExtractBytes_LaneAlignedCheck + mov $8, %rbx # rbx is (max) length of incomplete lane + sub %rax, %rbx + cmp %rcx, %rbx + cmovae %rcx, %rbx + sub %rbx, %rcx # length -= length of incomplete lane + mov (%rdx), %r9 + add $8, %rdx + add %rdi, %r9 + add %rax, %r9 +KeccakP1600_ExtractBytes_NotAlignedLoop: + mov (%r9), %r8b + inc %r9 + mov %r8b, (%rsi) + inc %rsi + dec %rbx + jnz KeccakP1600_ExtractBytes_NotAlignedLoop + jmp KeccakP1600_ExtractBytes_LaneAlignedCheck +KeccakP1600_ExtractBytes_LaneAlignedLoop: + mov (%rdx), %rax + add $8, %rdx + add %rdi, %rax + mov (%rax), %r8 + mov %r8, (%rsi) + add $8, %rsi +KeccakP1600_ExtractBytes_LaneAlignedCheck: + sub $8, %rcx + jnc KeccakP1600_ExtractBytes_LaneAlignedLoop +KeccakP1600_ExtractBytes_LastIncompleteLane: + add $8, %rcx + jz KeccakP1600_ExtractBytes_Exit + mov (%rdx), %rax + add %rdi, %rax + mov (%rax), %r8 +KeccakP1600_ExtractBytes_LastIncompleteLaneLoop: + mov %r8b, (%rsi) + shr $8, %r8 + inc %rsi + dec %rcx + jnz KeccakP1600_ExtractBytes_LastIncompleteLaneLoop +KeccakP1600_ExtractBytes_Exit: + pop %rbx + ret +.size KeccakP1600_ExtractBytes,.-KeccakP1600_ExtractBytes + +# ----------------------------------------------------------------------------- +# +# internal +# +.type __KeccakF1600,@function +.align 32 +__KeccakF1600: +.Loop_avx2: + ######################################### Theta + vpshufd $0b01001110,%ymm2,%ymm13 + vpxor %ymm3,%ymm5,%ymm12 + vpxor %ymm6,%ymm4,%ymm9 + vpxor %ymm1,%ymm12,%ymm12 + vpxor %ymm9,%ymm12,%ymm12 # C[1..4] + + vpermq $0b10010011,%ymm12,%ymm11 + vpxor %ymm2,%ymm13,%ymm13 + vpermq $0b01001110,%ymm13,%ymm7 + + vpsrlq $63,%ymm12,%ymm8 + vpaddq %ymm12,%ymm12,%ymm9 + vpor %ymm9,%ymm8,%ymm8 # ROL64(C[1..4],1) + + vpermq $0b00111001,%ymm8,%ymm15 + vpxor %ymm11,%ymm8,%ymm14 + vpermq $0b00000000,%ymm14,%ymm14 # D[0..0] = ROL64(C[1],1) ^ C[4] + + vpxor %ymm0,%ymm13,%ymm13 + vpxor %ymm7,%ymm13,%ymm13 # C[0..0] + + vpsrlq $63,%ymm13,%ymm7 + vpaddq %ymm13,%ymm13,%ymm8 + vpor %ymm7,%ymm8,%ymm8 # ROL64(C[0..0],1) + + vpxor %ymm14,%ymm2,%ymm2 # ^= D[0..0] + vpxor %ymm14,%ymm0,%ymm0 # ^= D[0..0] + + vpblendd $0b11000000,%ymm8,%ymm15,%ymm15 + vpblendd $0b00000011,%ymm13,%ymm11,%ymm11 + vpxor %ymm11,%ymm15,%ymm15 # D[1..4] = ROL64(C[2..4,0),1) ^ C[0..3] + + ######################################### Rho + Pi + pre-Chi shuffle + vpsllvq 0*32-96(%r8),%ymm2,%ymm10 + vpsrlvq 0*32-96(%r9),%ymm2,%ymm2 + vpor %ymm10,%ymm2,%ymm2 + + vpxor %ymm15,%ymm3,%ymm3 # ^= D[1..4] from Theta + vpsllvq 2*32-96(%r8),%ymm3,%ymm11 + vpsrlvq 2*32-96(%r9),%ymm3,%ymm3 + vpor %ymm11,%ymm3,%ymm3 + + vpxor %ymm15,%ymm4,%ymm4 # ^= D[1..4] from Theta + vpsllvq 3*32-96(%r8),%ymm4,%ymm12 + vpsrlvq 3*32-96(%r9),%ymm4,%ymm4 + vpor %ymm12,%ymm4,%ymm4 + + vpxor %ymm15,%ymm5,%ymm5 # ^= D[1..4] from Theta + vpsllvq 4*32-96(%r8),%ymm5,%ymm13 + vpsrlvq 4*32-96(%r9),%ymm5,%ymm5 + vpor %ymm13,%ymm5,%ymm5 + + vpxor %ymm15,%ymm6,%ymm6 # ^= D[1..4] from Theta + vpermq $0b10001101,%ymm2,%ymm10 # %ymm2 -> future %ymm3 + vpermq $0b10001101,%ymm3,%ymm11 # %ymm3 -> future %ymm4 + vpsllvq 5*32-96(%r8),%ymm6,%ymm14 + vpsrlvq 5*32-96(%r9),%ymm6,%ymm8 + vpor %ymm14,%ymm8,%ymm8 # %ymm6 -> future %ymm1 + + vpxor %ymm15,%ymm1,%ymm1 # ^= D[1..4] from Theta + vpermq $0b00011011,%ymm4,%ymm12 # %ymm4 -> future %ymm5 + vpermq $0b01110010,%ymm5,%ymm13 # %ymm5 -> future %ymm6 + vpsllvq 1*32-96(%r8),%ymm1,%ymm15 + vpsrlvq 1*32-96(%r9),%ymm1,%ymm9 + vpor %ymm15,%ymm9,%ymm9 # %ymm1 -> future %ymm2 + + ######################################### Chi + vpsrldq $8,%ymm8,%ymm14 + vpandn %ymm14,%ymm8,%ymm7 # tgting [0][0] [0][0] [0][0] [0][0] + + vpblendd $0b00001100,%ymm13,%ymm9,%ymm3 # [4][4] [2][0] + vpblendd $0b00001100,%ymm9,%ymm11,%ymm15 # [4][0] [2][1] + vpblendd $0b00001100,%ymm11,%ymm10,%ymm5 # [4][2] [2][4] + vpblendd $0b00001100,%ymm10,%ymm9,%ymm14 # [4][3] [2][0] + vpblendd $0b00110000,%ymm11,%ymm3,%ymm3 # [1][3] [4][4] [2][0] + vpblendd $0b00110000,%ymm12,%ymm15,%ymm15 # [1][4] [4][0] [2][1] + vpblendd $0b00110000,%ymm9,%ymm5,%ymm5 # [1][0] [4][2] [2][4] + vpblendd $0b00110000,%ymm13,%ymm14,%ymm14 # [1][1] [4][3] [2][0] + vpblendd $0b11000000,%ymm12,%ymm3,%ymm3 # [3][2] [1][3] [4][4] [2][0] + vpblendd $0b11000000,%ymm13,%ymm15,%ymm15 # [3][3] [1][4] [4][0] [2][1] + vpblendd $0b11000000,%ymm13,%ymm5,%ymm5 # [3][3] [1][0] [4][2] [2][4] + vpblendd $0b11000000,%ymm11,%ymm14,%ymm14 # [3][4] [1][1] [4][3] [2][0] + vpandn %ymm15,%ymm3,%ymm3 # tgting [3][1] [1][2] [4][3] [2][4] + vpandn %ymm14,%ymm5,%ymm5 # tgting [3][2] [1][4] [4][1] [2][3] + + vpblendd $0b00001100,%ymm9,%ymm12,%ymm6 # [4][0] [2][3] + vpblendd $0b00001100,%ymm12,%ymm10,%ymm15 # [4][1] [2][4] + vpxor %ymm10,%ymm3,%ymm3 + vpblendd $0b00110000,%ymm10,%ymm6,%ymm6 # [1][2] [4][0] [2][3] + vpblendd $0b00110000,%ymm11,%ymm15,%ymm15 # [1][3] [4][1] [2][4] + vpxor %ymm12,%ymm5,%ymm5 + vpblendd $0b11000000,%ymm11,%ymm6,%ymm6 # [3][4] [1][2] [4][0] [2][3] + vpblendd $0b11000000,%ymm9,%ymm15,%ymm15 # [3][0] [1][3] [4][1] [2][4] + vpandn %ymm15,%ymm6,%ymm6 # tgting [3][3] [1][1] [4][4] [2][2] + vpxor %ymm13,%ymm6,%ymm6 + + vpermq $0b00011110,%ymm8,%ymm4 # [0][1] [0][2] [0][4] [0][3] + vpblendd $0b00110000,%ymm0,%ymm4,%ymm15 # [0][1] [0][0] [0][4] [0][3] + vpermq $0b00111001,%ymm8,%ymm1 # [0][1] [0][4] [0][3] [0][2] + vpblendd $0b11000000,%ymm0,%ymm1,%ymm1 # [0][0] [0][4] [0][3] [0][2] + vpandn %ymm15,%ymm1,%ymm1 # tgting [0][4] [0][3] [0][2] [0][1] + + vpblendd $0b00001100,%ymm12,%ymm11,%ymm2 # [4][1] [2][1] + vpblendd $0b00001100,%ymm11,%ymm13,%ymm14 # [4][2] [2][2] + vpblendd $0b00110000,%ymm13,%ymm2,%ymm2 # [1][1] [4][1] [2][1] + vpblendd $0b00110000,%ymm10,%ymm14,%ymm14 # [1][2] [4][2] [2][2] + vpblendd $0b11000000,%ymm10,%ymm2,%ymm2 # [3][1] [1][1] [4][1] [2][1] + vpblendd $0b11000000,%ymm12,%ymm14,%ymm14 # [3][2] [1][2] [4][2] [2][2] + vpandn %ymm14,%ymm2,%ymm2 # tgting [3][0] [1][0] [4][0] [2][0] + vpxor %ymm9,%ymm2,%ymm2 + + vpermq $0b00000000,%ymm7,%ymm7 # [0][0] [0][0] [0][0] [0][0] + vpermq $0b00011011,%ymm3,%ymm3 # post-Chi shuffle + vpermq $0b10001101,%ymm5,%ymm5 + vpermq $0b01110010,%ymm6,%ymm6 + + vpblendd $0b00001100,%ymm10,%ymm13,%ymm4 # [4][3] [2][2] + vpblendd $0b00001100,%ymm13,%ymm12,%ymm14 # [4][4] [2][3] + vpblendd $0b00110000,%ymm12,%ymm4,%ymm4 # [1][4] [4][3] [2][2] + vpblendd $0b00110000,%ymm9,%ymm14,%ymm14 # [1][0] [4][4] [2][3] + vpblendd $0b11000000,%ymm9,%ymm4,%ymm4 # [3][0] [1][4] [4][3] [2][2] + vpblendd $0b11000000,%ymm10,%ymm14,%ymm14 # [3][1] [1][0] [4][4] [2][3] + vpandn %ymm14,%ymm4,%ymm4 # tgting [3][4] [1][3] [4][2] [2][1] + + vpxor %ymm7,%ymm0,%ymm0 + vpxor %ymm8,%ymm1,%ymm1 + vpxor %ymm11,%ymm4,%ymm4 + + ######################################### Iota + vpxor (%r10),%ymm0,%ymm0 + lea 32(%r10),%r10 + + dec %eax + jnz .Loop_avx2 + ret +.size __KeccakF1600,.-__KeccakF1600 + + + +.globl KeccakP1600_Permute_12rounds +.type KeccakP1600_Permute_12rounds,@function +.align 32 +KeccakP1600_Permute_12rounds: + lea rhotates_left+96(%rip),%r8 + lea rhotates_right+96(%rip),%r9 + lea iotas+12*4*8(%rip),%r10 + mov $12,%eax + lea 96(%rdi),%rdi + vzeroupper + vpbroadcastq -96(%rdi),%ymm0 # load A[5][5] + vmovdqu 8+32*0-96(%rdi),%ymm1 + vmovdqu 8+32*1-96(%rdi),%ymm2 + vmovdqu 8+32*2-96(%rdi),%ymm3 + vmovdqu 8+32*3-96(%rdi),%ymm4 + vmovdqu 8+32*4-96(%rdi),%ymm5 + vmovdqu 8+32*5-96(%rdi),%ymm6 + call __KeccakF1600 + vmovq %xmm0,-96(%rdi) + vmovdqu %ymm1,8+32*0-96(%rdi) + vmovdqu %ymm2,8+32*1-96(%rdi) + vmovdqu %ymm3,8+32*2-96(%rdi) + vmovdqu %ymm4,8+32*3-96(%rdi) + vmovdqu %ymm5,8+32*4-96(%rdi) + vmovdqu %ymm6,8+32*5-96(%rdi) + vzeroupper + ret +.size KeccakP1600_Permute_12rounds,.-KeccakP1600_Permute_12rounds + +# ----------------------------------------------------------------------------- +# +# size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_12rounds_FastLoop_Absorb +.type KeccakP1600_12rounds_FastLoop_Absorb,@function +.align 32 +KeccakP1600_12rounds_FastLoop_Absorb: + push %rbx + push %r10 + shr $3, %rcx # rcx = data length in lanes + mov %rdx, %rbx # rbx = initial data pointer + cmp %rsi, %rcx + jb KeccakP1600_12rounds_FastLoop_Absorb_Exit + vzeroupper + cmp $21, %rsi + jnz KeccakP1600_12rounds_FastLoop_Absorb_Not21Lanes + sub $21, %rcx + lea rhotates_left+96(%rip),%r8 + lea rhotates_right+96(%rip),%r9 + lea 96(%rdi),%rdi + vpbroadcastq -96(%rdi),%ymm0 # load A[5][5] + vmovdqu 8+32*0-96(%rdi),%ymm1 + vmovdqu 8+32*1-96(%rdi),%ymm2 + vmovdqu 8+32*2-96(%rdi),%ymm3 + vmovdqu 8+32*3-96(%rdi),%ymm4 + vmovdqu 8+32*4-96(%rdi),%ymm5 + vmovdqu 8+32*5-96(%rdi),%ymm6 +KeccakP1600_12rounds_FastLoop_Absorb_Loop21Lanes: + vpbroadcastq (%rdx),%ymm7 + vmovdqu 8(%rdx),%ymm8 + + vmovdqa map2(%rip), %xmm15 + vpcmpeqq %ymm14, %ymm14, %ymm14 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm9 + + vmovdqa mask3_21(%rip), %ymm14 + vpxor %ymm10, %ymm10, %ymm10 + vmovdqa map3(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm10 + + vmovdqa mask4_21(%rip), %ymm14 + vpxor %ymm11, %ymm11, %ymm11 + vmovdqa map4(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm11 + + vmovdqa mask5_21(%rip), %ymm14 + vpxor %ymm12, %ymm12, %ymm12 + vmovdqa map5(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm12 + + vmovdqa mask6_21(%rip), %ymm14 + vpxor %ymm13, %ymm13, %ymm13 + vmovdqa map6(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm13 + + vpxor %ymm7,%ymm0,%ymm0 + vpxor %ymm8,%ymm1,%ymm1 + vpxor %ymm9,%ymm2,%ymm2 + vpxor %ymm10,%ymm3,%ymm3 + vpxor %ymm11,%ymm4,%ymm4 + vpxor %ymm12,%ymm5,%ymm5 + vpxor %ymm13,%ymm6,%ymm6 + add $21*8, %rdx + lea iotas+12*4*8(%rip),%r10 + mov $12,%eax + call __KeccakF1600 + sub $21, %rcx + jnc KeccakP1600_12rounds_FastLoop_Absorb_Loop21Lanes +KeccakP1600_12rounds_FastLoop_Absorb_SaveAndExit: + vmovq %xmm0,-96(%rdi) + vmovdqu %ymm1,8+32*0-96(%rdi) + vmovdqu %ymm2,8+32*1-96(%rdi) + vmovdqu %ymm3,8+32*2-96(%rdi) + vmovdqu %ymm4,8+32*3-96(%rdi) + vmovdqu %ymm5,8+32*4-96(%rdi) + vmovdqu %ymm6,8+32*5-96(%rdi) +KeccakP1600_12rounds_FastLoop_Absorb_Exit: + vzeroupper + mov %rdx, %rax # return number of bytes processed + sub %rbx, %rax + pop %r10 + pop %rbx + ret +KeccakP1600_12rounds_FastLoop_Absorb_Not21Lanes: + cmp $17, %rsi + jnz KeccakP1600_12rounds_FastLoop_Absorb_Not17Lanes + sub $17, %rcx + lea rhotates_left+96(%rip),%r8 + lea rhotates_right+96(%rip),%r9 + lea 96(%rdi),%rdi + vpbroadcastq -96(%rdi),%ymm0 # load A[5][5] + vmovdqu 8+32*0-96(%rdi),%ymm1 + vmovdqu 8+32*1-96(%rdi),%ymm2 + vmovdqu 8+32*2-96(%rdi),%ymm3 + vmovdqu 8+32*3-96(%rdi),%ymm4 + vmovdqu 8+32*4-96(%rdi),%ymm5 + vmovdqu 8+32*5-96(%rdi),%ymm6 +KeccakP1600_12rounds_FastLoop_Absorb_Loop17Lanes: + vpbroadcastq (%rdx),%ymm7 + vmovdqu 8(%rdx),%ymm8 + + vmovdqa mask2_17(%rip), %ymm14 + vpxor %ymm9, %ymm9, %ymm9 + vmovdqa map2(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm9 + + vmovdqa mask3_17(%rip), %ymm14 + vpxor %ymm10, %ymm10, %ymm10 + vmovdqa map3(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm10 + + vmovdqa mask4_17(%rip), %ymm14 + vpxor %ymm11, %ymm11, %ymm11 + vmovdqa map4(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm11 + + vmovdqa mask5_17(%rip), %ymm14 + vpxor %ymm12, %ymm12, %ymm12 + vmovdqa map5(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm12 + + vmovdqa mask6_17(%rip), %ymm14 + vpxor %ymm13, %ymm13, %ymm13 + vmovdqa map6(%rip), %xmm15 + vpgatherdq %ymm14, (%rdx, %xmm15, 1), %ymm13 + + vpxor %ymm7,%ymm0,%ymm0 + vpxor %ymm8,%ymm1,%ymm1 + vpxor %ymm9,%ymm2,%ymm2 + vpxor %ymm10,%ymm3,%ymm3 + vpxor %ymm11,%ymm4,%ymm4 + vpxor %ymm12,%ymm5,%ymm5 + vpxor %ymm13,%ymm6,%ymm6 + add $17*8, %rdx + lea iotas+12*4*8(%rip),%r10 + mov $12,%eax + call __KeccakF1600 + sub $17, %rcx + jnc KeccakP1600_12rounds_FastLoop_Absorb_Loop17Lanes + jmp KeccakP1600_12rounds_FastLoop_Absorb_SaveAndExit +KeccakP1600_12rounds_FastLoop_Absorb_Not17Lanes: + lea mapState(%rip), %r9 + mov %rsi, %rax +KeccakP1600_12rounds_FastLoop_Absorb_LanesAddLoop: + mov (%rdx), %r8 + add $8, %rdx + mov (%r9), %r10 + add $8, %r9 + add %rdi, %r10 + xor %r8, (%r10) + sub $1, %rax + jnz KeccakP1600_12rounds_FastLoop_Absorb_LanesAddLoop + sub %rsi, %rcx + push %rdi + push %rsi + push %rdx + push %rcx + call KeccakP1600_Permute_12rounds@PLT + pop %rcx + pop %rdx + pop %rsi + pop %rdi + cmp %rsi, %rcx + jae KeccakP1600_12rounds_FastLoop_Absorb_Not17Lanes + jmp KeccakP1600_12rounds_FastLoop_Absorb_Exit +.size KeccakP1600_12rounds_FastLoop_Absorb,.-KeccakP1600_12rounds_FastLoop_Absorb + +.equ ALLON, 0xFFFFFFFFFFFFFFFF + +.align 64 +rhotates_left: + .quad 3, 18, 36, 41 # [2][0] [4][0] [1][0] [3][0] + .quad 1, 62, 28, 27 # [0][1] [0][2] [0][3] [0][4] + .quad 45, 6, 56, 39 # [3][1] [1][2] [4][3] [2][4] + .quad 10, 61, 55, 8 # [2][1] [4][2] [1][3] [3][4] + .quad 2, 15, 25, 20 # [4][1] [3][2] [2][3] [1][4] + .quad 44, 43, 21, 14 # [1][1] [2][2] [3][3] [4][4] +rhotates_right: + .quad 64-3, 64-18, 64-36, 64-41 + .quad 64-1, 64-62, 64-28, 64-27 + .quad 64-45, 64-6, 64-56, 64-39 + .quad 64-10, 64-61, 64-55, 64-8 + .quad 64-2, 64-15, 64-25, 64-20 + .quad 64-44, 64-43, 64-21, 64-14 +iotas: + .quad 0x0000000000000001, 0x0000000000000001, 0x0000000000000001, 0x0000000000000001 + .quad 0x0000000000008082, 0x0000000000008082, 0x0000000000008082, 0x0000000000008082 + .quad 0x800000000000808a, 0x800000000000808a, 0x800000000000808a, 0x800000000000808a + .quad 0x8000000080008000, 0x8000000080008000, 0x8000000080008000, 0x8000000080008000 + .quad 0x000000000000808b, 0x000000000000808b, 0x000000000000808b, 0x000000000000808b + .quad 0x0000000080000001, 0x0000000080000001, 0x0000000080000001, 0x0000000080000001 + .quad 0x8000000080008081, 0x8000000080008081, 0x8000000080008081, 0x8000000080008081 + .quad 0x8000000000008009, 0x8000000000008009, 0x8000000000008009, 0x8000000000008009 + .quad 0x000000000000008a, 0x000000000000008a, 0x000000000000008a, 0x000000000000008a + .quad 0x0000000000000088, 0x0000000000000088, 0x0000000000000088, 0x0000000000000088 + .quad 0x0000000080008009, 0x0000000080008009, 0x0000000080008009, 0x0000000080008009 + .quad 0x000000008000000a, 0x000000008000000a, 0x000000008000000a, 0x000000008000000a + .quad 0x000000008000808b, 0x000000008000808b, 0x000000008000808b, 0x000000008000808b + .quad 0x800000000000008b, 0x800000000000008b, 0x800000000000008b, 0x800000000000008b + .quad 0x8000000000008089, 0x8000000000008089, 0x8000000000008089, 0x8000000000008089 + .quad 0x8000000000008003, 0x8000000000008003, 0x8000000000008003, 0x8000000000008003 + .quad 0x8000000000008002, 0x8000000000008002, 0x8000000000008002, 0x8000000000008002 + .quad 0x8000000000000080, 0x8000000000000080, 0x8000000000000080, 0x8000000000000080 + .quad 0x000000000000800a, 0x000000000000800a, 0x000000000000800a, 0x000000000000800a + .quad 0x800000008000000a, 0x800000008000000a, 0x800000008000000a, 0x800000008000000a + .quad 0x8000000080008081, 0x8000000080008081, 0x8000000080008081, 0x8000000080008081 + .quad 0x8000000000008080, 0x8000000000008080, 0x8000000000008080, 0x8000000000008080 + .quad 0x0000000080000001, 0x0000000080000001, 0x0000000080000001, 0x0000000080000001 + .quad 0x8000000080008008, 0x8000000080008008, 0x8000000080008008, 0x8000000080008008 + +mapState: + .quad 0*8, 1*8, 2*8, 3*8, 4*8 + .quad 7*8, 21*8, 10*8, 15*8, 20*8 + .quad 5*8, 13*8, 22*8, 19*8, 12*8 + .quad 8*8, 9*8, 18*8, 23*8, 16*8 + .quad 6*8, 17*8, 14*8, 11*8, 24*8 + + .align 16 +map2: + .long 10*8, 20*8, 5*8, 15*8 +map3: + .long 16*8, 7*8, 23*8, 14*8 +map4: + .long 11*8, 22*8, 8*8, 19*8 +map5: + .long 21*8, 17*8, 13*8, 9*8 +map6: + .long 6*8, 12*8, 18*8, 24*8 + + .align 32 +mask3_21: + .quad ALLON, ALLON, 0, ALLON +mask4_21: + .quad ALLON, 0, ALLON, ALLON +mask5_21: + .quad 0, ALLON, ALLON, ALLON +mask6_21: + .quad ALLON, ALLON, ALLON, 0 + +mask2_17: + .quad ALLON, 0, ALLON, ALLON +mask3_17: + .quad ALLON, ALLON, 0, ALLON +mask4_17: + .quad ALLON, 0, ALLON, 0 +mask5_17: + .quad 0, 0, ALLON, ALLON +mask6_17: + .quad ALLON, ALLON, 0, 0 + +.asciz "Keccak-1600 for AVX2, CRYPTOGAMS by " diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-SnP.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-SnP.h new file mode 100644 index 000000000..8568d0997 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-SnP.h @@ -0,0 +1,65 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#ifndef _KeccakP_1600_SnP_h_ +#define _KeccakP_1600_SnP_h_ + +#include +#include "KeccakP-1600-config.h" + +#define KeccakP1600_implementation "AVX2 optimized implementation" +#define KeccakP1600_stateSizeInBytes 200 +#define KeccakP1600_stateAlignment 32 +#define KeccakP1600_12rounds_FastLoop_supported + +#define KeccakP1600_StaticInitialize() +void KeccakP1600_Initialize(void *state); +void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset); +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600_Permute_12rounds(void *state); +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); +size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen); + +#define KeccakP1600times2_implementation "128-bit SIMD implementation (" KeccakP1600times2_implementation_config ")" +#define KeccakP1600times2_statesSizeInBytes 400 +#define KeccakP1600times2_statesAlignment 16 + +#define KeccakP1600times2_StaticInitialize() +void KeccakP1600times2_InitializeAll(void *states); +#define KeccakP1600times2_AddByte(states, instanceIndex, byte, offset) \ + ((unsigned char*)(states))[(instanceIndex)*8 + ((offset)/8)*2*8 + (offset)%8] ^= (byte) +void KeccakP1600times2_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times2_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +void KeccakP1600times2_PermuteAll_12rounds(void *states); +void KeccakP1600times2_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times2_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset); + +#define KeccakP1600times4_implementation "256-bit SIMD implementation (" KeccakP1600times4_implementation_config ")" +#define KeccakP1600times4_statesSizeInBytes 800 +#define KeccakP1600times4_statesAlignment 32 +#define KeccakP1600times4_12rounds_FastLoop_supported + +#define KeccakP1600times4_StaticInitialize() +void KeccakP1600times4_InitializeAll(void *states); +#define KeccakP1600times4_AddByte(states, instanceIndex, byte, offset) \ + ((unsigned char*)(states))[(instanceIndex)*8 + ((offset)/8)*4*8 + (offset)%8] ^= (byte) +void KeccakP1600times4_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times4_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +void KeccakP1600times4_PermuteAll_12rounds(void *states); +void KeccakP1600times4_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times4_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +size_t KeccakP1600times4_12rounds_FastLoop_Absorb(void *states, unsigned int laneCount, unsigned int laneOffsetParallel, unsigned int laneOffsetSerial, const unsigned char *data, size_t dataByteLen); + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-config.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-config.h new file mode 100644 index 000000000..73c0e53e3 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-config.h @@ -0,0 +1,8 @@ +#define KeccakP1600times2_implementation_config "SSE2, 2 rounds unrolled" +#define KeccakP1600times2_unrolling 2 +#define KeccakP1600times2_useSSE +#define KeccakP1600times2_useSSE2 + +#define KeccakP1600times4_implementation_config "AVX2, 12 rounds unrolled" +#define KeccakP1600times4_unrolling 12 +#define KeccakP1600times4_useAVX2 diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-times2-SIMD128.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-times2-SIMD128.c new file mode 100644 index 000000000..6d5ac0bfb --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX2/KeccakP-1600-times2-SIMD128.c @@ -0,0 +1,704 @@ +/* +Implementation by Gilles Van Assche, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include +#include +#include +#include "KeccakP-1600-SnP.h" + +#include "brg_endian.h" +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +#error Expecting a little-endian platform +#endif + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +typedef unsigned char UINT8; +typedef unsigned long long int UINT64; +typedef __m128i V128; + +#define laneIndex(instanceIndex, lanePosition) ((lanePosition)*2 + instanceIndex) + +#if defined(KeccakP1600times2_useSSE) + #define ANDnu128(a, b) _mm_andnot_si128(a, b) + #define CONST128(a) _mm_load_si128((const V128 *)&(a)) + #define LOAD128(a) _mm_load_si128((const V128 *)&(a)) + #define LOAD128u(a) _mm_loadu_si128((const V128 *)&(a)) + #define LOAD6464(a, b) _mm_set_epi64((__m64)(a), (__m64)(b)) + #define CONST128_64(a) _mm_set1_epi64((__m64)(a)) + #if defined(KeccakP1600times2_useXOP) + #define ROL64in128(a, o) _mm_roti_epi64(a, o) + #define ROL64in128_8(a) ROL64in128(a, 8) + #define ROL64in128_56(a) ROL64in128(a, 56) + #else + #define ROL64in128(a, o) _mm_or_si128(_mm_slli_epi64(a, o), _mm_srli_epi64(a, 64-(o))) + #define ROL64in128_8(a) _mm_shuffle_epi8(a, CONST128(rho8)) + #define ROL64in128_56(a) _mm_shuffle_epi8(a, CONST128(rho56)) +static const UINT64 rho8[2] = {0x0605040302010007, 0x0E0D0C0B0A09080F}; +static const UINT64 rho56[2] = {0x0007060504030201, 0x080F0E0D0C0B0A09}; + #endif + #define STORE128(a, b) _mm_store_si128((V128 *)&(a), b) + #define STORE128u(a, b) _mm_storeu_si128((V128 *)&(a), b) + #define STORE64L(a, b) _mm_storel_pi((__m64 *)&(a), (__m128)b) + #define STORE64H(a, b) _mm_storeh_pi((__m64 *)&(a), (__m128)b) + #define XOR128(a, b) _mm_xor_si128(a, b) + #define XOReq128(a, b) a = _mm_xor_si128(a, b) + #define ZERO128() _mm_setzero_si128() +#if defined(KeccakP1600times2_useSSE2) + #define UNPACKL( a, b ) _mm_unpacklo_epi64((a), (b)) + #define UNPACKH( a, b ) _mm_unpackhi_epi64((a), (b)) +#endif +#endif + +#define SnP_laneLengthInBytes 8 + +void KeccakP1600times2_InitializeAll(void *states) +{ + memset(states, 0, KeccakP1600times2_statesSizeInBytes); +} + +void KeccakP1600times2_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length) +{ + unsigned int sizeLeft = length; + unsigned int lanePosition = offset/SnP_laneLengthInBytes; + unsigned int offsetInLane = offset%SnP_laneLengthInBytes; + const unsigned char *curData = data; + UINT64 *statesAsLanes = (UINT64 *)states; + + if ((sizeLeft > 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + UINT64 lane = 0; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + UINT64 lane = *((const UINT64*)curData); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + UINT64 lane = 0; + memcpy(&lane, curData, sizeLeft); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + } +} + +void KeccakP1600times2_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + V128 *stateAsLanes = (V128 *)states; + unsigned int i; + const UINT64 *curData0 = (const UINT64 *)data; + const UINT64 *curData1 = (const UINT64 *)(data+laneOffset*SnP_laneLengthInBytes); + #define XOR_In( argIndex ) XOReq128( stateAsLanes[argIndex], LOAD6464(curData1[argIndex], curData0[argIndex])) + if ( laneCount >= 17 ) { + XOR_In( 0 ); + XOR_In( 1 ); + XOR_In( 2 ); + XOR_In( 3 ); + XOR_In( 4 ); + XOR_In( 5 ); + XOR_In( 6 ); + XOR_In( 7 ); + XOR_In( 8 ); + XOR_In( 9 ); + XOR_In( 10 ); + XOR_In( 11 ); + XOR_In( 12 ); + XOR_In( 13 ); + XOR_In( 14 ); + XOR_In( 15 ); + XOR_In( 16 ); + if ( laneCount >= 21 ) { + XOR_In( 17 ); + XOR_In( 18 ); + XOR_In( 19 ); + XOR_In( 20 ); + for(i=21; i 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane); + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)]; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft); + } +} + +void KeccakP1600times2_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + const V128 *stateAsLanes = (const V128 *)states; + V128 lanes; + unsigned int i; + UINT64 *curData0 = (UINT64 *)data; + UINT64 *curData1 = (UINT64 *)(data+laneOffset*SnP_laneLengthInBytes); + + #define Extr( argIndex ) lanes = LOAD128( stateAsLanes[argIndex] ), \ + STORE64L( curData0[argIndex], lanes ), \ + STORE64H( curData1[argIndex], lanes ) + + #if defined(KeccakP1600times2_useSSE2) + #define Extr2( argIndex ) lanes0 = LOAD128( stateAsLanes[argIndex] ), \ + lanes1 = LOAD128( stateAsLanes[(argIndex)+1] ), \ + lanes = UNPACKL( lanes0, lanes1 ), \ + lanes0 = UNPACKH( lanes0, lanes1 ), \ + STORE128u( *(V128*)&curData0[argIndex], lanes ), \ + STORE128u( *(V128*)&curData1[argIndex], lanes0 ) + if ( laneCount >= 16 ) { + V128 lanes0, lanes1; + Extr2( 0 ); + Extr2( 2 ); + Extr2( 4 ); + Extr2( 6 ); + Extr2( 8 ); + Extr2( 10 ); + Extr2( 12 ); + Extr2( 14 ); + if ( laneCount >= 20 ) { + Extr2( 16 ); + Extr2( 18 ); + for(i=20; i= 17 ) { + Extr( 0 ); + Extr( 1 ); + Extr( 2 ); + Extr( 3 ); + Extr( 4 ); + Extr( 5 ); + Extr( 6 ); + Extr( 7 ); + Extr( 8 ); + Extr( 9 ); + Extr( 10 ); + Extr( 11 ); + Extr( 12 ); + Extr( 13 ); + Extr( 14 ); + Extr( 15 ); + Extr( 16 ); + if ( laneCount >= 21 ) { + Extr( 17 ); + Extr( 18 ); + Extr( 19 ); + Extr( 20 ); + for(i=21; i +#include +#include +#include +#include +#include +#include +#include "KeccakP-1600-SnP.h" + +#include "brg_endian.h" +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +#error Expecting a little-endian platform +#endif + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +typedef unsigned char UINT8; +typedef unsigned long long int UINT64; +typedef __m128i V128; +typedef __m256i V256; + +//#define UseGatherScatter + +#define laneIndex(instanceIndex, lanePosition) ((lanePosition)*4 + instanceIndex) + +#if defined(KeccakP1600times4_useAVX2) + #define ANDnu256(a, b) _mm256_andnot_si256(a, b) + #define CONST256(a) _mm256_load_si256((const V256 *)&(a)) + #define CONST256_64(a) (V256)_mm256_broadcast_sd((const double*)(&a)) + #define LOAD256(a) _mm256_load_si256((const V256 *)&(a)) + #define LOAD256u(a) _mm256_loadu_si256((const V256 *)&(a)) + #define LOAD4_64(a, b, c, d) _mm256_set_epi64x((UINT64)(a), (UINT64)(b), (UINT64)(c), (UINT64)(d)) + #define ROL64in256(d, a, o) d = _mm256_or_si256(_mm256_slli_epi64(a, o), _mm256_srli_epi64(a, 64-(o))) + #define ROL64in256_8(d, a) d = _mm256_shuffle_epi8(a, CONST256(rho8)) + #define ROL64in256_56(d, a) d = _mm256_shuffle_epi8(a, CONST256(rho56)) +static const UINT64 rho8[4] = {0x0605040302010007, 0x0E0D0C0B0A09080F, 0x1615141312111017, 0x1E1D1C1B1A19181F}; +static const UINT64 rho56[4] = {0x0007060504030201, 0x080F0E0D0C0B0A09, 0x1017161514131211, 0x181F1E1D1C1B1A19}; + #define STORE256(a, b) _mm256_store_si256((V256 *)&(a), b) + #define STORE256u(a, b) _mm256_storeu_si256((V256 *)&(a), b) + #define STORE2_128(ah, al, v) _mm256_storeu2_m128d((V128*)&(ah), (V128*)&(al), v) + #define XOR256(a, b) _mm256_xor_si256(a, b) + #define XOReq256(a, b) a = _mm256_xor_si256(a, b) + #define UNPACKL( a, b ) _mm256_unpacklo_epi64((a), (b)) + #define UNPACKH( a, b ) _mm256_unpackhi_epi64((a), (b)) + #define PERM128( a, b, c ) (V256)_mm256_permute2f128_ps((__m256)(a), (__m256)(b), c) + #define SHUFFLE64( a, b, c ) (V256)_mm256_shuffle_pd((__m256d)(a), (__m256d)(b), c) + + #define UNINTLEAVE() lanesL01 = UNPACKL( lanes0, lanes1 ), \ + lanesH01 = UNPACKH( lanes0, lanes1 ), \ + lanesL23 = UNPACKL( lanes2, lanes3 ), \ + lanesH23 = UNPACKH( lanes2, lanes3 ), \ + lanes0 = PERM128( lanesL01, lanesL23, 0x20 ), \ + lanes2 = PERM128( lanesL01, lanesL23, 0x31 ), \ + lanes1 = PERM128( lanesH01, lanesH23, 0x20 ), \ + lanes3 = PERM128( lanesH01, lanesH23, 0x31 ) + + #define INTLEAVE() lanesL01 = PERM128( lanes0, lanes2, 0x20 ), \ + lanesH01 = PERM128( lanes1, lanes3, 0x20 ), \ + lanesL23 = PERM128( lanes0, lanes2, 0x31 ), \ + lanesH23 = PERM128( lanes1, lanes3, 0x31 ), \ + lanes0 = SHUFFLE64( lanesL01, lanesH01, 0x00 ), \ + lanes1 = SHUFFLE64( lanesL01, lanesH01, 0x0F ), \ + lanes2 = SHUFFLE64( lanesL23, lanesH23, 0x00 ), \ + lanes3 = SHUFFLE64( lanesL23, lanesH23, 0x0F ) + +#endif + +#define SnP_laneLengthInBytes 8 + +void KeccakP1600times4_InitializeAll(void *states) +{ + memset(states, 0, KeccakP1600times4_statesSizeInBytes); +} + +void KeccakP1600times4_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length) +{ + unsigned int sizeLeft = length; + unsigned int lanePosition = offset/SnP_laneLengthInBytes; + unsigned int offsetInLane = offset%SnP_laneLengthInBytes; + const unsigned char *curData = data; + UINT64 *statesAsLanes = (UINT64 *)states; + + if ((sizeLeft > 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + UINT64 lane = 0; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + UINT64 lane = *((const UINT64*)curData); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + UINT64 lane = 0; + memcpy(&lane, curData, sizeLeft); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + } +} + +void KeccakP1600times4_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + V256 *stateAsLanes = (V256 *)states; + unsigned int i; + const UINT64 *curData0 = (const UINT64 *)data; + const UINT64 *curData1 = (const UINT64 *)(data+laneOffset*SnP_laneLengthInBytes); + const UINT64 *curData2 = (const UINT64 *)(data+laneOffset*2*SnP_laneLengthInBytes); + const UINT64 *curData3 = (const UINT64 *)(data+laneOffset*3*SnP_laneLengthInBytes); + V256 lanes0, lanes1, lanes2, lanes3, lanesL01, lanesL23, lanesH01, lanesH23; + + #define Xor_In( argIndex ) XOReq256(stateAsLanes[argIndex], LOAD4_64(curData3[argIndex], curData2[argIndex], curData1[argIndex], curData0[argIndex])) + + #define Xor_In4( argIndex ) lanes0 = LOAD256u( curData0[argIndex]),\ + lanes1 = LOAD256u( curData1[argIndex]),\ + lanes2 = LOAD256u( curData2[argIndex]),\ + lanes3 = LOAD256u( curData3[argIndex]),\ + INTLEAVE(),\ + XOReq256( stateAsLanes[argIndex+0], lanes0 ),\ + XOReq256( stateAsLanes[argIndex+1], lanes1 ),\ + XOReq256( stateAsLanes[argIndex+2], lanes2 ),\ + XOReq256( stateAsLanes[argIndex+3], lanes3 ) + + if ( laneCount >= 16 ) { + Xor_In4( 0 ); + Xor_In4( 4 ); + Xor_In4( 8 ); + Xor_In4( 12 ); + if ( laneCount >= 20 ) { + Xor_In4( 16 ); + for(i=20; i 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane); + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)]; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft); + } +} + +void KeccakP1600times4_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + UINT64 *curData0 = (UINT64 *)data; + UINT64 *curData1 = (UINT64 *)(data+laneOffset*1*SnP_laneLengthInBytes); + UINT64 *curData2 = (UINT64 *)(data+laneOffset*2*SnP_laneLengthInBytes); + UINT64 *curData3 = (UINT64 *)(data+laneOffset*3*SnP_laneLengthInBytes); + + const V256 *stateAsLanes = (const V256 *)states; + const UINT64 *stateAsLanes64 = (const UINT64*)states; + V256 lanes0, lanes1, lanes2, lanes3, lanesL01, lanesL23, lanesH01, lanesH23; + unsigned int i; + + #define Extr( argIndex ) curData0[argIndex] = stateAsLanes64[4*(argIndex)], \ + curData1[argIndex] = stateAsLanes64[4*(argIndex)+1], \ + curData2[argIndex] = stateAsLanes64[4*(argIndex)+2], \ + curData3[argIndex] = stateAsLanes64[4*(argIndex)+3] + + #define Extr4( argIndex ) lanes0 = LOAD256( stateAsLanes[argIndex+0] ), \ + lanes1 = LOAD256( stateAsLanes[argIndex+1] ), \ + lanes2 = LOAD256( stateAsLanes[argIndex+2] ), \ + lanes3 = LOAD256( stateAsLanes[argIndex+3] ), \ + UNINTLEAVE(), \ + STORE256u( curData0[argIndex], lanes0 ), \ + STORE256u( curData1[argIndex], lanes1 ), \ + STORE256u( curData2[argIndex], lanes2 ), \ + STORE256u( curData3[argIndex], lanes3 ) + + if ( laneCount >= 16 ) { + Extr4( 0 ); + Extr4( 4 ); + Extr4( 8 ); + Extr4( 12 ); + if ( laneCount >= 20 ) { + Extr4( 16 ); + for(i=20; i= (laneOffsetParallel*3 + laneCount)*8) { + #define XOR_In( Xxx, argIndex ) \ + XOReq256(Xxx, LOAD4_64(curData3[argIndex], curData2[argIndex], curData1[argIndex], curData0[argIndex])) + XOR_In( Aba, 0 ); + XOR_In( Abe, 1 ); + XOR_In( Abi, 2 ); + XOR_In( Abo, 3 ); + XOR_In( Abu, 4 ); + XOR_In( Aga, 5 ); + XOR_In( Age, 6 ); + XOR_In( Agi, 7 ); + XOR_In( Ago, 8 ); + XOR_In( Agu, 9 ); + XOR_In( Aka, 10 ); + XOR_In( Ake, 11 ); + XOR_In( Aki, 12 ); + XOR_In( Ako, 13 ); + XOR_In( Aku, 14 ); + XOR_In( Ama, 15 ); + XOR_In( Ame, 16 ); + XOR_In( Ami, 17 ); + XOR_In( Amo, 18 ); + XOR_In( Amu, 19 ); + XOR_In( Asa, 20 ); + #undef XOR_In + rounds12 + curData0 += laneOffsetSerial; + curData1 += laneOffsetSerial; + curData2 += laneOffsetSerial; + curData3 += laneOffsetSerial; + dataByteLen -= laneOffsetSerial*8; + } + copyToState(statesAsLanes, A) + return (const unsigned char *)curData0 - dataStart; + } + else { + unsigned int i; + const unsigned char *dataStart = data; + + while(dataByteLen >= (laneOffsetParallel*3 + laneCount)*8) { + KeccakP1600times4_AddLanesAll(states, data, laneCount, laneOffsetParallel); + KeccakP1600times4_PermuteAll_12rounds(states); + data += laneOffsetSerial*8; + dataByteLen -= laneOffsetSerial*8; + } + return data - dataStart; + } +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-AVX512.s b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-AVX512.s new file mode 100644 index 000000000..ff60ba2cd --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-AVX512.s @@ -0,0 +1,501 @@ +# Copyright (c) 2006-2017, CRYPTOGAMS by +# Copyright (c) 2018 Ronny Van Keer +# All rights reserved. +# +# The source code in this file is licensed under the CRYPTOGAMS license. +# For further details see http://www.openssl.org/~appro/cryptogams/. +# +# Notes: +# The code for the permutation (__KeccakF1600) was generated with +# Andy Polyakov's keccak1600-avx512.pl from the CRYPTOGAMS project +# (https://github.com/dot-asm/cryptogams/blob/master/x86_64/keccak1600-avx512.pl). +# The rest of the code was written by Ronny Van Keer. + +.text + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_Initialize(void *state); +# +.globl KeccakP1600_Initialize +.type KeccakP1600_Initialize,@function +.align 32 +KeccakP1600_Initialize: + vpxorq %zmm0,%zmm0,%zmm0 + vmovdqa64 %zmm0,0*64(%rdi) + vmovdqa64 %zmm0,1*64(%rdi) + vmovdqa64 %zmm0,2*64(%rdi) + movq $0,3*64(%rdi) + ret +.size KeccakP1600_Initialize,.-KeccakP1600_Initialize + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset); +# %rdi %rsi %rdx +#!! +#.globl KeccakP1600_AddByte +#.type KeccakP1600_AddByte,@function +#.align 32 +#KeccakP1600_AddByte: +# mov %rdx, %rax +# and $7, %rax +# and $0xFFFFFFF8, %edx +# mov mapState(%rdx), %rdx +# add %rdx, %rdi +# add %rax, %rdi +# xorb %sil, (%rdi) +# ret +#.size KeccakP1600_AddByte,.-KeccakP1600_AddByte + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_AddBytes +.type KeccakP1600_AddBytes,@function +.align 32 +KeccakP1600_AddBytes: + cmp $0, %rcx + jz KeccakP1600_AddBytes_Exit + add %rdx, %rdi # state += offset + and $7, %rdx + jz KeccakP1600_AddBytes_LaneAlignedCheck + mov $8, %r9 # r9 is (max) length of incomplete lane + sub %rdx, %r9 + cmp %rcx, %r9 + cmovae %rcx, %r9 + sub %r9, %rcx # length -= length of incomplete lane +KeccakP1600_AddBytes_NotAlignedLoop: + mov (%rsi), %r8b + inc %rsi + xorb %r8b, (%rdi) + inc %rdi + dec %r9 + jnz KeccakP1600_AddBytes_NotAlignedLoop + jmp KeccakP1600_AddBytes_LaneAlignedCheck +KeccakP1600_AddBytes_LaneAlignedLoop: + mov (%rsi), %r8 + add $8, %rsi + xor %r8, (%rdi) + add $8, %rdi +KeccakP1600_AddBytes_LaneAlignedCheck: + sub $8, %rcx + jnc KeccakP1600_AddBytes_LaneAlignedLoop +KeccakP1600_AddBytes_LastIncompleteLane: + add $8, %rcx + jz KeccakP1600_AddBytes_Exit +KeccakP1600_AddBytes_LastIncompleteLaneLoop: + mov (%rsi), %r8b + inc %rsi + xor %r8b, (%rdi) + inc %rdi + dec %rcx + jnz KeccakP1600_AddBytes_LastIncompleteLaneLoop +KeccakP1600_AddBytes_Exit: + ret +.size KeccakP1600_AddBytes,.-KeccakP1600_AddBytes + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_ExtractBytes +.type KeccakP1600_ExtractBytes,@function +.align 32 +KeccakP1600_ExtractBytes: + cmp $0, %rcx + jz KeccakP1600_ExtractBytes_Exit + add %rdx, %rdi # state += offset + and $7, %rdx + jz KeccakP1600_ExtractBytes_LaneAlignedCheck + mov $8, %rax # rax is (max) length of incomplete lane + sub %rdx, %rax + cmp %rcx, %rax + cmovae %rcx, %rax + sub %rax, %rcx # length -= length of incomplete lane +KeccakP1600_ExtractBytes_NotAlignedLoop: + mov (%rdi), %r8b + inc %rdi + mov %r8b, (%rsi) + inc %rsi + dec %rax + jnz KeccakP1600_ExtractBytes_NotAlignedLoop + jmp KeccakP1600_ExtractBytes_LaneAlignedCheck +KeccakP1600_ExtractBytes_LaneAlignedLoop: + mov (%rdi), %r8 + add $8, %rdi + mov %r8, (%rsi) + add $8, %rsi +KeccakP1600_ExtractBytes_LaneAlignedCheck: + sub $8, %rcx + jnc KeccakP1600_ExtractBytes_LaneAlignedLoop +KeccakP1600_ExtractBytes_LastIncompleteLane: + add $8, %rcx + jz KeccakP1600_ExtractBytes_Exit + mov (%rdi), %r8 +KeccakP1600_ExtractBytes_LastIncompleteLaneLoop: + mov %r8b, (%rsi) + shr $8, %r8 + inc %rsi + dec %rcx + jnz KeccakP1600_ExtractBytes_LastIncompleteLaneLoop +KeccakP1600_ExtractBytes_Exit: + ret +.size KeccakP1600_ExtractBytes,.-KeccakP1600_ExtractBytes + +# ----------------------------------------------------------------------------- +# +# internal +# +.text +.type __KeccakF1600,@function +.align 32 +__KeccakF1600: +.Loop_avx512: + ######################################### Theta, even round + vmovdqa64 %zmm0,%zmm5 # put aside original A00 + vpternlogq $0x96,%zmm2,%zmm1,%zmm0 # and use it as "C00" + vpternlogq $0x96,%zmm4,%zmm3,%zmm0 + vprolq $1,%zmm0,%zmm6 + vpermq %zmm0,%zmm13,%zmm0 + vpermq %zmm6,%zmm16,%zmm6 + vpternlogq $0x96,%zmm0,%zmm6,%zmm5 # T[0] is original A00 + vpternlogq $0x96,%zmm0,%zmm6,%zmm1 + vpternlogq $0x96,%zmm0,%zmm6,%zmm2 + vpternlogq $0x96,%zmm0,%zmm6,%zmm3 + vpternlogq $0x96,%zmm0,%zmm6,%zmm4 + ######################################### Rho + vprolvq %zmm22,%zmm5,%zmm0 # T[0] is original A00 + vprolvq %zmm23,%zmm1,%zmm1 + vprolvq %zmm24,%zmm2,%zmm2 + vprolvq %zmm25,%zmm3,%zmm3 + vprolvq %zmm26,%zmm4,%zmm4 + ######################################### Pi + vpermq %zmm0,%zmm17,%zmm0 + vpermq %zmm1,%zmm18,%zmm1 + vpermq %zmm2,%zmm19,%zmm2 + vpermq %zmm3,%zmm20,%zmm3 + vpermq %zmm4,%zmm21,%zmm4 + ######################################### Chi + vmovdqa64 %zmm0,%zmm5 + vmovdqa64 %zmm1,%zmm6 + vpternlogq $0xD2,%zmm2,%zmm1,%zmm0 + vpternlogq $0xD2,%zmm3,%zmm2,%zmm1 + vpternlogq $0xD2,%zmm4,%zmm3,%zmm2 + vpternlogq $0xD2,%zmm5,%zmm4,%zmm3 + vpternlogq $0xD2,%zmm6,%zmm5,%zmm4 + ######################################### Iota + vpxorq (%r10),%zmm0,%zmm0{%k1} + lea 16(%r10),%r10 + ######################################### Harmonize rounds + vpblendmq %zmm2,%zmm1,%zmm6{%k2} + vpblendmq %zmm3,%zmm2,%zmm7{%k2} + vpblendmq %zmm4,%zmm3,%zmm8{%k2} + vpblendmq %zmm1,%zmm0,%zmm5{%k2} + vpblendmq %zmm0,%zmm4,%zmm9{%k2} + vpblendmq %zmm3,%zmm6,%zmm6{%k3} + vpblendmq %zmm4,%zmm7,%zmm7{%k3} + vpblendmq %zmm2,%zmm5,%zmm5{%k3} + vpblendmq %zmm0,%zmm8,%zmm8{%k3} + vpblendmq %zmm1,%zmm9,%zmm9{%k3} + vpblendmq %zmm4,%zmm6,%zmm6{%k4} + vpblendmq %zmm3,%zmm5,%zmm5{%k4} + vpblendmq %zmm0,%zmm7,%zmm7{%k4} + vpblendmq %zmm1,%zmm8,%zmm8{%k4} + vpblendmq %zmm2,%zmm9,%zmm9{%k4} + vpblendmq %zmm4,%zmm5,%zmm5{%k5} + vpblendmq %zmm0,%zmm6,%zmm6{%k5} + vpblendmq %zmm1,%zmm7,%zmm7{%k5} + vpblendmq %zmm2,%zmm8,%zmm8{%k5} + vpblendmq %zmm3,%zmm9,%zmm9{%k5} + #vpermq %zmm5,%zmm33,%zmm0 # doesn't actually change order + vpermq %zmm6,%zmm13,%zmm1 + vpermq %zmm7,%zmm14,%zmm2 + vpermq %zmm8,%zmm15,%zmm3 + vpermq %zmm9,%zmm16,%zmm4 + ######################################### Theta, odd round + vmovdqa64 %zmm5,%zmm0 # real A00 + vpternlogq $0x96,%zmm2,%zmm1,%zmm5 # C00 is %zmm5's alias + vpternlogq $0x96,%zmm4,%zmm3,%zmm5 + vprolq $1,%zmm5,%zmm6 + vpermq %zmm5,%zmm13,%zmm5 + vpermq %zmm6,%zmm16,%zmm6 + vpternlogq $0x96,%zmm5,%zmm6,%zmm0 + vpternlogq $0x96,%zmm5,%zmm6,%zmm3 + vpternlogq $0x96,%zmm5,%zmm6,%zmm1 + vpternlogq $0x96,%zmm5,%zmm6,%zmm4 + vpternlogq $0x96,%zmm5,%zmm6,%zmm2 + ######################################### Rho + vprolvq %zmm27,%zmm0,%zmm0 + vprolvq %zmm30,%zmm3,%zmm6 + vprolvq %zmm28,%zmm1,%zmm7 + vprolvq %zmm31,%zmm4,%zmm8 + vprolvq %zmm29,%zmm2,%zmm9 + vpermq %zmm0,%zmm16,%zmm10 + vpermq %zmm0,%zmm15,%zmm11 + ######################################### Iota + vpxorq -8(%r10),%zmm0,%zmm0{%k1} + ######################################### Pi + vpermq %zmm6,%zmm14,%zmm1 + vpermq %zmm7,%zmm16,%zmm2 + vpermq %zmm8,%zmm13,%zmm3 + vpermq %zmm9,%zmm15,%zmm4 + ######################################### Chi + vpternlogq $0xD2,%zmm11,%zmm10,%zmm0 + vpermq %zmm6,%zmm13,%zmm12 + #vpermq %zmm6,%zmm33,%zmm6 + vpternlogq $0xD2,%zmm6,%zmm12,%zmm1 + vpermq %zmm7,%zmm15,%zmm5 + vpermq %zmm7,%zmm14,%zmm7 + vpternlogq $0xD2,%zmm7,%zmm5,%zmm2 + #vpermq %zmm8,%zmm33,%zmm8 + vpermq %zmm8,%zmm16,%zmm6 + vpternlogq $0xD2,%zmm6,%zmm8,%zmm3 + vpermq %zmm9,%zmm14,%zmm5 + vpermq %zmm9,%zmm13,%zmm9 + vpternlogq $0xD2,%zmm9,%zmm5,%zmm4 + dec %eax + jnz .Loop_avx512 + ret +.size __KeccakF1600,.-__KeccakF1600 + +# ----------------------------------------------------------------------------- +# +# void KeccakP1600_Permute_12rounds(void *state); +# %rdi +# +.globl KeccakP1600_Permute_12rounds +.type KeccakP1600_Permute_12rounds,@function +.align 32 +KeccakP1600_Permute_12rounds: + lea 96(%rdi),%rdi + lea theta_perm(%rip),%r8 + kxnorw %k6,%k6,%k6 + kshiftrw $15,%k6,%k1 + kshiftrw $11,%k6,%k6 + kshiftlw $1,%k1,%k2 + kshiftlw $2,%k1,%k3 + kshiftlw $3,%k1,%k4 + kshiftlw $4,%k1,%k5 + #vmovdqa64 64*0(%r8),%zmm33 + vmovdqa64 64*1(%r8),%zmm13 + vmovdqa64 64*2(%r8),%zmm14 + vmovdqa64 64*3(%r8),%zmm15 + vmovdqa64 64*4(%r8),%zmm16 + vmovdqa64 64*5(%r8),%zmm27 + vmovdqa64 64*6(%r8),%zmm28 + vmovdqa64 64*7(%r8),%zmm29 + vmovdqa64 64*8(%r8),%zmm30 + vmovdqa64 64*9(%r8),%zmm31 + vmovdqa64 64*10(%r8),%zmm22 + vmovdqa64 64*11(%r8),%zmm23 + vmovdqa64 64*12(%r8),%zmm24 + vmovdqa64 64*13(%r8),%zmm25 + vmovdqa64 64*14(%r8),%zmm26 + vmovdqa64 64*15(%r8),%zmm17 + vmovdqa64 64*16(%r8),%zmm18 + vmovdqa64 64*17(%r8),%zmm19 + vmovdqa64 64*18(%r8),%zmm20 + vmovdqa64 64*19(%r8),%zmm21 + vmovdqu64 40*0-96(%rdi),%zmm0{%k6}{z} +# vpxorq %zmm5,%zmm5,%zmm5 + vmovdqu64 40*1-96(%rdi),%zmm1{%k6}{z} + vmovdqu64 40*2-96(%rdi),%zmm2{%k6}{z} + vmovdqu64 40*3-96(%rdi),%zmm3{%k6}{z} + vmovdqu64 40*4-96(%rdi),%zmm4{%k6}{z} + lea iotas+12*8(%rip), %r10 + mov $12/2, %eax + call __KeccakF1600 + vmovdqu64 %zmm0,40*0-96(%rdi){%k6} + vmovdqu64 %zmm1,40*1-96(%rdi){%k6} + vmovdqu64 %zmm2,40*2-96(%rdi){%k6} + vmovdqu64 %zmm3,40*3-96(%rdi){%k6} + vmovdqu64 %zmm4,40*4-96(%rdi){%k6} + vzeroupper + ret +.size KeccakP1600_Permute_12rounds,.-KeccakP1600_Permute_12rounds + +# ----------------------------------------------------------------------------- +# +# size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen); +# %rdi %rsi %rdx %rcx +# +.globl KeccakP1600_12rounds_FastLoop_Absorb +.type KeccakP1600_12rounds_FastLoop_Absorb,@function +.align 32 +KeccakP1600_12rounds_FastLoop_Absorb: + push %rbx + push %r10 + shr $3, %rcx # rcx = data length in lanes + mov %rdx, %rbx # rbx = initial data pointer + cmp %rsi, %rcx + jb KeccakP1600_FastLoop_Absorb_Exit + lea 96(%rdi),%rdi + lea theta_perm(%rip),%r8 + kxnorw %k6,%k6,%k6 + kshiftrw $15,%k6,%k1 + kshiftrw $11,%k6,%k6 + kshiftlw $1,%k1,%k2 + kshiftlw $2,%k1,%k3 + kshiftlw $3,%k1,%k4 + kshiftlw $4,%k1,%k5 + vmovdqa64 64*1(%r8),%zmm13 + vmovdqa64 64*2(%r8),%zmm14 + vmovdqa64 64*3(%r8),%zmm15 + vmovdqa64 64*4(%r8),%zmm16 + vmovdqa64 64*5(%r8),%zmm27 + vmovdqa64 64*6(%r8),%zmm28 + vmovdqa64 64*7(%r8),%zmm29 + vmovdqa64 64*8(%r8),%zmm30 + vmovdqa64 64*9(%r8),%zmm31 + vmovdqa64 64*10(%r8),%zmm22 + vmovdqa64 64*11(%r8),%zmm23 + vmovdqa64 64*12(%r8),%zmm24 + vmovdqa64 64*13(%r8),%zmm25 + vmovdqa64 64*14(%r8),%zmm26 + vmovdqa64 64*15(%r8),%zmm17 + vmovdqa64 64*16(%r8),%zmm18 + vmovdqa64 64*17(%r8),%zmm19 + vmovdqa64 64*18(%r8),%zmm20 + vmovdqa64 64*19(%r8),%zmm21 + vmovdqu64 40*0-96(%rdi),%zmm0{%k6}{z} + vmovdqu64 40*1-96(%rdi),%zmm1{%k6}{z} + vmovdqu64 40*2-96(%rdi),%zmm2{%k6}{z} + vmovdqu64 40*3-96(%rdi),%zmm3{%k6}{z} + vmovdqu64 40*4-96(%rdi),%zmm4{%k6}{z} + cmp $21, %rsi + jnz KeccakP1600_FastLoop_Absorb_Not21Lanes + sub $21, %rcx +KeccakP1600_FastLoop_Absorb_Loop21Lanes: + vmovdqu64 8*0(%rdx),%zmm5{%k6}{z} + vmovdqu64 8*5(%rdx),%zmm6{%k6}{z} + vmovdqu64 8*10(%rdx),%zmm7{%k6}{z} + vmovdqu64 8*15(%rdx),%zmm8{%k6}{z} + vmovdqu64 8*20(%rdx),%zmm9{%k1}{z} + vpxorq %zmm5,%zmm0,%zmm0 + vpxorq %zmm6,%zmm1,%zmm1 + vpxorq %zmm7,%zmm2,%zmm2 + vpxorq %zmm8,%zmm3,%zmm3 + vpxorq %zmm9,%zmm4,%zmm4 + add $21*8, %rdx + lea iotas+12*8(%rip), %r10 + mov $12/2, %eax + call __KeccakF1600 + sub $21, %rcx + jnc KeccakP1600_FastLoop_Absorb_Loop21Lanes +KeccakP1600_FastLoop_Absorb_SaveAndExit: + vmovdqu64 %zmm0,40*0-96(%rdi){%k6} + vmovdqu64 %zmm1,40*1-96(%rdi){%k6} + vmovdqu64 %zmm2,40*2-96(%rdi){%k6} + vmovdqu64 %zmm3,40*3-96(%rdi){%k6} + vmovdqu64 %zmm4,40*4-96(%rdi){%k6} +KeccakP1600_FastLoop_Absorb_Exit: + vzeroupper + mov %rdx, %rax # return number of bytes processed + sub %rbx, %rax + pop %r10 + pop %rbx + ret +KeccakP1600_FastLoop_Absorb_Not21Lanes: + cmp $17, %rsi + jnz KeccakP1600_FastLoop_Absorb_Not17Lanes + sub $17, %rcx +KeccakP1600_FastLoop_Absorb_Loop17Lanes: + vmovdqu64 8*0(%rdx),%zmm5{%k6}{z} + vmovdqu64 8*5(%rdx),%zmm6{%k6}{z} + vmovdqu64 8*10(%rdx),%zmm7{%k6}{z} + vmovdqu64 8*15(%rdx),%zmm8{%k1}{z} + vmovdqu64 8*15(%rdx),%zmm8{%k2} + vpxorq %zmm5,%zmm0,%zmm0 + vpxorq %zmm6,%zmm1,%zmm1 + vpxorq %zmm7,%zmm2,%zmm2 + vpxorq %zmm8,%zmm3,%zmm3 + add $17*8, %rdx + lea iotas+12*8(%rip), %r10 + mov $12/2, %eax + call __KeccakF1600 + sub $17, %rcx + jnc KeccakP1600_FastLoop_Absorb_Loop17Lanes + jmp KeccakP1600_FastLoop_Absorb_SaveAndExit +KeccakP1600_FastLoop_Absorb_Not17Lanes: + lea -96(%rdi), %rdi +KeccakP1600_FastLoop_Absorb_LanesLoop: + mov %rsi, %rax + mov %rdi, %r10 +KeccakP1600_FastLoop_Absorb_LanesAddLoop: + mov (%rdx), %r8 + add $8, %rdx + xor %r8, (%r10) + add $8, %r10 + sub $1, %rax + jnz KeccakP1600_FastLoop_Absorb_LanesAddLoop + sub %rsi, %rcx + push %rdi + push %rsi + push %rdx + push %rcx + call KeccakP1600_Permute_12rounds@PLT + pop %rcx + pop %rdx + pop %rsi + pop %rdi + cmp %rsi, %rcx + jae KeccakP1600_FastLoop_Absorb_LanesLoop + jmp KeccakP1600_FastLoop_Absorb_Exit +.size KeccakP1600_12rounds_FastLoop_Absorb,.-KeccakP1600_12rounds_FastLoop_Absorb + +.align 64 +theta_perm: + .quad 0, 1, 2, 3, 4, 5, 6, 7 # [not used] + .quad 4, 0, 1, 2, 3, 5, 6, 7 + .quad 3, 4, 0, 1, 2, 5, 6, 7 + .quad 2, 3, 4, 0, 1, 5, 6, 7 + .quad 1, 2, 3, 4, 0, 5, 6, 7 +rhotates1: + .quad 0, 44, 43, 21, 14, 0, 0, 0 # [0][0] [1][1] [2][2] [3][3] [4][4] + .quad 18, 1, 6, 25, 8, 0, 0, 0 # [4][0] [0][1] [1][2] [2][3] [3][4] + .quad 41, 2, 62, 55, 39, 0, 0, 0 # [3][0] [4][1] [0][2] [1][3] [2][4] + .quad 3, 45, 61, 28, 20, 0, 0, 0 # [2][0] [3][1] [4][2] [0][3] [1][4] + .quad 36, 10, 15, 56, 27, 0, 0, 0 # [1][0] [2][1] [3][2] [4][3] [0][4] +rhotates0: + .quad 0, 1, 62, 28, 27, 0, 0, 0 + .quad 36, 44, 6, 55, 20, 0, 0, 0 + .quad 3, 10, 43, 25, 39, 0, 0, 0 + .quad 41, 45, 15, 21, 8, 0, 0, 0 + .quad 18, 2, 61, 56, 14, 0, 0, 0 +pi0_perm: + .quad 0, 3, 1, 4, 2, 5, 6, 7 + .quad 1, 4, 2, 0, 3, 5, 6, 7 + .quad 2, 0, 3, 1, 4, 5, 6, 7 + .quad 3, 1, 4, 2, 0, 5, 6, 7 + .quad 4, 2, 0, 3, 1, 5, 6, 7 +iotas: + .quad 0x0000000000000001 + .quad 0x0000000000008082 + .quad 0x800000000000808a + .quad 0x8000000080008000 + .quad 0x000000000000808b + .quad 0x0000000080000001 + .quad 0x8000000080008081 + .quad 0x8000000000008009 + .quad 0x000000000000008a + .quad 0x0000000000000088 + .quad 0x0000000080008009 + .quad 0x000000008000000a + .quad 0x000000008000808b + .quad 0x800000000000008b + .quad 0x8000000000008089 + .quad 0x8000000000008003 + .quad 0x8000000000008002 + .quad 0x8000000000000080 + .quad 0x000000000000800a + .quad 0x800000008000000a + .quad 0x8000000080008081 + .quad 0x8000000000008080 + .quad 0x0000000080000001 + .quad 0x8000000080008008 +iotas_end: +.asciz "Keccak-1600 for AVX-512F, CRYPTOGAMS by " diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-SnP.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-SnP.h new file mode 100644 index 000000000..0a16f95a1 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-SnP.h @@ -0,0 +1,84 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#ifndef _KeccakP_1600_SnP_h_ +#define _KeccakP_1600_SnP_h_ + +#include +#include +#include "KeccakP-1600-config.h" + +#define KeccakP1600_implementation "AVX-512 optimized implementation" +#define KeccakP1600_stateSizeInBytes 200 +#define KeccakP1600_stateAlignment 64 +#define KeccakP1600_12rounds_FastLoop_supported + +#define KeccakP1600_StaticInitialize() +void KeccakP1600_Initialize(void *state); +#define KeccakP1600_AddByte(state, byte, offset) ((unsigned char*)(state))[(offset)] ^= (byte) +void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600_Permute_12rounds(void *state); +void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length); +size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen); + +#define KeccakP1600times2_implementation "512-bit SIMD implementation (" KeccakP1600times2_implementation_config ")" +#define KeccakP1600times2_statesSizeInBytes 400 +#define KeccakP1600times2_statesAlignment 64 +#define KeccakP1600times2_12rounds_FastLoop_supported + +#define KeccakP1600times2_StaticInitialize() +void KeccakP1600times2_InitializeAll(void *states); +#define KeccakP1600times2_AddByte(states, instanceIndex, byte, offset) \ + ((unsigned char*)(states))[(instanceIndex)*8 + ((offset)/8)*2*8 + (offset)%8] ^= (byte) +void KeccakP1600times2_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times2_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +void KeccakP1600times2_PermuteAll_12rounds(void *states); +void KeccakP1600times2_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times2_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +size_t KeccakP1600times2_12rounds_FastLoop_Absorb(void *states, unsigned int laneCount, unsigned int laneOffsetParallel, unsigned int laneOffsetSerial, const unsigned char *data, size_t dataByteLen); + +#define KeccakP1600times4_implementation "512-bit SIMD implementation (" KeccakP1600times4_implementation_config ")" +#define KeccakP1600times4_statesSizeInBytes 800 +#define KeccakP1600times4_statesAlignment 64 +#define KeccakP1600times4_12rounds_FastLoop_supported + +#define KeccakP1600times4_StaticInitialize() +void KeccakP1600times4_InitializeAll(void *states); +#define KeccakP1600times4_AddByte(states, instanceIndex, byte, offset) \ + ((unsigned char*)(states))[(instanceIndex)*8 + ((offset)/8)*4*8 + (offset)%8] ^= (byte) +void KeccakP1600times4_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times4_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +void KeccakP1600times4_PermuteAll_12rounds(void *states); +void KeccakP1600times4_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times4_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +size_t KeccakP1600times4_12rounds_FastLoop_Absorb(void *states, unsigned int laneCount, unsigned int laneOffsetParallel, unsigned int laneOffsetSerial, const unsigned char *data, size_t dataByteLen); + +#define KeccakP1600times8_implementation "512-bit SIMD implementation (" KeccakP1600times8_implementation_config ")" +#define KeccakP1600times8_statesSizeInBytes 1600 +#define KeccakP1600times8_statesAlignment 64 +#define KeccakP1600times8_12rounds_FastLoop_supported + +#define KeccakP1600times8_StaticInitialize() +void KeccakP1600times8_InitializeAll(void *states); +#define KeccakP1600times8_AddByte(states, instanceIndex, byte, offset) \ + ((unsigned char*)(states))[(instanceIndex)*8 + ((offset)/8)*8*8 + (offset)%8] ^= (byte) +void KeccakP1600times8_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times8_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +void KeccakP1600times8_PermuteAll_12rounds(void *states); +void KeccakP1600times8_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length); +void KeccakP1600times8_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset); +size_t KeccakP1600times8_12rounds_FastLoop_Absorb(void *states, unsigned int laneCount, unsigned int laneOffsetParallel, unsigned int laneOffsetSerial, const unsigned char *data, size_t dataByteLen); + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-config.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-config.h new file mode 100644 index 000000000..eab653e71 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-config.h @@ -0,0 +1,11 @@ +#define KeccakP1600times2_implementation_config "AVX512, 12 rounds unrolled" +#define KeccakP1600times2_fullUnrolling +#define KeccakP1600times2_useAVX512 + +#define KeccakP1600times4_implementation_config "AVX512, 12 rounds unrolled" +#define KeccakP1600times4_fullUnrolling +#define KeccakP1600times4_useAVX512 + +#define KeccakP1600times8_implementation_config "AVX512, 12 rounds unrolled" +#define KeccakP1600times8_fullUnrolling +#define KeccakP1600times8_useAVX512 diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times2-SIMD512.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times2-SIMD512.c new file mode 100644 index 000000000..7d56f4015 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times2-SIMD512.c @@ -0,0 +1,471 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "KeccakP-1600-SnP.h" + +#include "brg_endian.h" +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +#error Expecting a little-endian platform +#endif + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +typedef uint8_t UINT8; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef __m128i V128; +typedef __m256i V256; +typedef __m512i V512; + +#if defined(KeccakP1600times2_useAVX512) + +#define XOR(a,b) _mm_xor_si128(a,b) +#define XOR3(a,b,c) _mm_ternarylogic_epi64(a,b,c,0x96) +#define XOR5(a,b,c,d,e) XOR3(XOR3(a,b,c),d,e) +#define XOR512(a,b) _mm512_xor_si512(a,b) +#define ROL(a,offset) _mm_rol_epi64(a,offset) +#define Chi(a,b,c) _mm_ternarylogic_epi64(a,b,c,0xD2) + +#define CONST128_64(a) _mm_set1_epi64((__m64)(a)) +#define LOAD4_32(a,b,c,d) _mm_set_epi32((UINT64)(a), (UINT32)(b), (UINT32)(c), (UINT32)(d)) +#define LOAD8_32(a,b,c,d,e,f,g,h) _mm256_set_epi32((UINT64)(a), (UINT32)(b), (UINT32)(c), (UINT32)(d), (UINT32)(e), (UINT32)(f), (UINT32)(g), (UINT32)(h)) +#define LOAD_GATHER2_64(idx,p) _mm_i32gather_epi64( (const void*)(p), idx, 8) +#define LOAD_GATHER8_64(idx,p) _mm512_i32gather_epi64( idx, (const void*)(p), 8) +#define STORE_SCATTER2_64(p,idx, v) _mm_i32scatter_epi64( (void*)(p), idx, v, 8) +#define STORE_SCATTER8_64(p,idx, v) _mm512_i32scatter_epi64( (void*)(p), idx, v, 8) + +#endif + +#define laneIndex(instanceIndex, lanePosition) ((lanePosition)*2 + instanceIndex) +#define SnP_laneLengthInBytes 8 + +void KeccakP1600times2_InitializeAll(void *states) +{ + memset(states, 0, KeccakP1600times2_statesSizeInBytes); +} + +void KeccakP1600times2_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length) +{ + unsigned int sizeLeft = length; + unsigned int lanePosition = offset/SnP_laneLengthInBytes; + unsigned int offsetInLane = offset%SnP_laneLengthInBytes; + const unsigned char *curData = data; + UINT64 *statesAsLanes = states; + + if ((sizeLeft > 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + UINT64 lane = 0; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + UINT64 lane = *((const UINT64*)curData); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + UINT64 lane = 0; + memcpy(&lane, curData, sizeLeft); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + } +} + +void KeccakP1600times2_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + V128 *stateAsLanes128 = states; + V512 *stateAsLanes512 = states; + const UINT64 *dataAsLanes = (const UINT64 *)data; + unsigned int i; + V128 index128 = LOAD4_32(0, 0, 1*laneOffset, 0*laneOffset); + V256 index512 = LOAD8_32(1*laneOffset+3, 0*laneOffset+3, 1*laneOffset+2, 0*laneOffset+2, 1*laneOffset+1, 0*laneOffset+1, 1*laneOffset, 0*laneOffset); + + #define Add_In1( argIndex ) stateAsLanes128[argIndex] = XOR(stateAsLanes128[argIndex], LOAD_GATHER2_64(index128, dataAsLanes+argIndex)) + #define Add_In4( argIndex ) stateAsLanes512[argIndex/4] = XOR512(stateAsLanes512[argIndex/4], LOAD_GATHER8_64(index512, dataAsLanes+argIndex)) + if ( laneCount >= 16 ) { + Add_In4( 0 ); + Add_In4( 4 ); + Add_In4( 8 ); + Add_In4( 12 ); + if ( laneCount >= 20 ) { + Add_In4( 16 ); + for(i=20; i 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane); + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)]; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft); + } +} + +void KeccakP1600times2_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + const V128 *stateAsLanes128 = states; + const V512 *stateAsLanes512 = states; + UINT64 *dataAsLanes = (UINT64 *)data; + unsigned int i; + V128 index128 = LOAD4_32(0, 0, 1*laneOffset, 0*laneOffset); + V256 index512 = LOAD8_32(1*laneOffset+3, 0*laneOffset+3, 1*laneOffset+2, 0*laneOffset+2, 1*laneOffset+1, 0*laneOffset+1, 1*laneOffset, 0*laneOffset); + + #define Extr1( argIndex ) STORE_SCATTER2_64(dataAsLanes+argIndex, index128, stateAsLanes128[argIndex]) + #define Extr4( argIndex ) STORE_SCATTER8_64(dataAsLanes+argIndex, index512, stateAsLanes512[argIndex/4]) + if ( laneCount >= 16 ) { + Extr4( 0 ); + Extr4( 4 ); + Extr4( 8 ); + Extr4( 12 ); + if ( laneCount >= 20 ) { + Extr4( 16 ); + for(i=20; i= dataMinimumSize) { + #define Add_In( argLane, argIndex ) argLane = XOR(argLane, LOAD_GATHER2_64(index, dataAsLanes+argIndex)) + Add_In( _ba, 0 ); + Add_In( _be, 1 ); + Add_In( _bi, 2 ); + Add_In( _bo, 3 ); + Add_In( _bu, 4 ); + Add_In( _ga, 5 ); + Add_In( _ge, 6 ); + Add_In( _gi, 7 ); + Add_In( _go, 8 ); + Add_In( _gu, 9 ); + Add_In( _ka, 10 ); + Add_In( _ke, 11 ); + Add_In( _ki, 12 ); + Add_In( _ko, 13 ); + Add_In( _ku, 14 ); + Add_In( _ma, 15 ); + Add_In( _me, 16 ); + Add_In( _mi, 17 ); + Add_In( _mo, 18 ); + Add_In( _mu, 19 ); + Add_In( _sa, 20 ); + #undef Add_In + rounds12; + dataAsLanes += laneOffsetSerial; + dataByteLen -= laneOffsetSerial*8; + } + copyToState(statesAsLanes); + return (const unsigned char *)dataAsLanes - dataStart; + } + else { + const unsigned char *dataStart = data; + + while(dataByteLen >= dataMinimumSize) { + KeccakP1600times2_AddLanesAll(states, data, laneCount, laneOffsetParallel); + KeccakP1600times2_PermuteAll_12rounds(states); + data += laneOffsetSerial*8; + dataByteLen -= laneOffsetSerial*8; + } + return data - dataStart; + } +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times4-SIMD512.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times4-SIMD512.c new file mode 100644 index 000000000..38b88b044 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times4-SIMD512.c @@ -0,0 +1,486 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "KeccakP-1600-SnP.h" + +#include "brg_endian.h" +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +#error Expecting a little-endian platform +#endif + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +typedef uint8_t UINT8; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef __m128i V128; +typedef __m256i V256; +typedef __m512i V512; + +#if defined(KeccakP1600times4_useAVX512) + +#define XOR(a,b) _mm256_xor_si256(a,b) +#define XOR3(a,b,c) _mm256_ternarylogic_epi64(a,b,c,0x96) +#define XOR5(a,b,c,d,e) XOR3(XOR3(a,b,c),d,e) +#define XOR512(a,b) _mm512_xor_si512(a,b) +#define ROL(a,offset) _mm256_rol_epi64(a,offset) +#define Chi(a,b,c) _mm256_ternarylogic_epi64(a,b,c,0xD2) + +#define CONST256_64(a) (V256)_mm256_broadcast_sd((const double*)(&a)) +#define LOAD4_32(a,b,c,d) _mm_set_epi32((UINT64)(a), (UINT32)(b), (UINT32)(c), (UINT32)(d)) +#define LOAD8_32(a,b,c,d,e,f,g,h) _mm256_set_epi32((UINT64)(a), (UINT32)(b), (UINT32)(c), (UINT32)(d), (UINT32)(e), (UINT32)(f), (UINT32)(g), (UINT32)(h)) +#define LOAD_GATHER4_64(idx,p) _mm256_i32gather_epi64( (const void*)(p), idx, 8) +#define LOAD_GATHER8_64(idx,p) _mm512_i32gather_epi64( idx, (const void*)(p), 8) +#define STORE_SCATTER4_64(p,idx, v) _mm256_i32scatter_epi64( (void*)(p), idx, v, 8) +#define STORE_SCATTER8_64(p,idx, v) _mm512_i32scatter_epi64( (void*)(p), idx, v, 8) + +#endif + +#define laneIndex(instanceIndex, lanePosition) ((lanePosition)*4 + instanceIndex) +#define SnP_laneLengthInBytes 8 + +void KeccakP1600times4_InitializeAll(void *states) +{ + memset(states, 0, KeccakP1600times4_statesSizeInBytes); +} + +void KeccakP1600times4_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length) +{ + unsigned int sizeLeft = length; + unsigned int lanePosition = offset/SnP_laneLengthInBytes; + unsigned int offsetInLane = offset%SnP_laneLengthInBytes; + const unsigned char *curData = data; + UINT64 *statesAsLanes = states; + + if ((sizeLeft > 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + UINT64 lane = 0; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + UINT64 lane = *((const UINT64*)curData); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + UINT64 lane = 0; + memcpy(&lane, curData, sizeLeft); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + } +} + +void KeccakP1600times4_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + V256 *stateAsLanes256 = states; + V512 *stateAsLanes512 = states; + const UINT64 *dataAsLanes = (const UINT64 *)data; + unsigned int i; + V256 index512; + V128 index256; + + #define Add_In1( argIndex ) stateAsLanes256[argIndex] = XOR(stateAsLanes256[argIndex], LOAD_GATHER4_64(index256, dataAsLanes+argIndex)) + #define Add_In2( argIndex ) stateAsLanes512[argIndex/2] = XOR512(stateAsLanes512[argIndex/2], LOAD_GATHER8_64(index512, dataAsLanes+argIndex)) + index256 = LOAD4_32(3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + index512 = LOAD8_32(3*laneOffset+1, 2*laneOffset+1, 1*laneOffset+1, 0*laneOffset+1, 3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + if ( laneCount >= 16 ) { + Add_In2( 0 ); + Add_In2( 2 ); + Add_In2( 4 ); + Add_In2( 6 ); + Add_In2( 8 ); + Add_In2( 10 ); + Add_In2( 12 ); + Add_In2( 14 ); + if ( laneCount >= 20 ) { + Add_In2( 16 ); + Add_In2( 18 ); + for(i=20; i 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane); + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)]; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft); + } +} + +void KeccakP1600times4_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + const V256 *stateAsLanes256 = states; + const V512 *stateAsLanes512 = states; + UINT64 *dataAsLanes = (UINT64 *)data; + unsigned int i; + V256 index512; + V128 index256; + + #define Extr1( argIndex ) STORE_SCATTER4_64(dataAsLanes+argIndex, index256, stateAsLanes256[argIndex]) + #define Extr2( argIndex ) STORE_SCATTER8_64(dataAsLanes+argIndex, index512, stateAsLanes512[argIndex/2]) + index256 = LOAD4_32(3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + index512 = LOAD8_32(3*laneOffset+1, 2*laneOffset+1, 1*laneOffset+1, 0*laneOffset+1, 3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + if ( laneCount >= 16 ) { + Extr2( 0 ); + Extr2( 2 ); + Extr2( 4 ); + Extr2( 6 ); + Extr2( 8 ); + Extr2( 10 ); + Extr2( 12 ); + Extr2( 14 ); + if ( laneCount >= 20 ) { + Extr2( 16 ); + Extr2( 18 ); + for(i=20; i= dataMinimumSize) { + #define Add_In( argLane, argIndex ) argLane = XOR(argLane, LOAD_GATHER4_64(index, dataAsLanes+argIndex)) + Add_In( _ba, 0 ); + Add_In( _be, 1 ); + Add_In( _bi, 2 ); + Add_In( _bo, 3 ); + Add_In( _bu, 4 ); + Add_In( _ga, 5 ); + Add_In( _ge, 6 ); + Add_In( _gi, 7 ); + Add_In( _go, 8 ); + Add_In( _gu, 9 ); + Add_In( _ka, 10 ); + Add_In( _ke, 11 ); + Add_In( _ki, 12 ); + Add_In( _ko, 13 ); + Add_In( _ku, 14 ); + Add_In( _ma, 15 ); + Add_In( _me, 16 ); + Add_In( _mi, 17 ); + Add_In( _mo, 18 ); + Add_In( _mu, 19 ); + Add_In( _sa, 20 ); + #undef Add_In + rounds12; + dataAsLanes += laneOffsetSerial; + dataByteLen -= laneOffsetSerial*8; + } + copyToState(statesAsLanes); + return (const unsigned char *)dataAsLanes - dataStart; + } + else { + const unsigned char *dataStart = data; + + while(dataByteLen >= dataMinimumSize) { + KeccakP1600times4_AddLanesAll(states, data, laneCount, laneOffsetParallel); + KeccakP1600times4_PermuteAll_12rounds(states); + data += laneOffsetSerial*8; + dataByteLen -= laneOffsetSerial*8; + } + return data - dataStart; + } +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times8-SIMD512.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times8-SIMD512.c new file mode 100644 index 000000000..a11e9e0de --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/OptimizedAVX512/KeccakP-1600-times8-SIMD512.c @@ -0,0 +1,496 @@ +/* +Implementation by Ronny Van Keer, hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ + +--- + +Please refer to the XKCP for more details. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "KeccakP-1600-SnP.h" + +#include "brg_endian.h" +#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN) +#error Expecting a little-endian platform +#endif + +#ifdef ALIGN +#undef ALIGN +#endif + +#if defined(__GNUC__) +#define ALIGN(x) __attribute__ ((aligned(x))) +#elif defined(_MSC_VER) +#define ALIGN(x) __declspec(align(x)) +#elif defined(__ARMCC_VERSION) +#define ALIGN(x) __align(x) +#else +#define ALIGN(x) +#endif + +typedef __m128i V128; +typedef __m256i V256; +typedef __m512i V512; + +#if defined(KeccakP1600times8_useAVX512) + +#define XOR(a,b) _mm512_xor_si512(a,b) +#define XOR3(a,b,c) _mm512_ternarylogic_epi64(a,b,c,0x96) +#define XOR5(a,b,c,d,e) XOR3(XOR3(a,b,c),d,e) +#define XOReq512(a, b) a = XOR(a,b) + +#define ROL(a,offset) _mm512_rol_epi64(a,offset) +#define Chi(a,b,c) _mm512_ternarylogic_epi64(a,b,c,0xD2) + +#define CONST8_64(a) (V512)_mm512_broadcast_f64x4(_mm256_broadcast_sd((const double*)(&a))) + +#define LOAD512(a) _mm512_load_si512((const V512 *)&(a)) +#define LOAD512u(a) _mm512_loadu_si512((const V512 *)&(a)) +#define LOAD8_32(a,b,c,d,e,f,g,h) _mm256_set_epi32((uint64_t)(a), (uint32_t)(b), (uint32_t)(c), (uint32_t)(d), (uint32_t)(e), (uint32_t)(f), (uint32_t)(g), (uint32_t)(h)) +#define LOAD8_64(a,b,c,d,e,f,g,h) _mm512_set_epi64((uint64_t)(a), (uint64_t)(b), (uint64_t)(c), (uint64_t)(d), (uint64_t)(e), (uint64_t)(f), (uint64_t)(g), (uint64_t)(h)) +#define LOAD_GATHER8_64(idx,p) _mm512_i32gather_epi64( idx, (const void*)(p), 8) + +#define STORE_SCATTER8_64(p,idx, v) _mm512_i32scatter_epi64( (void*)(p), idx, v, 8) + +#endif + +#define laneIndex(instanceIndex, lanePosition) ((lanePosition)*8 + instanceIndex) +#define SnP_laneLengthInBytes 8 + +void KeccakP1600times8_InitializeAll(void *states) +{ + memset(states, 0, KeccakP1600times8_statesSizeInBytes); +} + +void KeccakP1600times8_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length) +{ + unsigned int sizeLeft = length; + unsigned int lanePosition = offset/SnP_laneLengthInBytes; + unsigned int offsetInLane = offset%SnP_laneLengthInBytes; + const unsigned char *curData = data; + uint64_t *statesAsLanes = states; + + if ((sizeLeft > 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + uint64_t lane = 0; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + uint64_t lane = *((const uint64_t*)curData); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + uint64_t lane = 0; + memcpy(&lane, curData, sizeLeft); + statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane; + } +} + +void KeccakP1600times8_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + V512 *stateAsLanes = states; + const uint64_t *dataAsLanes = (const uint64_t *)data; + unsigned int i; + V256 index; + + #define Add_In( argIndex ) stateAsLanes[argIndex] = XOR(stateAsLanes[argIndex], LOAD_GATHER8_64(index, dataAsLanes+argIndex)) + index = LOAD8_32(7*laneOffset, 6*laneOffset, 5*laneOffset, 4*laneOffset, 3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + if ( laneCount >= 16 ) { + Add_In( 0 ); + Add_In( 1 ); + Add_In( 2 ); + Add_In( 3 ); + Add_In( 4 ); + Add_In( 5 ); + Add_In( 6 ); + Add_In( 7 ); + Add_In( 8 ); + Add_In( 9 ); + Add_In( 10 ); + Add_In( 11 ); + Add_In( 12 ); + Add_In( 13 ); + Add_In( 14 ); + Add_In( 15 ); + if ( laneCount >= 20 ) { + Add_In( 16 ); + Add_In( 17 ); + Add_In( 18 ); + Add_In( 19 ); + for(i=20; i 0) && (offsetInLane != 0)) { + unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane; + if (bytesInLane > sizeLeft) + bytesInLane = sizeLeft; + memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane); + sizeLeft -= bytesInLane; + lanePosition++; + curData += bytesInLane; + } + + while(sizeLeft >= SnP_laneLengthInBytes) { + *(uint64_t*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)]; + sizeLeft -= SnP_laneLengthInBytes; + lanePosition++; + curData += SnP_laneLengthInBytes; + } + + if (sizeLeft > 0) { + memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft); + } +} + +void KeccakP1600times8_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset) +{ + const V512 *stateAsLanes = states; + uint64_t *dataAsLanes = (uint64_t *)data; + unsigned int i; + V256 index; + + #define Extr( argIndex ) STORE_SCATTER8_64(dataAsLanes+argIndex, index, stateAsLanes[argIndex]) + index = LOAD8_32(7*laneOffset, 6*laneOffset, 5*laneOffset, 4*laneOffset, 3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset); + if ( laneCount >= 16 ) { + Extr( 0 ); + Extr( 1 ); + Extr( 2 ); + Extr( 3 ); + Extr( 4 ); + Extr( 5 ); + Extr( 6 ); + Extr( 7 ); + Extr( 8 ); + Extr( 9 ); + Extr( 10 ); + Extr( 11 ); + Extr( 12 ); + Extr( 13 ); + Extr( 14 ); + Extr( 15 ); + if ( laneCount >= 20 ) { + Extr( 16 ); + Extr( 17 ); + Extr( 18 ); + Extr( 19 ); + for(i=20; i= dataMinimumSize) { + #define Add_In( argLane, argIndex ) argLane = XOR(argLane, LOAD_GATHER8_64(index, dataAsLanes+argIndex)) + Add_In( _ba, 0 ); + Add_In( _be, 1 ); + Add_In( _bi, 2 ); + Add_In( _bo, 3 ); + Add_In( _bu, 4 ); + Add_In( _ga, 5 ); + Add_In( _ge, 6 ); + Add_In( _gi, 7 ); + Add_In( _go, 8 ); + Add_In( _gu, 9 ); + Add_In( _ka, 10 ); + Add_In( _ke, 11 ); + Add_In( _ki, 12 ); + Add_In( _ko, 13 ); + Add_In( _ku, 14 ); + Add_In( _ma, 15 ); + Add_In( _me, 16 ); + Add_In( _mi, 17 ); + Add_In( _mo, 18 ); + Add_In( _mu, 19 ); + Add_In( _sa, 20 ); + #undef Add_In + rounds12; + dataAsLanes += laneOffsetSerial; + dataByteLen -= laneOffsetSerial*8; + } + copyToState(statesAsLanes); + return (const unsigned char *)dataAsLanes - dataStart; + } + else { + const unsigned char *dataStart = data; + + while(dataByteLen >= dataMinimumSize) { + KeccakP1600times8_AddLanesAll(states, data, laneCount, laneOffsetParallel); + KeccakP1600times8_PermuteAll_12rounds(states); + data += laneOffsetSerial*8; + dataByteLen -= laneOffsetSerial*8; + } + return data - dataStart; + } +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/brg_endian.h b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/brg_endian.h new file mode 100644 index 000000000..7c640b90e --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/lib/brg_endian.h @@ -0,0 +1,143 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The redistribution and use of this software (with or without changes) + is allowed without the payment of fees or royalties provided that: + + 1. source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + 2. binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation; + + 3. the name of the copyright holder is not used to endorse products + built using this software without specific written permission. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 20/12/2007 + Changes for ARM 9/9/2010 +*/ + +#ifndef _BRG_ENDIAN_H +#define _BRG_ENDIAN_H + +#define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */ +#define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */ + +#if 0 +/* Include files where endian defines and byteswap functions may reside */ +#if defined( __sun ) +# include +#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ ) +# include +#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \ + defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ ) +# include +#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ ) +# if !defined( __MINGW32__ ) && !defined( _AIX ) +# include +# if !defined( __BEOS__ ) +# include +# endif +# endif +#endif +#endif + +/* Now attempt to set the define for platform byte order using any */ +/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */ +/* seem to encompass most endian symbol definitions */ + +#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN ) +# if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN ) +# if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( _BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( _LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN ) +# if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( __BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( __LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ ) +# if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__ +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__ +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( __BIG_ENDIAN__ ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( __LITTLE_ENDIAN__ ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +/* if the platform byte order could not be determined, then try to */ +/* set this define using common machine defines */ +#if !defined(PLATFORM_BYTE_ORDER) + +#if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \ + defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \ + defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \ + defined( vax ) || defined( vms ) || defined( VMS ) || \ + defined( __VMS ) || defined( _M_X64 ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN + +#elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \ + defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \ + defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \ + defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \ + defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \ + defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \ + defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX ) || \ + defined( __s390__ ) || defined( __s390x__ ) || defined( __zarch__ ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN + +#elif defined(__arm__) +# ifdef __BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# else +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif 1 /* **** EDIT HERE IF NECESSARY **** */ +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#elif 0 /* **** EDIT HERE IF NECESSARY **** */ +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#else +# error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order +#endif + +#endif + +#endif diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ExpandProducts.xsl b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ExpandProducts.xsl new file mode 100644 index 000000000..9d3f64fd7 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ExpandProducts.xsl @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToGlobalMakefile.xsl b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToGlobalMakefile.xsl new file mode 100644 index 000000000..c7fe1b0fa --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToGlobalMakefile.xsl @@ -0,0 +1,182 @@ + + + + + + + + + + + + + + + + + + : + + + + + .packs: + + + + + + .PHONY: + + + + + + + + + + + + : + + + + + + : + + + $(MAKE) -f + + + + + + + + : + + + $(MAKE) -f + + + + + + + + : + + + + + + : + + + mkdir -p $(dir $@) + xsltproc -o $@ support/Build/ToVCXProj.xsl + + + + + + : + + support/Build/ToTargetMakefile.xsl + mkdir -p $(dir $@) + xsltproc -o $@ support/Build/ToTargetMakefile.xsl $< + + + + : support/Build/ToOneTarget.xsl bin/.build/Makefile.expanded Makefile.build + mkdir -p $(dir $@) + xsltproc -o $@ -param nameTarget "' + + '" support/Build/ToOneTarget.xsl bin/.build/Makefile.expanded + + + + + + + .PHONY: + + + .packs + + + + + : + + + + .packs + : + .packs + + + + + + + + + + + @echo "+ + + [.packs]" + + + + + + + @echo "- + + [.pack|.vcxproj]" + + + + +.PHONY: _list +_list: + @echo "The defined targets (-) and groups of targets (+) are:" + + + @echo "+ + + [.packs]" + + + + + + + + .PHONY: + + + .packs + + + + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToOneTarget.xsl b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToOneTarget.xsl new file mode 100644 index 000000000..0d230e425 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToOneTarget.xsl @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToTargetMakefile.xsl b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToTargetMakefile.xsl new file mode 100644 index 000000000..a17245a1d --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToTargetMakefile.xsl @@ -0,0 +1,206 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CFLAGS := $(CFLAGS) + + + + + + + + CFLAGS := $(CFLAGS) -D + + ="" + + + + + + + + CFLAGS := $(CFLAGS) -I + + + + + + + + + HEADERS := $(HEADERS) + + + + SOURCES := $(SOURCES) + + + + + + + + + + SOURCES := $(SOURCES) + + + + + $(BINDIR)/ + + + + .o + + + : + + $(HEADERS) + $(CC) $(INCLUDES) $(CFLAGS) -c $< -o $@ +OBJECTS := $(OBJECTS) + + + + + + + + + + + + + + all: + + + + + : + + + + + .pack: + + + + + BINDIR = bin/.build/ + + +$(BINDIR): + mkdir -p $(BINDIR) + +MAKE ?= gmake +CC ?= gcc +AR = ar + + + + + CFLAGS := $(CFLAGS) -fpic + + + + + + + + bin/ + + : $(BINDIR) $(OBJECTS) + mkdir -p $(dir $@) + + + + + mkdir -p $@.headers + cp -f $(HEADERS) $@.headers/ + $(AR) rcsv $@ $(OBJECTS) + + + + mkdir -p $@.headers + cp -f $(HEADERS) $@.headers/ + $(CC) -shared -o $@ $(OBJECTS) $(CFLAGS) + + + + $(CC) -o $@ $(OBJECTS) $(CFLAGS) + + + + + + + + + : $(SOURCES) + mkdir -p bin/.pack/ + + + rm -rf bin/.pack/ + + /* + cp $(SOURCES) bin/.pack/ + + / + cd bin/.pack/ ; tar -czf + + + + /* + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToVCXProj.xsl b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToVCXProj.xsl new file mode 100644 index 000000000..03aaaf5e1 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/support/Build/ToVCXProj.xsl @@ -0,0 +1,131 @@ + + + + + + + + + + + + + Debug + Win32 + + + Release + Win32 + + + + {6F1C9407-7A01-444D-A07B-7DAE147F22A1} + XKCP + + + + Application + true + v110 + MultiByte + + + Application + false + v110 + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)$(ProjectName)\$(Configuration)\ + $(SolutionDir)$(ProjectName)\$(Configuration)\ + + + $(SolutionDir)$(ProjectName)\$(Configuration)\ + $(SolutionDir)$(ProjectName)\$(Configuration)\ + + + + Level3 + Disabled + + + + true + + + + + Level3 + MaxSpeed + true + true + + + + true + true + true + + + + + + + + + + + + + + + + + $(ProjectDir)..\..\ + + ; + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/plonk/blake2_const/benches/kangarootwelve/K12/tests/main.c b/src/plonk/blake2_const/benches/kangarootwelve/K12/tests/main.c new file mode 100644 index 000000000..efd384df5 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/K12/tests/main.c @@ -0,0 +1,70 @@ +/* +Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen, +Michaël Peeters, Gilles Van Assche and Ronny Van Keer, +hereby denoted as "the implementer". + +For more information, feedback or questions, please refer to our website: +https://keccak.team/ + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ +*/ + +#include +#include +#include +#include +#include "testKangarooTwelve.h" +#include "testPerformance.h" + +void printHelp() +{ + printf("Usage: KeccakTests command(s), where the commands can be\n"); + printf(" --help or -h To display this page\n"); + printf(" --all or -a All tests\n"); + printf(" --KangarooTwelve or -K12 Tests on KangarooTwelve\n"); + printf(" --speed or -s Speed measuresments\n"); +} + +int process(int argc, char* argv[]) +{ + int i; + int help = 0; + int KangarooTwelve = 0; + int speed = 0; + + if (argc == 1) + help = 1; + + for(i=1; i +#endif +#include +#include + +#if defined(EMBEDDED) +static void assert(int condition) +{ + if (!condition) + { + for ( ; ; ) ; + } +} +#else +#include +#endif + +static void generateSimpleRawMaterial(unsigned char* data, unsigned int length, unsigned char seed1, unsigned int seed2) +{ + unsigned int i; + + for(i=0; i> (8-seed2)); + byte = seed1 + 161*length - iRolled + i; + data[i] = byte; + } +} + +static void performTestKangarooTwelveOneInput(unsigned int inputLen, unsigned int outputLen, unsigned int customLen, KangarooTwelve_Instance *pSpongeChecksum, unsigned int mode, unsigned int useSqueeze) +{ + unsigned char input[inputByteSize]; + unsigned char output[outputByteSize]; + unsigned char customization[customizationByteSize]; + int result; + unsigned int i; + + generateSimpleRawMaterial(customization, customizationByteSize, customLen, 97); + generateSimpleRawMaterial(input, inputLen, outputLen, inputLen + customLen); + + #ifdef VERBOSE + printf( "outputLen %5u, inputLen %5u, customLen %3u\n", outputLen, inputLen, customLen); + #endif + if (!useSqueeze) + { + if (mode == 0) + { + /* Input/Output full size in one call */ + result = KangarooTwelve( input, inputLen, output, outputLen, customization, customLen ); + assert(result == 0); + } + else if (mode == 1) + { + /* Input/Output one byte per call */ + KangarooTwelve_Instance kt; + result = KangarooTwelve_Initialize(&kt, outputLen); + assert(result == 0); + for (i = 0; i < inputLen; ++i ) + { + result = KangarooTwelve_Update(&kt, input + i, 1); + assert(result == 0); + } + result = KangarooTwelve_Final(&kt, output, customization, customLen ); + assert(result == 0); + } + else if (mode == 2) + { + /* Input/Output random number of bytes per call */ + KangarooTwelve_Instance kt; + unsigned char *pInput = input; + result = KangarooTwelve_Initialize(&kt, outputLen); + assert(result == 0); + while (inputLen) + { + unsigned int len = ((rand() << 15) ^ rand()) % (inputLen + 1); + result = KangarooTwelve_Update(&kt, pInput, len); + assert(result == 0); + pInput += len; + inputLen -= len; + } + result = KangarooTwelve_Final(&kt, output, customization, customLen); + assert(result == 0); + } + } + else + { + if (mode == 0) + { + KangarooTwelve_Instance kt; + result = KangarooTwelve_Initialize(&kt, 0); + assert(result == 0); + result = KangarooTwelve_Update(&kt, input, inputLen); + assert(result == 0); + result = KangarooTwelve_Final(&kt, 0, customization, customLen); + assert(result == 0); + result = KangarooTwelve_Squeeze(&kt, output, outputLen); + assert(result == 0); + } + else if (mode == 1) + { + KangarooTwelve_Instance kt; + result = KangarooTwelve_Initialize(&kt, 0); + assert(result == 0); + result = KangarooTwelve_Update(&kt, input, inputLen); + assert(result == 0); + result = KangarooTwelve_Final(&kt, 0, customization, customLen); + assert(result == 0); + + for (i = 0; i < outputLen; ++i) + { + result = KangarooTwelve_Squeeze(&kt, output + i, 1); + assert(result == 0); + } + } + else if (mode == 2) + { + KangarooTwelve_Instance kt; + unsigned int len; + result = KangarooTwelve_Initialize(&kt, 0); + assert(result == 0); + result = KangarooTwelve_Update(&kt, input, inputLen); + assert(result == 0); + result = KangarooTwelve_Final(&kt, 0, customization, customLen); + assert(result == 0); + + for (i = 0; i < outputLen; i += len) + { + len = ((rand() << 15) ^ rand()) % ((outputLen-i) + 1); + result = KangarooTwelve_Squeeze(&kt, output+i, len); + assert(result == 0); + } + } + } + + #ifdef VERBOSE + { + unsigned int i; + + printf("KangarooTwelve\n"); + printf("Input of %d bytes:", inputLen); + for(i=0; (i 16) + printf(" ..."); + printf("\n"); + printf("Output of %d bytes:", outputLen); + for(i=0; i +#include +#include +#include +#include "KangarooTwelve.h" +#include "timing.h" +#include "testPerformance.h" + +void displayMeasurements1101001000(uint_32t *measurements, uint_32t *laneCounts, unsigned int numberOfColumns, unsigned int laneLengthInBytes); + +#define xstr(s) str(s) +#define str(s) #s + +uint_32t measureKangarooTwelve(uint_32t dtMin, unsigned int inputLen) +{ + ALIGN(32) unsigned char input[1024*1024]; + ALIGN(32) unsigned char output[32]; + measureTimingDeclare + + assert(inputLen <= 1024*1024); + + memset(input, 0xA5, 16); + + measureTimingBeginDeclared + KangarooTwelve(input, inputLen, output, 32, (const unsigned char *)"", 0); + measureTimingEnd +} + +void printKangarooTwelvePerformanceHeader( void ) +{ + printf("*** KangarooTwelve ***\n"); + printf("Using Keccak-p[1600,12] implementations:\n"); + printf("- \303\2271: " KeccakP1600_implementation "\n"); + #if defined(KeccakP1600_12rounds_FastLoop_supported) + printf(" + KeccakP1600_12rounds_FastLoop_Absorb()\n"); + #endif + + #if defined(KeccakP1600times2_implementation) && !defined(KeccakP1600times2_isFallback) + printf("- \303\2272: " KeccakP1600times2_implementation "\n"); + #if defined(KeccakP1600times2_12rounds_FastLoop_supported) + printf(" + KeccakP1600times2_12rounds_FastLoop_Absorb()\n"); + #endif + #else + printf("- \303\2272: not used\n"); + #endif + + #if defined(KeccakP1600times4_implementation) && !defined(KeccakP1600times4_isFallback) + printf("- \303\2274: " KeccakP1600times4_implementation "\n"); + #if defined(KeccakP1600times4_12rounds_FastLoop_supported) + printf(" + KeccakP1600times4_12rounds_FastLoop_Absorb()\n"); + #endif + #else + printf("- \303\2274: not used\n"); + #endif + + #if defined(KeccakP1600times8_implementation) && !defined(KeccakP1600times8_isFallback) + printf("- \303\2278: " KeccakP1600times8_implementation "\n"); + #if defined(KeccakP1600times8_12rounds_FastLoop_supported) + printf(" + KeccakP1600times8_12rounds_FastLoop_Absorb()\n"); + #endif + #else + printf("- \303\2278: not used\n"); + #endif + + printf("\n"); +} + +void testKangarooTwelvePerformanceOne( void ) +{ + const unsigned int chunkSize = 8192; + unsigned halfTones; + uint_32t calibration = calibrate(); + unsigned int chunkSizeLog = (unsigned int)floor(log(chunkSize)/log(2.0)+0.5); + int displaySlope = 0; + + measureKangarooTwelve(calibration, 500000); + for(halfTones=chunkSizeLog*12-28; halfTones<=13*12; halfTones+=4) { + double I = pow(2.0, halfTones/12.0); + unsigned int i = (unsigned int)floor(I+0.5); + uint_32t time, timePlus1Block, timePlus2Blocks, timePlus4Blocks, timePlus8Blocks; + uint_32t timePlus84Blocks; + time = measureKangarooTwelve(calibration, i); + if (i == chunkSize) { + displaySlope = 1; + timePlus1Block = measureKangarooTwelve(calibration, i+1*chunkSize); + timePlus2Blocks = measureKangarooTwelve(calibration, i+2*chunkSize); + timePlus4Blocks = measureKangarooTwelve(calibration, i+4*chunkSize); + timePlus8Blocks = measureKangarooTwelve(calibration, i+8*chunkSize); + timePlus84Blocks = measureKangarooTwelve(calibration, i+84*chunkSize); + } + printf("%8d bytes: %9d cycles, %6.3f cycles/byte\n", i, time, time*1.0/i); + if (displaySlope) { + printf(" +1 block: %9d cycles, %6.3f cycles/byte (slope)\n", timePlus1Block, (timePlus1Block-(double)(time))*1.0/chunkSize/1.0); + printf(" +2 blocks: %9d cycles, %6.3f cycles/byte (slope)\n", timePlus2Blocks, (timePlus2Blocks-(double)(time))*1.0/chunkSize/2.0); + printf(" +4 blocks: %9d cycles, %6.3f cycles/byte (slope)\n", timePlus4Blocks, (timePlus4Blocks-(double)(time))*1.0/chunkSize/4.0); + printf(" +8 blocks: %9d cycles, %6.3f cycles/byte (slope)\n", timePlus8Blocks, (timePlus8Blocks-(double)(time))*1.0/chunkSize/8.0); + printf(" +84 blocks: %9d cycles, %6.3f cycles/byte (slope)\n", timePlus84Blocks, (timePlus84Blocks-(double)(time))*1.0/chunkSize/84.0); + displaySlope = 0; + } + } + for(halfTones=12*12; halfTones<=19*12; halfTones+=4) { + double I = chunkSize + pow(2.0, halfTones/12.0); + unsigned int i = (unsigned int)floor(I+0.5); + uint_32t time; + time = measureKangarooTwelve(calibration, i); + printf("%8d bytes: %9d cycles, %6.3f cycles/byte\n", i, time, time*1.0/i); + } + printf("\n\n"); +} + +void testKangarooTwelvePerformance() +{ + printKangarooTwelvePerformanceHeader(); + testKangarooTwelvePerformanceOne(); +} +void testPerformance() +{ + testKangarooTwelvePerformance(); +} + +void bubbleSort(double *list, unsigned int size) +{ + unsigned int n = size; + + do { + unsigned int newn = 0; + unsigned int i; + + for(i=1; i list[i]) { + double temp = list[i-1]; + list[i-1] = list[i]; + list[i] = temp; + newn = i; + } + } + n = newn; + } + while(n > 0); +} + +double med4(double x0, double x1, double x2, double x3) +{ + double list[4]; + list[0] = x0; + list[1] = x1; + list[2] = x2; + list[3] = x3; + bubbleSort(list, 4); + if (fabs(list[2]-list[0]) < fabs(list[3]-list[1])) + return 0.25*list[0]+0.375*list[1]+0.25*list[2]+0.125*list[3]; + else + return 0.125*list[0]+0.25*list[1]+0.375*list[2]+0.25*list[3]; +} + +void displayMeasurements1101001000(uint_32t *measurements, uint_32t *laneCounts, unsigned int numberOfColumns, unsigned int laneLengthInBytes) +{ + double cpb[4]; + unsigned int i; + + for(i=0; i +Reply-To: hash-forum at nist.gov +To: Multiple recipients of list + +Sorry for the earlier empty email. I pushed send by mistake while starting my message. + +Yes, it's a real shame that C doesn't have a standard way to do this. Below is some code that you are free to copy if you wish I have used variants of this function for years, all the way back to AES days, and the code is entirely mine, so I hereby release it to the public domain. If you keep reading below, I also give some concrete suggestions on how to use it. + +This code works on x86 family CPUs (32-big and 64-bit), under MSVC, gcc, and BorlandC, including older compiler versions where the __rdtsc() function is not defined. It also checks for ANSI compiles (i.e., -ansi using gcc, /Za using MSVC, and -A using Borland) and disables the call, to avoid compile-time warnings/errors. The function HiResTime() currently returns only 32 bits, mostly for historical reasons. However, that's enough to do most timing measurements, and you could easily enhance it to return 64 bits if desired. I normally compile with multiple compilers -- e.g., three versions of MSVC (v4.2, v6.0 and v9.0), at least two versions of gcc, plus Borland -- and take performance measurements on all of them. + +[…] + +*/ + +/************** Timing routine (for performance measurements) ***********/ +/* By Doug Whiting */ +/* unfortunately, this is generally assembly code and not very portable */ +#if defined(_M_IX86) || defined(__i386) || defined(_i386) || defined(__i386__) || defined(i386) || \ + defined(_X86_) || defined(__x86_64__) || defined(_M_X64) || defined(__x86_64) +#define _Is_X86_ 1 +#endif + +#if defined(_Is_X86_) && (!defined(__STRICT_ANSI__)) && (defined(__GNUC__) || !defined(__STDC__)) && \ + (defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW_H) || defined(__GNUC__)) +#define HI_RES_CLK_OK 1 /* it's ok to use RDTSC opcode */ + +#if defined(_MSC_VER) /* && defined(_M_X64) */ +#include +#pragma intrinsic(__rdtsc) /* use MSVC rdtsc call where defined */ +#endif + +#endif + +typedef unsigned int uint_32t; + +static uint_32t HiResTime(void) /* return the current value of time stamp counter */ + { +#if defined(HI_RES_CLK_OK) + uint_32t x[2]; +#if defined(__BORLANDC__) +#define COMPILER_ID "BCC" + __emit__(0x0F,0x31); /* RDTSC instruction */ + _asm { mov x[0],eax }; +#elif defined(_MSC_VER) +#define COMPILER_ID "MSC" +#if defined(_MSC_VER) /* && defined(_M_X64) */ + x[0] = (uint_32t) __rdtsc(); +#else + _asm { _emit 0fh }; _asm { _emit 031h }; + _asm { mov x[0],eax }; +#endif +#elif defined(__MINGW_H) || defined(__GNUC__) +#define COMPILER_ID "GCC" + asm volatile("rdtsc" : "=a"(x[0]), "=d"(x[1])); +#else +#error "HI_RES_CLK_OK -- but no assembler code for this platform (?)" +#endif + return x[0]; +#else + /* avoid annoying MSVC 9.0 compiler warning #4720 in ANSI mode! */ +#if (!defined(_MSC_VER)) || (!defined(__STDC__)) || (_MSC_VER < 1300) + FatalError("No support for RDTSC on this CPU platform\n"); +#endif + return 0; +#endif /* defined(HI_RES_CLK_OK) */ + } + +#define TIMER_SAMPLE_CNT (100) + +static uint_32t calibrate() +{ + uint_32t dtMin = 0xFFFFFFFF; /* big number to start */ + uint_32t t0,t1,i; + + for (i=0;i < TIMER_SAMPLE_CNT;i++) /* calibrate the overhead for measuring time */ + { + t0 = HiResTime(); + t1 = HiResTime(); + if (dtMin > t1-t0) /* keep only the minimum time */ + dtMin = t1-t0; + } + return dtMin; +} + +#define measureTimingDeclare \ + uint_32t tMin = 0xFFFFFFFF; \ + uint_32t t0,t1,i; + +#define measureTimingBeginDeclared \ + for (i=0;i < TIMER_SAMPLE_CNT;i++) \ + { \ + t0 = HiResTime(); + +#define measureTimingBegin \ + uint_32t tMin = 0xFFFFFFFF; \ + uint_32t t0,t1,i; \ + for (i=0;i < TIMER_SAMPLE_CNT;i++) \ + { \ + t0 = HiResTime(); + +#define measureTimingEnd \ + t1 = HiResTime(); \ + if (tMin > t1-t0 - dtMin) \ + tMin = t1-t0 - dtMin; \ + } \ + return tMin; diff --git a/src/plonk/blake2_const/benches/kangarootwelve/README.md b/src/plonk/blake2_const/benches/kangarootwelve/README.md new file mode 100644 index 000000000..c20d4d51b --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/README.md @@ -0,0 +1,4 @@ +This is Rust FFI wrapper around the +[XKCP/K12](https://github.com/XKCP/K12) C implementation, which is +vendored here and statically linked. It's intended for benchmarking +only. This code assumes AVX2 support and isn't suitable for shipping. diff --git a/src/plonk/blake2_const/benches/kangarootwelve/build.rs b/src/plonk/blake2_const/benches/kangarootwelve/build.rs new file mode 100644 index 000000000..1a98aa252 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/build.rs @@ -0,0 +1,45 @@ +use std::env; +use std::path::PathBuf; +use std::process::Command; + +fn target_name() -> &'static str { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + { + if is_x86_feature_detected!("avx512f") { + assert!( + is_x86_feature_detected!("avx512vl"), + "AVX-512F supported but not AVX-512VL. This isn't SkylakeX.", + ); + return "SkylakeX"; + } else if is_x86_feature_detected!("avx2") { + return "Haswell"; + } + } + if std::mem::size_of::() == 8 { + "generic64" + } else if std::mem::size_of::() == 4 { + "generic32" + } else { + panic!("unexpected word size {}", std::mem::size_of::()) + } +} + +fn main() { + // Do local CPU feature detection to determine which version to build. This + // wouldn't be correct if we were building a distributable binary, because + // the features of the target machine wouldn't necessarily be the same as + // the features of the build machine. But this build is just for + // benchmarks, so it's fine. + let target = target_name(); + let manifest_dir: PathBuf = env::var("CARGO_MANIFEST_DIR").unwrap().into(); + let k12_dir = manifest_dir.join("K12"); + let build_dir = k12_dir.join(format!("bin/{}", target)); + let build_status = Command::new("make") + .arg(format!("{}/libk12.a", target)) + .current_dir(&k12_dir) + .status() + .unwrap(); + assert!(build_status.success()); + println!("cargo:rustc-link-search={}", build_dir.to_str().unwrap()); + println!("cargo:rustc-link-lib=static=k12"); +} diff --git a/src/plonk/blake2_const/benches/kangarootwelve/src/lib.rs b/src/plonk/blake2_const/benches/kangarootwelve/src/lib.rs new file mode 100644 index 000000000..acfd0e877 --- /dev/null +++ b/src/plonk/blake2_const/benches/kangarootwelve/src/lib.rs @@ -0,0 +1,55 @@ +pub fn kangarootwelve(input: &[u8]) -> [u8; 32] { + let mut hash = [0u8; 32]; + let ret = unsafe { + KangarooTwelve( + input.as_ptr(), + input.len(), + hash.as_mut_ptr(), + hash.len(), + std::ptr::null(), + 0, + ) + }; + debug_assert_eq!(0, ret, "KangarooTwelve returned an error code"); + hash +} + +extern "C" { + #[doc = " Extendable ouput function KangarooTwelve."] + #[doc = " @param input Pointer to the input message (M)."] + #[doc = " @param inputByteLen The length of the input message in bytes."] + #[doc = " @param output Pointer to the output buffer."] + #[doc = " @param outputByteLen The desired number of output bytes."] + #[doc = " @param customization Pointer to the customization string (C)."] + #[doc = " @param customByteLen The length of the customization string in bytes."] + #[doc = " @return 0 if successful, 1 otherwise."] + fn KangarooTwelve( + input: *const ::std::os::raw::c_uchar, + inputByteLen: usize, + output: *mut ::std::os::raw::c_uchar, + outputByteLen: usize, + customization: *const ::std::os::raw::c_uchar, + customByteLen: usize, + ) -> ::std::os::raw::c_int; +} + +#[cfg(test)] +mod test { + use super::*; + + // from https://eprint.iacr.org/2016/770.pdf + #[test] + fn test_vectors() { + let empty_expected = "1ac2d450fc3b4205d19da7bfca1b37513c0803577ac7167f06fe2ce1f0ef39e5"; + let empty_output = kangarootwelve(&[]); + assert_eq!(empty_expected, hex::encode(&empty_output)); + + let seventeen_expected = "6bf75fa2239198db4772e36478f8e19b0f371205f6a9a93a273f51df37122888"; + let mut input = Vec::new(); + for i in 0..17u8 { + input.push(i); + } + let seventeen_output = kangarootwelve(&input); + assert_eq!(seventeen_expected, hex::encode(&seventeen_output)); + } +} diff --git a/src/plonk/blake2_const/blake2_bin/Cargo.toml b/src/plonk/blake2_const/blake2_bin/Cargo.toml new file mode 100644 index 000000000..a751d50ea --- /dev/null +++ b/src/plonk/blake2_const/blake2_bin/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "blake2_bin" +version = "0.5.9" +authors = ["Jack O'Connor"] +description = "a command line implementation of BLAKE2b/s/bp/sp and all their parameters" +license = "MIT" +repository = "https://github.com/oconnor663/blake2_simd/tree/master/blake2_bin" +edition = "2018" + +[[bin]] +name = "blake2" +path = "src/main.rs" + +[dependencies] +blake2b_simd = { path = "../blake2b", version = "0.5" } +blake2s_simd = { path = "../blake2s", version = "0.5" } +failure = "0.1.5" +hex = "0.4.0" +memmap = "0.7.0" +structopt = "0.3.2" + +[dev-dependencies] +assert_cmd = "0.11.1" +duct = "0.13.0" +tempfile = "3.1.0" diff --git a/src/plonk/blake2_const/blake2_bin/src/main.rs b/src/plonk/blake2_const/blake2_bin/src/main.rs new file mode 100644 index 000000000..2000321ba --- /dev/null +++ b/src/plonk/blake2_const/blake2_bin/src/main.rs @@ -0,0 +1,390 @@ +use failure::{bail, Error}; +use std::fs::File; +use std::io; +use std::io::prelude::*; +use std::isize; +use std::path::{Path, PathBuf}; +use std::process::exit; +use structopt::StructOpt; + +#[derive(Debug, StructOpt)] +struct Opt { + /// Any number of filepaths, or empty for standard input. + inputs: Vec, + + #[structopt(long = "mmap")] + /// Read input with memory mapping. + mmap: bool, + + #[structopt(short = "b")] + /// Use the BLAKE2b hash function (default). + big: bool, + + #[structopt(short = "s")] + /// Use the BLAKE2s hash function. + small: bool, + + #[structopt(short = "p")] + /// Use the parallel variant, BLAKE2bp or BLAKE2sp. + parallel: bool, + + #[structopt(long = "length")] + /// Set the length of the output in bytes. + length: Option, + + #[structopt(long = "key")] + /// Set the key parameter with a hex string. + key: Option, + + #[structopt(long = "salt")] + /// Set the salt parameter with a hex string. + salt: Option, + + #[structopt(long = "personal")] + /// Set the personalization parameter with a hex string. + personal: Option, + + #[structopt(long = "fanout")] + /// Set the fanout parameter. + fanout: Option, + + #[structopt(long = "max-depth")] + /// Set the max depth parameter. + max_depth: Option, + + #[structopt(long = "max-leaf-length")] + /// Set the max leaf length parameter. + max_leaf_length: Option, + + #[structopt(long = "node-offset")] + /// Set the node offset parameter. + node_offset: Option, + + #[structopt(long = "node-depth")] + /// Set the node depth parameter. + node_depth: Option, + + #[structopt(long = "inner-hash-length")] + /// Set the inner hash length parameter. + inner_hash_length: Option, + + #[structopt(long = "last-node")] + /// Set the last node flag. + last_node: bool, +} + +enum Params { + Blake2b(blake2b_simd::Params), + Blake2bp(blake2b_simd::blake2bp::Params), + Blake2s(blake2s_simd::Params), + Blake2sp(blake2s_simd::blake2sp::Params), +} + +impl Params { + fn to_state(&self) -> State { + match self { + Params::Blake2b(p) => State::Blake2b(p.to_state()), + Params::Blake2s(p) => State::Blake2s(p.to_state()), + Params::Blake2bp(p) => State::Blake2bp(p.to_state()), + Params::Blake2sp(p) => State::Blake2sp(p.to_state()), + } + } +} + +#[derive(Clone)] +enum State { + Blake2b(blake2b_simd::State), + Blake2bp(blake2b_simd::blake2bp::State), + Blake2s(blake2s_simd::State), + Blake2sp(blake2s_simd::blake2sp::State), +} + +impl State { + fn update(&mut self, input: &[u8]) { + match self { + State::Blake2b(s) => { + s.update(input); + } + State::Blake2s(s) => { + s.update(input); + } + State::Blake2bp(s) => { + s.update(input); + } + State::Blake2sp(s) => { + s.update(input); + } + } + } + + fn finalize(&mut self) -> String { + match self { + State::Blake2b(s) => s.finalize().to_hex().to_string(), + State::Blake2s(s) => s.finalize().to_hex().to_string(), + State::Blake2bp(s) => s.finalize().to_hex().to_string(), + State::Blake2sp(s) => s.finalize().to_hex().to_string(), + } + } +} + +fn mmap_file(file: &File) -> io::Result { + let metadata = file.metadata()?; + let len = metadata.len(); + // See https://github.com/danburkert/memmap-rs/issues/69. + if len > isize::MAX as u64 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "mmap length would overflow isize", + )); + } + // Note that this will currently fail if the file is empty. We treat the --mmap flag as + // mandatory and don't try to recover. See https://github.com/danburkert/memmap-rs/issues/72 + // for a discussion about whether this case should succeed in the future. + unsafe { memmap::MmapOptions::new().len(len as usize).map(file) } +} + +fn read_write_all(mut reader: R, state: &mut State) -> io::Result<()> { + // Why not just use std::io::copy? Because it uses an 8192 byte buffer, and + // using a larger buffer is measurably faster. + // https://github.com/rust-lang/rust/commit/8128817119e479b0610685e3fc7a6ff21cde5abc + // describes how Rust picked its default buffer size. + // + // How did we pick 32768 (2^15) specifically? It's just what coreutils + // uses. When I benchmark lots of different sizes, a 4 MiB heap buffer + // actually seems to be the best size, possibly 8% faster than this. Though + // repeatedly hashing a gigabyte of random data might not reflect real + // world usage, who knows. At the end of the day, when we really care about + // speed, we're going to use --mmap and skip buffering entirely. The main + // goal of this program is to compare the underlying hash implementations + // (which is to say OpenSSL, which coreutils links against), and to get an + // honest comparison we might as well use the same buffer size. + let mut buf = [0; 32768]; + loop { + match reader.read(&mut buf) { + Ok(0) => return Ok(()), + Ok(n) => state.update(&buf[..n]), + Err(e) => { + if e.kind() != io::ErrorKind::Interrupted { + return Err(e); + } + } + } + } +} + +fn make_params(opt: &Opt) -> Result { + if opt.big && opt.small { + bail!("-b and -s can't be used together"); + } + let mut params = if opt.small { + if opt.parallel { + Params::Blake2sp(blake2s_simd::blake2sp::Params::new()) + } else { + Params::Blake2s(blake2s_simd::Params::new()) + } + } else { + if opt.parallel { + Params::Blake2bp(blake2b_simd::blake2bp::Params::new()) + } else { + Params::Blake2b(blake2b_simd::Params::new()) + } + }; + if let Some(length) = opt.length { + match &mut params { + Params::Blake2b(p) => { + p.hash_length(length); + } + Params::Blake2s(p) => { + p.hash_length(length); + } + Params::Blake2bp(p) => { + p.hash_length(length); + } + Params::Blake2sp(p) => { + p.hash_length(length); + } + } + } + if let Some(ref key) = opt.key { + let key_bytes = hex::decode(key)?; + match &mut params { + Params::Blake2b(p) => { + p.key(&key_bytes); + } + Params::Blake2s(p) => { + p.key(&key_bytes); + } + Params::Blake2bp(p) => { + p.key(&key_bytes); + } + Params::Blake2sp(p) => { + p.key(&key_bytes); + } + } + } + if let Some(ref salt) = opt.salt { + let salt_bytes = hex::decode(salt)?; + match &mut params { + Params::Blake2b(p) => { + p.salt(&salt_bytes); + } + Params::Blake2s(p) => { + p.salt(&salt_bytes); + } + _ => bail!("--salt not supported"), + } + } + if let Some(ref personal) = opt.personal { + let personal_bytes = hex::decode(personal)?; + match &mut params { + Params::Blake2b(p) => { + p.personal(&personal_bytes); + } + Params::Blake2s(p) => { + p.personal(&personal_bytes); + } + _ => bail!("--personal not supported"), + } + } + if let Some(fanout) = opt.fanout { + match &mut params { + Params::Blake2b(p) => { + p.fanout(fanout); + } + Params::Blake2s(p) => { + p.fanout(fanout); + } + _ => bail!("--fanout not supported"), + } + } + if let Some(max_depth) = opt.max_depth { + match &mut params { + Params::Blake2b(p) => { + p.max_depth(max_depth); + } + Params::Blake2s(p) => { + p.max_depth(max_depth); + } + _ => bail!("--max-depth not supported"), + } + } + if let Some(max_leaf_length) = opt.max_leaf_length { + match &mut params { + Params::Blake2b(p) => { + p.max_leaf_length(max_leaf_length); + } + Params::Blake2s(p) => { + p.max_leaf_length(max_leaf_length); + } + _ => bail!("--max-leaf-length not supported"), + } + } + if let Some(node_offset) = opt.node_offset { + match &mut params { + Params::Blake2b(p) => { + p.node_offset(node_offset); + } + Params::Blake2s(p) => { + p.node_offset(node_offset); + } + _ => bail!("--node-offset not supported"), + } + } + if let Some(node_depth) = opt.node_depth { + match &mut params { + Params::Blake2b(p) => { + p.node_depth(node_depth); + } + Params::Blake2s(p) => { + p.node_depth(node_depth); + } + _ => bail!("--node-depth not supported"), + } + } + if let Some(inner_hash_length) = opt.inner_hash_length { + match &mut params { + Params::Blake2b(p) => { + p.inner_hash_length(inner_hash_length); + } + Params::Blake2s(p) => { + p.inner_hash_length(inner_hash_length); + } + _ => bail!("--inner-hash-length not supported"), + } + } + if opt.last_node { + match &mut params { + Params::Blake2b(p) => { + p.last_node(true); + } + Params::Blake2s(p) => { + p.last_node(true); + } + _ => bail!("--last-node not supported"), + } + } + Ok(params) +} + +fn hash_file(opt: &Opt, params: &Params, path: &Path) -> Result { + let mut state = params.to_state(); + let mut file = File::open(path)?; + if opt.mmap { + let map = mmap_file(&file)?; + state.update(&map); + } else { + read_write_all(&mut file, &mut state)?; + } + Ok(state.finalize()) +} + +fn hash_stdin(opt: &Opt, params: &Params) -> Result { + if opt.mmap { + bail!("--mmap not supported for stdin"); + } + let mut state = params.to_state(); + read_write_all(std::io::stdin().lock(), &mut state)?; + Ok(state.finalize()) +} + +fn main() { + let opt = Opt::from_args(); + + let params = match make_params(&opt) { + Ok(params) => params, + Err(e) => { + eprintln!("blake2: {}", e); + exit(1); + } + }; + + let mut failed = false; + if opt.inputs.is_empty() { + match hash_stdin(&opt, ¶ms) { + Ok(hash) => println!("{}", hash), + Err(e) => { + eprintln!("blake2: stdin: {}", e); + failed = true; + } + } + } else { + for input in &opt.inputs { + match hash_file(&opt, ¶ms, input) { + Ok(hash) => { + if opt.inputs.len() > 1 { + println!("{} {}", hash, input.to_string_lossy()); + } else { + println!("{}", hash); + } + } + Err(e) => { + eprintln!("blake2: {}: {}", input.to_string_lossy(), e); + failed = true; + } + } + } + } + if failed { + exit(1); + } +} diff --git a/src/plonk/blake2_const/blake2_bin/tests/test.rs b/src/plonk/blake2_const/blake2_bin/tests/test.rs new file mode 100644 index 000000000..035274c7c --- /dev/null +++ b/src/plonk/blake2_const/blake2_bin/tests/test.rs @@ -0,0 +1,166 @@ +use duct::cmd; +use std::io::prelude::*; +use std::path::PathBuf; +use tempfile::NamedTempFile; + +pub fn blake2_exe() -> PathBuf { + assert_cmd::cargo::cargo_bin("blake2") +} + +#[test] +fn test_stdin() { + let output = cmd!(blake2_exe(), "--length=16") + .stdin_bytes("abcdef") + .read() + .expect("blake2 failed"); + assert_eq!("2465e7ee63a17b4b307c7792c432aef6", output); +} + +#[test] +fn test_input_file() { + let mut file = NamedTempFile::new().unwrap(); + file.write_all("abcdef".as_bytes()).unwrap(); + file.flush().unwrap(); + let output = cmd!(blake2_exe(), "--length=16", file.path()) + .read() + .expect("blake2 failed"); + assert_eq!("2465e7ee63a17b4b307c7792c432aef6", output); +} + +#[test] +fn test_input_file_mmap() { + let mut file = NamedTempFile::new().unwrap(); + file.write_all("abcdef".as_bytes()).unwrap(); + file.flush().unwrap(); + let output = cmd!(blake2_exe(), "--length=16", "--mmap", file.path()) + .read() + .expect("blake2 failed"); + assert_eq!("2465e7ee63a17b4b307c7792c432aef6", output); +} + +#[test] +fn test_blake2bp() { + // From https://raw.githubusercontent.com/BLAKE2/BLAKE2/master/testvectors/blake2-kat.json. + let vectors: &[(&[u8], &str)] = &[ + ( + b"", + "b5ef811a8038f70b628fa8b294daae7492b1ebe343a80eaabbf1f6ae664dd67b\ + 9d90b0120791eab81dc96985f28849f6a305186a85501b405114bfa678df9380", + ), + ( + b"\x00", + "a139280e72757b723e6473d5be59f36e9d50fc5cd7d4585cbc09804895a36c52\ + 1242fb2789f85cb9e35491f31d4a6952f9d8e097aef94fa1ca0b12525721f03d", + ), + ( + b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\ + \x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\ + \x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\ + \x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\ + \x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\ + \x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\ + \x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\ + \x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\ + \x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\ + \x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\ + \xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\ + \xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\ + \xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\ + \xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\ + \xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\ + \xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe", + "3f35c45d24fcfb4acca651076c08000e279ebbff37a1333ce19fd577202dbd24\ + b58c514e36dd9ba64af4d78eea4e2dd13bc18d798887dd971376bcae0087e17e", + ), + ]; + + for &(input, expected) in vectors { + let mut file = NamedTempFile::new().unwrap(); + file.write_all(input).unwrap(); + file.flush().unwrap(); + + let output = cmd!(blake2_exe(), "-bp", file.path()) + .read() + .expect("blake2 failed"); + assert_eq!(expected, output); + } +} + +#[test] +fn test_last_node_flag() { + let output = cmd!(blake2_exe(), "--length=16", "--last-node") + .stdin_bytes("abcdef") + .read() + .expect("blake2 failed"); + assert_eq!("d788eeea837a3d10b1f8c097059f815a", output); +} + +// This is the exact same result as test_all_parameters in the library tests. +#[test] +fn test_all_parameters_blake2b() { + let flags = [ + "-b", + "--length=18", + "--key=626172", + "--salt=62617a62617a62617a62617a62617a62", + "--personal=62696e672062696e672062696e672062", + "--fanout=2", + "--max-depth=3", + "--max-leaf-length=67438087", + "--node-offset=579005069656919567", + "--node-depth=16", + "--inner-hash-length=17", + "--last-node", + ]; + let output = cmd(blake2_exe(), flags.iter()) + .stdin_bytes("foo") + .read() + .expect("blake2 failed"); + assert_eq!("ec0f59cb65f92e7fcca1280ba859a6925ded", output); +} + +// This is the exact same result as test_all_parameters in the library tests. +#[test] +fn test_all_parameters_blake2s() { + let flags = [ + "-s", + "--length=18", + "--key=626172", + "--salt=62617a62617a6261", + "--personal=62696e672062696e", + "--fanout=2", + "--max-depth=3", + "--max-leaf-length=67438087", + "--node-offset=8834916224013", + "--node-depth=16", + "--inner-hash-length=17", + "--last-node", + ]; + let output = cmd(blake2_exe(), flags.iter()) + .stdin_bytes("foo") + .read() + .expect("blake2 failed"); + assert_eq!("62361e5392ab0eb7dd27e48a6809ee82dc57", output); +} + +// This is the exact same result as test_all_parameters_blake2bp in the library tests. +#[test] +fn test_all_parameters_blake2bp() { + let flags = ["-bp", "--length=18", "--key=626172"]; + let output = cmd(blake2_exe(), flags.iter()) + .stdin_bytes("foo") + .read() + .expect("blake2 failed"); + assert_eq!("8c54e888a8a01c63da6585c058fe54ea81df", output); +} + +// This is the exact same result as test_all_parameters_blake2sp in the library tests. +#[test] +fn test_all_parameters_blake2sp() { + let flags = ["-sp", "--length=18", "--key=626172"]; + let output = cmd(blake2_exe(), flags.iter()) + .stdin_bytes("foo") + .read() + .expect("blake2 failed"); + assert_eq!("947d4c671e2794f5e1a57daeca97bb46ed66", output); +} diff --git a/src/plonk/blake2_const/blake2b/Cargo.toml b/src/plonk/blake2_const/blake2b/Cargo.toml new file mode 100644 index 000000000..1970f72d7 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "blake2b_simd" +version = "0.5.9" +authors = ["Jack O'Connor"] +description = "a pure Rust BLAKE2b implementation with dynamic SIMD" +license = "MIT" +repository = "https://github.com/oconnor663/blake2_simd" +documentation = "https://docs.rs/blake2b_simd" +readme = "README.md" +edition = "2018" + +[features] +default = ["std"] +std = [] + +[dependencies] +arrayref = "0.3.5" +arrayvec = { version = "0.5.0", default-features = false } +constant_time_eq = "0.1.3" diff --git a/src/plonk/blake2_const/blake2b/README.md b/src/plonk/blake2_const/blake2b/README.md new file mode 100644 index 000000000..54caef739 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/README.md @@ -0,0 +1,42 @@ +# blake2b_simd [![GitHub](https://img.shields.io/github/tag/oconnor663/blake2_simd.svg?label=GitHub)](https://github.com/oconnor663/blake2_simd) [![crates.io](https://img.shields.io/crates/v/blake2b_simd.svg)](https://crates.io/crates/blake2b_simd) [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) + +An implementation of the BLAKE2b and BLAKE2bp hash functions. See also +[`blake2s_simd`](../blake2s). + +This crate includes: + +- 100% stable Rust. +- SIMD implementations based on Samuel Neves' [`blake2-avx2`](https://github.com/sneves/blake2-avx2). + These are very fast. For benchmarks, see [the Performance section of the + README](https://github.com/oconnor663/blake2_simd#performance). +- Portable, safe implementations for other platforms. +- Dynamic CPU feature detection. Binaries include multiple implementations by default and + choose the fastest one the processor supports at runtime. +- All the features from the [the BLAKE2 spec](https://blake2.net/blake2.pdf), like adjustable + length, keying, and associated data for tree hashing. +- `no_std` support. The `std` Cargo feature is on by default, for CPU feature detection and + for implementing `std::io::Write`. +- Support for computing multiple BLAKE2b hashes in parallel, matching the efficiency of + BLAKE2bp. See the [`many`](many/index.html) module. + +# Example + +``` +use blake2b_simd::{blake2b, Params}; + +let expected = "ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6d\ + c1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"; +let hash = blake2b(b"foo"); +assert_eq!(expected, &hash.to_hex()); + +let hash = Params::new() + .hash_length(16) + .key(b"The Magic Words are Squeamish Ossifrage") + .personal(b"L. P. Waterhouse") + .to_state() + .update(b"foo") + .update(b"bar") + .update(b"baz") + .finalize(); +assert_eq!("ee8ff4e9be887297cf79348dc35dab56", &hash.to_hex()); +``` diff --git a/src/plonk/blake2_const/blake2b/src/avx2.rs b/src/plonk/blake2_const/blake2b/src/avx2.rs new file mode 100644 index 000000000..268dd82d3 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/avx2.rs @@ -0,0 +1,928 @@ +#[cfg(target_arch = "x86")] +use core::arch::x86::*; +#[cfg(target_arch = "x86_64")] +use core::arch::x86_64::*; + +use crate::guts::{ + assemble_count, count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, + Job, LastNode, Stride, +}; +use crate::{Count, Word, BLOCKBYTES, IV, SIGMA}; +use arrayref::{array_refs, mut_array_refs}; +use core::cmp; +use core::mem; + +pub const DEGREE: usize = 4; + +#[inline(always)] +unsafe fn loadu(src: *const [Word; DEGREE]) -> __m256i { + // This is an unaligned load, so the pointer cast is allowed. + _mm256_loadu_si256(src as *const __m256i) +} + +#[inline(always)] +unsafe fn storeu(src: __m256i, dest: *mut [Word; DEGREE]) { + // This is an unaligned store, so the pointer cast is allowed. + _mm256_storeu_si256(dest as *mut __m256i, src) +} + +#[inline(always)] +unsafe fn loadu_128(mem_addr: &[u8; 16]) -> __m128i { + _mm_loadu_si128(mem_addr.as_ptr() as *const __m128i) +} + +#[inline(always)] +unsafe fn add(a: __m256i, b: __m256i) -> __m256i { + _mm256_add_epi64(a, b) +} + +#[inline(always)] +unsafe fn eq(a: __m256i, b: __m256i) -> __m256i { + _mm256_cmpeq_epi64(a, b) +} + +#[inline(always)] +unsafe fn and(a: __m256i, b: __m256i) -> __m256i { + _mm256_and_si256(a, b) +} + +#[inline(always)] +unsafe fn negate_and(a: __m256i, b: __m256i) -> __m256i { + // Note that "and not" implies the reverse of the actual arg order. + _mm256_andnot_si256(a, b) +} + +#[inline(always)] +unsafe fn xor(a: __m256i, b: __m256i) -> __m256i { + _mm256_xor_si256(a, b) +} + +#[inline(always)] +unsafe fn set1(x: u64) -> __m256i { + _mm256_set1_epi64x(x as i64) +} + +#[inline(always)] +unsafe fn set4(a: u64, b: u64, c: u64, d: u64) -> __m256i { + _mm256_setr_epi64x(a as i64, b as i64, c as i64, d as i64) +} + +// Adapted from https://github.com/rust-lang-nursery/stdsimd/pull/479. +macro_rules! _MM_SHUFFLE { + ($z:expr, $y:expr, $x:expr, $w:expr) => { + ($z << 6) | ($y << 4) | ($x << 2) | $w + }; +} + +#[inline(always)] +unsafe fn rot32(x: __m256i) -> __m256i { + _mm256_shuffle_epi32(x, _MM_SHUFFLE!(2, 3, 0, 1)) +} + +#[inline(always)] +unsafe fn rot24(x: __m256i) -> __m256i { + let rotate24 = _mm256_setr_epi8( + 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, + 14, 15, 8, 9, 10, + ); + _mm256_shuffle_epi8(x, rotate24) +} + +#[inline(always)] +unsafe fn rot16(x: __m256i) -> __m256i { + let rotate16 = _mm256_setr_epi8( + 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, + 13, 14, 15, 8, 9, + ); + _mm256_shuffle_epi8(x, rotate16) +} + +#[inline(always)] +unsafe fn rot63(x: __m256i) -> __m256i { + _mm256_or_si256(_mm256_srli_epi64(x, 63), add(x, x)) +} + +#[inline(always)] +unsafe fn g1(a: &mut __m256i, b: &mut __m256i, c: &mut __m256i, d: &mut __m256i, m: &mut __m256i) { + *a = add(*a, *m); + *a = add(*a, *b); + *d = xor(*d, *a); + *d = rot32(*d); + *c = add(*c, *d); + *b = xor(*b, *c); + *b = rot24(*b); +} + +#[inline(always)] +unsafe fn g2(a: &mut __m256i, b: &mut __m256i, c: &mut __m256i, d: &mut __m256i, m: &mut __m256i) { + *a = add(*a, *m); + *a = add(*a, *b); + *d = xor(*d, *a); + *d = rot16(*d); + *c = add(*c, *d); + *b = xor(*b, *c); + *b = rot63(*b); +} + +// Note the optimization here of leaving b as the unrotated row, rather than a. +// All the message loads below are adjusted to compensate for this. See +// discussion at https://github.com/sneves/blake2-avx2/pull/4 +#[inline(always)] +unsafe fn diagonalize(a: &mut __m256i, _b: &mut __m256i, c: &mut __m256i, d: &mut __m256i) { + *a = _mm256_permute4x64_epi64(*a, _MM_SHUFFLE!(2, 1, 0, 3)); + *d = _mm256_permute4x64_epi64(*d, _MM_SHUFFLE!(1, 0, 3, 2)); + *c = _mm256_permute4x64_epi64(*c, _MM_SHUFFLE!(0, 3, 2, 1)); +} + +#[inline(always)] +unsafe fn undiagonalize(a: &mut __m256i, _b: &mut __m256i, c: &mut __m256i, d: &mut __m256i) { + *a = _mm256_permute4x64_epi64(*a, _MM_SHUFFLE!(0, 3, 2, 1)); + *d = _mm256_permute4x64_epi64(*d, _MM_SHUFFLE!(1, 0, 3, 2)); + *c = _mm256_permute4x64_epi64(*c, _MM_SHUFFLE!(2, 1, 0, 3)); +} + +#[inline(always)] +unsafe fn compress_block( + block: &[u8; BLOCKBYTES], + words: &mut [Word; 8], + count: Count, + last_block: Word, + last_node: Word, +) { + let (words_low, words_high) = mut_array_refs!(words, DEGREE, DEGREE); + let (iv_low, iv_high) = array_refs!(&IV, DEGREE, DEGREE); + let mut a = loadu(words_low); + let mut b = loadu(words_high); + let mut c = loadu(iv_low); + let flags = set4(count_low(count), count_high(count), last_block, last_node); + let mut d = xor(loadu(iv_high), flags); + + let msg_chunks = array_refs!(block, 16, 16, 16, 16, 16, 16, 16, 16); + let m0 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.0)); + let m1 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.1)); + let m2 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.2)); + let m3 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.3)); + let m4 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.4)); + let m5 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.5)); + let m6 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.6)); + let m7 = _mm256_broadcastsi128_si256(loadu_128(msg_chunks.7)); + + let iv0 = a; + let iv1 = b; + let mut t0; + let mut t1; + let mut b0; + + // round 1 + t0 = _mm256_unpacklo_epi64(m0, m1); + t1 = _mm256_unpacklo_epi64(m2, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m0, m1); + t1 = _mm256_unpackhi_epi64(m2, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpacklo_epi64(m7, m4); + t1 = _mm256_unpacklo_epi64(m5, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m7, m4); + t1 = _mm256_unpackhi_epi64(m5, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 2 + t0 = _mm256_unpacklo_epi64(m7, m2); + t1 = _mm256_unpackhi_epi64(m4, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m5, m4); + t1 = _mm256_alignr_epi8(m3, m7, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpackhi_epi64(m2, m0); + t1 = _mm256_blend_epi32(m5, m0, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_alignr_epi8(m6, m1, 8); + t1 = _mm256_blend_epi32(m3, m1, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 3 + t0 = _mm256_alignr_epi8(m6, m5, 8); + t1 = _mm256_unpackhi_epi64(m2, m7); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m4, m0); + t1 = _mm256_blend_epi32(m6, m1, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_alignr_epi8(m5, m4, 8); + t1 = _mm256_unpackhi_epi64(m1, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m2, m7); + t1 = _mm256_blend_epi32(m0, m3, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 4 + t0 = _mm256_unpackhi_epi64(m3, m1); + t1 = _mm256_unpackhi_epi64(m6, m5); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m4, m0); + t1 = _mm256_unpacklo_epi64(m6, m7); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_alignr_epi8(m1, m7, 8); + t1 = _mm256_shuffle_epi32(m2, _MM_SHUFFLE!(1, 0, 3, 2)); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m4, m3); + t1 = _mm256_unpacklo_epi64(m5, m0); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 5 + t0 = _mm256_unpackhi_epi64(m4, m2); + t1 = _mm256_unpacklo_epi64(m1, m5); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_blend_epi32(m3, m0, 0x33); + t1 = _mm256_blend_epi32(m7, m2, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_alignr_epi8(m7, m1, 8); + t1 = _mm256_alignr_epi8(m3, m5, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m6, m0); + t1 = _mm256_unpacklo_epi64(m6, m4); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 6 + t0 = _mm256_unpacklo_epi64(m1, m3); + t1 = _mm256_unpacklo_epi64(m0, m4); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m6, m5); + t1 = _mm256_unpackhi_epi64(m5, m1); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_alignr_epi8(m2, m0, 8); + t1 = _mm256_unpackhi_epi64(m3, m7); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m4, m6); + t1 = _mm256_alignr_epi8(m7, m2, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 7 + t0 = _mm256_blend_epi32(m0, m6, 0x33); + t1 = _mm256_unpacklo_epi64(m7, m2); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m2, m7); + t1 = _mm256_alignr_epi8(m5, m6, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpacklo_epi64(m4, m0); + t1 = _mm256_blend_epi32(m4, m3, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m5, m3); + t1 = _mm256_shuffle_epi32(m1, _MM_SHUFFLE!(1, 0, 3, 2)); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 8 + t0 = _mm256_unpackhi_epi64(m6, m3); + t1 = _mm256_blend_epi32(m1, m6, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_alignr_epi8(m7, m5, 8); + t1 = _mm256_unpackhi_epi64(m0, m4); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_blend_epi32(m2, m1, 0x33); + t1 = _mm256_alignr_epi8(m4, m7, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m5, m0); + t1 = _mm256_unpacklo_epi64(m2, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 9 + t0 = _mm256_unpacklo_epi64(m3, m7); + t1 = _mm256_alignr_epi8(m0, m5, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m7, m4); + t1 = _mm256_alignr_epi8(m4, m1, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpacklo_epi64(m5, m6); + t1 = _mm256_unpackhi_epi64(m6, m0); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_alignr_epi8(m1, m2, 8); + t1 = _mm256_alignr_epi8(m2, m3, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 10 + t0 = _mm256_unpacklo_epi64(m5, m4); + t1 = _mm256_unpackhi_epi64(m3, m0); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m1, m2); + t1 = _mm256_blend_epi32(m2, m3, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpackhi_epi64(m6, m7); + t1 = _mm256_unpackhi_epi64(m4, m1); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_blend_epi32(m5, m0, 0x33); + t1 = _mm256_unpacklo_epi64(m7, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 11 + t0 = _mm256_unpacklo_epi64(m0, m1); + t1 = _mm256_unpacklo_epi64(m2, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m0, m1); + t1 = _mm256_unpackhi_epi64(m2, m3); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpacklo_epi64(m7, m4); + t1 = _mm256_unpacklo_epi64(m5, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpackhi_epi64(m7, m4); + t1 = _mm256_unpackhi_epi64(m5, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + // round 12 + t0 = _mm256_unpacklo_epi64(m7, m2); + t1 = _mm256_unpackhi_epi64(m4, m6); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_unpacklo_epi64(m5, m4); + t1 = _mm256_alignr_epi8(m3, m7, 8); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + diagonalize(&mut a, &mut b, &mut c, &mut d); + t0 = _mm256_unpackhi_epi64(m2, m0); + t1 = _mm256_blend_epi32(m5, m0, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g1(&mut a, &mut b, &mut c, &mut d, &mut b0); + t0 = _mm256_alignr_epi8(m6, m1, 8); + t1 = _mm256_blend_epi32(m3, m1, 0x33); + b0 = _mm256_blend_epi32(t0, t1, 0xF0); + g2(&mut a, &mut b, &mut c, &mut d, &mut b0); + undiagonalize(&mut a, &mut b, &mut c, &mut d); + + a = xor(a, c); + b = xor(b, d); + a = xor(a, iv0); + b = xor(b, iv1); + + storeu(a, words_low); + storeu(b, words_high); +} + +#[target_feature(enable = "avx2")] +pub unsafe fn compress1_loop( + input: &[u8], + words: &mut [Word; 8], + mut count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, +) { + input_debug_asserts(input, finalize); + + let mut local_words = *words; + + let mut fin_offset = input.len().saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + let mut buf = [0; BLOCKBYTES]; + let (fin_block, fin_len, _) = final_block(input, fin_offset, &mut buf, stride); + let fin_last_block = flag_word(finalize.yes()); + let fin_last_node = flag_word(finalize.yes() && last_node.yes()); + + let mut offset = 0; + loop { + let block; + let count_delta; + let last_block; + let last_node; + if offset == fin_offset { + block = fin_block; + count_delta = fin_len; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + // This unsafe cast avoids bounds checks. There's guaranteed to be + // enough input because `offset < fin_offset`. + block = &*(input.as_ptr().add(offset) as *const [u8; BLOCKBYTES]); + count_delta = BLOCKBYTES; + last_block = flag_word(false); + last_node = flag_word(false); + }; + + count = count.wrapping_add(count_delta as Count); + compress_block(block, &mut local_words, count, last_block, last_node); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + *words = local_words; +} + +// Performance note: Factoring out a G function here doesn't hurt performance, +// unlike in the case of BLAKE2s where it hurts substantially. In fact, on my +// machine, it helps a tiny bit. But the difference it tiny, so I'm going to +// stick to the approach used by https://github.com/sneves/blake2-avx2 +// until/unless I can be sure the (tiny) improvement is consistent across +// different Intel microarchitectures. Smaller code size is nice, but a +// divergence between the BLAKE2b and BLAKE2s implementations is less nice. +#[inline(always)] +unsafe fn round(v: &mut [__m256i; 16], m: &[__m256i; 16], r: usize) { + v[0] = add(v[0], m[SIGMA[r][0] as usize]); + v[1] = add(v[1], m[SIGMA[r][2] as usize]); + v[2] = add(v[2], m[SIGMA[r][4] as usize]); + v[3] = add(v[3], m[SIGMA[r][6] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot32(v[12]); + v[13] = rot32(v[13]); + v[14] = rot32(v[14]); + v[15] = rot32(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot24(v[4]); + v[5] = rot24(v[5]); + v[6] = rot24(v[6]); + v[7] = rot24(v[7]); + v[0] = add(v[0], m[SIGMA[r][1] as usize]); + v[1] = add(v[1], m[SIGMA[r][3] as usize]); + v[2] = add(v[2], m[SIGMA[r][5] as usize]); + v[3] = add(v[3], m[SIGMA[r][7] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[15] = rot16(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot63(v[4]); + v[5] = rot63(v[5]); + v[6] = rot63(v[6]); + v[7] = rot63(v[7]); + + v[0] = add(v[0], m[SIGMA[r][8] as usize]); + v[1] = add(v[1], m[SIGMA[r][10] as usize]); + v[2] = add(v[2], m[SIGMA[r][12] as usize]); + v[3] = add(v[3], m[SIGMA[r][14] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot32(v[15]); + v[12] = rot32(v[12]); + v[13] = rot32(v[13]); + v[14] = rot32(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot24(v[5]); + v[6] = rot24(v[6]); + v[7] = rot24(v[7]); + v[4] = rot24(v[4]); + v[0] = add(v[0], m[SIGMA[r][9] as usize]); + v[1] = add(v[1], m[SIGMA[r][11] as usize]); + v[2] = add(v[2], m[SIGMA[r][13] as usize]); + v[3] = add(v[3], m[SIGMA[r][15] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot16(v[15]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot63(v[5]); + v[6] = rot63(v[6]); + v[7] = rot63(v[7]); + v[4] = rot63(v[4]); +} + +// We'd rather make this a regular function with #[inline(always)], but for +// some reason that blows up compile times by about 10 seconds, at least in +// some cases (BLAKE2b avx2.rs). This macro seems to get the same performance +// result, without the compile time issue. +macro_rules! compress4_transposed { + ( + $h_vecs:expr, + $msg_vecs:expr, + $count_low:expr, + $count_high:expr, + $lastblock:expr, + $lastnode:expr, + ) => { + let h_vecs: &mut [__m256i; 8] = $h_vecs; + let msg_vecs: &[__m256i; 16] = $msg_vecs; + let count_low: __m256i = $count_low; + let count_high: __m256i = $count_high; + let lastblock: __m256i = $lastblock; + let lastnode: __m256i = $lastnode; + + let mut v = [ + h_vecs[0], + h_vecs[1], + h_vecs[2], + h_vecs[3], + h_vecs[4], + h_vecs[5], + h_vecs[6], + h_vecs[7], + set1(IV[0]), + set1(IV[1]), + set1(IV[2]), + set1(IV[3]), + xor(set1(IV[4]), count_low), + xor(set1(IV[5]), count_high), + xor(set1(IV[6]), lastblock), + xor(set1(IV[7]), lastnode), + ]; + + round(&mut v, &msg_vecs, 0); + round(&mut v, &msg_vecs, 1); + round(&mut v, &msg_vecs, 2); + round(&mut v, &msg_vecs, 3); + round(&mut v, &msg_vecs, 4); + round(&mut v, &msg_vecs, 5); + round(&mut v, &msg_vecs, 6); + round(&mut v, &msg_vecs, 7); + round(&mut v, &msg_vecs, 8); + round(&mut v, &msg_vecs, 9); + round(&mut v, &msg_vecs, 10); + round(&mut v, &msg_vecs, 11); + + h_vecs[0] = xor(xor(h_vecs[0], v[0]), v[8]); + h_vecs[1] = xor(xor(h_vecs[1], v[1]), v[9]); + h_vecs[2] = xor(xor(h_vecs[2], v[2]), v[10]); + h_vecs[3] = xor(xor(h_vecs[3], v[3]), v[11]); + h_vecs[4] = xor(xor(h_vecs[4], v[4]), v[12]); + h_vecs[5] = xor(xor(h_vecs[5], v[5]), v[13]); + h_vecs[6] = xor(xor(h_vecs[6], v[6]), v[14]); + h_vecs[7] = xor(xor(h_vecs[7], v[7]), v[15]); + }; +} + +#[inline(always)] +unsafe fn interleave128(a: __m256i, b: __m256i) -> (__m256i, __m256i) { + ( + _mm256_permute2x128_si256(a, b, 0x20), + _mm256_permute2x128_si256(a, b, 0x31), + ) +} + +// There are several ways to do a transposition. We could do it naively, with 8 separate +// _mm256_set_epi64x instructions, referencing each of the 64 words explicitly. Or we could copy +// the vecs into contiguous storage and then use gather instructions. This third approach is to use +// a series of unpack instructions to interleave the vectors. In my benchmarks, interleaving is the +// fastest approach. To test this, run `cargo +nightly bench --bench libtest load_4` in the +// https://github.com/oconnor663/bao_experiments repo. +#[inline(always)] +unsafe fn transpose_vecs( + vec_a: __m256i, + vec_b: __m256i, + vec_c: __m256i, + vec_d: __m256i, +) -> [__m256i; DEGREE] { + // Interleave 64-bit lates. The low unpack is lanes 00/22 and the high is 11/33. + let ab_02 = _mm256_unpacklo_epi64(vec_a, vec_b); + let ab_13 = _mm256_unpackhi_epi64(vec_a, vec_b); + let cd_02 = _mm256_unpacklo_epi64(vec_c, vec_d); + let cd_13 = _mm256_unpackhi_epi64(vec_c, vec_d); + + // Interleave 128-bit lanes. + let (abcd_0, abcd_2) = interleave128(ab_02, cd_02); + let (abcd_1, abcd_3) = interleave128(ab_13, cd_13); + + [abcd_0, abcd_1, abcd_2, abcd_3] +} + +#[inline(always)] +unsafe fn transpose_state_vecs(jobs: &[Job; DEGREE]) -> [__m256i; 8] { + // Load all the state words into transposed vectors, where the first vector + // has the first word of each state, etc. Transposing once at the beginning + // and once at the end is more efficient that repeating it for each block. + let words0 = array_refs!(&jobs[0].words, DEGREE, DEGREE); + let words1 = array_refs!(&jobs[1].words, DEGREE, DEGREE); + let words2 = array_refs!(&jobs[2].words, DEGREE, DEGREE); + let words3 = array_refs!(&jobs[3].words, DEGREE, DEGREE); + let [h0, h1, h2, h3] = transpose_vecs( + loadu(words0.0), + loadu(words1.0), + loadu(words2.0), + loadu(words3.0), + ); + let [h4, h5, h6, h7] = transpose_vecs( + loadu(words0.1), + loadu(words1.1), + loadu(words2.1), + loadu(words3.1), + ); + [h0, h1, h2, h3, h4, h5, h6, h7] +} + +#[inline(always)] +unsafe fn untranspose_state_vecs(h_vecs: &[__m256i; 8], jobs: &mut [Job; DEGREE]) { + // Un-transpose the updated state vectors back into the caller's arrays. + let [job0, job1, job2, job3] = jobs; + let words0 = mut_array_refs!(&mut job0.words, DEGREE, DEGREE); + let words1 = mut_array_refs!(&mut job1.words, DEGREE, DEGREE); + let words2 = mut_array_refs!(&mut job2.words, DEGREE, DEGREE); + let words3 = mut_array_refs!(&mut job3.words, DEGREE, DEGREE); + let out = transpose_vecs(h_vecs[0], h_vecs[1], h_vecs[2], h_vecs[3]); + storeu(out[0], words0.0); + storeu(out[1], words1.0); + storeu(out[2], words2.0); + storeu(out[3], words3.0); + let out = transpose_vecs(h_vecs[4], h_vecs[5], h_vecs[6], h_vecs[7]); + storeu(out[0], words0.1); + storeu(out[1], words1.1); + storeu(out[2], words2.1); + storeu(out[3], words3.1); +} + +#[inline(always)] +unsafe fn transpose_msg_vecs(blocks: [*const [u8; BLOCKBYTES]; DEGREE]) -> [__m256i; 16] { + // These input arrays have no particular alignment, so we use unaligned + // loads to read from them. + let block0 = blocks[0] as *const [Word; DEGREE]; + let block1 = blocks[1] as *const [Word; DEGREE]; + let block2 = blocks[2] as *const [Word; DEGREE]; + let block3 = blocks[3] as *const [Word; DEGREE]; + let [m0, m1, m2, m3] = transpose_vecs( + loadu(block0.add(0)), + loadu(block1.add(0)), + loadu(block2.add(0)), + loadu(block3.add(0)), + ); + let [m4, m5, m6, m7] = transpose_vecs( + loadu(block0.add(1)), + loadu(block1.add(1)), + loadu(block2.add(1)), + loadu(block3.add(1)), + ); + let [m8, m9, m10, m11] = transpose_vecs( + loadu(block0.add(2)), + loadu(block1.add(2)), + loadu(block2.add(2)), + loadu(block3.add(2)), + ); + let [m12, m13, m14, m15] = transpose_vecs( + loadu(block0.add(3)), + loadu(block1.add(3)), + loadu(block2.add(3)), + loadu(block3.add(3)), + ); + [ + m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, + ] +} + +#[inline(always)] +unsafe fn load_counts(jobs: &[Job; DEGREE]) -> (__m256i, __m256i) { + ( + set4( + count_low(jobs[0].count), + count_low(jobs[1].count), + count_low(jobs[2].count), + count_low(jobs[3].count), + ), + set4( + count_high(jobs[0].count), + count_high(jobs[1].count), + count_high(jobs[2].count), + count_high(jobs[3].count), + ), + ) +} + +#[inline(always)] +unsafe fn store_counts(jobs: &mut [Job; DEGREE], low: __m256i, high: __m256i) { + let low_ints: [Word; DEGREE] = mem::transmute(low); + let high_ints: [Word; DEGREE] = mem::transmute(high); + for i in 0..DEGREE { + jobs[i].count = assemble_count(low_ints[i], high_ints[i]); + } +} + +#[inline(always)] +unsafe fn add_to_counts(lo: &mut __m256i, hi: &mut __m256i, delta: __m256i) { + // If the low counts reach zero, that means they wrapped, unless the delta + // was also zero. + *lo = add(*lo, delta); + let lo_reached_zero = eq(*lo, set1(0)); + let delta_was_zero = eq(delta, set1(0)); + let hi_inc = and(set1(1), negate_and(delta_was_zero, lo_reached_zero)); + *hi = add(*hi, hi_inc); +} + +#[inline(always)] +unsafe fn flags_vec(flags: [bool; DEGREE]) -> __m256i { + set4( + flag_word(flags[0]), + flag_word(flags[1]), + flag_word(flags[2]), + flag_word(flags[3]), + ) +} + +#[target_feature(enable = "avx2")] +pub unsafe fn compress4_loop(jobs: &mut [Job; DEGREE], finalize: Finalize, stride: Stride) { + // If we're not finalizing, there can't be a partial block at the end. + for job in jobs.iter() { + input_debug_asserts(job.input, finalize); + } + + let msg_ptrs = [ + jobs[0].input.as_ptr(), + jobs[1].input.as_ptr(), + jobs[2].input.as_ptr(), + jobs[3].input.as_ptr(), + ]; + let mut h_vecs = transpose_state_vecs(&jobs); + let (mut counts_lo, mut counts_hi) = load_counts(&jobs); + + // Prepare the final blocks (note, which could be empty if the input is + // empty). Do all this before entering the main loop. + let min_len = jobs.iter().map(|job| job.input.len()).min().unwrap(); + let mut fin_offset = min_len.saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + // Performance note, making these buffers mem::uninitialized() seems to + // cause problems in the optimizer. + let mut buf0: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf1: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf2: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf3: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let (block0, len0, finalize0) = final_block(jobs[0].input, fin_offset, &mut buf0, stride); + let (block1, len1, finalize1) = final_block(jobs[1].input, fin_offset, &mut buf1, stride); + let (block2, len2, finalize2) = final_block(jobs[2].input, fin_offset, &mut buf2, stride); + let (block3, len3, finalize3) = final_block(jobs[3].input, fin_offset, &mut buf3, stride); + let fin_blocks: [*const [u8; BLOCKBYTES]; DEGREE] = [block0, block1, block2, block3]; + let fin_counts_delta = set4(len0 as Word, len1 as Word, len2 as Word, len3 as Word); + let fin_last_block; + let fin_last_node; + if finalize.yes() { + fin_last_block = flags_vec([finalize0, finalize1, finalize2, finalize3]); + fin_last_node = flags_vec([ + finalize0 && jobs[0].last_node.yes(), + finalize1 && jobs[1].last_node.yes(), + finalize2 && jobs[2].last_node.yes(), + finalize3 && jobs[3].last_node.yes(), + ]); + } else { + fin_last_block = set1(0); + fin_last_node = set1(0); + } + + // The main loop. + let mut offset = 0; + loop { + let blocks; + let counts_delta; + let last_block; + let last_node; + if offset == fin_offset { + blocks = fin_blocks; + counts_delta = fin_counts_delta; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + blocks = [ + msg_ptrs[0].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[1].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[2].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[3].add(offset) as *const [u8; BLOCKBYTES], + ]; + counts_delta = set1(BLOCKBYTES as Word); + last_block = set1(0); + last_node = set1(0); + }; + + let m_vecs = transpose_msg_vecs(blocks); + add_to_counts(&mut counts_lo, &mut counts_hi, counts_delta); + compress4_transposed!( + &mut h_vecs, + &m_vecs, + counts_lo, + counts_hi, + last_block, + last_node, + ); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + // Write out the results. + untranspose_state_vecs(&h_vecs, &mut *jobs); + store_counts(&mut *jobs, counts_lo, counts_hi); + let max_consumed = offset.saturating_add(stride.padded_blockbytes()); + for job in jobs.iter_mut() { + let consumed = cmp::min(max_consumed, job.input.len()); + job.input = &job.input[consumed..]; + } +} diff --git a/src/plonk/blake2_const/blake2b/src/blake2bp.rs b/src/plonk/blake2_const/blake2b/src/blake2bp.rs new file mode 100644 index 000000000..7bdfad64f --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/blake2bp.rs @@ -0,0 +1,570 @@ +//! BLAKE2bp, a variant of BLAKE2b that uses SIMD more efficiently. +//! +//! The AVX2 implementation of BLAKE2bp is about twice as fast that of BLAKE2b. +//! However, note that it's a different hash function, and it gives a different +//! hash from BLAKE2b for the same input. +//! +//! # Example +//! +//! ``` +//! use blake2b_simd::blake2bp; +//! +//! let hash = blake2bp::Params::new() +//! .hash_length(16) +//! .key(b"The Magic Words are Squeamish Ossifrage") +//! .to_state() +//! .update(b"foo") +//! .update(b"bar") +//! .update(b"baz") +//! .finalize(); +//! assert_eq!("e69c7d2c42a5ac14948772231c68c552", &hash.to_hex()); +//! ``` + +use crate::guts::{Finalize, Implementation, Job, LastNode, Stride}; +use crate::many; +use crate::Count; +use crate::Hash; +use crate::Word; +use crate::BLOCKBYTES; +use crate::KEYBYTES; +use crate::OUTBYTES; +use core::cmp; +use core::fmt; +use core::mem::size_of; + +#[cfg(feature = "std")] +use std; + +pub(crate) const DEGREE: usize = 4; + +/// Compute the BLAKE2bp hash of a slice of bytes all at once, using default +/// parameters. +/// +/// # Example +/// +/// ``` +/// # use blake2b_simd::blake2bp::blake2bp; +/// let expected = "8ca9ccee7946afcb686fe7556628b5ba1bf9a691da37ca58cd049354d99f3704\ +/// 2c007427e5f219b9ab5063707ec6823872dee413ee014b4d02f2ebb6abb5f643"; +/// let hash = blake2bp(b"foo"); +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +pub fn blake2bp(input: &[u8]) -> Hash { + Params::new().hash(input) +} + +/// A parameter builder for BLAKE2bp, just like the [`Params`](../struct.Params.html) type for +/// BLAKE2b. +/// +/// This builder only supports configuring the hash length and a secret key. This matches the +/// options provided by the [reference +/// implementation](https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2.h#L162-L165). +/// +/// # Example +/// +/// ``` +/// use blake2b_simd::blake2bp; +/// let mut state = blake2bp::Params::new().hash_length(32).to_state(); +/// ``` +#[derive(Clone)] +pub struct Params { + hash_length: u8, + key_length: u8, + key: [u8; KEYBYTES], + implementation: Implementation, +} + +impl Params { + /// Equivalent to `Params::default()`. + pub fn new() -> Self { + Self { + hash_length: OUTBYTES as u8, + key_length: 0, + key: [0; KEYBYTES], + implementation: Implementation::detect(), + } + } + + fn to_words(&self) -> ([[Word; 8]; DEGREE], [Word; 8]) { + let mut base_params = crate::Params::new(); + base_params + .hash_length(self.hash_length as usize) + .key(&self.key[..self.key_length as usize]) + .fanout(DEGREE as u8) + .max_depth(2) + .max_leaf_length(0) + // Note that inner_hash_length is always OUTBYTES, regardless of the hash_length + // parameter. This isn't documented in the spec, but it matches the behavior of the + // reference implementation: https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2bp-ref.c#L55 + .inner_hash_length(OUTBYTES); + let leaf_words = |worker_index| { + base_params + .clone() + .node_offset(worker_index) + .node_depth(0) + // Note that setting the last_node flag here has no effect, + // because it isn't included in the state words. + .to_words() + }; + let leaf_words = [leaf_words(0), leaf_words(1), leaf_words(2), leaf_words(3)]; + let root_words = base_params + .clone() + .node_offset(0) + .node_depth(1) + // Note that setting the last_node flag here has no effect, because + // it isn't included in the state words. Also note that because + // we're only preserving its state words, the root node won't hash + // any key bytes. + .to_words(); + (leaf_words, root_words) + } + + /// Hash an input all at once with these parameters. + pub fn hash(&self, input: &[u8]) -> Hash { + // If there's a key, just fall back to using the State. + if self.key_length > 0 { + return self.to_state().update(input).finalize(); + } + let (mut leaf_words, mut root_words) = self.to_words(); + // Hash each leaf in parallel. + let jobs = leaf_words.iter_mut().enumerate().map(|(i, words)| { + let input_start = cmp::min(input.len(), i * BLOCKBYTES); + Job { + input: &input[input_start..], + words, + count: 0, + last_node: if i == DEGREE - 1 { + LastNode::Yes + } else { + LastNode::No + }, + } + }); + many::compress_many(jobs, self.implementation, Finalize::Yes, Stride::Parallel); + // Hash each leaf into the root. + finalize_root_words( + &leaf_words, + &mut root_words, + self.hash_length, + self.implementation, + ) + } + + /// Construct a BLAKE2bp `State` object based on these parameters. + pub fn to_state(&self) -> State { + State::with_params(self) + } + + /// Set the length of the final hash, from 1 to `OUTBYTES` (64). Apart from controlling the + /// length of the final `Hash`, this is also associated data, and changing it will result in a + /// totally different hash. + pub fn hash_length(&mut self, length: usize) -> &mut Self { + assert!( + 1 <= length && length <= OUTBYTES, + "Bad hash length: {}", + length + ); + self.hash_length = length as u8; + self + } + + /// Use a secret key, so that BLAKE2bp acts as a MAC. The maximum key length is `KEYBYTES` + /// (64). An empty key is equivalent to having no key at all. + pub fn key(&mut self, key: &[u8]) -> &mut Self { + assert!(key.len() <= KEYBYTES, "Bad key length: {}", key.len()); + self.key_length = key.len() as u8; + self.key = [0; KEYBYTES]; + self.key[..key.len()].copy_from_slice(key); + self + } +} + +impl Default for Params { + fn default() -> Self { + Self::new() + } +} + +impl fmt::Debug for Params { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "Params {{ hash_length: {}, key_length: {} }}", + self.hash_length, + // NB: Don't print the key itself. Debug shouldn't leak secrets. + self.key_length, + ) + } +} + +/// An incremental hasher for BLAKE2bp, just like the [`State`](../struct.State.html) type for +/// BLAKE2b. +/// +/// # Example +/// +/// ``` +/// use blake2b_simd::blake2bp; +/// +/// let mut state = blake2bp::State::new(); +/// state.update(b"foo"); +/// state.update(b"bar"); +/// let hash = state.finalize(); +/// +/// let expected = "e654427b6ef02949471712263e59071abbb6aa94855674c1daeed6cfaf127c33\ +/// dfa3205f7f7f71e4f0673d25fa82a368488911f446bccd323af3ab03f53e56e5"; +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +#[derive(Clone)] +pub struct State { + leaf_words: [[Word; 8]; DEGREE], + root_words: [Word; 8], + // Note that this buffer is twice as large as what compress4 needs. That guarantees that we + // have enough input when we compress to know we don't need to finalize any of the leaves. + buf: [u8; 2 * DEGREE * BLOCKBYTES], + buf_len: u16, + // Note that this is the *per-leaf* count. + count: Count, + hash_length: u8, + implementation: Implementation, + is_keyed: bool, +} + +impl State { + /// Equivalent to `State::default()` or `Params::default().to_state()`. + pub fn new() -> Self { + Self::with_params(&Params::default()) + } + + fn with_params(params: &Params) -> Self { + let (leaf_words, root_words) = params.to_words(); + + // If a key is set, initalize the buffer to contain the key bytes. Note + // that only the leaves hash key bytes. The root doesn't, even though + // the key length it still set in its parameters. Again this isn't + // documented in the spec, but it matches the behavior of the reference + // implementation: + // https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2bp-ref.c#L128 + // This particular behavior (though not the inner hash length behavior + // above) is also corroborated by the official test vectors; see + // tests/vector_tests.rs. + let mut buf = [0; 2 * DEGREE * BLOCKBYTES]; + let mut buf_len = 0; + if params.key_length > 0 { + for i in 0..DEGREE { + let keybytes = ¶ms.key[..params.key_length as usize]; + buf[i * BLOCKBYTES..][..keybytes.len()].copy_from_slice(keybytes); + buf_len = BLOCKBYTES * DEGREE; + } + } + + Self { + leaf_words, + root_words, + buf, + buf_len: buf_len as u16, + count: 0, // count gets updated in self.compress() + hash_length: params.hash_length, + implementation: params.implementation, + is_keyed: params.key_length > 0, + } + } + + fn fill_buf(&mut self, input: &mut &[u8]) { + let take = cmp::min(self.buf.len() - self.buf_len as usize, input.len()); + self.buf[self.buf_len as usize..][..take].copy_from_slice(&input[..take]); + self.buf_len += take as u16; + *input = &input[take..]; + } + + fn compress_to_leaves( + leaves: &mut [[Word; 8]; DEGREE], + input: &[u8], + count: &mut Count, + implementation: Implementation, + ) { + // Input is assumed to be an even number of blocks for each leaf. Since + // we're not finilizing, debug asserts will fire otherwise. + let jobs = leaves.iter_mut().enumerate().map(|(i, words)| { + Job { + input: &input[i * BLOCKBYTES..], + words, + count: *count, + last_node: LastNode::No, // irrelevant when not finalizing + } + }); + many::compress_many(jobs, implementation, Finalize::No, Stride::Parallel); + // Note that count is the bytes input *per-leaf*. + *count = count.wrapping_add((input.len() / DEGREE) as Count); + } + + /// Add input to the hash. You can call `update` any number of times. + pub fn update(&mut self, mut input: &[u8]) -> &mut Self { + // If we have a partial buffer, try to complete it. If we complete it and there's more + // input waiting, we need to compress to make more room. However, because we need to be + // sure that *none* of the leaves would need to be finalized as part of this round of + // compression, we need to buffer more than we would for BLAKE2b. + if self.buf_len > 0 { + self.fill_buf(&mut input); + // The buffer is large enough for two compressions. If we've filled + // the buffer and there's still more input coming, then we have to + // do at least one compression. If there's enough input still + // coming that all the leaves are guaranteed to get more, do both + // compressions in the buffer. Otherwise, do just one and shift the + // back half of the buffer to the front. + if !input.is_empty() { + if input.len() > (DEGREE - 1) * BLOCKBYTES { + // Enough input coming to do both compressions. + Self::compress_to_leaves( + &mut self.leaf_words, + &self.buf, + &mut self.count, + self.implementation, + ); + self.buf_len = 0; + } else { + // Only enough input coming for one compression. + Self::compress_to_leaves( + &mut self.leaf_words, + &self.buf[..DEGREE * BLOCKBYTES], + &mut self.count, + self.implementation, + ); + self.buf_len = (DEGREE * BLOCKBYTES) as u16; + let (buf_front, buf_back) = self.buf.split_at_mut(DEGREE * BLOCKBYTES); + buf_front.copy_from_slice(buf_back); + } + } + } + + // Now we directly compress as much input as possible, without copying + // it into the buffer. We need to make sure we buffer at least one byte + // for each of the leaves, so that we know we don't need to finalize + // them. + let needed_tail = (DEGREE - 1) * BLOCKBYTES + 1; + let mut bulk_bytes = input.len().saturating_sub(needed_tail); + bulk_bytes -= bulk_bytes % (DEGREE * BLOCKBYTES); + if bulk_bytes > 0 { + Self::compress_to_leaves( + &mut self.leaf_words, + &input[..bulk_bytes], + &mut self.count, + self.implementation, + ); + input = &input[bulk_bytes..]; + } + + // Buffer any remaining input, to be either compressed or finalized in + // a subsequent call. + self.fill_buf(&mut input); + debug_assert_eq!(0, input.len()); + self + } + + /// Finalize the state and return a `Hash`. This method is idempotent, and calling it multiple + /// times will give the same result. It's also possible to `update` with more input in between. + pub fn finalize(&self) -> Hash { + // Hash whatever's remaining in the buffer and finalize the leaves. + let buf_len = self.buf_len as usize; + let mut leaves_copy = self.leaf_words; + let jobs = leaves_copy + .iter_mut() + .enumerate() + .map(|(leaf_index, leaf_words)| { + let input = &self.buf[cmp::min(leaf_index * BLOCKBYTES, buf_len)..buf_len]; + Job { + input, + words: leaf_words, + count: self.count, + last_node: if leaf_index == DEGREE - 1 { + LastNode::Yes + } else { + LastNode::No + }, + } + }); + many::compress_many(jobs, self.implementation, Finalize::Yes, Stride::Parallel); + + // Concatenate each leaf into the root and hash that. + let mut root_words_copy = self.root_words; + finalize_root_words( + &leaves_copy, + &mut root_words_copy, + self.hash_length, + self.implementation, + ) + } + + /// Return the total number of bytes input so far. + /// + /// Note that `count` doesn't include the bytes of the key block, if any. + /// It's exactly the total number of input bytes fed to `update`. + pub fn count(&self) -> Count { + // Remember that self.count is *per-leaf*. + let mut ret = self + .count + .wrapping_mul(DEGREE as Count) + .wrapping_add(self.buf_len as Count); + if self.is_keyed { + ret -= (DEGREE * BLOCKBYTES) as Count; + } + ret + } +} + +#[cfg(feature = "std")] +impl std::io::Write for State { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl fmt::Debug for State { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "State {{ count: {}, hash_length: {} }}", + self.count(), + self.hash_length, + ) + } +} + +impl Default for State { + fn default() -> Self { + Self::with_params(&Params::default()) + } +} + +// Compress each of the four finalized hashes into the root words as input, +// using two compressions. Note that even if a future version of this +// implementation supports the hash_length parameter and sets it as associated +// data for all nodes, this step must still use the untruncated output of each +// leaf. Note also that, as mentioned above, the root node doesn't hash any key +// bytes. +fn finalize_root_words( + leaf_words: &[[Word; 8]; DEGREE], + root_words: &mut [Word; 8], + hash_length: u8, + imp: Implementation, +) -> Hash { + debug_assert_eq!(OUTBYTES, 8 * size_of::()); + let mut block = [0; DEGREE * OUTBYTES]; + for (word, chunk) in leaf_words + .iter() + .flat_map(|words| words.iter()) + .zip(block.chunks_exact_mut(size_of::())) + { + chunk.copy_from_slice(&word.to_le_bytes()); + } + imp.compress1_loop( + &block, + root_words, + 0, + LastNode::Yes, + Finalize::Yes, + Stride::Serial, + ); + Hash { + bytes: crate::state_words_to_bytes(&root_words), + len: hash_length, + } +} + +pub(crate) fn force_portable(params: &mut Params) { + params.implementation = Implementation::portable(); +} + +#[cfg(test)] +pub(crate) mod test { + use super::*; + use crate::paint_test_input; + + // This is a simple reference implementation without the complicated buffering or parameter + // support of the real implementation. We need this because the official test vectors don't + // include any inputs large enough to exercise all the branches in the buffering logic. + fn blake2bp_reference(input: &[u8]) -> Hash { + let mut leaves = arrayvec::ArrayVec::<[_; DEGREE]>::new(); + for leaf_index in 0..DEGREE { + leaves.push( + crate::Params::new() + .fanout(DEGREE as u8) + .max_depth(2) + .node_offset(leaf_index as u64) + .inner_hash_length(OUTBYTES) + .to_state(), + ); + } + leaves[DEGREE - 1].set_last_node(true); + for (i, chunk) in input.chunks(BLOCKBYTES).enumerate() { + leaves[i % DEGREE].update(chunk); + } + let mut root = crate::Params::new() + .fanout(DEGREE as u8) + .max_depth(2) + .node_depth(1) + .inner_hash_length(OUTBYTES) + .last_node(true) + .to_state(); + for leaf in &mut leaves { + root.update(leaf.finalize().as_bytes()); + } + root.finalize() + } + + #[test] + fn test_against_reference() { + let mut buf = [0; 21 * BLOCKBYTES]; + paint_test_input(&mut buf); + // - 8 blocks is just enought to fill the double buffer. + // - 9 blocks triggers the "perform one compression on the double buffer" case. + // - 11 blocks is the largest input where only one compression may be performed, on the + // first half of the buffer, because there's not enough input to avoid needing to + // finalize the second half. + // - 12 blocks triggers the "perform both compressions in the double buffer" case. + // - 15 blocks is the largest input where, after compressing 8 blocks from the buffer, + // there's not enough input to hash directly from memory. + // - 16 blocks triggers "after emptying the buffer, hash directly from memory". + for num_blocks in 0..=20 { + for &extra in &[0, 1, BLOCKBYTES - 1] { + for &portable in &[false, true] { + // eprintln!("\ncase -----"); + // dbg!(num_blocks); + // dbg!(extra); + // dbg!(portable); + + // First hash the input all at once, as a sanity check. + let mut params = Params::new(); + if portable { + force_portable(&mut params); + } + let input = &buf[..num_blocks * BLOCKBYTES + extra]; + let expected = blake2bp_reference(&input); + let mut state = params.to_state(); + let found = state.update(input).finalize(); + assert_eq!(expected, found); + + // Then, do it again, but buffer 1 byte of input first. That causes the buffering + // branch to trigger. + let mut state = params.to_state(); + let maybe_one = cmp::min(1, input.len()); + state.update(&input[..maybe_one]); + assert_eq!(maybe_one as Count, state.count()); + // Do a throwaway finalize here to check for idempotency. + state.finalize(); + state.update(&input[maybe_one..]); + assert_eq!(input.len() as Count, state.count()); + let found = state.finalize(); + assert_eq!(expected, found); + + // Finally, do it again with the all-at-once interface. + assert_eq!(expected, blake2bp(input)); + } + } + } + } +} diff --git a/src/plonk/blake2_const/blake2b/src/guts.rs b/src/plonk/blake2_const/blake2b/src/guts.rs new file mode 100644 index 000000000..9fcacf319 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/guts.rs @@ -0,0 +1,565 @@ +use crate::*; +use arrayref::array_ref; +use core::cmp; + +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +pub const MAX_DEGREE: usize = 4; + +#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))] +pub const MAX_DEGREE: usize = 1; + +// Variants other than Portable are unreachable in no_std, unless CPU features +// are explicitly enabled for the build with e.g. RUSTFLAGS="-C target-feature=avx2". +// This might change in the future if is_x86_feature_detected moves into libcore. +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +enum Platform { + Portable, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + SSE41, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + AVX2, +} + +#[derive(Clone, Copy, Debug)] +pub struct Implementation(Platform); + +impl Implementation { + pub fn detect() -> Self { + // Try the different implementations in order of how fast/modern they + // are. Currently on non-x86, everything just uses portable. + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + { + if let Some(avx2_impl) = Self::avx2_if_supported() { + return avx2_impl; + } + } + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + { + if let Some(sse41_impl) = Self::sse41_if_supported() { + return sse41_impl; + } + } + Self::portable() + } + + pub fn portable() -> Self { + Implementation(Platform::Portable) + } + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[allow(unreachable_code)] + pub fn sse41_if_supported() -> Option { + // Check whether SSE4.1 support is assumed by the build. + #[cfg(target_feature = "sse4.1")] + { + return Some(Implementation(Platform::SSE41)); + } + // Otherwise dynamically check for support if we can. + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("sse4.1") { + return Some(Implementation(Platform::SSE41)); + } + } + None + } + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[allow(unreachable_code)] + pub fn avx2_if_supported() -> Option { + // Check whether AVX2 support is assumed by the build. + #[cfg(target_feature = "avx2")] + { + return Some(Implementation(Platform::AVX2)); + } + // Otherwise dynamically check for support if we can. + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("avx2") { + return Some(Implementation(Platform::AVX2)); + } + } + None + } + + pub fn degree(&self) -> usize { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 => avx2::DEGREE, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::SSE41 => sse41::DEGREE, + Platform::Portable => 1, + } + } + + pub fn compress1_loop( + &self, + input: &[u8], + words: &mut [Word; 8], + count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, + ) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 => unsafe { + avx2::compress1_loop(input, words, count, last_node, finalize, stride); + }, + // Note that there's an SSE version of compress1 in the official C + // implementation, but I haven't ported it yet. + _ => { + portable::compress1_loop(input, words, count, last_node, finalize, stride); + } + } + } + + pub fn compress2_loop(&self, jobs: &mut [Job; 2], finalize: Finalize, stride: Stride) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 | Platform::SSE41 => unsafe { + sse41::compress2_loop(jobs, finalize, stride) + }, + _ => panic!("unsupported"), + } + } + + pub fn compress4_loop(&self, jobs: &mut [Job; 4], finalize: Finalize, stride: Stride) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 => unsafe { avx2::compress4_loop(jobs, finalize, stride) }, + _ => panic!("unsupported"), + } + } +} + +pub struct Job<'a, 'b> { + pub input: &'a [u8], + pub words: &'b mut [Word; 8], + pub count: Count, + pub last_node: LastNode, +} + +impl<'a, 'b> core::fmt::Debug for Job<'a, 'b> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "Job {{ input_len: {}, count: {}, last_node: {} }}", + self.input.len(), + self.count, + self.last_node.yes(), + ) + } +} + +// Finalize could just be a bool, but this is easier to read at callsites. +#[derive(Clone, Copy, Debug)] +pub enum Finalize { + Yes, + No, +} + +impl Finalize { + pub fn yes(&self) -> bool { + match self { + Finalize::Yes => true, + Finalize::No => false, + } + } +} + +// Like Finalize, this is easier to read at callsites. +#[derive(Clone, Copy, Debug)] +pub enum LastNode { + Yes, + No, +} + +impl LastNode { + pub fn yes(&self) -> bool { + match self { + LastNode::Yes => true, + LastNode::No => false, + } + } +} + +#[derive(Clone, Copy, Debug)] +pub enum Stride { + Serial, // BLAKE2b/BLAKE2s + Parallel, // BLAKE2bp/BLAKE2sp +} + +impl Stride { + pub fn padded_blockbytes(&self) -> usize { + match self { + Stride::Serial => BLOCKBYTES, + Stride::Parallel => blake2bp::DEGREE * BLOCKBYTES, + } + } +} + +pub(crate) fn count_low(count: Count) -> Word { + count as Word +} + +pub(crate) fn count_high(count: Count) -> Word { + (count >> 8 * size_of::()) as Word +} + +pub(crate) fn assemble_count(low: Word, high: Word) -> Count { + low as Count + ((high as Count) << 8 * size_of::()) +} + +pub(crate) fn flag_word(flag: bool) -> Word { + if flag { + !0 + } else { + 0 + } +} + +// Pull a array reference at the given offset straight from the input, if +// there's a full block of input available. If there's only a partial block, +// copy it into the provided buffer, and return an array reference that. Along +// with the array, return the number of bytes of real input, and whether the +// input can be finalized (i.e. whether there aren't any more bytes after this +// block). Note that this is written so that the optimizer can elide bounds +// checks, see: https://godbolt.org/z/0hH2bC +pub fn final_block<'a>( + input: &'a [u8], + offset: usize, + buffer: &'a mut [u8; BLOCKBYTES], + stride: Stride, +) -> (&'a [u8; BLOCKBYTES], usize, bool) { + let capped_offset = cmp::min(offset, input.len()); + let offset_slice = &input[capped_offset..]; + if offset_slice.len() >= BLOCKBYTES { + let block = array_ref!(offset_slice, 0, BLOCKBYTES); + let should_finalize = offset_slice.len() <= stride.padded_blockbytes(); + (block, BLOCKBYTES, should_finalize) + } else { + // Copy the final block to the front of the block buffer. The rest of + // the buffer is assumed to be initialized to zero. + buffer[..offset_slice.len()].copy_from_slice(offset_slice); + (buffer, offset_slice.len(), true) + } +} + +pub fn input_debug_asserts(input: &[u8], finalize: Finalize) { + // If we're not finalizing, the input must not be empty, and it must be an + // even multiple of the block size. + if !finalize.yes() { + debug_assert!(!input.is_empty()); + debug_assert_eq!(0, input.len() % BLOCKBYTES); + } +} + +#[cfg(test)] +mod test { + use super::*; + use arrayvec::ArrayVec; + use core::mem::size_of; + + #[test] + fn test_detection() { + assert_eq!(Platform::Portable, Implementation::portable().0); + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("avx2") { + assert_eq!(Platform::AVX2, Implementation::detect().0); + assert_eq!( + Platform::AVX2, + Implementation::avx2_if_supported().unwrap().0 + ); + assert_eq!( + Platform::SSE41, + Implementation::sse41_if_supported().unwrap().0 + ); + } else if is_x86_feature_detected!("sse4.1") { + assert_eq!(Platform::SSE41, Implementation::detect().0); + assert!(Implementation::avx2_if_supported().is_none()); + assert_eq!( + Platform::SSE41, + Implementation::sse41_if_supported().unwrap().0 + ); + } else { + assert_eq!(Platform::Portable, Implementation::detect().0); + assert!(Implementation::avx2_if_supported().is_none()); + assert!(Implementation::sse41_if_supported().is_none()); + } + } + } + + // TODO: Move all of these case tests into the implementation files. + fn exercise_cases(mut f: F) + where + F: FnMut(Stride, usize, LastNode, Finalize, Count), + { + // Chose counts to hit the relevant overflow cases. + let counts = &[ + (0 as Count), + ((1 as Count) << (8 * size_of::())) - BLOCKBYTES as Count, + (0 as Count).wrapping_sub(BLOCKBYTES as Count), + ]; + for &stride in &[Stride::Serial, Stride::Parallel] { + let lengths = [ + 0, + 1, + BLOCKBYTES - 1, + BLOCKBYTES, + BLOCKBYTES + 1, + 2 * BLOCKBYTES - 1, + 2 * BLOCKBYTES, + 2 * BLOCKBYTES + 1, + stride.padded_blockbytes() - 1, + stride.padded_blockbytes(), + stride.padded_blockbytes() + 1, + 2 * stride.padded_blockbytes() - 1, + 2 * stride.padded_blockbytes(), + 2 * stride.padded_blockbytes() + 1, + ]; + for &length in &lengths { + for &last_node in &[LastNode::No, LastNode::Yes] { + for &finalize in &[Finalize::No, Finalize::Yes] { + if !finalize.yes() && (length == 0 || length % BLOCKBYTES != 0) { + // Skip these cases, they're invalid. + continue; + } + for &count in counts { + // eprintln!("\ncase -----"); + // dbg!(stride); + // dbg!(length); + // dbg!(last_node); + // dbg!(finalize); + // dbg!(count); + + f(stride, length, last_node, finalize, count); + } + } + } + } + } + } + + fn initial_test_words(input_index: usize) -> [Word; 8] { + crate::Params::new() + .node_offset(input_index as u64) + .to_words() + } + + // Use the portable implementation, one block at a time, to compute the + // final state words expected for a given test case. + fn reference_compression( + input: &[u8], + stride: Stride, + last_node: LastNode, + finalize: Finalize, + mut count: Count, + input_index: usize, + ) -> [Word; 8] { + let mut words = initial_test_words(input_index); + let mut offset = 0; + while offset == 0 || offset < input.len() { + let block_size = cmp::min(BLOCKBYTES, input.len() - offset); + let maybe_finalize = if offset + stride.padded_blockbytes() < input.len() { + Finalize::No + } else { + finalize + }; + portable::compress1_loop( + &input[offset..][..block_size], + &mut words, + count, + last_node, + maybe_finalize, + Stride::Serial, + ); + offset += stride.padded_blockbytes(); + count = count.wrapping_add(BLOCKBYTES as Count); + } + words + } + + // For various loop lengths and finalization parameters, make sure that the + // implementation gives the same answer as the portable implementation does + // when invoked one block at a time. (So even the portable implementation + // itself is being tested here, to make sure its loop is correct.) Note + // that this doesn't include any fixed test vectors; those are taken from + // the blake2-kat.json file (copied from upstream) and tested elsewhere. + fn exercise_compress1_loop(implementation: Implementation) { + let mut input = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input); + + exercise_cases(|stride, length, last_node, finalize, count| { + let reference_words = + reference_compression(&input[..length], stride, last_node, finalize, count, 0); + + let mut test_words = initial_test_words(0); + implementation.compress1_loop( + &input[..length], + &mut test_words, + count, + last_node, + finalize, + stride, + ); + assert_eq!(reference_words, test_words); + }); + } + + #[test] + fn test_compress1_loop_portable() { + exercise_compress1_loop(Implementation::portable()); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress1_loop_sse41() { + // Currently this just falls back to portable, but we test it anyway. + if let Some(imp) = Implementation::sse41_if_supported() { + exercise_compress1_loop(imp); + } + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress1_loop_avx2() { + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress1_loop(imp); + } + } + + // I use ArrayVec everywhere in here becuase currently these tests pass + // under no_std. I might decide that's not worth maintaining at some point, + // since really all we care about with no_std is that the library builds, + // but for now it's here. Everything is keyed off of this N constant so + // that it's easy to copy the code to exercise_compress4_loop. + fn exercise_compress2_loop(implementation: Implementation) { + const N: usize = 2; + + let mut input_buffer = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input_buffer); + let mut inputs = ArrayVec::<[_; N]>::new(); + for i in 0..N { + inputs.push(&input_buffer[i..]); + } + + exercise_cases(|stride, length, last_node, finalize, count| { + let mut reference_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + let words = reference_compression( + &inputs[i][..length], + stride, + last_node, + finalize, + count.wrapping_add((i * BLOCKBYTES) as Count), + i, + ); + reference_words.push(words); + } + + let mut test_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + test_words.push(initial_test_words(i)); + } + let mut jobs = ArrayVec::<[_; N]>::new(); + for (i, words) in test_words.iter_mut().enumerate() { + jobs.push(Job { + input: &inputs[i][..length], + words, + count: count.wrapping_add((i * BLOCKBYTES) as Count), + last_node, + }); + } + let mut jobs = jobs.into_inner().expect("full"); + implementation.compress2_loop(&mut jobs, finalize, stride); + + for i in 0..N { + assert_eq!(reference_words[i], test_words[i], "words {} unequal", i); + } + }); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress2_loop_sse41() { + if let Some(imp) = Implementation::sse41_if_supported() { + exercise_compress2_loop(imp); + } + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress2_loop_avx2() { + // Currently this just falls back to SSE4.1, but we test it anyway. + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress2_loop(imp); + } + } + + // Copied from exercise_compress2_loop, with a different value of N and an + // interior call to compress4_loop. + fn exercise_compress4_loop(implementation: Implementation) { + const N: usize = 4; + + let mut input_buffer = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input_buffer); + let mut inputs = ArrayVec::<[_; N]>::new(); + for i in 0..N { + inputs.push(&input_buffer[i..]); + } + + exercise_cases(|stride, length, last_node, finalize, count| { + let mut reference_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + let words = reference_compression( + &inputs[i][..length], + stride, + last_node, + finalize, + count.wrapping_add((i * BLOCKBYTES) as Count), + i, + ); + reference_words.push(words); + } + + let mut test_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + test_words.push(initial_test_words(i)); + } + let mut jobs = ArrayVec::<[_; N]>::new(); + for (i, words) in test_words.iter_mut().enumerate() { + jobs.push(Job { + input: &inputs[i][..length], + words, + count: count.wrapping_add((i * BLOCKBYTES) as Count), + last_node, + }); + } + let mut jobs = jobs.into_inner().expect("full"); + implementation.compress4_loop(&mut jobs, finalize, stride); + + for i in 0..N { + assert_eq!(reference_words[i], test_words[i], "words {} unequal", i); + } + }); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress4_loop_avx2() { + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress4_loop(imp); + } + } + + #[test] + fn sanity_check_count_size() { + assert_eq!(size_of::(), 2 * size_of::()); + } +} diff --git a/src/plonk/blake2_const/blake2b/src/lib.rs b/src/plonk/blake2_const/blake2b/src/lib.rs new file mode 100644 index 000000000..cadef7f9a --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/lib.rs @@ -0,0 +1,674 @@ +//! [![GitHub](https://img.shields.io/github/tag/oconnor663/blake2_simd.svg?label=GitHub)](https://github.com/oconnor663/blake2_simd) [![crates.io](https://img.shields.io/crates/v/blake2b_simd.svg)](https://crates.io/crates/blake2b_simd) [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) +//! +//! An implementation of the BLAKE2b and BLAKE2bp hash functions. See also +//! [`blake2s_simd`](https://docs.rs/blake2s_simd). +//! +//! This crate includes: +//! +//! - 100% stable Rust. +//! - SIMD implementations based on Samuel Neves' [`blake2-avx2`](https://github.com/sneves/blake2-avx2). +//! These are very fast. For benchmarks, see [the Performance section of the +//! README](https://github.com/oconnor663/blake2_simd#performance). +//! - Portable, safe implementations for other platforms. +//! - Dynamic CPU feature detection. Binaries include multiple implementations by default and +//! choose the fastest one the processor supports at runtime. +//! - All the features from the [the BLAKE2 spec](https://blake2.net/blake2.pdf), like adjustable +//! length, keying, and associated data for tree hashing. +//! - `no_std` support. The `std` Cargo feature is on by default, for CPU feature detection and +//! for implementing `std::io::Write`. +//! - Support for computing multiple BLAKE2b hashes in parallel, matching the efficiency of +//! BLAKE2bp. See the [`many`](many/index.html) module. +//! +//! # Example +//! +//! ``` +//! use blake2b_simd::{blake2b, Params}; +//! +//! let expected = "ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6d\ +//! c1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"; +//! let hash = blake2b(b"foo"); +//! assert_eq!(expected, &hash.to_hex()); +//! +//! let hash = Params::new() +//! .hash_length(16) +//! .key(b"The Magic Words are Squeamish Ossifrage") +//! .personal(b"L. P. Waterhouse") +//! .to_state() +//! .update(b"foo") +//! .update(b"bar") +//! .update(b"baz") +//! .finalize(); +//! assert_eq!("ee8ff4e9be887297cf79348dc35dab56", &hash.to_hex()); +//! ``` + +#![cfg_attr(not(feature = "std"), no_std)] + +use arrayref::{array_refs, mut_array_refs}; +use core::cmp; +use core::fmt; +use core::mem::size_of; + +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +mod avx2; +mod portable; +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +mod sse41; + +pub mod blake2bp; +mod guts; +pub mod many; + +#[cfg(test)] +mod test; + +type Word = u64; +type Count = u128; + +/// The max hash length. +pub const OUTBYTES: usize = 8 * size_of::(); +/// The max key length. +pub const KEYBYTES: usize = 8 * size_of::(); +/// The max salt length. +pub const SALTBYTES: usize = 2 * size_of::(); +/// The max personalization length. +pub const PERSONALBYTES: usize = 2 * size_of::(); +/// The number input bytes passed to each call to the compression function. Small benchmarks need +/// to use an even multiple of `BLOCKBYTES`, or else their apparent throughput will be low. +pub const BLOCKBYTES: usize = 16 * size_of::(); + +const IV: [Word; 8] = [ + 0x6A09E667F3BCC908, + 0xBB67AE8584CAA73B, + 0x3C6EF372FE94F82B, + 0xA54FF53A5F1D36F1, + 0x510E527FADE682D1, + 0x9B05688C2B3E6C1F, + 0x1F83D9ABFB41BD6B, + 0x5BE0CD19137E2179, +]; + +const SIGMA: [[u8; 16]; 12] = [ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3], + [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4], + [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8], + [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13], + [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9], + [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11], + [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10], + [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5], + [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0], + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3], +]; + +/// Compute the BLAKE2b hash of a slice of bytes all at once, using default +/// parameters. +/// +/// # Example +/// +/// ``` +/// # use blake2b_simd::{blake2b, Params}; +/// let expected = "ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6d\ +/// c1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d"; +/// let hash = blake2b(b"foo"); +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +pub fn blake2b(input: &[u8]) -> Hash { + Params::new().hash(input) +} + +/// A parameter builder that exposes all the non-default BLAKE2 features. +/// +/// Apart from `hash_length`, which controls the length of the final `Hash`, +/// all of these parameters are just associated data that gets mixed with the +/// input. For more details, see [the BLAKE2 spec](https://blake2.net/blake2.pdf). +/// +/// Several of the parameters have a valid range defined in the spec and +/// documented below. Trying to set an invalid parameter will panic. +/// +/// # Example +/// +/// ``` +/// # use blake2b_simd::Params; +/// // Create a Params object with a secret key and a non-default length. +/// let mut params = Params::new(); +/// params.key(b"my secret key"); +/// params.hash_length(16); +/// +/// // Use those params to hash an input all at once. +/// let hash = params.hash(b"my input"); +/// +/// // Or use those params to build an incremental State. +/// let mut state = params.to_state(); +/// ``` +#[derive(Clone)] +pub struct Params { + hash_length: u8, + key_length: u8, + key_block: [u8; BLOCKBYTES], + salt: [u8; SALTBYTES], + personal: [u8; PERSONALBYTES], + fanout: u8, + max_depth: u8, + max_leaf_length: u32, + node_offset: u64, + node_depth: u8, + inner_hash_length: u8, + last_node: guts::LastNode, + implementation: guts::Implementation, +} + +impl Params { + /// Equivalent to `Params::default()`. + #[inline] + pub fn new() -> Self { + Self { + hash_length: OUTBYTES as u8, + key_length: 0, + key_block: [0; BLOCKBYTES], + salt: [0; SALTBYTES], + personal: [0; PERSONALBYTES], + // NOTE: fanout and max_depth don't default to zero! + fanout: 1, + max_depth: 1, + max_leaf_length: 0, + node_offset: 0, + node_depth: 0, + inner_hash_length: 0, + last_node: guts::LastNode::No, + implementation: guts::Implementation::detect(), + } + } + + #[inline(always)] + fn to_words(&self) -> [Word; 8] { + let (salt_left, salt_right) = array_refs!(&self.salt, SALTBYTES / 2, SALTBYTES / 2); + let (personal_left, personal_right) = + array_refs!(&self.personal, PERSONALBYTES / 2, PERSONALBYTES / 2); + [ + IV[0] + ^ self.hash_length as u64 + ^ (self.key_length as u64) << 8 + ^ (self.fanout as u64) << 16 + ^ (self.max_depth as u64) << 24 + ^ (self.max_leaf_length as u64) << 32, + IV[1] ^ self.node_offset, + IV[2] ^ self.node_depth as u64 ^ (self.inner_hash_length as u64) << 8, + IV[3], + IV[4] ^ Word::from_le_bytes(*salt_left), + IV[5] ^ Word::from_le_bytes(*salt_right), + IV[6] ^ Word::from_le_bytes(*personal_left), + IV[7] ^ Word::from_le_bytes(*personal_right), + ] + } + + /// Hash an input all at once with these parameters. + #[inline] + pub fn hash(&self, input: &[u8]) -> Hash { + // If there's a key, just fall back to using the State. + if self.key_length > 0 { + return self.to_state().update(input).finalize(); + } + let mut words = self.to_words(); + self.implementation.compress1_loop( + input, + &mut words, + 0, + self.last_node, + guts::Finalize::Yes, + guts::Stride::Serial, + ); + Hash { + bytes: state_words_to_bytes(&words), + len: self.hash_length, + } + } + + /// Construct a `State` object based on these parameters, for hashing input + /// incrementally. + pub fn to_state(&self) -> State { + State::with_params(self) + } + + /// Set the length of the final hash in bytes, from 1 to `OUTBYTES` (64). Apart from + /// controlling the length of the final `Hash`, this is also associated data, and changing it + /// will result in a totally different hash. + #[inline] + pub fn hash_length(&mut self, length: usize) -> &mut Self { + assert!( + 1 <= length && length <= OUTBYTES, + "Bad hash length: {}", + length + ); + self.hash_length = length as u8; + self + } + + /// Use a secret key, so that BLAKE2 acts as a MAC. The maximum key length is `KEYBYTES` (64). + /// An empty key is equivalent to having no key at all. + #[inline] + pub fn key(&mut self, key: &[u8]) -> &mut Self { + assert!(key.len() <= KEYBYTES, "Bad key length: {}", key.len()); + self.key_length = key.len() as u8; + self.key_block = [0; BLOCKBYTES]; + self.key_block[..key.len()].copy_from_slice(key); + self + } + + /// At most `SALTBYTES` (16). Shorter salts are padded with null bytes. An empty salt is + /// equivalent to having no salt at all. + #[inline] + pub fn salt(&mut self, salt: &[u8]) -> &mut Self { + assert!(salt.len() <= SALTBYTES, "Bad salt length: {}", salt.len()); + self.salt = [0; SALTBYTES]; + self.salt[..salt.len()].copy_from_slice(salt); + self + } + + /// At most `PERSONALBYTES` (16). Shorter personalizations are padded with null bytes. An empty + /// personalization is equivalent to having no personalization at all. + #[inline] + pub fn personal(&mut self, personalization: &[u8]) -> &mut Self { + assert!( + personalization.len() <= PERSONALBYTES, + "Bad personalization length: {}", + personalization.len() + ); + self.personal = [0; PERSONALBYTES]; + self.personal[..personalization.len()].copy_from_slice(personalization); + self + } + + /// From 0 (meaning unlimited) to 255. The default is 1 (meaning sequential). + #[inline] + pub fn fanout(&mut self, fanout: u8) -> &mut Self { + self.fanout = fanout; + self + } + + /// From 0 (meaning BLAKE2X B2 hashes), through 1 (the default, meaning sequential) to 255 (meaning unlimited). + #[inline] + pub fn max_depth(&mut self, depth: u8) -> &mut Self { + self.max_depth = depth; + self + } + + /// From 0 (the default, meaning unlimited or sequential) to `2^32 - 1`. + #[inline] + pub fn max_leaf_length(&mut self, length: u32) -> &mut Self { + self.max_leaf_length = length; + self + } + + /// From 0 (the default, meaning first, leftmost, leaf, or sequential) to `2^64 - 1`. + #[inline] + pub fn node_offset(&mut self, offset: u64) -> &mut Self { + self.node_offset = offset; + self + } + + /// From 0 (the default, meaning leaf or sequential) to 255. + #[inline] + pub fn node_depth(&mut self, depth: u8) -> &mut Self { + self.node_depth = depth; + self + } + + /// From 0 (the default, meaning sequential) to `OUTBYTES` (64). + #[inline] + pub fn inner_hash_length(&mut self, length: usize) -> &mut Self { + assert!(length <= OUTBYTES, "Bad inner hash length: {}", length); + self.inner_hash_length = length as u8; + self + } + + /// Indicates the rightmost node in a row. This can also be changed on the + /// `State` object, potentially after hashing has begun. See + /// [`State::set_last_node`]. + /// + /// [`State::set_last_node`]: struct.State.html#method.set_last_node + #[inline] + pub fn last_node(&mut self, last_node: bool) -> &mut Self { + self.last_node = if last_node { + guts::LastNode::Yes + } else { + guts::LastNode::No + }; + self + } +} + +impl Default for Params { + fn default() -> Self { + Self::new() + } +} + +impl fmt::Debug for Params { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "Params {{ hash_length: {}, key_length: {}, salt: {:?}, personal: {:?}, fanout: {}, \ + max_depth: {}, max_leaf_length: {}, node_offset: {}, node_depth: {}, \ + inner_hash_length: {}, last_node: {} }}", + self.hash_length, + // NB: Don't print the key itself. Debug shouldn't leak secrets. + self.key_length, + &self.salt, + &self.personal, + self.fanout, + self.max_depth, + self.max_leaf_length, + self.node_offset, + self.node_depth, + self.inner_hash_length, + self.last_node.yes(), + ) + } +} + +/// An incremental hasher for BLAKE2b. +/// +/// To construct a `State` with non-default parameters, see `Params::to_state`. +/// +/// # Example +/// +/// ``` +/// use blake2b_simd::{State, blake2b}; +/// +/// let mut state = blake2b_simd::State::new(); +/// +/// state.update(b"foo"); +/// assert_eq!(blake2b(b"foo"), state.finalize()); +/// +/// state.update(b"bar"); +/// assert_eq!(blake2b(b"foobar"), state.finalize()); +/// ``` +#[derive(Clone)] +pub struct State { + words: [Word; 8], + count: Count, + buf: [u8; BLOCKBYTES], + buflen: u8, + last_node: guts::LastNode, + hash_length: u8, + implementation: guts::Implementation, + is_keyed: bool, +} + +impl State { + /// Equivalent to `State::default()` or `Params::default().to_state()`. + pub fn new() -> Self { + Self::with_params(&Params::default()) + } + + fn with_params(params: &Params) -> Self { + let mut state = Self { + words: params.to_words(), + count: 0, + buf: [0; BLOCKBYTES], + buflen: 0, + last_node: params.last_node, + hash_length: params.hash_length, + implementation: params.implementation, + is_keyed: params.key_length > 0, + }; + if state.is_keyed { + state.buf = params.key_block; + state.buflen = state.buf.len() as u8; + } + state + } + + fn fill_buf(&mut self, input: &mut &[u8]) { + let take = cmp::min(BLOCKBYTES - self.buflen as usize, input.len()); + self.buf[self.buflen as usize..self.buflen as usize + take].copy_from_slice(&input[..take]); + self.buflen += take as u8; + *input = &input[take..]; + } + + // If the state already has some input in its buffer, try to fill the buffer and perform a + // compression. However, only do the compression if there's more input coming, otherwise it + // will give the wrong hash it the caller finalizes immediately after. + fn compress_buffer_if_possible(&mut self, input: &mut &[u8]) { + if self.buflen > 0 { + self.fill_buf(input); + if !input.is_empty() { + self.implementation.compress1_loop( + &self.buf, + &mut self.words, + self.count, + self.last_node, + guts::Finalize::No, + guts::Stride::Serial, + ); + self.count = self.count.wrapping_add(BLOCKBYTES as Count); + self.buflen = 0; + } + } + } + + /// Add input to the hash. You can call `update` any number of times. + pub fn update(&mut self, mut input: &[u8]) -> &mut Self { + // If we have a partial buffer, try to complete it. + self.compress_buffer_if_possible(&mut input); + // While there's more than a block of input left (which also means we cleared the buffer + // above), compress blocks directly without copying. + let mut end = input.len().saturating_sub(1); + end -= end % BLOCKBYTES; + if end > 0 { + self.implementation.compress1_loop( + &input[..end], + &mut self.words, + self.count, + self.last_node, + guts::Finalize::No, + guts::Stride::Serial, + ); + self.count = self.count.wrapping_add(end as Count); + input = &input[end..]; + } + // Buffer any remaining input, to be either compressed or finalized in a subsequent call. + // Note that this represents some copying overhead, which in theory we could avoid in + // all-at-once setting. A function hardcoded for exactly BLOCKSIZE input bytes is about 10% + // faster than using this implementation for the same input. + self.fill_buf(&mut input); + self + } + + /// Finalize the state and return a `Hash`. This method is idempotent, and calling it multiple + /// times will give the same result. It's also possible to `update` with more input in between. + pub fn finalize(&self) -> Hash { + let mut words_copy = self.words; + self.implementation.compress1_loop( + &self.buf[..self.buflen as usize], + &mut words_copy, + self.count, + self.last_node, + guts::Finalize::Yes, + guts::Stride::Serial, + ); + Hash { + bytes: state_words_to_bytes(&words_copy), + len: self.hash_length, + } + } + + /// Set a flag indicating that this is the last node of its level in a tree hash. This is + /// equivalent to [`Params::last_node`], except that it can be set at any time before calling + /// `finalize`. That allows callers to begin hashing a node without knowing ahead of time + /// whether it's the last in its level. For more details about the intended use of this flag + /// [the BLAKE2 spec]. + /// + /// [`Params::last_node`]: struct.Params.html#method.last_node + /// [the BLAKE2 spec]: https://blake2.net/blake2.pdf + pub fn set_last_node(&mut self, last_node: bool) -> &mut Self { + self.last_node = if last_node { + guts::LastNode::Yes + } else { + guts::LastNode::No + }; + self + } + + /// Return the total number of bytes input so far. + /// + /// Note that `count` doesn't include the bytes of the key block, if any. + /// It's exactly the total number of input bytes fed to `update`. + pub fn count(&self) -> Count { + let mut ret = self.count.wrapping_add(self.buflen as Count); + if self.is_keyed { + ret -= BLOCKBYTES as Count; + } + ret + } +} + +#[inline(always)] +fn state_words_to_bytes(state_words: &[Word; 8]) -> [u8; OUTBYTES] { + let mut bytes = [0; OUTBYTES]; + { + const W: usize = size_of::(); + let refs = mut_array_refs!(&mut bytes, W, W, W, W, W, W, W, W); + *refs.0 = state_words[0].to_le_bytes(); + *refs.1 = state_words[1].to_le_bytes(); + *refs.2 = state_words[2].to_le_bytes(); + *refs.3 = state_words[3].to_le_bytes(); + *refs.4 = state_words[4].to_le_bytes(); + *refs.5 = state_words[5].to_le_bytes(); + *refs.6 = state_words[6].to_le_bytes(); + *refs.7 = state_words[7].to_le_bytes(); + } + bytes +} + +#[cfg(feature = "std")] +impl std::io::Write for State { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl fmt::Debug for State { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "State {{ count: {}, hash_length: {}, last_node: {} }}", + self.count(), + self.hash_length, + self.last_node.yes(), + ) + } +} + +impl Default for State { + fn default() -> Self { + Self::with_params(&Params::default()) + } +} + +type HexString = arrayvec::ArrayString<[u8; 2 * OUTBYTES]>; + +/// A finalized BLAKE2 hash, with constant-time equality. +#[derive(Clone, Copy)] +pub struct Hash { + bytes: [u8; OUTBYTES], + len: u8, +} + +impl Hash { + /// Convert the hash to a byte slice. Note that if you're using BLAKE2 as a MAC, you need + /// constant time equality, which `&[u8]` doesn't provide. + pub fn as_bytes(&self) -> &[u8] { + &self.bytes[..self.len as usize] + } + + /// Convert the hash to a byte array. Note that if you're using BLAKE2 as a + /// MAC, you need constant time equality, which arrays don't provide. This + /// panics in debug mode if the length of the hash isn't `OUTBYTES`. + #[inline] + pub fn as_array(&self) -> &[u8; OUTBYTES] { + debug_assert_eq!(self.len as usize, OUTBYTES); + &self.bytes + } + + /// Convert the hash to a lowercase hexadecimal + /// [`ArrayString`](https://docs.rs/arrayvec/0.4/arrayvec/struct.ArrayString.html). + pub fn to_hex(&self) -> HexString { + bytes_to_hex(self.as_bytes()) + } +} + +fn bytes_to_hex(bytes: &[u8]) -> HexString { + let mut s = arrayvec::ArrayString::new(); + let table = b"0123456789abcdef"; + for &b in bytes { + s.push(table[(b >> 4) as usize] as char); + s.push(table[(b & 0xf) as usize] as char); + } + s +} + +/// This implementation is constant time, if the two hashes are the same length. +impl PartialEq for Hash { + fn eq(&self, other: &Hash) -> bool { + constant_time_eq::constant_time_eq(&self.as_bytes(), &other.as_bytes()) + } +} + +/// This implementation is constant time, if the slice is the same length as the hash. +impl PartialEq<[u8]> for Hash { + fn eq(&self, other: &[u8]) -> bool { + constant_time_eq::constant_time_eq(&self.as_bytes(), other) + } +} + +impl Eq for Hash {} + +impl AsRef<[u8]> for Hash { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +impl fmt::Debug for Hash { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Hash(0x{})", self.to_hex()) + } +} + +// Paint a byte pattern that won't repeat, so that we don't accidentally miss +// buffer offset bugs. This is the same as what Bao uses in its tests. +#[cfg(test)] +fn paint_test_input(buf: &mut [u8]) { + let mut offset = 0; + let mut counter: u32 = 1; + while offset < buf.len() { + let bytes = counter.to_le_bytes(); + let take = cmp::min(bytes.len(), buf.len() - offset); + buf[offset..][..take].copy_from_slice(&bytes[..take]); + counter += 1; + offset += take; + } +} + +// This module is pub for internal benchmarks only. Please don't use it. +#[doc(hidden)] +pub mod benchmarks { + use super::*; + + pub fn force_portable(params: &mut Params) { + params.implementation = guts::Implementation::portable(); + } + + pub fn force_portable_blake2bp(params: &mut blake2bp::Params) { + blake2bp::force_portable(params); + } +} diff --git a/src/plonk/blake2_const/blake2b/src/many.rs b/src/plonk/blake2_const/blake2b/src/many.rs new file mode 100644 index 000000000..1588a3fb9 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/many.rs @@ -0,0 +1,529 @@ +//! Interfaces for hashing multiple inputs at once, using SIMD more +//! efficiently. +//! +//! The throughput of these interfaces is comparable to BLAKE2bp, about twice +//! the throughput of regular BLAKE2b when AVX2 is available. +//! +//! These interfaces can accept any number of inputs, and the implementation +//! does its best to parallelize them. In general, the more inputs you can pass +//! in at once the better. If you need to batch your inputs in smaller groups, +//! see the [`degree`](fn.degree.html) function for a good batch size. +//! +//! The implementation keeps working in parallel even when inputs are of +//! different lengths, by managing a working set of jobs whose input isn't yet +//! exhausted. However, if one or two inputs are much longer than the others, +//! and they're encountered only at the end, there might not be any remaining +//! work to parallelize them with. In this case, sorting the inputs +//! longest-first can improve parallelism. +//! +//! # Example +//! +//! ``` +//! use blake2b_simd::{blake2b, State, many::update_many}; +//! +//! let mut states = [ +//! State::new(), +//! State::new(), +//! State::new(), +//! State::new(), +//! ]; +//! +//! let inputs = [ +//! &b"foo"[..], +//! &b"bar"[..], +//! &b"baz"[..], +//! &b"bing"[..], +//! ]; +//! +//! update_many(states.iter_mut().zip(inputs.iter())); +//! +//! for (state, input) in states.iter_mut().zip(inputs.iter()) { +//! assert_eq!(blake2b(input), state.finalize()); +//! } +//! ``` + +use crate::guts::{self, Finalize, Implementation, Job, LastNode, Stride}; +use crate::state_words_to_bytes; +use crate::Count; +use crate::Hash; +use crate::Params; +use crate::State; +use crate::Word; +use crate::BLOCKBYTES; +use arrayref::array_mut_ref; +use arrayvec::ArrayVec; +use core::fmt; + +/// The largest possible value of [`degree`](fn.degree.html) on the target +/// platform. +/// +/// Note that this constant reflects the parallelism degree supported by this +/// crate, so it will change over time as support is added or removed. For +/// example, when Rust stabilizes AVX-512 support and this crate adds an +/// AVX-512 implementation, this constant will double on x86 targets. If that +/// implementation is an optional feature (e.g. because it's nightly-only), the +/// value of this constant will depend on that optional feature also. +pub const MAX_DEGREE: usize = guts::MAX_DEGREE; + +/// The parallelism degree of the implementation, detected at runtime. If you +/// hash your inputs in small batches, making the batch size a multiple of +/// `degree` will generally give good performance. +/// +/// For example, an x86 processor that supports AVX2 can compute four BLAKE2b +/// hashes in parallel, so `degree` returns 4 on that machine. If you call +/// [`hash_many`] with only three inputs, that's not enough to use the AVX2 +/// implementation, and your average throughput will be lower. Likewise if you +/// call it with five inputs of equal length, the first four will be hashed in +/// parallel with AVX2, but the last one will have to be hashed by itself, and +/// again your average throughput will be lower. +/// +/// As noted in the module level docs, performance is more complicated if your +/// inputs are of different lengths. When parallelizing long and short inputs +/// together, the longer ones will have bytes left over, and the implementation +/// will try to parallelize those leftover bytes with subsequent inputs. The +/// more inputs available in that case, the more the implementation will be +/// able to parallelize. +/// +/// If you need a constant batch size, for example to collect inputs in an +/// array, see [`MAX_DEGREE`]. +/// +/// [`hash_many`]: fn.hash_many.html +/// [`MAX_DEGREE`]: constant.MAX_DEGREE.html +pub fn degree() -> usize { + guts::Implementation::detect().degree() +} + +type JobsVec<'a, 'b> = ArrayVec<[Job<'a, 'b>; guts::MAX_DEGREE]>; + +#[inline(always)] +fn fill_jobs_vec<'a, 'b>( + jobs_iter: &mut impl Iterator>, + vec: &mut JobsVec<'a, 'b>, + target_len: usize, +) { + while vec.len() < target_len { + if let Some(job) = jobs_iter.next() { + vec.push(job); + } else { + break; + } + } +} + +#[inline(always)] +fn evict_finished<'a, 'b>(vec: &mut JobsVec<'a, 'b>, num_jobs: usize) { + // Iterate backwards so that removal doesn't cause an out-of-bounds panic. + for i in (0..num_jobs).rev() { + // Note that is_empty() is only valid because we know all these jobs + // have been run at least once. Otherwise we could confuse the empty + // input for a finished job, which would be incorrect. + // + // Avoid a panic branch here in release mode. + debug_assert!(vec.len() > i); + if vec.len() > i && vec[i].input.is_empty() { + // Note that calling pop_at() repeatedly has some overhead, because + // later elements need to be shifted up. However, the JobsVec is + // small, and this approach guarantees that jobs are encountered in + // order. + vec.pop_at(i); + } + } +} + +pub(crate) fn compress_many<'a, 'b, I>( + jobs: I, + imp: Implementation, + finalize: Finalize, + stride: Stride, +) where + I: IntoIterator>, +{ + // Fuse is important for correctness, since each of these blocks tries to + // advance the iterator, even if a previous block emptied it. + let mut jobs_iter = jobs.into_iter().fuse(); + let mut jobs_vec = JobsVec::new(); + + if imp.degree() >= 4 { + loop { + fill_jobs_vec(&mut jobs_iter, &mut jobs_vec, 4); + if jobs_vec.len() < 4 { + break; + } + let jobs_array = array_mut_ref!(jobs_vec, 0, 4); + imp.compress4_loop(jobs_array, finalize, stride); + evict_finished(&mut jobs_vec, 4); + } + } + + if imp.degree() >= 2 { + loop { + fill_jobs_vec(&mut jobs_iter, &mut jobs_vec, 2); + if jobs_vec.len() < 2 { + break; + } + let jobs_array = array_mut_ref!(jobs_vec, 0, 2); + imp.compress2_loop(jobs_array, finalize, stride); + evict_finished(&mut jobs_vec, 2); + } + } + + for job in jobs_vec.into_iter().chain(jobs_iter) { + let Job { + input, + words, + count, + last_node, + } = job; + imp.compress1_loop(input, words, count, last_node, finalize, stride); + } +} + +/// Update any number of `State` objects at once. +/// +/// # Example +/// +/// ``` +/// use blake2b_simd::{blake2b, State, many::update_many}; +/// +/// let mut states = [ +/// State::new(), +/// State::new(), +/// State::new(), +/// State::new(), +/// ]; +/// +/// let inputs = [ +/// &b"foo"[..], +/// &b"bar"[..], +/// &b"baz"[..], +/// &b"bing"[..], +/// ]; +/// +/// update_many(states.iter_mut().zip(inputs.iter())); +/// +/// for (state, input) in states.iter_mut().zip(inputs.iter()) { +/// assert_eq!(blake2b(input), state.finalize()); +/// } +/// ``` +pub fn update_many<'a, 'b, I, T>(pairs: I) +where + I: IntoIterator, + T: 'b + AsRef<[u8]> + ?Sized, +{ + // Get the guts::Implementation from the first state, if any. + let mut peekable_pairs = pairs.into_iter().peekable(); + let implementation = if let Some((state, _)) = peekable_pairs.peek() { + state.implementation + } else { + // No work items, just short circuit. + return; + }; + + // Adapt the pairs iterator into a Jobs iterator, but skip over the Jobs + // where there's not actually any work to do (e.g. because there's not much + // input and it's all just going in the State buffer). + let jobs = peekable_pairs.flat_map(|(state, input_t)| { + let mut input = input_t.as_ref(); + // For each pair, if the State has some input in its buffer, try to + // finish that buffer. If there wasn't enough input to do that -- + // or if the input was empty to begin with -- skip this pair. + state.compress_buffer_if_possible(&mut input); + if input.is_empty() { + return None; + } + // Now we know the buffer is empty and there's more input. Make sure we + // buffer the final block, because update() doesn't finalize. + let mut last_block_start = input.len() - 1; + last_block_start -= last_block_start % BLOCKBYTES; + let (blocks, last_block) = input.split_at(last_block_start); + state.buf[..last_block.len()].copy_from_slice(last_block); + state.buflen = last_block.len() as u8; + // Finally, if the full blocks slice is non-empty, prepare that job for + // compression, and bump the State count. + if blocks.is_empty() { + None + } else { + let count = state.count; + state.count = state.count.wrapping_add(blocks.len() as Count); + Some(Job { + input: blocks, + words: &mut state.words, + count, + last_node: state.last_node, + }) + } + }); + + // Run all the Jobs in the iterator. + compress_many(jobs, implementation, Finalize::No, Stride::Serial); +} + +/// A job for the [`hash_many`] function. After calling [`hash_many`] on a +/// collection of `HashManyJob` objects, you can call [`to_hash`] on each job +/// to get the result. +/// +/// [`hash_many`]: fn.hash_many.html +/// [`to_hash`]: struct.HashManyJob.html#method.to_hash +#[derive(Clone)] +pub struct HashManyJob<'a> { + words: [Word; 8], + count: Count, + last_node: LastNode, + hash_length: u8, + input: &'a [u8], + finished: bool, + implementation: guts::Implementation, +} + +impl<'a> HashManyJob<'a> { + /// Construct a new `HashManyJob` from a set of hashing parameters and an + /// input. + #[inline] + pub fn new(params: &Params, input: &'a [u8]) -> Self { + let mut words = params.to_words(); + let mut count = 0; + let mut finished = false; + // If we have key bytes, compress them into the state words. If there's + // no additional input, this compression needs to finalize and set + // finished=true. + if params.key_length > 0 { + let mut finalization = Finalize::No; + if input.is_empty() { + finalization = Finalize::Yes; + finished = true; + } + params.implementation.compress1_loop( + ¶ms.key_block, + &mut words, + 0, + params.last_node, + finalization, + Stride::Serial, + ); + count = BLOCKBYTES as Count; + } + Self { + words, + count, + last_node: params.last_node, + hash_length: params.hash_length, + input, + finished, + implementation: params.implementation, + } + } + + /// Get the hash from a finished job. If you call this before calling + /// [`hash_many`], it will panic in debug mode. + /// + /// [`hash_many`]: fn.hash_many.html + #[inline] + pub fn to_hash(&self) -> Hash { + debug_assert!(self.finished, "job hasn't been run yet"); + Hash { + bytes: state_words_to_bytes(&self.words), + len: self.hash_length, + } + } +} + +impl<'a> fmt::Debug for HashManyJob<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "HashManyJob {{ count: {}, hash_length: {}, last_node: {}, input_len: {} }}", + self.count, + self.hash_length, + self.last_node.yes(), + self.input.len(), + ) + } +} + +/// Hash any number of complete inputs all at once. +/// +/// This is slightly more efficient than using `update_many` with `State` +/// objects, because it doesn't need to do any buffering. +/// +/// Running `hash_many` on the same `HashManyJob` object more than once has no +/// effect. +/// +/// # Example +/// +/// ``` +/// use blake2b_simd::{blake2b, Params, many::{HashManyJob, hash_many}}; +/// +/// let inputs = [ +/// &b"foo"[..], +/// &b"bar"[..], +/// &b"baz"[..], +/// &b"bing"[..], +/// ]; +/// +/// let mut params = Params::new(); +/// params.hash_length(16); +/// +/// let mut jobs = [ +/// HashManyJob::new(¶ms, inputs[0]), +/// HashManyJob::new(¶ms, inputs[1]), +/// HashManyJob::new(¶ms, inputs[2]), +/// HashManyJob::new(¶ms, inputs[3]), +/// ]; +/// +/// hash_many(jobs.iter_mut()); +/// +/// for (input, job) in inputs.iter().zip(jobs.iter()) { +/// let expected = params.hash(input); +/// assert_eq!(expected, job.to_hash()); +/// } +/// ``` +pub fn hash_many<'a, 'b, I>(hash_many_jobs: I) +where + 'b: 'a, + I: IntoIterator>, +{ + // Get the guts::Implementation from the first job, if any. + let mut peekable_jobs = hash_many_jobs.into_iter().peekable(); + let implementation = if let Some(job) = peekable_jobs.peek() { + job.implementation + } else { + // No work items, just short circuit. + return; + }; + + // In the jobs iterator, skip HashManyJobs that have already been run. This + // is less because we actually expect callers to call hash_many twice + // (though they're allowed to if they want), and more because + // HashManyJob::new might need to finalize if there are key bytes but no + // input. Tying the job lifetime to the Params reference is an alternative, + // but I've found it too constraining in practice. We could also put key + // bytes in every HashManyJob, but that would add unnecessary storage and + // zeroing for all callers. + let unfinished_jobs = peekable_jobs.into_iter().filter(|j| !j.finished); + let jobs = unfinished_jobs.map(|j| { + j.finished = true; + Job { + input: j.input, + words: &mut j.words, + count: j.count, + last_node: j.last_node, + } + }); + compress_many(jobs, implementation, Finalize::Yes, Stride::Serial); +} + +#[cfg(test)] +mod test { + use super::*; + use crate::guts; + use crate::paint_test_input; + use crate::BLOCKBYTES; + use arrayvec::ArrayVec; + + #[test] + fn test_degree() { + assert!(degree() <= MAX_DEGREE); + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("avx2") { + assert!(degree() >= 4); + } + if is_x86_feature_detected!("sse4.1") { + assert!(degree() >= 2); + } + } + } + + #[test] + fn test_hash_many() { + // Use a length of inputs that will exercise all of the power-of-two loops. + const LEN: usize = 2 * guts::MAX_DEGREE - 1; + + // Rerun LEN inputs LEN different times, with the empty input starting in a + // different spot each time. + let mut input = [0; LEN * BLOCKBYTES]; + paint_test_input(&mut input); + for start_offset in 0..LEN { + let mut inputs: [&[u8]; LEN] = [&[]; LEN]; + for i in 0..LEN { + let chunks = (i + start_offset) % LEN; + inputs[i] = &input[..chunks * BLOCKBYTES]; + } + + let mut params: ArrayVec<[Params; LEN]> = ArrayVec::new(); + for i in 0..LEN { + let mut p = Params::new(); + p.node_offset(i as u64); + if i % 2 == 1 { + p.last_node(true); + p.key(b"foo"); + } + params.push(p); + } + + let mut jobs: ArrayVec<[HashManyJob; LEN]> = ArrayVec::new(); + for i in 0..LEN { + jobs.push(HashManyJob::new(¶ms[i], inputs[i])); + } + + hash_many(&mut jobs); + + // Check the outputs. + for i in 0..LEN { + let expected = params[i].hash(inputs[i]); + assert_eq!(expected, jobs[i].to_hash()); + } + } + } + + #[test] + fn test_update_many() { + // Use a length of inputs that will exercise all of the power-of-two loops. + const LEN: usize = 2 * guts::MAX_DEGREE - 1; + + // Rerun LEN inputs LEN different times, with the empty input starting in a + // different spot each time. + let mut input = [0; LEN * BLOCKBYTES]; + paint_test_input(&mut input); + for start_offset in 0..LEN { + let mut inputs: [&[u8]; LEN] = [&[]; LEN]; + for i in 0..LEN { + let chunks = (i + start_offset) % LEN; + inputs[i] = &input[..chunks * BLOCKBYTES]; + } + + let mut params: ArrayVec<[Params; LEN]> = ArrayVec::new(); + for i in 0..LEN { + let mut p = Params::new(); + p.node_offset(i as u64); + if i % 2 == 1 { + p.last_node(true); + p.key(b"foo"); + } + params.push(p); + } + + let mut states: ArrayVec<[State; LEN]> = ArrayVec::new(); + for i in 0..LEN { + states.push(params[i].to_state()); + } + + // Run each input twice through, to exercise buffering. + update_many(states.iter_mut().zip(inputs.iter())); + update_many(states.iter_mut().zip(inputs.iter())); + + // Check the outputs. + for i in 0..LEN { + let mut reference_state = params[i].to_state(); + // Again, run the input twice. + reference_state.update(inputs[i]); + reference_state.update(inputs[i]); + assert_eq!(reference_state.finalize(), states[i].finalize()); + assert_eq!(2 * inputs[i].len() as Count, states[i].count()); + } + } + } +} diff --git a/src/plonk/blake2_const/blake2b/src/portable.rs b/src/plonk/blake2_const/blake2b/src/portable.rs new file mode 100644 index 000000000..5a667ef2a --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/portable.rs @@ -0,0 +1,166 @@ +use arrayref::{array_ref, array_refs}; + +use super::*; +use crate::guts::{ + count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, LastNode, Stride, +}; + +// G is the mixing function, called eight times per round in the compression +// function. V is the 16-word state vector of the compression function, usually +// described as a 4x4 matrix. A, B, C, and D are the mixing indices, set by the +// caller first to the four columns of V, and then to its four diagonals. X and +// Y are words of input, chosen by the caller according to the message +// schedule, SIGMA. +#[inline(always)] +fn g(v: &mut [Word; 16], a: usize, b: usize, c: usize, d: usize, x: Word, y: Word) { + v[a] = v[a].wrapping_add(v[b]).wrapping_add(x); + v[d] = (v[d] ^ v[a]).rotate_right(32); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(24); + v[a] = v[a].wrapping_add(v[b]).wrapping_add(y); + v[d] = (v[d] ^ v[a]).rotate_right(16); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(63); +} + +#[inline(always)] +fn round(r: usize, m: &[Word; 16], v: &mut [Word; 16]) { + // Select the message schedule based on the round. + let s = SIGMA[r]; + + // Mix the columns. + g(v, 0, 4, 8, 12, m[s[0] as usize], m[s[1] as usize]); + g(v, 1, 5, 9, 13, m[s[2] as usize], m[s[3] as usize]); + g(v, 2, 6, 10, 14, m[s[4] as usize], m[s[5] as usize]); + g(v, 3, 7, 11, 15, m[s[6] as usize], m[s[7] as usize]); + + // Mix the rows. + g(v, 0, 5, 10, 15, m[s[8] as usize], m[s[9] as usize]); + g(v, 1, 6, 11, 12, m[s[10] as usize], m[s[11] as usize]); + g(v, 2, 7, 8, 13, m[s[12] as usize], m[s[13] as usize]); + g(v, 3, 4, 9, 14, m[s[14] as usize], m[s[15] as usize]); +} + +#[inline(always)] +fn compress_block( + block: &[u8; BLOCKBYTES], + words: &mut [Word; 8], + count: Count, + last_block: Word, + last_node: Word, +) { + // Initialize the compression state. + let mut v = [ + words[0], + words[1], + words[2], + words[3], + words[4], + words[5], + words[6], + words[7], + IV[0], + IV[1], + IV[2], + IV[3], + IV[4] ^ count_low(count), + IV[5] ^ count_high(count), + IV[6] ^ last_block, + IV[7] ^ last_node, + ]; + + // Parse the message bytes as ints in little endian order. + const W: usize = size_of::(); + let msg_refs = array_refs!(block, W, W, W, W, W, W, W, W, W, W, W, W, W, W, W, W); + let m = [ + Word::from_le_bytes(*msg_refs.0), + Word::from_le_bytes(*msg_refs.1), + Word::from_le_bytes(*msg_refs.2), + Word::from_le_bytes(*msg_refs.3), + Word::from_le_bytes(*msg_refs.4), + Word::from_le_bytes(*msg_refs.5), + Word::from_le_bytes(*msg_refs.6), + Word::from_le_bytes(*msg_refs.7), + Word::from_le_bytes(*msg_refs.8), + Word::from_le_bytes(*msg_refs.9), + Word::from_le_bytes(*msg_refs.10), + Word::from_le_bytes(*msg_refs.11), + Word::from_le_bytes(*msg_refs.12), + Word::from_le_bytes(*msg_refs.13), + Word::from_le_bytes(*msg_refs.14), + Word::from_le_bytes(*msg_refs.15), + ]; + + round(0, &m, &mut v); + round(1, &m, &mut v); + round(2, &m, &mut v); + round(3, &m, &mut v); + round(4, &m, &mut v); + round(5, &m, &mut v); + round(6, &m, &mut v); + round(7, &m, &mut v); + round(8, &m, &mut v); + round(9, &m, &mut v); + round(10, &m, &mut v); + round(11, &m, &mut v); + + words[0] ^= v[0] ^ v[8]; + words[1] ^= v[1] ^ v[9]; + words[2] ^= v[2] ^ v[10]; + words[3] ^= v[3] ^ v[11]; + words[4] ^= v[4] ^ v[12]; + words[5] ^= v[5] ^ v[13]; + words[6] ^= v[6] ^ v[14]; + words[7] ^= v[7] ^ v[15]; +} + +pub fn compress1_loop( + input: &[u8], + words: &mut [Word; 8], + mut count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, +) { + input_debug_asserts(input, finalize); + + let mut local_words = *words; + + let mut fin_offset = input.len().saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + let mut buf = [0; BLOCKBYTES]; + let (fin_block, fin_len, _) = final_block(input, fin_offset, &mut buf, stride); + let fin_last_block = flag_word(finalize.yes()); + let fin_last_node = flag_word(finalize.yes() && last_node.yes()); + + let mut offset = 0; + loop { + let block; + let count_delta; + let last_block; + let last_node; + if offset == fin_offset { + block = fin_block; + count_delta = fin_len; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + block = array_ref!(input, offset, BLOCKBYTES); + count_delta = BLOCKBYTES; + last_block = flag_word(false); + last_node = flag_word(false); + }; + + count = count.wrapping_add(count_delta as Count); + compress_block(block, &mut local_words, count, last_block, last_node); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + *words = local_words; +} diff --git a/src/plonk/blake2_const/blake2b/src/sse41.rs b/src/plonk/blake2_const/blake2b/src/sse41.rs new file mode 100644 index 000000000..3a55dc8c3 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/sse41.rs @@ -0,0 +1,454 @@ +#[cfg(target_arch = "x86")] +use core::arch::x86::*; +#[cfg(target_arch = "x86_64")] +use core::arch::x86_64::*; + +use crate::guts::{ + assemble_count, count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, + Job, Stride, +}; +use crate::{Word, BLOCKBYTES, IV, SIGMA}; +use arrayref::{array_refs, mut_array_refs}; +use core::cmp; +use core::mem; + +pub const DEGREE: usize = 2; + +#[inline(always)] +unsafe fn loadu(src: *const [Word; DEGREE]) -> __m128i { + // This is an unaligned load, so the pointer cast is allowed. + _mm_loadu_si128(src as *const __m128i) +} + +#[inline(always)] +unsafe fn storeu(src: __m128i, dest: *mut [Word; DEGREE]) { + // This is an unaligned store, so the pointer cast is allowed. + _mm_storeu_si128(dest as *mut __m128i, src) +} + +#[inline(always)] +unsafe fn add(a: __m128i, b: __m128i) -> __m128i { + _mm_add_epi64(a, b) +} + +#[inline(always)] +unsafe fn eq(a: __m128i, b: __m128i) -> __m128i { + _mm_cmpeq_epi64(a, b) +} + +#[inline(always)] +unsafe fn and(a: __m128i, b: __m128i) -> __m128i { + _mm_and_si128(a, b) +} + +#[inline(always)] +unsafe fn negate_and(a: __m128i, b: __m128i) -> __m128i { + // Note that "and not" implies the reverse of the actual arg order. + _mm_andnot_si128(a, b) +} + +#[inline(always)] +unsafe fn xor(a: __m128i, b: __m128i) -> __m128i { + _mm_xor_si128(a, b) +} + +#[inline(always)] +unsafe fn set1(x: u64) -> __m128i { + _mm_set1_epi64x(x as i64) +} + +#[inline(always)] +unsafe fn set2(a: u64, b: u64) -> __m128i { + // There's no _mm_setr_epi64x, so note the arg order is backwards. + _mm_set_epi64x(b as i64, a as i64) +} + +// Adapted from https://github.com/rust-lang-nursery/stdsimd/pull/479. +macro_rules! _MM_SHUFFLE { + ($z:expr, $y:expr, $x:expr, $w:expr) => { + ($z << 6) | ($y << 4) | ($x << 2) | $w + }; +} + +#[inline(always)] +unsafe fn rot32(x: __m128i) -> __m128i { + _mm_shuffle_epi32(x, _MM_SHUFFLE!(2, 3, 0, 1)) +} + +#[inline(always)] +unsafe fn rot24(x: __m128i) -> __m128i { + let rotate24 = _mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10); + _mm_shuffle_epi8(x, rotate24) +} + +#[inline(always)] +unsafe fn rot16(x: __m128i) -> __m128i { + let rotate16 = _mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9); + _mm_shuffle_epi8(x, rotate16) +} + +#[inline(always)] +unsafe fn rot63(x: __m128i) -> __m128i { + _mm_or_si128(_mm_srli_epi64(x, 63), add(x, x)) +} + +#[inline(always)] +unsafe fn round(v: &mut [__m128i; 16], m: &[__m128i; 16], r: usize) { + v[0] = add(v[0], m[SIGMA[r][0] as usize]); + v[1] = add(v[1], m[SIGMA[r][2] as usize]); + v[2] = add(v[2], m[SIGMA[r][4] as usize]); + v[3] = add(v[3], m[SIGMA[r][6] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot32(v[12]); + v[13] = rot32(v[13]); + v[14] = rot32(v[14]); + v[15] = rot32(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot24(v[4]); + v[5] = rot24(v[5]); + v[6] = rot24(v[6]); + v[7] = rot24(v[7]); + v[0] = add(v[0], m[SIGMA[r][1] as usize]); + v[1] = add(v[1], m[SIGMA[r][3] as usize]); + v[2] = add(v[2], m[SIGMA[r][5] as usize]); + v[3] = add(v[3], m[SIGMA[r][7] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[15] = rot16(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot63(v[4]); + v[5] = rot63(v[5]); + v[6] = rot63(v[6]); + v[7] = rot63(v[7]); + + v[0] = add(v[0], m[SIGMA[r][8] as usize]); + v[1] = add(v[1], m[SIGMA[r][10] as usize]); + v[2] = add(v[2], m[SIGMA[r][12] as usize]); + v[3] = add(v[3], m[SIGMA[r][14] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot32(v[15]); + v[12] = rot32(v[12]); + v[13] = rot32(v[13]); + v[14] = rot32(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot24(v[5]); + v[6] = rot24(v[6]); + v[7] = rot24(v[7]); + v[4] = rot24(v[4]); + v[0] = add(v[0], m[SIGMA[r][9] as usize]); + v[1] = add(v[1], m[SIGMA[r][11] as usize]); + v[2] = add(v[2], m[SIGMA[r][13] as usize]); + v[3] = add(v[3], m[SIGMA[r][15] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot16(v[15]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot63(v[5]); + v[6] = rot63(v[6]); + v[7] = rot63(v[7]); + v[4] = rot63(v[4]); +} + +// We'd rather make this a regular function with #[inline(always)], but for +// some reason that blows up compile times by about 10 seconds, at least in +// some cases (BLAKE2b avx2.rs). This macro seems to get the same performance +// result, without the compile time issue. +macro_rules! compress2_transposed { + ( + $h_vecs:expr, + $msg_vecs:expr, + $count_low:expr, + $count_high:expr, + $lastblock:expr, + $lastnode:expr, + ) => { + let h_vecs: &mut [__m128i; 8] = $h_vecs; + let msg_vecs: &[__m128i; 16] = $msg_vecs; + let count_low: __m128i = $count_low; + let count_high: __m128i = $count_high; + let lastblock: __m128i = $lastblock; + let lastnode: __m128i = $lastnode; + let mut v = [ + h_vecs[0], + h_vecs[1], + h_vecs[2], + h_vecs[3], + h_vecs[4], + h_vecs[5], + h_vecs[6], + h_vecs[7], + set1(IV[0]), + set1(IV[1]), + set1(IV[2]), + set1(IV[3]), + xor(set1(IV[4]), count_low), + xor(set1(IV[5]), count_high), + xor(set1(IV[6]), lastblock), + xor(set1(IV[7]), lastnode), + ]; + + round(&mut v, &msg_vecs, 0); + round(&mut v, &msg_vecs, 1); + round(&mut v, &msg_vecs, 2); + round(&mut v, &msg_vecs, 3); + round(&mut v, &msg_vecs, 4); + round(&mut v, &msg_vecs, 5); + round(&mut v, &msg_vecs, 6); + round(&mut v, &msg_vecs, 7); + round(&mut v, &msg_vecs, 8); + round(&mut v, &msg_vecs, 9); + round(&mut v, &msg_vecs, 10); + round(&mut v, &msg_vecs, 11); + + h_vecs[0] = xor(xor(h_vecs[0], v[0]), v[8]); + h_vecs[1] = xor(xor(h_vecs[1], v[1]), v[9]); + h_vecs[2] = xor(xor(h_vecs[2], v[2]), v[10]); + h_vecs[3] = xor(xor(h_vecs[3], v[3]), v[11]); + h_vecs[4] = xor(xor(h_vecs[4], v[4]), v[12]); + h_vecs[5] = xor(xor(h_vecs[5], v[5]), v[13]); + h_vecs[6] = xor(xor(h_vecs[6], v[6]), v[14]); + h_vecs[7] = xor(xor(h_vecs[7], v[7]), v[15]); + }; +} + +#[inline(always)] +unsafe fn transpose_vecs(a: __m128i, b: __m128i) -> [__m128i; DEGREE] { + let a_words: [Word; DEGREE] = mem::transmute(a); + let b_words: [Word; DEGREE] = mem::transmute(b); + [set2(a_words[0], b_words[0]), set2(a_words[1], b_words[1])] +} + +#[inline(always)] +unsafe fn transpose_state_vecs(jobs: &[Job; DEGREE]) -> [__m128i; 8] { + // Load all the state words into transposed vectors, where the first vector + // has the first word of each state, etc. Transposing once at the beginning + // and once at the end is more efficient that repeating it for each block. + let words0 = array_refs!(&jobs[0].words, DEGREE, DEGREE, DEGREE, DEGREE); + let words1 = array_refs!(&jobs[1].words, DEGREE, DEGREE, DEGREE, DEGREE); + let [h0, h1] = transpose_vecs(loadu(words0.0), loadu(words1.0)); + let [h2, h3] = transpose_vecs(loadu(words0.1), loadu(words1.1)); + let [h4, h5] = transpose_vecs(loadu(words0.2), loadu(words1.2)); + let [h6, h7] = transpose_vecs(loadu(words0.3), loadu(words1.3)); + [h0, h1, h2, h3, h4, h5, h6, h7] +} + +#[inline(always)] +unsafe fn untranspose_state_vecs(h_vecs: &[__m128i; 8], jobs: &mut [Job; DEGREE]) { + // Un-transpose the updated state vectors back into the caller's arrays. + let [job0, job1] = jobs; + let words0 = mut_array_refs!(&mut job0.words, DEGREE, DEGREE, DEGREE, DEGREE); + let words1 = mut_array_refs!(&mut job1.words, DEGREE, DEGREE, DEGREE, DEGREE); + + let out = transpose_vecs(h_vecs[0], h_vecs[1]); + storeu(out[0], words0.0); + storeu(out[1], words1.0); + let out = transpose_vecs(h_vecs[2], h_vecs[3]); + storeu(out[0], words0.1); + storeu(out[1], words1.1); + let out = transpose_vecs(h_vecs[4], h_vecs[5]); + storeu(out[0], words0.2); + storeu(out[1], words1.2); + let out = transpose_vecs(h_vecs[6], h_vecs[7]); + storeu(out[0], words0.3); + storeu(out[1], words1.3); +} + +#[inline(always)] +unsafe fn transpose_msg_vecs(blocks: [*const [u8; BLOCKBYTES]; DEGREE]) -> [__m128i; 16] { + // These input arrays have no particular alignment, so we use unaligned + // loads to read from them. + let block0 = blocks[0] as *const [Word; DEGREE]; + let block1 = blocks[1] as *const [Word; DEGREE]; + let [m0, m1] = transpose_vecs(loadu(block0.add(0)), loadu(block1.add(0))); + let [m2, m3] = transpose_vecs(loadu(block0.add(1)), loadu(block1.add(1))); + let [m4, m5] = transpose_vecs(loadu(block0.add(2)), loadu(block1.add(2))); + let [m6, m7] = transpose_vecs(loadu(block0.add(3)), loadu(block1.add(3))); + let [m8, m9] = transpose_vecs(loadu(block0.add(4)), loadu(block1.add(4))); + let [m10, m11] = transpose_vecs(loadu(block0.add(5)), loadu(block1.add(5))); + let [m12, m13] = transpose_vecs(loadu(block0.add(6)), loadu(block1.add(6))); + let [m14, m15] = transpose_vecs(loadu(block0.add(7)), loadu(block1.add(7))); + [ + m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, + ] +} + +#[inline(always)] +unsafe fn load_counts(jobs: &[Job; DEGREE]) -> (__m128i, __m128i) { + ( + set2(count_low(jobs[0].count), count_low(jobs[1].count)), + set2(count_high(jobs[0].count), count_high(jobs[1].count)), + ) +} + +#[inline(always)] +unsafe fn store_counts(jobs: &mut [Job; DEGREE], low: __m128i, high: __m128i) { + let low_ints: [Word; DEGREE] = mem::transmute(low); + let high_ints: [Word; DEGREE] = mem::transmute(high); + for i in 0..DEGREE { + jobs[i].count = assemble_count(low_ints[i], high_ints[i]); + } +} + +#[inline(always)] +unsafe fn add_to_counts(lo: &mut __m128i, hi: &mut __m128i, delta: __m128i) { + // If the low counts reach zero, that means they wrapped, unless the delta + // was also zero. + *lo = add(*lo, delta); + let lo_reached_zero = eq(*lo, set1(0)); + let delta_was_zero = eq(delta, set1(0)); + let hi_inc = and(set1(1), negate_and(delta_was_zero, lo_reached_zero)); + *hi = add(*hi, hi_inc); +} + +#[inline(always)] +unsafe fn flags_vec(flags: [bool; DEGREE]) -> __m128i { + set2(flag_word(flags[0]), flag_word(flags[1])) +} + +#[target_feature(enable = "sse4.1")] +pub unsafe fn compress2_loop(jobs: &mut [Job; DEGREE], finalize: Finalize, stride: Stride) { + // If we're not finalizing, there can't be a partial block at the end. + for job in jobs.iter() { + input_debug_asserts(job.input, finalize); + } + + let msg_ptrs = [jobs[0].input.as_ptr(), jobs[1].input.as_ptr()]; + let mut h_vecs = transpose_state_vecs(&jobs); + let (mut counts_lo, mut counts_hi) = load_counts(&jobs); + + // Prepare the final blocks (note, which could be empty if the input is + // empty). Do all this before entering the main loop. + let min_len = jobs.iter().map(|job| job.input.len()).min().unwrap(); + let mut fin_offset = min_len.saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + // Performance note, making these buffers mem::uninitialized() seems to + // cause problems in the optimizer. + let mut buf0: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf1: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let (block0, len0, finalize0) = final_block(jobs[0].input, fin_offset, &mut buf0, stride); + let (block1, len1, finalize1) = final_block(jobs[1].input, fin_offset, &mut buf1, stride); + let fin_blocks: [*const [u8; BLOCKBYTES]; DEGREE] = [block0, block1]; + let fin_counts_delta = set2(len0 as Word, len1 as Word); + let fin_last_block; + let fin_last_node; + if finalize.yes() { + fin_last_block = flags_vec([finalize0, finalize1]); + fin_last_node = flags_vec([ + finalize0 && jobs[0].last_node.yes(), + finalize1 && jobs[1].last_node.yes(), + ]); + } else { + fin_last_block = set1(0); + fin_last_node = set1(0); + } + + // The main loop. + let mut offset = 0; + loop { + let blocks; + let counts_delta; + let last_block; + let last_node; + if offset == fin_offset { + blocks = fin_blocks; + counts_delta = fin_counts_delta; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + blocks = [ + msg_ptrs[0].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[1].add(offset) as *const [u8; BLOCKBYTES], + ]; + counts_delta = set1(BLOCKBYTES as Word); + last_block = set1(0); + last_node = set1(0); + }; + + let m_vecs = transpose_msg_vecs(blocks); + add_to_counts(&mut counts_lo, &mut counts_hi, counts_delta); + compress2_transposed!( + &mut h_vecs, + &m_vecs, + counts_lo, + counts_hi, + last_block, + last_node, + ); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + // Write out the results. + untranspose_state_vecs(&h_vecs, &mut *jobs); + store_counts(&mut *jobs, counts_lo, counts_hi); + let max_consumed = offset.saturating_add(stride.padded_blockbytes()); + for job in jobs.iter_mut() { + let consumed = cmp::min(max_consumed, job.input.len()); + job.input = &job.input[consumed..]; + } +} diff --git a/src/plonk/blake2_const/blake2b/src/test.rs b/src/plonk/blake2_const/blake2b/src/test.rs new file mode 100644 index 000000000..9ca8e8775 --- /dev/null +++ b/src/plonk/blake2_const/blake2b/src/test.rs @@ -0,0 +1,201 @@ +use super::*; + +const EMPTY_HASH: &str = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419\ + d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce"; +const ABC_HASH: &str = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d1\ + 7d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923"; +const ONE_BLOCK_HASH: &str = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf7\ + 98e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41"; +const THOUSAND_HASH: &str = "1ee4e51ecab5210a518f26150e882627ec839967f19d763e1508b12cfefed148\ + 58f6a1c9d1f969bc224dc9440f5a6955277e755b9c513f9ba4421c5e50c8d787"; + +#[test] +fn test_update_state() { + let io = &[ + (&b""[..], EMPTY_HASH), + (&b"abc"[..], ABC_HASH), + (&[0; BLOCKBYTES], ONE_BLOCK_HASH), + (&[0; 1000], THOUSAND_HASH), + ]; + // Test each input all at once. + for &(input, output) in io { + let hash = blake2b(input); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } + // Now in two chunks. This is especially important for the ONE_BLOCK case, because it would be + // a mistake for update() to call compress, even though the buffer is full. + for &(input, output) in io { + let mut state = State::new(); + let split = input.len() / 2; + state.update(&input[..split]); + assert_eq!(split as Count, state.count()); + state.update(&input[split..]); + assert_eq!(input.len() as Count, state.count()); + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } + // Now one byte at a time. + for &(input, output) in io { + let mut state = State::new(); + let mut count = 0; + for &b in input { + state.update(&[b]); + count += 1; + assert_eq!(count, state.count()); + } + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } +} + +#[test] +fn test_multiple_finalizes() { + let mut state = State::new(); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + state.update(b"abc"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); +} + +#[cfg(feature = "std")] +#[test] +fn test_write() { + use std::io::prelude::*; + + let mut state = State::new(); + state.write_all(&[0; 1000]).unwrap(); + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), THOUSAND_HASH, "hash mismatch"); +} + +// You can check this case against the equivalent Python: +// +// import hashlib +// hashlib.blake2b( +// b'foo', +// digest_size=18, +// key=b"bar", +// salt=b"bazbazbazbazbazb", +// person=b"bing bing bing b", +// fanout=2, +// depth=3, +// leaf_size=0x04050607, +// node_offset=0x08090a0b0c0d0e0f, +// node_depth=16, +// inner_size=17, +// last_node=True, +// ).hexdigest() +#[test] +fn test_all_parameters() { + let mut params = Params::new(); + params + .hash_length(18) + // Make sure a shorter key properly overwrites a longer one. + .key(b"not the real key") + .key(b"bar") + .salt(b"bazbazbazbazbazb") + .personal(b"bing bing bing b") + .fanout(2) + .max_depth(3) + .max_leaf_length(0x04050607) + .node_offset(0x08090a0b0c0d0e0f) + .node_depth(16) + .inner_hash_length(17) + .last_node(true); + + // Check the State API. + assert_eq!( + "ec0f59cb65f92e7fcca1280ba859a6925ded", + ¶ms.to_state().update(b"foo").finalize().to_hex() + ); + + // Check the all-at-once API. + assert_eq!( + "ec0f59cb65f92e7fcca1280ba859a6925ded", + ¶ms.hash(b"foo").to_hex() + ); +} + +#[test] +fn test_all_parameters_blake2bp() { + let mut params = blake2bp::Params::new(); + params + .hash_length(18) + // Make sure a shorter key properly overwrites a longer one. + .key(b"not the real key") + .key(b"bar"); + + // Check the State API. + assert_eq!( + "8c54e888a8a01c63da6585c058fe54ea81df", + ¶ms.to_state().update(b"foo").finalize().to_hex() + ); + + // Check the all-at-once API. + assert_eq!( + "8c54e888a8a01c63da6585c058fe54ea81df", + ¶ms.hash(b"foo").to_hex() + ); +} + +#[test] +#[should_panic] +fn test_short_hash_length_panics() { + Params::new().hash_length(0); +} + +#[test] +#[should_panic] +fn test_long_hash_length_panics() { + Params::new().hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_long_key_panics() { + Params::new().key(&[0; KEYBYTES + 1]); +} + +#[test] +#[should_panic] +fn test_long_salt_panics() { + Params::new().salt(&[0; SALTBYTES + 1]); +} + +#[test] +#[should_panic] +fn test_long_personal_panics() { + Params::new().personal(&[0; PERSONALBYTES + 1]); +} + +#[test] +fn test_zero_max_depth_supported() { + Params::new().max_depth(0); +} + +#[test] +#[should_panic] +fn test_long_inner_hash_length_panics() { + Params::new().inner_hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_blake2bp_short_hash_length_panics() { + blake2bp::Params::new().hash_length(0); +} + +#[test] +#[should_panic] +fn test_blake2bp_long_hash_length_panics() { + blake2bp::Params::new().hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_blake2bp_long_key_panics() { + blake2bp::Params::new().key(&[0; KEYBYTES + 1]); +} diff --git a/src/plonk/blake2_const/blake2s/Cargo.toml b/src/plonk/blake2_const/blake2s/Cargo.toml new file mode 100644 index 000000000..c566b79b7 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "blake2s_const" +version = "0.6.0" +authors = ["Jack O'Connor"] +description = "a pure Rust BLAKE2s implementation with dynamic SIMD" +license = "MIT" +repository = "https://github.com/oconnor663/blake2_simd" +documentation = "https://docs.rs/blake2s_simd" +readme = "README.md" +edition = "2018" + +[features] +default = ["std"] +std = [] + +[dependencies] +arrayref = "0.3.5" +arrayvec = { version = "0.5.0", default-features = false } +constant_time_eq = "0.1.3" diff --git a/src/plonk/blake2_const/blake2s/README.md b/src/plonk/blake2_const/blake2s/README.md new file mode 100644 index 000000000..9c6b6d2e9 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/README.md @@ -0,0 +1,41 @@ +# blake2s_simd [![GitHub](https://img.shields.io/github/tag/oconnor663/blake2_simd.svg?label=GitHub)](https://github.com/oconnor663/blake2_simd) [![crates.io](https://img.shields.io/crates/v/blake2s_simd.svg)](https://crates.io/crates/blake2s_simd) [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) + +An implementation of the BLAKE2s and BLAKE2sp hash functions. See also +[`blake2b_simd`](../blake2b). + +This crate includes: + +- 100% stable Rust. +- SIMD implementations based on Samuel Neves' [`blake2-avx2`](https://github.com/sneves/blake2-avx2). + These are very fast. For benchmarks, see [the Performance section of the + README](https://github.com/oconnor663/blake2_simd#performance). +- Portable, safe implementations for other platforms. +- Dynamic CPU feature detection. Binaries include multiple implementations by default and + choose the fastest one the processor supports at runtime. +- All the features from the [the BLAKE2 spec](https://blake2.net/blake2.pdf), like adjustable + length, keying, and associated data for tree hashing. +- `no_std` support. The `std` Cargo feature is on by default, for CPU feature detection and + for implementing `std::io::Write`. +- Support for computing multiple BLAKE2s hashes in parallel, matching the efficiency of + BLAKE2sp. See the [`many`](many/index.html) module. + +# Example + +``` +use blake2s_simd::{blake2s, Params}; + +let expected = "08d6cad88075de8f192db097573d0e829411cd91eb6ec65e8fc16c017edfdb74"; +let hash = blake2s(b"foo"); +assert_eq!(expected, &hash.to_hex()); + +let hash = Params::new() + .hash_length(16) + .key(b"Squeamish Ossifrage") + .personal(b"Shaftoe") + .to_state() + .update(b"foo") + .update(b"bar") + .update(b"baz") + .finalize(); +assert_eq!("28325512782cbf5019424fa65da9a6c7", &hash.to_hex()); +``` diff --git a/src/plonk/blake2_const/blake2s/src/avx2.rs b/src/plonk/blake2_const/blake2s/src/avx2.rs new file mode 100644 index 000000000..96135228f --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/avx2.rs @@ -0,0 +1,595 @@ +#[cfg(target_arch = "x86")] +use core::arch::x86::*; +#[cfg(target_arch = "x86_64")] +use core::arch::x86_64::*; + +use crate::guts::{ + assemble_count, count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, + Job, Stride, +}; +use crate::{Word, BLOCKBYTES, IV, SIGMA}; +use core::cmp; +use core::mem; + +pub const DEGREE: usize = 8; + +#[inline(always)] +unsafe fn loadu(src: *const [Word; DEGREE]) -> __m256i { + // This is an unaligned load, so the pointer cast is allowed. + _mm256_loadu_si256(src as *const __m256i) +} + +#[inline(always)] +unsafe fn storeu(src: __m256i, dest: *mut [Word; DEGREE]) { + // This is an unaligned store, so the pointer cast is allowed. + _mm256_storeu_si256(dest as *mut __m256i, src) +} + +#[inline(always)] +unsafe fn add(a: __m256i, b: __m256i) -> __m256i { + _mm256_add_epi32(a, b) +} + +#[inline(always)] +unsafe fn eq(a: __m256i, b: __m256i) -> __m256i { + _mm256_cmpeq_epi32(a, b) +} + +#[inline(always)] +unsafe fn and(a: __m256i, b: __m256i) -> __m256i { + _mm256_and_si256(a, b) +} + +#[inline(always)] +unsafe fn negate_and(a: __m256i, b: __m256i) -> __m256i { + // Note that "and not" implies the reverse of the actual arg order. + _mm256_andnot_si256(a, b) +} + +#[inline(always)] +unsafe fn xor(a: __m256i, b: __m256i) -> __m256i { + _mm256_xor_si256(a, b) +} + +#[inline(always)] +unsafe fn set1(x: u32) -> __m256i { + _mm256_set1_epi32(x as i32) +} + +#[inline(always)] +unsafe fn set8(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32, g: u32, h: u32) -> __m256i { + _mm256_setr_epi32( + a as i32, b as i32, c as i32, d as i32, e as i32, f as i32, g as i32, h as i32, + ) +} + +#[inline(always)] +unsafe fn rot16(x: __m256i) -> __m256i { + _mm256_shuffle_epi8( + x, + _mm256_set_epi8( + 13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2, 13, 12, 15, 14, 9, 8, 11, 10, 5, + 4, 7, 6, 1, 0, 3, 2, + ), + ) +} + +#[inline(always)] +unsafe fn rot12(x: __m256i) -> __m256i { + _mm256_or_si256(_mm256_srli_epi32(x, 12), _mm256_slli_epi32(x, 20)) +} + +#[inline(always)] +unsafe fn rot8(x: __m256i) -> __m256i { + _mm256_shuffle_epi8( + x, + _mm256_set_epi8( + 12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1, 12, 15, 14, 13, 8, 11, 10, 9, 4, + 7, 6, 5, 0, 3, 2, 1, + ), + ) +} + +#[inline(always)] +unsafe fn rot7(x: __m256i) -> __m256i { + _mm256_or_si256(_mm256_srli_epi32(x, 7), _mm256_slli_epi32(x, 25)) +} + +#[inline(always)] +unsafe fn round(v: &mut [__m256i; 16], m: &[__m256i; 16], r: usize) { + v[0] = add(v[0], m[SIGMA[r][0] as usize]); + v[1] = add(v[1], m[SIGMA[r][2] as usize]); + v[2] = add(v[2], m[SIGMA[r][4] as usize]); + v[3] = add(v[3], m[SIGMA[r][6] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[15] = rot16(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot12(v[4]); + v[5] = rot12(v[5]); + v[6] = rot12(v[6]); + v[7] = rot12(v[7]); + v[0] = add(v[0], m[SIGMA[r][1] as usize]); + v[1] = add(v[1], m[SIGMA[r][3] as usize]); + v[2] = add(v[2], m[SIGMA[r][5] as usize]); + v[3] = add(v[3], m[SIGMA[r][7] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot8(v[12]); + v[13] = rot8(v[13]); + v[14] = rot8(v[14]); + v[15] = rot8(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot7(v[4]); + v[5] = rot7(v[5]); + v[6] = rot7(v[6]); + v[7] = rot7(v[7]); + + v[0] = add(v[0], m[SIGMA[r][8] as usize]); + v[1] = add(v[1], m[SIGMA[r][10] as usize]); + v[2] = add(v[2], m[SIGMA[r][12] as usize]); + v[3] = add(v[3], m[SIGMA[r][14] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot16(v[15]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot12(v[5]); + v[6] = rot12(v[6]); + v[7] = rot12(v[7]); + v[4] = rot12(v[4]); + v[0] = add(v[0], m[SIGMA[r][9] as usize]); + v[1] = add(v[1], m[SIGMA[r][11] as usize]); + v[2] = add(v[2], m[SIGMA[r][13] as usize]); + v[3] = add(v[3], m[SIGMA[r][15] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot8(v[15]); + v[12] = rot8(v[12]); + v[13] = rot8(v[13]); + v[14] = rot8(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot7(v[5]); + v[6] = rot7(v[6]); + v[7] = rot7(v[7]); + v[4] = rot7(v[4]); +} + +// We'd rather make this a regular function with #[inline(always)], but for +// some reason that blows up compile times by about 10 seconds, at least in +// some cases (BLAKE2b avx2.rs). This macro seems to get the same performance +// result, without the compile time issue. +macro_rules! compress8_transposed { + ( + $h_vecs:expr, + $msg_vecs:expr, + $count_low:expr, + $count_high:expr, + $lastblock:expr, + $lastnode:expr, + ) => { + let h_vecs: &mut [__m256i; 8] = $h_vecs; + let msg_vecs: &[__m256i; 16] = $msg_vecs; + let count_low: __m256i = $count_low; + let count_high: __m256i = $count_high; + let lastblock: __m256i = $lastblock; + let lastnode: __m256i = $lastnode; + + let mut v = [ + h_vecs[0], + h_vecs[1], + h_vecs[2], + h_vecs[3], + h_vecs[4], + h_vecs[5], + h_vecs[6], + h_vecs[7], + set1(IV[0]), + set1(IV[1]), + set1(IV[2]), + set1(IV[3]), + xor(set1(IV[4]), count_low), + xor(set1(IV[5]), count_high), + xor(set1(IV[6]), lastblock), + xor(set1(IV[7]), lastnode), + ]; + + round(&mut v, &msg_vecs, 0); + round(&mut v, &msg_vecs, 1); + round(&mut v, &msg_vecs, 2); + round(&mut v, &msg_vecs, 3); + round(&mut v, &msg_vecs, 4); + round(&mut v, &msg_vecs, 5); + round(&mut v, &msg_vecs, 6); + round(&mut v, &msg_vecs, 7); + round(&mut v, &msg_vecs, 8); + round(&mut v, &msg_vecs, 9); + + h_vecs[0] = xor(xor(h_vecs[0], v[0]), v[8]); + h_vecs[1] = xor(xor(h_vecs[1], v[1]), v[9]); + h_vecs[2] = xor(xor(h_vecs[2], v[2]), v[10]); + h_vecs[3] = xor(xor(h_vecs[3], v[3]), v[11]); + h_vecs[4] = xor(xor(h_vecs[4], v[4]), v[12]); + h_vecs[5] = xor(xor(h_vecs[5], v[5]), v[13]); + h_vecs[6] = xor(xor(h_vecs[6], v[6]), v[14]); + h_vecs[7] = xor(xor(h_vecs[7], v[7]), v[15]); + }; +} + +#[inline(always)] +unsafe fn interleave128(a: __m256i, b: __m256i) -> (__m256i, __m256i) { + ( + _mm256_permute2x128_si256(a, b, 0x20), + _mm256_permute2x128_si256(a, b, 0x31), + ) +} + +// There are several ways to do a transposition. We could do it naively, with 8 separate +// _mm256_set_epi32 instructions, referencing each of the 32 words explicitly. Or we could copy +// the vecs into contiguous storage and then use gather instructions. This third approach is to use +// a series of unpack instructions to interleave the vectors. In my benchmarks, interleaving is the +// fastest approach. To test this, run `cargo +nightly bench --bench libtest load_8` in the +// https://github.com/oconnor663/bao_experiments repo. +#[inline(always)] +unsafe fn transpose_vecs( + vec_a: __m256i, + vec_b: __m256i, + vec_c: __m256i, + vec_d: __m256i, + vec_e: __m256i, + vec_f: __m256i, + vec_g: __m256i, + vec_h: __m256i, +) -> [__m256i; 8] { + // Interleave 32-bit lanes. The low unpack is lanes 00/11/44/55, and the high is 22/33/66/77. + let ab_0145 = _mm256_unpacklo_epi32(vec_a, vec_b); + let ab_2367 = _mm256_unpackhi_epi32(vec_a, vec_b); + let cd_0145 = _mm256_unpacklo_epi32(vec_c, vec_d); + let cd_2367 = _mm256_unpackhi_epi32(vec_c, vec_d); + let ef_0145 = _mm256_unpacklo_epi32(vec_e, vec_f); + let ef_2367 = _mm256_unpackhi_epi32(vec_e, vec_f); + let gh_0145 = _mm256_unpacklo_epi32(vec_g, vec_h); + let gh_2367 = _mm256_unpackhi_epi32(vec_g, vec_h); + + // Interleave 64-bit lates. The low unpack is lanes 00/22 and the high is 11/33. + let abcd_04 = _mm256_unpacklo_epi64(ab_0145, cd_0145); + let abcd_15 = _mm256_unpackhi_epi64(ab_0145, cd_0145); + let abcd_26 = _mm256_unpacklo_epi64(ab_2367, cd_2367); + let abcd_37 = _mm256_unpackhi_epi64(ab_2367, cd_2367); + let efgh_04 = _mm256_unpacklo_epi64(ef_0145, gh_0145); + let efgh_15 = _mm256_unpackhi_epi64(ef_0145, gh_0145); + let efgh_26 = _mm256_unpacklo_epi64(ef_2367, gh_2367); + let efgh_37 = _mm256_unpackhi_epi64(ef_2367, gh_2367); + + // Interleave 128-bit lanes. + let (abcdefgh_0, abcdefgh_4) = interleave128(abcd_04, efgh_04); + let (abcdefgh_1, abcdefgh_5) = interleave128(abcd_15, efgh_15); + let (abcdefgh_2, abcdefgh_6) = interleave128(abcd_26, efgh_26); + let (abcdefgh_3, abcdefgh_7) = interleave128(abcd_37, efgh_37); + + [ + abcdefgh_0, abcdefgh_1, abcdefgh_2, abcdefgh_3, abcdefgh_4, abcdefgh_5, abcdefgh_6, + abcdefgh_7, + ] +} + +#[inline(always)] +unsafe fn transpose_state_vecs(jobs: &[Job; DEGREE]) -> [__m256i; 8] { + // Load all the state words into transposed vectors, where the first vector + // has the first word of each state, etc. Transposing once at the beginning + // and once at the end is more efficient that repeating it for each block. + transpose_vecs( + loadu(jobs[0].words), + loadu(jobs[1].words), + loadu(jobs[2].words), + loadu(jobs[3].words), + loadu(jobs[4].words), + loadu(jobs[5].words), + loadu(jobs[6].words), + loadu(jobs[7].words), + ) +} + +#[inline(always)] +unsafe fn untranspose_state_vecs(h_vecs: &[__m256i; 8], jobs: &mut [Job; DEGREE]) { + // Un-transpose the updated state vectors back into the caller's arrays. + let out = transpose_vecs( + h_vecs[0], h_vecs[1], h_vecs[2], h_vecs[3], h_vecs[4], h_vecs[5], h_vecs[6], h_vecs[7], + ); + storeu(out[0], jobs[0].words); + storeu(out[1], jobs[1].words); + storeu(out[2], jobs[2].words); + storeu(out[3], jobs[3].words); + storeu(out[4], jobs[4].words); + storeu(out[5], jobs[5].words); + storeu(out[6], jobs[6].words); + storeu(out[7], jobs[7].words); +} + +#[inline(always)] +unsafe fn transpose_msg_vecs(blocks: [*const [u8; BLOCKBYTES]; DEGREE]) -> [__m256i; 16] { + // These input arrays have no particular alignment, so we use unaligned + // loads to read from them. + let block0 = blocks[0] as *const [Word; DEGREE]; + let block1 = blocks[1] as *const [Word; DEGREE]; + let block2 = blocks[2] as *const [Word; DEGREE]; + let block3 = blocks[3] as *const [Word; DEGREE]; + let block4 = blocks[4] as *const [Word; DEGREE]; + let block5 = blocks[5] as *const [Word; DEGREE]; + let block6 = blocks[6] as *const [Word; DEGREE]; + let block7 = blocks[7] as *const [Word; DEGREE]; + let [m0, m1, m2, m3, m4, m5, m6, m7] = transpose_vecs( + loadu(block0.add(0)), + loadu(block1.add(0)), + loadu(block2.add(0)), + loadu(block3.add(0)), + loadu(block4.add(0)), + loadu(block5.add(0)), + loadu(block6.add(0)), + loadu(block7.add(0)), + ); + let [m8, m9, m10, m11, m12, m13, m14, m15] = transpose_vecs( + loadu(block0.add(1)), + loadu(block1.add(1)), + loadu(block2.add(1)), + loadu(block3.add(1)), + loadu(block4.add(1)), + loadu(block5.add(1)), + loadu(block6.add(1)), + loadu(block7.add(1)), + ); + [ + m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, + ] +} + +#[inline(always)] +unsafe fn load_counts(jobs: &[Job; DEGREE]) -> (__m256i, __m256i) { + ( + set8( + count_low(jobs[0].count), + count_low(jobs[1].count), + count_low(jobs[2].count), + count_low(jobs[3].count), + count_low(jobs[4].count), + count_low(jobs[5].count), + count_low(jobs[6].count), + count_low(jobs[7].count), + ), + set8( + count_high(jobs[0].count), + count_high(jobs[1].count), + count_high(jobs[2].count), + count_high(jobs[3].count), + count_high(jobs[4].count), + count_high(jobs[5].count), + count_high(jobs[6].count), + count_high(jobs[7].count), + ), + ) +} + +#[inline(always)] +unsafe fn store_counts(jobs: &mut [Job; DEGREE], low: __m256i, high: __m256i) { + let low_ints: [Word; DEGREE] = mem::transmute(low); + let high_ints: [Word; DEGREE] = mem::transmute(high); + for i in 0..DEGREE { + jobs[i].count = assemble_count(low_ints[i], high_ints[i]); + } +} + +#[inline(always)] +unsafe fn add_to_counts(lo: &mut __m256i, hi: &mut __m256i, delta: __m256i) { + // If the low counts reach zero, that means they wrapped, unless the delta + // was also zero. + *lo = add(*lo, delta); + let lo_reached_zero = eq(*lo, set1(0)); + let delta_was_zero = eq(delta, set1(0)); + let hi_inc = and(set1(1), negate_and(delta_was_zero, lo_reached_zero)); + *hi = add(*hi, hi_inc); +} + +#[inline(always)] +unsafe fn flags_vec(flags: [bool; DEGREE]) -> __m256i { + set8( + flag_word(flags[0]), + flag_word(flags[1]), + flag_word(flags[2]), + flag_word(flags[3]), + flag_word(flags[4]), + flag_word(flags[5]), + flag_word(flags[6]), + flag_word(flags[7]), + ) +} + +#[target_feature(enable = "avx2")] +pub unsafe fn compress8_loop(jobs: &mut [Job; DEGREE], finalize: Finalize, stride: Stride) { + // If we're not finalizing, there can't be a partial block at the end. + for job in jobs.iter() { + input_debug_asserts(job.input, finalize); + } + + let msg_ptrs = [ + jobs[0].input.as_ptr(), + jobs[1].input.as_ptr(), + jobs[2].input.as_ptr(), + jobs[3].input.as_ptr(), + jobs[4].input.as_ptr(), + jobs[5].input.as_ptr(), + jobs[6].input.as_ptr(), + jobs[7].input.as_ptr(), + ]; + let mut h_vecs = transpose_state_vecs(&jobs); + let (mut counts_lo, mut counts_hi) = load_counts(&jobs); + + // Prepare the final blocks (note, which could be empty if the input is + // empty). Do all this before entering the main loop. + let min_len = jobs.iter().map(|job| job.input.len()).min().unwrap(); + let mut fin_offset = min_len.saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + // Performance note, making these buffers mem::uninitialized() seems to + // cause problems in the optimizer. + let mut buf0: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf1: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf2: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf3: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf4: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf5: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf6: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf7: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let (block0, len0, finalize0) = final_block(jobs[0].input, fin_offset, &mut buf0, stride); + let (block1, len1, finalize1) = final_block(jobs[1].input, fin_offset, &mut buf1, stride); + let (block2, len2, finalize2) = final_block(jobs[2].input, fin_offset, &mut buf2, stride); + let (block3, len3, finalize3) = final_block(jobs[3].input, fin_offset, &mut buf3, stride); + let (block4, len4, finalize4) = final_block(jobs[4].input, fin_offset, &mut buf4, stride); + let (block5, len5, finalize5) = final_block(jobs[5].input, fin_offset, &mut buf5, stride); + let (block6, len6, finalize6) = final_block(jobs[6].input, fin_offset, &mut buf6, stride); + let (block7, len7, finalize7) = final_block(jobs[7].input, fin_offset, &mut buf7, stride); + let fin_blocks: [*const [u8; BLOCKBYTES]; DEGREE] = [ + block0, block1, block2, block3, block4, block5, block6, block7, + ]; + let fin_counts_delta = set8( + len0 as Word, + len1 as Word, + len2 as Word, + len3 as Word, + len4 as Word, + len5 as Word, + len6 as Word, + len7 as Word, + ); + let fin_last_block; + let fin_last_node; + if finalize.yes() { + fin_last_block = flags_vec([ + finalize0, finalize1, finalize2, finalize3, finalize4, finalize5, finalize6, finalize7, + ]); + fin_last_node = flags_vec([ + finalize0 && jobs[0].last_node.yes(), + finalize1 && jobs[1].last_node.yes(), + finalize2 && jobs[2].last_node.yes(), + finalize3 && jobs[3].last_node.yes(), + finalize4 && jobs[4].last_node.yes(), + finalize5 && jobs[5].last_node.yes(), + finalize6 && jobs[6].last_node.yes(), + finalize7 && jobs[7].last_node.yes(), + ]); + } else { + fin_last_block = set1(0); + fin_last_node = set1(0); + } + + // The main loop. + let mut offset = 0; + loop { + let blocks; + let counts_delta; + let last_block; + let last_node; + if offset == fin_offset { + blocks = fin_blocks; + counts_delta = fin_counts_delta; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + blocks = [ + msg_ptrs[0].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[1].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[2].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[3].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[4].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[5].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[6].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[7].add(offset) as *const [u8; BLOCKBYTES], + ]; + counts_delta = set1(BLOCKBYTES as Word); + last_block = set1(0); + last_node = set1(0); + }; + + let m_vecs = transpose_msg_vecs(blocks); + add_to_counts(&mut counts_lo, &mut counts_hi, counts_delta); + compress8_transposed!( + &mut h_vecs, + &m_vecs, + counts_lo, + counts_hi, + last_block, + last_node, + ); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + // Write out the results. + untranspose_state_vecs(&h_vecs, &mut *jobs); + store_counts(&mut *jobs, counts_lo, counts_hi); + let max_consumed = offset.saturating_add(stride.padded_blockbytes()); + for job in jobs.iter_mut() { + let consumed = cmp::min(max_consumed, job.input.len()); + job.input = &job.input[consumed..]; + } +} diff --git a/src/plonk/blake2_const/blake2s/src/blake2sp.rs b/src/plonk/blake2_const/blake2s/src/blake2sp.rs new file mode 100644 index 000000000..b00a86868 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/blake2sp.rs @@ -0,0 +1,577 @@ +//! BLAKE2sp, a variant of BLAKE2s that uses SIMD more efficiently. +//! +//! The AVX2 implementation of BLAKE2sp is about twice as fast that of BLAKE2s. +//! However, note that it's a different hash function, and it gives a different +//! hash from BLAKE2s for the same input. +//! +//! # Example +//! +//! ``` +//! use blake2s_simd::blake2sp; +//! +//! let hash = blake2sp::Params::new() +//! .hash_length(16) +//! .key(b"Squeamish Ossifrage") +//! .to_state() +//! .update(b"foo") +//! .update(b"bar") +//! .update(b"baz") +//! .finalize(); +//! assert_eq!("9a604f1653c25063debb3aeea79671c0", &hash.to_hex()); +//! ``` + +use crate::guts::{Finalize, Implementation, Job, LastNode, Stride}; +use crate::many; +use crate::Count; +use crate::Hash; +use crate::Word; +use crate::BLOCKBYTES; +use crate::KEYBYTES; +use crate::OUTBYTES; +use core::cmp; +use core::fmt; +use core::mem::size_of; + +#[cfg(feature = "std")] +use std; + +pub(crate) const DEGREE: usize = 8; + +/// Compute the BLAKE2sp hash of a slice of bytes all at once, using default +/// parameters. +/// +/// # Example +/// +/// ``` +/// # use blake2s_simd::blake2sp::blake2sp; +/// let expected = "050dc5786037ea72cb9ed9d0324afcab03c97ec02e8c47368fc5dfb4cf49d8c9"; +/// let hash = blake2sp(b"foo"); +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +pub fn blake2sp(input: &[u8]) -> Hash { + Params::new().hash(input) +} + +/// A parameter builder for BLAKE2sp, just like the [`Params`](../struct.Params.html) type for +/// BLAKE2s. +/// +/// This builder only supports configuring the hash length and a secret key. This matches the +/// options provided by the [reference +/// implementation](https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2.h#L162-L165). +/// +/// # Example +/// +/// ``` +/// use blake2s_simd::blake2sp; +/// let mut state = blake2sp::Params::new().hash_length(32).to_state(); +/// ``` +#[derive(Clone)] +pub struct Params { + hash_length: u8, + key_length: u8, + key: [u8; KEYBYTES], + implementation: Implementation, +} + +impl Params { + /// Equivalent to `Params::default()`. + pub fn new() -> Self { + Self { + hash_length: OUTBYTES as u8, + key_length: 0, + key: [0; KEYBYTES], + implementation: Implementation::detect(), + } + } + + fn to_words(&self) -> ([[Word; 8]; DEGREE], [Word; 8]) { + let mut base_params = crate::Params::new(); + base_params + .hash_length(self.hash_length as usize) + .key(&self.key[..self.key_length as usize]) + .fanout(DEGREE as u8) + .max_depth(2) + .max_leaf_length(0) + // Note that inner_hash_length is always OUTBYTES, regardless of the hash_length + // parameter. This isn't documented in the spec, but it matches the behavior of the + // reference implementation: https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2bp-ref.c#L55 + .inner_hash_length(OUTBYTES); + let leaf_words = |worker_index| { + base_params + .clone() + .node_offset(worker_index) + .node_depth(0) + // Note that setting the last_node flag here has no effect, + // because it isn't included in the state words. + .to_words() + }; + let leaf_words = [ + leaf_words(0), + leaf_words(1), + leaf_words(2), + leaf_words(3), + leaf_words(4), + leaf_words(5), + leaf_words(6), + leaf_words(7), + ]; + let root_words = base_params + .clone() + .node_offset(0) + .node_depth(1) + // Note that setting the last_node flag here has no effect, because + // it isn't included in the state words. Also note that because + // we're only preserving its state words, the root node won't hash + // any key bytes. + .to_words(); + (leaf_words, root_words) + } + + /// Hash an input all at once with these parameters. + pub fn hash(&self, input: &[u8]) -> Hash { + // If there's a key, just fall back to using the State. + if self.key_length > 0 { + return self.to_state().update(input).finalize(); + } + let (mut leaf_words, mut root_words) = self.to_words(); + // Hash each leaf in parallel. + let jobs = leaf_words.iter_mut().enumerate().map(|(i, words)| { + let input_start = cmp::min(input.len(), i * BLOCKBYTES); + Job { + input: &input[input_start..], + words, + count: 0, + last_node: if i == DEGREE - 1 { + LastNode::Yes + } else { + LastNode::No + }, + } + }); + many::compress_many(jobs, self.implementation, Finalize::Yes, Stride::Parallel); + // Hash each leaf into the root. + finalize_root_words( + &leaf_words, + &mut root_words, + self.hash_length, + self.implementation, + ) + } + + /// Construct a BLAKE2sp `State` object based on these parameters. + pub fn to_state(&self) -> State { + State::with_params(self) + } + + /// Set the length of the final hash, from 1 to `OUTBYTES` (64). Apart from controlling the + /// length of the final `Hash`, this is also associated data, and changing it will result in a + /// totally different hash. + pub fn hash_length(&mut self, length: usize) -> &mut Self { + assert!( + 1 <= length && length <= OUTBYTES, + "Bad hash length: {}", + length + ); + self.hash_length = length as u8; + self + } + + /// Use a secret key, so that BLAKE2sp acts as a MAC. The maximum key length is `KEYBYTES` + /// (64). An empty key is equivalent to having no key at all. + pub fn key(&mut self, key: &[u8]) -> &mut Self { + assert!(key.len() <= KEYBYTES, "Bad key length: {}", key.len()); + self.key_length = key.len() as u8; + self.key = [0; KEYBYTES]; + self.key[..key.len()].copy_from_slice(key); + self + } +} + +impl Default for Params { + fn default() -> Self { + Self::new() + } +} + +impl fmt::Debug for Params { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "Params {{ hash_length: {}, key_length: {} }}", + self.hash_length, + // NB: Don't print the key itself. Debug shouldn't leak secrets. + self.key_length, + ) + } +} + +/// An incremental hasher for BLAKE2sp, just like the [`State`](../struct.State.html) type for +/// BLAKE2s. +/// +/// # Example +/// +/// ``` +/// use blake2s_simd::blake2sp; +/// +/// let mut state = blake2sp::State::new(); +/// state.update(b"foo"); +/// state.update(b"bar"); +/// let hash = state.finalize(); +/// +/// let expected = "268120e51df583c61d6bfb7915f1c8ead299696c42f413092cd0b2247e1a388d"; +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +#[derive(Clone)] +pub struct State { + leaf_words: [[Word; 8]; DEGREE], + root_words: [Word; 8], + // Note that this buffer is twice as large as what compress4 needs. That guarantees that we + // have enough input when we compress to know we don't need to finalize any of the leaves. + buf: [u8; 2 * DEGREE * BLOCKBYTES], + buf_len: u16, + // Note that this is the *per-leaf* count. + count: Count, + hash_length: u8, + implementation: Implementation, + is_keyed: bool, +} + +impl State { + /// Equivalent to `State::default()` or `Params::default().to_state()`. + pub fn new() -> Self { + Self::with_params(&Params::default()) + } + + fn with_params(params: &Params) -> Self { + let (leaf_words, root_words) = params.to_words(); + + // If a key is set, initalize the buffer to contain the key bytes. Note + // that only the leaves hash key bytes. The root doesn't, even though + // the key length it still set in its parameters. Again this isn't + // documented in the spec, but it matches the behavior of the reference + // implementation: + // https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/ref/blake2bp-ref.c#L128 + // This particular behavior (though not the inner hash length behavior + // above) is also corroborated by the official test vectors; see + // tests/vector_tests.rs. + let mut buf = [0; 2 * DEGREE * BLOCKBYTES]; + let mut buf_len = 0; + if params.key_length > 0 { + for i in 0..DEGREE { + let keybytes = ¶ms.key[..params.key_length as usize]; + buf[i * BLOCKBYTES..][..keybytes.len()].copy_from_slice(keybytes); + buf_len = BLOCKBYTES * DEGREE; + } + } + + Self { + leaf_words, + root_words, + buf, + buf_len: buf_len as u16, + count: 0, // count gets updated in self.compress() + hash_length: params.hash_length, + implementation: params.implementation, + is_keyed: params.key_length > 0, + } + } + + fn fill_buf(&mut self, input: &mut &[u8]) { + let take = cmp::min(self.buf.len() - self.buf_len as usize, input.len()); + self.buf[self.buf_len as usize..][..take].copy_from_slice(&input[..take]); + self.buf_len += take as u16; + *input = &input[take..]; + } + + fn compress_to_leaves( + leaves: &mut [[Word; 8]; DEGREE], + input: &[u8], + count: &mut Count, + implementation: Implementation, + ) { + // Input is assumed to be an even number of blocks for each leaf. Since + // we're not finilizing, debug asserts will fire otherwise. + let jobs = leaves.iter_mut().enumerate().map(|(i, words)| { + Job { + input: &input[i * BLOCKBYTES..], + words, + count: *count, + last_node: LastNode::No, // irrelevant when not finalizing + } + }); + many::compress_many(jobs, implementation, Finalize::No, Stride::Parallel); + // Note that count is the bytes input *per-leaf*. + *count = count.wrapping_add((input.len() / DEGREE) as Count); + } + + /// Add input to the hash. You can call `update` any number of times. + pub fn update(&mut self, mut input: &[u8]) -> &mut Self { + // If we have a partial buffer, try to complete it. If we complete it and there's more + // input waiting, we need to compress to make more room. However, because we need to be + // sure that *none* of the leaves would need to be finalized as part of this round of + // compression, we need to buffer more than we would for BLAKE2s. + if self.buf_len > 0 { + self.fill_buf(&mut input); + // The buffer is large enough for two compressions. If we've filled + // the buffer and there's still more input coming, then we have to + // do at least one compression. If there's enough input still + // coming that all the leaves are guaranteed to get more, do both + // compressions in the buffer. Otherwise, do just one and shift the + // back half of the buffer to the front. + if !input.is_empty() { + if input.len() > (DEGREE - 1) * BLOCKBYTES { + // Enough input coming to do both compressions. + Self::compress_to_leaves( + &mut self.leaf_words, + &self.buf, + &mut self.count, + self.implementation, + ); + self.buf_len = 0; + } else { + // Only enough input coming for one compression. + Self::compress_to_leaves( + &mut self.leaf_words, + &self.buf[..DEGREE * BLOCKBYTES], + &mut self.count, + self.implementation, + ); + self.buf_len = (DEGREE * BLOCKBYTES) as u16; + let (buf_front, buf_back) = self.buf.split_at_mut(DEGREE * BLOCKBYTES); + buf_front.copy_from_slice(buf_back); + } + } + } + + // Now we directly compress as much input as possible, without copying + // it into the buffer. We need to make sure we buffer at least one byte + // for each of the leaves, so that we know we don't need to finalize + // them. + let needed_tail = (DEGREE - 1) * BLOCKBYTES + 1; + let mut bulk_bytes = input.len().saturating_sub(needed_tail); + bulk_bytes -= bulk_bytes % (DEGREE * BLOCKBYTES); + if bulk_bytes > 0 { + Self::compress_to_leaves( + &mut self.leaf_words, + &input[..bulk_bytes], + &mut self.count, + self.implementation, + ); + input = &input[bulk_bytes..]; + } + + // Buffer any remaining input, to be either compressed or finalized in + // a subsequent call. + self.fill_buf(&mut input); + debug_assert_eq!(0, input.len()); + self + } + + /// Finalize the state and return a `Hash`. This method is idempotent, and calling it multiple + /// times will give the same result. It's also possible to `update` with more input in between. + pub fn finalize(&self) -> Hash { + // Hash whatever's remaining in the buffer and finalize the leaves. + let buf_len = self.buf_len as usize; + let mut leaves_copy = self.leaf_words; + let jobs = leaves_copy + .iter_mut() + .enumerate() + .map(|(leaf_index, leaf_words)| { + let input = &self.buf[cmp::min(leaf_index * BLOCKBYTES, buf_len)..buf_len]; + Job { + input, + words: leaf_words, + count: self.count, + last_node: if leaf_index == DEGREE - 1 { + LastNode::Yes + } else { + LastNode::No + }, + } + }); + many::compress_many(jobs, self.implementation, Finalize::Yes, Stride::Parallel); + + // Concatenate each leaf into the root and hash that. + let mut root_words_copy = self.root_words; + finalize_root_words( + &leaves_copy, + &mut root_words_copy, + self.hash_length, + self.implementation, + ) + } + + /// Return the total number of bytes input so far. + /// + /// Note that `count` doesn't include the bytes of the key block, if any. + /// It's exactly the total number of input bytes fed to `update`. + pub fn count(&self) -> Count { + // Remember that self.count is *per-leaf*. + let mut ret = self + .count + .wrapping_mul(DEGREE as Count) + .wrapping_add(self.buf_len as Count); + if self.is_keyed { + ret -= (DEGREE * BLOCKBYTES) as Count; + } + ret + } +} + +#[cfg(feature = "std")] +impl std::io::Write for State { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl fmt::Debug for State { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "State {{ count: {}, hash_length: {} }}", + self.count(), + self.hash_length, + ) + } +} + +impl Default for State { + fn default() -> Self { + Self::with_params(&Params::default()) + } +} + +// Compress each of the four finalized hashes into the root words as input, +// using two compressions. Note that even if a future version of this +// implementation supports the hash_length parameter and sets it as associated +// data for all nodes, this step must still use the untruncated output of each +// leaf. Note also that, as mentioned above, the root node doesn't hash any key +// bytes. +fn finalize_root_words( + leaf_words: &[[Word; 8]; DEGREE], + root_words: &mut [Word; 8], + hash_length: u8, + imp: Implementation, +) -> Hash { + debug_assert_eq!(OUTBYTES, 8 * size_of::()); + let mut block = [0; DEGREE * OUTBYTES]; + for (word, chunk) in leaf_words + .iter() + .flat_map(|words| words.iter()) + .zip(block.chunks_exact_mut(size_of::())) + { + chunk.copy_from_slice(&word.to_le_bytes()); + } + imp.compress1_loop( + &block, + root_words, + 0, + LastNode::Yes, + Finalize::Yes, + Stride::Serial, + ); + Hash { + bytes: crate::state_words_to_bytes(&root_words), + len: hash_length, + } +} + +pub(crate) fn force_portable(params: &mut Params) { + params.implementation = Implementation::portable(); +} + +#[cfg(test)] +pub(crate) mod test { + use super::*; + use crate::paint_test_input; + + // This is a simple reference implementation without the complicated buffering or parameter + // support of the real implementation. We need this because the official test vectors don't + // include any inputs large enough to exercise all the branches in the buffering logic. + fn blake2sp_reference(input: &[u8]) -> Hash { + let mut leaves = arrayvec::ArrayVec::<[_; DEGREE]>::new(); + for leaf_index in 0..DEGREE { + leaves.push( + crate::Params::new() + .fanout(DEGREE as u8) + .max_depth(2) + .node_offset(leaf_index as u64) + .inner_hash_length(OUTBYTES) + .to_state(), + ); + } + leaves[DEGREE - 1].set_last_node(true); + for (i, chunk) in input.chunks(BLOCKBYTES).enumerate() { + leaves[i % DEGREE].update(chunk); + } + let mut root = crate::Params::new() + .fanout(DEGREE as u8) + .max_depth(2) + .node_depth(1) + .inner_hash_length(OUTBYTES) + .last_node(true) + .to_state(); + for leaf in &mut leaves { + root.update(leaf.finalize().as_bytes()); + } + root.finalize() + } + + #[test] + fn test_against_reference() { + let mut buf = [0; 21 * BLOCKBYTES]; + paint_test_input(&mut buf); + // - 8 blocks is just enought to fill the double buffer. + // - 9 blocks triggers the "perform one compression on the double buffer" case. + // - 11 blocks is the largest input where only one compression may be performed, on the + // first half of the buffer, because there's not enough input to avoid needing to + // finalize the second half. + // - 12 blocks triggers the "perform both compressions in the double buffer" case. + // - 15 blocks is the largest input where, after compressing 8 blocks from the buffer, + // there's not enough input to hash directly from memory. + // - 16 blocks triggers "after emptying the buffer, hash directly from memory". + for num_blocks in 0..=20 { + for &extra in &[0, 1, BLOCKBYTES - 1] { + for &portable in &[false, true] { + // eprintln!("\ncase -----"); + // dbg!(num_blocks); + // dbg!(extra); + // dbg!(portable); + + // First hash the input all at once, as a sanity check. + let mut params = Params::new(); + if portable { + force_portable(&mut params); + } + let input = &buf[..num_blocks * BLOCKBYTES + extra]; + let expected = blake2sp_reference(&input); + let mut state = params.to_state(); + let found = state.update(input).finalize(); + assert_eq!(expected, found); + + // Then, do it again, but buffer 1 byte of input first. That causes the buffering + // branch to trigger. + let mut state = params.to_state(); + let maybe_one = cmp::min(1, input.len()); + state.update(&input[..maybe_one]); + assert_eq!(maybe_one as Count, state.count()); + // Do a throwaway finalize here to check for idempotency. + state.finalize(); + state.update(&input[maybe_one..]); + assert_eq!(input.len() as Count, state.count()); + let found = state.finalize(); + assert_eq!(expected, found); + + // Finally, do it again with the all-at-once interface. + assert_eq!(expected, blake2sp(input)); + } + } + } + } +} diff --git a/src/plonk/blake2_const/blake2s/src/guts.rs b/src/plonk/blake2_const/blake2s/src/guts.rs new file mode 100644 index 000000000..12dfe3d63 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/guts.rs @@ -0,0 +1,550 @@ +use crate::*; +use arrayref::array_ref; +use core::cmp; + +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +pub const MAX_DEGREE: usize = 8; + +#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))] +pub const MAX_DEGREE: usize = 1; + +// Variants other than Portable are unreachable in no_std, unless CPU features +// are explicitly enabled for the build with e.g. RUSTFLAGS="-C target-feature=avx2". +// This might change in the future if is_x86_feature_detected moves into libcore. +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Platform { + Portable, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + SSE41, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + AVX2, +} + +#[derive(Clone, Copy, Debug)] +pub struct Implementation(pub Platform); + +impl Implementation { + pub fn detect() -> Self { + // Try the different implementations in order of how fast/modern they + // are. Currently on non-x86, everything just uses portable. + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + { + if let Some(avx2_impl) = Self::avx2_if_supported() { + return avx2_impl; + } + } + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + { + if let Some(sse41_impl) = Self::sse41_if_supported() { + return sse41_impl; + } + } + Self::portable() + } + + pub const fn portable() -> Self { + Implementation(Platform::Portable) + } + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[allow(unreachable_code)] + pub const fn sse41_if_supported() -> Option { + // Check whether SSE4.1 support is assumed by the build. + #[cfg(target_feature = "sse4.1")] + { + return Some(Implementation(Platform::SSE41)); + } + + None + } + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[allow(unreachable_code)] + pub const fn avx2_if_supported() -> Option { + // Check whether AVX2 support is assumed by the build. + #[cfg(target_feature = "avx2")] + { + return Some(Implementation(Platform::AVX2)); + } + + None + } + + pub fn degree(&self) -> usize { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 => avx2::DEGREE, + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::SSE41 => sse41::DEGREE, + Platform::Portable => 1, + } + } + + pub fn compress1_loop( + &self, + input: &[u8], + words: &mut [Word; 8], + count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, + ) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 | Platform::SSE41 => unsafe { + sse41::compress1_loop(input, words, count, last_node, finalize, stride); + }, + Platform::Portable => { + portable::compress1_loop(input, words, count, last_node, finalize, stride); + } + } + } + + pub fn compress4_loop(&self, jobs: &mut [Job; 4], finalize: Finalize, stride: Stride) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 | Platform::SSE41 => unsafe { + sse41::compress4_loop(jobs, finalize, stride) + }, + _ => panic!("unsupported"), + } + } + + pub fn compress8_loop(&self, jobs: &mut [Job; 8], finalize: Finalize, stride: Stride) { + match self.0 { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + Platform::AVX2 => unsafe { avx2::compress8_loop(jobs, finalize, stride) }, + _ => panic!("unsupported"), + } + } +} + +pub struct Job<'a, 'b> { + pub input: &'a [u8], + pub words: &'b mut [Word; 8], + pub count: Count, + pub last_node: LastNode, +} + +impl<'a, 'b> core::fmt::Debug for Job<'a, 'b> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "Job {{ input_len: {}, count: {}, last_node: {} }}", + self.input.len(), + self.count, + self.last_node.yes(), + ) + } +} + +// Finalize could just be a bool, but this is easier to read at callsites. +#[derive(Clone, Copy, Debug)] +pub enum Finalize { + Yes, + No, +} + +impl Finalize { + pub fn yes(&self) -> bool { + match self { + Finalize::Yes => true, + Finalize::No => false, + } + } +} + +// Like Finalize, this is easier to read at callsites. +#[derive(Clone, Copy, Debug)] +pub enum LastNode { + Yes, + No, +} + +impl LastNode { + pub fn yes(&self) -> bool { + match self { + LastNode::Yes => true, + LastNode::No => false, + } + } +} + +#[derive(Clone, Copy, Debug)] +pub enum Stride { + Serial, // BLAKE2b/BLAKE2s + Parallel, // BLAKE2bp/BLAKE2sp +} + +impl Stride { + pub fn padded_blockbytes(&self) -> usize { + match self { + Stride::Serial => BLOCKBYTES, + Stride::Parallel => blake2sp::DEGREE * BLOCKBYTES, + } + } +} + +pub(crate) fn count_low(count: Count) -> Word { + count as Word +} + +pub(crate) fn count_high(count: Count) -> Word { + (count >> 8 * size_of::()) as Word +} + +pub(crate) fn assemble_count(low: Word, high: Word) -> Count { + low as Count + ((high as Count) << 8 * size_of::()) +} + +pub(crate) fn flag_word(flag: bool) -> Word { + if flag { + !0 + } else { + 0 + } +} + +// Pull a array reference at the given offset straight from the input, if +// there's a full block of input available. If there's only a partial block, +// copy it into the provided buffer, and return an array reference that. Along +// with the array, return the number of bytes of real input, and whether the +// input can be finalized (i.e. whether there aren't any more bytes after this +// block). Note that this is written so that the optimizer can elide bounds +// checks, see: https://godbolt.org/z/0hH2bC +pub fn final_block<'a>( + input: &'a [u8], + offset: usize, + buffer: &'a mut [u8; BLOCKBYTES], + stride: Stride, +) -> (&'a [u8; BLOCKBYTES], usize, bool) { + let capped_offset = cmp::min(offset, input.len()); + let offset_slice = &input[capped_offset..]; + if offset_slice.len() >= BLOCKBYTES { + let block = array_ref!(offset_slice, 0, BLOCKBYTES); + let should_finalize = offset_slice.len() <= stride.padded_blockbytes(); + (block, BLOCKBYTES, should_finalize) + } else { + // Copy the final block to the front of the block buffer. The rest of + // the buffer is assumed to be initialized to zero. + buffer[..offset_slice.len()].copy_from_slice(offset_slice); + (buffer, offset_slice.len(), true) + } +} + +pub fn input_debug_asserts(input: &[u8], finalize: Finalize) { + // If we're not finalizing, the input must not be empty, and it must be an + // even multiple of the block size. + if !finalize.yes() { + debug_assert!(!input.is_empty()); + debug_assert_eq!(0, input.len() % BLOCKBYTES); + } +} + +#[cfg(test)] +mod test { + use super::*; + use arrayvec::ArrayVec; + use core::mem::size_of; + + #[test] + fn test_detection() { + assert_eq!(Platform::Portable, Implementation::portable().0); + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("avx2") { + assert_eq!(Platform::AVX2, Implementation::detect().0); + assert_eq!( + Platform::AVX2, + Implementation::avx2_if_supported().unwrap().0 + ); + assert_eq!( + Platform::SSE41, + Implementation::sse41_if_supported().unwrap().0 + ); + } else if is_x86_feature_detected!("sse4.1") { + assert_eq!(Platform::SSE41, Implementation::detect().0); + assert!(Implementation::avx2_if_supported().is_none()); + assert_eq!( + Platform::SSE41, + Implementation::sse41_if_supported().unwrap().0 + ); + } else { + assert_eq!(Platform::Portable, Implementation::detect().0); + assert!(Implementation::avx2_if_supported().is_none()); + assert!(Implementation::sse41_if_supported().is_none()); + } + } + } + + fn exercise_cases(mut f: F) + where + F: FnMut(Stride, usize, LastNode, Finalize, Count), + { + // Chose counts to hit the relevant overflow cases. + let counts = &[ + (0 as Count), + ((1 as Count) << (8 * size_of::())) - BLOCKBYTES as Count, + (0 as Count).wrapping_sub(BLOCKBYTES as Count), + ]; + for &stride in &[Stride::Serial, Stride::Parallel] { + let lengths = [ + 0, + 1, + BLOCKBYTES - 1, + BLOCKBYTES, + BLOCKBYTES + 1, + 2 * BLOCKBYTES - 1, + 2 * BLOCKBYTES, + 2 * BLOCKBYTES + 1, + stride.padded_blockbytes() - 1, + stride.padded_blockbytes(), + stride.padded_blockbytes() + 1, + 2 * stride.padded_blockbytes() - 1, + 2 * stride.padded_blockbytes(), + 2 * stride.padded_blockbytes() + 1, + ]; + for &length in &lengths { + for &last_node in &[LastNode::No, LastNode::Yes] { + for &finalize in &[Finalize::No, Finalize::Yes] { + if !finalize.yes() && (length == 0 || length % BLOCKBYTES != 0) { + // Skip these cases, they're invalid. + continue; + } + for &count in counts { + // eprintln!("\ncase -----"); + // dbg!(stride); + // dbg!(length); + // dbg!(last_node); + // dbg!(finalize); + // dbg!(count); + + f(stride, length, last_node, finalize, count); + } + } + } + } + } + } + + fn initial_test_words(input_index: usize) -> [Word; 8] { + crate::Params::new() + .node_offset(input_index as u64) + .to_words() + } + + // Use the portable implementation, one block at a time, to compute the + // final state words expected for a given test case. + fn reference_compression( + input: &[u8], + stride: Stride, + last_node: LastNode, + finalize: Finalize, + mut count: Count, + input_index: usize, + ) -> [Word; 8] { + let mut words = initial_test_words(input_index); + let mut offset = 0; + while offset == 0 || offset < input.len() { + let block_size = cmp::min(BLOCKBYTES, input.len() - offset); + let maybe_finalize = if offset + stride.padded_blockbytes() < input.len() { + Finalize::No + } else { + finalize + }; + portable::compress1_loop( + &input[offset..][..block_size], + &mut words, + count, + last_node, + maybe_finalize, + Stride::Serial, + ); + offset += stride.padded_blockbytes(); + count = count.wrapping_add(BLOCKBYTES as Count); + } + words + } + + // For various loop lengths and finalization parameters, make sure that the + // implementation gives the same answer as the portable implementation does + // when invoked one block at a time. (So even the portable implementation + // itself is being tested here, to make sure its loop is correct.) Note + // that this doesn't include any fixed test vectors; those are taken from + // the blake2-kat.json file (copied from upstream) and tested elsewhere. + fn exercise_compress1_loop(implementation: Implementation) { + let mut input = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input); + + exercise_cases(|stride, length, last_node, finalize, count| { + let reference_words = + reference_compression(&input[..length], stride, last_node, finalize, count, 0); + + let mut test_words = initial_test_words(0); + implementation.compress1_loop( + &input[..length], + &mut test_words, + count, + last_node, + finalize, + stride, + ); + assert_eq!(reference_words, test_words); + }); + } + + #[test] + fn test_compress1_loop_portable() { + exercise_compress1_loop(Implementation::portable()); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress1_loop_sse41() { + if let Some(imp) = Implementation::sse41_if_supported() { + exercise_compress1_loop(imp); + } + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress1_loop_avx2() { + // Currently this just falls back to SSE4.1, but we test it anyway. + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress1_loop(imp); + } + } + + // I use ArrayVec everywhere in here becuase currently these tests pass + // under no_std. I might decide that's not worth maintaining at some point, + // since really all we care about with no_std is that the library builds, + // but for now it's here. Everything is keyed off of this N constant so + // that it's easy to copy the code to exercise_compress4_loop. + fn exercise_compress4_loop(implementation: Implementation) { + const N: usize = 4; + + let mut input_buffer = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input_buffer); + let mut inputs = ArrayVec::<[_; N]>::new(); + for i in 0..N { + inputs.push(&input_buffer[i..]); + } + + exercise_cases(|stride, length, last_node, finalize, count| { + let mut reference_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + let words = reference_compression( + &inputs[i][..length], + stride, + last_node, + finalize, + count.wrapping_add((i * BLOCKBYTES) as Count), + i, + ); + reference_words.push(words); + } + + let mut test_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + test_words.push(initial_test_words(i)); + } + let mut jobs = ArrayVec::<[_; N]>::new(); + for (i, words) in test_words.iter_mut().enumerate() { + jobs.push(Job { + input: &inputs[i][..length], + words, + count: count.wrapping_add((i * BLOCKBYTES) as Count), + last_node, + }); + } + let mut jobs = jobs.into_inner().expect("full"); + implementation.compress4_loop(&mut jobs, finalize, stride); + + for i in 0..N { + assert_eq!(reference_words[i], test_words[i], "words {} unequal", i); + } + }); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress4_loop_sse41() { + if let Some(imp) = Implementation::sse41_if_supported() { + exercise_compress4_loop(imp); + } + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress4_loop_avx2() { + // Currently this just falls back to SSE4.1, but we test it anyway. + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress4_loop(imp); + } + } + + // Copied from exercise_compress2_loop, with a different value of N and an + // interior call to compress4_loop. + fn exercise_compress8_loop(implementation: Implementation) { + const N: usize = 8; + + let mut input_buffer = [0; 100 * BLOCKBYTES]; + paint_test_input(&mut input_buffer); + let mut inputs = ArrayVec::<[_; N]>::new(); + for i in 0..N { + inputs.push(&input_buffer[i..]); + } + + exercise_cases(|stride, length, last_node, finalize, count| { + let mut reference_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + let words = reference_compression( + &inputs[i][..length], + stride, + last_node, + finalize, + count.wrapping_add((i * BLOCKBYTES) as Count), + i, + ); + reference_words.push(words); + } + + let mut test_words = ArrayVec::<[_; N]>::new(); + for i in 0..N { + test_words.push(initial_test_words(i)); + } + let mut jobs = ArrayVec::<[_; N]>::new(); + for (i, words) in test_words.iter_mut().enumerate() { + jobs.push(Job { + input: &inputs[i][..length], + words, + count: count.wrapping_add((i * BLOCKBYTES) as Count), + last_node, + }); + } + let mut jobs = jobs.into_inner().expect("full"); + implementation.compress8_loop(&mut jobs, finalize, stride); + + for i in 0..N { + assert_eq!(reference_words[i], test_words[i], "words {} unequal", i); + } + }); + } + + #[test] + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + fn test_compress8_loop_avx2() { + if let Some(imp) = Implementation::avx2_if_supported() { + exercise_compress8_loop(imp); + } + } + + #[test] + fn sanity_check_count_size() { + assert_eq!(size_of::(), 2 * size_of::()); + } +} diff --git a/src/plonk/blake2_const/blake2s/src/lib.rs b/src/plonk/blake2_const/blake2s/src/lib.rs new file mode 100644 index 000000000..114b57416 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/lib.rs @@ -0,0 +1,754 @@ +//! [![GitHub](https://img.shields.io/github/tag/oconnor663/blake2_simd.svg?label=GitHub)](https://github.com/oconnor663/blake2_simd) [![crates.io](https://img.shields.io/crates/v/blake2s_simd.svg)](https://crates.io/crates/blake2s_simd) [![Build Status](https://travis-ci.org/oconnor663/blake2_simd.svg?branch=master)](https://travis-ci.org/oconnor663/blake2_simd) +//! +//! An implementation of the BLAKE2s and BLAKE2sp hash functions. See also +//! [`blake2b_simd`](https://docs.rs/blake2b_simd). +//! +//! This crate includes: +//! +//! - 100% stable Rust. +//! - SIMD implementations based on Samuel Neves' [`blake2-avx2`](https://github.com/sneves/blake2-avx2). +//! These are very fast. For benchmarks, see [the Performance section of the +//! README](https://github.com/oconnor663/blake2_simd#performance). +//! - Portable, safe implementations for other platforms. +//! - Dynamic CPU feature detection. Binaries include multiple implementations by default and +//! choose the fastest one the processor supports at runtime. +//! - All the features from the [the BLAKE2 spec](https://blake2.net/blake2.pdf), like adjustable +//! length, keying, and associated data for tree hashing. +//! - `no_std` support. The `std` Cargo feature is on by default, for CPU feature detection and +//! for implementing `std::io::Write`. +//! - Support for computing multiple BLAKE2s hashes in parallel, matching the efficiency of +//! BLAKE2sp. See the [`many`](many/index.html) module. +//! +//! # Example +//! +//! ``` +//! use blake2s_simd::{blake2s, Params}; +//! +//! let expected = "08d6cad88075de8f192db097573d0e829411cd91eb6ec65e8fc16c017edfdb74"; +//! let hash = blake2s(b"foo"); +//! assert_eq!(expected, &hash.to_hex()); +//! +//! let hash = Params::new() +//! .hash_length(16) +//! .key(b"Squeamish Ossifrage") +//! .personal(b"Shaftoe") +//! .to_state() +//! .update(b"foo") +//! .update(b"bar") +//! .update(b"baz") +//! .finalize(); +//! assert_eq!("28325512782cbf5019424fa65da9a6c7", &hash.to_hex()); +//! ``` + +#![cfg_attr(not(feature = "std"), no_std)] + +use arrayref::{array_refs, mut_array_refs}; +use core::cmp; +use core::fmt; +use core::mem::size_of; + +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +mod avx2; +mod portable; +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +mod sse41; + +pub mod blake2sp; +mod guts; +pub mod many; + +#[cfg(test)] +mod test; + +pub use guts::{Implementation, Platform}; + +type Word = u32; +type Count = u64; + +/// The max hash length. +pub const OUTBYTES: usize = 8 * size_of::(); +/// The max key length. +pub const KEYBYTES: usize = 8 * size_of::(); +/// The max salt length. +pub const SALTBYTES: usize = 2 * size_of::(); +/// The max personalization length. +pub const PERSONALBYTES: usize = 2 * size_of::(); +/// The number input bytes passed to each call to the compression function. Small benchmarks need +/// to use an even multiple of `BLOCKBYTES`, or else their apparent throughput will be low. +pub const BLOCKBYTES: usize = 16 * size_of::(); + +#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "avx2"))] +const EMPTY_PARAMS: Params = Params::new_for_implementation(Implementation(Platform::AVX2)); + +#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), all(not(target_feature = "avx2"),target_feature = "sse4.1")))] +const EMPTY_PARAMS: Params = Params::new_for_implementation(Implementation(Platform::SSE41)); + +#[cfg(not( + any( + all( + any(target_arch = "x86", target_arch = "x86_64"), + target_feature = "avx2" + ), + all( + any(target_arch = "x86", target_arch = "x86_64"), + target_feature = "sse4.1" + ), + ) +))] +const EMPTY_PARAMS: Params = Params::new_for_implementation(Implementation(Platform::Portable)); + +const EMPTY_WORDS: [Word; 8] = EMPTY_PARAMS.empty_words(); + +const IV: [Word; 8] = [ + 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19, +]; + +const SIGMA: [[u8; 16]; 10] = [ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3], + [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4], + [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8], + [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13], + [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9], + [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11], + [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10], + [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5], + [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0], +]; + +/// Compute the BLAKE2s hash of a slice of bytes all at once, using default +/// parameters. +/// +/// # Example +/// +/// ``` +/// # use blake2s_simd::{blake2s, Params}; +/// let expected = "08d6cad88075de8f192db097573d0e829411cd91eb6ec65e8fc16c017edfdb74"; +/// let hash = blake2s(b"foo"); +/// assert_eq!(expected, &hash.to_hex()); +/// ``` +pub fn blake2s(input: &[u8]) -> Hash { + Params::new().hash(input) +} + +pub fn blake2s_const(input: &[u8]) -> Hash { + EMPTY_PARAMS.hash_without_state(input) +} + +/// A parameter builder that exposes all the non-default BLAKE2 features. +/// +/// Apart from `hash_length`, which controls the length of the final `Hash`, +/// all of these parameters are just associated data that gets mixed with the +/// input. For more details, see [the BLAKE2 spec](https://blake2.net/blake2.pdf). +/// +/// Several of the parameters have a valid range defined in the spec and +/// documented below. Trying to set an invalid parameter will panic. +/// +/// # Example +/// +/// ``` +/// # use blake2s_simd::Params; +/// // Create a Params object with a secret key and a non-default length. +/// let mut params = Params::new(); +/// params.key(b"my secret key"); +/// params.hash_length(16); +/// +/// // Use those params to hash an input all at once. +/// let hash = params.hash(b"my input"); +/// +/// // Or use those params to build an incremental State. +/// let mut state = params.to_state(); +/// ``` +#[derive(Clone)] +pub struct Params { + hash_length: u8, + key_length: u8, + key_block: [u8; BLOCKBYTES], + salt: [u8; SALTBYTES], + personal: [u8; PERSONALBYTES], + fanout: u8, + max_depth: u8, + max_leaf_length: u32, + node_offset: u64, + node_depth: u8, + inner_hash_length: u8, + last_node: guts::LastNode, + implementation: guts::Implementation, +} + +impl Params { + /// Equivalent to `Params::default()`. + #[inline] + pub fn new() -> Self { + Self { + hash_length: OUTBYTES as u8, + key_length: 0, + key_block: [0; BLOCKBYTES], + salt: [0; SALTBYTES], + personal: [0; PERSONALBYTES], + // NOTE: fanout and max_depth don't default to zero! + fanout: 1, + max_depth: 1, + max_leaf_length: 0, + node_offset: 0, + node_depth: 0, + inner_hash_length: 0, + last_node: guts::LastNode::No, + implementation: guts::Implementation::detect(), + } + } + + /// Equivalent to `Params::default()`. + #[inline] + pub const fn new_for_implementation(implementation: Implementation) -> Self { + Self { + hash_length: OUTBYTES as u8, + key_length: 0, + key_block: [0; BLOCKBYTES], + salt: [0; SALTBYTES], + personal: [0; PERSONALBYTES], + // NOTE: fanout and max_depth don't default to zero! + fanout: 1, + max_depth: 1, + max_leaf_length: 0, + node_offset: 0, + node_depth: 0, + inner_hash_length: 0, + last_node: guts::LastNode::No, + implementation: implementation, + } + } + + #[inline(always)] + fn to_words(&self) -> [Word; 8] { + let (salt_left, salt_right) = array_refs!(&self.salt, SALTBYTES / 2, SALTBYTES / 2); + let (personal_left, personal_right) = + array_refs!(&self.personal, PERSONALBYTES / 2, PERSONALBYTES / 2); + [ + IV[0] + ^ self.hash_length as u32 + ^ (self.key_length as u32) << 8 + ^ (self.fanout as u32) << 16 + ^ (self.max_depth as u32) << 24, + IV[1] ^ self.max_leaf_length, + IV[2] ^ self.node_offset as u32, + IV[3] + ^ (self.node_offset >> 32) as u32 + ^ (self.node_depth as u32) << 16 + ^ (self.inner_hash_length as u32) << 24, + IV[4] ^ Word::from_le_bytes(*salt_left), + IV[5] ^ Word::from_le_bytes(*salt_right), + IV[6] ^ Word::from_le_bytes(*personal_left), + IV[7] ^ Word::from_le_bytes(*personal_right), + ] + } + + #[inline(always)] + const fn empty_words(&self) -> [Word; 8] { + [ + IV[0] + ^ self.hash_length as u32 + ^ (self.key_length as u32) << 8 + ^ (self.fanout as u32) << 16 + ^ (self.max_depth as u32) << 24, + IV[1] ^ self.max_leaf_length, + IV[2] ^ self.node_offset as u32, + IV[3] + ^ (self.node_offset >> 32) as u32 + ^ (self.node_depth as u32) << 16 + ^ (self.inner_hash_length as u32) << 24, + IV[4] ^ 0, + IV[5] ^ 0, + IV[6] ^ 0, + IV[7] ^ 0, + ] + } + + /// Hash an input all at once with these parameters. + #[inline] + pub fn hash(&self, input: &[u8]) -> Hash { + // If there's a key, just fall back to using the State. + if self.key_length > 0 { + return self.to_state().update(input).finalize(); + } + let mut words = self.to_words(); + self.implementation.compress1_loop( + input, + &mut words, + 0, + self.last_node, + guts::Finalize::Yes, + guts::Stride::Serial, + ); + Hash { + bytes: state_words_to_bytes(&words), + len: self.hash_length, + } + } + + /// Hash an input without keying and specialization. + #[inline] + pub fn hash_without_state(&self, input: &[u8]) -> Hash { + let mut words = EMPTY_WORDS; + self.implementation.compress1_loop( + input, + &mut words, + 0, + self.last_node, + guts::Finalize::Yes, + guts::Stride::Serial, + ); + Hash { + bytes: state_words_to_bytes(&words), + len: self.hash_length, + } + } + + /// Construct a `State` object based on these parameters, for hashing input + /// incrementally. + pub fn to_state(&self) -> State { + State::with_params(self) + } + + /// Set the length of the final hash in bytes, from 1 to `OUTBYTES` (32). Apart from + /// controlling the length of the final `Hash`, this is also associated data, and changing it + /// will result in a totally different hash. + #[inline] + pub fn hash_length(&mut self, length: usize) -> &mut Self { + assert!( + 1 <= length && length <= OUTBYTES, + "Bad hash length: {}", + length + ); + self.hash_length = length as u8; + self + } + + /// Use a secret key, so that BLAKE2 acts as a MAC. The maximum key length is `KEYBYTES` (32). + /// An empty key is equivalent to having no key at all. + #[inline] + pub fn key(&mut self, key: &[u8]) -> &mut Self { + assert!(key.len() <= KEYBYTES, "Bad key length: {}", key.len()); + self.key_length = key.len() as u8; + self.key_block = [0; BLOCKBYTES]; + self.key_block[..key.len()].copy_from_slice(key); + self + } + + /// At most `SALTBYTES` (8). Shorter salts are padded with null bytes. An empty salt is + /// equivalent to having no salt at all. + #[inline] + pub fn salt(&mut self, salt: &[u8]) -> &mut Self { + assert!(salt.len() <= SALTBYTES, "Bad salt length: {}", salt.len()); + self.salt = [0; SALTBYTES]; + self.salt[..salt.len()].copy_from_slice(salt); + self + } + + /// At most `PERSONALBYTES` (8). Shorter personalizations are padded with null bytes. An empty + /// personalization is equivalent to having no personalization at all. + #[inline] + pub fn personal(&mut self, personalization: &[u8]) -> &mut Self { + assert!( + personalization.len() <= PERSONALBYTES, + "Bad personalization length: {}", + personalization.len() + ); + self.personal = [0; PERSONALBYTES]; + self.personal[..personalization.len()].copy_from_slice(personalization); + self + } + + /// From 0 (meaning unlimited) to 255. The default is 1 (meaning sequential). + #[inline] + pub fn fanout(&mut self, fanout: u8) -> &mut Self { + self.fanout = fanout; + self + } + + /// From 0 (meaning BLAKE2X B2 hashes), through 1 (the default, meaning sequential) to 255 (meaning unlimited). + #[inline] + pub fn max_depth(&mut self, depth: u8) -> &mut Self { + self.max_depth = depth; + self + } + + /// From 0 (the default, meaning unlimited or sequential) to `2^32 - 1`. + #[inline] + pub fn max_leaf_length(&mut self, length: u32) -> &mut Self { + self.max_leaf_length = length; + self + } + + /// From 0 (the default, meaning first, leftmost, leaf, or sequential) to `2^48 - 1`. + #[inline] + pub fn node_offset(&mut self, offset: u64) -> &mut Self { + assert!(offset < (1 << 48), "Bad node offset: {}", offset); + self.node_offset = offset; + self + } + + /// From 0 (the default, meaning leaf or sequential) to 255. + #[inline] + pub fn node_depth(&mut self, depth: u8) -> &mut Self { + self.node_depth = depth; + self + } + + /// From 0 (the default, meaning sequential) to `OUTBYTES` (32). + #[inline] + pub fn inner_hash_length(&mut self, length: usize) -> &mut Self { + assert!(length <= OUTBYTES, "Bad inner hash length: {}", length); + self.inner_hash_length = length as u8; + self + } + + /// Indicates the rightmost node in a row. This can also be changed on the + /// `State` object, potentially after hashing has begun. See + /// [`State::set_last_node`]. + /// + /// [`State::set_last_node`]: struct.State.html#method.set_last_node + #[inline] + pub fn last_node(&mut self, last_node: bool) -> &mut Self { + self.last_node = if last_node { + guts::LastNode::Yes + } else { + guts::LastNode::No + }; + self + } +} + +impl Default for Params { + fn default() -> Self { + Self::new() + } +} + +impl fmt::Debug for Params { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "Params {{ hash_length: {}, key_length: {}, salt: {:?}, personal: {:?}, fanout: {}, \ + max_depth: {}, max_leaf_length: {}, node_offset: {}, node_depth: {}, \ + inner_hash_length: {}, last_node: {} }}", + self.hash_length, + // NB: Don't print the key itself. Debug shouldn't leak secrets. + self.key_length, + &self.salt, + &self.personal, + self.fanout, + self.max_depth, + self.max_leaf_length, + self.node_offset, + self.node_depth, + self.inner_hash_length, + self.last_node.yes(), + ) + } +} + +/// An incremental hasher for BLAKE2s. +/// +/// To construct a `State` with non-default parameters, see `Params::to_state`. +/// +/// # Example +/// +/// ``` +/// use blake2s_simd::{State, blake2s}; +/// +/// let mut state = blake2s_simd::State::new(); +/// +/// state.update(b"foo"); +/// assert_eq!(blake2s(b"foo"), state.finalize()); +/// +/// state.update(b"bar"); +/// assert_eq!(blake2s(b"foobar"), state.finalize()); +/// ``` +#[derive(Clone)] +pub struct State { + words: [Word; 8], + count: Count, + buf: [u8; BLOCKBYTES], + buflen: u8, + last_node: guts::LastNode, + hash_length: u8, + implementation: guts::Implementation, + is_keyed: bool, +} + +impl State { + /// Equivalent to `State::default()` or `Params::default().to_state()`. + pub fn new() -> Self { + Self::with_params(&Params::default()) + } + + fn with_params(params: &Params) -> Self { + let mut state = Self { + words: params.to_words(), + count: 0, + buf: [0; BLOCKBYTES], + buflen: 0, + last_node: params.last_node, + hash_length: params.hash_length, + implementation: params.implementation, + is_keyed: params.key_length > 0, + }; + if state.is_keyed { + state.buf = params.key_block; + state.buflen = state.buf.len() as u8; + } + state + } + + fn fill_buf(&mut self, input: &mut &[u8]) { + let take = cmp::min(BLOCKBYTES - self.buflen as usize, input.len()); + self.buf[self.buflen as usize..self.buflen as usize + take].copy_from_slice(&input[..take]); + self.buflen += take as u8; + *input = &input[take..]; + } + + // If the state already has some input in its buffer, try to fill the buffer and perform a + // compression. However, only do the compression if there's more input coming, otherwise it + // will give the wrong hash it the caller finalizes immediately after. + fn compress_buffer_if_possible(&mut self, input: &mut &[u8]) { + if self.buflen > 0 { + self.fill_buf(input); + if !input.is_empty() { + self.implementation.compress1_loop( + &self.buf, + &mut self.words, + self.count, + self.last_node, + guts::Finalize::No, + guts::Stride::Serial, + ); + self.count = self.count.wrapping_add(BLOCKBYTES as Count); + self.buflen = 0; + } + } + } + + /// Add input to the hash. You can call `update` any number of times. + pub fn update(&mut self, mut input: &[u8]) -> &mut Self { + // If we have a partial buffer, try to complete it. + self.compress_buffer_if_possible(&mut input); + // While there's more than a block of input left (which also means we cleared the buffer + // above), compress blocks directly without copying. + let mut end = input.len().saturating_sub(1); + end -= end % BLOCKBYTES; + if end > 0 { + self.implementation.compress1_loop( + &input[..end], + &mut self.words, + self.count, + self.last_node, + guts::Finalize::No, + guts::Stride::Serial, + ); + self.count = self.count.wrapping_add(end as Count); + input = &input[end..]; + } + // Buffer any remaining input, to be either compressed or finalized in a subsequent call. + // Note that this represents some copying overhead, which in theory we could avoid in + // all-at-once setting. A function hardcoded for exactly BLOCKSIZE input bytes is about 10% + // faster than using this implementation for the same input. + self.fill_buf(&mut input); + self + } + + /// Finalize the state and return a `Hash`. This method is idempotent, and calling it multiple + /// times will give the same result. It's also possible to `update` with more input in between. + pub fn finalize(&self) -> Hash { + let mut words_copy = self.words; + self.implementation.compress1_loop( + &self.buf[..self.buflen as usize], + &mut words_copy, + self.count, + self.last_node, + guts::Finalize::Yes, + guts::Stride::Serial, + ); + Hash { + bytes: state_words_to_bytes(&words_copy), + len: self.hash_length, + } + } + + /// Set a flag indicating that this is the last node of its level in a tree hash. This is + /// equivalent to [`Params::last_node`], except that it can be set at any time before calling + /// `finalize`. That allows callers to begin hashing a node without knowing ahead of time + /// whether it's the last in its level. For more details about the intended use of this flag + /// [the BLAKE2 spec]. + /// + /// [`Params::last_node`]: struct.Params.html#method.last_node + /// [the BLAKE2 spec]: https://blake2.net/blake2.pdf + pub fn set_last_node(&mut self, last_node: bool) -> &mut Self { + self.last_node = if last_node { + guts::LastNode::Yes + } else { + guts::LastNode::No + }; + self + } + + /// Return the total number of bytes input so far. + /// + /// Note that `count` doesn't include the bytes of the key block, if any. + /// It's exactly the total number of input bytes fed to `update`. + pub fn count(&self) -> Count { + let mut ret = self.count.wrapping_add(self.buflen as Count); + if self.is_keyed { + ret -= BLOCKBYTES as Count; + } + ret + } +} + +#[inline(always)] +fn state_words_to_bytes(state_words: &[Word; 8]) -> [u8; OUTBYTES] { + let mut bytes = [0; OUTBYTES]; + { + const W: usize = size_of::(); + let refs = mut_array_refs!(&mut bytes, W, W, W, W, W, W, W, W); + *refs.0 = state_words[0].to_le_bytes(); + *refs.1 = state_words[1].to_le_bytes(); + *refs.2 = state_words[2].to_le_bytes(); + *refs.3 = state_words[3].to_le_bytes(); + *refs.4 = state_words[4].to_le_bytes(); + *refs.5 = state_words[5].to_le_bytes(); + *refs.6 = state_words[6].to_le_bytes(); + *refs.7 = state_words[7].to_le_bytes(); + } + bytes +} + +#[cfg(feature = "std")] +impl std::io::Write for State { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl fmt::Debug for State { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "State {{ count: {}, hash_length: {}, last_node: {} }}", + self.count(), + self.hash_length, + self.last_node.yes(), + ) + } +} + +impl Default for State { + fn default() -> Self { + Self::with_params(&Params::default()) + } +} + +type HexString = arrayvec::ArrayString<[u8; 2 * OUTBYTES]>; + +/// A finalized BLAKE2 hash, with constant-time equality. +#[derive(Clone, Copy)] +pub struct Hash { + bytes: [u8; OUTBYTES], + len: u8, +} + +impl Hash { + /// Convert the hash to a byte slice. Note that if you're using BLAKE2 as a MAC, you need + /// constant time equality, which `&[u8]` doesn't provide. + pub fn as_bytes(&self) -> &[u8] { + &self.bytes[..self.len as usize] + } + + /// Convert the hash to a byte array. Note that if you're using BLAKE2 as a + /// MAC, you need constant time equality, which arrays don't provide. This + /// panics in debug mode if the length of the hash isn't `OUTBYTES`. + #[inline] + pub fn as_array(&self) -> &[u8; OUTBYTES] { + debug_assert_eq!(self.len as usize, OUTBYTES); + &self.bytes + } + + /// Convert the hash to a lowercase hexadecimal + /// [`ArrayString`](https://docs.rs/arrayvec/0.4/arrayvec/struct.ArrayString.html). + pub fn to_hex(&self) -> HexString { + bytes_to_hex(self.as_bytes()) + } +} + +fn bytes_to_hex(bytes: &[u8]) -> HexString { + let mut s = arrayvec::ArrayString::new(); + let table = b"0123456789abcdef"; + for &b in bytes { + s.push(table[(b >> 4) as usize] as char); + s.push(table[(b & 0xf) as usize] as char); + } + s +} + +/// This implementation is constant time, if the two hashes are the same length. +impl PartialEq for Hash { + fn eq(&self, other: &Hash) -> bool { + constant_time_eq::constant_time_eq(&self.as_bytes(), &other.as_bytes()) + } +} + +/// This implementation is constant time, if the slice is the same length as the hash. +impl PartialEq<[u8]> for Hash { + fn eq(&self, other: &[u8]) -> bool { + constant_time_eq::constant_time_eq(&self.as_bytes(), other) + } +} + +impl Eq for Hash {} + +impl AsRef<[u8]> for Hash { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +impl fmt::Debug for Hash { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Hash(0x{})", self.to_hex()) + } +} + +// Paint a byte pattern that won't repeat, so that we don't accidentally miss +// buffer offset bugs. This is the same as what Bao uses in its tests. +#[cfg(test)] +fn paint_test_input(buf: &mut [u8]) { + let mut offset = 0; + let mut counter: u32 = 1; + while offset < buf.len() { + let bytes = counter.to_le_bytes(); + let take = cmp::min(bytes.len(), buf.len() - offset); + buf[offset..][..take].copy_from_slice(&bytes[..take]); + counter += 1; + offset += take; + } +} + +// This module is pub for internal benchmarks only. Please don't use it. +#[doc(hidden)] +pub mod benchmarks { + use super::*; + + pub fn force_portable(params: &mut Params) { + params.implementation = guts::Implementation::portable(); + } + + pub fn force_portable_blake2sp(params: &mut blake2sp::Params) { + blake2sp::force_portable(params); + } +} diff --git a/src/plonk/blake2_const/blake2s/src/many.rs b/src/plonk/blake2_const/blake2s/src/many.rs new file mode 100644 index 000000000..78736d7b5 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/many.rs @@ -0,0 +1,529 @@ +//! Interfaces for hashing multiple inputs at once, using SIMD more +//! efficiently. +//! +//! The throughput of these interfaces is comparable to BLAKE2sp, much larger +//! than that of regular BLAKE2s when AVX2 is available. +//! +//! These interfaces can accept any number of inputs, and the implementation +//! does its best to parallelize them. In general, the more inputs you can pass +//! in at once the better. If you need to batch your inputs in smaller groups, +//! see the [`degree`](fn.degree.html) function for a good batch size. +//! +//! The implementation keeps working in parallel even when inputs are of +//! different lengths, by managing a working set of jobs whose input isn't yet +//! exhausted. However, if one or two inputs are much longer than the others, +//! and they're encountered only at the end, there might not be any remaining +//! work to parallelize them with. In this case, sorting the inputs +//! longest-first can improve parallelism. +//! +//! # Example +//! +//! ``` +//! use blake2s_simd::{blake2s, State, many::update_many}; +//! +//! let mut states = [ +//! State::new(), +//! State::new(), +//! State::new(), +//! State::new(), +//! ]; +//! +//! let inputs = [ +//! &b"foo"[..], +//! &b"bar"[..], +//! &b"baz"[..], +//! &b"bing"[..], +//! ]; +//! +//! update_many(states.iter_mut().zip(inputs.iter())); +//! +//! for (state, input) in states.iter_mut().zip(inputs.iter()) { +//! assert_eq!(blake2s(input), state.finalize()); +//! } +//! ``` + +use crate::guts::{self, Finalize, Implementation, Job, LastNode, Stride}; +use crate::state_words_to_bytes; +use crate::Count; +use crate::Hash; +use crate::Params; +use crate::State; +use crate::Word; +use crate::BLOCKBYTES; +use arrayref::array_mut_ref; +use arrayvec::ArrayVec; +use core::fmt; + +/// The largest possible value of [`degree`](fn.degree.html) on the target +/// platform. +/// +/// Note that this constant reflects the parallelism degree supported by this +/// crate, so it will change over time as support is added or removed. For +/// example, when Rust stabilizes AVX-512 support and this crate adds an +/// AVX-512 implementation, this constant will double on x86 targets. If that +/// implementation is an optional feature (e.g. because it's nightly-only), the +/// value of this constant will depend on that optional feature also. +pub const MAX_DEGREE: usize = guts::MAX_DEGREE; + +/// The parallelism degree of the implementation, detected at runtime. If you +/// hash your inputs in small batches, making the batch size a multiple of +/// `degree` will generally give good performance. +/// +/// For example, an x86 processor that supports AVX2 can compute eight BLAKE2s +/// hashes in parallel, so `degree` returns 8 on that machine. If you call +/// [`hash_many`] with only seven inputs, that's not enough to use the AVX2 +/// implementation, and your average throughput will be lower. Likewise if you +/// call it with nine inputs of equal length, the first eight will be hashed in +/// parallel with AVX2, but the last one will have to be hashed by itself, and +/// again your average throughput will be lower. +/// +/// As noted in the module level docs, performance is more complicated if your +/// inputs are of different lengths. When parallelizing long and short inputs +/// together, the longer ones will have bytes left over, and the implementation +/// will try to parallelize those leftover bytes with subsequent inputs. The +/// more inputs available in that case, the more the implementation will be +/// able to parallelize. +/// +/// If you need a constant batch size, for example to collect inputs in an +/// array, see [`MAX_DEGREE`]. +/// +/// [`hash_many`]: fn.hash_many.html +/// [`MAX_DEGREE`]: constant.MAX_DEGREE.html +pub fn degree() -> usize { + guts::Implementation::detect().degree() +} + +type JobsVec<'a, 'b> = ArrayVec<[Job<'a, 'b>; guts::MAX_DEGREE]>; + +#[inline(always)] +fn fill_jobs_vec<'a, 'b>( + jobs_iter: &mut impl Iterator>, + vec: &mut JobsVec<'a, 'b>, + target_len: usize, +) { + while vec.len() < target_len { + if let Some(job) = jobs_iter.next() { + vec.push(job); + } else { + break; + } + } +} + +#[inline(always)] +fn evict_finished<'a, 'b>(vec: &mut JobsVec<'a, 'b>, num_jobs: usize) { + // Iterate backwards so that removal doesn't cause an out-of-bounds panic. + for i in (0..num_jobs).rev() { + // Note that is_empty() is only valid because we know all these jobs + // have been run at least once. Otherwise we could confuse the empty + // input for a finished job, which would be incorrect. + // + // Avoid a panic branch here in release mode. + debug_assert!(vec.len() > i); + if vec.len() > i && vec[i].input.is_empty() { + // Note that calling pop_at() repeatedly has some overhead, because + // later elements need to be shifted up. However, the JobsVec is + // small, and this approach guarantees that jobs are encountered in + // order. + vec.pop_at(i); + } + } +} + +pub(crate) fn compress_many<'a, 'b, I>( + jobs: I, + imp: Implementation, + finalize: Finalize, + stride: Stride, +) where + I: IntoIterator>, +{ + // Fuse is important for correctness, since each of these blocks tries to + // advance the iterator, even if a previous block emptied it. + let mut jobs_iter = jobs.into_iter().fuse(); + let mut jobs_vec = JobsVec::new(); + + if imp.degree() >= 8 { + loop { + fill_jobs_vec(&mut jobs_iter, &mut jobs_vec, 8); + if jobs_vec.len() < 8 { + break; + } + let jobs_array = array_mut_ref!(jobs_vec, 0, 8); + imp.compress8_loop(jobs_array, finalize, stride); + evict_finished(&mut jobs_vec, 8); + } + } + + if imp.degree() >= 4 { + loop { + fill_jobs_vec(&mut jobs_iter, &mut jobs_vec, 4); + if jobs_vec.len() < 4 { + break; + } + let jobs_array = array_mut_ref!(jobs_vec, 0, 4); + imp.compress4_loop(jobs_array, finalize, stride); + evict_finished(&mut jobs_vec, 4); + } + } + + for job in jobs_vec.into_iter().chain(jobs_iter) { + let Job { + input, + words, + count, + last_node, + } = job; + imp.compress1_loop(input, words, count, last_node, finalize, stride); + } +} + +/// Update any number of `State` objects at once. +/// +/// # Example +/// +/// ``` +/// use blake2s_simd::{blake2s, State, many::update_many}; +/// +/// let mut states = [ +/// State::new(), +/// State::new(), +/// State::new(), +/// State::new(), +/// ]; +/// +/// let inputs = [ +/// &b"foo"[..], +/// &b"bar"[..], +/// &b"baz"[..], +/// &b"bing"[..], +/// ]; +/// +/// update_many(states.iter_mut().zip(inputs.iter())); +/// +/// for (state, input) in states.iter_mut().zip(inputs.iter()) { +/// assert_eq!(blake2s(input), state.finalize()); +/// } +/// ``` +pub fn update_many<'a, 'b, I, T>(pairs: I) +where + I: IntoIterator, + T: 'b + AsRef<[u8]> + ?Sized, +{ + // Get the guts::Implementation from the first state, if any. + let mut peekable_pairs = pairs.into_iter().peekable(); + let implementation = if let Some((state, _)) = peekable_pairs.peek() { + state.implementation + } else { + // No work items, just short circuit. + return; + }; + + // Adapt the pairs iterator into a Jobs iterator, but skip over the Jobs + // where there's not actually any work to do (e.g. because there's not much + // input and it's all just going in the State buffer). + let jobs = peekable_pairs.flat_map(|(state, input_t)| { + let mut input = input_t.as_ref(); + // For each pair, if the State has some input in its buffer, try to + // finish that buffer. If there wasn't enough input to do that -- + // or if the input was empty to begin with -- skip this pair. + state.compress_buffer_if_possible(&mut input); + if input.is_empty() { + return None; + } + // Now we know the buffer is empty and there's more input. Make sure we + // buffer the final block, because update() doesn't finalize. + let mut last_block_start = input.len() - 1; + last_block_start -= last_block_start % BLOCKBYTES; + let (blocks, last_block) = input.split_at(last_block_start); + state.buf[..last_block.len()].copy_from_slice(last_block); + state.buflen = last_block.len() as u8; + // Finally, if the full blocks slice is non-empty, prepare that job for + // compression, and bump the State count. + if blocks.is_empty() { + None + } else { + let count = state.count; + state.count = state.count.wrapping_add(blocks.len() as Count); + Some(Job { + input: blocks, + words: &mut state.words, + count, + last_node: state.last_node, + }) + } + }); + + // Run all the Jobs in the iterator. + compress_many(jobs, implementation, Finalize::No, Stride::Serial); +} + +/// A job for the [`hash_many`] function. After calling [`hash_many`] on a +/// collection of `HashManyJob` objects, you can call [`to_hash`] on each job +/// to get the result. +/// +/// [`hash_many`]: fn.hash_many.html +/// [`to_hash`]: struct.HashManyJob.html#method.to_hash +#[derive(Clone)] +pub struct HashManyJob<'a> { + words: [Word; 8], + count: Count, + last_node: LastNode, + hash_length: u8, + input: &'a [u8], + finished: bool, + implementation: guts::Implementation, +} + +impl<'a> HashManyJob<'a> { + /// Construct a new `HashManyJob` from a set of hashing parameters and an + /// input. + #[inline] + pub fn new(params: &Params, input: &'a [u8]) -> Self { + let mut words = params.to_words(); + let mut count = 0; + let mut finished = false; + // If we have key bytes, compress them into the state words. If there's + // no additional input, this compression needs to finalize and set + // finished=true. + if params.key_length > 0 { + let mut finalization = Finalize::No; + if input.is_empty() { + finalization = Finalize::Yes; + finished = true; + } + params.implementation.compress1_loop( + ¶ms.key_block, + &mut words, + 0, + params.last_node, + finalization, + Stride::Serial, + ); + count = BLOCKBYTES as Count; + } + Self { + words, + count, + last_node: params.last_node, + hash_length: params.hash_length, + input, + finished, + implementation: params.implementation, + } + } + + /// Get the hash from a finished job. If you call this before calling + /// [`hash_many`], it will panic in debug mode. + /// + /// [`hash_many`]: fn.hash_many.html + #[inline] + pub fn to_hash(&self) -> Hash { + debug_assert!(self.finished, "job hasn't been run yet"); + Hash { + bytes: state_words_to_bytes(&self.words), + len: self.hash_length, + } + } +} + +impl<'a> fmt::Debug for HashManyJob<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // NB: Don't print the words. Leaking them would allow length extension. + write!( + f, + "HashManyJob {{ count: {}, hash_length: {}, last_node: {}, input_len: {} }}", + self.count, + self.hash_length, + self.last_node.yes(), + self.input.len(), + ) + } +} + +/// Hash any number of complete inputs all at once. +/// +/// This is slightly more efficient than using `update_many` with `State` +/// objects, because it doesn't need to do any buffering. +/// +/// Running `hash_many` on the same `HashManyJob` object more than once has no +/// effect. +/// +/// # Example +/// +/// ``` +/// use blake2s_simd::{blake2s, Params, many::{HashManyJob, hash_many}}; +/// +/// let inputs = [ +/// &b"foo"[..], +/// &b"bar"[..], +/// &b"baz"[..], +/// &b"bing"[..], +/// ]; +/// +/// let mut params = Params::new(); +/// params.hash_length(16); +/// +/// let mut jobs = [ +/// HashManyJob::new(¶ms, inputs[0]), +/// HashManyJob::new(¶ms, inputs[1]), +/// HashManyJob::new(¶ms, inputs[2]), +/// HashManyJob::new(¶ms, inputs[3]), +/// ]; +/// +/// hash_many(jobs.iter_mut()); +/// +/// for (input, job) in inputs.iter().zip(jobs.iter()) { +/// let expected = params.hash(input); +/// assert_eq!(expected, job.to_hash()); +/// } +/// ``` +pub fn hash_many<'a, 'b, I>(hash_many_jobs: I) +where + 'b: 'a, + I: IntoIterator>, +{ + // Get the guts::Implementation from the first job, if any. + let mut peekable_jobs = hash_many_jobs.into_iter().peekable(); + let implementation = if let Some(job) = peekable_jobs.peek() { + job.implementation + } else { + // No work items, just short circuit. + return; + }; + + // In the jobs iterator, skip HashManyJobs that have already been run. This + // is less because we actually expect callers to call hash_many twice + // (though they're allowed to if they want), and more because + // HashManyJob::new might need to finalize if there are key bytes but no + // input. Tying the job lifetime to the Params reference is an alternative, + // but I've found it too constraining in practice. We could also put key + // bytes in every HashManyJob, but that would add unnecessary storage and + // zeroing for all callers. + let unfinished_jobs = peekable_jobs.into_iter().filter(|j| !j.finished); + let jobs = unfinished_jobs.map(|j| { + j.finished = true; + Job { + input: j.input, + words: &mut j.words, + count: j.count, + last_node: j.last_node, + } + }); + compress_many(jobs, implementation, Finalize::Yes, Stride::Serial); +} + +#[cfg(test)] +mod test { + use super::*; + use crate::guts; + use crate::paint_test_input; + use crate::BLOCKBYTES; + use arrayvec::ArrayVec; + + #[test] + fn test_degree() { + assert!(degree() <= MAX_DEGREE); + + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + #[cfg(feature = "std")] + { + if is_x86_feature_detected!("avx2") { + assert!(degree() >= 8); + } + if is_x86_feature_detected!("sse4.1") { + assert!(degree() >= 4); + } + } + } + + #[test] + fn test_hash_many() { + // Use a length of inputs that will exercise all of the power-of-two loops. + const LEN: usize = 2 * guts::MAX_DEGREE - 1; + + // Rerun LEN inputs LEN different times, with the empty input starting in a + // different spot each time. + let mut input = [0; LEN * BLOCKBYTES]; + paint_test_input(&mut input); + for start_offset in 0..LEN { + let mut inputs: [&[u8]; LEN] = [&[]; LEN]; + for i in 0..LEN { + let chunks = (i + start_offset) % LEN; + inputs[i] = &input[..chunks * BLOCKBYTES]; + } + + let mut params: ArrayVec<[Params; LEN]> = ArrayVec::new(); + for i in 0..LEN { + let mut p = Params::new(); + p.node_offset(i as u64); + if i % 2 == 1 { + p.last_node(true); + p.key(b"foo"); + } + params.push(p); + } + + let mut jobs: ArrayVec<[HashManyJob; LEN]> = ArrayVec::new(); + for i in 0..LEN { + jobs.push(HashManyJob::new(¶ms[i], inputs[i])); + } + + hash_many(&mut jobs); + + // Check the outputs. + for i in 0..LEN { + let expected = params[i].hash(inputs[i]); + assert_eq!(expected, jobs[i].to_hash()); + } + } + } + + #[test] + fn test_update_many() { + // Use a length of inputs that will exercise all of the power-of-two loops. + const LEN: usize = 2 * guts::MAX_DEGREE - 1; + + // Rerun LEN inputs LEN different times, with the empty input starting in a + // different spot each time. + let mut input = [0; LEN * BLOCKBYTES]; + paint_test_input(&mut input); + for start_offset in 0..LEN { + let mut inputs: [&[u8]; LEN] = [&[]; LEN]; + for i in 0..LEN { + let chunks = (i + start_offset) % LEN; + inputs[i] = &input[..chunks * BLOCKBYTES]; + } + + let mut params: ArrayVec<[Params; LEN]> = ArrayVec::new(); + for i in 0..LEN { + let mut p = Params::new(); + p.node_offset(i as u64); + if i % 2 == 1 { + p.last_node(true); + p.key(b"foo"); + } + params.push(p); + } + + let mut states: ArrayVec<[State; LEN]> = ArrayVec::new(); + for i in 0..LEN { + states.push(params[i].to_state()); + } + + // Run each input twice through, to exercise buffering. + update_many(states.iter_mut().zip(inputs.iter())); + update_many(states.iter_mut().zip(inputs.iter())); + + // Check the outputs. + for i in 0..LEN { + let mut reference_state = params[i].to_state(); + // Again, run the input twice. + reference_state.update(inputs[i]); + reference_state.update(inputs[i]); + assert_eq!(reference_state.finalize(), states[i].finalize()); + assert_eq!(2 * inputs[i].len() as Count, states[i].count()); + } + } + } +} diff --git a/src/plonk/blake2_const/blake2s/src/portable.rs b/src/plonk/blake2_const/blake2s/src/portable.rs new file mode 100644 index 000000000..23a301d88 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/portable.rs @@ -0,0 +1,164 @@ +use arrayref::{array_ref, array_refs}; + +use super::*; +use crate::guts::{ + count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, LastNode, Stride, +}; + +// G is the mixing function, called eight times per round in the compression +// function. V is the 16-word state vector of the compression function, usually +// described as a 4x4 matrix. A, B, C, and D are the mixing indices, set by the +// caller first to the four columns of V, and then to its four diagonals. X and +// Y are words of input, chosen by the caller according to the message +// schedule, SIGMA. +#[inline(always)] +fn g(v: &mut [Word; 16], a: usize, b: usize, c: usize, d: usize, x: Word, y: Word) { + v[a] = v[a].wrapping_add(v[b]).wrapping_add(x); + v[d] = (v[d] ^ v[a]).rotate_right(16); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(12); + v[a] = v[a].wrapping_add(v[b]).wrapping_add(y); + v[d] = (v[d] ^ v[a]).rotate_right(8); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(7); +} + +#[inline(always)] +fn round(r: usize, m: &[Word; 16], v: &mut [Word; 16]) { + // Select the message schedule based on the round. + let s = SIGMA[r]; + + // Mix the columns. + g(v, 0, 4, 8, 12, m[s[0] as usize], m[s[1] as usize]); + g(v, 1, 5, 9, 13, m[s[2] as usize], m[s[3] as usize]); + g(v, 2, 6, 10, 14, m[s[4] as usize], m[s[5] as usize]); + g(v, 3, 7, 11, 15, m[s[6] as usize], m[s[7] as usize]); + + // Mix the rows. + g(v, 0, 5, 10, 15, m[s[8] as usize], m[s[9] as usize]); + g(v, 1, 6, 11, 12, m[s[10] as usize], m[s[11] as usize]); + g(v, 2, 7, 8, 13, m[s[12] as usize], m[s[13] as usize]); + g(v, 3, 4, 9, 14, m[s[14] as usize], m[s[15] as usize]); +} + +#[inline(always)] +fn compress_block( + block: &[u8; BLOCKBYTES], + words: &mut [Word; 8], + count: Count, + last_block: Word, + last_node: Word, +) { + // Initialize the compression state. + let mut v = [ + words[0], + words[1], + words[2], + words[3], + words[4], + words[5], + words[6], + words[7], + IV[0], + IV[1], + IV[2], + IV[3], + IV[4] ^ count_low(count), + IV[5] ^ count_high(count), + IV[6] ^ last_block, + IV[7] ^ last_node, + ]; + + // Parse the message bytes as ints in little endian order. + const W: usize = size_of::(); + let msg_refs = array_refs!(block, W, W, W, W, W, W, W, W, W, W, W, W, W, W, W, W); + let m = [ + Word::from_le_bytes(*msg_refs.0), + Word::from_le_bytes(*msg_refs.1), + Word::from_le_bytes(*msg_refs.2), + Word::from_le_bytes(*msg_refs.3), + Word::from_le_bytes(*msg_refs.4), + Word::from_le_bytes(*msg_refs.5), + Word::from_le_bytes(*msg_refs.6), + Word::from_le_bytes(*msg_refs.7), + Word::from_le_bytes(*msg_refs.8), + Word::from_le_bytes(*msg_refs.9), + Word::from_le_bytes(*msg_refs.10), + Word::from_le_bytes(*msg_refs.11), + Word::from_le_bytes(*msg_refs.12), + Word::from_le_bytes(*msg_refs.13), + Word::from_le_bytes(*msg_refs.14), + Word::from_le_bytes(*msg_refs.15), + ]; + + round(0, &m, &mut v); + round(1, &m, &mut v); + round(2, &m, &mut v); + round(3, &m, &mut v); + round(4, &m, &mut v); + round(5, &m, &mut v); + round(6, &m, &mut v); + round(7, &m, &mut v); + round(8, &m, &mut v); + round(9, &m, &mut v); + + words[0] ^= v[0] ^ v[8]; + words[1] ^= v[1] ^ v[9]; + words[2] ^= v[2] ^ v[10]; + words[3] ^= v[3] ^ v[11]; + words[4] ^= v[4] ^ v[12]; + words[5] ^= v[5] ^ v[13]; + words[6] ^= v[6] ^ v[14]; + words[7] ^= v[7] ^ v[15]; +} + +pub fn compress1_loop( + input: &[u8], + words: &mut [Word; 8], + mut count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, +) { + input_debug_asserts(input, finalize); + + let mut local_words = *words; + + let mut fin_offset = input.len().saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + let mut buf = [0; BLOCKBYTES]; + let (fin_block, fin_len, _) = final_block(input, fin_offset, &mut buf, stride); + let fin_last_block = flag_word(finalize.yes()); + let fin_last_node = flag_word(finalize.yes() && last_node.yes()); + + let mut offset = 0; + loop { + let block; + let count_delta; + let last_block; + let last_node; + if offset == fin_offset { + block = fin_block; + count_delta = fin_len; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + block = array_ref!(input, offset, BLOCKBYTES); + count_delta = BLOCKBYTES; + last_block = flag_word(false); + last_node = flag_word(false); + }; + + count = count.wrapping_add(count_delta as Count); + compress_block(block, &mut local_words, count, last_block, last_node); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + *words = local_words; +} diff --git a/src/plonk/blake2_const/blake2s/src/sse41.rs b/src/plonk/blake2_const/blake2s/src/sse41.rs new file mode 100644 index 000000000..c40705d5c --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/sse41.rs @@ -0,0 +1,885 @@ +#[cfg(target_arch = "x86")] +use core::arch::x86::*; +#[cfg(target_arch = "x86_64")] +use core::arch::x86_64::*; + +use crate::guts::{ + assemble_count, count_high, count_low, final_block, flag_word, input_debug_asserts, Finalize, + Job, LastNode, Stride, +}; +use crate::{Count, Word, BLOCKBYTES, IV, SIGMA}; +use arrayref::{array_refs, mut_array_refs}; +use core::cmp; +use core::mem; + +pub const DEGREE: usize = 4; + +#[inline(always)] +unsafe fn loadu(src: *const [Word; DEGREE]) -> __m128i { + // This is an unaligned load, so the pointer cast is allowed. + _mm_loadu_si128(src as *const __m128i) +} + +#[inline(always)] +unsafe fn storeu(src: __m128i, dest: *mut [Word; DEGREE]) { + // This is an unaligned store, so the pointer cast is allowed. + _mm_storeu_si128(dest as *mut __m128i, src) +} + +#[inline(always)] +unsafe fn add(a: __m128i, b: __m128i) -> __m128i { + _mm_add_epi32(a, b) +} + +#[inline(always)] +unsafe fn eq(a: __m128i, b: __m128i) -> __m128i { + _mm_cmpeq_epi32(a, b) +} + +#[inline(always)] +unsafe fn and(a: __m128i, b: __m128i) -> __m128i { + _mm_and_si128(a, b) +} + +#[inline(always)] +unsafe fn negate_and(a: __m128i, b: __m128i) -> __m128i { + // Note that "and not" implies the reverse of the actual arg order. + _mm_andnot_si128(a, b) +} + +#[inline(always)] +unsafe fn xor(a: __m128i, b: __m128i) -> __m128i { + _mm_xor_si128(a, b) +} + +#[inline(always)] +unsafe fn set1(x: u32) -> __m128i { + _mm_set1_epi32(x as i32) +} + +#[inline(always)] +unsafe fn set4(a: u32, b: u32, c: u32, d: u32) -> __m128i { + _mm_setr_epi32(a as i32, b as i32, c as i32, d as i32) +} + +#[inline(always)] +unsafe fn rot7(a: __m128i) -> __m128i { + xor(_mm_srli_epi32(a, 7), _mm_slli_epi32(a, 32 - 7)) +} + +#[inline(always)] +unsafe fn rot8(a: __m128i) -> __m128i { + _mm_shuffle_epi8( + a, + _mm_set_epi8(12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1), + ) +} + +#[inline(always)] +unsafe fn rot12(a: __m128i) -> __m128i { + xor(_mm_srli_epi32(a, 12), _mm_slli_epi32(a, 32 - 12)) +} + +#[inline(always)] +unsafe fn rot16(a: __m128i) -> __m128i { + _mm_shuffle_epi8( + a, + _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2), + ) +} + +#[inline(always)] +unsafe fn g1( + row1: &mut __m128i, + row2: &mut __m128i, + row3: &mut __m128i, + row4: &mut __m128i, + m: __m128i, +) { + *row1 = add(add(*row1, m), *row2); + *row4 = xor(*row4, *row1); + *row4 = rot16(*row4); + *row3 = add(*row3, *row4); + *row2 = xor(*row2, *row3); + *row2 = rot12(*row2); +} + +#[inline(always)] +unsafe fn g2( + row1: &mut __m128i, + row2: &mut __m128i, + row3: &mut __m128i, + row4: &mut __m128i, + m: __m128i, +) { + *row1 = add(add(*row1, m), *row2); + *row4 = xor(*row4, *row1); + *row4 = rot8(*row4); + *row3 = add(*row3, *row4); + *row2 = xor(*row2, *row3); + *row2 = rot7(*row2); +} + +// Adapted from https://github.com/rust-lang-nursery/stdsimd/pull/479. +macro_rules! _MM_SHUFFLE { + ($z:expr, $y:expr, $x:expr, $w:expr) => { + ($z << 6) | ($y << 4) | ($x << 2) | $w + }; +} + +// Note the optimization here of leaving row2 as the unrotated row, rather than +// row1. All the message loads below are adjusted to compensate for this. See +// discussion at https://github.com/sneves/blake2-avx2/pull/4 +#[inline(always)] +unsafe fn diagonalize(row1: &mut __m128i, row3: &mut __m128i, row4: &mut __m128i) { + *row1 = _mm_shuffle_epi32(*row1, _MM_SHUFFLE!(2, 1, 0, 3)); + *row4 = _mm_shuffle_epi32(*row4, _MM_SHUFFLE!(1, 0, 3, 2)); + *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE!(0, 3, 2, 1)); +} + +#[inline(always)] +unsafe fn undiagonalize(row1: &mut __m128i, row3: &mut __m128i, row4: &mut __m128i) { + *row1 = _mm_shuffle_epi32(*row1, _MM_SHUFFLE!(0, 3, 2, 1)); + *row4 = _mm_shuffle_epi32(*row4, _MM_SHUFFLE!(1, 0, 3, 2)); + *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE!(2, 1, 0, 3)); +} + +#[inline(always)] +pub unsafe fn compress_block( + block: &[u8; BLOCKBYTES], + words: &mut [Word; 8], + count: Count, + last_block: Word, + last_node: Word, +) { + let (words_low, words_high) = mut_array_refs!(words, DEGREE, DEGREE); + let (iv_low, iv_high) = array_refs!(&IV, DEGREE, DEGREE); + + let row1 = &mut loadu(words_low); + let row2 = &mut loadu(words_high); + let row3 = &mut loadu(iv_low); + let row4 = &mut xor( + loadu(iv_high), + set4(count_low(count), count_high(count), last_block, last_node), + ); + + let msg_ptr = block.as_ptr() as *const [Word; DEGREE]; + let m0 = loadu(msg_ptr.add(0)); + let m1 = loadu(msg_ptr.add(1)); + let m2 = loadu(msg_ptr.add(2)); + let m3 = loadu(msg_ptr.add(3)); + + // round 1 + let buf = _mm_castps_si128(_mm_shuffle_ps( + _mm_castsi128_ps(m0), + _mm_castsi128_ps(m1), + _MM_SHUFFLE!(2, 0, 2, 0), + )); + g1(row1, row2, row3, row4, buf); + let buf = _mm_castps_si128(_mm_shuffle_ps( + _mm_castsi128_ps(m0), + _mm_castsi128_ps(m1), + _MM_SHUFFLE!(3, 1, 3, 1), + )); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_shuffle_epi32(m2, _MM_SHUFFLE!(3, 2, 0, 1)); + let t1 = _mm_shuffle_epi32(m3, _MM_SHUFFLE!(0, 1, 3, 2)); + let buf = _mm_blend_epi16(t0, t1, 0xC3); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(t0, t1, 0x3C); + let buf = _mm_shuffle_epi32(t0, _MM_SHUFFLE!(2, 3, 0, 1)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 2 + let t0 = _mm_blend_epi16(m1, m2, 0x0C); + let t1 = _mm_slli_si128(m3, 4); + let t2 = _mm_blend_epi16(t0, t1, 0xF0); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 1, 0, 3)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_shuffle_epi32(m2, _MM_SHUFFLE!(0, 0, 2, 0)); + let t1 = _mm_blend_epi16(m1, m3, 0xC0); + let t2 = _mm_blend_epi16(t0, t1, 0xF0); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 3, 0, 1)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_slli_si128(m1, 4); + let t1 = _mm_blend_epi16(m2, t0, 0x30); + let t2 = _mm_blend_epi16(m0, t1, 0xF0); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(3, 0, 1, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpackhi_epi32(m0, m1); + let t1 = _mm_slli_si128(m3, 4); + let t2 = _mm_blend_epi16(t0, t1, 0x0C); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(3, 0, 1, 2)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 3 + let t0 = _mm_unpackhi_epi32(m2, m3); + let t1 = _mm_blend_epi16(m3, m1, 0x0C); + let t2 = _mm_blend_epi16(t0, t1, 0x0F); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(3, 1, 0, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpacklo_epi32(m2, m0); + let t1 = _mm_blend_epi16(t0, m0, 0xF0); + let t2 = _mm_slli_si128(m3, 8); + let buf = _mm_blend_epi16(t1, t2, 0xC0); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_blend_epi16(m0, m2, 0x3C); + let t1 = _mm_srli_si128(m1, 12); + let t2 = _mm_blend_epi16(t0, t1, 0x03); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(0, 3, 2, 1)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_slli_si128(m3, 4); + let t1 = _mm_blend_epi16(m0, m1, 0x33); + let t2 = _mm_blend_epi16(t1, t0, 0xC0); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(1, 2, 3, 0)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 4 + let t0 = _mm_unpackhi_epi32(m0, m1); + let t1 = _mm_unpackhi_epi32(t0, m2); + let t2 = _mm_blend_epi16(t1, m3, 0x0C); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(3, 1, 0, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_slli_si128(m2, 8); + let t1 = _mm_blend_epi16(m3, m0, 0x0C); + let t2 = _mm_blend_epi16(t1, t0, 0xC0); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 0, 1, 3)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_blend_epi16(m0, m1, 0x0F); + let t1 = _mm_blend_epi16(t0, m3, 0xC0); + let buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE!(0, 1, 2, 3)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_alignr_epi8(m0, m1, 4); + let buf = _mm_blend_epi16(t0, m2, 0x33); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 5 + let t0 = _mm_unpacklo_epi64(m1, m2); + let t1 = _mm_unpackhi_epi64(m0, m2); + let t2 = _mm_blend_epi16(t0, t1, 0x33); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 0, 1, 3)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpackhi_epi64(m1, m3); + let t1 = _mm_unpacklo_epi64(m0, m1); + let buf = _mm_blend_epi16(t0, t1, 0x33); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_unpackhi_epi64(m3, m1); + let t1 = _mm_unpackhi_epi64(m2, m0); + let t2 = _mm_blend_epi16(t1, t0, 0x33); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 1, 0, 3)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(m0, m2, 0x03); + let t1 = _mm_slli_si128(t0, 8); + let t2 = _mm_blend_epi16(t1, m3, 0x0F); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 0, 3, 1)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 6 + let t0 = _mm_unpackhi_epi32(m0, m1); + let t1 = _mm_unpacklo_epi32(m0, m2); + let buf = _mm_unpacklo_epi64(t0, t1); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_srli_si128(m2, 4); + let t1 = _mm_blend_epi16(m0, m3, 0x03); + let buf = _mm_blend_epi16(t1, t0, 0x3C); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_blend_epi16(m1, m0, 0x0C); + let t1 = _mm_srli_si128(m3, 4); + let t2 = _mm_blend_epi16(t0, t1, 0x30); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 3, 0, 1)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpacklo_epi64(m2, m1); + let t1 = _mm_shuffle_epi32(m3, _MM_SHUFFLE!(2, 0, 1, 0)); + let t2 = _mm_srli_si128(t0, 4); + let buf = _mm_blend_epi16(t1, t2, 0x33); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 7 + let t0 = _mm_slli_si128(m1, 12); + let t1 = _mm_blend_epi16(m0, m3, 0x33); + let buf = _mm_blend_epi16(t1, t0, 0xC0); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(m3, m2, 0x30); + let t1 = _mm_srli_si128(m1, 4); + let t2 = _mm_blend_epi16(t0, t1, 0x03); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 1, 3, 0)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_unpacklo_epi64(m0, m2); + let t1 = _mm_srli_si128(m1, 4); + let buf = _mm_shuffle_epi32(_mm_blend_epi16(t0, t1, 0x0C), _MM_SHUFFLE!(3, 1, 0, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpackhi_epi32(m1, m2); + let t1 = _mm_unpackhi_epi64(m0, t0); + let buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE!(0, 1, 2, 3)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 8 + let t0 = _mm_unpackhi_epi32(m0, m1); + let t1 = _mm_blend_epi16(t0, m3, 0x0F); + let buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE!(2, 0, 3, 1)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(m2, m3, 0x30); + let t1 = _mm_srli_si128(m0, 4); + let t2 = _mm_blend_epi16(t0, t1, 0x03); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(1, 0, 2, 3)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_unpackhi_epi64(m0, m3); + let t1 = _mm_unpacklo_epi64(m1, m2); + let t2 = _mm_blend_epi16(t0, t1, 0x3C); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 3, 1, 0)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpacklo_epi32(m0, m1); + let t1 = _mm_unpackhi_epi32(m1, m2); + let t2 = _mm_unpacklo_epi64(t0, t1); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(2, 1, 0, 3)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 9 + let t0 = _mm_unpackhi_epi32(m1, m3); + let t1 = _mm_unpacklo_epi64(t0, m0); + let t2 = _mm_blend_epi16(t1, m2, 0xC0); + let buf = _mm_shufflehi_epi16(t2, _MM_SHUFFLE!(1, 0, 3, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_unpackhi_epi32(m0, m3); + let t1 = _mm_blend_epi16(m2, t0, 0xF0); + let buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE!(0, 2, 1, 3)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_unpacklo_epi64(m0, m3); + let t1 = _mm_srli_si128(m2, 8); + let t2 = _mm_blend_epi16(t0, t1, 0x03); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(1, 3, 2, 0)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(m1, m0, 0x30); + let buf = _mm_shuffle_epi32(t0, _MM_SHUFFLE!(0, 3, 2, 1)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + // round 10 + let t0 = _mm_blend_epi16(m0, m2, 0x03); + let t1 = _mm_blend_epi16(m1, m2, 0x30); + let t2 = _mm_blend_epi16(t1, t0, 0x0F); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(1, 3, 0, 2)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_slli_si128(m0, 4); + let t1 = _mm_blend_epi16(m1, t0, 0xC0); + let buf = _mm_shuffle_epi32(t1, _MM_SHUFFLE!(1, 2, 0, 3)); + g2(row1, row2, row3, row4, buf); + diagonalize(row1, row3, row4); + let t0 = _mm_unpackhi_epi32(m0, m3); + let t1 = _mm_unpacklo_epi32(m2, m3); + let t2 = _mm_unpackhi_epi64(t0, t1); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(0, 2, 1, 3)); + g1(row1, row2, row3, row4, buf); + let t0 = _mm_blend_epi16(m3, m2, 0xC0); + let t1 = _mm_unpacklo_epi32(m0, m3); + let t2 = _mm_blend_epi16(t0, t1, 0x0F); + let buf = _mm_shuffle_epi32(t2, _MM_SHUFFLE!(1, 2, 3, 0)); + g2(row1, row2, row3, row4, buf); + undiagonalize(row1, row3, row4); + + storeu(xor(loadu(words_low), xor(*row1, *row3)), words_low); + storeu(xor(loadu(words_high), xor(*row2, *row4)), words_high); +} + +#[target_feature(enable = "sse4.1")] +pub unsafe fn compress1_loop( + input: &[u8], + words: &mut [Word; 8], + mut count: Count, + last_node: LastNode, + finalize: Finalize, + stride: Stride, +) { + input_debug_asserts(input, finalize); + + let mut local_words = *words; + + let mut fin_offset = input.len().saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + let mut buf = [0; BLOCKBYTES]; + let (fin_block, fin_len, _) = final_block(input, fin_offset, &mut buf, stride); + let fin_last_block = flag_word(finalize.yes()); + let fin_last_node = flag_word(finalize.yes() && last_node.yes()); + + let mut offset = 0; + loop { + let block; + let count_delta; + let last_block; + let last_node; + if offset == fin_offset { + block = fin_block; + count_delta = fin_len; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + // This unsafe cast avoids bounds checks. There's guaranteed to be + // enough input because `offset < fin_offset`. + block = &*(input.as_ptr().add(offset) as *const [u8; BLOCKBYTES]); + count_delta = BLOCKBYTES; + last_block = flag_word(false); + last_node = flag_word(false); + }; + + count = count.wrapping_add(count_delta as Count); + compress_block(block, &mut local_words, count, last_block, last_node); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + *words = local_words; +} + +#[inline(always)] +unsafe fn round(v: &mut [__m128i; 16], m: &[__m128i; 16], r: usize) { + v[0] = add(v[0], m[SIGMA[r][0] as usize]); + v[1] = add(v[1], m[SIGMA[r][2] as usize]); + v[2] = add(v[2], m[SIGMA[r][4] as usize]); + v[3] = add(v[3], m[SIGMA[r][6] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[15] = rot16(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot12(v[4]); + v[5] = rot12(v[5]); + v[6] = rot12(v[6]); + v[7] = rot12(v[7]); + v[0] = add(v[0], m[SIGMA[r][1] as usize]); + v[1] = add(v[1], m[SIGMA[r][3] as usize]); + v[2] = add(v[2], m[SIGMA[r][5] as usize]); + v[3] = add(v[3], m[SIGMA[r][7] as usize]); + v[0] = add(v[0], v[4]); + v[1] = add(v[1], v[5]); + v[2] = add(v[2], v[6]); + v[3] = add(v[3], v[7]); + v[12] = xor(v[12], v[0]); + v[13] = xor(v[13], v[1]); + v[14] = xor(v[14], v[2]); + v[15] = xor(v[15], v[3]); + v[12] = rot8(v[12]); + v[13] = rot8(v[13]); + v[14] = rot8(v[14]); + v[15] = rot8(v[15]); + v[8] = add(v[8], v[12]); + v[9] = add(v[9], v[13]); + v[10] = add(v[10], v[14]); + v[11] = add(v[11], v[15]); + v[4] = xor(v[4], v[8]); + v[5] = xor(v[5], v[9]); + v[6] = xor(v[6], v[10]); + v[7] = xor(v[7], v[11]); + v[4] = rot7(v[4]); + v[5] = rot7(v[5]); + v[6] = rot7(v[6]); + v[7] = rot7(v[7]); + + v[0] = add(v[0], m[SIGMA[r][8] as usize]); + v[1] = add(v[1], m[SIGMA[r][10] as usize]); + v[2] = add(v[2], m[SIGMA[r][12] as usize]); + v[3] = add(v[3], m[SIGMA[r][14] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot16(v[15]); + v[12] = rot16(v[12]); + v[13] = rot16(v[13]); + v[14] = rot16(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot12(v[5]); + v[6] = rot12(v[6]); + v[7] = rot12(v[7]); + v[4] = rot12(v[4]); + v[0] = add(v[0], m[SIGMA[r][9] as usize]); + v[1] = add(v[1], m[SIGMA[r][11] as usize]); + v[2] = add(v[2], m[SIGMA[r][13] as usize]); + v[3] = add(v[3], m[SIGMA[r][15] as usize]); + v[0] = add(v[0], v[5]); + v[1] = add(v[1], v[6]); + v[2] = add(v[2], v[7]); + v[3] = add(v[3], v[4]); + v[15] = xor(v[15], v[0]); + v[12] = xor(v[12], v[1]); + v[13] = xor(v[13], v[2]); + v[14] = xor(v[14], v[3]); + v[15] = rot8(v[15]); + v[12] = rot8(v[12]); + v[13] = rot8(v[13]); + v[14] = rot8(v[14]); + v[10] = add(v[10], v[15]); + v[11] = add(v[11], v[12]); + v[8] = add(v[8], v[13]); + v[9] = add(v[9], v[14]); + v[5] = xor(v[5], v[10]); + v[6] = xor(v[6], v[11]); + v[7] = xor(v[7], v[8]); + v[4] = xor(v[4], v[9]); + v[5] = rot7(v[5]); + v[6] = rot7(v[6]); + v[7] = rot7(v[7]); + v[4] = rot7(v[4]); +} + +// We'd rather make this a regular function with #[inline(always)], but for +// some reason that blows up compile times by about 10 seconds, at least in +// some cases (BLAKE2b avx2.rs). This macro seems to get the same performance +// result, without the compile time issue. +macro_rules! compress4_transposed { + ( + $h_vecs:expr, + $msg_vecs:expr, + $count_low:expr, + $count_high:expr, + $lastblock:expr, + $lastnode:expr, + ) => { + let h_vecs: &mut [__m128i; 8] = $h_vecs; + let msg_vecs: &[__m128i; 16] = $msg_vecs; + let count_low: __m128i = $count_low; + let count_high: __m128i = $count_high; + let lastblock: __m128i = $lastblock; + let lastnode: __m128i = $lastnode; + let mut v = [ + h_vecs[0], + h_vecs[1], + h_vecs[2], + h_vecs[3], + h_vecs[4], + h_vecs[5], + h_vecs[6], + h_vecs[7], + set1(IV[0]), + set1(IV[1]), + set1(IV[2]), + set1(IV[3]), + xor(set1(IV[4]), count_low), + xor(set1(IV[5]), count_high), + xor(set1(IV[6]), lastblock), + xor(set1(IV[7]), lastnode), + ]; + + round(&mut v, &msg_vecs, 0); + round(&mut v, &msg_vecs, 1); + round(&mut v, &msg_vecs, 2); + round(&mut v, &msg_vecs, 3); + round(&mut v, &msg_vecs, 4); + round(&mut v, &msg_vecs, 5); + round(&mut v, &msg_vecs, 6); + round(&mut v, &msg_vecs, 7); + round(&mut v, &msg_vecs, 8); + round(&mut v, &msg_vecs, 9); + + h_vecs[0] = xor(xor(h_vecs[0], v[0]), v[8]); + h_vecs[1] = xor(xor(h_vecs[1], v[1]), v[9]); + h_vecs[2] = xor(xor(h_vecs[2], v[2]), v[10]); + h_vecs[3] = xor(xor(h_vecs[3], v[3]), v[11]); + h_vecs[4] = xor(xor(h_vecs[4], v[4]), v[12]); + h_vecs[5] = xor(xor(h_vecs[5], v[5]), v[13]); + h_vecs[6] = xor(xor(h_vecs[6], v[6]), v[14]); + h_vecs[7] = xor(xor(h_vecs[7], v[7]), v[15]); + }; +} + +#[inline(always)] +unsafe fn transpose_vecs( + vec_a: __m128i, + vec_b: __m128i, + vec_c: __m128i, + vec_d: __m128i, +) -> [__m128i; 4] { + // Interleave 32-bit lates. The low unpack is lanes 00/11 and the high is + // 22/33. Note that this doesn't split the vector into two lanes, as the + // AVX2 counterparts do. + let ab_01 = _mm_unpacklo_epi32(vec_a, vec_b); + let ab_23 = _mm_unpackhi_epi32(vec_a, vec_b); + let cd_01 = _mm_unpacklo_epi32(vec_c, vec_d); + let cd_23 = _mm_unpackhi_epi32(vec_c, vec_d); + + // Interleave 64-bit lanes. + let abcd_0 = _mm_unpacklo_epi64(ab_01, cd_01); + let abcd_1 = _mm_unpackhi_epi64(ab_01, cd_01); + let abcd_2 = _mm_unpacklo_epi64(ab_23, cd_23); + let abcd_3 = _mm_unpackhi_epi64(ab_23, cd_23); + + [abcd_0, abcd_1, abcd_2, abcd_3] +} + +#[inline(always)] +unsafe fn transpose_state_vecs(jobs: &[Job; DEGREE]) -> [__m128i; 8] { + // Load all the state words into transposed vectors, where the first vector + // has the first word of each state, etc. Transposing once at the beginning + // and once at the end is more efficient that repeating it for each block. + let words0 = array_refs!(&jobs[0].words, DEGREE, DEGREE); + let words1 = array_refs!(&jobs[1].words, DEGREE, DEGREE); + let words2 = array_refs!(&jobs[2].words, DEGREE, DEGREE); + let words3 = array_refs!(&jobs[3].words, DEGREE, DEGREE); + let [h0, h1, h2, h3] = transpose_vecs( + loadu(words0.0), + loadu(words1.0), + loadu(words2.0), + loadu(words3.0), + ); + let [h4, h5, h6, h7] = transpose_vecs( + loadu(words0.1), + loadu(words1.1), + loadu(words2.1), + loadu(words3.1), + ); + [h0, h1, h2, h3, h4, h5, h6, h7] +} + +#[inline(always)] +unsafe fn untranspose_state_vecs(h_vecs: &[__m128i; 8], jobs: &mut [Job; DEGREE]) { + // Un-transpose the updated state vectors back into the caller's arrays. + let [job0, job1, job2, job3] = jobs; + let words0 = mut_array_refs!(&mut job0.words, DEGREE, DEGREE); + let words1 = mut_array_refs!(&mut job1.words, DEGREE, DEGREE); + let words2 = mut_array_refs!(&mut job2.words, DEGREE, DEGREE); + let words3 = mut_array_refs!(&mut job3.words, DEGREE, DEGREE); + + let out = transpose_vecs(h_vecs[0], h_vecs[1], h_vecs[2], h_vecs[3]); + storeu(out[0], words0.0); + storeu(out[1], words1.0); + storeu(out[2], words2.0); + storeu(out[3], words3.0); + let out = transpose_vecs(h_vecs[4], h_vecs[5], h_vecs[6], h_vecs[7]); + storeu(out[0], words0.1); + storeu(out[1], words1.1); + storeu(out[2], words2.1); + storeu(out[3], words3.1); +} + +#[inline(always)] +unsafe fn transpose_msg_vecs(blocks: [*const [u8; BLOCKBYTES]; DEGREE]) -> [__m128i; 16] { + // These input arrays have no particular alignment, so we use unaligned + // loads to read from them. + let block0 = blocks[0] as *const [Word; DEGREE]; + let block1 = blocks[1] as *const [Word; DEGREE]; + let block2 = blocks[2] as *const [Word; DEGREE]; + let block3 = blocks[3] as *const [Word; DEGREE]; + let [m0, m1, m2, m3] = transpose_vecs( + loadu(block0.add(0)), + loadu(block1.add(0)), + loadu(block2.add(0)), + loadu(block3.add(0)), + ); + let [m4, m5, m6, m7] = transpose_vecs( + loadu(block0.add(1)), + loadu(block1.add(1)), + loadu(block2.add(1)), + loadu(block3.add(1)), + ); + let [m8, m9, m10, m11] = transpose_vecs( + loadu(block0.add(2)), + loadu(block1.add(2)), + loadu(block2.add(2)), + loadu(block3.add(2)), + ); + let [m12, m13, m14, m15] = transpose_vecs( + loadu(block0.add(3)), + loadu(block1.add(3)), + loadu(block2.add(3)), + loadu(block3.add(3)), + ); + [ + m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, + ] +} + +#[inline(always)] +unsafe fn load_counts(jobs: &[Job; DEGREE]) -> (__m128i, __m128i) { + ( + set4( + count_low(jobs[0].count), + count_low(jobs[1].count), + count_low(jobs[2].count), + count_low(jobs[3].count), + ), + set4( + count_high(jobs[0].count), + count_high(jobs[1].count), + count_high(jobs[2].count), + count_high(jobs[3].count), + ), + ) +} + +#[inline(always)] +unsafe fn store_counts(jobs: &mut [Job; DEGREE], low: __m128i, high: __m128i) { + let low_ints: [Word; DEGREE] = mem::transmute(low); + let high_ints: [Word; DEGREE] = mem::transmute(high); + for i in 0..DEGREE { + jobs[i].count = assemble_count(low_ints[i], high_ints[i]); + } +} + +#[inline(always)] +unsafe fn add_to_counts(lo: &mut __m128i, hi: &mut __m128i, delta: __m128i) { + // If the low counts reach zero, that means they wrapped, unless the delta + // was also zero. + *lo = add(*lo, delta); + let lo_reached_zero = eq(*lo, set1(0)); + let delta_was_zero = eq(delta, set1(0)); + let hi_inc = and(set1(1), negate_and(delta_was_zero, lo_reached_zero)); + *hi = add(*hi, hi_inc); +} + +#[inline(always)] +unsafe fn flags_vec(flags: [bool; DEGREE]) -> __m128i { + set4( + flag_word(flags[0]), + flag_word(flags[1]), + flag_word(flags[2]), + flag_word(flags[3]), + ) +} + +#[target_feature(enable = "sse4.1")] +pub unsafe fn compress4_loop(jobs: &mut [Job; DEGREE], finalize: Finalize, stride: Stride) { + // If we're not finalizing, there can't be a partial block at the end. + for job in jobs.iter() { + input_debug_asserts(job.input, finalize); + } + + let msg_ptrs = [ + jobs[0].input.as_ptr(), + jobs[1].input.as_ptr(), + jobs[2].input.as_ptr(), + jobs[3].input.as_ptr(), + ]; + let mut h_vecs = transpose_state_vecs(&jobs); + let (mut counts_lo, mut counts_hi) = load_counts(&jobs); + + // Prepare the final blocks (note, which could be empty if the input is + // empty). Do all this before entering the main loop. + let min_len = jobs.iter().map(|job| job.input.len()).min().unwrap(); + let mut fin_offset = min_len.saturating_sub(1); + fin_offset -= fin_offset % stride.padded_blockbytes(); + // Performance note, making these buffers mem::uninitialized() seems to + // cause problems in the optimizer. + let mut buf0: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf1: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf2: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let mut buf3: [u8; BLOCKBYTES] = [0; BLOCKBYTES]; + let (block0, len0, finalize0) = final_block(jobs[0].input, fin_offset, &mut buf0, stride); + let (block1, len1, finalize1) = final_block(jobs[1].input, fin_offset, &mut buf1, stride); + let (block2, len2, finalize2) = final_block(jobs[2].input, fin_offset, &mut buf2, stride); + let (block3, len3, finalize3) = final_block(jobs[3].input, fin_offset, &mut buf3, stride); + let fin_blocks: [*const [u8; BLOCKBYTES]; DEGREE] = [block0, block1, block2, block3]; + let fin_counts_delta = set4(len0 as Word, len1 as Word, len2 as Word, len3 as Word); + let fin_last_block; + let fin_last_node; + if finalize.yes() { + fin_last_block = flags_vec([finalize0, finalize1, finalize2, finalize3]); + fin_last_node = flags_vec([ + finalize0 && jobs[0].last_node.yes(), + finalize1 && jobs[1].last_node.yes(), + finalize2 && jobs[2].last_node.yes(), + finalize3 && jobs[3].last_node.yes(), + ]); + } else { + fin_last_block = set1(0); + fin_last_node = set1(0); + } + + // The main loop. + let mut offset = 0; + loop { + let blocks; + let counts_delta; + let last_block; + let last_node; + if offset == fin_offset { + blocks = fin_blocks; + counts_delta = fin_counts_delta; + last_block = fin_last_block; + last_node = fin_last_node; + } else { + blocks = [ + msg_ptrs[0].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[1].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[2].add(offset) as *const [u8; BLOCKBYTES], + msg_ptrs[3].add(offset) as *const [u8; BLOCKBYTES], + ]; + counts_delta = set1(BLOCKBYTES as Word); + last_block = set1(0); + last_node = set1(0); + }; + + let m_vecs = transpose_msg_vecs(blocks); + add_to_counts(&mut counts_lo, &mut counts_hi, counts_delta); + compress4_transposed!( + &mut h_vecs, + &m_vecs, + counts_lo, + counts_hi, + last_block, + last_node, + ); + + // Check for termination before bumping the offset, to avoid overflow. + if offset == fin_offset { + break; + } + + offset += stride.padded_blockbytes(); + } + + // Write out the results. + untranspose_state_vecs(&h_vecs, &mut *jobs); + store_counts(&mut *jobs, counts_lo, counts_hi); + let max_consumed = offset.saturating_add(stride.padded_blockbytes()); + for job in jobs.iter_mut() { + let consumed = cmp::min(max_consumed, job.input.len()); + job.input = &job.input[consumed..]; + } +} diff --git a/src/plonk/blake2_const/blake2s/src/test.rs b/src/plonk/blake2_const/blake2s/src/test.rs new file mode 100644 index 000000000..79b197400 --- /dev/null +++ b/src/plonk/blake2_const/blake2s/src/test.rs @@ -0,0 +1,223 @@ +use super::*; + +const EMPTY_HASH: &str = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"; +const ABC_HASH: &str = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"; +const ONE_BLOCK_HASH: &str = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3"; +const THOUSAND_HASH: &str = "37e9dd47498579c5343fd282c13c62ea824cdfc9b0f4f747a41347414640f62c"; + +#[test] +fn test_update_state() { + let io = &[ + (&b""[..], EMPTY_HASH), + (&b"abc"[..], ABC_HASH), + (&[0; BLOCKBYTES], ONE_BLOCK_HASH), + (&[0; 1000], THOUSAND_HASH), + ]; + // Test each input all at once. + for &(input, output) in io { + let hash = blake2s(input); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } + // Now in two chunks. This is especially important for the ONE_BLOCK case, because it would be + // a mistake for update() to call compress, even though the buffer is full. + for &(input, output) in io { + let mut state = State::new(); + let split = input.len() / 2; + state.update(&input[..split]); + assert_eq!(split as Count, state.count()); + state.update(&input[split..]); + assert_eq!(input.len() as Count, state.count()); + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } + // Now one byte at a time. + for &(input, output) in io { + let mut state = State::new(); + let mut count = 0; + for &b in input { + state.update(&[b]); + count += 1; + assert_eq!(count, state.count()); + } + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } +} + +#[test] +fn test_from_const_state() { + let io = &[ + (&b""[..], EMPTY_HASH), + (&b"abc"[..], ABC_HASH), + (&[0; BLOCKBYTES], ONE_BLOCK_HASH), + (&[0; 1000], THOUSAND_HASH), + ]; + // Test each input all at once. + for &(input, output) in io { + let hash = blake2s_const(input); + assert_eq!(&hash.to_hex(), output, "hash mismatch"); + } +} + +#[test] +fn test_multiple_finalizes() { + let mut state = State::new(); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), EMPTY_HASH, "hash mismatch"); + state.update(b"abc"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); + assert_eq!(&state.finalize().to_hex(), ABC_HASH, "hash mismatch"); +} + +#[cfg(feature = "std")] +#[test] +fn test_write() { + use std::io::prelude::*; + + let mut state = State::new(); + state.write_all(&[0; 1000]).unwrap(); + let hash = state.finalize(); + assert_eq!(&hash.to_hex(), THOUSAND_HASH, "hash mismatch"); +} + +// You can check this case against the equivalent Python: +// +// import hashlib +// hashlib.blake2s( +// b'foo', +// digest_size=18, +// key=b"bar", +// salt=b"bazbazba", +// person=b"bing bin", +// fanout=2, +// depth=3, +// leaf_size=0x04050607, +// node_offset=0x08090a0b0c0d, +// node_depth=16, +// inner_size=17, +// last_node=True, +// ).hexdigest() +#[test] +fn test_all_parameters() { + let mut params = Params::new(); + params + .hash_length(18) + // Make sure a shorter key properly overwrites a longer one. + .key(b"not the real key") + .key(b"bar") + .salt(b"bazbazba") + .personal(b"bing bin") + .fanout(2) + .max_depth(3) + .max_leaf_length(0x04050607) + .node_offset(0x08090a0b0c0d) + .node_depth(16) + .inner_hash_length(17) + .last_node(true); + + // Check the State API. + assert_eq!( + "62361e5392ab0eb7dd27e48a6809ee82dc57", + ¶ms.to_state().update(b"foo").finalize().to_hex() + ); + + // Check the all-at-once API. + assert_eq!( + "62361e5392ab0eb7dd27e48a6809ee82dc57", + ¶ms.hash(b"foo").to_hex() + ); +} + +#[test] +fn test_all_parameters_blake2sp() { + let mut params = blake2sp::Params::new(); + params + .hash_length(18) + // Make sure a shorter key properly overwrites a longer one. + .key(b"not the real key") + .key(b"bar"); + + // Check the State API. + assert_eq!( + "947d4c671e2794f5e1a57daeca97bb46ed66", + ¶ms.to_state().update(b"foo").finalize().to_hex() + ); + + // Check the all-at-once API. + assert_eq!( + "947d4c671e2794f5e1a57daeca97bb46ed66", + ¶ms.hash(b"foo").to_hex() + ); +} + +#[test] +#[should_panic] +fn test_short_hash_length_panics() { + Params::new().hash_length(0); +} + +#[test] +#[should_panic] +fn test_long_hash_length_panics() { + Params::new().hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_long_key_panics() { + Params::new().key(&[0; KEYBYTES + 1]); +} + +#[test] +#[should_panic] +fn test_long_salt_panics() { + Params::new().salt(&[0; SALTBYTES + 1]); +} + +#[test] +#[should_panic] +fn test_long_personal_panics() { + Params::new().personal(&[0; PERSONALBYTES + 1]); +} + +#[test] +fn test_zero_max_depth_supported() { + Params::new().max_depth(0); +} + +#[test] +#[should_panic] +fn test_long_inner_hash_length_panics() { + Params::new().inner_hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_blake2sp_short_hash_length_panics() { + blake2sp::Params::new().hash_length(0); +} + +#[test] +#[should_panic] +fn test_blake2sp_long_hash_length_panics() { + blake2sp::Params::new().hash_length(OUTBYTES + 1); +} + +#[test] +#[should_panic] +fn test_blake2sp_long_key_panics() { + blake2sp::Params::new().key(&[0; KEYBYTES + 1]); +} + +#[test] +fn test_blake2sp_max_offset_ok() { + Params::new().node_offset((1 << 48) - 1); +} + +#[test] +#[should_panic] +fn test_blake2sp_offset_too_large_panics() { + Params::new().node_offset(1 << 48); +} diff --git a/src/plonk/blake2_const/run_all_tests/Cargo.toml b/src/plonk/blake2_const/run_all_tests/Cargo.toml new file mode 100644 index 000000000..613daf1d0 --- /dev/null +++ b/src/plonk/blake2_const/run_all_tests/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "run_all_tests" +version = "0.0.0" +authors = ["Jack O'Connor "] +edition = "2018" + +[dependencies] diff --git a/src/plonk/blake2_const/run_all_tests/src/main.rs b/src/plonk/blake2_const/run_all_tests/src/main.rs new file mode 100644 index 000000000..c20e87cd9 --- /dev/null +++ b/src/plonk/blake2_const/run_all_tests/src/main.rs @@ -0,0 +1,54 @@ +use std::env; +use std::path::{Path, PathBuf}; +use std::process::{self, Command}; + +fn project_root() -> &'static Path { + Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .expect("parent failed") +} + +fn run_test_command(project: &str, flags: &[&str]) { + let project_dir = Path::new(project_root()).join(project); + println!("=== TEST COMMAND ==="); + println!( + "cd {} && cargo test {}", + project_dir.to_string_lossy(), + flags.join(" ") + ); + println!(); + let status = Command::new(env!("CARGO")) + .arg("test") + .args(flags) + .current_dir(project_dir) + .status() + .expect("spawn failed"); + + if !status.success() { + process::exit(1); + } +} + +fn main() { + // Set CARGO_TARGET_DIR for all the test runs (unless the caller already set + // it), so that they can share build artifacts. + let target_dir = env::var_os("CARGO_TARGET_DIR") + .map(Into::::into) + .unwrap_or(project_root().join("target")); + env::set_var("CARGO_TARGET_DIR", &target_dir); + + // Test all the sub-projects under both std and no_std. + for &project in &["blake2b", "blake2s", ".", "blake2_bin"] { + for &no_std in &[false, true] { + let mut flags = Vec::new(); + if no_std { + flags.push("--no-default-features"); + } + run_test_command(project, &flags); + } + } + + // In addition, run the root project under release mode. This lets the fuzz + // tests use a much larger iteration count. + run_test_command(".", &["--release"]); +} diff --git a/src/plonk/blake2_const/tests/blake2-kat.json b/src/plonk/blake2_const/tests/blake2-kat.json new file mode 100644 index 000000000..149e5058a --- /dev/null +++ b/src/plonk/blake2_const/tests/blake2-kat.json @@ -0,0 +1,18434 @@ +[ +{ + "hash": "blake2s", + "in": "", + "key": "", + "out": "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9" +}, +{ + "hash": "blake2s", + "in": "00", + "key": "", + "out": "e34d74dbaf4ff4c6abd871cc220451d2ea2648846c7757fbaac82fe51ad64bea" +}, +{ + "hash": "blake2s", + "in": "0001", + "key": "", + "out": "ddad9ab15dac4549ba42f49d262496bef6c0bae1dd342a8808f8ea267c6e210c" +}, +{ + "hash": "blake2s", + "in": "000102", + "key": "", + "out": "e8f91c6ef232a041452ab0e149070cdd7dd1769e75b3a5921be37876c45c9900" +}, +{ + "hash": "blake2s", + "in": "00010203", + "key": "", + "out": "0cc70e00348b86ba2944d0c32038b25c55584f90df2304f55fa332af5fb01e20" +}, +{ + "hash": "blake2s", + "in": "0001020304", + "key": "", + "out": "ec1964191087a4fe9df1c795342a02ffc191a5b251764856ae5b8b5769f0c6cd" +}, +{ + "hash": "blake2s", + "in": "000102030405", + "key": "", + "out": "e1fa51618d7df4eb70cf0d5a9e906f806e9d19f7f4f01e3b621288e4120405d6" +}, +{ + "hash": "blake2s", + "in": "00010203040506", + "key": "", + "out": "598001fafbe8f94ec66dc827d012cfcbba2228569f448e89ea2208c8bf769293" +}, +{ + "hash": "blake2s", + "in": "0001020304050607", + "key": "", + "out": "c7e887b546623635e93e0495598f1726821996c2377705b93a1f636f872bfa2d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708", + "key": "", + "out": "c315a437dd28062a770d481967136b1b5eb88b21ee53d0329c5897126e9db02c" +}, +{ + "hash": "blake2s", + "in": "00010203040506070809", + "key": "", + "out": "bb473deddc055fea6228f207da575347bb00404cd349d38c18026307a224cbff" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a", + "key": "", + "out": "687e1873a8277591bb33d9adf9a13912efefe557cafc39a7952623e47255f16d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b", + "key": "", + "out": "1ac7ba754d6e2f94e0e86c46bfb262abbb74f450ef456d6b4d97aa80ce6da767" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c", + "key": "", + "out": "012c97809614816b5d9494477d4b687d15b96eb69c0e8074a8516f31224b5c98" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d", + "key": "", + "out": "91ffd26cfa4da5134c7ea262f7889c329f61f6a657225cc212f40056d986b3f4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e", + "key": "", + "out": "d97c828d8182a72180a06a78268330673f7c4e0635947c04c02323fd45c0a52d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "", + "out": "efc04cdc391c7e9119bd38668a534e65fe31036d6a62112e44ebeb11f9c57080" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "", + "out": "992cf5c053442a5fbc4faf583e04e50bb70d2f39fbb6a503f89e56a63e18578a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "", + "out": "38640e9f21983e67b539caccae5ecf615ae2764f75a09c9c59b76483c1fbc735" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "", + "out": "213dd34c7efe4fb27a6b35f6b4000d1fe03281af3c723e5c9f94747a5f31cd3b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "", + "out": "ec246eeeb9ced3f7ad33ed28660dd9bb0732513db4e2fa278b60cde3682a4ccd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "", + "out": "ac9b61d446648c3005d7892bf3a8719f4c8181cfdcbc2b79fef10a279b911095" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "", + "out": "7bf8b22959e34e3a43f7079223e83a9754617d391e213dfd808e41b9bead4ce7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "", + "out": "68d4b5d4fa0e302b64ccc5af792913ac4c88ec95c07ddf40694256eb88ce9f3d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "", + "out": "b2c2420f05f9abe36315919336b37e4e0fa33ff7e76a492767006fdb5d935462" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "", + "out": "134f61bbd0bbb69aed5343904551a3e6c1aa7dcdd77e903e7023eb7c60320aa7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "", + "out": "4693f9bff7d4f3986a7d176e6e06f72ad1490d805c99e25347b8de77b4db6d9b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "", + "out": "853e26f741953b0fd5bdb424e8ab9e8b3750eaa8ef61e47902c91e554e9c73b9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "", + "out": "f7de536361abaa0e158156cf0ea4f63a99b5e4054f8fa4c9d45f6285cad55694" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "", + "out": "4c230608860a99ae8d7bd5c2cc17fa52096b9a61bedb17cb7617864ad29ca7a6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "", + "out": "aeb920ea87952dadb1fb759291e3388139a872865001886ed84752e93c250c2a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "", + "out": "aba4ad9b480b9df3d08ca5e87b0c2440d4e4ea21224c2eb42cbae469d089b931" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "", + "out": "05825607d7fdf2d82ef4c3c8c2aea961ad98d60edff7d018983e21204c0d93d1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "", + "out": "a742f8b6af82d8a6ca2357c5f1cf91defbd066267d75c048b352366585025962" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "", + "out": "2bcac89599000b42c95ae23835a713704ed79789c84fef149a874ff733f017a2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "", + "out": "ac1ed07d048f105a9e5b7ab85b09a492d5baff14b8bfb0e9fd789486eea2b974" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "", + "out": "e48d0ecfaf497d5b27c25d99e156cb0579d440d6e31fb62473696dbf95e010e4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "", + "out": "12a91fadf8b21644fd0f934f3c4a8f62ba862ffd20e8e961154c15c13884ed3d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "", + "out": "7cbee96e139897dc98fbef3be81ad4d964d235cb12141fb66727e6e5df73a878" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "", + "out": "ebf66abb597ae572a7297cb0871e355accafad8377b8e78bf164ce2a18de4baf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "", + "out": "71b933b07e4ff7818ce059d008829e453c6ff02ec0a7db393fc2d870f37a7286" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "", + "out": "7cf7c51331220b8d3ebaed9c29398a16d98156e2613cb088f2b0e08a1be4cf4f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "", + "out": "3e41a108e0f64ad276b979e1ce068279e16f7bc7e4aa1d211e17b81161df1602" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "", + "out": "886502a82ab47ba8d86710aa9de3d46ea65c47af6ee8de450cceb8b11b045f50" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "", + "out": "c021bc5f0954fee94f46ea09487e10a84840d02f64810bc08d9e551f7d416814" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "", + "out": "2030516e8a5fe19ae79c336fce26382a749d3fd0ec91e537d4bd2358c12dfb22" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "", + "out": "556698dac8317fd36dfbdf25a79cb112d5425860605cbaf507f23bf7e9f42afe" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "", + "out": "2f867ba67773fdc3e92fced99a6409ad39d0b880fde8f109a81730c4451d0178" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "", + "out": "172ec218f119dfae98896dff29dd9876c94af87417f9ae4c7014bb4e4b96afc7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "", + "out": "3f85814a18195f879aa962f95d26bd82a278f2b82320218f6b3bd6f7f667a6d9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "", + "out": "1b618fbaa566b3d498c12e982c9ec52e4da85a8c54f38f34c090394f23c184c1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "", + "out": "0c758fb5692ffd41a3575d0af00cc7fbf2cbe5905a58323a88ae4244f6e4c993" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "", + "out": "a931360cad628c7f12a6c1c4b753b0f4062aef3ce65a1ae3f19369dadf3ae23d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "", + "out": "cbac7d773b1e3b3c6691d7abb7e9df045c8ba19268ded153207f5e804352ec5d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "", + "out": "23a196d3802ed3c1b384019a82325840d32f71950c4580b03445e0898e14053c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "", + "out": "f4495470f226c8c214be08fdfad4bc4a2a9dbea9136a210df0d4b64929e6fc14" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "", + "out": "e290dd270b467f34ab1c002d340fa016257ff19e5833fdbbf2cb401c3b2817de" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "", + "out": "9fc7b5ded3c15042b2a6582dc39be016d24a682d5e61ad1eff9c63309848f706" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "", + "out": "8cca67a36d17d5e6341cb592fd7bef9926c9e3aa1027ea11a7d8bd260b576e04" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "", + "out": "409392f560f86831da4373ee5e0074260595d7bc24183b60ed700d4583d3f6f0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "", + "out": "2802165de090915546f3398cd849164a19f92adbc361adc99b0f20c8ea071054" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "", + "out": "ad839168d9f8a4be95ba9ef9a692f07256ae43fe6f9864e290691b0256ce50a9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "", + "out": "75fdaa5038c284b86d6e8affe8b2807e467b86600e79af3689fbc06328cbf894" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "", + "out": "e57cb79487dd57902432b250733813bd96a84efce59f650fac26e6696aefafc3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "", + "out": "56f34e8b96557e90c1f24b52d0c89d51086acf1b00f634cf1dde9233b8eaaa3e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "", + "out": "1b53ee94aaf34e4b159d48de352c7f0661d0a40edff95a0b1639b4090e974472" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "", + "out": "05705e2a81757c14bd383ea98dda544eb10e6bc07bae435e2518dbe133525375" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "", + "out": "d8b2866e8a309db53e529ec32911d82f5ca16cff76216891a9676aa31aaa6c42" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "", + "out": "f5041c241270eb04c71ec2c95d4c38d803b1237b0f29fd4db3eb397669e88699" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "", + "out": "9a4ce077c349322f595e0ee79ed0da5fab66752cbfef8f87d0e9d0723c7530dd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "", + "out": "657b09f3d0f52b5b8f2f97163a0edf0c04f075408a07bbeb3a4101a891990d62" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "", + "out": "1e3f7bd5a58fa533344aa8ed3ac122bb9e70d4ef50d004530821948f5fe6315a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "", + "out": "80dccf3fd83dfd0d35aa28585922ab89d5313997673eaf905cea9c0b225c7b5f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "", + "out": "8a0d0fbf6377d83bb08b514b4b1c43acc95d751714f8925645cb6bc856ca150a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "", + "out": "9fa5b487738ad2844cc6348a901918f659a3b89e9c0dfeead30dd94bcf42ef8e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "", + "out": "80832c4a1677f5ea2560f668e9354dd36997f03728cfa55e1b38337c0c9ef818" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "", + "out": "ab37ddb683137e74080d026b590b96ae9bb447722f305a5ac570ec1df9b1743c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "", + "out": "3ee735a694c2559b693aa68629361e15d12265ad6a3dedf488b0b00fac9754ba" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "", + "out": "d6fcd23219b647e4cbd5eb2d0ad01ec8838a4b2901fc325cc3701981ca6c888b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "", + "out": "0520ec2f5bf7a755dacb50c6bf233e3515434763db0139ccd9faefbb8207612d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "", + "out": "aff3b75f3f581264d7661662b92f5ad37c1d32bd45ff81a4ed8adc9ef30dd989" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "", + "out": "d0dd650befd3ba63dc25102c627c921b9cbeb0b130686935b5c927cb7ccd5e3b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "", + "out": "e1149816b10a8514fb3e2cab2c08bee9f73ce76221701246a589bbb67302d8a9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "", + "out": "7da3f441de9054317e72b5dbf979da01e6bceebb8478eae6a22849d90292635c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "", + "out": "1230b1fc8a7d9215edc2d4a2decbdd0a6e216c924278c91fc5d10e7d60192d94" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "", + "out": "5750d716b4808f751febc38806ba170bf6d5199a7816be514e3f932fbe0cb871" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "", + "out": "6fc59b2f10feba954aa6820b3ca987ee81d5cc1da3c63ce827301c569dfb39ce" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "", + "out": "c7c3fe1eebdc7b5a939326e8ddb83e8bf2b780b65678cb62f208b040abdd35e2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "", + "out": "0c75c1a15cf34a314ee478f4a5ce0b8a6b36528ef7a820696c3e4246c5a15864" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "", + "out": "216dc12a108569a3c7cdde4aed43a6c330139dda3ccc4a108905db3861899050" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "", + "out": "a57be6ae6756f28b02f59dadf7e0d7d8807f10fa15ced1ad3585521a1d995a89" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "", + "out": "816aef875953716cd7a581f732f53dd435dab66d09c361d2d6592de17755d8a8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "", + "out": "9a76893226693b6ea97e6a738f9d10fb3d0b43ae0e8b7d8123ea76ce97989c7e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "", + "out": "8daedb9a271529dbb7dc3b607fe5eb2d3211770758dd3b0a3593d2d7954e2d5b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "", + "out": "16dbc0aa5dd2c774f505100f733786d8a175fcbbb59c43e1fbff3e1eaf31cb4a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "", + "out": "8606cb899c6aeaf51b9db0fe4924a9fd5dabc19f8826f2bc1c1d7da14d2c2c99" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "", + "out": "8479731aeda57bd37eadb51a507e307f3bd95e69dbca94f3bc21726066ad6dfd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "", + "out": "58473a9ea82efa3f3b3d8fc83ed8863127b33ae8deae6307201edb6dde61de29" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "", + "out": "9a9255d53af116de8ba27ce35b4c7e15640657a0fcb888c70d95431dacd8f830" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "", + "out": "9eb05ffba39fd8596a45493e18d2510bf3ef065c51d6e13abe66aa57e05cfdb7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "", + "out": "81dcc3a505eace3f879d8f702776770f9df50e521d1428a85daf04f9ad2150e0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "", + "out": "e3e3c4aa3acbbc85332af9d564bc24165e1687f6b1adcbfae77a8f03c72ac28c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "", + "out": "6746c80b4eb56aea45e64e7289bba3edbf45ecf8206481ff6302122984cd526a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "", + "out": "2b628e52764d7d62c0868b212357cdd12d9149822f4e9845d918a08d1ae990c0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "", + "out": "e4bfe80d58c91994613909dc4b1a12496896c004af7b5701483de45d2823d78e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "", + "out": "ebb4ba150cef2734345b5d641bbed03a21eafae933c99e009212ef04574a8530" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "", + "out": "3966ec73b154acc697ac5cf5b24b40bdb0db9e398836d76d4b880e3b2af1aa27" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "", + "out": "ef7e4831b3a84636518d6e4bfce64a43db2a5dda9cca2b44f39033bdc40d6243" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "", + "out": "7abf6acf5c8e549ddbb15ae8d8b388c1c197e698737c9785501ed1f94930b7d9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "", + "out": "88018ded66813f0ca95def474c630692019967b9e36888dadd94124719b682f6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "", + "out": "3930876b9fc7529036b008b1b8bb997522a441635a0c25ec02fb6d9026e55a97" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "", + "out": "0a4049d57e833b5695fac93dd1fbef3166b44b12ad11248662383ae051e15827" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "", + "out": "81dcc0678bb6a765e48c3209654fe90089ce44ff5618477e39ab286476df052b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "", + "out": "e69b3a36a4461912dc08346b11ddcb9db796f885fd01936e662fe29297b099a4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "", + "out": "5ac6503b0d8da6917646e6dcc87edc58e94245324cc204f4dd4af01563acd427" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "", + "out": "df6dda21359a30bc271780971c1abd56a6ef167e480887888e73a86d3bf605e9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "", + "out": "e8e6e47071e7b7df2580f225cfbbedf84ce67746626628d33097e4b7dc571107" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "", + "out": "53e40ead62051e19cb9ba8133e3e5c1ce00ddcad8acf342a224360b0acc14777" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "", + "out": "9ccd53fe80be786aa984638462fb28afdf122b34d78f4687ec632bb19de2371a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "", + "out": "cbd48052c48d788466a3e8118c56c97fe146e5546faaf93e2bc3c47e45939753" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "", + "out": "256883b14e2af44dadb28e1b34b2ac0f0f4c91c34ec9169e29036158acaa95b9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "", + "out": "4471b91ab42db7c4dd8490ab95a2ee8d04e3ef5c3d6fc71ac74b2b26914d1641" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "", + "out": "a5eb08038f8f1155ed86e631906fc13095f6bba41de5d4e795758ec8c8df8af1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "", + "out": "dc1db64ed8b48a910e060a6b866374c578784e9ac49ab2774092ac71501934ac" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "", + "out": "285413b2f2ee873d34319ee0bbfbb90f32da434cc87e3db5ed121bb398ed964b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "", + "out": "0216e0f81f750f26f1998bc3934e3e124c9945e685a60b25e8fbd9625ab6b599" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "", + "out": "38c410f5b9d4072050755b31dca89fd5395c6785eeb3d790f320ff941c5a93bf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "", + "out": "f18417b39d617ab1c18fdf91ebd0fc6d5516bb34cf39364037bce81fa04cecb1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "", + "out": "1fa877de67259d19863a2a34bcc6962a2b25fcbf5cbecd7ede8f1fa36688a796" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "", + "out": "5bd169e67c82c2c2e98ef7008bdf261f2ddf30b1c00f9e7f275bb3e8a28dc9a2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "", + "out": "c80abeebb669ad5deeb5f5ec8ea6b7a05ddf7d31ec4c0a2ee20b0b98caec6746" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "", + "out": "e76d3fbda5ba374e6bf8e50fadc3bbb9ba5c206ebdec89a3a54cf3dd84a07016" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "", + "out": "7bba9dc5b5db2071d17752b1044c1eced96aaf2dd46e9b433750e8ea0dcc1870" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "", + "out": "f29b1b1ab9bab163018ee3da15232cca78ec52dbc34eda5b822ec1d80fc21bd0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "", + "out": "9ee3e3e7e900f1e11d308c4b2b3076d272cf70124f9f51e1da60f37846cdd2f4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "", + "out": "70ea3b0176927d9096a18508cd123a290325920a9d00a89b5de04273fbc76b85" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "", + "out": "67de25c02a4aaba23bdc973c8bb0b5796d47cc0659d43dff1f97de174963b68e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "", + "out": "b2168e4e0f18b0e64100b517ed95257d73f0620df885c13d2ecf79367b384cee" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "", + "out": "2e7dec2428853b2c71760745541f7afe9825b5dd77df06511d8441a94bacc927" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "", + "out": "ca9ffac4c43f0b48461dc5c263bea3f6f00611ceacabf6f895ba2b0101dbb68d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "", + "out": "7410d42d8fd1d5e9d2f5815cb93417998828ef3c4230bfbd412df0a4a7a2507a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "", + "out": "5010f684516dccd0b6ee0852c2512b4dc0066cf0d56f35302978db8ae32c6a81" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "", + "out": "acaab585f7b79b719935ceb89523ddc54827f75c56883856154a56cdcd5ee988" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "", + "out": "666de5d1440fee7331aaf0123a62ef2d8ba57453a0769635ac6cd01e633f7712" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "", + "out": "a6f98658f6eabaf902d8b3871a4b101d16196e8a4b241e1558fe29966e103e8d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "", + "out": "891546a8b29f3047ddcfe5b00e45fd55756373105ea8637dfcff547b6ea9535f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "", + "out": "18dfbc1ac5d25b0761137dbd22c17c829d0f0ef1d82344e9c89c286694da24e8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "", + "out": "b54b9b67f8fed54bbf5a2666dbdf4b23cff1d1b6f4afc985b2e6d3305a9ff80f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "", + "out": "7db442e132ba59bc1289aa98b0d3e806004f8ec12811af1e2e33c69bfde729e1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "", + "out": "250f37cdc15e817d2f160d9956c71fe3eb5db74556e4adf9a4ffafba74010396" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "", + "out": "4ab8a3dd1ddf8ad43dab13a27f66a6544f290597fa96040e0e1db9263aa479f8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "", + "out": "ee61727a0766df939ccdc860334044c79a3c9b156200bc3aa32973483d8341ae" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "", + "out": "3f68c7ec63ac11ebb98f94b339b05c104984fda50103060144e5a2bfccc9da95" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "", + "out": "056f29816b8af8f56682bc4d7cf094111da7733e726cd13d6b3e8ea03e92a0d5" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "", + "out": "f5ec43a28acbeff1f3318a5bcac7c66ddb5230b79db2d105bcbe15f3c1148d69" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "", + "out": "2a6960ad1d8dd547555cfbd5e4600f1eaa1c8eda34de0374ec4a26eaaaa33b4e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "", + "out": "dcc1ea7baab93384f76b796866199754742f7b96d6b4c120165c04a6c4f5ce10" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "", + "out": "13d5df179221379c6a78c07c793ff53487cae6bf9fe882541ab0e735e3eada3b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "", + "out": "8c59e4407641a01e8ff91f9980dc236f4ecd6fcf52589a099a961633967714e1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "", + "out": "833b1ac6a251fd08fd6d908fea2a4ee1e040bca93fc1a38ec3820e0c10bd82ea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "", + "out": "a244f927f3b40b8f6c391570c765418f2f6e708eac9006c51a7feff4af3b2b9e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "", + "out": "3d99ed9550cf1196e6c4d20c259620f858c3d703374c128ce7b590310c83046d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "", + "out": "2b35c47d7b87761f0ae43ac56ac27b9f25830367b595be8c240e94600c6e3312" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "", + "out": "5d11ed37d24dc767305cb7e1467d87c065ac4bc8a426de38991ff59aa8735d02" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "", + "out": "b836478e1ca0640dce6fd910a5096272c8330990cd97864ac2bf14ef6b23914a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "", + "out": "9100f946d6ccde3a597f90d39fc1215baddc7413643d85c21c3eee5d2dd32894" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "", + "out": "da70eedd23e663aa1a74b9766935b479222a72afba5c795158dad41a3bd77e40" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "", + "out": "f067ed6a0dbd43aa0a9254e69fd66bdd8acb87de936c258cfb02285f2c11fa79" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "", + "out": "715c99c7d57580cf9753b4c1d795e45a83fbb228c0d36fbe20faf39bdd6d4e85" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "", + "out": "e457d6ad1e67cb9bbd17cbd698fa6d7dae0c9b7ad6cbd6539634e32a719c8492" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "", + "out": "ece3ea8103e02483c64a70a4bdcee8ceb6278f2533f3f48dbeedfba94531d4ae" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "", + "out": "388aa5d3667a97c68d3d56f8f3ee8d3d36091f17fe5d1b0d5d84c93b2ffe40bd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "", + "out": "8b6b31b9ad7c3d5cd84bf98947b9cdb59df8a25ff738101013be4fd65e1dd1a3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "", + "out": "066291f6bbd25f3c853db7d8b95c9a1cfb9bf1c1c99fb95a9b7869d90f1c2903" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "", + "out": "a707efbccdceed42967a66f5539b93ed7560d467304016c4780d7755a565d4c4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "", + "out": "38c53dfb70be7e792b07a6a35b8a6a0aba02c5c5f38baf5c823fdfd9e42d657e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "", + "out": "f2911386501d9ab9d720cf8ad10503d5634bf4b7d12b56dfb74fecc6e4093f68" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "", + "out": "c6f2bdd52b81e6e4f6595abd4d7fb31f651169d00ff326926b34947b28a83959" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "", + "out": "293d94b18c98bb3223366b8ce74c28fbdf28e1f84a3350b0eb2d1804a577579b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "", + "out": "2c2fa5c0b51533165bc375c22e2781768270a383985d13bd6b67b6fd67f889eb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "", + "out": "caa09b82b72562e43f4b2275c091918e624d911661cc811bb5faec51f6088ef7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "", + "out": "24761e45e674395379fb17729c78cb939e6f74c5dffb9c961f495982c3ed1fe3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "", + "out": "55b70a82131ec94888d7ab54a7c515255c3938bb10bc784dc9b67f076e341a73" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "", + "out": "6ab9057b977ebc3ca4d4ce74506c25cccdc566497c450b5415a39486f8657a03" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "", + "out": "24066deee0ecee15a45f0a326d0f8dbc79761ebb93cf8c0377af440978fcf994" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "", + "out": "20000d3f66ba76860d5a950688b9aa0d76cfea59b005d859914b1a46653a939b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "", + "out": "b92daa79603e3bdbc3bfe0f419e409b2ea10dc435beefe2959da16895d5dca1c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "", + "out": "e947948705b206d572b0e8f62f66a6551cbd6bc305d26ce7539a12f9aadf7571" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "", + "out": "3d67c1b3f9b23910e3d35e6b0f2ccf44a0b540a45c18ba3c36264dd48e96af6a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "", + "out": "c7558babda04bccb764d0bbf3358425141902d22391d9f8c59159fec9e49b151" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "", + "out": "0b732bb035675a50ff58f2c242e4710aece64670079c13044c79c9b7491f7000" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "", + "out": "d120b5ef6d57ebf06eaf96bc933c967b16cbe6e2bf00741c30aa1c54ba64801f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "", + "out": "58d212ad6f58aef0f80116b441e57f6195bfef26b61463edec1183cdb04fe76d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "", + "out": "b8836f51d1e29bdfdba325565360268b8fad627473edecef7eaefee837c74003" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "", + "out": "c547a3c124ae5685ffa7b8edaf96ec86f8b2d0d50cee8be3b1f0c76763069d9c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "", + "out": "5d168b769a2f67853d6295f7568be40bb7a16b8d65ba87635d1978d2ab11ba2a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "", + "out": "a2f675dc7302638cb60201064ca55077714d71fe096a315f2fe7401277caa5af" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "", + "out": "c8aab5cd0160ae78cd2e8ac5fb0e093cdb5c4b6052a0a97bb04216826fa7a437" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "", + "out": "ff68ca4035bfeb43fbf145fddd5e43f1cea54f11f7bee13058f027329a4a5fa4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "", + "out": "1d4e5487ae3c740f2ba6e541ac91bc2bfcd2999c518d807b426748803a350fd4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "", + "out": "6d244e1a06ce4ef578dd0f63aff0936706735119ca9c8d22d86c801414ab9741" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "", + "out": "decf7329dbcc827b8fc524c9431e8998029ece12ce93b7b2f3e769a941fb8cea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "", + "out": "2fafcc0f2e63cbd07755be7b75ecea0adff9aa5ede2a52fdab4dfd0374cd483f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "", + "out": "aa85010dd46a546b535ef4cf5f07d65161e89828f3a77db7b9b56f0df59aae45" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "", + "out": "07e8e1ee732cb0d356c9c0d1069c89d17adf6a9a334f745ec7867332548ca8e9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "", + "out": "0e01e81cada8162bfd5f8a8c818a6c69fedf02ceb5208523cbe5313b89ca1053" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "", + "out": "6bb6c6472655084399852e00249f8cb247896d392b02d73b7f0dd818e1e29b07" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "", + "out": "42d4636e2060f08f41c882e76b396b112ef627cc24c43dd5f83a1d1a7ead711a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "", + "out": "4858c9a188b0234fb9a8d47d0b4133650a030bd0611b87c3892e94951f8df852" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "", + "out": "3fab3e36988d445a51c8783e531be3a02be40cd04796cfb61d40347442d3f794" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "", + "out": "ebabc49636bd433d2ec8f0e518732ef8fa21d4d071cc3bc46cd79fa38a28b810" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "", + "out": "a1d0343523b893fca84f47feb4a64d350a17d8eef5497ece697d02d79178b591" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "", + "out": "262ebfd9130b7d28760d08ef8bfd3b86cdd3b2113d2caef7ea951a303dfa3846" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "", + "out": "f76158edd50a154fa78203ed2362932fcb8253aae378903eded1e03f7021a257" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "", + "out": "26178e950ac722f67ae56e571b284c0207684a6334a17748a94d260bc5f55274" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "", + "out": "c378d1e493b40ef11fe6a15d9c2737a37809634c5abad5b33d7e393b4ae05d03" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "", + "out": "984bd8379101be8fd80612d8ea2959a7865ec9718523550107ae3938df32011b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "", + "out": "c6f25a812a144858ac5ced37a93a9f4759ba0b1c0fdc431dce35f9ec1f1f4a99" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "", + "out": "924c75c94424ff75e74b8b4e94358958b027b171df5e57899ad0d4dac37353b6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "", + "out": "0af35892a63f45931f6846ed190361cd073089e077165714b50b81a2e3dd9ba1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "", + "out": "cc80cefb26c3b2b0daef233e606d5ffc80fa17427d18e30489673e06ef4b87f7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "", + "out": "c2f8c8117447f3978b0818dcf6f70116ac56fd184dd1278494e103fc6d74a887" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "", + "out": "bdecf6bfc1ba0df6e862c831992207796acc797968358828c06e7a51e090098f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "", + "out": "24d1a26e3dab02fe4572d2aa7dbd3ec30f0693db26f273d0ab2cb0c13b5e6451" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "", + "out": "ec56f58b09299a300b140565d7d3e68782b6e2fbeb4b7ea97ac057989061dd3f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "", + "out": "11a437c1aba3c119ddfab31b3e8c841deeeb913ef57f7e48f2c9cf5a28fa42bc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "", + "out": "53c7e6114b850a2cb496c9b3c69a623eaea2cb1d33dd817e4765edaa6823c228" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "", + "out": "154c3e96fee5db14f8773e18af14857913509da999b46cdd3d4c169760c83ad2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "", + "out": "40b9916f093e027a8786641818920620472fbcf68f701d1b680632e6996bded3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "", + "out": "24c4cbba07119831a726b05305d96da02ff8b148f0da440fe233bcaa32c72f6f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "", + "out": "5d201510250020b783689688abbf8ecf2594a96a08f2bfec6ce0574465dded71" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "", + "out": "043b97e336ee6fdbbe2b50f22af83275a4084805d2d5645962454b6c9b8053a0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "", + "out": "564835cbaea774948568be36cf52fcdd83934eb0a27512dbe3e2db47b9e6635a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "", + "out": "f21c33f47bde40a2a101c9cde8027aaf61a3137de2422b30035a04c270894183" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "", + "out": "9db0ef74e66cbb842eb0e07343a03c5c567e372b3f23b943c788a4f250f67891" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "", + "out": "ab8d08655ff1d3fe8758d562235fd23e7cf9dcaad658872a49e5d3183b6ccebd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "", + "out": "6f27f77e7bcf46a1e963ade0309733543031dccdd47caac174d7d27ce8077e8b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "", + "out": "e3cd54da7e444caa6207569525a670ebae1278de4e3fe2684b3e33f5ef90cc1b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "", + "out": "b2c3e33a51d22c4c08fc0989c873c9cc4150579b1e6163fa694ad51d53d712dc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "", + "out": "be7fda983e13189b4c77e0a80920b6e0e0ea80c3b84dbe7e7117d253f48112f4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "", + "out": "b6008c28fae08aa427e5bd3aad36f10021f16c77cfeabed07f97cc7dc1f1284a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "", + "out": "6e4e6760c538f2e97b3adbfbbcde57f8966b7ea8fcb5bf7efec913fd2a2b0c55" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "", + "out": "4ae51fd1834aa5bd9a6f7ec39fc663338dc5d2e20761566d90cc68b1cb875ed8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "", + "out": "b673aad75ab1fdb5401abfa1bf89f3add2ebc468df3624a478f4fe859d8d55e2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "", + "out": "13c9471a9855913539836660398da0f3f99ada08479c69d1b7fcaa3461dd7e59" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "", + "out": "2c11f4a7f99a1d23a58bb636350fe849f29cbac1b2a1112d9f1ed5bc5b313ccd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "", + "out": "c7d3c0706b11ae741c05a1ef150dd65b5494d6d54c9a86e2617854e6aeeebbd9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "", + "out": "194e10c93893afa064c3ac04c0dd808d791c3d4b7556e89d8d9cb225c4b33339" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "", + "out": "6fc4988b8f78546b1688991845908f134b6a482e6994b3d48317bf08db292185" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "", + "out": "5665beb8b0955525813b5981cd142ed4d03fba38a6f3e5ad268e0cc270d1cd11" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "", + "out": "b883d68f5fe51936431ba4256738053b1d0426d4cb64b16e83badc5e9fbe3b81" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "", + "out": "53e7b27ea59c2f6dbb50769e43554df35af89f4822d0466b007dd6f6deafff02" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "", + "out": "1f1a0229d4640f01901588d9dec22d13fc3eb34a61b32938efbf5334b2800afa" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "", + "out": "c2b405afa0fa6668852aee4d88040853fab800e72b57581418e5506f214c7d1f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "", + "out": "c08aa1c286d709fdc7473744977188c895ba011014247e4efa8d07e78fec695c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "", + "out": "f03f5789d3336b80d002d59fdf918bdb775b00956ed5528e86aa994acb38fe2d" +}, +{ + "hash": "blake2s", + "in": "", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "48a8997da407876b3d79c0d92325ad3b89cbb754d86ab71aee047ad345fd2c49" +}, +{ + "hash": "blake2s", + "in": "00", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "40d15fee7c328830166ac3f918650f807e7e01e177258cdc0a39b11f598066f1" +}, +{ + "hash": "blake2s", + "in": "0001", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6bb71300644cd3991b26ccd4d274acd1adeab8b1d7914546c1198bbe9fc9d803" +}, +{ + "hash": "blake2s", + "in": "000102", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d220dbe2ee134661fdf6d9e74b41704710556f2f6e5a091b227697445dbea6b" +}, +{ + "hash": "blake2s", + "in": "00010203", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f6c3fbadb4cc687a0064a5be6e791bec63b868ad62fba61b3757ef9ca52e05b2" +}, +{ + "hash": "blake2s", + "in": "0001020304", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "49c1f21188dfd769aea0e911dd6b41f14dab109d2b85977aa3088b5c707e8598" +}, +{ + "hash": "blake2s", + "in": "000102030405", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fdd8993dcd43f696d44f3cea0ff35345234ec8ee083eb3cada017c7f78c17143" +}, +{ + "hash": "blake2s", + "in": "00010203040506", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e6c8125637438d0905b749f46560ac89fd471cf8692e28fab982f73f019b83a9" +}, +{ + "hash": "blake2s", + "in": "0001020304050607", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "19fc8ca6979d60e6edd3b4541e2f967ced740df6ec1eaebbfe813832e96b2974" +}, +{ + "hash": "blake2s", + "in": "000102030405060708", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a6ad777ce881b52bb5a4421ab6cdd2dfba13e963652d4d6d122aee46548c14a7" +}, +{ + "hash": "blake2s", + "in": "00010203040506070809", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f5c4b2ba1a00781b13aba0425242c69cb1552f3f71a9a3bb22b4a6b4277b46dd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e33c4c9bd0cc7e45c80e65c77fa5997fec7002738541509e68a9423891e822a3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fba16169b2c3ee105be6e1e650e5cbf40746b6753d036ab55179014ad7ef6651" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f5c4bec6d62fc608bf41cc115f16d61c7efd3ff6c65692bbe0afffb1fede7475" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a4862e76db847f05ba17ede5da4e7f91b5925cf1ad4ba12732c3995742a5cd6e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "65f4b860cd15b38ef814a1a804314a55be953caa65fd758ad989ff34a41c1eea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "19ba234f0a4f38637d1839f9d9f76ad91c8522307143c97d5f93f69274cec9a7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1a67186ca4a5cb8e65fca0e2ecbc5ddc14ae381bb8bffeb9e0a103449e3ef03c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "afbea317b5a2e89c0bd90ccf5d7fd0ed57fe585e4be3271b0a6bf0f5786b0f26" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f1b01558ce541262f5ec34299d6fb4090009e3434be2f49105cf46af4d2d4124" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "13a0a0c86335635eaa74ca2d5d488c797bbb4f47dc07105015ed6a1f3309efce" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1580afeebebb346f94d59fe62da0b79237ead7b1491f5667a90e45edf6ca8b03" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "20be1a875b38c573dd7faaa0de489d655c11efb6a552698e07a2d331b5f655c3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "be1fe3c4c04018c54c4a0f6b9a2ed3c53abe3a9f76b4d26de56fc9ae95059a99" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e3e3ace537eb3edd8463d9ad3582e13cf86533ffde43d668dd2e93bbdbd7195a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "110c50c0bf2c6e7aeb7e435d92d132ab6655168e78a2decdec3330777684d9c1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e9ba8f505c9c80c08666a701f3367e6cc665f34b22e73c3c0417eb1c2206082f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "26cd66fca02379c76df12317052bcafd6cd8c3a7b890d805f36c49989782433a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "213f3596d6e3a5d0e9932cd2159146015e2abc949f4729ee2632fe1edb78d337" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1015d70108e03be1c702fe97253607d14aee591f2413ea6787427b6459ff219a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3ca989de10cfe609909472c8d35610805b2f977734cf652cc64b3bfc882d5d89" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b6156f72d380ee9ea6acd190464f2307a5c179ef01fd71f99f2d0f7a57360aea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c03bc642b20959cbe133a0303e0c1abff3e31ec8e1a328ec8565c36decff5265" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2c3e08176f760c6264c3a2cd66fec6c3d78de43fc192457b2a4a660a1e0eb22b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f738c02f3c1b190c512b1a32deabf353728e0e9ab034490e3c3409946a97aeec" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8b1880df301cc963418811088964839287ff7fe31c49ea6ebd9e48bdeee497c5" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1e75cb21c60989020375f1a7a242839f0b0b68973a4c2a05cf7555ed5aaec4c1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "62bf8a9c32a5bccf290b6c474d75b2a2a4093f1a9e27139433a8f2b3bce7b8d7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "166c8350d3173b5e702b783dfd33c66ee0432742e9b92b997fd23c60dc6756ca" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "044a14d822a90cacf2f5a101428adc8f4109386ccb158bf905c8618b8ee24ec3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "387d397ea43a994be84d2d544afbe481a2000f55252696bba2c50c8ebd101347" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "56f8ccf1f86409b46ce36166ae9165138441577589db08cbc5f66ca29743b9fd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9706c092b04d91f53dff91fa37b7493d28b576b5d710469df79401662236fc03" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "877968686c068ce2f7e2adcff68bf8748edf3cf862cfb4d3947a3106958054e3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8817e5719879acf7024787eccdb271035566cfa333e049407c0178ccc57a5b9f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8938249e4b50cadaccdf5b18621326cbb15253e33a20f5636e995d72478de472" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f164abba4963a44d107257e3232d90aca5e66a1408248c51741e991db5227756" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d05563e2b1cba0c4a2a1e8bde3a1a0d9f5b40c85a070d6f5fb21066ead5d0601" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "03fbb16384f0a3866f4c3117877666efbf124597564b293d4aab0d269fabddfa" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5fa8486ac0e52964d1881bbe338eb54be2f719549224892057b4da04ba8b3475" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cdfabcee46911111236a31708b2539d71fc211d9b09c0d8530a11e1dbf6eed01" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4f82de03b9504793b82a07a0bdcdff314d759e7b62d26b784946b0d36f916f52" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "259ec7f173bcc76a0994c967b4f5f024c56057fb79c965c4fae41875f06a0e4c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "193cc8e7c3e08bb30f5437aa27ade1f142369b246a675b2383e6da9b49a9809e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5c10896f0e2856b2a2eee0fe4a2c1633565d18f0e93e1fab26c373e8f829654d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f16012d93f28851a1eb989f5d0b43f3f39ca73c9a62d5181bff237536bd348c3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2966b3cfae1e44ea996dc5d686cf25fa053fb6f67201b9e46eade85d0ad6b806" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ddb8782485e900bc60bcf4c33a6fd585680cc683d516efa03eb9985fad8715fb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4c4d6e71aea05786413148fc7a786b0ecaf582cff1209f5a809fba8504ce662c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fb4c5e86d7b2229b99b8ba6d94c247ef964aa3a2bae8edc77569f28dbbff2d4e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e94f526de9019633ecd54ac6120f23958d7718f1e7717bf329211a4faeed4e6d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cbd6660a10db3f23f7a03d4b9d4044c7932b2801ac89d60bc9eb92d65a46c2a0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8818bbd3db4dc123b25cbba5f54c2bc4b3fcf9bf7d7a7709f4ae588b267c4ece" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c65382513f07460da39833cb666c5ed82e61b9e998f4b0c4287cee56c3cc9bcd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8975b0577fd35566d750b362b0897a26c399136df07bababbde6203ff2954ed4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "21fe0ceb0052be7fb0f004187cacd7de67fa6eb0938d927677f2398c132317a8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2ef73f3c26f12d93889f3c78b6a66c1d52b649dc9e856e2c172ea7c58ac2b5e3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "388a3cd56d73867abb5f8401492b6e2681eb69851e767fd84210a56076fb3dd3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "af533e022fc9439e4e3cb838ecd18692232adf6fe9839526d3c3dd1b71910b1a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "751c09d41a9343882a81cd13ee40818d12eb44c6c7f40df16e4aea8fab91972a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5b73ddb68d9d2b0aa265a07988d6b88ae9aac582af83032f8a9b21a2e1b7bf18" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3da29126c7c5d7f43e64242a79feaa4ef3459cdeccc898ed59a97f6ec93b9dab" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "566dc920293da5cb4fe0aa8abda8bbf56f552313bff19046641e3615c1e3ed3f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4115bea02f73f97f629e5c5590720c01e7e449ae2a6697d4d2783321303692f9" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4ce08f4762468a7670012164878d68340c52a35e66c1884d5c864889abc96677" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "81ea0b7804124e0c22ea5fc71104a2afcb52a1fa816f3ecb7dcb5d9dea1786d0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fe362733b05f6bedaf9379d7f7936ede209b1f8323c3922549d9e73681b5db7b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "eff37d30dfd20359be4e73fdf40d27734b3df90a97a55ed745297294ca85d09f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "172ffc67153d12e0ca76a8b6cd5d4731885b39ce0cac93a8972a18006c8b8baf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c47957f1cc88e83ef9445839709a480a036bed5f88ac0fcc8e1e703ffaac132c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "30f3548370cfdceda5c37b569b6175e799eef1a62aaa943245ae7669c227a7b5" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c95dcb3cf1f27d0eef2f25d2413870904a877c4a56c2de1e83e2bc2ae2e46821" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d5d0b5d705434cd46b185749f66bfb5836dcdf6ee549a2b7a4aee7f58007caaf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bbc124a712f15d07c300e05b668389a439c91777f721f8320c1c9078066d2c7e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a451b48c35a6c7854cfaae60262e76990816382ac0667e5a5c9e1b46c4342ddf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b0d150fb55e778d01147f0b5d89d99ecb20ff07e5e6760d6b645eb5b654c622b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "34f737c0ab219951eee89a9f8dac299c9d4c38f33fa494c5c6eefc92b6db08bc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1a62cc3a00800dcbd99891080c1e098458193a8cc9f970ea99fbeff00318c289" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cfce55ebafc840d7ae48281c7fd57ec8b482d4b704437495495ac414cf4a374b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6746facf71146d999dabd05d093ae586648d1ee28e72617b99d0f0086e1e45bf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "571ced283b3f23b4e750bf12a2caf1781847bd890e43603cdc5976102b7bb11b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cfcb765b048e35022c5d089d26e85a36b005a2b80493d03a144e09f409b6afd1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4050c7a27705bb27f42089b299f3cbe5054ead68727e8ef9318ce6f25cd6f31d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "184070bd5d265fbdc142cd1c5cd0d7e414e70369a266d627c8fba84fa5e84c34" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9edda9a4443902a9588c0d0ccc62b930218479a6841e6fe7d43003f04b1fd643" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e412feef7908324a6da1841629f35d3d358642019310ec57c614836b63d30763" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1a2b8edff3f9acc1554fcbae3cf1d6298c6462e22e5eb0259684f835012bd13f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "288c4ad9b9409762ea07c24a41f04f69a7d74bee2d95435374bde946d7241c7b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "805691bb286748cfb591d3aebe7e6f4e4dc6e2808c65143cc004e4eb6fd09d43" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d4ac8d3a0afc6cfa7b460ae3001baeb36dadb37da07d2e8ac91822df348aed3d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c376617014d20158bced3d3ba552b6eccf84e62aa3eb650e90029c84d13eea69" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c41f09f43cecae7293d6007ca0a357087d5ae59be500c1cd5b289ee810c7b082" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "03d1ced1fba5c39155c44b7765cb760c78708dcfc80b0bd8ade3a56da8830b29" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "09bde6f152218dc92c41d7f45387e63e5869d807ec70b821405dbd884b7fcf4b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "71c9036e18179b90b37d39e9f05eb89cc5fc341fd7c477d0d7493285faca08a4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5916833ebb05cd919ca7fe83b692d3205bef72392b2cf6bb0a6d43f994f95f11" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f63aab3ec641b3b024964c2b437c04f6043c4c7e0279239995401958f86bbe54" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f172b180bfb09740493120b6326cbdc561e477def9bbcfd28cc8c1c5e3379a31" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cb9b89cc18381dd9141ade588654d4e6a231d5bf49d4d59ac27d869cbe100cf3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7bd8815046fdd810a923e1984aaebdcdf84d87c8992d68b5eeb460f93eb3c8d7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "607be66862fd08ee5b19facac09dfdbcd40c312101d66e6ebd2b841f1b9a9325" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9fe03bbe69ab1834f5219b0da88a08b30a66c5913f0151963c360560db0387b3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "90a83585717b75f0e9b725e055eeeeb9e7a028ea7e6cbc07b20917ec0363e38c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "336ea0530f4a7469126e0218587ebbde3358a0b31c29d200f7dc7eb15c6aadd8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a79e76dc0abca4396f0747cd7b748df913007626b1d659da0c1f78b9303d01a3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "44e78a773756e0951519504d7038d28d0213a37e0ce375371757bc996311e3b8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "77ac012a3f754dcfeab5eb996be9cd2d1f96111b6e49f3994df181f28569d825" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ce5a10db6fccdaf140aaa4ded6250a9c06e9222bc9f9f3658a4aff935f2b9f3a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ecc203a7fe2be4abd55bb53e6e673572e0078da8cd375ef430cc97f9f80083af" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "14a5186de9d7a18b0412b8563e51cc5433840b4a129a8ff963b33a3c4afe8ebb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "13f8ef95cb86e6a638931c8e107673eb76ba10d7c2cd70b9d9920bbeed929409" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0b338f4ee12f2dfcb78713377941e0b0632152581d1332516e4a2cab1942cca4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "eaab0ec37b3b8ab796e9f57238de14a264a076f3887d86e29bb5906db5a00e02" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "23cb68b8c0e6dc26dc27766ddc0a13a99438fd55617aa4095d8f969720c872df" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "091d8ee30d6f2968d46b687dd65292665742de0bb83dcc0004c72ce10007a549" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7f507abc6d19ba00c065a876ec5657868882d18a221bc46c7a6912541f5bc7ba" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a0607c24e14e8c223db0d70b4d30ee88014d603f437e9e02aa7dafa3cdfbad94" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ddbfea75cc467882eb3483ce5e2e756a4f4701b76b445519e89f22d60fa86e06" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0c311f38c35a4fb90d651c289d486856cd1413df9b0677f53ece2cd9e477c60a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "46a73a8dd3e70f59d3942c01df599def783c9da82fd83222cd662b53dce7dbdf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ad038ff9b14de84a801e4e621ce5df029dd93520d0c2fa38bff176a8b1d1698c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ab70c5dfbd1ea817fed0cd067293abf319e5d7901c2141d5d99b23f03a38e748" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1fffda67932b73c8ecaf009a3491a026953babfe1f663b0697c3c4ae8b2e7dcb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b0d2cc19472dd57f2b17efc03c8d58c2283dbb19da572f7755855aa9794317a0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a0d19a6ee33979c325510e276622df41f71583d07501b87071129a0ad94732a5" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "724642a7032d1062b89e52bea34b75df7d8fe772d9fe3c93ddf3c4545ab5a99b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ade5eaa7e61f672d587ea03dae7d7b55229c01d06bc0a5701436cbd18366a626" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "013b31ebd228fcdda51fabb03bb02d60ac20ca215aafa83bdd855e3755a35f0b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "332ed40bb10dde3c954a75d7b8999d4b26a1c063c1dc6e32c1d91bab7bbb7d16" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c7a197b3a05b566bcc9facd20e441d6f6c2860ac9651cd51d6b9d2cdeeea0390" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bd9cf64ea8953c037108e6f654914f3958b68e29c16700dc184d94a21708ff60" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8835b0ac021151df716474ce27ce4d3c15f0b2dab48003cf3f3efd0945106b9a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3bfefa3301aa55c080190cffda8eae51d9af488b4c1f24c3d9a75242fd8ea01d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "08284d14993cd47d53ebaecf0df0478cc182c89c00e1859c84851686ddf2c1b7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1ed7ef9f04c2ac8db6a864db131087f27065098e69c3fe78718d9b947f4a39d0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c161f2dcd57e9c1439b31a9dd43d8f3d7dd8f0eb7cfac6fb25a0f28e306f0661" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c01969ad34c52caf3dc4d80d19735c29731ac6e7a92085ab9250c48dea48a3fc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1720b3655619d2a52b3521ae0e49e345cb3389ebd6208acaf9f13fdacca8be49" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "756288361c83e24c617cf95c905b22d017cdc86f0bf1d658f4756c7379873b7f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e7d0eda3452693b752abcda1b55e276f82698f5f1605403eff830bea0071a394" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2c82ecaa6b84803e044af63118afe544687cb6e6c7df49ed762dfd7c8693a1bc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6136cbf4b441056fa1e2722498125d6ded45e17b52143959c7f4d4e395218ac2" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "721d3245aafef27f6a624f47954b6c255079526ffa25e9ff77e5dcff473b1597" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9dd2fbd8cef16c353c0ac21191d509eb28dd9e3e0d8cea5d26ca839393851c3a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b2394ceacdebf21bf9df2ced98e58f1c3a4bbbff660dd900f62202d6785cc46e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "57089f222749ad7871765f062b114f43ba20ec56422a8b1e3f87192c0ea718c6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e49a9459961cd33cdf4aae1b1078a5dea7c040e0fea340c93a724872fc4af806" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ede67f720effd2ca9c88994152d0201dee6b0a2d2c077aca6dae29f73f8b6309" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e0f434bf22e3088039c21f719ffc67f0f2cb5e98a7a0194c76e96bf4e8e17e61" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "277c04e2853484a4eba910ad336d01b477b67cc200c59f3c8d77eef8494f29cd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "156d5747d0c99c7f27097d7b7e002b2e185cb72d8dd7eb424a0321528161219f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "20ddd1ed9b1ca803946d64a83ae4659da67fba7a1a3eddb1e103c0f5e03e3a2c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f0af604d3dabbf9a0f2a7d3dda6bd38bba72c6d09be494fcef713ff10189b6e6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9802bb87def4cc10c4a5fd49aa58dfe2f3fddb46b4708814ead81d23ba95139b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4f8ce1e51d2fe7f24043a904d898ebfc91975418753413aa099b795ecb35cedb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bddc6514d7ee6ace0a4ac1d0e068112288cbcf560454642705630177cba608bd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d635994f6291517b0281ffdd496afa862712e5b3c4e52e4cd5fdae8c0e72fb08" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "878d9ca600cf87e769cc305c1b35255186615a73a0da613b5f1c98dbf81283ea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a64ebe5dc185de9fdde7607b6998702eb23456184957307d2fa72e87a47702d6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ce50eab7b5eb52bdc9ad8e5a480ab780ca9320e44360b1fe37e03f2f7ad7de01" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "eeddb7c0db6e30abe66d79e327511e61fcebbc29f159b40a86b046ecf0513823" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "787fc93440c1ec96b5ad01c16cf77916a1405f9426356ec921d8dff3ea63b7e0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7f0d5eab47eefda696c0bf0fbf86ab216fce461e9303aba6ac374120e890e8df" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b68004b42f14ad029f4c2e03b1d5eb76d57160e26476d21131bef20ada7d27f4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b0c4eb18ae250b51a41382ead92d0dc7455f9379fc9884428e4770608db0faec" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f92b7a870c059f4d46464c824ec96355140bdce681322cc3a992ff103e3fea52" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5364312614813398cc525d4c4e146edeb371265fba19133a2c3d2159298a1742" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f6620e68d37fb2af5000fc28e23b832297ecd8bce99e8be4d04e85309e3d3374" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5316a27969d7fe04ff27b283961bffc3bf5dfb32fb6a89d101c6c3b1937c2871" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "81d1664fdf3cb33c24eebac0bd64244b77c4abea90bbe8b5ee0b2aafcf2d6a53" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "345782f295b0880352e924a0467b5fbc3e8f3bfbc3c7e48b67091fb5e80a9442" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "794111ea6cd65e311f74ee41d476cb632ce1e4b051dc1d9e9d061a19e1d0bb49" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2a85daf6138816b99bf8d08ba2114b7ab07975a78420c1a3b06a777c22dd8bcb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "89b0d5f289ec16401a069a960d0b093e625da3cf41ee29b59b930c5820145455" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d0fdcb543943fc27d20864f52181471b942cc77ca675bcb30df31d358ef7b1eb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b17ea8d77063c709d4dc6b879413c343e3790e9e62ca85b7900b086f6b75c672" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e71a3e2c274db842d92114f217e2c0eac8b45093fdfd9df4ca7162394862d501" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c0476759ab7aa333234f6b44f5fd858390ec23694c622cb986e769c78edd733e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9ab8eabb1416434d85391341d56993c55458167d4418b19a0f2ad8b79a83a75b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7992d0bbb15e23826f443e00505d68d3ed7372995a5c3e498654102fbcd0964e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c021b30085151435df33b007ccecc69df1269f39ba25092bed59d932ac0fdc28" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "91a25ec0ec0d9a567f89c4bfe1a65a0e432d07064b4190e27dfb81901fd3139b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5950d39a23e1545f301270aa1a12f2e6c453776e4d6355de425cc153f9818867" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d79f14720c610af179a3765d4b7c0968f977962dbf655b521272b6f1e194488e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e9531bfc8b02995aeaa75ba27031fadbcbf4a0dab8961d9296cd7e84d25d6006" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "34e9c26a01d7f16181b454a9d1623c233cb99d31c694656e9413aca3e918692f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d9d7422f437bd439ddd4d883dae2a08350173414be78155133fff1964c3d7972" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4aee0c7aaf075414ff1793ead7eaca601775c615dbd60b640b0a9f0ce505d435" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6bfdd15459c83b99f096bfb49ee87b063d69c1974c6928acfcfb4099f8c4ef67" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9fd1c408fd75c336193a2a14d94f6af5adf050b80387b4b010fb29f4cc72707c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "13c88480a5d00d6c8c7ad2110d76a82d9b70f4fa6696d4e5dd42a066dcaf9920" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "820e725ee25fe8fd3a8d5abe4c46c3ba889de6fa9191aa22ba67d5705421542b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "32d93a0eb02f42fbbcaf2bad0085b282e46046a4df7ad10657c9d6476375b93e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "adc5187905b1669cd8ec9c721e1953786b9d89a9bae30780f1e1eab24a00523c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e90756ff7f9ad810b239a10ced2cf9b2284354c1f8c7e0accc2461dc796d6e89" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1251f76e56978481875359801db589a0b22f86d8d634dc04506f322ed78f17e8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3afa899fd980e73ecb7f4d8b8f291dc9af796bc65d27f974c6f193c9191a09fd" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "aa305be26e5deddc3c1010cbc213f95f051c785c5b431e6a7cd048f161787528" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8ea1884ff32e9d10f039b407d0d44e7e670abd884aeee0fb757ae94eaa97373d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d482b2155d4dec6b4736a1f1617b53aaa37310277d3fef0c37ad41768fc235b4" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4d413971387e7a8898a8dc2a27500778539ea214a2dfe9b3d7e8ebdce5cf3db3" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "696e5d46e6c57e8796e4735d08916e0b7929b3cf298c296d22e9d3019653371c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1f5647c1d3b088228885865c8940908bf40d1a8272821973b160008e7a3ce2eb" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b6e76c330f021a5bda65875010b0edf09126c0f510ea849048192003aef4c61c" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3cd952a0beada41abb424ce47f94b42be64e1ffb0fd0782276807946d0d0bc55" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "98d92677439b41b7bb513312afb92bcc8ee968b2e3b238cecb9b0f34c9bb63d0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ecbca2cf08ae57d517ad16158a32bfa7dc0382eaeda128e91886734c24a0b29d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "942cc7c0b52e2b16a4b89fa4fc7e0bf609e29a08c1a8543452b77c7bfd11bb28" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8a065d8b61a0dffb170d5627735a76b0e9506037808cba16c345007c9f79cf8f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1b9fa19714659c78ff413871849215361029ac802b1cbcd54e408bd87287f81f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8dab071bcd6c7292a9ef727b4ae0d86713301da8618d9a48adce55f303a869a1" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8253e3e7c7b684b9cb2beb014ce330ff3d99d17abbdbabe4f4d674ded53ffc6b" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f195f321e9e3d6bd7d074504dd2ab0e6241f92e784b1aa271ff648b1cab6d7f6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "27e4cc72090f241266476a7c09495f2db153d5bcbd761903ef79275ec56b2ed8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "899c2405788e25b99a1846355e646d77cf400083415f7dc5afe69d6e17c00023" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a59b78c4905744076bfee894de707d4f120b5c6893ea0400297d0bb834727632" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "59dc78b105649707a2bb4419c48f005400d3973de3736610230435b10424b24f" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c0149d1d7e7a6353a6d906efe728f2f329fe14a4149a3ea77609bc42b975ddfa" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a32f241474a6c16932e9243be0cf09bcdc7e0ca0e7a6a1b9b1a0f01e41502377" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b239b2e4f81841361c1339f68e2c359f929af9ad9f34e01aab4631ad6d5500b0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "85fb419c7002a3e0b4b6ea093b4c1ac6936645b65dac5ac15a8528b7b94c1754" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9619720625f190b93a3fad186ab314189633c0d3a01e6f9bc8c4a8f82f383dbf" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7d620d90fe69fa469a6538388970a1aa09bb48a2d59b347b97e8ce71f48c7f46" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "294383568596fb37c75bbacd979c5ff6f20a556bf8879cc72924855df9b8240e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "16b18ab314359c2b833c1c6986d48c55a9fc97cde9a3c1f10a3177140f73f738" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8cbbdd14bc33f04cf45813e4a153a273d36adad5ce71f499eeb87fb8ac63b729" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "69c9a498db174ecaefcc5a3ac9fdedf0f813a5bec727f1e775babdec7718816e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b462c3be40448f1d4f80626254e535b08bc9cdcff599a768578d4b2881a8e3f0" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "553e9d9c5f360ac0b74a7d44e5a391dad4ced03e0c24183b7e8ecabdf1715a64" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7a7c55a56fa9ae51e655e01975d8a6ff4ae9e4b486fcbe4eac044588f245ebea" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2afdf3c82abc4867f5de111286c2b3be7d6e48657ba923cfbf101a6dfcf9db9a" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "41037d2edcdce0c49b7fb4a6aa0999ca66976c7483afe631d4eda283144f6dfc" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c4466f8497ca2eeb4583a0b08e9d9ac74395709fda109d24f2e4462196779c5d" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "75f609338aa67d969a2ae2a2362b2da9d77c695dfd1df7224a6901db932c3364" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "68606ceb989d5488fc7cf649f3d7c272ef055da1a93faecd55fe06f6967098ca" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "44346bdeb7e052f6255048f0d9b42c425bab9c3dd24168212c3ecf1ebf34e6ae" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8e9cf6e1f366471f2ac7d2ee9b5e6266fda71f8f2e4109f2237ed5f8813fc718" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "84bbeb8406d250951f8c1b3e86a7c010082921833dfd9555a2f909b1086eb4b8" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ee666f3eef0f7e2a9c222958c97eaf35f51ced393d714485ab09a069340fdf88" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c153d34a65c47b4a62c5cacf24010975d0356b2f32c8f5da530d338816ad5de6" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9fc5450109e1b779f6c7ae79d56c27635c8dd426c5a9d54e2578db989b8c3b4e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d12bf3732ef4af5c22fa90356af8fc50fcb40f8f2ea5c8594737a3b3d5abdbd7" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "11030b9289bba5af65260672ab6fee88b87420acef4a1789a2073b7ec2f2a09e" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "69cb192b8444005c8c0ceb12c846860768188cda0aec27a9c8a55cdee2123632" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "db444c15597b5f1a03d1f9edd16e4a9f43a667cc275175dfa2b704e3bb1a9b83" +}, +{ + "hash": "blake2s", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3fb735061abc519dfe979e54c1ee5bfad0a9d858b3315bad34bde999efd724dd" +}, +{ + "hash": "blake2b", + "in": "", + "key": "", + "out": "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce" +}, +{ + "hash": "blake2b", + "in": "00", + "key": "", + "out": "2fa3f686df876995167e7c2e5d74c4c7b6e48f8068fe0e44208344d480f7904c36963e44115fe3eb2a3ac8694c28bcb4f5a0f3276f2e79487d8219057a506e4b" +}, +{ + "hash": "blake2b", + "in": "0001", + "key": "", + "out": "1c08798dc641aba9dee435e22519a4729a09b2bfe0ff00ef2dcd8ed6f8a07d15eaf4aee52bbf18ab5608a6190f70b90486c8a7d4873710b1115d3debbb4327b5" +}, +{ + "hash": "blake2b", + "in": "000102", + "key": "", + "out": "40a374727302d9a4769c17b5f409ff32f58aa24ff122d7603e4fda1509e919d4107a52c57570a6d94e50967aea573b11f86f473f537565c66f7039830a85d186" +}, +{ + "hash": "blake2b", + "in": "00010203", + "key": "", + "out": "77ddf4b14425eb3d053c1e84e3469d92c4cd910ed20f92035e0c99d8a7a86cecaf69f9663c20a7aa230bc82f60d22fb4a00b09d3eb8fc65ef547fe63c8d3ddce" +}, +{ + "hash": "blake2b", + "in": "0001020304", + "key": "", + "out": "cbaa0ba7d482b1f301109ae41051991a3289bc1198005af226c5e4f103b66579f461361044c8ba3439ff12c515fb29c52161b7eb9c2837b76a5dc33f7cb2e2e8" +}, +{ + "hash": "blake2b", + "in": "000102030405", + "key": "", + "out": "f95d45cf69af5c2023bdb505821e62e85d7caedf7beda12c0248775b0c88205eeb35af3a90816f6608ce7dd44ec28db1140614e1ddebf3aa9cd1843e0fad2c36" +}, +{ + "hash": "blake2b", + "in": "00010203040506", + "key": "", + "out": "8f945ba700f2530e5c2a7df7d5dce0f83f9efc78c073fe71ae1f88204a4fd1cf70a073f5d1f942ed623aa16e90a871246c90c45b621b3401a5ddbd9df6264165" +}, +{ + "hash": "blake2b", + "in": "0001020304050607", + "key": "", + "out": "e998e0dc03ec30eb99bb6bfaaf6618acc620320d7220b3af2b23d112d8e9cb1262f3c0d60d183b1ee7f096d12dae42c958418600214d04f5ed6f5e718be35566" +}, +{ + "hash": "blake2b", + "in": "000102030405060708", + "key": "", + "out": "6a9a090c61b3410aede7ec9138146ceb2c69662f460c3da53c6515c1eb31f41ca3d280e567882f95cf664a94147d78f42cfc714a40d22ef19470e053493508a2" +}, +{ + "hash": "blake2b", + "in": "00010203040506070809", + "key": "", + "out": "29102511d749db3cc9b4e335fa1f5e8faca8421d558f6a3f3321d50d044a248ba595cfc3efd3d2adc97334da732413f5cbf4751c362ba1d53862ac1e8dabeee8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a", + "key": "", + "out": "c97a4779d47e6f77729b5917d0138abb35980ab641bd73a8859eb1ac98c05362ed7d608f2e9587d6ba9e271d343125d40d933a8ed04ec1fe75ec407c7a53c34e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b", + "key": "", + "out": "10f0dc91b9f845fb95fad6860e6ce1adfa002c7fc327116d44d047cd7d5870d772bb12b5fac00e02b08ac2a0174d0446c36ab35f14ca31894cd61c78c849b48a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c", + "key": "", + "out": "dea9101cac62b8f6a3c650f90eea5bfae2653a4eafd63a6d1f0f132db9e4f2b1b662432ec85b17bcac41e775637881f6aab38dd66dcbd080f0990a7a6e9854fe" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d", + "key": "", + "out": "441ffaa08cd79dff4afc9b9e5b5620eec086730c25f661b1d6fbfbd1cec3148dd72258c65641f2fca5eb155fadbcabb13c6e21dc11faf72c2a281b7d56145f19" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e", + "key": "", + "out": "444b240fe3ed86d0e2ef4ce7d851edde22155582aa0914797b726cd058b6f45932e0e129516876527b1dd88fc66d7119f4ab3bed93a61a0e2d2d2aeac336d958" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "", + "out": "bfbabbef45554ccfa0dc83752a19cc35d5920956b301d558d772282bc867009168e9e98606bb5ba73a385de5749228c925a85019b71f72fe29b3cd37ca52efe6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "", + "out": "9c4d0c3e1cdbbf485bec86f41cec7c98373f0e09f392849aaa229ebfbf397b22085529cb7ef39f9c7c2222a514182b1effaa178cc3687b1b2b6cbcb6fdeb96f8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "", + "out": "477176b3bfcbadd7657c23c24625e4d0d674d1868f006006398af97aa41877c8e70d3d14c3bbc9bbcdcea801bd0e1599af1f3eec67405170f4e26c964a57a8b7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "", + "out": "a78c490eda3173bb3f10dee52f110fb1c08e0302230b85ddd7c11257d92de148785ef00c039c0bb8eb9808a35b2d8c080f572859714c9d4069c5bcaf090e898e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "", + "out": "58d023397beb5b4145cb2255b07d74290b36d9fd1e594afbd8eea47c205b2efbfe6f46190faf95af504ab072e36f6c85d767a321bfd7f22687a4abbf494a689c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "", + "out": "4001ec74d5a46fd29c2c3cdbe5d1b9f20e51a941be98d2a4e1e2fbf866a672121db6f81a514cfd10e7358d571bdba48e4ce708b9d124894bc0b5ed554935f73a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "", + "out": "ccd1b22dab6511225d2401ea2d8625d206a12473cc732b615e5640cefff0a4adf971b0e827a619e0a80f5db9ccd0962329010d07e34a2064e731c520817b2183" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "", + "out": "b4a0a9e3574edb9e1e72aa31e39cc5f30dbf943f8cabc408449654a39131e66d718a18819143e3ea96b4a1895988a1c0056cf2b6e04f9ac19d657383c2910c44" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "", + "out": "447becab16630608d39f4f058b16f7af95b85a76aa0fa7cea2b80755fb76e9c804f2ca78f02643c915fbf2fce5e19de86000de03b18861815a83126071f8a37b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "", + "out": "54e6dab9977380a5665822db93374eda528d9beb626f9b94027071cb26675e112b4a7fec941ee60a81e4d2ea3ff7bc52cfc45dfbfe735a1c646b2cf6d6a49b62" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "", + "out": "3ea62625949e3646704d7e3c906f82f6c028f540f5f72a794b0c57bf97b7649bfeb90b01d3ca3e829de21b3826e6f87014d3c77350cb5a15ff5d468a81bec160" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "", + "out": "213cfe145c54a33691569980e5938c8883a46d84d149c8ff1a67cd287b4d49c6da69d3a035443db085983d0efe63706bd5b6f15a7da459e8d50a19093db55e80" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "", + "out": "5716c4a38f38db104e494a0a27cbe89a26a6bb6f499ec01c8c01aa7cb88497e75148cd6eee12a7168b6f78ab74e4be749251a1a74c38c86d6129177e2889e0b6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "", + "out": "030460a98bdf9ff17cd96404f28fc304f2b7c04eaade53677fd28f788ca22186b8bc80dd21d17f8549c711aff0e514e19d4e15f5990252a03e082f28dc2052f6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "", + "out": "19e7f1ccee88a10672333e390cf22013a8c734c6cb9eab41f17c3c8032a2e4aca0569ea36f0860c7a1af28fa476840d66011168859334a9e4ef9cc2e61a0e29e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "", + "out": "29f8b8c78c80f2fcb4bdf7825ed90a70d625ff785d262677e250c04f3720c888d03f8045e4edf3f5285bd39d928a10a7d0a5df00b8484ac2868142a1e8bea351" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "", + "out": "5c52920a7263e39d57920ca0cb752ac6d79a04fef8a7a216a1ecb7115ce06d89fd7d735bd6f4272555dba22c2d1c96e6352322c62c5630fde0f4777a76c3de2c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "", + "out": "83b098f262251bf660064a9d3511ce7687a09e6dfbb878299c30e93dfb43a9314db9a600337db26ebeedaf2256a96dabe9b29e7573ad11c3523d874dde5be7ed" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "", + "out": "9447d98aa5c9331352f43d3e56d0a9a9f9581865998e2885cc56dd0a0bd5a7b50595bd10f7529bcd31f37dc16a1465d594079667da2a3fcb70401498837cedeb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "", + "out": "867732f2feeb23893097561ac710a4bff453be9cfbedba8ba324f9d312a82d732e1b83b829fdcd177b882ca0c1bf544b223be529924a246a63cf059bfdc50a1b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "", + "out": "f15ab26d4cdfcf56e196bb6ba170a8fccc414de9285afd98a3d3cf2fb88fcbc0f19832ac433a5b2cc2392a4ce34332987d8d2c2bef6c3466138db0c6e42fa47b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "", + "out": "2813516d68ed4a08b39d648aa6aacd81e9d655ecd5f0c13556c60fdf0d333ea38464b36c02baccd746e9575e96c63014f074ae34a0a25b320f0fbedd6acf7665" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "", + "out": "d3259afca8a48962fa892e145acf547f26923ae8d4924c8a531581526b04b44c7af83c643ef5a0bc282d36f3fb04c84e28b351f40c74b69dc7840bc717b6f15f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "", + "out": "f14b061ae359fa31b989e30332bfe8de8cc8cdb568e14be214a2223b84caab7419549ecfcc96ce2acec119485d87d157d3a8734fc426597d64f36570ceaf224d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "", + "out": "55e70b01d1fbf8b23b57fb62e26c2ce54f13f8fa2464e6eb98d16a6117026d8b90819012496d4071ebe2e59557ece3519a7aa45802f9615374877332b73490b3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "", + "out": "25261eb296971d6e4a71b2928e64839c67d422872bf9f3c31993615222de9f8f0b2c4be8548559b4b354e736416e3218d4e8a1e219a4a6d43e1a9a521d0e75fc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "", + "out": "08307f347c41294e34bb54cb42b1522d22f824f7b6e5db50fda096798e181a8f026fa27b4ae45d52a62caf9d5198e24a4913c6671775b2d723c1239bfbf016d7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "", + "out": "1e5c62e7e9bfa1b118747a2de08b3ca10112af96a46e4b22c3fc06f9bfee4eb5c49e057a4a4886234324572576bb9b5ecfde0d99b0de4f98ec16e4d1b85fa947" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "", + "out": "c74a77395fb8bc126447454838e561e962853dc7eb49a1e3cb67c3d0851f3e39517be8c350ac910903d49cd2bfdf545c99316d0346170b739f0add5d533c2cfc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "", + "out": "0dd57b423cc01eb2861391eb886a0d17079b933fc76eb3fc08a19f8a74952cb68f6bcdc644f77370966e4d13e80560bcf082ef0479d48fbbab4df03b53a4e178" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "", + "out": "4d8dc3923edccdfce70072398b8a3da5c31fcb3ee3b645c85f717cbaeb4b673a19394425a585bfb464d92f1597d0b754d163f97ced343b25db5a70ef48ebb34f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "", + "out": "f0a50553e4dfb0c4e3e3d3ba82034857e3b1e50918f5b8a7d698e10d242b0fb544af6c92d0c3aaf9932220416117b4e78ecb8a8f430e13b82a5915290a5819c5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "", + "out": "b15543f3f736086627cc5365e7e8988c2ef155c0fd4f428961b00d1526f04d6d6a658b4b8ed32c5d8621e7f4f8e8a933d9ecc9dd1b8333cbe28cfc37d9719e1c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "", + "out": "7b4fa158e415fef023247264cbbe15d16d91a44424a8db707eb1e2033c30e9e1e7c8c0864595d2cb8c580eb47e9d16abbd7e44e824f7cedb7def57130e52cfe9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "", + "out": "60424ff23234c34dc9687ad502869372cc31a59380186bc2361c835d972f49666eb1ac69629de646f03f9b4db9e2ace093fbfdf8f20ab5f98541978be8ef549f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "", + "out": "7406018ce704d84f5eb9c79fea97da345699468a350ee0b2d0f3a4bf2070304ea862d72a51c57d3064947286f531e0eaf7563702262e6c724abf5ed8c8398d17" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "", + "out": "14ef5c6d647b3bd1e6e32006c231199810de5c4dc88e70240273b0ea18e651a3eb4f5ca3114b8a56716969c7cda27e0c8db832ad5e89a2dc6cb0adbe7d93abd1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "", + "out": "38cf6c24e3e08bcf1f6cf3d1b1f65b905239a3118033249e448113ec632ea6dc346feeb2571c38bd9a7398b2221280328002b23e1a45adaffe66d93f6564eaa2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "", + "out": "6cd7208a4bc7e7e56201bbba02a0f489cd384abe40afd4222f158b3d986ee72a54c50fb64fd4ed2530eda2c8af2928a0da6d4f830ae1c9db469dfd970f12a56f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "", + "out": "659858f0b5c9edab5b94fd732f6e6b17c51cc096104f09beb3afc3aa467c2ecf885c4c6541effa9023d3b5738ae5a14d867e15db06fe1f9d1127b77e1aabb516" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "", + "out": "26cca0126f5d1a813c62e5c71001c046f9c92095704550be5873a495a999ad010a4f79491f24f286500adce1a137bc2084e4949f5b7294cefe51ecaff8e95cba" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "", + "out": "4147c1f55172788c5567c561feef876f621fff1ce87786b8467637e70dfbcd0dbdb6415cb600954ab9c04c0e457e625b407222c0fe1ae21b2143688ada94dc58" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "", + "out": "5b1bf154c62a8af6e93d35f18f7f90abb16a6ef0e8d1aecd118bf70167bab2af08935c6fdc0663ce74482d17a8e54b546d1c296631c65f3b522a515839d43d71" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "", + "out": "9f600419a4e8f4fb834c24b0f7fc13bf4e279d98e8a3c765ee934917403e3a66097182ea21453cb63ebbe8b73a9c2167596446438c57627f330badd4f569f7d6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "", + "out": "457ef6466a8924fd8011a34471a5a1ac8ccd9bd0d07a97414ac943021ce4b9e4b9c8db0a28f016ed43b1542481990022147b313e194671131e708dd43a3ed7dc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "", + "out": "9997b2194d9af6dfcb9143f41c0ed83d3a3f4388361103d38c2a49b280a581212715fd908d41c651f5c715ca38c0ce2830a37e00e508ced1bcdc320e5e4d1e2e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "", + "out": "5c6bbf16baa180f986bd40a1287ed4c549770e7284858fc47bc21ab95ebbf3374b4ee3fd9f2af60f3395221b2acc76f2d34c132954049f8a3a996f1e32ec84e5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "", + "out": "d10bf9a15b1c9fc8d41f89bb140bf0be08d2f3666176d13baac4d381358ad074c9d4748c300520eb026daeaea7c5b158892fde4e8ec17dc998dcd507df26eb63" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "", + "out": "2fc6e69fa26a89a5ed269092cb9b2a449a4409a7a44011eecad13d7c4b0456602d402fa5844f1a7a758136ce3d5d8d0e8b86921ffff4f692dd95bdc8e5ff0052" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "", + "out": "fcbe8be7dcb49a32dbdf239459e26308b84dff1ea480df8d104eeff34b46fae98627b450c2267d48c0946a697c5b59531452ac0484f1c84e3a33d0c339bb2e28" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "", + "out": "a19093a6e3bcf5952f850f2030f69b9606f147f90b8baee3362da71d9f35b44ef9d8f0a7712ba1877fddcd2d8ea8f1e5a773d0b745d4725605983a2de901f803" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "", + "out": "3c2006423f73e268fa59d2920377eb29a4f9a8b462be15983ee3b85ae8a78e992633581a9099893b63db30241c34f643027dc878279af5850d7e2d4a2653073a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "", + "out": "d0f2f2e3787653f77cce2fa24835785bbd0c433fc779465a115149905a9dd1cb827a628506d457fcf124a0c2aef9ce2d2a0a0f63545570d8667ff9e2eba07334" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "", + "out": "78a9fc048e25c6dcb5de45667de8ffdd3a93711141d594e9fa62a959475da6075ea8f0916e84e45ad911b75467077ee52d2c9aebf4d58f20ce4a3a00458b05d4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "", + "out": "45813f441769ab6ed37d349ff6e72267d76ae6bb3e3c612ec05c6e02a12af5a37c918b52bf74267c3f6a3f183a8064ff84c07b193d08066789a01accdb6f9340" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "", + "out": "956da1c68d83a7b881e01b9a966c3c0bf27f68606a8b71d457bd016d4c41dd8a380c709a296cb4c6544792920fd788835771a07d4a16fb52ed48050331dc4c8b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "", + "out": "df186c2dc09caa48e14e942f75de5ac1b7a21e4f9f072a5b371e09e07345b0740c76177b01278808fec025eded9822c122afd1c63e6f0ce2e32631041063145c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "", + "out": "87475640966a9fdcd6d3a3b5a2cca5c08f0d882b10243c0ec1bf3c6b1c37f2cd3212f19a057864477d5eaf8faed73f2937c768a0af415e84bbce6bd7de23b660" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "", + "out": "c3b573bbe10949a0fbd4ff884c446f2229b76902f9dfdbb8a0353da5c83ca14e8151bbaac82fd1576a009adc6f1935cf26edd4f1fb8da483e6c5cd9d8923adc3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "", + "out": "b09d8d0bba8a7286e43568f7907550e42036d674e3c8fc34d8ca46f771d6466b70fb605875f6a863c877d12f07063fdc2e90ccd459b1910dcd52d8f10b2b0a15" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "", + "out": "af3a22bf75b21abfb0acd54422ba1b7300a952eff02ebeb65b5c234471a98df32f4f9643ce1904108a168767924280bd76c83f8c82d9a79d9259b195362a2a04" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "", + "out": "bf4ff2221b7e6957a724cd964aa3d5d0d9941f540413752f4699d8101b3e537508bf09f8508b317736ffd265f2847aa7d84bd2d97569c49d632aed9945e5fa5e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "", + "out": "9c6b6b78199b1bdacb4300e31479fa622a6b5bc80d4678a6078f88a8268cd7206a2799e8d4621a464ef6b43dd8adffe97caf221b22b6b8778b149a822aefbb09" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "", + "out": "890656f09c99d280b5ecb381f56427b813751bc652c7828078b23a4af83b4e3a61fdbac61f89bee84ea6bee760c047f25c6b0a201c69a38fd6fd971af18588bb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "", + "out": "31a046f7882ffe6f83ce472e9a0701832ec7b3f76fbcfd1df60fe3ea48fde1651254247c3fd95e100f9172731e17fd5297c11f4bb328363ca361624a81af797c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "", + "out": "27a60b2d00e7a671d47d0aec2a686a0ac04b52f40ab6629028eb7d13f4baa99ac0fe46ee6c814944f2f4b4d20e9378e4847ea44c13178091e277b87ea7a55711" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "", + "out": "8b5ccef194162c1f19d68f91e0b0928f289ec5283720840c2f73d253111238dcfe94af2b59c2c1ca2591901a7bc060e7459b6c47df0f71701a35cc0aa831b5b6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "", + "out": "57ab6c4b2229aeb3b70476d803cd63812f107ce6da17fed9b17875e8f86c724f49e024cbf3a1b8b119c50357652b81879d2ade2d588b9e4f7cedba0e4644c9ee" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "", + "out": "0190a8dac320a739f322e15731aa140ddaf5bed294d5c82e54fef29f214e18aafaa84f8be99af62950266b8f901f15dd4c5d35516fc35b4cab2e96e4695bbe1c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "", + "out": "d14d7c4c415eeb0e10b159224bea127ebd84f9591c702a330f5bb7bb7aa44ea39de6ed01f18da7adf40cfb97c5d152c27528824b21e239526af8f36b214e0cfb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "", + "out": "be28c4be706970488fac7d29c3bd5c4e986085c4c3332f1f3fd30973db614164ba2f31a78875ffdc150325c88327a9443ed04fdfe5be93876d1628560c764a80" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "", + "out": "031da1069e3a2e9c3382e436ffd79df74b1ca6a8adb2deabe676ab45994cbc054f037d2f0eace858d32c14e2d1c8b46077308e3bdc2c1b53172ecf7a8c14e349" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "", + "out": "4665cef8ba4db4d0acb118f2987f0bb09f8f86aa445aa3d5fc9a8b346864787489e8fcecc125d17e9b56e12988eac5ecc7286883db0661b8ff05da2afff30fe4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "", + "out": "63b7032e5f930cc9939517f9e986816cfbec2be59b9568b13f2ead05bae7777cab620c6659404f7409e4199a3be5f7865aa7cbdf8c4253f7e8219b1bd5f46fea" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "", + "out": "9f09bf093a2b0ff8c2634b49e37f1b2135b447aa9144c9787dbfd92129316c99e88aab8a21fdef2372d1189aec500f95775f1f92bfb45545e4259fb9b7b02d14" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "", + "out": "f9f8493c68088807df7f6a2693d64ea59f03e9e05a223e68524ca32195a4734b654fcea4d2734c866cf95c889fb10c49159be2f5043dc98bb55e02ef7bdcb082" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "", + "out": "3c9a7359ab4febce07b20ac447b06a240b7fe1dae5439c49b60b5819f7812e4c172406c1aac316713cf0dded1038077258e2eff5b33913d9d95caeb4e6c6b970" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "", + "out": "ad6aab8084510e822cfce8625d62cf4de655f4763884c71e80bab9ac9d5318dba4a6033ed29084e65216c031606ca17615dcfe3ba11d26851ae0999ca6e232cf" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "", + "out": "156e9e6261374c9dc884f36e70f0fe1ab9297997b836fa7d170a9c9ebf575b881e7bcea44d6c0248d35597907154828955be19135852f9228815eca024a8adfb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "", + "out": "4215407633f4cca9b6788be93e6aa3d963c7d6ce4b147247099f46a3acb500a30038cb3e788c3d29f132ad844e80e9e99251f6db96acd8a091cfc770af53847b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "", + "out": "1c077e279de6548523502b6df800ffdab5e2c3e9442eb838f58c295f3b147cef9d701c41c321283f00c71affa0619310399126295b78dd4d1a74572ef9ed5135" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "", + "out": "f07a555f49fe481cf4cd0a87b71b82e4a95064d06677fdd90a0eb598877ba1c83d4677b393c3a3b6661c421f5b12cb99d20376ba7275c2f3a8f5a9b7821720da" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "", + "out": "b5911b380d20c7b04323e4026b38e200f534259233b581e02c1e3e2d8438d6c66d5a4eb201d5a8b75072c4ec29106334da70bc79521b0ced2cfd533f5ff84f95" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "", + "out": "01f070a09bae911296361f91aa0e8e0d09a7725478536d9d48c5fe1e5e7c3c5b9b9d6eb07796f6da57ae562a7d70e882e37adfde83f0c433c2cd363536bb22c8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "", + "out": "6f793eb4374a48b0775acaf9adcf8e45e54270c9475f004ad8d5973e2aca52747ff4ed04ae967275b9f9eb0e1ff75fb4f794fa8be9add7a41304868d103fab10" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "", + "out": "965f20f139765fcc4ce4ba3794675863cac24db472cd2b799d035bce3dbea502da7b524865f6b811d8c5828d3a889646fe64a380da1aa7c7044e9f245dced128" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "", + "out": "ec295b5783601244c30e4641e3b45be222c4dce77a58700f53bc8ec52a941690b4d0b087fb6fcb3f39832b9de8f75ec20bd43079811749cdc907edb94157d180" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "", + "out": "61c72f8ccc91dbb54ca6750bc489672de09faedb8fdd4f94ff2320909a303f5d5a98481c0bc1a625419fb4debfbf7f8a53bb07ec3d985e8ea11e72d559940780" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "", + "out": "afd8145b259eefc8d12620c3c5b03e1ed8fd2ccefe0365078c80fd42c1770e28b44948f27e65a1886690110db814397b68e43d80d1ba16dfa358e739c898cfa3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "", + "out": "552fc7893cf1ce933ada35c0da98844e41545e244c3157a1428d7b4c21f9cd7e4071aed77b7ca9f1c38fba32237412ef21a342742ec8324378f21e507fafdd88" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "", + "out": "467a33fbadf5ebc52596ef86aaaefc6faba8ee651b1ce04de368a03a5a9040ef2835e00adb09abb3fbd2bce818a2413d0b0253b5bda4fc5b2f6f85f3fd5b55f2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "", + "out": "22eff8e6dd5236f5f57d94ede874d6c9428e8f5d566f17cd6d1848cd752fe13c655cb10fbaaff76872f2bf2da99e15dc624075e1ec2f58a3f64072121838569e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "", + "out": "9cec6bbf62c4bce4138abae1cbec8dad31950444e90321b1347196834c114b864af3f3cc3508f83751ffb4eda7c84d140734bb4263c3625c00f04f4c8068981b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "", + "out": "a8b60fa4fc2442f6f1514ad7402626920cc7c2c9f72124b8cba8ee2cb7c4586f658a4410cffcc0ab88343955e094c6af0d20d0c714fb0a988f543f300f58d389" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "", + "out": "8271cc45dfa5e4170e847e8630b952cf9c2aa777d06f26a7585b8381f188dacc7337391cfcc94b053dc4ec29cc17f077870428f1ac23fddda165ef5a3f155f39" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "", + "out": "bf23c0c25c8060e4f6995f1623a3bebecaa96e308680000a8aa3cd56bb1a6da099e10d9231b37f4519b2efd2c24de72f31a5f19535241b4a59fa3c03ceb790e7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "", + "out": "877fd652c05281009c0a5250e7a3a671f8b18c108817fe4a874de22da8e45db11958a600c5f62e67d36cbf84474cf244a9c2b03a9fb9dc711cd1a2cab6f3fae0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "", + "out": "29df4d87ea444baf5bcdf5f4e41579e28a67de84149f06c03f110ea84f572a9f676addd04c4878f49c5c00accda441b1a387caceb2e993bb7a10cd8c2d6717e1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "", + "out": "710dacb166844639cd7b637c274209424e2449dc35d790bbfa4f76177054a36b3b76fac0ca6e61df1e687000678ac0746df75d0a3954897681fd393a155a1bb4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "", + "out": "c1d5f93b8dea1f2571babccbc01764541a0cda87e444d673c50966ca559c33354b3acb26e5d5781ffb28847a4b4754d77008c62a835835f500dea7c3b58bdae2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "", + "out": "a41e41271cdab8af4d72b104bfb2ad041ac4df14677da671d85640c4b187f50c2b66513c4619fbd5d5dc4fe65dd37b9042e9848dda556a504caa2b1c6afe4730" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "", + "out": "e7bcbacdc379c43d81ebadcb37781552fc1d753e8cf310d968392d06c91f1d64cc9e90ce1d22c32d277fc6cda433a4d442c762e9eacf2c259f32d64cf9da3a22" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "", + "out": "51755b4ac5456b13218a19c5b9242f57c4a981e4d4ecdce09a3193362b808a579345d4881c2607a56534dd7f21956aff72c2f4173a6e7b6cc2212ba0e3daee1f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "", + "out": "dcc2c4beb9c1f2607b786c20c631972347034c1cc02fcc7d02ff01099cfe1c6989840ac213923629113aa8bad713ccf0fe4ce13264fb32b8b0fe372da382544a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "", + "out": "3d55176acea4a7e3a65ffa9fb10a7a1767199cf077cee9f71532d67cd7c73c9f93cfc37ccdcc1fdef50aad46a504a650d298d597a3a9fa95c6c40cb71fa5e725" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "", + "out": "d07713c005de96dd21d2eb8bbeca66746ea51a31ae922a3e74864889540a48db27d7e4c90311638b224bf0201b501891754848113c266108d0adb13db71909c7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "", + "out": "58983c21433d950caa23e4bc18543b8e601c204318532152daf5e159a0cd1480183d29285c05f129cb0cc3164687928086ffe380158df1d394c6ac0d4288bca8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "", + "out": "8100a8dc528d2b682ab4250801ba33f02a3e94c54dac0ae1482aa21f51ef3a82f3807e6facb0aeb05947bf7aa2adcb034356f90fa4560ede02201a37e411ec1a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "", + "out": "07025f1bb6c784f3fe49de5c14b936a5acacacaab33f6ac4d0e00ab6a12483d6bec00b4fe67c7ca5cc508c2a53efb5bfa5398769d843ff0d9e8b14d36a01a77f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "", + "out": "ba6aefd972b6186e027a76273a4a723321a3f580cfa894da5a9ce8e721c828552c64dacee3a7fd2d743b5c35ad0c8efa71f8ce99bf96334710e2c2346e8f3c52" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "", + "out": "e0721e02517aedfa4e7e9ba503e025fd46e714566dc889a84cbfe56a55dfbe2fc4938ac4120588335deac8ef3fa229adc9647f54ad2e3472234f9b34efc46543" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "", + "out": "b6292669ccd38d5f01caae96ba272c76a879a45743afa0725d83b9ebb26665b731f1848c52f11972b6644f554c064fa90780dbbbf3a89d4fc31f67df3e5857ef" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "", + "out": "2319e3789c47e2daa5fe807f61bec2a1a6537fa03f19ff32e87eecbfd64b7e0e8ccff439ac333b040f19b0c4ddd11a61e24ac1fe0f10a039806c5dcc0da3d115" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "", + "out": "f59711d44a031d5f97a9413c065d1e614c417ede998590325f49bad2fd444d3e4418be19aec4e11449ac1a57207898bc57d76a1bcf3566292c20c683a5c4648f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "", + "out": "df0a9d0c212843a6a934e3902b2dd30d17fba5f969d2030b12a546d8a6a45e80cf5635f071f0452e9c919275da99bed51eb1173c1af0518726b75b0ec3bae2b5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "", + "out": "a3eb6e6c7bf2fb8b28bfe8b15e15bb500f781ecc86f778c3a4e655fc5869bf2846a245d4e33b7b14436a17e63be79b36655c226a50ffbc7124207b0202342db5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "", + "out": "56d4cbcd070563426a017069425c2cd2ae540668287a5fb9dac432eb8ab1a353a30f2fe1f40d83333afe696a267795408a92fe7da07a0c1814cf77f36e105ee8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "", + "out": "e59b9987d428b3eda37d80abdb16cd2b0aef674c2b1dda4432ea91ee6c935c684b48b4428a8cc740e579a30deff35a803013820dd23f14ae1d8413b5c8672aec" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "", + "out": "cd9fcc99f99d4cc16d031900b2a736e1508db4b586814e6345857f354a70ccecb1df3b50a19adaf43c278efa423ff4bb6c523ec7fd7859b97b168a7ebff8467c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "", + "out": "0602185d8c3a78738b99164b8bc6ffb21c7debebbf806372e0da44d121545597b9c662a255dc31542cf995ecbe6a50fb5e6e0ee4ef240fe557eded1188087e86" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "", + "out": "c08afa5b927bf08097afc5fff9ca4e7800125c1f52f2af3553fa2b89e1e3015c4f87d5e0a48956ad31450b083dad147ffb5ec03434a26830cf37d103ab50c5da" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "", + "out": "36f1e1c11d6ef6bc3b536d505d544a871522c5c2a253067ec9933b6ec25464daf985525f5b9560a16d890259ac1bb5cc67c0c469cde133def000ea1d686f4f5d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "", + "out": "bf2ab2e2470f5438c3b689e66e7686fffa0cb1e1798ad3a86ff99075bf6138e33d9c0ce59afb24ac67a02af34428191a9a0a6041c07471b7c3b1a752d6fc0b8b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "", + "out": "d400601f9728ccc4c92342d9787d8d28ab323af375ca5624b4bb91d17271fbae862e413be73f1f68e615b8c5c391be0dbd9144746eb339ad541547ba9c468a17" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "", + "out": "79fe2fe157eb85a038abb8ebbc647731d2c83f51b0ac6ee14aa284cb6a3549a4dcceb300740a825f52f5fb30b03b8c4d8b0f4aa67a63f4a94e3303c4eda4c02b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "", + "out": "75351313b52a8529298d8c186b1768666dcca8595317d7a4816eb88c062020c0c8efc554bb341b64688db5ccafc35f3c3cd09d6564b36d7b04a248e146980d4b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "", + "out": "e3128b1d311d02179d7f25f97a5a8bee2cc8c86303644fcd664e157d1fef00f23e46f9a5e8e5c890ce565bb6abd4302ce06469d52a5bd53e1c5a54d04649dc03" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "", + "out": "c2382a72d2d3ace9d5933d00b60827ed380cda08d0ba5f6dd41e29ee6dbe8ecb9235f06be95d83b6816a2fb7a5ad47035e8a4b69a4884b99e4bece58cab25d44" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "", + "out": "6b1c69460bbd50ac2ed6f32e6e887cfed407d47dcf0aaa60387fe320d780bd03eab6d7baeb2a07d10cd552a300341354ea9a5f03183a623f92a2d4d9f00926af" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "", + "out": "6cda206c80cdc9c44ba990e0328c314f819b142d00630404c48c05dc76d1b00ce4d72fc6a48e1469ddef609412c364820854214b4869af090f00d3c1ba443e1b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "", + "out": "7ffc8c26fbd6a0f7a609e6e1939f6a9edf1b0b066641fb76c4f9602ed748d11602496b35355b1aa255850a509d2f8ee18c8f3e1d7dcbc37a136598f56a59ed17" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "", + "out": "70de1f08dd4e09d5fc151f17fc991a23abfc05104290d50468882efaf582b6ec2f14f577c0d68c3ad06626916e3c86e6daab6c53e5163e82b6bd0ce49fc0d8df" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "", + "out": "4f81935756ed35ee2058ee0c6a6110d6fac5cb6a4f46aa9411603f99965823b6da4838276c5c06bc7880e376d92758369ee7305bcec8d3cfd28ccabb7b4f0579" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "", + "out": "abcb61cb3683d18f27ad527908ed2d32a0426cb7bb4bf18061903a7dc42e7e76f982382304d18af8c80d91dd58dd47af76f8e2c36e28af2476b4bccf82e89fdf" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "", + "out": "02d261ad56a526331b643dd2186de9a82e72a58223cd1e723686c53d869b83b94632b7b647ab2afc0d522e29da3a5615b741d82852e0df41b66007dbcba90543" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "", + "out": "c5832741fa30c5436823015383d297ff4c4a5d7276c3f902122066e04be5431b1a85faf73b918434f9300963d1dea9e8ac3924ef490226edeea5f743e410669f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "", + "out": "cfaeab268cd075a5a6aed515023a032d54f2f2ff733ce0cbc78db51db4504d675923f82746d6594606ad5d67734b11a67cc6a468c2032e43ca1a94c6273a985e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "", + "out": "860850f92eb268272b67d133609bd64e34f61bf03f4c1738645c17fec818465d7ecd2be2907641130025fda79470ab731646e7f69440e8367ea76ac4cee8a1df" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "", + "out": "84b154ed29bbedefa648286839046f4b5aa34430e2d67f7496e4c39f2c7ea78995f69e1292200016f16ac3b37700e6c7e7861afc396b64a59a1dbf47a55c4bbc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "", + "out": "aeeec260a5d8eff5ccab8b95da435a63ed7a21ea7fc7559413fd617e33609f8c290e64bbacc528f6c080262288b0f0a3219be223c991bee92e72349593e67638" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "", + "out": "8ad78a9f26601d127e8d2f2f976e63d19a054a17dcf59e0f013ab54a6887bbdffde7aaae117e0fbf3271016595b9d9c712c01b2c53e9655a382bc4522e616645" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "", + "out": "8934159dade1ac74147dfa282c75954fcef443ef25f80dfe9fb6ea633b8545111d08b34ef43fff17026c7964f5deac6d2b3c29dacf2747f022df5967dfdc1a0a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "", + "out": "cd36dd0b240614cf2fa2b9e959679dcdd72ec0cd58a43da3790a92f6cdeb9e1e795e478a0a47d371100d340c5cedcdbbc9e68b3f460818e5bdff7b4cda4c2744" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "", + "out": "00df4e099b807137a85990f49d3a94315e5a5f7f7a6076b303e96b056fb93800111f479628e2f8db59aeb6ac70c3b61f51f9b46e80ffdeae25ebddb4af6cb4ee" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "", + "out": "2b9c955e6caed4b7c9e246b86f9a1726e810c59d126cee66ed71bf015b83558a4b6d84d18dc3ff4620c2ffb722359fdef85ba0d4e2d22ecbe0ed784f99afe587" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "", + "out": "181df0a261a2f7d29ea5a15772715105d450a4b6c236f699f462d60ca76487feedfc9f5eb92df838e8fb5dc3694e84c5e0f4a10b761f506762be052c745a6ee8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "", + "out": "21fb203458bf3a7e9a80439f9a902899cd5de0139dfd56f7110c9dec8437b26bda63de2f565926d85edb1d6c6825669743dd9992653d13979544d5dc8228bfaa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "", + "out": "ef021f29c5ffb830e64b9aa9058dd660fd2fcb81c497a7e698bcfbf59de5ad4a86ff93c10a4b9d1ae5774725f9072dcde9e1f199bab91f8bff921864aa502eee" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "", + "out": "b3cfda40526b7f1d37569bdfcdf911e5a6efe6b2ec90a0454c47b2c046bf130fc3b352b34df4813d48d33ab8e269b69b075676cb6d00a8dcf9e1f967ec191b2c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "", + "out": "b4c6c3b267071eefb9c8c72e0e2b941293641f8673cb70c1cc26ad1e73cf141755860ad19b34c2f34ed35bb52ec4507cc1fe59047743a5f0c6febde625e26091" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "", + "out": "57a34f2bcca60d4b85103b830c9d7952a416be5263ae429c9e5e53fe8590a8f78ec65a51109ea85dcdf7b6223f9f2b340539fad81923dbf8edabf95129e4dff6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "", + "out": "9cf46662fcd61a232277b685663b8b5da832dfd9a3b8ccfeec993ec6ac415ad07e048adfe414df272770dba867da5c1224c6fd0aa0c2187d426ac647e9887361" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "", + "out": "5ce1042ab4d542c2f9ee9d17262af8164098935bef173d0e18489b04841746cd2f2df866bd7da6e5ef9024c648023ec723ab9c62fd80285739d84f15d2ab515a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "", + "out": "8488396bd4a8729b7a473178f232dadf3f0f8e22678ba5a43e041e72da1e2cf82194c307207a54cb8156293339eaec693ff66bfcd5efc65e95e4ecaf54530abd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "", + "out": "f598da901c3835bca560779037dfde9f0c51dc61c0b760fc1522d7b470ee63f5bdc6498476e86049ad86e4e21af2854a984cc905427d2f17f66b1f41c3da6f61" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "", + "out": "5f93269798cf02132107337660a8d7a177354c0212eb93e555e7c37a08aef3d8dce01217011cd965c04dd2c105f2e2b6cae5e4e6bcaf09dfbee3e0a6a6357c37" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "", + "out": "0ecf581d47bac9230986faabd70c2f5b80e91066f0ec55a842937882286d2ca007bb4e973b0b091d52167ff7c4009c7ab4ad38fff1dceacdb7be81ef4a452952" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "", + "out": "5aeca8abe1528582b2a307b4009585498a3d467ca6101cb0c5126f9976056e9ffc123cc20c302b2a737f492c75d21f01512c90ca0541dfa56e950a321dcb28d8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "", + "out": "732fbf8f1cb2b8329263ede27858fe46f8d3354d376bcda0548e7ce1fa9dd11f85eb661fe950b543aa635ca4d3f04ede5b32d6b656e5ce1c44d35c4a6c56cff8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "", + "out": "d5e938735d63788c80100aefd18648d18cf272f69f20ff24cfe2895c088ad08b0104da1672a4eb26fc52545cc7d7a01b266cf546c403c45bd129eb41bdd9200b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "", + "out": "65a245b49352ee297d91af8c8be00528ac6e046dd83ac7bd465a98816dd68f3e00e1ae8f895327a7e9a8c9326598379a29c9fc91ec0c6eef08f3e2b216c11008" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "", + "out": "c95654b63019130ab45dd0fb4941b98aeb3af2a123913eca2ce99b3e97410a7bf8661cc7fbaa2bc1cf2b13113b1ed40a0118b88e5fffc3542759ea007ed4c58d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "", + "out": "1eb262f38fa494431f017dad44c0dfb69324ac032f04b657fc91a88647bb74760f24e7c956514f0cf002990b182c1642b9b2426e96a61187e4e012f00e217d84" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "", + "out": "3b955aeebfa5151ac1ab8e3f5cc1e3767084c842a575d36269836e97353d41622b731dddcd5f269550a3a5b87be1e90326340b6e0e62555815d9600597ac6ef9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "", + "out": "68289f6605473ba0e4f241baf7477a9885426a858f19ef2a18b0d40ef8e41282ed5526b519799e270f13881327918278755711071d8511fe963e3b5606aa3716" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "", + "out": "80a33787542612c38f6bcd7cd86cab460227509b1cbad5ec408a91413d51155a0476dadbf3a2518e4a6e77cc346622e347a469bf8baa5f04eb2d98705355d063" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "", + "out": "34629bc6d831391c4cdf8af1b4b7b6b8e8ee17cf98c70e5dd586cd99f14b11df945166236a9571e6d591bb83ee4d164d46f6b9d8ef86ff865a81bfb91b00424b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "", + "out": "8b7cc339163863bb4383e542b0ef0e7cf36b84ad932cdf5a80419ec9ad692e7a7e784d2c7cb3796a18b8f800035f3aa06c824100611120a7bdeb35618ccb81b7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "", + "out": "4f084e4939dd5a7f5a658fad58a18a15c25c32ec1c7fd5c5c6c3e892b3971aeaac308304ef17b1c47239ea4bb398b3fd6d4528d8de8e768ae0f1a5a5c6b5c297" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "", + "out": "48f407a1af5b8009b2051742e8cf5cd5656669e7d722ee8e7bd202060849442168d8facc117c012bfb7bf449d99befff6a34aea203f1d8d352722be5014ec818" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "", + "out": "a6aa82cd1e426f9a73bfa39a29037876114655b8c22d6d3ff8b638ae7dea6b17843e09e52eb66fa1e475e4a8a3de429b7d0f4a776fcb8bdc9b9fede7d52e815f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "", + "out": "5817027d6bdd00c5dd10ac593cd560372270775a18526d7e6f13872a2e20eab664625be7168ac4bd7c9e0ce7fc4099e0f48442e2c767191c6e1284e9b2ccea8c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "", + "out": "08e41028340a45c74e4052b3a8d6389e22e043a1adab5e28d97619450d723469b620caa519b81c14523854f619fd3027e3847bd03276e60604a80ddb4de876d6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "", + "out": "130b8420537eb07d72abda07c85acbd8b9a44f16321dd0422145f809673d30f2b5321326e2bff317ef3fef983c51c4f8ab24a325d298e34afce569a82555774c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "", + "out": "ac49b844afaa012e31c474ca263648844fd2f6307992c2f752aca02c3828965175794deee2d2ee95c61cd284f6b5a2d75e2ef2b29ee8149e77fb81447b2fd04b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "", + "out": "b9d7ca81cc60bb9578e44024e5a0a0be80f27336a6a9f4e53df3999cb191280b090e2ac2d29c5baad9d71415bdc129e69aa2667af6a7fd5e189fccdcee817340" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "", + "out": "a755e113386572c75ced61d719706070b9146048e42a9f8cd35667a088b42f08808abdf77e618abd959afc757379ca2c00bcc1a48390fa2bff618b1e0078a613" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "", + "out": "a73c7debed326f1c0db0795ee7d6e3946894b826b1f8101c56c823ba17168312e7f53fc7dbe52c3e11e69852c40485e2ef182477862ea6a34ec136e2dfeea6f4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "", + "out": "6cb8f9d52c56d82cac28f39ea1593e8bb2506293ac0d68376a1709b62a46df14a4ae64b2d8fab76733a1ced2d548e3f3c6fcb49d40c3d5808e449cd83d1c2aa2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "", + "out": "683fa2b2369a10162c1c1c7b24bc970ee67da220564f32203f625696c0352a0b9ad96624362d952d84463c1106a2dba7a092599884b35a0b89c8f1b6a9b5a61e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "", + "out": "aad9ad44610118b77d508aeb1bbcd1c1b7d0171397fb510a401bbc0ec34623670d86a2dc3c8f3ab5a2044df730256727545f0860ce21a1eac717dfc48f5d228e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "", + "out": "c42578de23b4c987d5e1ac4d689ed5de4b0417f9704bc6bce969fa13471585d62c2cb1212a944f397fc9ca2c3747c3beb694ec4c5be68828dda53ef43faec6c0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "", + "out": "470f00841ee8244e63ed2c7ea30e2e419897c197462ecccecf713b42a5065fff5914bc9b79affe8f6b657875e789ae213bd914cd35bd174d46e9d18bd843773d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "", + "out": "34fc4213730f47a5e9a3580f643e12945cfcb31bf206f6ad450ce528da3fa432e005d6b0ecce10dca7c5995f6aacc5150e1b009e19751e8309f8859531844374" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "", + "out": "fb3c1f0f56a56f8e316fdf5d853c8c872c39635d083634c3904fc3ac07d1b578e85ff0e480e92d44ade33b62e893ee32343e79ddf6ef292e89b582d312502314" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "", + "out": "c7c97fc65dd2b9e3d3d607d31598d3f84261e9919251e9c8e57bb5f829377d5f73eabbed55c6c381180f29ad02e5be797ffec7e57bdecbc50ad3d062f0993ab0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "", + "out": "a57a49cdbe67ae7d9f797bb5cc7efc2df07f4e1b15955f85dae74b76e2ecb85afb6cd9eeed8888d5ca3ec5ab65d27a7b19e578475760a045ac3c92e13a938e77" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "", + "out": "c7143fce9614a17fd653aeb140726dc9c3dbb1de6cc581b2726897ec24b7a50359ad492243be66d9edd8c933b5b80e0b91bb61ea98056006516976fae8d99a35" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "", + "out": "65bb58d07f937e2d3c7e65385f9c54730b704105ccdb691f6e146d4ee8f6c086f49511035110a9ad6031fdceb943e0f9613bcb276dd40f0624ef0f924f809783" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "", + "out": "e540277f683b1186dd3b5b3f61433396581a35feb12002be8c6a6231fc40ffa70f08081bc58b2d94f7649543614a435faa2d62110e13dabc7b86629b63af9c24" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "", + "out": "418500878c5fbcb584c432f4285e05e49f2e3e075399a0dbfcf874ebf8c03d02bf16bc6989d161c77ca0786b05053c6c709433712319192128835cf0b660595b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "", + "out": "889090dbb1944bdc9433ee5ef1010c7a4a24a8e71ecea8e12a31318ce49dcab0aca5c3802334aab2cc84b14c6b9321fe586bf3f876f19cd406eb1127fb944801" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "", + "out": "53b6a28910aa92e27e536fb549cf9b9918791060898e0b9fe183577ff43b5e9c7689c745b32e412269837c31b89e6cc12bf76e13cad366b74ece48bb85fd09e9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "", + "out": "7c092080c6a80d672409d081d3d177106bcd63567785140719490950ae07ae8fcaabbaaab330cfbcf7374482c220af2eadeeb73dcbb35ed823344e144e7d4899" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "", + "out": "9ccde566d2400509181111f32dde4cd63209fe59a30c114546ad2776d889a41bad8fa1bb468cb2f9d42ca9928a7770fef8e8ba4d0c812d9a1e75c3d8d2ccd75a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "", + "out": "6e293bf5d03fe43977cfe3f57ccdb3ae282a85455dca33f37f4b74f8398cc612433d755cbec412f8f82a3bd3bc4a278f7ecd0dfa9bbdc40be7a787c8f159b2df" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "", + "out": "c56546fb2178456f336164c18b90deffc83ae2b5a3aca77b6884d36d2c1db39501b3e65e36c758c66e3188451fdb3515ee162c001f06c3e8cb573adf30f7a101" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "", + "out": "6f82f89f299ebca2fe014b59bffe1aa84e88b1915fe256afb646fd8448af2b8891a7fab37a4ea6f9a50e6c317039d8cf878f4c8e1a0dd464f0b4d6ff1c7ea853" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "", + "out": "2b8599ff9c3d6198637ad51e57d1998b0d75313fe2dd61a533c964a6dd9607c6f723e9452ce46e014b1c1d6de77ba5b88c914d1c597bf1eae13474b4290e89b2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "", + "out": "08bf346d38e1df06c8260edb1da75579275948d5c0a0aa9ed2886f8856de5417a156998758f5b17e52f101ca957a71137473dfd18d7d209c4c10d9233c93691d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "", + "out": "6df2156d773114d310b63db9ee5350d77e6bcf25b05fcd910f9b31bc42bb13fe8225ebcb2a23a62280777b6bf74e2cd0917c7640b43defe468cd1e18c943c66a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "", + "out": "7c7038bc13a91151828a5ba82b4a96040f258a4dfb1b1373f0d359168afb0517a20b28a12d3644046be66b8d08d8ae7f6a923ea1c00187c6d11dc502bac71305" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "", + "out": "bcd1b30d808fb739b987cbf154bea00da9d40380b861d4c1d6377122dadd61c0e59018b71941cfb62e00dcd70aeb9abf0473e80f0a7eca6b6dea246ab229dd2b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "", + "out": "7ed4468d968530fe7ab2c33540b26d8c3bd3ed44b34fbe8c2a9d7f805b5ada0ea252eeade4fce97f89728ad85bc8bb2430b1bef2cddd32c8446e59b8e8ba3c67" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "", + "out": "6d30b7c6ce8a3236c0ca2f8d728b1088ca06983a8043e621d5dcf0c537d13b08791edeb01a3cf0943ec1c890ab6e29b146a236cd46bcb9d93bf516fb67c63fe5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "", + "out": "97fe03cef31438508911bded975980a66029305dc5e3fa8ad1b4fb22fcdf5a19a733320327d8f71ccf496cb3a44a77af56e3dde73d3a5f176896cc57c9a5ad99" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "", + "out": "785a9d0fbd21136dbce8fa7eafd63c9dad220052978416b31d9753eaa149097847ed9b30a65c70507eff01879149ed5cf0471d37798edc05abd56ad4a2cccb1d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "", + "out": "ad408d2abddfd37b3bf34794c1a3371d928ed7fc8d966225333584c5665817832a37c07f0dc7cb5aa874cd7d20fe8fab8eabcb9b33d2e0841f6e200960899d95" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "", + "out": "97668f745b6032fc815d9579322769dccd9501a5080029b8ae826befb6742331bd9f76efeb3e2b8e81a9786b282f5068a3a2424697a77c41876b7e753f4c7767" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "", + "out": "26bb985f47e7fee0cfd252d4ef96bed42b9c370c1c6a3e8c9eb04ef7f7818b833a0d1f043ebafb911dc779e02740a02a44d3a1ea45ed4ad55e686c927cafe97e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "", + "out": "5bfe2b1dcf7fe9b95088acedb575c19016c743b2e763bf5851ac407c9eda43715edfa48b4825492c5179593fff21351b76e8b7e034e4c53c79f61f29c479bd08" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "", + "out": "c76509ef72f4a6f9c9c40618ed52b2084f83502232e0ac8bdaf3264368e4d0180f6854c4abf4f6509c79caafc44cf3194afc57bd077bd7b3c9bda3d4b8775816" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "", + "out": "d66f2beab990e354ccb910e4e9c7ac618c7b63ef292a96b552341de78dc46d3ec8cfabc699b50af41fda39cf1b0173660923510ad67faedef5207cffe8641d20" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "", + "out": "7d8f0672992b79be3a364d8e5904f4ab713bbc8ab01b4f309ad8ccf223ce1034a860dcb0b00550612cc2fa17f2969e18f22e1427d254b4a82b3a03a3eb394adf" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "", + "out": "a56d6725bfb3de47c1414adf25fc8f0fc9846f6987722bc06366d5ca4e89722925ebbc881418844075397a0ca89842c7b9e9e07e1d9d183ebeb39e120b483bf7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "", + "out": "af5e03d7fe60c67e10313344434e79485a03a758d6dce985574745763c1c5c77d4fb3e6fb12230368370993bf90feed0c5d1607524562d7c09c0c210ed393d7c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "", + "out": "7a20540cc07bf72b582421fc342e82f52134b69841ec28ed189e2ea6a29dd2f82a640352d222b52f2911dc72a7dab31caadd80c6118f13c56b2a1e4373be0ea3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "", + "out": "486f02c63e5467ea1fdde7e82bfacc2c1ba5d636d9f3d08b210da3f372f706ec218cc17ff60aef703bbe0c15c38ae55d286a684f864c78211ccab4178c92adba" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "", + "out": "1c7a5c1dedcd04a921788f7eb23361ca1953b04b9c7aec35d65ea3e4996db26f281278ea4ae666ad81027d98af57262cdbfa4c085f4210568c7e15eec7805114" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "", + "out": "9ce3fa9a860bdbd5378fd6d7b8b671c6cb7692910ce8f9b6cb4122cbcbe6ac06ca0422cef1225935053b7d193a81b9e972eb85a1d3074f14cbb5ec9f0573892d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "", + "out": "a91187be5c371c4265c174fd4653b8ab708551f83d1fee1cc1479581bc006d6fb78fcc9a5dee1db3666f508f9780a37593ebcccf5fbed39667dc6361e921f779" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "", + "out": "4625767d7b1d3d3ed2fbc674af14e0244152f2a4021fcf3311505d89bd81e2f9f9a500c3b199914db49500b3c98d03ea93286751a686a3b875daab0ccd63b44f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "", + "out": "43dfdfe1b014fed3a2acabb7f3e9a182f2aa18019d27e3e6cdcf31a15b428e91e7b08cf5e5c376fce2d8a28ff85ab0a0a1656edb4a0a91532620096d9a5a652d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "", + "out": "279e3202be3989ba3112772585177487e4fe3ee3eab49c2f7fa7fe87cfe7b80d3e0355edff6d031e6c96c795db1c6f041880ec3824defacf9263820a8e7327de" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "", + "out": "ea2d066ac229d4d4b616a8bedec734325224e4b4e58f1ae6dad7e40c2da29196c3b1ea9571dacc81e87328caa0211e09027b0524aa3f4a849917b3586747ebbb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "", + "out": "49f014f5c61822c899ab5cae51be4044a4495e777deb7da9b6d8490efbb87530adf293daf079f94c33b7044ef62e2e5bb3eb11e17304f8453ee6ce24f033ddb0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "", + "out": "9233490344e5b0dc5912671b7ae54cee7730dbe1f4c7d92a4d3e3aab50571708db51dcf9c2944591db651db32d22935b86944969be77d5b5feae6c3840a8db26" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "", + "out": "b6e75e6f4c7f453b7465d25b5ac8c7196902eaa953875228c8634e16e2ae1f38bc3275304335f5989eccc1e34167d4e68d7719968fba8e2fe67947c35c48e806" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "", + "out": "cc14ca665af1483efbc3af80080e650d5046a3932f4f51f3fe90a0705ec25104adf07839265dc51d43401411246e474f0d5e5637af94767283d53e0617e981f4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "", + "out": "230a1c857cb2e7852e41b647e90e4585d2d881e1734dc38955356e8dd7bff39053092c6b38e236e1899525647073dddf6895d64206325e7647f275567b255909" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "", + "out": "cbb65321ac436e2ffdab2936359ce49023f7dee7614ef28d173c3d27c5d1bffa51553d433f8ee3c9e49c05a2b883cce954c9a8093b80612a0cdd4732e041f995" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "", + "out": "3e7e570074337275efb51315588034c3cf0dddca20b4612e0bd5b881e7e5476d319ce4fe9f19186e4c0826f44f131eb048e65be242b1172c63badb123ab0cbe8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "", + "out": "d32e9ec02d38d4e1b8249df8dcb00c5b9c68eb8922672e3505393b6a210ba56f9496e5ee0490ef387c3cdec061f06bc0382d9304cafbb8e0cd33d57029e62df2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "", + "out": "8c1512466089f05b3775c262b62d22b83854a83218130b4ec91b3ccbd293d2a54302cecaab9b100c68d1e6ddc8f07cddbdfe6fdaaaf099cc09d6b725879c6369" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "", + "out": "91a7f61c97c2911e4c812ef71d780ad8fa788794561d08303fd1c1cb608a46a12563086ec5b39d471aed94fb0f6c678a43b8792932f9028d772a22768ea23a9b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "", + "out": "4f6bb222a395e8b18f6ba155477aed3f0729ac9e83e16d31a2a8bc655422b837c891c6199e6f0d75799e3b691525c581953517f252c4b9e3a27a28fbaf49644c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "", + "out": "5d06c07e7a646c413a501c3f4bb2fc38127de7509b7077c4d9b5613201c1aa02fd5f79d2745915dd57fbcb4ce08695f6efc0cb3d2d330e19b4b0e6004ea6471e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "", + "out": "b96756e57909968f14b796a5d30f4c9d671472cf82c8cfb2caca7ac7a44ca0a14c9842d00c82e337502c94d5960aca4c492ea7b0df919ddf1aada2a275bb10d4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "", + "out": "ff0a015e98db9c99f03977710aac3e658c0d896f6d71d618ba79dc6cf72ac75b7c038eb6862dede4543e145413a6368d69f5722c827ba3ef25b6ae6440d39276" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "", + "out": "5b21c5fd8868367612474fa2e70e9cfa2201ffeee8fafab5797ad58fefa17c9b5b107da4a3db6320baaf2c8617d5a51df914ae88da3867c2d41f0cc14fa67928" +}, +{ + "hash": "blake2b", + "in": "", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e996e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568" +}, +{ + "hash": "blake2b", + "in": "00", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "961f6dd1e4dd30f63901690c512e78e4b45e4742ed197c3c5e45c549fd25f2e4187b0bc9fe30492b16b0d0bc4ef9b0f34c7003fac09a5ef1532e69430234cebd" +}, +{ + "hash": "blake2b", + "in": "0001", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "da2cfbe2d8409a0f38026113884f84b50156371ae304c4430173d08a99d9fb1b983164a3770706d537f49e0c916d9f32b95cc37a95b99d857436f0232c88a965" +}, +{ + "hash": "blake2b", + "in": "000102", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "33d0825dddf7ada99b0e7e307104ad07ca9cfd9692214f1561356315e784f3e5a17e364ae9dbb14cb2036df932b77f4b292761365fb328de7afdc6d8998f5fc1" +}, +{ + "hash": "blake2b", + "in": "00010203", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "beaa5a3d08f3807143cf621d95cd690514d0b49efff9c91d24b59241ec0eefa5f60196d407048bba8d2146828ebcb0488d8842fd56bb4f6df8e19c4b4daab8ac" +}, +{ + "hash": "blake2b", + "in": "0001020304", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "098084b51fd13deae5f4320de94a688ee07baea2800486689a8636117b46c1f4c1f6af7f74ae7c857600456a58a3af251dc4723a64cc7c0a5ab6d9cac91c20bb" +}, +{ + "hash": "blake2b", + "in": "000102030405", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6044540d560853eb1c57df0077dd381094781cdb9073e5b1b3d3f6c7829e12066bbaca96d989a690de72ca3133a83652ba284a6d62942b271ffa2620c9e75b1f" +}, +{ + "hash": "blake2b", + "in": "00010203040506", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7a8cfe9b90f75f7ecb3acc053aaed6193112b6f6a4aeeb3f65d3de541942deb9e2228152a3c4bbbe72fc3b12629528cfbb09fe630f0474339f54abf453e2ed52" +}, +{ + "hash": "blake2b", + "in": "0001020304050607", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "380beaf6ea7cc9365e270ef0e6f3a64fb902acae51dd5512f84259ad2c91f4bc4108db73192a5bbfb0cbcf71e46c3e21aee1c5e860dc96e8eb0b7b8426e6abe9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "60fe3c4535e1b59d9a61ea8500bfac41a69dffb1ceadd9aca323e9a625b64da5763bad7226da02b9c8c4f1a5de140ac5a6c1124e4f718ce0b28ea47393aa6637" +}, +{ + "hash": "blake2b", + "in": "00010203040506070809", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4fe181f54ad63a2983feaaf77d1e7235c2beb17fa328b6d9505bda327df19fc37f02c4b6f0368ce23147313a8e5738b5fa2a95b29de1c7f8264eb77b69f585cd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f228773ce3f3a42b5f144d63237a72d99693adb8837d0e112a8a0f8ffff2c362857ac49c11ec740d1500749dac9b1f4548108bf3155794dcc9e4082849e2b85b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "962452a8455cc56c8511317e3b1f3b2c37df75f588e94325fdd77070359cf63a9ae6e930936fdf8e1e08ffca440cfb72c28f06d89a2151d1c46cd5b268ef8563" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "43d44bfa18768c59896bf7ed1765cb2d14af8c260266039099b25a603e4ddc5039d6ef3a91847d1088d401c0c7e847781a8a590d33a3c6cb4df0fab1c2f22355" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dcffa9d58c2a4ca2cdbb0c7aa4c4c1d45165190089f4e983bb1c2cab4aaeff1fa2b5ee516fecd780540240bf37e56c8bcca7fab980e1e61c9400d8a9a5b14ac6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6fbf31b45ab0c0b8dad1c0f5f4061379912dde5aa922099a030b725c73346c524291adef89d2f6fd8dfcda6d07dad811a9314536c2915ed45da34947e83de34e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a0c65bddde8adef57282b04b11e7bc8aab105b99231b750c021f4a735cb1bcfab87553bba3abb0c3e64a0b6955285185a0bd35fb8cfde557329bebb1f629ee93" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f99d815550558e81eca2f96718aed10d86f3f1cfb675cce06b0eff02f617c5a42c5aa760270f2679da2677c5aeb94f1142277f21c7f79f3c4f0cce4ed8ee62b1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "95391da8fc7b917a2044b3d6f5374e1ca072b41454d572c7356c05fd4bc1e0f40b8bb8b4a9f6bce9be2c4623c399b0dca0dab05cb7281b71a21b0ebcd9e55670" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "04b9cd3d20d221c09ac86913d3dc63041989a9a1e694f1e639a3ba7e451840f750c2fc191d56ad61f2e7936bc0ac8e094b60caeed878c18799045402d61ceaf9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ec0e0ef707e4ed6c0c66f9e089e4954b058030d2dd86398fe84059631f9ee591d9d77375355149178c0cf8f8e7c49ed2a5e4f95488a2247067c208510fadc44c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9a37cce273b79c09913677510eaf7688e89b3314d3532fd2764c39de022a2945b5710d13517af8ddc0316624e73bec1ce67df15228302036f330ab0cb4d218dd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4cf9bb8fb3d4de8b38b2f262d3c40f46dfe747e8fc0a414c193d9fcf753106ce47a18f172f12e8a2f1c26726545358e5ee28c9e2213a8787aafbc516d2343152" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "64e0c63af9c808fd893137129867fd91939d53f2af04be4fa268006100069b2d69daa5c5d8ed7fddcb2a70eeecdf2b105dd46a1e3b7311728f639ab489326bc9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5e9c93158d659b2def06b0c3c7565045542662d6eee8a96a89b78ade09fe8b3dcc096d4fe48815d88d8f82620156602af541955e1f6ca30dce14e254c326b88f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7775dff889458dd11aef417276853e21335eb88e4dec9cfb4e9edb49820088551a2ca60339f12066101169f0dfe84b098fddb148d9da6b3d613df263889ad64b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f0d2805afbb91f743951351a6d024f9353a23c7ce1fc2b051b3a8b968c233f46f50f806ecb1568ffaa0b60661e334b21dde04f8fa155ac740eeb42e20b60d764" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "86a2af316e7d7754201b942e275364ac12ea8962ab5bd8d7fb276dc5fbffc8f9a28cae4e4867df6780d9b72524160927c855da5b6078e0b554aa91e31cb9ca1d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "10bdf0caa0802705e706369baf8a3f79d72c0a03a80675a7bbb00be3a45e516424d1ee88efb56f6d5777545ae6e27765c3a8f5e493fc308915638933a1dfee55" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b01781092b1748459e2e4ec178696627bf4ebafebba774ecf018b79a68aeb84917bf0b84bb79d17b743151144cd66b7b33a4b9e52c76c4e112050ff5385b7f0b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c6dbc61dec6eaeac81e3d5f755203c8e220551534a0b2fd105a91889945a638550204f44093dd998c076205dffad703a0e5cd3c7f438a7e634cd59fededb539e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eba51acffb4cea31db4b8d87e9bf7dd48fe97b0253ae67aa580f9ac4a9d941f2bea518ee286818cc9f633f2a3b9fb68e594b48cdd6d515bf1d52ba6c85a203a7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "86221f3ada52037b72224f105d7999231c5e5534d03da9d9c0a12acb68460cd375daf8e24386286f9668f72326dbf99ba094392437d398e95bb8161d717f8991" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5595e05c13a7ec4dc8f41fb70cb50a71bce17c024ff6de7af618d0cc4e9c32d9570d6d3ea45b86525491030c0d8f2b1836d5778c1ce735c17707df364d054347" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ce0f4f6aca89590a37fe034dd74dd5fa65eb1cbd0a41508aaddc09351a3cea6d18cb2189c54b700c009f4cbf0521c7ea01be61c5ae09cb54f27bc1b44d658c82" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7ee80b06a215a3bca970c77cda8761822bc103d44fa4b33f4d07dcb997e36d55298bceae12241b3fa07fa63be5576068da387b8d5859aeab701369848b176d42" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "940a84b6a84d109aab208c024c6ce9647676ba0aaa11f86dbb7018f9fd2220a6d901a9027f9abcf935372727cbf09ebd61a2a2eeb87653e8ecad1bab85dc8327" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2020b78264a82d9f4151141adba8d44bf20c5ec062eee9b595a11f9e84901bf148f298e0c9f8777dcdbc7cc4670aac356cc2ad8ccb1629f16f6a76bcefbee760" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d1b897b0e075ba68ab572adf9d9c436663e43eb3d8e62d92fc49c9be214e6f27873fe215a65170e6bea902408a25b49506f47babd07cecf7113ec10c5dd31252" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b14d0c62abfa469a357177e594c10c194243ed2025ab8aa5ad2fa41ad318e0ff48cd5e60bec07b13634a711d2326e488a985f31e31153399e73088efc86a5c55" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4169c5cc808d2697dc2a82430dc23e3cd356dc70a94566810502b8d655b39abf9e7f902fe717e0389219859e1945df1af6ada42e4ccda55a197b7100a30c30a1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "258a4edb113d66c839c8b1c91f15f35ade609f11cd7f8681a4045b9fef7b0b24c82cda06a5f2067b368825e3914e53d6948ede92efd6e8387fa2e537239b5bee" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "79d2d8696d30f30fb34657761171a11e6c3f1e64cbe7bebee159cb95bfaf812b4f411e2f26d9c421dc2c284a3342d823ec293849e42d1e46b0a4ac1e3c86abaa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8b9436010dc5dee992ae38aea97f2cd63b946d94fedd2ec9671dcde3bd4ce9564d555c66c15bb2b900df72edb6b891ebcadfeff63c9ea4036a998be7973981e7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c8f68e696ed28242bf997f5b3b34959508e42d613810f1e2a435c96ed2ff560c7022f361a9234b9837feee90bf47922ee0fd5f8ddf823718d86d1e16c6090071" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b02d3eee4860d5868b2c39ce39bfe81011290564dd678c85e8783f29302dfc1399ba95b6b53cd9ebbf400cca1db0ab67e19a325f2d115812d25d00978ad1bca4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7693ea73af3ac4dad21ca0d8da85b3118a7d1c6024cfaf557699868217bc0c2f44a199bc6c0edd519798ba05bd5b1b4484346a47c2cadf6bf30b785cc88b2baf" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a0e5c1c0031c02e48b7f09a5e896ee9aef2f17fc9e18e997d7f6cac7ae316422c2b1e77984e5f3a73cb45deed5d3f84600105e6ee38f2d090c7d0442ea34c46d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "41daa6adcfdb69f1440c37b596440165c15ada596813e2e22f060fcd551f24dee8e04ba6890387886ceec4a7a0d7fc6b44506392ec3822c0d8c1acfc7d5aebe8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "14d4d40d5984d84c5cf7523b7798b254e275a3a8cc0a1bd06ebc0bee726856acc3cbf516ff667cda2058ad5c3412254460a82c92187041363cc77a4dc215e487" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d0e7a1e2b9a447fee83e2277e9ff8010c2f375ae12fa7aaa8ca5a6317868a26a367a0b69fbc1cf32a55d34eb370663016f3d2110230eba754028a56f54acf57c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e771aa8db5a3e043e8178f39a0857ba04a3f18e4aa05743cf8d222b0b095825350ba422f63382a23d92e4149074e816a36c1cd28284d146267940b31f8818ea2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "feb4fd6f9e87a56bef398b3284d2bda5b5b0e166583a66b61e538457ff0584872c21a32962b9928ffab58de4af2edd4e15d8b35570523207ff4e2a5aa7754caa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "462f17bf005fb1c1b9e671779f665209ec2873e3e411f98dabf240a1d5ec3f95ce6796b6fc23fe171903b502023467dec7273ff74879b92967a2a43a5a183d33" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d3338193b64553dbd38d144bea71c5915bb110e2d88180dbc5db364fd6171df317fc7268831b5aef75e4342b2fad8797ba39eddcef80e6ec08159350b1ad696d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e1590d585a3d39f7cb599abd479070966409a6846d4377acf4471d065d5db94129cc9be92573b05ed226be1e9b7cb0cabe87918589f80dadd4ef5ef25a93d28e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f8f3726ac5a26cc80132493a6fedcb0e60760c09cfc84cad178175986819665e76842d7b9fedf76dddebf5d3f56faaad4477587af21606d396ae570d8e719af2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "30186055c07949948183c850e9a756cc09937e247d9d928e869e20bafc3cd9721719d34e04a0899b92c736084550186886efba2e790d8be6ebf040b209c439a4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f3c4276cb863637712c241c444c5cc1e3554e0fddb174d035819dd83eb700b4ce88df3ab3841ba02085e1a99b4e17310c5341075c0458ba376c95a6818fbb3e2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0aa007c4dd9d5832393040a1583c930bca7dc5e77ea53add7e2b3f7c8e231368043520d4a3ef53c969b6bbfd025946f632bd7f765d53c21003b8f983f75e2a6a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "08e9464720533b23a04ec24f7ae8c103145f765387d738777d3d343477fd1c58db052142cab754ea674378e18766c53542f71970171cc4f81694246b717d7564" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d37ff7ad297993e7ec21e0f1b4b5ae719cdc83c5db687527f27516cbffa822888a6810ee5c1ca7bfe3321119be1ab7bfa0a502671c8329494df7ad6f522d440f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dd9042f6e464dcf86b1262f6accfafbd8cfd902ed3ed89abf78ffa482dbdeeb6969842394c9a1168ae3d481a017842f660002d42447c6b22f7b72f21aae021c9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bd965bf31e87d70327536f2a341cebc4768eca275fa05ef98f7f1b71a0351298de006fba73fe6733ed01d75801b4a928e54231b38e38c562b2e33ea1284992fa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "65676d800617972fbd87e4b9514e1c67402b7a331096d3bfac22f1abb95374abc942f16e9ab0ead33b87c91968a6e509e119ff07787b3ef483e1dcdccf6e3022" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "939fa189699c5d2c81ddd1ffc1fa207c970b6a3685bb29ce1d3e99d42f2f7442da53e95a72907314f4588399a3ff5b0a92beb3f6be2694f9f86ecf2952d5b41c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c516541701863f91005f314108ceece3c643e04fc8c42fd2ff556220e616aaa6a48aeb97a84bad74782e8dff96a1a2fa949339d722edcaa32b57067041df88cc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "987fd6e0d6857c553eaebb3d34970a2c2f6e89a3548f492521722b80a1c21a153892346d2cba6444212d56da9a26e324dccbc0dcde85d4d2ee4399eec5a64e8f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ae56deb1c2328d9c4017706bce6e99d41349053ba9d336d677c4c27d9fd50ae6aee17e853154e1f4fe7672346da2eaa31eea53fcf24a22804f11d03da6abfc2b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "49d6a608c9bde4491870498572ac31aac3fa40938b38a7818f72383eb040ad39532bc06571e13d767e6945ab77c0bdc3b0284253343f9f6c1244ebf2ff0df866" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "da582ad8c5370b4469af862aa6467a2293b2b28bd80ae0e91f425ad3d47249fdf98825cc86f14028c3308c9804c78bfeeeee461444ce243687e1a50522456a1d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d5266aa3331194aef852eed86d7b5b2633a0af1c735906f2e13279f14931a9fc3b0eac5ce9245273bd1aa92905abe16278ef7efd47694789a7283b77da3c70f8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2962734c28252186a9a1111c732ad4de4506d4b4480916303eb7991d659ccda07a9911914bc75c418ab7a4541757ad054796e26797feaf36e9f6ad43f14b35a4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e8b79ec5d06e111bdfafd71e9f5760f00ac8ac5d8bf768f9ff6f08b8f026096b1cc3a4c973333019f1e3553e77da3f98cb9f542e0a90e5f8a940cc58e59844b3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dfb320c44f9d41d1efdcc015f08dd5539e526e39c87d509ae6812a969e5431bf4fa7d91ffd03b981e0d544cf72d7b1c0374f8801482e6dea2ef903877eba675e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d88675118fdb55a5fb365ac2af1d217bf526ce1ee9c94b2f0090b2c58a06ca58187d7fe57c7bed9d26fca067b4110eefcd9a0a345de872abe20de368001b0745" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b893f2fc41f7b0dd6e2f6aa2e0370c0cff7df09e3acfcc0e920b6e6fad0ef747c40668417d342b80d2351e8c175f20897a062e9765e6c67b539b6ba8b9170545" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6c67ec5697accd235c59b486d7b70baeedcbd4aa64ebd4eef3c7eac189561a726250aec4d48cadcafbbe2ce3c16ce2d691a8cce06e8879556d4483ed7165c063" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f1aa2b044f8f0c638a3f362e677b5d891d6fd2ab0765f6ee1e4987de057ead357883d9b405b9d609eea1b869d97fb16d9b51017c553f3b93c0a1e0f1296fedcd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cbaa259572d4aebfc1917acddc582b9f8dfaa928a198ca7acd0f2aa76a134a90252e6298a65b08186a350d5b7626699f8cb721a3ea5921b753ae3a2dce24ba3a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fa1549c9796cd4d303dcf452c1fbd5744fd9b9b47003d920b92de34839d07ef2a29ded68f6fc9e6c45e071a2e48bd50c5084e96b657dd0404045a1ddefe282ed" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5cf2ac897ab444dcb5c8d87c495dbdb34e1838b6b629427caa51702ad0f9688525f13bec503a3c3a2c80a65e0b5715e8afab00ffa56ec455a49a1ad30aa24fcd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9aaf80207bace17bb7ab145757d5696bde32406ef22b44292ef65d4519c3bb2ad41a59b62cc3e94b6fa96d32a7faadae28af7d35097219aa3fd8cda31e40c275" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "af88b163402c86745cb650c2988fb95211b94b03ef290eed9662034241fd51cf398f8073e369354c43eae1052f9b63b08191caa138aa54fea889cc7024236897" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "48fa7d64e1ceee27b9864db5ada4b53d00c9bc7626555813d3cd6730ab3cc06ff342d727905e33171bde6e8476e77fb1720861e94b73a2c538d254746285f430" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0e6fd97a85e904f87bfe85bbeb34f69e1f18105cf4ed4f87aec36c6e8b5f68bd2a6f3dc8a9ecb2b61db4eedb6b2ea10bf9cb0251fb0f8b344abf7f366b6de5ab" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "06622da5787176287fdc8fed440bad187d830099c94e6d04c8e9c954cda70c8bb9e1fc4a6d0baa831b9b78ef6648681a4867a11da93ee36e5e6a37d87fc63f6f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1da6772b58fabf9c61f68d412c82f182c0236d7d575ef0b58dd22458d643cd1dfc93b03871c316d8430d312995d4197f0874c99172ba004a01ee295abac24e46" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3cd2d9320b7b1d5fb9aab951a76023fa667be14a9124e394513918a3f44096ae4904ba0ffc150b63bc7ab1eeb9a6e257e5c8f000a70394a5afd842715de15f29" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "04cdc14f7434e0b4be70cb41db4c779a88eaef6accebcb41f2d42fffe7f32a8e281b5c103a27021d0d08362250753cdf70292195a53a48728ceb5844c2d98bab" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9071b7a8a075d0095b8fb3ae5113785735ab98e2b52faf91d5b89e44aac5b5d4ebbf91223b0ff4c71905da55342e64655d6ef8c89a4768c3f93a6dc0366b5bc8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ebb30240dd96c7bc8d0abe49aa4edcbb4afdc51ff9aaf720d3f9e7fbb0f9c6d6571350501769fc4ebd0b2141247ff400d4fd4be414edf37757bb90a32ac5c65a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8532c58bf3c8015d9d1cbe00eef1f5082f8f3632fbe9f1ed4f9dfb1fa79e8283066d77c44c4af943d76b300364aecbd0648c8a8939bd204123f4b56260422dec" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fe9846d64f7c7708696f840e2d76cb4408b6595c2f81ec6a28a7f2f20cb88cfe6ac0b9e9b8244f08bd7095c350c1d0842f64fb01bb7f532dfcd47371b0aeeb79" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "28f17ea6fb6c42092dc264257e29746321fb5bdaea9873c2a7fa9d8f53818e899e161bc77dfe8090afd82bf2266c5c1bc930a8d1547624439e662ef695f26f24" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ec6b7d7f030d4850acae3cb615c21dd25206d63e84d1db8d957370737ba0e98467ea0ce274c66199901eaec18a08525715f53bfdb0aacb613d342ebdceeddc3b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b403d3691c03b0d3418df327d5860d34bbfcc4519bfbce36bf33b208385fadb9186bc78a76c489d89fd57e7dc75412d23bcd1dae8470ce9274754bb8585b13c5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "31fc79738b8772b3f55cd8178813b3b52d0db5a419d30ba9495c4b9da0219fac6df8e7c23a811551a62b827f256ecdb8124ac8a6792ccfecc3b3012722e94463" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bb2039ec287091bcc9642fc90049e73732e02e577e2862b32216ae9bedcd730c4c284ef3968c368b7d37584f97bd4b4dc6ef6127acfe2e6ae2509124e66c8af4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f53d68d13f45edfcb9bd415e2831e938350d5380d3432278fc1c0c381fcb7c65c82dafe051d8c8b0d44e0974a0e59ec7bf7ed0459f86e96f329fc79752510fd3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8d568c7984f0ecdf7640fbc483b5d8c9f86634f6f43291841b309a350ab9c1137d24066b09da9944bac54d5bb6580d836047aac74ab724b887ebf93d4b32eca9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c0b65ce5a96ff774c456cac3b5f2c4cd359b4ff53ef93a3da0778be4900d1e8da1601e769e8f1b02d2a2f8c5b9fa10b44f1c186985468feeb008730283a6657d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4900bba6f5fb103ece8ec96ada13a5c3c85488e05551da6b6b33d988e611ec0fe2e3c2aa48ea6ae8986a3a231b223c5d27cec2eadde91ce07981ee652862d1e4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c7f5c37c7285f927f76443414d4357ff789647d7a005a5a787e03c346b57f49f21b64fa9cf4b7e45573e23049017567121a9c3d4b2b73ec5e9413577525db45a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ec7096330736fdb2d64b5653e7475da746c23a4613a82687a28062d3236364284ac01720ffb406cfe265c0df626a188c9e5963ace5d3d5bb363e32c38c2190a6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "82e744c75f4649ec52b80771a77d475a3bc091989556960e276a5f9ead92a03f718742cdcfeaee5cb85c44af198adc43a4a428f5f0c2ddb0be36059f06d7df73" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2834b7a7170f1f5b68559ab78c1050ec21c919740b784a9072f6e5d69f828d70c919c5039fb148e39e2c8a52118378b064ca8d5001cd10a5478387b966715ed6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "16b4ada883f72f853bb7ef253efcab0c3e2161687ad61543a0d2824f91c1f81347d86be709b16996e17f2dd486927b0288ad38d13063c4a9672c39397d3789b6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "78d048f3a69d8b54ae0ed63a573ae350d89f7c6cf1f3688930de899afa037697629b314e5cd303aa62feea72a25bf42b304b6c6bcb27fae21c16d925e1fbdac3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0f746a48749287ada77a82961f05a4da4abdb7d77b1220f836d09ec814359c0ec0239b8c7b9ff9e02f569d1b301ef67c4612d1de4f730f81c12c40cc063c5caa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f0fc859d3bd195fbdc2d591e4cdac15179ec0f1dc821c11df1f0c1d26e6260aaa65b79fafacafd7d3ad61e600f250905f5878c87452897647a35b995bcadc3a3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2620f687e8625f6a412460b42e2cef67634208ce10a0cbd4dff7044a41b7880077e9f8dc3b8d1216d3376a21e015b58fb279b521d83f9388c7382c8505590b9b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "227e3aed8d2cb10b918fcb04f9de3e6d0a57e08476d93759cd7b2ed54a1cbf0239c528fb04bbf288253e601d3bc38b21794afef90b17094a182cac557745e75f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1a929901b09c25f27d6b35be7b2f1c4745131fdebca7f3e2451926720434e0db6e74fd693ad29b777dc3355c592a361c4873b01133a57c2e3b7075cbdb86f4fc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5fd7968bc2fe34f220b5e3dc5af9571742d73b7d60819f2888b629072b96a9d8ab2d91b82d0a9aaba61bbd39958132fcc4257023d1eca591b3054e2dc81c8200" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dfcce8cf32870cc6a503eadafc87fd6f78918b9b4d0737db6810be996b5497e7e5cc80e312f61e71ff3e9624436073156403f735f56b0b01845c18f6caf772e6" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "02f7ef3a9ce0fff960f67032b296efca3061f4934d690749f2d01c35c81c14f39a67fa350bc8a0359bf1724bffc3bca6d7c7bba4791fd522a3ad353c02ec5aa8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "64be5c6aba65d594844ae78bb022e5bebe127fd6b6ffa5a13703855ab63b624dcd1a363f99203f632ec386f3ea767fc992e8ed9686586aa27555a8599d5b808f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f78585505c4eaa54a8b5be70a61e735e0ff97af944ddb3001e35d86c4e2199d976104b6ae31750a36a726ed285064f5981b503889fef822fcdc2898dddb7889a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e4b5566033869572edfd87479a5bb73c80e8759b91232879d96b1dda36c012076ee5a2ed7ae2de63ef8406a06aea82c188031b560beafb583fb3de9e57952a7e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e1b3e7ed867f6c9484a2a97f7715f25e25294e992e41f6a7c161ffc2adc6daaeb7113102d5e6090287fe6ad94ce5d6b739c6ca240b05c76fb73f25dd024bf935" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "85fd085fdc12a080983df07bd7012b0d402a0f4043fcb2775adf0bad174f9b08d1676e476985785c0a5dcc41dbff6d95ef4d66a3fbdc4a74b82ba52da0512b74" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aed8fa764b0fbff821e05233d2f7b0900ec44d826f95e93c343c1bc3ba5a24374b1d616e7e7aba453a0ada5e4fab5382409e0d42ce9c2bc7fb39a99c340c20f0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7ba3b2e297233522eeb343bd3ebcfd835a04007735e87f0ca300cbee6d416565162171581e4020ff4cf176450f1291ea2285cb9ebffe4c56660627685145051c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "de748bcf89ec88084721e16b85f30adb1a6134d664b5843569babc5bbd1a15ca9b61803c901a4fef32965a1749c9f3a4e243e173939dc5a8dc495c671ab52145" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aaf4d2bdf200a919706d9842dce16c98140d34bc433df320aba9bd429e549aa7a3397652a4d768277786cf993cde2338673ed2e6b66c961fefb82cd20c93338f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c408218968b788bf864f0997e6bc4c3dba68b276e2125a4843296052ff93bf5767b8cdce7131f0876430c1165fec6c4f47adaa4fd8bcfacef463b5d3d0fa61a0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "76d2d819c92bce55fa8e092ab1bf9b9eab237a25267986cacf2b8ee14d214d730dc9a5aa2d7b596e86a1fd8fa0804c77402d2fcd45083688b218b1cdfa0dcbcb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "72065ee4dd91c2d8509fa1fc28a37c7fc9fa7d5b3f8ad3d0d7a25626b57b1b44788d4caf806290425f9890a3a2a35a905ab4b37acfd0da6e4517b2525c9651e4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "64475dfe7600d7171bea0b394e27c9b00d8e74dd1e416a79473682ad3dfdbb706631558055cfc8a40e07bd015a4540dcdea15883cbbf31412df1de1cd4152b91" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "12cd1674a4488a5d7c2b3160d2e2c4b58371bedad793418d6f19c6ee385d70b3e06739369d4df910edb0b0a54cbff43d54544cd37ab3a06cfa0a3ddac8b66c89" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "60756966479dedc6dd4bcff8ea7d1d4ce4d4af2e7b097e32e3763518441147cc12b3c0ee6d2ecabf1198cec92e86a3616fba4f4e872f5825330adbb4c1dee444" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a7803bcb71bc1d0f4383dde1e0612e04f872b715ad30815c2249cf34abb8b024915cb2fc9f4e7cc4c8cfd45be2d5a91eab0941c7d270e2da4ca4a9f7ac68663a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b84ef6a7229a34a750d9a98ee2529871816b87fbe3bc45b45fa5ae82d5141540211165c3c5d7a7476ba5a4aa06d66476f0d9dc49a3f1ee72c3acabd498967414" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fae4b6d8efc3f8c8e64d001dabec3a21f544e82714745251b2b4b393f2f43e0da3d403c64db95a2cb6e23ebb7b9e94cdd5ddac54f07c4a61bd3cb10aa6f93b49" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "34f7286605a122369540141ded79b8957255da2d4155abbf5a8dbb89c8eb7ede8eeef1daa46dc29d751d045dc3b1d658bb64b80ff8589eddb3824b13da235a6b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3b3b48434be27b9eababba43bf6b35f14b30f6a88dc2e750c358470d6b3aa3c18e47db4017fa55106d8252f016371a00f5f8b070b74ba5f23cffc5511c9f09f0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ba289ebd6562c48c3e10a8ad6ce02e73433d1e93d7c9279d4d60a7e879ee11f441a000f48ed9f7c4ed87a45136d7dccdca482109c78a51062b3ba4044ada2469" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "022939e2386c5a37049856c850a2bb10a13dfea4212b4c732a8840a9ffa5faf54875c5448816b2785a007da8a8d2bc7d71a54e4e6571f10b600cbdb25d13ede3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e6fec19d89ce8717b1a087024670fe026f6c7cbda11caef959bb2d351bf856f8055d1c0ebdaaa9d1b17886fc2c562b5e99642fc064710c0d3488a02b5ed7f6fd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "94c96f02a8f576aca32ba61c2b206f907285d9299b83ac175c209a8d43d53bfe683dd1d83e7549cb906c28f59ab7c46f8751366a28c39dd5fe2693c9019666c8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "31a0cd215ebd2cb61de5b9edc91e6195e31c59a5648d5c9f737e125b2605708f2e325ab3381c8dce1a3e958886f1ecdc60318f882cfe20a24191352e617b0f21" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "91ab504a522dce78779f4c6c6ba2e6b6db5565c76d3e7e7c920caf7f757ef9db7c8fcf10e57f03379ea9bf75eb59895d96e149800b6aae01db778bb90afbc989" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d85cabc6bd5b1a01a5afd8c6734740da9fd1c1acc6db29bfc8a2e5b668b028b6b3154bfb8703fa3180251d589ad38040ceb707c4bad1b5343cb426b61eaa49c1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d62efbec2ca9c1f8bd66ce8b3f6a898cb3f7566ba6568c618ad1feb2b65b76c3ce1dd20f7395372faf28427f61c9278049cf0140df434f5633048c86b81e0399" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7c8fdc6175439e2c3db15bafa7fb06143a6a23bc90f449e79deef73c3d492a671715c193b6fea9f036050b946069856b897e08c00768f5ee5ddcf70b7cd6d0e0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "58602ee7468e6bc9df21bd51b23c005f72d6cb013f0a1b48cbec5eca299299f97f09f54a9a01483eaeb315a6478bad37ba47ca1347c7c8fc9e6695592c91d723" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "27f5b79ed256b050993d793496edf4807c1d85a7b0a67c9c4fa99860750b0ae66989670a8ffd7856d7ce411599e58c4d77b232a62bef64d15275be46a68235ff" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3957a976b9f1887bf004a8dca942c92d2b37ea52600f25e0c9bc5707d0279c00c6e85a839b0d2d8eb59c51d94788ebe62474a791cadf52cccf20f5070b6573fc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eaa2376d55380bf772ecca9cb0aa4668c95c707162fa86d518c8ce0ca9bf7362b9f2a0adc3ff59922df921b94567e81e452f6c1a07fc817cebe99604b3505d38" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c1e2c78b6b2734e2480ec550434cb5d613111adcc21d475545c3b1b7e6ff12444476e5c055132e2229dc0f807044bb919b1a5662dd38a9ee65e243a3911aed1a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8ab48713389dd0fcf9f965d3ce66b1e559a1f8c58741d67683cd971354f452e62d0207a65e436c5d5d8f8ee71c6abfe50e669004c302b31a7ea8311d4a916051" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "24ce0addaa4c65038bd1b1c0f1452a0b128777aabc94a29df2fd6c7e2f85f8ab9ac7eff516b0e0a825c84a24cfe492eaad0a6308e46dd42fe8333ab971bb30ca" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5154f929ee03045b6b0c0004fa778edee1d139893267cc84825ad7b36c63de32798e4a166d24686561354f63b00709a1364b3c241de3febf0754045897467cd4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e74e907920fd87bd5ad636dd11085e50ee70459c443e1ce5809af2bc2eba39f9e6d7128e0e3712c316da06f4705d78a4838e28121d4344a2c79c5e0db307a677" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bf91a22334bac20f3fd80663b3cd06c4e8802f30e6b59f90d3035cc9798a217ed5a31abbda7fa6842827bdf2a7a1c21f6fcfccbb54c6c52926f32da816269be1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d9d5c74be5121b0bd742f26bffb8c89f89171f3f934913492b0903c271bbe2b3395ef259669bef43b57f7fcc3027db01823f6baee66e4f9fead4d6726c741fce" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "50c8b8cf34cd879f80e2faab3230b0c0e1cc3e9dcadeb1b9d97ab923415dd9a1fe38addd5c11756c67990b256e95ad6d8f9fedce10bf1c90679cde0ecf1be347" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0a386e7cd5dd9b77a035e09fe6fee2c8ce61b5383c87ea43205059c5e4cd4f4408319bb0a82360f6a58e6c9ce3f487c446063bf813bc6ba535e17fc1826cfc91" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1f1459cb6b61cbac5f0efe8fc487538f42548987fcd56221cfa7beb22504769e792c45adfb1d6b3d60d7b749c8a75b0bdf14e8ea721b95dca538ca6e25711209" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e58b3836b7d8fedbb50ca5725c6571e74c0785e97821dab8b6298c10e4c079d4a6cdf22f0fedb55032925c16748115f01a105e77e00cee3d07924dc0d8f90659" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b929cc6505f020158672deda56d0db081a2ee34c00c1100029bdf8ea98034fa4bf3e8655ec697fe36f40553c5bb46801644a627d3342f4fc92b61f03290fb381" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "72d353994b49d3e03153929a1e4d4f188ee58ab9e72ee8e512f29bc773913819ce057ddd7002c0433ee0a16114e3d156dd2c4a7e80ee53378b8670f23e33ef56" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c70ef9bfd775d408176737a0736d68517ce1aaad7e81a93c8c1ed967ea214f56c8a377b1763e676615b60f3988241eae6eab9685a5124929d28188f29eab06f7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c230f0802679cb33822ef8b3b21bf7a9a28942092901d7dac3760300831026cf354c9232df3e084d9903130c601f63c1f4a4a4b8106e468cd443bbe5a734f45f" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6f43094cafb5ebf1f7a4937ec50f56a4c9da303cbb55ac1f27f1f1976cd96beda9464f0e7b9c54620b8a9fba983164b8be3578425a024f5fe199c36356b88972" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3745273f4c38225db2337381871a0c6aafd3af9b018c88aa02025850a5dc3a42a1a3e03e56cbf1b0876d63a441f1d2856a39b8801eb5af325201c415d65e97fe" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c50c44cca3ec3edaae779a7e179450ebdda2f97067c690aa6c5a4ac7c30139bb27c0df4db3220e63cb110d64f37ffe078db72653e2daacf93ae3f0a2d1a7eb2e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8aef263e385cbc61e19b28914243262af5afe8726af3ce39a79c27028cf3ecd3f8d2dfd9cfc9ad91b58f6f20778fd5f02894a3d91c7d57d1e4b866a7f364b6be" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "28696141de6e2d9bcb3235578a66166c1448d3e905a1b482d423be4bc5369bc8c74dae0acc9cc123e1d8ddce9f97917e8c019c552da32d39d2219b9abf0fa8c8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2fb9eb2085830181903a9dafe3db428ee15be7662224efd643371fb25646aee716e531eca69b2bdc8233f1a8081fa43da1500302975a77f42fa592136710e9dc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "66f9a7143f7a3314a669bf2e24bbb35014261d639f495b6c9c1f104fe8e320aca60d4550d69d52edbd5a3cdeb4014ae65b1d87aa770b69ae5c15f4330b0b0ad8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f4c4dd1d594c3565e3e25ca43dad82f62abea4835ed4cd811bcd975e46279828d44d4c62c3679f1b7f7b9dd4571d7b49557347b8c5460cbdc1bef690fb2a08c0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8f1dc9649c3a84551f8f6e91cac68242a43b1f8f328ee92280257387fa7559aa6db12e4aeadc2d26099178749c6864b357f3f83b2fb3efa8d2a8db056bed6bcc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3139c1a7f97afd1675d460ebbc07f2728aa150df849624511ee04b743ba0a833092f18c12dc91b4dd243f333402f59fe28abdbbbae301e7b659c7a26d5c0f979" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "06f94a2996158a819fe34c40de3cf0379fd9fb85b3e363ba3926a0e7d960e3f4c2e0c70c7ce0ccb2a64fc29869f6e7ab12bd4d3f14fce943279027e785fb5c29" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c29c399ef3eee8961e87565c1ce263925fc3d0ce267d13e48dd9e732ee67b0f69fad56401b0f10fcaac119201046cca28c5b14abdea3212ae65562f7f138db3d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4cec4c9df52eef05c3f6faaa9791bc7445937183224ecc37a1e58d0132d35617531d7e795f52af7b1eb9d147de1292d345fe341823f8e6bc1e5badca5c656108" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "898bfbae93b3e18d00697eab7d9704fa36ec339d076131cefdf30edbe8d9cc81c3a80b129659b163a323bab9793d4feed92d54dae966c77529764a09be88db45" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ee9bd0469d3aaf4f14035be48a2c3b84d9b4b1fff1d945e1f1c1d38980a951be197b25fe22c731f20aeacc930ba9c4a1f4762227617ad350fdabb4e80273a0f4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3d4d3113300581cd96acbf091c3d0f3c310138cd6979e6026cde623e2dd1b24d4a8638bed1073344783ad0649cc6305ccec04beb49f31c633088a99b65130267" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "95c0591ad91f921ac7be6d9ce37e0663ed8011c1cfd6d0162a5572e94368bac02024485e6a39854aa46fe38e97d6c6b1947cd272d86b06bb5b2f78b9b68d559d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "227b79ded368153bf46c0a3ca978bfdbef31f3024a5665842468490b0ff748ae04e7832ed4c9f49de9b1706709d623e5c8c15e3caecae8d5e433430ff72f20eb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5d34f3952f0105eef88ae8b64c6ce95ebfade0e02c69b08762a8712d2e4911ad3f941fc4034dc9b2e479fdbcd279b902faf5d838bb2e0c6495d372b5b7029813" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7f939bf8353abce49e77f14f3750af20b7b03902e1a1e7fb6aaf76d0259cd401a83190f15640e74f3e6c5a90e839c7821f6474757f75c7bf9002084ddc7a62dc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "062b61a2f9a33a71d7d0a06119644c70b0716a504de7e5e1be49bd7b86e7ed6817714f9f0fc313d06129597e9a2235ec8521de36f7290a90ccfc1ffa6d0aee29" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f29e01eeae64311eb7f1c6422f946bf7bea36379523e7b2bbaba7d1d34a22d5ea5f1c5a09d5ce1fe682cced9a4798d1a05b46cd72dff5c1b355440b2a2d476bc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ec38cd3bbab3ef35d7cb6d5c914298351d8a9dc97fcee051a8a02f58e3ed6184d0b7810a5615411ab1b95209c3c810114fdeb22452084e77f3f847c6dbaafe16" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c2aef5e0ca43e82641565b8cb943aa8ba53550caef793b6532fafad94b816082f0113a3ea2f63608ab40437ecc0f0229cb8fa224dcf1c478a67d9b64162b92d1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "15f534efff7105cd1c254d074e27d5898b89313b7d366dc2d7d87113fa7d53aae13f6dba487ad8103d5e854c91fdb6e1e74b2ef6d1431769c30767dde067a35c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "89acbca0b169897a0a2714c2df8c95b5b79cb69390142b7d6018bb3e3076b099b79a964152a9d912b1b86412b7e372e9cecad7f25d4cbab8a317be36492a67d7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e3c0739190ed849c9c962fd9dbb55e207e624fcac1eb417691515499eea8d8267b7e8f1287a63633af5011fde8c4ddf55bfdf722edf88831414f2cfaed59cb9a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8d6cf87c08380d2d1506eee46fd4222d21d8c04e585fbfd08269c98f702833a156326a0724656400ee09351d57b440175e2a5de93cc5f80db6daf83576cf75fa" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "da24bede383666d563eeed37f6319baf20d5c75d1635a6ba5ef4cfa1ac95487e96f8c08af600aab87c986ebad49fc70a58b4890b9c876e091016daf49e1d322e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f9d1d1b1e87ea7ae753a029750cc1cf3d0157d41805e245c5617bb934e732f0ae3180b78e05bfe76c7c3051e3e3ac78b9b50c05142657e1e03215d6ec7bfd0fc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "11b7bc1668032048aa43343de476395e814bbbc223678db951a1b03a021efac948cfbe215f97fe9a72a2f6bc039e3956bfa417c1a9f10d6d7ba5d3d32ff323e5" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b8d9000e4fc2b066edb91afee8e7eb0f24e3a201db8b6793c0608581e628ed0bcc4e5aa6787992a4bcc44e288093e63ee83abd0bc3ec6d0934a674a4da13838a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ce325e294f9b6719d6b61278276ae06a2564c03bb0b783fafe785bdf89c7d5acd83e78756d301b445699024eaeb77b54d477336ec2a4f332f2b3f88765ddb0c3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "29acc30e9603ae2fccf90bf97e6cc463ebe28c1b2f9b4b765e70537c25c702a29dcbfbf14c99c54345ba2b51f17b77b5f15db92bbad8fa95c471f5d070a137cc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3379cbaae562a87b4c0425550ffdd6bfe1203f0d666cc7ea095be407a5dfe61ee91441cd5154b3e53b4f5fb31ad4c7a9ad5c7af4ae679aa51a54003a54ca6b2d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3095a349d245708c7cf550118703d7302c27b60af5d4e67fc978f8a4e60953c7a04f92fcf41aee64321ccb707a895851552b1e37b00bc5e6b72fa5bcef9e3fff" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "07262d738b09321f4dbccec4bb26f48cb0f0ed246ce0b31b9a6e7bc683049f1f3e5545f28ce932dd985c5ab0f43bd6de0770560af329065ed2e49d34624c2cbb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b6405eca8ee3316c87061cc6ec18dba53e6c250c63ba1f3bae9e55dd3498036af08cd272aa24d713c6020d77ab2f3919af1a32f307420618ab97e73953994fb4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7ee682f63148ee45f6e5315da81e5c6e557c2c34641fc509c7a5701088c38a74756168e2cd8d351e88fd1a451f360a01f5b2580f9b5a2e8cfc138f3dd59a3ffc" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1d263c179d6b268f6fa016f3a4f29e943891125ed8593c81256059f5a7b44af2dcb2030d175c00e62ecaf7ee96682aa07ab20a611024a28532b1c25b86657902" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "106d132cbdb4cd2597812846e2bc1bf732fec5f0a5f65dbb39ec4e6dc64ab2ce6d24630d0f15a805c3540025d84afa98e36703c3dbee713e72dde8465bc1be7e" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0e79968226650667a8d862ea8da4891af56a4e3a8b6d1750e394f0dea76d640d85077bcec2cc86886e506751b4f6a5838f7f0b5fef765d9dc90dcdcbaf079f08" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "521156a82ab0c4e566e5844d5e31ad9aaf144bbd5a464fdca34dbd5717e8ff711d3ffebbfa085d67fe996a34f6d3e4e60b1396bf4b1610c263bdbb834d560816" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1aba88befc55bc25efbce02db8b9933e46f57661baeabeb21cc2574d2a518a3cba5dc5a38e49713440b25f9c744e75f6b85c9d8f4681f676160f6105357b8406" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5a9949fcb2c473cda968ac1b5d08566dc2d816d960f57e63b898fa701cf8ebd3f59b124d95bfbbedc5f1cf0e17d5eaed0c02c50b69d8a402cabcca4433b51fd4" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b0cead09807c672af2eb2b0f06dde46cf5370e15a4096b1a7d7cbb36ec31c205fbefca00b7a4162fa89fb4fb3eb78d79770c23f44e7206664ce3cd931c291e5d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bb6664931ec97044e45b2ae420ae1c551a8874bc937d08e969399c3964ebdba8346cdd5d09caafe4c28ba7ec788191ceca65ddd6f95f18583e040d0f30d0364d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "65bc770a5faa3792369803683e844b0be7ee96f29f6d6a35568006bd5590f9a4ef639b7a8061c7b0424b66b60ac34af3119905f33a9d8c3ae18382ca9b689900" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ea9b4dca333336aaf839a45c6eaa48b8cb4c7ddabffea4f643d6357ea6628a480a5b45f2b052c1b07d1fedca918b6f1139d80f74c24510dcbaa4be70eacc1b06" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e6342fb4a780ad975d0e24bce149989b91d360557e87994f6b457b895575cc02d0c15bad3ce7577f4c63927ff13f3e381ff7e72bdbe745324844a9d27e3f1c01" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3e209c9b33e8e461178ab46b1c64b49a07fb745f1c8bc95fbfb94c6b87c69516651b264ef980937fad41238b91ddc011a5dd777c7efd4494b4b6ecd3a9c22ac0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fd6a3d5b1875d80486d6e69694a56dbb04a99a4d051f15db2689776ba1c4882e6d462a603b7015dc9f4b7450f05394303b8652cfb404a266962c41bae6e18a94" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "951e27517e6bad9e4195fc8671dee3e7e9be69cee1422cb9fecfce0dba875f7b310b93ee3a3d558f941f635f668ff832d2c1d033c5e2f0997e4c66f147344e02" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8eba2f874f1ae84041903c7c4253c82292530fc8509550bfdc34c95c7e2889d5650b0ad8cb988e5c4894cb87fbfbb19612ea93ccc4c5cad17158b9763464b492" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "16f712eaa1b7c6354719a8e7dbdfaf55e4063a4d277d947550019b38dfb564830911057d50506136e2394c3b28945cc964967d54e3000c2181626cfb9b73efd2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c39639e7d5c7fb8cdd0fd3e6a52096039437122f21c78f1679cea9d78a734c56ecbeb28654b4f18e342c331f6f7229ec4b4bc281b2d80a6eb50043f31796c88c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "72d081af99f8a173dcc9a0ac4eb3557405639a29084b54a40172912a2f8a395129d5536f0918e902f9e8fa6000995f4168ddc5f893011be6a0dbc9b8a1a3f5bb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c11aa81e5efd24d5fc27ee586cfd8847fbb0e27601ccece5ecca0198e3c7765393bb74457c7e7a27eb9170350e1fb53857177506be3e762cc0f14d8c3afe9077" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c28f2150b452e6c0c424bcde6f8d72007f9310fed7f2f87de0dbb64f4479d6c1441ba66f44b2accee61609177ed340128b407ecec7c64bbe50d63d22d8627727" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f63d88122877ec30b8c8b00d22e89000a966426112bd44166e2f525b769ccbe9b286d437a0129130dde1a86c43e04bedb594e671d98283afe64ce331de9828fd" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "348b0532880b88a6614a8d7408c3f913357fbb60e995c60205be9139e74998aede7f4581e42f6b52698f7fa1219708c14498067fd1e09502de83a77dd281150c" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5133dc8bef725359dff59792d85eaf75b7e1dcd1978b01c35b1b85fcebc63388ad99a17b6346a217dc1a9622ebd122ecf6913c4d31a6b52a695b86af00d741a0" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2753c4c0e98ecad806e88780ec27fccd0f5c1ab547f9e4bf1659d192c23aa2cc971b58b6802580baef8adc3b776ef7086b2545c2987f348ee3719cdef258c403" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b1663573ce4b9d8caefc865012f3e39714b9898a5da6ce17c25a6a47931a9ddb9bbe98adaa553beed436e89578455416c2a52a525cf2862b8d1d49a2531b7391" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "64f58bd6bfc856f5e873b2a2956ea0eda0d6db0da39c8c7fc67c9f9feefcff3072cdf9e6ea37f69a44f0c61aa0da3693c2db5b54960c0281a088151db42b11e8" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0764c7be28125d9065c4b98a69d60aede703547c66a12e17e1c618994132f5ef82482c1e3fe3146cc65376cc109f0138ed9a80e49f1f3c7d610d2f2432f20605" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f748784398a2ff03ebeb07e155e66116a839741a336e32da71ec696001f0ad1b25cd48c69cfca7265eca1dd71904a0ce748ac4124f3571076dfa7116a9cf00e9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3f0dbc0186bceb6b785ba78d2a2a013c910be157bdaffae81bb6663b1a73722f7f1228795f3ecada87cf6ef0078474af73f31eca0cc200ed975b6893f761cb6d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d4762cd4599876ca75b2b8fe249944dbd27ace741fdab93616cbc6e425460feb51d4e7adcc38180e7fc47c89024a7f56191adb878dfde4ead62223f5a2610efe" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cd36b3d5b4c91b90fcbba79513cfee1907d8645a162afd0cd4cf4192d4a5f4c892183a8eacdb2b6b6a9d9aa8c11ac1b261b380dbee24ca468f1bfd043c58eefe" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "98593452281661a53c48a9d8cd790826c1a1ce567738053d0bee4a91a3d5bd92eefdbabebe3204f2031ca5f781bda99ef5d8ae56e5b04a9e1ecd21b0eb05d3e1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "771f57dd2775ccdab55921d3e8e30ccf484d61fe1c1b9c2ae819d0fb2a12fab9be70c4a7a138da84e8280435daade5bbe66af0836a154f817fb17f3397e725a3" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c60897c6f828e21f16fbb5f15b323f87b6c8955eabf1d38061f707f608abdd993fac3070633e286cf8339ce295dd352df4b4b40b2f29da1dd50b3a05d079e6bb" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8210cd2c2d3b135c2cf07fa0d1433cd771f325d075c6469d9c7f1ba0943cd4ab09808cabf4acb9ce5bb88b498929b4b847f681ad2c490d042db2aec94214b06b" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1d4edfffd8fd80f7e4107840fa3aa31e32598491e4af7013c197a65b7f36dd3ac4b478456111cd4309d9243510782fa31b7c4c95fa951520d020eb7e5c36e4ef" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "af8e6e91fab46ce4873e1a50a8ef448cc29121f7f74deef34a71ef89cc00d9274bc6c2454bbb3230d8b2ec94c62b1dec85f3593bfa30ea6f7a44d7c09465a253" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "29fd384ed4906f2d13aa9fe7af905990938bed807f1832454a372ab412eea1f5625a1fcc9ac8343b7c67c5aba6e0b1cc4644654913692c6b39eb9187ceacd3ec" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a268c7885d9874a51c44dffed8ea53e94f78456e0b2ed99ff5a3924760813826d960a15edbedbb5de5226ba4b074e71b05c55b9756bb79e55c02754c2c7b6c8a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0cf8545488d56a86817cd7ecb10f7116b7ea530a45b6ea497b6c72c997e09e3d0da8698f46bb006fc977c2cd3d1177463ac9057fdd1662c85d0c126443c10473" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b39614268fdd8781515e2cfebf89b4d5402bab10c226e6344e6b9ae000fb0d6c79cb2f3ec80e80eaeb1980d2f8698916bd2e9f747236655116649cd3ca23a837" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "74bef092fc6f1e5dba3663a3fb003b2a5ba257496536d99f62b9d73f8f9eb3ce9ff3eec709eb883655ec9eb896b9128f2afc89cf7d1ab58a72f4a3bf034d2b4a" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3a988d38d75611f3ef38b8774980b33e573b6c57bee0469ba5eed9b44f29945e7347967fba2c162e1c3be7f310f2f75ee2381e7bfd6b3f0baea8d95dfb1dafb1" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "58aedfce6f67ddc85a28c992f1c0bd0969f041e66f1ee88020a125cbfcfebcd61709c9c4eba192c15e69f020d462486019fa8dea0cd7a42921a19d2fe546d43d" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9347bd291473e6b4e368437b8e561e065f649a6d8ada479ad09b1999a8f26b91cf6120fd3bfe014e83f23acfa4c0ad7b3712b2c3c0733270663112ccd9285cd9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b32163e7c5dbb5f51fdc11d2eac875efbbcb7e7699090a7e7ff8a8d50795af5d74d9ff98543ef8cdf89ac13d0485278756e0ef00c817745661e1d59fe38e7537" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1085d78307b1c4b008c57a2e7e5b234658a0a82e4ff1e4aaac72b312fda0fe27d233bc5b10e9cc17fdc7697b540c7d95eb215a19a1a0e20e1abfa126efd568c7" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4e5c734c7dde011d83eac2b7347b373594f92d7091b9ca34cb9c6f39bdf5a8d2f134379e16d822f6522170ccf2ddd55c84b9e6c64fc927ac4cf8dfb2a17701f2" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "695d83bd990a1117b3d0ce06cc888027d12a054c2677fd82f0d4fbfc93575523e7991a5e35a3752e9b70ce62992e268a877744cdd435f5f130869c9a2074b338" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a6213743568e3b3158b9184301f3690847554c68457cb40fc9a4b8cfd8d4a118c301a07737aeda0f929c68913c5f51c80394f53bff1c3e83b2e40ca97eba9e15" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d444bfa2362a96df213d070e33fa841f51334e4e76866b8139e8af3bb3398be2dfaddcbc56b9146de9f68118dc5829e74b0c28d7711907b121f9161cb92b69a9" +}, +{ + "hash": "blake2b", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "142709d62e28fcccd0af97fad0f8465b971e82201dc51070faa0372aa43e92484be1c1e73ba10906d5d1853db6a4106e0a7bf9800d373d6dee2d46d62ef2a461" +}, +{ + "hash": "blake2sp", + "in": "", + "key": "", + "out": "dd0e891776933f43c7d032b08a917e25741f8aa9a12c12e1cac8801500f2ca4f" +}, +{ + "hash": "blake2sp", + "in": "00", + "key": "", + "out": "a6b9eecc25227ad788c99d3f236debc8da408849e9a5178978727a81457f7239" +}, +{ + "hash": "blake2sp", + "in": "0001", + "key": "", + "out": "dacadece7a8e6bf3abfe324ca695436984b8195d29f6bbd896e41e18e21c9145" +}, +{ + "hash": "blake2sp", + "in": "000102", + "key": "", + "out": "ed14413b40da689f1f7fed2b08dff45b8092db5ec2c3610e02724d202f423c46" +}, +{ + "hash": "blake2sp", + "in": "00010203", + "key": "", + "out": "9b8a527b5272250a1ec397388f040914954806e794db04b70a4611bc59586a83" +}, +{ + "hash": "blake2sp", + "in": "0001020304", + "key": "", + "out": "2bb6333729000be3d5a21b98f8e7ead077f151a5393919eb67c876ee00bbbb04" +}, +{ + "hash": "blake2sp", + "in": "000102030405", + "key": "", + "out": "63c01408154ad19d7fb739f311781780462cf2eecce60f064e853487c272e3eb" +}, +{ + "hash": "blake2sp", + "in": "00010203040506", + "key": "", + "out": "3d051a1176019ca37bf33d60427f8d9d1c3abd598297cfb4235f747d7c7c7fec" +}, +{ + "hash": "blake2sp", + "in": "0001020304050607", + "key": "", + "out": "391ea912df4d4d79a4646d9da2549a446d2240f62415d070a2e093992b471fba" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708", + "key": "", + "out": "324640440ea5c3082ddc309e7809d741d6cc1b2d490ff8c052128a6eeb409d62" +}, +{ + "hash": "blake2sp", + "in": "00010203040506070809", + "key": "", + "out": "ab855e6fa39a5e8fc90eacb999c7f78ae71e59c3d97d60afe517d587923b7711" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a", + "key": "", + "out": "2a39da4586efc47785a7a8da85683a51724cdef5413b356dc4fb500513f8fa2e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b", + "key": "", + "out": "8a0057c1f78ad6214555c0670733e29a4c7e956227660efeb1d7fc79f58ec6f2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c", + "key": "", + "out": "0764b0017f5bd951f01d9fdf95c0cb4138985d84799cd42984e25b512800e73c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d", + "key": "", + "out": "cc02495693c8e184ad2ed09d533dc33b76a7783d6207fcaccb64f3ed2c6d66e0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e", + "key": "", + "out": "c0df49c206a34288143216847df334d4569dad73c2b1ff6284884fd38941fb95" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "", + "out": "b9194519e4978a9dc893b28bd808cdfabb1bd510d862b3171ff6e017a41b804c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "", + "out": "bba927acf11bebd362a3a3eb78c4bb65e602a8709fcef38dc6c8b7bda664c32c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "", + "out": "ecb4900a63924e720d40f2d2b14d1bb39c3701ad7346bd0b67234270bfbe7e70" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "", + "out": "f8315a21b25e6ba8bf59b17b05913b8ca4659f1cd838fcc773c9eb12e7004e09" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "", + "out": "4b77af67a9232bf1184e57818294031e55f1f853c94dbab5577547330d65aa61" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "", + "out": "768568390fd2b87094114ed4cf723ea320fe977b53180305c384335479f0b59b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "", + "out": "a431cb270f3e2c9b7a9593b155ccecff5b5c4a2dcd5d6bb1c485aa286997f915" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "", + "out": "d691fa6a790b1a517980087f50b03ded8c6ed486d084221c827d9bd922beb8c0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "", + "out": "8f978a4932f4459813e8fe15686e4efa25c2c5ff5a3a4f8c9b14965d2f0be461" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "", + "out": "1efbd0c131449142f2295f2d42411dfe0f48d4acae762d8df67a570bf7b1dcd5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "", + "out": "d53ba93346143ab8e0d3d1bf272706d169e66c69c7b8f4a5e82fef440702bcf2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "", + "out": "f71a3ec01aa382ea76992b430a7f42c7ad2a86aea9c19e76cd1732ec6830de6f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "", + "out": "80a6ab7b710464f93e6cba96864aa6409bcafc1bf4b32a309372e857e804068c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "", + "out": "dbde81e51a52174b1014901b53bef88de93b29e274347e8e9a7b037456629f35" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "", + "out": "75f274466b1a2d0fd845bbb57c38c989516e1568320ab517b163eaf709234cc7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "", + "out": "afe1a0591c491d416eb64f6286f3ba29d4c9998214a3831c39014ac030557945" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "", + "out": "67ff6acdbe8a99a166a5d9cf32136506b548d6c947c24c699cea3afd92adfaca" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "", + "out": "bfb4d0c7112075262c2dd248f334b2ef1540087ecc7382bc2a272575c5009f70" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "", + "out": "17c94b9c537243f2335b863949b2b91c98a6956d7c10aa989959a80f910c2522" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "", + "out": "f6338f434d319410196d9519abcaeff7d55439fd2aa5babf7a7e7913b294ed4d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "", + "out": "08ef7d65f9bbf3da1f7884ae9b75901fd85295662a6ea71de08bee3834576278" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "", + "out": "1647ecc2ba13f8b93b2fbcdc4e8f1dfa47fe3be12aaa0e459b0e5a87f3a69bb0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "", + "out": "ff927a717881f6fd8ed8bf5d5e35bd80161573e5829404c32d2a276a01f4b906" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "", + "out": "c8caf136ff209c82e0240c1e62a3bc7e9cac873b011cf7c5e67ec187a5fbcd96" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "", + "out": "d9acc73e3f421e1883b5ed53d82a9aec8f5dc980c42bcaeb0e7d8976a338ef51" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "", + "out": "9f173fcf08a5362193f352c8256ae534ae9ce7bfa4bc09fac90098f98a716294" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "", + "out": "0a724579dc80bc0c9004e51be7eff3afa53075ab4a32557733586e820fd36423" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "", + "out": "38f7c340f4b159b1e594f6eb83284917b7aa19c74f57117a4e08cf7c4e32a23c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "", + "out": "1c674be257e9b33134d4168f152f8b63dfd780c97dc4dc37ac26cc0aefb79c1a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "", + "out": "2f0c597616d5751714a5fb4ebf3c481a96c3ad145ebde06509f3a2e5f2c13fc8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "", + "out": "fddc69e0c983cd8283ed8188bec4e5f41dea3d01b9e74c4baf7341d8b4bf553d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "", + "out": "24d083cba038c87e9acb8681820208b75cb3293a96c9efa75d2c63f16b85fe1e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "", + "out": "7f6a649cca89b253ffbd20c016980100a87c168109628fcc66525d8baafe505f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "", + "out": "6da373b4c18792b3209add15a5074a1d70c10bb39480ca3fe5c439d95fc286ca" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "", + "out": "270affa6426f1a515c9b76dfc27d181fc2fd57d082a3ba2c1eef071533a6dfb7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "", + "out": "c22e15cfc5a3d14b64d131f35fb35dd5e6c57dc4afc552277501eca764da74bf" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "", + "out": "ad683e96b8ac658c4f3f10ad22d99b07cb5ef9e31cbe11e7f7dc29f2aee5024c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "", + "out": "78d3ceda1ce05293f430f6167b33c99f0b1d6dade52143c2925577c0ba8253eb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "", + "out": "e006456344f90f501c25813f9be2a3f40b9874fa0563981cd456ee8d44807c93" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "", + "out": "3908e8d547c0afb1134949466304a145027e6bb7a74dd1c162cdf0bcf77237e8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "", + "out": "1b6c87a34838c7cd5fd08914224e90c22abf5a97b10646d98c4916d3a8939e62" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "", + "out": "b0d38f82f248916952b316b6d36d9e022df6eecc26c762a655cf5f0ae649e2bd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "", + "out": "8d66fc9ceda5eddfb1e04d096ca70ef50650fb87cc6a9ffbb3d20bce7b5a6074" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "", + "out": "064354e8e11cf713b2c72ba67ac7d76e41ba61db9c2dea522e0bda17cba5e392" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "", + "out": "c8ef5f498bd1bc707fbc7b5cbc2dff0493144ac52786db3c793ef4ae8a838847" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "", + "out": "8a2397df31e7f0cc290da9a8bbe4f5f7a3a13750730db62dc2540fdbd6188589" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "", + "out": "f12d0b13c6adfb3be50a51eb6baf65abfb1700baa87e527dbe3e675a7a994661" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "", + "out": "1024c940be7341449b5010522b509f65bbdc1287b455c2bb7f72b2c92fd0d189" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "", + "out": "52603b6cbfad4966cb044cb267568385cf35f21e6c45cf30aed19832cb51e9f5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "", + "out": "fff24d3cc729d395daf978b0157306cb495797e6c8dca1731d2f6f81b849baae" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "", + "out": "41eee90d47ec2772cd352dfd67e0605fbdfc5fd6d826451e3d064d3828bd3bae" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "", + "out": "300b6b36e59f851dddc29bfa93082520cd77c51e007e00d2d78b26f4af961532" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "", + "out": "9ef30314834e401c871a2004e38d5ce32ed28e1137f1970f4f4378c73706763d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "", + "out": "3fbdcde7b64304025ec0582609031ec266d50f56835ae0cb72d8cdb4cfaf4419" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "", + "out": "e90ead3b982b435b66366a496c3f8ae65b17613700f547673f62153541912864" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "", + "out": "abe3547b336d6e240d7fe682d74b9cc7e8d7f9b5664858b94df59e9fc330d9e5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "", + "out": "b299642095b8286c521cdb21ed0fe057278021bb4038eb5a3d79542f5d751f54" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "", + "out": "e4d758359f086793a83754aca6968c3e9fd94b40497f2ec224a2916063a214a3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "", + "out": "59a304fc03ab75d557db04ebd02dd4c6b810a138bbfeea5dfceeaa2b75b06491" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "", + "out": "3995102215f5fe9210eb30d952d8c919589e7145fcd495ea78d02b9c148faf09" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "", + "out": "472ee711563506a5f0083fe82b08b9923cf6c8404d0cbacbf84864f648542ac0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "", + "out": "68fdb82adae79bef590aba62d7ac553212061c36e36f12c0efa29a1762de3b6a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "", + "out": "7585c0773383f174fd666549a8352b305bf6855bc98bea28c391b3c034da5a5a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "", + "out": "acc575fe2cd7ba2a31fc7d670a9234af68503386e959073d16a81b33b922b50e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "", + "out": "9ec7d2995943d39d6b971493b897a0ee2d3392a72db875c2405d357178fb6911" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "", + "out": "2d7ef19401425aba450e82d36d0fe7b2085ea0af6045a5994cf431ea59939cc9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "", + "out": "f32fd855f011c718027f2ebe377d6939f12370caff151c1e5ace438d703c6d9f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "", + "out": "b2bd83d2310d3d7b1d2d5aaf4359fae28612962719fdde4ddaf69e7820f33f61" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "", + "out": "1a7a9d0f44ddfa7fc2f4770cad7422fa6c4e37e6cb036d899e102750e594ffcd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "", + "out": "dc69f6141c8e103ff61f6298a2c44f52d147366ddbd9c79cc308fe84336a9564" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "", + "out": "e34ed417b0791d9a77ee1e50cc2c207e540c77140421c46ce0862878aaeb2709" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "", + "out": "2174425c8ccae398c4ff06f848991c5e9bc0f3461111706fb95d0be1c68e4760" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "", + "out": "1894582a8a25fe8f847a4a032574b77b8b36bf19997526bb4bc85f3824537feb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "", + "out": "17ed188ae3c953d655445983b8325bafff32e222b2dfeb16e8617abf86ee7cc5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "", + "out": "f1489ad1c354cde9789237ea6dbf67fc1e44d1acc8dc66ad838727f47d9a91fe" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "", + "out": "367f22165b8b66e97f6670f34eba2749d2643b21beadadfefea2574b7c9b2196" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "", + "out": "3d8dfea17eea5d645ac1d41a5b59226c486c36bd77ed44bb349170d080e30e68" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "", + "out": "4115f89e0b3b5c8f6122c02500171dcffbcea4662a8c5f8c1c01a9ca7b1027bb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "", + "out": "ed6e910b960255d7d792ebe67f260a143cfac1051dfc059025ee0c1bfcbc5681" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "", + "out": "558fa8afa12bbee54af78f6b7445f99665d4e356bc07d3effd8fd65ab9c74716" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "", + "out": "5b6012762053b8734af0e555e6a2bb4fd4840af3b04fcf6350a2b8a51b6796ad" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "", + "out": "ab7acca5d77710bad37ba0ff4ceae27e847179f7fd7aec8869c649b33f8d2577" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "", + "out": "ff7730b474ec2145a92dd1cffe45c342c6fd6bac580ff95a75eda3bf90eb4f01" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "", + "out": "d10f061d5b9cb44ee078a96b3318579e5ef50aef3ed96e4f62149b2e9f7c660c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "", + "out": "67d22b8edf2001d86422136ac6516cf39f7fc6a7029892fd75c98790964a720b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "", + "out": "7a5ec5ba76259b07b4da03f381fe7bea4865c86c424abaa0dd1ecf74f87d2ac0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "", + "out": "e0ff60d69029e6bd1c15953e91509c0c59ed5da5000199f216d29f96079c2fef" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "", + "out": "fc13ead841018f59903b40f2020c6638a66a54c3a338414d97a5c394f3266f33" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "", + "out": "0c2f62b898fb2f63617e787345263cb9cf60654b553b203ee49dcbb8f2a6afac" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "", + "out": "d7d6cb552aeb36eb96b1d5e052f8d921c3245a970d0bc8410cd65ea104c8e779" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "", + "out": "b7141f305efdfee556bd13e0400d1e8cfd6548bf81ee5d15327e4995ca8ad6fd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "", + "out": "b6b638d22b7a12825374f70348d7448d4e7d908cf6e7bbef8c93ef679b2a5478" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "", + "out": "0df4585641fa09f6cba4cc165a10adde34f80d425a70db67e2fd237b627f438a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "", + "out": "106b2b354d95acecd0d9588fbc231f8bea2e94ea662ddd3f139e1b6787461eed" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "", + "out": "ae5c69eefe9089b29c6c1a2370d20552ba40c3d5e3713c12defcae997f433ecd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "", + "out": "1aaef55d4fa892b635fb2a7a25f9a8e03b9ffb082ae9c07c2042a049c6515e45" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "", + "out": "297daac4d54dc41c83e32394599f171cdaa9ddb71726da4ece3ccf95c11f56df" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "", + "out": "2c45acf491ec2f4b7e309e7edd815be5a54c4458d1a57c4f9b763b0c6718d43e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "", + "out": "2f92f90170d3ae95abfac3a6989a2a60cb28b858782be7ea179b48a7276dd860" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "", + "out": "b401e84b15acc470936d6e37f7888333092731133b251bea221658ca19a75669" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "", + "out": "f8b340d2b9b33d43a0a66f3497820afaaee434c4e3c0c17e898b8301c57a26bd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "", + "out": "566da283990389138aa6f2aaa3b9e40cbf90840ec762bd96b7e33a3113b10108" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "", + "out": "340672b704676042c9bf3f337ba79f11336aebb5ec5d31df54eb6ad3b0430442" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "", + "out": "5050b73b9316eea2f149bffd22aee384dc5403b18e16fa88825e181609496fd2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "", + "out": "1365cc6fb9260e86889b3afbd1c8bc12923197715db266cc7a01ca57159f7596" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "", + "out": "29466f51c011fd10181494a9379b6159b808ae0fcb0161f8f07909ff041b1965" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "", + "out": "6591a3c3c767b38d805ed3f7eb6763e8b3d2d642e7307745cd3418eff69a19ed" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "", + "out": "1d84b04b1338b0d2e3c98f7aea3e98effc530a5044b93b96c67ee379d62e815f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "", + "out": "6fa295272532e983e166b12e4999c052f89d9f30ae1481f3d60eae85f8ee178a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "", + "out": "4ed8caa98ec39f6a629f9a654a447e7e3e4faeecf34dcf658d2d4b98b7a2ec1a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "", + "out": "cfab8299a0da0c2a7e8ff54d0a676d141ab26bc0012e5f668e85d814bc9888b0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "", + "out": "a626543c271fccc3e4450b48d66bc9cbdeb25e5d077a6213cd90cbbd0fd22076" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "", + "out": "05cf3a90049116dc60efc31536aaa3d167762994892876dcb7ef3fbecd7449c0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "", + "out": "ccd61c926cc1e5e9128c021c0c6e92aefc4ffbde394dd6f3b7d87a8ced896014" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "", + "out": "3ffa4f6dafa57f1c50f1afa4f81292ae71a06fe4f8ff46c51d32ff2613489f2b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "", + "out": "19d3921cfc0f1a2bb813b3dfa96df90e2c6b87d78e9238f85bbc77ae9a73f98f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "", + "out": "f5c916ff2badde3e29a5f940233ea34007d8f182a48a808b46bb8058003f1903" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "", + "out": "6ba07a1af758e682d3e09add2d3dcdf35d9553f6799854a27e536063c57f81a5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "", + "out": "b78378fb446c544b04d4a152ac49573161b3ddebf69386770a55a7d47b880e5d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "", + "out": "b519538fe1626f0c595945ada58a344faac0061761cc9d4a841419bd32eec0d9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "", + "out": "96e488b027896413f4034b0354f48484f6cfc10f8ec57b026fd21a3b88361a74" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "", + "out": "770c8a5f47bfd769ced35a71afc3ca1ff4c1f1e7cc3d2356de945004368d8145" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "", + "out": "6df9d8d0d3a8d98c8350d7162bd15579d5707add7611a00eeb6ca5743ed78cb7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "", + "out": "4f0fe8fc17901591cf348730e187de523d6d7568c1fbd82485913985eb67971c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "", + "out": "0ef3bb35cf372bd94e3f80eecebd50ef0d0308e01e0ed6de0f5a8a8c818a0074" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "", + "out": "c038d3e809a5e3a58db2f91c15ae12439578f75485cd84f556c6971e8e250620" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "", + "out": "ce399a0f08277d8d4816095060ebbf33da016fb43a6c356d5a3fe4bb574c5e7b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "", + "out": "869f7e316b194f9531bcaf33f7913f1b9cfc6bb5dcf86b692bf8cab29b8aa96f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "", + "out": "327dfa464459d9e48f5e55c7f5baa68fc4a25ad622bc7bf01aca82fd5e72314c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "", + "out": "e00dad3151b9085eae786984fe20735232b7ff7f1b1db7961fd0d0e0f605db9a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "", + "out": "076f644520d0b4732d6c531c9349089026936d99820461da87749a520fbe90ce" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "", + "out": "b4414ca1373be46f15cea6b1255a7d1886c6fdb08ed5af9657d5aac317de3a29" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "", + "out": "8d1ab0263dab7b86ecee219162d999a01245572269de31100e5d88fc1b1eaa69" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "", + "out": "b48d1c1f83924a02a23e5e0f971e16e87fc4884853833485191a2b60722fe269" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "", + "out": "f2edd5f750a20a541d3f6bd5df80838f11825b25a98f3da5e1523bff813bb560" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "", + "out": "07166004ef88e1614ebdc887dfc7da42ebcda02d92c12f18d1186ce3c98710e4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "", + "out": "69f83aa101d69b8f1220dc1c538d8934458420be335feb46ffc47a2c8e2e6a8a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "", + "out": "e1469f16c6fca15119a272e585c7f50421bc8a414c864fc76b01048d4c6fc5d2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "", + "out": "6763343a1c80f19283a80af854e7e9065c2a8349ef11f11bfb76ba9f97048539" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "", + "out": "1ae3a0b8b2c7885ba318ad6fd449fc4d7f8404b59cf3275fcdea13563425772d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "", + "out": "3a71184cbe8eb58e6812ba7a7a1dca0ca28eec63782f2e6e3c0b87073f533ffd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "", + "out": "184ccf2a52f388c9f897a857fe7ccec2959911a8d1e09ee8804d8d5d508dd918" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "", + "out": "a66d409af7afd75be831dd498c196ef12c73c31129ec02d5f12ab02a2c63a25e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "", + "out": "58b37497fcf0be0e0cf1734045c295b286c76a7c048e87c54028ed36915b5df3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "", + "out": "2c7333540a832d64456e43058c50d93c932ad9b18b3fc3a0599207cda3b3c7a6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "", + "out": "3dc062ffb57d835fe3aa409466822f9186918423947505165fdcdfb7306f7259" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "", + "out": "89204844acb92f353bfc89a3ce8a9817219c101385c593cf60e0befa9638e14e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "", + "out": "782ba902e91232941c78c49cd9771a5d9992f9b07d9c0a2df82d385d15c42bb3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "", + "out": "0dc3ff7df0dfc023763d7634e18da27393fc9fdb1c154646861075f0a87d0e90" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "", + "out": "b95c65fb6f254edbde8c037d5c8b2039340f4ac2b023a6aa28a8fcd2d2689cf4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "", + "out": "87e8f51572a5d6a239f85bc53e1174e15be12fcdf151a0b9a2b43640caf74c1d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "", + "out": "2a6f3e462c405c354fe80fccced1c9be44325d29e07da30960b625a76ea42f83" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "", + "out": "20b46c8fbfca97453262460f8498a7e2af15ac79b59ddfb027bb52f2d68e8f51" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "", + "out": "31b0763cb9ba92403dca1abdd7342d7de94c581e76f7c9a61e515928e10b4e77" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "", + "out": "e191e117063cfac9642cd93cb42b39eddd9e4ab65f1d0397e3e17dd04cab1180" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "", + "out": "225a202107a74703e041c6cca4eacf4f21eea6f22a146d8da2ab8cf6197229a5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "", + "out": "efc4836be4ac3e9791d2ec62226e7df64118f4565c19e6c9e84063f5661c7b2f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "", + "out": "3a76b0152c0e1d1fd7ac9d91a28a18e1a4c06080f2b7ecefb6effe28b8cfc765" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "", + "out": "0d46ad039070115828f94eb6b72963e60a7d2db7ca8991d225c3877b149b0a8a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "", + "out": "e44cfc42118f096bfc51521cb18d5d6525586b989f4ee2b828c5199feab94b82" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "", + "out": "6d4bd2e073ec4966847f5cbe88ddfaba2be4caf2f333552b8553da533487c25b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "", + "out": "bbc46db437d107c967ca6d91455bbdfe052118abd1d069f04359487e13aea0e1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "", + "out": "b974c14db7d3174dd06084bb303108b2f0daf50eccc3293543795c9636c62482" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "", + "out": "0eee235b06936aed7173c8c19aa7c217b9eedaeb1a88f30552e9225145149e82" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "", + "out": "36d089e025b5686937742825e6ee3d83e7d7a50c823c82883460f385147dc17b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "", + "out": "77ee4ffc9f5dd605470dc0e74d6b17c5130d8b73913f36d5f8787e619a947ca0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "", + "out": "0fe6c2ab754233360d68b9ac80cd61184bfaa7d356294180025fe40639c76c36" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "", + "out": "996088c79456ecdda1fbc02ee1ba42d91d858c310a5a8b4674fe6a7c144414a1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "", + "out": "9e338aed0bc71c0c97f19855bf49174f70a9d77014873663213427502bd85d9f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "", + "out": "4a843d26adec520e4b5dbf0145cc4f5024fafcdc2025824a8c64650617687ee7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "", + "out": "c91678c4a64e2fa4b74de61ad0c06ff06b5d672fa7c6877a4014ce9e91be38d7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "", + "out": "ff7777405d327adb58301c711ecdc2bce1bfa829ffc9b117f21a2b198d0d6884" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "", + "out": "0a8ddaf1728c5cd93a255d5623c3dada2d3d0571bf1438adc8c964a9aad118cb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "", + "out": "c133abbd0d2d808a67b6745b4b3650b4a64dc276cf98e30357b6abd5c1d22a9b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "", + "out": "c59ee5c196ba3cfef94087798207bdcef139ce2cf78dced6198f0fa3a409131c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "", + "out": "c7fdade59c4699385eba59e756c2b171b023deae082e5a6e3bfbdc1073a32003" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "", + "out": "975327c5f4dec6414b6e00cb042337b8d2a6564637a7442aec7be8f8c89a2f1c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "", + "out": "a2f7246df4a24efbacd3fd60683abc868bef25327052cf2f1d93ece4ffcd73c6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "", + "out": "497fb2acacf123f3595e40fc51a7bd24458bbcba4a2940a5cb03d608fbdf2825" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "", + "out": "0e97d22793ce6f283d5c740d308a27ad7c3b0d9afcd3d9e9b9cac56b10290c8f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "", + "out": "6630b35618e700d910683893795ef70bf07eb156f55ffe3b69ad88a4b8b0bfa1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "", + "out": "02f742c6e95278121a05e44205444fc5ea6af5e741c535bc2cbc3b235a2ea2b0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "", + "out": "4622f36eb898383f60d5bed809ac5c4745c5d6ab84bcadf79cf2a96d4ec88818" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "", + "out": "ccd11faaa0581ec32c3a403f92ef43d5dcf195c1a101dbfd495dbb4dce8069e0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "", + "out": "06024d6b07e000bce613470a2880519b8be4a36bf33c99c917893ec75dd90fe3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "", + "out": "d93af947b1463a817db441a474588d6f996d243983e83c7eee90e1efa440d9ba" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "", + "out": "94898945a7db259e1b2e7cbea48aa0c6d6570d18179f0618471c88f3ec3b0fc3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "", + "out": "4c2d935256392aa2be6e1078c0593815abef469de969b57b881b93af558465fa" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "", + "out": "aac7be16e52f790e4ff70b24015cb11b40616e94db13882b41d3dd8c8c1952b7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "", + "out": "0434b47c0ee7e6f53906799a43209d3fc37d3fd1f74555de67abacb951b006f4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "", + "out": "0442fbdd5b58496ec78159ccaa887c88a861fcca70e7abc976f24c11588be6ee" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "", + "out": "a73e68bb18b007648e76b5528d1e50e7fa654da3970ec349bf591a30d932c8f6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "", + "out": "849cf873162ba72c4b8008e68f932fb3a015a74fcf957198d56a0dc4625a74f5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "", + "out": "a6dec6fc8949349c4e9a9c623687fba4c9b275bdb230509b72e3d6711914e2d8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "", + "out": "58afc2b24a19fdbf76a09b70b1e3b77fcbd4065001d9636640eb5a2628f442cc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "", + "out": "473a43aa1d6a028767432a830ad1221e029c589af9fd4d68d56c4fb820259352" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "", + "out": "a0aeb4a5ad899af2e291b2e79dbb6b0bf56b5844676b955d945b6c4ae1c01eed" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "", + "out": "cfc3029a9eeb152222d96653492e46ca64ca4f0d64683028d3aee5a49cb47163" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "", + "out": "7467cf7761cd9f55618d30c9d8c5b41e4701510c7d16ab4e5d89a5d77146b092" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "", + "out": "c016d8424e531efc5737c03fc90a5efc9f9022e4d5ba3b0695f7ae538260c2ee" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "", + "out": "5d381189e6000fc117c71f59f786fb4b79fdd4ec5d4cd30aac2157f75dead778" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "", + "out": "7c9cdd15c4c9abcacbfe6f664a7f5f8b2e259183291ae5cc9130a0b241e5737f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "", + "out": "b8813172f5218ac3eb687bc4afaff83fbca4e9c1a462963301dd4459850150a2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "", + "out": "e3d130e36a028ea80c57a2aa4819fd34e4dbbeb14a495894b15a8787db1a9f9c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "", + "out": "fff1b4400f489e07d22351c1f09565e265b68ad29f6329879e6b5f7f6b419350" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "", + "out": "559ed5bb3e5f3985fb578228bf8c0f0b173f8d1153faeb9fec756ffd18a87238" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "", + "out": "88131253014d23c5e38e78bda19455d8a023bd7a7e727457a152a81d0b1718a7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "", + "out": "f4d3fae7cde6bb66715a198fa48d210c10f8df3204ae5e33a602467f1b622685" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "", + "out": "e62b622ac8a21366bf2ded30f4082a53e77a9aa696b1f3ee8cfe99c59312d9c7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "", + "out": "3d39ffa85512c3c8890d4bdf31889ca66e5cecb63cfeed57b9263708e74c550b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "", + "out": "b1703b8a00e2612497d11c649d150a6c963bf4fd38feb1c381fe0d9b04c02b22" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "", + "out": "12fbad9d3782812d71179a50fbd9b4566c7b06f5d77c6f329717fb4ae2c5b4ec" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "", + "out": "768b659a824b43f9ca5660b9ddf05f8ba2bc4993866b7c9be68791f5b24644b3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "", + "out": "c0204e23ca86be205eed0cc3dd7225ce5ffe1ee12dacb93c5d0629b7699cd733" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "", + "out": "f43296961f8eaeccd854413dc5adda62393a344627e86c066e7907550040744f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "", + "out": "82f4469e80789021c61db7e32f36acbe591a64f26059265770ae658d62bde7ef" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "", + "out": "2a85671a55c89fa156e296f75df1c7dbab178ebba65204a7e8178c916ad087f8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "", + "out": "33e245002808f6934b9be3a6fa8e8670c90baa625717b9201eb9b9dd912f5ce2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "", + "out": "58ee5e799184ad9da9a17c5b46a4810e28bdd08c3581634c835030539b79544d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "", + "out": "26d8fa08db308edf2f96f82af6b60c17d8f1ff858c52f2d0f3831078127526a3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "", + "out": "25a58df4039247a22f68ff2b71766b7b5600ddf401d99ff2c1955ae7bb43e56a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "", + "out": "be43e8686160e907ba547d5a879d10f788afc842b8ebb9f3f788532515912ae4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "", + "out": "aa4acb95d879192a6908e88ae3d6589f4e3eb3d4e03a806ccdb9b5d6a9586fdf" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "", + "out": "8466d5e44ce95b4fa179992444b8c2485b886448a6dccfcf0bc30bc5f0f56b01" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "", + "out": "0056d7e0ac33355783659b38ec8beccbf783939967fe37aeacf369ddb670ada0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "", + "out": "904f42f345530ac8a352d09b6872c5bca3661abca6ca64c8099f2fb6867c30fe" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "", + "out": "a8c3bf46f0b88bbd16fda4a8b5ca81f5243520c385d38c0b4d2352ab34ea35e6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "", + "out": "8d3317fc606e566d302edab55e801611d8c13f4a9a19d185978def72839cdaa3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "", + "out": "97388011f57a498690ec7988eff903ff9b2358f5b61baa20f73290d6296c1c0b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "", + "out": "cfb80cab8990950809123fbf85e976454708e0afed698e3352a31635909db3e5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "", + "out": "0daaca55132a235b831a5eff4ea467cd10af44200847735a1ffd51fa37eaa2a2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "", + "out": "69b21497ebb824ba665368188825e6f6f14cf2c3f7b5530bb34fa658eed9a739" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "", + "out": "b9a19f509be03fbc40e243a58a3ded11f0d51f80e3e29a505644cc05743814ec" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "", + "out": "c4bcb2002555d544fd0b02770623891e70eeec7744865dd6455ad665cc82e861" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "", + "out": "912d24dc3d6923a483c263eba81b7a8797f23cbf2f78b51e2226639f84a59047" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "", + "out": "56827a18883afdf9ceec562b2066d8acb2c19505ece6f7a83e9f3346cbb828c9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "", + "out": "251d8d09fc48dd1d6af8ffdf395091a46e05b8b7c5ec0c79b68a8904c827bdea" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "", + "out": "c2d14d69fd0bbd1c0fe8c845d5fd6a8f740151b1d8eb4d26364bb02dae0c13bc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "", + "out": "2e5fe21f8f1b6397a38a603d60b6f53c3b5db20aa56c6d44bebd4828ce28f90f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "", + "out": "25059f10605e67adfe681350666e15ae976a5a571c13cf5bc8053f430e120a52" +}, +{ + "hash": "blake2sp", + "in": "", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "715cb13895aeb678f6124160bff21465b30f4f6874193fc851b4621043f09cc6" +}, +{ + "hash": "blake2sp", + "in": "00", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "40578ffa52bf51ae1866f4284d3a157fc1bcd36ac13cbdcb0377e4d0cd0b6603" +}, +{ + "hash": "blake2sp", + "in": "0001", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "67e3097545bad7e852d74d4eb548eca7c219c202a7d088db0efeac0eac304249" +}, +{ + "hash": "blake2sp", + "in": "000102", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8dbcc0589a3d17296a7a58e2f1eff0e2aa4210b58d1f88b86d7ba5f29dd3b583" +}, +{ + "hash": "blake2sp", + "in": "00010203", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a9a9652c8c677594c87212d89d5a75fb31ef4f47c6582cde5f1ef66bd494533a" +}, +{ + "hash": "blake2sp", + "in": "0001020304", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "05a7180e595054739948c5e338c95fe0b7fc61ac58a73574745633bbc1f77031" +}, +{ + "hash": "blake2sp", + "in": "000102030405", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "814de83153b8d75dfade29fd39ac72dd09ca0f9bc8b7ab6a06baee7dd0f9f083" +}, +{ + "hash": "blake2sp", + "in": "00010203040506", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dfd419449129ff604f0a148b4c7d68f1174f7d0f8c8d2ce77f448fd3419c6fb0" +}, +{ + "hash": "blake2sp", + "in": "0001020304050607", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b9ed22e7dd8dd14ee8c95b20e7632e8553a268d9ff8633ed3c21d1b8c9a70be1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "95f031671a4e3c54441cee9dbef4b7aca44618a3a333ad7406d197ac5ba0791a" +}, +{ + "hash": "blake2sp", + "in": "00010203040506070809", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e2925b9d5ca0ff6288c5ea1af2d22b0a6b79e2dae08bfd36c3be10bb8d71d839" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "16249c744e4951451d4c894fb59a3ecb3fbfb7a45f96f85d1580ac0b842d96da" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "432bc91c52aceb9daed8832881648650c1b81d117abd68e08451508a63be0081" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cde8202bcfa3f3e95d79bacc165d52700ef71d874a3c637e634f644473720d6b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1621621f5c3ee446899d3c8aae4917b1e6db4a0ed042315fb2c174825e0a1819" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "336e8ebc71e2095c27f864a3121efd0faa7a41285725a592f61beded9dde86ed" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "079be0410e789b36ee7f55c19faac691656eb0521f42949b84ee29fe2a0e7f36" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "17270c4f3488082d9ff9937eab3ca99c97c5b4596147372dd4e98acf13db2810" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "183c38754d0341ce07c17a6cb6c2fd8bbcc1404fdd014199c78be1a97559a928" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6e52d728a405a6e1f87587bbc2ac91c5c09b2d828ac81e5c4a81d03dd4aa8d5c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f4e08e059b74144bf948146d14a2c81e46dc15ff26eb52344cdd474abea14bc0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0f2e0a100ed8a11785962ad4596af955e30b9aef930a248da9322b702d4b6872" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5190fcc732f404aad4364ac7960cfd5b4e348629c372eeb325b5c6c7cbce59ab" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c0c4cb86ea25ea957eec5b22d2550a1649e6dffa316bb8f4c91b8ff7a24b2531" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2c9eda135a30aecaf3acb3d23a3035fbabba98333165d87fcbf8fe10336ecf20" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3cd669e8d56262a2371367224dae6d759ee152c31533b263fa2e64920877b2a7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "18a9a0c2d0ea6c3bb332830f8918b0684f5d3994df4867462dd06ef0862424cc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7390ea4104a9f4eea90f81e26a129dcf9f4af38352d9cb6a812cc8056909050e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e49e0114c629b494b11ea98ecd4032731f153b4650acacd7e0f6e7de3df01977" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "27c5702be104b3a94fc43423aeee83ac3ca73b7f87839a6b2e29607903b7f287" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "81d2e12eb2f42760c6e3baa78f84073ae6f5616070fe25bede7c7c8248ab1fba" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fab235d59348ab8ce49bec77c0f19328fd045dfd608a530336df4f94e172a5c8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8aaa8d805c58881ff379fbd42c6bf6f14c6c73df8071b3b228981109ccc015f9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "91fdd262203916394740952bce72b64babb6f721344dee8250bf0e46f1ba188f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f7e57b8f85f47d5903ad4ccb8af62a3e858aab2b8cc226494f7b00bedbf5b0d0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f76f21addae96a9646fc06f9bf52ae0848f18c3526b129e15b2c355e2e79e5da" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8aeb1c795f3490015ef4cd61a2807b230efdc8460173dad026a4a0fcc2fbf22a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c564ffc623077765bb9787585654ce745dbd108cef248ab00ad1a2647d990387" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fe8942a3e5f5e8cd705104f88210726e53dd7eb3f9a202bf9314b3b9065eb712" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dc295359d436eea78084e7b077fe09b19c5bf3d2a796dab019e4200599fd8202" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "70b3f72f749032e25e383b964378ea1c543e9c15de3a27d86d2a9d2231eff48a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7982b54c08db2bfb6f45f35bc323bc093779b6bb0e3eea3e8c98b1de99d3c55e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "75e4162257014bedcc05c2944dce0df0c35eba131954064f6e4e095fd08445ee" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4a129ea6cdbabc2d392479372f975b9cf5a1b7deb69a3266f03ebc6d111393c4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8fed70f27955dc8ad9f1b7b3f6f5dfbd962a33592b42de856d421e2912bab86b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e2f20660376f2b1839667cbfe5e16ef075ac3943644f3532282f8bb0723b9986" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "abf84c913a83df98c70029819c065f6d6de4f6d43abf600dade035b23bed7baa" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "459c15d4856c7ecf82620351c3c1c76c403f3e9707741387e299073fb1704b2b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9ab912eda0768abdf826b6e05d0d735839e6a5f02e04c4cc75650b2c8cab6749" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4740ebecac90031bb7e68e51c55391afb189b317f2de558766f78f5cb71f81b6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3cc47f0ef64821587c937cddba85c993d3ce2dd0ced40d3be33cb7dc7edabcf1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9f476a22db54d6bb9befdb260c66578ae1d8a5f87d3d8c017fdb7475080fa8e1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8b68c6fb0706a795f3a839d6fe25fd4aa7f92e664f762d615381bc859afa292c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f640d225a6bcd2fc8accafbed5a84b5bbb5d8ae5db06a10b6d9d93160b392ee0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "704860a7f5ba68db27031c15f225500d692ab247534281c4f684f6c6c8cd88c7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c1a75bdda12b8b2ab1b924843858183a09d202421fdbcdf0e63eae46f37d91ed" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9a8cab7a5f2e576221a6a85e5fddee75678e065324a61db03a39261ddf75e3f4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "05c2b26b03ce6ca5871be0de84ee2786a79bcd9f30033e819b4a87cca27afc6a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b0b0993c6d0c6ed5c3590480f865f467f4331a58dd8e47bd98ebbcdb8eb4f94d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e57c103cf7b6bbeb8a0dc8f048625c3f4ce4f1a5ad4d079c1187bfe9ee3b8a5f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f10023e15f3b72b738ad61ae65ab9a07e7774e2d7ab02dba4e0caf5602c80178" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9a8fb3b538c1d6c45051fa9ed9b07d3e89b4430330014a1efa2823c0823cf237" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3075c5bc7c3ad7e3920101bc6899c58ea70167a7772ca28e38e2c1b0d325e5a0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e85594700e3922a1e8e41eb8b064e7ac6d949d13b5a34523e5a6beac03c8ab29" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d3701a5661bd31ab20562bd07b74dd19ac8f3524b73ce7bc996b788afd2f317" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "874e1938033d7d383597a2a65f58b554e41106f6d1d50e9ba0eb685f6b6da071" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "93f2f3d69b2d36529556eccaf9f99adbe895e1572231e649b50584b5d7d08af8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "06e06d610f2eebba3676823e7744d751aff73076ed65f3cff5e72fd227999c77" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8df757b3a1e0f480fa76c7f358ed0398be3f2a8f7b90ea8c807599deda1d0534" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "eec9c5c63cc5169d967bb1624e9ee5ced92897736efbd157548d82e87cc72f25" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cc2b5832ad272cc55c10d4f8c7f8bb38e6e4eb922f9386830f90b1e3da3937d5" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "368985d5387c0bfc928ac254fa6d16673e70947566961b5fb3325a588ab3173a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f1e442afb872151f8134956c548ae3240d07e6e338d4a7a6af8da4119ab0e2b0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b012c7546a39c40cadece4e04e7f33c593ad182ebc5a46d2dbf4ad1a92f59e7b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6c6097cd2033096b4df317de8a908b7d0c7294390c5a399c301bf2a2652e8262" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ba83feb510b49ade4faefbe942781eafd41ad5d436888531b68859f22c2d164a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5a069e4392195ac9d284a47f3bd854af8fd0d7fdc3483d2c5f3424ccfda15c8e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7e88d64bbbe2024f4454ba1398b3d8652dcec820b14c3b0abfbf0f4f3306bb5e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f8742ff46dfdf3ec8264f9945b20419462f069e833c594ec80ffac5e7e5134f9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d3e0b738d2e92f3c47c794666609c0f5504f67ec4e760eeeccf8644e68333411" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0c90ce10edf0ce1d47eeb50b5b7aff8ee8a43b64a889c1c6c6b8e31a3cfc45ee" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "83917ac1cdade8f0e3bf426feac1388b3fcbe3e1bf98798c8158bf758e8d5d4e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dc8eb0c013fa9d064ee37623369fb394af974b1aac82405b88976cd8fca12530" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9af4fc92ea8d6b5fe7990e3a02701ec22b2dfd7100b90d0551869417955e44c8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c722cec131baa163f47e4b339e1fb9b4aca248c4759345eadbd6c6a7ddb50477" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1837b120d4e4046c6de8ccaf09f1caf302ad56234e6b422ce90a61bf06aee43d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "87ac9d0f8a0b11bfedd6991a6daf34c8aa5d7e8ae1b9df4af738005fe78ce93c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e21fb668ebb8bf2d82086dedcb3a5371c2c46fa1ac11d2e2c566d14ad3c3653f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5a9a69815e4d3eb772ed908fe658ce5087310ec1d50cb94f5628339a61dcd9ee" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "aac285f1208f70a64797d0a9400da64653301838fef6690b87cda9159ee07ef4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "05643c1c6f265925a65093f9de8a191c4f6fd1418fbf66be8059a91ba8dcda61" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1c6cde5b78103c9e6f046dfe30f5121cf9d4039efe222540a41bbc06e469feb6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b49bb46d1b193b045e7412059fe72d552552a8fb6c36410723dc7d05fcceded3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b612d3d21fc4de3c791af735e59fb717d839723b42508e9ebf7806d93e9c837f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7c3390a3e5cb27d1868ba455cfeb3222fde27bcda4bf248e3d29cf1f34329f25" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bd42eea7b35486cdd0907cb4712ede2f4deeccbca191603865a1cc809f12b446" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d1dd6201740cfaad53ceccb756b110f3d50f817b43d7559557e57aad143a85d9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5829643c1b10e1c8ccf20c9b4af821ea052d7f0f7c22f7380bbbcfafb977e21f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fc4cf2a7fbe0b1e8aefbe4b4b79ed84ec97b034f51b4e97f760b20639765b933" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4d7c3b3438a0bda28e7a96e42027d813e88ae62885499833d3c5f6359ef7edbc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "34cbd32068ef7e82099e580bf9e26423e981e31b1bbce61aeab14c32a273e4cb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a05dda7d0da9e094ae22533f79e7dccd26b1757cefb95bcf62c4ff9c2692e1c0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "224ccffa7cca4ce34afd47f62ade53c5e8489b04ac9c41f7fad0c8edeb89e941" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6bc6076483aa11c07fba55c0f9a1b5da87ecbffea75598cc318a514cec7b3b6a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9a0360e23a22f4f76c0e9528dafd129bb4675fb88d44eaf85777300cec9bcc79" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "790199b4ca90dedccfe32474e85b174f069e3542be3104c1125c2fdbd69d32c7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "55839925834ca3e825e99241874d16d6c2623629c4c2adddf0dba01e6ce8a0dc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "615ff846d993007d38de1aecb3178289ded09e6bb5cbd60f69c6aa36383020f7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f0e40b4ed40d34851e72b4ee4d00ea6a40ea1c1bf9e5c269710c9d51cbb8a3c9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0b07b2333b08d08c11ca34ab449b71d29a0f43e1f778e073e79006ccb730ed62" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d1f4c29d9f23ea35ec4035b377d506538e728bc739c1459680cf1cc69424924d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1279cf6f669f92f6bfc25d605b9440c7dccbd25df28dc7353abc1c0530405dc4" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1fa0af00775dc2ce76506d3280f472d2f6ff97a2151faa827942fea44ad0ba1f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3e1ad54a5f835b983bd2aab0ed2a4c0bdd7216209c36a79e9e2aabb99faf3512" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c6ed39e2d8b636eccba245ef4e8864f4cd946be216b9be48303e08b92dd09434" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e24736c13ecb9f36a0d829d4798d7699c14cc65b6dc44ed6f10cd4853d6e0757" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "389be88052a381272c6df741a88ad349b712718435480a8190b704771d2de637" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "889f2d578a5daefd341c210984e126d1d96da2dee3c81f7a6080bf84569b3114" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e936095b9b982ffc856d2f5276a4e529ec7395da316d628702fb281ada6f3899" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ef89ce1d6f8b48ea5cd6aeab6a83d0cc98c9a3a207a1085732f047d94038c288" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f925016d79f2aca8c49edfcd6621d5be3c8cec61bd5871d8c1d3a565f35e0c9f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "63e8634b757a38f92b92fd23893ba299853a8613679fdf7e0511095c0f047bca" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cf2cca0772b705eb57d28943f83d353fe291e5b377780b374c8ba4665830be87" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "46df5b87c80e7e4074aee68559424742845b9b350f51ba55b074bbae4c626aab" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "658aa4f9d2bcbd4f7f8eb63e68f5367edbc500a0b1fbb41e9df141bcba8fcd53" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ee80555008a71655e081092bba6f670ed98af9a09fb5afb94cbc5c754814db4f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2c5f9d048220b041b6d4524b4490cf8c66fcb8e14b0d64887aa1e4761a602b39" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "44cb6311d0750b7e33f7333aa78aaca9c34ad5f79c1b1591ec33951e69c4c461" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0c6ce32a3ea05612c5f8090f6a7e87f5ab30e41b707dcbe54155620ad770a340" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c65938dd3a053c729cf5b7c89f390bfebb5112766bb00aa5fa3164dfdf3b5647" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7de7f0d59a9039aff3aaf32c3ee52e7917535729062168d2490b6b6ce244b380" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "895898f53a8f39e42410da77b6c4815b0bb2395e3922f5bed0e1fbf2a4c6dfeb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c905a84984348a64db1f542083748ad90a4bad9833cb6da387293431f19e7c9c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ed37d1a4d06c90d1957848667e9548febb5d423eab4f56785cc4b5416b780008" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0bc65d9997fb734a561fb1e9f8c0958a02c7a4dbd096ebef1a1751aed959eed7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7c5f432eb8b7352a9494dea4d53c21387031ce70e85d9408fc6f8cd98a6aaa1e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b8bf8e2c34e033983639909eaa37640d877b048fe299b470af2d0ba82a5f14c0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "88a9dd13d5dadbdee6bff7ee1ef8c71cc193aa4bf3e84f8fe80cb075683c0779" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9aedb8876dd21c8c84d2e702a13625980462f68bf0a1b7254ad806c38403c9de" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d097573df2d6b2489a479484869800a1f833ea169eff32ae3ce63a2079548d78" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d18f27a3e555d7f91a007c67aceede391f75a61fa42a0b4566eb582ca05ebce7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "df1daa90b1702313e6a5901c7afc5ed9657717a715fa53a4189ec1e5df293a68" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "04e3a496b66996c66e32919ed1f94c36eebbf240633a2f739845f0295d34afba" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8c45d88c4e9c9d0c8c677fe48fa5449ba30178d40af0f0217921c62e4b60cdd3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e149a6b13bdedea2eeee009ce9445e8dcf76b76e55a501d8f5b43ff896796ad1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a837c4c7c6f5cfb99e1085fd43287a4105cb28b76fc38b6055c5dcff78b82565" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "42411f28780b4f1638540b870521ec45bceb1e0c7131f7e1c4672e436c88c8e9" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "34b4e876769471df552e5522cea784fa53ac61bede8cfe291409e68b69e8776f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8f31d637a91dbd0ecb0ba0e694bec1447658ce6c27ea9b95ff36701caf36f001" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b5c895eb071e3d38528d475d3bb0ba88b71795e40a982e2ac2d84422a0f2685d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e906257c419d941ed2b8a9c12781db9759a3fcf3dc7cdb031599e1086b672f10" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "98ad24397c6eae4cf73ea8bbef5a0b74d21ad15f33920f44070a98bdf53d0b3a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dd510ca55b1170f9cefdbb16fc145262aa363a870a01e1bc4fbe40234b4b6f2f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f2d8d931b92e1cb698e56ed02819ea11d26619b83a6209ad67225368fe119571" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e4637055db91f9437cf460ef40b5145f6998266a5e74e96a00782c62cf30cf1c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3563530a89d32b75f78d83e9872ad4c575f520399d65035ded99e5eec5807150" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8e79f92c865beb3e1cdbf08f754a2606e85349053d66d616024a813fca541a4d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "864226f2839c76b1d5f7c13d98c2a5158c2abb71d9d8f0fa1f7c3f7468001603" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d3e3f5b8ceebb11184803535900b6eedda606eeb369751a7cda36ca30229fb02" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8c7d6b987269169031f71fd7e4c445012d3e6a3c8809f6479bd667cf311e276e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b904b5711bf19e8532f7ad6427410a62a1f77f77b9b6d71d2fc43bc90f73235a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4536634315c86728f5ab7449eb2d04020e9eae8dd6795500e9ec9a0066386e69" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fd5e49fed49dc44bde89f460a950191ebb067c698a3f21ea14308c7413b91681" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "31f01d030b9b22d00a0f71ed2ceb5d2dc81af2c24bf5670fde19a685e8d1392e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5f84d9de284b1e4f678e31ab6a76f5661b5aeaa768539384aa38f9e49cce6e6e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b2079e5997a4ead3a71fefc02f90a7483a10fd2e6f31bda9d2084485cc016bbd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e0f84d7f525b6fed791f77289ae58f7d50a29432d42c25c1e83929b838891d79" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "70469690956d7918ace7ba5f41302da138c9b56ecd415544face8d998c21abeb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "45c91a62249b39cda94e508295bec7667119447765ef80efa82d1e92d57067d8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d9e0073eed0731554c3beaa47460d511ad261dd4d4a3bed9d8d202f22f21589" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "408262736d8aec0b847dba250258608a4345a63a1eb195e5c7ae2ee874c34da8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "23d2b70439469949982390538d7e5ade9f18c8e3bbf6605afcf49b00c061e837" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "232fb187d271bea912efd407ffe08056d6a42e5321ec792df3d584a94f630ab2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "138e1944e4b54de8681d7e48c4f08148e40a567e5cad946a6af4e8d5d26f75c7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "80c151325fbfc678b7be4e40b30f29fe31cdbe1c84126e006df3c18524bd2d6c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a642267301669df261b839f87365762905ff320a0a2fc4bdc48e5a8e15d13233" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0f8b10993860937a74cc2de40a2731dd9954b654bb94c34e876652e98d4bbd16" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e634a58512493273260f10d44953cd998e34cb8281c41bf42e0ae2f25cbd1f75" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bde6af9baf3c07e95423cab504dee70edcc3318b22dd1eb6fd85be447ac9f209" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "914b37ab5b8cfde6a480466a0d82432c7d76328e9a88ef5b4f52429f7a3ffc7d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "55be66e9a5aa671a23882ef3e7d9d36ea95487dc71b725a5ad4b798a879143d0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3fd045894b836e44e9ca75fbe3eadc486cbbd0d8cee1b3cf14f76e7f1e77aef3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ce60343dc4874b6604e1fb231e37ec1eec3f06566e428ae764efffa230add485" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e38c9df024de2153d226738a0e5ba9b8c6784daca65c22a7628eb58ea0d495a7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8dfec0d4f3658a20a0bad66f2160832b164e700a21ec5a0165c36772b2086111" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4401b50e09865f4238243b8225ca40a08dbb4685f5f862fbdd72980431a85d3f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8668942788c4ce8a33190ffcfad1c678c4fa41e99417094e240f4a43f387a3b6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a7288d5e09809b696984ecd5326cdd84fbe35fcf67235d811c82002536a3c5e1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8e925c3c146bacf3351ec53241ace5f73e8fc9bd8c61cad97fd772b07e1b8373" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c7eb9e6ded2f993d48b0170da27c5b753b12176be126c7ba2d6af85f8593b752" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ca27f16f94e4ec0e628e7f8aefc6657bedc93742965940ae786a73b5fd593b97" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8c21e6568bc6dc00e3d6ebc09ea9c2ce006cd311d3b3e9cc9d8ddbfb3c5a7776" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "525666968b3b7d007bb926b6efdc7e212a31154c9ae18d43ee0eb7e6b1a938d3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e09a4fa5c28bdcd7c839840e0a383e4f7a102d0b1bc849c949627c4100c17dd3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c19f3e295db2fc0e7481c4f16af01155ddb0d7d1383d4a1ff1699db71177340c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "769e678c0a0909a2021c4dc26b1a3c9bc557adb21a50834cdc5c9293f75365f8" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b64874adab6bcb85b94bd9a6c565d0d2bc35445d7528bc85b41fdc79dc76e34f" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "faf250de15820f7fc610dd53eeae44601c3effa3accd088eb66905bb2653be8c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1e2038739b2c018b0e9e0e1e522fd9651287ee6e3665919b24c2124f0c1a3f3a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5fec3aa00861de1ac5dab3c137065d1e01bb03f69dcc7d1cf7ca4f4356aec9a3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4451fe6bbef39343919244c51dae1ea9a954cf2c0966ab045b15521ecf350081" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8c622fa2160e8e991813f180bfec0b431c6dbfa2956d9175816a23c382c4f200" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "817d5c8f92e7b5ca57f5e1639016ad5760e446d6e9caa7498414ace82280b5cd" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a6a1ad58cee54e69cbbcaa87df07a6707eb224739c217613460ab454b459ca9c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "63b847275226605be67681258f7d00bbb307c66f1959bf2e467a41aee714e55c" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fe52ebe5cfcfe6a2297b539fa3dadbd6ebd201aa2ca13563e3d7f14d15abff63" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b7bef9fa5a3d10426246b5f658c08fdf8066eaa3e55a2f7da1591e05c87df8c7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ded1d6caa9f8f3bda92cea7f6549b1fb86a2211478c4ec289b837efc2b5c27d7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9f30008a2eb050f18e56a76be92091b2fdc164d56e32c87dd64c9e3a611041b1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "010b6a3b11860088f0abc80a8972cbbc329d5275342950eb9a045afdc8bbed24" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0cd210aac11f1c1ced497f673e53db68c3ec3607f0c5787ddc60a355dfe56c25" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0e56fd01da3b4f8be2c990552aac8d1e8da209bcf4aad4ffb5427fd63172463e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d6d5cdb11440e34aca3a2fcf30f59e08b11a2a3de539e3e6513ed78a4fee513b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "aa35ac90680670c732ed1ef37e8cbaae49a4d88ecf4df2b689a0f101b756ae47" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "278e561288722630e26a5fc954bf2dcd6a65816739abee7be14307a96174e5b0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ab4b2ca1a2b349981524b6155462f0ff1060bf9bfa07fb9ec69ca471645b6a18" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "18a9bbec3c8e1f8ee9571297a93436de427cd270ec69dfe888db7dbf10b64993" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bafc7e43d265a173021a9d9e583d60ed42a803facd6b8360de1f916835389bf0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a5b67be950fbc2f0dd323a79a19e3ed1f4ae4ba7894f930ea5ef734de7db83ae" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bf1e65f3cd8498884d9d5c19ebf7b916067637604e26dbe2b7288ecb11426068" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c3342cf9cbbf29d406d7895dd4d9548d4ac78b4d00e9b63e203e5e19e9974620" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1c0be60277434b0e004b7b388a37559f84b30c6cf8600f528bfcd33caf52cb1e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "73954530d03f10bef52ad5bc7fb4c076f83f6331c8bd1eeec3887f4aa2069240" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "69c11ee04944dea985ac9f13960e73980e1bb0e309f4384a1676f8efab384288" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "36fb8fde0ec28ce853fb7175c1b79da3b5e8c39186e78aaece5464dbd9fe2aa2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6bb2a09dfcaf96962de00c8a082d6df9322b4966ae8d2ecf732411a76a1a0ee6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7412e7dd1bf1aa9397411bba4d3e0276d2e7a1a29a2477157ad60360d33d4e76" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dddeafcfc72321c849fb25947ab42c1af2a5e43fef681be42c7eaf3660080ad3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9defebadbdcb0a0e7ff992f947ced3d0a4c899e64fe77360e81e1f0e97f8c1a2" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "844c59fbe6476fd189239954f17e36e1f69e24aaed5d5c8b8405ef2a830cc2a0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ff3fafb67786e01a0c38eadf99c4cae8029da8cf29875fc419bf680009b3bdb3" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ca6760f345678f30a28d628294272a19e3072ebc61b19ff13b318973e97c2738" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c08e1a9047c505264a16447c9ed981a719d381f28e605fd7caa9e8bdbb42996a" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f173ba9d4584cd126050c69fc219a9190a0bf0aececbe611beed193da6ca4de7" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b184876520ded8bd7de25eaefbd3e03688c3be39c19fb73e1f0eccac7cc0f014" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9025db0758bdfb48f0667ebd7e120246598fed01c258764fa0fae334a2a00a97" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e83d8086fabc460d5efc459f95a268f5dc4ac284093c247ca6ec841ad6183fe1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cc9df41d35aa75928c185f7393666110b80f0986a221c370f45c2eb9016c9a3b" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "92f9a594954590fa819817e5d1c28aab2b1cc504d86dba443676bdf866796811" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "729562a1e07b0e2605494809bd480f1537cea10dcad43ef9f68c66e825dc46b1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "26f160ab96f5582045146eaff2e2a8d4dab298b4c57e117cdfc5d025c92a2268" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "87ebe721383873d247f86182e3f599a7634fcaec5e07b1e83ebb79625ba354e6" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e08d389f75694adc996c22f55d4f859ffd0c1319ff9cedf78c31be84b6f21abc" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1363e22913c6e18e7aa65b83e751c8a2c61b0f307155865a57dba569a99c7b0e" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8878088eb2d1f6d0bb481b4bb187da04bcd8c2c639f005b08054cc41753905fb" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0418d60d05b4e124646ee50e7749a1d209457bc543e3cc1130274aea0f7bf3c1" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7a397e503f293bc42d5f7ef5ec37872460a4f5b5ccde77fb4d47ac0681e5a049" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5c0d2983e72a6dd4e652d723c1dfc12b414c873d4ab4a0a150408eb34347e995" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5623365453c04989c7cf33635e0fc4cddd686fc95a33dfedcf3335794c7dc344" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "11f6dad188028fdf1378a256e4570e9063107b8f79dc663fa5556f56fd44a0f0" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0ed8161797ecee881e7d0e3f4c5fb839c84eb7a9242657cc48306807b32befde" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "736667c9364ce12db8f6b143c6c178cdef1e1445bc5a2f2634f08e9932273caa" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e15f368b4406c1f65557c8355cbe694b633e26f155f52b7da94cfb23fd4a5d96" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "437ab2d74f50ca86cc3de9be70e4554825e33d824b3a492362e2e9d611bc579d" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2b9158c722898e526d2cdd3fc088e9ffa79a9b73b7d2d24bc478e21cdb3b6763" +}, +{ + "hash": "blake2sp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0c8a36597d7461c63a94732821c941856c668376606c86a52de0ee4104c615db" +}, +{ + "hash": "blake2bp", + "in": "", + "key": "", + "out": "b5ef811a8038f70b628fa8b294daae7492b1ebe343a80eaabbf1f6ae664dd67b9d90b0120791eab81dc96985f28849f6a305186a85501b405114bfa678df9380" +}, +{ + "hash": "blake2bp", + "in": "00", + "key": "", + "out": "a139280e72757b723e6473d5be59f36e9d50fc5cd7d4585cbc09804895a36c521242fb2789f85cb9e35491f31d4a6952f9d8e097aef94fa1ca0b12525721f03d" +}, +{ + "hash": "blake2bp", + "in": "0001", + "key": "", + "out": "ef8cda9635d5063af81115da3c52325a86e84074f9f724b7cbd0b0856ff00177cdd283c298326cd0917754c5241f1480fb509cf2d2c449818077ae35fc330737" +}, +{ + "hash": "blake2bp", + "in": "000102", + "key": "", + "out": "8cf933a2d361a3e6a136dbe4a01e7903797ad6ce766e2b91b9b4a4035127d65f4be86550119418e22da00fd06bf2b27596b37f06be0a154aaf7eca54c4520b97" +}, +{ + "hash": "blake2bp", + "in": "00010203", + "key": "", + "out": "24dc1e6dc4e51a3a3c8da67aacb4c541e41818d180e5bb69753dbbff2f44d0e7da830386bfc83b27a59dbb62b964fc8ea6cbdf3049bff81f24f348db4efd0d07" +}, +{ + "hash": "blake2bp", + "in": "0001020304", + "key": "", + "out": "bc23f5abdffd6a32a5d40811262ed4479ef70b4233ca205bc5b9bf8596731982d04169a904dd43b0e0f94899f733022d24d84fad0a991600f1979b272ad62073" +}, +{ + "hash": "blake2bp", + "in": "000102030405", + "key": "", + "out": "ef107fcd0d92d84ef5ef9463e6e96241254529d2b97fdbe56419070adbc7d5706feb8f449579819ed4be619785fffaaf0d9789cfe726249ab08c9468cb5fde22" +}, +{ + "hash": "blake2bp", + "in": "00010203040506", + "key": "", + "out": "231fbfb7a1ddc5b74933a285a4224c049cba1485ce35640d9c516ed78eaa226d36f65b2589b826c459fa6a91c426fd2a8ab461c9767e7bdd996bef5a78f481b7" +}, +{ + "hash": "blake2bp", + "in": "0001020304050607", + "key": "", + "out": "3a831f2da969b9b7360e74ee53b518980a5ebcdfd4ee23ed805c26394d1824208d7e8f6327d4ec87979ce4af8ab097d69e261ca32db0eefdbc18d16377a6bd20" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708", + "key": "", + "out": "8349a20fddbae1d8472b67f0347aa0fd404d65c6fa1472b310390d7565ba6bc10260d3dce6a14f4dd9b8b3e0a0c47f6db7e7100a7a9b64a844f01064d07905c5" +}, +{ + "hash": "blake2bp", + "in": "00010203040506070809", + "key": "", + "out": "239ae3d6859c7c972a5dc8b9c55aeb938590cfb8552aa305a6f6f31ffa95a840f4ec36f6fb8f83b69c1da981fc9ba16360db0f4f7c68eb543ed58b28756a1e0d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a", + "key": "", + "out": "7c5673286308408fbc62240e074728b27a575cad2a156e00b5c08b218d8887791e47bf10b0bc61a582545a2469639ce628c40f20ea8b849cd005445f29a08cce" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b", + "key": "", + "out": "dd077e769e0def78dd7aadd57d58421bda3a1a4e6972059f8e649cd6bca44a13ab71eb535d244922948465d73bd64efb091046949066653603575a2e891ebd54" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c", + "key": "", + "out": "b36cef28532b40d8178628f0fab5e5b4a1dec0c0e911d727bf09490f5e8d9fac57213fd2a2d12ed3d77a41f5e2fecc40e4eeca1612f51c452331ae93966235bc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d", + "key": "", + "out": "de737dbc612ebd31bc49a2d7c644d4b137817419421c32f4e75114d899e3131d45ca5451248f24169fbf17ee60a9b70798a4b937cea62795289639d18fcd89e4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e", + "key": "", + "out": "b4c1bbcbbccdfce4d2be9dcdb983c1b020c5f720da5becf4cb2a9a3d1b8d23cea7a9f5fd70d3740ecd67ce7d1e9c5e31a3302df66a9b5d54304490fbe1c4a8b9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "", + "out": "b1d65e70c69ba7e3a728e8b6449493f237510b23b6e77d9584d05ff4d3f08780929d74fa5bed9b75d4d6d1ca91ab8d2637dc2e79ba0fe0594acd68fb3cc660b9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "", + "out": "da79f729eab98c04f37fcc854b69a84e467dea1e7782e7af02cb44a49d210d2523683d420ac1dec8ad1fb40e65ab3fe251a851e283d85838084261301ecd089b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "", + "out": "714040403921ae5548a20339d69e093f609aa99c22db72591d1ef4fcb0af016173e577d8c1a3063b443a0e48f313cf2e0f9b0c2ef96a96c424322ccc0cd5304c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "", + "out": "8b2e8c3f0e3c319ba67e86014bda683e5357a04037b4563286ac89cddb7ee04cf6675f9ab61fc8332d218d2bca9715e7dbe58372d1eebf6bc2948471cfcebb77" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "", + "out": "32ee9549d4e32f4be9c500bd8543afd0b69782d0b3ff7ed47a881a0e491f37650a21b26c3f5d0a64e09058b3004a2368b950e47230c22966d3f79da7baa0b87f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "", + "out": "cae7f292713782c471fe3178a9420cd4c11fcd3f6dbe5d15c84ab7353c739ef0641639a2f92aed31c56a2021cc5e58cbead374e2dc8a0dbce5450fe7a018cfa4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "", + "out": "f17fefaeae7d40cd885dac0bc350c0273668ea0222df5c75694f5cb3a321519f6e0ec43ba0c8593dc7341341e519488f20abd5b8124dfacea5cde0965b6970f9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "", + "out": "e2cf86ddc8424ee547eb7245b7325e02f2e3ac013c8d386b3d2e09208a9bcc0b44c4c438eaaf52d2077e9177eb8ee1d59075b52592202062229354bf23c96239" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "", + "out": "38f26a1102cb162d351f843b3c49f6ff85441633b6704a286af81ccbae5a67d3015cc0efafb7057dc2b28d6766e82a068a4c0b524b66d0a632775d93061575f9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "", + "out": "a2c4302daca7a7c632f676304e6275c1c1f0dbfe38dc571cb23e1f7ba5dc18180fc48a015f927c89967c1e104e66f5ea5b2dd31d781c3849bfc649220c385c82" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "", + "out": "c19c6b3fb5352bb394c26846523c25e8265d505f501f9603a4f8bd55386cf4cc9f4d71f38ff445f4efc83098d47969334e79a2bcb4026bc63b7959dedb62b7bd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "", + "out": "1f4ab9840a1cfa8fe6c5622d9b538becb8807a8778b69d9305f908576573b20ca3704e89129726d502e198588d072668bf03630b5b5a9232ff392527249df99b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "", + "out": "fe03177b58b48883a86d4268334b9591d9fbd8bf7cc2aacc5025ef476b4533ba7bd781df011147b3cf511d8b3dcd8c780d30d7da718c22442319817be3186bc5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "", + "out": "f4c3b059105b6aa5fe78843a07d94f712062cb5a4dd6059f97904d0c57973ba8df71d15a511a066864fe455edc9e5f16524cec7ee248ee3ec929063bd10798da" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "", + "out": "57a16f964b181b1203a5803b73817d774483826cea113b9ccfcf0eb87cb23064284962d847bb1fae8cbf5cc63b3ceaa1241ea42c63f898011fc4dbcae6f5e8c5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "", + "out": "7952fc83acf13a95ca9c27a2156d9c1b6300b0ef790f572bc394c677f7c14629ebd8e7d5d7c7f1a5ebbdc390cc08cd58c2008900cb55eb05e444a68c3b393e60" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "", + "out": "2c2240d6b541f4294ff976791d35e6a2d492f57a915fbac5832660c10e9c96465c7bd5fca751bf68e2673a638e3af735b02091d75d1a7f89e3f761c5df821a6b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "", + "out": "59dc846d3405ccd806f8fa20c8969ef68a4385ef6c274eee6dc0692c3ecfb1a834ce644376c52b80421bae94d6c7fdcca5a8f1859c45a10c4eb274826f1f089f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "", + "out": "b752962707a17b664faeb313e2b952dc03e74a7e9447098aa6d4ea5bd287d07a1225eceda9811570580a512b2b20b3fcfca70b44f6454ef3c3524cca6b69475b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "", + "out": "da0d8e5461f81024effeed5d7076a04fededac57e7c98a5945bfde66755818851be1136b71f433a56bda1841ae71392c4b8290826359f587223c3ef737ff732a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "", + "out": "edb86a237c6f137dfbb347011edb4c6e861f4d58146085463441042fa36316f1faf88711bb0f1811dfbbbfa7b51f9ce2d49605243ed016cbad6885eae203674f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "", + "out": "e6d8e0fbaa29dbeb60f3c7f985bad754d721aac63da6f4490c9d7ea231d2622fdfdef148d0ca442b8d59cf3e4f9835cbc240af40fba63a2ea5a235d46eea6eac" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "", + "out": "d4e463c4882987eb44a5ed0c821d68b0fef99d6f53a57bf319bdac25ac38eb0b23e1138c0012f5f38346a1de9d4a992a64b942834a856efbaa0620bda29f6a86" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "", + "out": "42d810d01c2da24735f04a5e901338fdfc2de1715ff6643a372f880e6c5c6c13d2b3ad7077469d643354054d32dd8049ea63732b5745bdb23be2b58e48c1013a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "", + "out": "cfbf5430076f825a3bbb88c1bc0aef61259e8f4d5fa33c39825062f15d19fd4a0182cd9736d2aec9749ccf83186c3574ab94426540660a9db8c3aabbcbdd9d0f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "", + "out": "6c2434a1afa157accc34a5c4872dff69fe7f3196cb1a750c541d8b73922888babe89b1c38202218620d88d77dad9dfbab3fbf740b2d1d8f37ead258e2ef10652" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "", + "out": "48b7268aa4342fab021d1472e9257f76585cc56810c8f2a6e1d4a8946b777142d44ae513a8809f2d6dc726305f7944604d952d4a9f085c5c1050bafdd21d1e60" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "", + "out": "cecfce4b12c6cf53d1b1b2d418a493e3f429170321e81aa25263aaa715d5ca389f65c3acf99b180e446b50e601fcbf4461d0426a8592a07742201857125f71ee" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "", + "out": "385a752242eb9ed56b074b702c91e75aec0be9064bd9cf880304c213270cb2eae8e21d9ae8c6081519f75dfabb003b2432b04755b8c32c97ac2914e8bf45b234" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "", + "out": "d89a124a9b958ba23d09207acfa62a33b87089b286e8438bdc01e233ab2a8630a1eeb6b2b9ba6b7d2100107733deaf4c20478c26f249c689c5268473e2e9fa60" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "", + "out": "43de1092ff9ff528206c6fcf81322ead3d22eaa4c854521577df336247495ce172fc873995300b21b94610c9d2f633b533bde4568ca09c380e8468fe6ad8d81d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "", + "out": "868b601199ef000b705cd64d3930262a5ab910e34e2d78e8587b4e010d376dd4a00de44867d0e933ee39a1fa9147d499d184f3a9cf354f2d3c51146ff7152d68" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "", + "out": "1517f8f0442f0d50bbc0aab6846fdce3b70faea4bb5113acb23abe101d99a40a1b76c1e8dc2ea1936294823ad8354c11e2e96c6712be4cf77c583fd06b5e5c55" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "", + "out": "af4c6c67c5ca38387348ca3ec2bed7fba8c2b3d22de148d08a618c297023fb7b6d2c153d5efcd1688999910b20e1eac7c100a2c5a6c1acf5e98f143b41dc8a12" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "", + "out": "a2ad94243b8eea68f5fadd6908adb0dacdaa6a6d24c250d339403dba8231bd51e887cb5b1b7bde2774c6b08acce0f7495648da3bebc7b1c2821508c4d382f730" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "", + "out": "28f88cdbe903ad63a02331de1a32af6dbba82d7fc0798702724933da773807bc804278134781f126233220e307928131b24710b4674ed705112f95d1aa37a2dc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "", + "out": "5bb29265e246b884ff40914ffa93d9a12edc19eee9cc8a83631d68bd46aad3354ba6674b913f4f823e791f0cb19ea6a67c6e32e9be0d0ff5760f16dd75a87b5d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "", + "out": "bf3c06dc6d94e3859a4daa50eca1af5357e34579e599f82049e1cca7a7d4f33fea443b44691bd43688f5550531cf22b71277890bffae1ece783f5663a1c4d71a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "", + "out": "c90df532f2f1493a1155be8c2a4400922049974e7d4f4b54f820c2269d3b161b6e88eb776b859b89b8567fbc550c4f54aad27a1610656d625c327f665dca707c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "", + "out": "3d39eecc9e904236dc857ba49d55d3bad76572a91a759503376b7708d62d5a785c23068059cf68897f23eec507219b0a02eda2d8bc94fa6989a514822203c8d1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "", + "out": "e08c54d998f92b7a54a24ca6aeb153a64f9c9f1fc33658b3edac2c4bb5263158dadf00d3519a119a5614c7f37940e55d13cce466cb71a407c39fc51e1efe18da" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "", + "out": "74767607041dd4b7c56b189ee8f27731a5167223eb7af9b939e118f87d80b49ea8d0d01f74f398b172a8ad0dbf99414f08d2b7d8d75216a18225273d8d7fd05d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "", + "out": "fee89a92ccf9f1eb084aaba95497ef0f30134c191cf90a49d22c7d2f6614993cbe1a4b6513edc153868a3d562b5b0226ba8e1b0dcb69ed45af47ce4f86ba474a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "", + "out": "cdae94b6d1d835f6c74c76ec3a2db65bbdfae19d7b050dc95d658733b8b22c6f9e0b63cc905a29ea8878ca394556b3673c62791546a9a1f0d1565fadc53536c1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "", + "out": "c7228b6f000017d2be4bf2ae48addb785e2735bf3c614d3c34231f1d0c887d3a8e88880b67ad3b2f6523dd6719342cd4f05935d2e5267f3680e773bd5eadfe1d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "", + "out": "122744fe3fff9a055f0f3bde01eb2f446b0cdaf3aed72caa2940741920120a964fcff87099b08ef33496e399032a82daad4fed3031172f77479258fa39db92fd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "", + "out": "1fb4e367eab642b72e43ad4abdfcad74620c3f6c63a8913128d2226eb192f9992eb9c8f76ae206d3f5dec726a5a686b4ae37b557ab57f956485334f73dce02e0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "", + "out": "0425caaa923b47b35045eb50829c048bc890444afeefc0afc9d1877b821e043c9c7b9d6dc33fbbdfa537c1ece311965b2fee8982bc46a2a750bfc71d79dbea04" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "", + "out": "6b9d86f15c090a00fc3d907f906c5eb79265e58b88eb64294b4cc4e2b89b1a7c5ee3127ed21b456862de6b2abda59eaacf2dcbe922ca755e40735be81d9c88a5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "", + "out": "146a187a99e8a2d233e0eb373d437b02bfa8d6515b3ca1de48a6b6acf7437eb7e7ac3f2d19ef3bb9b833cc5761dba22d1ad060be76cdcb812d64d578e989a5a4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "", + "out": "25754ca6669c4870840388ea64e95bd2e0810d363c4cf6a16ea1bd06686a93c8a125f230229d948485e1a82de48200358f3e02b505dabc4f139c0379dc2b3080" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "", + "out": "0e26cbc78dc754eca06cf8cb31fcbabb188892c10450890549b2d403a2a3c4577001f74a76bd38990d755bae0526648329f63545ed16995cb1e6343f189f8e6f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "", + "out": "58e7980b8b1a0b88da9da8640f2b96e3e048366130c266217ddc7953508f4a40d1674dabd39289e3f10c611968ccd1e9ccc18cadc7774a997dd1fa94e8354707" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "", + "out": "696fb84763e023584b35907a8b8aaa9e0e786f2ca5914541915848fb6ddab8d3d2eab600c138ce6717b0c70259d3193ea15695c850537f2c706ca4af158e957e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "", + "out": "23de6e73079c8c2047a7846a83ccacabd371163b7b6d54eb032bc49b669742be717b99da12c646ad525706f222e1df4a91dd0cc64df182da00731d439c46f8d2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "", + "out": "bb74f36a9db696c93335e6c46aab58db10cb07ea4f1b71936305228390959478f8734e215490e9ae2a3ec8f7f76733ae3f8b9a3fd7c406c6cac709975c40f856" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "", + "out": "ec6304d38e232c096ab586cadf27026dc5e53217d0e8b0c60adaae22f4e8c22d30bc5177f1c83acd925e02a2da89595fc106090e2e53edb31cdb76ff37eb6180" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "", + "out": "92f9fc6bc59a543f0dc9a1798fb1e5d523474e48ff3e29497f7280d1c408c8663348fe2af78f6c4e5ef5c0a017f3d3f215ecdd7a400ac5773b9e256068845a92" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "", + "out": "4a25b562f2fa01ddee7ea2e9fbf52f8c756d28db4a8bf70e740e9027426e51639df8788d133856858d01fddbdd5b987944c300dc7f8241fbcefa4f12948afeae" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "", + "out": "34212dd9f0651f81809a14edbcf7f3acdede7872c7a4847bea9f7ab7597382477a4cb8479a276321235e9021579446a4388a99e560a3907aeef2b438fe6b90c4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "", + "out": "d62cf7abbc7d7bcd5beb1ee48c43b804fd0db455e7f4febbcff14b05be9047e27e518d6d3a6ada4d5863b7ec7f8492458940ac6bddb506592ccbc896afbb77a3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "", + "out": "33a3a2636f9198d37a5ff1bff9eb10024b28468039f491402d39b708c55d27e5e8df5e3e1949958235cad980742096f2779a1d71dad58fafa3cd02cb5eaa98c5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "", + "out": "b7a38990e6f4564aa3d93a7937100c29f940aff7cb20865a1c218981a5420486081781f8d50c86625cc5d76d0f5ccc4eb65d436609624f21d05339ab0cf79f4c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "", + "out": "9d665a3fdd10459e77f03ac8c0e239019489693cc9315aa3ff112911d2acf0b7d276ac769bedfd852d2889dd12db91398b01c4f4a5da2780b1defe0d95b63270" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "", + "out": "70fb9efd5bca7f19b6e31d640dcf88d77e768ae227ecb3fd6b47137894f549bf1cf06e5db4546044dd9f465c9c85f7284fe54d2b7152699be4bd555a909a88a9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "", + "out": "7afdb0193087e0c9f8b4dd8b48d9f20ace2713afc71bcc9382b54290aebffeb2d138f4dcf028f9c43cc180898477a39e3f53a8d1bf67ceb608261fae6ddb1abc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "", + "out": "05990d7d7df1d484f5b1cae9ee5dfcb43f2cbe186c1a5b181a3731d4b1548ebff5bf61cb0f6d9fc230f25e8678b799e0e83026a0866bf0acab089e102e67ab6b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "", + "out": "1af7a5ce587c8d87c7b79fa3e723d74ce026b5286752fd0c3742c6f0418ed785990d21f28da839ce8212ed550c373e6d3a75d55c31770441eeaff2d50f6e61b6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "", + "out": "ddee0c76c9bdd32d7049354cfc85dc6867e2492e47feb08e3983d0b678845d7ec6c9793c3326bfdc1e113276d177fe38825204dd00073989c081cc3b71c68d5f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "", + "out": "de070648b37c47dc9f2f6d2ab20773cd82fa5725a6900eb71cddb0c9f39b31df6d0773246e8ef9034967752db7ed22733f4379948dc396dc35adbbe9f6537740" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "", + "out": "a6456fbcff9e3d5b116a0e331a1f974f070e955609781fa599d608a31da76ad8abfe346617c25786513b2c44bfe2cb457c43fa6f45361ca9c6341311b7ddfbd5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "", + "out": "5c95d382021891048b5ec81cc88e66b1b4d80a00b5ee66b3c0307749e6f24d170d23facc8eb253b3562bf8a45c37990cd2d3e443b18c68bbcc6c831dfde2f8e5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "", + "out": "e37400dbd9210f3137acaf49242fa123a052958a4c0d98906247d535a351fd52296e7010325bda841fa2aab44763763c5504d7b30c6d79fc1dc8cf1024466db0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "", + "out": "5273a3a13cf0ec7200442cbd7b374466a7190ddca131d963f8f83965aed3dd86e9d45ab489b9c56247c9f2aa69fd7e3187b8fa0dac77c47cb295ba6296784394" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "", + "out": "2adb9349a9ec37ff4962f4217e80ebdcd360967b513d1202d9982831155d2f43eb9add63b5ec10d3d0430dc9cf7648117fc60babbf8ebf19facee550455b60c9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "", + "out": "acaada3e4737c663ebf03c0249cca6f3179a0384ea2ab135d4d7a2bb8a2f40539cdce8a3760fd13deeecd160617f72de63754e2157cadcf067329c2a5198f8e0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "", + "out": "ef15e6db96e6d0c18c70adc3cdb32b28677402e8ea4411ea2f3468ed9382e19bfecaf5acb828a52be16b981e487e5bb4a1430865358e979fb1071fb95114ffdd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "", + "out": "057eab8fa61c230967d95dfb7545570e341ae3c6737c7db2a227d90ff315d098d476f715779e6772b4ed37548266e6598c6f096913c2fdd8d6e44fe2b54d9780" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "", + "out": "ede68d1b13e7ef78d9c4ee10eceb1d2aeec3b8157fdb91418c2219f64149747017aca7d465b8b47ffa53644b8bc6da12dd45d1055e47b4d8390eb2bd602ba030" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "", + "out": "27f856e63eb94d08fbbe5022b0eddbc7d8db865ef4fec20586df3dd902a05b26359e267c788d7c88032e766b118740200f49cb4d6edb1561b2de7dc65ee6423b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "", + "out": "e9e98d6de0ef53fd2427661e1acf103d4caa4dc610036209ec997419c120631c2c094a8ee7822d43f8778011c603111f2628f897c9b431315477756b032e1f8d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "", + "out": "52eb1e6c8a54492ca760b56ca87da3e1a9a6d8a4219219351d18715a9a2c26708bb712cdac0434482e551cb09e3f16338de29be2c66740c344df5488c5c2bb26" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "", + "out": "473fa6c51a48105f721c5cb8dba61c64a1e3ddccc3250e682262f212c01ab4874aff688fea9637739e2a25d2ee88dbdcc4f04d01479b301717533a6432b850cd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "", + "out": "6b7660d410eae5f35ad0ae85e63da453ebb057e43f42e842cbf6250da67866b4240d57c83b771b0f70663e17fbd9087f76b4ce6bcd0b502e3374b1509bba55a8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "", + "out": "a4d08aca7a9ea6439999ea21e4cfe9869bb90e3a014871ad88ed3a97aa8915951c3fd0b3933a508588938af7544944ef43c440aa8ff1e5a818a466435de70fa8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "", + "out": "85e0e9b50d2db022c239d7232ae47c025922e4f07e2afc656cdc5553a27d95bfa58a574d4ec3a973281a8f4e46a71ab0341c2577287463e251044db2398d55e2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "", + "out": "81a0d02442905191163370ae29c7f89c0f48bc1a1eb2947047da1c622b8677e9ea9beced55d33adb1553bd584ad2f86a6207e84e40e4607e11650ee2879f4e0b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "", + "out": "87790df6cf7394451bcc730e53fc57be564522771e14432a80ab0b06b7b1d209ad698995125385db8b3c0959b8a5339eda0ae67859d847f44c81597272cbf195" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "", + "out": "cc064ea853dc0152cc03feb5fb5de78b9b88e96155d5358bce84a54c0e0c42fbda092f22d056df9993262e2ba44a5b2d53c3759d0945febaa6fd51b8ff38d839" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "", + "out": "7e517fc383ee8c9f0a01681d39e73beba5969595ce77927f91691f33bb3e1307ee03616c27e6795186f6940fedd9d5c7f21b6d2aaf70299cdd835125050a8b3c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "", + "out": "845fcfa67f6e065510d262f1dd6939ea4c0a4a59c8ee3977db7005e1aee420bd3f3826ecfe59015b4dfa0bd5bbf8d8a434485dc11cb9cc8597cb8c9566115f31" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "", + "out": "17cf2c23215bcdfc243d8a945f3c5c251d2718a3f75fed6f3320bcc6fd927386d56f8719cca02ec5e99cdac4ea1095b465ba9a298b1d238e38b3fa15e8b14ee4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "", + "out": "d789cec7d7520f10e8b8b6c8409589df57b856b8245568f64e2d2183e359a784c8d26cf9b720f5df567b01f3f48de64d4f0db156be525d7c7a665aadc591f0b6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "", + "out": "b5e246a9027710c0b055c71f1167e0ee36ebc432cf5d142775a7aecccea78325ed8c12f50fbe648addf059b8c02a61492f8357bee142e7f7de043378dbcf2d33" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "", + "out": "b523fd77ab9eee424872bc2e83fc0a77ff8a90c9a0ce9e8c87680a0f6286331f15c93a2afecf7566653f24d930c323192d3043b905721cbdb63111ca42f28f4e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "", + "out": "4359a45876bf6acc0aece7b9b4b4a838b9dba5776a3b14da2fba9102e78bf648ffb4d867bae85fd9b71312dc4602d0d49c907bb9289b2295961e54138123f54a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "", + "out": "d3f2c8e74f343a4e7190d475cf9af754eed5577262b35bd9a9c42b58ce88262e3114917fb9e683c62d9f8947b58a294da506fb86b3edf25cb9e2d2df611cd448" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "", + "out": "41b890f8e8450dadb6959accba194917e02f3067821d4e995a37ac18ba3e47c7506e7a3dd1e112e6ec41bef530851120894a7b34b3dbcdae407327f0c5736edf" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "", + "out": "19d7144f0c851eb8b053a3a43586526dc5c773e497975164d11151364368df24bc44d536072304d70631a840b636b966fd028f61062bfc5285670153a6363a0a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "", + "out": "c2184c1a81e983be2c96e4cfd65afbda1ac6ef35266ee4b3ab1fb03abaddfdd403fffcafb4ade0e92da382da8c40222e10e9fde856c51bdacde741a649f7335d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "", + "out": "488c0d652e42fd78ab3a2dc28cf3eb35fcddc8def7ead4817bffb64c1ae0f208f78cf40976f7e2a2cb2dd30f1c99130208ceb692c66880d9528cd6d38ad29db2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "", + "out": "515b65bf65688399575f0e0677bb6a919b66335546d6cae336f5c6feae5e2bf745e3a7b13c3205dd8b5b92cf053be969df7120fcef77e3895f560fd232fb8950" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "", + "out": "3fdbc7d69f4b53c225663da30d80f72e54281044a22b9882c6638f5526834bd31601ca5eb2cca4f5ffcf675dcbcfca60c8a3612d1aa9dab693b2356069603a0e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "", + "out": "4ff6c31a8fc001ac3b7ae020c5f7c45efb6271a2d7ccab8713e548b729f0fff9c82fd4db5cf65643d4076a3fb17b3e893c302dc75b6122ff8681d037120e276a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "", + "out": "43dff260dfef1cb2d61600e240aad6b720e5f4f83086e26a49a0ce3e0ca44b9a60fcf46a8c3f1bb1a6f5762b66513fe3f7c5b0bc150c08491acbc4361cabcfdf" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "", + "out": "b4dea94c9d3675be0512efdea8163870fe3425dcd761f363c43a0ca5716b76540663fb2be49e2db106485c9cdd3c164898a954b58748c42fea16a40fc453d210" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "", + "out": "e5277b6f93ea1de3e2d9fcd8c679793c6ccb8a3be26e8e3114f35da4f2ac014f55c2f15e09e94aa071298167a2fb9be311701ffba9d3eeff8ffc7993a3cece18" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "", + "out": "f095a7c6e2b91664734f3e23f18eb2ba9b00e71fbfcb9931c0a614792a9d8675622a874c1bf5241a2a8741ed1c893bdfa8e28c2e20bb1c58eb4de7d801116c78" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "", + "out": "dfa1fd803a1d4a3e661df01f4943ea66260a18fece134d62f97dacdb8b3bf9c800afe579cfd13fc0148bdefbff4e7683561c06a6f7225e4781993b4f4f2bcbfa" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "", + "out": "2b86ceb270f6908d8b160075ea7f57163af5d5c6f8aac52040cc687c17abf3c778c13906e0e6f29a6ab123deebce391f907d75d3a2cefa0efcb880a0e70d7196" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "", + "out": "32466bcbded538e568795430352536feb919bf4d97cc44ab1d805040f4bc4c2e7952721018958b4ee78303590ef6ac450df92ec77f477054bff867b88971d421" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "", + "out": "ea64b003a135766121cfbccbdc08dca2402926be78cea3d0a7253d9ec9e63b8acdd994559917e0e03b5e155f944d7198d99245a794ce19c9b4df4da4a3399334" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "", + "out": "05ad0f271faf7e361320518452813ff9fb9976ac378050b6eefb05f7867b577b8f14475794cff61b2bc062d346a7c65c6e0067c60a374af7940f10aa449d5fb9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "", + "out": "b545880294afa153f8b9f49c73d952b5d1228f1a1ab5ebcb05ff79e560c030f7500fe256a40b6a0e6cb3d42acd4b98595c5b51eaec5ad69cd40f1fc16d2d5f50" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "", + "out": "bbfb9477ec6a9f0c25405acd8a30d5dd7c73571f1d1a6e8ce72f8b9c941cf779b76403ac7f0450052584390a14eaa37c20b5bdb0381054a9a49534f81466ba9d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "", + "out": "c8287e933d9504bffd7be2ac022b32f3f46d87a7a0e79bb2a1cbaacc2e84cd70845d0d427848a6d788d39622e10f4342237eefa6d3c012dae96cc8a650cc2e30" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "", + "out": "c4596fcb0a28d24aad70cf1853ec29dac0fb202d8ec140da300088bb85b92c30291946ad307c096e3b2866335c9317afe28cadab5d62c354329c98d993c5be1c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "", + "out": "e88c38e67e8d19835808854670779eca60bad854c5778790a07254a30a14ae82b61bb16911fe57771d19e9b7f5023c0d4e8a8d372e3d85e43b03e5e00e6eba4b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "", + "out": "2d663e03e6f3552ccdfba496a14cc6224ceb1eb61aa265e6a7d4a26e54106104a96e330959f9713b3487c1b9497ccf82611dbfa34ff11d3133b5b5d1f1e4f8d0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "", + "out": "707d6a58421b8f7e44ff1f8362bc700f71ef7c3935e0764bd14d390c1c72792af9c2c02fb72a2b9d9a0729cb3e99626cf034df54b506b5b16464f475864f2590" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "", + "out": "9d88f8baa4eb0f9ab2292e4982ac80445358227d7f9ce7a4a629f180f7141e08fe6355c64521a69ba2bfbd1c4a3ea048d0bc8ab3701f30ea83fbe02474d892bf" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "", + "out": "65ea4db04a7581c18194a8921afdfa4f8d9af629ded2772c658e08485f67ad2ce21a98cd293ff28d4dfcdf658cdc7ae67027848e71ccc115a3ffbac4fa61bb73" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "", + "out": "0b4a68929e7f15ca91bb4439f2403702034cd4748e46927aba95cbef80048b25a675970fac33c874abd3d83aa0f37be2308310e8dd794f8192930ed56e70a8e4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "", + "out": "c1c5d8acfe3fde674edd3620157a8b6b4c8e67c6a7a9726741d9c305e2a52a8797fda0b2f13ac78734db2f4fc83ef32414d931ebaeaecd826d7c2be203bdc2d1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "", + "out": "2dadc8c9f7425a0114491287bdc68eae4fb6194d1a109db9b6e8a2ac94d4e440909985c4291fe89fd8281f8fcef6f6bc32550e53cb7a49428981e8d53cf5a212" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "", + "out": "e555f2a58acac5503f9e2d97b246872b4ca78bd56d47b765f052aab3dc77dbe993936f2252f0ab2e01fb087472ccb5a121ddffde531d3dc4022a7d1956ce0e20" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "", + "out": "9b4eae1295000aea7983ec3bcb4857cc7125fd7306787c63132473cfe8f4eb45318a60daad646d63a27c4b9d1f5073700a3057de22a7fdf09a87aac66ebe4758" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "", + "out": "9664acc2dc7298b9868db495eebc6b59657d139a6af060a72fb69124bdd3a6591888f0354f702b1b888684411058a3759f7fd37f06eafb3b58ecf26f4553be27" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "", + "out": "fc16e0925a35aad47ad69554b25796fcf9260cb50e6cc3747535559e99c85881c75889ac793ab78b88b05fb160895655e4d663a2a09ba9fa614a10c22947210d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "", + "out": "225e7341f857524f7890376c50e6354b16c1cdfbf58fe5f3a4039493b5dd408d79d48c56e1f89b687fbe3362a77fa75a54374b7a485e91b189af2e2f749e2adb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "", + "out": "a07a4c023ac704ce7c09dd6c92c6f184f53e8dd96fe3be9e93c39c534485b64b39d5be7f7b7170604de77ce5a437a98e712cc44f19e21d41f0e6e3ec1e00ac55" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "", + "out": "62858463582d22e68e5227bfbab540048f65edd6a6755f6fab53c025b663ca377a0ed5efd6af166ca55a9c733fca805ac4e409ca56177aa74940db9f40c3b9ff" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "", + "out": "a1ac539d1abbc2b096ffab813b64457fe6eb3b50fcd88953d0cd9f6502f689620ad442b5517090b50cffb958866d7c161d8a7d7560c893e1def6aec437ad6d06" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "", + "out": "b586b75da70f6cc0627ef3cf1237c94b12d0f74dcba26a9e7c7bc6c21a335337bf9f5b830c6324afa6ef649e95af8790875234c6e661d3f5e98ca012ae81488a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "", + "out": "5668a2982137cbc622ef8d06cf4e86168cdd4a899cd4462af6c3d415426156a5d8dd67c9604f31b57d6c9d597250457e4ab52a58115542acf27f925930f6a112" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "", + "out": "f2b1bd16d88e37f3a518d193ed061a1df7b443a18ce9f84445ef86effbdff16055023cd4e78d034de4032a77ddc1d34352fe617f825624459bc3269f704f345b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "", + "out": "f085f3d8bd138e0569243f74523e87ff376f04eabd5a2f6e53df3899000e2e94af0d2bc71c3f711025c538a6c8b10b0904dfc346adad7ef36b1ae88a6cfeabbd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "", + "out": "8291a4afd2e4b71661773a46b3d4455a8d33a726d9d3873083ab337020c27b4dd643e28c2fe47ab2fbf5d14081a3fc1c839b12ea31d13cf49eee97ef2ed7fa3e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "", + "out": "b126ae46a7a4595e31607ef807a5601f4ecd9e7d66c82daeb9715f8da1c17d7d71c3e68250c9dc01ac40a36d2e638bef3d7bc70ea2d0e331e3d33e1704eba92d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "", + "out": "63b14d8ed2479caa17c3e4cf203b233a7e373edb0c2f197129a9a36c5b3e1f3838f2e82ac2c2ad9d52b335790bff577304a378e38eb6bb4162030ce2a8ba293c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "", + "out": "34422a3229669928c490f57b8e768852e5b7c00dcad60b012a5db39a2d597c3d0a63be6a263ea53608b70692d78e1b427eacec01f4bee0bdbb8f0881488efc28" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "", + "out": "e26b7ed6b907b54ca26567f11ee5bb6d739a0008a53437ad7590a3134ceb95196e49b3443f324922517523c0cd5a00d77e4c4de7a0de968a84fb1b3be7b3b963" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "", + "out": "260197cafbf456b411fa26d383d64d61e81e5e52f84cd9d57386c776230c65a2681cd2fdfd28679f67fe1bd7469cf7269585fccbaecc22f503d6e3fc39301436" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "", + "out": "cbd5abe37bcc4f9a1270add0a5270f42839c7d249320d1f1d88553d05faf9a2679f49b49c9e20c1c85c629aa0f090cae8f6e32c6cad71721fd0623e4ed25b256" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "", + "out": "780e314fd697d2a97d221a22c39011e25069163cd08f0070d067e8cdb0bc8673fdb0ec4f46e31d748cd3bb3d61b9010a6612f341d471d9c5a2de6b6dd538a6b5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "", + "out": "408f16ce86f801d08bd051364b3ecd9a3945715888df4663219a190b3504e4618e7bf55171178b0400fbebfaa01f6eeab54ff5e31e6d7a55b84adb9e03df4836" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "", + "out": "0bf98869ec0580199ca3708ec9c42c376c5c36e0fb749242572398a0da57f98d1c4cd2963b37c3c65a10f106b56dcb96dcdd325796297adbf6ee6270edd4592a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "", + "out": "052c32984387b1930d3a96be72368535444f130757bf87e0762d8b1c4f6570f4dc674c4e6f5e21abd0b35e1ca19db840688d1b6e9ec91f3730e8b2880ec2c3df" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "", + "out": "4bb71409c15a0d3932c599ef0ff3eff5c7602d7000cda974082c4a4682249a19d43a5c14e0aeef897821056380aff275201d7459148496eae9420e718288b414" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "", + "out": "4795b251cc7b35e69692db7fb40efd34f294f51aec15d6c8673e59f204becf4cf9df849523f1db73be2a66c839d801974d433b47806701a163a794b26a846b06" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "", + "out": "dd50f965b60baf168f5ea05ac20b8a78f4475c18610b9d9fc2b7c3ad5c6f97a4cf5ea48ee40a3ca2293cc4214082cf0f8ec895553269e14da9bd1a196562ca59" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "", + "out": "e0b54b617f44922c7f61c6a54c98c61e932ded1fa9340266eea25f01e8180d1ddc6ad8dd6a0b8fab8c73aebb9773171bba04a781b11314d5a30a9d1c2812ca7c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "", + "out": "2dc4ad0689a4460b5b399e911bdb41586ac8ad367b7aa39e3eaec8899a2d3ce38e34ab4608234d75eb6737fe215824c2a97883596f6f18ddebbf1627ded91d84" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "", + "out": "f56a11cbbf8a997e1477ec76e53c894b148d6925a4336f0cb7aab9d802ac9b4536f480101f3f9a77eecdcbae7aa6ea447a85da90b501f7db2ef8ddf5de173363" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "", + "out": "6e171d196d0fc82fb473e29da8f40f37ee9741ac3eaf175dd49fdb56530db59898baf3cee72eef5e77276cadabcd752ca3a1b864c10ad28d27eaad86e3f21d33" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "", + "out": "952012330d92bb9c1892f25b7b5aa0fed3c0398a1708509a661474a3f5e511d09f21c30008002f1042d83d2f7b11336b8c2fe1d979c1e386e02097489b2dfcf5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "", + "out": "2dce47c33a7e7f215d34a5471bcd1110606c77138f19d41741ed5d1b89e8f7c774eec4bbc102766ea1532f2e43134ad366bdcc27d1a0cc959e1648659e44cbbe" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "", + "out": "7f0659597e7ad122d1c9ed91930b07de40e255201a33eb2b3181376e368df7764c0c14bf799f161b9b0079578b4709713e24e42fe7dd71b50943f440e23cd1be" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "", + "out": "1e66f7b358805dddffc582683e0bad818c873403d4ba1506b92fb320ca8cf9cee8154715d6db6f04093d4b3fd8a6fc8e7eddeaf2795b3d22de7c75ecff6f92af" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "", + "out": "1f60c18db168d90d2b4660e758a3cd28023d4c0b848b5e33ea5cc15629fd352eacb14f05fdec07ac23da9204745fa973c32955135f8ec7410a1cb53bc7580684" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "", + "out": "b9df57b345ee6f870ee0e63c558b81c1bc3842976fd3cfb1b53b766bf436d1d175f4d4c5f1bd8d7af65b5d18a72f9571f234701932afb7c3c94a8c8fa023db4f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "", + "out": "d8c82495a2b5f66451f8c5b2e8a17333c2be3220ce06a814c2cea95cc86592aa0215bf294614a328cf07222b73f93f242a948bcae9565fc97057b52e0280eb82" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "", + "out": "8134ce66d95c4088a566d4e43599069ad04553b0fea3d74819a6fd766f436742f6b6ecc8279398609f60b4e4bb44fd72cdfbff18d8038aa71230838b126bc300" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "", + "out": "3da89f5c52b052e042e5117b96806edb1c55227e8514b39e8b22bea4c9533080a4d7a92492b751769b0e119ef4db2bb88d5c1e75b4031074d7f21a78014a1f96" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "", + "out": "9bdcb469c2665dd84683e58101fdae5c88292a4e05c400ca0826da79382b8a2826ff24fcd556c9d5b5aa892f02b1670477279bd75f1b2b7b675efac380607036" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "", + "out": "6c77857b38533e414af7387c98568d71c8f0e35e22b02e2a1c0dc6d57e37d868725ad823586a0beef39889cc31f1f7fad0960a125e29dfea745512d179e5f589" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "", + "out": "88c9833a6d44fc25bb64f3e98e838fb4ff564896dcd3583a8b57c9466e740c628b2d26ea147cb31110fbadcf9d0108accebe04317d19fc0366de0c28a1a45e2a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "", + "out": "0aabb3a178464a0147645f05712a0a1555c5b9a3e999ab255aca35c50381f490551a408931aa6be9a4ef497a165b36663b1e1f05134802b178b7c70468cb98e8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "", + "out": "5850d893706b3bc2dbba9cfab028bed819a28311d2d6f0cd8e272ee677bc878a0ced6c0dea9e5cc94b2b4f591a40ec9fb18222d6deace1f9c083dc05de117a53" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "", + "out": "bee696a4764f9425d91b141738625a0447a822bba7a84778cc3a77a386cb182487db513bb8f36fc2f7e6d2896e4456a52346c4948e3ec634cbf18f39c446cbab" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "", + "out": "3d9f75d3e50d9ba3bcac4a4e116b9b308dc64599a3864a9dafd75cb71f2de3109f7956a7d2dd374f8406d77f796311e3d30089e54dd6ce8abb02a85a85ae92e4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "", + "out": "ef3951475a16df64983224046530dc7cb053d29394753911c4949950f23e8a92c709f46369b23a0d703a6f36490f75be1e3e8129a829f3dcd72d0e55497b8133" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "", + "out": "d4197d2a685bca6bfbdd0e3d84c748013548bc849fe649dae7c4a277fcbd8f818a9edfa6ca14d7feea726b23b4a33aa8a3f5a66167215c6148c06b94cd8bfe37" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "", + "out": "7a24403335b86410d8d693f163d6198a680f7e3ac025ec4474249b011677fe1c866aaf453db0e8f654335150863ace576650803191278e9d4b547a434c5654e2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "", + "out": "af07c67d58743aeb1850eb53b2da78ecf7095818325beb866ff313e394c007e0c0b5a1cd7ae6bb37cd2781b52d154d18865d5e37dbaa5f96739bf7695996ae30" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "", + "out": "28b3c260fa7f23b9ccadd615a11469498adb18d7a9f684fde435c06533f5f508b29b5ecd0ecd57369f22f1c54e61be6cd104c8f7d3e1847aad67073a4786e1db" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "", + "out": "d643233325239e2ebd411f0e002330562eb1bb08e68824b71b98199c76d53158d91ddd6f4f8261ec1d72fc77c2cc237eda15f0257cf07b84cf1fbd1dbafa1dfc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "", + "out": "3d7b44cc82efcafcaba6b1910548958c180a0e8d84bc663e8ef9533bd80c4bbaaa255b1981f756eb1079ad0f3471a1fc9d7a432339303a5781a34535309e5a24" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "", + "out": "eb0812c9670646d563198b117aafc56fa1b6560f88b5754ebfc31b355216d8d74d341e35b243bc938cf546af1f73c1b00455dc06b2c6c535279e8767498f14e6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "", + "out": "7bba7d7304021c75b5d6ce66b4efa55019d942d208afac8211aa7e5e111e27697670e4ec91ba308ebdfb19154c3bad0526a62541ae5d43d0f547b9d98e073660" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "", + "out": "a8e2a9468da3e3543a23a578780e2562c7ce57fd1120e1c024d7ea3290317046616e14cd0f15a86b9939549b147611b6a55d85abc25f639546b89dd23d39a985" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "", + "out": "ce874cd6e1958b9d7f11ff44ab0832e848702c8f26656ba10bf5720a7caa1f5908c99a9603a98b416c57228c819ceaf827013b2e6d6b2dae59dff104b902c31b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "", + "out": "30fffe37218db194b23273498f4544d38414bee41b1755a0c6c2dbcb411942d5ecb9d4523fb4794ba36e579af2f8dd851999233183fab27b47add87df35914bb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "", + "out": "cef4431dce9ff55a00300ec8649e27583618224369f60a5c896b2a3110b032b87c9ee4f26c5f0bdb503ea7447a5db3f707fe3410dacdd7572219bdea8e17dc04" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "", + "out": "8ff0bcb75f0061b5f909298f569e45c75ed2d64a8189cebd4e02566e1a1b8be53a783228558e28b5f87ccc2f428f7f879744b525b24962b3604b120f06779f2e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "", + "out": "7f8ddffb4dc15191de3ddbe4a0f88b7ab02d48e25cfc1fe91da557e885d012b8f65526c5b7b1013fc816585043a345605a39d8dad70d8a6448513250aac4f3d5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "", + "out": "b1fe8c68aef6b4d4b23354eb8c1d8f5a56e32e76b96ac8443b2ab835e4c8b674b33e4c6c6dc121d7c2d34b59b37a568a1c98d500324e53088785b6b0806347d1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "", + "out": "8e8734fcf9259ee37fe9c6cda282c2d5eb83d0cf439c8619d4b042ff69966b03565be4df96393fe6bf35afa16e0273b6d339c00995bf6f60a714ef180ebb9315" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "", + "out": "ae156d43a72c042942595878a783079760f521edb8b2c3d41a566b7cf74a4a08ea0f119d240a62ec73b9509788fa3aedf120ee88cb951b693f8f7caf8cba377f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "", + "out": "9330aaca8c08844658c29506b1c34272e2b3c7b4e75e6fe99a0107ec5da4530fb1c88caa66dd9c471e01ca21a13a5d6f8215ded3147e94de2088571fd1bf23b6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "", + "out": "c129f22c50f5997232e2b9f93dfaa00ad8a53429f9d15b9842e3ae08d849ebdd45238c85f92c6f917e0f8f6f94e234be076168e0df43d028455279a6ff65dc84" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "", + "out": "0e2b4bc2f6a75be4b7c9d4b53d104da065858d387b340bc1634f3a8332d54caa943024b213dc8d4f219ec8e1decac7d5c6ae69c9efd88149367838205d0dc7c0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "", + "out": "83b543853b8142a83beff0735f201891e7ffc67dbdcd21a422bb336de32972ae0392646f6827d80cda654fd3a0774cd2f995517cf064c617f21a54275fe50c8d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "", + "out": "09be15eb6a5c226f6d9508cba4a2519fba172af8375827d754a7a1bc1925d13f5e6343f3e14d08a06e8d37f8ec56fb438e623666b6fb0e23fb50477d411b0c3a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "", + "out": "c35797e9832d3e2323335b8c19c5fa7491602dbf6bea77faeec9510bc2e891c8c3462199f60418d2e0abffe31b613bb980ea32b76c82438d025f678caf4824a4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "", + "out": "cfc057fda78a50318f4978ffffaf771798e12c3ea8c798195bc5b4e6891e61aa25f7af4aa7286ac8507662c907ed913eda658f63fc47997c59b85970f878ca18" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "", + "out": "d8ebe0e638fc535b52cb0afce0f82dde285701aff329a54ba06dfd3d1b4b31f9f4b24d9d6836f1223d6de66bae7888febc2040cfe930e69ced59da6da8a0a6a6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "", + "out": "16b8c55cf2f135a432590d2d4cfa38592f5935f8e71ce08a0206a0e5abea90b2e107eb86b918823bdd3bd2660722c8dbfa66abb9f8638e463402f657a168640a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "", + "out": "6a6e89384f535f02176c48a993d3687b389bfc03050c777086355c1a55597742f0b74834a71d052ae8a83dc34a8fd7ba5aa69dbd612a4c22df4f74e2528fb7a3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "", + "out": "1e4038cfa50d8b13ef68bec3b0ffd562a07ad634b5828257dba87304f823a900492a3137198b605cc7f77c33b8ca3d940fd9b338cf6b7b36e7d9d927209793d0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "", + "out": "5ba6cd988ff9a4819142217ed65d437b413ba5026b554d8d94ea2702c096d1014775dba2cae96f1e2e7229c378f20b0389e119547fdd35224a617fcdcd0cb3af" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "", + "out": "2d20961230e250f81ddcd2d2ab3ef0dacf96851ebae5963447192cdb89e48e84f396ec9a09252784e173ada52a9c81acdab3d8d68380247ae975239b017dc1ce" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "", + "out": "35383ea7762b55310a7d57fbd5a54997579b0ba39a4eb887942bd14fd8483188e50048838d6c02dc758959a9f74d83372743e864c601ed7040a9e87152d4cffb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "", + "out": "0b223b6a1c2d3ab3f9077a317b7fe32f6f957b7b1741f2717771834d3796a19ba36273c9eed64c07fa4e9af7a98ace9c789a79a5a0f94d0405aaf04af31ed797" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "", + "out": "5a007f5895524a5e8037036e0f2639fda8c5c1512d76e9d19b3dd2d5ba43f5079741a458313c5e02400ce02cb65680be282eacd9a254ef1cddeebdcee85d4187" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "", + "out": "be4dd1ccbde1670004d0efab6543e91c4e4664e5a2a88bac6dd27d27648d302a065be6078b22e4c4ab4f7f7cbfafc1ad86ec2a504fe5851766f7a3244757cb6f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "", + "out": "0fb4483f9659296cb9245b57792a1e6a99f28790077287968ab3ef3589e6902406f1f39dcce0061dea940fc8c1c49f4b545eed59e96ddae96a6c35b5593c2977" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "", + "out": "41d1fadc60a46c9ad0120a3f54d005f5a1075e2f71ee0da618bac1461efae969eccd7aa575c4cdae971ded13ae13c506872cecb5b208fa72a94840023edb3efe" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "", + "out": "2f7fdc1da44b6e5d2decde821aaf4b49168c02e8d5f25d5c699871083aebd928b74dc22dcbedfaba9316aefca848d15f0517329903d34b8370ddf9bd58c6d0cd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "", + "out": "88558a464ee1a8803b2395af6a6490842b5cd43d41f6c07cd6c5f85f82f58432a0b162b438bf0cb7082a7673e287d6b90f8d0dc8aa5ceba36bfa77b15ba06916" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "", + "out": "ecc149917b266398b6f3297e969673b14eae69ce43671fd3c6c215c7cf42dea102fc6bd90c87dbd4290251129cc19b38ccf00cbdb16dd8de5158601a416b1f00" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "", + "out": "ed3012f89d71ed13bb8272ecdc3d0f51e14a37c1ef7757777ada6712784be16ecfd3e6405830f51db33dcb85529293e23e473abf8c5c7655d0c4f152d048bab2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "", + "out": "097a81191e1005676d6e22a96348fa4a7c9561fd4d228eb25f294756bb87a2ba88475b036f79fe373d7540870552001d54795f259239be6d32c487d1944f1fe7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "", + "out": "3fc798e469d39086ba0bb4063e805fdfb2208de499184173f9a2364d56bcd563ed619bb687322425014a1aad3bcf50d22d83a99d09730a92ec6546b3fc40a2c6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "", + "out": "6912b4b341c7dd70683738ba0e7debbabfca5f4fb0760c849776e920750bf13789a6999796234e9e240715b26767782b85a64d680c6d4cd426ad72b2fce081e8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "", + "out": "cecd140150157dc906c0ff7f87c0088f316480783b4fe0a5944510c64a87e3ed066797a27ce9d0f284dca518441808ac18290afdc031294b31aa8b4a9fcd78f8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "", + "out": "2a2bed5d6ac0892811a409d9f1ff6303ccf95544574699cda7f7350301f6d0c4e86e635c80875666e2bb3907510d0e72120f04865edc4c6ceecb4462d6af60fb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "", + "out": "0385ae9b735dc59f304d414ca043749ab51ab665ee01be5e52dcf725ee7dfefea6ad73f335eecf2a5102e88807fdc75ae6dc490d7b8b5f116303ef60a5f17c06" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "", + "out": "0ca3ff038965c03bc65bbe2d866ce9e0e4e7d03dc7f86ba5650f82ddb3a9aa846b2b1f553bd89fb4f9b62e3c7faf9ec3109fa90ee56c2463e6efd1abad8e28e6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "", + "out": "6dfd4f22184ed091fd5aba039fcd3db922f5e59bf838c037357fad934b4510603f43a7319fffa62386f8788fdf9ded40c666b4bdca86d9328fe55ad86b372fc8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "", + "out": "a318976102747d800f584df65bfb443b856f009e74f72946d0076cedac04376fab973453adadc310f72081cbba96264ffe2b21a3b18be9d88c4246cba6d30901" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "", + "out": "b5e6e4fca0cf9848a00589c65457db68b3253a6e17788541472e1fb94817f804054d07a5d32dfa0cdb6fb44eed50d20e5f2264361132fa5fcfd6e1b367c1be28" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "", + "out": "2ea457382925e03cf81110050e636ad678e0aa3cbc6900bdef278aaa18f235e25160a20e23fe0e62a8511b5dd0592f79cbc8eb7dea64ac8667494345c6892dd4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "", + "out": "96b3498bccd78b5a401b2738787d28a98a0edfdc7c0b5ff943cfe1b14e9cf5d9ed43107dfbdd9e9728d5fdd6f71fbc770eaddc4f2e409abe71927bae1f8f73d1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "", + "out": "ce1bfb9afed28af4dc7535adef71b8f1b80a8d7294b411fd1ed393cf232d3a5c5df23dbb1db26dddf6f745f8bc24c3781f2dbbc818a00ae1fb9d6463e95f2986" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "", + "out": "e64d37356b296b36930eabe454db11b2097b0c040bed5798878d38a8c4d1c6f3261f36bff764e3b4d606b317e5ff5004184592b0b7ddfb8c2fd8352326cdddb1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "", + "out": "85e6fe54e1e76046af68f5c6044c1e3fff3bfca0baecaef6a1df90350df2b0bec6a420ee8f49ad4464ec4c1e7d71f667614acebdada3df320779078323f6a8af" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "", + "out": "b12ff1eb3bab320d7855b549d72b724759916811cbcf3e1a12823f98b64ab5c45941610f6b471e35ff792829dd5ade5179125738f3f23728630f1eec57775a19" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "", + "out": "b4dbe72a1e21697a4744be65000cb1bad37ce21416ee6fcea84ebaf12a59c11d7c080df92fb2aa8f1c4ee8e2a22d30be498582d7c5fbba165a472689aff601b6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "", + "out": "348218be4de08dfb245bf25286e36618631d3bdb5827d9f74fa04301661131a4d55c7609b1a6a03b853f0733e0aec02616a0a40e8491f494d76c1543cfc68214" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "", + "out": "4287e19bab1d4f75e1d197cbb43f11331307f2f75b8d0d50278eec540999a009c03373529607fda605aa0f0739e20bd1fdaa27d7c0cdc8284d98e6c755a7562e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "", + "out": "08560c9988c8ce5a8876a600b6e512b4e243a4a4300ad5ab2ff0637cc56a0441645b3deb1684064ea43bae1cb62d3bc41537fe8d7deca7172937776bbed793a9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "", + "out": "b536162394776fa7dd5e9fdd01530fda52be1d39bd609b3f3bd0476b8160aa18ab2d37d2991628be2fcc1256cd485525d1fa356b04d30e4a0f9fffc9935cf432" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "", + "out": "02abc97175edb47a4cb4bd38d82f86aa099c8b8fa8ab3fe1ce105a22bd616578c6dd1515dfb0397e1d9d0671916de4b522e74e6375236893c8fda6d236bc8da1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "", + "out": "21e1eb731276a835a6ddea7178b23ebc9aecaabc7ccd706587d71b85449793b07e7b179a3da7a571982997e8f5a67f8c93daf11aaa23f07e4df7a13105a54209" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "", + "out": "1cc537d3e50ed9fdcdc4f3ccb4819375415304d8e5a6c05805b6b5d9e1fc18256864f10cd812f84801b8616a92b40795a155932464f62dbf6ebd2f9ac3ee2816" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "", + "out": "6f6cd26005c8a561cff51e301d1a068fc28b9b650ddd27ae97b522dae9639134d5a150587b0a901f3b9aabc7e39784984cc585235d8e17ce9e3b42105bf9034c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "", + "out": "69c17c2864c3379fafb714c0475e00cf7c9b377d57a8bc9698b4d34a54854176a2f8d15afb54775604787390d60074cd4bca6902ea23d3ae1ac083409fe38a4d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "", + "out": "8669b0ad35829edc2a8a09852b0ee9b3903bf6c1f82f90a3f0ed9524192f1091fd6484e04c3fea8b022f4a8950db17d4734145c0cec5dc387455c126903f7766" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "", + "out": "3f35c45d24fcfb4acca651076c08000e279ebbff37a1333ce19fd577202dbd24b58c514e36dd9ba64af4d78eea4e2dd13bc18d798887dd971376bcae0087e17e" +}, +{ + "hash": "blake2bp", + "in": "", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9d9461073e4eb640a255357b839f394b838c6ff57c9b686a3f76107c1066728f3c9956bd785cbc3bf79dc2ab578c5a0c063b9d9c405848de1dbe821cd05c940a" +}, +{ + "hash": "blake2bp", + "in": "00", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ff8e90a37b94623932c59f7559f26035029c376732cb14d41602001cbb73adb79293a2dbda5f60703025144d158e2735529596251c73c0345ca6fccb1fb1e97e" +}, +{ + "hash": "blake2bp", + "in": "0001", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d6220ca195a0f356a4795e071cee1f5412ecd95d8a5e01d7c2b86750ca53d7f64c29cbb3d289c6f4ecc6c01e3ca9338971170388e3e40228479006d1bbebad51" +}, +{ + "hash": "blake2bp", + "in": "000102", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "30302c3fc999065d10dc982c8feef41bbb6642718f624af6e3eabea083e7fe785340db4b0897efff39cee1dc1eb737cd1eea0fe75384984e7d8f446faa683b80" +}, +{ + "hash": "blake2bp", + "in": "00010203", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "32f398a60c1e53f1f81d6d8da2ec1175422d6b2cfa0c0e66d8c4e730b296a4b53e392e39859822a145ae5f1a24c27f55339e2b4b4458e8c5eb19aa14206427aa" +}, +{ + "hash": "blake2bp", + "in": "0001020304", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "236db933f18a9dbd4e50b729539065bda420df97ac780be43f59103c472e0bcca6d497389786af22ba9430b74d6f74b13f6f949e256a140aa34b47700b100343" +}, +{ + "hash": "blake2bp", + "in": "000102030405", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "238c9d080285e35435cb53155d9f792ca1bb27de4f9b6c8726e11c028e7b878733549112a328b50e8cd8ba2787217e46b8168d57113dd404d914e29a6a5470e6" +}, +{ + "hash": "blake2bp", + "in": "00010203040506", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9a021ebd504a97596d0e85048ae1da8999e3a047016f17c6c5556c2731e9b139261f843fad6bd43f7c7c587f698d69b682e568b442ac45889857b7690734cdbb" +}, +{ + "hash": "blake2bp", + "in": "0001020304050607", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3aba07ae980e338637479dca1e352800f4588e62d823365aa69c5b25fce12968d26c9bdbee9a32bffd42e6b22c8138a61c1fce49ffbc190e1e15160153ccb6b4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "774cdf9abb5081fe07eb5725e6069b8d6c7e6004a24d70f7dfabfc03825bbc3b30e620b6041f3cc2896b14ab660af72e249510ac2fe810cc7763a2e5c3fca7fc" +}, +{ + "hash": "blake2bp", + "in": "00010203040506070809", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9e089f51657b29c2668e2850524e53aeaaa7306f2ad5a232b5f07f688d8ab2b425df7ea5bd3e9ffd61683890151d78bb94031185aca481e2140fe37985367643" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b35bd54e4f81696b4f22316a1e337d98d1c6b06110998763b5913335923a4076cb80d6d8a518629113477b30a132a6b27fc1ee79f6b2e0d35d5bc29727463db5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "123930d5a4b73b491f50e56e2b7397a43d2e4787237602b66fe0a847bd13cbe8b37dc703d7b2b4eaa8bfb9a58a7d719c908f1966a2f19fe6eb1a78962afa5bf9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "089cbc7ee1b12c0cc9c83ff666fec8026bb71b9084979b0ea8b723bbbe8b00d41008b60499f24f241b63281fe5b4d88966309c0d7e64669105e51e69d7af8ce5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6b3c678947f61252657c354978c101b2fdd2729ec34927dd5eff0a7c0a865826e833c363232131b10593be1ccf6ba54ecc14312f45bffc2404629ff80267f094" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aa0c23ea1c6fe2e90a7718ef4aa4751ff6beb9d46163595b5d4fb89600525c5b6cf19ecdb2477872a7a12d40e5063608e5f0008e7972a9c01a4be2afe9532f9c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "63347ab4cbb6f28952992c079d18d42001b7f3a9d0fd90b0a4771f6972f0c53289c8aee143294b50c63412585cdce4ff7bed112cd03c9b1df3def0cc320d6b70" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2396c0cb9edaaca9d8b104652cb7f125f193551ae5d7bc9463307c9e69ca7da23a9fbcbcb86669d5ba63438593e132f992b57c0017c86ddb9b47286ef5b68718" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a94b802257fd031ee60f1be184383a76328539f9d8060872ef3573beb6f27368089590edbb21f4d8f181ba662075f91905974beeef1fc5cb9bcfb28aae1e4de3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "52c7d3399a038004bea52d3ea9e91e2544c8652ab8f5285c9d3218637a6d9fcaf0d965b3588ee6d73fa599deca1f41ded8025bf7768e0e200e8cd3ff868c3800" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b629f57162876adb8fa9572eba4e1ecd75a6567308de90dbb8ffde77de8213a4d7f7cb85ae1b71e6457bc4e89c0d9de241b6b9f374b734194db2b26702d7cb7c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011121314", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "722846ddacaa94fde6632a2dc7dc708bdf98311c9fb63c61e525fd4b0d87b6388b5af7042018ddca065e8a55bbfd68ee61fcd3c6878f5b09bcc27bed61dd93ed" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1ced6a0c789ddb295678ad43a322d896617fde275f138cccfb1326cd3f7609c2aaa5ec102697173e121ae163024f428c982835b4fa6da6d678aeb9ee106a3f6c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e869148c0545b3580e395afdc745cd243b6b5fe3b67e2943f6f8d9f24ffa40e881756e1c18d92f3ebe84559b57e2ee3a65d9ece04972b35d4c4ebe786c88da62" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f1011121314151617", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dada155e554232b16ecad931cb42e325b586dbf1cbd0ce381445166bd1bfa3324985e77c6f0d512a026e09d4861c3bb8529d7202eac1c0442744d37c7f5ab8af" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2d148c8e8f76faac6f7f01f2039ea02a42d9325794c2c7a00f83f4a7798afba993ff94911e098b001a0bdff4c85a2a6131e0cfe70f1d2e07af0209da7796091f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f10111213141516171819", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "99983a759ccf9cacae702dcbfcdf7204ddf0334bc65dad846f831f9f9d8a453f0d24935c4c657fff2ebbdbaf7bce6aacdbb8876f160459b1a4aac95697e00d98" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7e4a02126d7552f4c9b94d80e3cf7b897e0984e406f078135cf456c0d51e1391ff18a88f93122c832cac7d796a6b42519b1db4ead8f49840ceb552336b29de44" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d7e16fd159658ad7ee251e517dce5a29f46fd4b8d319db805fc25aa620350ff423ad8d0537cd2069432ebff29236f8c2a8a04d04b3b48c59a355fcc62d27f8ee" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0d4517d4f1d04730c6916918a04c9e90cca3ac1c63d645978a7f07039f9220647c25c04e85f6e2286d2e35460d0b2c1e25af9d3537ef33fd7fe51e2ba8764b36" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "56b72e5137c689b27366fb22c7c67544f6bce576194131c5bfab1cf93c2b51aaa303368aa844d58df0ee5d4e319fcd8effc602cee4351bd2f551430b9211e73c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f335cc22ffea5aa59cdfc8f50289cc92319b8b14408d7a5aa1232ae23aa1ea7f7748cfef032010f8626d9318edba98d416620335c901ed02eabd276a1b829c9d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a99a3d10f95b442ffff7c418fa949d4830869b0e60ec8b972c30a3169c27beb5cf330594f014b66b2200a7f086d2c2f3f9fd8532a5718876dfca661ba0f7b36d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "158e2570d084a4869d969343c010860717ff74116188175f2ed74cd578fa0d8091b03fad0c65cf59ab91dd73b37fe3f58a58e7b4479c875acd63ec525812353f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7c49501c5808b15c0d31bdd5bb5631d53ae00df431025fea51eb4762544efdee978a83508dea6bfd3b931a0e9583ccfc049ea84644705d319fdc5c163bf48224" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fef436b35f717d59aca17e9bf5ffda28f5f401943efe93eb580ffb98f13bea809469a344e782a443c64eb25ad09d8de205fee7d5639686a19e7c42b40f706a08" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4d47a67a5f8e17b722df9858aeb67b9956b45962ec353dc2e27f0f501c398e34397bebe02b54927e2d31f12ecf55e88269fab5370e7fa57035266f89d5c26441" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1b58dc7aac363b00446ea803bcd749c3f5cabeaaf223994c0c3ecc1b28477344d7bf97c08a959d1ac2060b47278986929188ad73de67078ba680963b9d3b12a4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3c522c843e6974ec750df220d41a004ac2adf09456fa787f7c6543ab17979c777b3e79d1787da5a83f178da9f04cf6f5b255ddcb1874841bbf7016e6132b998a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5a4feb8f7075b4dc9ca16c6f05cd6b7027485ffed9157d824d9d1a1720eeeeea3f6c125fda4ba4409d798049fd1882c690288f33547a3d8d6260b654548853d7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bcaa793632569e2f8417cc603253535bd7d85f38531992591e56c1a4b6f58ee7f818fae027888a86284305101ec04661f5995347a467ed8b9279f1acc2b4bb1f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "34af91cc22a69bcb55ddbf7f0f43ec564840433213ea55d9f81ac475208d74851db70fe496af9da1d393ecf878695dd33fd54349a6f824aeed183cb1b08c5485" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223242526272829", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b8b7ad2ea2b6fa06d00bcd599c9971c5b4e16558e15212c9bfd373e4bc7917052601ffdb6801be80ba509db82a0b7195929133ad539956065233f49d071c84e4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dcee9c45bc5d1fe630b18b063ce82c3857e30d20c64b5cc25884943e7ae94edff850eb0e8244023d3d07a8a00706f0582cc102b66c6dda86e8f2df325659886f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "04f6e822f17cc7a5946df80d958aef065d874916e103a6830c6e46b6055918180d1452293c58a9749cbc8f0ac408a9ca895761cfc451164641a179fb5cd8febc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "511fdb7c88268535e97e4ed892f3c065832b265914fc6107a1d27dbb7d51c37e95981506c1147244d5bae90ee90d084984baa7587f41ff6f4ba722c8b92aeb99" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2ba2bd17e926275b0683b236bfe37630266e37f4182f53a98234e915ab64c95996c6cb7ae880c3dfcb47d05aadd21abf8e40b73f40f398dc5b02141457456a09" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9b668d9b4447e376f6c6cfa68dbc79198381ab605f55d5a7ef683bced46f9afd3685411a66e2346f960777d0c922712430e018bfae8653017ea20ecd5f1f956c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5681024f538588a01b2c8394cae873c6d85d6aa06eddb3a502096fc082bb89cb241531b315750d31bb0b630128d19d11392bcf4b3478d523d7d213e4750f5592" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2aa91ba6de6017f1930fc7d96dccd670748b7eb1d094dfb4b3b1478a612ebf03ddd721279a266de38845e612c93098c2efff34fe500617205b1de2fea1d80246" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "824d89c0637ce178b630684c729e26653f34eac7e90412e963d3f19d6451e825852167c48df7cc55b257b250a70c7bccfa9aa15c188ac4637a522289c0876ad4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "87e4ae11da1a2ca8822ae330dc97ab2e47ff62323093c2b7a6c0e2c16821cd7cec92184df4bb6e2b626a4478039063afeeb0d287f24219207898cce7ade0639c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dd7f2f44a402a01e8216b103a4e7235c2830319d56af639f23c48c2759aba6eb5eeee38c298ebe4198267a00eb2a08d93a503703171c77333862101055bd7ad2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4cb846596193f7f278aaaac5ccffd5357ab0d1245f6979d141a471bdab55e238b1aed67b73399504b97df1a25eb6fe272b5cd496a7c8a060926e7404fda0790d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6f44ecdae14e3b81a1912203015f5918eac6fbf4966010f49d2bc2bcefe7b1dfec5c835d7d87a44371f15a6c084252b93465264272a410d50f89a117f31af463" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1f705f6e9f070d87fde8e2774674fa9bf120d288eb0be7aa128dfb5d1011ce1fda99b255226665d83f634e8fcabda9a23c03515e9cfece6e94a8ec92e4edecb7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f3031323334353637", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2d96c5b01574722b817feb486c5fc98f5f8461f4cee9905af206d4723386d1c4c7cac5840028d7afed0e38ad139628eb6af92b4b88ebf09b1fa047fbe10bc31d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "65da780a0a37479dd8f4d65564f9a7089e4207eb16aca3f65531cfee7625ba1380a497b62472fc7e0007a6b035610416a5f82c1082fa065c46ddee4940d1fc46" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233343536373839", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1c09a3b380b8a7fc333fd2714df7129b44a46768bacf0a67a38a47b3ab31f51b0533c2aa2b4b7bbb6ae5edf3dcb0ecc1a283e843f2907b341f179afd8b67da90" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "67888b83faafbb622934b8d55963e186153e5951887c7f4a7635c798d9a58294be26a3c549c9fd5986abd19f401ee24eda3602042ad383357a317d38073b38ce" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b4f79963ca31bb62265dd929af7d51272fa6631de7fa35f7a6b03f9fcfdb8e3b5bace33591b7ec2cfab49c91a6db1ff8f6786d08f44e8062d2ff696a7d984142" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "408483697bb6f9d011a1f29a23c278a81d37578dcccf423bdf489337f182eab79a50b05f3d2ccc491337c7e41f30793bd27d7661c2e304c946a5a401af8d946f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eeb5ade1ab97e7154343a46eb4cdd2a773f36301edc6a1bc1dd6480e08f58765cb938782923bc01f8e0c61c6be0dd1ab4c18cb15ed5210112405f1ea8f2e8c4e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "714ad185f1eec43f46b67e992d2d38bc3149e37da7b44748d4d14c161e0878020442149579a865d804b049cd0155ba983378757a1388301bdc0fae2ceaea07dd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "22b8249eaf722964ce424f71a74d038ff9b615fba5c7c22cb62797f5398224c3f072ebc1dacba32fc6f66360b3e1658d0fa0da1ed1c1da662a2037da823a3383" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b8e903e691b992782528f8db964d08e3baafbd08ba60c72aec0c28ec6bfeca4b2ec4c46f22bf621a5d74f75c0d29693e56c5c584f4399e942f3bd8d38613e639" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d5b466ff1fd68cfa8edf0b6802448f302dccdaf56628786b9da0f662fda690266bd40ab6f0bec043f10128b33d05db82d4ab268a4f91ac4286795fc0f7cb485c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0a1e8c0a8c48b84b71ba0fe56fa056098ca692e92f276e85b33826cd7875fcf88385131b43df74532eaa86cf171f5076e6d17b1c75fba1db001b6e66977cb8d7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "65aa1799143693abd9cb218d9b5ec60c0eddb067e6a32f76796010acb11ad0136ce49f976e74f895042f7cbf13fb73d19dc889d7e903469deb33731f2406b663" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "deb712b9cc64f58814860b51fa89ad8a926a6908c796de557f90cfadb0c62c07872f33fe184e5e212a3c5c37317418446efd95613f618a35f7d2789efe0d9660" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b42f4a40b3c88bcecfe328c846bf0648a16990ca539195c0c1dc8d70308067685af677ad65ac0c7a9bcfa8f7acc0aacf45ca18ac831fed644ec3d9283101ffef" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "edcf6c81ccf16e11ddf719a33dd0e5349cabac5cfae597009840e1c39362c0f11982fe2c2765859a94262da28dd3373d522693897511eba5e07b8bc6b6064dc0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "46b962d2283694d27975dcbf32564c9b04032b30a93e058fb77b2b718b4ad5fb789ab7d7aa90852da2bfb6b393b09f98e869b16e410e7de230b179f62eb57471" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "29036c3f5382e35de7a69fa7a63ec7bdcbc4e0cc5a7b6414cf44bf9a8383efb59723506f0d51ad50ac1eacf704308e8aecb966f6ac941db1cde4b59e84c1ebba" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40414243444546474849", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "173f8ab8933eb07cc5fd6e4bcebae1ff35c7879b938a5a1579ea02f383324886c70ed9109de1690b8ee801bc959b21d38117ebb84ab56f88f8a37262002dd98e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c6afa6a191931fd45c3badba726e68a9bc7388c8cf37adec7c64561cf481fd259a646c8bd843e7709e11e64dcfd5dfffed79235c689b4200fe7ac8dfdaddece0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a6dccd8c19266488bf77b9f24b9143def1fed61d0c60b5000a523f450da23d74e4e3f6ef04090d1066b6ace85abc0f030173f52817727c4e40432dd34c6ef9f0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aaf8908d546e4f1e314c00e9d2e8855cb256445aae3eca44238322aec74034a1458a293675dad949408de5554f22d73454f3f0709cbccc85cb053a6f503891a1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "525f4aab9c327d2a6a3c9df81fb7be97ee03e3f7ce33211c47788acd134640dd90ad74992d3dd6ac806350f3babc7fe198a61db32d4ad1d6569ae8413104dea4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2daccd88719d0a00b52c6eb79e1ca8b4a1b4b44ffa20889f2363ef5c0d737f1f81f50da1caac231d6fcb48895e7299b77af81f0aa4a7618ad24b7aafc8e3a2be" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7d286f1f721ec2d2115ef4ccd82858a4d512211355d4fc58e534bfa59c2e1bf552a96dc4b3e46b012865da88134cf04e731b1930759e158ff620b6ec5aafd012" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "21826b9529c4bc519147f5f9fe6db878345215e5094f4e99b131ed54e24953cee9adb718d1743e6c27fc94516a9922fb975a7816b8aab02112608c032bf138e3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c1689c698ab065f62eee65ddca676baa45b52f308afa804ab4aa6ab84b7ac1aa1dff07175610b12ae11f27b7c430afd57556bd181d02832cd8d0a5fdc3020124" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a1a6281747e34d3ede5e933401747ca7f76628b614c8a394f502562bfee0b994ecb65fbfe1ff7067dcb01d02a92ba462207587cef7dc2cfdb4584848ad55914a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0070a0190aa696572d853f1d24ab630848ac56ad5c2ebfcfde27d111cd55939c1e4d07872dde7ce78b534b530f0a396e86af9d575354b5d7e34acde18cc767ae" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "51b9b5ed193fd4b1a3a92b46bd4bd1f6ec6b38a60f2d0261d72abfd16436128dcbf22c25e3e3c43fe4d29db9124d033330184592d20c5b082c23206454cb3dd7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "578f242746914e36d0d9d4809689571216a43e4733323951620f5ee78ccfee919bf55f287b45a73d4485ac7422879239653b0591c36c866941f8affe4ae56e9e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "947130ef0b948ee04581aba3e2cc4cefc38ccedc861792b7b5dcd9d9361c724a122003bf796ce0979800adabc7456f173ae5269315afc01b606db29c7550e8ca" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f5051525354555657", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c852e677f77b14b585bd102a0f144243059dabec7cb01ffa61df19fce8ab436bf5e2d5c79aa2d7b677f6c375e9343d342e4ff4e3ab001bc7988c3c7a83ccb69f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "01197526917ac2c7bc539519e68bb2798135f6033ed58f5c451e0ce946aff0f98dfdd15101731ac166126eafb5e7cbe2e272ee233f34e5f3f8ea3d2d122482fb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f50515253545556575859", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "059c9085895eb718304e2dda78686bd95749815a5ee902510b009af69248b6a7a72ff8a628d81773e11d5a1e7f697a449b7a1e2712d5cfae7ab26507d1112918" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "295243bd758cf21c803125fcf321de5f97987c8db3bb3cb51ff97c4cdac9d3bf0a67cee7ed350a41fde6abcc254fbc9f8e6b3e3ccecbd0e4a640a20f362ba3a0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dd8232d2412cceecb5123191f6e9221e851ecce0faebf0505f2aeeff8a8c92d41dacf177bdae27763ea4a86205ef7634f7a687cc44bbbbdeee5e11e65f9fbd69" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b046b683716d31c914c70b10f7646da31efab2236347459cf8fa2c09123431f72807f11d867c3770b1f061d56ca0e5b1e88a6b44a33cf93e18bcc9cebba5ade7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "20e5a255058be51e1a629b4ebf81e5cbe0781cb67ca4e57ba86b308896bce73820eb08431ce8c9bc5810cc8d8b9c9d6fcf834e42ea33ef73cec47d713b6d8dfd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1e4804f9c0b1e82b9ed363bde44728acf7d090a1bfe2ddf8819d6592ef453b835bd2efe8b0206e29255b07fb90c7d30d2c114800b86cb0e3e07d387e98ce9537" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "41c953d8d22a86c3634df422b6de4a4f149666be8c4f581b2623ee65c392a5c32836639ef56b93686220f45ce65b4fa8589c9125641790b6925faad948b8be04" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8bfca4c8dfe3fde4257b75c3db01862ed31167de66c2e03a2556c4f46c9dffc1ac45f7bc59a67ab93624beb86ddd0d02603f0dcd0364f0f808819be96cd8d3b6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f6bf59d8d45a557111a236cbba52619ae3dfcc4316943843afd1281b28214a4a5e851ef8c54f505e3c4b600effbebb3eac17087f2227581263f17d7e5f68ea83" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1bc9ede4d41a4df6e8e6f47c2f4ad87337b69b19f710f766e1faf5aa05a43b6645396e7fbef43bb7795d39407b5815b92ecc23a6c1241421153a55d51f12bfd8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "76b38b3631555dbcfb21218ff9e412a229889ef2ce8ad705e90f96aabbd5be7e5329a426534c815a5653771318726641424e3b88292fb1d89544406ade9bccb5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e53f600740224e4d10d31d2438003143afdb436eb1791b150de35676f0e32f80b0b65f0acf481a5fbf9596c0cb0a27c7afc11d1e2c4d5402475e4ffcc1cda811" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6206b91fc0b6f1211e9fdecdc9d51a6f1eee6554b138adcd4a823df00ddef6759a9bfd7a4e981e045236838f4af693f69377931484b3e81e3e3bc2cb7ef79fe9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "76fd02dadd963bc035399146ce42988cc099d3cf4d32df5c0bbf64101246b1c708d167e29595d11d09b3f63486b40526ac1dfe31bc22dec70b745e90e2eaaf5a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f0a1fbe31163e421015072183d68ee5191a99cfda169ba5a1954c9f3107d4eca063e137a7114d397c9db672b9f478d41c34e991b0669a951539290c8ed65e46a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "13c72a6aa571b143dccf45adcd98eae699a154b110f25e7e9e82b765b9a08923688e8e0ff311a68a771e145096d60776c6d6ee70ad6f69fa2b7677634055a00e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60616263646566676869", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0e062bfe818ee10f33481dea43028b2cfbb49ec95e0f75a9e16d404bc519b9ad50b4a733692ca54efb680469ed83ddefbdddb139042e0e1c09c3eb7903fa08df" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "453be4aab9f423b33652a0b5d02a9af855dd0d42dd83110ba3bc4b3994ea3f885a71308975089b4903e2e4d6ba6dc2e84031ffe9c8563975c8616aca0742e829" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5361e3e893dd360bcbf51c793ec092a6b052054f5f000b9fce507b6645f8d47013a8706a58d4b10629cc82b8d2d796fdd37b608a587952d6553e01d1af0e04b8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "74b56739f01f8209a40444df4ccdeeea8f97e8e76efa3c04337f69945c4d44c085f1f4789696361e3c97774a935f860d674686dcba3d45ecd8639a64aea0621b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b4d31587b92b5361cdc2d3c41086c1553e7b55a1f61e94d2bc30bc251daf8a5ebfc50709cc04cbaf4b3b4da2d26b81238fba718fa91759b80bd3103aec11e06f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aaf6127f00a03d96406b9fb4ac70160db522429b5cd94e7fa0303a749478fe3189c8ea23930a66252a802674dcaf770046820dd964c66f0f54751a72f97d9c35" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2c30d48df9984e02f75a94549217184dd02aad3b57683d09b5a8c2ef53a96afb73feb6f914e2d815bb3b08654332fcfe79f80ec5f051da10d721413ddde8fa60" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "92e2c5f75d0ceafc818fa7935939e48b915941ef734d75270eb321ba2080ef6d255e90ef96c64cff1d8c18f33c2eab107fef53e0d8bb160516807480fcba5373" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6e03a91e20444627e3d2e22226cf470026694434ed6479828cb6dc8f27960aeee2f4ab872a5ca2f7f652f7dc77d5f96d85828b8f9c2d6c239e797724a13131b1" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ba432db0a331bb8c39b17bee34462b26ddb7ad91b6c75aec2765fbae3a0e60ec546d45f8e58437b9d77c3d2e8d7ce06973156651d408222aa290cb58cabc0ae5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "83a01e23ab277b1fc28cd8bb8da7e94c70f1dee32d1955cee250ee58419a1fee10a8991797ce3d209380ca9f989339e2d8a81c67d737d8288c7fae4602834a8b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0ea32172cc191dfc131cd88aa03ff4185c0bfa7b19111219eecb45b0ff604d3edb00550abba111522b77ae61c9a8d6e94fca9d96c38d6b7cce2752f0d0c37e78" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "54add6552b08858b23d6645f6ce79e92f38b66ae918677e6d91f7187c4160524dfa8d01f00ea93dd299f3cc40901bd3327a0f18ccd7b6b8e4e47cd28cf838fab" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ef84746dc20156b66ba5c78a50830abd2aef90e667b97eb52291bc869d8aa24559a142c68fea2ef32af22dfcea4c90b3d4908cc9ea5cfc4e91bf11ce6a7e5761" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5a1bf381a04119f942e463aba2b1643882468aecc1b1aa1e7bcaab3b478fc5f056f10da9037d40fa7f55708e103bda965e920cf67ce3adf7e200e861014decc6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "acf78aa3284596f330b7e84751b94c314cd8363627ba997881308578873759895d13dfffa5e574501361f043c74f57d2d0f15c7a41c7c45e3c09ad89d699a977" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f70717273747576777879", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "18b3e9043844d4f3a2d021f54c38facc364f84ba1058f21009fc371d2e4f38c727518aaba6a29e0fdae6e760a4f1a6d758ebe42c2afc9d2cdc6dd580778c4b32" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1896b2317033cf31046873d87f26e6a42a9d770bbaf6e062df11f9b4a0eab275aab12caac2d3f529eb20d070fd844d86d0a571cdf6285f80e2308bb82c6c5b3b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8c3dc40194aa021f3c4a1f9a055e4d419eb3a26d4c2f1a8c7e188b7348134080b63f6e570ad11c2878665355419c1020de4b655e7a6c2ccde9072cd427fe8c4e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "70ae0430d545ec427f8541211d4fe042b9823acec04b15c90b7f4b8bdd3dc7851990f370e7141675106649d39151090318231e4ded51225d9a6fa6c424695de2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "07336c42bd51490ef84dfbdfab7466f6b63999a5c08872dfeda0206fda80b9a62de728e3e3c3fd6b7d21a438aad1b8dd223863c0d26aca27790174d9d442a64c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7926708859e6e2ab68f604da69a9fb5087bb33f4e8d895730e301ab2d7df748b67df0b6b8622e52dd57d8d3ad87d5820d4ecfd24178b2d2b78d64f4fbd387582" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9280f4d1157032ab315c100d636283fbf4fba2fbad0f8bc020721d76bc1c8973ced28871cc907dab60e59756987b0e0f867fa2fe9d9041f2c9618074e44fe5e9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5530c2d59f144872e987e4e258a7d8c38ce844e2cc2eed940ffc683b498815e53adb1faaf568946122805ac3b8e2fed435fed6162e76f564e586ba464424e885" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "da850a2f54e9448917d0dcaa63937b95a4da1eac8af4ddf2113e5c8b0d4db2669af3c2acb0803d05323f3ec55abd33bdf9b2be890ee79e7f3fce4e198696a7a3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f16095dd9f1eeb77d5b92f4b1fac3a2c5da6ae5d0ab3f254e2a7fe52672411d01cfa6ac05bf39ef65f4b22264b41c3f363563abf0e924290c1c680b18aa65b44" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "76d00a09c5bdd39ed32871722cfa0047674bec8d35175af90d7ae9107440a2a0638856d8384c817d772a4a597a895549c84866375631cba042f0ef6ffeb89d44" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a651137b2c47fb7951e7bda71543a6ebc6242acab4347d388be8350f0c3fa3df8d952c7c8a3daf01e06c1da69496bba8de62d86b5093256f77a187b53db03988" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f32f150c2d67c0c437401b70f60b38f0a3a47059033e7505e69a1d301296030bc9b29519c7f8b7d59a71fab90557dc3dc823fac95b9e85e652528cbfb01b1178" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2702566136c492f41089b060108460fa3022c9c25d343bcbd8af2af19c17ef4ca9f2224fe7c4700a10198ee5248f300b548ebf5c8e7116320cc893ff7e231ffb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ffe6879f46b6292b2196972e3fdf4fe9ea4a816d1807a31caead6aac5f063c8fe877797559a759a00f8ba8f668d8968fb31d8a3b845735902c5e42e289ee0b62" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "144884286822c2512d61b046e674d86b264e9cc6893eff36731124f59d1a82001e63f3e8051cfe52e7597e28738e3c3a70f1bed9680e2c0ef3728b10a56ed987" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "17c3f146ee8dec3bafcb51c0da37f17871f234c4a0fb7fa6d0707a543e3cbf3adb81e30c1e0ae9e1ace7223bda99bd5919a3cfcc92c6a755e456f093823bd33e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1b837af233a8a68be70952f783c4961a8152d1e0b0fa325ff086ea5b5f1312b89c42e01b8c3a477cb540c06b2f37ee0e3924d745b4ff5c6af7d61e0e37ac1931" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7897880c1eb00fd2567ae8a59e6482afe17349cf93924a915f8c592693d452075519689dfcd293e376897b3b0e036f114fe81ebcb3153671bd23bc2bed46f9c2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ca7b6c775d201e5b5a772261de528e475f4bde517660529f41beeb1578b24bcb94b9410f9bf336c109f9d47093a10ba6debe504380d9d15073bdd111c8d129fa" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5718e0d45debc3002d52b22c527329ae5ebf27e8fa9c8feab46c40bc6422ca0335304cf9e7f141de7fa6adb6789bdbf38d14daba3e6297d25bf17de170d6e3c8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "48d0ed249f902841997c255daf99089c9a3124698b164a3028330fdd4cee41e1683fa4d9dc66b2a79c8aa4c8284e27bee2a428a6719d6ec655ed769dcb624e24" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "794e0b64ace1fe5ae379937068d82df04868616cae0c17d30572c2024e774894e0668c472d623c903cc5885f1784945110329eb498a895a9e59a75e527158a5c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2179aa820e03fa33d9bde5568c262e2d3417a402e07a591f9d5570682db5f9bba4bb9d5a82ee5efdb4f65bbbfeee2f4ab9e46cf2ce7e3b054327a718d3f10806" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b0a48c6ada548725799b5986bab4326979609224d897184b8997104e0c6a24b3abe562165422a45d8ac819b99d3756ebbb64f843e3e0934dec487aed12137279" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "848d7f2ead41291d0538680c649d07897e45c70a0aa4f9353f82c3f6fbb8e8489c753e90dbe8890041a1aeef84cd3136434f530e9dd9c23fa54fe124eafb72ad" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0ed14626ee6d0c8ed3f0c200c129850fff76318fffa1ddd7dd563a01b7779706862b239959b615ae2ebe27c45037e6ffaf9914da8ff2772ba5ee0811cd9ed532" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5203c07638c4b65f78431e8b02e20f6d683f19fa8f83b5134cd0f4e468c97eacb5267c7d3eab583ccaacd0dba4d58ace52193a5178a7b12d2795f5fde8a37bb9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "48be43d5e0043688df3532f7121afffa167dabe4a484fb75a03af304a5c6f825f36ceccbbbc075eef320c4cd8d7ef8cb49e6dd5973379eec4c233c4543d132ce" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b5464e6abaf5d3d4083d1d7d2a8b0bab78b61709500bbf77823f602d57d513ca9e9fff65efaa899cfe7bf88a0188829c24e498ad00235abe8eefa719fa6ae6f6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "afe5e5e83f19adad9e95903ea9b298107d37dd38632c9590bbffc624d4de958cb6b61af080f037ad17d035b6bf58f780fadf70f3c959668a1b472198a59a8a00" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "efa2c7c802e210d2d80fb350b3c2cb3156131811e718eee5c9c6640f87682a55812b10f40310baa7b82b273ef3acc55fede0b5f1949de4293d91b589a2175ff7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f90919293949596979899", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d6c62a618271f3bcbe007924a0c9812f8317445fb6fb19eb589a629f512fb38a0b4e247dea88c56a1baf17883365b436f28446ff66ea43180bd01eb5a6509bd5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0b41166be62f65e193b3b865e6c47aad260af5fceec9ab44abaa460a0c0246b6c69b67d71d3adfec60dc8e77372f094952344fe10c0d59efec0e11c4a516936d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "79d5f9ffc05ecf337de9f1e0f1d89b30acfebbb88a6935867818cd8d45da3d2518de61a7fe28751b618f7a875e11898fff74157ab90681bd53fa6962671ed99d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bea983d76f24b1eede1d06714805768faaad4708c9a4ff9cd2422f706b6f0c306d8b67f34089c65ed3880c75f67bbc4d89ad87120a77d0ffe436fb7b58b2ca41" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "466fd915efd950bc966578cd92c685929d7b51a63db142c7b9a93d16520495319b87f658e6afda1b42773e2d49da814594a5549089efb1f3ab5f1590ca0a02af" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f64611137ad2954670eaecd626d212cfc5b9f6bb41aaebb1d71e89792eb1317aedc63813fe63de401798df756ca1f22035a0fabd37fb1103437f891ead5e6429" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "32e1f938a27faad8ac4a13fd4f6a8bf3dabe4bc72af11c8f0e1a06567ed704b8e78e1140a0c7724e3efb70d23807cf38e627e326afc164cded52b44139ffb3f3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4833ac92e302ac2b67b02b8827143bada15ced220e1d1f5b71120c51ee54c19d301f2960bdb5a2ce27d441d14af080cb010a8a23eeff5811dfa44d1d7b358b48" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9a0388cee1ad0146177c48b5a08a2db3c489e84ce2aba8c645112a021e411cf829127fa2f1d1ae1baf3a33ea53098477a7d12ba748d2af24d16602e919077623" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e3df0074a93735130d9922d2be916f35343d988ce59d769715a983b4ba807ce1ee70a313e59231584f556ebba1b90b1bb6a6c581a4b47c3ff52189652aab36f5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9191cf461b6959bec93eae7fb1c6e37073d1a61527ad75d10b7f8949d9b8af70a23ad1312ed51f70f0e9df601ddae238906c0fe3f766b14f113b26bc8542d1d2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2a8bade272ee7ac643c5e37147faac92c3970bd3862f531e5dcea5ceacd1837453aa498d785b4d1f89e1b2a739ca4a384987302746b4f113424302c4a1e0f9df" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "323e6793c7dd9b4d7bb7fbf21531d37f7264532c58f1225548d06e6940c63e91270990e7f5643203c987647e5cf66103e79b714c581bd8772e19d0f005dc8633" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f922076d295d23e2985830aad2f23f652f7f4db42c119ed220a5451488a453f59fa8a2de2303000d6bfd8c4823a85fadb4fb8e7eac122bf01247d76f65247d45" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dc40009560959291558ebe072064ce6712c921b5409b44e04f9a565eeadd39a7716e21b46dd8616517a21a0c03419e94db820a353f152d108384be9470093f89" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7fa4be91ca5207ff087de92f1db09bf71a67878bed193a5c2cc4e35323b8df99a26ecb9888d7b34a739d641a0ecd0a6647a6a06426f3cc1fefdf9069922fae4c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bad3cd75905d7bfda3322b44a7d3588714d333ee86855a872747e704f6119484bdb7d077fa08edc4a79de0f43fca8d436e8a100857f59bc7b055b987f97ac6b9" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b7dee8e8339db297fdaa3ca5c1dc1988d97f5fb6208c64dea95e1c78f337ce20a2b4df17a7b8236a90d6286733163572c867d93de89ef62fa05dab707ec3a770" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a0f7e93cf32502b9fd79ec20546207f331c5299ecef350d66ea855c87fbddf18e691c20d045a308f83f6cb8fca69d7e2b39b34d2f877276c196bf514bac60270" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabac", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6f5093cfc88300bf688e884b4c5ec2c31a8cc28d6331ad7ca71d9760216482052815d44fc69e18a8dc8bd71b31f2b589a7c0780b6199385f8dae6c9b7974c4cb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacad", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3cff46ac3546f65ad7a720871afa20a9216dda5c45188156a5bbedf21546d4bb3940b21a41a39403e3cfd5e7a0e7904da95f4d8e0c5bf5b70eb029556efd497e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadae", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "af668a805e6d704b1e581f1e8e3c00cf4cf3e546147c406d17ca974d19a014c78b44e72ddeeb652607e86d690259dcab0dda81c77c7ee2721e82bbb13943071d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "79ddeb5c54ded1e4484071c46bb42802d23b3a08c12311be363c7c7a025a1764c8d85069fda8d517777d8dd809e3d4a956041a7079f9167b0fe9712e5f1229f5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "998e82f4263d53aedac939ebb6eb8b1969746cb815bd721f17a48bee9ecff2fe598c539c419a60e0d5a04f1cb523a2fd0538bb178e44758d3159ab9e028401a3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3396cfd5cde14aec1aaed3e12252cfd6e342ed255e8e9e1be10f1f273877f3633381e3c961e67ec41e8f9e16110fc03dde88bfc096fc1514461d70d0bece0af6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "777d9dc55a2f57a46ea06a2f4cb9760d00d7a862d0a2aa19467b570f7c7d5ea7629a95eb200e1f9db06610cf8e30d5e6ad0a7b632977fc21bb178967f3b0e09b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "32ee357fc91636a855ba01a0b8da6f3553b1d520adcfe8fe9debccb26c5c4ce8505bb1efb5ed5baa4c5245b50d74463f0767b2c783c47a93b0fda66895693ce6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "340c0a7ce496febda13fa2407a21dc19839bedae1a086ad0fed3917df9bf40944a787f641e90ddbae03a9337723e51668fb893772c0fbdb3eb7ef790dfcbb9ab" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d86a5baa3365abd8f442cd6ebb93113819f0b46061e13404efaa1a58e1ff272ad4bfd30815add88ad98fce9af018374ca60d89790f71a6075f3d68d32021a9eb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a67e6ec657c95eab3c3c32e41fbf39cf2033ab4be2e2b821104adbe69d16e948dce4c4c6a3cf2276901f7d4ffd69654649882c014d2c10a1302b79c61569cd36" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "55ce192ae4b3eaf855590e2d44e625d9ba146eb75048e6b56e025031efba0bda8aaafa0470b7ac3d406e5aba3e832f27a507246d1b5f33dea1f724e2b81b0c98" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b3a20c1fb0b4f0d37726c23b5877dd8e72f69886e09a8c68cfc301d2a3f2f95cefcfabb8889903c732f4e81432d3f678ccdfc398acd8a2f06641100450d89f32" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f7272d93c7012d38b27f0c9ae2017958bba666a9de1e8812e97437aeb2e03c999438f0be333d09addbcfaac7aa73f7b6ccec67dc077998dedb8c1332bac0fba8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9ba", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1fe7b3de34c0479ca8405f3cbcd2db64bb18dbb291a5feaa16c5228c93ee21c711d68a010c2ae88005ebac959e3a322452f862dde94bb941813e524d2347feee" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4ee1d38805c32284ecebe92e3df6cd98c7d6680eab0d68664f96706c45633b1e268222aa5a5279ef01fc285432abeed74ba3df189f50a989d58e7130622daa59" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0e1405871c87a5ea408342f39d3494f939f73c2260c2a43a5c9f1b57330cca4093fc1f42f96d83005677037db51aef26f05438057ae79ed14464fd8e57d15586" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "17c5cab4091073621b5c24c336316d0cf649ba1effebfc87e0439cdf578887b221656d339a6fd198abaee67ea188dd66567823fc220c52b57490251469d25d8c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "57dc2797d142681c94fe488626986ed4b26703cbf6bfe59391643657065b2d46e4b1ddb3aa832c9bd449755ac8b1bf936897fbc6ade378f2bd6493e486f42029" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4412dd6bed6db2a803c2e0df8f5829e7a4b0417889510df7dfee49574a71ec0d9e0d46065017c72dd9743933ca839a768dd15ab0b7c14c626a354109690196ae" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d0ebc771031b7c160021c9b6fbb2b670e3b40270026907a39163db1873ecc3b800111dd7bf138f83a610dc046da268b72b8c9086922377dbed73948243ca1e14" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "10c4ba315591698dfb91a57337631884b4738d9f59807851a679840cc287ace3011ccdc8f4a485bb1973404ef9ee9b9cf1eadbc54074c6d113de8fc91d0797eb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1464347be32c7959172b7472d11fe07844a52e2d3b2d058cc6bcc0a8a275d6b82b2d6263755eaf2a6588b6a1eb799af83a4ce753f8c75a2284d0285bab5f7c1c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f409231ed187f5c4e833fa9e3042aca6c858b08b496b2531f84fd5cea93ecd06dafe0a10c3ff2376c74dc80da07da01864fbf2685960b540b3a2e942cb8d909f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "395132c580c355b5b0e235336c8dc1085e595964043d389e081efe485ba4c63772db8d7e0f186c50982e1223ea785adc740b0cf218707458b8b8034042f923c2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f92abaca213229660649ef2d8f88115b5bed8ab5b9bca9a1b4c52457035310c41a6bea2b23b7918b5b8bf38b52eac6ff3b6213a522f381be7ff0906dba7bd00c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cbade7ad3b5dee0ff1a46b082cf4e1e1dc21620dd2cc0edc2c707a2162d2149969abbb29c5720b04bd1568a9556195e67f24322dd9aa4e8365191aa5b6c44579" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f51b4ae4d4c54a29cf7135a8fe1eabd5e1bcbf820896967dc41e3849dac22507694210ca11c4ebf1c29a8d4f71b30f76c9b6010ad95bdfb0de837925f0612597" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ce3872115d833b3456ca942e6e385f28a903beabfb753f8afccc12f2582ce1f36212bd05e05a46fc88d31950b4911ae5dcd8ff7a0b50474cb488ccf2a89cd0eb" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9bb74cbd47a624cbeafcc16d462947bbea1370b85c961a407df9863e54e6d9e6a8d2ef0c6497205e5eb7c3e59e698d992463ca9dd4cf28cf9a2d4e30c133e855" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9ca", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "729633820bf013d9d2bd373ccac7bc9f3716f69e16a44e949c7a9a93dca126bb1aa54e5e7040707f02876afd020af472639d49f5420d294c3aa31d067e3e8575" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "06861db307c678086e8b2aecdf1829d2883d28b731abd0f1e72f1ced6c7ad4172eca6322a83fb6a65afa37e94a3e2ba205b87bf382d91588497a4650883bd875" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "356eceaf1702b370f4aab8ea828486f33013f744b39e7ea26c6918d60e1abcf44fb16edca7720acfc6a701bf1e2c35ddbd695a8d408e8c9632e8cd27230cad8d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "489a39d0fc3cdeaf42892ed80385c11ce293c932215bb23188692a86e61bcad92c2a1d1142601b1bdf0982d1cd1e05c052de819e64f247db35915dd1db79a3b5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdce", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c02f464b4dd18117e30a8db8ef1da067134b604efa1951767ee632dc024d64c00f2449f042db3aea0174ebcdbb4ff59dae754f723946f1b90a77fd9523690b7b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fb31e6ddb86dbff372646d1e3a3f31dd61159fc393658c2ee957103bf2116bdef82c33e869f3c83ac3c2f6380cf692f7b1dcbae0bb227ad347e754137466c69f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "006062abe16c2fe79af88085e0b582b106e7f79f01a43946c78b19f9bdd725997636a332eb9a3aaa6de0d4a8e9e28e8c778774224c665bf7bc3644fce411228c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d44a6db3de9fd4e4a7ef155a01bccb91c1bcf1cb53225689a77a0d23b4d39a89a189f28980f91c56eac5879eae933ced7f267e2f7040eb380fdbbf34a6b7b615" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5afbfea1deda5aeab92e4d0c31d16a9a86bf7c7523274a05c50529f5c139db10933a52c6229cd31108f083fb0c85cf52831b5a05f2550a77b5703cc668912dbc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d17fcad4e0d8bde2edfda168ba47104bbca4d26da2d31a070b0fba0b26eedd95eec1fc34d76cd4a1cb15f2621688a9cc0e96358de993222bb3e3cd0bfdcb746c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bd6a59216337b45d6b71aeac01366bfe9660e0fbc2959adbb68d526c43d48ffffe2ffc430588e78e66546a3c709b0acea17cbc5a218c53cd47aa4871c1dd984a" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "83ea5ae1891145c41a7c6c87fe922487f5d282933569b7ae0e345653381ede6d4b16e144d1c3e8f0605daa0db5965a7b79d91a8afe11f1e0bc549ac074a01ab7" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "375050cf2e430d0e29875835208e8906d7052e47292c5a38a63082873d31d583135c07a20c52d95b2d5dc3eade6be143ca3438f44d020aae160ed77ab9884f7d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3028b0e824957ff3b305e97ff592aa8ef29b3bec1dc47b76133d103ffe3871bf0512a231afcb1df86597ec5e46e923c8b985c2850857c64001b2c551ea833d0e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "087ccb1e5bd17222b8af206dd63908f8917297621a8cb9330ae0ba4af3e9d60c98fcf1effcec20136b4f9188126dfa044e1c1ccda3ced87373d9379ccbedbdb3" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7f17062498bfa2bb5856cd0a62c568c5c6b897432474efb2e6a2ee18caffd21e1ef30d064723850f7990d21ba34e8f2b3bb067023a772782158a27c6c467c928" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9da", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6ba986a942497fd38462972f50a61968c0652dac56ce9b9ac1bc061ab634fe5a77acd0275f8396e3c0bef012ae93b72758b8d7679c87e847e63017b55a69c5c6" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "967c81f561951833fa566f6b36077eadb2a615cc15f0edbbae4f844ddc8e9c1fb83d31a93fcb1774d740d69208ca5930bcfac4a1f944469fefd19b6e9375e0b5" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e8aef178e6da3ef5caed6530f7eb25608256c2377c4cf96b0cfd0d76eeb4bb86eeff7b7df1585c8d7a20c0633a67907f6d2867c3264a91c051abae6eea5a91d8" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6481dcc8157ae628b5cd526bac8f933156dedac956a2b22a974bf5f7ec2db5806f53dd0e2dd53db87cd8f58a586f9b3c5c522331a31174c4e7b9b6f7f057c28f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcddde", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a71ea45ce6616a3d2f0a592d5d0286932da63c6db11d59c6691c35a56f7ee4f80b6fc340b4dbc1844c5040e668d2892f4a4ae8533f1b6771bcfce7c3a23e0d97" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9693448770feae421726eb203b01c70823d5f44cc5213e6a68284729bd117d9bd18fec4a0a824a24080f298bacd296d7b497838fbd7b0d575c52492b3e6f926b" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "37a15066f2b9f94c24611bc453ed0274078d1f70b2d34c8b963608489dcbe8df448edd9c73362bb2b66beef61fce60106f7019ed373c692259d9556a940b1a06" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bd44e739e1f9db1c6baf42ca4a12ac099b96f6b36c4bcb1b72eeff08a6496835ec65150be8fe16cbe32707e347547dc5a583d265746fa595c5e7730fcf24581e" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fab2038e9498a1c39e0578a0a5ea6b44f3c1b41ae567f9914a95b131c48d121ecacea895a09b1d4e0442bec9c50c50e00a9fafeffae070884c2625a8b1a21726" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "05a1b76b2fd56211e0f2d75a251654a772f55e18ca022af52cb330191e98a3b8eb87e5117bae58044d944c1f1885451225417735fc72f73936693cff45469f8c" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2a30c96bdac78a3994eecaa5a53f827f58e13231a0d113086c06b1bdabda38d08f1ae27de25fd22eea70c05f0132bf7a501c82ae6215bfef3c016398baf2cb62" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "48db53765b82bd6f2533eae17f6769d7a4e3b24374601cdd8ec0ca3aab3093fd2b992438460baf8da58fb9a89b2c58f968e63617cbeb1844b02d6a27c5b4ad41" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5c8b2e0e1b5c8f457d7f7bd9f05a97e58dda1d28db9f34d1ce732528f968bedd9e1cc9352d0a5df6672928bdd3ea6f5cb06077cf3ad3a76e29b22e82bac67b61" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5b7391aa52f276fab9c13877f12232708497fc028faa1732a5db079e7fe073ed0cc9529cfc863a4ecba4dc2f1ea9f6bd6904f3a0c107193c5e711cb911f38025" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1d5af70f09a5fc6916ef59a38a86926dcaae39a8954d73fc80a350751adda38c9d597506dc05e1ed37bd2db1590f99aa296aea13ab8443d5a92347fb85fc816d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "80e3709297d44114b9fbdf5567f05f330094cf09f4c0efcfac05095c3608107730c1aa07ff23002562c7e841a9f56624ffe2abec611eb9e73e1ccbd8f62b1149" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9ea", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f9945c190677846194132b496ec6012c08750e025fd552ed324d3a49d86366c03dccde8d5b5ac9a4bcb7195e63bcaa939e8eda18f11694b6fa6937393bffdbf4" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaeb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8d8f2ed9ae39809aacad2fcedbd2dca730c783e62ff70b8d3c5362f073f83467197d3756b445195fe752117364d92cf42c026e409d5ff7a9533eab78f1754a2d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebec", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3ac99ac53ac49a56faa18646b8e08a2d35be80df3efbbba6bda4ae902b8d3e170a7be8605c34a4dc9a7362b1c201d702391bd7d5207f95fa390ce33c4314d411" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebeced", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e4694bdb31016f25532c043c5c6308cc619b0f8716f0c29eeb9f340f47b07b4a4ce0984c4724b12ab3d32af516ada2644ca6558c1cb5815c1212a9b5fa834412" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedee", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c63c703e62108aa0edc683f3678a00788fb100c0960b4e98b76a48e4e5923d3413448db8875e3bcea7b6b85d9e3eeab72cd15096fbbb2cc4270317fc34d40471" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9080b7e841ef519c5417e690aaf4327907a83dbcb738d0f7308b1d611def169a4f47423e690f27a7e2741ae7865da23c5d3f13c316063c7aa1a958e5be838f04" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "298df646915f04d665e9675e6a1031870d28eb7a0405663eac3b10d1b4fa2e868e6373a586cd73e06d8e7ad771b4fb0a8b4fc2dc6ce09c642ee89926fdc65260" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4f2de9c4f4348bdb323a668372e7714299c776f9602f3af8fb7746f176868df3542b2fa69eae38b6a26a06ca8942f88278c64e3d017fee67a94ea023b2b5be5f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4018c5ee9093a681112f4ce193a1d65e0548725f96ae315387cd765c2b9c3068ae4cbe5cd5402c11c55a9d785ffdfc2bde6e7acf19617475dae0eb014456ce45" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6fce6675e86d7e85704c96c295703cd95498590e50764d23d7a7a3a32268a0b3c991e8f78487699a554b581e339c09aec982e0baa4318793620635e1e2c8d9f2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eba937859197c7fd412dbc9afc0d67cc198160b5a9ccee87c41a8664859f3efd961366a809c7c6bc6fa844926814e0b4efa37ede2c8844268d7f3556e446581d" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "83f433e4f1c50797493c58c264cffa70c4a7a24c334dbaa3c57489d970d49d6949fe45b704f265efd2aee1ac1b46f4aa3e4fad68b37961d2c7280ae19672c850" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b557ece12272493dc27e88a05adcd861875a0cd00bd68adc3a301d263a9cd993a96ae14cfcddcb997cc98623935050ea43552a341107187de75c4eded7c786bd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9589c0813b7393dbaaafe47af5b408b23c8a8c8bac62554b8fa132a358ce3083b1d4e39707cd54a55f673d48116eb1f9ed8de9c943cd2de460a68bddf71e9803" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ae4ccf27ab00a40c3637d3d2ce51a83efba62d4a6fdad695063fbc60a2d82ec5a54acbe09ba9388f49aac27c992d84632036e1bdd4c529bbf1851eae0c6ea902" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a3944b2c31cb494080b7ee1db0816853e425b54c48d631447ea52c1d2952079bd88fab9ed0b7d8c0baaf0c4eca1910db6f98534f0d42e5ebb6c0a75ef0d8b2c0" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fa", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cfa1a224685a5fb2010458201ceb0cda21c82b1602dc413585fbce80976f061c235b1367712498144ac16a9854f6fb323cbeb62369cf9b752b9252a2a7ace1fd" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafb", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fa62c6cfc8f079e58f3d3fefd7c224e71ebc69a95b1835ccc32f350777051102615492d67fb6de62cf2ad5b18467fe8715748882db89ff86efdf2f96f8135ed2" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfc", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cc633fd4ea6ac408c3875756b901288a1de191892832be2e9026dc65c2ff00009f1436ddff4206260a3d66ef6192143e572f1e4bb8e5a74b12055e42411c18bc" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfd", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "44d2bf7f3696b8933f255b9be1a4a6ae3316c25d0395f590b9b9898f127e40d3f4124d7bdbc8725f00b0d28150ff05b4a79e5e04e34a47e9087b3f79d413ab7f" +}, +{ + "hash": "blake2bp", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "96fbcbb60bd313b8845033e5bc058a38027438572d7e7957f3684f6268aadd3ad08d21767ed6878685331ba98571487e12470aad669326716e46667f69f8d7e8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "99" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "57d5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "72d07f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bdf28396" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "20e81fc0f3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "53d87da652c6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dea6abdba2b385" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e8ef785d84bed985" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8564786ae17558a034" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8fe7cf0bedfc5c8a25c4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ced64dbdb850b8d9238544" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a61e711081c80de67b0f5cd3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ca84913682c32af70a5a762e96" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b3051e87aeb0e2f29d4197ea1001" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f1db5e2f2bde30d08125a67d718b3a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "541e57a4988909ea2f81953f6ca1cb75" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "58910f890077e12ec101610597195ddc0e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "42a2b79173ee4f554baafe870efdd11d0bef" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ab2133a08e937af16b521a09a83c5b25fe39fb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "839d21a3030d13c2f59fea3634d8394cfa97c7d4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0a0eb5cddef7a827d7d3ba947e55c04d5d74ae4780" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5fbfa41a06fabac5349e39701e79be5ee7d74195ac94" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "58ff07c4812f286cfb69bae047742a1fe519c5a886f3a5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "653a88f2458217a42ebb0cff862076dfff08ebdcef917bd2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4f64ff718d4a02663a64d61ef7a3a0b8a9e0d201c310931f32" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5980b25c906286f0850b2349b0ab1b6fdff051aac85814648c64" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "89a4ae162416824f35ef116369d155b2d941df8a3d3f6dbba2279e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e72beb4a6524fdfe06fb519edd634e62bfac05dc26e73d7da4e6b105" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "34fdfab2a60eb77a4b30e0a14d1b90c4d3fed0284b6ca4503d1e87729d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f0fe72dcc5a7aa3cd3ba068e14395b1998db37f922593dd6f340b3831ce3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ca46fb7d84d726f5011c00c379ef2fb625151c0a1f416e62c9da2aa14c33cb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "91cab802b466092897c7639a02acf529ca61864e5e8c8e422b3a9381a95154d1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0253f5487d927a5d35d0089ad9cab2d7515b65d332e870c78d1229d1c584bec3d5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "38524415a7ecc9d09128cbd0999bb76847fc812148b5a432548e4e500720b356c803" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4607a9e4ac70b3b61c47c44f9e5d05450bc356f2a323a9d2d213525ef2ad2905f82f79" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c8ab4ac86f91ab339c79bec70920cdf382f7cffa279a80687a5c27cf691cc92777120c3e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "de63da44e818a837a9ccb7d339ae9e68bb4632eb34ad5dcc2223de7b8c1dca50a3739ff8ea" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ad5a3ff34c717f1ea06334e074e30b4c57053501566d4889beb32933bc6dabd01f74d17fd3ec" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "845a8fcb16cc5459868f5200a811f511c84caf7fd7f6de2010c162c1eaeca1f3f135b14c4de356" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5ee53a681ccf1bb9d65359e2dd5daa377ce9f54096678a67390c2c9db5e797eabe13fc0ca5d4037c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ed2230ff3817d2ba55e65dc137a3ea9865e436355ac542ca0ee71bfb70e0f48f61f5a0099dbb6df616" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "29be3322662c65b7cceecbdaf27e6f65f93cf41bf27fe5dc8c29891297892bdf1adc948026ef20b6c29c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "82c496d4ed8b6cca197c25bd2fc6924c35ae9a23fd555cf12456cb24850124b1b8dce9a1badf1983f16cc5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c80125ad9d202db1fcbd9a4c7ec3857eb5578b20ef54cf71197954a45df5b5d246bbcfac43f19ae3aaf7b212" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6d25dcdaba3b133747de6c4fae478a6feee65c70b6ca904768796aba08a056071d2853b8375cad2911fdfff20e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ce14b4f4f327941684be16178f86c3cc1382c326909d3577748c672d6a80253c7a563ff36c409d647997cf1039a6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "62c256d6561b46b0cc6567b188ce615aadeb4b51880e16f2a268cbe3eb37b97d1136089d892b5dda8f65d1e418eda9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "02a06f6949c942ddcd8a659faa3492a12f22ed44cfd58de5e4312ad33b1af337655d2b292f9e4802b5ea1ad0f2f9a2be" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c9eb45d0a7430548d96f1033a0e0c62e150c0a105b53de8b7288ec74349ed6d329b60abeb64053cbd13c97404f0b1a8a9b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "253d1710e74d36ee28918880220468da1be23678579bee544a671094dd05cdc658752585bdcb8d943c5dd008531ada11a813" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8ac3361542a33bd1ddbaa83ceb37113e391803b46824e91a81862f8867420b78dcadc8967ca6645084db367f811001471c17c0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cdc6b82553314ed27d442d6445a97667ec94337ee913d7a6f6f83ac197286e93ad455be6e5346a3369ed7a5c03152f4e452b1773" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "74d8b9c28a80e3d2f9add23c1700a0a8677c6833c969f8337375411d0f2514757bb6dddbcb1ace7e0046fe3668f941860c9f624811" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1a801c80e2e74bcccd583037b6b2228c8bca8444a3ce7d3c47aac3647842c204c1f3997e2f0f8b2b3d63b27a9f845e392bb273497dbf" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4641d3f104a6d384d04c7a92712c02a7c1df543cddd80ad88252113c155b344530fe1602f50f0325f61669daa4b7dbb6ed5e1e3229ff37" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b79a894d9e95b0d71b78810f7ad18fbeb4bd3d84843b585195e3cdee4021a9ba3f0e6e1b960356afcf607fe3b5eab448dcf512fc5b0929fb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3e89fd9a7daf87bc75088c756067afb8da003e746553603338e0ef5aadf804267448c74e8ad014cde658708e5707976e8311881bbdd2fd3415" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d74c6b60df37362d218396f411d1ee7d7e34cb502ea637e9c9c10523f8f687c13a9b32d704fd49045f22c1c4b9d0576b3eb51f5f2b2e234703a0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5e428a29f184b93022812c39485c770cde5c3b4596c0d4e714054187a4bab511193458f7b618d64e2debbd8d5b5680b602326ed760cc5d48c5fc84" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "04147c14a73752961ae870b0ab6c3704e29c8534be4b3063adbf1430eee5f144a57bd003afce1fc1fbf6f926a34c504203ecd113ca3f2de3744238a2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8f54504e449e743a4308fb215d250a08f0541d376f8bec5f4d7afb609326795416a168084f62c187eac40f036603e8426d306a05df36b5e91a1733813a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "76c564a9a5960016b9e588d4fcad94a4b9afe77172edeff7cfbc25b2d08277225fd50250a05a3281f677adfdd96777351bd895fd289137dffd8588907deb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "25981b7d6af3c87840639621acd46ce4bce8612fe7f081cca25b72a569c81c498606deaf781f89b07534625336563e19c6b2c467033bd04b55561251f8521a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "57aa5c761e7cfa573c48785109ad76445441de0ee0f9fe9dd4abb920b7cb5f608fc9a029f85ec478a130f194372b6112f5f2d10408e0d23f696cc9e313b7f1d3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "150a3e311efb3299d0b9ca333526bdb96a0584f00b52f4e723407cc332a9d5f0f64f426fec8717ae03eaebf1b52401956595bd6e56543a53517be104be99745e51" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6add9e23840ca283a12f0b695a39631e5e068c27abb35edf351b19e542ec30d956b3a978df34155941e11b8182f71a57f3f4edad8dc8913b3e3830989ebdcaaf3952" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9878a842d17d75bae411967da45e1e23c395a714192d424a4a082c5ffd8745c5d872a841d827865fd4586c668798117d65b293ed2950427610cb9c908bb961699a9585" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "65f1a8874e3563170d4f8c81a52fe1b27d5137056e95ff03ccc97a1c658f29fedf0f3debaa39452f14821b2ce06d349f89f6aec7340e79727dfe4609b7d08c1b5f3b591e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0d1d71883a5d82addb706c677a054c03be97972392fce88b9dfc676fe83662c2d8a310f1ea00acc7bf1303b324bccc7bd7c9b8ec0f0d3e33d6e31311ad96357b144078b0bb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b85aeb30fd301c182b980ec09dc99caf533e7ec86f35580004b6741aec28d4ca416d13eaaf1c87758f1eb3a70525932129f65528a790983b012a7620db68d7858b48f9e999d6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bc3c10e1a08de16ce26134f363843f9243caf3bd1dcf445cfca839ee55cb5ca5f8994acd13509609578dd39d6b3c89901bf129a5bff17ffa1bb506ad7f63d0c18a570b8953a488" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d37cb91bdca013430f38c914d1ef18b68dc38e5c6013cf8e357048df2c86261a0f3301bbe436362bd81059c1f315cff45a9091f1e1d84141f63ff92f2c56a6ba11fe3db17cff3377" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "52704d061557de8f2debc6cfb71616bd6ea10eef41523670f87e8f8acc673fd3100b063b95f8bca943b3eb98984f908142d6da9e040aaf93cd711191d00ac48fa56e4669d2e7e5b548" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2c0981b3580aed2add3f7c0167f04221b376819ff5406034a41c261ec5969ff248b7a0ce2a6c9f01f1ec80b7d98c148a3a9f842c626354576c9e6cd0588aa129cc9360e9aaa8d4c58bf4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1b9b51a0e20a02922fabb2a99f11c9ab0111ceda3e20433b25caf010190aba37789c996947cff081d0c6332bf2a780d90c1ccaaa05ebe9a2f186e30b210f9859ace8bc9fe84bb5aa512e8e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8489919afae8ad867c55bddcb43868a089cdb5ed7b8fe0a3dadddbd12cf6ac1d608741d76881c085b4542fb5e82959860b4d617fcff1e627cc89910a8d7cf848dd6b0b70c9870005b8be5ea7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2b820effcb8312b6c05f1013d61327f84c1f11c5b8834a7e59820bbb8ccf77990d0190fe70f62bed946605d82e66ed4c68236c9aa39d9a88fe668331dacc607a3dc4a30365e9a185bf294e94ce" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "481f56240d0aab02b669e7e595041ea59851a8372b375bd1131e39cbdcd76e73734dd5838ae8ae655c2ef513af9bce364b103911defd332da64a1fe9a11011195e4a71c11e8eb57d82d0457b0346" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b57d1fa9332b7a22fd6cb3348733c2883f4a99f4a6fe22239dea9320a458f062a391e240044d19105b81f3c08dc9ecc5a9f86bc884cc1bad649b9cd5ce12a1f0a73bcfb5c1c32dbcbd75a74f5df617" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f59fdea0a8b6b99202c455194f5bb65e56fb45d34500c37a7e73470bd1175714969b608cb7507e8fa1b9e39dc82b1582b3cd4b193e1f518f016a7251b6f52ff4b1d217758715b739eee27b1c9a2aed11" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "56fe4e7c41e9ff59c48b6200d17e6f9eb30b6d4d18154bab7db9aaf206b667e937cd3d4ae23916dfb9f1485ef68c1aef8fe7a661c6a5fb9cb8034364821641b6ee9d76bd4cc378a454435a98c71e47ef8f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c7233615cf8b9d6871fdd7c0024f5ef629e00b2e0c0a19abdcc7b789ff1493d187ebad63b651eca605f8295b29f01364422527a15176754c332f3cf566fd2fbcccfee0bb33d9305e7b8660f81f3e8f6d42ca" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c1bca6f43d40a287f596e4730e27fcf56ab9b841aef9e4daa4e244846f2036689cb319520b93a43aac9e9238ffc256f26e7e5860873cb3404417099eb8147a5e12a094c3d9a758ac989c0c2baeb1e719c2a432" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e3b82e4cceec32977767241c1b1e8504ba76018162de5cea14a19c5f06875a32fff9e53a047e68416b8dc6bcb9e991487b81b76e58428cb33f92f637965f9ee00ec57923019e702c7ba3a8b3c1b7049f3bccdeba" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1489fc59f0b16c2f6bf4a78b6cb71a4c12e0a9e02567edb6a14ec2dfc512687113a709d7e4457a8d03c9d3b1a6cd77a0d50ec5aaab94d48d366e976e7f3dec356ea32ec0561bea07ce8a4204911619ebe54152c73b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7cb2babff9c15db475ee00db87804d984fdc3be81272a60f8286b7ccfc4294841908c56c7268e80356b566582ba457614e392f58613c4059b184e085b0caf4e81aef8ab67a2220c068151ae100c9a323792d7f49e477" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "508f70ce1e4450291f690e2172944e5008dc6bfc494f891a8c79c012351ff160357b39c69027859bd0d6ca7d329ef4c5779e8f3cfd5921ce9c7170038821e4ff03f5279a01156299cc5227eb8a81cae310d4c7ca52e7cb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e534d9fd2632c0d64a3df145048bc674ea0f01af879a26f252a4b0cf406d8bc4c2f134a86443228b667ec1c0c1babb2b04775b064a3994965cd6080913036ed387483fc9295930fe9ebb1da87adcccbca8318fd2b1d14e29" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "deed43ef976409050873e966a722922bd2b61bf11cff0064b5458b9eaaf9bac20846b7f20606d84b0429bc1a0c00df5b742cec643d44659b3243cf42217e6abc84d01cd326139120f96c92f625a08dcdf193639bc5756e29f9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "00b322e73e6eae7de84425961f11b9736806bafaddf0495274552328c6b1dbc9c88227de05e8348c04b9fdd9e9898fe69065cad8f884e4bf1a2eb821ad0a3eb4b49cee2ef299a0051976b28af1d3d16777233b75db6b9004cdbc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9d3a5ca80e99eefe49eee987132c73bb973260869149ecf8b167a7a4424939f48c5acfce848232f49372aff6ff09908f943768a5b87bc30594ad6272f63b5ec2fb46e742700767d4663f82a1ac88e060ee87dd30ecc27115f52df1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e068a4c054cf8b757ac81d216c961f221276e1753148fc9202f83f258bd2877d192e324784fabe600a2dcb53996d67aee8ee9964b9020e2bf458daa4e9494a193f3446daf087899d71c52688a14c05f5ebb6811ca0fad85003aaefe2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0d4ea1a13a2cb5e403caf018e5c529dcf0fb8b1fa625e150fa46383c45fc25e51725e946f09b93877ae2058de3577e996637817a3332c46842089ceef2dc9a4f52f14edd2f10fe56d11477a4eb06e559d4636c4f06019be3911426d1b3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8de5e14a26cf4c758fd43b30b71fab2a77480ee98faccc95488849a49fb983362f883e5c75d6e6515063c15194f3fe9fada18b91b8ccf0b3ced07c410d8eda5f0956a1fe9340b5a3dacc10c2f1b5f4a9c751a65361f21273a11e571829cc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bfec8b58ee2e2e32008eb9d7d304914ea756ecb31879eb2318e066c182b0e77e6a518e366f345692e29f497515f799895983200f0d7dafa65c83a7506c03e8e5eee387cffdb27a0e6f5f3e9cb0ccbcfba827984586f608769f08f6b1a84872" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "291a233932dca80d3a4ff11f06c056b8c7e9de2a99c4c28c666965ef6c075b8d90017608ac7074b7e4831536f5811ccf97f47ec39660ee1de01e31161cbfaeb575a45413df6a9a69767763a4578c23d1d697d7b8673d2b2dabb05dbd506c7c62" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "967c76e3814a1a2fe4ab811b8e0ec56b54dd67f37947bc3554adcd143d8ff17f0f11b5736d512dd8966bad9c4e4c2aae5835ef5d0baff5c6a034e58e3eafacaaa0d0ba4489dd78f06449754b25688fd9e50a191bab8ca6dea5e59c08aa07f2947b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4ea13e136028596e6e0ffbcd2aa8f177d2e40abb7a5efc95a66b0113eab8eb48c7e0af7a7499eeb6e04b341a229f24fb5b9c6ab444288d32a9489e9c9abc6bbad1fcf406adeff9b14e29bc60dc0307094ad8e6b1b6151d7dc185c2a6b2f2c0465798" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "61aa1f4d4e2cdf23bd547f425b52cdac799ff437ea49adbd5a81f0801f640881a09569fbc8b6c91ea2c5538f518e054b5ea75dd074a8285b5869b109646408621b64f6a902ae061192f0dc25a172361508c945e218d1e42182abc21eab8d2b00c8e308" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5e3f0046de3d99d5de3d01ef2947b812714e09af342d9ea03311565a748ac0842540e0504aa8a54d4c7563bd8948d36177d88cc7b14777b2c7930252d4ec1c1a0fa0e21ff2889f41615c9b828b179c4778f314751cc58fbe386bb6cc48b1a729cafd9f2f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "37238968e530a2c072632186f8c54f271d15f43d2bb2a5541914a9d771a7d22a2e718992f74534da17f126e1616c39788bb4a8196e49da93ff4c6300b0d873de6b1effa0af995f534ff4c5c079324e66b18d3c2a87b632541a39c1353a6e2c0cf5b594d4e0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "88623f66c92f3993a309c6ecdafd29815c8b9ac1757290ca3a5f5694932e57acf70fdd83c595858b3331afae7de0884859ecf11b28f84ec8794fb16a136ae0cc9a4360f64a9dc6e8cc5160e8f11e2d2243e927e1479bae5afb82d192b44e59971357a5cb14ab" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e8b11e720b0870db776a8f682b85c865144ffae5a7ab7849bbd0cd9077e5f64d4ee4aec0b25d06ff5d2ad528b1248df90a3dc8cc189cec026b22910d57d756b12153362001920c3f82d102f910eafdd34b1a50e9b99b019107e764b5b8eeda5b465c755d684489" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "690501ac0b21e40128f36be64fd19919dbfb4e0edcf01df9a4d946f1660d3c81b896e77fdb74ef601e44b4af6e1a0f6aead0fca6328542dc7c99d230ca97b905bcbf2dbe0bbc6a73f062d555fe2579cd3e658ddb9a6959467f64fc02344e42cecbfe1c10740f3b6e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "672a69beeb960495361d80ce9bdc3c348b8a747ae83399cb648a720ab7596a8c2db14f924c0960355988189d6aa437e87c3ef3cf3a716d49a045a4fa8dcc7731925f1d5e66f8c0e644d9b4746f5f27d2361269c1313f8badcb38d74ece67d4de7dae120dd9f8291393" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "739c7ea259cebc61598b9630de10c1217eb32a1107933b8929ffbe71e664c266f5733b94843a57f92f57af363ff73ba91022d92183ea368ed26a7bb27162b66651ccb4c3fd417b0ed195d2b7f1323396c49d82f5fd17c60962f795705c3f8262cacff82a587d49c25b37" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fc80be54afb6a6dbfa21744fa588249e6532572e70236ccc6170f5abfee2e7806104f2ec507782d93efbe7b9f7b098588bfc2f62879df7b05929523015cd5720ef452c244ec212bd21ecc3e1a15932858dc6a55b6888947c067865f0c34f7e8b78b76c8f18c28e1a0b81d0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7dfa64ccdeec6811f6f67a899511d693b999cfafe705a9cdf0458273ad314d2580e01d6975a476beb67e9cffd48da875aa9faabc555968ce2f3ad0b1d9526c986b78fd86b8abc36e281de1e4258ba5521240ac7734990de7299e51063344d9bf9fc1a47d8a9b0c4b9243e7b8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c4d84255d5a7ebb77d632d59f998decbac3d031464653146adf5e78475910cc049fc0101fabed376bd8440bfdffd83d80c27081d531b9fcc3e732248dca2c3bf6007da725c0787ba07269b05034a953a2df682c962e1441c96024966ee6663853f8c3ac88e80bc6117b7f68483" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9003bcbe5e928e28827eeb435f311730e8ab0e7d1f2bb615f4258e591c625d28301ea72520079c40455a9464e4811599ceeedb913071f5c9c8b4486079108e0916282668799441c4901b72d5a57da1f72b65a1512a23c4c0c88857ada847d75c39f3e925100ef0bdde49f5127083" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1c1ce518a470f751be5abc5c95e797809b40c83f5002c69c3e34b2eb52e9eabd4202539d821e98e8510733e26dad712527ff04e17d37f9172c58e4af94524fdf0bdd55126cce429c7ec91293d073a4e3d33b33a8bb198b2bac7113799cac70df1d860db405b78a0bac420976a6f6d6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "23e5ac8c6331d772e7b2bdd3f0b6fe57df95bee52645013072f076835a3393547d454d67f3f228d1cc2d1e969a80879c241f68273477ae65a6cf6e5194e5ad6cdb2881b74fc0a3e31263669bf5f1fb70890c681c5e1d12eee43b44141e9b95d0180c11aa95c0e513a96861bc3944cc31" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "51f3254390ba613dad1b4288b6b40f8615e047e1ae85b7eca3d1e8fddddb5ef0555c1db8683fd889fc304c62c70eef2ea4c21c2192f6097a996d421b8b6f730cf829ac14f82b45c64c299831e8015039a10314896517297c4c48a91d0914a6da1eb7951e29d0ec63f3fde0c98e24bf7ab5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "75168cde1904184c2cc845ecdef73f69fa67a709cda969853fe8644c44cf8674f13c3a399509f1671568edeb936ef60a450c282aef04086bded69d0696df84b00c3d3477ad51d5483cdade2eddf8093de0aef19761f7af4f6182bf48e848b422088a22ab38eb331c8908a2ad28956e4824b2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d8f6542eaa90aebbc9d24c28e29c229ea4cc6a775aa8146e98cf6929160d90786fd1168e5e81aa91246e4175b06a383f3cf61a6d832b91c13ca2ebfd88f659e351da333fb25ded1fc44df314cb42897cb56ed6544fe556d4e6a658fead6154b3a1cae3e50be2c81f2f86a326515078fb8cc910" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2be8d7128e0200e78ccd7cf6e61a8786b62809b2a17fc3b333387b2205794fef2b6836b19eb9600b8de93aed934191b3e2c291954244d46e87774c465f96b46ff46093d66d6ca1ac4176e9e59c6ea649ea174ac197043f6b2b39ab3397218e78bc2bd79071bb4ab3532d304bac5c5e47730dec36" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "835a085c2f477b537c8d5ff4dd439f2794f8cb3bc1d787fe30b3ff9c590c3d3df6f4b903238c482c63e24b448fcb347b73821089496fd7587f4b9f23ef73c615060c9282fd67f8f012869ffebc12521cb745dc318b07b48dc02aa8b5a512aed4e346919b3ee4836cbdaffef1b3dabdb01bcc7eb636" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6c626640d1496181b0c161e28ccf741598e521d9187e8ac1a648bf7128dafea2562a6e9010f2dd8fbe561f158a0d1eed7c7f1ac2cd208b7cfa2c352939227a12da50018c54cc44a7146ac79d5d847897a69cd64e22f252abbb506d141d3a8393b38a3a3cd99096a3d10037de1feb6404b6c5072c3d98" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "295ccefe2bd4e68d533fe402c8e6477ad00a3cba55aa1c99b7a9bf31f0d021d761607d27312fb099784a456efbaad30fbddd354df45c328838c423f169888c3e7ac7dd9f9052ea356aa46171156ddc645dd2d9801aa23ca832c8a19c5c2fbef040b66fcc579bd73e92e0a1052519452392c94b50176012" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e635d9a82e5fa5af49561bae9abf31ce5c2fb85c1d3ed819f2aec39019bd637d66595ed7be4d1eec75d2f97ee0bf41b441624667e0e7a727e4aedb3c306c6903aba306b88074d2c9ae6787c14003fb76408efb90b0827538f5099ea35baf2a1d7c874ab38804efe51a925aa852a9b4e776e21fe913518afb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "92e056584b2767dc7a5f4f4d0837c034d962eb36e97a590fa3386b106a58e238842923b8e688d6034e7c1466cb26f2b09a5378117a8fbf3fc08398070fcb4ab8d0ca0b4ef197a4252ecb5eccca097d32cb036c8ece264a45f9f7d4b0ab945fd95286ed3714b9979b0575226fc52c979fc26cfa8d3d23e6b327" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d826daae45241b3e5b24e9049a4f86c454b50c5de06e2dc70605acc8da4712f9391ba7a8ea90449c368590881ddcdb2d37775004ca032aa8861453704c9afc42a77553d24f664db7798b25667e9b5e3d04287a35fd6e604feb70a2f8d03de083a364e7711687eddca8c3b73e0134b940b0a42f9631a74f39cf1f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8cf01578e2d2cf15680485db397ee230e4d04171c45fd8d0c65555128f6a13b8dd28cfd7d90807ff4f71ab9ef5384bc8160c49a23b19a541658d7b8f8c43aa98f09af0fc0668da332b1b8f9590a5a5b46fe9058bacf25157892705130d8004dde4eeab3255214776a2d9b2368755b20574b37524f15e300e0aa093" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "16ce0a26a1985633c5f9c653bf4da9853b301b08c321165e20ab38762efc7952352556f91d109779485cab6100294f3d59269b99082037fd5e48a125523c95d5ec4e8339d3eaccc67d9bf37c7e82c0962d72532b0448a4497d312524ee2f92b44a6763de12996164821f0f11db66031b1247cb4cc1dcfbc366b93c88" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b145e964233d8c74eded80b6c625de7efe274142c26ae9140a762bfbd31bf543eb8e52c65fe0c96dec46a02c08a8fac0aa564f0abdfe6ce629d5e191ea159165f351982d51f0d64ea434a1e7e789ffef38ecb8756485cbc2614de9b80e1172fd2c4be05ae5b7dc76182f8d9ba29106e5ed4f8d610c7708fc97eccade92" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c96773d31fb8c6f02fbf2a9f4f4ff74234e26808d7162678d25c931309209c3b568fc2c69b5d97a00ae7378702b344644fe9c4b0f9e44fe01ee219a3471866ee1fafa8b00265a10dccd1b3f676562ffe2fe43bee82c4f7b5ff5e04dfd4e23de75b6ee35dfaf01c716c0db1c848a781d04978bba749d347b6e85c5334b74a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "87776d4b3be82f3eef9a88f8135a005e4c8efb34d51d182efc358af1b4287b46c8c16a6307fc57dbdd7af3af57c3f3670a310e65c69ff7c91b2a75bfe622dc860cb6384459eafa243d0d6cc768add9bf5145e6ad393777d745f285ef4e96f2238da3f7416b049958cd55019850982843315038cb97f788be3aadbf283ef956" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4d1f33edc0d969128edb16e0756c5b1ef45caa7c23a2f3724dab70c8d068cfbfc4ee15ca2fa799b1eb286c2298036faec73d3cac41b950083e17ef20ddff9d55aa8b4d0365c6dd38d5ddea19ebfa2cb009dd5961320c547af20f96044f7a82a0919126466bad6f88f49b0342fd40f5c7b85206e77d26256c8b7ff4fedf36119b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9339bc4d2c29865f64d1b93b1e29314bc26b78d53b69873ef54205b3891155683f2d8199eb9c8bb37becb7ec02d126b730cc4310c9c70785fb819551beb509ec14f2f7cef1deb83a8c9fae4511f94d48ed38f8a444b73630cd433ed8e6022211286a2df8193dbaa1f57b38ff84d6ac2945a575dfd4804b538cbd33800f488f254a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c4018d36d2f84fe2e1f726181caf1952f3501b4b4ababe525c76d8436c9e79d18094a3f7726f3bdced6781f1626e90ee3b230bb4862e5497129bb58b40d6717c7f25ca7d96f80b1f37273105acc9dbd30f15fc0c5b81f465e2f596948a00aefb9d976eef60669e1770cdb6beabd2ba112622734c8659eb87f0aa08c034d462a0267d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "03a44e84603f79ebdeef6680447ded2bdd5a640549f4ed6cc493ddec1006d0535481417bb8ce221e1b3b2535cd0223630e2f96a8e47f44da8a998c2766be89b2e245033a1bf1fc15f506825964e6c6a9c6c5eebf06b1fec66b8322d1425755aabe7391ca9f5c59cfe0c14095036b141f864c01a5dff04b8fdfb7de2b88d6c31f8c684f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "181870851c94b7b02629c99ed1bdf55a20412534c5101918cdb36525364b1e7d0f7eb2b4f549be88bfec9eabe45be9e4bc3d8495258b83c6107c995c85e1f5ec84bbb8bd43f58ae98d13854ea7de75e51a5f73e24bff4e6dd850878b3b7f8948ff99924b9706bec23fa613634abe2191023d01d463ea7f6f4019f1eb4af6e74832008e69" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9b8d7205ace31b13e544de5f65ec17fa2ce350c8bd32e68aea7b22cfdba9e0181b8db8dc961a279f3441e2f86543e0ef8de65b89d28eeac748fb65a2b5c13466ca94fd45c425f8146c4fa12c6705e6230b0a0ea060fafeeb43907087682d26a465fcf7f21ac52f1351f73b45d75ece0680d27db1be924af3a92adc38a9efec2963b6882b8b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "60ddbc9c10494d540b04627b30dbceefa1331bfed86ea30407c99fb18a50f5afe58a7f73544f6c70b3034825111fdd139dfc3e0c3c00ee2f1960fee71284332f727efa6187a4d131d4271e23948a2c2092b24fc0b366ecb11ab464bc85e2c779fd3d9f2b68e62ee59d9b86debfdd96cac33b2628a5a966c26b0602e242ed4053737a3db0e83d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "27e3bca4fccfae88c9a7a7f43c0b72a302b626cdf32eb70122e9cdbc100be2d29d945098f5d74354b4f90a66e938ed6eea3ed9cadc24a1b08d12e731150b327f0f53ad43fdaa9ba76785c03fcb9b2995cc2ea67009a0ce10e92f9ed9fab54c09b3f90b0fb9db2545edb9088f93a547333fff31dec6000120914baf6b6ad7feba9ceee614beed11" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "71028d445c4d77fa30c5c58057b4d233ad2e12ee640d484177e20c635fd1ebc150d1a3e4d855b7910623492a6828c215d5d1a9f39a4ff3f4e6c98c98068fb1f3b4ce319658fdc764854b95928bf0315a81a0f0a022b3d2bd285f22b16b1613b52590399f1b993589ff2f8997c4d9eabda69c9f3b8a925ac9b4942b380c6fe0ccc95f1b4e3d8cf336" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8533108fe06b8ffadb5b8618d03486db657bc32221488b7b629d6ea2e24c1e1de3755edb971c1db135bb38e0cc943bc2b3aae2369b3019b98b5a92dbe122b35dfbef0620685d5a808f21c31704e7296f207dfda914fad3a903d8142c623a83a0f55dbd0313bbca2c2831c8e4f02b10bef62ef321644836b3b5224a0eb68e84f25742450b10f9c59bed" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "45a62940d954283daa40a17b89a8d89f383ecd3a888d009b31d96f48bb5a656e4d6870062b41ff33d0b7dc7893b3a480f2d2c4c909b18d50365451e7e56c6305d26e357cf51665bda819c1f64b59dfe87123755523ff969934f5900d2f5e69da3189c118ac2bc1c0438f14b1a37d2227801ac6895a3c54dbab0faf77e9b1b8eea879c9dcbfbb7dbcfaef" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "03f992e29cff3059d46ae559186581b67954e6efa73d7a8aa26ed3e453828c3e8ca5031a988dbd680648f5775b0484a09d0ec953c49c3f44bbeeafec5d7c0820e6c04cabab144d66e2076f1dc8ffda96fdd292edad65a671c440a2810bd0c86e9608173ebde1d193f2fc738e1482cabea306208b9eae348113be4855d5aa322ea604597cc0793488b65cea" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f3a30064a77618fcb495df57dd45d498e7fc9edf91e6c41fb76ab296201f6b9eecff62f5a3aa6309e38d02bff0548238dc7a54bb1c51f89500c8cd07bb8da92a7659cfb12b175f6417eff25d811c930b029c543c4cd0f849e77cacf476f3bc690a169e1dbc5a60c407cf206074980d265a44231a9afe10aa679b542f63397019011e6fdc0316f658dd10a4d6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ab3cfed6234f8bba8918664f83d266b3876ad57575032b3260c3cbba740ef1530db08f0f5e9f1718d5bf1f177922407ed746455736f21016994e0b447258234921f0f373974ba0e17f04f0aabdf7e7a33d180e474fb259191450ba590e225e9d7fcdd7fa5d4b3eea4f836444e31ecea28727d215709ba33bf6f2fe31305689600a314dffc81f99afdc1f63010f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fcc8d836915a460569d081121755425439a95a85f635b8b1087b55abf43c1ae3af7350de02a0d11443315e5b46cd2dc135c5a2522801ced212bbe05c7c595ce3cf30b9bca9a34082b270b42c02b12e3c570524a9f7724ff0adfb2a134cfc70b6da98c375f197cd1a0f56c792695a88272ab3c30fbc3d46cd391303812e3db840e594f59b25e21007fbb7e259ad2c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7664b3954ecad281dc23e0dac62536a4512076afd536addfc74d2ccf9742e80abd6a45dbdecccbb951e41b5f9dc4b5c10fa2734a0ff4b247f237950367a3e2f1ee00f75813eb6c3d6da4383ab908333fc123d5570a43319587d9625516122104e5691a7c6e9244ab7785846e13da5bd0e15568eea2d491cf202a0253a25209389b27c817c22c5ff3da99520cd71290" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ed5ee508aab550984e5c58cbdefab0b5161a4455f2d4eb0cfb633dc2fe88144504e294af91dc830604a0c6be4583b97d054fd2d11c431292e52e559206bac1a447b4267a93740c7fc50973a6569772589286593164262056ddd60e6cde4fcd7798cfcbe4761ceed93c68f9075c6f1d5ded991974c2c75a8057eeeb73eeb07de5dfdfde32af4f69fa1476209f38003cdc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5a1c93e287f1e01a6e832e7c0c23522db04758c67faf12f8900cbfdf48cd62fdd0e5f1c1de85c921104164e35ff970ae0f047ec1ffdc84934cb869d4f944cbe010061b6e1f04fcc67eb1fe73a267c9e2cc784937b70ccc9bc210ce12c52c1a4c6e944d212d8a7789f7fb28e0633f299bfbb69bc967a464cf18610c695029f14a9049fafd3d876b68c9e3abdb4f829ee2cb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "70de86a6b3d9cd1d9b61084e7008b948afa2beda8e6171618260533d5f55bde09d454add55d6c6419467a57e48fa5ff16ffe852d5d650659310e3d56da10d0bea2d3ca1ed3557ea2ee5cd9a1067f3415a628aa0c174234ae0636e662b51bf5d1d0d066f5900e7464ab741bc69d3fec621dc610748271a672862aaf3c553fe4ca2ed9ba4f57f1e27953e3167fd1d9c3e4c30e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2bb9490c3f07c77e4cc4db3b10e57e6606920d0ae01bf3a7b68a3d29b327ba9f5d7389fb0636d1494c3cb95d27122cfbcd9ae960fa0fadcbb123927f93599a24be52a01be80f5763597b8c52268ae553f5f6a90894573cd0a8876ee1035a65ff5a739c8abd8f115cab980d369d68b266b7a34d75f9c18b2efe3742e3e398ab6c70448f670354a8b486fa916bbff492fc98daab" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "deaf859404fc6e48c66cff9bc437eed861b45dabdbe625af4a82353f426a040050ed9235c0798a40930714df30bb796b64e9ad0df4350e196390aba4b0a10a6cae34007414a5880c5c2ce672c2b36a0e7d2622d677b74348ce07eb3cbb1c5a9c568063d8da555a64a0ba4b126a0e9d9f9ccde4cfca6d206f54c022f7518b8dda9d26d31a7dc9a2afcc3abf70ee5b0fcef9bf669f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f875ef68c13c5a982637b84eb21a11e6f57ffab07bbc11e5326fea005326cb27c6f70e99347d5bf3b303639c260193c1b7d15de51da7e661e2ee4d08d5022d918d0bf1f3a4572d8003a8a4afb821f6dd03c2bc189391f25b2e425b743282f1371d209b61cce95092a2aedfabcc842fcfdef7a0b33473992e13fe0d6da31b41976597aebd26657407ede2d7c51ab1dfad8d44e66b86" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9f46e27edb697d90398d02620b06ac8d49a3f66f0cfb02b9c628e70bfa0bda51eb024376fbcec59d8517f1e896557349d22ec78038b66a9a16460b8941005336bff96caa32e195abded0d31de0f4c8ab234d994979dc2b53476460abf5136b6b7fe6489793c14c48daab353208e150c43f7b1c7d659d6f8b5bf2fc3663335495e9aa47537afa5b5173aebde200f26705b6f1f3efc4be" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "35a3235938ed1312e8d79120615daa622cb5d24bb84efaa84dfd8daad79311ce6ebd52af7c8ea8dfc3ab72f49ede51d5b62f538e6cc84127a0eefa20c558961c644ea09c913cfc8550173109deb8554e0a418351073d5bda8f13cecdc71f32efa4e8c96ff5b30f663c7a4112f4b6b6afd6ab8daba9e2c7ac604a7e4b00cb52cce8ed10bca0cd6a6d1842b59867ca9e7f36ad678d28ec5a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b3a70cd849fb5978199d363881831cc9df46c940d405360faa294e36e8ebcbbfdd8a672dca3b3195eb86b1a0817e537f853ee599ef3058692bcf5dcccd37118fdd42d50c524bc96ba7c6d2deedfe062a32b7ac93a20a8bd3ef20fb7a1766db25313390838e6a08e01cc932dc8b4410efdbb02aa4d53cd88d1b5fa0ba564b6e764aa417833f52e0a3ac46b42f4da1ddce5a35e070e0e02343" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "090c351eadfa98ea2843c39c0f1f6c6bc1800cf17359ae22e7a8a24960ddf137666e1cb45eaa675bd01175e81110f54c775ba952e3de3784987c96b92bd9fd349c7f120de13553366f621e7437a08e374612dae5f9f2cf9081c6761bf287c7a3af39963f06a345f1a8f7a8b04d360836f172bcc2f4b3aa2c6754a60b1bd49d42747561b3fef35501581f606777e6530c446daa462a4f7ccf83" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "01cba0c30285c6963c3bd9455713eb330bb887289c2a71ef7755e64cc0067810f120a1becf6a0dd45eb8c31ddb2befae75bbe7b4fa7dca9417455b92b6adb7118a36bed55b379f66d9bf4423ec928f14ff644019a6b9bbef69cc013f717b9a385ada55c87c06dd6b3474020edeef23188d0ccbc5d758e61eb00a20f9f52f309f2a8ba45f49db93170e61c239eb8bbc3c89b0b925c1c87a099aad" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e13f2c5aff51c441fc9aaf48aa45bfa2afc7c517104b6b7d50a9c4fa40ddd0595bb06541ec709c685aaea4c77ac37afb266f3510ac0c8c8891b4904a065ff9f7dd11de4bb758f6f2f5b16370a3ebc5890ec75b69a2c014bc9c67598c7e094c8820858e34c0d2150996dbd1c3de69f53dbfae0283412d27680428437ec1d5dfa444c5a553851bde66ef3377019c06f93d36e9b7e540e09ed223c948" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "84d5ae7fab040456d5b60a49db84184c6522c671eae6d715432d5b92da30fa8d17ca6fd8e10f00dc0a06fd7bc0fd3c1b00e6308b0c2615b20aa1a65d8ac905238c0520774181ffbdf4767eb2971813de6ecb07baad256ae3dbcb1b73d90afd0f5de22ee1e4be79541bcf4eb887ce1f904c3f32a868b289a76e43214ec171bc1639b51132a1f6b0db60c835761b6106115d81aecbc385114d56372891" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5fe779f861e709fe51ba04ef56aeab3865b758ddd56caec49d268eb04ccf2cfbd83075286011ba7af59b8c50f81d978b029b541a5a5023c86533e1d25c4db5ec4f9b4ccadade8f4332fb62dd5f41cc0756adb4662c4b9063c7bca3dac7719082080e07de40956a4f3922b0271d6227115eb634639383608693bde9942fbeb4c0a76c1efa407946ad440556f489800d92eca6a7c73beacdac79e7fc551a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "be6ba46b695d0b8a24d4886e3a49caa510bed696d342a842bc51c0d015b9b737f299516ec27d3082a8c87fcc92bd50efa4a3aae7ca140bff820e5a849fa02b421fc0647a09f5a0f01bcc31c966fefab1e136b0c6d1fe1bfdb24a436f7a84d3905a88dbe18ceda4ea4923ad4b2b42ecf1923678f3d0bcca46c20c4a8edaed8f76e27ebeeff5d3fb3831de0b0de469e73968f94adb172c50eed38cb058ea62" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a00bc425de55c2d030ac39dcce74083b56f809c1f1f8e3398fd68f4139a083ea7261f872378aafcfa6bb45b720101c9be64eef0eb2097a1c4f66ce4b56df65b144ba74267ace2c0dc80076d5d3e6e8a9acd70f21e7e743422acfc148be0088db05ef5575f9eaf5a1bcfaa468142b8f2c4a62ab3247571dc2481254ff030ca298dee37a4500845ee322378324ae2f635f4891e2d46f1f9c71ca307e5243d056" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5f57318fca8c3a3b590e0205a5f5d314c15fd2ae751ba7befb91c4f898205f3f2701651e23f941c274b9228a39b598b33405f4a75e9d6600f1192e4f06f81edeb7f619ecc4e82b161f0cf9c8d37e68c7139ca9d653ee34a43419205caa61d14ab51f28b7c8e393dca8d6fdfdbd796d7f84ec0f3f33ebadeec67dbf7afe134c37f2bfc24a8ec47e0536361a87c8ac238e42c0baa9eebb9d576548c847f78f3f78" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "61237c1ea7a82566fc6f76a1d3d78eec3b3181de76065da39f4bd1da971e40e3011334c225e66ef4d4ff50e49b331ac39b00c91f985aec227d43f7e0eeee40c2668328201bc663039851fcf757e1c757f27f831a983b1050ac1e669c6a1f4cb42fd76c40f76cf0f4bb889ea36c02890f0d2adaa009d47169a9a8b4d1bdfb2e107c7b3b2bc907c368c59ab37ef54f84c4488ab75901995ac8430c27be15934f0de6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "24c443acf04ee19b20fae2268582993fbd142d22ad75a777647201116bd8c123334f6e0e847b3030af1482f7cd2cd2ccf5425683172094cda8e73e33cdc9991ca69e3285b9387beabf00c370ceb47db606aeae4b958636dd0937ce857cbdedbe31cb67a33eedcf2c51dccf620e20d8dd9f35718dbd208d865f1459e4cf3946e0a9b4e60ad0c450ba81d73d892b0cd595a52f4e07b6f740bb957e7768a9f32bc154ab" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7ba4f3ed6000a2117982962ffd84e932de959aee244a8096778264fdbec4d04ddacda8a73c5728b04f0571ce5b9ec482a9ecf50b21133418f644262d9794601e7f2398629122b5b888d6af02ecb42d2e41238e0082fb2d47636f2aaa6cdb7d3be5eacdd4d4912f1b307e49572f1d657038ca83d1a9c456bc3bb6faf851687e5cdf4977984a44050413b5fd2c4272c2a3448fcda152e2c306a98d738ba1f8a21fcbf57a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9b16ea160c255452b6baf3c4e5caf627c1f4e8663da9c9036f048860d31f0918075e3eda569254422b0295ff3afa152e4df0f99de21bac416e028e2a32e52896179f18bce7be2c5ecce28625222dcfaf2cc503ac4768df7bf04cd38d6dfcf1f1c4233051ae9843de7ac552203cbe0afcdee913ced89103a986af7fec428f9f93167a4218d5745cdcf57c6de15bcac08ce8a8de8b03ad9ebde73978a6486f7e1b90d1123e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1dc2f82fc83a973eba60ee0ca1ad7a50fc50e9db3fc530378865b9abd4101198d6017a40777839dbc6313ecf35b7b727e0311226fa865d73a43cd28a400d8b35408d789b2249b7a8e5df452d50c6a3c28fcaadb58b222261be49aeee3667e0ba7c5f2726e31cd5bffd125231116baee18bdf7727ce3bcc0c31e1cf600635623881a944d14d514e1becd9bd0d823b41a93ae969396db22411172efdcb73593fc8cf80071f2c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e8c00940d825a6117d59d922221e01e2dfc2fcb47bcba06a72f09e8f5969bf988aee8a4035fc97d4ba4a0d4629c06912c908b90611c1cf4c580f8bd3345fd8b155c64dd747a9c21017146d620913979ece6df5a610d12ebb9ef30724586655ea7a11e45ed51a58f7705db538dd075a6a5ff70239e88a8d8da0817da0318aa57f637b522c50418da50d0710ece7e3b36331eb1147094ea8321659e6cfbfb90e92f10e90c3a73c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8e9c1aee76744af025ba3f5bf630c13af132ab7c55230c8adbd20b214f204494f08035d9cf1beaa30a3f8522eabb88d02d5558e7f43c27b58c56dec5bf67812055a99bfca881e86f0024ef84501eb63bd5af849a134de4dabccb087a6cafe0426ff0d03de8cdcea2af83746f94b33eba2dcf4de7775d6a4db8d0ccb0d789e11b9bc3586e82e31a265cb26f82ef705139a5464118072af13f494f1b9a07bbbdb19dd596fdcac414" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "44753f6011c68059b5fdbaf6156e158221b5f1a544225844b33f3d4509efe0d4185a670627c3652b4f6427b583ebc5d941da2a801111a12d8d46ab1c0fde95c91e538be2e86954be14d3e7ae33d04029102e4267f3e2f099fb76f6801ff19f26b5ba07c29ab74cf1e3f3e3bdff363699dcfa7a32e3ffda3419bd22691cc64167f66a3c999714144e1079e6ff0472dc218d11274c061d92d97ee5ac1e02c104d1313a1ce3272326d3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f6a4be7b99c42b72c4e03cef4ac7420b445fb0720804df5f58d284e16cf27ae905dcd5e53f2ac1cc19d62c762fc9906cd45a0a5720dce51692285118f80dcd0cfa4008730a49c69aa259cf9221f2a992c21617e5fb361b03cffe6bdc283866d4f4823abbf43f02dd4d9351f1e37cbabe3eba1438dce281d6b87fcdcc88f4d6c2473d479467e13a5a1e94d1fcc32b9932c5f28ada66615d1f8c7e6e9170b06ff1c1041eaa4ca838edf7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "894491aeccd8edcceb6a6cb3c7722b2959cc591f8443b1efbc19a459d84c77183b2439e594e644b5b66091059fe372cc41c98ee01e2b83242ed2379dc97cb7f9d75fa146b36dfa9f923f2e5093b19fa4beb18d844af8926338f458d458f7452075bd0882e70570fc9b74cb61fa4fc2d50f8aeba4ee7d1dfaa4cdd44134c751ef6dd04d06f4892256472a09b9cf68919769c3b1ccd75c3b89b7f122d9b5c37d8745caaab703a32113afe7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0ba47fc6ad5364ed20dba3638480fd26ab35fcc2da8220e971f3849235d6e706f291e08736bd2edb5de04299bf2fbb97d9fea02456244540821a7ecd0f3b87a7819e054fb14130c92245b72b8b8b4e5a0d3a0cbf513a75aeb398e2c5842553c947297603cc733021608451a615cde713099a4b4d1ab26b6a322932d1fd6a99c0285b7c44103c7ee80499db0716160382db8fea1b5caea9aeaaf1d940dedf185b903dfc2764bae972005fe0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9f80b7abc0af99d288971d6a3bd35dc802e7975eeb854bc16dc0d7a2b4c41607fca9d2628d042d65d7a2bdabde5912ab36b293932c12f02f8c97d2623fd4b660a559de3ebfe58ef90f5cb5dd9515f5d21157825803f32aeaf2c1700ff8d084c0b7bcc70ac7f29090ad8c218375624d58f2ce789ab0b345da99ad17a47279d3e8a001f337e5fa7278c26554c673a7bac334efb258471c4156974cd1b54749a49000cc7459fb3983b4258e1f0a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c254b38aaed704cce241ac2308490d469aa01403a44fa44987e3a33a94f51a9b762d02ea54967a8ba351812a6662463e82fcc4ee07af0862113e01c3f6d513b292dd02ae0e3afcc8584b559b930a27f877443d9443afa119db7cee8c632e18f186df0b907e8e3f3267f48a5a44232b720cc9330720e93a31cfbdab14718453cd5eac89beac73c996b6175bae2e91eda40e47625b286d42993fcac967e8320d7cb013a84427df4e30d23abe9cfe" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "abc8df1ef3606c517f5a2d8623e5cd0325504ebfc670da56ca01a570cf3840416b24f21091a68a536e162cc7ed7922869b7ab30283e57f5eeb60b778a06a8c5d6c6d10c91fe5cd37ce47669b785b11a3e1ae824eb9dbc4857a3ecfe0d1aeedeb103688daa07c4e01eb3e12507fcbdf1522fc5a186afbd858cfe8a453278c78285271c303a82417afa3d1893e09b4d2d1146c715cd226292af1ef2ad968ac7e491c127129d106677336767f25597c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dcb3db73e478b5957276b1c6b16b1cb26d6679d4ce009ee6e5f4dff8ac135296f3ceeb80426d5bffac0324e927d7f77e31d011737e7460cb1f19b8c8aed25a786ebd8b521524c5faddfa009c6799778b48c50075d43db1dbdb891715f038595c597380a8d02baa3f06c58bf3d610148ef84c7bfc610455b63c1a8acc9e834cc079bdc9452bf5a1964c75776f33ce648d71b99a3a97f776938fd76314296a892973f1ac73cfd778eb130bb7aacab4b1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b390160aab430ba9fd39956bc2cffbb81e85f83323840c665cb3c8534dcbba46769ace43b21a0e0f6808b22cbe2e64075c5ee4aeb9f6588cf377a7f10f824aa48e9c3ff93c2ab1ee3bf2149ec9d51783af44d50d49f5801f5e30183b4a18ee99496357201602cfb7cdc6c68ea95bdb858dcef3f4333e304183f139811c853ce1397deadea3875036c72d4e018f8443763e5679bbf177b6d6f9295a9f0079dd6f3d33d523481b44d5abf432fb5cc372dc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "eb380ddac0f8e07171d05759fac1dc71a22448e1453ff2430f82944743457b56a6c5228f6d14408d703cdb89305c5d67efd1c8cc9b0b145e51784edab2beab0021dce4a93fd4113cbdd7c7a33a6a77028228eb6b2a6750dfd2f842769da9692b8f1da6f9ce58ed56a63a666be97912f464ff57d3214889b7d66394b759caa18e57266b63bef3002a8a32d1138ff033e8f078d88b2f01b800e3f1181acb82460b8352b6736b3f122f02f416fd4aa40ec98c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b480f56a66f51cb1385dec327ce586e81d3d9143a7301dce4bc593035080d6c2e1f0cb256bfaa082f68edd8542c0e0166464021dd2a5d721e9f6ce79d05208c348d9c892beecda78200ff67d61a96d7d2df1eb5426d41d5cca0ae3b25e896a914360db473c96899b923fd850a03770923473fded07c0b82cfa2e8c6f9aeca4f266829ebd10a07c1662d2ab1f2986eb9ebc33559958db46a89d46c7dee617caf1740f5e3022458d5cb0b8476381ed6ec8abc7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a91a2d8ecb6485fa780adb7dab9679ac17f2b269306589e1eff3bd7842c2e004795ba3367ab5e6bad584159a6e6c063d64c0338cdb19f89eba55059992b02258f27fbbe1b5b748810a6d00cb365e08a493b98159a169616b8ff88f7e67e7ddb6502e03481a2c601852ed0b6651fb8963af760fdac36edd4fdcce1529b2c3800af3e63ab6bb013864b49950f04a3c784f0e84db4a1f58aa8b4a437b86673d124caa8534afff3fc5be3f5d5f16ba6f862ab5b9e7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "214b8e934e70e2e9ed6ca65e198bca56c84f498fc642b5add5b709b62544171a4d57f82d70d1fbb5cd4359379aadd8dbf274da265ea78302d66f130aa5593ab968a64f596e5f72093ccc3e5473e2de5cb4378823e6282e93d52fbdc4217cb1f942da7e5fdbae8c5ccd44c59fde24128bbcc3436bb6e43fa6d7bacb7a8714f693f1348dedbb024a8c22e164e0e7804a51bfb316569c3fde1b771fb2af9a648d949cd701cbab36a5bcd87c6923428301f3d64f5231" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a2efa708dda81f8ef989f37cb10cf344a8a91548cffbab474041b59c5ebcebf34355e38de9e3b853201b3a4547762b9d10bfbdb52d8230c057fe84177b7790f488204d401fb8dc35fda836cbd549d504c47487ca1ed4fe80f327acd84a43e228c43c811070d74b788a3ea7b39b4a908bf9a17098fe36723f994b0d4cf2390ad430b979a5a48b89e1b7069656f806d53ded32cd256e3d3ad0ec09738b822aba507c16d15f2f4b748fd050b7984654e597d9b30c63eb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1c8e20f3bb00f4d30a8b6d53458ff0b13032bdae6bbf1c99389d32069284dba2e82e068205583bf493de4cbf873ddb0018d866d4543e480b7f3040be117f526e99dc60a60bd84c3ebca8331dc2c126304369420c5c98d00f55d753cf7a993d58962093fae8460f2af2e495908bbe8276c50c11d15dd7ce09dfa35a49bdb6c1b0679f4abc2645034d9b61e07f29af79239dc2a47bd04157ccb5e77011f8dda9f75ed06e1fcb6b87b18a0d02a2648d91f6800ddd041a85" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "34a6209350420b4fe7eb859cbc21e7323f73921819f03529de3051d248f5ba3d73694eac76ef6e3281c51755ca6d625f6f840b181e18ef1f227669603e7f65875891639111d996314dc4b6e5a2dd18a8fa2da32ee3fc1514a44b3b105d291f3d49990d2a1c904921685b9f713c484fa1787608c735bccaeb4ceccd3e799960354444cdce5d9880a3100ca285560d2b9d3842391f60ef89126a58a0af453b1dd0d8ee44d253a99fbcc9f5b0ccd7b80cd2488a57bb4b23d8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "85aecb151295bb3b7c992aa4c2534701e6ec0c9893d9bc8b95716262497411d9592b4f061357e7de7d03b0bf213c0c371c513e12fdf5d0fcaddf8b4b801a261082731dd269ab64e436dbade46152669a945bc51b9fb583cf287c76af8f236b2b44c85649066d2f46ad699435c3c3e954a9e85503537d70f34c06c5aa7c5e0cff11d2cf37c9ce6e883c837d7873a0b152470b26e21c82fb36c300a5e0bb62c81d09444d0967f0e8e8533d69660686f2c7fe2cc6f28478e231" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e7eaea666eda1ad214069ebe8acc8c01e7fcaea21ac8bc4922c686f8f256741f6b29c00fba4e9556b056e3c1ee55d75f06d946d77450c5398e17844ded4f7276693bbe9109bfe9507f42bced1971b3b03f3d70f25f0f99e29d82969bcf1bb663e4c4ae2a04882e05baa2f9c34c029b700c745705581cc5dcef33472cf2319aad0d1d37d92add19e20c88168475463969ca10c5e37cdee346482edbd9133636ad18690070fa7313fa39a7b8656b3e67340d386bd91eb2069262" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e0d3cae4de4bb434d22e779d992c671825b2af5209a236d0d82fe8103d21bf4519401ce2cd4c2852a8aa63f4aa29c8533ac9cb280bf39c92e5813208f563e7b3b88393f611175e99bdf22abc75e2cb175e5bcc9e0f614766e8c9f61b675899e701fad79ddc1f84c18649e50795305667bd22f1bc5dabf914ef207770c99ce3d802ff9afb36c829e5eb34c3218aa3ac47381da335d6dd1757c92af01f51b45d1f7b08a2ce50586474171acaa36927b10752268bc727b057f7c14d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3d237d5b4e1fd29c6677c0fe437bc6624165b3a6e3ca157258dede30d0a59346a57b49ae0cb049324d5c6f289e91de76ffb29395a79e4937a74fdaefa65ea2513a487b8b50675954b72c9d551b0de89ef39c5596e678bae4b5b1cbeebf86e6818555fe886c624fa37f645120973fc92f4f83b263fe6d3e6eb4896d3bbdb8840c01a5f96d9213ac0400cb39e045ebbdbae00179afb31b77823a1ca3fae079d2cc4b09fb0525aec2ea5421e2c4b5ff9e2c881a29b49f9868d15a5dc4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "89a8c115681b38ec1fef2137fe0dc1c76d53d042820536455233743830fb08a9d601fd1f3d796a08472687e457cad3166dd4781fa3ec0ade3ba31ba38a528932f0c6a1727d012631f649e50c76b983873217fc3c397c39ad8661c0f818222c55b35d0679b8ff13ff66235ad5bbb64c2eaa2891e400d443c687ddba429c2ec038c080785510cf999e0d2bf4e3918b27ec209145e0176dd533ff69876e4ac57438ec45ff3574a8e03afddf802e946385a158505526c1f6f6d816db2d3b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f3f8196eeb035d4d2d9a0312f962190af5451a245a04ca77d2f7201c57a34f81332822730fb68bbe9c7876fe5b2dfbd56734110a9cc550419643ad094dda17171fcb06437e69e76c6614f4b90acfa3767093ad1eaeb5ddd3ea30769efdae090545eb74c482559c9c08e78231b0f235402a339eaf72c1c3f202a456d9a954e3187325bdaec1cee4a436e65a7ba401596a88c8b116470cadf8143f1cf0206eb7fea09fbe13178e30c7522218d80cb5146550f94c0f7085011bbea616c82a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "17790b069543cc3116bf84983c6fda6b6782d48bea79f4359f194a0a91f071fc9dff793af64302ff581d60905ca0e0ec07e16bb1af54d30bbe2ad2f522611d6d164ca85274041ab0a041f78a066480f19cb44ef88980febb1108513654b06480350fb68923b64b3c06c749d9da05430a0b4440105c44653e808a8557f59ac721c99aea7edf76b3bb3f1abebb4a7e55babf42cdc03c91135b48ff1554e57a96f07ed9bab8e6f529c93c6ccfa6961a591d8d05d7a9ef4d333b7722d2b29b08" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "86e0a5f8f3e995dae42d2e73d87438cf139f4bc42bdffe97dbf8fc26939f1454a254fdcd56882b3f552fa30b25ca62d0315fa49f1d5d42020b68bfc7bdb20fd4957ed50a533b2be720a8af438e68f174cbfee6817f3f0b3be2bfa365ab51942dab2b321def065c20cda6c7b1a7aa6fc3a1f1d6b4185880491601507ae2a0fa9686b40aaf0524705b760e15d9db822bbca58fba45f6c2d1b33fe49381120dec862d3940a3b145106125e3e99068beda1b073e5f03d38f6973e5969a4bab896e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0459375f9886f055105cb34a109eb44de838bd5e14812f0719a40593aa1bd3c76c8339b7ad90d934d23f1b2aef5aca6f795c4e0132fb1e2d0702fb044f4724fb33e75c5a5d5af60501bec7c873349b1b8bb756ff7a816088ed08fd1a1e79830396d3f73f4656da870a5c1c0aa238c024ed490ec93e0e410c9312b96b5a64313e3d404c6236c655c9d9ad5df6b64e2149bc62f0173f33df60840f44386f4726ce15ee50fbaa0aedf1c384225413889f68571e578412bc6f6897081848fb7df0cc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1cc2c138b0cec83dddb572024356c6a05b456b889f69a8dd2cd8007fe7a23715b567fd6f646c0282b5c5d5360c0e1dc04fa45f69010eaaff42385ba85fd8d343bd1f6d2ac4556fc35ef57394473652f468bc28a0911eeca4234cf0f5e15d5b61a5c8e6340e974835aa8d5e36c63cfafb67bc1388d94e2a57f37056ff1925401f3ea9b497ce7750af79d45a8bbfe9cffd0597a0ad17cbffaa0f90451ac25ed14e807e4ec68e0100373a9d951d094c43308ebc195aae1c68067e1308bbc6144d0464" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "464d0ed294396d610f6b6ce100a876c0ef5b6d3193b746e2152cf437c422a2ab89abca1af36d2d585ddca437e43f9b045c129147820b0ec937d75f5051bb70c528ad9d419a38c9062d665a111e738e44ee9ec9c0f06e566c7267b05f8bb824854d4441c4cd3ba152002c4425e42e9e67926ee8f152f4b76f8bedf50855bfffb23780f02897765571a66b22c3b91fb115ecbd8f6b60b47761cb89d776d8376fd7a7ec9f267e4a27c0339d05812fb98e332100c3540d26a13d1122c09ab64acd30092f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8b18cb31351dc0e00052722e236ab7c57c35c6ffff24a1dc28a56854f48ededdb067315234f6b25308a45c8fd9cd8130ecb24cb5ab0b1719796681fcbb4fd007f92c7d946545a0ac340f7e641cf3647756e08a96d4bd3396b691c9701b149c0c3859fcc922c76d2e827b5717198f015644301acfd2629840a0196e00e9f50477fc561dc69c8df6322d05e922212f2a5d5436701bc3256cad9d868cbd3ca4616938c8cb0e6dca03d2acec7709aa0dbb82b558b912f7e18283fcf13b7e32a992b222f341" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f9962f0b9c6d5628577fcbc108d5708c2ecdc65c157ebabadfc68350cd0734d8ce6277544f39b16438f3b29b8265bfe421eec22f854e7ce8c0d165ddb38ecc523d895704764dfe263303a72db9aec08b1aaf5edba746b585fad6af8b7c61c7753cf9f1fa6121959842bcf74566cbd18bb8471bcf438cc3080feaca7891d326e627de7fb0f104851f1afcd832c3031366406953581540eddb0834dc79964facab1e7b8a45a3c64c6726e3057f82c22c674cc09f41bac59aaf3f7c727f4cee52306f91fe4f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fd7af4e31d0f692bd74c4089e0af8890a933800b04521d59bb8c24bacc43e96193fea4475bd67419153362b83e54d235d7c7816d4027197e73ec1474dd2d7d003c1297eaf6ea80586d748cc52f1719b73f66cd6174c09c12524f960cd4d4bc26d066020d2ead9af8210bb78eebcb7e480604a1eeb15cb5e3df95f8d701b2d3ebb0b5b06822e157f09fd5a12fbf6af1762ff5cc9a7bb780237fe572eeb9fc4f52ea8b3494b1690fa5809819af4680070d25081dc00bf531710a13d8b661fbeef104ce7bce72" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7a366aa68ea6dd5eaf6820ad9ac4a4863a3e67dd54d1d54b13f4bc88043398a5bac0c735750e5d3d65c157f97cd981aa1ea489f58d6ddd187fd18b8c65bcc3f36e22f564c64786254f319e25bdfd3edfd9d9cb744e7d36115788ca119b892ab4bffba4b467eeb7be8bfaaa09d902143765622351126e1d9707929350701875d512a762d28ec4d9e506d946078be66c6f57b9f5f21d8121bb339e9688b52a7ec1af7c4d0755026a531b73cb940c512d28d3421a302d83acd915ff2fc3c2a45ad5ebd91db7168b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e29fdaf8cae1f2aceb376d53f550170e5d18c44b3083c835340ed6079f312c7d1776824a4604d7967efda33b3824f106abfaf08f359555a24b78dc8ed6787186b8650a19adf64a8a7bd3d8598d9fb4699d3c8df6007086b03141a78aed1fab1ba46d4ad57d6b165dd2a405a6725e50d7bf0114728d1f81eb542abc72ebf499bf795f58f8bd0805b15fabd16de34bc646a7199e2df0e80064a9aef599c9d60884a6503fb9cc50efbc6e46d6dc1c8992978b9cd67b6d61b779c99e98d01c4c84a258a3318e57672a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "da61658788de4b16bc6eae4d9999785448e4055e730629275d1dadd048ac007440ec203f593c4e790cf9bdeba07ac926ab4310c5d6c196fa62dd239b22074bffa535fa1e9616bf7ceed9ecd56b7b6ec1d1d6f88c8672fc4087db0488cb0313642599682a5cbfdb7b79cbff91b4bcf76ad8f779d9fc2fa8fb95c4123775c7c0ffaea19dc28f310aa40cf734b8de7aea233c18b40ce01a851d0e208017e4a8f36c74d344a41dce80b6b180699021bbb13670c2c6025681b730c5f2ea581923f900c9e42baa2d5e0a38" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "31f1b58b087a656bd501b6b89b95e87ec36db90469b3ca02e8bc2b2f2493ccaa9dee81e8877f41a846b717ab550bf3ddc60438d747520f28ce4c30db9ed6be0e5062e5bd4aeeda7c42b94792247b383423cc24dc84613b1c8c892fd3c926267a1f6b290619be07126a34a442b860980967844138155bdf8fc4869115fc65fecd28b16bba47b4651e8bb586c1189dbb7d557124e04943ef79754beffdfe63ef9151610abbfd7b9696b98a6af7f5af088a6ce6ab23ec7533b7ce2942ec61bf9baedab3f3768205ebc85b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "77b6b031b61fa2a66115ba10bdbce0922cc3a5fa29a1410dd5e7021182389319800c3c2e3587af3629ae821366ccd5fa498960786814c3a2263a7b912d2ee866a35a51fdce1df8c7b9c6a86659bd6d2a05d665fb0b6f39582f26d648420abdc1f0404739b0502f85ce9b0d034d51a3eeabc562a8900ecee65dec28e111befc3c62ef8f928e707cdd2ec76068f3d347eeb0f062f6abd23e7c0cbd50061fd462dbf07bec30ef13ced3e5c65d2d8913495680a71a80275c0ca20d7a693a3b25f8c96beb78dabfdc55b8ab57" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5169d680a74be335c0bbfa5f28985595b9d23b4a7101f92d11332ed5938b578900c18b6c2cd6676bf3bdf93121b6537d3aa97b3856b2fda9dabcb1a01f7eec7bdb8239dc8e6aed00f08bce422ad6b834670c847684669c84739ee2e26baca9703db038b92b943bd9ce0f8fb2711e79f8722115e6d7b8eb9b5cbc2b7e318fdae83edf3dc24b400b1907c8b8450c6b31bc975ed4303c9bcaf84b4003077f7c39514244434f7ed1b691ec9bf4c01005e14f40e1818ec376cac21d60f3986dba064f48655a5ca9a9f6045957db" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1681227674cf4bc7124559c7c3409caa4eaec0f895a35693d454e44d79166bd93d29fafb5750c4235609d8a6545b19685a3049466c1e9a01e79221ff4d045390d3493186d116eef714a26e79dbc38a84d2b44b5909524d123ee2a1db6c5fb8d97f6d9776acd3a77210107c2853780225d49b8aebd00486eca5f469d0fb4ede6a7bb72ff92d778357b25053307db21b4f394c120c42712d52fb2ab3f803b276d5d81619a94560bfa0dbbad76a88f6527e453ee3eae3cd0dad3e9be3bbda9277a167d4de833f2a0876f13032a0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1ff6e40a736e0aab47957a8f9631e7b7740645cc10e00ad4f1e95837bd45dc95f44d63139c28351c80432d195e8970222544d7b9f31b29cfde5bda467b814ff381b0af02ddfca8199f18aceb656eaf34df471918b5280c0c5e08ad17dafbbd22627febdf9e62ab1fc0beea3f3732ea166b4715733ec2c68262c09103ee96b062a0d112af1e800cff59b970101626bf3af5ec665d9de91467101e8a261dc733fef971639ada5b8c7679efc6a83cd6195fe5ee933efac81e8f83d0fcc4147f6dd7ddb35c1d0a17395f3309c4328e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b44f695a21679104c2ee1662abff4f654712c990c2b8a89141481e5f33757484a2b921e822c5f37e5703cdbca480df2813163bab64fe5f7ee2958c6e08d2296908cd2aec4b66055f4d64d39967fed56f1074365d1d0e973cf10cb6b8b872ce0debe7658d75d73a4295d858b316559f9ddd9c4adae98143d990880dcac0b8f2c803a6162f0627bc18e8b43c0ccc1475fd03c51b39a64d93e7d60bc63de383598833fc248b5daf8c124ecbe9c39e1be8cd9c0e5c453936b1370177720f2d0b76078088ae483018ae6d5432b4324aa2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dde2dbfa04b50b16c03e7134981e2a947f49fd05ca06c25d3dce5203bdb17a281af45a291f9e0c3a463468f90415322bb4e61ef0016f47f169e0cdbd4dd88b352f6f27c12ddb9705a1269529eae07f3d34f6ec9fd5ac8eaaf3f20fb1961c188a771163c50778dcf452ea52b17723399d3f8a02967b0e27cfa61ac1c90adb585d6fa504f646e3d08c9abd695405563ea08b0163c6a4f91c88f7b0321e4393e234a355e3fc83a5245ca46cc6236e6f053d854360a7bf379f521acee6b6f54deda7b2fe233208d75ae77db9d1d827afe0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fd0e4876256b31547b3bc1a2c2def5c417a5d3fb2c3771946784705528611d0bd60b1b5bedf3ee074875b6c8f38f57eac0323d85842dc3980c133f785379ae98fc732cdf733e7600b0cdd895b15ef0a280a01171fc7be87995047e70f8f4a1556e4cd7f0cbe0afd63fea4e51d5b8ee613ce38241e6f6e9e25c577cc8ad7dc914c0f26314a6a629cfd85d364ee73db9e888036fcad410478b563590aa10324d0b7d95618d36210fe8d086808b09fe52939f629d0e083ef6b03c1bc46b7e57779649f5f2b5f9f2e7f99d4017d1c20de6ce" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6cfb70ed1c1ba261bb608217a062828357f228007518657378d4c633b5f15a54946cdf4a25f3466860339b42ad84b2a13553a8c7e49999716d7c8bace66ba68bb499d7840c622fa93245bf144b0bad70bdc16a27ec9bfafa92a1a58e846c3565d1309a29a371fcc2105e50b769f4fb620d839f042fde48e72a01e5889154f0572e31b7d6caa4326f393cba00100404c38ba6150465cb181aa29d4031d3e2ec3f09310caf4dd0bea9bc5527aa0161e41ddd923c4c0885dfcfc08ff92e85c703901dfe0ab233066a3d2d41a282d77fb767bc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8cd5d164a2b79c9e78b6235e49e62a174b7318c8c5b9a1e56e344951ee03daceab43c7ad9240e6ace541a052a1f500145b4dbd6590bba86f094f0b0696650c64be3ed6d041acd8ea6b0a32082eaf396faadcf0ef1880eb8ac2fbfd82b41f4755f02e970061328a7c8d93de8043d6d8df00e0e3527ae796738be6a76513e12af27807e981d152aa64892a1290c5d28636b4f7917cd0b7c4cb84fc00f4b9687e195cf77a52cc14bc1f5881a02f2a118d2296f7a254ac1a6d566ce4c04e91e42c398ae305e406db300dc3a9d450a390958fc62a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a7a88b8862ac6d4895b627d2b4ca88f144781d69f64da7ff294b92b1f398c8740f94664c8262d5f1a47ec35cb2442fd91f5a0e74317782c2dbd861022945447313d7e5d17f930ab9f7e546dbc02e5df9f07629baf206fac4c3a5bd8de1d4172fb99bd2423b67c9e6c16d5648d3a95554996fd9d8ffb8a0dea44cf70e9f3976c53187e3f54810bafc49ea8164f77e8f0e6b1207445940b82f7a2ba783d9bfa1bd19cf847d7d6a5eb5989433c7aee0356a021b0701ffce133cf2242560b451abfc240d23ab2584de14bc727537a7b5fd582c4322" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a3dead87fa53514025d8523b2ebcd89c7136c51788a8828c4ab62cf129e39a13f0ebaa2c990e621511bb6e8c1f948c4ea4775ae68263f368d7a7d52346a2fb45fb098d7009d46ea17078b8a0ae8a6cdc2368e6df793f5362bda3ec1d88959ae4aaf665d6d755902c908bba2ee95a38f59a5bfa9564103b95789f31f293c8766c51d8f41fb598581dc1503a8904b6efb74071c9fc7f5d6028a609bd4780f283867eb71e5754d1459d70f5393a5da9a2e0f90492bba2264b3db26cb4294082a8d98cabeba6733e5081a8d026f8a490858d8855d239" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cbed99581a74de8d52bd80a970cec4fad1deba42a37496c7a584dfe75f1f883e1810b2efe18d59b6d92d800d1a0290b956fb35f8f8c9ba0878e0e5d477fa1d4d3fa0d7a835a25cdf9282ad93dafdfd90a28d7314d42b4724cfa495a599eeeb501a719168e38dc82200a593ae3f34920eca33a0224f511247a733f03ffaf1ebf476ad3645c3f1807bfc01619dfaf8731405d5efa106df774c0f3f018f8a545def065578651b01c33dfa5643d4a1b03dc9953bc943ea097f1a616002400e1cc4241084f63acb935561e0d3ba0ed5e487ffb3cded6a5b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cebc668bc2e2f5089abfd20f1e15167f923a3d8514839eba2d6321f91f4cc7045ccb9d07f77bcb4872e42984e54b78f2e1c5fa66882c34d0369342b78d05443001b6eb97943f80d90689f140343b7b8b7e0eb2b5aa41d270c6cca1062c11b3cc6e0801e62213cece8860aace2a94176702f5e5f3ee31cb09e8c5b18d5d1e99a66492b115f11eb951e78b268e19009ff509605c66cc319d38ac0402c20d384c3ae4772b8d3aa4ad03dd19a639d5dd4a7e88307d68cb7bc13d768f1bfd7724cb2da50812e77a516ed36a1666b23ad3c5d8c80f4a94b9f2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1241811d00320b1ba7c370bfef2e3f423caa0680c22d17674db382617ec02be7c360bfadf95329ddae76919208bfe6f138b45885a5cc54e9fa46096707625c8b6a9b2be1e29428a98177a8c7d703969fc6f34c7b4cbcd316b7515b23502d0eedff8dad2d918b2673089160ce5bfbf1a03fa43bded3b7c006fe23af584a577b6518238706cc1ba6d0f462bc3f62e68948dd2332fe3ab624df9662cde869cdff1b8785a08af7f14aaee0217ca2e29b3e1679acdd25ff50958aaef05c13797bbe4992ba77c3091320c5e1b237decb7131a1eab79dfd636260" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f175fe4bb81904142c7bbf271a3133444b8fde748d151672c471392458238dfd84cb643715705e2f21d7193ba52e06b81f6644a8733eaf71aaa9b24be772e6491b68717d6755b4af4e45f43cf88f874fca71a01e559d4a5a1f60c321d3e0ea0a8854b8d51ce7f8febebfade0edcf04a74f3c21814061cc7e9e5a48a40c49778a803a0eae7449f73512016f272784e32a4cc78c8d0f30ce3832b7e2d324bdd7b0c3d09ca49c654348760d261c55b56cb7767535ea925af2f0159780bdc8906c57abcc6319f2a5e9f16bf6729bc6e919311e5948aaffd84e89" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8923aa7bc888549a47f405f61f09cfd235a9126250566506b7576d1c65a7e49dc76553f1921a4d1e1458c35bb032d4d804e421d8e19d9ee0dc80fe4de1f06d183c3ce60709df1726450532ad082275bd2552233bce9b15324dd1211d939c0ade85a16b5618754c6bfbba9dc15e79c2e69d375918a5301d8fca2fc5fb0dd02d71490575192497f769967c5c5a15a3552109d862c5ea21170db9a660418dafc942982d56a46181ec290c6fe9322738f00ccd0dab2bb825e557e39d61662409609b5d06676e9801ee7826076a665dbc9a0b65c17fc48d6223cfda" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4dd761fd488c41c89c1998a95dcfae35c7907221195c6747aaada8e37b900d6c2f1a69e874a088dc2a7f01c31c64d877fe0a970716446135af511380276a51b067ef6a4ab914765a36444add895d4586a941bd1ba8db907487159a968bb8cf2f4457585b331cdaed2dd327b972c5aa71eca959add6dde4ad0b97f82bee9dd5ce457b0bb3b6da042068f6ff2bb8c20d8459d44172dcfd6139215a42aca13ebeec835357d3e7e01b1a684a4089c1e502cb655331acda4cd2f1c748ec2d86c8841f7606cb13271710ae816d62c3e7e4e35c968cd608f54bad127074" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "af5d2912543cf85417cc243ce775ca86d09a3463a6f6caa554834cab060d88dd18678dc22c46c99529709afa2499e37d58e345a72d40dec191ac1035b9eb6cdb85c41e6d5935574b9600e3b6acbf9292d237b410827e3e4ba40023141e19372bce972e16561983a0a2d06b5659224a8cfb4fdc253311a7c7c3b08d34db27c5118f5423ebc5d0503dba6ffc8653b5d0be4e82e3b0d3cac1f5b2a5efac448849c42d775fb659b041dbc793c0b64a58e884410d6aaf69e3d7bcd7bf500e61ef66f16f77ad1b4c3f009206577196be081b7aee014f4d62cebfb6d058e8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1317d1f48092dff2f78bacd0ca292e7a36839ed52d7bf1e0e729ff800372456a544ece4e740443652b67dc697e316009b3dcecbf9cc471193dfac3935c81f928744770a8b250159f44de9461f068d024927d5d8a4aebd2061fe015927ae67658aa48209aadd2115de5d02fb55fc5b4c274c7c9f2dbe218116fdc235e37d07a9fc5747da978c4fbee1244e5210ddbda05984f0e3dbc5b63359d2c928051a4d5ce6cd3857b6864ad1dec588ceb6306328f925f195a05aacf53d9340427f5fd433289fa0320f073417e68f356e4e6e5fb6b8a2a467af8fd51f4092afc10" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3dc8e8ad7119b010d186e1238acb4bbaf33a2d93852ba91f733611e981df6597a87226f6c6d41edac6981d12e7642daa82c0490fd150b8d57f790630716b188af8285925fc0ff8457b4aa93963adfbdebacb8ba89fc4281bc56e4562a632e030f47093a7a44ec563c23dd6556cdedf899a2d3c1298f63e7959716981f82743b3f4d8cca371c7881550fb30bde8b7feba2e80d0ed5ec63e166d0ef17ddf8db2cf8cfe983d88eb40b0b10e0c9a9eeb38b220f7e013bb952c86b5ad11fc570f525c0125e01302a28ed8b1a97cc79edb87846a8e596c4d28f5018f2387a1ef" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3a2f35477d7056e9ffd101691d80926ae1595c6fc618be62d6b24eed1922c1fdf10dc62d019a29b87440f3f3311dd90d0155e726eb96c3a49d985e9bf719e1480ecb4f4460d16cac29aa64b77e58d9a414160ed5f90ef0811c161c4e860a2ac705c988ac3567b1e63de780781b61ca6e8f16087a89e5304ceb7a68506ffa692194130eb82d1a458cf0057cb4a08346ace3076c72728c4e7abab4bf0add26d33eec3709a7644bc2c7cc355a10887f245f92fc049d733dfd1a87d2b67c9ee12ea4545cb84df60f3d8ffe209b7ac2fb3aada065acd7138d3680e36802f671f0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b8d04609ff91f7dd457592d183d5482fe26f2862069011c5255d4c265c7906b55c72d2befd472309430fed0664b39cb67d16fcc622ada4976e2ff23c39910f85566473ab6bf0f5a8e1315310a2789ceddda80cae84f48f7a2d6c75df0277b5424d2c54c20209a9cf298f94d43b7769ada163ad1b4c2497e6a2406d41af3cbf11d233b882a46ee9195ad7f511b3de6369fc65e34ed54715681bbf8afefb337fc2f26adadecb429fda383b56a2529cfc7aec86b6377dbc17d03557d61f5410c106672d3a553c36e2a3722663f47d75c4c45595a9e7579d058aea1b35a5caa836" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7d2f8d13222f1aafc0a47689010713d019feede3b1fdfad25def42550cbe918f5f4829787413a3606f854e0d431c6b2761d53f92786e969965d06700a39945adbdc17972b0ce501ddc5c6dd4b489944611ccbb9e62134d98fea9ef5bb6b5f7a684d971bc09e21fe6b40828199864516bc0b00323767a6d9506c8e3aa47c7676feaa60c820d70d0d8bfb7c3b7abb8d47eadf3beca782c79f6cb469c7c8c3340c14896b3489cb950fd23c4439a72f5c8a9589efcefb85bc786ee32124030a1c6d346011ef105cddbb398a6fef999cd19b04fcbbc6427cc385e8399d2611f0f3e65" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "723898ccebd8d2746ce9e3796d429462fe9e34cec7fd6c863e3d90c4f51eced7e241365ff428161a6762544675b6c805e6cc04c625f4d727e6e2e596c501ca5d9baab86c7b4d04fe4da505acd3e2d34b477ece7339b2064ae9f8d991d4f21de6273fb32fdd789df450b3d10e8961a5061290af31ea4f240a512da433fcead2c0908f9a020a0167fa45b7575e65f4febdd63ae251953afc407de50c5ed5da15384a16b5bbd86ff3514cd1f7cf2902cb7192dadd848987929121b051da8de022239c01e8b8f40379c0970e31ba98859bc5349637fcae05c8a50ea7c00fa3300b1af6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6433591eaca79f1bb52aef15dbaea5e19f2b29312e594ac58702c3f96c297d87ca6ee2bffa2f961f41814c410b763125ec7a412e0621f32fd4b0fe2e17ac262c75780bd43877c56c413c2a6bd8c119ea73baf2cb821d46b7684f81101d3ed0429b6a94ad91742f7bd51b11bf4c12e5547c30e870f8e407bb5ffbdb96b10f901430eaf3e650b69b7802e93ec2c75d05183fb905f21d590e79617e4d08838a1ca126cb47d7e80a55253444682b49543b97146e71a96ddab190821a3007b28b55785442259bb2ade35e0cfe11e994f3894b7f3f5fceb341734e6b52d7e22b22f678f283" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7d7e6bca9da076e7e833dd86bcb7d86fa305755e46e252eb201982fa3a3bd7fbd5d04d9077908a694de27a236361ea68a1f04adc231cc3856de97941ac8936152c51fe55e02be1673f315281cec9ae3b3f10f1668a84c1a96ee3f0a889c22cfeb7d6175b3bc23052971ae2e88b9be6fd5454b6256b8d62bdf617ad6cb22ad93fa02a20f1a3c29cee6447dff6806bcc7169f0b94b016c6a68f0b5a581a58d41a0cab986d4660cedcf1cc6113df7423bd486ef4e4b8f7fe33f3d82afccb9c86eea598156aedc90bdbccb75fd55c254975a193e1a6937e7a5ea0aefa94de7a9667565826c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ac91aa5434938c1293186c76b7ae28a8437e621ac79c93b4b8145de9951f1948fd4cac58b781c3593a444b51751297db4dfd6bca2aa3452156f6bc412010da90270b09b6c5d0e4d8d836dadc2bdc35152ec6fdec7d1faedcb33868c81717100dca6bea92e08408ca6d1bbc7b68e7f71ae48f2fb2117697b9fdc4b46cccdf2d81bd6dc8c76c225ac71a49548b2f3788e47d56127a703e6705b08f4949738415b3392a701025775359ac29940a12161e554e50e6a6d5c0229039b25326ae1a61c93035f68c389ab2e88e8dce09b2f55d9291e6e640d411a543f5e97fa50eee2c10aedaf5fb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0502fd59c54a710da5a6c4060d3573de3ad4c9a5a570722f95ccef846e5c7a574c8bb772816a6e7dd5c56331af86139fe7fbf3d7a3fb1c44c9d8579094c622b061060ef1f3dcd77163932ee6fe66af70d854e31ecfc086979416cf3e193c5dcd19ec1a9933aac0c04964981e4f76169a937bf9a454d9ca413d6a1097dee798a5f60a20b0643acb48c7514f026a9219a8d7aee6087584ac33a8c52af289699e604f2659bd7fbb45342cc3be9e7fe7564fa0332e5c2233daa9472f59d59f38369c1d153cee628fd5ba511c0f5df6deface8ad81a2864d403273175db913047b80556da8ef76e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3d7eb388c75f23aa5a413c1aea1fcb3ba1d76123bc1834b5b973b385aa12eb0041ab55f571c7432287786ddae33539ca8777250f7f1960c973d7afbf561c274104f3c4cc033cab139247e43d98a5c814076482fe829e2eee0e302b3265676fdc82cf921935d19161ae814394cda9818f8e7c2bb4c56565790fffefa9ba86ab35816daa9bcb35f11e72637e7a6b127d084057906035914ff0ae08f71b601d755371171d249c7f87586e53cef8e175fb6312e8771ff5ead9a2f68050b8bf1add0aea7a3cd2f6d18eea57c6a7a13918cf7ebeb21113d09ce9c7a641a34b8ac22c9c164e9729ffda" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a2a3b9a7c7f17ed8c51f8437c92e8918d0102f320227682192479a094a0cd6401d689a24f0f1f0ec7ccd7d5343391a7ef7590db47c83da0b43c133c673a679b49dacce5386a92c50880ff2803489a1ab8edf6212a155dfe8e3cdeff98cb145ddc1a9a1260385ffafb175e954d67eb5816c4da009df5a21b96a5cba8e77050220abd4f0b21f87fd44bf0354b9ea270cb8e428bd2d1822c8ae57256a413016b67894a3c38ef74bda287c2ee7aac2efbf244bea3dd1e9e94b0e1a5b18295f538253d7362e0bf0b5c090ca4b537e692bdb993e1225b23565cb281372f4d3a0ce247b96b1af1db06da1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "42563ee8adfb99ea56890d94074a727c47d0aef5756145a92b1a41ae4cfeaa91351c88668afc1c4a715f35d265a36ffc103c5820098b13f0bb4ec0b761066aeb521a3b40dd40bacb45f58908cb2742e453c671754e85cfc43b12ac385dc1c72883260196658ae345ca16d16a08548fc8197709e3d026b7130bf6a0a74375dbfe619e64d35c2577f8e2d53eca56ae60d11551208ce41f95d19f789d909b4d9fcb52d289ed8862d5f1bfe5542b9fc68dd49d20f673b53a06e2ad6d74725e1180228a2dabf7f2089f4a974a22e91f3f413c2a4c18d7f5da95152a0338c3f406b71d760a9b2c32a5328b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d699a03480c769b114056f7b8c1c2f4ea6013f785216a91ab9cf02df1a72625162c74979bfdbb938f76e0248f7a18c20dca243104aacefd8e8d2c9eba6ac0123f38fdc6ed1dadab1ed473097276f6c1a50d1d6fab39f2dfa8e78cc965d5875f73c703785c77e346c4ca551aa4ac0c25fd74567555209aa5bc7b7455a71f3d6cdc94a81297d1aa2901d2be9423f91e4d2c6977355910b0bb0dfad851e87bfca350e1406225dec1c514cfd2325411425c71dbfcacd4e21338980af552e5f833e4743a96130e71988005a26ecaeeac6abca9fe7aab0c8ff320ff135195532bde17cc5cc398476fa935597" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cbc516abdb43cc8aa4d6e8c0dd28c4f8a1286d510a9ee9db7815814b635c6f17dbee4d4d18442d03faa7b21bc9756e7ab276f855d8780e2c35e0fdc4e6e1d2c7bdba75b3236e761289731461427e89ae9c36b815727740004c7aa565b9c8e52796a67a5be792c01365e6005d7bdaf71eeb26cbb67a2c503e978cc1469cf90cc5c67a0277eb78227c66c999fda6d87f6e2c8d69ca614f5335fb77333ad53bd64a904b9a588e99d5362b965fa509829bc88c5163f09ba40147e61834dab7316ff537eedbd207ab34c103c014048a33861e85d1e5384145a002b0d21cc0dcbb55ef3ebe8c595dcb910ec06e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e63a2558d900ebbee7ecf56cfd1a20b7ed133c1476f9504fa814917cbd3057c729e38284cacdf8c6e65387be06664ffbd5dba5523186a05231c377b26ad453b8ffba3439d44ea10e4a12ab7038da3c734927d88769a00ec15d39dd2d7d2ac8bef814d06bcbf804889ef46d2ed58bfe2d0bc4a9bf10594f3c4244f7460f40eb1df72d80ef4c20ea18c2af5a059ade20d634e3d0f184a6d025ce40759ddb4de99746cbe4afe858893c2a5c2f51c19e47e2b2a36c7efef85ac7bbe63657253a2ebc0915f09f288d7c2030f24c923dfd0f29b66f8ebfdf3cfbb6f551ba7d83c068ba8144e566df37b64edbf111" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c12bc01a2001cca9b3b2f8aa048c86a70fb6f9c0f03ee16e0dff7154d5989c0f22e0d5db0c05a0a24f85e89e1bf1c1c49a7343158fa5827a3031fad7a3b62cf69a24f9d6541984c498b758a70a91576c0209be7f83ff47b3788de21ccb1f2c5dde0d654b92ce5d6c4da20f0904a453d2dbb2f84b43ff4d8ae84432d896bf07ee1047af1a942c5e2576917a279846451e1ab36843ff1c7fee1202e1ff7d4fb14788bf4ddd7bdc050048d73d2375440575b04c83127a5a4189b926f777f24d9abe76270c4f1c64a3f9da133180a8f6f88f423134ecf7b49df41c57b6c736bcb2c896f754dbc07f6b4fc807f047" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "df5437f55443ccd7676aa471db84da24295903a87f02dd95e23aa468f6fd60be2e96d1d4366e2bb831c0f396b9b92328baaf45641a1c19339b768021f6aa823c953fefc56e7dd15805f4a3c0f83f9a21b5b3a7f81591febc8f0b1614813cc4b09df3a67dc11cb3d0f4d0399101da60b7986c1b7af3d19afa3a245a6c457332caa28e4c87be2596b6662992631d6ea8361c44f7b5f0ae991951b18fa187de224966fd074e2add2cd4e442ab18118737b75751c32b5c14afaf06318c2011b08e62c5c2bb35e48ab946a59be2ba6dadb3dc0e94b69ed0de84f02d6b5c61ffd4bc42cbf393b51760583477946b5417" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "491baaaf3061239f157fb02dda59e76f995c710d6170179821aa556264dd237e2eeb3c1b51efb94623e5603a0f0d3f0cce2b5ace1108e5c1f1edb359f5e1d65de4c99f1f48cca747adc58786515b955f65177e36f4f5c7fc696146fd4e7f7b9cb38c81b215fe08b6f034710cf9076b29dad70f8795bdb89bf4688c020fd2362feb2b6876fbdc9cf0edd250709cc7d059870f080ba9899f977007110274ebac11373578d11c93b1ff5872253aa395b1bd0b4e9da71c273dfd8c98c46d65d692c688adbd656bbcadd4ad4a5531e5ea96728afd25da0ea6c3b472bd5924aaff2b0e26ec6e0f0496f1cdd8c3c8cb34b4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "39d12b605a6241a2a239a9cfa9936556b2d6f8d961b6165425f0a9b8c63940db014e41ad93aa9a94e68517a7553a4979a58eb24238eef54baea5384836be636b9953893114830467065ecb7b5d8b53fe8d861001f3c16e616cc5cbe0650942b40b068dc6740ba40684f837685f0581d699ec34226967223228bb73f5449d933c2fd7577b4f5feb3c98c5cc890c86e56e666b135c9ac46ca67f0ef5f4f5516beb221006b38bb37c1e8df9b549a5ba128fe168b83752c588d0ff9ddf725d31431f0ae085b5dd9f251124e0d575f9f79b6d2c28ba8d5c79a7d106c2617f77863a95fce0ff9962e6a21c4c00647ba27e8f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c0ef3d806481d316ab62e4a75d42256f653138e6bfbfb42c398e88ee6f3d5ee2e85c5f6d407196718cda38c890111f2ca41a20238fe78903b1071591916b964e1cb15e1c357cd0f2c30aebf03a3662e14cbc1cd5bd4d58cf0054960edb9f091e3f4ed6c11a87fcdfdd84b8f5ca3ad8f1e4e5f06efd9594e1c5e5240ac9a8a373e140850d6b4eb4df20da33ce768b46a645fd73ec0fde5b799d548a12be5452492e46dba3da03fccce0cd3666ce88373ed07633024f29dc883c16245f8992b0b134e5461ad8def4922b4911e526f3e3c72b121fec0318369d1a40a4fadfa5078585494d3926b7ec6fc522fc85e3eec7aa" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d9c78eb756dc9335fed007b1156ee7d89356291bd1808b025b7ac3bdaac8597c2a68f3d99890c04578ada7fad23125dc1fdee6e183f17c332882979913fd2610352e61f4f1b6e3c711907f4c6b5ecdd5ab5659b9788ab98e734455ba2a564215c7cd147a838e4ee02f4f35fdeb38706e64d23b8dfe3a58b0e1fa76c63038dc6aae308896bf52b9f851b76f3760f808b00e17442328f78287161dc283affb00862dd500140b86ca787bd58fd20f8425d2b5735467f723db7a0f9d1d08800ec395078a5470670056013ee95d7e59eee510fa23fe899a59594a3f823a1d62017a03bf464135c6b71f405e774c25563218b45f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fb4504919408017da6d8a0622f6e95b9ed6b14db7841bd44f046eef98bf26bc834ecb3f4b7628ba3a53fc4d75075a25bfdc8536d014a185c0087fca9e011efe29e794b0e02719b617470fff50b02562a521e6c109a6cc183d74ab70b60ff1326255f8de02307cae03ff1bf49a771b5b311daa67cd4131004b2a1efaccd1d157c468637ea400caa891a531261b32f0fc61b241ff0fb8d1e8cf90703f80945a50dbf8edd650d43dd1c19dd4bcfdc202812f7dd5fe7d66dd39b3a9be37ecbfe1d0b3609c79cb19e49cafac783f02b9815912619cb3ccf8aaa47362bbb98f21fb48f61dfbe20d48b281fac8263b84b7c472b1719" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0c317a9baf295d07e050e015a73f8827778973d924707c71aac3edf5e0f13bb51ad4f391b56d9b6dc204bbfc71d091d274fbb21e38317b7844a5e1cd58225279471401512a874ce6da69b364e2bad389069892057eba683f55b97ca4d18febda810eced644b6475fb00b64a4d86e81ba344a41b8b120eb63b047a45c9251c396448b07afa0315e062f40c430cae51448eaed7946cc58c7ff05917b564e6e4f99d1522be04d235659b3dc1e3f7ab0e65a5bb1cc3d26c1589e8532cb361f6bf2ef0b6b27e57569030db4e543a684c17db3dfc6bdb984834d842fd3642412ff88453d78dbd0cfd3b0771b6c0fb7ee38261cd1d103" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3edf5d417a0d1a38a3a57e5265eb8df1542e25d90cd64292ab63713cb4a75b9c94850978fe2bd2f96f160b61c51d62eb2092d19b70c4448c2900f57f861f34425e2af6fd060c94f237fd4cccb745bee2bc47d0b4d5d8a57bd612af6109f5bb9a964bb4a6360371bec3bf851c269aad8d0f191eb7a9b77a1e98bc096a9b5586252526508a1c25cc1f6b0c1333f97c86a8799ad2ef8aa123400aa8741fe6277a2b92a6c4d4edaadc7fcae7953fbdf5ef1b499f871f66809b0d72c9b03e9b49cd5b8a91dc1c749fada0d9a4595d085f4b3e7643e239689c87a73455b31c9c5a6e0b899934408edc0dab175ce25c659c238b69e9ebbe" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "80f4ea817d4649de3f998374e11c9b41c3db5a5ac86b53031abab352171f46b893592ac5650a5218f7e54964b962b297079751c1d82bfbb9333fac445067a04473d26cf96a71c0c8092a8571d91f4413bfef40807206584d04928a5243f5ecec60e42aa3e0c83a28c8df71075d9a52ffd3519d5e40a0b20d4f4d1b21c695a249b5509a540cc0360d2906d6fddb6fa327beb9b087b1ad4d40ad435a2d589406369e7655dbd6d4f6ea340e35301b4bc02ac03ca85e55c8e50dff67718a9c1aedb6a0334bdc99f6c8b4dd52996bfd8dfca840c10aa92f6cf9d84c3994f5719fbc8d6a9592ffdada572d32aef67a9d7f9c897e08a197cb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "32d5d8e29fe1b68a49a30ef65787bf1ce003534891700ca2efe6dc4ce4b8770857130cad694451c148ed276c6843cc92597b3cd0129a043cd2d0803d82dda405b4151c5b4121bc276540c1723f4ce0f490d5ba0a4bff3a92117898d6ec362cbabd34052b6f82633f059a9f7948b46ab11cbe78d23f5a4828dfff412acf333a21cca6aacf570348a12a44c2939d360099234c2a68aff2bfc7e6fa0af55fbecbcb7d5d581a133bc46af75437147bdc42bd2cc0769098953655b2a41b5fec382ce63820ff4a447c7f62c825e68628279b8da57071a0c0a187943cfe5ac99e8447c3cb565973642115bf78cab6884cacd202d5c086ff09a5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2042c8097d147442b9e0787ad9efc72f0b351bcbc3e4037556a82e29a6f0015f0c8e162513c6529fcb5e1e790c789c0022e34ec0541128ee07f3597062ca54e4bc9ac6566861d0d3e93212c229a318b379f03e480776b0c57dc0053535d3c94ebe54887fd89212bc3f1814eccbe00918049f17b9db59aea0e5cba970ec6bae937cd059d0eacd3bffaa19dc1ebf5f5cd90681effe1eff986754b80c5817589abf4ca404bce5ccaa066c4753494b8620e0a796f7892c6ee8c62a44a9b40f7a098d344f09b45134583f860a3b59621aa31b96e094713406674a9974df69d206eb8efaffc9b7feda8ae5757406e5278873d68114e11dc57ee3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "32217f6690884421cd6b0cb94884511ed0047b3a317cd2ff899b2dc866ece06ae9473018019124ab7f91918b9410a67f411ec349182c7f9dea73fad0152716d8f9910496e83fd50c56c93d5b088548071d65eae370722ac87178e62126f3a702ad323bac48bd7c238d65033c76187baabd952d6008723ecc4f492ca401b85fade1b219b31c6ede814e0ae35e1977ffd7b3b8c3b3474a3465a860ea7f27ee4b92852b09e4343772272deb760621bac6beb48143013dbe1c7ff1b7ff51cf66d02bd59e76604ad8b3374c688a05843f8af5e66465d5b5b738712e809d87587468c970e6239594720f1200b084fdd0829f282912a86d1c6360dd" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "da4830165af94ace9b01248bf2c373911096ebd83129cf6f454128c41efce7fea91156ab30a74a521e533b3ddb21b4a48de883c0ba7028420a128b3ead0a0d15d42766ce4d0607413cce1f947fa25f4a5ba29573554e68e005978d3b14ac0216ada50e02964759625bb313926f5ee7369fb3d4f50ab7e20244d2930d7f0113a44dd4b3edee72c15d57224d24b9fe9d9c1df2ef77f7566b18b6fcbb1f550f7717d4cf50b6666da197bfe2f4c3c23fe7d1ff6f770711dcc54ef9231bfa6ff455f859fb4be342e33a623723f17976f7b014ff8f50bfd2a687622dccf55e724d17337c65a1ef721c9ae68aece4906387078f058809e2a139e9755d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1017ee9edb76500379a9eb1011cdfdb02cba68c53e47dcb2a2e29075c1b275f6a60782257b69e23e92563e8e6ef00bd99b5eac94ec223279e18422af405b0708689e8e3ae56044286c80f4de21474b4d0f8a5e525ed4394dd285abc592fd52410893a4f5b695ec9015bb3e95d9b8905ee6357122020729177042dd1b1a36f3fb33f992d4abbee44753c0d911745a186db1dfbfada785e5cfdb119217107f51e33858ddc5cfc97bafb75d838baf5e7407176db5080dfd3f4417221f0d1673db79289f16cac33e1be977f75a699658a965bb4730118202eabe34486f35664eec62610260014755d2704339ce611e759eae087b9b9ffe237bb8e88d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5fb36a00c95a45ec6e7526c2a35189980e231aa36c2c8d6a9ccf288abe52ff56f77f01a0303d267fbed331bde0c30555e0f5a298b148fece91d802e3c33c233b535e37caef41ce16ab5df52070fdc3bcff00aefc15a552b0760769011e81aa70fb5740a3a568a15b5f72bc70564630209c5356dee3e49b1e089d97d9137f33653d81758f0a38aa53913753b5703249b5bcdd0104c86998d815951d5d0ec94685dbcf98e7fdbeae10361e9522fe87ba60c49fa6290503016cfd85a478a91fc70e9d43075b167058f1589b194296c750c6693f9dc245e9b21a483975ada00217166189b99b6c56357886e9a8063da35e9d20db24002ed36edbbd1981" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c6942d36146678f56f4f8cec34f97448aeaeab84424cc0ea957292227287ffa954d5186f3e133eddd0d460c741dfc104f0015165e5efb7ee33043b97e55b2995b7887c49a5df5546459f445819a55edee3fc39743352b5b197095787710dd55b11f88d1155b051b97918885916a59dc8d64dc31c2e1eebd3995bf144c86849b992a35be67fa30bbba18a565b1aae21ad2738236014cbde288ecfcb910a7edbf33d41bf59fd81675a8fc0f3dce569d0662d6d565e8bcccb8528328aa75bc98e09163be1ff113af4d7e4dd514ead744117754e54b4bc85c194c2f074d3d27033011c66beb70e984ef7b675b70a9eb73a3dc0c3d626bba33a87cde4dd68" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "55f5d8c7a4fb578ae7f02e9d627b5ec4e6279aaeb1791be6a030e00f3f715eff486affd8539d41fd7517588cb6a08dc77c0a3d2ad6be11492cc950d44137c3209177ca50e5a48073a85ecac000fee2cc97c81ea4c82f9ddaec4ec479219ceffa06052d6c0fd57044b7c69c07b6c361269aa6e2fd6dec3d93cef32cd8a698af82f676f211053787b69194552d03d3db7ddc508efb6336f17541d7c18b18e93854d24644ca999495e8b321303b8dfe9eb430d251ee9e265dc838b1d201f84018fb89cca117954c7c059927e5eb8ab54afe5caf720292edfc003959fd93f945dabae0c3d56edd430894c103f579a048ba0c097a17fb4954df8acaa46026b5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7c4634ca8c596c5f3003986ef7a26bbae711327cc9ea020b546755ebe23e4997731fc1a9760de9e44529a8d671f99f567db7aba5d8b594ae35a61bb585cd2a950f6c216f3173614b1f96ac120085f79106732e7bb55edbfe1b525c23e4dbb117a23517ac4a89cd3d09a39b421ac1bf3f83ea763c272f3f653c3c3807130d6a998394359bc5f51047c46f77af1c738b363cd243c10d1c7a0d9db55d8e14c91bced77065d0a5c21061d181ef6fab35218aeb065b49630b9e3b29ca1d64fe21ddd2b906d9a9421eca770639084e97ca4b04cbd522a355f7e30465219a5ac869003f5c5d40401d5e049a9737081effda31c6ea9e6aaf4205c85470d5a2ca2d37" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2953a3385e63c8bc7bf7f441756deedf21f7620528ded82100ee0639658c6b973ee4878b1ed8c7a9a755b2aefaf010855c64933c578cdf5d9b93f991ea044ff020662757901c1b6014f354f061f7274c2d912eae78601944be200be650a869219a9f67890f5d6a48ab799c3676b24009642690105b20e034c6632b36956e43d049b306b0a596d0ecc0e79cb1ff11824ea31e8d023bba757bf2597bc58e83076e1c45b2f0e9b72fa93f4423589401efa4916d2f9a82833f44e2866bcbb222ddec1b5a70ac5f78716e4389e566dff0e9c1b510eae7a3106c47eb60b8b5bab89acbe46c055a7554bb1cdfa485a891c3b548c7a5f1d38c03cdfefa5ead65031ea4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d4a23a17b657fa3ddc2df61eefce362f048b9dd156809062997ab9d5b1fb26b8542b1a638f517fcbad72a6fb23de0754db7bb488b75c12ac826dcced9806d7873e6b31922097ef7b42506275ccc54caf86918f9d1c6cdb9bad2bacf123c0380b2e5dc3e98de83a159ee9e10a8444832c371e5b72039b31c38621261aa04d8271598b17dba0d28c20d1858d879038485ab069bdb58733b5495f934889658ae81b7536bcf601cfcc572060863c1ff2202d2ea84c800482dbe777335002204b7c1f70133e4d8a6b7516c66bb433ad31030a7a9a9a6b9ea69890aa40662d908a5acfe8328802595f0284c51a000ce274a985823de9ee74250063a879a3787fca23a6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5196" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ad6bad" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d8e4b32f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8eb89056f3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "410497c2ed72" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f0de771b375c90" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8662db8685033611" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9ef9f1eed88a3f52ca" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "08225082df0d2b0a815e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0f6e84a17439f1bc97c299" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "895ec39c78d3556cefdbfabc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2b396b3fa90ab556079a79b44d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "abae26501c4c1d6123c0f2289111" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bca098df9099b3f785a37ba40fce5f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "19b827f054b67a120f11efb0d690be70" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b88d32a338fd60b58570fda228a121113b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3f30143af1cad33f9b794576e078cc79062e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ffddb58d9aa8d38086fcdae07e6653e8f31dfc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "abb99c2e74a74556919040ca0cd857c95ec985e9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "71f13f89af55ba936f8a7188ee93d2e8fb0cf2a720" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "99734fdf0eef4838a7515426f4c59b800854e2fcdc1c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "579b1652aa1f5779d2b0e61868af856855020bdd44d7a7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1383d4ab4a6d8672b4075d421a159f69380ff47e4bb518d5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d3fa1412712dbbab71d4c6265dc1585c8dcc73380cf807f76a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d57868a71e7245667780455d9aaa9e0683baf08fbaf946091c2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ef80418fe7049c6251ed7960a6b0e9def0da2749781994b24593a0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ef91cb81e4bfb50231e89475e251e2ef2fde59357551cd227588b63f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d7f398a5d21c3139cff0562a84f154b6953c7bc18a5f4b60491c196b6d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0a2abc6d38f30aef253579a4088c5b9aec64391f37d576eb06a300c193a5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "02dd758fa23113a14fd94830e50e0f6b86faec4e551e808b0ca8d00fef2a15" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a4fe2bd0f96a215fa7164ae1a405f4030a586c12b0c29806a099d7d7fdd8dd72" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7dce710a20f42ab687ec6ea83b53faaa418229ce0d5a2ff2a5e66defb0b65c03c9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0320c40b5eea641d0bc25420b7545ac1d796b61563728a4dc451207f1addeedcf860" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "460539415f2baeb626fad748dee0eb3e9f27221661160e13edf39d1b5d476ee0672400" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "02de8ffa5b9c748164f99ed9d678b02e53f4ae88fb26c6d94a8cefc328725a692eae78c2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "348a61a0136436136910262ad67ef20644b32c15456d5fad6b1679386d0bea87cc1a2e2b5e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "24c32966c803434d48d2283482ee8f404f598cf7a17961748125d2ed1da987039b1ce00f2ba7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bd07cb16121d3b47adf03b96c41c947beadc01e40548e0d0773e61780d48d33a0e2a675ca681a6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a35844e34c20b4b9371b6c52fac412afe5d80a4c1e40aa3a0e5a729dc3d41c2c3719d096f616f0ba" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6df1efbb4567747fe98d218935612f8835852dde2ce3dec767792d7f1d876cdae0056fef085245449d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "48d6094af78bd38d8f4b39c54279b80ef617bc6ad21def0b2c62113b656c5d6a55aea2e3fde94a254b92" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cd6e684759d2f19083164712c2aca0038442efb5b646594396b1fccdbd21203290f44cfdecca0373b3801b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "155dfbf26103c8354362663677fa27d0e1ce3487a821a2a7171014c1bd5dd071f4974df272b1374765b8f2e1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "15b11067f311efa4ee813dbca48d690dc92780656bc4d4c56510523190a240180867c829a8b8b9844175a8aa23" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9bc27953a17fb84d5eabe95b4ea6bc03ea450274abccfb6f3938ded8560fb59662459a11a86b0e0f32fbea6bb1f8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "03b78fb0b34fb8662accdf350a6be75ace9789653ee4375d351e871f6a98ac5e782ca4b4a717665d25e49a5ae25d81" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "687e9a6fda6e2ce0e40e4d30fef38c31e3513d2892bbe85c991fc3715947e42bc49bcd079a40ed061c2c3665efe555ab" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f3886027d2049a8909e26545bd202d6a6fa2a6f815d31c7d520f705a81fa606dd695369c37aee4fa77dc645e9b05813ceb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e4a412ccd20b97797d91ccc286904fcd17c5afe8bed0618f1af333c052c473cd327637d951c32e4af047106036a3bc8c1c45" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "92f4b8c240a28b6238bc2eabadaf2ff3c4bfe0e6c61268ace6aebdeb0691450caea4287db8b329bde96af8cdb8a0fe2f57ef2d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e506834b3445e1a9a9b7bae844e91e0834512a06c0dc75fa4604e3b903c4e23616f2e0c78b5cc496660b4a13064bb1138edef4ff" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "27031955a40d8dbd1591f26e3c26e367a3c68f8204a396c6a4ba34b89672896d11276966a42bd516716f35ed63e442e116dbcf35da" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "646b1635c68d2328dddd5ac26eb9877c24c28390a45753a65044c3136ae2fe4fb40d09bf555271646d3dceb1ab1b7c8d8e421f553f94" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f6171f8d833743bdee7cc8f8b29c38614e1d2d8d6a5fff68bec2c0f4dd463d7941ff5c368e2683d8f1dc97119bde2b73ca412718bc8cb1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "45db1c478b040aa2e23fb4427017079810775c62abe737e82ec0ef8dcd0fc51f521f29fe6412fff7eac9beb7bcf75f483f3f8b971e42454b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "500dab14687db3ca3dde9304af5f54194b37bdf475628af46b07bfbf6bc2b64ecef284b17f9d1d9be41794699bc0e76c2878b3a55730f7142d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "31bba2efc7b3f415c3f031d4c06bb590ae40085ad157370af30238e03e25a359c9e133212ed34b7a006f839173b577e7015a87fdff2270fafddb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0600b3fb4b5e1ed0c8b2698ac1d9905e67e027390764821f963ad8d2b33cbc378b9c25c3ee422992d22b760222ed5697be0576d73938ae9d634ed7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4c0ca4f177d132594a4c613bad68da24c564efa3b4da0d0a903f26534a2e09f8d799d10e78f48ccdb0203954a36c5cf1bf24c076632c2b022b041200" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "97aacf2e1b013677b2e14084f097cb1e64d7b3fa36f097e189d86dc4a263bcc46817cd1ee6ff0c7ccd9acef63201cdc0e36254e19204a7388643bb571f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "71fd6846ce7adb0843d6063546a16b79b54ad6c0f018a479a45817624fa221f63525084860559d1a0679c8d89a80701c62743ec2da8419d503f8f0cd7946" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f73dfb046def3362d6de36077dae2cee2587fe95fe0800548bb7d99737897096ba59052e0dadcc1fb0ccb5535391875328637a0376a43a4d89366758dfe3e2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ec470d0aa932c78c5bcf86203ec0014314114765fa679c3daef214f883a17e1b4ca12f44433772a6e4ef685c904b2fc35586c6bd88f325b965968b06d808d73f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "cf601753ffa09fe48a8a84c37769991e96290e200bbaf1910c57760f989bd0c72e6128e294528ee861ad7eee70d589de3cf4a0c35f7197e1925a64d0133628d87d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f15413f7d6fc54bb55829f698da92ee42fcf58dde1aa1bd07d438ecdc32ad6bf2bcdbecc99f18ed43e81b33065af5a4ca29960ae50553e610c0bbf4153d580e73dbb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "84b1738adb9757fb9402ef7113581291136184d7ae35fe0b6a738da6acb0889d4d5bac7a957024e3709fa80c77d3859871ed1aa25cf488e438a2d24cfadce6008761dd" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e02814bb81f250c1835a05108396b74c7878e737654bb83155e241774d04e639bbc571b413cd9349092f926c8a149a53cd33e9b63f370b6d460e504199d2e7d849db6cbe" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "aeee4a789956ec0913592c30ce4f9c544894da77ba447c84df3be2c869100e4df8f7e316445d844b31c3209abcc912f647735fd4a7136c2f35c6fda5b2e6708f5ca951b2b0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8cfd11ca385de3c843de84c830d59278fe79b70fb5ddbfbfc1ddefeb22c329ef2f607d1d1abbd1cd0d0cc7c5d3ed922add76aadca0d2f57b66cb16c582b6f18f60aee2f7509b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "852e5ce2047d8d8b42b4c7e4987b95d23e8026a202d4567951bbbd23111e389fe33a736318546a914d2bddedfbf53846036ad9e35f29318b1f96e33eba08f071d6dc665149feb6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f225c23164979d0d13874a90ee291627e4f61a672a5578506fd3d65a12cb48a182f78350dc24c637b2f3950dc4882a5c1d5d5bad551c6f3e0093aa87e962bea51566af3791d52d65" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5f33864d882455f8ef046aed64e2d1691e5c1555e333b0852750592e6f00d3b5ec941d0c00e99629612795d5870cf93c984b45e4464ba072a34903b400a42824ac13da28c7c1cb1959" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7baaee7c3eb68c18c5ae1d45ba381803de34e36a52e2d7ccc9d48a297273c4d8644b473195bc23005f7a4f5ca790b1fa11f6a96e585e635513f11745dd97a69c1222204ab28d3c7735df" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d0a2a3fc450ef9af7ae982041feb2842901026467d87839c33b4a9e081ea63d5be60ae99ca6e42393ded45255b8f42886f87ba0310572d9f0d8b5a07ff4b6bae1f30559a844983cc568560" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3aa4164462b3e7044c35b08b047b924790f6d5c520b1df4305b5d41f4717e81f0cd4bccb9a5a6594773832b8707443adde4047caaed2293f92234df257df54ed275a9658fab483d0576d33a9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c8b4239fd7f1b893d978268f77f6505b5775d89090374322d40083b0f4c437423f670ca213f7fe05c61069725da2561646eefaea597ac48e293fbad44c2872046857e56d04a426a84008cefd71" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f94839a7024c0a16971271b6727c081770110c957b1f2e03be03d2200b565cf8240f2873b0426042aaea996a1784fadb2b27f23bc1a521b4f7320dfbed86cd38d75141365ba9b443defc0a3b4078" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8af934fdc8b3376ca09bdd89f9057ed38b656bff96a8f8a3038d456a265689ca32036670cb01469cc6e958cc4a46f1e80d700ae56659828a65c0456b8e55f28f255bc86ce48e44377bf1f9970b617d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ada572989e42f0e38c1f7c22b46bb52a84df8f7b3b773c9f17a5823e59a9725248d703efb4cb011abc9474e8e711666ed3cfa60db48480a8160615dfabad761bc0eb843d2e46299c59b61a15b4422fdf" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b11f1ea52a7e4bd2a5cf1e234b7c9eb909fb45860080f0a6bdb5517a37b5b7cd90f3a9e2297f995e96c293189b807a7bf6e7633bebbc36674544db5f18dd33020aeaf50ee832efe4d3d053873fd31ce3b9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e54b006cd96c43d19787c1ab1e08ea0f8922bdb7142e748212e7912a1f2c0a4fad1b9f5209c30960b8b83ef4960e929b155a8a48c8fb7ce4326915950cede6b98a96b6f1ecb12715b713985dacd1c1180413" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ee2c2f31a414ccd8f6a790f55e09155fd50aac2a878f9014f6c6035cae9186f90cdef0b7adf3e207c3d24ddfba8cd321b2e9228b02a1182b6973da6698071fce8cc0a23a7bf0d5aefd21ab1b8dc7818549bba3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6d6810793bad6c7efe8fd56cac04a0fb8717a44c09cbfaebce196a80ac318c79ca5c2db54fee8191ee2d305b690a92bd9e2c947a3c29342a93ac05796484638787a184e4525e82aeb9afa2f9480caebb91014c51" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "91e4694366cff84854872667fd168d2d42eca9070cdc92fca9936e8361e7266931f418450d098a42686241d08024dd72f0024d22ba644bd414245e78608942321ff61860ba1245f83c88592dc7995c49c0c53aa8a9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "608aa620a5cf145f4477694407ccd8faa3182465b29ae98d96a42f7409434c21e4671bcae079f6871a09d8f2965e4926a9b08277d32f9dd6a474e3a9fb232f27fc4235df9c02abf67f7e540ca9ddc270ee91b23a5b57" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c14f75e92f75f4356ab01c8792af13383e7fef2ffb3064de55e8da0a50511fea364ccd8140134872adccad197228319260a7b77b67a39677a0dcdcadfb750333ac8e032121e278bdcdbed5e452dae0416011186d9ebf29" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "03fcb9f6e1f058091b11351e775184ff2cd1f31ee846c6ea8efd49dd344f4af473f92eb44eba8a019776f77bb24e294aa9f962b39feecf7c59d46f1a606f89b1e81c2715ac9aa252e9ce941d091ffb99bb52404961794cf8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "11e189b1d90fcfe8111c79c5351d826f5ec15a602af3b71d50bc7ed813f36c9a682520984ae911669d3c3036223a53176794c7e17929efab2b1c5b500f24f8c83d3db5d1029c5714c6fd34eb800a913985c218071677b9885c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "69f8f5db3ab0321a708ab2f4234645dade6bfda495851dbe7257f2b72e3e8378b9fa8120bc836b737a675271e519b4712d2b56b359e0f2234ba7552dd4828b939e0542e729878ac1f81b6ce14cb573e76af3a6aa227f95b2350e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "be734d78fae92cacb009cc400e023086bc3a3a10e8ca7cb4d553ea85314f51383660b8508e8477af60baf7e07c04cc9e094690ae12c73e5f089763201b4b48d664b94b4f5820bd1540f4a84100fdf8fce7f6466aa5d5c34fcbab45" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d61b77032403f9b6ea5ad2b760eb0157545e37f1712ec44d7926ccf130e8fc0fe8e9b15570a6214c3899a074811486182b250dc97ebdd3b61403614d935cd0a61c0899f31b0e49b81c8a9a4fe8409822c470aacfde229d965dd62f51" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c31bd548e36d5fae95ed8fa6e807642711c897f0fcc3b0d00bd317ed2bca73412064618c6a84a61c71bce3e963333b0266a5656571dcc4ba8a8c9d84af4bdb445c34a7aef445b15d77698e0b13c436c928cc7fa7acd5f68867e8132993" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9903b8adab803d085b634bfae2e109dd247a7d6249f203403216d9f7410c36142df8fa56fb4d6f78136eef5817bad5ea3608439bb19336628c37d42db16ab2df8018b773baedafb77278a50926370b48bd81710203c7abc7b4043f9a1751" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4dadaf0d6a96022c8ce40d48f460526d9956da33260e1770315ead420da75b122c762762aa3ddc1aef9070ff2298b2304cf90443318b17183b60778f3859b141053e5827decfff27ff106a48cfdb0371d0ef614fc7400e860b676df3176d1a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "314dda800f2f494ca9c9678f178940d2284cb29c51cb01ca2019a9bede0cdc50f8ecf2a77e238b884867e78e691461a66100b38f374c4ccac80309641533a3217eca7e6b9a9af01c026201f0afaec5a61629a59eb530c3cb81934b0cb5b45eae" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4658b7500951f75c84e4509d74047ca621009835c0152f03c9f96ca73beb29608c44390ba4473323e621284be872bdb72175628780113e470036265d11dfcb284ac04604e667f1e4c1d357a411d3100d4d9f84a14a6fabd1e3f4de0ac81af50179" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "491f877592837e7912f16b73ee1fb06f4633d854a5723e156978f48ec48fbd8b5e863c24d838ff95fa865155d07e5513df42c8bb7706f8e3806b705866475c0ac04bbe5aa4b91b7dc373e82153483b1b03304a1a791b058926c1becd069509cbf46e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "231034720c719ab31f7c146a702a971f5943b70086b80a2a3eb928fa9380b7a1ad8773bfd0739142d2ad6e19819765ca54f92db5f16c1df5fa4b445c266215a92527bd4ef50ed277b9a21aee3fb7a8128c14ce084f53eac878a7a660b7c011eb1a33c5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3366860c77804fe0b4f368b02bb5b0d150821d957e3ba37842da9fc8d336e9d702c8446ecafbd19d79b868702f32405853bc17695873a7306e0ce4573cd9ac0b7fc7dd35534d7635198d152a1802f7d8d6a4bb07600fcdaacfaa1c3f40a09bc02e974c99" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ccbbbe621f910a95835f5f8d74b21e13f8a4b03f72f91f37b5c7e995aa3cd5539508d5e234e77a4668a42c239b2d13ef0e55ecf85142055e3f8a7e46320e21324a6b88e6c823ac04b485125c2aa59b61476481208f92ea4dd330cb18777c1cf0df7cd07893" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "87faf0e49e7e5ab66ee3147921f8817867fe637d4ab694c33ee8009c759e7d707f44c69c1b9754e2b4f8f47b25f51cd01de7273f548f4952e8efc4d9044c6ea72d1d5857e0ffeb3f44b0c88cb67683401cfb2f1d17f0ca5696641bef28d7579f68d9d066d968" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "38c876a007ec727c92e2503990c4d9407cea2271026aee88cd7b16c4396f00cc4b760576adf2d683713a3f6063cc13ecd7e4f3b6148ad914ca89f34d1375aa4c8e2033f1315153189507bfd116b07fc4bc14f751bbbb0e752f621153ae8df4d68491a22430b309" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "87d636a33dbd9ad81ecd6f3569e418bf8a972f97c5644787b99c361195231a72455a121dd7b3254d6ff80101a0a1e2b1eb1ca4866bd23063fe007310c88c4a2ab3b49f14755cd0ee0e5ffa2fd0d2c0ea41d89e67a27a8f6c94b134ba8d361491b3c20bacac3d226b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b021af793badbb857f9a353e320450c44c1030fce3885e6b271bcc02e6af65fdc5be4dc483ff44bd5d539ed1e7eb7efe3001252e92a87df8227ace601047e101c871d29302b3cb6c6f4639078afc81c4c0f4c2e04688612ecf3f7be1d58ea92894a5dab49b949f2089" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c5c1f2fbf2c8504a686b615278fc6221858d401b7fe790b75fb6bca6885cdd128e9142bf925471ee126f9e62d984de1c30c9c677eff5fdbd5eb0fa4ef3bff6a831056cea20fd61cf44d56ffc5bda0e8472ecdc67946d63c40db4ba882bc4dfa16d8ddac600570b9b6bf3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "88f8cc0daeaeaea7ab0520a311dff91b1fd9a7a3ec778c333422c9f3eb0bc183acc80dfefb17a5ac5f95c490693c45666ec69234919b83244003191bad837aa2a237daeb427e07b9e7aa6ca94b1db03d54ee8f4fe8d0802cb14a6599005eb6326eefe5008d9098d40aa851" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2eb6b1a58e7fe39ff915ac84c2f21a22432c4f0d260380a3f993310af048b11647f95d23adf8a746500833ee4e467fb52ea9f1039519fa58bcb0f1d0151558147b3c92b83730aba0e20eeeea2b75f3ff3ad79f2f8a46cbbadb114a52e32f018342aeeaf827e03ad6d583bbce" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3ba7dcd16a98be1df6b904457709b906cbf8d39516ef107006c0bf363db79f91aaae033466624d30858e61c2c368599963e49f22446e4473aa0df06e9c734e183a941510d540536377072334910e9cef56bc66c12df310ecd4b9dc14207439c1da0ac08bdd9be9f2c840df207e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a34a7926324ea96867dac6f0dba51d753268e497b1c4f272918c7eb0e34120be65b7b5ba044d583141ec3ea16fcedae6197116b16562fb0706a89dc8efd3ba173ccd0fd7d84d480e0a3dda3b580c326aa1caca623879b0fb91e7d173998889da704eda6495023b5ad4c9ad406298" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5ef97d80b90d5c716322d9ba645a0e1b7a403968258a7d43d310320f60f96235f50e9f22cac0ad239636521fa0607d2f471051b505b371d88778c46fe6787d47a91a5bec4e3900fe6ed22918226fc9fbb3f70ee733c369420612b76b5f55988d757c891d7005d17ee55783fe506202" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "140d2c08dae0553f6a49585fd5c217796279152b2e100ebde6812d6e5f6b862b2a3a484aed4d6226197e511be2d7f05f55a916e32534ddcb81bdcf499c3f44f526eb515cc3b6fa4c4039ad251253241f541558bba7413ca29318a414179048a054104e433c674ca2d4b3a4c181878727" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "29fdfc1e859b001ee104d107216b5299a792d26b2418e823e0381fa390380d654e4a0a0720ba5ff59b2ff22d8c4e013284f980911dcfec7f0dca2f89867f311ced1ac8a14d669ef1114504a5b7626f67b22ecd86469800f1575543b72ab1d4c5c10ee08f06159a4a3e1ae09937f12aa173" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "52dfb643832a598a10786a430fc484d6370a05356ee61c80a101dbbcfac75847fba78e27e537cc4eb918eb5ab40b968d0fb23506fee2ad37e12fb7534fb55a9e50902b69ceb78d51db449cbe2d1fc0a8c0022d8a82e2182b0a059035e5f6c4f4cc90278518e178becfbea814f317f9e7c051" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d32f69c6a8ee00ca83b82eaf82e312fbb00d9b2f6202412a1ffc6890b4509bbbeda4c4a90e8f7bca37e7fd82bd23307e2342d27aa10039a83da55e84ce273822740510e4ec239d73c52b0cbc245ad523af961994f19db225212bf4cc160f68a84760233952a8e09f2c963be9bb1d71ca4bb265" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d1e603a46aa49ee1a9ded63918f80feca5fc22fb45f659fd837ff79be5ad7faf0bbd9c4ba91628ee293b478a7e6a7bd433fa265c20e5941b9ea7edc906055ce9799cbb06d0b33ae7ed7f4b918cc082c3d4a1ac317a4acec175a73cc3eeb7cb97d96d24133a29c19375c57f3a4105519846dd14d4" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b45ac88fac2e8d8f5a4a90930cd7523730733369af9e39bf1ffb833c01108952198301f4619f04b9c399fef04c214bad3358999967c474b67a7c06457a1d61f9466489ed5c0c64c6cdc83027386d6263491d18e81ae8d68ca4e396a71207adaaa60997d0dca867065e68852e6dba9669b62dc7672b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d5f2893edd67f8a4b5245a616039ffe459d50e3d103ad4675102028f2c497ea69bf52fa62cd9e84f30ae2ea40449302932bbb0a5e426a054f166fdbe92c744314cc0a0aa58bbc3a8739f7e099961219ec208a8d01c1ae8a2a2b06534bf822aaa00ca96218e430f0389c69c7f3fd195e128c38d484ff6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "37279a76e79f33f8b52f29358841db9ec2e03cc86d09a335f5a35c0a31a1db3e9c4eb7b1d1b978332f47f8c3e5409d4e443e1d15342a316f442e3bfa151f6a0d216df2443d80cbcf12c101c51f2946d81161583218584640f4f9c10de3bb3f4772bd3a0f4a365f444777456b913592719818afb26472b6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a46d252a0addf504ad2541e7d992cbed58a22ea5679980fb0df072d37540a77dd0a1448bdb7f172da7da19d6e4180a29356ecb2a8b5199b59a24e7028bb4521f3281313d2c00da9e1d284972ab6527066e9d508d68094c6aa03537226ef19c28d47f91dddebfcc796ec4221642ddf9de5b80b3b90c22d9e7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "060c18d8b57b5e6572dee194c69e265c2743a48d4185a802eaa8d4dbd4c66c9ff725c93667f1fb816418f18c5f9be55e38b7718a9250bc06284bd834c7bd6dfcd11a97c14779ac539629bcd6e15b5fca3466d14fe60d8671af0fb8b080218703bc1c21563b8f640fde0304a3f4aeb9ec0482f880b5be0daa74" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8f2f42bc01acca20d36054ec81272da60580a9a5414697e0bdb4e44a4ab18b8e690c8056d32f6eaaf9ee08f3448f1f23b9844cf33fb4a93cba5e8157b00b2179d18b6aa7215ae4e9dc9ad52484ad4bfb3688fc80565ddb246dd6db8f0937e01b0d2f2e2a64ad87e03c2a4ad74af5ab97976379445b96404f1d71" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ccb9e524051cca0578aa1cb437116a01c400338f371f9e57525214ad5143b9c3416897eae8e584ce79347297071f67041f921cbc381c2be0b310b8004d039c7cc08cb8ff30ef83c3db413f3fb9c799e31cd930f64da1592ec980cc19830b2a448594cb12a61fc7a229e9c59fe1d66179772865894afd068f0942e5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3eb5dc42172022ab7d0bc465a3c725b2d82ee8d9844b396913ceb8a885323dbbbf9ef4ed549724cc96d451ea1d1d44a8175a75f2a7d44bb8bfc2c2dffed00db0328cfde52bf9171f4025770abbe59b3aefd8151c480bafa09f613955fd571e5d8c0d4936c670d182cf119c068d420ded12af694d63cd5aef2f4f6f71" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "20ea77e58e41337ad63f149ed962a8210b6efa3747fe9bea317c4b48f9641f7145b7906ed020a7ae7d2ee59435392edc32aee7eff978a661375af723fbd440dd84e4a152f2e6ef66f4ab1046b22c77ac52717de721dfe39aa8ba8cd5da27baca00cc1fffe12c52382f0ee83ad1418f4c6a122effaf7471e1e125d7e7ba" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "95c662b835171fa23f948c3c3ed27bab9b3c367bbfe267fe65f8037a35b50cd7fc6030bfce4000425ef646c34793f0762635ae70487a0216ef7428da622be895d1b6040423246511c2370d6876a5c5d2df8bbd48fb14f787b632ad2c1f5a927fdf36bc493c1c8606accfa52de33258669f7d2d73c9c81119591c8ea2b0ef" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f708a230675d83299cc43167a771602d52fa37cbc068ef9128ef60d186e5d98efb8c98798da619d2011bf4673214f4a4c82e4b11156f6292f6e676d5b84dc1b81e7cc811b0d37310ac58da1bfcb339f6ba689d80dd876b82d131e03f450c6c9f15c3a3b3d4db43c273c94ed1d1bd6d369c4d30256ff80ea626bda56a6b94ea" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f8417766ce86b275f2b7fec49da832ab9bf9cb6fdfe1b916979ae5b69176d7e0293f8d34cb55cf2b4264a8d671370cb595c419c1a3ce5b8afa642208481333522005fbe48cdc700e47b29254b79f685e1e91e7e34121784f53bd6a7d9fb6369571bba992c54316a54e309bbc2d488e9f4233d51d72a0dd8845772377f2c0feb9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3479e04efa2318afc441931a7d0134abc2f04227239fa5a6ae40f25189da1f1f313732026631969d3761aea0c478528b129808955be429136eeff003779dd0b8757e3b802bdff0f5f957e19278eabad72764aa74d469231e935f4c80040462ab56094e4a69a82346b3aeb075e73a8e30318e46fdaec0a42f17ccf5b592fb800613" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "03df0e061fa2ae63b42f94a1ba387661760deaab3ec8ffabcaff20eeed8d0717d8d09a0eafd9bde04e97b9501ac0c6f4255331f787d16054873f0673a3b42ce23b75a3b38c1ebcc04306d086c57a79d6095d8ce78e082a66c9efca7c2650c1046c6e0bbce0b2cba27c3824333e50e046e2a7703d3328ab3b82c9d6a51bc99b9516ff" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "76b488b801932932beefffdd8c19cf5b4632306e69e37e6a837e9a20c8e073bcadd5640549faa4972ebd7ee55cb2425b74cb041a52dd401b1a531beb6dfb23c4cfe74bc84f034156c8f55050ca93236eb73c4e2595d9fbf93dc49e1ec9a31705359732dda73f737ec4274e5c82626dc4ec929e5e2c7a2f5f5fb666181922bd8be575e3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ff17f6ef13abc0426b03d309dc6e8eeb822300f7b87eff4f9c44140a424098fd2aef860e5646066d22f5e8ed1e82a459c9b9ad7b9d5978c29718e17bff4eeefd1a80ba48108b551e62cd8be919e29edea8fbd5a96dfc97d01058d226105cfcdec0fba5d70769039c77be10bd182bd67f431e4b48b3345f534f08a4beb49628515d3e0b67" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "95b9d7b5b88431445ec80df511d4d106db2da75a2ba201484f90699157e5954d31a19f34d8f11524c1dabd88b9c3adcdba0520b2bdc8485def670409d1cd3707ff5f3e9dffe1bca56a23f254bf24770e2e636755f215814c8e897a062fd84c9f3f3fd62d16c6672a2578db26f65851b2c9f50e0f42685733a12dd9828cee198eb7c835b066" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "010e2192db21f3d49f96ba542b9977588025d823fc941c1c02d982eae87fb58c200b70b88d41bbe8ab0b0e8d6e0f14f7da03fde25e10148887d698289d2f686fa1408501422e1250af6b63e8bb30aac23dcdec4bba9c517361dff6dff5e6c6d9adcf42e1606e451b0004de10d90f0aed30dd853a7143e9e3f9256a1e638793713013ebee79d5" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "02aaf6b569e8e5b703ff5f28ccb6b89bf879b7311ea7f1a25edd372db62de8e000219afc1ad67e7909cc2f7c714c6fc63ba341062cebf24780980899950afc35cef38086ee88991e3002ae17c07fd8a16a49a8a90fc5540be0956dff95390c3d37629949de99920d93096eb35cf0427f75a6561cf68326e129dbeffb8772bfdce245d320f922ae" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "70752b3f18713e2f533246a2a46e38a83cc36dfccec07c1030b5204cba4432700735a8cee538b078d281a2d0262110381c5815a112bb84404f55af91652bd17502dd75e4910e062943d8a736ae3eecdfdd8e3f83e0a5e2ddeeff0ccbdadaddc95391310fc657a59724f7e6560c37dc1d5bb5db40170190f04a274c864ade9687c0f6a2a48283177a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "01f3c1333b44077c518cc594d0fb90c37651fb7b2442e71fc0a5611097f1cf7bcfaf11c8e0ac1b1cab54afba15bb9332df6bc64d8032368e3f686c8324b0114e0979dad78a5ccd3fff88bbe89eef89c4be586ca092addef552ed33224e85d8c2f4fba85ac7735f34b6aa5ae5299154f861a9fb83046b0e8fca4db32c1343e02676f283975f43c086cf" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "509283ebc99ff8d87902fa00e2d2a6fa239e335fb840dbd0fdbab6ed2d95e8275402523f7ce9a2fabd4b6c9b533288fbe914bde84365a204711d0977a7d698f4614385984dd4c137e4820035dd6737da364edff1bb62283e87a8c7ae8637314fe9b5777ec4ec21276dafedb2ad5ee1aa0ac99e34a6c01c055c8a239fd28681607f65143082cd4553c529" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c17e417e876db4e123c631f7136b8a85bfd6ce66a69180d0cd5ecfd6f037bb1c7bd7908d51f2c485bf9e92c0e1799ee5f6ab834ee481f5eb1a8020205adb4d0f90126d4e7c2c859c5a5f644bdfa9c649ff4f168e834de6f9769429732099d46d0af506ab86c6fd92175159bbc05c75db8e1fa867e6030d64250008d64c857c47caec3dc8b2ffb384d0193e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "950988fbe9d62a66f5f2c492bc8dc944a78eb3796ec37ba94b6a81a9d402ccad03cd8497fff74c5f4a03081c5fecec48574fecb21c1de261332c23108195d3f6a96ff8e433a1a30eda53dd5bb414973334f8cde5510ff759f7c17046cbb5acd8e8c4a6eecf2a9121ec3fc4b22c4daa72678194ce809024cd45c4ebb9ccdb6f854205cdb624f0787480d8034d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "552a212c403b473741da8e9c7b916d5e5e9bcc9949021ae1ca1ed46b7d4a98addbb604d9fff56175b7e0367db26c9635fa7813653dc8d610befdd09ec41e99b192a716106f4299eec8b940863e5a59cf26cdc2cd0c3017f9b4f215812bed15f69e77edf672178e13c55580982f01fcc2fa131ec3d736a55d56504c545f4be50fee83f1263e4d3f3c877cc6242c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b00c4283dd3d9cd26e44bd97cede6c771cb14f2571b51cfdaae4309560ffd165da025a1bbd31096c3aa8286e2d6dcc3e681b8d01f2c5064ea26dfd0b5156b7a7f5d1e046c5bd1628f8fdae24b03bdf7cf7366900cc013a8cbed9d7f5937c914b08f8c27683b956e1279812d04288515333fc6aba3684dde2292951f0610649d90fe61606630fc6a4cd383649252c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f6e79457bb6d0884dd223be2cf5ae412a1ed425f1e4012f75951b096aea3b9f3581f9013bcae1aff2d3fc1e5c7e06f24af6d53c2c5c238b71c71cc670b05a7ee5204400026a5c4e5ddec3ad96771e49fae4b0f75ec58049ad9d972e5749a32d90f847f1ed2a1bab83db181e541cf5c8adb6b29ecc64dc25add491d408d3eb3ddcb013de7f5ffb6de9dd7ff300a5fc6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fe1d71e1d5efa3f712d23216ee8ee9139e66bd648b83efc02cdb4d45a28cf36759ff190a84d14d9471477abefb5aea4111110336143dd80cf81e02f268120cc07d746538f968e9876bff8358d390f5b8e7eafa61ecd236cedaf276bd61865fdd3424988201dcdeda2e3e0c33c9e3b3670125dd1049106cc6df5695fb2dca443233ff440f265bbff055483bac1e859b83" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4c80163562872a965dedd8725652906156ada6e9d999027d96f49289edb92f9ef043e9d7c3377e091b27f85275499454af32317535997fb4aaeaf93565ad481ff7d45d2abddd4df4b60f71a6923ec30496c6ae534dc5427107ab4c5e656a322c7ab058d4c13ec0ebafa76576560697ac98f84aa4a554f98ec87134c0d7dca9184cf70412a324aac91823c0aca02537d197" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fdd58c5ffe88665beb7073c8f4c22472f4bc9390cdd27a42622ca55978b000ab7579f795d4de0dfcaf521b8268980ef1d20277b07567985c0fd5030784ad6c32541ac24e99ab706105a2255fc32935c0fce6fdad9bb224d94ae4eae2a3ff08836618a3adf193630647bce1952b69da4de360f59da303519278bfd39b733cf66820a5e9e971b702f45998b69a0889f4bec8ec" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ff38b15aba3794e2c81d88003e045ac6cbfc9f4833cdf896cefd8ac0c88674727ad9a9fcb9ef36574deea480e6f6e8691c8390ad73b8ea0eb3665c914b0d886546948e67d7987eea248b5feb52346ffdd965d5c835144c3bc63daf325e74b11267e32e58a914ae4521a668839d9445fececa49c5fba41f9e171698bbc7c6c97fa163a377a96456958d6e1d74f91ada56a30df8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f048c19328d60b4e59ed76940415b2c84c23883198bba5699efb0a1774ad5da6d15390c7b55d77d66f37448fe08107f42a5336408d5322f4b630e3275865fc66dccab39f6e13fabc133e5a441fe352d81c7cd9a25f145a6e2e2417d3b0bbc79eafcd7ad688c02011fd268dd44ac3f4f87b37a84a46fd9e9975962fba92c9a3486deb0c45f6a2e044df4bb79f0feeea432c5008b0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1b3e5fe6f113cce28a6f8d6f7809d3cec398cabffe9ff2ff10a7fec29a4ee4b54186063fd5307a2be393c9ecd75a37620bdb94c9c18da69b658579676ec90351d10dc33a7cb3b75798b1234f9f684d4a73a0fab2df3d5d6fdb1c1b1514d0935c1f2dd21486f91c2595b2f8f8a500ff443b9305270fb6f3da7961d9316d4ed6a135a31c4a3611d40e6585bbb34f498cd5b9a5d92676" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "740db337baa12b16897f17a85fa5685acc85e48338867f8ac9c0198dd650f5dfa7c17725c1262c72207e365c8aa45ffaab6470a0e5afefbfc3bb702a9766064f28cc8b796878dfdd3ca9d0216c14941438fc541fb5be0a13d29a996c5c985db4f630df067a5626db5dcd8df3a2bff17dc446e46e4079b8815da4318cb228c7722684e2a795a0ca56f500ea51951a6a385385d886f678" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1465f2d578d167faa017fe8f763ce3cc8dc1e8371d774ed2a8803f12585296ee71a1f2253dd16b717a81f91f0f3641018a0111182b4e65d884b0a3d0292631ad807cdccc88bdeecb476e76f72b5246a630aff6e2401fa9570f85acb73ccb4e19ef04a932a03d7b7985dbe1e5bb410df517fe362321469e6f8b0e0cef6c31d7aa8ec06aa220620d66cc0e133fdee963589b12320fc9678e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "80c051952fa6f3ef6af0f1759ec3e83c8eb91abee1de360bfa09e74b05af2475a0dbf8f9135aa25892919bbe0515898cfb6f88abc9e1891f2b2180bb97370f578973d55c13c35edb22ed80647c2a7e2884d1ccb2dc2f92d7b6ec5843ade13a608a31190ce965bde97161c4d4af1d91ca9962053f9aa51865bdf04fc23fa35a6fc3c8e888941263a26ed66c2dd0b29b2325dfbd1227c5091c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9c1e2a1aed6406052eed12b4495365f2f80e9c9645473f3549b607f20910bcd16dc3a4b173ac8d128129cdb7c76ebbc8e9a2a1ba0d822c66b367e790a69ac71f0a60ed4bff0e979148e3f3ee6607c76dbc572ee5ff17c27e4b52adebb4bedddff517f591a1977299c7cb01106f1453b098d29848ba3751c816215bb0d090c50f9e445b41b2c49d4eec83b92ce6c269ce835fd279e7cbbb5e47" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "466abda8944d0329d2975c0f2e2afc901f117887af301881f63b714f49a2f692fa63a8871fc0b301fe8573dc9b2689880cd8969e5072c57671e0633b041481dab25e65c9de404af033a11a8070c8ab70ca6d465318501afdd9940c7efbe1bb6d49581c222fad251dba4ee0a98efe22a3c4f74da05844523b30bbad6b080ac8df70a02da80bc9d477dfb869adb211e209a316d5dd1fd89a6b8f8e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0e89a873e07799ba9372fc95d483193bd91a1ee6cc186374b51c8e4d1f40dd3d30e08f7feecfffbea5395d480ee588a294b96304b04f1ee7bbf6200cc8876395d1db3ac813e1019bb68d27204e514fe4a61ad2cbd1782dca0e38b5538c5390bca626c5895b745cfca5dac636fd4f37fed9014ab46ae1156c7789bbcbb956ff7ee5ce9effa560731d26783dc6ae8bddd53a5d28133614d0ddeddd9c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fdde2b80bc7a577ef0a6c03e59512bd5b62c265d860b75416ef0ce374d544cbb4e3a5dbd31e3b43e82975090c28bc77d1bdec907aeceb5d1c8b71375b6d631b84a46153f5f1d195bfcb2af6f597a9cdc83782c5bbbb58c5188a87ebf375eee5212fa52523820a83106e8ecd52bedd60d95cd646159774389c07e1adcaa6b6f649408f33399ec6e507d61659696b3dd249996892d5986b654d94ff337" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f5d7d66929afcdff04de30e83f248e69e89604daea782e1d82d8032e91a95c1d6fb2f5578f79b51be4397e4cd7cbc608ce143fdddbc6fb6c43ffdd394a7df0124353b919aeeac025f3eb11ff246c3b9657c1a947fc534ce48e18feffada8797037c6bc7e2d9a9e2e019fe65627b3feb28e446473e3bd413047a2587f0be6a103403cb3c33fdc212dca14d8e386aa511c22308e632f5f9528dbabaf2deb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "332990a8dba55f977bc814436cf386ebbf10cb487a5f6ce83e13741bac670c6810284fbbe4e303547ef411e964fae82854e8c13cf56979b89ecfedd337aad78260060122d13dfbbf8497acb2066ed89e30a1d5c11008bd4d145b5ec353956310536304d8b8bba0793baec6d8f3ff49718a56e6694f8122078265cf5731d9ba61292c1219a1affb3679576d4998290aba3684a205c3469d40761a5c4e96b2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "efbdff285027610f03182009c89b953f19721cfcdb8accd74bab6ec4bdf3f555ab902cb0dd91284269d140638aaabd211748aa4da3b18cddc653b57e461b9ad8491807c535c08fe97d89eb587c6af19ca152e72479626ab764e8b62da89fefc8354c75a44851f985746d78715a5a92798dac1a4222be27897b3f0aa63d596aa7378545f49b259aa8518c3def8a2ec8f7aa956c43668c8717052035a7c36b47" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0eea9bb83bdc324fd21b03669aa922fbebc448e7d25e210294c07862cfa6e061731dfb67b4810633f4dbe2130d90fa1c65843af436e74219d213c4458dcac1c48ec4541fc6e3b7918ab2bc621aedda53658050900c3865ca57cd5dfa1d28576827401956d2dd8b861fa90ab11bb0b544ded9bd3d62e3278ed484e17db8f2d5dc5ea4d19a0e15134ba6986714c2b22c59c2f0e517b74eb92ce40d2f5b89e6d79f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "25da9f90d2d3f81b420ea5b03be69df8ccf05f91cc46d9ace62c7f56ead9de4af576fbeee747b906aad69e59104523fe03e1a0a4d5d902352df18d18dc8225855c46fefeec9bd09c508c916995ed4161ee633f6e6291cb16e8cac7edcce213417d34a2c1edea84a0e613278b1e853e25fb4d66ff4c7ee4584e7f9b681c319c874d43502534e8c16a57b1ae7cc0723783807738a55b661e617ee285bdb8b845607f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a76b6f81372df09322098868d469fb3fb9beafc5edb32c674974ca7032966aaca5b5c9bffef87bfe626bd8e33d1c5f054f7d5acd3b91ff95324d1ae39eb905b9f2694fe5cb03486cee86d2f661a751b0e6c716a61d1d405494c2d4e32bf803803dc02dba2c06eecf6f97fb1f6c5fd10cfc4215c06d627c46b6a16da0854e4c7c873d50aa1bd396b35961b5fa31ac962575230c07c369f8fbc1ff2256b47383a3df2a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f9db613812f2259972d91b1598ffb166031b339913925ee385f03b3b35dc4b2f1ae78a3c3d99c6ff6a07be129ce1f4b8d994d24988d7fbd31f20535d36ab6bd0592cfb4f8c1ed9244c7fa8a3c46e91272a1a40c6cfcf261c5658476c59793bf1a3775086e41a0492f88a31e2d9d1ce75cf1c6b4b928b3545d838d1de6b61b735d921bcf72e4e0615e9ff969ef76b4b947026cb016e2660ba39b0c4c953369a52c210de" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e601c7e75f80b10a2d15b06c521618ddc1836fe9b024458385c53cbfcedd79f3b4239598cd7b9f72c42dec0b29dda9d4fa842173558ed16c2c0969f7117157317b57266990855b9acbf510e76310ebe4b96c0de47d7f6b00bb88d06fad2c2f01610b9a686079f3ed84613ba477922502bc2305681cd8dd465e70e357534503b7cbc68070ad16d9c51de96ccf0aae1599299331c5655b801fd1dd48dddf6902d0e9579f0c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ee5ff4ca16d1bde59ffaf2d064eac9141c1d8f120ea2bda942b7956ba3effc5f1e725a3b40b0b9223a14d7a50df1681d14ca0e0eda7bb09c428fa3b2701f83a7a3e139485a118f6287d266dbc7fe68c87b35becabc7782537c79cb8165bdc40cc103d7b6d4b627fafa0e4113f92341ab90ceab594bfae20dadbfafd401684584598941f1ffb8e23dc8a04ecd15376cda6d849fe0dfd177538c62413622d172d9d46e05c450" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1daca80db6ed9cb162ae24aae07c02f4126f07cd09ecee8e798fa1bc25c26c644333b63731b4ebc3f287f2318a820c32a3a55fc976576bc936f7384e2553d2891e3771ff24dd4c7f0256906460a8f12d30ed2b23583a0259cb00a9065a757d654d6e4603e7c7eb4a8426b527ae8a849d9350e9094b890367df3e8b23ad2df4d7dcce416bd8ea3badd037f53f7b07c02e5926515f196d62aeb9b8b14c863f067fc12c5dfc90db" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "27ff4e58a34ff1fcd66855d014ea17889a3cf0021a9fea3fabfd5b270ae770f40b5439e00c0d26bd9766f6fb0b4f23c5fcc195edf6d04bf708e5b0bced4f5c256e5ae47cc5651e51cd9fe9dc5d101439b9bc5cc24f76a8e8847c72686e2af1ce7098ad7bc104dad00c096a6d48b6453322e9cd6773fb91fb1eabd05dc5185a9aea07a2f64c6fea9897681b4428aaffe1fe5fd3e8ceb890b12169ec9d51eaabf0ca3d5ba415770d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "75e2fb56327983b04f640717be8cba6fef3655b4d8e5539587d6478356ec397efaed818b8425d052778eb30ef0dee656c52c2aeab079ed496ae4441a365f2130432c87ba757e25b4511656ad15e2eff84d342331fd2814d1f1d11af65d98a424c115ba183437c0d0aa55f5c44b8685028a47d89d0d36a0f20aed510c366ab338f074a941b404fb349caaec821e0850a627777cc8f5abce6b509290027a2a28ff1db62a5ed2f95fc6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c6ae8b6a060917cd498aa7874ad44baff73efc89a023d9f3e9d12c03d0b7f5bcb5e24e1bc2ab2f2c67b9a9d36ff8beb51b5affd4a3510361001c80642955b22ea4bf28b81a5affe5ecdbabd8d17960a6af3825a4522fe76b3d720b5d06e66bff5379d7a8de1f5cc3e7bb75163a854d77d9b3949bf904b6c4e568682f0dab7f217f80da7303cfdc9a53c17b6b51d8ddff0ce49541e0c7d7b2eed82a9d6be4aec73274c30895f5f0f5fa" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "606c9a15a89cd66a00f26122e33ab0a08c4f73f073d843e0f6a4c1618271cfd64e52a055327deaaea8841bdd5b778ebbbd46fbc5f43362326208fdb0d0f93153c57072e2e84cecfe3b45accae7cf9dd1b3eaf9d8250d8174b3dade2256ecc8c3acc77f79d1bf9795a53c46c0f04196d8b492608a9f2a0f0b80294e2abe012dc01e60af94323c467f44c536bf375cddbb068c78432843703dd00544f4fff3eaa1a5a1467afaae7815f80d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "88b383cb266937c4259fc65b9005a8c190ee6cc4b7d3575900e6f3f091d0a2cefa26e601259ffb3fd03083270eb63db1ffb8b4515ec454d12f0944f8f9f6869eedc2c5f1689766a748d74e79ad83ff6a1639aefdec6109342dead31e9cead50bcc00c5b2206e8aaa47fdd01397b141880490174141a1e6e19268378c1b54a84aba60ca711fd72f7df88e120dfea2caa140085a0cf73342f3c588b7edfb5b5e5ccabd68a32364746d92d536" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dc0b293f1ba02a326743509f41efdfeeac1efc45137ac03e397a3273a1f586a0190cfb4ea96d6c13ca692a4de6de905c8338c3e29a04cbae76272f568b9d795cea5d758106b9d9cff6f80ef650d6b7c428ea3946c3acc594907fe4227ed68faf31f2f6775f1be5139dc0b4d73ed6308fa226b9077561c9e4c7a4df68cc6b819b0f463a11b9a09682ba99752c4db7aea9beac1d9279f2c2675d42b551d27aa2c1c34125e32f2f6f45c35bca45" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5d801a7413311e1d1b19b3c321542b22e2a4ccbe340545d272abede9223741d9835a0fc80cc9da97a13f8bb4110eb4ad71093efba165b1edad0da01da89d86726e0d8e42ae003b4b50297d233c87da08406f0e7fc58ba6da5ee5ba3d2d7142cbe6632734eb2e7b7863c15cc82198ee8f9a0ae0b7f93bdbda1ed269b3824d5d3c8e78513815b17a4c0cc8c9706b9c77423a309ae3fd98e1e05cdbe9e2577834fd71f964301b10b66c316a2d8f2c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2fd32a2bc15a9e96a100624404fd0a4e54ba9f8c0543d8ccf7c5c2e35f5e8c3c11dfd497320aa903900a4ca55a2b323b3ac4a7cfcd01bf0b448db8829072bee6b77c3d7bec2e1d8b414d907288d4a804d2379546ef2e2dc628269589164b13fceb32dba6fd5d48a956ce0b5c3eb28d894a95af58bf52f0d6d6cbe51317152744b4ccfc918ed17fa6856478d580b389016b772e1d02e57d2217a204e25361d91d4845a3fa20fefe2c5004f1f89ff7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f537b437662759bef8bd64368536b9c64fffbddc5e2cbdad465c3966b7f2c4bc5b96767ef40a1c144a4f1cd49edc4cc5b57e7eb30d9b90108f6fd3c0dc8a8808b9e0bd13aa3d661c4863637c5e4ba286553694a60bef18801299ae349df53a355051dcc46a7d003c4aa613808f430e9db8ca7dfe0b3f0a4c5ab6eb306aeb53e11a01f910064fbe6ca78b2a94fac34a2602f73de3f275953e13ff5c6bb5c39b82321ead17ec0f8ecc479e6afbc926e1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1dd9fb7d5b5d5074971e69300720014deba6fbdb942bd29704cdfcd40fa5281d2a1b9f5b776183e03ff99c29587f10e8d325cb49c5c93e94f5132741b92c4086eec1374dea5c1e772cbb230c7b31f3e962eb572be810076bdb926b63732522cdf815c3ab99bbc164a1036aab103cac7b823dd21a911aec9bc794028f07b7f839bae0e68211286441f1c8d3a35b281fd321312577bbda04f643ecb2a74ec4527bb5148dbccbeba749f5ea19b6072366ba" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5bd63737449de2d20ca63943953338ecf4cdd6cd0a726241adb04376385a809cc6ba0f3482a310746fbc2cd5eb214f03a14cdc548777fb0d048d659cd75a962e490c4fe47affc2430a34b10275e4c76752a115aae3a24d4fb4fad89ce4d79d65de10292f3490bfdaeabfae08ed51bda6ec8230e66cb07ddbeec26e3ef68dd71c852900659fcf0c963f4574ffe4626a33db9abf0873dde68b21138498b81e8cc44d354be4073615889a7ddff633b5447d38" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a683ec8250506571f9c640fb1837e1ebb06f123e745f95e521e4ea7a0b2b08a514bbe5bdfd316903d1d6a05f5a143d94dab61d8a3a146ab40b2d6b72df2f0e945875a8aa7051ed115975f6f1567cfcbf04c5e11e3a7027b8e179ba00739181ba10b028e3df7259d0712f4a6cef96469ff737865b85fee2c2db02a6423e32505381e18a1e0b4ce3c7998b8d6b1b5e09c3a280b85486d0984c9e193b0ad2043c2bc4ad04f5b00a73956715937eebf6b3e27afc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4df9d160b8e81c42930c48956fcb46b20b6656ee30e5a51dd6317876dc33e0160d31280fc185e58479f994991d575a917073b4439919c9ac49b6a7c3f985211d084c82c9d5c5b9a2d29c5699a22e79de3958d7b0e856b9aa97493cd4563aaa04fa3977a9bb89e0bc06a82296bdc76d20c8d393770176d648712454305fdfcf4e117d05acb5a5b006a9f8d0dc66dca708c4e4103ca825d2331750685c44ce3d9b3e753455580f4d6ac4533edeeb02cebec7cc84" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "67bb59c3ef5ee8bc79b89a673e331e581215076cc36b68f517ca0a74f74efafe9dcc240e6d8ca4b21019c27d6c9289f4419b4f218eeb39eb741c5ebebfe0ed2f6faeec5e8c477acf71907990e8e288f4d4049111779b0635c7bbec16b76493f1c22f645745fdac2b383679fee573e4f47af45ee08d84f63a5ace4ee1c06fa41e2e6e14b7bc392e38426813087a3a461efc62ed1941dc8f1728a2bdc04fde72a0b786558783c84abd4bd100e4926979a0a5e707b1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "d341147169d2937ff2373bd0a9aefa77968ec8f0d993c6f9881eb174a1911e05cdc45993cb86d149a754bbe321ae38363f9518c50dd3faf087ffeeeb6a058b226ccab7858c00ba6de0e8f4d034b1d27508da5cc473f3a413189ee6fd912d7750486912944d4dc34405ce5ccc3885fb0aabcb922bcfa9081d0ab84c288022bd501235a835eb2e1124ed1d48fd4f8682da8e7919321031326502273375625c4e3a7282b9f53452195e53c6b4b57cd5c66f621bed1814" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "27e7872a54dfff359ea7f0fca256983f7600236e716e111be15a1fe72eb66923ea60038ca2953b0286447dfe4fe853ca13c4d1ddc7a578f1fc5fc8598b05809ad0c64a4363c0228f8d15e28280837a16a5c4dadab681e28968ae17934639fbc124bc59212138e494eecad48f6546c38366f1b7b2a0f56f579f41fb3aef75dc5a0958b25deaa50cb7fd1c69816aa9a51874a98e57911a33daf773c6e6166cecfeec7a0cf54df01ab4b931984f54424e92e08cd92d5e43" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "13dcc9c2783b3fbf6711d02505b924e72ec6736131159017b966dda90986b97522bf52fd15fc0560ecb91e2175322334aaaa0097e1f3777c0be6d5d3de18ed6fa3444133486068a777443a8d0fa212ca46994944555c87ad1fb3a367db711c7ebd8f7a7a6dbb3a0207de85851d1b0ad2f4149bdd5a5ba0e1a81ff742df95edee850c0de20e90dd01753137cb8f2c64e5e4638ceb893a3879ae2c049aa5bce44d56bf3f325b6c5029b2b8e1b2da8de7d4e48ca7d8f6fbdc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9ca875115b109eab538d4ec7023600ad953cacdb49b5abe263e68b48eafac89a15e803e838d048d9625972f271cc8f36344bed7bab69abf0bf05979a4cfff273b82f9961626509765fcb4b4e7fa48212bcb3ab2b1f2dd5e2af768cba6300a813514dd13e4d269e3d36548af0cacdb18bb2439ec9459f6d847d39f5598304ec46a26d75de1f9f0c2a88db915bd26e45e1f1e68c5b5b50d1890e97a3803c36755f026863d14176b8b57f42e91d3ff37787f9b38e333e9f0433" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ec006ac11e6d62b6d9b32ebe2e18c002353a9ffd5dfbc5161ab887770ddd9b8c0e19e5321e5bc105add22e473050b71f0399327c7eba1ef809f8667c1f4e2c7172e10e753705e9a083f5bce88d77521225ecd9e89f1e1caed367fb0275dc28f620fbd67e6b176c9ae5d2659e6ec662116c9f2bbca3a93043233a4861e0688db6dc1800f752c5d58aa5033c250c891d9126e534ed921a9026eb333333fa8292059b8b446f336ca6a0cb4c7946b6aea3831653122f154a4ea1d7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "23deadc94481ce28188f3a0ca3e85431964cb31b60fabf381e6bd45ef0332bd4dde774b0281d317dc2e7d0c298fcf8625fa734126968df8b68ef8a35c325d84ba4fc53936ff3ffdd8838d2a8cabf8a9cac54aa444ed9875944e55994a22f7fa8538b1e983b57d9215fac5c0052029644044e790ce2f5044655608c1d7ad3bb862203ba3aba3b526606f273d342ed5721648e3f600942d3f7546f679161436389d879dd8094e1bd1b1e12cde15cd3cda4c30a40835665e4e5cf94" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "94701e06340114f9cf715a1fb659988d33db59e87bc4844b1500448960af757b5282f6d52967a6ae11aa4ecfc6818c962b084c811a57724f5d401191567f24ce917e4f8c3963474fdc9d2c8613c16f62446448b6da6eeae54d672825ed7606a90e4611d0e318ff00566862c955b636b5e81fec3362e8672ad2a6d222a515cf410482836deba092a51a4d464dfbbab35c50a33437ac16a88256e9e23ddd3c827cc58d3e5000ee90b12e4c5175c5733662d4848ae0d406c2f0a4f498" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "735b0758d5a331b2304f01081172eb95ae4115de651b1a6693c5b9543de33df25d9f421dbaeca033fc8bff57313b482778005aa9fdcbca65c643da2f3320e34197868eec3848ff3c70d7ac7d910fc332e9a359f892ae01641be253013b554a0d3f249b3586b1857e5a0f9482ebd91432a852b221f4287a6e81ed24e8064645d5b28ab9a13b26cc1420ce73dbc47b31acf8a871601022ce23bc443b1222ce9a037a2fe5226295feb4efd4fd671338f459ae146032697cf82fc55c8fbf" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c48d94f14549352790079fee69e3e72ebaa380510e3581a0824066413e7044a36ad08affbf9b52b21963d2f8e092ff0ac1c973c423ade3ece5d3bca852b894675e8173290529226939c24109f50b8b0d5c9f762ff10388833d99bea99c5ef3ebb2a9d19d2231e67ca6c9056d8834730605897426cd069cbeb6a46b9f5332be73ab45c03fcc35c2d91f22bf3861b2b2549f9ec8798aeff83ceaf707325c77e7389b388de8dab7c7c63a4110ec156c5145e42203c4a8e3d071a7cb83b4cd" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "553e9e0de274167ecdd7b5fc85f9c0e665be7c22c93ddc6ec840ce171cf5d1d1a476743eb7ea0c9492eac5a4c9837c62a91dd1a6ea9e6fff1f1470b22cc62359474a6ba0b0334b2739528454470f4e14b9c4eeb6fd2cdd7e7c6f97668eebd1000bef4388015630a8332de7b17c2004060ecb11e58029b3f9575040a5dd4e294e7c78e4fc99e4390c56534a4e933d9a45460f62ffaaba25da293f7765cd7a4ce78c28a85013b893a0099c1c128b01ee66a76f051dc1409bf4176e5afec90e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dea8f97c66a3e375d0a3412105ed4f0784f3973ec8c57b4f553d3da40fd4cfd39761de563ec96a9178804641f7ebbee48caf9dec17a14bc8246618b22e683c0090259e3db19dc5b6175710df80cdc735a92a990a3cfb166461ae713adda7d9fa3c4cf9f409b1467f3cf85d2141ef3f119d1c53f23c0380b1ebd728d7e932c535965bca41a414b6ea5bf0f9a381e098d282a554a25ce41980d7c7be75ff5ce4b1e54cc61e683f1dd817b8e2c1a430d7f895e5e7af13912cc110f0bbb95372fb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9dfda2e2f732867e60ed2b5fa99ab88eb82dc7a54334d02031258beef75fa4bd6962a1083b9c29e4eeb3e5ab8065f3e2fc732675b8d7705c16cfb4ef7305eb58120f1af5ddc55872a2cbde3a48661a0598f48f63e2e9aadc603545e2b6001748e3af9e86e1830af7b84ffd3e8f16679213d37cac91f07af0af02b37f5ed946ef5c955b60d488acc6ae736b10459ca7dabeacd7dabcfd656511ac913174f6d99327be59befe3e463a49afbb5235f0ce2840588c6edfbaaba00a4211c0764dd638" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ddcd23e8b9dc8889b8599c721e7f8ecc2cbdca03e5a8fd5105f7f2941daec4e2906c654210bdd478374ddee43ee749a920ee91872e057a1157d384dcd111266221b3c79774476b4862fe450704ff2c5353e9a936cac87c96515c28ed4c830335a55d084cb5873c5fd2dd907f3266d8eb7bf13b6dd7cd4966982a0949efd8e428dae13daee549e01cc3c226211d6307823f742c5ef2155601a4644c46eddd603d4abd959c6d242e427768df3b1e22d87971df58a1564b38311a897c85b497a72556" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "39016647acfbc63fe55a74598bc1956eaf4e0cb49d532c5d8323fc6a3f15a0231597f06eafd74ad245e672bf6b21e4da503cb5bf9d15e9038ef354b38807564d91f38b4258378ccd9b9420a1562d7136196822a1291c913d83c4cd99fd8d420990c72cdc47607124de21da8d9c7f472fdcc780379f186a04da93cd87628abf323c8dadcd7fb8fbade37d7d2b5c9f9fc524ff77494c98f42f2158a6f68c906105ca9e8bb2df463863cfc1e9008d8344f55c4e3203dde6699b59812d49ce1279fa1c86" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "02cff7567067cbca5911664c6bd7daaf484181edd2a771d0b64566c3ab08d382e83932cdd7b4dbf86c9cdd1a4c353a511e68afb6746a507a9cd385c198246f4543d606c6149a5384e4ff54c1b90d663dc7a4b91aeac3cf716db7ca6f9a1914e3a33efe82e7ccc4215999c0b012782402db4726db1d7d1c73571d45739aa6fcb5a20eeb54a84d5f99902a8d356cbf95f34c9c28c8f2badfbc08c69233514493c0c04963268c88bc54039ab2999c7b06cba405936dfc43b48cb53f62e18e7ff8ff3f6eb9" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5764812ae6ab9491d8d295a0299228ec7146148ff373241a510faee7db7080706a8dada87938bf726c754e416c8c63c0ac617266a0a4863c2582412bf0f53b827e9a3465949a03dc2db3cb10b8c75e45cb9bf65410a0f6e6410b7f71f3a7e229e647cbbd5a54904bb96f8358adea1aaa0e845ac2838f6dd16936baa15a7c755af8029ef50aed3066d375d3265eaaa38822d11b173f4a1de39461d17d1629c8df7334d8da1b6401daaf7f34b2b48d6556ae99cd29ed1073926bcda867421832a4c36c7095" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4df3043cf0f90462b37d9106e67366d112e4938c4f06abae97869531af89e9feebce0812dffe71a226de5dc36be652e26ef6a4be47d9b2db5cdd43809a565e4fc0988bfe82037c505dd276b757b785203249fd083fb474a25acccc9f38dc5164ff9097e05989aa6e280739a755231f93670e7226e22046914c155bf33d135b3f736ccca84cc47ae643215a054b54b7e13ffcd7ad73cced9279dc3210b80700fcc757acfb64c68e0bc4da05aac2b6a99d5582e79b303c88a7ac4dd8ed4289516bba0e243527" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bf041a11622715426c3a755c637d5f478dd7da949e50f05377bf333f1c62c671ebdbf9467d37b780c25f7af9d453fc67fafb2f065a3f9f15d4c3561eeaa73fa6c813bf96dcf02430a2e6b65da8d174d2558110dc1208bdcb7898e2670894c0b9e2c894da3b130f57a90ec8ea1bffd27a37b4da4645c546b2b141db4e2c919154dac00e78dd3eb6e4445974e3bb07905982da35e4069ee8f8c5acd0efcfa5c981b4fd5d42da83c633e3e35ebdc959bd14c8bacb52212b4334f94aa64d2ee183861db35d2d8a94" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a170ceda0613adc9c3a1e427f07beacf3b16ed69fb42b6bc09a38d803f632ad2929dba215b85683b74e2feb1d18fe17d0ea0db84d1be4e2e73476917a2a4cff51d6eca7c5e82232afde00dd2286a4c20eb09800b4d5d80e7ea35b6965b9792d99e399abda8cf32174ae2b7414b9bdb9d63e148f7357635a7310b130c939593cd3479164724011966c4232142df9966f09422f34f20b30af4b640a2c6d3dd985fe0ba3dfa9083cbb9b8dfe540ff9f6c608d18481213040768ef33300d773f9890c724ead320a1e7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "929477e9c2d0bbad3429a0e0de776695255013108261dc6404cb09828770e274d8bb650a50e490dfe917fc2047b0f8ee72e105927d9fa70523c727778cbf6ae876d641ad562938c870d12f2e047bb78920739dba0c3f8ce1fb77589623a5f1625f5d6ab81940c7dfc3dc3a641d82b2813629bab8282999317d6b93842334f123fb4693a9c2c9d8ba9bfc746642dfbd045cd2021b272eab7358aa954d453da53fc5392dfa7eb881f6f53809b692d27f3366595ff403289efcc691e118b4744a1147071d8909bef1e8" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3e98bb14fff5bdf7db38a3960dc55ca7d02333daed8712cca13dd5bffd114636559279db72554cc0a0ee1f7e15557d77cab0f2f1131f94fe698db81be38300a856a5eca85e5cf915fb7b6f38ccd2f27350e62cc30ce10ffe835118be3d435d2342ed3d06199b7e20c8e34d68902f0ab8745bd8b7d5b863d525c1f5906d2dca598db8a0f1e67736182cac15677579c58b8c670cae1be3e3c882153b2aa2988933e579ec2d6dbb00c671da64443dfc027dee6dfc3233c99758304570a982bf9b2eb59ccd70d0b54c4b54" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "aa12c7fa50ffdc2811c1872e4bee15f43e6909212385c872eb489f7e06dc1787043f56126f8373bdfa4b3f61405c73dd4dfd3f40aa5cd207e8520849c26f67716a46c0989a99efff42f24e0736e327af8e607c401a1bac77341e9a78c91e35d55b2457bdd5317a405a1fcf7a2a23de68ef92b65819e8aa3807c545361dfc9fe89125123492da958dc313cb5d03cb4b192c54ac6b27fcbc498652f5ed36b587bb74942b3ad453a8d79e5ddc06ebf806dad5046b73251064582ef5777dc530f8701701761884783fdf197f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "83e615cf6e17a29e63945710b548a6d9935850eec69830841e26cb6071e908bf72c87cf079ffb34c5eb1a390def72d004a9488224a18e189aa1092a0f1135712834d257a53dc1d0e2c6417d8f472ff13b181910f4c93a307420d44beec8875d5219a3160b8e921434ddf3f71d68db1c1d5c39d68edb7a604792f8b4e31ecda7895c99fc7031a5b98a22009c1da005ac8fd2da0b5d742743f5712d12fd76d11a18e487776ce21ca0d6e5ab9ca6d8c394c321b91c14e291399a642721361811a73b7392e8603a3004e7060bf" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ae1a8f7bfe4b1a0fa94708921dadb2c20b938239d7b9a2c7c598528f20f49764d322ebe85a5b2ea15563cf2f2304baf55d6607c52e2e1160859dcb7af6d7856899eada0e9128a180d3de6fed9334ba52b80c5c362d5591a0ec30f86d37a399927eb1c53076a12d26775522c511c83eb5b7abc2a00bd2dfd5627a8febba53d85f9b74c4b7f0c862ddb0d9298899b646b774d6cc23e4e23ab47174fccd34499253996d5e0917210e2f6daa1685f89f2f1fdfd5509ebc38191d539ecfb54ff0f5bbe6ef36ea35d425af6462f518" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d033e06be253ab800c8176d3a9650ab2a5bcaa03e11ea95fb9ab3834b41eb0d1b2bcecfe219364c3104ef65a8d692bd77c798548b7d9a8faf7f5172db24ec7c93006d6e9839368291b8277a82c034a3731f1b2e298d6e0282ec8a7902e4f844d132f1d261d171375c646065e201849f2df73e3748d853a3122c2206aac92fea448500c5418ecfb3d80e0e6c0d51f85831ce74f6c659cc291f5348a1ef8b949f1b2a753633e382f40c1bd1b2f44748ea61127b6f568255ae25e1da9f52c8c53cd62cd482788ae430388a92694c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "104bc838b16a641749dcf73c57b207ea3bcc84381170e4ca362065a3d492e892b426a1f4fd82f69461d1ce1f3aaf8fc291ea30d6667e7e1aea4c44f7d52a5fa6d34709e6658483260ff5da76bfb74e7d194ad40dcac00daf0e45e74db4bc2248100a8b256b257278c3c98f1f2e3a80cdb812352aaf4155b3a4033999fb9fe7f506994fcf3a8db31e9e5ca8ef8c2e9c6326ca5b0803724ba641950eca877fe6ed6afc2e014651c56d0e6a61eaff7c5ed0b861d4bebe42904c0a568c26aa8abb2e97da2bfb40f14eafb6bf16cd208f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5b92e4a175437d0a53eb10de2c56401720b11715a034459ebf506c3fd6534b5e817a0f09deac4bcfd353301d8d031b1331582ac09189b48e6ccea444655866c4bbd123d45ebabb774f877cf12d33b84cfca4a6a94f3f98869fcf2bbb6cc1b964c2438c2f348bcdf9001dce60a4706d20c169a040baa61cbeb0b8e58d505e6e3739ab03e110ae7efdf91347474033defbd1e86af322ec6456d3394699ca7ca6a29a70d9b10a38fe666eab2858bfe12dacb31568549c826c15af5b6fddf779954351be1872f04e53db7b3b5fbf61fd18" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "401cc7bd9f8227efaed70dad83fc8db3bd38efc166f0f11ab142c565c68ba9db680423a3d698b6f3476ef440051fd20b93f6a2ed045825567df5a65e3f62e4442ec396ad260a16a13a1dee46c7e8d88bdd7edf223ab76a9a787c1f4fe9925c051a4ca0e77a0e78baa29f36d193c862fd3a60653f544ea9e3f75f2f553891be8c1fb882f6a6aad118f576f3c2793efc67221b37a45ab6137434f6228cb002fc137b91fb8572c757f00736879453d64a8a868c131810ffdad9e9d028d132157ecb1da675d54047d19b27d3258c9b1bca0a" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c20cf0354982ca6a19d9a4dbf78f810934db2373941a12c263adefa61a5f385c859bc47028829c531dc25ccc0004c7510e707175a102ec3c4b4c933e3f52033e67476ff5f864c446c042a21e6037f7798363d20267891b965879fde80af6b59d77862e3a229af01b7ac78b578e94bd9f9b073c38a627c1864df0083aabb17024bdab6c3c0f0f73d31d59480523a2f23b78baa0385c15f290114305d7f98786b7dbc17a8c2aad97448e8ea389e68ef71091a6a9735ac12ca5497b9171da11a93c28d3273f58b74e2e46279d3ce9d0b20d19" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "e2365c2754073b511f16a1881ff8a537541ca7362ae7b84223d3c7d1d49d03a37d6d05dd2b819af9705c015dacc9dda83474eb14b7d5fce6e8a8f8c58e870149338d320e5ae476da6749af45e65ffed550d225a39dc74ffd93ba7da476985d6f44e90fc8e82454496260458431804d802fe804d825f611772f9710667377adfb1a11e4275bcecb42175c515f6a9439a359824f82cc9d480954364e6693099a821ace362e6c7ecbe68be8823bb5b49b4f23ad81b64139e3b63d9d4d298a842f013ef0d91ce7915ee8f816c70ba2aa3994216f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9c43944676fe859327096f82049cf69e48b98715878400fdf2805e0d5ee642e6cc9c43739f418b701348a033c5cb96bf8702fcd2fac9be58262a843c1e4155ed8a1724b6ebf7cce659d88a95a0c54deb2d7d9574a45219b6419ee173d1d8fad3ace47c962b349abe1048565df85bbd0eb9b11698258c23598023a00fdd26573e41951452027125c6e894a97736ecd63fd15b29a55d8dd9dab7e2e18f541a2e341890a61b7c896e7dc67aa82f3479dacd4a8ec7558d40c34d9ae4060e13718d676c2450258d83de8a86e012813693098c165b4e" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1c707c29582d98a0e99639211102f3f041660ca03ad0939fe3855b8c1b22d6a9b8673c93e3eabc0ab231509b2b0d73c76a290a363943d12d2ff0ea30c6dd54eda753767effe04cabb4c3966388fa4c83a1906a0f48519a5fba9aeb585e0f8c45d6123a75ebe98fd1d0272f733a3925119481a321fe7509346c05128302851ba17a137f956f184e057a305e79a148727a5926de6854eb0314d5492fd735fa773d99ea34c95ca7546bd3a3aa8e66bcc6d860cec3d35d0e2165d5fbe8be99b6e7967df6693e5a6243e94c9c4a2528ae6305cbeca209" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8f1e88103ffa378f062cade0ec509bec99a5c73fb273e79dbef24abf718ac26ac23dfd2b8932038ed3cb9637b71643c161142019f45b25b4fa4c52356737a27027e805ec635154327a66bfe64efc6285cca98c34edc7fb6c0766970a545342cf840aec0a5ba1dd3c6949be4fe97b0f8c8186de07536fd9074db34d09b2f08af9dcf9424d6edbf9cd044102c0e5dc35aff78c36d079dbd2c500e19c8c985ae2abaf6b2a20716bb719754a8840ce97632116c4d0b0e3c83ccca27f11c4204b76b5d6cfe6348a9615d8e4af53500dc4c2cabf12ec8c76" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "b9a0c28f1a6156992c103a84655fc6e654fa6e45e45819513afa797024717c00cc195994512fd53ecd1e12dac4d2448e0c40308382312084d2111f7db147b2e6589ce6d977f6115f629508167df8f45bac98abd49f6b272bcc4fd874dd5e29fb6daceb2d727a2a892194cfb9269eda00626ac89b4e74bd29b21e9f6ef18cb69889a02d4f0a06a2e5718899c1dc3b051c2cfa29653e782f87fefa478e6465bf5ff27f8b6abdb500077aac97100bd955ec535a587d66f23354be51cd8170289344bac9451f74e8aee3639f7c09981f4885e018912324d7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "456844a34ae1074246f8f71eeef2010ec8733265bed7c1cc60043d770edfa320cbd4284a94be2574337e16d27f125074ebd7e99031f7abb4547b9540a7b0b5148ef501b550dd929f3dfe39ac65519f563e9254424aaafa05b1d37c16c771882e9e25d4906ac58603da749adf686932cd73d81e2658134fe69294c7a521d257eaf2110c667fc9d6f09b52d24b93910e532184eeb96eae9d9c9750ac3c39e79367431ac1af7011172d0a8be46a31010219a0310a733068c589bfc4748f3626aa4ff8d355cc893d05111c287c9992e95ad47481a6c42d6eca" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c5c4b9900b9727bdc24baa544cad5faf8340be6b3759361f53889f71f5f4b224aa0090d875a00ea7116772117dbefc3a81c6950ca7ceeae71e4ba975c50d61fec82e6d9448d3a0dfd10bb087bdf0673e3e19fa2aaa7e97eebf71f11b86034fcf5a61240c71444ac3da15ef09b27b3523d37d309e8722380f835c1aee4a767bb027ec0674040853e5b53d6a31657f51acff6d2487860becd5ce695696cfe5937f4a0217b69e01cc6facc24dfe5f5230b8692a0b718e3b3c789d682db36101795a9a5f8bbb838c3679be72f7941a1db180135347d0a884ab7c" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1781df2fedd2c39137854737d054cd3ed16b0ade411e41d97888ac900fdb46d9ae26b3d2dd07e118fd57eabd0dfd03a55793c76420666444865371adffc9b2f35068a0d70f9cfda1ac27ccb4beff4ffa5b8bb8bddac843386675c38a181fd0d935d6d51b25d78e7ff4ecef27a9853c0f0d2879c395ed1c4883987d123890d04f851c3e042e1164c68c0d503de16816f4b0e554236e5f4c339ea11d01ce652f6208f78f457a2417a97c0a6a240f443262def4b6763abf53e597bf1a28f907dc7cbdc751a234ea7d75710ad5ab0c37e8e9805102a375abd44011" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8963552ad1e729ead07750df599d734157aaa4bcdcac17e8eb19b4f99cdb162686ff433137aa4e8a0cc8df0053999196262115aec326cf37567d9ba4760e0ad21d5763977f1ab9b35c0fc667890fa87fc946ceb776a811b5adc69446bfb8f5d9908029dc5aa38db816e4a4e8f98e5a48cf0a01627031c5bd1ced8bc1940dcafe4ae2f1199b186468eafc07e96a89d95dc18ef0fed3eda5b58ce58f221a47ba5311313cc680367eeb058fafc7bcadce5f520b6371489d9e529278ae6ee2650a85aed82896879038bbd9aa8d685fc9528943ccf2235cdf69a86464" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "23ceae3008085134433f5de4b47bafe0f443d443491e6cd47b216dd2dcc3da65239515a6e6b9beb9a939ae9f1f1f5e11f88326475e0962f319d9bf75ddfb4a46e7cc3f799d7547f3c0b2e089018b75787b82ea1a7295e7411f4852f94c94170e98bb0647923b8eb7d184038e56560da46085540cbfef82b6b577c445d038f6c93fbfdfc96ab3a0191d20a57b8610efb4cc45cd95198198e6f80ac46b0601511885f650eb00992605be903bcb46cd53c360c6f86e476c4c9ca4ad052eb572bbf26eb81dd9c73bcbec137aea6ee27aa97dadf7bef733fa1555019dab" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c0fd31e82c996d7edef095cccfcf669accb85a483ea9c59f368cc980f73da7202a95c5156c34192ae4ebf773c1a683c079b17ac9d08b4265b4054fcddaf6666ca50f38f1a2ef2497459a68c06837363a526e850ecfbd223f55dba67db017eadb7a9139abb5bf3854834478b838aafa16c5ee90ea52fb2f7b8db2bcefb85b06fc455c2b6c27d0af9a49dbf2f313bf2599370637393e7972b31d8bf6759f3e6115c618e672831f84d76ba1879c754144e1df4d56b1e264b1797dcb8ab165040c8d20b931071081d7f74fbff590bdc8e888e71acc6a720270da8db7c821" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "936fdab91fba396e4a8754a97a04ba333daadc29885c9d0c8fea3387165278f4974e468fea57f2bfd8428c4d0f010833283db73735d39de0c0cb5898d0c06c0ecd05f61098935cb6130a8da60d1a6c2ecfe420f972263fff5a631b09e81c837183c5528bb1c740b36fc39cb082f3383c2b4afb25d04ad1d1f4af63dcf26a0bf5a647cd2e35a51cc119c4dc5031f5715b3bfa1f2b92de06bdac0d670fdd30980f32c51f3936b51e5db6b95a8d36279da5faa4c4e454f2b7e54e9f488071011c7f6f9b63da260a2e46d796d36c9a9dcae88085806a10a77bbb670d475778" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a55fe162b287bd6eebd6cf7e7aeea8672322d924ae42c7404ff89aedb98943f3755d2889bca488cc7000e6e9b8e7a0ef289273cd29c44cc600e330d1775e3cb767f12150e1615dca8c3f67466463a3ca993a1b788cf67a7a35b95dfff954206eb5ea1e1bf7fb06482a551625b5c9fd9a86e8414c8cf79d3a14104a153cbe04aac5172aa4c4a89349f5856c4262dd1d7317a7544c9afbbed449e7dcc2b58d9df6c9c9ed3883e42e80f5c2433550f30e73c7bce0fccdd880adc19282a392dae26a0108e7faf168cfc15937aeb046d60712603286b8ddfb27916b79242d56f1" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2bd6976592408cdbc4e41dcd3ecfbb786775ddedef914d9058e6753f839fdfe15b17d549dbc084aa6cdf3befa0158aa84c5d58c5876144fd7e6c41ab7d42419d0dd353732e0e6d3fafc4f5626c07433390a4fd467197e85b5de7e2cf1c26cc575356adedcc0740008523b503df12ff571387726c5ccb280376d19cbacb1d7ce7aab8b13292c6a8b8881e949cbf6d4610d16ebba1d46cdb8d0459596e0aa683d0307bd926e14de19b9bfeaefa29d91b82248604673a455520cbb64eef3f38cfad8e126a3b1cfa1aaba53a784c8ae0c50279c0ecdab54095d36f67ace9b8ebbb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "71913ae2b1c8729ed6da003c24a1d4f96e28d7faf55ca14ee0b2865282b9b61103ce6ee0b00b00aacf2081adedea5616f9dfd22c6d6d4f5907bcc02eb33edf92de0bd479794f51246d9b612b4543f6ff633c4fc83bfa6144c9d26721cdc690a3d5a8db54d8bc7873bfd32924eeb502810732b5ac2f1852bb021c401d26c39aa3b7eb09083093a9e89bf889b53383b5af61110aca1b9fdf38908c7d5a184fc5f46b3423a66a2749feb8de2c541c563987278dbd0513d99b732411012b5b75e385510de5f6839c3797dc094c9501d5f0504b06b43efb6e746f2129ca189c1da424" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "9d048a83294de08d3063d2ee4b4f3106641d9b340a3785c076233686dd3382d9064a349c9eaa78028d35652078b583e3f708e036eb2ced3f7f0e936c0fd98f5d0f8aa91b8d9badef298bd0c06843831279e7c0c67ca7e572f552cfdd984c12e924c08c13aeec6f7e13d161785546ebfd794b5d6a92a4744e52c4cab1d0df93b9468be6e264e8cfcc488f9c3c1817cbe501f4b9cc5999483b7433aea777226b25273a6ef2331b5f3b6db8091591e8e276015da3ef78bb2ee0526ffe23def2d8d193cbe594e8ced1f3d216fcedae2a1eb288da82e34cf98aebc28def658ee0849ae7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3251c96cbf82ee2e5264528c0b6cdfc23d20e1eb2d6441b5d62f0fd24c692a0d45a8bc8aac32884b7141ac0f4f113ec9fc7f6b4db3d696374177f9a42d602ca471275b928f639105a55b846da9ac7274cc37de8c38541f6895f94d72a81e117844b46601c201f7189b935a96e42505f2098ac985d92dfe86349a706ef6325b3c2e4060ced3c453e68ed09e043bcc75846b80118dc53530248da250fb57922d0afa53a7b2c89161aa4fa372a46b2a8e1307741cecedf585d2f998a9d496763800b6965c38a5d8aa566c709f13699c8185ab4fd8fdc8b824f4dd6d1c255b4788f50574" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2de31dbc8a012254586f3229d3524fc529554e98850d30acdfc11406bba6a142029126ac165ee90b2de7509fc3571a8ee12e16b05054eb8baea879d135b39627f0d8331be3e66bc720c2096ce74e437daebf3bc53d8f2ccc228c3256d3edb6e9ae7c354a0c9350e6d663a9a30630bf9da3d96b96608a2a171ae28105714058b6c4b38a36c56561c4612c32aad25c65b7fb6faa4e4ecd44ebf9b2fad42ff9a807cda2581614fd30d41a7436069399b8d4f062a37a5bd4066a93d541fa5797a7d3e7dc9c4c40f0bbf5256f71613240f9ef128b3423eacaf428ada06b6a531f835281e4f3" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "07dadee629a08223dcd7ec441287b4c5e26347451d9c003e3a8496b4ea313b51126283a6720d7851e24423d9c9c818b4601247178f38a61f45fd4c8596d79529d416834226666a2c8552bbc901cc5cc3406a18fc88077fea52e1b620748553052ab7788c0d025b095b736fbe714cb3a968ec16b5917652eba2d7cf32ef3140d6c27b25d053e9786d24cd09a5306a0ef55e46201faa6196a91084267d7a7b5ca57c2efdeb2cb97d682d2a191b915553c8933f1d1b7faf0b4a1d83ef611f1e44438bc1c3d860fbfd12b5f26e5a6889a31ce26ae6a55c7a563b5816d113423ef3f25fa9befc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1d94166bb387526d519c4ce150221954da8930f66765fe6a5504e30a69962d595cfdd07a82c003843598864261f053bdb6f5086d516c261e089caa89990f0967605768ae9200bdfe4dcd7b77a93265cb33d9851a2a1036113c732bf3f37534530641300f0620de5c16101e16f4baf39d9fcbfcb01c52afce0992c329d8dbb438c314eee995c5020611d6f889e06b8a032785cba9a415580dbf752b5e510523c89f478cc6f047bd926f51e4a965c9749d1e76379c0e7e5b56803893bafaa4d2892b4c52f143b2fa777cd1035ea418684b8019df084f9a3f1f768753096621f342895c510d01" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "fc0073f199ed8a1d6edc8e7bdf182670003108d82b283aba82326e856f8de378987a03d0fe8d2041440fd29d51c63796aab44090d2b14ee00859b3a08cbe88f724badcd3c401226c5db8b307b8deea5be305412b080e9f99cf79d6d08d3646f347a7afebb62912e3e246e2e726f9aec5c101d916e47f984507b1d65d313697256c77da7eca3bc5811c87bee02a2826cefff0d92bae989609aaf95d70561b40d98474c37277c884aed887a1606d206b11e8a8a71d1f1d19319557b57351228ff0404be700a6cc56c0a30f3d4b7a0a046463fdaf19e7d5f59e155f378e35baa33db1e881f2207f" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f42a6a91278d6a076feba985b1cf4ce0af1fa9d6d039c136e8971e665ff088a10b6b9a379a6f5526fc5957773a0ccb8972a4a19be0745ac13937030a54b18dee4f4c5df47a58a33a7516b90e646e5da999166ab0e52f457f7c9b7e391836a687eaae37b377e59a4c995ab0c57162c307ab951a9ba6590f429cd27250e7010eb794ec1b1ec35f8aad189b2fd3e8aff24d93601d91a4884e6f84b02757ce7620a02901519fccfda52f68ad6df709d112a9c25d66bcbb9622806427ca8b8d346b6db05874bde800cde9cf17df4b05baab0f133febd1ebbb053b49c109a7f5b1f864a304d10288e2f0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "bbcefaf4a0739509f8a2f831c954071aac52e60cfa882a867b8b910dcf7edf92e1c0692bb027bc378c460a01cb6ecc8f2a012dd84ee5a678cd497b1457b6d393421fbee98ff544fc7eba24cbc3aae506254d9a2d74dde74437ce4c8a69010718506bf4c5943342a942e5e2d3406a3016280b6e37954c5d5e763346251afb0b746cad68cac757f9df765e092518729cfb9a5e76300c124e708ca33591a369767ffb63933cb72fba67beb2223d98984d0b75eb5d1a38615913747b520b3d613c715c0c77d2987bb88f3c419bcc5d38573cf4a8a4f550b2d876f05ca252d88c70a561d869a5018b32f7" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "dc2437010cb05d9cab2af5c275e1d2acd627ce19fb86355df91fb8d059e60d591663c8eb077d48388c9a321057a98136f49f0098348d9f29d808936f98bb1787c7ac75fb14f6076dfd2de5b59b1fa4848cabaa9a99a091dc24b561911c392ecdbe53f4adae82b852d830adea3a10490c908e337ce0a6d12354ce05a37ad3a06696b66820af8a1f67e6287533fd6f38a5f6ad1c6b078c08baf2c37d2683af01e6a5b33796c8ae48935a888f9bd265f4f11a4e27c433b8b1c9afd140bcd21a07e24378ad6badde8e47c57e3340f49e2406e8d49afadd65eaaa4c3d078c27d7e42118cb86cd248100a356" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "6c290db326dd3152e6fa9b9c0cd7d49e50a0221b96e32f5f34a8cb7d0c2edd3e937a7d025d6999b7b468add4d6894d8f7aceaabc18f4d9c171f1fe95ea1ae8570382a8450fbc595d95b1f51d24e1abc2970b0e1d20ca40aa21bdfb3656adf2f19882eda606f5ef1c03174e1d94c8d12f0fee8dce6852f42a364eeafa27a7971d4379405db8e46baac4d685b969238e5df06292a6c790bf1994a051b038e1d8db91e1bc4804f32443781c34a552ed2e8100cea374e77af56ba0e11c45990d3ba68df9087b1f4968cbcbb1c42f99b7267c76af926ff3134e093df28fab039cad420c6b70f2d9b5e678c155" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ac724a22ebabaedbbb052953e3c264a4b6440f313bad501cdc1484b64f33402a2230898776db5c818c28035ffae6ea24abd04b7159e42159833903a0c23a7c564f7645e49ddedb748fd9e51bd6cbf2eced98caaa35226970f003ce1fd260ac5795e096f1c04aebf8fd36e5e2adeea929b5e963a3cb71d6b55c85bb7d3a2b03a7e74b4416de8fa68950168d7c3ae8ed2e29bad1e8a182a7c5418e5d564373163778cd3c34e9d320eb1a60480a8f98b12e0026cbd7752e6079812e3767d9f55f3f10b8c214a6eceb2a58954091a06b33862af171a9b60bf2c6a44e8766e6c56e98092c56f2a8510f6d05c103" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "8c70114f7cffb375c2b9a06e27297a5c32418b2daf68af5bbedcc7106edbc070e764bf40c1f8eb15079e2ab77f898afff3490108ed9afb7ea9cb05df41d263be0e42d2321d3d2656622d7bd232bf68d37375fe7314b09cba66f19c8b59424198ee69e7a9f3de0ecce0685127807ce336fa479ccaf7aa1ebc4e406271ce6c4923ec36093516498cc227f9218869346c80ba5ae83e023aca0ae2bc86b5bf5d115a4616b6587cb869d92f8c780ab70d5766de07a204af5e1c8dbba622516d2e911b36c82e4687e4d258ea616c07f76ff0baa376c8d5975cffac0b25817f779ae3ce88b72eb47e378484ce999bf0" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0733d59f041036398233fd47a84b93f6778ae5259ef5d62aa3b9faedec34c7edb570c18b2a5d2c4c55cf656d98a1ae396d45a3b746b7ad6f07312c3d05d1a50ffa90bcdcdba105e25b7b0c52664223f8c2476925d46dc6ea2406ded7d0b0b292f6656cebcc7616cfa4b82aec68b35d1da67f6ed2bf0171849d6bb65128d8a140ea5cf97f1003f8d7093bee077be78def4f7bd2caccbf0644f26b26285225142c40038484c3bb9ba9597744f4389e76dca3eb695c33ccc621cab1fb603cb3535a0ad318d220385d5e94f8674f3d55e97e097f8d5c049e911946afbfce783819951d65d6bff4567dc951390d1aaa" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "398ddbba3dcb5642c102efa841c1fcdaf067062e7eef8e2ee0cd73d7f77e57372d6ee1a9b7b6f86ad12d575001ae71f593449cb5a476c6bfeddaa2af0f9239c1d7effdedf66ceaf413707b5ab9661a7cc0ef8cfe4d1651579c4f0f64e2d12a52653c54f2dd60864e769eab8a627c89c56ee93365d031f0d2523cb95664b1575d51b122f33c9e94de75432a690658c977b68aa5b721a393f9b9b3b612c10e920a7d510c6d8460b35f8614c42f5d2c241a01b28105aa7c1b521ac63ebbedafac6d5a38c898e8590f918a1927bc53aecc2b1c8b18d7df9107c6997d9b3fa4b0bdb1c603da619d9e75670b97a5b40f06" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "ef07bbc7c4150dd47f8c69a7989948fe831dc798b0424dcd6551bfa8e88216095a7e5d720909bf3d23526b9ba464b66ff6b63a7337c31451ab9a15f04ead809a62bb52206237de77597a730106d02d227dd6099ea9ee2a92cdc446ac3b9d024e32255adb3e9b56b561c431e0b5a721f0336f19568a5335d0ebc6c73ed8ff2c15e219477d9e4b67f2928e251f8a61a2848857e037d010806c718ab062967fd8e85f3722252957923f5f9005aae47b4b1b3fa464e3ba9df573a56055f17e903126fbbcb6cb96de92fe617c97f84ef3ba0d8f2651dc4aa80c157f372ae1bc02e5067ad076f3fe48bb72c0f3c99273f82b" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "c7076986d2333f3a6752adf11f1a9e5c6bc4755f341073cc86a9c7519c8db029d5ae833fdf3fee826ff4692c57880c5074620ea97c00f1dde1e8a0f18501627984ded4d1b5c4af35be5cc1bcc868060a49a968dc0547acde490b4c68d79924a93a986aa0ad060c7de706e8a99ce8f84a4f8707b52a8ee122b763ba580d6b1f35f6af25094c69f49247da96c836991851ad36f60bf577863d7471608a012afa7a56656abeee7cd9b4f1f4d9d13a8526c0f33cd251caf7486639e787250390e7e488e9ec311fc3d847a7266cc59bcc2bc34192554aa57cf25db10ce04bdabef3fde6db85f55195ecc2ff892b2e268ebea6" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "01789f40d42d8d3e4a416fd9ae7de78c3a30507809eda200e1afaaf8d7020cd1fad18eba62d821946f220506cf105ff0e2069a771a2c233714afa6b2f695497e4b95c9693dbb93ec4c9a14720676aa87ee31dd34e4e081756477032b4a57b328285f2cdec1b269754c474936927e93acc26012aff1bb36f30c2402aca0a9b9ce9568f5000e2c934263933b436c94f8d6589c89db7edabc5d03a8fe795fe50c5166beab64ed7c22662b984ae2c66dbe4c090b0df603b27c759278f8d66859afea3f6a8f02c2c2a2202b9fc29132256f164b5050a803b43688dc4c9ba86374a3522afba5d1a19bb3820b883aebc267627095" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "2c61944bd6a50da00ebb951d2b67d79fc6b6fb5aca83b1de3dbd7690ab756bb1e1a21051ccf1e24136ac8ccb42a2ee10be94d2cb9289d5f52b6f90e9d07a3478f36a1eb7d08c3dec52ca154fd1427ba92a4ecbe73a71bceafbd26e9a39d50821e2876d3a0c0e6e373b9795dbf72ea29cc439ff42706be798c90d4617b39c90ec84bf9fb699dc8a9a34e25d81759d6c57df45efb1d0d68aa51278564b99633ed5dc464bb7d53c5c21f798f33bcd868657ecfe75a1ed8149d394b398969ef624831b30f1458465bfd2fdf3f284f2ffc54bf2817b5fab2e02056e864f78bb6fd870c64f3609dab218f25da8060f756e45121e79" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "942fa0c68cc72f69518a3a7aac0cde45bab0e928b5cb2bd24d049fc313f74b6afa87c4e34150484f3b5200163f8a6472d04777928ecc49319539fc17d71a38090f55a74f757fe45781a3c09f08dcd3dd4c73c8533a5e00cf8a86ebe77fe45be2848574f7c5d25e9a0632a60d2dd41febdbf987d2a0487e4a4ce6ed5f49f2d741a88ecac232b1498253fa4ee8147bbd0f600abdf295e81f7570015aac5fe6ca7bb4a99bb3fc54287106d7fc1132a574af49db82a7b9a5f33e193cde527ca2176c52cdab672165e0fe5720f71ada57ee90060aa069ae2a0bfe67c1b71b17c601c3c2224bf9891bc11ba216e3ebcb51fd95b8d7cb" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "0d68cfe9c087ec116fe7572042385159cc705960f842aabad1ed1387ec1697f4413a23c6090041328fedd4b626c6eeaac5b5a71acc1fd1bb8fbd228857ac5bd045c364be7a5a26338ff04c99c4c473cf445a891db6422d1bdef4533442df171643fc36a092fabb464298e4194c9e2950884de13d113ee24160a416404c16ddc5d2476cb3fb80da543e6ed9105f6003977acb34e1fdd2cbdf7a00d5ff84350b74ac231418c0d88269d02d824802791ff42a51cc835deb9869a6023f867f82ef6dc0bfb03e6dfa835646bb18a4074773486e308aa39e532aaea4e6fb35dcada7e060f8282c371ed26d22302323d4fd142a85534671" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "45e24b167a0bbef1bd8f79dd047763d0754f36a7b623f298059d177e8ac994945c37d2c4af06f01318960301595941124592f2995af1459d854339998d3ae17534df2d9793d6e203857d02c98a0cd88991e641b3e640090ba303f87b907dca8ca462fac19ad079b2c82ea5b521ab891b10138b083b3d9fa214a8fe60d1cb3599c5d199c61a2cfb7ee2f39e5a5abad5ac4998b707545f73e92128d21803420526d2598a53bb314adf29a0ef56b94bd2221601eb53ecb8540e8fffd38fba7bd827ef255e4ef55491475c0f383a241f81c72af4e1dbf2a65cd4d18a497615aa0de2791a3511a7977a8d4d41492bfa4085f2fd4e8f751d" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "1c1bb695ae90e6e33fc1e8b2a62ab98bf835ac7193440f2351c8cdd830472b637d2fd9c9013cb83caef506abc1c4f7567706db6046b1d184579c7a9223ab1b35e32898c70a3c27628123ffcfa518612f080a2c4a9f8e0a927a47dc98307d2b48de9d5dddcb5c82f0b0e4e610d44f1baa9bbbf7f5a727134680bb7d1327b73b52d8e5e36dbb53971e99e699d79f75a3fc01316bd7012947d119d6aeb7f75b8fbf0479c03002148553fa0da450fd59d4f1bebc252caa11ed9bec5b6ef54279b5f8382b61cffc67ec03f4baa7ea476c31364b86aa8ccad9fd0818717f0ced2dd49477874b4341c602d7a1beab860eb476c7e3ce597e6926" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "7a3cd9bb2277e2c7f1134fe7233f0f7883c2db9fba80aa5742b03041de0fe589d9e5ea84470dabf41bb66816f3e33ebf19a0ca5aba1004cf971249b258ff26a98dbd0c37ec6cd574854109433357720040bafed4531e0079186b1e853e0ced35d08d27f6d732ed6e2c6651b51cc15c420a24f2dc36c16ef4b3896df1bb03b3963f9aaeb02a48eac5772abd5948c2fd0db2bb74e3351e5eabd681c4f413655bd94dec96b1544c1d5d2d1df4bdc26020d25fe81d5238de824687a5505e1fbe08d11b3924b3ccc070fd225bf01eb79e3d21f7b62a836cd3bcc11c931669c37613470e356143df87c48848a829f5e018973a5db88eb6c60203" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "3f158afd0733fcc5dfe1efc2dd4eada732f942af734ee664955bb1ba613eafd0f349e7554a14d68200c62d8f2dca2ec8b81c8350735eaf437041f78b452598825b6899560963ade66a0fc74ad01f8343d1d19c7bb327a8dc14ffdb1c42fa72b2970d9155e2da6a2e6419d4117842d826ff38ffab9617307a0283d3ea28c8104ad9a6e087bb750ed1d10fd8f7100b1663682e979d80e43968c33d9eff66f4d1344e583ee521e78d0a2193c0577516b978339c143bfc689bc744bbc4a9163063de82c9706384b6b385e54666c86b34f23c1e25be293af06092ca31d857e11e5b2caf0d19dd3afbe85380878eda76d718b4bb869c67e044e242" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "a177af4387b9bfa3d59e97ee7b0ff5f4ae4a326fd9204c8d28831a67fcc385ee6c4828247b16d11aea9bb8cd9e6c4d2876c6b2fa6d5041ad39e1b04039071e29c4d86417e7eac4fc7d3823958a021823e2c880a757dfbcd0c8196371db5bbfac15e4d1a0596508b6d26f8c4a664924c95082d173f817995b44c4285d625d9b2f56c86632fe1295c5a8a7a3760028072bcb07bc245a705e7174d06b9d5c0c8ca495b9ac218f1921fa63f2db3fd148f07545366d008fb5aead7497d902b91fbaa39669929d4ae9d07df8557f1f0aed7b51252f10c6606e5ff3ede1327530ca356b4896ecf14bf7322d77fddfbe28d52f6de7f66eeb81704c87e2" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "01a15b9018e35cc342c926b01d03ad9db4993a6bf92e0555969fee90033f28f3ec234c1268b11b040dfa0770d4ceb39edfeb8ee6a589f4eebcc08d2d1b0a1a52953aa26eb44fdf4a2743c3dacb212a0c0f325572f645f53027b6f3c0c55abaeb1b0918c89bedcb5028f094d743ea354f8ff553c45f111a8fd5a14a4e5c835164747d302472e19a67da04b4c8e39756a9d248ce14d1ed43de75aca86850f2455eccd4639b2af035bb3f504cc9065d091c1c47e036083cb3fc50bf39292b11737c7ce0b49673ba93981de304dc65a671775b6ff927e3ff93850b214fffb5792105a4bdc81354d5b09e84afbdd1792b8fb4e9d0ae3dad2492b03282" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "24f07ae31279ceed18ec6d35990f21200934ad6b132c6c62e82fe92a40a0e60a5bed10720eff5a1f728971888682772b2d9060d4fee88f37d0824e7384dddcc549475f0e1a44eda4804778b62febe46e04657a20577ee70acb3425e334881eebd8ddf714ae8c527ea747e3367de384e595a43b299b6bb3f6b0a4716cf90038e0f75a47d5057d7fcc3c8a8f9224992c67f8ae0d3251ea09a24aed9ce57ab637f6b3cbb7083df62b6287f64d0877984c4249d113bdb2b07865082aa24cd7ec07061b17de320f51f29f25b82d7073d369cf2dbf96310c0c311997911b2cc02f606f9cd99663c57e78499192a2a78f9c9fa67013e0f9817287faa69b22" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "4aeb32bf9d050f10bea18d9f71b4afea7bd08550e574e7d50df234c7413668b297b6721d7a0f0bdcdcceb2f55adddea28cd59bd44be0c5ec067039e428706caae11f565d961ad6e7f4c51b0aed6d05cc5b8d826c4b9c39daefb6c7da46dce619a359dc9ce215a215218fa8d54ee0b4f301b6c201c7c2c5f7cb1c6e0cb76ba6c6e8f63ef7a5213d550b0d0857fa0ff9e3e38e497161617413ac066e2fa539520233193a5cb7baa0c2cb20b45e56bfed2c40a9544d1f230dd0cd6d4976e7cf51da8a13200c3957c0154c8237b2931ce19b824963ac576ea49b548cc6aa85c47796b470fb2c6308d88f390bb13607e294c84a838b2713b14ca6a5e8bcee" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "77e607478be5502432230c913d9ec82f967d87c0ee169a74076f989648853eca693277287f8a5b306bc94dfdbf64ca5cb5dfc0bc498589d51a691b8d57d4b0a9ee247d038fe1b5571183be3e75c37045bf1235863ff1b84b208c10e7f1a5ba54ff36af5b2870129867164d013e0a6d2cc067a3509bba2f46390302c80b651cf590ef69aad8effd94cab28a9b44be6a38b58cfc47c9c725d6fa467894163383b6873d10d263b1cbbad932ded59ab503920267ac026726f794a335a88f6ef564f8968c6fa6f5d3ea161eb6062ca349b9a0e4038273399cfa297a6b07ceda1ebaa99c9de2d935ee230a08c5a488ad46f3393243371d40916b8063cac9da63" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "50957c407519951bd32e45d21129d6b83436e520b0801ec8292d79a828106a41583a0d607f853dc4410e0a1427f7e873455a75df065cfc6eef970f7e49d123b346976460aadd91cf513c140c356442a84656904a8b1d708dc6089db371c36f4fe059c62302eaab3c06c0cb3b429961f899dcf99798464b8571a440cac7a52b495f32417af6bc8f58adc63647531f804b4e96273b29b42434c1236bde80ba3744fef7b1d11c2f9db332b35bc25123338ac9a0796aac213c9709b3c514ea7ecd80e22d3d8a74f28c8194418a6e1ff30714d0f5a61c068b73b2ba6cad14e05569b4a5a100da3f91429d6e3ffee10ceea057845ec6fc47a6c5125b22e598b2dc" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "f2273ec31e03cf42d9ca953f8b87e78c291cb538098e0f2436194b308ce30583f553fccb21ae6c2d58f3a5a2ca6037c1b8b7afb291009e4310a0c518e75314c5bb1e813bf521f56d0a4891d0772ad84f09a00634815029a3f9ad4e41eafb4a745e409ef3d4f0b1cf6232b70a5ce262b9432f096e834201a0992db5d09ffa5cbc5471460519a4bc7cdc33ae6dfe6ffc1e80ea5d29813136406499c3514186ced71854a340701519ef33b6c82ca67049ab58578ff49c4c4fbf7d97bfec2ecd8fbefec1b6d6467503fea9d26e134e8c35739a422647aaf4db29c9a32e3df36e5845791fdd75a70903e0ce808313a3327431b7772567f779bbaee2e134c109a387" +}, +{ + "hash": "blake2xs", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", + "out": "5784e614d538f7f26c803191deb464a884817002988c36448dcbecfad1997fe51ab0b3853c51ed49ce9f4e477522fb3f32cc50515b753c18fb89a8d965afcf1ed5e099b22c4225732baeb986f5c5bc88e4582d27915e2a19126d3d4555fab4f6516a6a156dbfeed9e982fc589e33ce2b9e1ba2b416e11852ddeab93025974267ac82c84f071c3d07f215f47e3565fd1d962c76e0d635892ea71488273765887d31f250a26c4ddc377ed89b17326e259f6cc1de0e63158e83aebb7f5a7c08c63c767876c8203639958a407acca096d1f606c04b4f4b3fd771781a5901b1c3cee7c04c3b6870226eee309b74f51edbf70a3817cc8da87875301e04d0416a65dc5d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b5aa" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bc38f1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "57624fb2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ea9d54f5f2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2bcb84c09d35" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2df3b0c53f2967" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "26de76fed412b6f1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b91f740750ffdb2aa9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e161ee158218cfd98f91" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6bdaf88b0922b637274001" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "eff9f92cbd769c81a64c20f2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "313f0d863f80e115d342afc286" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9ac7c942487e8f48b1bec271562d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "221d56ed5ac8b0936111c773f9a744" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d0a446adfd1fe0cc61e42e70772584c2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a7248218b83af8ca2728d9aca773438100" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7ada5a3cd09be192f152e36eb77a49228bd5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8969cf3e34b108498786f3c9807a54da29c5df" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d6981306dc3865bebe4ee085ae81a11d43601bba" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e1f7cd444fc960831929a1ba4c81316537e315dab1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dd675ed39403b1500a2a619889c2d9d91791fe15d177" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d503e3a0261176767e318f079e9c4941cee791d3db3e03" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4bcb663054528ad4cc568d12ee1ac0e33790e0635189e53e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ee8ad528ce57395cfc101654a2e205deb62429640755a6067c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8435fb101e96b9dbca75a444212a99211ccb35173e9f1c2b01c9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bb849abcb58a9e8a3a2becdf0550774cff0093d5ee5dab5e9db38a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0a74d45327c814c45abc41713680021f487be9a133455a7550fad2e2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f662e426340a253766ad9a1a13b7f60db4bdf953a04456789b5a261543" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1a03271192bdc3981f166cb43945d4d78878cd2a2ab620f56337f4cf1206" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e8cdc5a0f15392219c8ad35abf0c1a976fb430debe801887ac8000a7968fd5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b5d259e2e3a86c77cbf6d53f9dc78daddc2afd84dbb4ba7e9891227fec079d5a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d3818948294fdecac8411f860f7cad50469df5d1485524e059d4dd8cfb69c32bbd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8e3ee191e4d30346f19ab6904b6e810d416a87a1da3c7f78445db72fe49f615705a6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c2622f680f4350aadb5dc35300e08197b1e968a1df8b3091cadc3abfe261a269605319" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7030a487b0c270d224a0f2eba284b876ac44576a119546af47627417ddce0f4650bb8b56" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1c09ce4bedf8ee67d19430f8a4708d73f0be22e19c55fd397471e7705ff9958603911f6a38" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "84f7f7502bd140a07b57e0f69863874a635403c111836b3fdfd27a030582e6d8e46162b62cf7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "63971b351ba119eff6342fdfda6bd558edada5c56e65ec0648ba3455fca1a3d51b603c028ead8f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "64e5a1f06e4d5cb5859ff01f3af1dcecdb89729d97aad3d4c8cd96eed4bd10487f918ea0ec6c96c0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d3cbcee509e8efa84f4c54f6eb097f17ba98c23024097f8ae5498d364d45afecb6ec1654e2e3c073c1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c35631a7735d09551b02c64eb3edfcfdd515c12646bb51695ac51681b33841197e92f6c3a0a2691cfbd9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4835394320ff955c272fce2a6eefc8279aaf63492610912ccb525a9f3c78870397c6dd35119900e88385d8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "66c4227b1a29889d5cc7e2025fa4649c365e56d153eb4c4e1790b3f0a26a3553c51f198b04851401af1c0acb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a1550d81d0e465b8e1bd228e0d3b71c29a23f8cf58d9c43361ecac7eff8698cd68bca923c25d08be3c92bb9926" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3ba25c21d16bb7c93ce16fc914b1bdb5b7ec249ba7dda6be1533c76e8dc20b704913cbe53201086b0e14e5901042" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0c4c0363a32aa180de2d3aebad786dfa1612141ae77f2eefedda3fc6366f34ef8d64e496a30e972ead3760f13553f5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "60fea990c5efb33b64005694d1ec92c90ea86f434ffc603cc26393a6bcdaaf99c8993f6f2fc5a3080a5cca5532697a08" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "67c9623f20ada31853c15e3d973b8a9c69643c3e328908bd138fa7d74789b4e5408da66ca04f0a286cda823c738958665c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dcda6413fdbd760d59bcdf5d28000c099818c9237511acdc6e0ad40819d47c40f0f883bb0b98d3caefb7fbd281db805d3aa8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "120c123171c486c9a11af8d7a1aeef60f78d071c8edb55fd97959261e4c708ac06eacee87e657b84a5072a7989b101c98b0415" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "434cb92246e474ce066de67de1fce06ab17416438598d3cff730faf1deb4574812e877f6a3f2dbc30a3e48a2cf4e441da32c4ee9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dd4cde9f87ecd959a41c6454869e55342ce0e5d2ff306b3d4dd2263365e192ee6781fe463175280d4682b397b8d6020699ed3a9611" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "df8471721ee7aae06d5aab20ac9ab5624797cd0311ee38116eec76748a42aa5ad23d1e3dcadbfba6c296aceaa05512cf1f2a2b415c14" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d226e59df92c995bd5fac8b9cdbd4bce4e11d6b2a2cc382b253a5188e7f4164063d1daff2254b4cfc7ecca462b7c1e11080c1ae51dd908" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0316b9cf375915d70a2c0a0f6560a609b3fd43bc8b26b8489caaece3c8cab25beecc3bb86d3860d6f2ca9297625fa2f2d5fcca5f6f0a32f6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "828bdf033346520f262ac1383a5e7091640fb9df39c51f82de52bc61b7284f4d7cfb1e90fa19d0ffe3f38dfd60fd05136d66c190cc47639634" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9388577eb0bacab40bfc38e2333f82fe72b575392db914da2706bf2a30787d638b6b31343e8245e4dbb2c962cf3f940d8ed0945d2db04b902b0c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5a79d4de91c298c87bfba338f3f85efe00275f6e5463419af83c34129586f30a3d36f57bdf68c9b5e16373c9f9921866c302bc75722c314fc57cf4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "73068c5b623b14802a9eb899f6285ebb7e601c4d916b0255762b7cccc2161417695818a605fed681fd4016e4cb1ad3a42cd88fe1a3f73367ae0aaff6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "668d87bfd70619d877ee8d8f86b5d5ecc4df2aacbad00f2dcf7c80741be0b890bf404bf62c1b4c8d1b0201ffb92d85fdc45149fa58f557a9c6a0190e7d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cbaab54fe4bfd9ed5d9b7fc97d8a4105af147e13f009514ddb083402ee941ecc7dc3c286308d9555bee67cd73505142758db79fd819ed399e490b801623c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d9942e996573688a348aa0fd1a2951b11d7732103acc23f31f27b222d5103879b9d3837f2571a7aebffd170ad03cfd89281f48fa70edb7c9f4103b5b8bb791" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "571be91037c15145e2ab4894a7bb8d8a3cab75e6e64ef296e760c15cf8f3f3acfa5c894ee56cb6ac2db9b32c39a1cc39f96c50dd333f1059230482f3ed2d9246" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c6f0b1b66f22726cef3e4fca2325d2bb4e922b39f9df5ef548d321419c07391fc311904407f98db7d7462db1e8576138baeac2a76400b2a2f72b4497c19e239430" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "43cb5507bcb6d7162f7b1d6b81a958b1e21ed2db9ae907a663819ae0d613ebb43c4b39359ff859ce90a9f65c369c6d30b83aa56b0107a5193a6fadced2d6c0ec5be9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d412ca3d1b8fa9adcda589c5c422c295c3fe953ffd896e7a98f9262689bd10670047d9224b685c449b6daa5ff5d660c3ecbe5b3865652932d35cf15176de70e4356ed9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "54955d39b0806ec95897e117064c4b173f20fb248596ac8b00ce57de2d88c01a12f42d3a6f0de1d1af8c41c0b2f8dcd613532314f773bb3ad0f470500466f0d8ae599164" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "713b87f7f4f2edb42d279e9ca3bef61e8ceaad72e6ea90cfcae4f9638798e00e8d4b464bf49ff26231dfca5a4dc8b3d47afb36708f494ea2c20cb9bd3d344901a42a95ff82" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c9421a7a80df6882010c6c4aff7ddf920924fc77246d1870da90f183c14dc3264faeace4c76426020d8383efaca2abfbb0957f1cc8249a212699019d36afae811253e8bb3b26" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2f28d45cdb35951f9e043335c0df22d53e238a7b2df3bfd74d5656bb7e65f24d12c35fe0254669622edb9f76fe2672a7978dff201aecfd2605b2b326a73a43fd470dff9d8d98bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "93694e4b1a7b15ac94963b9111f86a29266f4beabf1fce740ee44fd264ff44eadd8d0df5aafba8b8b65f48513a5920bcccd2e4d9c3a90b71fe51e11e2857df2e0379debecb4ade7f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "48887c63b6a5b7351632689a03b53cfba034c653cb65ba6756e0f816eb630663b263ea897025b65703cac600e1a450d71c945f7063d1606f0950da744f47ce0021d7a180e943ee9aef" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "44c7a8ed8751f54d0e5428d1ae063f1ec081d93acca64542d28d8c11aa0011caec398a2897b3c3a15ed382610b23620e833ab295d9a0eb61afd2948b4093d9e5df08d01d03dd6834742b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d625de2d8ee2ad2ef5a207af5092eb7965c4df09ac6b55ebe2bdaae799162a32e576925129f32f02c00e42bb2ce5afd73e0c64b9fa8298fe1495f0c8f201ad5c6780b83d58787cb2b4d8f2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "36370178c82981799e8622265c63ecf2329875efec250e995a8de5064aa5f1dd80d2854adb1d806f6bf2360c567c34e802d58fdd0ea15008b20492e09a6e11ff340de57dd8b03aa319d61c41" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "554918ff5b98e3df9c43ab9559a75e8eeb8f2bcd5c4bc87b8a9c2329df8fc35c241bbf9ad354fba00c318a2057e9eea6184260fb11072f57c6a587add3043c9f2bbc162abc6e50d06c7c673c9f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "72715c4ad8a633712074b9f133fea34cad5f7c44aa12ae7f1027b03500a9a132a7ecc477c0d18cf4a1a794e064eeca6743534ce07dba5ca211251c903a6d2729d02728161fb8812ff511e7e49c16" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "98a842b0fbce066ec6778cc378ca4b90c69ef7570247cf789dd5c9a502f5f7dcb3ab02c32f06375c2e153237babe51d0cf3fee0cd75bf1e34095a98ba712a2e11c1017500abc9238dc1494c527c4d5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2e548c4d06fe63198b95a9629e5c68372f8c51b0f2689a2a0b7994a204dee4a5669525786c5709e68ff35faa3d29be6f8902ff1bd742c4f1534fe3d6b5cf0b4f6f1c0f9415bd9801ca0c33c8e11940d2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9ea0b2e651b1d1755a7f67e78d2333b658bd4dd49157795657a7ad8bbce158dc0d4a002e5e737f52ab1e55abd0cfadac928a977949b264946af48045920b46da19f63649dc116217f6ac67355edb94c46f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "740fe0d1f4db6f6337d300089af7a166ce44da3c6e71e80ad6e92d604f80ac067eb077f2ac2ad76bc0604a8089ddbd22ed3373438e5ee0f25dc34ed466ff4b420d77db7e1e9d88a4ac919fc421116b62e673" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c435ab1e8d4697596abec90384c47634689ec73e87fb2d360f30bc5b4b47268bf3a1f31b271b800132f8a45dc85f82ee7620d50db5bdd400d36a36e1c87cb2f637c30afbd07ae34417e77ef2dd24e017deb7b9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7f32551c0b81ba6233553c8ce988da296fa2e345262950188cf6372aca5bcb8cedbbec424978310adddec426551681f93a9b4cf6e15a06ac70650dd211386498d45dbd6b70d66b843f73f07fdec611bbc5ee0440" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d8e9839dd767f514a33125051022d7e50c05d6521d852fbaa635fed502e59554bc9b8a1a31753f4fe90d2f270b27e73d65edcdecc18055d53fe1859744ca3d5f39bfa6b23a4cbdb9c326d7b3be831ebf7c0abbe676" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a1d587c939232585840b8f9ff27503efcbc1f59bca47f2dbae3fcf8ce26743debf6d67936f3d45bf2cf7474eb8f69b0765f362867be29a7ccfe41710e2c3c9fb5ab8a0a860612461e7f4b52ef28c73a087ef0852116e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "63dad275e477674191cf03436e979fbf16b1220e81ea8965fe53828e46f06a1dbd1a6bb03cabfbca70261f63d5cf491e54e31c024e87394a3cbaa9ea1cab3a2f3a6f5a015888c01150286460dabadc8d0af900bced9a64" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bbe011c112d53f842c0cffe98d96855b8d775c8c1572d29ffcf3feb0bae18de317e1db03f847fcba90ed941095ce0b2b96c8b1c7d9dc2afda7f08d16ca6c0f32d3a5cafca2fac92487c5a177af200c9adc866112629beb26" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ddafad4d5b5fcbc07f2222f9765f750f7a526e5894a165bbc9ddd6de71e23775246601393f488b61ca9f26aba2d3847de759f4082999e472e40c829e6923282b4f6c1d3702071457c7fb2dbd0db54c5c6072159d1fdcdf90b0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "275cd52846616d516fe77a6c7a4069ce46f120b66fe8043be79dd70906abb006ce5ced75dee096277b8c26899323cb8567a8c389578fa0ddb0b0988ded7d96ca69d8b78abd52663fd20e66a0ef4660e1f38460db06304479e421" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "39e75539fdefb2bd552b0009e7b2fa583afc8a2b011b505de62aba44c545e13b86590c731fc2fd848a219a510c3f1184ba0149283668ba93dd5a056cf5b752200659991351a7db19f04fcc7f96b3d25de5b4a726c7dad1b7ec7768" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cdb61379ab20f7975a61b52dfc3f218d5f803f08e8286881aecc94b92f46923973f227b7a1637c1269cc87b9634bce578858f4e9b04fa60ee0516899d71573c8e7560886dfea6d08b744010c0a9c236f3caabf523cf3a3d7a075e23b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a1b3588cc3742b70cf826f7af7c45ed5b4cba2559541e34cdd3562a216afdaa2a4e39436183ece09c222bc77ed5cf7b806b7f67c703f5c273a7d5879a630029224140f9b33bf2f4243372e8f781851f7db7d3dd8c795d161605257aaf4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3443227e56b16df3f7e15deeb5c8c0713300348703503a82474f964612ae13a047925c3f5b6b364af3f5f89f3b8fbfd1814a42856ed777b90e702256d241938a60b16d00a65143762ca29f577405301979aef51ac5c666247dc2f932ffe0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e0cde88552c1f5e0f9d3e7a97ccb49996aedc8d38093edd3930094002306f729b8f55d1fdd54db364173ce2abfdb65a35e698f78ffa02686119217597b26216af81ce7c7701e9ecc74dda65feba3d63e3e7dfc1f0a2c7ca13c552fe16c2830" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "610a5ed42281e3b93a210848ebb8203b8eacafc2a19a502d8baaa2e604a573bac3acd16f265ea4befde07c5de8c0c5cd019877d90de6c3e93df1afb6930ae311bd52b7c6e7c677aac72df9edd2657264d145755dc936193e1ecc44edb1246dfe" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "99f96987a955b931534b13d38fb49f383078112195ac492fd6cc44a6efb2e161ab87caa50a594fc7f86328f374d4b21c7802a84f99fa498c22d62c461c2945347e6abf1749afe2e22c0aae2f053b6a6bc7854f56503f3ea6d70193287bf9b82f23" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3ddc943c2a5e5d0786d8671083dd8893906b02a610db62bfe64c7e6ab086646474483193062f08f903866d6050b50ef55213e3935aaeccbc385f90ebd040f7e7efca8be101824770d1e5e7ef92fd65d148e63fa627469c3f2b5fd5e5e4476159665c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3df18ae1f63e037219787a95ad960e967671a8389c1ef07c17be3632d5bfb30ddd86ccd7b53f191baa81dba189665407df6d3b1931c7a94c2ad62bb6ed9b7da1dc9b2a5b98cc069abb2c7e58648ed4436d359eb60fe5425c16103d20c793ca66bf847d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "726ead16f67729ba596654a551eb126e99457962286fc54bb6baf50d93c283409694db0142264b697e6d9be81bd7f63e4965c784ef0af12529294ef7795e9d64c371b15c1a5701c48dae9e2a3d908602c4a82bbeddb9a20eca30b591140f76fbc11a3df2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bb100a9b0c720ffb4e57422af4017c7eee0396f9c1b1174e0248298d521ad171ffac53c622b68f45c9482b3e520170f44b9ac4855f25874674afec56ba9f608c6c7a6e8bc9b77dc7f5f48a148052e649ff31004a47dc1b3f15bc668b060862684bae6cc402" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cde6c07be9135468c33b09e648fa0551578d8b7317fffa60add7e430838633f0fc1efe2783468c96c74e2208ac947d726b139b5f5b682bf615910ea9a911195f71ed8ed899f7b8ed126d6452cbcdbf6aee558662de0f689d766e69ab2244f5ca70e6bbe9cc4d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "591fbc984e4b79a372b2dc951afbc269dc51afcca0f131840335fd93275b40b32be13db09b36a8bbbe7644470093210e04ed4832e6aea478fb5028320ca8ef513f27d0b3d1c018fd7d2fe1bb1b8da6fab196dbebc33043b13469a114153267a3d4668d062d109f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b14803314977b0e29e3ac469b17206b527b6e95e3a47f537bd7e5e18ce69e0e783737f8b1d993c48b0dc2078b0bacf2f752ade8a0a709f8b27bb5efac90177d6bad0d946223992cab2bedd83f8e874f13839578bfbb1e283423616b9cc9c5a7793ae921664338d4e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5b3f9b47a210b68bb40b96396fdfdc4b130cf0c4f7708277a6bce760837dd8508f4e321e09cd36cde6fb6125ede04599064fd9a7675c0508b240b8352e71168668681eb6a0aac08dd9145439ae2ceb9c7b0e575230c51e1f89a08fdd4590c3c1bc2c397b64d098302c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dd31b6a184c00932da12262e6030c8045d45433e15b975eaad70144143c8b9ede3c71f4bc0324c04617ffd377362caed64ee57e40cbd952b559b54b59fc86832b687d08931403f854f26297251e606c75f41717228a3a6eff683fad7528f252960a286e15edac01a5a59" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "872cba270f1ac791d7444b1222ba36706735ee0a2794cbb33eb0e7f1e091f06124f61c1a1332e78f71290c8e9bd3f8f7b73d7619958a2d9a8ec9e7345e43c2b49868264ce15785577f4b7542b4dacbea045850d38c006e40f61a710b660ffb1be2a9697d0c50802c19fe2f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "190acd9ec74d1e20da6d30b7c8ba4a8477d87cc700569017e74dbd1fde1e66fb746d43cd115e7d4e4e960cf23a762325c2fe0a36fe5f9b1f5b3d100cd0427c9747b4ed2fb8e4c1f8e86da805884c55333f5d8b29db7317699919f927b235aed26014b4bb0ccf02b6b3ee4ea6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d7b9dc5c89dc7a2f6caa59d66faf48c7d3cd85b40241ed5f839f7693a637e2f995300cdbb942dda736929ec84cbb4113a982666b9f49f7758b1dd8cfe1edf2049f8f822afeb9d7b469839325e1a854a0a48fed747ccdecd01f1dec302899578a27947eac0ecf4f07742b311053" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1c8f939474416a28984e8e5edd261c73757210a84a070b8feff99a3395e5f61f4eb5fc97b4a10015d5adc35fdc79be330112cb1133c9ec8362872029cff48c1aed3a4734d343208a809ecb1280e442ff80cdd793ffe3a0feb207de7ffdf685f595633b758f80f0e932464935e79d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bf442201603db1da2d8e8dbebad06c0856aa36008825fff03295f3e81219f0708983414a8e584c2e40bc897a777a03923b3be75dd66b764863c67b7dcb18fa781e2543f8c1a901e9e7a50c125f7ed0202f5fe5ffa4e2ebb3242e36e2ffa25ac5fa6d86ee556310a7cecc84a023b16a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "33166d74ead94fd2ea667981edbe87ff5a7418098953bd4a293ceb01954e83991ac116ad990bd176a885ebec291a3b2385d78e7b2c1034849b413a66bfea98910e5aaf3c3a83b726ec63c94b8f36832235f5986eefa495e7e9e1320ad00ff57b7898284a0f1550986cfb5ad938bc8e35" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "eca675d47a8c160371cfde83919fb31b65653792432281718d113780c0d0c1d8eed4f5e0238606d66fa0a3b515716ba58535c7d36a2a3835f7599ed6601a7e1467adc1720514d78946a1658139482d3ec38cf5d6aeb58f79ec51780b780a58df316a05784764d791e3a8f37368137e8ce3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "923bbbb27c5a11d4d5305a35646543efc0ff2c38b8602f306024b2b5954d940039720677ec0e873c8e0e83f9581a045867e9b2c02edb359249d9e006dcc6c79f75c9cc5dee9c5f04ae43268d5a4a1da37122904b2750aa8aa43800b7ff90e07041b9752cc7001928d9fca5e73874e4fd78eb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "16353325821cbee3c476b1f872fc6822a902426f812affdffb50b5cb7c8b5c550133c9135e0ac6068c3f8f0709f1a720717da2833c3a83dd9e6faddc45502950c33ac14d35dd05a96cc7a41158fbfbada5e5775668c6d0724a454446655f25e7a212e6d6b6335df1c86d0db17332fb4d12698f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "04a979bac8684f95894f1c4db8009a33bcc0c054858c7e8ec40f0820d9c98e09758be2b492426333cdbb0606fa7981033aca5afe0d13c89bb51b8c3f5b65593183c91eb23165a141b4ed8b9064469c71301541b8f7d087d5bdbf192b99c8f5cc440f01c3e29631c5d10c88f9f3ef9236fb42a1e5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "19352454e048610cb26842f57414f8f62285eac8944f6c448a09b2706c8b853267ef45d93a5056a89b2f28dece8475b4232f6206ca0c9090ce731b0dffa5130383eaed7a81f06c457a4684e5ee1783d4792e0d47681b7262757ed3446f037e6a9808972585cb2ef0074c07994d30caceecf9a9d66a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "965ac58510f8f8f446dc09b91d3eda85b3a2de1350a4ede9aa95391bd116898fd4e70c0311df9353e602b1d8f1060d69b8dd8672fcd6d1dd7249c804c5b4031d22896019809434483beb3eceeca78f11415a71e101df3fe5eef09afa97a1d1c66ee3f3efc08cc35a5268e06521b1f0742a45d0fb4053" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5f2215f843ba3949f5c68cdf5cac13ecc64a589ba0d752ef877a4928dc462d918395c83bd1c1f5dc3036621e75a51038f9467a8023800d6545b970abda4029ce1fabf0887ae3721f3494dc15a6eaab704969a5b4670c9339f181ea91eb7085be064154f6a359f12b6715e6a1190fe9fa2aac0b1a082f91" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8e6a13e3d41197e3f8b897761594dd9ba97ea1166a281fa01e2804e92597dd596d25726df67d9d7fcef9607a6fd248ae1502ee743f6d0eb3a1a8efc621f86bcacde2c53e091f6778eed63bcf5092ea732ed2ef7f71090f4c41d0b6567a4d7fa62c40ce14d7321f5fc18261a7c86fc06c764e94eb6b72f63f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "13fe6282f3c1379432cba49fa10fa325d165fe17e7923620c4172759bc8989395d16715cffd3bc719d72558a19cda78fca79477ae6342da459aec809692976ef227fea180e4df795766883c4260320acfa8e8128c6bd616ded9714e9d5badb3a22e93ee69fdf5496d9ca6c5c3a93dc524bc519861d80dea323" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6812a934dde83d1b997082e980f7c4b01f12e354cd064131de1380d10627549fcbd13db3405bef9fdc9bea482e72a29e727a233b0a5df6bafbf5512e30d58cee5cb21cf351199251f5dd8d45bce9c868d562f6eb6898952a82082eb5d334c69fc85543491d04c5bdfbf8b50337bff27a503563d8d7baedde9207" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f8c6b86a31408a2278b8b6ceb60eab1254987587eadf7655ffe26389e3119319ead76d4c1086ba5ca8c42aad07e607de1205594483184401ebd3fa5ac8bfdc3276c84f78b9a2c3d52580c6e7ee439168c30720fde06738753140c64206902bb597a794bc3e359053716c7cf1ccfaf3916f79902358501b13f81498" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "81672d4663cb2ffb96f8cf0646a522b58dd0ceb087da631e24b57446345f7a2ed9b684e1f22bc6f20a51004b58fc4cd3f575af5ac846aa777f9be473362fccdb8155d24ea889cbfb418f774b96c8ad1c6e5b5da2af8722f74661691b56662ad5fdba5022385717151d33e2d1f4d373c8260778881fcaf9efdf676a12" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f7abea1397adedb382ef9efe62949b6b3a4358470937ec54c5e7df6d30ae6db38082bb2d56f56eceef44bc13e4372a2d6af84a671fb7fe007513e9d5f1161774ebda4fd832184118cb7ac265c043be9c65f63c418ccd27a4c9da085b12e6c6533db311755bd1e678d3934581af794c0587c8203822dbbe865653b2aef8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9c9b67c43ccff3b84ee5b83d17c2d8ae44dd079821967b2176336a1667c7249099ece48abc047351fa6bf730c55c10823442350e164116fa4e0b290ea378bcde454ac8ec4d6962462d63917321a5d509fd2bcdccd47ddf5302c5696815fb1ceaca869dfa07285b1b43f19874c53793583f689bc3952f34272bb7da273c24" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "95edd838e7fe5a3916372ba59f6b58222f66552b6321066ac66159efa14cd7e06365c3430d325e9a8bc8945e595a0569de98ed571d340fa63f8ee506d9aa8070f9b70757a8d31fa5d677cedb5909fdaf12cac56b4e138d1e072ffdb126dbc850159bc581c98f3c26e27b8c79ca50d77dd622eeffe10a95882ab2d93d0c9a19" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "926f571626650610f95622628f738040814e59315fe7af85a8e346d18c28cfc6f3cab985db9947917d0fc128b138af2ecb02fd840ed91c363f8d52608ea405e37e2a522d0f1bf185cf2c3199fd9f1957f7216f6f2e6ea661c6a3196e77608402373dc9c36e35b2eff1fe17ae8f269e5241956088130f8e7b94cf042391482329" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "afc3dc4a953e845bc367f2930acf37a902e0b2fc61563119f41260c5d50bfed64951b127611789bab0e9679325a24c4642e0e80ff392c42c340e2bbb6d208c7e28e833a0d8adee30f907afca672835acb7b41063d804cef1e8df7e2688d9803d4d34b31200a4e2ef25280bace4e11266a1250653e89b2e9b350616dcc09bda9241" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0323b5622248d8ef0fc718e54c0296c99176043504f4f8739caf6078d17ddfb8f738e35e8a2469e62c57fde5b3678b66dc3ffa8291251ed099340a6bb07987bb47bb2bca76f58346d3ac254442ff6ed32712a80ad20b622c1e2a7e010b2a30915fcce91ad88c3eb6137c347cb2943970b2eb72b463209703c034c82bd22a302c5527" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6db9fb1727b40f3736250d908386e19f2329afd69389826073c2ad5eef09eb57f2e3b7bc746b4b7d346dbbadfa4c3e368300f6c21535eb3f3b5cf400fdef2084d38d1a042e3093cac8074a915ab7c8593f171ce6eaab28abb1b83786f0095be1757c7a71a38fac667d16f9f7c4ed2629f1465fafe635f624ee946f8d08e0587b62349b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0733913340ec863e87e9c0c29882a73aa820fd764130cbbeeca52c70b20b65a4437af34cfcd220b22ffc1d7f7dd6c143653177035cd29dcf5a68834de1a6d1e517b381ad173a9dd31aa93c7bd57ebc58214c8106910df2b3879377686ca7aaa9e39e8ee7fe65dc1c87749b475a24edb68b423135aa47c7f423034b4be5fa3eb06b1f67ec" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d9e86e137b90bdfe911a9fe8181f733d6a1a1bf1bef0a6e8e21ecbc2b52cbdb33b00097d3a2329eea102266fc9a5828f20d8f79b0b38e6e46f832c4dd09f2022eeb4de8a063cee2777b18f57e9184bcea014511c793f6ec65b2cb5b829cf02e32089663a7807f7f5f292fe2bf07a2a2efddcdbf0998e7511e0fb92ca96d2851de61ac1d92f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a802b116e08094afd366f0884b21917f20cffa2bbbc962f0338b75d0374ab0957c42c4abef8fa2a0bd9f208b54ccd39b0dfbadd13a4f9a2e6b699ab8938112e3fdb907de7dd3105388b137f998ceb943132aa97fc5b616d2a2f038e3eb8ca8b85abf0d74b70a5c64d8d39c5d01d6f653431f73e5ee74dbd12b770f87ede864d67a30942efbfe" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f69081e0dcace4ce289806fb4fdeb0b48599dffb1ddf7f5f558e101fd1a0528d534a5286db0f1e18cae824849ddd440a735801a24c84fff16ab92c4a09e091c3316d72677c3dcec71a9bb412b8763858dd649f28150642b850e642a17923632be4bde995d01d43225f72d3ac91d7fb55d8bed4e8deb4a8e88ed71811933e6e4a126e1a1e275633" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "eefbad10e1a20fb3a4747860dd0a5d1ae60a5dc9da7919f21b3aff8cf40f465221f1ded0584e73d02f1f3d598ccc1259b1a39f173ad03c4e3573528bb1e4aa410e5ac0702f16c53f71b041e06a631195066ddfb5c97ca6c6955ebfd9aa24f5ba650f2a9fbb574e30a0b19ae4bb485b422e3a47fde01fd22fd72633c11e397bffe55af45bef687673" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "97e9262370583e5abe378e45febbfb8738691395eab70550021a94c31a82069c22beff6edbb9c65341c6eee246cef57f25ff864ad0eff66cc3b9a41fd3d82287528dfaa12452f9bea39997c00552d45fea39a460ecc2f23d7a58673f93acc4bc48513c0d01298af2195a2d0b692d5ce0b4ccc85c82b45a9a43f70a6e91800dacfc022b27d535cbc147" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ea995f5f197d938e1958a041708710e6632bf48f92a1ef5b1ba1fed9b0566e9cd6b1fefbb77b2009e98fdf14d0f0e6d14dd33fd7ae1bc4d4de7ab1c614ecdbf5651707f1386a6120651cfd2a561a31019f80b50b330d0e5d052a434d053b76594f93bba3ad7b2e048d2dba4fa7c3498fe8f310c0ceaae5c12e26d74aff0a6717aa16850aa2b07115fc9f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d1cc5d7ec1035fcc4160d5cd7ff1a3c89194697ccb0a00cc3ed4b3d48ee71eb5fcf228746e20d4b3e93dabc12427c15bbc3147f00b124d812437d19eb6f9ea5236f87052a5fbb379e27091ad829199365115275061c79f20521053a88fca71cd7b0afc377fe4fe34d9d56d21816d88a374f7df5de258123f35ee1ebbf9cb20f1ae94705581f67f24f626f6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2fe0f366c5051ece560570f2c2783604c1bac4c84c2156c916fa5ef7839ba296343eb2e26c9dc446441897c62a9fa56fcce2fb92af4db0ca6d16999514a1b63bee0f0b949cba08fa3e5aad137df5cf5656e7fc3b09ed8c69873861871911091303f855d79e678f674fb74830b263e22be7ac7b89434fed87e0df401ade983a672ad919565cef1ed9403a41b7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e234ec499d037ff0ad5e3698ecdb7dae1e10dad50e4d5507545395913fb51831e4f767e578a7e17bbbb77f57d1abf76bc1d419e6f38383b26fb639a5ae6e14a910a2b22ed2a41aa18437862ce6c2fe8d1206f21900d50f26b1f24024c8ff36e9b662b3c4c0687364921d2fa6f6d0cba9e76d4b2b4b2a74f14dd8c2e1a752e99bf1e5154ef64b095197b0e7da71" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c5b8214c2baa3953871edac53f0513cfae89f14c99eb9119075430c8882f71f2efdde2aee59b8395dd84db4dbd0c0dc0d2f248159d9e994799491aa75b02093cff37fc9a4e06a09ae5b6d2bb80bb46c21eebcc2a03ad0bfb1cdf86197af8b5cba960ba137fb9c3ff8656c4b38dba954944f05a921f98e19a19d89aad62db2ae7c12804e0947970cdf30fbdc056bc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7de7a86206aed65ca62e28e8021707156d74cdf87e0de02acfdfb0fdb46de5a70a06b4907e3d90ce9aa016723adcab4186fba4dd054c10f715ddb95991b10a18afedeb83746d17d3d3287645c00b4b9cdec703fdb4a802bf919514c605957865b27c1b601d2a1a0010f9e5de3839a325b99e6b8bf6691b4c298221297250488fc406878fecd9c6cd7319cc1bc8f869" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6c441cb15bb438db10c972797d08b719aba3987c056800016fb542a3daa944c4226b9b3c41260c8013721158b36f6aa3f3118524bc91b68b35def994a010d05e35cb29a3c784968eb8ce322edd3c3d5f1fbe89970a1817d7d5b7359342c964e2d4adc992cc27ac5322ba43c352ceebd88e08aeadc090a7a62983fdffa66002a862d24be79f20a408fdf051d302972e81" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5e6e5eb22f30350dd71c5f3253d403d85471d2130967e049ed4294f7e137743bb60c0b11b0f5818c0224bdb4ae1295458a98857b6a32ffbfd1f7d2863acce5c844e044bb314e34df2222721614d0d51e5bb2c04548228a1693d90783dd985818d25bcc6c61ff875dc4b6fc0eaf6af89e58d981904b522a589ddb0178d6b3a1d1c395922584b62c67e965e840589f658c63" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e0cc757725180643bf8d08d9256aa7acea53a56dad9b49ff86e73792e721c96aa5c496d2922665ce3ab27fcaaf596d2aeac7ccba1e5f56c1bb3aae070dd01a702dce11ba34fbe71b102c35df3420928e90e84671640279ede57748346a3bb8643a37cffc092490760406146e7922e45680f6520b694f8e599b857074981be25e89bbdf82f9b1af169936a2ac1b2eb1fb7513" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f992da612169ab7b8184e28fc2fbbcb5006b3e92f084052dfbd89a74cc65dd0c361a0e0c764a315f58ee5123ef8d48cd6c5d8421e8bcecf0fa1bc2933671d856fe30dbd9e9492c4c3970804297df06f08336b05e5f5227b568b7d99570d9b7ee54aef3a8bb236a736605403fe0945fd85cccb0ba083f20034d6c625bf5a75e090f42af954f444aad730ba13489e972bfcf0a15" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "762a04d1740f3a31150b0763b5b3b91d3e1203b9939e3d45a6bf21e96ba6c82214f1b7481137084c234445406aebf30d7b2148afedb78c19e308ef49debdef5dca50926bf123d9be9f0a39d0f59e2de55f512075c2ff4d5b426168f31284e1aa5385127dcd054ab144c26c351f5a70d9ffb7735c43b10a83e790df8da1a8311c7175dc8e2a79f4bc7b47cba13a1d8af0440ef70b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f5b7e6dfe2febe4e8280667743680cb85ffa1c520ca8651046dadeb10d38e6a0cbdd2abc9dbdf4e5c7f0d81497acdf291fa41848c30a6bee17330ec49bc440ba92b4b5bf3515cb02e5675f7f09856041560fa38e4f26c6309f2c4be814138839ed8ef64be1cc13d322bc9eac111090a24e0a7ac29fb7c9b9bc8f864f2dc96f862598026352530ab7d3120dffdcaca1560b7b52bbe8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ac6436d8b5bc121875027945b6ec42ac48bc7d37c81ab624851121e6f8938a67f49efc5223205478e25ce51c6a802773be807b2e61a448a7656b7c9f22622e8e9101486c8c6ea443ad17402f2f373123236137925cfbc5d8a154a55b9e7295f0b0dc3e58c91dfef8eff278e770c9007d5247f481dbce8ec0c129e49a95fe4ae2ebe9ec6a75dbe7c9c44d29218e1a69389da9783933ae" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "47a8cca3b77e63f270d2448200d9f3606374f7e708d3e60669896f159e2e80192c141210cbce44c06369f339d93f97c1107affef1722cd2238546dd69505bf7a2f894bae87f13209d03fcf372413aedef8fef4583270c6bd787a452647e3534ce8cfde89d03e3a4bf8100e4b57c04d6844492af0eaac44e1482814e038039d37d41d7df47d7098254ae1fac3bc3b2af97b46eb2af9b8ca" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a7f309a4215057b16b9084a95cae92e7b91526786b63acd8f8c5c13d7ed0ed696994f07b96d9cd2c416909529ac914a128634ccd9979edfe256205998569b395a06095de53699bd1e9ffef2638432a4cbd4d02b53b600fd34e04d2032555d7ccee0a217e6d96c67c76467b62bd4cf4099210b8155f8ec0ebcf4336047c45d925622e328be20b4966aa8706bc36fd222def584579decd3f59" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "39e0a9b4109ac94bc86adcc6f3b13e5b6bd12980f6b6203a6de641804791164fddcfc888db5cd5d26d9e7bdb8e2d1467f5870031a93b55b4b8e872adb1886c98e698dbc19d6eac9c767ab2b562d3e4a726f2c8782db54b27b0ace7836dbf86ea5dddc3ca95447c17b90f97a6d925c913b0df825135b93f32e7c845a0c40ec7abb07970c928b6e2153de1f5f927a872624a1a6329e3d675cdbc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "34c075d9d6d050229c6f9575cd477ef976a83026b7979776c1a255382de751894a47e9905c16a596a6fdbb557825cfe194cce09d520009ec70b4d3e591c96130c882a282334b9def2b0ec09714380a3437e8f0f568a00b91e5ec6617eb64db9a0e5a631e089ba4cc3030b918def43d5e2d745362ec7caf4302dea3741686f423df8904a03732968a16528a36b26acd4c6c677a724cc19181f040" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b43e4a514c52415dfaa0e9d69e7a329520093e5760a1d79116d756c177518245757f603d3f859a48ad27f7ef25c210eb6660a37fd27f8dd4dc29f16b9717507f3cef8ee8c49b0cb44ca0cbe2cb2762d91ea3f49db133271212d7dcfdd6afddabfa34c5bd3f6c5f57e12b6d4d13e1eabd96baa27da286b139e2fad4896ffb7701d6bf57df16d2779b6b46aebf4d498d991d6387e5ed9cd23fd1c847" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f132c18f218b14ab6add0c359f2c81638f9df0d11a951236818e81fd7d436b97e18c45abd3307ccbc3bc93e0b17c1c66bd65d089d16e78236f557cefb1e6219586d223c284144199e3fbd715c6d5adb5f5dffed926c8cb9fc825602b3f206b91d4aaab5b868b6610bbabbfcb8b3c96400c4045e47951ccdaacd2d72a3c8f8bc265db7553eca4f53a7e816628ca70f1ed5943d33fefc7c4462dbe4c5a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5dff03f0b320ab343c4b63733b193bc2ac369c015ed55ed7217207b0cc86582758cc59620e02abafd241c892f237130178186f97e50a90154a3f020a2bec33e49d5d06b17e13bc3ddcbbcfb6503c9eb14e64a10a9b1bde1aca7fa6f1af33c182795c00c283d033b5f7420265ac8194e79327aa4817ef04d4e9991035e7fb5efbbfe7426098392c3d5a33908ab6cdf7bca5354880e138d341853e5401ec" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "89e2b44833586822f237d1cf49e47479aea3a909bd703f2623faa889544032e52e7084670456375a58297f04e73cb6bb05a2af8e7d6f295972192f143001caee5dcb15d93bf02133cb5056b94dfe3f64283f2f1c59ef9f8cf7732563d088a67447fb92d13159b0950de9c4efee5cd4da5847830f62144b553803601e695960ad04e3d37232056dd1cb8a90ff304b172dfb035226d29cbd0b59e9d5b21c3e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7bef5d050056bf05c4c735ca53f59a5db8ba571a09a16012c469552c5a2231a0d8b52452051ccb79b11153f2afd3c9e5f2a491bc8d49a81f320b1dda084b3010f86eaa22dc5cab4b179b2189556f09467013258e0f1afba6264af97bbcbc844d7136103f403f56db79cdb997b7d0a20240852025648f7507101b81a6883ebfa49255ed6cc0318082fa48a3927a91ee6d73160bc7665faa67a5716005e4931b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "750212ce39be39e573bf4a4787e969103a41dd9e2d0e9025026c5ff30c6a66e3f42378e1ebfbcb193cc8b695ef90d94b1dd6b785fbc3010d95e9f4a91108d3fcf97ab46ed7059839adec545599369703756a3939c23979e254671a1b3840953f7a7b089cc33089e3da314a8bb1899d70efa47e9320b81ffaa3364c7e403351e26ab49d9a7e6f288cca67ed5c1120fb9c8f1d58557036dbecab75b0f40a9d9647" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7d927ba14c4d09e95ced48ab6aa295b68262ec0ad054025de80da8cd73e4a38cede35ab2abfbc29bda89dc6e5185b313d9de1f21cd8020c1b45bfefca13725966603d3b0a19d906e76a1599eb6612edbcd98abec8278d1147f1cff473a626636f75e0c2f691146ace47b4bea98e78b34c3aa0f2ea3df7f57a10d4cae3aba3f2323fc44c0eb8db6c1b3fe0562328461eed1c3da8c2543150e0b535faa8727397395" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bf24edc1bbb0ba5f27a8bcb2c6c10fe342e7e3f05b47990dc118aa4afb459842c91faca491e57c32a73b09ef42fbd00e1cab092a616523ce8392a8d65537c4dbca23928d7c85df694d7cd7353adea0ba1f5b944d5396660003f394f9db0b75e7f4188dfd1e4ed6bc0d6e651d3e0b51a576913c7bcd6b2e585f80f9b2c23f76d3a756f2d905bcbc52290e73d29a1453b7555419cff091679d0accb3a0d687ad115020" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f633b297ac617d6e4885ece567e1d25979f305be0a2f8d8f35cd48def39b96848d26419832cd6871126d862c7b00870116e23aac91d3ac7d428b61521f7dfd676459261e47b47b2e389960cf2925050266bfd09de6df95097c2978334d85779036b82c4a934e29646bb076a9f9762d56fa18cb59f37c026267461e8ebf18bedb565520f7b1f2dda53c026539f31b63e5b09166595cddf7f1a0812f23fdffffc63c169c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "1abb663429f560454807260b09a5b7291f483127d168259872e964f0de5f885a2280cd3f75ecbb7afe1fa4bf5edf058a3f591a37315fa132d3d18ca52c5ded5048370f9717cd64e42a964a5d708a492f2bf7fed270e570fa493152d3b794ae440259fa0dfb56dafe068f40785272854b06d4bc022ef1815846f5389ffc3a48b15e40e69875586824f6efbc44669f0457afd3e69ab8437c0e594206430a8ca8f81d787ac0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5f81f7efaf96c3d6f2586b7ea870c287b8b4d9e3f785867ae56a8a93307c13695dd1300b423b5004f0a03b0ff3a84b012e47086da6a7700b1ace111c753de88844af71217bbe4d0b8d905cca16a163999baa30e514d402e22b265ee33032e6e8e69b7aa871130f779d40bd8d89f47c72623421f54c0de9138817a436ce2b3d8645994427524dd26348b6caba28768e924b3faa468c4abf68b8a39da2b39aa8431af99997d8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9f7fe6ca671658925daa4ab04f5cd68b9ab5e41b504f4f85a504affd2e3b8caad9d7a735640b348dd657a30fac592708803e31fc675e0dec7e344f4c55ffd707b67f1c5f80af611ba923b9c2abd71294c2a29f75f3d686948abb2b5aba5c324af2ca5711342f7eee49be3e19e97fc59cf4a5edf82f7bc01a49ea90c94f3d549a45ce01ab785f2174a0ba35e2bbb3738ed4bf4b8b708d94163e74faa108034fb8defd5c506c62" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e07157420910a5ffe21df9ee78671ce38984c83a89a3219a6e8873c569f378a2afe4132e9b768a6a5391a6733897e642aac6f9b7020b2750ee9abe3d13ffd24be62b62f943420c503a68ab8cb6830762a59e42039f723b06667b6cc483dda77105b65ee205de8b9452e8fb7c5009be1107d255b79a5bc5f2ed9bf8e6e92aa0f7b5e70d676dd66fd445bd2583f225b5cec24e8c8d725b27b1ec218abb485490a696318ca6da50f6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "50fbfaef285279077944e04de5c0ceb42d7fa25b9e40f4efb2730c605e9b868e5fa3de3e5dc39a838eecc31bdfccc0e67587fbf9b2bfa8bb96f77a9ec3a0baf84014dbbedc288c4307c8648a97051b39bf30825766fab4974ebe3396dc4b9209d6de68640cea6548d2e660d5cf375cdc2519ddc396769ee5aadf4cba872610fd1f4322b3adf0b02f9437b28ed007beab1212e15fc5a854f9bb7d8b78d7f760f89f854675ee0e8b70" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f650845cc5512c33490a9eddf7d940dabd432789a736a105e44737b1ec4459706cedfddb4a1e6774a5c113d4195cc5073bf2b9e4e403bbbe349b687c5d9b938502568231b294a445c6e0cec07f4010ef5e88d700ad796b5488c9f26735e82fc556cf196759a6346130b6a103ecd89134c2b9a8763b5afaeac942c69cbd5e0f0b05caf8460ac7adbb0af868e943874320888d2687299b0ece196e93fdad44f6b355264c6cbe233c4709" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "faeb1f08b867088b601a8d773405fba4fa28ada560c2e9e46a34eccde500b7080a35bbbe108bfcdb0f28cfb0a6fa0ac50b80fa0917b65868439129707bb26eb13290fd2ad8c60061c20b3b75668d0d2ed539f1dd99076e58513b302004977f92069c077c4e6332ee044c14d0cbb71d480a344080cd12f7f31e17245a55165cbc6727053443a1264361f41a7784f6043d93cd8bf0fc0f2141ad1cdbf366f612e16d07f49ee8398142f1b9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0b703c4014d626e29fa067f138861ec42f3b71fce5cd19110f0dfcef1f50b3d07880cd07d2db8f6c2f4975bd674dd6b62c0b98bf97ea54eb541ffc66f73d6b2c16d1fb08e208163289be8a8f05c423e05e68523f75baac9d61fa3b0f6e1bfb4a7faad3007197c37ec3b0e34ceebcec9592501faabf812fff49ca8c2c5373bc7f4d75de7b1a2e5e6bd32cb77c6c2d6fd58cd56326f33cd61ba0940b4c1086e606de79ddb50f7cb182cc5742" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a992d3932a5d000119aeb6933b815ede519b52c7176c6d62ae98a39b70bd52c602075ed884fd82bd0b2380df2f8f244bf759fbfc5cf99954ac5cb9adb70317b4d52e1f982293e0d5a377753740f8f744ae4aa025fc66ed382002ba7f405a2f0cbce92ae70b20660da3b3ac10abf4f179e02553c2520b8b7c997ed51233fce90918547a6004a4f729711df06c8d2b29f65f24024459ea040a6bad1cc27fb1c0d8ff3d756a6c9bc74dc0a9703f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "152718090ecce8f70756546834cb6591fe853759c6eff8771c36d81e08c4458b080041d2f3d3a2f5fdc5efade8144dca0176d68c61909ef985060b522cec9f8ec6d54ee2453f1d670a75ebe7ab12c7de5a30d65c28fdf561599dc19c72c8f75e54eaa2de391909a948aa47c9a76358ef46554791bc18c289f8535bb9d30101bbc6d840347903c2b4f61cad5c2f6f04227df38108236a7a2f2bfef15ddcbc597257b48e8a5718c668d61872641f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "63d02fc7a14e2881eb47db6c79104f866a15d26f9f84d2c55adaf26b3c010a69ba973d586de5b12ad51e89a899c9b4743a60017dbf356b7c5a485da33047c028d580bcfe8d1408a1dbce0194af2a84011a6ea16dd5efddd7073e8a0c024c5f5dc4e71f36dea8229976962de385162896d0eedebb22ba35d7275b9ba8a5aede12c78843ad540a28838728bc1d4ad24e53c91f9d025371cbc230032a836212ca45aec4b611ebc14b5d353c54e06e6c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "cad989474092fba2670873c9cebc67dec86eb823dde7b0b99f1178d298be05828e4aa3eb1dc369fe7c6058b8372184156600adb5624da2ad769c689a7cbcb5e5c38e259a45d4b83ff0e93011e3fff285601fd209db19134883c1fd97e5979f97f7da4df2f3ac489290494dfc6748008f96b98e92637d4eaca6953c2cae677dd6395d2884ad59e632592c15df904cd7c9c8e481228e23667860dc3f5d2e6c4ea1ce0c0a73076e6a747aee3cf3c3647e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "36b5ba6d0fcb50ee37aaf66544d34b4106ff8f865c24b9c8ea769d6b16894ca0592dd3d709124f18997a98aa2c88e0a45af0a5fcbc4cbfa7baf15b246c74a26ec0e672bef688a9b619b081b63e7a30e09c0c8442de9fb071e73909f5d50b6c1d0692004242d3750d793f8a767d28fbb8b4bd40b6fe7fefdace8ee530aca73f75f5b0e000e242e1c6d31e3a3adde861668721439bf952edcdaab40560e30795c9578436f0373f6316a66dee75f2a13fd7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b9d5f19e82dcd525aeca9808a2d76174a04574e48265396a5aef082e66c867a0551bc30f9d1f044009db3c2d0d698678a9734ddeaed08d96df5e6efffb40c758c81ea7e5924f5530d60efe3a983351f54388683b21fb08cbbcd95aab9306454dd9104cd7d0b6b1cea85d7630d38b818082badf854af8104fdaa76e4c186b77fe0047f3e3566cea7db732d893b3453ff52cef9d0e7cbc58a5417c547454a353cd90dbcef06dda6a2643ee50f00dcdb9019a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "742d6d0d638dada3fa15074f7e6ca29f861131e7784a46720687b3d4534db7090d1312d1a215cbc5adad439e741f938e3cc31d2b92561e9302bc54ab4588ba4e89d0d538437e11960a83a11a1e52a30dce185cf3bc3ea671b0e24d54f6561e502f6d987b6de7a49e057b38123acc7125fd68ebf3e8fda86b64baf026fa8ad53c2ec32f0af41cd37c56d624f83611e0f10861b11f78b9999680f4aab8ec35298897c206522e554cc032c8a1847d4112b40dee" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "aea024c695d12c1e8e5b8d181ea49771fa6941188fbe128216b65f20849e11d61855ed132c2458524ff7f7bf4bfbdb31a09a5e3f1257243553e35c8f78b64803ac2c10db6dba6662caac0049aafdc627d65d040bdef334fcf5bdcb4e4aa25629cfe86faec497d1bb7bb9c9c581fb89fb91f7898ff9f2f3ac3db4c8b58fcfc1fe741a5ac6fd34c49cd058b48f39432345da0699bec367b04f4b5591a30097a451a593d0df658e9a9e15e1f5481e23d137104f1d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d28db81040d09a6b5303b588f280411511fc5f8c32a8fd6739f38f5b633d0175391c12e7f429cd387eec7b2bda428e56b93877da802354f5622a67ae458c37ac9676d7ad065e2764adfcdf8082001f9a2b86f0f46162f4a5cb8007122fec5d3838806a9758a6440433e808c8392f55e27c295f517ede674126739f7d32d923c6c09003cdb701ddb53e2cb48545cf184a142f6916694c9d823366ea900b49bb20fde261d55790160a41ff42f2b0a199c6272a6bd9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ace60c7ac074b101965aee3c36049cdf4b8a409f81e713771d519294819bcdd1b36e2bc76c4b7559830ebd7dc838696def0e1aae649e0ceb583eeddd0b94a239dfbf18b5dba8800898187b1c4c7eac811f43b8d8e6d9d250a35810c7171ecc79b4967bcf73c016cbfe8aa7cbebbaff236abfde7135bc6e29fa9e2af007eb5e524c15a1008d5535309ef3209276f14f27d05955d92e0d7d3eb05e4bbd4301625964129893abadb60f6f8b7d6c3c015b8570cbb4522c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5b5c19a7fb153284634acd3a98da6a66e31f66ffb581d71befe94f958105d814aa2b370c245134b25f3547abd0101abde238110b7d7f25206cb8aa57a4e1415b205c6cf3b46af23981d1cf48b6d6159040b279ba60ab78a14d08f6a3377b28892b5bb3d0e44f980290cceec226f90d5f4457a5bebe8d1a39e2e98c3b4e2010ef9eb24438a23ae73d0386bc5c9f56b581ca358b164ac7c051933e2ca54648456af3bfde933fd090aa0a3d57c5cbc3b3df57ea4a31b5a8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dd7b1c4ad1d97d73a7f5b00c0f45c1cd33be706a31aa44b36ddf6704796da1eb23d2195dd92740221b97bfc11a11fd0c5a1f8717ffd84bb5401e965a3e987e4a6c91a5163a0d2860e3c96f0acdc30ae389048f5eead04606f8f2d313b78623962d55f5c81aafa9f4e6c754f9525b1fef34403ca08d2c0e20d0cd61f6957b2b096471130e4d1d714e4e270e4fc29d45c536c035642afad9bf17e893c4e37c13935d9055a926a9ff0d5460eb3f809646e18222fef84d28ae" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "195e390bc6f727cbc247c31f58dba36117921596afae5be4fa0f33d1a8d454ff417bc95f03fdae775325ff64dc6918354adbb586844d66490814ee513700fe893d7640e81e24ab461ee79221308b245d5e54d99d1f7472a4262ee2ba759963a5970c46153add4bc04328fda5983ebfe903e2b47e076b48d517f7f0a6cff9ada7d9bb07d787c0acc11a2ebe22fc352f3517640e9dc5395b92ae769d00251dbae88a809d0673f08525494ee3ff7fb9956a23a6ab37dfe2b13b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2b18ec0134bd03907c3a81f39186adc4b025043d58deb0c327673d73a4d79b1720d843fb4f7bab22fb4126f4378a801b9fdde70051a48c59a4dbfd094cfc8bd658855ce16af0e563750c5f7909c273a78815a55b30e019a5ee26752a0a25db5032d1735f0df1c03c078a43ad190944cf2b6c89933466b49abc32f2e5242077e13b48c92d22e232e53a52c4bacee3b1e03d61c7fb8578cb8c58605fab06f86c010f5722f7dec13cba3931143f979269a4d7031068771cd7131a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2f9268871cd9a46480466df658d8ab1513de8ae18aea3175b00ebc92af48e363384b24723c780371e1c6a45444dcf17182c0a66c315c73de24f430a49aa8f2f8947ebc7bb8cc10fbf85fc8fbe134d2f6e9e11eea9dc79d0de6bc227ed831567d55a939f388cd4b2ec2c057e5ed8eb583b4addc14f0f2a5842e974556426e6d4510b56fb2bb0cb8518ce3a4e14dcdd3377329280364b0b1f602e72ba15e27e0991255801983211917f26c196bef06c3cdd90291def8c677a257e5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d567627598873f4dec3f6236240abe5b6943ac8dfbf2774dd7f40efacebc50b07fe52e6b89595553ecd93bf9065db058163ae63552d2fe4f3d19a614715981b7a503c6052c3e9e2747f6018b5275ffe078216c46f3820d964a2d11e85eb031f6f314602f462dd3c3aecc8a4f77d4e73bc44505201fd3e8e580d2b04c3f4c885f0d13e52b505067f3f605e9b637b5ad81d3d2cffb07f88f12ace18da209c10d0f4d9aa38c5a17995c92c8fa28d55fc731ecdcafa65d956dd65ada03" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e6f01a669f9e61cec57e3256c7a7c23b840b749fcc849b9e46d66f5903f770c7bddde56e969a46228dd2d69a8e5bceb5bb06a0555375178e15cb9c5957b2f52568a41778659a0841fa62cce468ba409bbc30e1a70facb45e0c748f08ad36ce113612f1217281f822546e29ac37466e32fbbf9fc878a12a75c5849c7efb6ccd2c3163bd2fd9ca8349dfbbd234c15da524256ce20d150e54086cdb6a83d3ae83a0b9c4a49cb5cd67ad91719dabc6179df90012b5193c120179c0b69987" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f3d1c40217c3ed135e5e6afb91770819b1596034a0a183ceb9ba5a1050f4cdacea0c8ce35111abecda4a09615fcc0ca476531b24d67e94f11b30b15fdae2c31d09995a2ee9f8db40667656dc197dc35dff1416d968a572424c7fea2de1f4c23bf6ead4345c881cbcf22c4a98ba1d3d3c6100e4e4a21e9197d3d54634a5d3c18dafcb9a8270f4550cfdd17cf77e06e1e72a6181d9342dbdbd1b656eaf735a07afc9ca4e883ca545e041f6aabadff6b1ece06870a534aebd638db701ceb9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4e80407aad5316ba80492fde6cd6caa97b1eb853111cdf4909bb0ef9ca3828cf94d059349f363e1c5afa16aa1f18c95e9b0b44b2ff348bcca79877e294beb7405c88b05dec34b775947d0fae8ec1da26c02bd5035788d27305707181fa60327c5825e2fc50e175e2922753307b994d27f902f0cc72b5f2e3b78ac3ea66973400b8faff4e346e48405eb2bedf96f70fbbda6ab905dad86e766dc3db774a358f16a1d416cdc0bc8a0d99a90fe23780c2da3ea7774aa976025cf784e46eda77" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a01a2a35365e7f0b3349529bdafc41cf031feac97e6254182bbc6f78ccc97b918dd51ba1279c24f0ee5a257b8dfb3e838567da4fde3fa4b2b49d108b5e843f8ea2453e2a5ba4cee6bfcb9e224d172369d7d8fa3e8fdac85aa257498b28b0af88559213cb147b6116ec0f7fc872dd6a84f246ca1f41b10ca43fc19c8f20ea5d63c4c39bc2c257ca5aaf7a89f2e50aba5eb6b069c200f733d7f68f2f11f4c430b932d40e7e62e84c22b75952cfd941dc505085f12869bc520dc645b00d0cdaa0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "03c4b34be5d2a1891b10a0a74e4cccd5a0be17ae1f2388a972ad699db8c247c4ec013ac22fe6c6c1a75751834101a17c930c90dd3805963235aa8909edd60211cd97f2896332f606164a3ddb1aa9465fa8c994aab818768166828e3d7a81b9aeb5dedf93555fc351782663167e2e36b618fb16abcb6d64de99971082ca76ed6ec17d5d0cd8b45e0336ff3061a5e06c54793b8eb10a1b772c8cfe390e5d32ccf61c05a618f5130af24b33068ce35dde6e3a9acf7550797078294e69a9b6c10be1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "52f245b0d61ee4f1b173511bd008d3970a25b5022250ec2b9f9a28b68b3b0c8d274ead30fb9fc1f9b3b5f2c3e7125c4fad241dd3f5f4d0c186f64ebe09d879922a682f638c73c0419e7a729329809a7325a76851b1df2eb4cdb4eca2204779b8acc052c62551e274b9137b1c50d822cca8d4cd0b8eb7554ba448b7ac6409eaa38093281c5017260ce2bba9bce09b3467178cba5bfa899101ea3d073cf778944afe12651ab713743218c28092e6d37b41721f191e006f29b5ac33f973d671e943d9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "24b7bb806303fb0581f5baaa960cbea9b2eaf6ad927d073237e4d77cc52c306a407a4b1094c668061ecb445eb3de6f1880bd72db303bc05af8a5b72ab54014a032c28af1d71a62fed15f95b468557a28fbf06eb22caad469b20702b3e067e96ebe06ec31a61ffc2cd4edcb19c11abaeb5e303860869ec7ce19061bef3522a6c3b0c64e11c7226bab5547ccf4042bf59b1bc0c2c41dd1a7db42418e835e7871bf121bc9b1aa037c3796214e31b682f8393a1531d1734e2bf0237be24002f8c2a8a7ca" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "21535b47e5d30e131aaa9572e94390d6466ea90f4daaa27b2211a9725ef1715be8805ca5dd95e01a649d23984d5e1dbd461ca6c6d9c9c4d62779bcd3c286103e6d3a86d289a86c58cf84941e74d022cc75942d41af9da94602361e1839a4d8232c3d0ad09f8db42d13e66f79bc22bf52950abad83a84fe6c071aabd718c243ce9f11d84a266b172c08f0b17bb07d0032cc27d60fe21f29479474f52563b9eb42e40a7c2188404019e02ecda1c588a3b9684191b19dd33bbde2fb3e9d5ecd1317594127" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f64e8a480d548be1e8dfbfc1a6c494b81e9c630d05c9e1c843d35c62109496e03c954da403b57249e6c3863f3f7289c47bd97bbfc927de8edd896c2dc4dd02971bec98624cfaa7244543c4bdc02c0ba6edcbe543cfe80a34245d5fc4abbb5a60588df8a1783d655c65606d4fb3a3568b1b44c1ab7397ad8117c5d6d9033890e2558ac2e2b9c8e262191cb35b2c7f77d4ab0c459473beea90eb8129a4cb4008febac2bf51997ec1074acdb75b8c446803b8f0d4cdd24d411c7cdd58f21e587a98a79a8562" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "ea65942ff43fa6092e4056100586228f2d44cd8f7020d7c9a0927af28fc4cfda7d7f8202b1dec3ac153d186b97729508f8875bc46c5213bb3254717facf81fb1b750f56b0e25923d428aee8f06ffa9f55bb9d06b7144c98926f9dc82cb7de678d0d217816d73821b34e60ec41a64e4b9cbabfa8a88ba9559ded2ad1c2e5c3b54654af840715d7de483c1844ed17e8d515d13016ad5dbb83e09d1eab459b68720672ffe1d8ac982fb5ffebaf08b7b94fcdd9481ce3bc07df4d4aacdf06b4f145871133b8296" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2cd24ad3e4a9f3b145eb0c899f4e9622724c3ee8afe865f8f1aa10003c584cc6eaf3639154ba7ae2ceb4c4daad3b2e9712bdd50fcb8bb844a080ae9ae2565a562333b098ae9f56fcad5219cf37bd7a093191eee913cd46231ca9290ca858e8c057a4862700c701178a908795932a16d95d17e4000d71911ac1048d82cfaf6c8007f3c50ba8b1eb87d07d66d62a19ed638079d4a5e813de2863362b2237b9c6940708373ebf162fe5365cae6f43a535a73e6f49d6ca51e8ef3811bd395cb84fcb7387db81d7fd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "35d3281fcd49033ff7255c49ee4b084e90a34cabbba2984fb4ce4f66a62b514977b328050f0af3b9ec9b2907abca5413de2ca1aa05edeadd440d5a261c861cb3e726488913917cc07e2c4763024aaad13d37158f1606bcda253d1332811f0fde69d411bf8296d00b45830d300567dbaefa79ae5f152a7a6212f0c481838a9319d042404dd3e64892b592fefd3b1127c300cb541388867dae011b749672008958764dad93c13898a4b612e6a137bdfa4ccf0da58aa0c25c096ba79cfa49ec9af689e761855fd712" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d055196d7bf4fbe53b8fac09d12e55f2401fe2dfdb423fc25c6e787a10ba2c192885c2ee5fedaa4d2cd1c880833bc32e2095246311d47f464629ad53c82cd0eca24de0801cc5d5f72c5f0d37733ca62b9dd47dfbbfb1f66ecbb1b710e342afbee3ba971c1fc735c9441e910ea7fd9669dd78d1fd4053dd06856744a122be93e5f73ecf04606af47d49403e3e658849c3a76d38833d96271ed76b0ad924b5aea8ee680b1da889991d52da6a4b7ea12c848e134fdbb1305e27c2fbce7233280c3b3bea6a1219fcc3bc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5d3e88955c388dcf6177185f894fa7901bc5874a9e73d9596da159dd88b77fcccb3ad5fed768ee6d69c05d6e38df5a679eb433e0161b3464b4b8157cffec2c450a28eab12c11b18ccbb68f3ae14c71a233e114c4868ccbd1e9eca1a2b6ca4a63779508099080d3de3396649344423a8b445d34e5902725627608e9b5ec920a8202d82a5eefbb3b3360d5eacbec5d9817a64d111052e5f030622ffca610e1af69beb2296825f2409a1042e4012daab54d649f5ae284ccfa665e6fe80fd910f39cfe3860f3adee2912c6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "392bfcad38f2938b8d7880f70e33c14070fe54843ce8622ebbd9c5fd9d7cca22156dc73c1dd616449826ce33e4bfeb4d536c8b3a72aa23cdd512bd16a7c7ed5febe356c8869c5db31d67b4fa34ceec7015a19391c4b5d8ff95dcf414aeac3e80d261689275be9b70e336cb13d9255d05084c367f42d92c18939e89018e0b5e3ab9a51bd9eaef72829e964e65c8d70e47ee0668af16d27a0307da66a9c4297da67963ac1bff76083e3a87ff12aa25aa5d042a744bc01157102cebe6521d7b2e5932e81fe2a23341534823" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "97d63a07164ce86d6b413acfe23156e919e1c40e320ee6419b9aea50271506d739aafaa4829862b611786a772e7aeced9007e09bd7524309095f1643ac8d18af3d3a95f9864b18d2e89df43a3a4597b0801f2ce05811ccfaa88c8e94373378bf325fa7fb6f05cdd0c8ec6cbe8db438ae131f5097353eba012e18f5d1499e735ff4bc951986390530998726e7a90b0ed71d16e8986074dde9d3770005a748fdcf411ddf0b03615896d2e0cabeddb07c57d74ef262e1778016c8246625c237be901bb8a6c05cdb1ec2f3f4b7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "5d14d28542ed0c9c21aa82de98c45157b83675341370700d01a9cdf62c3254ec8e44bb1346f503b561ddcda6f1176816449993f99f870d774bf6610af93cf00c5d36e08a6e006c4dc78c6605345c8abad4a8405f575cf40744b1c789f987cba44c31a022d98d20e79d214659653dc1d9812c7b7f82ed38b469e8c718a8f4a281f71911929ed1b5d4e618c4250dcd6980bdc64cb34f57d0d4778511c38456c40300ee6b0b2f50f64542a44a8c9b3b41d4c14bc06b4e166200c1a22bf0f11d51f07dd130ed482f6a5804c6ea11" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b606c4c803672e40423f7b2017825cc6d87f7db31cb155458427d40824f4d8ef0e77b8f2aa152a3938e1acdc8db298728ded23dd2eab091f91273c284b8f644328d16d7568c112f4f0d1209a857a6fcd9ed00fda2d8bf2409a01fe2cb771006fae826ae58d7f5d4af94415569395bddf575a116d6daebbca841469f06ca234edd6348e078506d5f3699e8fa74fbeb65e6e182e40af3b129bbfab140a287d95bced6a4ddf4bc942eeccbb875c60aff88987642b499d6d50f2d37beb1b54d9a27dc25350b324e13b4dbad157d18d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "29606ee5ab59bb463bdb766a319af2085a36d5d5d92b83e60092c0f568ebc8bd2c7139cc0042f7e248c0c8a89936a39f4655a78b66e668451562fc7c7f9127a7254f4fa39fdb21528f21aacc04d86ca7d985056db91d70cf46ddd89a54a78cb2f133ae1310ab830813637fddaad4d70118b68f50919476e81bae14010d8b5dbfc88b2f92b048476139e7d47f6501ef8b0e8b52e1626924d6f90fa32a7ca62e1fceebd50dab14baae9e21a68a64af88962b6d8c55e0e7e6cc22233405e7a1d29360058bfff24051db40ebed223271" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "63b44af02cda636a386591f0f2698336e2110a2552e43783ad6da06ded94e314fd50adf6661f1caef42c42f60d9c4e50261a5eb45267fbb457deb03ad0317c4c9ece21c6595d17c7c854a3589aa6e75e04a9865f821d3b8552acba9bac49c959188de5fdf7f81a26e4f634ecfcf46ab5acac7233b697ef91b79a04dca30fc2959bae72c0a9806c74a59c53f6eb322e00301b8c4858f6d554a43a4e2f2486306704ae96b0b815802caaa96f4078b27e5bb7968da16b5a6c5b0168be405c95647bd21b3055e6c849d65f0510d458ee25" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d33b0bb08e56a3ba99a7bc02d236c884110bd637c293804ba2dc254473461ebc307a311658232ebdd608177e1be7f9fb66d912a433ae6bd1500822d7becbe453f01e1df8b7b3903d2b8dcffe1ac23e42b33d8d5b446e22f5dd220ab3f22217d1c992b30d656cb56bd3c1199e8672328a8598599c6099bfe3d452c942a285f35f96a85584e11e9e4586f726b721098294fd27e3b4ca3ecd127989e1202eeb218fa5d74aa66fd5533a22b25b213eafc8dffbabef6e17362b9c1888e82b00108cbf8ce096348bab79d7d53ce997a1b182e1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "623b1417140ab573ca90ded7bd86f7fe01292df33d285d2a2ded9fc6ad13060769d18cf5aff2e276231a172a9ff46800434ef60f8feed67e10058a6d32dbb111aa286db0a8f0980a5e55c6498f4e380bf31b1a4af1332dbea6cc0add86f563f1ba70df596b29eb9fc694201590a63e817cf455bdaf49ca1e5a4ee4250643e8f30389eca76e03251b41ef211ff1d17250ff7bf7a72993687f6cbd1e73015d42485ca36c995352e77b966c2f77a201ef57d5d3d8272bb87931077df73ea3937195b4bc6c95cc7d975053c150c6f354a5cb6c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "debdf7e34d1927d34002aeda057f7c56a5d2fc56ee130c91007432860e1da1a940a71293f371b2da670ecc5a7e3fbfe8779c1546cf4939a6f36dca6aec54018770ec3c9945cba91a83edb3fd32ca6182c01d0e1b74c1d80a4e5f5537a17c2200fbe0659dedbd4b3200ead90ed34a8549759eb3a21eaf6f8f9bb1b9525f11bb4e10ea55b04174dec2a7fb6b5ba2dc212d4f4e45e6b948ab3d6600f51767ade1339c26277cdf0b3627df43e227aff9a38800fc496f6c4b3cda3dcb5bb1c3dd03ff916266d5f6f4bf1df0ed4024afe84ad1edc5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "dcdc862adacdbdbb9b1d43ba399136029cd9901fd16f443311ce1009a17b2bbd118a92db41f60bd9640be21488c671c8267b7ef10d94f001d94bc43cc783351eb05a419c183a6abec9af39d91edfca281f0c53db8bba509140924327739f394af61b77352543530b1364fee4dec9a04bfcc3aa51373692087b4d3115a7295e549736abebaeb87c64066d3e1d5752988395bfe67c9b5fe9598e313a39766486fca2bc053c4ed09b5dee30b182cabda9395ab140809fae76ccd5851ca625c8ef0dc8eed9308248aba77a06fe6d581aa103b43e00" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2a94dc0ec9592004cb301aa3adc90da3d326794934c8c05e17915d31d3912b133b0508d16d47c77c03cc7097d68f1879a39139260d39a10ec407db9680048e8ed06f3cb4ee9e53afd01ae78da4f18d0e7e298bdc882239b22c4e0790863cd88fd3485b633adf21d279811c4eaee6f61a3b0b6146be2075c08a9c97883062b4ca2a16c4f309406a3782fdb3646e51b8d52d25a15c7af7edbba28693906dc8497b9240518b2457003a9c55c7a41601329ba7eb46e82af1db23d1ddbe1a67dd358a9cfddd3497bd91cf0d4e41edaae8d2232e3acbf5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "b390805562b9503677a1a5adefa7eb55ebb22acc2c7fd7032326c3f87900a6d429eda3663b77eed2a5df929e1b43763325bde8ed901092e4099aa96f89b42c2620a1d8a2f20f772187c4b30d62dc49f12fa929396249c41936e2bc379474c8d8ae0d71fef5307644893eaa14b46ebeb581bb139956e1ff4064301d03862cd358eb156c9dfce5712b35b149e42b53be3097e813305b8a689d4a211259d73ed116fed8fd6ed457f58665289c73799137aa57925037d2a4898e19609a576609a539d640a6a0898d76e7d1170de06e98a87c0aecce67e7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d527df309ff5112d906def8c461e300942e10324f9ea54fc47ac4e81bc7f0e83f9eb3c7f347ec1877340c78346f4618f52681eec7828b38583719def723ef4b405553373e280668c33d846ad90ce5e074f31cf6ea49b08e86cfe2ba6039a7259ef9d73297d310c6db2e17491f524811edeff14383280dcd3a6ac23cf170bcae854b7bfd476195b3ff0762f1ef4bd0d5c1727968fb79c3dd15b256d6cd53ddd0ddf4e29eadf3f75013d9099a351c53e9c4e604516f050dc6b2883d07a28e691798aab696cabf607bdcb6f59fc32e1079d20424995d13c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "58ced7f7d6ecfaeddf35b67823815da814b008028d25af3b79364d93ac4aa8c120a27745598f742a52a4dadc2298df0d7d0fbc23c250cd097a0076b89017c8707963e0b90f06161dbb4df4822bfcd2656870aceb9a5adae5cae7de37c3df6abaf2ec751cd163f03613e60409ddf579dd9b732ba3c429271f3200251c560b4010e9310233426904f8e2418798373ece661646e8e511a75b0df17eadaedcc64259cf8c4fea77d754eb09f378edc79259325ba9414865385e6347efd0f41de3c52c6f27d6c8b92d97a29c1e06d37874e0c58c3d940f0f996c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6a1d428d191bb36d060f1263573118da568af27ed52b96c71dcfd8e4a61274c64bd3627ccc59825ac8f2325b2a7cd46be2fcd5c22f3ea1b7a8920ee8d150542f08e3595b225404a125a96ba66f9ce1fd36d57f12bef1c66fbea22144d1353d65a072d506d0187e2e8aaaa25d1c7c8695e3293f01fbddfd44307f687f6389c34a2969ccdbdfc6237b382063f6f6a9aaca24e370e88ccec8e74972fcb6934c08dcded213830f6430b37a82b05f408c8209f95ea2bce17b712e73ec83acbf3bc51a2b6881e3f3bdf02684b6b752e7abe723679191e26abe2cc7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "acd7222469ae8767f7c949610852bb7f120a51bc6561fbf66cc7396b38dfbdf33049302b4f26caa93b2844c6c4d46b6ec0f5384c9767358751b7c148830d957e68c08e11ef9a0fd7f381aaca2238c773f4d2f885fafa151d17a12746c7c28a57b2ec7c575d88b9d98652ff9140c1a4c50f31ee4491e53572bf16a10b29efa94a2c079046604c0715ff4fa1c4ea8fda3cf30fa8ce37e53740274e83f6dcc4a63d24d34b3ed9393b671d3b9915dde6fdeda18ca5d670277c434d793090bed30966dbaab252966afba1d426ae2d19b5c74b16d3bd36528cb42b4d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "97ef05ca9a81c3ccb8e993d10943be011b8ca3e8307ff65b1ca259d70718f22bed4fe50de5e46d6abdfb3da2bf9669c6ade7746d44a40ae0655e9e8b4dec1f21c41a9e907fb0b4beafe49ede427c7da456d9c9139530875ddcd9e6e1602480e63ab8426fcafa6eaa3f4a68e3e04d53b64312e25e3339d0084a987b53c11dae4cab7091141018f9f1780753e87aee6317b9e249135ca32d26289783ca2af99a2d29ef35b92d4f6541e5e337b85716266441867d89f0af4b855ce0db3fcd0b7b71d8491d43023ef06586070e167d2dcd90ce9aee71f9043913f459" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "faab0206e2bd10ec36f111531e9114f4ee7fa43deb60b268254c0e3d29a4cdf928497a097791816a8ee8220d8bcd6e5ae6d403ce64c7bac17104dfed8f56870f067bbb210aad4b042654fdc7d5e7c1598eef1f307fe871d00e6d69d68067dd98a7d91abb8040393455f606da8349beb2faa52bccec14c4f1f4d9609b3b23dc24b031c65e7eb67ed4faf8e096511403c871a9f64e4b8dc3e557e9bb5d6716d158924bc4e5b53d81138b2643c253fe9276110956e553790e0ea89a79366934198c21f9532b43e3675552dad56b447f4bab67ce04d53101b7734a50b7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "48d6d638ea797322909ec196c41ecd64717c3ef45a9c7cc24820524b1e20e430c59a9fe3efd044c692a2b7fa0d476d546b35cb09e8144877c62ade19bfeaf598d8087a97acb68f8add97862c1db10f0fc032a74ba3c8fe4fbd07a28bb9a3c107ad0a2a0e0da23eb74ab55f8a2b7b511e1bdae340b1d8803b46edbcef3f537c8a6ec2806b89dac13989b89186587792f42e5cc2f8d08f9bb989f00b770e4c4a29e1c0689809b950c04dd34e7e7f74823b1bfcc4f855bc955ec7fa53d9a6d582a5186ca1c282f030869fe5d7caee534b98ca7748c37476c6c69a277051" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2894313e0e99da4a8d543ab6dd9803eeb369cd4b3a7c590e2e56b9f99487c16bef7eb190ff51fd2aa6b93723e712717cf721106115f10b2951141deb33b18ef7ef1e7145ed9b5eff22fa30780f05948adc7195118e8411f853b3a26caf220e81d241121dd431716a58994b7d97bf76b4acec5424818e545c4c334586efb63907dd436e92bd04aee200bd7dcb7cc1ca5f39e67e355b9e1fce7ddf882e324bcf957500212461df00303eba46f538c6de2a1681d08432e3e28ed69767b1538b09eef75637da24d100ca8acbe418760edfa21a1125a8dcdb30762544405405" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "0a760b5a7b059f5f97b19552306d18463598a21ce5d01c9d228bdf61bc5eb4a6820cefc9e3d59018f775e945e20518f9520ac91a7469b612d738a900c94e0ac42431aeae194040c02b6d628f1815e5270edd3bf616221b0238e779cfca37c3034a0a747a0c0b25a60d9fc67abd1fbee5498355cde9821814edc8785b2f965d29eccb4aa1b6c5c417150afe9e2537bad0b696228e073d73b0e6753fd165831b479c95adeeb2dea1466ab405ec85bf72a436a0764bda5581369fab7dc094cb0e8556e3336bf1c6380c1f35cec4f38cb2e2ab03969ae62c7fa81b3a43869cdd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6f268254d6fcea73605bd2ce4d85df1c319e2ec84dcb204d46037e25d3acc81051f9a32be04f687b642a6a18d506b26b0c6c8f2c00a6bf1726c628113069beede1020cfc255391be45cdf3ebda30042bb300c3053608716ecf5f8c435bb10d4f5da66a8695788b034c28956d2fc6fe5dcf4b3285fab8fb650d3c4c6ee0ecaffa47f8177eab9ebec5f8adc5a8cfaa9c3adbc94b91629413e6da4781a86525a3b27597c78b0642cce5f12e5bcb844d2439bf901c3934d66e17f2414b1b8a62b53447203cdbb9299f928799a0701c58cd816afc73f0001f58b4097cad8e1412e5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bbdf17fb1bb249561642899623e7c7f5cd41a403171b675bbe59e5ede54a76ebe2cddfe9eb77a4a66494a09748f25e1fc3f0bd744bc685ea2199196e0859d6a4b6733f866b7b2df0ed69eb5c5ff6223a520c9ea99840c9c5ff0795d9ba45118d491d4fd6ed8413dc22e0f1ecd64e64a01c7b93ef9a9ee7dba83bae239d116637ccef80f25cca04acfa82eed665c46c98a9bc04121f70d781c73ab892f7982d0e772ab37dfdc3b84d2f357efbd60542ade377ba416d9d5a595c96d17ed8dd5c8a32f114ec99512dc2001227013eba20356120f0f712291c8da6df5681e2197ef4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "439943e702aed09907d07e36c81f1fba89772351f4b60fd69e3058e88330e242470c0bba6e42a3c16e1b89115eeb4226c2d9d2e49ffba7038b3bca20e08028947b166957ff2bd91d21bcc6377f105b3d49a91cae8eb6b9b701de96a423445dde2472ba3eb001261c17ca50a955c0daf9832c7fe86f9434f88d2411d7a030389e7d93f14b6568b300aab8f54865343ae1863852827c9f72e7102e92a1f6d67c55ddc6a2b216241893d010bbe104d2229acb0282263979d5b0b86e2768ad7a59ed51935d29bdb7989bc3b9900c6e7e2ca65d27b9673d2c8def797c3fa554a032b8c9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "4f66b96ecfb7dd7f1fe069e77f9a40ea372bac1f13c0c8b29e03a4384a928ddcf6d0c7b29e429991d43a1d835878f4d597b59da447b448209788dc3cae8f7b3f110490e1bd0e7d096d1d4b433b2acc70031b74daafee42f3ea8cfb12aa2a72bf12217457e3ccd4660a9ce8c6b1adc002dd5e50faa748546920b61e27f1e6ae0fcb4eda0336381d81833321eb8edef96ed046bb88416c95cfed95d30321ba53952c9b738ea3a6c8650ae31bcd1342016ec070e4527ac9509b4542d9983ad63ca226528448d46ffd6417f70c78dbc5160f546d92a4ab0854aa6abe37481824ea956792" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e71efa0eae7d17b57212f0a1b9e9ce30e9442bcbe26312fe8dc1dc0e2b0b1ef028e0e98ac816aca2af4a725a0abce96c0907cca5c07c612707dc785eff79e759393258f90b981d7f4d89833629d32507aeab8348d628484e67b4783c0bce6d810ccbffdc77ee2796553c9182f5ef9ef6d84774518c05374ea6cac33f720767d7a8ed29c3c422a3667a692e0bb8cf9439d879ef90659636442bbe07438dcc1bba764c6497433fc000a09b7eb5518b2c179364e829f7a1128c7504935503ebc7d1d59166a843ce018f721e4d554fd27b731570ddda8482e67f03e6669ed4ef2511aa7bd9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fc646e856c320f2b9caa33bd90bf08231db8740d7fd3ced036411aa80b7650b58ae100bc07195e88d8ccc460aa58557482a794f15204a51ee45adb7986bff62003a32083e5bab62d66ac406dd74bfaa09cbfd21f2467457a51c3cd4988d40628d65b6363e186f7be7195d110d772f3ae0a8c24be2b0d28ffbbe00b133cce4ecb51651f0d8f6ed63ef5ed012c93bf58c221ee7837c6c7ea0c09302570cbf2316e76474cf264633c5b28e71988ebf9bdc055f127e19b49a46d892291b76f70ac290f87c8534292d76c4c7bac67a2dc498a81c108e52b8c0db290628121882a067cffe235a2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c6f6b3eca36be502cfe65b1d4803854336969b65febede26d9513e83c6d55a38948a85c54997c99f206fbef972f473a8aee5ab44d32eb75f38f03ecaa31223cbc4bff215772061afb48a80705e1511d0cdd4ddf00a365a09d7e1e8daf0f32629bde8576e2055e5fee04053f661224f96e28c3c3b56c8bcc6bfe14c7a224242dcf0e3e7f002192655846037017acaf069c63a44b72a343a14cfed90ced833822de6118a5b5b257bbce56d24ae81bc731e0b4a318e45a84310bbcb569833dde17b396f76b4b0f72f4e59239ab3738d028319765e3e79dc752f2aecf2a3ab5c51923d8d6bc58d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d11ae03c75a7b0bc1723d301b4bd2775085801d01ae5cccb9dec444e46e44f0f413ab0ac34a005a4b7877cfcbc6d7db3b46071c0e73b90a430f4cd3a2a4576763926df0894dfdaf47ecf18d2d4a9844e818ade7c11a993d11349e04a6b3da2090889e0ac67fbb0b86817215505a728bacd2e3dd7be9f80ec92c591037d16fd1b8f706c95c097b18f01aa4577437bb2a38c569a64fe262192fe00921df4a9d95f3e481fcf422d7d35fccdfab474f633e17dc041285d6fd59831056846166cf8f95e56a6204239794125b1502376f1934ff62b35a2dcf1f51b53720a96f191d72032138035cff2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6d243cfc8bc00b2def28def7543a0ca2b0d531c4be9cd1cef41d53bb2b84da4f3e1f58c2fe89a49658dc0ff614beaec3949dbc673a45fce18e7bfaf7953e16b8298c406e5013949e268aeed343a2abb4ffc1e740937f40fc5c99313209688929a6fab1223ce62e924ec290c21702acc2627a1862098cf3eaed6ab08004eca7108b1b02fd6188e04353012a5eac7bf17547ffa761cb7430fec5d21d576bafa3aee71be6787d6d210a72cda07bf8fefbbd49c3326826836698ba003f3482005907d5fd7f4fc8d31ed92802b6ad28df0c174cdb525238dfe82cc324b628f3359ccb57f4024c06c17e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "579efb8aa51c50b13766d79a95712358ad522c2a1baa33b10df4b6817f8909e3d855b037f9f382a18aed61fa776ceb53dcb9bd2adfddb7b69e417e3ec6740b363852625ad0182e686274b3556c1fd71b3cb5df25c64ed23ce194f247022ac398408e804de1fe525046f6455c41122a3818f24b312c5db11714537f75d0f96d3c6ce02e379046a7878514157398153f9187dc5ef160e9f3572dd7abe016fc710ef0ab7670610305ec612f084026771e93274bed74cadeb5a6522076af6db38fd184c07c3721f281754119221cb49e1c35ad07838565f10f234e05bae1d88f66d8e9ab5e51d838a151" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a857f1dae5f4e7fc5b8035e82a3df1735dc0eb001c70da569d93e85efcb3ee64bb58c553770ae07c9fd6bbc5cbc8b6743b7587f1a75d277eed7599f946d94944aa668568dcb42fec6a3a7144f52c89731996207664ec0bd7aa0aae2dec262bbb3a3f4edc902619e5e5e24656f98d5dec3b9ac6937b3a27a913e43782dddfa351dc863b9b72465f653f59e1cc2cf32e04ead53cd231ec6f00603517b191bdc3434b989ff9d8e83f4ecd0bd1a145593e245b8fff15bdbfdcbbd7e1696d28df5ac6d285bff0eac38bb5342dd7ceb630e4f238019ca1235e13b8cef8f03b0945a3b1f777cef905b15a1087" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e0bdc65893480aab82ac4665e5e732a634619d7cb68fe5cfc25a4726c15ca1fd604d45aff79387153e8466f724c902c2a1ada5c53d61daca9320722c47342fef394645b5b8631dbf45046afd67b682ffca139ccf97f1f94dc0ee90155c4eed46dc42e658b105d592d0a70eb43a68a0dd9f3b8eb6609355c8169cfa483956afa46ff9ea55eaf0e66a7c36ca0d19d6986175c034d4105976580ff9d9d4959d00025b5978ae7c76fde710f7d8c9161befb62f40179be1d072f43610709af18f472798e96586a11dea0b1e37ecb4254d9b0b376916ec412f5668e93f332f8a1ef883f57f2fec44ada795286a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "bc9fb80a5685dde8244f6f552a32794a8fe86ac9a3822fcc753484726513c7e129c5794b1055e1202f1cd91ebc5ee789d131c532c9efd2248beeea52cbe0eb96287a6e3a4a8b763afb37f3176e11e2c4fd9c593c3246f51bb5092f94e7d6d63b5ba5942dda975c01c3b4990a11a8571ce3494809584605d4b9d06b45d1a9604616b10477caa617542c6a89f1e8a155a1ba4b0e31c63497a8fd48ed62b47ea098f4850b9d386a2a0de0a1d793d20e720c4e1d63ab2e19133bcb2a379ca830bea32ac8103eb9105207eb10c812c0fe3dee657a357ecb13e405cb23bfbad572bee5ca80fb5bc4b315c3821b28" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f9ae35ffbbb49c533eb324cd02252de0aedaa3748c4c8884c389ca6abae2e953e405212dd687237efc676f7a000235fb13d604e0481617839493bd10a2ccac9c7d8d11186dd33134a41da716ee7a4a7e5085e48fea22b9b753709b9d86d264a521978955b2e4836573859f7124d6c9d89107f55914f33cd009fef23fd8f28c85fc53d6a7ff331ab2df6899ea0565ae4fe2f0168830ff1c20f39f994f37a857d502002b1239f7809b117856bfb92eaff2e4d8c05c718fde83825431003c5c11e661ae40b516289e3e347957669a7f20ddc665dc3bcab5bd42f2e03bca3511d83519f4a6cdb8c67e0f33b12dfd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "664950c1caf4e5737671bb02158b45a938ba5aca3f7c153b64ef531c1d7e9e79bf78678abc9480046286cbf03bcea3db6de2cc5663193198e8dfa9907f7712892fc522ba644d46bd956bd8a8ce8a2d35266ef237e6c1a9fd0ec6e5c5ceccd7f726e4dad639eaa21cb475e9765671cf041f45b88840d60b22c1537112c72471f4d2430b6ace85ae80eaf4da52fb2ae1ad15ba2c5e7754da94de5b00f6aab061c1d96a7a524ffbc1ea526d3d1744d4682985e8a1427c72f90aee27505c73ae7e378e371c6000c4602007c2fc3be33936b15483a60e0838aea4834cf8d38325ad3430a1614d56ddb0370e8c8ef748" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3deef64b2abd079784b7dbaabe360aa3f6cb20763520eff7069ec1704c9789beea0fe3390ba5af842abde876b371d43a94771b513a081099e136d32f4f8a88f4c9630db04f05ae6019b814489a5ecb7ace0c25476ae1decd59c6dda06de38e3e06347cd2294aeaaf941f0e030a895c2f2b2bc88e2ca698dcf6b6f18f24479e383a36caa47224719e581a20002bf2a21d8650f031f7dd1870c3153693b624608069f30a0ba6cf5a9a1eb712d92bb97ad3a3327a41069e23a7445c02d6de1e46b35b4a8a44134ee19886afbef0a4834f7a7fda53c1f784aee2ffaeecd86e7df02be15b62ea204aa3a082637c4ea34a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "fa80ca58dee32b10b4282f576ac3f88ea89530aa712ca01a708761cfbe2a14de2fb4d5ffcc486ffab600ef97e79e4d734337b637947d04f1aa87e60020be8a26937d0e701b39c2ef09b54cc1fc784931bcc5d6b58b01bf8f636c6d40545ef5a7a5aff122f21d72e40fa1b3bea67c5a6c27127c55ccf61b601f4d59438a453c6e8ef9f1904e5c209556c085393c4ea7152412090961dc0f406dd7c008d00c8bac435b6f77ce8f26240d3ca3653d86a542240b34209ae9ab87086a539a10f9fa5551b9d13ed9501877faa3708219a2b0b2678ec57bb1ad31a8d0462ee7b2cc38f2644969b742c0da8aefe33c5185e088" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "d87dc4024a0266375b6e4ba966765b1f98a02c0b14ae969d3a00bcbcc2c1b741dc96035fddc310d2b2f801e019252489084363589be8242dd4c5454cfec5cd68858d519d9f1a2660d522a399638a3dce554fbb3b9c5956f8046f7e2c488739f6fc399c208c8abb94bef1e057a4e64b8a2b4a1e71903a4ebb5540934919828696f09fe0a2bf4560d9206f7bf7d5e78ac1ccf8e4650d05cffb71b20725249f82b62f94730e854c2e50cdab1bda0888ca1137b4bc32a7b469191ea7ee33a329fc5cef8c096934ccd6142f109163b4efb93f12e85307da35eb6562ef110d4eedd0baa1ed720aa77c2dafccb1a33c6f5d8a23" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c0ce6af7494dff967497d120cf99bc0fdabdd04831ba57bd6fa5d7f5d1378b1fad4aa0c5638b3aeb34730aa782515e9a720ba112933adeeed13f5407959bad9715057001402327698a8512af562b75bb70e0f9883df3726407edf3a6cfdd410718ed739969ddafa6b4e186b3ee77dbf47cad4ed5e7a458bb927b8efccdd63a5b2399e49926e68c6d4dafaa639354e0ba349187a0cf4f3e92774a33bf95878ac585fd72b5544ae54295a3a0d8fd0d063b0e6e77feb7deb3e617e263de65531d60d138eb2e54de5d50b12c47c23ba4bc91bc477556ac56b0706629a2a89657253ccd36746918be8d0b57b9e97c6146466554" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "6df5132e38e7c63b5e09d42239bf16f6a53187733ba07287b51f2362196dcd9347cf74d9f6be301ed993b63ceff5192e6f68966dee3277587bf4845bb345af7907217cfd0f3c99c34a0d8b723f8c70c5648b998e22ad0c4612b778235f757755b5fdc4f00684d5aed5c135fcf487f06cedf9f11934715b66589d6af2188a3b4e885d28e6f223f60d98817415a2d47607ed5d5b43a7559cb2bde1021f168a9d4a89d1cda0801e2c876e03208a841ed48ce86965b822039e99d56fa82d62bcd9f50deb810420e456e80f535be7baa5c1d3087f5145690a4dcf284a106ba6f5903fc0f1ecb57a7b81485710c82edf7090cf382a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "925437b13c121ef97e09a3ab9a90ccba96896302f81c52697109dfc0987eeef28b9f1062981c61076b7b2d028bb6547f50401c1268d192570bcd05d5003c9bcf3845995f195339696e010981afa1adbc79857df2f72757eb4c72dd61944b68cfd1805bc248ccef6a20874add8029a8b9768d632e74fd03698d959b71b3e9e801280c022ba6d1b193cad60227a22fada2a0ff5f00b673e866127cc2da1c355cf58093fcc65580d2f1795c2ecae21ac5f0bb5737d748dbe3f83d26bc5194b00a50250367fc687d813acb857acdd580aeef2637fa78c2a7ee2dd7543d4a40d37e49673aa073932dfb75e9d79c087fe757db4414d6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a840502c7c8a93e3a9722b1baa51b553df591b2091a842678e4c68e34c92afcb1099b3d3334e247aa2acc24e03a32b438dec4ffa644f114ff50e3683d695562754134c73ffe785f1a2c87591a50239402d6302c30c8365dd8f50dfeb5c2479f760eb119f31686e29ae973b46ce646463e1e56c0f8a6252b85d83bfd17fa22ce98a9dc2880db8fe277d6f92cd4cf7cf73cd930c9e33cf61395a36548b31ca1f8b27dd43100fe9df2884a7b384f14bf7ccb69e8a8b21884012058c11e3e1078727e452dbbc49c26db558c3d00032dffb21ae2841a186fc66d5bc5243ddad577727fbee6bf8c2d0af778773a1b5250e875483bca9c0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "8e474a9a84ca66665afbe283ea1dcc50e9a4e962a8c4a57aae5531047a062852db6b2a0622fb46cd62be1be9136a41834ce55ea5676142415b7c3ad60901a365df3197a375d9b2d78eaab078eaa1df2e0bce6e5f6c983a73f15d8275ebc31867a1b85abad097742e6213841ea0f2c96ca9860d73a4908b8544de88c82e12a32f38c8af1434c720a82dac08152ec7b3acae5482664a68ef92a5eb8e7c27a45f2750c0b4e7f057d6fb3bc36b07ea16735e12c14d0c1ba4dc5f6788428f036b4e5e4fe59766e80f864d11962f02805c0ddb7f9705faa0e2eae4d3c7f1b44af42baebe8b079bc063bfe14638a126926c9984210a2b932d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "c39669d1c430c3e2c1724f007eabc83ab5965414fbcb96c5496285529885cdc7fe1e499d7a10f697b7d6b1d96720481ef33758100b1237aab8d204cdfecfc3324ec5232c18c95e427a16ccfdd2755850f142e67f61b5cde4a4b17b2427ce216dd0021edb094c78321a6e73a120da59e11188064db3432b30942b5caf3d8692d4762fb64b0a725c097d747366cba193de4651e92de640911838c351a43e85a391d85638b38a85c7083ee02e41bded091399a77851ddd026ac2d8cf11f8b07883d238f7e1e19acb2ef215e1d4a033cca51d7d7ff132bb89cfcde2693b3a41efd5123a0f17a64d7e0a6d2e5b77283e99ab1c69fcc6d20e0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "7dbeac7fa7003c93db93ad5c10e1c5a7d1f3d25df52edc39192ad115a9aa142986803a35912edf5568ff4d35a8a68a2db44d5c2ae93c7239198c642dc0732e28f703dbdf4b586a3ad2db363fe17c27c77e08344cd8fa36db95665ca974b5a0613f3eb584eb6b371ef1432d39edbed3ef88104d0664a006b2b08ade648f90da57661b267ec637c147bdfec665bb05e01e4d607070b8eeddbfce52ab461b4a54d4c3c3eb33c6213eeb5581c7d752669d70ba1542c9f83a3e8e5445afc468306180268083aa7c0c471929dc70150d3886e2fdd8ffa1821f956b3eb1cb5d8870c36910bed17f32872a8c36e6df6a77d2b8ba67d0e367b71137" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "9e75cfd15638c15d60ea531b2806b51d3ae590e64d6aac611812992e870fba84f76c367f78c8b26de7033f87896468edc89d88a5ee582429548b620ec67388ee80888be6f513009777d9243dc6d71f3b3251418ff9d2aef57287d7e9d1a62437f54d39dec07aa36bb28ee45d3c7f050b8f9a3e37e233e3aa91711287510dd5111616c0fe19ce08390f6033408dfcc5ad37bb6af02e8ccf794e5609d5e16e971aa36e21304dfcdb4368131db4acf38f7c911368e4df2b42fb02068509e3a15b9d59b87292d684966e7492a1f46e2923a9a40324b0bec5f7d1751b41feb97def10447a278a062150bba4129e6ba7206bad86d4b6d7d98b06b7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "e6cd6a12f97317f3c1fc588b7a4f1afa8abde43821301514f2970b224af94a9032efa0c6f97a8434dd37bba19471faeaff3b8a8f9cb5a9acc71f00917563a8c835bb97e4fda77aa709a4e88937b852e957b01f0f2385b82db6327185a131efeca048f2a853ffe5b1cfc5310513efaef893f95360447acffc38cc409f7ab0485722aab359a37918c52019c86689dbb9a4f0f38c9917d76b22910ed656ffee07acefb88ec7f0809e7f0203fd3cd4a1e7527cce0c029b7c80852b86455cb9d87a6f0878f08b0d001afba2768f33334d81be572503b1cc3a0af7807ec41a4dfaad3a50fc96476af744cd7c49d919454c187d156799e583a8c74d03" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "02608e76c626822f416e6deb6056eba09a6898fd696174e39620d960e47b78de1fc006d8130521843c8f3e610a6295fe15950c8974b2f7b18f3850a257eae17269a0268ce18b321f480d96e2750e923bd32d6c05fafb4ed3eb49d45c02f2c5358baa0411743c96285bee23da543dd8e21ac15326f9d9eabd3c3feb98d91cc99c0322d52622321946a688e28180c1212e75461d205eaa0080ca2667c670747f8bb5b18ceaadcb4fbcf5ad8be2878030b510c6fcd564c848bb08b5b877da740e684d9d52654324067c8a32f90c8ef40a9ad0067b183d1c18f93d5437f08bf03e4a04cebdbf8a075e88ce8b95669b71dff7e40d384d20d1c06a31af" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "2f4119c21c013098b20b8dbd84b47fd5011c72df62b939746b7c8d496ab4173cdd2d8ff9952619fbcc86d1ef2777f17638de90c1644b17e27d7ed97da0074a2f530b2441eb6d0eb56eb46ce882105bf2ae3d956c4d7e5be803c5dab0ce7c55548306cb9105ab5d098288d8aeedc03cca581721ef1cab2e04e315cd7f8bddae7c9ac4afa865a15bbf558b8f4205a6fdf405d021b67a0326efda528149b1729c26b3b4d3869425f324b5f0865a6be0ed9dd04893f1fa2da06b0e5665fc317e89b47cb71fe6e673878ae4839fbbdb26fae94cf37583985b642186afafa3c896c55e9284ee2b7e5fde9596c42d5136a5024ce6f0c6ba5fed11928ef0ad" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "a270cd89ec091f4862974d10dca5a283b8c332f7b4a99527ad63fb86e1d4b64edc1281e5278d000c9c6f1bb5fca1d687f689ec64ab32d61b3f47a23c98ef70718cc1510b4785c2b56e3b619b3e5c184628e0c96255257b345a6c42a589fa245e2fdbd7819b8f0460fc371d683c37a468a5eb61bfd5338fdedb66d70ac110949a19b9e417b60d6fdf511eb41737c35ae15975f5a98125198f53214375ae8361f2d1a4d9df67c21067a676301a040e2ff99b7f9f4b7f27a5a2db82c56f8fdb366aeb3deaeff45d163c859ee2d60f11a16193a3b81f51ab9c268d53883c166fbf2af91f34735b170278a8d594c4489ef6fc530e2faa10e78c90274084b5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "3e4cc5a816a4eb2e2c4a7fa626ed70a7dd08bc3d8b3fe70ed007c76db3fc62be345d00107519a2f16c31479b9ab74553169b8a6a54c3e1bf5c142a946cba2d1cff48bfb4c4896209514a349c6367df2ade1d6b5848a4aad085db2e48ca933f9217a11ffd55f1addc12f20abfbd71382836df2283e739bd003031acafb7331fbe4baef9a166f45f504f6aae650e29733a3b8f15cf39c99506cfd1bf2bd7a70ad600fd27bf34a18a8b94be6e7ccd0d92fc004de9d3f06268878ff7af6c796d350388d28760e9930a8de562d4a99f5c7446520a186337389f3763305209212571f573d0cb26ab0cbddb0b09eec2112feffcde44dcc641d2396dbd1a31d965" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "f34675a5f4c344c1616dfffbe5ed963b6308a5409b7d0106a2a733117f9ad88923d33478d4d0f52058f03bf7c2da3f26221cc0495fe9edb16bd32682965f992d7e9a14daae5cd44f29d4dd92d0b4f1a893394c659c2a755231ab20e59a31aec6451d3b301d6e7a41027fb8a2520177094b7422575803e72e647de294a04c4f34f8e487036de84679f3c5f915608cfd15d565e24b8ae27acefcbf54b033a83882745f6418a217ccd0f8ae4e10ff04e67f57b36d94dcd5b442f6e36e452ffbf6ec7ba6490e079419252d54ab64c5afdde196d0b5c352ad70ce39b16791cccbb33d498d5a7ffd2ae2174b34b23f78e8972a5fa04f7ebe66203d681bb163aa18" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "65caea398636380c6955c7549491c91157776fa1a6514355837e51fc6bbc35b7bb8b44fe019c1be93ce474e810305e36e5cd445b417001cb2b8bba78af6fdc1c12b83e326a5d323752930c5fe879629d5f5772f872b3db4ddb1cbf43ef3115e344327b3dcba6a7d8c82511c74a70b12b405481e66dbd1b8a7a9cdab1d52bdcde972aba064915ceee02e7901e757d1470fabc32f9ab873508c6e243b956cac2d63aeb32b179f2cfab3cb4c2345dfb6a18c05b97f9e659c0020de22f85b5ceef470a5ad6e8597c8570a85be25d48d60151577f9a4fbe2c09862dd57ff734e156f66fd7107ccfe0e46193d2272ce6d6c0dfc0a81cef52cbd61d2964aea53922bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "", + "out": "59f8eea01a07a2670f2fe464bd755d8cde620cb4bac6006556a8663d2d9625c62fe63b6b68adba279ab287c04d3de6c4c17e6428dff30e9b2524fea1e869e42485c03a9f48af40d12d5cba0d13abac272ee36efeb8bd098ce0e1da8233ef6e6b3e96c9e05a7fedb79ae44e698640e6b8f26c43674e2c32ef17b4d7b005554ec4fd8aa1dac0f975fc888bec5bd7a06fbf29ae09f2d37c5eb7d0f67c9c77d5caf7afe681ae336fb3fccd97ecdec0348cdea4787a4e9de4df4bbfb209eeb642ce8f92730d598a71c94259e648d0a4dd89079a06c4b463ba1d175476337d553b0401d2b6f0c32639e3edcdd8c225c61e0afa5cd103b5d26a56afe3ac9462df794dc0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "64" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f457" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e8c045" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a74c6d0d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eb02ae482a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "be65b981275e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8540ccd083a455" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "074a02fa58d7c7c0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "da6da05e10db3022b6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "542a5aae2f28f2c3b68c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ca3af2afc4afe891da78b1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e0f66b8dcebf4edc85f12c85" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "744224d383733b3fa2c53bfcf5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b09b653e85b72ef5cdf8fcfa95f3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dd51877f31f1cf7b9f68bbb09064a3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f5ebf68e7ebed6ad445ffc0c47e82650" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ebdcfe03bcb7e21a9091202c5938c0a1bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "860fa5a72ff92efafc48a89df1632a4e2809" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0d6d49daa26ae2818041108df3ce0a4db48c8d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e5d7e1bc5715f5ae991e4043e39533af5d53e47f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5232028a43b9d4dfa7f37439b49495926481ab8a29" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c118803c922f9ae2397fb676a2ab7603dd9c29c21fe4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2af924f48b9bd7076bfd68794bba6402e2a7ae048de3ea" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "61255ac38231087c79ea1a0fa14538c26be1c851b6f318c0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f9712b8e42f0532162822f142cb946c40369f2f0e77b6b186e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "76da0b89558df66f9b1e66a61d1e795b178ce77a359087793ff2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9036fd1eb32061bdecebc4a32aa524b343b8098a16768ee774d93c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f4ce5a05934e125d159678bea521f585574bcf9572629f155f63efcc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5e1c0d9fae56393445d3024d6b82692d1339f7b5936f68b062c691d3bf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "538e35f3e11111d7c4bab69f83b30ade4f67addf1f45cdd2ac74bf299509" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "17572c4dcbb17faf8785f3bba9f6903895394352eae79b01ebd758377694cc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "29f6bb55de7f8868e053176c878c9fe6c2055c4c5413b51ab0386c277fdbac75" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bad026c8b2bd3d294907f2280a7145253ec2117d76e3800357be6d431b16366e41" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "386b7cb6e0fd4b27783125cbe80065af8eb9981fafc3ed18d8120863d972fa7427d9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "06e8e6e26e756fff0b83b226dce974c21f970e44fb5b3e5bbada6e4b12f81cca666f48" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2f9bd300244f5bc093ba6dcdb4a89fa29da22b1de9d2c9762af919b5fedf6998fbda305b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cf6bdcc46d788074511f9e8f0a4b86704365b2d3f98340b8db53920c385b959a38c8869ae7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1171e603e5cdeb4cda8fd7890222dd8390ede87b6f3284cac0f0d832d8250c9200715af7913d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "bda7b2ad5d02bd35ffb009bdd72b7d7bc9c28b3a32f32b0ba31d6cbd3ee87c60b7b98c03404621" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2001455324e748503aa08eff2fb2e52ae0170e81a6e9368ada054a36ca340fb779393fb045ac72b3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "45f0761aefafbf87a68f9f1f801148d9bba52616ad5ee8e8ac9207e9846a782f487d5cca8b20355a18" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3a7e05708be62f087f17b41ac9f20e4ef8115c5ab6d08e84d46af8c273fb46d3ce1aabebae5eea14e018" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ea318da9d042ca337ccdfb2bee3e96ecb8f907876c8d143e8e44569178353c2e593e4a82c265931ba1dd79" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e0f7c08f5bd712f87094b04528fadb283d83c9ceb82a3e39ec31c19a42a1a1c3bee5613b5640abe069b0d690" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d35e63fb1f3f52ab8f7c6cd7c8247e9799042e53922fbaea808ab979fa0c096588cfea3009181d2f93002dfc11" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b8b0ab69e3ae55a8699eb481dd665b6a2424c89bc6b7cca02d15fdf1b9854139cab49d34de498b50b2c7e8b910cf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fb65e3222a2950eae1701d4cdd4736266f65bf2c0d2e77968996eadb60ef74fb786f6234973a2524bdfe32d100aa0e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f28b4bb3a2e2c4d5c01a23ff134558559a2d3d704b75402983ee4e0f71d273ae056842c4153b18ee5c47e2bfa54313d4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7bb78794e58a53c3e4b1aeb161e756af051583d14e0a5a3205e094b7c9a8cf62d098fa9ea1db12f330a51ab9852c17f983" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a879a8ebae4d0987789bcc58ec3448e35ba1fa1ee58c668d8295aba4eaeaf2762b053a677e25404f635a53037996974d418a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "695865b353ec701ecc1cb38f3154489eed0d39829fc192bb68db286d20fa0a64235cde5639137819f7e99f86bd89afcef84a0f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a6ec25f369f71176952fb9b33305dc768589a6070463ee4c35996e1ced4964a865a5c3dc8f0d809eab71366450de702318e4834d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "604749f7bfadb069a036409ffac5ba291fa05be8cba2f141554132f56d9bcb88d1ce12f2004cd3ade1aa66a26e6ef64e327514096d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "daf9fa7dc2464a899533594e7916fc9bc585bd29dd60c930f3bfa78bc47f6c8439448043a45119fc9228c15bce5fd24f46baf9de736b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "943ea5647a8666763084da6a6f15dcf0e8dc24f27fd0d9194805d25180fe3a6d98f4b2b5e0d6a04e9b41869817030f16ae975dd41fc35c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "af4f73cbfc093760dfeb52d57ef45207bbd1a515f5523404e5d95a73c237d97ae65bd195b472de6d514c2c448b12fafc282166da132258e9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "605f4ed72ed7f5046a342fe4cf6808100d4632e610d59f7ebb016e367d0ff0a95cf45b02c727ba71f147e95212f52046804d376c918cadd260" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3750d8ab0a6b13f78e51d321dfd1aa801680e958de45b7b977d05732ee39f856b27cb2bcce8fbf3db6666d35e21244c2881fdcc27fbfea6b1672" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8f1b929e80ab752b58abe9731b7b34eb61369536995abef1c0980d93903c1880da3637d367456895f0cb4769d6de3a979e38ed6f5f6ac4d48e9b32" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d8469b7aa538b36cdc711a591d60dafecca22bd421973a70e2deef72f69d8014a6f0064eabfbebf5383cbb90f452c6e113d2110e4b1092c54a38b857" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7d1f1ad2029f4880e1898af8289c23bc933a40863cc4ab697fead79c58b6b8e25b68cf5324579b0fe879fe7a12e6d03907f0140dfe7b29d33d6109ecf1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "87a77aca6d551642288a0dff66078225ae39d288801607429d6725ca949eed7a6f199dd8a65523b4ee7cfa4187400e96597bfffc3e38ade0ae0ab88536a9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e101f43179d8e8546e5ce6a96d7556b7e6b9d4a7d00e7aade5579d085d527ce34a9329551ebcaf6ba946949bbe38e30a62ae344c1950b4bde55306b3bac432" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4324561d76c370ef35ac36a4adf8f3773a50d86504bd284f71f7ce9e2bc4c1f1d34a7fb2d67561d101955d448b67577eb30dfee96a95c7f921ef53e20be8bc44" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "78f0ed6e220b3da3cc9381563b2f72c8dc830cb0f39a48c6ae479a6a78dcfa94002631dec467e9e9b47cc8f0887eb680e340aec3ec009d4a33d241533c76c8ca8c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9f6589c31a472e0a736f4eb22b6c70a9d332cc15304ccb66a6b97cd051b6ed82f8990e1d9bee2e4bb1c3c45e550ae0e7b96e93ae23f2fb8f63b309131e72b36cba6a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c138077ee4ed3d7ffa85ba851dfdf6e9843fc1dc00889d117237bfaad9aa757192f73556b959f98e6d24886ce48869f2a01a48c371785f12b6484eb2078f08c22066e1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f83e7c9e0954a500576ea1fc90a3db2cbd7994eaef647dab5b34e88ab9dc0b47addbc807b21c8e6dd3d0bd357f008471d4f3e0abb18450e1d4919e03a34545b9643f870e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3277a11f2628544fc66f50428f1ad56bcba6ee36ba2ca6ecdf7e255effc0c30235c039d13e01f04cf1efe95b5c2033ab72adda30994b62f2851d17c9920eadca9a251752dc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c2a834281a06fe7b730d3a03f90761daf02714c066e33fc07e1f59ac801ec2f4433486b5a2da8faa51a0cf3c34e29b2960cd0013378938dbd47c3a3d12d70db01d7d06c3e91e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "47680182924a51cabe142a6175c9253e8ba7ea579ece8d9bcb78b1e9ca00db844fa08abcf41702bd758ee2c608d9612fed50e85854469cb4ef3038acf1e35b6ba4390561d8ae82" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cec45830cd71869e83b109a99a3cd7d935f83a95de7c582f3adbd34e4938fa2f3f922f52f14f169c38cc6618d3f306a8a4d607b345b8a9c48017136fbf825aecf7b620e85f837fae" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "46fb53c70ab105079d5d78dc60eaa30d938f26e4d0b9df122e21ec85deda94744c1daf8038b8a6652d1ff3e7e15376f5abd30e564784a999f665078340d66b0e939e0c2ef03f9c08bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7b0dcb52791a170cc52f2e8b95d8956f325c3751d3ef3b2b83b41d82d4496b46228a750d02b71a96012e56b0720949ca77dc68be9b1ef1ad6d6a5ceb86bf565cb972279039e209dddcdc" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7153fd43e6b05f5e1a4401e0fef954a737ed142ec2f60bc4daeef9ce73ea1b40a0fcaf1a1e03a3513f930dd5335723632f59f7297fe3a98b68e125eadf478eb045ed9fc4ee566d13f537f5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c7f569c79c801dab50e9d9ca6542f25774b3841e49c83efe0b89109f569509ce7887bc0d2b57b50320eb81fab9017f16c4c870e59edb6c26620d93748500231d70a36f48a7c60747ca2d5986" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0a81e0c547648595adca65623ce783411aac7f7d30c3ad269efafab288e7186f6895261972f5137877669c550f34f5128850ebb50e1884814ea1055ee29a866afd04b2087abed02d9592573428" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6a7b6769e1f1c95314b0c7fe77013567891bd23416374f23e4f43e27bc4c55cfada13b53b1581948e07fb96a50676baa2756db0988077b0f27d36ac088e0ff0fe72eda1e8eb4b8facff3218d9af0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a399474595cb1ccab6107f18e80f03b1707745c7bf769fc9f260094dc9f8bc6fe09271cb0b131ebb2acd073de4a6521c8368e664278be86be216d1622393f23435fae4fbc6a2e7c961282a777c2d75" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4f0fc590b2755a515ae6b46e9628092369d9c8e589e3239320639aa8f7aa44f8111c7c4b3fdbe6e55e036fbf5ebc9c0aa87a4e66851c11e86f6cbf0bd9eb1c98a378c7a7d3af900f55ee108b59bc9e5c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ed96a046f08dd675107331d267379c6fce3c352a9f8d7b243008a74cb4e9410836afaabe871dab6038ca94ce5f6d41fa922ce08aba58169f94cfc86d9f688f396abd24c11a6a9b0830572105a477c33e92" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "379955f539abf0eb2972ee99ed9546c4bbee363403991833005dc27904c271ef22a799bc32cb39f08d2e4ba6717d55153feb692d7c5efae70890bf29d96df02333c7b05ccc314e4835b018fec9141a82c745" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e16cc8d41b96547ede0d0cf4d908c5fa393399daa4a9696e76a4c1f6a2a9fef70f17fb53551a8145ed88f18db8fe780a079d94732437023f7c1d1849ef69ad536a76204239e8ba5d97e507c36c7d042f87fe0e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a81de50750ece3f84536728f227208bf01ec5b7721579d007de72c88ee20663318332efe5bc7c09ad1fa8342be51f0609046ccf760a7957a7d8dc88941adb93666a4521ebe76618e5ddc2dd3261493d400b50073" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b72c5fb7c7f60d243928fa41a2d711157b96aef290185c64b4de3dcfa3d644da67a8f37c2ac55caad79ec695a473e8b481f658c497edb8a191526592b11a412282d2a4010c90ef4647bd6ce745ebc9244a71d4876b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9550703877079c90e200e830f277b605624954c549e729c359ee01ee2b07741ecc4255cb37f96682dafcdbaade1063e2c5ccbd1918fb669926a67744101fb6de3ac016be4c74165a1e5a696b704ba2ebf4a953d44b95" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a17eb44d4de502dc04a80d5a5e9507d17f27c96467f24c79b06bc98a4c410741d4ac2db98ec02c2a976d788531f1a4451b6c6204cef6dae1b6ebbcd0bde23e6fffb02754043c8fd3c783d90a670b16879ce68b5554fe1c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "41d3ea1eaba5be4a206732dbb5b70b79b66a6e5908795ad4fb7cf9e67efb13f06fef8f90acb080ce082aadec6a1b543af759ab63fa6f1d3941186482b0c2b312f1151ea8386253a13ed3708093279b8eb04185636488b226" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5e7cdd8373dc42a243c96013cd29df9283b5f28bb50453a903c85e2ce57f35861bf93f03029072b70dac0804e7d51fd0c578c8d9fa619f1e9ce3d8044f65d55634dba611280c1d5cfb59c836a595c803124f696b07ddfac718" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "26a14c4aa168907cb5de0d12a82e1373a128fb21f2ed11feba108b1bebce934ad63ed89f4ed7ea5e0bc8846e4fc10142f82de0bebd39d68f7874f615c3a9c896bab34190e85df05aaa316e14820b5e478d838fa89dfc94a7fc1e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0211dfc3c35881adc170e4ba6daab1b702dff88933db9a6829a76b8f4a7c2a6d658117132a974f0a0b3a38ceea1efc2488da21905345909e1d859921dc2b5054f09bce8eeb91fa2fc6d048ce00b9cd655e6aafbdaa3a2f19270a16" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ddf015b01b68c4f5f72c3145d54049867d99ee6bef24282abf0eecdb506e295bacf8f23ffa65a4cd891f76a046b9dd82cae43a8d01e18a8dff3b50aeb92672be69d7c087ec1fa2d3b2a39196ea5b49b7baede37a586fea71aded587f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6ee721f71ca4dd5c9ce7873c5c04c6ce76a2c824b984251c15535afc96adc9a4d48ca314bfeb6b8ee65092f14cf2a7ca9614e1dcf24c2a7f0f0c11207d3d8aed4af92873b56e8b9ba2fbd659c3f4ca90fa24f113f74a37181bf0fdf758" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "689bd150e65ac123612524f720f54def78c095eaab8a87b8bcc72b443408e3227f5c8e2bd5af9bcac684d497bc3e41b7a022c28fb5458b95e8dfa2e8caccde0492936ff1902476bb7b4ef2125b19aca2cd3384d922d9f36dddbcd96ae0d6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3a3c0ef066fa4390ec76ad6be1dc9c31ddf45fef43fbfa1f49b439caa2eb9f3042253a9853e96a9cf86b4f873785a5d2c5d3b05f6501bc876e09031188e05f48937bf3c9b667d14800db62437590b84ce96aa70bb5141ee2ea41b55a6fd944" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "741ce384e5e0edaebb136701ce38b3d33215415197758ae81235307a4115777d4dab23891db530c6d28f63a957428391421f742789a0e04c99c828373d9903b64dd57f26b3a38b67df829ae243feef731ead0abfca049924667fdec49d40f665" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a513f450d66cd5a48a115aee862c65b26e836f35a5eb6894a80519e2cd96cc4cad8ed7eb922b4fc9bbc55c973089d627b1da9c3a95f6c019ef1d47143cc545b15e4244424be28199c51a5efc7234dcd94e72d229897c392af85f523c2633427825" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "71f1554d2d49bb7bd9e62e71fa049fb54a2c097032f61ebda669b3e1d4593962e47fc62a0ab5d85706aebd6a2f9a192c88aa1ee2f6a46710cf4af6d3c25b7e68ad5c3db23ac009c8f13625ff85dc8e50a9a1b2682d3329330b973ec8cbb7bb73b2bd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "167cc1067bc08a8d2c1a0c10041ebe1fc327b37043f6bd8f1c63569e9d36ded58519e66b162f34b6d8f1107ef1e3de199d97b36b44141a1fc4f49b883f40507ff11f909a017869dc8a2357fc7336ae68703d25f75710b0ff5f9765321c0fa53a51675c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cb859b35dc70e264efaad2a809fea1e71cd4a3f924be3b5a13f8687a1166b538c40b2ad51d5c3e47b0de482497382673140f547068ff0b3b0fb7501209e1bf36082509ae85f60bb98fd02ac50d883a1a8daa704952d83c1f6da60c9624bc7c99912930bf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "afb1f0c6b7125b04fa2578dd40f60cb411b35ebc7026c702e25b3f0ae3d4695d44cfdf37cb755691dd9c365edadf21ee44245620e6a24d4c2497135b37cd7ac67e3bd0aaee9f63f107746f9b88859ea902bc7d6895406aa2161f480cad56327d0a5bba2836" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "13e9c0522587460d90c7cb354604de8f1bf850e75b4b176bda92862d35ec810861f7d5e7ff6ba9302f2c2c8642ff8b7776a2f53665790f570fcef3cac069a90d50db42227331c4affb33d6c040d75b9aeafc9086eb83ced38bb02c759e95ba08c92b17031288" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0549812d62d3ed497307673a4806a21060987a4dbbf43d352b9b170a29240954cf04bc3e1e250476e6800b79e843a8bd8253b7d743de01ab336e978d4bea384eaff700ce020691647411b10a60acacb6f8837fb08ad666b8dcc9eaa87ccb42aef6914a3f3bc30a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3a263efbe1f2d463f20526e1d0fd735035fd3f808925f058b32c4d8788aeeab9b8ce233b3c34894731cd73361f465bd350395aebcabd2fb63010298ca025d849c1fa3cd573309b74d7f824bbfe383f09db24bcc565f636b877333206a6ad70815c3bef5574c5fc1c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3c6a7d8a84ef7e3eaa812fc1eb8e85105467230d2c9e4562edbfd808f4d1ac15d16b786cc6a02959c2bc17149c2ce74c6f85ee5ef22a8a96b9be1f197cffd214c1ab02a06a9227f37cd432579f8c28ff2b5ac91cca8ffe6240932739d56788c354e92c591e1dd76499" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b571859294b02af17541a0b5e899a5f67d6f5e36d38255bc417486e69240db56b09cf2607fbf4f95d085a779358a8a8b41f36503438c1860c8f361ce0f2783a08b21bd7232b50ca6d35428335272a5c05b436b2631d8d5c84d60e8040083768ce56a250727fb0579dd5c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "98ee1b7269d2a0dd490ca38d447279870ea55326571a1b430adbb2cf65c492131136f504145df3ab113a13abfb72c33663266b8bc9c458db4bf5d7ef03e1d3b8a99d5de0c024be8fabc8dc4f5dac82a0342d8ed65c329e7018d6997e69e29a01350516c86beaf153da65ac" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "41c5c95f088df320d35269e5bf86d10248f17aec6776f0fe653f1c356aae409788c938befeb67c86d1c8870e8099ca0ce61a80fbb5a6654c44529368f70fc9b9c2f912f5092047d0ffc339577d24142300e34948e086f62e23ecaca410d24f8a36b5c8c5a80e0926bc8aa16a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9f93c41f533b2a82a4df893c78faaaa793c1506974ba2a604cd33101713ca4adfd30819ffd8403402b8d40aff78106f3357f3e2c24312c0d3603a17184d7b999fc9908d14d50192aebabd90d05073da7af4be37dd3d81c90acc80e8333df546f17ab6874f1ec204392d1c0571e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3da5207245ac270a915fc91cdb314e5a2577c4f8e269c4e701f0d7493ba716de79935918b917a2bd5db98050dbd1eb3894b65fac5abf13e075abebc011e651c03cafb6127147771a5c8418223e1548137a89206635c26ca9c235ccc108dc25cf846e4732444bd0c2782b197b262b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "96011af3965bb941dc8f749932ea484eccb9ba94e34b39f24c1e80410f96ce1d4f6e0aa5be606def4f54301e930493d4b55d484d93ab9dd4dc2c9cfb79345363af31ad42f4bd1aa6c77b8afc9f0d551bef7570b13b927afe3e7ac4de7603a0876d5edb1ad9be05e9ee8b53941e8f59" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "51dbbf2a7ca224e524e3454fe82ddc901fafd2120fa8603bc343f129484e9600f688586e040566de0351d1693829045232d04ff31aa6b80125c763faab2a9b233313d931903dcfaba490538b06e4688a35886dc24cdd32a13875e6acf45454a8eb8a315ab95e608ad8b6a49aef0e299a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5a6a422529e22104681e8b18d64bc0463a45df19ae2633751c7aae412c250f8fb2cd5e1270d3d0cf009c8aa69688ccd4e2b6536f5747a5bc479b20c135bf4e89d33a26118705a614c6be7ecfe766932471ad4ba01c4f045b1abb5070f90ec78439a27a1788db9327d1c32f939e5fb1d5ba" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5d26c983642093cb12ff0afabd87b7c56e211d01844ad6da3f623b9f20a0c968034299f2a65e6673530c5980a532beb831c7d0697d12760445986681076dfb6fae5f3a4d8f17a0db5008ce8619f566d2cfe4cf2a6d6f9c3664e3a48564a351c0b3c945c5ee24587521e4112c57e318be1b6a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "52641dbc6e36be4d905d8d60311e303e8e859cc47901ce30d6f67f152343e3c4030e3a33463793c19effd81fb7c4d631a9479a7505a983a052b1e948ce093b30efa595fab3a00f4cef9a2f664ceeb07ec61719212d58966bca9f00a7d7a8cb4024cf6476bab7fbccee5fd4e7c3f5e2b2975aa2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a34ce135b37bf3db1c4aaa4878b4499bd2ee17b85578fcaf605d41e1826b45fdaa1b083d8235dc642787f11469a5493e36806504fe2a2063905e821475e2d5ee217057950370492f5024995e77b82aa51b4f5bd8ea24dc71e0a8a640b0592c0d80c24a726169cf0a10b40944747113d03b52708c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "46b3cdf4946e15a5334fc3244d6680f5fc132afa67bf43bfade23d0c9e0ec64e7dab76faaeca1870c05f96b7d019411d8b0873d9fed04fa5057c039d5949a4d592827f619471359d6171691cfa8a5d7cb07ef2804f6ccad4821c56d4988bea7765f660f09ef87405f0a80bcf8559efa111f2a0b419" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8b9fc21691477f11252fca050b121c5334eb4280aa11659e267297de1fec2b2294c7ccee9b59a149b9930b08bd320d3943130930a7d931b71d2f10234f4480c67f1de883d9894ada5ed5071660e221d78ae402f1f05af47761e13fec979f2671e3c63fb0ae7aa1327cf9b8313adab90794a52686bbc4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cd6598924ce847de7ff45b20ac940aa6292a8a99b56a74eddc24f2cfb45797188614a21d4e8867e23ff75afd7cd324248d58fcf1ddc73fbd115dfa8c09e62022fab540a59f87c989c12a86ded05130939f00cd2f3b512963dfe0289f0e54acad881c1027d2a0292138fdee902d67d9669c0ca1034a9456" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "594e1cd7337248704e691854af0fdb021067ddf7832b049ba7b684438c32b029eded2df2c89a6ff5f2f2c311522ae2dc6db5a815afc60637b15ec24ef9541f1550409db2a006da3affffe548a1eaee7bd114e9b805d0756c8e90c4dc33cb05226bc2b393b18d953f8730d4c7ae693159cdba758ad28964e2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1f0d292453f04406ada8be4c161b82e3cdd69099a8637659e0ee40b8f6da46005cfc6085db9804852decfbe9f7b4dda019a7112612895a144ed430a960c8b2f5458d3d56b7f427cee6358915aee7146278aed2a0296cdd929e4d21ef95a3adf8b7a6beba673cdccdbdcfb2474711732d972ad054b2dc64f38d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b65a72d4e1f9f9f75911cc46ad0806b9b18c87d105332a3fe183f45f063a746c892dc6c4b9181b1485b3e3a2cc3b453eba2d4c39d6905a774ed3fb755468beb190925ecd8e57ecb0d985125741650c6b6a1b2a3a50e93e3892c21d47ed5884eed83aa94e1602288f2f49fe286624de9d01fcb54433a0dc4ad70b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "705ce0ffa469250782aff725248fc88fe98eb76659e8407edc1c4842c9867d61fe64fb86f74e980598b92bc213d06f337bd5654fc28643c7ba769a4c31563427543c00808b627a19c90d86c322f33566ce020121cc322229c3337943d46f68ef939d613dcef0077269f88151d6398b6b009abb763410b154ad76a3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7fa881ce87498440ab6af13854f0d851a7e0404de33896999a9b3292a5d2f5b3ad033530c558168fe5d2fdb9b89a2354c46cf32a0e612afc6c6485d789511bfef26800c74bf1a4cfbe30bda310d5f6029c3dccdedb6149e4971274e276dccfabd63bc4b9955e8303feb57f8a688db55ecb4b33d1f9fe1b3a8ba7ac32" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "23a98f71c01c0408ae16843dc03be7db0aeaf055f951709d4e0dfdf64fffbffaf900ee592ee10929648e56f6c1e9f5be5793f7df66453eb56502c7c56c0f0c88da77abc8fa371e434104627ef7c663c49f40998dbad63fa6c7aa4fac17ae138d8bbe081f9bd168cd33c1fbc92fa35ed687679f48a64b87db1fe5bae675" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7b8970b6a33237e5a7bcb39272703edb92285c55842b30b9a48834b1b507cc02a6764739f2f7ee6ae02a7b715a1c455e59e8c77a1ae98abb10161853f1234d20da99016588cd8602d6b7ec7e177d4011edfa61e6b3766a3c6f8d6e9eac893c568903eb6e6aba9c4725774f6b4343b7acaa6c031593a36eef6c72806ff309" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f7f4d328ba108b7b1de4443e889a985ed52f485f3ca4e0c246aa5526590cbed344e9f4fe53e4eea0e761c82324649206ca8c2b45152157d4115e68c818644b03b65bb47ad79f94d37cb03c1d953b74c2b8adfa0e1c418bda9c518ddcd7050e0f149044740a2b16479413b63fc13c36144f80c73687513dca761ba8642a8ae0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2d7dc80c19a1d12d5fe3963569547a5d1d3e821e6f06c5d5e2c09401f946c9f7e13cd019f2f9a878b62dd850453b6294b99ccaa068e542993524b0f63832d48e865be31e8ec1ee103c718340c904b32efb69170b67f038d50a3252794b1b4076c0620621ab3d91215d55ffea99f23d54e161a90d8d4902fda5931d9f6a27146a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "77dff4c7ad30c954338c4b23639dae4b275086cbe654d401a2343528065e4c9f1f2eca22aa025d49ca823e76fdbb35df78b1e5075ff2c82b680bca385c6d57f7ea7d1030bb392527b25dd73e9eeff97bea397cf3b9dda0c817a9c870ed12c006cc054968c64000e0da874e9b7d7d621b0679866912243ea096c7b38a1344e98f74" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "83bed0d556798f2b419f7056e6d3ffada06e939b95a688d0ec8c6ac5ea45ab73a4cf01043e0a170766e21395f27ab4b78c435f5f0dfe6e93ab80df38610e41158429ddf20296f53a06a017723359fe22dc08b5da33f0800a4fe50118e8d7eab2f83a85cd764bf8a166903bd0e9dcfeeceba44ff4ca4439846458d31ea2bb564645d1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ea12cf5a113543e39504123036f15a5bafa9c555562469f99cd29996a4dfaaab2a34b00557ccf15f37fc0cc1b3be427e725f2cd952e50af7970dda9200cd5ce252b1f29c40067fea3027ed686190803b59d834179d1b8f5b55abe55ad174b2a1188f7753ec0ae2fc01316e7d498b68ee3598a0e9baaaa664a60f7fb4f90edbed494ad7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "55266358332d8d9e68bd13432088beadf95833aab67a0eb3b10650414255f299e2670c3e1a5b2976159a46c72a7ce57d59b7be14c15798e09ed50fa312a431b0264d7a1396aa6168bde897e208ece53d2cfc83786113b1e6eac5e9bb98984abb6c8d64eebb991903254abc650c999bb9958a5d7937434b869bc940e21b9dc1cc8982f2ba" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4d6104ded730aefe02873f4c741232c8234a6d66d85393aff57fbf56ba6347666988dfc4d58f3cc895a0da598822edeee4533d24ec0ee292fd5e1ad04898ffbc1ff4bef14dec220babcb0f28fffe32a6e2c28aaaac16442bf4feb02917d18bb3a415d84fa9358d5a9852688d846c92271911f934181c30f82434d915f93f155a1ffbf0b125" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eb5f579a4c476af554aac11e5719d378549497e613b35a929d6f36bb8831d7a466aa76de9be24ebb55543f1c13924f64cfd648a5b3fa90387315c16174dbf1e9a183c196d9bb8f84af65f1f8212429aadc11ef2426d07d4716062b85c8d5d2dff8e21b9e62b7fa7dbd57d72633054b464fb28583a56ca13ccc5ddc74dae942492f31731e7046" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ebddec3dcaf18063e45a76ebeac39af85a1adc2818881ccce48c106288f5988365cca2b4b1d7f037322da46840f42bebdcbc7193838d426e101087d8cea03aaff743d573eb4f4e9a71a2c884390769a6503874125d194bee8d46a3a0d5e4fcf28ff8465887d8e9df771d70157e75df3642b331d2778ceb32ceba868640171ab7a5d22eede1ee44" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "26d87ec70b57691e3bb359633d3ddba17f029d62cdfe977f5fd42274d79b444a32494d1c01e9f72d03cce78c806df96e93ea78da3a054209924ed765edc4d570f66168dc25ee3114e4017e387440349c8f0a94804761c3055f88e4fda2a49b860b1486a9609095f6250f268b6a4d1aecc03a505632ebf0b9dc22d0755a736faf7ad7000858b5864b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3880f5cc2d08fa70ef44b1f263fcf534d062a298c1bd5ee2eee8c3265806c4ce50b004f3a1fc1fa5b024aaac7f528c023c8181f67c6e1c357425dc4d573bd46b93a542afa3a19bdb140a2ce666e1a01f5c4d2dcd681fa9f5839b797813c394738d5ee4971386c12c7c117d17c7bec324b760aa30cda9ab2aa850284ba6fa97946f710f02449d1883c6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3317d2f452105dd3f4a96f9257af8285a80be58066b50f6f54bd633749b49f6ab9d57d45652d2ae852a2f6940cd5ec3159dd7f333358b12f502325df38843508faf7e246352d201280babd90b14fbf7722641c3601d0e458474439973c611bb5502fd0eb3078f87124ca7e1a016fcb6cfeff65f6a565985aca7122cfa8c5a11da0cb47797c5132333179" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f2c5c955d0224e784a46b9125f8fef8a5e1271e145eb08bbbd07ca8e1cfc848cef14fa3b36221ac62006403dbb7f7d77958ccc54a8566c837858b809f3e310ace8ca682515bc655d2a397cab238a663b464d511f02dc5d033dad4cb5e0e519e94a54b62a3896e460ec70e5716b5921bf8396aa86a60123e6287e34570bb01bdc602e113670bf498af2ff10" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "180e275205691a83630cf4b0c7b80e6df8fad6ef1c23ba8013d2f09aef7abade1827f23af230de90676240b4b3b0673f8afdea0327330055041741f65560d90348de696d34ca80dfe8afae582fe4879d4594b80e9408fb53e800e01ca58552b905c365e7f1416e51c080f517d6bbd30e64ae1535d59decdc76c6624d737868f49f2f719da39ba1344d59eab9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c517a84e4631a7f65ace170d1e5c2fdb259841535d88da323e68c0883e6af7b041cfe05908815a5a9d1b14fa712c2c16fadcf1ca54d3aa954d411240df331b2aebdfb65aced84d0b8aace56ec0aa7c13ec7d75ca883b6bcf6db74c9e98463c484a8262684f29910373430651f90ecffe18b072170e61ee58de20e2a6ff67b3ab00fccbb80af943f20b56b98107" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d1a56a5ee990e02b84b5862fde62f69ec07567be2d7ccb769a461c4989d11fdda6c945d942fb8b2da795ed97e43a5b7dbdde7f8fd2ff7154544336d5c50fb7380341e660d4898c7fbc39b2b782f28defac6873523c7c1de8e52c65e4395c686ba483c35a220b0416d46357a063fa4c33fa9c52d5c207a1304ae141c791e62ba6a7374ed922b8dd94079b72b69302" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4720b88d6bfb1ab43958e26827730d852d9ec30173ebd0fe0d273edcece2e788558984cd9306fe5978086a5cb6d37975755d2a3daeb16f99a8a11544b8247a8b7ed5587afc5bea1daf85dcea5703c5905cf56ae7cc76408ccabb8fcc25cacc5ff456db3f62fa559c45b9c71505eb5073df1f10fc4c9060843f0cd68bbb4e8edfb48d0fd81d9c21e53b28a2aae4f7ba" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f4639b511db9e092823d47d2947efacbaae0e5b912dec3b284d2350b9262f3a51796a0cd9f8bc5a65879d6578ec24a060e293100c2e12ad82d5b2a0e9d22965858030e7cdf2ab3562bfa8ac084c6e8237aa22f54b94c4e92d69f22169ced6c85a293f5e16bfc326153bf629cdd6393675c6627cd949cd367eef02e0f54779f4d5210197698e4754a5fe490a3a7521c1c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3d9e7a860a718565e3670c29079ce80e381969fea91017cfd5952e0d8a4a79bb08e2cd1e26161f30ee03a24891d1bfa8c212861b51618d07429fb48000ff87ef09c6fca526567777e9c076d58a642d5c521b1caa5fb0fb3a4b8982dc14a444732b72b239b8f01fc8ba8ee86b3013b5d3e98a92b2aeaecd4879fca5d5e9e0bd880dbfffa6f96f94f3998812aac6a714f331" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4d9bf551d7fd531e7482e2ec875c0651b0bcc6caa738f7497befd11e67ae0e036c9d7ae4301cc3c7906f0d0e1ed4738753f414f9b3cd9b8a71176e325c4c74ce020680ecbfb146889597f5b40487e93f974cd866817fb9fb24c7c7c16177e6e120bfe349e83aa82ba40e59e917565788658a2b254f25cf99bc65070b3794cea2259eb10e42bb54852cba3110baa773dcd70c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b91f65ab5bc059bfa5b43b6ebae243b1c46826f3da061338b5af02b2da76bb5ebad2b426de3c3134a633499c7c36a120369727cb48a0c6cbab0acecdda137057159aa117a5d687c4286868f561a272e0c18966b2fec3e55d75abea818ce2d339e26adc005c2658493fe06271ad0cc33fcb25065e6a2a286af45a518aee5e2532f81ec9256f93ff2d0d41c9b9a2efdb1a2af899" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "736f6e387acb9acbee026a6080f8a9eb8dbb5d7c54ac7053ce75dd184b2cb7b942e22a3497419ddb3a04cf9e4eb9340a1a6f9474c06ee1dcfc8513979fee1fc4768087617fd424f4d65f54782c787a1d2de6efc81534343e855f20b3f3589027a5436201eee747d45b9b8375e4294d72ab6a52e04dfbb2914db92ee58f134b026527ed52d4f794459e02a43a17b0d51ea69bd7f3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9242d3eb31d26d923b99d66954cfade94f25a18912e6356810b63b971ae74bb53bc58b3c01424208ea1e0b1499936daea27e63d904f9ed65fdf69de40780a3027b2e89d94bdf214f585472613ce328f628f4f0d56217dfb53db5f7a07f54c8d71db16e27de7cdb8d23988837b49b65c12f1771d979e8b192c9f4a16b8d9fba917bcf74ce5a82aac2075608ba6c2d485fa59864b9de" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5da68704f4b592d41f08aca08f62d85e2e2466e5f3be010315d11d113db674c4b98764a509a2f5aacc7ae72c9deff2bcc42810b47f64d429b35745b9efff0b18c58653461e968aaa3c2c7fc455bc5771a8f10cd184be831040df767201ab8d32cb9a58c89afbebecb524502c9b940c1b838f8361bbcde90d272715017f67609ea39b20fac985332d82daaa023999e3f8bfa5f3758bb8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "71ea2af9c8ac2e5ae44a176662882e01027ca3cdb41ec2c6785606a07d7231cd4a2bded7155c2feef3d44d8fd42afa73265cef826f6e03aa761c5c51d5b1f129ddc27503ff50d9c2d748322df4b13dd5cdc7d46381528ab22b79b0049011e4d2e57fe2735e0d58d8d56e92c75dbeac8c76c4239d7f3f24fb56697593b3e4afa6671d5bbc96c079a1c154fe20212ade67b05d49ceaa7a84" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1d133170582fa4bff59a21953ebbc01bc202d43cd79c083d1f5c02fa15a43a0f519e36acb710bdabac880f04bc003800641c2487930de9c03c0e0deb347fa815efca0a38c6c5de694db698743bc955581f6a945deec4ae988ef7cdf40498b77796ddea3fae0ea844891ab751c7ee20917c5a4af53cd4ebd82170078f41ada2795e6eea17593fa90cbf5290a1095e299fc7f507f360f187cd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5ec4ac45d48fc15c72471d795066bdf8e99a483d5fdd599511b9cdc408de7c0616491b73924d0266da34a495331a935c4b8884f57d7ad8cce4cbe586875aa52482215ed39d7626cce55d50349c7767981c8bd6890f132a196184247343566fc972b86fe3c5369d6a6519e9f07942f0522b77ad01c751dcf7defe31e471a0ec00963765dd8518144a3b8c3c978ad108056516a25dbe3092e73c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0d5e74b78290c689f2b3cfea45fc9b6a84c822639cd438a7f05c07c374adced42cdc12d2a9233a4ffe80307efc1ac13cb04300e165f8d90dd01c0ea955e7657332c6e86ad6b43e78ba4c13c675aed83192d8427866fb6484e6a3071b2369a46fba9005f31232da7ffec7952f831aaaddf63e225263531c2cf387f8cc14fa856c8795137142c3a52ffa69b8e30ebc88ce3bbc227597bcc8dddd89" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a0fe36f983259921dc2fa7d89002b3066241d63bfc2448caf7e10522a35562be0bfedc3dce49cfce2e614a04d4c64cfc0ab898873a7fc26928dc1927c009d12f6f9b7a278205d3d0057604f4ac746f8b9287c3bc6b929832bf253b6586192ac43fdd29ba585dbd9059aab9c6ff6000a7867c67fec1457b733f6b620881166b8fed92bc8d84f0426002e7be7fcd6ee0abf3755e2babfe5636ca0b37" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1d29b6d8eca793bb801becf90b7d7de215b17618ec32340da4bac707cdbb58b951d5036ec02e105d83b5960e2a72002d19b7fa8e1128cc7c5049ed1f76b82a59eac6ed09e56eb73d9ade38a6739f0e07155afa6ec0d9f5cf13c4b30f5f9a465b162a9c3ba04b5a0b3363c2a63f13f2a3b57c590ec6aa7f64f4dcf7f1582d0ca157eb3b3e53b20e306b1f24e9bda87397d413f01b453ceffeca1fb1e7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6a2860c110cd0fc5a19bcaafcd30762ee10242d34739638e716bd89fd537ea4dc630e6f85d1bd88a25ad3892ca554c232c9830bd56980c9f08d378d28f7fa6fa7df4fcbf6ad98b1adfff3ec1f63310e50f920c99a5200b8e64c2c2ca249399a149942261f737d5d72da949e914c024d57c4b639cb89990fed2b38a37e5bcd24d17ca12dfcd36ce04691fd03c32f6ed5de2a2191ed7c826375ba81f78d0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7132aa291ddc9210c60dbe7eb3c19f9053f2dd74742cf57fdc5df98312adbf4710a73245de4a0c3b24e21ab8b466a77ae29d15500d5142555ef3088cbccbe685ed9119a10755148f0b9f0dbcf02b2b9bcadc8517c88346ea4e78285e9cbab122f824cc18faf53b742a87c008bb6aa47eed8e1c8709b8c2b9adb4cc4f07fb423e5830a8e503ab4f7945a2a02ab0a019b65d4fd71dc364d07bdc6e637990e3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3e664da330f2c6007bff0d5101d88288aaacd3c07913c09e871cce16e55a39fde1ce4db6b8379977c46cce08983ca686778afe0a77a41baf447854b9aa286c398c2b83c95a127b053101b6799c1638e5efd67273b2618df6ec0b96d8d040e8c1ee01a99b9b5c8fe63fea2f749e6c90d31f6fae4e1469ac09884c4fe1a8539acb313f42c941224a0e79c059e18affc2bcb6724975c436f7bf949ebdd8aef51c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7a6ea63a271eb49470f5ce77519ed61ae9b2f1be07a96855726bc3df1d0723af3a703fdfc2e739c9d31d25814daf661a23558b50982e66ee37ad880f5c8f11c8130fac8a5d0250583700d5a324894fae6d61993f6bf9327214f8674649f355b23fd634940b2c467973a839e659169c773119919f5b81ee171edb2e5f6940d7551f9e5a70625d9ea88711ad0ed8ab2da720ad358bef954456cb2d5636425717c2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c5106bbda114168c449172e49590c7eeb827fa4e1a2a7a87a3c1f721a9047d0c0a50fbf244731be1b7eb1a2ef30f5ae846a9f38f0df44f32af61b68dbdcd0226e741dfb6ef81a2503691af5e4b3171f48c59ba4ef91eba344b5b697f261df7bbbb734ca6e6daebaa4a179feb17002823281b8534d55a6531c59305f6e3fd3fa63b747bcf0deb654c392a02fe687a269effb1238f38bcaea6b208b221c45fe7fbe7" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "597716a5ebeebc4bf524c15518816f0b5dcda39cc833c3d66b6368ce39f3fd02ceba8d12072bfe6137c68d3acd50c849873150928b320b4fbc31c1456679ea1d0acaeeabf666d1f1bad3e6b9312c5cbdecf9b799d3e30b0316bed5f41245107b693366accc8b2bcef2a6be54209ffabc0bb6f93377abdcd57d1b25a89e046f16d8fd00f99d1c0cd247aafa72234386ae484510c084ee609f08aad32a005a0a5710cb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0771ffe789f4135704b6970b617bae41666bc9a6939d47bd04282e140d5a861c44cf05e0aa57190f5b02e298f1431265a365d29e3127d6fccd86ec0df600e26bcdda2d8f487d2e4b38fbb20f1667591f9b5730930788f2691b9ee1564829d1ada15fffc53e785e0c5e5dd11705a5a71e390ca66f4a592785be188fefe89b4bd085b2024b22a210cb7f4a71c2ad215f082ec63746c7367c22aedb5601f513d9f1ffc1f3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "be6556c94313739c115895a7bad2b620c0708e24f0390daa55521c31d2c6782acf41156271238885c367a57c72b4fe999c160e804ad58d8e565edbce14a2dd90e443eb80626b3eab9d7ab75d6f8a062d7ca89b7af8eb292c98eaf87ad1dfd0db103d1bb6188bd7e7a63502153cf3ce23d43b60c5782602bac8ad92fb2324f5a79453898c5de18415639ecc5c7974d3077f76fc1df5b956723bb19a624d7ea3ec13ba3d86" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4bc33729f14cd2f1dc2ff459abee8f6860dda1062845e4adab78b53c835d106bdfa35dd9e77219eaef403d4e80488ca6bd1c93dd76ef9d543fbb7c8904dccc5f71509a6214f73d0f4e467c3e038ea639b29e7fc442ee29f57117740576188ada15a739827c647a46b0271817ab235c023c30c90f2115e5c90cd8501e7b286962fc66ffc3fe7e8978746168314908a41998bd83a1eeffda9d714b864f4d490fdeb9c7a6edfa" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ab12faea205b3d3a803cf6cb32b9698c32301a1e7f7c6c23a20174c95e98b7c3cfe93fffb3c970face8f5751312a261741141b948d777b8a2ea286fe69fc8ac84d34116a4674bb09a1a0b6af90a748e511749de4697908f4acb22be08e96ebc58ab1690acf73914286c198a2b57f1dd70ea8a52325d3045b8bdfe9a09792521526b7564a2a5fcd01e291f1f8894017ce7d3e8a5dba15332fb410fcfc8d62195a48a9e7c86fc4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7d421e59a567af70594757a49809a9c22e07fe14061090b9a041875bb77933deae36c823a9b47044fa0599187c75426b6b5ed94982ab1af7882d9e952eca399ee80a8903c4bc8ebe7a0fb035b6b26a2a013536e57fa9c94b16f8c2753c9dd79fb568f638966b06da81ce87cd77ac0793b7a36c45b8687c995bf4414d28289dbee977e77bf05d931b4feaa359a397ca41be529910077c8d498e0e8fb06e8e660cc6ebf07b77a02f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0c18ab727725d62fd3a2714b7185c09faca130438eff1675b38beca7f93a6962d7b98cb300ea33067a2035cdd694348784aa2eda2f16c731eca119a050d3b3ce7d5c0fd6c234354a1da98c0642451922f670984d035f8c6f35031d6188bbeb31a95e99e21b26f6eb5e2af3c7f8eea426357b3b5f83e0029f4c4732bca366c9aa625748297f039327c276cd8d9c9bf692a47af098aa50ca97b99961bef8bc2a7a802e0b8cfdb84319" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "92d5909d18a8b2b9971cd1627b461e98a74ba377186a6a9df5bd133635250b300abccb2254cacb775df6d99f7c7d0952653c28e6909b9f9a45adce691f7adc1afffcd9b06e49f775364cc2c62825b9c1a86089080e26b57e732aac98d80d009bfe50df01b95205aa07ed8ec5c873da3b92d00d53af825aa64b3c634c5ece40bff152c331222d3453fd92e0ca17cef19ecb96a6eed4961b627aca48b12fecd091754f770d52ba861546" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "802f22e4a388e874927fef24c797408254e03910bab5bf372320207f8067f2b1ea543917d4a27df89f5bf936ba12e04302bde23119533d0976beca9e20cc16b4dbf17a2ddc44b66aba76c61ad59d5e90de02a88327ead0a8b75463a1a68e307a6e2e53ecc1986274b9ee80bc9f3140671d5285bc5fb57b281042a8978a1175900c6073fd7bd740122956602c1aa773dd2896674d0a6beab24454b107f7c847acb31a0d332b4dfc5e3f2f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3844fe65db11c92fb90bf15e2e0cd216b5b5be91604baf3b84a0ca480e41ecfaca3709b32f8c6e8761406a635b88eec91e075c48799a16ca08f295d9766d74475c47f3f2a274eae8a6ee1d191a7f37ee413a4bf42cad52acd5564a651715ae42ac2cddd52f819c692ecdef52ecb763270322cdca7bd5aef71428fa73e844568b96b43c89bf1ed42a0abf209ffad0eeec286c6f141e8af073ba4adfbbdeda253752ae36c9957dfc905b4c49" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "329377f7bf3c8d74991a7d61b0cf39baff5d485d79751b0d5ad017d23bec570fb19810105bab79ab5acb102ab972165224d4ec888ec7de5148077fa9c1bb6820e0d91ae4e2591a21fec2f820606ce4bafc1e377f8dc3a5bd1a9e2772a57abccd0b757164d768872c91d02789545ab5b203f688d71dd08522a3fd2f5bcd7df507aebf1ca27ddff0a82afb7aa9c180008f49d1325adf97d047e77238fc75f56356de4e87d8c961575c9f6362c9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f7f269929b0d71ea8eef7120e55ccba691c582dd534692abef35c0fe9dec7dae973cd9702e5ad420d278fe0e653fdcb22fdcb63148109ec7e94f2d0750b28157dd1764376ae10fdb0a4aef3b304bd82793e0595f941226a2d72abbc929f53134dc495b0d65ced409914f94c2523f3dfbbdeeac84ae247ab5d1b9ea33dce1a808885a55be1f3683b46f4be73d9b62eec2585f690056858dfc427aabf591cd276724885bcd4c00b93bb51fb7484d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ac022309aa2c4d7fb628255b8b7fb4c3e3ae64b1cb65e0de711a6def1653d95d8088871cb8905fe8ae76423604988a8f77589f3f776dc1e4b30dbe9dd262b2187db02518a132d219bd1a06ebac13132b5164b6c420b37dd2ccee7d69b3b7fa12e54f0a53b853d490a68379ea1fa2d79762830ffb71bf86aab506b51f85c4b6a41b69325c7d0c7aa85b93b7144489d213e8f33dbb879fce22849865337b620b155cb2d2d36a68832889e30194d36d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d009c2b78a8f02e5e5dbb586ef71fc324b375092e15913ca1a5bfd22d516baadb96867bee3562e77c4a4852344a1a76c30728be5e22400b4cc41711f66754c246a520498d8c24f0205b9c873748dbeb67fe1ad099ad04cf89f4b517f0aa481136d9f6de2d727df01c6aa4099da59d4382b51e25fd47c33d9842c32b62331e50794bfe8b61b3ba9de1b8b704779c6d65edff3af00f121ab4a7ea384edabe47c6d0098a48991f387ca4444135ec59d46" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c00bab36cce69899817d1425016d222d7303197ed3e3fdcac744705e7f178a1ac745968900f69299163e19b3161f3e0a4cc55aa2e4e71e0ee6ac427d1f4d14e063f68d303ddfbb18118335cfa7a6a90d99c38319ee76f7a884846a9e0b68030bf28e78bfbd56359b9368842814da42b04cb0e307d5d846dc22f049147bae31b9a956d17676a8cc348dafa3cabc2007a30e730e3894dddf9999fb8819086311f0703e141613ed6dcd7af8510e2dc435b0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c9789152a9fc29698d49ed95f09bd11b75f18a8c5615a73dbe54ae5e550027fd0ae6a8b60667040c1b12de3d1ee3f6bf061c78c951a3210effc912e19f482dd4de152063c588c44903bc11761706fd935afa040df085b08144d83d0dde32b46ab52f4fae98ac116c7ff11d7f553450c2e37b9c5f0b1dd9e0b8640a24cba6f2a5246c41f197f46e3dc8a29131c79bef3351c6e277a0a34442274d546ccd058891277473d668420f121750d19cd684267405" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "06a15a0731ce52557e368bcbaa11ef3399299e36fb9f2eda6e5726907c1d29c5c6fc581405ba48c7e2e522206a8f128d7c1c939d1132a00bd7d6366aa82724e968964eb2e373563f607dfa649590dcf5589114df69da5547fef8d1604cc4c6de1ed5783c8746918a4dd31168d6bc8784cd0c769206bd803d6ca8557b66748770402b075ef44b38157d4c0da7c6281725a2065d087b1f7b23455fa673bdeeba45b983311c44eabe9ef4b7bde3420ae9881863" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d08aacef2d7a41aec09473bd8a44f628e15addb7b9e5b77a1e09c8ab4942f379a0bfcb324d580b774666f18ae78dd36710824ff12393f059068fe4b559c53662c2b0e6c69e23785c8f32554e837ec1714bee902e60737b639dd933af4f68cb9d7de77e1f3b28e5b122891afce62b79acd5b1ab4ba411662cc77d806449e69c5a45a143b742d98ac84a0826d68433b9b700ace6cd472ba2d58a90847f42ce9c43f38ffc017db4bf40450b2eee1f4594dc740c0f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6a6058b0a498b7ea76a93c646eb9b8629f0cba4a0c726420c5f67ba9b0412cade356abdf0a4fb94384bad32ce0d5dd9e23dcaae1d6f28ff8683616b30f1392890c67b3a2c04b360893b801f127e527e4da82e239f4c878da13f4a4f1c76db07190e77ec123995168102fb274434a2d1e12913b9b5cbab4aacaad2bd89d88b3ca2b8e60dacf7c22c9379097ff60880f552e320ca3b571994f52534470feee2b39e0dadb5cd88257a3e459a4cc6f12f17b8d54e1bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "adeced01fc5671531cbb45679f5ddd42b3a95151677b6125aaf6f5e8f82fbabaa5ecf7c3552c2458587224f0042870f178f5fca5465250e75d71352e652eeed23cdb7f915f5ebb44099b6db116ca1be45530ac8ed32b7f161d60ed4397ad3d7d649ae6bf75ca5bec891d8e595605be9764f3a03965e1fe0eaffbf212e3df4f0fa35e08ff9d0091e6d4ac4748edfe43b611085a6ffec163014655fdd839fd9e81b63b1fa8cae4ec335ec343289758e389a79ceedfae" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d014592f3a83ba40af366f137c674724916c3cdd3f6cf9d4c5c7c8d6d51ebf26e315e2c12b3546be56fb52382904046ecbd2f5b883aa4ff473de6f0c26ab862c3fa34bf3d880cc1911ce39a4088c6617c179dc5faf68a2c488bbde12d67b50f73abcfab0e3b062e68c95363e11f5f1de8ec36ed01ea21442518089045df67d346135283ad5b3fff80cf57f20876849f6db9fa139728358415a90610f69ec720fc92d8234e3e122551e9df2c644c4a2c4e3734d07de8e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c0d0c37838873ba8757d6e41b409605043bc1635edcd731219587676d94217e9f0ab44b71de25000661ce7303b7015f45e6eaa7b7ebef92b8f4a34c902c908d2172185505fa33aca5a41be83079316cdfdd430fc2c45f505f85d867e6d516f7e1bf19c001d9f43018968aab65ec031b3801399231c83ec9e622dab5629922a6b424cab938c135ff7310501c2c02971bfd2f577e25904d1a618baf0859f77f4e8b1d0cde9544e95ec52ff710c0672fdb3d891feeea2b017" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "7022e7f00902219ba97baa0e940e8ac7727f58955aa068c29680fac4a16bcd812c03eeb5adbcfe867a7f7c6b5d89f4641adb9173b76a1a8438866f9b4f640ce2aedf5f1080c890bcf515b4be4e3e512352f1e5323c62ec46cb73f3d71be8235fee55a154763f7c3f9aeb61ffd28f4cd93d3310f608e2133586bf1ab3f102de96f64c68a4668de8acb2a76a7ce0cddddc8fa3df5e9d230823da16ed9ebb402d36e38e6e018795e5a71517ecab5f9ca472b9ced8ff69d2d195" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "acaf4baf3681ab865ab9abfae41697141ead9d5e98523c2e0e1eeb6373dd15405242a3393611e19b693cabaa4e45ac866cc66663a6e898dc73095a4132d43fb78ff7166724f06562fc6c546c78f2d5087467fcfb780478ec871ac38d9516c2f62bdb66c00218747e959b24f1f1795fafe39ee4109a1f84e3f82e96436a3f8e2c74ef1a665b0daaa459c7a80757b52c905e2fb4e30c4a3f882e87bce35d70e2925a1671205c28c89886a49e045e31434abaab4a7aed077ff22c" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "84cb6ec8a2da4f6c3b15edf77f9af9e44e13d67acc17b24bd4c7a33980f37050c0301ba3aa15ad92efe842cd3ebd3636cf945bb1f199fe0682037b9dacf86f162dadabfa625239c37f8b8db9901df0e618ff56fa62a57499f7ba83baebc085eaf3dda850835520344a67e09419368d81012168e5de5ea45158397af9a5c6a1657b26f319b66f816cd2c28996547d697e8df2bb163ccb9dda4d6691dffd102a13667ab9cde60ffbfb872187d9c425a7f67c1d9fffff9276ed0aeb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6a52c9bbbba454c14540b2be58230d78ecbeb391646a0c6fcce2f789086a78364b81ae85d5396d7cfa8b46bda41e3083ec5cf7b4c47dc601c8a697df52f557defca248506dbebab25657f5a561d09625b7f4b2f0119a12beeac087efc9d350a735c35d2431c1da7dda99befb17f41a3dc4da0f00bb95366be128538ce27763d81f832fe3c1d4efc07b5b08ad8dc9e65fb5e48546664e18cb2d3bb3fe1f56fa7aae718c5e3bbdeaf70e15023f6a25b72a2d177fcfd04211d40664fe" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c3c4d3b31f1f5f9538923df3478c84fffaef411520a542da9a220ee4132eabb9d718b5076fb2f985485e8ba058330aed27ddfd3afa3db34aa60301088caec3d0053828c0c2bc87e2e61db5ea5a29f62fdad9c8b5fc5063ec4ee865e5b2e35fac0c7a835d5f57a1b1079833c25fc38fcb14311c54f8a3bd251bca19342d69e5785f9c2e43cf189d421c76c8e8db925d70fa0fae5ee3a28c4047c23a2b8a167ce53f35ced33bec822b88b06f41558c47d4fed1bfa3e21eb060df4d8ba1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8d55e92136992ba23856c1aea109766fc44772477efc932b3194af2265e433ed77d63b44d2a1cff2e8680eff120a430fe012f0f09c6201d546e13ad46fc4ce910eab27bb1569879abed2d9c37fae9f1267c2216ec5debcb20d4de58461a621e6ce8946899de81c0add44d35e27b7982a97f2a5e6314901caebe41dbba35f48bc9244ca6dca2bdde7306435892f287036df088633a070c2e385815ab3e2bfc1a47c05a5b9fe0e80dd6e38e4713a70c8f82bd32475eea8400c7bc67f59cf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5016284e20362610fa05ca9d789cad25f6d43263787e7e085476764ce4a8908ce99b262b375e9d106170b1bec1f473d5e777e0c1896533040e39c8c1465e07907ef5860e14e4d8310013e35f12090e0bfc687474b1f15f3dd2033a0edac5246102da4deec7e188c3517d84d9c2a0a4497a4c5f82a30f1ba009e45ee6eb3ab4368c720ea6feee428ffd2c4cc52debb8d634a64176572c72368f94a66689f23f8a01218f532117af5a8060d140e7ca435a92882fcb5630ebe14a4805f1dc83" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "05456ec59b8d41bbd736727976b96b38c43827f9e16169be673ff37870c2ecd5f0d1ea1a136be4cc7b047a02a4421d484fd2a12ece418e42ee391a13a0b1df5a0162b29ab70d3fe3e04ba6ab26b37d62b7cf05a5e2f033611bf970b8e1f30e198e483e740fa9618c1e8677e07b61296b94a9787a68fba622d7653b5568f4a8628025939b0f74389ea8fced6098c065bf2a869fd8e07d705eadb53006be2abb716a3114ceb0236d7e916f037cb954cf977720855d12be76d900ca124a2a66bb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "eb6f60b83fcee77060ff346aaf6ec34d82a8af469947d3b5074cde8eb26566eb1fa039bcc707738df1e95869bd827c246e88436f0614d9834ead5392ef376105c4a9f370071cdeaaff6ca0f18b74c3a48d19a717253c49bd9009ccbfdd5728a08b7d112a2ed8dbafbbb46d7a75dc9a05e09bfde1a0a92d74a51887f9d123d7896e9f9d0057b660ed7d55454c069d3c5260411db4cdc67e7b74f680d7ac4b9dcc2f8baf72e15e6b3cafebcdf449a6436ed2c398b675f79c644747c57553bf7ea2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "187a88e88514f6c4157c1ba40b442baae1ae563a6c989277443b12a219aa484cb9fa8adbb9a29d429f50155321b15664926317477079c7060dfdaa84c1d74bba78892c34e6f21ad35208d2ae622012401696bff5cd57b6485944b3db7b9071fa5f57fbfb1085d91bb9cff5808d662cdc6c8157249478262c44b7fbc397ed42a4977b202e817717bfccc9f0467294062313f7705251ed09573f16d23429361fada259dfb300369c4198f07341b38e84d02cdb74af5de6aab1fc2026208ea7c418c0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "be31bc96606d0fab007e5caeded2f1c9f747c759777e9b6eef962bed49e45a1d4fc993e279d024915e600865ecb087b960584be18c41114d3c43f92169b9e0e1f85a0ebcd4e196376ccdc920e66103cd3b1c58407d0aafd0e003c4e341a1daddb9f4faba974362a32f35db83384b05ae8e3322d728893861afd8b1c940de5a17f691e763ce4969b6d94f67fb4a0235d100225bd8602f291388f0ca4a568748ad0d6040f1262eac2aede6cd27419bb78a394c1ffad72c262be8c3f9d9619d633e51d0" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4d83d85ca838b4518588f2a90228a4dd18f14dd5b4c012d26298a97d848abbd825d221d02cceb6e8c701b4ad00e1dee4889b5c533e4bb60f1f41a4a61ee5478be2c1b1016c30345afd7a5253668260515e70751f22c8b4022d7fe4877d7bbce90b46531507dd3e89549e7fd58ea28f4cb23d33662bd003c1345ba94cc4b06867f778957901a8c441bee0f3b12e16463a51f7e50690356971dd73a686a49fda1eae46c9d54fba262811d698025d0ee053f1c58591c3bb3cbde69de0b31549ef5b69cf10" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "cdeb07d36dc5f9a1cd717a9e9cca37a2ce93caa298eee63571f7d6c5fde2a11c666cf53cf2dcb41ca2ea2319e7230ca68e38c647905928713a13982bf47fe33d7095ebd50b2df976208920a43eb2e29b942f32467403c45cea18bf44e0f6aeb155b48a8e5c471fec972a9d62f7ae093d2758f0aaec7ca50cb4725bfa219f1a3a46ad6bde7361f445f86b94d66b8ece080e56c510250693a5d0ea0ae87b4421860b853bcf0381eae4f1bf7c5c0472a93ad18407bc88475ab8560d344a921d3e86a02da397" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a598fad52852c5d51ae3b10528fc1f722e21d44fbd42ae5acdf20e85a28532e646a223d27fd907bfd38eb8bb75175636892f8242877aab89e8c0824d368f3339ce7a82aa4e5af6db1f3b588a4d667a00f67bee37cfd2724dde06d2909fb9e58d892f4cfd2c4ca85acdf8256f5458b030a6bda151154ff2e6d7a8da90b54a2884c8a99fab5a4ac211ff23dc0975f4f592fd1b6b9dc7783bdcd2d4ca4e68d2902f2013e122cb62e2bff6b0a98ec55ba25837e21f1cfe67739b568d43e6413dab2bd1dc471e5a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "17b68c74c9fe4926e8102070916a4e381b9fe25f5973c9bd4b04ce25749fc18931f37a65a356d3f5e5a1ef125d546f4f0ea797c15fb2efea6fbfcc5739c564693d47adeb12dcb3d98a2830719b13247792cb2491dca159a28138c6cff925aca42f4fdb02e73fbd508ec49b25c60703a7595a3e8f44b155b371d525e48e7e5dc84ac7b17c52bf5e526a67e7187234a2f19f57c548c70fc0b27183df73ffa53fa58b658034c896fa791ae9a7fd2620f5e46ce84c842a6e60e9324ae4db224ffc87d9617cb85ca2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b9e4267ea39e1de1fed0579f93bb351007c9f8fcdd811053fae33f09e2753d7428f04e1a9efcd45ea701a5d87a35b3afb2e6b65365dee6ead0bbb611b7797b212ac688653f542e604a39df277f12514ddfee3b4e27b98395c2cd97a203f1f1153c50327965770802ec2c9783edc428271762b275471e7ac65ac36523df28b0d7e6e6ccc7674268a132a63411fc82c0738dbb68af003b769a0bf9e6587b36476cb465350fee13f88ea355d47ffac7b0f964f4139db11b7642cb8d75fe1bc74d859b6d9e884f75ac" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8ca704fe7208fe5f9c23110c0b3b4eee0ef632cae82bda68d8db2436ad409aa05cf159223586e1e6d8bdae9f316ea786809fbe7fe81ec61c61552d3a83cd6beaf652d1263862664df6aae321d0323440430f400f291c3efbe5d5c690b0cc6b0bf871b3933befb40bc870e2ee1ebb68025a2dcc11b68daadef6be29b5f21e440374301bde1e80dcfade4c9d681480e65ec494a6af48df232c3d51447b9d06be714949249c44c43cf73ed13ef0d533e770284e51369d94ae241a5fb2f163893071b2b4c118aeaf9eae" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4fd8dd01012bb4df82bf42e0683f998e6f52dd9c5617bae33f867d6c0b69798cead8179346d70acc941abbbdd26e3229d5651361d2252c72ff22db2938d06ff6fc29a42fdf800ae967d06479bc7bbb8e71f40b1190a4b7189ffc9a7096cdb76d40aec424e1388e1eb7ef4ac3b34f3f089da8fda7d1927f5d775c0b2801d22dd1265c973158f640cec93edfed06dc80b20ef8c496b98289d54d46ccd205951cbb0f4e7daeb866b60bacb483411e4382b6f04d472843186bd0e31fbaa93e5c901ec028efafeb45fc551a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e9ee1b22b04b321a5fdd8301627011f583887d77560fb0f35552e207561f81e38ac58a0d0aeaf832d1ee72d913720d01f75574e9a321864fe95f4d0d8f0b8db97649a53e71e940aede5c40b4b9105daa42a6fb2811b61209247534cbaf830b07abe338d75d2f5f4eb1c3cf151e9edabe2c8d5f6fff08fac1495ef48160b100d30dcb0676700bcceb28723a29980ab0766a93abb8cb3d1963007db8458ed99b689d2a7c28c788743c80e8c1239b20982c81dadd0eed6740c65fbc4ef15c7b5569cb9fc997c6550a34b3b2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ec01e3a60964360f7f23ab0b22e021815765ad706f242265ebc19a2bb9e4eac94393952dcf61aae47682671a10f9165f0b20adf83a6706bfbdcf04c6faba6114653a35584267267873291c6fe7ff5f7695243143421509502c8875aafa9e9afe5be5ef2c851c7f35d69be5d3896000ccdbbfab5c238bb34d607cfe2d55d748880545b4aa7ca61137992925189025c62654b1f20d49c3ccd75aa73ce99cd7258dabedd6480a9f5185531fc0118beb68cc0a9cd182f6973287cf9252e12be5b619f15c25b65c71b7a316ebfd" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "db51a2f84704b78414093aa93708ec5e78573595c6e3a16c9e15744fa0f98ec78a1b3ed1e16f9717c01f6cab1bff0d56367ffc516c2e33261074935e0735ccf0d018744b4d28450f9a4db0dcf7ff504d3183aa967f76a507357948da9018fc38f150db53e2df6cea14466f03792f8bc11bdb5266dd6d508cde9e12ff04305c0295de29de19d491ad86e766774bb517e7e65befb1c5e2c267f013e235d8483e177214f89978b4cdc81aa7eff8b39f2825ad3a1b6ac1424e30edd49b067d770f16e74dd7a9c3af2ad74289a676" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "00e40f30ae3746edad0f5dd03d0e640933cf3d1694804c1e1ed6399ac36611d405196ee48f129344a8512feda16a354517871322bd5d9c6a1b592933eab531923efb393ffb23d9109cbe1075cebfa5fb917b40df028a621460ff6783c798792cb1d9635b5a6f84ec13918fa302924649b5c7fcb1f7007f0d2f06e9cfd7c27491e565a96c68a0c3644f92cd8f38857258c33801c5d537a83dfe583cba59d7eec7e394199c0a2660a62fabe3ed2099d57f315a6cd8de1a4ade29d977f15d65759cff433e5ac0c182aef3761163e1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3c5ea24d0d9b618294a263f062b2414a722be4eb10dfc346a6ec3b821d7396eba61cd6ef33618b04cd087a811f299d4606820227f16000d7c839062b96d3e3f59cd1a082448d13fc8f56b3fa7fb5f66d0350aa3b72dd7c165d590282f7da2e12cfe9e60e1796122bb8c2d40fdc2997af634b9c6b127a893dfb3467909378300db3da911be1d7b616bb8e0572433e65527e15d936500a2c60e9f9909dcf22ab5e4b6700f0238c205b4a813626fac3d945bab2637fb08203044a73d20c9a3fcf7c3fc4eb7807c3276dd5f73ce89597" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9271aeeebfac46f4de85df78f1bfd36136aa8905e15835c9e1941176f71e3aa5b1b131843d40479735e23e182a2bd71f66f6149dccb7ed8c16469079dc8590bbf165374951785f4531f7e7361de62f936cfb23a2b5bdf186632e7042a0dd451fdc9b7208f923f3a5f250ae590ec348c63a16c3aacaf7379f53b5dd4152dcd40d23e683e2156e64c592ffc07e2cd6bbeebef4dd590b2f6b2bcbf08fcd111c079f5c4033adb6c17574f8756ecd87be27eff1d7c8e8d0324438d59ae171d5a17128fbcb5533d921bd044a2038a5046b33" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4e3e533d5bcb15793d1b9d0468aaee801f32fdb486b11027183553a09ddbee8213924296f2815dc61577297459e834bf1c7a53f87d43782209e589b8295219ba7073a8fff18ad647fdb474fa39e1faa69911bf83438d5f64fe52f38ce6a991f25812c8f548de7bf2fdea7e9b4782beb4011d3567184c817521a2ba0ebad75b892f7f8e35d68b099827a1b08a84ec5e8125651d6f260295684d0ab1011a9209d2bdeb75128bf5364774d7df91e0746b7b08bda9185035f4f226e7d0a1946fcaa9c607a66b185d8546aac2800e85b74e67" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "b5d89fa2d94531093365d1259cc6fe8827fea48e6374c8b9a8c4d2209c280fa5c44958a1847222a692a59e6aa2696e6cdc8a543dd89b0ce03bc293b4e78d6ef48e1839694ccd5c65661143095c705b07e3ced84a0f5959114dd89deb956ab3fac8130eb4a878278205b801ae41a29e34146192308c4e759b374757b0c3b00319bce92a1b95a4d2ee179fd6714ff96155d26f693a5bc973f84ac8b3b91e3926276297532d98b46992a3f104c08100bf1671c43134bac280c617da711e90a0100137525375ebb12802a428885ae7fce6514a" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "40e3d8048fc10650cb8a7fc2e7113e26dec34f9ca2d5129cd10a8e8e44d113d61ee48c7d003e19fd307fc6debd70feb30243f298c510ccc4418355ce143066f067ad7c6de7288c3080e7ad46a23c8d34deb55a43e652fe90444ad3c57d3ec1e1c489d63ef915a24bc74a7925a0a7b1e1523f21ca8fee78df24e3d0a68d0013423db97c280799a0618229c0f2c167289a891e5c8d6661ab21285951c31710e3b5fe55f6347fe16d9b40507948a59252efeb616df83e5c098b07d0a7247cd371daff0e50491c582503fd89f79ba94d6af9ed76" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1fa444de01dd3901e2b4684e3d7a799ffa02d85afd35fb30fe4c9d672837bee6dd8a3b8608b4bb5e589220ad5a854f46b46e41c6d57ad124a46beab4169ff69fee7e3838a6165e19dad8eb5d7bf53d4edd3cd2769daf219510a02fdd2afe0c0e1da3cd30fcd1aa88b68965586f07a25a1720fbd90a096ea30fc8e945e3637d7857c8a9c0ab4154ffb2000e57b5f9adfa4e4eaf8065bc3c2b2e75f495963325588785a6ce417dcddffd299873b15dcccca128d63cd4eeeadb64cda28099a9ad7c80d34844901f26b88b00b9aafeb2f90286d29d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fde0a0d9d813983bd1f55cf778a003a2023b34a555322ab280584537bc6bdd844d22a7d6066c18da83ec09f3d8d5a1aab4be0d5ce19b436052f6e259a4b49017a1f47f1fe2bf115d5bc8599fb216351c60dd6b1bedb2e6f4dcadf424b833501b6f099cbfad9e2290680fb69c25032b42a6274f7cb9b5c5950401354838a45f7cb77b95bf54718e2f3d3d9fb91eb2311903980277396398d9736d8e92fd838594ac8a537c6c529db5a8a4f89290e6ba6f20ac0e5ed6fef40901d0e0e8e3e502990811f9acaae555dd54eb1bcd96b513e2fe751bec" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9f8e0caec87858599f5ab29bff86da78a841a918a023a111098687ecdf2747612d3f3809d9ca400b878bd4f92c43a1004f1c17c7f19a3cd1ce449bd2b23aff551623c37dd8c0be56bf3fd857b500c2b9f9ccea62481944090a3cf3b6ee81d9af8eeb60f65ef150f9fa4d3ed6ce4762d3d4f174ee8ccd460c25cafac0ea5ec8a6a4b2f9e8c0520cb7061155e532cb65f188b01e4b9086db951f504b060c296b326b3fc1c590498ecce594f828f4a10ea416675720ae505295d38a791bd0e93f428448a8f4c1fc0af53604a9e8255384d29ae5c334e2" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "33d1e683a4c97ee6bbaa5f9df1a88cb53b7f3c157b6045d70a56fda0ccbd3a1fa1f049cd564da072b53f415bf5fb843771c1d2551fd075d33377362b2f7c0645f9723123d11975991db8a2b518f02e2c7c30342a044754290bae2c77496d755e5981f12e6b0a0174280b958bf11ed628a9062775993ced04bf752ea8d165e3ac2177d7cd1b9371c44efa98f0b3e68602a839d384eec007979f46429dafb138cbc231ad928a9f65f7d66fac77416395e8f1debaaf76ec2e4e03e8674102cd26f614739f3ec9f949033df1fb97e87c2326d65aef94ed5f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "180048f09d0b480887af7fd548a85abf605440c1ddde6afe4c30c30670233f7bf928f43b4681f59279ebbda5e8f8f2a1abefdee129e18ac60f9224e90b38b0aabd01308e0a27f41b6fb2ee07ee176ec9048c5fe33c3f7c791469c81f30e28170585b9f3e7e3c8c2e9d74370cb4518f13bf2dee048cbd98ffa32d85e43bcc64a626b40efb51ce712925fdd6fee006dc68b88004a81549d2121986dd1966084cd654a7c6686b3bae32afbd9625e09344e85cf9611ea08dfce835a2e5b3726e69ae8a76a97db60fcc539944ba4b1e8449e4d9802ae99fae86" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "13c0bc2f5eb887cd90eae426143764cf82b3545998c386007cca871890912217aa143ac4ed4ddb5a7495b704aa4de18419b8664b15bc26cfc6596a4d2ae408f98b47a566476d5802d594ba84c2f538def9d016661f6404bb2337a3932a24f6e30073a6c9c274b940c62c727242e24466084a3ea336365d71ea8fa6499c0ea8d59eea505f1126b99c795023c4963aa0d99323d0391e8701110edf551b2d3799e1063ca443f1add162156e445502ca1a052fe70c289838593b58839fc63de128a03e2bbf389e22ae0cf957fd03315ee407b096cc1cfd92dee6" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6f1eb607d679efef065df08987a1174aab41bdac8aece7726dfa65805d6fff5b3d17a672d96b770dc32165f144f0f7324822a5c87563b7cd9e37a742ae83ef245d09006d91576f435a03476f509ea2936636232f66aa7f6cdf1ac187bbd1fcb8e20f8791866e60ed96c73374c12ac16795e999b891c64507d2dbd97e5fc29fac750ad27f2937cbcd29fdafccf27ab22453834d475f6186eaf975a36fad5c8bd61c21da554e1ded46c4c39765dcf5c8f5ccfb49b6a4dc562c919d0c7d8940ec536ab2448ec3c9a9c8b0e8fd4870cad9de2577c7b0c38563f355" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dcdd993c94d3acbc555f464871a32c5da6f13b3d5bbc3e34429705e8ad2e76393fdd96a69a94acb652f5dc3c120d41187e9aa919669f727c4868013b0cb6acc165c1b7706c52248e15c3bf81eb6c147619467945c7c48fa14a73e7c3d5bec91706c567145342a026c9d97eff97ec672c5debb9df1a998083b0b0081d65c517b3e5634c95e347e781aa30ca1c8af815e2e494d844e847fdcb41622894a518dc36571123a40bfdbe8c4f4cff44d83c61dd9dcd24c464c53b395edb31efee9f3aa080e87cdc3d22d613ae84a53c9249c32c96f9a3bc4629bb126a70" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "49971f9823e63c3a72574d977953329e813b22a8387cd13f56d8ea77a5d1a8a20012632d1d8732bbcb9f756b9675aab5db927beacab7ca263e5718b8dfa7b2eed9a91bf5ed163b16139d45f7b8cc7e3f7bdda6202106f67dfb23b7c315ee3e17a09d466b1e6b13e7c7428184a979f5358667b4fa8bd40bcc8ea46058db44587a85377ac46bf155136c09ac58cb6c27f28e17028c91e7e8f74d5b500e56293b316974f02b9d9ea205d9b6ac4cfb74eb8eb0c944577fd2f41316368307beab3e327bf7dbaa0a4428836ec4e895dea635234abeaf113ceeadac33c7a3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c57a9cc958cee983599b04fe694f15fb470fcbc53e4bfcc00a27351b12d5d2434444253ad4184e87b81b738922ffd7ff1dc1e54f39c5518b49fb8fe50d63e3935f99e4bd125e8dc0ba8a17fd62de709339a43fabe15cf86d96a54010112170c340cfac4132182eed7301402bc7c8276089dec38488af145cb6222525894658f03501204b7a66aba0be1b557b28a2f652d66f7313ed825ecc4d8596c1be7420d4425b86a1a90a5b7f30d0f24e0d1aae0eb619ca457a71699e44be612a4011c597ee80b94d5507e429d7fc6af22579cd6ad642723b05ef169fade526fb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "0568a672cd1ecbaa947045b712e2ac27995392fbef8f9488f79803cbee561c212287f080eca95adb5ba42739d78e3ba667f06045d87850d3a0499358649caa257ad29f1a9c511e7054db20554d15cbb55ff854afa45cae475c729cea72ede953522031865bc02b95589ed4d9841c552a8cc94904a93ed09ed77222f6c178195056be59bc4e96a815adf534e6b466fb47e262ff79c803c157a21b6e2269c2e0abeb494113cd868d8466e82d4b2f6a28b73645853d96bc9242515d803e33294848d3fe42fdff68da53c03491636beede47ff1399dd3d54a5e914d55d7adf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "3f19f61a4cd085796731ac9f85a75a8bce77031932c31762d87d8b8d07b8bd19ff78d6b7d1bd1e87f3a4f41aad03b6c4d17a6cbc86be55f7c8b88ada047bb04f8d49f1c34bcf81cc0f3389ad01a758fc7eeb0072aa9ad1481992bfdde82e438e75590a4423832dfbe3756e2229ea873bc3606e6d72174cb2163bf40b5d49c81009dab85ecc03e311351bbf96e32c030a2b276a7698cb25bc2c967acb3213161a1fdde7d912cd6a804490f8056c47da1333f6e35c41e749c2c23919cb9af5eec5652e6e072b034fb1682e9aaa194a9c0bd456ea0b008d14dbce37967a7a8e" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "705f98f632d99d3651793825c38dc4deda56c59eac539da6a0159c83131cf8ab6f2ee0c3b74111fde351f7aa1a8c500a0cecab17c212d2c58ca09eae608c8eefc922b9902ef8d6832f799ba48c3c28aa702b3242107edeba01daafe424406a3822965056cfe8783455a671e93b1e2eae2321364f1871471c82124df33bc09e1b52882bd7e1c4c7d0b2f3dd4a28c2a002a43246768af0700f9659de99d62167be93177aabf19d678e79e9c726ac510d94e74873eda99620a3961930cd91937c88a06d8153d64fd60da7ca38cf26d1d4f04a0df273f52127c53fdc593f0f8df9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ea6f8e977c954657b45f25480ff42c36c7a10c77caa26eb1c907062e24fbca5aebc65cacca0de10abea8c78322f08672e13d8ac16996eca1aa17402eaea4c1cc6c800b22dc18cb8d620192d74bac02c07b5cfa61e513c7f28b7e29b9700e0e442720bf4c669d4995da19d19f841d9eb68cc74153592591e3bf059ef616b95305aa453b32fe99a91afb35bd482cf2b7aa42702837a53be3c38883d2963020e347556f841254ec6b85854485fe8c520b05f2ea67a9bf3981555c20991e2bacd4db5b418228b6002d8d41c025cb472bf5443aaa885974a408ea7f2e3f932c600deb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "408190134ed06556811b1af808ab2d986aff152a28de2c41a2207c0ccc18125ac20f48384de89ea7c80cda1da14e60cc1599943646b4c0082bbcda2d9fa55a13e9df2934edf15eb4fd41f25fa3dd706ab6de522ed351b106321e494e7a27d5f7caf44ec6fadf1122d227eefc0f57aefc140d2c63d07dcbfd65790b1099745ed042cfd1548242076b98e616b76ff0d53db5179df8dd62c06a36a8b9e95a671e2a9b9dd3fb187a31ae5828d218ec5851913e0b52e2532bd4bf9e7b349f32de2b6d5d3cdf9f372d49617b6220c93c05962327e99a0480488443349f0fd54c1860f7c8" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "5f9e5c6f38573a85010a9d84d33f29c057003b2645e3ea6f72cbc7af95d197ce6a06b13fea81722853e6991791b8b15091cd066f5ed913592ed3d3af5370d39ba22beeb2a582a414b16824b77e194a094c2afdcc09aa73ce36f4943cca5ae32c5017dc398801dd92a47382d9327c9f6cffd38ca4167cd836f7855fc5ff048d8efba378cdde224905a0425e6b1de061fc951c5e624a5153b008ad41160a710b3ff2081748d5e02deb9f841f4fc6cf4a15153dd4fe874fd447482696283e79ee0e6bc8c1c0409baa5ab02c5209c319e3169b2476149c0c6e541c6197ca46e004eef533" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "218c6b3508aec69574f2b5039b30b942b72a8349d05f48ff945bbbe5c8957d5a6199492a6bf54bab821c9377e2edfa4c908384664d2c80112d5e805d66e0a551b941021be17dd20bd825bea9a3b6afb1b8c605805b3bda58750f03ea5c953a698494b425d8980c69f34d1c3f6b5866e8717031152a127215c256e08873c21b0f5cc85875d0f7c94601659150c04cd5fe5d381ba29983a2d94fcd3a65a94c53c7279cd000dddd4253d8cff8d7f6ace10247fe3bc30d63ba4bb54f557b3d22a3924369430d71ab37b701e9500bda70b5a643704858beed4726a889b6c9c91584194c68f1" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "dac26aa7273fc25d6e044c79fc2bfa46e59892a42bbca59a86826c91e76ab03e4bd9f7c0b5f08d1931d88b36ea77d94f7ba67cd4f1d3086e529427201119096ae066ae6f170940830ed7900de7bb9d66e09788287403a4ecc93c6da975d2fb08e918840a236c15f5d3a8f7375c2eeebbf6f01a6e7f29ca2b8d42df158414c320777433663c59fdcd1f39ca68e3473db721be7ce8c6dba5fddc024f94fedb286b0477581d451313ca8c737484daf60d67f9b2d56d4bcc271f7e9ae958c7f258efbc74d25753e0516f28282461941bf2dcc7dd8c7df6173b89760cefcac07190243ff863fb" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "c46e6512e6797cc7a54254a1b26b2de29aa83d6c4b1ea5a2786fbcec388270625b12635eae39e1fba013f8a65219421bca8b52a8ddfd431cda60299bdf160734d5a7450ec79620058522702174ae451b9bfa7c4a455fbbee3e1d048c7d4bac5131018228f137c8e130440c7059b4f15eaa34ce872a851a16ce86f982df78a00be4d564da2003a450ddee9ab43ea876b8b4b65c84f0b39265fd5456417afb5bc54997c986e66fc222f2123ba5e719c4d6b9a177b188277df384f1125821cf19d5248cef0be183ccdc84ac194506f740ed2188b2689ea4c9236a9e9e3a2fff85b6af4e9b49a3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1ccd4d278d67b65cf2564ecd4de1b55fe07adc80e1f735fe2f08ea53fd3977323689122c29c798957abaff6aba09bdcbf661d77f4dc8913ab1fe2bef38846166e3834785e7105d746484eff8c656af5d8c7854abc1c62b7fadb65521dc6f793d978bda9838eb3800417d32e8a24d8c8cb1d18a5de6ca79d9e1b0ff9aa25e6218fe944cf18666fecc1e31334b390260dbe0997539e1b02f6366b2aea4f4a21efe04f4b97568fcb39e59919d5ebac6543d5d0f48fc66b923c34aac377dc95c20329b837b6ed5e8d9a3d2089cd0d8f025658006ff41cbdaccca618822ca590ab155253f8bc1c7f5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "9875209588395ee3c9fdd793fd48717cc84c8c3ea622b2ccc4a1be4448e6034b7810569855255031f10be5ffd714b05f9ce01972d712d40abf03d4d0ce175813a7a668f761324996093fc2aa5912f7fc2abdadd8775d2b4d9ad492216293381460ed8f6db3d641d1525f4242c348bbfe504c704f215dc461de51b5c75c1aae967936963848f16c673eca5e78dfd47eb19001d52d1bcf96c98956dad5ddf594a5da757e7ca35f2f69803b784e66ac5a58b75c228b8266ec592505e5d1ca87d81225738855f15bc0914677e81593fd409e77d159f8a908f67788de9eb06c5561547aada96c47c535" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "40c90e375e366f3756d89091eb3eed9fe0fbfc5638700af4617d358812bac53124a2205dd6756456787d49cd6a35e302479a0992288f47532e4ea7ab62fc5ad5adc690a5d9a446f7e035ad4641bd8dae83946aee3338ec984ccb5cc633e1409f2531eeffe05532a8b0062ba99454c9aeabf8ecb94db195af7032bfebc22912f49d39330add47ff8fa5720612d697f0b602738930e060a1bb214efc5e292224cf34e29deaea6b1b1ff847e94ecc997325ac38df61db45d82bf0e74a664d2fe085c20b04c39e90d6a170b68d2f1d373f00c731c524456ada73d659aaac9df3191a7a3865083343fc13" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "e8800d82e072210ca6d7fa2472028974780b76aad4bcb9ad362422dd05ae3232668251d164daa375a43b26a38cce28dbeb3dee1a4a579f70d0fe7febb29b5ece8aa836e050fb3d188c63aa9c3c0da6c717d86458a6096b5effceb964efdec7035960c09ccd10dea3c5f1c7f9f478d5887ebbe2e15c5ff85dbacbc444bb951c4eec7abecb89ed80187e409e2972ffe1a5f01562af109f2cf09471cf72cf83a3bb8f4e2ef38ed0e326b698296394e5b2718a5000c01425708e8ad0461e62462d8819c2377f13ab1be2c7c9f33dc06fe23cad27b87569f2ce2e56e4b2c60c7b1b3d370841d89ebdc1f192" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "796d6d1447d5b7e8c55cd8b2f8b7010db39f27565f907e3fc0e464ea2d4bb52b37f10e7c6dcfc59231b9cdee12c32aeb4adbc42b86e86eb6defb5b69e6ca75e1f4d0dae3e124e5a1b8b6697f7e10b0403f1f0a5ff848eef3752837a9ba17780f16a9a709188a8d5b89a2fa74adb2e651163b1c2b3d261e225c9158dcd9eb7ac3d6704cee290cdff6bcb3cb90cee030aa0d19d4693655c3c30ac6fc06d2ae37787c47126d57ed9a6bef5f8a6c56859aefc08755739a95aac57a4dd916a92ba9f3afbf969df8085949615033365c751a9a3e1a18cee98a69d22e64009bebf8307169b6c61de0617ecfafdf" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "4f9057183566153cf337b07c3f5556006de54c56b2a1e5326c07aaeabd1886ec6f1641358925db232b2f0dbf75229c796a7395b2f934c1f99090bec1123f3c841b1cb3c5b1ec42ed5408f2940f0c48a9470b852c46d6557853d459cecd2c32bbcd8ee21fa11e385eef0857cba4d8545a61b52a484cdd779db4739fbc7aa9860dcabe0488b98fa0b60c3f7d6153db279000a52ffb573dab37d2ab1896a90e5deb7ac6bbe56239085c325d83a917dc6e8a448425b718c2356b9f3066163555ec444f372e184e02c8c4c69b1c1c2ae2b51e45b98f73d933d18750968945ca85d6bbb22014b4c4015262e3c40d" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "79dcca7d8b81a61359e4aece21f3df7b99518ce70bd2f57a18bab5e7114af2add0a0cea7f319d69f231f060e0a539d9a23fb3e95451ce8c6340cfb09edf931df84203a39226dd9eb278f11b691ef612585b973daab373e65d11325898badf6732100371fd759960fa8fec373268421d28bffdb9b12a430b92fe4b07566ca0c89e616e49f8fc75ccd9cdc66db820d7c02e109aa5ed86b89770262918a518f90a2292f6b68d68ae03992e4259a17a23c84ec2a417f082b5abf3a26e44d2278ecb8ba9456965303a75f25394d1aaf5544590e74b14d8a4cc4050be2b0ebcfe4d2db6b12a02c68a3bcdda70301f3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "848755dc31e25e9a42f9ec12d847d19f292c14c162c9aba49e972cb123b58b8e57bb263a923929833373858594ff52dbc298dbbc078599194e4c07b0e5fc1e10808bbacdb6e93c72b333685cf961f28eb0d5a395c63266b01f130d25db384b356e5da6d01042fc2359581b89c63b3bb2d1ce897fbc9e83fe85d9666cb60e6a8c657f70caad5387b8a045bf91095606802c8424ea8ac52ef29386dc46183378a5fcb2cb927428b8c070f1c42aafd3bc70ca25437807696a46873cfeb7b80ba2ebc3c4272443d445e46343a1465253a9eebd532a0d1d2c18264b91ff45159f245404ae9335f2af55c802772426b4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ecaa6e999ef355a0768730edb835db411829a3764f79d764bb5682af6d00f51b313e017b83fffe2e332cd4a3de0a81d6a52084d5748346a1f81eb9b183ff6d93d05edc00e938d001c90872dfe234e8dd085f639af168af4a07e18f1c56ca6c7c1addffc4a70eb4660666dda0321636c3f83479ad3b64e23d749620413a2ecdcc52ad4e6e63f2b817ce99c15b5d2da3792721d7158297cce65e0c04fe810d7e2434b969e4c7892b3840623e153576356e9a696fd9e7a801c25de621a7849da3f99158d3d09bf039f43c510c8ffb00fa3e9a3c12d2c8062dd25b8dabe53d8581e30427e81c3dfc2d455352487e1255" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "23a3fe80e3636313fdf922a1359514d9f31775e1adf24285e8001c04dbce866df055edf25b506e18953492a173ba5aa0c1ec758123406a97025ba9b6b7a97eb14734424d1a7841ec0eaeba0051d6e9734263bea1af9895a3b8c83d8c854da2ae7832bdd7c285b73f8113c3821cced38b3656b4e6369a9f8327cd368f04128f1d78b6b4260f55995277feffa15e34532cd0306c1f47354667c17018ee012a791af2dbbc7afc92c388008c601740cccbbe66f1eb06ea657e9d478066c2bd2093ab62cd94abadc002722f50968e8acf361658fc64f50685a5b1b004888b3b4f64a4ddb67bec7e4ac64c9ee8deeda896b9" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "758f3567cd992228386a1c01930f7c52a9dcce28fdc1aaa54b0fed97d9a54f1df805f31bac12d559e90a2063cd7df8311a148f6904f78c5440f75e49877c0c0855d59c7f7ee52837e6ef3e54a568a7b38a0d5b896e298c8e46a56d24d8cabda8aeff85a622a3e7c87483ba921f34156defd185f608e2241224286e38121a162c2ba7604f68484717196f6628861a948180e8f06c6cc1ec66d032cf8d16da039cd74277cde31e535bc1692a44046e16881c954af3cd91dc49b443a3680e4bc42a954a46ebd1368b1398edd7580f935514b15c7fbfa9b40048a35122283af731f5e460aa85b66e65f49a9d158699bd2870" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fe511e86971cea2b6af91b2afa898d9b067fa71780790bb409189f5debe719f405e16acf7c4306a6e6ac5cd535290efe088943b9e6c5d25bfc508023c1b105d20d57252fee8cdbddb4d34a6ec2f72e8d55be55afcafd2e922ab8c31888bec4e816d04f0b2cd23df6e04720969c5152b3563c6da37e4608554cc7b8715bc10aba6a2e3b6fbcd35408df0dd73a9076bfad32b741fcdb0edfb563b3f753508b9b26f0a91673255f9bcda2b9a120f6bfa0632b6551ca517d846a747b66ebda1b2170891ece94c19ce8bf682cc94afdf0053fba4e4f0530935c07cdd6f879c999a8c4328ef6d3e0a37974a230ada83910604337" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "a6024f5b959698c0de45f4f29e1803f99dc8112989c536e5a1337e281bc856ff721e986de183d7b0ea9eb61166830ae5d6d6bc857dc833ff189b52889b8e2bd3f35b4937624d9b36dc5f19db44f0772508029784c7dac9568d28609058bc437e2f79f95b12307d8a8fb042d7fd6ee910a9e8df609ede3283f958ba918a9925a0b1d0f9f9f232062315f28a52cbd60e71c09d83e0f6600f508f0ae8ad7642c080ffc618fcd2314e26f67f1529342569f6df37017f7e3b2dac32ad88d56d175ab22205ee7e3ee94720d76933a21132e110fefbb0689a3adbaa4c685f43652136d09b3a359b5c671e38f11915cb5612db2ae294" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "af6de0e227bd78494acb559ddf34d8a7d55a03912384831be21c38376f39cda8a864aff7a48aed758f6bdf777779a669068a75ce82a06f6b3325c855ed83daf5513a078a61f7dc6c1622a633367e5f3a33e765c8ec5d8d54f48494006fdbf8922063e5340013e312871b7f8f8e5ea439c0d4cb78e2f19dd11f010729b692c65dd0d347f0ce53de9d849224666ea2f6487f1c6f953e8f9dbfd3d6de291c3e9d045e633cfd83c89d2f2327d0b2f31f72ac1604a3db1febc5f22cad08153278047210cc2894582c251a014c652e3951593e70e52a5d7451be8924b64f85c8247dab6268d24710b39fc1c07b4ac829fbda34ed79b5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "d7314e8b1ff82100b8f5870da62b61c31ab37ace9e6a7b6f7d294571523783c1fdedcbc00dd487dd6f848c34aab493507d07071b5eb59d1a2346068c7f356755fbde3d2cab67514f8c3a12d6ff9f96a977a9ac9263491bd33122a904da5386b943d35a6ba383932df07f259b6b45f69e9b27b4ca124fb3ae143d709853eed86690bc2754d5f8865c355a44b5279d8eb31cdc00f7407fb5f5b34edc57fc7ace943565da2222dc80632ccf42f2f125ceb19714ea964c2e50603c9f8960c3f27c2ed0e18a559931c4352bd7422109a28c5e145003f55c9b7c664fdc985168868950396eaf6fefc7b73d815c1aca721d7c67da632925" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2928b55c0e4d0f5cb4b60af59e9a702e3d616a8cf427c8bb03981fb8c29026d8f7d89161f36c11654f9a5e8ccb703595a58d671ecdc22c6a784abe363158682be4643002a7da5c9d268a30ea9a8d4cc24f562ab59f55c2b43af7dbcecc7e5ebe7494e82d74145a1e7d442125eb0431c5ea0939b27afa47f8ca97849f341f707660c7fbe49b7a0712fbcb6f7562ae2961425f27c7779c7534ecdeb8047ff3cb89a25159f3e1cefe42f9ef16426241f2c4d62c11d7ac43c4500dfcd184436bb4ef33260366f875230f26d81613c334dbda4736ba9d1d2966502914ec01bbe72d885606ec11da7a2cb01b29d35eebedbb0ecc73ed6c35" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "fd993f50e8a68c7b2c7f87511ce65b93c0aa94dcbdf2c9cca93816f0f3b2ab34c62c586fc507b4900a34cf9d0517e0fe10a89d154c5419c1f5e38de00e8834fe3dc1032abdeb10729a81655a69a12856a78ca6e12110580de879b086fd6608726541cfa9616326bdd36064bc0d1e5f9c93b41278bff6a13b2494b81e238c0c45aea1b07d855e8f3fe1478e373bd9d3957cf8a5e5b9003386793d994c7c575cff2322e2428cbbaa4f47560316ae3354a7478842ff7cc5dcbacb6e871e72b36f06d63a9aaeb9044cfb7974afdc238a5816f537dcf33ee40b4e1a5eb3cff2402b46d548264e133008d284f11b7e4e450bc3c5ff9f79b9c4" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "8df21892f5fc303b0de4adef1970186db6fe71bb3ea3094922e13afcfabf1d0be009f36d6f6310c5f9fda51f1a946507a055b645c296370440e5e83d8e906a2fb51f2b42de8856a81a4f28a73a8825c68ea08e5e366730bce8047011cb7d6d9be8c6f4211308fad21856284d5bc47d199988e0abf5badf8693ceeed0a2d98e8ae94b7775a42925edb1f697ffbd8e806af23145054a85e071819cca4cd48875290ca65e5ee72a9a54ff9f19c10ef4adaf8d04c9a9afcc73853fc128bbebc61f78702787c966ca6e1b1a0e4dab646acdfcd3c6bf3e5cfbec5ebe3e06c8abaa1de56e48421d87c46b5c78030afcafd91f27e7d7c85eb4872b" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "48ec6ec520f8e593d7b3f653eb15553de246723b81a6d0c3221aaa42a37420fba98a23796338dff5f845dce6d5a449be5ecc1887356619270461087e08d05fb60433a83d7bd00c002b09ea210b428965124b9b27d9105a71c826c1a2491cfd60e4cfa86c2da0c7100a8dc1c3f2f94b280d54e01e043acf0e966200d9fa8a41daf3b9382820786c75cadbb8841a1b2be5b6cbeb64878e4a231ae063a99b4e2308960ef0c8e2a16bb3545cc43bdf171493fb89a84f47e7973dc60cf75aeeca71e0a7ebe17d161d4fb9fe009941cc438f16a5bae6c99fcad08cac486eb2a48060b023d8730bf1d82fe60a2f036e6f52a5bff95f43bbe088933f" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "f4d84ed3e564c102600a795eaa9b1eaf4ad12f1a4deca1d042a0a2750ddf6201db03073d8bf553cb9dde48a1b0083827a609f7242b86584cc180964ae794b12ce55661e00e36a6ba4dbc389e6a5a85f1b45df9af7ead1b0a54db56e68639b9d438a91504e82c35d40c7bc7e048a53ac0b04accd0dadf4ac9884b0ca0e3cb5ba4336e3581be4c4760a553823ffa283a1120d4e145af56a59f2533903650f0b9e9ad9fe2e8a3c3c3dd03a1fcb709032c8835324839c735b0c051d0cbd8b5d867617c11023432e4bd275d3d0eb98a0b6cf58071a5b712922f2bc751ac7c2588c447444cde2f37a8ea5ec126425bf517e0d17c9e2999f52fee14b3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2ccea21bac9c2b70d3923309cbf2d7cb7abd1fcc8b8b002688870a80029c62397350c3c898194e5deea360bb963d26d485cb7963f8167586976ec0556950b2e86135f4a2800991ce8473bfd44a3c5e937a48b5e355ba5141bccf2131a83988d9d2a9e8e7635a956105b3512c05ef708139ced51d7a4e204c12d8a49a21e8dc6de2629a2fd092326885d9f218745fe09f6d91fb6afce250a30a63689534b6be1f26899ffa3767d835cf586aa47776700f94241bc999b1e3deefe188f37ff734f5f16ee6a00914323dc7b8a143c9137cdcc5cd08ae9566f04bb2941532674c97dff6ffa5ce3405ef8e5d27ec403114253dd6394c0167d72a0044c5" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "2b681c6398aee63bf862770341648bbcd31d7de7903c5903fe3d9469311320bb24d914f2af0cdca199c97214c7c679dc32a2800ba484a03c010ea6be3bb9f2c87e30a98b606050b8a3f297f12b8f92caaeceb3e844652115934874e0a1ab093a73d759b53f6a6c3096940dd22c2bb96ce6820a7b9c6d71a208de9892aa6a7209b0fff56a0cafea52b952cdd6f5752cff3309d448800b4e4c878aa595595b56b12b83fcd6ca89520c7da664e449d7b4438fc455888aad5de0fad9a06eed14afd3513b5ebbffe01775549b701181bd26370764f56eba52fdb24286ad1ac0f5418a7c429f7dfc7f3168437fa8eed7a2ed7c723a485e4c3ed14dea2e07" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "aadfd505a89f4aade2c3018258a7e039401b1fc6a7f3d87910dddbb880d372ec8a13c70d92245de5b8e5f9a285c33b99dc82fa2b22decee72b93a72211656ad7a52696c8e570f78be28c0e427a371dafde856e8d5ed24f83b0660b51e7fac05d93a8666dfde6def59af863f80f3e5f6801182c87422203df390dcb736b8f830052a8832eeeb0b4e27e732aaf793d166b5a3ec7745aeef3766937c2b75a276bddd145f6010c29d035e343e267cb2d828436876ec3a7ebe3b6347d4172f7a99d6821ce152e039e53deb33340b324c7f068ffb94b3cde35a8eaa12d15c3806a7ad0acec3e8c7078c1d32a28fd3eec9f32cb86e4c22166ff69e83785e851" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1605b8cce529a9d6262fd4390d9e4ae5e14e0adc0ec89b028ef68dd0f373ea259aaa96f2967091dd0874c0105385e9e6da9ca68297c31afa44ef834535fb302ce5b4e49edacbbdf359fe1228a8172495b3e57014c27edd58b685110980056c50c398a64f4923f2d720b4df16d75cb36b4233660694182099c35028a972519c24764fc94e18e582b24deb3491535fc06b83837c7958522800e822201d694af0bd0aa3834e17d4b1ba36f470905ae5f8bbeeb6c4c8604d8af02baa347b07086d6989867ddd5e8e8ed7740c3469bfa2810519c55c6add1332c4c54ee9097961d6741cb12a09713a0d07645f784f42f5ad94b48b836b34263130b0483f15e3" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "ff9c6125b2f60bfd6c2427b279df070e430075096647599bdc68c531152c58e13858b82385d78c856092d6c74106e87ccf51ac7e673936332d9b223444eaa0e762ee258d8a733d3a515ec68ed73285e5ca183ae3278b4820b0ab2797feb1e7d8cc864df585dfb5ebe02a993325a9ad5e2d7d49d3132cf66013898351d044e0fe908ccdfeeebf651983601e3673a1f92d36510c0cc19b2e75856db8e4a41f92a51efa66d6cc22e414944c2c34a5a89ccde0be76f51410824e330d8e7c613194338c93732e8aea651fca18bcf1ac1824340c5553aff1e58d4ab8d7c8842b4712021e517cd6c140f6743c69c7bee05b10a8f24050a8caa4f96d1664909c5a06" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "6e85c2f8e1fdc3aaeb969da1258cb504bbf0070cd03d23b3fb5ee08feea5ee2e0ee1c71a5d0f4f701b351f4e4b4d74cb1e2ae6184814f77b62d2f08134b7236ebf6b67d8a6c9f01b4248b30667c555f5d8646dbfe291151b23c9c9857e33a4d5c847be29a5ee7b402e03bac02d1a4319acc0dd8f25e9c7a266f5e5c896cc11b5b238df96a0963ae806cb277abc515c298a3e61a3036b177acf87a56ca4478c4c6d0d468913de602ec891318bbaf52c97a77c35c5b7d164816cf24e4c4b0b5f45853882f716d61eb947a45ce2efa78f1c70a918512af1ad536cbe6148083385b34e207f5f690d7a954021e4b5f4258a385fd8a87809a481f34202af4caccb82" +}, +{ + "hash": "blake2xb", + "in": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", + "key": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f", + "out": "1e9b2c454e9de3a2d723d850331037dbf54133dbe27488ff757dd255833a27d8eb8a128ad12d0978b6884e25737086a704fb289aaaccf930d5b582ab4df1f55f0c429b6875edec3fe45464fa74164be056a55e243c4222c586bec5b18f39036aa903d98180f24f83d09a454dfa1e03a60e6a3ba4613e99c35f874d790174ee48a557f4f021ade4d1b278d7997ef094569b37b3db0505951e9ee8400adaea275c6db51b325ee730c69df97745b556ae41cd98741e28aa3a49544541eeb3da1b1e8fa4e8e9100d66dd0c7f5e2c271b1ecc077de79c462b9fe4c273543ecd82a5bea63c5acc01eca5fb780c7d7c8c9fe208ae8bd50cad1769693d92c6c8649d20d8" +} +] diff --git a/src/plonk/blake2_const/tests/fuzz_many.rs b/src/plonk/blake2_const/tests/fuzz_many.rs new file mode 100644 index 000000000..2220a751b --- /dev/null +++ b/src/plonk/blake2_const/tests/fuzz_many.rs @@ -0,0 +1,208 @@ +use arrayvec::ArrayVec; +use rand::Rng; +use rand::RngCore; +use rand::SeedableRng; + +// Do more tests in release mode, but try to keep execution time under 1 sec. +#[cfg(debug_assertions)] +const NUM_TESTS: usize = 1_000; +#[cfg(not(debug_assertions))] +const NUM_TESTS: usize = 100_000; + +const BLAKE2B_MAX_LEN: usize = 3 * blake2b_simd::BLOCKBYTES; +const BLAKE2B_MAX_N: usize = 2 * blake2b_simd::many::MAX_DEGREE; + +fn random_params_blake2b(rng: &mut rand_chacha::ChaChaRng) -> blake2b_simd::Params { + let mut params = blake2b_simd::Params::new(); + // hash_length, key, and last_node are all things that need to be passed + // from the Params through to the State or whatever. Randomize those. + // Everything else just winds up in the state words and doesn't really need + // to be exercised here. + params.hash_length(rng.gen_range(1, blake2b_simd::OUTBYTES + 1)); + if rng.gen() { + let len: usize = rng.gen_range(1, blake2b_simd::KEYBYTES + 1); + let key_buf = &[1; blake2b_simd::KEYBYTES]; + params.key(&key_buf[..len]); + } + params.last_node(rng.gen()); + params +} + +fn with_random_inputs_blake2b(mut f: impl FnMut(&[blake2b_simd::Params], &[&[u8]])) { + let mut rng = rand_chacha::ChaChaRng::seed_from_u64(0); + + // Generate randomized input buffers to reuse in each test case. + let mut input_bufs = [[0; BLAKE2B_MAX_LEN]; BLAKE2B_MAX_N]; + for input in input_bufs.iter_mut() { + rng.fill_bytes(input); + } + + for _ in 0..NUM_TESTS { + // Select a random number of random length input slices from the + // buffers. + let num_inputs: usize = rng.gen_range(0, BLAKE2B_MAX_N + 1); + let mut inputs = ArrayVec::<[&[u8]; BLAKE2B_MAX_N]>::new(); + for i in 0..num_inputs { + let input_length = rng.gen_range(0, BLAKE2B_MAX_LEN + 1); + inputs.push(&input_bufs[i][..input_length]); + } + + // For each input slice, create a random Params object. + let mut params = ArrayVec::<[blake2b_simd::Params; BLAKE2B_MAX_N]>::new(); + for _ in 0..num_inputs { + params.push(random_params_blake2b(&mut rng)); + } + + f(¶ms, &inputs); + } +} + +#[test] +fn fuzz_blake2b_hash_many() { + with_random_inputs_blake2b(|params, inputs| { + // Compute the hash of each input independently. + let mut expected = ArrayVec::<[blake2b_simd::Hash; BLAKE2B_MAX_N]>::new(); + for (param, input) in params.iter().zip(inputs.iter()) { + expected.push(param.hash(input)); + } + + // Now compute the same hashes in a batch, and check that this gives + // the same result. + let mut jobs: ArrayVec<[blake2b_simd::many::HashManyJob; BLAKE2B_MAX_N]> = inputs + .iter() + .zip(params.iter()) + .map(|(input, param)| blake2b_simd::many::HashManyJob::new(param, input)) + .collect(); + blake2b_simd::many::hash_many(&mut jobs); + for i in 0..jobs.len() { + assert_eq!(&expected[i], &jobs[i].to_hash(), "job {} mismatch", i); + } + }); +} + +#[test] +fn fuzz_blake2b_update_many() { + with_random_inputs_blake2b(|params, inputs| { + // Compute the hash of each input independently. Feed each into the + // state twice, to exercise buffering. + let mut expected = ArrayVec::<[blake2b_simd::Hash; BLAKE2B_MAX_N]>::new(); + for (param, input) in params.iter().zip(inputs.iter()) { + let mut state = param.to_state(); + state.update(input); + state.update(input); + expected.push(state.finalize()); + } + + // Now compute the same hashes in a batch, and check that this gives + // the same result. + let mut states = ArrayVec::<[blake2b_simd::State; BLAKE2B_MAX_N]>::new(); + for param in params { + states.push(param.to_state()); + } + blake2b_simd::many::update_many(states.iter_mut().zip(inputs.iter())); + blake2b_simd::many::update_many(states.iter_mut().zip(inputs.iter())); + for i in 0..states.len() { + assert_eq!(2 * inputs[i].len() as u128, states[i].count()); + assert_eq!(&expected[i], &states[i].finalize(), "state {} mismatch", i); + } + }); +} + +const BLAKE2S_MAX_LEN: usize = 3 * blake2s_simd::BLOCKBYTES; +const BLAKE2S_MAX_N: usize = 2 * blake2s_simd::many::MAX_DEGREE; + +fn random_params_blake2s(rng: &mut rand_chacha::ChaChaRng) -> blake2s_simd::Params { + let mut params = blake2s_simd::Params::new(); + // hash_length, key, and last_node are all things that need to be passed + // from the Params through to the State or whatever. Randomize those. + // Everything else just winds up in the state words and doesn't really need + // to be exercised here. + params.hash_length(rng.gen_range(1, blake2s_simd::OUTBYTES + 1)); + if rng.gen() { + let len: usize = rng.gen_range(1, blake2s_simd::KEYBYTES + 1); + let key_buf = &[1; blake2s_simd::KEYBYTES]; + params.key(&key_buf[..len]); + } + params.last_node(rng.gen()); + params +} + +fn with_random_inputs_blake2s(mut f: impl FnMut(&[blake2s_simd::Params], &[&[u8]])) { + let mut rng = rand_chacha::ChaChaRng::seed_from_u64(0); + + // Generate randomized input buffers to reuse in each test case. + let mut input_bufs = [[0; BLAKE2S_MAX_LEN]; BLAKE2S_MAX_N]; + for input in input_bufs.iter_mut() { + rng.fill_bytes(input); + } + + for _ in 0..NUM_TESTS { + // Select a random number of random length input slices from the + // buffers. + let num_inputs: usize = rng.gen_range(0, BLAKE2S_MAX_N + 1); + let mut inputs = ArrayVec::<[&[u8]; BLAKE2S_MAX_N]>::new(); + for i in 0..num_inputs { + let input_length = rng.gen_range(0, BLAKE2S_MAX_LEN + 1); + inputs.push(&input_bufs[i][..input_length]); + } + + // For each input slice, create a random Params object. + let mut params = ArrayVec::<[blake2s_simd::Params; BLAKE2S_MAX_N]>::new(); + for _ in 0..num_inputs { + params.push(random_params_blake2s(&mut rng)); + } + + f(¶ms, &inputs); + } +} + +#[test] +fn fuzz_blake2s_hash_many() { + with_random_inputs_blake2s(|params, inputs| { + // Compute the hash of each input independently. + let mut expected = ArrayVec::<[blake2s_simd::Hash; BLAKE2S_MAX_N]>::new(); + for (param, input) in params.iter().zip(inputs.iter()) { + expected.push(param.hash(input)); + } + + // Now compute the same hashes in a batch, and check that this gives + // the same result. + let mut jobs: ArrayVec<[blake2s_simd::many::HashManyJob; BLAKE2S_MAX_N]> = inputs + .iter() + .zip(params.iter()) + .map(|(input, param)| blake2s_simd::many::HashManyJob::new(param, input)) + .collect(); + blake2s_simd::many::hash_many(&mut jobs); + for i in 0..jobs.len() { + assert_eq!(&expected[i], &jobs[i].to_hash(), "job {} mismatch", i); + } + }); +} + +#[test] +fn fuzz_blake2s_update_many() { + with_random_inputs_blake2s(|params, inputs| { + // Compute the hash of each input independently. Feed each into the + // state twice, to exercise buffering. + let mut expected = ArrayVec::<[blake2s_simd::Hash; BLAKE2S_MAX_N]>::new(); + for (param, input) in params.iter().zip(inputs.iter()) { + let mut state = param.to_state(); + state.update(input); + state.update(input); + expected.push(state.finalize()); + } + + // Now compute the same hashes in a batch, and check that this gives + // the same result. + let mut states = ArrayVec::<[blake2s_simd::State; BLAKE2S_MAX_N]>::new(); + for param in params { + states.push(param.to_state()); + } + blake2s_simd::many::update_many(states.iter_mut().zip(inputs.iter())); + blake2s_simd::many::update_many(states.iter_mut().zip(inputs.iter())); + for i in 0..states.len() { + assert_eq!(2 * inputs[i].len() as u64, states[i].count()); + assert_eq!(&expected[i], &states[i].finalize(), "state {} mismatch", i); + } + }); +} diff --git a/src/plonk/blake2_const/tests/vector_tests.rs b/src/plonk/blake2_const/tests/vector_tests.rs new file mode 100644 index 000000000..c120df415 --- /dev/null +++ b/src/plonk/blake2_const/tests/vector_tests.rs @@ -0,0 +1,276 @@ +//! The tests in this file run the standard set of test vectors from upstream: +//! https://github.com/BLAKE2/BLAKE2/blob/320c325437539ae91091ce62efec1913cd8093c2/testvectors/blake2-kat.json +//! +//! Currently those cover default hashing and keyed hashing in BLAKE2b and BLAKE2bp. But they don't +//! test the other associated data features, and they don't test any inputs longer than a couple +//! blocks. + +use lazy_static::lazy_static; +use serde::{Deserialize, Serialize}; + +lazy_static! { + static ref TEST_CASES: Vec = + serde_json::from_str(include_str!("blake2-kat.json")).unwrap(); +} + +#[derive(Debug, Serialize, Deserialize)] +struct TestCase { + hash: String, + #[serde(rename = "in")] + in_: String, + key: String, + out: String, +} + +#[test] +fn blake2b_vectors() { + let mut test_num = 0u64; + for case in TEST_CASES.iter() { + if &case.hash == "blake2b" { + test_num += 1; + println!("input {:?}, key {:?}", case.in_, case.key); + + let input_bytes = hex::decode(&case.in_).unwrap(); + let mut params = blake2b_simd::Params::new(); + if !case.key.is_empty() { + let key_bytes = hex::decode(&case.key).unwrap(); + params.key(&key_bytes); + } + + // Assert the all-at-once result. + assert_eq!(case.out, &*params.hash(&input_bytes).to_hex()); + + // Assert the State result. + let mut state = params.to_state(); + state.update(&input_bytes); + assert_eq!(case.out, &*state.finalize().to_hex()); + assert_eq!(input_bytes.len() as u128, state.count()); + } + } + + // Make sure we don't accidentally skip all the tests somehow. If the + // number of test vectors changes in the future, we'll need to update this + // count. + assert_eq!(512, test_num); +} + +#[test] +fn blake2bp_vectors() { + let mut test_num = 0u64; + for case in TEST_CASES.iter() { + if &case.hash == "blake2bp" { + test_num += 1; + println!("input {:?}, key {:?}", case.in_, case.key); + + let input_bytes = hex::decode(&case.in_).unwrap(); + let mut params = blake2b_simd::blake2bp::Params::new(); + if !case.key.is_empty() { + let key_bytes = hex::decode(&case.key).unwrap(); + params.key(&key_bytes); + } + + // Assert the all-at-once result. + assert_eq!(case.out, &*params.hash(&input_bytes).to_hex()); + + // Assert the State result. + let mut state = params.to_state(); + state.update(&input_bytes); + assert_eq!(case.out, &*state.finalize().to_hex()); + assert_eq!(input_bytes.len() as u128, state.count()); + } + } + + // Make sure we don't accidentally skip all the tests somehow. If the + // number of test vectors changes in the future, we'll need to update this + // count. + assert_eq!(512, test_num); +} + +#[test] +fn blake2s_vectors() { + let mut test_num = 0u64; + for case in TEST_CASES.iter() { + if &case.hash == "blake2s" { + test_num += 1; + println!("input {:?}, key {:?}", case.in_, case.key); + + let input_bytes = hex::decode(&case.in_).unwrap(); + let mut params = blake2s_simd::Params::new(); + if !case.key.is_empty() { + let key_bytes = hex::decode(&case.key).unwrap(); + params.key(&key_bytes); + } + + // Assert the all-at-once result. + assert_eq!(case.out, &*params.hash(&input_bytes).to_hex()); + + // Assert the State result. + let mut state = params.to_state(); + state.update(&input_bytes); + assert_eq!(case.out, &*state.finalize().to_hex()); + assert_eq!(input_bytes.len() as u64, state.count()); + } + } + + // Make sure we don't accidentally skip all the tests somehow. If the + // number of test vectors changes in the future, we'll need to update this + // count. + assert_eq!(512, test_num); +} + +#[test] +fn blake2sp_vectors() { + let mut test_num = 0u64; + for case in TEST_CASES.iter() { + if &case.hash == "blake2sp" { + test_num += 1; + println!("input {:?}, key {:?}", case.in_, case.key); + + let input_bytes = hex::decode(&case.in_).unwrap(); + let mut params = blake2s_simd::blake2sp::Params::new(); + if !case.key.is_empty() { + let key_bytes = hex::decode(&case.key).unwrap(); + params.key(&key_bytes); + } + + // Assert the all-at-once result. + assert_eq!(case.out, &*params.hash(&input_bytes).to_hex()); + + // Assert the State result. + let mut state = params.to_state(); + state.update(&input_bytes); + assert_eq!(case.out, &*state.finalize().to_hex()); + assert_eq!(input_bytes.len() as u64, state.count()); + } + } + + // Make sure we don't accidentally skip all the tests somehow. If the + // number of test vectors changes in the future, we'll need to update this + // count. + assert_eq!(512, test_num); +} + +fn blake2x_test Vec, F2: Fn(&[u8], u64, usize) -> Vec>( + h0_hasher: F, + b2_hasher: F2, + variant_hash_length: usize, + variant_name: &str, +) { + let mut test_num = 0u64; + for case in TEST_CASES.iter() { + if &case.hash == variant_name { + test_num += 1; + + let input_bytes = hex::decode(&case.in_).unwrap(); + let key = if !case.key.is_empty() { + hex::decode(&case.key).unwrap() + } else { + vec![] + }; + + let output_length = case.out.len() / 2; + + // BLAKE2X divides the underlying hash node_offset into two parts - node_offset + // and xof_digest_length. This is the encoding of xof_digest_length in the + // correct position in the node_offset. + let combined_node_offset_xof_length = (output_length as u64) << 32; + let h0 = h0_hasher(&input_bytes, &key, combined_node_offset_xof_length); + + let mut buf = vec![]; + let mut b2_hash_index = 0; + while buf.len() < output_length { + let hash_length = { + // Is this the last hash and the digest length doesn't divide the output + // length? + if output_length - buf.len() < variant_hash_length + && (output_length % variant_hash_length) != 0 + { + output_length % variant_hash_length + } else { + variant_hash_length + } + }; + + let b2_out = b2_hasher( + &h0, + (b2_hash_index as u64) | combined_node_offset_xof_length, + hash_length, + ); + buf.extend_from_slice(&b2_out); + b2_hash_index += 1; + } + assert_eq!(case.out, hex::encode(&buf[..output_length])); + } + } + + // Make sure we don't accidentally skip all the tests somehow. If the + // number of test vectors changes in the future, we'll need to update this + // count. + assert_eq!(512, test_num); +} + +#[test] +fn blake2xs_vectors() { + let blake2xs_h0_hasher = + |input_bytes: &[u8], key: &[u8], combined_node_offset_xof_length: u64| -> Vec { + let mut params = blake2s_simd::Params::new(); + let h0 = params + .key(key) + .hash_length(32) + .node_offset(combined_node_offset_xof_length) + .hash(&input_bytes) + .as_bytes() + .to_vec(); + h0 + }; + let blake2xs_b2_hasher = + |input_bytes: &[u8], combined_node_offset_xof_length: u64, hash_length: usize| -> Vec { + let mut params = blake2s_simd::Params::new(); + let b2_out = params + .hash_length(hash_length) + .max_leaf_length(32) + .inner_hash_length(32) + .fanout(0) + .max_depth(0) + .node_offset(combined_node_offset_xof_length) + .hash(&input_bytes) + .as_bytes() + .to_vec(); + b2_out + }; + + blake2x_test(blake2xs_h0_hasher, blake2xs_b2_hasher, 32, "blake2xs"); +} + +#[test] +fn blake2xb_vectors() { + let blake2xb_h0_hasher = + |input_bytes: &[u8], key: &[u8], combined_node_offset_xof_length: u64| -> Vec { + let mut params = blake2b_simd::Params::new(); + let h0 = params + .key(key) + .hash_length(64) + .node_offset(combined_node_offset_xof_length) + .hash(&input_bytes) + .as_bytes() + .to_vec(); + h0 + }; + let blake2xb_b2_hasher = + |input_bytes: &[u8], combined_node_offset_xof_length: u64, hash_length: usize| -> Vec { + let mut params = blake2b_simd::Params::new(); + let b2_out = params + .hash_length(hash_length) + .max_leaf_length(64) + .inner_hash_length(64) + .fanout(0) + .max_depth(0) + .node_offset(combined_node_offset_xof_length) + .hash(&input_bytes) + .as_bytes() + .to_vec(); + b2_out + }; + + blake2x_test(blake2xb_h0_hasher, blake2xb_b2_hasher, 64, "blake2xb"); +} diff --git a/src/plonk/commitments/mod.rs b/src/plonk/commitments/mod.rs new file mode 100644 index 000000000..7ba4e29b1 --- /dev/null +++ b/src/plonk/commitments/mod.rs @@ -0,0 +1,28 @@ +use crate::pairing::ff::PrimeField; + +use crate::plonk::polynomials::*; +use crate::plonk::commitments::transcript::*; + +pub mod transparent; + +pub mod transcript; + +pub trait CommitmentScheme { + type Commitment: std::fmt::Debug; + type OpeningProof; + type IntermediateData; + type Meta: Clone; + type Prng: Prng; + + const REQUIRES_PRECOMPUTATION: bool; + const IS_HOMOMORPHIC: bool; + + fn new_for_size(max_degree_plus_one: usize, meta: Self::Meta) -> Self; + fn precompute(&self, poly: &Polynomial) -> Option; + fn commit_single(&self, poly: &Polynomial) -> (Self::Commitment, Option); + fn commit_multiple(&self, polynomials: Vec<&Polynomial>, degrees: Vec, aggregation_coefficient: F) -> (Self::Commitment, Option>); + fn open_single(&self, poly: &Polynomial, at_point: F, opening_value: F, data: &Option<&Self::IntermediateData>, prng: &mut Self::Prng) -> Self::OpeningProof; + fn open_multiple(&self, polynomials: Vec<&Polynomial>, degrees: Vec, aggregation_coefficient: F, at_points: Vec, opening_values: Vec, data: &Option>, prng: &mut Self::Prng) -> Self::OpeningProof; + fn verify_single(&self, commitment: &Self::Commitment, at_point: F, claimed_value: F, proof: &Self::OpeningProof, prng: &mut Self::Prng) -> bool; + fn verify_multiple_openings(&self, commitments: Vec<&Self::Commitment>, at_points: Vec, claimed_values: &Vec, aggregation_coefficient: F, proof: &Self::OpeningProof, prng: &mut Self::Prng) -> bool; +} \ No newline at end of file diff --git a/src/plonk/commitments/transcript/keccak_transcript.rs b/src/plonk/commitments/transcript/keccak_transcript.rs new file mode 100644 index 000000000..163a5d7c6 --- /dev/null +++ b/src/plonk/commitments/transcript/keccak_transcript.rs @@ -0,0 +1,139 @@ +use tiny_keccak::Keccak; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use crate::byteorder::{ByteOrder, BigEndian}; + +use super::*; + +#[derive(Clone)] +pub struct RollingKeccakTranscript { + state_part_0: [u8; 32], + state_part_1: [u8; 32], + challenge_counter: u32, + _marker: std::marker::PhantomData +} + +impl RollingKeccakTranscript { + const SHAVE_BITS: u32 = 256 - F::CAPACITY; + // const REPR_SIZE: usize = std::mem::size_of::(); + const REPR_SIZE: usize = (((F::NUM_BITS as usize)/ 64) + 1) * 8; + const DST_0_TAG: u32 = 0; + const DST_1_TAG: u32 = 1; + const CHALLENGE_DST_TAG: u32 = 2; + + fn update(&mut self, bytes: &[u8]){ + let old_state_0 = self.state_part_0; + + let mut input = vec![0u8; bytes.len() + 32 + 32 + 4]; + BigEndian::write_u32(&mut input[0..4], Self::DST_0_TAG); + input[4..36].copy_from_slice(&old_state_0[..]); + input[36..68].copy_from_slice(&self.state_part_1[..]); + input[68..].copy_from_slice(bytes); + + let mut hasher = Keccak::new_keccak256(); + hasher.update(&input); + hasher.finalize(&mut self.state_part_0); + + let mut input = vec![0u8; bytes.len() + 32 + 32 + 4]; + BigEndian::write_u32(&mut input[0..4], Self::DST_1_TAG); + input[4..36].copy_from_slice(&old_state_0[..]); + input[36..68].copy_from_slice(&self.state_part_1[..]); + input[68..].copy_from_slice(bytes); + + let mut hasher = Keccak::new_keccak256(); + hasher.update(&input); + hasher.finalize(&mut self.state_part_1); + } + + fn query(&mut self) -> [u8; 32] { + let mut input = vec![0u8; 4 + 32 + 32 + 4]; + BigEndian::write_u32(&mut input[0..4], Self::CHALLENGE_DST_TAG); + input[4..36].copy_from_slice(&self.state_part_0[..]); + input[36..68].copy_from_slice(&self.state_part_1[..]); + BigEndian::write_u32(&mut input[68..72], self.challenge_counter); + + self.challenge_counter += 1; + + let mut value = [0u8; 32]; + let mut hasher = Keccak::new_keccak256(); + hasher.update(&input); + hasher.finalize(&mut value); + + value + } +} + +impl Prng for RollingKeccakTranscript { + type Input = [u8; 32]; + type InitializationParameters = (); + + fn new() -> Self { + assert!(F::NUM_BITS < 256); + Self { + state_part_0: [0u8; 32], + state_part_1: [0u8; 32], + challenge_counter: 0, + _marker: std::marker::PhantomData + } + } + + fn commit_input(&mut self, input: &Self::Input) { + self.commit_bytes(input) + } + + fn get_challenge(&mut self) -> F { + let value = self.query(); + + // let mut value: [u8; 32] = [0; 32]; + // self.state.finalize(&mut value); + + // self.state = Keccak::new_keccak256(); + // self.state.update(&value); + + let mut repr = F::Repr::default(); + let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); + repr.read_be(&value[..]).expect("will read"); + let last_limb_idx = repr.as_ref().len() - 1; + repr.as_mut()[last_limb_idx] &= shaving_mask; + let value = F::from_repr(repr).expect("in a field"); + + // println!("Outputting {}", value); + + value + } +} + +impl Transcript for RollingKeccakTranscript { + fn commit_bytes(&mut self, bytes: &[u8]) { + // println!("Committing bytes {:?}", bytes); + // self.state.update(&bytes); + self.update(&bytes); + } + + fn commit_field_element(&mut self, element: &F) { + // dbg!(element); + // println!("Committing field element {:?}", element); + let repr = element.into_repr(); + let mut bytes: Vec = vec![0u8; Self::REPR_SIZE]; + repr.write_be(&mut bytes[..]).expect("should write"); + + // self.state.update(&bytes[..]); + self.update(&bytes); + } + + fn get_challenge_bytes(&mut self) -> Vec { + let value = self.query(); + // let value = *(self.state.finalize().as_array()); + // self.state.update(&value[..]); + + // println!("Outputting {:?}", value); + + Vec::from(&value[..]) + } + + fn commit_fe(&mut self, element: &FF) { + let repr = element.into_repr(); + let mut bytes: Vec = vec![0u8; Self::REPR_SIZE]; + repr.write_be(&mut bytes[..]).expect("should write"); + self.update(&bytes); + } +} diff --git a/src/plonk/commitments/transcript/mod.rs b/src/plonk/commitments/transcript/mod.rs new file mode 100644 index 000000000..7f50f752e --- /dev/null +++ b/src/plonk/commitments/transcript/mod.rs @@ -0,0 +1,149 @@ +use blake2s_simd::{Params, State}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; + +pub mod prng; +pub mod keccak_transcript; + +#[cfg(feature = "redshift")] +pub mod rescue_transcript; +#[cfg(feature = "redshift")] +pub mod poseidon_transcript; + +lazy_static! { + static ref TRANSCRIPT_BLAKE2S_PARAMS: State = { + Params::new() + .hash_length(32) + .key(b"Squeamish Ossifrage") + .personal(b"Shaftoe") + .to_state() + }; +} + +pub trait Prng: Sized + Clone { + type Input; + type InitializationParameters: Clone; + fn new() -> Self; + fn new_from_params(_params: Self::InitializationParameters) -> Self { + unimplemented!("not implemented by default"); + } + fn commit_input(&mut self, input: &Self::Input); + fn get_challenge(&mut self) -> F; +} + +pub trait Transcript: Prng + Sized + Clone { + fn commit_bytes(&mut self, bytes: &[u8]); + fn commit_field_element(&mut self, element: &F); + fn get_challenge_bytes(&mut self) -> Vec; + fn commit_fe(&mut self, element: &FF); +} + +#[derive(Clone)] +pub struct Blake2sTranscript { + state: State, + _marker: std::marker::PhantomData +} + +impl Blake2sTranscript { + const SHAVE_BITS: u32 = 256 - F::CAPACITY; + // const REPR_SIZE: usize = std::mem::size_of::(); + const REPR_SIZE: usize = (((F::NUM_BITS as usize)/ 64) + 1) * 8; +} + + +// impl Prng for Blake2sTranscript { +// type Input = F; + +// fn new() -> Self { +// assert!(F::NUM_BITS < 256); +// let state = (*TRANSCRIPT_BLAKE2S_PARAMS).clone(); +// Self { +// state, +// _marker: std::marker::PhantomData +// } +// } + +// fn commit_input(&mut self, input: &Self::Input) { +// self.commit_field_element(input) +// } + +// fn get_challenge(&mut self) -> F { +// let value = *(self.state.finalize().as_array()); +// self.state.update(&value[..]); + +// let mut repr = F::Repr::default(); +// let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); +// repr.read_be(&value[..]).expect("will read"); +// let last_limb_idx = repr.as_ref().len() - 1; +// repr.as_mut()[last_limb_idx] &= shaving_mask; +// let value = F::from_repr(repr).expect("in a field"); + +// value +// } +// } + +impl Prng for Blake2sTranscript { + type Input = [u8; 32]; + type InitializationParameters = (); + + fn new() -> Self { + assert!(F::NUM_BITS < 256); + let state = (*TRANSCRIPT_BLAKE2S_PARAMS).clone(); + Self { + state, + _marker: std::marker::PhantomData + } + } + + fn commit_input(&mut self, input: &Self::Input) { + self.commit_bytes(input) + } + + fn get_challenge(&mut self) -> F { + let value = *(self.state.finalize().as_array()); + self.state.update(&value[..]); + + let mut repr = F::Repr::default(); + let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); + repr.read_be(&value[..]).expect("will read"); + let last_limb_idx = repr.as_ref().len() - 1; + repr.as_mut()[last_limb_idx] &= shaving_mask; + let value = F::from_repr(repr).expect("in a field"); + + // println!("Outputting {}", value); + + value + } +} + +impl Transcript for Blake2sTranscript { + fn commit_bytes(&mut self, bytes: &[u8]) { + // println!("Committing bytes {:?}", bytes); + self.state.update(&bytes); + } + + fn commit_field_element(&mut self, element: &F) { + // println!("Committing field element {:?}", element); + let repr = element.into_repr(); + let mut bytes: Vec = vec![0u8; Self::REPR_SIZE]; + repr.write_be(&mut bytes[..]).expect("should write"); + + self.state.update(&bytes[..]); + } + + fn get_challenge_bytes(&mut self) -> Vec { + let value = *(self.state.finalize().as_array()); + self.state.update(&value[..]); + + // println!("Outputting {:?}", value); + + Vec::from(&value[..]) + } + + fn commit_fe(&mut self, element: &FF) { + let repr = element.into_repr(); + let mut bytes: Vec = vec![0u8; Self::REPR_SIZE]; + repr.write_be(&mut bytes[..]).expect("should write"); + + self.state.update(&bytes[..]); + } +} diff --git a/src/plonk/commitments/transcript/poseidon_transcript.rs b/src/plonk/commitments/transcript/poseidon_transcript.rs new file mode 100644 index 000000000..09a66c50f --- /dev/null +++ b/src/plonk/commitments/transcript/poseidon_transcript.rs @@ -0,0 +1,48 @@ +use poseidon_hash::{PoseidonEngine, PoseidonHashParams, StatefulSponge}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use crate::byteorder::{ByteOrder, BigEndian}; + +use super::*; + +#[derive(Clone)] +pub struct PoseidonTranscript<'a, E: PoseidonEngine> { + state: StatefulSponge<'a, E>, +} + +impl<'a, E: PoseidonEngine> PoseidonTranscript<'a, E> { + pub fn from_params(params: &'a E::Params) -> Self { + let stateful = StatefulSponge::new(params); + + Self { + state: stateful + } + } +} + + +impl<'a, E: PoseidonEngine> Prng for PoseidonTranscript<'a, E> { + type Input = E::Fr; + type InitializationParameters = &'a E::Params; + + fn new() -> Self { + unimplemented!() + } + + fn new_from_params(params: Self::InitializationParameters) -> Self { + let stateful = StatefulSponge::new(params); + + Self { + state: stateful + } + } + + fn commit_input(&mut self, input: &Self::Input) { + self.state.absorb_single_value(*input); + } + + fn get_challenge(&mut self) -> E::Fr { + let value = self.state.squeeze_out_single(); + + value + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transcript/prng.rs b/src/plonk/commitments/transcript/prng.rs new file mode 100644 index 000000000..721c92c9f --- /dev/null +++ b/src/plonk/commitments/transcript/prng.rs @@ -0,0 +1,61 @@ +use blake2s_simd::{Params, State}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use super::Prng; + +lazy_static! { + static ref STATELESS_PRNG_BLAKE2S_PARAMS: State = { + Params::new() + .hash_length(32) + .key(b"Squeamish Ossifrage") + .personal(b"S_Prng_F") + .to_state() + }; +} + +#[derive(Clone)] +pub struct StatelessBlake2sPrng { + state: State, + _marker: std::marker::PhantomData +} + +impl StatelessBlake2sPrng { + const SHAVE_BITS: u32 = 256 - F::CAPACITY; + // const REPR_SIZE: usize = std::mem::size_of::(); + const REPR_SIZE: usize = (((F::NUM_BITS as usize)/ 64) + 1) * 8; +} + +impl Prng for StatelessBlake2sPrng { + type Input = F; + type InitializationParameters = (); + + fn new() -> Self { + assert!(F::NUM_BITS < 256); + Self { + state: STATELESS_PRNG_BLAKE2S_PARAMS.clone(), + _marker: std::marker::PhantomData + } + } + + fn commit_input(&mut self, input: &Self::Input) { + let mut state = STATELESS_PRNG_BLAKE2S_PARAMS.clone(); + let repr = input.into_repr(); + let mut bytes: Vec = vec![0u8; Self::REPR_SIZE]; + repr.write_be(&mut bytes[..]).expect("should write"); + state.update(&bytes[..]); + self.state = state; + } + + fn get_challenge(&mut self) -> F { + let value = *(self.state.finalize().as_array()); + self.state = STATELESS_PRNG_BLAKE2S_PARAMS.clone(); + + let mut repr = F::Repr::default(); + let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); + repr.read_be(&value[..]).expect("will read"); + let last_limb_idx = repr.as_ref().len() - 1; + repr.as_mut()[last_limb_idx] &= shaving_mask; + let value = F::from_repr(repr).expect("in a field"); + + value + } +} diff --git a/src/plonk/commitments/transcript/rescue_transcript.rs b/src/plonk/commitments/transcript/rescue_transcript.rs new file mode 100644 index 000000000..9f4201221 --- /dev/null +++ b/src/plonk/commitments/transcript/rescue_transcript.rs @@ -0,0 +1,48 @@ +use rescue_hash::{RescueEngine, RescueHashParams, StatefulRescue}; +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use crate::byteorder::{ByteOrder, BigEndian}; + +use super::*; + +#[derive(Clone)] +pub struct RescueTranscript<'a, E: RescueEngine> { + state: StatefulRescue<'a, E>, +} + +impl<'a, E: RescueEngine> RescueTranscript<'a, E> { + pub fn from_params(params: &'a E::Params) -> Self { + let stateful = StatefulRescue::new(params); + + Self { + state: stateful + } + } +} + + +impl<'a, E: RescueEngine> Prng for RescueTranscript<'a, E> { + type Input = E::Fr; + type InitializationParameters = &'a E::Params; + + fn new() -> Self { + unimplemented!() + } + + fn new_from_params(params: Self::InitializationParameters) -> Self { + let stateful = StatefulRescue::new(params); + + Self { + state: stateful + } + } + + fn commit_input(&mut self, input: &Self::Input) { + self.state.absorb_single_value(*input); + } + + fn get_challenge(&mut self) -> E::Fr { + let value = self.state.squeeze_out_single(); + + value + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/coset_combining_fri/fri.rs b/src/plonk/commitments/transparent/fri/coset_combining_fri/fri.rs new file mode 100644 index 000000000..75b118285 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/coset_combining_fri/fri.rs @@ -0,0 +1,492 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop_compiler::*; +use crate::plonk::commitments::transparent::iop_compiler::coset_combining_blake2s_tree::*; +use crate::plonk::polynomials::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::utils::log2_floor; +use crate::plonk::commitments::transcript::Prng; +use crate::plonk::commitments::transparent::precomputations::*; +use super::*; + +pub struct CosetCombiningFriIop { + cosets_schedule: Vec, + _marker_f: std::marker::PhantomData, +} + +#[derive(Clone, Debug)] +pub struct CosetParams { + pub cosets_schedule: Vec, + pub coset_factor: F +} + +impl FriIop for CosetCombiningFriIop { + const DEGREE: usize = 2; + + type IopType = FriSpecificBlake2sTree; + type ProofPrototype = FRIProofPrototype; + type Proof = FRIProof; + type Params = CosetParams; + + fn proof_from_lde>::Commitment>, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P, + params: &Self::Params + ) -> Result { + Self::proof_from_lde_by_values( + lde_values, + lde_factor, + output_coeffs_at_degree_plus_one, + precomputations, + worker, + prng, + params + ) + } + + fn prototype_into_proof( + prototype: Self::ProofPrototype, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + params: &Self::Params + ) -> Result { + unimplemented!() + // prototype.produce_proof(iop_values, natural_first_element_indexes) + } + + fn get_fri_challenges>::Commitment>>( + proof: &Self::Proof, + prng: &mut P, + params: &Self::Params + ) -> Vec { + let mut fri_challenges = vec![]; + + for root in proof.roots.iter() { + let iop_challenge = { + prng.commit_input(&root); + prng.get_challenge() + }; + + fri_challenges.push(iop_challenge); + } + + fri_challenges + } + + fn verify_proof_with_challenges( + proof: &Self::Proof, + natural_element_indexes: Vec, + expected_value: &[F], + fri_challenges: &[F], + params: &Self::Params + ) -> Result { + unimplemented!() + // Self::verify_proof_queries(proof, natural_element_indexes, Self::DEGREE, expected_value, fri_challenges) + } +} + +use std::time::Instant; + +#[derive(PartialEq, Eq, Clone)] +pub struct FRIProofPrototype> { + // pub l0_commitment: I, + pub intermediate_commitments: Vec, + pub intermediate_values: Vec< Polynomial >, + pub challenges: Vec>, + pub final_root: I::Commitment, + pub final_coefficients: Vec, + pub initial_degree_plus_one: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub lde_factor: usize, +} + +impl> FriProofPrototype for FRIProofPrototype { + fn get_roots(&self) -> Vec { + let mut roots = vec![]; + // roots.push(self.l0_commitment.get_commitment().clone()); + for c in self.intermediate_commitments.iter() { + roots.push(c.get_commitment().clone()); + } + + roots + } + + fn get_final_root(&self) -> I::Commitment { + self.final_root.clone() + } + + fn get_final_coefficients(&self) -> Vec { + self.final_coefficients.clone() + } +} + +#[derive(PartialEq, Eq, Clone)] +pub struct FRIProof> { + pub queries: Vec>, + pub roots: Vec, + pub final_coefficients: Vec, + pub initial_degree_plus_one: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub lde_factor: usize, +} + +impl> FriProof for FRIProof { + fn get_final_coefficients(&self) -> &[F] { + &self.final_coefficients + } + + fn get_queries(&self) -> &Vec> { + &self.queries + } +} + +impl CosetCombiningFriIop { + pub fn proof_from_lde_by_values>::IopType as IopInstance>::Commitment>, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P, + params: &>::Params + ) -> Result>::IopType>, SynthesisError> { + let mut coset_schedule_index = 0; + let coset_factor = params.cosets_schedule[coset_schedule_index]; + + let mut total_wrap_factor = 1; + for s in params.cosets_schedule.iter() { + let coeff = 1 << *s; + total_wrap_factor *= coeff; + } + + let mut roots = vec![]; + // let tree_params = FriSpecificBlake2sTreeParams { + // values_per_leaf: (1 << coset_factor) + // }; + + // let l0_commitment = FriSpecificBlake2sTree::create(lde_values.as_ref(), &tree_params); + // let root = l0_commitment.get_commitment(); + // roots.push(root); + let initial_domain_size = lde_values.size(); + + assert_eq!(precomputations.domain_size(), initial_domain_size); + + let mut two = F::one(); + two.double(); + let two_inv = two.inverse().expect("should exist"); + + assert!(output_coeffs_at_degree_plus_one.is_power_of_two()); + assert!(lde_factor.is_power_of_two()); + + let initial_degree_plus_one = initial_domain_size / lde_factor; + assert_eq!(initial_degree_plus_one / total_wrap_factor, output_coeffs_at_degree_plus_one, + "number of FRI round does not match the ouput degree: initial degree+1 = {}, wrapping factor {}, output at degree+1 = {}", + initial_degree_plus_one, total_wrap_factor, output_coeffs_at_degree_plus_one); + + let mut intermediate_commitments = vec![]; + let mut intermediate_values = vec![]; + let mut challenges = vec![]; + let num_challenges = coset_factor; + let mut next_domain_challenges = { + // prng.commit_input(&l0_commitment.get_commitment()); + let mut challenges = vec![]; + for _ in 0..num_challenges { + challenges.push(prng.get_challenge()); + } + + challenges + }; + + challenges.push(next_domain_challenges.clone()); + + let mut values_slice = lde_values.as_ref(); + + let omegas_inv_bitreversed: &[F] = precomputations.omegas_inv_bitreversed(); + + // if we would precompute all N we would have + // [0, N/2, N/4, 3N/4, N/8, N/2 + N/8, N/8 + N/4, N/8 + N/4 + N/2, ...] + // but we only precompute half of them and have + // [0, N/4, N/8, N/8 + N/4, ...] + + let mut this_domain_size = lde_values.size(); + + // step 0: fold totally by 2 + // step 1: fold totally by 4 + // etc... + + let num_steps = params.cosets_schedule.len(); + + for (fri_step, coset_factor) in params.cosets_schedule.iter().enumerate() { + let coset_factor = *coset_factor; + let wrapping_factor = 1 << coset_factor; + let next_domain_size = this_domain_size / wrapping_factor; + let mut next_values = vec![F::zero(); next_domain_size]; + + // we combine like this with FRI trees being aware of the FRI computations + // next_value(omega**) + // / \ + // intermediate(omega*) intermediate(-omega*) + // / \ / \ + // this(omega) this(-omega) this(omega') this(-omega') + // + // so omega* = omega^2i. omega' = sqrt(-omega^2i) = sqrt(omega^(N/2 + 2i)) = omega^N/4 + i + // + // we expect values to come bitreversed, so this(omega) and this(-omega) are always adjustent to each other + // because in normal emumeration it would be elements b0XYZ and b1XYZ, and now it's bZYX0 and bZYX1 + // + // this(omega^(N/4 + i)) for b00YZ has a form b01YZ, so bitreversed it's bZY00 and bZY10 + // this(-omega^(N/4 + i)) obviously has bZY11, so they are all near in initial values + + worker.scope(next_values.len(), |scope, chunk| { + for (i, v) in next_values.chunks_mut(chunk).enumerate() { + let next_domain_challenges = next_domain_challenges.clone(); + scope.spawn(move |_| { + let initial_k = i*chunk; + let mut this_level_values = Vec::with_capacity(wrapping_factor); + let mut next_level_values = vec![F::zero(); wrapping_factor]; + for (j, v) in v.iter_mut().enumerate() { + let batch_id = initial_k + j; + let values_offset = batch_id*wrapping_factor; + for (wrapping_step, challenge) in next_domain_challenges.iter().enumerate() { + let base_omega_idx = (batch_id * wrapping_factor) >> (1 + wrapping_step); + let expected_this_level_values = wrapping_factor >> wrapping_step; + let expected_next_level_values = wrapping_factor >> (wrapping_step + 1); + let inputs = if wrapping_step == 0 { + &values_slice[values_offset..(values_offset + wrapping_factor)] + } else { + &this_level_values[..expected_this_level_values] + }; + + // imagine first FRI step, first wrapping step + // in values we have f(i), f(i + N/2), f(i + N/4), f(i + N/4 + N/2), f(i + N/8), ... + // so we need to use omega(i) for the first pair, omega(i + N/4) for the second, omega(i + N/8) + // on the next step we would have f'(2i), f'(2i + N/2), f'(2i + N/4), f'(2i + N/4 + N/2) + // so we would have to pick omega(2i) and omega(2i + N/4) + // this means LSB is always the same an only depend on the pair_idx below + // MSB is more tricky + // for a batch number 0 we have i = 0 + // for a batch number 1 due to bitreverse we have index equal to b000001xxx where LSB are not important in the batch + // such value actually gives i = bxxx100000 that is a bitreverse of the batch number with proper number of bits + // due to precomputed omegas also being bitreversed we just need a memory location b000001xxx >> 1 + + debug_assert_eq!(inputs.len() / 2, expected_next_level_values); + + for (pair_idx, (pair, o)) in inputs.chunks(2).zip(next_level_values[..expected_next_level_values].iter_mut()).enumerate() { + debug_assert!(base_omega_idx & pair_idx == 0); + let omega_idx = base_omega_idx + pair_idx; + let omega_inv = omegas_inv_bitreversed[omega_idx]; + let f_at_omega = pair[0]; + let f_at_minus_omega = pair[1]; + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&omega_inv); + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + *o = tmp; + } + + this_level_values.clear(); + this_level_values.clone_from(&next_level_values); + } + + *v = next_level_values[0]; + } + }); + } + }); + + if fri_step < num_steps - 1 { + coset_schedule_index += 1; + this_domain_size = next_domain_size; + let coset_factor = params.cosets_schedule[coset_schedule_index]; + let tree_params = FriSpecificBlake2sTreeParams { + values_per_leaf: (1 << coset_factor) + }; + let intermediate_iop = FriSpecificBlake2sTree::create(next_values.as_ref(), &tree_params); + let root = intermediate_iop.get_commitment(); + roots.push(root); + let num_challenges = coset_factor; + next_domain_challenges = { + prng.commit_input(&intermediate_iop.get_commitment()); + let mut challenges = vec![]; + for _ in 0..num_challenges { + challenges.push(prng.get_challenge()); + } + + challenges + }; + + challenges.push(next_domain_challenges.clone()); + intermediate_commitments.push(intermediate_iop); + } + + let next_values_as_poly = Polynomial::from_values(next_values)?; + intermediate_values.push(next_values_as_poly); + + values_slice = intermediate_values.last().expect("is something").as_ref(); + } + + let final_root = roots.last().expect("will work").clone(); + + assert_eq!(challenges.len(), num_steps); + // assert_eq!(roots.len(), num_steps); + assert_eq!(intermediate_commitments.len(), num_steps-1); + assert_eq!(intermediate_values.len(), num_steps); + + let mut final_poly_values = Polynomial::from_values(values_slice.to_vec())?; + final_poly_values.bitreverse_enumeration(&worker); + let final_poly_coeffs = if params.coset_factor == F::one() { + final_poly_values.icoset_fft(&worker) + } else { + final_poly_values.icoset_fft_for_generator(&worker, ¶ms.coset_factor) + }; + + let mut final_poly_coeffs = final_poly_coeffs.into_coeffs(); + + let mut degree = final_poly_coeffs.len() - 1; + for c in final_poly_coeffs.iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break + } + } + + assert!(degree < output_coeffs_at_degree_plus_one, "polynomial degree is too large, coeffs = {:?}", final_poly_coeffs); + + final_poly_coeffs.truncate(output_coeffs_at_degree_plus_one); + + Ok(FRIProofPrototype { + // l0_commitment, + intermediate_commitments, + intermediate_values, + challenges, + final_root, + final_coefficients: final_poly_coeffs, + initial_degree_plus_one, + output_coeffs_at_degree_plus_one, + lde_factor, + }) + + } +} + +#[cfg(test)] +mod test { + #[test] + fn test_bench_fri_with_coset_combining() { + use crate::ff::Field; + use crate::ff::PrimeField; + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth_engine::Fr; + use crate::plonk::transparent_engine::PartialTwoBitReductionField; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas, OmegasInvBitreversed}; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::FriPrecomputations; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; + use crate::plonk::commitments::transcript::*; + + const SIZE: usize = 1024; + + let mut transcript = Blake2sTranscript::::new(); + + let worker = Worker::new_with_cpus(1); + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..SIZE).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly.size()); + let start = Instant::now(); + let coset_factor = Fr::multiplicative_generator(); + let eval_result = poly.bitreversed_lde_using_bitreversed_ntt(&worker, 16, &precomp, &coset_factor).unwrap(); + println!("LDE with factor 16 for size {} bitreversed {:?}", SIZE, start.elapsed()); + + let fri_precomp = as FriPrecomputations>::new_for_domain_size(eval_result.size()); + + let params = CosetParams:: { + cosets_schedule: vec![3, 3, 3], + coset_factor: coset_factor + }; + + let fri_proto = CosetCombiningFriIop::::proof_from_lde( + &eval_result, + 16, + 2, + &fri_precomp, + &worker, + &mut transcript, + ¶ms + ).expect("FRI must succeed"); + } + + #[test] + #[should_panic] + fn test_invalid_eval_fri_with_coset_combining() { + use crate::ff::Field; + use crate::ff::PrimeField; + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth_engine::Fr; + use crate::plonk::transparent_engine::PartialTwoBitReductionField; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas, OmegasInvBitreversed}; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::FriPrecomputations; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; + use crate::plonk::commitments::transcript::*; + + const SIZE: usize = 1024; + + let mut transcript = Blake2sTranscript::::new(); + + let worker = Worker::new_with_cpus(1); + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..SIZE).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly.size()); + let start = Instant::now(); + let coset_factor = Fr::multiplicative_generator(); + let mut eval_result = poly.bitreversed_lde_using_bitreversed_ntt(&worker, 16, &precomp, &coset_factor).unwrap(); + eval_result.as_mut()[1].sub_assign(&Fr::one()); + println!("LDE with factor 16 for size {} bitreversed {:?}", SIZE, start.elapsed()); + + let fri_precomp = as FriPrecomputations>::new_for_domain_size(eval_result.size()); + + let params = CosetParams:: { + cosets_schedule: vec![3, 3, 3], + coset_factor: coset_factor + }; + + let fri_proto = CosetCombiningFriIop::::proof_from_lde( + &eval_result, + 16, + 2, + &fri_precomp, + &worker, + &mut transcript, + ¶ms + ).expect("FRI must succeed"); + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/coset_combining_fri/mod.rs b/src/plonk/commitments/transparent/fri/coset_combining_fri/mod.rs new file mode 100644 index 000000000..1039a3ca5 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/coset_combining_fri/mod.rs @@ -0,0 +1,71 @@ +pub mod fri; +// pub mod query_producer; +// pub mod verifier; +pub mod precomputation; + +use crate::SynthesisError; +use crate::worker::Worker; +use crate::ff::PrimeField; +use crate::plonk::commitments::transparent::iop_compiler::*; + +use crate::plonk::polynomials::*; +use crate::plonk::commitments::transcript::Prng; + +pub trait FriProofPrototype> { + fn get_roots(&self) -> Vec; + fn get_final_root(&self) -> I::Commitment; + fn get_final_coefficients(&self) -> Vec; +} + +pub trait FriProof> { + fn get_final_coefficients(&self) -> &[F]; + fn get_queries(&self) -> &Vec>; +} + +pub trait FriPrecomputations { + fn new_for_domain_size(size: usize) -> Self; + fn omegas_inv_bitreversed(&self) -> &[F]; + fn domain_size(&self) -> usize; +} + +pub trait FriIop { + const DEGREE: usize; + + type IopType: IopInstance; + type ProofPrototype: FriProofPrototype; + type Proof: FriProof; + type Params: Clone + std::fmt::Debug; + + fn proof_from_lde>::Commitment>, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P, + params: &Self::Params + ) -> Result; + + fn prototype_into_proof( + prototype: Self::ProofPrototype, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + params: &Self::Params + ) -> Result; + + fn get_fri_challenges>::Commitment>>( + proof: &Self::Proof, + prng: &mut P, + params: &Self::Params + ) -> Vec; + + fn verify_proof_with_challenges( + proof: &Self::Proof, + natural_element_indexes: Vec, + expected_value: &[F], + fri_challenges: &[F], + params: &Self::Params + ) -> Result; +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/coset_combining_fri/precomputation.rs b/src/plonk/commitments/transparent/fri/coset_combining_fri/precomputation.rs new file mode 100644 index 000000000..739eab029 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/coset_combining_fri/precomputation.rs @@ -0,0 +1,86 @@ +use crate::ff::PrimeField; + +use crate::plonk::domains::Domain; +use crate::worker::Worker; +use crate::plonk::fft::distribute_powers; +use super::*; +use crate::plonk::fft::cooley_tukey_ntt::{bitreverse, log2_floor}; +use crate::plonk::fft::cooley_tukey_ntt::{OmegasInvBitreversed}; + +impl FriPrecomputations for OmegasInvBitreversed { + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn omegas_inv_bitreversed(&self) -> &[F] { + &self.omegas[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} + +pub struct CosetOmegasInvBitreversed { + pub omegas: Vec, + domain_size: usize +} + +impl CosetOmegasInvBitreversed { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + + let omega = domain.generator.inverse().expect("must exist"); + let precomputation_size = domain_size / 2; + + let log_n = log2_floor(precomputation_size); + + let mut omegas = vec![F::zero(); precomputation_size]; + let geninv = F::multiplicative_generator().inverse().expect("must exist"); + + worker.scope(omegas.len(), |scope, chunk| { + for (i, v) in omegas.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega.pow(&[(i * chunk) as u64]); + u.mul_assign(&geninv); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega); + } + }); + } + }); + + if omegas.len() > 2 { + for k in 0..omegas.len() { + let rk = bitreverse(k, log_n as usize); + if k < rk { + omegas.swap(rk, k); + } + } + } + + CosetOmegasInvBitreversed{ + omegas, + domain_size + } + } +} + +impl FriPrecomputations for CosetOmegasInvBitreversed { + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn omegas_inv_bitreversed(&self) -> &[F] { + &self.omegas[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/coset_combining_fri/query_producer.rs b/src/plonk/commitments/transparent/fri/coset_combining_fri/query_producer.rs new file mode 100644 index 000000000..751a210c8 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/coset_combining_fri/query_producer.rs @@ -0,0 +1,67 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::fri::*; +use super::super::*; + +impl> FRIProofPrototype { + pub fn produce_proof( + self, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + ) -> Result, SynthesisError> { + let domain_size = self.initial_degree_plus_one * self.lde_factor; + + let mut roots = vec![]; + let l0_commitment = Some(self.l0_commitment); + + for iop in l0_commitment.iter().chain(&self.intermediate_commitments) { + roots.push(iop.get_root()); + } + + let mut rounds = vec![]; + + for natural_first_element_index in natural_first_element_indexes.into_iter() { + let mut queries = vec![]; + let mut domain_idx = natural_first_element_index; + let mut domain_size = domain_size; + + for (iop, leaf_values) in l0_commitment.iter().chain(&self.intermediate_commitments) + .zip(Some(iop_values).into_iter().chain(&self.intermediate_values)) { + + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + if coset_values.len() != >::COSET_SIZE { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for idx in coset_values.into_iter() { + let query = iop.query(idx, leaf_values.as_ref()); + queries.push(query); + } + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + } + + rounds.push(queries); + } + + let proof = FRIProof:: { + queries: rounds, + roots, + final_coefficients: self.final_coefficients, + initial_degree_plus_one: self.initial_degree_plus_one, + output_coeffs_at_degree_plus_one: self.output_coeffs_at_degree_plus_one, + lde_factor: self.lde_factor, + }; + + Ok(proof) + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/coset_combining_fri/verifier.rs b/src/plonk/commitments/transparent/fri/coset_combining_fri/verifier.rs new file mode 100644 index 000000000..3c8deaf11 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/coset_combining_fri/verifier.rs @@ -0,0 +1,318 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::fri::*; +use super::super::*; + +impl CosetCombiningFriIop { + pub fn verify_prototype( + proof: & FRIProofPrototype>>, + leaf_values: & Polynomial, + natural_element_index: usize + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + // start from the bottom: we need to get a "pair" and calculate FRI step + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + + let mut omega = domain.generator; + let mut omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + debug_assert_eq!(F::one(), omega_inv.pow([domain.size])); + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + + for (iop_values, iop_challenge) in Some(leaf_values).into_iter().chain(&proof.intermediate_values) + .zip(proof.challenges.iter()) { + + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + assert!(coset_values.len() == 2); + assert!(coset_values[0] < coset_values[1]); + + let f_at_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[0]); + + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + return Ok(false); + } + + let supplied_value = *I::get_for_natural_index(iop_values.as_ref(), domain_idx); + // check consistency + if supplied_value != value { + return Ok(false); + } + } + + let f_at_minus_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[1]); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = *f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = *f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + // debug_assert!(domain_idx < domain_size / 2); + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + Ok(valid) + } + + // pub fn verify_proof_queries >::TreeHasher as IopTreeHasher >::HashOutput> >( + // proof: &FRIProof, + // natural_element_indexes: Vec, + // degree: usize, + // expected_value_from_oracle: F, + // prng: &mut P + // ) -> Result { + + // } + + pub fn verify_proof_queries( + proof: &FRIProof, + natural_element_indexes: Vec, + degree: usize, + expected_values_from_oracle: &[F], + fri_challenges: &[F] + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let omega = domain.generator; + let omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + assert!(fri_challenges.len() == proof.roots.len()); + + assert!(natural_element_indexes.len() == proof.queries.len()); + + for ((query, natural_element_index), expected_value_from_oracle) in proof.queries.iter() + .zip(natural_element_indexes.into_iter()) + .zip(expected_values_from_oracle.iter()) + { + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + // let next_domain_size = domain.size / 2; + // let el = domain_element.pow([next_domain_size]); + // if el == F::one() { + // return Err(SynthesisError::UnexpectedIdentity); + // } + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + let mut omega = omega; + let mut omega_inv = omega_inv; + + if query.len() % degree != 0 { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for (round, ((root, queries), iop_challenge)) in proof.roots.iter() + .zip(query.chunks_exact(degree)) + .zip(fri_challenges.iter()) + .enumerate() + { + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + if coset_values.len() != >::COSET_SIZE { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for q in queries.iter() { + if !coset_values.contains(&q.natural_index()) { + println!("Coset values do not contain query index {}", q.natural_index()); + return Ok(false); + } + } + + if round == 0 { + for q in queries.iter() { + if q.natural_index() == natural_element_index && q.value() != *expected_value_from_oracle { + println!("Expected {}, got {} from query", expected_value_from_oracle, q.value()); + return Ok(false); + } + } + } + + for (c, q) in coset_values.iter().zip(queries.iter()) { + let tree_index = >::natural_index_into_tree_index(*c); + if q.tree_index() != tree_index { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + assert!(q.natural_index() == *c, "coset values and produced queries are expected to be sorted!"); + } + + for q in queries.iter() { + if !I::verify_query(&q, &root) { + println!("Query is not in the root"); + return Ok(false); + } + } + + let f_at_omega = (&queries[0]).value(); + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + println!("Coset values {:?} do not containt required index {}", coset_values, domain_idx); + return Ok(false); + } + + let q: Vec<_> = queries.iter().filter(|el| el.natural_index() == domain_idx).collect(); + if q.len() != 1 { + println!("Queries containt duplicate opening for required index {}", domain_idx); + return Ok(false) + } + + let supplied_value = q[0].value(); + // check in the next domain + if supplied_value != value { + println!("Query value {} is not equal to the expected value {} for round {}", supplied_value, value, round); + return Ok(false); + } + } + + let f_at_minus_omega = (&queries[1]).value(); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + if !valid { + println!("Value from supplied coefficients {} is not equal to the value from queries {} for natural index {}", expected_value_from_coefficients, expected_value, natural_element_index); + println!("Final coefficients = {:?}", proof.final_coefficients); + return Ok(false); + } + } + + Ok(true) + } +} diff --git a/src/plonk/commitments/transparent/fri/mod.rs b/src/plonk/commitments/transparent/fri/mod.rs new file mode 100644 index 000000000..d604cbea5 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/mod.rs @@ -0,0 +1,76 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::utils::log2_floor; +use crate::plonk::commitments::transcript::Prng; + +pub mod naive_fri; +pub mod coset_combining_fri; + +pub trait FriProofPrototype> { + fn get_roots(&self) -> Vec< < >::TreeHasher as IopTreeHasher>::HashOutput>; + fn get_final_root(&self) -> < >::TreeHasher as IopTreeHasher>::HashOutput; + fn get_final_coefficients(&self) -> Vec; +} + +pub trait FriProof> { + fn get_final_coefficients(&self) -> &[F]; +} + +pub trait FriPrecomputations { + fn new_for_domain_size(size: usize) -> Self; + fn omegas_inv_ref(&self) -> &[F]; + fn domain_size(&self) -> usize; +} + +pub trait FriIop { + const DEGREE: usize; + + type IopType: IOP; + type ProofPrototype: FriProofPrototype; + type Proof: FriProof; + type Params: Clone + std::fmt::Debug; + + fn proof_from_lde>::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput >, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P, + params: &Self::Params + ) -> Result; + + fn prototype_into_proof( + prototype: Self::ProofPrototype, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + params: &Self::Params + ) -> Result; + + // // will write roots to prng values + // fn verify_proof_with_transcript>::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput > >( + // proof: &Self::Proof, + // natural_element_indexes: Vec, + // expected_values: &[F], + // prng: &mut P + // ) -> Result; + + fn get_fri_challenges>::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput > >( + proof: &Self::Proof, + prng: &mut P, + params: &Self::Params + ) -> Vec; + + fn verify_proof_with_challenges( + proof: &Self::Proof, + natural_element_indexes: Vec, + expected_value: &[F], + fri_challenges: &[F], + params: &Self::Params + ) -> Result; +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/naive_fri/mod.rs b/src/plonk/commitments/transparent/fri/naive_fri/mod.rs new file mode 100644 index 000000000..ba7866a12 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/naive_fri/mod.rs @@ -0,0 +1,3 @@ +pub mod naive_fri; +pub mod query_producer; +pub mod verifier; \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/naive_fri/naive_fri.rs b/src/plonk/commitments/transparent/fri/naive_fri/naive_fri.rs new file mode 100644 index 000000000..27208e74f --- /dev/null +++ b/src/plonk/commitments/transparent/fri/naive_fri/naive_fri.rs @@ -0,0 +1,398 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use crate::plonk::commitments::transcript::Prng; +use crate::plonk::commitments::transparent::precomputations::*; +use super::super::*; + +pub struct NaiveFriIop> { + _marker_f: std::marker::PhantomData, + _marker_i: std::marker::PhantomData, +} + +impl > FriIop for NaiveFriIop { + const DEGREE: usize = 2; + + type IopType = I; + type ProofPrototype = FRIProofPrototype; + type Proof = FRIProof; + type Params = (); + + fn proof_from_lde >::TreeHasher as IopTreeHasher >::HashOutput>, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P, + params: &Self::Params + ) -> Result { + NaiveFriIop::proof_from_lde_by_values( + lde_values, + lde_factor, + output_coeffs_at_degree_plus_one, + precomputations, + worker, + prng + ) + } + + fn prototype_into_proof( + prototype: Self::ProofPrototype, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + _params: &Self::Params + ) -> Result { + prototype.produce_proof(iop_values, natural_first_element_indexes) + } + + fn get_fri_challenges >::TreeHasher as IopTreeHasher >::HashOutput> >( + proof: &Self::Proof, + prng: &mut P, + _params: &Self::Params + ) -> Vec { + let mut fri_challenges = vec![]; + + for root in proof.roots.iter() { + let iop_challenge = { + prng.commit_input(&root); + prng.get_challenge() + }; + + fri_challenges.push(iop_challenge); + } + + fri_challenges + } + + fn verify_proof_with_challenges( + proof: &Self::Proof, + natural_element_indexes: Vec, + expected_value: &[F], + fri_challenges: &[F], + _params: &Self::Params + ) -> Result { + Self::verify_proof_queries(proof, natural_element_indexes, Self::DEGREE, expected_value, fri_challenges) + } +} + +use std::time::Instant; + +#[derive(PartialEq, Eq, Clone)] +pub struct FRIProofPrototype> { + pub l0_commitment: I, + pub intermediate_commitments: Vec, + pub intermediate_values: Vec< Polynomial >, + pub challenges: Vec, + pub final_root: < >::TreeHasher as IopTreeHasher>::HashOutput, + pub final_coefficients: Vec, + pub initial_degree_plus_one: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub lde_factor: usize, +} + +impl> FriProofPrototype for FRIProofPrototype { + fn get_roots(&self) -> Vec< < >::TreeHasher as IopTreeHasher>::HashOutput> { + let mut roots = vec![]; + roots.push(self.l0_commitment.get_root().clone()); + for c in self.intermediate_commitments.iter() { + roots.push(c.get_root().clone()); + } + + roots + } + + fn get_final_root(&self) -> < >::TreeHasher as IopTreeHasher>::HashOutput { + self.final_root.clone() + } + + fn get_final_coefficients(&self) -> Vec { + self.final_coefficients.clone() + } +} + +#[derive(PartialEq, Eq, Clone)] +pub struct FRIProof> { + pub queries: Vec< Vec< >::Query > >, + pub roots: Vec< < >::TreeHasher as IopTreeHasher>::HashOutput>, + pub final_coefficients: Vec, + pub initial_degree_plus_one: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub lde_factor: usize, +} + +impl> FriProof for FRIProof { + fn get_final_coefficients(&self) -> &[F] { + &self.final_coefficients + } +} + +impl> NaiveFriIop { + pub fn proof_from_lde_through_coefficients >::TreeHasher as IopTreeHasher >::HashOutput> >( + lde_values: Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + worker: &Worker, + prng: &mut P + ) -> Result, SynthesisError> { + let l0_commitment: I = I::create(lde_values.as_ref()); + let initial_domain_size = lde_values.size(); + + assert!(output_coeffs_at_degree_plus_one.is_power_of_two()); + assert!(lde_factor.is_power_of_two()); + + let initial_degree_plus_one = initial_domain_size / lde_factor; + let num_steps = log2_floor(initial_degree_plus_one / output_coeffs_at_degree_plus_one) as usize; + + let initial_polynomial = lde_values.ifft(&worker); + let mut initial_polynomial_coeffs = initial_polynomial.into_coeffs(); + initial_polynomial_coeffs.truncate(initial_degree_plus_one); + + let mut intermediate_commitments = vec![]; + let mut intermediate_values = vec![]; + let mut challenges = vec![]; + let mut next_domain_challenge = { + prng.commit_input(&l0_commitment.get_root()); + prng.get_challenge() + }; + challenges.push(next_domain_challenge); + let mut next_domain_size = initial_polynomial_coeffs.len() / 2; + + let mut coeffs = initial_polynomial_coeffs; + let mut roots = vec![]; + + for step in 0..num_steps { + let mut next_coefficients = vec![F::zero(); next_domain_size]; + let coeffs_slice: &[F] = coeffs.as_ref(); + assert!(next_coefficients.len()*2 == coeffs_slice.len()); + + worker.scope(next_coefficients.len(), |scope, chunk| { + for (v, old) in next_coefficients.chunks_mut(chunk) + .zip(coeffs_slice.chunks(chunk*2)) { + scope.spawn(move |_| { + for (v, old) in v.iter_mut().zip(old.chunks(2)) { + // a_0 + beta * a_1 + + let x = old[0]; + let mut tmp = old[1]; + tmp.mul_assign(&next_domain_challenge); + tmp.add_assign(&x); + + *v = tmp; + } + }); + } + }); + + let next_coeffs_as_poly = Polynomial::from_coeffs(next_coefficients.clone())?; + let next_values_as_poly = next_coeffs_as_poly.lde(&worker, lde_factor)?; + let intermediate_iop = I::create(next_values_as_poly.as_ref()); + if step < num_steps - 1 { + let root = intermediate_iop.get_root(); + roots.push(root); + next_domain_challenge = { + prng.commit_input(&intermediate_iop.get_root()); + prng.get_challenge() + }; + + challenges.push(next_domain_challenge); + + next_domain_size /= 2; + + intermediate_commitments.push(intermediate_iop); + intermediate_values.push(next_values_as_poly); + + coeffs = next_coefficients; + } + } + + // challenges.pop().expect("will work"); + + // let final_root = roots.pop().expect("will work"); + let final_root = roots.last().expect("will work").clone(); + + assert!(challenges.len() == num_steps); + assert!(intermediate_commitments.len() == num_steps); + assert!(intermediate_values.len() == num_steps); + + let final_poly_coeffs = coeffs; + + assert!(final_poly_coeffs.len() == output_coeffs_at_degree_plus_one); + + Ok(FRIProofPrototype { + l0_commitment, + intermediate_commitments, + intermediate_values, + challenges, + final_root, + final_coefficients: final_poly_coeffs, + initial_degree_plus_one, + output_coeffs_at_degree_plus_one, + lde_factor, + }) + + } + + pub fn proof_from_lde_by_values >::TreeHasher as IopTreeHasher >::HashOutput>, + C: FriPrecomputations + >( + lde_values: &Polynomial, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + precomputations: &C, + worker: &Worker, + prng: &mut P + ) -> Result, SynthesisError> { + println!("Starting FRI"); + let start = Instant::now(); + + let mut roots = vec![]; + let l0_commitment: I = I::create(lde_values.as_ref()); + let root = l0_commitment.get_root(); + roots.push(root); + let initial_domain_size = lde_values.size(); + + assert_eq!(precomputations.domain_size(), initial_domain_size); + + let mut two = F::one(); + two.double(); + let two_inv = two.inverse().expect("should exist"); + + assert!(output_coeffs_at_degree_plus_one.is_power_of_two()); + assert!(lde_factor.is_power_of_two()); + + let initial_degree_plus_one = initial_domain_size / lde_factor; + + let num_steps = log2_floor(initial_degree_plus_one / output_coeffs_at_degree_plus_one) as usize; + + let mut intermediate_commitments = vec![]; + let mut intermediate_values = vec![]; + let mut challenges = vec![]; + let mut next_domain_challenge = { + prng.commit_input(&l0_commitment.get_root()); + prng.get_challenge() + }; + challenges.push(next_domain_challenge); + + let mut next_domain_size = initial_domain_size / 2; + + let mut values_slice = lde_values.as_ref(); + + let omegas_inv_ref: &[F] = precomputations.omegas_inv_ref(); + + // step 0: fold totally by 2 + // step 1: fold totally by 4 + // etc... + + for i in 0..num_steps { + // we step over 1, omega, omega^2, + // then over 1, omega^2, + // etc. + let stride = 1 << i; + let mut next_values = vec![F::zero(); next_domain_size]; + + assert!(values_slice.len() == next_values.len() * 2); + + worker.scope(next_values.len(), |scope, chunk| { + for (i, v) in next_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let initial_k = i*chunk; + for (j, v) in v.iter_mut().enumerate() { + let idx = initial_k + j; + debug_assert!(idx < next_domain_size); + let omega_idx = idx * stride; + let f_at_omega = values_slice[idx]; + let f_at_minus_omega = values_slice[idx + next_domain_size]; + + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&omegas_inv_ref[omega_idx]); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&next_domain_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + *v = tmp; + } + }); + } + }); + + if i < num_steps - 1 { + let intermediate_iop = I::create(next_values.as_ref()); + let root = intermediate_iop.get_root(); + roots.push(root); + next_domain_challenge = { + prng.commit_input(&intermediate_iop.get_root()); + prng.get_challenge() + }; + challenges.push(next_domain_challenge); + next_domain_size >>= 1; + + intermediate_commitments.push(intermediate_iop); + } + + let next_values_as_poly = Polynomial::from_values(next_values)?; + intermediate_values.push(next_values_as_poly); + + values_slice = intermediate_values.last().expect("is something").as_ref(); + } + + let final_root = roots.last().expect("will work").clone(); + + assert_eq!(challenges.len(), num_steps); + assert_eq!(roots.len(), num_steps); + assert_eq!(intermediate_commitments.len(), num_steps-1); + assert_eq!(intermediate_values.len(), num_steps); + + let final_poly_values = Polynomial::from_values(values_slice.to_vec())?; + let final_poly_coeffs = final_poly_values.ifft(&worker); + + let mut final_poly_coeffs = final_poly_coeffs.into_coeffs(); + + let mut degree = final_poly_coeffs.len() - 1; + for c in final_poly_coeffs.iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break + } + } + + assert!(degree < output_coeffs_at_degree_plus_one, "polynomial degree is too large, coeffs = {:?}", final_poly_coeffs); + + final_poly_coeffs.truncate(output_coeffs_at_degree_plus_one); + + println!("Done FRI for degree {} in {:?}", lde_values.size()/lde_factor, start.elapsed()); + + Ok(FRIProofPrototype { + l0_commitment, + intermediate_commitments, + intermediate_values, + challenges, + final_root, + final_coefficients: final_poly_coeffs, + initial_degree_plus_one, + output_coeffs_at_degree_plus_one, + lde_factor, + }) + + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/naive_fri/query_producer.rs b/src/plonk/commitments/transparent/fri/naive_fri/query_producer.rs new file mode 100644 index 000000000..156514034 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/naive_fri/query_producer.rs @@ -0,0 +1,67 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::naive_fri::*; +use super::super::*; + +impl> FRIProofPrototype { + pub fn produce_proof( + self, + iop_values: &Polynomial, + natural_first_element_indexes: Vec, + ) -> Result, SynthesisError> { + let domain_size = self.initial_degree_plus_one * self.lde_factor; + + let mut roots = vec![]; + let l0_commitment = Some(self.l0_commitment); + + for iop in l0_commitment.iter().chain(&self.intermediate_commitments) { + roots.push(iop.get_root()); + } + + let mut rounds = vec![]; + + for natural_first_element_index in natural_first_element_indexes.into_iter() { + let mut queries = vec![]; + let mut domain_idx = natural_first_element_index; + let mut domain_size = domain_size; + + for (iop, leaf_values) in l0_commitment.iter().chain(&self.intermediate_commitments) + .zip(Some(iop_values).into_iter().chain(&self.intermediate_values)) { + + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + if coset_values.len() != >::COSET_SIZE { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for idx in coset_values.into_iter() { + let query = iop.query(idx, leaf_values.as_ref()); + queries.push(query); + } + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + } + + rounds.push(queries); + } + + let proof = FRIProof:: { + queries: rounds, + roots, + final_coefficients: self.final_coefficients, + initial_degree_plus_one: self.initial_degree_plus_one, + output_coeffs_at_degree_plus_one: self.output_coeffs_at_degree_plus_one, + lde_factor: self.lde_factor, + }; + + Ok(proof) + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/fri/naive_fri/verifier.rs b/src/plonk/commitments/transparent/fri/naive_fri/verifier.rs new file mode 100644 index 000000000..750818729 --- /dev/null +++ b/src/plonk/commitments/transparent/fri/naive_fri/verifier.rs @@ -0,0 +1,318 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::worker::*; +use crate::SynthesisError; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transparent::utils::log2_floor; +use super::naive_fri::*; +use super::super::*; + +impl> NaiveFriIop { + pub fn verify_prototype( + proof: & FRIProofPrototype, + leaf_values: & Polynomial, + natural_element_index: usize + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + // start from the bottom: we need to get a "pair" and calculate FRI step + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + + let mut omega = domain.generator; + let mut omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + debug_assert_eq!(F::one(), omega_inv.pow([domain.size])); + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + + for (iop_values, iop_challenge) in Some(leaf_values).into_iter().chain(&proof.intermediate_values) + .zip(proof.challenges.iter()) { + + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + assert!(coset_values.len() == 2); + assert!(coset_values[0] < coset_values[1]); + + let f_at_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[0]); + + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + return Ok(false); + } + + let supplied_value = *I::get_for_natural_index(iop_values.as_ref(), domain_idx); + // check consistency + if supplied_value != value { + return Ok(false); + } + } + + let f_at_minus_omega = I::get_for_natural_index(iop_values.as_ref(), coset_values[1]); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = *f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = *f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + // debug_assert!(domain_idx < domain_size / 2); + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + Ok(valid) + } + + // pub fn verify_proof_queries >::TreeHasher as IopTreeHasher >::HashOutput> >( + // proof: &FRIProof, + // natural_element_indexes: Vec, + // degree: usize, + // expected_value_from_oracle: F, + // prng: &mut P + // ) -> Result { + + // } + + pub fn verify_proof_queries( + proof: &FRIProof, + natural_element_indexes: Vec, + degree: usize, + expected_values_from_oracle: &[F], + fri_challenges: &[F] + ) -> Result { + let mut two = F::one(); + two.double(); + + let two_inv = two.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + let domain = Domain::::new_for_size((proof.initial_degree_plus_one * proof.lde_factor) as u64)?; + + let omega = domain.generator; + let omega_inv = omega.inverse().ok_or( + SynthesisError::DivisionByZero + )?; + + assert!(fri_challenges.len() == proof.roots.len()); + + assert!(natural_element_indexes.len() == proof.queries.len()); + + for ((query, natural_element_index), expected_value_from_oracle) in proof.queries.iter() + .zip(natural_element_indexes.into_iter()) + .zip(expected_values_from_oracle.iter()) + { + + let domain_element = domain.generator.pow([natural_element_index as u64]); + + let el = domain_element.pow([domain.size]); + if el != F::one() { + return Err(SynthesisError::UnexpectedIdentity); + } + // let next_domain_size = domain.size / 2; + // let el = domain_element.pow([next_domain_size]); + // if el == F::one() { + // return Err(SynthesisError::UnexpectedIdentity); + // } + + let mut expected_value: Option = None; + let mut domain_size = domain.size as usize; + let mut domain_idx = natural_element_index; + let mut omega = omega; + let mut omega_inv = omega_inv; + + if query.len() % degree != 0 { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for (round, ((root, queries), iop_challenge)) in proof.roots.iter() + .zip(query.chunks_exact(degree)) + .zip(fri_challenges.iter()) + .enumerate() + { + let coset_values = >::get_coset_for_natural_index(domain_idx, domain_size); + + if coset_values.len() != >::COSET_SIZE { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + for q in queries.iter() { + if !coset_values.contains(&q.natural_index()) { + println!("Coset values do not contain query index {}", q.natural_index()); + return Ok(false); + } + } + + if round == 0 { + for q in queries.iter() { + if q.natural_index() == natural_element_index && q.value() != *expected_value_from_oracle { + println!("Expected {}, got {} from query", expected_value_from_oracle, q.value()); + return Ok(false); + } + } + } + + for (c, q) in coset_values.iter().zip(queries.iter()) { + let tree_index = >::natural_index_into_tree_index(*c); + if q.tree_index() != tree_index { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + assert!(q.natural_index() == *c, "coset values and produced queries are expected to be sorted!"); + } + + for q in queries.iter() { + if !I::verify_query(&q, &root) { + println!("Query is not in the root"); + return Ok(false); + } + } + + let f_at_omega = (&queries[0]).value(); + if let Some(value) = expected_value { + if !coset_values.contains(&domain_idx) { + println!("Coset values {:?} do not containt required index {}", coset_values, domain_idx); + return Ok(false); + } + + let q: Vec<_> = queries.iter().filter(|el| el.natural_index() == domain_idx).collect(); + if q.len() != 1 { + println!("Queries containt duplicate opening for required index {}", domain_idx); + return Ok(false) + } + + let supplied_value = q[0].value(); + // check in the next domain + if supplied_value != value { + println!("Query value {} is not equal to the expected value {} for round {}", supplied_value, value, round); + return Ok(false); + } + } + + let f_at_minus_omega = (&queries[1]).value(); + let divisor = omega_inv.pow([coset_values[0] as u64]); + + let mut v_even_coeffs = f_at_omega; + v_even_coeffs.add_assign(&f_at_minus_omega); + + let mut v_odd_coeffs = f_at_omega; + v_odd_coeffs.sub_assign(&f_at_minus_omega); + v_odd_coeffs.mul_assign(&divisor); + + // those can be treated as (doubled) evaluations of polynomials that + // are themselves made only from even or odd coefficients of original poly + // (with reduction of degree by 2) on a domain of the size twice smaller + // with an extra factor of "omega" in odd coefficients + + // to do assemble FRI step we just need to add them with a random challenge + + let mut tmp = v_odd_coeffs; + tmp.mul_assign(&iop_challenge); + tmp.add_assign(&v_even_coeffs); + tmp.mul_assign(&two_inv); + + expected_value = Some(tmp); + + // we have jumped in a coset and can keep it ordered using the smaller index out of two + // domain_idx = coset_values[0]; + + let (next_idx, next_size) = Domain::::index_and_size_for_next_domain(domain_idx, domain_size); + + domain_idx = next_idx; + domain_size = next_size; + + omega.square(); + omega_inv.square(); + } + + + // finally we need to get expected value from coefficients + + let mut expected_value_from_coefficients = F::zero(); + let mut power = F::one(); + let evaluation_point = omega.pow([domain_idx as u64]); + + for c in proof.final_coefficients.iter() { + let mut tmp = power; + tmp.mul_assign(c); + + expected_value_from_coefficients.add_assign(&tmp); + power.mul_assign(&evaluation_point); + } + + let expected_value = expected_value.expect("is some"); + + let valid = expected_value_from_coefficients == expected_value; + + if !valid { + println!("Value from supplied coefficients {} is not equal to the value from queries {} for natural index {}", expected_value_from_coefficients, expected_value, natural_element_index); + println!("Final coefficients = {:?}", proof.final_coefficients); + return Ok(false); + } + } + + Ok(true) + } +} diff --git a/src/plonk/commitments/transparent/iop/blake2s_trivial_iop.rs b/src/plonk/commitments/transparent/iop/blake2s_trivial_iop.rs new file mode 100644 index 000000000..17f1215c6 --- /dev/null +++ b/src/plonk/commitments/transparent/iop/blake2s_trivial_iop.rs @@ -0,0 +1,409 @@ +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use blake2s_simd::{Params, State}; +use crate::worker::Worker; +use super::super::utils::log2_floor; +use super::*; +use super::trivial_coset_combiner::*; + +lazy_static! { + static ref BASE_BLAKE2S_PARAMS: State = { + Params::new() + .hash_length(32) + .key(b"Squeamish Ossifrage") + .personal(b"Shaftoe") + .to_state() + }; +} + +pub struct Blake2sLeafEncoder { + _marker: std::marker::PhantomData +} + +impl Blake2sLeafEncoder { + const SHAVE_BITS: u32 = 256 - F::CAPACITY; + pub fn new() -> Self { + assert!(F::NUM_BITS < 256); + + Self { + _marker: std::marker::PhantomData + } + } +} + +impl LeafEncoder for Blake2sLeafEncoder{ + type Output = [u8; 32]; + + fn encode_leaf(value: &F) -> Self::Output { + let raw_repr = value.into_raw_repr(); + let mut output = [0u8; 32]; + raw_repr.write_le(&mut output[..]).expect("will write"); + + output + } +} + +impl FiatShamirHasher for Blake2sLeafEncoder{ + type Input = [u8; 32]; + + fn transform(value: &Self::Input) -> F { + let value = *value; + let mut repr = F::Repr::default(); + let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); + repr.read_be(&value[..]).expect("will read"); + // repr.read_le(&value[..]).expect("will read"); + let last_limb_idx = repr.as_ref().len() - 1; + repr.as_mut()[last_limb_idx] &= shaving_mask; + let value = F::from_repr(repr).expect("in a field"); + + value + } +} + +pub struct Blake2sTreeHasher { + encoder: Blake2sLeafEncoder +} + +impl Blake2sTreeHasher { + pub fn new() -> Self { + Self { + encoder: Blake2sLeafEncoder::new() + } + } +} + +impl HashFunctionOutput for [u8; 32] {} + +impl IopTreeHasher for Blake2sTreeHasher { + type HashOutput = [u8; 32]; + type LeafEncoder = Blake2sLeafEncoder; + + fn hash_leaf(value: &F) -> Self::HashOutput { + let value = >::encode_leaf(value); + Self::hash_encoded_leaf(&value) + } + + fn hash_encoded_leaf(value: &>::Output) -> Self::HashOutput { + let mut state = (*BASE_BLAKE2S_PARAMS).clone(); + state.update(value); + let output = state.finalize(); + + *output.as_array() + } + + fn hash_node(values: &[Self::HashOutput], _level: usize) -> Self::HashOutput { + debug_assert!(values.len() == 2); + let mut state = (*BASE_BLAKE2S_PARAMS).clone(); + for value in values.iter() { + state.update(value); + } + + let output = state.finalize(); + + *output.as_array() + } +} + +pub struct Blake2sIopTree { + size: usize, + nodes: Vec< < Blake2sTreeHasher as IopTreeHasher >::HashOutput >, +} + +impl Blake2sIopTree { + pub fn new() -> Self { + Self { + size: 0usize, + nodes: vec![], + } + } +} + +use std::time::Instant; + +impl<'a, F: PrimeField> IopTree for Blake2sIopTree { + type Combiner = TrivialCombiner; + type TreeHasher = Blake2sTreeHasher; + type FiatShamirTransformer = Blake2sLeafEncoder; + + fn size(&self) -> usize { + self.size + } + + fn create(leafs: &[F]) -> Self { + { + let _ = *BASE_BLAKE2S_PARAMS; + } + + println!("Creating a tree of size {}", leafs.len()); + let start = Instant::now(); + + let num_leafs = leafs.len(); + assert!(num_leafs == num_leafs.next_power_of_two()); + let num_nodes = num_leafs; + + let size = num_leafs; + + let mut nodes = vec![[0u8; 32]; num_nodes]; + + let worker = Worker::new(); + + let mut leaf_hashes = vec![[0u8; 32]; num_leafs]; + + { + worker.scope(leafs.len(), |scope, chunk| { + for (i, lh) in leaf_hashes.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let leaf_ref = >::get_for_tree_index(&leafs, idx); + *lh = < Self::TreeHasher as IopTreeHasher >::hash_leaf(leaf_ref); + } + }); + } + }); + } + + // leafs are now encoded and hashed, so let's make a tree + + let num_levels = log2_floor(num_leafs) as usize; + let mut nodes_for_hashing = &mut nodes[..]; + + // separately hash last level, which hashes leaf hashes into first nodes + { + let level = num_levels-1; + let inputs = &mut leaf_hashes[..]; + let (_, outputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + *o = < Self::TreeHasher as IopTreeHasher >::hash_node(i, level); + } + }); + } + }); + } + + for level in (0..(num_levels-1)).rev() { + // do the trick - split + let (next_levels, inputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + let (_, outputs) = next_levels.split_at_mut(next_levels.len() / 2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + *o = < Self::TreeHasher as IopTreeHasher >::hash_node(i, level); + } + }); + } + }); + + nodes_for_hashing = next_levels; + } + + println!("Done creating a tree of size {} in {:?}", leafs.len(), start.elapsed()); + + Self { + size: size, + nodes: nodes, + } + } + + fn get_root(&self) -> >::HashOutput { + // 1 here is ok, cause we have nodes as power of two, but not 2^n - 1 + self.nodes[1] + } + + fn encode_root_into_challenge(root: & >::HashOutput) -> F { + >::transform(&root) + } + + fn get_challenge_scalar_from_root(&self) -> F { + let root = self.get_root(); + + Self::encode_root_into_challenge(&root) + } + + fn verify(root: &>::HashOutput, leaf_value: &F, path: &[>::HashOutput], tree_index: usize) -> bool { + let mut hash = >::hash_leaf(&leaf_value); + let mut idx = tree_index; + for el in path.iter() { + if idx & 1usize == 0 { + hash = >::hash_node(&[hash, el.clone()], 0); + } else { + hash = >::hash_node(&[el.clone(), hash], 0); + } + idx >>= 1; + } + + &hash == root + } + + fn get_path(&self, tree_index: usize, leafs_values: &[F]) -> Vec< >::HashOutput >{ + assert!(self.size == self.nodes.len()); + let mut nodes = &self.nodes[..]; + + let tree_pair_index = tree_index ^ 1usize; + + let mut path = vec![]; + + let pair_natural_index = >::tree_index_into_natural_index(tree_pair_index); + + let pair = &leafs_values[pair_natural_index as usize]; + let encoded_pair_hash = < Self::TreeHasher as IopTreeHasher >::hash_leaf(pair); + path.push(encoded_pair_hash); + + let mut idx = tree_index; + idx >>= 1; + + for _ in 0..log2_floor(nodes.len() / 2) { + let half_len = nodes.len() / 2; + let (next_level, this_level) = nodes.split_at(half_len); + let pair_idx = idx ^ 1usize; + let value = this_level[pair_idx]; + path.push(value); + idx >>= 1; + nodes = next_level; + } + + path + } +} + +pub struct TrivialBlake2sIOP { + tree: Blake2sIopTree, +} + + +impl IOP for TrivialBlake2sIOP { + type Combiner = TrivialCombiner; + type Tree = Blake2sIopTree; + type Query = TrivialBlake2sIopQuery; + + fn create<'l> (leafs: &'l [F]) -> Self { + let tree = Self::Tree::create(leafs); + + Self { + tree + } + } + + fn get_for_natural_index(leafs: &[F], natural_index: usize) -> &F { + >::get_for_natural_index(leafs, natural_index) + } + + fn get_for_tree_index(leafs: &[F], tree_index: usize) -> &F { + >::get_for_tree_index(leafs, tree_index) + } + + fn get_root(&self) -> < >::TreeHasher as IopTreeHasher>::HashOutput { + self.tree.get_root() + } + + fn verify_query(query: &Self::Query, root: &< >::TreeHasher as IopTreeHasher>::HashOutput) -> bool { + Self::Tree::verify(root, &query.value(), &query.path(), query.tree_index()) + } + + fn query(&self, natural_index: usize, leafs: &[F]) -> Self::Query { + assert!(natural_index < self.tree.size() as usize); + assert!(natural_index < leafs.len()); + let value = leafs[natural_index]; + + let tree_index = >::natural_index_into_tree_index(natural_index); + + let path = self.tree.get_path(tree_index, leafs); + + TrivialBlake2sIopQuery:: { + index: natural_index, + value: vec![value], + path: path + } + } +} + +impl PartialEq for TrivialBlake2sIOP { + fn eq(&self, other: &Self) -> bool { + self.get_root() == other.get_root() + } +} + +impl Eq for TrivialBlake2sIOP {} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TrivialBlake2sIopQuery { + index: usize, + value: Vec, + path: Vec<[u8; 32]>, +} + +impl IopQuery for TrivialBlake2sIopQuery { + type TreeHasher = Blake2sTreeHasher; + + fn natural_index(&self) -> usize { + self.index + } + + fn natural_indexes(&self) -> Vec { + vec![self.index] + } + + fn tree_index(&self) -> usize { + self.index + } + + fn value(&self) -> F { + self.value[0] + } + + fn values(&self) -> &[F] { + &self.value + } + + fn path(&self) -> &[>::HashOutput] { + &self.path + } +} + +// #[test] +// fn make_small_tree() { +// use ff::Field; +// use hex::encode; +// use crate::experiments::Fr; +// let inputs = vec![Fr::one(); 16]; + +// let tree = Blake2sIopTree::create(&inputs); +// let root = tree.get_root(); +// let challenge_scalar = tree.get_challenge_scalar_from_root(); +// println!("Root = {}, scalar = {}", encode(&root), challenge_scalar); +// } + +// #[test] +// fn make_small_iop() { +// use crate::iop::IOP; +// use ff::Field; +// const SIZE: usize = 64; +// use crate::experiments::Fr; +// let mut inputs = vec![]; +// let mut f = Fr::one(); +// for _ in 0..SIZE { +// inputs.push(f); +// f.double(); +// } + +// let iop = TrivialBlake2sIOP::create(&inputs); +// let root = iop.get_root(); +// for i in 0..SIZE { +// let query = iop.query(i, &inputs); +// let valid = TrivialBlake2sIOP::verify_query(&query, &root); +// assert!(valid, "invalid query for leaf {}", i); +// } +// } \ No newline at end of file diff --git a/src/plonk/commitments/transparent/iop/keccak_trivial_iop.rs b/src/plonk/commitments/transparent/iop/keccak_trivial_iop.rs new file mode 100644 index 000000000..1994689e8 --- /dev/null +++ b/src/plonk/commitments/transparent/iop/keccak_trivial_iop.rs @@ -0,0 +1,392 @@ +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use tiny_keccak::*; +use crate::worker::Worker; +use super::super::utils::log2_floor; +use super::*; +use super::trivial_coset_combiner::*; + +pub struct KeccakLeafEncoder { + _marker: std::marker::PhantomData +} + +impl KeccakLeafEncoder { + const SHAVE_BITS: u32 = 256 - F::CAPACITY; + pub fn new() -> Self { + assert!(F::NUM_BITS < 256); + + Self { + _marker: std::marker::PhantomData + } + } +} + +impl LeafEncoder for KeccakLeafEncoder{ + type Output = [u8; 32]; + + fn encode_leaf(value: &F) -> Self::Output { + let raw_repr = value.into_raw_repr(); + let mut output = [0u8; 32]; + raw_repr.write_le(&mut output[..]).expect("will write"); + + output + } +} + +impl FiatShamirHasher for KeccakLeafEncoder{ + type Input = [u8; 32]; + + fn transform(value: &Self::Input) -> F { + let value = *value; + let mut repr = F::Repr::default(); + let shaving_mask: u64 = 0xffffffffffffffff >> (Self::SHAVE_BITS % 64); + repr.read_be(&value[..]).expect("will read"); + // repr.read_le(&value[..]).expect("will read"); + let last_limb_idx = repr.as_ref().len() - 1; + repr.as_mut()[last_limb_idx] &= shaving_mask; + let value = F::from_repr(repr).expect("in a field"); + + value + } +} + +pub struct KeccakTreeHasher { + _marker: std::marker::PhantomData +} + +impl KeccakTreeHasher { + pub fn new() -> Self { + Self { + _marker: std::marker::PhantomData + } + } +} + +impl IopTreeHasher for KeccakTreeHasher { + type HashOutput = [u8; 32]; + type LeafEncoder = KeccakLeafEncoder; + + fn hash_leaf(value: &F) -> Self::HashOutput { + let value = >::encode_leaf(value); + Self::hash_encoded_leaf(&value) + } + + fn hash_encoded_leaf(value: &>::Output) -> Self::HashOutput { + let output = keccak256(value); + + output + } + + fn hash_node(values: &[Self::HashOutput], _level: usize) -> Self::HashOutput { + debug_assert!(values.len() == 2); + let mut state = Keccak::new_keccak256(); + for value in values.iter() { + state.update(value); + } + + let mut output: [u8; 32] = [0; 32]; + state.finalize(&mut output); + + output + } +} + +pub struct KeccakIopTree { + size: usize, + nodes: Vec< < KeccakTreeHasher as IopTreeHasher >::HashOutput >, +} + +impl KeccakIopTree { + pub fn new() -> Self { + Self { + size: 0usize, + nodes: vec![], + } + } +} + +use std::time::Instant; + +impl<'a, F: PrimeField> IopTree for KeccakIopTree { + type Combiner = TrivialCombiner; + type TreeHasher = KeccakTreeHasher; + type FiatShamirTransformer = KeccakLeafEncoder; + + fn size(&self) -> usize { + self.size + } + + fn create(leafs: &[F]) -> Self { + println!("Creating a tree of size {}", leafs.len()); + let start = Instant::now(); + + let num_leafs = leafs.len(); + assert!(num_leafs == num_leafs.next_power_of_two()); + let num_nodes = num_leafs; + + let size = num_leafs; + + let mut nodes = vec![[0u8; 32]; num_nodes]; + + let worker = Worker::new(); + + let mut leaf_hashes = vec![[0u8; 32]; num_leafs]; + + { + worker.scope(leafs.len(), |scope, chunk| { + for (i, lh) in leaf_hashes.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let base_idx = i*chunk; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let leaf_ref = >::get_for_tree_index(&leafs, idx); + *lh = < Self::TreeHasher as IopTreeHasher >::hash_leaf(leaf_ref); + } + }); + } + }); + } + + // leafs are now encoded and hashed, so let's make a tree + + let num_levels = log2_floor(num_leafs) as usize; + let mut nodes_for_hashing = &mut nodes[..]; + + // separately hash last level, which hashes leaf hashes into first nodes + { + let level = num_levels-1; + let inputs = &mut leaf_hashes[..]; + let (_, outputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + *o = < Self::TreeHasher as IopTreeHasher >::hash_node(i, level); + } + }); + } + }); + } + + for level in (0..(num_levels-1)).rev() { + // do the trick - split + let (next_levels, inputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + let (_, outputs) = next_levels.split_at_mut(next_levels.len() / 2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + *o = < Self::TreeHasher as IopTreeHasher >::hash_node(i, level); + } + }); + } + }); + + nodes_for_hashing = next_levels; + } + + println!("Done creating a tree of size {} in {:?}", leafs.len(), start.elapsed()); + + Self { + size: size, + nodes: nodes, + } + } + + fn get_root(&self) -> >::HashOutput { + // 1 here is ok, cause we have nodes as power of two, but not 2^n - 1 + self.nodes[1] + } + + fn encode_root_into_challenge(root: & >::HashOutput) -> F { + >::transform(&root) + } + + fn get_challenge_scalar_from_root(&self) -> F { + let root = self.get_root(); + + Self::encode_root_into_challenge(&root) + } + + fn verify(root: &>::HashOutput, leaf_value: &F, path: &[>::HashOutput], tree_index: usize) -> bool { + let mut hash = >::hash_leaf(&leaf_value); + let mut idx = tree_index; + for el in path.iter() { + if idx & 1usize == 0 { + hash = >::hash_node(&[hash, el.clone()], 0); + } else { + hash = >::hash_node(&[el.clone(), hash], 0); + } + idx >>= 1; + } + + &hash == root + } + + fn get_path(&self, tree_index: usize, leafs_values: &[F]) -> Vec< >::HashOutput >{ + assert!(self.size == self.nodes.len()); + let mut nodes = &self.nodes[..]; + + let tree_pair_index = tree_index ^ 1usize; + + let mut path = vec![]; + + let pair_natural_index = >::tree_index_into_natural_index(tree_pair_index); + + let pair = &leafs_values[pair_natural_index as usize]; + let encoded_pair_hash = < Self::TreeHasher as IopTreeHasher >::hash_leaf(pair); + path.push(encoded_pair_hash); + + let mut idx = tree_index; + idx >>= 1; + + for _ in 0..log2_floor(nodes.len() / 2) { + let half_len = nodes.len() / 2; + let (next_level, this_level) = nodes.split_at(half_len); + let pair_idx = idx ^ 1usize; + let value = this_level[pair_idx]; + path.push(value); + idx >>= 1; + nodes = next_level; + } + + path + } +} + +pub struct TrivialKeccakIOP { + tree: KeccakIopTree, +} + + +impl IOP for TrivialKeccakIOP { + type Combiner = TrivialCombiner; + type Tree = KeccakIopTree; + type Query = TrivialKeccakIopQuery; + + fn create<'l> (leafs: &'l [F]) -> Self { + let tree = Self::Tree::create(leafs); + + Self { + tree + } + } + + fn get_for_natural_index(leafs: &[F], natural_index: usize) -> &F { + >::get_for_natural_index(leafs, natural_index) + } + + fn get_for_tree_index(leafs: &[F], tree_index: usize) -> &F { + >::get_for_tree_index(leafs, tree_index) + } + + fn get_root(&self) -> < >::TreeHasher as IopTreeHasher>::HashOutput { + self.tree.get_root() + } + + fn verify_query(query: &Self::Query, root: &< >::TreeHasher as IopTreeHasher>::HashOutput) -> bool { + Self::Tree::verify(root, &query.value(), &query.path(), query.tree_index()) + } + + fn query(&self, natural_index: usize, leafs: &[F]) -> Self::Query { + assert!(natural_index < self.tree.size() as usize); + assert!(natural_index < leafs.len()); + let value = leafs[natural_index]; + + let tree_index = >::natural_index_into_tree_index(natural_index); + + let path = self.tree.get_path(tree_index, leafs); + + TrivialKeccakIopQuery:: { + index: natural_index, + value: vec![value], + path: path + } + } +} + +impl PartialEq for TrivialKeccakIOP { + fn eq(&self, other: &Self) -> bool { + self.get_root() == other.get_root() + } +} + +impl Eq for TrivialKeccakIOP {} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TrivialKeccakIopQuery { + index: usize, + value: Vec, + path: Vec<[u8; 32]>, +} + +impl IopQuery for TrivialKeccakIopQuery { + type TreeHasher = KeccakTreeHasher; + + fn natural_index(&self) -> usize { + self.index + } + + fn natural_indexes(&self) -> Vec { + vec![self.index] + } + + fn tree_index(&self) -> usize { + self.index + } + + fn value(&self) -> F { + self.value[0] + } + + fn values(&self) -> &[F] { + &self.value + } + + fn path(&self) -> &[>::HashOutput] { + &self.path + } +} + +// #[test] +// fn make_small_tree() { +// use ff::Field; +// use hex::encode; +// use crate::experiments::Fr; +// let inputs = vec![Fr::one(); 16]; + +// let tree = Blake2sIopTree::create(&inputs); +// let root = tree.get_root(); +// let challenge_scalar = tree.get_challenge_scalar_from_root(); +// println!("Root = {}, scalar = {}", encode(&root), challenge_scalar); +// } + +// #[test] +// fn make_small_iop() { +// use crate::iop::IOP; +// use ff::Field; +// const SIZE: usize = 64; +// use crate::experiments::Fr; +// let mut inputs = vec![]; +// let mut f = Fr::one(); +// for _ in 0..SIZE { +// inputs.push(f); +// f.double(); +// } + +// let iop = TrivialBlake2sIOP::create(&inputs); +// let root = iop.get_root(); +// for i in 0..SIZE { +// let query = iop.query(i, &inputs); +// let valid = TrivialBlake2sIOP::verify_query(&query, &root); +// assert!(valid, "invalid query for leaf {}", i); +// } +// } \ No newline at end of file diff --git a/src/plonk/commitments/transparent/iop/mod.rs b/src/plonk/commitments/transparent/iop/mod.rs new file mode 100644 index 000000000..c47c5737f --- /dev/null +++ b/src/plonk/commitments/transparent/iop/mod.rs @@ -0,0 +1,84 @@ +use crate::pairing::ff::PrimeField; + +pub mod trivial_coset_combiner; +pub mod blake2s_trivial_iop; +pub mod keccak_trivial_iop; + +pub trait CosetInformation: Sized + Clone + Copy { + const COSET_SIZE: usize; +} + +pub trait CosetCombiner { + const EXPECTED_DEGREE: usize; + const COSET_SIZE: usize; + // type CosetData: CosetInformation; + + fn get_for_natural_index(leafs: &[F], natural_index: usize) -> &F; + fn get_for_tree_index(leafs: &[F], tree_index: usize) -> &F; + fn tree_index_into_natural_index(tree_index: usize) -> usize; + fn natural_index_into_tree_index(natural_index: usize) -> usize; + fn get_coset_for_natural_index(natural_index: usize, domain_size: usize) -> Vec; + fn get_coset_for_tree_index(tree_index: usize, domain_size: usize) -> Vec; +} + +pub trait HashFunctionOutput: Clone + Eq + PartialEq + std::fmt::Debug {} + +pub trait LeafEncoder { + type Output; + + fn encode_leaf(value: &F) -> Self::Output; +} + +pub trait FiatShamirHasher { + type Input; + + fn transform(value: &Self::Input) -> F; +} + +pub trait IopTreeHasher { + type HashOutput: HashFunctionOutput; + type LeafEncoder: LeafEncoder; + + fn hash_leaf(value: &F) -> Self::HashOutput; + fn hash_encoded_leaf(value: &>::Output) -> Self::HashOutput; + fn hash_node(values: &[Self::HashOutput], level: usize) -> Self::HashOutput; +} + + +pub trait IopTree { + type Combiner: CosetCombiner; + type TreeHasher: IopTreeHasher; + type FiatShamirTransformer: FiatShamirHasher>::HashOutput>; + + fn create(leafs: &[F]) -> Self; + fn size(&self) -> usize; + fn get_root(&self) -> >::HashOutput; + fn encode_root_into_challenge(root: & >::HashOutput) -> F; + fn get_challenge_scalar_from_root(&self) -> F; + fn verify(root: &>::HashOutput, leaf_value: &F, path: &[>::HashOutput], index: usize) -> bool; + fn get_path(&self, index: usize, leafs_values: &[F]) -> Vec< >::HashOutput >; +} + +pub trait IopQuery: 'static + PartialEq + Eq + Clone + std::fmt::Debug { + type TreeHasher: IopTreeHasher; + + fn tree_index(&self) -> usize; + fn natural_index(&self) -> usize; + fn natural_indexes(&self) -> Vec; + fn value(&self) -> F; + fn values(&self) -> &[F]; + fn path(&self) -> &[>::HashOutput]; +} + +pub trait IOP { + type Combiner: CosetCombiner; + type Tree: IopTree; + type Query: IopQuery >::TreeHasher>; + + fn create(leafs: & [F]) -> Self; + fn get_for_natural_index(leafs: &[F], natural_index: usize) -> &F; + fn get_for_tree_index(leafs: &[F], tree_index: usize) -> &F; + fn get_root(&self) -> < >::TreeHasher as IopTreeHasher>::HashOutput; + fn verify_query(query: &Self::Query, root: &< >::TreeHasher as IopTreeHasher>::HashOutput) -> bool; + fn query(&self, natural_index: usize, leafs: &[F]) -> Self::Query; +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/iop/trivial_coset_combiner.rs b/src/plonk/commitments/transparent/iop/trivial_coset_combiner.rs new file mode 100644 index 000000000..5e2acceab --- /dev/null +++ b/src/plonk/commitments/transparent/iop/trivial_coset_combiner.rs @@ -0,0 +1,51 @@ +use crate::pairing::ff::PrimeField; +use super::*; + +#[derive(Copy, Clone)] +pub struct CosetOfSizeTwo; + +impl CosetInformation for CosetOfSizeTwo { + const COSET_SIZE: usize = 2usize; +} + +pub struct TrivialCombiner { + _marker: std::marker::PhantomData +} + +impl<'c, F: PrimeField> CosetCombiner for TrivialCombiner { + const EXPECTED_DEGREE: usize = 2usize; + const COSET_SIZE: usize = 2usize; + + #[inline(always)] + fn get_for_natural_index(leafs: &[F], natural_index: usize) -> &F { + &leafs[natural_index] + } + + #[inline(always)] + fn get_for_tree_index(leafs: &[F], tree_index: usize) -> &F { + &leafs[tree_index] + } + + fn get_coset_for_natural_index(natural_index: usize, domain_size: usize) -> Vec { + assert!(natural_index < domain_size, "asking for index {} for domain size {}", natural_index, domain_size); + let natural_pair_index = (natural_index + (domain_size / 2)) % domain_size; + let mut coset = vec![natural_index, natural_pair_index]; + coset.sort(); + + coset + } + + fn get_coset_for_tree_index(natural_index: usize, domain_size: usize) -> Vec { + Self::get_coset_for_natural_index(natural_index, domain_size) + } + + #[inline(always)] + fn tree_index_into_natural_index(tree_index: usize) -> usize { + tree_index + } + + #[inline(always)] + fn natural_index_into_tree_index(natural_index: usize) -> usize { + natural_index + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/iop_compiler/coset_combining_blake2s_tree.rs b/src/plonk/commitments/transparent/iop_compiler/coset_combining_blake2s_tree.rs new file mode 100644 index 000000000..069cbf443 --- /dev/null +++ b/src/plonk/commitments/transparent/iop_compiler/coset_combining_blake2s_tree.rs @@ -0,0 +1,338 @@ +use crate::pairing::ff::{PrimeField, PrimeFieldRepr}; +use blake2s_const::blake2s_const; +use crate::worker::Worker; +use super::super::utils::log2_floor; +use super::*; + +#[derive(Debug)] +pub struct FriSpecificBlake2sTree { + size: usize, + nodes: Vec<[u8; 32]>, + params: FriSpecificBlake2sTreeParams, + _marker: std::marker::PhantomData +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct FriSpecificBlake2sTreeParams { + pub values_per_leaf: usize +} + +// impl FriSpecificBlake2sTree { +// pub fn new() -> Self { +// Self { +// size: 0usize, +// nodes: vec![], +// } +// } +// } + +use std::time::Instant; + +impl FriSpecificBlake2sTree { + const VALUE_BYTE_SIZE: usize = (((F::NUM_BITS as usize) / 64) + 1) * 8; + + fn encode_leaf_values(values: &[F], buffer: &mut [u8]) { + debug_assert!(buffer.len() == values.len() * Self::VALUE_BYTE_SIZE); + for (i, value) in values.iter().enumerate() { + let start = Self::VALUE_BYTE_SIZE * i; + let end = start + Self::VALUE_BYTE_SIZE; + let raw_repr = value.into_raw_repr(); + raw_repr.write_le(&mut buffer[start..end]).expect("will write"); + } + } + + fn decode_leaf_values(buffer: &[u8]) -> Vec { + debug_assert!(buffer.len() % Self::VALUE_BYTE_SIZE == 0); + let num_elements = buffer.len() / Self::VALUE_BYTE_SIZE; + let mut result = Vec::with_capacity(num_elements); + let mut raw_repr = F::zero().into_raw_repr(); + for i in 0..num_elements { + let start = Self::VALUE_BYTE_SIZE * i; + let end = start + Self::VALUE_BYTE_SIZE; + raw_repr.read_le(&buffer[start..end]).expect("will write"); + result.push(F::from_raw_repr(raw_repr).expect("must work")); + } + + result + } + + fn hash_into_leaf(values: &[F], scratch_space: &mut [u8]) -> [u8; 32] { + Self::encode_leaf_values(values, scratch_space); + *blake2s_const(scratch_space).as_array() + } + + fn make_full_path(&self, leaf_index: usize, leaf_pair_hash: [u8; 32]) -> Vec<[u8; 32]> { + let mut nodes = &self.nodes[..]; + + let mut path = vec![]; + path.push(leaf_pair_hash); + + let mut idx = leaf_index; + idx >>= 1; + + for _ in 0..log2_floor(nodes.len() / 2) { + let half_len = nodes.len() / 2; + let (next_level, this_level) = nodes.split_at(half_len); + let pair_idx = idx ^ 1usize; + let value = this_level[pair_idx]; + path.push(value); + idx >>= 1; + nodes = next_level; + } + + path + } +} + +impl IopInstance for FriSpecificBlake2sTree { + type Commitment = [u8; 32]; + type Params = FriSpecificBlake2sTreeParams; + type Query = CosetCombinedQuery; + + fn size(&self) -> usize { + self.size + } + + fn create(values: &[F], params: &Self::Params) -> Self { + assert!(params.values_per_leaf.is_power_of_two()); + + let values_per_leaf = params.values_per_leaf; + let num_leafs = values.len() / values_per_leaf; + assert!(num_leafs.is_power_of_two()); + + let num_nodes = num_leafs; + + let size = values.len(); + + let mut nodes = vec![[0u8; 32]; num_nodes]; + + let worker = Worker::new(); + + let mut leaf_hashes = vec![[0u8; 32]; num_leafs]; + + { + worker.scope(leaf_hashes.len(), |scope, chunk| { + for (i, lh) in leaf_hashes.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let base_idx = i*chunk; + let mut scratch_space = vec![0u8; Self::VALUE_BYTE_SIZE * values_per_leaf]; + for (j, lh) in lh.iter_mut().enumerate() { + let idx = base_idx + j; + let values_start = idx * values_per_leaf; + let values_end = values_start + values_per_leaf; + *lh = Self::hash_into_leaf(&values[values_start..values_end], &mut scratch_space); + } + }); + } + }); + } + + // leafs are now encoded and hashed, so let's make a tree + + let num_levels = log2_floor(num_leafs) as usize; + let mut nodes_for_hashing = &mut nodes[..]; + + // separately hash last level, which hashes leaf hashes into first nodes + { + let _level = num_levels-1; + let inputs = &mut leaf_hashes[..]; + let (_, outputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [0u8; 64]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0..32].copy_from_slice(&i[0]); + hash_input[32..64].copy_from_slice(&i[1]); + *o = *blake2s_const(&hash_input).as_array(); + } + }); + } + }); + } + + for _ in (0..(num_levels-1)).rev() { + // do the trick - split + let (next_levels, inputs) = nodes_for_hashing.split_at_mut(nodes_for_hashing.len()/2); + let (_, outputs) = next_levels.split_at_mut(next_levels.len() / 2); + assert!(outputs.len() * 2 == inputs.len()); + assert!(outputs.len().is_power_of_two()); + + worker.scope(outputs.len(), |scope, chunk| { + for (o, i) in outputs.chunks_mut(chunk) + .zip(inputs.chunks(chunk*2)) { + scope.spawn(move |_| { + let mut hash_input = [0u8; 64]; + for (o, i) in o.iter_mut().zip(i.chunks(2)) { + hash_input[0..32].copy_from_slice(&i[0]); + hash_input[32..64].copy_from_slice(&i[1]); + *o = *blake2s_const(&hash_input).as_array(); + } + }); + } + }); + + nodes_for_hashing = next_levels; + } + + Self { + size: size, + nodes: nodes, + params: params.clone(), + _marker: std::marker::PhantomData + } + } + + fn get_commitment(&self) -> Self::Commitment { + self.nodes[1] + } + + fn produce_query(&self, indexes: Vec, values: &[F]) -> Self::Query { + // we never expect that query is mis-alligned, so check it + debug_assert!(indexes[0] % self.params.values_per_leaf == 0); + debug_assert!(indexes.len() == self.params.values_per_leaf); + debug_assert!(indexes == (indexes[0]..(indexes[0]+self.params.values_per_leaf)).collect::>()); + debug_assert!(*indexes.last().expect("is some") < self.size()); + debug_assert!(*indexes.last().expect("is some") < values.len()); + + let query_values = Vec::from(&values[indexes[0]..(indexes[0]+self.params.values_per_leaf)]); + + let leaf_index = indexes[0] / self.params.values_per_leaf; + + let pair_index = leaf_index ^ 1; + + let mut scratch_space = vec![0u8; Self::VALUE_BYTE_SIZE * self.params.values_per_leaf]; + let leaf_pair_hash = Self::hash_into_leaf(&values[(pair_index*self.params.values_per_leaf)..((pair_index+1)*self.params.values_per_leaf)], &mut scratch_space); + + let path = self.make_full_path(leaf_index, leaf_pair_hash); + + CosetCombinedQuery:: { + indexes: indexes, + values: query_values, + path: path, + } + } + + fn verify_query(commitment: &Self::Commitment, query: &Self::Query, params: &Self::Params) -> bool { + if query.values().len() != params.values_per_leaf { + return false; + } + + let mut scratch_space = vec![0u8; Self::VALUE_BYTE_SIZE * params.values_per_leaf]; + let mut hash = Self::hash_into_leaf(query.values(), &mut scratch_space); + let mut idx = query.indexes()[0] / params.values_per_leaf; + let mut hash_input = [0u8; 64]; + + for el in query.path.iter() { + { + let (left, right) = hash_input.split_at_mut(32); + if idx & 1usize == 0 { + left.copy_from_slice(&hash[..]); + right.copy_from_slice(&el[..]); + } else { + right.copy_from_slice(&hash[..]); + left.copy_from_slice(&el[..]); + } + } + hash = *blake2s_const(&hash_input).as_array(); + idx >>= 1; + } + + &hash == commitment + } +} + +impl PartialEq for FriSpecificBlake2sTree { + fn eq(&self, other: &Self) -> bool { + self.get_commitment() == other.get_commitment() + } +} + +impl Eq for FriSpecificBlake2sTree {} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CosetCombinedQuery { + indexes: Vec, + values: Vec, + path: Vec<[u8; 32]>, +} + +impl IopQuery for CosetCombinedQuery { + fn indexes(&self) -> Vec { + self.indexes.clone() + } + + fn values(&self) -> &[F] { + &self.values + } +} + +#[test] +fn make_small_iop() { + use crate::ff::Field; + use crate::plonk::transparent_engine::Fr; + + const SIZE: usize = 16; + const VALUES_PER_LEAF: usize = 4; + + let params = FriSpecificBlake2sTreeParams { + values_per_leaf: VALUES_PER_LEAF + }; + + let mut inputs = vec![]; + let mut f = Fr::one(); + for _ in 0..SIZE { + inputs.push(f); + f.double(); + } + + let iop = FriSpecificBlake2sTree::create(&inputs, ¶ms); + let commitment = iop.get_commitment(); + let tree_size = iop.size(); + assert!(tree_size == SIZE); + assert!(iop.nodes.len() == (SIZE / VALUES_PER_LEAF)); + for i in 0..(SIZE / VALUES_PER_LEAF) { + let indexes: Vec<_> = ((i*VALUES_PER_LEAF)..(VALUES_PER_LEAF + i*VALUES_PER_LEAF)).collect(); + let query = iop.produce_query(indexes, &inputs); + let valid = FriSpecificBlake2sTree::verify_query(&commitment, &query, ¶ms); + assert!(valid, "invalid query for leaf index {}", i); + } +} + + +#[test] +fn test_bench_large_fri_specific_iop() { + use crate::ff::Field; + use crate::plonk::transparent_engine::Fr; + + const SIZE: usize = 1 << (20 + 4); + const VALUES_PER_LEAF: usize = 8; + + let params = FriSpecificBlake2sTreeParams { + values_per_leaf: VALUES_PER_LEAF + }; + + let mut inputs = vec![]; + let mut f = Fr::one(); + for _ in 0..SIZE { + inputs.push(f); + f.double(); + } + + let iop = FriSpecificBlake2sTree::create(&inputs, ¶ms); + let commitment = iop.get_commitment(); + let tree_size = iop.size(); + assert!(tree_size == SIZE); + assert!(iop.nodes.len() == (SIZE / VALUES_PER_LEAF)); + for i in 0..128 { + let indexes: Vec<_> = ((i*VALUES_PER_LEAF)..(VALUES_PER_LEAF + i*VALUES_PER_LEAF)).collect(); + let query = iop.produce_query(indexes, &inputs); + let valid = FriSpecificBlake2sTree::verify_query(&commitment, &query, ¶ms); + assert!(valid, "invalid query for leaf index {}", i); + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/iop_compiler/mod.rs b/src/plonk/commitments/transparent/iop_compiler/mod.rs new file mode 100644 index 000000000..40d409a0e --- /dev/null +++ b/src/plonk/commitments/transparent/iop_compiler/mod.rs @@ -0,0 +1,26 @@ +use crate::ff::PrimeField; + +pub mod coset_combining_blake2s_tree; + +pub trait Commitment: Clone + Eq + PartialEq + std::fmt::Debug {} + +pub trait IopInstance: PartialEq + Eq { + type Commitment: Clone + Eq + PartialEq + std::fmt::Debug; + type Query: IopQuery; + type Params: Clone + Eq + PartialEq + std::fmt::Debug; + + fn create(values: &[F], params: &Self::Params) -> Self; + fn size(&self) -> usize; + fn get_commitment(&self) -> Self::Commitment; + fn verify_query(commitment: &Self::Commitment, query: &Self::Query, params: &Self::Params) -> bool; + fn produce_query(&self, indexes: Vec, values: &[F]) -> Self::Query; +} + +pub trait IopQuery: 'static + PartialEq + Eq + Clone + std::fmt::Debug { + fn indexes(&self) -> Vec; + fn values(&self) -> &[F]; +} + +// const fn byte_size() -> usize { +// (((F::NUM_BITS as usize) / 64) + 1) * 8 +// } \ No newline at end of file diff --git a/src/plonk/commitments/transparent/mod.rs b/src/plonk/commitments/transparent/mod.rs new file mode 100644 index 000000000..5dd4a74ec --- /dev/null +++ b/src/plonk/commitments/transparent/mod.rs @@ -0,0 +1,742 @@ +use crate::pairing::ff::PrimeField; + +use crate::plonk::polynomials::*; +use crate::worker::Worker; +use super::CommitmentScheme; + +pub mod precomputations; +pub mod iop; +pub mod fri; +pub mod iop_compiler; + +pub mod utils; + +use self::precomputations::PrecomputedInvOmegas; +use crate::plonk::domains::*; +use crate::plonk::commitments::transcript::Prng; +use crate::plonk::commitments::transparent::fri::*; +use crate::plonk::commitments::transparent::iop::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas}; + +// Such committer uses external transcript for all the operations +pub struct StatelessTransparentCommitter< + F: PrimeField, + FRI: FriIop, + T: Transcript >::IopType as IOP >::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput > +>{ + max_degree_plus_one: usize, + lde_factor: usize, + output_coeffs_at_degree_plus_one: usize, + num_queries: usize, + worker: Worker, + precomputed_inverse_omegas: PrecomputedInvOmegas, + precomputed_bitreversed_omegas: BitReversedOmegas, + fri_params: >::Params, + _marker_fri: std::marker::PhantomData, + _marker_t: std::marker::PhantomData +} + +impl< + F: PrimeField, + FRI: FriIop, + T: Transcript >::IopType as IOP >::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput > +> std::fmt::Debug for StatelessTransparentCommitter { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { + writeln!(f, "Stateless transparent committer") + } +} + +#[derive(Debug)] +pub struct TransparentCommitterParameters>{ + pub lde_factor: usize, + pub num_queries: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub fri_params: >::Params, +} + +impl> Clone for TransparentCommitterParameters { + fn clone(&self) -> Self { + TransparentCommitterParameters::{ + lde_factor: self.lde_factor, + num_queries: self.num_queries, + output_coeffs_at_degree_plus_one: self.output_coeffs_at_degree_plus_one, + fri_params: self.fri_params.clone(), + } + } +} + +use std::time::Instant; + +impl< + F: PrimeField, + FRI: FriIop, + T: Transcript >::IopType as IOP >::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput > +> CommitmentScheme for StatelessTransparentCommitter { + type Commitment = < < < >::IopType as IOP >::Tree as IopTree >::TreeHasher as IopTreeHasher>::HashOutput; + type OpeningProof = (FRI::Proof, Vec >::IopType as IOP >::Query) > >); + type IntermediateData = (Polynomial, < FRI as FriIop >::IopType); + type Meta = TransparentCommitterParameters; + type Prng = T; + + const REQUIRES_PRECOMPUTATION: bool = true; + const IS_HOMOMORPHIC: bool = false; + + fn new_for_size(max_degree_plus_one: usize, meta: Self::Meta) -> Self { + let base_size = max_degree_plus_one.next_power_of_two(); + assert!(meta.lde_factor.is_power_of_two()); + assert!(meta.output_coeffs_at_degree_plus_one.is_power_of_two()); + let lde_domain_size = base_size*meta.lde_factor; + let base_domain = Domain::::new_for_size(base_size as u64).expect("domain of large enough size should exist"); + let lde_domain = Domain::::new_for_size(lde_domain_size as u64).expect("domain of large enough size should exist"); + let worker = Worker::new(); + let omegas_inv_precomp = PrecomputedInvOmegas::::new_for_domain(&lde_domain, &worker); + let omegas_bitrev_precomp = BitReversedOmegas::::new_for_domain(&base_domain, &worker); + + StatelessTransparentCommitter:: { + max_degree_plus_one: max_degree_plus_one, + lde_factor: meta.lde_factor, + output_coeffs_at_degree_plus_one: meta.output_coeffs_at_degree_plus_one, + num_queries: meta.num_queries, + worker: worker, + precomputed_inverse_omegas: omegas_inv_precomp, + precomputed_bitreversed_omegas: omegas_bitrev_precomp, + fri_params: meta.fri_params, + _marker_fri: std::marker::PhantomData, + _marker_t: std::marker::PhantomData + } + } + + fn precompute(&self, poly: &Polynomial) -> Option { + assert!(poly.size() == self.max_degree_plus_one); + let original_poly_lde = poly.clone().lde_using_bitreversed_ntt(&self.worker, self.lde_factor, &self.precomputed_bitreversed_omegas).expect("must make an LDE"); + // let original_poly_lde = poly.clone().lde(&self.worker, self.lde_factor).expect("must make an LDE"); + let original_tree = < < FRI as FriIop >::IopType as IOP >::create(&original_poly_lde.as_ref()); + + Some((original_poly_lde, original_tree)) + } + + fn commit_single(&self, poly: &Polynomial) -> (Self::Commitment, Option) { + println!("Start commit single"); + let start = Instant::now(); + let original_poly_lde = poly.clone().lde_using_bitreversed_ntt(&self.worker, self.lde_factor, &self.precomputed_bitreversed_omegas).expect("must make an LDE"); + // let original_poly_lde = poly.clone().lde(&self.worker, self.lde_factor).expect("must make an LDE"); + let original_tree = < < FRI as FriIop >::IopType as IOP >::create(&original_poly_lde.as_ref()); + let commitment = original_tree.get_root(); + + println!("Done in {:?} for max degree {}", start.elapsed(), poly.size()); + println!("Done commit single"); + + (commitment, Some((original_poly_lde, original_tree))) + + } + + fn commit_multiple(&self, polynomials: Vec<&Polynomial>, degrees: Vec, aggregation_coefficient: F) -> (Self::Commitment, Option>) { + unimplemented!() + } + + fn open_single( + &self, + poly: &Polynomial, + at_point: F, + _opening_value: F, + data: &Option<&Self::IntermediateData>, + prng: &mut Self::Prng + ) -> Self::OpeningProof { + println!("Start open single"); + let start = Instant::now(); + + // do not need to to the subtraction cause last coefficient is never used by division + let division_result = { + let division_result = kate_divison_with_same_return_size(poly.as_ref(), at_point); + + division_result + }; + + let q_poly = Polynomial::::from_coeffs(division_result).expect("must be small enough"); + let q_poly_lde = q_poly.lde_using_bitreversed_ntt(&self.worker, self.lde_factor, &self.precomputed_bitreversed_omegas).expect("must make an LDE"); + // let q_poly_lde = q_poly.lde(&self.worker, self.lde_factor).expect("must make an LDE"); + + let lde_size = q_poly_lde.size(); + + let fri_proto = FRI::proof_from_lde( + &q_poly_lde, + self.lde_factor, + self.output_coeffs_at_degree_plus_one, + &self.precomputed_inverse_omegas, + &self.worker, + prng, + &self.fri_params + ).expect("FRI must succeed"); + + for c in fri_proto.get_final_coefficients().iter() { + prng.commit_field_element(&c); + } + + let mut used_queries: Vec = vec![]; + + let mut domain_indexes = vec![]; + + // even while this is conditional, it can be changed to unconditional given large enough field + + while domain_indexes.len() < self.num_queries { + let domain_idx = bytes_to_challenge_index(prng.get_challenge_bytes(), lde_size); + let coset_index_values = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_coset_for_natural_index(domain_idx, lde_size); + let mut can_use = true; + for v in coset_index_values.iter() { + if used_queries.contains(&v) { + can_use = false; + break + } + } + if can_use { + domain_indexes.push(domain_idx); + used_queries.extend(coset_index_values); + } + } + + let q_poly_fri_proof = FRI::prototype_into_proof(fri_proto, &q_poly_lde, domain_indexes.clone(), &self.fri_params).expect("must generate a proper proof"); + + let mut original_poly_queries = vec![]; + + let precomputations = if data.is_some() { + None + } else { + self.precompute(&poly) + }; + + let (original_poly_lde, original_poly_lde_oracle) = if let Some((lde, oracle)) = data.as_ref() { + (lde, oracle) + } else if let Some((lde, oracle)) = precomputations.as_ref() { + (lde, oracle) + } else { + unreachable!("precomputations are required for transparent polynomial commitment"); + }; + + for idx in domain_indexes.into_iter() { + let original_value = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_for_natural_index(original_poly_lde.as_ref(), idx); + let original_poly_query = original_poly_lde_oracle.query(idx, original_poly_lde.as_ref()); + original_poly_queries.push((*original_value, original_poly_query)); + } + + println!("Done in {:?} for max degree {}", start.elapsed(), poly.size()); + println!("Done open single"); + + (q_poly_fri_proof, vec![original_poly_queries]) + + } + + fn open_multiple( + &self, + polynomials: Vec<&Polynomial>, + degrees: Vec, + aggregation_coefficient: F, + at_points: Vec, + opening_values: Vec, + data: &Option>, + prng: &mut Self::Prng + ) -> Self::OpeningProof { + println!("Start open multiple"); + let start = Instant::now(); + assert!(at_points.len() == opening_values.len()); + assert!(at_points.len() == polynomials.len()); + + let max_degree = *degrees.iter().max().expect("MAX element exists"); + let min_degree = *degrees.iter().min().expect("MIN element exists"); + + assert!(f64::from(max_degree as u32) / f64::from(min_degree as u32) < 2.0, "polynomials should not have too large degree difference"); + + let mut division_results = vec![vec![]; polynomials.len()]; + + self.worker.scope(polynomials.len(), |scope, chunk| { + for ((p, q), at) in polynomials.chunks(chunk) + .zip(division_results.chunks_mut(chunk)) + .zip(at_points.chunks(chunk)) + { + scope.spawn(move |_| { + for ((p, q), at) in p.iter().zip(q.iter_mut()).zip(at.iter()) { + let division_result = kate_divison_with_same_return_size(p.as_ref(), *at); + + *q = division_result; + } + }); + } + }); + + // aggregate starting usign the first coefficient of 1 + + let mut q_poly: Option> = None; + + let mut alpha = F::one(); + + for q in division_results.into_iter() { + if let Some(q_poly) = q_poly.as_mut() { + let q = Polynomial::::from_coeffs(q).expect("must be small enough"); + q_poly.add_assign_scaled(&self.worker, &q, &alpha); + } else { + let q = Polynomial::::from_coeffs(q).expect("must be small enough"); + q_poly = Some(q); + } + alpha.mul_assign(&aggregation_coefficient); + } + + let q_poly = q_poly.expect("now it's aggregated"); + + let q_poly_lde = q_poly.lde_using_bitreversed_ntt(&self.worker, self.lde_factor, &self.precomputed_bitreversed_omegas).expect("must make an LDE"); + + // let q_poly_lde = q_poly.lde(&self.worker, self.lde_factor).expect("must make an LDE"); + + let lde_size = q_poly_lde.size(); + + let fri_proto = FRI::proof_from_lde( + &q_poly_lde, + self.lde_factor, + self.output_coeffs_at_degree_plus_one, + &self.precomputed_inverse_omegas, + &self.worker, + prng, + &self.fri_params + ).expect("FRI must succeed"); + + for c in fri_proto.get_final_coefficients().iter() { + prng.commit_field_element(&c); + } + + let mut used_queries: Vec = vec![]; + + let mut domain_indexes = vec![]; + + // even while this is conditional, it can be changed to unconditional given large enough field + + while domain_indexes.len() < self.num_queries { + let domain_idx = bytes_to_challenge_index(prng.get_challenge_bytes(), lde_size); + let coset_index_values = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_coset_for_natural_index(domain_idx, lde_size); + let mut can_use = true; + for v in coset_index_values.iter() { + if used_queries.contains(&v) { + can_use = false; + break + } + } + if can_use { + domain_indexes.push(domain_idx); + used_queries.extend(coset_index_values); + } + } + + let q_poly_fri_proof = FRI::prototype_into_proof( + fri_proto, + &q_poly_lde, + domain_indexes.clone(), + &self.fri_params + ).expect("must generate a proper proof"); + + let precomputations = if data.is_some() { + None + } else { + let mut result = Vec::with_capacity(polynomials.len()); + for poly in polynomials.iter() { + let p = self.precompute(&poly).expect("aux data is computed"); + result.push(p); + } + + Some(result) + }; + + let mut prec_may_be = None; + + let data = if data.is_some() { + data.as_ref() + } else { + prec_may_be = Some(precomputations.as_ref().expect("is some").iter().map(|el| el).collect::>()); + prec_may_be.as_ref() + }.expect("there is aux data in full"); + + let mut queries = vec![]; + + for (original_poly_lde, original_poly_lde_oracle) in data.iter() { + let mut original_poly_queries = vec![]; + for idx in domain_indexes.clone().into_iter() { + let original_value = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_for_natural_index(original_poly_lde.as_ref(), idx); + let original_poly_query = original_poly_lde_oracle.query(idx, original_poly_lde.as_ref()); + original_poly_queries.push((*original_value, original_poly_query)); + } + queries.push(original_poly_queries); + } + + // let mut opened_values = vec![]; + + // for idx in domain_indexes.clone().into_iter() { + // let value = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_for_natural_index(q_poly_lde.as_ref(), idx); + // opened_values.push(value); + // } + + // println!("Will open poly at indexes {:?} for values {:?}", domain_indexes, opened_values); + + + println!("Done in {:?} for max degree {}", start.elapsed(), max_degree); + println!("Done open multiple"); + + (q_poly_fri_proof, queries) + } + + fn verify_single(&self, commitment: &Self::Commitment, at_point: F, claimed_value: F, proof: &Self::OpeningProof, prng: &mut Self::Prng) -> bool { + let (q_poly_fri_proof, original_poly_queries_vec) = proof; + + assert!(original_poly_queries_vec.len() == 1); + + let original_poly_queries = &original_poly_queries_vec[0]; + + let lde_size = self.max_degree_plus_one.next_power_of_two() * self.lde_factor; + let lde_domain = Domain::::new_for_size(lde_size as u64).expect("large enough domain must exist"); + + // first get FRI challenges + + let fri_challenges = FRI::get_fri_challenges(q_poly_fri_proof, prng, &self.fri_params); + + for c in q_poly_fri_proof.get_final_coefficients().iter() { + prng.commit_field_element(&c); + } + + // then make expected query locations + + let mut used_queries: Vec = vec![]; + + let mut domain_indexes = vec![]; + + // even while this is conditional, it can be changed to unconditional given large enough field + + while domain_indexes.len() < self.num_queries { + let domain_idx = bytes_to_challenge_index(prng.get_challenge_bytes(), lde_size); + let coset_index_values = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_coset_for_natural_index(domain_idx, lde_size); + let mut can_use = true; + for v in coset_index_values.iter() { + if used_queries.contains(&v) { + can_use = false; + break + } + } + if can_use { + domain_indexes.push(domain_idx); + used_queries.extend(coset_index_values); + } + } + + // now simulate expected values + + let mut simulated_q_poly_values = vec![]; + + for (domain_idx, original_poly_query) in domain_indexes.clone().into_iter() + .zip(original_poly_queries.iter()) { + let x = lde_domain.generator.pow(&[domain_idx as u64]); + + assert!(original_poly_query.1.value() == original_poly_query.0); + + let mut num = original_poly_query.0; + num.sub_assign(&claimed_value); + + let mut den = x; + den.sub_assign(&at_point); + + let den_inversed = den.inverse().expect("denominator is unlikely to be zero in large enough field"); + + let mut value_at_x = num; + value_at_x.mul_assign(&den_inversed); + + let is_in_commitment = < >::IopType as IOP >::verify_query(&original_poly_query.1, commitment); + if !is_in_commitment { + return false; + } + + simulated_q_poly_values.push(value_at_x); + } + + let valid = FRI::verify_proof_with_challenges( + q_poly_fri_proof, + domain_indexes, + &simulated_q_poly_values, + &fri_challenges, + &self.fri_params + ).expect("fri verification should work"); + + valid + } + + fn verify_multiple_openings( + &self, + commitments: Vec<&Self::Commitment>, + at_points: Vec, + claimed_values: &Vec, + aggregation_coefficient: F, + proof: &Self::OpeningProof, + prng: &mut Self::Prng + ) -> bool { + let (q_poly_fri_proof, original_poly_queries_vec) = proof; + + let lde_size = self.max_degree_plus_one.next_power_of_two() * self.lde_factor; + let lde_domain = Domain::::new_for_size(lde_size as u64).expect("large enough domain must exist"); + + // first get FRI challenges + + let fri_challenges = FRI::get_fri_challenges(q_poly_fri_proof, prng, &self.fri_params); + + for c in q_poly_fri_proof.get_final_coefficients().iter() { + prng.commit_field_element(&c); + } + + // then make expected query locations + + let mut used_queries: Vec = vec![]; + + let mut domain_indexes = vec![]; + + // even while this is conditional, it can be changed to unconditional given large enough field + + while domain_indexes.len() < self.num_queries { + let domain_idx = bytes_to_challenge_index(prng.get_challenge_bytes(), lde_size); + let coset_index_values = < < >::IopType as IOP >::Combiner as CosetCombiner>::get_coset_for_natural_index(domain_idx, lde_size); + let mut can_use = true; + for v in coset_index_values.iter() { + if used_queries.contains(&v) { + can_use = false; + break + } + } + if can_use { + domain_indexes.push(domain_idx); + used_queries.extend(coset_index_values); + } + } + + // now simulate expected values + + let mut simulated_q_poly_values = vec![F::zero(); domain_indexes.len()]; + + assert!(original_poly_queries_vec.len() == claimed_values.len()); + + // accumulate value of the q poly over subpolys + + let mut alpha = F::one(); + + for subpoly_index in 0..original_poly_queries_vec.len() { + let subpoly_queries = &original_poly_queries_vec[subpoly_index]; + let claimed_value = claimed_values[subpoly_index]; + let subpoly_commitment = commitments[subpoly_index]; + let opening_at = &at_points[subpoly_index]; + + let mut simulated_q_poly_subvalues = vec![]; + + for (domain_idx, original_poly_query) in domain_indexes.clone().into_iter() + .zip(subpoly_queries.iter()) { + + let x = lde_domain.generator.pow(&[domain_idx as u64]); + + assert!(original_poly_query.1.value() == original_poly_query.0); + + let mut num = original_poly_query.0; + num.sub_assign(&claimed_value); + + let mut den = x; + den.sub_assign(&opening_at); + + let den_inversed = den.inverse().expect("denominator is unlikely to be zero in large enough field"); + + let mut value_at_x = num; + value_at_x.mul_assign(&den_inversed); + + let is_in_commitment = < >::IopType as IOP >::verify_query(&original_poly_query.1, subpoly_commitment); + if !is_in_commitment { + println!("Not in the root for subpoly {} out of {}", subpoly_index, original_poly_queries_vec.len()); + return false; + } + + simulated_q_poly_subvalues.push(value_at_x); + } + + // in simulated_q_poly_values now there are values of this polynomial for all the queries, + // now we need to sum them up with a proper coefficients starting with 0 + + for (a, s) in simulated_q_poly_values.iter_mut().zip(simulated_q_poly_subvalues.iter()) { + let mut tmp = *s; + tmp.mul_assign(&alpha); + a.add_assign(&tmp); + } + + alpha.mul_assign(&aggregation_coefficient); + } + + // println!("Will open poly at indexes {:?} for simulated values {:?}", domain_indexes, simulated_q_poly_values); + + let valid = FRI::verify_proof_with_challenges( + q_poly_fri_proof, + domain_indexes, + &simulated_q_poly_values, + &fri_challenges, + &self.fri_params + ).expect("fri verification should work"); + + valid + } +} + + +// use single threaded Kate division for now +fn kate_divison_with_same_return_size(a: &[F], mut b: F) -> Vec +{ + b.negate(); + + let mut q = vec![F::zero(); a.len()]; + + let mut tmp = F::zero(); + let mut found_one = false; + for (q, r) in q.iter_mut().rev().skip(1).zip(a.iter().rev()) { + if !found_one { + if r.is_zero() { + continue + } else { + found_one = true; + } + } + + let mut lead_coeff = *r; + lead_coeff.sub_assign(&tmp); + *q = lead_coeff; + tmp = lead_coeff; + tmp.mul_assign(&b); + } + + q +} + +// this one is not ZK cause will expose values not from LDE, but from the original domain too +fn bytes_to_challenge_index>(bytes: S, lde_size: usize) -> usize { + use byteorder::{BigEndian, ByteOrder}; + + let as_ref = bytes.as_ref(); + let natural_x_index = BigEndian::read_u64(&as_ref[(as_ref.len() - 8)..]); + + let natural_x_index = natural_x_index as usize; + let natural_x_index = natural_x_index % lde_size; + + natural_x_index +} + + +#[cfg(test)] +mod test { + + use super::*; + use crate::pairing::ff::{Field, PrimeField}; + + use crate::{SynthesisError}; + use std::marker::PhantomData; + + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + + + #[test] + fn test_small_transparent_commitment() { + use crate::pairing::bn256::{Bn256, Fr}; + + const SIZE:usize = 16; + + let worker = Worker::new(); + + // let coeffs: Vec<_> = (0..SIZE).collect(); + // let coeffs: Vec<_> = vec![1, 1, 0, 0, 0, 0, 0, 0]; + let coeffs: Vec<_> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; + let coeffs = convert_to_field_elements(&coeffs, &worker); + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + + let mut transcript = Blake2sTranscript::::new(); + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + let committer = >::new_for_size(SIZE, meta); + + let (commitment, aux_data) = committer.commit_single(&poly); + + let open_at = Fr::from_str("123").unwrap(); + + let expected_at_z = poly.evaluate_at(&worker, open_at); + + let proof = committer.open_single(&poly, open_at, expected_at_z, &aux_data.as_ref(), &mut transcript); + + let mut transcript = Blake2sTranscript::::new(); + + let valid = committer.verify_single(&commitment, open_at, expected_at_z, &proof, &mut transcript); + + assert!(valid); + } + + #[test] + fn test_large_transparent_commitment() { + use std::time::Instant; + use crate::pairing::bn256::{Bn256, Fr}; + + let worker = Worker::new(); + + const SIZE:usize = 1 << 20; + // const SIZE:usize = 1 << 10; + + let coeffs: Vec<_> = (0..SIZE).collect(); + let coeffs = convert_to_field_elements(&coeffs, &worker); + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + + let mut transcript = Blake2sTranscript::::new(); + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 6, // ~100 bits of security + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let committer = >::new_for_size(SIZE, meta); + + let now = Instant::now(); + + let (commitment, aux_data) = committer.commit_single(&poly); + + println!("Commitment taken {:?}", now.elapsed()); + + let open_at = Fr::from_str("123").unwrap(); + + let expected_at_z = poly.evaluate_at(&worker, open_at); + + let now = Instant::now(); + + let proof = committer.open_single(&poly, open_at, expected_at_z, &aux_data.as_ref(), &mut transcript); + + println!("Opening taken {:?}", now.elapsed()); + + let mut transcript = Blake2sTranscript::::new(); + + let now = Instant::now(); + + let valid = committer.verify_single(&commitment, open_at, expected_at_z, &proof, &mut transcript); + + println!("Verification taken {:?}", now.elapsed()); + + assert!(valid); + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/precomputations/mod.rs b/src/plonk/commitments/transparent/precomputations/mod.rs new file mode 100644 index 000000000..cc6c89972 --- /dev/null +++ b/src/plonk/commitments/transparent/precomputations/mod.rs @@ -0,0 +1,153 @@ +use crate::pairing::ff::PrimeField; + +use crate::plonk::domains::Domain; +use crate::worker::Worker; +use crate::plonk::fft::distribute_powers; +use crate::plonk::commitments::transparent::fri::FriPrecomputations; +use crate::plonk::fft::with_precomputation::FftPrecomputations; + +pub struct PrecomputedOmegas { + pub omegas: Vec, + pub coset: Vec, + pub omegas_inv: Vec, + domain_size: usize +} + +impl PrecomputedOmegas { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + let precomputation_size = domain_size/2; + + let omega = domain.generator; + let omega_inv = domain.generator.inverse().expect("must exist"); + + let mut omegas = vec![F::zero(); domain_size]; + let mut omegas_inv = vec![F::zero(); precomputation_size]; + + worker.scope(omegas.len(), |scope, chunk| { + for (i, v) in omegas.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega); + } + }); + } + }); + + worker.scope(omegas_inv.len(), |scope, chunk| { + for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega_inv.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega_inv); + } + }); + } + }); + + let mut coset = omegas.clone(); + let mult_generator = F::multiplicative_generator(); + + worker.scope(coset.len(), |scope, chunk| { + for v in coset.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + v.mul_assign(&mult_generator); + } + }); + } + }); + + PrecomputedOmegas{ + omegas, + coset, + omegas_inv, + domain_size + } + } +} + +impl FriPrecomputations for PrecomputedOmegas{ + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn omegas_inv_ref(&self) -> &[F] { + &self.omegas_inv[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} + +impl FftPrecomputations for PrecomputedOmegas{ + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn element_for_index(&self, index: usize) -> &F { + &self.omegas_inv[index] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} + +pub struct PrecomputedInvOmegas { + pub omegas_inv: Vec, + domain_size: usize +} + +impl PrecomputedInvOmegas { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + let precomputation_size = domain_size/2; + + let omega = domain.generator; + let omega_inv = omega.inverse().expect("must exist"); + + let mut omegas_inv = vec![F::zero(); precomputation_size]; + + worker.scope(omegas_inv.len(), |scope, chunk| { + for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega_inv.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega_inv); + } + }); + } + }); + + PrecomputedInvOmegas{ + omegas_inv, + domain_size + } + } +} + +impl FriPrecomputations for PrecomputedInvOmegas{ + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn omegas_inv_ref(&self) -> &[F] { + &self.omegas_inv[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} \ No newline at end of file diff --git a/src/plonk/commitments/transparent/utils.rs b/src/plonk/commitments/transparent/utils.rs new file mode 100644 index 000000000..446858303 --- /dev/null +++ b/src/plonk/commitments/transparent/utils.rs @@ -0,0 +1,11 @@ +pub fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} \ No newline at end of file diff --git a/src/plonk/cs/gates.rs b/src/plonk/cs/gates.rs new file mode 100644 index 000000000..e4d9c0a95 --- /dev/null +++ b/src/plonk/cs/gates.rs @@ -0,0 +1,268 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; +use std::ops::{Add, Sub, Neg}; + +pub use super::variable::{Variable, Index}; + +pub enum Coeff { + Zero, + One, + NegativeOne, + Full(F), +} + +impl std::fmt::Debug for Coeff { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Coeff::Zero => { + write!(f, "Coeff 0x0") + }, + Coeff::One => { + write!(f, "Coeff 0x1") + }, + Coeff::NegativeOne => { + write!(f, "Coeff -0x1") + }, + Coeff::Full(c) => { + write!(f, "Coeff {:?}", c) + }, + } + } +} + +impl Coeff { + pub fn multiply(&self, with: &mut F) { + match self { + Coeff::Zero => { + *with = F::zero(); + }, + Coeff::One => {}, + Coeff::NegativeOne => { + with.negate(); + }, + Coeff::Full(val) => { + with.mul_assign(val); + } + } + } + + pub fn new(coeff: F) -> Self { + let mut negative_one = F::one(); + negative_one.negate(); + + if coeff.is_zero() { + Coeff::::Zero + } else if coeff == F::one() { + Coeff::::One + } else if coeff == negative_one { + Coeff::::NegativeOne + } else { + Coeff::::Full(coeff) + } + } +} + +impl Copy for Coeff {} +impl Clone for Coeff { + fn clone(&self) -> Self { + *self + } +} + +impl Neg for Coeff { + type Output = Coeff; + + fn neg(self) -> Self { + match self { + Coeff::Zero => Coeff::Zero, + Coeff::One => Coeff::NegativeOne, + Coeff::NegativeOne => Coeff::One, + Coeff::Full(mut a) => { + a.negate(); + Coeff::Full(a) + } + } + } +} + +#[derive(Copy, Clone)] +pub struct Gate { + a_wire: Variable, + b_wire: Variable, + c_wire: Variable, + pub(crate) q_l: Coeff, + pub(crate) q_r: Coeff, + pub(crate) q_o: Coeff, + pub(crate) q_m: Coeff, + pub(crate) q_c: Coeff, +} + +impl std::fmt::Debug for Gate { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "Gate A = {:?}, B = {:?}, C = {:?}, q_l = {:?}, q_r = {:?}, q_o = {:?}, q_m = {:?}, q_c = {:?}", + self.a_wire, self.b_wire, self.c_wire, self.q_l, self.q_r, self.q_o, self.q_m, self.q_c) + + } +} + +impl Gate { + pub(crate) fn empty() -> Self { + Self { + a_wire: Variable(Index::Aux(0)), + b_wire: Variable(Index::Aux(0)), + c_wire: Variable(Index::Aux(0)), + q_l: Coeff::::Zero, + q_r: Coeff::::Zero, + q_o: Coeff::::Zero, + q_m: Coeff::::Zero, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn a_wire(&self) -> &Variable { + &self.a_wire + } + + pub(crate) fn b_wire(&self) -> &Variable { + &self.b_wire + } + + pub(crate) fn c_wire(&self) -> &Variable { + &self.c_wire + } + + pub(crate) fn new_multiplication_gate(variables: (Variable, Variable, Variable)) -> Self { + + Self { + a_wire: variables.0, + b_wire: variables.1, + c_wire: variables.2, + q_l: Coeff::::Zero, + q_r: Coeff::::Zero, + q_o: Coeff::::NegativeOne, + q_m: Coeff::::One, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn new_addition_gate(variables: (Variable, Variable, Variable)) -> Self { + Self { + a_wire: variables.0, + b_wire: variables.1, + c_wire: variables.2, + q_l: Coeff::::One, + q_r: Coeff::::One, + q_o: Coeff::::NegativeOne, + q_m: Coeff::::Zero, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn new_lc_gate(variables: (Variable, Variable, Variable), coeffs: (F, F, F), constant: F) -> Self { + let (a_coeff, b_coeff, c_coeff) = coeffs; + + Self { + a_wire: variables.0, + b_wire: variables.1, + c_wire: variables.2, + q_l: Coeff::::Full(a_coeff), + q_r: Coeff::::Full(b_coeff), + q_o: Coeff::::Full(c_coeff), + q_m: Coeff::::Zero, + q_c: Coeff::::new(constant), + } + } + + pub(crate) fn new_enforce_zero_gate(variables: (Variable, Variable, Variable), coeffs: (F, F, F)) -> Self { + let (a_coeff, b_coeff, c_coeff) = coeffs; + + Self { + a_wire: variables.0, + b_wire: variables.1, + c_wire: variables.2, + q_l: Coeff::::Full(a_coeff), + q_r: Coeff::::Full(b_coeff), + q_o: Coeff::::Full(c_coeff), + q_m: Coeff::::Zero, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn new_enforce_boolean_gate(variable: Variable, dummy_variable: Variable) -> Self { + + Self { + a_wire: variable, + b_wire: variable, + c_wire: dummy_variable, + q_l: Coeff::::NegativeOne, + q_r: Coeff::::Zero, + q_o: Coeff::::Zero, + q_m: Coeff::::One, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn new_empty_gate(dummy_variable: Variable) -> Self { + + Self { + a_wire: dummy_variable, + b_wire: dummy_variable, + c_wire: dummy_variable, + q_l: Coeff::::Zero, + q_r: Coeff::::Zero, + q_o: Coeff::::Zero, + q_m: Coeff::::Zero, + q_c: Coeff::::Zero, + } + } + + pub(crate) fn new_enforce_constant_gate(variable: Variable, constant: Option, dummy_variable: Variable) -> Self { + let mut negative_one = F::one(); + negative_one.negate(); + + let q_c = if let Some(constant) = constant { + let mut const_negated = constant; + const_negated.negate(); + let coeff = if const_negated.is_zero() { + Coeff::::Zero + } else if const_negated == F::one() { + Coeff::::One + } else if const_negated == negative_one { + Coeff::::NegativeOne + } else { + Coeff::::Full(const_negated) + }; + + coeff + } else { + Coeff::::Zero + }; + + Self { + a_wire: variable, + b_wire: dummy_variable, + c_wire: dummy_variable, + q_l: Coeff::::One, + q_r: Coeff::::Zero, + q_o: Coeff::::Zero, + q_m: Coeff::::Zero, + q_c: q_c, + } + } + + pub(crate) fn new_gate(variables: (Variable, Variable, Variable), + coeffs: (F, F, F, F, F)) -> Self { + let (q_l, q_r, q_o, q_m, q_c) = coeffs; + + Self { + a_wire: variables.0, + b_wire: variables.1, + c_wire: variables.2, + q_l: Coeff::new(q_l), + q_r: Coeff::new(q_r), + q_o: Coeff::new(q_o), + q_m: Coeff::new(q_m), + q_c: Coeff::new(q_c), + } + } +} diff --git a/src/plonk/cs/mod.rs b/src/plonk/cs/mod.rs new file mode 100644 index 000000000..5d3c18cb0 --- /dev/null +++ b/src/plonk/cs/mod.rs @@ -0,0 +1,127 @@ +use crate::pairing::ff::{Field}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +pub mod gates; +pub mod variable; + +use self::variable::*; +use self::gates::*; + +pub trait Circuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError>; +} + +pub trait ConstraintSystem { + // const ZERO: Variable; + // const ONE: Variable; + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result; + + // // allocate a multiplication gate + // fn multiply(&mut self, values: F) -> Result<(Variable, Variable, Variable), SynthesisError> + // where + // F: FnOnce() -> Result<(E::Fr, E::Fr, E::Fr), SynthesisError>; + + // // allocate an addition gate + // fn add(&mut self, values: F) -> Result<(Variable, Variable, Variable), SynthesisError> + // where + // F: FnOnce() -> Result<(E::Fr, E::Fr, E::Fr), SynthesisError>; + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError>; + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), + coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError>; + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError>; + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError>; + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError>; + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError>; + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError>; + + + // // allocate a linear combination gate + // fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr), values: F) -> Result<(), SynthesisError>; + + // // allocate a linear combination gate + // fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr), values: F) -> Result<(), SynthesisError>; + + // // allocate a linear combination gate + // fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr), values: F) -> Result<(), SynthesisError> + // where + // F: FnOnce() -> Result<(E::Fr, E::Fr), SynthesisError>; + + // // allocate a linear combination gate + // fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr), values: F) -> Result<(), SynthesisError> + // where + // F: FnOnce() -> Result<(E::Fr, E::Fr, E::Fr), SynthesisError>; + + fn get_value(&self, _variable: Variable) -> Result { + Err(SynthesisError::AssignmentMissing) + } + + fn get_dummy_variable(&self) -> Variable; + + // fn get_dummy_variable(&self) -> Variable { + // >::ZERO + // } +} + + + +// /// This is a backend for the `SynthesisDriver` to relay information about +// /// the concrete circuit. One backend might just collect basic information +// /// about the circuit for verification, while another actually constructs +// /// a witness. +// pub trait Backend { +// type LinearConstraintIndex; + +// /// Get the value of a variable. Can return None if we don't know. +// fn get_var(&self, _variable: Variable) -> Option { None } + +// /// Set the value of a variable. Might error if this backend expects to know it. +// fn set_var(&mut self, _variable: Variable, _value: F) -> Result<(), SynthesisError> +// where F: FnOnce() -> Result { Ok(()) } + +// /// Create a new multiplication gate. +// fn new_multiplication_gate(&mut self) { } + +// /// Create a new linear constraint, returning the power of Y for caching purposes. +// fn new_linear_constraint(&mut self) -> Self::LinearConstraintIndex; + +// /// Insert a term into a linear constraint. TODO: bad name of function +// fn insert_coefficient(&mut self, _var: Variable, _coeff: Coeff, _y: &Self::LinearConstraintIndex) { } + +// /// Compute a `LinearConstraintIndex` from `q`. +// fn get_for_q(&self, q: usize) -> Self::LinearConstraintIndex; + +// /// Mark y^{_index} as the power of y cooresponding to the public input +// /// coefficient for the next public input, in the k(Y) polynomial. +// fn new_k_power(&mut self, _index: usize) { } +// } + +// /// This is an abstraction which synthesizes circuits. +// pub trait SynthesisDriver { +// fn synthesize, B: Backend>(backend: B, circuit: &C) -> Result<(), SynthesisError>; +// } \ No newline at end of file diff --git a/src/plonk/cs/variable.rs b/src/plonk/cs/variable.rs new file mode 100644 index 000000000..fc9ee9a06 --- /dev/null +++ b/src/plonk/cs/variable.rs @@ -0,0 +1,25 @@ +/// Represents a variable in our constraint system. +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct Variable(pub(crate) Index); + +impl Variable { + /// This constructs a variable with an arbitrary index. + /// Circuit implementations are not recommended to use this. + pub fn new_unchecked(idx: Index) -> Variable { + Variable(idx) + } + + /// This returns the index underlying the variable. + /// Circuit implementations are not recommended to use this. + pub fn get_unchecked(&self) -> Index { + self.0 + } +} + +/// Represents the index of either an input variable or +/// auxillary variable. +#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)] +pub enum Index { + Input(usize), + Aux(usize) +} \ No newline at end of file diff --git a/src/plonk/domains/mod.rs b/src/plonk/domains/mod.rs new file mode 100644 index 000000000..d59243adb --- /dev/null +++ b/src/plonk/domains/mod.rs @@ -0,0 +1,88 @@ +use crate::pairing::ff::PrimeField; +use crate::SynthesisError; +use crate::worker::Worker; + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct Domain { + pub size: u64, + pub power_of_two: u64, + pub generator: F, +} + +impl Domain { + pub fn new_for_size(size: u64) -> Result { + let size = size.next_power_of_two(); + let mut power_of_two = 0; + let mut k = size; + while k != 1 { + k >>= 1; + power_of_two += 1; + } + let max_power_of_two = F::S as u64; + if power_of_two > max_power_of_two { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + + let mut generator = F::root_of_unity(); + for _ in power_of_two..max_power_of_two { + generator.square() + } + + Ok(Self { + size: size, + power_of_two: power_of_two, + generator: generator + }) + } + + pub fn coset_for_natural_index_and_size(natural_index: usize, domain_size: usize) -> Vec { + assert!(domain_size > 1); + assert!(domain_size.is_power_of_two()); + let natural_pair_index = (natural_index + (domain_size / 2)) % domain_size; + let mut coset = vec![natural_index, natural_pair_index]; + coset.sort(); + + coset + } + + pub fn index_and_size_for_next_domain(natural_index: usize, domain_size: usize) -> (usize, usize) { + // maps coset index into element of the next domain + // if index < current_size / 2 -> return index + // else -> return index - current_size / 2 + assert!(domain_size > 1); + assert!(domain_size.is_power_of_two()); + let next_size = domain_size / 2; + + let next_index = if natural_index < next_size { + natural_index + } else { + natural_index - next_size + }; + + (next_index, next_size) + } +} + +pub(crate) fn materialize_domain_elements_with_natural_enumeration( + domain: &Domain, + worker: &Worker +) -> Vec { + let mut values = vec![F::zero(); domain.size as usize]; + let generator = domain.generator; + + worker.scope(values.len(), |scope, chunk| { + for (i, values) in values.chunks_mut(chunk).enumerate() + { + scope.spawn(move |_| { + let mut current_power = generator.pow(&[(i*chunk) as u64]); + + for p in values { + *p = current_power; + current_power.mul_assign(&generator); + } + }); + } + }); + + values +} \ No newline at end of file diff --git a/src/plonk/fft/cooley_tukey_ntt/mod.rs b/src/plonk/fft/cooley_tukey_ntt/mod.rs new file mode 100644 index 000000000..764375a62 --- /dev/null +++ b/src/plonk/fft/cooley_tukey_ntt/mod.rs @@ -0,0 +1,773 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; +use crate::plonk::domains::*; +use log::info; + +pub(crate) mod partial_reduction; + +pub trait CTPrecomputations: Send + Sync { + fn new_for_domain_size(size: usize) -> Self; + fn bit_reversed_omegas(&self) -> &[F]; + fn domain_size(&self) -> usize; +} + +#[inline(always)] +pub fn bitreverse(n: usize, l: usize) -> usize { + let mut r = n.reverse_bits(); + // now we need to only use the bits that originally were "last" l, so shift + + r >>= (std::mem::size_of::() * 8) - l; + + r +} + +#[inline(always)] +fn bitreverse_naive(mut n: u32, l: u32) -> u32 { + // takes a bit reverse of the last l bits + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r +} + +pub struct BitReversedOmegas { + pub omegas: Vec, + pub(crate) domain_size: usize +} + +impl BitReversedOmegas { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + + let omega = domain.generator; + let precomputation_size = domain_size / 2; + // let precomputation_size = domain_size; + + let log_n = log2_floor(precomputation_size); + + let mut omegas = vec![F::zero(); precomputation_size]; + + worker.scope(omegas.len(), |scope, chunk| { + for (i, v) in omegas.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega); + } + }); + } + }); + + if omegas.len() > 2 { + for k in 0..omegas.len() { + let rk = bitreverse(k, log_n as usize); + // let rk_naive = bitreverse_naive(k as u32, log_n as u32); + // debug_assert!(rk == rk_naive as usize); + if k < rk { + omegas.swap(rk, k); + } + } + } + + BitReversedOmegas{ + omegas, + domain_size + } + } +} + +impl CTPrecomputations for BitReversedOmegas{ + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn bit_reversed_omegas(&self) -> &[F] { + &self.omegas[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} + + +pub struct OmegasInvBitreversed { + pub omegas: Vec, + pub(crate) domain_size: usize +} + +impl OmegasInvBitreversed { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + + let omega = domain.generator.inverse().expect("must exist"); + let precomputation_size = domain_size / 2; + + let log_n = log2_floor(precomputation_size); + + let mut omegas = vec![F::zero(); precomputation_size]; + + worker.scope(omegas.len(), |scope, chunk| { + for (i, v) in omegas.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega); + } + }); + } + }); + + if omegas.len() > 2 { + for k in 0..omegas.len() { + let rk = bitreverse(k, log_n as usize); + if k < rk { + omegas.swap(rk, k); + } + } + } + + OmegasInvBitreversed{ + omegas, + domain_size + } + } +} + +impl CTPrecomputations for OmegasInvBitreversed { + fn new_for_domain_size(size: usize) -> Self { + let domain = Domain::::new_for_size(size as u64).expect("domain must exist"); + let worker = Worker::new(); + Self::new_for_domain(&domain, &worker) + } + + fn bit_reversed_omegas(&self) -> &[F] { + &self.omegas[..] + } + + fn domain_size(&self) -> usize { + self.domain_size + } +} + +pub(crate) fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + +pub(crate) fn best_ct_ntt>( + a: &mut [F], + worker: &Worker, + log_n: u32, + use_cpus_hint: Option, + precomputed_omegas: &P +) +{ + info!("**** begin best_ct_ntt"); + let log_cpus = if let Some(hint) = use_cpus_hint { + assert!(hint <= worker.cpus); + let hint = if hint > 0 { + log2_floor(hint) + } else { + 0 + }; + + hint + } else { + worker.log_num_cpus() + }; + + if log_cpus == 0 || log_n <= log_cpus { + serial_ct_ntt(a, log_n, precomputed_omegas); + } else { + parallel_ct_ntt(a, worker, log_n, log_cpus, precomputed_omegas); + } + + info!("**** end best_ct_ntt"); +} + +pub(crate) fn serial_ct_ntt>( + a: &mut [F], + log_n: u32, + precomputed_omegas: &P +) +{ + assert_eq!(a.len(), precomputed_omegas.domain_size()); + assert_eq!(a.len(), (1< 1); + for k in 0..num_groups { + let idx_1 = k * pairs_per_group * 2; + let idx_2 = idx_1 + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in idx_1..idx_2 { + let u = a[j]; + let mut v = a[j+distance]; + v.mul_assign(&s); + + let mut tmp = u; + tmp.sub_assign(&v); + + a[j+distance] = tmp; + a[j].add_assign(&v); + } + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + } + + // let log_n = log_n as usize; + + // for k in 0..n { + // let rk = bitreverse(k, log_n); + // if k < rk { + // a.swap(rk, k); + // } + // } +} + + +// pub(crate) fn serial_ct_ntt>( +// a: &mut [F], +// // worker: &Worker, +// log_n: u32, +// // log_cpus: u32, +// precomputed_omegas: &P +// ) +// { +// assert_eq!(a.len(), precomputed_omegas.domain_size()); + +// let log_n = log_n as usize; +// let n = a.len(); + +// for k in 0..n { +// let rk = bitreverse(k, log_n); +// if k < rk { +// a.swap(rk, k); +// } +// } + +// let mut current_size = a.len(); +// let mut num_subroutines = 1; +// let mut distance = 1; + +// let omegas_bit_reversed = precomputed_omegas.bit_reversed_omegas(); + +// while current_size > 1 { +// for k in 0..num_subroutines { +// let mut j = k; +// let mut omega_idx = 0; +// let step = 2*num_subroutines; + +// while j < n-1 { +// let omega = omegas_bit_reversed[omega_idx]; +// let u = a[j]; +// let v = a[j+distance]; + +// let mut tmp = u; +// tmp.sub_assign(&v); +// tmp.mul_assign(&omega); + +// a[j+distance] = tmp; +// a[j].add_assign(&v); + +// omega_idx += 1; +// j += step; +// } +// } + +// num_subroutines *= 2; +// current_size /= 2; +// distance *= 2; +// } +// } + + +pub(crate) fn parallel_ct_ntt>( + a: &mut [F], + worker: &Worker, + log_n: u32, + log_cpus: u32, + precomputed_omegas: &P +) +{ + assert!(log_n >= log_cpus); + assert_eq!(a.len(), precomputed_omegas.domain_size()); + + let n = a.len(); + if n == 1 { + return; + } + let pairs_per_group = n / 2; + let num_groups = 1; + let distance = n / 2; + + let omegas_bit_reversed = precomputed_omegas.bit_reversed_omegas(); + + let a = a as *mut [F]; + + use std::sync::{Arc, Barrier}; + + let num_remaining_rounds = log_n as usize; + + // TODO: later find a way to utilize all the cores in case of not power of twwo + let to_spawn = (1 << log_cpus) as usize; + + let mut barriers = Vec::with_capacity(num_remaining_rounds); + for _ in 0..num_remaining_rounds { + let barrier = Barrier::new(to_spawn); + barriers.push(barrier); + } + + let barriers = Arc::new(barriers); + + worker.scope(0, |scope, _| { + for thread_id in 0..to_spawn { + let a = unsafe {&mut *a}; + let mut pairs_per_group = pairs_per_group; + let mut num_groups = num_groups; + let mut distance = distance; + let barriers = barriers.clone(); + scope.spawn(move |_| { + let mut round_id = 0; + { + // special case for omega = 1 + debug_assert!(num_groups == 1); + let group_start_idx = 0; + let group_end_idx = pairs_per_group; + let group_size = pairs_per_group; + + let chunk = Worker::chunk_size_for_num_spawned_threads(group_size, to_spawn); + + let start = group_start_idx + thread_id * chunk; + let end = if start + chunk <= group_end_idx { + start + chunk + } else { + group_end_idx + }; + + for j in start..end { + let u = a[j]; + let v = a[j+distance]; + + let mut tmp = u; + tmp.sub_assign(&v); + + a[j+distance] = tmp; + a[j].add_assign(&v); + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + + (&barriers[round_id]).wait(); + + round_id += 1; + } + + // if pairs per group << num cpus we use splitting in k, + // otherwise use splitting in indexes + while num_groups < n { + if num_groups >= to_spawn { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + + let chunk = Worker::chunk_size_for_num_spawned_threads(num_groups, to_spawn); + let start = thread_id * chunk; + let end = if start + chunk <= num_groups { + start + chunk + } else { + num_groups + }; + + for k in start..end { + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in group_start_idx..group_end_idx { + let u = a[j]; + let mut v = a[j+distance]; + v.mul_assign(&s); + + let mut tmp = u; + tmp.sub_assign(&v); + + a[j+distance] = tmp; + a[j].add_assign(&v); + } + } + } else { + for k in 0..num_groups { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let group_size = pairs_per_group; + let s = omegas_bit_reversed[k]; + + // we always split thread work in here + + let chunk = Worker::chunk_size_for_num_spawned_threads(group_size, to_spawn); + + let start = group_start_idx + thread_id * chunk; + let end = if start + chunk <= group_end_idx { + start + chunk + } else { + group_end_idx + }; + + for j in start..end { + let u = a[j]; + let mut v = a[j+distance]; + v.mul_assign(&s); + + let mut tmp = u; + tmp.sub_assign(&v); + + a[j+distance] = tmp; + a[j].add_assign(&v); + } + } + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + + // use barrier to wait for all other threads + (&barriers[round_id]).wait(); + + round_id += 1; + } + }); + } + }); + + // let log_n = log_n as usize; + + // for k in 0..n { + // let rk = bitreverse(k, log_n); + // // let rk_naive = bitreverse_naive(k as u32, log_n as u32); + // // debug_assert!(rk == rk_naive as usize); + // if k < rk { + // a.swap(rk, k); + // } + // } +} + + +#[cfg(test)] +mod test { + #[test] + fn test_bit_reversed_omegas_computation() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use super::CTPrecomputations; + use super::BitReversedOmegas; + + // let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + let poly_sizes = vec![4]; + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + println!("{:?}", precomp.bit_reversed_omegas()); + } + } + + #[test] + fn test_bench_ct_serial_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use super::*; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::serial_fft; + use super::CTPrecomputations; + use super::BitReversedOmegas; + use crate::plonk::domains::Domain; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + // let poly_sizes = vec![8]; + + fn check_permutation(one: &[F], two: &[F]) -> (bool, Vec) { + let mut permutation: Vec = (0..one.len()).collect(); + let mut valid = true; + + for (i, el) in one.iter().enumerate() { + let mut idx = 0; + let mut found = false; + for (j, el2) in two.iter().enumerate() { + if *el == *el2 { + idx = j; + found = true; + break; + } + } + if !found { + println!("Not found for {}", i); + valid = false; + break; + } + permutation[i] = idx; + } + + (valid, permutation) + } + + // let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + // println!("{:?}", precomp.bit_reversed_omegas()); + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + serial_fft(&mut coeffs, &omega, log_n); + println!("serial FFT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + // println!("Coeffs = {:?}", coeffs); + let start = Instant::now(); + serial_ct_ntt(&mut coeffs, log_n, &precomp); + println!("serial NTT for size {} taken {:?}", poly_size, start.elapsed()); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + coeffs + }; + + assert!(res1 == res2); + + // let (valid, permutation) = check_permutation(&res1, &res2); + + // if valid { + // println!("Permutation = {:?}", permutation); + // } + + // assert!(valid, "true = {:?}\n,got = {:?}", res1, res2); + } + } + + #[test] + fn test_bench_ct_parallel_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use super::*; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::parallel_fft; + use super::CTPrecomputations; + use super::BitReversedOmegas; + use crate::plonk::domains::Domain; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + // let poly_sizes = vec![1000usize]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_fft(&mut coeffs, &worker, &omega, log_n, worker.log_num_cpus()); + println!("parallel FFT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_ct_ntt(&mut coeffs, &worker, log_n, worker.log_num_cpus(), &precomp); + println!("parallel NTT for size {} taken {:?}", poly_size, start.elapsed()); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + coeffs + }; + + assert!(res1 == res2); + } + } + + + #[test] + fn test_fft_ctt_consistency() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use super::*; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::parallel_fft; + use super::CTPrecomputations; + use super::BitReversedOmegas; + use crate::plonk::domains::Domain; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + // let poly_sizes = vec![1000usize]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_fft(&mut coeffs, &worker, &omega, log_n, worker.log_num_cpus()); + println!("parallel FFT for size {} taken {:?}", poly_size, start.elapsed()); + + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + coeffs + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_ct_ntt(&mut coeffs, &worker, log_n, worker.log_num_cpus(), &precomp); + println!("parallel NTT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + assert!(res1 == res2); + } + } + + + + + +} + + + + + + + diff --git a/src/plonk/fft/cooley_tukey_ntt/partial_reduction.rs b/src/plonk/fft/cooley_tukey_ntt/partial_reduction.rs new file mode 100644 index 000000000..64aa3f5be --- /dev/null +++ b/src/plonk/fft/cooley_tukey_ntt/partial_reduction.rs @@ -0,0 +1,722 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; +use crate::plonk::domains::*; +use crate::plonk::transparent_engine::PartialTwoBitReductionField; + +use super::CTPrecomputations; +use super::log2_floor; + +pub(crate) fn best_ct_ntt_partial_reduction>( + a: &mut [F], + worker: &Worker, + log_n: u32, + use_cpus_hint: Option, + precomputed_omegas: &P +) +{ + let log_cpus = if let Some(hint) = use_cpus_hint { + assert!(hint <= worker.cpus); + let hint = if hint > 0 { + log2_floor(hint) + } else { + 0 + }; + + hint + } else { + worker.log_num_cpus() + }; + + if log_cpus == 0 || log_n <= log_cpus { + serial_ct_ntt_partial_reduction(a, log_n, precomputed_omegas); + } else { + parallel_ct_ntt_partial_reduction(a, worker, log_n, log_cpus, precomputed_omegas); + } +} + +pub(crate) fn serial_ct_ntt_partial_reduction>( + a: &mut [F], + log_n: u32, + precomputed_omegas: &P +) +{ + assert_eq!(a.len(), precomputed_omegas.domain_size(), "precomputation size is invalid for ntt"); + assert_eq!(a.len(), (1<= 2); + + let n = a.len(); + if n == 1 { + return; + } + let half_n = n / 2; + + let mut pairs_per_group = n / 2; + let mut num_groups = 1; + let mut distance = n / 2; + + let omegas_bit_reversed = precomputed_omegas.bit_reversed_omegas(); + + { + // special case for omega = 1 + debug_assert!(num_groups == 1); + let idx_1 = 0; + let idx_2 = pairs_per_group; + + for j in idx_1..idx_2 { + let u = a[j]; + let v = a[j+distance]; + + let mut tmp = u; + tmp.sub_assign_unreduced(&v); + + a[j+distance] = tmp; + a[j].add_assign_unreduced(&v); + + debug_assert!(a[j].overflow_factor() < 2); + debug_assert!(a[j+distance].overflow_factor() < 2); + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + } + + // all elements are [0, 2p) + + while num_groups < half_n { + debug_assert!(num_groups > 1); + for k in 0..num_groups { + let idx_1 = k * pairs_per_group * 2; + let idx_2 = idx_1 + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in idx_1..idx_2 { + let mut u = a[j]; + let mut v = a[j+distance]; + + debug_assert!(u.overflow_factor() < 4, "factor is {} for num groups {}", u.overflow_factor(), num_groups); + u.reduce_twice(); + + debug_assert!(v.overflow_factor() < 4, "factor is {} for num groups {}", v.overflow_factor(), num_groups); + v.mul_assign_unreduced(&s); + debug_assert!(v.overflow_factor() < 2, "factor is {} for num groups {}", v.overflow_factor(), num_groups); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + tmp_v.sub_assign_twice_unreduced(&v); + + debug_assert!(tmp_u.overflow_factor() < 4, "factor is {} for num groups {}", tmp_u.overflow_factor(), num_groups); + debug_assert!(tmp_v.overflow_factor() < 4, "factor is {} for num groups {}", tmp_v.overflow_factor(), num_groups); + + a[j+distance] = tmp_v; + a[j] = tmp_u; + } + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + } + + // here we should reduce completely + + if num_groups < n { + debug_assert!(num_groups > 1); + for k in 0..num_groups { + let idx_1 = k * pairs_per_group * 2; + let idx_2 = idx_1 + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in idx_1..idx_2 { + let mut u = a[j]; + let mut v = a[j+distance]; + + debug_assert!(u.overflow_factor() < 4, "factor is {} for num groups {}", u.overflow_factor(), num_groups); + u.reduce_twice(); + debug_assert!(u.overflow_factor() < 2, "factor is {} for num groups {}", u.overflow_factor(), num_groups); + + debug_assert!(v.overflow_factor() < 4, "factor is {} for num groups {}", v.overflow_factor(), num_groups); + v.mul_assign_unreduced(&s); + debug_assert!(v.overflow_factor() < 2, "factor is {} for num groups {}", v.overflow_factor(), num_groups); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_u); + + tmp_v.sub_assign_twice_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_v); + + debug_assert!(tmp_u.overflow_factor() < 1, "factor is {} for num groups {}", tmp_u.overflow_factor(), num_groups); + debug_assert!(tmp_v.overflow_factor() < 1, "factor is {} for num groups {}", tmp_v.overflow_factor(), num_groups); + + a[j+distance] = tmp_v; + a[j] = tmp_u; + } + } + } +} + +pub(crate) fn parallel_ct_ntt_partial_reduction>( + a: &mut [F], + worker: &Worker, + log_n: u32, + log_cpus: u32, + precomputed_omegas: &P +) +{ + assert!(log_n >= log_cpus); + assert_eq!(a.len(), precomputed_omegas.domain_size(), "precomputation size is invalid for ntt"); + assert!(64 - (F::NUM_BITS % 64) >= 2); + + let n = a.len(); + if n == 1 { + return; + } + let half_n = n / 2; + + let pairs_per_group = n / 2; + let num_groups = 1; + let distance = n / 2; + + let omegas_bit_reversed = precomputed_omegas.bit_reversed_omegas(); + + let a = a as *mut [F]; + + use std::sync::{Arc, Barrier}; + + let num_remaining_rounds = log_n as usize; + + // TODO: later find a way to utilize all the cores in case of not power of two + let to_spawn = (1 << log_cpus) as usize; + + let mut barriers = Vec::with_capacity(num_remaining_rounds); + for _ in 0..num_remaining_rounds { + let barrier = Barrier::new(to_spawn); + barriers.push(barrier); + } + + let barriers = Arc::new(barriers); + + worker.scope(0, |scope, _| { + for thread_id in 0..to_spawn { + let a = unsafe {&mut *a}; + let mut pairs_per_group = pairs_per_group; + let mut num_groups = num_groups; + let mut distance = distance; + let barriers = barriers.clone(); + scope.spawn(move |_| { + let mut round_id = 0; + { + // special case for omega = 1 + debug_assert!(num_groups == 1); + let group_start_idx = 0; + let group_end_idx = pairs_per_group; + let group_size = pairs_per_group; + + let chunk = Worker::chunk_size_for_num_spawned_threads(group_size, to_spawn); + + let start = group_start_idx + thread_id * chunk; + let end = if start + chunk <= group_end_idx { + start + chunk + } else { + group_end_idx + }; + + for j in start..end { + let u = unsafe { *a.get_unchecked(j) }; + let v = unsafe { *a.get_unchecked(j+distance) }; + + // let u = a[j]; + // let v = a[j+distance]; + + let mut tmp = u; + tmp.sub_assign_unreduced(&v); + + unsafe { + *a.get_unchecked_mut(j+distance) = tmp; + a.get_unchecked_mut(j).add_assign_unreduced(&v); + }; + + // a[j+distance] = tmp; + // a[j].add_assign_unreduced(&v); + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + + (&barriers[round_id]).wait(); + + round_id += 1; + } + + // if pairs per group << num cpus we use splitting in k, + // otherwise use splitting in indexes + while num_groups < half_n { + if num_groups >= to_spawn { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + + let chunk = Worker::chunk_size_for_num_spawned_threads(num_groups, to_spawn); + let start = thread_id * chunk; + let end = if start + chunk <= num_groups { + start + chunk + } else { + num_groups + }; + + for k in start..end { + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in group_start_idx..group_end_idx { + let mut u = unsafe { *a.get_unchecked(j) }; + let mut v = unsafe { *a.get_unchecked(j+distance) }; + + // let mut u = a[j]; + // let mut v = a[j+distance]; + + u.reduce_twice(); + v.mul_assign_unreduced(&s); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + tmp_v.sub_assign_twice_unreduced(&v); + + unsafe { + *a.get_unchecked_mut(j+distance) = tmp_v; + *a.get_unchecked_mut(j) = tmp_u; + }; + + // a[j+distance] = tmp_v; + // a[j] = tmp_u; + } + } + } else { + for k in 0..num_groups { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let group_size = pairs_per_group; + let s = omegas_bit_reversed[k]; + + // we always split thread work in here + + let chunk = Worker::chunk_size_for_num_spawned_threads(group_size, to_spawn); + + let start = group_start_idx + thread_id * chunk; + let end = if start + chunk <= group_end_idx { + start + chunk + } else { + group_end_idx + }; + + for j in start..end { + let mut u = unsafe { *a.get_unchecked(j) }; + let mut v = unsafe { *a.get_unchecked(j+distance) }; + + // let mut u = a[j]; + // let mut v = a[j+distance]; + + u.reduce_twice(); + v.mul_assign_unreduced(&s); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + tmp_v.sub_assign_twice_unreduced(&v); + + unsafe { + *a.get_unchecked_mut(j+distance) = tmp_v; + *a.get_unchecked_mut(j) = tmp_u; + }; + + // a[j+distance] = tmp_v; + // a[j] = tmp_u; + } + } + } + + pairs_per_group /= 2; + num_groups *= 2; + distance /= 2; + + // use barrier to wait for all other threads + (&barriers[round_id]).wait(); + + round_id += 1; + } + + // if pairs per group << num cpus we use splitting in k, + // otherwise use splitting in indexes + if num_groups < n { + if num_groups >= to_spawn { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + + let chunk = Worker::chunk_size_for_num_spawned_threads(num_groups, to_spawn); + let start = thread_id * chunk; + let end = if start + chunk <= num_groups { + start + chunk + } else { + num_groups + }; + + for k in start..end { + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let s = omegas_bit_reversed[k]; + + for j in group_start_idx..group_end_idx { + let mut u = unsafe { *a.get_unchecked(j) }; + let mut v = unsafe { *a.get_unchecked(j+distance) }; + + // let mut u = a[j]; + // let mut v = a[j+distance]; + + u.reduce_twice(); + v.mul_assign_unreduced(&s); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_u); + + tmp_v.sub_assign_twice_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_v); + + unsafe { + *a.get_unchecked_mut(j+distance) = tmp_v; + *a.get_unchecked_mut(j) = tmp_u; + }; + + // a[j+distance] = tmp_v; + // a[j] = tmp_u; + } + } + } else { + for k in 0..num_groups { + // for each k we start at k*pairs*2 and end on k*pairs*2 + pairs + // for k+1 we start at (k+1)*pairs*2 = k*pairs*2 + pairs*2 + // and end on (k+1)*pairs*2 + pairs = k*pairs*2 + pairs*3 + // for k+2 we start at (k+2)*pairs*2 = k*pairs*2 + pairs*4 + // and end on (k+2)*pairs*2 + pairs = k*pairs*2 + pairs*5 + // so we do not overlap during the full run and do not need to sync + let group_start_idx = k * pairs_per_group * 2; + let group_end_idx = group_start_idx + pairs_per_group; + let group_size = pairs_per_group; + let s = omegas_bit_reversed[k]; + + // we always split thread work in here + + let chunk = Worker::chunk_size_for_num_spawned_threads(group_size, to_spawn); + + let start = group_start_idx + thread_id * chunk; + let end = if start + chunk <= group_end_idx { + start + chunk + } else { + group_end_idx + }; + + for j in start..end { + let mut u = unsafe { *a.get_unchecked(j) }; + let mut v = unsafe { *a.get_unchecked(j+distance) }; + + // let mut u = a[j]; + // let mut v = a[j+distance]; + + u.reduce_twice(); + v.mul_assign_unreduced(&s); + + let mut tmp_v = u; + let mut tmp_u = u; + + tmp_u.add_assign_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_u); + + tmp_v.sub_assign_twice_unreduced(&v); + PartialTwoBitReductionField::reduce_completely(&mut tmp_v); + + unsafe { + *a.get_unchecked_mut(j+distance) = tmp_v; + *a.get_unchecked_mut(j) = tmp_u; + }; + + // a[j+distance] = tmp_v; + // a[j] = tmp_u; + } + } + } + + // use barrier to wait for all other threads + (&barriers[round_id]).wait(); + } + }); + } + }); +} + + + +#[cfg(test)] +mod test { + use crate::plonk::fft::cooley_tukey_ntt::*; + + #[test] + fn test_bench_ct_serial_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use super::*; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::serial_fft; + use super::CTPrecomputations; + use super::super::BitReversedOmegas; + use crate::plonk::domains::Domain; + + let poly_sizes = if cfg!(debug_assertions) { + vec![10_000] + } else { + vec![1_000_000, 2_000_000, 4_000_000, 8_000_000] + }; + // let poly_sizes = vec![8]; + + fn check_permutation(one: &[F], two: &[F]) -> (bool, Vec) { + let mut permutation: Vec = (0..one.len()).collect(); + let mut valid = true; + + for (i, el) in one.iter().enumerate() { + let mut idx = 0; + let mut found = false; + for (j, el2) in two.iter().enumerate() { + if *el == *el2 { + idx = j; + found = true; + break; + } + } + if !found { + println!("Not found for {}", i); + valid = false; + break; + } + permutation[i] = idx; + } + + (valid, permutation) + } + + // let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + // println!("{:?}", precomp.bit_reversed_omegas()); + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + serial_fft(&mut coeffs, &omega, log_n); + println!("serial FFT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let (res2, elapsed2) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + // println!("Coeffs = {:?}", coeffs); + let start = Instant::now(); + serial_ct_ntt(&mut coeffs, log_n, &precomp); + let finish = start.elapsed(); + println!("serial NTT for size {} taken {:?}", poly_size, finish); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + (coeffs, finish) + }; + + let (res3, elapsed3) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + // println!("Coeffs = {:?}", coeffs); + let start = Instant::now(); + serial_ct_ntt_partial_reduction(&mut coeffs, log_n, &precomp); + let finish = start.elapsed(); + println!("serial PRR for size {} taken {:?}", poly_size, finish); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + (coeffs, finish) + }; + + let (res5, elapsed5) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + // println!("Coeffs = {:?}", coeffs); + let start = Instant::now(); + serial_ct_ntt(&mut coeffs, log_n, &precomp); + let finish = start.elapsed(); + println!("serial NTT for size {} taken {:?}", poly_size, finish); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + (coeffs, finish) + }; + + let ntt_time = (elapsed2 + elapsed5).div_f32(2.); + let diff_pr = ntt_time.checked_sub(elapsed3); + if let Some(diff) = diff_pr { + println!("Partial reduction: speed up is {}%.", diff.as_nanos()*100/ntt_time.as_nanos()); + } else { + println!("Partial reduction: no speed up."); + } + + assert!(res1 == res2); + assert!(res1 == res5); + assert!(res1 == res3); + } + } + + #[test] + fn test_bench_ct_parallel_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::transparent_engine::proth::Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use super::*; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::parallel_fft; + use super::CTPrecomputations; + use super::super::BitReversedOmegas; + use crate::plonk::domains::Domain; + + let poly_sizes = if cfg!(debug_assertions) { + vec![10_000] + } else { + vec![2_000_000, 4_000_000, 8_000_000, 16_000_000] + }; + + // let poly_sizes = vec![1000usize]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_fft(&mut coeffs, &worker, &omega, log_n, worker.log_num_cpus()); + println!("parallel FFT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let (res2, elapsed2) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_ct_ntt(&mut coeffs, &worker, log_n, worker.log_num_cpus(), &precomp); + let finish = start.elapsed(); + println!("parallel NTT for size {} taken {:?}", poly_size, finish); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + (coeffs, finish) + }; + + let (res3, elapsed3) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let start = Instant::now(); + parallel_ct_ntt_partial_reduction(&mut coeffs, &worker, log_n, worker.log_num_cpus(), &precomp); + let finish = start.elapsed(); + println!("parallel NTT with partial reduction for size {} taken {:?}", poly_size, finish); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = bitreverse(k, log_n); + if k < rk { + coeffs.swap(rk, k); + } + } + + (coeffs, finish) + }; + + let ntt_time = elapsed2; + let diff_pr = ntt_time.checked_sub(elapsed3); + if let Some(diff) = diff_pr { + println!("Partial reduction: speed up is {}%.", diff.as_nanos()*100/ntt_time.as_nanos()); + } else { + println!("Partial reduction: no speed up."); + } + + assert!(res1 == res2); + assert!(res1 == res3); + } + } +} diff --git a/src/plonk/fft/fft.rs b/src/plonk/fft/fft.rs new file mode 100644 index 000000000..a7a01dd15 --- /dev/null +++ b/src/plonk/fft/fft.rs @@ -0,0 +1,287 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; +use crate::gpu::{self, GPUError, LockedFFTKernel}; + +use crate::pairing::Engine; + + +use crate::pairing::bn256::{self, Bn256,Fr}; +use crate::domain::{EvaluationDomain, Scalar}; +use crate::domain::{self, best_fft_gpu}; +use crate::plonk::fft::cooley_tukey_ntt::{bitreverse as ntt_bitreverse, CTPrecomputations, BitReversedOmegas, OmegasInvBitreversed}; + +use crate::plonk::domains::*; + +use log::info; +use crate::plonk::fft::cooley_tukey_ntt; + + +fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + + +pub(crate) fn bit_rev_best_ct_ntt_2_best_fft_gpu>( + a: &mut [F], + worker: &Worker, + log_n: u32, + precomputed_omegas: &P +) +{ + info!("begin bit_rev_best_ct_ntt_2_best_fft_gpu"); + assert_eq!(a.len(), (1<::new_for_domain_size(4).omegas[1]; + let omega_1_r = unsafe{std::mem::transmute::<&Fr, &F>(&omega_1)}; + let omegas_inv_1 = OmegasInvBitreversed::::new_for_domain_size(4).omegas[1]; + let omegas_inv_1_r = unsafe{std::mem::transmute::<&Fr, &F>(&omegas_inv_1)}; + + let omegas_precom_1 = precomputed_omegas.bit_reversed_omegas()[1]; + + let poly_size = a.len(); + + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + let omega = domain.generator; + let omega_inv = domain.generator.inverse().expect("must exist"); + + if *omega_1_r == omegas_precom_1 { + info!("use best_fft_bn256_gpu with omega"); + best_fft_bn256_gpu(a, worker, &omega, log_n, None); + } + else if *omegas_inv_1_r == omegas_precom_1 { + info!("use best_fft_bn256_gpu with omega_inv"); + best_fft_bn256_gpu(a, worker, &omega_inv, log_n, None); + } + else { + info!("use native cooley_tukey_ntt::best_ct_ntt"); + cooley_tukey_ntt::best_ct_ntt(a, worker, log_n, Some(worker.cpus), precomputed_omegas); + } + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = ntt_bitreverse(k, log_n); + if k < rk { + a.swap(rk, k); + } + } + info!("end bit_rev_best_ct_ntt_2_best_fft_gpu"); +} + +// can only be used to omega, cannot be used omegaInv +pub(crate) fn best_ct_ntt_2_best_fft_gpu( + a: &mut [F], + worker: &Worker, + poly_size: usize, +) +{ + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + let omega = domain.generator; + let omega_r = unsafe{std::mem::transmute::<&Fr, &F>(&omega)}; + let log_n = domain.power_of_two as u32; + best_fft_bn256_gpu(a, worker, omega_r, log_n, None); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = ntt_bitreverse(k, log_n); + if k < rk { + a.swap(rk, k); + } + } + +} + +pub(crate) fn best_fft_bn256_gpu( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + use_cpus_hint: Option +) +{ + info!("begin best_fft_bn256_gpu"); + let mut fft_kern = Some(LockedFFTKernel::::new(log_n as usize, false)); + let a = unsafe { std::mem::transmute::<&mut [F], &mut [Scalar::]>(a) }; + let omega = unsafe{std::mem::transmute::<&F, &bn256::Fr>(omega)}; + best_fft_gpu(&mut fft_kern, a, &worker, omega,log_n).unwrap(); + drop(fft_kern); + info!("end best_fft_bn256_gpu"); +} + +// #### some unkown bugs +// pub(crate) fn best_fft_bn256_gpu( +// a: &mut [F], +// worker: &Worker, +// omega: &F, +// log_n: u32, +// use_cpus_hint: Option +// ) +// { +// if let Some(ref mut kern) = kern { +// +// let b = unsafe { std::mem::transmute::<&mut [F], &mut [Scalar::]>(a) }; +// let mut c: Vec> = b.into_iter().map(|e| (*e)).collect(); +// let omega = unsafe{std::mem::transmute::<&F, &bn256::Fr>(omega)}; +// +// // if kern +// // .with(|k: &mut gpu::FFTKernel| gpu_fft(k, b, omega, log_n)) +// // .is_ok() +// // { +// // return Ok(()); +// // } +// // else { +// // return Err(GPUError::Simple("GPU accelerator does not correctly execute")); +// // } +// +// if kern +// .with(|k: &mut gpu::FFTKernel| gpu_fft(k, &mut c, omega, log_n)) +// .is_ok() +// { +// return Ok(()); +// } +// else { +// return Err(GPUError::Simple("GPU accelerator does not correctly execute")); +// } +// +// } +// best_fft(a, worker, omega, log_n, use_cpus_hint); +// return Ok(()) +// } + + +// important +pub(crate) fn best_fft(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, use_cpus_hint: Option) +{ + let log_cpus = if let Some(hint) = use_cpus_hint { + assert!(hint <= worker.cpus); + let hint = if hint > 0 { + log2_floor(hint) + } else { + 0 + }; + + hint + } else { + worker.log_num_cpus() + }; + + if log_cpus == 0 || log_n <= log_cpus { + serial_fft(a, omega, log_n); + } else { + parallel_fft(a, worker, omega, log_n, log_cpus); + } +} + + + +pub(crate) fn serial_fft(a: &mut [F], omega: &F, log_n: u32) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + let n = a.len() as u32; + assert_eq!(n, 1 << log_n); + + for k in 0..n { + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + let mut m = 1; + for _ in 0..log_n { + let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let mut k = 0; + while k < n { + let mut w = F::one(); + for j in 0..m { + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + + k += 2*m; + } + + m *= 2; + } +} + +pub(crate) fn parallel_fft( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32 +) +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + let mut t = a[idx]; + + t.mul_assign(&elt); + tmp[i].add_assign(&t); + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + serial_fft(tmp, &new_omega, log_new_n); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} \ No newline at end of file diff --git a/src/plonk/fft/lde.rs b/src/plonk/fft/lde.rs new file mode 100644 index 000000000..d75401d0b --- /dev/null +++ b/src/plonk/fft/lde.rs @@ -0,0 +1,357 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; + +pub(crate) fn best_lde(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, lde_factor: usize) +{ + let log_cpus = worker.log_num_cpus(); + + if log_n <= log_cpus { + serial_lde(a, omega, log_n, lde_factor); + } else { + parallel_lde(a, worker, omega, log_n, log_cpus, lde_factor); + } +} + +pub(crate) fn serial_lde(a: &mut [F], omega: &F, log_n: u32, lde_factor: usize) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + #[inline(always)] + fn is_non_zero(idx: usize, lde_factor: usize, step: usize) -> bool { + let idx_mod_f = idx & (lde_factor - 1); + return idx_mod_f < (1 << step); + } + + #[inline(always)] + fn is_dense_round(lde_factor: usize, step: usize) -> bool { + let f = lde_factor >> step; + if f <= 1 { + return true; + } + + false + } + + let n = a.len() as u32; + assert_eq!(n, 1 << log_n); + + for k in 0..n { + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + // even after bit reverses we can guarantee some distribution + + let mut m = 1; + let mut step = 0; + + for _ in 0..log_n { + let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let step_by = 2*m as usize; + if is_dense_round(lde_factor, step) { + // standard fft + for k in (0..n).step_by(step_by) { + let mut w = F::one(); + for j in 0..m { + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + } + } else { + // have some pain trying to save on memory reads and multiplications + for k in (0..n).step_by(step_by) { + let mut w = F::one(); + for j in 0..m { + let odd_idx = (k+j+m) as usize; + let even_idx = (k+j) as usize; + + let odd_is_non_zero = is_non_zero(odd_idx, lde_factor, step); + let even_is_non_zero = is_non_zero(even_idx, lde_factor, step); + + // debug_assert!(!a[odd_idx].is_zero() == odd_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", odd_idx, odd_is_non_zero, step, a[odd_idx]); + // debug_assert!(!a[even_idx].is_zero() == even_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", even_idx, even_is_non_zero, step, a[even_idx]); + + match (odd_is_non_zero, even_is_non_zero) { + (true, true) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = a[even_idx]; + tmp.sub_assign(&t); + + a[odd_idx] = tmp; + a[even_idx].add_assign(&t); + }, + (false, true) => { + a[odd_idx] = a[even_idx]; + }, + (true, false) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = t; + tmp.negate(); + + a[odd_idx] = tmp; + a[even_idx] = t; + }, + (false, false) => { + } + } + + w.mul_assign(&w_m); + } + } + } + + step += 1; + m *= 2; + } +} + +pub(crate) fn parallel_lde( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32, + lde_factor: usize +) +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + let non_trivial_len = a.len() / lde_factor; + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + if idx < non_trivial_len { + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + } + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + let new_lde_factor = lde_factor >> log_cpus; + if new_lde_factor <= 1 { + super::fft::serial_fft(tmp, &new_omega, log_new_n); + } else { + serial_lde(tmp, &new_omega, log_new_n, new_lde_factor); + } + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} + +// #[test] +// fn test_small_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::best_fft(&mut reference[..], &worker, &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// // println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // self::serial_lde(&mut lde, &omega, log_n, BASE); +// // println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_small_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 20; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 22; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use crate::polynomials::Polynomial; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// let mut poly = Polynomial::from_coeffs(coeffs.clone()).unwrap(); + +// poly.pad_by_factor(LDE_FACTOR).unwrap(); +// let now = Instant::now(); +// let naive_lde = poly.fft(&worker); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let now = Instant::now(); +// let mut lde = coeffs.clone(); +// best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(naive_lde.into_coeffs() == lde); +// } + diff --git a/src/plonk/fft/mod.rs b/src/plonk/fft/mod.rs new file mode 100644 index 000000000..b18492b37 --- /dev/null +++ b/src/plonk/fft/mod.rs @@ -0,0 +1,90 @@ +pub(crate) mod fft; +pub(crate) mod lde; +pub(crate) mod radix_4; +pub(crate) mod with_precomputation; +pub mod cooley_tukey_ntt; + +use cfg_if; + +#[cfg(feature = "nightly")] +mod prefetch_lde; +#[cfg(feature = "nightly")] +mod prefetch_fft; +#[cfg(feature = "nightly")] +mod prefetch; + +use crate::pairing::ff::PrimeField; +use crate::worker::Worker; + +cfg_if! { + if #[cfg(feature = "nightly")] { + #[inline(always)] + pub(crate) fn best_lde(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, lde_factor: usize) { + self::prefetch_lde::best_lde(a, worker, omega, log_n, lde_factor) + } + + #[inline(always)] + pub(crate) fn best_fft(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, use_cpus_hint: Option) { + self::prefetch_fft::best_fft(a, worker, omega, log_n, use_cpus_hint) + } + + #[inline(always)] + pub(crate) fn serial_fft(a: &mut [F], omega: &F, log_n: u32) { + self::prefetch_fft::serial_fft(a, omega, log_n) + } + } else { + #[inline(always)] + pub(crate) fn best_lde(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, lde_factor: usize) { + self::lde::best_lde(a, worker, omega, log_n, lde_factor) + } + #[inline(always)] + pub(crate) fn best_fft(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, use_cpus_hint: Option) { + self::fft::best_fft(a, worker, omega, log_n, use_cpus_hint) + } + #[inline(always)] + pub(crate) fn serial_fft(a: &mut [F], omega: &F, log_n: u32) { + self::fft::serial_fft(a, omega, log_n) + } + } +} + +pub fn distribute_powers(coeffs: &mut [F], worker: &Worker, g: F) +{ + worker.scope(coeffs.len(), |scope, chunk| { + for (i, v) in coeffs.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = g.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + v.mul_assign(&u); + u.mul_assign(&g); + } + }); + } + }); +} + +pub fn distribute_powers_with_num_cpus(coeffs: &mut [F], worker: &Worker, g: F, cpus: usize) +{ + assert!(cpus > 0); + let chunk = Worker::chunk_size_for_num_spawned_threads(coeffs.len(), cpus); + worker.scope(0, |scope, _| { + for (i, v) in coeffs.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = g.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + v.mul_assign(&u); + u.mul_assign(&g); + } + }); + } + }); +} + +pub fn distribute_powers_serial(coeffs: &mut [F], g: F) +{ + let mut u = F::one(); + for v in coeffs.iter_mut() { + v.mul_assign(&u); + u.mul_assign(&g); + } +} \ No newline at end of file diff --git a/src/plonk/fft/multicore.rs b/src/plonk/fft/multicore.rs new file mode 100644 index 000000000..2c3203ba6 --- /dev/null +++ b/src/plonk/fft/multicore.rs @@ -0,0 +1,140 @@ +//! This is an interface for dealing with the kinds of +//! parallel computations involved in bellman. It's +//! currently just a thin wrapper around CpuPool and +//! crossbeam but may be extended in the future to +//! allow for various parallelism strategies. + +extern crate num_cpus; +extern crate futures; +extern crate futures_cpupool; +extern crate crossbeam; + +use self::futures::{Future, IntoFuture, Poll}; +use self::futures_cpupool::{CpuPool, CpuFuture}; +use self::crossbeam::thread::{Scope}; + +#[derive(Clone)] +pub struct Worker { + pub(crate) cpus: usize, + pool: CpuPool +} + +impl Worker { + // We don't expose this outside the library so that + // all `Worker` instances have the same number of + // CPUs configured. + pub(crate) fn new_with_cpus(cpus: usize) -> Worker { + Worker { + cpus: cpus, + pool: CpuPool::new(cpus) + } + } + + pub fn new() -> Worker { + let cpus = num_cpus::get(); + Self::new_with_cpus(cpus) + } + + pub fn log_num_cpus(&self) -> u32 { + log2_floor(self.cpus) + } + + pub fn num_cpus(&self) -> u32 { + self.cpus as u32 + } + + pub fn compute( + &self, f: F + ) -> WorkerFuture + where F: FnOnce() -> R + Send + 'static, + R: IntoFuture + 'static, + R::Future: Send + 'static, + R::Item: Send + 'static, + R::Error: Send + 'static + { + WorkerFuture { + future: self.pool.spawn_fn(f) + } + } + + pub fn scope<'a, F, R>( + &self, + elements: usize, + f: F + ) -> R + where F: FnOnce(&Scope<'a>, usize) -> R + { + let chunk_size = self.get_chunk_size(elements); + + crossbeam::scope(|scope| { + f(scope, chunk_size) + }).expect("must run") + } + + pub fn get_chunk_size( + &self, + elements: usize + ) -> usize { + let chunk_size = if elements < self.cpus { + 1 + } else { + elements / self.cpus + }; + + chunk_size + } + + pub fn get_num_spawned_threads( + &self, + elements: usize + ) -> usize { + let chunk_size = self.get_chunk_size(elements); + + let mut n = elements / chunk_size; + if elements % chunk_size != 0 { + n += 1; + } + + n + } +} + +pub struct WorkerFuture { + future: CpuFuture +} + +impl Future for WorkerFuture { + type Item = T; + type Error = E; + + fn poll(&mut self) -> Poll + { + self.future.poll() + } +} + +fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + +#[test] +fn test_log2_floor() { + assert_eq!(log2_floor(1), 0); + assert_eq!(log2_floor(2), 1); + assert_eq!(log2_floor(3), 1); + assert_eq!(log2_floor(4), 2); + assert_eq!(log2_floor(5), 2); + assert_eq!(log2_floor(6), 2); + assert_eq!(log2_floor(7), 2); + assert_eq!(log2_floor(8), 3); + assert_eq!(log2_floor(15), 3); + assert_eq!(log2_floor(16), 4); +} diff --git a/src/plonk/fft/prefetch.rs b/src/plonk/fft/prefetch.rs new file mode 100644 index 000000000..c6a8e8126 --- /dev/null +++ b/src/plonk/fft/prefetch.rs @@ -0,0 +1,17 @@ +extern crate prefetch; + +use self::prefetch::prefetch::*; + +#[inline(always)] +pub(crate) fn prefetch_index(slice: &[T], idx: usize) { + let p: *const T = &slice[idx]; + // unsafe { std::intrinsics::prefetch_write_data(p, 2) }; + prefetch::(p); +} + +#[inline(always)] +pub(crate) fn prefetch_index_read(slice: &[T], idx: usize) { + let p: *const T = &slice[idx]; + // unsafe { std::intrinsics::prefetch_read_data(p, 2) }; + prefetch::(p); +} \ No newline at end of file diff --git a/src/plonk/fft/prefetch_fft.rs b/src/plonk/fft/prefetch_fft.rs new file mode 100644 index 000000000..431ded853 --- /dev/null +++ b/src/plonk/fft/prefetch_fft.rs @@ -0,0 +1,155 @@ +use crate::ff::PrimeField; +use crate::worker::*; +use super::prefetch::*; +use log::info; + +fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + +pub(crate) fn best_fft(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, use_cpus_hint: Option) +{ + + info!("******** begin best_fft in prefetch_fft.rs"); + let log_cpus = if let Some(hint) = use_cpus_hint { + assert!(hint <= worker.cpus); + log2_floor(hint) + } else { + worker.log_num_cpus() + }; + + if log_cpus == 0 || log_n <= log_cpus { + serial_fft(a, omega, log_n); + } else { + parallel_fft(a, worker, omega, log_n, log_cpus); + } + + info!("****** end best_fft in prefetch_fft.rs") +} + +pub(crate) fn serial_fft(a: &mut [F], omega: &F, log_n: u32) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + let n = a.len() as u32; + assert_eq!(n, 1 << log_n); + + for k in 0..n { + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + let mut m = 1; + for _ in 0..log_n { + let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let step_by = 2*m as usize; + for k in (0..n).step_by(step_by) { + { + prefetch_index::(a, (k + m) as usize); + prefetch_index::(a, k as usize); + } + let mut w = F::one(); + for j in 0..(m-1) { + { + prefetch_index::(a, (k+j+1+m) as usize); + prefetch_index::(a, (k+j+1) as usize); + } + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + + let j = m - 1; + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + + m *= 2; + } +} + +pub(crate) fn parallel_fft( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32 +) +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + serial_fft(tmp, &new_omega, log_new_n); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} \ No newline at end of file diff --git a/src/plonk/fft/prefetch_lde.rs b/src/plonk/fft/prefetch_lde.rs new file mode 100644 index 000000000..659af1adf --- /dev/null +++ b/src/plonk/fft/prefetch_lde.rs @@ -0,0 +1,447 @@ +use crate::ff::PrimeField; +use crate::worker::*; +use super::prefetch::*; + +fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + +pub(crate) fn best_lde(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, lde_factor: usize) +{ + let log_cpus = worker.log_num_cpus(); + + if log_n <= log_cpus { + serial_lde(a, omega, log_n, lde_factor); + } else { + parallel_lde(a, worker, omega, log_n, log_cpus, lde_factor); + } +} + +pub(crate) fn serial_lde(a: &mut [F], omega: &F, log_n: u32, lde_factor: usize) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + #[inline(always)] + fn is_non_zero(idx: usize, lde_factor: usize, step: usize) -> bool { + let idx_mod_f = idx & (lde_factor - 1); + return idx_mod_f < (1 << step); + } + + #[inline(always)] + fn is_dense_round(lde_factor: usize, step: usize) -> bool { + let f = lde_factor >> step; + if f <= 1 { + return true; + } + + false + } + + let n = a.len() as u32; + let non_trivial_len = (a.len() / lde_factor) as u32; + assert_eq!(n, 1 << log_n); + + for k in 0..n { + if k >= non_trivial_len { + break; + } + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + // even after bit reverses we can guarantee some distribution + + let mut m = 1; + let mut step = 0; + + for _ in 0..log_n { + let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let step_by = 2*m as usize; + if is_dense_round(lde_factor, step) { + // standard fft + for k in (0..n).step_by(step_by) { + { + prefetch_index::(a, (k + m) as usize); + prefetch_index::(a, k as usize); + } + let mut w = F::one(); + for j in 0..(m-1) { + { + prefetch_index::(a, (k+j+1+m) as usize); + prefetch_index::(a, (k+j+1) as usize); + } + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + + let j = m - 1; + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + } else { + // have some pain trying to save on memory reads and multiplications + for k in (0..n).step_by(step_by) { + { + let odd_idx = (k + m) as usize; + let even_idx = k as usize; + if is_non_zero(even_idx, lde_factor, step) || is_non_zero(odd_idx, lde_factor, step) { + prefetch_index::(a, odd_idx); + prefetch_index::(a, even_idx); + } + } + let mut w = F::one(); + for j in 0..(m-1) { + let odd_idx = (k+j+m) as usize; + let even_idx = (k+j) as usize; + { + if is_non_zero(even_idx+1, lde_factor, step) || is_non_zero(odd_idx+1, lde_factor, step) { + prefetch_index::(a, odd_idx + 1); + prefetch_index::(a, even_idx + 1); + } + } + + let odd_is_non_zero = is_non_zero(odd_idx, lde_factor, step); + let even_is_non_zero = is_non_zero(even_idx, lde_factor, step); + + // debug_assert!(!a[odd_idx].is_zero() == odd_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", odd_idx, odd_is_non_zero, step, a[odd_idx]); + // debug_assert!(!a[even_idx].is_zero() == even_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", even_idx, even_is_non_zero, step, a[even_idx]); + + match (odd_is_non_zero, even_is_non_zero) { + (true, true) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = a[even_idx]; + tmp.sub_assign(&t); + + a[odd_idx] = tmp; + a[even_idx].add_assign(&t); + }, + (false, true) => { + a[odd_idx] = a[even_idx]; + }, + (true, false) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = t; + tmp.negate(); + + a[odd_idx] = tmp; + a[even_idx] = t; + }, + (false, false) => { + } + } + + w.mul_assign(&w_m); + } + + let j = m-1; + + let odd_idx = (k+j+m) as usize; + let even_idx = (k+j) as usize; + + let odd_is_non_zero = is_non_zero(odd_idx, lde_factor, step); + let even_is_non_zero = is_non_zero(even_idx, lde_factor, step); + + // debug_assert!(!a[odd_idx].is_zero() == odd_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", odd_idx, odd_is_non_zero, step, a[odd_idx]); + // debug_assert!(!a[even_idx].is_zero() == even_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", even_idx, even_is_non_zero, step, a[even_idx]); + + match (odd_is_non_zero, even_is_non_zero) { + (true, true) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = a[even_idx]; + tmp.sub_assign(&t); + + a[odd_idx] = tmp; + a[even_idx].add_assign(&t); + }, + (false, true) => { + a[odd_idx] = a[even_idx]; + }, + (true, false) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = t; + tmp.negate(); + + a[odd_idx] = tmp; + a[even_idx] = t; + }, + (false, false) => { + } + } + + w.mul_assign(&w_m); + } + } + + step += 1; + m *= 2; + } +} + +pub(crate) fn parallel_lde( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32, + lde_factor: usize +) +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + let non_trivial_len = a.len() / lde_factor; + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + if idx < non_trivial_len { + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + } + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + let new_lde_factor = lde_factor >> log_cpus; + if new_lde_factor <= 1 { + super::prefetch_fft::serial_fft(tmp, &new_omega, log_new_n); + } else { + serial_lde(tmp, &new_omega, log_new_n, new_lde_factor); + } + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} + +// #[test] +// fn test_small_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::best_fft(&mut reference[..], &worker, &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// // println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // self::serial_lde(&mut lde, &omega, log_n, BASE); +// // println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_small_prefetch_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_prefetch_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 20; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_prefetch_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 22; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use crate::polynomials::Polynomial; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// let mut poly = Polynomial::from_coeffs(coeffs.clone()).unwrap(); + +// poly.pad_by_factor(LDE_FACTOR).unwrap(); +// let now = Instant::now(); +// let naive_lde = poly.fft(&worker); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let now = Instant::now(); +// let mut lde = coeffs.clone(); +// best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + + +// assert!(naive_lde.into_coeffs() == lde); +// } + diff --git a/src/plonk/fft/radix_4/mod.rs b/src/plonk/fft/radix_4/mod.rs new file mode 100644 index 000000000..b043a1479 --- /dev/null +++ b/src/plonk/fft/radix_4/mod.rs @@ -0,0 +1,184 @@ +use crate::ff::PrimeField; +use crate::worker::*; + +pub(crate) fn best_fft(a: &mut [F], worker: &Worker, omega: &F, log_n: u32) +{ + assert!(log_n % 2 == 0); // TODO: For now + let mut log_cpus = worker.log_num_cpus(); + if log_cpus % 2 != 0 + { + log_cpus -= 1; + } + + // we split into radix-4 kernels, so we need more points to start + if log_n <= log_cpus { + serial_fft_radix_4(a, omega, log_n); + } else { + parallel_fft_radix_4(a, worker, omega, log_n, log_cpus); + } +} + +#[inline(always)] +fn base_4_digit_reverse(mut n: u64, l: u64) -> u64 { + let mut r = 0u64; + for _ in 0..l { + r = (r << 2) | (n & 3); + n >>= 2; + } + + r +} + +#[inline(always)] +fn bitreverse(mut n: u64, l: u64) -> u64 +{ + let mut r = 0; + for _ in 0..l + { + r = (r << 1) | (n & 1); + n >>= 1; + } + r +} + +pub(crate) fn serial_fft_radix_4(a: &mut [F], omega: &F, log_n: u32) +{ + let n = a.len() as u64; + assert_eq!(n, 1 << log_n); + + assert!(log_n % 2 == 0); + let num_digits = (log_n / 2) as u64; + + for k in 0..n { + let rk = base_4_digit_reverse(k, num_digits); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + // v = W_4 + let v = omega.pow(&[(n / 4) as u64]); + + let mut m = 1; + for _ in 0..(log_n / 2) { + let w_m = omega.pow(&[(n / (4*m)) as u64]); + + let mut k = 0; + while k < n { + let mut w = F::one(); + for j in 0..m { + + // y_0 = x_0 + x_1 + x_2 + x_3 + // y_1 = x_0 + W_4 * x_1 - x_2 - W_4 * x_3 + // y_2 = x_0 - x_1 + x_2 - x3 + // y_3 = x_0 - W_4 * x_1 - x_2 + W_4 * x_3 + + let mut u = w; + + let x0 = a[(k+j) as usize]; + + let mut x1 = a[(k+j+m) as usize]; + x1.mul_assign(&w); + + let mut x2 = a[(k+j+2*m) as usize]; + u.mul_assign(&w); + x2.mul_assign(&u); + + let mut x3 = a[(k+j+3*m) as usize]; + u.mul_assign(&w); + x3.mul_assign(&u); + + let mut x0_plus_x2 = x0; + x0_plus_x2.add_assign(&x2); + + let mut x1_plus_x3 = x1; + x1_plus_x3.add_assign(&x3); + + a[(k+j) as usize] = x0_plus_x2; + a[(k+j) as usize].add_assign(&x1_plus_x3); + a[(k+j+2*m) as usize] = x0_plus_x2; + a[(k+j+2*m) as usize].sub_assign(&x1_plus_x3); + + let mut x0_minus_x2 = x0; + x0_minus_x2.sub_assign(&x2); + + let mut x1_minus_x3_by_w4 = x1; + x1_minus_x3_by_w4.sub_assign(&x3); + x1_minus_x3_by_w4.mul_assign(&v); + + a[(k+j+m) as usize] = x0_minus_x2; + a[(k+j+m) as usize].add_assign(&x1_minus_x3_by_w4); + a[(k+j+3*m) as usize] = x0_minus_x2; + a[(k+j+3*m) as usize].sub_assign(&x1_minus_x3_by_w4); + + w.mul_assign(&w_m); + } + + k += 4*m; + } + + m *= 4; + } +} + +pub(crate) fn parallel_fft_radix_4( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32 +) +{ + assert!(log_n >= log_cpus); + + //we need log_n and log_cpu to be even + assert!(log_n % 2 == 0); + assert!(log_cpus % 2 == 0); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = i + (s << log_new_n); + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + serial_fft_radix_4(tmp, &new_omega, log_new_n); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} \ No newline at end of file diff --git a/src/plonk/fft/recursive_fft.rs b/src/plonk/fft/recursive_fft.rs new file mode 100644 index 000000000..456fe7c02 --- /dev/null +++ b/src/plonk/fft/recursive_fft.rs @@ -0,0 +1,211 @@ +use ff::PrimeField; +use super::multicore::*; +use log::info; + +pub(crate) fn best_fft(a: Vec, worker: &Worker, omega: &F, log_n: u32) -> Vec +{ + info!("******** begin best_fft in recursive_fft.rs"); + let log_cpus = worker.log_num_cpus(); + + if log_n <= log_cpus { + recursive_fft(&a, *omega, log_n) + } else { + parallel_fft(a, worker, omega, log_n, log_cpus) + } + info!("******** end best_fft in recursive_fft.rs"); +} + +pub(crate) fn recursive_fft(a: &[F], omega: F, log_n: u32) -> Vec +{ + let n = a.len(); + if n == 2 { + let mut t0 = a[0]; + let mut t1 = t0; + t0.add_assign(&a[1]); + t1.sub_assign(&a[1]); + + return vec![t0, t1]; + } + assert_eq!(n, 1 << log_n); + + let n_half = n / 2; + + // copy into subproblems + let mut even = Vec::with_capacity(n_half); + let mut odd = Vec::with_capacity(n_half); + + for c in a.chunks(2) { + even.push(c[0]); + odd.push(c[1]); + } + + let mut w_n = omega; + w_n.square(); + + let next_log_n = log_n - 1; + + let y_0 = recursive_fft(&even, w_n, next_log_n); + let y_1 = recursive_fft(&odd, w_n, next_log_n); + + let mut result = vec![F::zero(); n]; + + let mut w = F::one(); + for (i, (y0, y1)) in y_0.into_iter() + .zip(y_1.into_iter()) + .enumerate() { + let mut tmp = y1; + tmp.mul_assign(&w); + + result[i] = y0; + result[i].add_assign(&tmp); + + result[i+n_half] = y0; + result[i+n_half].sub_assign(&tmp); + + w.mul_assign(&omega); + } + + result +} + +pub(crate) fn parallel_fft( + mut a: Vec, + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32 +) -> Vec +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + *tmp = recursive_fft(tmp, new_omega, log_new_n); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); + + a +} + +#[test] +fn test_vs_inplace_fft() { + use ff::Field; + use crate::Fr; + use crate::fft::fft::serial_fft; + use self::recursive_fft; + use crate::domains::Domain; + let mut input = vec![Fr::one(); 16]; + input.resize(32, Fr::zero()); + + let mut reference = input.clone(); + + let log_n = 5 as u32; + + let domain = Domain::::new_for_size(32).unwrap(); + let omega = domain.generator; + + serial_fft(&mut reference[..], &omega, log_n); + let recursive = recursive_fft(&input, omega, log_n); + + assert!(recursive == reference); +} + +#[test] +fn test_best_vs_inplace_fft() { + use ff::Field; + use crate::Fr; + use crate::domains::Domain; + use crate::fft::multicore::Worker; + let mut input = vec![Fr::one(); 16]; + input.resize(32, Fr::zero()); + + let mut reference = input.clone(); + + let worker = Worker::new(); + + let log_n = 5 as u32; + + let domain = Domain::::new_for_size(32).unwrap(); + let omega = domain.generator; + + crate::fft::fft::best_fft(&mut reference[..], &worker, &omega, log_n); + let recursive = self::best_fft(input, &worker, &omega, log_n); + + assert!(recursive == reference); +} + +#[test] +fn test_large_fft_speed() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + const LOG_N: usize = 24; + const BASE: usize = 1 << LOG_N; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + use ff::Field; + use crate::experiments::vdf::Fr; + use crate::domains::Domain; + use crate::fft::multicore::Worker; + use crate::polynomials::Polynomial; + use std::time::Instant; + + let worker = Worker::new(); + + let coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + + let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); + let omega = domain.generator; + let log_n = LOG_N as u32; + + let mut reference = coeffs.clone(); + let now = Instant::now(); + crate::fft::fft::best_fft(&mut reference[..], &worker, &omega, log_n); + println!("inplace FFT taken {}ms", now.elapsed().as_millis()); + + + let now = Instant::now(); + let recursive = self::best_fft(coeffs, &worker, &omega, log_n); + println!("Recursive taken {}ms", now.elapsed().as_millis()); + + assert!(recursive == reference); +} \ No newline at end of file diff --git a/src/plonk/fft/recursive_lde.rs b/src/plonk/fft/recursive_lde.rs new file mode 100644 index 000000000..35b8bc185 --- /dev/null +++ b/src/plonk/fft/recursive_lde.rs @@ -0,0 +1,227 @@ +use ff::PrimeField; +use super::multicore::*; + +// this is different from FFT by assumption that a lot of coeffs are zero +// and it is good to check for in in arithmetic + +pub(crate) fn best_lde(a: Vec, worker: &Worker, omega: &F, log_n: u32) -> Vec +{ + let log_cpus = worker.log_num_cpus(); + + if log_n <= log_cpus { + recursive_lde(&a, *omega, log_n) + } else { + parallel_lde(a, worker, omega, log_n, log_cpus) + } +} + +pub(crate) fn recursive_lde(a: &[F], omega: F, log_n: u32) -> Vec +{ + // println!("------------------------"); + // println!("A = {:?}", a); + let mut all_zeroes = true; + for a in a.iter() { + if !a.is_zero() { + all_zeroes = false; + break; + } + } + + let n = a.len(); + + if all_zeroes { + return vec![F::zero(); n]; + } + + if n == 2 { + let mut t0 = a[0]; + let mut t1 = t0; + t0.add_assign(&a[1]); + t1.sub_assign(&a[1]); + + return vec![t0, t1]; + } + assert_eq!(n, 1 << log_n); + + let n_half = n / 2; + + // copy into subproblems + let mut even = Vec::with_capacity(n_half); + let mut odd = Vec::with_capacity(n_half); + + for c in a.chunks(2) { + even.push(c[0]); + odd.push(c[1]); + } + + let mut w_n = omega; + w_n.square(); + + let next_log_n = log_n - 1; + + let y_0 = recursive_lde(&even, w_n, next_log_n); + let y_1 = recursive_lde(&odd, w_n, next_log_n); + + let mut result = vec![F::zero(); n]; + + let mut w = F::one(); + for (i, (y0, y1)) in y_0.into_iter() + .zip(y_1.into_iter()) + .enumerate() { + let mut tmp = y1; + if !tmp.is_zero() { + tmp.mul_assign(&w); + + result[i] = y0; + result[i].add_assign(&tmp); + + result[i+n_half] = y0; + result[i+n_half].sub_assign(&tmp); + } else if !y0.is_zero() { + result[i] = y0; + result[i+n_half] = y0; + } + + w.mul_assign(&omega); + } + + result +} + +pub(crate) fn parallel_lde( + mut a: Vec, + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32 +) -> Vec +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + let mut t = a[idx]; + if !t.is_zero() { + t.mul_assign(&elt); + tmp[i].add_assign(&t); + } + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + *tmp = recursive_lde(tmp, new_omega, log_new_n); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); + + a +} + +#[test] +fn test_small_recursive_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + const LOG_N: usize = 4; + const BASE: usize = 1 << LOG_N; + const LOG_LDE: usize = 6; + const LDE_FACTOR: usize = 1 << LOG_LDE; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + use ff::Field; + use crate::experiments::vdf::Fr; + use crate::domains::Domain; + use crate::fft::multicore::Worker; + use std::time::Instant; + + let worker = Worker::new(); + + let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + + coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + + let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); + let omega = domain.generator; + let log_n = (LOG_N + LOG_LDE) as u32; + + let mut reference = coeffs.clone(); + + let now = Instant::now(); + crate::fft::fft::best_fft(&mut reference[..], &worker, &omega, log_n); + println!("naive LDE taken {}ms", now.elapsed().as_millis()); + + // let now = Instant::now(); + // let _lde = best_lde(coeffs, &worker, &omega, log_n); + // println!("LDE taken {}ms", now.elapsed().as_millis()); +} + +#[test] +fn test_large_recursive_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + const LOG_N: usize = 20; + const BASE: usize = 1 << LOG_N; + const LOG_LDE: usize = 6; + const LDE_FACTOR: usize = 1 << LOG_LDE; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + use ff::Field; + use crate::experiments::vdf::Fr; + use crate::domains::Domain; + use crate::fft::multicore::Worker; + use crate::polynomials::Polynomial; + use std::time::Instant; + + let worker = Worker::new(); + + let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + + let mut poly = Polynomial::from_coeffs(coeffs.clone()).unwrap(); + + poly.pad_by_factor(LDE_FACTOR).unwrap(); + let now = Instant::now(); + let naive_lde = poly.fft(&worker); + println!("naive LDE taken {}ms", now.elapsed().as_millis()); + + coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + + let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); + let omega = domain.generator; + let log_n = (LOG_N + LOG_LDE) as u32; + + let now = Instant::now(); + let lde = best_lde(coeffs, &worker, &omega, log_n); + println!("LDE taken {}ms", now.elapsed().as_millis()); + + assert!(naive_lde.into_coeffs() == lde); +} \ No newline at end of file diff --git a/src/plonk/fft/with_precomputation/fft.rs b/src/plonk/fft/with_precomputation/fft.rs new file mode 100644 index 000000000..e6fd1efcf --- /dev/null +++ b/src/plonk/fft/with_precomputation/fft.rs @@ -0,0 +1,156 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; +use super::FftPrecomputations; + +fn log2_floor(num: usize) -> u32 { + assert!(num > 0); + + let mut pow = 0; + + while (1 << (pow+1)) <= num { + pow += 1; + } + + pow +} + +pub(crate) fn best_fft>( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + use_cpus_hint: Option, + precomputed_omegas: &P +) +{ + let log_cpus = if let Some(hint) = use_cpus_hint { + assert!(hint <= worker.cpus); + log2_floor(hint) + } else { + worker.log_num_cpus() + }; + + if log_cpus == 0 || log_n <= log_cpus { + serial_fft(a, omega, log_n, 1, precomputed_omegas); + } else { + parallel_fft(a, worker, omega, log_n, log_cpus, precomputed_omegas); + } +} + +pub(crate) fn serial_fft>(a: &mut [F], omega: &F, log_n: u32, stride: usize, precomputed_omegas: &P) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + let n = a.len() as u32; + assert_eq!(n, 1 << log_n); + if stride == 1 { + assert_eq!(n as usize, precomputed_omegas.domain_size()) + } else { + assert!((precomputed_omegas.domain_size() / (n as usize)).is_power_of_two()); + } + + for k in 0..n { + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + let mut m = 1; + for _ in 0..log_n { + let stride_idx = ((n / (2*m)) as usize) * stride; + // let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let mut k = 0; + while k < n { + let mut idx = 0; + // let mut w = F::one(); + for j in 0..m { + + let mut t = a[(k+j+m) as usize]; + t.mul_assign(precomputed_omegas.element_for_index(idx)); + // t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + // precomputations save one multiplication here per loop + idx += stride_idx; + // w.mul_assign(&w_m); + } + + k += 2*m; + } + + m *= 2; + } +} + +pub(crate) fn parallel_fft>( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32, + precomputed_omegas: &P +) +{ + assert!(log_n >= log_cpus); + assert_eq!(a.len(), precomputed_omegas.domain_size()); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + let mut t = a[idx]; + + t.mul_assign(&elt); + tmp[i].add_assign(&t); + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + // Perform sub-FFT + serial_fft(tmp, &new_omega, log_new_n, num_cpus as usize, precomputed_omegas); + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} \ No newline at end of file diff --git a/src/plonk/fft/with_precomputation/lde.rs b/src/plonk/fft/with_precomputation/lde.rs new file mode 100644 index 000000000..d75401d0b --- /dev/null +++ b/src/plonk/fft/with_precomputation/lde.rs @@ -0,0 +1,357 @@ +use crate::pairing::ff::PrimeField; +use crate::worker::*; + +pub(crate) fn best_lde(a: &mut [F], worker: &Worker, omega: &F, log_n: u32, lde_factor: usize) +{ + let log_cpus = worker.log_num_cpus(); + + if log_n <= log_cpus { + serial_lde(a, omega, log_n, lde_factor); + } else { + parallel_lde(a, worker, omega, log_n, log_cpus, lde_factor); + } +} + +pub(crate) fn serial_lde(a: &mut [F], omega: &F, log_n: u32, lde_factor: usize) +{ + #[inline(always)] + fn bitreverse(mut n: u32, l: u32) -> u32 { + let mut r = 0; + for _ in 0..l { + r = (r << 1) | (n & 1); + n >>= 1; + } + r + } + + #[inline(always)] + fn is_non_zero(idx: usize, lde_factor: usize, step: usize) -> bool { + let idx_mod_f = idx & (lde_factor - 1); + return idx_mod_f < (1 << step); + } + + #[inline(always)] + fn is_dense_round(lde_factor: usize, step: usize) -> bool { + let f = lde_factor >> step; + if f <= 1 { + return true; + } + + false + } + + let n = a.len() as u32; + assert_eq!(n, 1 << log_n); + + for k in 0..n { + let rk = bitreverse(k, log_n); + if k < rk { + a.swap(rk as usize, k as usize); + } + } + + // even after bit reverses we can guarantee some distribution + + let mut m = 1; + let mut step = 0; + + for _ in 0..log_n { + let w_m = omega.pow(&[(n / (2*m)) as u64]); + + let step_by = 2*m as usize; + if is_dense_round(lde_factor, step) { + // standard fft + for k in (0..n).step_by(step_by) { + let mut w = F::one(); + for j in 0..m { + let mut t = a[(k+j+m) as usize]; + t.mul_assign(&w); + let mut tmp = a[(k+j) as usize]; + tmp.sub_assign(&t); + a[(k+j+m) as usize] = tmp; + a[(k+j) as usize].add_assign(&t); + w.mul_assign(&w_m); + } + } + } else { + // have some pain trying to save on memory reads and multiplications + for k in (0..n).step_by(step_by) { + let mut w = F::one(); + for j in 0..m { + let odd_idx = (k+j+m) as usize; + let even_idx = (k+j) as usize; + + let odd_is_non_zero = is_non_zero(odd_idx, lde_factor, step); + let even_is_non_zero = is_non_zero(even_idx, lde_factor, step); + + // debug_assert!(!a[odd_idx].is_zero() == odd_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", odd_idx, odd_is_non_zero, step, a[odd_idx]); + // debug_assert!(!a[even_idx].is_zero() == even_is_non_zero, "expected for idx = {} to be non-zero: {} for step {}, value: {}", even_idx, even_is_non_zero, step, a[even_idx]); + + match (odd_is_non_zero, even_is_non_zero) { + (true, true) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = a[even_idx]; + tmp.sub_assign(&t); + + a[odd_idx] = tmp; + a[even_idx].add_assign(&t); + }, + (false, true) => { + a[odd_idx] = a[even_idx]; + }, + (true, false) => { + let mut t = a[odd_idx]; + t.mul_assign(&w); + + let mut tmp = t; + tmp.negate(); + + a[odd_idx] = tmp; + a[even_idx] = t; + }, + (false, false) => { + } + } + + w.mul_assign(&w_m); + } + } + } + + step += 1; + m *= 2; + } +} + +pub(crate) fn parallel_lde( + a: &mut [F], + worker: &Worker, + omega: &F, + log_n: u32, + log_cpus: u32, + lde_factor: usize +) +{ + assert!(log_n >= log_cpus); + + let num_cpus = 1 << log_cpus; + let log_new_n = log_n - log_cpus; + let mut tmp = vec![vec![F::zero(); 1 << log_new_n]; num_cpus]; + let new_omega = omega.pow(&[num_cpus as u64]); + + let non_trivial_len = a.len() / lde_factor; + + worker.scope(0, |scope, _| { + let a = &*a; + + for (j, tmp) in tmp.iter_mut().enumerate() { + scope.spawn(move |_| { + // Shuffle into a sub-FFT + let omega_j = omega.pow(&[j as u64]); + let omega_step = omega.pow(&[(j as u64) << log_new_n]); + + let mut elt = F::one(); + for i in 0..(1 << log_new_n) { + for s in 0..num_cpus { + let idx = (i + (s << log_new_n)) % (1 << log_n); + if idx < non_trivial_len { + let mut t = a[idx]; + t.mul_assign(&elt); + tmp[i].add_assign(&t); + } + elt.mul_assign(&omega_step); + } + elt.mul_assign(&omega_j); + } + + let new_lde_factor = lde_factor >> log_cpus; + if new_lde_factor <= 1 { + super::fft::serial_fft(tmp, &new_omega, log_new_n); + } else { + serial_lde(tmp, &new_omega, log_new_n, new_lde_factor); + } + }); + } + }); + + worker.scope(a.len(), |scope, chunk| { + let tmp = &tmp; + + for (idx, a) in a.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = idx * chunk; + let mask = (1 << log_cpus) - 1; + for a in a { + *a = tmp[idx & mask][idx >> log_cpus]; + idx += 1; + } + }); + } + }); +} + +// #[test] +// fn test_small_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::best_fft(&mut reference[..], &worker, &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// // println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// // let now = Instant::now(); +// // self::serial_lde(&mut lde, &omega, log_n, BASE); +// // println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_small_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 2; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 6; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_serial_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 20; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use std::time::Instant; + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let mut reference = coeffs.clone(); + +// let mut lde = coeffs; + +// let now = Instant::now(); +// crate::fft::fft::serial_fft(&mut reference[..], &omega, log_n); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// let now = Instant::now(); +// self::serial_lde(&mut lde, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(reference == lde); +// } + +// #[test] +// fn test_large_lde() { +// use rand::{XorShiftRng, SeedableRng, Rand}; +// const LOG_N: usize = 22; +// const BASE: usize = 1 << LOG_N; +// const LOG_LDE: usize = 7; +// const LDE_FACTOR: usize = 1 << LOG_LDE; +// let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + +// use ff::Field; +// use crate::experiments::vdf::Fr; +// use crate::domains::Domain; +// use crate::fft::multicore::Worker; +// use crate::polynomials::Polynomial; +// use std::time::Instant; + +// let worker = Worker::new(); + +// let mut coeffs = (0..BASE).map(|_| Fr::rand(rng)).collect::>(); + +// let mut poly = Polynomial::from_coeffs(coeffs.clone()).unwrap(); + +// poly.pad_by_factor(LDE_FACTOR).unwrap(); +// let now = Instant::now(); +// let naive_lde = poly.fft(&worker); +// println!("naive LDE taken {}ms", now.elapsed().as_millis()); + +// coeffs.resize(BASE * LDE_FACTOR, Fr::zero()); + +// let domain = Domain::::new_for_size(coeffs.len() as u64).unwrap(); +// let omega = domain.generator; +// let log_n = (LOG_N + LOG_LDE) as u32; + +// let now = Instant::now(); +// let mut lde = coeffs.clone(); +// best_lde(&mut lde, &worker, &omega, log_n, LDE_FACTOR); +// println!("LDE taken {}ms", now.elapsed().as_millis()); + +// assert!(naive_lde.into_coeffs() == lde); +// } + diff --git a/src/plonk/fft/with_precomputation/mod.rs b/src/plonk/fft/with_precomputation/mod.rs new file mode 100644 index 000000000..4b744a588 --- /dev/null +++ b/src/plonk/fft/with_precomputation/mod.rs @@ -0,0 +1,9 @@ +use crate::ff::PrimeField; + +pub trait FftPrecomputations: Send + Sync { + fn new_for_domain_size(size: usize) -> Self; + fn element_for_index(&self, index: usize) -> &F; + fn domain_size(&self) -> usize; +} + +pub(crate) mod fft; \ No newline at end of file diff --git a/src/plonk/generator/mod.rs b/src/plonk/generator/mod.rs new file mode 100644 index 000000000..2b9d0cdbd --- /dev/null +++ b/src/plonk/generator/mod.rs @@ -0,0 +1,534 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use super::polynomials::*; +use super::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::utils::*; + +#[derive(Debug)] +struct GeneratorAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + inputs_map: Vec, + + is_finalized: bool, +} + +impl ConstraintSystem for GeneratorAssembly { + const ZERO: Variable = Variable(Index::Aux(1)); + const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_aux += 1; + let index = self.num_aux; + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_inputs += 1; + let index = self.num_inputs; + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr), values: F) -> Result<(), SynthesisError> + where + F: FnOnce() -> Result<(E::Fr, E::Fr), SynthesisError> + { + unimplemented!() + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } +} + +impl GeneratorAssembly { + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + pub(crate) fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + inputs_map: vec![], + + is_finalized: false, + + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + match (zero, >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + match (one, >::ONE) { + (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + _ => panic!("one variable is incorrect") + } + + match (tmp.dummy_variable(), >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + >::ZERO + // Variable(Index::Aux(0)) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: & Coeff) -> E::Fr { + match coeff { + Coeff::Zero => { + E::Fr::zero() + }, + Coeff::One => { + E::Fr::one() + }, + Coeff::NegativeOne => { + let mut tmp = E::Fr::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + assert!(self.is_finalized); + + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub(crate) fn num_gates(&self) -> usize { + self.input_gates.len() + self.aux_gates.len() + } + + fn finalize(&mut self) { + if self.is_finalized { + return; + } + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + self.is_finalized = true; + } +} + +#[derive(Debug)] +pub struct PlonkSetup >{ + pub n: usize, + pub q_l: S::Commitment, + pub q_r: S::Commitment, + pub q_o: S::Commitment, + pub q_m: S::Commitment, + pub q_c: S::Commitment, + pub s_id: S::Commitment, + pub sigma_1: S::Commitment, + pub sigma_2: S::Commitment, + pub sigma_3: S::Commitment, +} + +#[derive(Debug)] +pub struct PlonkSetupAuxData >{ + pub q_l_aux: Option, + pub q_r_aux: Option, + pub q_o_aux: Option, + pub q_m_aux: Option, + pub q_c_aux: Option, + pub s_id_aux: Option, + pub sigma_1_aux: Option, + pub sigma_2_aux: Option, + pub sigma_3_aux: Option, +} + +pub fn setup, C: Circuit>(circuit: &C, meta: S::Meta) -> Result<(PlonkSetup, PlonkSetupAuxData), SynthesisError> { + let mut assembly = GeneratorAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let n = assembly.num_gates(); + + let worker = Worker::new(); + + let committer = S::new_for_size(n.next_power_of_two(), meta); + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let (q_l, q_l_aux) = committer.commit_single(&q_l); + let (q_r, q_r_aux) = committer.commit_single(&q_r); + let (q_o, q_o_aux) = committer.commit_single(&q_o); + let (q_m, q_m_aux) = committer.commit_single(&q_m); + let (q_c, q_c_aux) = committer.commit_single(&q_c); + let (s_id, s_id_aux) = committer.commit_single(&s_id); + let (sigma_1, sigma_1_aux) = committer.commit_single(&sigma_1); + let (sigma_2, sigma_2_aux) = committer.commit_single(&sigma_2); + let (sigma_3, sigma_3_aux) = committer.commit_single(&sigma_3); + + let setup = PlonkSetup:: { + n, + q_l, + q_r, + q_o, + q_m, + q_c, + s_id, + sigma_1, + sigma_2, + sigma_3, + }; + + let aux = PlonkSetupAuxData:: { + q_l_aux, + q_r_aux, + q_o_aux, + q_m_aux, + q_c_aux, + s_id_aux, + sigma_1_aux, + sigma_2_aux, + sigma_3_aux + }; + + Ok((setup, aux)) +} \ No newline at end of file diff --git a/src/plonk/mod.rs b/src/plonk/mod.rs new file mode 100644 index 000000000..b99691f9c --- /dev/null +++ b/src/plonk/mod.rs @@ -0,0 +1,451 @@ +pub mod adaptor; +pub mod cs; +// pub mod generator; +// pub mod prover; +// pub mod verifier; +// pub mod tester; +pub mod polynomials; +pub mod domains; +pub mod fft; +pub mod utils; +pub mod transparent_engine; + +pub mod redshift; + +pub mod plonk; + +pub mod commitments; + +pub mod better_cs; + +pub mod better_better_cs; + +pub use self::better_cs::adaptor::{TranspilationVariant, Transpiler, Adaptor, AdaptorCircuit}; +pub use self::better_cs::keys::{SetupPolynomials, SetupPolynomialsPrecomputations, VerificationKey, Proof}; + +use crate::pairing::Engine; +use crate::{SynthesisError, Circuit}; +use crate::worker::Worker; +use crate::kate_commitment::*; +use self::better_cs::cs::{PlonkCsWidth4WithNextStepParams, PlonkConstraintSystemParams}; +use crate::plonk::commitments::transcript::*; +use crate::plonk::fft::cooley_tukey_ntt::*; + +pub fn transpile>(circuit: C) -> Result, SynthesisError> { + let mut transpiler = Transpiler::::new(); + + circuit.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let hints = transpiler.into_hints(); + + Ok(hints) +} + +pub fn transpile_with_gates_count>(circuit: C) -> Result<(usize, Vec<(usize, TranspilationVariant)>), SynthesisError> { + let mut transpiler = Transpiler::::new(); + + circuit.synthesize(&mut transpiler).expect("sythesize into traspilation must succeed"); + + let (n, hints) = transpiler.into_hints_and_num_gates(); + + Ok((n, hints)) +} + +pub fn is_satisfied>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)> +) -> Result<(), SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + let mut assembly = self::better_cs::test_assembly::TestAssembly::new(); + + adapted_curcuit.synthesize(&mut assembly) +} + +pub fn is_satisfied_using_one_shot_check>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)> +) -> Result<(), SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + let mut assembly = self::better_cs::one_shot_test_assembly::OneShotTestAssembly::new(); + + adapted_curcuit.synthesize(&mut assembly)?; + + let valid = assembly.is_satisfied(false); + + if valid { + return Ok(()); + } else { + return Err(SynthesisError::Unsatisfiable); + } +} + +pub fn setup>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)> +) -> Result, SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + let mut assembly = self::better_cs::generator::GeneratorAssembly::::new(); + + adapted_curcuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let worker = Worker::new(); + + assembly.setup(&worker) +} + +pub fn make_verification_key>( + setup: &SetupPolynomials, + crs: &Crs +) -> Result, SynthesisError> { + let worker = Worker::new(); + + let verification_key = VerificationKey::from_setup( + &setup, + &worker, + &crs + )?; + + Ok(verification_key) +} + +pub fn make_precomputations>( + setup: &SetupPolynomials +) -> Result, SynthesisError> { + let worker = Worker::new(); + + let precomputations = SetupPolynomialsPrecomputations::from_setup( + &setup, + &worker, + )?; + + Ok(precomputations) +} + +pub fn prove_native_by_steps, T: Transcript>( + circuit: &C, + setup: &SetupPolynomials, + setup_precomputations: Option<&SetupPolynomialsPrecomputations>, + csr_mon_basis: &Crs, + transcript_init_params: Option< >:: InitializationParameters>, +) -> Result, SynthesisError> { + use crate::plonk::better_cs::utils::{commit_point_as_xy}; + use crate::plonk::better_cs::prover::prove_steps::{FirstVerifierMessage, SecondVerifierMessage, ThirdVerifierMessage, FourthVerifierMessage}; + + use std::time::Instant; + + let mut assembly = self::better_cs::prover::ProverAssembly::new_with_size_hints(setup.num_inputs, setup.n); + + let subtime = Instant::now(); + + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + println!("Synthesis taken {:?}", subtime.elapsed()); + + let worker = Worker::new(); + + let now = Instant::now(); + + let mut transcript = if let Some(p) = transcript_init_params { + T::new_from_params(p) + } else { + T::new() + }; + + let mut precomputed_omegas = crate::plonk::better_cs::prover::prove_steps::PrecomputedOmegas::< E::Fr, BitReversedOmegas >::None; + let mut precomputed_omegas_inv = crate::plonk::better_cs::prover::prove_steps::PrecomputedOmegas::< E::Fr, OmegasInvBitreversed >::None; + + let mut proof = Proof::::empty(); + + let subtime = Instant::now(); + + let (first_state, first_message) = assembly.first_step_with_monomial_form_key( + &worker, + csr_mon_basis, + &mut precomputed_omegas_inv + )?; + + println!("First step (witness commitment) taken {:?}", subtime.elapsed()); + + proof.n = first_message.n; + proof.num_inputs = first_message.num_inputs; + proof.input_values = first_message.input_values; + proof.wire_commitments = first_message.wire_commitments; + + for inp in proof.input_values.iter() { + transcript.commit_field_element(inp); + } + + for c in proof.wire_commitments.iter() { + commit_point_as_xy::(&mut transcript, &c); + } + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let first_verifier_message = FirstVerifierMessage:: { + beta, + gamma, + + _marker: std::marker::PhantomData + }; + + let subtime = Instant::now(); + + let (second_state, second_message) = self::better_cs::prover::ProverAssembly::second_step_from_first_step( + first_state, + first_verifier_message, + &setup, + csr_mon_basis, + &setup_precomputations, + &mut precomputed_omegas_inv, + &worker + )?; + + println!("Second step (grand product commitment) taken {:?}", subtime.elapsed()); + + proof.grand_product_commitment = second_message.z_commitment; + commit_point_as_xy::(&mut transcript, &proof.grand_product_commitment); + + let alpha = transcript.get_challenge(); + + let second_verifier_message = SecondVerifierMessage:: { + alpha, + beta, + gamma, + + _marker: std::marker::PhantomData + }; + + let subtime = Instant::now(); + + let (third_state, third_message) = self::better_cs::prover::ProverAssembly::third_step_from_second_step( + second_state, + second_verifier_message, + &setup, + csr_mon_basis, + &setup_precomputations, + &mut precomputed_omegas, + &mut precomputed_omegas_inv, + &worker + )?; + + println!("Third step (quotient calculation and commitment) taken {:?}", subtime.elapsed()); + + proof.quotient_poly_commitments = third_message.quotient_poly_commitments; + + for c in proof.quotient_poly_commitments.iter() { + commit_point_as_xy::(&mut transcript, &c); + } + + let z = transcript.get_challenge(); + + let third_verifier_message = ThirdVerifierMessage:: { + alpha, + beta, + gamma, + z, + + _marker: std::marker::PhantomData + }; + + let subtime = Instant::now(); + + let (fourth_state, fourth_message) = self::better_cs::prover::ProverAssembly::fourth_step_from_third_step( + third_state, + third_verifier_message, + &setup, + &worker + )?; + + println!("Fourth step (openings at z) taken {:?}", subtime.elapsed()); + + proof.wire_values_at_z = fourth_message.wire_values_at_z; + proof.wire_values_at_z_omega = fourth_message.wire_values_at_z_omega; + proof.permutation_polynomials_at_z = fourth_message.permutation_polynomials_at_z; + proof.grand_product_at_z_omega = fourth_message.grand_product_at_z_omega; + proof.quotient_polynomial_at_z = fourth_message.quotient_polynomial_at_z; + proof.linearization_polynomial_at_z = fourth_message.linearization_polynomial_at_z; + + for el in proof.wire_values_at_z.iter() { + transcript.commit_field_element(el); + } + + for el in proof.wire_values_at_z_omega.iter() { + transcript.commit_field_element(el); + } + + for el in proof.permutation_polynomials_at_z.iter() { + transcript.commit_field_element(el); + } + + transcript.commit_field_element(&proof.quotient_polynomial_at_z); + transcript.commit_field_element(&proof.linearization_polynomial_at_z); + transcript.commit_field_element(&proof.grand_product_at_z_omega); + + let v = transcript.get_challenge(); + + let fourth_verifier_message = FourthVerifierMessage:: { + alpha, + beta, + gamma, + z, + v, + + _marker: std::marker::PhantomData + }; + + let subtime = Instant::now(); + + let fifth_message = self::better_cs::prover::ProverAssembly::fifth_step_from_fourth_step( + fourth_state, + fourth_verifier_message, + &setup, + csr_mon_basis, + &worker + )?; + + println!("Fifth step (proving opening at z) taken {:?}", subtime.elapsed()); + + proof.opening_at_z_proof = fifth_message.opening_proof_at_z; + proof.opening_at_z_omega_proof = fifth_message.opening_proof_at_z_omega; + + println!("Proving taken {:?}", now.elapsed()); + + Ok(proof) +} + +pub fn prove_by_steps, T: Transcript>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)>, + setup: &SetupPolynomials, + setup_precomputations: Option<&SetupPolynomialsPrecomputations>, + csr_mon_basis: &Crs, + transcript_init_params: Option< >:: InitializationParameters>, +) -> Result, SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + use crate::plonk::better_cs::utils::{commit_point_as_xy}; + use crate::plonk::better_cs::prover::prove_steps::{FirstVerifierMessage, SecondVerifierMessage, ThirdVerifierMessage, FourthVerifierMessage}; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + prove_native_by_steps::<_, _, T>( + &adapted_curcuit, + setup, + setup_precomputations, + csr_mon_basis, + transcript_init_params + ) +} + +pub fn prove, T: Transcript>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)>, + setup: &SetupPolynomials, + csr_mon_basis: &Crs, + crs_lagrange_basis: &Crs +) -> Result, SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + let precomputations = make_precomputations(&setup)?; + + // TODO: keep track of num AUX too + let mut assembly = self::better_cs::prover::ProverAssembly::new_with_size_hints(setup.num_inputs, setup.n); + + adapted_curcuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let size = setup.n.next_power_of_two(); + + let worker = Worker::new(); + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + use std::time::Instant; + let now = Instant::now(); + let proof = assembly.prove::( + &worker, + &setup, + &precomputations, + &crs_lagrange_basis, + &csr_mon_basis, + &omegas_bitreversed, + &omegas_inv_bitreversed, + None, + )?; + + println!("Proving taken {:?}", now.elapsed()); + + Ok(proof) +} + + +pub fn prove_from_recomputations< + E: Engine, + C: crate::Circuit, + T: Transcript, + CP: CTPrecomputations, + CPI: CTPrecomputations, +>( + circuit: C, + hints: &Vec<(usize, TranspilationVariant)>, + setup: &SetupPolynomials, + setup_precomputations: &SetupPolynomialsPrecomputations, + omegas_bitreversed: &CP, + omegas_inv_bitreversed: &CPI, + csr_mon_basis: &Crs, + crs_lagrange_basis: &Crs +) -> Result, SynthesisError> { + use crate::plonk::better_cs::cs::Circuit; + + let adapted_curcuit = AdaptorCircuit::::new(circuit, &hints); + + let mut assembly = self::better_cs::prover::ProverAssembly::new_with_size_hints(setup.num_inputs, setup.n); + + adapted_curcuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let size = setup.n.next_power_of_two(); + + assert_eq!(omegas_bitreversed.domain_size(), size); + assert_eq!(omegas_inv_bitreversed.domain_size(), size); + + let worker = Worker::new(); + + use std::time::Instant; + let now = Instant::now(); + let proof = assembly.prove::( + &worker, + &setup, + &setup_precomputations, + &crs_lagrange_basis, + &csr_mon_basis, + omegas_bitreversed, + omegas_inv_bitreversed, + None, + )?; + + println!("Proving taken {:?}", now.elapsed()); + + Ok(proof) +} + +pub fn verify>( + proof: &Proof, + verification_key: &VerificationKey +) -> Result { + self::better_cs::verifier::verify::(&proof, &verification_key, None) +} \ No newline at end of file diff --git a/src/plonk/plonk/generator.rs b/src/plonk/plonk/generator.rs new file mode 100644 index 000000000..82014f8b7 --- /dev/null +++ b/src/plonk/plonk/generator.rs @@ -0,0 +1,547 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::utils::*; + +use super::prover::ProvingAssembly; + +#[derive(Debug)] +pub struct GeneratorAssembly { + pub(crate) m: usize, + pub(crate) n: usize, + pub(crate) input_gates: Vec>, + pub(crate) aux_gates: Vec>, + + pub(crate) num_inputs: usize, + pub(crate) num_aux: usize, + + pub(crate) inputs_map: Vec, + + pub(crate) is_finalized: bool, +} + +impl ConstraintSystem for GeneratorAssembly { + // const ZERO: Variable = Variable(Index::Aux(1)); + // const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_aux += 1; + let index = self.num_aux; + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_inputs += 1; + let index = self.num_inputs; + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), + coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl GeneratorAssembly { + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + pub fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + inputs_map: vec![], + + is_finalized: false, + + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + // let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + // tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + // match (zero, >::ZERO) { + // (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + // _ => panic!("zero variable is incorrect") + // } + + // match (one, >::ONE) { + // (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + // _ => panic!("one variable is incorrect") + // } + + match (tmp.dummy_variable(), zero) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + assert_eq!(tmp.num_inputs, 0); + assert_eq!(tmp.num_aux, 1); + + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + // >::ZERO + Variable(Index::Aux(1)) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: &Coeff) -> F { + match coeff { + Coeff::Zero => { + F::zero() + }, + Coeff::One => { + F::one() + }, + Coeff::NegativeOne => { + let mut tmp = F::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element::(&gate.q_l); + *q_r = coeff_into_field_element::(&gate.q_r); + *q_o = coeff_into_field_element::(&gate.q_o); + *q_m = coeff_into_field_element::(&gate.q_m); + *q_c = coeff_into_field_element::(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + assert!(self.is_finalized); + + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub fn num_gates(&self) -> usize { + self.input_gates.len() + self.aux_gates.len() + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + let n = self.input_gates.len() + self.aux_gates.len(); + assert!((n+1).is_power_of_two()); + + self.is_finalized = true; + } +} + +use super::prover::*; +use crate::plonk::fft::cooley_tukey_ntt::CTPrecomputations; + +use crate::pairing::CurveAffine; + +pub fn setup_with_precomputations, CP: CTPrecomputations>( + circuit: &C, + omegas_bitreversed: &CP, + bases: &[E::G1Affine] + ) -> Result<(PlonkSetup, PlonkSetupPrecomputation), SynthesisError> +{ + let mut assembly = GeneratorAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let n = assembly.num_gates(); + + let worker = Worker::new(); + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let q_l_commitment_data = ProvingAssembly::::commit_single_poly(&q_l, &bases, &worker)?; + let q_r_commitment_data = ProvingAssembly::::commit_single_poly(&q_r, &bases, &worker)?; + let q_o_commitment_data = ProvingAssembly::::commit_single_poly(&q_o, &bases, &worker)?; + let q_m_commitment_data = ProvingAssembly::::commit_single_poly(&q_m, &bases, &worker)?; + let q_c_commitment_data = ProvingAssembly::::commit_single_poly(&q_c, &bases, &worker)?; + let s_id_commitment_data = ProvingAssembly::::commit_single_poly(&s_id, &bases, &worker)?; + let sigma_1_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_1, &bases, &worker)?; + let sigma_2_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_2, &bases, &worker)?; + let sigma_3_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_3, &bases, &worker)?; + + let setup = PlonkSetup:: { + n: n, + q_l: q_l_commitment_data, + q_r: q_r_commitment_data, + q_o: q_o_commitment_data, + q_m: q_m_commitment_data, + q_c: q_c_commitment_data, + s_id: s_id_commitment_data, + sigma_1: sigma_1_commitment_data, + sigma_2: sigma_2_commitment_data, + sigma_3: sigma_3_commitment_data, + }; + + let coset_generator = E::Fr::multiplicative_generator(); + + let q_l_lde = q_l.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let q_r_lde = q_r.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let q_o_lde = q_o.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let q_m_lde = q_m.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let q_c_lde = q_c.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + + let s_id_lde = s_id.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + + let sigma_1_lde = sigma_1.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let sigma_2_lde = sigma_2.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + let sigma_3_lde = sigma_3.bitreversed_lde_using_bitreversed_ntt(&worker, 4, omegas_bitreversed, &coset_generator)?; + + let precomputation = PlonkSetupPrecomputation:: { + q_l_aux: q_l_lde, + q_r_aux: q_r_lde, + q_o_aux: q_o_lde, + q_m_aux: q_m_lde, + q_c_aux: q_c_lde, + s_id_aux: s_id_lde, + sigma_1_aux: sigma_1_lde, + sigma_2_aux: sigma_2_lde, + sigma_3_aux: sigma_3_lde + }; + + Ok((setup, precomputation)) +} \ No newline at end of file diff --git a/src/plonk/plonk/mod.rs b/src/plonk/plonk/mod.rs new file mode 100644 index 000000000..bc10e00d7 --- /dev/null +++ b/src/plonk/plonk/mod.rs @@ -0,0 +1,2 @@ +pub mod prover; +pub mod generator; \ No newline at end of file diff --git a/src/plonk/plonk/prover.rs b/src/plonk/plonk/prover.rs new file mode 100644 index 000000000..0ab5e85b7 --- /dev/null +++ b/src/plonk/plonk/prover.rs @@ -0,0 +1,2052 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; +use crate::plonk::transparent_engine::TransparentEngine; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use crate::plonk::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; +use crate::plonk::polynomials::*; + +#[derive(Debug, Clone)] +pub struct ProvingAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + inputs_map: Vec, + + is_finalized: bool +} + +impl ConstraintSystem for ProvingAssembly { + // const ZERO: Variable = Variable(Index::Aux(1)); + // const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + // println!("Allocated variable Aux({}) with value {}", index, value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + // let gate = Gate::::new_enforce_constant_gate(input_var, Some(value), self.dummy_variable()); + self.input_gates.push(gate); + + // println!("Allocated input Input({}) with value {}", index, value); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), + coeffs:(E::Fr,E::Fr,E::Fr,E::Fr,E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_gate(variables, coeffs); + // println!("Enforced new gate number {}: {:?}", self.n, gate); + self.aux_gates.push(gate); + self.n += 1; + + // let satisfied = self.clone().is_satisfied(); + // if !satisfied { + // return Err(SynthesisError::Unsatisfiable); + // } + + Ok(()) + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + // println!("Enforced new constant gate number {}: {:?}", self.n, gate); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + fn get_value(&self, var: Variable) -> Result { + let value = match var { + Variable(Index::Input(input)) => { + self.input_assingments[input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[aux - 1] + } + }; + + Ok(value) + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl ProvingAssembly { + pub fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + inputs_map: vec![], + + is_finalized: false, + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + // let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + // tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + // match (zero, >::ZERO) { + // (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + // _ => panic!("zero variable is incorrect") + // } + + // match (one, >::ONE) { + // (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + // _ => panic!("one variable is incorrect") + // } + + match (tmp.dummy_variable(), zero) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + // >::ZERO + Variable(Index::Aux(1)) + } + + pub(crate) fn make_wire_assingments(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + // create a vector of gate assingments + // if a_i = j then w_j = f_l(g^i) + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut f_l = vec![E::Fr::zero(); total_num_gates]; + let mut f_r = vec![E::Fr::zero(); total_num_gates]; + let mut f_o = vec![E::Fr::zero(); total_num_gates]; + + for (i, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + f_l[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_l[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + f_r[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_r[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + f_o[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_o[i] = self.aux_assingments[index - 1]; + }, + } + } + + (f_l, f_r, f_o) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: & Coeff) -> F { + match coeff { + Coeff::Zero => { + F::zero() + }, + Coeff::One => { + F::one() + }, + Coeff::NegativeOne => { + let mut tmp = F::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub fn num_gates(&self) -> usize { + assert!(self.is_finalized); + + self.input_gates.len() + self.aux_gates.len() + } + + pub fn finalize(&mut self) { + if self.is_finalized { + return; + } + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + self.is_finalized = true; + } + + pub fn is_satisfied(mut self) -> bool { + // self.finalize(); + // assert!(self.is_finalized); + + fn coeff_into_field_element(coeff: & Coeff) -> F { + match coeff { + Coeff::Zero => { + F::zero() + }, + Coeff::One => { + F::one() + }, + Coeff::NegativeOne => { + let mut tmp = F::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (i, gate) in self.input_gates.iter().enumerate() + { + let q_l = coeff_into_field_element(&gate.q_l); + let q_r = coeff_into_field_element(&gate.q_r); + let q_o = coeff_into_field_element(&gate.q_o); + let q_m = coeff_into_field_element(&gate.q_m); + let q_c = coeff_into_field_element(&gate.q_c); + + assert!(q_c.is_zero(), "should not hardcode a constant into the input gate"); + + let a_value = self.get_value(*gate.a_wire()).expect("must get a variable value"); + let b_value = self.get_value(*gate.b_wire()).expect("must get a variable value"); + let c_value = self.get_value(*gate.c_wire()).expect("must get a variable value"); + + let input_value = self.input_assingments[i]; + let mut res = input_value; + res.negate(); + + let mut tmp = q_l; + tmp.mul_assign(&a_value); + res.add_assign(&tmp); + + let mut tmp = q_r; + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + let mut tmp = q_o; + tmp.mul_assign(&c_value); + res.add_assign(&tmp); + + let mut tmp = q_m; + tmp.mul_assign(&a_value); + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + if !res.is_zero() { + println!("Unsatisfied at input gate {}: {:?}", i+1, gate); + println!("A value = {}, B value = {}, C value = {}", a_value, b_value, c_value); + return false; + } + } + + for (i, gate) in self.aux_gates.iter().enumerate() + { + let q_l = coeff_into_field_element(&gate.q_l); + let q_r = coeff_into_field_element(&gate.q_r); + let q_o = coeff_into_field_element(&gate.q_o); + let q_m = coeff_into_field_element(&gate.q_m); + let q_c = coeff_into_field_element(&gate.q_c); + + let a_value = self.get_value(*gate.a_wire()).expect("must get a variable value"); + let b_value = self.get_value(*gate.b_wire()).expect("must get a variable value"); + let c_value = self.get_value(*gate.c_wire()).expect("must get a variable value"); + + let mut res = q_c; + + let mut tmp = q_l; + tmp.mul_assign(&a_value); + res.add_assign(&tmp); + + let mut tmp = q_r; + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + let mut tmp = q_o; + tmp.mul_assign(&c_value); + res.add_assign(&tmp); + + let mut tmp = q_m; + tmp.mul_assign(&a_value); + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + if !res.is_zero() { + println!("Unsatisfied at aux gate {}", i+1); + println!("Gate {:?}", *gate); + println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + return false; + } + } + + true + } + + fn calculate_inverse_vanishing_polynomial_in_a_coset(&self, worker: &Worker, poly_size:usize, vahisning_size: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64)?; + let n_domain_omega = domain.generator; + let mut root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + root.negate(); + + let multiplicative_generator = E::Fr::multiplicative_generator(); + + let mut negative_one = E::Fr::one(); + negative_one.negate(); + + let mut numerator = Polynomial::::from_values(vec![multiplicative_generator; poly_size])?; + // evaluate X in linear time + + numerator.distribute_powers(&worker, numerator.omega); + numerator.add_constant(&worker, &root); + + // numerator.add_constant(&worker, &negative_one); + // now it's a series of values in a coset + + // now we should evaluate X^(n+1) - 1 in a linear time + + let shift = multiplicative_generator.pow([vahisning_size as u64]); + + let mut denominator = Polynomial::::from_values(vec![shift; poly_size])?; + + // elements are h^size - 1, (hg)^size - 1, (hg^2)^size - 1, ... + + denominator.distribute_powers(&worker, denominator.omega.pow([vahisning_size as u64])); + denominator.add_constant(&worker, &negative_one); + + denominator.batch_inversion(&worker)?; + + numerator.mul_assign(&worker, &denominator); + + Ok(numerator) + } + + fn evaluate_inverse_vanishing_poly(&self, vahisning_size: usize, point: E::Fr) -> E::Fr { + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("should fit"); + let n_domain_omega = domain.generator; + let root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + + let mut numerator = point; + numerator.sub_assign(&root); + + let mut denominator = point.pow([vahisning_size as u64]); + denominator.sub_assign(&E::Fr::one()); + + let denominator = denominator.inverse().expect("must exist"); + + numerator.mul_assign(&denominator); + + numerator + } + + fn calculate_lagrange_poly(&self, worker: &Worker, poly_size:usize, poly_number: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(poly_number < poly_size); + + let mut poly = Polynomial::::from_values(vec![E::Fr::zero(); poly_size])?; + + poly.as_mut()[poly_number] = E::Fr::one(); + + Ok(poly.ifft(&worker)) + } +} + +// pub struct RedshiftProof, FRI: FriIop>{ +// pub a_opening_value: F, +// pub b_opening_value: F, +// pub c_opening_value: F, +// pub q_l_opening_value: F, +// pub q_r_opening_value: F, +// pub q_o_opening_value: F, +// pub q_m_opening_value: F, +// pub q_c_opening_value: F, +// pub s_id_opening_value: F, +// pub sigma_1_opening_value: F, +// pub sigma_2_opening_value: F, +// pub sigma_3_opening_value: F, +// pub z_1_unshifted_opening_value: F, +// pub z_2_unshifted_opening_value: F, +// pub z_1_shifted_opening_value: F, +// pub z_2_shifted_opening_value: F, +// pub t_low_opening_value: F, +// pub t_mid_opening_value: F, +// pub t_high_opening_value: F, +// pub a_commitment: I::Commitment, +// pub b_commitment: I::Commitment, +// pub c_commitment: I::Commitment, +// pub z_1_commitment: I::Commitment, +// pub z_2_commitment: I::Commitment, +// pub t_low_commitment: I::Commitment, +// pub t_mid_commitment: I::Commitment, +// pub t_high_commitment: I::Commitment, +// pub openings_proof: FRI::Proof, +// } + +use crate::plonk::fft::cooley_tukey_ntt::CTPrecomputations; + +use crate::pairing::{CurveAffine, CurveProjective}; +use crate::pairing::EncodedPoint; + +#[derive(Debug)] +pub struct PlonkSetup{ + pub n: usize, + pub q_l: E::G1Affine, + pub q_r: E::G1Affine, + pub q_o: E::G1Affine, + pub q_m: E::G1Affine, + pub q_c: E::G1Affine, + pub s_id: E::G1Affine, + pub sigma_1: E::G1Affine, + pub sigma_2: E::G1Affine, + pub sigma_3: E::G1Affine, +} + +// #[derive(Debug)] +pub struct PlonkSetupPrecomputation{ + pub q_l_aux: Polynomial, + pub q_r_aux: Polynomial, + pub q_o_aux: Polynomial, + pub q_m_aux: Polynomial, + pub q_c_aux: Polynomial, + pub s_id_aux: Polynomial, + pub sigma_1_aux: Polynomial, + pub sigma_2_aux: Polynomial, + pub sigma_3_aux: Polynomial, +} + +struct OpeningRequest<'a, E: Engine> { + polynomials: Vec<&'a Polynomial>, + opening_point: E::Fr, + opening_values: Vec +} + +use crate::multiexp::dense_multiexp; + +pub(crate) fn field_elements_into_representations( + worker: &Worker, + scalars: Vec +) -> Result::Repr>, SynthesisError> +{ + let mut representations = vec![::Repr::default(); scalars.len()]; + worker.scope(scalars.len(), |scope, chunk| { + for (scalar, repr) in scalars.chunks(chunk) + .zip(representations.chunks_mut(chunk)) { + scope.spawn(move |_| { + for (scalar, repr) in scalar.iter() + .zip(repr.iter_mut()) { + *repr = scalar.into_repr(); + } + }); + } + }); + + Ok(representations) +} + +impl ProvingAssembly { + pub(crate) fn commit_single_poly( + poly: &Polynomial, + bases: &[E::G1Affine], + worker: &Worker + ) -> Result { + let reprs = field_elements_into_representations::(&worker, poly.as_ref().to_owned())?; + let result = dense_multiexp(&worker, bases, &reprs)?; + + Ok(result.into_affine()) + } + + fn divide_single( + poly: &[E::Fr], + opening_point: E::Fr, + ) -> Vec { + // we are only interested in quotient without a reminder, so we actually don't need opening value + let mut b = opening_point; + b.negate(); + + let mut q = vec![E::Fr::zero(); poly.len()]; + + let mut tmp = E::Fr::zero(); + let mut found_one = false; + for (q, r) in q.iter_mut().rev().skip(1).zip(poly.iter().rev()) { + if !found_one { + if r.is_zero() { + continue + } else { + found_one = true; + } + } + + let mut lead_coeff = *r; + lead_coeff.sub_assign(&tmp); + *q = lead_coeff; + tmp = lead_coeff; + tmp.mul_assign(&b); + } + + q + } + + fn multiopening> + ( + opening_request: OpeningRequest, + bases: &[E::G1Affine], + worker: &Worker, + transcript: &mut T + ) -> Result { + let required_size = opening_request.polynomials[0].size(); + + let mut final_aggregate = Polynomial::from_coeffs(vec![E::Fr::zero(); required_size])?; + + let aggregation_challenge = transcript.get_challenge(); + + let mut alpha = E::Fr::one(); + + for poly in opening_request.polynomials.iter() { + final_aggregate.add_assign_scaled(&worker, poly, &alpha); + + alpha.mul_assign(&aggregation_challenge); + } + + let q = Self::divide_single(final_aggregate.as_ref(), opening_request.opening_point); + + let q = Polynomial::from_coeffs(q)?; + + let opening = Self::commit_single_poly(&q, bases, &worker)?; + + Ok(opening) + } + + fn prove_with_setup_precomputed, CPI: CTPrecomputations, T: Transcript >( + self, + setup_precomp: &PlonkSetupPrecomputation, + worker: &Worker, + omegas_bitreversed: &CP, + omegas_inv_bitreversed: &CPI, + bases: &[E::G1Affine] + ) -> Result<(), SynthesisError> { + assert!(self.is_finalized); + + let mut transcript = T::new(); + + let n = self.input_gates.len() + self.aux_gates.len(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let (w_l, w_r, w_o) = self.make_wire_assingments(); + + // these are 2^k - 1 size and explicitly unpadded + let w_l = Polynomial::::from_values_unpadded(w_l)?; + let w_r = Polynomial::::from_values_unpadded(w_r)?; + let w_o = Polynomial::::from_values_unpadded(w_o)?; + + let a_poly = w_l.clone_padded_to_domain()?.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let b_poly = w_r.clone_padded_to_domain()?.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let c_poly = w_o.clone_padded_to_domain()?.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // polynomials inside of these is are values in cosets + + let a_commitment_data = Self::commit_single_poly(&a_poly, bases, &worker)?; + let b_commitment_data = Self::commit_single_poly(&b_poly, bases, &worker)?; + let c_commitment_data = Self::commit_single_poly(&c_poly, bases, &worker)?; + + transcript.commit_bytes(a_commitment_data.into_compressed().as_ref()); + transcript.commit_bytes(b_commitment_data.into_compressed().as_ref()); + transcript.commit_bytes(c_commitment_data.into_compressed().as_ref()); + + // TODO: Add public inputs + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut w_l_plus_gamma = w_l.clone(); + w_l_plus_gamma.add_constant(&worker, &gamma); + + let mut w_r_plus_gamma = w_r.clone(); + w_r_plus_gamma.add_constant(&worker, &gamma); + + let mut w_o_plus_gamma = w_o.clone(); + w_o_plus_gamma.add_constant(&worker, &gamma); + + // we take A, B, C values and form (A + beta*i + gamma), etc and calculate their grand product + + let z_1 = { + let n = self.input_gates.len() + self.aux_gates.len(); + let s_id_1: Vec<_> = (1..=n).collect(); + let s_id_1 = convert_to_field_elements(&s_id_1, &worker); + let s_id_1 = Polynomial::::from_values_unpadded(s_id_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &s_id_1, &beta); + drop(s_id_1); + + let s_id_2: Vec<_> = ((n+1)..=(2*n)).collect(); + let s_id_2 = convert_to_field_elements(&s_id_2, &worker); + let s_id_2 = Polynomial::::from_values_unpadded(s_id_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &s_id_2, &beta); + drop(s_id_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let s_id_3: Vec<_> = ((2*n+1)..=(3*n)).collect(); + let s_id_3 = convert_to_field_elements(&s_id_3, &worker); + let s_id_3 = Polynomial::::from_values_unpadded(s_id_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &s_id_3, &beta); + drop(s_id_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + Polynomial::::from_values(prepadded)? + }; + + let z_2 = { + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let sigma_1 = convert_to_field_elements(&sigma_1, &worker); + let sigma_1 = Polynomial::::from_values_unpadded(sigma_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &sigma_1, &beta); + drop(sigma_1); + + let sigma_2 = convert_to_field_elements(&sigma_2, &worker); + let sigma_2 = Polynomial::::from_values_unpadded(sigma_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &sigma_2, &beta); + drop(sigma_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let sigma_3 = convert_to_field_elements(&sigma_3, &worker); + let sigma_3 = Polynomial::::from_values_unpadded(sigma_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &sigma_3, &beta); + drop(sigma_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + let z_2 = Polynomial::::from_values(prepadded)?; + + z_2 + }; + + assert!(z_2.as_ref().last().expect("must exist") == z_1.as_ref().last().expect("must exist")); + + // interpolate on the main domain + let z_1 = z_1.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let z_2 = z_2.ifft_using_bitreversed_ntt(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // polynomials inside of these is are values in cosets + + let z_1_commitment_data = Self::commit_single_poly(&z_1, &bases, &worker)?; + let z_2_commitment_data = Self::commit_single_poly(&z_2, &bases, &worker)?; + + transcript.commit_bytes(z_1_commitment_data.into_compressed().as_ref()); + transcript.commit_bytes(z_2_commitment_data.into_compressed().as_ref()); + + let mut z_1_shifted = z_1.clone(); + z_1_shifted.distribute_powers(&worker, z_1.omega); + + let mut z_2_shifted = z_2.clone(); + z_2_shifted.distribute_powers(&worker, z_2.omega); + + + let a_coset_lde_bitreversed = a_poly.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + let b_coset_lde_bitreversed = b_poly.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + let c_coset_lde_bitreversed = c_poly.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + let q_l_coset_lde_bitreversed = setup_precomp.q_l_aux.clone(); + let q_r_coset_lde_bitreversed = setup_precomp.q_r_aux.clone(); + let q_o_coset_lde_bitreversed = setup_precomp.q_o_aux.clone(); + let q_m_coset_lde_bitreversed = setup_precomp.q_m_aux.clone(); + let q_c_coset_lde_bitreversed = setup_precomp.q_c_aux.clone(); + let s_id_coset_lde_bitreversed = setup_precomp.s_id_aux.clone(); + let sigma_1_coset_lde_bitreversed = setup_precomp.sigma_1_aux.clone(); + let sigma_2_coset_lde_bitreversed = setup_precomp.sigma_2_aux.clone(); + let sigma_3_coset_lde_bitreversed = setup_precomp.sigma_3_aux.clone(); + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = self.output_setup_polynomials(&worker)?; + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + // TODO: may be speedup this one too + let mut vanishing_poly_inverse_bitreversed = self.calculate_inverse_vanishing_polynomial_in_a_coset(&worker, q_l_coset_lde_bitreversed.size(), required_domain_size.next_power_of_two())?; + vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker); + + let mut t_1 = { + let mut t_1 = q_c_coset_lde_bitreversed; + + let mut q_l_by_a = q_l_coset_lde_bitreversed; + q_l_by_a.mul_assign(&worker, &a_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_l_by_a); + drop(q_l_by_a); + + let mut q_r_by_b = q_r_coset_lde_bitreversed; + q_r_by_b.mul_assign(&worker, &b_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_r_by_b); + drop(q_r_by_b); + + let mut q_o_by_c = q_o_coset_lde_bitreversed; + q_o_by_c.mul_assign(&worker, &c_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_o_by_c); + drop(q_o_by_c); + + let mut q_m_by_ab = q_m_coset_lde_bitreversed; + q_m_by_ab.mul_assign(&worker, &a_coset_lde_bitreversed); + q_m_by_ab.mul_assign(&worker, &b_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_m_by_ab); + drop(q_m_by_ab); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + t_1.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1 + }; + + fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + println!("Degree = {}", degree); + + degree + } + + let z_1_coset_lde_bitreversed = z_1.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_1_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_1_shifted_coset_lde_bitreversed = z_1_shifted.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_1_shifted_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_2_coset_lde_bitreversed = z_2.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_2_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_2_shifted_coset_lde_bitreversed = z_2_shifted.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_2_shifted_coset_lde_bitreversed.size() == required_domain_size*4); + + // (A + beta*i + gamma)(B + beta(n+i) + gamma)(C + beta(2n+i) + gamma)*Z(k) = Z(k+1) + { + // TODO: May be optimize number of additions + let mut contrib_z_1 = z_1_coset_lde_bitreversed.clone(); + + let mut s_id_by_beta = s_id_coset_lde_bitreversed; + s_id_by_beta.scale(&worker, beta); + + let mut n_by_beta = n_fe; + n_by_beta.mul_assign(&beta); + + let mut a_perm = s_id_by_beta.clone(); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &a_perm); + drop(a_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut b_perm = s_id_by_beta.clone(); + + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &b_perm); + drop(b_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut c_perm = s_id_by_beta; + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_1.sub_assign(&worker, &z_1_shifted_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + contrib_z_1.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &contrib_z_1); + } + + { + // TODO: May be optimize number of additions + let mut contrib_z_2 = z_2_coset_lde_bitreversed.clone(); + + let mut a_perm = sigma_1_coset_lde_bitreversed; + a_perm.scale(&worker, beta); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &a_perm); + drop(a_perm); + + + let mut b_perm = sigma_2_coset_lde_bitreversed; + b_perm.scale(&worker, beta); + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &b_perm); + drop(b_perm); + + let mut c_perm = sigma_3_coset_lde_bitreversed; + c_perm.scale(&worker, beta); + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_2.sub_assign(&worker, &z_2_shifted_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + contrib_z_2.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &contrib_z_2); + } + + drop(a_coset_lde_bitreversed); + drop(b_coset_lde_bitreversed); + drop(c_coset_lde_bitreversed); + + let l_0 = self.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), 0)?; + let l_n_minus_one = self.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), n-1)?; + + { + let mut z_1_minus_z_2_shifted = z_1_shifted_coset_lde_bitreversed.clone(); + z_1_minus_z_2_shifted.sub_assign(&worker, &z_2_shifted_coset_lde_bitreversed); + + let l_coset_lde_bitreversed = l_n_minus_one.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + z_1_minus_z_2_shifted.mul_assign(&worker, &l_coset_lde_bitreversed); + drop(l_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + z_1_minus_z_2_shifted.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &z_1_minus_z_2_shifted); + } + + { + let mut z_1_minus_z_2 = z_1_coset_lde_bitreversed.clone(); + z_1_minus_z_2.sub_assign(&worker, &z_2_coset_lde_bitreversed); + + let l_coset_lde_bitreversed = l_0.clone().bitreversed_lde_using_bitreversed_ntt( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + z_1_minus_z_2.mul_assign(&worker, &l_coset_lde_bitreversed); + drop(l_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + z_1_minus_z_2.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &z_1_minus_z_2); + } + + drop(z_1_coset_lde_bitreversed); + drop(z_2_coset_lde_bitreversed); + drop(z_1_shifted_coset_lde_bitreversed); + drop(z_2_shifted_coset_lde_bitreversed); + + t_1.bitreverse_enumeration(&worker); + + let t_poly = t_1.icoset_fft_for_generator(&worker, &E::Fr::multiplicative_generator()); + + debug_assert!(get_degree::(&t_poly) <= 3*n); + + let mut t_poly_parts = t_poly.break_into_multiples(required_domain_size)?; + + t_poly_parts.pop().expect("last part is irrelevant"); + let t_poly_high = t_poly_parts.pop().expect("high exists"); + let t_poly_mid = t_poly_parts.pop().expect("mid exists"); + let t_poly_low = t_poly_parts.pop().expect("low exists"); + + let t_poly_high_commitment_data = Self::commit_single_poly(&t_poly_high, &bases, &worker)?; + let t_poly_mid_commitment_data = Self::commit_single_poly(&t_poly_mid, &bases, &worker)?; + let t_poly_low_commitment_data = Self::commit_single_poly(&t_poly_low, &bases, &worker)?; + + transcript.commit_bytes(t_poly_low_commitment_data.into_compressed().as_ref()); + transcript.commit_bytes(t_poly_mid_commitment_data.into_compressed().as_ref()); + transcript.commit_bytes(t_poly_high_commitment_data.into_compressed().as_ref()); + + let z = transcript.get_challenge(); + + let a_at_z = a_poly.evaluate_at(&worker, z); + let b_at_z = b_poly.evaluate_at(&worker, z); + let c_at_z = c_poly.evaluate_at(&worker, z); + + let q_l_at_z = q_l.evaluate_at(&worker, z); + let q_r_at_z = q_r.evaluate_at(&worker, z); + let q_o_at_z = q_o.evaluate_at(&worker, z); + let q_m_at_z = q_m.evaluate_at(&worker, z); + let q_c_at_z = q_c.evaluate_at(&worker, z); + + let s_id_at_z = s_id.evaluate_at(&worker, z); + let sigma_1_at_z = sigma_1.evaluate_at(&worker, z); + let sigma_2_at_z = sigma_2.evaluate_at(&worker, z); + let sigma_3_at_z = sigma_3.evaluate_at(&worker, z); + + let mut inverse_vanishing_at_z = self.evaluate_inverse_vanishing_poly(required_domain_size.next_power_of_two(), z); + + let z_1_at_z = z_1.evaluate_at(&worker, z); + let z_2_at_z = z_2.evaluate_at(&worker, z); + + let z_1_shifted_at_z = z_1_shifted.evaluate_at(&worker, z); + let z_2_shifted_at_z = z_2_shifted.evaluate_at(&worker, z); + + let t_low_at_z = t_poly_low.evaluate_at(&worker, z); + let t_mid_at_z = t_poly_mid.evaluate_at(&worker, z); + let t_high_at_z = t_poly_high.evaluate_at(&worker, z); + + let l_0_at_z = l_0.evaluate_at(&worker, z); + let l_n_minus_one_at_z = l_n_minus_one.evaluate_at(&worker, z); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_low_at_z); + transcript.commit_field_element(&t_mid_at_z); + transcript.commit_field_element(&t_high_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + // let aggregation_challenge = transcript.get_challenge(); + + let z_in_pow_of_domain_size = z.pow([required_domain_size as u64]); + + // this is a sanity check + { + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + let mut t_at_z = E::Fr::zero(); + t_at_z.add_assign(&t_low_at_z); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&t_mid_at_z); + t_at_z.add_assign(&tmp); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&z_in_pow_of_domain_size); + tmp.mul_assign(&t_high_at_z); + t_at_z.add_assign(&tmp); + + if t_at_z != t_1 { + println!("Sanity check failed, may be due to public inputs ignored"); + } + + // assert_eq!(t_at_z, t_1, "sanity check failed"); + } + + // Compute linearization polynomial + + let mut linearization_poly = q_m.clone(); + let mut linearization_multiplier = alpha; + { + let mut tmp = q_l_at_z; + tmp.mul_assign(&q_r_at_z); + + linearization_poly.scale(&worker, tmp); + + linearization_poly.add_assign_scaled(&worker, &q_l, &q_l_at_z); + + linearization_poly.add_assign_scaled(&worker, &q_r, &q_r_at_z); + + linearization_poly.add_assign_scaled(&worker, &q_o, &q_o_at_z); + + linearization_poly.add_assign(&worker, &q_c); + + linearization_poly.scale(&worker, linearization_multiplier); + } + + linearization_multiplier.mul_assign(&alpha); + { + let mut factor = linearization_multiplier; + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&a_at_z); + + factor.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&b_at_z); + + factor.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&c_at_z); + + factor.mul_assign(&tmp); + + linearization_poly.add_assign_scaled(&worker, &z_1, &tmp); + } + + linearization_multiplier.mul_assign(&alpha); + { + let mut factor = linearization_multiplier; + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&a_at_z); + + factor.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&b_at_z); + + factor.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&c_at_z); + + factor.mul_assign(&tmp); + + linearization_poly.add_assign_scaled(&worker, &z_2, &tmp); + } + + linearization_multiplier.mul_assign(&alpha); + linearization_multiplier.mul_assign(&alpha); + { + let mut tmp = z_1.clone(); + tmp.sub_assign(&worker, &z_2); + linearization_poly.add_assign_scaled(&worker, &tmp, &linearization_multiplier); + } + + let linearization_poly_at_z = linearization_poly.evaluate_at(&worker, z); + + transcript.commit_field_element(&linearization_poly_at_z); + + let mut z_by_omega = z; + z_by_omega.mul_assign(&z_1.omega); + + let request_at_z = OpeningRequest { + polynomials: vec![ + &a_poly, + &b_poly, + &c_poly, + &z_1, + &z_2, + &s_id, + &sigma_1, + &sigma_2, + &sigma_3, + &t_poly_low, + &t_poly_mid, + &t_poly_high + ], + opening_point: z, + opening_values: vec![ + a_at_z, + b_at_z, + c_at_z, + z_1_at_z, + z_2_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + t_low_at_z, + t_mid_at_z, + t_high_at_z, + ] + }; + + let request_at_z_omega = OpeningRequest { + polynomials: vec![ + &z_1, + &z_2 + ], + opening_point: z_by_omega, + opening_values: vec![ + z_1_shifted_at_z, + z_2_shifted_at_z, + ] + }; + + let _ = Self::multiopening(request_at_z, &bases, &worker, &mut transcript); + let _ = Self::multiopening(request_at_z_omega, &bases, &worker, &mut transcript); + + + Ok(()) + + + // let proof = PlonkChunkedNonhomomorphicProof:: { + // a_opening_value: a_at_z, + // b_opening_value: b_at_z, + // c_opening_value: c_at_z, + // q_l_opening_value: q_l_at_z, + // q_r_opening_value: q_r_at_z, + // q_o_opening_value: q_o_at_z, + // q_m_opening_value: q_m_at_z, + // q_c_opening_value: q_c_at_z, + // s_id_opening_value: s_id_at_z, + // sigma_1_opening_value: sigma_1_at_z, + // sigma_2_opening_value: sigma_2_at_z, + // sigma_3_opening_value: sigma_3_at_z, + // z_1_unshifted_opening_value: z_1_at_z, + // z_2_unshifted_opening_value: z_2_at_z, + // z_1_shifted_opening_value: z_1_shifted_at_z, + // z_2_shifted_opening_value: z_2_shifted_at_z, + // t_low_opening_value: t_low_at_z, + // t_mid_opening_value: t_mid_at_z, + // t_high_opening_value: t_high_at_z, + // a_commitment: a_commitment, + // b_commitment: b_commitment, + // c_commitment: c_commitment, + // z_1_commitment: z_1_commitment, + // z_2_commitment: z_2_commitment, + // t_low_commitment: t_low_commitment, + // t_mid_commitment: t_mid_commitment, + // t_high_commitment: t_high_commitment, + // openings_proof: multiopen_proof, + // }; + + // Ok(proof) + } +} + +#[cfg(test)] +mod test { + + use crate::plonk::cs::*; + use crate::pairing::Engine; + use crate::SynthesisError; + use super::*; + use super::super::generator::*; + + use crate::ff::{Field, PrimeField}; + + #[derive(Clone)] + struct BenchmarkCircuit{ + num_steps: usize, + _marker: std::marker::PhantomData + } + + impl Circuit for BenchmarkCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + // yeah, fibonacci... + + let one = E::Fr::one(); + let mut negative_one = one; + negative_one.negate(); + + let mut two = one; + two.double(); + + let mut a = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + let mut b = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + cs.enforce_zero_2((a, b), (one, negative_one))?; + // cs.enforce_zero_2((b, CS::ONE), (one, negative_one))?; + + let mut c = cs.alloc(|| { + Ok(two) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + + let mut a_value = one; + let mut b_value = one; + let mut c_value = two; + + for _ in 0..self.num_steps { + a = b; + b = c; + + a_value = b_value; + b_value = c_value; + c_value.add_assign(&a_value); + + c = cs.alloc(|| { + Ok(c_value) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + } + + Ok(()) + } + } + + #[test] + fn test_bench_plonk_bls12() { + use crate::pairing::Engine; + use crate::pairing::{CurveProjective, CurveAffine}; + use crate::pairing::bls12_381::{Bls12, Fr}; + use crate::plonk::utils::*; + use crate::worker::Worker; + // use crate::plonk::tester::*; + + type Transcr = Blake2sTranscript; + type Eng = Bls12; + + use std::time::Instant; + + use crate::plonk::fft::cooley_tukey_ntt::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::precomputation::*; + + let sizes: Vec = vec![(1 << 18) - 10, (1 << 19) - 10, (1 << 20) - 10, (1 << 21) - 10, (1 << 22) - 10, (1 << 23) - 10]; + + let max_size = *sizes.last().unwrap(); + + let worker = Worker::new(); + + println!("Making bases"); + let bases = { + use crate::pairing::Wnaf; + let tau = Fr::from_str("42").unwrap(); + let powers_of_tau = vec![Fr::one(); max_size.next_power_of_two()]; + let mut powers_of_tau = Polynomial::::from_coeffs(powers_of_tau).unwrap(); + + powers_of_tau.distribute_powers(&worker, tau); + + let powers_of_tau = powers_of_tau.into_coeffs(); + + // Compute G1 window table + let mut g1_wnaf = Wnaf::new(); + let g1 = ::G1::one(); + let g1_wnaf = g1_wnaf.base(g1, max_size.next_power_of_two()); + + let mut bases = vec![g1; max_size.next_power_of_two()]; + + // Compute the H query with multiple threads + worker.scope(bases.len(), |scope, chunk| { + for (h, p) in bases.chunks_mut(chunk).zip(powers_of_tau.chunks(chunk)) + { + let mut g1_wnaf = g1_wnaf.shared(); + scope.spawn(move |_| { + // Set values of the H query to g1^{(tau^i * t(tau)) / delta} + for (h, p) in h.iter_mut().zip(p.iter()) + { + // Exponentiate + *h = g1_wnaf.scalar(p.into_repr()); + } + + // Batch normalize + <::G1 as CurveProjective>::batch_normalization(h); + }); + } + }); + + bases.iter().map(|el| el.into_affine()).collect::>() + }; + println!("Done making bases"); + + for size in sizes.into_iter() { + + let circuit = BenchmarkCircuit:: { + // num_steps: 1_000_000, + num_steps: size, + _marker: std::marker::PhantomData + }; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + println!("Start setup and precomputations"); + let (_, setup_precomp) = setup_with_precomputations::( + &circuit, + &omegas_bitreversed, + &bases[0..size.next_power_of_two()] + ).unwrap(); + + let mut prover = ProvingAssembly::::new(); + circuit.synthesize(&mut prover).unwrap(); + prover.finalize(); + + println!("End setup and precomputations"); + + println!("Start proving"); + + let start = Instant::now(); + + let _ = prover.prove_with_setup_precomputed::<_, _, Transcr>( + &setup_precomp, + &worker, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &bases[0..size.next_power_of_two()] + ).unwrap(); + + println!("Proving taken {:?} for size {}", start.elapsed(), size); + } + + + // { + // let mut tester = TestingAssembly::::new(); + + // circuit.synthesize(&mut tester).expect("must synthesize"); + + // let satisfied = tester.is_satisfied(); + + // assert!(satisfied); + + // println!("Circuit is satisfied"); + // } + + // println!("Start setup"); + // let start = Instant::now(); + // let (setup, aux) = setup::(&circuit, meta.clone()).unwrap(); + // println!("Setup taken {:?}", start.elapsed()); + + // println!("Using circuit with N = {}", setup.n); + + // println!("Start proving"); + // let start = Instant::now(); + // let proof = prove_nonhomomorphic_chunked::, _>(&circuit, &aux, meta.clone()).unwrap(); + // println!("Proof taken {:?}", start.elapsed()); + + // println!("Start verifying"); + // let start = Instant::now(); + // let valid = verify_nonhomomorphic_chunked::>(&setup, &proof, meta).unwrap(); + // println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + // assert!(valid); + } + + #[test] + fn test_bench_plonk_bn254() { + use crate::pairing::Engine; + use crate::pairing::{CurveProjective, CurveAffine}; + use crate::pairing::bn256::{Bn256, Fr}; + use crate::plonk::utils::*; + use crate::worker::Worker; + // use crate::plonk::tester::*; + + type Transcr = Blake2sTranscript; + type Eng = Bn256; + + use std::time::Instant; + + use crate::plonk::fft::cooley_tukey_ntt::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::precomputation::*; + + let sizes: Vec = vec![(1 << 18) - 10, (1 << 19) - 10, (1 << 20) - 10, (1 << 21) - 10, (1 << 22) - 10, (1 << 23) - 10]; + + let max_size = *sizes.last().unwrap(); + + let worker = Worker::new(); + + println!("Making bases"); + let bases = { + use crate::pairing::Wnaf; + let tau = Fr::from_str("42").unwrap(); + let powers_of_tau = vec![Fr::one(); max_size.next_power_of_two()]; + let mut powers_of_tau = Polynomial::::from_coeffs(powers_of_tau).unwrap(); + + powers_of_tau.distribute_powers(&worker, tau); + + let powers_of_tau = powers_of_tau.into_coeffs(); + + // Compute G1 window table + let mut g1_wnaf = Wnaf::new(); + let g1 = ::G1::one(); + let g1_wnaf = g1_wnaf.base(g1, max_size.next_power_of_two()); + + let mut bases = vec![g1; max_size.next_power_of_two()]; + + // Compute the H query with multiple threads + worker.scope(bases.len(), |scope, chunk| { + for (h, p) in bases.chunks_mut(chunk).zip(powers_of_tau.chunks(chunk)) + { + let mut g1_wnaf = g1_wnaf.shared(); + scope.spawn(move |_| { + // Set values of the H query to g1^{(tau^i * t(tau)) / delta} + for (h, p) in h.iter_mut().zip(p.iter()) + { + // Exponentiate + *h = g1_wnaf.scalar(p.into_repr()); + } + + // Batch normalize + <::G1 as CurveProjective>::batch_normalization(h); + }); + } + }); + + bases.iter().map(|el| el.into_affine()).collect::>() + }; + println!("Done making bases"); + + for size in sizes.into_iter() { + println!("Working for size {}", size); + + let circuit = BenchmarkCircuit:: { + // num_steps: 1_000_000, + num_steps: size, + _marker: std::marker::PhantomData + }; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + + println!("Start setup and precomputations"); + let (_, setup_precomp) = setup_with_precomputations::( + &circuit, + &omegas_bitreversed, + &bases[0..size.next_power_of_two()] + ).unwrap(); + + let mut prover = ProvingAssembly::::new(); + circuit.synthesize(&mut prover).unwrap(); + prover.finalize(); + + println!("End setup and precomputations"); + + println!("Start proving"); + + let start = Instant::now(); + + let _ = prover.prove_with_setup_precomputed::<_, _, Transcr>( + &setup_precomp, + &worker, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &bases[0..size.next_power_of_two()] + ).unwrap(); + + println!("Proving taken {:?} for size {}", start.elapsed(), size); + } + + + // { + // let mut tester = TestingAssembly::::new(); + + // circuit.synthesize(&mut tester).expect("must synthesize"); + + // let satisfied = tester.is_satisfied(); + + // assert!(satisfied); + + // println!("Circuit is satisfied"); + // } + + // println!("Start setup"); + // let start = Instant::now(); + // let (setup, aux) = setup::(&circuit, meta.clone()).unwrap(); + // println!("Setup taken {:?}", start.elapsed()); + + // println!("Using circuit with N = {}", setup.n); + + // println!("Start proving"); + // let start = Instant::now(); + // let proof = prove_nonhomomorphic_chunked::, _>(&circuit, &aux, meta.clone()).unwrap(); + // println!("Proof taken {:?}", start.elapsed()); + + // println!("Start verifying"); + // let start = Instant::now(); + // let valid = verify_nonhomomorphic_chunked::>(&setup, &proof, meta).unwrap(); + // println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + // assert!(valid); + } +} \ No newline at end of file diff --git a/src/plonk/polynomials/mod.rs b/src/plonk/polynomials/mod.rs new file mode 100644 index 000000000..2b0132ac7 --- /dev/null +++ b/src/plonk/polynomials/mod.rs @@ -0,0 +1,2845 @@ +use crate::pairing::ff::PrimeField; +use crate::plonk::domains::*; +use crate::SynthesisError; +use crate::worker::*; +use crate::plonk::fft::*; +use crate::plonk::fft::with_precomputation; +use crate::plonk::fft::with_precomputation::FftPrecomputations; + +use crate::plonk::fft::cooley_tukey_ntt; +use crate::plonk::fft::cooley_tukey_ntt::CTPrecomputations; +use crate::plonk::fft::cooley_tukey_ntt::partial_reduction; +use log::info; + +use crate::plonk::transparent_engine::PartialTwoBitReductionField; +use crate::plonk::fft::fft::{best_fft_bn256_gpu, bit_rev_best_ct_ntt_2_best_fft_gpu}; + +pub trait PolynomialForm: Sized + Copy + Clone {} + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum Coefficients { } + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum Values { } + +impl PolynomialForm for Coefficients {} +impl PolynomialForm for Values{} + +// TODO: Enforce bitreversed values as a separate form + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct Polynomial { + coeffs: Vec, + pub exp: u32, + pub omega: F, + pub omegainv: F, + pub geninv: F, + pub minv: F, + _marker: std::marker::PhantomData

+} + + +impl Polynomial { + pub fn size(&self) -> usize { + self.coeffs.len() + } + + pub fn as_ref(&self) -> &[F] { + &self.coeffs + } + + pub fn as_mut(&mut self) -> &mut [F] { + &mut self.coeffs + } + + pub fn into_coeffs(self) -> Vec { + self.coeffs + } + + pub fn distribute_powers(&mut self, worker: &Worker, g: F) + { + distribute_powers(&mut self.coeffs, &worker, g); + } + + pub fn reuse_allocation (&mut self, other: &Polynomial) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + self.coeffs.copy_from_slice(&other.coeffs); + } + + pub fn bitreverse_enumeration(&mut self, worker: &Worker) { + let total_len = self.coeffs.len(); + let log_n = self.exp as usize; + if total_len <= worker.cpus { + for j in 0..total_len { + let rj = cooley_tukey_ntt::bitreverse(j, log_n); + if j < rj { + self.coeffs.swap(j, rj); + } + } + + return; + } + + let r = &mut self.coeffs[..] as *mut [F]; + + let to_spawn = worker.cpus; + + let chunk = Worker::chunk_size_for_num_spawned_threads(total_len, to_spawn); + + // while it's unsafe we don't care cause swapping is always one to one + + worker.scope(0, |scope, _| { + for thread_id in 0..to_spawn { + let r = unsafe {&mut *r}; + scope.spawn(move |_| { + let start = thread_id * chunk; + let end = if start + chunk <= total_len { + start + chunk + } else { + total_len + }; + for j in start..end { + let rj = cooley_tukey_ntt::bitreverse(j, log_n); + if j < rj { + r.swap(j, rj); + } + } + }); + } + }); + } + + pub fn scale(&mut self, worker: &Worker, g: F) + { + if g == F::one() { + return; + } + + worker.scope(self.coeffs.len(), |scope, chunk| { + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + v.mul_assign(&g); + } + }); + } + }); + } + + pub fn negate(&mut self, worker: &Worker) + { + worker.scope(self.coeffs.len(), |scope, chunk| { + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + v.negate(); + } + }); + } + }); + } + + pub fn map () + Send + Copy>(&mut self, worker: &Worker, func: M) + { + worker.scope(self.coeffs.len(), |scope, chunk| { + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + func(v); + } + }); + } + }); + } + + pub fn map_indexed () + Send + Copy>(&mut self, worker: &Worker, func: M) + { + worker.scope(self.coeffs.len(), |scope, chunk| { + for (chunk_idx, v) in self.coeffs.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let base = chunk_idx * chunk; + for (in_chunk_idx, v) in v.iter_mut().enumerate() { + func(base + in_chunk_idx, v); + } + }); + } + }); + } + + pub fn pad_by_factor(&mut self, factor: usize) -> Result<(), SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + + if factor == 1 { + return Ok(()); + } + let next_power_of_two = factor.next_power_of_two(); + if factor != next_power_of_two { + return Err(SynthesisError::Unsatisfiable); + } + + let new_size = self.coeffs.len() * factor; + self.coeffs.resize(new_size, F::zero()); + + let domain = Domain::new_for_size(new_size as u64)?; + self.exp = domain.power_of_two as u32; + let m = domain.size as usize; + self.omega = domain.generator; + self.omegainv = self.omega.inverse().unwrap(); + self.minv = F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(); + + Ok(()) + } + + pub fn pad_to_size(&mut self, new_size: usize) -> Result<(), SynthesisError> { + if new_size < self.coeffs.len() { + return Err(SynthesisError::PolynomialDegreeTooLarge); + } + let next_power_of_two = new_size.next_power_of_two(); + if new_size != next_power_of_two { + return Err(SynthesisError::Unsatisfiable); + } + self.coeffs.resize(new_size, F::zero()); + + let domain = Domain::new_for_size(new_size as u64)?; + self.exp = domain.power_of_two as u32; + let m = domain.size as usize; + self.omega = domain.generator; + self.omegainv = self.omega.inverse().unwrap(); + self.minv = F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(); + + Ok(()) + } + + pub fn pad_to_domain(&mut self) -> Result<(), SynthesisError> { + let domain = Domain::::new_for_size(self.coeffs.len() as u64)?; + self.coeffs.resize(domain.size as usize, F::zero()); + + Ok(()) + } + + pub fn clone_padded_to_domain(&self) -> Result { + let mut padded = self.clone(); + let domain = Domain::::new_for_size(self.coeffs.len() as u64)?; + padded.coeffs.resize(domain.size as usize, F::zero()); + + Ok(padded) + } + + pub fn trim_to_degree(&mut self, degree: usize) -> Result<(), SynthesisError> { + let size = self.coeffs.len(); + if size <= degree + 1 { + return Ok(()); + } + self.coeffs.truncate(degree + 1); + self.coeffs.resize(size, F::zero()); + + Ok(()) + } +} + +impl Polynomial { + pub fn new_for_size(size: usize) -> Result, SynthesisError> { + let coeffs = vec![F::zero(); size]; + + Self::from_coeffs(coeffs) + } + + pub fn from_coeffs(mut coeffs: Vec) -> Result, SynthesisError> + { + let coeffs_len = coeffs.len(); + + let domain = Domain::new_for_size(coeffs_len as u64)?; + let exp = domain.power_of_two as u32; + let m = domain.size as usize; + let omega = domain.generator; + + coeffs.resize(m, F::zero()); + + Ok(Polynomial:: { + coeffs: coeffs, + exp: exp, + omega: omega, + omegainv: omega.inverse().unwrap(), + geninv: F::multiplicative_generator().inverse().unwrap(), + minv: F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(), + _marker: std::marker::PhantomData + }) + } + + pub fn from_roots(roots: Vec, worker: &Worker) -> Result, SynthesisError> + { + info!("******* begin from_roots "); + let coeffs_len = roots.len() + 1; + + let domain = Domain::::new_for_size(coeffs_len as u64)?; + let num_threads = worker.cpus; + + // vector of vectors of polynomial coefficients for subproducts + let mut subterms = vec![vec![]; num_threads]; + + worker.scope(roots.len(), |scope, chunk| { + for (r, s) in roots.chunks(chunk) + .zip(subterms.chunks_mut(1)) { + scope.spawn(move |_| { + for r in r.iter() { + if s[0].len() == 0 { + let mut tmp = *r; + tmp.negate(); + s[0] = vec![tmp, F::one()]; + } else { + let mut tmp = Vec::with_capacity(s[0].len() + 1); + tmp.push(F::zero()); + tmp.extend(s[0].clone()); + for (c, n) in s[0].iter().zip(tmp.iter_mut()) { + let mut t = *c; + t.mul_assign(&r); + n.sub_assign(&t); + } + s[0] = tmp; + } + } + }); + } + }); + + // now we have subproducts in a coefficient form + + let mut result: Option> = None; + let result_len = domain.size as usize; + + for s in subterms.into_iter() { + if s.len() == 0 { + continue; + } + let t = Polynomial::::from_coeffs(s)?; + let factor = result_len / t.size(); + let t = t.lde(&worker, factor)?; + if let Some(res) = result.as_mut() { + res.mul_assign(&worker, &t); + } else { + result = Some(t); + } + } + + let result = result.expect("is some"); + let result = result.ifft(&worker); + info!("******* end from_roots "); + Ok(result) + } + + pub fn evaluate_at_domain_for_degree_one( + &self, + worker: &Worker, + domain_size: u64 + ) -> Result, SynthesisError> { + assert_eq!(self.coeffs.len(), 2); + let alpha = self.coeffs[1]; + let c = self.coeffs[0]; + + let domain = Domain::::new_for_size(domain_size)?; + + let mut result = vec![F::zero(); domain.size as usize]; + let g = domain.generator; + worker.scope(result.len(), |scope, chunk| { + for (i, v) in result.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = g.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + let mut tmp = alpha; + tmp.mul_assign(&u); + tmp.add_assign(&c); + *v = tmp; + u.mul_assign(&g); + } + }); + } + }); + + Polynomial::from_values(result) + } + + pub fn coset_evaluate_at_domain_for_degree_one( + &self, + worker: &Worker, + domain_size: u64 + ) -> Result, SynthesisError> { + assert_eq!(self.coeffs.len(), 2); + let alpha = self.coeffs[1]; + let c = self.coeffs[0]; + + let domain = Domain::::new_for_size(domain_size)?; + + let mut result = vec![F::zero(); domain.size as usize]; + let g = domain.generator; + worker.scope(result.len(), |scope, chunk| { + for (i, v) in result.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = g.pow(&[(i * chunk) as u64]); + u.mul_assign(&F::multiplicative_generator()); + for v in v.iter_mut() { + let mut tmp = alpha; + tmp.mul_assign(&u); + tmp.add_assign(&c); + *v = tmp; + u.mul_assign(&g); + } + }); + } + }); + + Polynomial::from_values(result) + } + + // pub fn sparse_distribute(&mut self, factor: usize, worker: &Worker) -> Result<(), SynthesisError> { + // if factor == 1 { + // return Ok(()); + // } + // let next_power_of_two = factor.next_power_of_two(); + // if factor != next_power_of_two { + // return Err(SynthesisError::Error); + // } + + // let new_size = self.coeffs.len() * factor; + // let new_coeffs = vec![F::zero(); new_size]; + // let old_coeffs = std::mem::replace(&mut self.coeffs, new_coeffs); + + // // now we need to interleave the coefficients + // worker.scope(old_coeffs.len(), |scope, chunk| { + // for (old, new) in old_coeffs.chunks(chunk) + // .zip(self.coeffs.chunks_mut(chunk*factor)) { + // scope.spawn(move |_| { + // for (j, old_coeff) in old.iter().enumerate() { + // new[j*factor] = *old_coeff; + // } + // }); + // } + // }); + + // let domain = Domain::new_for_size(new_size as u64)?; + // self.exp = domain.power_of_two as u32; + // let m = domain.size as usize; + // self.omega = domain.generator; + // self.omegainv = self.omega.inverse().unwrap(); + // self.minv = F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(); + + // Ok(()) + // } + + // pub fn extend(&mut self, factor: usize, _worker: &Worker) -> Result<(), SynthesisError> { + // if factor == 1 { + // return Ok(()); + // } + // let next_power_of_two = factor.next_power_of_two(); + // if factor != next_power_of_two { + // return Err(SynthesisError::Error); + // } + + // let new_size = self.coeffs.len() * factor; + // self.coeffs.resize(new_size, F::zero()); + + // Ok(()) + // } + + #[inline(always)] + pub fn break_into_multiples(self, size: usize) -> Result>, SynthesisError> { + let mut coeffs = self.coeffs; + + let (mut num_parts, last_size) = if coeffs.len() % size == 0 { + let num_parts = coeffs.len() / size; + + (num_parts, 0) + } else { + let num_parts = coeffs.len() / size; + let last_size = coeffs.len() - num_parts * size; + + (num_parts, last_size) + }; + + let mut rev_results = Vec::with_capacity(num_parts); + + if last_size != 0 { + let drain = coeffs.split_off(coeffs.len() - last_size); + rev_results.push(drain); + num_parts -= 1; + } + + for _ in 0..num_parts { + let drain = coeffs.split_off(coeffs.len() - size); + rev_results.push(drain); + } + + let mut results = Vec::with_capacity(num_parts); + + for c in rev_results.into_iter().rev() { + let poly = Polynomial::::from_coeffs(c)?; + results.push(poly); + } + + Ok(results) + } + + #[inline(always)] + pub fn lde(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + self.lde_using_multiple_cosets(worker, factor) + // self.filtering_lde(worker, factor) + } + + #[inline(always)] + pub fn coset_lde(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + self.coset_lde_using_multiple_cosets(worker, factor) + // self.filtering_coset_lde(worker, factor) + } + + pub fn filtering_lde(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + info!("******* begin filtering_lde "); + if factor == 1 { + return Ok(self.fft(&worker)); + } + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::new_for_size(new_size as u64)?; + + let mut lde = self.coeffs; + lde.resize(new_size as usize, F::zero()); + best_lde(&mut lde, worker, &domain.generator, domain.power_of_two as u32, factor); + info!("******* end filtering_lde "); + Polynomial::from_values(lde) + } + + pub fn lde_using_multiple_cosets_naive(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + info!("******* begin lde_using_multiple_cosets_naive "); + if factor == 1 { + return Ok(self.fft(&worker)); + } + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::new_for_size(new_size as u64)?; + + let mut results = vec![]; + + let mut coset_generator = F::one(); + + let one = F::one(); + + for _ in 0..factor { + let coeffs = self.clone(); + let lde = if coset_generator == one { + coeffs.fft(&worker) + } else { + coeffs.coset_fft_for_generator(&worker, coset_generator) + }; + + results.push(lde.into_coeffs()); + coset_generator.mul_assign(&domain.generator); + } + + let mut final_values = vec![F::zero(); new_size]; + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + info!("******* end lde_using_multiple_cosets_naive "); + Polynomial::from_values(final_values) + } + + pub fn lde_using_multiple_cosets(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + info!("******* begin lde_using_multiple_cosets "); + + if factor == 1 { + return Ok(self.fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let threads_per_coset = factor / num_cpus; + // TODO: it's not immediately clean if having more threads than (virtual) cores benefits + // over underutilization of some (virtual) cores + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + let mut results = vec![self.coeffs; factor]; + + let coset_omega = domain.generator; + let this_domain_omega = self.omega; + + let log_n = self.exp; + + worker.scope(results.len(), |scope, chunk| { + for (i, r) in results.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut coset_generator = coset_omega.pow(&[i as u64]); + for r in r.iter_mut() { + if coset_generator != F::one() { + distribute_powers_serial(&mut r[..], coset_generator); + // distribute_powers(&mut r[..], &worker, coset_generator); + } + best_fft_bn256_gpu(&mut r[..], &worker, &this_domain_omega, log_n, num_cpus_hint); + coset_generator.mul_assign(&coset_omega); + } + }); + } + }); + + let mut final_values = vec![F::zero(); new_size]; + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + info!("******* end lde_using_multiple_cosets "); + Polynomial::from_values(final_values) + } + + pub fn lde_using_multiple_cosets_with_precomputation>( + self, + worker: &Worker, + factor: usize, + precomputed_omegas: &P + ) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + debug_assert_eq!(self.size(), precomputed_omegas.domain_size()); + info!("******* begin lde_using_multiple_cosets_with_precomputation "); + if factor == 1 { + return Ok(self.fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let threads_per_coset = factor / num_cpus; + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + let mut results = vec![self.coeffs; factor]; + + let coset_omega = domain.generator; + let this_domain_omega = self.omega; + + let log_n = self.exp; + + worker.scope(results.len(), |scope, chunk| { + for (i, r) in results.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut coset_generator = coset_omega.pow(&[i as u64]); + for r in r.iter_mut() { + distribute_powers(&mut r[..], &worker, coset_generator); + with_precomputation::fft::best_fft(&mut r[..], &worker, &this_domain_omega, log_n, num_cpus_hint, precomputed_omegas); + coset_generator.mul_assign(&coset_omega); + } + }); + } + }); + + let mut final_values = vec![F::zero(); new_size]; + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + info!("******* end lde_using_multiple_cosets_with_precomputation "); + Polynomial::from_values(final_values) + } + + pub fn lde_using_bitreversed_ntt>( + self, + worker: &Worker, + factor: usize, + precomputed_omegas: &P + ) -> Result, SynthesisError> { + use std::time::Instant; + debug_assert!(self.coeffs.len().is_power_of_two()); + debug_assert_eq!(self.size(), precomputed_omegas.domain_size()); + info!("******* begin lde_using_bitreversed_ntt "); + if factor == 1 { + return Ok(self.fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let threads_per_coset = factor / num_cpus; + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let current_size = self.coeffs.len(); + let new_size = current_size * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + let mut results = vec![self.coeffs; factor]; + + let coset_omega = domain.generator; + + let log_n_u32 = self.exp; + let log_n = log_n_u32 as usize; + + // for r in results.iter_mut().skip(1) { + // let mut coset_generator = coset_omega; + // distribute_powers(&mut r[..], &worker, coset_generator); + // coset_generator.mul_assign(&coset_omega); + // } + + worker.scope(results.len(), |scope, chunk| { + for (i, r) in results.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut coset_generator = coset_omega.pow(&[i as u64]); + let mut gen_power = i; + for r in r.iter_mut() { + if gen_power != 0 { + distribute_powers_serial(&mut r[..], coset_generator); + } + // distribute_powers(&mut r[..], &worker, coset_generator); + cooley_tukey_ntt::best_ct_ntt(&mut r[..], &worker, log_n_u32, num_cpus_hint, precomputed_omegas); + + coset_generator.mul_assign(&coset_omega); + gen_power += 1; + } + }); + } + }); + + // let mut final_values = vec![F::zero(); new_size]; + + let mut final_values = Vec::with_capacity(new_size); + unsafe {final_values.set_len(new_size)}; + + // copy here is more complicated: to have the value in a natural order + // one has to use coset_idx to address the result element + // and use bit-reversed lookup for an element index + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + let element_idx = cooley_tukey_ntt::bitreverse(element_idx, log_n); + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + + // let res_ptr = &mut final_values[..] as *mut [F]; + + // let factor_log_n = crate::plonk::commitments::transparent::utils::log2_floor(factor); + + // worker.scope(results.len(), |scope, chunk| { + // for (chunk_idx, r) in results.chunks(chunk).enumerate() { + // let res = unsafe {&mut *res_ptr}; + // scope.spawn(move |_| { + // // elements from the coset i should be on the places + // // of sequence i, i + lde_factor, i + 2*lde_factor, ... + // let mut coset_idx = chunk_idx * chunk; + // for r in r.iter() { + // for (element_idx, el) in r.iter().enumerate() { + // let write_to = (cooley_tukey_ntt::bitreverse(element_idx, log_n) << factor_log_n) | coset_idx; + // res[write_to] = *el; + // } + + // coset_idx += 1; + // } + // }); + // } + // }); + info!("******* end lde_using_bitreversed_ntt "); + Polynomial::from_values(final_values) + } + + + // pub fn lde_using_bitreversed_ntt_no_allocations_lowest_bits_reversed>( + // self, + // worker: &Worker, + // factor: usize, + // precomputed_omegas: &P + // ) -> Result, SynthesisError> { + // debug_assert!(self.coeffs.len().is_power_of_two()); + // debug_assert_eq!(self.size(), precomputed_omegas.domain_size()); + + // if factor == 1 { + // return Ok(self.fft(&worker)); + // } + + // let num_cpus = worker.cpus; + // let num_cpus_hint = if num_cpus <= factor { + // Some(1) + // } else { + // let threads_per_coset = factor / num_cpus; + // // let mut threads_per_coset = factor / num_cpus; + // // if factor % num_cpus != 0 { + // // if (threads_per_coset + 1).is_power_of_two() { + // // threads_per_coset += 1; + // // } + // // } + // Some(threads_per_coset) + // }; + + // assert!(factor.is_power_of_two()); + // let current_size = self.coeffs.len(); + // let new_size = self.coeffs.len() * factor; + // let domain = Domain::::new_for_size(new_size as u64)?; + + // // let mut results = vec![self.coeffs.clone(); factor]; + + // let mut result = Vec::with_capacity(new_size); + // unsafe { result.set_len(new_size)}; + + // let r = &mut result[..] as *mut [F]; + + // let coset_omega = domain.generator; + + // let log_n = self.exp; + + // let range: Vec = (0..factor).collect(); + + // let self_coeffs_ref = &self.coeffs; + + // // copy + + // worker.scope(range.len(), |scope, chunk| { + // for coset_idx in range.chunks(chunk) { + // let r = unsafe {&mut *r}; + // scope.spawn(move |_| { + // for coset_idx in coset_idx.iter() { + // let start = current_size * coset_idx; + // let end = start + current_size; + // let copy_start_pointer: *mut F = r[start..end].as_mut_ptr(); + + // unsafe { std::ptr::copy_nonoverlapping(self_coeffs_ref.as_ptr(), copy_start_pointer, current_size) }; + // } + // }); + // } + // }); + + // // let mut coset_generator = F::one(); + // // for _ in 0..factor { + // // result.extend_from_slice(&self.coeffs); + // // // if coset_idx != 0 { + // // // let start = coset_idx * current_size; + // // // let end = start + current_size; + // // // distribute_powers(&mut result[start..end], &worker, coset_generator); + // // // // cooley_tukey_ntt::best_ct_ntt(&mut result[start..end], &worker, log_n, Some(log_num_cpus as usize), precomputed_omegas); + // // // } + // // // coset_generator.mul_assign(&coset_omega); + // // } + // // println!("Copying taken {:?}", start.elapsed()); + + + + // // for coset_idx in 0..factor { + // // result.extend_from_slice(&self.coeffs); + // // if coset_idx != 0 { + // // let start = coset_idx * current_size; + // // let end = start + current_size; + // // distribute_powers(&mut result[start..end], &worker, coset_generator); + // // } + // // coset_generator.mul_assign(&coset_omega); + // // } + + // // for r in results.iter_mut().skip(1) { + // // let mut coset_generator = coset_omega; + // // distribute_powers(&mut r[..], &worker, coset_generator); + // // coset_generator.mul_assign(&coset_omega); + // // } + + // // let start = Instant::now(); + + // let to_spawn = worker.cpus; + + // let chunk = Worker::chunk_size_for_num_spawned_threads(factor, to_spawn); + + // worker.scope(0, |scope, _| { + // for thread_id in 0..to_spawn { + // let r = unsafe {&mut *r}; + // scope.spawn(move |_| { + // let start = thread_id * chunk; + // let end = if start + chunk <= factor { + // start + chunk + // } else { + // factor + // }; + // let mut gen_power = start; + // let mut coset_generator = coset_omega.pow(&[start as u64]); + // for i in start..end { + // let from = current_size * i; + // let to = from + current_size; + // if gen_power != 0 { + // distribute_powers_serial(&mut r[from..to], coset_generator); + // } + // cooley_tukey_ntt::best_ct_ntt(&mut r[from..to], &worker, log_n, num_cpus_hint, precomputed_omegas); + // coset_generator.mul_assign(&coset_omega); + // gen_power += 1; + // } + // }); + // } + // }); + + // // println!("NTT taken {:?}", start.elapsed()); + + // // let start = Instant::now(); + + // // let mut final_values = vec![F::zero(); new_size]; + + // // println!("Allocation of result taken {:?}", start.elapsed()); + + // // let results_ref = &results; + + // // copy here is more complicated: to have the value in a natural order + // // one has to use coset_idx to address the result element + // // and use bit-reversed lookup for an element index + + // // let log_n = log_n as usize; + + // // let start = Instant::now(); + + // // let total_len = result.len(); + + // // let chunk = Worker::chunk_size_for_num_spawned_threads(total_len, to_spawn); + + // // let lower_bits_mask = (1 << log_n) - 1; + + // // let higher_bits_mask = !lower_bits_mask; + + + // // worker.scope(0, |scope, _| { + // // for thread_id in 0..to_spawn { + // // let r = unsafe {&mut *r}; + // // scope.spawn(move |_| { + // // let start = thread_id * chunk; + // // let end = if start + chunk <= total_len { + // // start + chunk + // // } else { + // // total_len + // // }; + // // for j in start..end { + // // let element_idx = j & lower_bits_mask; + // // let coset_mask = j & higher_bits_mask; + // // let rj = cooley_tukey_ntt::bitreverse(element_idx, log_n) | coset_mask; + // // if j < rj { + // // r.swap(j, rj); + // // } + // // } + // // }); + // // } + // // }); + + // // println!("Final copying taken {:?}", start.elapsed()); + + // Polynomial::from_values(result) + // } + + pub fn coset_filtering_lde(mut self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + info!("******* begin coset_filtering_lde "); + if factor == 1 { + return Ok(self.coset_fft(&worker)); + } + assert!(factor.is_power_of_two()); + self.distribute_powers(worker, F::multiplicative_generator()); + + let new_size = self.coeffs.len() * factor; + let domain = Domain::new_for_size(new_size as u64)?; + + let mut lde = self.coeffs; + lde.resize(new_size as usize, F::zero()); + best_lde(&mut lde, worker, &domain.generator, domain.power_of_two as u32, factor); + info!("******* end coset_filtering_lde "); + Polynomial::from_values(lde) + } + + pub fn coset_lde_using_multiple_cosets_naive(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + info!("******* begin coset_lde_using_multiple_cosets_naive "); + if factor == 1 { + return Ok(self.coset_fft(&worker)); + } + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::new_for_size(new_size as u64)?; + + let mut results = vec![]; + + let mut coset_generator = F::multiplicative_generator(); + + for _ in 0..factor { + let coeffs = self.clone(); + let lde = coeffs.coset_fft_for_generator(&worker, coset_generator); + + results.push(lde.into_coeffs()); + coset_generator.mul_assign(&domain.generator); + } + + let mut final_values = vec![F::zero(); new_size]; + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + info!("******* end coset_lde_using_multiple_cosets_naive "); + + Polynomial::from_values(final_values) + } + + pub fn coset_lde_using_multiple_cosets(self, worker: &Worker, factor: usize) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + + if factor == 1 { + return Ok(self.coset_fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let threads_per_coset = factor / num_cpus; + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let new_size = self.coeffs.len() * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + let mut results = vec![self.coeffs; factor]; + + let coset_omega = domain.generator; + let this_domain_omega = self.omega; + + let log_n = self.exp; + + worker.scope(results.len(), |scope, chunk| { + for (i, r) in results.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut coset_generator = coset_omega.pow(&[i as u64]); + coset_generator.mul_assign(&F::multiplicative_generator()); + for r in r.iter_mut() { + distribute_powers_serial(&mut r[..], coset_generator); + // distribute_powers(&mut r[..], &worker, coset_generator); + best_fft_bn256_gpu(&mut r[..], &worker, &this_domain_omega, log_n, num_cpus_hint); + coset_generator.mul_assign(&coset_omega); + } + }); + } + }); + + let mut final_values = vec![F::zero(); new_size]; + + let results_ref = &results; + + worker.scope(final_values.len(), |scope, chunk| { + for (i, v) in final_values.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut idx = i*chunk; + for v in v.iter_mut() { + let coset_idx = idx % factor; + let element_idx = idx / factor; + *v = results_ref[coset_idx][element_idx]; + + idx += 1; + } + }); + } + }); + + Polynomial::from_values(final_values) + } + + pub fn fft(mut self, worker: &Worker) -> Polynomial + { + info!("******* begin fft in polynomials"); + debug_assert!(self.coeffs.len().is_power_of_two()); + best_fft_bn256_gpu(&mut self.coeffs, worker, &self.omega, self.exp, None); + info!("******* end fft in polynomials"); + + Polynomial:: { + coeffs: self.coeffs, + exp: self.exp, + omega: self.omega, + omegainv: self.omegainv, + geninv: self.geninv, + minv: self.minv, + _marker: std::marker::PhantomData + } + } + + pub fn coset_fft(mut self, worker: &Worker) -> Polynomial + { + info!("**** begin coset_fft"); + debug_assert!(self.coeffs.len().is_power_of_two()); + self.distribute_powers(worker, F::multiplicative_generator()); + self.fft(worker) + } + + pub fn coset_fft_for_generator(mut self, worker: &Worker, gen: F) -> Polynomial + { + info!("**** begin coset_fft_for_generator"); + debug_assert!(self.coeffs.len().is_power_of_two()); + self.distribute_powers(worker, gen); + self.fft(worker) + } + + pub fn add_assign(&mut self, worker: &Worker, other: &Polynomial) { + assert!(self.coeffs.len() >= other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + a.add_assign(&b); + } + }); + } + }); + } + + pub fn add_assign_scaled(&mut self, worker: &Worker, other: &Polynomial, scaling: &F) { + assert!(self.coeffs.len() >= other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + let mut tmp = *b; + tmp.mul_assign(&scaling); + a.add_assign(&tmp); + } + }); + } + }); + } + + /// Perform O(n) subtraction of one polynomial from another in the domain. + pub fn sub_assign(&mut self, worker: &Worker, other: &Polynomial) { + assert!(self.coeffs.len() >= other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + a.sub_assign(&b); + } + }); + } + }); + } + + pub fn sub_assign_scaled(&mut self, worker: &Worker, other: &Polynomial, scaling: &F) { + assert!(self.coeffs.len() >= other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + let mut tmp = *b; + tmp.mul_assign(&scaling); + a.sub_assign(&tmp); + } + }); + } + }); + } + + pub fn evaluate_at(&self, worker: &Worker, g: F) -> F { + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + let mut subvalues = vec![F::zero(); num_threads]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for (i, (a, s)) in self.coeffs.chunks(chunk) + .zip(subvalues.chunks_mut(1)) + .enumerate() { + scope.spawn(move |_| { + let mut x = g.pow([(i*chunk) as u64]); + for a in a.iter() { + let mut value = x; + value.mul_assign(&a); + s[0].add_assign(&value); + x.mul_assign(&g); + } + }); + } + }); + + let mut result = F::zero(); + for v in subvalues.iter() { + result.add_assign(&v); + } + + result + } +} + + +impl Polynomial { + pub fn new_for_size(size: usize) -> Result, SynthesisError> { + let coeffs = vec![F::zero(); size]; + + Self::from_values(coeffs) + } + + pub fn from_values(mut values: Vec) -> Result, SynthesisError> + { + let coeffs_len = values.len(); + + let domain = Domain::new_for_size(coeffs_len as u64)?; + let exp = domain.power_of_two as u32; + let m = domain.size as usize; + let omega = domain.generator; + + values.resize(m, F::zero()); + + Ok(Polynomial:: { + coeffs: values, + exp: exp, + omega: omega, + omegainv: omega.inverse().unwrap(), + geninv: F::multiplicative_generator().inverse().unwrap(), + minv: F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(), + _marker: std::marker::PhantomData + }) + } + + pub fn from_values_unpadded(values: Vec) -> Result, SynthesisError> + { + let coeffs_len = values.len(); + + let domain = Domain::new_for_size(coeffs_len as u64)?; + let exp = domain.power_of_two as u32; + let m = domain.size as usize; + let omega = domain.generator; + + Ok(Polynomial:: { + coeffs: values, + exp: exp, + omega: omega, + omegainv: omega.inverse().unwrap(), + geninv: F::multiplicative_generator().inverse().unwrap(), + minv: F::from_str(&format!("{}", m)).unwrap().inverse().unwrap(), + _marker: std::marker::PhantomData + }) + } + + // this function should only be used on the values that are bitreverse enumerated + pub fn clone_subset_assuming_bitreversed( + &self, + subset_factor: usize, + ) -> Result, SynthesisError> { + if subset_factor == 1 { + return Ok(self.clone()); + } + + assert!(subset_factor.is_power_of_two()); + + let current_size = self.coeffs.len(); + let new_size = current_size / subset_factor; + + let mut result = Vec::with_capacity(new_size); + unsafe { result.set_len(new_size)}; + + // copy elements. If factor is 2 then non-reversed we would output only elements that are == 0 mod 2 + // If factor is 2 and we are bit-reversed - we need to only output first half of the coefficients + // If factor is 4 then we need to output only the first 4th part + // if factor is 8 - only the first 8th part + + let start = 0; + let end = new_size; + + result.copy_from_slice(&self.coeffs[start..end]); + + // unsafe { result.set_len(new_size)}; + // let copy_to_start_pointer: *mut F = result[..].as_mut_ptr(); + // let copy_from_start_pointer: *const F = self.coeffs[start..end].as_ptr(); + + // unsafe { std::ptr::copy_nonoverlapping(copy_from_start_pointer, copy_to_start_pointer, new_size) }; + + Polynomial::from_values(result) + } + + pub fn pow(&mut self, worker: &Worker, exp: u64) + { + if exp == 2 { + return self.square(&worker); + } + worker.scope(self.coeffs.len(), |scope, chunk| { + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + *v = v.pow([exp]); + } + }); + } + }); + } + + pub fn square(&mut self, worker: &Worker) + { + worker.scope(self.coeffs.len(), |scope, chunk| { + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + v.square(); + } + }); + } + }); + } + + pub fn ifft(mut self, worker: &Worker) -> Polynomial + { + info!("***** begin ifft in polynomials."); + debug_assert!(self.coeffs.len().is_power_of_two()); + best_fft_bn256_gpu(&mut self.coeffs, worker, &self.omegainv, self.exp, None); + + worker.scope(self.coeffs.len(), |scope, chunk| { + let minv = self.minv; + + for v in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v { + v.mul_assign(&minv); + } + }); + } + }); + + info!("***** end ifft in polynomials."); + + Polynomial:: { + coeffs: self.coeffs, + exp: self.exp, + omega: self.omega, + omegainv: self.omegainv, + geninv: self.geninv, + minv: self.minv, + _marker: std::marker::PhantomData + } + } + + pub fn icoset_fft(self, worker: &Worker) -> Polynomial + { + info!("**** begin icoset_fft"); + debug_assert!(self.coeffs.len().is_power_of_two()); + let geninv = self.geninv; + let mut res = self.ifft(worker); + res.distribute_powers(worker, geninv); + info!("**** end icoset_fft"); + res + } + + pub fn icoset_fft_for_generator(self, worker: &Worker, coset_generator: &F) -> Polynomial + { + + info!("**** begin icoset_fft_for_generator"); + debug_assert!(self.coeffs.len().is_power_of_two()); + let geninv = coset_generator.inverse().expect("must exist"); + let mut res = self.ifft(worker); + res.distribute_powers(worker, geninv); + info!("**** end icoset_fft_for_generator"); + res + } + + + pub fn add_assign(&mut self, worker: &Worker, other: &Polynomial) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + + worker.scope(self.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + a.add_assign(&b); + } + }); + } + }); + } + + pub fn add_constant(&mut self, worker: &Worker, constant: &F) { + worker.scope(self.coeffs.len(), |scope, chunk| { + for a in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for a in a.iter_mut() { + a.add_assign(&constant); + } + }); + } + }); + } + + pub fn sub_constant(&mut self, worker: &Worker, constant: &F) { + worker.scope(self.coeffs.len(), |scope, chunk| { + for a in self.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for a in a.iter_mut() { + a.sub_assign(&constant); + } + }); + } + }); + } + + pub fn rotate(mut self, by: usize) -> Result, SynthesisError>{ + let mut values: Vec<_> = self.coeffs.drain(by..).collect(); + + for c in self.coeffs.into_iter() { + values.push(c); + } + + Polynomial::from_values(values) + } + + pub fn barycentric_evaluate_at(&self, worker: &Worker, g: F) -> Result { + // use a barycentric formula + + // L_i(X) = (omega^i / N) / (X - omega^i) * (X^N - 1) + // we'll have to pay more for batch inversion at some point, but + // it's still useful + let domain_size = self.size() as u64; + assert!(domain_size.is_power_of_two()); + + let mut vanishing_at_g = g.pow(&[domain_size]); + vanishing_at_g.sub_assign(&F::one()); + + // now generate (X - omega^i) + let mut tmp = vec![g; domain_size as usize]; + + let generator = self.omega; + + // constant factor = 1 / ( (1 / N) * (X^N - 1) ) = N / (X^N - 1) + + worker.scope(tmp.len(), |scope, chunk| { + for (i, vals) in tmp.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + // let mut one_over_omega_pow = generator_inv.pow([(i*chunk) as u64]); + // one_over_omega_pow.mul_assign(&constant_factor); + let mut omega_power = generator.pow([(i*chunk) as u64]); + for val in vals.iter_mut() { + val.sub_assign(&omega_power); // (X - omega^i) + // val.mul_assign(&one_over_omega_pow); // (X - omega^i) * N / (X^N - 1) * omega^(-i), so when we inverse it's valid evaluation + omega_power.mul_assign(&generator); + // one_over_omega_pow.mul_assign(&generator_inv); + } + }); + } + }); + + let mut values = Polynomial::from_values(tmp)?; + values.batch_inversion(&worker)?; + + // now multiply by omega^i / N * (X^N - 1) and value for L_i(X) + + let mut constant_factor = vanishing_at_g; + constant_factor.mul_assign(&self.minv); + + worker.scope(values.size(), |scope, chunk| { + for (i, (vals, coeffs)) in values.as_mut().chunks_mut(chunk) + .zip(self.coeffs.chunks(chunk)) + .enumerate() { + scope.spawn(move |_| { + let mut omega_power = generator.pow([(i*chunk) as u64]); + omega_power.mul_assign(&constant_factor); + for (val, coeff) in vals.iter_mut().zip(coeffs.iter()) { + val.mul_assign(&omega_power); + val.mul_assign(coeff); + omega_power.mul_assign(&generator); + } + }); + } + }); + + values.calculate_sum(&worker) + } + + pub fn barycentric_over_coset_evaluate_at(&self, worker: &Worker, x: F, coset_factor: &F) -> Result { + // use a barycentric formula + // L_i(x) = \prod_{i != j} (X - x_j) / \prod_{i != j} (x_i - x_j) + // that for a case when x_j = g*omega^j is simplified + + // \prod_{i != j} (X - x_j) = (X^N - g^N) / (X - g * omega^i) + + // \prod_{i != j} (x_i - x_j) = g * (omega)^i / N + + // L_i(X) = (g*(omega)^i / N) / (X - g*(omega)^i) * (X^N - g^N) + // we'll have to pay more for batch inversion at some point, but + // it's still useful + let domain_size = self.size() as u64; + assert!(domain_size.is_power_of_two()); + + // let normalization_factor = ..pow(&[domain_size]); + + let offset = coset_factor.pow(&[domain_size]); + + let normalization_factor = offset.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut vanishing_at_x = x.pow(&[domain_size]); + vanishing_at_x.sub_assign(&offset); + + // now generate (X - g*omega^i) + let mut tmp = vec![x; domain_size as usize]; + + let generator = self.omega; + + // constant factor = 1 / ( (1 / N) * (X^N - g^N) ) = N / (X^N - g^N) + + worker.scope(tmp.len(), |scope, chunk| { + for (i, vals) in tmp.chunks_mut(chunk) + .enumerate() { + scope.spawn(move |_| { + let mut omega_power = generator.pow([(i*chunk) as u64]); + omega_power.mul_assign(&coset_factor); + for val in vals.iter_mut() { + val.sub_assign(&omega_power); // (X - omega^i) + omega_power.mul_assign(&generator); + } + }); + } + }); + + let mut values = Polynomial::from_values(tmp)?; + values.batch_inversion(&worker)?; + + // now multiply by g*omega^i / N * (X^N - g^N) and value for L_i(X) + + let mut constant_factor = vanishing_at_x; + constant_factor.mul_assign(&self.minv); + constant_factor.mul_assign(&coset_factor); + constant_factor.mul_assign(&normalization_factor); + + worker.scope(values.size(), |scope, chunk| { + for (i, (vals, coeffs)) in values.as_mut().chunks_mut(chunk) + .zip(self.coeffs.chunks(chunk)) + .enumerate() { + scope.spawn(move |_| { + let mut omega_power = generator.pow([(i*chunk) as u64]); + omega_power.mul_assign(&constant_factor); + for (val, coeff) in vals.iter_mut().zip(coeffs.iter()) { + val.mul_assign(&omega_power); + val.mul_assign(coeff); + omega_power.mul_assign(&generator); + } + }); + } + }); + + values.calculate_sum(&worker) + } + + // pub fn split_into_even_and_odd_assuming_natural_ordering( + // self, + // worker: &Worker, + // ) -> Result<(Polynomial::, Polynomial::), SynthesisError> { + // // Classical trick: f(x) = f_even(X^2) + x * f_odd(X^2) + // assert!(self.coeffs.len().is_power_of_two()); + // assert!(self.coeffs.len() > 1); + + // let result_len = self.coeffs.len() / 2; + + // let mut coeffs = self.coeffs; + + // let mut second: Vec<_> = coeffs.drain(result_len..(2*result_len)).collect(); + // let mut first = coeffs; + + // // f_even(X^2) = (f(x) + f(-x))/ 2 + // // f_odd(X^2) = (f(x) - f(-x))/ 2x + + // worker.scope(first.len(), |scope, chunk| { + // for (i, (first, second)) in first.chunks_mut(chunk) + // .zip(second.chunks_mut(chunk)) + // .enumerate() { + // scope.spawn(move |_| { + // let mut divisor = generator_inv.pow([(i*chunk) as u64]); + // divisor.mul_assign(&constant_factor); + // for (f, s) in first.iter_mut().zip(second.iter_mut()) { + // let f_at_x = *f; + // let f_at_minus_x = *s; + + // let mut even = f_at_x; + // even.add_assign(&f_at_minus_x); + // even.mul_assign(&two_inv); + + // let mut odd = f_at_x; + // odd.sub_assign(&f_at_minus_x); + // odd.mul_assign(&divisor); + + // *f = even; + // *s = odd; + + // divisor.mul_assign(&generator_inv); + // } + // }); + // } + // }); + + // let even = Polynomial::from_values(first)?; + // let odd = Polynomial::from_values(second)?; + + // Ok((even, odd)) + // } + + pub fn split_into_even_and_odd_assuming_natural_ordering( + self, + worker: &Worker, + coset_offset: &F + ) -> Result<(Polynomial::, Polynomial::), SynthesisError> { + // Classical trick: f(x) = f_even(X^2) + x * f_odd(X^2) + + // f(g) = c_0 + c_1 * g + c_2 * g + c_3 * g + // f(-g) = c_0 - c_1 * g + c_2 * g - c_3 * g + // f_even(g) = c_0 + c_2 * g + ... + // f_odd(g) = c_1 * g + c_3 * g + ... + + // f(g*Omega) = c_0 + c_1 * g * Omega + c_2 * g * Omega^2 + c_3 * g * Omega^3 + // f(-g*Omega) = c_0 - c_1 * g * Omega + c_2 * g * Omega^2 - c_3 * g * Omega^3 + + // what should be + // f_even(g*Omega^2) = c_0 + c_2 * g*Omega^2 + ... + // f_odd(g*Omega^2/g) * g*Omega = c_1 * g * Omega + c_3 * g * Omega^3 + ... + + // (f(g*Omega) + f(-g*Omega))/2 = c_0 + c_2 * g*Omega^2 + ... - those are values of the even coefficient polynomial at X^2/g + // (f(g*Omega) - f(-g*Omega))/2 / (g * Omega) = c_1 + c_3 * Omega^2 + ... - those are values of the even coefficient polynomial at X^2/g^2 + + + // to make it homogenius (cause we don't care about particular coefficients) + // we make it as + // (f(g*Omega) + f(-g*Omega))/2 / g = c_0/g + c_2 * Omega^2 - values for some polynomial over (X^2 / g^2) + // (f(g*Omega) - f(-g*Omega))/2 / (g * Omega) = c_1 + c_3 * Omega^2 - values for some polynomial over (X^2 / g^2) + assert!(self.coeffs.len().is_power_of_two()); + assert!(self.coeffs.len() > 1); + + let result_len = self.coeffs.len() / 2; + + let mut coeffs = self.coeffs; + + let mut second: Vec<_> = coeffs.drain(result_len..(2*result_len)).collect(); + let mut first = coeffs; + + let generator_inv = self.omegainv; + + let mut two = F::one(); + two.double(); + + let coset_offset_inv = coset_offset.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let two_inv = two.inverse().ok_or(SynthesisError::DivisionByZero)?; + + let mut constant_factor = two_inv; + constant_factor.mul_assign(&coset_offset_inv); + + let divisor_even = two_inv; + // let divisor_even = constant_factor; + + // f_even(X^2) = (f(x) + f(-x))/ 2 + // f_odd(X^2) = (f(x) - f(-x))/ 2x + + worker.scope(first.len(), |scope, chunk| { + for (i, (first, second)) in first.chunks_mut(chunk) + .zip(second.chunks_mut(chunk)) + .enumerate() { + scope.spawn(move |_| { + let mut divisor_odd = generator_inv.pow([(i*chunk) as u64]); + divisor_odd.mul_assign(&constant_factor); + for (f, s) in first.iter_mut().zip(second.iter_mut()) { + let f_at_x = *f; + let f_at_minus_x = *s; + + let mut even = f_at_x; + even.add_assign(&f_at_minus_x); + even.mul_assign(&divisor_even); + + let mut odd = f_at_x; + odd.sub_assign(&f_at_minus_x); + odd.mul_assign(&divisor_odd); + + *f = even; + *s = odd; + + divisor_odd.mul_assign(&generator_inv); + } + }); + } + }); + + let even = Polynomial::from_values(first)?; + let odd = Polynomial::from_values(second)?; + + Ok((even, odd)) + } + + pub fn calculate_shifted_grand_product(&self, worker: &Worker) -> Result, SynthesisError> { + let mut result = vec![F::zero(); self.coeffs.len() + 1]; + result[0] = F::one(); + + // let not_shifted_product = self.calculate_grand_product(&worker)?; + // result[1..].copy_from_slice(¬_shifted_product.into_coeffs()[..]); + + // Polynomial::from_values_unpadded(result) + + let work_chunk = &mut result[1..]; + assert!(work_chunk.len() == self.coeffs.len()); + + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + let mut subproducts = vec![F::one(); num_threads as usize]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for ((g, c), s) in work_chunk.chunks_mut(chunk) + .zip(self.coeffs.chunks(chunk)) + .zip(subproducts.chunks_mut(1)) { + scope.spawn(move |_| { + for (g, c) in g.iter_mut() + .zip(c.iter()) { + s[0].mul_assign(&c); + *g = s[0]; + } + }); + } + }); + + // subproducts are [abc, def, xyz] + + // we do not need the last one + subproducts.pop().expect("has at least one value"); + + let mut tmp = F::one(); + for s in subproducts.iter_mut() { + tmp.mul_assign(&s); + *s = tmp; + } + + let chunk_len = worker.get_chunk_size(self.coeffs.len()); + + worker.scope(0, |scope, _| { + for (g, s) in work_chunk[chunk_len..].chunks_mut(chunk_len) + .zip(subproducts.chunks(1)) { + scope.spawn(move |_| { + for g in g.iter_mut() { + g.mul_assign(&s[0]); + } + }); + } + }); + + Polynomial::from_values(result) + } + + pub fn calculate_grand_product(&self, worker: &Worker) -> Result, SynthesisError> { + let mut result = vec![F::zero(); self.coeffs.len()]; + + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + let mut subproducts = vec![F::one(); num_threads as usize]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for ((g, c), s) in result.chunks_mut(chunk) + .zip(self.coeffs.chunks(chunk)) + .zip(subproducts.chunks_mut(1)) { + scope.spawn(move |_| { + for (g, c) in g.iter_mut() + .zip(c.iter()) { + s[0].mul_assign(&c); + *g = s[0]; + } + }); + } + }); + + // subproducts are [abc, def, xyz] + + // we do not need the last one + subproducts.pop().expect("has at least one value"); + + let mut tmp = F::one(); + for s in subproducts.iter_mut() { + tmp.mul_assign(&s); + *s = tmp; + } + + let chunk_len = worker.get_chunk_size(self.coeffs.len()); + + worker.scope(0, |scope, _| { + for (g, s) in result[chunk_len..].chunks_mut(chunk_len) + .zip(subproducts.chunks(1)) { + scope.spawn(move |_| { + let c = s[0]; + for g in g.iter_mut() { + g.mul_assign(&c); + } + }); + } + }); + + Polynomial::from_values_unpadded(result) + } + + pub fn calculate_grand_product_serial(&self) -> Result, SynthesisError> { + let mut result = Vec::with_capacity(self.coeffs.len()); + + let mut tmp = F::one(); + for c in self.coeffs.iter() { + tmp.mul_assign(&c); + result.push(tmp); + } + + Polynomial::from_values_unpadded(result) + } + + pub fn calculate_sum(&self, worker: &Worker) -> Result { + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + let mut subresults = vec![F::zero(); num_threads as usize]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for (c, s) in self.coeffs.chunks(chunk) + .zip(subresults.chunks_mut(1)) { + scope.spawn(move |_| { + for c in c.iter() { + s[0].add_assign(&c); + } + }); + } + }); + + let mut sum = F::zero(); + + for el in subresults.iter() { + sum.add_assign(&el); + } + + Ok(sum) + } + + pub fn calculate_grand_sum(&self, worker: &Worker) -> Result<(F, Polynomial), SynthesisError> { + // first value is zero, then first element, then first + second, ... + let mut result = vec![F::zero(); self.coeffs.len() + 1]; + + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + let mut subsums = vec![F::zero(); num_threads as usize]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for ((g, c), s) in result[1..].chunks_mut(chunk) + .zip(self.coeffs.chunks(chunk)) + .zip(subsums.chunks_mut(1)) { + scope.spawn(move |_| { + for (g, c) in g.iter_mut() + .zip(c.iter()) { + s[0].add_assign(&c); + *g = s[0]; + } + }); + } + }); + + // subsums are [a+b+c, d+e+f, x+y+z] + + let mut tmp = F::zero(); + for s in subsums.iter_mut() { + tmp.add_assign(&s); + *s = tmp; + } + + // sum over the full domain is the last element + let domain_sum = subsums.pop().expect("has at least one value"); + + let chunk_len = worker.get_chunk_size(self.coeffs.len()); + + worker.scope(0, |scope, _| { + for (g, s) in result[(chunk_len+1)..].chunks_mut(chunk_len) + .zip(subsums.chunks(1)) { + scope.spawn(move |_| { + let c = s[0]; + for g in g.iter_mut() { + g.add_assign(&c); + } + }); + } + }); + + // let result = result.drain(1..).collect(); + + let alt_total_sum = result.pop().expect("must pop the last element"); + + assert_eq!(alt_total_sum, domain_sum); + + Ok((domain_sum, Polynomial::from_values_unpadded(result)?)) + } + + pub fn add_assign_scaled(&mut self, worker: &Worker, other: &Polynomial, scaling: &F) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + let mut tmp = *b; + tmp.mul_assign(&scaling); + a.add_assign(&tmp); + } + }); + } + }); + } + + /// Perform O(n) subtraction of one polynomial from another in the domain. + pub fn sub_assign(&mut self, worker: &Worker, other: &Polynomial) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + + worker.scope(self.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + a.sub_assign(&b); + } + }); + } + }); + } + + pub fn sub_assign_scaled(&mut self, worker: &Worker, other: &Polynomial, scaling: &F) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + + worker.scope(other.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + let mut tmp = *b; + tmp.mul_assign(&scaling); + a.sub_assign(&tmp); + } + }); + } + }); + } + + /// Perform O(n) multiplication of two polynomials in the domain. + pub fn mul_assign(&mut self, worker: &Worker, other: &Polynomial) { + assert_eq!(self.coeffs.len(), other.coeffs.len()); + + worker.scope(self.coeffs.len(), |scope, chunk| { + for (a, b) in self.coeffs.chunks_mut(chunk).zip(other.coeffs.chunks(chunk)) { + scope.spawn(move |_| { + for (a, b) in a.iter_mut().zip(b.iter()) { + a.mul_assign(&b); + } + }); + } + }); + } + + pub fn batch_inversion(&mut self, worker: &Worker) -> Result<(), SynthesisError> { + let num_threads = worker.get_num_spawned_threads(self.coeffs.len()); + + let mut grand_products = vec![F::one(); self.coeffs.len()]; + let mut subproducts = vec![F::one(); num_threads as usize]; + + worker.scope(self.coeffs.len(), |scope, chunk| { + for ((a, g), s) in self.coeffs.chunks(chunk) + .zip(grand_products.chunks_mut(chunk)) + .zip(subproducts.chunks_mut(1)) { + scope.spawn(move |_| { + for (a, g) in a.iter().zip(g.iter_mut()) { + s[0].mul_assign(&a); + *g = s[0]; + } + }); + } + }); + + // now coeffs are [a, b, c, d, ..., z] + // grand_products are [a, ab, abc, d, de, def, ...., xyz] + // subproducts are [abc, def, xyz] + // not guaranteed to have equal length + + let mut full_grand_product = F::one(); + for sub in subproducts.iter() { + full_grand_product.mul_assign(sub); + } + + let product_inverse = full_grand_product.inverse().ok_or(SynthesisError::DivisionByZero)?; + + // now let's get [abc^-1, def^-1, ..., xyz^-1]; + let mut subinverses = vec![F::one(); num_threads]; + for (i, s) in subinverses.iter_mut().enumerate() { + let mut tmp = product_inverse; + for (j, p) in subproducts.iter().enumerate() { + if i == j { + continue; + } + tmp.mul_assign(&p); + } + + *s = tmp; + } + + worker.scope(self.coeffs.len(), |scope, chunk| { + for ((a, g), s) in self.coeffs.chunks_mut(chunk) + .zip(grand_products.chunks(chunk)) + .zip(subinverses.chunks_mut(1)) { + scope.spawn(move |_| { + for (a, g) in a.iter_mut().rev() + .zip(g.iter().rev().skip(1).chain(Some(F::one()).iter())) { + // s[0] = abc^-1 + // a = c + // g = ab + let tmp = *a; // c + *a = *g; + a.mul_assign(&s[0]); // a = ab*(abc^-1) = c^-1 + s[0].mul_assign(&tmp); // s[0] = (ab)^-1 + } + }); + } + }); + + Ok(()) + } + + pub fn pop_last(&mut self) -> Result { + let last = self.coeffs.pop().ok_or(SynthesisError::AssignmentMissing)?; + + Ok(last) + } + + pub fn clone_shifted_assuming_natural_ordering(&self, by: usize) -> Result { + let len = self.coeffs.len(); + assert!(by < len); + let mut new_coeffs = vec![F::zero(); self.coeffs.len()]; + new_coeffs[..(len - by)].copy_from_slice(&self.coeffs[by..]); + new_coeffs[(len-by)..].copy_from_slice(&self.coeffs[..by]); + + Self::from_values(new_coeffs) + } + + pub fn clone_shifted_assuming_bitreversed(&self, by: usize, worker: &Worker) -> Result { + let len = self.coeffs.len(); + assert!(by < len); + let mut extended_clone = Vec::with_capacity(len + by); + extended_clone.extend_from_slice(&self.coeffs); + let mut tmp = Self::from_values(extended_clone)?; + tmp.bitreverse_enumeration(&worker); + + let mut coeffs = tmp.into_coeffs(); + let tmp: Vec<_> = coeffs.drain(..by).collect(); + coeffs.extend(tmp); + + let mut tmp = Self::from_values(coeffs)?; + tmp.bitreverse_enumeration(&worker); + + Ok(tmp) + } +} + +impl Polynomial { + pub fn bitreversed_lde_using_bitreversed_ntt_with_partial_reduction>( + self, + worker: &Worker, + factor: usize, + precomputed_omegas: &P, + coset_factor: &F + ) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + debug_assert_eq!(self.size(), precomputed_omegas.domain_size()); + + if factor == 1 { + return Ok(self.fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let mut threads_per_coset = num_cpus / factor; + if threads_per_coset == 0 { + threads_per_coset = 1; + } else if num_cpus % factor != 0 { + threads_per_coset += 1; + } + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let current_size = self.coeffs.len(); + let new_size = self.coeffs.len() * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + // let mut results = vec![self.coeffs.clone(); factor]; + + let mut result = Vec::with_capacity(new_size); + unsafe { result.set_len(new_size)}; + + let r = &mut result[..] as *mut [F]; + + let coset_omega = domain.generator; + + let log_n = self.exp; + + let range: Vec = (0..factor).collect(); + + let self_coeffs_ref = &self.coeffs; + + // copy + + worker.scope(range.len(), |scope, chunk| { + for coset_idx in range.chunks(chunk) { + let r = unsafe {&mut *r}; + scope.spawn(move |_| { + for coset_idx in coset_idx.iter() { + let start = current_size * coset_idx; + let end = start + current_size; + let copy_start_pointer: *mut F = r[start..end].as_mut_ptr(); + + unsafe { std::ptr::copy_nonoverlapping(self_coeffs_ref.as_ptr(), copy_start_pointer, current_size) }; + } + }); + } + }); + + let to_spawn = factor; + let coset_size = current_size; + + use crate::plonk::commitments::transparent::utils::log2_floor; + + let factor_log = log2_floor(factor) as usize; + + // let chunk = Worker::chunk_size_for_num_spawned_threads(factor, to_spawn); + + // Each coset will produce values at specific indexes only, e.g + // coset factor of omega^0 = 1 will produce elements that are only at places == 0 mod 16 + // coset factor of omega^1 will produce elements that are only at places == 1 mod 16 + // etc. We expect the output to be bitreversed, so + // elements for coset factor of omega^0 = 1 will need to be placed first (00 top bits, bitreversed 00) + // elements for coset factor of omega^1 will need to be placed after the first half (10 top bits, bitreversed 01) + + worker.scope(0, |scope, _| { + for coset_idx in 0..to_spawn { + let r = unsafe {&mut *r}; + scope.spawn(move |_| { + let from = coset_size * coset_idx; + let to = from + coset_size; + let one = F::one(); + let bitreversed_power = cooley_tukey_ntt::bitreverse(coset_idx, factor_log); + let mut coset_generator = coset_omega.pow(&[bitreversed_power as u64]); + coset_generator.mul_assign(&coset_factor); + if coset_generator != one { + distribute_powers_with_num_cpus(&mut r[from..to], &worker, coset_generator, num_cpus_hint.expect("is some")); + } + partial_reduction::best_ct_ntt_partial_reduction(&mut r[from..to], &worker, log_n, num_cpus_hint, precomputed_omegas); + }); + } + }); + + Polynomial::from_values(result) + } +} + +impl Polynomial { + pub fn ifft_using_bitreversed_ntt_with_partial_reduction>( + self, + worker: &Worker, + precomputed_omegas: &P, + coset_generator: &F + ) -> Result, SynthesisError> { + info!("**** begin ifft_using_bitreversed_ntt_with_partial_reduction"); + + if self.coeffs.len() <= worker.cpus * 4 { + return Ok(self.ifft(&worker)); + } + + let mut coeffs: Vec<_> = self.coeffs; + let exp = self.exp; + cooley_tukey_ntt::partial_reduction::best_ct_ntt_partial_reduction(&mut coeffs, worker, exp, Some(worker.cpus), precomputed_omegas); + + let mut this = Polynomial::from_coeffs(coeffs)?; + + this.bitreverse_enumeration(&worker); + + let geninv = coset_generator.inverse().expect("must exist"); + + worker.scope(this.coeffs.len(), |scope, chunk| { + let minv = this.minv; + + for v in this.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v { + v.mul_assign(&minv); + } + }); + } + }); + + if geninv != F::one() { + this.distribute_powers(&worker, geninv); + } + + info!("**** end ifft_using_bitreversed_ntt_with_partial_reduction"); + + Ok(this) + } +} + +impl Polynomial { + /// taken in natural enumeration + /// outputs in natural enumeration + pub fn ifft_using_bitreversed_ntt>( + self, + worker: &Worker, + precomputed_omegas: &P, + coset_generator: &F + ) -> Result, SynthesisError> { + + info!("**** begin ifft_using_bitreversed_ntt"); + + if self.coeffs.len() <= worker.cpus * 4 { + info!("*** using ifft"); + return Ok(self.ifft(&worker)); + } + + let mut coeffs: Vec<_> = self.coeffs; + let mut coeffs_2 = coeffs.clone(); + let exp = self.exp; + + // cooley_tukey_ntt::best_ct_ntt(&mut coeffs, worker, exp, Some(worker.cpus), precomputed_omegas); + bit_rev_best_ct_ntt_2_best_fft_gpu(&mut coeffs, worker, exp, precomputed_omegas); + + let mut this = Polynomial::from_coeffs(coeffs)?; + + + this.bitreverse_enumeration(&worker); + + let geninv = coset_generator.inverse().expect("must exist"); + + worker.scope(this.coeffs.len(), |scope, chunk| { + let minv = this.minv; + + for v in this.coeffs.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v { + v.mul_assign(&minv); + } + }); + } + }); + + if geninv != F::one() { + this.distribute_powers(&worker, geninv); + } + + info!("**** end ifft_using_bitreversed_ntt"); + + Ok(this) + } +} + +impl Polynomial { + pub fn bitreversed_lde_using_bitreversed_ntt>( + self, + worker: &Worker, + factor: usize, + precomputed_omegas: &P, + coset_factor: &F + ) -> Result, SynthesisError> { + debug_assert!(self.coeffs.len().is_power_of_two()); + debug_assert_eq!(self.size(), precomputed_omegas.domain_size()); + info!("**** begin bitreversed_lde_using_bitreversed_ntt"); + if factor == 1 { + return Ok(self.fft(&worker)); + } + + let num_cpus = worker.cpus; + let num_cpus_hint = if num_cpus <= factor { + Some(1) + } else { + let mut threads_per_coset = num_cpus / factor; + if threads_per_coset == 0 { + threads_per_coset = 1; + } else if num_cpus % factor != 0 { + threads_per_coset += 1; + } + // let mut threads_per_coset = factor / num_cpus; + // if factor % num_cpus != 0 { + // if (threads_per_coset + 1).is_power_of_two() { + // threads_per_coset += 1; + // } + // } + Some(threads_per_coset) + }; + + assert!(factor.is_power_of_two()); + let current_size = self.coeffs.len(); + let new_size = self.coeffs.len() * factor; + let domain = Domain::::new_for_size(new_size as u64)?; + + // let mut results = vec![self.coeffs.clone(); factor]; + + let mut result = Vec::with_capacity(new_size); + unsafe { result.set_len(new_size)}; + + let r = &mut result[..] as *mut [F]; + + let coset_omega = domain.generator; + + let log_n = self.exp; + + let range: Vec = (0..factor).collect(); + + let self_coeffs_ref = &self.coeffs; + + // copy + + worker.scope(range.len(), |scope, chunk| { + for coset_idx in range.chunks(chunk) { + let r = unsafe {&mut *r}; + scope.spawn(move |_| { + for coset_idx in coset_idx.iter() { + let start = current_size * coset_idx; + let end = start + current_size; + let copy_start_pointer: *mut F = r[start..end].as_mut_ptr(); + + unsafe { std::ptr::copy_nonoverlapping(self_coeffs_ref.as_ptr(), copy_start_pointer, current_size) }; + } + }); + } + }); + + let to_spawn = factor; + let coset_size = current_size; + + use crate::plonk::commitments::transparent::utils::log2_floor; + + let factor_log = log2_floor(factor) as usize; + + // let chunk = Worker::chunk_size_for_num_spawned_threads(factor, to_spawn); + + // Each coset will produce values at specific indexes only, e.g + // coset factor of omega^0 = 1 will produce elements that are only at places == 0 mod 16 + // coset factor of omega^1 will produce elements that are only at places == 1 mod 16 + // etc. We expect the output to be bitreversed, so + // elements for coset factor of omega^0 = 1 will need to be placed first (00 top bits, bitreversed 00) + // elements for coset factor of omega^1 will need to be placed after the first half (10 top bits, bitreversed 01) + + let poly_size = self.size(); + worker.scope(0, |scope, _| { + for coset_idx in 0..to_spawn { + let r = unsafe {&mut *r}; + scope.spawn(move |_| { + let from = coset_size * coset_idx; + let to = from + coset_size; + let one = F::one(); + let bitreversed_power = cooley_tukey_ntt::bitreverse(coset_idx, factor_log); + let mut coset_generator = coset_omega.pow(&[bitreversed_power as u64]); + coset_generator.mul_assign(&coset_factor); + if coset_generator != one { + distribute_powers_with_num_cpus(&mut r[from..to], &worker, coset_generator, num_cpus_hint.expect("is some")); + } + // cooley_tukey_ntt::best_ct_ntt(&mut r[from..to], &worker, log_n, num_cpus_hint, precomputed_omegas); + bit_rev_best_ct_ntt_2_best_fft_gpu(&mut r[from..to], &worker, log_n,precomputed_omegas); + }); + } + }); + + info!("**** end bitreversed_lde_using_bitreversed_ntt"); + + Polynomial::from_values(result) + } + + /// taken in natural enumeration + /// outputs in natural enumeration + pub fn fft_using_bitreversed_ntt>( + self, + worker: &Worker, + precomputed_omegas: &P, + coset_generator: &F + ) -> Result, SynthesisError> { + + info!("**** begin fft_using_bitreversed_ntt"); + + if self.coeffs.len() <= worker.cpus * 4 { + return Ok(self.coset_fft_for_generator(&worker, *coset_generator)); + } + + let mut this = self; + if coset_generator != &F::one() { + this.distribute_powers(&worker, *coset_generator); + } + + let mut coeffs: Vec<_> = this.coeffs; + let exp = this.exp; + // cooley_tukey_ntt::best_ct_ntt(&mut coeffs, worker, exp, Some(worker.cpus), precomputed_omegas); + bit_rev_best_ct_ntt_2_best_fft_gpu(&mut coeffs, &worker, exp, precomputed_omegas); + + let mut this = Polynomial::from_values(coeffs)?; + + this.bitreverse_enumeration(&worker); + + info!("**** end fft_using_bitreversed_ntt"); + + Ok(this) + } + + /// taken in natural enumeration + /// outputs in natural enumeration + pub fn fft_using_bitreversed_ntt_output_bitreversed>( + self, + worker: &Worker, + precomputed_omegas: &P, + coset_generator: &F + ) -> Result, SynthesisError> { + info!("**** begin fft_using_bitreversed_ntt_output_bitreversed"); + + if self.coeffs.len() <= worker.cpus * 4 { + return Ok(self.coset_fft_for_generator(&worker, *coset_generator)); + } + + let mut this = self; + if coset_generator != &F::one() { + this.distribute_powers(&worker, *coset_generator); + } + + let mut coeffs: Vec<_> = this.coeffs; + let exp = this.exp; + cooley_tukey_ntt::best_ct_ntt(&mut coeffs, worker, exp, Some(worker.cpus), precomputed_omegas); + let this = Polynomial::from_values(coeffs)?; + info!("**** end fft_using_bitreversed_ntt_output_bitreversed"); + Ok(this) + } +} + +#[cfg(test)] +mod test { + + #[test] + fn test_shifted_grand_product() { + use crate::pairing::bn256::Fr; + use crate::ff::{Field, PrimeField}; + use super::*; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::worker::Worker; + + let samples: usize = 1 << 20; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..samples).map(|_| Fr::rand(rng)).collect::>(); + + let mut manual = vec![]; + manual.push(Fr::one()); + + let mut tmp = Fr::one(); + + for v in v.iter() { + tmp.mul_assign(&v); + manual.push(tmp); + } + + let as_poly = Polynomial::from_values(v).unwrap(); + let worker = Worker::new(); + let as_poly = as_poly.calculate_shifted_grand_product(&worker).unwrap(); + let as_poly = as_poly.into_coeffs(); + for idx in 0..manual.len() { + assert_eq!(manual[idx], as_poly[idx], "failed at idx = {}", idx); + } + } + + #[test] + fn test_grand_product() { + use crate::pairing::bn256::Fr; + use crate::ff::{Field, PrimeField}; + use super::*; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::worker::Worker; + + let samples: usize = 1 << 20; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..samples).map(|_| Fr::rand(rng)).collect::>(); + + let mut manual = vec![]; + + let mut tmp = Fr::one(); + + for v in v.iter() { + tmp.mul_assign(&v); + manual.push(tmp); + } + + let as_poly = Polynomial::from_values(v).unwrap(); + let worker = Worker::new(); + let as_poly = as_poly.calculate_grand_product(&worker).unwrap(); + let as_poly = as_poly.into_coeffs(); + for idx in 0..manual.len() { + assert_eq!(manual[idx], as_poly[idx], "failed at idx = {}", idx); + } + } + + #[test] + #[ignore] + fn test_insane_size_lde() { + use crate::pairing::bn256::Fr; + use crate::ff::{Field, PrimeField}; + use super::*; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::worker::Worker; + + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + + let scalars = crate::kate_commitment::test::make_random_field_elements::(&worker, max_size); + + for size in vec![1 << 23, 1 << 24, 1 << 25, 1 << 26] { + let poly = Polynomial::from_coeffs(scalars[..size].to_vec()).unwrap(); + use crate::plonk::fft::cooley_tukey_ntt::*; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + for cpus in vec![4, 8, 16, 32] { + // for cpus in vec![16, 24, 32] { + + use std::time::Instant; + + let subworker = Worker::new_with_cpus(cpus); + + let poly = poly.clone(); + + let now = Instant::now(); + + let _ = poly.bitreversed_lde_using_bitreversed_ntt( + &subworker, + 4, + &omegas_bitreversed, + &Fr::multiplicative_generator() + ).unwrap(); + + println!("Total LDE time for {} points on {} cpus = {:?}", size, cpus, now.elapsed()); + } + } + } + + #[test] + #[ignore] + fn test_fft_scaling() { + use crate::pairing::bn256::Fr; + use crate::ff::{Field, PrimeField}; + use super::*; + + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::worker::Worker; + + let max_size = 1 << 26; + let worker = Worker::new(); + + assert!(worker.cpus >= 16, "should be tested only on large machines"); + + let scalars = crate::kate_commitment::test::make_random_field_elements::(&worker, max_size); + + for size in vec![1 << 23, 1 << 24, 1 << 25, 1 << 26] { + let poly = Polynomial::from_coeffs(scalars[..size].to_vec()).unwrap(); + use crate::plonk::fft::cooley_tukey_ntt::*; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + for cpus in vec![4, 8, 16, 32] { + // for cpus in vec![16, 24, 32] { + + use std::time::Instant; + + let subworker = Worker::new_with_cpus(cpus); + + let poly = poly.clone(); + + let now = Instant::now(); + + let _ = poly.fft_using_bitreversed_ntt_output_bitreversed( + &subworker, + &omegas_bitreversed, + &Fr::one() + // &Fr::multiplicative_generator() + ).unwrap(); + + println!("Total FFT time time for {} points on {} cpus = {:?}", size, cpus, now.elapsed()); + } + } + } +} + +#[test] +fn test_primefiled_fft_gpu() +{ + use crate::pairing::bn256::{Bn256,Fr}; + use crate::ff::{Field, PrimeField}; + use crate::worker::Worker; + use crate::plonk::polynomials::Polynomial; + use crate::domain::Scalar; + use crate::domain::best_fft as best_fft_domain; + use crate::gpu::{self, LockedFFTKernel}; + use crate::domain::{gpu_fft, EvaluationDomain}; + + let max_log = 20; + let max_size = 1 << max_log; + let worker = Worker::new(); + let mut scalars_a = crate::kate_commitment::test::make_random_field_elements::(&worker, max_size); + let mut scalars_b = scalars_a.clone(); + let mut scalars_c = scalars_a.clone(); + let mut scalars_d = scalars_a.clone(); + let mut scalars_e = scalars_a.clone(); + + let poly_a = Polynomial::from_coeffs(scalars_a[..].to_vec()).unwrap(); + let poly_b = Polynomial::from_coeffs(scalars_b[..].to_vec()).unwrap(); + let poly_c = Polynomial::from_coeffs(scalars_c[..].to_vec()).unwrap(); + let poly_d = Polynomial::from_coeffs(scalars_d[..].to_vec()).unwrap(); + let poly_e = Polynomial::from_coeffs(scalars_e[..].to_vec()).unwrap(); + + let poly_a_omega = poly_a.omega; + let mut poly_a_coff = poly_a.into_coeffs(); + best_fft(&mut poly_a_coff, &worker, &poly_a_omega, max_log, None); + + let poly_b_omega = poly_b.omega; + let poly_b_coff = poly_b.into_coeffs(); + let mut scalars_b: Vec> = poly_b_coff.into_iter().map(|e| Scalar::(e)).collect(); + best_fft_domain(&mut scalars_b, &worker, &poly_b_omega, max_log); + let mut scalars_b: Vec = scalars_b.into_iter().map(|e| e.0).collect(); + assert_eq!(poly_a_coff, scalars_b); + + + let poly_c_omega = poly_c.omega; + let mut poly_c_coff = poly_c.into_coeffs(); + let scalars_c = unsafe { std::mem::transmute::<&mut [Fr], &mut [Scalar::]>(&mut poly_c_coff) }; + best_fft_domain(scalars_c, &worker, &poly_c_omega, max_log); + let mut scalars_c: Vec = scalars_c.into_iter().map(|e| (*e).0).collect(); + assert_eq!(poly_a_coff, scalars_c); + + + let poly_d_omega = poly_d.omega; + let mut poly_d_coff = poly_d.into_coeffs(); + let scalars_d = unsafe { std::mem::transmute::<&mut [Fr], &mut [Scalar::]>(&mut poly_d_coff) }; + + let mut kern = gpu::FFTKernel::create(1 << 24, false).expect("Cannot initialize kernel!"); + gpu_fft(&mut kern,scalars_d,&poly_d_omega,max_log).unwrap(); + let mut scalars_d: Vec = scalars_d.into_iter().map(|e| (*e).0).collect(); + assert_eq!(poly_a_coff, scalars_d); + drop(kern); + + let poly_e_omega = poly_e.omega; + let mut poly_e_coff = poly_e.into_coeffs(); + best_fft_bn256_gpu(&mut poly_e_coff, &worker, &poly_e_omega, max_log, None ); + assert_eq!(poly_a_coff, poly_e_coff); +} + + +#[test] +fn test_poly_fft_ctt_consistency(){ + use crate::pairing::bn256::{Bn256,Fr}; + use crate::ff::{Field, PrimeField}; + use crate::worker::Worker; + use crate::plonk::polynomials::Polynomial; + use crate::domain::Scalar; + use crate::domain::best_fft as best_fft_domain; + use crate::gpu::{self, LockedFFTKernel}; + use crate::domain::{gpu_fft, EvaluationDomain}; + use crate::plonk::fft::cooley_tukey_ntt::{BitReversedOmegas,OmegasInvBitreversed}; + use crate::plonk::fft::fft::{parallel_fft, bit_rev_best_ct_ntt_2_best_fft_gpu,best_ct_ntt_2_best_fft_gpu}; + use crate::plonk::fft::cooley_tukey_ntt::{parallel_ct_ntt,serial_ct_ntt, best_ct_ntt}; + use crate::plonk::fft::cooley_tukey_ntt::bitreverse as ntt_bitreverse; + + let max_log = 10; + let max_size = 1 << max_log; + let worker = Worker::new(); + + let mut scalars_a = crate::kate_commitment::test::make_random_field_elements::(&worker, max_size); + let mut scalars_b = scalars_a.clone(); + let mut scalars_c = scalars_a.clone(); + let mut scalars_d = scalars_a.clone(); + let mut scalars_e = scalars_a.clone(); + + + let poly_a = Polynomial::from_coeffs(scalars_a[..].to_vec()).unwrap(); + let poly_b = Polynomial::from_coeffs(scalars_b[..].to_vec()).unwrap(); + let poly_c = Polynomial::from_coeffs(scalars_c[..].to_vec()).unwrap(); + let poly_d = Polynomial::from_coeffs(scalars_c[..].to_vec()).unwrap(); + let poly_e = Polynomial::from_coeffs(scalars_e[..].to_vec()).unwrap(); + + let poly_size = poly_a.size(); + let poly_size = poly_size.next_power_of_two(); + + + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + let omega = domain.generator; + let omega_inv = domain.generator.inverse().expect("must exist"); + + let log_n = domain.power_of_two as u32; + + let poly_a_omega = poly_a.omega; + let mut poly_a_coff = poly_a.into_coeffs(); + best_fft_bn256_gpu(&mut poly_a_coff, &worker, &omega, log_n, None); + + let poly_b_omega = poly_b.omega; + let mut poly_b_coff = poly_b.into_coeffs(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly_size); + // parallel_ct_ntt(&mut poly_b_coff, &worker, log_n, worker.log_num_cpus(), &precomp); + best_ct_ntt(&mut poly_b_coff, &worker, log_n, None, &precomp); + + let log_n = log_n as usize; + for k in 0..poly_size { + let rk = ntt_bitreverse(k, log_n); + if k < rk { + poly_a_coff.swap(rk, k); + } + } + assert_eq!(poly_a_coff, poly_b_coff); + + let poly_c_size = poly_c.size(); + let mut poly_c_coff = poly_c.into_coeffs(); + best_ct_ntt_2_best_fft_gpu(&mut poly_c_coff, &worker, poly_c_size); + assert_eq!(poly_a_coff, poly_c_coff); + + let poly_d_size = poly_d.size(); + let mut poly_d_coff = poly_d.into_coeffs(); + bit_rev_best_ct_ntt_2_best_fft_gpu(&mut poly_d_coff, &worker, log_n as u32, &precomp); + assert_eq!(poly_a_coff, poly_d_coff); +} + +#[test] +fn test_omegas_inv_ntt_ftt_consistency() +{ + use crate::pairing::bn256::{Bn256,Fr}; + use crate::ff::{Field, PrimeField}; + use crate::worker::Worker; + use crate::plonk::polynomials::Polynomial; + use crate::domain::Scalar; + use crate::domain::best_fft as best_fft_domain; + use crate::gpu::{self, LockedFFTKernel}; + use crate::domain::{gpu_fft, EvaluationDomain}; + use crate::plonk::fft::cooley_tukey_ntt::{BitReversedOmegas,OmegasInvBitreversed}; + use crate::plonk::fft::fft::{parallel_fft, bit_rev_best_ct_ntt_2_best_fft_gpu}; + use crate::plonk::fft::cooley_tukey_ntt::{parallel_ct_ntt,serial_ct_ntt, best_ct_ntt}; + use crate::plonk::fft::cooley_tukey_ntt::bitreverse as ntt_bitreverse; + + let max_log = 2; + let max_size = 1 << max_log; + let worker = Worker::new(); + + let mut scalars_a = crate::kate_commitment::test::make_random_field_elements::(&worker, max_size); + let mut scalars_b = scalars_a.clone(); + + let poly_a = Polynomial::from_coeffs(scalars_a[..].to_vec()).unwrap(); + let poly_b = Polynomial::from_coeffs(scalars_b[..].to_vec()).unwrap(); + + let poly_size = poly_a.size(); + let poly_size = poly_size.next_power_of_two(); + + let poly_a_omega = poly_a.omegainv; + let mut poly_a_coff = poly_a.into_coeffs(); + best_fft_bn256_gpu(&mut poly_a_coff, &worker, &poly_a_omega, max_log, None); + + let poly_b_omega = poly_b.omega; + let mut poly_b_coff = poly_b.into_coeffs(); + let precomp = OmegasInvBitreversed::::new_for_domain_size(poly_size); + + let precomp_tem = BitReversedOmegas::::new_for_domain_size(poly_size); + // parallel_ct_ntt(&mut poly_b_coff, &worker, log_n, worker.log_num_cpus(), &precomp); + best_ct_ntt(&mut poly_b_coff, &worker, max_log, None, &precomp); + + let log_n = max_log as usize; + for k in 0..poly_size { + let rk = ntt_bitreverse(k, log_n); + if k < rk { + poly_a_coff.swap(rk, k); + } + } + assert_eq!(poly_a_coff, poly_b_coff); + + +} \ No newline at end of file diff --git a/src/plonk/prover/homomorphic.rs b/src/plonk/prover/homomorphic.rs new file mode 100644 index 000000000..381a459d8 --- /dev/null +++ b/src/plonk/prover/homomorphic.rs @@ -0,0 +1,904 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use super::polynomials::*; +use super::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; + +pub struct PlonkNonhomomorphicProof >{ + q_l_opening_value: E::Fr, + q_r_opening_value: E::Fr, + q_o_opening_value: E::Fr, + q_m_opening_value: E::Fr, + q_c_opening_value: E::Fr, + s_id_opening_value: E::Fr, + sigma_1_opening_value: E::Fr, + sigma_2_opening_value: E::Fr, + sigma_3_opening_value: E::Fr, + z_1_shifted_opening_value: E::Fr, + z_2_shifted_opening_value: E::Fr, + r_opening_value: E::Fr, + unshifted_openings_proof: S::OpeningProof, + shifted_openings_proof: S::OpeningProof, + +} + +pub fn prove_nonhomomorphic, T: Transcript, C: Circuit>(circuit: &C, committer: &S) -> Result, SynthesisError> { + let mut assembly = ProvingAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let worker = Worker::new(); + + let mut transcript = T::new(); + + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let (w_l, w_r, w_o) = assembly.make_wire_assingments(); + + let w_l = Polynomial::::from_values_unpadded(w_l)?; + let w_r = Polynomial::::from_values_unpadded(w_r)?; + let w_o = Polynomial::::from_values_unpadded(w_o)?; + + let a_poly = w_l.clone_padded_to_domain()?.ifft(&worker); + let b_poly = w_r.clone_padded_to_domain()?.ifft(&worker); + let c_poly = w_o.clone_padded_to_domain()?.ifft(&worker); + + let (a_commitment, a_aux_data) = committer.commit_single(&a_poly); + let (b_commitment, b_aux_data) = committer.commit_single(&b_poly); + let (c_commitment, c_aux_data) = committer.commit_single(&c_poly); + + transcript.commit_input(&a_commitment); + transcript.commit_input(&b_commitment); + transcript.commit_input(&c_commitment); + + // TODO: Add public inputs + + println!("Committed A, B and C polys"); + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut w_l_plus_gamma = w_l.clone(); + w_l_plus_gamma.add_constant(&worker, &gamma); + + let mut w_r_plus_gamma = w_r.clone(); + w_r_plus_gamma.add_constant(&worker, &gamma); + + let mut w_o_plus_gamma = w_o.clone(); + w_o_plus_gamma.add_constant(&worker, &gamma); + + let z_1 = { + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + let s_id_1: Vec<_> = (1..=n).collect(); + let s_id_1 = convert_to_field_elements(&s_id_1, &worker); + let s_id_1 = Polynomial::::from_values_unpadded(s_id_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &s_id_1, &beta); + drop(s_id_1); + + let s_id_2: Vec<_> = ((n+1)..=(2*n)).collect(); + let s_id_2 = convert_to_field_elements(&s_id_2, &worker); + let s_id_2 = Polynomial::::from_values_unpadded(s_id_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &s_id_2, &beta); + drop(s_id_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let s_id_3: Vec<_> = ((2*n+1)..=(3*n)).collect(); + let s_id_3 = convert_to_field_elements(&s_id_3, &worker); + let s_id_3 = Polynomial::::from_values_unpadded(s_id_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &s_id_3, &beta); + drop(s_id_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + // let grand_product_serial = w_l_contribution.calculate_grand_product_serial()?; + + // assert!(grand_product == grand_product_serial); + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + Polynomial::::from_values(prepadded)? + }; + + let z_2 = { + let (sigma_1, sigma_2, sigma_3) = assembly.calculate_permutations_as_in_a_paper(); + + let sigma_1 = convert_to_field_elements(&sigma_1, &worker); + let sigma_1 = Polynomial::::from_values_unpadded(sigma_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &sigma_1, &beta); + drop(sigma_1); + + let sigma_2 = convert_to_field_elements(&sigma_2, &worker); + let sigma_2 = Polynomial::::from_values_unpadded(sigma_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &sigma_2, &beta); + drop(sigma_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let sigma_3 = convert_to_field_elements(&sigma_3, &worker); + let sigma_3 = Polynomial::::from_values_unpadded(sigma_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &sigma_3, &beta); + drop(sigma_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + // let grand_product_serial = w_l_contribution.calculate_grand_product_serial()?; + + // assert!(grand_product == grand_product_serial); + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + let z_2 = Polynomial::::from_values(prepadded)?; + + z_2 + }; + + let z_1 = z_1.ifft(&worker); + let z_2 = z_2.ifft(&worker); + + let (z_1_commitment, z_1_aux) = committer.commit_single(&z_1); + let (z_2_commitment, z_2_aux) = committer.commit_single(&z_2); + + transcript.commit_input(&z_1_commitment); + transcript.commit_input(&z_2_commitment); + + let mut z_1_shifted = z_1.clone(); + z_1_shifted.distribute_powers(&worker, z_1.omega); + + let mut z_2_shifted = z_2.clone(); + z_2_shifted.distribute_powers(&worker, z_2.omega); + + let a_lde = a_poly.clone().coset_lde(&worker, 4)?; + let b_lde = b_poly.clone().coset_lde(&worker, 4)?; + let c_lde = c_poly.clone().coset_lde(&worker, 4)?; + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let q_l_lde = q_l.clone().coset_lde(&worker, 4)?; + let q_r_lde = q_r.clone().coset_lde(&worker, 4)?; + let q_o_lde = q_o.clone().coset_lde(&worker, 4)?; + let q_m_lde = q_m.clone().coset_lde(&worker, 4)?; + let q_c_lde = q_c.clone().coset_lde(&worker, 4)?; + let s_id_lde = s_id.clone().coset_lde(&worker, 4)?; + let sigma_1_lde = sigma_1.clone().coset_lde(&worker, 4)?; + let sigma_2_lde = sigma_2.clone().coset_lde(&worker, 4)?; + let sigma_3_lde = sigma_3.clone().coset_lde(&worker, 4)?; + + let n_fe = E::Fr::from_str(&n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + let mut vanishing_poly_inverse = assembly.calculate_inverse_vanishing_polynomial_in_a_coset(&worker, q_c_lde.size(), required_domain_size.next_power_of_two())?; + + let mut t_1 = { + let mut t_1 = q_c_lde; + + let mut q_l_by_a = q_l_lde; + q_l_by_a.mul_assign(&worker, &a_lde); + t_1.add_assign(&worker, &q_l_by_a); + drop(q_l_by_a); + + let mut q_r_by_b = q_r_lde; + q_r_by_b.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_r_by_b); + drop(q_r_by_b); + + let mut q_o_by_c = q_o_lde; + q_o_by_c.mul_assign(&worker, &c_lde); + t_1.add_assign(&worker, &q_o_by_c); + drop(q_o_by_c); + + let mut q_m_by_ab = q_m_lde; + q_m_by_ab.mul_assign(&worker, &a_lde); + q_m_by_ab.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_m_by_ab); + drop(q_m_by_ab); + + vanishing_poly_inverse.scale(&worker, alpha); + + t_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1 + }; + + let z_1_lde = z_1.clone().coset_lde(&worker, 4)?; + + let z_1_shifted_lde = z_1_shifted.clone().coset_lde(&worker, 4)?; + + let z_2_lde = z_2.clone().coset_lde(&worker, 4)?; + + let z_2_shifted_lde = z_2_shifted.clone().coset_lde(&worker, 4)?; + + { + // TODO: May be optimize number of additions + let mut contrib_z_1 = z_1_lde.clone(); + + let mut s_id_by_beta = s_id_lde; + s_id_by_beta.scale(&worker, beta); + + let mut n_by_beta = n_fe; + n_by_beta.mul_assign(&beta); + + let mut a_perm = s_id_by_beta.clone(); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_1.mul_assign(&worker, &a_perm); + drop(a_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut b_perm = s_id_by_beta.clone(); + + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_1.mul_assign(&worker, &b_perm); + drop(b_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut c_perm = s_id_by_beta; + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_1.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_1.sub_assign(&worker, &z_1_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_1); + } + + { + // TODO: May be optimize number of additions + let mut contrib_z_2 = z_2_lde.clone(); + + let mut a_perm = sigma_1_lde; + a_perm.scale(&worker, beta); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_2.mul_assign(&worker, &a_perm); + drop(a_perm); + + + let mut b_perm = sigma_2_lde; + b_perm.scale(&worker, beta); + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_2.mul_assign(&worker, &b_perm); + drop(b_perm); + + let mut c_perm = sigma_3_lde; + c_perm.scale(&worker, beta); + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_2.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_2.sub_assign(&worker, &z_2_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_2); + } + + drop(a_lde); + drop(b_lde); + drop(c_lde); + + let l_0 = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), 0)?; + let l_n_minus_one = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), n-1)?; + + { + let mut z_1_minus_z_2_shifted = z_1_shifted_lde.clone(); + z_1_minus_z_2_shifted.sub_assign(&worker, &z_2_shifted_lde); + + let l = l_n_minus_one.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2_shifted.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2_shifted.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2_shifted); + } + + { + let mut z_1_minus_z_2= z_1_lde.clone(); + z_1_minus_z_2.sub_assign(&worker, &z_2_lde); + + let l = l_0.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2); + } + + let t_poly = t_1.icoset_fft(&worker); + + let degree = get_degree::(&t_poly); + + assert!(degree <= 3*n); + + fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + println!("Degree = {}", degree); + + degree + } + + let (t_commitment, t_2_aux) = committer.commit_single(&t_poly); + + transcript.commit_input(&t_commitment); + + let z = transcript.get_challenge(); + + // this is a sanity check + + let a_at_z = a_poly.evaluate_at(&worker, z); + let b_at_z = b_poly.evaluate_at(&worker, z); + let c_at_z = c_poly.evaluate_at(&worker, z); + + let q_l_at_z = q_l.evaluate_at(&worker, z); + let q_r_at_z = q_r.evaluate_at(&worker, z); + let q_o_at_z = q_o.evaluate_at(&worker, z); + let q_m_at_z = q_m.evaluate_at(&worker, z); + let q_c_at_z = q_c.evaluate_at(&worker, z); + + let s_id_at_z = s_id.evaluate_at(&worker, z); + let sigma_1_at_z = sigma_1.evaluate_at(&worker, z); + let sigma_2_at_z = sigma_2.evaluate_at(&worker, z); + let sigma_3_at_z = sigma_3.evaluate_at(&worker, z); + + let mut inverse_vanishing_at_z = assembly.evaluate_inverse_vanishing_poly(required_domain_size.next_power_of_two(), z); + + let inverse_vanishing_at_z_no_alphas = inverse_vanishing_at_z; + + let z_1_at_z = z_1.evaluate_at(&worker, z); + let z_2_at_z = z_2.evaluate_at(&worker, z); + + let z_1_shifted_at_z = z_1_shifted.evaluate_at(&worker, z); + let z_2_shifted_at_z = z_2_shifted.evaluate_at(&worker, z); + + let l_0_at_z = l_0.evaluate_at(&worker, z); + let l_n_minus_one_at_z = l_n_minus_one.evaluate_at(&worker, z); + + let t_at_z = t_poly.evaluate_at(&worker, z); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + let unshifted_opening_aggregation_challenge = transcript.get_challenge(); + + let shifted_opening_aggregation_challenge = transcript.get_challenge(); + + // this is a sanity check + { + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + assert_eq!(t_at_z, t_1); + } + + // now compute linearization polynomial + + let mut r_1 = { + let mut res = q_c; + + res.add_assign_scaled(&worker, &q_l, &a_at_z); + res.add_assign_scaled(&worker, &q_r, &b_at_z); + res.add_assign_scaled(&worker, &q_o, &c_at_z); + + let mut a_by_b_at_z = a_at_z; + a_by_b_at_z.mul_assign(&b_at_z); + res.add_assign_scaled(&worker, &q_m, &a_by_b_at_z); + + res.scale(&worker, alpha); + + res + }; + + { + let mut factor = alpha; + factor.square(); + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + r_1.add_assign_scaled(&worker, &z_1, &factor); + } + + { + let mut factor = alpha; + factor.square(); + factor.mul_assign(&alpha); + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + factor.mul_assign(&tmp); + + r_1.add_assign_scaled(&worker, &z_2, &factor); + } + + { + let mut factor = alpha; + factor.square(); + factor.square(); + factor.mul_assign(&alpha); + factor.mul_assign(&l_0_at_z); + + let mut tmp = z_1; + tmp.sub_assign(&worker, &z_2); + + r_1.add_assign_scaled(&worker, &tmp, &factor); + } + + let (r_commitment, r_aux_data) = committer.commit_single(&r_1); + + let r_at_z = r_1.evaluate_at(&worker, z); + + // another sanity check + + { + let reevaluated_at_at_z = { + let mut numerator = r_at_z; + + let mut tmp = alpha; + tmp.square(); + tmp.mul_assign(&z_1_shifted_at_z); + + numerator.sub_assign(&tmp); + + let mut tmp = alpha; + tmp.square(); + tmp.mul_assign(&alpha); + tmp.mul_assign(&z_2_shifted_at_z); + + numerator.sub_assign(&tmp); + + let mut z_1_shifted_minus_z_2_shifted = z_1_shifted_at_z; + z_1_shifted_minus_z_2_shifted.sub_assign(&z_2_shifted_at_z); + + let mut tmp = alpha; + tmp.square(); + tmp.square(); + tmp.mul_assign(&l_n_minus_one_at_z); + tmp.mul_assign(&z_1_shifted_minus_z_2_shifted); + + numerator.add_assign(&tmp); + + numerator.mul_assign(&inverse_vanishing_at_z_no_alphas); + + numerator + }; + + assert_eq!(t_at_z, reevaluated_at_at_z); + + } + + // follow the order from the paper + + let unshifted_opening_values = vec![t_at_z, r_at_z, a_at_z, b_at_z, c_at_z, ] + + Ok(()) +} + +#[cfg(test)] +mod test { + + use super::*; + use crate::pairing::ff::{Field, PrimeField}; + use crate::pairing::{Engine}; + + use crate::{SynthesisError}; + use std::marker::PhantomData; + + use crate::plonk::cs::gates::*; + use crate::plonk::cs::*; + + struct TestCircuit{ + _marker: PhantomData + } + + impl Circuit for TestCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + cs.enforce_zero_2((a, b), (two, negative_one))?; + + let ten = E::Fr::from_str("10").unwrap(); + cs.enforce_zero_2((b, c), (ten, negative_one))?; + + cs.enforce_mul_3((a, b, c))?; + + Ok(()) + } + } + + #[test] + fn test_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + + let mut assembly = GeneratorAssembly::::new(); + + let circuit = TestCircuit:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + println!("{:?}", assembly); + + assembly.finalize(); + + let (f_l, f_r, f_o) = assembly.make_wire_assingments(); + + let (sigma_1, sigma_2, sigma_3) = assembly.calculate_permutations_as_in_a_paper(); + + let num_gates = assembly.num_gates(); + + let id_1: Vec<_> = (1..=num_gates).collect(); + let id_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let id_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let beta = Fr::from_str("15").unwrap(); + let gamma = Fr::from_str("4").unwrap(); + + let mut f_1_poly = vec![]; + let mut g_1_poly = vec![]; + for (i, el) in f_l.iter().enumerate() { + let mut tmp = Fr::from_str(&id_1[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_1_poly.push(tmp); + } + + for (i, el) in f_l.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_1[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_1_poly.push(tmp); + } + + let mut f_2_poly = vec![]; + let mut g_2_poly = vec![]; + for (i, el) in f_r.iter().enumerate() { + let mut tmp = Fr::from_str(&id_2[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_2_poly.push(tmp); + } + + for (i, el) in f_r.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_2[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_2_poly.push(tmp); + } + + + let mut f_3_poly = vec![]; + let mut g_3_poly = vec![]; + for (i, el) in f_o.iter().enumerate() { + let mut tmp = Fr::from_str(&id_3[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_3_poly.push(tmp); + } + + for (i, el) in f_o.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_3[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_3_poly.push(tmp); + } + + let mut f_poly = vec![]; + let mut g_poly = vec![]; + + for i in 0..f_1_poly.len() { + let mut tmp = f_1_poly[i]; + tmp.mul_assign(&f_2_poly[i]); + tmp.mul_assign(&f_3_poly[i]); + f_poly.push(tmp); + } + + for i in 0..g_1_poly.len() { + let mut tmp = g_1_poly[i]; + tmp.mul_assign(&g_2_poly[i]); + tmp.mul_assign(&g_3_poly[i]); + g_poly.push(tmp); + } + + let mut tmp = Fr::one(); + let mut f_prime = vec![tmp]; + for el in f_poly.iter() { + tmp.mul_assign(&el); + f_prime.push(tmp); + } + + let mut tmp = Fr::one(); + let mut g_prime = vec![tmp]; + for el in g_poly.iter() { + tmp.mul_assign(&el); + g_prime.push(tmp); + } + + assert!(f_prime[0] == g_prime[0]); + assert!(f_prime[num_gates] == g_prime[num_gates]); + + let worker = Worker::new(); + + let _ = assembly.output_setup_polynomials(&worker).unwrap(); + + let _ = assembly.generate_proof().unwrap(); + + } + + #[test] + fn test_coset_lde() { + use crate::pairing::bn256::{Bn256, Fr}; + + let worker = Worker::new(); + + let coeffs: Vec<_> = (0..4).collect(); + let coeffs = convert_to_field_elements(&coeffs, &worker); + let coeffs = Polynomial::::from_coeffs(coeffs).unwrap(); + + let mut expanded = coeffs.clone(); + expanded.pad_to_size(16).unwrap(); + + let naive = expanded.coset_fft(&worker); + let fast = coeffs.coset_lde(&worker, 4).unwrap(); + + assert!(naive == fast); + + } +} \ No newline at end of file diff --git a/src/plonk/prover/mod.rs b/src/plonk/prover/mod.rs new file mode 100644 index 000000000..d1806f245 --- /dev/null +++ b/src/plonk/prover/mod.rs @@ -0,0 +1,2241 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use super::polynomials::*; +use super::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; +use crate::plonk::generator::*; + + +#[derive(Debug)] +struct ProvingAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + inputs_map: Vec, + + is_finalized: bool +} + +impl ConstraintSystem for ProvingAssembly { + const ZERO: Variable = Variable(Index::Aux(1)); + const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + // let gate = Gate::::new_enforce_constant_gate(input_var, Some(value), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr), values: F) -> Result<(), SynthesisError> + where + F: FnOnce() -> Result<(E::Fr, E::Fr), SynthesisError> + { + unimplemented!() + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } +} + +impl ProvingAssembly { + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + pub(crate) fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + inputs_map: vec![], + + is_finalized: false, + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + match (zero, >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + match (one, >::ONE) { + (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + _ => panic!("one variable is incorrect") + } + + match (tmp.dummy_variable(), >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + >::ZERO + // Variable(Index::Aux(0)) + } + + pub(crate) fn make_wire_assingments(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + // create a vector of gate assingments + // if a_i = j then w_j = f_l(g^i) + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut f_l = vec![E::Fr::zero(); total_num_gates]; + let mut f_r = vec![E::Fr::zero(); total_num_gates]; + let mut f_o = vec![E::Fr::zero(); total_num_gates]; + + for (i, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + f_l[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_l[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + f_r[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_r[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + f_o[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_o[i] = self.aux_assingments[index - 1]; + }, + } + } + + (f_l, f_r, f_o) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: & Coeff) -> E::Fr { + match coeff { + Coeff::Zero => { + E::Fr::zero() + }, + Coeff::One => { + E::Fr::one() + }, + Coeff::NegativeOne => { + let mut tmp = E::Fr::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub(crate) fn num_gates(&self) -> usize { + assert!(self.is_finalized); + + self.input_gates.len() + self.aux_gates.len() + } + + fn finalize(&mut self) { + if self.is_finalized { + return; + } + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + self.is_finalized = true; + } + + fn calculate_inverse_vanishing_polynomial_in_a_coset(&self, worker: &Worker, poly_size:usize, vahisning_size: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64)?; + let n_domain_omega = domain.generator; + let mut root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + root.negate(); + + let multiplicative_generator = E::Fr::multiplicative_generator(); + + let mut negative_one = E::Fr::one(); + negative_one.negate(); + + let mut numerator = Polynomial::::from_values(vec![multiplicative_generator; poly_size])?; + // evaluate X in linear time + + numerator.distribute_powers(&worker, numerator.omega); + numerator.add_constant(&worker, &root); + + // numerator.add_constant(&worker, &negative_one); + // now it's a series of values in a coset + + // now we should evaluate X^(n+1) - 1 in a linear time + + let shift = multiplicative_generator.pow([vahisning_size as u64]); + + let mut denominator = Polynomial::::from_values(vec![shift; poly_size])?; + + // elements are h^size - 1, (hg)^size - 1, (hg^2)^size - 1, ... + + denominator.distribute_powers(&worker, denominator.omega.pow([vahisning_size as u64])); + denominator.add_constant(&worker, &negative_one); + + denominator.batch_inversion(&worker)?; + + numerator.mul_assign(&worker, &denominator); + + Ok(numerator) + } + + fn evaluate_inverse_vanishing_poly(&self, vahisning_size: usize, point: E::Fr) -> E::Fr { + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("should fit"); + let n_domain_omega = domain.generator; + let root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + + let mut numerator = point; + numerator.sub_assign(&root); + + let mut denominator = point.pow([vahisning_size as u64]); + denominator.sub_assign(&E::Fr::one()); + + let denominator = denominator.inverse().expect("must exist"); + + numerator.mul_assign(&denominator); + + numerator + } + + fn calculate_lagrange_poly(&self, worker: &Worker, poly_size:usize, poly_number: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(poly_number < poly_size); + + let mut poly = Polynomial::::from_values(vec![E::Fr::zero(); poly_size])?; + + poly.as_mut()[poly_number] = E::Fr::one(); + + Ok(poly.ifft(&worker)) + } +} + + +// for a non-homomorphic case we do not need r(x) polynomial at all, just open all the parts of t(x) at z + +pub struct PlonkNonhomomorphicProof >{ + pub a_opening_value: E::Fr, + pub b_opening_value: E::Fr, + pub c_opening_value: E::Fr, + pub q_l_opening_value: E::Fr, + pub q_r_opening_value: E::Fr, + pub q_o_opening_value: E::Fr, + pub q_m_opening_value: E::Fr, + pub q_c_opening_value: E::Fr, + pub s_id_opening_value: E::Fr, + pub sigma_1_opening_value: E::Fr, + pub sigma_2_opening_value: E::Fr, + pub sigma_3_opening_value: E::Fr, + pub z_1_unshifted_opening_value: E::Fr, + pub z_2_unshifted_opening_value: E::Fr, + pub z_1_shifted_opening_value: E::Fr, + pub z_2_shifted_opening_value: E::Fr, + pub t_opening_value: E::Fr, + pub a_commitment: S::Commitment, + pub b_commitment: S::Commitment, + pub c_commitment: S::Commitment, + pub z_1_commitment: S::Commitment, + pub z_2_commitment: S::Commitment, + pub t_commitment: S::Commitment, + pub openings_proof: S::OpeningProof, + // pub shifted_openings_proof: S::OpeningProof, + pub t_opening_proof: S::OpeningProof, +} + +pub struct PlonkChunkedNonhomomorphicProof >{ + pub a_opening_value: E::Fr, + pub b_opening_value: E::Fr, + pub c_opening_value: E::Fr, + pub q_l_opening_value: E::Fr, + pub q_r_opening_value: E::Fr, + pub q_o_opening_value: E::Fr, + pub q_m_opening_value: E::Fr, + pub q_c_opening_value: E::Fr, + pub s_id_opening_value: E::Fr, + pub sigma_1_opening_value: E::Fr, + pub sigma_2_opening_value: E::Fr, + pub sigma_3_opening_value: E::Fr, + pub z_1_unshifted_opening_value: E::Fr, + pub z_2_unshifted_opening_value: E::Fr, + pub z_1_shifted_opening_value: E::Fr, + pub z_2_shifted_opening_value: E::Fr, + pub t_low_opening_value: E::Fr, + pub t_mid_opening_value: E::Fr, + pub t_high_opening_value: E::Fr, + pub a_commitment: S::Commitment, + pub b_commitment: S::Commitment, + pub c_commitment: S::Commitment, + pub z_1_commitment: S::Commitment, + pub z_2_commitment: S::Commitment, + pub t_low_commitment: S::Commitment, + pub t_mid_commitment: S::Commitment, + pub t_high_commitment: S::Commitment, + pub openings_proof: S::OpeningProof, +} + +pub fn prove_nonhomomorphic, T: Transcript, C: Circuit>( + circuit: &C, + setup: &PlonkSetup, + aux: &PlonkSetupAuxData, + meta: S::Meta, + large_meta: S::Meta +) -> Result, SynthesisError> { + assert!(S::IS_HOMOMORPHIC == false); + + let mut assembly = ProvingAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.num_gates(); + + let committer = S::new_for_size(num_gates.next_power_of_two(), meta); + let large_committer = S::new_for_size(4 * num_gates.next_power_of_two(), large_meta); + + let worker = Worker::new(); + + let mut transcript = T::new(); + + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + println!("Start work with polynomials"); + + let (w_l, w_r, w_o) = assembly.make_wire_assingments(); + + let w_l = Polynomial::::from_values_unpadded(w_l)?; + let w_r = Polynomial::::from_values_unpadded(w_r)?; + let w_o = Polynomial::::from_values_unpadded(w_o)?; + + let a_poly = w_l.clone_padded_to_domain()?.ifft(&worker); + let b_poly = w_r.clone_padded_to_domain()?.ifft(&worker); + let c_poly = w_o.clone_padded_to_domain()?.ifft(&worker); + + let (a_commitment, a_aux_data) = committer.commit_single(&a_poly); + let (b_commitment, b_aux_data) = committer.commit_single(&b_poly); + let (c_commitment, c_aux_data) = committer.commit_single(&c_poly); + + transcript.commit_input(&a_commitment); + transcript.commit_input(&b_commitment); + transcript.commit_input(&c_commitment); + + // TODO: Add public inputs + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut w_l_plus_gamma = w_l.clone(); + w_l_plus_gamma.add_constant(&worker, &gamma); + + let mut w_r_plus_gamma = w_r.clone(); + w_r_plus_gamma.add_constant(&worker, &gamma); + + let mut w_o_plus_gamma = w_o.clone(); + w_o_plus_gamma.add_constant(&worker, &gamma); + + let z_1 = { + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + let s_id_1: Vec<_> = (1..=n).collect(); + let s_id_1 = convert_to_field_elements(&s_id_1, &worker); + let s_id_1 = Polynomial::::from_values_unpadded(s_id_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &s_id_1, &beta); + drop(s_id_1); + + let s_id_2: Vec<_> = ((n+1)..=(2*n)).collect(); + let s_id_2 = convert_to_field_elements(&s_id_2, &worker); + let s_id_2 = Polynomial::::from_values_unpadded(s_id_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &s_id_2, &beta); + drop(s_id_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let s_id_3: Vec<_> = ((2*n+1)..=(3*n)).collect(); + let s_id_3 = convert_to_field_elements(&s_id_3, &worker); + let s_id_3 = Polynomial::::from_values_unpadded(s_id_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &s_id_3, &beta); + drop(s_id_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + Polynomial::::from_values(prepadded)? + }; + + let z_2 = { + let (sigma_1, sigma_2, sigma_3) = assembly.calculate_permutations_as_in_a_paper(); + + let sigma_1 = convert_to_field_elements(&sigma_1, &worker); + let sigma_1 = Polynomial::::from_values_unpadded(sigma_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &sigma_1, &beta); + drop(sigma_1); + + let sigma_2 = convert_to_field_elements(&sigma_2, &worker); + let sigma_2 = Polynomial::::from_values_unpadded(sigma_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &sigma_2, &beta); + drop(sigma_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let sigma_3 = convert_to_field_elements(&sigma_3, &worker); + let sigma_3 = Polynomial::::from_values_unpadded(sigma_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &sigma_3, &beta); + drop(sigma_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + let z_2 = Polynomial::::from_values(prepadded)?; + + z_2 + }; + + let z_1 = z_1.ifft(&worker); + let z_2 = z_2.ifft(&worker); + + let (z_1_commitment, z_1_aux) = committer.commit_single(&z_1); + let (z_2_commitment, z_2_aux) = committer.commit_single(&z_2); + + transcript.commit_input(&z_1_commitment); + transcript.commit_input(&z_2_commitment); + + let mut z_1_shifted = z_1.clone(); + z_1_shifted.distribute_powers(&worker, z_1.omega); + + let mut z_2_shifted = z_2.clone(); + z_2_shifted.distribute_powers(&worker, z_2.omega); + + let a_lde = a_poly.clone().coset_lde(&worker, 4)?; + let b_lde = b_poly.clone().coset_lde(&worker, 4)?; + let c_lde = c_poly.clone().coset_lde(&worker, 4)?; + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let q_l_lde = q_l.clone().coset_lde(&worker, 4)?; + let q_r_lde = q_r.clone().coset_lde(&worker, 4)?; + let q_o_lde = q_o.clone().coset_lde(&worker, 4)?; + let q_m_lde = q_m.clone().coset_lde(&worker, 4)?; + let q_c_lde = q_c.clone().coset_lde(&worker, 4)?; + let s_id_lde = s_id.clone().coset_lde(&worker, 4)?; + let sigma_1_lde = sigma_1.clone().coset_lde(&worker, 4)?; + let sigma_2_lde = sigma_2.clone().coset_lde(&worker, 4)?; + let sigma_3_lde = sigma_3.clone().coset_lde(&worker, 4)?; + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + let mut vanishing_poly_inverse = assembly.calculate_inverse_vanishing_polynomial_in_a_coset(&worker, q_c_lde.size(), required_domain_size.next_power_of_two())?; + + let mut t_1 = { + let mut t_1 = q_c_lde; + + let mut q_l_by_a = q_l_lde; + q_l_by_a.mul_assign(&worker, &a_lde); + t_1.add_assign(&worker, &q_l_by_a); + drop(q_l_by_a); + + let mut q_r_by_b = q_r_lde; + q_r_by_b.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_r_by_b); + drop(q_r_by_b); + + let mut q_o_by_c = q_o_lde; + q_o_by_c.mul_assign(&worker, &c_lde); + t_1.add_assign(&worker, &q_o_by_c); + drop(q_o_by_c); + + let mut q_m_by_ab = q_m_lde; + q_m_by_ab.mul_assign(&worker, &a_lde); + q_m_by_ab.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_m_by_ab); + drop(q_m_by_ab); + + vanishing_poly_inverse.scale(&worker, alpha); + + t_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1 + }; + + let z_1_lde = z_1.clone().coset_lde(&worker, 4)?; + + let z_1_shifted_lde = z_1_shifted.clone().coset_lde(&worker, 4)?; + + let z_2_lde = z_2.clone().coset_lde(&worker, 4)?; + + let z_2_shifted_lde = z_2_shifted.clone().coset_lde(&worker, 4)?; + + { + // TODO: May be optimize number of additions + let mut contrib_z_1 = z_1_lde.clone(); + + let mut s_id_by_beta = s_id_lde; + s_id_by_beta.scale(&worker, beta); + + let mut n_by_beta = n_fe; + n_by_beta.mul_assign(&beta); + + let mut a_perm = s_id_by_beta.clone(); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_1.mul_assign(&worker, &a_perm); + drop(a_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut b_perm = s_id_by_beta.clone(); + + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_1.mul_assign(&worker, &b_perm); + drop(b_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut c_perm = s_id_by_beta; + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_1.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_1.sub_assign(&worker, &z_1_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_1); + } + + { + // TODO: May be optimize number of additions + let mut contrib_z_2 = z_2_lde.clone(); + + let mut a_perm = sigma_1_lde; + a_perm.scale(&worker, beta); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_2.mul_assign(&worker, &a_perm); + drop(a_perm); + + + let mut b_perm = sigma_2_lde; + b_perm.scale(&worker, beta); + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_2.mul_assign(&worker, &b_perm); + drop(b_perm); + + let mut c_perm = sigma_3_lde; + c_perm.scale(&worker, beta); + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_2.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_2.sub_assign(&worker, &z_2_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_2); + } + + drop(a_lde); + drop(b_lde); + drop(c_lde); + + let l_0 = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), 0)?; + let l_n_minus_one = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), n-1)?; + + { + let mut z_1_minus_z_2_shifted = z_1_shifted_lde.clone(); + z_1_minus_z_2_shifted.sub_assign(&worker, &z_2_shifted_lde); + + let l = l_n_minus_one.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2_shifted.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2_shifted.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2_shifted); + } + + { + let mut z_1_minus_z_2= z_1_lde.clone(); + z_1_minus_z_2.sub_assign(&worker, &z_2_lde); + + let l = l_0.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2); + } + + let t_poly = t_1.icoset_fft(&worker); + + println!("End work with polynomials"); + + // let degree = get_degree::(&t_poly); + + // assert!(degree <= 3*n); + + fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + println!("Degree = {}", degree); + + degree + } + + let (t_commitment, t_aux) = large_committer.commit_single(&t_poly); + + transcript.commit_input(&t_commitment); + + let z = transcript.get_challenge(); + + // this is a sanity check + + let a_at_z = a_poly.evaluate_at(&worker, z); + let b_at_z = b_poly.evaluate_at(&worker, z); + let c_at_z = c_poly.evaluate_at(&worker, z); + + let q_l_at_z = q_l.evaluate_at(&worker, z); + let q_r_at_z = q_r.evaluate_at(&worker, z); + let q_o_at_z = q_o.evaluate_at(&worker, z); + let q_m_at_z = q_m.evaluate_at(&worker, z); + let q_c_at_z = q_c.evaluate_at(&worker, z); + + let s_id_at_z = s_id.evaluate_at(&worker, z); + let sigma_1_at_z = sigma_1.evaluate_at(&worker, z); + let sigma_2_at_z = sigma_2.evaluate_at(&worker, z); + let sigma_3_at_z = sigma_3.evaluate_at(&worker, z); + + let mut inverse_vanishing_at_z = assembly.evaluate_inverse_vanishing_poly(required_domain_size.next_power_of_two(), z); + + let z_1_at_z = z_1.evaluate_at(&worker, z); + let z_2_at_z = z_2.evaluate_at(&worker, z); + + let z_1_shifted_at_z = z_1_shifted.evaluate_at(&worker, z); + let z_2_shifted_at_z = z_2_shifted.evaluate_at(&worker, z); + + let t_at_z = t_poly.evaluate_at(&worker, z); + + let l_0_at_z = l_0.evaluate_at(&worker, z); + let l_n_minus_one_at_z = l_n_minus_one.evaluate_at(&worker, z); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + let aggregation_challenge = transcript.get_challenge(); + + // let shifted_opening_aggregation_challenge = transcript.get_challenge(); + + // this is a sanity check + { + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + assert_eq!(t_at_z, t_1, "sanity check failed"); + } + + // we do NOT compute linearization polynomial for non-homomorphic case + + let mut z_by_omega = z; + z_by_omega.mul_assign(&z_1.omega); + + let opening_polynomials = vec![ + &a_poly, + &b_poly, + &c_poly, + &q_l, + &q_r, + &q_o, + &q_m, + &q_c, + &s_id, + &sigma_1, + &sigma_2, + &sigma_3, + &z_1, + &z_2, + &z_1, + &z_2, + ]; + + let degrees: Vec = opening_polynomials.iter().map(|el| el.size()).collect(); + + let precomputations = Some(vec![ + a_aux_data.as_ref().expect("is some"), + b_aux_data.as_ref().expect("is some"), + c_aux_data.as_ref().expect("is some"), + aux.q_l_aux.as_ref().expect("is some"), + aux.q_r_aux.as_ref().expect("is some"), + aux.q_o_aux.as_ref().expect("is some"), + aux.q_m_aux.as_ref().expect("is some"), + aux.q_c_aux.as_ref().expect("is some"), + aux.s_id_aux.as_ref().expect("is some"), + aux.sigma_1_aux.as_ref().expect("is some"), + aux.sigma_2_aux.as_ref().expect("is some"), + aux.sigma_3_aux.as_ref().expect("is some"), + z_1_aux.as_ref().expect("is some"), + z_2_aux.as_ref().expect("is some"), + z_1_aux.as_ref().expect("is some"), + z_2_aux.as_ref().expect("is some"), + ]); + + let opening_values = vec![ + a_at_z, + b_at_z, + c_at_z, + q_l_at_z, + q_r_at_z, + q_o_at_z, + q_m_at_z, + q_c_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + z_1_at_z, + z_2_at_z, + z_1_shifted_at_z, + z_2_shifted_at_z + ]; + + let opening_points = vec![ + z, + z, + z, + + z, + z, + z, + z, + z, + + z, + z, + z, + z, + + z, + z, + + z_by_omega, + z_by_omega + ]; + + let multiopen_proof = committer.open_multiple( + opening_polynomials, + degrees, + aggregation_challenge, + opening_points, + opening_values, + &precomputations, + &mut transcript + ); + + let t_opening_proof = large_committer.open_single( + &t_poly, + z, + t_at_z, + &t_aux.as_ref(), + &mut transcript + ); + + + + // let opening_polynomials = vec![ + // &z_1, + // &z_2, + // ]; + + // let degrees: Vec = opening_polynomials.iter().map(|el| el.size()).collect(); + + // let precomputations = Some(vec![ + // z_1_aux.as_ref().expect("is some"), + // z_2_aux.as_ref().expect("is some"), + // ]); + + // let opening_values = vec![ + // z_1_shifted_at_z, + // z_2_shifted_at_z + // ]; + + + + // let shifted_proof = committer.open_multiple( + // opening_polynomials, + // degrees, + // shifted_opening_aggregation_challenge, + // opening_point, + // opening_values, + // &precomputations, + // &mut transcript + // ); + + let proof = PlonkNonhomomorphicProof:: { + a_opening_value: a_at_z, + b_opening_value: b_at_z, + c_opening_value: c_at_z, + q_l_opening_value: q_l_at_z, + q_r_opening_value: q_r_at_z, + q_o_opening_value: q_o_at_z, + q_m_opening_value: q_m_at_z, + q_c_opening_value: q_c_at_z, + s_id_opening_value: s_id_at_z, + sigma_1_opening_value: sigma_1_at_z, + sigma_2_opening_value: sigma_2_at_z, + sigma_3_opening_value: sigma_3_at_z, + z_1_unshifted_opening_value: z_1_at_z, + z_2_unshifted_opening_value: z_2_at_z, + z_1_shifted_opening_value: z_1_shifted_at_z, + z_2_shifted_opening_value: z_2_shifted_at_z, + t_opening_value: t_at_z, + a_commitment: a_commitment, + b_commitment: b_commitment, + c_commitment: c_commitment, + z_1_commitment: z_1_commitment, + z_2_commitment: z_2_commitment, + t_commitment: t_commitment, + openings_proof: multiopen_proof, + // shifted_openings_proof: shifted_proof, + t_opening_proof: t_opening_proof, + }; + + Ok(proof) +} + +pub fn prove_nonhomomorphic_chunked, T: Transcript, C: Circuit>( + circuit: &C, + aux: &PlonkSetupAuxData, + meta: S::Meta, +) -> Result, SynthesisError> { + assert!(S::IS_HOMOMORPHIC == false); + + let mut assembly = ProvingAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let num_gates = assembly.num_gates(); + + let committer = S::new_for_size(num_gates.next_power_of_two(), meta); + + let worker = Worker::new(); + + let mut transcript = T::new(); + + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + println!("Start work with polynomials"); + + let (w_l, w_r, w_o) = assembly.make_wire_assingments(); + + let w_l = Polynomial::::from_values_unpadded(w_l)?; + let w_r = Polynomial::::from_values_unpadded(w_r)?; + let w_o = Polynomial::::from_values_unpadded(w_o)?; + + let a_poly = w_l.clone_padded_to_domain()?.ifft(&worker); + let b_poly = w_r.clone_padded_to_domain()?.ifft(&worker); + let c_poly = w_o.clone_padded_to_domain()?.ifft(&worker); + + let (a_commitment, a_aux_data) = committer.commit_single(&a_poly); + let (b_commitment, b_aux_data) = committer.commit_single(&b_poly); + let (c_commitment, c_aux_data) = committer.commit_single(&c_poly); + + transcript.commit_input(&a_commitment); + transcript.commit_input(&b_commitment); + transcript.commit_input(&c_commitment); + + // TODO: Add public inputs + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut w_l_plus_gamma = w_l.clone(); + w_l_plus_gamma.add_constant(&worker, &gamma); + + let mut w_r_plus_gamma = w_r.clone(); + w_r_plus_gamma.add_constant(&worker, &gamma); + + let mut w_o_plus_gamma = w_o.clone(); + w_o_plus_gamma.add_constant(&worker, &gamma); + + let z_1 = { + let n = assembly.input_gates.len() + assembly.aux_gates.len(); + let s_id_1: Vec<_> = (1..=n).collect(); + let s_id_1 = convert_to_field_elements(&s_id_1, &worker); + let s_id_1 = Polynomial::::from_values_unpadded(s_id_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &s_id_1, &beta); + drop(s_id_1); + + let s_id_2: Vec<_> = ((n+1)..=(2*n)).collect(); + let s_id_2 = convert_to_field_elements(&s_id_2, &worker); + let s_id_2 = Polynomial::::from_values_unpadded(s_id_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &s_id_2, &beta); + drop(s_id_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let s_id_3: Vec<_> = ((2*n+1)..=(3*n)).collect(); + let s_id_3 = convert_to_field_elements(&s_id_3, &worker); + let s_id_3 = Polynomial::::from_values_unpadded(s_id_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &s_id_3, &beta); + drop(s_id_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + Polynomial::::from_values(prepadded)? + }; + + let z_2 = { + let (sigma_1, sigma_2, sigma_3) = assembly.calculate_permutations_as_in_a_paper(); + + let sigma_1 = convert_to_field_elements(&sigma_1, &worker); + let sigma_1 = Polynomial::::from_values_unpadded(sigma_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &sigma_1, &beta); + drop(sigma_1); + + let sigma_2 = convert_to_field_elements(&sigma_2, &worker); + let sigma_2 = Polynomial::::from_values_unpadded(sigma_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &sigma_2, &beta); + drop(sigma_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let sigma_3 = convert_to_field_elements(&sigma_3, &worker); + let sigma_3 = Polynomial::::from_values_unpadded(sigma_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &sigma_3, &beta); + drop(sigma_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + let z_2 = Polynomial::::from_values(prepadded)?; + + z_2 + }; + + let z_1 = z_1.ifft(&worker); + let z_2 = z_2.ifft(&worker); + + let (z_1_commitment, z_1_aux) = committer.commit_single(&z_1); + let (z_2_commitment, z_2_aux) = committer.commit_single(&z_2); + + transcript.commit_input(&z_1_commitment); + transcript.commit_input(&z_2_commitment); + + let mut z_1_shifted = z_1.clone(); + z_1_shifted.distribute_powers(&worker, z_1.omega); + + let mut z_2_shifted = z_2.clone(); + z_2_shifted.distribute_powers(&worker, z_2.omega); + + let a_lde = a_poly.clone().coset_lde(&worker, 4)?; + let b_lde = b_poly.clone().coset_lde(&worker, 4)?; + let c_lde = c_poly.clone().coset_lde(&worker, 4)?; + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let q_l_lde = q_l.clone().coset_lde(&worker, 4)?; + let q_r_lde = q_r.clone().coset_lde(&worker, 4)?; + let q_o_lde = q_o.clone().coset_lde(&worker, 4)?; + let q_m_lde = q_m.clone().coset_lde(&worker, 4)?; + let q_c_lde = q_c.clone().coset_lde(&worker, 4)?; + let s_id_lde = s_id.clone().coset_lde(&worker, 4)?; + let sigma_1_lde = sigma_1.clone().coset_lde(&worker, 4)?; + let sigma_2_lde = sigma_2.clone().coset_lde(&worker, 4)?; + let sigma_3_lde = sigma_3.clone().coset_lde(&worker, 4)?; + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + let mut vanishing_poly_inverse = assembly.calculate_inverse_vanishing_polynomial_in_a_coset(&worker, q_c_lde.size(), required_domain_size.next_power_of_two())?; + + let mut t_1 = { + let mut t_1 = q_c_lde; + + let mut q_l_by_a = q_l_lde; + q_l_by_a.mul_assign(&worker, &a_lde); + t_1.add_assign(&worker, &q_l_by_a); + drop(q_l_by_a); + + let mut q_r_by_b = q_r_lde; + q_r_by_b.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_r_by_b); + drop(q_r_by_b); + + let mut q_o_by_c = q_o_lde; + q_o_by_c.mul_assign(&worker, &c_lde); + t_1.add_assign(&worker, &q_o_by_c); + drop(q_o_by_c); + + let mut q_m_by_ab = q_m_lde; + q_m_by_ab.mul_assign(&worker, &a_lde); + q_m_by_ab.mul_assign(&worker, &b_lde); + t_1.add_assign(&worker, &q_m_by_ab); + drop(q_m_by_ab); + + vanishing_poly_inverse.scale(&worker, alpha); + + t_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1 + }; + + let z_1_lde = z_1.clone().coset_lde(&worker, 4)?; + + let z_1_shifted_lde = z_1_shifted.clone().coset_lde(&worker, 4)?; + + let z_2_lde = z_2.clone().coset_lde(&worker, 4)?; + + let z_2_shifted_lde = z_2_shifted.clone().coset_lde(&worker, 4)?; + + { + // TODO: May be optimize number of additions + let mut contrib_z_1 = z_1_lde.clone(); + + let mut s_id_by_beta = s_id_lde; + s_id_by_beta.scale(&worker, beta); + + let mut n_by_beta = n_fe; + n_by_beta.mul_assign(&beta); + + let mut a_perm = s_id_by_beta.clone(); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_1.mul_assign(&worker, &a_perm); + drop(a_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut b_perm = s_id_by_beta.clone(); + + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_1.mul_assign(&worker, &b_perm); + drop(b_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut c_perm = s_id_by_beta; + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_1.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_1.sub_assign(&worker, &z_1_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_1.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_1); + } + + { + // TODO: May be optimize number of additions + let mut contrib_z_2 = z_2_lde.clone(); + + let mut a_perm = sigma_1_lde; + a_perm.scale(&worker, beta); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_lde); + contrib_z_2.mul_assign(&worker, &a_perm); + drop(a_perm); + + + let mut b_perm = sigma_2_lde; + b_perm.scale(&worker, beta); + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_lde); + contrib_z_2.mul_assign(&worker, &b_perm); + drop(b_perm); + + let mut c_perm = sigma_3_lde; + c_perm.scale(&worker, beta); + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_lde); + contrib_z_2.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_2.sub_assign(&worker, &z_2_shifted_lde); + + vanishing_poly_inverse.scale(&worker, alpha); + + contrib_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &contrib_z_2); + } + + drop(a_lde); + drop(b_lde); + drop(c_lde); + + let l_0 = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), 0)?; + let l_n_minus_one = assembly.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), n-1)?; + + { + let mut z_1_minus_z_2_shifted = z_1_shifted_lde.clone(); + z_1_minus_z_2_shifted.sub_assign(&worker, &z_2_shifted_lde); + + let l = l_n_minus_one.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2_shifted.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2_shifted.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2_shifted); + } + + { + let mut z_1_minus_z_2= z_1_lde.clone(); + z_1_minus_z_2.sub_assign(&worker, &z_2_lde); + + let l = l_0.clone().coset_lde(&worker, 4)?; + + z_1_minus_z_2.mul_assign(&worker, &l); + drop(l); + + vanishing_poly_inverse.scale(&worker, alpha); + + z_1_minus_z_2.mul_assign(&worker, &vanishing_poly_inverse); + + t_1.add_assign(&worker, &z_1_minus_z_2); + } + + let t_poly = t_1.icoset_fft(&worker); + + println!("End work with polynomials"); + + let mut t_poly_parts = t_poly.break_into_multiples(required_domain_size)?; + + t_poly_parts.pop().expect("last part is irrelevant"); + let t_poly_high = t_poly_parts.pop().expect("high exists"); + let t_poly_mid = t_poly_parts.pop().expect("mid exists"); + let t_poly_low = t_poly_parts.pop().expect("low exists"); + + let (t_low_commitment, t_low_aux) = committer.commit_single(&t_poly_low); + let (t_mid_commitment, t_mid_aux) = committer.commit_single(&t_poly_mid); + let (t_high_commitment, t_high_aux) = committer.commit_single(&t_poly_high); + + transcript.commit_input(&t_low_commitment); + transcript.commit_input(&t_mid_commitment); + transcript.commit_input(&t_high_commitment); + + let z = transcript.get_challenge(); + + let a_at_z = a_poly.evaluate_at(&worker, z); + let b_at_z = b_poly.evaluate_at(&worker, z); + let c_at_z = c_poly.evaluate_at(&worker, z); + + let q_l_at_z = q_l.evaluate_at(&worker, z); + let q_r_at_z = q_r.evaluate_at(&worker, z); + let q_o_at_z = q_o.evaluate_at(&worker, z); + let q_m_at_z = q_m.evaluate_at(&worker, z); + let q_c_at_z = q_c.evaluate_at(&worker, z); + + let s_id_at_z = s_id.evaluate_at(&worker, z); + let sigma_1_at_z = sigma_1.evaluate_at(&worker, z); + let sigma_2_at_z = sigma_2.evaluate_at(&worker, z); + let sigma_3_at_z = sigma_3.evaluate_at(&worker, z); + + let mut inverse_vanishing_at_z = assembly.evaluate_inverse_vanishing_poly(required_domain_size.next_power_of_two(), z); + + let z_1_at_z = z_1.evaluate_at(&worker, z); + let z_2_at_z = z_2.evaluate_at(&worker, z); + + let z_1_shifted_at_z = z_1_shifted.evaluate_at(&worker, z); + let z_2_shifted_at_z = z_2_shifted.evaluate_at(&worker, z); + + let t_low_at_z = t_poly_low.evaluate_at(&worker, z); + let t_mid_at_z = t_poly_mid.evaluate_at(&worker, z); + let t_high_at_z = t_poly_high.evaluate_at(&worker, z); + + let l_0_at_z = l_0.evaluate_at(&worker, z); + let l_n_minus_one_at_z = l_n_minus_one.evaluate_at(&worker, z); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_low_at_z); + transcript.commit_field_element(&t_mid_at_z); + transcript.commit_field_element(&t_high_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + let aggregation_challenge = transcript.get_challenge(); + + let z_in_pow_of_domain_size = z.pow([required_domain_size as u64]); + + // this is a sanity check + { + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + let mut t_at_z = E::Fr::zero(); + t_at_z.add_assign(&t_low_at_z); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&t_mid_at_z); + t_at_z.add_assign(&tmp); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&z_in_pow_of_domain_size); + tmp.mul_assign(&t_high_at_z); + t_at_z.add_assign(&tmp); + + assert_eq!(t_at_z, t_1, "sanity check failed"); + } + + // we do NOT compute linearization polynomial for non-homomorphic case + + let mut z_by_omega = z; + z_by_omega.mul_assign(&z_1.omega); + + let opening_polynomials = vec![ + &a_poly, + &b_poly, + &c_poly, + &q_l, + &q_r, + &q_o, + &q_m, + &q_c, + &s_id, + &sigma_1, + &sigma_2, + &sigma_3, + &z_1, + &z_2, + &z_1, + &z_2, + &t_poly_low, + &t_poly_mid, + &t_poly_high + ]; + + let degrees: Vec = opening_polynomials.iter().map(|el| el.size()).collect(); + + let precomputations = Some(vec![ + a_aux_data.as_ref().expect("is some"), + b_aux_data.as_ref().expect("is some"), + c_aux_data.as_ref().expect("is some"), + aux.q_l_aux.as_ref().expect("is some"), + aux.q_r_aux.as_ref().expect("is some"), + aux.q_o_aux.as_ref().expect("is some"), + aux.q_m_aux.as_ref().expect("is some"), + aux.q_c_aux.as_ref().expect("is some"), + aux.s_id_aux.as_ref().expect("is some"), + aux.sigma_1_aux.as_ref().expect("is some"), + aux.sigma_2_aux.as_ref().expect("is some"), + aux.sigma_3_aux.as_ref().expect("is some"), + z_1_aux.as_ref().expect("is some"), + z_2_aux.as_ref().expect("is some"), + z_1_aux.as_ref().expect("is some"), + z_2_aux.as_ref().expect("is some"), + t_low_aux.as_ref().expect("is some"), + t_mid_aux.as_ref().expect("is some"), + t_high_aux.as_ref().expect("is some"), + ]); + + let opening_values = vec![ + a_at_z, + b_at_z, + c_at_z, + q_l_at_z, + q_r_at_z, + q_o_at_z, + q_m_at_z, + q_c_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + z_1_at_z, + z_2_at_z, + z_1_shifted_at_z, + z_2_shifted_at_z, + t_low_at_z, + t_mid_at_z, + t_high_at_z, + ]; + + let opening_points = vec![ + z, + z, + z, + + z, + z, + z, + z, + z, + + z, + z, + z, + z, + + z, + z, + + z_by_omega, + z_by_omega, + + z, + z, + z, + ]; + + let multiopen_proof = committer.open_multiple( + opening_polynomials, + degrees, + aggregation_challenge, + opening_points, + opening_values, + &precomputations, + &mut transcript + ); + + let proof = PlonkChunkedNonhomomorphicProof:: { + a_opening_value: a_at_z, + b_opening_value: b_at_z, + c_opening_value: c_at_z, + q_l_opening_value: q_l_at_z, + q_r_opening_value: q_r_at_z, + q_o_opening_value: q_o_at_z, + q_m_opening_value: q_m_at_z, + q_c_opening_value: q_c_at_z, + s_id_opening_value: s_id_at_z, + sigma_1_opening_value: sigma_1_at_z, + sigma_2_opening_value: sigma_2_at_z, + sigma_3_opening_value: sigma_3_at_z, + z_1_unshifted_opening_value: z_1_at_z, + z_2_unshifted_opening_value: z_2_at_z, + z_1_shifted_opening_value: z_1_shifted_at_z, + z_2_shifted_opening_value: z_2_shifted_at_z, + t_low_opening_value: t_low_at_z, + t_mid_opening_value: t_mid_at_z, + t_high_opening_value: t_high_at_z, + a_commitment: a_commitment, + b_commitment: b_commitment, + c_commitment: c_commitment, + z_1_commitment: z_1_commitment, + z_2_commitment: z_2_commitment, + t_low_commitment: t_low_commitment, + t_mid_commitment: t_mid_commitment, + t_high_commitment: t_high_commitment, + openings_proof: multiopen_proof, + }; + + Ok(proof) +} + +#[cfg(test)] +mod test { + + use super::*; + use crate::pairing::ff::{Field, PrimeField}; + use crate::pairing::{Engine}; + + use crate::{SynthesisError}; + use std::marker::PhantomData; + + use crate::plonk::cs::gates::*; + use crate::plonk::cs::*; + + struct TestCircuit{ + _marker: PhantomData + } + + impl Circuit for TestCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + println!("A = {:?}", a); + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + println!("B = {:?}", b); + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + println!("C = {:?}", c); + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + cs.enforce_zero_2((a, b), (two, negative_one))?; + + let ten = E::Fr::from_str("10").unwrap(); + cs.enforce_zero_2((b, c), (ten, negative_one))?; + + cs.enforce_mul_3((a, b, c))?; + + Ok(()) + } + } + + #[test] + fn test_trivial_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + + let mut assembly = ProvingAssembly::::new(); + + let circuit = TestCircuit:: { + _marker: PhantomData + }; + + circuit.synthesize(&mut assembly).expect("must work"); + + println!("{:?}", assembly); + + assembly.finalize(); + + let (f_l, f_r, f_o) = assembly.make_wire_assingments(); + + let (sigma_1, sigma_2, sigma_3) = assembly.calculate_permutations_as_in_a_paper(); + + let num_gates = assembly.num_gates(); + + let id_1: Vec<_> = (1..=num_gates).collect(); + let id_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let id_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let beta = Fr::from_str("15").unwrap(); + let gamma = Fr::from_str("4").unwrap(); + + let mut f_1_poly = vec![]; + let mut g_1_poly = vec![]; + for (i, el) in f_l.iter().enumerate() { + let mut tmp = Fr::from_str(&id_1[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_1_poly.push(tmp); + } + + for (i, el) in f_l.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_1[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_1_poly.push(tmp); + } + + let mut f_2_poly = vec![]; + let mut g_2_poly = vec![]; + for (i, el) in f_r.iter().enumerate() { + let mut tmp = Fr::from_str(&id_2[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_2_poly.push(tmp); + } + + for (i, el) in f_r.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_2[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_2_poly.push(tmp); + } + + + let mut f_3_poly = vec![]; + let mut g_3_poly = vec![]; + for (i, el) in f_o.iter().enumerate() { + let mut tmp = Fr::from_str(&id_3[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + f_3_poly.push(tmp); + } + + for (i, el) in f_o.iter().enumerate() { + let mut tmp = Fr::from_str(&sigma_3[i].to_string()).unwrap(); + tmp.mul_assign(&beta); + tmp.add_assign(&gamma); + tmp.add_assign(&el); + g_3_poly.push(tmp); + } + + let mut f_poly = vec![]; + let mut g_poly = vec![]; + + for i in 0..f_1_poly.len() { + let mut tmp = f_1_poly[i]; + tmp.mul_assign(&f_2_poly[i]); + tmp.mul_assign(&f_3_poly[i]); + f_poly.push(tmp); + } + + for i in 0..g_1_poly.len() { + let mut tmp = g_1_poly[i]; + tmp.mul_assign(&g_2_poly[i]); + tmp.mul_assign(&g_3_poly[i]); + g_poly.push(tmp); + } + + let mut tmp = Fr::one(); + let mut f_prime = vec![tmp]; + for el in f_poly.iter() { + tmp.mul_assign(&el); + f_prime.push(tmp); + } + + let mut tmp = Fr::one(); + let mut g_prime = vec![tmp]; + for el in g_poly.iter() { + tmp.mul_assign(&el); + g_prime.push(tmp); + } + + assert!(f_prime[0] == g_prime[0]); + assert!(f_prime[num_gates] == g_prime[num_gates]); + + let worker = Worker::new(); + + let _ = assembly.output_setup_polynomials(&worker).unwrap(); + } +} \ No newline at end of file diff --git a/src/plonk/redshift/generator.rs b/src/plonk/redshift/generator.rs new file mode 100644 index 000000000..03dd764f6 --- /dev/null +++ b/src/plonk/redshift/generator.rs @@ -0,0 +1,605 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use crate::plonk::polynomials::*; +use crate::plonk::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::utils::*; + +use super::prover::ProvingAssembly; + +#[derive(Debug)] +struct GeneratorAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + inputs_map: Vec, + + is_finalized: bool, +} + +impl ConstraintSystem for GeneratorAssembly { + // const ZERO: Variable = Variable(Index::Aux(1)); + // const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_aux += 1; + let index = self.num_aux; + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, _value: F) -> Result + where + F: FnOnce() -> Result + { + self.num_inputs += 1; + let index = self.num_inputs; + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), + coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl GeneratorAssembly { + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + pub(crate) fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + inputs_map: vec![], + + is_finalized: false, + + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + // match (zero, >::ZERO) { + // (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + // _ => panic!("zero variable is incorrect") + // } + + // match (one, >::ONE) { + // (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + // _ => panic!("one variable is incorrect") + // } + + match (tmp.dummy_variable(), zero) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + // >::ZERO + Variable(Index::Aux(1)) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: &Coeff) -> F { + match coeff { + Coeff::Zero => { + F::zero() + }, + Coeff::One => { + F::one() + }, + Coeff::NegativeOne => { + let mut tmp = F::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element::(&gate.q_l); + *q_r = coeff_into_field_element::(&gate.q_r); + *q_o = coeff_into_field_element::(&gate.q_o); + *q_m = coeff_into_field_element::(&gate.q_m); + *q_c = coeff_into_field_element::(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + assert!(self.is_finalized); + + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub(crate) fn num_gates(&self) -> usize { + self.input_gates.len() + self.aux_gates.len() + } + + fn finalize(&mut self) { + if self.is_finalized { + return; + } + + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + let n = self.input_gates.len() + self.aux_gates.len(); + assert!((n+1).is_power_of_two()); + + self.is_finalized = true; + } +} + +use super::prover::*; +use crate::plonk::fft::cooley_tukey_ntt::CTPrecomputations; +use crate::plonk::commitments::transparent::fri::coset_combining_fri::*; +use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; +use crate::plonk::commitments::transparent::iop_compiler::*; +use crate::plonk::commitments::transparent::iop_compiler::coset_combining_blake2s_tree::*; +use crate::plonk::transparent_engine::PartialTwoBitReductionField; + +use crate::plonk::commitments::transcript::*; + +pub fn setup_with_precomputations, CP: CTPrecomputations, T: Transcript as IopInstance> :: Commitment> >( + circuit: &C, + params: &RedshiftParameters, + omegas_bitreversed: &CP, + ) -> Result<(RedshiftSetup>, RedshiftSetupPrecomputation>), SynthesisError> + where E::Fr : PartialTwoBitReductionField +{ + let mut assembly = GeneratorAssembly::::new(); + circuit.synthesize(&mut assembly)?; + assembly.finalize(); + + let n = assembly.num_gates(); + + let worker = Worker::new(); + + let mut transcript = T::new(); + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = assembly.output_setup_polynomials(&worker)?; + + let q_l_commitment_data = ProvingAssembly::::commit_single_poly(&q_l, omegas_bitreversed, ¶ms, &worker)?; + let q_r_commitment_data = ProvingAssembly::::commit_single_poly(&q_r, omegas_bitreversed, ¶ms, &worker)?; + let q_o_commitment_data = ProvingAssembly::::commit_single_poly(&q_o, omegas_bitreversed, ¶ms, &worker)?; + let q_m_commitment_data = ProvingAssembly::::commit_single_poly(&q_m, omegas_bitreversed, ¶ms, &worker)?; + let q_c_commitment_data = ProvingAssembly::::commit_single_poly(&q_c, omegas_bitreversed, ¶ms, &worker)?; + let s_id_commitment_data = ProvingAssembly::::commit_single_poly(&s_id, omegas_bitreversed, ¶ms, &worker)?; + let sigma_1_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_1, omegas_bitreversed, ¶ms, &worker)?; + let sigma_2_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_2, omegas_bitreversed, ¶ms, &worker)?; + let sigma_3_commitment_data = ProvingAssembly::::commit_single_poly(&sigma_3, omegas_bitreversed, ¶ms, &worker)?; + + transcript.commit_input(&q_l_commitment_data.oracle.get_commitment()); + transcript.commit_input(&q_r_commitment_data.oracle.get_commitment()); + transcript.commit_input(&q_o_commitment_data.oracle.get_commitment()); + transcript.commit_input(&q_m_commitment_data.oracle.get_commitment()); + transcript.commit_input(&q_c_commitment_data.oracle.get_commitment()); + transcript.commit_input(&s_id_commitment_data.oracle.get_commitment()); + transcript.commit_input(&sigma_1_commitment_data.oracle.get_commitment()); + transcript.commit_input(&sigma_2_commitment_data.oracle.get_commitment()); + transcript.commit_input(&sigma_3_commitment_data.oracle.get_commitment()); + + let setup_point = transcript.get_challenge(); + + let q_l_setup_value = q_l.evaluate_at(&worker, setup_point); + let q_r_setup_value = q_r.evaluate_at(&worker, setup_point); + let q_o_setup_value = q_o.evaluate_at(&worker, setup_point); + let q_m_setup_value = q_m.evaluate_at(&worker, setup_point); + let q_c_setup_value = q_c.evaluate_at(&worker, setup_point); + + let s_id_setup_value = s_id.evaluate_at(&worker, setup_point); + let sigma_1_setup_value = sigma_1.evaluate_at(&worker, setup_point); + let sigma_2_setup_value = sigma_2.evaluate_at(&worker, setup_point); + let sigma_3_setup_value = sigma_3.evaluate_at(&worker, setup_point); + + let setup = RedshiftSetup::> { + n: n, + q_l: q_l_commitment_data.oracle.get_commitment(), + q_r: q_r_commitment_data.oracle.get_commitment(), + q_o: q_o_commitment_data.oracle.get_commitment(), + q_m: q_m_commitment_data.oracle.get_commitment(), + q_c: q_c_commitment_data.oracle.get_commitment(), + s_id: s_id_commitment_data.oracle.get_commitment(), + sigma_1: sigma_1_commitment_data.oracle.get_commitment(), + sigma_2: sigma_2_commitment_data.oracle.get_commitment(), + sigma_3: sigma_3_commitment_data.oracle.get_commitment(), + }; + + let precomputation = RedshiftSetupPrecomputation::> { + q_l_aux: SinglePolySetupData::> { + poly: q_l_commitment_data.poly, + oracle: q_l_commitment_data.oracle, + setup_point: setup_point, + setup_value: q_l_setup_value, + }, + q_r_aux: SinglePolySetupData::> { + poly: q_r_commitment_data.poly, + oracle: q_r_commitment_data.oracle, + setup_point: setup_point, + setup_value: q_r_setup_value, + }, + q_o_aux: SinglePolySetupData::> { + poly: q_o_commitment_data.poly, + oracle: q_o_commitment_data.oracle, + setup_point: setup_point, + setup_value: q_o_setup_value, + }, + q_m_aux: SinglePolySetupData::> { + poly: q_m_commitment_data.poly, + oracle: q_m_commitment_data.oracle, + setup_point: setup_point, + setup_value: q_m_setup_value, + }, + q_c_aux: SinglePolySetupData::> { + poly: q_c_commitment_data.poly, + oracle: q_c_commitment_data.oracle, + setup_point: setup_point, + setup_value: q_c_setup_value, + }, + s_id_aux: SinglePolySetupData::> { + poly: s_id_commitment_data.poly, + oracle: s_id_commitment_data.oracle, + setup_point: setup_point, + setup_value: s_id_setup_value, + }, + sigma_1_aux: SinglePolySetupData::> { + poly: sigma_1_commitment_data.poly, + oracle: sigma_1_commitment_data.oracle, + setup_point: setup_point, + setup_value: sigma_1_setup_value, + }, + sigma_2_aux: SinglePolySetupData::> { + poly: sigma_2_commitment_data.poly, + oracle: sigma_2_commitment_data.oracle, + setup_point: setup_point, + setup_value: sigma_2_setup_value, + }, + sigma_3_aux: SinglePolySetupData::> { + poly: sigma_3_commitment_data.poly, + oracle: sigma_3_commitment_data.oracle, + setup_point: setup_point, + setup_value: sigma_3_setup_value, + }, + }; + + Ok((setup, precomputation)) +} \ No newline at end of file diff --git a/src/plonk/redshift/mod.rs b/src/plonk/redshift/mod.rs new file mode 100644 index 000000000..7f715c69d --- /dev/null +++ b/src/plonk/redshift/mod.rs @@ -0,0 +1,2 @@ +mod prover; +mod generator; \ No newline at end of file diff --git a/src/plonk/redshift/prover.rs b/src/plonk/redshift/prover.rs new file mode 100644 index 000000000..0516951e9 --- /dev/null +++ b/src/plonk/redshift/prover.rs @@ -0,0 +1,1912 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; +use crate::plonk::transparent_engine::TransparentEngine; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use crate::plonk::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; +use crate::plonk::polynomials::*; + +#[derive(Debug)] +pub(crate) struct ProvingAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + inputs_map: Vec, + + is_finalized: bool +} + +impl ConstraintSystem for ProvingAssembly { + // const ZERO: Variable = Variable(Index::Aux(1)); + // const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + // let gate = Gate::::new_enforce_constant_gate(input_var, Some(value), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), + coeffs:(E::Fr,E::Fr,E::Fr,E::Fr,E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } + + fn get_dummy_variable(&self) -> Variable { + self.dummy_variable() + } +} + +impl ProvingAssembly { + pub(crate) fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + inputs_map: vec![], + + is_finalized: false, + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + // let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + // tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + // match (zero, >::ZERO) { + // (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + // _ => panic!("zero variable is incorrect") + // } + + // match (one, >::ONE) { + // (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + // _ => panic!("one variable is incorrect") + // } + + match (tmp.dummy_variable(), zero) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + fn new_empty_gate(&mut self) -> usize { + self.n += 1; + let index = self.n; + + self.aux_gates.push(Gate::::empty()); + + index + } + + fn set_gate(&mut self, gate: Gate, index: usize) { + self.aux_gates[index-1] = gate; + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + // >::ZERO + Variable(Index::Aux(1)) + } + + pub(crate) fn make_wire_assingments(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + // create a vector of gate assingments + // if a_i = j then w_j = f_l(g^i) + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut f_l = vec![E::Fr::zero(); total_num_gates]; + let mut f_r = vec![E::Fr::zero(); total_num_gates]; + let mut f_o = vec![E::Fr::zero(); total_num_gates]; + + for (i, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + f_l[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_l[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + f_r[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_r[i] = self.aux_assingments[index - 1]; + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + f_o[i] = self.input_assingments[index - 1]; + }, + Variable(Index::Aux(index)) => { + f_o[i] = self.aux_assingments[index - 1]; + }, + } + } + + (f_l, f_r, f_o) + } + + pub(crate) fn make_circuit_description_polynomials(&self, worker: &Worker) -> Result<( + Polynomial::, Polynomial::, Polynomial::, + Polynomial::, Polynomial:: + ), SynthesisError> { + assert!(self.is_finalized); + + let total_num_gates = self.input_gates.len() + self.aux_gates.len(); + let mut q_l = vec![E::Fr::zero(); total_num_gates]; + let mut q_r = vec![E::Fr::zero(); total_num_gates]; + let mut q_o = vec![E::Fr::zero(); total_num_gates]; + let mut q_m = vec![E::Fr::zero(); total_num_gates]; + let mut q_c = vec![E::Fr::zero(); total_num_gates]; + + fn coeff_into_field_element(coeff: & Coeff) -> F { + match coeff { + Coeff::Zero => { + F::zero() + }, + Coeff::One => { + F::one() + }, + Coeff::NegativeOne => { + let mut tmp = F::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.input_gates.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + + + let num_input_gates = self.input_gates.len(); + let q_l_aux = &mut q_l[num_input_gates..]; + let q_r_aux = &mut q_r[num_input_gates..]; + let q_o_aux = &mut q_o[num_input_gates..]; + let q_m_aux = &mut q_m[num_input_gates..]; + let q_c_aux = &mut q_c[num_input_gates..]; + + debug_assert!(self.aux_gates.len() == q_l_aux.len()); + + worker.scope(self.aux_gates.len(), |scope, chunk| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in self.aux_gates.chunks(chunk) + .zip(q_l_aux.chunks_mut(chunk)) + .zip(q_r_aux.chunks_mut(chunk)) + .zip(q_o_aux.chunks_mut(chunk)) + .zip(q_m_aux.chunks_mut(chunk)) + .zip(q_c_aux.chunks_mut(chunk)) + { + scope.spawn(move |_| { + for (((((gate, q_l), q_r), q_o), q_m), q_c) in gate.iter() + .zip(q_l.iter_mut()) + .zip(q_r.iter_mut()) + .zip(q_o.iter_mut()) + .zip(q_m.iter_mut()) + .zip(q_c.iter_mut()) + { + *q_l = coeff_into_field_element(&gate.q_l); + *q_r = coeff_into_field_element(&gate.q_r); + *q_o = coeff_into_field_element(&gate.q_o); + *q_m = coeff_into_field_element(&gate.q_m); + *q_c = coeff_into_field_element(&gate.q_c); + } + }); + } + }); + + let q_l = Polynomial::from_values(q_l)?; + let q_r = Polynomial::from_values(q_r)?; + let q_o = Polynomial::from_values(q_o)?; + let q_m = Polynomial::from_values(q_m)?; + let q_c = Polynomial::from_values(q_c)?; + + Ok((q_l, q_r, q_o, q_m, q_c)) + } + + pub(crate) fn calculate_permutations_as_in_a_paper(&self) -> (Vec, Vec, Vec) { + assert!(self.is_finalized); + + let num_gates = self.input_gates.len() + self.aux_gates.len(); + let num_partitions = self.num_inputs + self.num_aux; + let num_inputs = self.num_inputs; + // in the partition number i there is a set of indexes in V = (a, b, c) such that V_j = i + let mut partitions = vec![vec![]; num_partitions + 1]; + + for (j, gate) in self.input_gates.iter().chain(&self.aux_gates).enumerate() + { + match gate.a_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j+1); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j+1); + } + }, + } + + match gate.b_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + num_gates); + } + }, + } + + match gate.c_wire() { + Variable(Index::Input(index)) => { + let i = *index; + partitions[i].push(j + 1 + 2*num_gates); + }, + Variable(Index::Aux(index)) => { + if *index != 0 { + let i = index + num_inputs; + partitions[i].push(j + 1 + 2*num_gates); + } + }, + } + } + + let mut sigma_1: Vec<_> = (1..=num_gates).collect(); + let mut sigma_2: Vec<_> = ((num_gates+1)..=(2*num_gates)).collect(); + let mut sigma_3: Vec<_> = ((2*num_gates + 1)..=(3*num_gates)).collect(); + + let mut permutations = vec![vec![]; num_partitions + 1]; + + fn rotate(mut vec: Vec) -> Vec { + if vec.len() > 0 { + let els: Vec<_> = vec.drain(0..1).collect(); + vec.push(els[0]); + } + + vec + } + + for (i, partition) in partitions.into_iter().enumerate().skip(1) { + // copy-permutation should have a cycle around the partition + + let permutation = rotate(partition.clone()); + permutations[i] = permutation.clone(); + + for (original, new) in partition.into_iter() + .zip(permutation.into_iter()) + { + if original <= num_gates { + debug_assert!(sigma_1[original - 1] == original); + sigma_1[original - 1] = new; + } else if original <= 2*num_gates { + debug_assert!(sigma_2[original - num_gates - 1] == original); + sigma_2[original - num_gates - 1] = new; + } else { + debug_assert!(sigma_3[original - 2*num_gates - 1] == original); + sigma_3[original - 2*num_gates - 1] = new; + } + } + } + + (sigma_1, sigma_2, sigma_3) + } + + fn make_s_id(&self) -> Vec { + let size = self.input_gates.len() + self.aux_gates.len(); + let result: Vec<_> = (1..=size).collect(); + + result + } + + pub(crate) fn output_setup_polynomials(&self, worker: &Worker) -> Result< + ( + Polynomial::, // q_l + Polynomial::, // q_r + Polynomial::, // q_o + Polynomial::, // q_m + Polynomial::, // q_c + Polynomial::, // s_id + Polynomial::, // sigma_1 + Polynomial::, // sigma_2 + Polynomial::, // sigma_3 + ), SynthesisError> + { + assert!(self.is_finalized); + + let s_id = self.make_s_id(); + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let s_id = convert_to_field_elements::(&s_id, &worker); + let sigma_1 = convert_to_field_elements::(&sigma_1, &worker); + let sigma_2 = convert_to_field_elements::(&sigma_2, &worker); + let sigma_3 = convert_to_field_elements::(&sigma_3, &worker); + + let s_id = Polynomial::from_values(s_id)?; + let sigma_1 = Polynomial::from_values(sigma_1)?; + let sigma_2 = Polynomial::from_values(sigma_2)?; + let sigma_3 = Polynomial::from_values(sigma_3)?; + + let (q_l, q_r, q_o, q_m, q_c) = self.make_circuit_description_polynomials(&worker)?; + + let s_id = s_id.ifft(&worker); + let sigma_1 = sigma_1.ifft(&worker); + let sigma_2 = sigma_2.ifft(&worker); + let sigma_3 = sigma_3.ifft(&worker); + + let q_l = q_l.ifft(&worker); + let q_r = q_r.ifft(&worker); + let q_o = q_o.ifft(&worker); + let q_m = q_m.ifft(&worker); + let q_c = q_c.ifft(&worker); + + Ok((q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3)) + } + + pub(crate) fn num_gates(&self) -> usize { + assert!(self.is_finalized); + + self.input_gates.len() + self.aux_gates.len() + } + + fn finalize(&mut self) { + if self.is_finalized { + return; + } + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + self.is_finalized = true; + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + self.is_finalized = true; + } + + fn calculate_inverse_vanishing_polynomial_in_a_coset(&self, worker: &Worker, poly_size:usize, vahisning_size: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64)?; + let n_domain_omega = domain.generator; + let mut root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + root.negate(); + + let multiplicative_generator = E::Fr::multiplicative_generator(); + + let mut negative_one = E::Fr::one(); + negative_one.negate(); + + let mut numerator = Polynomial::::from_values(vec![multiplicative_generator; poly_size])?; + // evaluate X in linear time + + numerator.distribute_powers(&worker, numerator.omega); + numerator.add_constant(&worker, &root); + + // numerator.add_constant(&worker, &negative_one); + // now it's a series of values in a coset + + // now we should evaluate X^(n+1) - 1 in a linear time + + let shift = multiplicative_generator.pow([vahisning_size as u64]); + + let mut denominator = Polynomial::::from_values(vec![shift; poly_size])?; + + // elements are h^size - 1, (hg)^size - 1, (hg^2)^size - 1, ... + + denominator.distribute_powers(&worker, denominator.omega.pow([vahisning_size as u64])); + denominator.add_constant(&worker, &negative_one); + + denominator.batch_inversion(&worker)?; + + numerator.mul_assign(&worker, &denominator); + + Ok(numerator) + } + + fn evaluate_inverse_vanishing_poly(&self, vahisning_size: usize, point: E::Fr) -> E::Fr { + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("should fit"); + let n_domain_omega = domain.generator; + let root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + + let mut numerator = point; + numerator.sub_assign(&root); + + let mut denominator = point.pow([vahisning_size as u64]); + denominator.sub_assign(&E::Fr::one()); + + let denominator = denominator.inverse().expect("must exist"); + + numerator.mul_assign(&denominator); + + numerator + } + + fn calculate_lagrange_poly(&self, worker: &Worker, poly_size:usize, poly_number: usize) -> Result, SynthesisError> { + assert!(poly_size.is_power_of_two()); + assert!(poly_number < poly_size); + + let mut poly = Polynomial::::from_values(vec![E::Fr::zero(); poly_size])?; + + poly.as_mut()[poly_number] = E::Fr::one(); + + Ok(poly.ifft(&worker)) + } +} + +// pub struct RedshiftProof, FRI: FriIop>{ +// pub a_opening_value: F, +// pub b_opening_value: F, +// pub c_opening_value: F, +// pub q_l_opening_value: F, +// pub q_r_opening_value: F, +// pub q_o_opening_value: F, +// pub q_m_opening_value: F, +// pub q_c_opening_value: F, +// pub s_id_opening_value: F, +// pub sigma_1_opening_value: F, +// pub sigma_2_opening_value: F, +// pub sigma_3_opening_value: F, +// pub z_1_unshifted_opening_value: F, +// pub z_2_unshifted_opening_value: F, +// pub z_1_shifted_opening_value: F, +// pub z_2_shifted_opening_value: F, +// pub t_low_opening_value: F, +// pub t_mid_opening_value: F, +// pub t_high_opening_value: F, +// pub a_commitment: I::Commitment, +// pub b_commitment: I::Commitment, +// pub c_commitment: I::Commitment, +// pub z_1_commitment: I::Commitment, +// pub z_2_commitment: I::Commitment, +// pub t_low_commitment: I::Commitment, +// pub t_mid_commitment: I::Commitment, +// pub t_high_commitment: I::Commitment, +// pub openings_proof: FRI::Proof, +// } + +use crate::plonk::fft::cooley_tukey_ntt::CTPrecomputations; +use crate::plonk::commitments::transparent::fri::coset_combining_fri::*; +use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; +use crate::plonk::commitments::transparent::iop_compiler::*; +use crate::plonk::commitments::transparent::iop_compiler::coset_combining_blake2s_tree::*; +use crate::plonk::transparent_engine::PartialTwoBitReductionField; + +#[derive(Debug)] +pub struct RedshiftSetup>{ + pub n: usize, + pub q_l: I::Commitment, + pub q_r: I::Commitment, + pub q_o: I::Commitment, + pub q_m: I::Commitment, + pub q_c: I::Commitment, + pub s_id: I::Commitment, + pub sigma_1: I::Commitment, + pub sigma_2: I::Commitment, + pub sigma_3: I::Commitment, +} + +pub struct SinglePolySetupData>{ + pub poly: Polynomial, + pub oracle: I, + pub setup_point: F, + pub setup_value: F, +} + +pub struct SinglePolyCommitmentData>{ + pub poly: Polynomial, + pub oracle: I, +} + +// #[derive(Debug)] +pub struct RedshiftSetupPrecomputation>{ + pub q_l_aux: SinglePolySetupData, + pub q_r_aux: SinglePolySetupData, + pub q_o_aux: SinglePolySetupData, + pub q_m_aux: SinglePolySetupData, + pub q_c_aux: SinglePolySetupData, + pub s_id_aux: SinglePolySetupData, + pub sigma_1_aux: SinglePolySetupData, + pub sigma_2_aux: SinglePolySetupData, + pub sigma_3_aux: SinglePolySetupData, +} + +#[derive(Debug, Clone)] +pub struct RedshiftParameters{ + pub lde_factor: usize, + pub num_queries: usize, + pub output_coeffs_at_degree_plus_one: usize, + pub coset_params: CosetParams, +} + +struct WitnessOpeningRequest<'a, F: PrimeField> { + polynomials: Vec<&'a Polynomial>, + opening_point: F, + opening_values: Vec +} + +struct SetupOpeningRequest<'a, F: PrimeField> { + polynomials: Vec<&'a Polynomial>, + setup_point: F, + setup_values: Vec, + opening_point: F, + opening_values: Vec +} + +impl ProvingAssembly where E::Fr : PartialTwoBitReductionField { + pub(crate) fn commit_single_poly>( + poly: &Polynomial, + omegas_bitreversed: &CP, + params: &RedshiftParameters, + worker: &Worker + ) -> Result>, SynthesisError> { + let lde = poly.clone().bitreversed_lde_using_bitreversed_ntt_with_partial_reduction( + worker, + params.lde_factor, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + let oracle_params = FriSpecificBlake2sTreeParams { + values_per_leaf: (1 << params.coset_params.cosets_schedule[0]) + }; + + let oracle = FriSpecificBlake2sTree::create(&lde.as_ref(), &oracle_params); + + Ok(SinglePolyCommitmentData:: { + poly: lde, + oracle: oracle + }) + } + + // fn divide_single( + // poly: &[F], + // opening_point: F, + // ) -> Vec { + // // we are only interested in quotient without a reminder, so we actually don't need opening value + // let mut b = opening_point; + // b.negate(); + + // let mut q = vec![F::zero(); a.len()]; + + // let mut tmp = F::zero(); + // let mut found_one = false; + // for (q, r) in q.iter_mut().rev().skip(1).zip(a.iter().rev()) { + // if !found_one { + // if r.is_zero() { + // continue + // } else { + // found_one = true; + // } + // } + + // let mut lead_coeff = *r; + // lead_coeff.sub_assign(&tmp); + // *q = lead_coeff; + // tmp = lead_coeff; + // tmp.mul_assign(&b); + // } + + // q + // } + + fn multiopening, T: Transcript as IopInstance> :: Commitment> > + ( + witness_opening_requests: Vec>, + setup_opening_requests: Vec>, + omegas_inv_bitreversed: &P, + params: &RedshiftParameters, + worker: &Worker, + transcript: &mut T + ) -> Result<(), SynthesisError> { + let required_divisor_size = witness_opening_requests[0].polynomials[0].size(); + + let mut final_aggregate = Polynomial::from_values(vec![E::Fr::zero(); required_divisor_size])?; + + let mut precomputed_bitreversed_coset_divisor = Polynomial::from_values(vec![E::Fr::one(); required_divisor_size])?; + precomputed_bitreversed_coset_divisor.distribute_powers(&worker, precomputed_bitreversed_coset_divisor.omega); + precomputed_bitreversed_coset_divisor.scale(&worker, E::Fr::multiplicative_generator()); + precomputed_bitreversed_coset_divisor.bitreverse_enumeration(&worker); + + let mut scratch_space_numerator = final_aggregate.clone(); + let mut scratch_space_denominator = final_aggregate.clone(); + + let aggregation_challenge = transcript.get_challenge(); + + let mut alpha = E::Fr::one(); + + for witness_request in witness_opening_requests.iter() { + let z = witness_request.opening_point; + let mut minus_z = z; + minus_z.negate(); + scratch_space_denominator.reuse_allocation(&precomputed_bitreversed_coset_divisor); + scratch_space_denominator.add_constant(&worker, &minus_z); + scratch_space_denominator.batch_inversion(&worker)?; + for (poly, value) in witness_request.polynomials.iter().zip(witness_request.opening_values.iter()) { + scratch_space_numerator.reuse_allocation(&poly); + let mut v = *value; + v.negate(); + scratch_space_numerator.add_constant(&worker, &v); + scratch_space_numerator.mul_assign(&worker, &scratch_space_denominator); + if aggregation_challenge != E::Fr::one() { + scratch_space_numerator.scale(&worker, alpha); + } + + final_aggregate.add_assign(&worker, &scratch_space_numerator); + + alpha.mul_assign(&aggregation_challenge); + } + } + + for setup_request in setup_opening_requests.iter() { + // for now assume a single setup point per poly and setup point is the same for all polys + // (omega - y)(omega - z) = omega^2 - (z+y)*omega + zy + + let setup_point = setup_request.setup_point; + let opening_point = setup_request.opening_point; + + let mut t0 = setup_point; + t0.add_assign(&opening_point); + t0.negate(); + + let mut t1 = setup_point; + t1.mul_assign(&opening_point); + + scratch_space_denominator.reuse_allocation(&precomputed_bitreversed_coset_divisor); + worker.scope(scratch_space_denominator.as_ref().len(), |scope, chunk| { + for den in scratch_space_denominator.as_mut().chunks_mut(chunk) { + scope.spawn(move |_| { + for d in den.iter_mut() { + let mut result = *d; + result.square(); + result.add_assign(&t1); + + let mut tmp = t0; + tmp.mul_assign(&d); + + result.add_assign(&tmp); + + *d = result; + } + }); + } + }); + + scratch_space_denominator.batch_inversion(&worker)?; + + // each numerator must have a value removed of the polynomial that interpolates the following points: + // (setup_x, setup_y) + // (opening_x, opening_y) + // such polynomial is linear and has a form e.g setup_y + (X - setup_x) * (witness_y - setup_y) / (witness_x - setup_x) + + for ((poly, value), setup_value) in setup_request.polynomials.iter().zip(setup_request.opening_values.iter()).zip(setup_request.setup_values.iter()) { + scratch_space_numerator.reuse_allocation(&poly); + + let intercept = setup_value; + let mut t0 = opening_point; + t0.sub_assign(&setup_point); + + let mut slope = t0.inverse().expect("must exist"); + + let mut t1 = *value; + t1.sub_assign(&setup_value); + + slope.mul_assign(&t1); + + worker.scope(scratch_space_numerator.as_ref().len(), |scope, chunk| { + for (num, omega) in scratch_space_numerator.as_mut().chunks_mut(chunk). + zip(precomputed_bitreversed_coset_divisor.as_ref().chunks(chunk)) { + scope.spawn(move |_| { + for (n, omega) in num.iter_mut().zip(omega.iter()) { + let mut result = *omega; + result.sub_assign(&setup_point); + result.mul_assign(&slope); + result.add_assign(&intercept); + + n.sub_assign(&result); + } + }); + } + }); + + scratch_space_numerator.mul_assign(&worker, &scratch_space_denominator); + if aggregation_challenge != E::Fr::one() { + scratch_space_numerator.scale(&worker, alpha); + } + + final_aggregate.add_assign(&worker, &scratch_space_numerator); + + alpha.mul_assign(&aggregation_challenge); + } + } + + let fri_proto = CosetCombiningFriIop::proof_from_lde( + &final_aggregate, + params.lde_factor, + params.output_coeffs_at_degree_plus_one, + omegas_inv_bitreversed, + &worker, + transcript, + ¶ms.coset_params + )?; + + Ok(()) + } + + fn prove_with_setup_precomputed, CPI: CTPrecomputations, FP: FriPrecomputations, T: Transcript as IopInstance> :: Commitment> >( + self, + setup_precomp: &RedshiftSetupPrecomputation>, + params: &RedshiftParameters, + worker: &Worker, + omegas_bitreversed: &CP, + omegas_inv_bitreversed: &CPI, + bitreversed_omegas_for_fri: &FP + ) -> Result<(), SynthesisError> { + assert!(self.is_finalized); + + let mut transcript = T::new(); + + let n = self.input_gates.len() + self.aux_gates.len(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = n + 1; + assert!(required_domain_size.is_power_of_two()); + + let (w_l, w_r, w_o) = self.make_wire_assingments(); + + // these are 2^k - 1 size and explicitly unpadded + let w_l = Polynomial::::from_values_unpadded(w_l)?; + let w_r = Polynomial::::from_values_unpadded(w_r)?; + let w_o = Polynomial::::from_values_unpadded(w_o)?; + + let a_poly = w_l.clone_padded_to_domain()?.ifft_using_bitreversed_ntt_with_partial_reduction(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let b_poly = w_r.clone_padded_to_domain()?.ifft_using_bitreversed_ntt_with_partial_reduction(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let c_poly = w_o.clone_padded_to_domain()?.ifft_using_bitreversed_ntt_with_partial_reduction(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // polynomials inside of these is are values in cosets + + let a_commitment_data = Self::commit_single_poly(&a_poly, omegas_bitreversed, ¶ms, &worker)?; + let b_commitment_data = Self::commit_single_poly(&b_poly, omegas_bitreversed, ¶ms, &worker)?; + let c_commitment_data = Self::commit_single_poly(&c_poly, omegas_bitreversed, ¶ms, &worker)?; + + transcript.commit_input(&a_commitment_data.oracle.get_commitment()); + transcript.commit_input(&b_commitment_data.oracle.get_commitment()); + transcript.commit_input(&c_commitment_data.oracle.get_commitment()); + + // TODO: Add public inputs + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + let mut w_l_plus_gamma = w_l.clone(); + w_l_plus_gamma.add_constant(&worker, &gamma); + + let mut w_r_plus_gamma = w_r.clone(); + w_r_plus_gamma.add_constant(&worker, &gamma); + + let mut w_o_plus_gamma = w_o.clone(); + w_o_plus_gamma.add_constant(&worker, &gamma); + + // we take A, B, C values and form (A + beta*i + gamma), etc and calculate their grand product + + let z_1 = { + let n = self.input_gates.len() + self.aux_gates.len(); + let s_id_1: Vec<_> = (1..=n).collect(); + let s_id_1 = convert_to_field_elements(&s_id_1, &worker); + let s_id_1 = Polynomial::::from_values_unpadded(s_id_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &s_id_1, &beta); + drop(s_id_1); + + let s_id_2: Vec<_> = ((n+1)..=(2*n)).collect(); + let s_id_2 = convert_to_field_elements(&s_id_2, &worker); + let s_id_2 = Polynomial::::from_values_unpadded(s_id_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &s_id_2, &beta); + drop(s_id_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let s_id_3: Vec<_> = ((2*n+1)..=(3*n)).collect(); + let s_id_3 = convert_to_field_elements(&s_id_3, &worker); + let s_id_3 = Polynomial::::from_values_unpadded(s_id_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &s_id_3, &beta); + drop(s_id_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + Polynomial::::from_values(prepadded)? + }; + + let z_2 = { + let (sigma_1, sigma_2, sigma_3) = self.calculate_permutations_as_in_a_paper(); + + let sigma_1 = convert_to_field_elements(&sigma_1, &worker); + let sigma_1 = Polynomial::::from_values_unpadded(sigma_1)?; + let mut w_l_contribution = w_l_plus_gamma.clone(); + w_l_contribution.add_assign_scaled(&worker, &sigma_1, &beta); + drop(sigma_1); + + let sigma_2 = convert_to_field_elements(&sigma_2, &worker); + let sigma_2 = Polynomial::::from_values_unpadded(sigma_2)?; + let mut w_r_contribution = w_r_plus_gamma.clone(); + w_r_contribution.add_assign_scaled(&worker, &sigma_2, &beta); + drop(sigma_2); + w_l_contribution.mul_assign(&worker, &w_r_contribution); + drop(w_r_contribution); + + let sigma_3 = convert_to_field_elements(&sigma_3, &worker); + let sigma_3 = Polynomial::::from_values_unpadded(sigma_3)?; + let mut w_o_contribution = w_o_plus_gamma.clone(); + w_o_contribution.add_assign_scaled(&worker, &sigma_3, &beta); + drop(sigma_3); + w_l_contribution.mul_assign(&worker, &w_o_contribution); + drop(w_o_contribution); + + let grand_product = w_l_contribution.calculate_grand_product(&worker)?; + + drop(w_l_contribution); + + let values = grand_product.into_coeffs(); + assert!((values.len() + 1).is_power_of_two()); + let mut prepadded = Vec::with_capacity(values.len() + 1); + prepadded.push(E::Fr::one()); + prepadded.extend(values); + + let z_2 = Polynomial::::from_values(prepadded)?; + + z_2 + }; + + assert!(z_2.as_ref().last().expect("must exist") == z_1.as_ref().last().expect("must exist")); + + // interpolate on the main domain + let z_1 = z_1.ifft_using_bitreversed_ntt_with_partial_reduction(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + let z_2 = z_2.ifft_using_bitreversed_ntt_with_partial_reduction(&worker, omegas_inv_bitreversed, &E::Fr::one())?; + + // polynomials inside of these is are values in cosets + + let z_1_commitment_data = Self::commit_single_poly(&z_1, omegas_bitreversed, ¶ms, &worker)?; + let z_2_commitment_data = Self::commit_single_poly(&z_2, omegas_bitreversed, ¶ms, &worker)?; + + transcript.commit_input(&z_1_commitment_data.oracle.get_commitment()); + transcript.commit_input(&z_2_commitment_data.oracle.get_commitment()); + + let mut z_1_shifted = z_1.clone(); + z_1_shifted.distribute_powers(&worker, z_1.omega); + + let mut z_2_shifted = z_2.clone(); + z_2_shifted.distribute_powers(&worker, z_2.omega); + + let partition_factor = params.lde_factor / 4; + + assert!(partition_factor > 0); + assert!(partition_factor.is_power_of_two()); + + let a_coset_lde_bitreversed = a_commitment_data.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let b_coset_lde_bitreversed = b_commitment_data.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let c_coset_lde_bitreversed = c_commitment_data.poly.clone_subset_assuming_bitreversed(partition_factor)?; + + let q_l_coset_lde_bitreversed = setup_precomp.q_l_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let q_r_coset_lde_bitreversed = setup_precomp.q_r_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let q_o_coset_lde_bitreversed = setup_precomp.q_o_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let q_m_coset_lde_bitreversed = setup_precomp.q_m_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let q_c_coset_lde_bitreversed = setup_precomp.q_c_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let s_id_coset_lde_bitreversed = setup_precomp.s_id_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let sigma_1_coset_lde_bitreversed = setup_precomp.sigma_1_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let sigma_2_coset_lde_bitreversed = setup_precomp.sigma_2_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + let sigma_3_coset_lde_bitreversed = setup_precomp.sigma_3_aux.poly.clone_subset_assuming_bitreversed(partition_factor)?; + + let (q_l, q_r, q_o, q_m, q_c, s_id, sigma_1, sigma_2, sigma_3) = self.output_setup_polynomials(&worker)?; + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + // TODO: may be speedup this one too + let mut vanishing_poly_inverse_bitreversed = self.calculate_inverse_vanishing_polynomial_in_a_coset(&worker, q_l_coset_lde_bitreversed.size(), required_domain_size.next_power_of_two())?; + vanishing_poly_inverse_bitreversed.bitreverse_enumeration(&worker); + + let mut t_1 = { + let mut t_1 = q_c_coset_lde_bitreversed; + + let mut q_l_by_a = q_l_coset_lde_bitreversed; + q_l_by_a.mul_assign(&worker, &a_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_l_by_a); + drop(q_l_by_a); + + let mut q_r_by_b = q_r_coset_lde_bitreversed; + q_r_by_b.mul_assign(&worker, &b_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_r_by_b); + drop(q_r_by_b); + + let mut q_o_by_c = q_o_coset_lde_bitreversed; + q_o_by_c.mul_assign(&worker, &c_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_o_by_c); + drop(q_o_by_c); + + let mut q_m_by_ab = q_m_coset_lde_bitreversed; + q_m_by_ab.mul_assign(&worker, &a_coset_lde_bitreversed); + q_m_by_ab.mul_assign(&worker, &b_coset_lde_bitreversed); + t_1.add_assign(&worker, &q_m_by_ab); + drop(q_m_by_ab); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + t_1.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1 + }; + + fn get_degree(poly: &Polynomial) -> usize { + let mut degree = poly.as_ref().len() - 1; + for c in poly.as_ref().iter().rev() { + if c.is_zero() { + degree -= 1; + } else { + break; + } + } + + println!("Degree = {}", degree); + + degree + } + + let z_1_coset_lde_bitreversed = z_1_commitment_data.poly.clone_subset_assuming_bitreversed(partition_factor)?; + + assert!(z_1_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_1_shifted_coset_lde_bitreversed = z_1_shifted.clone().bitreversed_lde_using_bitreversed_ntt_with_partial_reduction( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_1_shifted_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_2_coset_lde_bitreversed = z_2_commitment_data.poly.clone_subset_assuming_bitreversed(partition_factor)?; + + assert!(z_2_coset_lde_bitreversed.size() == required_domain_size*4); + + let z_2_shifted_coset_lde_bitreversed = z_2_shifted.clone().bitreversed_lde_using_bitreversed_ntt_with_partial_reduction( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + assert!(z_2_shifted_coset_lde_bitreversed.size() == required_domain_size*4); + + // (A + beta*i + gamma)(B + beta(n+i) + gamma)(C + beta(2n+i) + gamma)*Z(k) = Z(k+1) + { + // TODO: May be optimize number of additions + let mut contrib_z_1 = z_1_coset_lde_bitreversed.clone(); + + let mut s_id_by_beta = s_id_coset_lde_bitreversed; + s_id_by_beta.scale(&worker, beta); + + let mut n_by_beta = n_fe; + n_by_beta.mul_assign(&beta); + + let mut a_perm = s_id_by_beta.clone(); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &a_perm); + drop(a_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut b_perm = s_id_by_beta.clone(); + + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &b_perm); + drop(b_perm); + + s_id_by_beta.add_constant(&worker, &n_by_beta); + + let mut c_perm = s_id_by_beta; + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_coset_lde_bitreversed); + contrib_z_1.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_1.sub_assign(&worker, &z_1_shifted_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + contrib_z_1.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &contrib_z_1); + } + + { + // TODO: May be optimize number of additions + let mut contrib_z_2 = z_2_coset_lde_bitreversed.clone(); + + let mut a_perm = sigma_1_coset_lde_bitreversed; + a_perm.scale(&worker, beta); + a_perm.add_constant(&worker, &gamma); + a_perm.add_assign(&worker, &a_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &a_perm); + drop(a_perm); + + + let mut b_perm = sigma_2_coset_lde_bitreversed; + b_perm.scale(&worker, beta); + b_perm.add_constant(&worker, &gamma); + b_perm.add_assign(&worker, &b_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &b_perm); + drop(b_perm); + + let mut c_perm = sigma_3_coset_lde_bitreversed; + c_perm.scale(&worker, beta); + c_perm.add_constant(&worker, &gamma); + c_perm.add_assign(&worker, &c_coset_lde_bitreversed); + contrib_z_2.mul_assign(&worker, &c_perm); + drop(c_perm); + + contrib_z_2.sub_assign(&worker, &z_2_shifted_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + contrib_z_2.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &contrib_z_2); + } + + drop(a_coset_lde_bitreversed); + drop(b_coset_lde_bitreversed); + drop(c_coset_lde_bitreversed); + + let l_0 = self.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), 0)?; + let l_n_minus_one = self.calculate_lagrange_poly(&worker, required_domain_size.next_power_of_two(), n-1)?; + + { + let mut z_1_minus_z_2_shifted = z_1_shifted_coset_lde_bitreversed.clone(); + z_1_minus_z_2_shifted.sub_assign(&worker, &z_2_shifted_coset_lde_bitreversed); + + let l_coset_lde_bitreversed = l_n_minus_one.clone().bitreversed_lde_using_bitreversed_ntt_with_partial_reduction( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + z_1_minus_z_2_shifted.mul_assign(&worker, &l_coset_lde_bitreversed); + drop(l_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + z_1_minus_z_2_shifted.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &z_1_minus_z_2_shifted); + } + + { + let mut z_1_minus_z_2 = z_1_coset_lde_bitreversed.clone(); + z_1_minus_z_2.sub_assign(&worker, &z_2_coset_lde_bitreversed); + + let l_coset_lde_bitreversed = l_0.clone().bitreversed_lde_using_bitreversed_ntt_with_partial_reduction( + &worker, + 4, + omegas_bitreversed, + &E::Fr::multiplicative_generator() + )?; + + z_1_minus_z_2.mul_assign(&worker, &l_coset_lde_bitreversed); + drop(l_coset_lde_bitreversed); + + vanishing_poly_inverse_bitreversed.scale(&worker, alpha); + + z_1_minus_z_2.mul_assign(&worker, &vanishing_poly_inverse_bitreversed); + + t_1.add_assign(&worker, &z_1_minus_z_2); + } + + drop(z_1_coset_lde_bitreversed); + drop(z_2_coset_lde_bitreversed); + drop(z_1_shifted_coset_lde_bitreversed); + drop(z_2_shifted_coset_lde_bitreversed); + + t_1.bitreverse_enumeration(&worker); + + let t_poly = t_1.icoset_fft_for_generator(&worker, &E::Fr::multiplicative_generator()); + + debug_assert!(get_degree::(&t_poly) <= 3*n); + + let mut t_poly_parts = t_poly.break_into_multiples(required_domain_size)?; + + t_poly_parts.pop().expect("last part is irrelevant"); + let t_poly_high = t_poly_parts.pop().expect("high exists"); + let t_poly_mid = t_poly_parts.pop().expect("mid exists"); + let t_poly_low = t_poly_parts.pop().expect("low exists"); + + let t_poly_high_commitment_data = Self::commit_single_poly(&t_poly_high, omegas_bitreversed, ¶ms, &worker)?; + let t_poly_mid_commitment_data = Self::commit_single_poly(&t_poly_mid, omegas_bitreversed, ¶ms, &worker)?; + let t_poly_low_commitment_data = Self::commit_single_poly(&t_poly_low, omegas_bitreversed, ¶ms, &worker)?; + + transcript.commit_input(&t_poly_low_commitment_data.oracle.get_commitment()); + transcript.commit_input(&t_poly_mid_commitment_data.oracle.get_commitment()); + transcript.commit_input(&t_poly_high_commitment_data.oracle.get_commitment()); + + let z = transcript.get_challenge(); + + let a_at_z = a_poly.evaluate_at(&worker, z); + let b_at_z = b_poly.evaluate_at(&worker, z); + let c_at_z = c_poly.evaluate_at(&worker, z); + + let q_l_at_z = q_l.evaluate_at(&worker, z); + let q_r_at_z = q_r.evaluate_at(&worker, z); + let q_o_at_z = q_o.evaluate_at(&worker, z); + let q_m_at_z = q_m.evaluate_at(&worker, z); + let q_c_at_z = q_c.evaluate_at(&worker, z); + + let s_id_at_z = s_id.evaluate_at(&worker, z); + let sigma_1_at_z = sigma_1.evaluate_at(&worker, z); + let sigma_2_at_z = sigma_2.evaluate_at(&worker, z); + let sigma_3_at_z = sigma_3.evaluate_at(&worker, z); + + let mut inverse_vanishing_at_z = self.evaluate_inverse_vanishing_poly(required_domain_size.next_power_of_two(), z); + + let z_1_at_z = z_1.evaluate_at(&worker, z); + let z_2_at_z = z_2.evaluate_at(&worker, z); + + let z_1_shifted_at_z = z_1_shifted.evaluate_at(&worker, z); + let z_2_shifted_at_z = z_2_shifted.evaluate_at(&worker, z); + + let t_low_at_z = t_poly_low.evaluate_at(&worker, z); + let t_mid_at_z = t_poly_mid.evaluate_at(&worker, z); + let t_high_at_z = t_poly_high.evaluate_at(&worker, z); + + let l_0_at_z = l_0.evaluate_at(&worker, z); + let l_n_minus_one_at_z = l_n_minus_one.evaluate_at(&worker, z); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_low_at_z); + transcript.commit_field_element(&t_mid_at_z); + transcript.commit_field_element(&t_high_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + // let aggregation_challenge = transcript.get_challenge(); + + let z_in_pow_of_domain_size = z.pow([required_domain_size as u64]); + + // this is a sanity check + { + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + let mut t_at_z = E::Fr::zero(); + t_at_z.add_assign(&t_low_at_z); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&t_mid_at_z); + t_at_z.add_assign(&tmp); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&z_in_pow_of_domain_size); + tmp.mul_assign(&t_high_at_z); + t_at_z.add_assign(&tmp); + + assert_eq!(t_at_z, t_1, "sanity check failed"); + } + + // we do NOT compute linearization polynomial for non-homomorphic case + + let mut z_by_omega = z; + z_by_omega.mul_assign(&z_1.omega); + + let witness_opening_request_at_z = WitnessOpeningRequest { + polynomials: vec![ + &a_commitment_data.poly, + &b_commitment_data.poly, + &c_commitment_data.poly, + &z_1_commitment_data.poly, + &z_2_commitment_data.poly, + &t_poly_low_commitment_data.poly, + &t_poly_mid_commitment_data.poly, + &t_poly_high_commitment_data.poly + ], + opening_point: z, + opening_values: vec![ + a_at_z, + b_at_z, + c_at_z, + z_1_at_z, + z_2_at_z, + t_low_at_z, + t_mid_at_z, + t_high_at_z, + ] + }; + + let witness_opening_request_at_z_omega = WitnessOpeningRequest { + polynomials: vec![ + &z_1_commitment_data.poly, + &z_2_commitment_data.poly, + ], + opening_point: z_by_omega, + opening_values: vec![ + z_1_shifted_at_z, + z_2_shifted_at_z, + ] + }; + + let setup_opening_request = SetupOpeningRequest { + polynomials: vec![ + &setup_precomp.q_l_aux.poly, + &setup_precomp.q_r_aux.poly, + &setup_precomp.q_o_aux.poly, + &setup_precomp.q_m_aux.poly, + &setup_precomp.q_c_aux.poly, + &setup_precomp.s_id_aux.poly, + &setup_precomp.sigma_1_aux.poly, + &setup_precomp.sigma_2_aux.poly, + &setup_precomp.sigma_3_aux.poly, + ], + setup_point: setup_precomp.q_l_aux.setup_point, + setup_values: vec![ + setup_precomp.q_l_aux.setup_value, + setup_precomp.q_r_aux.setup_value, + setup_precomp.q_o_aux.setup_value, + setup_precomp.q_m_aux.setup_value, + setup_precomp.q_c_aux.setup_value, + setup_precomp.s_id_aux.setup_value, + setup_precomp.sigma_1_aux.setup_value, + setup_precomp.sigma_2_aux.setup_value, + setup_precomp.sigma_3_aux.setup_value, + ], + opening_point: z, + opening_values: vec![ + q_l_at_z, + q_r_at_z, + q_o_at_z, + q_m_at_z, + q_c_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + ] + }; + + let _ = Self::multiopening(vec![witness_opening_request_at_z, witness_opening_request_at_z_omega], + vec![setup_opening_request], + bitreversed_omegas_for_fri, + ¶ms, + &worker, + &mut transcript + )?; + + Ok(()) + + + // let proof = PlonkChunkedNonhomomorphicProof:: { + // a_opening_value: a_at_z, + // b_opening_value: b_at_z, + // c_opening_value: c_at_z, + // q_l_opening_value: q_l_at_z, + // q_r_opening_value: q_r_at_z, + // q_o_opening_value: q_o_at_z, + // q_m_opening_value: q_m_at_z, + // q_c_opening_value: q_c_at_z, + // s_id_opening_value: s_id_at_z, + // sigma_1_opening_value: sigma_1_at_z, + // sigma_2_opening_value: sigma_2_at_z, + // sigma_3_opening_value: sigma_3_at_z, + // z_1_unshifted_opening_value: z_1_at_z, + // z_2_unshifted_opening_value: z_2_at_z, + // z_1_shifted_opening_value: z_1_shifted_at_z, + // z_2_shifted_opening_value: z_2_shifted_at_z, + // t_low_opening_value: t_low_at_z, + // t_mid_opening_value: t_mid_at_z, + // t_high_opening_value: t_high_at_z, + // a_commitment: a_commitment, + // b_commitment: b_commitment, + // c_commitment: c_commitment, + // z_1_commitment: z_1_commitment, + // z_2_commitment: z_2_commitment, + // t_low_commitment: t_low_commitment, + // t_mid_commitment: t_mid_commitment, + // t_high_commitment: t_high_commitment, + // openings_proof: multiopen_proof, + // }; + + // Ok(proof) + } +} + +#[cfg(test)] +mod test { + + use crate::plonk::cs::*; + use crate::pairing::Engine; + use crate::SynthesisError; + use super::*; + use super::super::generator::*; + + use crate::ff::{Field, PrimeField}; + + #[derive(Clone)] + struct BenchmarkCircuit{ + num_steps: usize, + _marker: std::marker::PhantomData + } + + impl Circuit for BenchmarkCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + // yeah, fibonacci... + + let one = E::Fr::one(); + let mut negative_one = one; + negative_one.negate(); + + let mut two = one; + two.double(); + + let mut a = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + let mut b = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + cs.enforce_zero_2((a, b), (one, negative_one))?; + // cs.enforce_zero_2((b, CS::ONE), (one, negative_one))?; + + let mut c = cs.alloc(|| { + Ok(two) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + + let mut a_value = one; + let mut b_value = one; + let mut c_value = two; + + for _ in 0..self.num_steps { + a = b; + b = c; + + a_value = b_value; + b_value = c_value; + c_value.add_assign(&a_value); + + c = cs.alloc(|| { + Ok(c_value) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + } + + Ok(()) + } + } + + #[test] + fn test_bench_redshift() { + use crate::pairing::Engine; + use crate::ff::ScalarEngine; + use crate::plonk::transparent_engine::{TransparentEngine, PartialTwoBitReductionField}; + use crate::plonk::transparent_engine::proth_engine::Transparent252; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::*; + use crate::plonk::commitments::transparent::iop_compiler::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::*; + use crate::worker::Worker; + // use crate::plonk::tester::*; + + type Fr = ::Fr; + type Transcr = Blake2sTranscript; + + use crate::plonk::fft::cooley_tukey_ntt::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::precomputation::*; + use crate::plonk::commitments::transparent::iop_compiler::*; + use crate::plonk::commitments::transparent::iop_compiler::coset_combining_blake2s_tree::*; + + use std::time::Instant; + + let log_2_rate = 4; + let rate = 1 << log_2_rate; + println!("Using rate {}", rate); + let sizes = vec![(1 << 18) - 10, (1 << 19) - 10, (1 << 20) - 10, (1 << 21) - 10, (1 << 22) - 10, (1 << 23) - 10]; + let coset_schedules = vec![ + vec![3, 3, 3, 3, 3, 3], // 18 + vec![3, 3, 3, 3, 3, 2, 2], // 19 + vec![3, 3, 3, 3, 3, 3, 2], // 20 + vec![3, 3, 3, 3, 3, 3, 3], // 21 + vec![3, 3, 3, 3, 3, 3, 2, 2], // 22 + vec![3, 3, 3, 3, 3, 3, 3, 2], // 23 + ]; + + let worker = Worker::new(); + + for (size, coset_schedule) in sizes.into_iter().zip(coset_schedules.into_iter()) { + println!("Working for size {}", size); + let coset_params = CosetParams { + cosets_schedule: coset_schedule, + coset_factor: Fr::multiplicative_generator() + }; + + let params = RedshiftParameters { + lde_factor: rate, + num_queries: 4, + output_coeffs_at_degree_plus_one: 1, + coset_params: coset_params + }; + + let circuit = BenchmarkCircuit:: { + num_steps: size, + _marker: std::marker::PhantomData + }; + + let omegas_bitreversed = BitReversedOmegas::::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size(size.next_power_of_two()); + let omegas_inv_bitreversed_for_fri = as FriPrecomputations::>::new_for_domain_size(size.next_power_of_two() * rate); + + let (_, setup_precomp) = setup_with_precomputations::( + &circuit, + ¶ms, + &omegas_bitreversed + ).unwrap(); + + let mut prover = ProvingAssembly::::new(); + circuit.synthesize(&mut prover).unwrap(); + prover.finalize(); + + println!("Start proving"); + + let start = Instant::now(); + + let _ = prover.prove_with_setup_precomputed::<_, _, _, Transcr>( + &setup_precomp, + ¶ms, + &worker, + &omegas_bitreversed, + &omegas_inv_bitreversed, + &omegas_inv_bitreversed_for_fri + ).unwrap(); + + println!("Proving taken {:?} for size {}", start.elapsed(), size); + + + // { + // let mut tester = TestingAssembly::::new(); + + // circuit.synthesize(&mut tester).expect("must synthesize"); + + // let satisfied = tester.is_satisfied(); + + // assert!(satisfied); + + // println!("Circuit is satisfied"); + // } + + // println!("Start setup"); + // let start = Instant::now(); + // let (setup, aux) = setup::(&circuit, meta.clone()).unwrap(); + // println!("Setup taken {:?}", start.elapsed()); + + // println!("Using circuit with N = {}", setup.n); + + // println!("Start proving"); + // let start = Instant::now(); + // let proof = prove_nonhomomorphic_chunked::, _>(&circuit, &aux, meta.clone()).unwrap(); + // println!("Proof taken {:?}", start.elapsed()); + + // println!("Start verifying"); + // let start = Instant::now(); + // let valid = verify_nonhomomorphic_chunked::>(&setup, &proof, meta).unwrap(); + // println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + // assert!(valid); + } + } + + #[test] + fn test_ifft_using_ntt() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::fft::cooley_tukey_ntt::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::fri::*; + use crate::plonk::commitments::transparent::fri::coset_combining_fri::precomputation::*; + use crate::pairing::Engine; + use crate::ff::ScalarEngine; + use crate::plonk::transparent_engine::{TransparentEngine, PartialTwoBitReductionField}; + use crate::plonk::transparent_engine::proth_engine::Transparent252; + + use crate::worker::*; + use crate::source::*; + + type Fr = ::Fr; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let poly_sizes = vec![100, 1000, 10_000, 1_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.clone().into_iter() { + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let poly = Polynomial::::from_values(coeffs).unwrap(); + let naive_result = poly.clone().icoset_fft_for_generator(&worker, &Fr::one()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size((poly_size as usize).next_power_of_two()); + let ntt_result = poly.clone().ifft_using_bitreversed_ntt(&worker, &omegas_inv_bitreversed, &Fr::one()).unwrap(); + + assert!(naive_result == ntt_result); + } + + for poly_size in poly_sizes.into_iter() { + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let poly = Polynomial::::from_values(coeffs).unwrap(); + let naive_result = poly.clone().icoset_fft_for_generator(&worker, &Fr::multiplicative_generator()); + let omegas_inv_bitreversed = as CTPrecomputations::>::new_for_domain_size((poly_size as usize).next_power_of_two()); + let ntt_result = poly.clone().ifft_using_bitreversed_ntt(&worker, &omegas_inv_bitreversed, &Fr::multiplicative_generator()).unwrap(); + + assert!(naive_result == ntt_result); + } + } + + #[test] + fn test_fft_test_vectors() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::plonk::fft::*; + use crate::pairing::Engine; + use crate::ff::ScalarEngine; + use crate::plonk::transparent_engine::{TransparentEngine}; + use crate::plonk::transparent_engine::proth_engine::Transparent252; + + use crate::worker::*; + use crate::source::*; + + type Fr = ::Fr; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let poly_sizes = vec![4, 8, 16]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.clone().into_iter() { + println!("Poly size {}", poly_size); + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + println!("Coefficients"); + for c in coeffs.iter() { + println!("{}", c.into_raw_repr()); + } + println!("Generators"); + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let omega = poly.omega; + for i in 0..poly_size { + let gen = omega.pow([i as u64]); + println!("Omega^{} = {}", i, gen.into_raw_repr()); + } + println!("Result"); + let naive_result = poly.fft(&worker); + let coeffs = naive_result.into_coeffs(); + for c in coeffs.iter() { + println!("{}", c.into_raw_repr()); + } + } + } +} \ No newline at end of file diff --git a/src/plonk/tester/mod.rs b/src/plonk/tester/mod.rs new file mode 100644 index 000000000..9c16886e3 --- /dev/null +++ b/src/plonk/tester/mod.rs @@ -0,0 +1,339 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use super::polynomials::*; +use super::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; +use crate::plonk::generator::*; + + +#[derive(Debug)] +pub struct TestingAssembly { + m: usize, + n: usize, + input_gates: Vec>, + aux_gates: Vec>, + + num_inputs: usize, + num_aux: usize, + + input_assingments: Vec, + aux_assingments: Vec, + + inputs_map: Vec, + + is_finalized: bool +} + +impl ConstraintSystem for TestingAssembly { + const ZERO: Variable = Variable(Index::Aux(1)); + const ONE: Variable = Variable(Index::Aux(2)); + + // allocate a variable + fn alloc(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_aux += 1; + let index = self.num_aux; + self.aux_assingments.push(value); + + Ok(Variable(Index::Aux(index))) + } + + // allocate an input variable + fn alloc_input(&mut self, value: F) -> Result + where + F: FnOnce() -> Result + { + let value = value()?; + + self.num_inputs += 1; + let index = self.num_inputs; + self.input_assingments.push(value); + + let input_var = Variable(Index::Input(index)); + + let gate = Gate::::new_enforce_constant_gate(input_var, Some(E::Fr::zero()), self.dummy_variable()); + // let gate = Gate::::new_enforce_constant_gate(input_var, Some(value), self.dummy_variable()); + self.input_gates.push(gate); + + Ok(input_var) + + } + + // enforce variable as boolean + fn enforce_boolean(&mut self, variable: Variable) -> Result<(), SynthesisError> { + let gate = Gate::::new_enforce_boolean_gate(variable, self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate an abstract gate + fn new_gate(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr, E::Fr, E::Fr), values: F) -> Result<(), SynthesisError> + where + F: FnOnce() -> Result<(E::Fr, E::Fr), SynthesisError> + { + unimplemented!() + } + + // allocate a constant + fn enforce_constant(&mut self, variable: Variable, constant: E::Fr) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_constant_gate(variable, Some(constant), self.dummy_variable()); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_2(&mut self, variables: (Variable, Variable)) -> Result<(), SynthesisError> { + // q_l, q_r, q_o, q_c = 0, q_m = 1 + let (v_0, v_1) = variables; + let zero = E::Fr::zero(); + let one = E::Fr::one(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (zero, zero, zero, one, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a multiplication gate + fn enforce_mul_3(&mut self, variables: (Variable, Variable, Variable)) -> Result<(), SynthesisError> { + let gate = Gate::::new_multiplication_gate(variables); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_2(&mut self, variables: (Variable, Variable), coeffs:(E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let (v_0, v_1) = variables; + let (c_0, c_1) = coeffs; + let zero = E::Fr::zero(); + + let gate = Gate::::new_gate((v_0, v_1, self.dummy_variable()), (c_0, c_1, zero, zero, zero)); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + } + + // allocate a linear combination gate + fn enforce_zero_3(&mut self, variables: (Variable, Variable, Variable), coeffs:(E::Fr, E::Fr, E::Fr)) -> Result<(), SynthesisError> + { + let gate = Gate::::new_enforce_zero_gate(variables, coeffs); + self.aux_gates.push(gate); + self.n += 1; + + Ok(()) + + } +} + +impl TestingAssembly { + pub fn new() -> Self { + let mut tmp = Self { + n: 0, + m: 0, + input_gates: vec![], + aux_gates: vec![], + + num_inputs: 0, + num_aux: 0, + + input_assingments: vec![], + aux_assingments: vec![], + + inputs_map: vec![], + + is_finalized: false, + }; + + let zero = tmp.alloc(|| Ok(E::Fr::zero())).expect("should have no issues"); + tmp.enforce_constant(zero, E::Fr::zero()).expect("should have no issues"); + + let one = tmp.alloc(|| Ok(E::Fr::one())).expect("should have no issues"); + tmp.enforce_constant(one, E::Fr::one()).expect("should have no issues"); + + match (zero, >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + match (one, >::ONE) { + (Variable(Index::Aux(2)), Variable(Index::Aux(2))) => {}, + _ => panic!("one variable is incorrect") + } + + match (tmp.dummy_variable(), >::ZERO) { + (Variable(Index::Aux(1)), Variable(Index::Aux(1))) => {}, + _ => panic!("zero variable is incorrect") + } + + tmp + } + + // return variable that is not in a constraint formally, but has some value + fn dummy_variable(&self) -> Variable { + >::ZERO + // Variable(Index::Aux(0)) + } + + pub fn num_gates(&self) -> usize { + assert!(self.is_finalized); + + self.input_gates.len() + self.aux_gates.len() + } + + fn finalize(&mut self) { + if self.is_finalized { + return; + } + let n = self.input_gates.len() + self.aux_gates.len(); + if (n+1).is_power_of_two() { + return; + } + + let empty_gate = Gate::::new_empty_gate(self.dummy_variable()); + + let new_aux_len = (n+1).next_power_of_two() - 1 - self.input_gates.len(); + + self.aux_gates.resize(new_aux_len, empty_gate); + + self.is_finalized = true; + } + + fn get_value(&self, var: &Variable) -> E::Fr { + match var { + Variable(Index::Input(input)) => { + self.input_assingments[*input - 1] + }, + Variable(Index::Aux(aux)) => { + self.aux_assingments[*aux - 1] + } + } + } + + pub fn is_satisfied(mut self) -> bool { + self.finalize(); + assert!(self.is_finalized); + + fn coeff_into_field_element(coeff: & Coeff) -> E::Fr { + match coeff { + Coeff::Zero => { + E::Fr::zero() + }, + Coeff::One => { + E::Fr::one() + }, + Coeff::NegativeOne => { + let mut tmp = E::Fr::one(); + tmp.negate(); + + tmp + }, + Coeff::Full(c) => { + *c + }, + } + } + + // expect a small number of inputs + for (i, gate) in self.input_gates.iter().enumerate() + { + let q_l = coeff_into_field_element(&gate.q_l); + let q_r = coeff_into_field_element(&gate.q_r); + let q_o = coeff_into_field_element(&gate.q_o); + let q_m = coeff_into_field_element(&gate.q_m); + let q_c = coeff_into_field_element(&gate.q_c); + + let a_value = self.get_value(gate.a_wire()); + let b_value = self.get_value(gate.b_wire()); + let c_value = self.get_value(gate.c_wire()); + + let mut res = q_c; + + let mut tmp = q_l; + tmp.mul_assign(&a_value); + res.add_assign(&tmp); + + let mut tmp = q_r; + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + let mut tmp = q_o; + tmp.mul_assign(&c_value); + res.add_assign(&tmp); + + let mut tmp = q_m; + tmp.mul_assign(&a_value); + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + if !res.is_zero() { + println!("Unsatisfied at input gate {}", i+1); + return false; + } + } + + for (i, gate) in self.aux_gates.iter().enumerate() + { + let q_l = coeff_into_field_element(&gate.q_l); + let q_r = coeff_into_field_element(&gate.q_r); + let q_o = coeff_into_field_element(&gate.q_o); + let q_m = coeff_into_field_element(&gate.q_m); + let q_c = coeff_into_field_element(&gate.q_c); + + let a_value = self.get_value(gate.a_wire()); + let b_value = self.get_value(gate.b_wire()); + let c_value = self.get_value(gate.c_wire()); + + let mut res = q_c; + + let mut tmp = q_l; + tmp.mul_assign(&a_value); + res.add_assign(&tmp); + + let mut tmp = q_r; + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + let mut tmp = q_o; + tmp.mul_assign(&c_value); + res.add_assign(&tmp); + + let mut tmp = q_m; + tmp.mul_assign(&a_value); + tmp.mul_assign(&b_value); + res.add_assign(&tmp); + + if !res.is_zero() { + println!("Unsatisfied at aux gate {}", i+1); + println!("Gate {:?}", *gate); + println!("A = {}, B = {}, C = {}", a_value, b_value, c_value); + return false; + } + } + + true + } +} \ No newline at end of file diff --git a/src/plonk/transparent_engine/impl_macro.rs b/src/plonk/transparent_engine/impl_macro.rs new file mode 100644 index 000000000..6f6268ce3 --- /dev/null +++ b/src/plonk/transparent_engine/impl_macro.rs @@ -0,0 +1,239 @@ +use rand_core::RngCore; + + +macro_rules! transparent_engine_impl { + ( + $engine:ident, + $fr:ty + ) => { + #[derive(Clone, Debug)] + pub struct $engine; + + impl crate::ff::ScalarEngine for $engine { + type Fr = $fr; + } + + impl crate::pairing::Engine for $engine { + type G1 = $fr; + type G1Affine = $fr; + type G2 = $fr; + type G2Affine = $fr; + type Fq = $fr; + type Fqe = $fr; + type Fqk = $fr; + + fn miller_loop<'a, I>(_i: I) -> Self::Fqk + where I: IntoIterator::Prepared, + &'a ::Prepared + )> + { + <$fr as crate::ff::Field>::zero() + } + + /// Perform final exponentiation of the result of a miller loop. + fn final_exponentiation(this: &Self::Fqk) -> Option + { + Some(*this) + } + } + + + impl crate::pairing::CurveProjective for $fr { + type Affine = $fr; + type Base = $fr; + type Scalar = $fr; + type Engine = $engine; + + // fn random(rng: &mut R) -> Self { + // unimplemented!() + // } + + fn zero() -> Self { + <$fr as crate::ff::Field>::zero() + } + + fn one() -> Self { + <$fr as crate::ff::Field>::one() + } + + fn is_zero(self: &Self) -> bool { + <$fr as crate::ff::Field>::is_zero(self) + } + + fn batch_normalization(_: &mut [Self]) { + + } + + fn is_normalized(&self) -> bool { + true + } + + fn double(self: &mut Self) { + <$fr as crate::ff::Field>::double(self); + } + + fn add_assign(self: &mut Self, other: &Self) { + <$fr as crate::ff::Field>::add_assign(self, other); + } + + fn add_assign_mixed(&mut self, other: &Self) { + <$fr as crate::ff::Field>::add_assign(self, other); + } + + fn negate(self: &mut Self) { + <$fr as crate::ff::Field>::negate(self); + } + + fn mul_assign::Repr>>(self: &mut Self, other: S) + { + let tmp = <$fr as crate::ff::PrimeField>::from_repr(other.into()).unwrap(); + + <$fr as crate::ff::Field>::mul_assign(self, &tmp); + } + + fn into_affine(&self) -> $fr { + *self + } + + fn recommended_wnaf_for_scalar(_: ::Repr) -> usize { + 3 + } + + fn recommended_wnaf_for_num_scalars(_: usize) -> usize { + 3 + } + } + + #[derive(Copy, Clone)] + pub struct FakePoint; + + impl AsMut<[u8]> for FakePoint { + fn as_mut(&mut self) -> &mut [u8] { + unimplemented!() + } + } + + impl AsRef<[u8]> for FakePoint { + fn as_ref(&self) -> &[u8] { + unimplemented!() + } + } + + impl crate::pairing::EncodedPoint for FakePoint { + type Affine = $fr; + + fn empty() -> Self { + unimplemented!() + } + + fn size() -> usize { + unimplemented!() + } + + fn into_affine(&self) -> Result { + unimplemented!() + } + + fn into_affine_unchecked(&self) -> Result { + unimplemented!() + } + + fn from_affine(_: Self::Affine) -> Self { + unimplemented!() + } + } + + impl crate::pairing::CurveAffine for $fr { + type Pair = $fr; + type PairingResult = $fr; + type Compressed = FakePoint; + type Uncompressed = FakePoint; + type Prepared = $fr; + type Projective = $fr; + type Base = $fr; + type Scalar = $fr; + type Engine = $engine; + + fn zero() -> Self { + <$fr as crate::ff::Field>::zero() + } + + fn one() -> Self { + <$fr as crate::ff::Field>::one() + } + + fn is_zero(&self) -> bool { + <$fr as crate::ff::Field>::is_zero(self) + } + + fn negate(&mut self) { + <$fr as crate::ff::Field>::negate(self); + } + + fn mul::Repr>>(&self, other: S) -> Self::Projective + { + let mut res = *self; + let tmp = <$fr as crate::ff::PrimeField>::from_repr(other.into()).unwrap(); + + <$fr as crate::ff::Field>::mul_assign(&mut res, &tmp); + + res + } + + fn prepare(&self) -> Self::Prepared { + *self + } + + fn pairing_with(&self, other: &Self::Pair) -> Self::PairingResult { + self.mul(*other) + } + + fn into_projective(&self) -> Self::Projective { + *self + } + + fn as_xy(&self) -> (&Self::Base, &Self::Base) { + (&self, &self) + } + + fn into_xy_unchecked(self) -> (Self::Base, Self::Base) { + (<$fr as crate::ff::Field>::zero(), <$fr as crate::ff::Field>::zero()) + } + + fn from_xy_unchecked(_x: Self::Base, _y: Self::Base) -> Self { + <$fr as crate::ff::Field>::zero() + } + + fn from_xy_checked(_x: Self::Base, _y: Self::Base) -> Result { + Ok(<$fr as crate::ff::Field>::zero()) + } + + fn a_coeff() -> Self::Base { + unimplemented!() + } + + fn b_coeff() -> Self::Base { + unimplemented!() + } + } + + impl crate::pairing::RawEncodable for $fr { + fn into_raw_uncompressed_le(&self) -> Self::Uncompressed { + use crate::pairing::EncodedPoint; + Self::Uncompressed::empty() + } + + fn from_raw_uncompressed_le_unchecked( + _encoded: &Self::Uncompressed, + _infinity: bool + ) -> Result { + Ok(::zero()) + } + + fn from_raw_uncompressed_le(encoded: &Self::Uncompressed, _infinity: bool) -> Result { + Self::from_raw_uncompressed_le_unchecked(&encoded, _infinity) + } + } + } +} \ No newline at end of file diff --git a/src/plonk/transparent_engine/mod.rs b/src/plonk/transparent_engine/mod.rs new file mode 100644 index 000000000..e48beec4d --- /dev/null +++ b/src/plonk/transparent_engine/mod.rs @@ -0,0 +1,500 @@ +use crate::ff::*; + +use crate::pairing::Engine; +use rand_core::RngCore; + +#[macro_use] +mod impl_macro; + +#[derive(PrimeField)] +#[PrimeFieldModulus = "3618502788666131213697322783095070105623107215331596699973092056135872020481"] +#[PrimeFieldGenerator = "3"] +pub struct Fr(FrRepr); + +pub trait TransparentEngine: Engine {} + +pub trait PartialReductionField: PrimeField { + /// Adds another element by this element without reduction. + fn add_assign_unreduced(&mut self, other: &Self); + + /// Subtracts another element by this element without reduction. + fn sub_assign_unreduced(&mut self, other: &Self); + + /// Multiplies another element by this element without reduction. + fn mul_assign_unreduced(&mut self, other: &Self); + + /// Reduces this element. + fn reduce_once(&mut self); + + /// Reduces this element by max of three moduluses. + fn reduce_completely(&mut self); + + fn overflow_factor(&self) -> usize; +} + +pub trait PartialTwoBitReductionField: PartialReductionField { + /// Subtracts another element by this element without reduction. + fn sub_assign_twice_unreduced(&mut self, other: &Self); + + /// Reduces this element by two moduluses. + fn reduce_twice(&mut self); + + /// Reduces this element by max of three moduluses. + fn reduce_completely(&mut self); +} + +pub mod engine { + use super::Fr; + + use super::impl_macro::*; + use rand_core::RngCore; + + transparent_engine_impl!{Transparent252, Fr} +} + +pub use self::engine::Transparent252; + +pub(crate) mod proth; +pub(crate) mod proth_engine; + +#[cfg(test)] +mod test { + #[test] + fn test_bench_proth_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::Fr as FrMontNaive; + use super::proth::Fr as FrOptimized; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| FrMontNaive::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.lde(&worker, 16).unwrap(); + println!("LDE with factor 16 for size {} with naive mont reduction taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| FrOptimized::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.lde(&worker, 16).unwrap(); + println!("LDE with factor 16 for size {} with optimized mont reduction taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + assert_eq!(format!("{}", res1[0]), format!("{}", res2[0])); + + } + } + + #[test] + fn test_proth_field() { + use crate::ff::{Field, PrimeField, to_hex}; + use super::Fr as FrMontNaive; + use super::proth::Fr as FrOptimized; + + let one_naive = FrMontNaive::from_str("1").unwrap(); + let one_optimized = FrOptimized::from_str("1").unwrap(); + + println!("{}", FrMontNaive::one()); + println!("{}", FrOptimized::one()); + + println!("{}", one_naive.into_raw_repr()); + println!("{}", one_optimized.into_raw_repr()); + + let mut tmp0 = one_naive; + tmp0.mul_assign(&one_naive); + + let mut tmp1 = one_optimized; + tmp1.mul_assign(&one_optimized); + + assert_eq!(to_hex(&tmp0), to_hex(&tmp1)); + + assert_eq!(to_hex(&FrMontNaive::multiplicative_generator()), to_hex(&FrOptimized::multiplicative_generator())); + } + + #[test] + fn test_bench_precomputations_for_proth_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::Fr as FrMontNaive; + use super::proth::Fr as FrOptimized; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::fft::best_fft; + use crate::plonk::fft::with_precomputation::FftPrecomputations; + use crate::plonk::fft::with_precomputation::fft::best_fft as best_fft_with_precomputations; + use crate::plonk::commitments::transparent::precomputations::*; + use crate::plonk::domains::Domain; + let poly_sizes = vec![32_000_000, 64_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let domain = Domain::::new_for_size(poly_size).unwrap(); + let precomp = PrecomputedOmegas::::new_for_domain_size(domain.size as usize); + let omega = domain.generator; + let log_n = domain.power_of_two as u32; + + let poly_size = domain.size as usize; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| FrOptimized::rand(rng)).collect::>(); + let start = Instant::now(); + best_fft(&mut coeffs, &worker, &omega, log_n, None); + println!("FFT for size {} without precomputation taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| FrOptimized::rand(rng)).collect::>(); + let start = Instant::now(); + best_fft_with_precomputations(&mut coeffs, &worker, &omega, log_n, None, &precomp); + println!("FFT for size {} with precomputation taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + assert!(res1 == res2); + + } + } + + #[test] + fn test_bench_precomputations_for_proth_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::Fr as FrMontNaive; + use super::proth::Fr as FrOptimized; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::with_precomputation::FftPrecomputations; + use crate::plonk::commitments::transparent::precomputations::*; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| FrMontNaive::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.lde(&worker, 16).unwrap(); + println!("LDE with factor 16 for size {} with naive mont reduction taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| FrOptimized::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let precomp = PrecomputedOmegas::::new_for_domain_size(poly.size()); + let start = Instant::now(); + let eval_result = poly.lde_using_multiple_cosets_with_precomputation(&worker, 16, &precomp).unwrap(); + println!("LDE with factor 16 for size {} with optimized mont reduction and precomputation taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + assert_eq!(format!("{}", res1[0]), format!("{}", res2[0])); + + } + } + + #[test] + fn test_bench_ct_ploth_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::proth::Fr as Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas}; + + let poly_sizes = vec![1_000_000, 2_000_000, 4_000_000]; + + // let poly_sizes = vec![2]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.lde_using_multiple_cosets(&worker, 16).unwrap(); + println!("LDE with factor 16 for size {} taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + let res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly.size()); + let start = Instant::now(); + let eval_result = poly.lde_using_bitreversed_ntt(&worker, 16, &precomp).unwrap(); + println!("LDE with factor 16 for size {} with optimized ntt taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + assert_eq!(res1, res2); + + assert!(res1 == res2); + } + } + + // #[test] + // fn test_bench_noalloc_bit_reversed_ploth_lde() { + // use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + // use super::proth::Fr as Fr; + // use crate::plonk::polynomials::*; + // use std::time::Instant; + // use crate::worker::*; + // use crate::plonk::commitments::transparent::utils::*; + // use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas}; + + // let poly_sizes = vec![32, 64,1_000_000, 2_000_000, 4_000_000]; + + // let worker = Worker::new(); + + // for poly_size in poly_sizes.into_iter() { + // let poly_size = poly_size as usize; + + // let res1 = { + // let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + // let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + // let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + // let start = Instant::now(); + // let eval_result = poly.lde(&worker, 16).unwrap(); + // println!("LDE with factor 16 for size {} taken {:?}", poly_size, start.elapsed()); + + // eval_result.into_coeffs() + // }; + + // let res2 = { + // let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + // let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + // let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + // let precomp = BitReversedOmegas::::new_for_domain_size(poly.size()); + // let start = Instant::now(); + // let eval_result = poly.lde_using_bitreversed_ntt_no_allocations_lowest_bits_reversed(&worker, 16, &precomp).unwrap(); + // println!("LDE with factor 16 for size {} with optimized ntt taken {:?}", poly_size, start.elapsed()); + + // eval_result.into_coeffs() + // }; + + // use crate::ff::PrimeField; + + // fn check_permutation(one: &[F], two: &[F]) -> (bool, Vec) { + // let mut permutation: Vec = (0..one.len()).collect(); + // let mut valid = true; + + // for (i, el) in one.iter().enumerate() { + // let mut idx = 0; + // let mut found = false; + // for (j, el2) in two.iter().enumerate() { + // if *el == *el2 { + // idx = j; + // found = true; + // break; + // } + // } + // if !found { + // println!("Not found for {}", i); + // valid = false; + // break; + // } + // permutation[i] = idx; + // } + + // (valid, permutation) + // } + + // if poly_size < 1000 { + // let (valid, permutation) = check_permutation(&res1, &res2); + + // assert!(valid); + // } + // } + // } + + #[test] + fn test_bench_partial_reduction_bitreversed_lde() { + use crate::ff::Field; + use crate::ff::PrimeField; + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::proth::Fr as Fr; + use super::PartialTwoBitReductionField; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas}; + + let poly_sizes = vec![32, 64, 1_000_000, 2_000_000, 4_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + + let res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.lde(&worker, 16).unwrap(); + println!("LDE with factor 16 for size {} taken {:?}", poly_size, start.elapsed()); + + eval_result.into_coeffs() + }; + + let mut res2 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let precomp = BitReversedOmegas::::new_for_domain_size(poly.size()); + let start = Instant::now(); + let eval_result = poly.bitreversed_lde_using_bitreversed_ntt(&worker, 16, &precomp, &::one()).unwrap(); + println!("LDE with factor 16 for size {} bitreversed {:?}", poly_size, start.elapsed()); + + eval_result + }; + + if poly_size < 1000 { + res2.bitreverse_enumeration(&worker); + assert!(res1 == res2.into_coeffs()); + } + } + } + + #[test] + fn test_bench_ct_proth_fft() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use super::proth::Fr as Fr; + use crate::plonk::polynomials::*; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + use crate::plonk::fft::cooley_tukey_ntt::{CTPrecomputations, BitReversedOmegas, best_ct_ntt}; + use crate::plonk::fft::fft::best_fft; + use crate::plonk::domains::Domain; + + // let poly_sizes = vec![1_000_000, 2_000_000]; + let poly_sizes = vec![1_000_000]; + + // let poly_sizes = vec![2]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let poly_size = poly_size as usize; + let poly_size = poly_size.next_power_of_two(); + + let _res1 = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let log_n = log2_floor(coeffs.len()); + let domain = Domain::new_for_size(coeffs.len() as u64).unwrap(); + + let start = Instant::now(); + best_fft(&mut coeffs, &worker, &domain.generator, log_n, Some(8)); + println!("FFT for size {} taken {:?}", poly_size, start.elapsed()); + + coeffs + }; + + let (input, output) = { + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + let mut coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let input = coeffs.clone(); + let log_n = log2_floor(coeffs.len()); + let precomp = BitReversedOmegas::::new_for_domain_size(coeffs.len()); + + let start = Instant::now(); + best_ct_ntt(&mut coeffs, &worker, log_n, Some(8), &precomp); + println!("CT FFT for size {} taken {:?}", poly_size, start.elapsed()); + + (input, coeffs) + }; + + let mut writer = std::io::BufWriter::with_capacity( + 1<<24, + std::fs::File::create("./fft_test_input.data").unwrap() + ); + + use crate::pairing::ff::{Field, PrimeField}; + use std::io::Write; + use crate::pairing::ff::PrimeFieldRepr; + + let mut scratch = vec![]; + for el in input.into_iter() { + let repr = el.into_raw_repr(); + repr.write_le(&mut scratch).unwrap(); + writer.write_all(&scratch).unwrap(); + scratch.truncate(0); + } + + println!("Results"); + for el in output[0..16].iter() { + println!("{}", el.into_raw_repr()); + } + + let domain = Domain::::new_for_size(poly_size as u64).unwrap(); + + println!("Omegas"); + + assert!(domain.generator.pow(&[1u64<<20]) == Fr::one()); + + for i in 0..=20 { + let pow = 1u64 << i; + println!("Omega^{} = {}", pow, domain.generator.pow(&[pow]).into_raw_repr()); + } + + println!("Idenity = {}", Fr::one().into_raw_repr()); + } + } + +} + + + + diff --git a/src/plonk/transparent_engine/proth.rs b/src/plonk/transparent_engine/proth.rs new file mode 100644 index 000000000..cd9a4880e --- /dev/null +++ b/src/plonk/transparent_engine/proth.rs @@ -0,0 +1,893 @@ +use crate::ff::*; +use super::{PartialReductionField, PartialTwoBitReductionField}; +use rand_core::RngCore; + +#[derive(Copy, Clone, PartialEq, Eq, Default, Hash)] +pub struct FrRepr(pub [u64; 4usize]); + +#[derive(Hash)] +pub struct Fr(FrRepr); + +// const MODULUS: FrRepr = FrRepr([1u64, 0u64, 0u64, 576460752303423505u64]); + +const MODULUS: FrRepr = FrRepr([1u64, 0u64, 0u64, 0x0800_0000_0000_0011]); +const MODULUS_TWICE: FrRepr = FrRepr([2u64, 0u64, 0u64, 0x1000_0000_0000_0022]); + +const MODULUS_BITS: u32 = 252u32; + +const REPR_SHAVE_BITS: u32 = 4u32; + +const S: u32 = 192u32; + +const C: u64 = 1u64; + +// 0800 0000 0000 0011 +const K: u64 = 576460752303423505u64; + +const K_U128: u128 = 576460752303423505u128; + +const NU: [u64; 5] = [ + 0x0000028c81fffbff, + 0xfffffffeccf00000, + 0x0000000000907fff, + 0xffffffffffffbc00, + 0x1f +]; + +const R: FrRepr = FrRepr([ + 18446744073709551585u64, + 18446744073709551615u64, + 18446744073709551615u64, + 576460752303422960u64, +]); + +const R2: FrRepr = FrRepr([ + 18446741271209837569u64, + 5151653887u64, + 18446744073700081664u64, + 576413109808302096u64, +]); + +const GENERATOR: FrRepr = FrRepr([ + 18446744073709551521u64, + 18446744073709551615u64, + 18446744073709551615u64, + 576460752303421872u64, +]); + +const ROOT_OF_UNITY: FrRepr = FrRepr([ + 4685640052668284376u64, + 12298664652803292137u64, + 735711535595279732u64, + 514024103053294630u64, +]); + +// const INV: u64 = 18446744073709551615u64; + +#[inline(always)] +fn add_carry(a: u64, carry: &mut u64) -> u64 { + // use std::num::Wrapping; + + let (low, of) = a.overflowing_add(*carry); + + if of { + *carry = 1u64; + } else { + *carry = 0u64; + } + + low + + // let tmp = u128::from(a).wrapping_add(u128::from(*carry)); + + // *carry = (tmp >> 64) as u64; + + // tmp as u64 +} + +#[inline(always)] +fn sub_borrow(a: u64, borrow: &mut u64) -> u64 { + // use std::num::Wrapping; + + let (low, of) = a.overflowing_sub(*borrow); + + if of { + *borrow = 1u64; + } else { + *borrow = 0u64; + } + + low + + // let tmp = (1u128 << 64).wrapping_add(u128::from(a)).wrapping_sub(u128::from(*borrow)); + + // *borrow = if tmp >> 64 == 0 { 1 } else { 0 }; + + // tmp as u64 +} + +impl ::std::fmt::Debug for FrRepr { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + write!(f, "0x")?; + for i in self.0.iter().rev() { + write!(f, "{:016x}", i)?; + } + + Ok(()) + } +} +impl ::rand::Rand for FrRepr { + #[inline(always)] + fn rand(rng: &mut R) -> Self { + FrRepr(rng.gen()) + } +} +impl ::std::fmt::Display for FrRepr { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + write!(f, "0x")?; + for i in self.0.iter().rev() { + write!(f, "{:016x}", i)?; + } + + Ok(()) + } +} +impl AsRef<[u64]> for FrRepr { + #[inline(always)] + fn as_ref(&self) -> &[u64] { + &self.0 + } +} +impl AsMut<[u64]> for FrRepr { + #[inline(always)] + fn as_mut(&mut self) -> &mut [u64] { + &mut self.0 + } +} +impl From for FrRepr { + #[inline(always)] + fn from(val: u64) -> FrRepr { + use std::default::Default; + let mut repr = Self::default(); + repr.0[0] = val; + repr + } +} +impl Ord for FrRepr { + #[inline(always)] + fn cmp(&self, other: &FrRepr) -> ::std::cmp::Ordering { + for (a, b) in self.0.iter().rev().zip(other.0.iter().rev()) { + if a < b { + return ::std::cmp::Ordering::Less; + } else if a > b { + return ::std::cmp::Ordering::Greater; + } + } + ::std::cmp::Ordering::Equal + } +} +impl PartialOrd for FrRepr { + #[inline(always)] + fn partial_cmp(&self, other: &FrRepr) -> Option<::std::cmp::Ordering> { + Some(self.cmp(other)) + } +} +impl crate::ff::PrimeFieldRepr for FrRepr { + #[inline(always)] + fn is_odd(&self) -> bool { + self.0[0] & 1 == 1 + } + #[inline(always)] + fn is_even(&self) -> bool { + !self.is_odd() + } + #[inline(always)] + fn is_zero(&self) -> bool { + self.0.iter().all(|&e| e == 0) + } + #[inline(always)] + fn shr(&mut self, mut n: u32) { + if n as usize >= 64 * 4usize { + *self = Self::from(0); + return; + } + while n >= 64 { + let mut t = 0; + for i in self.0.iter_mut().rev() { + ::std::mem::swap(&mut t, i); + } + n -= 64; + } + if n > 0 { + let mut t = 0; + for i in self.0.iter_mut().rev() { + let t2 = *i << (64 - n); + *i >>= n; + *i |= t; + t = t2; + } + } + } + #[inline(always)] + fn div2(&mut self) { + let mut t = 0; + for i in self.0.iter_mut().rev() { + let t2 = *i << 63; + *i >>= 1; + *i |= t; + t = t2; + } + } + #[inline(always)] + fn mul2(&mut self) { + let mut last = 0; + for i in &mut self.0 { + let tmp = *i >> 63; + *i <<= 1; + *i |= last; + last = tmp; + } + } + #[inline(always)] + fn shl(&mut self, mut n: u32) { + if n as usize >= 64 * 4usize { + *self = Self::from(0); + return; + } + while n >= 64 { + let mut t = 0; + for i in &mut self.0 { + ::std::mem::swap(&mut t, i); + } + n -= 64; + } + if n > 0 { + let mut t = 0; + for i in &mut self.0 { + let t2 = *i >> (64 - n); + *i <<= n; + *i |= t; + t = t2; + } + } + } + #[inline(always)] + fn num_bits(&self) -> u32 { + let mut ret = (4usize as u32) * 64; + for i in self.0.iter().rev() { + let leading = i.leading_zeros(); + ret -= leading; + if leading != 64 { + break; + } + } + ret + } + #[inline(always)] + fn add_nocarry(&mut self, other: &FrRepr) { + let mut carry = 0; + for (a, b) in self.0.iter_mut().zip(other.0.iter()) { + *a = crate::ff::adc(*a, *b, &mut carry); + } + } + #[inline(always)] + fn sub_noborrow(&mut self, other: &FrRepr) { + let mut borrow = 0; + for (a, b) in self.0.iter_mut().zip(other.0.iter()) { + *a = crate::ff::sbb(*a, *b, &mut borrow); + } + } +} + +impl FrRepr { + #[inline(always)] + fn add_modulus_nocarry(&mut self) { + let mut carry = MODULUS.0[0usize]; + self.0[0] = add_carry(self.0[0], &mut carry); + self.0[1] = add_carry(self.0[1], &mut carry); + self.0[2] = add_carry(self.0[2], &mut carry); + + self.0[3] = crate::ff::adc(self.0[3], MODULUS.0[3usize], &mut carry); + } + + #[inline(always)] + fn sub_modulus_noborrow(&mut self) { + let mut borrow = MODULUS.0[0usize]; + // sub one, so just sub borrow + self.0[0] = sub_borrow(self.0[0], &mut borrow); + // sub borrow + self.0[1] = sub_borrow(self.0[1], &mut borrow); + // sub borrow + self.0[2] = sub_borrow(self.0[2], &mut borrow); + + self.0[3] = crate::ff::sbb(self.0[3], MODULUS.0[3usize], &mut borrow); + } + + #[inline(always)] + fn add_modulus_twice_nocarry(&mut self) { + let mut carry = MODULUS_TWICE.0[0]; + self.0[0] = add_carry(self.0[0], &mut carry); + self.0[1] = add_carry(self.0[1], &mut carry); + self.0[2] = add_carry(self.0[2], &mut carry); + + self.0[3] = crate::ff::adc(self.0[3], MODULUS_TWICE.0[3usize], &mut carry); + } + + #[inline(always)] + fn sub_modulus_twice_noborrow(&mut self) { + let mut borrow = MODULUS_TWICE.0[0]; + // sub one, so just sub borrow + self.0[0] = sub_borrow(self.0[0], &mut borrow); + // sub borrow + self.0[1] = sub_borrow(self.0[1], &mut borrow); + // sub borrow + self.0[2] = sub_borrow(self.0[2], &mut borrow); + + self.0[3] = crate::ff::sbb(self.0[3], MODULUS_TWICE.0[3usize], &mut borrow); + } +} + +impl ::std::marker::Copy for Fr {} +impl ::std::clone::Clone for Fr { + fn clone(&self) -> Fr { + *self + } +} +impl ::std::cmp::PartialEq for Fr { + fn eq(&self, other: &Fr) -> bool { + self.0 == other.0 + } +} +impl ::std::cmp::Eq for Fr {} + +impl ::std::fmt::Debug for Fr { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + write!(f, "{}({:?})", "Fr", self.into_repr()) + } +} + +impl Ord for Fr { + #[inline(always)] + fn cmp(&self, other: &Fr) -> ::std::cmp::Ordering { + self.into_repr().cmp(&other.into_repr()) + } +} + +impl PartialOrd for Fr { + #[inline(always)] + fn partial_cmp(&self, other: &Fr) -> Option<::std::cmp::Ordering> { + Some(self.cmp(other)) + } +} + +impl ::std::fmt::Display for Fr { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + write!(f, "{}({:?})", "Fr", self.into_repr()) + } +} + +impl ::rand::Rand for Fr { + fn rand(rng: &mut R) -> Self { + loop { + let mut tmp = Fr(FrRepr::rand(rng)); + tmp.0.as_mut()[3usize] &= 0xffffffffffffffff >> REPR_SHAVE_BITS; + if tmp.is_valid() { + return tmp; + } + } + } +} + +impl From for FrRepr { + fn from(e: Fr) -> FrRepr { + e.into_repr() + } +} + +impl crate::ff::PrimeField for Fr { + type Repr = FrRepr; + + fn from_repr(r: FrRepr) -> Result { + let mut r = Fr(r); + if r.is_valid() { + r.mul_assign(&Fr(R2)); + Ok(r) + } else { + Err(crate::ff::PrimeFieldDecodingError::NotInField(format!("{}", r.0))) + } + } + + fn from_raw_repr(r: FrRepr) -> Result { + let r = Fr(r); + if r.is_valid() { + Ok(r) + } else { + Err(crate::ff::PrimeFieldDecodingError::NotInField(format!("{}", r.0))) + } + } + + fn into_repr(&self) -> FrRepr { + let mut r = *self; + r.mont_reduce( + (self.0).0[0usize], + (self.0).0[1usize], + (self.0).0[2usize], + (self.0).0[3usize], + 0, + 0, + 0, + 0, + ); + + r.0 + } + + fn into_raw_repr(&self) -> FrRepr { + let r = *self; + r.0 + } + + fn char() -> FrRepr { + MODULUS + } + + const NUM_BITS: u32 = MODULUS_BITS; + const CAPACITY: u32 = Self::NUM_BITS - 1; + + fn multiplicative_generator() -> Self { + Fr(GENERATOR) + } + + const S: u32 = S; + fn root_of_unity() -> Self { + Fr(ROOT_OF_UNITY) + } +} + + +impl crate::ff::Field for Fr { + #[inline] + fn zero() -> Self { + Fr(FrRepr::default()) + } + + #[inline] + fn one() -> Self { + Fr(R) + } + + #[inline] + fn is_zero(&self) -> bool { + self.0.is_zero() + } + + #[inline] + fn add_assign(&mut self, other: &Fr) { + self.0.add_nocarry(&other.0); + self.reduce(); + } + + #[inline] + fn double(&mut self) { + self.0.mul2(); + self.reduce(); + } + + #[inline] + fn sub_assign(&mut self, other: &Fr) { + if other.0 > self.0 { + self.0.add_modulus_nocarry(); + // self.0.add_nocarry(&MODULUS); + } + self.0.sub_noborrow(&other.0); + } + + #[inline] + fn negate(&mut self) { + if !self.is_zero() { + let mut tmp = MODULUS; + tmp.sub_noborrow(&self.0); + self.0 = tmp; + } + } + + fn inverse(&self) -> Option { + if self.is_zero() { + None + } else { + let one = FrRepr::from(1); + let mut u = self.0; + let mut v = MODULUS; + let mut b = Fr(R2); + let mut c = Self::zero(); + while u != one && v != one { + while u.is_even() { + u.div2(); + if b.0.is_even() { + b.0.div2(); + } else { + b.0.add_modulus_nocarry(); + // b.0.add_nocarry(&MODULUS); + b.0.div2(); + } + } + while v.is_even() { + v.div2(); + if c.0.is_even() { + c.0.div2(); + } else { + c.0.add_modulus_nocarry(); + // c.0.add_nocarry(&MODULUS); + c.0.div2(); + } + } + if v < u { + u.sub_noborrow(&v); + b.sub_assign(&c); + } else { + v.sub_noborrow(&u); + c.sub_assign(&b); + } + } + if u == one { + Some(b) + } else { + Some(c) + } + } + } + + #[inline(always)] + fn frobenius_map(&mut self, _: usize) {} + + #[inline] + fn mul_assign(&mut self, other: &Fr) { + let mut carry = 0; + let r0 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[0usize], &mut carry); + let r1 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[1usize], &mut carry); + let r2 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[2usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[3usize], &mut carry); + let r4 = carry; + let mut carry = 0; + let r1 = + crate::ff::mac_with_carry(r1, (self.0).0[1usize], (other.0).0[0usize], &mut carry); + let r2 = + crate::ff::mac_with_carry(r2, (self.0).0[1usize], (other.0).0[1usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[1usize], (other.0).0[2usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[1usize], (other.0).0[3usize], &mut carry); + let r5 = carry; + let mut carry = 0; + let r2 = + crate::ff::mac_with_carry(r2, (self.0).0[2usize], (other.0).0[0usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[2usize], (other.0).0[1usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[2usize], (other.0).0[2usize], &mut carry); + let r5 = + crate::ff::mac_with_carry(r5, (self.0).0[2usize], (other.0).0[3usize], &mut carry); + let r6 = carry; + let mut carry = 0; + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[3usize], (other.0).0[0usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[3usize], (other.0).0[1usize], &mut carry); + let r5 = + crate::ff::mac_with_carry(r5, (self.0).0[3usize], (other.0).0[2usize], &mut carry); + let r6 = + crate::ff::mac_with_carry(r6, (self.0).0[3usize], (other.0).0[3usize], &mut carry); + let r7 = carry; + self.mont_reduce(r0, r1, r2, r3, r4, r5, r6, r7); + } + + #[inline] + fn square(&mut self) { + let mut carry = 0; + let r1 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (self.0).0[1usize], &mut carry); + let r2 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (self.0).0[2usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (self.0).0[3usize], &mut carry); + let r4 = carry; + let mut carry = 0; + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[1usize], (self.0).0[2usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[1usize], (self.0).0[3usize], &mut carry); + let r5 = carry; + let mut carry = 0; + let r5 = + crate::ff::mac_with_carry(r5, (self.0).0[2usize], (self.0).0[3usize], &mut carry); + let r6 = carry; + let r7 = r6 >> 63; + let r6 = (r6 << 1) | (r5 >> 63); + let r5 = (r5 << 1) | (r4 >> 63); + let r4 = (r4 << 1) | (r3 >> 63); + let r3 = (r3 << 1) | (r2 >> 63); + let r2 = (r2 << 1) | (r1 >> 63); + let r1 = r1 << 1; + let mut carry = 0; + let r0 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (self.0).0[0usize], &mut carry); + let r1 = crate::ff::adc(r1, 0, &mut carry); + let r2 = + crate::ff::mac_with_carry(r2, (self.0).0[1usize], (self.0).0[1usize], &mut carry); + let r3 = crate::ff::adc(r3, 0, &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[2usize], (self.0).0[2usize], &mut carry); + let r5 = crate::ff::adc(r5, 0, &mut carry); + let r6 = + crate::ff::mac_with_carry(r6, (self.0).0[3usize], (self.0).0[3usize], &mut carry); + let r7 = crate::ff::adc(r7, 0, &mut carry); + self.mont_reduce(r0, r1, r2, r3, r4, r5, r6, r7); + } + + // fn random(rng: &mut R) -> Self { + // unimplemented!() + // } +} + +impl std::default::Default for Fr { + fn default() -> Self { + Self::zero() + } +} + +impl Fr { + #[inline(always)] + fn is_valid(&self) -> bool { + self.0 < MODULUS + } + + #[inline(always)] + fn is_below_modulus_twice(&self) -> bool { + self.0 < MODULUS_TWICE + } + + #[inline(always)] + fn reduce(&mut self) { + if !self.is_valid() { + self.0.sub_modulus_noborrow(); + // self.0.sub_noborrow(&MODULUS); + } + } + + #[inline(always)] + fn mont_reduce_unreduced( + &mut self, + r0: u64, + mut r1: u64, + mut r2: u64, + mut r3: u64, + mut r4: u64, + mut r5: u64, + mut r6: u64, + mut r7: u64, + ) { + let k = (!r0).wrapping_add(1); + let mut carry = 0; + crate::ff::adc(r0, k, &mut carry); + r1 = add_carry(r1, &mut carry); + r2 = add_carry(r2, &mut carry); + r3 = crate::ff::mac_with_carry(r3, k, MODULUS.0[3usize], &mut carry); + r4 = add_carry(r4, &mut carry); + + let carry2 = carry; + let k = (!r1).wrapping_add(1); + let mut carry = 0; + crate::ff::adc(r1, k, &mut carry); + r2 = add_carry(r2, &mut carry); + r3 = add_carry(r3, &mut carry); + r4 = crate::ff::mac_with_carry(r4, k, MODULUS.0[3usize], &mut carry); + r5 = crate::ff::adc(r5, carry2, &mut carry); + + let carry2 = carry; + let k = (!r2).wrapping_add(1); + let mut carry = 0; + crate::ff::adc(r2, k, &mut carry); + r3 = add_carry(r3, &mut carry); + r4 = add_carry(r4, &mut carry); + r5 = crate::ff::mac_with_carry(r5, k, MODULUS.0[3usize], &mut carry); + r6 = crate::ff::adc(r6, carry2, &mut carry); + + let carry2 = carry; + let k = (!r3).wrapping_add(1); + let mut carry = 0; + crate::ff::adc(r3, k, &mut carry); + r4 = add_carry(r4, &mut carry); + r5 = add_carry(r5, &mut carry); + r6 = crate::ff::mac_with_carry(r6, k, MODULUS.0[3usize], &mut carry); + r7 = crate::ff::adc(r7, carry2, &mut carry); + + (self.0).0[0usize] = r4; + (self.0).0[1usize] = r5; + (self.0).0[2usize] = r6; + (self.0).0[3usize] = r7; + } + + #[inline(always)] + fn mont_reduce(&mut self, + r0: u64, + r1: u64, + r2: u64, + r3: u64, + r4: u64, + r5: u64, + r6: u64, + r7: u64, + ) { + self.mont_reduce_unreduced(r0, r1, r2, r3, r4, r5, r6, r7); + self.reduce(); + } + + pub fn to_hex(&self) -> String { + let mut buf: Vec = Vec::with_capacity(32); + self.into_repr().write_be(&mut buf).unwrap(); + crate::ff::hex::encode(&buf) + } + + pub fn from_hex(value: &str) -> Result { + let value = if value.starts_with("0x") { &value[2..] } else { value }; + if value.len() % 2 != 0 {return Err(format!("hex length must be even for full byte encoding: {}", value))} + let mut buf = crate::ff::hex::decode(&value).map_err(|_| format!("could not decode hex: {}", value))?; + buf.reverse(); + buf.resize(32, 0); + let mut repr = FrRepr::default(); + repr.read_le(&buf[..]).map_err(|e| format!("could not read {}: {}", value, &e))?; + Fr::from_repr(repr).map_err(|e| format!("could not convert into prime field: {}: {}", value, &e)) + } +} + +impl crate::ff::SqrtField for Fr { + fn legendre(&self) -> crate::ff::LegendreSymbol { + let s = self.pow([0u64, 0u64, 9223372036854775808u64, 288230376151711752u64]); + if s == Self::zero() { + crate::ff::LegendreSymbol::Zero + } else if s == Self::one() { + crate::ff::LegendreSymbol::QuadraticResidue + } else { + crate::ff::LegendreSymbol::QuadraticNonResidue + } + } + fn sqrt(&self) -> Option { + match self.legendre() { + crate::ff::LegendreSymbol::Zero => Some(*self), + crate::ff::LegendreSymbol::QuadraticNonResidue => None, + crate::ff::LegendreSymbol::QuadraticResidue => { + let mut c = Fr(ROOT_OF_UNITY); + let mut r = self.pow([288230376151711753u64, 0u64, 0u64, 0u64]); + let mut t = self.pow([576460752303423505u64, 0u64, 0u64, 0u64]); + let mut m = S; + while t != Self::one() { + let mut i = 1; + { + let mut t2i = t; + t2i.square(); + loop { + if t2i == Self::one() { + break; + } + t2i.square(); + i += 1; + } + } + for _ in 0..(m - i - 1) { + c.square(); + } + r.mul_assign(&c); + c.square(); + t.mul_assign(&c); + m = i; + } + Some(r) + } + } + } +} + + +impl PartialReductionField for Fr { + #[inline(always)] + fn add_assign_unreduced(&mut self, other: &Fr) { + self.0.add_nocarry(&other.0); + } + + #[inline(always)] + fn sub_assign_unreduced(&mut self, other: &Self) { + self.0.add_modulus_nocarry(); + self.0.sub_noborrow(&other.0); + } + + #[inline] + fn mul_assign_unreduced(&mut self, other: &Fr) { + let mut carry = 0; + let r0 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[0usize], &mut carry); + let r1 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[1usize], &mut carry); + let r2 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[2usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(0, (self.0).0[0usize], (other.0).0[3usize], &mut carry); + let r4 = carry; + let mut carry = 0; + let r1 = + crate::ff::mac_with_carry(r1, (self.0).0[1usize], (other.0).0[0usize], &mut carry); + let r2 = + crate::ff::mac_with_carry(r2, (self.0).0[1usize], (other.0).0[1usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[1usize], (other.0).0[2usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[1usize], (other.0).0[3usize], &mut carry); + let r5 = carry; + let mut carry = 0; + let r2 = + crate::ff::mac_with_carry(r2, (self.0).0[2usize], (other.0).0[0usize], &mut carry); + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[2usize], (other.0).0[1usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[2usize], (other.0).0[2usize], &mut carry); + let r5 = + crate::ff::mac_with_carry(r5, (self.0).0[2usize], (other.0).0[3usize], &mut carry); + let r6 = carry; + let mut carry = 0; + let r3 = + crate::ff::mac_with_carry(r3, (self.0).0[3usize], (other.0).0[0usize], &mut carry); + let r4 = + crate::ff::mac_with_carry(r4, (self.0).0[3usize], (other.0).0[1usize], &mut carry); + let r5 = + crate::ff::mac_with_carry(r5, (self.0).0[3usize], (other.0).0[2usize], &mut carry); + let r6 = + crate::ff::mac_with_carry(r6, (self.0).0[3usize], (other.0).0[3usize], &mut carry); + let r7 = carry; + self.mont_reduce_unreduced(r0, r1, r2, r3, r4, r5, r6, r7); + } + + #[inline(always)] + fn reduce_once(&mut self) { + self.reduce(); + } + + #[inline(always)] + fn reduce_completely(&mut self) { + self.reduce_once(); + } + + fn overflow_factor(&self) -> usize { + let mut factor = 0usize; + let mut this = *self; + while !this.is_valid() { + this.0.sub_modulus_noborrow(); + factor += 1; + } + + factor + } +} + +impl PartialTwoBitReductionField for Fr { + #[inline(always)] + fn sub_assign_twice_unreduced(&mut self, other: &Self) { + self.0.add_modulus_twice_nocarry(); + self.0.sub_noborrow(&other.0); + } + + #[inline(always)] + fn reduce_twice(&mut self) { + if !self.is_below_modulus_twice() { + self.0.sub_modulus_twice_noborrow(); + } + } + + #[inline(always)] + fn reduce_completely(&mut self) { + self.reduce_twice(); + self.reduce_once(); + } +} \ No newline at end of file diff --git a/src/plonk/transparent_engine/proth_engine.rs b/src/plonk/transparent_engine/proth_engine.rs new file mode 100644 index 000000000..80ba65979 --- /dev/null +++ b/src/plonk/transparent_engine/proth_engine.rs @@ -0,0 +1,10 @@ +pub use super::proth::Fr; + +use super::impl_macro::*; + +use super::TransparentEngine; +use rand_core::RngCore; + +transparent_engine_impl!{Transparent252, Fr} + +impl TransparentEngine for Transparent252 {} \ No newline at end of file diff --git a/src/plonk/utils.rs b/src/plonk/utils.rs new file mode 100644 index 000000000..580177b35 --- /dev/null +++ b/src/plonk/utils.rs @@ -0,0 +1,22 @@ +use crate::worker::*; +use crate::pairing::ff::PrimeField; + +pub(crate) fn convert_to_field_elements(indexes: &[usize], worker: &Worker) -> Vec { + let mut result = vec![F::zero(); indexes.len()]; + + worker.scope(indexes.len(), |scope, chunk| { + for (idx, fe) in indexes.chunks(chunk) + .zip(result.chunks_mut(chunk)) { + scope.spawn(move |_| { + let mut repr = F::zero().into_repr(); + for (idx, fe) in idx.iter().zip(fe.iter_mut()) { + repr.as_mut()[0] = *idx as u64; + *fe = F::from_repr(repr).expect("is a valid representation"); + } + }); + } + }); + + result +} + diff --git a/src/plonk/verifier/mod.rs b/src/plonk/verifier/mod.rs new file mode 100644 index 000000000..d7fec41fb --- /dev/null +++ b/src/plonk/verifier/mod.rs @@ -0,0 +1,1423 @@ +use crate::pairing::ff::{Field, PrimeField}; +use crate::pairing::{Engine}; + +use crate::{SynthesisError}; +use std::marker::PhantomData; + +use crate::plonk::cs::gates::*; +use crate::plonk::cs::*; + +use crate::worker::*; +use super::polynomials::*; +use super::domains::*; +use crate::plonk::commitments::*; +use crate::plonk::commitments::transcript::*; +use crate::plonk::utils::*; +use crate::plonk::generator::*; +use crate::plonk::prover::*; + +fn evaluate_inverse_vanishing_poly(vahisning_size: usize, point: E::Fr) -> E::Fr { + assert!(vahisning_size.is_power_of_two()); + + // update from the paper - it should not hold for the last generator, omega^(n) in original notations + + // Z(X) = (X^(n+1) - 1) / (X - omega^(n)) => Z^{-1}(X) = (X - omega^(n)) / (X^(n+1) - 1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("should fit"); + let n_domain_omega = domain.generator; + let root = n_domain_omega.pow([(vahisning_size - 1) as u64]); + + let mut numerator = point; + numerator.sub_assign(&root); + + let mut denominator = point.pow([vahisning_size as u64]); + denominator.sub_assign(&E::Fr::one()); + + let denominator = denominator.inverse().expect("must exist"); + + numerator.mul_assign(&denominator); + + numerator +} + +fn evaluate_lagrange_poly(vahisning_size:usize, poly_number: usize, at: E::Fr) -> E::Fr { + assert!(vahisning_size.is_power_of_two()); + + let mut repr = E::Fr::zero().into_repr(); + repr.as_mut()[0] = vahisning_size as u64; + + let size_fe = E::Fr::from_repr(repr).expect("is a valid representation"); + // let size_inv = n_fe.inverse().expect("must exist"); + + // L_0(X) = (Z_H(X) / (X - 1)).(1/n) and L_0(1) = 1 + // L_1(omega) = 1 = L_0(omega * omega^-1) + + let domain = Domain::::new_for_size(vahisning_size as u64).expect("domain of this size should exist"); + let omega = domain.generator; + + let omega_inv = omega.inverse().expect("must exist"); + + let argument_multiplier = omega_inv.pow([poly_number as u64]); + let mut argument = at; + argument.mul_assign(&argument_multiplier); + + let mut numerator = argument.pow([vahisning_size as u64]); + numerator.sub_assign(&E::Fr::one()); + + let mut denom = argument; + denom.sub_assign(&E::Fr::one()); + denom.mul_assign(&size_fe); + + let denom_inv = denom.inverse().expect("must exist"); + + numerator.mul_assign(&denom_inv); + + numerator +} + +pub fn verify_nonhomomorphic, T: Transcript>( + setup: &PlonkSetup, + proof: &PlonkNonhomomorphicProof, + meta: S::Meta, + large_meta: S::Meta +) -> Result { + assert!(S::IS_HOMOMORPHIC == false); + + let num_gates = setup.n; + + let committer = S::new_for_size(num_gates.next_power_of_two(), meta); + let large_committer = S::new_for_size(4 * num_gates.next_power_of_two(), large_meta); + + let mut transcript = T::new(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = setup.n + 1; + assert!(required_domain_size.is_power_of_two()); + + transcript.commit_input(&proof.a_commitment); + transcript.commit_input(&proof.b_commitment); + transcript.commit_input(&proof.c_commitment); + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + transcript.commit_input(&proof.z_1_commitment); + transcript.commit_input(&proof.z_2_commitment); + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&setup.n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + transcript.commit_input(&proof.t_commitment); + + let z = transcript.get_challenge(); + + // this is a sanity check + + let a_at_z = proof.a_opening_value; + let b_at_z = proof.b_opening_value; + let c_at_z = proof.c_opening_value; + + let q_l_at_z = proof.q_l_opening_value; + let q_r_at_z = proof.q_r_opening_value; + let q_o_at_z = proof.q_o_opening_value; + let q_m_at_z = proof.q_m_opening_value; + let q_c_at_z = proof.q_c_opening_value; + + let s_id_at_z = proof.s_id_opening_value; + let sigma_1_at_z = proof.sigma_1_opening_value; + let sigma_2_at_z = proof.sigma_2_opening_value; + let sigma_3_at_z = proof.sigma_3_opening_value; + + let mut inverse_vanishing_at_z = evaluate_inverse_vanishing_poly::(required_domain_size.next_power_of_two(), z); + + let z_1_at_z = proof.z_1_unshifted_opening_value; + let z_2_at_z = proof.z_2_unshifted_opening_value; + + let z_1_shifted_at_z = proof.z_1_shifted_opening_value; + let z_2_shifted_at_z = proof.z_2_shifted_opening_value; + + let l_0_at_z = evaluate_lagrange_poly::(required_domain_size.next_power_of_two(), 0, z); + let l_n_minus_one_at_z = evaluate_lagrange_poly::(required_domain_size.next_power_of_two(), setup.n - 1, z); + + let t_at_z = proof.t_opening_value; + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + let aggregation_challenge = transcript.get_challenge(); + + // let shifted_opening_aggregation_challenge = transcript.get_challenge(); + + // TODO: add public inputs + + // verify by blindly assembling a t poly + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + let domain = Domain::::new_for_size(required_domain_size as u64)?; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + let commitments = vec![ + &proof.a_commitment, + &proof.b_commitment, + &proof.c_commitment, + &setup.q_l, + &setup.q_r, + &setup.q_o, + &setup.q_m, + &setup.q_c, + &setup.s_id, + &setup.sigma_1, + &setup.sigma_2, + &setup.sigma_3, + &proof.z_1_commitment, + &proof.z_2_commitment, + &proof.z_1_commitment, + &proof.z_2_commitment, + ]; + + let claimed_values = vec![ + a_at_z, + b_at_z, + c_at_z, + q_l_at_z, + q_r_at_z, + q_o_at_z, + q_m_at_z, + q_c_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + z_1_at_z, + z_2_at_z, + z_1_shifted_at_z, + z_2_shifted_at_z, + ]; + + let opening_points = vec![ + z, + z, + z, + + z, + z, + z, + z, + z, + + z, + z, + z, + z, + + z, + z, + + z_by_omega, + z_by_omega + ]; + + if t_1 != t_at_z { + println!("Recalculated t(z) is not equal to the provided value"); + return Ok(false); + } + + let valid = committer.verify_multiple_openings(commitments, opening_points, &claimed_values, aggregation_challenge, &proof.openings_proof, &mut transcript); + + if !valid { + println!("Multiopening is invalid"); + return Ok(false); + } + + let valid = large_committer.verify_single(&proof.t_commitment, z, proof.t_opening_value, &proof.t_opening_proof, &mut transcript); + + if !valid { + println!("T commitment opening is invalid"); + return Ok(false); + } + + + + // let mut opening_point = z; + // opening_point.mul_assign(&domain.generator); + + // let commitments = vec![ + // &proof.z_1_commitment, + // &proof.z_2_commitment, + // ]; + + // let claimed_values = vec![ + // proof.z_1_shifted_opening_value, + // proof.z_2_shifted_opening_value + // ]; + + // let valid = committer.verify_multiple_openings(commitments, opening_point, &claimed_values, shifted_opening_aggregation_challenge, &proof.shifted_openings_proof, &mut transcript); + + Ok(valid) +} + +pub fn verify_nonhomomorphic_chunked, T: Transcript>( + setup: &PlonkSetup, + proof: &PlonkChunkedNonhomomorphicProof, + meta: S::Meta +) -> Result { + assert!(S::IS_HOMOMORPHIC == false); + + let num_gates = setup.n; + + let committer = S::new_for_size(num_gates.next_power_of_two(), meta); + + let mut transcript = T::new(); + + // we need n+1 to be a power of two and can not have n to be power of two + let required_domain_size = setup.n + 1; + assert!(required_domain_size.is_power_of_two()); + + transcript.commit_input(&proof.a_commitment); + transcript.commit_input(&proof.b_commitment); + transcript.commit_input(&proof.c_commitment); + + let beta = transcript.get_challenge(); + let gamma = transcript.get_challenge(); + + transcript.commit_input(&proof.z_1_commitment); + transcript.commit_input(&proof.z_2_commitment); + + // we do not commit those cause those are known already + + let n_fe = E::Fr::from_str(&setup.n.to_string()).expect("must be valid field element"); + let mut two_n_fe = n_fe; + two_n_fe.double(); + + let alpha = transcript.get_challenge(); + + transcript.commit_input(&proof.t_low_commitment); + transcript.commit_input(&proof.t_mid_commitment); + transcript.commit_input(&proof.t_high_commitment); + + let z = transcript.get_challenge(); + + // this is a sanity check + + let a_at_z = proof.a_opening_value; + let b_at_z = proof.b_opening_value; + let c_at_z = proof.c_opening_value; + + let q_l_at_z = proof.q_l_opening_value; + let q_r_at_z = proof.q_r_opening_value; + let q_o_at_z = proof.q_o_opening_value; + let q_m_at_z = proof.q_m_opening_value; + let q_c_at_z = proof.q_c_opening_value; + + let s_id_at_z = proof.s_id_opening_value; + let sigma_1_at_z = proof.sigma_1_opening_value; + let sigma_2_at_z = proof.sigma_2_opening_value; + let sigma_3_at_z = proof.sigma_3_opening_value; + + let mut inverse_vanishing_at_z = evaluate_inverse_vanishing_poly::(required_domain_size, z); + + let z_1_at_z = proof.z_1_unshifted_opening_value; + let z_2_at_z = proof.z_2_unshifted_opening_value; + + let z_1_shifted_at_z = proof.z_1_shifted_opening_value; + let z_2_shifted_at_z = proof.z_2_shifted_opening_value; + + let l_0_at_z = evaluate_lagrange_poly::(required_domain_size, 0, z); + let l_n_minus_one_at_z = evaluate_lagrange_poly::(required_domain_size, setup.n - 1, z); + + let t_low_at_z = proof.t_low_opening_value; + let t_mid_at_z = proof.t_mid_opening_value; + let t_high_at_z = proof.t_high_opening_value; + + let z_in_pow_of_domain_size = z.pow([required_domain_size as u64]); + + let mut t_at_z = E::Fr::zero(); + t_at_z.add_assign(&t_low_at_z); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&t_mid_at_z); + t_at_z.add_assign(&tmp); + + let mut tmp = z_in_pow_of_domain_size; + tmp.mul_assign(&z_in_pow_of_domain_size); + tmp.mul_assign(&t_high_at_z); + t_at_z.add_assign(&tmp); + + { + transcript.commit_field_element(&a_at_z); + transcript.commit_field_element(&b_at_z); + transcript.commit_field_element(&c_at_z); + + transcript.commit_field_element(&q_l_at_z); + transcript.commit_field_element(&q_r_at_z); + transcript.commit_field_element(&q_o_at_z); + transcript.commit_field_element(&q_m_at_z); + transcript.commit_field_element(&q_c_at_z); + + transcript.commit_field_element(&s_id_at_z); + transcript.commit_field_element(&sigma_1_at_z); + transcript.commit_field_element(&sigma_2_at_z); + transcript.commit_field_element(&sigma_3_at_z); + + transcript.commit_field_element(&t_low_at_z); + transcript.commit_field_element(&t_mid_at_z); + transcript.commit_field_element(&t_high_at_z); + + transcript.commit_field_element(&z_1_at_z); + transcript.commit_field_element(&z_2_at_z); + + transcript.commit_field_element(&z_1_shifted_at_z); + transcript.commit_field_element(&z_2_shifted_at_z); + } + + let aggregation_challenge = transcript.get_challenge(); + + // TODO: add public inputs + + // verify by blindly assembling a t poly + let mut t_1 = { + let mut res = q_c_at_z; + + let mut tmp = q_l_at_z; + tmp.mul_assign(&a_at_z); + res.add_assign(&tmp); + + let mut tmp = q_r_at_z; + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + let mut tmp = q_o_at_z; + tmp.mul_assign(&c_at_z); + res.add_assign(&tmp); + + let mut tmp = q_m_at_z; + tmp.mul_assign(&a_at_z); + tmp.mul_assign(&b_at_z); + res.add_assign(&tmp); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + res + }; + + { + let mut res = z_1_at_z; + + let mut tmp = s_id_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = s_id_at_z; + tmp.add_assign(&two_n_fe); + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_1_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_2_at_z; + + let mut tmp = sigma_1_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&a_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_2_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&b_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + let mut tmp = sigma_3_at_z; + tmp.mul_assign(&beta); + tmp.add_assign(&c_at_z); + tmp.add_assign(&gamma); + res.mul_assign(&tmp); + + res.sub_assign(&z_2_shifted_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_shifted_at_z; + res.sub_assign(&z_2_shifted_at_z); + res.mul_assign(&l_n_minus_one_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + { + let mut res = z_1_at_z; + res.sub_assign(&z_2_at_z); + res.mul_assign(&l_0_at_z); + + inverse_vanishing_at_z.mul_assign(&alpha); + + res.mul_assign(&inverse_vanishing_at_z); + + t_1.add_assign(&res); + } + + let domain = Domain::::new_for_size(required_domain_size as u64)?; + + let mut z_by_omega = z; + z_by_omega.mul_assign(&domain.generator); + + let commitments = vec![ + &proof.a_commitment, + &proof.b_commitment, + &proof.c_commitment, + &setup.q_l, + &setup.q_r, + &setup.q_o, + &setup.q_m, + &setup.q_c, + &setup.s_id, + &setup.sigma_1, + &setup.sigma_2, + &setup.sigma_3, + &proof.z_1_commitment, + &proof.z_2_commitment, + &proof.z_1_commitment, + &proof.z_2_commitment, + &proof.t_low_commitment, + &proof.t_mid_commitment, + &proof.t_high_commitment, + ]; + + let claimed_values = vec![ + a_at_z, + b_at_z, + c_at_z, + q_l_at_z, + q_r_at_z, + q_o_at_z, + q_m_at_z, + q_c_at_z, + s_id_at_z, + sigma_1_at_z, + sigma_2_at_z, + sigma_3_at_z, + z_1_at_z, + z_2_at_z, + z_1_shifted_at_z, + z_2_shifted_at_z, + t_low_at_z, + t_mid_at_z, + t_high_at_z, + ]; + + let opening_points = vec![ + z, + z, + z, + + z, + z, + z, + z, + z, + + z, + z, + z, + z, + + z, + z, + + z_by_omega, + z_by_omega, + + z, + z, + z, + ]; + + if t_1 != t_at_z { + println!("Recalculated t(z) is not equal to the provided value"); + return Ok(false); + } + + let valid = committer.verify_multiple_openings(commitments, opening_points, &claimed_values, aggregation_challenge, &proof.openings_proof, &mut transcript); + + if !valid { + println!("Multiopening is invalid"); + return Ok(false); + } + + Ok(valid) +} + +#[cfg(test)] +mod test { + + use super::*; + use crate::pairing::ff::{Field, PrimeField}; + use crate::pairing::{Engine}; + + use crate::{SynthesisError}; + use std::marker::PhantomData; + + use crate::plonk::cs::gates::*; + use crate::plonk::cs::*; + + struct TestCircuit{ + _marker: PhantomData + } + + impl Circuit for TestCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("10").unwrap()) + })?; + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + cs.enforce_zero_2((a, b), (two, negative_one))?; + + let ten = E::Fr::from_str("10").unwrap(); + cs.enforce_zero_2((b, c), (ten, negative_one))?; + + cs.enforce_mul_3((a, b, c))?; + + Ok(()) + } + } + + struct InvalidTestCircuit{ + _marker: PhantomData + } + + impl Circuit for InvalidTestCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + let a = cs.alloc(|| { + Ok(E::Fr::from_str("11").unwrap()) + })?; + + let b = cs.alloc(|| { + Ok(E::Fr::from_str("20").unwrap()) + })?; + + let c = cs.alloc(|| { + Ok(E::Fr::from_str("200").unwrap()) + })?; + + let one = E::Fr::one(); + + let mut two = one; + two.double(); + + let mut negative_one = one; + negative_one.negate(); + + cs.enforce_zero_2((a, b), (two, negative_one))?; + + let ten = E::Fr::from_str("10").unwrap(); + cs.enforce_zero_2((b, c), (ten, negative_one))?; + + cs.enforce_mul_3((a, b, c))?; + + Ok(()) + } + } + + #[test] + fn test_small_circuit_transparent_verification() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + use crate::plonk::commitments::transparent::*; + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + let meta_large = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + let circuit = TestCircuit:: { + _marker: PhantomData + }; + + let (setup, aux) = setup::(&circuit, meta).unwrap(); + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + println!("Proving"); + + let proof = prove_nonhomomorphic::, _>(&circuit, &setup, &aux, meta.clone(), meta_large.clone()).unwrap(); + + + println!("Verifying"); + + let valid = verify_nonhomomorphic::>(&setup, &proof, meta, meta_large).unwrap(); + + assert!(valid); + } + + #[test] + fn test_small_circuit_invalid_witness_transparent_verification() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + use crate::plonk::commitments::transparent::*; + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + let meta_large = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 2, + output_coeffs_at_degree_plus_one: 1, + fri_params: () + }; + + let circuit = InvalidTestCircuit:: { + _marker: PhantomData + }; + + let (setup, aux) = setup::(&circuit, meta.clone()).unwrap(); + + println!("Proving"); + + let proof = prove_nonhomomorphic::, _>(&circuit, &setup, &aux, meta.clone(), meta_large.clone()).unwrap(); + + println!("Verifying"); + + let valid = verify_nonhomomorphic::>(&setup, &proof, meta, meta_large).unwrap(); + + assert!(!valid); + } + + #[derive(Clone)] + struct BenchmarkCircuit{ + num_steps: usize, + _marker: PhantomData + } + + impl Circuit for BenchmarkCircuit { + fn synthesize>(&self, cs: &mut CS) -> Result<(), SynthesisError> { + // yeah, fibonacci... + + let one = E::Fr::one(); + let mut negative_one = one; + negative_one.negate(); + + let mut two = one; + two.double(); + + let mut a = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + let mut b = cs.alloc(|| { + Ok(E::Fr::one()) + })?; + + cs.enforce_zero_2((a, CS::ONE), (one, negative_one))?; + cs.enforce_zero_2((b, CS::ONE), (one, negative_one))?; + + let mut c = cs.alloc(|| { + Ok(two) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + + let mut a_value = one; + let mut b_value = one; + let mut c_value = two; + + for _ in 0..self.num_steps { + a = b; + b = c; + + a_value = b_value; + b_value = c_value; + c_value.add_assign(&a_value); + + c = cs.alloc(|| { + Ok(c_value) + })?; + + cs.enforce_zero_3((a, b, c), (one, one, negative_one))?; + } + + Ok(()) + } + } + + #[test] + fn test_bench_fibonacci_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + use crate::plonk::commitments::transparent::*; + use crate::plonk::tester::*; + + use std::time::Instant; + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let meta_large = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let circuit = BenchmarkCircuit:: { + num_steps: 1_000_000, + _marker: PhantomData + }; + + { + let mut tester = TestingAssembly::::new(); + + circuit.synthesize(&mut tester).expect("must synthesize"); + + let satisfied = tester.is_satisfied(); + + assert!(satisfied); + + println!("Circuit is satisfied"); + } + + println!("Start setup"); + let start = Instant::now(); + let (setup, aux) = setup::(&circuit, meta).unwrap(); + println!("Setup taken {:?}", start.elapsed()); + + println!("Using circuit with N = {}", setup.n); + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + println!("Start proving"); + let start = Instant::now(); + let proof = prove_nonhomomorphic::, _>(&circuit, &setup, &aux, meta.clone(), meta_large.clone()).unwrap(); + println!("Proof taken {:?}", start.elapsed()); + + println!("Start verifying"); + let start = Instant::now(); + let valid = verify_nonhomomorphic::>(&setup, &proof, meta, meta_large).unwrap(); + println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + assert!(valid); + } + + // #[test] + // fn test_bench_keccak_for_fibonacci_circuit() { + // use crate::pairing::bn256::{Bn256, Fr}; + // use crate::plonk::utils::*; + // use crate::plonk::commitments::transparent::fri::*; + // use crate::plonk::commitments::transparent::iop::*; + // use crate::plonk::commitments::transcript::*; + // use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + // use crate::plonk::commitments::transparent::iop::keccak_trivial_iop::*; + // use crate::plonk::commitments::*; + // use crate::plonk::commitments::transparent::*; + + // use std::time::Instant; + + // type Iop = TrivialKeccakIOP; + // type Fri = NaiveFriIop; + // type Committer = StatelessTransparentCommitter>; + + // let meta = TransparentCommitterParameters { + // lde_factor: 16, + // num_queries: 10, + // output_coeffs_at_degree_plus_one: 16, + // }; + + // let meta_large = TransparentCommitterParameters { + // lde_factor: 16, + // num_queries: 10, + // output_coeffs_at_degree_plus_one: 16, + // }; + + // let circuit = BenchmarkCircuit:: { + // num_steps: 1_000_000, + // _marker: PhantomData + // }; + + // println!("Start setup"); + // let start = Instant::now(); + // let setup = setup::(&circuit, meta).unwrap(); + // println!("Setup taken {:?}", start.elapsed()); + + // println!("Using circuit with N = {}", setup.n); + + // let meta = TransparentCommitterParameters { + // lde_factor: 16, + // num_queries: 10, + // output_coeffs_at_degree_plus_one: 16, + // }; + + // println!("Start proving"); + // let start = Instant::now(); + // let proof = prove_nonhomomorphic::, _>(&circuit, meta, meta_large).unwrap(); + // println!("Proof taken {:?}", start.elapsed()); + + // let meta = TransparentCommitterParameters { + // lde_factor: 16, + // num_queries: 10, + // output_coeffs_at_degree_plus_one: 16, + // }; + + // let meta_large = TransparentCommitterParameters { + // lde_factor: 16, + // num_queries: 10, + // output_coeffs_at_degree_plus_one: 16, + // }; + + // println!("Start verifying"); + // let start = Instant::now(); + // let valid = verify_nonhomomorphic::>(&setup, &proof, meta, meta_large).unwrap(); + // println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + // assert!(!valid); + // } + + #[test] + fn test_bench_homomorphic_plonk() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::pairing::bn256::Bn256; + use num_cpus; + use crate::pairing::ff::ScalarEngine; + use crate::pairing::CurveProjective; + use crate::multiexp::*; + use crate::worker::*; + use crate::source::*; + use std::sync::Arc; + use futures::{Future}; + + const SAMPLES: usize = 1 << 20; + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let v = (0..SAMPLES).map(|_| ::Fr::rand(rng).into_repr()).collect::>(); + let g = (0..SAMPLES).map(|_| ::G1::rand(rng).into_affine()).collect::>(); + + println!("Done generating test points and scalars"); + + let pool = Worker::new(); + let start = std::time::Instant::now(); + + let _sparse = multiexp( + &pool, + (Arc::new(g), 0), + FullDensity, + Arc::new(v) + ).wait().unwrap(); + + let per_one_poly = start.elapsed().as_micros(); + // a, b, c, z_1, z_2, t, opening at z (of length t), opening at z*omega(of length a) + let total_expected_plonk = per_one_poly * (5 + 1 + 3 + 3 + 1); + println!("{} ms for expected plonk with ~ {} gates", total_expected_plonk/1000u128, SAMPLES); + } + + #[test] + fn test_bench_transparent_engine() { + use crate::plonk::transparent_engine::proth_engine::*; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + use crate::plonk::commitments::transparent::*; + use crate::plonk::tester::*; + + use std::time::Instant; + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let mut negative_one = Fr::one(); + negative_one.negate(); + println!("-1 = {}", negative_one); + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let meta_large = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let circuit = BenchmarkCircuit:: { + num_steps: 1_000_000, + _marker: PhantomData + }; + + { + let mut tester = TestingAssembly::::new(); + + circuit.synthesize(&mut tester).expect("must synthesize"); + + let satisfied = tester.is_satisfied(); + + assert!(satisfied); + + println!("Circuit is satisfied"); + } + + println!("Start setup"); + let start = Instant::now(); + let (setup, aux) = setup::(&circuit, meta).unwrap(); + println!("Setup taken {:?}", start.elapsed()); + + println!("Using circuit with N = {}", setup.n); + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + println!("Start proving"); + let start = Instant::now(); + let proof = prove_nonhomomorphic::, _>(&circuit, &setup, &aux, meta.clone(), meta_large.clone()).unwrap(); + println!("Proof taken {:?}", start.elapsed()); + + println!("Start verifying"); + let start = Instant::now(); + let valid = verify_nonhomomorphic::>(&setup, &proof, meta, meta_large).unwrap(); + println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + assert!(valid); + } + + #[test] + fn test_bench_chunked_proof_on_transparent_engine() { + use crate::plonk::transparent_engine::proth_engine::*; + use crate::plonk::utils::*; + use crate::plonk::commitments::transparent::fri::*; + use crate::plonk::commitments::transparent::iop::*; + use crate::plonk::commitments::transcript::*; + use crate::plonk::commitments::transparent::fri::naive_fri::naive_fri::*; + use crate::plonk::commitments::transparent::iop::blake2s_trivial_iop::*; + use crate::plonk::commitments::*; + use crate::plonk::commitments::transparent::*; + use crate::plonk::tester::*; + + use std::time::Instant; + + type Iop = TrivialBlake2sIOP; + type Fri = NaiveFriIop; + type Committer = StatelessTransparentCommitter>; + + let mut negative_one = Fr::one(); + negative_one.negate(); + println!("-1 = {}", negative_one); + + let meta = TransparentCommitterParameters { + lde_factor: 16, + num_queries: 10, + output_coeffs_at_degree_plus_one: 16, + fri_params: () + }; + + let circuit = BenchmarkCircuit:: { + num_steps: 1_000_000, + _marker: PhantomData + }; + + { + let mut tester = TestingAssembly::::new(); + + circuit.synthesize(&mut tester).expect("must synthesize"); + + let satisfied = tester.is_satisfied(); + + assert!(satisfied); + + println!("Circuit is satisfied"); + } + + println!("Start setup"); + let start = Instant::now(); + let (setup, aux) = setup::(&circuit, meta.clone()).unwrap(); + println!("Setup taken {:?}", start.elapsed()); + + println!("Using circuit with N = {}", setup.n); + + println!("Start proving"); + let start = Instant::now(); + let proof = prove_nonhomomorphic_chunked::, _>(&circuit, &aux, meta.clone()).unwrap(); + println!("Proof taken {:?}", start.elapsed()); + + println!("Start verifying"); + let start = Instant::now(); + let valid = verify_nonhomomorphic_chunked::>(&setup, &proof, meta).unwrap(); + println!("Verification with unnecessary precomputation taken {:?}", start.elapsed()); + + assert!(valid); + } + + #[test] + fn test_poly_eval_correctness() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::pairing::bn256::Fr; + use num_cpus; + use crate::pairing::ff::ScalarEngine; + use crate::pairing::CurveProjective; + use crate::multiexp::*; + use crate::worker::*; + use crate::source::*; + use std::sync::Arc; + use futures::{Future}; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let poly_sizes = vec![1, 10, 100, 1000, 10_000, 1_000_000]; + + let x: Fr = rng.gen(); + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + let mut point = Fr::one(); + let mut result = Fr::zero(); + for c in coeffs.iter() { + let mut tmp = point; + tmp.mul_assign(&c); + result.add_assign(&tmp); + + point.mul_assign(&x); + } + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let eval_result = poly.evaluate_at(&worker, x); + assert!(eval_result == result, "failed for size {}", poly_size); + } + } + + #[test] + fn test_poly_grand_product_correctness() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::pairing::bn256::Fr; + use num_cpus; + use crate::pairing::ff::ScalarEngine; + use crate::pairing::CurveProjective; + use crate::multiexp::*; + use crate::worker::*; + use crate::source::*; + use std::sync::Arc; + use futures::{Future}; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let poly_sizes = vec![1, 10, 100, 1000, 10_000, 1_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).filter(|el| !el.is_zero()).collect::>(); + let poly = Polynomial::::from_values_unpadded(coeffs).unwrap(); + let palallel_result = poly.calculate_grand_product(&worker).unwrap(); + let serial_result = poly.calculate_grand_product_serial().unwrap(); + + if palallel_result != serial_result { + for (i, (c0, c1)) in palallel_result.as_ref().iter() + .zip(serial_result.as_ref().iter()) + .enumerate() + { + assert!(c0 == c1, "failed at value number {} for size {}", i, poly_size); + } + } + } + } + + #[test] + fn test_bench_lde() { + use rand::{XorShiftRng, SeedableRng, Rand, Rng}; + use crate::pairing::bn256::Fr; + use crate::pairing::ff::ScalarEngine; + use crate::pairing::CurveProjective; + use std::time::Instant; + use crate::worker::*; + use crate::plonk::commitments::transparent::utils::*; + + let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]); + + let poly_sizes = vec![1, 10, 100, 1000, 10_000, 1_000_000, 2_000_000]; + + let worker = Worker::new(); + + for poly_size in poly_sizes.into_iter() { + let coeffs = (0..poly_size).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let _eval_result = poly.lde(&worker, 16); + println!("LDE with factor 16 for size {} taken {:?}", poly_size, start.elapsed()); + + let coeffs = (0..(16*poly_size)).map(|_| Fr::rand(rng)).collect::>(); + + let poly = Polynomial::::from_coeffs(coeffs).unwrap(); + let start = Instant::now(); + let eval_result = poly.clone().fft(&worker); + println!("FFT of the same size taken {:?}", start.elapsed()); + + if log2_floor(poly.size()) % 2 == 0 { + let log_n = log2_floor(poly.size()); + let omega = poly.omega; + let mut coeffs = poly.into_coeffs(); + let start = Instant::now(); + crate::plonk::fft::radix_4::best_fft(&mut coeffs, &worker, &omega, log_n as u32); + println!("Radix-4 FFT of the same size taken {:?}", start.elapsed()); + let to_compare = eval_result.into_coeffs(); + assert!(to_compare == coeffs); + } + + + } + } +} \ No newline at end of file diff --git a/src/precomputations/mod.rs b/src/precomputations/mod.rs new file mode 100644 index 000000000..e69de29bb diff --git a/src/precomputations/natural_ordering.rs b/src/precomputations/natural_ordering.rs new file mode 100644 index 000000000..bc4ad8964 --- /dev/null +++ b/src/precomputations/natural_ordering.rs @@ -0,0 +1,103 @@ +use crate::pairing::ff::PrimeField; + +use crate::plonk::domains::Domain; +use crate::worker::Worker; +use crate::plonk::fft::distribute_powers; +use crate::plonk::fft::with_precomputation::FftPrecomputations; + +pub struct PrecomputedOmegas { + pub omegas: Vec, + pub coset: Vec, + pub omegas_inv: Vec, + domain_size: usize +} + +impl PrecomputedOmegas { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + + let omega = domain.generator; + let omega_inv = domain.generator.inverse().expect("must exist"); + + let mut omegas = vec![F::zero(); domain_size]; + let mut omegas_inv = vec![F::zero(); domain_size]; + + worker.scope(omegas.len(), |scope, chunk| { + for (i, v) in omegas.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega); + } + }); + } + }); + + worker.scope(omegas_inv.len(), |scope, chunk| { + for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega_inv.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega_inv); + } + }); + } + }); + + let mut coset = omegas.clone(); + let mult_generator = F::multiplicative_generator(); + + worker.scope(coset.len(), |scope, chunk| { + for v in coset.chunks_mut(chunk) { + scope.spawn(move |_| { + for v in v.iter_mut() { + v.mul_assign(&mult_generator); + } + }); + } + }); + + PrecomputedOmegas{ + omegas, + coset, + omegas_inv, + domain_size + } + } +} + +pub struct PrecomputedInvOmegasHalfSize { + pub omegas_inv: Vec, + domain_size: usize +} + +impl PrecomputedInvOmegasHalfSize { + pub fn new_for_domain(domain: &Domain, worker: &Worker) -> Self { + let domain_size = domain.size as usize; + let precomputation_size = domain_size/2; + + let omega = domain.generator; + let omega_inv = omega.inverse().expect("must exist"); + + let mut omegas_inv = vec![F::zero(); precomputation_size]; + + worker.scope(omegas_inv.len(), |scope, chunk| { + for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() { + scope.spawn(move |_| { + let mut u = omega_inv.pow(&[(i * chunk) as u64]); + for v in v.iter_mut() { + *v = u; + u.mul_assign(&omega_inv); + } + }); + } + }); + + PrecomputedInvOmegas{ + omegas_inv, + domain_size + } + } +} \ No newline at end of file diff --git a/src/prefetch.rs b/src/prefetch.rs new file mode 100644 index 000000000..74c8fa3dd --- /dev/null +++ b/src/prefetch.rs @@ -0,0 +1,122 @@ +cfg_if! { + if #[cfg( + all( + any(target_arch = "x86", target_arch = "x86_64"), + any(target_feature = "sse", target_feature = "sse4.1", target_feature = "avx", target_feature = "avx2") + ) + )] { + #[inline(always)] + pub(crate) fn prefetch_l1_pointer(pointer: *const T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(pointer as *const i8, core::arch::x86_64::_MM_HINT_T0); + #[cfg(target_arch = "x86")] + _mm_prefetch(pointer as *const i8, core::arch::x86::_MM_HINT_T0); + } + } + + #[inline(always)] + pub(crate) fn prefetch_l2_pointer(pointer: *const T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(pointer as *const i8, core::arch::x86_64::_MM_HINT_T1); + #[cfg(target_arch = "x86")] + _mm_prefetch(pointer as *const i8, core::arch::x86::_MM_HINT_T1); + } + } + + #[inline(always)] + pub(crate) fn prefetch_l3_pointer(pointer: *const T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(pointer as *const i8, core::arch::x86_64::_MM_HINT_T2); + #[cfg(target_arch = "x86")] + _mm_prefetch(pointer as *const i8, core::arch::x86::_MM_HINT_T2); + } + } + + #[inline(always)] + pub(crate) fn prefetch_l1(reference: &T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86_64::_MM_HINT_T0); + #[cfg(target_arch = "x86")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86::_MM_HINT_T0); + } + } + + #[inline(always)] + pub(crate) fn prefetch_l2(reference: &T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86_64::_MM_HINT_T1); + #[cfg(target_arch = "x86")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86::_MM_HINT_T1); + } + } + + #[inline(always)] + pub(crate) fn prefetch_l3(reference: &T) { + #[cfg(target_arch = "x86")] + use std::arch::x86::_mm_prefetch; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::_mm_prefetch; + + + unsafe { + #[cfg(target_arch = "x86_64")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86_64::_MM_HINT_T2); + #[cfg(target_arch = "x86")] + _mm_prefetch(reference as *const T as *const i8, core::arch::x86::_MM_HINT_T2); + } + } + } else { + #[inline(always)] + pub(crate) fn prefetch_l1_pointer(pointer: *const T) {} + + #[inline(always)] + pub(crate) fn prefetch_l2_pointer(pointer: *const T) {} + + #[inline(always)] + pub(crate) fn prefetch_l3_pointer(pointer: *const T) {} + + #[inline(always)] + pub(crate) fn prefetch_l1(reference: &T) {} + + #[inline(always)] + pub(crate) fn prefetch_l2(reference: &T) {} + + #[inline(always)] + pub(crate) fn prefetch_l3(reference: &T) {} + } +} diff --git a/src/singlecore.rs b/src/singlecore.rs index 8acb4b5bc..6708bd9fd 100644 --- a/src/singlecore.rs +++ b/src/singlecore.rs @@ -13,7 +13,7 @@ use self::futures::executor::{block_on}; #[derive(Clone)] pub struct Worker { - cpus: usize, + pub(crate) cpus: usize, } impl Worker { @@ -68,6 +68,29 @@ impl Worker { f(&scope, chunk_size) } + + pub fn get_chunk_size( + &self, + elements: usize + ) -> usize { + elements + } + + pub fn get_num_spawned_threads( + &self, + elements: usize + ) -> usize { + 1 + } + + pub fn chunk_size_for_num_spawned_threads(elements: usize, num_threads: usize) -> usize { + assert!(elements >= num_threads, "received {} elements to spawn {} threads", elements, num_threads); + if elements % num_threads == 0 { + elements / num_threads + } else { + elements / num_threads + 1 + } + } } #[derive(Clone)] pub struct Scope<'a> { @@ -119,7 +142,7 @@ impl WorkerFuture { #[test] fn test_trivial_singlecore_spawning() { - use self::futures_new::executor::block_on; + use self::futures::executor::block_on; fn long_fn() -> Result { let mut i: usize = 1; diff --git a/src/sonic/helped/generator.rs b/src/sonic/helped/generator.rs index 6ef9efca4..b2e33574c 100644 --- a/src/sonic/helped/generator.rs +++ b/src/sonic/helped/generator.rs @@ -32,7 +32,7 @@ use crate::domain::{ Scalar }; -use crate::multicore::{ +use crate::worker::{ Worker }; diff --git a/src/sonic/util.rs b/src/sonic/util.rs index a91cfa87e..3518a14cc 100644 --- a/src/sonic/util.rs +++ b/src/sonic/util.rs @@ -154,7 +154,7 @@ pub fn evaluate_at_consequitive_powers<'a, F: Field> ( base: F ) -> F { - use crate::multicore::Worker; + use crate::worker::Worker; let (s, r) = unbounded(); @@ -205,7 +205,7 @@ pub fn mut_evaluate_at_consequitive_powers<'a, F: Field> ( base: F ) -> F { - use crate::multicore::Worker; + use crate::worker::Worker; let (s, r) = unbounded(); @@ -257,7 +257,7 @@ pub fn mut_distribute_consequitive_powers<'a, F: Field> ( base: F ) { - use crate::multicore::Worker; + use crate::worker::Worker; let worker = Worker::new(); @@ -291,7 +291,7 @@ pub fn mut_distribute_consequitive_powers<'a, F: Field> ( // IB::IntoIter: ExactSizeIterator + Clone, // IS::IntoIter: ExactSizeIterator, // { -// use crate::multicore::Worker; +// use crate::worker::Worker; // use crate::multiexp::dense_multiexp; // use std::time::Instant; @@ -334,7 +334,7 @@ where IB::IntoIter: ExactSizeIterator + Clone, IS::IntoIter: ExactSizeIterator, { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::multiexp::multiexp; use crate::source::FullDensity; use futures::Future; @@ -630,7 +630,7 @@ fn laurent_division() { pub fn multiply_polynomials(a: Vec, b: Vec) -> Vec { let result_len = a.len() + b.len() - 1; - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{EvaluationDomain, Scalar}; let worker = Worker::new(); @@ -658,7 +658,7 @@ pub fn multiply_polynomials(a: Vec, b: Vec) -> Vec(a: Vec, b: Vec) -> Vec { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{best_fft, Scalar}; use crate::group::Group; @@ -791,7 +791,7 @@ pub fn multiply_polynomials_serial(mut a: Vec, mut b: Vec(a: &mut [F], b: &[F]) { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{EvaluationDomain, Scalar}; let worker = Worker::new(); @@ -812,7 +812,7 @@ pub fn add_polynomials(a: &mut [F], b: &[F]) { // subtract polynomails in coefficient form pub fn sub_polynomials(a: &mut [F], b: &[F]) { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{EvaluationDomain, Scalar}; let worker = Worker::new(); @@ -833,7 +833,7 @@ pub fn sub_polynomials(a: &mut [F], b: &[F]) { // multiply coefficients of the polynomial by the scalar pub fn mul_polynomial_by_scalar(a: &mut [F], b: F) { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{EvaluationDomain, Scalar}; let worker = Worker::new(); @@ -853,7 +853,7 @@ pub fn mul_polynomial_by_scalar(a: &mut [F], b: F) { // elementwise add coeffs of one polynomial with coeffs of other, that are // first multiplied by a scalar pub fn mul_add_polynomials(a: &mut [F], b: &[F], c: F) { - use crate::multicore::Worker; + use crate::worker::Worker; use crate::domain::{EvaluationDomain, Scalar}; let worker = Worker::new(); diff --git a/src/source.rs b/src/source.rs index ad4c0652a..7009d1c86 100644 --- a/src/source.rs +++ b/src/source.rs @@ -22,6 +22,7 @@ pub trait SourceBuilder: Send + Sync + 'static + Clone { type Source: Source; fn new(self) -> Self::Source; + fn get(self) -> (Arc>, usize); } /// A source of bases, like an iterator. @@ -39,6 +40,10 @@ impl SourceBuilder for (Arc>, usize) { fn new(self) -> (Arc>, usize) { (self.0.clone(), self.1) } + + fn get(self) -> (Arc>, usize) { + (self.0.clone(), self.1) + } } impl Source for (Arc>, usize) { @@ -100,7 +105,7 @@ impl<'a> QueryDensity for &'a FullDensity { #[derive(Clone)] pub struct DensityTracker { - bv: BitVec, + pub(crate) bv: BitVec, total_density: usize } @@ -128,6 +133,12 @@ impl DensityTracker { self.bv.push(false); } + pub fn pad(&mut self, to_size: usize) { + assert!(to_size >= self.bv.len()); + let padding = to_size - self.bv.len(); + self.bv.extend(BitVec::from_elem(padding, false)); + } + pub fn inc(&mut self, idx: usize) { if !self.bv.get(idx).unwrap() { self.bv.set(idx, true); @@ -138,4 +149,35 @@ impl DensityTracker { pub fn get_total_density(&self) -> usize { self.total_density } +} + +#[derive(Clone)] +pub struct DensityTrackerersChain { + pub(crate) tracker_0: DensityTracker, + pub(crate) tracker_1: DensityTracker, + total_density: usize +} + +impl DensityTrackerersChain { + pub fn new(tracker_0: DensityTracker, tracker_1: DensityTracker) -> Self { + let total_density = tracker_0.total_density + tracker_1.total_density; + + Self { + tracker_0, + tracker_1, + total_density + } + } +} + +impl<'a> QueryDensity for &'a DensityTrackerersChain { + type Iter = std::iter::Chain, bit_vec::Iter<'a>>; + + fn iter(self) -> Self::Iter { + self.tracker_0.bv.iter().chain(&self.tracker_1.bv) + } + + fn get_query_size(self) -> Option { + Some(self.tracker_0.bv.len() + self.tracker_1.bv.len()) + } } \ No newline at end of file diff --git a/src/tests/dummy_engine.rs b/src/tests/dummy_engine.rs index 7b0954a5b..379f0a6a8 100644 --- a/src/tests/dummy_engine.rs +++ b/src/tests/dummy_engine.rs @@ -21,10 +21,11 @@ use std::cmp::Ordering; use std::fmt; use rand::{Rand, Rng}; use std::num::Wrapping; +use rand_core::RngCore; const MODULUS_R: Wrapping = Wrapping(64513); -#[derive(Copy, Clone, Debug, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] pub struct Fr(Wrapping); impl fmt::Display for Fr { @@ -40,6 +41,10 @@ impl Rand for Fr { } impl Field for Fr { + // fn random(rng: &mut R) -> Self { + // unimplemented!() + // } + fn zero() -> Self { Fr(Wrapping(0)) } @@ -160,7 +165,7 @@ impl SqrtField for Fr { } } -#[derive(Copy, Clone, Debug, Eq, PartialEq)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] pub struct FrRepr([u64; 1]); impl Ord for FrRepr { @@ -294,7 +299,7 @@ impl PrimeField for Fr { } } -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct DummyEngine; impl ScalarEngine for DummyEngine { @@ -396,6 +401,10 @@ impl CurveProjective for Fr { fn recommended_wnaf_for_num_scalars(_: usize) -> usize { 3 } + + // fn random(rng: &mut R) -> Self { + // unimplemented!() + // } } #[derive(Copy, Clone)] @@ -485,4 +494,28 @@ impl CurveAffine for Fr { fn into_projective(&self) -> Self::Projective { *self } + + fn as_xy(&self) -> (&Self::Base, &Self::Base) { + (&self, &self) + } + + fn into_xy_unchecked(self) -> (Self::Base, Self::Base) { + (::zero(), ::zero()) + } + + fn from_xy_unchecked(_x: Self::Base, _y: Self::Base) -> Self { + ::zero() + } + + fn from_xy_checked(_x: Self::Base, _y: Self::Base) -> Result { + Ok(::zero()) + } + + fn a_coeff() -> ::Base { + ::zero() + } + + fn b_coeff() -> ::Base { + ::zero() + } } diff --git a/src/tests/mod.rs b/src/tests/mod.rs index 843d2cf87..bf990484c 100644 --- a/src/tests/mod.rs +++ b/src/tests/mod.rs @@ -18,6 +18,7 @@ use crate::{ SynthesisError }; +#[derive(Clone)] pub(crate) struct XORDemo { pub(crate) a: Option, pub(crate) b: Option, @@ -91,3 +92,111 @@ impl Circuit for XORDemo { } } +#[derive(Clone)] +pub(crate) struct TranspilationTester { + pub(crate) a: Option, + pub(crate) b: Option, +} + +impl Circuit for TranspilationTester { + fn synthesize>( + self, + cs: &mut CS + ) -> Result<(), SynthesisError> + { + let a_var = cs.alloc(|| "a", || { + if let Some(a_value) = self.a { + Ok(a_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "a is zero", + |lc| lc + a_var, + |lc| lc + CS::one(), + |lc| lc + ); + + let b_var = cs.alloc(|| "b", || { + if let Some(b_value) = self.b { + Ok(b_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "b is one", + |lc| lc + b_var, + |lc| lc + CS::one(), + |lc| lc + CS::one() + ); + + let c_var = cs.alloc_input(|| "c", || { + if let Some(a_value) = self.a { + Ok(a_value) + } else { + Err(SynthesisError::AssignmentMissing) + } + })?; + + cs.enforce( + || "a is equal to c", + |lc| lc + a_var, + |lc| lc + CS::one(), + |lc| lc + c_var + ); + + Ok(()) + } +} + +#[cfg(feature = "plonk")] +#[test] +fn transpile_xor() { + use crate::pairing::bn256::Bn256; + use crate::plonk::adaptor::alternative::Transpiler; + + let c = XORDemo:: { + a: None, + b: None, + _marker: PhantomData + }; + + let mut transpiler = Transpiler::new(); + + c.synthesize(&mut transpiler).unwrap(); +} + +#[cfg(feature = "plonk")] +#[test] +fn transpile_test_circuit() { + use crate::pairing::bn256::{Bn256, Fr}; + use crate::plonk::adaptor::alternative::*; + use crate::plonk::plonk::prover::*; + + let c = TranspilationTester:: { + a: Some(Fr::zero()), + b: Some(Fr::one()), + }; + + let mut transpiler = Transpiler::new(); + + c.clone().synthesize(&mut transpiler).unwrap(); + + let hints = transpiler.into_hints(); + + let adapted_curcuit = AdaptorCircuit::new(c.clone(), &hints); + + use crate::plonk::cs::Circuit as PlonkCircuit; + + let mut prover = ProvingAssembly::::new(); + adapted_curcuit.synthesize(&mut prover).unwrap(); + prover.finalize(); + + println!("Checking if is satisfied"); + assert!(prover.is_satisfied()); +} + diff --git a/tests/mimc.rs b/tests/mimc.rs index 623c1ee4b..4936adb9a 100644 --- a/tests/mimc.rs +++ b/tests/mimc.rs @@ -38,9 +38,66 @@ use bellman_ce::groth16::{ verify_proof, }; -const MIMC_ROUNDS: usize = 322; +// const MIMC_ROUNDS: usize = 322; -// const MIMC_ROUNDS: usize = 1000000; +const MIMC_ROUNDS: usize = 1000000; + + +#[cfg(feature = "marlin")] +#[test] +fn test_bench_marlin_prover() { + use bellman_ce::pairing::bn256::{Bn256}; + use bellman_ce::marlin::prover::test_over_engine_and_circuit_with_proving_key; + { + // This may not be cryptographically safe, use + // `OsRng` (for example) in production software. + let rng = &mut thread_rng(); + + // Generate the MiMC round constants + let constants = (0..MIMC_ROUNDS).map(|_| rng.gen()).collect::>(); + + let xl = rng.gen(); + let xr = rng.gen(); + + // Create an instance of our circuit (with the + // witness) + let circuit = MiMCDemo { + xl: Some(xl), + xr: Some(xr), + constants: &constants + }; + + test_over_engine_and_circuit_with_proving_key::(circuit, format!("./marlin_mimc_{}", MIMC_ROUNDS)); + } +} + +#[cfg(feature = "marlin")] +#[test] +fn test_create_marlin_proving_key() { + use bellman_ce::pairing::bn256::{Bn256}; + use bellman_ce::marlin::prover::create_test_keys; + { + // This may not be cryptographically safe, use + // `OsRng` (for example) in production software. + let rng = &mut thread_rng(); + + // Generate the MiMC round constants + let constants = (0..MIMC_ROUNDS).map(|_| rng.gen()).collect::>(); + + let xl = rng.gen(); + let xr = rng.gen(); + + // Create an instance of our circuit (with the + // witness) + let circuit = MiMCDemo { + xl: Some(xl), + xr: Some(xr), + constants: &constants + }; + + create_test_keys::(circuit, format!("./marlin_mimc_{}", MIMC_ROUNDS)); + } +} /// This is an implementation of MiMC, specifically a /// variant named `LongsightF322p3` for BLS12-381. @@ -284,7 +341,8 @@ fn test_mimc_bn256() { println!("Creating proofs..."); // Let's benchmark stuff! - const SAMPLES: u32 = 50; + // const SAMPLES: u32 = 50; + const SAMPLES: u32 = 1; let mut total_proving = Duration::new(0, 0); let mut total_verifying = Duration::new(0, 0); @@ -339,3 +397,26 @@ fn test_mimc_bn256() { println!("Average proving time: {:?} seconds", proving_avg); println!("Average verifying time: {:?} seconds", verifying_avg); } + + +#[cfg(feature = "plonk")] +#[test] +fn test_mimc_transpilation_into_plonk() { + use bellman_ce::plonk::adaptor::alternative::Transpiler; + // This may not be cryptographically safe, use + // `OsRng` (for example) in production software. + let rng = &mut thread_rng(); + + // Generate the MiMC round constants + let constants = (0..MIMC_ROUNDS).map(|_| rng.gen()).collect::>(); + + let c = MiMCDemo:: { + xl: None, + xr: None, + constants: &constants + }; + + let mut transpiler = Transpiler::new(); + + c.synthesize(&mut transpiler).unwrap(); +}